Initial decoder implementation.

With minor contributions from:
 - Jean-Baptiste Kempf <jb@videolan.org>
 - Marvin Scholz <epirat07@gmail.com>
 - Hugo Beauzée-Luyssen <hugo@videolan.org>

64 files changed, 28387 insertions, 0 deletions

diff --git a/src/cdef.c b/src/cdef.c
new file mode 100644
index 0000000..98736e9
--- /dev/null
+++ b/src/cdef.c
@@ -0,0 +1,271 @@
+/*
+ * Copyright © 2018, VideoLAN and dav1d authors
+ * Copyright © 2018, Two Orioles, LLC
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright notice, this
+ *    list of conditions and the following disclaimer.
+ *
+ * 2. Redistributions in binary form must reproduce the above copyright notice,
+ *    this list of conditions and the following disclaimer in the documentation
+ *    and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
+ * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#include "config.h"
+
+#include <stdlib.h>
+
+#include "common/intops.h"
+
+#include "src/cdef.h"
+
+static const int8_t cdef_directions[8 /* dir */][2 /* pass */][2 /* y, x */] = {
+    { { -1, 1 }, { -2,  2 } },
+    { {  0, 1 }, { -1,  2 } },
+    { {  0, 1 }, {  0,  2 } },
+    { {  0, 1 }, {  1,  2 } },
+    { {  1, 1 }, {  2,  2 } },
+    { {  1, 0 }, {  2,  1 } },
+    { {  1, 0 }, {  2,  0 } },
+    { {  1, 0 }, {  2, -1 } }
+};
+static const uint8_t cdef_pri_taps[2][2] = { { 4, 2 }, { 3, 3 } };
+static const uint8_t cdef_sec_taps[2][2] = { { 2, 1 }, { 2, 1 } };
+
+static inline int constrain(const int diff, const int threshold,
+                            const int damping)
+{
+    if (!threshold) return 0;
+    const int shift = imax(0, damping - ulog2(threshold));
+    return apply_sign(imin(abs(diff), imax(0, threshold - (abs(diff) >> shift))),
+                      diff);
+}
+
+/*
+ * <code partially copied from libaom>
+ */
+
+#define CDEF_VERY_LARGE (30000)
+
+static void fill(uint16_t *tmp, const ptrdiff_t stride,
+                 const int w, const int h)
+{
+    for (int y = 0; y < h; y++) {
+        for (int x = 0; x < w; x++)
+            tmp[x] = CDEF_VERY_LARGE;
+        tmp += stride;
+    }
+}
+
+/* Smooth in the direction detected. */
+static void cdef_filter_block_c(pixel *const dst, const ptrdiff_t dst_stride,
+                                /*const*/ pixel *const top[2],
+                                const int w, const int h, const int pri_strength,
+                                const int sec_strength, const int dir,
+                                const int damping, const enum CdefEdgeFlags edges)
+{
+    const ptrdiff_t tmp_stride = w + 4;
+    uint16_t tmp[tmp_stride * (h + 4)];
+    const uint8_t *const pri_taps = cdef_pri_taps[(pri_strength >> (BITDEPTH - 8)) & 1];
+    const uint8_t *const sec_taps = cdef_sec_taps[(pri_strength >> (BITDEPTH - 8)) & 1];
+
+    // fill extended input buffer
+    int x_start = -2, x_end = w + 2, y_start = -2, y_end = h + 2;
+    if (!(edges & HAVE_TOP)) {
+        fill(tmp, tmp_stride, w + 4, 2);
+        y_start = 0;
+    }
+    if (!(edges & HAVE_BOTTOM)) {
+        fill(tmp + (h + 2) * tmp_stride, tmp_stride, w + 4, 2);
+        y_end -= 2;
+    }
+    if (!(edges & HAVE_LEFT)) {
+        fill(tmp + (2 + y_start) * tmp_stride, tmp_stride, 2, y_end - y_start);
+        x_start = 0;
+    }
+    if (!(edges & HAVE_RIGHT)) {
+        fill(tmp + (2 + y_start) * tmp_stride + w + 2, tmp_stride,
+             2, y_end - y_start);
+        x_end -= 2;
+    }
+    for (int y = y_start; y < 0; y++)
+        for (int x = x_start; x < x_end; x++)
+            tmp[(y + 2) * tmp_stride + (x + 2)] = top[y & 1][x];
+    for (int y = 0; y < y_end; y++)
+        for (int x = x_start; x < x_end; x++)
+            tmp[(y + 2) * tmp_stride + (x + 2)] = dst[y * PXSTRIDE(dst_stride) + x];
+
+    // run actual filter
+    for (int y = 0; y < h; y++) {
+        for (int x = 0; x < w; x++) {
+            int sum = 0;
+            const int px = dst[y * PXSTRIDE(dst_stride) + x];
+            int max = px, min = px;
+            for (int k = 0; k < 2; k++) {
+#define extpx(y, x) tmp[((y) + 2) * tmp_stride + ((x) + 2)]
+                const int8_t *const off1 = cdef_directions[dir][k];
+                const int p0 = extpx(y + off1[0], x + off1[1]);
+                const int p1 = extpx(y - off1[0], x - off1[1]);
+                sum += pri_taps[k] * constrain(p0 - px, pri_strength, damping);
+                sum += pri_taps[k] * constrain(p1 - px, pri_strength, damping);
+                if (p0 != CDEF_VERY_LARGE) max = imax(p0, max);
+                if (p1 != CDEF_VERY_LARGE) max = imax(p1, max);
+                min = imin(p0, min);
+                min = imin(p1, min);
+                const int8_t *const off2 = cdef_directions[(dir + 2) & 7][k];
+                const int s0 = extpx(y + off2[0], x + off2[1]);
+                const int s1 = extpx(y - off2[0], x - off2[1]);
+                const int8_t *const off3 = cdef_directions[(dir + 6) & 7][k];
+                const int s2 = extpx(y + off3[0], x + off3[1]);
+                const int s3 = extpx(y - off3[0], x - off3[1]);
+#undef extpx
+                if (s0 != CDEF_VERY_LARGE) max = imax(s0, max);
+                if (s1 != CDEF_VERY_LARGE) max = imax(s1, max);
+                if (s2 != CDEF_VERY_LARGE) max = imax(s2, max);
+                if (s3 != CDEF_VERY_LARGE) max = imax(s3, max);
+                min = imin(s0, min);
+                min = imin(s1, min);
+                min = imin(s2, min);
+                min = imin(s3, min);
+                sum += sec_taps[k] * constrain(s0 - px, sec_strength, damping);
+                sum += sec_taps[k] * constrain(s1 - px, sec_strength, damping);
+                sum += sec_taps[k] * constrain(s2 - px, sec_strength, damping);
+                sum += sec_taps[k] * constrain(s3 - px, sec_strength, damping);
+            }
+            dst[y * PXSTRIDE(dst_stride) + x] =
+                iclip(px + ((8 + sum - (sum < 0)) >> 4), min, max);
+        }
+    }
+}
+
+/*
+ * </code partially copied from libaom>
+ */
+
+#define cdef_fn(w, h) \
+static void cdef_filter_block_##w##x##h##_c(pixel *const dst, \
+                                            const ptrdiff_t stride, \
+                                            /*const*/ pixel *const top[2], \
+                                            const int pri_strength, \
+                                            const int sec_strength, \
+                                            const int dir, \
+                                            const int damping, \
+                                            const enum CdefEdgeFlags edges) \
+{ \
+    cdef_filter_block_c(dst, stride, top, w, h, pri_strength, sec_strength, \
+                        dir, damping, edges); \
+}
+
+cdef_fn(4, 4);
+cdef_fn(4, 8);
+cdef_fn(8, 8);
+
+/*
+ * <code copied from libaom>
+ */
+
+/* Detect direction. 0 means 45-degree up-right, 2 is horizontal, and so on.
+   The search minimizes the weighted variance along all the lines in a
+   particular direction, i.e. the squared error between the input and a
+   "predicted" block where each pixel is replaced by the average along a line
+   in a particular direction. Since each direction have the same sum(x^2) term,
+   that term is never computed. See Section 2, step 2, of:
+   http://jmvalin.ca/notes/intra_paint.pdf */
+static const uint16_t div_table[] = {
+    0, 840, 420, 280, 210, 168, 140, 120, 105
+};
+static int cdef_find_dir_c(const pixel *img, const ptrdiff_t stride,
+                           unsigned *const var)
+{
+    int i;
+    int32_t cost[8] = { 0 };
+    int partial[8][15] = { { 0 } };
+    int32_t best_cost = 0;
+    int best_dir = 0;
+    /* Instead of dividing by n between 2 and 8, we multiply by 3*5*7*8/n.
+     The output is then 840 times larger, but we don't care for finding
+     the max. */
+    for (i = 0; i < 8; i++) {
+        int j;
+        for (j = 0; j < 8; j++) {
+            int x;
+            /* We subtract 128 here to reduce the maximum range of the squared
+             partial sums. */
+            x = (img[i * PXSTRIDE(stride) + j] >> (BITDEPTH - 8)) - 128;
+            partial[0][i + j] += x;
+            partial[1][i + j / 2] += x;
+            partial[2][i] += x;
+            partial[3][3 + i - j / 2] += x;
+            partial[4][7 + i - j] += x;
+            partial[5][3 - i / 2 + j] += x;
+            partial[6][j] += x;
+            partial[7][i / 2 + j] += x;
+        }
+    }
+    for (i = 0; i < 8; i++) {
+        cost[2] += partial[2][i] * partial[2][i];
+        cost[6] += partial[6][i] * partial[6][i];
+    }
+    cost[2] *= div_table[8];
+    cost[6] *= div_table[8];
+    for (i = 0; i < 7; i++) {
+        cost[0] += (partial[0][i] * partial[0][i] +
+                    partial[0][14 - i] * partial[0][14 - i]) *
+                   div_table[i + 1];
+        cost[4] += (partial[4][i] * partial[4][i] +
+                    partial[4][14 - i] * partial[4][14 - i]) *
+                   div_table[i + 1];
+    }
+    cost[0] += partial[0][7] * partial[0][7] * div_table[8];
+    cost[4] += partial[4][7] * partial[4][7] * div_table[8];
+    for (i = 1; i < 8; i += 2) {
+        int j;
+        for (j = 0; j < 4 + 1; j++) {
+            cost[i] += partial[i][3 + j] * partial[i][3 + j];
+        }
+        cost[i] *= div_table[8];
+        for (j = 0; j < 4 - 1; j++) {
+            cost[i] += (partial[i][j] * partial[i][j] +
+                        partial[i][10 - j] * partial[i][10 - j]) *
+                       div_table[2 * j + 2];
+        }
+    }
+    for (i = 0; i < 8; i++) {
+        if (cost[i] > best_cost) {
+            best_cost = cost[i];
+            best_dir = i;
+        }
+    }
+    /* Difference between the optimal variance and the variance along the
+     orthogonal direction. Again, the sum(x^2) terms cancel out. */
+    *var = best_cost - cost[(best_dir + 4) & 7];
+    /* We'd normally divide by 840, but dividing by 1024 is close enough
+     for what we're going to do with this. */
+    *var >>= 10;
+    return best_dir;
+}
+
+/*
+ * </code copied from libaom>
+ */
+
+void bitfn(dav1d_cdef_dsp_init)(Dav1dCdefDSPContext *const c) {
+    c->dir = cdef_find_dir_c;
+    c->fb[0] = cdef_filter_block_8x8_c;
+    c->fb[1] = cdef_filter_block_4x8_c;
+    c->fb[2] = cdef_filter_block_4x4_c;
+}
diff --git a/src/cdef.h b/src/cdef.h
new file mode 100644
index 0000000..9573962
--- /dev/null
+++ b/src/cdef.h
@@ -0,0 +1,62 @@
+/*
+ * Copyright © 2018, VideoLAN and dav1d authors
+ * Copyright © 2018, Two Orioles, LLC
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright notice, this
+ *    list of conditions and the following disclaimer.
+ *
+ * 2. Redistributions in binary form must reproduce the above copyright notice,
+ *    this list of conditions and the following disclaimer in the documentation
+ *    and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
+ * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#ifndef __DAV1D_SRC_CDEF_H__
+#define __DAV1D_SRC_CDEF_H__
+
+#include <stddef.h>
+#include <stdint.h>
+
+#include "common/bitdepth.h"
+
+enum CdefEdgeFlags {
+    HAVE_LEFT = 1 << 0,
+    HAVE_RIGHT = 1 << 1,
+    HAVE_TOP = 1 << 2,
+    HAVE_BOTTOM = 1 << 3,
+};
+
+// CDEF operates entirely on pre-filter data; if bottom/right edges are
+// present (according to $edges), then the pre-filter data is located in
+// $dst. However, the edge pixels above $dst may be post-filter, so in
+// order to get access to pre-filter top pixels, use $top.
+typedef void (*cdef_fn)(pixel *dst, ptrdiff_t stride,
+                        /*const*/ pixel *const top[2],
+                        int pri_strength, int sec_strength,
+                        int dir, int damping, enum CdefEdgeFlags edges);
+typedef int (*cdef_dir_fn)(const pixel *dst, ptrdiff_t stride,
+                           unsigned *var);
+
+typedef struct Dav1dCdefDSPContext {
+    cdef_dir_fn dir;
+    cdef_fn fb[3 /* 444/luma, 422, 420 */];
+} Dav1dCdefDSPContext;
+
+void dav1d_cdef_dsp_init_8bpc(Dav1dCdefDSPContext *c);
+void dav1d_cdef_dsp_init_10bpc(Dav1dCdefDSPContext *c);
+
+#endif /* __DAV1D_SRC_CDEF_H__ */
diff --git a/src/cdef_apply.c b/src/cdef_apply.c
new file mode 100644
index 0000000..d794da3
--- /dev/null
+++ b/src/cdef_apply.c
@@ -0,0 +1,237 @@
+/*
+ * Copyright © 2018, VideoLAN and dav1d authors
+ * Copyright © 2018, Two Orioles, LLC
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright notice, this
+ *    list of conditions and the following disclaimer.
+ *
+ * 2. Redistributions in binary form must reproduce the above copyright notice,
+ *    this list of conditions and the following disclaimer in the documentation
+ *    and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
+ * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#include "config.h"
+
+#include <string.h>
+
+#include "common/intops.h"
+
+#include "src/cdef_apply.h"
+
+static void backup2lines(pixel *const dst[3][2],
+                         /*const*/ pixel *const src[3],
+                         const ptrdiff_t src_stride[2], int y_off, int w,
+                         const enum Dav1dPixelLayout layout)
+{
+    pixel_copy(dst[0][0], src[0] + (y_off - 2) * PXSTRIDE(src_stride[0]), w);
+    pixel_copy(dst[0][1], src[0] + (y_off - 1) * PXSTRIDE(src_stride[0]), w);
+
+    if (layout == DAV1D_PIXEL_LAYOUT_I400) return;
+    const int ss_ver = layout == DAV1D_PIXEL_LAYOUT_I420;
+    const int ss_hor = layout != DAV1D_PIXEL_LAYOUT_I444;
+
+    w >>= ss_hor;
+    y_off >>= ss_ver;
+    pixel_copy(dst[1][0], src[1] + (y_off - 2) * PXSTRIDE(src_stride[1]), w);
+    pixel_copy(dst[1][1], src[1] + (y_off - 1) * PXSTRIDE(src_stride[1]), w);
+    pixel_copy(dst[2][0], src[2] + (y_off - 2) * PXSTRIDE(src_stride[1]), w);
+    pixel_copy(dst[2][1], src[2] + (y_off - 1) * PXSTRIDE(src_stride[1]), w);
+}
+
+static void backup2x8(pixel dst[3][8][2],
+                      /*const*/ pixel *const src[3],
+                      const ptrdiff_t src_stride[2], int x_off,
+                      const enum Dav1dPixelLayout layout)
+{
+    for (int y = 0, y_off = 0; y < 8; y++, y_off += PXSTRIDE(src_stride[0]))
+        pixel_copy(dst[0][y], &src[0][y_off + x_off - 2], 2);
+
+    if (layout == DAV1D_PIXEL_LAYOUT_I400) return;
+    const int ss_ver = layout == DAV1D_PIXEL_LAYOUT_I420;
+    const int ss_hor = layout != DAV1D_PIXEL_LAYOUT_I444;
+
+    x_off >>= ss_hor;
+    for (int y = 0, y_off = 0; y < (8 >> ss_ver); y++, y_off += PXSTRIDE(src_stride[1])) {
+        pixel_copy(dst[1][y], &src[1][y_off + x_off - 2], 2);
+        pixel_copy(dst[2][y], &src[2][y_off + x_off - 2], 2);
+    }
+}
+
+static void restore2x8(pixel *const dst[3],
+                       const ptrdiff_t dst_stride[2],
+                       const pixel src[3][8][2], const enum Dav1dPixelLayout layout)
+{
+    for (int y = 0, y_off = 0; y < 8; y++, y_off += PXSTRIDE(dst_stride[0]))
+        pixel_copy(&dst[0][y_off - 2], src[0][y], 2);
+
+    if (layout == DAV1D_PIXEL_LAYOUT_I400) return;
+    const int ss_ver = layout == DAV1D_PIXEL_LAYOUT_I420;
+
+    for (int y = 0, y_off = 0; y < (8 >> ss_ver); y++, y_off += PXSTRIDE(dst_stride[1])) {
+        pixel_copy(&dst[1][y_off - 2], src[1][y], 2);
+        pixel_copy(&dst[2][y_off - 2], src[2][y], 2);
+    }
+}
+
+static int adjust_strength(const int strength, const unsigned var) {
+    if (!var) return 0;
+    const int i = var >> 6 ? imin(ulog2(var >> 6), 12) : 0;
+    return (strength * (4 + i) + 8) >> 4;
+}
+
+void bytefn(dav1d_cdef_brow)(Dav1dFrameContext *const f,
+                             pixel *const p[3],
+                             const Av1Filter *const lflvl,
+                             const int by_start, const int by_end)
+{
+    const Dav1dDSPContext *const dsp = f->dsp;
+    enum CdefEdgeFlags edges = HAVE_BOTTOM | (by_start > 0 ? HAVE_TOP : 0);
+    pixel *ptrs[3] = { p[0], p[1], p[2] };
+    const int sbsz = 16;
+    const int sb64w = f->sb128w << 1;
+    const int damping = f->frame_hdr.cdef.damping + BITDEPTH - 8;
+    const enum Dav1dPixelLayout layout = f->cur.p.p.layout;
+    const int uv_idx = DAV1D_PIXEL_LAYOUT_I444 - layout;
+    const int has_chroma = layout != DAV1D_PIXEL_LAYOUT_I400;
+    const int ss_ver = layout == DAV1D_PIXEL_LAYOUT_I420;
+    const int ss_hor = layout != DAV1D_PIXEL_LAYOUT_I444;
+
+    // FIXME a design improvement that could be made here is to keep a set of
+    // flags for each block position on whether the block was filtered; if not,
+    // the backup of pre-filter data is empty, and the restore is therefore
+    // unnecessary as well.
+
+    for (int by = by_start; by < by_end; by += 2, edges |= HAVE_TOP) {
+        const int tf = f->lf.top_pre_cdef_toggle;
+        if (by + 2 >= f->bh) edges &= ~HAVE_BOTTOM;
+
+        if (edges & HAVE_BOTTOM) {
+            // backup pre-filter data for next iteration
+            backup2lines(f->lf.cdef_line_ptr[!tf], ptrs, f->cur.p.stride,
+                         8, f->bw * 4, layout);
+        }
+
+        pixel lr_bak[2 /* idx */][3 /* plane */][8 /* y */][2 /* x */];
+        pixel *iptrs[3] = { ptrs[0], ptrs[1], ptrs[2] };
+        edges &= ~HAVE_LEFT;
+        edges |= HAVE_RIGHT;
+        for (int sbx = 0, last_skip = 1; sbx < sb64w; sbx++, edges |= HAVE_LEFT) {
+            const int sb128x = sbx >>1;
+            const int sb64_idx = ((by & sbsz) >> 3) + (sbx & 1);
+            const int cdef_idx = lflvl[sb128x].cdef_idx[sb64_idx];
+            if (cdef_idx == -1 ||
+                (!f->frame_hdr.cdef.y_strength[cdef_idx] &&
+                 !f->frame_hdr.cdef.uv_strength[cdef_idx]))
+            {
+                last_skip = 1;
+                goto next_sb;
+            }
+
+            const int y_lvl = f->frame_hdr.cdef.y_strength[cdef_idx];
+            const int uv_lvl = f->frame_hdr.cdef.uv_strength[cdef_idx];
+            pixel *bptrs[3] = { iptrs[0], iptrs[1], iptrs[2] };
+            for (int bx = sbx * sbsz; bx < imin((sbx + 1) * sbsz, f->bw);
+                 bx += 2, edges |= HAVE_LEFT)
+            {
+                if (bx + 2 >= f->bw) edges &= ~HAVE_RIGHT;
+
+                // check if this 8x8 block had any coded coefficients; if not,
+                // go to the next block
+                const unsigned bx_mask = 3U << (bx & 30);
+                const int by_idx = by & 30;
+                if (!((lflvl[sb128x].noskip_mask[by_idx + 0] |
+                       lflvl[sb128x].noskip_mask[by_idx + 1]) & bx_mask))
+                {
+                    last_skip = 1;
+                    goto next_b;
+                }
+
+                if (!last_skip) {
+                    // backup post-filter data (will be restored at the end)
+                    backup2x8(lr_bak[1], bptrs, f->cur.p.stride, 0, layout);
+
+                    // restore pre-filter data from last iteration
+                    restore2x8(bptrs, f->cur.p.stride, lr_bak[0], layout);
+                }
+                if (edges & HAVE_RIGHT) {
+                    // backup pre-filter data for next iteration
+                    backup2x8(lr_bak[0], bptrs, f->cur.p.stride, 8, layout);
+                }
+
+                // the actual filter
+                const int y_pri_lvl = (y_lvl >> 2) << (BITDEPTH - 8);
+                int y_sec_lvl = y_lvl & 3;
+                y_sec_lvl += y_sec_lvl == 3;
+                y_sec_lvl <<= BITDEPTH - 8;
+                const int uv_pri_lvl = (uv_lvl >> 2) << (BITDEPTH - 8);
+                int uv_sec_lvl = uv_lvl & 3;
+                uv_sec_lvl += uv_sec_lvl == 3;
+                uv_sec_lvl <<= BITDEPTH - 8;
+                unsigned variance;
+                const int dir = dsp->cdef.dir(bptrs[0], f->cur.p.stride[0],
+                                              &variance);
+                if (y_lvl) {
+                    dsp->cdef.fb[0](bptrs[0], f->cur.p.stride[0],
+                                    (pixel *const [2]) {
+                                        &f->lf.cdef_line_ptr[tf][0][0][bx * 4],
+                                        &f->lf.cdef_line_ptr[tf][0][1][bx * 4],
+                                    },
+                                    adjust_strength(y_pri_lvl, variance),
+                                    y_sec_lvl, y_pri_lvl ? dir : 0,
+                                    damping, edges);
+                }
+                if (uv_lvl && has_chroma) {
+                    const int uvdir =
+                        f->cur.p.p.layout != DAV1D_PIXEL_LAYOUT_I422 ? dir :
+                        ((uint8_t[]) { 7, 0, 2, 4, 5, 6, 6, 6 })[dir];
+                    for (int pl = 1; pl <= 2; pl++) {
+                        dsp->cdef.fb[uv_idx](bptrs[pl], f->cur.p.stride[1],
+                                             (pixel *const [2]) {
+                                                 &f->lf.cdef_line_ptr[tf][pl][0][bx * 4 >> ss_hor],
+                                                 &f->lf.cdef_line_ptr[tf][pl][1][bx * 4 >> ss_hor],
+                                             },
+                                             uv_pri_lvl, uv_sec_lvl,
+                                             uv_pri_lvl ? uvdir : 0,
+                                             damping - 1, edges);
+                    }
+                }
+
+                if (!last_skip) {
+                    // restore post-filter data from the beginning of this loop
+                    restore2x8(bptrs, f->cur.p.stride, lr_bak[1], layout);
+                }
+                last_skip = 0;
+
+            next_b:
+                bptrs[0] += 8;
+                bptrs[1] += 8 >> ss_hor;
+                bptrs[2] += 8 >> ss_hor;
+            }
+
+        next_sb:
+            iptrs[0] += sbsz * 4;
+            iptrs[1] += sbsz * 4 >> ss_hor;
+            iptrs[2] += sbsz * 4 >> ss_hor;
+        }
+
+        ptrs[0] += 8 * PXSTRIDE(f->cur.p.stride[0]);
+        ptrs[1] += 8 * PXSTRIDE(f->cur.p.stride[1]) >> ss_ver;
+        ptrs[2] += 8 * PXSTRIDE(f->cur.p.stride[1]) >> ss_ver;
+        f->lf.top_pre_cdef_toggle ^= 1;
+    }
+}
diff --git a/src/cdef_apply.h b/src/cdef_apply.h
new file mode 100644
index 0000000..912812d
--- /dev/null
+++ b/src/cdef_apply.h
@@ -0,0 +1,38 @@
+/*
+ * Copyright © 2018, VideoLAN and dav1d authors
+ * Copyright © 2018, Two Orioles, LLC
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright notice, this
+ *    list of conditions and the following disclaimer.
+ *
+ * 2. Redistributions in binary form must reproduce the above copyright notice,
+ *    this list of conditions and the following disclaimer in the documentation
+ *    and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
+ * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#ifndef __DAV1D_SRC_CDEF_APPLY_H__
+#define __DAV1D_SRC_CDEF_APPLY_H__
+
+#include "common/bitdepth.h"
+
+#include "src/internal.h"
+
+void bytefn(dav1d_cdef_brow)(Dav1dFrameContext *f, pixel *const p[3],
+                             const Av1Filter *lflvl, int by_start, int by_end);
+
+#endif /* __DAV1D_SRC_CDEF_APPLY_H__ */
diff --git a/src/cdf.c b/src/cdf.c
new file mode 100644
index 0000000..71bc237
--- /dev/null
+++ b/src/cdf.c
@@ -0,0 +1,4251 @@
+/*
+ * Copyright © 2018, VideoLAN and dav1d authors
+ * Copyright © 2018, Two Orioles, LLC
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright notice, this
+ *    list of conditions and the following disclaimer.
+ *
+ * 2. Redistributions in binary form must reproduce the above copyright notice,
+ *    this list of conditions and the following disclaimer in the documentation
+ *    and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
+ * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#include "config.h"
+
+#include <assert.h>
+#include <pthread.h>
+#include <string.h>
+
+#include "common/intops.h"
+
+#include "src/cdf.h"
+
+#define AOM_ICDF(x) (32768-(x))
+
+#define AOM_CDF2(a) \
+    AOM_ICDF(a)
+#define AOM_CDF3(a,b) \
+    AOM_ICDF(a), AOM_ICDF(b)
+#define AOM_CDF4(a,b,c) \
+    AOM_ICDF(a), AOM_CDF3(b,c)
+#define AOM_CDF5(a,b,c,d) \
+    AOM_ICDF(a), AOM_CDF4(b,c,d)
+#define AOM_CDF6(a,b,c,d,e) \
+    AOM_ICDF(a), AOM_CDF5(b,c,d,e)
+#define AOM_CDF7(a,b,c,d,e,f) \
+    AOM_ICDF(a), AOM_CDF6(b,c,d,e,f)
+#define AOM_CDF8(a,b,c,d,e,f,g) \
+    AOM_ICDF(a), AOM_CDF7(b,c,d,e,f,g)
+#define AOM_CDF9(a,b,c,d,e,f,g,h) \
+    AOM_ICDF(a), AOM_CDF8(b,c,d,e,f,g,h)
+#define AOM_CDF10(a,b,c,d,e,f,g,h,i) \
+    AOM_ICDF(a), AOM_CDF9(b,c,d,e,f,g,h,i)
+#define AOM_CDF11(a,b,c,d,e,f,g,h,i,j) \
+    AOM_ICDF(a), AOM_CDF10(b,c,d,e,f,g,h,i,j)
+#define AOM_CDF12(a,b,c,d,e,f,g,h,i,j,k) \
+    AOM_ICDF(a), AOM_CDF11(b,c,d,e,f,g,h,i,j,k)
+#define AOM_CDF13(a,b,c,d,e,f,g,h,i,j,k,l) \
+    AOM_ICDF(a), AOM_CDF12(b,c,d,e,f,g,h,i,j,k,l)
+#define AOM_CDF14(a,b,c,d,e,f,g,h,i,j,k,l,m) \
+    AOM_ICDF(a), AOM_CDF13(b,c,d,e,f,g,h,i,j,k,l,m)
+#define AOM_CDF15(a,b,c,d,e,f,g,h,i,j,k,l,m,n) \
+    AOM_ICDF(a), AOM_CDF14(b,c,d,e,f,g,h,i,j,k,l,m,n)
+#define AOM_CDF16(a,b,c,d,e,f,g,h,i,j,k,l,m,n,o) \
+    AOM_ICDF(a), AOM_CDF15(b,c,d,e,f,g,h,i,j,k,l,m,n,o)
+
+static const CdfModeContext av1_default_cdf = {
+    .y_mode = {
+        { AOM_CDF13(22801, 23489, 24293, 24756, 25601, 26123,
+                    26606, 27418, 27945, 29228, 29685, 30349) },
+        { AOM_CDF13(18673, 19845, 22631, 23318, 23950, 24649,
+                    25527, 27364, 28152, 29701, 29984, 30852) },
+        { AOM_CDF13(19770, 20979, 23396, 23939, 24241, 24654,
+                    25136, 27073, 27830, 29360, 29730, 30659) },
+        { AOM_CDF13(20155, 21301, 22838, 23178, 23261, 23533,
+                    23703, 24804, 25352, 26575, 27016, 28049) },
+    }, .use_filter_intra = {
+        [BS_4x4]     = { AOM_CDF2(4621) },
+        [BS_4x8]     = { AOM_CDF2(6743) },
+        [BS_8x4]     = { AOM_CDF2(5893) },
+        [BS_8x8]     = { AOM_CDF2(7866) },
+        [BS_8x16]    = { AOM_CDF2(12551) },
+        [BS_16x8]    = { AOM_CDF2(9394) },
+        [BS_16x16]   = { AOM_CDF2(12408) },
+        [BS_16x32]   = { AOM_CDF2(14301) },
+        [BS_32x16]   = { AOM_CDF2(12756) },
+        [BS_32x32]   = { AOM_CDF2(22343) },
+        [BS_32x64]   = { AOM_CDF2(16384) },
+        [BS_64x32]   = { AOM_CDF2(16384) },
+        [BS_64x64]   = { AOM_CDF2(16384) },
+        [BS_64x128]  = { AOM_CDF2(16384) },
+        [BS_128x64]  = { AOM_CDF2(16384) },
+        [BS_128x128] = { AOM_CDF2(16384) },
+        [BS_4x16]    = { AOM_CDF2(12770) },
+        [BS_16x4]    = { AOM_CDF2(10368) },
+        [BS_8x32]    = { AOM_CDF2(20229) },
+        [BS_32x8]    = { AOM_CDF2(18101) },
+        [BS_16x64]   = { AOM_CDF2(16384) },
+        [BS_64x16]   = { AOM_CDF2(16384) },
+    }, .filter_intra = {
+        AOM_CDF5(8949, 12776, 17211, 29558),
+    }, .uv_mode = {
+        {
+            { AOM_CDF13(22631, 24152, 25378, 25661, 25986, 26520, 27055, 27923,
+                        28244, 30059, 30941, 31961) },
+            { AOM_CDF13(9513, 26881, 26973, 27046, 27118, 27664, 27739, 27824,
+                        28359, 29505, 29800, 31796) },
+            { AOM_CDF13(9845, 9915, 28663, 28704, 28757, 28780, 29198, 29822,
+                        29854, 30764, 31777, 32029) },
+            { AOM_CDF13(13639, 13897, 14171, 25331, 25606, 25727, 25953, 27148,
+                        28577, 30612, 31355, 32493) },
+            { AOM_CDF13(9764, 9835, 9930, 9954, 25386, 27053, 27958, 28148,
+                        28243, 31101, 31744, 32363) },
+            { AOM_CDF13(11825, 13589, 13677, 13720, 15048, 29213, 29301, 29458,
+                        29711, 31161, 31441, 32550) },
+            { AOM_CDF13(14175, 14399, 16608, 16821, 17718, 17775, 28551, 30200,
+                        30245, 31837, 32342, 32667) },
+            { AOM_CDF13(12885, 13038, 14978, 15590, 15673, 15748, 16176, 29128,
+                        29267, 30643, 31961, 32461) },
+            { AOM_CDF13(12026, 13661, 13874, 15305, 15490, 15726, 15995, 16273,
+                        28443, 30388, 30767, 32416) },
+            { AOM_CDF13(19052, 19840, 20579, 20916, 21150, 21467, 21885, 22719,
+                        23174, 28861, 30379, 32175) },
+            { AOM_CDF13(18627, 19649, 20974, 21219, 21492, 21816, 22199, 23119,
+                        23527, 27053, 31397, 32148) },
+            { AOM_CDF13(17026, 19004, 19997, 20339, 20586, 21103, 21349, 21907,
+                        22482, 25896, 26541, 31819) },
+            { AOM_CDF13(12124, 13759, 14959, 14992, 15007, 15051, 15078, 15166,
+                        15255, 15753, 16039, 16606) }
+        }, {
+            { AOM_CDF14(10407, 11208, 12900, 13181, 13823, 14175, 14899, 15656,
+                      15986, 20086, 20995, 22455, 24212) },
+            { AOM_CDF14(4532, 19780, 20057, 20215, 20428, 21071, 21199, 21451,
+                        22099, 24228, 24693, 27032, 29472) },
+            { AOM_CDF14(5273, 5379, 20177, 20270, 20385, 20439, 20949, 21695,
+                        21774, 23138, 24256, 24703, 26679) },
+            { AOM_CDF14(6740, 7167, 7662, 14152, 14536, 14785, 15034, 16741,
+                        18371, 21520, 22206, 23389, 24182) },
+            { AOM_CDF14(4987, 5368, 5928, 6068, 19114, 20315, 21857, 22253,
+                        22411, 24911, 25380, 26027, 26376) },
+            { AOM_CDF14(5370, 6889, 7247, 7393, 9498, 21114, 21402, 21753,
+                        21981, 24780, 25386, 26517, 27176) },
+            { AOM_CDF14(4816, 4961, 7204, 7326, 8765, 8930, 20169, 20682,
+                        20803, 23188, 23763, 24455, 24940) },
+            { AOM_CDF14(6608, 6740, 8529, 9049, 9257, 9356, 9735, 18827,
+                        19059, 22336, 23204, 23964, 24793) },
+            { AOM_CDF14(5998, 7419, 7781, 8933, 9255, 9549, 9753, 10417,
+                        18898, 22494, 23139, 24764, 25989) },
+            { AOM_CDF14(10660, 11298, 12550, 12957, 13322, 13624, 14040, 15004,
+                        15534, 20714, 21789, 23443, 24861) },
+            { AOM_CDF14(10522, 11530, 12552, 12963, 13378, 13779, 14245, 15235,
+                        15902, 20102, 22696, 23774, 25838) },
+            { AOM_CDF14(10099, 10691, 12639, 13049, 13386, 13665, 14125, 15163,
+                        15636, 19676, 20474, 23519, 25208) },
+            { AOM_CDF14(3144, 5087, 7382, 7504, 7593, 7690, 7801, 8064,
+                        8232, 9248, 9875, 10521, 29048) }
+        }
+    }, .angle_delta = {
+        { AOM_CDF7(2180, 5032, 7567, 22776, 26989, 30217) },
+        { AOM_CDF7(2301, 5608, 8801, 23487, 26974, 30330) },
+        { AOM_CDF7(3780, 11018, 13699, 19354, 23083, 31286) },
+        { AOM_CDF7(4581, 11226, 15147, 17138, 21834, 28397) },
+        { AOM_CDF7(1737, 10927, 14509, 19588, 22745, 28823) },
+        { AOM_CDF7(2664, 10176, 12485, 17650, 21600, 30495) },
+        { AOM_CDF7(2240, 11096, 15453, 20341, 22561, 28917) },
+        { AOM_CDF7(3605, 10428, 12459, 17676, 21244, 30655) }
+    }, .filter = {
+        {
+            { AOM_CDF3(31935, 32720) },
+            { AOM_CDF3(5568, 32719) },
+            { AOM_CDF3(422, 2938) },
+            { AOM_CDF3(28244, 32608) },
+            { AOM_CDF3(31206, 31953) },
+            { AOM_CDF3(4862, 32121) },
+            { AOM_CDF3(770, 1152) },
+            { AOM_CDF3(20889, 25637) },
+        }, {
+            { AOM_CDF3(31910, 32724) },
+            { AOM_CDF3(4120, 32712) },
+            { AOM_CDF3(305, 2247) },
+            { AOM_CDF3(27403, 32636) },
+            { AOM_CDF3(31022, 32009) },
+            { AOM_CDF3(2963, 32093) },
+            { AOM_CDF3(601, 943) },
+            { AOM_CDF3(14969, 21398) }
+        }
+    }, .newmv_mode = {
+        { AOM_CDF2(24035) },
+        { AOM_CDF2(16630) },
+        { AOM_CDF2(15339) },
+        { AOM_CDF2(8386) },
+        { AOM_CDF2(12222) },
+        { AOM_CDF2(4676) },
+    }, .globalmv_mode = {
+        { AOM_CDF2(2175) },
+        { AOM_CDF2(1054) }
+    }, .refmv_mode = {
+        { AOM_CDF2(23974) },
+        { AOM_CDF2(24188) },
+        { AOM_CDF2(17848) },
+        { AOM_CDF2(28622) },
+        { AOM_CDF2(24312) },
+        { AOM_CDF2(19923) }
+    }, .drl_bit = {
+        { AOM_CDF2(13104) },
+        { AOM_CDF2(24560) },
+        { AOM_CDF2(18945) }
+    }, .comp_inter_mode = {
+        { AOM_CDF8(7760, 13823, 15808, 17641, 19156, 20666, 26891) },
+        { AOM_CDF8(10730, 19452, 21145, 22749, 24039, 25131, 28724) },
+        { AOM_CDF8(10664, 20221, 21588, 22906, 24295, 25387, 28436) },
+        { AOM_CDF8(13298, 16984, 20471, 24182, 25067, 25736, 26422) },
+        { AOM_CDF8(18904, 23325, 25242, 27432, 27898, 28258, 30758) },
+        { AOM_CDF8(10725, 17454, 20124, 22820, 24195, 25168, 26046) },
+        { AOM_CDF8(17125, 24273, 25814, 27492, 28214, 28704, 30592) },
+        { AOM_CDF8(13046, 23214, 24505, 25942, 27435, 28442, 29330) }
+    }, .intra = {
+        { AOM_CDF2(806) },
+        { AOM_CDF2(16662) },
+        { AOM_CDF2(20186) },
+        { AOM_CDF2(26538) }
+    }, .comp = {
+        { AOM_CDF2(26828) },
+        { AOM_CDF2(24035) },
+        { AOM_CDF2(12031) },
+        { AOM_CDF2(10640) },
+        { AOM_CDF2(2901) }
+    }, .comp_dir = {
+        { AOM_CDF2(1198) },
+        { AOM_CDF2(2070) },
+        { AOM_CDF2(9166) },
+        { AOM_CDF2(7499) },
+        { AOM_CDF2(22475) }
+    }, .jnt_comp = {
+        { AOM_CDF2(18244) },
+        { AOM_CDF2(12865) },
+        { AOM_CDF2(7053) },
+        { AOM_CDF2(13259) },
+        { AOM_CDF2(9334) },
+        { AOM_CDF2(4644) }
+    }, .mask_comp = {
+        { AOM_CDF2(26607) },
+        { AOM_CDF2(22891) },
+        { AOM_CDF2(18840) },
+        { AOM_CDF2(24594) },
+        { AOM_CDF2(19934) },
+        { AOM_CDF2(22674) }
+    }, .wedge_comp = {
+        { AOM_CDF2(23431) },
+        { AOM_CDF2(13171) },
+        { AOM_CDF2(11470) },
+        { AOM_CDF2(9770) },
+        { AOM_CDF2(9100) },
+        { AOM_CDF2(8233) },
+        { AOM_CDF2(6172) },
+        { AOM_CDF2(11820) },
+        { AOM_CDF2(7701) },
+    }, .wedge_idx = {
+        { AOM_CDF16(2438, 4440, 6599, 8663, 11005, 12874, 15751, 18094,
+                    20359, 22362, 24127, 25702, 27752, 29450, 31171) },
+        { AOM_CDF16(806, 3266, 6005, 6738, 7218, 7367, 7771, 14588,
+                    16323, 17367, 18452, 19422, 22839, 26127, 29629) },
+        { AOM_CDF16(2779, 3738, 4683, 7213, 7775, 8017, 8655, 14357,
+                    17939, 21332, 24520, 27470, 29456, 30529, 31656) },
+        { AOM_CDF16(1684, 3625, 5675, 7108, 9302, 11274, 14429, 17144,
+                    19163, 20961, 22884, 24471, 26719, 28714, 30877) },
+        { AOM_CDF16(1142, 3491, 6277, 7314, 8089, 8355, 9023, 13624,
+                    15369, 16730, 18114, 19313, 22521, 26012, 29550) },
+        { AOM_CDF16(2742, 4195, 5727, 8035, 8980, 9336, 10146, 14124,
+                    17270, 20533, 23434, 25972, 27944, 29570, 31416) },
+        { AOM_CDF16(1727, 3948, 6101, 7796, 9841, 12344, 15766, 18944,
+                    20638, 22038, 23963, 25311, 26988, 28766, 31012) },
+        { AOM_CDF16(154, 987, 1925, 2051, 2088, 2111, 2151, 23033,
+                    23703, 24284, 24985, 25684, 27259, 28883, 30911) },
+        { AOM_CDF16(1135, 1322, 1493, 2635, 2696, 2737, 2770, 21016,
+                    22935, 25057, 27251, 29173, 30089, 30960, 31933) },
+    }, .interintra = {
+        { AOM_CDF2(16384) },
+        { AOM_CDF2(26887) },
+        { AOM_CDF2(27597) },
+        { AOM_CDF2(30237) }
+    }, .interintra_mode = {
+        { AOM_CDF4(8192, 16384, 24576) },
+        { AOM_CDF4(1875, 11082, 27332) },
+        { AOM_CDF4(2473, 9996, 26388) },
+        { AOM_CDF4(4238, 11537, 25926) }
+    }, .interintra_wedge = {
+        { AOM_CDF2(20036) },
+        { AOM_CDF2(24957) },
+        { AOM_CDF2(26704) },
+        { AOM_CDF2(27530) },
+        { AOM_CDF2(29564) },
+        { AOM_CDF2(29444) },
+        { AOM_CDF2(26872) },
+    }, .ref = {
+        {
+            { AOM_CDF2(4897) },
+            { AOM_CDF2(16973) },
+            { AOM_CDF2(29744) },
+        }, {
+            { AOM_CDF2(1555) },
+            { AOM_CDF2(16751) },
+            { AOM_CDF2(30279) },
+        }, {
+            { AOM_CDF2(4236) },
+            { AOM_CDF2(19647) },
+            { AOM_CDF2(31194) },
+        }, {
+            { AOM_CDF2(8650) },
+            { AOM_CDF2(24773) },
+            { AOM_CDF2(31895) },
+        }, {
+            { AOM_CDF2(904) },
+            { AOM_CDF2(11014) },
+            { AOM_CDF2(26875) },
+        }, {
+            { AOM_CDF2(1444) },
+            { AOM_CDF2(15087) },
+            { AOM_CDF2(30304) },
+        }
+    }, .comp_fwd_ref = {
+        {
+            { AOM_CDF2(4946) },
+            { AOM_CDF2(19891) },
+            { AOM_CDF2(30731) },
+        }, {
+            { AOM_CDF2(9468) },
+            { AOM_CDF2(22441) },
+            { AOM_CDF2(31059) },
+        }, {
+            { AOM_CDF2(1503) },
+            { AOM_CDF2(15160) },
+            { AOM_CDF2(27544) },
+        }
+    }, .comp_bwd_ref = {
+        {
+            { AOM_CDF2(2235) },
+            { AOM_CDF2(17182) },
+            { AOM_CDF2(30606) },
+        }, {
+            { AOM_CDF2(1423) },
+            { AOM_CDF2(15175) },
+            { AOM_CDF2(30489) },
+        }
+    }, .comp_uni_ref = {
+        {
+            { AOM_CDF2(5284) },
+            { AOM_CDF2(23152) },
+            { AOM_CDF2(31774) },
+        }, {
+            { AOM_CDF2(3865) },
+            { AOM_CDF2(14173) },
+            { AOM_CDF2(25120) },
+        }, {
+            { AOM_CDF2(3128) },
+            { AOM_CDF2(15270) },
+            { AOM_CDF2(26710) },
+        }
+    }, .txsz = {
+        {
+            { AOM_CDF2(19968) },
+            { AOM_CDF2(19968) },
+            { AOM_CDF2(24320) }
+        }, {
+            { AOM_CDF3(12272, 30172) },
+            { AOM_CDF3(12272, 30172) },
+            { AOM_CDF3(18677, 30848) }
+        }, {
+            { AOM_CDF3(12986, 15180) },
+            { AOM_CDF3(12986, 15180) },
+            { AOM_CDF3(24302, 25602) }
+        }, {
+            { AOM_CDF3(5782, 11475) },
+            { AOM_CDF3(5782, 11475) },
+            { AOM_CDF3(16803, 22759) }
+        }
+    }, .txpart = {
+        { { AOM_CDF2(28581) }, { AOM_CDF2(23846) }, { AOM_CDF2(20847) }, },
+        { { AOM_CDF2(24315) }, { AOM_CDF2(18196) }, { AOM_CDF2(12133) }, },
+        { { AOM_CDF2(18791) }, { AOM_CDF2(10887) }, { AOM_CDF2(11005) }, },
+        { { AOM_CDF2(27179) }, { AOM_CDF2(20004) }, { AOM_CDF2(11281) }, },
+        { { AOM_CDF2(26549) }, { AOM_CDF2(19308) }, { AOM_CDF2(14224) }, },
+        { { AOM_CDF2(28015) }, { AOM_CDF2(21546) }, { AOM_CDF2(14400) }, },
+        { { AOM_CDF2(28165) }, { AOM_CDF2(22401) }, { AOM_CDF2(16088) }, },
+    }, .txtp_inter = {
+        {}, {
+            { AOM_CDF16(4458, 5560, 7695, 9709, 13330, 14789, 17537, 20266,
+                        21504, 22848, 23934, 25474, 27727, 28915, 30631) },
+            { AOM_CDF16(1645, 2573, 4778, 5711, 7807, 8622, 10522, 15357,
+                        17674, 20408, 22517, 25010, 27116, 28856, 30749) },
+            { AOM_CDF16(2048, 4096, 6144, 8192, 10240, 12288, 14336, 16384,
+                        18432, 20480, 22528, 24576, 26624, 28672, 30720) },
+            { AOM_CDF16(2048, 4096, 6144, 8192, 10240, 12288, 14336, 16384,
+                        18432, 20480, 22528, 24576, 26624, 28672, 30720) },
+        }, {
+            { AOM_CDF12(2731, 5461, 8192, 10923, 13653, 16384, 19115, 21845,
+                        24576, 27307, 30037) },
+            { AOM_CDF12(2731, 5461, 8192, 10923, 13653, 16384, 19115, 21845,
+                        24576, 27307, 30037) },
+            { AOM_CDF12(770, 2421, 5225, 12907, 15819, 18927, 21561, 24089,
+                        26595, 28526, 30529) },
+            { AOM_CDF12(2731, 5461, 8192, 10923, 13653, 16384, 19115, 21845,
+                        24576, 27307, 30037) },
+        }, {
+            { AOM_CDF2(16384) },
+            { AOM_CDF2(4167) },
+            { AOM_CDF2(1998) },
+            { AOM_CDF2(748) },
+        },
+    }, .txtp_intra = {
+        {}, {
+            {
+                { AOM_CDF7(1535, 8035, 9461, 12751, 23467, 27825) },
+                { AOM_CDF7(564, 3335, 9709, 10870, 18143, 28094) },
+                { AOM_CDF7(672, 3247, 3676, 11982, 19415, 23127) },
+                { AOM_CDF7(5279, 13885, 15487, 18044, 23527, 30252) },
+                { AOM_CDF7(4423, 6074, 7985, 10416, 25693, 29298) },
+                { AOM_CDF7(1486, 4241, 9460, 10662, 16456, 27694) },
+                { AOM_CDF7(439, 2838, 3522, 6737, 18058, 23754) },
+                { AOM_CDF7(1190, 4233, 4855, 11670, 20281, 24377) },
+                { AOM_CDF7(1045, 4312, 8647, 10159, 18644, 29335) },
+                { AOM_CDF7(202, 3734, 4747, 7298, 17127, 24016) },
+                { AOM_CDF7(447, 4312, 6819, 8884, 16010, 23858) },
+                { AOM_CDF7(277, 4369, 5255, 8905, 16465, 22271) },
+                { AOM_CDF7(3409, 5436, 10599, 15599, 19687, 24040) },
+            }, {
+                { AOM_CDF7(1870, 13742, 14530, 16498, 23770, 27698) },
+                { AOM_CDF7(326, 8796, 14632, 15079, 19272, 27486) },
+                { AOM_CDF7(484, 7576, 7712, 14443, 19159, 22591) },
+                { AOM_CDF7(1126, 15340, 15895, 17023, 20896, 30279) },
+                { AOM_CDF7(655, 4854, 5249, 5913, 22099, 27138) },
+                { AOM_CDF7(1299, 6458, 8885, 9290, 14851, 25497) },
+                { AOM_CDF7(311, 5295, 5552, 6885, 16107, 22672) },
+                { AOM_CDF7(883, 8059, 8270, 11258, 17289, 21549) },
+                { AOM_CDF7(741, 7580, 9318, 10345, 16688, 29046) },
+                { AOM_CDF7(110, 7406, 7915, 9195, 16041, 23329) },
+                { AOM_CDF7(363, 7974, 9357, 10673, 15629, 24474) },
+                { AOM_CDF7(153, 7647, 8112, 9936, 15307, 19996) },
+                { AOM_CDF7(3511, 6332, 11165, 15335, 19323, 23594) },
+            }, {
+                { AOM_CDF7(4681, 9362, 14043, 18725, 23406, 28087) },
+                { AOM_CDF7(4681, 9362, 14043, 18725, 23406, 28087) },
+                { AOM_CDF7(4681, 9362, 14043, 18725, 23406, 28087) },
+                { AOM_CDF7(4681, 9362, 14043, 18725, 23406, 28087) },
+                { AOM_CDF7(4681, 9362, 14043, 18725, 23406, 28087) },
+                { AOM_CDF7(4681, 9362, 14043, 18725, 23406, 28087) },
+                { AOM_CDF7(4681, 9362, 14043, 18725, 23406, 28087) },
+                { AOM_CDF7(4681, 9362, 14043, 18725, 23406, 28087) },
+                { AOM_CDF7(4681, 9362, 14043, 18725, 23406, 28087) },
+                { AOM_CDF7(4681, 9362, 14043, 18725, 23406, 28087) },
+                { AOM_CDF7(4681, 9362, 14043, 18725, 23406, 28087) },
+                { AOM_CDF7(4681, 9362, 14043, 18725, 23406, 28087) },
+                { AOM_CDF7(4681, 9362, 14043, 18725, 23406, 28087) },
+            }, {
+                { AOM_CDF7(4681, 9362, 14043, 18725, 23406, 28087) },
+                { AOM_CDF7(4681, 9362, 14043, 18725, 23406, 28087) },
+                { AOM_CDF7(4681, 9362, 14043, 18725, 23406, 28087) },
+                { AOM_CDF7(4681, 9362, 14043, 18725, 23406, 28087) },
+                { AOM_CDF7(4681, 9362, 14043, 18725, 23406, 28087) },
+                { AOM_CDF7(4681, 9362, 14043, 18725, 23406, 28087) },
+                { AOM_CDF7(4681, 9362, 14043, 18725, 23406, 28087) },
+                { AOM_CDF7(4681, 9362, 14043, 18725, 23406, 28087) },
+                { AOM_CDF7(4681, 9362, 14043, 18725, 23406, 28087) },
+                { AOM_CDF7(4681, 9362, 14043, 18725, 23406, 28087) },
+                { AOM_CDF7(4681, 9362, 14043, 18725, 23406, 28087) },
+                { AOM_CDF7(4681, 9362, 14043, 18725, 23406, 28087) },
+                { AOM_CDF7(4681, 9362, 14043, 18725, 23406, 28087) },
+            },
+        }, {
+            {
+                { AOM_CDF5(6554, 13107, 19661, 26214) },
+                { AOM_CDF5(6554, 13107, 19661, 26214) },
+                { AOM_CDF5(6554, 13107, 19661, 26214) },
+                { AOM_CDF5(6554, 13107, 19661, 26214) },
+                { AOM_CDF5(6554, 13107, 19661, 26214) },
+                { AOM_CDF5(6554, 13107, 19661, 26214) },
+                { AOM_CDF5(6554, 13107, 19661, 26214) },
+                { AOM_CDF5(6554, 13107, 19661, 26214) },
+                { AOM_CDF5(6554, 13107, 19661, 26214) },
+                { AOM_CDF5(6554, 13107, 19661, 26214) },
+                { AOM_CDF5(6554, 13107, 19661, 26214) },
+                { AOM_CDF5(6554, 13107, 19661, 26214) },
+                { AOM_CDF5(6554, 13107, 19661, 26214) },
+            }, {
+                { AOM_CDF5(6554, 13107, 19661, 26214) },
+                { AOM_CDF5(6554, 13107, 19661, 26214) },
+                { AOM_CDF5(6554, 13107, 19661, 26214) },
+                { AOM_CDF5(6554, 13107, 19661, 26214) },
+                { AOM_CDF5(6554, 13107, 19661, 26214) },
+                { AOM_CDF5(6554, 13107, 19661, 26214) },
+                { AOM_CDF5(6554, 13107, 19661, 26214) },
+                { AOM_CDF5(6554, 13107, 19661, 26214) },
+                { AOM_CDF5(6554, 13107, 19661, 26214) },
+                { AOM_CDF5(6554, 13107, 19661, 26214) },
+                { AOM_CDF5(6554, 13107, 19661, 26214) },
+                { AOM_CDF5(6554, 13107, 19661, 26214) },
+                { AOM_CDF5(6554, 13107, 19661, 26214) },
+            }, {
+                { AOM_CDF5(1127, 12814, 22772, 27483) },
+                { AOM_CDF5(145, 6761, 11980, 26667) },
+                { AOM_CDF5(362, 5887, 11678, 16725) },
+                { AOM_CDF5(385, 15213, 18587, 30693) },
+                { AOM_CDF5(25, 2914, 23134, 27903) },
+                { AOM_CDF5(60, 4470, 11749, 23991) },
+                { AOM_CDF5(37, 3332, 14511, 21448) },
+                { AOM_CDF5(157, 6320, 13036, 17439) },
+                { AOM_CDF5(119, 6719, 12906, 29396) },
+                { AOM_CDF5(47, 5537, 12576, 21499) },
+                { AOM_CDF5(269, 6076, 11258, 23115) },
+                { AOM_CDF5(83, 5615, 12001, 17228) },
+                { AOM_CDF5(1968, 5556, 12023, 18547) },
+            }, {
+                { AOM_CDF5(6554, 13107, 19661, 26214) },
+                { AOM_CDF5(6554, 13107, 19661, 26214) },
+                { AOM_CDF5(6554, 13107, 19661, 26214) },
+                { AOM_CDF5(6554, 13107, 19661, 26214) },
+                { AOM_CDF5(6554, 13107, 19661, 26214) },
+                { AOM_CDF5(6554, 13107, 19661, 26214) },
+                { AOM_CDF5(6554, 13107, 19661, 26214) },
+                { AOM_CDF5(6554, 13107, 19661, 26214) },
+                { AOM_CDF5(6554, 13107, 19661, 26214) },
+                { AOM_CDF5(6554, 13107, 19661, 26214) },
+                { AOM_CDF5(6554, 13107, 19661, 26214) },
+                { AOM_CDF5(6554, 13107, 19661, 26214) },
+                { AOM_CDF5(6554, 13107, 19661, 26214) },
+            },
+        },
+    }, .skip = {
+        { AOM_CDF2(31671) },
+        { AOM_CDF2(16515) },
+        { AOM_CDF2(4576) }
+    }, .skip_mode = {
+        { AOM_CDF2(32621) },
+        { AOM_CDF2(20708) },
+        { AOM_CDF2(8127) }
+    }, .partition = {
+        {
+            // 128x128 -> 64x64
+            { AOM_CDF8(27899, 28219, 28529, 32484, 32539, 32619, 32639) },
+            { AOM_CDF8(6607, 6990, 8268, 32060, 32219, 32338, 32371) },
+            { AOM_CDF8(5429, 6676, 7122, 32027, 32227, 32531, 32582) },
+            { AOM_CDF8(711, 966, 1172, 32448, 32538, 32617, 32664) },
+        }, {
+            // 64x64 -> 32x32
+            { AOM_CDF10(20137, 21547, 23078, 29566, 29837, 30261, 30524, 30892,
+                        31724) },
+            { AOM_CDF10(6732, 7490, 9497, 27944, 28250, 28515, 28969, 29630,
+                        30104) },
+            { AOM_CDF10(5945, 7663, 8348, 28683, 29117, 29749, 30064, 30298,
+                        32238) },
+            { AOM_CDF10(870, 1212, 1487, 31198, 31394, 31574, 31743, 31881,
+                        32332) },
+        }, {
+            // 32x32 -> 16x16
+            { AOM_CDF10(18462, 20920, 23124, 27647, 28227, 29049, 29519, 30178,
+                        31544) },
+            { AOM_CDF10(7689, 9060, 12056, 24992, 25660, 26182, 26951, 28041,
+                        29052) },
+            { AOM_CDF10(6015, 9009, 10062, 24544, 25409, 26545, 27071, 27526,
+                        32047) },
+            { AOM_CDF10(1394, 2208, 2796, 28614, 29061, 29466, 29840, 30185,
+                        31899) },
+        }, {
+            // 16x16 -> 8x8
+            { AOM_CDF10(15597, 20929, 24571, 26706, 27664, 28821, 29601, 30571,
+                        31902) },
+            { AOM_CDF10(7925, 11043, 16785, 22470, 23971, 25043, 26651, 28701,
+                        29834) },
+            { AOM_CDF10(5414, 13269, 15111, 20488, 22360, 24500, 25537, 26336,
+                        32117) },
+            { AOM_CDF10(2662, 6362, 8614, 20860, 23053, 24778, 26436, 27829,
+                        31171) },
+        }, {
+            // 8x8 -> 4x4 only supports the four legacy partition types
+            { AOM_CDF4(19132, 25510, 30392) },
+            { AOM_CDF4(13928, 19855, 28540) },
+            { AOM_CDF4(12522, 23679, 28629) },
+            { AOM_CDF4(9896, 18783, 25853) },
+        }
+    }, .seg_pred = {
+        { AOM_CDF2(128 * 128) },
+        { AOM_CDF2(128 * 128) },
+        { AOM_CDF2(128 * 128) }
+    }, .seg_id = {
+        { AOM_CDF8(5622, 7893, 16093, 18233, 27809, 28373, 32533), },
+        { AOM_CDF8(14274, 18230, 22557, 24935, 29980, 30851, 32344), },
+        { AOM_CDF8(27527, 28487, 28723, 28890, 32397, 32647, 32679), },
+    }, .cfl_sign = {
+        AOM_CDF8(1418, 2123, 13340, 18405, 26972, 28343, 32294)
+    }, .cfl_alpha = {
+        { AOM_CDF16(7637, 20719, 31401, 32481, 32657, 32688, 32692, 32696,
+                    32700, 32704, 32708, 32712, 32716, 32720, 32724) },
+        { AOM_CDF16(14365, 23603, 28135, 31168, 32167, 32395, 32487, 32573,
+                    32620, 32647, 32668, 32672, 32676, 32680, 32684) },
+        { AOM_CDF16(11532, 22380, 28445, 31360, 32349, 32523, 32584, 32649,
+                    32673, 32677, 32681, 32685, 32689, 32693, 32697) },
+        { AOM_CDF16(26990, 31402, 32282, 32571, 32692, 32696, 32700, 32704,
+                    32708, 32712, 32716, 32720, 32724, 32728, 32732) },
+        { AOM_CDF16(17248, 26058, 28904, 30608, 31305, 31877, 32126, 32321,
+                    32394, 32464, 32516, 32560, 32576, 32593, 32622) },
+        { AOM_CDF16(14738, 21678, 25779, 27901, 29024, 30302, 30980, 31843,
+                    32144, 32413, 32520, 32594, 32622, 32656, 32660) }
+    }, .restore_wiener = {
+        AOM_CDF2(11570)
+    }, .restore_sgrproj = {
+        AOM_CDF2(16855)
+    }, .restore_switchable = {
+        AOM_CDF3(9413, 22581)
+    }, .delta_q = {
+        AOM_CDF4(28160, 32120, 32677)
+    }, .delta_lf = {
+        { AOM_CDF4(28160, 32120, 32677) },
+        { AOM_CDF4(28160, 32120, 32677) },
+        { AOM_CDF4(28160, 32120, 32677) },
+        { AOM_CDF4(28160, 32120, 32677) },
+        { AOM_CDF4(28160, 32120, 32677) },
+    }, .motion_mode = {
+        [BS_8x8]     = { AOM_CDF3(7651, 24760) },
+        [BS_8x16]    = { AOM_CDF3(4738, 24765) },
+        [BS_8x32]    = { AOM_CDF3(28799, 31390) },
+        [BS_16x8]    = { AOM_CDF3(5391, 25528) },
+        [BS_16x16]   = { AOM_CDF3(19419, 26810) },
+        [BS_16x32]   = { AOM_CDF3(5123, 23606) },
+        [BS_16x64]   = { AOM_CDF3(28973, 31594) },
+        [BS_32x8]    = { AOM_CDF3(26431, 30774) },
+        [BS_32x16]   = { AOM_CDF3(11606, 24308) },
+        [BS_32x32]   = { AOM_CDF3(26260, 29116) },
+        [BS_32x64]   = { AOM_CDF3(20360, 28062) },
+        [BS_64x16]   = { AOM_CDF3(29742, 31203) },
+        [BS_64x32]   = { AOM_CDF3(21679, 26830) },
+        [BS_64x64]   = { AOM_CDF3(29516, 30701) },
+        [BS_64x128]  = { AOM_CDF3(28898, 30397) },
+        [BS_128x64]  = { AOM_CDF3(30878, 31335) },
+        [BS_128x128] = { AOM_CDF3(32507, 32558) },
+    }, .obmc = {
+        [BS_8x8]     = { AOM_CDF2(10437) },
+        [BS_8x16]    = { AOM_CDF2(9371) },
+        [BS_8x32]    = { AOM_CDF2(23664) },
+        [BS_16x8]    = { AOM_CDF2(9301) },
+        [BS_16x16]   = { AOM_CDF2(17432) },
+        [BS_16x32]   = { AOM_CDF2(14423) },
+        [BS_16x64]   = { AOM_CDF2(24008) },
+        [BS_32x8]    = { AOM_CDF2(20901) },
+        [BS_32x16]   = { AOM_CDF2(15142) },
+        [BS_32x32]   = { AOM_CDF2(25817) },
+        [BS_32x64]   = { AOM_CDF2(22823) },
+        [BS_64x16]   = { AOM_CDF2(26879) },
+        [BS_64x32]   = { AOM_CDF2(22083) },
+        [BS_64x64]   = { AOM_CDF2(30128) },
+        [BS_64x128]  = { AOM_CDF2(31014) },
+        [BS_128x64]  = { AOM_CDF2(31560) },
+        [BS_128x128] = { AOM_CDF2(32638) },
+    }, .pal_y = {
+        { { AOM_CDF2(31676) }, { AOM_CDF2(3419) }, { AOM_CDF2(1261) } },
+        { { AOM_CDF2(31912) }, { AOM_CDF2(2859) }, { AOM_CDF2(980) } },
+        { { AOM_CDF2(31823) }, { AOM_CDF2(3400) }, { AOM_CDF2(781) } },
+        { { AOM_CDF2(32030) }, { AOM_CDF2(3561) }, { AOM_CDF2(904) } },
+        { { AOM_CDF2(32309) }, { AOM_CDF2(7337) }, { AOM_CDF2(1462) } },
+        { { AOM_CDF2(32265) }, { AOM_CDF2(4015) }, { AOM_CDF2(1521) } },
+        { { AOM_CDF2(32450) }, { AOM_CDF2(7946) }, { AOM_CDF2(129) } },
+    }, .pal_sz = {
+        {
+            { AOM_CDF7(7952, 13000, 18149, 21478, 25527, 29241) },
+            { AOM_CDF7(7139, 11421, 16195, 19544, 23666, 28073) },
+            { AOM_CDF7(7788, 12741, 17325, 20500, 24315, 28530) },
+            { AOM_CDF7(8271, 14064, 18246, 21564, 25071, 28533) },
+            { AOM_CDF7(12725, 19180, 21863, 24839, 27535, 30120) },
+            { AOM_CDF7(9711, 14888, 16923, 21052, 25661, 27875) },
+            { AOM_CDF7(14940, 20797, 21678, 24186, 27033, 28999) },
+        }, {
+            { AOM_CDF7(8713, 19979, 27128, 29609, 31331, 32272) },
+            { AOM_CDF7(5839, 15573, 23581, 26947, 29848, 31700) },
+            { AOM_CDF7(4426, 11260, 17999, 21483, 25863, 29430) },
+            { AOM_CDF7(3228, 9464, 14993, 18089, 22523, 27420) },
+            { AOM_CDF7(3768, 8886, 13091, 17852, 22495, 27207) },
+            { AOM_CDF7(2464, 8451, 12861, 21632, 25525, 28555) },
+            { AOM_CDF7(1269, 5435, 10433, 18963, 21700, 25865) },
+        }
+    }, .pal_uv = {
+        { AOM_CDF2(32461) }, { AOM_CDF2(21488) },
+    }, .color_map = {
+        { /* y */
+            {
+                { AOM_CDF2(28710) },
+                { AOM_CDF2(16384) },
+                { AOM_CDF2(10553) },
+                { AOM_CDF2(27036) },
+                { AOM_CDF2(31603) },
+            }, {
+                { AOM_CDF3(27877, 30490) },
+                { AOM_CDF3(11532, 25697) },
+                { AOM_CDF3(6544, 30234) },
+                { AOM_CDF3(23018, 28072) },
+                { AOM_CDF3(31915, 32385) },
+            }, {
+                { AOM_CDF4(25572, 28046, 30045) },
+                { AOM_CDF4(9478, 21590, 27256) },
+                { AOM_CDF4(7248, 26837, 29824) },
+                { AOM_CDF4(19167, 24486, 28349) },
+                { AOM_CDF4(31400, 31825, 32250) },
+            }, {
+                { AOM_CDF5(24779, 26955, 28576, 30282) },
+                { AOM_CDF5(8669, 20364, 24073, 28093) },
+                { AOM_CDF5(4255, 27565, 29377, 31067) },
+                { AOM_CDF5(19864, 23674, 26716, 29530) },
+                { AOM_CDF5(31646, 31893, 32147, 32426) },
+            }, {
+                { AOM_CDF6(23132, 25407, 26970, 28435, 30073) },
+                { AOM_CDF6(7443, 17242, 20717, 24762, 27982) },
+                { AOM_CDF6(6300, 24862, 26944, 28784, 30671) },
+                { AOM_CDF6(18916, 22895, 25267, 27435, 29652) },
+                { AOM_CDF6(31270, 31550, 31808, 32059, 32353) },
+            }, {
+                { AOM_CDF7(23105, 25199, 26464, 27684, 28931, 30318) },
+                { AOM_CDF7(6950, 15447, 18952, 22681, 25567, 28563) },
+                { AOM_CDF7(7560, 23474, 25490, 27203, 28921, 30708) },
+                { AOM_CDF7(18544, 22373, 24457, 26195, 28119, 30045) },
+                { AOM_CDF7(31198, 31451, 31670, 31882, 32123, 32391) },
+            }, {
+                { AOM_CDF8(21689, 23883, 25163, 26352, 27506, 28827, 30195) },
+                { AOM_CDF8(6892, 15385, 17840, 21606, 24287, 26753, 29204) },
+                { AOM_CDF8(5651, 23182, 25042, 26518, 27982, 29392, 30900) },
+                { AOM_CDF8(19349, 22578, 24418, 25994, 27524, 29031, 30448) },
+                { AOM_CDF8(31028, 31270, 31504, 31705, 31927, 32153, 32392) },
+            },
+        }, { /* uv */
+            {
+                { AOM_CDF2(29089) },
+                { AOM_CDF2(16384) },
+                { AOM_CDF2(8713) },
+                { AOM_CDF2(29257) },
+                { AOM_CDF2(31610) },
+            }, {
+                { AOM_CDF3(25257, 29145) },
+                { AOM_CDF3(12287, 27293) },
+                { AOM_CDF3(7033, 27960) },
+                { AOM_CDF3(20145, 25405) },
+                { AOM_CDF3(30608, 31639) },
+            }, {
+                { AOM_CDF4(24210, 27175, 29903) },
+                { AOM_CDF4(9888, 22386, 27214) },
+                { AOM_CDF4(5901, 26053, 29293) },
+                { AOM_CDF4(18318, 22152, 28333) },
+                { AOM_CDF4(30459, 31136, 31926) },
+            }, {
+                { AOM_CDF5(22980, 25479, 27781, 29986) },
+                { AOM_CDF5(8413, 21408, 24859, 28874) },
+                { AOM_CDF5(2257, 29449, 30594, 31598) },
+                { AOM_CDF5(19189, 21202, 25915, 28620) },
+                { AOM_CDF5(31844, 32044, 32281, 32518) },
+            }, {
+                { AOM_CDF6(22217, 24567, 26637, 28683, 30548) },
+                { AOM_CDF6(7307, 16406, 19636, 24632, 28424) },
+                { AOM_CDF6(4441, 25064, 26879, 28942, 30919) },
+                { AOM_CDF6(17210, 20528, 23319, 26750, 29582) },
+                { AOM_CDF6(30674, 30953, 31396, 31735, 32207) },
+            }, {
+                { AOM_CDF7(21239, 23168, 25044, 26962, 28705, 30506) },
+                { AOM_CDF7(6545, 15012, 18004, 21817, 25503, 28701) },
+                { AOM_CDF7(3448, 26295, 27437, 28704, 30126, 31442) },
+                { AOM_CDF7(15889, 18323, 21704, 24698, 26976, 29690) },
+                { AOM_CDF7(30988, 31204, 31479, 31734, 31983, 32325) },
+            }, {
+                { AOM_CDF8(21442, 23288, 24758, 26246, 27649, 28980, 30563) },
+                { AOM_CDF8(5863, 14933, 17552, 20668, 23683, 26411, 29273) },
+                { AOM_CDF8(3415, 25810, 26877, 27990, 29223, 30394, 31618) },
+                { AOM_CDF8(17965, 20084, 22232, 23974, 26274, 28402, 30390) },
+                { AOM_CDF8(31190, 31329, 31516, 31679, 31825, 32026, 32322) },
+            },
+        },
+    }, .intrabc = {
+        AOM_CDF2(30531)
+    },
+};
+
+static const CdfMvContext default_mv_cdf = {
+    .comp = {
+        { /* mv vertical component */
+            .classes = {
+                AOM_CDF11(28672, 30976, 31858, 32320, 32551, 32656, 32740,
+                          32757, 32762, 32767)
+            }, .class0 = {
+                AOM_CDF2(216 * 128)
+            }, .classN = {
+                { AOM_CDF2(128 * 136) },
+                { AOM_CDF2(128 * 140) },
+                { AOM_CDF2(128 * 148) },
+                { AOM_CDF2(128 * 160) },
+                { AOM_CDF2(128 * 176) },
+                { AOM_CDF2(128 * 192) },
+                { AOM_CDF2(128 * 224) },
+                { AOM_CDF2(128 * 234) },
+                { AOM_CDF2(128 * 234) },
+                { AOM_CDF2(128 * 240) }
+            }, .class0_fp = {
+                { AOM_CDF4(16384, 24576, 26624) },
+                { AOM_CDF4(12288, 21248, 24128) }
+            }, .classN_fp = {
+                AOM_CDF4(8192, 17408, 21248)
+            }, .class0_hp = {
+                AOM_CDF2(160 * 128)
+            }, .classN_hp = {
+                AOM_CDF2(128 * 128)
+            }, .sign = {
+                AOM_CDF2(128 * 128)
+            }
+        }, { /* mv horizontal component */
+            .classes = {
+                AOM_CDF11(28672, 30976, 31858, 32320, 32551, 32656, 32740,
+                          32757, 32762, 32767)
+            }, .class0 = {
+                AOM_CDF2(216 * 128)
+            }, .classN = {
+                { AOM_CDF2(128 * 136) },
+                { AOM_CDF2(128 * 140) },
+                { AOM_CDF2(128 * 148) },
+                { AOM_CDF2(128 * 160) },
+                { AOM_CDF2(128 * 176) },
+                { AOM_CDF2(128 * 192) },
+                { AOM_CDF2(128 * 224) },
+                { AOM_CDF2(128 * 234) },
+                { AOM_CDF2(128 * 234) },
+                { AOM_CDF2(128 * 240) }
+            }, .class0_fp = {
+                { AOM_CDF4(16384, 24576, 26624) },
+                { AOM_CDF4(12288, 21248, 24128) }
+            }, .classN_fp = {
+                AOM_CDF4(8192, 17408, 21248)
+            }, .class0_hp = {
+                AOM_CDF2(160 * 128)
+            }, .classN_hp = {
+                AOM_CDF2(128 * 128)
+            }, .sign = {
+                AOM_CDF2(128 * 128)
+            },
+        }
+    }, .joint = {
+        AOM_CDF4(4096, 11264, 19328)
+    }
+};
+
+static const uint16_t default_kf_y_mode_cdf[5][5][N_INTRA_PRED_MODES + 1] = {
+    {
+        { AOM_CDF13(15588, 17027, 19338, 20218, 20682, 21110, 21825, 23244,
+                    24189, 28165, 29093, 30466) },
+        { AOM_CDF13(12016, 18066, 19516, 20303, 20719, 21444, 21888, 23032,
+                    24434, 28658, 30172, 31409) },
+        { AOM_CDF13(10052, 10771, 22296, 22788, 23055, 23239, 24133, 25620,
+                    26160, 29336, 29929, 31567) },
+        { AOM_CDF13(14091, 15406, 16442, 18808, 19136, 19546, 19998, 22096,
+                    24746, 29585, 30958, 32462) },
+        { AOM_CDF13(12122, 13265, 15603, 16501, 18609, 20033, 22391, 25583,
+                    26437, 30261, 31073, 32475) }
+    }, {
+        { AOM_CDF13(10023, 19585, 20848, 21440, 21832, 22760, 23089, 24023,
+                  25381, 29014, 30482, 31436) },
+        { AOM_CDF13(5983, 24099, 24560, 24886, 25066, 25795, 25913, 26423,
+                    27610, 29905, 31276, 31794) },
+        { AOM_CDF13(7444, 12781, 20177, 20728, 21077, 21607, 22170, 23405,
+                    24469, 27915, 29090, 30492) },
+        { AOM_CDF13(8537, 14689, 15432, 17087, 17408, 18172, 18408, 19825,
+                    24649, 29153, 31096, 32210) },
+        { AOM_CDF13(7543, 14231, 15496, 16195, 17905, 20717, 21984, 24516,
+                    26001, 29675, 30981, 31994) }
+    }, {
+        { AOM_CDF13(12613, 13591, 21383, 22004, 22312, 22577, 23401, 25055,
+                  25729, 29538, 30305, 32077) },
+        { AOM_CDF13(9687, 13470, 18506, 19230, 19604, 20147, 20695, 22062,
+                    23219, 27743, 29211, 30907) },
+        { AOM_CDF13(6183, 6505, 26024, 26252, 26366, 26434, 27082, 28354,
+                    28555, 30467, 30794, 32086) },
+        { AOM_CDF13(10718, 11734, 14954, 17224, 17565, 17924, 18561, 21523,
+                    23878, 28975, 30287, 32252) },
+        { AOM_CDF13(9194, 9858, 16501, 17263, 18424, 19171, 21563, 25961,
+                    26561, 30072, 30737, 32463) }
+    }, {
+        { AOM_CDF13(12602, 14399, 15488, 18381, 18778, 19315, 19724, 21419,
+                  25060, 29696, 30917, 32409) },
+        { AOM_CDF13(8203, 13821, 14524, 17105, 17439, 18131, 18404, 19468,
+                    25225, 29485, 31158, 32342) },
+        { AOM_CDF13(8451, 9731, 15004, 17643, 18012, 18425, 19070, 21538,
+                    24605, 29118, 30078, 32018) },
+        { AOM_CDF13(7714, 9048, 9516, 16667, 16817, 16994, 17153, 18767,
+                    26743, 30389, 31536, 32528) },
+        { AOM_CDF13(8843, 10280, 11496, 15317, 16652, 17943, 19108, 22718,
+                    25769, 29953, 30983, 32485) }
+    }, {
+        { AOM_CDF13(12578, 13671, 15979, 16834, 19075, 20913, 22989, 25449,
+                  26219, 30214, 31150, 32477) },
+        { AOM_CDF13(9563, 13626, 15080, 15892, 17756, 20863, 22207, 24236,
+                    25380, 29653, 31143, 32277) },
+        { AOM_CDF13(8356, 8901, 17616, 18256, 19350, 20106, 22598, 25947,
+                    26466, 29900, 30523, 32261) },
+        { AOM_CDF13(10835, 11815, 13124, 16042, 17018, 18039, 18947, 22753,
+                    24615, 29489, 30883, 32482) },
+        { AOM_CDF13(7618, 8288, 9859, 10509, 15386, 18657, 22903, 28776,
+                    29180, 31355, 31802, 32593) }
+    }
+};
+
+static const CdfCoefContext av1_default_coef_cdf[4] = {
+    [0] = {
+        .skip = {
+            { { AOM_CDF2(31849) },
+                { AOM_CDF2(5892) },
+                { AOM_CDF2(12112) },
+                { AOM_CDF2(21935) },
+                { AOM_CDF2(20289) },
+                { AOM_CDF2(27473) },
+                { AOM_CDF2(32487) },
+                { AOM_CDF2(7654) },
+                { AOM_CDF2(19473) },
+                { AOM_CDF2(29984) },
+                { AOM_CDF2(9961) },
+                { AOM_CDF2(30242) },
+                { AOM_CDF2(32117) } },
+            { { AOM_CDF2(31548) },
+                { AOM_CDF2(1549) },
+                { AOM_CDF2(10130) },
+                { AOM_CDF2(16656) },
+                { AOM_CDF2(18591) },
+                { AOM_CDF2(26308) },
+                { AOM_CDF2(32537) },
+                { AOM_CDF2(5403) },
+                { AOM_CDF2(18096) },
+                { AOM_CDF2(30003) },
+                { AOM_CDF2(16384) },
+                { AOM_CDF2(16384) },
+                { AOM_CDF2(16384) } },
+            { { AOM_CDF2(29957) },
+                { AOM_CDF2(5391) },
+                { AOM_CDF2(18039) },
+                { AOM_CDF2(23566) },
+                { AOM_CDF2(22431) },
+                { AOM_CDF2(25822) },
+                { AOM_CDF2(32197) },
+                { AOM_CDF2(3778) },
+                { AOM_CDF2(15336) },
+                { AOM_CDF2(28981) },
+                { AOM_CDF2(16384) },
+                { AOM_CDF2(16384) },
+                { AOM_CDF2(16384) } },
+            { { AOM_CDF2(17920) },
+                { AOM_CDF2(1818) },
+                { AOM_CDF2(7282) },
+                { AOM_CDF2(25273) },
+                { AOM_CDF2(10923) },
+                { AOM_CDF2(31554) },
+                { AOM_CDF2(32624) },
+                { AOM_CDF2(1366) },
+                { AOM_CDF2(15628) },
+                { AOM_CDF2(30462) },
+                { AOM_CDF2(146) },
+                { AOM_CDF2(5132) },
+                { AOM_CDF2(31657) } },
+            { { AOM_CDF2(6308) },
+                { AOM_CDF2(117) },
+                { AOM_CDF2(1638) },
+                { AOM_CDF2(2161) },
+                { AOM_CDF2(16384) },
+                { AOM_CDF2(10923) },
+                { AOM_CDF2(30247) },
+                { AOM_CDF2(16384) },
+                { AOM_CDF2(16384) },
+                { AOM_CDF2(16384) },
+                { AOM_CDF2(16384) },
+                { AOM_CDF2(16384) },
+                { AOM_CDF2(16384) } }
+        }, .eob_bin_16 = {
+            { { AOM_CDF5(840, 1039, 1980, 4895) },
+              { AOM_CDF5(370, 671, 1883, 4471) } },
+            { { AOM_CDF5(3247, 4950, 9688, 14563) },
+              { AOM_CDF5(1904, 3354, 7763, 14647) } }
+        }, .eob_bin_32 = {
+            { { AOM_CDF6(400, 520, 977, 2102, 6542) },
+              { AOM_CDF6(210, 405, 1315, 3326, 7537) } },
+            { { AOM_CDF6(2636, 4273, 7588, 11794, 20401) },
+              { AOM_CDF6(1786, 3179, 6902, 11357, 19054) } }
+        }, .eob_bin_64 = {
+            { { AOM_CDF7(329, 498, 1101, 1784, 3265, 7758) },
+              { AOM_CDF7(335, 730, 1459, 5494, 8755, 12997) } },
+            { { AOM_CDF7(3505, 5304, 10086, 13814, 17684, 23370) },
+              { AOM_CDF7(1563, 2700, 4876, 10911, 14706, 22480) } }
+        }, .eob_bin_128 = {
+            { { AOM_CDF8(219, 482, 1140, 2091, 3680, 6028, 12586) },
+              { AOM_CDF8(371, 699, 1254, 4830, 9479, 12562, 17497) } },
+            { { AOM_CDF8(5245, 7456, 12880, 15852, 20033, 23932, 27608) },
+              { AOM_CDF8(2054, 3472, 5869, 14232, 18242, 20590, 26752) } }
+        }, .eob_bin_256 = {
+            { { AOM_CDF9(310, 584, 1887, 3589, 6168, 8611, 11352, 15652) },
+              { AOM_CDF9(998, 1850, 2998, 5604, 17341, 19888, 22899, 25583) } },
+            { { AOM_CDF9(2520, 3240, 5952, 8870, 12577, 17558, 19954, 24168) },
+              { AOM_CDF9(2203, 4130, 7435, 10739, 20652, 23681, 25609, 27261) } }
+        }, .eob_bin_512 = {
+            { { AOM_CDF10(641, 983, 3707, 5430, 10234, 14958, 18788,
+                          23412, 26061) },
+              { AOM_CDF10(3277, 6554, 9830, 13107, 16384, 19661, 22938,
+                          26214, 29491) } },
+            { { AOM_CDF10(5095, 6446, 9996, 13354, 16017, 17986, 20919,
+                          26129, 29140) },
+              { AOM_CDF10(3277, 6554, 9830, 13107, 16384, 19661, 22938,
+                          26214, 29491) } }
+        }, .eob_bin_1024 = {
+            { { AOM_CDF11(393, 421, 751, 1623, 3160, 6352, 13345, 18047,
+                          22571, 25830) },
+              { AOM_CDF11(2979, 5958, 8937, 11916, 14895, 17873, 20852,
+                          23831, 26810, 29789) } },
+            { { AOM_CDF11(1865, 1988, 2930, 4242, 10533, 16538, 21354,
+                          27255, 28546, 31784) },
+              { AOM_CDF11(2979, 5958, 8937, 11916, 14895, 17873, 20852,
+                          23831, 26810, 29789) } }
+        }, .eob_hi_bit = {
+            { { { AOM_CDF2(16384) }, { AOM_CDF2(16384) },
+                { AOM_CDF2(16961) }, { AOM_CDF2(17223) }, { AOM_CDF2(7621) },
+                { AOM_CDF2(16384) }, { AOM_CDF2(16384) }, { AOM_CDF2(16384) },
+                { AOM_CDF2(16384) }, { AOM_CDF2(16384) }, { AOM_CDF2(16384) } },
+              { { AOM_CDF2(16384) }, { AOM_CDF2(16384) },
+                { AOM_CDF2(19069) }, { AOM_CDF2(22525) }, { AOM_CDF2(13377) },
+                { AOM_CDF2(16384) }, { AOM_CDF2(16384) }, { AOM_CDF2(16384) },
+                { AOM_CDF2(16384) }, { AOM_CDF2(16384) }, { AOM_CDF2(16384) } } },
+            { { { AOM_CDF2(16384) }, { AOM_CDF2(16384) },
+                { AOM_CDF2(20401) }, { AOM_CDF2(17025) }, { AOM_CDF2(12845) },
+                { AOM_CDF2(12873) }, { AOM_CDF2(14094) }, { AOM_CDF2(16384) },
+                { AOM_CDF2(16384) }, { AOM_CDF2(16384) }, { AOM_CDF2(16384) } },
+              { { AOM_CDF2(16384) }, { AOM_CDF2(16384) },
+                { AOM_CDF2(20681) }, { AOM_CDF2(20701) }, { AOM_CDF2(15250) },
+                { AOM_CDF2(15017) }, { AOM_CDF2(14928) }, { AOM_CDF2(16384) },
+                { AOM_CDF2(16384) }, { AOM_CDF2(16384) }, { AOM_CDF2(16384) } } },
+            { { { AOM_CDF2(16384) }, { AOM_CDF2(16384) },
+                { AOM_CDF2(23905) }, { AOM_CDF2(17194) }, { AOM_CDF2(16170) },
+                { AOM_CDF2(17695) }, { AOM_CDF2(13826) }, { AOM_CDF2(15810) },
+                { AOM_CDF2(12036) }, { AOM_CDF2(16384) }, { AOM_CDF2(16384) } },
+              { { AOM_CDF2(16384) }, { AOM_CDF2(16384) },
+                { AOM_CDF2(23959) }, { AOM_CDF2(20799) }, { AOM_CDF2(19021) },
+                { AOM_CDF2(16203) }, { AOM_CDF2(17886) }, { AOM_CDF2(14144) },
+                { AOM_CDF2(12010) }, { AOM_CDF2(16384) }, { AOM_CDF2(16384) } } },
+            { { { AOM_CDF2(16384) }, { AOM_CDF2(16384) },
+                { AOM_CDF2(27399) }, { AOM_CDF2(16327) }, { AOM_CDF2(18071) },
+                { AOM_CDF2(19584) }, { AOM_CDF2(20721) }, { AOM_CDF2(18432) },
+                { AOM_CDF2(19560) }, { AOM_CDF2(10150) }, { AOM_CDF2(8805) } },
+              { { AOM_CDF2(16384) }, { AOM_CDF2(16384) },
+                { AOM_CDF2(24932) }, { AOM_CDF2(20833) }, { AOM_CDF2(12027) },
+                { AOM_CDF2(16670) }, { AOM_CDF2(19914) }, { AOM_CDF2(15106) },
+                { AOM_CDF2(17662) }, { AOM_CDF2(13783) }, { AOM_CDF2(28756) } } },
+            { { { AOM_CDF2(16384) }, { AOM_CDF2(16384) },
+                { AOM_CDF2(23406) }, { AOM_CDF2(21845) }, { AOM_CDF2(18432) },
+                { AOM_CDF2(16384) }, { AOM_CDF2(17096) }, { AOM_CDF2(12561) },
+                { AOM_CDF2(17320) }, { AOM_CDF2(22395) }, { AOM_CDF2(21370) } },
+              { { AOM_CDF2(16384) }, { AOM_CDF2(16384) },
+                { AOM_CDF2(16384) }, { AOM_CDF2(16384) }, { AOM_CDF2(16384) },
+                { AOM_CDF2(16384) }, { AOM_CDF2(16384) }, { AOM_CDF2(16384) },
+                { AOM_CDF2(16384) }, { AOM_CDF2(16384) }, { AOM_CDF2(16384) } } }
+        }, .eob_base_tok = {
+            { { { AOM_CDF3(17837, 29055) },
+                { AOM_CDF3(29600, 31446) },
+                { AOM_CDF3(30844, 31878) },
+                { AOM_CDF3(24926, 28948) } },
+             { { AOM_CDF3(21365, 30026) },
+                { AOM_CDF3(30512, 32423) },
+                { AOM_CDF3(31658, 32621) },
+                { AOM_CDF3(29630, 31881) } } },
+            { { { AOM_CDF3(5717, 26477) },
+                { AOM_CDF3(30491, 31703) },
+                { AOM_CDF3(31550, 32158) },
+                { AOM_CDF3(29648, 31491) } },
+              { { AOM_CDF3(12608, 27820) },
+                { AOM_CDF3(30680, 32225) },
+                { AOM_CDF3(30809, 32335) },
+                { AOM_CDF3(31299, 32423) } } },
+            { { { AOM_CDF3(1786, 12612) },
+                { AOM_CDF3(30663, 31625) },
+                { AOM_CDF3(32339, 32468) },
+                { AOM_CDF3(31148, 31833) } },
+              { { AOM_CDF3(18857, 23865) },
+                { AOM_CDF3(31428, 32428) },
+                { AOM_CDF3(31744, 32373) },
+                { AOM_CDF3(31775, 32526) } } },
+            { { { AOM_CDF3(1787, 2532) },
+                { AOM_CDF3(30832, 31662) },
+                { AOM_CDF3(31824, 32682) },
+                { AOM_CDF3(32133, 32569) } },
+              { { AOM_CDF3(13751, 22235) },
+                { AOM_CDF3(32089, 32409) },
+                { AOM_CDF3(27084, 27920) },
+                { AOM_CDF3(29291, 32594) } } },
+            { { { AOM_CDF3(1725, 3449) },
+                { AOM_CDF3(31102, 31935) },
+                { AOM_CDF3(32457, 32613) },
+                { AOM_CDF3(32412, 32649) } },
+              { { AOM_CDF3(10923, 21845) },
+                { AOM_CDF3(10923, 21845) },
+                { AOM_CDF3(10923, 21845) },
+                { AOM_CDF3(10923, 21845) } } }
+        }, .base_tok = {
+            { { { AOM_CDF4(4034, 8930, 12727) },
+                { AOM_CDF4(18082, 29741, 31877) },
+                { AOM_CDF4(12596, 26124, 30493) },
+                { AOM_CDF4(9446, 21118, 27005) },
+                { AOM_CDF4(6308, 15141, 21279) },
+                { AOM_CDF4(2463, 6357, 9783) },
+                { AOM_CDF4(20667, 30546, 31929) },
+                { AOM_CDF4(13043, 26123, 30134) },
+                { AOM_CDF4(8151, 18757, 24778) },
+                { AOM_CDF4(5255, 12839, 18632) },
+                { AOM_CDF4(2820, 7206, 11161) },
+                { AOM_CDF4(8192, 16384, 24576) },
+                { AOM_CDF4(8192, 16384, 24576) },
+                { AOM_CDF4(8192, 16384, 24576) },
+                { AOM_CDF4(8192, 16384, 24576) },
+                { AOM_CDF4(8192, 16384, 24576) },
+                { AOM_CDF4(8192, 16384, 24576) },
+                { AOM_CDF4(8192, 16384, 24576) },
+                { AOM_CDF4(8192, 16384, 24576) },
+                { AOM_CDF4(8192, 16384, 24576) },
+                { AOM_CDF4(8192, 16384, 24576) },
+                { AOM_CDF4(15736, 27553, 30604) },
+                { AOM_CDF4(11210, 23794, 28787) },
+                { AOM_CDF4(5947, 13874, 19701) },
+                { AOM_CDF4(4215, 9323, 13891) },
+                { AOM_CDF4(2833, 6462, 10059) },
+                { AOM_CDF4(19605, 30393, 31582) },
+                { AOM_CDF4(13523, 26252, 30248) },
+                { AOM_CDF4(8446, 18622, 24512) },
+                { AOM_CDF4(3818, 10343, 15974) },
+                { AOM_CDF4(1481, 4117, 6796) },
+                { AOM_CDF4(22649, 31302, 32190) },
+                { AOM_CDF4(14829, 27127, 30449) },
+                { AOM_CDF4(8313, 17702, 23304) },
+                { AOM_CDF4(3022, 8301, 12786) },
+                { AOM_CDF4(1536, 4412, 7184) },
+                { AOM_CDF4(22354, 29774, 31372) },
+                { AOM_CDF4(14723, 25472, 29214) },
+                { AOM_CDF4(6673, 13745, 18662) },
+                { AOM_CDF4(2068, 5766, 9322) },
+                { AOM_CDF4(8192, 16384, 24576) } },
+              { { AOM_CDF4(6302, 16444, 21761) },
+                { AOM_CDF4(23040, 31538, 32475) },
+                { AOM_CDF4(15196, 28452, 31496) },
+                { AOM_CDF4(10020, 22946, 28514) },
+                { AOM_CDF4(6533, 16862, 23501) },
+                { AOM_CDF4(3538, 9816, 15076) },
+                { AOM_CDF4(24444, 31875, 32525) },
+                { AOM_CDF4(15881, 28924, 31635) },
+                { AOM_CDF4(9922, 22873, 28466) },
+                { AOM_CDF4(6527, 16966, 23691) },
+                { AOM_CDF4(4114, 11303, 17220) },
+                { AOM_CDF4(8192, 16384, 24576) },
+                { AOM_CDF4(8192, 16384, 24576) },
+                { AOM_CDF4(8192, 16384, 24576) },
+                { AOM_CDF4(8192, 16384, 24576) },
+                { AOM_CDF4(8192, 16384, 24576) },
+                { AOM_CDF4(8192, 16384, 24576) },
+                { AOM_CDF4(8192, 16384, 24576) },
+                { AOM_CDF4(8192, 16384, 24576) },
+                { AOM_CDF4(8192, 16384, 24576) },
+                { AOM_CDF4(8192, 16384, 24576) },
+                { AOM_CDF4(20201, 30770, 32209) },
+                { AOM_CDF4(14754, 28071, 31258) },
+                { AOM_CDF4(8378, 20186, 26517) },
+                { AOM_CDF4(5916, 15299, 21978) },
+                { AOM_CDF4(4268, 11583, 17901) },
+                { AOM_CDF4(24361, 32025, 32581) },
+                { AOM_CDF4(18673, 30105, 31943) },
+                { AOM_CDF4(10196, 22244, 27576) },
+                { AOM_CDF4(5495, 14349, 20417) },
+                { AOM_CDF4(2676, 7415, 11498) },
+                { AOM_CDF4(24678, 31958, 32585) },
+                { AOM_CDF4(18629, 29906, 31831) },
+                { AOM_CDF4(9364, 20724, 26315) },
+                { AOM_CDF4(4641, 12318, 18094) },
+                { AOM_CDF4(2758, 7387, 11579) },
+                { AOM_CDF4(25433, 31842, 32469) },
+                { AOM_CDF4(18795, 29289, 31411) },
+                { AOM_CDF4(7644, 17584, 23592) },
+                { AOM_CDF4(3408, 9014, 15047) },
+                { AOM_CDF4(8192, 16384, 24576) } } },
+            { { { AOM_CDF4(4536, 10072, 14001) },
+                { AOM_CDF4(25459, 31416, 32206) },
+                { AOM_CDF4(16605, 28048, 30818) },
+                { AOM_CDF4(11008, 22857, 27719) },
+                { AOM_CDF4(6915, 16268, 22315) },
+                { AOM_CDF4(2625, 6812, 10537) },
+                { AOM_CDF4(24257, 31788, 32499) },
+                { AOM_CDF4(16880, 29454, 31879) },
+                { AOM_CDF4(11958, 25054, 29778) },
+                { AOM_CDF4(7916, 18718, 25084) },
+                { AOM_CDF4(3383, 8777, 13446) },
+                { AOM_CDF4(22720, 31603, 32393) },
+                { AOM_CDF4(14960, 28125, 31335) },
+                { AOM_CDF4(9731, 22210, 27928) },
+                { AOM_CDF4(6304, 15832, 22277) },
+                { AOM_CDF4(2910, 7818, 12166) },
+                { AOM_CDF4(20375, 30627, 32131) },
+                { AOM_CDF4(13904, 27284, 30887) },
+                { AOM_CDF4(9368, 21558, 27144) },
+                { AOM_CDF4(5937, 14966, 21119) },
+                { AOM_CDF4(2667, 7225, 11319) },
+                { AOM_CDF4(23970, 31470, 32378) },
+                { AOM_CDF4(17173, 29734, 32018) },
+                { AOM_CDF4(12795, 25441, 29965) },
+                { AOM_CDF4(8981, 19680, 25893) },
+                { AOM_CDF4(4728, 11372, 16902) },
+                { AOM_CDF4(24287, 31797, 32439) },
+                { AOM_CDF4(16703, 29145, 31696) },
+                { AOM_CDF4(10833, 23554, 28725) },
+                { AOM_CDF4(6468, 16566, 23057) },
+                { AOM_CDF4(2415, 6562, 10278) },
+                { AOM_CDF4(26610, 32395, 32659) },
+                { AOM_CDF4(18590, 30498, 32117) },
+                { AOM_CDF4(12420, 25756, 29950) },
+                { AOM_CDF4(7639, 18746, 24710) },
+                { AOM_CDF4(3001, 8086, 12347) },
+                { AOM_CDF4(25076, 32064, 32580) },
+                { AOM_CDF4(17946, 30128, 32028) },
+                { AOM_CDF4(12024, 24985, 29378) },
+                { AOM_CDF4(7517, 18390, 24304) },
+                { AOM_CDF4(3243, 8781, 13331) } },
+              { { AOM_CDF4(6037, 16771, 21957) },
+                { AOM_CDF4(24774, 31704, 32426) },
+                { AOM_CDF4(16830, 28589, 31056) },
+                { AOM_CDF4(10602, 22828, 27760) },
+                { AOM_CDF4(6733, 16829, 23071) },
+                { AOM_CDF4(3250, 8914, 13556) },
+                { AOM_CDF4(25582, 32220, 32668) },
+                { AOM_CDF4(18659, 30342, 32223) },
+                { AOM_CDF4(12546, 26149, 30515) },
+                { AOM_CDF4(8420, 20451, 26801) },
+                { AOM_CDF4(4636, 12420, 18344) },
+                { AOM_CDF4(27581, 32362, 32639) },
+                { AOM_CDF4(18987, 30083, 31978) },
+                { AOM_CDF4(11327, 24248, 29084) },
+                { AOM_CDF4(7264, 17719, 24120) },
+                { AOM_CDF4(3995, 10768, 16169) },
+                { AOM_CDF4(25893, 31831, 32487) },
+                { AOM_CDF4(16577, 28587, 31379) },
+                { AOM_CDF4(10189, 22748, 28182) },
+                { AOM_CDF4(6832, 17094, 23556) },
+                { AOM_CDF4(3708, 10110, 15334) },
+                { AOM_CDF4(25904, 32282, 32656) },
+                { AOM_CDF4(19721, 30792, 32276) },
+                { AOM_CDF4(12819, 26243, 30411) },
+                { AOM_CDF4(8572, 20614, 26891) },
+                { AOM_CDF4(5364, 14059, 20467) },
+                { AOM_CDF4(26580, 32438, 32677) },
+                { AOM_CDF4(20852, 31225, 32340) },
+                { AOM_CDF4(12435, 25700, 29967) },
+                { AOM_CDF4(8691, 20825, 26976) },
+                { AOM_CDF4(4446, 12209, 17269) },
+                { AOM_CDF4(27350, 32429, 32696) },
+                { AOM_CDF4(21372, 30977, 32272) },
+                { AOM_CDF4(12673, 25270, 29853) },
+                { AOM_CDF4(9208, 20925, 26640) },
+                { AOM_CDF4(5018, 13351, 18732) },
+                { AOM_CDF4(27351, 32479, 32713) },
+                { AOM_CDF4(21398, 31209, 32387) },
+                { AOM_CDF4(12162, 25047, 29842) },
+                { AOM_CDF4(7896, 18691, 25319) },
+                { AOM_CDF4(4670, 12882, 18881) } } },
+            { { { AOM_CDF4(5487, 10460, 13708) },
+                { AOM_CDF4(21597, 28303, 30674) },
+                { AOM_CDF4(11037, 21953, 26476) },
+                { AOM_CDF4(8147, 17962, 22952) },
+                { AOM_CDF4(5242, 13061, 18532) },
+                { AOM_CDF4(1889, 5208, 8182) },
+                { AOM_CDF4(26774, 32133, 32590) },
+                { AOM_CDF4(17844, 29564, 31767) },
+                { AOM_CDF4(11690, 24438, 29171) },
+                { AOM_CDF4(7542, 18215, 24459) },
+                { AOM_CDF4(2993, 8050, 12319) },
+                { AOM_CDF4(28023, 32328, 32591) },
+                { AOM_CDF4(18651, 30126, 31954) },
+                { AOM_CDF4(12164, 25146, 29589) },
+                { AOM_CDF4(7762, 18530, 24771) },
+                { AOM_CDF4(3492, 9183, 13920) },
+                { AOM_CDF4(27591, 32008, 32491) },
+                { AOM_CDF4(17149, 28853, 31510) },
+                { AOM_CDF4(11485, 24003, 28860) },
+                { AOM_CDF4(7697, 18086, 24210) },
+                { AOM_CDF4(3075, 7999, 12218) },
+                { AOM_CDF4(28268, 32482, 32654) },
+                { AOM_CDF4(19631, 31051, 32404) },
+                { AOM_CDF4(13860, 27260, 31020) },
+                { AOM_CDF4(9605, 21613, 27594) },
+                { AOM_CDF4(4876, 12162, 17908) },
+                { AOM_CDF4(27248, 32316, 32576) },
+                { AOM_CDF4(18955, 30457, 32075) },
+                { AOM_CDF4(11824, 23997, 28795) },
+                { AOM_CDF4(7346, 18196, 24647) },
+                { AOM_CDF4(3403, 9247, 14111) },
+                { AOM_CDF4(29711, 32655, 32735) },
+                { AOM_CDF4(21169, 31394, 32417) },
+                { AOM_CDF4(13487, 27198, 30957) },
+                { AOM_CDF4(8828, 21683, 27614) },
+                { AOM_CDF4(4270, 11451, 17038) },
+                { AOM_CDF4(28708, 32578, 32731) },
+                { AOM_CDF4(20120, 31241, 32482) },
+                { AOM_CDF4(13692, 27550, 31321) },
+                { AOM_CDF4(9418, 22514, 28439) },
+                { AOM_CDF4(4999, 13283, 19462) } },
+              { { AOM_CDF4(5673, 14302, 19711) },
+                { AOM_CDF4(26251, 30701, 31834) },
+                { AOM_CDF4(12782, 23783, 27803) },
+                { AOM_CDF4(9127, 20657, 25808) },
+                { AOM_CDF4(6368, 16208, 21462) },
+                { AOM_CDF4(2465, 7177, 10822) },
+                { AOM_CDF4(29961, 32563, 32719) },
+                { AOM_CDF4(18318, 29891, 31949) },
+                { AOM_CDF4(11361, 24514, 29357) },
+                { AOM_CDF4(7900, 19603, 25607) },
+                { AOM_CDF4(4002, 10590, 15546) },
+                { AOM_CDF4(29637, 32310, 32595) },
+                { AOM_CDF4(18296, 29913, 31809) },
+                { AOM_CDF4(10144, 21515, 26871) },
+                { AOM_CDF4(5358, 14322, 20394) },
+                { AOM_CDF4(3067, 8362, 13346) },
+                { AOM_CDF4(28652, 32470, 32676) },
+                { AOM_CDF4(17538, 30771, 32209) },
+                { AOM_CDF4(13924, 26882, 30494) },
+                { AOM_CDF4(10496, 22837, 27869) },
+                { AOM_CDF4(7236, 16396, 21621) },
+                { AOM_CDF4(30743, 32687, 32746) },
+                { AOM_CDF4(23006, 31676, 32489) },
+                { AOM_CDF4(14494, 27828, 31120) },
+                { AOM_CDF4(10174, 22801, 28352) },
+                { AOM_CDF4(6242, 15281, 21043) },
+                { AOM_CDF4(25817, 32243, 32720) },
+                { AOM_CDF4(18618, 31367, 32325) },
+                { AOM_CDF4(13997, 28318, 31878) },
+                { AOM_CDF4(12255, 26534, 31383) },
+                { AOM_CDF4(9561, 21588, 28450) },
+                { AOM_CDF4(28188, 32635, 32724) },
+                { AOM_CDF4(22060, 32365, 32728) },
+                { AOM_CDF4(18102, 30690, 32528) },
+                { AOM_CDF4(14196, 28864, 31999) },
+                { AOM_CDF4(12262, 25792, 30865) },
+                { AOM_CDF4(24176, 32109, 32628) },
+                { AOM_CDF4(18280, 29681, 31963) },
+                { AOM_CDF4(10205, 23703, 29664) },
+                { AOM_CDF4(7889, 20025, 27676) },
+                { AOM_CDF4(6060, 16743, 23970) } } },
+            { { { AOM_CDF4(5141, 7096, 8260) },
+                { AOM_CDF4(27186, 29022, 29789) },
+                { AOM_CDF4(6668, 12568, 15682) },
+                { AOM_CDF4(2172, 6181, 8638) },
+                { AOM_CDF4(1126, 3379, 4531) },
+                { AOM_CDF4(443, 1361, 2254) },
+                { AOM_CDF4(26083, 31153, 32436) },
+                { AOM_CDF4(13486, 24603, 28483) },
+                { AOM_CDF4(6508, 14840, 19910) },
+                { AOM_CDF4(3386, 8800, 13286) },
+                { AOM_CDF4(1530, 4322, 7054) },
+                { AOM_CDF4(29639, 32080, 32548) },
+                { AOM_CDF4(15897, 27552, 30290) },
+                { AOM_CDF4(8588, 20047, 25383) },
+                { AOM_CDF4(4889, 13339, 19269) },
+                { AOM_CDF4(2240, 6871, 10498) },
+                { AOM_CDF4(28165, 32197, 32517) },
+                { AOM_CDF4(20735, 30427, 31568) },
+                { AOM_CDF4(14325, 24671, 27692) },
+                { AOM_CDF4(5119, 12554, 17805) },
+                { AOM_CDF4(1810, 5441, 8261) },
+                { AOM_CDF4(31212, 32724, 32748) },
+                { AOM_CDF4(23352, 31766, 32545) },
+                { AOM_CDF4(14669, 27570, 31059) },
+                { AOM_CDF4(8492, 20894, 27272) },
+                { AOM_CDF4(3644, 10194, 15204) },
+                { AOM_CDF4(8192, 16384, 24576) },
+                { AOM_CDF4(8192, 16384, 24576) },
+                { AOM_CDF4(8192, 16384, 24576) },
+                { AOM_CDF4(8192, 16384, 24576) },
+                { AOM_CDF4(8192, 16384, 24576) },
+                { AOM_CDF4(8192, 16384, 24576) },
+                { AOM_CDF4(8192, 16384, 24576) },
+                { AOM_CDF4(8192, 16384, 24576) },
+                { AOM_CDF4(8192, 16384, 24576) },
+                { AOM_CDF4(8192, 16384, 24576) },
+                { AOM_CDF4(8192, 16384, 24576) },
+                { AOM_CDF4(8192, 16384, 24576) },
+                { AOM_CDF4(8192, 16384, 24576) },
+                { AOM_CDF4(8192, 16384, 24576) },
+                { AOM_CDF4(8192, 16384, 24576) } },
+              { { AOM_CDF4(2461, 7013, 9371) },
+                { AOM_CDF4(24749, 29600, 30986) },
+                { AOM_CDF4(9466, 19037, 22417) },
+                { AOM_CDF4(3584, 9280, 14400) },
+                { AOM_CDF4(1505, 3929, 5433) },
+                { AOM_CDF4(677, 1500, 2736) },
+                { AOM_CDF4(23987, 30702, 32117) },
+                { AOM_CDF4(13554, 24571, 29263) },
+                { AOM_CDF4(6211, 14556, 21155) },
+                { AOM_CDF4(3135, 10972, 15625) },
+                { AOM_CDF4(2435, 7127, 11427) },
+                { AOM_CDF4(31300, 32532, 32550) },
+                { AOM_CDF4(14757, 30365, 31954) },
+                { AOM_CDF4(4405, 11612, 18553) },
+                { AOM_CDF4(580, 4132, 7322) },
+                { AOM_CDF4(1695, 10169, 14124) },
+                { AOM_CDF4(30008, 32282, 32591) },
+                { AOM_CDF4(19244, 30108, 31748) },
+                { AOM_CDF4(11180, 24158, 29555) },
+                { AOM_CDF4(5650, 14972, 19209) },
+                { AOM_CDF4(2114, 5109, 8456) },
+                { AOM_CDF4(31856, 32716, 32748) },
+                { AOM_CDF4(23012, 31664, 32572) },
+                { AOM_CDF4(13694, 26656, 30636) },
+                { AOM_CDF4(8142, 19508, 26093) },
+                { AOM_CDF4(4253, 10955, 16724) },
+                { AOM_CDF4(8192, 16384, 24576) },
+                { AOM_CDF4(8192, 16384, 24576) },
+                { AOM_CDF4(8192, 16384, 24576) },
+                { AOM_CDF4(8192, 16384, 24576) },
+                { AOM_CDF4(8192, 16384, 24576) },
+                { AOM_CDF4(8192, 16384, 24576) },
+                { AOM_CDF4(8192, 16384, 24576) },
+                { AOM_CDF4(8192, 16384, 24576) },
+                { AOM_CDF4(8192, 16384, 24576) },
+                { AOM_CDF4(8192, 16384, 24576) },
+                { AOM_CDF4(8192, 16384, 24576) },
+                { AOM_CDF4(8192, 16384, 24576) },
+                { AOM_CDF4(8192, 16384, 24576) },
+                { AOM_CDF4(8192, 16384, 24576) },
+                { AOM_CDF4(8192, 16384, 24576) } } },
+            { { { AOM_CDF4(601, 983, 1311) },
+                { AOM_CDF4(18725, 23406, 28087) },
+                { AOM_CDF4(5461, 8192, 10923) },
+                { AOM_CDF4(3781, 15124, 21425) },
+                { AOM_CDF4(2587, 7761, 12072) },
+                { AOM_CDF4(106, 458, 810) },
+                { AOM_CDF4(22282, 29710, 31894) },
+                { AOM_CDF4(8508, 20926, 25984) },
+                { AOM_CDF4(3726, 12713, 18083) },
+                { AOM_CDF4(1620, 7112, 10893) },
+                { AOM_CDF4(729, 2236, 3495) },
+                { AOM_CDF4(30163, 32474, 32684) },
+                { AOM_CDF4(18304, 30464, 32000) },
+                { AOM_CDF4(11443, 26526, 29647) },
+                { AOM_CDF4(6007, 15292, 21299) },
+                { AOM_CDF4(2234, 6703, 8937) },
+                { AOM_CDF4(30954, 32177, 32571) },
+                { AOM_CDF4(17363, 29562, 31076) },
+                { AOM_CDF4(9686, 22464, 27410) },
+                { AOM_CDF4(8192, 16384, 21390) },
+                { AOM_CDF4(1755, 8046, 11264) },
+                { AOM_CDF4(31168, 32734, 32748) },
+                { AOM_CDF4(22486, 31441, 32471) },
+                { AOM_CDF4(12833, 25627, 29738) },
+                { AOM_CDF4(6980, 17379, 23122) },
+                { AOM_CDF4(3111, 8887, 13479) },
+                { AOM_CDF4(8192, 16384, 24576) },
+                { AOM_CDF4(8192, 16384, 24576) },
+                { AOM_CDF4(8192, 16384, 24576) },
+                { AOM_CDF4(8192, 16384, 24576) },
+                { AOM_CDF4(8192, 16384, 24576) },
+                { AOM_CDF4(8192, 16384, 24576) },
+                { AOM_CDF4(8192, 16384, 24576) },
+                { AOM_CDF4(8192, 16384, 24576) },
+                { AOM_CDF4(8192, 16384, 24576) },
+                { AOM_CDF4(8192, 16384, 24576) },
+                { AOM_CDF4(8192, 16384, 24576) },
+                { AOM_CDF4(8192, 16384, 24576) },
+                { AOM_CDF4(8192, 16384, 24576) },
+                { AOM_CDF4(8192, 16384, 24576) },
+                { AOM_CDF4(8192, 16384, 24576) } },
+              { { AOM_CDF4(8192, 16384, 24576) },
+                { AOM_CDF4(8192, 16384, 24576) },
+                { AOM_CDF4(8192, 16384, 24576) },
+                { AOM_CDF4(8192, 16384, 24576) },
+                { AOM_CDF4(8192, 16384, 24576) },
+                { AOM_CDF4(8192, 16384, 24576) },
+                { AOM_CDF4(8192, 16384, 24576) },
+                { AOM_CDF4(8192, 16384, 24576) },
+                { AOM_CDF4(8192, 16384, 24576) },
+                { AOM_CDF4(8192, 16384, 24576) },
+                { AOM_CDF4(8192, 16384, 24576) },
+                { AOM_CDF4(8192, 16384, 24576) },
+                { AOM_CDF4(8192, 16384, 24576) },
+                { AOM_CDF4(8192, 16384, 24576) },
+                { AOM_CDF4(8192, 16384, 24576) },
+                { AOM_CDF4(8192, 16384, 24576) },
+                { AOM_CDF4(8192, 16384, 24576) },
+                { AOM_CDF4(8192, 16384, 24576) },
+                { AOM_CDF4(8192, 16384, 24576) },
+                { AOM_CDF4(8192, 16384, 24576) },
+                { AOM_CDF4(8192, 16384, 24576) },
+                { AOM_CDF4(8192, 16384, 24576) },
+                { AOM_CDF4(8192, 16384, 24576) },
+                { AOM_CDF4(8192, 16384, 24576) },
+                { AOM_CDF4(8192, 16384, 24576) },
+                { AOM_CDF4(8192, 16384, 24576) },
+                { AOM_CDF4(8192, 16384, 24576) },
+                { AOM_CDF4(8192, 16384, 24576) },
+                { AOM_CDF4(8192, 16384, 24576) },
+                { AOM_CDF4(8192, 16384, 24576) },
+                { AOM_CDF4(8192, 16384, 24576) },
+                { AOM_CDF4(8192, 16384, 24576) },
+                { AOM_CDF4(8192, 16384, 24576) },
+                { AOM_CDF4(8192, 16384, 24576) },
+                { AOM_CDF4(8192, 16384, 24576) },
+                { AOM_CDF4(8192, 16384, 24576) },
+                { AOM_CDF4(8192, 16384, 24576) },
+                { AOM_CDF4(8192, 16384, 24576) },
+                { AOM_CDF4(8192, 16384, 24576) },
+                { AOM_CDF4(8192, 16384, 24576) },
+                { AOM_CDF4(8192, 16384, 24576) } } }
+        }, .dc_sign = {
+            {
+                { AOM_CDF2(128 * 125) },
+                { AOM_CDF2(128 * 102) },
+                { AOM_CDF2(128 * 147) },
+            }, {
+                { AOM_CDF2(128 * 119) },
+                { AOM_CDF2(128 * 101) },
+                { AOM_CDF2(128 * 135) },
+            }
+        }, .br_tok = {
+            { { { AOM_CDF4(14298, 20718, 24174) },
+                { AOM_CDF4(12536, 19601, 23789) },
+                { AOM_CDF4(8712, 15051, 19503) },
+                { AOM_CDF4(6170, 11327, 15434) },
+                { AOM_CDF4(4742, 8926, 12538) },
+                { AOM_CDF4(3803, 7317, 10546) },
+                { AOM_CDF4(1696, 3317, 4871) },
+                { AOM_CDF4(14392, 19951, 22756) },
+                { AOM_CDF4(15978, 23218, 26818) },
+                { AOM_CDF4(12187, 19474, 23889) },
+                { AOM_CDF4(9176, 15640, 20259) },
+                { AOM_CDF4(7068, 12655, 17028) },
+                { AOM_CDF4(5656, 10442, 14472) },
+                { AOM_CDF4(2580, 4992, 7244) },
+                { AOM_CDF4(12136, 18049, 21426) },
+                { AOM_CDF4(13784, 20721, 24481) },
+                { AOM_CDF4(10836, 17621, 21900) },
+                { AOM_CDF4(8372, 14444, 18847) },
+                { AOM_CDF4(6523, 11779, 16000) },
+                { AOM_CDF4(5337, 9898, 13760) },
+                { AOM_CDF4(3034, 5860, 8462) } },
+              { { AOM_CDF4(15967, 22905, 26286) },
+                { AOM_CDF4(13534, 20654, 24579) },
+                { AOM_CDF4(9504, 16092, 20535) },
+                { AOM_CDF4(6975, 12568, 16903) },
+                { AOM_CDF4(5364, 10091, 14020) },
+                { AOM_CDF4(4357, 8370, 11857) },
+                { AOM_CDF4(2506, 4934, 7218) },
+                { AOM_CDF4(23032, 28815, 30936) },
+                { AOM_CDF4(19540, 26704, 29719) },
+                { AOM_CDF4(15158, 22969, 27097) },
+                { AOM_CDF4(11408, 18865, 23650) },
+                { AOM_CDF4(8885, 15448, 20250) },
+                { AOM_CDF4(7108, 12853, 17416) },
+                { AOM_CDF4(4231, 8041, 11480) },
+                { AOM_CDF4(19823, 26490, 29156) },
+                { AOM_CDF4(18890, 25929, 28932) },
+                { AOM_CDF4(15660, 23491, 27433) },
+                { AOM_CDF4(12147, 19776, 24488) },
+                { AOM_CDF4(9728, 16774, 21649) },
+                { AOM_CDF4(7919, 14277, 19066) },
+                { AOM_CDF4(5440, 10170, 14185) } } },
+            { { { AOM_CDF4(14406, 20862, 24414) },
+                { AOM_CDF4(11824, 18907, 23109) },
+                { AOM_CDF4(8257, 14393, 18803) },
+                { AOM_CDF4(5860, 10747, 14778) },
+                { AOM_CDF4(4475, 8486, 11984) },
+                { AOM_CDF4(3606, 6954, 10043) },
+                { AOM_CDF4(1736, 3410, 5048) },
+                { AOM_CDF4(14430, 20046, 22882) },
+                { AOM_CDF4(15593, 22899, 26709) },
+                { AOM_CDF4(12102, 19368, 23811) },
+                { AOM_CDF4(9059, 15584, 20262) },
+                { AOM_CDF4(6999, 12603, 17048) },
+                { AOM_CDF4(5684, 10497, 14553) },
+                { AOM_CDF4(2822, 5438, 7862) },
+                { AOM_CDF4(15785, 21585, 24359) },
+                { AOM_CDF4(18347, 25229, 28266) },
+                { AOM_CDF4(14974, 22487, 26389) },
+                { AOM_CDF4(11423, 18681, 23271) },
+                { AOM_CDF4(8863, 15350, 20008) },
+                { AOM_CDF4(7153, 12852, 17278) },
+                { AOM_CDF4(3707, 7036, 9982) } },
+              { { AOM_CDF4(15460, 21696, 25469) },
+                { AOM_CDF4(12170, 19249, 23191) },
+                { AOM_CDF4(8723, 15027, 19332) },
+                { AOM_CDF4(6428, 11704, 15874) },
+                { AOM_CDF4(4922, 9292, 13052) },
+                { AOM_CDF4(4139, 7695, 11010) },
+                { AOM_CDF4(2291, 4508, 6598) },
+                { AOM_CDF4(19856, 26920, 29828) },
+                { AOM_CDF4(17923, 25289, 28792) },
+                { AOM_CDF4(14278, 21968, 26297) },
+                { AOM_CDF4(10910, 18136, 22950) },
+                { AOM_CDF4(8423, 14815, 19627) },
+                { AOM_CDF4(6771, 12283, 16774) },
+                { AOM_CDF4(4074, 7750, 11081) },
+                { AOM_CDF4(19852, 26074, 28672) },
+                { AOM_CDF4(19371, 26110, 28989) },
+                { AOM_CDF4(16265, 23873, 27663) },
+                { AOM_CDF4(12758, 20378, 24952) },
+                { AOM_CDF4(10095, 17098, 21961) },
+                { AOM_CDF4(8250, 14628, 19451) },
+                { AOM_CDF4(5205, 9745, 13622) } } },
+            { { { AOM_CDF4(10563, 16233, 19763) },
+                { AOM_CDF4(9794, 16022, 19804) },
+                { AOM_CDF4(6750, 11945, 15759) },
+                { AOM_CDF4(4963, 9186, 12752) },
+                { AOM_CDF4(3845, 7435, 10627) },
+                { AOM_CDF4(3051, 6085, 8834) },
+                { AOM_CDF4(1311, 2596, 3830) },
+                { AOM_CDF4(11246, 16404, 19689) },
+                { AOM_CDF4(12315, 18911, 22731) },
+                { AOM_CDF4(10557, 17095, 21289) },
+                { AOM_CDF4(8136, 14006, 18249) },
+                { AOM_CDF4(6348, 11474, 15565) },
+                { AOM_CDF4(5196, 9655, 13400) },
+                { AOM_CDF4(2349, 4526, 6587) },
+                { AOM_CDF4(13337, 18730, 21569) },
+                { AOM_CDF4(19306, 26071, 28882) },
+                { AOM_CDF4(15952, 23540, 27254) },
+                { AOM_CDF4(12409, 19934, 24430) },
+                { AOM_CDF4(9760, 16706, 21389) },
+                { AOM_CDF4(8004, 14220, 18818) },
+                { AOM_CDF4(4138, 7794, 10961) } },
+              { { AOM_CDF4(10870, 16684, 20949) },
+                { AOM_CDF4(9664, 15230, 18680) },
+                { AOM_CDF4(6886, 12109, 15408) },
+                { AOM_CDF4(4825, 8900, 12305) },
+                { AOM_CDF4(3630, 7162, 10314) },
+                { AOM_CDF4(3036, 6429, 9387) },
+                { AOM_CDF4(1671, 3296, 4940) },
+                { AOM_CDF4(13819, 19159, 23026) },
+                { AOM_CDF4(11984, 19108, 23120) },
+                { AOM_CDF4(10690, 17210, 21663) },
+                { AOM_CDF4(7984, 14154, 18333) },
+                { AOM_CDF4(6868, 12294, 16124) },
+                { AOM_CDF4(5274, 8994, 12868) },
+                { AOM_CDF4(2988, 5771, 8424) },
+                { AOM_CDF4(19736, 26647, 29141) },
+                { AOM_CDF4(18933, 26070, 28984) },
+                { AOM_CDF4(15779, 23048, 27200) },
+                { AOM_CDF4(12638, 20061, 24532) },
+                { AOM_CDF4(10692, 17545, 22220) },
+                { AOM_CDF4(9217, 15251, 20054) },
+                { AOM_CDF4(5078, 9284, 12594) } } },
+            { { { AOM_CDF4(2331, 3662, 5244) },
+                { AOM_CDF4(2891, 4771, 6145) },
+                { AOM_CDF4(4598, 7623, 9729) },
+                { AOM_CDF4(3520, 6845, 9199) },
+                { AOM_CDF4(3417, 6119, 9324) },
+                { AOM_CDF4(2601, 5412, 7385) },
+                { AOM_CDF4(600, 1173, 1744) },
+                { AOM_CDF4(7672, 13286, 17469) },
+                { AOM_CDF4(4232, 7792, 10793) },
+                { AOM_CDF4(2915, 5317, 7397) },
+                { AOM_CDF4(2318, 4356, 6152) },
+                { AOM_CDF4(2127, 4000, 5554) },
+                { AOM_CDF4(1850, 3478, 5275) },
+                { AOM_CDF4(977, 1933, 2843) },
+                { AOM_CDF4(18280, 24387, 27989) },
+                { AOM_CDF4(15852, 22671, 26185) },
+                { AOM_CDF4(13845, 20951, 24789) },
+                { AOM_CDF4(11055, 17966, 22129) },
+                { AOM_CDF4(9138, 15422, 19801) },
+                { AOM_CDF4(7454, 13145, 17456) },
+                { AOM_CDF4(3370, 6393, 9013) } },
+              { { AOM_CDF4(5842, 9229, 10838) },
+                { AOM_CDF4(2313, 3491, 4276) },
+                { AOM_CDF4(2998, 6104, 7496) },
+                { AOM_CDF4(2420, 7447, 9868) },
+                { AOM_CDF4(3034, 8495, 10923) },
+                { AOM_CDF4(4076, 8937, 10975) },
+                { AOM_CDF4(1086, 2370, 3299) },
+                { AOM_CDF4(9714, 17254, 20444) },
+                { AOM_CDF4(8543, 13698, 17123) },
+                { AOM_CDF4(4918, 9007, 11910) },
+                { AOM_CDF4(4129, 7532, 10553) },
+                { AOM_CDF4(2364, 5533, 8058) },
+                { AOM_CDF4(1834, 3546, 5563) },
+                { AOM_CDF4(1473, 2908, 4133) },
+                { AOM_CDF4(15405, 21193, 25619) },
+                { AOM_CDF4(15691, 21952, 26561) },
+                { AOM_CDF4(12962, 19194, 24165) },
+                { AOM_CDF4(10272, 17855, 22129) },
+                { AOM_CDF4(8588, 15270, 20718) },
+                { AOM_CDF4(8682, 14669, 19500) },
+                { AOM_CDF4(4870, 9636, 13205) } } }
+        },
+    }, [1] = {
+        .skip = {
+            { { AOM_CDF2(30371) },
+                { AOM_CDF2(7570) },
+                { AOM_CDF2(13155) },
+                { AOM_CDF2(20751) },
+                { AOM_CDF2(20969) },
+                { AOM_CDF2(27067) },
+                { AOM_CDF2(32013) },
+                { AOM_CDF2(5495) },
+                { AOM_CDF2(17942) },
+                { AOM_CDF2(28280) },
+                { AOM_CDF2(16384) },
+                { AOM_CDF2(16384) },
+                { AOM_CDF2(16384) } },
+            { { AOM_CDF2(31782) },
+                { AOM_CDF2(1836) },
+                { AOM_CDF2(10689) },
+                { AOM_CDF2(17604) },
+                { AOM_CDF2(21622) },
+                { AOM_CDF2(27518) },
+                { AOM_CDF2(32399) },
+                { AOM_CDF2(4419) },
+                { AOM_CDF2(16294) },
+                { AOM_CDF2(28345) },
+                { AOM_CDF2(16384) },
+                { AOM_CDF2(16384) },
+                { AOM_CDF2(16384) } },
+            { { AOM_CDF2(31901) },
+                { AOM_CDF2(10311) },
+                { AOM_CDF2(18047) },
+                { AOM_CDF2(24806) },
+                { AOM_CDF2(23288) },
+                { AOM_CDF2(27914) },
+                { AOM_CDF2(32296) },
+                { AOM_CDF2(4215) },
+                { AOM_CDF2(15756) },
+                { AOM_CDF2(28341) },
+                { AOM_CDF2(16384) },
+                { AOM_CDF2(16384) },
+                { AOM_CDF2(16384) } },
+            { { AOM_CDF2(26726) },
+                { AOM_CDF2(1045) },
+                { AOM_CDF2(11703) },
+                { AOM_CDF2(20590) },
+                { AOM_CDF2(18554) },
+                { AOM_CDF2(25970) },
+                { AOM_CDF2(31938) },
+                { AOM_CDF2(5583) },
+                { AOM_CDF2(21313) },
+                { AOM_CDF2(29390) },
+                { AOM_CDF2(641) },
+                { AOM_CDF2(22265) },
+                { AOM_CDF2(31452) } },
+            { { AOM_CDF2(26584) },
+                { AOM_CDF2(188) },
+                { AOM_CDF2(8847) },
+                { AOM_CDF2(24519) },
+                { AOM_CDF2(22938) },
+                { AOM_CDF2(30583) },
+                { AOM_CDF2(32608) },
+                { AOM_CDF2(16384) },
+                { AOM_CDF2(16384) },
+                { AOM_CDF2(16384) },
+                { AOM_CDF2(16384) },
+                { AOM_CDF2(16384) },
+                { AOM_CDF2(16384) } }
+        }, .eob_bin_16 = {
+            { { AOM_CDF5(2125, 2551, 5165, 8946) },
+              { AOM_CDF5(513, 765, 1859, 6339) } },
+            { { AOM_CDF5(7637, 9498, 14259, 19108) },
+              { AOM_CDF5(2497, 4096, 8866, 16993) } }
+        }, .eob_bin_32 = {
+            { { AOM_CDF6(989, 1249, 2019, 4151, 10785) },
+              { AOM_CDF6(313, 441, 1099, 2917, 8562) } },
+            { { AOM_CDF6(8394, 10352, 13932, 18855, 26014) },
+              { AOM_CDF6(2578, 4124, 8181, 13670, 24234) } }
+        }, .eob_bin_64 = {
+            { { AOM_CDF7(1260, 1446, 2253, 3712, 6652, 13369) },
+              { AOM_CDF7(401, 605, 1029, 2563, 5845, 12626) } },
+            { { AOM_CDF7(8609, 10612, 14624, 18714, 22614, 29024) },
+              { AOM_CDF7(1923, 3127, 5867, 9703, 14277, 27100) } }
+        }, .eob_bin_128 = {
+            { { AOM_CDF8(685, 933, 1488, 2714, 4766, 8562, 19254) },
+              { AOM_CDF8(217, 352, 618, 2303, 5261, 9969, 17472) } },
+            { { AOM_CDF8(8045, 11200, 15497, 19595, 23948, 27408, 30938) },
+              { AOM_CDF8(2310, 4160, 7471, 14997, 17931, 20768, 30240) } }
+        }, .eob_bin_256 = {
+            { { AOM_CDF9(1448, 2109, 4151, 6263, 9329, 13260, 17944, 23300) },
+              { AOM_CDF9(399, 1019, 1749, 3038, 10444, 15546, 22739, 27294) } },
+            { { AOM_CDF9(6402, 8148, 12623, 15072, 18728, 22847, 26447, 29377) },
+              { AOM_CDF9(1674, 3252, 5734, 10159, 22397, 23802, 24821, 30940) } }
+        }, .eob_bin_512 = {
+            { { AOM_CDF10(1230, 2278, 5035, 7776, 11871, 15346, 19590,
+                          24584, 28749) },
+              { AOM_CDF10(3277, 6554, 9830, 13107, 16384, 19661, 22938,
+                          26214, 29491) } },
+            { { AOM_CDF10(7265, 9979, 15819, 19250, 21780, 23846, 26478,
+                          28396, 31811) },
+              { AOM_CDF10(3277, 6554, 9830, 13107, 16384, 19661, 22938,
+                          26214, 29491) } }
+        }, .eob_bin_1024 = {
+            { { AOM_CDF11(696, 948, 3145, 5702, 9706, 13217, 17851,
+                          21856, 25692, 28034) },
+              { AOM_CDF11(2979, 5958, 8937, 11916, 14895, 17873, 20852,
+                          23831, 26810, 29789) } },
+            { { AOM_CDF11(2672, 3591, 9330, 17084, 22725, 24284, 26527,
+                          28027, 28377, 30876) },
+              { AOM_CDF11(2979, 5958, 8937, 11916, 14895, 17873, 20852,
+                          23831, 26810, 29789) } }
+        }, .eob_hi_bit = {
+            { { { AOM_CDF2(16384) }, { AOM_CDF2(16384) },
+                { AOM_CDF2(17471) }, { AOM_CDF2(20223) }, { AOM_CDF2(11357) },
+                { AOM_CDF2(16384) }, { AOM_CDF2(16384) }, { AOM_CDF2(16384) },
+                { AOM_CDF2(16384) }, { AOM_CDF2(16384) }, { AOM_CDF2(16384) } },
+              { { AOM_CDF2(16384) }, { AOM_CDF2(16384) },
+                { AOM_CDF2(20335) }, { AOM_CDF2(21667) }, { AOM_CDF2(14818) },
+                { AOM_CDF2(16384) }, { AOM_CDF2(16384) }, { AOM_CDF2(16384) },
+                { AOM_CDF2(16384) }, { AOM_CDF2(16384) }, { AOM_CDF2(16384) } } },
+            { { { AOM_CDF2(16384) }, { AOM_CDF2(16384) },
+                { AOM_CDF2(20430) }, { AOM_CDF2(20662) }, { AOM_CDF2(15367) },
+                { AOM_CDF2(16970) }, { AOM_CDF2(14657) }, { AOM_CDF2(16384) },
+                { AOM_CDF2(16384) }, { AOM_CDF2(16384) }, { AOM_CDF2(16384) } },
+              { { AOM_CDF2(16384) }, { AOM_CDF2(16384) },
+                { AOM_CDF2(22117) }, { AOM_CDF2(22028) }, { AOM_CDF2(18650) },
+                { AOM_CDF2(16042) }, { AOM_CDF2(15885) }, { AOM_CDF2(16384) },
+                { AOM_CDF2(16384) }, { AOM_CDF2(16384) }, { AOM_CDF2(16384) } } },
+            { { { AOM_CDF2(16384) }, { AOM_CDF2(16384) },
+                { AOM_CDF2(22409) }, { AOM_CDF2(21012) }, { AOM_CDF2(15650) },
+                { AOM_CDF2(17395) }, { AOM_CDF2(15469) }, { AOM_CDF2(20205) },
+                { AOM_CDF2(19511) }, { AOM_CDF2(16384) }, { AOM_CDF2(16384) } },
+              { { AOM_CDF2(16384) }, { AOM_CDF2(16384) },
+                { AOM_CDF2(24220) }, { AOM_CDF2(22480) }, { AOM_CDF2(17737) },
+                { AOM_CDF2(18916) }, { AOM_CDF2(19268) }, { AOM_CDF2(18412) },
+                { AOM_CDF2(18844) }, { AOM_CDF2(16384) }, { AOM_CDF2(16384) } } },
+            { { { AOM_CDF2(16384) }, { AOM_CDF2(16384) },
+                { AOM_CDF2(25991) }, { AOM_CDF2(20314) }, { AOM_CDF2(17731) },
+                { AOM_CDF2(19678) }, { AOM_CDF2(18649) }, { AOM_CDF2(17307) },
+                { AOM_CDF2(21798) }, { AOM_CDF2(17549) }, { AOM_CDF2(15630) } },
+              { { AOM_CDF2(16384) }, { AOM_CDF2(16384) },
+                { AOM_CDF2(26585) }, { AOM_CDF2(21469) }, { AOM_CDF2(20432) },
+                { AOM_CDF2(17735) }, { AOM_CDF2(19280) }, { AOM_CDF2(15235) },
+                { AOM_CDF2(20297) }, { AOM_CDF2(22471) }, { AOM_CDF2(28997) } } },
+            { { { AOM_CDF2(16384) }, { AOM_CDF2(16384) },
+                { AOM_CDF2(26605) }, { AOM_CDF2(11304) }, { AOM_CDF2(16726) },
+                { AOM_CDF2(16560) }, { AOM_CDF2(20866) }, { AOM_CDF2(23524) },
+                { AOM_CDF2(19878) }, { AOM_CDF2(13469) }, { AOM_CDF2(23084) } },
+              { { AOM_CDF2(16384) }, { AOM_CDF2(16384) },
+                { AOM_CDF2(16384) }, { AOM_CDF2(16384) }, { AOM_CDF2(16384) },
+                { AOM_CDF2(16384) }, { AOM_CDF2(16384) }, { AOM_CDF2(16384) },
+                { AOM_CDF2(16384) }, { AOM_CDF2(16384) }, { AOM_CDF2(16384) } } }
+        }, .eob_base_tok = {
+            { { { AOM_CDF3(17560, 29888) },
+                { AOM_CDF3(29671, 31549) },
+                { AOM_CDF3(31007, 32056) },
+                { AOM_CDF3(27286, 30006) } },
+              { { AOM_CDF3(26594, 31212) },
+                { AOM_CDF3(31208, 32582) },
+                { AOM_CDF3(31835, 32637) },
+                { AOM_CDF3(30595, 32206) } } },
+            { { { AOM_CDF3(15239, 29932) },
+                { AOM_CDF3(31315, 32095) },
+                { AOM_CDF3(32130, 32434) },
+                { AOM_CDF3(30864, 31996) } },
+              { { AOM_CDF3(26279, 30968) },
+                { AOM_CDF3(31142, 32495) },
+                { AOM_CDF3(31713, 32540) },
+                { AOM_CDF3(31929, 32594) } } },
+            { { { AOM_CDF3(2644, 25198) },
+                { AOM_CDF3(32038, 32451) },
+                { AOM_CDF3(32639, 32695) },
+                { AOM_CDF3(32166, 32518) } },
+              { { AOM_CDF3(17187, 27668) },
+                { AOM_CDF3(31714, 32550) },
+                { AOM_CDF3(32283, 32678) },
+                { AOM_CDF3(31930, 32563) } } },
+            { { { AOM_CDF3(1044, 2257) },
+                { AOM_CDF3(30755, 31923) },
+                { AOM_CDF3(32208, 32693) },
+                { AOM_CDF3(32244, 32615) } },
+              { { AOM_CDF3(21317, 26207) },
+                { AOM_CDF3(29133, 30868) },
+                { AOM_CDF3(29311, 31231) },
+                { AOM_CDF3(29657, 31087) } } },
+            { { { AOM_CDF3(478, 1834) },
+                { AOM_CDF3(31005, 31987) },
+                { AOM_CDF3(32317, 32724) },
+                { AOM_CDF3(30865, 32648) } },
+              { { AOM_CDF3(10923, 21845) },
+                { AOM_CDF3(10923, 21845) },
+                { AOM_CDF3(10923, 21845) },
+                { AOM_CDF3(10923, 21845) } } }
+        }, .base_tok = {
+            { { { AOM_CDF4(6041, 11854, 15927) },
+                { AOM_CDF4(20326, 30905, 32251) },
+                { AOM_CDF4(14164, 26831, 30725) },
+                { AOM_CDF4(9760, 20647, 26585) },
+                { AOM_CDF4(6416, 14953, 21219) },
+                { AOM_CDF4(2966, 7151, 10891) },
+                { AOM_CDF4(23567, 31374, 32254) },
+                { AOM_CDF4(14978, 27416, 30946) },
+                { AOM_CDF4(9434, 20225, 26254) },
+                { AOM_CDF4(6658, 14558, 20535) },
+                { AOM_CDF4(3916, 8677, 12989) },
+                { AOM_CDF4(8192, 16384, 24576) },
+                { AOM_CDF4(8192, 16384, 24576) },
+                { AOM_CDF4(8192, 16384, 24576) },
+                { AOM_CDF4(8192, 16384, 24576) },
+                { AOM_CDF4(8192, 16384, 24576) },
+                { AOM_CDF4(8192, 16384, 24576) },
+                { AOM_CDF4(8192, 16384, 24576) },
+                { AOM_CDF4(8192, 16384, 24576) },
+                { AOM_CDF4(8192, 16384, 24576) },
+                { AOM_CDF4(8192, 16384, 24576) },
+                { AOM_CDF4(18088, 29545, 31587) },
+                { AOM_CDF4(13062, 25843, 30073) },
+                { AOM_CDF4(8940, 16827, 22251) },
+                { AOM_CDF4(7654, 13220, 17973) },
+                { AOM_CDF4(5733, 10316, 14456) },
+                { AOM_CDF4(22879, 31388, 32114) },
+                { AOM_CDF4(15215, 27993, 30955) },
+                { AOM_CDF4(9397, 19445, 24978) },
+                { AOM_CDF4(3442, 9813, 15344) },
+                { AOM_CDF4(1368, 3936, 6532) },
+                { AOM_CDF4(25494, 32033, 32406) },
+                { AOM_CDF4(16772, 27963, 30718) },
+                { AOM_CDF4(9419, 18165, 23260) },
+                { AOM_CDF4(2677, 7501, 11797) },
+                { AOM_CDF4(1516, 4344, 7170) },
+                { AOM_CDF4(26556, 31454, 32101) },
+                { AOM_CDF4(17128, 27035, 30108) },
+                { AOM_CDF4(8324, 15344, 20249) },
+                { AOM_CDF4(1903, 5696, 9469) },
+                { AOM_CDF4(8192, 16384, 24576) } },
+              { { AOM_CDF4(8455, 19003, 24368) },
+                { AOM_CDF4(23563, 32021, 32604) },
+                { AOM_CDF4(16237, 29446, 31935) },
+                { AOM_CDF4(10724, 23999, 29358) },
+                { AOM_CDF4(6725, 17528, 24416) },
+                { AOM_CDF4(3927, 10927, 16825) },
+                { AOM_CDF4(26313, 32288, 32634) },
+                { AOM_CDF4(17430, 30095, 32095) },
+                { AOM_CDF4(11116, 24606, 29679) },
+                { AOM_CDF4(7195, 18384, 25269) },
+                { AOM_CDF4(4726, 12852, 19315) },
+                { AOM_CDF4(8192, 16384, 24576) },
+                { AOM_CDF4(8192, 16384, 24576) },
+                { AOM_CDF4(8192, 16384, 24576) },
+                { AOM_CDF4(8192, 16384, 24576) },
+                { AOM_CDF4(8192, 16384, 24576) },
+                { AOM_CDF4(8192, 16384, 24576) },
+                { AOM_CDF4(8192, 16384, 24576) },
+                { AOM_CDF4(8192, 16384, 24576) },
+                { AOM_CDF4(8192, 16384, 24576) },
+                { AOM_CDF4(8192, 16384, 24576) },
+                { AOM_CDF4(22822, 31648, 32483) },
+                { AOM_CDF4(16724, 29633, 31929) },
+                { AOM_CDF4(10261, 23033, 28725) },
+                { AOM_CDF4(7029, 17840, 24528) },
+                { AOM_CDF4(4867, 13886, 21502) },
+                { AOM_CDF4(25298, 31892, 32491) },
+                { AOM_CDF4(17809, 29330, 31512) },
+                { AOM_CDF4(9668, 21329, 26579) },
+                { AOM_CDF4(4774, 12956, 18976) },
+                { AOM_CDF4(2322, 7030, 11540) },
+                { AOM_CDF4(25472, 31920, 32543) },
+                { AOM_CDF4(17957, 29387, 31632) },
+                { AOM_CDF4(9196, 20593, 26400) },
+                { AOM_CDF4(4680, 12705, 19202) },
+                { AOM_CDF4(2917, 8456, 13436) },
+                { AOM_CDF4(26471, 32059, 32574) },
+                { AOM_CDF4(18458, 29783, 31909) },
+                { AOM_CDF4(8400, 19464, 25956) },
+                { AOM_CDF4(3812, 10973, 17206) },
+                { AOM_CDF4(8192, 16384, 24576) } } },
+            { { { AOM_CDF4(6779, 13743, 17678) },
+                { AOM_CDF4(24806, 31797, 32457) },
+                { AOM_CDF4(17616, 29047, 31372) },
+                { AOM_CDF4(11063, 23175, 28003) },
+                { AOM_CDF4(6521, 16110, 22324) },
+                { AOM_CDF4(2764, 7504, 11654) },
+                { AOM_CDF4(25266, 32367, 32637) },
+                { AOM_CDF4(19054, 30553, 32175) },
+                { AOM_CDF4(12139, 25212, 29807) },
+                { AOM_CDF4(7311, 18162, 24704) },
+                { AOM_CDF4(3397, 9164, 14074) },
+                { AOM_CDF4(25988, 32208, 32522) },
+                { AOM_CDF4(16253, 28912, 31526) },
+                { AOM_CDF4(9151, 21387, 27372) },
+                { AOM_CDF4(5688, 14915, 21496) },
+                { AOM_CDF4(2717, 7627, 12004) },
+                { AOM_CDF4(23144, 31855, 32443) },
+                { AOM_CDF4(16070, 28491, 31325) },
+                { AOM_CDF4(8702, 20467, 26517) },
+                { AOM_CDF4(5243, 13956, 20367) },
+                { AOM_CDF4(2621, 7335, 11567) },
+                { AOM_CDF4(26636, 32340, 32630) },
+                { AOM_CDF4(19990, 31050, 32341) },
+                { AOM_CDF4(13243, 26105, 30315) },
+                { AOM_CDF4(8588, 19521, 25918) },
+                { AOM_CDF4(4717, 11585, 17304) },
+                { AOM_CDF4(25844, 32292, 32582) },
+                { AOM_CDF4(19090, 30635, 32097) },
+                { AOM_CDF4(11963, 24546, 28939) },
+                { AOM_CDF4(6218, 16087, 22354) },
+                { AOM_CDF4(2340, 6608, 10426) },
+                { AOM_CDF4(28046, 32576, 32694) },
+                { AOM_CDF4(21178, 31313, 32296) },
+                { AOM_CDF4(13486, 26184, 29870) },
+                { AOM_CDF4(7149, 17871, 23723) },
+                { AOM_CDF4(2833, 7958, 12259) },
+                { AOM_CDF4(27710, 32528, 32686) },
+                { AOM_CDF4(20674, 31076, 32268) },
+                { AOM_CDF4(12413, 24955, 29243) },
+                { AOM_CDF4(6676, 16927, 23097) },
+                { AOM_CDF4(2966, 8333, 12919) } },
+              { { AOM_CDF4(8639, 19339, 24429) },
+                { AOM_CDF4(24404, 31837, 32525) },
+                { AOM_CDF4(16997, 29425, 31784) },
+                { AOM_CDF4(11253, 24234, 29149) },
+                { AOM_CDF4(6751, 17394, 24028) },
+                { AOM_CDF4(3490, 9830, 15191) },
+                { AOM_CDF4(26283, 32471, 32714) },
+                { AOM_CDF4(19599, 31168, 32442) },
+                { AOM_CDF4(13146, 26954, 30893) },
+                { AOM_CDF4(8214, 20588, 26890) },
+                { AOM_CDF4(4699, 13081, 19300) },
+                { AOM_CDF4(28212, 32458, 32669) },
+                { AOM_CDF4(18594, 30316, 32100) },
+                { AOM_CDF4(11219, 24408, 29234) },
+                { AOM_CDF4(6865, 17656, 24149) },
+                { AOM_CDF4(3678, 10362, 16006) },
+                { AOM_CDF4(25825, 32136, 32616) },
+                { AOM_CDF4(17313, 29853, 32021) },
+                { AOM_CDF4(11197, 24471, 29472) },
+                { AOM_CDF4(6947, 17781, 24405) },
+                { AOM_CDF4(3768, 10660, 16261) },
+                { AOM_CDF4(27352, 32500, 32706) },
+                { AOM_CDF4(20850, 31468, 32469) },
+                { AOM_CDF4(14021, 27707, 31133) },
+                { AOM_CDF4(8964, 21748, 27838) },
+                { AOM_CDF4(5437, 14665, 21187) },
+                { AOM_CDF4(26304, 32492, 32698) },
+                { AOM_CDF4(20409, 31380, 32385) },
+                { AOM_CDF4(13682, 27222, 30632) },
+                { AOM_CDF4(8974, 21236, 26685) },
+                { AOM_CDF4(4234, 11665, 16934) },
+                { AOM_CDF4(26273, 32357, 32711) },
+                { AOM_CDF4(20672, 31242, 32441) },
+                { AOM_CDF4(14172, 27254, 30902) },
+                { AOM_CDF4(9870, 21898, 27275) },
+                { AOM_CDF4(5164, 13506, 19270) },
+                { AOM_CDF4(26725, 32459, 32728) },
+                { AOM_CDF4(20991, 31442, 32527) },
+                { AOM_CDF4(13071, 26434, 30811) },
+                { AOM_CDF4(8184, 20090, 26742) },
+                { AOM_CDF4(4803, 13255, 19895) } } },
+            { { { AOM_CDF4(7555, 14942, 18501) },
+                { AOM_CDF4(24410, 31178, 32287) },
+                { AOM_CDF4(14394, 26738, 30253) },
+                { AOM_CDF4(8413, 19554, 25195) },
+                { AOM_CDF4(4766, 12924, 18785) },
+                { AOM_CDF4(2029, 5806, 9207) },
+                { AOM_CDF4(26776, 32364, 32663) },
+                { AOM_CDF4(18732, 29967, 31931) },
+                { AOM_CDF4(11005, 23786, 28852) },
+                { AOM_CDF4(6466, 16909, 23510) },
+                { AOM_CDF4(3044, 8638, 13419) },
+                { AOM_CDF4(29208, 32582, 32704) },
+                { AOM_CDF4(20068, 30857, 32208) },
+                { AOM_CDF4(12003, 25085, 29595) },
+                { AOM_CDF4(6947, 17750, 24189) },
+                { AOM_CDF4(3245, 9103, 14007) },
+                { AOM_CDF4(27359, 32465, 32669) },
+                { AOM_CDF4(19421, 30614, 32174) },
+                { AOM_CDF4(11915, 25010, 29579) },
+                { AOM_CDF4(6950, 17676, 24074) },
+                { AOM_CDF4(3007, 8473, 13096) },
+                { AOM_CDF4(29002, 32676, 32735) },
+                { AOM_CDF4(22102, 31849, 32576) },
+                { AOM_CDF4(14408, 28009, 31405) },
+                { AOM_CDF4(9027, 21679, 27931) },
+                { AOM_CDF4(4694, 12678, 18748) },
+                { AOM_CDF4(28216, 32528, 32682) },
+                { AOM_CDF4(20849, 31264, 32318) },
+                { AOM_CDF4(12756, 25815, 29751) },
+                { AOM_CDF4(7565, 18801, 24923) },
+                { AOM_CDF4(3509, 9533, 14477) },
+                { AOM_CDF4(30133, 32687, 32739) },
+                { AOM_CDF4(23063, 31910, 32515) },
+                { AOM_CDF4(14588, 28051, 31132) },
+                { AOM_CDF4(9085, 21649, 27457) },
+                { AOM_CDF4(4261, 11654, 17264) },
+                { AOM_CDF4(29518, 32691, 32748) },
+                { AOM_CDF4(22451, 31959, 32613) },
+                { AOM_CDF4(14864, 28722, 31700) },
+                { AOM_CDF4(9695, 22964, 28716) },
+                { AOM_CDF4(4932, 13358, 19502) } },
+              { { AOM_CDF4(6465, 16958, 21688) },
+                { AOM_CDF4(25199, 31514, 32360) },
+                { AOM_CDF4(14774, 27149, 30607) },
+                { AOM_CDF4(9257, 21438, 26972) },
+                { AOM_CDF4(5723, 15183, 21882) },
+                { AOM_CDF4(3150, 8879, 13731) },
+                { AOM_CDF4(26989, 32262, 32682) },
+                { AOM_CDF4(17396, 29937, 32085) },
+                { AOM_CDF4(11387, 24901, 29784) },
+                { AOM_CDF4(7289, 18821, 25548) },
+                { AOM_CDF4(3734, 10577, 16086) },
+                { AOM_CDF4(29728, 32501, 32695) },
+                { AOM_CDF4(17431, 29701, 31903) },
+                { AOM_CDF4(9921, 22826, 28300) },
+                { AOM_CDF4(5896, 15434, 22068) },
+                { AOM_CDF4(3430, 9646, 14757) },
+                { AOM_CDF4(28614, 32511, 32705) },
+                { AOM_CDF4(19364, 30638, 32263) },
+                { AOM_CDF4(13129, 26254, 30402) },
+                { AOM_CDF4(8754, 20484, 26440) },
+                { AOM_CDF4(4378, 11607, 17110) },
+                { AOM_CDF4(30292, 32671, 32744) },
+                { AOM_CDF4(21780, 31603, 32501) },
+                { AOM_CDF4(14314, 27829, 31291) },
+                { AOM_CDF4(9611, 22327, 28263) },
+                { AOM_CDF4(4890, 13087, 19065) },
+                { AOM_CDF4(25862, 32567, 32733) },
+                { AOM_CDF4(20794, 32050, 32567) },
+                { AOM_CDF4(17243, 30625, 32254) },
+                { AOM_CDF4(13283, 27628, 31474) },
+                { AOM_CDF4(9669, 22532, 28918) },
+                { AOM_CDF4(27435, 32697, 32748) },
+                { AOM_CDF4(24922, 32390, 32714) },
+                { AOM_CDF4(21449, 31504, 32536) },
+                { AOM_CDF4(16392, 29729, 31832) },
+                { AOM_CDF4(11692, 24884, 29076) },
+                { AOM_CDF4(24193, 32290, 32735) },
+                { AOM_CDF4(18909, 31104, 32563) },
+                { AOM_CDF4(12236, 26841, 31403) },
+                { AOM_CDF4(8171, 21840, 29082) },
+                { AOM_CDF4(7224, 17280, 25275) } } },
+            { { { AOM_CDF4(3078, 6839, 9890) },
+                { AOM_CDF4(13837, 20450, 24479) },
+                { AOM_CDF4(5914, 14222, 19328) },
+                { AOM_CDF4(3866, 10267, 14762) },
+                { AOM_CDF4(2612, 7208, 11042) },
+                { AOM_CDF4(1067, 2991, 4776) },
+                { AOM_CDF4(25817, 31646, 32529) },
+                { AOM_CDF4(13708, 26338, 30385) },
+                { AOM_CDF4(7328, 18585, 24870) },
+                { AOM_CDF4(4691, 13080, 19276) },
+                { AOM_CDF4(1825, 5253, 8352) },
+                { AOM_CDF4(29386, 32315, 32624) },
+                { AOM_CDF4(17160, 29001, 31360) },
+                { AOM_CDF4(9602, 21862, 27396) },
+                { AOM_CDF4(5915, 15772, 22148) },
+                { AOM_CDF4(2786, 7779, 12047) },
+                { AOM_CDF4(29246, 32450, 32663) },
+                { AOM_CDF4(18696, 29929, 31818) },
+                { AOM_CDF4(10510, 23369, 28560) },
+                { AOM_CDF4(6229, 16499, 23125) },
+                { AOM_CDF4(2608, 7448, 11705) },
+                { AOM_CDF4(30753, 32710, 32748) },
+                { AOM_CDF4(21638, 31487, 32503) },
+                { AOM_CDF4(12937, 26854, 30870) },
+                { AOM_CDF4(8182, 20596, 26970) },
+                { AOM_CDF4(3637, 10269, 15497) },
+                { AOM_CDF4(8192, 16384, 24576) },
+                { AOM_CDF4(8192, 16384, 24576) },
+                { AOM_CDF4(8192, 16384, 24576) },
+                { AOM_CDF4(8192, 16384, 24576) },
+                { AOM_CDF4(8192, 16384, 24576) },
+                { AOM_CDF4(8192, 16384, 24576) },
+                { AOM_CDF4(8192, 16384, 24576) },
+                { AOM_CDF4(8192, 16384, 24576) },
+                { AOM_CDF4(8192, 16384, 24576) },
+                { AOM_CDF4(8192, 16384, 24576) },
+                { AOM_CDF4(8192, 16384, 24576) },
+                { AOM_CDF4(8192, 16384, 24576) },
+                { AOM_CDF4(8192, 16384, 24576) },
+                { AOM_CDF4(8192, 16384, 24576) },
+                { AOM_CDF4(8192, 16384, 24576) } },
+              { { AOM_CDF4(5244, 12150, 16906) },
+                { AOM_CDF4(20486, 26858, 29701) },
+                { AOM_CDF4(7756, 18317, 23735) },
+                { AOM_CDF4(3452, 9256, 13146) },
+                { AOM_CDF4(2020, 5206, 8229) },
+                { AOM_CDF4(1801, 4993, 7903) },
+                { AOM_CDF4(27051, 31858, 32531) },
+                { AOM_CDF4(15988, 27531, 30619) },
+                { AOM_CDF4(9188, 21484, 26719) },
+                { AOM_CDF4(6273, 17186, 23800) },
+                { AOM_CDF4(3108, 9355, 14764) },
+                { AOM_CDF4(31076, 32520, 32680) },
+                { AOM_CDF4(18119, 30037, 31850) },
+                { AOM_CDF4(10244, 22969, 27472) },
+                { AOM_CDF4(4692, 14077, 19273) },
+                { AOM_CDF4(3694, 11677, 17556) },
+                { AOM_CDF4(30060, 32581, 32720) },
+                { AOM_CDF4(21011, 30775, 32120) },
+                { AOM_CDF4(11931, 24820, 29289) },
+                { AOM_CDF4(7119, 17662, 24356) },
+                { AOM_CDF4(3833, 10706, 16304) },
+                { AOM_CDF4(31954, 32731, 32748) },
+                { AOM_CDF4(23913, 31724, 32489) },
+                { AOM_CDF4(15520, 28060, 31286) },
+                { AOM_CDF4(11517, 23008, 28571) },
+                { AOM_CDF4(6193, 14508, 20629) },
+                { AOM_CDF4(8192, 16384, 24576) },
+                { AOM_CDF4(8192, 16384, 24576) },
+                { AOM_CDF4(8192, 16384, 24576) },
+                { AOM_CDF4(8192, 16384, 24576) },
+                { AOM_CDF4(8192, 16384, 24576) },
+                { AOM_CDF4(8192, 16384, 24576) },
+                { AOM_CDF4(8192, 16384, 24576) },
+                { AOM_CDF4(8192, 16384, 24576) },
+                { AOM_CDF4(8192, 16384, 24576) },
+                { AOM_CDF4(8192, 16384, 24576) },
+                { AOM_CDF4(8192, 16384, 24576) },
+                { AOM_CDF4(8192, 16384, 24576) },
+                { AOM_CDF4(8192, 16384, 24576) },
+                { AOM_CDF4(8192, 16384, 24576) },
+                { AOM_CDF4(8192, 16384, 24576) } } },
+            { { { AOM_CDF4(1035, 2807, 4156) },
+                { AOM_CDF4(13162, 18138, 20939) },
+                { AOM_CDF4(2696, 6633, 8755) },
+                { AOM_CDF4(1373, 4161, 6853) },
+                { AOM_CDF4(1099, 2746, 4716) },
+                { AOM_CDF4(340, 1021, 1599) },
+                { AOM_CDF4(22826, 30419, 32135) },
+                { AOM_CDF4(10395, 21762, 26942) },
+                { AOM_CDF4(4726, 12407, 17361) },
+                { AOM_CDF4(2447, 7080, 10593) },
+                { AOM_CDF4(1227, 3717, 6011) },
+                { AOM_CDF4(28156, 31424, 31934) },
+                { AOM_CDF4(16915, 27754, 30373) },
+                { AOM_CDF4(9148, 20990, 26431) },
+                { AOM_CDF4(5950, 15515, 21148) },
+                { AOM_CDF4(2492, 7327, 11526) },
+                { AOM_CDF4(30602, 32477, 32670) },
+                { AOM_CDF4(20026, 29955, 31568) },
+                { AOM_CDF4(11220, 23628, 28105) },
+                { AOM_CDF4(6652, 17019, 22973) },
+                { AOM_CDF4(3064, 8536, 13043) },
+                { AOM_CDF4(31769, 32724, 32748) },
+                { AOM_CDF4(22230, 30887, 32373) },
+                { AOM_CDF4(12234, 25079, 29731) },
+                { AOM_CDF4(7326, 18816, 25353) },
+                { AOM_CDF4(3933, 10907, 16616) },
+                { AOM_CDF4(8192, 16384, 24576) },
+                { AOM_CDF4(8192, 16384, 24576) },
+                { AOM_CDF4(8192, 16384, 24576) },
+                { AOM_CDF4(8192, 16384, 24576) },
+                { AOM_CDF4(8192, 16384, 24576) },
+                { AOM_CDF4(8192, 16384, 24576) },
+                { AOM_CDF4(8192, 16384, 24576) },
+                { AOM_CDF4(8192, 16384, 24576) },
+                { AOM_CDF4(8192, 16384, 24576) },
+                { AOM_CDF4(8192, 16384, 24576) },
+                { AOM_CDF4(8192, 16384, 24576) },
+                { AOM_CDF4(8192, 16384, 24576) },
+                { AOM_CDF4(8192, 16384, 24576) },
+                { AOM_CDF4(8192, 16384, 24576) },
+                { AOM_CDF4(8192, 16384, 24576) } },
+              { { AOM_CDF4(8192, 16384, 24576) },
+                { AOM_CDF4(8192, 16384, 24576) },
+                { AOM_CDF4(8192, 16384, 24576) },
+                { AOM_CDF4(8192, 16384, 24576) },
+                { AOM_CDF4(8192, 16384, 24576) },
+                { AOM_CDF4(8192, 16384, 24576) },
+                { AOM_CDF4(8192, 16384, 24576) },
+                { AOM_CDF4(8192, 16384, 24576) },
+                { AOM_CDF4(8192, 16384, 24576) },
+                { AOM_CDF4(8192, 16384, 24576) },
+                { AOM_CDF4(8192, 16384, 24576) },
+                { AOM_CDF4(8192, 16384, 24576) },
+                { AOM_CDF4(8192, 16384, 24576) },
+                { AOM_CDF4(8192, 16384, 24576) },
+                { AOM_CDF4(8192, 16384, 24576) },
+                { AOM_CDF4(8192, 16384, 24576) },
+                { AOM_CDF4(8192, 16384, 24576) },
+                { AOM_CDF4(8192, 16384, 24576) },
+                { AOM_CDF4(8192, 16384, 24576) },
+                { AOM_CDF4(8192, 16384, 24576) },
+                { AOM_CDF4(8192, 16384, 24576) },
+                { AOM_CDF4(8192, 16384, 24576) },
+                { AOM_CDF4(8192, 16384, 24576) },
+                { AOM_CDF4(8192, 16384, 24576) },
+                { AOM_CDF4(8192, 16384, 24576) },
+                { AOM_CDF4(8192, 16384, 24576) },
+                { AOM_CDF4(8192, 16384, 24576) },
+                { AOM_CDF4(8192, 16384, 24576) },
+                { AOM_CDF4(8192, 16384, 24576) },
+                { AOM_CDF4(8192, 16384, 24576) },
+                { AOM_CDF4(8192, 16384, 24576) },
+                { AOM_CDF4(8192, 16384, 24576) },
+                { AOM_CDF4(8192, 16384, 24576) },
+                { AOM_CDF4(8192, 16384, 24576) },
+                { AOM_CDF4(8192, 16384, 24576) },
+                { AOM_CDF4(8192, 16384, 24576) },
+                { AOM_CDF4(8192, 16384, 24576) },
+                { AOM_CDF4(8192, 16384, 24576) },
+                { AOM_CDF4(8192, 16384, 24576) },
+                { AOM_CDF4(8192, 16384, 24576) },
+                { AOM_CDF4(8192, 16384, 24576) } } }
+        }, .dc_sign = {
+            {
+                { AOM_CDF2(128 * 125) },
+                { AOM_CDF2(128 * 102) },
+                { AOM_CDF2(128 * 147) },
+            },
+            {
+                { AOM_CDF2(128 * 119) },
+                { AOM_CDF2(128 * 101) },
+                { AOM_CDF2(128 * 135) },
+            }
+        }, .br_tok = {
+            { { { AOM_CDF4(14995, 21341, 24749) },
+                { AOM_CDF4(13158, 20289, 24601) },
+                { AOM_CDF4(8941, 15326, 19876) },
+                { AOM_CDF4(6297, 11541, 15807) },
+                { AOM_CDF4(4817, 9029, 12776) },
+                { AOM_CDF4(3731, 7273, 10627) },
+                { AOM_CDF4(1847, 3617, 5354) },
+                { AOM_CDF4(14472, 19659, 22343) },
+                { AOM_CDF4(16806, 24162, 27533) },
+                { AOM_CDF4(12900, 20404, 24713) },
+                { AOM_CDF4(9411, 16112, 20797) },
+                { AOM_CDF4(7056, 12697, 17148) },
+                { AOM_CDF4(5544, 10339, 14460) },
+                { AOM_CDF4(2954, 5704, 8319) },
+                { AOM_CDF4(12464, 18071, 21354) },
+                { AOM_CDF4(15482, 22528, 26034) },
+                { AOM_CDF4(12070, 19269, 23624) },
+                { AOM_CDF4(8953, 15406, 20106) },
+                { AOM_CDF4(7027, 12730, 17220) },
+                { AOM_CDF4(5887, 10913, 15140) },
+                { AOM_CDF4(3793, 7278, 10447) } },
+              { { AOM_CDF4(15571, 22232, 25749) },
+                { AOM_CDF4(14506, 21575, 25374) },
+                { AOM_CDF4(10189, 17089, 21569) },
+                { AOM_CDF4(7316, 13301, 17915) },
+                { AOM_CDF4(5783, 10912, 15190) },
+                { AOM_CDF4(4760, 9155, 13088) },
+                { AOM_CDF4(2993, 5966, 8774) },
+                { AOM_CDF4(23424, 28903, 30778) },
+                { AOM_CDF4(20775, 27666, 30290) },
+                { AOM_CDF4(16474, 24410, 28299) },
+                { AOM_CDF4(12471, 20180, 24987) },
+                { AOM_CDF4(9410, 16487, 21439) },
+                { AOM_CDF4(7536, 13614, 18529) },
+                { AOM_CDF4(5048, 9586, 13549) },
+                { AOM_CDF4(21090, 27290, 29756) },
+                { AOM_CDF4(20796, 27402, 30026) },
+                { AOM_CDF4(17819, 25485, 28969) },
+                { AOM_CDF4(13860, 21909, 26462) },
+                { AOM_CDF4(11002, 18494, 23529) },
+                { AOM_CDF4(8953, 15929, 20897) },
+                { AOM_CDF4(6448, 11918, 16454) } } },
+            { { { AOM_CDF4(15999, 22208, 25449) },
+                { AOM_CDF4(13050, 19988, 24122) },
+                { AOM_CDF4(8594, 14864, 19378) },
+                { AOM_CDF4(6033, 11079, 15238) },
+                { AOM_CDF4(4554, 8683, 12347) },
+                { AOM_CDF4(3672, 7139, 10337) },
+                { AOM_CDF4(1900, 3771, 5576) },
+                { AOM_CDF4(15788, 21340, 23949) },
+                { AOM_CDF4(16825, 24235, 27758) },
+                { AOM_CDF4(12873, 20402, 24810) },
+                { AOM_CDF4(9590, 16363, 21094) },
+                { AOM_CDF4(7352, 13209, 17733) },
+                { AOM_CDF4(5960, 10989, 15184) },
+                { AOM_CDF4(3232, 6234, 9007) },
+                { AOM_CDF4(15761, 20716, 23224) },
+                { AOM_CDF4(19318, 25989, 28759) },
+                { AOM_CDF4(15529, 23094, 26929) },
+                { AOM_CDF4(11662, 18989, 23641) },
+                { AOM_CDF4(8955, 15568, 20366) },
+                { AOM_CDF4(7281, 13106, 17708) },
+                { AOM_CDF4(4248, 8059, 11440) } },
+              { { AOM_CDF4(14899, 21217, 24503) },
+                { AOM_CDF4(13519, 20283, 24047) },
+                { AOM_CDF4(9429, 15966, 20365) },
+                { AOM_CDF4(6700, 12355, 16652) },
+                { AOM_CDF4(5088, 9704, 13716) },
+                { AOM_CDF4(4243, 8154, 11731) },
+                { AOM_CDF4(2702, 5364, 7861) },
+                { AOM_CDF4(22745, 28388, 30454) },
+                { AOM_CDF4(20235, 27146, 29922) },
+                { AOM_CDF4(15896, 23715, 27637) },
+                { AOM_CDF4(11840, 19350, 24131) },
+                { AOM_CDF4(9122, 15932, 20880) },
+                { AOM_CDF4(7488, 13581, 18362) },
+                { AOM_CDF4(5114, 9568, 13370) },
+                { AOM_CDF4(20845, 26553, 28932) },
+                { AOM_CDF4(20981, 27372, 29884) },
+                { AOM_CDF4(17781, 25335, 28785) },
+                { AOM_CDF4(13760, 21708, 26297) },
+                { AOM_CDF4(10975, 18415, 23365) },
+                { AOM_CDF4(9045, 15789, 20686) },
+                { AOM_CDF4(6130, 11199, 15423) } } },
+            { { { AOM_CDF4(13549, 19724, 23158) },
+                { AOM_CDF4(11844, 18382, 22246) },
+                { AOM_CDF4(7919, 13619, 17773) },
+                { AOM_CDF4(5486, 10143, 13946) },
+                { AOM_CDF4(4166, 7983, 11324) },
+                { AOM_CDF4(3364, 6506, 9427) },
+                { AOM_CDF4(1598, 3160, 4674) },
+                { AOM_CDF4(15281, 20979, 23781) },
+                { AOM_CDF4(14939, 22119, 25952) },
+                { AOM_CDF4(11363, 18407, 22812) },
+                { AOM_CDF4(8609, 14857, 19370) },
+                { AOM_CDF4(6737, 12184, 16480) },
+                { AOM_CDF4(5506, 10263, 14262) },
+                { AOM_CDF4(2990, 5786, 8380) },
+                { AOM_CDF4(20249, 25253, 27417) },
+                { AOM_CDF4(21070, 27518, 30001) },
+                { AOM_CDF4(16854, 24469, 28074) },
+                { AOM_CDF4(12864, 20486, 25000) },
+                { AOM_CDF4(9962, 16978, 21778) },
+                { AOM_CDF4(8074, 14338, 19048) },
+                { AOM_CDF4(4494, 8479, 11906) } },
+              { { AOM_CDF4(13960, 19617, 22829) },
+                { AOM_CDF4(11150, 17341, 21228) },
+                { AOM_CDF4(7150, 12964, 17190) },
+                { AOM_CDF4(5331, 10002, 13867) },
+                { AOM_CDF4(4167, 7744, 11057) },
+                { AOM_CDF4(3480, 6629, 9646) },
+                { AOM_CDF4(1883, 3784, 5686) },
+                { AOM_CDF4(18752, 25660, 28912) },
+                { AOM_CDF4(16968, 24586, 28030) },
+                { AOM_CDF4(13520, 21055, 25313) },
+                { AOM_CDF4(10453, 17626, 22280) },
+                { AOM_CDF4(8386, 14505, 19116) },
+                { AOM_CDF4(6742, 12595, 17008) },
+                { AOM_CDF4(4273, 8140, 11499) },
+                { AOM_CDF4(22120, 27827, 30233) },
+                { AOM_CDF4(20563, 27358, 29895) },
+                { AOM_CDF4(17076, 24644, 28153) },
+                { AOM_CDF4(13362, 20942, 25309) },
+                { AOM_CDF4(10794, 17965, 22695) },
+                { AOM_CDF4(9014, 15652, 20319) },
+                { AOM_CDF4(5708, 10512, 14497) } } },
+            { { { AOM_CDF4(5705, 10930, 15725) },
+                { AOM_CDF4(7946, 12765, 16115) },
+                { AOM_CDF4(6801, 12123, 16226) },
+                { AOM_CDF4(5462, 10135, 14200) },
+                { AOM_CDF4(4189, 8011, 11507) },
+                { AOM_CDF4(3191, 6229, 9408) },
+                { AOM_CDF4(1057, 2137, 3212) },
+                { AOM_CDF4(10018, 17067, 21491) },
+                { AOM_CDF4(7380, 12582, 16453) },
+                { AOM_CDF4(6068, 10845, 14339) },
+                { AOM_CDF4(5098, 9198, 12555) },
+                { AOM_CDF4(4312, 8010, 11119) },
+                { AOM_CDF4(3700, 6966, 9781) },
+                { AOM_CDF4(1693, 3326, 4887) },
+                { AOM_CDF4(18757, 24930, 27774) },
+                { AOM_CDF4(17648, 24596, 27817) },
+                { AOM_CDF4(14707, 22052, 26026) },
+                { AOM_CDF4(11720, 18852, 23292) },
+                { AOM_CDF4(9357, 15952, 20525) },
+                { AOM_CDF4(7810, 13753, 18210) },
+                { AOM_CDF4(3879, 7333, 10328) } },
+              { { AOM_CDF4(8278, 13242, 15922) },
+                { AOM_CDF4(10547, 15867, 18919) },
+                { AOM_CDF4(9106, 15842, 20609) },
+                { AOM_CDF4(6833, 13007, 17218) },
+                { AOM_CDF4(4811, 9712, 13923) },
+                { AOM_CDF4(3985, 7352, 11128) },
+                { AOM_CDF4(1688, 3458, 5262) },
+                { AOM_CDF4(12951, 21861, 26510) },
+                { AOM_CDF4(9788, 16044, 20276) },
+                { AOM_CDF4(6309, 11244, 14870) },
+                { AOM_CDF4(5183, 9349, 12566) },
+                { AOM_CDF4(4389, 8229, 11492) },
+                { AOM_CDF4(3633, 6945, 10620) },
+                { AOM_CDF4(3600, 6847, 9907) },
+                { AOM_CDF4(21748, 28137, 30255) },
+                { AOM_CDF4(19436, 26581, 29560) },
+                { AOM_CDF4(16359, 24201, 27953) },
+                { AOM_CDF4(13961, 21693, 25871) },
+                { AOM_CDF4(11544, 18686, 23322) },
+                { AOM_CDF4(9372, 16462, 20952) },
+                { AOM_CDF4(6138, 11210, 15390) } } }
+        },
+    }, [2] = {
+        .skip = {
+            { { AOM_CDF2(29614) },
+                { AOM_CDF2(9068) },
+                { AOM_CDF2(12924) },
+                { AOM_CDF2(19538) },
+                { AOM_CDF2(17737) },
+                { AOM_CDF2(24619) },
+                { AOM_CDF2(30642) },
+                { AOM_CDF2(4119) },
+                { AOM_CDF2(16026) },
+                { AOM_CDF2(25657) },
+                { AOM_CDF2(16384) },
+                { AOM_CDF2(16384) },
+                { AOM_CDF2(16384) } },
+            { { AOM_CDF2(31957) },
+                { AOM_CDF2(3230) },
+                { AOM_CDF2(11153) },
+                { AOM_CDF2(18123) },
+                { AOM_CDF2(20143) },
+                { AOM_CDF2(26536) },
+                { AOM_CDF2(31986) },
+                { AOM_CDF2(3050) },
+                { AOM_CDF2(14603) },
+                { AOM_CDF2(25155) },
+                { AOM_CDF2(16384) },
+                { AOM_CDF2(16384) },
+                { AOM_CDF2(16384) } },
+            { { AOM_CDF2(32363) },
+                { AOM_CDF2(10692) },
+                { AOM_CDF2(19090) },
+                { AOM_CDF2(24357) },
+                { AOM_CDF2(24442) },
+                { AOM_CDF2(28312) },
+                { AOM_CDF2(32169) },
+                { AOM_CDF2(3648) },
+                { AOM_CDF2(15690) },
+                { AOM_CDF2(26815) },
+                { AOM_CDF2(16384) },
+                { AOM_CDF2(16384) },
+                { AOM_CDF2(16384) } },
+            { { AOM_CDF2(30669) },
+                { AOM_CDF2(3832) },
+                { AOM_CDF2(11663) },
+                { AOM_CDF2(18889) },
+                { AOM_CDF2(19782) },
+                { AOM_CDF2(23313) },
+                { AOM_CDF2(31330) },
+                { AOM_CDF2(5124) },
+                { AOM_CDF2(18719) },
+                { AOM_CDF2(28468) },
+                { AOM_CDF2(3082) },
+                { AOM_CDF2(20982) },
+                { AOM_CDF2(29443) } },
+            { { AOM_CDF2(28573) },
+                { AOM_CDF2(3183) },
+                { AOM_CDF2(17802) },
+                { AOM_CDF2(25977) },
+                { AOM_CDF2(26677) },
+                { AOM_CDF2(27832) },
+                { AOM_CDF2(32387) },
+                { AOM_CDF2(16384) },
+                { AOM_CDF2(16384) },
+                { AOM_CDF2(16384) },
+                { AOM_CDF2(16384) },
+                { AOM_CDF2(16384) },
+                { AOM_CDF2(16384) } }
+        }, .eob_bin_16 = {
+            { { AOM_CDF5(4016, 4897, 8881, 14968) },
+              { AOM_CDF5(716, 1105, 2646, 10056) } },
+            { { AOM_CDF5(11139, 13270, 18241, 23566) },
+              { AOM_CDF5(3192, 5032, 10297, 19755) } }
+        }, .eob_bin_32 = {
+            { { AOM_CDF6(2515, 3003, 4452, 8162, 16041) },
+              { AOM_CDF6(574, 821, 1836, 5089, 13128) } },
+            { { AOM_CDF6(13468, 16303, 20361, 25105, 29281) },
+              { AOM_CDF6(3542, 5502, 10415, 16760, 25644) } }
+        }, .eob_bin_64 = {
+            { { AOM_CDF7(2374, 2772, 4583, 7276, 12288, 19706) },
+              { AOM_CDF7(497, 810, 1315, 3000, 7004, 15641) } },
+            { { AOM_CDF7(15050, 17126, 21410, 24886, 28156, 30726) },
+              { AOM_CDF7(4034, 6290, 10235, 14982, 21214, 28491) } }
+        }, .eob_bin_128 = {
+            { { AOM_CDF8(1366, 1738, 2527, 5016, 9355, 15797, 24643) },
+              { AOM_CDF8(354, 558, 944, 2760, 7287, 14037, 21779) } },
+            { { AOM_CDF8(13627, 16246, 20173, 24429, 27948, 30415, 31863) },
+              { AOM_CDF8(6275, 9889, 14769, 23164, 27988, 30493, 32272) } }
+        }, .eob_bin_256 = {
+            { { AOM_CDF9(3089, 3920, 6038, 9460, 14266, 19881, 25766, 29176) },
+              { AOM_CDF9(1084, 2358, 3488, 5122, 11483, 18103, 26023, 29799) } },
+            { { AOM_CDF9(11514, 13794, 17480, 20754, 24361, 27378, 29492, 31277) },
+              { AOM_CDF9(6571, 9610, 15516, 21826, 29092, 30829, 31842, 32708) } }
+        }, .eob_bin_512 = {
+            { { AOM_CDF10(2624, 3936, 6480, 9686, 13979, 17726, 23267,
+                          28410, 31078) },
+              { AOM_CDF10(3277, 6554, 9830, 13107, 16384, 19661, 22938,
+                          26214, 29491) } },
+            { { AOM_CDF10(12015, 14769, 19588, 22052, 24222, 25812,
+                          27300, 29219, 32114) },
+              { AOM_CDF10(3277, 6554, 9830, 13107, 16384, 19661, 22938,
+                          26214, 29491) } }
+        }, .eob_bin_1024 = {
+            { { AOM_CDF11(2784, 3831, 7041, 10521, 14847, 18844, 23155,
+                          26682, 29229, 31045) },
+              { AOM_CDF11(2979, 5958, 8937, 11916, 14895, 17873, 20852,
+                          23831, 26810, 29789) } },
+            { { AOM_CDF11(9577, 12466, 17739, 20750, 22061, 23215, 24601,
+                          25483, 25843, 32056) },
+              { AOM_CDF11(2979, 5958, 8937, 11916, 14895, 17873, 20852,
+                          23831, 26810, 29789) } }
+        }, .eob_hi_bit = {
+            { { { AOM_CDF2(16384) }, { AOM_CDF2(16384) },
+                { AOM_CDF2(18983) }, { AOM_CDF2(20512) }, { AOM_CDF2(14885) },
+                { AOM_CDF2(16384) }, { AOM_CDF2(16384) }, { AOM_CDF2(16384) },
+                { AOM_CDF2(16384) }, { AOM_CDF2(16384) }, { AOM_CDF2(16384) } },
+              { { AOM_CDF2(16384) }, { AOM_CDF2(16384) },
+                { AOM_CDF2(20090) }, { AOM_CDF2(19444) }, { AOM_CDF2(17286) },
+                { AOM_CDF2(16384) }, { AOM_CDF2(16384) }, { AOM_CDF2(16384) },
+                { AOM_CDF2(16384) }, { AOM_CDF2(16384) }, { AOM_CDF2(16384) } } },
+            { { { AOM_CDF2(16384) }, { AOM_CDF2(16384) },
+                { AOM_CDF2(19139) }, { AOM_CDF2(21487) }, { AOM_CDF2(18959) },
+                { AOM_CDF2(20910) }, { AOM_CDF2(19089) }, { AOM_CDF2(16384) },
+                { AOM_CDF2(16384) }, { AOM_CDF2(16384) }, { AOM_CDF2(16384) } },
+              { { AOM_CDF2(16384) }, { AOM_CDF2(16384) },
+                { AOM_CDF2(20536) }, { AOM_CDF2(20664) }, { AOM_CDF2(20625) },
+                { AOM_CDF2(19123) }, { AOM_CDF2(14862) }, { AOM_CDF2(16384) },
+                { AOM_CDF2(16384) }, { AOM_CDF2(16384) }, { AOM_CDF2(16384) } } },
+            { { { AOM_CDF2(16384) }, { AOM_CDF2(16384) },
+                { AOM_CDF2(19833) }, { AOM_CDF2(21502) }, { AOM_CDF2(17485) },
+                { AOM_CDF2(20267) }, { AOM_CDF2(18353) }, { AOM_CDF2(23329) },
+                { AOM_CDF2(21478) }, { AOM_CDF2(16384) }, { AOM_CDF2(16384) } },
+              { { AOM_CDF2(16384) }, { AOM_CDF2(16384) },
+                { AOM_CDF2(22041) }, { AOM_CDF2(23434) }, { AOM_CDF2(20001) },
+                { AOM_CDF2(20554) }, { AOM_CDF2(20951) }, { AOM_CDF2(20145) },
+                { AOM_CDF2(15562) }, { AOM_CDF2(16384) }, { AOM_CDF2(16384) } } },
+            { { { AOM_CDF2(16384) }, { AOM_CDF2(16384) },
+                { AOM_CDF2(23312) }, { AOM_CDF2(21607) }, { AOM_CDF2(16526) },
+                { AOM_CDF2(18957) }, { AOM_CDF2(18034) }, { AOM_CDF2(18934) },
+                { AOM_CDF2(24247) }, { AOM_CDF2(16921) }, { AOM_CDF2(17080) } },
+              { { AOM_CDF2(16384) }, { AOM_CDF2(16384) },
+                { AOM_CDF2(26579) }, { AOM_CDF2(24910) }, { AOM_CDF2(18637) },
+                { AOM_CDF2(19800) }, { AOM_CDF2(20388) }, { AOM_CDF2(9887) },
+                { AOM_CDF2(15642) }, { AOM_CDF2(30198) }, { AOM_CDF2(24721) } } },
+            { { { AOM_CDF2(16384) }, { AOM_CDF2(16384) },
+                { AOM_CDF2(26998) }, { AOM_CDF2(16737) }, { AOM_CDF2(17838) },
+                { AOM_CDF2(18922) }, { AOM_CDF2(19515) }, { AOM_CDF2(18636) },
+                { AOM_CDF2(17333) }, { AOM_CDF2(15776) }, { AOM_CDF2(22658) } },
+              { { AOM_CDF2(16384) }, { AOM_CDF2(16384) },
+                { AOM_CDF2(16384) }, { AOM_CDF2(16384) }, { AOM_CDF2(16384) },
+                { AOM_CDF2(16384) }, { AOM_CDF2(16384) }, { AOM_CDF2(16384) },
+                { AOM_CDF2(16384) }, { AOM_CDF2(16384) }, { AOM_CDF2(16384) } } }
+        }, .eob_base_tok = {
+            { { { AOM_CDF3(20092, 30774) },
+                { AOM_CDF3(30695, 32020) },
+                { AOM_CDF3(31131, 32103) },
+                { AOM_CDF3(28666, 30870) } },
+              { { AOM_CDF3(27258, 31095) },
+                { AOM_CDF3(31804, 32623) },
+                { AOM_CDF3(31763, 32528) },
+                { AOM_CDF3(31438, 32506) } } },
+            { { { AOM_CDF3(18049, 30489) },
+                { AOM_CDF3(31706, 32286) },
+                { AOM_CDF3(32163, 32473) },
+                { AOM_CDF3(31550, 32184) } },
+              { { AOM_CDF3(27116, 30842) },
+                { AOM_CDF3(31971, 32598) },
+                { AOM_CDF3(32088, 32576) },
+                { AOM_CDF3(32067, 32664) } } },
+            { { { AOM_CDF3(12854, 29093) },
+                { AOM_CDF3(32272, 32558) },
+                { AOM_CDF3(32667, 32729) },
+                { AOM_CDF3(32306, 32585) } },
+              { { AOM_CDF3(25476, 30366) },
+                { AOM_CDF3(32169, 32687) },
+                { AOM_CDF3(32479, 32689) },
+                { AOM_CDF3(31673, 32634) } } },
+            { { { AOM_CDF3(2809, 19301) },
+                { AOM_CDF3(32205, 32622) },
+                { AOM_CDF3(32338, 32730) },
+                { AOM_CDF3(31786, 32616) } },
+              { { AOM_CDF3(22737, 29105) },
+                { AOM_CDF3(30810, 32362) },
+                { AOM_CDF3(30014, 32627) },
+                { AOM_CDF3(30528, 32574) } } },
+            { { { AOM_CDF3(935, 3382) },
+                { AOM_CDF3(30789, 31909) },
+                { AOM_CDF3(32466, 32756) },
+                { AOM_CDF3(30860, 32513) } },
+              { { AOM_CDF3(10923, 21845) },
+                { AOM_CDF3(10923, 21845) },
+                { AOM_CDF3(10923, 21845) },
+                { AOM_CDF3(10923, 21845) } } }
+        }, .base_tok = {
+            { { { AOM_CDF4(8896, 16227, 20630) },
+                { AOM_CDF4(23629, 31782, 32527) },
+                { AOM_CDF4(15173, 27755, 31321) },
+                { AOM_CDF4(10158, 21233, 27382) },
+                { AOM_CDF4(6420, 14857, 21558) },
+                { AOM_CDF4(3269, 8155, 12646) },
+                { AOM_CDF4(24835, 32009, 32496) },
+                { AOM_CDF4(16509, 28421, 31579) },
+                { AOM_CDF4(10957, 21514, 27418) },
+                { AOM_CDF4(7881, 15930, 22096) },
+                { AOM_CDF4(5388, 10960, 15918) },
+                { AOM_CDF4(8192, 16384, 24576) },
+                { AOM_CDF4(8192, 16384, 24576) },
+                { AOM_CDF4(8192, 16384, 24576) },
+                { AOM_CDF4(8192, 16384, 24576) },
+                { AOM_CDF4(8192, 16384, 24576) },
+                { AOM_CDF4(8192, 16384, 24576) },
+                { AOM_CDF4(8192, 16384, 24576) },
+                { AOM_CDF4(8192, 16384, 24576) },
+                { AOM_CDF4(8192, 16384, 24576) },
+                { AOM_CDF4(8192, 16384, 24576) },
+                { AOM_CDF4(20745, 30773, 32093) },
+                { AOM_CDF4(15200, 27221, 30861) },
+                { AOM_CDF4(13032, 20873, 25667) },
+                { AOM_CDF4(12285, 18663, 23494) },
+                { AOM_CDF4(11563, 17481, 21489) },
+                { AOM_CDF4(26260, 31982, 32320) },
+                { AOM_CDF4(15397, 28083, 31100) },
+                { AOM_CDF4(9742, 19217, 24824) },
+                { AOM_CDF4(3261, 9629, 15362) },
+                { AOM_CDF4(1480, 4322, 7499) },
+                { AOM_CDF4(27599, 32256, 32460) },
+                { AOM_CDF4(16857, 27659, 30774) },
+                { AOM_CDF4(9551, 18290, 23748) },
+                { AOM_CDF4(3052, 8933, 14103) },
+                { AOM_CDF4(2021, 5910, 9787) },
+                { AOM_CDF4(29005, 32015, 32392) },
+                { AOM_CDF4(17677, 27694, 30863) },
+                { AOM_CDF4(9204, 17356, 23219) },
+                { AOM_CDF4(2403, 7516, 12814) },
+                { AOM_CDF4(8192, 16384, 24576) } },
+              { { AOM_CDF4(10808, 22056, 26896) },
+                { AOM_CDF4(25739, 32313, 32676) },
+                { AOM_CDF4(17288, 30203, 32221) },
+                { AOM_CDF4(11359, 24878, 29896) },
+                { AOM_CDF4(6949, 17767, 24893) },
+                { AOM_CDF4(4287, 11796, 18071) },
+                { AOM_CDF4(27880, 32521, 32705) },
+                { AOM_CDF4(19038, 31004, 32414) },
+                { AOM_CDF4(12564, 26345, 30768) },
+                { AOM_CDF4(8269, 19947, 26779) },
+                { AOM_CDF4(5674, 14657, 21674) },
+                { AOM_CDF4(8192, 16384, 24576) },
+                { AOM_CDF4(8192, 16384, 24576) },
+                { AOM_CDF4(8192, 16384, 24576) },
+                { AOM_CDF4(8192, 16384, 24576) },
+                { AOM_CDF4(8192, 16384, 24576) },
+                { AOM_CDF4(8192, 16384, 24576) },
+                { AOM_CDF4(8192, 16384, 24576) },
+                { AOM_CDF4(8192, 16384, 24576) },
+                { AOM_CDF4(8192, 16384, 24576) },
+                { AOM_CDF4(8192, 16384, 24576) },
+                { AOM_CDF4(25742, 32319, 32671) },
+                { AOM_CDF4(19557, 31164, 32454) },
+                { AOM_CDF4(13381, 26381, 30755) },
+                { AOM_CDF4(10101, 21466, 26722) },
+                { AOM_CDF4(9209, 19650, 26825) },
+                { AOM_CDF4(27107, 31917, 32432) },
+                { AOM_CDF4(18056, 28893, 31203) },
+                { AOM_CDF4(10200, 21434, 26764) },
+                { AOM_CDF4(4660, 12913, 19502) },
+                { AOM_CDF4(2368, 6930, 12504) },
+                { AOM_CDF4(26960, 32158, 32613) },
+                { AOM_CDF4(18628, 30005, 32031) },
+                { AOM_CDF4(10233, 22442, 28232) },
+                { AOM_CDF4(5471, 14630, 21516) },
+                { AOM_CDF4(3235, 10767, 17109) },
+                { AOM_CDF4(27696, 32440, 32692) },
+                { AOM_CDF4(20032, 31167, 32438) },
+                { AOM_CDF4(8700, 21341, 28442) },
+                { AOM_CDF4(5662, 14831, 21795) },
+                { AOM_CDF4(8192, 16384, 24576) } } },
+            { { { AOM_CDF4(9704, 17294, 21132) },
+                { AOM_CDF4(26762, 32278, 32633) },
+                { AOM_CDF4(18382, 29620, 31819) },
+                { AOM_CDF4(10891, 23475, 28723) },
+                { AOM_CDF4(6358, 16583, 23309) },
+                { AOM_CDF4(3248, 9118, 14141) },
+                { AOM_CDF4(27204, 32573, 32699) },
+                { AOM_CDF4(19818, 30824, 32329) },
+                { AOM_CDF4(11772, 25120, 30041) },
+                { AOM_CDF4(6995, 18033, 25039) },
+                { AOM_CDF4(3752, 10442, 16098) },
+                { AOM_CDF4(27222, 32256, 32559) },
+                { AOM_CDF4(15356, 28399, 31475) },
+                { AOM_CDF4(8821, 20635, 27057) },
+                { AOM_CDF4(5511, 14404, 21239) },
+                { AOM_CDF4(2935, 8222, 13051) },
+                { AOM_CDF4(24875, 32120, 32529) },
+                { AOM_CDF4(15233, 28265, 31445) },
+                { AOM_CDF4(8605, 20570, 26932) },
+                { AOM_CDF4(5431, 14413, 21196) },
+                { AOM_CDF4(2994, 8341, 13223) },
+                { AOM_CDF4(28201, 32604, 32700) },
+                { AOM_CDF4(21041, 31446, 32456) },
+                { AOM_CDF4(13221, 26213, 30475) },
+                { AOM_CDF4(8255, 19385, 26037) },
+                { AOM_CDF4(4930, 12585, 18830) },
+                { AOM_CDF4(28768, 32448, 32627) },
+                { AOM_CDF4(19705, 30561, 32021) },
+                { AOM_CDF4(11572, 23589, 28220) },
+                { AOM_CDF4(5532, 15034, 21446) },
+                { AOM_CDF4(2460, 7150, 11456) },
+                { AOM_CDF4(29874, 32619, 32699) },
+                { AOM_CDF4(21621, 31071, 32201) },
+                { AOM_CDF4(12511, 24747, 28992) },
+                { AOM_CDF4(6281, 16395, 22748) },
+                { AOM_CDF4(3246, 9278, 14497) },
+                { AOM_CDF4(29715, 32625, 32712) },
+                { AOM_CDF4(20958, 31011, 32283) },
+                { AOM_CDF4(11233, 23671, 28806) },
+                { AOM_CDF4(6012, 16128, 22868) },
+                { AOM_CDF4(3427, 9851, 15414) } },
+              { { AOM_CDF4(11016, 22111, 26794) },
+                { AOM_CDF4(25946, 32357, 32677) },
+                { AOM_CDF4(17890, 30452, 32252) },
+                { AOM_CDF4(11678, 25142, 29816) },
+                { AOM_CDF4(6720, 17534, 24584) },
+                { AOM_CDF4(4230, 11665, 17820) },
+                { AOM_CDF4(28400, 32623, 32747) },
+                { AOM_CDF4(21164, 31668, 32575) },
+                { AOM_CDF4(13572, 27388, 31182) },
+                { AOM_CDF4(8234, 20750, 27358) },
+                { AOM_CDF4(5065, 14055, 20897) },
+                { AOM_CDF4(28981, 32547, 32705) },
+                { AOM_CDF4(18681, 30543, 32239) },
+                { AOM_CDF4(10919, 24075, 29286) },
+                { AOM_CDF4(6431, 17199, 24077) },
+                { AOM_CDF4(3819, 10464, 16618) },
+                { AOM_CDF4(26870, 32467, 32693) },
+                { AOM_CDF4(19041, 30831, 32347) },
+                { AOM_CDF4(11794, 25211, 30016) },
+                { AOM_CDF4(6888, 18019, 24970) },
+                { AOM_CDF4(4370, 12363, 18992) },
+                { AOM_CDF4(29578, 32670, 32744) },
+                { AOM_CDF4(23159, 32007, 32613) },
+                { AOM_CDF4(15315, 28669, 31676) },
+                { AOM_CDF4(9298, 22607, 28782) },
+                { AOM_CDF4(6144, 15913, 22968) },
+                { AOM_CDF4(28110, 32499, 32669) },
+                { AOM_CDF4(21574, 30937, 32015) },
+                { AOM_CDF4(12759, 24818, 28727) },
+                { AOM_CDF4(6545, 16761, 23042) },
+                { AOM_CDF4(3649, 10597, 16833) },
+                { AOM_CDF4(28163, 32552, 32728) },
+                { AOM_CDF4(22101, 31469, 32464) },
+                { AOM_CDF4(13160, 25472, 30143) },
+                { AOM_CDF4(7303, 18684, 25468) },
+                { AOM_CDF4(5241, 13975, 20955) },
+                { AOM_CDF4(28400, 32631, 32744) },
+                { AOM_CDF4(22104, 31793, 32603) },
+                { AOM_CDF4(13557, 26571, 30846) },
+                { AOM_CDF4(7749, 19861, 26675) },
+                { AOM_CDF4(4873, 14030, 21234) } } },
+            { { { AOM_CDF4(9800, 17635, 21073) },
+                { AOM_CDF4(26153, 31885, 32527) },
+                { AOM_CDF4(15038, 27852, 31006) },
+                { AOM_CDF4(8718, 20564, 26486) },
+                { AOM_CDF4(5128, 14076, 20514) },
+                { AOM_CDF4(2636, 7566, 11925) },
+                { AOM_CDF4(27551, 32504, 32701) },
+                { AOM_CDF4(18310, 30054, 32100) },
+                { AOM_CDF4(10211, 23420, 29082) },
+                { AOM_CDF4(6222, 16876, 23916) },
+                { AOM_CDF4(3462, 9954, 15498) },
+                { AOM_CDF4(29991, 32633, 32721) },
+                { AOM_CDF4(19883, 30751, 32201) },
+                { AOM_CDF4(11141, 24184, 29285) },
+                { AOM_CDF4(6420, 16940, 23774) },
+                { AOM_CDF4(3392, 9753, 15118) },
+                { AOM_CDF4(28465, 32616, 32712) },
+                { AOM_CDF4(19850, 30702, 32244) },
+                { AOM_CDF4(10983, 24024, 29223) },
+                { AOM_CDF4(6294, 16770, 23582) },
+                { AOM_CDF4(3244, 9283, 14509) },
+                { AOM_CDF4(30023, 32717, 32748) },
+                { AOM_CDF4(22940, 32032, 32626) },
+                { AOM_CDF4(14282, 27928, 31473) },
+                { AOM_CDF4(8562, 21327, 27914) },
+                { AOM_CDF4(4846, 13393, 19919) },
+                { AOM_CDF4(29981, 32590, 32695) },
+                { AOM_CDF4(20465, 30963, 32166) },
+                { AOM_CDF4(11479, 23579, 28195) },
+                { AOM_CDF4(5916, 15648, 22073) },
+                { AOM_CDF4(3031, 8605, 13398) },
+                { AOM_CDF4(31146, 32691, 32739) },
+                { AOM_CDF4(23106, 31724, 32444) },
+                { AOM_CDF4(13783, 26738, 30439) },
+                { AOM_CDF4(7852, 19468, 25807) },
+                { AOM_CDF4(3860, 11124, 16853) },
+                { AOM_CDF4(31014, 32724, 32748) },
+                { AOM_CDF4(23629, 32109, 32628) },
+                { AOM_CDF4(14747, 28115, 31403) },
+                { AOM_CDF4(8545, 21242, 27478) },
+                { AOM_CDF4(4574, 12781, 19067) } },
+              { { AOM_CDF4(9185, 19694, 24688) },
+                { AOM_CDF4(26081, 31985, 32621) },
+                { AOM_CDF4(16015, 29000, 31787) },
+                { AOM_CDF4(10542, 23690, 29206) },
+                { AOM_CDF4(6732, 17945, 24677) },
+                { AOM_CDF4(3916, 11039, 16722) },
+                { AOM_CDF4(28224, 32566, 32744) },
+                { AOM_CDF4(19100, 31138, 32485) },
+                { AOM_CDF4(12528, 26620, 30879) },
+                { AOM_CDF4(7741, 20277, 26885) },
+                { AOM_CDF4(4566, 12845, 18990) },
+                { AOM_CDF4(29933, 32593, 32718) },
+                { AOM_CDF4(17670, 30333, 32155) },
+                { AOM_CDF4(10385, 23600, 28909) },
+                { AOM_CDF4(6243, 16236, 22407) },
+                { AOM_CDF4(3976, 10389, 16017) },
+                { AOM_CDF4(28377, 32561, 32738) },
+                { AOM_CDF4(19366, 31175, 32482) },
+                { AOM_CDF4(13327, 27175, 31094) },
+                { AOM_CDF4(8258, 20769, 27143) },
+                { AOM_CDF4(4703, 13198, 19527) },
+                { AOM_CDF4(31086, 32706, 32748) },
+                { AOM_CDF4(22853, 31902, 32583) },
+                { AOM_CDF4(14759, 28186, 31419) },
+                { AOM_CDF4(9284, 22382, 28348) },
+                { AOM_CDF4(5585, 15192, 21868) },
+                { AOM_CDF4(28291, 32652, 32746) },
+                { AOM_CDF4(19849, 32107, 32571) },
+                { AOM_CDF4(14834, 26818, 29214) },
+                { AOM_CDF4(10306, 22594, 28672) },
+                { AOM_CDF4(6615, 17384, 23384) },
+                { AOM_CDF4(28947, 32604, 32745) },
+                { AOM_CDF4(25625, 32289, 32646) },
+                { AOM_CDF4(18758, 28672, 31403) },
+                { AOM_CDF4(10017, 23430, 28523) },
+                { AOM_CDF4(6862, 15269, 22131) },
+                { AOM_CDF4(23933, 32509, 32739) },
+                { AOM_CDF4(19927, 31495, 32631) },
+                { AOM_CDF4(11903, 26023, 30621) },
+                { AOM_CDF4(7026, 20094, 27252) },
+                { AOM_CDF4(5998, 18106, 24437) } } },
+            { { { AOM_CDF4(4456, 11274, 15533) },
+                { AOM_CDF4(21219, 29079, 31616) },
+                { AOM_CDF4(11173, 23774, 28567) },
+                { AOM_CDF4(7282, 18293, 24263) },
+                { AOM_CDF4(4890, 13286, 19115) },
+                { AOM_CDF4(1890, 5508, 8659) },
+                { AOM_CDF4(26651, 32136, 32647) },
+                { AOM_CDF4(14630, 28254, 31455) },
+                { AOM_CDF4(8716, 21287, 27395) },
+                { AOM_CDF4(5615, 15331, 22008) },
+                { AOM_CDF4(2675, 7700, 12150) },
+                { AOM_CDF4(29954, 32526, 32690) },
+                { AOM_CDF4(16126, 28982, 31633) },
+                { AOM_CDF4(9030, 21361, 27352) },
+                { AOM_CDF4(5411, 14793, 21271) },
+                { AOM_CDF4(2943, 8422, 13163) },
+                { AOM_CDF4(29539, 32601, 32730) },
+                { AOM_CDF4(18125, 30385, 32201) },
+                { AOM_CDF4(10422, 24090, 29468) },
+                { AOM_CDF4(6468, 17487, 24438) },
+                { AOM_CDF4(2970, 8653, 13531) },
+                { AOM_CDF4(30912, 32715, 32748) },
+                { AOM_CDF4(20666, 31373, 32497) },
+                { AOM_CDF4(12509, 26640, 30917) },
+                { AOM_CDF4(8058, 20629, 27290) },
+                { AOM_CDF4(4231, 12006, 18052) },
+                { AOM_CDF4(8192, 16384, 24576) },
+                { AOM_CDF4(8192, 16384, 24576) },
+                { AOM_CDF4(8192, 16384, 24576) },
+                { AOM_CDF4(8192, 16384, 24576) },
+                { AOM_CDF4(8192, 16384, 24576) },
+                { AOM_CDF4(8192, 16384, 24576) },
+                { AOM_CDF4(8192, 16384, 24576) },
+                { AOM_CDF4(8192, 16384, 24576) },
+                { AOM_CDF4(8192, 16384, 24576) },
+                { AOM_CDF4(8192, 16384, 24576) },
+                { AOM_CDF4(8192, 16384, 24576) },
+                { AOM_CDF4(8192, 16384, 24576) },
+                { AOM_CDF4(8192, 16384, 24576) },
+                { AOM_CDF4(8192, 16384, 24576) },
+                { AOM_CDF4(8192, 16384, 24576) } },
+              { { AOM_CDF4(10202, 20633, 25484) },
+                { AOM_CDF4(27336, 31445, 32352) },
+                { AOM_CDF4(12420, 24384, 28552) },
+                { AOM_CDF4(7648, 18115, 23856) },
+                { AOM_CDF4(5662, 14341, 19902) },
+                { AOM_CDF4(3611, 10328, 15390) },
+                { AOM_CDF4(30945, 32616, 32736) },
+                { AOM_CDF4(18682, 30505, 32253) },
+                { AOM_CDF4(11513, 25336, 30203) },
+                { AOM_CDF4(7449, 19452, 26148) },
+                { AOM_CDF4(4482, 13051, 18886) },
+                { AOM_CDF4(32022, 32690, 32747) },
+                { AOM_CDF4(18578, 30501, 32146) },
+                { AOM_CDF4(11249, 23368, 28631) },
+                { AOM_CDF4(5645, 16958, 22158) },
+                { AOM_CDF4(5009, 11444, 16637) },
+                { AOM_CDF4(31357, 32710, 32748) },
+                { AOM_CDF4(21552, 31494, 32504) },
+                { AOM_CDF4(13891, 27677, 31340) },
+                { AOM_CDF4(9051, 22098, 28172) },
+                { AOM_CDF4(5190, 13377, 19486) },
+                { AOM_CDF4(32364, 32740, 32748) },
+                { AOM_CDF4(24839, 31907, 32551) },
+                { AOM_CDF4(17160, 28779, 31696) },
+                { AOM_CDF4(12452, 24137, 29602) },
+                { AOM_CDF4(6165, 15389, 22477) },
+                { AOM_CDF4(8192, 16384, 24576) },
+                { AOM_CDF4(8192, 16384, 24576) },
+                { AOM_CDF4(8192, 16384, 24576) },
+                { AOM_CDF4(8192, 16384, 24576) },
+                { AOM_CDF4(8192, 16384, 24576) },
+                { AOM_CDF4(8192, 16384, 24576) },
+                { AOM_CDF4(8192, 16384, 24576) },
+                { AOM_CDF4(8192, 16384, 24576) },
+                { AOM_CDF4(8192, 16384, 24576) },
+                { AOM_CDF4(8192, 16384, 24576) },
+                { AOM_CDF4(8192, 16384, 24576) },
+                { AOM_CDF4(8192, 16384, 24576) },
+                { AOM_CDF4(8192, 16384, 24576) },
+                { AOM_CDF4(8192, 16384, 24576) },
+                { AOM_CDF4(8192, 16384, 24576) } } },
+            { { { AOM_CDF4(2575, 7281, 11077) },
+                { AOM_CDF4(14002, 20866, 25402) },
+                { AOM_CDF4(6343, 15056, 19658) },
+                { AOM_CDF4(4474, 11858, 17041) },
+                { AOM_CDF4(2865, 8299, 12534) },
+                { AOM_CDF4(1344, 3949, 6391) },
+                { AOM_CDF4(24720, 31239, 32459) },
+                { AOM_CDF4(12585, 25356, 29968) },
+                { AOM_CDF4(7181, 18246, 24444) },
+                { AOM_CDF4(5025, 13667, 19885) },
+                { AOM_CDF4(2521, 7304, 11605) },
+                { AOM_CDF4(29908, 32252, 32584) },
+                { AOM_CDF4(17421, 29156, 31575) },
+                { AOM_CDF4(9889, 22188, 27782) },
+                { AOM_CDF4(5878, 15647, 22123) },
+                { AOM_CDF4(2814, 8665, 13323) },
+                { AOM_CDF4(30183, 32568, 32713) },
+                { AOM_CDF4(18528, 30195, 32049) },
+                { AOM_CDF4(10982, 24606, 29657) },
+                { AOM_CDF4(6957, 18165, 25231) },
+                { AOM_CDF4(3508, 10118, 15468) },
+                { AOM_CDF4(31761, 32736, 32748) },
+                { AOM_CDF4(21041, 31328, 32546) },
+                { AOM_CDF4(12568, 26732, 31166) },
+                { AOM_CDF4(8052, 20720, 27733) },
+                { AOM_CDF4(4336, 12192, 18396) },
+                { AOM_CDF4(8192, 16384, 24576) },
+                { AOM_CDF4(8192, 16384, 24576) },
+                { AOM_CDF4(8192, 16384, 24576) },
+                { AOM_CDF4(8192, 16384, 24576) },
+                { AOM_CDF4(8192, 16384, 24576) },
+                { AOM_CDF4(8192, 16384, 24576) },
+                { AOM_CDF4(8192, 16384, 24576) },
+                { AOM_CDF4(8192, 16384, 24576) },
+                { AOM_CDF4(8192, 16384, 24576) },
+                { AOM_CDF4(8192, 16384, 24576) },
+                { AOM_CDF4(8192, 16384, 24576) },
+                { AOM_CDF4(8192, 16384, 24576) },
+                { AOM_CDF4(8192, 16384, 24576) },
+                { AOM_CDF4(8192, 16384, 24576) },
+                { AOM_CDF4(8192, 16384, 24576) } },
+              { { AOM_CDF4(8192, 16384, 24576) },
+                { AOM_CDF4(8192, 16384, 24576) },
+                { AOM_CDF4(8192, 16384, 24576) },
+                { AOM_CDF4(8192, 16384, 24576) },
+                { AOM_CDF4(8192, 16384, 24576) },
+                { AOM_CDF4(8192, 16384, 24576) },
+                { AOM_CDF4(8192, 16384, 24576) },
+                { AOM_CDF4(8192, 16384, 24576) },
+                { AOM_CDF4(8192, 16384, 24576) },
+                { AOM_CDF4(8192, 16384, 24576) },
+                { AOM_CDF4(8192, 16384, 24576) },
+                { AOM_CDF4(8192, 16384, 24576) },
+                { AOM_CDF4(8192, 16384, 24576) },
+                { AOM_CDF4(8192, 16384, 24576) },
+                { AOM_CDF4(8192, 16384, 24576) },
+                { AOM_CDF4(8192, 16384, 24576) },
+                { AOM_CDF4(8192, 16384, 24576) },
+                { AOM_CDF4(8192, 16384, 24576) },
+                { AOM_CDF4(8192, 16384, 24576) },
+                { AOM_CDF4(8192, 16384, 24576) },
+                { AOM_CDF4(8192, 16384, 24576) },
+                { AOM_CDF4(8192, 16384, 24576) },
+                { AOM_CDF4(8192, 16384, 24576) },
+                { AOM_CDF4(8192, 16384, 24576) },
+                { AOM_CDF4(8192, 16384, 24576) },
+                { AOM_CDF4(8192, 16384, 24576) },
+                { AOM_CDF4(8192, 16384, 24576) },
+                { AOM_CDF4(8192, 16384, 24576) },
+                { AOM_CDF4(8192, 16384, 24576) },
+                { AOM_CDF4(8192, 16384, 24576) },
+                { AOM_CDF4(8192, 16384, 24576) },
+                { AOM_CDF4(8192, 16384, 24576) },
+                { AOM_CDF4(8192, 16384, 24576) },
+                { AOM_CDF4(8192, 16384, 24576) },
+                { AOM_CDF4(8192, 16384, 24576) },
+                { AOM_CDF4(8192, 16384, 24576) },
+                { AOM_CDF4(8192, 16384, 24576) },
+                { AOM_CDF4(8192, 16384, 24576) },
+                { AOM_CDF4(8192, 16384, 24576) },
+                { AOM_CDF4(8192, 16384, 24576) },
+                { AOM_CDF4(8192, 16384, 24576) } } }
+        }, .dc_sign = {
+            {
+                { AOM_CDF2(128 * 125) },
+                { AOM_CDF2(128 * 102) },
+                { AOM_CDF2(128 * 147) },
+            },
+            {
+                { AOM_CDF2(128 * 119) },
+                { AOM_CDF2(128 * 101) },
+                { AOM_CDF2(128 * 135) },
+            }
+        }, .br_tok = {
+            { { { AOM_CDF4(16138, 22223, 25509) },
+                { AOM_CDF4(15347, 22430, 26332) },
+                { AOM_CDF4(9614, 16736, 21332) },
+                { AOM_CDF4(6600, 12275, 16907) },
+                { AOM_CDF4(4811, 9424, 13547) },
+                { AOM_CDF4(3748, 7809, 11420) },
+                { AOM_CDF4(2254, 4587, 6890) },
+                { AOM_CDF4(15196, 20284, 23177) },
+                { AOM_CDF4(18317, 25469, 28451) },
+                { AOM_CDF4(13918, 21651, 25842) },
+                { AOM_CDF4(10052, 17150, 21995) },
+                { AOM_CDF4(7499, 13630, 18587) },
+                { AOM_CDF4(6158, 11417, 16003) },
+                { AOM_CDF4(4014, 7785, 11252) },
+                { AOM_CDF4(15048, 21067, 24384) },
+                { AOM_CDF4(18202, 25346, 28553) },
+                { AOM_CDF4(14302, 22019, 26356) },
+                { AOM_CDF4(10839, 18139, 23166) },
+                { AOM_CDF4(8715, 15744, 20806) },
+                { AOM_CDF4(7536, 13576, 18544) },
+                { AOM_CDF4(5413, 10335, 14498) } },
+              { { AOM_CDF4(17394, 24501, 27895) },
+                { AOM_CDF4(15889, 23420, 27185) },
+                { AOM_CDF4(11561, 19133, 23870) },
+                { AOM_CDF4(8285, 14812, 19844) },
+                { AOM_CDF4(6496, 12043, 16550) },
+                { AOM_CDF4(4771, 9574, 13677) },
+                { AOM_CDF4(3603, 6830, 10144) },
+                { AOM_CDF4(21656, 27704, 30200) },
+                { AOM_CDF4(21324, 27915, 30511) },
+                { AOM_CDF4(17327, 25336, 28997) },
+                { AOM_CDF4(13417, 21381, 26033) },
+                { AOM_CDF4(10132, 17425, 22338) },
+                { AOM_CDF4(8580, 15016, 19633) },
+                { AOM_CDF4(5694, 11477, 16411) },
+                { AOM_CDF4(24116, 29780, 31450) },
+                { AOM_CDF4(23853, 29695, 31591) },
+                { AOM_CDF4(20085, 27614, 30428) },
+                { AOM_CDF4(15326, 24335, 28575) },
+                { AOM_CDF4(11814, 19472, 24810) },
+                { AOM_CDF4(10221, 18611, 24767) },
+                { AOM_CDF4(7689, 14558, 20321) } } },
+            { { { AOM_CDF4(16214, 22380, 25770) },
+                { AOM_CDF4(14213, 21304, 25295) },
+                { AOM_CDF4(9213, 15823, 20455) },
+                { AOM_CDF4(6395, 11758, 16139) },
+                { AOM_CDF4(4779, 9187, 13066) },
+                { AOM_CDF4(3821, 7501, 10953) },
+                { AOM_CDF4(2293, 4567, 6795) },
+                { AOM_CDF4(15859, 21283, 23820) },
+                { AOM_CDF4(18404, 25602, 28726) },
+                { AOM_CDF4(14325, 21980, 26206) },
+                { AOM_CDF4(10669, 17937, 22720) },
+                { AOM_CDF4(8297, 14642, 19447) },
+                { AOM_CDF4(6746, 12389, 16893) },
+                { AOM_CDF4(4324, 8251, 11770) },
+                { AOM_CDF4(16532, 21631, 24475) },
+                { AOM_CDF4(20667, 27150, 29668) },
+                { AOM_CDF4(16728, 24510, 28175) },
+                { AOM_CDF4(12861, 20645, 25332) },
+                { AOM_CDF4(10076, 17361, 22417) },
+                { AOM_CDF4(8395, 14940, 19963) },
+                { AOM_CDF4(5731, 10683, 14912) } },
+              { { AOM_CDF4(14433, 21155, 24938) },
+                { AOM_CDF4(14658, 21716, 25545) },
+                { AOM_CDF4(9923, 16824, 21557) },
+                { AOM_CDF4(6982, 13052, 17721) },
+                { AOM_CDF4(5419, 10503, 15050) },
+                { AOM_CDF4(4852, 9162, 13014) },
+                { AOM_CDF4(3271, 6395, 9630) },
+                { AOM_CDF4(22210, 27833, 30109) },
+                { AOM_CDF4(20750, 27368, 29821) },
+                { AOM_CDF4(16894, 24828, 28573) },
+                { AOM_CDF4(13247, 21276, 25757) },
+                { AOM_CDF4(10038, 17265, 22563) },
+                { AOM_CDF4(8587, 14947, 20327) },
+                { AOM_CDF4(5645, 11371, 15252) },
+                { AOM_CDF4(22027, 27526, 29714) },
+                { AOM_CDF4(23098, 29146, 31221) },
+                { AOM_CDF4(19886, 27341, 30272) },
+                { AOM_CDF4(15609, 23747, 28046) },
+                { AOM_CDF4(11993, 20065, 24939) },
+                { AOM_CDF4(9637, 18267, 23671) },
+                { AOM_CDF4(7625, 13801, 19144) } } },
+            { { { AOM_CDF4(14438, 20798, 24089) },
+                { AOM_CDF4(12621, 19203, 23097) },
+                { AOM_CDF4(8177, 14125, 18402) },
+                { AOM_CDF4(5674, 10501, 14456) },
+                { AOM_CDF4(4236, 8239, 11733) },
+                { AOM_CDF4(3447, 6750, 9806) },
+                { AOM_CDF4(1986, 3950, 5864) },
+                { AOM_CDF4(16208, 22099, 24930) },
+                { AOM_CDF4(16537, 24025, 27585) },
+                { AOM_CDF4(12780, 20381, 24867) },
+                { AOM_CDF4(9767, 16612, 21416) },
+                { AOM_CDF4(7686, 13738, 18398) },
+                { AOM_CDF4(6333, 11614, 15964) },
+                { AOM_CDF4(3941, 7571, 10836) },
+                { AOM_CDF4(22819, 27422, 29202) },
+                { AOM_CDF4(22224, 28514, 30721) },
+                { AOM_CDF4(17660, 25433, 28913) },
+                { AOM_CDF4(13574, 21482, 26002) },
+                { AOM_CDF4(10629, 17977, 22938) },
+                { AOM_CDF4(8612, 15298, 20265) },
+                { AOM_CDF4(5607, 10491, 14596) } },
+              { { AOM_CDF4(13569, 19800, 23206) },
+                { AOM_CDF4(13128, 19924, 23869) },
+                { AOM_CDF4(8329, 14841, 19403) },
+                { AOM_CDF4(6130, 10976, 15057) },
+                { AOM_CDF4(4682, 8839, 12518) },
+                { AOM_CDF4(3656, 7409, 10588) },
+                { AOM_CDF4(2577, 5099, 7412) },
+                { AOM_CDF4(22427, 28684, 30585) },
+                { AOM_CDF4(20913, 27750, 30139) },
+                { AOM_CDF4(15840, 24109, 27834) },
+                { AOM_CDF4(12308, 20029, 24569) },
+                { AOM_CDF4(10216, 16785, 21458) },
+                { AOM_CDF4(8309, 14203, 19113) },
+                { AOM_CDF4(6043, 11168, 15307) },
+                { AOM_CDF4(23166, 28901, 30998) },
+                { AOM_CDF4(21899, 28405, 30751) },
+                { AOM_CDF4(18413, 26091, 29443) },
+                { AOM_CDF4(15233, 23114, 27352) },
+                { AOM_CDF4(12683, 20472, 25288) },
+                { AOM_CDF4(10702, 18259, 23409) },
+                { AOM_CDF4(8125, 14464, 19226) } } },
+            { { { AOM_CDF4(9040, 14786, 18360) },
+                { AOM_CDF4(9979, 15718, 19415) },
+                { AOM_CDF4(7913, 13918, 18311) },
+                { AOM_CDF4(5859, 10889, 15184) },
+                { AOM_CDF4(4593, 8677, 12510) },
+                { AOM_CDF4(3820, 7396, 10791) },
+                { AOM_CDF4(1730, 3471, 5192) },
+                { AOM_CDF4(11803, 18365, 22709) },
+                { AOM_CDF4(11419, 18058, 22225) },
+                { AOM_CDF4(9418, 15774, 20243) },
+                { AOM_CDF4(7539, 13325, 17657) },
+                { AOM_CDF4(6233, 11317, 15384) },
+                { AOM_CDF4(5137, 9656, 13545) },
+                { AOM_CDF4(2977, 5774, 8349) },
+                { AOM_CDF4(21207, 27246, 29640) },
+                { AOM_CDF4(19547, 26578, 29497) },
+                { AOM_CDF4(16169, 23871, 27690) },
+                { AOM_CDF4(12820, 20458, 25018) },
+                { AOM_CDF4(10224, 17332, 22214) },
+                { AOM_CDF4(8526, 15048, 19884) },
+                { AOM_CDF4(5037, 9410, 13118) } },
+              { { AOM_CDF4(12339, 17329, 20140) },
+                { AOM_CDF4(13505, 19895, 23225) },
+                { AOM_CDF4(9847, 16944, 21564) },
+                { AOM_CDF4(7280, 13256, 18348) },
+                { AOM_CDF4(4712, 10009, 14454) },
+                { AOM_CDF4(4361, 7914, 12477) },
+                { AOM_CDF4(2870, 5628, 7995) },
+                { AOM_CDF4(20061, 25504, 28526) },
+                { AOM_CDF4(15235, 22878, 26145) },
+                { AOM_CDF4(12985, 19958, 24155) },
+                { AOM_CDF4(9782, 16641, 21403) },
+                { AOM_CDF4(9456, 16360, 20760) },
+                { AOM_CDF4(6855, 12940, 18557) },
+                { AOM_CDF4(5661, 10564, 15002) },
+                { AOM_CDF4(25656, 30602, 31894) },
+                { AOM_CDF4(22570, 29107, 31092) },
+                { AOM_CDF4(18917, 26423, 29541) },
+                { AOM_CDF4(15940, 23649, 27754) },
+                { AOM_CDF4(12803, 20581, 25219) },
+                { AOM_CDF4(11082, 18695, 23376) },
+                { AOM_CDF4(7939, 14373, 19005) } } }
+        },
+    }, [3] = {
+        .skip = {
+            { { AOM_CDF2(26887) },
+                { AOM_CDF2(6729) },
+                { AOM_CDF2(10361) },
+                { AOM_CDF2(17442) },
+                { AOM_CDF2(15045) },
+                { AOM_CDF2(22478) },
+                { AOM_CDF2(29072) },
+                { AOM_CDF2(2713) },
+                { AOM_CDF2(11861) },
+                { AOM_CDF2(20773) },
+                { AOM_CDF2(16384) },
+                { AOM_CDF2(16384) },
+                { AOM_CDF2(16384) } },
+            { { AOM_CDF2(31903) },
+                { AOM_CDF2(2044) },
+                { AOM_CDF2(7528) },
+                { AOM_CDF2(14618) },
+                { AOM_CDF2(16182) },
+                { AOM_CDF2(24168) },
+                { AOM_CDF2(31037) },
+                { AOM_CDF2(2786) },
+                { AOM_CDF2(11194) },
+                { AOM_CDF2(20155) },
+                { AOM_CDF2(16384) },
+                { AOM_CDF2(16384) },
+                { AOM_CDF2(16384) } },
+            { { AOM_CDF2(32510) },
+                { AOM_CDF2(8430) },
+                { AOM_CDF2(17318) },
+                { AOM_CDF2(24154) },
+                { AOM_CDF2(23674) },
+                { AOM_CDF2(28789) },
+                { AOM_CDF2(32139) },
+                { AOM_CDF2(3440) },
+                { AOM_CDF2(13117) },
+                { AOM_CDF2(22702) },
+                { AOM_CDF2(16384) },
+                { AOM_CDF2(16384) },
+                { AOM_CDF2(16384) } },
+            { { AOM_CDF2(31671) },
+                { AOM_CDF2(2056) },
+                { AOM_CDF2(11746) },
+                { AOM_CDF2(16852) },
+                { AOM_CDF2(18635) },
+                { AOM_CDF2(24715) },
+                { AOM_CDF2(31484) },
+                { AOM_CDF2(4656) },
+                { AOM_CDF2(16074) },
+                { AOM_CDF2(24704) },
+                { AOM_CDF2(1806) },
+                { AOM_CDF2(14645) },
+                { AOM_CDF2(25336) } },
+            { { AOM_CDF2(31539) },
+                { AOM_CDF2(8433) },
+                { AOM_CDF2(20576) },
+                { AOM_CDF2(27904) },
+                { AOM_CDF2(27852) },
+                { AOM_CDF2(30026) },
+                { AOM_CDF2(32441) },
+                { AOM_CDF2(16384) },
+                { AOM_CDF2(16384) },
+                { AOM_CDF2(16384) },
+                { AOM_CDF2(16384) },
+                { AOM_CDF2(16384) },
+                { AOM_CDF2(16384) } }
+        }, .eob_bin_16 = {
+            { { AOM_CDF5(6708, 8958, 14746, 22133) },
+              { AOM_CDF5(1222, 2074, 4783, 15410) } },
+            { { AOM_CDF5(19575, 21766, 26044, 29709) },
+              { AOM_CDF5(7297, 10767, 19273, 28194) } }
+        }, .eob_bin_32 = {
+            { { AOM_CDF6(4617, 5709, 8446, 13584, 23135) },
+              { AOM_CDF6(1156, 1702, 3675, 9274, 20539) } },
+            { { AOM_CDF6(22086, 24282, 27010, 29770, 31743) },
+              { AOM_CDF6(7699, 10897, 20891, 26926, 31628) } }
+        }, .eob_bin_64 = {
+            { { AOM_CDF7(6307, 7541, 12060, 16358, 22553, 27865) },
+              { AOM_CDF7(1289, 2320, 3971, 7926, 14153, 24291) } },
+            { { AOM_CDF7(24212, 25708, 28268, 30035, 31307, 32049) },
+              { AOM_CDF7(8726, 12378, 19409, 26450, 30038, 32462) } }
+        }, .eob_bin_128 = {
+            { { AOM_CDF8(3472, 4885, 7489, 12481, 18517, 24536, 29635) },
+              { AOM_CDF8(886, 1731, 3271, 8469, 15569, 22126, 28383) } },
+            { { AOM_CDF8(24313, 26062, 28385, 30107, 31217, 31898, 32345) },
+              { AOM_CDF8(9165, 13282, 21150, 30286, 31894, 32571, 32712) } }
+        }, .eob_bin_256 = {
+            { { AOM_CDF9(5348, 7113, 11820, 15924, 22106, 26777, 30334, 31757) },
+              { AOM_CDF9(2453, 4474, 6307, 8777, 16474, 22975, 29000, 31547) } },
+            { { AOM_CDF9(23110, 24597, 27140, 28894, 30167, 30927, 31392, 32094) },
+              { AOM_CDF9(9998, 17661, 25178, 28097, 31308, 32038, 32403, 32695) } }
+        }, .eob_bin_512 = {
+            { { AOM_CDF10(5927, 7809, 10923, 14597, 19439, 24135, 28456,
+                          31142, 32060) },
+              { AOM_CDF10(3277, 6554, 9830, 13107, 16384, 19661, 22938,
+                          26214, 29491) } },
+            { { AOM_CDF10(21093, 23043, 25742, 27658, 29097, 29716,
+                          30073, 30820, 31956) },
+              { AOM_CDF10(3277, 6554, 9830, 13107, 16384, 19661, 22938,
+                          26214, 29491) } }
+        }, .eob_bin_1024 = {
+            { { AOM_CDF11(6698, 8334, 11961, 15762, 20186, 23862, 27434,
+                          29326, 31082, 32050) },
+              { AOM_CDF11(2979, 5958, 8937, 11916, 14895, 17873, 20852,
+                          23831, 26810, 29789) } },
+            { { AOM_CDF11(20569, 22426, 25569, 26859, 28053, 28913,
+                          29486, 29724, 29807, 32570) },
+              { AOM_CDF11(2979, 5958, 8937, 11916, 14895, 17873, 20852,
+                          23831, 26810, 29789) } }
+        }, .eob_hi_bit = {
+            { { { AOM_CDF2(16384) }, { AOM_CDF2(16384) },
+                { AOM_CDF2(20177) }, { AOM_CDF2(20789) }, { AOM_CDF2(20262) },
+                { AOM_CDF2(16384) }, { AOM_CDF2(16384) }, { AOM_CDF2(16384) },
+                { AOM_CDF2(16384) }, { AOM_CDF2(16384) }, { AOM_CDF2(16384) } },
+              { { AOM_CDF2(16384) }, { AOM_CDF2(16384) },
+                { AOM_CDF2(21416) }, { AOM_CDF2(20855) }, { AOM_CDF2(23410) },
+                { AOM_CDF2(16384) }, { AOM_CDF2(16384) }, { AOM_CDF2(16384) },
+                { AOM_CDF2(16384) }, { AOM_CDF2(16384) }, { AOM_CDF2(16384) } } },
+            { { { AOM_CDF2(16384) }, { AOM_CDF2(16384) },
+                { AOM_CDF2(20238) }, { AOM_CDF2(21057) }, { AOM_CDF2(19159) },
+                { AOM_CDF2(22337) }, { AOM_CDF2(20159) }, { AOM_CDF2(16384) },
+                { AOM_CDF2(16384) }, { AOM_CDF2(16384) }, { AOM_CDF2(16384) } },
+              { { AOM_CDF2(16384) }, { AOM_CDF2(16384) },
+                { AOM_CDF2(20125) }, { AOM_CDF2(20559) }, { AOM_CDF2(21707) },
+                { AOM_CDF2(22296) }, { AOM_CDF2(17333) }, { AOM_CDF2(16384) },
+                { AOM_CDF2(16384) }, { AOM_CDF2(16384) }, { AOM_CDF2(16384) } } },
+            { { { AOM_CDF2(16384) }, { AOM_CDF2(16384) },
+                { AOM_CDF2(19941) }, { AOM_CDF2(20527) }, { AOM_CDF2(21470) },
+                { AOM_CDF2(22487) }, { AOM_CDF2(19558) }, { AOM_CDF2(22354) },
+                { AOM_CDF2(20331) }, { AOM_CDF2(16384) }, { AOM_CDF2(16384) } },
+              { { AOM_CDF2(16384) }, { AOM_CDF2(16384) },
+                { AOM_CDF2(22752) }, { AOM_CDF2(25006) }, { AOM_CDF2(22075) },
+                { AOM_CDF2(21576) }, { AOM_CDF2(17740) }, { AOM_CDF2(21690) },
+                { AOM_CDF2(19211) }, { AOM_CDF2(16384) }, { AOM_CDF2(16384) } } },
+            { { { AOM_CDF2(16384) }, { AOM_CDF2(16384) },
+                { AOM_CDF2(21442) }, { AOM_CDF2(22358) }, { AOM_CDF2(18503) },
+                { AOM_CDF2(20291) }, { AOM_CDF2(19945) }, { AOM_CDF2(21294) },
+                { AOM_CDF2(21178) }, { AOM_CDF2(19400) }, { AOM_CDF2(10556) } },
+              { { AOM_CDF2(16384) }, { AOM_CDF2(16384) },
+                { AOM_CDF2(24648) }, { AOM_CDF2(24949) }, { AOM_CDF2(20708) },
+                { AOM_CDF2(23905) }, { AOM_CDF2(20501) }, { AOM_CDF2(9558) },
+                { AOM_CDF2(9423) },  { AOM_CDF2(30365) }, { AOM_CDF2(19253) } } },
+            { { { AOM_CDF2(16384) }, { AOM_CDF2(16384) },
+                { AOM_CDF2(26064) }, { AOM_CDF2(22098) }, { AOM_CDF2(19613) },
+                { AOM_CDF2(20525) }, { AOM_CDF2(17595) }, { AOM_CDF2(16618) },
+                { AOM_CDF2(20497) }, { AOM_CDF2(18989) }, { AOM_CDF2(15513) } },
+              { { AOM_CDF2(16384) }, { AOM_CDF2(16384) },
+                { AOM_CDF2(16384) }, { AOM_CDF2(16384) }, { AOM_CDF2(16384) },
+                { AOM_CDF2(16384) }, { AOM_CDF2(16384) }, { AOM_CDF2(16384) },
+                { AOM_CDF2(16384) }, { AOM_CDF2(16384) }, { AOM_CDF2(16384) } } }
+        }, .eob_base_tok = {
+            { { { AOM_CDF3(22497, 31198) },
+                { AOM_CDF3(31715, 32495) },
+                { AOM_CDF3(31606, 32337) },
+                { AOM_CDF3(30388, 31990) } },
+              { { AOM_CDF3(27877, 31584) },
+                { AOM_CDF3(32170, 32728) },
+                { AOM_CDF3(32155, 32688) },
+                { AOM_CDF3(32219, 32702) } } },
+            { { { AOM_CDF3(21457, 31043) },
+                { AOM_CDF3(31951, 32483) },
+                { AOM_CDF3(32153, 32562) },
+                { AOM_CDF3(31473, 32215) } },
+              { { AOM_CDF3(27558, 31151) },
+                { AOM_CDF3(32020, 32640) },
+                { AOM_CDF3(32097, 32575) },
+                { AOM_CDF3(32242, 32719) } } },
+            { { { AOM_CDF3(19980, 30591) },
+                { AOM_CDF3(32219, 32597) },
+                { AOM_CDF3(32581, 32706) },
+                { AOM_CDF3(31803, 32287) } },
+              { { AOM_CDF3(26473, 30507) },
+                { AOM_CDF3(32431, 32723) },
+                { AOM_CDF3(32196, 32611) },
+                { AOM_CDF3(31588, 32528) } } },
+            { { { AOM_CDF3(24647, 30463) },
+                { AOM_CDF3(32412, 32695) },
+                { AOM_CDF3(32468, 32720) },
+                { AOM_CDF3(31269, 32523) } },
+              { { AOM_CDF3(28482, 31505) },
+                { AOM_CDF3(32152, 32701) },
+                { AOM_CDF3(31732, 32598) },
+                { AOM_CDF3(31767, 32712) } } },
+            { { { AOM_CDF3(12358, 24977) },
+                { AOM_CDF3(31331, 32385) },
+                { AOM_CDF3(32634, 32756) },
+                { AOM_CDF3(30411, 32548) } },
+              { { AOM_CDF3(10923, 21845) },
+                { AOM_CDF3(10923, 21845) },
+                { AOM_CDF3(10923, 21845) },
+                { AOM_CDF3(10923, 21845) } } }
+        }, .base_tok = {
+            { { { AOM_CDF4(7062, 16472, 22319) },
+                { AOM_CDF4(24538, 32261, 32674) },
+                { AOM_CDF4(13675, 28041, 31779) },
+                { AOM_CDF4(8590, 20674, 27631) },
+                { AOM_CDF4(5685, 14675, 22013) },
+                { AOM_CDF4(3655, 9898, 15731) },
+                { AOM_CDF4(26493, 32418, 32658) },
+                { AOM_CDF4(16376, 29342, 32090) },
+                { AOM_CDF4(10594, 22649, 28970) },
+                { AOM_CDF4(8176, 17170, 24303) },
+                { AOM_CDF4(5605, 12694, 19139) },
+                { AOM_CDF4(8192, 16384, 24576) },
+                { AOM_CDF4(8192, 16384, 24576) },
+                { AOM_CDF4(8192, 16384, 24576) },
+                { AOM_CDF4(8192, 16384, 24576) },
+                { AOM_CDF4(8192, 16384, 24576) },
+                { AOM_CDF4(8192, 16384, 24576) },
+                { AOM_CDF4(8192, 16384, 24576) },
+                { AOM_CDF4(8192, 16384, 24576) },
+                { AOM_CDF4(8192, 16384, 24576) },
+                { AOM_CDF4(8192, 16384, 24576) },
+                { AOM_CDF4(23888, 31902, 32542) },
+                { AOM_CDF4(18612, 29687, 31987) },
+                { AOM_CDF4(16245, 24852, 29249) },
+                { AOM_CDF4(15765, 22608, 27559) },
+                { AOM_CDF4(19895, 24699, 27510) },
+                { AOM_CDF4(28401, 32212, 32457) },
+                { AOM_CDF4(15274, 27825, 30980) },
+                { AOM_CDF4(9364, 18128, 24332) },
+                { AOM_CDF4(2283, 8193, 15082) },
+                { AOM_CDF4(1228, 3972, 7881) },
+                { AOM_CDF4(29455, 32469, 32620) },
+                { AOM_CDF4(17981, 28245, 31388) },
+                { AOM_CDF4(10921, 20098, 26240) },
+                { AOM_CDF4(3743, 11829, 18657) },
+                { AOM_CDF4(2374, 9593, 15715) },
+                { AOM_CDF4(31068, 32466, 32635) },
+                { AOM_CDF4(20321, 29572, 31971) },
+                { AOM_CDF4(10771, 20255, 27119) },
+                { AOM_CDF4(2795, 10410, 17361) },
+                { AOM_CDF4(8192, 16384, 24576) } },
+              { { AOM_CDF4(9320, 22102, 27840) },
+                { AOM_CDF4(27057, 32464, 32724) },
+                { AOM_CDF4(16331, 30268, 32309) },
+                { AOM_CDF4(10319, 23935, 29720) },
+                { AOM_CDF4(6189, 16448, 24106) },
+                { AOM_CDF4(3589, 10884, 18808) },
+                { AOM_CDF4(29026, 32624, 32748) },
+                { AOM_CDF4(19226, 31507, 32587) },
+                { AOM_CDF4(12692, 26921, 31203) },
+                { AOM_CDF4(7049, 19532, 27635) },
+                { AOM_CDF4(7727, 15669, 23252) },
+                { AOM_CDF4(8192, 16384, 24576) },
+                { AOM_CDF4(8192, 16384, 24576) },
+                { AOM_CDF4(8192, 16384, 24576) },
+                { AOM_CDF4(8192, 16384, 24576) },
+                { AOM_CDF4(8192, 16384, 24576) },
+                { AOM_CDF4(8192, 16384, 24576) },
+                { AOM_CDF4(8192, 16384, 24576) },
+                { AOM_CDF4(8192, 16384, 24576) },
+                { AOM_CDF4(8192, 16384, 24576) },
+                { AOM_CDF4(8192, 16384, 24576) },
+                { AOM_CDF4(28056, 32625, 32748) },
+                { AOM_CDF4(22383, 32075, 32669) },
+                { AOM_CDF4(15417, 27098, 31749) },
+                { AOM_CDF4(18127, 26493, 27190) },
+                { AOM_CDF4(5461, 16384, 21845) },
+                { AOM_CDF4(27982, 32091, 32584) },
+                { AOM_CDF4(19045, 29868, 31972) },
+                { AOM_CDF4(10397, 22266, 27932) },
+                { AOM_CDF4(5990, 13697, 21500) },
+                { AOM_CDF4(1792, 6912, 15104) },
+                { AOM_CDF4(28198, 32501, 32718) },
+                { AOM_CDF4(21534, 31521, 32569) },
+                { AOM_CDF4(11109, 25217, 30017) },
+                { AOM_CDF4(5671, 15124, 26151) },
+                { AOM_CDF4(4681, 14043, 18725) },
+                { AOM_CDF4(28688, 32580, 32741) },
+                { AOM_CDF4(22576, 32079, 32661) },
+                { AOM_CDF4(10627, 22141, 28340) },
+                { AOM_CDF4(9362, 14043, 28087) },
+                { AOM_CDF4(8192, 16384, 24576) } } },
+            { { { AOM_CDF4(7754, 16948, 22142) },
+                { AOM_CDF4(25670, 32330, 32691) },
+                { AOM_CDF4(15663, 29225, 31994) },
+                { AOM_CDF4(9878, 23288, 29158) },
+                { AOM_CDF4(6419, 17088, 24336) },
+                { AOM_CDF4(3859, 11003, 17039) },
+                { AOM_CDF4(27562, 32595, 32725) },
+                { AOM_CDF4(17575, 30588, 32399) },
+                { AOM_CDF4(10819, 24838, 30309) },
+                { AOM_CDF4(7124, 18686, 25916) },
+                { AOM_CDF4(4479, 12688, 19340) },
+                { AOM_CDF4(28385, 32476, 32673) },
+                { AOM_CDF4(15306, 29005, 31938) },
+                { AOM_CDF4(8937, 21615, 28322) },
+                { AOM_CDF4(5982, 15603, 22786) },
+                { AOM_CDF4(3620, 10267, 16136) },
+                { AOM_CDF4(27280, 32464, 32667) },
+                { AOM_CDF4(15607, 29160, 32004) },
+                { AOM_CDF4(9091, 22135, 28740) },
+                { AOM_CDF4(6232, 16632, 24020) },
+                { AOM_CDF4(4047, 11377, 17672) },
+                { AOM_CDF4(29220, 32630, 32718) },
+                { AOM_CDF4(19650, 31220, 32462) },
+                { AOM_CDF4(13050, 26312, 30827) },
+                { AOM_CDF4(9228, 20870, 27468) },
+                { AOM_CDF4(6146, 15149, 21971) },
+                { AOM_CDF4(30169, 32481, 32623) },
+                { AOM_CDF4(17212, 29311, 31554) },
+                { AOM_CDF4(9911, 21311, 26882) },
+                { AOM_CDF4(4487, 13314, 20372) },
+                { AOM_CDF4(2570, 7772, 12889) },
+                { AOM_CDF4(30924, 32613, 32708) },
+                { AOM_CDF4(19490, 30206, 32107) },
+                { AOM_CDF4(11232, 23998, 29276) },
+                { AOM_CDF4(6769, 17955, 25035) },
+                { AOM_CDF4(4398, 12623, 19214) },
+                { AOM_CDF4(30609, 32627, 32722) },
+                { AOM_CDF4(19370, 30582, 32287) },
+                { AOM_CDF4(10457, 23619, 29409) },
+                { AOM_CDF4(6443, 17637, 24834) },
+                { AOM_CDF4(4645, 13236, 20106) } },
+              { { AOM_CDF4(8626, 20271, 26216) },
+                { AOM_CDF4(26707, 32406, 32711) },
+                { AOM_CDF4(16999, 30329, 32286) },
+                { AOM_CDF4(11445, 25123, 30286) },
+                { AOM_CDF4(6411, 18828, 25601) },
+                { AOM_CDF4(6801, 12458, 20248) },
+                { AOM_CDF4(29918, 32682, 32748) },
+                { AOM_CDF4(20649, 31739, 32618) },
+                { AOM_CDF4(12879, 27773, 31581) },
+                { AOM_CDF4(7896, 21751, 28244) },
+                { AOM_CDF4(5260, 14870, 23698) },
+                { AOM_CDF4(29252, 32593, 32731) },
+                { AOM_CDF4(17072, 30460, 32294) },
+                { AOM_CDF4(10653, 24143, 29365) },
+                { AOM_CDF4(6536, 17490, 23983) },
+                { AOM_CDF4(4929, 13170, 20085) },
+                { AOM_CDF4(28137, 32518, 32715) },
+                { AOM_CDF4(18171, 30784, 32407) },
+                { AOM_CDF4(11437, 25436, 30459) },
+                { AOM_CDF4(7252, 18534, 26176) },
+                { AOM_CDF4(4126, 13353, 20978) },
+                { AOM_CDF4(31162, 32726, 32748) },
+                { AOM_CDF4(23017, 32222, 32701) },
+                { AOM_CDF4(15629, 29233, 32046) },
+                { AOM_CDF4(9387, 22621, 29480) },
+                { AOM_CDF4(6922, 17616, 25010) },
+                { AOM_CDF4(28838, 32265, 32614) },
+                { AOM_CDF4(19701, 30206, 31920) },
+                { AOM_CDF4(11214, 22410, 27933) },
+                { AOM_CDF4(5320, 14177, 23034) },
+                { AOM_CDF4(5049, 12881, 17827) },
+                { AOM_CDF4(27484, 32471, 32734) },
+                { AOM_CDF4(21076, 31526, 32561) },
+                { AOM_CDF4(12707, 26303, 31211) },
+                { AOM_CDF4(8169, 21722, 28219) },
+                { AOM_CDF4(6045, 19406, 27042) },
+                { AOM_CDF4(27753, 32572, 32745) },
+                { AOM_CDF4(20832, 31878, 32653) },
+                { AOM_CDF4(13250, 27356, 31674) },
+                { AOM_CDF4(7718, 21508, 29858) },
+                { AOM_CDF4(7209, 18350, 25559) } } },
+            { { { AOM_CDF4(7876, 16901, 21741) },
+                { AOM_CDF4(24001, 31898, 32625) },
+                { AOM_CDF4(14529, 27959, 31451) },
+                { AOM_CDF4(8273, 20818, 27258) },
+                { AOM_CDF4(5278, 14673, 21510) },
+                { AOM_CDF4(2983, 8843, 14039) },
+                { AOM_CDF4(28016, 32574, 32732) },
+                { AOM_CDF4(17471, 30306, 32301) },
+                { AOM_CDF4(10224, 24063, 29728) },
+                { AOM_CDF4(6602, 17954, 25052) },
+                { AOM_CDF4(4002, 11585, 17759) },
+                { AOM_CDF4(30190, 32634, 32739) },
+                { AOM_CDF4(17497, 30282, 32270) },
+                { AOM_CDF4(10229, 23729, 29538) },
+                { AOM_CDF4(6344, 17211, 24440) },
+                { AOM_CDF4(3849, 11189, 17108) },
+                { AOM_CDF4(28570, 32583, 32726) },
+                { AOM_CDF4(17521, 30161, 32238) },
+                { AOM_CDF4(10153, 23565, 29378) },
+                { AOM_CDF4(6455, 17341, 24443) },
+                { AOM_CDF4(3907, 11042, 17024) },
+                { AOM_CDF4(30689, 32715, 32748) },
+                { AOM_CDF4(21546, 31840, 32610) },
+                { AOM_CDF4(13547, 27581, 31459) },
+                { AOM_CDF4(8912, 21757, 28309) },
+                { AOM_CDF4(5548, 15080, 22046) },
+                { AOM_CDF4(30783, 32540, 32685) },
+                { AOM_CDF4(17540, 29528, 31668) },
+                { AOM_CDF4(10160, 21468, 26783) },
+                { AOM_CDF4(4724, 13393, 20054) },
+                { AOM_CDF4(2702, 8174, 13102) },
+                { AOM_CDF4(31648, 32686, 32742) },
+                { AOM_CDF4(20954, 31094, 32337) },
+                { AOM_CDF4(12420, 25698, 30179) },
+                { AOM_CDF4(7304, 19320, 26248) },
+                { AOM_CDF4(4366, 12261, 18864) },
+                { AOM_CDF4(31581, 32723, 32748) },
+                { AOM_CDF4(21373, 31586, 32525) },
+                { AOM_CDF4(12744, 26625, 30885) },
+                { AOM_CDF4(7431, 20322, 26950) },
+                { AOM_CDF4(4692, 13323, 20111) } },
+              { { AOM_CDF4(7833, 18369, 24095) },
+                { AOM_CDF4(26650, 32273, 32702) },
+                { AOM_CDF4(16371, 29961, 32191) },
+                { AOM_CDF4(11055, 24082, 29629) },
+                { AOM_CDF4(6892, 18644, 25400) },
+                { AOM_CDF4(5006, 13057, 19240) },
+                { AOM_CDF4(29834, 32666, 32748) },
+                { AOM_CDF4(19577, 31335, 32570) },
+                { AOM_CDF4(12253, 26509, 31122) },
+                { AOM_CDF4(7991, 20772, 27711) },
+                { AOM_CDF4(5677, 15910, 23059) },
+                { AOM_CDF4(30109, 32532, 32720) },
+                { AOM_CDF4(16747, 30166, 32252) },
+                { AOM_CDF4(10134, 23542, 29184) },
+                { AOM_CDF4(5791, 16176, 23556) },
+                { AOM_CDF4(4362, 10414, 17284) },
+                { AOM_CDF4(29492, 32626, 32748) },
+                { AOM_CDF4(19894, 31402, 32525) },
+                { AOM_CDF4(12942, 27071, 30869) },
+                { AOM_CDF4(8346, 21216, 27405) },
+                { AOM_CDF4(6572, 17087, 23859) },
+                { AOM_CDF4(32035, 32735, 32748) },
+                { AOM_CDF4(22957, 31838, 32618) },
+                { AOM_CDF4(14724, 28572, 31772) },
+                { AOM_CDF4(10364, 23999, 29553) },
+                { AOM_CDF4(7004, 18433, 25655) },
+                { AOM_CDF4(27528, 32277, 32681) },
+                { AOM_CDF4(16959, 31171, 32096) },
+                { AOM_CDF4(10486, 23593, 27962) },
+                { AOM_CDF4(8192, 16384, 23211) },
+                { AOM_CDF4(8937, 17873, 20852) },
+                { AOM_CDF4(27715, 32002, 32615) },
+                { AOM_CDF4(15073, 29491, 31676) },
+                { AOM_CDF4(11264, 24576, 28672) },
+                { AOM_CDF4(2341, 18725, 23406) },
+                { AOM_CDF4(7282, 18204, 25486) },
+                { AOM_CDF4(28547, 32213, 32657) },
+                { AOM_CDF4(20788, 29773, 32239) },
+                { AOM_CDF4(6780, 21469, 30508) },
+                { AOM_CDF4(5958, 14895, 23831) },
+                { AOM_CDF4(16384, 21845, 27307) } } },
+            { { { AOM_CDF4(5992, 14304, 19765) },
+                { AOM_CDF4(22612, 31238, 32456) },
+                { AOM_CDF4(13456, 27162, 31087) },
+                { AOM_CDF4(8001, 20062, 26504) },
+                { AOM_CDF4(5168, 14105, 20764) },
+                { AOM_CDF4(2632, 7771, 12385) },
+                { AOM_CDF4(27034, 32344, 32709) },
+                { AOM_CDF4(15850, 29415, 31997) },
+                { AOM_CDF4(9494, 22776, 28841) },
+                { AOM_CDF4(6151, 16830, 23969) },
+                { AOM_CDF4(3461, 10039, 15722) },
+                { AOM_CDF4(30134, 32569, 32731) },
+                { AOM_CDF4(15638, 29422, 31945) },
+                { AOM_CDF4(9150, 21865, 28218) },
+                { AOM_CDF4(5647, 15719, 22676) },
+                { AOM_CDF4(3402, 9772, 15477) },
+                { AOM_CDF4(28530, 32586, 32735) },
+                { AOM_CDF4(17139, 30298, 32292) },
+                { AOM_CDF4(10200, 24039, 29685) },
+                { AOM_CDF4(6419, 17674, 24786) },
+                { AOM_CDF4(3544, 10225, 15824) },
+                { AOM_CDF4(31333, 32726, 32748) },
+                { AOM_CDF4(20618, 31487, 32544) },
+                { AOM_CDF4(12901, 27217, 31232) },
+                { AOM_CDF4(8624, 21734, 28171) },
+                { AOM_CDF4(5104, 14191, 20748) },
+                { AOM_CDF4(8192, 16384, 24576) },
+                { AOM_CDF4(8192, 16384, 24576) },
+                { AOM_CDF4(8192, 16384, 24576) },
+                { AOM_CDF4(8192, 16384, 24576) },
+                { AOM_CDF4(8192, 16384, 24576) },
+                { AOM_CDF4(8192, 16384, 24576) },
+                { AOM_CDF4(8192, 16384, 24576) },
+                { AOM_CDF4(8192, 16384, 24576) },
+                { AOM_CDF4(8192, 16384, 24576) },
+                { AOM_CDF4(8192, 16384, 24576) },
+                { AOM_CDF4(8192, 16384, 24576) },
+                { AOM_CDF4(8192, 16384, 24576) },
+                { AOM_CDF4(8192, 16384, 24576) },
+                { AOM_CDF4(8192, 16384, 24576) },
+                { AOM_CDF4(8192, 16384, 24576) } },
+              { { AOM_CDF4(11206, 21090, 26561) },
+                { AOM_CDF4(28759, 32279, 32671) },
+                { AOM_CDF4(14171, 27952, 31569) },
+                { AOM_CDF4(9743, 22907, 29141) },
+                { AOM_CDF4(6871, 17886, 24868) },
+                { AOM_CDF4(4960, 13152, 19315) },
+                { AOM_CDF4(31077, 32661, 32748) },
+                { AOM_CDF4(19400, 31195, 32515) },
+                { AOM_CDF4(12752, 26858, 31040) },
+                { AOM_CDF4(8370, 22098, 28591) },
+                { AOM_CDF4(5457, 15373, 22298) },
+                { AOM_CDF4(31697, 32706, 32748) },
+                { AOM_CDF4(17860, 30657, 32333) },
+                { AOM_CDF4(12510, 24812, 29261) },
+                { AOM_CDF4(6180, 19124, 24722) },
+                { AOM_CDF4(5041, 13548, 17959) },
+                { AOM_CDF4(31552, 32716, 32748) },
+                { AOM_CDF4(21908, 31769, 32623) },
+                { AOM_CDF4(14470, 28201, 31565) },
+                { AOM_CDF4(9493, 22982, 28608) },
+                { AOM_CDF4(6858, 17240, 24137) },
+                { AOM_CDF4(32543, 32752, 32756) },
+                { AOM_CDF4(24286, 32097, 32666) },
+                { AOM_CDF4(15958, 29217, 32024) },
+                { AOM_CDF4(10207, 24234, 29958) },
+                { AOM_CDF4(6929, 18305, 25652) },
+                { AOM_CDF4(8192, 16384, 24576) },
+                { AOM_CDF4(8192, 16384, 24576) },
+                { AOM_CDF4(8192, 16384, 24576) },
+                { AOM_CDF4(8192, 16384, 24576) },
+                { AOM_CDF4(8192, 16384, 24576) },
+                { AOM_CDF4(8192, 16384, 24576) },
+                { AOM_CDF4(8192, 16384, 24576) },
+                { AOM_CDF4(8192, 16384, 24576) },
+                { AOM_CDF4(8192, 16384, 24576) },
+                { AOM_CDF4(8192, 16384, 24576) },
+                { AOM_CDF4(8192, 16384, 24576) },
+                { AOM_CDF4(8192, 16384, 24576) },
+                { AOM_CDF4(8192, 16384, 24576) },
+                { AOM_CDF4(8192, 16384, 24576) },
+                { AOM_CDF4(8192, 16384, 24576) } } },
+            { { { AOM_CDF4(4137, 10847, 15682) },
+                { AOM_CDF4(17824, 27001, 30058) },
+                { AOM_CDF4(10204, 22796, 28291) },
+                { AOM_CDF4(6076, 15935, 22125) },
+                { AOM_CDF4(3852, 10937, 16816) },
+                { AOM_CDF4(2252, 6324, 10131) },
+                { AOM_CDF4(25840, 32016, 32662) },
+                { AOM_CDF4(15109, 28268, 31531) },
+                { AOM_CDF4(9385, 22231, 28340) },
+                { AOM_CDF4(6082, 16672, 23479) },
+                { AOM_CDF4(3318, 9427, 14681) },
+                { AOM_CDF4(30594, 32574, 32718) },
+                { AOM_CDF4(16836, 29552, 31859) },
+                { AOM_CDF4(9556, 22542, 28356) },
+                { AOM_CDF4(6305, 16725, 23540) },
+                { AOM_CDF4(3376, 9895, 15184) },
+                { AOM_CDF4(29383, 32617, 32745) },
+                { AOM_CDF4(18891, 30809, 32401) },
+                { AOM_CDF4(11688, 25942, 30687) },
+                { AOM_CDF4(7468, 19469, 26651) },
+                { AOM_CDF4(3909, 11358, 17012) },
+                { AOM_CDF4(31564, 32736, 32748) },
+                { AOM_CDF4(20906, 31611, 32600) },
+                { AOM_CDF4(13191, 27621, 31537) },
+                { AOM_CDF4(8768, 22029, 28676) },
+                { AOM_CDF4(5079, 14109, 20906) },
+                { AOM_CDF4(8192, 16384, 24576) },
+                { AOM_CDF4(8192, 16384, 24576) },
+                { AOM_CDF4(8192, 16384, 24576) },
+                { AOM_CDF4(8192, 16384, 24576) },
+                { AOM_CDF4(8192, 16384, 24576) },
+                { AOM_CDF4(8192, 16384, 24576) },
+                { AOM_CDF4(8192, 16384, 24576) },
+                { AOM_CDF4(8192, 16384, 24576) },
+                { AOM_CDF4(8192, 16384, 24576) },
+                { AOM_CDF4(8192, 16384, 24576) },
+                { AOM_CDF4(8192, 16384, 24576) },
+                { AOM_CDF4(8192, 16384, 24576) },
+                { AOM_CDF4(8192, 16384, 24576) },
+                { AOM_CDF4(8192, 16384, 24576) },
+                { AOM_CDF4(8192, 16384, 24576) } },
+              { { AOM_CDF4(8192, 16384, 24576) },
+                { AOM_CDF4(8192, 16384, 24576) },
+                { AOM_CDF4(8192, 16384, 24576) },
+                { AOM_CDF4(8192, 16384, 24576) },
+                { AOM_CDF4(8192, 16384, 24576) },
+                { AOM_CDF4(8192, 16384, 24576) },
+                { AOM_CDF4(8192, 16384, 24576) },
+                { AOM_CDF4(8192, 16384, 24576) },
+                { AOM_CDF4(8192, 16384, 24576) },
+                { AOM_CDF4(8192, 16384, 24576) },
+                { AOM_CDF4(8192, 16384, 24576) },
+                { AOM_CDF4(8192, 16384, 24576) },
+                { AOM_CDF4(8192, 16384, 24576) },
+                { AOM_CDF4(8192, 16384, 24576) },
+                { AOM_CDF4(8192, 16384, 24576) },
+                { AOM_CDF4(8192, 16384, 24576) },
+                { AOM_CDF4(8192, 16384, 24576) },
+                { AOM_CDF4(8192, 16384, 24576) },
+                { AOM_CDF4(8192, 16384, 24576) },
+                { AOM_CDF4(8192, 16384, 24576) },
+                { AOM_CDF4(8192, 16384, 24576) },
+                { AOM_CDF4(8192, 16384, 24576) },
+                { AOM_CDF4(8192, 16384, 24576) },
+                { AOM_CDF4(8192, 16384, 24576) },
+                { AOM_CDF4(8192, 16384, 24576) },
+                { AOM_CDF4(8192, 16384, 24576) },
+                { AOM_CDF4(8192, 16384, 24576) },
+                { AOM_CDF4(8192, 16384, 24576) },
+                { AOM_CDF4(8192, 16384, 24576) },
+                { AOM_CDF4(8192, 16384, 24576) },
+                { AOM_CDF4(8192, 16384, 24576) },
+                { AOM_CDF4(8192, 16384, 24576) },
+                { AOM_CDF4(8192, 16384, 24576) },
+                { AOM_CDF4(8192, 16384, 24576) },
+                { AOM_CDF4(8192, 16384, 24576) },
+                { AOM_CDF4(8192, 16384, 24576) },
+                { AOM_CDF4(8192, 16384, 24576) },
+                { AOM_CDF4(8192, 16384, 24576) },
+                { AOM_CDF4(8192, 16384, 24576) },
+                { AOM_CDF4(8192, 16384, 24576) },
+                { AOM_CDF4(8192, 16384, 24576) } } }
+        }, .dc_sign = {
+            {
+                { AOM_CDF2(128 * 125) },
+                { AOM_CDF2(128 * 102) },
+                { AOM_CDF2(128 * 147) },
+            },
+            {
+                { AOM_CDF2(128 * 119) },
+                { AOM_CDF2(128 * 101) },
+                { AOM_CDF2(128 * 135) },
+            }
+        }, .br_tok = {
+            { { { AOM_CDF4(18315, 24289, 27551) },
+                { AOM_CDF4(16854, 24068, 27835) },
+                { AOM_CDF4(10140, 17927, 23173) },
+                { AOM_CDF4(6722, 12982, 18267) },
+                { AOM_CDF4(4661, 9826, 14706) },
+                { AOM_CDF4(3832, 8165, 12294) },
+                { AOM_CDF4(2795, 6098, 9245) },
+                { AOM_CDF4(17145, 23326, 26672) },
+                { AOM_CDF4(20733, 27680, 30308) },
+                { AOM_CDF4(16032, 24461, 28546) },
+                { AOM_CDF4(11653, 20093, 25081) },
+                { AOM_CDF4(9290, 16429, 22086) },
+                { AOM_CDF4(7796, 14598, 19982) },
+                { AOM_CDF4(6502, 12378, 17441) },
+                { AOM_CDF4(21681, 27732, 30320) },
+                { AOM_CDF4(22389, 29044, 31261) },
+                { AOM_CDF4(19027, 26731, 30087) },
+                { AOM_CDF4(14739, 23755, 28624) },
+                { AOM_CDF4(11358, 20778, 25511) },
+                { AOM_CDF4(10995, 18073, 24190) },
+                { AOM_CDF4(9162, 14990, 20617) } },
+              { { AOM_CDF4(21425, 27952, 30388) },
+                { AOM_CDF4(18062, 25838, 29034) },
+                { AOM_CDF4(11956, 19881, 24808) },
+                { AOM_CDF4(7718, 15000, 20980) },
+                { AOM_CDF4(5702, 11254, 16143) },
+                { AOM_CDF4(4898, 9088, 16864) },
+                { AOM_CDF4(3679, 6776, 11907) },
+                { AOM_CDF4(23294, 30160, 31663) },
+                { AOM_CDF4(24397, 29896, 31836) },
+                { AOM_CDF4(19245, 27128, 30593) },
+                { AOM_CDF4(13202, 19825, 26404) },
+                { AOM_CDF4(11578, 19297, 23957) },
+                { AOM_CDF4(8073, 13297, 21370) },
+                { AOM_CDF4(5461, 10923, 19745) },
+                { AOM_CDF4(27367, 30521, 31934) },
+                { AOM_CDF4(24904, 30671, 31940) },
+                { AOM_CDF4(23075, 28460, 31299) },
+                { AOM_CDF4(14400, 23658, 30417) },
+                { AOM_CDF4(13885, 23882, 28325) },
+                { AOM_CDF4(14746, 22938, 27853) },
+                { AOM_CDF4(5461, 16384, 27307) } } },
+            { { { AOM_CDF4(18274, 24813, 27890) },
+                { AOM_CDF4(15537, 23149, 27003) },
+                { AOM_CDF4(9449, 16740, 21827) },
+                { AOM_CDF4(6700, 12498, 17261) },
+                { AOM_CDF4(4988, 9866, 14198) },
+                { AOM_CDF4(4236, 8147, 11902) },
+                { AOM_CDF4(2867, 5860, 8654) },
+                { AOM_CDF4(17124, 23171, 26101) },
+                { AOM_CDF4(20396, 27477, 30148) },
+                { AOM_CDF4(16573, 24629, 28492) },
+                { AOM_CDF4(12749, 20846, 25674) },
+                { AOM_CDF4(10233, 17878, 22818) },
+                { AOM_CDF4(8525, 15332, 20363) },
+                { AOM_CDF4(6283, 11632, 16255) },
+                { AOM_CDF4(20466, 26511, 29286) },
+                { AOM_CDF4(23059, 29174, 31191) },
+                { AOM_CDF4(19481, 27263, 30241) },
+                { AOM_CDF4(15458, 23631, 28137) },
+                { AOM_CDF4(12416, 20608, 25693) },
+                { AOM_CDF4(10261, 18011, 23261) },
+                { AOM_CDF4(8016, 14655, 19666) } },
+              { { AOM_CDF4(17616, 24586, 28112) },
+                { AOM_CDF4(15809, 23299, 27155) },
+                { AOM_CDF4(10767, 18890, 23793) },
+                { AOM_CDF4(7727, 14255, 18865) },
+                { AOM_CDF4(6129, 11926, 16882) },
+                { AOM_CDF4(4482, 9704, 14861) },
+                { AOM_CDF4(3277, 7452, 11522) },
+                { AOM_CDF4(22956, 28551, 30730) },
+                { AOM_CDF4(22724, 28937, 30961) },
+                { AOM_CDF4(18467, 26324, 29580) },
+                { AOM_CDF4(13234, 20713, 25649) },
+                { AOM_CDF4(11181, 17592, 22481) },
+                { AOM_CDF4(8291, 18358, 24576) },
+                { AOM_CDF4(7568, 11881, 14984) },
+                { AOM_CDF4(24948, 29001, 31147) },
+                { AOM_CDF4(25674, 30619, 32151) },
+                { AOM_CDF4(20841, 26793, 29603) },
+                { AOM_CDF4(14669, 24356, 28666) },
+                { AOM_CDF4(11334, 23593, 28219) },
+                { AOM_CDF4(8922, 14762, 22873) },
+                { AOM_CDF4(8301, 13544, 20535) } } },
+            { { { AOM_CDF4(17113, 23733, 27081) },
+                { AOM_CDF4(14139, 21406, 25452) },
+                { AOM_CDF4(8552, 15002, 19776) },
+                { AOM_CDF4(5871, 11120, 15378) },
+                { AOM_CDF4(4455, 8616, 12253) },
+                { AOM_CDF4(3469, 6910, 10386) },
+                { AOM_CDF4(2255, 4553, 6782) },
+                { AOM_CDF4(18224, 24376, 27053) },
+                { AOM_CDF4(19290, 26710, 29614) },
+                { AOM_CDF4(14936, 22991, 27184) },
+                { AOM_CDF4(11238, 18951, 23762) },
+                { AOM_CDF4(8786, 15617, 20588) },
+                { AOM_CDF4(7317, 13228, 18003) },
+                { AOM_CDF4(5101, 9512, 13493) },
+                { AOM_CDF4(22639, 28222, 30210) },
+                { AOM_CDF4(23216, 29331, 31307) },
+                { AOM_CDF4(19075, 26762, 29895) },
+                { AOM_CDF4(15014, 23113, 27457) },
+                { AOM_CDF4(11938, 19857, 24752) },
+                { AOM_CDF4(9942, 17280, 22282) },
+                { AOM_CDF4(7167, 13144, 17752) } },
+              { { AOM_CDF4(15820, 22738, 26488) },
+                { AOM_CDF4(13530, 20885, 25216) },
+                { AOM_CDF4(8395, 15530, 20452) },
+                { AOM_CDF4(6574, 12321, 16380) },
+                { AOM_CDF4(5353, 10419, 14568) },
+                { AOM_CDF4(4613, 8446, 12381) },
+                { AOM_CDF4(3440, 7158, 9903) },
+                { AOM_CDF4(24247, 29051, 31224) },
+                { AOM_CDF4(22118, 28058, 30369) },
+                { AOM_CDF4(16498, 24768, 28389) },
+                { AOM_CDF4(12920, 21175, 26137) },
+                { AOM_CDF4(10730, 18619, 25352) },
+                { AOM_CDF4(10187, 16279, 22791) },
+                { AOM_CDF4(9310, 14631, 22127) },
+                { AOM_CDF4(24970, 30558, 32057) },
+                { AOM_CDF4(24801, 29942, 31698) },
+                { AOM_CDF4(22432, 28453, 30855) },
+                { AOM_CDF4(19054, 25680, 29580) },
+                { AOM_CDF4(14392, 23036, 28109) },
+                { AOM_CDF4(12495, 20947, 26650) },
+                { AOM_CDF4(12442, 20326, 26214) } } },
+            { { { AOM_CDF4(12162, 18785, 22648) },
+                { AOM_CDF4(12749, 19697, 23806) },
+                { AOM_CDF4(8580, 15297, 20346) },
+                { AOM_CDF4(6169, 11749, 16543) },
+                { AOM_CDF4(4836, 9391, 13448) },
+                { AOM_CDF4(3821, 7711, 11613) },
+                { AOM_CDF4(2228, 4601, 7070) },
+                { AOM_CDF4(16319, 24725, 28280) },
+                { AOM_CDF4(15698, 23277, 27168) },
+                { AOM_CDF4(12726, 20368, 25047) },
+                { AOM_CDF4(9912, 17015, 21976) },
+                { AOM_CDF4(7888, 14220, 19179) },
+                { AOM_CDF4(6777, 12284, 17018) },
+                { AOM_CDF4(4492, 8590, 12252) },
+                { AOM_CDF4(23249, 28904, 30947) },
+                { AOM_CDF4(21050, 27908, 30512) },
+                { AOM_CDF4(17440, 25340, 28949) },
+                { AOM_CDF4(14059, 22018, 26541) },
+                { AOM_CDF4(11288, 18903, 23898) },
+                { AOM_CDF4(9411, 16342, 21428) },
+                { AOM_CDF4(6278, 11588, 15944) } },
+              { { AOM_CDF4(13981, 20067, 23226) },
+                { AOM_CDF4(16922, 23580, 26783) },
+                { AOM_CDF4(11005, 19039, 24487) },
+                { AOM_CDF4(7389, 14218, 19798) },
+                { AOM_CDF4(5598, 11505, 17206) },
+                { AOM_CDF4(6090, 11213, 15659) },
+                { AOM_CDF4(3820, 7371, 10119) },
+                { AOM_CDF4(21082, 26925, 29675) },
+                { AOM_CDF4(21262, 28627, 31128) },
+                { AOM_CDF4(18392, 26454, 30437) },
+                { AOM_CDF4(14870, 22910, 27096) },
+                { AOM_CDF4(12620, 19484, 24908) },
+                { AOM_CDF4(9290, 16553, 22802) },
+                { AOM_CDF4(6668, 14288, 20004) },
+                { AOM_CDF4(27704, 31055, 31949) },
+                { AOM_CDF4(24709, 29978, 31788) },
+                { AOM_CDF4(21668, 29264, 31657) },
+                { AOM_CDF4(18295, 26968, 30074) },
+                { AOM_CDF4(16399, 24422, 29313) },
+                { AOM_CDF4(14347, 23026, 28104) },
+                { AOM_CDF4(12370, 19806, 24477) } } }
+        },
+    }
+};
+
+static inline int get_qcat_idx(int q) {
+    if (q <= 20) return 0;
+    if (q <= 60) return 1;
+    if (q <= 120) return 2;
+    return 3;
+}
+
+static CdfThreadContext cdf_init[4] = {
+    [0] = { .cdf = NULL },
+    [1] = { .cdf = NULL },
+    [2] = { .cdf = NULL },
+    [3] = { .cdf = NULL },
+};
+
+void av1_init_states(CdfThreadContext *const cdf, const int qidx) {
+    const int qcat = get_qcat_idx(qidx);
+    if (cdf_init[qcat].cdf) {
+        cdf_thread_ref(cdf, &cdf_init[qcat]);
+        return;
+    }
+
+    cdf_thread_alloc(&cdf_init[qcat], NULL);
+    cdf_init[qcat].cdf->m = av1_default_cdf;
+    memcpy(cdf_init[qcat].cdf->kfym, default_kf_y_mode_cdf,
+           sizeof(default_kf_y_mode_cdf));
+    cdf_init[qcat].cdf->coef = av1_default_coef_cdf[qcat];
+    cdf_init[qcat].cdf->mv = default_mv_cdf;
+    cdf_init[qcat].cdf->dmv = default_mv_cdf;
+    cdf_thread_ref(cdf, &cdf_init[qcat]);
+}
+
+void av1_update_tile_cdf(const Av1FrameHeader *const hdr,
+                         CdfContext *const dst,
+                         const CdfContext *const src)
+{
+    int i, j, k, l;
+
+#define update_cdf_1d(n1d, name) \
+    do { \
+        memcpy(dst->name, src->name, sizeof(*dst->name) * n1d); \
+        assert(!dst->name[n1d - 1]); \
+        dst->name[n1d] = 0; \
+    } while (0)
+
+#define update_cdf_2d(n1d, n2d, name) \
+    for (j = 0; j < (n1d); j++) update_cdf_1d(n2d, name[j])
+#define update_cdf_3d(n1d, n2d, n3d, name) \
+    for (k = 0; k < (n1d); k++) update_cdf_2d(n2d, n3d, name[k])
+#define update_cdf_4d(n1d, n2d, n3d, n4d, name) \
+    for (l = 0; l < (n1d); l++) update_cdf_3d(n2d, n3d, n4d, name[l])
+#define update_cdf_6d(n1d, n2d, n3d, n4d, n5d, n6d, name) \
+    for (n = 0; n < (n1d); n++) \
+        for (m = 0; m < (n2d); m++) \
+            update_cdf_4d(n3d, n4d, n5d, n6d, name[n][m])
+
+#define update_bit_0d(name) \
+    do { \
+        dst->name[0] = src->name[0]; \
+        dst->name[1] = 0; \
+    } while (0)
+
+#define update_bit_1d(n1d, name) \
+    for (i = 0; i < (n1d); i++) update_bit_0d(name[i])
+#define update_bit_2d(n1d, n2d, name) \
+    for (j = 0; j < (n1d); j++) update_bit_1d(n2d, name[j])
+#define update_bit_3d(n1d, n2d, n3d, name) \
+    for (k = 0; k < (n1d); k++) update_bit_2d(n2d, n3d, name[k])
+
+    update_bit_1d(N_BS_SIZES, m.use_filter_intra);
+    update_cdf_1d(5, m.filter_intra);
+    update_cdf_3d(2, N_INTRA_PRED_MODES, N_UV_INTRA_PRED_MODES - !k, m.uv_mode);
+    update_cdf_2d(8, 7, m.angle_delta);
+    update_cdf_3d(N_TX_SIZES - 1, 3, imin(k + 2, 3), m.txsz);
+    update_cdf_3d(N_TX_SIZES - 1, N_INTRA_PRED_MODES, 7, m.txtp_intra[1]);
+    update_cdf_3d(N_TX_SIZES - 1, N_INTRA_PRED_MODES, 5, m.txtp_intra[2]);
+    update_bit_1d(3, m.skip);
+    static const uint8_t n_partitions[N_BL_LEVELS] = {
+        [BL_128X128] = N_PARTITIONS - 2,
+        [BL_64X64]   = N_PARTITIONS,
+        [BL_32X32]   = N_PARTITIONS,
+        [BL_16X16]   = N_PARTITIONS,
+        [BL_8X8]     = N_SUB8X8_PARTITIONS,
+    };
+    update_cdf_3d(N_BL_LEVELS, 4, n_partitions[k], m.partition);
+    update_bit_2d(N_TX_SIZES, 13, coef.skip);
+    update_cdf_3d(2, 2, 5, coef.eob_bin_16);
+    update_cdf_3d(2, 2, 6, coef.eob_bin_32);
+    update_cdf_3d(2, 2, 7, coef.eob_bin_64);
+    update_cdf_3d(2, 2, 8, coef.eob_bin_128);
+    update_cdf_3d(2, 2, 9, coef.eob_bin_256);
+    update_cdf_3d(2, 2, 10, coef.eob_bin_512);
+    update_cdf_3d(2, 2, 11, coef.eob_bin_1024);
+    update_bit_3d(N_TX_SIZES, 2, 11 /*22*/, coef.eob_hi_bit);
+    update_cdf_4d(N_TX_SIZES, 2, 4, 3, coef.eob_base_tok);
+    update_cdf_4d(N_TX_SIZES, 2, 41 /*42*/, 4, coef.base_tok);
+    update_bit_2d(2, 3, coef.dc_sign);
+    update_cdf_4d(4, 2, 21, 4, coef.br_tok);
+    update_cdf_2d(3, NUM_SEGMENTS, m.seg_id);
+    update_cdf_1d(8, m.cfl_sign);
+    update_cdf_2d(6, 16, m.cfl_alpha);
+    update_bit_0d(m.restore_wiener);
+    update_bit_0d(m.restore_sgrproj);
+    update_cdf_1d(3, m.restore_switchable);
+    update_cdf_1d(4, m.delta_q);
+    update_cdf_2d(5, 4, m.delta_lf);
+    update_bit_2d(7, 3, m.pal_y);
+    update_bit_1d(2, m.pal_uv);
+    update_cdf_3d(2, 7, 7, m.pal_sz);
+    update_cdf_4d(2, 7, 5, k + 2, m.color_map);
+
+    if (!(hdr->frame_type & 1)) {
+        update_bit_0d(m.intrabc);
+
+        update_cdf_1d(N_MV_JOINTS, dmv.joint);
+        for (k = 0; k < 2; k++) {
+            update_cdf_1d(11, dmv.comp[k].classes);
+            update_bit_0d(dmv.comp[k].class0);
+            update_bit_1d(10, dmv.comp[k].classN);
+            update_bit_0d(dmv.comp[k].sign);
+        }
+        return;
+    }
+
+    update_bit_1d(3, m.skip_mode);
+    update_cdf_2d(4, N_INTRA_PRED_MODES, m.y_mode);
+    update_cdf_3d(2, 8, N_SWITCHABLE_FILTERS, m.filter);
+    update_bit_1d(6, m.newmv_mode);
+    update_bit_1d(2, m.globalmv_mode);
+    update_bit_1d(6, m.refmv_mode);
+    update_bit_1d(3, m.drl_bit);
+    update_cdf_2d(8, N_COMP_INTER_PRED_MODES, m.comp_inter_mode);
+    update_bit_1d(4, m.intra);
+    update_bit_1d(5, m.comp);
+    update_bit_1d(5, m.comp_dir);
+    update_bit_1d(6, m.jnt_comp);
+    update_bit_1d(6, m.mask_comp);
+    update_bit_1d(9, m.wedge_comp);
+    update_cdf_2d(9, 16, m.wedge_idx);
+    update_bit_2d(6, 3, m.ref);
+    update_bit_2d(3, 3, m.comp_fwd_ref);
+    update_bit_2d(2, 3, m.comp_bwd_ref);
+    update_bit_2d(3, 3, m.comp_uni_ref);
+    update_bit_2d(7, 3, m.txpart);
+    update_cdf_2d(N_TX_SIZES - 1, 16, m.txtp_inter[1]);
+    update_cdf_2d(N_TX_SIZES - 1, 12, m.txtp_inter[2]);
+    update_cdf_2d(N_TX_SIZES - 1,  2, m.txtp_inter[3]);
+    update_bit_1d(3, m.seg_pred);
+    update_bit_1d(4, m.interintra);
+    update_bit_1d(7, m.interintra_wedge);
+    update_cdf_2d(4, 4, m.interintra_mode);
+    update_cdf_2d(N_BS_SIZES, 3, m.motion_mode);
+    update_bit_1d(N_BS_SIZES, m.obmc);
+
+    update_cdf_1d(N_MV_JOINTS, mv.joint);
+    for (k = 0; k < 2; k++) {
+        update_cdf_1d(11, mv.comp[k].classes);
+        update_bit_0d(mv.comp[k].class0);
+        update_bit_1d(10, mv.comp[k].classN);
+        update_cdf_2d(2, 4, mv.comp[k].class0_fp);
+        update_cdf_1d(4, mv.comp[k].classN_fp);
+        update_bit_0d(mv.comp[k].class0_hp);
+        update_bit_0d(mv.comp[k].classN_hp);
+        update_bit_0d(mv.comp[k].sign);
+    }
+}
+
+/*
+ * CDF threading wrappers.
+ */
+void cdf_thread_alloc(CdfThreadContext *const cdf, struct thread_data *const t) {
+    cdf->ref = dav1d_ref_create(sizeof(CdfContext) +
+                                (t != NULL) * sizeof(atomic_uint));
+    cdf->cdf = cdf->ref->data;
+    if (t) {
+        cdf->progress = (atomic_uint *) &cdf->cdf[1];
+        atomic_init(cdf->progress, 0);
+        cdf->t = t;
+    }
+}
+
+void cdf_thread_ref(CdfThreadContext *const dst, CdfThreadContext *const src) {
+    dav1d_ref_inc(src->ref);
+    *dst = *src;
+}
+
+void cdf_thread_unref(CdfThreadContext *const cdf) {
+    dav1d_ref_dec(cdf->ref);
+    memset(cdf, 0, sizeof(*cdf));
+}
+
+void cdf_thread_wait(CdfThreadContext *const cdf) {
+    if (!cdf->t) return;
+
+    if (atomic_load(cdf->progress)) return;
+    pthread_mutex_lock(&cdf->t->lock);
+    while (!atomic_load(cdf->progress))
+        pthread_cond_wait(&cdf->t->cond, &cdf->t->lock);
+    pthread_mutex_unlock(&cdf->t->lock);
+}
+
+void cdf_thread_signal(CdfThreadContext *const cdf) {
+    if (!cdf->t) return;
+
+    pthread_mutex_lock(&cdf->t->lock);
+    atomic_store(cdf->progress, 1);
+    pthread_cond_broadcast(&cdf->t->cond);
+    pthread_mutex_unlock(&cdf->t->lock);
+}
diff --git a/src/cdf.h b/src/cdf.h
new file mode 100644
index 0000000..014f36b
--- /dev/null
+++ b/src/cdf.h
@@ -0,0 +1,148 @@
+/*
+ * Copyright © 2018, VideoLAN and dav1d authors
+ * Copyright © 2018, Two Orioles, LLC
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright notice, this
+ *    list of conditions and the following disclaimer.
+ *
+ * 2. Redistributions in binary form must reproduce the above copyright notice,
+ *    this list of conditions and the following disclaimer in the documentation
+ *    and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
+ * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#ifndef __AV1_CDF_H__
+#define __AV1_CDF_H__
+
+#include <stdint.h>
+
+#include "src/levels.h"
+#include "src/ref.h"
+#include "src/thread_data.h"
+
+typedef struct CdfModeContext {
+    uint16_t y_mode[4][N_INTRA_PRED_MODES + 1];
+    uint16_t use_filter_intra[N_BS_SIZES][2];
+    uint16_t filter_intra[5 + 1];
+    uint16_t uv_mode[2][N_INTRA_PRED_MODES][N_UV_INTRA_PRED_MODES + 1];
+    uint16_t angle_delta[8][8];
+    uint16_t filter[2][8][N_SWITCHABLE_FILTERS + 1];
+    uint16_t newmv_mode[6][2];
+    uint16_t globalmv_mode[2][2];
+    uint16_t refmv_mode[6][2];
+    uint16_t drl_bit[3][2];
+    uint16_t comp_inter_mode[8][N_COMP_INTER_PRED_MODES + 1];
+    uint16_t intra[4][2];
+    uint16_t comp[5][2];
+    uint16_t comp_dir[5][2];
+    uint16_t jnt_comp[6][2];
+    uint16_t mask_comp[6][2];
+    uint16_t wedge_comp[9][2];
+    uint16_t wedge_idx[9][16 + 1];
+    uint16_t interintra[7][2];
+    uint16_t interintra_mode[4][5];
+    uint16_t interintra_wedge[7][2];
+    uint16_t ref[6][3][2];
+    uint16_t comp_fwd_ref[3][3][2];
+    uint16_t comp_bwd_ref[2][3][2];
+    uint16_t comp_uni_ref[3][3][2];
+    uint16_t txsz[N_TX_SIZES - 1][3][4];
+    uint16_t txpart[7][3][2];
+    uint16_t txtp_inter[4][N_TX_SIZES][N_TX_TYPES + 1];
+    uint16_t txtp_intra[3][N_TX_SIZES][N_INTRA_PRED_MODES][N_TX_TYPES + 1];
+    uint16_t skip[3][2];
+    uint16_t skip_mode[3][2];
+    uint16_t partition[N_BL_LEVELS][4][N_PARTITIONS + 1];
+    uint16_t seg_pred[3][2];
+    uint16_t seg_id[3][NUM_SEGMENTS + 1];
+    uint16_t cfl_sign[8 + 1];
+    uint16_t cfl_alpha[6][16 + 1];
+    uint16_t restore_wiener[2];
+    uint16_t restore_sgrproj[2];
+    uint16_t restore_switchable[3 + 1];
+    uint16_t delta_q[4 + 1];
+    uint16_t delta_lf[5][4 + 1];
+    uint16_t obmc[N_BS_SIZES][2];
+    uint16_t motion_mode[N_BS_SIZES][3 + 1];
+    uint16_t pal_y[7][3][2];
+    uint16_t pal_uv[2][2];
+    uint16_t pal_sz[2][7][7 + 1];
+    uint16_t color_map[2][7][5][8 + 1];
+    uint16_t intrabc[2];
+} CdfModeContext;
+
+typedef struct CdfCoefContext {
+    uint16_t skip[N_TX_SIZES][13][2];
+    uint16_t eob_bin_16[2][2][6];
+    uint16_t eob_bin_32[2][2][7];
+    uint16_t eob_bin_64[2][2][8];
+    uint16_t eob_bin_128[2][2][9];
+    uint16_t eob_bin_256[2][2][10];
+    uint16_t eob_bin_512[2][2][11];
+    uint16_t eob_bin_1024[2][2][12];
+    uint16_t eob_hi_bit[N_TX_SIZES][2][11 /*22*/][2];
+    uint16_t eob_base_tok[N_TX_SIZES][2][4][4];
+    uint16_t base_tok[N_TX_SIZES][2][41][5];
+    uint16_t dc_sign[2][3][2];
+    uint16_t br_tok[4 /*5*/][2][21][5];
+} CdfCoefContext;
+
+typedef struct CdfMvComponent {
+    uint16_t classes[11 + 1];
+    uint16_t class0[2];
+    uint16_t classN[10][2];
+    uint16_t class0_fp[2][4 + 1];
+    uint16_t classN_fp[4 + 1];
+    uint16_t class0_hp[2];
+    uint16_t classN_hp[2];
+    uint16_t sign[2];
+} CdfMvComponent;
+
+typedef struct CdfMvContext {
+    CdfMvComponent comp[2];
+    uint16_t joint[N_MV_JOINTS + 1];
+} CdfMvContext;
+
+typedef struct CdfContext {
+    CdfModeContext m;
+    uint16_t kfym[5][5][N_INTRA_PRED_MODES + 1];
+    CdfCoefContext coef;
+    CdfMvContext mv, dmv;
+} CdfContext;
+
+typedef struct CdfThreadContext {
+    CdfContext *cdf;
+    Dav1dRef *ref; ///< allocation origin
+    struct thread_data *t;
+    atomic_uint *progress;
+} CdfThreadContext;
+
+void av1_init_states(CdfThreadContext *cdf, int qidx);
+void av1_update_tile_cdf(const Av1FrameHeader *hdr, CdfContext *dst,
+                         const CdfContext *src);
+
+void cdf_thread_alloc(CdfThreadContext *cdf, struct thread_data *t);
+void cdf_thread_ref(CdfThreadContext *dst, CdfThreadContext *src);
+void cdf_thread_unref(CdfThreadContext *cdf);
+
+/*
+ * These are binary signals (so a signal is either "done" or "not done").
+ */
+void cdf_thread_wait(CdfThreadContext *cdf);
+void cdf_thread_signal(CdfThreadContext *cdf);
+
+#endif /* __AV1_CDF_H__ */
diff --git a/src/data.c b/src/data.c
new file mode 100644
index 0000000..343e1f8
--- /dev/null
+++ b/src/data.c
@@ -0,0 +1,54 @@
+/*
+ * Copyright © 2018, VideoLAN and dav1d authors
+ * Copyright © 2018, Two Orioles, LLC
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright notice, this
+ *    list of conditions and the following disclaimer.
+ *
+ * 2. Redistributions in binary form must reproduce the above copyright notice,
+ *    this list of conditions and the following disclaimer in the documentation
+ *    and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
+ * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#include "config.h"
+
+#include <errno.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include "dav1d/data.h"
+
+#include "common/validate.h"
+
+#include "src/ref.h"
+
+int dav1d_data_create(Dav1dData *const buf, const size_t sz) {
+    validate_input_or_ret(buf != NULL, -EINVAL);
+
+    buf->ref = dav1d_ref_create(sz);
+    if (!buf->ref) return -ENOMEM;
+    buf->data = buf->ref->data;
+    buf->sz = sz;
+
+    return 0;
+}
+
+void dav1d_data_unref(Dav1dData *const buf) {
+    dav1d_ref_dec(buf->ref);
+    memset(buf, 0, sizeof(*buf));
+}
diff --git a/src/data.h b/src/data.h
new file mode 100644
index 0000000..8f13030
--- /dev/null
+++ b/src/data.h
@@ -0,0 +1,35 @@
+/*
+ * Copyright © 2018, VideoLAN and dav1d authors
+ * Copyright © 2018, Two Orioles, LLC
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright notice, this
+ *    list of conditions and the following disclaimer.
+ *
+ * 2. Redistributions in binary form must reproduce the above copyright notice,
+ *    this list of conditions and the following disclaimer in the documentation
+ *    and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
+ * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#ifndef __DAV1D_SRC_DATA_H__
+#define __DAV1D_SRC_DATA_H__
+
+#include "dav1d/data.h"
+
+void dav1d_data_unref(Dav1dData *buf);
+
+#endif /* __DAV1D_SRC_DATA_H__ */
diff --git a/src/decode.c b/src/decode.c
new file mode 100644
index 0000000..2cc1d4b
--- /dev/null
+++ b/src/decode.c
@@ -0,0 +1,2908 @@
+/*
+ * Copyright © 2018, VideoLAN and dav1d authors
+ * Copyright © 2018, Two Orioles, LLC
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright notice, this
+ *    list of conditions and the following disclaimer.
+ *
+ * 2. Redistributions in binary form must reproduce the above copyright notice,
+ *    this list of conditions and the following disclaimer in the documentation
+ *    and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
+ * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#include "config.h"
+
+#include <errno.h>
+#include <limits.h>
+#include <string.h>
+#include <stdio.h>
+#include <inttypes.h>
+
+#include "dav1d/data.h"
+
+#include "common/intops.h"
+#include "common/mem.h"
+
+#include "src/decode.h"
+#include "src/dequant_tables.h"
+#include "src/env.h"
+#include "src/qm.h"
+#include "src/recon.h"
+#include "src/ref.h"
+#include "src/tables.h"
+#include "src/thread_task.h"
+#include "src/warpmv.h"
+
+static void init_quant_tables(const Av1SequenceHeader *const seq_hdr,
+                              const Av1FrameHeader *const frame_hdr,
+                              const int qidx, uint16_t (*dq)[3][2])
+{
+    for (int i = 0; i < (frame_hdr->segmentation.enabled ? 8 : 1); i++) {
+        const int yac = frame_hdr->segmentation.enabled ?
+            iclip_u8(qidx + frame_hdr->segmentation.seg_data.d[i].delta_q) : qidx;
+        const int ydc = iclip_u8(yac + frame_hdr->quant.ydc_delta);
+        const int uac = iclip_u8(yac + frame_hdr->quant.uac_delta);
+        const int udc = iclip_u8(yac + frame_hdr->quant.udc_delta);
+        const int vac = iclip_u8(yac + frame_hdr->quant.vac_delta);
+        const int vdc = iclip_u8(yac + frame_hdr->quant.vdc_delta);
+
+        dq[i][0][0] = dav1d_dq_tbl[seq_hdr->bpc > 8][ydc][0];
+        dq[i][0][1] = dav1d_dq_tbl[seq_hdr->bpc > 8][yac][1];
+        dq[i][1][0] = dav1d_dq_tbl[seq_hdr->bpc > 8][udc][0];
+        dq[i][1][1] = dav1d_dq_tbl[seq_hdr->bpc > 8][uac][1];
+        dq[i][2][0] = dav1d_dq_tbl[seq_hdr->bpc > 8][vdc][0];
+        dq[i][2][1] = dav1d_dq_tbl[seq_hdr->bpc > 8][vac][1];
+    }
+}
+
+static int read_mv_component_diff(Dav1dTileContext *const t,
+                                  CdfMvComponent *const mv_comp,
+                                  const int have_fp)
+{
+    Dav1dTileState *const ts = t->ts;
+    const Dav1dFrameContext *const f = t->f;
+    const int have_hp = f->frame_hdr.hp;
+    const int sign = msac_decode_bool_adapt(&ts->msac, mv_comp->sign);
+    const int cl = msac_decode_symbol_adapt(&ts->msac, mv_comp->classes, 11);
+    int up, fp, hp;
+
+    if (!cl) {
+        up = msac_decode_bool_adapt(&ts->msac, mv_comp->class0);
+        if (have_fp) {
+            fp = msac_decode_symbol_adapt(&ts->msac, mv_comp->class0_fp[up], 4);
+            hp = have_hp ? msac_decode_bool_adapt(&ts->msac, mv_comp->class0_hp) : 1;
+        } else {
+            fp = 3;
+            hp = 1;
+        }
+    } else {
+        up = 1 << cl;
+        for (int n = 0; n < cl; n++)
+            up |= msac_decode_bool_adapt(&ts->msac, mv_comp->classN[n]) << n;
+        if (have_fp) {
+            fp = msac_decode_symbol_adapt(&ts->msac, mv_comp->classN_fp, 4);
+            hp = have_hp ? msac_decode_bool_adapt(&ts->msac, mv_comp->classN_hp) : 1;
+        } else {
+            fp = 3;
+            hp = 1;
+        }
+    }
+
+    const int diff = ((up << 3) | (fp << 1) | hp) + 1;
+
+    return sign ? -diff : diff;
+}
+
+static void read_mv_residual(Dav1dTileContext *const t, mv *const ref_mv,
+                             CdfMvContext *const mv_cdf, const int have_fp)
+{
+    switch (msac_decode_symbol_adapt(&t->ts->msac, t->ts->cdf.mv.joint, N_MV_JOINTS)) {
+    case MV_JOINT_HV:
+        ref_mv->y += read_mv_component_diff(t, &mv_cdf->comp[0], have_fp);
+        ref_mv->x += read_mv_component_diff(t, &mv_cdf->comp[1], have_fp);
+        break;
+    case MV_JOINT_H:
+        ref_mv->x += read_mv_component_diff(t, &mv_cdf->comp[1], have_fp);
+        break;
+    case MV_JOINT_V:
+        ref_mv->y += read_mv_component_diff(t, &mv_cdf->comp[0], have_fp);
+        break;
+    default:
+        break;
+    }
+}
+
+static void read_tx_tree(Dav1dTileContext *const t,
+                         const enum RectTxfmSize from,
+                         const int depth, uint16_t *const masks,
+                         const int x_off, const int y_off)
+{
+    const Dav1dFrameContext *const f = t->f;
+    const int bx4 = t->bx & 31, by4 = t->by & 31;
+    const TxfmInfo *const t_dim = &av1_txfm_dimensions[from];
+    const int txw = t_dim->lw, txh = t_dim->lh;
+    int is_split;
+
+    if (depth < 2 && from > (int) TX_4X4) {
+        const int cat = 2 * (TX_64X64 - t_dim->max) - depth;
+        const int a = t->a->tx[bx4] < txw;
+        const int l = t->l.tx[by4] < txh;
+
+        is_split = msac_decode_bool_adapt(&t->ts->msac, t->ts->cdf.m.txpart[cat][a + l]);
+        if (is_split)
+            masks[depth] |= 1 << (y_off * 4 + x_off);
+    } else {
+        is_split = 0;
+    }
+
+    if (is_split && t_dim->max > TX_8X8) {
+        const enum RectTxfmSize sub = t_dim->sub;
+        const TxfmInfo *const sub_t_dim = &av1_txfm_dimensions[sub];
+        const int txsw = sub_t_dim->w, txsh = sub_t_dim->h;
+
+        read_tx_tree(t, sub, depth + 1, masks, x_off * 2 + 0, y_off * 2 + 0);
+        t->bx += txsw;
+        if (txw >= txh && t->bx < f->bw)
+            read_tx_tree(t, sub, depth + 1, masks, x_off * 2 + 1, y_off * 2 + 0);
+        t->bx -= txsw;
+        t->by += txsh;
+        if (txh >= txw && t->by < f->bh) {
+            read_tx_tree(t, sub, depth + 1, masks, x_off * 2 + 0, y_off * 2 + 1);
+            t->bx += txsw;
+            if (txw >= txh && t->bx < f->bw)
+                read_tx_tree(t, sub, depth + 1, masks,
+                             x_off * 2 + 1, y_off * 2 + 1);
+            t->bx -= txsw;
+        }
+        t->by -= txsh;
+    } else {
+        memset(&t->a->tx[bx4], is_split ? TX_4X4 : txw, t_dim->w);
+        memset(&t->l.tx[by4], is_split ? TX_4X4 : txh, t_dim->h);
+    }
+}
+
+int av1_neg_deinterleave(int diff, int ref, int max) {
+    if (!ref) return diff;
+    if (ref >= (max - 1)) return max - diff - 1;
+    if (2 * ref < max) {
+        if (diff <= 2 * ref) {
+            if (diff & 1)
+                return ref + ((diff + 1) >> 1);
+            else
+                return ref - (diff >> 1);
+        }
+        return diff;
+    } else {
+        if (diff <= 2 * (max - ref - 1)) {
+            if (diff & 1)
+                return ref + ((diff + 1) >> 1);
+            else
+                return ref - (diff >> 1);
+        }
+        return max - (diff + 1);
+    }
+}
+
+static void find_matching_ref(const Dav1dTileContext *const t,
+                              const enum EdgeFlags intra_edge_flags,
+                              const int bw4, const int bh4,
+                              const int w4, const int h4,
+                              const int have_left, const int have_top,
+                              const int ref, uint64_t masks[2])
+{
+    const Dav1dFrameContext *const f = t->f;
+    const ptrdiff_t b4_stride = f->b4_stride;
+    const refmvs *const r = &f->mvs[t->by * b4_stride + t->bx];
+    int count = 0;
+    int have_topleft = have_top && have_left;
+    int have_topright = imax(bw4, bh4) < 32 &&
+                        have_top && t->bx + bw4 < t->ts->tiling.col_end &&
+                        (intra_edge_flags & EDGE_I444_TOP_HAS_RIGHT);
+
+#define bs(rp) av1_block_dimensions[sbtype_to_bs[(rp)->sb_type]]
+#define matches(rp) ((rp)->ref[0] == ref + 1 && (rp)->ref[1] == -1)
+
+    if (have_top) {
+        const refmvs *r2 = &r[-b4_stride];
+        if (matches(r2)) {
+            masks[0] |= 1;
+            count = 1;
+        }
+        int aw4 = bs(r2)[0];
+        if (aw4 >= bw4) {
+            const int off = t->bx & (aw4 - 1);
+            if (off) have_topleft = 0;
+            if (aw4 - off > bw4) have_topright = 0;
+        } else {
+            unsigned mask = 1 << aw4;
+            for (int x = aw4; x < w4; x += aw4) {
+                r2 += aw4;
+                if (matches(r2)) {
+                    masks[0] |= mask;
+                    if (++count >= 8) return;
+                }
+                aw4 = bs(r2)[0];
+                mask <<= aw4;
+            }
+        }
+    }
+    if (have_left) {
+        const refmvs *r2 = &r[-1];
+        if (matches(r2)) {
+            masks[1] |= 1;
+            if (++count >= 8) return;
+        }
+        int lh4 = bs(r2)[1];
+        if (lh4 >= bh4) {
+            if (t->by & (lh4 - 1)) have_topleft = 0;
+        } else {
+            unsigned mask = 1 << lh4;
+            for (int y = lh4; y < h4; y += lh4) {
+                r2 += lh4 * b4_stride;
+                if (matches(r2)) {
+                    masks[1] |= mask;
+                    if (++count >= 8) return;
+                }
+                lh4 = bs(r2)[1];
+                mask <<= lh4;
+            }
+        }
+    }
+    if (have_topleft && matches(&r[-(1 + b4_stride)])) {
+        masks[1] |= 1ULL << 32;
+        if (++count >= 8) return;
+    }
+    if (have_topright && matches(&r[bw4 - b4_stride])) {
+        masks[0] |= 1ULL << 32;
+    }
+#undef matches
+}
+
+static void derive_warpmv(const Dav1dTileContext *const t,
+                          const int bw4, const int bh4,
+                          const uint64_t masks[2], const struct mv mv,
+                          WarpedMotionParams *const wmp)
+{
+    int pts[8][2 /* in, out */][2 /* x, y */], np = 0;
+    const Dav1dFrameContext *const f = t->f;
+    const ptrdiff_t b4_stride = f->b4_stride;
+    const refmvs *const r = &f->mvs[t->by * b4_stride + t->bx];
+
+#define add_sample(dx, dy, sx, sy, rp) do { \
+    pts[np][0][0] = 16 * (2 * dx + sx * bs(rp)[0]) - 8; \
+    pts[np][0][1] = 16 * (2 * dy + sy * bs(rp)[1]) - 8; \
+    pts[np][1][0] = pts[np][0][0] + (rp)->mv[0].x; \
+    pts[np][1][1] = pts[np][0][1] + (rp)->mv[0].y; \
+    np++; \
+} while (0)
+
+    // use masks[] to find the projectable motion vectors in the edges
+    if ((unsigned) masks[0] == 1 && !(masks[1] >> 32)) {
+        const int off = t->bx & (bs(&r[-b4_stride])[0] - 1);
+        add_sample(-off, 0, 1, -1, &r[-b4_stride]);
+    } else for (unsigned off = 0, xmask = masks[0]; np < 8 && xmask;) { // top
+        const int tz = __builtin_ctz(xmask);
+        off += tz;
+        add_sample(off, 0, 1, -1, &r[off - b4_stride]);
+        xmask >>= tz + 1;
+        off += 1;
+    }
+    if (np < 8 && masks[1] == 1) {
+        const int off = t->by & (bs(&r[-1])[1] - 1);
+        add_sample(0, -off, -1, 1, &r[-1 - off * b4_stride]);
+    } else for (unsigned off = 0, ymask = masks[1]; np < 8 && ymask;) { // left
+        const int tz = __builtin_ctz(ymask);
+        off += tz;
+        add_sample(0, off, -1, 1, &r[off * b4_stride - 1]);
+        ymask >>= tz + 1;
+        off += 1;
+    }
+    if (np < 8 && masks[1] >> 32) // top/left
+        add_sample(0, 0, -1, -1, &r[-(1 + b4_stride)]);
+    if (np < 8 && masks[0] >> 32) // top/right
+        add_sample(bw4, 0, 1, -1, &r[bw4 - b4_stride]);
+    assert(np > 0 && np <= 8);
+#undef bs
+
+    // select according to motion vector difference against a threshold
+    int mvd[8], ret = 0;
+    const int thresh = 4 * iclip(imax(bw4, bh4), 4, 28);
+    for (int i = 0; i < np; i++) {
+        mvd[i] = labs(pts[i][1][0] - pts[i][0][0] - mv.x) +
+                 labs(pts[i][1][1] - pts[i][0][1] - mv.y);
+        if (mvd[i] > thresh)
+            mvd[i] = -1;
+        else
+            ret++;
+    }
+    if (!ret) {
+        ret = 1;
+    } else for (int i = 0, j = np - 1, k = 0; k < np - ret; k++, i++, j--) {
+        while (mvd[i] != -1) i++;
+        while (mvd[j] == -1) j--;
+        assert(i != j);
+        if (i > j) break;
+        // replace the discarded samples;
+        mvd[i] = mvd[j];
+        memcpy(pts[i], pts[j], sizeof(*pts));
+    }
+
+    if (!find_affine_int(pts, ret, bw4, bh4, mv, wmp, t->bx, t->by) &&
+        !get_shear_params(wmp))
+    {
+        wmp->type = WM_TYPE_AFFINE;
+    } else
+        wmp->type = WM_TYPE_IDENTITY;
+}
+
+static inline int findoddzero(const uint8_t *buf, int len) {
+    for (int n = 0; n < len; n++)
+        if (!buf[n * 2]) return 1;
+    return 0;
+}
+
+static void read_pal_plane(Dav1dTileContext *const t, Av1Block *const b,
+                           const int pl, const int sz_ctx,
+                           const int bx4, const int by4)
+{
+    Dav1dTileState *const ts = t->ts;
+    const Dav1dFrameContext *const f = t->f;
+    const int pal_sz = b->pal_sz[pl] = 2 + msac_decode_symbol_adapt(&ts->msac,
+                                                 ts->cdf.m.pal_sz[pl][sz_ctx], 7);
+    uint16_t cache[16], used_cache[8];
+    int l_cache = pl ? t->pal_sz_uv[1][by4] : t->l.pal_sz[by4];
+    int n_cache = 0;
+    // don't reuse above palette outside SB64 boundaries
+    int a_cache = by4 & 15 ? pl ? t->pal_sz_uv[0][bx4] : t->a->pal_sz[bx4] : 0;
+    const uint16_t *l = t->al_pal[1][by4][pl], *a = t->al_pal[0][bx4][pl];
+
+    // fill/sort cache
+    while (l_cache && a_cache) {
+        if (*l < *a) {
+            if (!n_cache || cache[n_cache - 1] != *l)
+                cache[n_cache++] = *l;
+            l++;
+            l_cache--;
+        } else {
+            if (*a == *l) {
+                l++;
+                l_cache--;
+            }
+            if (!n_cache || cache[n_cache - 1] != *a)
+                cache[n_cache++] = *a;
+            a++;
+            a_cache--;
+        }
+    }
+    if (l_cache) {
+        do {
+            if (!n_cache || cache[n_cache - 1] != *l)
+                cache[n_cache++] = *l;
+            l++;
+        } while (--l_cache > 0);
+    } else if (a_cache) {
+        do {
+            if (!n_cache || cache[n_cache - 1] != *a)
+                cache[n_cache++] = *a;
+            a++;
+        } while (--a_cache > 0);
+    }
+
+    // find reused cache entries
+    int i = 0;
+    for (int n = 0; n < n_cache && i < pal_sz; n++)
+        if (msac_decode_bool(&ts->msac, 128 << 7))
+            used_cache[i++] = cache[n];
+    const int n_used_cache = i;
+
+    // parse new entries
+    uint16_t *const pal = f->frame_thread.pass ?
+        f->frame_thread.pal[((t->by >> 1) + (t->bx & 1)) * (f->b4_stride >> 1) +
+                            ((t->bx >> 1) + (t->by & 1))][pl] : t->pal[pl];
+    if (i < pal_sz) {
+        int prev = pal[i++] = msac_decode_bools(&ts->msac, f->cur.p.p.bpc);
+
+        if (i < pal_sz) {
+            int bits = f->cur.p.p.bpc - 3 + msac_decode_bools(&ts->msac, 2);
+            const int max = (1 << f->cur.p.p.bpc) - 1;
+
+            do {
+                const int delta = msac_decode_bools(&ts->msac, bits);
+                prev = pal[i++] = imin(prev + delta + !pl, max);
+                if (prev + !pl >= max) {
+                    for (; i < pal_sz; i++)
+                        pal[i] = pal[i - 1];
+                    break;
+                }
+                bits = imin(bits, 1 + ulog2(max - prev - !pl));
+            } while (i < pal_sz);
+        }
+
+        // merge cache+new entries
+        int n = 0, m = n_used_cache;
+        for (i = 0; i < pal_sz; i++) {
+            if (n < n_used_cache && (m >= pal_sz || used_cache[n] <= pal[m])) {
+                pal[i] = used_cache[n++];
+            } else {
+                assert(m < pal_sz);
+                pal[i] = pal[m++];
+            }
+        }
+    } else {
+        memcpy(pal, used_cache, n_used_cache * sizeof(*used_cache));
+    }
+
+    if (DEBUG_BLOCK_INFO) {
+        printf("Post-pal[pl=%d,sz=%d,cache_size=%d,used_cache=%d]: r=%d, cache=",
+               pl, b->pal_sz[pl], n_cache, n_used_cache, ts->msac.rng);
+        for (int n = 0; n < n_cache; n++)
+            printf("%c%02x", n ? ' ' : '[', cache[n]);
+        printf("%s, pal=", n_cache ? "]" : "[]");
+        for (int n = 0; n < b->pal_sz[0]; n++)
+            printf("%c%02x", n ? ' ' : '[', pal[n]);
+        printf("]\n");
+    }
+}
+
+static void read_pal_uv(Dav1dTileContext *const t, Av1Block *const b,
+                        const int sz_ctx, const int cbx4, const int cby4)
+{
+    read_pal_plane(t, b, 1, sz_ctx, cbx4, cby4);
+
+    // V pal coding
+    Dav1dTileState *const ts = t->ts;
+    const Dav1dFrameContext *const f = t->f;
+    uint16_t *const pal = f->frame_thread.pass ?
+        f->frame_thread.pal[((t->by >> 1) + (t->bx & 1)) * (f->b4_stride >> 1) +
+                            ((t->bx >> 1) + (t->by & 1))][2] : t->pal[2];
+    if (msac_decode_bool(&ts->msac, 128 << 7)) {
+        const int bits = f->cur.p.p.bpc - 4 + msac_decode_bools(&ts->msac, 2);
+        int prev = pal[0] = msac_decode_bools(&ts->msac, f->cur.p.p.bpc);
+        const int max = (1 << f->cur.p.p.bpc) - 1;
+        for (int i = 1; i < b->pal_sz[1]; i++) {
+            int delta = msac_decode_bools(&ts->msac, bits);
+            if (delta && msac_decode_bool(&ts->msac, 128 << 7)) delta = -delta;
+            prev = pal[i] = (prev + delta) & max;
+        }
+    } else {
+        for (int i = 0; i < b->pal_sz[1]; i++)
+            pal[i] = msac_decode_bools(&ts->msac, f->cur.p.p.bpc);
+    }
+    if (DEBUG_BLOCK_INFO) {
+        printf("Post-pal[pl=2]: r=%d ", ts->msac.rng);
+        for (int n = 0; n < b->pal_sz[1]; n++)
+            printf("%c%02x", n ? ' ' : '[', pal[n]);
+        printf("]\n");
+    }
+}
+
+// meant to be SIMD'able, so that theoretical complexity of this function
+// times block size goes from w4*h4 to w4+h4-1
+// a and b are previous two lines containing (a) top/left entries or (b)
+// top/left entries, with a[0] being either the first top or first left entry,
+// depending on top_offset being 1 or 0, and b being the first top/left entry
+// for whichever has one. left_offset indicates whether the (len-1)th entry
+// has a left neighbour.
+// output is order[] and ctx for each member of this diagonal.
+static void order_palette(const uint8_t *pal_idx, const ptrdiff_t stride,
+                          const int i, const int first, const int last,
+                          uint8_t (*const order)[8], uint8_t *const ctx)
+{
+    int have_top = i > first;
+
+    pal_idx += first + (i - first) * stride;
+    for (int j = first, n = 0; j >= last; have_top = 1, j--, n++, pal_idx += stride - 1) {
+        const int have_left = j > 0;
+
+        assert(have_left || have_top);
+
+#define add(v_in) do { \
+        const int v = v_in; \
+        assert(v < 8U); \
+        order[n][o_idx++] = v; \
+        mask |= 1 << v; \
+    } while (0)
+
+        unsigned mask = 0;
+        int o_idx = 0;
+        if (!have_left) {
+            ctx[n] = 0;
+            add(pal_idx[-stride]);
+        } else if (!have_top) {
+            ctx[n] = 0;
+            add(pal_idx[-1]);
+        } else {
+            const int l = pal_idx[-1], t = pal_idx[-stride], tl = pal_idx[-(stride + 1)];
+            const int same_t_l = t == l;
+            const int same_t_tl = t == tl;
+            const int same_l_tl = l == tl;
+            const int same_all = same_t_l & same_t_tl & same_l_tl;
+
+            if (same_all) {
+                ctx[n] = 4;
+                add(t);
+            } else if (same_t_l) {
+                ctx[n] = 3;
+                add(t);
+                add(tl);
+            } else if (same_t_tl | same_l_tl) {
+                ctx[n] = 2;
+                add(tl);
+                add(same_t_tl ? l : t);
+            } else {
+                ctx[n] = 1;
+                add(imin(t, l));
+                add(imax(t, l));
+                add(tl);
+            }
+        }
+        for (unsigned m = 1, bit = 0; m < 0x100; m <<= 1, bit++)
+            if (!(mask & m))
+                order[n][o_idx++] = bit;
+        assert(o_idx == 8);
+#undef add
+    }
+}
+
+static void read_pal_indices(Dav1dTileContext *const t,
+                             uint8_t *const pal_idx,
+                             const Av1Block *const b, const int pl,
+                             const int w4, const int h4,
+                             const int bw4, const int bh4)
+{
+    Dav1dTileState *const ts = t->ts;
+    const ptrdiff_t stride = bw4 * 4;
+    pal_idx[0] = msac_decode_uniform(&ts->msac, b->pal_sz[pl]);
+    uint16_t (*const color_map_cdf)[8 + 1] =
+        ts->cdf.m.color_map[pl][b->pal_sz[pl] - 2];
+    for (int i = 1; i < 4 * (w4 + h4) - 1; i++) {
+        // top/left-to-bottom/right diagonals ("wave-front")
+        uint8_t order[64][8], ctx[64];
+        const int first = imin(i, w4 * 4 - 1);
+        const int last = imax(0, i - h4 * 4 + 1);
+        order_palette(pal_idx, stride, i, first, last, order, ctx);
+        for (int j = first, m = 0; j >= last; j--, m++) {
+            const int color_idx =
+                msac_decode_symbol_adapt(&ts->msac, color_map_cdf[ctx[m]],
+                                         b->pal_sz[pl]);
+            pal_idx[(i - j) * stride + j] = order[m][color_idx];
+        }
+    }
+    // fill invisible edges
+    if (bw4 > w4)
+        for (int y = 0; y < 4 * h4; y++)
+            memset(&pal_idx[y * stride + 4 * w4],
+                   pal_idx[y * stride + 4 * w4 - 1], 4 * (bw4 - w4));
+    if (h4 < bh4) {
+        const uint8_t *const src = &pal_idx[stride * (4 * h4 - 1)];
+        for (int y = h4 * 4; y < bh4 * 4; y++)
+            memcpy(&pal_idx[y * stride], src, bw4 * 4);
+    }
+}
+
+static void read_vartx_tree(Dav1dTileContext *const t,
+                            Av1Block *const b, const enum BlockSize bs,
+                            const int bx4, const int by4)
+{
+    const Dav1dFrameContext *const f = t->f;
+    const uint8_t *const b_dim = av1_block_dimensions[bs];
+    const int bw4 = b_dim[0], bh4 = b_dim[1];
+
+    // var-tx tree coding
+    b->tx_split[0] = b->tx_split[1] = 0;
+    b->max_ytx = av1_max_txfm_size_for_bs[bs][0];
+    if (f->frame_hdr.segmentation.lossless[b->seg_id] ||
+        b->max_ytx == TX_4X4)
+    {
+        b->max_ytx = b->uvtx = TX_4X4;
+        if (f->frame_hdr.txfm_mode == TX_SWITCHABLE) {
+            memset(&t->a->tx[bx4], TX_4X4, bw4);
+            memset(&t->l.tx[by4], TX_4X4, bh4);
+        }
+    } else if (f->frame_hdr.txfm_mode != TX_SWITCHABLE || b->skip) {
+        if (f->frame_hdr.txfm_mode == TX_SWITCHABLE) {
+            memset(&t->a->tx[bx4], b_dim[2], bw4);
+            memset(&t->l.tx[by4], b_dim[3], bh4);
+        } else {
+            assert(f->frame_hdr.txfm_mode == TX_LARGEST);
+        }
+        b->uvtx = av1_max_txfm_size_for_bs[bs][f->cur.p.p.layout];
+    } else {
+        assert(imin(bw4, bh4) <= 16 || b->max_ytx == TX_64X64);
+        int y, x, y_off, x_off;
+        const TxfmInfo *const ytx = &av1_txfm_dimensions[b->max_ytx];
+        for (y = 0, y_off = 0; y < bh4; y += ytx->h, y_off++) {
+            for (x = 0, x_off = 0; x < bw4; x += ytx->w, x_off++) {
+                read_tx_tree(t, b->max_ytx, 0, b->tx_split, x_off, y_off);
+                // contexts are updated inside read_tx_tree()
+                t->bx += ytx->w;
+            }
+            t->bx -= x;
+            t->by += ytx->h;
+        }
+        t->by -= y;
+        if (DEBUG_BLOCK_INFO)
+            printf("Post-vartxtree[%x/%x]: r=%d\n",
+                   b->tx_split[0], b->tx_split[1], t->ts->msac.rng);
+        b->uvtx = av1_max_txfm_size_for_bs[bs][f->cur.p.p.layout];
+    }
+}
+
+static inline unsigned get_prev_frame_segid(const Dav1dFrameContext *const f,
+                                            const int by, const int bx,
+                                            const int w4, int h4,
+                                            const uint8_t *ref_seg_map,
+                                            const ptrdiff_t stride)
+{
+    unsigned seg_id = 8;
+
+    assert(f->frame_hdr.primary_ref_frame != PRIMARY_REF_NONE);
+    dav1d_thread_picture_wait(&f->refp[f->frame_hdr.primary_ref_frame],
+                              (by + h4) * 4, PLANE_TYPE_BLOCK);
+
+    ref_seg_map += by * stride + bx;
+    do {
+        for (int x = 0; x < w4; x++)
+            seg_id = imin(seg_id, ref_seg_map[x]);
+        ref_seg_map += stride;
+    } while (--h4 > 0);
+    assert(seg_id < 8);
+
+    return seg_id;
+}
+
+static void decode_b(Dav1dTileContext *const t,
+                     const enum BlockLevel bl,
+                     const enum BlockSize bs,
+                     const enum BlockPartition bp,
+                     const enum EdgeFlags intra_edge_flags)
+{
+    Dav1dTileState *const ts = t->ts;
+    const Dav1dFrameContext *const f = t->f;
+    Av1Block b_mem, *const b = f->frame_thread.pass ?
+        &f->frame_thread.b[t->by * f->b4_stride + t->bx] : &b_mem;
+    const uint8_t *const b_dim = av1_block_dimensions[bs];
+    const int bx4 = t->bx & 31, by4 = t->by & 31;
+    const int ss_ver = f->cur.p.p.layout == DAV1D_PIXEL_LAYOUT_I420;
+    const int ss_hor = f->cur.p.p.layout != DAV1D_PIXEL_LAYOUT_I444;
+    const int cbx4 = bx4 >> ss_hor, cby4 = by4 >> ss_ver;
+    const int bw4 = b_dim[0], bh4 = b_dim[1];
+    const int w4 = imin(bw4, f->bw - t->bx), h4 = imin(bh4, f->bh - t->by);
+    const int cbw4 = (bw4 + ss_hor) >> ss_hor, cbh4 = (bh4 + ss_ver) >> ss_ver;
+    const int have_left = t->bx > ts->tiling.col_start;
+    const int have_top = t->by > ts->tiling.row_start;
+    const int has_chroma = f->seq_hdr.layout != DAV1D_PIXEL_LAYOUT_I400 &&
+                           (bw4 > ss_hor || t->bx & 1) &&
+                           (bh4 > ss_ver || t->by & 1);
+
+    if (f->frame_thread.pass == 2) {
+        if (b->intra) {
+            f->bd_fn.recon_b_intra(t, bs, intra_edge_flags, b);
+
+            if (has_chroma) {
+                memset(&t->l.uvmode[cby4], b->uv_mode, cbh4);
+                memset(&t->a->uvmode[cbx4], b->uv_mode, cbw4);
+            }
+            const enum IntraPredMode y_mode_nofilt =
+                b->y_mode == FILTER_PRED ? DC_PRED : b->y_mode;
+            memset(&t->l.mode[by4], y_mode_nofilt, bh4);
+            memset(&t->a->mode[bx4], y_mode_nofilt, bw4);
+        } else {
+            if (b->comp_type == COMP_INTER_NONE && b->motion_mode == MM_WARP) {
+                uint64_t mask[2] = { 0, 0 };
+                find_matching_ref(t, intra_edge_flags, bw4, bh4, w4, h4,
+                                  have_left, have_top, b->ref[0], mask);
+                derive_warpmv(t, bw4, bh4, mask, b->mv[0], &t->warpmv);
+            }
+            f->bd_fn.recon_b_inter(t, bs, b);
+
+            const uint8_t *const filter = eve_av1_filter_dir[b->filter2d];
+            memset(&t->l.filter[0][by4], filter[0], bh4);
+            memset(&t->a->filter[0][bx4], filter[0], bw4);
+            memset(&t->l.filter[1][by4], filter[1], bh4);
+            memset(&t->a->filter[1][bx4], filter[1], bw4);
+            if (has_chroma) {
+                memset(&t->l.uvmode[cby4], DC_PRED, cbh4);
+                memset(&t->a->uvmode[cbx4], DC_PRED, cbw4);
+            }
+        }
+        memset(&t->l.intra[by4], b->intra, bh4);
+        memset(&t->a->intra[bx4], b->intra, bw4);
+        return;
+    }
+
+    const int cw4 = (w4 + ss_hor) >> ss_hor, ch4 = (h4 + ss_ver) >> ss_ver;
+
+    b->bl = bl;
+    b->bp = bp;
+    b->bs = bs;
+
+    // skip_mode
+    if (f->frame_hdr.skip_mode_enabled && imin(bw4, bh4) > 1) {
+        const int smctx = t->a->skip_mode[bx4] + t->l.skip_mode[by4];
+        b->skip_mode = msac_decode_bool_adapt(&ts->msac,
+                                              ts->cdf.m.skip_mode[smctx]);
+        if (DEBUG_BLOCK_INFO)
+            printf("Post-skipmode[%d]: r=%d\n", b->skip_mode, ts->msac.rng);
+    } else {
+        b->skip_mode = 0;
+    }
+
+    // segment_id (if seg_feature for skip/ref/gmv is enabled)
+    int seg_pred = 0;
+    if (f->frame_hdr.segmentation.enabled) {
+        if (!f->frame_hdr.segmentation.update_map) {
+            b->seg_id = f->prev_segmap ?
+                        get_prev_frame_segid(f, t->by, t->bx, w4, h4,
+                                             f->prev_segmap, f->b4_stride) : 0;
+        } else if (f->frame_hdr.segmentation.seg_data.preskip) {
+            if (f->frame_hdr.segmentation.temporal &&
+                (seg_pred = msac_decode_bool_adapt(&ts->msac,
+                                       ts->cdf.m.seg_pred[t->a->seg_pred[bx4] +
+                                                          t->l.seg_pred[by4]])))
+            {
+                // temporal predicted seg_id
+                b->seg_id = f->prev_segmap ?
+                            get_prev_frame_segid(f, t->by, t->bx, w4, h4,
+                                                 f->prev_segmap, f->b4_stride) : 0;
+            } else {
+                int seg_ctx;
+                const unsigned pred_seg_id =
+                    get_cur_frame_segid(t->by, t->bx, have_top, have_left,
+                                        &seg_ctx, f->cur_segmap, f->b4_stride);
+                const unsigned diff = msac_decode_symbol_adapt(&ts->msac,
+                                                   ts->cdf.m.seg_id[seg_ctx],
+                                                   NUM_SEGMENTS);
+                const unsigned last_active_seg_id =
+                    f->frame_hdr.segmentation.seg_data.last_active_segid;
+                b->seg_id = av1_neg_deinterleave(diff, pred_seg_id,
+                                                 last_active_seg_id + 1);
+                if (b->seg_id > last_active_seg_id) b->seg_id = 0; // error?
+            }
+
+            if (DEBUG_BLOCK_INFO)
+                printf("Post-segid[preskip;%d]: r=%d\n",
+                       b->seg_id, ts->msac.rng);
+        }
+    } else {
+        b->seg_id = 0;
+    }
+
+    // skip
+    const int sctx = t->a->skip[bx4] + t->l.skip[by4];
+    b->skip = b->skip_mode ? 1 :
+              msac_decode_bool_adapt(&ts->msac, ts->cdf.m.skip[sctx]);
+    if (DEBUG_BLOCK_INFO)
+        printf("Post-skip[%d]: r=%d\n", b->skip, ts->msac.rng);
+
+    // segment_id
+    if (f->frame_hdr.segmentation.enabled &&
+        f->frame_hdr.segmentation.update_map &&
+        !f->frame_hdr.segmentation.seg_data.preskip)
+    {
+        if (!b->skip && f->frame_hdr.segmentation.temporal &&
+            (seg_pred = msac_decode_bool_adapt(&ts->msac,
+                                   ts->cdf.m.seg_pred[t->a->seg_pred[bx4] +
+                                                      t->l.seg_pred[by4]])))
+        {
+            // temporal predicted seg_id
+            b->seg_id = f->prev_segmap ?
+                        get_prev_frame_segid(f, t->by, t->bx, w4, h4,
+                                             f->prev_segmap, f->b4_stride) : 0;
+        } else {
+            int seg_ctx;
+            const unsigned pred_seg_id =
+                get_cur_frame_segid(t->by, t->bx, have_top, have_left,
+                                    &seg_ctx, f->cur_segmap, f->b4_stride);
+            if (b->skip) {
+                b->seg_id = pred_seg_id;
+            } else {
+                const unsigned diff = msac_decode_symbol_adapt(&ts->msac,
+                                                   ts->cdf.m.seg_id[seg_ctx],
+                                                   NUM_SEGMENTS);
+                const unsigned last_active_seg_id =
+                    f->frame_hdr.segmentation.seg_data.last_active_segid;
+                b->seg_id = av1_neg_deinterleave(diff, pred_seg_id,
+                                                 last_active_seg_id + 1);
+                if (b->seg_id > last_active_seg_id) b->seg_id = 0; // error?
+            }
+        }
+
+        if (DEBUG_BLOCK_INFO)
+            printf("Post-segid[postskip;%d]: r=%d\n",
+                   b->seg_id, ts->msac.rng);
+    }
+
+    // cdef index
+    if (!b->skip) {
+        const int idx = f->seq_hdr.sb128 ? ((t->bx & 16) >> 4) +
+                                           ((t->by & 16) >> 3) : 0;
+        if (t->cur_sb_cdef_idx_ptr[idx] == -1) {
+            const int v = msac_decode_bools(&ts->msac, f->frame_hdr.cdef.n_bits);
+            t->cur_sb_cdef_idx_ptr[idx] = v;
+            if (bw4 > 16) t->cur_sb_cdef_idx_ptr[idx + 1] = v;
+            if (bh4 > 16) t->cur_sb_cdef_idx_ptr[idx + 2] = v;
+            if (bw4 == 32 && bh4 == 32) t->cur_sb_cdef_idx_ptr[idx + 3] = v;
+
+            if (DEBUG_BLOCK_INFO)
+                printf("Post-cdef_idx[%d]: r=%d\n",
+                        *t->cur_sb_cdef_idx_ptr, ts->msac.rng);
+        }
+    }
+
+    // delta-q/lf
+    if (!(t->bx & (31 >> !f->seq_hdr.sb128)) &&
+        !(t->by & (31 >> !f->seq_hdr.sb128)))
+    {
+        const int prev_qidx = ts->last_qidx;
+        const int have_delta_q = f->frame_hdr.delta_q_present &&
+            (bs != (f->seq_hdr.sb128 ? BS_128x128 : BS_64x64) || !b->skip);
+        if (have_delta_q) {
+            int delta_q = msac_decode_symbol_adapt(&ts->msac, ts->cdf.m.delta_q, 4);
+            if (delta_q == 3) {
+                const int n_bits = 1 + msac_decode_bools(&ts->msac, 3);
+                delta_q = msac_decode_bools(&ts->msac, n_bits) + 1 + (1 << n_bits);
+            }
+            if (delta_q) {
+                if (msac_decode_bool(&ts->msac, 128 << 7)) delta_q = -delta_q;
+                delta_q *= 1 << f->frame_hdr.delta_q_res_log2;
+            }
+            ts->last_qidx = iclip(ts->last_qidx + delta_q, 1, 255);
+            if (have_delta_q && DEBUG_BLOCK_INFO)
+                printf("Post-delta_q[%d->%d]: r=%d\n",
+                       delta_q, ts->last_qidx, ts->msac.rng);
+        }
+        if (ts->last_qidx == f->frame_hdr.quant.yac) {
+            // assign frame-wide q values to this sb
+            ts->dq = f->dq;
+        } else if (ts->last_qidx != prev_qidx) {
+            // find sb-specific quant parameters
+            init_quant_tables(&f->seq_hdr, &f->frame_hdr, ts->last_qidx, ts->dqmem);
+            ts->dq = ts->dqmem;
+        }
+
+        // delta_lf
+        int8_t prev_delta_lf[4];
+        memcpy(prev_delta_lf, ts->last_delta_lf, 4);
+        if (have_delta_q && f->frame_hdr.delta_lf_present) {
+            const int n_lfs = f->frame_hdr.delta_lf_multi ?
+                f->seq_hdr.layout != DAV1D_PIXEL_LAYOUT_I400 ? 4 : 2 : 1;
+
+            for (int i = 0; i < n_lfs; i++) {
+                int delta_lf = msac_decode_symbol_adapt(&ts->msac,
+                                ts->cdf.m.delta_lf[i + f->frame_hdr.delta_lf_multi], 4);
+                if (delta_lf == 3) {
+                    const int n_bits = 1 + msac_decode_bools(&ts->msac, 3);
+                    delta_lf = msac_decode_bools(&ts->msac, n_bits) + 1 + (1 << n_bits);
+                }
+                if (delta_lf) {
+                    if (msac_decode_bool(&ts->msac, 128 << 7)) delta_lf = -delta_lf;
+                    delta_lf *= 1 << f->frame_hdr.delta_lf_res_log2;
+                }
+                ts->last_delta_lf[i] = iclip(ts->last_delta_lf[i] + delta_lf, -63, 63);
+                if (have_delta_q && DEBUG_BLOCK_INFO)
+                    printf("Post-delta_lf[%d:%d]: r=%d\n", i, delta_lf, ts->msac.rng);
+            }
+        }
+        if (!memcmp(ts->last_delta_lf, (int8_t[4]) { 0, 0, 0, 0 }, 4)) {
+            // assign frame-wide lf values to this sb
+            ts->lflvl = f->lf.lvl;
+        } else if (memcmp(ts->last_delta_lf, prev_delta_lf, 4)) {
+            // find sb-specific lf lvl parameters
+            dav1d_calc_lf_values(ts->lflvlmem, &f->frame_hdr, ts->last_delta_lf);
+            ts->lflvl = ts->lflvlmem;
+        }
+    }
+
+    if (b->skip_mode) {
+        b->intra = 0;
+    } else if (f->frame_hdr.frame_type & 1) {
+        const int ictx = get_intra_ctx(t->a, &t->l, by4, bx4,
+                                       have_top, have_left);
+        b->intra = !msac_decode_bool_adapt(&ts->msac, ts->cdf.m.intra[ictx]);
+        if (DEBUG_BLOCK_INFO)
+            printf("Post-intra[%d]: r=%d\n", b->intra, ts->msac.rng);
+    } else if (f->frame_hdr.allow_intrabc) {
+        b->intra = !msac_decode_bool_adapt(&ts->msac, ts->cdf.m.intrabc);
+        if (DEBUG_BLOCK_INFO)
+            printf("Post-intrabcflag[%d]: r=%d\n", b->intra, ts->msac.rng);
+    } else {
+        b->intra = 1;
+    }
+
+    // intra/inter-specific stuff
+    if (b->intra) {
+        uint16_t *const ymode_cdf = f->frame_hdr.frame_type & 1 ?
+            ts->cdf.m.y_mode[av1_ymode_size_context[bs]] :
+            ts->cdf.kfym[intra_mode_context[t->a->mode[bx4]]]
+                        [intra_mode_context[t->l.mode[by4]]];
+        b->y_mode = msac_decode_symbol_adapt(&ts->msac, ymode_cdf,
+                                              N_INTRA_PRED_MODES);
+        if (DEBUG_BLOCK_INFO)
+            printf("Post-ymode[%d]: r=%d\n", b->y_mode, ts->msac.rng);
+
+        // angle delta
+        if (b_dim[2] + b_dim[3] >= 2 && b->y_mode >= VERT_PRED &&
+            b->y_mode <= VERT_LEFT_PRED)
+        {
+            uint16_t *const acdf = ts->cdf.m.angle_delta[b->y_mode - VERT_PRED];
+            const int angle = msac_decode_symbol_adapt(&ts->msac, acdf, 7);
+            b->y_angle = angle - 3;
+        } else {
+            b->y_angle = 0;
+        }
+
+        if (has_chroma) {
+            const int cfl_allowed = !!(cfl_allowed_mask & (1 << bs));
+            uint16_t *const uvmode_cdf = ts->cdf.m.uv_mode[cfl_allowed][b->y_mode];
+            b->uv_mode = msac_decode_symbol_adapt(&ts->msac, uvmode_cdf,
+                                         N_UV_INTRA_PRED_MODES - !cfl_allowed);
+            if (DEBUG_BLOCK_INFO)
+                printf("Post-uvmode[%d]: r=%d\n", b->uv_mode, ts->msac.rng);
+
+            if (b->uv_mode == CFL_PRED) {
+#define SIGN(a) (!!(a) + ((a) > 0))
+                const int sign =
+                    msac_decode_symbol_adapt(&ts->msac, ts->cdf.m.cfl_sign, 8) + 1;
+                const int sign_u = sign * 0x56 >> 8, sign_v = sign - sign_u * 3;
+                assert(sign_u == sign / 3);
+                if (sign_u) {
+                    const int ctx = (sign_u == 2) * 3 + sign_v;
+                    b->cfl_alpha[0] = msac_decode_symbol_adapt(&ts->msac,
+                                            ts->cdf.m.cfl_alpha[ctx], 16) + 1;
+                    if (sign_u == 1) b->cfl_alpha[0] = -b->cfl_alpha[0];
+                } else {
+                    b->cfl_alpha[0] = 0;
+                }
+                if (sign_v) {
+                    const int ctx = (sign_v == 2) * 3 + sign_u;
+                    b->cfl_alpha[1] = msac_decode_symbol_adapt(&ts->msac,
+                                            ts->cdf.m.cfl_alpha[ctx], 16) + 1;
+                    if (sign_v == 1) b->cfl_alpha[1] = -b->cfl_alpha[1];
+                } else {
+                    b->cfl_alpha[1] = 0;
+                }
+#undef SIGN
+                if (DEBUG_BLOCK_INFO)
+                    printf("Post-uvalphas[%d/%d]: r=%d\n",
+                           b->cfl_alpha[0], b->cfl_alpha[1], ts->msac.rng);
+            } else if (b_dim[2] + b_dim[3] >= 2 && b->uv_mode >= VERT_PRED &&
+                       b->uv_mode <= VERT_LEFT_PRED)
+            {
+                uint16_t *const acdf = ts->cdf.m.angle_delta[b->uv_mode - VERT_PRED];
+                const int angle = msac_decode_symbol_adapt(&ts->msac, acdf, 7);
+                b->uv_angle = angle - 3;
+            } else {
+                b->uv_angle = 0;
+            }
+        }
+
+        b->pal_sz[0] = b->pal_sz[1] = 0;
+        if (f->frame_hdr.allow_screen_content_tools &&
+            imax(bw4, bh4) <= 16 && bw4 + bh4 >= 4)
+        {
+            const int sz_ctx = b_dim[2] + b_dim[3] - 2;
+            if (b->y_mode == DC_PRED) {
+                const int pal_ctx = (t->a->pal_sz[bx4] > 0) + (t->l.pal_sz[by4] > 0);
+                const int use_y_pal =
+                    msac_decode_bool_adapt(&ts->msac, ts->cdf.m.pal_y[sz_ctx][pal_ctx]);
+                if (DEBUG_BLOCK_INFO)
+                    printf("Post-y_pal[%d]: r=%d\n", use_y_pal, ts->msac.rng);
+                if (use_y_pal)
+                    read_pal_plane(t, b, 0, sz_ctx, bx4, by4);
+            }
+
+            if (has_chroma && b->uv_mode == DC_PRED) {
+                const int pal_ctx = b->pal_sz[0] > 0;
+                const int use_uv_pal =
+                    msac_decode_bool_adapt(&ts->msac, ts->cdf.m.pal_uv[pal_ctx]);
+                if (DEBUG_BLOCK_INFO)
+                    printf("Post-uv_pal[%d]: r=%d\n", use_uv_pal, ts->msac.rng);
+                if (use_uv_pal)
+                    read_pal_uv(t, b, sz_ctx, cbx4, cby4);
+            }
+        }
+
+        if (b->y_mode == DC_PRED && !b->pal_sz[0] &&
+            imax(b_dim[2], b_dim[3]) <= 3 && f->seq_hdr.filter_intra)
+        {
+            const int is_filter = msac_decode_bool_adapt(&ts->msac,
+                                            ts->cdf.m.use_filter_intra[bs]);
+            if (is_filter) {
+                b->y_mode = FILTER_PRED;
+                b->y_angle = msac_decode_symbol_adapt(&ts->msac,
+                                                  ts->cdf.m.filter_intra, 5);
+            }
+            if (DEBUG_BLOCK_INFO)
+                printf("Post-filterintramode[%d/%d]: r=%d\n",
+                       b->y_mode, b->y_angle, ts->msac.rng);
+        }
+
+        if (b->pal_sz[0]) {
+            uint8_t *pal_idx;
+            if (f->frame_thread.pass) {
+                pal_idx = ts->frame_thread.pal_idx;
+                ts->frame_thread.pal_idx += bw4 * bh4 * 16;
+            } else
+                pal_idx = t->scratch.pal_idx;
+            read_pal_indices(t, pal_idx, b, 0, w4, h4, bw4, bh4);
+            if (DEBUG_BLOCK_INFO)
+                printf("Post-y-pal-indices: r=%d\n", ts->msac.rng);
+        }
+
+        if (has_chroma && b->pal_sz[1]) {
+            uint8_t *pal_idx;
+            if (f->frame_thread.pass) {
+                pal_idx = ts->frame_thread.pal_idx;
+                ts->frame_thread.pal_idx += cbw4 * cbh4 * 16;
+            } else
+                pal_idx = &t->scratch.pal_idx[bw4 * bh4 * 16];
+            read_pal_indices(t, pal_idx, b, 1, cw4, ch4, cbw4, cbh4);
+            if (DEBUG_BLOCK_INFO)
+                printf("Post-uv-pal-indices: r=%d\n", ts->msac.rng);
+        }
+
+        const TxfmInfo *t_dim;
+        if (f->frame_hdr.segmentation.lossless[b->seg_id]) {
+            b->tx = b->uvtx = (int) TX_4X4;
+            t_dim = &av1_txfm_dimensions[TX_4X4];
+        } else {
+            b->tx = av1_max_txfm_size_for_bs[bs][0];
+            b->uvtx = av1_max_txfm_size_for_bs[bs][f->cur.p.p.layout];
+            t_dim = &av1_txfm_dimensions[b->tx];
+            if (f->frame_hdr.txfm_mode == TX_SWITCHABLE && t_dim->max > TX_4X4) {
+                const int tctx = get_tx_ctx(t->a, &t->l, t_dim, by4, bx4,
+                                            have_top, have_left);
+                uint16_t *const tx_cdf = ts->cdf.m.txsz[t_dim->max - 1][tctx];
+                int depth = msac_decode_symbol_adapt(&ts->msac, tx_cdf,
+                                                     imin(t_dim->max + 1, 3));
+
+                while (depth--) {
+                    b->tx = t_dim->sub;
+                    t_dim = &av1_txfm_dimensions[b->tx];
+                }
+            }
+            if (DEBUG_BLOCK_INFO)
+                printf("Post-tx[%d]: r=%d\n", b->tx, ts->msac.rng);
+        }
+
+        // reconstruction
+        if (f->frame_thread.pass == 1) {
+            f->bd_fn.read_coef_blocks(t, bs, b);
+        } else {
+            f->bd_fn.recon_b_intra(t, bs, intra_edge_flags, b);
+        }
+
+        dav1d_create_lf_mask_intra(t->lf_mask, f->lf.level, f->b4_stride,
+                                   &f->frame_hdr, (const uint8_t (*)[8][2])
+                                   &ts->lflvl[b->seg_id][0][0][0],
+                                   t->bx, t->by, f->bw, f->bh, bs,
+                                   b->tx, b->uvtx, f->cur.p.p.layout,
+                                   &t->a->tx_lpf_y[bx4], &t->l.tx_lpf_y[by4],
+                                   has_chroma ? &t->a->tx_lpf_uv[cbx4] : NULL,
+                                   has_chroma ? &t->l.tx_lpf_uv[cby4] : NULL);
+
+        // update contexts
+        memset(&t->a->tx_intra[bx4], t_dim->lw, bw4);
+        memset(&t->l.tx_intra[by4], t_dim->lh, bh4);
+        const enum IntraPredMode y_mode_nofilt =
+            b->y_mode == FILTER_PRED ? DC_PRED : b->y_mode;
+        memset(&t->l.mode[by4], y_mode_nofilt, bh4);
+        memset(&t->a->mode[bx4], y_mode_nofilt, bw4);
+        memset(&t->l.pal_sz[by4], b->pal_sz[0], bh4);
+        memset(&t->a->pal_sz[bx4], b->pal_sz[0], bw4);
+        if (b->pal_sz[0]) {
+            uint16_t *const pal = f->frame_thread.pass ?
+                f->frame_thread.pal[((t->by >> 1) + (t->bx & 1)) * (f->b4_stride >> 1) +
+                                    ((t->bx >> 1) + (t->by & 1))][0] : t->pal[0];
+            for (int x = 0; x < bw4; x++)
+                memcpy(t->al_pal[0][bx4 + x][0], pal, 16);
+            for (int y = 0; y < bh4; y++)
+                memcpy(t->al_pal[1][by4 + y][0], pal, 16);
+        }
+        if (has_chroma) {
+            memset(&t->l.uvmode[cby4], b->uv_mode, cbh4);
+            memset(&t->a->uvmode[cbx4], b->uv_mode, cbw4);
+            memset(&t->pal_sz_uv[1][cby4], b->pal_sz[1], cbh4);
+            memset(&t->pal_sz_uv[0][cbx4], b->pal_sz[1], cbw4);
+            if (b->pal_sz[1]) for (int pl = 1; pl < 3; pl++) {
+                uint16_t *const pal = f->frame_thread.pass ?
+                    f->frame_thread.pal[((t->by >> 1) + (t->bx & 1)) * (f->b4_stride >> 1) +
+                                        ((t->bx >> 1) + (t->by & 1))][pl] : t->pal[pl];
+                for (int x = 0; x < cbw4; x++)
+                    memcpy(t->al_pal[0][cbx4 + x][pl], pal, 16);
+                for (int y = 0; y < cbh4; y++)
+                    memcpy(t->al_pal[1][cby4 + y][pl], pal, 16);
+            }
+        }
+        if ((f->frame_hdr.frame_type & 1) || f->frame_hdr.allow_intrabc) {
+            memset(&t->a->tx[bx4], t_dim->lw, bw4);
+            memset(&t->l.tx[by4], t_dim->lh, bh4);
+            splat_intraref(f->mvs, f->b4_stride, t->by, t->bx, bs,
+                           y_mode_nofilt);
+        }
+        if (f->frame_hdr.frame_type & 1) {
+            memset(&t->l.comp_type[by4], COMP_INTER_NONE, bh4);
+            memset(&t->a->comp_type[bx4], COMP_INTER_NONE, bw4);
+            memset(&t->l.ref[0][by4], -1, bh4);
+            memset(&t->a->ref[0][bx4], -1, bw4);
+            memset(&t->l.ref[1][by4], -1, bh4);
+            memset(&t->a->ref[1][bx4], -1, bw4);
+            memset(&t->l.filter[0][by4], N_SWITCHABLE_FILTERS, bh4);
+            memset(&t->a->filter[0][bx4], N_SWITCHABLE_FILTERS, bw4);
+            memset(&t->l.filter[1][by4], N_SWITCHABLE_FILTERS, bh4);
+            memset(&t->a->filter[1][bx4], N_SWITCHABLE_FILTERS, bw4);
+        }
+    } else if (!(f->frame_hdr.frame_type & 1)) {
+        // intra block copy
+        candidate_mv mvstack[8];
+        int n_mvs;
+        mv mvlist[2][2];
+        av1_find_ref_mvs(mvstack, &n_mvs, mvlist, NULL,
+                         (int[2]) { -1, -1 }, f->bw, f->bh,
+                         bs, bp, t->by, t->bx, ts->tiling.col_start,
+                         ts->tiling.col_end, ts->tiling.row_start,
+                         ts->tiling.row_end, f->libaom_cm);
+
+        if (mvlist[0][0].y | mvlist[0][0].x)
+            b->mv[0] = mvlist[0][0];
+        else if (mvlist[0][1].y | mvlist[0][1].x)
+            b->mv[0] = mvlist[0][1];
+        else {
+            if (t->by - (16 << f->seq_hdr.sb128) < ts->tiling.row_start) {
+                b->mv[0].y = 0;
+                b->mv[0].x = -(512 << f->seq_hdr.sb128) - 2048;
+            } else {
+                b->mv[0].y = -(512 << f->seq_hdr.sb128);
+                b->mv[0].x = 0;
+            }
+        }
+
+        const struct mv ref = b->mv[0];
+        read_mv_residual(t, &b->mv[0], &ts->cdf.dmv, 0);
+        if (DEBUG_BLOCK_INFO)
+            printf("Post-dmv[%d/%d,ref=%d/%d|%d/%d]: r=%d\n",
+                   b->mv[0].y, b->mv[0].x, ref.y, ref.x,
+                   mvlist[0][0].y, mvlist[0][0].x, ts->msac.rng);
+        read_vartx_tree(t, b, bs, bx4, by4);
+
+        // reconstruction
+        if (f->frame_thread.pass == 1) {
+            f->bd_fn.read_coef_blocks(t, bs, b);
+        } else {
+            f->bd_fn.recon_b_inter(t, bs, b);
+        }
+
+        splat_intrabc_mv(f->mvs, f->b4_stride, t->by, t->bx, bs, b->mv[0]);
+
+        memset(&t->a->tx_intra[bx4], b_dim[2], bw4);
+        memset(&t->l.tx_intra[by4], b_dim[3], bh4);
+        memset(&t->l.mode[by4], DC_PRED, bh4);
+        memset(&t->a->mode[bx4], DC_PRED, bw4);
+        memset(&t->l.pal_sz[by4], 0, bh4);
+        memset(&t->a->pal_sz[bx4], 0, bw4);
+        if (has_chroma) {
+            memset(&t->l.uvmode[cby4], DC_PRED, cbh4);
+            memset(&t->a->uvmode[cbx4], DC_PRED, cbw4);
+            memset(&t->pal_sz_uv[1][cby4], 0, cbh4);
+            memset(&t->pal_sz_uv[0][cbx4], 0, cbw4);
+        }
+    } else {
+        // inter-specific mode/mv coding
+        int is_comp, has_subpel_filter;
+
+        if (b->skip_mode) {
+            is_comp = 1;
+        } else if (f->frame_hdr.switchable_comp_refs && imin(bw4, bh4) > 1) {
+            const int ctx = get_comp_ctx(t->a, &t->l, by4, bx4,
+                                         have_top, have_left);
+            is_comp = msac_decode_bool_adapt(&ts->msac, ts->cdf.m.comp[ctx]);
+            if (DEBUG_BLOCK_INFO)
+                printf("Post-compflag[%d]: r=%d\n", is_comp, ts->msac.rng);
+        } else {
+            is_comp = 0;
+        }
+
+        if (b->skip_mode) {
+            b->ref[0] = f->frame_hdr.skip_mode_refs[0];
+            b->ref[1] = f->frame_hdr.skip_mode_refs[1];
+            b->comp_type = COMP_INTER_AVG;
+            b->inter_mode = NEARESTMV_NEARESTMV;
+            b->drl_idx = 0;
+            has_subpel_filter = 0;
+
+            candidate_mv mvstack[8];
+            int n_mvs, ctx;
+            mv mvlist[2][2];
+            av1_find_ref_mvs(mvstack, &n_mvs, mvlist, &ctx,
+                             (int[2]) { b->ref[0], b->ref[1] }, f->bw, f->bh,
+                             bs, bp, t->by, t->bx, ts->tiling.col_start,
+                             ts->tiling.col_end, ts->tiling.row_start,
+                             ts->tiling.row_end, f->libaom_cm);
+
+            b->mv[0] = mvstack[0].this_mv;
+            b->mv[1] = mvstack[0].comp_mv;
+            if (!f->frame_hdr.hp) {
+                unset_hp_bit(&b->mv[0]);
+                unset_hp_bit(&b->mv[1]);
+            }
+            if (DEBUG_BLOCK_INFO)
+                printf("Post-skipmodeblock[mv=1:y=%d,x=%d,2:y=%d,x=%d,refs=%d+%d\n",
+                       b->mv[0].y, b->mv[0].x, b->mv[1].y, b->mv[1].x,
+                       b->ref[0], b->ref[1]);
+        } else if (is_comp) {
+            const int dir_ctx = get_comp_dir_ctx(t->a, &t->l, by4, bx4,
+                                                 have_top, have_left);
+            if (msac_decode_bool_adapt(&ts->msac, ts->cdf.m.comp_dir[dir_ctx])) {
+                // bidir - first reference (fw)
+                const int ctx1 = av1_get_fwd_ref_ctx(t->a, &t->l, by4, bx4,
+                                                     have_top, have_left);
+                if (msac_decode_bool_adapt(&ts->msac,
+                                           ts->cdf.m.comp_fwd_ref[0][ctx1]))
+                {
+                    const int ctx2 = av1_get_fwd_ref_2_ctx(t->a, &t->l, by4, bx4,
+                                                           have_top, have_left);
+                    b->ref[0] = 2 + msac_decode_bool_adapt(&ts->msac,
+                                            ts->cdf.m.comp_fwd_ref[2][ctx2]);
+                } else {
+                    const int ctx2 = av1_get_fwd_ref_1_ctx(t->a, &t->l, by4, bx4,
+                                                           have_top, have_left);
+                    b->ref[0] = msac_decode_bool_adapt(&ts->msac,
+                                            ts->cdf.m.comp_fwd_ref[1][ctx2]);
+                }
+
+                // second reference (bw)
+                const int ctx3 = av1_get_bwd_ref_ctx(t->a, &t->l, by4, bx4,
+                                                     have_top, have_left);
+                if (msac_decode_bool_adapt(&ts->msac,
+                                           ts->cdf.m.comp_bwd_ref[0][ctx3]))
+                {
+                    b->ref[1] = 6;
+                } else {
+                    const int ctx4 = av1_get_bwd_ref_1_ctx(t->a, &t->l, by4, bx4,
+                                                           have_top, have_left);
+                    b->ref[1] = 4 + msac_decode_bool_adapt(&ts->msac,
+                                           ts->cdf.m.comp_bwd_ref[1][ctx4]);
+                }
+            } else {
+                // unidir
+                const int uctx_p = av1_get_uni_p_ctx(t->a, &t->l, by4, bx4,
+                                                     have_top, have_left);
+                if (msac_decode_bool_adapt(&ts->msac,
+                                           ts->cdf.m.comp_uni_ref[0][uctx_p]))
+                {
+                    b->ref[0] = 4;
+                    b->ref[1] = 6;
+                } else {
+                    const int uctx_p1 = av1_get_uni_p1_ctx(t->a, &t->l, by4, bx4,
+                                                           have_top, have_left);
+                    b->ref[0] = 0;
+                    b->ref[1] = 1 + msac_decode_bool_adapt(&ts->msac,
+                                           ts->cdf.m.comp_uni_ref[1][uctx_p1]);
+                    if (b->ref[1] == 2) {
+                        const int uctx_p2 = av1_get_uni_p2_ctx(t->a, &t->l, by4, bx4,
+                                                               have_top, have_left);
+                        b->ref[1] += msac_decode_bool_adapt(&ts->msac,
+                                           ts->cdf.m.comp_uni_ref[2][uctx_p2]);
+                    }
+                }
+            }
+            if (DEBUG_BLOCK_INFO)
+                printf("Post-refs[%d/%d]: r=%d\n",
+                       b->ref[0], b->ref[1], ts->msac.rng);
+
+            candidate_mv mvstack[8];
+            int n_mvs, ctx;
+            mv mvlist[2][2];
+            av1_find_ref_mvs(mvstack, &n_mvs, mvlist, &ctx,
+                             (int[2]) { b->ref[0], b->ref[1] }, f->bw, f->bh,
+                             bs, bp, t->by, t->bx, ts->tiling.col_start,
+                             ts->tiling.col_end, ts->tiling.row_start,
+                             ts->tiling.row_end, f->libaom_cm);
+
+            b->inter_mode = msac_decode_symbol_adapt(&ts->msac,
+                                             ts->cdf.m.comp_inter_mode[ctx],
+                                             N_COMP_INTER_PRED_MODES);
+            if (DEBUG_BLOCK_INFO)
+                printf("Post-compintermode[%d,ctx=%d,n_mvs=%d]: r=%d\n",
+                       b->inter_mode, ctx, n_mvs, ts->msac.rng);
+
+            const uint8_t *const im = av1_comp_inter_pred_modes[b->inter_mode];
+            b->drl_idx = 0;
+            if (b->inter_mode == NEWMV_NEWMV) {
+                if (n_mvs > 1) {
+                    const int drl_ctx_v1 = get_drl_context(mvstack, 0);
+                    b->drl_idx += msac_decode_bool_adapt(&ts->msac,
+                                             ts->cdf.m.drl_bit[drl_ctx_v1]);
+                    if (b->drl_idx == 1 && n_mvs > 2) {
+                        const int drl_ctx_v2 = get_drl_context(mvstack, 1);
+                        b->drl_idx += msac_decode_bool_adapt(&ts->msac,
+                                             ts->cdf.m.drl_bit[drl_ctx_v2]);
+                    }
+                    if (DEBUG_BLOCK_INFO)
+                        printf("Post-drlidx[%d,n_mvs=%d]: r=%d\n",
+                               b->drl_idx, n_mvs, ts->msac.rng);
+                }
+            } else if (im[0] == NEARMV || im[1] == NEARMV) {
+                b->drl_idx = 1;
+                if (n_mvs > 2) {
+                    const int drl_ctx_v2 = get_drl_context(mvstack, 1);
+                    b->drl_idx += msac_decode_bool_adapt(&ts->msac,
+                                             ts->cdf.m.drl_bit[drl_ctx_v2]);
+                    if (b->drl_idx == 2 && n_mvs > 3) {
+                        const int drl_ctx_v3 = get_drl_context(mvstack, 2);
+                        b->drl_idx += msac_decode_bool_adapt(&ts->msac,
+                                             ts->cdf.m.drl_bit[drl_ctx_v3]);
+                    }
+                    if (DEBUG_BLOCK_INFO)
+                        printf("Post-drlidx[%d,n_mvs=%d]: r=%d\n",
+                               b->drl_idx, n_mvs, ts->msac.rng);
+                }
+            }
+
+#define assign_comp_mv(idx, pfx) \
+            switch (im[idx]) { \
+            case NEARMV: \
+            case NEARESTMV: \
+                b->mv[idx] = mvstack[b->drl_idx].pfx##_mv; \
+                if (!f->frame_hdr.hp) unset_hp_bit(&b->mv[idx]); \
+                break; \
+            case GLOBALMV: \
+                has_subpel_filter |= \
+                    f->frame_hdr.gmv[b->ref[idx]].type == WM_TYPE_TRANSLATION; \
+                b->mv[idx] = get_gmv_2d(&f->frame_hdr.gmv[b->ref[idx]], \
+                                        t->bx, t->by, bw4, bh4, &f->frame_hdr); \
+                break; \
+            case NEWMV: \
+                b->mv[idx] = mvstack[b->drl_idx].pfx##_mv; \
+                read_mv_residual(t, &b->mv[idx], &ts->cdf.mv, \
+                                 !f->frame_hdr.force_integer_mv); \
+                break; \
+            }
+            has_subpel_filter = imin(bw4, bh4) == 1 ||
+                                b->inter_mode != GLOBALMV_GLOBALMV;
+            assign_comp_mv(0, this);
+            assign_comp_mv(1, comp);
+#undef assign_comp_mv
+            if (DEBUG_BLOCK_INFO)
+                printf("Post-residual_mv[1:y=%d,x=%d,2:y=%d,x=%d]: r=%d\n",
+                       b->mv[0].y, b->mv[0].x, b->mv[1].y, b->mv[1].x,
+                       ts->msac.rng);
+
+            // jnt_comp vs. seg vs. wedge
+            int is_segwedge = 0;
+            if (f->seq_hdr.masked_compound) {
+                const int mask_ctx = get_mask_comp_ctx(t->a, &t->l, by4, bx4);
+
+                is_segwedge = msac_decode_bool_adapt(&ts->msac,
+                                                 ts->cdf.m.mask_comp[mask_ctx]);
+                if (DEBUG_BLOCK_INFO)
+                    printf("Post-segwedge_vs_jntavg[%d,ctx=%d]: r=%d\n",
+                           is_segwedge, mask_ctx, ts->msac.rng);
+            }
+
+            if (!is_segwedge) {
+                if (f->seq_hdr.jnt_comp) {
+                    const int jnt_ctx =
+                        get_jnt_comp_ctx(f->seq_hdr.order_hint_n_bits,
+                                         f->cur.p.poc, f->refp[b->ref[0]].p.poc,
+                                         f->refp[b->ref[1]].p.poc, t->a, &t->l,
+                                         by4, bx4);
+                    b->comp_type = COMP_INTER_WEIGHTED_AVG +
+                        msac_decode_bool_adapt(&ts->msac,
+                                               ts->cdf.m.jnt_comp[jnt_ctx]);
+                    if (DEBUG_BLOCK_INFO)
+                        printf("Post-jnt_comp[%d,ctx=%d[ac:%d,ar:%d,lc:%d,lr:%d]]: r=%d\n",
+                               b->comp_type == COMP_INTER_AVG,
+                               jnt_ctx, t->a->comp_type[bx4], t->a->ref[0][bx4],
+                               t->l.comp_type[by4], t->l.ref[0][by4],
+                               ts->msac.rng);
+                } else {
+                    b->comp_type = COMP_INTER_AVG;
+                }
+            } else {
+                if (wedge_allowed_mask & (1 << bs)) {
+                    const int ctx = av1_wedge_ctx_lut[bs];
+                    b->comp_type = COMP_INTER_WEDGE -
+                        msac_decode_bool_adapt(&ts->msac,
+                                               ts->cdf.m.wedge_comp[ctx]);
+                    if (b->comp_type == COMP_INTER_WEDGE)
+                        b->wedge_idx = msac_decode_symbol_adapt(&ts->msac,
+                                                ts->cdf.m.wedge_idx[ctx], 16);
+                } else {
+                    b->comp_type = COMP_INTER_SEG;
+                }
+                b->mask_sign = msac_decode_bool(&ts->msac, 128 << 7);
+                if (DEBUG_BLOCK_INFO)
+                    printf("Post-seg/wedge[%d,wedge_idx=%d,sign=%d]: r=%d\n",
+                           b->comp_type == COMP_INTER_WEDGE,
+                           b->wedge_idx, b->mask_sign, ts->msac.rng);
+            }
+        } else {
+            b->comp_type = COMP_INTER_NONE;
+
+            // ref
+            const int ctx1 = av1_get_ref_ctx(t->a, &t->l, by4, bx4,
+                                             have_top, have_left);
+            if (msac_decode_bool_adapt(&ts->msac, ts->cdf.m.ref[0][ctx1])) {
+                const int ctx2 = av1_get_ref_2_ctx(t->a, &t->l, by4, bx4,
+                                                   have_top, have_left);
+                if (msac_decode_bool_adapt(&ts->msac, ts->cdf.m.ref[1][ctx2])) {
+                    b->ref[0] = 6;
+                } else {
+                    const int ctx3 = av1_get_ref_6_ctx(t->a, &t->l, by4, bx4,
+                                                       have_top, have_left);
+                    b->ref[0] = 4 + msac_decode_bool_adapt(&ts->msac,
+                                                       ts->cdf.m.ref[5][ctx3]);
+                }
+            } else {
+                const int ctx2 = av1_get_ref_3_ctx(t->a, &t->l, by4, bx4,
+                                                   have_top, have_left);
+                if (msac_decode_bool_adapt(&ts->msac, ts->cdf.m.ref[2][ctx2])) {
+                    const int ctx3 = av1_get_ref_5_ctx(t->a, &t->l, by4, bx4,
+                                                       have_top, have_left);
+                    b->ref[0] = 2 + msac_decode_bool_adapt(&ts->msac,
+                                                       ts->cdf.m.ref[4][ctx3]);
+                } else {
+                    const int ctx3 = av1_get_ref_4_ctx(t->a, &t->l, by4, bx4,
+                                                       have_top, have_left);
+                    b->ref[0] = msac_decode_bool_adapt(&ts->msac,
+                                                       ts->cdf.m.ref[3][ctx3]);
+                }
+            }
+            b->ref[1] = -1;
+            if (DEBUG_BLOCK_INFO)
+                printf("Post-ref[%d]: r=%d\n", b->ref[0], ts->msac.rng);
+
+            candidate_mv mvstack[8];
+            int n_mvs, ctx;
+            mv mvlist[2][2];
+            av1_find_ref_mvs(mvstack, &n_mvs, mvlist, &ctx,
+                             (int[2]) { b->ref[0], -1 }, f->bw, f->bh, bs, bp,
+                             t->by, t->bx, ts->tiling.col_start,
+                             ts->tiling.col_end, ts->tiling.row_start,
+                             ts->tiling.row_end, f->libaom_cm);
+
+            // mode parsing and mv derivation from ref_mvs
+            if (msac_decode_bool_adapt(&ts->msac, ts->cdf.m.newmv_mode[ctx & 7])) {
+                if (!msac_decode_bool_adapt(&ts->msac,
+                                        ts->cdf.m.globalmv_mode[(ctx >> 3) & 1]))
+                {
+                    b->inter_mode = GLOBALMV;
+                    b->mv[0] = get_gmv_2d(&f->frame_hdr.gmv[b->ref[0]],
+                                          t->bx, t->by, bw4, bh4, &f->frame_hdr);
+                    has_subpel_filter = imin(bw4, bh4) == 1 ||
+                        f->frame_hdr.gmv[b->ref[0]].type == WM_TYPE_TRANSLATION;
+                } else {
+                    has_subpel_filter = 1;
+                    if (msac_decode_bool_adapt(&ts->msac,
+                                       ts->cdf.m.refmv_mode[(ctx >> 4) & 15]))
+                    {
+                        b->inter_mode = NEARMV;
+                        b->drl_idx = 1;
+                        if (n_mvs > 2) {
+                            const int drl_ctx_v2 = get_drl_context(mvstack, 1);
+                            b->drl_idx += msac_decode_bool_adapt(&ts->msac,
+                                                 ts->cdf.m.drl_bit[drl_ctx_v2]);
+                            if (b->drl_idx == 2 && n_mvs > 3) {
+                                const int drl_ctx_v3 =
+                                    get_drl_context(mvstack, 2);
+                                b->drl_idx += msac_decode_bool_adapt(&ts->msac,
+                                                 ts->cdf.m.drl_bit[drl_ctx_v3]);
+                            }
+                        }
+                    } else {
+                        b->inter_mode = NEARESTMV;
+                        b->drl_idx = 0;
+                    }
+                    if (b->drl_idx >= 2) {
+                        b->mv[0] = mvstack[b->drl_idx].this_mv;
+                    } else {
+                        b->mv[0] = mvlist[0][b->drl_idx];
+                        if (!f->frame_hdr.hp) unset_hp_bit(&b->mv[0]);
+                    }
+                }
+
+                if (DEBUG_BLOCK_INFO)
+                    printf("Post-intermode[%d,drl=%d,mv=y:%d,x:%d,n_mvs=%d]: r=%d\n",
+                           b->inter_mode, b->drl_idx, b->mv[0].y, b->mv[0].x, n_mvs,
+                           ts->msac.rng);
+            } else {
+                has_subpel_filter = 1;
+                b->inter_mode = NEWMV;
+                b->drl_idx = 0;
+                if (n_mvs > 1) {
+                    const int drl_ctx_v1 = get_drl_context(mvstack, 0);
+                    b->drl_idx += msac_decode_bool_adapt(&ts->msac,
+                                                 ts->cdf.m.drl_bit[drl_ctx_v1]);
+                    if (b->drl_idx == 1 && n_mvs > 2) {
+                        const int drl_ctx_v2 = get_drl_context(mvstack, 1);
+                        b->drl_idx += msac_decode_bool_adapt(&ts->msac,
+                                                 ts->cdf.m.drl_bit[drl_ctx_v2]);
+                    }
+                }
+                if (n_mvs > 1) {
+                    b->mv[0] = mvstack[b->drl_idx].this_mv;
+                } else {
+                    b->mv[0] = mvlist[0][0];
+                    if (!f->frame_hdr.hp) unset_hp_bit(&b->mv[0]);
+                }
+                if (DEBUG_BLOCK_INFO)
+                    printf("Post-intermode[%d,drl=%d]: r=%d\n",
+                           b->inter_mode, b->drl_idx, ts->msac.rng);
+                read_mv_residual(t, &b->mv[0], &ts->cdf.mv,
+                                 !f->frame_hdr.force_integer_mv);
+                if (DEBUG_BLOCK_INFO)
+                    printf("Post-residualmv[mv=y:%d,x:%d]: r=%d\n",
+                           b->mv[0].y, b->mv[0].x, ts->msac.rng);
+            }
+
+            // interintra flags
+            const int ii_sz_grp = av1_ymode_size_context[bs];
+            if (f->seq_hdr.inter_intra &&
+                interintra_allowed_mask & (1 << bs) &&
+                msac_decode_bool_adapt(&ts->msac, ts->cdf.m.interintra[ii_sz_grp]))
+            {
+                b->interintra_mode = msac_decode_symbol_adapt(&ts->msac,
+                                          ts->cdf.m.interintra_mode[ii_sz_grp],
+                                          N_INTER_INTRA_PRED_MODES);
+                const int wedge_ctx = av1_wedge_ctx_lut[bs];
+                b->interintra_type = INTER_INTRA_BLEND +
+                    msac_decode_bool_adapt(&ts->msac,
+                                           ts->cdf.m.interintra_wedge[wedge_ctx]);
+                if (b->interintra_type == INTER_INTRA_WEDGE)
+                    b->wedge_idx = msac_decode_symbol_adapt(&ts->msac,
+                                            ts->cdf.m.wedge_idx[wedge_ctx], 16);
+            } else {
+                b->interintra_type = INTER_INTRA_NONE;
+            }
+            if (DEBUG_BLOCK_INFO && f->seq_hdr.inter_intra &&
+                interintra_allowed_mask & (1 << bs))
+            {
+                printf("Post-interintra[t=%d,m=%d,w=%d]: r=%d\n",
+                       b->interintra_type, b->interintra_mode,
+                       b->wedge_idx, ts->msac.rng);
+            }
+
+            // motion variation
+            if (f->frame_hdr.switchable_motion_mode &&
+                b->interintra_type == INTER_INTRA_NONE && imin(bw4, bh4) >= 2 &&
+                // is not warped global motion
+                !(!f->frame_hdr.force_integer_mv && b->inter_mode == GLOBALMV &&
+                  f->frame_hdr.gmv[b->ref[0]].type > WM_TYPE_TRANSLATION) &&
+                // has overlappable neighbours
+                ((have_left && findoddzero(&t->l.intra[by4 + 1], h4 >> 1)) ||
+                 (have_top && findoddzero(&t->a->intra[bx4 + 1], w4 >> 1))))
+            {
+                // reaching here means the block allows obmc - check warp by
+                // finding matching-ref blocks in top/left edges
+                uint64_t mask[2] = { 0, 0 };
+                find_matching_ref(t, intra_edge_flags, bw4, bh4, w4, h4,
+                                  have_left, have_top, b->ref[0], mask);
+                const int allow_warp = !f->frame_hdr.force_integer_mv &&
+                    f->frame_hdr.warp_motion && (mask[0] | mask[1]);
+
+                b->motion_mode = allow_warp ?
+                    msac_decode_symbol_adapt(&ts->msac, ts->cdf.m.motion_mode[bs], 3) :
+                    msac_decode_bool_adapt(&ts->msac, ts->cdf.m.obmc[bs]);
+                if (b->motion_mode == MM_WARP) {
+                    has_subpel_filter = 0;
+                    derive_warpmv(t, bw4, bh4, mask, b->mv[0], &t->warpmv);
+#define signabs(v) v < 0 ? '-' : ' ', abs(v)
+                    if (DEBUG_BLOCK_INFO)
+                        printf("[ %c%x %c%x %c%x\n  %c%x %c%x %c%x ]\n"
+                               "alpha=%c%x, beta=%c%x, gamma=%c%x, delta=%c%x\n",
+                               signabs(t->warpmv.matrix[0]),
+                               signabs(t->warpmv.matrix[1]),
+                               signabs(t->warpmv.matrix[2]),
+                               signabs(t->warpmv.matrix[3]),
+                               signabs(t->warpmv.matrix[4]),
+                               signabs(t->warpmv.matrix[5]),
+                               signabs(t->warpmv.alpha),
+                               signabs(t->warpmv.beta),
+                               signabs(t->warpmv.gamma),
+                               signabs(t->warpmv.delta));
+#undef signabs
+                }
+
+                if (DEBUG_BLOCK_INFO)
+                    printf("Post-motionmode[%d]: r=%d [mask: 0x%" PRIu64 "x/0x%"
+                           PRIu64 "x]\n", b->motion_mode, ts->msac.rng, mask[0],
+                            mask[1]);
+            } else {
+                b->motion_mode = MM_TRANSLATION;
+            }
+        }
+
+        // subpel filter
+        enum FilterMode filter[2];
+        if (f->frame_hdr.subpel_filter_mode == FILTER_SWITCHABLE) {
+            if (has_subpel_filter) {
+                const int comp = b->comp_type != COMP_INTER_NONE;
+                const int ctx1 = get_filter_ctx(t->a, &t->l, comp, 0, b->ref[0],
+                                                by4, bx4);
+                filter[0] = msac_decode_symbol_adapt(&ts->msac,
+                    ts->cdf.m.filter[0][ctx1], N_SWITCHABLE_FILTERS);
+                if (f->seq_hdr.dual_filter) {
+                    const int ctx2 = get_filter_ctx(t->a, &t->l, comp, 1,
+                                                    b->ref[0], by4, bx4);
+                    if (DEBUG_BLOCK_INFO)
+                        printf("Post-subpel_filter1[%d,ctx=%d]: r=%d\n",
+                               filter[0], ctx1, ts->msac.rng);
+                    filter[1] = msac_decode_symbol_adapt(&ts->msac,
+                        ts->cdf.m.filter[1][ctx2], N_SWITCHABLE_FILTERS);
+                    if (DEBUG_BLOCK_INFO)
+                        printf("Post-subpel_filter2[%d,ctx=%d]: r=%d\n",
+                               filter[1], ctx2, ts->msac.rng);
+                } else {
+                    filter[1] = filter[0];
+                    if (DEBUG_BLOCK_INFO)
+                        printf("Post-subpel_filter[%d,ctx=%d]: r=%d\n",
+                               filter[0], ctx1, ts->msac.rng);
+                }
+            } else {
+                filter[0] = filter[1] = FILTER_8TAP_REGULAR;
+            }
+        } else {
+            filter[0] = filter[1] = f->frame_hdr.subpel_filter_mode;
+        }
+        b->filter2d = av1_filter_2d[filter[1]][filter[0]];
+
+        read_vartx_tree(t, b, bs, bx4, by4);
+
+        // reconstruction
+        if (f->frame_thread.pass == 1) {
+            f->bd_fn.read_coef_blocks(t, bs, b);
+        } else {
+            f->bd_fn.recon_b_inter(t, bs, b);
+        }
+
+        const int is_globalmv =
+            b->inter_mode == (is_comp ? GLOBALMV_GLOBALMV : GLOBALMV);
+        const uint8_t (*const lf_lvls)[8][2] = (const uint8_t (*)[8][2])
+            &ts->lflvl[b->seg_id][0][b->ref[0] + 1][!is_globalmv];
+        dav1d_create_lf_mask_inter(t->lf_mask, f->lf.level, f->b4_stride,
+                                   &f->frame_hdr, lf_lvls, t->bx, t->by,
+                                   f->bw, f->bh, b->skip, bs, b->tx_split,
+                                   b->uvtx, f->cur.p.p.layout,
+                                   &t->a->tx_lpf_y[bx4], &t->l.tx_lpf_y[by4],
+                                   has_chroma ? &t->a->tx_lpf_uv[cbx4] : NULL,
+                                   has_chroma ? &t->l.tx_lpf_uv[cby4] : NULL);
+
+        // context updates
+        if (is_comp) {
+            splat_tworef_mv(f->mvs, f->b4_stride, t->by, t->bx, bs,
+                            b->inter_mode, b->ref[0], b->ref[1],
+                            b->mv[0], b->mv[1]);
+        } else {
+            splat_oneref_mv(f->mvs, f->b4_stride, t->by, t->bx, bs,
+                            b->inter_mode, b->ref[0], b->mv[0],
+                            b->interintra_type);
+        }
+        memset(&t->l.pal_sz[by4], 0, bh4);
+        memset(&t->a->pal_sz[bx4], 0, bw4);
+        if (has_chroma) {
+            memset(&t->l.uvmode[cby4], DC_PRED, cbh4);
+            memset(&t->a->uvmode[cbx4], DC_PRED, cbw4);
+            memset(&t->pal_sz_uv[1][cby4], 0, cbh4);
+            memset(&t->pal_sz_uv[0][cbx4], 0, cbw4);
+        }
+        memset(&t->a->tx_intra[bx4], b_dim[2], bw4);
+        memset(&t->l.tx_intra[by4], b_dim[3], bh4);
+        memset(&t->l.comp_type[by4], b->comp_type, bh4);
+        memset(&t->a->comp_type[bx4], b->comp_type, bw4);
+        memset(&t->l.filter[0][by4], filter[0], bh4);
+        memset(&t->a->filter[0][bx4], filter[0], bw4);
+        memset(&t->l.filter[1][by4], filter[1], bh4);
+        memset(&t->a->filter[1][bx4], filter[1], bw4);
+        memset(&t->l.mode[by4], b->inter_mode, bh4);
+        memset(&t->a->mode[bx4], b->inter_mode, bw4);
+        memset(&t->l.ref[0][by4], b->ref[0], bh4);
+        memset(&t->a->ref[0][bx4], b->ref[0], bw4);
+        memset(&t->l.ref[1][by4], b->ref[1], bh4);
+        memset(&t->a->ref[1][bx4], b->ref[1], bw4);
+    }
+
+    // update contexts
+    if (f->frame_hdr.segmentation.enabled &&
+        f->frame_hdr.segmentation.update_map)
+    {
+        uint8_t *seg_ptr = &f->cur_segmap[t->by * f->b4_stride + t->bx];
+        for (int y = 0; y < bh4; y++) {
+            memset(seg_ptr, b->seg_id, bw4);
+            seg_ptr += f->b4_stride;
+        }
+    }
+    memset(&t->l.seg_pred[by4], seg_pred, bh4);
+    memset(&t->a->seg_pred[bx4], seg_pred, bw4);
+    memset(&t->l.skip_mode[by4], b->skip_mode, bh4);
+    memset(&t->a->skip_mode[bx4], b->skip_mode, bw4);
+    memset(&t->l.intra[by4], b->intra, bh4);
+    memset(&t->a->intra[bx4], b->intra, bw4);
+    memset(&t->l.skip[by4], b->skip, bh4);
+    memset(&t->a->skip[bx4], b->skip, bw4);
+    if (!b->skip) {
+        uint32_t *noskip_mask = &t->lf_mask->noskip_mask[by4];
+        const unsigned mask = ((1ULL << bw4) - 1) << bx4;
+        for (int y = 0; y < bh4; y++)
+            *noskip_mask++ |= mask;
+    }
+}
+
+static int decode_sb(Dav1dTileContext *const t, const enum BlockLevel bl,
+                     const EdgeNode *const node)
+{
+    const Dav1dFrameContext *const f = t->f;
+    const int hsz = 16 >> bl;
+    const int have_h_split = f->bw > t->bx + hsz;
+    const int have_v_split = f->bh > t->by + hsz;
+
+    if (!have_h_split && !have_v_split) {
+        assert(bl < BL_8X8);
+        return decode_sb(t, bl + 1, ((const EdgeBranch *) node)->split[0]);
+    }
+
+    uint16_t *pc;
+    enum BlockPartition bp;
+    int ctx, bx8, by8;
+    if (f->frame_thread.pass != 2) {
+        if (0 && bl == BL_64X64)
+            printf("poc=%d,y=%d,x=%d,bl=%d,r=%d\n",
+                   f->frame_hdr.frame_offset, t->by, t->bx, bl, t->ts->msac.rng);
+        bx8 = (t->bx & 31) >> 1;
+        by8 = (t->by & 31) >> 1;
+        ctx = get_partition_ctx(t->a, &t->l, bl, by8, bx8);
+        pc = t->ts->cdf.m.partition[bl][ctx];
+    }
+
+    if (have_h_split && have_v_split) {
+        if (f->frame_thread.pass == 2) {
+            const Av1Block *const b = &f->frame_thread.b[t->by * f->b4_stride + t->bx];
+            bp = b->bl == bl ? b->bp : PARTITION_SPLIT;
+        } else {
+            const unsigned n_part = bl == BL_8X8 ? N_SUB8X8_PARTITIONS :
+                bl == BL_128X128 ? N_PARTITIONS - 2 : N_PARTITIONS;
+            bp = msac_decode_symbol_adapt(&t->ts->msac, pc, n_part);
+            if (f->cur.p.p.layout == DAV1D_PIXEL_LAYOUT_I422 &&
+                (bp == PARTITION_V || bp == PARTITION_V4 ||
+                 bp == PARTITION_T_LEFT_SPLIT || bp == PARTITION_T_RIGHT_SPLIT))
+            {
+                return 1;
+            }
+            if (DEBUG_BLOCK_INFO)
+                printf("poc=%d,y=%d,x=%d,bl=%d,ctx=%d,bp=%d: r=%d\n",
+                       f->frame_hdr.frame_offset, t->by, t->bx, bl, ctx, bp,
+                       t->ts->msac.rng);
+        }
+        const uint8_t *const b = av1_block_sizes[bl][bp];
+
+        switch (bp) {
+        case PARTITION_NONE:
+            decode_b(t, bl, b[0], PARTITION_NONE, node->o);
+            break;
+        case PARTITION_H:
+            decode_b(t, bl, b[0], PARTITION_H, node->h[0]);
+            t->by += hsz;
+            decode_b(t, bl, b[0], PARTITION_H, node->h[1]);
+            t->by -= hsz;
+            break;
+        case PARTITION_V:
+            decode_b(t, bl, b[0], PARTITION_V, node->v[0]);
+            t->bx += hsz;
+            decode_b(t, bl, b[0], PARTITION_V, node->v[1]);
+            t->bx -= hsz;
+            break;
+        case PARTITION_SPLIT:
+            if (bl == BL_8X8) {
+                const EdgeTip *const tip = (const EdgeTip *) node;
+                assert(hsz == 1);
+                decode_b(t, bl, BS_4x4, PARTITION_SPLIT, tip->split[0]);
+                const enum Filter2d tl_filter = t->tl_4x4_filter;
+                t->bx++;
+                decode_b(t, bl, BS_4x4, PARTITION_SPLIT, tip->split[1]);
+                t->bx--;
+                t->by++;
+                decode_b(t, bl, BS_4x4, PARTITION_SPLIT, tip->split[2]);
+                t->bx++;
+                t->tl_4x4_filter = tl_filter;
+                decode_b(t, bl, BS_4x4, PARTITION_SPLIT, tip->split[3]);
+                t->bx--;
+                t->by--;
+            } else {
+                const EdgeBranch *const branch = (const EdgeBranch *) node;
+                if (decode_sb(t, bl + 1, branch->split[0])) return 1;
+                t->bx += hsz;
+                if (decode_sb(t, bl + 1, branch->split[1])) return 1;
+                t->bx -= hsz;
+                t->by += hsz;
+                if (decode_sb(t, bl + 1, branch->split[2])) return 1;
+                t->bx += hsz;
+                if (decode_sb(t, bl + 1, branch->split[3])) return 1;
+                t->bx -= hsz;
+                t->by -= hsz;
+            }
+            break;
+        case PARTITION_T_TOP_SPLIT: {
+            const EdgeBranch *const branch = (const EdgeBranch *) node;
+            decode_b(t, bl, b[0], PARTITION_T_TOP_SPLIT, branch->tts[0]);
+            t->bx += hsz;
+            decode_b(t, bl, b[0], PARTITION_T_TOP_SPLIT, branch->tts[1]);
+            t->bx -= hsz;
+            t->by += hsz;
+            decode_b(t, bl, b[1], PARTITION_T_TOP_SPLIT, branch->tts[2]);
+            t->by -= hsz;
+            break;
+        }
+        case PARTITION_T_BOTTOM_SPLIT: {
+            const EdgeBranch *const branch = (const EdgeBranch *) node;
+            decode_b(t, bl, b[0], PARTITION_T_BOTTOM_SPLIT, branch->tbs[0]);
+            t->by += hsz;
+            decode_b(t, bl, b[1], PARTITION_T_BOTTOM_SPLIT, branch->tbs[1]);
+            t->bx += hsz;
+            decode_b(t, bl, b[1], PARTITION_T_BOTTOM_SPLIT, branch->tbs[2]);
+            t->bx -= hsz;
+            t->by -= hsz;
+            break;
+        }
+        case PARTITION_T_LEFT_SPLIT: {
+            const EdgeBranch *const branch = (const EdgeBranch *) node;
+            decode_b(t, bl, b[0], PARTITION_T_LEFT_SPLIT, branch->tls[0]);
+            t->by += hsz;
+            decode_b(t, bl, b[0], PARTITION_T_LEFT_SPLIT, branch->tls[1]);
+            t->by -= hsz;
+            t->bx += hsz;
+            decode_b(t, bl, b[1], PARTITION_T_LEFT_SPLIT, branch->tls[2]);
+            t->bx -= hsz;
+            break;
+        }
+        case PARTITION_T_RIGHT_SPLIT: {
+            const EdgeBranch *const branch = (const EdgeBranch *) node;
+            decode_b(t, bl, b[0], PARTITION_T_RIGHT_SPLIT, branch->trs[0]);
+            t->bx += hsz;
+            decode_b(t, bl, b[1], PARTITION_T_RIGHT_SPLIT, branch->trs[1]);
+            t->by += hsz;
+            decode_b(t, bl, b[1], PARTITION_T_RIGHT_SPLIT, branch->trs[2]);
+            t->by -= hsz;
+            t->bx -= hsz;
+            break;
+        }
+        case PARTITION_H4: {
+            const EdgeBranch *const branch = (const EdgeBranch *) node;
+            decode_b(t, bl, b[0], PARTITION_H4, branch->h4[0]);
+            t->by += hsz >> 1;
+            decode_b(t, bl, b[0], PARTITION_H4, branch->h4[1]);
+            t->by += hsz >> 1;
+            decode_b(t, bl, b[0], PARTITION_H4, branch->h4[2]);
+            t->by += hsz >> 1;
+            if (t->by < f->bh)
+                decode_b(t, bl, b[0], PARTITION_H4, branch->h4[3]);
+            t->by -= hsz * 3 >> 1;
+            break;
+        }
+        case PARTITION_V4: {
+            const EdgeBranch *const branch = (const EdgeBranch *) node;
+            decode_b(t, bl, b[0], PARTITION_V4, branch->v4[0]);
+            t->bx += hsz >> 1;
+            decode_b(t, bl, b[0], PARTITION_V4, branch->v4[1]);
+            t->bx += hsz >> 1;
+            decode_b(t, bl, b[0], PARTITION_V4, branch->v4[2]);
+            t->bx += hsz >> 1;
+            if (t->bx < f->bw)
+                decode_b(t, bl, b[0], PARTITION_V4, branch->v4[3]);
+            t->bx -= hsz * 3 >> 1;
+            break;
+        }
+        default: assert(0);
+        }
+    } else if (have_h_split) {
+        unsigned is_split;
+        if (f->frame_thread.pass == 2) {
+            const Av1Block *const b = &f->frame_thread.b[t->by * f->b4_stride + t->bx];
+            is_split = b->bl != bl;
+        } else {
+            const unsigned p = gather_top_partition_prob(pc, bl);
+            is_split = msac_decode_bool(&t->ts->msac, p);
+            if (DEBUG_BLOCK_INFO)
+                printf("poc=%d,y=%d,x=%d,bl=%d,ctx=%d,bp=%d: r=%d\n",
+                       f->frame_hdr.frame_offset, t->by, t->bx, bl, ctx,
+                       is_split ? PARTITION_SPLIT : PARTITION_H, t->ts->msac.rng);
+        }
+
+        assert(bl < BL_8X8);
+        if (is_split) {
+            const EdgeBranch *const branch = (const EdgeBranch *) node;
+            bp = PARTITION_SPLIT;
+            if (decode_sb(t, bl + 1, branch->split[0])) return 1;
+            t->bx += hsz;
+            if (decode_sb(t, bl + 1, branch->split[1])) return 1;
+            t->bx -= hsz;
+        } else {
+            bp = PARTITION_H;
+            decode_b(t, bl, av1_block_sizes[bl][PARTITION_H][0], PARTITION_H,
+                     node->h[0]);
+        }
+    } else {
+        assert(have_v_split);
+        unsigned is_split;
+        if (f->frame_thread.pass == 2) {
+            const Av1Block *const b = &f->frame_thread.b[t->by * f->b4_stride + t->bx];
+            is_split = b->bl != bl;
+        } else {
+            const unsigned p = gather_left_partition_prob(pc, bl);
+            is_split = msac_decode_bool(&t->ts->msac, p);
+            if (f->cur.p.p.layout == DAV1D_PIXEL_LAYOUT_I422 && !is_split)
+                return 1;
+            if (DEBUG_BLOCK_INFO)
+                printf("poc=%d,y=%d,x=%d,bl=%d,ctx=%d,bp=%d: r=%d\n",
+                       f->frame_hdr.frame_offset, t->by, t->bx, bl, ctx,
+                       is_split ? PARTITION_SPLIT : PARTITION_V, t->ts->msac.rng);
+        }
+
+        assert(bl < BL_8X8);
+        if (is_split) {
+            const EdgeBranch *const branch = (const EdgeBranch *) node;
+            bp = PARTITION_SPLIT;
+            if (decode_sb(t, bl + 1, branch->split[0])) return 1;
+            t->by += hsz;
+            if (decode_sb(t, bl + 1, branch->split[2])) return 1;
+            t->by -= hsz;
+        } else {
+            bp = PARTITION_V;
+            decode_b(t, bl, av1_block_sizes[bl][PARTITION_V][0], PARTITION_V,
+                     node->v[0]);
+        }
+    }
+
+    if (f->frame_thread.pass != 2 && (bp != PARTITION_SPLIT || bl == BL_8X8)) {
+        memset(&t->a->partition[bx8], av1_al_part_ctx[0][bl][bp], hsz);
+        memset(&t->l.partition[by8], av1_al_part_ctx[1][bl][bp], hsz);
+    }
+
+    return 0;
+}
+
+static void reset_context(BlockContext *const ctx, const int keyframe, const int pass) {
+    memset(ctx->intra, keyframe, sizeof(ctx->intra));
+    memset(ctx->uvmode, DC_PRED, sizeof(ctx->uvmode));
+    if (keyframe)
+        memset(ctx->mode, DC_PRED, sizeof(ctx->mode));
+
+    if (pass == 2) return;
+
+    memset(ctx->partition, 0, sizeof(ctx->partition));
+    memset(ctx->skip, 0, sizeof(ctx->skip));
+    memset(ctx->skip_mode, 0, sizeof(ctx->skip_mode));
+    memset(ctx->tx_lpf_y, 2, sizeof(ctx->tx_lpf_y));
+    memset(ctx->tx_lpf_uv, 1, sizeof(ctx->tx_lpf_uv));
+    memset(ctx->tx_intra, -1, sizeof(ctx->tx_intra));
+    memset(ctx->tx, TX_64X64, sizeof(ctx->tx));
+    if (!keyframe) {
+        memset(ctx->ref, -1, sizeof(ctx->ref));
+        memset(ctx->comp_type, 0, sizeof(ctx->comp_type));
+        memset(ctx->mode, NEARESTMV, sizeof(ctx->mode));
+    }
+    memset(ctx->lcoef, 0x40, sizeof(ctx->lcoef));
+    memset(ctx->ccoef, 0x40, sizeof(ctx->ccoef));
+    memset(ctx->filter, N_SWITCHABLE_FILTERS, sizeof(ctx->filter));
+    memset(ctx->seg_pred, 0, sizeof(ctx->seg_pred));
+    memset(ctx->pal_sz, 0, sizeof(ctx->pal_sz));
+}
+
+static void setup_tile(Dav1dTileState *const ts,
+                       const Dav1dFrameContext *const f,
+                       const uint8_t *const data, const size_t sz,
+                       const int tile_row, const int tile_col,
+                       const int tile_start_off)
+{
+    const int col_sb_start = f->frame_hdr.tiling.col_start_sb[tile_col];
+    const int col_sb128_start = col_sb_start >> !f->seq_hdr.sb128;
+    const int col_sb_end = f->frame_hdr.tiling.col_start_sb[tile_col + 1];
+    const int row_sb_start = f->frame_hdr.tiling.row_start_sb[tile_row];
+    const int row_sb_end = f->frame_hdr.tiling.row_start_sb[tile_row + 1];
+    const int sb_shift = f->sb_shift;
+
+    ts->frame_thread.pal_idx = &f->frame_thread.pal_idx[tile_start_off * 2];
+    ts->frame_thread.cf = &((int32_t *) f->frame_thread.cf)[tile_start_off * 3];
+    ts->cdf = *f->in_cdf.cdf;
+    ts->last_qidx = f->frame_hdr.quant.yac;
+    memset(ts->last_delta_lf, 0, sizeof(ts->last_delta_lf));
+
+    msac_init(&ts->msac, data, sz);
+
+    ts->tiling.row = tile_row;
+    ts->tiling.col = tile_col;
+    ts->tiling.col_start = col_sb_start << sb_shift;
+    ts->tiling.col_end = imin(col_sb_end << sb_shift, f->bw);
+    ts->tiling.row_start = row_sb_start << sb_shift;
+    ts->tiling.row_end = imin(row_sb_end << sb_shift, f->bh);
+
+    // Reference Restoration Unit (used for exp coding)
+    Av1Filter *const lf_mask =
+        f->lf.mask + (ts->tiling.row_start >> 5) * f->sb128w + col_sb128_start;
+    const int unit_idx = ((ts->tiling.row_start & 16) >> 3) +
+                         ((ts->tiling.col_start & 16) >> 4);
+    for (int p = 0; p < 3; p++) {
+        ts->lr_ref[p] = &lf_mask->lr[p][unit_idx];
+        ts->lr_ref[p]->filter_v[0] = 3;
+        ts->lr_ref[p]->filter_v[1] = -7;
+        ts->lr_ref[p]->filter_v[2] = 15;
+        ts->lr_ref[p]->filter_h[0] = 3;
+        ts->lr_ref[p]->filter_h[1] = -7;
+        ts->lr_ref[p]->filter_h[2] = 15;
+        ts->lr_ref[p]->sgr_weights[0] = -32;
+        ts->lr_ref[p]->sgr_weights[1] = 31;
+    }
+
+    if (f->n_tc > 1)
+        atomic_init(&ts->progress, 0);
+}
+
+int decode_tile_sbrow(Dav1dTileContext *const t) {
+    const Dav1dFrameContext *const f = t->f;
+    const enum BlockLevel root_bl = f->seq_hdr.sb128 ? BL_128X128 : BL_64X64;
+    Dav1dTileState *const ts = t->ts;
+    const Dav1dContext *const c = f->c;
+    const int sb_step = f->sb_step;
+    const int tile_row = ts->tiling.row, tile_col = ts->tiling.col;
+    const int col_sb_start = f->frame_hdr.tiling.col_start_sb[tile_col];
+    const int col_sb128_start = col_sb_start >> !f->seq_hdr.sb128;
+
+    reset_context(&t->l, !(f->frame_hdr.frame_type & 1), f->frame_thread.pass);
+    if (f->frame_thread.pass == 2) {
+        for (t->bx = ts->tiling.col_start,
+             t->a = f->a + col_sb128_start + tile_row * f->sb128w;
+             t->bx < ts->tiling.col_end; t->bx += sb_step)
+        {
+            if (decode_sb(t, root_bl, c->intra_edge.root[root_bl]))
+                return 1;
+            if (t->bx & 16 || f->seq_hdr.sb128)
+                t->a++;
+        }
+        f->bd_fn.backup_ipred_edge(t);
+        return 0;
+    }
+
+    const int ss_ver = f->cur.p.p.layout == DAV1D_PIXEL_LAYOUT_I420;
+    const int ss_hor = f->cur.p.p.layout != DAV1D_PIXEL_LAYOUT_I444;
+
+    if (c->n_fc > 1 && f->frame_hdr.use_ref_frame_mvs) {
+        for (int n = 0; n < 7; n++)
+            dav1d_thread_picture_wait(&f->refp[n], 4 * (t->by + sb_step),
+                                      PLANE_TYPE_BLOCK);
+        av1_init_ref_mv_tile_row(f->libaom_cm,
+                                 ts->tiling.col_start, ts->tiling.col_end,
+                                 t->by, imin(t->by + sb_step, f->bh));
+    }
+    memset(t->pal_sz_uv[1], 0, sizeof(*t->pal_sz_uv));
+    const int sb128y = t->by >> 5;
+    for (t->bx = ts->tiling.col_start, t->a = f->a + col_sb128_start + tile_row * f->sb128w,
+         t->lf_mask = f->lf.mask + sb128y * f->sb128w + col_sb128_start;
+         t->bx < ts->tiling.col_end; t->bx += sb_step)
+    {
+        if (root_bl == BL_128X128) {
+            t->cur_sb_cdef_idx_ptr = t->lf_mask->cdef_idx;
+            t->cur_sb_cdef_idx_ptr[0] = -1;
+            t->cur_sb_cdef_idx_ptr[1] = -1;
+            t->cur_sb_cdef_idx_ptr[2] = -1;
+            t->cur_sb_cdef_idx_ptr[3] = -1;
+        } else {
+            t->cur_sb_cdef_idx_ptr =
+                &t->lf_mask->cdef_idx[((t->bx & 16) >> 4) +
+                                      ((t->by & 16) >> 3)];
+            t->cur_sb_cdef_idx_ptr[0] = -1;
+        }
+        // Restoration filter
+        for (int p = 0; p < 3; p++) {
+            if (f->frame_hdr.restoration.type[p] == RESTORATION_NONE)
+                continue;
+            const int by = t->by >> (ss_ver & !!p);
+            const int bx = t->bx >> (ss_hor & !!p);
+            const int bh = f->bh >> (ss_ver & !!p);
+            const int bw = f->bw >> (ss_hor & !!p);
+
+            const int unit_size_log2 =
+                f->frame_hdr.restoration.unit_size[!!p];
+            // 4pel unit size
+            const int b_unit_size = 1 << (unit_size_log2 - 2);
+            const unsigned mask = b_unit_size - 1;
+            if (by & mask || bx & mask) continue;
+            const int half_unit = b_unit_size >> 1;
+            // Round half up at frame boundaries, if there's more than one
+            // restoration unit
+            const int bottom_round = by && by + half_unit > bh;
+            const int right_round = bx && bx + half_unit > bw;
+            if (bottom_round || right_round) continue;
+            const int unit_idx = ((t->by & 16) >> 3) + ((t->bx & 16) >> 4);
+            Av1RestorationUnit *const lr = &t->lf_mask->lr[p][unit_idx];
+            const enum RestorationType frame_type =
+                f->frame_hdr.restoration.type[p];
+
+            if (frame_type == RESTORATION_SWITCHABLE) {
+                const int filter =
+                    msac_decode_symbol_adapt(&ts->msac,
+                                             ts->cdf.m.restore_switchable, 3);
+                lr->type = filter ? filter == 2 ? RESTORATION_SGRPROJ :
+                                                  RESTORATION_WIENER :
+                                    RESTORATION_NONE;
+            } else {
+                const unsigned type =
+                    msac_decode_bool_adapt(&ts->msac,
+                                           frame_type == RESTORATION_WIENER ?
+                                               ts->cdf.m.restore_wiener :
+                                               ts->cdf.m.restore_sgrproj);
+                lr->type = type ? frame_type : RESTORATION_NONE;
+            }
+
+            if (lr->type == RESTORATION_WIENER) {
+                lr->filter_v[0] =
+                    !p ? msac_decode_subexp(&ts->msac,
+                                            ts->lr_ref[p]->filter_v[0] + 5, 16,
+                                            1) - 5:
+                         0;
+                lr->filter_v[1] =
+                    msac_decode_subexp(&ts->msac,
+                                       ts->lr_ref[p]->filter_v[1] + 23, 32,
+                                       2) - 23;
+                lr->filter_v[2] =
+                    msac_decode_subexp(&ts->msac,
+                                       ts->lr_ref[p]->filter_v[2] + 17, 64,
+                                       3) - 17;
+
+                lr->filter_h[0] =
+                    !p ? msac_decode_subexp(&ts->msac,
+                                            ts->lr_ref[p]->filter_h[0] + 5, 16,
+                                            1) - 5:
+                        0;
+                lr->filter_h[1] =
+                    msac_decode_subexp(&ts->msac,
+                                       ts->lr_ref[p]->filter_h[1] + 23, 32,
+                                       2) - 23;
+                lr->filter_h[2] =
+                    msac_decode_subexp(&ts->msac,
+                                       ts->lr_ref[p]->filter_h[2] + 17, 64,
+                                       3) - 17;
+                memcpy(lr->sgr_weights, ts->lr_ref[p]->sgr_weights, sizeof(lr->sgr_weights));
+                ts->lr_ref[p] = lr;
+                if (DEBUG_BLOCK_INFO)
+                    printf("Post-lr_wiener[pl=%d,v[%d,%d,%d],h[%d,%d,%d]]: r=%d\n",
+                           p, lr->filter_v[0], lr->filter_v[1],
+                           lr->filter_v[2], lr->filter_h[0],
+                           lr->filter_h[1], lr->filter_h[2], ts->msac.rng);
+            } else if (lr->type == RESTORATION_SGRPROJ) {
+                const unsigned idx = msac_decode_bools(&ts->msac, 4);
+                lr->sgr_idx = idx;
+                lr->sgr_weights[0] = sgr_params[idx][0] ?
+                    msac_decode_subexp(&ts->msac,
+                                       ts->lr_ref[p]->sgr_weights[0] + 96, 128,
+                                       4) - 96 :
+                    0;
+                lr->sgr_weights[1] = sgr_params[idx][1] ?
+                    msac_decode_subexp(&ts->msac,
+                                       ts->lr_ref[p]->sgr_weights[1] + 32, 128,
+                                       4) - 32 :
+                    iclip(128 - lr->sgr_weights[0], -32, 95);
+                memcpy(lr->filter_v, ts->lr_ref[p]->filter_v, sizeof(lr->filter_v));
+                memcpy(lr->filter_h, ts->lr_ref[p]->filter_h, sizeof(lr->filter_h));
+                ts->lr_ref[p] = lr;
+                if (DEBUG_BLOCK_INFO)
+                    printf("Post-lr_sgrproj[pl=%d,idx=%d,w[%d,%d]]: r=%d\n",
+                           p, lr->sgr_idx, lr->sgr_weights[0],
+                           lr->sgr_weights[1], ts->msac.rng);
+            }
+        }
+        if (decode_sb(t, root_bl, c->intra_edge.root[root_bl]))
+            return 1;
+        if (t->bx & 16 || f->seq_hdr.sb128) {
+            t->a++;
+            t->lf_mask++;
+        }
+    }
+
+    // backup pre-loopfilter pixels for intra prediction of the next sbrow
+    if (f->frame_thread.pass != 1)
+        f->bd_fn.backup_ipred_edge(t);
+
+    // backup t->a/l.tx_lpf_y/uv at tile boundaries to use them to "fix"
+    // up the initial value in neighbour tiles when running the loopfilter
+    int align_h = (f->bh + 31) & ~31;
+    memcpy(&f->lf.tx_lpf_right_edge[0][align_h * tile_col + t->by],
+           &t->l.tx_lpf_y[t->by & 16], sb_step);
+    align_h >>= 1;
+    memcpy(&f->lf.tx_lpf_right_edge[1][align_h * tile_col + (t->by >> 1)],
+           &t->l.tx_lpf_uv[(t->by & 16) >> 1], sb_step >> 1);
+
+    return 0;
+}
+
+int decode_frame(Dav1dFrameContext *const f) {
+    const Dav1dContext *const c = f->c;
+
+    if (f->n_tc > 1) {
+        if (f->frame_hdr.tiling.cols * f->sbh > f->tile_thread.titsati_sz) {
+            f->tile_thread.task_idx_to_sby_and_tile_idx =
+                malloc(sizeof(*f->tile_thread.task_idx_to_sby_and_tile_idx) *
+                       f->frame_hdr.tiling.cols * f->sbh);
+            if (!f->tile_thread.task_idx_to_sby_and_tile_idx) return -ENOMEM;
+            f->tile_thread.titsati_sz = f->frame_hdr.tiling.cols * f->sbh;
+        }
+        if (f->tile_thread.titsati_init[0] != f->frame_hdr.tiling.cols ||
+            f->tile_thread.titsati_init[1] != f->sbh)
+        {
+            for (int tile_row = 0, tile_idx = 0;
+                 tile_row < f->frame_hdr.tiling.rows; tile_row++)
+            {
+                for (int sby = f->frame_hdr.tiling.row_start_sb[tile_row];
+                     sby < f->frame_hdr.tiling.row_start_sb[tile_row + 1]; sby++)
+                {
+                    for (int tile_col = 0; tile_col < f->frame_hdr.tiling.cols;
+                         tile_col++, tile_idx++)
+                    {
+                        f->tile_thread.task_idx_to_sby_and_tile_idx[tile_idx][0] = sby;
+                        f->tile_thread.task_idx_to_sby_and_tile_idx[tile_idx][1] =
+                            tile_row * f->frame_hdr.tiling.cols + tile_col;
+                    }
+                }
+            }
+            f->tile_thread.titsati_init[0] = f->frame_hdr.tiling.cols;
+            f->tile_thread.titsati_init[1] = f->sbh;
+        }
+    }
+
+    if (f->frame_hdr.tiling.cols * f->frame_hdr.tiling.rows > f->n_ts) {
+        f->ts = realloc(f->ts, f->frame_hdr.tiling.cols *
+                               f->frame_hdr.tiling.rows * sizeof(*f->ts));
+        if (!f->ts) return -ENOMEM;
+        for (int n = f->n_ts;
+             n < f->frame_hdr.tiling.cols * f->frame_hdr.tiling.rows; n++)
+        {
+            Dav1dTileState *const ts = &f->ts[n];
+            pthread_mutex_init(&ts->tile_thread.lock, NULL);
+            pthread_cond_init(&ts->tile_thread.cond, NULL);
+        }
+        if (c->n_fc > 1) {
+            freep(&f->frame_thread.tile_start_off);
+            f->frame_thread.tile_start_off =
+                malloc(sizeof(*f->frame_thread.tile_start_off) *
+                       f->frame_hdr.tiling.cols * f->frame_hdr.tiling.rows);
+        }
+        f->n_ts = f->frame_hdr.tiling.cols * f->frame_hdr.tiling.rows;
+    }
+
+    if (c->n_fc > 1) {
+        int tile_idx = 0;
+        for (int tile_row = 0; tile_row < f->frame_hdr.tiling.rows; tile_row++) {
+            int row_off = f->frame_hdr.tiling.row_start_sb[tile_row] *
+                          f->sb_step * 4 * f->sb128w * 128;
+            int b_diff = (f->frame_hdr.tiling.row_start_sb[tile_row + 1] -
+                          f->frame_hdr.tiling.row_start_sb[tile_row]) * f->sb_step * 4;
+            for (int tile_col = 0; tile_col < f->frame_hdr.tiling.cols; tile_col++) {
+                f->frame_thread.tile_start_off[tile_idx++] = row_off + b_diff *
+                    f->frame_hdr.tiling.col_start_sb[tile_col] * f->sb_step * 4;
+            }
+        }
+    }
+
+    if (f->sb128w * f->frame_hdr.tiling.rows > f->a_sz) {
+        freep(&f->a);
+        f->a = malloc(f->sb128w * f->frame_hdr.tiling.rows * sizeof(*f->a));
+        if (!f->a) return -ENOMEM;
+        f->a_sz = f->sb128w * f->frame_hdr.tiling.rows;
+    }
+
+    // update allocation of block contexts for above
+    if (f->sb128w > f->lf.line_sz) {
+        dav1d_freep_aligned(&f->lf.cdef_line);
+        dav1d_freep_aligned(&f->lf.lr_lpf_line);
+
+        // note that we allocate all pixel arrays as if we were dealing with
+        // 10 bits/component data
+        uint16_t *ptr = f->lf.cdef_line =
+            dav1d_alloc_aligned(f->b4_stride * 4 * 12 * sizeof(uint16_t), 32);
+
+        uint16_t *lr_ptr = f->lf.lr_lpf_line =
+            dav1d_alloc_aligned(f->b4_stride * 4 * 3 * 12 * sizeof(uint16_t), 32);
+
+        for (int pl = 0; pl <= 2; pl++) {
+            f->lf.cdef_line_ptr[0][pl][0] = ptr + f->b4_stride * 4 * 0;
+            f->lf.cdef_line_ptr[0][pl][1] = ptr + f->b4_stride * 4 * 1;
+            f->lf.cdef_line_ptr[1][pl][0] = ptr + f->b4_stride * 4 * 2;
+            f->lf.cdef_line_ptr[1][pl][1] = ptr + f->b4_stride * 4 * 3;
+            ptr += f->b4_stride * 4 * 4;
+
+            f->lf.lr_lpf_line_ptr[pl] = lr_ptr;
+            lr_ptr += f->b4_stride * 4 * 12;
+        }
+
+        f->lf.line_sz = f->sb128w;
+    }
+
+    // update allocation for loopfilter masks
+    if (f->sb128w * f->sb128h > f->lf.mask_sz) {
+        freep(&f->lf.mask);
+        freep(&f->lf.level);
+        freep(&f->frame_thread.b);
+        f->lf.mask = malloc(f->sb128w * f->sb128h * sizeof(*f->lf.mask));
+        f->lf.level = malloc(f->sb128w * f->sb128h * 32 * 32 *
+                             sizeof(*f->lf.level));
+        if (!f->lf.mask || !f->lf.level) return -ENOMEM;
+        if (c->n_fc > 1) {
+            freep(&f->frame_thread.b);
+            freep(&f->frame_thread.cbi);
+            dav1d_freep_aligned(&f->frame_thread.cf);
+            dav1d_freep_aligned(&f->frame_thread.pal_idx);
+            freep(&f->frame_thread.pal);
+            f->frame_thread.b = malloc(sizeof(*f->frame_thread.b) *
+                                       f->sb128w * f->sb128h * 32 * 32);
+            f->frame_thread.pal = malloc(sizeof(*f->frame_thread.pal) *
+                                         f->sb128w * f->sb128h * 16 * 16);
+            f->frame_thread.pal_idx =
+                dav1d_alloc_aligned(sizeof(*f->frame_thread.pal_idx) *
+                                    f->sb128w * f->sb128h * 128 * 128 * 2, 32);
+            f->frame_thread.cbi = malloc(sizeof(*f->frame_thread.cbi) *
+                                         f->sb128w * f->sb128h * 32 * 32);
+            f->frame_thread.cf =
+                dav1d_alloc_aligned(sizeof(int32_t) * 3 *
+                                    f->sb128w * f->sb128h * 128 * 128, 32);
+            if (!f->frame_thread.b || !f->frame_thread.pal_idx ||
+                !f->frame_thread.cf)
+            {
+                return -ENOMEM;
+            }
+            memset(f->frame_thread.cf, 0,
+                   sizeof(int32_t) * 3 * f->sb128w * f->sb128h * 128 * 128);
+        }
+        f->lf.mask_sz = f->sb128w * f->sb128h;
+    }
+    if (f->frame_hdr.loopfilter.sharpness != f->lf.last_sharpness) {
+        dav1d_calc_eih(&f->lf.lim_lut, f->frame_hdr.loopfilter.sharpness);
+        f->lf.last_sharpness = f->frame_hdr.loopfilter.sharpness;
+    }
+    dav1d_calc_lf_values(f->lf.lvl, &f->frame_hdr, (int8_t[4]) { 0, 0, 0, 0 });
+    memset(f->lf.mask, 0, sizeof(*f->lf.mask) * f->sb128w * f->sb128h);
+
+    if (f->sbh * f->sb128w * 128 > f->ipred_edge_sz) {
+        dav1d_freep_aligned(&f->ipred_edge[0]);
+        uint16_t *ptr = f->ipred_edge[0] =
+            dav1d_alloc_aligned(f->sb128w * 128 * f->sbh * 3 * sizeof(uint16_t), 32);
+        if (!f->ipred_edge[0]) return -ENOMEM;
+        f->ipred_edge_sz = f->sbh * f->sb128w * 128;
+        f->ipred_edge[1] = &ptr[f->ipred_edge_sz];
+        f->ipred_edge[2] = &ptr[f->ipred_edge_sz * 2];
+    }
+
+    if (f->sb128h > f->lf.re_sz) {
+        freep(&f->lf.tx_lpf_right_edge[0]);
+        f->lf.tx_lpf_right_edge[0] = malloc((f->sb128h * 32 * 2) *
+                                            f->frame_hdr.tiling.cols);
+        if (!f->lf.tx_lpf_right_edge[0]) return -ENOMEM;
+        f->lf.tx_lpf_right_edge[1] = f->lf.tx_lpf_right_edge[0] +
+                                     f->sb128h * 32 * f->frame_hdr.tiling.cols;
+        f->lf.re_sz = f->sb128h;
+    }
+
+    // init ref mvs
+    if ((f->frame_hdr.frame_type & 1) || f->frame_hdr.allow_intrabc) {
+        f->mvs = f->mvs_ref->data;
+        const int order_hint_n_bits = f->seq_hdr.order_hint * f->seq_hdr.order_hint_n_bits;
+        av1_init_ref_mv_common(f->libaom_cm, f->bw >> 1, f->bh >> 1,
+                               f->b4_stride, f->seq_hdr.sb128,
+                               f->mvs, f->ref_mvs, f->cur.p.poc, f->refpoc,
+                               f->refrefpoc, f->frame_hdr.gmv,
+                               f->frame_hdr.hp, f->frame_hdr.force_integer_mv,
+                               f->frame_hdr.use_ref_frame_mvs,
+                               order_hint_n_bits);
+        if (c->n_fc == 1 && f->frame_hdr.use_ref_frame_mvs)
+            av1_init_ref_mv_tile_row(f->libaom_cm, 0, f->bw, 0, f->bh);
+    }
+
+    // setup dequant tables
+    init_quant_tables(&f->seq_hdr, &f->frame_hdr, f->frame_hdr.quant.yac, f->dq);
+    if (f->frame_hdr.quant.qm)
+        for (int j = 0; j < N_RECT_TX_SIZES; j++) {
+            f->qm[0][j][0] = av1_qm_tbl[f->frame_hdr.quant.qm_y][0][j];
+            f->qm[0][j][1] = av1_qm_tbl[f->frame_hdr.quant.qm_u][1][j];
+            f->qm[0][j][2] = av1_qm_tbl[f->frame_hdr.quant.qm_v][1][j];
+        }
+    for (int i = f->frame_hdr.quant.qm; i < 2; i++)
+        for (int tx = 0; tx < N_RECT_TX_SIZES; tx++)
+            for (int pl = 0; pl < 3; pl++)
+                f->qm[i][tx][pl] = av1_qm_tbl[15][!!pl][tx];
+
+    // setup jnt_comp weights
+    if (f->frame_hdr.switchable_comp_refs) {
+        for (int i = 0; i < 7; i++) {
+            const unsigned ref0poc = f->refp[i].p.poc;
+
+            for (int j = i + 1; j < 7; j++) {
+                const unsigned ref1poc = f->refp[j].p.poc;
+
+                const unsigned d1 = imin(abs(get_poc_diff(f->seq_hdr.order_hint_n_bits,
+                                                          ref0poc, f->cur.p.poc)), 31);
+                const unsigned d0 = imin(abs(get_poc_diff(f->seq_hdr.order_hint_n_bits,
+                                                          ref1poc, f->cur.p.poc)), 31);
+                const int order = d0 <= d1;
+
+                static const uint8_t quant_dist_weight[3][2] = {
+                    { 2, 3 }, { 2, 5 }, { 2, 7 }
+                };
+                static const uint8_t quant_dist_lookup_table[4][2] = {
+                    { 9, 7 }, { 11, 5 }, { 12, 4 }, { 13, 3 }
+                };
+
+                int k;
+                for (k = 0; k < 3; k++) {
+                    const int c0 = quant_dist_weight[k][order];
+                    const int c1 = quant_dist_weight[k][!order];
+                    const int d0_c0 = d0 * c0;
+                    const int d1_c1 = d1 * c1;
+                    if ((d0 > d1 && d0_c0 < d1_c1) || (d0 <= d1 && d0_c0 > d1_c1)) break;
+                }
+
+                f->jnt_weights[i][j] = quant_dist_lookup_table[k][order];
+            }
+        }
+    }
+
+    // init loopfilter pointers
+    f->lf.mask_ptr = f->lf.mask;
+    f->lf.p[0] = f->cur.p.data[0];
+    f->lf.p[1] = f->cur.p.data[1];
+    f->lf.p[2] = f->cur.p.data[2];
+    f->lf.tile_row = 1;
+
+    cdf_thread_wait(&f->in_cdf);
+
+    // parse individual tiles per tile group
+    int update_set = 0, tile_idx = 0;
+    const unsigned tile_col_mask = (1 << f->frame_hdr.tiling.log2_cols) - 1;
+    for (int i = 0; i < f->n_tile_data; i++) {
+        const uint8_t *data = f->tile[i].data.data;
+        size_t size = f->tile[i].data.sz;
+
+        const int last_tile_row_plus1 = 1 + (f->tile[i].end >> f->frame_hdr.tiling.log2_cols);
+        const int last_tile_col_plus1 = 1 + (f->tile[i].end & tile_col_mask);
+        const int empty_tile_cols = imax(0, last_tile_col_plus1 - f->frame_hdr.tiling.cols);
+        const int empty_tile_rows = imax(0, last_tile_row_plus1 - f->frame_hdr.tiling.rows);
+        const int empty_tiles =
+            (empty_tile_rows << f->frame_hdr.tiling.log2_cols) + empty_tile_cols;
+        for (int j = f->tile[i].start; j <= f->tile[i].end - empty_tiles; j++) {
+            const int tile_row = j >> f->frame_hdr.tiling.log2_cols;
+            const int tile_col = j & tile_col_mask;
+
+            if (tile_col >= f->frame_hdr.tiling.cols) continue;
+            if (tile_row >= f->frame_hdr.tiling.rows) continue;
+
+            size_t tile_sz;
+            if (j == f->tile[i].end - empty_tiles) {
+                tile_sz = size;
+            } else {
+                tile_sz = 0;
+                for (int k = 0; k < f->frame_hdr.tiling.n_bytes; k++)
+                    tile_sz |= *data++ << (k * 8);
+                tile_sz++;
+                size -= f->frame_hdr.tiling.n_bytes;
+                if (tile_sz > size) goto error;
+            }
+
+            setup_tile(&f->ts[tile_row * f->frame_hdr.tiling.cols + tile_col],
+                       f, data, tile_sz, tile_row, tile_col,
+                       c->n_fc > 1 ? f->frame_thread.tile_start_off[tile_idx++] : 0);
+            if (j == f->frame_hdr.tiling.update && f->frame_hdr.refresh_context)
+                update_set = 1;
+            data += tile_sz;
+            size -= tile_sz;
+        }
+    }
+
+    cdf_thread_unref(&f->in_cdf);
+
+    // 2-pass decoding:
+    // - enabled for frame-threading, so that one frame can do symbol parsing
+    //   as another (or multiple) are doing reconstruction. One advantage here
+    //   is that although reconstruction is limited by reference availability,
+    //   symbol parsing is not. Therefore, symbol parsing can effectively use
+    //   row and col tile threading, but reconstruction only col tile threading;
+    // - pass 0 means no 2-pass;
+    // - pass 1 means symbol parsing only;
+    // - pass 2 means reconstruction and loop filtering.
+
+    const int uses_2pass = c->n_fc > 1 && f->frame_hdr.refresh_context;
+    for (f->frame_thread.pass = uses_2pass;
+         f->frame_thread.pass <= 2 * uses_2pass; f->frame_thread.pass++)
+    {
+        const enum PlaneType progress_plane_type =
+            f->frame_thread.pass == 0 ? PLANE_TYPE_ALL :
+            f->frame_thread.pass == 1 ? PLANE_TYPE_BLOCK : PLANE_TYPE_Y;
+
+        for (int n = 0; n < f->sb128w * f->frame_hdr.tiling.rows; n++)
+            reset_context(&f->a[n], !(f->frame_hdr.frame_type & 1), f->frame_thread.pass);
+
+        if (f->n_tc == 1) {
+            Dav1dTileContext *const t = f->tc;
+
+            // no tile threading - we explicitly interleave tile/sbrow decoding
+            // and post-filtering, so that the full process runs in-line, so
+            // that frame threading is still possible
+            for (int tile_row = 0; tile_row < f->frame_hdr.tiling.rows; tile_row++) {
+                for (int sby = f->frame_hdr.tiling.row_start_sb[tile_row];
+                     sby < f->frame_hdr.tiling.row_start_sb[tile_row + 1]; sby++)
+                {
+                    t->by = sby << (4 + f->seq_hdr.sb128);
+                    for (int tile_col = 0; tile_col < f->frame_hdr.tiling.cols; tile_col++) {
+                        t->ts = &f->ts[tile_row * f->frame_hdr.tiling.rows + tile_col];
+
+                        int res;
+                        if ((res = decode_tile_sbrow(t)))
+                            return res;
+                    }
+
+                    // loopfilter + cdef + restoration
+                    if (f->frame_thread.pass != 1)
+                        f->bd_fn.filter_sbrow(f, sby);
+                    dav1d_thread_picture_signal(&f->cur, (sby + 1) * f->sb_step * 4,
+                                                progress_plane_type);
+                }
+            }
+        } else {
+            // signal available tasks to worker threads
+            int num_tasks;
+
+            const uint64_t all_mask = ~0ULL >> (64 - f->n_tc);
+            pthread_mutex_lock(&f->tile_thread.lock);
+            while (f->tile_thread.available != all_mask)
+                pthread_cond_wait(&f->tile_thread.icond, &f->tile_thread.lock);
+            assert(!f->tile_thread.tasks_left);
+            if (f->frame_thread.pass == 1 || f->n_tc >= f->frame_hdr.tiling.cols) {
+                // we can (or in fact, if >, we need to) do full tile decoding.
+                // loopfilter happens below
+                num_tasks = f->frame_hdr.tiling.cols * f->frame_hdr.tiling.rows;
+            } else {
+                // we need to interleave sbrow decoding for all tile cols in a
+                // tile row, since otherwise subsequent threads will be blocked
+                // waiting for the post-filter to complete
+                num_tasks = f->sbh * f->frame_hdr.tiling.cols;
+            }
+            f->tile_thread.num_tasks = f->tile_thread.tasks_left = num_tasks;
+            pthread_cond_broadcast(&f->tile_thread.cond);
+            pthread_mutex_unlock(&f->tile_thread.lock);
+
+            // loopfilter + cdef + restoration
+            for (int tile_row = 0; tile_row < f->frame_hdr.tiling.rows; tile_row++) {
+                for (int sby = f->frame_hdr.tiling.row_start_sb[tile_row];
+                     sby < f->frame_hdr.tiling.row_start_sb[tile_row + 1]; sby++)
+                {
+                    for (int tile_col = 0; tile_col < f->frame_hdr.tiling.cols;
+                         tile_col++)
+                    {
+                        Dav1dTileState *const ts =
+                            &f->ts[tile_row * f->frame_hdr.tiling.cols + tile_col];
+
+                        if (atomic_load(&ts->progress) <= sby) {
+                            pthread_mutex_lock(&ts->tile_thread.lock);
+                            while (atomic_load(&ts->progress) <= sby)
+                                pthread_cond_wait(&ts->tile_thread.cond,
+                                                  &ts->tile_thread.lock);
+                            pthread_mutex_unlock(&ts->tile_thread.lock);
+                        }
+                    }
+
+                    // loopfilter + cdef + restoration
+                    if (f->frame_thread.pass != 1)
+                        f->bd_fn.filter_sbrow(f, sby);
+                    dav1d_thread_picture_signal(&f->cur, (sby + 1) * f->sb_step * 4,
+                                                progress_plane_type);
+                }
+            }
+        }
+
+        if (f->frame_thread.pass <= 1 && f->frame_hdr.refresh_context) {
+            // cdf update
+            if (update_set)
+                av1_update_tile_cdf(&f->frame_hdr, f->out_cdf.cdf,
+                                    &f->ts[f->frame_hdr.tiling.update].cdf);
+            cdf_thread_signal(&f->out_cdf);
+            cdf_thread_unref(&f->out_cdf);
+        }
+        if (f->frame_thread.pass == 1) {
+            assert(c->n_fc > 1);
+            for (int tile_idx = 0;
+                 tile_idx < f->frame_hdr.tiling.rows * f->frame_hdr.tiling.cols;
+                 tile_idx++)
+            {
+                Dav1dTileState *const ts = &f->ts[tile_idx];
+                const int tile_start_off = f->frame_thread.tile_start_off[tile_idx];
+                ts->frame_thread.pal_idx = &f->frame_thread.pal_idx[tile_start_off * 2];
+                ts->frame_thread.cf = &((int32_t *) f->frame_thread.cf)[tile_start_off * 3];
+                if (f->n_tc > 0)
+                    atomic_init(&ts->progress, 0);
+            }
+        }
+    }
+
+    dav1d_thread_picture_signal(&f->cur, UINT_MAX, PLANE_TYPE_ALL);
+
+    for (int i = 0; i < 7; i++) {
+        if (f->refp[i].p.data[0])
+            dav1d_thread_picture_unref(&f->refp[i]);
+        if (f->ref_mvs_ref[i])
+            dav1d_ref_dec(f->ref_mvs_ref[i]);
+    }
+
+    dav1d_thread_picture_unref(&f->cur);
+    if (f->cur_segmap_ref)
+        dav1d_ref_dec(f->cur_segmap_ref);
+    if (f->prev_segmap_ref)
+        dav1d_ref_dec(f->prev_segmap_ref);
+    if (f->mvs_ref)
+        dav1d_ref_dec(f->mvs_ref);
+
+    for (int i = 0; i < f->n_tile_data; i++)
+        dav1d_data_unref(&f->tile[i].data);
+
+    return 0;
+
+error:
+    for (int i = 0; i < f->n_tile_data; i++)
+        dav1d_data_unref(&f->tile[i].data);
+
+    return -EINVAL;
+}
+
+int submit_frame(Dav1dContext *const c) {
+    Dav1dFrameContext *f;
+    int res;
+
+    // wait for c->out_delayed[next] and move into c->out if visible
+    Dav1dThreadPicture *out_delayed;
+    if (c->n_fc > 1) {
+        const unsigned next = c->frame_thread.next++;
+        if (c->frame_thread.next == c->n_fc)
+            c->frame_thread.next = 0;
+
+        f = &c->fc[next];
+        pthread_mutex_lock(&f->frame_thread.td.lock);
+        while (f->n_tile_data > 0)
+            pthread_cond_wait(&f->frame_thread.td.cond,
+                              &f->frame_thread.td.lock);
+        out_delayed = &c->frame_thread.out_delayed[next];
+        if (out_delayed->p.data[0]) {
+            if (out_delayed->visible)
+                dav1d_picture_ref(&c->out, &out_delayed->p);
+            dav1d_thread_picture_unref(out_delayed);
+        }
+    } else {
+        f = c->fc;
+    }
+
+    f->seq_hdr = c->seq_hdr;
+    f->frame_hdr = c->frame_hdr;
+    const int bd_idx = (f->seq_hdr.bpc - 8) >> 1;
+    f->dsp = &c->dsp[bd_idx];
+
+    if (!f->dsp->ipred.intra_pred[TX_4X4][DC_PRED]) {
+        Dav1dDSPContext *const dsp = &c->dsp[bd_idx];
+
+        switch (f->seq_hdr.bpc) {
+#define assign_bitdepth_case(bd) \
+        case bd: \
+            dav1d_cdef_dsp_init_##bd##bpc(&dsp->cdef); \
+            dav1d_intra_pred_dsp_init_##bd##bpc(&dsp->ipred); \
+            dav1d_itx_dsp_init_##bd##bpc(&dsp->itx); \
+            dav1d_loop_filter_dsp_init_##bd##bpc(&dsp->lf); \
+            dav1d_loop_restoration_dsp_init_##bd##bpc(&dsp->lr); \
+            dav1d_mc_dsp_init_##bd##bpc(&dsp->mc); \
+            break
+#if CONFIG_8BPC
+        assign_bitdepth_case(8);
+#endif
+#if CONFIG_10BPC
+        assign_bitdepth_case(10);
+#endif
+#undef assign_bitdepth_case
+        default:
+            fprintf(stderr, "Compiled without support for %d-bit decoding\n",
+                    f->seq_hdr.bpc);
+            return -ENOPROTOOPT;
+        }
+    }
+
+#define assign_bitdepth_case(bd) \
+        f->bd_fn.recon_b_inter = recon_b_inter_##bd##bpc; \
+        f->bd_fn.recon_b_intra = recon_b_intra_##bd##bpc; \
+        f->bd_fn.filter_sbrow = filter_sbrow_##bd##bpc; \
+        f->bd_fn.backup_ipred_edge = backup_ipred_edge_##bd##bpc; \
+        f->bd_fn.read_coef_blocks = read_coef_blocks_##bd##bpc
+    if (f->seq_hdr.bpc <= 8) {
+#if CONFIG_8BPC
+        assign_bitdepth_case(8);
+#endif
+    } else {
+#if CONFIG_10BPC
+        assign_bitdepth_case(16);
+#endif
+    }
+#undef assign_bitdepth_case
+
+    if (f->frame_hdr.frame_type & 1)
+        for (int i = 0; i < 7; i++) {
+            const int refidx = f->frame_hdr.refidx[i];
+            dav1d_thread_picture_ref(&f->refp[i], &c->refs[refidx].p);
+        }
+
+    // setup entropy
+    if (f->frame_hdr.primary_ref_frame == PRIMARY_REF_NONE) {
+        av1_init_states(&f->in_cdf, f->frame_hdr.quant.yac);
+    } else {
+        const int pri_ref = f->frame_hdr.refidx[f->frame_hdr.primary_ref_frame];
+        cdf_thread_ref(&f->in_cdf, &c->cdf[pri_ref]);
+    }
+    if (f->frame_hdr.refresh_context) {
+        cdf_thread_alloc(&f->out_cdf, c->n_fc > 1 ? &f->frame_thread.td : NULL);
+        memcpy(f->out_cdf.cdf, f->in_cdf.cdf, sizeof(*f->in_cdf.cdf));
+    }
+
+    // FIXME qsort so tiles are in order (for frame threading)
+    memcpy(f->tile, c->tile, c->n_tile_data * sizeof(*f->tile));
+    f->n_tile_data = c->n_tile_data;
+    c->n_tile_data = 0;
+
+    // allocate frame
+    if ((res = dav1d_thread_picture_alloc(&f->cur, f->frame_hdr.width,
+                                          f->frame_hdr.height,
+                                          f->seq_hdr.layout, f->seq_hdr.bpc,
+                                          c->n_fc > 1 ? &f->frame_thread.td : NULL,
+                                          f->frame_hdr.show_frame)) < 0)
+    {
+        return res;
+    }
+
+    f->cur.p.poc = f->frame_hdr.frame_offset;
+    f->cur.p.p.pri = f->seq_hdr.pri;
+    f->cur.p.p.trc = f->seq_hdr.trc;
+    f->cur.p.p.mtrx = f->seq_hdr.mtrx;
+    f->cur.p.p.chr = f->seq_hdr.chr;
+    f->cur.p.p.fullrange = f->seq_hdr.color_range;
+
+    // move f->cur into output queue
+    if (c->n_fc == 1) {
+        if (f->frame_hdr.show_frame)
+            dav1d_picture_ref(&c->out, &f->cur.p);
+    } else {
+        dav1d_thread_picture_ref(out_delayed, &f->cur);
+    }
+
+    f->bw = (f->frame_hdr.width + 3) >> 2;
+    f->bh = (f->frame_hdr.height + 3) >> 2;
+    f->sb128w = (f->bw + 31) >> 5;
+    f->sb128h = (f->bh + 31) >> 5;
+    f->sb_shift = 4 + f->seq_hdr.sb128;
+    f->sb_step = 16 << f->seq_hdr.sb128;
+    f->sbh = (f->bh + f->sb_step - 1) >> f->sb_shift;
+    f->b4_stride = (f->bw + 31) & ~31;
+
+    // ref_mvs
+    if ((f->frame_hdr.frame_type & 1) || f->frame_hdr.allow_intrabc) {
+        f->mvs_ref = dav1d_ref_create(f->sb128h * 32 * f->b4_stride *
+                                      sizeof(*f->mvs));
+        f->mvs = f->mvs_ref->data;
+        if (f->frame_hdr.use_ref_frame_mvs) {
+            for (int i = 0; i < 7; i++) {
+                const int refidx = f->frame_hdr.refidx[i];
+                f->refpoc[i] = f->refp[i].p.poc;
+                if (c->refs[refidx].refmvs != NULL &&
+                    f->refp[i].p.p.w == f->cur.p.p.w &&
+                    f->refp[i].p.p.h == f->cur.p.p.h)
+                {
+                    f->ref_mvs_ref[i] = c->refs[refidx].refmvs;
+                    dav1d_ref_inc(f->ref_mvs_ref[i]);
+                    f->ref_mvs[i] = c->refs[refidx].refmvs->data;
+                } else {
+                    f->ref_mvs[i] = NULL;
+                    f->ref_mvs_ref[i] = NULL;
+                }
+                memcpy(f->refrefpoc[i], c->refs[refidx].refpoc,
+                       sizeof(*f->refrefpoc));
+            }
+        } else {
+            memset(f->ref_mvs_ref, 0, sizeof(f->ref_mvs_ref));
+        }
+    } else {
+        f->mvs_ref = NULL;
+        memset(f->ref_mvs_ref, 0, sizeof(f->ref_mvs_ref));
+    }
+
+    // segmap
+    if (f->frame_hdr.segmentation.enabled) {
+        if (f->frame_hdr.segmentation.temporal) {
+            const int pri_ref = f->frame_hdr.primary_ref_frame;
+            assert(pri_ref != PRIMARY_REF_NONE);
+            const int ref_w = (f->refp[pri_ref].p.p.w + 3) >> 2;
+            const int ref_h = (f->refp[pri_ref].p.p.h + 3) >> 2;
+            if (ref_w == f->bw && ref_h == f->bh) {
+                f->prev_segmap_ref = c->refs[f->frame_hdr.refidx[pri_ref]].segmap;
+                dav1d_ref_inc(f->prev_segmap_ref);
+                f->prev_segmap = f->prev_segmap_ref->data;
+            } else {
+                f->prev_segmap_ref = NULL;
+                f->prev_segmap = NULL;
+            }
+        } else {
+            f->prev_segmap_ref = NULL;
+            f->prev_segmap = NULL;
+        }
+        if (f->frame_hdr.segmentation.update_map) {
+            f->cur_segmap_ref = dav1d_ref_create(f->b4_stride * 32 * f->sb128h);
+            f->cur_segmap = f->cur_segmap_ref->data;
+        } else {
+            f->cur_segmap_ref = f->prev_segmap_ref;
+            dav1d_ref_inc(f->cur_segmap_ref);
+            f->cur_segmap = f->prev_segmap_ref->data;
+        }
+    } else {
+        f->cur_segmap = NULL;
+        f->cur_segmap_ref = NULL;
+        f->prev_segmap_ref = NULL;
+    }
+
+    // update references etc.
+    for (int i = 0; i < 8; i++) {
+        if (f->frame_hdr.refresh_frame_flags & (1 << i)) {
+            if (c->refs[i].p.p.data[0])
+                dav1d_thread_picture_unref(&c->refs[i].p);
+            dav1d_thread_picture_ref(&c->refs[i].p, &f->cur);
+
+            if (c->cdf[i].cdf) cdf_thread_unref(&c->cdf[i]);
+            if (f->frame_hdr.refresh_context) {
+                cdf_thread_ref(&c->cdf[i], &f->out_cdf);
+            } else {
+                cdf_thread_ref(&c->cdf[i], &f->in_cdf);
+            }
+            c->refs[i].lf_mode_ref_deltas =
+                f->frame_hdr.loopfilter.mode_ref_deltas;
+            c->refs[i].seg_data = f->frame_hdr.segmentation.seg_data;
+            memcpy(c->refs[i].gmv, f->frame_hdr.gmv, sizeof(c->refs[i].gmv));
+            c->refs[i].film_grain = f->frame_hdr.film_grain.data;
+
+            if (c->refs[i].segmap)
+                dav1d_ref_dec(c->refs[i].segmap);
+            c->refs[i].segmap = f->cur_segmap_ref;
+            if (f->cur_segmap_ref)
+                dav1d_ref_inc(f->cur_segmap_ref);
+            if (c->refs[i].refmvs)
+                dav1d_ref_dec(c->refs[i].refmvs);
+            if (f->frame_hdr.allow_intrabc) {
+                c->refs[i].refmvs = NULL;
+            } else {
+                c->refs[i].refmvs = f->mvs_ref;
+                if (f->mvs_ref)
+                    dav1d_ref_inc(f->mvs_ref);
+            }
+            memcpy(c->refs[i].refpoc, f->refpoc, sizeof(f->refpoc));
+        }
+    }
+
+    if (c->n_fc == 1) {
+        if ((res = decode_frame(f)) < 0)
+            return res;
+    } else {
+        pthread_cond_signal(&f->frame_thread.td.cond);
+        pthread_mutex_unlock(&f->frame_thread.td.lock);
+    }
+
+    return 0;
+}
diff --git a/src/decode.h b/src/decode.h
new file mode 100644
index 0000000..5947976
--- /dev/null
+++ b/src/decode.h
@@ -0,0 +1,35 @@
+/*
+ * Copyright © 2018, VideoLAN and dav1d authors
+ * Copyright © 2018, Two Orioles, LLC
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright notice, this
+ *    list of conditions and the following disclaimer.
+ *
+ * 2. Redistributions in binary form must reproduce the above copyright notice,
+ *    this list of conditions and the following disclaimer in the documentation
+ *    and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
+ * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#ifndef __DAV1D_SRC_DECODE_H__
+#define __DAV1D_SRC_DECODE_H__
+
+#include "src/internal.h"
+
+int submit_frame(Dav1dContext *c);
+
+#endif /* __DAV1D_SRC_DECODE_H__ */
diff --git a/src/dequant_tables.c b/src/dequant_tables.c
new file mode 100644
index 0000000..a8fe4c5
--- /dev/null
+++ b/src/dequant_tables.c
@@ -0,0 +1,164 @@
+/*
+ * Copyright © 2018, VideoLAN and dav1d authors
+ * Copyright © 2018, Two Orioles, LLC
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright notice, this
+ *    list of conditions and the following disclaimer.
+ *
+ * 2. Redistributions in binary form must reproduce the above copyright notice,
+ *    this list of conditions and the following disclaimer in the documentation
+ *    and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
+ * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#include "config.h"
+
+#include "src/dequant_tables.h"
+
+const uint16_t dav1d_dq_tbl[][QINDEX_RANGE][2] = {
+    {
+        {    4,    4, }, {    8,    8, }, {    8,    9, }, {    9,   10, },
+        {   10,   11, }, {   11,   12, }, {   12,   13, }, {   12,   14, },
+        {   13,   15, }, {   14,   16, }, {   15,   17, }, {   16,   18, },
+        {   17,   19, }, {   18,   20, }, {   19,   21, }, {   19,   22, },
+        {   20,   23, }, {   21,   24, }, {   22,   25, }, {   23,   26, },
+        {   24,   27, }, {   25,   28, }, {   26,   29, }, {   26,   30, },
+        {   27,   31, }, {   28,   32, }, {   29,   33, }, {   30,   34, },
+        {   31,   35, }, {   32,   36, }, {   32,   37, }, {   33,   38, },
+        {   34,   39, }, {   35,   40, }, {   36,   41, }, {   37,   42, },
+        {   38,   43, }, {   38,   44, }, {   39,   45, }, {   40,   46, },
+        {   41,   47, }, {   42,   48, }, {   43,   49, }, {   43,   50, },
+        {   44,   51, }, {   45,   52, }, {   46,   53, }, {   47,   54, },
+        {   48,   55, }, {   48,   56, }, {   49,   57, }, {   50,   58, },
+        {   51,   59, }, {   52,   60, }, {   53,   61, }, {   53,   62, },
+        {   54,   63, }, {   55,   64, }, {   56,   65, }, {   57,   66, },
+        {   57,   67, }, {   58,   68, }, {   59,   69, }, {   60,   70, },
+        {   61,   71, }, {   62,   72, }, {   62,   73, }, {   63,   74, },
+        {   64,   75, }, {   65,   76, }, {   66,   77, }, {   66,   78, },
+        {   67,   79, }, {   68,   80, }, {   69,   81, }, {   70,   82, },
+        {   70,   83, }, {   71,   84, }, {   72,   85, }, {   73,   86, },
+        {   74,   87, }, {   74,   88, }, {   75,   89, }, {   76,   90, },
+        {   77,   91, }, {   78,   92, }, {   78,   93, }, {   79,   94, },
+        {   80,   95, }, {   81,   96, }, {   81,   97, }, {   82,   98, },
+        {   83,   99, }, {   84,  100, }, {   85,  101, }, {   85,  102, },
+        {   87,  104, }, {   88,  106, }, {   90,  108, }, {   92,  110, },
+        {   93,  112, }, {   95,  114, }, {   96,  116, }, {   98,  118, },
+        {   99,  120, }, {  101,  122, }, {  102,  124, }, {  104,  126, },
+        {  105,  128, }, {  107,  130, }, {  108,  132, }, {  110,  134, },
+        {  111,  136, }, {  113,  138, }, {  114,  140, }, {  116,  142, },
+        {  117,  144, }, {  118,  146, }, {  120,  148, }, {  121,  150, },
+        {  123,  152, }, {  125,  155, }, {  127,  158, }, {  129,  161, },
+        {  131,  164, }, {  134,  167, }, {  136,  170, }, {  138,  173, },
+        {  140,  176, }, {  142,  179, }, {  144,  182, }, {  146,  185, },
+        {  148,  188, }, {  150,  191, }, {  152,  194, }, {  154,  197, },
+        {  156,  200, }, {  158,  203, }, {  161,  207, }, {  164,  211, },
+        {  166,  215, }, {  169,  219, }, {  172,  223, }, {  174,  227, },
+        {  177,  231, }, {  180,  235, }, {  182,  239, }, {  185,  243, },
+        {  187,  247, }, {  190,  251, }, {  192,  255, }, {  195,  260, },
+        {  199,  265, }, {  202,  270, }, {  205,  275, }, {  208,  280, },
+        {  211,  285, }, {  214,  290, }, {  217,  295, }, {  220,  300, },
+        {  223,  305, }, {  226,  311, }, {  230,  317, }, {  233,  323, },
+        {  237,  329, }, {  240,  335, }, {  243,  341, }, {  247,  347, },
+        {  250,  353, }, {  253,  359, }, {  257,  366, }, {  261,  373, },
+        {  265,  380, }, {  269,  387, }, {  272,  394, }, {  276,  401, },
+        {  280,  408, }, {  284,  416, }, {  288,  424, }, {  292,  432, },
+        {  296,  440, }, {  300,  448, }, {  304,  456, }, {  309,  465, },
+        {  313,  474, }, {  317,  483, }, {  322,  492, }, {  326,  501, },
+        {  330,  510, }, {  335,  520, }, {  340,  530, }, {  344,  540, },
+        {  349,  550, }, {  354,  560, }, {  359,  571, }, {  364,  582, },
+        {  369,  593, }, {  374,  604, }, {  379,  615, }, {  384,  627, },
+        {  389,  639, }, {  395,  651, }, {  400,  663, }, {  406,  676, },
+        {  411,  689, }, {  417,  702, }, {  423,  715, }, {  429,  729, },
+        {  435,  743, }, {  441,  757, }, {  447,  771, }, {  454,  786, },
+        {  461,  801, }, {  467,  816, }, {  475,  832, }, {  482,  848, },
+        {  489,  864, }, {  497,  881, }, {  505,  898, }, {  513,  915, },
+        {  522,  933, }, {  530,  951, }, {  539,  969, }, {  549,  988, },
+        {  559, 1007, }, {  569, 1026, }, {  579, 1046, }, {  590, 1066, },
+        {  602, 1087, }, {  614, 1108, }, {  626, 1129, }, {  640, 1151, },
+        {  654, 1173, }, {  668, 1196, }, {  684, 1219, }, {  700, 1243, },
+        {  717, 1267, }, {  736, 1292, }, {  755, 1317, }, {  775, 1343, },
+        {  796, 1369, }, {  819, 1396, }, {  843, 1423, }, {  869, 1451, },
+        {  896, 1479, }, {  925, 1508, }, {  955, 1537, }, {  988, 1567, },
+        { 1022, 1597, }, { 1058, 1628, }, { 1098, 1660, }, { 1139, 1692, },
+        { 1184, 1725, }, { 1232, 1759, }, { 1282, 1793, }, { 1336, 1828, },
+    }, {
+        {    4,    4, }, {    9,    9, }, {   10,   11, }, {   13,   13, },
+        {   15,   16, }, {   17,   18, }, {   20,   21, }, {   22,   24, },
+        {   25,   27, }, {   28,   30, }, {   31,   33, }, {   34,   37, },
+        {   37,   40, }, {   40,   44, }, {   43,   48, }, {   47,   51, },
+        {   50,   55, }, {   53,   59, }, {   57,   63, }, {   60,   67, },
+        {   64,   71, }, {   68,   75, }, {   71,   79, }, {   75,   83, },
+        {   78,   88, }, {   82,   92, }, {   86,   96, }, {   90,  100, },
+        {   93,  105, }, {   97,  109, }, {  101,  114, }, {  105,  118, },
+        {  109,  122, }, {  113,  127, }, {  116,  131, }, {  120,  136, },
+        {  124,  140, }, {  128,  145, }, {  132,  149, }, {  136,  154, },
+        {  140,  158, }, {  143,  163, }, {  147,  168, }, {  151,  172, },
+        {  155,  177, }, {  159,  181, }, {  163,  186, }, {  166,  190, },
+        {  170,  195, }, {  174,  199, }, {  178,  204, }, {  182,  208, },
+        {  185,  213, }, {  189,  217, }, {  193,  222, }, {  197,  226, },
+        {  200,  231, }, {  204,  235, }, {  208,  240, }, {  212,  244, },
+        {  215,  249, }, {  219,  253, }, {  223,  258, }, {  226,  262, },
+        {  230,  267, }, {  233,  271, }, {  237,  275, }, {  241,  280, },
+        {  244,  284, }, {  248,  289, }, {  251,  293, }, {  255,  297, },
+        {  259,  302, }, {  262,  306, }, {  266,  311, }, {  269,  315, },
+        {  273,  319, }, {  276,  324, }, {  280,  328, }, {  283,  332, },
+        {  287,  337, }, {  290,  341, }, {  293,  345, }, {  297,  349, },
+        {  300,  354, }, {  304,  358, }, {  307,  362, }, {  310,  367, },
+        {  314,  371, }, {  317,  375, }, {  321,  379, }, {  324,  384, },
+        {  327,  388, }, {  331,  392, }, {  334,  396, }, {  337,  401, },
+        {  343,  409, }, {  350,  417, }, {  356,  425, }, {  362,  433, },
+        {  369,  441, }, {  375,  449, }, {  381,  458, }, {  387,  466, },
+        {  394,  474, }, {  400,  482, }, {  406,  490, }, {  412,  498, },
+        {  418,  506, }, {  424,  514, }, {  430,  523, }, {  436,  531, },
+        {  442,  539, }, {  448,  547, }, {  454,  555, }, {  460,  563, },
+        {  466,  571, }, {  472,  579, }, {  478,  588, }, {  484,  596, },
+        {  490,  604, }, {  499,  616, }, {  507,  628, }, {  516,  640, },
+        {  525,  652, }, {  533,  664, }, {  542,  676, }, {  550,  688, },
+        {  559,  700, }, {  567,  713, }, {  576,  725, }, {  584,  737, },
+        {  592,  749, }, {  601,  761, }, {  609,  773, }, {  617,  785, },
+        {  625,  797, }, {  634,  809, }, {  644,  825, }, {  655,  841, },
+        {  666,  857, }, {  676,  873, }, {  687,  889, }, {  698,  905, },
+        {  708,  922, }, {  718,  938, }, {  729,  954, }, {  739,  970, },
+        {  749,  986, }, {  759, 1002, }, {  770, 1018, }, {  782, 1038, },
+        {  795, 1058, }, {  807, 1078, }, {  819, 1098, }, {  831, 1118, },
+        {  844, 1138, }, {  856, 1158, }, {  868, 1178, }, {  880, 1198, },
+        {  891, 1218, }, {  906, 1242, }, {  920, 1266, }, {  933, 1290, },
+        {  947, 1314, }, {  961, 1338, }, {  975, 1362, }, {  988, 1386, },
+        { 1001, 1411, }, { 1015, 1435, }, { 1030, 1463, }, { 1045, 1491, },
+        { 1061, 1519, }, { 1076, 1547, }, { 1090, 1575, }, { 1105, 1603, },
+        { 1120, 1631, }, { 1137, 1663, }, { 1153, 1695, }, { 1170, 1727, },
+        { 1186, 1759, }, { 1202, 1791, }, { 1218, 1823, }, { 1236, 1859, },
+        { 1253, 1895, }, { 1271, 1931, }, { 1288, 1967, }, { 1306, 2003, },
+        { 1323, 2039, }, { 1342, 2079, }, { 1361, 2119, }, { 1379, 2159, },
+        { 1398, 2199, }, { 1416, 2239, }, { 1436, 2283, }, { 1456, 2327, },
+        { 1476, 2371, }, { 1496, 2415, }, { 1516, 2459, }, { 1537, 2507, },
+        { 1559, 2555, }, { 1580, 2603, }, { 1601, 2651, }, { 1624, 2703, },
+        { 1647, 2755, }, { 1670, 2807, }, { 1692, 2859, }, { 1717, 2915, },
+        { 1741, 2971, }, { 1766, 3027, }, { 1791, 3083, }, { 1817, 3143, },
+        { 1844, 3203, }, { 1871, 3263, }, { 1900, 3327, }, { 1929, 3391, },
+        { 1958, 3455, }, { 1990, 3523, }, { 2021, 3591, }, { 2054, 3659, },
+        { 2088, 3731, }, { 2123, 3803, }, { 2159, 3876, }, { 2197, 3952, },
+        { 2236, 4028, }, { 2276, 4104, }, { 2319, 4184, }, { 2363, 4264, },
+        { 2410, 4348, }, { 2458, 4432, }, { 2508, 4516, }, { 2561, 4604, },
+        { 2616, 4692, }, { 2675, 4784, }, { 2737, 4876, }, { 2802, 4972, },
+        { 2871, 5068, }, { 2944, 5168, }, { 3020, 5268, }, { 3102, 5372, },
+        { 3188, 5476, }, { 3280, 5584, }, { 3375, 5692, }, { 3478, 5804, },
+        { 3586, 5916, }, { 3702, 6032, }, { 3823, 6148, }, { 3953, 6268, },
+        { 4089, 6388, }, { 4236, 6512, }, { 4394, 6640, }, { 4559, 6768, },
+        { 4737, 6900, }, { 4929, 7036, }, { 5130, 7172, }, { 5347, 7312, },
+    }
+};
diff --git a/src/dequant_tables.h b/src/dequant_tables.h
new file mode 100644
index 0000000..82b4fdc
--- /dev/null
+++ b/src/dequant_tables.h
@@ -0,0 +1,37 @@
+/*
+ * Copyright © 2018, VideoLAN and dav1d authors
+ * Copyright © 2018, Two Orioles, LLC
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright notice, this
+ *    list of conditions and the following disclaimer.
+ *
+ * 2. Redistributions in binary form must reproduce the above copyright notice,
+ *    this list of conditions and the following disclaimer in the documentation
+ *    and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
+ * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#ifndef __DAV1D_SRC_DEQUANT_TABLES_H__
+#define __DAV1D_SRC_DEQUANT_TABLES_H__
+
+#include <stdint.h>
+
+#include "src/levels.h"
+
+extern const uint16_t dav1d_dq_tbl[][QINDEX_RANGE][2];
+
+#endif /* __DAV1D_SRC_DEQUANT_TABLES_H__ */
diff --git a/src/env.h b/src/env.h
new file mode 100644
index 0000000..2f406b1
--- /dev/null
+++ b/src/env.h
@@ -0,0 +1,754 @@
+/*
+ * Copyright © 2018, VideoLAN and dav1d authors
+ * Copyright © 2018, Two Orioles, LLC
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright notice, this
+ *    list of conditions and the following disclaimer.
+ *
+ * 2. Redistributions in binary form must reproduce the above copyright notice,
+ *    this list of conditions and the following disclaimer in the documentation
+ *    and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
+ * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#ifndef __DAV1D_SRC_ENV_H__
+#define __DAV1D_SRC_ENV_H__
+
+#include <assert.h>
+#include <stddef.h>
+#include <stdint.h>
+#include <stdlib.h>
+
+#include "src/levels.h"
+#include "src/ref_mvs.h"
+#include "src/tables.h"
+
+typedef struct BlockContext {
+    uint8_t mode[32];
+    uint8_t lcoef[32];
+    uint8_t ccoef[2][32];
+    uint8_t seg_pred[32];
+    uint8_t skip[32];
+    uint8_t skip_mode[32];
+    uint8_t intra[32];
+    uint8_t comp_type[32];
+    int8_t ref[2][32]; // -1 means intra
+    uint8_t filter[2][32]; // 3 means unset
+    int8_t tx_intra[32];
+    int8_t tx[32];
+    uint8_t tx_lpf_y[32];
+    uint8_t tx_lpf_uv[32];
+    uint8_t partition[16];
+    uint8_t uvmode[32];
+    uint8_t pal_sz[32];
+} BlockContext;
+
+static inline int get_intra_ctx(const BlockContext *const a,
+                                const BlockContext *const l,
+                                const int yb4, const int xb4,
+                                const int have_top, const int have_left)
+{
+    if (have_left) {
+        if (have_top) {
+            const int ctx = l->intra[yb4] + a->intra[xb4];
+            return ctx + (ctx == 2);
+        } else
+            return l->intra[yb4] * 2;
+    } else {
+        return have_top ? a->intra[xb4] * 2 : 0;
+    }
+}
+
+static inline int get_tx_ctx(const BlockContext *const a,
+                             const BlockContext *const l,
+                             const TxfmInfo *const max_tx,
+                             const int yb4, const int xb4,
+                             const int have_top, const int have_left)
+{
+    return (l->tx_intra[yb4] >= max_tx->lh) + (a->tx_intra[xb4] >= max_tx->lw);
+}
+
+static inline int get_partition_ctx(const BlockContext *const a,
+                                    const BlockContext *const l,
+                                    const enum BlockLevel bl,
+                                    const int yb8, const int xb8)
+{
+    return ((a->partition[xb8] >> (4 - bl)) & 1) +
+          (((l->partition[yb8] >> (4 - bl)) & 1) << 1);
+}
+
+static inline unsigned cdf_element_prob(const uint16_t *const cdf, const int e) {
+    return (e > 0 ? cdf[e - 1] : 32768) - cdf[e];
+}
+
+static inline unsigned gather_left_partition_prob(const uint16_t *const in,
+                                                  const enum BlockLevel bl)
+{
+    unsigned out = 32768;
+    out -= cdf_element_prob(in, PARTITION_H);
+    if (bl != BL_128X128)
+        out -= cdf_element_prob(in, PARTITION_H4);
+    out -= cdf_element_prob(in, PARTITION_SPLIT);
+    out -= cdf_element_prob(in, PARTITION_T_TOP_SPLIT);
+    out -= cdf_element_prob(in, PARTITION_T_BOTTOM_SPLIT);
+    out -= cdf_element_prob(in, PARTITION_T_LEFT_SPLIT);
+    return 32768 - out;
+}
+
+static inline unsigned gather_top_partition_prob(const uint16_t *const in,
+                                                 const enum BlockLevel bl)
+{
+    unsigned out = 32768;
+    out -= cdf_element_prob(in, PARTITION_V);
+    if (bl != BL_128X128)
+        out -= cdf_element_prob(in, PARTITION_V4);
+    out -= cdf_element_prob(in, PARTITION_SPLIT);
+    out -= cdf_element_prob(in, PARTITION_T_TOP_SPLIT);
+    out -= cdf_element_prob(in, PARTITION_T_LEFT_SPLIT);
+    out -= cdf_element_prob(in, PARTITION_T_RIGHT_SPLIT);
+    return 32768 - out;
+}
+
+static inline enum TxfmTypeSet get_ext_txtp_set(const enum RectTxfmSize tx,
+                                                const int inter,
+                                                const Av1FrameHeader *const hdr,
+                                                const int seg_id)
+{
+    if (hdr->segmentation.lossless[seg_id]) {
+        assert(tx == (int) TX_4X4);
+        return TXTP_SET_LOSSLESS;
+    }
+
+    const TxfmInfo *const t_dim = &av1_txfm_dimensions[tx];
+
+    if (t_dim->max >= TX_64X64)
+        return TXTP_SET_DCT;
+
+    if (t_dim->max == TX_32X32)
+        return inter ? TXTP_SET_DCT_ID : TXTP_SET_DCT;
+
+    if (hdr->reduced_txtp_set)
+        return inter ? TXTP_SET_DCT_ID : TXTP_SET_DT4_ID;
+
+    const enum TxfmSize txsqsz = t_dim->min;
+
+    if (inter)
+        return txsqsz == TX_16X16 ? TXTP_SET_DT9_ID_1D : TXTP_SET_ALL;
+    else
+        return txsqsz == TX_16X16 ? TXTP_SET_DT4_ID : TXTP_SET_DT4_ID_1D;
+}
+
+static inline enum TxfmType get_uv_intra_txtp(const enum IntraPredMode uv_mode,
+                                              const enum RectTxfmSize tx,
+                                              const Av1FrameHeader *const hdr,
+                                              const int seg_id)
+{
+    if (hdr->segmentation.lossless[seg_id]) {
+        assert(tx == (int) TX_4X4);
+        return WHT_WHT;
+    }
+
+    const TxfmInfo *const t_dim = &av1_txfm_dimensions[tx];
+
+    return t_dim->max == TX_32X32 ? DCT_DCT : av1_txtp_from_uvmode[uv_mode];
+}
+
+static inline enum TxfmType get_uv_inter_txtp(const TxfmInfo *const uvt_dim,
+                                              const enum TxfmType ytxtp,
+                                              const Av1FrameHeader *const hdr,
+                                              const int seg_id)
+{
+    if (hdr->segmentation.lossless[seg_id]) {
+        assert(uvt_dim->max == TX_4X4);
+        return WHT_WHT;
+    }
+
+    if (uvt_dim->max == TX_32X32)
+        return ytxtp == IDTX ? IDTX : DCT_DCT;
+    if (uvt_dim->min == TX_16X16 &&
+        ((1 << ytxtp) & ((1 << H_FLIPADST) | (1 << V_FLIPADST) |
+                         (1 << H_ADST) | (1 << V_ADST))))
+    {
+        return DCT_DCT;
+    }
+
+    return ytxtp;
+}
+
+static inline int get_filter_ctx(const BlockContext *const a,
+                                 const BlockContext *const l,
+                                 const int comp, const int dir, const int ref,
+                                 const int yb4, const int xb4)
+{
+    const int a_filter = (a->ref[0][xb4] == ref || a->ref[1][xb4] == ref) ?
+                         a->filter[dir][xb4] : N_SWITCHABLE_FILTERS;
+    const int l_filter = (l->ref[0][yb4] == ref || l->ref[1][yb4] == ref) ?
+                         l->filter[dir][yb4] : N_SWITCHABLE_FILTERS;
+
+    if (a_filter == l_filter) {
+        return comp * 4 + a_filter;
+    } else if (a_filter == N_SWITCHABLE_FILTERS) {
+        return comp * 4 + l_filter;
+    } else if (l_filter == N_SWITCHABLE_FILTERS) {
+        return comp * 4 + a_filter;
+    } else {
+        return comp * 4 + N_SWITCHABLE_FILTERS;
+    }
+}
+
+static inline int get_comp_ctx(const BlockContext *const a,
+                               const BlockContext *const l,
+                               const int yb4, const int xb4,
+                               const int have_top, const int have_left)
+{
+    if (have_top) {
+        if (have_left) {
+            if (a->comp_type[xb4]) {
+                if (l->comp_type[yb4]) {
+                    return 4;
+                } else {
+                    // 4U means intra (-1) or bwd (>= 4)
+                    return 2 + (l->ref[0][yb4] >= 4U);
+                }
+            } else if (l->comp_type[yb4]) {
+                // 4U means intra (-1) or bwd (>= 4)
+                return 2 + (a->ref[0][xb4] >= 4U);
+            } else {
+                return (l->ref[0][yb4] >= 4) ^ (a->ref[0][xb4] >= 4);
+            }
+        } else {
+            return a->comp_type[xb4] ? 3 : a->ref[0][xb4] >= 4;
+        }
+    } else if (have_left) {
+        return l->comp_type[yb4] ? 3 : l->ref[0][yb4] >= 4;
+    } else {
+        return 1;
+    }
+}
+
+static inline int get_comp_dir_ctx(const BlockContext *const a,
+                                   const BlockContext *const l,
+                                   const int yb4, const int xb4,
+                                   const int have_top, const int have_left)
+{
+#define has_uni_comp(edge, off) \
+    ((edge->ref[0][off] < 4) == (edge->ref[1][off] < 4))
+
+    if (have_top && have_left) {
+        const int a_intra = a->intra[xb4], l_intra = l->intra[yb4];
+
+        if (a_intra && l_intra) return 2;
+        if (a_intra || l_intra) {
+            const BlockContext *const edge = a_intra ? l : a;
+            const int off = a_intra ? yb4 : xb4;
+
+            if (edge->comp_type[off] == COMP_INTER_NONE) return 2;
+            return 1 + 2 * has_uni_comp(edge, off);
+        }
+
+        const int a_comp = a->comp_type[xb4] != COMP_INTER_NONE;
+        const int l_comp = l->comp_type[yb4] != COMP_INTER_NONE;
+        const int a_ref0 = a->ref[0][xb4], l_ref0 = l->ref[0][yb4];
+
+        if (!a_comp && !l_comp) {
+            return 1 + 2 * ((a_ref0 >= 4) == (l_ref0 >= 4));
+        } else if (!a_comp || !l_comp) {
+            const BlockContext *const edge = a_comp ? a : l;
+            const int off = a_comp ? xb4 : yb4;
+
+            if (!has_uni_comp(edge, off)) return 1;
+            return 3 + ((a_ref0 >= 4) == (l_ref0 >= 4));
+        } else {
+            const int a_uni = has_uni_comp(a, xb4), l_uni = has_uni_comp(l, yb4);
+
+            if (!a_uni && !l_uni) return 0;
+            if (!a_uni || !l_uni) return 2;
+            return 3 + ((a_ref0 == 4) == (l_ref0 == 4));
+        }
+    } else if (have_top || have_left) {
+        const BlockContext *const edge = have_left ? l : a;
+        const int off = have_left ? yb4 : xb4;
+
+        if (edge->intra[off]) return 2;
+        if (edge->comp_type[off] == COMP_INTER_NONE) return 2;
+        return 4 * has_uni_comp(edge, off);
+    } else {
+        return 2;
+    }
+}
+
+static inline int get_poc_diff(const int order_hint_n_bits,
+                               const int poc0, const int poc1)
+{
+    const int mask = 1 << (order_hint_n_bits - 1);
+    const int diff = poc0 - poc1;
+    return (diff & (mask - 1)) - (diff & mask);
+}
+
+static inline int get_jnt_comp_ctx(const int order_hint_n_bits,
+                                   const unsigned poc, const unsigned ref0poc,
+                                   const unsigned ref1poc,
+                                   const BlockContext *const a,
+                                   const BlockContext *const l,
+                                   const int yb4, const int xb4)
+{
+    const unsigned d0 = abs(get_poc_diff(order_hint_n_bits, ref0poc, poc));
+    const unsigned d1 = abs(get_poc_diff(order_hint_n_bits, ref1poc, poc));
+    const int offset = d0 == d1;
+    const int a_ctx = a->comp_type[xb4] >= COMP_INTER_AVG ||
+                      a->ref[0][xb4] == 6;
+    const int l_ctx = l->comp_type[yb4] >= COMP_INTER_AVG ||
+                      l->ref[0][yb4] == 6;
+
+    return 3 * offset + a_ctx + l_ctx;
+}
+
+static inline int get_mask_comp_ctx(const BlockContext *const a,
+                                    const BlockContext *const l,
+                                    const int yb4, const int xb4)
+{
+    const int a_ctx = a->comp_type[xb4] >= COMP_INTER_SEG ? 1 :
+                      a->ref[0][xb4] == 6 ? 3 : 0;
+    const int l_ctx = l->comp_type[yb4] >= COMP_INTER_SEG ? 1 :
+                      l->ref[0][yb4] == 6 ? 3 : 0;
+
+    return imin(a_ctx + l_ctx, 5);
+}
+
+#define av1_get_ref_2_ctx av1_get_bwd_ref_ctx
+#define av1_get_ref_3_ctx av1_get_fwd_ref_ctx
+#define av1_get_ref_4_ctx av1_get_fwd_ref_1_ctx
+#define av1_get_ref_5_ctx av1_get_fwd_ref_2_ctx
+#define av1_get_ref_6_ctx av1_get_bwd_ref_1_ctx
+#define av1_get_uni_p_ctx av1_get_ref_ctx
+#define av1_get_uni_p2_ctx av1_get_fwd_ref_2_ctx
+
+static inline int av1_get_ref_ctx(const BlockContext *const a,
+                                  const BlockContext *const l,
+                                  const int yb4, const int xb4,
+                                  int have_top, int have_left)
+{
+    int cnt[2] = { 0 };
+
+    if (have_top && !a->intra[xb4]) {
+        cnt[a->ref[0][xb4] >= 4]++;
+        if (a->comp_type[xb4]) cnt[a->ref[1][xb4] >= 4]++;
+    }
+
+    if (have_left && !l->intra[yb4]) {
+        cnt[l->ref[0][yb4] >= 4]++;
+        if (l->comp_type[yb4]) cnt[l->ref[1][yb4] >= 4]++;
+    }
+
+    return cnt[0] == cnt[1] ? 1 : cnt[0] < cnt[1] ? 0 : 2;
+}
+
+static inline int av1_get_fwd_ref_ctx(const BlockContext *const a,
+                                      const BlockContext *const l,
+                                      const int yb4, const int xb4,
+                                      const int have_top, const int have_left)
+{
+    int cnt[4] = { 0 };
+
+    if (have_top && !a->intra[xb4]) {
+        if (a->ref[0][xb4] < 4) cnt[a->ref[0][xb4]]++;
+        if (a->comp_type[xb4] && a->ref[1][xb4] < 4) cnt[a->ref[1][xb4]]++;
+    }
+
+    if (have_left && !l->intra[yb4]) {
+        if (l->ref[0][yb4] < 4) cnt[l->ref[0][yb4]]++;
+        if (l->comp_type[yb4] && l->ref[1][yb4] < 4) cnt[l->ref[1][yb4]]++;
+    }
+
+    cnt[0] += cnt[1];
+    cnt[2] += cnt[3];
+
+    return cnt[0] == cnt[2] ? 1 : cnt[0] < cnt[2] ? 0 : 2;
+}
+
+static inline int av1_get_fwd_ref_1_ctx(const BlockContext *const a,
+                                        const BlockContext *const l,
+                                        const int yb4, const int xb4,
+                                        const int have_top, const int have_left)
+{
+    int cnt[2] = { 0 };
+
+    if (have_top && !a->intra[xb4]) {
+        if (a->ref[0][xb4] < 2) cnt[a->ref[0][xb4]]++;
+        if (a->comp_type[xb4] && a->ref[1][xb4] < 2) cnt[a->ref[1][xb4]]++;
+    }
+
+    if (have_left && !l->intra[yb4]) {
+        if (l->ref[0][yb4] < 2) cnt[l->ref[0][yb4]]++;
+        if (l->comp_type[yb4] && l->ref[1][yb4] < 2) cnt[l->ref[1][yb4]]++;
+    }
+
+    return cnt[0] == cnt[1] ? 1 : cnt[0] < cnt[1] ? 0 : 2;
+}
+
+static inline int av1_get_fwd_ref_2_ctx(const BlockContext *const a,
+                                        const BlockContext *const l,
+                                        const int yb4, const int xb4,
+                                        const int have_top, const int have_left)
+{
+    int cnt[2] = { 0 };
+
+    if (have_top && !a->intra[xb4]) {
+        if (a->ref[0][xb4] - 2U < 2) cnt[a->ref[0][xb4] - 2]++;
+        if (a->comp_type[xb4] && a->ref[1][xb4] - 2U < 2) cnt[a->ref[1][xb4] - 2]++;
+    }
+
+    if (have_left && !l->intra[yb4]) {
+        if (l->ref[0][yb4] - 2U < 2) cnt[l->ref[0][yb4] - 2]++;
+        if (l->comp_type[yb4] && l->ref[1][yb4] - 2U < 2) cnt[l->ref[1][yb4] - 2]++;
+    }
+
+    return cnt[0] == cnt[1] ? 1 : cnt[0] < cnt[1] ? 0 : 2;
+}
+
+static inline int av1_get_bwd_ref_ctx(const BlockContext *const a,
+                                      const BlockContext *const l,
+                                      const int yb4, const int xb4,
+                                      const int have_top, const int have_left)
+{
+    int cnt[3] = { 0 };
+
+    if (have_top && !a->intra[xb4]) {
+        if (a->ref[0][xb4] >= 4) cnt[a->ref[0][xb4] - 4]++;
+        if (a->comp_type[xb4] && a->ref[1][xb4] >= 4) cnt[a->ref[1][xb4] - 4]++;
+    }
+
+    if (have_left && !l->intra[yb4]) {
+        if (l->ref[0][yb4] >= 4) cnt[l->ref[0][yb4] - 4]++;
+        if (l->comp_type[yb4] && l->ref[1][yb4] >= 4) cnt[l->ref[1][yb4] - 4]++;
+    }
+
+    cnt[1] += cnt[0];
+
+    return cnt[2] == cnt[1] ? 1 : cnt[1] < cnt[2] ? 0 : 2;
+}
+
+static inline int av1_get_bwd_ref_1_ctx(const BlockContext *const a,
+                                        const BlockContext *const l,
+                                        const int yb4, const int xb4,
+                                        const int have_top, const int have_left)
+{
+    int cnt[3] = { 0 };
+
+    if (have_top && !a->intra[xb4]) {
+        if (a->ref[0][xb4] >= 4) cnt[a->ref[0][xb4] - 4]++;
+        if (a->comp_type[xb4] && a->ref[1][xb4] >= 4) cnt[a->ref[1][xb4] - 4]++;
+    }
+
+    if (have_left && !l->intra[yb4]) {
+        if (l->ref[0][yb4] >= 4) cnt[l->ref[0][yb4] - 4]++;
+        if (l->comp_type[yb4] && l->ref[1][yb4] >= 4) cnt[l->ref[1][yb4] - 4]++;
+    }
+
+    return cnt[0] == cnt[1] ? 1 : cnt[0] < cnt[1] ? 0 : 2;
+}
+
+static inline int av1_get_uni_p1_ctx(const BlockContext *const a,
+                                     const BlockContext *const l,
+                                     const int yb4, const int xb4,
+                                     const int have_top, const int have_left)
+{
+    int cnt[3] = { 0 };
+
+    if (have_top && !a->intra[xb4]) {
+        if (a->ref[0][xb4] - 1U < 3) cnt[a->ref[0][xb4] - 1]++;
+        if (a->comp_type[xb4] && a->ref[1][xb4] - 1U < 3) cnt[a->ref[1][xb4] - 1]++;
+    }
+
+    if (have_left && !l->intra[yb4]) {
+        if (l->ref[0][yb4] - 1U < 3) cnt[l->ref[0][yb4] - 1]++;
+        if (l->comp_type[yb4] && l->ref[1][yb4] - 1U < 3) cnt[l->ref[1][yb4] - 1]++;
+    }
+
+    cnt[1] += cnt[2];
+
+    return cnt[0] == cnt[1] ? 1 : cnt[0] < cnt[1] ? 0 : 2;
+}
+
+static inline int get_drl_context(const candidate_mv *const ref_mv_stack,
+                                  const int ref_idx)
+{
+    if (ref_mv_stack[ref_idx].weight >= 640 &&
+        ref_mv_stack[ref_idx + 1].weight >= 640)
+        return 0;
+
+    if (ref_mv_stack[ref_idx].weight >= 640 &&
+        ref_mv_stack[ref_idx + 1].weight < 640)
+        return 1;
+
+    if (ref_mv_stack[ref_idx].weight < 640 &&
+        ref_mv_stack[ref_idx + 1].weight < 640)
+        return 2;
+
+    return 0;
+}
+
+static inline unsigned get_cur_frame_segid(const int by, const int bx,
+                                           const int have_top,
+                                           const int have_left,
+                                           int *const seg_ctx,
+                                           const uint8_t *cur_seg_map,
+                                           const ptrdiff_t stride)
+{
+    cur_seg_map += bx + by * stride;
+    if (have_left && have_top) {
+        const int l = cur_seg_map[-1];
+        const int a = cur_seg_map[-stride];
+        const int al = cur_seg_map[-(stride + 1)];
+
+        if (l == a && al == l) *seg_ctx = 2;
+        else if (l == a || al == l || a == al) *seg_ctx = 1;
+        else *seg_ctx = 0;
+        return a == al ? a : l;
+    } else {
+        *seg_ctx = 0;
+        return have_left ? cur_seg_map[-1] : have_top ? cur_seg_map[-stride] : 0;
+    }
+}
+
+static inline int get_coef_skip_ctx(const TxfmInfo *const t_dim,
+                                    const enum BlockSize bs,
+                                    const uint8_t *const a,
+                                    const uint8_t *const l,
+                                    const int chroma,
+                                    const enum Dav1dPixelLayout layout)
+{
+    const uint8_t *const b_dim = av1_block_dimensions[bs];
+
+    if (chroma) {
+        const int ss_ver = layout == DAV1D_PIXEL_LAYOUT_I420;
+        const int ss_hor = layout != DAV1D_PIXEL_LAYOUT_I444;
+        const int not_one_blk = b_dim[2] - (!!b_dim[2] && ss_hor) > t_dim->lw ||
+                                b_dim[3] - (!!b_dim[3] && ss_ver) > t_dim->lh;
+        int ca, cl;
+
+#define MERGE_CTX(dir, type, mask) \
+        c##dir = !!((*(const type *) dir) & mask); \
+        break
+        switch (t_dim->lw) {
+        case TX_4X4:   MERGE_CTX(a, uint8_t,  0x3F);
+        case TX_8X8:   MERGE_CTX(a, uint16_t, 0x3F3F);
+        case TX_16X16: MERGE_CTX(a, uint32_t, 0x3F3F3F3FU);
+        case TX_32X32: MERGE_CTX(a, uint64_t, 0x3F3F3F3F3F3F3F3FULL);
+        default: abort();
+        }
+        switch (t_dim->lh) {
+        case TX_4X4:   MERGE_CTX(l, uint8_t,  0x3F);
+        case TX_8X8:   MERGE_CTX(l, uint16_t, 0x3F3F);
+        case TX_16X16: MERGE_CTX(l, uint32_t, 0x3F3F3F3FU);
+        case TX_32X32: MERGE_CTX(l, uint64_t, 0x3F3F3F3F3F3F3F3FULL);
+        default: abort();
+        }
+#undef MERGE_CTX
+
+        return 7 + not_one_blk * 3 + ca + cl;
+    } else if (b_dim[2] == t_dim->lw && b_dim[3] == t_dim->lh) {
+        return 0;
+    } else {
+        static const uint8_t skip_contexts[5][5] = {
+            { 1, 2, 2, 2, 3 },
+            { 1, 4, 4, 4, 5 },
+            { 1, 4, 4, 4, 5 },
+            { 1, 4, 4, 4, 5 },
+            { 1, 4, 4, 4, 6 }
+        };
+        uint64_t la, ll;
+
+#define MERGE_CTX(dir, type, tx) do { \
+            l##dir = *(const type *) dir; \
+            if (tx == TX_64X64) \
+                l##dir |= *(const type *) &dir[sizeof(type)]; \
+            if (tx >= TX_32X32) l##dir |= l##dir >> 32; \
+            if (tx >= TX_16X16) l##dir |= l##dir >> 16; \
+            if (tx >= TX_8X8)   l##dir |= l##dir >> 8; \
+            l##dir &= 0x3F; \
+        } while (0); \
+        break
+        switch (t_dim->lw) {
+        case TX_4X4:   MERGE_CTX(a, uint8_t,  TX_4X4);
+        case TX_8X8:   MERGE_CTX(a, uint16_t, TX_8X8);
+        case TX_16X16: MERGE_CTX(a, uint32_t, TX_16X16);
+        case TX_32X32: MERGE_CTX(a, uint64_t, TX_32X32);
+        case TX_64X64: MERGE_CTX(a, uint64_t, TX_64X64);
+        }
+        switch (t_dim->lh) {
+        case TX_4X4:   MERGE_CTX(l, uint8_t,  TX_4X4);
+        case TX_8X8:   MERGE_CTX(l, uint16_t, TX_8X8);
+        case TX_16X16: MERGE_CTX(l, uint32_t, TX_16X16);
+        case TX_32X32: MERGE_CTX(l, uint64_t, TX_32X32);
+        case TX_64X64: MERGE_CTX(l, uint64_t, TX_64X64);
+        }
+#undef MERGE_CTX
+
+        const int max = imin(la | ll, 4);
+        const int min = imin(imin(la, ll), 4);
+
+        return skip_contexts[min][max];
+    }
+}
+
+static inline int get_coef_nz_ctx(uint8_t *const levels, const int scan_idx,
+                                  const int rc, const int is_eob,
+                                  const enum RectTxfmSize tx,
+                                  const enum TxClass tx_class)
+{
+    const TxfmInfo *const t_dim = &av1_txfm_dimensions[tx];
+
+    if (is_eob) {
+        if (scan_idx == 0)         return 0;
+        const int eighth_sz = imin(t_dim->w, 8) * imin(t_dim->h, 8) * 2;
+        if (scan_idx <= eighth_sz) return 1;
+        const int quart_sz = eighth_sz * 2;
+        if (scan_idx <= quart_sz)  return 2;
+        return 3;
+    }
+
+    const int x = rc >> (2 + imin(t_dim->lh, 3));
+    const int y = rc & (4 * imin(t_dim->h, 8) - 1);
+    const ptrdiff_t stride = 4 * (imin(t_dim->h, 8) + 1);
+    static const uint8_t offsets[3][5][2 /* x, y */] = {
+        [TX_CLASS_2D] = {
+            { 0, 1 }, { 1, 0 }, { 2, 0 }, { 0, 2 }, { 1, 1 }
+        }, [TX_CLASS_V] = {
+            { 0, 1 }, { 1, 0 }, { 0, 2 }, { 0, 3 }, { 0, 4 }
+        }, [TX_CLASS_H] = {
+            { 0, 1 }, { 1, 0 }, { 2, 0 }, { 3, 0 }, { 4, 0 }
+        }
+    };
+    const uint8_t (*const off)[2] = offsets[tx_class];
+    int mag = 0;
+    for (int i = 0; i < 5; i++)
+        mag += imin(levels[(x + off[i][0]) * stride + (y + off[i][1])], 3);
+    const int ctx = imin((mag + 1) >> 1, 4);
+    if (tx_class == TX_CLASS_2D) {
+        return !rc ? 0 :
+            av1_nz_map_ctx_offset[tx][imin(y, 4)][imin(x, 4)] + ctx;
+    } else {
+        return 26 + imin((tx_class == TX_CLASS_V) ? y : x, 2) * 5 + ctx;
+    }
+}
+
+static inline int get_dc_sign_ctx(const TxfmInfo *const t_dim,
+                                  const uint8_t *const a,
+                                  const uint8_t *const l)
+{
+    uint64_t sa, sl;
+
+#define MERGE_CTX(dir, type, tx, mask) do { \
+        s##dir = ((*(const type *) dir) >> 6) & mask; \
+        if (tx == TX_64X64) \
+            s##dir += ((*(const type *) &dir[sizeof(type)]) >> 6) & mask; \
+        if (tx >= TX_32X32) s##dir += s##dir >> 32; \
+        if (tx >= TX_16X16) s##dir += s##dir >> 16; \
+        if (tx >= TX_8X8)   s##dir += s##dir >> 8; \
+    } while (0); \
+    break
+    switch (t_dim->lw) {
+    case TX_4X4:   MERGE_CTX(a, uint8_t,  TX_4X4,   0x03);
+    case TX_8X8:   MERGE_CTX(a, uint16_t, TX_8X8,   0x0303);
+    case TX_16X16: MERGE_CTX(a, uint32_t, TX_16X16, 0x03030303U);
+    case TX_32X32: MERGE_CTX(a, uint64_t, TX_32X32, 0x0303030303030303ULL);
+    case TX_64X64: MERGE_CTX(a, uint64_t, TX_64X64, 0x0303030303030303ULL);
+    }
+    switch (t_dim->lh) {
+    case TX_4X4:   MERGE_CTX(l, uint8_t,  TX_4X4,   0x03);
+    case TX_8X8:   MERGE_CTX(l, uint16_t, TX_8X8,   0x0303);
+    case TX_16X16: MERGE_CTX(l, uint32_t, TX_16X16, 0x03030303U);
+    case TX_32X32: MERGE_CTX(l, uint64_t, TX_32X32, 0x0303030303030303ULL);
+    case TX_64X64: MERGE_CTX(l, uint64_t, TX_64X64, 0x0303030303030303ULL);
+    }
+#undef MERGE_CTX
+    const int s = ((int) ((sa + sl) & 0xFF)) - (t_dim->w + t_dim->h);
+
+    return s < 0 ? 1 : s > 0 ? 2 : 0;
+}
+
+static inline int get_br_ctx(const uint8_t *const levels,
+                             const int rc, const enum RectTxfmSize tx,
+                             const enum TxClass tx_class)
+{
+    const TxfmInfo *const t_dim = &av1_txfm_dimensions[tx];
+    const int x = rc >> (imin(t_dim->lh, 3) + 2);
+    const int y = rc & (4 * imin(t_dim->h, 8) - 1);
+    const int stride = 4 * (imin(t_dim->h, 8) + 1);
+    int mag = 0;
+    static const uint8_t offsets_from_txclass[3][3][2] = {
+        [TX_CLASS_2D] = { { 0, 1 }, { 1, 0 }, { 1, 1 } },
+        [TX_CLASS_H]  = { { 0, 1 }, { 1, 0 }, { 0, 2 } },
+        [TX_CLASS_V]  = { { 0, 1 }, { 1, 0 }, { 2, 0 } }
+    };
+    const uint8_t (*const offsets)[2] = offsets_from_txclass[tx_class];
+    for (int i = 0; i < 3; i++)
+        mag += levels[(x + offsets[i][1]) * stride + y + offsets[i][0]];
+
+    mag = imin((mag + 1) >> 1, 6);
+    if (rc == 0) return mag;
+    switch (tx_class) {
+    case TX_CLASS_2D:
+        if (y < 2 && x < 2) return mag + 7;
+        break;
+    case TX_CLASS_H:
+        if (x == 0) return mag + 7;
+        break;
+    case TX_CLASS_V:
+        if (y == 0) return mag + 7;
+        break;
+    }
+    return mag + 14;
+}
+
+static inline mv get_gmv_2d(const WarpedMotionParams *const gmv,
+                            const int bx4, const int by4,
+                            const int bw4, const int bh4,
+                            const Av1FrameHeader *const hdr)
+{
+    switch (gmv->type) {
+    case WM_TYPE_ROT_ZOOM:
+        assert(gmv->matrix[5] ==  gmv->matrix[2]);
+        assert(gmv->matrix[4] == -gmv->matrix[3]);
+        // fall-through
+    default:
+    case WM_TYPE_AFFINE: {
+        const int x = bx4 * 4 + bw4 * 2 - 1;
+        const int y = by4 * 4 + bh4 * 2 - 1;
+        const int xc = (gmv->matrix[2] - (1 << 16)) * x +
+                       gmv->matrix[3] * y + gmv->matrix[0];
+        const int yc = (gmv->matrix[5] - (1 << 16)) * y +
+                       gmv->matrix[4] * x + gmv->matrix[1];
+        const int shift = 16 - (3 - !hdr->hp);
+        const int round = (1 << shift) >> 1;
+        return (mv) {
+            .y = apply_sign(((abs(yc) + round) >> shift) << !hdr->hp, yc),
+            .x = apply_sign(((abs(xc) + round) >> shift) << !hdr->hp, xc),
+        };
+    }
+    case WM_TYPE_TRANSLATION:
+        return (mv) {
+            .y = gmv->matrix[0] >> 13,
+            .x = gmv->matrix[1] >> 13,
+        };
+    case WM_TYPE_IDENTITY:
+        return (mv) { .x = 0, .y = 0 };
+    }
+}
+
+#endif /* __DAV1D_SRC_ENV_H__ */
diff --git a/src/getbits.c b/src/getbits.c
new file mode 100644
index 0000000..9eb0759
--- /dev/null
+++ b/src/getbits.c
@@ -0,0 +1,129 @@
+/*
+ * Copyright © 2018, VideoLAN and dav1d authors
+ * Copyright © 2018, Two Orioles, LLC
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright notice, this
+ *    list of conditions and the following disclaimer.
+ *
+ * 2. Redistributions in binary form must reproduce the above copyright notice,
+ *    this list of conditions and the following disclaimer in the documentation
+ *    and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
+ * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#include "config.h"
+
+#include <assert.h>
+
+#include "common/intops.h"
+
+#include "src/getbits.h"
+
+void init_get_bits(GetBits *const c,
+                   const uint8_t *const data, const size_t sz)
+{
+    c->ptr = c->ptr_start = data;
+    c->ptr_end = &c->ptr_start[sz];
+    c->bits_left = 0;
+    c->state = 0;
+    c->error = 0;
+    c->eof = 0;
+}
+
+static void refill(GetBits *const c, const unsigned n) {
+    assert(c->bits_left <= 56);
+    uint64_t state = 0;
+    do {
+        state <<= 8;
+        c->bits_left += 8;
+        if (!c->eof)
+            state |= *c->ptr++;
+        if (c->ptr >= c->ptr_end) {
+            c->error = c->eof;
+            c->eof = 1;
+        }
+    } while (n > c->bits_left);
+    c->state |= state << (64 - c->bits_left);
+}
+
+unsigned get_bits(GetBits *const c, const unsigned n) {
+    assert(n <= 32 /* can go up to 57 if we change return type */);
+
+    if (n > c->bits_left) refill(c, n);
+
+    const uint64_t state = c->state;
+    c->bits_left -= n;
+    c->state <<= n;
+
+    return state >> (64 - n);
+}
+
+int get_sbits(GetBits *const c, const unsigned n) {
+    const int shift = 31 - n;
+    const int res = get_bits(c, n + 1) << shift;
+    return res >> shift;
+}
+
+unsigned get_uniform(GetBits *const c, const unsigned n) {
+    assert(n > 0);
+    const int l = ulog2(n) + 1;
+    assert(l > 0);
+    const int m = (1 << l) - n;
+    const int v = get_bits(c, l - 1);
+    return v < m ? v : (v << 1) - m + get_bits(c, 1);
+}
+
+unsigned get_vlc(GetBits *const c) {
+    int n_bits = 0;
+    while (!get_bits(c, 1)) n_bits++;
+    if (n_bits >= 32) return 0xFFFFFFFFU;
+    return ((1 << n_bits) - 1) + get_bits(c, n_bits);
+}
+
+static unsigned get_bits_subexp_u(GetBits *const c, const unsigned ref,
+                                  const unsigned n)
+{
+    unsigned v = 0;
+
+    for (int i = 0;; i++) {
+        const int b = i ? 3 + i - 1 : 3;
+
+        if (n < v + 3 * (1 << b)) {
+            v += get_uniform(c, n - v + 1);
+            break;
+        }
+
+        if (!get_bits(c, 1)) {
+            v += get_bits(c, b);
+            break;
+        }
+
+        v += 1 << b;
+    }
+
+    return ref * 2 <= n ? inv_recenter(ref, v) : n - inv_recenter(n - ref, v);
+}
+
+int get_bits_subexp(GetBits *const c, const int ref, const unsigned n) {
+    return (int) get_bits_subexp_u(c, ref + (1 << n), 2 << n) - (1 << n);
+}
+
+const uint8_t *flush_get_bits(GetBits *c) {
+    c->bits_left = 0;
+    c->state = 0;
+    return c->ptr;
+}
diff --git a/src/getbits.h b/src/getbits.h
new file mode 100644
index 0000000..1a2c940
--- /dev/null
+++ b/src/getbits.h
@@ -0,0 +1,49 @@
+/*
+ * Copyright © 2018, VideoLAN and dav1d authors
+ * Copyright © 2018, Two Orioles, LLC
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright notice, this
+ *    list of conditions and the following disclaimer.
+ *
+ * 2. Redistributions in binary form must reproduce the above copyright notice,
+ *    this list of conditions and the following disclaimer in the documentation
+ *    and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
+ * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#ifndef __DAV1D_SRC_GETBITS_H__
+#define __DAV1D_SRC_GETBITS_H__
+
+#include <stddef.h>
+#include <stdint.h>
+
+typedef struct GetBits {
+    int error, eof;
+    uint64_t state;
+    unsigned bits_left;
+    const uint8_t *ptr, *ptr_start, *ptr_end;
+} GetBits;
+
+void init_get_bits(GetBits *c, const uint8_t *data, size_t sz);
+unsigned get_bits(GetBits *c, unsigned n);
+int get_sbits(GetBits *c, unsigned n);
+unsigned get_uniform(GetBits *c, unsigned range);
+unsigned get_vlc(GetBits *c);
+int get_bits_subexp(GetBits *c, int ref, unsigned n);
+const uint8_t *flush_get_bits(GetBits *c);
+
+#endif /* __DAV1D_SRC_GETBITS_H__ */
diff --git a/src/internal.h b/src/internal.h
new file mode 100644
index 0000000..ffb2b64
--- /dev/null
+++ b/src/internal.h
@@ -0,0 +1,275 @@
+/*
+ * Copyright © 2018, VideoLAN and dav1d authors
+ * Copyright © 2018, Two Orioles, LLC
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright notice, this
+ *    list of conditions and the following disclaimer.
+ *
+ * 2. Redistributions in binary form must reproduce the above copyright notice,
+ *    this list of conditions and the following disclaimer in the documentation
+ *    and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
+ * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#ifndef __DAV1D_SRC_INTERNAL_H__
+#define __DAV1D_SRC_INTERNAL_H__
+
+#include <pthread.h>
+#include <stdatomic.h>
+
+#include "dav1d/data.h"
+
+typedef struct Dav1dFrameContext Dav1dFrameContext;
+typedef struct Dav1dTileState Dav1dTileState;
+typedef struct Dav1dTileContext Dav1dTileContext;
+
+#include "common/attributes.h"
+
+#include "src/cdef.h"
+#include "src/cdf.h"
+#include "src/env.h"
+#include "src/intra_edge.h"
+#include "src/ipred.h"
+#include "src/itx.h"
+#include "src/levels.h"
+#include "src/lf_mask.h"
+#include "src/loopfilter.h"
+#include "src/looprestoration.h"
+#include "src/mc.h"
+#include "src/msac.h"
+#include "src/picture.h"
+#include "src/recon.h"
+#include "src/ref_mvs.h"
+
+typedef struct Dav1dDSPContext {
+    Dav1dIntraPredDSPContext ipred;
+    Dav1dMCDSPContext mc;
+    Dav1dInvTxfmDSPContext itx;
+    Dav1dLoopFilterDSPContext lf;
+    Dav1dCdefDSPContext cdef;
+    Dav1dLoopRestorationDSPContext lr;
+} Dav1dDSPContext;
+
+struct Dav1dContext {
+    Dav1dFrameContext *fc;
+    int n_fc;
+
+    // cache of OBUs that make up a single frame before we submit them
+    // to a frame worker to be decoded
+    struct {
+        Dav1dData data;
+        int start, end;
+    } tile[256];
+    int n_tile_data, have_seq_hdr, have_frame_hdr;
+    unsigned tile_mask;
+    Av1SequenceHeader seq_hdr; // FIXME make ref?
+    Av1FrameHeader frame_hdr; // FIXME make ref?
+
+    // decoded output picture queue
+    Dav1dPicture out;
+    struct {
+        Dav1dThreadPicture *out_delayed;
+        unsigned next;
+    } frame_thread;
+
+    // reference/entropy state
+    struct {
+        Dav1dThreadPicture p;
+        Dav1dRef *segmap;
+        Av1SegmentationDataSet seg_data;
+        Dav1dRef *refmvs;
+        unsigned refpoc[7];
+        WarpedMotionParams gmv[7];
+        Av1LoopfilterModeRefDeltas lf_mode_ref_deltas;
+        Av1FilmGrainData film_grain;
+    } refs[8];
+    CdfThreadContext cdf[8];
+
+    Dav1dDSPContext dsp[3 /* 8, 10, 12 bits/component */];
+
+    // tree to keep track of which edges are available
+    struct {
+        EdgeNode *root[2 /* BL_128X128 vs. BL_64X64 */];
+        EdgeBranch branch_sb128[1 + 4 + 16 + 64];
+        EdgeBranch branch_sb64[1 + 4 + 16];
+        EdgeTip tip_sb128[256];
+        EdgeTip tip_sb64[64];
+    } intra_edge;
+};
+
+struct Dav1dFrameContext {
+    Av1SequenceHeader seq_hdr;
+    Av1FrameHeader frame_hdr;
+    Dav1dThreadPicture refp[7], cur;
+    Dav1dRef *mvs_ref;
+    refmvs *mvs, *ref_mvs[7];
+    Dav1dRef *ref_mvs_ref[7];
+    Dav1dRef *cur_segmap_ref, *prev_segmap_ref;
+    uint8_t *cur_segmap;
+    const uint8_t *prev_segmap;
+    unsigned refpoc[7], refrefpoc[7][7];
+    CdfThreadContext in_cdf, out_cdf;
+    struct {
+        Dav1dData data;
+        int start, end;
+    } tile[256];
+    int n_tile_data;
+
+    const Dav1dContext *c;
+    Dav1dTileContext *tc;
+    int n_tc;
+    Dav1dTileState *ts;
+    int n_ts;
+    const Dav1dDSPContext *dsp;
+    struct {
+        recon_b_intra_fn recon_b_intra;
+        recon_b_inter_fn recon_b_inter;
+        filter_sbrow_fn filter_sbrow;
+        backup_ipred_edge_fn backup_ipred_edge;
+        read_coef_blocks_fn read_coef_blocks;
+    } bd_fn;
+
+    int ipred_edge_sz;
+    pixel *ipred_edge[3];
+    ptrdiff_t b4_stride;
+    int bw, bh, sb128w, sb128h, sbh, sb_shift, sb_step;
+    uint16_t dq[NUM_SEGMENTS][3 /* plane */][2 /* dc/ac */];
+    const uint8_t *qm[2 /* is_1d */][N_RECT_TX_SIZES][3 /* plane */];
+    BlockContext *a;
+    int a_sz /* w*tile_rows */;
+    AV1_COMMON *libaom_cm; // FIXME
+    uint8_t jnt_weights[7][7];
+
+    struct {
+        struct thread_data td;
+        int pass, die;
+        // indexed using t->by * f->b4_stride + t->bx
+        Av1Block *b;
+        struct CodedBlockInfo {
+            int16_t eob[3 /* plane */];
+            uint8_t txtp[3 /* plane */];
+        } *cbi;
+        int8_t *txtp;
+        // indexed using (t->by >> 1) * (f->b4_stride >> 1) + (t->bx >> 1)
+        uint16_t (*pal)[3 /* plane */][8 /* idx */];
+        // iterated over inside tile state
+        uint8_t *pal_idx;
+        coef *cf;
+        // start offsets per tile
+        int *tile_start_off;
+    } frame_thread;
+
+    // loopfilter
+    struct {
+        uint8_t (*level)[4];
+        Av1Filter *mask;
+        int top_pre_cdef_toggle;
+        int mask_sz /* w*h */, line_sz /* w */, re_sz /* h */;
+        Av1FilterLUT lim_lut;
+        int last_sharpness;
+        uint8_t lvl[8 /* seg_id */][4 /* dir */][8 /* ref */][2 /* is_gmv */];
+        uint8_t *tx_lpf_right_edge[2];
+        pixel *cdef_line;
+        pixel *cdef_line_ptr[2 /* pre, post */][3 /* plane */][2 /* y */];
+        pixel *lr_lpf_line;
+        pixel *lr_lpf_line_ptr[3 /* plane */];
+
+        // in-loop filter per-frame state keeping
+        int tile_row; // for carry-over at tile row edges
+        pixel *p[3];
+        Av1Filter *mask_ptr, *prev_mask_ptr;
+    } lf;
+
+    // threading (refer to tc[] for per-thread things)
+    struct FrameTileThreadData {
+        uint64_t available;
+        pthread_mutex_t lock;
+        pthread_cond_t cond, icond;
+        int tasks_left, num_tasks;
+        int (*task_idx_to_sby_and_tile_idx)[2];
+        int titsati_sz, titsati_init[2];
+    } tile_thread;
+};
+
+struct Dav1dTileState {
+    struct {
+        int col_start, col_end, row_start, row_end; // in 4px units
+        int col, row; // in tile units
+    } tiling;
+
+    CdfContext cdf;
+    MsacContext msac;
+
+    atomic_int progress; // in sby units
+    struct {
+        pthread_mutex_t lock;
+        pthread_cond_t cond;
+    } tile_thread;
+    struct {
+        uint8_t *pal_idx;
+        coef *cf;
+    } frame_thread;
+
+    uint16_t dqmem[NUM_SEGMENTS][3 /* plane */][2 /* dc/ac */];
+    const uint16_t (*dq)[3][2];
+    int last_qidx;
+
+    int8_t last_delta_lf[4];
+    uint8_t lflvlmem[8 /* seg_id */][4 /* dir */][8 /* ref */][2 /* is_gmv */];
+    const uint8_t (*lflvl)[4][8][2];
+
+    Av1RestorationUnit *lr_ref[3];
+};
+
+struct Dav1dTileContext {
+    const Dav1dFrameContext *f;
+    Dav1dTileState *ts;
+    int bx, by;
+    BlockContext l, *a;
+    coef *cf;
+    pixel *emu_edge; // stride=160
+    // FIXME types can be changed to pixel (and dynamically allocated)
+    // which would make copy/assign operations slightly faster?
+    uint16_t al_pal[2 /* a/l */][32 /* bx/y4 */][3 /* plane */][8 /* palette_idx */];
+    uint16_t pal[3 /* plane */][8 /* palette_idx */];
+    uint8_t pal_sz_uv[2 /* a/l */][32 /* bx4/by4 */];
+    uint8_t txtp_map[32 * 32]; // inter-only
+    WarpedMotionParams warpmv;
+    union {
+        void *mem;
+        uint8_t *pal_idx;
+        int16_t *ac;
+        pixel *interintra, *lap;
+        coef *compinter;
+    } scratch;
+    ALIGN(uint8_t scratch_seg_mask[128 * 128], 32);
+
+    Av1Filter *lf_mask;
+    int8_t *cur_sb_cdef_idx_ptr;
+    // for chroma sub8x8, we need to know the filter for all 4 subblocks in
+    // a 4x4 area, but the top/left one can go out of cache already, so this
+    // keeps it accessible
+    enum Filter2d tl_4x4_filter;
+
+    struct {
+        struct thread_data td;
+        struct FrameTileThreadData *fttd;
+        int die;
+    } tile_thread;
+};
+
+#endif /* __DAV1D_SRC_INTERNAL_H__ */
diff --git a/src/intra_edge.c b/src/intra_edge.c
new file mode 100644
index 0000000..e2ec080
--- /dev/null
+++ b/src/intra_edge.c
@@ -0,0 +1,166 @@
+/*
+ * Copyright © 2018, VideoLAN and dav1d authors
+ * Copyright © 2018, Two Orioles, LLC
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright notice, this
+ *    list of conditions and the following disclaimer.
+ *
+ * 2. Redistributions in binary form must reproduce the above copyright notice,
+ *    this list of conditions and the following disclaimer in the documentation
+ *    and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
+ * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#include "config.h"
+
+#include <assert.h>
+
+#include "src/intra_edge.h"
+#include "src/levels.h"
+
+struct ModeSelMem {
+    EdgeBranch *nwc[3 /* 64x64, 32x32, 16x16 */];
+    EdgeTip *nt;
+};
+
+static void init_edges(EdgeNode *const node,
+                       const enum BlockLevel bl,
+                       const enum EdgeFlags edge_flags)
+{
+    node->o = edge_flags;
+
+#define ALL_FL(t) (EDGE_I444_##t | EDGE_I422_##t | EDGE_I420_##t)
+    if (bl == BL_8X8) {
+        EdgeTip *const nt = (EdgeTip *) node;
+
+        node->h[0] = edge_flags | ALL_FL(LEFT_HAS_BOTTOM);
+        node->h[1] = edge_flags & (ALL_FL(LEFT_HAS_BOTTOM) |
+                                   EDGE_I420_TOP_HAS_RIGHT);
+
+        node->v[0] = edge_flags | ALL_FL(TOP_HAS_RIGHT);
+        node->v[1] = edge_flags & (ALL_FL(TOP_HAS_RIGHT) |
+                                   EDGE_I420_LEFT_HAS_BOTTOM |
+                                   EDGE_I422_LEFT_HAS_BOTTOM);
+
+        nt->split[0] = ALL_FL(TOP_HAS_RIGHT) | ALL_FL(LEFT_HAS_BOTTOM);
+        nt->split[1] = (edge_flags & ALL_FL(TOP_HAS_RIGHT)) |
+                       EDGE_I422_LEFT_HAS_BOTTOM;
+        nt->split[2] = edge_flags | EDGE_I444_TOP_HAS_RIGHT;
+        nt->split[3] = edge_flags & (EDGE_I420_TOP_HAS_RIGHT |
+                                     EDGE_I420_LEFT_HAS_BOTTOM |
+                                     EDGE_I422_LEFT_HAS_BOTTOM);
+    } else {
+        EdgeBranch *const nwc = (EdgeBranch *) node;
+
+        node->h[0] = edge_flags | ALL_FL(LEFT_HAS_BOTTOM);
+        node->h[1] = edge_flags & ALL_FL(LEFT_HAS_BOTTOM);
+
+        node->v[0] = edge_flags | ALL_FL(TOP_HAS_RIGHT);
+        node->v[1] = edge_flags & ALL_FL(TOP_HAS_RIGHT);
+
+        nwc->h4[0] = edge_flags | ALL_FL(LEFT_HAS_BOTTOM);
+        nwc->h4[1] =
+        nwc->h4[2] = ALL_FL(LEFT_HAS_BOTTOM);
+        nwc->h4[3] = edge_flags & ALL_FL(LEFT_HAS_BOTTOM);
+        if (bl == BL_16X16)
+            nwc->h4[1] |= edge_flags & EDGE_I420_TOP_HAS_RIGHT;
+
+        nwc->v4[0] = edge_flags | ALL_FL(TOP_HAS_RIGHT);
+        nwc->v4[1] =
+        nwc->v4[2] = ALL_FL(TOP_HAS_RIGHT);
+        nwc->v4[3] = edge_flags & ALL_FL(TOP_HAS_RIGHT);
+        if (bl == BL_16X16)
+            nwc->v4[1] |= edge_flags & (EDGE_I420_LEFT_HAS_BOTTOM |
+                                        EDGE_I422_LEFT_HAS_BOTTOM);
+
+        nwc->tls[0] = ALL_FL(TOP_HAS_RIGHT) | ALL_FL(LEFT_HAS_BOTTOM);
+        nwc->tls[1] = edge_flags & ALL_FL(LEFT_HAS_BOTTOM);
+        nwc->tls[2] = edge_flags & ALL_FL(TOP_HAS_RIGHT);
+
+        nwc->trs[0] = edge_flags | ALL_FL(TOP_HAS_RIGHT);
+        nwc->trs[1] = edge_flags | ALL_FL(LEFT_HAS_BOTTOM);
+        nwc->trs[2] = 0;
+
+        nwc->tts[0] = ALL_FL(TOP_HAS_RIGHT) | ALL_FL(LEFT_HAS_BOTTOM);
+        nwc->tts[1] = edge_flags & ALL_FL(TOP_HAS_RIGHT);
+        nwc->tts[2] = edge_flags & ALL_FL(LEFT_HAS_BOTTOM);
+
+        nwc->tbs[0] = edge_flags | ALL_FL(LEFT_HAS_BOTTOM);
+        nwc->tbs[1] = edge_flags | ALL_FL(TOP_HAS_RIGHT);
+        nwc->tbs[2] = 0;
+    }
+}
+
+static void init_mode_node(EdgeBranch *const nwc,
+                           const enum BlockLevel bl,
+                           struct ModeSelMem *const mem,
+                           const int top_has_right,
+                           const int left_has_bottom)
+{
+    int n;
+
+    init_edges(&nwc->node, bl,
+               (top_has_right ? ALL_FL(TOP_HAS_RIGHT) : 0) |
+               (left_has_bottom ? ALL_FL(LEFT_HAS_BOTTOM) : 0));
+    if (bl == BL_16X16) {
+        for (n = 0; n < 4; n++) {
+            EdgeTip *const nt = mem->nt++;
+            nwc->split[n] = &nt->node;
+            init_edges(&nt->node, bl + 1,
+                       ((n == 3 || (n == 1 && !top_has_right)) ? 0 :
+                        ALL_FL(TOP_HAS_RIGHT)) |
+                       (!(n == 0 || (n == 2 && left_has_bottom)) ? 0 :
+                        ALL_FL(LEFT_HAS_BOTTOM)));
+        }
+    } else {
+        for (n = 0; n < 4; n++) {
+            EdgeBranch *const nwc_child = mem->nwc[bl]++;
+            nwc->split[n] = &nwc_child->node;
+            init_mode_node(nwc_child, bl + 1, mem,
+                           !(n == 3 || (n == 1 && !top_has_right)),
+                           n == 0 || (n == 2 && left_has_bottom));
+        }
+    }
+}
+
+void init_mode_tree(EdgeNode *const root_node, EdgeTip *const nt,
+                    const int allow_sb128)
+{
+    EdgeBranch *const root = (EdgeBranch *) root_node;
+    struct ModeSelMem mem;
+
+    if (allow_sb128) {
+        mem.nwc[BL_128X128] = &root[1];
+        mem.nwc[BL_64X64] = &root[1 + 4];
+        mem.nwc[BL_32X32] = &root[1 + 4 + 16];
+        mem.nt = nt;
+        init_mode_node(root, BL_128X128, &mem, 1, 0);
+        assert(mem.nwc[BL_128X128] == &root[1 + 4]);
+        assert(mem.nwc[BL_64X64] == &root[1 + 4 + 16]);
+        assert(mem.nwc[BL_32X32] == &root[1 + 4 + 16 + 64]);
+        assert(mem.nt == &nt[256]);
+    } else {
+        mem.nwc[BL_128X128] = NULL;
+        mem.nwc[BL_64X64] = &root[1];
+        mem.nwc[BL_32X32] = &root[1 + 4];
+        mem.nt = nt;
+        init_mode_node(root, BL_64X64, &mem, 1, 0);
+        assert(mem.nwc[BL_64X64] == &root[1 + 4]);
+        assert(mem.nwc[BL_32X32] == &root[1 + 4 + 16]);
+        assert(mem.nt == &nt[64]);
+    }
+}
diff --git a/src/intra_edge.h b/src/intra_edge.h
new file mode 100644
index 0000000..aa0181c
--- /dev/null
+++ b/src/intra_edge.h
@@ -0,0 +1,57 @@
+/*
+ * Copyright © 2018, VideoLAN and dav1d authors
+ * Copyright © 2018, Two Orioles, LLC
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright notice, this
+ *    list of conditions and the following disclaimer.
+ *
+ * 2. Redistributions in binary form must reproduce the above copyright notice,
+ *    this list of conditions and the following disclaimer in the documentation
+ *    and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
+ * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#ifndef __DAV1D_SRC_INTRA_EDGE_H__
+#define __DAV1D_SRC_INTRA_EDGE_H__
+
+enum EdgeFlags {
+    EDGE_I444_TOP_HAS_RIGHT = 1 << 0,
+    EDGE_I422_TOP_HAS_RIGHT = 1 << 1,
+    EDGE_I420_TOP_HAS_RIGHT = 1 << 2,
+    EDGE_I444_LEFT_HAS_BOTTOM = 1 << 3,
+    EDGE_I422_LEFT_HAS_BOTTOM = 1 << 4,
+    EDGE_I420_LEFT_HAS_BOTTOM = 1 << 5,
+};
+
+typedef struct EdgeNode EdgeNode;
+struct EdgeNode {
+    enum EdgeFlags o, h[2], v[2];
+};
+typedef struct EdgeTip {
+    EdgeNode node;
+    enum EdgeFlags split[4];
+} EdgeTip;
+typedef struct EdgeBranch {
+    EdgeNode node;
+    enum EdgeFlags tts[3], tbs[3], tls[3], trs[3], h4[4], v4[4];
+    EdgeNode *split[4];
+} EdgeBranch;
+
+void init_mode_tree(EdgeNode *const root, EdgeTip *const nt,
+                    const int allow_sb128);
+
+#endif /* __DAV1D_SRC_INTRA_EDGE_H__ */
diff --git a/src/ipred.c b/src/ipred.c
new file mode 100644
index 0000000..1c50f45
--- /dev/null
+++ b/src/ipred.c
@@ -0,0 +1,1010 @@
+/*
+ * Copyright © 2018, VideoLAN and dav1d authors
+ * Copyright © 2018, Two Orioles, LLC
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright notice, this
+ *    list of conditions and the following disclaimer.
+ *
+ * 2. Redistributions in binary form must reproduce the above copyright notice,
+ *    this list of conditions and the following disclaimer in the documentation
+ *    and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
+ * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#include "config.h"
+
+#include <assert.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include "common/intops.h"
+
+#include "src/ipred.h"
+
+#define sz_grid(l_fn) \
+l_fn( 4,  4); \
+l_fn( 4,  8); \
+l_fn( 4, 16); \
+l_fn( 8,  4); \
+l_fn( 8,  8); \
+l_fn( 8, 16); \
+l_fn( 8, 32); \
+l_fn(16,  4); \
+l_fn(16,  8); \
+l_fn(16, 16); \
+l_fn(16, 32); \
+l_fn(16, 64); \
+l_fn(32,  8); \
+l_fn(32, 16); \
+l_fn(32, 32); \
+l_fn(32, 64); \
+l_fn(64, 16); \
+l_fn(64, 32); \
+l_fn(64, 64)
+
+static __attribute__((noinline)) void
+splat_dc_c(pixel *dst, const ptrdiff_t stride,
+           const int w, const int h, const unsigned dc)
+{
+    assert(dc <= (1 << BITDEPTH) - 1);
+#if BITDEPTH == 8
+    if (w > 4) {
+        const uint64_t dcN = dc * 0x0101010101010101ULL;
+        for (int y = 0; y < h; y++) {
+            for (int x = 0; x < w; x += sizeof(dcN))
+                *((uint64_t *) &dst[x]) = dcN;
+            dst += PXSTRIDE(stride);
+        }
+    } else {
+        const unsigned dcN = dc * 0x01010101U;
+        for (int y = 0; y < h; y++) {
+            for (int x = 0; x < w; x += sizeof(dcN))
+                *((unsigned *) &dst[x]) = dcN;
+            dst += PXSTRIDE(stride);
+        }
+    }
+#else
+    const uint64_t dcN = dc * 0x0001000100010001ULL;
+    for (int y = 0; y < h; y++) {
+        for (int x = 0; x < w; x += sizeof(dcN) >> 1)
+            *((uint64_t *) &dst[x]) = dcN;
+        dst += PXSTRIDE(stride);
+    }
+#endif
+}
+
+#define dc_lfn(w, h, dir, dc_gen) \
+static void dc##dir##_##w##x##h##_c(pixel *dst, const ptrdiff_t stride, \
+                                    const pixel *const topleft, const int a) \
+{ \
+    dc_gen; \
+    splat_dc_c(dst, stride, w, h, dc); \
+}
+
+#define dc1d_lfns(width, height, sh1, sh2) \
+dc_lfn(width, height, top, unsigned dc = width >> 1; \
+                           for (int i = 0; i < width; i++) \
+                               dc += topleft[1 + i]; \
+                           dc >>= sh1); \
+dc_lfn(width, height, left, unsigned dc = height >> 1; \
+                            for (int i = 0; i < height; i++) \
+                                dc += topleft[-(1 + i)]; \
+                            dc >>= sh2)
+
+dc1d_lfns( 4,  4, 2, 2);
+dc1d_lfns( 4,  8, 2, 3);
+dc1d_lfns( 4, 16, 2, 4);
+dc1d_lfns( 8,  4, 3, 2);
+dc1d_lfns( 8,  8, 3, 3);
+dc1d_lfns( 8, 16, 3, 4);
+dc1d_lfns( 8, 32, 3, 5);
+dc1d_lfns(16,  4, 4, 2);
+dc1d_lfns(16,  8, 4, 3);
+dc1d_lfns(16, 16, 4, 4);
+dc1d_lfns(16, 32, 4, 5);
+dc1d_lfns(16, 64, 4, 6);
+dc1d_lfns(32,  8, 5, 3);
+dc1d_lfns(32, 16, 5, 4);
+dc1d_lfns(32, 32, 5, 5);
+dc1d_lfns(32, 64, 5, 6);
+dc1d_lfns(64, 16, 6, 4);
+dc1d_lfns(64, 32, 6, 5);
+dc1d_lfns(64, 64, 6, 6);
+
+#define dc2d_lfn(width, height, dc_gen) \
+dc_lfn(width, height,, unsigned dc = (width + height) >> 1; \
+                       for (int i = 0; i < width; i++) \
+                           dc += topleft[i + 1]; \
+                       for (int i = 0; i < height; i++) \
+                           dc += topleft[-(i + 1)]; \
+                       dc_gen)
+
+dc2d_lfn( 4,  4, dc >>= 3);
+dc2d_lfn( 4,  8, dc = iclip_pixel(0x5556 * dc >> 18));
+dc2d_lfn( 4, 16, dc = iclip_pixel(0x3334 * dc >> 18));
+dc2d_lfn( 8,  4, dc = iclip_pixel(0x5556 * dc >> 18));
+dc2d_lfn( 8,  8, dc >>= 4);
+dc2d_lfn( 8, 16, dc = iclip_pixel(0x5556 * dc >> 19));
+dc2d_lfn( 8, 32, dc = iclip_pixel(0x3334 * dc >> 19));
+dc2d_lfn(16,  4, dc = iclip_pixel(0x3334 * dc >> 18));
+dc2d_lfn(16,  8, dc = iclip_pixel(0x5556 * dc >> 19));
+dc2d_lfn(16, 16, dc >>= 5);
+dc2d_lfn(16, 32, dc = iclip_pixel(0x5556 * dc >> 20));
+dc2d_lfn(16, 64, dc = iclip_pixel(0x3334 * dc >> 20));
+dc2d_lfn(32,  8, dc = iclip_pixel(0x3334 * dc >> 19));
+dc2d_lfn(32, 16, dc = iclip_pixel(0x5556 * dc >> 20));
+dc2d_lfn(32, 32, dc >>= 6);
+dc2d_lfn(32, 64, dc = iclip_pixel(0x5556 * dc >> 21));
+dc2d_lfn(64, 16, dc = iclip_pixel(0x3334 * dc >> 20));
+dc2d_lfn(64, 32, dc = iclip_pixel(0x5556 * dc >> 21));
+dc2d_lfn(64, 64, dc >>= 7);
+
+#define dc128_lfn(width, height) \
+dc_lfn(width, height, 128, const unsigned dc = (1 << BITDEPTH) >> 1)
+
+sz_grid(dc128_lfn);
+
+static __attribute__((noinline)) void
+v_c(pixel *dst, const ptrdiff_t stride,
+    const pixel *const topleft, const int width, const int height)
+{
+    for (int y = 0; y < height; y++) {
+        pixel_copy(dst, topleft + 1, width);
+        dst += PXSTRIDE(stride);
+    }
+}
+
+#define v_lfn(width, height) \
+static void v_##width##x##height##_##c(pixel *dst, const ptrdiff_t stride, \
+                                       const pixel *const topleft, const int a) \
+{ \
+    v_c(dst, stride, topleft, width, height); \
+}
+
+sz_grid(v_lfn);
+
+static __attribute__((noinline)) void
+h_c(pixel *dst, const ptrdiff_t stride,
+    const pixel *const topleft, const int width, const int height)
+{
+    for (int y = 0; y < height; y++) {
+        pixel_set(dst, topleft[-(1 + y)], width);
+        dst += PXSTRIDE(stride);
+    }
+}
+
+#define h_lfn(width, height) \
+static void h_##width##x##height##_c(pixel *dst, const ptrdiff_t stride, \
+                                     const pixel *const topleft, const int a) \
+{ \
+    h_c(dst, stride, topleft, width, height); \
+}
+
+sz_grid(h_lfn);
+
+static __attribute__((noinline)) void
+paeth_c(pixel *dst, const ptrdiff_t stride, const pixel *const tl_ptr,
+        const int width, const int height)
+{
+    const int topleft = tl_ptr[0];
+    for (int y = 0; y < height; y++) {
+        const int left = tl_ptr[-(y + 1)];
+        for (int x = 0; x < width; x++) {
+            const int top = tl_ptr[1 + x];
+            const int base = left + top - topleft;
+            const int ldiff = abs(left - base);
+            const int tdiff = abs(top - base);
+            const int tldiff = abs(topleft - base);
+
+            dst[x] = ldiff <= tdiff && ldiff <= tldiff ? left :
+                     tdiff <= tldiff ? top : topleft;
+        }
+        dst += PXSTRIDE(stride);
+    }
+}
+
+#define paeth_lfn(width, height) \
+static void paeth_##width##x##height##_c(pixel *dst, const ptrdiff_t stride, \
+                                         const pixel *const topleft, \
+                                         const int a) \
+{ \
+    paeth_c(dst, stride, topleft, width, height); \
+}
+
+sz_grid(paeth_lfn);
+
+static const uint8_t sm_weight_arrays[] = {
+    // Unused, because we always offset by bs, which is at least 2.
+    0, 0,
+    // bs = 2
+    255, 128,
+    // bs = 4
+    255, 149, 85, 64,
+    // bs = 8
+    255, 197, 146, 105, 73, 50, 37, 32,
+    // bs = 16
+    255, 225, 196, 170, 145, 123, 102, 84, 68, 54, 43, 33, 26, 20, 17, 16,
+    // bs = 32
+    255, 240, 225, 210, 196, 182, 169, 157, 145, 133, 122, 111, 101, 92, 83, 74,
+    66, 59, 52, 45, 39, 34, 29, 25, 21, 17, 14, 12, 10, 9, 8, 8,
+    // bs = 64
+    255, 248, 240, 233, 225, 218, 210, 203, 196, 189, 182, 176, 169, 163, 156,
+    150, 144, 138, 133, 127, 121, 116, 111, 106, 101, 96, 91, 86, 82, 77, 73, 69,
+    65, 61, 57, 54, 50, 47, 44, 41, 38, 35, 32, 29, 27, 25, 22, 20, 18, 16, 15,
+    13, 12, 10, 9, 8, 7, 6, 6, 5, 5, 4, 4, 4,
+};
+
+static __attribute__((noinline)) void
+smooth_c(pixel *dst, const ptrdiff_t stride, const pixel *const topleft,
+         const int width, const int height)
+{
+    const uint8_t *const weights_hor = &sm_weight_arrays[width];
+    const uint8_t *const weights_ver = &sm_weight_arrays[height];
+    const int right = topleft[width], bottom = topleft[-height];
+
+    for (int y = 0; y < height; y++) {
+        for (int x = 0; x < width; x++) {
+            const int pred = weights_ver[y]  * topleft[1 + x] +
+                      (256 - weights_ver[y]) * bottom +
+                             weights_hor[x]  * topleft[-(1 + y)] +
+                      (256 - weights_hor[x]) * right;
+            dst[x] = (pred + 256) >> 9;
+        }
+        dst += PXSTRIDE(stride);
+    }
+}
+
+#define smooth_lfn(width, height) \
+static void smooth_##width##x##height##_c(pixel *dst, const ptrdiff_t stride, \
+                                          const pixel *const topleft, \
+                                          const int a) \
+{ \
+    smooth_c(dst, stride, topleft, width, height); \
+}
+
+sz_grid(smooth_lfn);
+
+static __attribute__((noinline)) void
+smooth_v_c(pixel *dst, const ptrdiff_t stride, const pixel *const topleft,
+           const int width, const int height)
+{
+    const uint8_t *const weights_ver = &sm_weight_arrays[height];
+    const int bottom = topleft[-height];
+
+    for (int y = 0; y < height; y++) {
+        for (int x = 0; x < width; x++) {
+            const int pred = weights_ver[y]  * topleft[1 + x] +
+                      (256 - weights_ver[y]) * bottom;
+            dst[x] = (pred + 128) >> 8;
+        }
+        dst += PXSTRIDE(stride);
+    }
+}
+
+#define smooth_v_lfn(width, height) \
+static void smooth_v_##width##x##height##_c(pixel *dst, const ptrdiff_t stride, \
+                                            const pixel *const topleft, \
+                                            const int a) \
+{ \
+    smooth_v_c(dst, stride, topleft, width, height); \
+}
+
+sz_grid(smooth_v_lfn);
+
+static __attribute__((noinline)) void
+smooth_h_c(pixel *dst, const ptrdiff_t stride, const pixel *const topleft,
+           const int width, const int height)
+{
+    const uint8_t *const weights_hor = &sm_weight_arrays[width];
+    const int right = topleft[width];
+
+    for (int y = 0; y < height; y++) {
+        for (int x = 0; x < width; x++) {
+            const int pred = weights_hor[x]  * topleft[-(y + 1)] +
+                      (256 - weights_hor[x]) * right;
+            dst[x] = (pred + 128) >> 8;
+        }
+        dst += PXSTRIDE(stride);
+    }
+}
+
+#define smooth_h_lfn(width, height) \
+static void smooth_h_##width##x##height##_c(pixel *dst, const ptrdiff_t stride, \
+                                            const pixel *const topleft, \
+                                            const int a) \
+{ \
+    smooth_h_c(dst, stride, topleft, width, height); \
+}
+
+sz_grid(smooth_h_lfn);
+
+static const int16_t dr_intra_derivative[90] = {
+  // More evenly spread out angles and limited to 10-bit
+  // Values that are 0 will never be used
+  //                    Approx angle
+  0,    0, 0,        //
+  1023, 0, 0,        // 3, ...
+  547,  0, 0,        // 6, ...
+  372,  0, 0, 0, 0,  // 9, ...
+  273,  0, 0,        // 14, ...
+  215,  0, 0,        // 17, ...
+  178,  0, 0,        // 20, ...
+  151,  0, 0,        // 23, ... (113 & 203 are base angles)
+  132,  0, 0,        // 26, ...
+  116,  0, 0,        // 29, ...
+  102,  0, 0, 0,     // 32, ...
+  90,   0, 0,        // 36, ...
+  80,   0, 0,        // 39, ...
+  71,   0, 0,        // 42, ...
+  64,   0, 0,        // 45, ... (45 & 135 are base angles)
+  57,   0, 0,        // 48, ...
+  51,   0, 0,        // 51, ...
+  45,   0, 0, 0,     // 54, ...
+  40,   0, 0,        // 58, ...
+  35,   0, 0,        // 61, ...
+  31,   0, 0,        // 64, ...
+  27,   0, 0,        // 67, ... (67 & 157 are base angles)
+  23,   0, 0,        // 70, ...
+  19,   0, 0,        // 73, ...
+  15,   0, 0, 0, 0,  // 76, ...
+  11,   0, 0,        // 81, ...
+  7,    0, 0,        // 84, ...
+  3,    0, 0,        // 87, ...
+};
+
+static int get_filter_strength(const unsigned blk_wh, const unsigned d,
+                               const int type)
+{
+    int strength = 0;
+
+    if (type == 0) {
+        if (blk_wh <= 8) {
+            if (d >= 56) strength = 1;
+        } else if (blk_wh <= 12) {
+            if (d >= 40) strength = 1;
+        } else if (blk_wh <= 16) {
+            if (d >= 40) strength = 1;
+        } else if (blk_wh <= 24) {
+            if (d >= 8) strength = 1;
+            if (d >= 16) strength = 2;
+            if (d >= 32) strength = 3;
+        } else if (blk_wh <= 32) {
+            if (d >= 1) strength = 1;
+            if (d >= 4) strength = 2;
+            if (d >= 32) strength = 3;
+        } else {
+            if (d >= 1) strength = 3;
+        }
+    } else {
+        if (blk_wh <= 8) {
+            if (d >= 40) strength = 1;
+            if (d >= 64) strength = 2;
+        } else if (blk_wh <= 16) {
+            if (d >= 20) strength = 1;
+            if (d >= 48) strength = 2;
+        } else if (blk_wh <= 24) {
+            if (d >= 4) strength = 3;
+        } else {
+            if (d >= 1) strength = 3;
+        }
+    }
+
+    return strength;
+}
+
+static void filter_edge(pixel *const out, const int sz,
+                        const pixel *const in, const int from, const int to,
+                        const unsigned strength)
+{
+    const uint8_t kernel[3][5] = {
+        { 0, 4, 8, 4, 0 },
+        { 0, 5, 6, 5, 0 },
+        { 2, 4, 4, 4, 2 }
+    };
+
+    assert(strength > 0);
+    for (int i = 0; i < sz; i++) {
+        int s = 0;
+        for (int j = 0; j < 5; j++)
+            s += in[iclip(i - 2 + j, from, to - 1)] * kernel[strength - 1][j];
+        out[i] = (s + 8) >> 4;
+    }
+}
+
+static int get_upsample(const int blk_wh, const unsigned d, const int type) {
+    if (d >= 40) return 0;
+    return type ? (blk_wh <= 8) : (blk_wh <= 16);
+}
+
+static void upsample_edge(pixel *const out, const int hsz,
+                          const pixel *const in, const int from, const int to)
+{
+    const int8_t kernel[4] = { -1, 9, 9, -1 };
+    int i;
+    for (i = 0; i < hsz - 1; i++) {
+        out[i * 2] = in[iclip(i, from, to - 1)];
+
+        int s = 0;
+        for (int j = 0; j < 4; j++)
+            s += in[iclip(i + j - 1, from, to - 1)] * kernel[j];
+        out[i * 2 + 1] = iclip_pixel((s + 8) >> 4);
+    }
+    out[i * 2] = in[iclip(i, from, to - 1)];
+}
+
+static __attribute__((noinline)) void
+z1_c(pixel *dst, const ptrdiff_t stride, const pixel *const topleft_in,
+     int angle, const int width, const int height)
+{
+    const int is_sm = angle >> 9;
+    angle &= 511;
+    assert(angle < 90);
+    const int dx = dr_intra_derivative[angle];
+    pixel top_out[(width + height) * 2];
+    const pixel *top;
+    int max_base_x;
+    const int upsample_above = get_upsample(width + height, 90 - angle, is_sm);
+    if (upsample_above) {
+        upsample_edge(top_out, width + height,
+                      &topleft_in[1], -1, width + imin(width, height));
+        top = top_out;
+        max_base_x = 2 * (width + height) - 2;
+    } else {
+        const int filter_strength =
+            get_filter_strength(width + height, 90 - angle, is_sm);
+
+        if (filter_strength) {
+            filter_edge(top_out, width + height,
+                        &topleft_in[1], -1, width + imin(width, height),
+                        filter_strength);
+            top = top_out;
+            max_base_x = width + height - 1;
+        } else {
+            top = &topleft_in[1];
+            max_base_x = width + imin(width, height) - 1;
+        }
+    }
+    const int frac_bits = 6 - upsample_above;
+    const int base_inc = 1 << upsample_above;
+    for (int y = 0, xpos = dx; y < height;
+         y++, dst += PXSTRIDE(stride), xpos += dx)
+    {
+        int base = xpos >> frac_bits;
+        const int frac = ((xpos << upsample_above) & 0x3F) >> 1;
+
+        for (int x = 0; x < width; x++, base += base_inc) {
+            if (base < max_base_x) {
+                const int v = top[base] * (32 - frac) + top[base + 1] * frac;
+                dst[x] = iclip_pixel((v + 16) >> 5);
+            } else {
+                pixel_set(&dst[x], top[max_base_x], width - x);
+                break;
+            }
+        }
+    }
+}
+
+#define z1_lfn(width, height) \
+static void z1_##width##x##height##_c(pixel *dst, const ptrdiff_t stride, \
+                                      const pixel *const topleft, \
+                                      const int angle) \
+{ \
+    z1_c(dst, stride, topleft, angle, width, height); \
+}
+
+sz_grid(z1_lfn);
+
+static __attribute__((noinline)) void
+z2_c(pixel *dst, const ptrdiff_t stride, const pixel *const topleft_in,
+     int angle, const int width, const int height)
+{
+    const int is_sm = angle >> 9;
+    angle &= 511;
+    assert(angle > 90 && angle < 180);
+    const int dy = dr_intra_derivative[angle - 90];
+    const int dx = dr_intra_derivative[180 - angle];
+    const int upsample_left = get_upsample(width + height, 180 - angle, is_sm);
+    const int upsample_above = get_upsample(width + height, angle - 90, is_sm);
+    pixel edge[width * 2 + height * 2 + 1];
+    pixel *const topleft = &edge[height * 2];
+
+    if (upsample_above) {
+        upsample_edge(topleft, width + 1, topleft_in, 0, width + 1);
+    } else {
+        const int filter_strength =
+            get_filter_strength(width + height, angle - 90, is_sm);
+
+        if (filter_strength) {
+            filter_edge(&topleft[1], width, &topleft_in[1], -1, width,
+                        filter_strength);
+        } else {
+            pixel_copy(&topleft[1], &topleft_in[1], width);
+        }
+    }
+    if (upsample_left) {
+        upsample_edge(edge, height + 1, &topleft_in[-height], 0, height + 1);
+    } else {
+        const int filter_strength =
+            get_filter_strength(width + height, 180 - angle, is_sm);
+
+        if (filter_strength) {
+            filter_edge(&topleft[-height], height, &topleft_in[-height],
+                        0, height + 1, filter_strength);
+        } else {
+            pixel_copy(&topleft[-height], &topleft_in[-height], height);
+        }
+    }
+    *topleft = *topleft_in;
+
+    const int min_base_x = -(1 << upsample_above);
+    const int frac_bits_y = 6 - upsample_left, frac_bits_x = 6 - upsample_above;
+    const int base_inc_x = 1 << upsample_above;
+    const pixel *const left = &topleft[-(1 << upsample_left)];
+    const pixel *const top = &topleft[1 << upsample_above];
+    for (int y = 0, xpos = -dx; y < height;
+         y++, xpos -= dx, dst += PXSTRIDE(stride))
+    {
+        int base_x = xpos >> frac_bits_x;
+        const int frac_x = ((xpos * (1 << upsample_above)) & 0x3F) >> 1;
+
+        for (int x = 0, ypos = (y << 6) - dy; x < width;
+             x++, base_x += base_inc_x, ypos -= dy)
+        {
+            int v;
+
+            if (base_x >= min_base_x) {
+                v = top[base_x] * (32 - frac_x) + top[base_x + 1] * frac_x;
+            } else {
+                const int base_y = ypos >> frac_bits_y;
+                assert(base_y >= -(1 << upsample_left));
+                const int frac_y = ((ypos * (1 << upsample_left)) & 0x3F) >> 1;
+                v = left[-base_y] * (32 - frac_y) + left[-(base_y + 1)] * frac_y;
+            }
+            dst[x] = iclip_pixel((v + 16) >> 5);
+        }
+    }
+}
+
+#define z2_lfn(width, height) \
+static void z2_##width##x##height##_c(pixel *dst, const ptrdiff_t stride, \
+                                      const pixel *const topleft, \
+                                      const int angle) \
+{ \
+    z2_c(dst, stride, topleft, angle, width, height); \
+}
+
+sz_grid(z2_lfn);
+
+static __attribute__((noinline)) void
+z3_c(pixel *dst, const ptrdiff_t stride, const pixel *const topleft_in,
+     int angle, const int width, const int height)
+{
+    const int is_sm = angle >> 9;
+    angle &= 511;
+    assert(angle > 180);
+    const int dy = dr_intra_derivative[270 - angle];
+    pixel left_out[(width + height) * 2];
+    const pixel *left;
+    int max_base_y;
+    const int upsample_left = get_upsample(width + height, angle - 180, is_sm);
+    if (upsample_left) {
+        upsample_edge(left_out, width + height,
+                      &topleft_in[-(width + height)],
+                      imax(width - height, 0), width + height + 1);
+        left = &left_out[2 * (width + height) - 2];
+        max_base_y = 2 * (width + height) - 2;
+    } else {
+        const int filter_strength =
+            get_filter_strength(width + height, angle - 180, is_sm);
+
+        if (filter_strength) {
+            filter_edge(left_out, width + height,
+                        &topleft_in[-(width + height)],
+                        imax(width - height, 0), width + height + 1,
+                        filter_strength);
+            left = &left_out[width + height - 1];
+            max_base_y = width + height - 1;
+        } else {
+            left = &topleft_in[-1];
+            max_base_y = height + imin(width, height) - 1;
+        }
+    }
+    const int frac_bits = 6 - upsample_left;
+    const int base_inc = 1 << upsample_left;
+    for (int x = 0, ypos = dy; x < width; x++, ypos += dy) {
+        int base = ypos >> frac_bits;
+        const int frac = ((ypos << upsample_left) & 0x3F) >> 1;
+
+        for (int y = 0; y < height; y++, base += base_inc) {
+            if (base < max_base_y) {
+                const int v = left[-base] * (32 - frac) +
+                              left[-(base + 1)] * frac;
+                dst[y * PXSTRIDE(stride) + x] = iclip_pixel((v + 16) >> 5);
+            } else {
+                do {
+                    dst[y * PXSTRIDE(stride) + x] = left[-max_base_y];
+                } while (++y < height);
+                break;
+            }
+        }
+    }
+}
+
+#define z3_lfn(width, height) \
+static void z3_##width##x##height##_c(pixel *dst, const ptrdiff_t stride, \
+                                      const pixel *const topleft, \
+                                      const int angle) \
+{ \
+    z3_c(dst, stride, topleft, angle, width, height); \
+}
+
+sz_grid(z3_lfn);
+
+static const int8_t av1_filter_intra_taps[5][8][8] = {
+    {
+        { -6, 10,  0,  0,  0, 12,  0, 0 },
+        { -5,  2, 10,  0,  0,  9,  0, 0 },
+        { -3,  1,  1, 10,  0,  7,  0, 0 },
+        { -3,  1,  1,  2, 10,  5,  0, 0 },
+        { -4,  6,  0,  0,  0,  2, 12, 0 },
+        { -3,  2,  6,  0,  0,  2,  9, 0 },
+        { -3,  2,  2,  6,  0,  2,  7, 0 },
+        { -3,  1,  2,  2,  6,  3,  5, 0 },
+    }, {
+        { -10, 16,  0,  0,  0, 10,  0, 0 },
+        {  -6,  0, 16,  0,  0,  6,  0, 0 },
+        {  -4,  0,  0, 16,  0,  4,  0, 0 },
+        {  -2,  0,  0,  0, 16,  2,  0, 0 },
+        { -10, 16,  0,  0,  0,  0, 10, 0 },
+        {  -6,  0, 16,  0,  0,  0,  6, 0 },
+        {  -4,  0,  0, 16,  0,  0,  4, 0 },
+        {  -2,  0,  0,  0, 16,  0,  2, 0 },
+    }, {
+        { -8, 8, 0, 0, 0, 16,  0, 0 },
+        { -8, 0, 8, 0, 0, 16,  0, 0 },
+        { -8, 0, 0, 8, 0, 16,  0, 0 },
+        { -8, 0, 0, 0, 8, 16,  0, 0 },
+        { -4, 4, 0, 0, 0,  0, 16, 0 },
+        { -4, 0, 4, 0, 0,  0, 16, 0 },
+        { -4, 0, 0, 4, 0,  0, 16, 0 },
+        { -4, 0, 0, 0, 4,  0, 16, 0 },
+    }, {
+        { -2, 8, 0, 0, 0, 10,  0, 0 },
+        { -1, 3, 8, 0, 0,  6,  0, 0 },
+        { -1, 2, 3, 8, 0,  4,  0, 0 },
+        {  0, 1, 2, 3, 8,  2,  0, 0 },
+        { -1, 4, 0, 0, 0,  3, 10, 0 },
+        { -1, 3, 4, 0, 0,  4,  6, 0 },
+        { -1, 2, 3, 4, 0,  4,  4, 0 },
+        { -1, 2, 2, 3, 4,  3,  3, 0 },
+    }, {
+        { -12, 14,  0,  0,  0, 14,  0, 0 },
+        { -10,  0, 14,  0,  0, 12,  0, 0 },
+        {  -9,  0,  0, 14,  0, 11,  0, 0 },
+        {  -8,  0,  0,  0, 14, 10,  0, 0 },
+        { -10, 12,  0,  0,  0,  0, 14, 0 },
+        {  -9,  1, 12,  0,  0,  0, 12, 0 },
+        {  -8,  0,  0, 12,  0,  1, 11, 0 },
+        {  -7,  0,  0,  1, 12,  1,  9, 0 },
+    },
+};
+
+static __attribute__((noinline)) void
+filter_intra_c(pixel *dst, const ptrdiff_t stride,
+               const pixel *const topleft_in,
+               int filt_idx, const int width, const int height)
+{
+    filt_idx &= 511;
+    assert(filt_idx < 5);
+
+    const int8_t (*const filter)[8] = av1_filter_intra_taps[filt_idx];
+    int x, y;
+    ptrdiff_t left_stride;
+    const pixel *left, *topleft, *top;
+
+    top = &topleft_in[1];
+    for (y = 0; y < height; y += 2) {
+        topleft = &topleft_in[-y];
+        left = &topleft[-1];
+        left_stride = -1;
+        for (x = 0; x < width; x += 4) {
+            const int p0 = *topleft;
+            const int p1 = top[0], p2 = top[1], p3 = top[2], p4 = top[3];
+            const int p5 = left[0 * left_stride], p6 = left[1 * left_stride];
+            pixel *ptr = &dst[x];
+            const int8_t (*flt_ptr)[8] = filter;
+
+            for (int yy = 0; yy < 2; yy++) {
+                for (int xx = 0; xx < 4; xx++, flt_ptr++) {
+                    int acc = flt_ptr[0][0] * p0 + flt_ptr[0][1] * p1 +
+                              flt_ptr[0][2] * p2 + flt_ptr[0][3] * p3 +
+                              flt_ptr[0][4] * p4 + flt_ptr[0][5] * p5 +
+                              flt_ptr[0][6] * p6;
+                    ptr[xx] = iclip_pixel((acc + 8) >> 4);
+                }
+                ptr += PXSTRIDE(stride);
+            }
+
+            left = &dst[x + 4 - 1];
+            left_stride = PXSTRIDE(stride);
+            top += 4;
+            topleft = &top[-1];
+        }
+        top = &dst[PXSTRIDE(stride)];
+        dst = &dst[PXSTRIDE(stride) * 2];
+    }
+}
+
+#define filter_lfn(width, height) \
+static void filter_##width##x##height##_c(pixel *const dst, \
+                                          const ptrdiff_t stride, \
+                                          const pixel *const topleft, \
+                                          const int filt_idx) \
+{ \
+    filter_intra_c(dst, stride, topleft, filt_idx, width, height); \
+}
+
+filter_lfn( 4,  4);
+filter_lfn( 8,  4);
+filter_lfn(16,  4);
+filter_lfn( 4,  8);
+filter_lfn( 8,  8);
+filter_lfn(16,  8);
+filter_lfn(32,  8);
+filter_lfn( 4, 16);
+filter_lfn( 8, 16);
+filter_lfn(16, 16);
+filter_lfn(32, 16);
+filter_lfn( 8, 32);
+filter_lfn(16, 32);
+filter_lfn(32, 32);
+
+static __attribute__((noinline)) void
+cfl_ac_c(int16_t *ac, const pixel *ypx, const ptrdiff_t stride,
+         const int w_pad, const int h_pad, const int width, const int height,
+         const int ss_hor, const int ss_ver, const int log2sz)
+{
+    int y, x;
+    int16_t *const ac_orig = ac;
+
+    assert(w_pad >= 0 && w_pad * 4 < width);
+    assert(h_pad >= 0 && h_pad * 4 < height);
+
+    for (y = 0; y < height - 4 * h_pad; y++) {
+        for (x = 0; x < width - 4 * w_pad; x++) {
+            int ac_sum = ypx[x << ss_hor];
+            if (ss_hor) ac_sum += ypx[x * 2 + 1];
+            if (ss_ver) {
+                ac_sum += ypx[(x << ss_hor) + PXSTRIDE(stride)];
+                if (ss_hor) ac_sum += ypx[x * 2 + 1 + PXSTRIDE(stride)];
+            }
+            ac[x] = ac_sum << (1 + !ss_ver + !ss_hor);
+        }
+        for (; x < width; x++)
+            ac[x] = ac[x - 1];
+        ac += width;
+        ypx += PXSTRIDE(stride) << ss_ver;
+    }
+    for (; y < height; y++) {
+        memcpy(ac, &ac[-32], width * sizeof(*ac));
+        ac += width;
+    }
+
+    int sum = (1 << log2sz) >> 1;
+    for (ac = ac_orig, y = 0; y < height; y++) {
+        for (x = 0; x < width; x++)
+            sum += ac[x];
+        ac += width;
+    }
+    sum >>= log2sz;
+
+    // subtract DC
+    for (ac = ac_orig, y = 0; y < height; y++) {
+        for (x = 0; x < width; x++)
+            ac[x] -= sum;
+        ac += width;
+    }
+}
+
+#define cfl_ac_fn(lw, lh, cw, ch, ss_hor, ss_ver, log2sz) \
+static void cfl_ac_##lw##x##lh##_to_##cw##x##ch##_c(int16_t *const ac, \
+                                                    const pixel *const ypx, \
+                                                    const ptrdiff_t stride, \
+                                                    const int w_pad, \
+                                                    const int h_pad) \
+{ \
+    cfl_ac_c(ac, ypx, stride, w_pad, h_pad, cw, ch, ss_hor, ss_ver, log2sz); \
+}
+
+cfl_ac_fn( 8,  8,  4,  4, 1, 1, 4);
+cfl_ac_fn( 8, 16,  4,  8, 1, 1, 5);
+cfl_ac_fn( 8, 32,  4, 16, 1, 1, 6);
+cfl_ac_fn(16,  8,  8,  4, 1, 1, 5);
+cfl_ac_fn(16, 16,  8,  8, 1, 1, 6);
+cfl_ac_fn(16, 32,  8, 16, 1, 1, 7);
+cfl_ac_fn(32,  8, 16,  4, 1, 1, 6);
+cfl_ac_fn(32, 16, 16,  8, 1, 1, 7);
+cfl_ac_fn(32, 32, 16, 16, 1, 1, 8);
+
+cfl_ac_fn( 8,  4,  4,  4, 1, 0, 4);
+cfl_ac_fn( 8,  8,  4,  8, 1, 0, 5);
+cfl_ac_fn(16,  4,  8,  4, 1, 0, 5);
+cfl_ac_fn(16,  8,  8,  8, 1, 0, 6);
+cfl_ac_fn(16, 16,  8, 16, 1, 0, 7);
+cfl_ac_fn(32,  8, 16,  8, 1, 0, 7);
+cfl_ac_fn(32, 16, 16, 16, 1, 0, 8);
+cfl_ac_fn(32, 32, 16, 32, 1, 0, 9);
+
+cfl_ac_fn( 4,  4,  4,  4, 0, 0, 4);
+cfl_ac_fn( 4,  8,  4,  8, 0, 0, 5);
+cfl_ac_fn( 4, 16,  4, 16, 0, 0, 6);
+cfl_ac_fn( 8,  4,  8,  4, 0, 0, 5);
+cfl_ac_fn( 8,  8,  8,  8, 0, 0, 6);
+cfl_ac_fn( 8, 16,  8, 16, 0, 0, 7);
+cfl_ac_fn( 8, 32,  8, 32, 0, 0, 8);
+cfl_ac_fn(16,  4, 16,  4, 0, 0, 6);
+cfl_ac_fn(16,  8, 16,  8, 0, 0, 7);
+cfl_ac_fn(16, 16, 16, 16, 0, 0, 8);
+cfl_ac_fn(16, 32, 16, 32, 0, 0, 9);
+cfl_ac_fn(32,  8, 32,  8, 0, 0, 8);
+cfl_ac_fn(32, 16, 32, 16, 0, 0, 9);
+cfl_ac_fn(32, 32, 32, 32, 0, 0, 10);
+
+static __attribute__((noinline)) void
+cfl_pred_c(pixel *dstU, pixel *dstV, const ptrdiff_t stride,
+           const int16_t *ac, const pixel *const dc_pred,
+           const int8_t *const alphas, const int width, const int height)
+{
+    for (int y = 0; y < height; y++) {
+        for (int x = 0; x < width; x++) {
+            const int diff1 = alphas[0] * ac[x];
+            dstU[x] = iclip_pixel(dc_pred[ 0] + apply_sign((abs(diff1) + 32) >> 6,
+                                                           diff1));
+            const int diff2 = alphas[1] * ac[x];
+            dstV[x] = iclip_pixel(dc_pred[32] + apply_sign((abs(diff2) + 32) >> 6,
+                                                           diff2));
+        }
+        ac += width;
+        dstU += PXSTRIDE(stride);
+        dstV += PXSTRIDE(stride);
+    }
+}
+
+#define cfl_pred_fn(width) \
+static void cfl_pred_##width##xN_c(pixel *const dstU, \
+                                   pixel *const dstV, \
+                                   const ptrdiff_t stride, \
+                                   const int16_t *const ac, \
+                                   const pixel *const dc_pred, \
+                                   const int8_t *const alphas, \
+                                   const int height) \
+{ \
+    cfl_pred_c(dstU, dstV, stride, ac, dc_pred, alphas, width, height); \
+}
+
+cfl_pred_fn( 4);
+cfl_pred_fn( 8);
+cfl_pred_fn(16);
+cfl_pred_fn(32);
+
+static void pal_pred_c(pixel *dst, const ptrdiff_t stride,
+                       const uint16_t *const pal, const uint8_t *idx,
+                       const int w, const int h)
+{
+    for (int y = 0; y < h; y++) {
+        for (int x = 0; x < w; x++)
+            dst[x] = pal[idx[x]];
+        idx += w;
+        dst += PXSTRIDE(stride);
+    }
+}
+
+void bitfn(dav1d_intra_pred_dsp_init)(Dav1dIntraPredDSPContext *const c) {
+#define assign_lfn(w, h, p1, p2, pfx) \
+    c->intra_pred[pfx##TX_##w##X##h][p1##_PRED] = p2##_##w##x##h##_c
+#define assign_fns(p1, p2) \
+    assign_lfn( 4,  4, p1, p2,); \
+    assign_lfn( 4,  8, p1, p2, R); \
+    assign_lfn( 4, 16, p1, p2, R); \
+    assign_lfn( 8,  4, p1, p2, R); \
+    assign_lfn( 8,  8, p1, p2,); \
+    assign_lfn( 8, 16, p1, p2, R); \
+    assign_lfn( 8, 32, p1, p2, R); \
+    assign_lfn(16,  4, p1, p2, R); \
+    assign_lfn(16,  8, p1, p2, R); \
+    assign_lfn(16, 16, p1, p2,); \
+    assign_lfn(16, 32, p1, p2, R); \
+    assign_lfn(16, 64, p1, p2, R); \
+    assign_lfn(32,  8, p1, p2, R); \
+    assign_lfn(32, 16, p1, p2, R); \
+    assign_lfn(32, 32, p1, p2,); \
+    assign_lfn(32, 64, p1, p2, R); \
+    assign_lfn(64, 16, p1, p2, R); \
+    assign_lfn(64, 32, p1, p2, R); \
+    assign_lfn(64, 64, p1, p2,); \
+
+    assign_fns(DC, dc);
+    assign_fns(DC_128, dc128);
+    assign_fns(TOP_DC,  dctop);
+    assign_fns(LEFT_DC, dcleft);
+    assign_fns(HOR, h);
+    assign_fns(VERT, v);
+    assign_fns(PAETH, paeth);
+    assign_fns(SMOOTH, smooth);
+    assign_fns(SMOOTH_V, smooth_v);
+    assign_fns(SMOOTH_H, smooth_h);
+    assign_fns(Z1, z1);
+    assign_fns(Z2, z2);
+    assign_fns(Z3, z3);
+
+    assign_lfn( 4,  4, FILTER, filter,);
+    assign_lfn( 8,  4, FILTER, filter, R);
+    assign_lfn(16,  4, FILTER, filter, R);
+    assign_lfn( 4,  8, FILTER, filter, R);
+    assign_lfn( 8,  8, FILTER, filter,);
+    assign_lfn(16,  8, FILTER, filter, R);
+    assign_lfn(32,  8, FILTER, filter, R);
+    assign_lfn( 4, 16, FILTER, filter, R);
+    assign_lfn( 8, 16, FILTER, filter, R);
+    assign_lfn(16, 16, FILTER, filter,);
+    assign_lfn(32, 16, FILTER, filter, R);
+    assign_lfn( 8, 32, FILTER, filter, R);
+    assign_lfn(16, 32, FILTER, filter, R);
+    assign_lfn(32, 32, FILTER, filter,);
+
+    // cfl functions are split per chroma subsampling type
+    c->cfl_ac[DAV1D_PIXEL_LAYOUT_I420 - 1][ TX_4X4  ] = cfl_ac_8x8_to_4x4_c;
+    c->cfl_ac[DAV1D_PIXEL_LAYOUT_I420 - 1][RTX_4X8  ] = cfl_ac_8x16_to_4x8_c;
+    c->cfl_ac[DAV1D_PIXEL_LAYOUT_I420 - 1][RTX_4X16 ] = cfl_ac_8x32_to_4x16_c;
+    c->cfl_ac[DAV1D_PIXEL_LAYOUT_I420 - 1][RTX_8X4  ] = cfl_ac_16x8_to_8x4_c;
+    c->cfl_ac[DAV1D_PIXEL_LAYOUT_I420 - 1][ TX_8X8  ] = cfl_ac_16x16_to_8x8_c;
+    c->cfl_ac[DAV1D_PIXEL_LAYOUT_I420 - 1][RTX_8X16 ] = cfl_ac_16x32_to_8x16_c;
+    c->cfl_ac[DAV1D_PIXEL_LAYOUT_I420 - 1][RTX_16X4 ] = cfl_ac_32x8_to_16x4_c;
+    c->cfl_ac[DAV1D_PIXEL_LAYOUT_I420 - 1][RTX_16X8 ] = cfl_ac_32x16_to_16x8_c;
+    c->cfl_ac[DAV1D_PIXEL_LAYOUT_I420 - 1][ TX_16X16] = cfl_ac_32x32_to_16x16_c;
+
+    c->cfl_ac[DAV1D_PIXEL_LAYOUT_I422 - 1][ TX_4X4  ] = cfl_ac_8x4_to_4x4_c;
+    c->cfl_ac[DAV1D_PIXEL_LAYOUT_I422 - 1][RTX_4X8  ] = cfl_ac_8x8_to_4x8_c;
+    c->cfl_ac[DAV1D_PIXEL_LAYOUT_I422 - 1][RTX_8X4 ] = cfl_ac_16x4_to_8x4_c;
+    c->cfl_ac[DAV1D_PIXEL_LAYOUT_I422 - 1][ TX_8X8 ] = cfl_ac_16x8_to_8x8_c;
+    c->cfl_ac[DAV1D_PIXEL_LAYOUT_I422 - 1][RTX_8X16] = cfl_ac_16x16_to_8x16_c;
+    c->cfl_ac[DAV1D_PIXEL_LAYOUT_I422 - 1][RTX_16X8 ] = cfl_ac_32x8_to_16x8_c;
+    c->cfl_ac[DAV1D_PIXEL_LAYOUT_I422 - 1][ TX_16X16] = cfl_ac_32x16_to_16x16_c;
+    c->cfl_ac[DAV1D_PIXEL_LAYOUT_I422 - 1][RTX_16X32] = cfl_ac_32x32_to_16x32_c;
+
+    c->cfl_ac[DAV1D_PIXEL_LAYOUT_I444 - 1][ TX_4X4  ] = cfl_ac_4x4_to_4x4_c;
+    c->cfl_ac[DAV1D_PIXEL_LAYOUT_I444 - 1][RTX_4X8  ] = cfl_ac_4x8_to_4x8_c;
+    c->cfl_ac[DAV1D_PIXEL_LAYOUT_I444 - 1][RTX_4X16 ] = cfl_ac_4x16_to_4x16_c;
+    c->cfl_ac[DAV1D_PIXEL_LAYOUT_I444 - 1][RTX_8X4  ] = cfl_ac_8x4_to_8x4_c;
+    c->cfl_ac[DAV1D_PIXEL_LAYOUT_I444 - 1][ TX_8X8  ] = cfl_ac_8x8_to_8x8_c;
+    c->cfl_ac[DAV1D_PIXEL_LAYOUT_I444 - 1][RTX_8X16 ] = cfl_ac_8x16_to_8x16_c;
+    c->cfl_ac[DAV1D_PIXEL_LAYOUT_I444 - 1][RTX_8X32 ] = cfl_ac_8x32_to_8x32_c;
+    c->cfl_ac[DAV1D_PIXEL_LAYOUT_I444 - 1][RTX_16X4 ] = cfl_ac_16x4_to_16x4_c;
+    c->cfl_ac[DAV1D_PIXEL_LAYOUT_I444 - 1][RTX_16X8 ] = cfl_ac_16x8_to_16x8_c;
+    c->cfl_ac[DAV1D_PIXEL_LAYOUT_I444 - 1][ TX_16X16] = cfl_ac_16x16_to_16x16_c;
+    c->cfl_ac[DAV1D_PIXEL_LAYOUT_I444 - 1][RTX_16X32] = cfl_ac_16x32_to_16x32_c;
+    c->cfl_ac[DAV1D_PIXEL_LAYOUT_I444 - 1][RTX_32X8 ] = cfl_ac_32x8_to_32x8_c;
+    c->cfl_ac[DAV1D_PIXEL_LAYOUT_I444 - 1][RTX_32X16] = cfl_ac_32x16_to_32x16_c;
+    c->cfl_ac[DAV1D_PIXEL_LAYOUT_I444 - 1][ TX_32X32] = cfl_ac_32x32_to_32x32_c;
+
+    c->cfl_pred[0] = cfl_pred_4xN_c;
+    c->cfl_pred[1] = cfl_pred_8xN_c;
+    c->cfl_pred[2] = cfl_pred_16xN_c;
+    c->cfl_pred[3] = cfl_pred_32xN_c;
+
+    c->pal_pred = pal_pred_c;
+}
diff --git a/src/ipred.h b/src/ipred.h
new file mode 100644
index 0000000..4e6c312
--- /dev/null
+++ b/src/ipred.h
@@ -0,0 +1,92 @@
+/*
+ * Copyright © 2018, VideoLAN and dav1d authors
+ * Copyright © 2018, Two Orioles, LLC
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright notice, this
+ *    list of conditions and the following disclaimer.
+ *
+ * 2. Redistributions in binary form must reproduce the above copyright notice,
+ *    this list of conditions and the following disclaimer in the documentation
+ *    and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
+ * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#ifndef __DAV1D_SRC_IPRED_H__
+#define __DAV1D_SRC_IPRED_H__
+
+#include "common/bitdepth.h"
+
+#include "src/levels.h"
+
+/*
+ * Intra prediction.
+ * - a is the angle (in degrees) for directional intra predictors. For other
+ *   modes, it is ignored;
+ * - topleft is the same as the argument given to dav1d_prepare_intra_edges(),
+ *   see ipred_prepare.h for more detailed documentation.
+ */
+#define decl_angular_ipred_fn(name) \
+void (name)(pixel *dst, ptrdiff_t stride, const pixel *topleft, int angle);
+typedef decl_angular_ipred_fn(*angular_ipred_fn);
+
+/*
+ * Create a subsampled Y plane with the DC subtracted.
+ * - w/h_pad is the edge of the width/height that extends outside the visible
+ *   portion of the frame in 4px units;
+ * - ac has a stride of 16.
+ */
+#define decl_cfl_ac_fn(name) \
+void (name)(int16_t *ac, const pixel *y, ptrdiff_t stride, \
+            int w_pad, int h_pad)
+typedef decl_cfl_ac_fn(*cfl_ac_fn);
+
+/*
+ * dst[plane][x,y] = dc[plane] + alpha[plane] * ac[x,y]
+ * - alphas contains two q3 scalars (one for each plane) in [-16,16] range;
+ * - dc_pred[] is the first line of each plane's DC prediction, the second plane
+ *   starting at an offset of 16 * sizeof(pixel) bytes.
+ */
+#define decl_cfl_pred_fn(name) \
+void (name)(pixel *u_dst, pixel *v_dst, ptrdiff_t stride, \
+            const int16_t *ac, const pixel *dc_pred, \
+            const int8_t *const alphas, const int height)
+typedef decl_cfl_pred_fn(*cfl_pred_fn);
+
+/*
+ * dst[x,y] = pal[idx[x,y]]
+ * - palette indices are [0-7]
+ */
+#define decl_pal_pred_fn(name) \
+void (name)(pixel *dst, ptrdiff_t stride, const uint16_t *pal, \
+            const uint8_t *idx, const int w, const int h)
+typedef decl_pal_pred_fn(*pal_pred_fn);
+
+typedef struct Dav1dIntraPredDSPContext {
+    angular_ipred_fn intra_pred[N_RECT_TX_SIZES][N_IMPL_INTRA_PRED_MODES];
+
+    // chroma-from-luma
+    cfl_ac_fn cfl_ac[3 /* 420, 422, 444 */][N_RECT_TX_SIZES /* chroma tx size */];
+    cfl_pred_fn cfl_pred[4];
+
+    // palette
+    pal_pred_fn pal_pred;
+} Dav1dIntraPredDSPContext;
+
+void dav1d_intra_pred_dsp_init_8bpc(Dav1dIntraPredDSPContext *c);
+void dav1d_intra_pred_dsp_init_10bpc(Dav1dIntraPredDSPContext *c);
+
+#endif /* __DAV1D_SRC_IPRED_H__ */
diff --git a/src/ipred_prepare.c b/src/ipred_prepare.c
new file mode 100644
index 0000000..d7c3c51
--- /dev/null
+++ b/src/ipred_prepare.c
@@ -0,0 +1,209 @@
+/*
+ * Copyright © 2018, VideoLAN and dav1d authors
+ * Copyright © 2018, Two Orioles, LLC
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright notice, this
+ *    list of conditions and the following disclaimer.
+ *
+ * 2. Redistributions in binary form must reproduce the above copyright notice,
+ *    this list of conditions and the following disclaimer in the documentation
+ *    and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
+ * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#include "config.h"
+
+#include <assert.h>
+#include <stdint.h>
+#include <string.h>
+
+#include "common/intops.h"
+
+#include "src/ipred_prepare.h"
+
+static const uint8_t av1_mode_conv[N_INTRA_PRED_MODES]
+                                  [2 /* have_left */][2 /* have_top */] =
+{
+    [DC_PRED]    = { { DC_128_PRED,  TOP_DC_PRED },
+                     { LEFT_DC_PRED, DC_PRED     } },
+    [PAETH_PRED] = { { DC_128_PRED,  VERT_PRED   },
+                     { HOR_PRED,     PAETH_PRED  } },
+};
+
+static const uint8_t av1_mode_to_angle_map[8] = {
+    90, 180, 45, 135, 113, 157, 203, 67
+};
+
+static const struct {
+    uint8_t needs_left:1;
+    uint8_t needs_top:1;
+    uint8_t needs_topleft:1;
+    uint8_t needs_topright:1;
+    uint8_t needs_bottomleft:1;
+} av1_intra_prediction_edges[N_IMPL_INTRA_PRED_MODES] = {
+    [DC_PRED]       = { .needs_top  = 1, .needs_left = 1 },
+    [VERT_PRED]     = { .needs_top  = 1 },
+    [HOR_PRED]      = { .needs_left = 1 },
+    [LEFT_DC_PRED]  = { .needs_left = 1 },
+    [TOP_DC_PRED]   = { .needs_top  = 1 },
+    [DC_128_PRED]   = { 0 },
+    [Z1_PRED]       = { .needs_top = 1, .needs_topright = 1,
+                        .needs_topleft = 1 },
+    [Z2_PRED]       = { .needs_left = 1, .needs_top = 1, .needs_topleft = 1 },
+    [Z3_PRED]       = { .needs_left = 1, .needs_bottomleft = 1,
+                        .needs_topleft = 1 },
+    [SMOOTH_PRED]   = { .needs_left = 1, .needs_top = 1 },
+    [SMOOTH_V_PRED] = { .needs_left = 1, .needs_top = 1 },
+    [SMOOTH_H_PRED] = { .needs_left = 1, .needs_top = 1 },
+    [PAETH_PRED]    = { .needs_left = 1, .needs_top = 1, .needs_topleft = 1 },
+    [FILTER_PRED]   = { .needs_left = 1, .needs_top = 1, .needs_topleft = 1 },
+};
+
+enum IntraPredMode
+bytefn(prepare_intra_edges)(const int x, const int have_left,
+                            const int y, const int have_top,
+                            const int w, const int h,
+                            const enum EdgeFlags edge_flags,
+                            const pixel *const dst,
+                            const ptrdiff_t stride,
+                            const pixel *prefilter_toplevel_sb_edge,
+                            enum IntraPredMode mode, int *const angle,
+                            const int tw, const int th,
+                            pixel *const topleft_out)
+{
+    assert(y < h && x < w);
+
+    switch (mode) {
+    case VERT_PRED:
+    case HOR_PRED:
+    case DIAG_DOWN_LEFT_PRED:
+    case DIAG_DOWN_RIGHT_PRED:
+    case VERT_RIGHT_PRED:
+    case HOR_DOWN_PRED:
+    case HOR_UP_PRED:
+    case VERT_LEFT_PRED: {
+        *angle = av1_mode_to_angle_map[mode - VERT_PRED] + 3 * *angle;
+
+        if (*angle < 90) {
+            mode = have_top ? Z1_PRED : VERT_PRED;
+        } else if (*angle == 90) {
+            mode = VERT_PRED;
+        } else if (*angle < 180) {
+            mode = Z2_PRED;
+        } else if (*angle == 180) {
+            mode = HOR_PRED;
+        } else {
+            mode = have_left ? Z3_PRED : HOR_PRED;
+        }
+        break;
+    }
+    case DC_PRED:
+    case PAETH_PRED:
+        mode = av1_mode_conv[mode][have_left][have_top];
+        break;
+    default:
+        break;
+    }
+
+    const pixel *dst_top;
+    if (have_top &&
+        (av1_intra_prediction_edges[mode].needs_top ||
+         av1_intra_prediction_edges[mode].needs_topleft ||
+         (av1_intra_prediction_edges[mode].needs_left && !have_left)))
+    {
+        if (prefilter_toplevel_sb_edge) {
+            dst_top = &prefilter_toplevel_sb_edge[x * 4];
+        } else {
+            dst_top = &dst[-PXSTRIDE(stride)];
+        }
+    }
+
+    if (av1_intra_prediction_edges[mode].needs_left) {
+        const int sz = th << 2;
+        pixel *const left = &topleft_out[-sz];
+
+        if (have_left) {
+            const int px_have = imin(sz, (h - y) << 2);
+
+            for (int i = 0; i < px_have; i++)
+                left[sz - 1 - i] = dst[PXSTRIDE(stride) * i - 1];
+            if (px_have < sz)
+                pixel_set(left, left[sz - px_have], sz - px_have);
+        } else {
+            pixel_set(left, have_top ? *dst_top : ((1 << BITDEPTH) >> 1) + 1, sz);
+        }
+
+        if (av1_intra_prediction_edges[mode].needs_bottomleft) {
+            const int have_bottomleft = (!have_left || y + th >= h) ? 0 :
+                                        (edge_flags & EDGE_I444_LEFT_HAS_BOTTOM);
+
+            if (have_bottomleft) {
+                const int px_have = imin(sz, (h - y - th) << 2);
+
+                for (int i = 0; i < px_have; i++)
+                    left[-(i + 1)] = dst[(sz + i) * PXSTRIDE(stride) - 1];
+                if (px_have < sz)
+                    pixel_set(left - sz, left[-px_have], sz - px_have);
+            } else {
+                pixel_set(left - sz, left[0], sz);
+            }
+        }
+    }
+
+    if (av1_intra_prediction_edges[mode].needs_top) {
+        const int sz = tw << 2;
+        pixel *const top = &topleft_out[1];
+
+        if (have_top) {
+            const int px_have = imin(sz, (w - x) << 2);
+            pixel_copy(top, dst_top, px_have);
+            if (px_have < sz)
+                pixel_set(top + px_have, top[px_have - 1], sz - px_have);
+        } else {
+            pixel_set(top, have_left ? dst[-1] : ((1 << BITDEPTH) >> 1) - 1, sz);
+        }
+
+        if (av1_intra_prediction_edges[mode].needs_topright) {
+            const int have_topright = (!have_top || x + tw >= w) ? 0 :
+                                      (edge_flags & EDGE_I444_TOP_HAS_RIGHT);
+
+            if (have_topright) {
+                const int px_have = imin(sz, (w - x - tw) << 2);
+
+                pixel_copy(top + sz, &dst_top[sz], px_have);
+                if (px_have < sz)
+                    pixel_set(top + sz + px_have, top[sz + px_have - 1],
+                              sz - px_have);
+            } else {
+                pixel_set(top + sz, top[sz - 1], sz);
+            }
+        }
+    }
+
+    if (av1_intra_prediction_edges[mode].needs_topleft) {
+        if (have_left) {
+            *topleft_out = have_top ? dst_top[-1] : dst[-1];
+        } else {
+            *topleft_out = have_top ? *dst_top : (1 << BITDEPTH) >> 1;
+        }
+        if (mode == Z2_PRED && tw + th >= 6)
+            *topleft_out = (topleft_out[-1] * 5 + topleft_out[0] * 6 +
+                            topleft_out[1] * 5 + 8) >> 4;
+    }
+
+    return mode;
+}
diff --git a/src/ipred_prepare.h b/src/ipred_prepare.h
new file mode 100644
index 0000000..7552be1
--- /dev/null
+++ b/src/ipred_prepare.h
@@ -0,0 +1,102 @@
+/*
+ * Copyright © 2018, VideoLAN and dav1d authors
+ * Copyright © 2018, Two Orioles, LLC
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright notice, this
+ *    list of conditions and the following disclaimer.
+ *
+ * 2. Redistributions in binary form must reproduce the above copyright notice,
+ *    this list of conditions and the following disclaimer in the documentation
+ *    and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
+ * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#ifndef __DAV1D_SRC_IPRED_PREPARE_H__
+#define __DAV1D_SRC_IPRED_PREPARE_H__
+
+#include <stddef.h>
+#include <stdint.h>
+
+#include "common/bitdepth.h"
+
+#include "src/env.h"
+#include "src/intra_edge.h"
+#include "src/levels.h"
+
+/*
+ * Luma intra edge preparation.
+ *
+ * x/y/start/w/h are in luma block (4px) units:
+ * - x and y are the absolute block positions in the image;
+ * - start/w/h are the *dependent tile* boundary positions. In practice, start
+ *   is the horizontal tile start, w is the horizontal tile end, the vertical
+ *   tile start is assumed to be 0 and h is the vertical image end.
+ *
+ * edge_flags signals which edges are available for this transform-block inside
+ * the given partition, as well as for the partition inside the superblock
+ * structure.
+ *
+ * dst and stride are pointers to the top/left position of the current block,
+ * and can be used to locate the top, left, top/left, top/right and bottom/left
+ * edge pointers also.
+ *
+ * angle is the angle_delta [-3..3] on input, and the absolute angle on output.
+ *
+ * mode is the intra prediction mode as coded in the bitstream. The return value
+ * is this same mode, converted to an index in the DSP functions.
+ *
+ * tw/th are the size of the transform block in block (4px) units.
+ *
+ * topleft_out is a pointer to scratch memory that will be filled with the edge
+ * pixels. The memory array should have space to be indexed in the [-2*w,2*w]
+ * range, in the following order:
+ * - [0] will be the top/left edge pixel;
+ * - [1..w] will be the top edge pixels (1 being left-most, w being right-most);
+ * - [w+1..w*w] will be the top/right edge pixels;
+ * - [-1..-w] will be the left edge pixels (-1 being top-most, -w being bottom-
+ *   most);
+ * - [-w-1..-2*w] will be the bottom/left edge pixels.
+ * Each edge may remain uninitialized if it is not used by the returned mode
+ * index. If edges are not available (because the edge position is outside the
+ * tile dimensions or because edge_flags indicates lack of edge availability),
+ * they will be extended from nearby edges as defined by the av1 spec.
+ */
+enum IntraPredMode
+    bytefn(prepare_intra_edges)(int x, int have_left, int y, int have_top,
+                                int w, int h, enum EdgeFlags edge_flags,
+                                const pixel *dst, ptrdiff_t stride,
+                                const pixel *prefilter_toplevel_sb_edge,
+                                enum IntraPredMode mode, int *angle,
+                                int tw, int th, pixel *topleft_out);
+
+// is or'ed with the angle argument into intra predictors to signal that edges
+// are smooth and should use reduced filter strength
+#define ANGLE_SMOOTH_EDGE_FLAG 512
+static inline int sm_flag(const BlockContext *const b, const int idx) {
+    if (!b->intra[idx]) return 0;
+    const enum IntraPredMode m = b->mode[idx];
+    return (m == SMOOTH_PRED || m == SMOOTH_H_PRED ||
+            m == SMOOTH_V_PRED) ? ANGLE_SMOOTH_EDGE_FLAG : 0;
+}
+
+static inline int sm_uv_flag(const BlockContext *const b, const int idx) {
+    const enum IntraPredMode m = b->uvmode[idx];
+    return (m == SMOOTH_PRED || m == SMOOTH_H_PRED ||
+            m == SMOOTH_V_PRED) ? ANGLE_SMOOTH_EDGE_FLAG : 0;
+}
+
+#endif /* __DAV1D_SRC_IPRED_PREPARE_H__ */
diff --git a/src/itx.c b/src/itx.c
new file mode 100644
index 0000000..730e790
--- /dev/null
+++ b/src/itx.c
@@ -0,0 +1,224 @@
+/*
+ * Copyright © 2018, VideoLAN and dav1d authors
+ * Copyright © 2018, Two Orioles, LLC
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright notice, this
+ *    list of conditions and the following disclaimer.
+ *
+ * 2. Redistributions in binary form must reproduce the above copyright notice,
+ *    this list of conditions and the following disclaimer in the documentation
+ *    and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
+ * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#include "config.h"
+
+#include <assert.h>
+#include <stddef.h>
+#include <stdint.h>
+#include <string.h>
+
+#include "common/intops.h"
+
+#include "src/itx.h"
+
+#include "src/itx_1d.c"
+
+typedef void (*itx_1d_fn)(const coef *in, ptrdiff_t in_s,
+                          coef *out, ptrdiff_t out_s);
+
+static void __attribute__((noinline))
+inv_txfm_add_c(pixel *dst, const ptrdiff_t stride,
+               coef *const coeff, const int eob,
+               const int w, const int h, const int shift1, const int shift2,
+               const itx_1d_fn first_1d_fn, const itx_1d_fn second_1d_fn)
+{
+    int i, j;
+    const ptrdiff_t sh = imin(h, 32), sw = imin(w, 32);
+    coef tmp[w * h], out[h], in_mem[w];
+    const int is_rect2 = w * 2 == h || h * 2 == w;
+
+    if (w != sw) memset(&in_mem[sw], 0, (w - sw) * sizeof(*in_mem));
+    const int rnd1 = (1 << shift1) >> 1;
+    for (i = 0; i < sh; i++) {
+        if (w != sw || is_rect2) {
+            for (j = 0; j < sw; j++) {
+                in_mem[j] = coeff[i + j * sh];
+                if (is_rect2)
+                    in_mem[j] = (in_mem[j] * 2896 + 2048) >> 12;
+            }
+            first_1d_fn(in_mem, 1, &tmp[i * w], 1);
+        } else {
+            first_1d_fn(&coeff[i], sh, &tmp[i * w], 1);
+        }
+        for (j = 0; j < w; j++)
+            tmp[i * w + j] = (tmp[i * w + j] + (rnd1)) >> shift1;
+    }
+
+    if (h != sh) memset(&tmp[sh * w], 0, w * (h - sh) * sizeof(*tmp));
+    const int rnd2 = (1 << shift2) >> 1;
+    for (i = 0; i < w; i++) {
+        second_1d_fn(&tmp[i], w, out, 1);
+        for (j = 0; j < h; j++)
+            dst[i + j * PXSTRIDE(stride)] =
+                iclip_pixel(dst[i + j * PXSTRIDE(stride)] +
+                            ((out[j] + (rnd2)) >> shift2));
+    }
+    memset(coeff, 0, sizeof(*coeff) * sh * sw);
+}
+
+#define inv_txfm_fn(type1, type2, w, h, shift1, shift2) \
+static void \
+inv_txfm_add_##type1##_##type2##_##w##x##h##_c(pixel *dst, \
+                                               const ptrdiff_t stride, \
+                                               coef *const coeff, \
+                                               const int eob) \
+{ \
+    inv_txfm_add_c(dst, stride, coeff, eob, w, h, shift1, shift2, \
+                   inv_##type1##w##_1d, inv_##type2##h##_1d); \
+}
+
+#define inv_txfm_fn64(w, h, shift1, shift2) \
+inv_txfm_fn(dct, dct, w, h, shift1, shift2)
+
+#define inv_txfm_fn32(w, h, shift1, shift2) \
+inv_txfm_fn64(w, h, shift1, shift2); \
+inv_txfm_fn(identity, identity, w, h, shift1, shift2)
+
+#define inv_txfm_fn16(w, h, shift1, shift2) \
+inv_txfm_fn32(w, h, shift1, shift2); \
+inv_txfm_fn(adst,     dct,      w, h, shift1, shift2); \
+inv_txfm_fn(dct,      adst,     w, h, shift1, shift2); \
+inv_txfm_fn(adst,     adst,     w, h, shift1, shift2); \
+inv_txfm_fn(dct,      flipadst, w, h, shift1, shift2); \
+inv_txfm_fn(flipadst, dct,      w, h, shift1, shift2); \
+inv_txfm_fn(adst,     flipadst, w, h, shift1, shift2); \
+inv_txfm_fn(flipadst, adst,     w, h, shift1, shift2); \
+inv_txfm_fn(flipadst, flipadst, w, h, shift1, shift2); \
+inv_txfm_fn(identity, dct,      w, h, shift1, shift2); \
+inv_txfm_fn(dct,      identity, w, h, shift1, shift2); \
+
+#define inv_txfm_fn84(w, h, shift1, shift2) \
+inv_txfm_fn16(w, h, shift1, shift2); \
+inv_txfm_fn(identity, flipadst, w, h, shift1, shift2); \
+inv_txfm_fn(flipadst, identity, w, h, shift1, shift2); \
+inv_txfm_fn(identity, adst,     w, h, shift1, shift2); \
+inv_txfm_fn(adst,     identity, w, h, shift1, shift2); \
+
+inv_txfm_fn84( 4,  4, 0, 4);
+inv_txfm_fn84( 4,  8, 0, 4);
+inv_txfm_fn84( 4, 16, 1, 4);
+inv_txfm_fn84( 8,  4, 0, 4);
+inv_txfm_fn84( 8,  8, 1, 4);
+inv_txfm_fn84( 8, 16, 1, 4);
+inv_txfm_fn32( 8, 32, 2, 4);
+inv_txfm_fn84(16,  4, 1, 4);
+inv_txfm_fn84(16,  8, 1, 4);
+inv_txfm_fn16(16, 16, 2, 4);
+inv_txfm_fn32(16, 32, 1, 4);
+inv_txfm_fn64(16, 64, 2, 4);
+inv_txfm_fn32(32,  8, 2, 4);
+inv_txfm_fn32(32, 16, 1, 4);
+inv_txfm_fn32(32, 32, 2, 4);
+inv_txfm_fn64(32, 64, 1, 4);
+inv_txfm_fn64(64, 16, 2, 4);
+inv_txfm_fn64(64, 32, 1, 4);
+inv_txfm_fn64(64, 64, 2, 4);
+
+static void inv_txfm_add_wht_wht_4x4_c(pixel *dst, const ptrdiff_t stride,
+                                       coef *const coeff, const int eob)
+{
+    int i, j;
+    coef tmp[4 * 4], out[4];
+
+    for (i = 0; i < 4; i++)
+        inv_wht4_1d(&coeff[i], 4, &tmp[i * 4], 1, 0);
+
+    for (i = 0; i < 4; i++) {
+        inv_wht4_1d(&tmp[i], 4, out, 1, 1);
+        for (j = 0; j < 4; j++)
+            dst[i + j * PXSTRIDE(stride)] =
+                iclip_pixel(dst[i + j * PXSTRIDE(stride)] + out[j]);
+    }
+    memset(coeff, 0, sizeof(*coeff) * 4 * 4);
+}
+
+void bitfn(dav1d_itx_dsp_init)(Dav1dInvTxfmDSPContext *const c) {
+#define assign_itx_all_fn64(w, h, pfx) \
+    c->itxfm_add[pfx##TX_##w##X##h][DCT_DCT  ] = \
+        inv_txfm_add_dct_dct_##w##x##h##_c
+
+#define assign_itx_all_fn32(w, h, pfx) \
+    assign_itx_all_fn64(w, h, pfx); \
+    c->itxfm_add[pfx##TX_##w##X##h][IDTX] = \
+        inv_txfm_add_identity_identity_##w##x##h##_c
+
+#define assign_itx_all_fn16(w, h, pfx) \
+    assign_itx_all_fn32(w, h, pfx); \
+    c->itxfm_add[pfx##TX_##w##X##h][DCT_ADST ] = \
+        inv_txfm_add_adst_dct_##w##x##h##_c; \
+    c->itxfm_add[pfx##TX_##w##X##h][ADST_DCT ] = \
+        inv_txfm_add_dct_adst_##w##x##h##_c; \
+    c->itxfm_add[pfx##TX_##w##X##h][ADST_ADST] = \
+        inv_txfm_add_adst_adst_##w##x##h##_c; \
+    c->itxfm_add[pfx##TX_##w##X##h][ADST_FLIPADST] = \
+        inv_txfm_add_flipadst_adst_##w##x##h##_c; \
+    c->itxfm_add[pfx##TX_##w##X##h][FLIPADST_ADST] = \
+        inv_txfm_add_adst_flipadst_##w##x##h##_c; \
+    c->itxfm_add[pfx##TX_##w##X##h][DCT_FLIPADST] = \
+        inv_txfm_add_flipadst_dct_##w##x##h##_c; \
+    c->itxfm_add[pfx##TX_##w##X##h][FLIPADST_DCT] = \
+        inv_txfm_add_dct_flipadst_##w##x##h##_c; \
+    c->itxfm_add[pfx##TX_##w##X##h][FLIPADST_FLIPADST] = \
+        inv_txfm_add_flipadst_flipadst_##w##x##h##_c; \
+    c->itxfm_add[pfx##TX_##w##X##h][H_DCT] = \
+        inv_txfm_add_dct_identity_##w##x##h##_c; \
+    c->itxfm_add[pfx##TX_##w##X##h][V_DCT] = \
+        inv_txfm_add_identity_dct_##w##x##h##_c
+
+#define assign_itx_all_fn84(w, h, pfx) \
+    assign_itx_all_fn16(w, h, pfx); \
+    c->itxfm_add[pfx##TX_##w##X##h][H_FLIPADST] = \
+        inv_txfm_add_flipadst_identity_##w##x##h##_c; \
+    c->itxfm_add[pfx##TX_##w##X##h][V_FLIPADST] = \
+        inv_txfm_add_identity_flipadst_##w##x##h##_c; \
+    c->itxfm_add[pfx##TX_##w##X##h][H_ADST] = \
+        inv_txfm_add_adst_identity_##w##x##h##_c; \
+    c->itxfm_add[pfx##TX_##w##X##h][V_ADST] = \
+        inv_txfm_add_identity_adst_##w##x##h##_c; \
+
+    c->itxfm_add[TX_4X4][WHT_WHT] = inv_txfm_add_wht_wht_4x4_c;
+    assign_itx_all_fn84( 4,  4, );
+    assign_itx_all_fn84( 4,  8, R);
+    assign_itx_all_fn84( 4, 16, R);
+    assign_itx_all_fn84( 8,  4, R);
+    assign_itx_all_fn84( 8,  8, );
+    assign_itx_all_fn84( 8, 16, R);
+    assign_itx_all_fn32( 8, 32, R);
+    assign_itx_all_fn84(16,  4, R);
+    assign_itx_all_fn84(16,  8, R);
+    assign_itx_all_fn16(16, 16, );
+    assign_itx_all_fn32(16, 32, R);
+    assign_itx_all_fn64(16, 64, R);
+    assign_itx_all_fn32(32,  8, R);
+    assign_itx_all_fn32(32, 16, R);
+    assign_itx_all_fn32(32, 32, );
+    assign_itx_all_fn64(32, 64, R);
+    assign_itx_all_fn64(64, 16, R);
+    assign_itx_all_fn64(64, 32, R);
+    assign_itx_all_fn64(64, 64, );
+}
diff --git a/src/itx.h b/src/itx.h
new file mode 100644
index 0000000..a20503b
--- /dev/null
+++ b/src/itx.h
@@ -0,0 +1,46 @@
+/*
+ * Copyright © 2018, VideoLAN and dav1d authors
+ * Copyright © 2018, Two Orioles, LLC
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright notice, this
+ *    list of conditions and the following disclaimer.
+ *
+ * 2. Redistributions in binary form must reproduce the above copyright notice,
+ *    this list of conditions and the following disclaimer in the documentation
+ *    and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
+ * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#ifndef __DAV1D_SRC_ITX_H__
+#define __DAV1D_SRC_ITX_H__
+
+#include "common/bitdepth.h"
+
+#include "src/levels.h"
+
+#define decl_itx_fn(name) \
+void (name)(pixel *dst, ptrdiff_t dst_stride, coef *coeff, int eob)
+typedef decl_itx_fn(*itxfm_fn);
+
+typedef struct Dav1dInvTxfmDSPContext {
+    itxfm_fn itxfm_add[N_RECT_TX_SIZES][N_TX_TYPES_PLUS_LL];
+} Dav1dInvTxfmDSPContext;
+
+void dav1d_itx_dsp_init_8bpc(Dav1dInvTxfmDSPContext *c);
+void dav1d_itx_dsp_init_10bpc(Dav1dInvTxfmDSPContext *c);
+
+#endif /* __DAV1D_SRC_ITX_H__ */
diff --git a/src/itx_1d.c b/src/itx_1d.c
new file mode 100644
index 0000000..0c4547e
--- /dev/null
+++ b/src/itx_1d.c
@@ -0,0 +1,861 @@
+/*
+ * Copyright © 2018, VideoLAN and dav1d authors
+ * Copyright © 2018, Two Orioles, LLC
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright notice, this
+ *    list of conditions and the following disclaimer.
+ *
+ * 2. Redistributions in binary form must reproduce the above copyright notice,
+ *    this list of conditions and the following disclaimer in the documentation
+ *    and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
+ * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#include "config.h"
+
+#include <stddef.h>
+#include <stdint.h>
+
+static void __attribute__((noinline))
+inv_dct4_1d(const coef *const in, const ptrdiff_t in_s,
+            coef *const out, const ptrdiff_t out_s)
+{
+    const int in0 = in[0 * in_s], in1 = in[1 * in_s];
+    const int in2 = in[2 * in_s], in3 = in[3 * in_s];
+
+    int t0 = ((in0 + in2) * 2896 + 2048) >> 12;
+    int t1 = ((in0 - in2) * 2896 + 2048) >> 12;
+    int t2 = (in1 * 1567 - in3 * 3784 + 2048) >> 12;
+    int t3 = (in1 * 3784 + in3 * 1567 + 2048) >> 12;
+
+    out[0 * out_s] = t0 + t3;
+    out[1 * out_s] = t1 + t2;
+    out[2 * out_s] = t1 - t2;
+    out[3 * out_s] = t0 - t3;
+}
+
+static void __attribute__((noinline))
+inv_dct8_1d(const coef *const in, const ptrdiff_t in_s,
+            coef *const out, const ptrdiff_t out_s)
+{
+    coef tmp[4];
+
+    inv_dct4_1d(in, in_s * 2, tmp, 1);
+
+    const int in1 = in[1 * in_s], in3 = in[3 * in_s];
+    const int in5 = in[5 * in_s], in7 = in[7 * in_s];
+
+    int t4a = (in1 *  799 - in7 * 4017 + 2048) >> 12;
+    int t5a = (in5 * 3406 - in3 * 2276 + 2048) >> 12;
+    int t6a = (in5 * 2276 + in3 * 3406 + 2048) >> 12;
+    int t7a = (in1 * 4017 + in7 *  799 + 2048) >> 12;
+
+    int t4  = t4a + t5a;
+        t5a = t4a - t5a;
+    int t7  = t7a + t6a;
+        t6a = t7a - t6a;
+
+    int t5  = ((t6a - t5a) * 2896 + 2048) >> 12;
+    int t6  = ((t6a + t5a) * 2896 + 2048) >> 12;
+
+    out[0 * out_s] = tmp[0] + t7;
+    out[1 * out_s] = tmp[1] + t6;
+    out[2 * out_s] = tmp[2] + t5;
+    out[3 * out_s] = tmp[3] + t4;
+    out[4 * out_s] = tmp[3] - t4;
+    out[5 * out_s] = tmp[2] - t5;
+    out[6 * out_s] = tmp[1] - t6;
+    out[7 * out_s] = tmp[0] - t7;
+}
+
+static void __attribute__((noinline))
+inv_dct16_1d(const coef *const in, const ptrdiff_t in_s,
+             coef *const out, const ptrdiff_t out_s)
+{
+    coef tmp[8];
+
+    inv_dct8_1d(in, in_s * 2, tmp, 1);
+
+    const int in1  = in[ 1 * in_s], in3  = in[ 3 * in_s];
+    const int in5  = in[ 5 * in_s], in7  = in[ 7 * in_s];
+    const int in9  = in[ 9 * in_s], in11 = in[11 * in_s];
+    const int in13 = in[13 * in_s], in15 = in[15 * in_s];
+
+    int t8a  = (in1  *  401 - in15 * 4076 + 2048) >> 12;
+    int t15a = (in1  * 4076 + in15 *  401 + 2048) >> 12;
+    int t9a  = (in9  * 3166 - in7  * 2598 + 2048) >> 12;
+    int t14a = (in9  * 2598 + in7  * 3166 + 2048) >> 12;
+    int t10a = (in5  * 1931 - in11 * 3612 + 2048) >> 12;
+    int t13a = (in5  * 3612 + in11 * 1931 + 2048) >> 12;
+    int t11a = (in13 * 3920 - in3  * 1189 + 2048) >> 12;
+    int t12a = (in13 * 1189 + in3  * 3920 + 2048) >> 12;
+
+    int t8  = t8a  + t9a;
+    int t9  = t8a  - t9a;
+    int t10 = t11a - t10a;
+    int t11 = t11a + t10a;
+    int t12 = t12a + t13a;
+    int t13 = t12a - t13a;
+    int t14 = t15a - t14a;
+    int t15 = t15a + t14a;
+
+    t9a  = (  t14 * 1567 - t9  * 3784  + 2048) >> 12;
+    t14a = (  t14 * 3784 + t9  * 1567  + 2048) >> 12;
+    t10a = (-(t13 * 3784 + t10 * 1567) + 2048) >> 12;
+    t13a = (  t13 * 1567 - t10 * 3784  + 2048) >> 12;
+
+    t8a  = t8   + t11;
+    t9   = t9a  + t10a;
+    t10  = t9a  - t10a;
+    t11a = t8   - t11;
+    t12a = t15  - t12;
+    t13  = t14a - t13a;
+    t14  = t14a + t13a;
+    t15a = t15  + t12;
+
+    t10a = ((t13  - t10)  * 2896 + 2048) >> 12;
+    t13a = ((t13  + t10)  * 2896 + 2048) >> 12;
+    t11  = ((t12a - t11a) * 2896 + 2048) >> 12;
+    t12  = ((t12a + t11a) * 2896 + 2048) >> 12;
+
+    out[ 0 * out_s] = tmp[0] + t15a;
+    out[ 1 * out_s] = tmp[1] + t14;
+    out[ 2 * out_s] = tmp[2] + t13a;
+    out[ 3 * out_s] = tmp[3] + t12;
+    out[ 4 * out_s] = tmp[4] + t11;
+    out[ 5 * out_s] = tmp[5] + t10a;
+    out[ 6 * out_s] = tmp[6] + t9;
+    out[ 7 * out_s] = tmp[7] + t8a;
+    out[ 8 * out_s] = tmp[7] - t8a;
+    out[ 9 * out_s] = tmp[6] - t9;
+    out[10 * out_s] = tmp[5] - t10a;
+    out[11 * out_s] = tmp[4] - t11;
+    out[12 * out_s] = tmp[3] - t12;
+    out[13 * out_s] = tmp[2] - t13a;
+    out[14 * out_s] = tmp[1] - t14;
+    out[15 * out_s] = tmp[0] - t15a;
+}
+
+static void __attribute__((noinline))
+inv_dct32_1d(const coef *const in, const ptrdiff_t in_s,
+             coef *const out, const ptrdiff_t out_s)
+{
+    coef tmp[16];
+
+    inv_dct16_1d(in, in_s * 2, tmp, 1);
+
+    const int in1  = in[ 1 * in_s], in3  = in[ 3 * in_s];
+    const int in5  = in[ 5 * in_s], in7  = in[ 7 * in_s];
+    const int in9  = in[ 9 * in_s], in11 = in[11 * in_s];
+    const int in13 = in[13 * in_s], in15 = in[15 * in_s];
+    const int in17 = in[17 * in_s], in19 = in[19 * in_s];
+    const int in21 = in[21 * in_s], in23 = in[23 * in_s];
+    const int in25 = in[25 * in_s], in27 = in[27 * in_s];
+    const int in29 = in[29 * in_s], in31 = in[31 * in_s];
+
+    int t16a = (in1  *  201 - in31 * 4091 + 2048) >> 12;
+    int t31a = (in1  * 4091 + in31 *  201 + 2048) >> 12;
+    int t17a = (in17 * 3035 - in15 * 2751 + 2048) >> 12;
+    int t30a = (in17 * 2751 + in15 * 3035 + 2048) >> 12;
+    int t18a = (in9  * 1751 - in23 * 3703 + 2048) >> 12;
+    int t29a = (in9  * 3703 + in23 * 1751 + 2048) >> 12;
+    int t19a = (in25 * 3857 - in7  * 1380 + 2048) >> 12;
+    int t28a = (in25 * 1380 + in7  * 3857 + 2048) >> 12;
+    int t20a = (in5  *  995 - in27 * 3973 + 2048) >> 12;
+    int t27a = (in5  * 3973 + in27 *  995 + 2048) >> 12;
+    int t21a = (in21 * 3513 - in11 * 2106 + 2048) >> 12;
+    int t26a = (in21 * 2106 + in11 * 3513 + 2048) >> 12;
+    int t22a = (in13 * 2440 - in19 * 3290 + 2048) >> 12;
+    int t25a = (in13 * 3290 + in19 * 2440 + 2048) >> 12;
+    int t23a = (in29 * 4052 - in3  *  601 + 2048) >> 12;
+    int t24a = (in29 *  601 + in3  * 4052 + 2048) >> 12;
+
+    int t16 = t16a + t17a;
+    int t17 = t16a - t17a;
+    int t18 = t19a - t18a;
+    int t19 = t19a + t18a;
+    int t20 = t20a + t21a;
+    int t21 = t20a - t21a;
+    int t22 = t23a - t22a;
+    int t23 = t23a + t22a;
+    int t24 = t24a + t25a;
+    int t25 = t24a - t25a;
+    int t26 = t27a - t26a;
+    int t27 = t27a + t26a;
+    int t28 = t28a + t29a;
+    int t29 = t28a - t29a;
+    int t30 = t31a - t30a;
+    int t31 = t31a + t30a;
+
+    t17a = (  t30 *  799 - t17 * 4017  + 2048) >> 12;
+    t30a = (  t30 * 4017 + t17 *  799  + 2048) >> 12;
+    t18a = (-(t29 * 4017 + t18 *  799) + 2048) >> 12;
+    t29a = (  t29 *  799 - t18 * 4017  + 2048) >> 12;
+    t21a = (  t26 * 3406 - t21 * 2276  + 2048) >> 12;
+    t26a = (  t26 * 2276 + t21 * 3406  + 2048) >> 12;
+    t22a = (-(t25 * 2276 + t22 * 3406) + 2048) >> 12;
+    t25a = (  t25 * 3406 - t22 * 2276  + 2048) >> 12;
+
+    t16a = t16  + t19;
+    t17  = t17a + t18a;
+    t18  = t17a - t18a;
+    t19a = t16  - t19;
+    t20a = t23  - t20;
+    t21  = t22a - t21a;
+    t22  = t22a + t21a;
+    t23a = t23  + t20;
+    t24a = t24  + t27;
+    t25  = t25a + t26a;
+    t26  = t25a - t26a;
+    t27a = t24  - t27;
+    t28a = t31  - t28;
+    t29  = t30a - t29a;
+    t30  = t30a + t29a;
+    t31a = t31  + t28;
+
+    t18a = (  t29  * 1567 - t18  * 3784  + 2048) >> 12;
+    t29a = (  t29  * 3784 + t18  * 1567  + 2048) >> 12;
+    t19  = (  t28a * 1567 - t19a * 3784  + 2048) >> 12;
+    t28  = (  t28a * 3784 + t19a * 1567  + 2048) >> 12;
+    t20  = (-(t27a * 3784 + t20a * 1567) + 2048) >> 12;
+    t27  = (  t27a * 1567 - t20a * 3784  + 2048) >> 12;
+    t21a = (-(t26  * 3784 + t21  * 1567) + 2048) >> 12;
+    t26a = (  t26  * 1567 - t21  * 3784  + 2048) >> 12;
+
+    t16  = t16a + t23a;
+    t17a = t17  + t22;
+    t18  = t18a + t21a;
+    t19a = t19  + t20;
+    t20a = t19  - t20;
+    t21  = t18a - t21a;
+    t22a = t17  - t22;
+    t23  = t16a - t23a;
+    t24  = t31a - t24a;
+    t25a = t30  - t25;
+    t26  = t29a - t26a;
+    t27a = t28  - t27;
+    t28a = t28  + t27;
+    t29  = t29a + t26a;
+    t30a = t30  + t25;
+    t31  = t31a + t24a;
+
+    t20  = ((t27a - t20a) * 2896 + 2048) >> 12;
+    t27  = ((t27a + t20a) * 2896 + 2048) >> 12;
+    t21a = ((t26  - t21 ) * 2896 + 2048) >> 12;
+    t26a = ((t26  + t21 ) * 2896 + 2048) >> 12;
+    t22  = ((t25a - t22a) * 2896 + 2048) >> 12;
+    t25  = ((t25a + t22a) * 2896 + 2048) >> 12;
+    t23a = ((t24  - t23 ) * 2896 + 2048) >> 12;
+    t24a = ((t24  + t23 ) * 2896 + 2048) >> 12;
+
+    out[ 0 * out_s] = tmp[ 0] + t31;
+    out[ 1 * out_s] = tmp[ 1] + t30a;
+    out[ 2 * out_s] = tmp[ 2] + t29;
+    out[ 3 * out_s] = tmp[ 3] + t28a;
+    out[ 4 * out_s] = tmp[ 4] + t27;
+    out[ 5 * out_s] = tmp[ 5] + t26a;
+    out[ 6 * out_s] = tmp[ 6] + t25;
+    out[ 7 * out_s] = tmp[ 7] + t24a;
+    out[ 8 * out_s] = tmp[ 8] + t23a;
+    out[ 9 * out_s] = tmp[ 9] + t22;
+    out[10 * out_s] = tmp[10] + t21a;
+    out[11 * out_s] = tmp[11] + t20;
+    out[12 * out_s] = tmp[12] + t19a;
+    out[13 * out_s] = tmp[13] + t18;
+    out[14 * out_s] = tmp[14] + t17a;
+    out[15 * out_s] = tmp[15] + t16;
+    out[16 * out_s] = tmp[15] - t16;
+    out[17 * out_s] = tmp[14] - t17a;
+    out[18 * out_s] = tmp[13] - t18;
+    out[19 * out_s] = tmp[12] - t19a;
+    out[20 * out_s] = tmp[11] - t20;
+    out[21 * out_s] = tmp[10] - t21a;
+    out[22 * out_s] = tmp[ 9] - t22;
+    out[23 * out_s] = tmp[ 8] - t23a;
+    out[24 * out_s] = tmp[ 7] - t24a;
+    out[25 * out_s] = tmp[ 6] - t25;
+    out[26 * out_s] = tmp[ 5] - t26a;
+    out[27 * out_s] = tmp[ 4] - t27;
+    out[28 * out_s] = tmp[ 3] - t28a;
+    out[29 * out_s] = tmp[ 2] - t29;
+    out[30 * out_s] = tmp[ 1] - t30a;
+    out[31 * out_s] = tmp[ 0] - t31;
+}
+
+static void __attribute__((noinline))
+inv_dct64_1d(const coef *const in, const ptrdiff_t in_s,
+             coef *const out, const ptrdiff_t out_s)
+{
+    coef tmp[32];
+
+    inv_dct32_1d(in, in_s * 2, tmp, 1);
+
+    const int in1  = in[ 1 * in_s], in3  = in[ 3 * in_s];
+    const int in5  = in[ 5 * in_s], in7  = in[ 7 * in_s];
+    const int in9  = in[ 9 * in_s], in11 = in[11 * in_s];
+    const int in13 = in[13 * in_s], in15 = in[15 * in_s];
+    const int in17 = in[17 * in_s], in19 = in[19 * in_s];
+    const int in21 = in[21 * in_s], in23 = in[23 * in_s];
+    const int in25 = in[25 * in_s], in27 = in[27 * in_s];
+    const int in29 = in[29 * in_s], in31 = in[31 * in_s];
+    const int in33 = in[33 * in_s], in35 = in[35 * in_s];
+    const int in37 = in[37 * in_s], in39 = in[39 * in_s];
+    const int in41 = in[41 * in_s], in43 = in[43 * in_s];
+    const int in45 = in[45 * in_s], in47 = in[47 * in_s];
+    const int in49 = in[49 * in_s], in51 = in[51 * in_s];
+    const int in53 = in[53 * in_s], in55 = in[55 * in_s];
+    const int in57 = in[57 * in_s], in59 = in[59 * in_s];
+    const int in61 = in[61 * in_s], in63 = in[63 * in_s];
+
+    int t32a = (in1  *  101 - in63 * 4095 + 2048) >> 12;
+    int t33a = (in33 * 2967 - in31 * 2824 + 2048) >> 12;
+    int t34a = (in17 * 1660 - in47 * 3745 + 2048) >> 12;
+    int t35a = (in49 * 3822 - in15 * 1474 + 2048) >> 12;
+    int t36a = (in9  *  897 - in55 * 3996 + 2048) >> 12;
+    int t37a = (in41 * 3461 - in23 * 2191 + 2048) >> 12;
+    int t38a = (in25 * 2359 - in39 * 3349 + 2048) >> 12;
+    int t39a = (in57 * 4036 - in7  *  700 + 2048) >> 12;
+    int t40a = (in5  *  501 - in59 * 4065 + 2048) >> 12;
+    int t41a = (in37 * 3229 - in27 * 2520 + 2048) >> 12;
+    int t42a = (in21 * 2019 - in43 * 3564 + 2048) >> 12;
+    int t43a = (in53 * 3948 - in11 * 1092 + 2048) >> 12;
+    int t44a = (in13 * 1285 - in51 * 3889 + 2048) >> 12;
+    int t45a = (in45 * 3659 - in19 * 1842 + 2048) >> 12;
+    int t46a = (in29 * 2675 - in35 * 3102 + 2048) >> 12;
+    int t47a = (in61 * 4085 - in3  *  301 + 2048) >> 12;
+    int t48a = (in61 *  301 + in3  * 4085 + 2048) >> 12;
+    int t49a = (in29 * 3102 + in35 * 2675 + 2048) >> 12;
+    int t50a = (in45 * 1842 + in19 * 3659 + 2048) >> 12;
+    int t51a = (in13 * 3889 + in51 * 1285 + 2048) >> 12;
+    int t52a = (in53 * 1092 + in11 * 3948 + 2048) >> 12;
+    int t53a = (in21 * 3564 + in43 * 2019 + 2048) >> 12;
+    int t54a = (in37 * 2520 + in27 * 3229 + 2048) >> 12;
+    int t55a = (in5  * 4065 + in59 *  501 + 2048) >> 12;
+    int t56a = (in57 *  700 + in7  * 4036 + 2048) >> 12;
+    int t57a = (in25 * 3349 + in39 * 2359 + 2048) >> 12;
+    int t58a = (in41 * 2191 + in23 * 3461 + 2048) >> 12;
+    int t59a = (in9  * 3996 + in55 *  897 + 2048) >> 12;
+    int t60a = (in49 * 1474 + in15 * 3822 + 2048) >> 12;
+    int t61a = (in17 * 3745 + in47 * 1660 + 2048) >> 12;
+    int t62a = (in33 * 2824 + in31 * 2967 + 2048) >> 12;
+    int t63a = (in1  * 4095 + in63 *  101 + 2048) >> 12;
+
+    int t32 = t32a + t33a;
+    int t33 = t32a - t33a;
+    int t34 = t35a - t34a;
+    int t35 = t35a + t34a;
+    int t36 = t36a + t37a;
+    int t37 = t36a - t37a;
+    int t38 = t39a - t38a;
+    int t39 = t39a + t38a;
+    int t40 = t40a + t41a;
+    int t41 = t40a - t41a;
+    int t42 = t43a - t42a;
+    int t43 = t43a + t42a;
+    int t44 = t44a + t45a;
+    int t45 = t44a - t45a;
+    int t46 = t47a - t46a;
+    int t47 = t47a + t46a;
+    int t48 = t48a + t49a;
+    int t49 = t48a - t49a;
+    int t50 = t51a - t50a;
+    int t51 = t51a + t50a;
+    int t52 = t52a + t53a;
+    int t53 = t52a - t53a;
+    int t54 = t55a - t54a;
+    int t55 = t55a + t54a;
+    int t56 = t56a + t57a;
+    int t57 = t56a - t57a;
+    int t58 = t59a - t58a;
+    int t59 = t59a + t58a;
+    int t60 = t60a + t61a;
+    int t61 = t60a - t61a;
+    int t62 = t63a - t62a;
+    int t63 = t63a + t62a;
+
+    t33a = (t33 * -4076 + t62 *   401 + 2048) >> 12;
+    t34a = (t34 * - 401 + t61 * -4076 + 2048) >> 12;
+    t37a = (t37 * -2598 + t58 *  3166 + 2048) >> 12;
+    t38a = (t38 * -3166 + t57 * -2598 + 2048) >> 12;
+    t41a = (t41 * -3612 + t54 *  1931 + 2048) >> 12;
+    t42a = (t42 * -1931 + t53 * -3612 + 2048) >> 12;
+    t45a = (t45 * -1189 + t50 *  3920 + 2048) >> 12;
+    t46a = (t46 * -3920 + t49 * -1189 + 2048) >> 12;
+    t49a = (t46 * -1189 + t49 *  3920 + 2048) >> 12;
+    t50a = (t45 *  3920 + t50 *  1189 + 2048) >> 12;
+    t53a = (t42 * -3612 + t53 *  1931 + 2048) >> 12;
+    t54a = (t41 *  1931 + t54 *  3612 + 2048) >> 12;
+    t57a = (t38 * -2598 + t57 *  3166 + 2048) >> 12;
+    t58a = (t37 *  3166 + t58 *  2598 + 2048) >> 12;
+    t61a = (t34 * -4076 + t61 *   401 + 2048) >> 12;
+    t62a = (t33 *   401 + t62 *  4076 + 2048) >> 12;
+
+    t32a = t32  + t35;
+    t33  = t33a + t34a;
+    t34  = t33a - t34a;
+    t35a = t32  - t35;
+    t36a = t39  - t36;
+    t37  = t38a - t37a;
+    t38  = t38a + t37a;
+    t39a = t39  + t36;
+    t40a = t40  + t43;
+    t41  = t41a + t42a;
+    t42  = t41a - t42a;
+    t43a = t40  - t43;
+    t44a = t47  - t44;
+    t45  = t46a - t45a;
+    t46  = t46a + t45a;
+    t47a = t47  + t44;
+    t48a = t48  + t51;
+    t49  = t49a + t50a;
+    t50  = t49a - t50a;
+    t51a = t48  - t51;
+    t52a = t55  - t52;
+    t53  = t54a - t53a;
+    t54  = t54a + t53a;
+    t55a = t55  + t52;
+    t56a = t56  + t59;
+    t57  = t57a + t58a;
+    t58  = t57a - t58a;
+    t59a = t56  - t59;
+    t60a = t63  - t60;
+    t61  = t62a - t61a;
+    t62  = t62a + t61a;
+    t63a = t63  + t60;
+
+    t34a = (t34  * -4017 + t61  *   799 + 2048) >> 12;
+    t35  = (t35a * -4017 + t60a *   799 + 2048) >> 12;
+    t36  = (t36a * - 799 + t59a * -4017 + 2048) >> 12;
+    t37a = (t37  * - 799 + t58  * -4017 + 2048) >> 12;
+    t42a = (t42  * -2276 + t53  *  3406 + 2048) >> 12;
+    t43  = (t43a * -2276 + t52a *  3406 + 2048) >> 12;
+    t44  = (t44a * -3406 + t51a * -2276 + 2048) >> 12;
+    t45a = (t45  * -3406 + t50  * -2276 + 2048) >> 12;
+    t50a = (t45  * -2276 + t50  *  3406 + 2048) >> 12;
+    t51  = (t44a * -2276 + t51a *  3406 + 2048) >> 12;
+    t52  = (t43a *  3406 + t52a *  2276 + 2048) >> 12;
+    t53a = (t42  *  3406 + t53  *  2276 + 2048) >> 12;
+    t58a = (t37  * -4017 + t58  *   799 + 2048) >> 12;
+    t59  = (t36a * -4017 + t59a *   799 + 2048) >> 12;
+    t60  = (t35a *   799 + t60a *  4017 + 2048) >> 12;
+    t61a = (t34  *   799 + t61  *  4017 + 2048) >> 12;
+
+    t32  = t32a + t39a;
+    t33a = t33  + t38;
+    t34  = t34a + t37a;
+    t35a = t35  + t36;
+    t36a = t35  - t36;
+    t37  = t34a - t37a;
+    t38a = t33  - t38;
+    t39  = t32a - t39a;
+    t40  = t47a - t40a;
+    t41a = t46  - t41;
+    t42  = t45a - t42a;
+    t43a = t44  - t43;
+    t44a = t44  + t43;
+    t45  = t45a + t42a;
+    t46a = t46  + t41;
+    t47  = t47a + t40a;
+    t48  = t48a + t55a;
+    t49a = t49  + t54;
+    t50  = t50a + t53a;
+    t51a = t51  + t52;
+    t52a = t51  - t52;
+    t53  = t50a - t53a;
+    t54a = t49  - t54;
+    t55  = t48a - t55a;
+    t56  = t63a - t56a;
+    t57a = t62  - t57;
+    t58  = t61a - t58a;
+    t59a = t60  - t59;
+    t60a = t60  + t59;
+    t61  = t61a + t58a;
+    t62a = t62  + t57;
+    t63  = t63a + t56a;
+
+    t36  = (t36a * -3784 + t59a *  1567 + 2048) >> 12;
+    t37a = (t37  * -3784 + t58  *  1567 + 2048) >> 12;
+    t38  = (t38a * -3784 + t57a *  1567 + 2048) >> 12;
+    t39a = (t39  * -3784 + t56  *  1567 + 2048) >> 12;
+    t40a = (t40  * -1567 + t55  * -3784 + 2048) >> 12;
+    t41  = (t41a * -1567 + t54a * -3784 + 2048) >> 12;
+    t42a = (t42  * -1567 + t53  * -3784 + 2048) >> 12;
+    t43  = (t43a * -1567 + t52a * -3784 + 2048) >> 12;
+    t52  = (t43a * -3784 + t52a *  1567 + 2048) >> 12;
+    t53a = (t42  * -3784 + t53  *  1567 + 2048) >> 12;
+    t54  = (t41a * -3784 + t54a *  1567 + 2048) >> 12;
+    t55a = (t40  * -3784 + t55  *  1567 + 2048) >> 12;
+    t56a = (t39  *  1567 + t56  *  3784 + 2048) >> 12;
+    t57  = (t38a *  1567 + t57a *  3784 + 2048) >> 12;
+    t58a = (t37  *  1567 + t58  *  3784 + 2048) >> 12;
+    t59  = (t36a *  1567 + t59a *  3784 + 2048) >> 12;
+
+    t32a = t32  + t47;
+    t33  = t33a + t46a;
+    t34a = t34  + t45;
+    t35  = t35a + t44a;
+    t36a = t36  + t43;
+    t37  = t37a + t42a;
+    t38a = t38  + t41;
+    t39  = t39a + t40a;
+    t40  = t39a - t40a;
+    t41a = t38  - t41;
+    t42  = t37a - t42a;
+    t43a = t36  - t43;
+    t44  = t35a - t44a;
+    t45a = t34  - t45;
+    t46  = t33a - t46a;
+    t47a = t32  - t47;
+    t48a = t63  - t48;
+    t49  = t62a - t49a;
+    t50a = t61  - t50;
+    t51  = t60a - t51a;
+    t52a = t59  - t52;
+    t53  = t58a - t53a;
+    t54a = t57  - t54;
+    t55  = t56a - t55a;
+    t56  = t56a + t55a;
+    t57a = t57  + t54;
+    t58  = t58a + t53a;
+    t59a = t59  + t52;
+    t60  = t60a + t51a;
+    t61a = t61  + t50;
+    t62  = t62a + t49a;
+    t63a = t63  + t48;
+
+    t40a = (t40  * -2896 + t55  * 2896 + 2048) >> 12;
+    t41  = (t41a * -2896 + t54a * 2896 + 2048) >> 12;
+    t42a = (t42  * -2896 + t53  * 2896 + 2048) >> 12;
+    t43  = (t43a * -2896 + t52a * 2896 + 2048) >> 12;
+    t44a = (t44  * -2896 + t51  * 2896 + 2048) >> 12;
+    t45  = (t45a * -2896 + t50a * 2896 + 2048) >> 12;
+    t46a = (t46  * -2896 + t49  * 2896 + 2048) >> 12;
+    t47  = (t47a * -2896 + t48a * 2896 + 2048) >> 12;
+    t48  = (t47a *  2896 + t48a * 2896 + 2048) >> 12;
+    t49a = (t46  *  2896 + t49  * 2896 + 2048) >> 12;
+    t50  = (t45a *  2896 + t50a * 2896 + 2048) >> 12;
+    t51a = (t44  *  2896 + t51  * 2896 + 2048) >> 12;
+    t52  = (t43a *  2896 + t52a * 2896 + 2048) >> 12;
+    t53a = (t42  *  2896 + t53  * 2896 + 2048) >> 12;
+    t54  = (t41a *  2896 + t54a * 2896 + 2048) >> 12;
+    t55a = (t40  *  2896 + t55  * 2896 + 2048) >> 12;
+
+    out[ 0 * out_s] = tmp[ 0] + t63a;
+    out[ 1 * out_s] = tmp[ 1] + t62;
+    out[ 2 * out_s] = tmp[ 2] + t61a;
+    out[ 3 * out_s] = tmp[ 3] + t60;
+    out[ 4 * out_s] = tmp[ 4] + t59a;
+    out[ 5 * out_s] = tmp[ 5] + t58;
+    out[ 6 * out_s] = tmp[ 6] + t57a;
+    out[ 7 * out_s] = tmp[ 7] + t56;
+    out[ 8 * out_s] = tmp[ 8] + t55a;
+    out[ 9 * out_s] = tmp[ 9] + t54;
+    out[10 * out_s] = tmp[10] + t53a;
+    out[11 * out_s] = tmp[11] + t52;
+    out[12 * out_s] = tmp[12] + t51a;
+    out[13 * out_s] = tmp[13] + t50;
+    out[14 * out_s] = tmp[14] + t49a;
+    out[15 * out_s] = tmp[15] + t48;
+    out[16 * out_s] = tmp[16] + t47;
+    out[17 * out_s] = tmp[17] + t46a;
+    out[18 * out_s] = tmp[18] + t45;
+    out[19 * out_s] = tmp[19] + t44a;
+    out[20 * out_s] = tmp[20] + t43;
+    out[21 * out_s] = tmp[21] + t42a;
+    out[22 * out_s] = tmp[22] + t41;
+    out[23 * out_s] = tmp[23] + t40a;
+    out[24 * out_s] = tmp[24] + t39;
+    out[25 * out_s] = tmp[25] + t38a;
+    out[26 * out_s] = tmp[26] + t37;
+    out[27 * out_s] = tmp[27] + t36a;
+    out[28 * out_s] = tmp[28] + t35;
+    out[29 * out_s] = tmp[29] + t34a;
+    out[30 * out_s] = tmp[30] + t33;
+    out[31 * out_s] = tmp[31] + t32a;
+    out[32 * out_s] = tmp[31] - t32a;
+    out[33 * out_s] = tmp[30] - t33;
+    out[34 * out_s] = tmp[29] - t34a;
+    out[35 * out_s] = tmp[28] - t35;
+    out[36 * out_s] = tmp[27] - t36a;
+    out[37 * out_s] = tmp[26] - t37;
+    out[38 * out_s] = tmp[25] - t38a;
+    out[39 * out_s] = tmp[24] - t39;
+    out[40 * out_s] = tmp[23] - t40a;
+    out[41 * out_s] = tmp[22] - t41;
+    out[42 * out_s] = tmp[21] - t42a;
+    out[43 * out_s] = tmp[20] - t43;
+    out[44 * out_s] = tmp[19] - t44a;
+    out[45 * out_s] = tmp[18] - t45;
+    out[46 * out_s] = tmp[17] - t46a;
+    out[47 * out_s] = tmp[16] - t47;
+    out[48 * out_s] = tmp[15] - t48;
+    out[49 * out_s] = tmp[14] - t49a;
+    out[50 * out_s] = tmp[13] - t50;
+    out[51 * out_s] = tmp[12] - t51a;
+    out[52 * out_s] = tmp[11] - t52;
+    out[53 * out_s] = tmp[10] - t53a;
+    out[54 * out_s] = tmp[ 9] - t54;
+    out[55 * out_s] = tmp[ 8] - t55a;
+    out[56 * out_s] = tmp[ 7] - t56;
+    out[57 * out_s] = tmp[ 6] - t57a;
+    out[58 * out_s] = tmp[ 5] - t58;
+    out[59 * out_s] = tmp[ 4] - t59a;
+    out[60 * out_s] = tmp[ 3] - t60;
+    out[61 * out_s] = tmp[ 2] - t61a;
+    out[62 * out_s] = tmp[ 1] - t62;
+    out[63 * out_s] = tmp[ 0] - t63a;
+}
+
+static void __attribute__((noinline))
+inv_adst4_1d(const coef *const in, const ptrdiff_t in_s,
+             coef *const out, const ptrdiff_t out_s)
+{
+    const int in0 = in[0 * in_s], in1 = in[1 * in_s];
+    const int in2 = in[2 * in_s], in3 = in[3 * in_s];
+
+    int t0 = 1321 * in0 + 3803 * in2 + 2482 * in3;
+    int t1 = 2482 * in0 - 1321 * in2 - 3803 * in3;
+    int t2 = 3344 * (in0 - in2 + in3);
+    int t3 = 3344 * in1;
+
+    out[0 * out_s] = (t0 + t3      + 2048) >> 12;
+    out[1 * out_s] = (t1 + t3      + 2048) >> 12;
+    out[2 * out_s] = (t2           + 2048) >> 12;
+    out[3 * out_s] = (t0 + t1 - t3 + 2048) >> 12;
+}
+
+static void __attribute__((noinline))
+inv_adst8_1d(const coef *const in, const ptrdiff_t in_s,
+             coef *const out, const ptrdiff_t out_s)
+{
+    const int in0 = in[0 * in_s], in1 = in[1 * in_s];
+    const int in2 = in[2 * in_s], in3 = in[3 * in_s];
+    const int in4 = in[4 * in_s], in5 = in[5 * in_s];
+    const int in6 = in[6 * in_s], in7 = in[7 * in_s];
+
+    int t0a = (4076 * in7 +  401 * in0 + 2048) >> 12;
+    int t1a = ( 401 * in7 - 4076 * in0 + 2048) >> 12;
+    int t2a = (3612 * in5 + 1931 * in2 + 2048) >> 12;
+    int t3a = (1931 * in5 - 3612 * in2 + 2048) >> 12;
+    int t4a = (2598 * in3 + 3166 * in4 + 2048) >> 12;
+    int t5a = (3166 * in3 - 2598 * in4 + 2048) >> 12;
+    int t6a = (1189 * in1 + 3920 * in6 + 2048) >> 12;
+    int t7a = (3920 * in1 - 1189 * in6 + 2048) >> 12;
+
+    int t0 = t0a + t4a;
+    int t1 = t1a + t5a;
+    int t2 = t2a + t6a;
+    int t3 = t3a + t7a;
+    int t4 = t0a - t4a;
+    int t5 = t1a - t5a;
+    int t6 = t2a - t6a;
+    int t7 = t3a - t7a;
+
+    t4a = (3784 * t4 + 1567 * t5 + 2048) >> 12;
+    t5a = (1567 * t4 - 3784 * t5 + 2048) >> 12;
+    t6a = (3784 * t7 - 1567 * t6 + 2048) >> 12;
+    t7a = (1567 * t7 + 3784 * t6 + 2048) >> 12;
+
+    out[0 * out_s] =   t0 + t2;
+    out[7 * out_s] = -(t1 + t3);
+    t2             =   t0 - t2;
+    t3             =   t1 - t3;
+
+    out[1 * out_s] = -(t4a + t6a);
+    out[6 * out_s] =   t5a + t7a;
+    t6             =   t4a - t6a;
+    t7             =   t5a - t7a;
+
+    out[3 * out_s] = -(((t2 + t3) * 2896 + 2048) >> 12);
+    out[4 * out_s] =   ((t2 - t3) * 2896 + 2048) >> 12;
+    out[2 * out_s] =   ((t6 + t7) * 2896 + 2048) >> 12;
+    out[5 * out_s] = -(((t6 - t7) * 2896 + 2048) >> 12);
+}
+
+static void __attribute__((noinline))
+inv_adst16_1d(const coef *const in, const ptrdiff_t in_s,
+              coef *const out, const ptrdiff_t out_s)
+{
+    const int in0  = in[ 0 * in_s], in1  = in[ 1 * in_s];
+    const int in2  = in[ 2 * in_s], in3  = in[ 3 * in_s];
+    const int in4  = in[ 4 * in_s], in5  = in[ 5 * in_s];
+    const int in6  = in[ 6 * in_s], in7  = in[ 7 * in_s];
+    const int in8  = in[ 8 * in_s], in9  = in[ 9 * in_s];
+    const int in10 = in[10 * in_s], in11 = in[11 * in_s];
+    const int in12 = in[12 * in_s], in13 = in[13 * in_s];
+    const int in14 = in[14 * in_s], in15 = in[15 * in_s];
+
+    int t0  = (in15 * 4091 + in0  *  201 + 2048) >> 12;
+    int t1  = (in15 *  201 - in0  * 4091 + 2048) >> 12;
+    int t2  = (in13 * 3973 + in2  *  995 + 2048) >> 12;
+    int t3  = (in13 *  995 - in2  * 3973 + 2048) >> 12;
+    int t4  = (in11 * 3703 + in4  * 1751 + 2048) >> 12;
+    int t5  = (in11 * 1751 - in4  * 3703 + 2048) >> 12;
+    int t6  = (in9  * 3290 + in6  * 2440 + 2048) >> 12;
+    int t7  = (in9  * 2440 - in6  * 3290 + 2048) >> 12;
+    int t8  = (in7  * 2751 + in8  * 3035 + 2048) >> 12;
+    int t9  = (in7  * 3035 - in8  * 2751 + 2048) >> 12;
+    int t10 = (in5  * 2106 + in10 * 3513 + 2048) >> 12;
+    int t11 = (in5  * 3513 - in10 * 2106 + 2048) >> 12;
+    int t12 = (in3  * 1380 + in12 * 3857 + 2048) >> 12;
+    int t13 = (in3  * 3857 - in12 * 1380 + 2048) >> 12;
+    int t14 = (in1  *  601 + in14 * 4052 + 2048) >> 12;
+    int t15 = (in1  * 4052 - in14 *  601 + 2048) >> 12;
+
+    int t0a  = t0 + t8;
+    int t1a  = t1 + t9;
+    int t2a  = t2 + t10;
+    int t3a  = t3 + t11;
+    int t4a  = t4 + t12;
+    int t5a  = t5 + t13;
+    int t6a  = t6 + t14;
+    int t7a  = t7 + t15;
+    int t8a  = t0 - t8;
+    int t9a  = t1 - t9;
+    int t10a = t2 - t10;
+    int t11a = t3 - t11;
+    int t12a = t4 - t12;
+    int t13a = t5 - t13;
+    int t14a = t6 - t14;
+    int t15a = t7 - t15;
+
+    t8   = (t8a  * 4017 + t9a  *  799 + 2048) >> 12;
+    t9   = (t8a  *  799 - t9a  * 4017 + 2048) >> 12;
+    t10  = (t10a * 2276 + t11a * 3406 + 2048) >> 12;
+    t11  = (t10a * 3406 - t11a * 2276 + 2048) >> 12;
+    t12  = (t13a * 4017 - t12a *  799 + 2048) >> 12;
+    t13  = (t13a *  799 + t12a * 4017 + 2048) >> 12;
+    t14  = (t15a * 2276 - t14a * 3406 + 2048) >> 12;
+    t15  = (t15a * 3406 + t14a * 2276 + 2048) >> 12;
+
+    t0   = t0a + t4a;
+    t1   = t1a + t5a;
+    t2   = t2a + t6a;
+    t3   = t3a + t7a;
+    t4   = t0a - t4a;
+    t5   = t1a - t5a;
+    t6   = t2a - t6a;
+    t7   = t3a - t7a;
+    t8a  = t8  + t12;
+    t9a  = t9  + t13;
+    t10a = t10 + t14;
+    t11a = t11 + t15;
+    t12a = t8  - t12;
+    t13a = t9  - t13;
+    t14a = t10 - t14;
+    t15a = t11 - t15;
+
+    t4a  = (t4   * 3784 + t5   * 1567 + 2048) >> 12;
+    t5a  = (t4   * 1567 - t5   * 3784 + 2048) >> 12;
+    t6a  = (t7   * 3784 - t6   * 1567 + 2048) >> 12;
+    t7a  = (t7   * 1567 + t6   * 3784 + 2048) >> 12;
+    t12  = (t12a * 3784 + t13a * 1567 + 2048) >> 12;
+    t13  = (t12a * 1567 - t13a * 3784 + 2048) >> 12;
+    t14  = (t15a * 3784 - t14a * 1567 + 2048) >> 12;
+    t15  = (t15a * 1567 + t14a * 3784 + 2048) >> 12;
+
+    out[ 0 * out_s] =   t0  + t2;
+    out[15 * out_s] = -(t1  + t3);
+    t2a             =   t0  - t2;
+    t3a             =   t1  - t3;
+    out[ 3 * out_s] = -(t4a + t6a);
+    out[12 * out_s] =   t5a + t7a;
+    t6              =   t4a - t6a;
+    t7              =   t5a - t7a;
+    out[ 1 * out_s] = -(t8a + t10a);
+    out[14 * out_s] =   t9a + t11a;
+    t10             =   t8a - t10a;
+    t11             =   t9a - t11a;
+    out[ 2 * out_s] =   t12 + t14;
+    out[13 * out_s] = -(t13 + t15);
+    t14a            =   t12 - t14;
+    t15a            =   t13 - t15;
+
+    out[ 7 * out_s] = -(((t2a  + t3a)  * 2896 + 2048) >> 12);
+    out[ 8 * out_s] =   ((t2a  - t3a)  * 2896 + 2048) >> 12;
+    out[ 4 * out_s] =   ((t6   + t7)   * 2896 + 2048) >> 12;
+    out[11 * out_s] = -(((t6   - t7)   * 2896 + 2048) >> 12);
+    out[ 6 * out_s] =   ((t10  + t11)  * 2896 + 2048) >> 12;
+    out[ 9 * out_s] = -(((t10  - t11)  * 2896 + 2048) >> 12);
+    out[ 5 * out_s] = -(((t14a + t15a) * 2896 + 2048) >> 12);
+    out[10 * out_s] =   ((t14a - t15a) * 2896 + 2048) >> 12;
+}
+
+#define flip_inv_adst(sz) \
+static void inv_flipadst##sz##_1d(const coef *const in, const ptrdiff_t in_s, \
+                                  coef *const out, const ptrdiff_t out_s) \
+{ \
+    inv_adst##sz##_1d(in, in_s, &out[(sz - 1) * out_s], -out_s); \
+}
+
+flip_inv_adst(4);
+flip_inv_adst(8);
+flip_inv_adst(16);
+
+#undef flip_inv_adst
+
+static void __attribute__((noinline))
+inv_identity4_1d(const coef *const in, const ptrdiff_t in_s,
+                 coef *const out, const ptrdiff_t out_s)
+{
+    for (int i = 0; i < 4; i++)
+        out[out_s * i] = (in[in_s * i] * 5793 + 2048) >> 12;
+}
+
+static void __attribute__((noinline))
+inv_identity8_1d(const coef *const in, const ptrdiff_t in_s,
+                 coef *const out, const ptrdiff_t out_s)
+{
+    for (int i = 0; i < 8; i++)
+        out[out_s * i] = in[in_s * i] * 2;
+}
+
+static void __attribute__((noinline))
+inv_identity16_1d(const coef *const in, const ptrdiff_t in_s,
+                  coef *const out, const ptrdiff_t out_s)
+{
+    for (int i = 0; i < 16; i++)
+        out[out_s * i] = (in[in_s * i] * 2 * 5793 + 2048) >> 12;
+}
+
+static void __attribute__((noinline))
+inv_identity32_1d(const coef *const in, const ptrdiff_t in_s,
+                  coef *const out, const ptrdiff_t out_s)
+{
+    for (int i = 0; i < 32; i++)
+        out[out_s * i] = in[in_s * i] * 4;
+}
+
+static void __attribute__((noinline))
+inv_wht4_1d(const coef *const in, const ptrdiff_t in_s,
+            coef *const out, const ptrdiff_t out_s,
+            const int pass)
+{
+    const int sh = 2 * !pass;
+    const int in0 = in[0 * in_s] >> sh, in1 = in[1 * in_s] >> sh;
+    const int in2 = in[2 * in_s] >> sh, in3 = in[3 * in_s] >> sh;
+    const int t0 = in0 + in1;
+    const int t2 = in2 - in3;
+    const int t4 = (t0 - t2) >> 1;
+    const int t3 = t4 - in3;
+    const int t1 = t4 - in1;
+
+    out[0 * out_s] = t0 - t3;
+    out[1 * out_s] = t3;
+    out[2 * out_s] = t1;
+    out[3 * out_s] = t2 + t1;
+}
diff --git a/src/levels.h b/src/levels.h
new file mode 100644
index 0000000..d339f92
--- /dev/null
+++ b/src/levels.h
@@ -0,0 +1,525 @@
+/*
+ * Copyright © 2018, VideoLAN and dav1d authors
+ * Copyright © 2018, Two Orioles, LLC
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright notice, this
+ *    list of conditions and the following disclaimer.
+ *
+ * 2. Redistributions in binary form must reproduce the above copyright notice,
+ *    this list of conditions and the following disclaimer in the documentation
+ *    and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
+ * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#ifndef __DAV1D_SRC_LEVELS_H__
+#define __DAV1D_SRC_LEVELS_H__
+
+#include "dav1d/picture.h"
+
+enum ObuType {
+    OBU_SEQ_HDR   = 1,
+    OBU_TD        = 2,
+    OBU_FRAME_HDR = 3,
+    OBU_TILE_GRP  = 4,
+    OBU_METADATA  = 5,
+    OBU_FRAME     = 6,
+    OBU_PADDING   = 15,
+};
+
+enum FrameType {
+    KEY_FRAME       = 0,
+    INTER_FRAME     = 1,
+    INTRAONLY_FRAME = 2,
+    S_FRAME         = 3,
+} FRAME_TYPE;
+
+enum TxfmSize {
+    TX_4X4,
+    TX_8X8,
+    TX_16X16,
+    TX_32X32,
+    TX_64X64,
+    N_TX_SIZES,
+};
+
+enum BlockLevel {
+    BL_128X128,
+    BL_64X64,
+    BL_32X32,
+    BL_16X16,
+    BL_8X8,
+    N_BL_LEVELS,
+};
+
+enum TxfmMode {
+    TX_4X4_ONLY,
+    TX_LARGEST,
+    TX_SWITCHABLE,
+    N_TX_MODES,
+};
+
+enum RectTxfmSize {
+    RTX_4X8 = N_TX_SIZES,
+    RTX_8X4,
+    RTX_8X16,
+    RTX_16X8,
+    RTX_16X32,
+    RTX_32X16,
+    RTX_32X64,
+    RTX_64X32,
+    RTX_4X16,
+    RTX_16X4,
+    RTX_8X32,
+    RTX_32X8,
+    RTX_16X64,
+    RTX_64X16,
+    N_RECT_TX_SIZES
+};
+
+enum TxfmType {
+    DCT_DCT,    // DCT  in both horizontal and vertical
+    ADST_DCT,   // ADST in vertical, DCT in horizontal
+    DCT_ADST,   // DCT  in vertical, ADST in horizontal
+    ADST_ADST,  // ADST in both directions
+    FLIPADST_DCT,
+    DCT_FLIPADST,
+    FLIPADST_FLIPADST,
+    ADST_FLIPADST,
+    FLIPADST_ADST,
+    IDTX,
+    V_DCT,
+    H_DCT,
+    V_ADST,
+    H_ADST,
+    V_FLIPADST,
+    H_FLIPADST,
+    N_TX_TYPES,
+    WHT_WHT = N_TX_TYPES,
+    N_TX_TYPES_PLUS_LL,
+};
+
+enum TxfmTypeSet {
+    TXTP_SET_DCT,
+    TXTP_SET_DCT_ID,
+    TXTP_SET_DT4_ID,
+    TXTP_SET_DT4_ID_1D,
+    TXTP_SET_DT9_ID_1D,
+    TXTP_SET_ALL,
+    TXTP_SET_LOSSLESS,
+    N_TXTP_SETS
+};
+
+enum TxClass {
+    TX_CLASS_2D,
+    TX_CLASS_H,
+    TX_CLASS_V,
+};
+
+enum IntraPredMode {
+    DC_PRED,
+    VERT_PRED,
+    HOR_PRED,
+    DIAG_DOWN_LEFT_PRED,
+    DIAG_DOWN_RIGHT_PRED,
+    VERT_RIGHT_PRED,
+    HOR_DOWN_PRED,
+    HOR_UP_PRED,
+    VERT_LEFT_PRED,
+    SMOOTH_PRED,
+    SMOOTH_V_PRED,
+    SMOOTH_H_PRED,
+    PAETH_PRED,
+    N_INTRA_PRED_MODES,
+    CFL_PRED = N_INTRA_PRED_MODES,
+    N_UV_INTRA_PRED_MODES,
+    N_IMPL_INTRA_PRED_MODES = N_UV_INTRA_PRED_MODES,
+    LEFT_DC_PRED = DIAG_DOWN_LEFT_PRED,
+    TOP_DC_PRED,
+    DC_128_PRED,
+    Z1_PRED,
+    Z2_PRED,
+    Z3_PRED,
+    FILTER_PRED = N_INTRA_PRED_MODES,
+};
+
+enum InterIntraPredMode {
+    II_DC_PRED,
+    II_VERT_PRED,
+    II_HOR_PRED,
+    II_SMOOTH_PRED,
+    N_INTER_INTRA_PRED_MODES,
+};
+
+enum BlockPartition {
+    PARTITION_NONE,     // [ ] <-.
+    PARTITION_H,        // [-]   |
+    PARTITION_V,        // [|]   |
+    PARTITION_SPLIT,    // [+] --'
+    PARTITION_T_TOP_SPLIT,    // [⊥] i.e. split top, H bottom
+    PARTITION_T_BOTTOM_SPLIT, // [т] i.e. H top, split bottom
+    PARTITION_T_LEFT_SPLIT,   // [-|] i.e. split left, V right
+    PARTITION_T_RIGHT_SPLIT,  // [|-] i.e. V left, split right
+    PARTITION_H4,       // [Ⲷ]
+    PARTITION_V4,       // [Ⲽ]
+    N_PARTITIONS,
+    N_SUB8X8_PARTITIONS = PARTITION_T_TOP_SPLIT,
+};
+
+enum BlockSize {
+    BS_128x128,
+    BS_128x64,
+    BS_64x128,
+    BS_64x64,
+    BS_64x32,
+    BS_64x16,
+    BS_32x64,
+    BS_32x32,
+    BS_32x16,
+    BS_32x8,
+    BS_16x64,
+    BS_16x32,
+    BS_16x16,
+    BS_16x8,
+    BS_16x4,
+    BS_8x32,
+    BS_8x16,
+    BS_8x8,
+    BS_8x4,
+    BS_4x16,
+    BS_4x8,
+    BS_4x4,
+    N_BS_SIZES,
+};
+
+enum FilterMode {
+    FILTER_8TAP_REGULAR,
+    FILTER_8TAP_SMOOTH,
+    FILTER_8TAP_SHARP,
+    N_SWITCHABLE_FILTERS,
+    FILTER_BILINEAR = N_SWITCHABLE_FILTERS,
+    N_FILTERS,
+    FILTER_SWITCHABLE = N_FILTERS,
+};
+
+enum Filter2d { // order is horizontal, vertical
+    FILTER_2D_8TAP_REGULAR,
+    FILTER_2D_8TAP_REGULAR_SMOOTH,
+    FILTER_2D_8TAP_REGULAR_SHARP,
+    FILTER_2D_8TAP_SHARP_REGULAR,
+    FILTER_2D_8TAP_SHARP_SMOOTH,
+    FILTER_2D_8TAP_SHARP,
+    FILTER_2D_8TAP_SMOOTH_REGULAR,
+    FILTER_2D_8TAP_SMOOTH,
+    FILTER_2D_8TAP_SMOOTH_SHARP,
+    FILTER_2D_BILINEAR,
+    N_2D_FILTERS,
+};
+
+enum MVJoint {
+    MV_JOINT_ZERO,
+    MV_JOINT_H,
+    MV_JOINT_V,
+    MV_JOINT_HV,
+    N_MV_JOINTS,
+};
+
+enum InterPredMode {
+    NEARESTMV,
+    NEARMV,
+    GLOBALMV,
+    NEWMV,
+    N_INTER_PRED_MODES,
+};
+
+enum CompInterPredMode {
+    NEARESTMV_NEARESTMV,
+    NEARMV_NEARMV,
+    NEARESTMV_NEWMV,
+    NEWMV_NEARESTMV,
+    NEARMV_NEWMV,
+    NEWMV_NEARMV,
+    GLOBALMV_GLOBALMV,
+    NEWMV_NEWMV,
+    N_COMP_INTER_PRED_MODES,
+};
+
+enum CompInterType {
+    COMP_INTER_NONE,
+    COMP_INTER_WEIGHTED_AVG,
+    COMP_INTER_AVG,
+    COMP_INTER_SEG,
+    COMP_INTER_WEDGE,
+};
+
+enum InterIntraType {
+    INTER_INTRA_NONE,
+    INTER_INTRA_BLEND,
+    INTER_INTRA_WEDGE,
+};
+
+enum AdaptiveBoolean {
+    OFF = 0,
+    ON = 1,
+    ADAPTIVE = 2,
+};
+
+enum RestorationType {
+    RESTORATION_NONE,
+    RESTORATION_SWITCHABLE,
+    RESTORATION_WIENER,
+    RESTORATION_SGRPROJ,
+};
+
+typedef struct mv {
+    int16_t y, x;
+} mv;
+
+enum WarpedMotionType {
+    WM_TYPE_IDENTITY,
+    WM_TYPE_TRANSLATION,
+    WM_TYPE_ROT_ZOOM,
+    WM_TYPE_AFFINE,
+};
+
+typedef struct WarpedMotionParams {
+    enum WarpedMotionType type;
+    int32_t matrix[6];
+    union {
+        struct {
+            int16_t alpha, beta, gamma, delta;
+        };
+        int16_t abcd[4];
+    };
+} WarpedMotionParams;
+
+enum MotionMode {
+    MM_TRANSLATION,
+    MM_OBMC,
+    MM_WARP,
+};
+
+typedef struct Av1SequenceHeader {
+    int profile;
+    int still_picture;
+    int reduced_still_picture_header;
+    int timing_info_present;
+    int num_units_in_tick;
+    int time_scale;
+    int equal_picture_interval;
+    int num_ticks_per_picture;
+    int decoder_model_info_present;
+    int bitrate_scale;
+    int buffer_size_scale;
+    int encoder_decoder_buffer_delay_length;
+    int num_units_in_decoding_tick;
+    int buffer_removal_delay_length;
+    int frame_presentation_delay_length;
+    int display_model_info_present;
+    int num_operating_points;
+    struct Av1SequenceHeaderOperatingPoint {
+        int idc;
+        int major_level, minor_level;
+        int tier;
+        int decoder_model_param_present;
+        int bitrate;
+        int buffer_size;
+        int cbr;
+        int decoder_buffer_delay;
+        int encoder_buffer_delay;
+        int low_delay_mode;
+        int display_model_param_present;
+        int initial_display_delay;
+    } operating_points[32];
+    int max_width, max_height, width_n_bits, height_n_bits;
+    int frame_id_numbers_present;
+    int delta_frame_id_n_bits;
+    int frame_id_n_bits;
+    int sb128;
+    int filter_intra;
+    int intra_edge_filter;
+    int inter_intra;
+    int masked_compound;
+    int warped_motion;
+    int dual_filter;
+    int order_hint;
+    int jnt_comp;
+    int ref_frame_mvs;
+    enum AdaptiveBoolean screen_content_tools;
+    enum AdaptiveBoolean force_integer_mv;
+    int order_hint_n_bits;
+    int super_res;
+    int cdef;
+    int restoration;
+    int bpc;
+    int hbd;
+    int color_description_present;
+    enum Dav1dPixelLayout layout;
+    enum Dav1dColorPrimaries pri;
+    enum Dav1dTransferCharacteristics trc;
+    enum Dav1dMatrixCoefficients mtrx;
+    enum Dav1dChromaSamplePosition chr;
+    int color_range;
+    int separate_uv_delta_q;
+    int film_grain_present;
+} Av1SequenceHeader;
+
+#define NUM_SEGMENTS 8
+
+typedef struct Av1SegmentationData {
+    int delta_q;
+    int delta_lf_y_v, delta_lf_y_h, delta_lf_u, delta_lf_v;
+    int ref;
+    int skip;
+    int globalmv;
+} Av1SegmentationData;
+
+typedef struct Av1SegmentationDataSet {
+    Av1SegmentationData d[NUM_SEGMENTS];
+    int preskip;
+    int last_active_segid;
+} Av1SegmentationDataSet;
+
+typedef struct Av1LoopfilterModeRefDeltas {
+    int mode_delta[2];
+    int ref_delta[8];
+} Av1LoopfilterModeRefDeltas;
+
+typedef struct Av1FilmGrainData {
+    int num_y_points;
+    uint8_t y_points[14][2 /* value, scaling */];
+    int chroma_scaling_from_luma;
+    int num_uv_points[2];
+    uint8_t uv_points[2][10][2 /* value, scaling */];
+    int scaling_shift;
+    int ar_coeff_lag;
+    int8_t ar_coeffs_y[24];
+    int8_t ar_coeffs_uv[2][25];
+    int ar_coeff_shift;
+    int grain_scale_shift;
+    int uv_mult[2];
+    int uv_luma_mult[2];
+    int uv_offset[2];
+    int overlap_flag;
+    int clip_to_restricted_range;
+} Av1FilmGrainData;
+
+typedef struct Av1FrameHeader {
+    int show_existing_frame;
+    int existing_frame_idx;
+    int frame_id;
+    enum FrameType frame_type;
+    int show_frame;
+    int showable_frame;
+    int error_resilient_mode;
+    int disable_cdf_update;
+    int allow_screen_content_tools;
+    int force_integer_mv;
+    int frame_size_override;
+#define PRIMARY_REF_NONE 7
+    int primary_ref_frame;
+    int frame_offset;
+    int refresh_frame_flags;
+    int width, height;
+    int render_width, render_height;
+    int super_res;
+    int have_render_size;
+    int allow_intrabc;
+    int frame_ref_short_signaling;
+    int refidx[7];
+    int hp;
+    enum FilterMode subpel_filter_mode;
+    int switchable_motion_mode;
+    int use_ref_frame_mvs;
+    int refresh_context;
+    struct {
+        int uniform;
+        int n_bytes;
+        int min_log2_cols, max_log2_cols, log2_cols, cols;
+        int col_start_sb[1025];
+        int min_log2_rows, max_log2_rows, log2_rows, rows;
+        int row_start_sb[1025];
+        int update;
+    } tiling;
+    struct {
+        int yac;
+        int ydc_delta;
+        int udc_delta, uac_delta, vdc_delta, vac_delta;
+        int qm, qm_y, qm_u, qm_v;
+    } quant;
+    struct {
+        int enabled, update_map, temporal, update_data;
+        Av1SegmentationDataSet seg_data;
+        int lossless[NUM_SEGMENTS], qidx[NUM_SEGMENTS];
+    } segmentation;
+    int delta_q_present;
+    int delta_q_res_log2;
+    int delta_lf_present;
+    int delta_lf_res_log2;
+    int delta_lf_multi;
+    int all_lossless;
+    struct {
+        int level_y[2];
+        int level_u, level_v;
+        int mode_ref_delta_enabled;
+        int mode_ref_delta_update;
+        Av1LoopfilterModeRefDeltas mode_ref_deltas;
+        int sharpness;
+    } loopfilter;
+    struct {
+        int damping;
+        int n_bits;
+        int y_strength[8];
+        int uv_strength[8];
+    } cdef;
+    struct {
+        enum RestorationType type[3];
+        int unit_size[2];
+    } restoration;
+    enum TxfmMode txfm_mode;
+    int switchable_comp_refs;
+    int skip_mode_allowed, skip_mode_enabled, skip_mode_refs[2];
+    int warp_motion;
+    int reduced_txtp_set;
+    WarpedMotionParams gmv[7];
+    struct {
+        int present, update, seed;
+        Av1FilmGrainData data;
+    } film_grain;
+} Av1FrameHeader;
+
+#define QINDEX_RANGE 256
+
+typedef struct Av1Block {
+    uint8_t bl, bs, bp;
+    uint8_t intra, seg_id, skip_mode, skip, uvtx;
+    union {
+        struct {
+            uint8_t y_mode, uv_mode, tx, pal_sz[2];
+            int8_t y_angle, uv_angle, cfl_alpha[2];
+        }; // intra
+        struct {
+            int8_t ref[2];
+            uint8_t comp_type, wedge_idx, mask_sign, inter_mode, drl_idx;
+            uint8_t interintra_type, interintra_mode, motion_mode;
+            uint8_t max_ytx, filter2d;
+            uint16_t tx_split[2];
+            mv mv[2];
+        }; // inter
+    };
+} Av1Block;
+
+#endif /* __DAV1D_SRC_LEVELS_H__ */
diff --git a/src/lf_apply.c b/src/lf_apply.c
new file mode 100644
index 0000000..f5a24ef
--- /dev/null
+++ b/src/lf_apply.c
@@ -0,0 +1,330 @@
+/*
+ * Copyright © 2018, VideoLAN and dav1d authors
+ * Copyright © 2018, Two Orioles, LLC
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright notice, this
+ *    list of conditions and the following disclaimer.
+ *
+ * 2. Redistributions in binary form must reproduce the above copyright notice,
+ *    this list of conditions and the following disclaimer in the documentation
+ *    and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
+ * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#include "config.h"
+
+#include <assert.h>
+#include <string.h>
+
+#include "common/intops.h"
+
+#include "src/lf_apply.h"
+
+static inline int maxifzero(const uint8_t (*const a)[4], const int have_b,
+                            const uint8_t (*const b)[4], const int diridx)
+{
+    const int a_val = (*a)[diridx];
+    if (a_val) return a_val;
+    if (!have_b) return a_val;
+    return (*b)[diridx];
+}
+
+static inline void filter_plane_cols_y(const Dav1dFrameContext *const f,
+                                       const int have_left,
+                                       const uint8_t (*lvl)[4],
+                                       const ptrdiff_t b4_stride,
+                                       const uint32_t (*const mask)[3],
+                                       pixel *dst, const ptrdiff_t ls,
+                                       const int starty4, const int endy4)
+{
+    const Dav1dDSPContext *const dsp = f->dsp;
+
+    // filter edges between columns (e.g. block1 | block2)
+    for (int y = starty4; y < endy4;
+         y++, dst += 4 * PXSTRIDE(ls), lvl += b4_stride)
+    {
+        pixel *ptr = dst;
+        const uint8_t (*l)[4] = lvl;
+        const uint32_t *const hmask = mask[y];
+        const unsigned hm = hmask[0] | hmask[1] | hmask[2];
+
+        for (unsigned x = 1; hm & ~(x - 1); l++, x <<= 1, ptr += 4) {
+            if ((have_left || x > 1) && (hm & x)) {
+                const int L = maxifzero(l, have_left || x > 1, &l[-1], 0);
+                if (!L) continue;
+                const int H = L >> 4;
+                const int E = f->lf.lim_lut.e[L], I = f->lf.lim_lut.i[L];
+                const int idx = (hmask[2] & x) ? 2 : !!(hmask[1] & x);
+
+                dsp->lf.loop_filter[idx][0](ptr, ls, E, I, H);
+            }
+        }
+    }
+}
+
+static inline void filter_plane_rows_y(const Dav1dFrameContext *const f,
+                                       const int have_top,
+                                       const uint8_t (*lvl)[4],
+                                       const ptrdiff_t b4_stride,
+                                       const uint32_t (*const mask)[3],
+                                       pixel *dst, const ptrdiff_t ls,
+                                       const int starty4, const int endy4)
+{
+    const Dav1dDSPContext *const dsp = f->dsp;
+
+    //                                 block1
+    // filter edges between rows (e.g. ------)
+    //                                 block2
+    for (int y = starty4; y < endy4;
+         y++, dst += 4 * PXSTRIDE(ls), lvl += b4_stride)
+    {
+        pixel *ptr = dst;
+        const uint8_t (*l)[4] = lvl;
+        const uint32_t *const vmask = mask[y];
+        const unsigned vm = vmask[0] | vmask[1] | vmask[2];
+
+        for (unsigned x = 1; vm & ~(x - 1); x <<= 1, ptr += 4, l++) {
+            if ((have_top || y) && (vm & x)) {
+                const int L = maxifzero(l, have_top || y, &l[-b4_stride], 1);
+                if (!L) continue;
+                const int H = L >> 4;
+                const int E = f->lf.lim_lut.e[L], I = f->lf.lim_lut.i[L];
+                const int idx = (vmask[2] & x) ? 2 : !!(vmask[1] & x);
+
+                dsp->lf.loop_filter[idx][1](ptr, ls, E, I, H);
+            }
+        }
+    }
+}
+
+static inline void filter_plane_cols_uv(const Dav1dFrameContext *const f,
+                                        const int have_left,
+                                        const uint8_t (*lvl)[4],
+                                        const ptrdiff_t b4_stride,
+                                        const uint32_t (*const mask)[2],
+                                        pixel *const u, pixel *const v,
+                                        const ptrdiff_t ls,
+                                        const int starty4, const int endy4)
+{
+    const Dav1dDSPContext *const dsp = f->dsp;
+    int y;
+    ptrdiff_t off_l;
+    const int ss_ver = f->cur.p.p.layout == DAV1D_PIXEL_LAYOUT_I420;
+    const int ss_hor = f->cur.p.p.layout != DAV1D_PIXEL_LAYOUT_I444;
+    const int hstep = 1 << ss_hor;
+
+    // filter edges between columns (e.g. block1 | block2)
+    lvl += ss_hor + ss_ver * b4_stride;
+    for (off_l = 0, y = starty4; y < endy4;
+         y++, off_l += 4 * PXSTRIDE(ls), lvl += b4_stride << ss_ver)
+    {
+        ptrdiff_t off = off_l;
+        const uint8_t (*l)[4] = lvl;
+        const uint32_t *const hmask = mask[y];
+        const unsigned hm = hmask[0] | hmask[1];
+
+        for (unsigned x = 1; hm & ~(x - 1); l += hstep, x <<= 1, off += 4) {
+            if ((have_left || x > 1) && (hm & x)) {
+                const int idx = !!(hmask[1] & x);
+
+                const int Lu = maxifzero(l, have_left || x > 1, &l[-hstep], 2);
+                if (Lu) {
+                    const int H = Lu >> 4;
+                    const int E = f->lf.lim_lut.e[Lu], I = f->lf.lim_lut.i[Lu];
+
+                    dsp->lf.loop_filter_uv[idx][0](&u[off], ls, E, I, H);
+                }
+
+                const int Lv = maxifzero(l, have_left || x > 1, &l[-hstep], 3);
+                if (Lv) {
+                    const int H = Lv >> 4;
+                    const int E = f->lf.lim_lut.e[Lv], I = f->lf.lim_lut.i[Lv];
+
+                    dsp->lf.loop_filter_uv[idx][0](&v[off], ls, E, I, H);
+                }
+            }
+        }
+    }
+}
+
+static inline void filter_plane_rows_uv(const Dav1dFrameContext *const f,
+                                        const int have_top,
+                                        const uint8_t (*lvl)[4],
+                                        const ptrdiff_t b4_stride,
+                                        const uint32_t (*const mask)[2],
+                                        pixel *const u, pixel *const v,
+                                        const ptrdiff_t ls,
+                                        const int starty4, const int endy4)
+{
+    const Dav1dDSPContext *const dsp = f->dsp;
+    int y;
+    ptrdiff_t off_l;
+    const int ss_ver = f->cur.p.p.layout == DAV1D_PIXEL_LAYOUT_I420;
+    const int ss_hor = f->cur.p.p.layout != DAV1D_PIXEL_LAYOUT_I444;
+    const int hstep = 1 << ss_hor;
+
+    //                                 block1
+    // filter edges between rows (e.g. ------)
+    //                                 block2
+    lvl += ss_ver * b4_stride + ss_hor;
+    for (off_l = 0, y = starty4; y < endy4;
+         y++, off_l += 4 * PXSTRIDE(ls), lvl += b4_stride << ss_ver)
+    {
+        ptrdiff_t off = off_l;
+        const uint8_t (*l)[4] = lvl;
+        const uint32_t *const vmask = mask[y];
+        const unsigned vm = vmask[0] | vmask[1];
+
+        for (unsigned x = 1; vm & ~(x - 1); x <<= 1, off += 4, l += hstep) {
+            if ((have_top || y) && (vm & x)) {
+                const int idx = !!(vmask[1] & x);
+
+                const int Lu = maxifzero(l, have_top || y,
+                                         &l[-(b4_stride << ss_ver)], 2);
+                if (Lu) {
+                    const int H = Lu >> 4;
+                    const int E = f->lf.lim_lut.e[Lu], I = f->lf.lim_lut.i[Lu];
+
+                    dsp->lf.loop_filter_uv[idx][1](&u[off], ls, E, I, H);
+                }
+
+                const int Lv = maxifzero(l, have_top || y,
+                                         &l[-(b4_stride << ss_ver)], 3);
+                if (Lv) {
+                    const int H = Lv >> 4;
+                    const int E = f->lf.lim_lut.e[Lv], I = f->lf.lim_lut.i[Lv];
+
+                    dsp->lf.loop_filter_uv[idx][1](&v[off], ls, E, I, H);
+                }
+            }
+        }
+    }
+}
+
+void bytefn(dav1d_loopfilter_sbrow)(const Dav1dFrameContext *const f,
+                                    pixel *const p[3], Av1Filter *const lflvl,
+                                    int sby, const int start_of_tile_row)
+{
+    int x, have_left;
+    const int have_top = sby > 0;
+    const int is_sb64 = !f->seq_hdr.sb128;
+    const int starty4 = (sby & is_sb64) << 4;
+    const int sbsz = 32 >> is_sb64;
+    const int sbl2 = 5 - is_sb64;
+    const int endy4 = starty4 + imin(f->bh - sby * f->sb_step, sbsz);
+    const int halign = (f->bh + 31) & ~31;
+    const int ss_ver = f->cur.p.p.layout == DAV1D_PIXEL_LAYOUT_I420;
+    const int ss_hor = f->cur.p.p.layout != DAV1D_PIXEL_LAYOUT_I444;
+
+    // fix lpf strength at tile col boundaries
+    const uint8_t *lpf_y = &f->lf.tx_lpf_right_edge[0][sby << sbl2];
+    const uint8_t *lpf_uv = &f->lf.tx_lpf_right_edge[1][sby << (sbl2 - ss_ver)];
+    for (int tile_col = 1;; tile_col++) {
+        x = f->frame_hdr.tiling.col_start_sb[tile_col];
+        if ((x << sbl2) >= f->bw) break;
+        const int mask = x & is_sb64 ? 1 << 16 : 1;
+        const int uv_mask = x & is_sb64 ? 1 << (16 >> ss_hor) : 1;
+        x >>= is_sb64;
+        for (int y = starty4; y < endy4; y++) {
+            const int idx = 2 * !!(lflvl[x].filter_y[0][y][2] & mask) +
+                                !!(lflvl[x].filter_y[0][y][1] & mask);
+            lflvl[x].filter_y[0][y][2] &= ~mask;
+            lflvl[x].filter_y[0][y][1] &= ~mask;
+            lflvl[x].filter_y[0][y][0] &= ~mask;
+            lflvl[x].filter_y[0][y][imin(idx, lpf_y[y - starty4])] |= mask;
+        }
+        for (int y = starty4 >> ss_ver; y < (endy4 >> ss_ver); y++) {
+            const int idx = !!(lflvl[x].filter_uv[0][y][1] & uv_mask);
+            lflvl[x].filter_uv[0][y][1] &= ~uv_mask;
+            lflvl[x].filter_uv[0][y][0] &= ~uv_mask;
+            lflvl[x].filter_uv[0][y][imin(idx, lpf_uv[y - (starty4 >> ss_ver)])] |= uv_mask;
+        }
+        lpf_y  += halign;
+        lpf_uv += halign >> ss_ver;
+    }
+
+    // fix lpf strength at tile row boundaries
+    if (start_of_tile_row) {
+        const BlockContext *a;
+        for (x = 0, a = &f->a[f->sb128w * (start_of_tile_row - 1)];
+             x < f->sb128w; x++, a++)
+        {
+            uint32_t *const y_vmask = lflvl[x].filter_y[1][starty4];
+            const unsigned y_vm = y_vmask[0] | y_vmask[1] | y_vmask[2];
+
+            for (unsigned mask = 1, i = 0; i < 32; mask <<= 1, i++) {
+                if (!(y_vm & mask)) continue;
+                const int idx = 2 * !!(y_vmask[2] & mask) + !!(y_vmask[1] & mask);
+                y_vmask[2] &= ~mask;
+                y_vmask[1] &= ~mask;
+                y_vmask[0] &= ~mask;
+                y_vmask[imin(idx, a->tx_lpf_y[i])] |= mask;
+            }
+
+            uint32_t *const uv_vmask = lflvl[x].filter_uv[1][starty4 >> ss_ver];
+            const unsigned uv_vm = uv_vmask[0] | uv_vmask[1];
+            for (unsigned mask = 1, i = 0; i < (32 >> ss_hor); mask <<= 1, i++) {
+                if (!(uv_vm & mask)) continue;
+                const int idx = !!(uv_vmask[1] & mask);
+                uv_vmask[1] &= ~mask;
+                uv_vmask[0] &= ~mask;
+                uv_vmask[imin(idx, a->tx_lpf_uv[i])] |= mask;
+            }
+        }
+    }
+
+    pixel *ptr;
+    uint8_t (*level_ptr)[4] = f->lf.level + f->b4_stride * sby * sbsz;
+    for (ptr = p[0], have_left = 0, x = 0; x < f->sb128w;
+         x++, have_left = 1, ptr += 128, level_ptr += 32)
+    {
+        filter_plane_cols_y(f, have_left, level_ptr, f->b4_stride,
+                            lflvl[x].filter_y[0],
+                            ptr, f->cur.p.stride[0], starty4, endy4);
+    }
+
+    level_ptr = f->lf.level + f->b4_stride * sby * sbsz;
+    for (ptr = p[0], x = 0; x < f->sb128w; x++, ptr += 128, level_ptr += 32) {
+        filter_plane_rows_y(f, have_top, level_ptr, f->b4_stride,
+                            lflvl[x].filter_y[1],
+                            ptr, f->cur.p.stride[0], starty4, endy4);
+    }
+
+    if (!f->frame_hdr.loopfilter.level_u && !f->frame_hdr.loopfilter.level_v)
+        return;
+
+    ptrdiff_t uv_off;
+    level_ptr = f->lf.level + f->b4_stride * sby * sbsz;
+    for (uv_off = 0, have_left = 0, x = 0; x < f->sb128w;
+         x++, have_left = 1, uv_off += 128 >> ss_hor, level_ptr += 32)
+    {
+        filter_plane_cols_uv(f, have_left, level_ptr, f->b4_stride,
+                             lflvl[x].filter_uv[0],
+                             &p[1][uv_off], &p[2][uv_off], f->cur.p.stride[1],
+                             starty4 >> ss_ver, endy4 >> ss_ver);
+    }
+
+    level_ptr = f->lf.level + f->b4_stride * sby * sbsz;
+    for (uv_off = 0, x = 0; x < f->sb128w;
+         x++, uv_off += 128 >> ss_hor, level_ptr += 32)
+    {
+        filter_plane_rows_uv(f, have_top, level_ptr, f->b4_stride,
+                             lflvl[x].filter_uv[1],
+                             &p[1][uv_off], &p[2][uv_off], f->cur.p.stride[1],
+                             starty4 >> ss_ver, endy4 >> ss_ver);
+    }
+}
diff --git a/src/lf_apply.h b/src/lf_apply.h
new file mode 100644
index 0000000..580aafb
--- /dev/null
+++ b/src/lf_apply.h
@@ -0,0 +1,42 @@
+/*
+ * Copyright © 2018, VideoLAN and dav1d authors
+ * Copyright © 2018, Two Orioles, LLC
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright notice, this
+ *    list of conditions and the following disclaimer.
+ *
+ * 2. Redistributions in binary form must reproduce the above copyright notice,
+ *    this list of conditions and the following disclaimer in the documentation
+ *    and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
+ * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#ifndef __DAV1D_SRC_LF_APPLY_H__
+#define __DAV1D_SRC_LF_APPLY_H__
+
+#include <stdint.h>
+
+#include "common/bitdepth.h"
+
+#include "src/internal.h"
+#include "src/levels.h"
+
+void bytefn(dav1d_loopfilter_sbrow)(const Dav1dFrameContext *f,
+                                    pixel *const p[3], Av1Filter *lflvl,
+                                    int sby, int start_of_tile_row);
+
+#endif /* __DAV1D_SRC_LF_APPLY_H__ */
diff --git a/src/lf_mask.c b/src/lf_mask.c
new file mode 100644
index 0000000..9c5572c
--- /dev/null
+++ b/src/lf_mask.c
@@ -0,0 +1,402 @@
+/*
+ * Copyright © 2018, VideoLAN and dav1d authors
+ * Copyright © 2018, Two Orioles, LLC
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright notice, this
+ *    list of conditions and the following disclaimer.
+ *
+ * 2. Redistributions in binary form must reproduce the above copyright notice,
+ *    this list of conditions and the following disclaimer in the documentation
+ *    and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
+ * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#include "config.h"
+
+#include <assert.h>
+#include <string.h>
+
+#include "common/intops.h"
+
+#include "src/levels.h"
+#include "src/lf_mask.h"
+#include "src/tables.h"
+
+static void decomp_tx(uint8_t (*txa)[2 /* txsz, step */][32 /* y */][32 /* x */],
+                      const enum RectTxfmSize from,
+                      const int depth,
+                      const int y_off, const int x_off,
+                      const uint16_t *const tx_masks)
+{
+    const TxfmInfo *const t_dim = &av1_txfm_dimensions[from];
+    int is_split;
+
+    if (depth > 1) {
+        is_split = 0;
+    } else {
+        const int off = y_off * 4 + x_off;
+        is_split = (tx_masks[depth] >> off) & 1;
+    }
+
+    if (is_split) {
+        const enum RectTxfmSize sub = t_dim->sub;
+        const int htw4 = t_dim->w >> 1, hth4 = t_dim->h >> 1;
+
+        decomp_tx(txa, sub, depth + 1, y_off * 2 + 0, x_off * 2 + 0, tx_masks);
+        if (t_dim->w >= t_dim->h)
+            decomp_tx((uint8_t(*)[2][32][32]) &txa[0][0][0][htw4],
+                      sub, depth + 1, y_off * 2 + 0, x_off * 2 + 1, tx_masks);
+        if (t_dim->h >= t_dim->w) {
+            decomp_tx((uint8_t(*)[2][32][32]) &txa[0][0][hth4][0],
+                      sub, depth + 1, y_off * 2 + 1, x_off * 2 + 0, tx_masks);
+            if (t_dim->w >= t_dim->h)
+                decomp_tx((uint8_t(*)[2][32][32]) &txa[0][0][hth4][htw4],
+                          sub, depth + 1, y_off * 2 + 1, x_off * 2 + 1, tx_masks);
+        }
+    } else {
+        const int lw = imin(2, t_dim->lw), lh = imin(2, t_dim->lh);
+        int y;
+
+        for (y = 0; y < t_dim->h; y++) {
+            memset(txa[0][0][y], lw, t_dim->w);
+            memset(txa[1][0][y], lh, t_dim->w);
+            txa[0][1][y][0] = t_dim->w;
+        }
+        memset(txa[1][1][0], t_dim->h, t_dim->w);
+    }
+}
+
+static inline void mask_edges_inter(uint32_t (*masks)[32][3],
+                                    const int by4, const int bx4,
+                                    const int w4, const int h4, const int skip,
+                                    const enum RectTxfmSize max_tx,
+                                    const uint16_t *const tx_masks,
+                                    uint8_t *const a, uint8_t *const l)
+{
+    const TxfmInfo *const t_dim = &av1_txfm_dimensions[max_tx];
+    int y, x;
+
+    uint8_t txa[2 /* edge */][2 /* txsz, step */][32 /* y */][32 /* x */];
+    int y_off, x_off;
+    for (y_off = 0, y = 0; y < h4; y += t_dim->h, y_off++)
+        for (x_off = 0, x = 0; x < w4; x += t_dim->w, x_off++)
+            decomp_tx((uint8_t(*)[2][32][32]) &txa[0][0][y][x],
+                      max_tx, 0, y_off, x_off, tx_masks);
+
+    // left block edge
+    unsigned mask = 1U << bx4;
+    for (y = 0; y < h4; y++)
+        masks[0][by4 + y][imin(txa[0][0][y][0], l[y])] |= mask;
+
+    // top block edge
+    for (x = 0; x < w4; x++, mask <<= 1)
+        masks[1][by4][imin(txa[1][0][0][x], a[x])] |= mask;
+
+    if (!skip) {
+        // inner (tx) left|right edges
+        for (y = 0; y < h4; y++) {
+            int ltx = txa[0][0][y][0];
+            int step = txa[0][1][y][0];
+            for (x = step, mask = 1U << (bx4 + step);
+                 x < w4; x += step, mask <<= step)
+            {
+                const int rtx = txa[0][0][y][x];
+                masks[0][by4 + y][imin(rtx, ltx)] |= mask;
+                ltx = rtx;
+                step = txa[0][1][y][x];
+            }
+        }
+
+        //            top
+        // inner (tx) --- edges
+        //           bottom
+        for (x = 0, mask = 1U << bx4; x < w4; x++, mask <<= 1) {
+            int ttx = txa[1][0][0][x];
+            int step = txa[1][1][0][x];
+            for (y = step; y < h4; y += step) {
+                const int btx = txa[1][0][y][x];
+                masks[1][by4 + y][imin(ttx, btx)] |= mask;
+                ttx = btx;
+                step = txa[1][1][y][x];
+            }
+        }
+    }
+
+    for (y = 0; y < h4; y++)
+        l[y] = txa[0][0][y][w4 - 1];
+    memcpy(a, txa[1][0][h4 - 1], w4);
+}
+
+static inline void mask_edges_intra(uint32_t (*const masks)[32][3],
+                                    const int by4, const int bx4,
+                                    const int w4, const int h4,
+                                    const enum RectTxfmSize tx,
+                                    uint8_t *const a, uint8_t *const l)
+{
+    const TxfmInfo *const t_dim = &av1_txfm_dimensions[tx];
+    const int twl4 = t_dim->lw, thl4 = t_dim->lh;
+    const int twl4c = imin(2, twl4), thl4c = imin(2, thl4);
+    int y, x;
+
+    // left block edge
+    unsigned mask = 1U << bx4;
+    for (y = 0; y < h4; y++)
+        masks[0][by4 + y][imin(twl4c, l[y])] |= mask;
+
+    // top block edge
+    for (mask = 1U << bx4, x = 0; x < w4; x++, mask <<= 1)
+        masks[1][by4][imin(thl4c, a[x])] |= mask;
+
+    static const uint32_t hstep[] = {
+        0xffffffff, 0x55555555, 0x11111111, 0x01010101, 0x00010001
+    };
+
+    // inner (tx) left|right edges
+    const unsigned t = 1U << bx4;
+    const unsigned inner = (((uint64_t) t) << w4) - t;
+    mask = (inner - t) & hstep[twl4];
+    for (y = 0; y < h4; y++)
+        masks[0][by4 + y][twl4c] |= mask;
+
+    //            top
+    // inner (tx) --- edges
+    //           bottom
+    const int vstep = t_dim->h;
+    for (y = vstep; y < h4; y += vstep)
+        masks[1][by4 + y][thl4c] |= inner;
+
+    memset(a, thl4c, w4);
+    memset(l, twl4c, h4);
+}
+
+static inline void mask_edges_chroma(uint32_t (*const masks)[32][2],
+                                     const int cby4, const int cbx4,
+                                     const int cw4, const int ch4,
+                                     const int skip_inter,
+                                     const enum RectTxfmSize tx,
+                                     uint8_t *const a, uint8_t *const l)
+{
+    const TxfmInfo *const t_dim = &av1_txfm_dimensions[tx];
+    const int twl4 = t_dim->lw, thl4 = t_dim->lh;
+    const int twl4c = !!twl4, thl4c = !!thl4;
+    int y, x;
+
+    // left block edge
+    unsigned mask = 1U << cbx4;
+    for (y = 0; y < ch4; y++)
+        masks[0][cby4 + y][imin(twl4c, l[y])] |= mask;
+
+    // top block edge
+    for (mask = 1U << cbx4, x = 0; x < cw4; x++, mask <<= 1)
+        masks[1][cby4][imin(thl4c, a[x])] |= mask;
+
+    if (!skip_inter) {
+        static const uint32_t hstep[] = {
+            0xffffffff, 0x55555555, 0x11111111, 0x01010101
+        };
+
+        // inner (tx) left|right edges
+        const int t = 1U << cbx4;
+        const unsigned inner = (((uint64_t) t) << cw4) - t;
+        mask = (inner - t) & hstep[twl4];
+        for (y = 0; y < ch4; y++)
+            masks[0][cby4 + y][twl4c] |= mask;
+
+        //            top
+        // inner (tx) --- edges
+        //           bottom
+        const int vstep = t_dim->h;
+        for (y = vstep; y < ch4; y += vstep)
+            masks[1][cby4 + y][thl4c] |= inner;
+    }
+
+    memset(a, thl4c, cw4);
+    memset(l, twl4c, ch4);
+}
+
+void dav1d_create_lf_mask_intra(Av1Filter *const lflvl,
+                                uint8_t (*level_cache)[4],
+                                const ptrdiff_t b4_stride,
+                                const Av1FrameHeader *const hdr,
+                                const uint8_t (*filter_level)[8][2],
+                                const int bx, const int by,
+                                const int iw, const int ih,
+                                const enum BlockSize bs,
+                                const enum RectTxfmSize ytx,
+                                const enum RectTxfmSize uvtx,
+                                const enum Dav1dPixelLayout layout,
+                                uint8_t *const ay, uint8_t *const ly,
+                                uint8_t *const auv, uint8_t *const luv)
+{
+    if (!hdr->loopfilter.level_y[0] && !hdr->loopfilter.level_y[1])
+        return;
+
+    const uint8_t *const b_dim = av1_block_dimensions[bs];
+    const int bw4 = imin(iw - bx, b_dim[0]);
+    const int bh4 = imin(ih - by, b_dim[1]);
+    const int bx4 = bx & 31;
+    const int by4 = by & 31;
+
+    level_cache += by * b4_stride + bx;
+    for (int y = 0; y < bh4; y++) {
+        for (int x = 0; x < bw4; x++) {
+            level_cache[x][0] = filter_level[0][0][0];
+            level_cache[x][1] = filter_level[1][0][0];
+            level_cache[x][2] = filter_level[2][0][0];
+            level_cache[x][3] = filter_level[3][0][0];
+        }
+        level_cache += b4_stride;
+    }
+
+    mask_edges_intra(lflvl->filter_y, by4, bx4, bw4, bh4, ytx, ay, ly);
+
+    if (!auv) return;
+
+    const int ss_ver = layout == DAV1D_PIXEL_LAYOUT_I420;
+    const int ss_hor = layout != DAV1D_PIXEL_LAYOUT_I444;
+    const int cbw4 = (bw4 + ss_hor) >> ss_hor;
+    const int cbh4 = (bh4 + ss_ver) >> ss_ver;
+    const int cbx4 = bx4 >> ss_hor;
+    const int cby4 = by4 >> ss_ver;
+
+    mask_edges_chroma(lflvl->filter_uv, cby4, cbx4, cbw4, cbh4, 0, uvtx, auv, luv);
+}
+
+void dav1d_create_lf_mask_inter(Av1Filter *const lflvl,
+                                uint8_t (*level_cache)[4],
+                                const ptrdiff_t b4_stride,
+                                const Av1FrameHeader *const hdr,
+                                const uint8_t (*filter_level)[8][2],
+                                const int bx, const int by,
+                                const int iw, const int ih,
+                                const int skip, const enum BlockSize bs,
+                                const uint16_t *const tx_masks,
+                                const enum RectTxfmSize uvtx,
+                                const enum Dav1dPixelLayout layout,
+                                uint8_t *const ay, uint8_t *const ly,
+                                uint8_t *const auv, uint8_t *const luv)
+{
+    if (!hdr->loopfilter.level_y[0] && !hdr->loopfilter.level_y[1])
+        return;
+
+    const uint8_t *const b_dim = av1_block_dimensions[bs];
+    const int bw4 = imin(iw - bx, b_dim[0]);
+    const int bh4 = imin(ih - by, b_dim[1]);
+    const int bx4 = bx & 31;
+    const int by4 = by & 31;
+
+    level_cache += by * b4_stride + bx;
+    for (int y = 0; y < bh4; y++) {
+        for (int x = 0; x < bw4; x++) {
+            level_cache[x][0] = filter_level[0][0][0];
+            level_cache[x][1] = filter_level[1][0][0];
+            level_cache[x][2] = filter_level[2][0][0];
+            level_cache[x][3] = filter_level[3][0][0];
+        }
+        level_cache += b4_stride;
+    }
+
+    mask_edges_inter(lflvl->filter_y, by4, bx4, bw4, bh4, skip,
+                     av1_max_txfm_size_for_bs[bs][0], tx_masks, ay, ly);
+
+    if (!auv) return;
+
+    const int ss_ver = layout == DAV1D_PIXEL_LAYOUT_I420;
+    const int ss_hor = layout != DAV1D_PIXEL_LAYOUT_I444;
+    const int cbw4 = (bw4 + ss_hor) >> ss_hor;
+    const int cbh4 = (bh4 + ss_ver) >> ss_ver;
+    const int cbx4 = bx4 >> ss_hor;
+    const int cby4 = by4 >> ss_ver;
+
+    mask_edges_chroma(lflvl->filter_uv, cby4, cbx4, cbw4, cbh4, skip, uvtx, auv, luv);
+}
+
+void dav1d_calc_eih(Av1FilterLUT *const lim_lut, const int filter_sharpness) {
+    int level;
+
+    // set E/I/H values from loopfilter level
+    for (level = 0; level < 64; level++) {
+        const int sharp = filter_sharpness;
+        int limit = level;
+
+        if (sharp > 0) {
+            limit >>= (sharp + 3) >> 2;
+            limit = imin(limit, 9 - sharp);
+        }
+        limit = imax(limit, 1);
+
+        lim_lut->i[level] = limit;
+        lim_lut->e[level] = 2 * (level + 2) + limit;
+    }
+}
+
+static void dav1d_calc_lf_value(uint8_t (*const lflvl_values)[2],
+                                const int is_chroma, const int base_lvl,
+                                const int lf_delta, const int seg_delta,
+                                const Av1LoopfilterModeRefDeltas *const mr_delta)
+{
+    const int base = iclip(iclip(base_lvl + lf_delta, 0, 63) + seg_delta, 0, 63);
+
+    if (!base_lvl && is_chroma) {
+        memset(lflvl_values, 0, 8 * 2);
+    } else if (!mr_delta) {
+        memset(lflvl_values, base, 8 * 2);
+    } else {
+        const int sh = base >= 32;
+        lflvl_values[0][0] = lflvl_values[0][1] =
+            iclip(base + (mr_delta->ref_delta[0] * (1 << sh)), 0, 63);
+        for (int r = 1; r < 8; r++) {
+            for (int m = 0; m < 2; m++) {
+                const int delta =
+                    mr_delta->mode_delta[m] + mr_delta->ref_delta[r];
+                lflvl_values[r][m] = iclip(base + (delta * (1 << sh)), 0, 63);
+            }
+        }
+    }
+}
+
+void dav1d_calc_lf_values(uint8_t (*const lflvl_values)[4][8][2],
+                          const Av1FrameHeader *const hdr,
+                          const int8_t lf_delta[4])
+{
+    const int n_seg = hdr->segmentation.enabled ? 8 : 1;
+
+    if (!hdr->loopfilter.level_y[0] && !hdr->loopfilter.level_y[1]) {
+        memset(lflvl_values, 0, 8 * 4 * 2 * n_seg);
+        return;
+    }
+
+    const Av1LoopfilterModeRefDeltas *const mr_deltas =
+        hdr->loopfilter.mode_ref_delta_enabled ?
+        &hdr->loopfilter.mode_ref_deltas : NULL;
+    for (int s = 0; s < n_seg; s++) {
+        const Av1SegmentationData *const segd =
+            hdr->segmentation.enabled ? &hdr->segmentation.seg_data.d[s] : NULL;
+
+        dav1d_calc_lf_value(lflvl_values[s][0], 0, hdr->loopfilter.level_y[0],
+                            lf_delta[0], segd ? segd->delta_lf_y_v : 0, mr_deltas);
+        dav1d_calc_lf_value(lflvl_values[s][1], 0, hdr->loopfilter.level_y[1],
+                            lf_delta[hdr->delta_lf_multi ? 1 : 0],
+                            segd ? segd->delta_lf_y_h : 0, mr_deltas);
+        dav1d_calc_lf_value(lflvl_values[s][2], 1, hdr->loopfilter.level_u,
+                            lf_delta[hdr->delta_lf_multi ? 2 : 0],
+                            segd ? segd->delta_lf_u : 0, mr_deltas);
+        dav1d_calc_lf_value(lflvl_values[s][3], 1, hdr->loopfilter.level_v,
+                            lf_delta[hdr->delta_lf_multi ? 3 : 0],
+                            segd ? segd->delta_lf_v : 0, mr_deltas);
+    }
+}
diff --git a/src/lf_mask.h b/src/lf_mask.h
new file mode 100644
index 0000000..ed7412a
--- /dev/null
+++ b/src/lf_mask.h
@@ -0,0 +1,80 @@
+/*
+ * Copyright © 2018, VideoLAN and dav1d authors
+ * Copyright © 2018, Two Orioles, LLC
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright notice, this
+ *    list of conditions and the following disclaimer.
+ *
+ * 2. Redistributions in binary form must reproduce the above copyright notice,
+ *    this list of conditions and the following disclaimer in the documentation
+ *    and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
+ * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#ifndef __DAV1D_SRC_LF_MASK_H__
+#define __DAV1D_SRC_LF_MASK_H__
+
+#include <stddef.h>
+#include <stdint.h>
+
+#include "src/levels.h"
+
+typedef struct Av1FilterLUT {
+    uint8_t e[64];
+    uint8_t i[64];
+} Av1FilterLUT;
+
+typedef struct Av1RestorationUnit {
+    enum RestorationType type;
+    int16_t filter_h[3];
+    int16_t filter_v[3];
+    uint8_t sgr_idx;
+    int16_t sgr_weights[2];
+} Av1RestorationUnit;
+
+// each struct describes one 128x128 area (1 or 4 SBs)
+typedef struct Av1Filter {
+    // each bit is 1 col
+    uint32_t filter_y[2 /* 0=col, 1=row */][32][3];
+    uint32_t filter_uv[2 /* 0=col, 1=row */][32][2];
+    int8_t cdef_idx[4]; // -1 means "unset"
+    uint32_t noskip_mask[32];
+    Av1RestorationUnit lr[3][4];
+} Av1Filter;
+
+void dav1d_create_lf_mask_intra(Av1Filter *lflvl, uint8_t (*level_cache)[4],
+                                const ptrdiff_t b4_stride,
+                                const Av1FrameHeader *hdr,
+                                const uint8_t (*level)[8][2], int bx, int by,
+                                int iw, int ih, enum BlockSize bs,
+                                enum RectTxfmSize ytx, enum RectTxfmSize uvtx,
+                                enum Dav1dPixelLayout layout, uint8_t *ay,
+                                uint8_t *ly, uint8_t *auv, uint8_t *luv);
+void dav1d_create_lf_mask_inter(Av1Filter *lflvl, uint8_t (*level_cache)[4],
+                                const ptrdiff_t b4_stride,
+                                const Av1FrameHeader *hdr,
+                                const uint8_t (*level)[8][2], int bx, int by,
+                                int iw, int ih, int skip_inter,
+                                enum BlockSize bs, const uint16_t *tx_mask,
+                                enum RectTxfmSize uvtx,
+                                enum Dav1dPixelLayout layout, uint8_t *ay,
+                                uint8_t *ly, uint8_t *auv, uint8_t *luv);
+void dav1d_calc_eih(Av1FilterLUT *lim_lut, int filter_sharpness);
+void dav1d_calc_lf_values(uint8_t (*values)[4][8][2], const Av1FrameHeader *hdr,
+                          const int8_t lf_delta[4]);
+
+#endif /* __DAV1D_SRC_LF_MASK_H__ */
diff --git a/src/lib.c b/src/lib.c
new file mode 100644
index 0000000..7954f49
--- /dev/null
+++ b/src/lib.c
@@ -0,0 +1,297 @@
+/*
+ * Copyright © 2018, VideoLAN and dav1d authors
+ * Copyright © 2018, Two Orioles, LLC
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright notice, this
+ *    list of conditions and the following disclaimer.
+ *
+ * 2. Redistributions in binary form must reproduce the above copyright notice,
+ *    this list of conditions and the following disclaimer in the documentation
+ *    and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
+ * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#include "config.h"
+
+#include <errno.h>
+#include <string.h>
+
+#include "dav1d/dav1d.h"
+#include "dav1d/data.h"
+
+#include "include/version.h"
+
+#include "common/mem.h"
+#include "common/validate.h"
+
+#include "src/internal.h"
+#include "src/obu.h"
+#include "src/qm.h"
+#include "src/ref.h"
+#include "src/thread_task.h"
+#include "src/wedge.h"
+
+void dav1d_init(void) {
+    av1_init_wedge_masks();
+    av1_init_interintra_masks();
+    av1_init_qm_tables();
+}
+
+const char *dav1d_version(void) {
+    return DAV1D_VERSION;
+}
+
+void dav1d_default_settings(Dav1dSettings *const s) {
+    s->n_frame_threads = 1;
+    s->n_tile_threads = 1;
+}
+
+int dav1d_open(Dav1dContext **const c_out,
+               const Dav1dSettings *const s)
+{
+    validate_input_or_ret(c_out != NULL, -EINVAL);
+    validate_input_or_ret(s != NULL, -EINVAL);
+    validate_input_or_ret(s->n_tile_threads >= 1 &&
+                          s->n_tile_threads <= 64, -EINVAL);
+    validate_input_or_ret(s->n_frame_threads >= 1 &&
+                          s->n_frame_threads <= 256, -EINVAL);
+
+    Dav1dContext *const c = *c_out = dav1d_alloc_aligned(sizeof(*c), 32);
+    if (!c) goto error;
+    memset(c, 0, sizeof(*c));
+
+    c->n_fc = s->n_frame_threads;
+    c->fc = dav1d_alloc_aligned(sizeof(*c->fc) * s->n_frame_threads, 32);
+    if (!c->fc) goto error;
+    memset(c->fc, 0, sizeof(*c->fc) * s->n_frame_threads);
+    if (c->n_fc > 1) {
+        c->frame_thread.out_delayed =
+            malloc(sizeof(*c->frame_thread.out_delayed) * c->n_fc);
+        memset(c->frame_thread.out_delayed, 0,
+               sizeof(*c->frame_thread.out_delayed) * c->n_fc);
+    }
+    for (int n = 0; n < s->n_frame_threads; n++) {
+        Dav1dFrameContext *const f = &c->fc[n];
+        f->c = c;
+        f->lf.last_sharpness = -1;
+        f->n_tc = s->n_tile_threads;
+        f->tc = dav1d_alloc_aligned(sizeof(*f->tc) * s->n_tile_threads, 32);
+        if (!f->tc) goto error;
+        memset(f->tc, 0, sizeof(*f->tc) * s->n_tile_threads);
+        if (f->n_tc > 1) {
+            pthread_mutex_init(&f->tile_thread.lock, NULL);
+            pthread_cond_init(&f->tile_thread.cond, NULL);
+            pthread_cond_init(&f->tile_thread.icond, NULL);
+        }
+        for (int m = 0; m < s->n_tile_threads; m++) {
+            Dav1dTileContext *const t = &f->tc[m];
+            t->f = f;
+            t->cf = dav1d_alloc_aligned(32 * 32 * sizeof(int32_t), 32);
+            if (!t->cf) goto error;
+            t->scratch.mem = dav1d_alloc_aligned(128 * 128 * 8, 32);
+            if (!t->scratch.mem) goto error;
+            memset(t->cf, 0, 32 * 32 * sizeof(int32_t));
+            t->emu_edge =
+                dav1d_alloc_aligned(160 * (128 + 7) * sizeof(uint16_t), 32);
+            if (!t->emu_edge) goto error;
+            if (f->n_tc > 1) {
+                pthread_mutex_init(&t->tile_thread.td.lock, NULL);
+                pthread_cond_init(&t->tile_thread.td.cond, NULL);
+                t->tile_thread.fttd = &f->tile_thread;
+                pthread_create(&t->tile_thread.td.thread, NULL, dav1d_tile_task, t);
+            }
+        }
+        f->libaom_cm = av1_alloc_ref_mv_common();
+        if (c->n_fc > 1) {
+            pthread_mutex_init(&f->frame_thread.td.lock, NULL);
+            pthread_cond_init(&f->frame_thread.td.cond, NULL);
+            pthread_create(&f->frame_thread.td.thread, NULL, dav1d_frame_task, f);
+        }
+    }
+
+    // intra edge tree
+    c->intra_edge.root[BL_128X128] = &c->intra_edge.branch_sb128[0].node;
+    init_mode_tree(c->intra_edge.root[BL_128X128], c->intra_edge.tip_sb128, 1);
+    c->intra_edge.root[BL_64X64] = &c->intra_edge.branch_sb64[0].node;
+    init_mode_tree(c->intra_edge.root[BL_64X64], c->intra_edge.tip_sb64, 0);
+
+    return 0;
+
+error:
+    if (c) {
+        if (c->fc) {
+            for (int n = 0; n < c->n_fc; n++)
+                if (c->fc[n].tc)
+                    free(c->fc[n].tc);
+            free(c->fc);
+        }
+        free(c);
+    }
+    fprintf(stderr, "Failed to allocate memory: %s\n", strerror(errno));
+    return -ENOMEM;
+}
+
+int dav1d_decode(Dav1dContext *const c,
+                 Dav1dData *const in, Dav1dPicture *const out)
+{
+    int res;
+
+    validate_input_or_ret(c != NULL, -EINVAL);
+    validate_input_or_ret(out != NULL, -EINVAL);
+
+    while (!in) {
+        if (c->n_fc == 1) return -EAGAIN;
+
+        // flush
+        const unsigned next = c->frame_thread.next;
+        Dav1dFrameContext *const f = &c->fc[next];
+
+        pthread_mutex_lock(&f->frame_thread.td.lock);
+        while (f->n_tile_data > 0)
+            pthread_cond_wait(&f->frame_thread.td.cond,
+                              &f->frame_thread.td.lock);
+        pthread_mutex_unlock(&f->frame_thread.td.lock);
+        Dav1dThreadPicture *const out_delayed =
+            &c->frame_thread.out_delayed[next];
+        if (out_delayed->p.data[0]) {
+            if (++c->frame_thread.next == c->n_fc)
+                c->frame_thread.next = 0;
+            if (out_delayed->visible) {
+                dav1d_picture_ref(out, &out_delayed->p);
+            }
+            dav1d_thread_picture_unref(out_delayed);
+            if (out->data[0]) {
+                return 0;
+            }
+            // else continue
+        } else {
+            return -EAGAIN;
+        }
+    }
+
+    while (in->sz > 0) {
+        if ((res = parse_obus(c, in)) < 0)
+            return res;
+
+        assert(res <= in->sz);
+        in->sz -= res;
+        in->data += res;
+        if (c->out.data[0]) {
+            if (!in->sz) dav1d_data_unref(in);
+            dav1d_picture_ref(out, &c->out);
+            dav1d_picture_unref(&c->out);
+            return 0;
+        }
+    }
+
+    if (c->out.data[0]) {
+        dav1d_picture_ref(out, &c->out);
+        dav1d_picture_unref(&c->out);
+        return 0;
+    }
+
+    return -EAGAIN;
+}
+
+void dav1d_close(Dav1dContext *const c) {
+    validate_input(c != NULL);
+
+    for (int n = 0; n < c->n_fc; n++) {
+        Dav1dFrameContext *const f = &c->fc[n];
+
+        // clean-up threading stuff
+        if (c->n_fc > 1) {
+            pthread_mutex_lock(&f->frame_thread.td.lock);
+            f->frame_thread.die = 1;
+            pthread_cond_signal(&f->frame_thread.td.cond);
+            pthread_mutex_unlock(&f->frame_thread.td.lock);
+            pthread_join(f->frame_thread.td.thread, NULL);
+            freep(&f->frame_thread.b);
+            dav1d_free_aligned(&f->frame_thread.pal_idx);
+            dav1d_free_aligned(&f->frame_thread.cf);
+            freep(&f->frame_thread.tile_start_off);
+            freep(&f->frame_thread.pal);
+            freep(&f->frame_thread.cbi);
+            pthread_mutex_destroy(&f->frame_thread.td.lock);
+            pthread_cond_destroy(&f->frame_thread.td.cond);
+        }
+        if (f->n_tc > 1) {
+            pthread_mutex_lock(&f->tile_thread.lock);
+            for (int m = 0; m < f->n_tc; m++) {
+                Dav1dTileContext *const t = &f->tc[m];
+                t->tile_thread.die = 1;
+            }
+            pthread_cond_broadcast(&f->tile_thread.cond);
+            while (f->tile_thread.available != (1 << f->n_tc) - 1)
+                pthread_cond_wait(&f->tile_thread.icond,
+                                  &f->tile_thread.lock);
+            pthread_mutex_unlock(&f->tile_thread.lock);
+            for (int m = 0; m < f->n_tc; m++) {
+                Dav1dTileContext *const t = &f->tc[m];
+                if (f->n_tc > 1) {
+                    pthread_join(t->tile_thread.td.thread, NULL);
+                    pthread_mutex_destroy(&t->tile_thread.td.lock);
+                    pthread_cond_destroy(&t->tile_thread.td.cond);
+                }
+            }
+            pthread_mutex_destroy(&f->tile_thread.lock);
+            pthread_cond_destroy(&f->tile_thread.cond);
+            pthread_cond_destroy(&f->tile_thread.icond);
+        }
+        for (int m = 0; m < f->n_tc; m++) {
+            Dav1dTileContext *const t = &f->tc[m];
+            dav1d_free_aligned(t->cf);
+            dav1d_free_aligned(t->scratch.mem);
+            dav1d_free_aligned(t->emu_edge);
+        }
+        for (int m = 0; m < f->n_ts; m++) {
+            Dav1dTileState *const ts = &f->ts[m];
+            pthread_cond_destroy(&ts->tile_thread.cond);
+            pthread_mutex_destroy(&ts->tile_thread.lock);
+        }
+        free(f->ts);
+        dav1d_free_aligned(f->tc);
+        dav1d_free_aligned(f->ipred_edge[0]);
+        free(f->a);
+        free(f->lf.mask);
+        free(f->lf.level);
+        free(f->lf.tx_lpf_right_edge[0]);
+        av1_free_ref_mv_common(f->libaom_cm);
+        dav1d_free_aligned(f->lf.cdef_line);
+        dav1d_free_aligned(f->lf.lr_lpf_line);
+    }
+    dav1d_free_aligned(c->fc);
+    if (c->n_fc > 1) {
+        for (int n = 0; n < c->n_fc; n++)
+            if (c->frame_thread.out_delayed[n].p.data[0])
+                dav1d_thread_picture_unref(&c->frame_thread.out_delayed[n]);
+        free(c->frame_thread.out_delayed);
+    }
+    for (int n = 0; n < c->n_tile_data; n++)
+        dav1d_data_unref(&c->tile[n].data);
+    for (int n = 0; n < 8; n++) {
+        if (c->cdf[n].cdf)
+            cdf_thread_unref(&c->cdf[n]);
+        if (c->refs[n].p.p.data[0])
+            dav1d_thread_picture_unref(&c->refs[n].p);
+        if (c->refs[n].refmvs)
+            dav1d_ref_dec(c->refs[n].refmvs);
+        if (c->refs[n].segmap)
+            dav1d_ref_dec(c->refs[n].segmap);
+    }
+    dav1d_free_aligned(c);
+}
diff --git a/src/loopfilter.c b/src/loopfilter.c
new file mode 100644
index 0000000..a460eb7
--- /dev/null
+++ b/src/loopfilter.c
@@ -0,0 +1,195 @@
+/*
+ * Copyright © 2018, VideoLAN and dav1d authors
+ * Copyright © 2018, Two Orioles, LLC
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright notice, this
+ *    list of conditions and the following disclaimer.
+ *
+ * 2. Redistributions in binary form must reproduce the above copyright notice,
+ *    this list of conditions and the following disclaimer in the documentation
+ *    and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
+ * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#include "config.h"
+
+#include <stdlib.h>
+
+#include "common/intops.h"
+
+#include "src/loopfilter.h"
+
+static __attribute__((noinline)) void
+loop_filter(pixel *dst, int E, int I, int H,
+            const ptrdiff_t stridea, const ptrdiff_t strideb, const int wd)
+{
+    int i, F = 1 << (BITDEPTH - 8);
+
+    E <<= BITDEPTH - 8;
+    I <<= BITDEPTH - 8;
+    H <<= BITDEPTH - 8;
+
+    for (i = 0; i < 4; i++, dst += stridea) {
+        int p6, p5, p4, p3, p2;
+        int p1 = dst[strideb * -2], p0 = dst[strideb * -1];
+        int q0 = dst[strideb * +0], q1 = dst[strideb * +1];
+        int q2, q3, q4, q5, q6;
+        int fm, flat8out, flat8in;
+
+        fm = abs(p1 - p0) <= I && abs(q1 - q0) <= I &&
+             abs(p0 - q0) * 2 + (abs(p1 - q1) >> 1) <= E;
+
+        if (wd > 4) {
+            p2 = dst[strideb * -3];
+            q2 = dst[strideb * +2];
+
+            fm &= abs(p2 - p1) <= I && abs(q2 - q1) <= I;
+
+            if (wd > 6) {
+                p3 = dst[strideb * -4];
+                q3 = dst[strideb * +3];
+
+                fm &= abs(p3 - p2) <= I && abs(q3 - q2) <= I;
+            }
+        }
+
+        if (!fm) continue;
+
+        if (wd >= 16) {
+            p6 = dst[strideb * -7];
+            p5 = dst[strideb * -6];
+            p4 = dst[strideb * -5];
+            q4 = dst[strideb * +4];
+            q5 = dst[strideb * +5];
+            q6 = dst[strideb * +6];
+
+            flat8out = abs(p6 - p0) <= F && abs(p5 - p0) <= F &&
+                       abs(p4 - p0) <= F && abs(q4 - q0) <= F &&
+                       abs(q5 - q0) <= F && abs(q6 - q0) <= F;
+        }
+
+        if (wd >= 6)
+            flat8in = abs(p2 - p0) <= F && abs(p1 - p0) <= F &&
+                      abs(q1 - q0) <= F && abs(q2 - q0) <= F;
+
+        if (wd >= 8)
+            flat8in &= abs(p3 - p0) <= F && abs(q3 - q0) <= F;
+
+        if (wd >= 16 && (flat8out & flat8in)) {
+            dst[strideb * -6] = (p6 + p6 + p6 + p6 + p6 + p6 * 2 + p5 * 2 +
+                                 p4 * 2 + p3 + p2 + p1 + p0 + q0 + 8) >> 4;
+            dst[strideb * -5] = (p6 + p6 + p6 + p6 + p6 + p5 * 2 + p4 * 2 +
+                                 p3 * 2 + p2 + p1 + p0 + q0 + q1 + 8) >> 4;
+            dst[strideb * -4] = (p6 + p6 + p6 + p6 + p5 + p4 * 2 + p3 * 2 +
+                                 p2 * 2 + p1 + p0 + q0 + q1 + q2 + 8) >> 4;
+            dst[strideb * -3] = (p6 + p6 + p6 + p5 + p4 + p3 * 2 + p2 * 2 +
+                                 p1 * 2 + p0 + q0 + q1 + q2 + q3 + 8) >> 4;
+            dst[strideb * -2] = (p6 + p6 + p5 + p4 + p3 + p2 * 2 + p1 * 2 +
+                                 p0 * 2 + q0 + q1 + q2 + q3 + q4 + 8) >> 4;
+            dst[strideb * -1] = (p6 + p5 + p4 + p3 + p2 + p1 * 2 + p0 * 2 +
+                                 q0 * 2 + q1 + q2 + q3 + q4 + q5 + 8) >> 4;
+            dst[strideb * +0] = (p5 + p4 + p3 + p2 + p1 + p0 * 2 + q0 * 2 +
+                                 q1 * 2 + q2 + q3 + q4 + q5 + q6 + 8) >> 4;
+            dst[strideb * +1] = (p4 + p3 + p2 + p1 + p0 + q0 * 2 + q1 * 2 +
+                                 q2 * 2 + q3 + q4 + q5 + q6 + q6 + 8) >> 4;
+            dst[strideb * +2] = (p3 + p2 + p1 + p0 + q0 + q1 * 2 + q2 * 2 +
+                                 q3 * 2 + q4 + q5 + q6 + q6 + q6 + 8) >> 4;
+            dst[strideb * +3] = (p2 + p1 + p0 + q0 + q1 + q2 * 2 + q3 * 2 +
+                                 q4 * 2 + q5 + q6 + q6 + q6 + q6 + 8) >> 4;
+            dst[strideb * +4] = (p1 + p0 + q0 + q1 + q2 + q3 * 2 + q4 * 2 +
+                                 q5 * 2 + q6 + q6 + q6 + q6 + q6 + 8) >> 4;
+            dst[strideb * +5] = (p0 + q0 + q1 + q2 + q3 + q4 * 2 + q5 * 2 +
+                                 q6 * 2 + q6 + q6 + q6 + q6 + q6 + 8) >> 4;
+        } else if (wd >= 8 && flat8in) {
+            dst[strideb * -3] = (p3 + p3 + p3 + 2 * p2 + p1 + p0 + q0 + 4) >> 3;
+            dst[strideb * -2] = (p3 + p3 + p2 + 2 * p1 + p0 + q0 + q1 + 4) >> 3;
+            dst[strideb * -1] = (p3 + p2 + p1 + 2 * p0 + q0 + q1 + q2 + 4) >> 3;
+            dst[strideb * +0] = (p2 + p1 + p0 + 2 * q0 + q1 + q2 + q3 + 4) >> 3;
+            dst[strideb * +1] = (p1 + p0 + q0 + 2 * q1 + q2 + q3 + q3 + 4) >> 3;
+            dst[strideb * +2] = (p0 + q0 + q1 + 2 * q2 + q3 + q3 + q3 + 4) >> 3;
+        } else if (wd == 6 && flat8in) {
+            dst[strideb * -2] = (p2 + 2 * p2 + 2 * p1 + 2 * p0 + q0 + 4) >> 3;
+            dst[strideb * -1] = (p2 + 2 * p1 + 2 * p0 + 2 * q0 + q1 + 4) >> 3;
+            dst[strideb * +0] = (p1 + 2 * p0 + 2 * q0 + 2 * q1 + q2 + 4) >> 3;
+            dst[strideb * +1] = (p0 + 2 * q0 + 2 * q1 + 2 * q2 + q2 + 4) >> 3;
+        } else {
+            int hev = abs(p1 - p0) > H || abs(q1 - q0) > H;
+
+#define iclip_diff(v) iclip(v, -128 * (1 << (BITDEPTH - 8)), \
+                                127 * (1 << (BITDEPTH - 8)))
+
+            if (hev) {
+                int f = iclip_diff(p1 - q1), f1, f2;
+                f = iclip_diff(3 * (q0 - p0) + f);
+
+                f1 = imin(f + 4, 127) >> 3;
+                f2 = imin(f + 3, 127) >> 3;
+
+                dst[strideb * -1] = iclip_pixel(p0 + f2);
+                dst[strideb * +0] = iclip_pixel(q0 - f1);
+            } else {
+                int f = iclip_diff(3 * (q0 - p0)), f1, f2;
+
+                f1 = imin(f + 4, 127) >> 3;
+                f2 = imin(f + 3, 127) >> 3;
+
+                dst[strideb * -1] = iclip_pixel(p0 + f2);
+                dst[strideb * +0] = iclip_pixel(q0 - f1);
+
+                f = (f1 + 1) >> 1;
+                dst[strideb * -2] = iclip_pixel(p1 + f);
+                dst[strideb * +1] = iclip_pixel(q1 - f);
+            }
+#undef iclip_diff
+        }
+    }
+}
+
+#define lf_4_fn(dir, wd, stridea, strideb) \
+static void loop_filter_##dir##_##wd##wd_4px_c(pixel *const dst, \
+                                               const ptrdiff_t stride, \
+                                               const int E, const int I, \
+                                               const int H) \
+{ \
+    loop_filter(dst, E, I, H, stridea, strideb, wd); \
+}
+
+#define lf_4_fns(wd) \
+lf_4_fn(h, wd, PXSTRIDE(stride), 1) \
+lf_4_fn(v, wd, 1, PXSTRIDE(stride))
+
+lf_4_fns(4)
+lf_4_fns(6)
+lf_4_fns(8)
+lf_4_fns(16)
+
+#undef lf_4_fn
+#undef lf_4_fns
+
+void bitfn(dav1d_loop_filter_dsp_init)(Dav1dLoopFilterDSPContext *const c) {
+    c->loop_filter[0][0] = loop_filter_h_4wd_4px_c;
+    c->loop_filter[0][1] = loop_filter_v_4wd_4px_c;
+    c->loop_filter[1][0] = loop_filter_h_8wd_4px_c;
+    c->loop_filter[1][1] = loop_filter_v_8wd_4px_c;
+    c->loop_filter[2][0] = loop_filter_h_16wd_4px_c;
+    c->loop_filter[2][1] = loop_filter_v_16wd_4px_c;
+
+    c->loop_filter_uv[0][0] = loop_filter_h_4wd_4px_c;
+    c->loop_filter_uv[0][1] = loop_filter_v_4wd_4px_c;
+    c->loop_filter_uv[1][0] = loop_filter_h_6wd_4px_c;
+    c->loop_filter_uv[1][1] = loop_filter_v_6wd_4px_c;
+}
diff --git a/src/loopfilter.h b/src/loopfilter.h
new file mode 100644
index 0000000..4676978
--- /dev/null
+++ b/src/loopfilter.h
@@ -0,0 +1,56 @@
+/*
+ * Copyright © 2018, VideoLAN and dav1d authors
+ * Copyright © 2018, Two Orioles, LLC
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright notice, this
+ *    list of conditions and the following disclaimer.
+ *
+ * 2. Redistributions in binary form must reproduce the above copyright notice,
+ *    this list of conditions and the following disclaimer in the documentation
+ *    and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
+ * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#ifndef __DAV1D_SRC_LOOPFILTER_H__
+#define __DAV1D_SRC_LOOPFILTER_H__
+
+#include <stdint.h>
+#include <stddef.h>
+
+#include "common/bitdepth.h"
+
+#include "src/levels.h"
+
+#define decl_loopfilter_fn(name) \
+void (name)(pixel *dst, ptrdiff_t stride, int mb_lim, int lim, int hev_thr);
+typedef decl_loopfilter_fn(*loopfilter_fn);
+
+typedef struct Dav1dLoopFilterDSPContext {
+    /*
+     * dimension 1: filter taps (0=4, 1=8, 2=16 for luma; 0=4, 1=6 for chroma)
+     * dimension 2: 0=col-edge filter (h), 1=row-edge filter (v)
+     *
+     * dst/stride are aligned by 4
+     */
+    loopfilter_fn loop_filter[3][2];
+    loopfilter_fn loop_filter_uv[2][2];
+} Dav1dLoopFilterDSPContext;
+
+void dav1d_loop_filter_dsp_init_8bpc(Dav1dLoopFilterDSPContext *c);
+void dav1d_loop_filter_dsp_init_10bpc(Dav1dLoopFilterDSPContext *c);
+
+#endif /* __DAV1D_SRC_LOOPFILTER_H__ */
diff --git a/src/looprestoration.c b/src/looprestoration.c
new file mode 100644
index 0000000..a08d3a5
--- /dev/null
+++ b/src/looprestoration.c
@@ -0,0 +1,577 @@
+/*
+ * Copyright © 2018, VideoLAN and dav1d authors
+ * Copyright © 2018, Two Orioles, LLC
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright notice, this
+ *    list of conditions and the following disclaimer.
+ *
+ * 2. Redistributions in binary form must reproduce the above copyright notice,
+ *    this list of conditions and the following disclaimer in the documentation
+ *    and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
+ * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#include "config.h"
+
+#include <stdlib.h>
+
+#include "common/intops.h"
+
+#include "src/looprestoration.h"
+#include "src/tables.h"
+
+
+// TODO Reuse p when no padding is needed (add and remove lpf pixels in p)
+// TODO Chroma only requires 2 rows of padding.
+static void padding(pixel *dst, const ptrdiff_t dst_stride,
+                    const pixel *p, const ptrdiff_t p_stride,
+                    const pixel *lpf, const ptrdiff_t lpf_stride,
+                    int unit_w, const int stripe_h, const enum LrEdgeFlags edges)
+{
+    const int have_left = !!(edges & LR_HAVE_LEFT);
+    const int have_right = !!(edges & LR_HAVE_RIGHT);
+
+    // Copy more pixels if we don't have to pad them
+    unit_w += 3 * have_left + 3 * have_right;
+    pixel *dst_l = dst + 3 * !have_left;
+    p -= 3 * have_left;
+    lpf -= 3 * have_left;
+
+    if (edges & LR_HAVE_TOP) {
+        // Copy previous loop filtered rows
+        const pixel *const above_1 = lpf;
+        const pixel *const above_2 = above_1 + PXSTRIDE(lpf_stride);
+        pixel_copy(dst_l, above_1, unit_w);
+        pixel_copy(dst_l + PXSTRIDE(dst_stride), above_1, unit_w);
+        pixel_copy(dst_l + 2 * PXSTRIDE(dst_stride), above_2, unit_w);
+    } else {
+        // Pad with first row
+        pixel_copy(dst_l, p, unit_w);
+        pixel_copy(dst_l + PXSTRIDE(dst_stride), p, unit_w);
+        pixel_copy(dst_l + 2 * PXSTRIDE(dst_stride), p, unit_w);
+    }
+
+    pixel *dst_tl = dst_l + 3 * PXSTRIDE(dst_stride);
+    if (edges & LR_HAVE_BOTTOM) {
+        // Copy next loop filtered rows
+        const pixel *const below_1 = lpf + 6 * PXSTRIDE(lpf_stride);
+        const pixel *const below_2 = below_1 + PXSTRIDE(lpf_stride);
+        pixel_copy(dst_tl + stripe_h * PXSTRIDE(dst_stride), below_1, unit_w);
+        pixel_copy(dst_tl + (stripe_h + 1) * PXSTRIDE(dst_stride), below_2, unit_w);
+        pixel_copy(dst_tl + (stripe_h + 2) * PXSTRIDE(dst_stride), below_2, unit_w);
+    } else {
+        // Pad with last row
+        const pixel *const src = p + (stripe_h - 1) * PXSTRIDE(p_stride);
+        pixel_copy(dst_tl + stripe_h * PXSTRIDE(dst_stride), src, unit_w);
+        pixel_copy(dst_tl + (stripe_h + 1) * PXSTRIDE(dst_stride), src, unit_w);
+        pixel_copy(dst_tl + (stripe_h + 2) * PXSTRIDE(dst_stride), src, unit_w);
+    }
+
+    // Inner UNIT_WxSTRIPE_H
+    for (int j = 0; j < stripe_h; j++) {
+        pixel_copy(dst_tl, p, unit_w);
+        dst_tl += PXSTRIDE(dst_stride);
+        p += PXSTRIDE(p_stride);
+    }
+
+    if (!have_right) {
+        pixel *pad = dst_l + unit_w;
+        pixel *row_last = &dst_l[unit_w - 1];
+        // Pad 3x(STRIPE_H+6) with last column
+        for (int j = 0; j < stripe_h + 6; j++) {
+            pixel_set(pad, *row_last, 3);
+            pad += PXSTRIDE(dst_stride);
+            row_last += PXSTRIDE(dst_stride);
+        }
+    }
+
+    if (!have_left) {
+        // Pad 3x(STRIPE_H+6) with first column
+        for (int j = 0; j < stripe_h + 6; j++) {
+            pixel_set(dst, *dst_l, 3);
+            dst += PXSTRIDE(dst_stride);
+            dst_l += PXSTRIDE(dst_stride);
+        }
+    }
+}
+
+// FIXME Could split into luma and chroma specific functions,
+// (since first and last tops are always 0 for chroma)
+// FIXME Could implement a version that requires less temporary memory
+// (should be possible to implement with only 6 rows of temp storage)
+static void wiener_c(pixel *p, const ptrdiff_t p_stride,
+                     const pixel *lpf, const ptrdiff_t lpf_stride,
+                     const int w, const int h,
+                     const int16_t filterh[7], const int16_t filterv[7],
+                     const enum LrEdgeFlags edges)
+{
+    // padding is 3 pixels above and 3 pixels below
+    const ptrdiff_t tmp_stride = sizeof(pixel) * (w + 6);
+    pixel tmp[(h + 6) * PXSTRIDE(tmp_stride)];
+    pixel *tmp_ptr = tmp;
+
+    padding(tmp, tmp_stride, p, p_stride, lpf, lpf_stride, w, h, edges);
+
+    // Values stored between horizontal and vertical filtering don't
+    // fit in a uint8_t.
+    uint16_t hor[(h + 6 /*padding*/) * w];
+    uint16_t *hor_ptr = hor;
+
+    const int round_bits_h = 3 + (BITDEPTH == 12) * 2;
+    const int rounding_off_h = 1 << (round_bits_h - 1);
+    const int clip_limit = 1 << ((BITDEPTH) + 1 + 7 - round_bits_h);
+    for (int j = 0; j < h + 6; j++) {
+        for (int i = 0; i < w; i++) {
+            int sum = (tmp_ptr[i + 3] << 7) + (1 << (BITDEPTH + 6));
+
+            for (int k = 0; k < 7; k++) {
+                sum += tmp_ptr[i + k] * filterh[k];
+            }
+
+            hor_ptr[i] =
+                iclip((sum + rounding_off_h) >> round_bits_h, 0, clip_limit);
+        }
+        tmp_ptr += PXSTRIDE(tmp_stride);
+        hor_ptr += w;
+    }
+
+    const int round_bits_v = 11 - (BITDEPTH == 12) * 2;
+    const int rounding_off_v = 1 << (round_bits_v - 1);
+    const int round_offset = 1 << (BITDEPTH + (round_bits_v - 1));
+    for (int i = 0; i < w; i++) {
+        for (int j = 0; j < h; j++) {
+            int sum = (hor[w * (j + 3) + i] << 7) - round_offset;
+
+            for (int k = 0; k < 7; k++) {
+                sum += hor[(j + k) * w + i] * filterv[k];
+            }
+
+            p[j * PXSTRIDE(p_stride) + i] =
+                iclip_pixel((sum + rounding_off_v) >> round_bits_v);
+        }
+    }
+}
+
+// Sum over a 3x3 area
+// The dst and src pointers are positioned 3 pixels above and 3 pixels to the
+// left of the top left corner. However, the self guided filter only needs 1
+// pixel above and one pixel to the left. As for the pixels below and to the
+// right they must be computed in the sums, but don't need to be stored.
+//
+// Example for a 4x4 block:
+//      x x x x x x x x x x
+//      x c c c c c c c c x
+//      x i s s s s s s i x
+//      x i s s s s s s i x
+//      x i s s s s s s i x
+//      x i s s s s s s i x
+//      x i s s s s s s i x
+//      x i s s s s s s i x
+//      x c c c c c c c c x
+//      x x x x x x x x x x
+//
+// s: Pixel summed and stored
+// i: Pixel summed and stored (between loops)
+// c: Pixel summed not stored
+// x: Pixel not summed not stored
+static void boxsum3(coef *dst, const ptrdiff_t dst_stride,
+                    const pixel *src, ptrdiff_t src_stride,
+                    const int w, const int h)
+{
+    src_stride = PXSTRIDE(src_stride);
+    // We skip the first row, as it is never used
+    src += src_stride;
+    dst += dst_stride;
+
+    // We skip the first and last columns, as they are never used
+    for (int x = 1; x < w - 1; x++) {
+        coef *ds = dst + x;
+        const pixel *s = src + x;
+        int a = s[0], b = s[src_stride];
+
+        // We skip the first 2 rows, as they are skipped in the next loop and
+        // we don't need the last 2 row as it is skipped in the next loop
+        for (int y = 2; y < h - 2; y++) {
+            s += src_stride;
+            const int c = s[src_stride];
+            ds += dst_stride;
+            *ds = a + b + c;
+            a = b;
+            b = c;
+        }
+     }
+
+    // We skip the first 2 rows as they are never read
+    dst += dst_stride;
+    // We skip the last 2 rows as it is never read
+    for (int y = 2; y < h - 2; y++) {
+        int a = dst[1], b = dst[2];
+
+        // We don't store the first column as it is never read and
+        // we don't store the last 2 columns as they are never read
+        for (int x = 2; x < w - 2; x++) {
+            const int c = dst[x + 1];
+            dst[x] = a + b + c;
+            a = b;
+            b = c;
+        }
+        dst += dst_stride;
+    }
+}
+
+// Sum over a 5x5 area
+// The dst and src pointers are positioned 3 pixels above and 3 pixels to the
+// left of the top left corner. However, the self guided filter only needs 1
+// pixel above and one pixel to the left. As for the pixels below and to the
+// right they must be computed in the sums, but don't need to be stored.
+//
+// Example for a 4x4 block:
+//      c c c c c c c c c c
+//      c c c c c c c c c c
+//      i i s s s s s s i i
+//      i i s s s s s s i i
+//      i i s s s s s s i i
+//      i i s s s s s s i i
+//      i i s s s s s s i i
+//      i i s s s s s s i i
+//      c c c c c c c c c c
+//      c c c c c c c c c c
+//
+// s: Pixel summed and stored
+// i: Pixel summed and stored (between loops)
+// c: Pixel summed not stored
+// x: Pixel not summed not stored
+static void boxsum5(coef *dst, const ptrdiff_t dst_stride,
+                    const pixel *const src, ptrdiff_t src_stride,
+                    const int w, const int h)
+{
+    src_stride = PXSTRIDE(src_stride);
+
+    // We skip the first row, as it is never used
+    dst += dst_stride;
+
+    for (int x = 0; x < w; x++) {
+        coef *ds = dst + x;
+        const pixel *s = src + 3 * src_stride + x;
+        int a = s[-3 * src_stride];
+        int b = s[-2 * src_stride];
+        int c = s[-1 * src_stride];
+        int d = s[0];
+
+        // We skip the first 2 rows, as they are skipped in the next loop and
+        // we don't need the last 2 row as it is skipped in the next loop
+        for (int y = 2; y < h - 2; y++) {
+            s += src_stride;
+            const int e = *s;
+            ds += dst_stride;
+            *ds = a + b + c + d + e;
+            a = b;
+            b = c;
+            c = d;
+            d = e;
+        }
+    }
+
+    // We skip the first 2 rows as they are never read
+    dst += dst_stride;
+    for (int y = 2; y < h - 2; y++) {
+        int a = dst[0];
+        int b = dst[1];
+        int c = dst[2];
+        int d = dst[3];
+
+        for (int x = 2; x < w - 2; x++) {
+            const int e = dst[x + 2];
+            dst[x] = a + b + c + d + e;
+            a = b;
+            b = c;
+            c = d;
+            d = e;
+        }
+        dst += dst_stride;
+    }
+}
+
+// See boxsum3 function comments for details on row and column skipping
+static void boxsum3sqr(int32_t *dst, const ptrdiff_t dst_stride,
+                       const pixel *src, ptrdiff_t src_stride,
+                       const int w, const int h)
+{
+    src_stride = PXSTRIDE(src_stride);
+
+    // We skip the first row, as it is never used
+    src += src_stride;
+    dst += dst_stride;
+
+    // We skip the first and last columns, as they are never used
+    for (int x = 1; x < w - 1; x++) {
+        int *ds = dst + x;
+        const pixel *s = src + x;
+        int a = s[0] * s[0];
+        int b = s[src_stride] * s[src_stride];
+
+        // We skip the first row, as it is skipped in the next loop and
+        // we don't need the last row as it is skipped in the next loop
+        for (int y = 2; y < h - 2; y++) {
+            s += src_stride;
+            const int c = s[src_stride] * s[src_stride];
+            ds += dst_stride;
+            *ds = a + b + c;
+            a = b;
+            b = c;
+        }
+     }
+
+    // We skip the first row as it is never read
+    dst += dst_stride;
+    // We skip the last row as it is never read
+    for (int y = 2; y < h - 2; y++) {
+        int a = dst[1], b = dst[2];
+
+        // We don't store the first column as it is never read and
+        // we don't store the last 2 columns as they are never read
+        for (int x = 2; x < w - 2; x++) {
+            const int c = dst[x + 1];
+            dst[x] = a + b + c;
+            a = b;
+            b = c;
+        }
+        dst += dst_stride;
+    }
+}
+
+// See boxsum5 function comments for details on row and column skipping
+static void boxsum5sqr(int32_t *dst, const ptrdiff_t dst_stride,
+                       const pixel *const src, ptrdiff_t src_stride,
+                       const int w, const int h)
+{
+    src_stride = PXSTRIDE(src_stride);
+
+    // We skip the first row, as it is never used
+    dst += dst_stride;
+
+    for (int x = 0; x < w; x++) {
+        int *ds = dst + x;
+        const pixel *s = src + 3 * src_stride + x;
+        int a = s[-3 * src_stride] * s[-3 * src_stride];
+        int b = s[-2 * src_stride] * s[-2 * src_stride];
+        int c = s[-1 * src_stride] * s[-1 * src_stride];
+        int d = s[0] * s[0];
+
+        // We skip the first 2 rows, as they are skipped in the next loop and
+        // we don't need the last 2 row as it is skipped in the next loop
+        for (int y = 2; y < h - 2; y++) {
+            s += src_stride;
+            const int e = s[0] * s[0];
+            ds += dst_stride;
+            *ds = a + b + c + d + e;
+            a = b;
+            b = c;
+            c = d;
+            d = e;
+        }
+    }
+
+    // We skip the first 2 rows as they are never read
+    dst += dst_stride;
+    for (int y = 2; y < h - 2; y++) {
+        int a = dst[0];
+        int b = dst[1];
+        int c = dst[2];
+        int d = dst[3];
+
+        for (int x = 2; x < w - 2; x++) {
+            const int e = dst[x + 2];
+            dst[x] = a + b + c + d + e;
+            a = b;
+            b = c;
+            c = d;
+            d = e;
+        }
+        dst += dst_stride;
+    }
+}
+
+static void selfguided_filter(int32_t *dst, const ptrdiff_t dst_stride,
+                              const pixel *src, const ptrdiff_t src_stride,
+                              const int w, const int h, const int n, const int s)
+{
+    const int tmp_stride = w + 6;
+    // FIXME Replace array with scratch memory
+    int32_t A_[(h + 6) * tmp_stride];
+    int32_t *A = A_ + 3 * tmp_stride + 3;
+    // By inverting A and B after the boxsums, B can be of size coef instead
+    // of int32_t
+    coef B_[(h + 6) * tmp_stride];
+    coef *B = B_ + 3 * tmp_stride + 3;
+
+    const int step = (n == 25) + 1;
+    if (n == 25) {
+        boxsum5(B_, tmp_stride, src, src_stride, w + 6, h + 6);
+        boxsum5sqr(A_, tmp_stride, src, src_stride, w + 6, h + 6);
+    } else {
+        boxsum3(B_, tmp_stride, src, src_stride, w + 6, h + 6);
+        boxsum3sqr(A_, tmp_stride, src, src_stride, w + 6, h + 6);
+    }
+
+    int32_t *AA = A - tmp_stride;
+    coef *BB = B - tmp_stride;
+    for (int j = -1; j < h + 1; j+= step) {
+        for (int i = -1; i < w + 1; i++) {
+            const int a =
+                (AA[i] + (1 << (2 * (BITDEPTH - 8)) >> 1)) >> (2 * (BITDEPTH - 8));
+            const int b =
+                (BB[i] + (1 << (BITDEPTH - 8) >> 1)) >> (BITDEPTH - 8);
+
+            const uint32_t p = (a * n >= b * b) * (a * n - b * b);
+            const uint32_t z = (p * s + (1 << 19)) >> 20;
+
+            const int x = sgr_x_by_xplus1[imin(z, 255)];
+            // This is where we invert A and B, so that B is of size coef.
+            AA[i] = (((1 << 8) - x) * BB[i] * sgr_one_by_x[n - 1] + (1 << 11)) >> 12;
+            BB[i] = x;
+        }
+        AA += step * tmp_stride;
+        BB += step * tmp_stride;
+    }
+
+    src += 3 * PXSTRIDE(src_stride) + 3;
+    if (n == 25) {
+        for (int j = 0; j < h; j+=2) {
+            for (int i = 0; i < w; i++) {
+                const int32_t a = (B[i - tmp_stride] +
+                                   B[i + tmp_stride]) * 6 +
+                                  (B[i - 1 - tmp_stride] +
+                                   B[i - 1 + tmp_stride] +
+                                   B[i + 1 - tmp_stride] +
+                                   B[i + 1 + tmp_stride]) * 5;
+                const int32_t b = (A[i - tmp_stride] +
+                                   A[i + tmp_stride]) * 6 +
+                                  (A[i - 1 - tmp_stride] +
+                                   A[i - 1 + tmp_stride] +
+                                   A[i + 1 - tmp_stride] +
+                                   A[i + 1 + tmp_stride]) * 5;
+                dst[i] = (a * src[i] + b + (1 << 8)) >> 9;
+            }
+            dst += dst_stride;
+            src += PXSTRIDE(src_stride);
+            B += tmp_stride;
+            A += tmp_stride;
+            for (int i = 0; i < w; i++) {
+                const int32_t a = B[i] * 6 + (B[i - 1] + B[i + 1]) * 5;
+                const int32_t b = A[i] * 6 + (A[i - 1] + A[i + 1]) * 5;
+                dst[i] = (a * src[i] + b + (1 << 7)) >> 8;
+            }
+            dst += dst_stride;
+            src += PXSTRIDE(src_stride);
+            B += tmp_stride;
+            A += tmp_stride;
+        }
+    } else {
+        for (int j = 0; j < h; j++) {
+            for (int i = 0; i < w; i++) {
+                const int32_t a =
+                    (B[i] + B[i - 1] + B[i + 1] +
+                     B[i - tmp_stride] +
+                     B[i + tmp_stride]) * 4 +
+                    (B[i - 1 - tmp_stride] +
+                     B[i - 1 + tmp_stride] +
+                     B[i + 1 - tmp_stride] +
+                     B[i + 1 + tmp_stride]) * 3;
+
+                const int32_t b =
+                    (A[i] + A[i - 1] + A[i + 1] +
+                     A[i - tmp_stride] +
+                     A[i + tmp_stride]) * 4 +
+                    (A[i - 1 - tmp_stride] +
+                     A[i - 1 + tmp_stride] +
+                     A[i + 1 - tmp_stride] +
+                     A[i + 1 + tmp_stride]) * 3;
+
+                dst[i] = (a * src[i] + b + (1 << 8)) >> 9;
+            }
+            dst += dst_stride;
+            src += PXSTRIDE(src_stride);
+            B += tmp_stride;
+            A += tmp_stride;
+        }
+    }
+}
+
+static void selfguided_c(pixel *p, const ptrdiff_t p_stride,
+                         const pixel *lpf, const ptrdiff_t lpf_stride,
+                         const int w, const int h, const int sgr_idx,
+                         const int16_t sgr_w[2], const enum LrEdgeFlags edges)
+{
+    // padding is 3 pixels above and 3 pixels below
+    const int tmp_stride = sizeof(pixel) * (w + 6);
+    pixel tmp[(h + 6) * PXSTRIDE(tmp_stride)];
+
+    padding(tmp, tmp_stride, p, p_stride, lpf, lpf_stride, w, h, edges);
+
+    // both r1 and r0 can't be zero
+    if (!sgr_params[sgr_idx][0]) {
+        int32_t dst[h * w];
+        const int s1 = sgr_params[sgr_idx][3];
+        selfguided_filter(dst, w, tmp, tmp_stride, w, h, 9, s1);
+        const int w1 = (1 << 7) - sgr_w[1];
+        for (int j = 0; j < h; j++) {
+            for (int i = 0; i < w; i++) {
+                const int32_t u = (p[i] << 4);
+                const int32_t v = (u << 7) + w1 * (dst[j * w + i] - u);
+                p[i] = iclip_pixel((v + (1 << 10)) >> 11);
+            }
+            p += PXSTRIDE(p_stride);
+        }
+    } else if (!sgr_params[sgr_idx][1]) {
+        int32_t dst[h * w];
+        const int s0 = sgr_params[sgr_idx][2];
+        selfguided_filter(dst, w, tmp, tmp_stride, w, h, 25, s0);
+        const int w0 = sgr_w[0];
+        for (int j = 0; j < h; j++) {
+            for (int i = 0; i < w; i++) {
+                const int32_t u = (p[i] << 4);
+                const int32_t v = (u << 7) + w0 * (dst[j * w + i] - u);
+                p[i] = iclip_pixel((v + (1 << 10)) >> 11);
+            }
+            p += PXSTRIDE(p_stride);
+        }
+    } else {
+        int32_t dst0[h * w];
+        int32_t dst1[h * w];
+        const int s0 = sgr_params[sgr_idx][2];
+        const int s1 = sgr_params[sgr_idx][3];
+        const int w0 = sgr_w[0];
+        const int w1 = (1 << 7) - w0 - sgr_w[1];
+        selfguided_filter(dst0, w, tmp, tmp_stride, w, h, 25, s0);
+        selfguided_filter(dst1, w, tmp, tmp_stride, w, h, 9, s1);
+        for (int j = 0; j < h; j++) {
+            for (int i = 0; i < w; i++) {
+                const int32_t u = (p[i] << 4);
+                const int32_t v = (u << 7) + w0 * (dst0[j * w + i] - u) +
+                                  w1 * (dst1[j * w + i] - u);
+                p[i] = iclip_pixel((v + (1 << 10)) >> 11);
+            }
+            p += PXSTRIDE(p_stride);
+        }
+    }
+}
+
+void bitfn(dav1d_loop_restoration_dsp_init)(Dav1dLoopRestorationDSPContext *const c) {
+    c->wiener = wiener_c;
+    c->selfguided = selfguided_c;
+}
diff --git a/src/looprestoration.h b/src/looprestoration.h
new file mode 100644
index 0000000..b1dd24a
--- /dev/null
+++ b/src/looprestoration.h
@@ -0,0 +1,65 @@
+/*
+ * Copyright © 2018, VideoLAN and dav1d authors
+ * Copyright © 2018, Two Orioles, LLC
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright notice, this
+ *    list of conditions and the following disclaimer.
+ *
+ * 2. Redistributions in binary form must reproduce the above copyright notice,
+ *    this list of conditions and the following disclaimer in the documentation
+ *    and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
+ * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#ifndef __DAV1D_SRC_LOOPRESTORATION_H__
+#define __DAV1D_SRC_LOOPRESTORATION_H__
+
+#include <stdint.h>
+#include <stddef.h>
+
+#include "common/bitdepth.h"
+
+enum LrEdgeFlags {
+    LR_HAVE_LEFT = 1 << 0,
+    LR_HAVE_RIGHT = 1 << 1,
+    LR_HAVE_TOP = 1 << 2,
+    LR_HAVE_BOTTOM = 1 << 3,
+};
+
+// Although the spec applies restoration filters over 4x4 blocks, the wiener
+// filter can be applied to a bigger surface.
+//    * w is constrained by the restoration unit size (w <= 256)
+//    * h is constrained by the stripe height (h <= 64)
+typedef void (*wienerfilter_fn)(pixel *dst, ptrdiff_t dst_stride,
+                                const pixel *lpf, ptrdiff_t lpf_stride,
+                                int w, int h, const int16_t filterh[7],
+                                const int16_t filterv[7], enum LrEdgeFlags edges);
+
+typedef void (*selfguided_fn)(pixel *dst, ptrdiff_t dst_stride,
+                              const pixel *lpf, ptrdiff_t lpf_stride,
+                              int w, int h, int sgr_idx, const int16_t sgr_w[2],
+                              const enum LrEdgeFlags edges);
+
+typedef struct Dav1dLoopRestorationDSPContext {
+    wienerfilter_fn wiener;
+    selfguided_fn selfguided;
+} Dav1dLoopRestorationDSPContext;
+
+void dav1d_loop_restoration_dsp_init_8bpc(Dav1dLoopRestorationDSPContext *c);
+void dav1d_loop_restoration_dsp_init_10bpc(Dav1dLoopRestorationDSPContext *c);
+
+#endif /* __DAV1D_SRC_LOOPRESTORATION_H__ */
diff --git a/src/lr_apply.c b/src/lr_apply.c
new file mode 100644
index 0000000..21ed86d
--- /dev/null
+++ b/src/lr_apply.c
@@ -0,0 +1,302 @@
+/*
+ * Copyright © 2018, VideoLAN and dav1d authors
+ * Copyright © 2018, Two Orioles, LLC
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright notice, this
+ *    list of conditions and the following disclaimer.
+ *
+ * 2. Redistributions in binary form must reproduce the above copyright notice,
+ *    this list of conditions and the following disclaimer in the documentation
+ *    and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
+ * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#include "config.h"
+
+#include <stdio.h>
+
+#include "common/intops.h"
+
+#include "src/lr_apply.h"
+
+
+enum LrRestorePlanes {
+    LR_RESTORE_Y = 1 << 0,
+    LR_RESTORE_U = 1 << 1,
+    LR_RESTORE_V = 1 << 2,
+};
+
+static void backup_lpf(pixel *dst, ptrdiff_t dst_stride,
+                       const pixel *src, ptrdiff_t src_stride,
+                       const int first_stripe_h, const int next_stripe_h,
+                       int row, const int row_h, const int w, const int h)
+{
+    src_stride = PXSTRIDE(src_stride);
+    dst_stride = PXSTRIDE(dst_stride);
+    if (row) {
+        // Copy the top part of the stored loop filtered pixels from the
+        // previous sb row needed above the first stripe of this sb row.
+        pixel_copy(&dst[dst_stride *  0], &dst[dst_stride *  8], w);
+        pixel_copy(&dst[dst_stride *  1], &dst[dst_stride *  9], w);
+        pixel_copy(&dst[dst_stride *  2], &dst[dst_stride * 10], w);
+        pixel_copy(&dst[dst_stride *  3], &dst[dst_stride * 11], w);
+    }
+
+    int stripe_h = first_stripe_h;
+    dst += 4 * dst_stride;
+    src += (stripe_h - 2) * src_stride;
+    for (; row + stripe_h <= row_h; row += stripe_h) {
+        for (int i = 0; i < 4; i++) {
+            pixel_copy(dst, src, w);
+            dst += dst_stride;
+            src += src_stride;
+        }
+        stripe_h = next_stripe_h;
+        src += (stripe_h - 4) * src_stride;
+    }
+}
+
+void bytefn(dav1d_lr_copy_lpf)(Dav1dFrameContext *const f,
+                               /*const*/ pixel *const src[3], const int sby)
+{
+    const int stripe_h = 64 - (8 * !sby);
+    const ptrdiff_t offset = 8 * !!sby;
+    const ptrdiff_t *const src_stride = f->cur.p.stride;
+
+    // TODO Also check block level restore type to reduce copying.
+    const int restore_planes =
+        ((f->frame_hdr.restoration.type[0] != RESTORATION_NONE) << 0) +
+        ((f->frame_hdr.restoration.type[1] != RESTORATION_NONE) << 1) +
+        ((f->frame_hdr.restoration.type[2] != RESTORATION_NONE) << 2);
+
+    if (restore_planes & LR_RESTORE_Y) {
+        const int h = f->bh << 2;
+        const int w = f->bw << 2;
+        const int row_h = imin((sby + 1) << (6 + f->seq_hdr.sb128), h);
+        const int y_stripe = (sby << (6 + f->seq_hdr.sb128)) - offset;
+        backup_lpf(f->lf.lr_lpf_line_ptr[0], sizeof(pixel) * f->b4_stride * 4,
+                   src[0] - offset * PXSTRIDE(src_stride[0]),
+                   src_stride[0], stripe_h, 64, y_stripe, row_h, w, h);
+    }
+    if (restore_planes & (LR_RESTORE_U | LR_RESTORE_V)) {
+        const int ss_ver = f->cur.p.p.layout == DAV1D_PIXEL_LAYOUT_I420;
+        const int ss_hor = f->cur.p.p.layout != DAV1D_PIXEL_LAYOUT_I444;
+        const int h = f->bh << (2 - ss_ver);
+        const int w = f->bw << (2 - ss_hor);
+        const int row_h = imin((sby + 1) << ((6 - ss_ver) + f->seq_hdr.sb128), h);
+        const int stripe_h_uv = stripe_h >> ss_ver;
+        const ptrdiff_t offset_uv = offset >> ss_ver;
+        const int y_stripe =
+            (sby << ((6 - ss_ver) + f->seq_hdr.sb128)) - offset_uv;
+
+        if (restore_planes & LR_RESTORE_U) {
+            backup_lpf(f->lf.lr_lpf_line_ptr[1], sizeof(pixel) * f->b4_stride * 4,
+                       src[1] - offset_uv * PXSTRIDE(src_stride[1]),
+                       src_stride[1], stripe_h_uv, 32, y_stripe,
+                       row_h, w, h);
+        }
+        if (restore_planes & LR_RESTORE_V) {
+            backup_lpf(f->lf.lr_lpf_line_ptr[2], sizeof(pixel) * f->b4_stride * 4,
+                       src[2] - offset_uv * PXSTRIDE(src_stride[1]),
+                       src_stride[1], stripe_h_uv, 32, y_stripe,
+                       row_h, w, h);
+        }
+    }
+}
+
+
+static void lr_stripe(const Dav1dFrameContext *const f, pixel *p, int x, int y,
+                      const int plane, const int unit_w,
+                      const int first_stripe_h, const int next_stripe_h,
+                      const int row_h, const Av1RestorationUnit *const lr,
+                      enum LrEdgeFlags edges)
+{
+    const Dav1dDSPContext *const dsp = f->dsp;
+    const int sbrow_has_bottom = (edges & LR_HAVE_BOTTOM);
+    const pixel *lpf = f->lf.lr_lpf_line_ptr[plane] + x;
+    const ptrdiff_t p_stride = f->cur.p.stride[!!plane];
+    const ptrdiff_t lpf_stride = sizeof(pixel) * f->b4_stride * 4;
+
+    int stripe_h = first_stripe_h;
+
+    // FIXME [8] might be easier for SIMD
+    int16_t filterh[7], filterv[7];
+    if (lr->type == RESTORATION_WIENER) {
+        filterh[0] = filterh[6] = lr->filter_h[0];
+        filterh[1] = filterh[5] = lr->filter_h[1];
+        filterh[2] = filterh[4] = lr->filter_h[2];
+        filterh[3] = -((filterh[0] + filterh[1] + filterh[2]) * 2);
+
+        filterv[0] = filterv[6] = lr->filter_v[0];
+        filterv[1] = filterv[5] = lr->filter_v[1];
+        filterv[2] = filterv[4] = lr->filter_v[2];
+        filterv[3] = -((filterv[0] + filterv[1] + filterv[2]) * 2);
+    }
+
+    while (y + stripe_h <= row_h) {
+        // TODO Look into getting rid of the this if
+        if (y + stripe_h == row_h) {
+            edges &= ~LR_HAVE_BOTTOM;
+        } else {
+            edges |= LR_HAVE_BOTTOM;
+        }
+        if (lr->type == RESTORATION_WIENER) {
+            dsp->lr.wiener(p, p_stride, lpf, lpf_stride, unit_w, stripe_h,
+                           filterh, filterv, edges);
+        } else {
+            assert(lr->type == RESTORATION_SGRPROJ);
+            dsp->lr.selfguided(p, p_stride, lpf, lpf_stride, unit_w, stripe_h,
+                               lr->sgr_idx, lr->sgr_weights, edges);
+        }
+
+        y += stripe_h;
+        edges |= LR_HAVE_TOP;
+        if (y + stripe_h > row_h && sbrow_has_bottom) break;
+        p += stripe_h * PXSTRIDE(p_stride);
+        stripe_h = imin(next_stripe_h, row_h - y);
+        if (stripe_h == 0) break;
+        lpf += 4 * PXSTRIDE(lpf_stride);
+    }
+}
+
+static void backup3xU(pixel *dst, const pixel *src, const ptrdiff_t src_stride,
+                      int u)
+{
+    for (; u > 0; u--, dst += 3, src += PXSTRIDE(src_stride))
+        pixel_copy(dst, src, 3);
+}
+
+static void restore3xU(pixel *dst, const ptrdiff_t dst_stride, const pixel *src,
+                       int u)
+{
+    for (; u > 0; u--, dst += PXSTRIDE(dst_stride), src += 3)
+        pixel_copy(dst, src, 3);
+}
+
+static void lr_sbrow(const Dav1dFrameContext *const f, pixel *p, const int y,
+                     const int w, const int h, const int row_h, const int plane)
+{
+    const int ss_ver = !!plane * f->cur.p.p.layout == DAV1D_PIXEL_LAYOUT_I420;
+    const ptrdiff_t p_stride = f->cur.p.stride[!!plane];
+
+    const int unit_size_log2 = f->frame_hdr.restoration.unit_size[!!plane];
+    const int unit_size = 1 << unit_size_log2;
+    const int half_unit_size = unit_size >> 1;
+    const int max_unit_size = unit_size + half_unit_size;
+
+    const int row_y = y + ((8 >> ss_ver) * !!y);
+
+    // FIXME This is an ugly hack to lookup the proper AV1Filter unit for
+    // chroma planes. Question: For Multithreaded decoding, is it better
+    // to store the chroma LR information with collocated Luma information?
+    // In other words. For a chroma restoration unit locate at 128,128 and
+    // with a 4:2:0 chroma subsampling, do we store the filter information at
+    // the AV1Filter unit located at (128,128) or (256,256)
+    // TODO Support chroma subsampling.
+    const int shift = plane ? 6 : 7;
+
+    int ruy = (row_y >> unit_size_log2);
+    // Merge last restoration unit if its height is < half_unit_size
+    if (ruy > 0) ruy -= (ruy << unit_size_log2) + half_unit_size > h;
+
+    const int proc_h = 64 >> ss_ver;
+    const int stripe_h = proc_h - ((8 >> ss_ver) * !y);
+    const int filter_h = imin(stripe_h + proc_h * f->seq_hdr.sb128, h - y);
+
+    pixel pre_lr_border[filter_h * 3];
+    pixel post_lr_border[filter_h * 3];
+
+    int unit_w = unit_size;
+
+    enum LrEdgeFlags edges = (y > 0 ? LR_HAVE_TOP : 0) |
+                             (row_h < h ? LR_HAVE_BOTTOM : 0);
+
+    for (int x = 0, rux = 0; x < w; x+= unit_w, rux++, edges |= LR_HAVE_LEFT) {
+        // TODO Clean up this if statement.
+        if (x + max_unit_size > w) {
+            unit_w = w - x;
+            edges &= ~LR_HAVE_RIGHT;
+        } else {
+            edges |= LR_HAVE_RIGHT;
+        }
+
+        // Based on the position of the restoration unit, find the corresponding
+        // AV1Filter unit.
+        const int unit_idx = ((ruy & 16) >> 3) + ((rux & 16) >> 4);
+        const Av1RestorationUnit *const lr =
+            &f->lf.mask[(((ruy << unit_size_log2) >> shift) * f->sb128w) +
+                        (x >> shift)].lr[plane][unit_idx];
+
+        if (edges & LR_HAVE_LEFT) {
+            restore3xU(p - 3, p_stride, pre_lr_border, filter_h);
+        }
+        // FIXME Don't backup if the next restoration unit is RESTORE_NONE
+        // This also requires not restoring in the same conditions.
+        if (edges & LR_HAVE_RIGHT) {
+            backup3xU(pre_lr_border, p + unit_w - 3, p_stride, filter_h);
+        }
+        if (lr->type != RESTORATION_NONE) {
+            lr_stripe(f, p, x, y, plane, unit_w, stripe_h, proc_h,
+                      row_h, lr, edges);
+        }
+        if (edges & LR_HAVE_LEFT) {
+            restore3xU(p - 3, p_stride, post_lr_border, filter_h);
+        }
+        if (edges & LR_HAVE_RIGHT) {
+            backup3xU(post_lr_border, p + unit_w - 3, p_stride, filter_h);
+        }
+        p += unit_w;
+    }
+}
+
+void bytefn(dav1d_lr_sbrow)(Dav1dFrameContext *const f, pixel *const dst[3],
+                            const int sby)
+{
+    const ptrdiff_t offset_y = 8 * !!sby;
+    const ptrdiff_t *const dst_stride = f->cur.p.stride;
+
+    const int restore_planes =
+        ((f->frame_hdr.restoration.type[0] != RESTORATION_NONE) << 0) +
+        ((f->frame_hdr.restoration.type[1] != RESTORATION_NONE) << 1) +
+        ((f->frame_hdr.restoration.type[2] != RESTORATION_NONE) << 2);
+
+    if (restore_planes & LR_RESTORE_Y) {
+        const int h = f->bh << 2;
+        const int w = f->bw << 2;
+        const int row_h = imin((sby + 1) << (6 + f->seq_hdr.sb128), h);
+        const int y_stripe = (sby << (6 + f->seq_hdr.sb128)) - offset_y;
+        lr_sbrow(f, dst[0] - offset_y * PXSTRIDE(dst_stride[0]), y_stripe, w,
+                 h, row_h, 0);
+    }
+    if (restore_planes & (LR_RESTORE_U | LR_RESTORE_V)) {
+        const int ss_ver = f->cur.p.p.layout == DAV1D_PIXEL_LAYOUT_I420;
+        const int ss_hor = f->cur.p.p.layout != DAV1D_PIXEL_LAYOUT_I444;
+        const int h = f->bh << (2 - ss_ver);
+        const int w = f->bw << (2 - ss_hor);
+        const int row_h = imin((sby + 1) << ((6 - ss_ver) + f->seq_hdr.sb128), h);
+        const ptrdiff_t offset_uv = offset_y >> ss_ver;
+        const int y_stripe =
+            (sby << ((6 - ss_ver) + f->seq_hdr.sb128)) - offset_uv;
+        if (restore_planes & LR_RESTORE_U)
+            lr_sbrow(f, dst[1] - offset_uv * PXSTRIDE(dst_stride[1]), y_stripe,
+                     w, h, row_h, 1);
+
+        if (restore_planes & LR_RESTORE_V)
+            lr_sbrow(f, dst[2] - offset_uv * PXSTRIDE(dst_stride[1]), y_stripe,
+                     w, h, row_h, 2);
+    }
+}
diff --git a/src/lr_apply.h b/src/lr_apply.h
new file mode 100644
index 0000000..67a7a21
--- /dev/null
+++ b/src/lr_apply.h
@@ -0,0 +1,44 @@
+/*
+ * Copyright © 2018, VideoLAN and dav1d authors
+ * Copyright © 2018, Two Orioles, LLC
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright notice, this
+ *    list of conditions and the following disclaimer.
+ *
+ * 2. Redistributions in binary form must reproduce the above copyright notice,
+ *    this list of conditions and the following disclaimer in the documentation
+ *    and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
+ * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#ifndef __DAV1D_SRC_LR_APPLY_H__
+#define __DAV1D_SRC_LR_APPLY_H__
+
+#include <stdint.h>
+#include <stddef.h>
+
+#include "common/bitdepth.h"
+
+#include "src/internal.h"
+
+void bytefn(dav1d_lr_copy_lpf)(Dav1dFrameContext *const f,
+                               /*const*/ pixel *const src[3], int sby);
+
+void bytefn(dav1d_lr_sbrow)(Dav1dFrameContext *const f, pixel *const dst[3],
+                            int sby);
+
+#endif /* __DAV1D_SRC_LR_APPLY_H__ */
diff --git a/src/mc.c b/src/mc.c
new file mode 100644
index 0000000..10106b2
--- /dev/null
+++ b/src/mc.c
@@ -0,0 +1,533 @@
+/*
+ * Copyright © 2018, VideoLAN and dav1d authors
+ * Copyright © 2018, Two Orioles, LLC
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright notice, this
+ *    list of conditions and the following disclaimer.
+ *
+ * 2. Redistributions in binary form must reproduce the above copyright notice,
+ *    this list of conditions and the following disclaimer in the documentation
+ *    and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
+ * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#include "config.h"
+
+#include <stdlib.h>
+#include <string.h>
+
+#include "common/intops.h"
+
+#include "src/mc.h"
+#include "src/tables.h"
+
+static __attribute__((noinline)) void
+put_c(pixel *dst, const ptrdiff_t dst_stride,
+      const pixel *src, const ptrdiff_t src_stride, const int w, int h)
+{
+    do {
+        pixel_copy(dst, src, w);
+
+        dst += dst_stride;
+        src += src_stride;
+    } while (--h);
+}
+
+static __attribute__((noinline)) void
+prep_c(coef *tmp, const pixel *src, const ptrdiff_t src_stride,
+       const int w, int h)
+{
+    do {
+        for (int x = 0; x < w; x++)
+            tmp[x] = src[x] << 4;
+
+        tmp += w;
+        src += src_stride;
+    } while (--h);
+}
+
+#define FILTER_8TAP(src, x, F, stride) \
+    (F[0] * src[x + -3 * stride] + \
+     F[1] * src[x + -2 * stride] + \
+     F[2] * src[x + -1 * stride] + \
+     F[3] * src[x + +0 * stride] + \
+     F[4] * src[x + +1 * stride] + \
+     F[5] * src[x + +2 * stride] + \
+     F[6] * src[x + +3 * stride] + \
+     F[7] * src[x + +4 * stride])
+
+#define FILTER_8TAP_RND(src, x, F, stride, sh) \
+    ((FILTER_8TAP(src, x, F, stride) + ((1 << sh) >> 1)) >> sh)
+
+#define FILTER_8TAP_CLIP(src, x, F, stride, sh) \
+    iclip_pixel(FILTER_8TAP_RND(src, x, F, stride, sh))
+
+#define GET_FILTERS() \
+    const int8_t *const fh = !mx ? NULL : w > 4 ? \
+        dav1d_mc_subpel_filters[filter_type & 3][mx - 1] : \
+        dav1d_mc_subpel_filters[3 + (filter_type & 1)][mx - 1]; \
+    const int8_t *const fv = !my ? NULL : h > 4 ? \
+        dav1d_mc_subpel_filters[filter_type >> 2][my - 1] : \
+        dav1d_mc_subpel_filters[3 + ((filter_type >> 2) & 1)][my - 1]; \
+
+static __attribute__((noinline)) void
+put_8tap_c(pixel *dst, ptrdiff_t dst_stride,
+           const pixel *src, ptrdiff_t src_stride,
+           const int w, int h, const int mx, const int my,
+           const int filter_type)
+{
+    GET_FILTERS();
+    dst_stride = PXSTRIDE(dst_stride);
+    src_stride = PXSTRIDE(src_stride);
+
+    if (fh) {
+        if (fv) {
+            int tmp_h = h + 7;
+            coef mid[128 * 135], *mid_ptr = mid;
+
+            src -= src_stride * 3;
+            do {
+                for (int x = 0; x < w; x++)
+                    mid_ptr[x] = FILTER_8TAP_RND(src, x, fh, 1, 3);
+
+                mid_ptr += 128;
+                src += src_stride;
+            } while (--tmp_h);
+
+            mid_ptr = mid + 128 * 3;
+            do {
+                for (int x = 0; x < w; x++)
+                    dst[x] = FILTER_8TAP_CLIP(mid_ptr, x, fv, 128, 11);
+
+                mid_ptr += 128;
+                dst += dst_stride;
+            } while (--h);
+        } else {
+            do {
+                for (int x = 0; x < w; x++) {
+                    const int px = FILTER_8TAP_RND(src, x, fh, 1, 3);
+                    dst[x] = iclip_pixel((px + 8) >> 4);
+                }
+
+                dst += dst_stride;
+                src += src_stride;
+            } while (--h);
+        }
+    } else if (fv) {
+        do {
+            for (int x = 0; x < w; x++)
+                dst[x] = FILTER_8TAP_CLIP(src, x, fv, src_stride, 7);
+
+            dst += dst_stride;
+            src += src_stride;
+        } while (--h);
+    } else
+        put_c(dst, dst_stride, src, src_stride, w, h);
+}
+
+static __attribute__((noinline)) void
+prep_8tap_c(coef *tmp, const pixel *src, ptrdiff_t src_stride,
+            const int w, int h, const int mx, const int my,
+            const int filter_type)
+{
+    GET_FILTERS();
+    src_stride = PXSTRIDE(src_stride);
+
+    if (fh) {
+        if (fv) {
+            int tmp_h = h + 7;
+            coef mid[128 * 135], *mid_ptr = mid;
+
+            src -= src_stride * 3;
+            do {
+                for (int x = 0; x < w; x++)
+                    mid_ptr[x] = FILTER_8TAP_RND(src, x, fh, 1, 3);
+
+                mid_ptr += 128;
+                src += src_stride;
+            } while (--tmp_h);
+
+            mid_ptr = mid + 128 * 3;
+            do {
+                for (int x = 0; x < w; x++)
+                    tmp[x] = FILTER_8TAP_RND(mid_ptr, x, fv, 128, 7);
+
+                mid_ptr += 128;
+                tmp += w;
+            } while (--h);
+        } else {
+            do {
+                for (int x = 0; x < w; x++)
+                    tmp[x] = FILTER_8TAP_RND(src, x, fh, 1, 3);
+
+                tmp += w;
+                src += src_stride;
+            } while (--h);
+        }
+    } else if (fv) {
+        do {
+            for (int x = 0; x < w; x++)
+                tmp[x] = FILTER_8TAP_RND(src, x, fv, src_stride, 3);
+
+            tmp += w;
+            src += src_stride;
+        } while (--h);
+    } else
+        prep_c(tmp, src, src_stride, w, h);
+}
+
+#define filter_fns(type, type_h, type_v) \
+static void put_8tap_##type##_c(pixel *const dst, \
+                                const ptrdiff_t dst_stride, \
+                                const pixel *const src, \
+                                const ptrdiff_t src_stride, \
+                                const int w, const int h, \
+                                const int mx, const int my) \
+{ \
+    put_8tap_c(dst, dst_stride, src, src_stride, w, h, mx, my, \
+               type_h | (type_v << 2)); \
+} \
+static void prep_8tap_##type##_c(coef *const tmp, \
+                                 const pixel *const src, \
+                                 const ptrdiff_t src_stride, \
+                                 const int w, const int h, \
+                                 const int mx, const int my) \
+{ \
+    prep_8tap_c(tmp, src, src_stride, w, h, mx, my, \
+                type_h | (type_v << 2)); \
+}
+
+filter_fns(regular,        FILTER_8TAP_REGULAR, FILTER_8TAP_REGULAR)
+filter_fns(regular_sharp,  FILTER_8TAP_REGULAR, FILTER_8TAP_SHARP)
+filter_fns(regular_smooth, FILTER_8TAP_REGULAR, FILTER_8TAP_SMOOTH)
+filter_fns(smooth,         FILTER_8TAP_SMOOTH,  FILTER_8TAP_SMOOTH)
+filter_fns(smooth_regular, FILTER_8TAP_SMOOTH,  FILTER_8TAP_REGULAR)
+filter_fns(smooth_sharp,   FILTER_8TAP_SMOOTH,  FILTER_8TAP_SHARP)
+filter_fns(sharp,          FILTER_8TAP_SHARP,   FILTER_8TAP_SHARP)
+filter_fns(sharp_regular,  FILTER_8TAP_SHARP,   FILTER_8TAP_REGULAR)
+filter_fns(sharp_smooth,   FILTER_8TAP_SHARP,   FILTER_8TAP_SMOOTH)
+
+#define FILTER_BILIN(src, x, mxy, stride) \
+    (16 * src[x] + (mxy * (src[x + stride] - src[x])))
+
+#define FILTER_BILIN_RND(src, x, mxy, stride, sh) \
+    ((FILTER_BILIN(src, x, mxy, stride) + ((1 << sh) >> 1)) >> sh)
+
+#define FILTER_BILIN_CLIP(src, x, mxy, stride, sh) \
+    iclip_pixel(FILTER_BILIN_RND(src, x, mxy, stride, sh))
+
+static void put_bilin_c(pixel *dst, ptrdiff_t dst_stride,
+                        const pixel *src, ptrdiff_t src_stride,
+                        const int w, int h, const int mx, const int my)
+{
+    dst_stride = PXSTRIDE(dst_stride);
+    src_stride = PXSTRIDE(src_stride);
+
+    if (mx) {
+        if (my) {
+            coef mid[128 * 129], *mid_ptr = mid;
+            int tmp_h = h + 1;
+
+            do {
+                for (int x = 0; x < w; x++)
+                    mid_ptr[x] = FILTER_BILIN(src, x, mx, 1);
+
+                mid_ptr += 128;
+                src += src_stride;
+            } while (--tmp_h);
+
+            mid_ptr = mid;
+            do {
+                for (int x = 0; x < w; x++)
+                    dst[x] = FILTER_BILIN_CLIP(mid_ptr, x, my, 128, 8);
+
+                mid_ptr += 128;
+                dst += dst_stride;
+            } while (--h);
+        } else {
+            do {
+                for (int x = 0; x < w; x++)
+                    dst[x] = FILTER_BILIN_CLIP(src, x, mx, 1, 4);
+
+                dst += dst_stride;
+                src += src_stride;
+            } while (--h);
+        }
+    } else if (my) {
+        do {
+            for (int x = 0; x < w; x++)
+                dst[x] = FILTER_BILIN_CLIP(src, x, my, src_stride, 4);
+
+            dst += dst_stride;
+            src += src_stride;
+        } while (--h);
+    } else
+        put_c(dst, dst_stride, src, src_stride, w, h);
+}
+
+static void prep_bilin_c(coef *tmp,
+                         const pixel *src, ptrdiff_t src_stride,
+                         const int w, int h, const int mx, const int my)
+{
+    src_stride = PXSTRIDE(src_stride);
+
+    if (mx) {
+        if (my) {
+            coef mid[128 * 129], *mid_ptr = mid;
+            int tmp_h = h + 1;
+
+            do {
+                for (int x = 0; x < w; x++)
+                    mid_ptr[x] = FILTER_BILIN(src, x, mx, 1);
+
+                mid_ptr += 128;
+                src += src_stride;
+            } while (--tmp_h);
+
+            mid_ptr = mid;
+            do {
+                for (int x = 0; x < w; x++)
+                    tmp[x] = FILTER_BILIN_RND(mid_ptr, x, my, 128, 4);
+
+                mid_ptr += 128;
+                tmp += w;
+            } while (--h);
+        } else {
+            do {
+                for (int x = 0; x < w; x++)
+                    tmp[x] = FILTER_BILIN(src, x, mx, 1);
+
+                tmp += w;
+                src += src_stride;
+            } while (--h);
+        }
+    } else if (my) {
+        do {
+            for (int x = 0; x < w; x++)
+                tmp[x] = FILTER_BILIN(src, x, my, src_stride);
+
+            tmp += w;
+            src += src_stride;
+        } while (--h);
+    } else
+        prep_c(tmp, src, src_stride, w, h);
+}
+
+static void avg_c(pixel *dst, const ptrdiff_t dst_stride,
+                  const coef *tmp1, const coef *tmp2, const int w, int h)
+{
+    do {
+        for (int x = 0; x < w; x++)
+            dst[x] = iclip_pixel((tmp1[x] + tmp2[x] + 16) >> 5);
+
+        tmp1 += w;
+        tmp2 += w;
+        dst += PXSTRIDE(dst_stride);
+    } while (--h);
+}
+
+static void w_avg_c(pixel *dst, const ptrdiff_t dst_stride,
+                    const coef *tmp1, const coef *tmp2, const int w, int h,
+                    const int weight)
+{
+    do {
+        for (int x = 0; x < w; x++)
+            dst[x] = iclip_pixel((tmp1[x] * weight +
+                                  tmp2[x] * (16 - weight) + 128) >> 8);
+
+        tmp1 += w;
+        tmp2 += w;
+        dst += PXSTRIDE(dst_stride);
+    } while (--h);
+}
+
+static void mask_c(pixel *dst, const ptrdiff_t dst_stride,
+                   const coef *tmp1, const coef *tmp2, const int w, int h,
+                   const uint8_t *mask)
+{
+    do {
+        for (int x = 0; x < w; x++)
+            dst[x] = iclip_pixel((tmp1[x] * mask[x] +
+                                  tmp2[x] * (64 - mask[x]) + 512) >> 10);
+
+        tmp1 += w;
+        tmp2 += w;
+        mask += w;
+        dst += PXSTRIDE(dst_stride);
+    } while (--h);
+}
+
+static void blend_c(pixel *dst, const ptrdiff_t dst_stride,
+                    const pixel *tmp, const ptrdiff_t tmp_stride,
+                    const int w, const int h,
+                    const uint8_t *mask, const ptrdiff_t m_stride)
+{
+    for (int y = 0; y < h; y++) {
+        for (int x = 0; x < w; x++) {
+#define blend_px(a, b, m) (((a * (64 - m) + b * m) + 32) >> 6)
+            dst[x] = blend_px(dst[x], tmp[x], mask[m_stride == 1 ? 0 : x]);
+        }
+        dst += PXSTRIDE(dst_stride);
+        tmp += PXSTRIDE(tmp_stride);
+        mask += m_stride;
+    }
+}
+
+static void w_mask_c(pixel *dst, const ptrdiff_t dst_stride,
+                     const coef *tmp1, const coef *tmp2, const int w, int h,
+                     uint8_t *mask, const int sign,
+                     const int ss_hor, const int ss_ver)
+{
+    // store mask at 2x2 resolution, i.e. store 2x1 sum for even rows,
+    // and then load this intermediate to calculate final value for odd rows
+    const int rnd = 8 << (BITDEPTH - 8);
+    do {
+        for (int x = 0; x < w; x++) {
+            const int m = imin(38 + ((abs(tmp1[x] - tmp2[x]) + rnd) >> BITDEPTH), 64);
+            dst[x] = iclip_pixel((tmp1[x] * m +
+                                  tmp2[x] * (64 - m) + 512) >> 10);
+
+            if (ss_hor) {
+                x++;
+
+                const int n = imin(38 + ((abs(tmp1[x] - tmp2[x]) + rnd) >> BITDEPTH), 64);
+                dst[x] = iclip_pixel((tmp1[x] * n +
+                                      tmp2[x] * (64 - n) + 512) >> 10);
+
+                if (h & ss_ver) {
+                    mask[x >> 1] = (m + n + mask[x >> 1] + 2 - sign) >> 2;
+                } else if (ss_ver) {
+                    mask[x >> 1] = m + n;
+                } else {
+                    mask[x >> 1] = (m + n + 1 - sign) >> 1;
+                }
+            } else {
+                mask[x] = m;
+            }
+        }
+
+        tmp1 += w;
+        tmp2 += w;
+        dst += PXSTRIDE(dst_stride);
+        if (!ss_ver || (h & 1)) mask += w >> ss_hor;
+    } while (--h);
+}
+
+#define w_mask_fns(ssn, ss_hor, ss_ver) \
+static void w_mask_##ssn##_c(pixel *const dst, const ptrdiff_t dst_stride, \
+                             const coef *const tmp1, const coef *const tmp2, \
+                             const int w, const int h, uint8_t *mask, \
+                             const int sign) \
+{ \
+    w_mask_c(dst, dst_stride, tmp1, tmp2, w, h, mask, sign, ss_hor, ss_ver); \
+}
+
+w_mask_fns(444, 0, 0);
+w_mask_fns(422, 1, 0);
+w_mask_fns(420, 1, 1);
+
+#undef w_mask_fns
+
+static void warp_affine_8x8_c(pixel *dst, const ptrdiff_t dst_stride,
+                              const pixel *src, const ptrdiff_t src_stride,
+                              const int16_t *const abcd, int mx, int my)
+{
+    coef mid[15 * 8], *mid_ptr = mid;
+
+    src -= 3 * PXSTRIDE(src_stride);
+    for (int y = 0; y < 15; y++, mx += abcd[1]) {
+        for (int x = 0, tmx = mx; x < 8; x++, tmx += abcd[0]) {
+            const int8_t *const filter =
+                dav1d_mc_warp_filter[64 + ((tmx + 512) >> 10)];
+
+            mid_ptr[x] = FILTER_8TAP_RND(src, x, filter, 1, 3);
+        }
+        src += PXSTRIDE(src_stride);
+        mid_ptr += 8;
+    }
+
+    mid_ptr = &mid[3 * 8];
+    for (int y = 0; y < 8; y++, my += abcd[3]) {
+        for (int x = 0, tmy = my; x < 8; x++, tmy += abcd[2]) {
+            const int8_t *const filter =
+                dav1d_mc_warp_filter[64 + ((tmy + 512) >> 10)];
+
+            dst[x] = FILTER_8TAP_CLIP(mid_ptr, x, filter, 8, 11);
+        }
+        mid_ptr += 8;
+        dst += PXSTRIDE(dst_stride);
+    }
+}
+
+static void warp_affine_8x8t_c(coef *tmp, const ptrdiff_t tmp_stride,
+                               const pixel *src, const ptrdiff_t src_stride,
+                               const int16_t *const abcd, int mx, int my)
+{
+    coef mid[15 * 8], *mid_ptr = mid;
+
+    src -= 3 * PXSTRIDE(src_stride);
+    for (int y = 0; y < 15; y++, mx += abcd[1]) {
+        for (int x = 0, tmx = mx; x < 8; x++, tmx += abcd[0]) {
+            const int8_t *const filter =
+                dav1d_mc_warp_filter[64 + ((tmx + 512) >> 10)];
+
+            mid_ptr[x] = FILTER_8TAP_RND(src, x, filter, 1, 3);
+        }
+        src += PXSTRIDE(src_stride);
+        mid_ptr += 8;
+    }
+
+    mid_ptr = &mid[3 * 8];
+    for (int y = 0; y < 8; y++, my += abcd[3]) {
+        for (int x = 0, tmy = my; x < 8; x++, tmy += abcd[2]) {
+            const int8_t *const filter =
+                dav1d_mc_warp_filter[64 + ((tmy + 512) >> 10)];
+
+            tmp[x] = FILTER_8TAP_RND(mid_ptr, x, filter, 8, 7);
+        }
+        mid_ptr += 8;
+        tmp += tmp_stride;
+    }
+}
+
+void bitfn(dav1d_mc_dsp_init)(Dav1dMCDSPContext *const c) {
+#define init_mc_fns(type, name) do { \
+    c->mc [type] = put_##name##_c; \
+    c->mct[type] = prep_##name##_c; \
+} while (0)
+
+    init_mc_fns(FILTER_2D_8TAP_REGULAR,        8tap_regular);
+    init_mc_fns(FILTER_2D_8TAP_REGULAR_SMOOTH, 8tap_regular_smooth);
+    init_mc_fns(FILTER_2D_8TAP_REGULAR_SHARP,  8tap_regular_sharp);
+    init_mc_fns(FILTER_2D_8TAP_SHARP_REGULAR,  8tap_sharp_regular);
+    init_mc_fns(FILTER_2D_8TAP_SHARP_SMOOTH,   8tap_sharp_smooth);
+    init_mc_fns(FILTER_2D_8TAP_SHARP,          8tap_sharp);
+    init_mc_fns(FILTER_2D_8TAP_SMOOTH_REGULAR, 8tap_smooth_regular);
+    init_mc_fns(FILTER_2D_8TAP_SMOOTH,         8tap_smooth);
+    init_mc_fns(FILTER_2D_8TAP_SMOOTH_SHARP,   8tap_smooth_sharp);
+    init_mc_fns(FILTER_2D_BILINEAR,            bilin);
+
+    c->avg      = avg_c;
+    c->w_avg    = w_avg_c;
+    c->mask     = mask_c;
+    c->blend    = blend_c;
+    c->w_mask[0] = w_mask_444_c;
+    c->w_mask[1] = w_mask_422_c;
+    c->w_mask[2] = w_mask_420_c;
+    c->warp8x8  = warp_affine_8x8_c;
+    c->warp8x8t = warp_affine_8x8t_c;
+}
diff --git a/src/mc.h b/src/mc.h
new file mode 100644
index 0000000..af1c41f
--- /dev/null
+++ b/src/mc.h
@@ -0,0 +1,104 @@
+/*
+ * Copyright © 2018, VideoLAN and dav1d authors
+ * Copyright © 2018, Two Orioles, LLC
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright notice, this
+ *    list of conditions and the following disclaimer.
+ *
+ * 2. Redistributions in binary form must reproduce the above copyright notice,
+ *    this list of conditions and the following disclaimer in the documentation
+ *    and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
+ * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#ifndef __DAV1D_SRC_MC_H__
+#define __DAV1D_SRC_MC_H__
+
+#include <stdint.h>
+#include <stddef.h>
+
+#include "common/bitdepth.h"
+
+#include "src/levels.h"
+
+#define decl_mc_fn(name) \
+void (name)(pixel *dst, ptrdiff_t dst_stride, \
+            const pixel *src, ptrdiff_t src_stride, \
+            int w, int h, int mx, int my)
+typedef decl_mc_fn(*mc_fn);
+
+#define decl_warp8x8_fn(name) \
+void (name)(pixel *dst, ptrdiff_t dst_stride, \
+            const pixel *src, ptrdiff_t src_stride, \
+            const int16_t *abcd, int mx, int my)
+typedef decl_warp8x8_fn(*warp8x8_fn);
+
+#define decl_mct_fn(name) \
+void (name)(coef *tmp, const pixel *src, ptrdiff_t src_stride, \
+            int w, int h, int mx, int my)
+typedef decl_mct_fn(*mct_fn);
+
+#define decl_warp8x8t_fn(name) \
+void (name)(coef *tmp, const ptrdiff_t tmp_stride, \
+            const pixel *src, ptrdiff_t src_stride, \
+            const int16_t *abcd, int mx, int my)
+typedef decl_warp8x8t_fn(*warp8x8t_fn);
+
+#define decl_avg_fn(name) \
+void (name)(pixel *dst, ptrdiff_t dst_stride, \
+            const coef *tmp1, const coef *tmp2, int w, int h)
+typedef decl_avg_fn(*avg_fn);
+
+#define decl_w_avg_fn(name) \
+void (name)(pixel *dst, ptrdiff_t dst_stride, \
+            const coef *tmp1, const coef *tmp2, int w, int h, int weight)
+typedef decl_w_avg_fn(*w_avg_fn);
+
+#define decl_mask_fn(name) \
+void (name)(pixel *dst, ptrdiff_t dst_stride, \
+            const coef *tmp1, const coef *tmp2, int w, int h, \
+            const uint8_t *mask)
+typedef decl_mask_fn(*mask_fn);
+
+#define decl_w_mask_fn(name) \
+void (name)(pixel *dst, ptrdiff_t dst_stride, \
+            const coef *tmp1, const coef *tmp2, int w, int h, \
+            uint8_t *mask, int sign)
+typedef decl_w_mask_fn(*w_mask_fn);
+
+#define decl_blend_fn(name) \
+void (name)(pixel *dst, ptrdiff_t dst_stride, \
+            const pixel *tmp, ptrdiff_t tmp_stride, int w, int h, \
+            const uint8_t *mask, ptrdiff_t mstride)
+typedef decl_blend_fn(*blend_fn);
+
+typedef struct Dav1dMCDSPContext {
+    mc_fn mc[N_2D_FILTERS];
+    mct_fn mct[N_2D_FILTERS];
+    avg_fn avg;
+    w_avg_fn w_avg;
+    mask_fn mask;
+    w_mask_fn w_mask[3 /* 444, 422, 420 */];
+    blend_fn blend;
+    warp8x8_fn warp8x8;
+    warp8x8t_fn warp8x8t;
+} Dav1dMCDSPContext;
+
+void dav1d_mc_dsp_init_8bpc(Dav1dMCDSPContext *c);
+void dav1d_mc_dsp_init_10bpc(Dav1dMCDSPContext *c);
+
+#endif /* __DAV1D_SRC_MC_H__ */
diff --git a/src/msac.c b/src/msac.c
new file mode 100644
index 0000000..b3ae55d
--- /dev/null
+++ b/src/msac.c
@@ -0,0 +1,318 @@
+/*
+ * Copyright (c) 2001-2016, Alliance for Open Media. All rights reserved
+ *
+ * This source code is subject to the terms of the BSD 2 Clause License and
+ * the Alliance for Open Media Patent License 1.0. If the BSD 2 Clause License
+ * was not distributed with this source code in the LICENSE file, you can
+ * obtain it at www.aomedia.org/license/software. If the Alliance for Open
+ * Media Patent License 1.0 was not distributed with this source code in the
+ * PATENTS file, you can obtain it at www.aomedia.org/license/patent.
+ */
+
+#include "config.h"
+
+#include <assert.h>
+#include <limits.h>
+
+#include "common/intops.h"
+
+#include "src/msac.h"
+
+typedef MsacContext od_ec_dec;
+
+//#define CDF_SIZE(x) ((x) + 1)
+#define CDF_PROB_BITS 15
+#define CDF_PROB_TOP (1 << CDF_PROB_BITS)
+//#define CDF_INIT_TOP 32768
+#define CDF_SHIFT (15 - CDF_PROB_BITS)
+
+#define OD_CLZ0 (1)
+#define OD_CLZ(x) (-get_msb(x))
+#define OD_ILOG_NZ(x) (OD_CLZ0 - OD_CLZ(x))
+
+static inline int get_msb(unsigned int n) {
+    assert(n != 0);
+    return 31 ^ __builtin_clz(n);
+}
+
+#define EC_PROB_SHIFT 6
+#define EC_MIN_PROB 4  // must be <= (1<<EC_PROB_SHIFT)/16
+
+/*OPT: od_ec_window must be at least 32 bits, but if you have fast arithmetic
+ on a larger type, you can speed up the decoder by using it here.*/
+typedef uint32_t od_ec_window;
+
+#define OD_EC_WINDOW_SIZE ((int)sizeof(od_ec_window) * CHAR_BIT)
+
+/*The resolution of fractional-precision bit usage measurements, i.e.,
+ 3 => 1/8th bits.*/
+#define OD_BITRES (3)
+
+#define OD_ICDF AOM_ICDF
+
+#define AOM_ICDF(a) (32768-(a))
+
+/*A range decoder.
+  This is an entropy decoder based upon \cite{Mar79}, which is itself a
+   rediscovery of the FIFO arithmetic code introduced by \cite{Pas76}.
+  It is very similar to arithmetic encoding, except that encoding is done with
+   digits in any base, instead of with bits, and so it is faster when using
+   larger bases (i.e.: a byte).
+  The author claims an average waste of $\frac{1}{2}\log_b(2b)$ bits, where $b$
+   is the base, longer than the theoretical optimum, but to my knowledge there
+   is no published justification for this claim.
+  This only seems true when using near-infinite precision arithmetic so that
+   the process is carried out with no rounding errors.
+
+  An excellent description of implementation details is available at
+   http://www.arturocampos.com/ac_range.html
+  A recent work \cite{MNW98} which proposes several changes to arithmetic
+   encoding for efficiency actually re-discovers many of the principles
+   behind range encoding, and presents a good theoretical analysis of them.
+
+  End of stream is handled by writing out the smallest number of bits that
+   ensures that the stream will be correctly decoded regardless of the value of
+   any subsequent bits.
+  od_ec_dec_tell() can be used to determine how many bits were needed to decode
+   all the symbols thus far; other data can be packed in the remaining bits of
+   the input buffer.
+  @PHDTHESIS{Pas76,
+    author="Richard Clark Pasco",
+    title="Source coding algorithms for fast data compression",
+    school="Dept. of Electrical Engineering, Stanford University",
+    address="Stanford, CA",
+    month=May,
+    year=1976,
+    URL="http://www.richpasco.org/scaffdc.pdf"
+  }
+  @INPROCEEDINGS{Mar79,
+   author="Martin, G.N.N.",
+   title="Range encoding: an algorithm for removing redundancy from a digitised
+    message",
+   booktitle="Video & Data Recording Conference",
+   year=1979,
+   address="Southampton",
+   month=Jul,
+   URL="http://www.compressconsult.com/rangecoder/rngcod.pdf.gz"
+  }
+  @ARTICLE{MNW98,
+   author="Alistair Moffat and Radford Neal and Ian H. Witten",
+   title="Arithmetic Coding Revisited",
+   journal="{ACM} Transactions on Information Systems",
+   year=1998,
+   volume=16,
+   number=3,
+   pages="256--294",
+   month=Jul,
+   URL="http://researchcommons.waikato.ac.nz/bitstream/handle/10289/78/content.pdf"
+  }*/
+
+/*This is meant to be a large, positive constant that can still be efficiently
+   loaded as an immediate (on platforms like ARM, for example).
+  Even relatively modest values like 100 would work fine.*/
+#define OD_EC_LOTS_OF_BITS (0x4000)
+
+static void od_ec_dec_refill(od_ec_dec *dec) {
+  int s;
+  od_ec_window dif;
+  int16_t cnt;
+  const unsigned char *bptr;
+  const unsigned char *end;
+  dif = dec->dif;
+  cnt = dec->cnt;
+  bptr = dec->bptr;
+  end = dec->end;
+  s = OD_EC_WINDOW_SIZE - 9 - (cnt + 15);
+  for (; s >= 0 && bptr < end; s -= 8, bptr++) {
+    assert(s <= OD_EC_WINDOW_SIZE - 8);
+    dif ^= (od_ec_window)bptr[0] << s;
+    cnt += 8;
+  }
+  if (bptr >= end) {
+    dec->tell_offs += OD_EC_LOTS_OF_BITS - cnt;
+    cnt = OD_EC_LOTS_OF_BITS;
+  }
+  dec->dif = dif;
+  dec->cnt = cnt;
+  dec->bptr = bptr;
+}
+
+/*Takes updated dif and range values, renormalizes them so that
+   32768 <= rng < 65536 (reading more bytes from the stream into dif if
+   necessary), and stores them back in the decoder context.
+  dif: The new value of dif.
+  rng: The new value of the range.
+  ret: The value to return.
+  Return: ret.
+          This allows the compiler to jump to this function via a tail-call.*/
+static int od_ec_dec_normalize(od_ec_dec *dec, od_ec_window dif, unsigned rng,
+                               int ret) {
+  int d;
+  assert(rng <= 65535U);
+  d = 16 - OD_ILOG_NZ(rng);
+  dec->cnt -= d;
+  /*This is equivalent to shifting in 1's instead of 0's.*/
+  dec->dif = ((dif + 1) << d) - 1;
+  dec->rng = rng << d;
+  if (dec->cnt < 0) od_ec_dec_refill(dec);
+  return ret;
+}
+
+/*Initializes the decoder.
+  buf: The input buffer to use.
+  Return: 0 on success, or a negative value on error.*/
+void od_ec_dec_init(od_ec_dec *dec, const unsigned char *buf,
+                    uint32_t storage) {
+  dec->buf = buf;
+  dec->tell_offs = 10 - (OD_EC_WINDOW_SIZE - 8);
+  dec->end = buf + storage;
+  dec->bptr = buf;
+  dec->dif = ((od_ec_window)1 << (OD_EC_WINDOW_SIZE - 1)) - 1;
+  dec->rng = 0x8000;
+  dec->cnt = -15;
+  dec->error = 0;
+  od_ec_dec_refill(dec);
+}
+
+/*Decode a single binary value.
+  f: The probability that the bit is one, scaled by 32768.
+  Return: The value decoded (0 or 1).*/
+int od_ec_decode_bool_q15(od_ec_dec *dec, unsigned f) {
+  od_ec_window dif;
+  od_ec_window vw;
+  unsigned r;
+  unsigned r_new;
+  unsigned v;
+  int ret;
+  assert(0 < f);
+  assert(f < 32768U);
+  dif = dec->dif;
+  r = dec->rng;
+  assert(dif >> (OD_EC_WINDOW_SIZE - 16) < r);
+  assert(32768U <= r);
+  v = ((r >> 8) * (uint32_t)(f >> EC_PROB_SHIFT) >> (7 - EC_PROB_SHIFT));
+  v += EC_MIN_PROB;
+  vw = (od_ec_window)v << (OD_EC_WINDOW_SIZE - 16);
+  ret = 1;
+  r_new = v;
+  if (dif >= vw) {
+    r_new = r - v;
+    dif -= vw;
+    ret = 0;
+  }
+  return od_ec_dec_normalize(dec, dif, r_new, ret);
+}
+
+/*Decodes a symbol given an inverse cumulative distribution function (CDF)
+   table in Q15.
+  icdf: CDF_PROB_TOP minus the CDF, such that symbol s falls in the range
+         [s > 0 ? (CDF_PROB_TOP - icdf[s - 1]) : 0, CDF_PROB_TOP - icdf[s]).
+        The values must be monotonically non-increasing, and icdf[nsyms - 1]
+         must be 0.
+  nsyms: The number of symbols in the alphabet.
+         This should be at most 16.
+  Return: The decoded symbol s.*/
+int od_ec_decode_cdf_q15(od_ec_dec *dec, const uint16_t *icdf, int nsyms) {
+  od_ec_window dif;
+  unsigned r;
+  unsigned c;
+  unsigned u;
+  unsigned v;
+  int ret;
+  (void)nsyms;
+  dif = dec->dif;
+  r = dec->rng;
+  const int N = nsyms - 1;
+
+  assert(dif >> (OD_EC_WINDOW_SIZE - 16) < r);
+  assert(icdf[nsyms - 1] == OD_ICDF(CDF_PROB_TOP));
+  assert(32768U <= r);
+  assert(7 - EC_PROB_SHIFT - CDF_SHIFT >= 0);
+  c = (unsigned)(dif >> (OD_EC_WINDOW_SIZE - 16));
+  v = r;
+  ret = -1;
+  do {
+    u = v;
+    v = ((r >> 8) * (uint32_t)(icdf[++ret] >> EC_PROB_SHIFT) >>
+         (7 - EC_PROB_SHIFT - CDF_SHIFT));
+    v += EC_MIN_PROB * (N - ret);
+  } while (c < v);
+  assert(v < u);
+  assert(u <= r);
+  r = u - v;
+  dif -= (od_ec_window)v << (OD_EC_WINDOW_SIZE - 16);
+  return od_ec_dec_normalize(dec, dif, r, ret);
+}
+
+void msac_init(MsacContext *const c,
+               const uint8_t *const data, const size_t sz)
+{
+    od_ec_dec_init(c, data, sz);
+}
+
+unsigned msac_decode_symbol(MsacContext *const c, const uint16_t *const cdf,
+                            const unsigned n_symbols)
+{
+    return od_ec_decode_cdf_q15(c, cdf, n_symbols);
+}
+
+unsigned msac_decode_bool(MsacContext *const c, const unsigned cdf) {
+    return od_ec_decode_bool_q15(c, cdf);
+}
+
+unsigned msac_decode_bools(MsacContext *const c, const unsigned l) {
+    int v = 0;
+    for (int n = (int) l - 1; n >= 0; n--)
+        v = (v << 1) | msac_decode_bool(c, 128 << 7);
+    return v;
+}
+
+int msac_decode_subexp(MsacContext *const c, const int ref,
+                       const unsigned n, const unsigned k)
+{
+    int i = 0;
+    int a = 0;
+    int b = k;
+    while ((2 << b) < n) {
+        if (!msac_decode_bool(c, 128 << 7)) break;
+        b = k + i++;
+        a = (1 << b);
+    }
+    const unsigned v = msac_decode_bools(c, b) + a;
+    return ref * 2 <= n ? inv_recenter(ref, v) :
+                          n - 1 - inv_recenter(n - 1 - ref, v);
+}
+
+int msac_decode_uniform(MsacContext *const c, const unsigned n) {
+    assert(n > 0);
+    const int l = ulog2(n) + 1;
+    assert(l > 1);
+    const int m = (1 << l) - n;
+    const int v = msac_decode_bools(c, l - 1);
+    return v < m ? v : (v << 1) - m + msac_decode_bool(c, 128 << 7);
+}
+
+void update_cdf(uint16_t *cdf, unsigned val, unsigned nsymbs) {
+    int rate;
+    int i, tmp;
+
+    static const int nsymbs2speed[17] = {
+        0, 0, 1, 1, 2, 2, 2, 2, 2,
+        2, 2, 2, 2, 2, 2, 2, 2
+    };
+    assert(nsymbs < 17);
+    rate = 3 + (cdf[nsymbs] > 15) + (cdf[nsymbs] > 31) + nsymbs2speed[nsymbs];
+    tmp = 32768;
+
+    // Single loop (faster)
+    for (i = 0; i < nsymbs - 1; ++i) {
+        tmp = (i == val) ? 0 : tmp;
+        if (tmp < cdf[i]) {
+            cdf[i] -= ((cdf[i] - tmp) >> rate);
+        } else {
+            cdf[i] += ((tmp - cdf[i]) >> rate);
+        }
+    }
+
+    cdf[nsymbs] += (cdf[nsymbs] < 32);
+}
diff --git a/src/msac.h b/src/msac.h
new file mode 100644
index 0000000..8e61b5c
--- /dev/null
+++ b/src/msac.h
@@ -0,0 +1,56 @@
+/*
+ * Copyright (c) 2001-2016, Alliance for Open Media. All rights reserved
+ *
+ * This source code is subject to the terms of the BSD 2 Clause License and
+ * the Alliance for Open Media Patent License 1.0. If the BSD 2 Clause License
+ * was not distributed with this source code in the LICENSE file, you can
+ * obtain it at www.aomedia.org/license/software. If the Alliance for Open
+ * Media Patent License 1.0 was not distributed with this source code in the
+ * PATENTS file, you can obtain it at www.aomedia.org/license/patent.
+ */
+
+#ifndef __DAV1D_SRC_MSAC_H__
+#define __DAV1D_SRC_MSAC_H__
+
+#include <stdint.h>
+#include <stdlib.h>
+
+typedef struct MsacContext {
+    const uint8_t *buf, *end, *bptr;
+    int32_t tell_offs;
+    uint32_t dif;
+    uint16_t rng;
+    int16_t cnt;
+    int error;
+} MsacContext;
+
+void msac_init(MsacContext *c, const uint8_t *data, size_t sz);
+unsigned msac_decode_symbol(MsacContext *c, const uint16_t *cdf,
+                            const unsigned n_symbols);
+unsigned msac_decode_bool(MsacContext *c, unsigned cdf);
+unsigned msac_decode_bools(MsacContext *c, unsigned l);
+int msac_decode_subexp(MsacContext *c, int ref, unsigned n, unsigned k);
+int msac_decode_uniform(MsacContext *c, unsigned n);
+void update_cdf(uint16_t *cdf, unsigned val, unsigned nsymbs);
+
+static inline unsigned msac_decode_symbol_adapt(MsacContext *const c,
+                                                uint16_t *const cdf,
+                                                const unsigned n_symbols)
+{
+    const unsigned val = msac_decode_symbol(c, cdf, n_symbols);
+    update_cdf(cdf, val, n_symbols);
+    return val;
+}
+
+static inline unsigned msac_decode_bool_adapt(MsacContext *const c,
+                                              uint16_t *const cdf)
+{
+    const unsigned bit = msac_decode_bool(c, *cdf);
+    uint16_t bak_cdf[3] = { cdf[0], 0, cdf[1] };
+    update_cdf(bak_cdf, bit, 2);
+    cdf[0] = bak_cdf[0];
+    cdf[1] = bak_cdf[2];
+    return bit;
+}
+
+#endif /* __DAV1D_SRC_MSAC_H__ */
diff --git a/src/obu.c b/src/obu.c
new file mode 100644
index 0000000..cf5490b
--- /dev/null
+++ b/src/obu.c
@@ -0,0 +1,1102 @@
+/*
+ * Copyright © 2018, VideoLAN and dav1d authors
+ * Copyright © 2018, Two Orioles, LLC
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright notice, this
+ *    list of conditions and the following disclaimer.
+ *
+ * 2. Redistributions in binary form must reproduce the above copyright notice,
+ *    this list of conditions and the following disclaimer in the documentation
+ *    and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
+ * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#include "config.h"
+
+#include <assert.h>
+#include <errno.h>
+#include <limits.h>
+#include <stdio.h>
+
+#include "dav1d/data.h"
+
+#include "common/intops.h"
+
+#include "src/decode.h"
+#include "src/getbits.h"
+#include "src/levels.h"
+#include "src/obu.h"
+#include "src/ref.h"
+#include "src/warpmv.h"
+
+static int parse_seq_hdr(Dav1dContext *const c, GetBits *const gb) {
+    const uint8_t *const init_ptr = gb->ptr;
+    Av1SequenceHeader *const hdr = &c->seq_hdr;
+
+#define DEBUG_SEQ_HDR 0
+
+    hdr->profile = get_bits(gb, 3);
+    if (hdr->profile > 2U) goto error;
+#if DEBUG_SEQ_HDR
+    printf("SEQHDR: post-profile: off=%ld\n",
+           (gb->ptr - init_ptr) * 8 - gb->bits_left);
+#endif
+
+    hdr->still_picture = get_bits(gb, 1);
+    hdr->reduced_still_picture_header = get_bits(gb, 1);
+    if (hdr->reduced_still_picture_header && !hdr->still_picture) goto error;
+#if DEBUG_SEQ_HDR
+    printf("SEQHDR: post-stillpicture_flags: off=%ld\n",
+           (gb->ptr - init_ptr) * 8 - gb->bits_left);
+#endif
+
+    if (hdr->reduced_still_picture_header) {
+        hdr->timing_info_present = 0;
+        hdr->decoder_model_info_present = 0;
+        hdr->display_model_info_present = 0;
+        hdr->num_operating_points = 1;
+        hdr->operating_points[0].idc = 0;
+        hdr->operating_points[0].major_level = get_bits(gb, 3);
+        hdr->operating_points[0].minor_level = get_bits(gb, 2);
+        hdr->operating_points[0].tier = 0;
+        hdr->operating_points[0].decoder_model_param_present = 0;
+        hdr->operating_points[0].display_model_param_present = 0;
+    } else {
+        hdr->timing_info_present = get_bits(gb, 1);
+        if (hdr->timing_info_present) {
+            hdr->num_units_in_tick = get_bits(gb, 32);
+            hdr->time_scale = get_bits(gb, 32);
+            hdr->equal_picture_interval = get_bits(gb, 1);
+            if (hdr->equal_picture_interval)
+                hdr->num_ticks_per_picture = get_vlc(gb) + 1;
+
+            hdr->decoder_model_info_present = get_bits(gb, 1);
+            if (hdr->decoder_model_info_present) {
+                hdr->bitrate_scale = get_bits(gb, 4);
+                hdr->buffer_size_scale = get_bits(gb, 4);
+                hdr->encoder_decoder_buffer_delay_length = get_bits(gb, 5) + 1;
+                hdr->num_units_in_decoding_tick = get_bits(gb, 32);
+                hdr->buffer_removal_delay_length = get_bits(gb, 5) + 1;
+                hdr->frame_presentation_delay_length = get_bits(gb, 5) + 1;
+            }
+        } else {
+            hdr->decoder_model_info_present = 0;
+        }
+#if DEBUG_SEQ_HDR
+        printf("SEQHDR: post-timinginfo: off=%ld\n",
+               (gb->ptr - init_ptr) * 8 - gb->bits_left);
+#endif
+
+        hdr->display_model_info_present = get_bits(gb, 1);
+        hdr->num_operating_points = get_bits(gb, 5) + 1;
+        for (int i = 0; i < c->seq_hdr.num_operating_points; i++) {
+            struct Av1SequenceHeaderOperatingPoint *const op =
+                &hdr->operating_points[i];
+            op->idc = get_bits(gb, 12);
+            op->major_level = 2 + get_bits(gb, 3);
+            op->minor_level = get_bits(gb, 2);
+            op->tier = op->major_level > 3 ? get_bits(gb, 1) : 0;
+            op->decoder_model_param_present =
+                hdr->decoder_model_info_present && get_bits(gb, 1);
+            if (op->decoder_model_param_present) {
+                op->bitrate = get_vlc(gb) + 1;
+                op->buffer_size = get_vlc(gb) + 1;
+                op->cbr = get_bits(gb, 1);
+                op->decoder_buffer_delay =
+                    get_bits(gb, hdr->encoder_decoder_buffer_delay_length);
+                op->encoder_buffer_delay =
+                    get_bits(gb, hdr->encoder_decoder_buffer_delay_length);
+                op->low_delay_mode = get_bits(gb, 1);
+            }
+            op->display_model_param_present =
+                hdr->display_model_info_present && get_bits(gb, 1);
+            if (op->display_model_param_present) {
+                op->initial_display_delay = get_bits(gb, 4) + 1;
+            }
+        }
+#if DEBUG_SEQ_HDR
+        printf("SEQHDR: post-operating-points: off=%ld\n",
+               (gb->ptr - init_ptr) * 8 - gb->bits_left);
+#endif
+    }
+
+    hdr->width_n_bits = get_bits(gb, 4) + 1;
+    hdr->height_n_bits = get_bits(gb, 4) + 1;
+    hdr->max_width = get_bits(gb, hdr->width_n_bits) + 1;
+    hdr->max_height = get_bits(gb, hdr->height_n_bits) + 1;
+#if DEBUG_SEQ_HDR
+    printf("SEQHDR: post-size: off=%ld\n",
+           (gb->ptr - init_ptr) * 8 - gb->bits_left);
+#endif
+    hdr->frame_id_numbers_present =
+        hdr->reduced_still_picture_header ? 0 : get_bits(gb, 1);
+    if (hdr->frame_id_numbers_present) {
+        hdr->delta_frame_id_n_bits = get_bits(gb, 4) + 2;
+        hdr->frame_id_n_bits = get_bits(gb, 3) + hdr->delta_frame_id_n_bits + 1;
+    }
+#if DEBUG_SEQ_HDR
+    printf("SEQHDR: post-frame-id-numbers-present: off=%ld\n",
+           (gb->ptr - init_ptr) * 8 - gb->bits_left);
+#endif
+
+    hdr->sb128 = get_bits(gb, 1);
+    hdr->filter_intra = get_bits(gb, 1);
+    hdr->intra_edge_filter = get_bits(gb, 1);
+    if (hdr->reduced_still_picture_header) {
+        hdr->inter_intra = 0;
+        hdr->masked_compound = 0;
+        hdr->warped_motion = 0;
+        hdr->dual_filter = 0;
+        hdr->order_hint = 0;
+        hdr->jnt_comp = 0;
+        hdr->ref_frame_mvs = 0;
+        hdr->order_hint_n_bits = 0;
+        hdr->screen_content_tools = ADAPTIVE;
+        hdr->force_integer_mv = ADAPTIVE;
+    } else {
+        hdr->inter_intra = get_bits(gb, 1);
+        hdr->masked_compound = get_bits(gb, 1);
+        hdr->warped_motion = get_bits(gb, 1);
+        hdr->dual_filter = get_bits(gb, 1);
+        hdr->order_hint = get_bits(gb, 1);
+        if (hdr->order_hint) {
+            hdr->jnt_comp = get_bits(gb, 1);
+            hdr->ref_frame_mvs = get_bits(gb, 1);
+        } else {
+            hdr->jnt_comp = 0;
+            hdr->ref_frame_mvs = 0;
+            hdr->order_hint_n_bits = 0;
+        }
+        hdr->screen_content_tools = get_bits(gb, 1) ? ADAPTIVE : get_bits(gb, 1);
+    #if DEBUG_SEQ_HDR
+        printf("SEQHDR: post-screentools: off=%ld\n",
+               (gb->ptr - init_ptr) * 8 - gb->bits_left);
+    #endif
+        hdr->force_integer_mv = hdr->screen_content_tools ?
+                                get_bits(gb, 1) ? ADAPTIVE : get_bits(gb, 1) : 2;
+        if (hdr->order_hint)
+            hdr->order_hint_n_bits = get_bits(gb, 3) + 1;
+    }
+    hdr->super_res = get_bits(gb, 1);
+    hdr->cdef = get_bits(gb, 1);
+    hdr->restoration = get_bits(gb, 1);
+#if DEBUG_SEQ_HDR
+    printf("SEQHDR: post-featurebits: off=%ld\n",
+           (gb->ptr - init_ptr) * 8 - gb->bits_left);
+#endif
+
+    const int hbd = get_bits(gb, 1);
+    hdr->bpc = hdr->profile == 2 && hbd ? 10 + 2 * get_bits(gb, 1): 8 + 2 * hbd;
+    hdr->hbd = hdr->bpc > 8;
+    const int monochrome = hdr->profile != 1 ? get_bits(gb, 1) : 0;
+    hdr->color_description_present = get_bits(gb, 1);
+    if (hdr->color_description_present) {
+        hdr->pri = get_bits(gb, 8);
+        hdr->trc = get_bits(gb, 8);
+        hdr->mtrx = get_bits(gb, 8);
+    } else {
+        hdr->pri = DAV1D_COLOR_PRI_UNKNOWN;
+        hdr->trc = DAV1D_TRC_UNKNOWN;
+        hdr->mtrx = DAV1D_MC_UNKNOWN;
+    }
+    if (monochrome) {
+        hdr->color_range = get_bits(gb, 1);
+        hdr->layout = DAV1D_PIXEL_LAYOUT_I400;
+        hdr->chr = DAV1D_CHR_UNKNOWN;
+        hdr->separate_uv_delta_q = 0;
+    } else if (hdr->pri == DAV1D_COLOR_PRI_BT709 &&
+               hdr->trc == DAV1D_TRC_SRGB &&
+               hdr->mtrx == DAV1D_MC_IDENTITY)
+    {
+        hdr->layout = DAV1D_PIXEL_LAYOUT_I444;
+        hdr->color_range = 1;
+        if (hdr->profile != 1 && !(hdr->profile == 2 && hdr->bpc == 12))
+            goto error;
+    } else {
+        hdr->color_range = get_bits(gb, 1);
+        switch (hdr->profile) {
+        case 0: hdr->layout = DAV1D_PIXEL_LAYOUT_I420; break;
+        case 1: hdr->layout = DAV1D_PIXEL_LAYOUT_I444; break;
+        case 2:
+            if (hdr->bpc == 12) {
+                hdr->layout = get_bits(gb, 1) ?
+                              get_bits(gb, 1) ? DAV1D_PIXEL_LAYOUT_I420 :
+                                                DAV1D_PIXEL_LAYOUT_I422 :
+                                                DAV1D_PIXEL_LAYOUT_I444;
+            } else
+                hdr->layout = DAV1D_PIXEL_LAYOUT_I422;
+            break;
+        }
+        if (hdr->layout == DAV1D_PIXEL_LAYOUT_I420)
+            hdr->chr = get_bits(gb, 2);
+        hdr->separate_uv_delta_q = get_bits(gb, 1);
+    }
+#if DEBUG_SEQ_HDR
+    printf("SEQHDR: post-colorinfo: off=%ld\n",
+           (gb->ptr - init_ptr) * 8 - gb->bits_left);
+#endif
+
+    c->seq_hdr.film_grain_present = get_bits(gb, 1);
+#if DEBUG_SEQ_HDR
+    printf("SEQHDR: post-filmgrain: off=%ld\n",
+           (gb->ptr - init_ptr) * 8 - gb->bits_left);
+#endif
+
+    get_bits(gb, 1); // dummy bit
+
+    return flush_get_bits(gb) - init_ptr;
+
+error:
+    fprintf(stderr, "Error parsing sequence header\n");
+    return -EINVAL;
+}
+
+static int read_frame_size(Dav1dContext *const c, GetBits *const gb,
+                           const int use_ref)
+{
+    const Av1SequenceHeader *const seqhdr = &c->seq_hdr;
+    Av1FrameHeader *const hdr = &c->frame_hdr;
+
+    if (use_ref) {
+        for (int i = 0; i < 7; i++) {
+            if (get_bits(gb, 1)) {
+                Dav1dThreadPicture *const ref =
+                    &c->refs[c->frame_hdr.refidx[i]].p;
+                if (!ref->p.data[0]) return -1;
+                // FIXME render_* may be wrong
+                hdr->render_width = hdr->width = ref->p.p.w;
+                hdr->render_height = hdr->height = ref->p.p.h;
+                hdr->super_res = 0; // FIXME probably wrong
+                return 0;
+            }
+        }
+    }
+
+    if (hdr->frame_size_override) {
+        hdr->width = get_bits(gb, seqhdr->width_n_bits) + 1;
+        hdr->height = get_bits(gb, seqhdr->height_n_bits) + 1;
+    } else {
+        hdr->width = seqhdr->max_width;
+        hdr->height = seqhdr->max_height;
+    }
+    hdr->super_res = seqhdr->super_res && get_bits(gb, 1);
+    if (hdr->super_res) return -1; // FIXME
+    hdr->have_render_size = get_bits(gb, 1);
+    if (hdr->have_render_size) {
+        hdr->render_width = get_bits(gb, seqhdr->width_n_bits) + 1;
+        hdr->render_height = get_bits(gb, seqhdr->height_n_bits) + 1;
+    } else {
+        hdr->render_width = hdr->width;
+        hdr->render_height = hdr->height;
+    }
+    return 0;
+}
+
+static inline int tile_log2(int sz, int tgt) {
+    int k;
+    for (k = 0; (sz << k) < tgt; k++) ;
+    return k;
+}
+
+static const Av1LoopfilterModeRefDeltas default_mode_ref_deltas = {
+    .mode_delta = { 0, 0 },
+    .ref_delta = { 1, 0, 0, 0, -1, 0, -1, -1 },
+};
+
+static int parse_frame_hdr(Dav1dContext *const c, GetBits *const gb,
+                           const int have_trailing_bit)
+{
+    const uint8_t *const init_ptr = gb->ptr;
+    const Av1SequenceHeader *const seqhdr = &c->seq_hdr;
+    Av1FrameHeader *const hdr = &c->frame_hdr;
+    int res;
+
+#define DEBUG_FRAME_HDR 0
+
+    hdr->show_existing_frame =
+        !seqhdr->reduced_still_picture_header && get_bits(gb, 1);
+#if DEBUG_FRAME_HDR
+    printf("HDR: post-show_existing_frame: off=%ld\n",
+           (gb->ptr - init_ptr) * 8 - gb->bits_left);
+#endif
+    if (hdr->show_existing_frame) {
+        hdr->existing_frame_idx = get_bits(gb, 3);
+        if (seqhdr->frame_id_numbers_present)
+            hdr->frame_id = get_bits(gb, seqhdr->frame_id_n_bits);
+        goto end;
+    }
+
+    hdr->frame_type = seqhdr->reduced_still_picture_header ? KEY_FRAME : get_bits(gb, 2);
+    hdr->show_frame = seqhdr->reduced_still_picture_header || get_bits(gb, 1);
+    if (!hdr->show_frame)
+        hdr->showable_frame = get_bits(gb, 1);
+    hdr->error_resilient_mode =
+        (hdr->frame_type == KEY_FRAME && hdr->show_frame) ||
+        hdr->frame_type == S_FRAME ||
+        seqhdr->reduced_still_picture_header || get_bits(gb, 1);
+#if DEBUG_FRAME_HDR
+    printf("HDR: post-frametype_bits: off=%ld\n",
+           (gb->ptr - init_ptr) * 8 - gb->bits_left);
+#endif
+    hdr->disable_cdf_update = get_bits(gb, 1);
+    hdr->allow_screen_content_tools = seqhdr->screen_content_tools == ADAPTIVE ?
+                                 get_bits(gb, 1) : seqhdr->screen_content_tools;
+    if (hdr->allow_screen_content_tools)
+        hdr->force_integer_mv = seqhdr->force_integer_mv == ADAPTIVE ?
+                                get_bits(gb, 1) : seqhdr->force_integer_mv;
+
+    if (seqhdr->frame_id_numbers_present)
+        hdr->frame_id = get_bits(gb, seqhdr->frame_id_n_bits);
+
+    hdr->frame_size_override = seqhdr->reduced_still_picture_header ? 0 :
+                               hdr->frame_type == S_FRAME ? 1 : get_bits(gb, 1);
+#if DEBUG_FRAME_HDR
+    printf("HDR: post-frame_size_override_flag: off=%ld\n",
+           (gb->ptr - init_ptr) * 8 - gb->bits_left);
+#endif
+    hdr->frame_offset = seqhdr->order_hint ?
+                        get_bits(gb, seqhdr->order_hint_n_bits) : 0;
+    hdr->primary_ref_frame = !hdr->error_resilient_mode && hdr->frame_type & 1 ?
+                             get_bits(gb, 3) : PRIMARY_REF_NONE;
+
+    if (hdr->frame_type == KEY_FRAME) {
+        hdr->refresh_frame_flags = hdr->show_frame ? 0xff : get_bits(gb, 8);
+        if ((res = read_frame_size(c, gb, 0)) < 0) goto error;
+        hdr->allow_intrabc = hdr->allow_screen_content_tools &&
+                             /* FIXME: no superres scaling && */ get_bits(gb, 1);
+        hdr->use_ref_frame_mvs = 0;
+    } else {
+        if (hdr->error_resilient_mode && seqhdr->order_hint)
+            for (int i = 0; i < 8; i++)
+                get_bits(gb, seqhdr->order_hint_n_bits);
+
+        if (hdr->frame_type == INTRAONLY_FRAME) {
+            hdr->refresh_frame_flags = get_bits(gb, 8);
+            if ((res = read_frame_size(c, gb, 0)) < 0) goto error;
+            hdr->allow_intrabc = hdr->allow_screen_content_tools &&
+                             /* FIXME: no superres scaling && */ get_bits(gb, 1);
+        } else {
+            hdr->allow_intrabc = 0;
+            hdr->refresh_frame_flags = hdr->frame_type == S_FRAME ? 0xff :
+                                       get_bits(gb, 8);
+            hdr->frame_ref_short_signaling =
+                seqhdr->order_hint && get_bits(gb, 1);
+            if (hdr->frame_ref_short_signaling) goto error; // FIXME
+            for (int i = 0; i < 7; i++) {
+                hdr->refidx[i] = get_bits(gb, 3);
+                if (seqhdr->frame_id_numbers_present)
+                    get_bits(gb, seqhdr->delta_frame_id_n_bits);
+            }
+            const int use_ref = !hdr->error_resilient_mode &&
+                                hdr->frame_size_override;
+            if ((res = read_frame_size(c, gb, use_ref)) < 0) goto error;
+            hdr->hp = !hdr->force_integer_mv && get_bits(gb, 1);
+            hdr->subpel_filter_mode = get_bits(gb, 1) ? FILTER_SWITCHABLE :
+                                                        get_bits(gb, 2);
+            hdr->switchable_motion_mode = get_bits(gb, 1);
+            hdr->use_ref_frame_mvs = !hdr->error_resilient_mode &&
+                seqhdr->ref_frame_mvs && seqhdr->order_hint &&
+                hdr->frame_type & 1 && get_bits(gb, 1);
+        }
+    }
+#if DEBUG_FRAME_HDR
+    printf("HDR: post-frametype-specific-bits: off=%ld\n",
+           (gb->ptr - init_ptr) * 8 - gb->bits_left);
+#endif
+
+    hdr->refresh_context = !seqhdr->reduced_still_picture_header &&
+                           !hdr->disable_cdf_update && !get_bits(gb, 1);
+#if DEBUG_FRAME_HDR
+    printf("HDR: post-refresh_context: off=%ld\n",
+           (gb->ptr - init_ptr) * 8 - gb->bits_left);
+#endif
+
+    // tile data
+    hdr->tiling.uniform = get_bits(gb, 1);
+    const int sbsz_min1 = (64 << seqhdr->sb128) - 1;
+    int sbsz_log2 = 6 + seqhdr->sb128;
+    int sbw = (hdr->width + sbsz_min1) >> sbsz_log2;
+    int sbh = (hdr->height + sbsz_min1) >> sbsz_log2;
+    int max_tile_width_sb = 4096 >> sbsz_log2, max_tile_height_sb;
+    int max_tile_area_sb = 4096 * 2304 >> (2 * sbsz_log2);
+    hdr->tiling.min_log2_cols = tile_log2(max_tile_width_sb, sbw);
+    hdr->tiling.max_log2_cols = tile_log2(1, imin(sbw, 1024));
+    hdr->tiling.max_log2_rows = tile_log2(1, imin(sbh, 1024));
+    int min_log2_tiles = imax(tile_log2(max_tile_area_sb, sbw * sbh),
+                              hdr->tiling.min_log2_cols);
+    if (hdr->tiling.uniform) {
+        for (hdr->tiling.log2_cols = hdr->tiling.min_log2_cols;
+             hdr->tiling.log2_cols < hdr->tiling.max_log2_cols && get_bits(gb, 1);
+             hdr->tiling.log2_cols++) ;
+        const int tile_w = 1 + ((sbw - 1) >> hdr->tiling.log2_cols);
+        hdr->tiling.cols = 0;
+        for (int sbx = 0; sbx < sbw; sbx += tile_w, hdr->tiling.cols++)
+            hdr->tiling.col_start_sb[hdr->tiling.cols] = sbx;
+        hdr->tiling.min_log2_rows =
+            imax(min_log2_tiles - hdr->tiling.log2_cols, 0);
+        max_tile_height_sb = sbh >> hdr->tiling.min_log2_rows;
+
+        for (hdr->tiling.log2_rows = hdr->tiling.min_log2_rows;
+             hdr->tiling.log2_rows < hdr->tiling.max_log2_rows && get_bits(gb, 1);
+             hdr->tiling.log2_rows++) ;
+        const int tile_h = 1 + ((sbh - 1) >> hdr->tiling.log2_rows);
+        hdr->tiling.rows = 0;
+        for (int sby = 0; sby < sbh; sby += tile_h, hdr->tiling.rows++)
+            hdr->tiling.row_start_sb[hdr->tiling.rows] = sby;
+    } else {
+        hdr->tiling.cols = 0;
+        int widest_tile = 0, max_tile_area_sb = sbw * sbh;
+        for (int sbx = 0; sbx < sbw; hdr->tiling.cols++) {
+            const int tile_w = get_uniform(gb, imin(sbw - sbx,
+                                                    max_tile_width_sb));
+            hdr->tiling.col_start_sb[hdr->tiling.cols] = sbx;
+            sbx += tile_w;
+            widest_tile = imax(widest_tile, tile_w);
+        }
+        hdr->tiling.log2_cols = tile_log2(1, hdr->tiling.cols);
+        if (min_log2_tiles) max_tile_area_sb >>= min_log2_tiles + 1;
+        max_tile_height_sb = imax(max_tile_area_sb / widest_tile, 1);
+
+        hdr->tiling.rows = 0;
+        for (int sby = 0; sby < sbh; hdr->tiling.rows++) {
+            const int tile_h = get_uniform(gb, imin(sbh - sby,
+                                                    max_tile_height_sb));
+            hdr->tiling.row_start_sb[hdr->tiling.rows] = sby;
+            sby += tile_h;
+        }
+        hdr->tiling.log2_rows = tile_log2(1, hdr->tiling.rows);
+    }
+    hdr->tiling.col_start_sb[hdr->tiling.cols] = sbw;
+    hdr->tiling.row_start_sb[hdr->tiling.rows] = sbh;
+    if (hdr->tiling.log2_cols || hdr->tiling.log2_rows) {
+        hdr->tiling.update = get_bits(gb, hdr->tiling.log2_cols +
+                                          hdr->tiling.log2_rows);
+        hdr->tiling.n_bytes = get_bits(gb, 2) + 1;
+    } else {
+        hdr->tiling.n_bytes = hdr->tiling.update = 0;
+    }
+#if DEBUG_FRAME_HDR
+    printf("HDR: post-tiling: off=%ld\n",
+           (gb->ptr - init_ptr) * 8 - gb->bits_left);
+#endif
+
+    // quant data
+    hdr->quant.yac = get_bits(gb, 8);
+    hdr->quant.ydc_delta = get_bits(gb, 1) ? get_sbits(gb, 6) : 0;
+    if (seqhdr->layout != DAV1D_PIXEL_LAYOUT_I400) {
+        hdr->quant.udc_delta = get_bits(gb, 1) ? get_sbits(gb, 6) : 0;
+        hdr->quant.uac_delta = get_bits(gb, 1) ? get_sbits(gb, 6) : 0;
+        if (seqhdr->separate_uv_delta_q) {
+            hdr->quant.vdc_delta = get_bits(gb, 1) ? get_sbits(gb, 6) : 0;
+            hdr->quant.vac_delta = get_bits(gb, 1) ? get_sbits(gb, 6) : 0;
+        } else {
+            hdr->quant.vdc_delta = hdr->quant.udc_delta;
+            hdr->quant.vac_delta = hdr->quant.uac_delta;
+        }
+    }
+#if DEBUG_FRAME_HDR
+    printf("HDR: post-quant: off=%ld\n",
+           (gb->ptr - init_ptr) * 8 - gb->bits_left);
+#endif
+    hdr->quant.qm = get_bits(gb, 1);
+    if (hdr->quant.qm) {
+        hdr->quant.qm_y = get_bits(gb, 4);
+        hdr->quant.qm_u = get_bits(gb, 4);
+        hdr->quant.qm_v = seqhdr->separate_uv_delta_q ? get_bits(gb, 4) :
+                                                        hdr->quant.qm_u;
+    }
+#if DEBUG_FRAME_HDR
+    printf("HDR: post-qm: off=%ld\n",
+           (gb->ptr - init_ptr) * 8 - gb->bits_left);
+#endif
+
+    // segmentation data
+    hdr->segmentation.enabled = get_bits(gb, 1);
+    if (hdr->segmentation.enabled) {
+        if (hdr->primary_ref_frame == PRIMARY_REF_NONE) {
+            hdr->segmentation.update_map = 1;
+            hdr->segmentation.temporal = 0;
+            hdr->segmentation.update_data = 1;
+        } else {
+            hdr->segmentation.update_map = get_bits(gb, 1);
+            hdr->segmentation.temporal =
+                hdr->segmentation.update_map ? get_bits(gb, 1) : 0;
+            hdr->segmentation.update_data = get_bits(gb, 1);
+        }
+
+        if (hdr->segmentation.update_data) {
+            hdr->segmentation.seg_data.preskip = 0;
+            hdr->segmentation.seg_data.last_active_segid = -1;
+            for (int i = 0; i < NUM_SEGMENTS; i++) {
+                Av1SegmentationData *const seg =
+                    &hdr->segmentation.seg_data.d[i];
+                if (get_bits(gb, 1)) {
+                    seg->delta_q = get_sbits(gb, 8);
+                    hdr->segmentation.seg_data.last_active_segid = i;
+                } else {
+                    seg->delta_q = 0;
+                }
+                if (get_bits(gb, 1)) {
+                    seg->delta_lf_y_v = get_sbits(gb, 6);
+                    hdr->segmentation.seg_data.last_active_segid = i;
+                } else {
+                    seg->delta_lf_y_v = 0;
+                }
+                if (get_bits(gb, 1)) {
+                    seg->delta_lf_y_h = get_sbits(gb, 6);
+                    hdr->segmentation.seg_data.last_active_segid = i;
+                } else {
+                    seg->delta_lf_y_h = 0;
+                }
+                if (get_bits(gb, 1)) {
+                    seg->delta_lf_u = get_sbits(gb, 6);
+                    hdr->segmentation.seg_data.last_active_segid = i;
+                } else {
+                    seg->delta_lf_u = 0;
+                }
+                if (get_bits(gb, 1)) {
+                    seg->delta_lf_v = get_sbits(gb, 6);
+                    hdr->segmentation.seg_data.last_active_segid = i;
+                } else {
+                    seg->delta_lf_v = 0;
+                }
+                if (get_bits(gb, 1)) {
+                    seg->ref = get_bits(gb, 3);
+                    hdr->segmentation.seg_data.last_active_segid = i;
+                    hdr->segmentation.seg_data.preskip = 1;
+                } else {
+                    seg->ref = -1;
+                }
+                if ((seg->skip = get_bits(gb, 1))) {
+                    hdr->segmentation.seg_data.last_active_segid = i;
+                    hdr->segmentation.seg_data.preskip = 1;
+                }
+                if ((seg->globalmv = get_bits(gb, 1))) {
+                    hdr->segmentation.seg_data.last_active_segid = i;
+                    hdr->segmentation.seg_data.preskip = 1;
+                }
+            }
+        } else {
+            const int pri_ref = hdr->refidx[hdr->primary_ref_frame];
+            hdr->segmentation.seg_data = c->refs[pri_ref].seg_data;
+        }
+    } else {
+        const int pri_ref = hdr->refidx[hdr->primary_ref_frame];
+        hdr->segmentation.seg_data = c->refs[pri_ref].seg_data;
+    }
+#if DEBUG_FRAME_HDR
+    printf("HDR: post-segmentation: off=%ld\n",
+           (gb->ptr - init_ptr) * 8 - gb->bits_left);
+#endif
+
+    // delta q
+    hdr->delta_q_present = hdr->quant.yac ? get_bits(gb, 1) : 0;
+    hdr->delta_q_res_log2 = hdr->delta_q_present ? get_bits(gb, 2) : 0;
+    hdr->delta_lf_present = hdr->delta_q_present && !hdr->allow_intrabc &&
+                            get_bits(gb, 1);
+    hdr->delta_lf_res_log2 = hdr->delta_lf_present ? get_bits(gb, 2) : 0;
+    hdr->delta_lf_multi = hdr->delta_lf_present ? get_bits(gb, 1) : 0;
+#if DEBUG_FRAME_HDR
+    printf("HDR: post-delta_q_lf_flags: off=%ld\n",
+           (gb->ptr - init_ptr) * 8 - gb->bits_left);
+#endif
+
+    // derive lossless flags
+    const int delta_lossless = !hdr->quant.ydc_delta && !hdr->quant.udc_delta &&
+        !hdr->quant.uac_delta && !hdr->quant.vdc_delta && !hdr->quant.vac_delta;
+    hdr->all_lossless = 1;
+    for (int i = 0; i < NUM_SEGMENTS; i++) {
+        hdr->segmentation.qidx[i] = hdr->segmentation.enabled ?
+            iclip_u8(hdr->quant.yac + hdr->segmentation.seg_data.d[i].delta_q) :
+            hdr->quant.yac;
+        hdr->segmentation.lossless[i] =
+            !hdr->segmentation.qidx[i] && delta_lossless;
+        hdr->all_lossless &= hdr->segmentation.lossless[i];
+    }
+
+    // loopfilter
+    if (hdr->all_lossless || hdr->allow_intrabc) {
+        hdr->loopfilter.level_y[0] = hdr->loopfilter.level_y[1] = 0;
+        hdr->loopfilter.level_u = hdr->loopfilter.level_v = 0;
+        hdr->loopfilter.sharpness = 0;
+        hdr->loopfilter.mode_ref_delta_enabled = 1;
+        hdr->loopfilter.mode_ref_delta_update = 1;
+        hdr->loopfilter.mode_ref_deltas = default_mode_ref_deltas;
+    } else {
+        hdr->loopfilter.level_y[0] = get_bits(gb, 6);
+        hdr->loopfilter.level_y[1] = get_bits(gb, 6);
+        if (seqhdr->layout != DAV1D_PIXEL_LAYOUT_I400 &&
+            (hdr->loopfilter.level_y[0] || hdr->loopfilter.level_y[1]))
+        {
+            hdr->loopfilter.level_u = get_bits(gb, 6);
+            hdr->loopfilter.level_v = get_bits(gb, 6);
+        }
+        hdr->loopfilter.sharpness = get_bits(gb, 3);
+
+        if (hdr->primary_ref_frame == PRIMARY_REF_NONE) {
+            hdr->loopfilter.mode_ref_deltas = default_mode_ref_deltas;
+        } else {
+            const int ref = hdr->refidx[hdr->primary_ref_frame];
+            hdr->loopfilter.mode_ref_deltas = c->refs[ref].lf_mode_ref_deltas;
+        }
+        hdr->loopfilter.mode_ref_delta_enabled = get_bits(gb, 1);
+        if (hdr->loopfilter.mode_ref_delta_enabled) {
+            hdr->loopfilter.mode_ref_delta_update = get_bits(gb, 1);
+            if (hdr->loopfilter.mode_ref_delta_update) {
+                for (int i = 0; i < 8; i++)
+                    if (get_bits(gb, 1))
+                        hdr->loopfilter.mode_ref_deltas.ref_delta[i] =
+                            get_sbits(gb, 6);
+                for (int i = 0; i < 2; i++)
+                    if (get_bits(gb, 1))
+                        hdr->loopfilter.mode_ref_deltas.mode_delta[i] =
+                            get_sbits(gb, 6);
+            }
+        }
+    }
+#if DEBUG_FRAME_HDR
+    printf("HDR: post-lpf: off=%ld\n",
+           (gb->ptr - init_ptr) * 8 - gb->bits_left);
+#endif
+
+    // cdef
+    if (!hdr->all_lossless && seqhdr->cdef && !hdr->allow_intrabc) {
+        hdr->cdef.damping = get_bits(gb, 2) + 3;
+        hdr->cdef.n_bits = get_bits(gb, 2);
+        for (int i = 0; i < (1 << hdr->cdef.n_bits); i++) {
+            hdr->cdef.y_strength[i] = get_bits(gb, 6);
+            if (seqhdr->layout != DAV1D_PIXEL_LAYOUT_I400)
+                hdr->cdef.uv_strength[i] = get_bits(gb, 6);
+        }
+    } else {
+        hdr->cdef.n_bits = 0;
+        hdr->cdef.y_strength[0] = 0;
+        hdr->cdef.uv_strength[0] = 0;
+    }
+#if DEBUG_FRAME_HDR
+    printf("HDR: post-cdef: off=%ld\n",
+           (gb->ptr - init_ptr) * 8 - gb->bits_left);
+#endif
+
+    // restoration
+    if (!hdr->all_lossless && seqhdr->restoration && !hdr->allow_intrabc) {
+        hdr->restoration.type[0] = get_bits(gb, 2);
+        if (seqhdr->layout != DAV1D_PIXEL_LAYOUT_I400) {
+            hdr->restoration.type[1] = get_bits(gb, 2);
+            hdr->restoration.type[2] = get_bits(gb, 2);
+        }
+
+        if (hdr->restoration.type[0] || hdr->restoration.type[1] ||
+            hdr->restoration.type[2])
+        {
+            // Log2 of the restoration unit size.
+            hdr->restoration.unit_size[0] = 6 + seqhdr->sb128;
+            if (get_bits(gb, 1)) {
+                hdr->restoration.unit_size[0]++;
+                if (!seqhdr->sb128)
+                    hdr->restoration.unit_size[0] += get_bits(gb, 1);
+            }
+            hdr->restoration.unit_size[1] = hdr->restoration.unit_size[0];
+            if ((hdr->restoration.type[1] || hdr->restoration.type[2]) &&
+                seqhdr->layout == DAV1D_PIXEL_LAYOUT_I420)
+            {
+                hdr->restoration.unit_size[1] -= get_bits(gb, 1);
+            }
+        } else {
+            hdr->restoration.unit_size[0] = 8;
+        }
+    } else {
+        hdr->restoration.type[0] = RESTORATION_NONE;
+        hdr->restoration.type[1] = RESTORATION_NONE;
+        hdr->restoration.type[2] = RESTORATION_NONE;
+    }
+#if DEBUG_FRAME_HDR
+    printf("HDR: post-restoration: off=%ld\n",
+           (gb->ptr - init_ptr) * 8 - gb->bits_left);
+#endif
+
+    hdr->txfm_mode = hdr->all_lossless ? TX_4X4_ONLY :
+                     get_bits(gb, 1) ? TX_SWITCHABLE : TX_LARGEST;
+#if DEBUG_FRAME_HDR
+    printf("HDR: post-txfmmode: off=%ld\n",
+           (gb->ptr - init_ptr) * 8 - gb->bits_left);
+#endif
+    hdr->switchable_comp_refs = hdr->frame_type & 1 ? get_bits(gb, 1) : 0;
+#if DEBUG_FRAME_HDR
+    printf("HDR: post-refmode: off=%ld\n",
+           (gb->ptr - init_ptr) * 8 - gb->bits_left);
+#endif
+    hdr->skip_mode_allowed = 0;
+    if (hdr->switchable_comp_refs && hdr->frame_type & 1) {
+        const unsigned poc = hdr->frame_offset;
+        unsigned off_before[2] = { 0xFFFFFFFF, 0xFFFFFFFF };
+        int off_after = -1;
+        int off_before_idx[2], off_after_idx;
+        for (int i = 0; i < 7; i++) {
+            const unsigned refpoc = c->refs[hdr->refidx[i]].p.p.poc;
+
+            const int diff = get_poc_diff(seqhdr->order_hint_n_bits, refpoc, poc);
+            if (diff > 0) {
+                if (off_after == -1 || get_poc_diff(seqhdr->order_hint_n_bits,
+                                                    off_after, refpoc) > 0)
+                {
+                    off_after = refpoc;
+                    off_after_idx = i;
+                }
+            } else if (diff < 0) {
+                if (off_before[0] == 0xFFFFFFFFU ||
+                    get_poc_diff(seqhdr->order_hint_n_bits,
+                                 refpoc, off_before[0]) > 0)
+                {
+                    off_before[1] = off_before[0];
+                    off_before[0] = refpoc;
+                    off_before_idx[1] = off_before_idx[0];
+                    off_before_idx[0] = i;
+                } else if (refpoc != off_before[0] &&
+                           (off_before[1] == 0xFFFFFFFFU ||
+                            get_poc_diff(seqhdr->order_hint_n_bits,
+                                         refpoc, off_before[1]) > 0))
+                {
+                    off_before[1] = refpoc;
+                    off_before_idx[1] = i;
+                }
+            }
+        }
+
+        if (off_before[0] != 0xFFFFFFFFU && off_after != -1) {
+            hdr->skip_mode_refs[0] = off_before_idx[0];
+            hdr->skip_mode_refs[1] = off_after_idx;
+            hdr->skip_mode_allowed = 1;
+        } else if (off_before[0] != 0xFFFFFFFFU &&
+                   off_before[1] != 0xFFFFFFFFU)
+        {
+            hdr->skip_mode_refs[0] = off_before_idx[0];
+            hdr->skip_mode_refs[1] = off_before_idx[1];
+            hdr->skip_mode_allowed = 1;
+        }
+    }
+    hdr->skip_mode_enabled = hdr->skip_mode_allowed ? get_bits(gb, 1) : 0;
+#if DEBUG_FRAME_HDR
+    printf("HDR: post-extskip: off=%ld\n",
+           (gb->ptr - init_ptr) * 8 - gb->bits_left);
+#endif
+    hdr->warp_motion = !hdr->error_resilient_mode && hdr->frame_type & 1 &&
+        seqhdr->warped_motion && get_bits(gb, 1);
+#if DEBUG_FRAME_HDR
+    printf("HDR: post-warpmotionbit: off=%ld\n",
+           (gb->ptr - init_ptr) * 8 - gb->bits_left);
+#endif
+    hdr->reduced_txtp_set = get_bits(gb, 1);
+#if DEBUG_FRAME_HDR
+    printf("HDR: post-reducedtxtpset: off=%ld\n",
+           (gb->ptr - init_ptr) * 8 - gb->bits_left);
+#endif
+
+    for (int i = 0; i < 7; i++)
+        hdr->gmv[i] = default_wm_params;
+
+    if (hdr->frame_type & 1) {
+        for (int i = 0; i < 7; i++) {
+            hdr->gmv[i].type = !get_bits(gb, 1) ? WM_TYPE_IDENTITY :
+                                get_bits(gb, 1) ? WM_TYPE_ROT_ZOOM :
+                                get_bits(gb, 1) ? WM_TYPE_TRANSLATION :
+                                                  WM_TYPE_AFFINE;
+
+            if (hdr->gmv[i].type == WM_TYPE_IDENTITY) continue;
+
+            const WarpedMotionParams *const ref_gmv =
+                hdr->primary_ref_frame == PRIMARY_REF_NONE ? &default_wm_params :
+                &c->refs[hdr->refidx[hdr->primary_ref_frame]].gmv[i];
+            int32_t *const mat = hdr->gmv[i].matrix;
+            const int32_t *const ref_mat = ref_gmv->matrix;
+            int bits, shift;
+
+            if (hdr->gmv[i].type >= WM_TYPE_ROT_ZOOM) {
+                mat[2] = (1 << 16) + 2 *
+                    get_bits_subexp(gb, (ref_mat[2] - (1 << 16)) >> 1, 12);
+                mat[3] = 2 * get_bits_subexp(gb, ref_mat[3] >> 1, 12);
+
+                bits = 12;
+                shift = 10;
+            } else {
+                bits = 9 - !hdr->hp;
+                shift = 13 + !hdr->hp;
+            }
+
+            if (hdr->gmv[i].type == WM_TYPE_AFFINE) {
+                mat[4] = 2 * get_bits_subexp(gb, ref_mat[4] >> 1, 12);
+                mat[5] = (1 << 16) + 2 *
+                    get_bits_subexp(gb, (ref_mat[5] - (1 << 16)) >> 1, 12);
+            } else {
+                mat[4] = -mat[3];
+                mat[5] = mat[2];
+            }
+
+            mat[0] = get_bits_subexp(gb, ref_mat[0] >> shift, bits) * (1 << shift);
+            mat[1] = get_bits_subexp(gb, ref_mat[1] >> shift, bits) * (1 << shift);
+
+            if (get_shear_params(&hdr->gmv[i]))
+                goto error;
+        }
+    }
+#if DEBUG_FRAME_HDR
+    printf("HDR: post-gmv: off=%ld\n",
+           (gb->ptr - init_ptr) * 8 - gb->bits_left);
+#endif
+
+    hdr->film_grain.present = seqhdr->film_grain_present && get_bits(gb, 1);
+    if (hdr->film_grain.present) {
+        hdr->film_grain.seed = get_bits(gb, 16);
+        hdr->film_grain.update = hdr->frame_type != INTER_FRAME || get_bits(gb, 1);
+        if (!hdr->film_grain.update) {
+            const int refidx = get_bits(gb, 3);
+            int i;
+            for (i = 0; i < 7; i++)
+                if (hdr->refidx[i] == refidx)
+                    break;
+            if (i == 7) goto error;
+            hdr->film_grain.data = c->refs[refidx].film_grain;
+        } else {
+            Av1FilmGrainData *const fgd = &hdr->film_grain.data;
+
+            fgd->num_y_points = get_bits(gb, 4);
+            if (fgd->num_y_points > 14) goto error;
+            for (int i = 0; i < fgd->num_y_points; i++) {
+                fgd->y_points[i][0] = get_bits(gb, 8);
+                if (i && fgd->y_points[i - 1][0] >= fgd->y_points[i][0])
+                    goto error;
+                fgd->y_points[i][1] = get_bits(gb, 8);
+            }
+
+            fgd->chroma_scaling_from_luma =
+                seqhdr->layout != DAV1D_PIXEL_LAYOUT_I400 && get_bits(gb, 1);
+            if (seqhdr->layout == DAV1D_PIXEL_LAYOUT_I400 ||
+                fgd->chroma_scaling_from_luma ||
+                (seqhdr->layout == DAV1D_PIXEL_LAYOUT_I420 && !fgd->num_y_points))
+            {
+                fgd->num_uv_points[0] = fgd->num_uv_points[1] = 0;
+            } else for (int pl = 0; pl < 2; pl++) {
+                fgd->num_uv_points[pl] = get_bits(gb, 4);
+                if (fgd->num_uv_points[pl] > 10) goto error;
+                for (int i = 0; i < fgd->num_uv_points[pl]; i++) {
+                    fgd->uv_points[pl][i][0] = get_bits(gb, 8);
+                    if (i && fgd->uv_points[pl][i - 1][0] >= fgd->uv_points[pl][i][0])
+                        goto error;
+                    fgd->uv_points[pl][i][1] = get_bits(gb, 8);
+                }
+            }
+
+            if (seqhdr->layout == DAV1D_PIXEL_LAYOUT_I420 &&
+                !!fgd->num_uv_points[0] != !!fgd->num_uv_points[1])
+            {
+                goto error;
+            }
+
+            fgd->scaling_shift = get_bits(gb, 2) + 8;
+            fgd->ar_coeff_lag = get_bits(gb, 2);
+            const int num_y_pos = 2 * fgd->ar_coeff_lag * (fgd->ar_coeff_lag + 1);
+            if (fgd->num_y_points)
+                for (int i = 0; i < num_y_pos; i++)
+                    fgd->ar_coeffs_y[i] = get_bits(gb, 8) - 128;
+            for (int pl = 0; pl < 2; pl++)
+                if (fgd->num_uv_points[pl] || fgd->chroma_scaling_from_luma) {
+                    const int num_uv_pos = num_y_pos + !!fgd->num_y_points;
+                    for (int i = 0; i < num_uv_pos; i++)
+                        fgd->ar_coeffs_uv[pl][i] = get_bits(gb, 8) - 128;
+                }
+            fgd->ar_coeff_shift = get_bits(gb, 2) + 6;
+            fgd->grain_scale_shift = get_bits(gb, 2);
+            for (int pl = 0; pl < 2; pl++)
+                if (fgd->num_uv_points[pl]) {
+                    fgd->uv_mult[pl] = get_bits(gb, 8);
+                    fgd->uv_luma_mult[pl] = get_bits(gb, 8);
+                    fgd->uv_offset[pl] = get_bits(gb, 9);
+                }
+            fgd->overlap_flag = get_bits(gb, 1);
+            fgd->clip_to_restricted_range = get_bits(gb, 1);
+        }
+    } else {
+        memset(&hdr->film_grain.data, 0, sizeof(hdr->film_grain));
+    }
+#if DEBUG_FRAME_HDR
+    printf("HDR: post-filmgrain: off=%ld\n",
+           (gb->ptr - init_ptr) * 8 - gb->bits_left);
+#endif
+
+end:
+
+    if (have_trailing_bit)
+        get_bits(gb, 1); // dummy bit
+
+    return flush_get_bits(gb) - init_ptr;
+
+error:
+    fprintf(stderr, "Error parsing frame header\n");
+    return -EINVAL;
+}
+
+static int parse_tile_hdr(Dav1dContext *const c, GetBits *const gb) {
+    const uint8_t *const init_ptr = gb->ptr;
+
+    int have_tile_pos = 0;
+    const int n_bits = c->frame_hdr.tiling.log2_cols +
+                       c->frame_hdr.tiling.log2_rows;
+    if (n_bits)
+        have_tile_pos = get_bits(gb, 1);
+
+    if (have_tile_pos) {
+        c->tile[c->n_tile_data].start = get_bits(gb, n_bits);
+        c->tile[c->n_tile_data].end = get_bits(gb, n_bits);
+    } else {
+        c->tile[c->n_tile_data].start = 0;
+        c->tile[c->n_tile_data].end = (1 << n_bits) - 1;
+    }
+
+    return flush_get_bits(gb) - init_ptr;
+}
+
+int parse_obus(Dav1dContext *const c, Dav1dData *const in) {
+    GetBits gb;
+    int res;
+
+    init_get_bits(&gb, in->data, in->sz);
+
+    // obu header
+    get_bits(&gb, 1); // obu_forbidden_bit
+    const enum ObuType type = get_bits(&gb, 4);
+    const int has_extension = get_bits(&gb, 1);
+    const int has_length_field = get_bits(&gb, 1);
+    if (!has_length_field) goto error;
+    get_bits(&gb, 1); // reserved
+    if (has_extension) {
+        get_bits(&gb, 3); // temporal_layer_id
+        get_bits(&gb, 2); // enhancement_layer_id
+        get_bits(&gb, 3); // reserved
+    }
+
+    // obu length field
+    int len = 0, more, i = 0;
+    do {
+        more = get_bits(&gb, 1);
+        len |= get_bits(&gb, 7) << (i * 7);
+        if (more && ++i == 8) goto error;
+    } while (more);
+    if (gb.error) goto error;
+
+    int off = flush_get_bits(&gb) - in->data;
+    const int init_off = off;
+    if (len > in->sz - off) goto error;
+
+    switch (type) {
+    case OBU_SEQ_HDR:
+        if ((res = parse_seq_hdr(c, &gb)) < 0)
+            return res;
+        if (res != len) goto error;
+        c->have_seq_hdr = 1;
+        c->have_frame_hdr = 0;
+        break;
+    case OBU_FRAME:
+    case OBU_FRAME_HDR:
+        if (!c->have_seq_hdr) goto error;
+        if ((res = parse_frame_hdr(c, &gb, type == OBU_FRAME_HDR)) < 0)
+            return res;
+        c->have_frame_hdr = 1;
+        for (int n = 0; n < c->n_tile_data; n++)
+            dav1d_data_unref(&c->tile[n].data);
+        c->n_tile_data = 0;
+        c->tile_mask = 0;
+        if (type == OBU_FRAME_HDR) break;
+        off += res;
+        // fall-through
+    case OBU_TILE_GRP:
+        if (!c->have_frame_hdr) goto error;
+        if (c->n_tile_data >= 256) goto error;
+        if ((res = parse_tile_hdr(c, &gb)) < 0)
+            return res;
+        off += res;
+        dav1d_ref_inc(in->ref);
+        c->tile[c->n_tile_data].data.ref = in->ref;
+        c->tile[c->n_tile_data].data.data = in->data + off;
+        c->tile[c->n_tile_data].data.sz = len + init_off - off;
+        if (c->tile[c->n_tile_data].start > c->tile[c->n_tile_data].end)
+            goto error;
+#define mask(a) ((1 << (a)) - 1)
+        const unsigned tile_mask = mask(c->tile[c->n_tile_data].end + 1) -
+                                   mask(c->tile[c->n_tile_data].start);
+#undef mask
+        if (tile_mask & c->tile_mask) goto error; // tile overlap
+        c->tile_mask |= tile_mask;
+        c->n_tile_data++;
+        break;
+    case OBU_PADDING:
+    case OBU_TD:
+    case OBU_METADATA:
+        // ignore OBUs we don't care about
+        break;
+    default:
+        fprintf(stderr, "Unknown OBU type %d of size %d\n", type, len);
+        return -EINVAL;
+    }
+
+    const int n_tiles = 1 << (c->frame_hdr.tiling.log2_cols +
+                              c->frame_hdr.tiling.log2_rows);
+    if (c->have_seq_hdr && c->have_frame_hdr &&
+        c->tile_mask == (1 << n_tiles) - 1)
+    {
+        assert(c->n_tile_data);
+        submit_frame(c);
+        assert(!c->n_tile_data);
+        c->have_frame_hdr = 0;
+        c->tile_mask = 0;
+    } else if (c->have_seq_hdr && c->have_frame_hdr &&
+               c->frame_hdr.show_existing_frame)
+    {
+        if (c->n_fc == 1) {
+            dav1d_picture_ref(&c->out,
+                              &c->refs[c->frame_hdr.existing_frame_idx].p.p);
+        } else {
+            // need to append this to the frame output queue
+            const unsigned next = c->frame_thread.next++;
+            if (c->frame_thread.next == c->n_fc)
+                c->frame_thread.next = 0;
+
+            Dav1dFrameContext *const f = &c->fc[next];
+            pthread_mutex_lock(&f->frame_thread.td.lock);
+            while (f->n_tile_data > 0)
+                pthread_cond_wait(&f->frame_thread.td.cond,
+                                  &f->frame_thread.td.lock);
+            Dav1dThreadPicture *const out_delayed =
+                &c->frame_thread.out_delayed[next];
+            if (out_delayed->p.data[0]) {
+                if (out_delayed->visible)
+                    dav1d_picture_ref(&c->out, &out_delayed->p);
+                dav1d_thread_picture_unref(out_delayed);
+            }
+            dav1d_thread_picture_ref(out_delayed,
+                                     &c->refs[c->frame_hdr.existing_frame_idx].p);
+            out_delayed->visible = 1;
+            pthread_mutex_unlock(&f->frame_thread.td.lock);
+        }
+        c->have_frame_hdr = 0;
+    }
+
+    return len + init_off;
+
+error:
+    fprintf(stderr, "Error parsing OBU data\n");
+    return -EINVAL;
+}
diff --git a/src/obu.h b/src/obu.h
new file mode 100644
index 0000000..df476fc
--- /dev/null
+++ b/src/obu.h
@@ -0,0 +1,36 @@
+/*
+ * Copyright © 2018, VideoLAN and dav1d authors
+ * Copyright © 2018, Two Orioles, LLC
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright notice, this
+ *    list of conditions and the following disclaimer.
+ *
+ * 2. Redistributions in binary form must reproduce the above copyright notice,
+ *    this list of conditions and the following disclaimer in the documentation
+ *    and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
+ * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#ifndef __DAV1D_SRC_OBU_H__
+#define __DAV1D_SRC_OBU_H__
+
+#include "dav1d/data.h"
+#include "src/internal.h"
+
+int parse_obus(Dav1dContext *c, Dav1dData *in);
+
+#endif /* __DAV1D_SRC_OBU_H__ */
diff --git a/src/picture.c b/src/picture.c
new file mode 100644
index 0000000..dccfd40
--- /dev/null
+++ b/src/picture.c
@@ -0,0 +1,187 @@
+/*
+ * Copyright © 2018, VideoLAN and dav1d authors
+ * Copyright © 2018, Two Orioles, LLC
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright notice, this
+ *    list of conditions and the following disclaimer.
+ *
+ * 2. Redistributions in binary form must reproduce the above copyright notice,
+ *    this list of conditions and the following disclaimer in the documentation
+ *    and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
+ * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#include "config.h"
+
+#include <assert.h>
+#include <errno.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include "common/intops.h"
+#include "common/mem.h"
+#include "common/validate.h"
+
+#include "src/picture.h"
+#include "src/ref.h"
+
+static int picture_alloc_with_edges(Dav1dPicture *const p,
+                                    const int w, const int h,
+                                    const enum Dav1dPixelLayout layout,
+                                    const int bpc,
+                                    const int extra, void **const extra_ptr)
+{
+    int aligned_h;
+
+    if (p->data[0]) {
+        fprintf(stderr, "Picture already allocated!\n");
+        return -1;
+    }
+    assert(bpc > 0 && bpc <= 16);
+
+    const int hbd = bpc > 8;
+    const int aligned_w = (w + 127) & ~127;
+    const int has_chroma = layout != DAV1D_PIXEL_LAYOUT_I400;
+    const int ss_ver = layout == DAV1D_PIXEL_LAYOUT_I420;
+    const int ss_hor = layout != DAV1D_PIXEL_LAYOUT_I444;
+    p->stride[0] = aligned_w << hbd;
+    p->stride[1] = has_chroma ? (aligned_w >> ss_hor) << hbd : 0;
+    p->p.w = w;
+    p->p.h = h;
+    p->p.pri = DAV1D_COLOR_PRI_UNKNOWN;
+    p->p.trc = DAV1D_TRC_UNKNOWN;
+    p->p.mtrx = DAV1D_MC_UNKNOWN;
+    p->p.chr = DAV1D_CHR_UNKNOWN;
+    aligned_h = (h + 127) & ~127;
+    p->p.layout = layout;
+    p->p.bpc = bpc;
+    const size_t y_sz = p->stride[0] * aligned_h;
+    const size_t uv_sz = p->stride[1] * (aligned_h >> ss_ver);
+    if (!(p->ref = dav1d_ref_create(y_sz + 2 * uv_sz + extra))) {
+        fprintf(stderr, "Failed to allocate memory of size %zu: %s\n",
+                y_sz + 2 * uv_sz + extra, strerror(errno));
+        return -ENOMEM;
+    }
+    uint8_t *data = p->ref->data;
+    p->data[0] = data;
+    p->data[1] = has_chroma ? data + y_sz : NULL;
+    p->data[2] = has_chroma ? data + y_sz + uv_sz : NULL;
+
+    if (extra)
+        *extra_ptr = &data[y_sz + uv_sz * 2];
+
+    return 0;
+}
+
+int dav1d_thread_picture_alloc(Dav1dThreadPicture *const p,
+                               const int w, const int h,
+                               const enum Dav1dPixelLayout layout, const int bpc,
+                               struct thread_data *const t, const int visible)
+{
+    p->t = t;
+
+    const int res =
+        picture_alloc_with_edges(&p->p, w, h, layout, bpc,
+                                 t != NULL ? sizeof(atomic_int) * 2 : 0,
+                                 (void **) &p->progress);
+
+    p->visible = visible;
+    if (t) {
+        atomic_init(&p->progress[0], 0);
+        atomic_init(&p->progress[1], 0);
+    }
+    return res;
+}
+
+void dav1d_picture_ref(Dav1dPicture *const dst, const Dav1dPicture *const src) {
+    validate_input(dst != NULL);
+    validate_input(dst->data[0] == NULL);
+    validate_input(src != NULL);
+
+    if (src->ref) {
+        validate_input(src->data[0] != NULL);
+        dav1d_ref_inc(src->ref);
+    }
+    *dst = *src;
+}
+
+void dav1d_thread_picture_ref(Dav1dThreadPicture *dst,
+                              const Dav1dThreadPicture *src)
+{
+    dav1d_picture_ref(&dst->p, &src->p);
+    dst->t = src->t;
+    dst->visible = src->visible;
+    dst->progress = src->progress;
+}
+
+void dav1d_picture_unref(Dav1dPicture *const p) {
+    validate_input(p != NULL);
+
+    if (p->ref) {
+        validate_input(p->data[0] != NULL);
+        dav1d_ref_dec(p->ref);
+    }
+    memset(p, 0, sizeof(*p));
+}
+
+void dav1d_thread_picture_unref(Dav1dThreadPicture *const p) {
+    dav1d_picture_unref(&p->p);
+
+    p->t = NULL;
+    p->progress = NULL;
+}
+
+void dav1d_thread_picture_wait(const Dav1dThreadPicture *const p,
+                               int y_unclipped, const enum PlaneType plane_type)
+{
+    assert(plane_type != PLANE_TYPE_ALL);
+
+    if (!p->t)
+        return;
+
+    // convert to luma units; include plane delay from loopfilters; clip
+    const int ss_ver = p->p.p.layout != DAV1D_PIXEL_LAYOUT_I444;
+    y_unclipped <<= plane_type & ss_ver; // we rely here on PLANE_TYPE_UV being 1
+    y_unclipped += (plane_type != PLANE_TYPE_BLOCK) * 8; // delay imposed by loopfilter
+    const int y = iclip(y_unclipped, 0, p->p.p.h - 1);
+    atomic_uint *const progress = &p->progress[plane_type != PLANE_TYPE_BLOCK];
+
+    if (atomic_load_explicit(progress, memory_order_acquire) >= y)
+        return;
+
+    pthread_mutex_lock(&p->t->lock);
+    while (atomic_load_explicit(progress, memory_order_relaxed) < y)
+        pthread_cond_wait(&p->t->cond, &p->t->lock);
+    pthread_mutex_unlock(&p->t->lock);
+}
+
+void dav1d_thread_picture_signal(const Dav1dThreadPicture *const p,
+                                 const int y, // in pixel units
+                                 const enum PlaneType plane_type)
+{
+    assert(plane_type != PLANE_TYPE_UV);
+
+    if (!p->t)
+        return;
+
+    pthread_mutex_lock(&p->t->lock);
+    if (plane_type != PLANE_TYPE_Y) atomic_store(&p->progress[0], y);
+    if (plane_type != PLANE_TYPE_BLOCK) atomic_store(&p->progress[1], y);
+    pthread_cond_broadcast(&p->t->cond);
+    pthread_mutex_unlock(&p->t->lock);
+}
diff --git a/src/picture.h b/src/picture.h
new file mode 100644
index 0000000..051d4cf
--- /dev/null
+++ b/src/picture.h
@@ -0,0 +1,91 @@
+/*
+ * Copyright © 2018, VideoLAN and dav1d authors
+ * Copyright © 2018, Two Orioles, LLC
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright notice, this
+ *    list of conditions and the following disclaimer.
+ *
+ * 2. Redistributions in binary form must reproduce the above copyright notice,
+ *    this list of conditions and the following disclaimer in the documentation
+ *    and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
+ * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#ifndef __DAV1D_SRC_PICTURE_H__
+#define __DAV1D_SRC_PICTURE_H__
+
+#include <pthread.h>
+#include <stdatomic.h>
+
+#include "dav1d/picture.h"
+
+#include "src/thread_data.h"
+
+enum PlaneType {
+    PLANE_TYPE_Y,
+    PLANE_TYPE_UV,
+    PLANE_TYPE_BLOCK,
+    PLANE_TYPE_ALL,
+};
+
+typedef struct Dav1dThreadPicture {
+    Dav1dPicture p;
+    int visible;
+    struct thread_data *t;
+    // [0] block data (including segmentation map and motion vectors)
+    // [1] pixel data
+    atomic_uint *progress;
+} Dav1dThreadPicture;
+
+/*
+ * Allocate a picture with custom border size.
+ */
+int dav1d_thread_picture_alloc(Dav1dThreadPicture *p, int w, int h,
+                               enum Dav1dPixelLayout layout, int bpc,
+                               struct thread_data *t, int visible);
+
+/**
+ * Create a copy of a picture.
+ */
+void dav1d_picture_ref(Dav1dPicture *dst, const Dav1dPicture *src);
+void dav1d_thread_picture_ref(Dav1dThreadPicture *dst,
+                              const Dav1dThreadPicture *src);
+void dav1d_thread_picture_unref(Dav1dThreadPicture *p);
+
+/**
+ * Wait for picture to reach a certain stage.
+ *
+ * y is in full-pixel units. If pt is not UV, this is in luma
+ * units, else it is in chroma units.
+ * plane_type is used to determine how many pixels delay are
+ * introduced by loopfilter processes.
+ */
+void dav1d_thread_picture_wait(const Dav1dThreadPicture *p, int y,
+                               enum PlaneType plane_type);
+
+/**
+ * Signal decoding progress.
+ *
+ * y is in full-pixel luma units.
+ * plane_type denotes whether we have completed block data (pass 1;
+ * PLANE_TYPE_BLOCK), pixel data (pass 2, PLANE_TYPE_Y) or both (no
+ * 2-pass decoding; PLANE_TYPE_ALL).
+ */
+void dav1d_thread_picture_signal(const Dav1dThreadPicture *p, int y,
+                                 enum PlaneType plane_type);
+
+#endif /* __DAV1D_SRC_PICTURE_H__ */
diff --git a/src/qm.c b/src/qm.c
new file mode 100644
index 0000000..51e129c
--- /dev/null
+++ b/src/qm.c
@@ -0,0 +1,3152 @@
+/*
+ * Copyright © 2018, VideoLAN and dav1d authors
+ * Copyright © 2018, Two Orioles, LLC
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright notice, this
+ *    list of conditions and the following disclaimer.
+ *
+ * 2. Redistributions in binary form must reproduce the above copyright notice,
+ *    this list of conditions and the following disclaimer in the documentation
+ *    and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
+ * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#include "config.h"
+
+#include <string.h>
+
+#include "src/qm.h"
+
+static const uint8_t qm_tbl_4x4_t[][2][10] = {
+    {
+        {
+             32,
+             43,  67,
+             73,  94, 137,
+             97, 110, 150, 200,
+        }, {
+             35,
+             46,  60,
+             57,  69,  90,
+             66,  71,  90, 109,
+        },
+    }, {
+        {
+             32,
+             41,  63,
+             69,  88, 127,
+             92, 103, 140, 184,
+        }, {
+             33,
+             45,  58,
+             56,  66,  86,
+             64,  69,  87, 105,
+        },
+    }, {
+        {
+             32,
+             38,  56,
+             63,  78, 113,
+             86,  97, 130, 169,
+        }, {
+             32,
+             45,  55,
+             53,  62,  80,
+             63,  67,  84, 101,
+        },
+    }, {
+        {
+             32,
+             37,  54,
+             58,  72, 102,
+             81,  91, 121, 156,
+        }, {
+             32,
+             45,  54,
+             51,  59,  75,
+             61,  65,  81,  97,
+        },
+    }, {
+        {
+             32,
+             34,  49,
+             53,  64,  91,
+             75,  81, 112, 140,
+        }, {
+             32,
+             46,  53,
+             49,  55,  70,
+             58,  62,  78,  91,
+        },
+    }, {
+        {
+             32,
+             34,  48,
+             49,  60,  82,
+             72,  79, 104, 134,
+        }, {
+             32,
+             46,  53,
+             47,  54,  66,
+             57,  60,  75,  89,
+        },
+    }, {
+        {
+             32,
+             33,  39,
+             45,  51,  71,
+             62,  64,  87, 108,
+        }, {
+             31,
+             42,  48,
+             47,  50,  61,
+             53,  54,  67,  78,
+        },
+    }, {
+        {
+             32,
+             33,  38,
+             42,  46,  63,
+             55,  57,  75,  92,
+        }, {
+             31,
+             41,  48,
+             46,  48,  58,
+             51,  51,  62,  71,
+        },
+    }, {
+        {
+             32,
+             32,  35,
+             38,  40,  54,
+             51,  49,  64,  81,
+        }, {
+             31,
+             38,  47,
+             47,  46,  54,
+             49,  46,  57,  66,
+        },
+    }, {
+        {
+             32,
+             32,  34,
+             35,  37,  48,
+             43,  43,  54,  65,
+        }, {
+             31,
+             37,  44,
+             47,  47,  53,
+             47,  45,  53,  59,
+        },
+    }, {
+        {
+             32,
+             32,  33,
+             34,  35,  39,
+             38,  39,  45,  54,
+        }, {
+             31,
+             34,  39,
+             42,  45,  48,
+             47,  46,  49,  54,
+        },
+    }, {
+        {
+             32,
+             32,  32,
+             32,  33,  35,
+             35,  35,  38,  46,
+        }, {
+             31,
+             32,  34,
+             38,  41,  47,
+             46,  46,  47,  52,
+        },
+    }, {
+        {
+             31,
+             32,  32,
+             32,  32,  33,
+             32,  33,  34,  35,
+        }, {
+             31,
+             31,  32,
+             34,  35,  39,
+             38,  40,  43,  47,
+        },
+    }, {
+        {
+             31,
+             31,  32,
+             31,  32,  32,
+             32,  32,  32,  33,
+        }, {
+             31,
+             31,  31,
+             31,  31,  32,
+             34,  35,  35,  39,
+        },
+    }, {
+        {
+             31,
+             31,  32,
+             31,  32,  32,
+             31,  32,  32,  32,
+        }, {
+             31,
+             31,  31,
+             31,  31,  31,
+             31,  31,  31,  31,
+        },
+    },
+};
+
+static const uint8_t qm_tbl_8x4[][2][32] = {
+    {
+        {
+             32,  33,  37,  49,  65,  80,  91, 104,
+             42,  42,  58,  71,  84,  97, 100, 112,
+             75,  69,  84, 103, 125, 142, 145, 146,
+             91,  86,  91, 110, 128, 152, 178, 190,
+        }, {
+             31,  40,  46,  48,  54,  61,  64,  68,
+             47,  45,  56,  61,  65,  69,  68,  71,
+             60,  54,  64,  75,  85,  92,  90,  87,
+             66,  61,  64,  73,  82,  92, 102, 105,
+        },
+    }, {
+        {
+             32,  33,  36,  46,  60,  75,  86,  98,
+             42,  42,  56,  67,  79,  92,  95, 105,
+             69,  64,  77,  93, 112, 130, 136, 136,
+             88,  83,  88, 105, 122, 144, 167, 177,
+        }, {
+             31,  40,  46,  47,  52,  59,  63,  66,
+             47,  45,  55,  60,  64,  68,  66,  69,
+             57,  52,  61,  70,  79,  87,  88,  85,
+             65,  61,  63,  72,  81,  90,  99, 102,
+        },
+    }, {
+        {
+             32,  32,  34,  44,  54,  72,  82,  92,
+             38,  40,  51,  61,  69,  84,  89,  98,
+             62,  58,  68,  85,  98, 118, 129, 127,
+             86,  80,  85, 101, 117, 136, 157, 165,
+        }, {
+             31,  38,  46,  46,  50,  57,  61,  65,
+             47,  46,  53,  56,  59,  64,  65,  67,
+             54,  50,  57,  66,  74,  82,  85,  82,
+             64,  60,  62,  71,  79,  88,  97,  99,
+        },
+    }, {
+        {
+             32,  32,  34,  41,  51,  65,  75,  86,
+             35,  36,  47,  53,  61,  73,  81,  92,
+             59,  57,  65,  78,  92, 108, 117, 119,
+             83,  78,  82,  97, 111, 129, 148, 154,
+        }, {
+             31,  36,  46,  45,  49,  54,  59,  63,
+             47,  47,  52,  53,  55,  58,  61,  65,
+             53,  50,  55,  63,  71,  77,  81,  80,
+             63,  59,  61,  70,  77,  86,  94,  95,
+        },
+    }, {
+        {
+             32,  32,  34,  38,  48,  60,  72,  81,
+             35,  36,  42,  51,  59,  68,  79,  86,
+             51,  50,  54,  67,  80,  92, 104, 112,
+             77,  72,  75,  87, 103, 119, 135, 144,
+        }, {
+             31,  36,  43,  45,  47,  52,  57,  61,
+             47,  47,  50,  53,  54,  56,  60,  63,
+             50,  47,  50,  58,  66,  70,  75,  77,
+             61,  57,  58,  65,  74,  82,  90,  93,
+        },
+    }, {
+        {
+             32,  32,  34,  37,  45,  54,  65,  75,
+             35,  36,  42,  50,  56,  63,  73,  81,
+             51,  50,  54,  65,  76,  87,  97, 106,
+             75,  71,  73,  84,  96, 110, 125, 136,
+        }, {
+             31,  36,  43,  46,  46,  50,  54,  59,
+             47,  47,  50,  53,  54,  55,  58,  61,
+             50,  47,  50,  57,  64,  68,  72,  75,
+             60,  56,  57,  64,  71,  78,  85,  90,
+        },
+    }, {
+        {
+             32,  32,  33,  35,  41,  49,  57,  66,
+             34,  34,  37,  43,  48,  54,  60,  68,
+             43,  42,  44,  54,  64,  71,  78,  86,
+             62,  59,  58,  68,  79,  91, 101, 111,
+        }, {
+             31,  33,  40,  47,  45,  48,  51,  55,
+             42,  44,  47,  50,  49,  50,  52,  55,
+             47,  45,  46,  54,  59,  61,  63,  66,
+             54,  51,  50,  57,  64,  70,  75,  79,
+        },
+    }, {
+        {
+             32,  32,  32,  34,  38,  44,  50,  61,
+             32,  33,  35,  37,  40,  45,  50,  58,
+             42,  41,  42,  50,  58,  66,  71,  79,
+             56,  53,  52,  59,  68,  78,  86,  97,
+        }, {
+             31,  32,  39,  44,  46,  47,  48,  53,
+             38,  40,  47,  47,  47,  46,  47,  50,
+             47,  45,  45,  51,  56,  59,  61,  64,
+             52,  49,  48,  53,  58,  64,  68,  73,
+        },
+    }, {
+        {
+             32,  32,  32,  34,  35,  40,  46,  52,
+             32,  33,  34,  37,  38,  42,  46,  51,
+             37,  36,  38,  44,  49,  55,  59,  64,
+             52,  49,  49,  54,  60,  69,  76,  83,
+        }, {
+             31,  31,  36,  42,  47,  46,  48,  50,
+             38,  40,  44,  47,  48,  46,  46,  48,
+             47,  46,  47,  50,  53,  54,  55,  56,
+             50,  48,  47,  50,  54,  60,  64,  67,
+        },
+    }, {
+        {
+             31,  32,  32,  32,  34,  37,  42,  46,
+             32,  33,  34,  35,  37,  40,  43,  46,
+             35,  34,  36,  38,  43,  49,  53,  56,
+             43,  41,  42,  42,  49,  56,  63,  67,
+        }, {
+             31,  31,  35,  39,  43,  47,  46,  48,
+             38,  40,  43,  47,  47,  47,  46,  46,
+             47,  46,  47,  47,  50,  53,  53,  54,
+             48,  45,  46,  45,  50,  55,  58,  59,
+        },
+    }, {
+        {
+             31,  32,  32,  32,  33,  34,  37,  40,
+             32,  32,  33,  33,  34,  36,  38,  40,
+             34,  34,  34,  36,  38,  41,  44,  46,
+             39,  38,  38,  40,  42,  47,  52,  56,
+        }, {
+             31,  31,  33,  36,  40,  45,  47,  47,
+             34,  35,  37,  41,  44,  46,  47,  46,
+             42,  42,  44,  46,  48,  49,  50,  49,
+             48,  46,  46,  46,  48,  51,  54,  55,
+        },
+    }, {
+        {
+             31,  32,  32,  32,  32,  33,  34,  35,
+             31,  32,  32,  32,  33,  33,  34,  34,
+             32,  32,  33,  34,  35,  36,  37,  38,
+             35,  35,  34,  36,  38,  40,  42,  48,
+        }, {
+             31,  31,  31,  34,  37,  39,  42,  48,
+             31,  31,  32,  36,  39,  41,  43,  46,
+             37,  38,  40,  43,  46,  47,  47,  48,
+             48,  47,  46,  47,  47,  48,  50,  53,
+        },
+    }, {
+        {
+             31,  31,  32,  32,  32,  32,  32,  33,
+             31,  32,  32,  32,  32,  32,  33,  33,
+             32,  32,  32,  32,  33,  34,  34,  35,
+             32,  32,  32,  33,  34,  34,  35,  36,
+        }, {
+             31,  31,  31,  31,  34,  35,  38,  41,
+             31,  31,  32,  32,  36,  37,  40,  42,
+             35,  36,  37,  37,  40,  42,  45,  45,
+             37,  38,  39,  40,  43,  44,  47,  47,
+        },
+    }, {
+        {
+             31,  31,  31,  31,  31,  31,  32,  32,
+             31,  32,  32,  32,  32,  32,  32,  32,
+             31,  32,  32,  32,  32,  32,  32,  32,
+             32,  32,  32,  32,  32,  33,  33,  33,
+        }, {
+             31,  31,  31,  31,  31,  31,  34,  34,
+             31,  31,  31,  32,  32,  33,  36,  36,
+             31,  31,  31,  32,  32,  33,  36,  36,
+             34,  35,  35,  36,  36,  37,  40,  40,
+        },
+    }, {
+        {
+             31,  31,  31,  31,  31,  31,  31,  31,
+             31,  31,  32,  32,  32,  32,  32,  32,
+             31,  31,  32,  32,  32,  32,  32,  32,
+             31,  31,  32,  32,  32,  32,  32,  32,
+        }, {
+             31,  31,  31,  31,  31,  31,  31,  30,
+             31,  31,  31,  31,  31,  31,  31,  31,
+             31,  31,  31,  31,  31,  31,  32,  32,
+             31,  31,  31,  31,  31,  31,  32,  32,
+        },
+    },
+};
+
+static const uint8_t qm_tbl_8x8_t[][2][36] = {
+    {
+        {
+             32,
+             32,  35,
+             38,  40,  54,
+             51,  49,  65,  82,
+             68,  63,  78,  97, 117,
+             84,  76,  91, 111, 134, 152,
+             95,  89,  98, 113, 138, 159, 183,
+            109, 102, 106, 121, 142, 168, 199, 220,
+        }, {
+             31,
+             38,  47,
+             47,  46,  54,
+             50,  47,  57,  66,
+             57,  52,  61,  72,  82,
+             63,  57,  66,  77,  88,  96,
+             67,  62,  67,  75,  86,  95, 104,
+             71,  67,  68,  75,  84,  95, 107, 113,
+        },
+    }, {
+        {
+             32,
+             32,  35,
+             37,  39,  51,
+             47,  46,  60,  73,
+             62,  58,  71,  87, 105,
+             78,  72,  84, 100, 121, 140,
+             90,  84,  93, 106, 129, 148, 169,
+            102,  96, 100, 113, 132, 155, 183, 201,
+        }, {
+             31,
+             38,  47,
+             47,  47,  53,
+             48,  46,  55,  62,
+             54,  50,  58,  67,  76,
+             61,  55,  63,  72,  83,  91,
+             66,  61,  65,  73,  84,  92, 101,
+             69,  65,  66,  73,  82,  92, 103, 109,
+        },
+    }, {
+        {
+             32,
+             32,  34,
+             35,  37,  48,
+             46,  45,  56,  70,
+             57,  54,  64,  80,  93,
+             76,  70,  79,  96, 111, 134,
+             85,  79,  87, 100, 121, 138, 156,
+             96,  90,  93, 105, 122, 144, 168, 184,
+        }, {
+             31,
+             36,  43,
+             47,  47,  53,
+             48,  46,  54,  61,
+             52,  49,  55,  65,  71,
+             60,  55,  60,  70,  78,  89,
+             64,  59,  63,  71,  81,  89,  97,
+             67,  63,  64,  71,  79,  89,  99, 104,
+        },
+    }, {
+        {
+             32,
+             32,  33,
+             35,  36,  46,
+             42,  42,  52,  63,
+             53,  51,  60,  73,  86,
+             68,  64,  72,  84, 100, 117,
+             78,  74,  80,  92, 109, 128, 140,
+             90,  84,  87,  98, 114, 133, 155, 168,
+        }, {
+             31,
+             34,  39,
+             46,  47,  52,
+             47,  45,  52,  58,
+             50,  48,  54,  62,  68,
+             57,  53,  58,  65,  73,  82,
+             61,  57,  61,  68,  77,  86,  91,
+             65,  61,  62,  68,  76,  86,  95, 100,
+        },
+    }, {
+        {
+             32,
+             32,  33,
+             34,  35,  39,
+             39,  40,  46,  56,
+             50,  48,  53,  65,  78,
+             62,  59,  63,  75,  90, 105,
+             76,  71,  74,  86, 101, 118, 134,
+             84,  79,  81,  92, 106, 123, 142, 153,
+        }, {
+             31,
+             34,  39,
+             42,  45,  48,
+             47,  46,  49,  55,
+             49,  47,  50,  58,  65,
+             54,  51,  53,  61,  69,  76,
+             60,  56,  57,  65,  73,  82,  89,
+             64,  59,  60,  66,  74,  83,  92,  96,
+        },
+    }, {
+        {
+             32,
+             32,  33,
+             34,  35,  39,
+             38,  39,  45,  54,
+             46,  45,  51,  61,  71,
+             56,  54,  58,  69,  80,  92,
+             68,  64,  68,  78,  90, 103, 117,
+             78,  74,  76,  86,  99, 113, 128, 140,
+        }, {
+             31,
+             34,  39,
+             42,  45,  48,
+             47,  46,  49,  54,
+             48,  46,  50,  56,  61,
+             52,  49,  52,  58,  65,  71,
+             57,  53,  55,  61,  68,  75,  82,
+             61,  57,  58,  64,  71,  79,  86,  91,
+        },
+    }, {
+        {
+             31,
+             32,  32,
+             32,  33,  35,
+             35,  35,  38,  48,
+             42,  41,  43,  54,  63,
+             51,  49,  49,  59,  71,  81,
+             59,  56,  56,  66,  77,  89,  98,
+             69,  65,  64,  73,  85,  97, 108, 119,
+        }, {
+             31,
+             32,  35,
+             38,  42,  47,
+             48,  47,  48,  53,
+             47,  45,  45,  53,  58,
+             50,  47,  47,  54,  61,  66,
+             53,  50,  49,  56,  63,  69,  73,
+             57,  54,  52,  58,  65,  72,  77,  82,
+        },
+    }, {
+        {
+             31,
+             32,  32,
+             32,  32,  35,
+             34,  34,  37,  42,
+             38,  37,  40,  47,  54,
+             46,  44,  45,  52,  60,  69,
+             52,  49,  49,  56,  65,  75,  82,
+             63,  59,  58,  65,  73,  84,  92, 105,
+        }, {
+             31,
+             31,  32,
+             38,  40,  47,
+             44,  44,  47,  50,
+             47,  45,  46,  51,  54,
+             48,  46,  46,  51,  56,  61,
+             50,  47,  47,  52,  57,  63,  66,
+             55,  52,  50,  54,  60,  66,  70,  76,
+        },
+    }, {
+        {
+             31,
+             32,  32,
+             32,  32,  34,
+             34,  33,  35,  39,
+             35,  34,  37,  42,  48,
+             41,  40,  41,  47,  53,  60,
+             47,  44,  45,  51,  57,  65,  71,
+             53,  50,  51,  55,  61,  70,  77,  85,
+        }, {
+             31,
+             31,  32,
+             35,  36,  41,
+             42,  42,  45,  48,
+             48,  46,  47,  50,  53,
+             47,  45,  45,  49,  53,  57,
+             49,  46,  46,  50,  54,  59,  61,
+             51,  48,  48,  51,  54,  60,  64,  68,
+        },
+    }, {
+        {
+             31,
+             31,  32,
+             32,  32,  33,
+             32,  32,  34,  35,
+             34,  34,  35,  37,  41,
+             37,  36,  38,  39,  45,  51,
+             43,  41,  42,  42,  49,  56,  63,
+             47,  44,  45,  46,  52,  59,  67,  71,
+        }, {
+             31,
+             31,  32,
+             34,  35,  39,
+             37,  40,  43,  47,
+             43,  43,  45,  47,  49,
+             48,  46,  46,  47,  50,  53,
+             47,  45,  45,  45,  50,  55,  58,
+             49,  46,  46,  46,  50,  55,  60,  61,
+        },
+    }, {
+        {
+             31,
+             31,  32,
+             32,  32,  32,
+             32,  32,  33,  34,
+             33,  33,  34,  35,  37,
+             34,  34,  35,  36,  39,  43,
+             37,  36,  37,  38,  41,  46,  51,
+             41,  39,  40,  41,  44,  49,  54,  58,
+        }, {
+             31,
+             31,  31,
+             32,  33,  35,
+             35,  37,  39,  43,
+             39,  41,  42,  45,  47,
+             45,  44,  45,  47,  48,  50,
+             48,  46,  46,  47,  48,  51,  53,
+             48,  46,  45,  46,  47,  51,  54,  56,
+        },
+    }, {
+        {
+             31,
+             31,  32,
+             31,  32,  32,
+             32,  32,  32,  33,
+             32,  32,  32,  34,  35,
+             32,  33,  33,  34,  35,  36,
+             34,  34,  33,  35,  36,  38,  39,
+             35,  35,  34,  36,  38,  40,  42,  48,
+        }, {
+             31,
+             31,  31,
+             30,  31,  32,
+             34,  34,  35,  39,
+             36,  37,  39,  42,  46,
+             39,  40,  41,  44,  47,  47,
+             42,  42,  42,  45,  47,  48,  48,
+             48,  47,  46,  47,  47,  49,  50,  53,
+        },
+    }, {
+        {
+             31,
+             31,  32,
+             31,  32,  32,
+             31,  32,  32,  32,
+             32,  32,  32,  32,  33,
+             32,  32,  32,  32,  33,  34,
+             32,  32,  32,  32,  34,  34,  35,
+             33,  33,  33,  33,  35,  35,  36,  38,
+        }, {
+             31,
+             31,  31,
+             31,  31,  31,
+             30,  31,  31,  32,
+             34,  34,  35,  35,  39,
+             35,  35,  36,  36,  40,  41,
+             37,  38,  39,  40,  43,  44,  47,
+             40,  41,  41,  42,  44,  45,  47,  48,
+        },
+    }, {
+        {
+             31,
+             31,  32,
+             31,  32,  32,
+             31,  32,  32,  32,
+             31,  32,  32,  32,  32,
+             31,  32,  32,  32,  32,  32,
+             32,  32,  32,  32,  32,  32,  33,
+             32,  32,  32,  32,  32,  32,  33,  33,
+        }, {
+             31,
+             31,  31,
+             31,  31,  31,
+             31,  31,  31,  31,
+             30,  31,  31,  31,  32,
+             31,  32,  32,  32,  32,  33,
+             33,  34,  34,  35,  35,  36,  39,
+             33,  34,  34,  35,  35,  36,  39,  39,
+        },
+    }, {
+        {
+             31,
+             31,  31,
+             31,  31,  31,
+             31,  31,  32,  32,
+             31,  31,  32,  32,  32,
+             31,  31,  32,  32,  32,  32,
+             31,  31,  32,  32,  32,  32,  32,
+             31,  31,  32,  32,  32,  32,  32,  32,
+        }, {
+             31,
+             31,  31,
+             31,  31,  31,
+             31,  31,  31,  31,
+             31,  31,  31,  31,  31,
+             31,  31,  31,  31,  31,  31,
+             31,  31,  31,  31,  31,  31,  31,
+             30,  31,  31,  31,  31,  31,  31,  31,
+        },
+    },
+};
+
+static const uint8_t qm_tbl_16x4[][2][64] = {
+    {
+        {
+             31,  32,  32,  34,  34,  41,  45,  54,  60,  72,  75,  83,  88,  94, 101, 108,
+             44,  41,  42,  48,  54,  63,  67,  75,  79,  90,  92, 100, 100, 101, 108, 115,
+             79,  72,  71,  73,  78,  90,  96, 110, 118, 133, 136, 142, 140, 144, 141, 151,
+             96,  90,  86,  83,  89,  95, 102, 111, 123, 135, 149, 160, 173, 180, 188, 197,
+        }, {
+             31,  32,  36,  43,  46,  45,  46,  50,  52,  57,  59,  62,  63,  65,  67,  69,
+             49,  45,  46,  49,  53,  58,  59,  62,  64,  67,  68,  71,  69,  68,  70,  72,
+             63,  57,  56,  57,  60,  67,  71,  78,  82,  89,  90,  91,  89,  89,  86,  88,
+             69,  65,  62,  60,  63,  66,  70,  74,  80,  85,  91,  96, 101, 103, 105, 107,
+        },
+    }, {
+        {
+             31,  32,  32,  33,  34,  37,  44,  49,  56,  65,  72,  78,  84,  89,  95, 101,
+             44,  41,  42,  44,  54,  58,  66,  71,  77,  84,  90,  95,  95,  95, 101, 108,
+             73,  67,  65,  66,  74,  79,  90,  99, 107, 119, 127, 133, 132, 136, 132, 141,
+             93,  87,  83,  81,  86,  92,  98, 107, 117, 129, 141, 151, 163, 169, 175, 183,
+        }, {
+             31,  32,  36,  41,  46,  46,  46,  48,  51,  54,  57,  60,  62,  64,  65,  67,
+             49,  45,  46,  47,  53,  56,  59,  61,  63,  65,  67,  69,  67,  66,  68,  70,
+             61,  55,  54,  54,  59,  62,  68,  73,  77,  82,  86,  88,  86,  87,  83,  86,
+             69,  64,  61,  59,  62,  65,  68,  73,  78,  84,  89,  93,  98, 100, 102, 103,
+        },
+    }, {
+        {
+             31,  32,  32,  33,  34,  37,  41,  46,  53,  60,  65,  74,  79,  84,  89,  94,
+             39,  38,  39,  40,  47,  54,  58,  62,  68,  73,  78,  85,  90,  90,  95, 101,
+             65,  60,  59,  58,  65,  73,  79,  86,  97, 105, 111, 120, 125, 128, 124, 131,
+             90,  84,  81,  78,  83,  89,  94, 102, 112, 123, 134, 143, 154, 158, 164, 170,
+        }, {
+             31,  32,  36,  40,  44,  46,  45,  47,  49,  52,  54,  58,  60,  62,  64,  65,
+             48,  46,  46,  46,  51,  54,  56,  57,  58,  60,  62,  64,  66,  64,  66,  68,
+             57,  53,  51,  50,  54,  60,  64,  68,  73,  76,  79,  82,  84,  84,  81,  83,
+             68,  63,  60,  58,  61,  64,  67,  71,  77,  82,  87,  91,  95,  97,  99, 100,
+        },
+    }, {
+        {
+             31,  32,  32,  33,  34,  34,  39,  44,  49,  54,  60,  68,  75,  79,  84,  88,
+             36,  35,  36,  38,  42,  48,  51,  56,  60,  63,  68,  75,  81,  85,  89,  94,
+             62,  58,  57,  56,  61,  66,  74,  82,  90,  95, 102, 110, 117, 120, 116, 123,
+             88,  82,  79,  76,  81,  85,  91,  98, 107, 117, 127, 135, 145, 148, 153, 159,
+        }, {
+             31,  32,  35,  40,  43,  46,  45,  46,  48,  50,  52,  56,  58,  60,  62,  63,
+             48,  46,  47,  47,  50,  53,  53,  54,  54,  55,  56,  59,  61,  63,  64,  66,
+             56,  52,  50,  49,  53,  56,  61,  65,  70,  72,  75,  79,  81,  82,  79,  81,
+             67,  62,  60,  57,  60,  63,  66,  70,  75,  80,  85,  89,  93,  94,  96,  97,
+        },
+    }, {
+        {
+             31,  32,  32,  32,  33,  34,  37,  41,  45,  49,  54,  61,  68,  74,  78,  83,
+             36,  35,  35,  37,  41,  48,  50,  53,  56,  60,  63,  69,  75,  80,  84,  88,
+             53,  51,  49,  49,  53,  60,  65,  71,  76,  82,  87,  93, 100, 105, 109, 114,
+             81,  76,  73,  71,  74,  80,  85,  91,  98, 105, 112, 121, 130, 137, 142, 148,
+        }, {
+             31,  31,  33,  38,  42,  46,  46,  45,  46,  48,  50,  52,  56,  58,  60,  62,
+             48,  47,  46,  47,  49,  53,  53,  53,  54,  54,  55,  57,  59,  61,  62,  64,
+             52,  49,  48,  47,  50,  54,  57,  61,  64,  66,  68,  71,  73,  75,  76,  78,
+             64,  60,  57,  56,  57,  61,  64,  68,  71,  75,  78,  83,  87,  90,  92,  94,
+        },
+    }, {
+        {
+             31,  32,  32,  32,  33,  34,  34,  37,  41,  45,  49,  54,  60,  65,  72,  75,
+             36,  35,  34,  36,  38,  42,  48,  50,  53,  56,  60,  63,  68,  73,  79,  81,
+             53,  51,  49,  50,  49,  54,  60,  65,  71,  76,  82,  87,  92,  97, 104, 106,
+             79,  75,  72,  71,  69,  73,  78,  84,  90,  96, 103, 110, 118, 125, 133, 136,
+        }, {
+             31,  31,  32,  36,  40,  43,  46,  46,  45,  46,  48,  50,  52,  54,  57,  59,
+             48,  47,  46,  47,  47,  50,  53,  53,  53,  54,  54,  55,  56,  58,  60,  61,
+             52,  50,  48,  47,  47,  50,  54,  57,  61,  64,  66,  68,  70,  72,  75,  75,
+             63,  60,  57,  56,  54,  57,  60,  64,  67,  71,  75,  78,  82,  85,  89,  90,
+        },
+    }, {
+        {
+             31,  32,  32,  32,  32,  34,  34,  36,  39,  42,  45,  50,  54,  60,  66,  73,
+             34,  34,  33,  35,  37,  39,  42,  44,  46,  48,  51,  54,  58,  63,  68,  74,
+             44,  43,  41,  43,  43,  48,  53,  57,  60,  64,  67,  72,  76,  80,  85,  91,
+             65,  62,  59,  59,  58,  63,  67,  71,  76,  81,  85,  92,  98, 105, 111, 118,
+        }, {
+             31,  31,  32,  35,  40,  43,  46,  46,  46,  46,  47,  48,  50,  52,  55,  58,
+             42,  42,  42,  45,  47,  48,  50,  50,  49,  49,  50,  50,  52,  53,  55,  58,
+             49,  47,  45,  46,  46,  49,  53,  55,  57,  59,  60,  61,  63,  64,  66,  68,
+             57,  54,  52,  51,  50,  53,  56,  58,  61,  64,  67,  71,  73,  76,  79,  82,
+        },
+    }, {
+        {
+             31,  32,  32,  32,  32,  32,  34,  35,  37,  39,  41,  45,  50,  54,  57,  61,
+             32,  32,  33,  34,  34,  35,  37,  38,  40,  41,  43,  46,  50,  53,  56,  58,
+             44,  42,  41,  42,  42,  42,  48,  54,  57,  60,  63,  67,  71,  74,  77,  79,
+             58,  55,  53,  53,  53,  52,  57,  63,  67,  70,  74,  79,  86,  90,  93,  97,
+        }, {
+             31,  31,  32,  34,  37,  39,  42,  47,  46,  46,  46,  47,  48,  50,  51,  53,
+             37,  38,  40,  42,  44,  47,  47,  48,  47,  46,  46,  46,  47,  48,  49,  50,
+             49,  47,  45,  45,  45,  45,  49,  53,  55,  57,  58,  59,  61,  62,  63,  64,
+             54,  51,  49,  49,  48,  48,  51,  55,  58,  60,  62,  65,  68,  70,  71,  73,
+        },
+    }, {
+        {
+             31,  32,  32,  32,  32,  32,  33,  34,  35,  37,  38,  42,  45,  47,  51,  55,
+             32,  32,  32,  33,  34,  35,  36,  37,  38,  40,  40,  43,  45,  47,  50,  54,
+             38,  37,  36,  36,  38,  39,  41,  44,  49,  51,  52,  56,  58,  60,  63,  67,
+             53,  51,  49,  49,  50,  49,  51,  54,  60,  63,  65,  71,  75,  77,  82,  87,
+        }, {
+             31,  31,  31,  32,  35,  39,  40,  42,  47,  47,  46,  46,  47,  48,  49,  51,
+             37,  38,  39,  40,  43,  47,  47,  47,  48,  47,  47,  46,  46,  47,  47,  49,
+             48,  47,  46,  46,  46,  47,  48,  50,  53,  53,  54,  55,  55,  55,  56,  57,
+             52,  50,  48,  48,  47,  47,  48,  50,  54,  56,  57,  61,  63,  64,  66,  68,
+        },
+    }, {
+        {
+             31,  32,  32,  32,  32,  32,  32,  33,  34,  35,  35,  38,  40,  42,  45,  46,
+             32,  32,  32,  33,  34,  34,  35,  36,  37,  38,  38,  40,  41,  43,  45,  46,
+             36,  35,  35,  34,  36,  36,  38,  40,  42,  47,  48,  50,  51,  53,  56,  56,
+             44,  42,  41,  41,  42,  42,  42,  44,  48,  52,  54,  58,  60,  63,  66,  67,
+        }, {
+             31,  31,  31,  31,  34,  35,  39,  40,  42,  46,  47,  47,  47,  46,  48,  48,
+             37,  38,  39,  40,  42,  43,  47,  47,  47,  48,  48,  47,  46,  46,  46,  46,
+             48,  47,  46,  46,  47,  47,  47,  48,  50,  52,  53,  53,  53,  53,  54,  54,
+             49,  47,  46,  45,  45,  46,  45,  47,  49,  53,  53,  56,  57,  58,  59,  59,
+        },
+    }, {
+        {
+             31,  32,  32,  32,  32,  32,  32,  32,  32,  34,  34,  35,  35,  38,  38,  42,
+             32,  32,  32,  32,  32,  33,  33,  34,  34,  35,  35,  36,  36,  39,  39,  42,
+             34,  34,  34,  33,  33,  35,  35,  37,  37,  39,  39,  43,  43,  45,  45,  48,
+             39,  38,  38,  37,  37,  39,  39,  40,  40,  45,  45,  51,  51,  54,  54,  58,
+        }, {
+             31,  31,  31,  31,  31,  34,  34,  38,  38,  42,  42,  48,  48,  47,  47,  47,
+             33,  34,  34,  35,  35,  39,  39,  43,  43,  45,  45,  47,  47,  46,  46,  45,
+             42,  42,  42,  42,  42,  45,  45,  47,  47,  48,  48,  50,  50,  50,  50,  49,
+             48,  47,  47,  45,  45,  46,  46,  46,  46,  50,  50,  53,  53,  54,  54,  56,
+        },
+    }, {
+        {
+             31,  31,  32,  32,  32,  32,  32,  32,  32,  32,  32,  33,  34,  34,  35,  35,
+             31,  32,  32,  32,  32,  32,  32,  32,  32,  33,  33,  33,  34,  34,  34,  34,
+             32,  32,  32,  32,  33,  33,  34,  34,  34,  35,  35,  36,  37,  37,  38,  38,
+             36,  35,  35,  35,  34,  34,  36,  36,  37,  38,  38,  41,  42,  44,  48,  48,
+        }, {
+             31,  31,  31,  31,  31,  31,  34,  34,  36,  38,  38,  41,  42,  44,  48,  48,
+             31,  31,  31,  32,  32,  32,  35,  36,  37,  40,  40,  42,  43,  44,  46,  46,
+             37,  38,  38,  39,  40,  40,  42,  43,  44,  47,  47,  47,  47,  47,  48,  48,
+             48,  47,  47,  46,  46,  46,  47,  47,  47,  47,  47,  49,  50,  51,  53,  53,
+        },
+    }, {
+        {
+             31,  31,  31,  31,  31,  32,  32,  32,  32,  32,  32,  32,  32,  32,  33,  34,
+             31,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  33,  33,  33,  34,
+             32,  32,  32,  32,  32,  32,  32,  33,  33,  33,  33,  34,  34,  34,  35,  36,
+             32,  32,  32,  32,  32,  33,  33,  33,  34,  34,  34,  35,  35,  35,  36,  37,
+        }, {
+             31,  31,  31,  31,  31,  31,  31,  31,  33,  34,  34,  36,  38,  38,  39,  42,
+             31,  31,  31,  31,  32,  32,  32,  33,  35,  36,  36,  38,  40,  40,  41,  43,
+             35,  35,  36,  36,  36,  37,  37,  38,  40,  40,  40,  43,  45,  45,  45,  46,
+             37,  38,  38,  38,  39,  40,  40,  40,  42,  43,  43,  45,  47,  47,  47,  47,
+        },
+    }, {
+        {
+             31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  32,  32,  32,  32,  32,
+             31,  31,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,
+             31,  31,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,
+             32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  33,  33,  33,  33,  33,
+        }, {
+             31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  32,  33,  34,  34,  34,
+             31,  31,  31,  31,  31,  31,  32,  32,  32,  32,  32,  33,  35,  36,  36,  36,
+             31,  31,  31,  31,  31,  31,  32,  32,  32,  32,  32,  33,  35,  36,  36,  36,
+             34,  34,  35,  35,  35,  35,  36,  36,  36,  36,  36,  37,  39,  40,  40,  40,
+        },
+    }, {
+        {
+             31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,
+             31,  31,  31,  31,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,
+             31,  31,  31,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,
+             31,  31,  31,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,
+        }, {
+             31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  30,
+             31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,
+             31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  32,  32,  32,
+             31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  32,  32,  32,  32,
+        },
+    },
+};
+
+static const uint8_t qm_tbl_16x8[][2][128] = {
+    {
+        {
+             32,  31,  32,  34,  36,  44,  48,  58,  65,  79,  82,  91,  97, 103, 110, 118,
+             32,  33,  34,  37,  38,  43,  46,  54,  58,  70,  72,  80,  86,  93, 100, 107,
+             36,  34,  36,  42,  48,  53,  56,  63,  68,  79,  81,  88,  94,  98, 101, 105,
+             53,  49,  50,  54,  60,  71,  76,  87,  92, 104, 106, 106, 107, 114, 117, 118,
+             65,  59,  59,  63,  68,  79,  85,  98, 105, 118, 121, 130, 128, 131, 138, 136,
+             87,  78,  77,  79,  84,  95, 102, 116, 124, 141, 144, 148, 157, 150, 161, 157,
+             93,  86,  82,  80,  86,  94, 105, 112, 122, 135, 149, 162, 167, 174, 183, 182,
+             99,  93,  89,  88,  90,  97, 105, 115, 124, 135, 146, 159, 171, 186, 193, 203,
+        }, {
+             32,  30,  33,  42,  49,  49,  50,  54,  57,  63,  64,  68,  70,  72,  74,  76,
+             37,  40,  43,  47,  48,  46,  46,  49,  50,  55,  56,  59,  62,  64,  67,  69,
+             48,  46,  47,  50,  53,  53,  54,  55,  56,  60,  61,  64,  66,  66,  66,  67,
+             52,  48,  47,  50,  54,  61,  64,  68,  70,  75,  75,  74,  73,  75,  74,  73,
+             57,  52,  51,  53,  57,  64,  67,  73,  76,  82,  83,  86,  83,  83,  84,  82,
+             66,  60,  59,  60,  62,  69,  73,  80,  84,  92,  93,  94,  96,  92,  94,  91,
+             68,  63,  60,  59,  62,  66,  72,  76,  80,  87,  93,  98,  99, 101, 103, 101,
+             71,  66,  63,  62,  62,  66,  70,  75,  79,  84,  89,  94,  98, 104, 106, 109,
+        },
+    }, {
+        {
+             32,  31,  32,  32,  36,  39,  47,  53,  61,  71,  79,  86,  92,  98, 104, 110,
+             32,  32,  34,  35,  37,  40,  45,  50,  56,  64,  70,  76,  82,  88,  94, 100,
+             36,  35,  36,  40,  48,  50,  56,  60,  65,  73,  79,  84,  89,  93,  95,  98,
+             47,  44,  45,  47,  56,  60,  69,  75,  81,  89,  95, 100, 101, 108, 110, 111,
+             65,  60,  59,  60,  68,  73,  84,  92, 100, 111, 118, 124, 121, 124, 129, 127,
+             79,  72,  71,  71,  78,  84,  95, 103, 113, 125, 133, 140, 148, 141, 151, 147,
+             90,  84,  80,  78,  83,  91, 101, 108, 116, 129, 142, 153, 157, 163, 171, 169,
+             96,  90,  87,  85,  87,  94, 101, 110, 118, 129, 138, 150, 161, 174, 181, 188,
+        }, {
+             32,  30,  33,  39,  49,  48,  50,  52,  55,  60,  63,  66,  68,  70,  72,  74,
+             35,  38,  41,  46,  48,  46,  46,  47,  49,  53,  55,  58,  60,  62,  65,  67,
+             48,  46,  47,  48,  53,  53,  54,  54,  56,  58,  60,  62,  64,  65,  65,  65,
+             50,  46,  46,  47,  54,  56,  61,  63,  65,  68,  70,  72,  71,  73,  72,  71,
+             57,  52,  51,  51,  57,  60,  66,  71,  74,  79,  82,  84,  81,  81,  82,  79,
+             63,  58,  56,  55,  60,  64,  70,  75,  79,  85,  89,  91,  94,  89,  92,  89,
+             68,  63,  60,  58,  61,  65,  71,  75,  79,  85,  91,  95,  97,  98, 100,  98,
+             70,  65,  63,  61,  61,  65,  69,  74,  78,  82,  87,  91,  96, 101, 103, 105,
+        },
+    }, {
+        {
+             32,  31,  32,  32,  34,  39,  44,  49,  57,  65,  71,  81,  87,  92,  98, 103,
+             32,  32,  33,  34,  36,  39,  42,  46,  53,  59,  64,  72,  77,  83,  88,  94,
+             36,  35,  36,  38,  44,  50,  53,  57,  63,  68,  73,  80,  85,  88,  89,  92,
+             44,  41,  42,  42,  50,  58,  63,  67,  74,  79,  84,  91,  96, 102, 103, 103,
+             58,  54,  53,  52,  59,  68,  74,  81,  90,  97, 102, 110, 114, 117, 121, 119,
+             79,  73,  71,  69,  75,  84,  90,  97, 108, 118, 125, 135, 140, 133, 141, 137,
+             88,  81,  78,  76,  81,  88,  97, 104, 111, 123, 135, 145, 148, 153, 160, 158,
+             93,  88,  84,  82,  84,  90,  97, 105, 113, 122, 131, 141, 151, 163, 169, 175,
+        }, {
+             32,  31,  33,  37,  44,  48,  49,  51,  54,  57,  60,  64,  66,  68,  70,  72,
+             34,  36,  40,  44,  46,  46,  45,  47,  49,  51,  53,  57,  59,  61,  63,  65,
+             48,  46,  47,  47,  51,  53,  53,  54,  55,  56,  58,  61,  63,  63,  63,  63,
+             49,  46,  46,  45,  51,  56,  58,  60,  62,  64,  65,  68,  69,  71,  70,  69,
+             54,  50,  49,  48,  53,  58,  62,  65,  70,  73,  75,  78,  79,  79,  80,  77,
+             63,  58,  56,  54,  59,  64,  67,  71,  77,  82,  85,  89,  91,  87,  89,  86,
+             67,  62,  59,  57,  60,  64,  70,  73,  77,  83,  89,  93,  94,  96,  97,  95,
+             69,  65,  62,  60,  61,  64,  68,  72,  76,  81,  85,  89,  93,  98, 100, 102,
+        },
+    }, {
+        {
+             32,  31,  31,  32,  34,  36,  41,  47,  53,  58,  65,  74,  82,  87,  92,  97,
+             31,  32,  33,  34,  35,  36,  40,  44,  50,  54,  59,  67,  73,  78,  83,  88,
+             35,  34,  35,  37,  41,  46,  49,  53,  57,  61,  66,  73,  79,  83,  84,  86,
+             44,  41,  42,  42,  48,  54,  60,  66,  71,  75,  79,  86,  92,  96,  97,  97,
+             53,  50,  49,  49,  54,  60,  67,  75,  82,  87,  92, 100, 105, 110, 114, 111,
+             65,  61,  59,  58,  63,  68,  76,  84,  92,  98, 105, 113, 120, 125, 132, 128,
+             82,  76,  73,  71,  76,  80,  88,  97, 106, 112, 120, 131, 139, 144, 150, 147,
+             90,  85,  81,  79,  81,  87,  93, 101, 108, 116, 124, 134, 142, 153, 157, 163,
+        }, {
+             32,  31,  33,  37,  42,  49,  48,  50,  52,  54,  57,  61,  64,  66,  68,  70,
+             33,  34,  37,  43,  44,  47,  46,  46,  47,  49,  51,  55,  57,  59,  61,  63,
+             45,  45,  46,  47,  49,  52,  51,  52,  53,  54,  55,  58,  60,  61,  61,  61,
+             49,  46,  45,  45,  49,  53,  57,  59,  61,  62,  64,  66,  68,  69,  68,  67,
+             52,  49,  47,  47,  50,  54,  59,  63,  66,  68,  70,  73,  75,  77,  77,  75,
+             57,  53,  51,  50,  53,  57,  61,  66,  71,  73,  76,  80,  83,  84,  86,  83,
+             64,  60,  57,  55,  58,  61,  66,  71,  75,  79,  83,  87,  91,  93,  94,  92,
+             68,  64,  61,  59,  60,  63,  67,  71,  74,  79,  83,  87,  91,  95,  97,  98,
+        },
+    }, {
+        {
+             32,  31,  31,  32,  33,  36,  39,  44,  48,  53,  58,  66,  74,  81,  86,  91,
+             31,  32,  32,  33,  34,  35,  38,  41,  45,  49,  54,  60,  67,  73,  78,  82,
+             33,  33,  34,  36,  38,  42,  44,  46,  50,  53,  57,  63,  69,  75,  78,  80,
+             40,  39,  38,  40,  44,  51,  54,  59,  62,  66,  70,  75,  81,  86,  90,  90,
+             51,  49,  47,  48,  52,  58,  63,  69,  74,  79,  84,  90,  97, 102, 106, 103,
+             65,  61,  59,  58,  62,  68,  73,  79,  85,  92,  98, 106, 113, 120, 124, 119,
+             79,  74,  71,  69,  72,  78,  84,  90,  96, 103, 110, 119, 128, 135, 140, 137,
+             87,  82,  79,  77,  78,  84,  89,  96, 103, 111, 118, 126, 134, 143, 147, 151,
+        }, {
+             32,  31,  31,  35,  41,  49,  48,  49,  50,  52,  54,  57,  61,  64,  66,  68,
+             32,  33,  35,  39,  43,  47,  46,  45,  46,  48,  50,  52,  55,  58,  59,  61,
+             40,  41,  43,  46,  48,  50,  49,  48,  49,  50,  51,  53,  56,  58,  59,  59,
+             49,  47,  46,  46,  49,  53,  54,  56,  57,  58,  59,  61,  63,  65,  66,  65,
+             51,  49,  47,  47,  49,  54,  57,  61,  63,  65,  67,  69,  72,  73,  75,  72,
+             57,  54,  51,  50,  52,  57,  60,  64,  67,  71,  73,  77,  80,  82,  84,  81,
+             63,  59,  57,  55,  57,  60,  64,  67,  71,  75,  78,  82,  86,  89,  91,  89,
+             67,  63,  60,  58,  59,  62,  65,  69,  73,  77,  81,  85,  88,  92,  94,  95,
+        },
+    }, {
+        {
+             32,  31,  31,  32,  32,  34,  36,  39,  44,  48,  53,  58,  65,  71,  79,  82,
+             31,  32,  32,  32,  33,  34,  34,  37,  41,  45,  49,  54,  60,  65,  72,  75,
+             32,  32,  33,  34,  35,  37,  38,  40,  43,  46,  50,  54,  58,  63,  70,  72,
+             36,  35,  34,  36,  38,  42,  48,  50,  53,  56,  60,  63,  68,  73,  79,  81,
+             44,  42,  41,  42,  42,  48,  54,  58,  63,  67,  71,  75,  79,  84,  90,  92,
+             53,  51,  49,  50,  49,  54,  60,  65,  71,  76,  82,  87,  92,  97, 104, 106,
+             65,  62,  59,  59,  58,  63,  68,  73,  79,  85,  92,  98, 105, 111, 118, 121,
+             79,  75,  72,  71,  69,  73,  78,  84,  90,  96, 103, 110, 118, 125, 133, 136,
+        }, {
+             32,  31,  30,  33,  37,  42,  49,  48,  49,  50,  52,  54,  57,  60,  63,  64,
+             31,  31,  32,  36,  40,  43,  46,  46,  45,  46,  48,  50,  52,  54,  57,  59,
+             37,  38,  40,  43,  47,  47,  48,  47,  46,  46,  47,  49,  50,  52,  55,  56,
+             48,  47,  46,  47,  47,  50,  53,  53,  53,  54,  54,  55,  56,  58,  60,  61,
+             49,  47,  45,  46,  45,  49,  53,  56,  58,  59,  61,  62,  64,  65,  67,  68,
+             52,  50,  48,  47,  47,  50,  54,  57,  61,  64,  66,  68,  70,  72,  75,  75,
+             57,  54,  52,  51,  50,  53,  57,  60,  64,  67,  71,  73,  76,  79,  82,  83,
+             63,  60,  57,  56,  54,  57,  60,  64,  67,  71,  75,  78,  82,  85,  89,  90,
+        },
+    }, {
+        {
+             32,  31,  31,  32,  32,  34,  35,  38,  41,  44,  48,  53,  58,  65,  71,  79,
+             31,  32,  32,  32,  33,  34,  34,  36,  39,  42,  45,  49,  54,  60,  65,  72,
+             32,  32,  33,  34,  35,  37,  38,  40,  41,  43,  46,  50,  54,  58,  63,  70,
+             36,  35,  34,  36,  38,  42,  47,  49,  51,  54,  56,  60,  63,  68,  73,  79,
+             44,  42,  41,  42,  42,  48,  52,  56,  60,  64,  67,  71,  75,  79,  84,  90,
+             53,  51,  49,  50,  49,  54,  59,  63,  67,  72,  76,  82,  87,  92,  97, 104,
+             62,  59,  57,  57,  56,  61,  65,  69,  74,  79,  83,  90,  95, 102, 108, 115,
+             73,  69,  66,  65,  64,  69,  73,  77,  81,  86,  91,  99, 105, 112, 119, 127,
+        }, {
+             32,  31,  30,  33,  37,  42,  47,  48,  48,  49,  50,  52,  54,  57,  60,  63,
+             31,  31,  32,  36,  40,  43,  46,  46,  45,  45,  46,  48,  50,  52,  54,  57,
+             37,  38,  40,  43,  47,  47,  48,  47,  46,  46,  46,  47,  49,  50,  52,  55,
+             48,  47,  46,  47,  47,  50,  52,  53,  53,  53,  54,  54,  55,  56,  58,  60,
+             49,  47,  45,  46,  45,  49,  53,  55,  57,  58,  59,  61,  62,  64,  65,  67,
+             52,  50,  48,  47,  47,  50,  53,  56,  59,  62,  64,  66,  68,  70,  72,  75,
+             56,  53,  51,  50,  49,  53,  55,  58,  61,  64,  66,  70,  72,  75,  77,  80,
+             61,  57,  55,  54,  52,  56,  58,  61,  63,  66,  69,  73,  76,  79,  82,  86,
+        },
+    }, {
+        {
+             32,  31,  31,  31,  32,  32,  34,  36,  38,  41,  44,  48,  53,  57,  61,  65,
+             31,  32,  32,  32,  32,  33,  34,  34,  37,  39,  41,  45,  49,  53,  56,  60,
+             32,  32,  33,  34,  34,  35,  37,  38,  40,  41,  43,  46,  50,  53,  56,  58,
+             35,  35,  34,  35,  36,  37,  41,  46,  47,  49,  51,  54,  57,  60,  63,  66,
+             39,  38,  37,  38,  39,  40,  44,  50,  52,  54,  57,  60,  64,  67,  69,  72,
+             44,  42,  41,  42,  42,  42,  48,  54,  57,  60,  63,  67,  71,  74,  77,  79,
+             53,  51,  49,  49,  49,  49,  54,  60,  64,  67,  71,  76,  82,  86,  89,  92,
+             65,  62,  59,  59,  58,  58,  63,  68,  72,  76,  79,  85,  92,  97, 100, 105,
+        }, {
+             32,  31,  30,  33,  35,  37,  42,  49,  48,  48,  49,  50,  52,  54,  55,  57,
+             31,  31,  32,  35,  37,  40,  43,  46,  46,  45,  45,  46,  48,  49,  51,  52,
+             37,  38,  40,  42,  44,  47,  47,  48,  47,  46,  46,  46,  47,  48,  49,  50,
+             45,  45,  44,  46,  46,  47,  49,  52,  51,  51,  51,  52,  53,  54,  54,  55,
+             48,  47,  45,  46,  46,  47,  50,  53,  54,  54,  55,  56,  57,  58,  58,  59,
+             49,  47,  45,  45,  45,  45,  49,  53,  55,  57,  58,  59,  61,  62,  63,  64,
+             52,  50,  48,  47,  47,  47,  50,  54,  57,  59,  61,  64,  66,  68,  69,  70,
+             57,  54,  52,  51,  51,  50,  53,  57,  59,  61,  64,  67,  71,  73,  74,  76,
+        },
+    }, {
+        {
+             32,  31,  31,  31,  32,  32,  32,  34,  36,  38,  39,  44,  47,  49,  53,  58,
+             31,  32,  32,  32,  32,  33,  33,  34,  34,  36,  37,  41,  44,  46,  49,  54,
+             32,  32,  32,  33,  34,  35,  35,  36,  37,  39,  40,  42,  45,  47,  50,  54,
+             32,  33,  33,  33,  34,  36,  36,  38,  40,  41,  42,  45,  47,  48,  51,  55,
+             36,  35,  35,  35,  36,  38,  40,  42,  48,  49,  50,  53,  56,  57,  60,  63,
+             44,  42,  41,  41,  42,  42,  44,  48,  54,  56,  58,  63,  66,  67,  71,  75,
+             47,  45,  44,  44,  45,  45,  47,  50,  56,  58,  60,  66,  69,  71,  75,  79,
+             53,  51,  49,  49,  50,  49,  51,  54,  60,  63,  65,  71,  75,  77,  82,  87,
+        }, {
+             32,  31,  30,  31,  33,  37,  39,  42,  49,  48,  48,  49,  50,  51,  52,  54,
+             31,  31,  32,  33,  36,  40,  41,  43,  46,  46,  46,  45,  46,  47,  48,  50,
+             35,  37,  38,  38,  41,  45,  46,  46,  48,  47,  46,  45,  46,  47,  47,  49,
+             38,  40,  40,  41,  44,  47,  47,  48,  49,  48,  48,  47,  48,  48,  48,  50,
+             48,  47,  46,  46,  47,  47,  48,  50,  53,  53,  53,  53,  54,  54,  54,  55,
+             49,  47,  45,  45,  46,  45,  47,  49,  53,  55,  56,  58,  59,  60,  61,  62,
+             50,  48,  46,  46,  46,  46,  47,  50,  54,  55,  56,  59,  61,  61,  63,  65,
+             52,  50,  48,  48,  47,  47,  48,  50,  54,  56,  57,  61,  63,  64,  66,  68,
+        },
+    }, {
+        {
+             32,  31,  31,  31,  31,  32,  32,  32,  34,  35,  36,  39,  41,  44,  47,  48,
+             31,  32,  32,  32,  32,  32,  33,  33,  34,  34,  34,  37,  39,  41,  44,  45,
+             31,  32,  32,  32,  33,  33,  34,  34,  35,  36,  36,  39,  40,  42,  44,  45,
+             32,  32,  32,  33,  34,  34,  35,  36,  37,  38,  38,  40,  41,  43,  45,  46,
+             35,  35,  34,  34,  35,  36,  37,  39,  41,  45,  46,  48,  49,  51,  53,  54,
+             36,  35,  35,  34,  36,  36,  38,  40,  42,  47,  48,  50,  51,  53,  56,  56,
+             44,  42,  41,  41,  42,  42,  42,  44,  48,  52,  54,  58,  60,  63,  66,  67,
+             47,  45,  45,  44,  44,  45,  45,  47,  50,  55,  56,  60,  62,  66,  69,  70,
+        }, {
+             32,  31,  31,  30,  33,  33,  37,  39,  42,  47,  49,  48,  48,  49,  50,  50,
+             31,  31,  32,  32,  35,  36,  40,  41,  43,  46,  46,  46,  45,  45,  46,  46,
+             33,  34,  34,  35,  37,  38,  43,  43,  44,  46,  47,  46,  46,  45,  46,  46,
+             37,  38,  39,  40,  42,  43,  47,  47,  47,  48,  48,  47,  46,  46,  46,  46,
+             45,  45,  45,  44,  46,  46,  47,  48,  49,  51,  52,  51,  51,  51,  52,  52,
+             48,  47,  46,  46,  47,  47,  47,  48,  50,  52,  53,  53,  53,  53,  54,  54,
+             49,  47,  46,  45,  45,  46,  45,  47,  49,  53,  53,  56,  57,  58,  59,  59,
+             50,  48,  47,  46,  46,  46,  46,  47,  50,  53,  54,  56,  57,  59,  61,  61,
+        },
+    }, {
+        {
+             32,  31,  31,  31,  31,  32,  32,  32,  32,  34,  34,  36,  36,  39,  39,  44,
+             31,  32,  32,  32,  32,  32,  32,  33,  33,  34,  34,  34,  34,  37,  37,  41,
+             31,  32,  32,  32,  32,  32,  32,  33,  33,  34,  34,  34,  34,  37,  37,  41,
+             32,  32,  32,  33,  33,  34,  34,  35,  35,  37,  37,  38,  38,  40,  40,  43,
+             32,  32,  32,  33,  33,  34,  34,  35,  35,  37,  37,  38,  38,  40,  40,  43,
+             36,  35,  35,  34,  34,  36,  36,  38,  38,  42,  42,  48,  48,  50,  50,  53,
+             36,  35,  35,  34,  34,  36,  36,  38,  38,  42,  42,  48,  48,  50,  50,  53,
+             44,  42,  42,  41,  41,  42,  42,  42,  42,  48,  48,  54,  54,  58,  58,  63,
+        }, {
+             32,  31,  31,  30,  30,  33,  33,  37,  37,  42,  42,  49,  49,  48,  48,  49,
+             31,  31,  31,  32,  32,  36,  36,  40,  40,  43,  43,  46,  46,  46,  46,  45,
+             31,  31,  31,  32,  32,  36,  36,  40,  40,  43,  43,  46,  46,  46,  46,  45,
+             37,  38,  38,  40,  40,  43,  43,  47,  47,  47,  47,  48,  48,  47,  47,  46,
+             37,  38,  38,  40,  40,  43,  43,  47,  47,  47,  47,  48,  48,  47,  47,  46,
+             48,  47,  47,  46,  46,  47,  47,  47,  47,  50,  50,  53,  53,  53,  53,  53,
+             48,  47,  47,  46,  46,  47,  47,  47,  47,  50,  50,  53,  53,  53,  53,  53,
+             49,  47,  47,  45,  45,  46,  46,  45,  45,  49,  49,  53,  53,  56,  56,  58,
+        },
+    }, {
+        {
+             32,  31,  31,  31,  31,  31,  31,  32,  32,  32,  32,  33,  34,  34,  36,  36,
+             31,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  33,  34,  34,  35,  35,
+             31,  32,  32,  32,  32,  32,  32,  32,  32,  33,  33,  33,  34,  34,  34,  34,
+             31,  32,  32,  32,  32,  32,  33,  33,  33,  34,  34,  35,  35,  35,  36,  36,
+             32,  32,  32,  32,  33,  33,  34,  34,  34,  35,  35,  36,  37,  37,  38,  38,
+             32,  32,  32,  32,  33,  33,  34,  34,  34,  35,  35,  36,  37,  37,  38,  38,
+             35,  35,  35,  34,  34,  34,  35,  36,  36,  37,  37,  40,  41,  43,  46,  46,
+             36,  35,  35,  35,  34,  34,  36,  36,  37,  38,  38,  41,  42,  44,  48,  48,
+        }, {
+             32,  31,  31,  31,  30,  30,  33,  33,  35,  37,  37,  41,  42,  44,  49,  49,
+             31,  31,  31,  31,  32,  32,  34,  35,  37,  39,  39,  42,  42,  44,  47,  47,
+             31,  31,  31,  32,  32,  32,  35,  36,  37,  40,  40,  42,  43,  44,  46,  46,
+             33,  34,  34,  34,  35,  35,  37,  38,  40,  43,  43,  44,  44,  45,  47,  47,
+             37,  38,  38,  39,  40,  40,  42,  43,  44,  47,  47,  47,  47,  47,  48,  48,
+             37,  38,  38,  39,  40,  40,  42,  43,  44,  47,  47,  47,  47,  47,  48,  48,
+             45,  45,  45,  45,  44,  44,  46,  46,  46,  47,  47,  49,  49,  50,  52,  52,
+             48,  47,  47,  46,  46,  46,  47,  47,  47,  47,  47,  49,  50,  51,  53,  53,
+        },
+    }, {
+        {
+             32,  31,  31,  31,  31,  31,  31,  31,  31,  32,  32,  32,  32,  32,  32,  34,
+             31,  31,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  33,  34,
+             31,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  33,  33,  33,  34,
+             31,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  33,  33,  33,  34,
+             31,  32,  32,  32,  32,  32,  32,  32,  33,  33,  33,  33,  34,  34,  34,  35,
+             32,  32,  32,  32,  32,  33,  33,  33,  34,  34,  34,  35,  35,  35,  36,  37,
+             32,  32,  32,  32,  32,  33,  33,  33,  34,  34,  34,  35,  35,  35,  36,  37,
+             32,  33,  33,  33,  33,  33,  33,  33,  34,  34,  34,  35,  36,  36,  36,  38,
+        }, {
+             32,  31,  31,  31,  31,  30,  30,  31,  33,  33,  33,  35,  37,  37,  39,  42,
+             31,  31,  31,  31,  31,  31,  31,  32,  34,  35,  35,  37,  39,  39,  40,  42,
+             31,  31,  31,  31,  32,  32,  32,  33,  35,  36,  36,  38,  40,  40,  41,  43,
+             31,  31,  31,  31,  32,  32,  32,  33,  35,  36,  36,  38,  40,  40,  41,  43,
+             33,  33,  34,  34,  34,  35,  35,  35,  37,  38,  38,  41,  43,  43,  43,  44,
+             37,  38,  38,  38,  39,  40,  40,  40,  42,  43,  43,  45,  47,  47,  47,  47,
+             37,  38,  38,  38,  39,  40,  40,  40,  42,  43,  43,  45,  47,  47,  47,  47,
+             38,  39,  40,  40,  40,  41,  41,  41,  43,  44,  44,  46,  47,  47,  47,  48,
+        },
+    }, {
+        {
+             32,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  32,  32,  32,
+             31,  31,  31,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,
+             31,  31,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,
+             31,  31,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,
+             31,  31,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,
+             31,  31,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,
+             31,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  33,  33,  33,  33,  33,
+             32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  33,  33,  34,  34,  34,
+        }, {
+             32,  31,  31,  31,  31,  31,  31,  30,  30,  30,  30,  31,  33,  33,  33,  33,
+             31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  32,  34,  34,  34,  34,
+             31,  31,  31,  31,  31,  31,  31,  31,  32,  32,  32,  33,  34,  35,  35,  35,
+             31,  31,  31,  31,  31,  31,  32,  32,  32,  32,  32,  33,  35,  36,  36,  36,
+             31,  31,  31,  31,  31,  31,  32,  32,  32,  32,  32,  33,  35,  36,  36,  36,
+             31,  31,  31,  31,  31,  31,  32,  32,  32,  32,  32,  33,  35,  36,  36,  36,
+             33,  33,  34,  34,  34,  34,  34,  34,  35,  35,  35,  36,  37,  38,  38,  38,
+             35,  36,  36,  37,  37,  37,  37,  38,  38,  38,  38,  39,  40,  41,  41,  41,
+        },
+    }, {
+        {
+             32,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,
+             31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,
+             31,  31,  31,  31,  31,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,
+             31,  31,  31,  31,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,
+             31,  31,  31,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,
+             31,  31,  31,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,
+             31,  31,  31,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,
+             31,  31,  31,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,
+        }, {
+             32,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  30,  30,
+             31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,
+             31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,
+             31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,
+             31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  32,
+             31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  32,  32,  32,  32,
+             31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  32,  32,  32,  32,
+             31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  32,  32,  32,  32,
+        },
+    },
+};
+
+static const uint8_t qm_tbl_32x8[][2][256] = {
+    {
+        {
+             32,  31,  31,  31,  32,  32,  34,  35,  36,  39,  44,  46,  48,  53,  58,  61,  65,  71,  79,  81,  82,  88,  91,  94,  97, 100, 103, 107, 110, 114, 118, 122,
+             32,  32,  33,  33,  34,  35,  37,  37,  38,  40,  43,  44,  46,  50,  54,  56,  58,  63,  70,  71,  72,  77,  80,  83,  86,  89,  93,  96, 100, 104, 107, 111,
+             36,  35,  34,  35,  36,  38,  42,  45,  48,  50,  53,  55,  56,  60,  63,  66,  68,  73,  79,  80,  81,  85,  88,  91,  94,  97,  98, 100, 101, 103, 105, 107,
+             53,  51,  49,  49,  50,  49,  54,  57,  60,  65,  71,  73,  76,  82,  87,  89,  92,  97, 104, 105, 106, 108, 106, 105, 107, 111, 114, 117, 117, 117, 118, 119,
+             65,  62,  59,  59,  59,  58,  63,  65,  68,  73,  79,  82,  85,  92,  98, 101, 105, 111, 118, 119, 121, 126, 130, 131, 128, 127, 131, 136, 138, 137, 136, 136,
+             87,  82,  78,  78,  77,  75,  79,  82,  84,  89,  95,  98, 102, 109, 116, 120, 124, 132, 141, 142, 144, 149, 148, 153, 157, 152, 150, 155, 161, 159, 157, 156,
+             93,  88,  86,  84,  82,  82,  80,  84,  86,  91,  94,  98, 105, 107, 112, 119, 122, 130, 135, 140, 149, 153, 162, 165, 167, 173, 174, 177, 183, 185, 182, 179,
+             99,  94,  93,  90,  89,  89,  88,  87,  90,  93,  97,  99, 105, 107, 115, 116, 124, 127, 135, 139, 146, 152, 159, 166, 171, 182, 186, 191, 193, 201, 203, 204,
+        }, {
+             32,  31,  30,  32,  33,  37,  42,  45,  49,  48,  49,  49,  50,  52,  54,  55,  57,  60,  63,  64,  64,  67,  68,  69,  70,  71,  72,  73,  74,  75,  76,  77,
+             37,  38,  40,  41,  43,  47,  47,  47,  48,  47,  46,  46,  46,  47,  49,  49,  50,  52,  55,  55,  56,  58,  59,  60,  62,  63,  64,  65,  67,  68,  69,  70,
+             48,  47,  46,  46,  47,  47,  50,  51,  53,  53,  53,  53,  54,  54,  55,  56,  56,  58,  60,  61,  61,  63,  64,  65,  66,  67,  66,  66,  66,  66,  67,  67,
+             52,  50,  48,  48,  47,  47,  50,  52,  54,  57,  61,  62,  64,  66,  68,  69,  70,  72,  75,  75,  75,  76,  74,  72,  73,  74,  75,  75,  74,  74,  73,  73,
+             57,  54,  52,  51,  51,  50,  53,  55,  57,  60,  64,  65,  67,  71,  73,  75,  76,  79,  82,  82,  83,  85,  86,  85,  83,  82,  83,  84,  84,  83,  82,  81,
+             66,  63,  60,  59,  59,  57,  60,  61,  62,  66,  69,  71,  73,  77,  80,  82,  84,  88,  92,  92,  93,  95,  94,  95,  96,  93,  92,  93,  94,  93,  91,  90,
+             68,  65,  63,  62,  60,  60,  59,  61,  62,  65,  66,  68,  72,  73,  76,  79,  80,  84,  87,  89,  93,  94,  98,  99,  99, 102, 101, 102, 103, 103, 101,  99,
+             71,  67,  66,  64,  63,  62,  62,  61,  62,  64,  66,  67,  70,  71,  75,  76,  79,  81,  84,  86,  89,  91,  94,  97,  98, 102, 104, 106, 106, 109, 109, 108,
+        },
+    }, {
+        {
+             32,  31,  31,  31,  32,  32,  32,  34,  36,  38,  39,  44,  47,  49,  53,  58,  61,  65,  71,  76,  79,  82,  86,  89,  92,  95,  98, 101, 104, 107, 110, 114,
+             32,  32,  32,  33,  34,  35,  35,  36,  37,  39,  40,  42,  45,  47,  50,  54,  56,  59,  64,  68,  70,  73,  76,  79,  82,  85,  88,  91,  94,  97, 100, 104,
+             36,  35,  35,  35,  36,  38,  40,  42,  48,  49,  50,  53,  56,  57,  60,  63,  65,  68,  73,  76,  79,  81,  84,  87,  89,  92,  93,  94,  95,  96,  98, 100,
+             47,  45,  44,  44,  45,  45,  47,  50,  56,  58,  60,  66,  69,  71,  75,  79,  81,  84,  89,  92,  95,  97, 100,  99, 101, 105, 108, 110, 110, 110, 111, 111,
+             65,  62,  60,  59,  59,  58,  60,  63,  68,  71,  73,  79,  84,  86,  92,  98, 100, 105, 111, 115, 118, 121, 124, 124, 121, 120, 124, 128, 129, 128, 127, 127,
+             79,  75,  72,  71,  71,  69,  71,  73,  78,  81,  84,  90,  95,  97, 103, 110, 113, 118, 125, 130, 133, 136, 140, 145, 148, 143, 141, 146, 151, 149, 147, 145,
+             90,  86,  84,  82,  80,  80,  78,  82,  83,  88,  91,  94, 101, 103, 108, 114, 116, 124, 129, 134, 142, 145, 153, 156, 157, 163, 163, 166, 171, 173, 169, 166,
+             96,  91,  90,  87,  87,  86,  85,  84,  87,  90,  94,  96, 101, 102, 110, 111, 118, 121, 129, 132, 138, 144, 150, 156, 161, 171, 174, 179, 181, 188, 188, 190,
+        }, {
+             32,  31,  30,  31,  33,  37,  39,  42,  49,  48,  48,  49,  50,  51,  52,  54,  55,  57,  60,  62,  63,  64,  66,  67,  68,  69,  70,  71,  72,  73,  74,  75,
+             35,  37,  38,  38,  41,  45,  46,  46,  48,  47,  46,  45,  46,  47,  47,  49,  49,  50,  53,  54,  55,  56,  58,  59,  60,  61,  62,  64,  65,  66,  67,  68,
+             48,  47,  46,  46,  47,  47,  48,  50,  53,  53,  53,  53,  54,  54,  54,  55,  56,  56,  58,  60,  60,  61,  62,  63,  64,  65,  65,  65,  65,  65,  65,  65,
+             50,  48,  46,  46,  46,  46,  47,  50,  54,  55,  56,  59,  61,  61,  63,  65,  65,  66,  68,  69,  70,  71,  72,  71,  71,  72,  73,  73,  72,  72,  71,  71,
+             57,  54,  52,  52,  51,  50,  51,  53,  57,  58,  60,  64,  66,  68,  71,  73,  74,  76,  79,  81,  82,  83,  84,  83,  81,  80,  81,  82,  82,  81,  79,  78,
+             63,  60,  58,  57,  56,  54,  55,  57,  60,  62,  64,  67,  70,  71,  75,  78,  79,  82,  85,  87,  89,  90,  91,  93,  94,  91,  89,  90,  92,  90,  89,  87,
+             68,  64,  63,  61,  60,  59,  58,  60,  61,  64,  65,  67,  71,  72,  75,  78,  79,  83,  85,  87,  91,  92,  95,  96,  97,  99,  98,  99, 100, 100,  98,  96,
+             70,  66,  65,  63,  63,  62,  61,  60,  61,  63,  65,  66,  69,  70,  74,  74,  78,  79,  82,  84,  87,  89,  91,  94,  96, 100, 101, 103, 103, 105, 105, 105,
+        },
+    }, {
+        {
+             32,  31,  31,  31,  32,  32,  32,  34,  34,  36,  39,  40,  44,  47,  49,  53,  57,  59,  65,  69,  71,  79,  81,  82,  87,  90,  92,  95,  98, 100, 103, 106,
+             32,  32,  32,  32,  33,  34,  34,  35,  36,  37,  39,  40,  42,  45,  46,  50,  53,  54,  59,  62,  64,  71,  72,  73,  77,  80,  83,  85,  88,  91,  94,  97,
+             36,  35,  35,  34,  36,  37,  38,  42,  44,  48,  50,  51,  53,  56,  57,  60,  63,  64,  68,  71,  73,  79,  80,  81,  85,  87,  88,  88,  89,  90,  92,  93,
+             44,  42,  41,  41,  42,  42,  42,  48,  50,  54,  58,  59,  63,  66,  67,  71,  74,  75,  79,  83,  84,  90,  91,  92,  96,  99, 102, 103, 103, 103, 103, 104,
+             58,  55,  54,  53,  53,  53,  52,  57,  59,  63,  68,  70,  74,  79,  81,  86,  90,  91,  97, 100, 102, 109, 110, 111, 114, 113, 117, 120, 121, 120, 119, 118,
+             79,  75,  73,  72,  71,  70,  69,  73,  75,  78,  84,  85,  90,  95,  97, 103, 108, 111, 118, 122, 125, 133, 135, 136, 140, 135, 133, 137, 141, 139, 137, 135,
+             88,  83,  81,  79,  78,  77,  76,  79,  81,  85,  88,  91,  97,  99, 104, 109, 111, 119, 123, 127, 135, 137, 145, 147, 148, 153, 153, 155, 160, 161, 158, 155,
+             93,  88,  88,  84,  84,  83,  82,  81,  84,  86,  90,  92,  97,  98, 105, 106, 113, 115, 122, 125, 131, 136, 141, 147, 151, 160, 163, 168, 169, 175, 175, 176,
+        }, {
+             32,  31,  31,  30,  33,  35,  37,  42,  44,  49,  48,  48,  49,  50,  51,  52,  54,  54,  57,  59,  60,  63,  64,  64,  66,  67,  68,  69,  70,  71,  72,  73,
+             34,  35,  36,  36,  40,  42,  44,  45,  46,  47,  46,  46,  45,  46,  47,  47,  49,  49,  51,  52,  53,  56,  57,  57,  59,  60,  61,  62,  63,  64,  65,  66,
+             48,  47,  46,  46,  47,  47,  47,  50,  51,  53,  53,  53,  53,  54,  54,  54,  55,  55,  56,  58,  58,  60,  61,  61,  63,  63,  63,  63,  63,  63,  63,  63,
+             49,  47,  46,  45,  46,  45,  45,  49,  51,  53,  56,  56,  58,  59,  60,  61,  62,  62,  64,  65,  65,  67,  68,  68,  69,  70,  71,  71,  70,  70,  69,  69,
+             54,  51,  50,  49,  49,  48,  48,  51,  53,  55,  58,  59,  62,  65,  65,  68,  70,  70,  73,  74,  75,  77,  78,  78,  79,  78,  79,  80,  80,  78,  77,  76,
+             63,  60,  58,  57,  56,  55,  54,  57,  59,  60,  64,  65,  67,  70,  71,  75,  77,  78,  82,  84,  85,  89,  89,  90,  91,  88,  87,  88,  89,  88,  86,  84,
+             67,  63,  62,  60,  59,  58,  57,  59,  60,  63,  64,  66,  70,  70,  73,  76,  77,  81,  83,  85,  89,  90,  93,  94,  94,  96,  96,  96,  97,  97,  95,  93,
+             69,  65,  65,  62,  62,  61,  60,  59,  61,  62,  64,  65,  68,  68,  72,  73,  76,  77,  81,  82,  85,  87,  89,  92,  93,  97,  98, 100, 100, 102, 102, 101,
+        },
+    }, {
+        {
+             32,  31,  31,  31,  31,  32,  32,  32,  34,  35,  36,  39,  41,  44,  47,  48,  53,  55,  58,  63,  65,  71,  74,  79,  82,  82,  87,  89,  92,  94,  97,  99,
+             31,  32,  32,  32,  33,  33,  34,  34,  35,  36,  36,  39,  40,  42,  44,  45,  50,  51,  54,  58,  59,  64,  67,  71,  73,  74,  78,  81,  83,  85,  88,  91,
+             35,  35,  34,  34,  35,  36,  37,  39,  41,  45,  46,  48,  49,  51,  53,  54,  57,  59,  61,  65,  66,  71,  73,  77,  79,  79,  83,  83,  84,  85,  86,  87,
+             44,  42,  41,  41,  42,  42,  42,  44,  48,  52,  54,  58,  60,  63,  66,  67,  71,  72,  75,  78,  79,  84,  86,  90,  92,  92,  96,  97,  97,  97,  97,  97,
+             53,  51,  50,  49,  49,  50,  49,  51,  54,  59,  60,  65,  67,  71,  75,  76,  82,  84,  87,  91,  92,  97, 100, 104, 105, 106, 110, 113, 114, 112, 111, 110,
+             65,  62,  61,  59,  59,  59,  58,  60,  63,  67,  68,  73,  76,  79,  84,  85,  92,  94,  98, 103, 105, 111, 113, 118, 120, 121, 125, 128, 132, 130, 128, 126,
+             82,  78,  76,  74,  73,  73,  71,  73,  76,  79,  80,  86,  88,  92,  97,  98, 106, 108, 112, 118, 120, 127, 131, 136, 139, 139, 144, 145, 150, 151, 147, 144,
+             90,  86,  85,  82,  81,  80,  79,  78,  81,  83,  87,  88,  93,  94, 101, 101, 108, 110, 116, 119, 124, 129, 134, 139, 142, 150, 153, 157, 157, 163, 163, 163,
+        }, {
+             32,  31,  31,  30,  33,  33,  37,  39,  42,  47,  49,  48,  48,  49,  50,  50,  52,  53,  54,  56,  57,  60,  61,  63,  64,  64,  66,  67,  68,  69,  70,  70,
+             33,  34,  34,  35,  37,  38,  43,  43,  44,  46,  47,  46,  46,  45,  46,  46,  47,  48,  49,  51,  51,  54,  55,  56,  57,  58,  59,  60,  61,  62,  63,  64,
+             45,  45,  45,  44,  46,  46,  47,  48,  49,  51,  52,  51,  51,  51,  52,  52,  53,  53,  54,  55,  55,  57,  58,  59,  60,  60,  61,  61,  61,  61,  61,  61,
+             49,  47,  46,  45,  45,  46,  45,  47,  49,  53,  53,  56,  57,  58,  59,  59,  61,  61,  62,  63,  64,  65,  66,  67,  68,  68,  69,  69,  68,  68,  67,  67,
+             52,  50,  49,  48,  47,  47,  47,  48,  50,  53,  54,  57,  59,  61,  63,  64,  66,  67,  68,  70,  70,  72,  73,  75,  75,  75,  77,  78,  77,  76,  75,  74,
+             57,  54,  53,  52,  51,  51,  50,  51,  53,  56,  57,  60,  61,  64,  66,  67,  71,  72,  73,  76,  76,  79,  80,  82,  83,  83,  84,  85,  86,  85,  83,  82,
+             64,  61,  60,  58,  57,  57,  55,  56,  58,  61,  61,  64,  66,  68,  71,  71,  75,  77,  79,  82,  83,  86,  87,  90,  91,  91,  93,  93,  94,  94,  92,  90,
+             68,  64,  64,  61,  61,  60,  59,  58,  60,  61,  63,  64,  67,  67,  71,  71,  74,  75,  79,  80,  83,  85,  87,  89,  91,  94,  95,  97,  97,  99,  98,  98,
+        },
+    }, {
+        {
+             32,  31,  31,  31,  31,  32,  32,  32,  33,  34,  36,  36,  39,  40,  44,  46,  48,  52,  53,  58,  58,  65,  66,  71,  74,  79,  81,  82,  86,  88,  91,  93,
+             31,  32,  32,  32,  32,  33,  33,  33,  34,  34,  35,  35,  38,  39,  41,  43,  45,  48,  49,  53,  54,  59,  60,  65,  67,  72,  73,  74,  78,  80,  82,  85,
+             33,  33,  33,  33,  34,  35,  36,  36,  38,  39,  42,  42,  44,  45,  46,  48,  50,  52,  53,  57,  57,  62,  63,  67,  69,  73,  75,  75,  78,  80,  80,  81,
+             40,  39,  39,  38,  38,  39,  40,  41,  44,  45,  51,  51,  54,  56,  59,  60,  62,  65,  66,  69,  70,  74,  75,  79,  81,  85,  86,  87,  90,  90,  90,  90,
+             51,  49,  49,  47,  47,  48,  48,  48,  52,  53,  58,  59,  63,  65,  69,  72,  74,  78,  79,  83,  84,  89,  90,  94,  97, 101, 102, 103, 106, 105, 103, 103,
+             65,  62,  61,  59,  59,  59,  58,  58,  62,  63,  68,  68,  73,  75,  79,  82,  85,  90,  92,  97,  98, 105, 106, 111, 113, 118, 120, 121, 124, 122, 119, 117,
+             79,  75,  74,  72,  71,  71,  69,  69,  72,  73,  78,  79,  84,  85,  90,  93,  96, 101, 103, 109, 110, 118, 119, 125, 128, 133, 135, 136, 140, 140, 137, 134,
+             87,  83,  82,  79,  79,  78,  77,  75,  78,  80,  84,  85,  89,  90,  96,  97, 103, 105, 111, 113, 118, 122, 126, 131, 134, 141, 143, 147, 147, 152, 151, 152,
+        }, {
+             32,  31,  31,  30,  31,  33,  35,  37,  41,  42,  49,  49,  48,  48,  49,  49,  50,  51,  52,  54,  54,  57,  57,  60,  61,  63,  64,  64,  66,  67,  68,  68,
+             32,  33,  33,  33,  35,  37,  39,  41,  43,  43,  47,  47,  46,  46,  45,  46,  46,  47,  48,  49,  50,  52,  52,  54,  55,  57,  58,  58,  59,  60,  61,  62,
+             40,  41,  41,  42,  43,  44,  46,  47,  48,  48,  50,  50,  49,  49,  48,  49,  49,  49,  50,  51,  51,  52,  53,  55,  56,  57,  58,  58,  59,  59,  59,  59,
+             49,  47,  47,  45,  46,  46,  46,  46,  49,  49,  53,  53,  54,  55,  56,  57,  57,  58,  58,  59,  59,  60,  61,  62,  63,  64,  65,  65,  66,  66,  65,  65,
+             51,  49,  49,  47,  47,  47,  47,  46,  49,  50,  54,  54,  57,  58,  61,  62,  63,  64,  65,  67,  67,  69,  69,  71,  72,  73,  73,  74,  75,  74,  72,  71,
+             57,  54,  54,  52,  51,  51,  50,  50,  52,  53,  57,  57,  60,  61,  64,  65,  67,  69,  71,  73,  73,  76,  77,  79,  80,  82,  82,  83,  84,  82,  81,  79,
+             63,  60,  59,  57,  57,  56,  55,  54,  57,  57,  60,  61,  64,  65,  67,  69,  71,  73,  75,  77,  78,  82,  82,  85,  86,  89,  89,  90,  91,  91,  89,  87,
+             67,  63,  63,  60,  60,  59,  58,  57,  59,  60,  62,  63,  65,  66,  69,  70,  73,  74,  77,  78,  81,  83,  85,  87,  88,  92,  92,  94,  94,  96,  95,  95,
+        },
+    }, {
+        {
+             32,  31,  31,  31,  31,  32,  32,  32,  32,  34,  34,  36,  36,  39,  39,  44,  44,  48,  48,  53,  53,  58,  58,  65,  65,  71,  71,  79,  79,  82,  82,  87,
+             31,  32,  32,  32,  32,  32,  32,  33,  33,  34,  34,  34,  34,  37,  37,  41,  41,  45,  45,  49,  49,  54,  54,  60,  60,  65,  65,  72,  72,  75,  75,  79,
+             32,  32,  32,  33,  33,  34,  34,  35,  35,  37,  37,  38,  38,  40,  40,  43,  43,  46,  46,  50,  50,  54,  54,  58,  58,  63,  63,  70,  70,  72,  72,  76,
+             36,  35,  35,  34,  34,  36,  36,  38,  38,  42,  42,  48,  48,  50,  50,  53,  53,  56,  56,  60,  60,  63,  63,  68,  68,  73,  73,  79,  79,  81,  81,  84,
+             44,  42,  42,  41,  41,  42,  42,  42,  42,  48,  48,  54,  54,  58,  58,  63,  63,  67,  67,  71,  71,  75,  75,  79,  79,  84,  84,  90,  90,  92,  92,  96,
+             53,  51,  51,  49,  49,  50,  50,  49,  49,  54,  54,  60,  60,  65,  65,  71,  71,  76,  76,  82,  82,  87,  87,  92,  92,  97,  97, 104, 104, 106, 106, 109,
+             65,  62,  62,  59,  59,  59,  59,  58,  58,  63,  63,  68,  68,  73,  73,  79,  79,  85,  85,  92,  92,  98,  98, 105, 105, 111, 111, 118, 118, 121, 121, 124,
+             79,  75,  75,  72,  72,  71,  71,  69,  69,  73,  73,  78,  78,  84,  84,  90,  90,  96,  96, 103, 103, 110, 110, 118, 118, 125, 125, 133, 133, 136, 136, 141,
+        }, {
+             32,  31,  31,  30,  30,  33,  33,  37,  37,  42,  42,  49,  49,  48,  48,  49,  49,  50,  50,  52,  52,  54,  54,  57,  57,  60,  60,  63,  63,  64,  64,  66,
+             31,  31,  31,  32,  32,  36,  36,  40,  40,  43,  43,  46,  46,  46,  46,  45,  45,  46,  46,  48,  48,  50,  50,  52,  52,  54,  54,  57,  57,  59,  59,  60,
+             37,  38,  38,  40,  40,  43,  43,  47,  47,  47,  47,  48,  48,  47,  47,  46,  46,  46,  46,  47,  47,  49,  49,  50,  50,  52,  52,  55,  55,  56,  56,  57,
+             48,  47,  47,  46,  46,  47,  47,  47,  47,  50,  50,  53,  53,  53,  53,  53,  53,  54,  54,  54,  54,  55,  55,  56,  56,  58,  58,  60,  60,  61,  61,  63,
+             49,  47,  47,  45,  45,  46,  46,  45,  45,  49,  49,  53,  53,  56,  56,  58,  58,  59,  59,  61,  61,  62,  62,  64,  64,  65,  65,  67,  67,  68,  68,  69,
+             52,  50,  50,  48,  48,  47,  47,  47,  47,  50,  50,  54,  54,  57,  57,  61,  61,  64,  64,  66,  66,  68,  68,  70,  70,  72,  72,  75,  75,  75,  75,  77,
+             57,  54,  54,  52,  52,  51,  51,  50,  50,  53,  53,  57,  57,  60,  60,  64,  64,  67,  67,  71,  71,  73,  73,  76,  76,  79,  79,  82,  82,  83,  83,  84,
+             63,  60,  60,  57,  57,  56,  56,  54,  54,  57,  57,  60,  60,  64,  64,  67,  67,  71,  71,  75,  75,  78,  78,  82,  82,  85,  85,  89,  89,  90,  90,  92,
+        },
+    }, {
+        {
+             32,  31,  31,  31,  31,  31,  32,  32,  32,  32,  34,  34,  35,  36,  38,  39,  41,  44,  44,  48,  48,  53,  53,  57,  58,  61,  65,  67,  71,  72,  79,  79,
+             31,  32,  32,  32,  32,  32,  32,  32,  33,  33,  34,  34,  34,  34,  36,  37,  39,  41,  42,  45,  45,  49,  49,  52,  54,  57,  60,  61,  65,  66,  72,  72,
+             32,  32,  32,  32,  33,  33,  34,  34,  35,  35,  37,  37,  38,  38,  40,  40,  41,  43,  43,  46,  46,  49,  50,  52,  54,  56,  58,  60,  63,  64,  70,  70,
+             36,  35,  35,  35,  34,  35,  36,  37,  38,  39,  42,  42,  47,  48,  49,  50,  51,  53,  54,  56,  56,  59,  60,  62,  63,  66,  68,  69,  73,  73,  79,  79,
+             44,  42,  42,  41,  41,  41,  42,  42,  42,  43,  48,  48,  52,  54,  56,  58,  60,  63,  64,  67,  67,  71,  71,  74,  75,  77,  79,  81,  84,  85,  90,  90,
+             53,  51,  51,  50,  49,  49,  50,  49,  49,  50,  54,  54,  59,  60,  63,  65,  67,  71,  72,  76,  76,  81,  82,  85,  87,  89,  92,  94,  97,  98, 104, 104,
+             62,  60,  59,  58,  57,  57,  57,  56,  56,  56,  61,  61,  65,  66,  69,  71,  74,  78,  79,  83,  83,  89,  90,  94,  95,  98, 102, 103, 108, 108, 115, 115,
+             73,  70,  69,  67,  66,  66,  65,  65,  64,  64,  69,  69,  73,  74,  77,  79,  81,  85,  86,  91,  91,  98,  99, 103, 105, 108, 112, 114, 119, 119, 127, 127,
+        }, {
+             32,  31,  31,  30,  30,  32,  33,  34,  37,  37,  42,  42,  47,  49,  48,  48,  48,  49,  49,  50,  50,  52,  52,  53,  54,  55,  57,  58,  60,  60,  63,  63,
+             31,  31,  31,  32,  32,  34,  36,  37,  40,  40,  43,  43,  46,  46,  46,  46,  45,  45,  45,  46,  46,  48,  48,  49,  50,  51,  52,  53,  54,  55,  57,  57,
+             37,  38,  38,  39,  40,  41,  43,  44,  47,  47,  47,  47,  48,  48,  47,  47,  46,  46,  46,  46,  46,  47,  47,  48,  49,  49,  50,  51,  52,  53,  55,  55,
+             48,  47,  47,  46,  46,  46,  47,  47,  47,  48,  50,  50,  52,  53,  53,  53,  53,  53,  53,  54,  54,  54,  54,  55,  55,  56,  56,  57,  58,  59,  60,  60,
+             49,  47,  47,  46,  45,  45,  46,  45,  45,  46,  49,  49,  53,  53,  55,  56,  57,  58,  58,  59,  59,  61,  61,  62,  62,  63,  64,  64,  65,  65,  67,  67,
+             52,  50,  50,  48,  48,  48,  47,  47,  47,  47,  50,  50,  53,  54,  56,  57,  59,  61,  62,  64,  64,  66,  66,  68,  68,  69,  70,  71,  72,  73,  75,  75,
+             56,  54,  53,  52,  51,  51,  50,  50,  49,  49,  53,  53,  55,  56,  58,  59,  61,  63,  64,  66,  66,  69,  70,  71,  72,  74,  75,  76,  77,  78,  80,  80,
+             61,  58,  57,  56,  55,  54,  54,  53,  52,  53,  56,  56,  58,  59,  61,  62,  63,  66,  66,  69,  69,  72,  73,  75,  76,  78,  79,  80,  82,  83,  86,  86,
+        },
+    }, {
+        {
+             32,  31,  31,  31,  31,  31,  31,  32,  32,  32,  32,  33,  34,  34,  36,  36,  38,  39,  41,  44,  44,  47,  48,  50,  53,  53,  57,  58,  61,  65,  65,  70,
+             31,  32,  32,  32,  32,  32,  32,  32,  32,  33,  33,  33,  34,  34,  34,  34,  37,  37,  39,  41,  41,  44,  45,  46,  49,  49,  53,  54,  56,  60,  60,  64,
+             32,  32,  32,  32,  33,  33,  34,  34,  34,  35,  35,  36,  37,  37,  38,  38,  40,  40,  41,  43,  43,  45,  46,  47,  50,  50,  53,  54,  56,  58,  58,  62,
+             35,  35,  35,  34,  34,  34,  35,  36,  36,  37,  37,  40,  41,  43,  46,  46,  47,  48,  49,  51,  51,  53,  54,  55,  57,  57,  60,  61,  63,  66,  66,  70,
+             39,  38,  38,  37,  37,  37,  38,  38,  39,  40,  40,  43,  44,  46,  50,  50,  52,  53,  54,  57,  57,  59,  60,  61,  64,  64,  67,  68,  69,  72,  72,  76,
+             44,  42,  42,  41,  41,  41,  42,  42,  42,  42,  42,  46,  48,  50,  54,  54,  57,  58,  60,  63,  63,  66,  67,  68,  71,  71,  74,  75,  77,  79,  79,  83,
+             53,  52,  51,  50,  49,  49,  49,  50,  49,  49,  49,  53,  54,  56,  60,  60,  64,  65,  67,  71,  71,  75,  76,  78,  82,  82,  86,  87,  89,  92,  92,  96,
+             65,  63,  62,  61,  59,  59,  59,  59,  58,  58,  58,  62,  63,  65,  68,  68,  72,  73,  76,  79,  79,  84,  85,  88,  92,  92,  97,  98, 100, 105, 105, 109,
+        }, {
+             32,  31,  31,  31,  30,  30,  33,  33,  35,  37,  37,  41,  42,  44,  49,  49,  48,  48,  48,  49,  49,  50,  50,  51,  52,  52,  54,  54,  55,  57,  57,  59,
+             31,  31,  31,  32,  32,  32,  35,  36,  37,  40,  40,  42,  43,  44,  46,  46,  46,  46,  45,  45,  45,  46,  46,  47,  48,  48,  49,  50,  51,  52,  52,  54,
+             37,  38,  38,  39,  40,  40,  42,  43,  44,  47,  47,  47,  47,  47,  48,  48,  47,  47,  46,  46,  46,  46,  46,  47,  47,  47,  48,  49,  49,  50,  50,  52,
+             45,  45,  45,  45,  44,  44,  46,  46,  46,  47,  47,  49,  49,  50,  52,  52,  51,  51,  51,  51,  51,  52,  52,  52,  53,  53,  54,  54,  54,  55,  55,  57,
+             48,  47,  47,  46,  45,  45,  46,  46,  46,  47,  47,  49,  50,  51,  53,  53,  54,  54,  54,  55,  55,  56,  56,  56,  57,  57,  58,  58,  58,  59,  59,  61,
+             49,  47,  47,  46,  45,  45,  45,  46,  45,  45,  45,  48,  49,  51,  53,  53,  55,  56,  57,  58,  58,  59,  59,  60,  61,  61,  62,  62,  63,  64,  64,  65,
+             52,  50,  50,  49,  48,  48,  47,  47,  47,  47,  47,  50,  50,  52,  54,  54,  57,  57,  59,  61,  61,  63,  64,  65,  66,  66,  68,  68,  69,  70,  70,  72,
+             57,  55,  54,  53,  52,  52,  51,  51,  51,  50,  50,  52,  53,  54,  57,  57,  59,  60,  61,  64,  64,  66,  67,  68,  71,  71,  73,  73,  74,  76,  76,  78,
+        },
+    }, {
+        {
+             32,  31,  31,  31,  31,  31,  31,  32,  32,  32,  32,  32,  32,  34,  34,  35,  36,  36,  38,  39,  39,  42,  44,  44,  47,  48,  49,  53,  53,  55,  58,  58,
+             31,  32,  32,  32,  32,  32,  32,  32,  32,  32,  33,  33,  33,  34,  34,  34,  34,  34,  36,  37,  37,  40,  41,  41,  44,  45,  46,  49,  49,  51,  54,  54,
+             32,  32,  32,  32,  32,  32,  33,  33,  34,  34,  35,  35,  35,  36,  36,  37,  37,  37,  39,  40,  40,  42,  42,  43,  45,  46,  47,  49,  50,  51,  54,  54,
+             32,  33,  33,  33,  33,  33,  33,  34,  34,  35,  36,  36,  36,  38,  38,  39,  40,  40,  41,  42,  42,  44,  45,  45,  47,  48,  48,  51,  51,  53,  55,  55,
+             36,  35,  35,  35,  35,  34,  35,  36,  36,  37,  38,  38,  40,  42,  42,  45,  48,  48,  49,  50,  50,  52,  53,  54,  56,  56,  57,  59,  60,  61,  63,  63,
+             44,  43,  42,  42,  41,  41,  41,  42,  42,  42,  42,  42,  44,  48,  48,  50,  54,  54,  56,  58,  58,  61,  63,  63,  66,  67,  67,  71,  71,  72,  75,  75,
+             47,  46,  45,  45,  44,  44,  44,  45,  45,  45,  45,  45,  47,  50,  50,  53,  56,  56,  58,  60,  60,  64,  66,  66,  69,  70,  71,  74,  75,  76,  79,  79,
+             53,  52,  51,  51,  49,  49,  49,  49,  50,  49,  49,  49,  51,  54,  54,  57,  60,  60,  63,  65,  65,  69,  71,  72,  75,  76,  77,  81,  82,  83,  87,  87,
+        }, {
+             32,  31,  31,  31,  30,  30,  31,  33,  33,  34,  37,  37,  39,  42,  42,  45,  49,  49,  48,  48,  48,  49,  49,  49,  50,  50,  51,  52,  52,  53,  54,  54,
+             31,  31,  31,  31,  32,  32,  33,  35,  36,  37,  40,  40,  41,  43,  43,  44,  46,  46,  46,  46,  46,  45,  45,  45,  46,  46,  47,  48,  48,  48,  50,  50,
+             35,  36,  37,  37,  38,  38,  38,  41,  41,  42,  45,  45,  46,  46,  46,  47,  48,  48,  47,  46,  46,  46,  45,  46,  46,  46,  47,  47,  47,  48,  49,  49,
+             38,  39,  40,  40,  40,  41,  41,  43,  44,  45,  47,  47,  47,  48,  48,  48,  49,  49,  48,  48,  48,  47,  47,  47,  48,  48,  48,  48,  48,  49,  50,  50,
+             48,  47,  47,  47,  46,  46,  46,  47,  47,  47,  47,  47,  48,  50,  50,  51,  53,  53,  53,  53,  53,  53,  53,  53,  54,  54,  54,  54,  54,  54,  55,  55,
+             49,  48,  47,  47,  45,  45,  45,  45,  46,  45,  45,  45,  47,  49,  49,  51,  53,  53,  55,  56,  56,  57,  58,  58,  59,  59,  60,  61,  61,  61,  62,  62,
+             50,  49,  48,  48,  46,  46,  46,  46,  46,  46,  46,  46,  47,  50,  50,  52,  54,  54,  55,  56,  56,  58,  59,  60,  61,  61,  61,  63,  63,  63,  65,  65,
+             52,  50,  50,  50,  48,  48,  48,  47,  47,  47,  47,  47,  48,  50,  50,  52,  54,  54,  56,  57,  57,  60,  61,  61,  63,  64,  64,  66,  66,  67,  68,  68,
+        },
+    }, {
+        {
+             32,  31,  31,  31,  31,  31,  31,  31,  31,  32,  32,  32,  32,  32,  32,  34,  34,  34,  35,  36,  36,  38,  39,  39,  41,  44,  44,  44,  47,  48,  48,  51,
+             31,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  33,  33,  33,  34,  34,  34,  34,  34,  34,  36,  37,  37,  39,  41,  41,  42,  44,  45,  45,  47,
+             31,  32,  32,  32,  32,  32,  32,  32,  33,  33,  33,  33,  34,  34,  34,  35,  35,  35,  36,  36,  36,  37,  39,  39,  40,  42,  42,  42,  44,  45,  45,  48,
+             32,  32,  32,  32,  32,  33,  33,  33,  34,  34,  34,  35,  35,  35,  36,  37,  37,  37,  38,  38,  38,  40,  40,  40,  41,  43,  43,  43,  45,  46,  46,  48,
+             35,  35,  35,  35,  34,  34,  34,  34,  35,  36,  36,  37,  37,  37,  39,  41,  41,  42,  45,  46,  46,  47,  48,  48,  49,  51,  51,  51,  53,  54,  54,  56,
+             36,  35,  35,  35,  35,  34,  34,  35,  36,  36,  36,  37,  38,  38,  40,  42,  42,  43,  47,  48,  48,  49,  50,  50,  51,  53,  53,  54,  56,  56,  56,  58,
+             44,  43,  42,  42,  41,  41,  41,  41,  42,  42,  42,  42,  42,  42,  44,  48,  48,  49,  52,  54,  54,  56,  58,  58,  60,  63,  63,  64,  66,  67,  67,  69,
+             47,  46,  45,  45,  45,  44,  44,  44,  44,  45,  45,  45,  45,  45,  47,  50,  50,  51,  55,  56,  56,  58,  60,  60,  62,  66,  66,  67,  69,  70,  70,  73,
+        }, {
+             32,  31,  31,  31,  31,  30,  30,  31,  33,  33,  33,  35,  37,  37,  39,  42,  42,  43,  47,  49,  49,  48,  48,  48,  48,  49,  49,  49,  50,  50,  50,  51,
+             31,  31,  31,  31,  32,  32,  32,  33,  35,  36,  36,  38,  40,  40,  41,  43,  43,  43,  46,  46,  46,  46,  46,  46,  45,  45,  45,  45,  46,  46,  46,  47,
+             33,  33,  34,  34,  34,  35,  35,  35,  37,  38,  38,  41,  43,  43,  43,  44,  44,  45,  46,  47,  47,  46,  46,  46,  46,  45,  45,  45,  46,  46,  46,  47,
+             37,  38,  38,  38,  39,  40,  40,  40,  42,  43,  43,  45,  47,  47,  47,  47,  47,  47,  48,  48,  48,  47,  47,  47,  46,  46,  46,  46,  46,  46,  46,  47,
+             45,  45,  45,  45,  45,  44,  44,  45,  46,  46,  46,  47,  47,  47,  48,  49,  49,  50,  51,  52,  52,  52,  51,  51,  51,  51,  51,  52,  52,  52,  52,  52,
+             48,  47,  47,  47,  46,  46,  46,  46,  47,  47,  47,  47,  47,  47,  48,  50,  50,  50,  52,  53,  53,  53,  53,  53,  53,  53,  53,  53,  54,  54,  54,  54,
+             49,  48,  47,  47,  46,  45,  45,  45,  45,  46,  46,  45,  45,  45,  47,  49,  49,  50,  53,  53,  53,  55,  56,  56,  57,  58,  58,  58,  59,  59,  59,  60,
+             50,  49,  48,  48,  47,  46,  46,  46,  46,  46,  46,  46,  46,  46,  47,  50,  50,  50,  53,  54,  54,  55,  56,  56,  57,  59,  59,  60,  61,  61,  61,  62,
+        },
+    }, {
+        {
+             32,  31,  31,  31,  31,  31,  31,  31,  31,  31,  32,  32,  32,  32,  32,  32,  32,  33,  34,  34,  34,  35,  36,  36,  36,  37,  39,  39,  39,  41,  44,  44,
+             31,  31,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  33,  33,  33,  33,  34,  34,  34,  34,  34,  34,  34,  36,  37,  37,  37,  39,  41,  41,
+             31,  31,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  33,  33,  33,  33,  34,  34,  34,  34,  34,  34,  34,  36,  37,  37,  37,  39,  41,  41,
+             32,  32,  32,  32,  32,  32,  33,  33,  33,  33,  34,  34,  34,  34,  35,  35,  35,  36,  37,  37,  37,  37,  38,  38,  38,  39,  40,  40,  40,  42,  43,  43,
+             32,  32,  32,  32,  32,  32,  33,  33,  33,  33,  34,  34,  34,  34,  35,  35,  35,  36,  37,  37,  37,  37,  38,  38,  38,  39,  40,  40,  40,  42,  43,  43,
+             36,  35,  35,  35,  35,  35,  34,  34,  34,  35,  36,  36,  36,  37,  38,  38,  38,  40,  42,  42,  42,  45,  48,  48,  48,  49,  50,  50,  50,  52,  53,  53,
+             36,  35,  35,  35,  35,  35,  34,  34,  34,  35,  36,  36,  36,  37,  38,  38,  38,  40,  42,  42,  42,  45,  48,  48,  48,  49,  50,  50,  50,  52,  53,  53,
+             44,  43,  42,  42,  42,  41,  41,  41,  41,  41,  42,  42,  42,  42,  42,  42,  42,  45,  48,  48,  48,  50,  54,  54,  54,  56,  58,  58,  58,  60,  63,  63,
+        }, {
+             32,  31,  31,  31,  31,  31,  30,  30,  30,  32,  33,  33,  33,  35,  37,  37,  37,  39,  42,  42,  42,  45,  49,  49,  49,  48,  48,  48,  48,  48,  49,  49,
+             31,  31,  31,  31,  31,  32,  32,  32,  32,  34,  36,  36,  36,  38,  40,  40,  40,  41,  43,  43,  43,  44,  46,  46,  46,  46,  46,  46,  46,  45,  45,  45,
+             31,  31,  31,  31,  31,  32,  32,  32,  32,  34,  36,  36,  36,  38,  40,  40,  40,  41,  43,  43,  43,  44,  46,  46,  46,  46,  46,  46,  46,  45,  45,  45,
+             37,  37,  38,  38,  38,  39,  40,  40,  40,  41,  43,  43,  43,  45,  47,  47,  47,  47,  47,  47,  47,  47,  48,  48,  48,  47,  47,  47,  47,  46,  46,  46,
+             37,  37,  38,  38,  38,  39,  40,  40,  40,  41,  43,  43,  43,  45,  47,  47,  47,  47,  47,  47,  47,  47,  48,  48,  48,  47,  47,  47,  47,  46,  46,  46,
+             48,  47,  47,  47,  47,  46,  46,  46,  46,  46,  47,  47,  47,  47,  47,  47,  47,  49,  50,  50,  50,  51,  53,  53,  53,  53,  53,  53,  53,  53,  53,  53,
+             48,  47,  47,  47,  47,  46,  46,  46,  46,  46,  47,  47,  47,  47,  47,  47,  47,  49,  50,  50,  50,  51,  53,  53,  53,  53,  53,  53,  53,  53,  53,  53,
+             49,  48,  47,  47,  47,  46,  45,  45,  45,  45,  46,  46,  46,  45,  45,  45,  45,  47,  49,  49,  49,  51,  53,  53,  53,  54,  56,  56,  56,  57,  58,  58,
+        },
+    }, {
+        {
+             32,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  32,  32,  32,  32,  32,  32,  32,  32,  32,  33,  34,  34,  34,  34,  35,  36,  36,  36,  37,
+             31,  31,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  33,  33,  34,  34,  34,  34,  34,  35,  35,  35,  36,
+             31,  31,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  33,  33,  33,  33,  33,  33,  34,  34,  34,  34,  34,  34,  34,  34,  36,
+             31,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  33,  33,  33,  33,  33,  33,  33,  34,  34,  34,  34,  35,  35,  35,  35,  35,  36,  36,  36,  36,  37,
+             32,  32,  32,  32,  32,  32,  32,  32,  33,  33,  33,  33,  34,  34,  34,  34,  34,  35,  35,  35,  35,  36,  36,  37,  37,  37,  37,  38,  38,  38,  38,  39,
+             32,  32,  32,  32,  32,  32,  32,  32,  33,  33,  33,  33,  34,  34,  34,  34,  34,  35,  35,  35,  35,  36,  36,  37,  37,  37,  37,  38,  38,  38,  38,  39,
+             35,  35,  35,  35,  35,  35,  34,  34,  34,  34,  34,  35,  35,  36,  36,  36,  36,  37,  37,  37,  37,  39,  40,  41,  41,  41,  43,  45,  46,  46,  46,  46,
+             36,  35,  35,  35,  35,  35,  35,  35,  34,  34,  34,  35,  36,  36,  36,  36,  37,  38,  38,  38,  38,  40,  41,  42,  42,  42,  44,  47,  48,  48,  48,  49,
+        }, {
+             32,  31,  31,  31,  31,  31,  31,  30,  30,  30,  30,  31,  33,  33,  33,  33,  35,  36,  37,  37,  37,  39,  41,  42,  42,  42,  44,  47,  49,  49,  49,  49,
+             31,  31,  31,  31,  31,  31,  31,  31,  32,  32,  32,  33,  34,  35,  35,  35,  37,  38,  39,  39,  39,  40,  42,  42,  42,  42,  44,  46,  47,  47,  47,  47,
+             31,  31,  31,  31,  31,  31,  32,  32,  32,  32,  32,  33,  35,  36,  36,  36,  37,  39,  40,  40,  40,  41,  42,  43,  43,  43,  44,  46,  46,  46,  46,  46,
+             33,  33,  34,  34,  34,  34,  34,  34,  35,  35,  35,  36,  37,  38,  38,  38,  40,  42,  43,  43,  43,  43,  44,  44,  44,  44,  45,  46,  47,  47,  47,  47,
+             37,  37,  38,  38,  38,  38,  39,  39,  40,  40,  40,  41,  42,  43,  43,  43,  44,  46,  47,  47,  47,  47,  47,  47,  47,  47,  47,  48,  48,  48,  48,  47,
+             37,  37,  38,  38,  38,  38,  39,  39,  40,  40,  40,  41,  42,  43,  43,  43,  44,  46,  47,  47,  47,  47,  47,  47,  47,  47,  47,  48,  48,  48,  48,  47,
+             45,  45,  45,  45,  45,  45,  45,  44,  44,  44,  44,  45,  46,  46,  46,  46,  46,  47,  47,  47,  47,  48,  49,  49,  49,  49,  50,  51,  52,  52,  52,  52,
+             48,  48,  47,  47,  47,  47,  46,  46,  46,  46,  46,  46,  47,  47,  47,  47,  47,  47,  47,  47,  47,  48,  49,  50,  50,  50,  51,  52,  53,  53,  53,  53,
+        },
+    }, {
+        {
+             32,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  33,  34,  34,
+             31,  31,  31,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  33,  33,  34,  34,
+             31,  31,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  33,  33,  33,  33,  33,  33,  33,  34,  34,
+             31,  31,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  33,  33,  33,  33,  33,  33,  33,  34,  34,
+             31,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  33,  33,  33,  33,  33,  33,  33,  33,  33,  34,  34,  34,  34,  34,  34,  35,  35,
+             32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  33,  33,  33,  33,  33,  33,  34,  34,  34,  34,  34,  34,  35,  35,  35,  35,  35,  35,  36,  36,  37,  37,
+             32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  33,  33,  33,  33,  33,  33,  34,  34,  34,  34,  34,  34,  35,  35,  35,  35,  35,  35,  36,  36,  37,  37,
+             32,  33,  33,  33,  33,  33,  33,  33,  33,  33,  33,  33,  33,  33,  33,  34,  34,  34,  34,  34,  34,  35,  35,  36,  36,  36,  36,  36,  36,  37,  38,  38,
+        }, {
+             32,  31,  31,  31,  31,  31,  31,  31,  31,  30,  30,  30,  30,  30,  31,  32,  33,  33,  33,  33,  33,  34,  35,  36,  37,  37,  37,  37,  39,  40,  42,  42,
+             31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  32,  33,  34,  35,  35,  35,  35,  36,  37,  38,  39,  39,  39,  39,  40,  41,  42,  42,
+             31,  31,  31,  31,  31,  31,  31,  31,  32,  32,  32,  32,  32,  32,  33,  34,  35,  36,  36,  36,  36,  37,  38,  39,  40,  40,  40,  40,  41,  42,  43,  43,
+             31,  31,  31,  31,  31,  31,  31,  31,  32,  32,  32,  32,  32,  32,  33,  34,  35,  36,  36,  36,  36,  37,  38,  39,  40,  40,  40,  40,  41,  42,  43,  43,
+             33,  33,  33,  34,  34,  34,  34,  34,  34,  34,  35,  35,  35,  35,  35,  36,  37,  38,  38,  38,  38,  39,  41,  42,  43,  43,  43,  43,  43,  44,  44,  44,
+             37,  37,  38,  38,  38,  38,  38,  38,  39,  39,  40,  40,  40,  40,  40,  41,  42,  43,  43,  43,  43,  44,  45,  47,  47,  47,  47,  47,  47,  47,  47,  47,
+             37,  37,  38,  38,  38,  38,  38,  38,  39,  39,  40,  40,  40,  40,  40,  41,  42,  43,  43,  43,  43,  44,  45,  47,  47,  47,  47,  47,  47,  47,  47,  47,
+             38,  39,  39,  40,  40,  40,  40,  40,  40,  40,  41,  41,  41,  41,  41,  42,  43,  44,  44,  44,  44,  45,  46,  47,  47,  47,  47,  47,  47,  47,  48,  48,
+        },
+    }, {
+        {
+             32,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  32,  32,  32,  32,  32,  32,  32,
+             31,  31,  31,  31,  31,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,
+             31,  31,  31,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,
+             31,  31,  31,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,
+             31,  31,  31,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,
+             31,  31,  31,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,
+             31,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  33,  33,  33,  33,  33,  33,  33,  33,  33,  33,
+             32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  33,  33,  33,  33,  34,  34,  34,  34,  34,  34,  34,
+        }, {
+             32,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  30,  30,  30,  30,  30,  30,  30,  31,  31,  32,  33,  33,  33,  33,  33,  33,  33,  34,
+             31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  32,  33,  34,  34,  34,  34,  34,  34,  34,  35,
+             31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  32,  32,  32,  32,  32,  32,  32,  33,  34,  34,  35,  35,  35,  35,  35,  35,  36,
+             31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  32,  32,  32,  32,  32,  32,  32,  32,  32,  33,  33,  34,  35,  36,  36,  36,  36,  36,  36,  36,
+             31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  32,  32,  32,  32,  32,  32,  32,  32,  32,  33,  33,  34,  35,  36,  36,  36,  36,  36,  36,  36,
+             31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  32,  32,  32,  32,  32,  32,  32,  32,  32,  33,  33,  34,  35,  36,  36,  36,  36,  36,  36,  36,
+             33,  33,  33,  33,  34,  34,  34,  34,  34,  34,  34,  34,  34,  34,  34,  35,  35,  35,  35,  35,  35,  35,  36,  37,  37,  38,  38,  38,  38,  38,  38,  39,
+             35,  35,  36,  36,  36,  37,  37,  37,  37,  37,  37,  37,  37,  37,  38,  38,  38,  38,  38,  38,  38,  38,  39,  40,  40,  41,  41,  41,  41,  41,  41,  42,
+        },
+    }, {
+        {
+             32,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,
+             31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,
+             31,  31,  31,  31,  31,  31,  31,  31,  31,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,
+             31,  31,  31,  31,  31,  31,  31,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,
+             31,  31,  31,  31,  31,  31,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,
+             31,  31,  31,  31,  31,  31,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,
+             31,  31,  31,  31,  31,  31,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,
+             31,  31,  31,  31,  31,  31,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,
+        }, {
+             32,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  30,  30,  30,  30,  30,
+             31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,
+             31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,
+             31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,
+             31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  32,  32,  32,
+             31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  32,  32,  32,  32,  32,  32,  32,  32,  32,
+             31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  32,  32,  32,  32,  32,  32,  32,  32,  32,
+             31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  32,  32,  32,  32,  32,  32,  32,  32,  32,
+        },
+    },
+};
+
+static const uint8_t qm_tbl_32x16[][2][512] = {
+    {
+        {
+             32,  31,  31,  31,  32,  32,  34,  35,  36,  39,  44,  46,  48,  53,  58,  61,  65,  71,  79,  81,  82,  88,  91,  94,  97, 100, 103, 107, 110, 114, 118, 122,
+             31,  32,  32,  32,  32,  33,  34,  34,  34,  37,  41,  43,  45,  49,  54,  57,  60,  65,  72,  74,  75,  80,  83,  85,  88,  91,  94,  97, 101, 104, 108, 111,
+             32,  32,  33,  33,  34,  35,  37,  37,  38,  40,  43,  44,  46,  50,  54,  56,  58,  63,  70,  71,  72,  77,  80,  83,  86,  89,  93,  96, 100, 104, 107, 111,
+             34,  34,  33,  34,  35,  37,  39,  41,  43,  45,  48,  49,  51,  54,  58,  60,  63,  68,  74,  75,  76,  80,  81,  82,  85,  87,  90,  93,  97, 100, 103, 107,
+             36,  35,  34,  35,  36,  38,  42,  45,  48,  50,  53,  55,  56,  60,  63,  66,  68,  73,  79,  80,  81,  85,  88,  91,  94,  97,  98, 100, 101, 103, 105, 107,
+             44,  42,  41,  41,  42,  42,  48,  50,  54,  58,  63,  65,  67,  71,  75,  77,  79,  84,  90,  91,  92,  97, 100, 100, 100, 100, 101, 104, 108, 112, 115, 119,
+             53,  51,  49,  49,  50,  49,  54,  57,  60,  65,  71,  73,  76,  82,  87,  89,  92,  97, 104, 105, 106, 108, 106, 105, 107, 111, 114, 117, 117, 117, 118, 119,
+             59,  56,  54,  54,  54,  53,  58,  61,  64,  69,  75,  78,  80,  87,  92,  95,  98, 103, 110, 112, 113, 115, 114, 118, 123, 121, 120, 119, 123, 127, 131, 136,
+             65,  62,  59,  59,  59,  58,  63,  65,  68,  73,  79,  82,  85,  92,  98, 101, 105, 111, 118, 119, 121, 126, 130, 131, 128, 127, 131, 136, 138, 137, 136, 136,
+             79,  75,  72,  71,  71,  69,  73,  76,  78,  84,  90,  93,  96, 103, 110, 114, 118, 125, 133, 135, 136, 142, 142, 137, 140, 145, 144, 142, 141, 146, 151, 156,
+             87,  82,  78,  78,  77,  75,  79,  82,  84,  89,  95,  98, 102, 109, 116, 120, 124, 132, 141, 142, 144, 149, 148, 153, 157, 152, 150, 155, 161, 159, 157, 156,
+             90,  85,  82,  81,  80,  78,  78,  83,  87,  89,  93, 100, 102, 107, 115, 118, 123, 132, 136, 140, 151, 153, 155, 160, 161, 164, 170, 168, 165, 167, 172, 178,
+             93,  88,  86,  84,  82,  82,  80,  84,  86,  91,  94,  98, 105, 107, 112, 119, 122, 130, 135, 140, 149, 153, 162, 165, 167, 173, 174, 177, 183, 185, 182, 179,
+             96,  91,  90,  87,  86,  86,  83,  84,  89,  91,  95, 100, 102, 110, 111, 118, 123, 128, 135, 138, 149, 152, 160, 167, 173, 178, 180, 187, 188, 190, 197, 203,
+             99,  94,  93,  90,  89,  89,  88,  87,  90,  93,  97,  99, 105, 107, 115, 116, 124, 127, 135, 139, 146, 152, 159, 166, 171, 182, 186, 191, 193, 201, 203, 204,
+            102,  97,  97,  93,  93,  92,  92,  90,  90,  96,  97, 103, 104, 111, 112, 120, 121, 130, 131, 142, 143, 154, 155, 168, 169, 181, 183, 198, 200, 206, 208, 217,
+        }, {
+             32,  31,  30,  32,  33,  37,  42,  45,  49,  48,  49,  49,  50,  52,  54,  55,  57,  60,  63,  64,  64,  67,  68,  69,  70,  71,  72,  73,  74,  75,  76,  77,
+             31,  31,  32,  34,  36,  40,  43,  44,  46,  46,  45,  46,  46,  48,  50,  51,  52,  54,  57,  58,  59,  61,  62,  62,  63,  64,  65,  66,  67,  68,  69,  70,
+             37,  38,  40,  41,  43,  47,  47,  47,  48,  47,  46,  46,  46,  47,  49,  49,  50,  52,  55,  55,  56,  58,  59,  60,  62,  63,  64,  65,  67,  68,  69,  70,
+             42,  42,  42,  44,  45,  47,  48,  49,  50,  50,  49,  49,  50,  50,  52,  52,  53,  55,  58,  58,  58,  60,  60,  60,  60,  61,  62,  63,  64,  65,  66,  67,
+             48,  47,  46,  46,  47,  47,  50,  51,  53,  53,  53,  53,  54,  54,  55,  56,  56,  58,  60,  61,  61,  63,  64,  65,  66,  67,  66,  66,  66,  66,  67,  67,
+             49,  47,  45,  45,  46,  45,  49,  51,  53,  56,  58,  59,  59,  61,  62,  63,  64,  65,  67,  68,  68,  69,  71,  70,  69,  68,  68,  69,  70,  71,  72,  73,
+             52,  50,  48,  48,  47,  47,  50,  52,  54,  57,  61,  62,  64,  66,  68,  69,  70,  72,  75,  75,  75,  76,  74,  72,  73,  74,  75,  75,  74,  74,  73,  73,
+             54,  52,  50,  49,  49,  48,  52,  54,  55,  59,  62,  64,  65,  68,  71,  72,  73,  75,  78,  78,  79,  79,  78,  79,  81,  79,  78,  76,  77,  78,  80,  81,
+             57,  54,  52,  51,  51,  50,  53,  55,  57,  60,  64,  65,  67,  71,  73,  75,  76,  79,  82,  82,  83,  85,  86,  85,  83,  82,  83,  84,  84,  83,  82,  81,
+             63,  60,  57,  57,  56,  54,  57,  59,  60,  64,  67,  69,  71,  75,  78,  80,  82,  85,  89,  89,  90,  92,  91,  88,  89,  90,  89,  87,  86,  87,  88,  90,
+             66,  63,  60,  59,  59,  57,  60,  61,  62,  66,  69,  71,  73,  77,  80,  82,  84,  88,  92,  92,  93,  95,  94,  95,  96,  93,  92,  93,  94,  93,  91,  90,
+             67,  64,  62,  61,  60,  58,  58,  61,  63,  65,  67,  70,  72,  74,  78,  80,  82,  86,  88,  90,  95,  96,  96,  98,  97,  98, 100,  98,  96,  96,  97,  99,
+             68,  65,  63,  62,  60,  60,  59,  61,  62,  65,  66,  68,  72,  73,  76,  79,  80,  84,  87,  89,  93,  94,  98,  99,  99, 102, 101, 102, 103, 103, 101,  99,
+             69,  66,  65,  63,  62,  61,  60,  60,  63,  64,  66,  68,  70,  73,  74,  78,  80,  82,  85,  87,  91,  92,  96,  98, 101, 102, 103, 105, 105, 105, 107, 108,
+             71,  67,  66,  64,  63,  62,  62,  61,  62,  64,  66,  67,  70,  71,  75,  76,  79,  81,  84,  86,  89,  91,  94,  97,  98, 102, 104, 106, 106, 109, 109, 108,
+             72,  68,  68,  65,  65,  63,  63,  61,  62,  65,  65,  68,  69,  72,  73,  77,  77,  81,  81,  86,  87,  91,  91,  96,  97, 101, 102, 107, 107, 109, 110, 113,
+        },
+    }, {
+        {
+             32,  31,  31,  31,  32,  32,  32,  34,  36,  38,  39,  44,  47,  49,  53,  58,  61,  65,  71,  76,  79,  82,  86,  89,  92,  95,  98, 101, 104, 107, 110, 114,
+             31,  32,  32,  32,  32,  33,  33,  34,  34,  36,  37,  41,  44,  46,  49,  54,  56,  60,  65,  69,  72,  75,  78,  81,  84,  86,  89,  92,  95,  98, 101, 104,
+             32,  32,  32,  33,  34,  35,  35,  36,  37,  39,  40,  42,  45,  47,  50,  54,  56,  59,  64,  68,  70,  73,  76,  79,  82,  85,  88,  91,  94,  97, 100, 104,
+             32,  33,  33,  33,  34,  36,  36,  38,  40,  41,  42,  45,  47,  48,  51,  55,  57,  60,  65,  69,  71,  74,  77,  78,  80,  83,  85,  88,  91,  94,  97, 100,
+             36,  35,  35,  35,  36,  38,  40,  42,  48,  49,  50,  53,  56,  57,  60,  63,  65,  68,  73,  76,  79,  81,  84,  87,  89,  92,  93,  94,  95,  96,  98, 100,
+             44,  42,  41,  41,  42,  42,  44,  48,  54,  56,  58,  63,  66,  67,  71,  75,  77,  79,  84,  88,  90,  92,  95,  95,  95,  95,  95,  98, 101, 105, 108, 111,
+             47,  45,  44,  44,  45,  45,  47,  50,  56,  58,  60,  66,  69,  71,  75,  79,  81,  84,  89,  92,  95,  97, 100,  99, 101, 105, 108, 110, 110, 110, 111, 111,
+             53,  51,  49,  49,  50,  49,  51,  54,  60,  63,  65,  71,  75,  77,  82,  87,  89,  92,  97, 101, 104, 106, 109, 112, 116, 114, 113, 112, 115, 119, 123, 126,
+             65,  62,  60,  59,  59,  58,  60,  63,  68,  71,  73,  79,  84,  86,  92,  98, 100, 105, 111, 115, 118, 121, 124, 124, 121, 120, 124, 128, 129, 128, 127, 127,
+             73,  69,  67,  66,  65,  64,  66,  69,  74,  77,  79,  85,  90,  93,  99, 105, 107, 112, 119, 123, 127, 130, 133, 130, 132, 136, 136, 133, 132, 136, 141, 145,
+             79,  75,  72,  71,  71,  69,  71,  73,  78,  81,  84,  90,  95,  97, 103, 110, 113, 118, 125, 130, 133, 136, 140, 145, 148, 143, 141, 146, 151, 149, 147, 145,
+             87,  83,  80,  79,  78,  76,  76,  80,  84,  86,  90,  96,  99, 103, 111, 114, 118, 126, 130, 134, 143, 146, 147, 152, 151, 155, 160, 158, 154, 156, 161, 166,
+             90,  86,  84,  82,  80,  80,  78,  82,  83,  88,  91,  94, 101, 103, 108, 114, 116, 124, 129, 134, 142, 145, 153, 156, 157, 163, 163, 166, 171, 173, 169, 166,
+             93,  88,  87,  84,  83,  83,  81,  81,  86,  88,  92,  96,  98, 105, 107, 113, 117, 122, 129, 131, 141, 144, 151, 157, 163, 167, 169, 175, 175, 177, 183, 189,
+             96,  91,  90,  87,  87,  86,  85,  84,  87,  90,  94,  96, 101, 102, 110, 111, 118, 121, 129, 132, 138, 144, 150, 156, 161, 171, 174, 179, 181, 188, 188, 190,
+             99,  94,  94,  90,  90,  88,  89,  86,  87,  93,  93,  99,  99, 106, 107, 115, 116, 124, 125, 135, 136, 145, 146, 158, 159, 170, 171, 185, 186, 192, 193, 201,
+        }, {
+             32,  31,  30,  31,  33,  37,  39,  42,  49,  48,  48,  49,  50,  51,  52,  54,  55,  57,  60,  62,  63,  64,  66,  67,  68,  69,  70,  71,  72,  73,  74,  75,
+             31,  31,  32,  33,  36,  40,  41,  43,  46,  46,  46,  45,  46,  47,  48,  50,  51,  52,  54,  56,  57,  59,  60,  61,  62,  63,  64,  65,  65,  66,  67,  68,
+             35,  37,  38,  38,  41,  45,  46,  46,  48,  47,  46,  45,  46,  47,  47,  49,  49,  50,  53,  54,  55,  56,  58,  59,  60,  61,  62,  64,  65,  66,  67,  68,
+             38,  40,  40,  41,  44,  47,  47,  48,  49,  48,  48,  47,  48,  48,  48,  50,  50,  51,  53,  55,  56,  57,  58,  58,  59,  60,  60,  61,  62,  63,  64,  65,
+             48,  47,  46,  46,  47,  47,  48,  50,  53,  53,  53,  53,  54,  54,  54,  55,  56,  56,  58,  60,  60,  61,  62,  63,  64,  65,  65,  65,  65,  65,  65,  65,
+             49,  47,  45,  45,  46,  45,  47,  49,  53,  55,  56,  58,  59,  60,  61,  62,  63,  64,  65,  66,  67,  68,  69,  68,  67,  66,  66,  67,  68,  69,  70,  71,
+             50,  48,  46,  46,  46,  46,  47,  50,  54,  55,  56,  59,  61,  61,  63,  65,  65,  66,  68,  69,  70,  71,  72,  71,  71,  72,  73,  73,  72,  72,  71,  71,
+             52,  50,  48,  48,  47,  47,  48,  50,  54,  56,  57,  61,  63,  64,  66,  68,  69,  70,  72,  74,  75,  75,  76,  78,  79,  77,  76,  74,  75,  76,  77,  78,
+             57,  54,  52,  52,  51,  50,  51,  53,  57,  58,  60,  64,  66,  68,  71,  73,  74,  76,  79,  81,  82,  83,  84,  83,  81,  80,  81,  82,  82,  81,  79,  78,
+             61,  57,  55,  55,  54,  52,  54,  56,  59,  61,  62,  66,  68,  70,  73,  76,  77,  79,  82,  84,  86,  87,  88,  86,  86,  88,  87,  85,  83,  85,  86,  87,
+             63,  60,  58,  57,  56,  54,  55,  57,  60,  62,  64,  67,  70,  71,  75,  78,  79,  82,  85,  87,  89,  90,  91,  93,  94,  91,  89,  90,  92,  90,  89,  87,
+             67,  63,  61,  60,  59,  57,  57,  60,  63,  64,  66,  69,  71,  73,  77,  79,  81,  85,  87,  88,  92,  93,  94,  96,  95,  96,  97,  95,  93,  93,  94,  96,
+             68,  64,  63,  61,  60,  59,  58,  60,  61,  64,  65,  67,  71,  72,  75,  78,  79,  83,  85,  87,  91,  92,  95,  96,  97,  99,  98,  99, 100, 100,  98,  96,
+             69,  65,  64,  62,  61,  61,  59,  59,  62,  63,  65,  67,  68,  72,  73,  76,  78,  81,  84,  85,  89,  90,  93,  96,  98,  99, 100, 102, 102, 102, 103, 105,
+             70,  66,  65,  63,  63,  62,  61,  60,  61,  63,  65,  66,  69,  70,  74,  74,  78,  79,  82,  84,  87,  89,  91,  94,  96, 100, 101, 103, 103, 105, 105, 105,
+             71,  67,  67,  64,  64,  62,  62,  60,  61,  64,  64,  67,  67,  71,  71,  75,  75,  79,  80,  84,  84,  89,  89,  94,  94,  98,  99, 104, 104, 106, 106, 109,
+        },
+    }, {
+        {
+             32,  31,  31,  31,  32,  32,  32,  34,  34,  36,  39,  40,  44,  47,  49,  53,  57,  59,  65,  69,  71,  79,  81,  82,  87,  90,  92,  95,  98, 100, 103, 106,
+             31,  32,  32,  32,  32,  32,  33,  34,  34,  34,  37,  38,  41,  44,  46,  49,  53,  54,  60,  63,  65,  72,  74,  75,  79,  82,  84,  87,  89,  92,  94,  97,
+             32,  32,  32,  32,  33,  34,  34,  35,  36,  37,  39,  40,  42,  45,  46,  50,  53,  54,  59,  62,  64,  71,  72,  73,  77,  80,  83,  85,  88,  91,  94,  97,
+             32,  32,  32,  33,  34,  34,  35,  37,  37,  38,  40,  41,  43,  46,  47,  50,  53,  54,  58,  62,  63,  70,  71,  72,  76,  78,  81,  83,  85,  88,  90,  93,
+             36,  35,  35,  34,  36,  37,  38,  42,  44,  48,  50,  51,  53,  56,  57,  60,  63,  64,  68,  71,  73,  79,  80,  81,  85,  87,  88,  88,  89,  90,  92,  93,
+             39,  38,  38,  37,  39,  40,  40,  45,  47,  51,  54,  55,  58,  61,  62,  65,  68,  69,  73,  76,  78,  84,  85,  86,  90,  89,  90,  92,  95,  98, 101, 104,
+             44,  42,  41,  41,  42,  42,  42,  48,  50,  54,  58,  59,  63,  66,  67,  71,  74,  75,  79,  83,  84,  90,  91,  92,  96,  99, 102, 103, 103, 103, 103, 104,
+             53,  51,  50,  49,  50,  49,  49,  54,  56,  60,  65,  67,  71,  75,  77,  82,  86,  87,  92,  96,  97, 104, 105, 106, 110, 108, 106, 105, 108, 111, 114, 118,
+             58,  55,  54,  53,  53,  53,  52,  57,  59,  63,  68,  70,  74,  79,  81,  86,  90,  91,  97, 100, 102, 109, 110, 111, 114, 113, 117, 120, 121, 120, 119, 118,
+             65,  62,  60,  59,  59,  58,  58,  63,  65,  68,  73,  75,  79,  85,  86,  92,  97,  98, 105, 109, 111, 118, 120, 121, 125, 129, 128, 125, 124, 127, 131, 135,
+             79,  75,  73,  72,  71,  70,  69,  73,  75,  78,  84,  85,  90,  95,  97, 103, 108, 111, 118, 122, 125, 133, 135, 136, 140, 135, 133, 137, 141, 139, 137, 135,
+             81,  77,  75,  74,  72,  71,  70,  75,  77,  80,  85,  87,  91,  97,  99, 105, 110, 112, 119, 124, 127, 135, 137, 139, 143, 146, 150, 148, 144, 146, 150, 154,
+             88,  83,  81,  79,  78,  77,  76,  79,  81,  85,  88,  91,  97,  99, 104, 109, 111, 119, 123, 127, 135, 137, 145, 147, 148, 153, 153, 155, 160, 161, 158, 155,
+             90,  86,  84,  82,  81,  80,  78,  79,  83,  85,  89,  92,  94, 101, 102, 108, 112, 117, 123, 125, 134, 136, 143, 148, 154, 157, 158, 164, 164, 165, 170, 175,
+             93,  88,  88,  84,  84,  83,  82,  81,  84,  86,  90,  92,  97,  98, 105, 106, 113, 115, 122, 125, 131, 136, 141, 147, 151, 160, 163, 168, 169, 175, 175, 176,
+             96,  91,  91,  87,  87,  85,  86,  83,  84,  89,  89,  95,  95, 102, 102, 110, 110, 118, 119, 128, 129, 137, 138, 149, 149, 159, 160, 173, 174, 179, 180, 187,
+        }, {
+             32,  31,  31,  30,  33,  35,  37,  42,  44,  49,  48,  48,  49,  50,  51,  52,  54,  54,  57,  59,  60,  63,  64,  64,  66,  67,  68,  69,  70,  71,  72,  73,
+             31,  31,  32,  32,  36,  38,  40,  43,  44,  46,  46,  45,  45,  46,  47,  48,  49,  50,  52,  54,  54,  57,  58,  59,  60,  61,  62,  63,  64,  65,  65,  66,
+             34,  35,  36,  36,  40,  42,  44,  45,  46,  47,  46,  46,  45,  46,  47,  47,  49,  49,  51,  52,  53,  56,  57,  57,  59,  60,  61,  62,  63,  64,  65,  66,
+             37,  38,  39,  40,  43,  45,  47,  47,  47,  48,  47,  46,  46,  46,  47,  47,  48,  49,  50,  52,  52,  55,  55,  56,  57,  58,  59,  60,  60,  61,  62,  63,
+             48,  47,  46,  46,  47,  47,  47,  50,  51,  53,  53,  53,  53,  54,  54,  54,  55,  55,  56,  58,  58,  60,  61,  61,  63,  63,  63,  63,  63,  63,  63,  63,
+             48,  47,  46,  45,  46,  46,  46,  50,  51,  53,  54,  55,  56,  56,  57,  57,  58,  59,  60,  61,  62,  64,  64,  65,  66,  65,  64,  65,  66,  67,  68,  69,
+             49,  47,  46,  45,  46,  45,  45,  49,  51,  53,  56,  56,  58,  59,  60,  61,  62,  62,  64,  65,  65,  67,  68,  68,  69,  70,  71,  71,  70,  70,  69,  69,
+             52,  50,  48,  48,  47,  47,  47,  50,  52,  54,  57,  58,  61,  63,  64,  66,  68,  68,  70,  72,  72,  75,  75,  75,  77,  75,  74,  72,  73,  74,  75,  76,
+             54,  51,  50,  49,  49,  48,  48,  51,  53,  55,  58,  59,  62,  65,  65,  68,  70,  70,  73,  74,  75,  77,  78,  78,  79,  78,  79,  80,  80,  78,  77,  76,
+             57,  54,  53,  52,  51,  50,  50,  53,  54,  57,  60,  61,  64,  66,  68,  71,  73,  74,  76,  78,  79,  82,  82,  83,  84,  85,  84,  82,  81,  82,  83,  84,
+             63,  60,  58,  57,  56,  55,  54,  57,  59,  60,  64,  65,  67,  70,  71,  75,  77,  78,  82,  84,  85,  89,  89,  90,  91,  88,  87,  88,  89,  88,  86,  84,
+             64,  61,  59,  58,  57,  56,  55,  58,  59,  61,  64,  65,  68,  71,  72,  75,  78,  79,  82,  85,  86,  90,  90,  91,  93,  93,  94,  93,  90,  90,  92,  93,
+             67,  63,  62,  60,  59,  58,  57,  59,  60,  63,  64,  66,  70,  70,  73,  76,  77,  81,  83,  85,  89,  90,  93,  94,  94,  96,  96,  96,  97,  97,  95,  93,
+             68,  64,  63,  61,  60,  60,  58,  58,  61,  62,  64,  66,  67,  71,  71,  75,  77,  79,  82,  83,  87,  88,  91,  93,  95,  97,  97,  99,  99,  99, 100, 101,
+             69,  65,  65,  62,  62,  61,  60,  59,  61,  62,  64,  65,  68,  68,  72,  73,  76,  77,  81,  82,  85,  87,  89,  92,  93,  97,  98, 100, 100, 102, 102, 101,
+             69,  66,  66,  63,  63,  61,  61,  59,  60,  63,  63,  66,  66,  70,  70,  73,  74,  78,  78,  82,  82,  86,  87,  91,  91,  95,  96, 101, 101, 103, 103, 105,
+        },
+    }, {
+        {
+             32,  31,  31,  31,  31,  32,  32,  32,  34,  35,  36,  39,  41,  44,  47,  48,  53,  55,  58,  63,  65,  71,  74,  79,  82,  82,  87,  89,  92,  94,  97,  99,
+             31,  32,  32,  32,  32,  32,  33,  33,  34,  34,  34,  37,  39,  41,  44,  45,  49,  51,  54,  58,  60,  65,  68,  72,  75,  75,  79,  82,  84,  86,  88,  91,
+             31,  32,  32,  32,  33,  33,  34,  34,  35,  36,  36,  39,  40,  42,  44,  45,  50,  51,  54,  58,  59,  64,  67,  71,  73,  74,  78,  81,  83,  85,  88,  91,
+             32,  32,  32,  33,  34,  34,  35,  36,  37,  38,  38,  40,  41,  43,  45,  46,  50,  51,  54,  57,  58,  63,  66,  70,  72,  72,  76,  78,  80,  82,  85,  87,
+             35,  35,  34,  34,  35,  36,  37,  39,  41,  45,  46,  48,  49,  51,  53,  54,  57,  59,  61,  65,  66,  71,  73,  77,  79,  79,  83,  83,  84,  85,  86,  87,
+             36,  35,  35,  34,  36,  36,  38,  40,  42,  47,  48,  50,  51,  53,  56,  56,  60,  61,  63,  67,  68,  73,  75,  79,  81,  81,  85,  87,  89,  92,  94,  97,
+             44,  42,  41,  41,  42,  42,  42,  44,  48,  52,  54,  58,  60,  63,  66,  67,  71,  72,  75,  78,  79,  84,  86,  90,  92,  92,  96,  97,  97,  97,  97,  97,
+             47,  45,  45,  44,  44,  45,  45,  47,  50,  55,  56,  60,  62,  66,  69,  70,  75,  77,  79,  83,  84,  89,  91,  95,  97,  97, 100,  99, 101, 104, 107, 110,
+             53,  51,  50,  49,  49,  50,  49,  51,  54,  59,  60,  65,  67,  71,  75,  76,  82,  84,  87,  91,  92,  97, 100, 104, 105, 106, 110, 113, 114, 112, 111, 110,
+             62,  59,  58,  57,  57,  57,  56,  58,  61,  65,  66,  71,  74,  78,  82,  83,  90,  92,  95, 100, 102, 108, 110, 115, 117, 117, 120, 118, 116, 119, 123, 126,
+             65,  62,  61,  59,  59,  59,  58,  60,  63,  67,  68,  73,  76,  79,  84,  85,  92,  94,  98, 103, 105, 111, 113, 118, 120, 121, 125, 128, 132, 130, 128, 126,
+             79,  75,  74,  72,  71,  71,  69,  71,  73,  77,  78,  84,  86,  90,  95,  96, 103, 106, 110, 116, 118, 125, 128, 133, 136, 136, 141, 139, 135, 136, 140, 144,
+             82,  78,  76,  74,  73,  73,  71,  73,  76,  79,  80,  86,  88,  92,  97,  98, 106, 108, 112, 118, 120, 127, 131, 136, 139, 139, 144, 145, 150, 151, 147, 144,
+             88,  83,  82,  79,  79,  78,  76,  76,  81,  82,  85,  89,  91,  97,  98, 104, 107, 111, 117, 119, 127, 129, 135, 140, 145, 148, 148, 153, 153, 154, 159, 163,
+             90,  86,  85,  82,  81,  80,  79,  78,  81,  83,  87,  88,  93,  94, 101, 101, 108, 110, 116, 119, 124, 129, 134, 139, 142, 150, 153, 157, 157, 163, 163, 163,
+             93,  88,  88,  84,  84,  82,  83,  80,  80,  86,  86,  91,  91,  97,  98, 105, 105, 112, 113, 121, 122, 130, 130, 140, 140, 149, 150, 161, 162, 166, 167, 173,
+        }, {
+             32,  31,  31,  30,  33,  33,  37,  39,  42,  47,  49,  48,  48,  49,  50,  50,  52,  53,  54,  56,  57,  60,  61,  63,  64,  64,  66,  67,  68,  69,  70,  70,
+             31,  31,  32,  32,  35,  36,  40,  41,  43,  46,  46,  46,  45,  45,  46,  46,  48,  49,  50,  51,  52,  54,  56,  57,  58,  59,  60,  61,  62,  63,  63,  64,
+             33,  34,  34,  35,  37,  38,  43,  43,  44,  46,  47,  46,  46,  45,  46,  46,  47,  48,  49,  51,  51,  54,  55,  56,  57,  58,  59,  60,  61,  62,  63,  64,
+             37,  38,  39,  40,  42,  43,  47,  47,  47,  48,  48,  47,  46,  46,  46,  46,  47,  48,  49,  50,  50,  52,  53,  55,  56,  56,  57,  58,  59,  59,  60,  61,
+             45,  45,  45,  44,  46,  46,  47,  48,  49,  51,  52,  51,  51,  51,  52,  52,  53,  53,  54,  55,  55,  57,  58,  59,  60,  60,  61,  61,  61,  61,  61,  61,
+             48,  47,  46,  46,  47,  47,  47,  48,  50,  52,  53,  53,  53,  53,  54,  54,  54,  55,  55,  56,  56,  58,  59,  60,  61,  61,  63,  63,  64,  65,  66,  67,
+             49,  47,  46,  45,  45,  46,  45,  47,  49,  53,  53,  56,  57,  58,  59,  59,  61,  61,  62,  63,  64,  65,  66,  67,  68,  68,  69,  69,  68,  68,  67,  67,
+             50,  48,  47,  46,  46,  46,  46,  47,  50,  53,  54,  56,  57,  59,  61,  61,  63,  64,  65,  66,  66,  68,  69,  70,  71,  71,  72,  70,  71,  72,  73,  74,
+             52,  50,  49,  48,  47,  47,  47,  48,  50,  53,  54,  57,  59,  61,  63,  64,  66,  67,  68,  70,  70,  72,  73,  75,  75,  75,  77,  78,  77,  76,  75,  74,
+             56,  53,  52,  51,  50,  50,  49,  50,  53,  55,  56,  59,  61,  63,  65,  66,  70,  71,  72,  74,  75,  77,  79,  80,  81,  81,  82,  80,  79,  80,  81,  82,
+             57,  54,  53,  52,  51,  51,  50,  51,  53,  56,  57,  60,  61,  64,  66,  67,  71,  72,  73,  76,  76,  79,  80,  82,  83,  83,  84,  85,  86,  85,  83,  82,
+             63,  60,  59,  57,  56,  56,  54,  55,  57,  60,  60,  64,  65,  67,  70,  71,  75,  76,  78,  81,  82,  85,  86,  89,  90,  90,  92,  90,  88,  88,  89,  90,
+             64,  61,  60,  58,  57,  57,  55,  56,  58,  61,  61,  64,  66,  68,  71,  71,  75,  77,  79,  82,  83,  86,  87,  90,  91,  91,  93,  93,  94,  94,  92,  90,
+             67,  63,  62,  60,  60,  59,  57,  57,  60,  61,  63,  65,  66,  70,  70,  73,  75,  77,  80,  81,  85,  86,  89,  91,  93,  94,  94,  96,  96,  95,  97,  98,
+             68,  64,  64,  61,  61,  60,  59,  58,  60,  61,  63,  64,  67,  67,  71,  71,  74,  75,  79,  80,  83,  85,  87,  89,  91,  94,  95,  97,  97,  99,  98,  98,
+             68,  65,  65,  62,  62,  60,  61,  59,  59,  62,  62,  65,  65,  68,  68,  72,  72,  76,  76,  80,  80,  84,  84,  89,  89,  93,  93,  97,  98,  99,  99, 102,
+        },
+    }, {
+        {
+             32,  31,  31,  31,  31,  32,  32,  32,  33,  34,  36,  36,  39,  40,  44,  46,  48,  52,  53,  58,  58,  65,  66,  71,  74,  79,  81,  82,  86,  88,  91,  93,
+             31,  32,  32,  32,  32,  32,  32,  33,  33,  34,  34,  35,  37,  38,  41,  43,  45,  48,  49,  53,  54,  60,  61,  65,  68,  72,  74,  75,  78,  81,  83,  85,
+             31,  32,  32,  32,  32,  33,  33,  33,  34,  34,  35,  35,  38,  39,  41,  43,  45,  48,  49,  53,  54,  59,  60,  65,  67,  72,  73,  74,  78,  80,  82,  85,
+             32,  32,  32,  33,  33,  34,  35,  35,  36,  37,  38,  38,  40,  41,  43,  44,  46,  49,  50,  53,  54,  58,  59,  63,  66,  70,  71,  72,  75,  77,  79,  81,
+             33,  33,  33,  33,  34,  35,  36,  36,  38,  39,  42,  42,  44,  45,  46,  48,  50,  52,  53,  57,  57,  62,  63,  67,  69,  73,  75,  75,  78,  80,  80,  81,
+             36,  35,  35,  34,  35,  36,  37,  38,  41,  42,  48,  48,  50,  51,  53,  55,  56,  59,  60,  63,  63,  68,  69,  73,  75,  79,  80,  81,  84,  86,  88,  90,
+             40,  39,  39,  38,  38,  39,  40,  41,  44,  45,  51,  51,  54,  56,  59,  60,  62,  65,  66,  69,  70,  74,  75,  79,  81,  85,  86,  87,  90,  90,  90,  90,
+             44,  42,  42,  41,  41,  42,  42,  42,  46,  48,  54,  54,  58,  59,  63,  65,  67,  70,  71,  74,  75,  79,  80,  84,  86,  90,  91,  92,  95,  98, 100, 102,
+             51,  49,  49,  47,  47,  48,  48,  48,  52,  53,  58,  59,  63,  65,  69,  72,  74,  78,  79,  83,  84,  89,  90,  94,  97, 101, 102, 103, 106, 105, 103, 103,
+             53,  51,  51,  49,  49,  50,  49,  49,  53,  54,  60,  60,  65,  67,  71,  73,  76,  80,  82,  86,  87,  92,  93,  97, 100, 104, 105, 106, 109, 112, 114, 117,
+             65,  62,  61,  59,  59,  59,  58,  58,  62,  63,  68,  68,  73,  75,  79,  82,  85,  90,  92,  97,  98, 105, 106, 111, 113, 118, 120, 121, 124, 122, 119, 117,
+             66,  63,  62,  60,  60,  60,  59,  59,  63,  64,  69,  69,  74,  76,  80,  83,  86,  91,  93,  98,  99, 106, 107, 112, 115, 119, 121, 122, 125, 127, 130, 134,
+             79,  75,  74,  72,  71,  71,  69,  69,  72,  73,  78,  79,  84,  85,  90,  93,  96, 101, 103, 109, 110, 118, 119, 125, 128, 133, 135, 136, 140, 140, 137, 134,
+             81,  77,  76,  74,  73,  72,  71,  70,  74,  75,  80,  80,  85,  87,  91,  94,  98, 103, 105, 111, 112, 119, 121, 127, 130, 135, 137, 139, 142, 144, 148, 151,
+             87,  83,  82,  79,  79,  78,  77,  75,  78,  80,  84,  85,  89,  90,  96,  97, 103, 105, 111, 113, 118, 122, 126, 131, 134, 141, 143, 147, 147, 152, 151, 152,
+             90,  85,  85,  81,  81,  80,  80,  77,  78,  83,  83,  87,  88,  93,  93, 100, 100, 107, 107, 115, 115, 123, 123, 132, 132, 140, 140, 151, 151, 155, 155, 160,
+        }, {
+             32,  31,  31,  30,  31,  33,  35,  37,  41,  42,  49,  49,  48,  48,  49,  49,  50,  51,  52,  54,  54,  57,  57,  60,  61,  63,  64,  64,  66,  67,  68,  68,
+             31,  31,  31,  32,  33,  36,  38,  40,  42,  43,  46,  46,  46,  45,  45,  46,  46,  47,  48,  50,  50,  52,  52,  54,  56,  57,  58,  59,  60,  61,  62,  62,
+             32,  33,  33,  33,  35,  37,  39,  41,  43,  43,  47,  47,  46,  46,  45,  46,  46,  47,  48,  49,  50,  52,  52,  54,  55,  57,  58,  58,  59,  60,  61,  62,
+             37,  38,  38,  40,  41,  43,  45,  47,  47,  47,  48,  48,  47,  46,  46,  46,  46,  47,  47,  48,  49,  50,  51,  52,  53,  55,  55,  56,  57,  58,  58,  59,
+             40,  41,  41,  42,  43,  44,  46,  47,  48,  48,  50,  50,  49,  49,  48,  49,  49,  49,  50,  51,  51,  52,  53,  55,  56,  57,  58,  58,  59,  59,  59,  59,
+             48,  47,  47,  46,  46,  47,  47,  47,  49,  50,  53,  53,  53,  53,  53,  53,  54,  54,  54,  55,  55,  56,  57,  58,  59,  60,  61,  61,  62,  63,  64,  65,
+             49,  47,  47,  45,  46,  46,  46,  46,  49,  49,  53,  53,  54,  55,  56,  57,  57,  58,  58,  59,  59,  60,  61,  62,  63,  64,  65,  65,  66,  66,  65,  65,
+             49,  47,  47,  45,  45,  46,  45,  45,  48,  49,  53,  54,  56,  56,  58,  59,  59,  61,  61,  62,  62,  64,  64,  65,  66,  67,  68,  68,  69,  70,  71,  71,
+             51,  49,  49,  47,  47,  47,  47,  46,  49,  50,  54,  54,  57,  58,  61,  62,  63,  64,  65,  67,  67,  69,  69,  71,  72,  73,  73,  74,  75,  74,  72,  71,
+             52,  50,  49,  48,  48,  47,  47,  47,  50,  50,  54,  55,  57,  58,  61,  62,  64,  66,  66,  68,  68,  70,  71,  72,  73,  75,  75,  75,  76,  77,  78,  79,
+             57,  54,  54,  52,  51,  51,  50,  50,  52,  53,  57,  57,  60,  61,  64,  65,  67,  69,  71,  73,  73,  76,  77,  79,  80,  82,  82,  83,  84,  82,  81,  79,
+             58,  55,  54,  52,  52,  52,  51,  50,  53,  54,  57,  57,  60,  61,  64,  66,  67,  70,  71,  73,  74,  77,  77,  79,  81,  82,  83,  83,  85,  85,  86,  87,
+             63,  60,  59,  57,  57,  56,  55,  54,  57,  57,  60,  61,  64,  65,  67,  69,  71,  73,  75,  77,  78,  82,  82,  85,  86,  89,  89,  90,  91,  91,  89,  87,
+             64,  61,  60,  58,  57,  57,  56,  55,  57,  58,  61,  61,  64,  65,  68,  69,  71,  74,  75,  78,  78,  82,  83,  86,  87,  90,  90,  91,  92,  93,  94,  95,
+             67,  63,  63,  60,  60,  59,  58,  57,  59,  60,  62,  63,  65,  66,  69,  70,  73,  74,  77,  78,  81,  83,  85,  87,  88,  92,  92,  94,  94,  96,  95,  95,
+             67,  64,  64,  61,  61,  60,  60,  58,  58,  61,  61,  64,  64,  67,  67,  70,  71,  74,  74,  78,  78,  82,  82,  86,  86,  90,  90,  95,  95,  96,  96,  98,
+        },
+    }, {
+        {
+             32,  31,  31,  31,  31,  32,  32,  32,  32,  34,  34,  36,  36,  39,  39,  44,  44,  48,  48,  53,  53,  58,  58,  65,  65,  71,  71,  79,  79,  82,  82,  87,
+             31,  32,  32,  32,  32,  32,  32,  33,  33,  34,  34,  34,  34,  37,  37,  41,  41,  45,  45,  49,  49,  54,  54,  60,  60,  65,  65,  72,  72,  75,  75,  79,
+             31,  32,  32,  32,  32,  32,  32,  33,  33,  34,  34,  34,  34,  37,  37,  41,  41,  45,  45,  49,  49,  54,  54,  60,  60,  65,  65,  72,  72,  75,  75,  79,
+             32,  32,  32,  33,  33,  34,  34,  35,  35,  37,  37,  38,  38,  40,  40,  43,  43,  46,  46,  50,  50,  54,  54,  58,  58,  63,  63,  70,  70,  72,  72,  76,
+             32,  32,  32,  33,  33,  34,  34,  35,  35,  37,  37,  38,  38,  40,  40,  43,  43,  46,  46,  50,  50,  54,  54,  58,  58,  63,  63,  70,  70,  72,  72,  76,
+             36,  35,  35,  34,  34,  36,  36,  38,  38,  42,  42,  48,  48,  50,  50,  53,  53,  56,  56,  60,  60,  63,  63,  68,  68,  73,  73,  79,  79,  81,  81,  84,
+             36,  35,  35,  34,  34,  36,  36,  38,  38,  42,  42,  48,  48,  50,  50,  53,  53,  56,  56,  60,  60,  63,  63,  68,  68,  73,  73,  79,  79,  81,  81,  84,
+             44,  42,  42,  41,  41,  42,  42,  42,  42,  48,  48,  54,  54,  58,  58,  63,  63,  67,  67,  71,  71,  75,  75,  79,  79,  84,  84,  90,  90,  92,  92,  96,
+             44,  42,  42,  41,  41,  42,  42,  42,  42,  48,  48,  54,  54,  58,  58,  63,  63,  67,  67,  71,  71,  75,  75,  79,  79,  84,  84,  90,  90,  92,  92,  96,
+             53,  51,  51,  49,  49,  50,  50,  49,  49,  54,  54,  60,  60,  65,  65,  71,  71,  76,  76,  82,  82,  87,  87,  92,  92,  97,  97, 104, 104, 106, 106, 109,
+             53,  51,  51,  49,  49,  50,  50,  49,  49,  54,  54,  60,  60,  65,  65,  71,  71,  76,  76,  82,  82,  87,  87,  92,  92,  97,  97, 104, 104, 106, 106, 109,
+             65,  62,  62,  59,  59,  59,  59,  58,  58,  63,  63,  68,  68,  73,  73,  79,  79,  85,  85,  92,  92,  98,  98, 105, 105, 111, 111, 118, 118, 121, 121, 124,
+             65,  62,  62,  59,  59,  59,  59,  58,  58,  63,  63,  68,  68,  73,  73,  79,  79,  85,  85,  92,  92,  98,  98, 105, 105, 111, 111, 118, 118, 121, 121, 124,
+             79,  75,  75,  72,  72,  71,  71,  69,  69,  73,  73,  78,  78,  84,  84,  90,  90,  96,  96, 103, 103, 110, 110, 118, 118, 125, 125, 133, 133, 136, 136, 141,
+             79,  75,  75,  72,  72,  71,  71,  69,  69,  73,  73,  78,  78,  84,  84,  90,  90,  96,  96, 103, 103, 110, 110, 118, 118, 125, 125, 133, 133, 136, 136, 141,
+             87,  82,  82,  78,  78,  77,  77,  75,  75,  79,  79,  84,  84,  89,  89,  95,  95, 102, 102, 109, 109, 116, 116, 124, 124, 132, 132, 141, 141, 144, 144, 149,
+        }, {
+             32,  31,  31,  30,  30,  33,  33,  37,  37,  42,  42,  49,  49,  48,  48,  49,  49,  50,  50,  52,  52,  54,  54,  57,  57,  60,  60,  63,  63,  64,  64,  66,
+             31,  31,  31,  32,  32,  36,  36,  40,  40,  43,  43,  46,  46,  46,  46,  45,  45,  46,  46,  48,  48,  50,  50,  52,  52,  54,  54,  57,  57,  59,  59,  60,
+             31,  31,  31,  32,  32,  36,  36,  40,  40,  43,  43,  46,  46,  46,  46,  45,  45,  46,  46,  48,  48,  50,  50,  52,  52,  54,  54,  57,  57,  59,  59,  60,
+             37,  38,  38,  40,  40,  43,  43,  47,  47,  47,  47,  48,  48,  47,  47,  46,  46,  46,  46,  47,  47,  49,  49,  50,  50,  52,  52,  55,  55,  56,  56,  57,
+             37,  38,  38,  40,  40,  43,  43,  47,  47,  47,  47,  48,  48,  47,  47,  46,  46,  46,  46,  47,  47,  49,  49,  50,  50,  52,  52,  55,  55,  56,  56,  57,
+             48,  47,  47,  46,  46,  47,  47,  47,  47,  50,  50,  53,  53,  53,  53,  53,  53,  54,  54,  54,  54,  55,  55,  56,  56,  58,  58,  60,  60,  61,  61,  63,
+             48,  47,  47,  46,  46,  47,  47,  47,  47,  50,  50,  53,  53,  53,  53,  53,  53,  54,  54,  54,  54,  55,  55,  56,  56,  58,  58,  60,  60,  61,  61,  63,
+             49,  47,  47,  45,  45,  46,  46,  45,  45,  49,  49,  53,  53,  56,  56,  58,  58,  59,  59,  61,  61,  62,  62,  64,  64,  65,  65,  67,  67,  68,  68,  69,
+             49,  47,  47,  45,  45,  46,  46,  45,  45,  49,  49,  53,  53,  56,  56,  58,  58,  59,  59,  61,  61,  62,  62,  64,  64,  65,  65,  67,  67,  68,  68,  69,
+             52,  50,  50,  48,  48,  47,  47,  47,  47,  50,  50,  54,  54,  57,  57,  61,  61,  64,  64,  66,  66,  68,  68,  70,  70,  72,  72,  75,  75,  75,  75,  77,
+             52,  50,  50,  48,  48,  47,  47,  47,  47,  50,  50,  54,  54,  57,  57,  61,  61,  64,  64,  66,  66,  68,  68,  70,  70,  72,  72,  75,  75,  75,  75,  77,
+             57,  54,  54,  52,  52,  51,  51,  50,  50,  53,  53,  57,  57,  60,  60,  64,  64,  67,  67,  71,  71,  73,  73,  76,  76,  79,  79,  82,  82,  83,  83,  84,
+             57,  54,  54,  52,  52,  51,  51,  50,  50,  53,  53,  57,  57,  60,  60,  64,  64,  67,  67,  71,  71,  73,  73,  76,  76,  79,  79,  82,  82,  83,  83,  84,
+             63,  60,  60,  57,  57,  56,  56,  54,  54,  57,  57,  60,  60,  64,  64,  67,  67,  71,  71,  75,  75,  78,  78,  82,  82,  85,  85,  89,  89,  90,  90,  92,
+             63,  60,  60,  57,  57,  56,  56,  54,  54,  57,  57,  60,  60,  64,  64,  67,  67,  71,  71,  75,  75,  78,  78,  82,  82,  85,  85,  89,  89,  90,  90,  92,
+             66,  63,  63,  60,  60,  59,  59,  57,  57,  60,  60,  62,  62,  66,  66,  69,  69,  73,  73,  77,  77,  80,  80,  84,  84,  88,  88,  92,  92,  93,  93,  95,
+        },
+    }, {
+        {
+             32,  31,  31,  31,  31,  31,  32,  32,  32,  32,  34,  34,  35,  36,  38,  39,  41,  44,  44,  48,  48,  53,  53,  57,  58,  61,  65,  67,  71,  72,  79,  79,
+             31,  32,  32,  32,  32,  32,  32,  32,  32,  33,  34,  34,  34,  35,  36,  38,  39,  41,  42,  45,  45,  49,  50,  53,  54,  57,  60,  62,  66,  66,  73,  73,
+             31,  32,  32,  32,  32,  32,  32,  32,  33,  33,  34,  34,  34,  34,  36,  37,  39,  41,  42,  45,  45,  49,  49,  52,  54,  57,  60,  61,  65,  66,  72,  72,
+             32,  32,  32,  32,  32,  33,  33,  34,  34,  34,  36,  36,  37,  37,  38,  40,  41,  42,  43,  46,  46,  49,  50,  52,  54,  56,  59,  60,  64,  64,  71,  71,
+             32,  32,  32,  32,  33,  33,  34,  34,  35,  35,  37,  37,  38,  38,  40,  40,  41,  43,  43,  46,  46,  49,  50,  52,  54,  56,  58,  60,  63,  64,  70,  70,
+             34,  34,  34,  33,  33,  34,  35,  35,  37,  37,  39,  39,  42,  43,  44,  45,  46,  48,  48,  51,  51,  54,  54,  57,  58,  60,  63,  64,  68,  68,  74,  74,
+             36,  35,  35,  35,  34,  35,  36,  37,  38,  39,  42,  42,  47,  48,  49,  50,  51,  53,  54,  56,  56,  59,  60,  62,  63,  66,  68,  69,  73,  73,  79,  79,
+             38,  37,  37,  36,  36,  37,  38,  38,  39,  40,  44,  44,  48,  49,  51,  52,  54,  56,  56,  59,  59,  62,  63,  65,  67,  69,  71,  72,  76,  76,  82,  82,
+             44,  42,  42,  41,  41,  41,  42,  42,  42,  43,  48,  48,  52,  54,  56,  58,  60,  63,  64,  67,  67,  71,  71,  74,  75,  77,  79,  81,  84,  85,  90,  90,
+             44,  43,  43,  42,  41,  42,  43,  43,  43,  44,  48,  48,  53,  54,  57,  58,  60,  64,  64,  67,  67,  71,  72,  75,  76,  78,  80,  82,  85,  86,  91,  91,
+             53,  51,  51,  50,  49,  49,  50,  49,  49,  50,  54,  54,  59,  60,  63,  65,  67,  71,  72,  76,  76,  81,  82,  85,  87,  89,  92,  94,  97,  98, 104, 104,
+             53,  51,  51,  50,  49,  49,  50,  49,  49,  50,  54,  54,  59,  60,  63,  65,  67,  71,  72,  76,  76,  81,  82,  85,  87,  89,  92,  94,  97,  98, 104, 104,
+             62,  60,  59,  58,  57,  57,  57,  56,  56,  56,  61,  61,  65,  66,  69,  71,  74,  78,  79,  83,  83,  89,  90,  94,  95,  98, 102, 103, 108, 108, 115, 115,
+             65,  62,  62,  60,  59,  59,  59,  59,  58,  58,  63,  63,  67,  68,  71,  73,  76,  79,  81,  85,  85,  91,  92,  96,  98, 101, 105, 106, 111, 111, 118, 118,
+             73,  70,  69,  67,  66,  66,  65,  65,  64,  64,  69,  69,  73,  74,  77,  79,  81,  85,  86,  91,  91,  98,  99, 103, 105, 108, 112, 114, 119, 119, 127, 127,
+             79,  75,  75,  73,  72,  71,  71,  70,  69,  69,  73,  73,  77,  78,  81,  84,  86,  90,  91,  96,  96, 103, 103, 108, 110, 114, 118, 120, 125, 125, 133, 133,
+        }, {
+             32,  31,  31,  30,  30,  32,  33,  34,  37,  37,  42,  42,  47,  49,  48,  48,  48,  49,  49,  50,  50,  52,  52,  53,  54,  55,  57,  58,  60,  60,  63,  63,
+             31,  31,  31,  32,  32,  33,  35,  37,  40,  40,  43,  43,  46,  47,  46,  46,  46,  45,  46,  47,  47,  48,  48,  50,  50,  51,  52,  53,  55,  55,  58,  58,
+             31,  31,  31,  32,  32,  34,  36,  37,  40,  40,  43,  43,  46,  46,  46,  46,  45,  45,  45,  46,  46,  48,  48,  49,  50,  51,  52,  53,  54,  55,  57,  57,
+             35,  36,  36,  37,  37,  39,  40,  42,  45,  45,  46,  46,  47,  47,  47,  46,  46,  45,  46,  46,  46,  47,  47,  48,  49,  50,  51,  51,  53,  53,  56,  56,
+             37,  38,  38,  39,  40,  41,  43,  44,  47,  47,  47,  47,  48,  48,  47,  47,  46,  46,  46,  46,  46,  47,  47,  48,  49,  49,  50,  51,  52,  53,  55,  55,
+             42,  42,  42,  42,  42,  44,  45,  45,  47,  47,  48,  48,  50,  50,  50,  50,  49,  49,  49,  50,  50,  50,  50,  51,  52,  52,  53,  54,  55,  55,  58,  58,
+             48,  47,  47,  46,  46,  46,  47,  47,  47,  48,  50,  50,  52,  53,  53,  53,  53,  53,  53,  54,  54,  54,  54,  55,  55,  56,  56,  57,  58,  59,  60,  60,
+             48,  47,  47,  46,  46,  46,  46,  47,  47,  47,  50,  50,  52,  53,  53,  54,  54,  55,  55,  55,  55,  56,  56,  57,  57,  58,  58,  59,  60,  60,  62,  62,
+             49,  47,  47,  46,  45,  45,  46,  45,  45,  46,  49,  49,  53,  53,  55,  56,  57,  58,  58,  59,  59,  61,  61,  62,  62,  63,  64,  64,  65,  65,  67,  67,
+             49,  47,  47,  46,  45,  45,  46,  46,  46,  46,  49,  49,  53,  54,  55,  56,  57,  59,  59,  60,  60,  61,  61,  62,  63,  63,  64,  65,  66,  66,  68,  68,
+             52,  50,  50,  48,  48,  48,  47,  47,  47,  47,  50,  50,  53,  54,  56,  57,  59,  61,  62,  64,  64,  66,  66,  68,  68,  69,  70,  71,  72,  73,  75,  75,
+             52,  50,  50,  48,  48,  48,  47,  47,  47,  47,  50,  50,  53,  54,  56,  57,  59,  61,  62,  64,  64,  66,  66,  68,  68,  69,  70,  71,  72,  73,  75,  75,
+             56,  54,  53,  52,  51,  51,  50,  50,  49,  49,  53,  53,  55,  56,  58,  59,  61,  63,  64,  66,  66,  69,  70,  71,  72,  74,  75,  76,  77,  78,  80,  80,
+             57,  54,  54,  52,  52,  51,  51,  51,  50,  50,  53,  53,  56,  57,  58,  60,  61,  64,  64,  67,  67,  70,  71,  72,  73,  75,  76,  77,  79,  79,  82,  82,
+             61,  58,  57,  56,  55,  54,  54,  53,  52,  53,  56,  56,  58,  59,  61,  62,  63,  66,  66,  69,  69,  72,  73,  75,  76,  78,  79,  80,  82,  83,  86,  86,
+             63,  60,  60,  58,  57,  57,  56,  55,  54,  55,  57,  57,  60,  60,  62,  64,  65,  67,  68,  71,  71,  74,  75,  77,  78,  80,  82,  83,  85,  85,  89,  89,
+        },
+    }, {
+        {
+             32,  31,  31,  31,  31,  31,  31,  32,  32,  32,  32,  33,  34,  34,  36,  36,  38,  39,  41,  44,  44,  47,  48,  50,  53,  53,  57,  58,  61,  65,  65,  70,
+             31,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  33,  34,  34,  35,  35,  37,  38,  39,  41,  41,  44,  45,  47,  50,  50,  54,  55,  57,  61,  61,  65,
+             31,  32,  32,  32,  32,  32,  32,  32,  32,  33,  33,  33,  34,  34,  34,  34,  37,  37,  39,  41,  41,  44,  45,  46,  49,  49,  53,  54,  56,  60,  60,  64,
+             31,  32,  32,  32,  32,  32,  33,  33,  33,  34,  34,  35,  35,  35,  36,  36,  38,  39,  40,  42,  42,  44,  45,  47,  50,  50,  53,  54,  56,  59,  59,  63,
+             32,  32,  32,  32,  33,  33,  34,  34,  34,  35,  35,  36,  37,  37,  38,  38,  40,  40,  41,  43,  43,  45,  46,  47,  50,  50,  53,  54,  56,  58,  58,  62,
+             32,  32,  32,  32,  33,  33,  34,  34,  34,  35,  35,  36,  37,  37,  38,  38,  40,  40,  41,  43,  43,  45,  46,  47,  50,  50,  53,  54,  56,  58,  58,  62,
+             35,  35,  35,  34,  34,  34,  35,  36,  36,  37,  37,  40,  41,  43,  46,  46,  47,  48,  49,  51,  51,  53,  54,  55,  57,  57,  60,  61,  63,  66,  66,  70,
+             36,  35,  35,  35,  34,  34,  36,  36,  37,  38,  38,  41,  42,  44,  48,  48,  50,  50,  51,  53,  53,  56,  56,  58,  60,  60,  63,  63,  65,  68,  68,  72,
+             39,  38,  38,  37,  37,  37,  38,  38,  39,  40,  40,  43,  44,  46,  50,  50,  52,  53,  54,  57,  57,  59,  60,  61,  64,  64,  67,  68,  69,  72,  72,  76,
+             44,  42,  42,  41,  41,  41,  42,  42,  42,  42,  42,  46,  48,  50,  54,  54,  57,  58,  60,  63,  63,  66,  67,  68,  71,  71,  74,  75,  77,  79,  79,  83,
+             44,  42,  42,  41,  41,  41,  42,  42,  42,  42,  42,  46,  48,  50,  54,  54,  57,  58,  60,  63,  63,  66,  67,  68,  71,  71,  74,  75,  77,  79,  79,  83,
+             51,  49,  49,  48,  47,  47,  48,  48,  48,  48,  48,  52,  53,  55,  58,  58,  62,  63,  66,  69,  69,  73,  74,  76,  79,  79,  83,  84,  86,  89,  89,  93,
+             53,  52,  51,  50,  49,  49,  49,  50,  49,  49,  49,  53,  54,  56,  60,  60,  64,  65,  67,  71,  71,  75,  76,  78,  82,  82,  86,  87,  89,  92,  92,  96,
+             58,  56,  55,  54,  53,  53,  53,  53,  53,  52,  52,  56,  57,  59,  63,  63,  67,  68,  70,  74,  74,  78,  79,  82,  86,  86,  90,  91,  93,  97,  97, 101,
+             65,  63,  62,  61,  59,  59,  59,  59,  58,  58,  58,  62,  63,  65,  68,  68,  72,  73,  76,  79,  79,  84,  85,  88,  92,  92,  97,  98, 100, 105, 105, 109,
+             65,  63,  62,  61,  59,  59,  59,  59,  58,  58,  58,  62,  63,  65,  68,  68,  72,  73,  76,  79,  79,  84,  85,  88,  92,  92,  97,  98, 100, 105, 105, 109,
+        }, {
+             32,  31,  31,  31,  30,  30,  33,  33,  35,  37,  37,  41,  42,  44,  49,  49,  48,  48,  48,  49,  49,  50,  50,  51,  52,  52,  54,  54,  55,  57,  57,  59,
+             31,  31,  31,  31,  32,  32,  34,  35,  37,  39,  39,  42,  42,  44,  47,  47,  46,  46,  46,  46,  46,  47,  47,  48,  48,  48,  50,  51,  51,  53,  53,  55,
+             31,  31,  31,  32,  32,  32,  35,  36,  37,  40,  40,  42,  43,  44,  46,  46,  46,  46,  45,  45,  45,  46,  46,  47,  48,  48,  49,  50,  51,  52,  52,  54,
+             33,  34,  34,  34,  35,  35,  37,  38,  40,  43,  43,  44,  44,  45,  47,  47,  46,  46,  46,  45,  45,  46,  46,  47,  47,  47,  49,  49,  50,  51,  51,  53,
+             37,  38,  38,  39,  40,  40,  42,  43,  44,  47,  47,  47,  47,  47,  48,  48,  47,  47,  46,  46,  46,  46,  46,  47,  47,  47,  48,  49,  49,  50,  50,  52,
+             37,  38,  38,  39,  40,  40,  42,  43,  44,  47,  47,  47,  47,  47,  48,  48,  47,  47,  46,  46,  46,  46,  46,  47,  47,  47,  48,  49,  49,  50,  50,  52,
+             45,  45,  45,  45,  44,  44,  46,  46,  46,  47,  47,  49,  49,  50,  52,  52,  51,  51,  51,  51,  51,  52,  52,  52,  53,  53,  54,  54,  54,  55,  55,  57,
+             48,  47,  47,  46,  46,  46,  47,  47,  47,  47,  47,  49,  50,  51,  53,  53,  53,  53,  53,  53,  53,  54,  54,  54,  54,  54,  55,  55,  56,  56,  56,  58,
+             48,  47,  47,  46,  45,  45,  46,  46,  46,  47,  47,  49,  50,  51,  53,  53,  54,  54,  54,  55,  55,  56,  56,  56,  57,  57,  58,  58,  58,  59,  59,  61,
+             49,  47,  47,  46,  45,  45,  45,  46,  45,  45,  45,  48,  49,  51,  53,  53,  55,  56,  57,  58,  58,  59,  59,  60,  61,  61,  62,  62,  63,  64,  64,  65,
+             49,  47,  47,  46,  45,  45,  45,  46,  45,  45,  45,  48,  49,  51,  53,  53,  55,  56,  57,  58,  58,  59,  59,  60,  61,  61,  62,  62,  63,  64,  64,  65,
+             51,  50,  49,  48,  47,  47,  47,  47,  47,  46,  46,  49,  50,  52,  54,  54,  56,  57,  58,  61,  61,  62,  63,  64,  65,  65,  67,  67,  68,  69,  69,  70,
+             52,  50,  50,  49,  48,  48,  47,  47,  47,  47,  47,  50,  50,  52,  54,  54,  57,  57,  59,  61,  61,  63,  64,  65,  66,  66,  68,  68,  69,  70,  70,  72,
+             54,  52,  51,  51,  49,  49,  49,  49,  48,  48,  48,  51,  51,  53,  55,  55,  58,  58,  60,  62,  62,  64,  65,  66,  68,  68,  70,  70,  71,  73,  73,  74,
+             57,  55,  54,  53,  52,  52,  51,  51,  51,  50,  50,  52,  53,  54,  57,  57,  59,  60,  61,  64,  64,  66,  67,  68,  71,  71,  73,  73,  74,  76,  76,  78,
+             57,  55,  54,  53,  52,  52,  51,  51,  51,  50,  50,  52,  53,  54,  57,  57,  59,  60,  61,  64,  64,  66,  67,  68,  71,  71,  73,  73,  74,  76,  76,  78,
+        },
+    }, {
+        {
+             32,  31,  31,  31,  31,  31,  31,  32,  32,  32,  32,  32,  32,  34,  34,  35,  36,  36,  38,  39,  39,  42,  44,  44,  47,  48,  49,  53,  53,  55,  58,  58,
+             31,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  33,  34,  34,  34,  35,  35,  37,  38,  38,  40,  42,  42,  45,  46,  47,  50,  51,  52,  55,  55,
+             31,  32,  32,  32,  32,  32,  32,  32,  32,  32,  33,  33,  33,  34,  34,  34,  34,  34,  36,  37,  37,  40,  41,  41,  44,  45,  46,  49,  49,  51,  54,  54,
+             31,  32,  32,  32,  32,  32,  32,  32,  33,  33,  33,  33,  33,  34,  34,  34,  35,  35,  37,  38,  38,  40,  41,  41,  44,  45,  46,  49,  49,  51,  54,  54,
+             32,  32,  32,  32,  32,  32,  33,  33,  34,  34,  35,  35,  35,  36,  36,  37,  37,  37,  39,  40,  40,  42,  42,  43,  45,  46,  47,  49,  50,  51,  54,  54,
+             32,  32,  32,  32,  32,  33,  33,  34,  34,  34,  35,  35,  36,  37,  37,  37,  38,  38,  40,  40,  40,  42,  43,  43,  45,  46,  47,  49,  50,  51,  54,  54,
+             32,  33,  33,  33,  33,  33,  33,  34,  34,  35,  36,  36,  36,  38,  38,  39,  40,  40,  41,  42,  42,  44,  45,  45,  47,  48,  48,  51,  51,  53,  55,  55,
+             35,  35,  35,  35,  34,  34,  35,  36,  36,  37,  38,  38,  39,  42,  42,  44,  47,  47,  48,  49,  49,  51,  52,  52,  54,  55,  56,  58,  59,  60,  62,  62,
+             36,  35,  35,  35,  35,  34,  35,  36,  36,  37,  38,  38,  40,  42,  42,  45,  48,  48,  49,  50,  50,  52,  53,  54,  56,  56,  57,  59,  60,  61,  63,  63,
+             38,  37,  37,  37,  36,  36,  36,  38,  38,  38,  39,  39,  41,  44,  44,  46,  49,  49,  51,  52,  52,  55,  56,  56,  58,  59,  60,  62,  63,  64,  67,  67,
+             44,  43,  42,  42,  41,  41,  41,  42,  42,  42,  42,  42,  44,  48,  48,  50,  54,  54,  56,  58,  58,  61,  63,  63,  66,  67,  67,  71,  71,  72,  75,  75,
+             44,  43,  42,  42,  41,  41,  41,  42,  42,  42,  42,  42,  44,  48,  48,  50,  54,  54,  56,  58,  58,  61,  63,  63,  66,  67,  67,  71,  71,  72,  75,  75,
+             47,  46,  45,  45,  44,  44,  44,  45,  45,  45,  45,  45,  47,  50,  50,  53,  56,  56,  58,  60,  60,  64,  66,  66,  69,  70,  71,  74,  75,  76,  79,  79,
+             53,  52,  51,  51,  49,  49,  49,  49,  50,  49,  49,  49,  51,  54,  54,  57,  60,  60,  63,  65,  65,  69,  71,  72,  75,  76,  77,  81,  82,  83,  87,  87,
+             53,  52,  51,  51,  49,  49,  49,  49,  50,  49,  49,  49,  51,  54,  54,  57,  60,  60,  63,  65,  65,  69,  71,  72,  75,  76,  77,  81,  82,  83,  87,  87,
+             59,  57,  56,  56,  54,  54,  54,  54,  54,  54,  53,  53,  55,  58,  58,  61,  64,  64,  67,  69,  69,  73,  75,  76,  79,  80,  81,  86,  87,  88,  92,  92,
+        }, {
+             32,  31,  31,  31,  30,  30,  31,  33,  33,  34,  37,  37,  39,  42,  42,  45,  49,  49,  48,  48,  48,  49,  49,  49,  50,  50,  51,  52,  52,  53,  54,  54,
+             31,  31,  31,  31,  31,  31,  32,  35,  35,  36,  39,  39,  40,  42,  42,  45,  47,  47,  47,  46,  46,  46,  46,  46,  47,  48,  48,  49,  49,  50,  51,  51,
+             31,  31,  31,  31,  32,  32,  33,  35,  36,  37,  40,  40,  41,  43,  43,  44,  46,  46,  46,  46,  46,  45,  45,  45,  46,  46,  47,  48,  48,  48,  50,  50,
+             31,  32,  32,  32,  32,  33,  33,  36,  36,  37,  41,  41,  42,  43,  43,  45,  47,  47,  46,  46,  46,  45,  45,  45,  46,  46,  47,  48,  48,  48,  50,  50,
+             35,  36,  37,  37,  38,  38,  38,  41,  41,  42,  45,  45,  46,  46,  46,  47,  48,  48,  47,  46,  46,  46,  45,  46,  46,  46,  47,  47,  47,  48,  49,  49,
+             37,  38,  38,  38,  39,  40,  40,  43,  43,  44,  47,  47,  47,  47,  47,  47,  48,  48,  47,  47,  47,  46,  46,  46,  46,  46,  47,  47,  47,  48,  49,  49,
+             38,  39,  40,  40,  40,  41,  41,  43,  44,  45,  47,  47,  47,  48,  48,  48,  49,  49,  48,  48,  48,  47,  47,  47,  48,  48,  48,  48,  48,  49,  50,  50,
+             47,  46,  46,  46,  45,  45,  45,  46,  46,  47,  47,  47,  48,  50,  50,  51,  52,  52,  52,  52,  52,  52,  52,  52,  53,  53,  53,  53,  53,  54,  55,  55,
+             48,  47,  47,  47,  46,  46,  46,  47,  47,  47,  47,  47,  48,  50,  50,  51,  53,  53,  53,  53,  53,  53,  53,  53,  54,  54,  54,  54,  54,  54,  55,  55,
+             48,  47,  47,  47,  46,  46,  46,  46,  46,  47,  47,  47,  48,  50,  50,  51,  53,  53,  53,  54,  54,  54,  55,  55,  55,  55,  55,  56,  56,  56,  57,  57,
+             49,  48,  47,  47,  45,  45,  45,  45,  46,  45,  45,  45,  47,  49,  49,  51,  53,  53,  55,  56,  56,  57,  58,  58,  59,  59,  60,  61,  61,  61,  62,  62,
+             49,  48,  47,  47,  45,  45,  45,  45,  46,  45,  45,  45,  47,  49,  49,  51,  53,  53,  55,  56,  56,  57,  58,  58,  59,  59,  60,  61,  61,  61,  62,  62,
+             50,  49,  48,  48,  46,  46,  46,  46,  46,  46,  46,  46,  47,  50,  50,  52,  54,  54,  55,  56,  56,  58,  59,  60,  61,  61,  61,  63,  63,  63,  65,  65,
+             52,  50,  50,  50,  48,  48,  48,  47,  47,  47,  47,  47,  48,  50,  50,  52,  54,  54,  56,  57,  57,  60,  61,  61,  63,  64,  64,  66,  66,  67,  68,  68,
+             52,  50,  50,  50,  48,  48,  48,  47,  47,  47,  47,  47,  48,  50,  50,  52,  54,  54,  56,  57,  57,  60,  61,  61,  63,  64,  64,  66,  66,  67,  68,  68,
+             54,  53,  52,  52,  50,  50,  50,  49,  49,  49,  48,  48,  50,  52,  52,  54,  55,  55,  57,  59,  59,  61,  62,  63,  65,  65,  66,  68,  68,  69,  71,  71,
+        },
+    }, {
+        {
+             32,  31,  31,  31,  31,  31,  31,  31,  31,  32,  32,  32,  32,  32,  32,  34,  34,  34,  35,  36,  36,  38,  39,  39,  41,  44,  44,  44,  47,  48,  48,  51,
+             31,  31,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  33,  34,  34,  34,  35,  35,  35,  37,  38,  38,  40,  42,  42,  43,  45,  46,  46,  49,
+             31,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  33,  33,  33,  34,  34,  34,  34,  34,  34,  36,  37,  37,  39,  41,  41,  42,  44,  45,  45,  47,
+             31,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  33,  33,  33,  34,  34,  34,  34,  34,  34,  36,  37,  37,  39,  41,  41,  42,  44,  45,  45,  47,
+             31,  32,  32,  32,  32,  32,  32,  32,  33,  33,  33,  33,  34,  34,  34,  35,  35,  35,  36,  36,  36,  37,  39,  39,  40,  42,  42,  42,  44,  45,  45,  48,
+             32,  32,  32,  32,  32,  33,  33,  33,  34,  34,  34,  35,  35,  35,  36,  37,  37,  37,  38,  38,  38,  40,  40,  40,  41,  43,  43,  43,  45,  46,  46,  48,
+             32,  32,  32,  32,  32,  33,  33,  33,  34,  34,  34,  35,  35,  35,  36,  37,  37,  37,  38,  38,  38,  40,  40,  40,  41,  43,  43,  43,  45,  46,  46,  48,
+             32,  33,  33,  33,  33,  33,  33,  33,  34,  34,  34,  35,  36,  36,  36,  38,  38,  38,  39,  40,  40,  41,  42,  42,  43,  45,  45,  45,  47,  48,  48,  50,
+             35,  35,  35,  35,  34,  34,  34,  34,  35,  36,  36,  37,  37,  37,  39,  41,  41,  42,  45,  46,  46,  47,  48,  48,  49,  51,  51,  51,  53,  54,  54,  56,
+             36,  35,  35,  35,  35,  34,  34,  35,  36,  36,  36,  37,  38,  38,  40,  42,  42,  43,  47,  48,  48,  49,  50,  50,  51,  53,  53,  54,  56,  56,  56,  58,
+             36,  35,  35,  35,  35,  34,  34,  35,  36,  36,  36,  37,  38,  38,  40,  42,  42,  43,  47,  48,  48,  49,  50,  50,  51,  53,  53,  54,  56,  56,  56,  58,
+             40,  39,  39,  39,  39,  38,  38,  38,  39,  39,  39,  40,  41,  41,  42,  45,  45,  46,  50,  51,  51,  53,  54,  54,  56,  59,  59,  59,  61,  62,  62,  64,
+             44,  43,  42,  42,  41,  41,  41,  41,  42,  42,  42,  42,  42,  42,  44,  48,  48,  49,  52,  54,  54,  56,  58,  58,  60,  63,  63,  64,  66,  67,  67,  69,
+             44,  43,  42,  42,  41,  41,  41,  41,  42,  42,  42,  42,  42,  42,  44,  48,  48,  49,  52,  54,  54,  56,  58,  58,  60,  63,  63,  64,  66,  67,  67,  69,
+             47,  46,  45,  45,  45,  44,  44,  44,  44,  45,  45,  45,  45,  45,  47,  50,  50,  51,  55,  56,  56,  58,  60,  60,  62,  66,  66,  67,  69,  70,  70,  73,
+             53,  52,  51,  51,  50,  49,  49,  49,  49,  50,  50,  49,  49,  49,  51,  54,  54,  55,  59,  60,  60,  63,  65,  65,  67,  71,  71,  72,  75,  76,  76,  79,
+        }, {
+             32,  31,  31,  31,  31,  30,  30,  31,  33,  33,  33,  35,  37,  37,  39,  42,  42,  43,  47,  49,  49,  48,  48,  48,  48,  49,  49,  49,  50,  50,  50,  51,
+             31,  31,  31,  31,  31,  31,  31,  32,  34,  35,  35,  37,  39,  39,  40,  42,  42,  43,  46,  47,  47,  47,  47,  47,  47,  46,  46,  47,  48,  48,  48,  49,
+             31,  31,  31,  31,  32,  32,  32,  33,  35,  36,  36,  38,  40,  40,  41,  43,  43,  43,  46,  46,  46,  46,  46,  46,  45,  45,  45,  45,  46,  46,  46,  47,
+             31,  31,  31,  31,  32,  32,  32,  33,  35,  36,  36,  38,  40,  40,  41,  43,  43,  43,  46,  46,  46,  46,  46,  46,  45,  45,  45,  45,  46,  46,  46,  47,
+             33,  33,  34,  34,  34,  35,  35,  35,  37,  38,  38,  41,  43,  43,  43,  44,  44,  45,  46,  47,  47,  46,  46,  46,  46,  45,  45,  45,  46,  46,  46,  47,
+             37,  38,  38,  38,  39,  40,  40,  40,  42,  43,  43,  45,  47,  47,  47,  47,  47,  47,  48,  48,  48,  47,  47,  47,  46,  46,  46,  46,  46,  46,  46,  47,
+             37,  38,  38,  38,  39,  40,  40,  40,  42,  43,  43,  45,  47,  47,  47,  47,  47,  47,  48,  48,  48,  47,  47,  47,  46,  46,  46,  46,  46,  46,  46,  47,
+             38,  39,  40,  40,  40,  41,  41,  41,  43,  44,  44,  46,  47,  47,  47,  48,  48,  48,  48,  49,  49,  48,  48,  48,  47,  47,  47,  47,  48,  48,  48,  48,
+             45,  45,  45,  45,  45,  44,  44,  45,  46,  46,  46,  47,  47,  47,  48,  49,  49,  50,  51,  52,  52,  52,  51,  51,  51,  51,  51,  52,  52,  52,  52,  52,
+             48,  47,  47,  47,  46,  46,  46,  46,  47,  47,  47,  47,  47,  47,  48,  50,  50,  50,  52,  53,  53,  53,  53,  53,  53,  53,  53,  53,  54,  54,  54,  54,
+             48,  47,  47,  47,  46,  46,  46,  46,  47,  47,  47,  47,  47,  47,  48,  50,  50,  50,  52,  53,  53,  53,  53,  53,  53,  53,  53,  53,  54,  54,  54,  54,
+             49,  48,  47,  47,  46,  45,  45,  45,  46,  46,  46,  46,  46,  46,  47,  49,  49,  50,  52,  53,  53,  54,  54,  54,  55,  56,  56,  56,  57,  57,  57,  58,
+             49,  48,  47,  47,  46,  45,  45,  45,  45,  46,  46,  45,  45,  45,  47,  49,  49,  50,  53,  53,  53,  55,  56,  56,  57,  58,  58,  58,  59,  59,  59,  60,
+             49,  48,  47,  47,  46,  45,  45,  45,  45,  46,  46,  45,  45,  45,  47,  49,  49,  50,  53,  53,  53,  55,  56,  56,  57,  58,  58,  58,  59,  59,  59,  60,
+             50,  49,  48,  48,  47,  46,  46,  46,  46,  46,  46,  46,  46,  46,  47,  50,  50,  50,  53,  54,  54,  55,  56,  56,  57,  59,  59,  60,  61,  61,  61,  62,
+             52,  51,  50,  50,  49,  48,  48,  48,  47,  47,  47,  47,  47,  47,  48,  50,  50,  51,  53,  54,  54,  56,  57,  57,  59,  61,  61,  62,  63,  64,  64,  65,
+        },
+    }, {
+        {
+             32,  31,  31,  31,  31,  31,  31,  31,  31,  31,  32,  32,  32,  32,  32,  32,  32,  33,  34,  34,  34,  35,  36,  36,  36,  37,  39,  39,  39,  41,  44,  44,
+             31,  31,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  33,  34,  34,  34,  34,  35,  35,  35,  37,  38,  38,  38,  40,  42,  42,
+             31,  31,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  33,  33,  33,  33,  34,  34,  34,  34,  34,  34,  34,  36,  37,  37,  37,  39,  41,  41,
+             31,  31,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  33,  33,  33,  33,  34,  34,  34,  34,  34,  34,  34,  36,  37,  37,  37,  39,  41,  41,
+             31,  31,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  33,  33,  33,  33,  34,  34,  34,  34,  34,  34,  34,  36,  37,  37,  37,  39,  41,  41,
+             32,  32,  32,  32,  32,  32,  32,  32,  32,  33,  33,  33,  33,  33,  34,  34,  34,  34,  35,  35,  35,  36,  36,  36,  36,  38,  39,  39,  39,  40,  42,  42,
+             32,  32,  32,  32,  32,  32,  33,  33,  33,  33,  34,  34,  34,  34,  35,  35,  35,  36,  37,  37,  37,  37,  38,  38,  38,  39,  40,  40,  40,  42,  43,  43,
+             32,  32,  32,  32,  32,  32,  33,  33,  33,  33,  34,  34,  34,  34,  35,  35,  35,  36,  37,  37,  37,  37,  38,  38,  38,  39,  40,  40,  40,  42,  43,  43,
+             32,  32,  32,  32,  32,  32,  33,  33,  33,  33,  34,  34,  34,  34,  35,  35,  35,  36,  37,  37,  37,  37,  38,  38,  38,  39,  40,  40,  40,  42,  43,  43,
+             34,  34,  34,  34,  34,  34,  33,  33,  33,  34,  35,  35,  35,  36,  37,  37,  37,  38,  39,  39,  39,  41,  43,  43,  43,  44,  45,  45,  45,  46,  48,  48,
+             36,  35,  35,  35,  35,  35,  34,  34,  34,  35,  36,  36,  36,  37,  38,  38,  38,  40,  42,  42,  42,  45,  48,  48,  48,  49,  50,  50,  50,  52,  53,  53,
+             36,  35,  35,  35,  35,  35,  34,  34,  34,  35,  36,  36,  36,  37,  38,  38,  38,  40,  42,  42,  42,  45,  48,  48,  48,  49,  50,  50,  50,  52,  53,  53,
+             36,  35,  35,  35,  35,  35,  34,  34,  34,  35,  36,  36,  36,  37,  38,  38,  38,  40,  42,  42,  42,  45,  48,  48,  48,  49,  50,  50,  50,  52,  53,  53,
+             39,  39,  38,  38,  38,  38,  37,  37,  37,  38,  39,  39,  39,  40,  40,  40,  40,  42,  45,  45,  45,  47,  51,  51,  51,  52,  54,  54,  54,  56,  58,  58,
+             44,  43,  42,  42,  42,  41,  41,  41,  41,  41,  42,  42,  42,  42,  42,  42,  42,  45,  48,  48,  48,  50,  54,  54,  54,  56,  58,  58,  58,  60,  63,  63,
+             44,  43,  42,  42,  42,  41,  41,  41,  41,  41,  42,  42,  42,  42,  42,  42,  42,  45,  48,  48,  48,  50,  54,  54,  54,  56,  58,  58,  58,  60,  63,  63,
+        }, {
+             32,  31,  31,  31,  31,  31,  30,  30,  30,  32,  33,  33,  33,  35,  37,  37,  37,  39,  42,  42,  42,  45,  49,  49,  49,  48,  48,  48,  48,  48,  49,  49,
+             31,  31,  31,  31,  31,  31,  31,  31,  31,  33,  34,  34,  34,  36,  38,  38,  38,  40,  42,  42,  42,  45,  48,  48,  48,  47,  47,  47,  47,  47,  47,  47,
+             31,  31,  31,  31,  31,  32,  32,  32,  32,  34,  36,  36,  36,  38,  40,  40,  40,  41,  43,  43,  43,  44,  46,  46,  46,  46,  46,  46,  46,  45,  45,  45,
+             31,  31,  31,  31,  31,  32,  32,  32,  32,  34,  36,  36,  36,  38,  40,  40,  40,  41,  43,  43,  43,  44,  46,  46,  46,  46,  46,  46,  46,  45,  45,  45,
+             31,  31,  31,  31,  31,  32,  32,  32,  32,  34,  36,  36,  36,  38,  40,  40,  40,  41,  43,  43,  43,  44,  46,  46,  46,  46,  46,  46,  46,  45,  45,  45,
+             33,  34,  34,  34,  34,  35,  35,  35,  35,  37,  39,  39,  39,  41,  43,  43,  43,  44,  45,  45,  45,  46,  47,  47,  47,  47,  46,  46,  46,  46,  45,  45,
+             37,  37,  38,  38,  38,  39,  40,  40,  40,  41,  43,  43,  43,  45,  47,  47,  47,  47,  47,  47,  47,  47,  48,  48,  48,  47,  47,  47,  47,  46,  46,  46,
+             37,  37,  38,  38,  38,  39,  40,  40,  40,  41,  43,  43,  43,  45,  47,  47,  47,  47,  47,  47,  47,  47,  48,  48,  48,  47,  47,  47,  47,  46,  46,  46,
+             37,  37,  38,  38,  38,  39,  40,  40,  40,  41,  43,  43,  43,  45,  47,  47,  47,  47,  47,  47,  47,  47,  48,  48,  48,  47,  47,  47,  47,  46,  46,  46,
+             42,  42,  42,  42,  42,  42,  42,  42,  42,  44,  45,  45,  45,  46,  47,  47,  47,  48,  48,  48,  48,  49,  50,  50,  50,  50,  50,  50,  50,  49,  49,  49,
+             48,  47,  47,  47,  47,  46,  46,  46,  46,  46,  47,  47,  47,  47,  47,  47,  47,  49,  50,  50,  50,  51,  53,  53,  53,  53,  53,  53,  53,  53,  53,  53,
+             48,  47,  47,  47,  47,  46,  46,  46,  46,  46,  47,  47,  47,  47,  47,  47,  47,  49,  50,  50,  50,  51,  53,  53,  53,  53,  53,  53,  53,  53,  53,  53,
+             48,  47,  47,  47,  47,  46,  46,  46,  46,  46,  47,  47,  47,  47,  47,  47,  47,  49,  50,  50,  50,  51,  53,  53,  53,  53,  53,  53,  53,  53,  53,  53,
+             48,  48,  47,  47,  47,  46,  45,  45,  45,  46,  46,  46,  46,  46,  46,  46,  46,  48,  50,  50,  50,  51,  53,  53,  53,  54,  54,  54,  54,  55,  56,  56,
+             49,  48,  47,  47,  47,  46,  45,  45,  45,  45,  46,  46,  46,  45,  45,  45,  45,  47,  49,  49,  49,  51,  53,  53,  53,  54,  56,  56,  56,  57,  58,  58,
+             49,  48,  47,  47,  47,  46,  45,  45,  45,  45,  46,  46,  46,  45,  45,  45,  45,  47,  49,  49,  49,  51,  53,  53,  53,  54,  56,  56,  56,  57,  58,  58,
+        },
+    }, {
+        {
+             32,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  32,  32,  32,  32,  32,  32,  32,  32,  32,  33,  34,  34,  34,  34,  35,  36,  36,  36,  37,
+             31,  31,  31,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  33,  33,  34,  34,  34,  34,  35,  35,  35,  35,  36,
+             31,  31,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  33,  33,  34,  34,  34,  34,  34,  35,  35,  35,  36,
+             31,  31,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  33,  33,  33,  33,  33,  33,  34,  34,  34,  34,  34,  34,  34,  34,  36,
+             31,  31,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  33,  33,  33,  33,  33,  33,  34,  34,  34,  34,  34,  34,  34,  34,  36,
+             31,  31,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  33,  33,  33,  33,  33,  33,  34,  34,  34,  34,  34,  34,  34,  34,  36,
+             31,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  33,  33,  33,  33,  33,  33,  33,  34,  34,  34,  34,  35,  35,  35,  35,  35,  36,  36,  36,  36,  37,
+             32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  33,  33,  34,  34,  34,  34,  34,  35,  35,  35,  35,  36,  36,  36,  36,  37,  37,  37,  37,  37,  38,
+             32,  32,  32,  32,  32,  32,  32,  32,  33,  33,  33,  33,  34,  34,  34,  34,  34,  35,  35,  35,  35,  36,  36,  37,  37,  37,  37,  38,  38,  38,  38,  39,
+             32,  32,  32,  32,  32,  32,  32,  32,  33,  33,  33,  33,  34,  34,  34,  34,  34,  35,  35,  35,  35,  36,  36,  37,  37,  37,  37,  38,  38,  38,  38,  39,
+             32,  32,  32,  32,  32,  32,  32,  32,  33,  33,  33,  33,  34,  34,  34,  34,  34,  35,  35,  35,  35,  36,  36,  37,  37,  37,  37,  38,  38,  38,  38,  39,
+             33,  33,  33,  33,  33,  33,  33,  33,  33,  33,  33,  34,  34,  35,  35,  35,  35,  36,  36,  36,  36,  37,  38,  39,  39,  39,  40,  41,  42,  42,  42,  42,
+             35,  35,  35,  35,  35,  35,  34,  34,  34,  34,  34,  35,  35,  36,  36,  36,  36,  37,  37,  37,  37,  39,  40,  41,  41,  41,  43,  45,  46,  46,  46,  46,
+             36,  35,  35,  35,  35,  35,  35,  35,  34,  34,  34,  35,  36,  36,  36,  36,  37,  38,  38,  38,  38,  40,  41,  42,  42,  42,  44,  47,  48,  48,  48,  49,
+             36,  35,  35,  35,  35,  35,  35,  35,  34,  34,  34,  35,  36,  36,  36,  36,  37,  38,  38,  38,  38,  40,  41,  42,  42,  42,  44,  47,  48,  48,  48,  49,
+             36,  35,  35,  35,  35,  35,  35,  35,  34,  34,  34,  35,  36,  36,  36,  36,  37,  38,  38,  38,  38,  40,  41,  42,  42,  42,  44,  47,  48,  48,  48,  49,
+        }, {
+             32,  31,  31,  31,  31,  31,  31,  30,  30,  30,  30,  31,  33,  33,  33,  33,  35,  36,  37,  37,  37,  39,  41,  42,  42,  42,  44,  47,  49,  49,  49,  49,
+             31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  32,  34,  34,  34,  34,  36,  37,  38,  38,  38,  39,  41,  42,  42,  42,  44,  46,  48,  48,  48,  48,
+             31,  31,  31,  31,  31,  31,  31,  31,  32,  32,  32,  33,  34,  35,  35,  35,  37,  38,  39,  39,  39,  40,  42,  42,  42,  42,  44,  46,  47,  47,  47,  47,
+             31,  31,  31,  31,  31,  31,  32,  32,  32,  32,  32,  33,  35,  36,  36,  36,  37,  39,  40,  40,  40,  41,  42,  43,  43,  43,  44,  46,  46,  46,  46,  46,
+             31,  31,  31,  31,  31,  31,  32,  32,  32,  32,  32,  33,  35,  36,  36,  36,  37,  39,  40,  40,  40,  41,  42,  43,  43,  43,  44,  46,  46,  46,  46,  46,
+             31,  31,  31,  31,  31,  31,  32,  32,  32,  32,  32,  33,  35,  36,  36,  36,  37,  39,  40,  40,  40,  41,  42,  43,  43,  43,  44,  46,  46,  46,  46,  46,
+             33,  33,  34,  34,  34,  34,  34,  34,  35,  35,  35,  36,  37,  38,  38,  38,  40,  42,  43,  43,  43,  43,  44,  44,  44,  44,  45,  46,  47,  47,  47,  47,
+             35,  36,  36,  37,  37,  37,  37,  38,  38,  38,  38,  39,  40,  41,  41,  41,  43,  44,  45,  45,  45,  46,  46,  46,  46,  46,  47,  47,  48,  48,  48,  47,
+             37,  37,  38,  38,  38,  38,  39,  39,  40,  40,  40,  41,  42,  43,  43,  43,  44,  46,  47,  47,  47,  47,  47,  47,  47,  47,  47,  48,  48,  48,  48,  47,
+             37,  37,  38,  38,  38,  38,  39,  39,  40,  40,  40,  41,  42,  43,  43,  43,  44,  46,  47,  47,  47,  47,  47,  47,  47,  47,  47,  48,  48,  48,  48,  47,
+             37,  37,  38,  38,  38,  38,  39,  39,  40,  40,  40,  41,  42,  43,  43,  43,  44,  46,  47,  47,  47,  47,  47,  47,  47,  47,  47,  48,  48,  48,  48,  47,
+             40,  41,  41,  41,  41,  41,  41,  42,  42,  42,  42,  43,  44,  44,  44,  44,  45,  47,  47,  47,  47,  48,  48,  48,  48,  48,  49,  49,  50,  50,  50,  49,
+             45,  45,  45,  45,  45,  45,  45,  44,  44,  44,  44,  45,  46,  46,  46,  46,  46,  47,  47,  47,  47,  48,  49,  49,  49,  49,  50,  51,  52,  52,  52,  52,
+             48,  48,  47,  47,  47,  47,  46,  46,  46,  46,  46,  46,  47,  47,  47,  47,  47,  47,  47,  47,  47,  48,  49,  50,  50,  50,  51,  52,  53,  53,  53,  53,
+             48,  48,  47,  47,  47,  47,  46,  46,  46,  46,  46,  46,  47,  47,  47,  47,  47,  47,  47,  47,  47,  48,  49,  50,  50,  50,  51,  52,  53,  53,  53,  53,
+             48,  48,  47,  47,  47,  47,  46,  46,  46,  46,  46,  46,  47,  47,  47,  47,  47,  47,  47,  47,  47,  48,  49,  50,  50,  50,  51,  52,  53,  53,  53,  53,
+        },
+    }, {
+        {
+             32,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  33,  34,  34,
+             31,  31,  31,  31,  31,  31,  31,  31,  31,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  33,  33,  34,  34,
+             31,  31,  31,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  33,  33,  34,  34,
+             31,  31,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  33,  33,  33,  34,  34,
+             31,  31,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  33,  33,  33,  33,  33,  33,  33,  34,  34,
+             31,  31,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  33,  33,  33,  33,  33,  33,  33,  34,  34,
+             31,  31,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  33,  33,  33,  33,  33,  33,  33,  34,  34,
+             31,  31,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  33,  33,  33,  33,  33,  33,  33,  33,  33,  33,  33,  33,  34,  34,  34,
+             31,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  33,  33,  33,  33,  33,  33,  33,  33,  33,  34,  34,  34,  34,  34,  34,  35,  35,
+             32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  33,  33,  33,  33,  33,  33,  33,  34,  34,  34,  34,  34,  34,  34,  35,  35,  36,  36,
+             32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  33,  33,  33,  33,  33,  33,  34,  34,  34,  34,  34,  34,  35,  35,  35,  35,  35,  35,  36,  36,  37,  37,
+             32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  33,  33,  33,  33,  33,  33,  34,  34,  34,  34,  34,  34,  35,  35,  35,  35,  35,  35,  36,  36,  37,  37,
+             32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  33,  33,  33,  33,  33,  33,  34,  34,  34,  34,  34,  34,  35,  35,  35,  35,  35,  35,  36,  36,  37,  37,
+             32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  33,  33,  33,  33,  33,  33,  34,  34,  34,  34,  34,  34,  35,  35,  35,  35,  35,  35,  36,  36,  37,  37,
+             32,  33,  33,  33,  33,  33,  33,  33,  33,  33,  33,  33,  33,  33,  33,  34,  34,  34,  34,  34,  34,  35,  35,  36,  36,  36,  36,  36,  36,  37,  38,  38,
+             34,  34,  34,  34,  34,  34,  34,  34,  34,  33,  33,  33,  33,  33,  34,  34,  35,  35,  35,  35,  35,  35,  36,  36,  37,  37,  37,  37,  38,  38,  39,  39,
+        }, {
+             32,  31,  31,  31,  31,  31,  31,  31,  31,  30,  30,  30,  30,  30,  31,  32,  33,  33,  33,  33,  33,  34,  35,  36,  37,  37,  37,  37,  39,  40,  42,  42,
+             31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  32,  33,  34,  34,  34,  34,  35,  36,  37,  38,  38,  38,  38,  39,  41,  42,  42,
+             31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  32,  33,  34,  35,  35,  35,  35,  36,  37,  38,  39,  39,  39,  39,  40,  41,  42,  42,
+             31,  31,  31,  31,  31,  31,  31,  31,  31,  32,  32,  32,  32,  32,  32,  33,  35,  35,  35,  35,  35,  37,  38,  39,  40,  40,  40,  40,  41,  42,  43,  43,
+             31,  31,  31,  31,  31,  31,  31,  31,  32,  32,  32,  32,  32,  32,  33,  34,  35,  36,  36,  36,  36,  37,  38,  39,  40,  40,  40,  40,  41,  42,  43,  43,
+             31,  31,  31,  31,  31,  31,  31,  31,  32,  32,  32,  32,  32,  32,  33,  34,  35,  36,  36,  36,  36,  37,  38,  39,  40,  40,  40,  40,  41,  42,  43,  43,
+             31,  31,  31,  31,  31,  31,  31,  31,  32,  32,  32,  32,  32,  32,  33,  34,  35,  36,  36,  36,  36,  37,  38,  39,  40,  40,  40,  40,  41,  42,  43,  43,
+             31,  31,  32,  32,  32,  32,  32,  32,  32,  32,  33,  33,  33,  33,  33,  34,  35,  36,  36,  36,  36,  37,  39,  40,  41,  41,  41,  41,  42,  42,  43,  43,
+             33,  33,  33,  34,  34,  34,  34,  34,  34,  34,  35,  35,  35,  35,  35,  36,  37,  38,  38,  38,  38,  39,  41,  42,  43,  43,  43,  43,  43,  44,  44,  44,
+             35,  35,  35,  36,  36,  36,  36,  36,  36,  37,  37,  37,  37,  37,  38,  39,  40,  40,  40,  40,  40,  42,  43,  44,  45,  45,  45,  45,  45,  45,  46,  46,
+             37,  37,  38,  38,  38,  38,  38,  38,  39,  39,  40,  40,  40,  40,  40,  41,  42,  43,  43,  43,  43,  44,  45,  47,  47,  47,  47,  47,  47,  47,  47,  47,
+             37,  37,  38,  38,  38,  38,  38,  38,  39,  39,  40,  40,  40,  40,  40,  41,  42,  43,  43,  43,  43,  44,  45,  47,  47,  47,  47,  47,  47,  47,  47,  47,
+             37,  37,  38,  38,  38,  38,  38,  38,  39,  39,  40,  40,  40,  40,  40,  41,  42,  43,  43,  43,  43,  44,  45,  47,  47,  47,  47,  47,  47,  47,  47,  47,
+             37,  37,  38,  38,  38,  38,  38,  38,  39,  39,  40,  40,  40,  40,  40,  41,  42,  43,  43,  43,  43,  44,  45,  47,  47,  47,  47,  47,  47,  47,  47,  47,
+             38,  39,  39,  40,  40,  40,  40,  40,  40,  40,  41,  41,  41,  41,  41,  42,  43,  44,  44,  44,  44,  45,  46,  47,  47,  47,  47,  47,  47,  47,  48,  48,
+             42,  42,  42,  42,  42,  42,  42,  42,  42,  42,  42,  42,  42,  42,  43,  44,  44,  45,  45,  45,  45,  45,  46,  47,  47,  47,  47,  47,  48,  48,  48,  48,
+        },
+    }, {
+        {
+             32,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  32,  32,  32,  32,  32,  32,  32,
+             31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,
+             31,  31,  31,  31,  31,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,
+             31,  31,  31,  31,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,
+             31,  31,  31,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,
+             31,  31,  31,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,
+             31,  31,  31,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,
+             31,  31,  31,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,
+             31,  31,  31,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,
+             31,  31,  31,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,
+             31,  31,  31,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,
+             31,  31,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  33,  33,  33,  33,  33,  33,  33,  33,
+             31,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  33,  33,  33,  33,  33,  33,  33,  33,  33,  33,
+             32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  33,  33,  33,  33,  33,  33,  33,  33,  33,  33,  33,
+             32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  33,  33,  33,  33,  34,  34,  34,  34,  34,  34,  34,
+             32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  33,  33,  33,  33,  33,  33,  33,  33,  33,  34,  34,  34,  34,  34,  34,  34,  34,
+        }, {
+             32,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  30,  30,  30,  30,  30,  30,  30,  31,  31,  32,  33,  33,  33,  33,  33,  33,  33,  34,
+             31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  32,  32,  33,  34,  34,  34,  34,  34,  34,  34,
+             31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  32,  33,  34,  34,  34,  34,  34,  34,  34,  35,
+             31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  32,  33,  33,  34,  35,  35,  35,  35,  35,  35,  35,
+             31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  32,  32,  32,  32,  32,  32,  32,  33,  34,  34,  35,  35,  35,  35,  35,  35,  36,
+             31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  32,  32,  32,  32,  32,  32,  32,  32,  32,  33,  33,  34,  35,  36,  36,  36,  36,  36,  36,  36,
+             31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  32,  32,  32,  32,  32,  32,  32,  32,  32,  33,  33,  34,  35,  36,  36,  36,  36,  36,  36,  36,
+             31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  32,  32,  32,  32,  32,  32,  32,  32,  32,  33,  33,  34,  35,  36,  36,  36,  36,  36,  36,  36,
+             31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  32,  32,  32,  32,  32,  32,  32,  32,  32,  33,  33,  34,  35,  36,  36,  36,  36,  36,  36,  36,
+             31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  32,  32,  32,  32,  32,  32,  32,  32,  32,  33,  33,  34,  35,  36,  36,  36,  36,  36,  36,  36,
+             31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  32,  32,  32,  32,  32,  32,  32,  32,  32,  33,  33,  34,  35,  36,  36,  36,  36,  36,  36,  36,
+             32,  32,  32,  32,  32,  33,  33,  33,  33,  33,  33,  33,  33,  33,  33,  33,  33,  33,  33,  33,  33,  34,  35,  35,  36,  37,  37,  37,  37,  37,  37,  38,
+             33,  33,  33,  33,  34,  34,  34,  34,  34,  34,  34,  34,  34,  34,  34,  35,  35,  35,  35,  35,  35,  35,  36,  37,  37,  38,  38,  38,  38,  38,  38,  39,
+             34,  34,  34,  35,  35,  35,  35,  35,  35,  35,  35,  35,  36,  36,  36,  36,  36,  36,  36,  36,  36,  37,  37,  38,  39,  40,  40,  40,  40,  40,  40,  40,
+             35,  35,  36,  36,  36,  37,  37,  37,  37,  37,  37,  37,  37,  37,  38,  38,  38,  38,  38,  38,  38,  38,  39,  40,  40,  41,  41,  41,  41,  41,  41,  42,
+             37,  37,  37,  38,  38,  38,  38,  38,  38,  38,  38,  38,  39,  39,  39,  40,  40,  40,  40,  40,  40,  40,  41,  41,  42,  43,  43,  43,  43,  43,  43,  44,
+        },
+    }, {
+        {
+             32,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,
+             31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,
+             31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,
+             31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  32,  32,  32,  32,  32,  32,
+             31,  31,  31,  31,  31,  31,  31,  31,  31,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,
+             31,  31,  31,  31,  31,  31,  31,  31,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,
+             31,  31,  31,  31,  31,  31,  31,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,
+             31,  31,  31,  31,  31,  31,  31,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,
+             31,  31,  31,  31,  31,  31,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,
+             31,  31,  31,  31,  31,  31,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,
+             31,  31,  31,  31,  31,  31,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,
+             31,  31,  31,  31,  31,  31,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,
+             31,  31,  31,  31,  31,  31,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,
+             31,  31,  31,  31,  31,  31,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,
+             31,  31,  31,  31,  31,  31,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,
+             31,  31,  31,  31,  31,  31,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,
+        }, {
+             32,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  30,  30,  30,  30,  30,
+             31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  30,  30,  30,
+             31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,
+             31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,
+             31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,
+             31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,
+             31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,
+             31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,
+             31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  32,  32,  32,
+             31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  32,  32,  32,  32,  32,  32,  32,
+             31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  32,  32,  32,  32,  32,  32,  32,  32,  32,
+             31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  32,  32,  32,  32,  32,  32,  32,  32,  32,
+             31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  32,  32,  32,  32,  32,  32,  32,  32,  32,
+             31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  32,  32,  32,  32,  32,  32,  32,  32,  32,
+             31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  32,  32,  32,  32,  32,  32,  32,  32,  32,
+             31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  32,  32,  32,  32,  32,  32,  32,  32,  32,
+        },
+    },
+};
+
+static const uint8_t qm_tbl_32x32_t[][2][528] = {
+    {
+        {
+             32,
+             31,  32,
+             31,  32,  32,
+             31,  32,  32,  32,
+             31,  32,  32,  33,  33,
+             32,  32,  32,  33,  34,  35,
+             34,  34,  33,  34,  35,  37,  39,
+             35,  34,  34,  35,  36,  37,  41,  43,
+             36,  35,  34,  35,  36,  38,  42,  45,  48,
+             39,  38,  37,  38,  39,  40,  45,  47,  50,  54,
+             44,  42,  41,  41,  42,  42,  47,  50,  54,  58,  63,
+             46,  44,  42,  43,  44,  44,  49,  52,  55,  59,  65,  67,
+             48,  46,  44,  45,  45,  46,  51,  53,  57,  61,  67,  69,  71,
+             54,  51,  49,  49,  50,  49,  54,  57,  60,  65,  71,  74,  76,  82,
+             59,  56,  54,  54,  54,  53,  58,  61,  64,  69,  75,  78,  80,  87,  92,
+             62,  59,  56,  56,  56,  55,  60,  63,  66,  71,  77,  80,  83,  89,  95,  98,
+             65,  62,  59,  59,  59,  58,  63,  65,  68,  73,  79,  82,  85,  92,  98, 101, 105,
+             71,  68,  65,  64,  64,  63,  68,  70,  73,  78,  84,  87,  90,  97, 103, 107, 111, 117,
+             80,  76,  72,  72,  71,  69,  74,  76,  79,  84,  90,  93,  96, 104, 110, 114, 118, 125, 134,
+             81,  77,  73,  73,  72,  70,  75,  77,  80,  85,  91,  94,  97, 105, 111, 115, 119, 126, 135, 137,
+             83,  78,  75,  74,  74,  72,  76,  79,  81,  86,  92,  95,  99, 106, 113, 117, 121, 128, 137, 138, 140,
+             88,  84,  80,  79,  78,  76,  80,  82,  85,  91,  95,  98, 103, 111, 115, 119, 126, 134, 139, 144, 147, 152,
+             91,  86,  83,  82,  81,  79,  81,  84,  88,  92,  95, 100, 107, 110, 115, 123, 127, 132, 140, 147, 151, 154, 159,
+             94,  89,  86,  85,  84,  82,  82,  86,  90,  92,  97, 103, 105, 111, 119, 121, 128, 136, 139, 146, 156, 158, 161, 166,
+             97,  92,  90,  88,  86,  85,  84,  89,  91,  95, 100, 102, 108, 114, 116, 125, 130, 133, 143, 148, 152, 163, 166, 168, 174,
+            101,  95,  93,  91,  89,  89,  87,  91,  93,  98, 101, 105, 111, 113, 120, 126, 130, 138, 142, 149, 157, 159, 171, 174, 176, 183,
+            104,  99,  97,  94,  93,  93,  90,  92,  96, 100, 102, 108, 111, 116, 122, 125, 134, 137, 144, 151, 155, 165, 169, 179, 182, 184, 191,
+            107, 102, 101,  97,  96,  96,  93,  93,  99, 101, 105, 110, 113, 120, 122, 129, 133, 140, 146, 150, 161, 163, 173, 178, 187, 191, 193, 200,
+            111, 105, 104, 101, 100,  99,  97,  96, 102, 103, 109, 111, 117, 120, 125, 131, 135, 143, 146, 156, 158, 168, 173, 180, 189, 195, 200, 202, 210,
+            115, 109, 108, 104, 104, 102, 101, 100, 103, 106, 111, 113, 119, 121, 129, 131, 140, 142, 151, 155, 162, 168, 176, 183, 188, 199, 204, 210, 212, 220,
+            119, 113, 112, 107, 107, 106, 105, 103, 105, 110, 112, 117, 120, 125, 130, 135, 140, 145, 152, 157, 165, 169, 179, 183, 193, 197, 210, 214, 220, 222, 231,
+            123, 116, 116, 111, 111, 109, 110, 107, 107, 114, 114, 121, 122, 130, 130, 140, 140, 150, 151, 163, 164, 176, 177, 190, 191, 204, 206, 222, 224, 230, 232, 242,
+        }, {
+             32,
+             31,  31,
+             30,  31,  32,
+             32,  33,  33,  35,
+             33,  34,  35,  37,  39,
+             36,  38,  40,  41,  43,  47,
+             41,  42,  42,  43,  45,  47,  48,
+             45,  45,  44,  45,  46,  47,  49,  50,
+             49,  47,  46,  47,  47,  48,  50,  51,  53,
+             48,  47,  45,  46,  46,  46,  49,  51,  53,  54,
+             49,  47,  45,  45,  45,  45,  49,  51,  53,  55,  58,
+             50,  47,  45,  46,  46,  46,  49,  51,  54,  56,  59,  60,
+             50,  48,  46,  46,  46,  46,  50,  52,  54,  56,  60,  60,  61,
+             52,  50,  47,  47,  47,  47,  50,  52,  54,  57,  61,  62,  63,  66,
+             54,  52,  49,  49,  49,  48,  52,  53,  55,  58,  62,  64,  65,  68,  71,
+             56,  53,  51,  50,  50,  49,  52,  54,  56,  59,  63,  64,  66,  69,  72,  73,
+             57,  54,  52,  51,  51,  50,  53,  55,  56,  60,  63,  65,  67,  70,  73,  75,  76,
+             60,  57,  54,  54,  53,  52,  55,  57,  58,  61,  65,  67,  68,  72,  75,  77,  79,  82,
+             63,  60,  57,  57,  56,  54,  57,  59,  60,  63,  67,  69,  71,  75,  78,  80,  82,  85,  89,
+             64,  61,  58,  57,  57,  55,  58,  59,  61,  64,  67,  69,  71,  75,  78,  80,  82,  85,  89,  90,
+             65,  61,  58,  58,  57,  55,  58,  60,  61,  64,  68,  70,  71,  75,  79,  81,  83,  86,  90,  91,  91,
+             67,  63,  61,  60,  59,  57,  60,  61,  63,  66,  69,  70,  73,  77,  79,  81,  85,  88,  90,  92,  94,  96,
+             68,  64,  62,  61,  60,  58,  59,  61,  64,  66,  67,  71,  74,  75,  78,  82,  84,  86,  90,  93,  94,  96,  98,
+             69,  65,  63,  62,  61,  59,  59,  62,  64,  65,  68,  71,  72,  75,  79,  80,  83,  87,  89,  92,  96,  97,  98, 100,
+             70,  66,  64,  63,  62,  61,  60,  63,  64,  66,  69,  70,  73,  76,  77,  81,  84,  85,  89,  92,  93,  98,  99, 100, 102,
+             71,  67,  66,  64,  63,  62,  61,  63,  64,  67,  68,  70,  74,  75,  78,  81,  83,  86,  88,  91,  94,  95, 100, 101, 102, 104,
+             72,  68,  67,  65,  64,  64,  61,  63,  65,  67,  68,  71,  73,  75,  78,  79,  84,  85,  88,  91,  93,  97,  98, 102, 103, 104, 106,
+             73,  69,  68,  66,  65,  65,  63,  63,  66,  67,  69,  71,  73,  76,  77,  81,  82,  85,  88,  90,  94,  95,  99, 101, 104, 105, 106, 109,
+             74,  70,  70,  67,  66,  66,  64,  63,  66,  67,  70,  71,  74,  75,  78,  80,  82,  86,  87,  91,  92,  96,  98, 101, 104, 106, 108, 108, 111,
+             75,  71,  71,  68,  68,  67,  66,  64,  66,  68,  70,  71,  74,  75,  79,  79,  84,  84,  88,  90,  93,  95,  98, 101, 103, 107, 108, 110, 111, 113,
+             76,  72,  72,  69,  69,  68,  67,  65,  66,  69,  70,  72,  74,  76,  78,  81,  83,  85,  88,  90,  93,  95,  98, 100, 104, 105, 109, 111, 112, 113, 116,
+             78,  74,  74,  70,  70,  69,  69,  66,  66,  70,  70,  74,  74,  77,  78,  82,  82,  86,  87,  92,  92,  96,  97, 102, 102, 107, 107, 112, 113, 115, 115, 118,
+        },
+    }, {
+        {
+             32,
+             31,  32,
+             31,  32,  32,
+             31,  32,  32,  32,
+             31,  32,  32,  32,  33,
+             32,  32,  32,  33,  34,  35,
+             32,  33,  33,  33,  34,  36,  36,
+             34,  34,  33,  34,  35,  37,  38,  39,
+             36,  35,  34,  35,  36,  38,  40,  42,  48,
+             38,  37,  36,  36,  38,  39,  41,  44,  50,  51,
+             39,  38,  37,  38,  39,  40,  42,  45,  50,  52,  54,
+             44,  42,  41,  41,  42,  42,  44,  47,  54,  56,  58,  63,
+             47,  45,  44,  44,  45,  45,  47,  50,  56,  58,  60,  66,  69,
+             49,  47,  46,  45,  46,  46,  48,  51,  57,  60,  62,  68,  71,  73,
+             54,  51,  50,  49,  50,  49,  51,  54,  60,  63,  65,  71,  75,  77,  82,
+             59,  56,  54,  54,  54,  53,  55,  58,  64,  67,  69,  75,  79,  81,  87,  92,
+             61,  58,  56,  56,  56,  55,  57,  60,  65,  68,  70,  77,  81,  83,  89,  94,  97,
+             65,  62,  60,  59,  59,  58,  60,  63,  68,  71,  73,  79,  84,  87,  92,  98, 101, 105,
+             71,  68,  65,  65,  64,  63,  65,  68,  73,  76,  78,  84,  89,  92,  97, 103, 106, 111, 117,
+             76,  72,  70,  69,  68,  66,  68,  71,  76,  79,  81,  88,  92,  95, 101, 107, 110, 115, 122, 127,
+             80,  76,  73,  72,  71,  69,  71,  74,  79,  82,  84,  90,  95,  98, 104, 110, 113, 118, 125, 130, 134,
+             83,  78,  76,  75,  74,  72,  73,  76,  81,  84,  86,  92,  97, 100, 106, 113, 116, 121, 128, 133, 137, 140,
+             86,  82,  79,  78,  77,  74,  76,  79,  84,  87,  89,  95, 100, 103, 109, 116, 119, 124, 131, 136, 140, 144, 147,
+             89,  85,  82,  81,  79,  78,  78,  82,  86,  87,  92,  97, 100, 105, 112, 114, 120, 128, 131, 136, 146, 147, 150, 155,
+             92,  88,  85,  84,  82,  81,  80,  85,  86,  90,  95,  97, 102, 107, 110, 117, 122, 125, 134, 138, 142, 152, 154, 156, 162,
+             95,  90,  88,  86,  85,  84,  82,  86,  88,  93,  95,  99, 105, 106, 113, 118, 121, 129, 132, 139, 146, 148, 159, 161, 163, 169,
+             98,  93,  91,  89,  88,  87,  85,  87,  90,  94,  96, 102, 104, 109, 114, 117, 126, 128, 134, 141, 145, 154, 157, 166, 168, 170, 176,
+            101,  96,  95,  92,  91,  90,  88,  88,  93,  95,  99, 103, 106, 112, 114, 121, 124, 131, 136, 140, 149, 151, 160, 165, 173, 176, 178, 184,
+            104,  99,  98,  95,  94,  93,  91,  90,  95,  96, 102, 103, 109, 112, 117, 122, 125, 133, 136, 145, 146, 156, 160, 167, 174, 180, 184, 186, 193,
+            108, 102, 101,  98,  97,  96,  95,  93,  97, 100, 104, 106, 111, 113, 121, 122, 130, 132, 140, 143, 150, 155, 162, 169, 174, 183, 188, 192, 194, 201,
+            111, 105, 105, 101, 100,  99,  98,  96,  98, 103, 105, 109, 112, 117, 121, 125, 130, 135, 141, 146, 152, 156, 165, 169, 178, 181, 193, 196, 201, 202, 210,
+            114, 109, 109, 104, 104, 102, 102,  99, 100, 106, 106, 113, 113, 120, 121, 129, 130, 139, 140, 151, 151, 162, 162, 175, 176, 187, 188, 203, 204, 210, 211, 219,
+        }, {
+             32,
+             31,  31,
+             30,  31,  31,
+             31,  32,  32,  33,
+             33,  34,  35,  36,  39,
+             36,  38,  39,  40,  43,  47,
+             38,  40,  41,  41,  44,  47,  47,
+             41,  42,  42,  43,  45,  47,  48,  48,
+             49,  47,  46,  46,  47,  48,  49,  50,  53,
+             49,  47,  46,  46,  46,  47,  48,  50,  53,  53,
+             48,  47,  46,  45,  46,  46,  48,  49,  53,  54,  54,
+             49,  47,  45,  45,  45,  45,  47,  49,  53,  55,  55,  58,
+             50,  48,  46,  46,  46,  46,  47,  50,  54,  55,  56,  59,  61,
+             51,  48,  47,  46,  47,  46,  47,  50,  54,  55,  56,  60,  61,  62,
+             52,  50,  48,  47,  47,  47,  48,  50,  54,  56,  57,  61,  63,  64,  66,
+             54,  52,  50,  49,  49,  48,  49,  52,  55,  57,  58,  62,  64,  66,  68,  71,
+             55,  53,  51,  50,  50,  49,  50,  52,  56,  58,  59,  63,  65,  66,  69,  72,  73,
+             57,  54,  52,  51,  51,  50,  51,  53,  56,  58,  60,  63,  66,  67,  70,  73,  74,  76,
+             60,  57,  55,  54,  53,  52,  53,  55,  58,  60,  61,  65,  68,  69,  72,  75,  77,  79,  82,
+             62,  59,  57,  56,  55,  53,  54,  56,  59,  61,  63,  66,  69,  70,  74,  77,  78,  80,  84,  86,
+             63,  60,  58,  57,  56,  54,  55,  57,  60,  62,  63,  67,  70,  71,  75,  78,  79,  82,  85,  87,  89,
+             65,  61,  59,  58,  57,  55,  56,  58,  61,  63,  64,  68,  71,  72,  75,  79,  80,  83,  86,  88,  90,  91,
+             66,  63,  60,  59,  58,  56,  58,  59,  62,  64,  65,  69,  72,  73,  76,  80,  81,  84,  87,  90,  91,  93,  94,
+             67,  64,  62,  61,  59,  58,  58,  60,  63,  64,  66,  69,  71,  73,  77,  78,  81,  85,  86,  89,  93,  94,  95,  97,
+             68,  65,  63,  62,  60,  59,  58,  61,  62,  64,  67,  68,  71,  74,  75,  79,  81,  83,  87,  89,  91,  95,  96,  97,  99,
+             69,  66,  64,  63,  61,  61,  59,  61,  62,  65,  66,  68,  72,  73,  76,  78,  80,  84,  85,  88,  91,  92,  97,  98,  98, 101,
+             70,  67,  65,  63,  62,  62,  60,  61,  63,  65,  66,  69,  71,  73,  76,  77,  81,  83,  85,  88,  90,  94,  95,  99, 100, 100, 103,
+             71,  67,  67,  64,  63,  63,  61,  61,  64,  65,  67,  69,  71,  74,  75,  78,  80,  83,  85,  87,  91,  92,  95,  97, 100, 102, 102, 105,
+             72,  68,  68,  65,  65,  64,  62,  62,  64,  65,  68,  69,  72,  73,  76,  78,  80,  83,  84,  88,  89,  93,  95,  97, 100, 102, 104, 104, 107,
+             73,  69,  69,  66,  66,  65,  64,  63,  64,  66,  68,  69,  72,  73,  77,  77,  81,  82,  86,  87,  90,  92,  95,  97,  99, 103, 104, 106, 106, 109,
+             74,  70,  70,  67,  67,  66,  65,  63,  64,  67,  68,  70,  72,  74,  76,  78,  80,  82,  85,  87,  90,  91,  95,  96, 100, 101, 105, 106, 108, 108, 111,
+             75,  71,  71,  68,  68,  66,  66,  64,  64,  68,  68,  71,  71,  75,  75,  79,  79,  83,  84,  88,  89,  93,  93,  98,  98, 102, 103, 108, 108, 110, 110, 113,
+        },
+    }, {
+        {
+             32,
+             31,  32,
+             31,  32,  32,
+             31,  32,  32,  32,
+             31,  32,  32,  32,  33,
+             32,  32,  32,  32,  33,  34,
+             32,  32,  32,  32,  34,  34,  35,
+             34,  34,  33,  33,  35,  36,  37,  39,
+             34,  34,  34,  34,  36,  36,  37,  41,  42,
+             36,  35,  34,  34,  36,  37,  38,  42,  45,  48,
+             39,  38,  38,  37,  39,  40,  40,  45,  47,  50,  54,
+             41,  39,  39,  38,  40,  40,  41,  46,  48,  51,  55,  56,
+             44,  42,  41,  41,  42,  42,  42,  47,  50,  54,  58,  59,  63,
+             48,  46,  45,  44,  45,  45,  45,  50,  53,  56,  61,  62,  66,  70,
+             49,  47,  46,  45,  46,  46,  46,  51,  53,  57,  62,  63,  68,  71,  73,
+             54,  51,  50,  49,  50,  49,  49,  54,  56,  60,  65,  67,  71,  76,  77,  82,
+             58,  55,  54,  53,  53,  53,  52,  57,  59,  63,  68,  70,  74,  79,  81,  86,  90,
+             59,  57,  55,  54,  54,  54,  54,  59,  61,  64,  69,  71,  75,  80,  82,  87,  91,  93,
+             65,  62,  60,  59,  59,  58,  58,  63,  65,  68,  73,  75,  79,  85,  87,  92,  97,  99, 105,
+             69,  66,  64,  63,  63,  62,  61,  66,  68,  71,  76,  78,  83,  88,  90,  96, 100, 102, 109, 113,
+             71,  68,  66,  65,  64,  63,  63,  68,  70,  73,  78,  80,  84,  90,  92,  97, 102, 104, 111, 115, 117,
+             80,  76,  73,  72,  71,  70,  69,  74,  76,  79,  84,  86,  90,  96,  98, 104, 109, 111, 118, 123, 125, 134,
+             81,  77,  75,  74,  73,  72,  71,  75,  77,  80,  85,  87,  91,  97,  99, 105, 110, 112, 120, 125, 127, 136, 137,
+             83,  78,  76,  75,  74,  73,  72,  76,  78,  81,  86,  88,  92,  98, 100, 106, 111, 113, 121, 126, 128, 137, 139, 140,
+             87,  83,  81,  79,  78,  77,  75,  80,  82,  85,  90,  91,  96, 101, 103, 110, 114, 117, 125, 129, 133, 142, 143, 145, 150,
+             90,  85,  83,  81,  80,  79,  78,  81,  83,  87,  89,  93,  98, 100, 106, 110, 114, 121, 124, 130, 136, 138, 148, 149, 151, 156,
+             93,  88,  86,  84,  83,  82,  80,  82,  85,  89,  90,  96,  98, 102, 107, 109, 118, 120, 125, 131, 134, 143, 145, 153, 156, 157, 163,
+             95,  90,  89,  86,  85,  85,  83,  83,  88,  89,  93,  97,  99, 105, 106, 113, 116, 122, 127, 130, 139, 140, 148, 153, 159, 162, 164, 169,
+             98,  93,  92,  89,  88,  87,  86,  85,  89,  90,  96,  97, 102, 105, 109, 114, 117, 124, 126, 134, 136, 144, 148, 154, 160, 166, 169, 170, 176,
+            101,  96,  95,  91,  91,  90,  89,  87,  90,  93,  97,  99, 104, 105, 112, 113, 121, 122, 130, 133, 139, 144, 150, 155, 160, 168, 172, 176, 177, 184,
+            104,  99,  98,  94,  94,  92,  92,  90,  92,  96,  98, 102, 104, 109, 112, 116, 121, 125, 130, 135, 141, 144, 152, 155, 163, 166, 177, 179, 184, 185, 191,
+            107, 101, 101,  97,  97,  95,  95,  93,  93,  99,  99, 105, 105, 112, 112, 120, 120, 129, 129, 139, 140, 149, 149, 161, 161, 172, 172, 185, 186, 191, 192, 199,
+        }, {
+             32,
+             31,  31,
+             30,  31,  31,
+             30,  31,  31,  32,
+             33,  34,  35,  35,  39,
+             35,  36,  37,  37,  41,  43,
+             36,  38,  39,  40,  43,  45,  47,
+             41,  42,  42,  42,  45,  46,  47,  48,
+             44,  44,  44,  44,  46,  46,  47,  49,  50,
+             49,  47,  47,  46,  47,  47,  48,  50,  51,  53,
+             48,  47,  46,  45,  46,  46,  46,  49,  51,  53,  54,
+             48,  47,  46,  45,  46,  46,  46,  49,  51,  53,  54,  55,
+             49,  47,  46,  45,  45,  45,  45,  49,  51,  53,  55,  56,  58,
+             50,  48,  47,  46,  46,  46,  46,  50,  51,  54,  56,  57,  59,  61,
+             51,  48,  47,  46,  47,  46,  46,  50,  51,  54,  56,  57,  60,  62,  62,
+             52,  50,  48,  47,  47,  47,  47,  50,  52,  54,  57,  58,  61,  63,  64,  66,
+             54,  51,  50,  49,  49,  48,  48,  51,  53,  55,  58,  59,  62,  64,  65,  68,  70,
+             55,  52,  51,  50,  49,  49,  48,  52,  53,  55,  59,  60,  62,  65,  66,  68,  70,  71,
+             57,  54,  53,  52,  51,  50,  50,  53,  54,  56,  60,  61,  63,  66,  67,  70,  73,  73,  76,
+             59,  56,  54,  53,  53,  52,  51,  54,  56,  58,  61,  62,  65,  68,  69,  72,  74,  75,  78,  80,
+             60,  57,  55,  54,  53,  53,  52,  55,  56,  58,  61,  63,  65,  68,  69,  72,  75,  76,  79,  81,  82,
+             63,  60,  58,  57,  56,  55,  54,  57,  59,  60,  63,  65,  67,  70,  71,  75,  77,  78,  82,  84,  85,  89,
+             64,  61,  59,  58,  57,  56,  55,  58,  59,  61,  64,  65,  68,  71,  72,  75,  78,  79,  82,  85,  86,  89,  90,
+             65,  61,  60,  58,  57,  56,  55,  58,  59,  61,  64,  65,  68,  71,  72,  75,  78,  79,  83,  85,  86,  90,  91,  91,
+             67,  63,  61,  60,  59,  58,  57,  60,  61,  63,  65,  66,  69,  72,  73,  77,  79,  80,  84,  86,  88,  92,  93,  93,  95,
+             68,  64,  63,  61,  60,  59,  58,  60,  61,  63,  65,  67,  70,  71,  74,  76,  78,  81,  83,  86,  88,  89,  94,  94,  95,  97,
+             68,  65,  64,  62,  61,  60,  58,  59,  61,  64,  64,  68,  69,  71,  74,  75,  79,  80,  83,  86,  87,  91,  92,  95,  96,  97,  99,
+             69,  66,  65,  63,  62,  61,  59,  59,  62,  63,  65,  67,  69,  72,  72,  76,  78,  80,  83,  84,  88,  89,  92,  94,  97,  98,  99, 101,
+             70,  67,  66,  63,  63,  62,  61,  60,  63,  63,  66,  67,  69,  71,  73,  76,  77,  81,  82,  85,  86,  90,  91,  94,  96,  99, 100, 100, 103,
+             71,  67,  67,  64,  64,  63,  62,  61,  62,  64,  66,  67,  70,  71,  74,  74,  78,  79,  83,  84,  87,  89,  91,  94,  95,  99, 100, 102, 102, 104,
+             72,  68,  68,  65,  65,  64,  63,  61,  62,  65,  66,  68,  69,  71,  73,  75,  77,  79,  82,  84,  87,  88,  92,  93,  96,  97, 101, 102, 104, 104, 106,
+             73,  69,  69,  66,  66,  64,  64,  62,  62,  66,  66,  69,  69,  72,  73,  76,  77,  81,  81,  85,  85,  89,  90,  94,  94,  99,  99, 104, 104, 106, 106, 108,
+        },
+    }, {
+        {
+             32,
+             31,  32,
+             31,  32,  32,
+             31,  32,  32,  32,
+             31,  32,  32,  32,  33,
+             31,  32,  32,  32,  33,  33,
+             32,  32,  32,  32,  33,  34,  35,
+             32,  33,  33,  33,  34,  34,  36,  36,
+             34,  34,  34,  33,  35,  35,  37,  38,  39,
+             35,  35,  34,  34,  36,  36,  38,  39,  42,  46,
+             36,  35,  35,  34,  36,  36,  38,  40,  42,  47,  48,
+             39,  38,  38,  37,  39,  39,  40,  42,  45,  49,  50,  54,
+             41,  40,  39,  38,  40,  40,  41,  43,  46,  50,  52,  55,  57,
+             44,  42,  42,  41,  42,  42,  42,  44,  47,  52,  54,  58,  60,  63,
+             47,  45,  45,  44,  44,  45,  45,  47,  50,  55,  56,  60,  62,  66,  69,
+             48,  46,  45,  44,  45,  45,  46,  47,  51,  55,  57,  61,  63,  67,  70,  71,
+             54,  51,  50,  49,  49,  50,  49,  51,  54,  59,  60,  65,  67,  71,  75,  76,  82,
+             56,  53,  52,  51,  51,  51,  51,  53,  56,  60,  61,  66,  69,  73,  77,  78,  84,  86,
+             59,  56,  55,  54,  54,  54,  53,  55,  58,  62,  64,  69,  71,  75,  79,  80,  87,  89,  92,
+             64,  61,  60,  58,  58,  58,  57,  59,  62,  66,  67,  72,  75,  79,  83,  84,  91,  93,  97, 102,
+             65,  62,  61,  59,  59,  59,  58,  60,  63,  67,  68,  73,  75,  79,  84,  85,  92,  94,  98, 103, 105,
+             71,  68,  67,  65,  64,  64,  63,  65,  68,  72,  73,  78,  80,  84,  89,  90,  97, 100, 103, 109, 111, 117,
+             74,  71,  69,  68,  67,  67,  65,  67,  70,  74,  75,  80,  83,  86,  91,  93, 100, 102, 106, 112, 114, 120, 123,
+             80,  76,  74,  72,  71,  71,  69,  71,  74,  78,  79,  84,  86,  90,  95,  96, 104, 106, 110, 116, 118, 125, 128, 134,
+             82,  78,  76,  74,  73,  73,  71,  73,  76,  79,  80,  86,  88,  92,  97,  98, 106, 108, 112, 118, 120, 127, 131, 136, 139,
+             83,  78,  77,  75,  74,  74,  72,  73,  76,  80,  81,  86,  89,  92,  97,  99, 106, 109, 113, 119, 121, 128, 131, 137, 139, 140,
+             87,  83,  81,  79,  78,  78,  75,  77,  80,  83,  85,  90,  92,  96, 100, 102, 110, 112, 117, 122, 125, 133, 135, 142, 144, 145, 150,
+             90,  85,  84,  81,  80,  80,  78,  78,  82,  84,  87,  91,  93,  98,  99, 106, 108, 113, 118, 121, 129, 130, 137, 141, 147, 150, 151, 156,
+             92,  88,  87,  84,  83,  82,  80,  80,  84,  85,  90,  91,  95,  98, 102, 106, 109, 115, 117, 125, 126, 134, 137, 142, 148, 152, 155, 156, 162,
+             95,  90,  89,  86,  85,  84,  83,  82,  85,  87,  91,  92,  97,  98, 105, 105, 112, 114, 121, 123, 129, 133, 138, 143, 147, 155, 158, 161, 162, 168,
+             97,  92,  92,  88,  88,  86,  86,  84,  85,  90,  91,  95,  97, 101, 104, 108, 112, 116, 121, 125, 130, 133, 140, 143, 150, 152, 162, 164, 168, 168, 174,
+            100,  95,  95,  90,  90,  89,  89,  86,  86,  92,  92,  97,  98, 104, 104, 111, 111, 119, 119, 128, 129, 137, 137, 147, 148, 157, 158, 169, 170, 174, 175, 181,
+        }, {
+             32,
+             31,  31,
+             31,  31,  31,
+             30,  31,  31,  32,
+             33,  34,  34,  34,  37,
+             33,  34,  35,  35,  38,  39,
+             36,  38,  39,  40,  42,  43,  47,
+             38,  40,  40,  41,  43,  44,  47,  47,
+             41,  42,  42,  42,  44,  45,  47,  48,  48,
+             47,  46,  46,  45,  46,  47,  47,  48,  50,  52,
+             49,  47,  47,  46,  47,  47,  48,  49,  50,  52,  53,
+             48,  47,  46,  45,  46,  46,  46,  48,  49,  52,  53,  54,
+             49,  47,  46,  45,  46,  46,  46,  47,  49,  52,  53,  55,  55,
+             49,  47,  46,  45,  45,  45,  45,  47,  49,  52,  53,  55,  57,  58,
+             50,  48,  47,  46,  46,  46,  46,  47,  50,  53,  54,  56,  57,  59,  61,
+             50,  48,  47,  46,  46,  46,  46,  47,  50,  53,  54,  56,  58,  60,  61,  61,
+             52,  50,  49,  47,  47,  47,  47,  48,  50,  53,  54,  57,  59,  61,  63,  63,  66,
+             53,  50,  50,  48,  48,  48,  47,  49,  51,  54,  55,  58,  59,  62,  64,  64,  67,  68,
+             54,  52,  51,  49,  49,  49,  48,  49,  52,  55,  55,  58,  60,  62,  64,  65,  68,  69,  71,
+             56,  54,  53,  51,  51,  51,  49,  51,  53,  55,  56,  59,  61,  63,  66,  66,  70,  71,  73,  75,
+             57,  54,  53,  52,  51,  51,  50,  51,  53,  56,  56,  60,  61,  63,  66,  67,  70,  71,  73,  76,  76,
+             60,  57,  56,  54,  53,  53,  52,  53,  55,  58,  58,  61,  63,  65,  68,  68,  72,  73,  75,  78,  79,  82,
+             61,  58,  57,  55,  55,  54,  53,  54,  56,  58,  59,  62,  64,  66,  69,  69,  73,  74,  76,  79,  80,  83,  84,
+             63,  60,  59,  57,  56,  56,  54,  55,  57,  60,  60,  63,  65,  67,  70,  71,  75,  76,  78,  81,  82,  85,  86,  89,
+             64,  61,  60,  58,  57,  57,  55,  56,  58,  60,  61,  64,  66,  68,  70,  71,  75,  77,  79,  82,  82,  86,  87,  90,  91,
+             65,  61,  60,  58,  57,  57,  55,  56,  58,  61,  61,  64,  66,  68,  71,  71,  75,  77,  79,  82,  83,  86,  88,  90,  91,  91,
+             67,  63,  62,  60,  59,  59,  57,  58,  60,  62,  63,  66,  67,  69,  72,  73,  77,  78,  80,  83,  84,  88,  89,  92,  93,  93,  95,
+             67,  64,  63,  61,  60,  60,  58,  58,  61,  61,  63,  65,  67,  70,  70,  74,  75,  78,  80,  81,  85,  86,  89,  91,  93,  94,  95,  97,
+             68,  65,  64,  62,  61,  60,  59,  58,  61,  61,  64,  65,  67,  69,  71,  73,  75,  78,  79,  83,  83,  87,  88,  91,  93,  95,  96,  97,  99,
+             69,  65,  65,  62,  62,  61,  60,  59,  61,  62,  64,  65,  68,  68,  72,  72,  76,  76,  80,  81,  84,  86,  88,  90,  92,  95,  96,  98,  98, 100,
+             70,  66,  66,  63,  63,  62,  61,  60,  60,  63,  64,  66,  67,  69,  71,  73,  75,  77,  79,  81,  84,  85,  88,  89,  93,  93,  97,  98, 100, 100, 102,
+             71,  67,  67,  64,  64,  62,  62,  60,  60,  64,  64,  67,  67,  70,  70,  74,  74,  78,  78,  82,  82,  86,  86,  91,  91,  95,  95, 100, 100, 101, 101, 104,
+        },
+    }, {
+        {
+             32,
+             31,  32,
+             31,  32,  32,
+             31,  32,  32,  32,
+             31,  32,  32,  32,  32,
+             31,  32,  32,  32,  33,  33,
+             32,  32,  32,  32,  33,  33,  34,
+             32,  32,  32,  32,  33,  34,  35,  35,
+             33,  33,  33,  33,  34,  35,  36,  36,  38,
+             34,  34,  34,  33,  34,  35,  36,  37,  39,  39,
+             36,  35,  35,  34,  35,  36,  37,  38,  42,  42,  48,
+             36,  35,  35,  34,  35,  36,  38,  38,  42,  43,  48,  49,
+             39,  38,  38,  37,  38,  39,  40,  40,  44,  45,  50,  51,  54,
+             41,  39,  39,  38,  39,  40,  40,  41,  45,  46,  51,  52,  55,  56,
+             44,  42,  42,  41,  41,  42,  42,  42,  46,  47,  54,  54,  58,  59,  63,
+             46,  44,  44,  42,  43,  44,  44,  44,  48,  49,  55,  55,  59,  61,  65,  67,
+             48,  46,  46,  44,  45,  45,  45,  46,  50,  51,  57,  57,  61,  63,  67,  69,  71,
+             52,  50,  49,  48,  48,  48,  48,  48,  52,  53,  59,  59,  64,  65,  70,  72,  74,  78,
+             54,  51,  51,  49,  49,  50,  49,  49,  53,  54,  60,  60,  65,  67,  71,  74,  76,  80,  82,
+             58,  56,  55,  53,  53,  53,  53,  53,  57,  58,  63,  64,  68,  70,  75,  77,  80,  84,  86,  91,
+             59,  56,  56,  54,  54,  54,  53,  53,  57,  58,  64,  64,  69,  70,  75,  78,  80,  85,  87,  91,  92,
+             65,  62,  61,  59,  59,  59,  58,  58,  62,  63,  68,  68,  73,  75,  79,  82,  85,  90,  92,  97,  98, 105,
+             66,  63,  63,  60,  60,  60,  59,  59,  63,  64,  69,  69,  74,  76,  80,  83,  86,  91,  93,  98,  99, 106, 107,
+             71,  68,  67,  65,  65,  64,  63,  63,  67,  68,  73,  73,  78,  80,  84,  87,  90,  95,  97, 103, 103, 111, 112, 117,
+             74,  71,  70,  68,  67,  67,  66,  65,  69,  70,  75,  75,  80,  82,  86,  89,  93,  97, 100, 105, 106, 114, 115, 120, 123,
+             80,  76,  75,  72,  72,  71,  70,  69,  73,  74,  79,  79,  84,  86,  90,  93,  96, 101, 104, 110, 110, 118, 119, 125, 128, 134,
+             81,  77,  77,  74,  73,  73,  71,  71,  74,  75,  80,  80,  85,  87,  91,  94,  98, 103, 105, 111, 112, 120, 121, 127, 130, 136, 137,
+             83,  78,  78,  75,  74,  74,  72,  72,  75,  76,  81,  81,  86,  88,  92,  95,  99, 104, 106, 112, 113, 121, 122, 128, 131, 137, 139, 140,
+             86,  82,  81,  78,  77,  77,  75,  74,  78,  79,  84,  84,  89,  91,  95,  98, 101, 106, 109, 115, 116, 124, 125, 131, 135, 140, 142, 144, 147,
+             89,  84,  84,  80,  80,  79,  78,  77,  79,  81,  85,  86,  91,  92,  97,  98, 104, 106, 112, 114, 119, 123, 128, 132, 135, 142, 145, 148, 149, 153,
+             91,  86,  86,  82,  82,  81,  80,  79,  80,  84,  85,  88,  91,  94,  97, 100, 104, 107, 112, 115, 120, 123, 129, 132, 138, 140, 148, 150, 153, 154, 159,
+             93,  88,  88,  84,  84,  83,  83,  80,  81,  86,  86,  91,  91,  96,  97, 103, 103, 110, 110, 118, 119, 126, 126, 135, 136, 144, 144, 155, 155, 159, 159, 164,
+        }, {
+             32,
+             31,  31,
+             31,  31,  31,
+             30,  31,  31,  32,
+             31,  32,  32,  33,  34,
+             33,  34,  35,  35,  37,  39,
+             35,  37,  37,  38,  39,  41,  44,
+             36,  38,  39,  40,  41,  43,  46,  47,
+             40,  41,  41,  42,  43,  44,  46,  47,  48,
+             41,  42,  42,  42,  43,  45,  46,  47,  48,  48,
+             49,  47,  47,  46,  46,  47,  47,  48,  50,  50,  53,
+             49,  47,  47,  46,  46,  47,  47,  47,  49,  50,  53,  53,
+             48,  47,  47,  45,  46,  46,  46,  46,  49,  49,  53,  53,  54,
+             48,  47,  46,  45,  45,  46,  46,  46,  49,  49,  53,  53,  54,  55,
+             49,  47,  46,  45,  45,  45,  45,  45,  48,  49,  53,  54,  55,  56,  58,
+             50,  47,  47,  45,  46,  46,  46,  46,  49,  49,  54,  54,  56,  57,  59,  60,
+             50,  48,  48,  46,  46,  46,  46,  46,  49,  50,  54,  54,  56,  57,  60,  60,  61,
+             52,  49,  49,  47,  47,  47,  47,  46,  49,  50,  54,  54,  57,  58,  61,  62,  63,  65,
+             52,  50,  49,  47,  47,  47,  47,  47,  49,  50,  54,  54,  57,  58,  61,  62,  63,  65,  66,
+             54,  52,  51,  49,  49,  49,  48,  48,  51,  52,  55,  55,  58,  59,  62,  63,  65,  67,  68,  70,
+             54,  52,  51,  49,  49,  49,  48,  48,  51,  52,  55,  56,  58,  60,  62,  64,  65,  67,  68,  70,  71,
+             57,  54,  54,  52,  51,  51,  50,  50,  52,  53,  56,  57,  60,  61,  63,  65,  67,  69,  70,  73,  73,  76,
+             57,  55,  54,  52,  52,  51,  51,  50,  53,  53,  57,  57,  60,  61,  64,  65,  67,  70,  71,  73,  74,  77,  77,
+             60,  57,  56,  54,  54,  53,  52,  52,  54,  55,  58,  59,  61,  63,  65,  67,  68,  71,  72,  75,  75,  79,  79,  82,
+             61,  58,  57,  55,  55,  54,  53,  53,  55,  56,  59,  59,  62,  63,  66,  68,  69,  72,  73,  76,  76,  80,  80,  83,  84,
+             63,  60,  59,  57,  57,  56,  55,  54,  57,  57,  60,  61,  63,  65,  67,  69,  71,  73,  75,  78,  78,  82,  82,  85,  86,  89,
+             64,  61,  60,  58,  57,  57,  56,  55,  57,  58,  61,  61,  64,  65,  68,  69,  71,  74,  75,  78,  78,  82,  83,  86,  87,  89,  90,
+             65,  61,  61,  58,  58,  57,  56,  55,  58,  58,  61,  62,  64,  65,  68,  70,  71,  74,  75,  78,  79,  83,  83,  86,  88,  90,  91,  91,
+             66,  63,  62,  60,  59,  58,  57,  56,  59,  59,  62,  63,  65,  66,  69,  70,  72,  75,  76,  79,  80,  84,  84,  87,  89,  91,  92,  93,  94,
+             67,  64,  63,  61,  60,  59,  58,  57,  59,  60,  62,  63,  66,  66,  70,  70,  73,  74,  77,  78,  81,  83,  85,  87,  89,  92,  93,  94,  94,  96,
+             68,  64,  64,  61,  61,  60,  59,  58,  59,  61,  62,  64,  65,  67,  69,  71,  72,  74,  77,  78,  81,  82,  85,  86,  89,  90,  94,  94,  96,  96,  98,
+             69,  65,  65,  62,  62,  61,  61,  58,  59,  62,  62,  65,  65,  68,  68,  71,  71,  75,  75,  79,  79,  83,  83,  87,  87,  91,  91,  96,  96,  97,  97,  99,
+        },
+    }, {
+        {
+             32,
+             31,  32,
+             31,  32,  32,
+             31,  32,  32,  32,
+             31,  32,  32,  32,  32,
+             31,  32,  32,  32,  32,  33,
+             31,  32,  32,  32,  32,  33,  33,
+             32,  32,  32,  32,  32,  34,  34,  35,
+             32,  32,  32,  32,  32,  34,  34,  35,  35,
+             34,  34,  34,  33,  33,  35,  35,  37,  37,  39,
+             34,  34,  34,  33,  33,  35,  35,  37,  37,  39,  39,
+             36,  35,  35,  34,  34,  36,  36,  38,  38,  42,  42,  48,
+             36,  35,  35,  34,  34,  36,  36,  38,  38,  42,  42,  48,  48,
+             39,  38,  38,  37,  37,  39,  39,  40,  40,  45,  45,  50,  50,  54,
+             39,  38,  38,  37,  37,  39,  39,  40,  40,  45,  45,  50,  50,  54,  54,
+             44,  42,  42,  41,  41,  42,  42,  42,  42,  47,  47,  54,  54,  58,  58,  63,
+             44,  42,  42,  41,  41,  42,  42,  42,  42,  47,  47,  54,  54,  58,  58,  63,  63,
+             48,  46,  46,  44,  44,  45,  45,  46,  46,  51,  51,  57,  57,  61,  61,  67,  67,  71,
+             48,  46,  46,  44,  44,  45,  45,  46,  46,  51,  51,  57,  57,  61,  61,  67,  67,  71,  71,
+             54,  51,  51,  49,  49,  50,  50,  49,  49,  54,  54,  60,  60,  65,  65,  71,  71,  76,  76,  82,
+             54,  51,  51,  49,  49,  50,  50,  49,  49,  54,  54,  60,  60,  65,  65,  71,  71,  76,  76,  82,  82,
+             59,  56,  56,  54,  54,  54,  54,  53,  53,  58,  58,  64,  64,  69,  69,  75,  75,  80,  80,  87,  87,  92,
+             59,  56,  56,  54,  54,  54,  54,  53,  53,  58,  58,  64,  64,  69,  69,  75,  75,  80,  80,  87,  87,  92,  92,
+             65,  62,  62,  59,  59,  59,  59,  58,  58,  63,  63,  68,  68,  73,  73,  79,  79,  85,  85,  92,  92,  98,  98, 105,
+             65,  62,  62,  59,  59,  59,  59,  58,  58,  63,  63,  68,  68,  73,  73,  79,  79,  85,  85,  92,  92,  98,  98, 105, 105,
+             71,  68,  68,  65,  65,  64,  64,  63,  63,  68,  68,  73,  73,  78,  78,  84,  84,  90,  90,  97,  97, 103, 103, 111, 111, 117,
+             71,  68,  68,  65,  65,  64,  64,  63,  63,  68,  68,  73,  73,  78,  78,  84,  84,  90,  90,  97,  97, 103, 103, 111, 111, 117, 117,
+             80,  76,  76,  72,  72,  71,  71,  69,  69,  74,  74,  79,  79,  84,  84,  90,  90,  96,  96, 104, 104, 110, 110, 118, 118, 125, 125, 134,
+             80,  76,  76,  72,  72,  71,  71,  69,  69,  74,  74,  79,  79,  84,  84,  90,  90,  96,  96, 104, 104, 110, 110, 118, 118, 125, 125, 134, 134,
+             83,  78,  78,  75,  75,  74,  74,  72,  72,  76,  76,  81,  81,  86,  86,  92,  92,  99,  99, 106, 106, 113, 113, 121, 121, 128, 128, 137, 137, 140,
+             83,  78,  78,  75,  75,  74,  74,  72,  72,  76,  76,  81,  81,  86,  86,  92,  92,  99,  99, 106, 106, 113, 113, 121, 121, 128, 128, 137, 137, 140, 140,
+             87,  83,  83,  79,  79,  77,  77,  75,  75,  80,  80,  84,  84,  90,  90,  96,  96, 102, 102, 109, 109, 116, 116, 124, 124, 132, 132, 141, 141, 144, 144, 149,
+        }, {
+             32,
+             31,  31,
+             31,  31,  31,
+             30,  31,  31,  32,
+             30,  31,  31,  32,  32,
+             33,  34,  34,  35,  35,  39,
+             33,  34,  34,  35,  35,  39,  39,
+             36,  38,  38,  40,  40,  43,  43,  47,
+             36,  38,  38,  40,  40,  43,  43,  47,  47,
+             41,  42,  42,  42,  42,  45,  45,  47,  47,  48,
+             41,  42,  42,  42,  42,  45,  45,  47,  47,  48,  48,
+             49,  47,  47,  46,  46,  47,  47,  48,  48,  50,  50,  53,
+             49,  47,  47,  46,  46,  47,  47,  48,  48,  50,  50,  53,  53,
+             48,  47,  47,  45,  45,  46,  46,  46,  46,  49,  49,  53,  53,  54,
+             48,  47,  47,  45,  45,  46,  46,  46,  46,  49,  49,  53,  53,  54,  54,
+             49,  47,  47,  45,  45,  45,  45,  45,  45,  49,  49,  53,  53,  55,  55,  58,
+             49,  47,  47,  45,  45,  45,  45,  45,  45,  49,  49,  53,  53,  55,  55,  58,  58,
+             50,  48,  48,  46,  46,  46,  46,  46,  46,  50,  50,  54,  54,  56,  56,  60,  60,  61,
+             50,  48,  48,  46,  46,  46,  46,  46,  46,  50,  50,  54,  54,  56,  56,  60,  60,  61,  61,
+             52,  50,  50,  47,  47,  47,  47,  47,  47,  50,  50,  54,  54,  57,  57,  61,  61,  63,  63,  66,
+             52,  50,  50,  47,  47,  47,  47,  47,  47,  50,  50,  54,  54,  57,  57,  61,  61,  63,  63,  66,  66,
+             54,  52,  52,  49,  49,  49,  49,  48,  48,  52,  52,  55,  55,  58,  58,  62,  62,  65,  65,  68,  68,  71,
+             54,  52,  52,  49,  49,  49,  49,  48,  48,  52,  52,  55,  55,  58,  58,  62,  62,  65,  65,  68,  68,  71,  71,
+             57,  54,  54,  52,  52,  51,  51,  50,  50,  53,  53,  56,  56,  60,  60,  63,  63,  67,  67,  70,  70,  73,  73,  76,
+             57,  54,  54,  52,  52,  51,  51,  50,  50,  53,  53,  56,  56,  60,  60,  63,  63,  67,  67,  70,  70,  73,  73,  76,  76,
+             60,  57,  57,  54,  54,  53,  53,  52,  52,  55,  55,  58,  58,  61,  61,  65,  65,  68,  68,  72,  72,  75,  75,  79,  79,  82,
+             60,  57,  57,  54,  54,  53,  53,  52,  52,  55,  55,  58,  58,  61,  61,  65,  65,  68,  68,  72,  72,  75,  75,  79,  79,  82,  82,
+             63,  60,  60,  57,  57,  56,  56,  54,  54,  57,  57,  60,  60,  63,  63,  67,  67,  71,  71,  75,  75,  78,  78,  82,  82,  85,  85,  89,
+             63,  60,  60,  57,  57,  56,  56,  54,  54,  57,  57,  60,  60,  63,  63,  67,  67,  71,  71,  75,  75,  78,  78,  82,  82,  85,  85,  89,  89,
+             65,  61,  61,  58,  58,  57,  57,  55,  55,  58,  58,  61,  61,  64,  64,  68,  68,  71,  71,  75,  75,  79,  79,  83,  83,  86,  86,  90,  90,  91,
+             65,  61,  61,  58,  58,  57,  57,  55,  55,  58,  58,  61,  61,  64,  64,  68,  68,  71,  71,  75,  75,  79,  79,  83,  83,  86,  86,  90,  90,  91,  91,
+             67,  63,  63,  60,  60,  59,  59,  57,  57,  60,  60,  62,  62,  66,  66,  69,  69,  72,  72,  76,  76,  80,  80,  84,  84,  88,  88,  92,  92,  93,  93,  95,
+        },
+    }, {
+        {
+             32,
+             31,  31,
+             31,  32,  32,
+             31,  32,  32,  32,
+             31,  32,  32,  32,  32,
+             31,  32,  32,  32,  32,  32,
+             31,  32,  32,  32,  32,  33,  33,
+             32,  32,  32,  32,  32,  33,  33,  34,
+             32,  32,  32,  32,  32,  33,  34,  34,  35,
+             32,  32,  32,  32,  33,  33,  34,  34,  35,  35,
+             34,  34,  34,  33,  33,  34,  35,  35,  37,  37,  39,
+             34,  34,  34,  33,  33,  34,  35,  35,  37,  37,  39,  39,
+             35,  35,  35,  34,  34,  35,  36,  36,  38,  38,  42,  42,  46,
+             36,  35,  35,  34,  34,  35,  36,  37,  38,  38,  42,  42,  47,  48,
+             38,  37,  37,  36,  36,  37,  38,  38,  39,  40,  44,  44,  48,  50,  51,
+             39,  38,  38,  38,  37,  38,  39,  39,  40,  41,  45,  45,  49,  50,  52,  54,
+             41,  40,  40,  39,  38,  39,  40,  40,  41,  41,  46,  46,  50,  52,  54,  55,  57,
+             44,  42,  42,  41,  41,  41,  42,  42,  42,  43,  47,  47,  52,  54,  56,  58,  60,  63,
+             45,  43,  43,  42,  41,  42,  42,  43,  43,  43,  48,  48,  53,  54,  57,  58,  60,  64,  65,
+             48,  46,  46,  45,  44,  45,  45,  45,  46,  46,  51,  51,  55,  57,  59,  61,  63,  67,  68,  71,
+             48,  46,  46,  45,  44,  45,  45,  45,  46,  46,  51,  51,  55,  57,  59,  61,  63,  67,  68,  71,  71,
+             53,  51,  51,  49,  49,  49,  49,  49,  49,  49,  54,  54,  58,  59,  62,  64,  67,  71,  72,  75,  75,  81,
+             54,  52,  51,  50,  49,  49,  50,  49,  49,  50,  54,  54,  59,  60,  63,  65,  67,  71,  72,  76,  76,  81,  82,
+             57,  55,  55,  53,  52,  52,  52,  52,  52,  52,  57,  57,  61,  62,  65,  67,  70,  74,  75,  79,  79,  85,  85,  89,
+             59,  56,  56,  54,  54,  54,  54,  54,  53,  54,  58,  58,  62,  64,  67,  69,  71,  75,  76,  80,  80,  86,  87,  90,  92,
+             62,  59,  59,  57,  56,  56,  56,  56,  55,  56,  60,  60,  64,  66,  69,  71,  73,  77,  78,  83,  83,  89,  89,  93,  95,  98,
+             65,  62,  62,  60,  59,  59,  59,  59,  58,  58,  63,  63,  67,  68,  71,  73,  75,  79,  81,  85,  85,  91,  92,  96,  98, 101, 105,
+             67,  64,  64,  62,  61,  61,  60,  60,  59,  60,  64,  64,  68,  69,  72,  74,  77,  81,  82,  87,  87,  93,  94,  98,  99, 103, 106, 108,
+             71,  68,  68,  66,  65,  64,  64,  64,  63,  63,  68,  68,  72,  73,  76,  78,  80,  84,  85,  90,  90,  97,  97, 102, 103, 107, 111, 113, 117,
+             72,  69,  69,  66,  65,  65,  65,  64,  63,  64,  68,  68,  72,  73,  76,  78,  81,  85,  86,  91,  91,  97,  98, 102, 104, 108, 111, 113, 118, 119,
+             80,  76,  76,  73,  72,  72,  71,  70,  69,  70,  74,  74,  78,  79,  82,  84,  86,  90,  91,  96,  96, 103, 104, 108, 110, 114, 118, 120, 125, 126, 134,
+             80,  76,  76,  73,  72,  72,  71,  70,  69,  70,  74,  74,  78,  79,  82,  84,  86,  90,  91,  96,  96, 103, 104, 108, 110, 114, 118, 120, 125, 126, 134, 134,
+        }, {
+             32,
+             31,  31,
+             31,  31,  31,
+             30,  31,  31,  31,
+             30,  31,  31,  31,  32,
+             32,  32,  33,  33,  33,  35,
+             33,  34,  34,  35,  35,  37,  39,
+             34,  35,  35,  36,  36,  38,  40,  41,
+             36,  38,  38,  39,  40,  41,  43,  44,  47,
+             37,  38,  39,  40,  40,  42,  43,  44,  47,  47,
+             41,  42,  42,  42,  42,  43,  45,  45,  47,  47,  48,
+             41,  42,  42,  42,  42,  43,  45,  45,  47,  47,  48,  48,
+             47,  46,  46,  46,  45,  46,  47,  47,  47,  48,  50,  50,  52,
+             49,  48,  47,  47,  46,  47,  47,  47,  48,  48,  50,  50,  52,  53,
+             49,  47,  47,  46,  46,  46,  46,  47,  47,  47,  50,  50,  52,  53,  53,
+             48,  47,  47,  46,  45,  46,  46,  46,  46,  47,  49,  49,  52,  53,  54,  54,
+             49,  47,  47,  46,  45,  45,  46,  46,  46,  46,  49,  49,  52,  53,  54,  55,  55,
+             49,  47,  47,  45,  45,  45,  45,  45,  45,  45,  49,  49,  52,  53,  55,  55,  57,  58,
+             49,  47,  47,  46,  45,  45,  45,  45,  45,  46,  49,  49,  52,  53,  55,  56,  57,  59,  59,
+             50,  48,  48,  47,  46,  46,  46,  46,  46,  46,  50,  50,  53,  54,  55,  56,  58,  60,  60,  61,
+             50,  48,  48,  47,  46,  46,  46,  46,  46,  46,  50,  50,  53,  54,  55,  56,  58,  60,  60,  61,  61,
+             52,  50,  49,  48,  47,  47,  47,  47,  46,  47,  50,  50,  53,  54,  56,  57,  59,  61,  61,  63,  63,  66,
+             52,  50,  50,  48,  47,  47,  47,  47,  47,  47,  50,  50,  53,  54,  56,  57,  59,  61,  61,  63,  63,  66,  66,
+             54,  51,  51,  50,  49,  49,  49,  48,  48,  48,  51,  51,  54,  55,  57,  58,  60,  62,  62,  65,  65,  67,  68,  69,
+             54,  52,  52,  50,  49,  49,  49,  49,  48,  48,  52,  52,  55,  55,  57,  58,  60,  62,  63,  65,  65,  68,  68,  70,  71,
+             56,  53,  53,  51,  51,  50,  50,  50,  49,  49,  52,  52,  55,  56,  58,  59,  61,  63,  63,  66,  66,  69,  69,  71,  72,  73,
+             57,  54,  54,  52,  52,  51,  51,  51,  50,  50,  53,  53,  56,  56,  58,  60,  61,  63,  64,  67,  67,  70,  70,  72,  73,  75,  76,
+             58,  55,  55,  53,  52,  52,  52,  51,  50,  51,  54,  54,  56,  57,  59,  60,  62,  64,  65,  67,  67,  71,  71,  73,  74,  75,  77,  78,
+             60,  57,  57,  55,  54,  54,  53,  53,  52,  52,  55,  55,  58,  58,  60,  61,  63,  65,  66,  68,  68,  72,  72,  74,  75,  77,  79,  80,  82,
+             60,  57,  57,  55,  54,  54,  54,  53,  52,  52,  55,  55,  58,  58,  60,  62,  63,  65,  66,  69,  69,  72,  73,  75,  76,  77,  79,  80,  82,  82,
+             63,  60,  60,  58,  57,  57,  56,  55,  54,  55,  57,  57,  60,  60,  62,  63,  65,  67,  68,  71,  71,  74,  75,  77,  78,  80,  82,  83,  85,  85,  89,
+             63,  60,  60,  58,  57,  57,  56,  55,  54,  55,  57,  57,  60,  60,  62,  63,  65,  67,  68,  71,  71,  74,  75,  77,  78,  80,  82,  83,  85,  85,  89,  89,
+        },
+    }, {
+        {
+             32,
+             31,  31,
+             31,  31,  32,
+             31,  32,  32,  32,
+             31,  32,  32,  32,  32,
+             31,  32,  32,  32,  32,  32,
+             31,  32,  32,  32,  32,  32,  33,
+             31,  32,  32,  32,  32,  32,  33,  33,
+             32,  32,  32,  32,  32,  32,  33,  33,  34,
+             32,  32,  32,  32,  32,  32,  33,  34,  34,  35,
+             32,  32,  32,  32,  32,  32,  33,  34,  34,  35,  35,
+             33,  33,  33,  33,  33,  33,  34,  35,  35,  36,  36,  38,
+             34,  34,  34,  34,  33,  33,  35,  35,  36,  37,  37,  39,  39,
+             34,  34,  34,  34,  34,  34,  35,  36,  36,  37,  37,  40,  41,  42,
+             36,  35,  35,  35,  34,  34,  36,  36,  37,  38,  38,  42,  42,  45,  48,
+             36,  35,  35,  35,  34,  34,  36,  36,  37,  38,  38,  42,  42,  45,  48,  48,
+             38,  38,  38,  37,  37,  37,  38,  38,  39,  40,  40,  43,  44,  46,  50,  50,  52,
+             39,  38,  38,  38,  37,  37,  39,  39,  39,  40,  40,  44,  45,  47,  50,  50,  53,  54,
+             41,  40,  40,  39,  38,  38,  40,  40,  40,  41,  41,  45,  46,  48,  52,  52,  54,  55,  57,
+             44,  42,  42,  42,  41,  41,  42,  42,  42,  42,  42,  46,  47,  50,  54,  54,  57,  58,  60,  63,
+             44,  42,  42,  42,  41,  41,  42,  42,  42,  42,  42,  46,  47,  50,  54,  54,  57,  58,  60,  63,  63,
+             47,  46,  45,  45,  44,  44,  44,  45,  45,  45,  45,  49,  50,  52,  56,  56,  59,  60,  62,  66,  66,  69,
+             48,  47,  46,  45,  44,  44,  45,  45,  45,  46,  46,  50,  51,  53,  57,  57,  60,  61,  63,  67,  67,  70,  71,
+             50,  49,  48,  47,  46,  46,  47,  47,  47,  47,  47,  51,  52,  54,  58,  58,  61,  62,  65,  68,  68,  72,  73,  75,
+             54,  52,  51,  50,  49,  49,  49,  50,  49,  49,  49,  53,  54,  56,  60,  60,  64,  65,  67,  71,  71,  75,  76,  78,  82,
+             54,  52,  51,  50,  49,  49,  49,  50,  49,  49,  49,  53,  54,  56,  60,  60,  64,  65,  67,  71,  71,  75,  76,  78,  82,  82,
+             58,  56,  55,  54,  53,  53,  53,  53,  53,  52,  52,  56,  57,  59,  63,  63,  67,  68,  70,  74,  74,  78,  79,  82,  86,  86,  90,
+             59,  57,  56,  55,  54,  54,  54,  54,  54,  53,  53,  57,  58,  60,  64,  64,  68,  69,  71,  75,  75,  79,  80,  83,  87,  87,  91,  92,
+             61,  59,  58,  57,  56,  56,  56,  56,  55,  55,  55,  59,  60,  62,  65,  65,  69,  70,  73,  77,  77,  81,  82,  85,  89,  89,  93,  94,  97,
+             65,  63,  62,  61,  59,  59,  59,  59,  59,  58,  58,  62,  63,  65,  68,  68,  72,  73,  75,  79,  79,  84,  85,  88,  92,  92,  97,  98, 101, 105,
+             65,  63,  62,  61,  59,  59,  59,  59,  59,  58,  58,  62,  63,  65,  68,  68,  72,  73,  75,  79,  79,  84,  85,  88,  92,  92,  97,  98, 101, 105, 105,
+             70,  67,  67,  65,  64,  64,  63,  63,  63,  62,  62,  66,  67,  69,  72,  72,  76,  77,  79,  83,  83,  88,  89,  92,  96,  96, 101, 102, 105, 109, 109, 114,
+        }, {
+             32,
+             31,  31,
+             31,  31,  31,
+             31,  31,  31,  31,
+             30,  31,  31,  31,  32,
+             30,  31,  31,  31,  32,  32,
+             33,  33,  34,  34,  34,  34,  37,
+             33,  34,  34,  35,  35,  35,  38,  39,
+             34,  36,  36,  36,  37,  37,  40,  40,  42,
+             36,  38,  38,  39,  40,  40,  42,  43,  45,  47,
+             36,  38,  38,  39,  40,  40,  42,  43,  45,  47,  47,
+             40,  41,  41,  41,  42,  42,  44,  44,  45,  47,  47,  48,
+             41,  42,  42,  42,  42,  42,  44,  45,  46,  47,  47,  48,  48,
+             44,  44,  44,  44,  44,  44,  45,  46,  46,  47,  47,  49,  49,  50,
+             49,  48,  47,  47,  46,  46,  47,  47,  47,  48,  48,  50,  50,  51,  53,
+             49,  48,  47,  47,  46,  46,  47,  47,  47,  48,  48,  50,  50,  51,  53,  53,
+             48,  47,  47,  46,  45,  45,  46,  46,  46,  47,  47,  49,  50,  51,  53,  53,  54,
+             48,  47,  47,  46,  45,  45,  46,  46,  46,  46,  46,  49,  49,  51,  53,  53,  54,  54,
+             49,  47,  47,  46,  45,  45,  46,  46,  46,  46,  46,  49,  49,  51,  53,  53,  54,  55,  55,
+             49,  47,  47,  46,  45,  45,  45,  45,  45,  45,  45,  48,  49,  51,  53,  53,  55,  55,  57,  58,
+             49,  47,  47,  46,  45,  45,  45,  45,  45,  45,  45,  48,  49,  51,  53,  53,  55,  55,  57,  58,  58,
+             50,  48,  48,  47,  46,  46,  46,  46,  46,  46,  46,  49,  50,  51,  54,  54,  56,  56,  57,  59,  59,  61,
+             50,  49,  48,  47,  46,  46,  46,  46,  46,  46,  46,  49,  50,  51,  54,  54,  56,  56,  58,  60,  60,  61,  61,
+             51,  49,  49,  48,  47,  47,  47,  47,  47,  46,  46,  49,  50,  51,  54,  54,  56,  57,  58,  60,  60,  62,  62,  63,
+             52,  50,  50,  49,  47,  47,  47,  47,  47,  47,  47,  49,  50,  52,  54,  54,  57,  57,  59,  61,  61,  63,  63,  65,  66,
+             52,  50,  50,  49,  47,  47,  47,  47,  47,  47,  47,  49,  50,  52,  54,  54,  57,  57,  59,  61,  61,  63,  63,  65,  66,  66,
+             54,  52,  51,  50,  49,  49,  49,  49,  48,  48,  48,  51,  51,  53,  55,  55,  58,  58,  60,  62,  62,  64,  65,  66,  68,  68,  70,
+             54,  52,  52,  51,  49,  49,  49,  49,  49,  48,  48,  51,  52,  53,  55,  55,  58,  58,  60,  62,  62,  64,  65,  66,  68,  68,  70,  71,
+             55,  53,  53,  52,  50,  50,  50,  50,  49,  49,  49,  51,  52,  54,  56,  56,  58,  59,  60,  63,  63,  65,  66,  67,  69,  69,  71,  72,  73,
+             57,  55,  54,  53,  52,  52,  51,  51,  50,  50,  50,  52,  53,  54,  56,  56,  59,  60,  61,  63,  63,  66,  67,  68,  70,  70,  73,  73,  74,  76,
+             57,  55,  54,  53,  52,  52,  51,  51,  50,  50,  50,  52,  53,  54,  56,  56,  59,  60,  61,  63,  63,  66,  67,  68,  70,  70,  73,  73,  74,  76,  76,
+             59,  57,  56,  55,  54,  54,  53,  53,  52,  51,  51,  54,  55,  56,  58,  58,  60,  61,  63,  65,  65,  67,  68,  70,  72,  72,  74,  75,  76,  78,  78,  80,
+        },
+    }, {
+        {
+             32,
+             31,  31,
+             31,  31,  32,
+             31,  31,  32,  32,
+             31,  32,  32,  32,  32,
+             31,  32,  32,  32,  32,  32,
+             31,  32,  32,  32,  32,  32,  32,
+             31,  32,  32,  32,  32,  32,  32,  33,
+             31,  32,  32,  32,  32,  32,  32,  33,  33,
+             32,  32,  32,  32,  32,  32,  33,  33,  33,  34,
+             32,  32,  32,  32,  32,  32,  33,  34,  34,  34,  35,
+             32,  32,  32,  32,  32,  32,  33,  34,  34,  34,  35,  35,
+             32,  33,  33,  33,  33,  33,  33,  34,  34,  35,  36,  36,  36,
+             34,  34,  34,  34,  33,  33,  34,  35,  35,  35,  37,  37,  38,  39,
+             34,  34,  34,  34,  33,  33,  34,  35,  35,  35,  37,  37,  38,  39,  39,
+             35,  34,  34,  34,  34,  34,  34,  35,  36,  36,  37,  37,  39,  41,  41,  43,
+             36,  35,  35,  35,  34,  34,  35,  36,  36,  37,  38,  38,  40,  42,  42,  45,  48,
+             36,  35,  35,  35,  34,  34,  35,  36,  36,  37,  38,  38,  40,  42,  42,  45,  48,  48,
+             38,  37,  37,  37,  36,  36,  36,  38,  38,  38,  39,  39,  41,  44,  44,  47,  50,  50,  51,
+             39,  39,  38,  38,  37,  37,  38,  39,  39,  39,  40,  40,  42,  45,  45,  47,  50,  50,  52,  54,
+             39,  39,  38,  38,  37,  37,  38,  39,  39,  39,  40,  40,  42,  45,  45,  47,  50,  50,  52,  54,  54,
+             42,  41,  41,  41,  40,  40,  40,  41,  41,  41,  42,  42,  44,  47,  47,  49,  53,  53,  55,  56,  56,  60,
+             44,  43,  42,  42,  41,  41,  41,  42,  42,  42,  42,  42,  44,  47,  47,  50,  54,  54,  56,  58,  58,  61,  63,
+             44,  43,  43,  42,  41,  41,  41,  42,  42,  42,  43,  43,  45,  48,  48,  51,  54,  54,  56,  58,  58,  62,  64,  64,
+             47,  46,  45,  45,  44,  44,  44,  44,  45,  45,  45,  45,  47,  50,  50,  53,  56,  56,  58,  60,  60,  64,  66,  66,  69,
+             48,  47,  46,  46,  45,  44,  45,  45,  45,  45,  46,  46,  47,  51,  51,  53,  57,  57,  59,  61,  61,  65,  67,  67,  70,  71,
+             49,  48,  47,  47,  46,  45,  45,  46,  46,  46,  46,  46,  48,  51,  51,  54,  57,  57,  60,  62,  62,  66,  68,  68,  71,  72,  73,
+             53,  51,  51,  51,  49,  49,  49,  49,  49,  49,  49,  49,  51,  54,  54,  57,  59,  59,  62,  64,  64,  69,  71,  71,  74,  75,  77,  81,
+             54,  52,  51,  51,  50,  49,  49,  50,  50,  49,  49,  49,  51,  54,  54,  57,  60,  60,  63,  65,  65,  69,  71,  72,  75,  76,  77,  81,  82,
+             55,  53,  53,  52,  51,  50,  50,  51,  51,  51,  50,  50,  52,  55,  55,  58,  61,  61,  64,  66,  66,  70,  72,  73,  76,  77,  78,  83,  83,  85,
+             59,  57,  56,  56,  54,  54,  54,  54,  54,  54,  53,  53,  55,  58,  58,  61,  64,  64,  67,  69,  69,  73,  75,  76,  79,  80,  81,  86,  87,  88,  92,
+             59,  57,  56,  56,  54,  54,  54,  54,  54,  54,  53,  53,  55,  58,  58,  61,  64,  64,  67,  69,  69,  73,  75,  76,  79,  80,  81,  86,  87,  88,  92,  92,
+        }, {
+             32,
+             31,  31,
+             31,  31,  31,
+             31,  31,  31,  31,
+             30,  31,  31,  31,  31,
+             30,  31,  31,  31,  31,  32,
+             31,  31,  32,  32,  32,  32,  33,
+             33,  34,  34,  34,  35,  35,  35,  38,
+             33,  34,  34,  34,  35,  35,  36,  38,  39,
+             34,  35,  35,  36,  36,  36,  37,  40,  40,  41,
+             36,  38,  38,  38,  39,  40,  40,  43,  43,  44,  47,
+             36,  38,  38,  38,  39,  40,  40,  43,  43,  44,  47,  47,
+             38,  39,  40,  40,  41,  41,  41,  43,  44,  45,  47,  47,  47,
+             41,  42,  42,  42,  42,  42,  43,  44,  45,  45,  47,  47,  48,  48,
+             41,  42,  42,  42,  42,  42,  43,  44,  45,  45,  47,  47,  48,  48,  48,
+             45,  45,  45,  45,  44,  44,  44,  46,  46,  46,  47,  47,  48,  49,  49,  50,
+             49,  48,  47,  47,  46,  46,  46,  47,  47,  47,  48,  48,  49,  50,  50,  51,  53,
+             49,  48,  47,  47,  46,  46,  46,  47,  47,  47,  48,  48,  49,  50,  50,  51,  53,  53,
+             49,  47,  47,  47,  46,  46,  46,  46,  46,  47,  47,  47,  48,  50,  50,  51,  53,  53,  53,
+             48,  47,  47,  47,  46,  45,  45,  46,  46,  46,  46,  46,  48,  49,  49,  51,  53,  53,  54,  54,
+             48,  47,  47,  47,  46,  45,  45,  46,  46,  46,  46,  46,  48,  49,  49,  51,  53,  53,  54,  54,  54,
+             49,  47,  47,  47,  45,  45,  45,  45,  45,  45,  45,  45,  47,  49,  49,  51,  53,  53,  54,  55,  55,  57,
+             49,  47,  47,  46,  45,  45,  45,  45,  45,  45,  45,  45,  47,  49,  49,  51,  53,  53,  55,  55,  55,  57,  58,
+             49,  47,  47,  47,  45,  45,  45,  45,  45,  45,  45,  45,  47,  49,  49,  51,  53,  53,  55,  56,  56,  58,  58,  59,
+             50,  49,  48,  48,  46,  46,  46,  46,  46,  46,  46,  46,  47,  50,  50,  52,  54,  54,  55,  56,  56,  58,  59,  59,  61,
+             50,  49,  48,  48,  47,  46,  46,  46,  46,  46,  46,  46,  47,  50,  50,  52,  54,  54,  55,  56,  56,  59,  60,  60,  61,  61,
+             51,  49,  48,  48,  47,  46,  46,  47,  47,  46,  46,  46,  47,  50,  50,  52,  54,  54,  55,  56,  56,  59,  60,  60,  61,  62,  62,
+             52,  50,  49,  49,  48,  47,  47,  47,  47,  47,  46,  46,  48,  50,  50,  52,  54,  54,  56,  57,  57,  60,  61,  61,  63,  63,  64,  66,
+             52,  50,  50,  49,  48,  47,  47,  47,  47,  47,  47,  47,  48,  50,  50,  52,  54,  54,  56,  57,  57,  60,  61,  61,  63,  63,  64,  66,  66,
+             53,  51,  50,  50,  48,  48,  48,  48,  48,  48,  47,  47,  48,  51,  51,  52,  54,  54,  56,  58,  58,  60,  61,  62,  63,  64,  64,  67,  67,  68,
+             54,  53,  52,  52,  50,  49,  49,  49,  49,  49,  48,  48,  49,  52,  52,  53,  55,  55,  57,  58,  58,  61,  62,  63,  64,  65,  66,  68,  68,  69,  71,
+             54,  53,  52,  52,  50,  49,  49,  49,  49,  49,  48,  48,  49,  52,  52,  53,  55,  55,  57,  58,  58,  61,  62,  63,  64,  65,  66,  68,  68,  69,  71,  71,
+        },
+    }, {
+        {
+             32,
+             31,  31,
+             31,  31,  32,
+             31,  31,  32,  32,
+             31,  31,  32,  32,  32,
+             31,  31,  32,  32,  32,  32,
+             31,  31,  32,  32,  32,  32,  32,
+             31,  32,  32,  32,  32,  32,  32,  32,
+             31,  32,  32,  32,  32,  32,  32,  32,  33,
+             31,  32,  32,  32,  32,  32,  32,  32,  33,  33,
+             31,  32,  32,  32,  32,  32,  32,  32,  33,  33,  33,
+             32,  32,  32,  32,  32,  32,  32,  33,  33,  33,  33,  34,
+             32,  32,  32,  32,  32,  32,  32,  33,  33,  34,  34,  35,  35,
+             32,  32,  32,  32,  32,  32,  32,  33,  33,  34,  34,  35,  35,  35,
+             32,  33,  33,  33,  33,  33,  33,  33,  34,  34,  34,  35,  36,  36,  36,
+             34,  34,  34,  34,  34,  33,  33,  34,  35,  35,  35,  36,  37,  37,  38,  39,
+             34,  34,  34,  34,  34,  33,  33,  34,  35,  35,  35,  36,  37,  37,  38,  39,  39,
+             34,  34,  34,  34,  34,  34,  34,  34,  35,  35,  35,  36,  37,  37,  38,  40,  40,  41,
+             35,  35,  35,  35,  34,  34,  34,  34,  36,  36,  36,  37,  38,  38,  39,  42,  42,  43,  46,
+             36,  35,  35,  35,  35,  34,  34,  35,  36,  36,  36,  37,  38,  38,  40,  42,  42,  44,  47,  48,
+             36,  35,  35,  35,  35,  34,  34,  35,  36,  36,  36,  37,  38,  38,  40,  42,  42,  44,  47,  48,  48,
+             38,  37,  37,  37,  36,  36,  36,  36,  37,  38,  38,  39,  39,  39,  41,  44,  44,  45,  48,  50,  50,  51,
+             39,  39,  38,  38,  38,  37,  37,  38,  39,  39,  39,  40,  40,  40,  42,  45,  45,  46,  49,  50,  50,  52,  54,
+             39,  39,  38,  38,  38,  37,  37,  38,  39,  39,  39,  40,  40,  40,  42,  45,  45,  46,  49,  50,  50,  52,  54,  54,
+             41,  40,  40,  40,  39,  38,  38,  39,  40,  40,  40,  41,  41,  41,  43,  46,  46,  47,  50,  52,  52,  54,  55,  55,  57,
+             44,  43,  42,  42,  42,  41,  41,  41,  42,  42,  42,  42,  42,  42,  44,  47,  47,  49,  52,  54,  54,  56,  58,  58,  60,  63,
+             44,  43,  42,  42,  42,  41,  41,  41,  42,  42,  42,  42,  42,  42,  44,  47,  47,  49,  52,  54,  54,  56,  58,  58,  60,  63,  63,
+             45,  44,  43,  43,  42,  41,  41,  42,  42,  42,  42,  43,  43,  43,  45,  48,  48,  49,  53,  54,  54,  57,  58,  58,  60,  64,  64,  65,
+             47,  46,  45,  45,  45,  44,  44,  44,  44,  45,  45,  45,  45,  45,  47,  50,  50,  51,  55,  56,  56,  58,  60,  60,  62,  66,  66,  67,  69,
+             48,  47,  46,  46,  45,  44,  44,  45,  45,  45,  45,  45,  46,  46,  47,  51,  51,  52,  55,  57,  57,  59,  61,  61,  63,  67,  67,  68,  70,  71,
+             48,  47,  46,  46,  45,  44,  44,  45,  45,  45,  45,  45,  46,  46,  47,  51,  51,  52,  55,  57,  57,  59,  61,  61,  63,  67,  67,  68,  70,  71,  71,
+             51,  50,  49,  49,  48,  47,  47,  47,  48,  48,  48,  48,  48,  48,  50,  53,  53,  54,  57,  58,  58,  61,  63,  63,  66,  69,  69,  70,  73,  74,  74,  77,
+        }, {
+             32,
+             31,  31,
+             31,  31,  31,
+             31,  31,  31,  31,
+             31,  31,  31,  31,  31,
+             30,  31,  31,  31,  31,  32,
+             30,  31,  31,  31,  31,  32,  32,
+             31,  31,  32,  32,  32,  32,  32,  33,
+             33,  33,  34,  34,  34,  34,  34,  35,  37,
+             33,  34,  34,  34,  35,  35,  35,  36,  38,  39,
+             33,  34,  34,  34,  35,  35,  35,  36,  38,  39,  39,
+             35,  36,  37,  37,  37,  38,  38,  38,  41,  41,  41,  44,
+             36,  37,  38,  38,  39,  40,  40,  40,  42,  43,  43,  46,  47,
+             36,  37,  38,  38,  39,  40,  40,  40,  42,  43,  43,  46,  47,  47,
+             38,  39,  40,  40,  40,  41,  41,  41,  43,  44,  44,  46,  47,  47,  47,
+             41,  42,  42,  42,  42,  42,  42,  43,  44,  45,  45,  46,  47,  47,  48,  48,
+             41,  42,  42,  42,  42,  42,  42,  43,  44,  45,  45,  46,  47,  47,  48,  48,  48,
+             43,  43,  43,  43,  43,  43,  43,  43,  45,  45,  45,  46,  47,  47,  48,  49,  49,  49,
+             47,  47,  46,  46,  46,  45,  45,  46,  46,  47,  47,  47,  47,  47,  48,  50,  50,  50,  52,
+             49,  48,  47,  47,  47,  46,  46,  46,  47,  47,  47,  47,  48,  48,  49,  50,  50,  51,  52,  53,
+             49,  48,  47,  47,  47,  46,  46,  46,  47,  47,  47,  47,  48,  48,  49,  50,  50,  51,  52,  53,  53,
+             49,  48,  47,  47,  46,  46,  46,  46,  46,  46,  46,  47,  47,  47,  48,  50,  50,  50,  52,  53,  53,  53,
+             48,  47,  47,  47,  46,  45,  45,  45,  46,  46,  46,  46,  46,  46,  48,  49,  49,  50,  52,  53,  53,  54,  54,
+             48,  47,  47,  47,  46,  45,  45,  45,  46,  46,  46,  46,  46,  46,  48,  49,  49,  50,  52,  53,  53,  54,  54,  54,
+             49,  47,  47,  47,  46,  45,  45,  45,  46,  46,  46,  46,  46,  46,  47,  49,  49,  50,  52,  53,  53,  54,  55,  55,  55,
+             49,  47,  47,  47,  46,  45,  45,  45,  45,  45,  45,  45,  45,  45,  47,  49,  49,  50,  52,  53,  53,  55,  55,  55,  57,  58,
+             49,  47,  47,  47,  46,  45,  45,  45,  45,  45,  45,  45,  45,  45,  47,  49,  49,  50,  52,  53,  53,  55,  55,  55,  57,  58,  58,
+             49,  48,  47,  47,  46,  45,  45,  45,  45,  45,  45,  45,  45,  45,  47,  49,  49,  50,  52,  53,  53,  55,  56,  56,  57,  59,  59,  59,
+             50,  49,  48,  48,  47,  46,  46,  46,  46,  46,  46,  46,  46,  46,  47,  50,  50,  50,  53,  54,  54,  55,  56,  56,  57,  59,  59,  60,  61,
+             50,  49,  48,  48,  47,  46,  46,  46,  46,  46,  46,  46,  46,  46,  47,  50,  50,  50,  53,  54,  54,  55,  56,  56,  58,  60,  60,  60,  61,  61,
+             50,  49,  48,  48,  47,  46,  46,  46,  46,  46,  46,  46,  46,  46,  47,  50,  50,  50,  53,  54,  54,  55,  56,  56,  58,  60,  60,  60,  61,  61,  61,
+             51,  50,  49,  49,  48,  47,  47,  47,  47,  47,  47,  47,  46,  46,  48,  50,  50,  51,  53,  54,  54,  56,  57,  57,  58,  60,  60,  61,  62,  63,  63,  64,
+        },
+    }, {
+        {
+             32,
+             31,  31,
+             31,  31,  32,
+             31,  31,  32,  32,
+             31,  31,  32,  32,  32,
+             31,  31,  32,  32,  32,  32,
+             31,  31,  32,  32,  32,  32,  32,
+             31,  31,  32,  32,  32,  32,  32,  32,
+             31,  31,  32,  32,  32,  32,  32,  32,  32,
+             31,  32,  32,  32,  32,  32,  32,  32,  32,  32,
+             31,  32,  32,  32,  32,  32,  32,  32,  32,  33,  33,
+             31,  32,  32,  32,  32,  32,  32,  32,  32,  33,  33,  33,
+             31,  32,  32,  32,  32,  32,  32,  32,  32,  33,  33,  33,  33,
+             32,  32,  32,  32,  32,  32,  32,  32,  32,  33,  33,  33,  33,  34,
+             32,  32,  32,  32,  32,  32,  32,  32,  32,  33,  34,  34,  34,  34,  35,
+             32,  32,  32,  32,  32,  32,  32,  32,  32,  33,  34,  34,  34,  34,  35,  35,
+             32,  32,  32,  32,  32,  32,  32,  32,  32,  33,  34,  34,  34,  34,  35,  35,  35,
+             33,  33,  33,  33,  33,  33,  33,  33,  33,  34,  34,  34,  34,  35,  36,  36,  36,  37,
+             34,  34,  34,  34,  34,  34,  33,  33,  33,  34,  35,  35,  35,  36,  37,  37,  37,  38,  39,
+             34,  34,  34,  34,  34,  34,  33,  33,  33,  34,  35,  35,  35,  36,  37,  37,  37,  38,  39,  39,
+             34,  34,  34,  34,  34,  34,  33,  33,  33,  34,  35,  35,  35,  36,  37,  37,  37,  38,  39,  39,  39,
+             35,  34,  34,  34,  34,  34,  34,  34,  34,  35,  36,  36,  36,  36,  37,  37,  37,  39,  41,  41,  41,  43,
+             36,  35,  35,  35,  35,  35,  34,  34,  34,  35,  36,  36,  36,  37,  38,  38,  38,  40,  42,  42,  42,  45,  48,
+             36,  35,  35,  35,  35,  35,  34,  34,  34,  35,  36,  36,  36,  37,  38,  38,  38,  40,  42,  42,  42,  45,  48,  48,
+             36,  35,  35,  35,  35,  35,  34,  34,  34,  35,  36,  36,  36,  37,  38,  38,  38,  40,  42,  42,  42,  45,  48,  48,  48,
+             37,  37,  37,  37,  37,  36,  36,  36,  36,  37,  38,  38,  38,  38,  39,  39,  39,  41,  44,  44,  44,  46,  49,  49,  49,  51,
+             39,  39,  38,  38,  38,  38,  37,  37,  37,  38,  39,  39,  39,  40,  40,  40,  40,  42,  45,  45,  45,  47,  50,  50,  50,  52,  54,
+             39,  39,  38,  38,  38,  38,  37,  37,  37,  38,  39,  39,  39,  40,  40,  40,  40,  42,  45,  45,  45,  47,  50,  50,  50,  52,  54,  54,
+             39,  39,  38,  38,  38,  38,  37,  37,  37,  38,  39,  39,  39,  40,  40,  40,  40,  42,  45,  45,  45,  47,  50,  50,  50,  52,  54,  54,  54,
+             41,  41,  40,  40,  40,  39,  39,  39,  39,  40,  40,  40,  40,  41,  41,  41,  41,  44,  46,  46,  46,  49,  52,  52,  52,  54,  56,  56,  56,  58,
+             44,  43,  42,  42,  42,  41,  41,  41,  41,  41,  42,  42,  42,  42,  42,  42,  42,  45,  47,  47,  47,  50,  54,  54,  54,  56,  58,  58,  58,  60,  63,
+             44,  43,  42,  42,  42,  41,  41,  41,  41,  41,  42,  42,  42,  42,  42,  42,  42,  45,  47,  47,  47,  50,  54,  54,  54,  56,  58,  58,  58,  60,  63,  63,
+        }, {
+             32,
+             31,  31,
+             31,  31,  31,
+             31,  31,  31,  31,
+             31,  31,  31,  31,  31,
+             31,  31,  31,  31,  31,  31,
+             30,  31,  31,  31,  31,  31,  32,
+             30,  31,  31,  31,  31,  31,  32,  32,
+             30,  31,  31,  31,  31,  31,  32,  32,  32,
+             32,  32,  33,  33,  33,  33,  33,  33,  33,  35,
+             33,  34,  34,  34,  34,  35,  35,  35,  35,  37,  39,
+             33,  34,  34,  34,  34,  35,  35,  35,  35,  37,  39,  39,
+             33,  34,  34,  34,  34,  35,  35,  35,  35,  37,  39,  39,  39,
+             35,  35,  36,  36,  36,  37,  37,  37,  37,  39,  41,  41,  41,  43,
+             36,  37,  38,  38,  38,  39,  40,  40,  40,  41,  43,  43,  43,  45,  47,
+             36,  37,  38,  38,  38,  39,  40,  40,  40,  41,  43,  43,  43,  45,  47,  47,
+             36,  37,  38,  38,  38,  39,  40,  40,  40,  41,  43,  43,  43,  45,  47,  47,  47,
+             39,  39,  40,  40,  40,  41,  41,  41,  41,  42,  44,  44,  44,  45,  47,  47,  47,  47,
+             41,  42,  42,  42,  42,  42,  42,  42,  42,  43,  45,  45,  45,  46,  47,  47,  47,  48,  48,
+             41,  42,  42,  42,  42,  42,  42,  42,  42,  43,  45,  45,  45,  46,  47,  47,  47,  48,  48,  48,
+             41,  42,  42,  42,  42,  42,  42,  42,  42,  43,  45,  45,  45,  46,  47,  47,  47,  48,  48,  48,  48,
+             45,  45,  45,  45,  45,  44,  44,  44,  44,  45,  46,  46,  46,  47,  47,  47,  47,  48,  49,  49,  49,  50,
+             49,  48,  47,  47,  47,  47,  46,  46,  46,  47,  47,  47,  47,  47,  48,  48,  48,  49,  50,  50,  50,  51,  53,
+             49,  48,  47,  47,  47,  47,  46,  46,  46,  47,  47,  47,  47,  47,  48,  48,  48,  49,  50,  50,  50,  51,  53,  53,
+             49,  48,  47,  47,  47,  47,  46,  46,  46,  47,  47,  47,  47,  47,  48,  48,  48,  49,  50,  50,  50,  51,  53,  53,  53,
+             49,  48,  47,  47,  47,  46,  46,  46,  46,  46,  47,  47,  47,  47,  47,  47,  47,  48,  50,  50,  50,  51,  53,  53,  53,  53,
+             48,  48,  47,  47,  47,  46,  45,  45,  45,  46,  46,  46,  46,  46,  46,  46,  46,  48,  49,  49,  49,  51,  53,  53,  53,  53,  54,
+             48,  48,  47,  47,  47,  46,  45,  45,  45,  46,  46,  46,  46,  46,  46,  46,  46,  48,  49,  49,  49,  51,  53,  53,  53,  53,  54,  54,
+             48,  48,  47,  47,  47,  46,  45,  45,  45,  46,  46,  46,  46,  46,  46,  46,  46,  48,  49,  49,  49,  51,  53,  53,  53,  53,  54,  54,  54,
+             49,  48,  47,  47,  47,  46,  45,  45,  45,  45,  46,  46,  46,  46,  46,  46,  46,  47,  49,  49,  49,  51,  53,  53,  53,  54,  55,  55,  55,  56,
+             49,  48,  47,  47,  47,  46,  45,  45,  45,  45,  45,  45,  45,  45,  45,  45,  45,  47,  49,  49,  49,  51,  53,  53,  53,  54,  55,  55,  55,  57,  58,
+             49,  48,  47,  47,  47,  46,  45,  45,  45,  45,  45,  45,  45,  45,  45,  45,  45,  47,  49,  49,  49,  51,  53,  53,  53,  54,  55,  55,  55,  57,  58,  58,
+        },
+    }, {
+        {
+             32,
+             31,  31,
+             31,  31,  31,
+             31,  31,  31,  32,
+             31,  31,  31,  32,  32,
+             31,  31,  31,  32,  32,  32,
+             31,  31,  32,  32,  32,  32,  32,
+             31,  31,  32,  32,  32,  32,  32,  32,
+             31,  31,  32,  32,  32,  32,  32,  32,  32,
+             31,  31,  32,  32,  32,  32,  32,  32,  32,  32,
+             31,  31,  32,  32,  32,  32,  32,  32,  32,  32,  32,
+             31,  31,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,
+             31,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  33,  33,
+             31,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  33,  33,  33,
+             31,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  33,  33,  33,  33,
+             31,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  33,  33,  33,  33,  33,
+             32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  33,  33,  33,  33,  33,  34,
+             32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  33,  33,  34,  34,  34,  34,  35,
+             32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  33,  33,  34,  34,  34,  34,  35,  35,
+             32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  33,  33,  34,  34,  34,  34,  35,  35,  35,
+             32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  33,  33,  34,  34,  34,  34,  35,  35,  35,  35,
+             32,  32,  33,  33,  33,  33,  33,  33,  33,  33,  33,  33,  34,  34,  34,  34,  35,  35,  36,  36,  36,  36,
+             33,  33,  33,  33,  33,  33,  33,  33,  33,  33,  33,  34,  34,  35,  35,  35,  35,  36,  36,  36,  36,  37,  38,
+             34,  34,  34,  34,  34,  34,  34,  33,  33,  33,  33,  34,  35,  35,  35,  35,  36,  36,  37,  37,  37,  38,  39,  39,
+             34,  34,  34,  34,  34,  34,  34,  33,  33,  33,  33,  34,  35,  35,  35,  35,  36,  36,  37,  37,  37,  38,  39,  39,  39,
+             34,  34,  34,  34,  34,  34,  34,  33,  33,  33,  33,  34,  35,  35,  35,  35,  36,  36,  37,  37,  37,  38,  39,  39,  39,  39,
+             34,  34,  34,  34,  34,  34,  34,  34,  34,  34,  34,  34,  35,  36,  36,  36,  36,  37,  37,  37,  37,  38,  40,  41,  41,  41,  42,
+             35,  35,  35,  35,  35,  35,  34,  34,  34,  34,  34,  35,  36,  36,  36,  36,  37,  37,  38,  38,  38,  39,  41,  42,  42,  42,  44,  46,
+             36,  35,  35,  35,  35,  35,  35,  34,  34,  34,  34,  35,  36,  36,  36,  36,  37,  38,  38,  38,  38,  40,  42,  42,  42,  42,  45,  47,  48,
+             36,  35,  35,  35,  35,  35,  35,  34,  34,  34,  34,  35,  36,  36,  36,  36,  37,  38,  38,  38,  38,  40,  42,  42,  42,  42,  45,  47,  48,  48,
+             36,  35,  35,  35,  35,  35,  35,  34,  34,  34,  34,  35,  36,  36,  36,  36,  37,  38,  38,  38,  38,  40,  42,  42,  42,  42,  45,  47,  48,  48,  48,
+             37,  37,  36,  36,  36,  36,  36,  35,  35,  35,  35,  36,  37,  37,  37,  37,  38,  39,  39,  39,  39,  41,  42,  43,  43,  43,  45,  48,  49,  49,  49,  50,
+        }, {
+             32,
+             31,  31,
+             31,  31,  31,
+             31,  31,  31,  31,
+             31,  31,  31,  31,  31,
+             31,  31,  31,  31,  31,  31,
+             31,  31,  31,  31,  31,  31,  31,
+             30,  31,  31,  31,  31,  31,  31,  31,
+             30,  30,  31,  31,  31,  31,  31,  31,  32,
+             30,  30,  31,  31,  31,  31,  31,  31,  32,  32,
+             30,  30,  31,  31,  31,  31,  31,  31,  32,  32,  32,
+             31,  32,  32,  32,  32,  32,  33,  33,  33,  33,  33,  34,
+             33,  33,  33,  34,  34,  34,  34,  34,  34,  34,  34,  36,  37,
+             33,  34,  34,  34,  34,  34,  35,  35,  35,  35,  35,  37,  38,  39,
+             33,  34,  34,  34,  34,  34,  35,  35,  35,  35,  35,  37,  38,  39,  39,
+             33,  34,  34,  34,  34,  34,  35,  35,  35,  35,  35,  37,  38,  39,  39,  39,
+             34,  35,  36,  36,  36,  36,  36,  37,  37,  37,  37,  38,  40,  40,  40,  40,  42,
+             36,  36,  37,  37,  37,  37,  38,  38,  39,  39,  39,  40,  41,  42,  42,  42,  44,  46,
+             36,  37,  38,  38,  38,  38,  39,  39,  40,  40,  40,  41,  42,  43,  43,  43,  45,  46,  47,
+             36,  37,  38,  38,  38,  38,  39,  39,  40,  40,  40,  41,  42,  43,  43,  43,  45,  46,  47,  47,
+             36,  37,  38,  38,  38,  38,  39,  39,  40,  40,  40,  41,  42,  43,  43,  43,  45,  46,  47,  47,  47,
+             38,  39,  39,  40,  40,  40,  40,  41,  41,  41,  41,  42,  43,  44,  44,  44,  45,  47,  47,  47,  47,  47,
+             40,  41,  41,  41,  41,  41,  41,  42,  42,  42,  42,  43,  44,  44,  44,  44,  45,  47,  47,  47,  47,  48,  48,
+             41,  42,  42,  42,  42,  42,  42,  42,  42,  42,  42,  43,  44,  45,  45,  45,  46,  47,  47,  47,  47,  48,  48,  48,
+             41,  42,  42,  42,  42,  42,  42,  42,  42,  42,  42,  43,  44,  45,  45,  45,  46,  47,  47,  47,  47,  48,  48,  48,  48,
+             41,  42,  42,  42,  42,  42,  42,  42,  42,  42,  42,  43,  44,  45,  45,  45,  46,  47,  47,  47,  47,  48,  48,  48,  48,  48,
+             44,  44,  44,  44,  44,  44,  44,  44,  44,  44,  44,  44,  45,  46,  46,  46,  46,  47,  47,  47,  47,  48,  49,  49,  49,  49,  50,
+             47,  47,  46,  46,  46,  46,  46,  46,  45,  45,  45,  46,  46,  47,  47,  47,  47,  47,  47,  47,  47,  48,  49,  50,  50,  50,  51,  52,
+             49,  48,  48,  47,  47,  47,  47,  46,  46,  46,  46,  46,  47,  47,  47,  47,  47,  47,  48,  48,  48,  49,  50,  50,  50,  50,  51,  52,  53,
+             49,  48,  48,  47,  47,  47,  47,  46,  46,  46,  46,  46,  47,  47,  47,  47,  47,  47,  48,  48,  48,  49,  50,  50,  50,  50,  51,  52,  53,  53,
+             49,  48,  48,  47,  47,  47,  47,  46,  46,  46,  46,  46,  47,  47,  47,  47,  47,  47,  48,  48,  48,  49,  50,  50,  50,  50,  51,  52,  53,  53,  53,
+             49,  48,  47,  47,  47,  47,  47,  46,  46,  46,  46,  46,  46,  47,  47,  47,  47,  47,  47,  47,  47,  48,  49,  50,  50,  50,  51,  52,  53,  53,  53,  53,
+        },
+    }, {
+        {
+             32,
+             31,  31,
+             31,  31,  31,
+             31,  31,  31,  31,
+             31,  31,  31,  32,  32,
+             31,  31,  31,  32,  32,  32,
+             31,  31,  31,  32,  32,  32,  32,
+             31,  31,  31,  32,  32,  32,  32,  32,
+             31,  31,  31,  32,  32,  32,  32,  32,  32,
+             31,  31,  31,  32,  32,  32,  32,  32,  32,  32,
+             31,  31,  31,  32,  32,  32,  32,  32,  32,  32,  32,
+             31,  31,  31,  32,  32,  32,  32,  32,  32,  32,  32,  32,
+             31,  31,  31,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,
+             31,  31,  31,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,
+             31,  31,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,
+             31,  31,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,
+             31,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  33,  33,
+             31,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  33,  33,  33,
+             31,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  33,  33,  33,  33,
+             31,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  33,  33,  33,  33,  33,
+             31,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  33,  33,  33,  33,  33,  33,
+             32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  33,  33,  33,  33,  33,  33,  33,  34,
+             32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  33,  33,  33,  33,  33,  33,  33,  34,  34,
+             32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  33,  33,  33,  34,  34,  34,  34,  34,  34,  35,
+             32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  33,  33,  33,  34,  34,  34,  34,  34,  35,  35,  35,
+             32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  33,  33,  33,  34,  34,  34,  34,  34,  35,  35,  35,  35,
+             32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  33,  33,  33,  34,  34,  34,  34,  34,  35,  35,  35,  35,  35,
+             32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  33,  33,  33,  33,  33,  33,  34,  34,  34,  34,  34,  34,  35,  35,  35,  35,  35,  35,
+             32,  32,  33,  33,  33,  33,  33,  33,  33,  33,  33,  33,  33,  33,  33,  34,  34,  34,  34,  34,  34,  35,  35,  35,  36,  36,  36,  36,  36,
+             33,  33,  33,  33,  33,  33,  33,  33,  33,  33,  33,  33,  33,  33,  33,  34,  34,  35,  35,  35,  35,  35,  35,  36,  36,  36,  36,  36,  37,  38,
+             34,  34,  34,  34,  34,  34,  34,  34,  34,  33,  33,  33,  33,  33,  34,  34,  35,  35,  35,  35,  35,  35,  36,  36,  37,  37,  37,  37,  38,  38,  39,
+             34,  34,  34,  34,  34,  34,  34,  34,  34,  33,  33,  33,  33,  33,  34,  34,  35,  35,  35,  35,  35,  35,  36,  36,  37,  37,  37,  37,  38,  38,  39,  39,
+        }, {
+             32,
+             31,  31,
+             31,  31,  31,
+             31,  31,  31,  31,
+             31,  31,  31,  31,  31,
+             31,  31,  31,  31,  31,  31,
+             31,  31,  31,  31,  31,  31,  31,
+             31,  31,  31,  31,  31,  31,  31,  31,
+             31,  31,  31,  31,  31,  31,  31,  31,  31,
+             30,  31,  31,  31,  31,  31,  31,  31,  31,  31,
+             30,  30,  31,  31,  31,  31,  31,  31,  31,  31,  32,
+             30,  30,  31,  31,  31,  31,  31,  31,  31,  31,  32,  32,
+             30,  30,  31,  31,  31,  31,  31,  31,  31,  31,  32,  32,  32,
+             30,  30,  31,  31,  31,  31,  31,  31,  31,  31,  32,  32,  32,  32,
+             31,  31,  31,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  33,
+             32,  32,  32,  32,  33,  33,  33,  33,  33,  33,  33,  33,  33,  33,  34,  35,
+             33,  33,  33,  34,  34,  34,  34,  34,  34,  34,  34,  34,  34,  34,  35,  36,  37,
+             33,  34,  34,  34,  34,  34,  34,  34,  35,  35,  35,  35,  35,  35,  36,  37,  38,  39,
+             33,  34,  34,  34,  34,  34,  34,  34,  35,  35,  35,  35,  35,  35,  36,  37,  38,  39,  39,
+             33,  34,  34,  34,  34,  34,  34,  34,  35,  35,  35,  35,  35,  35,  36,  37,  38,  39,  39,  39,
+             33,  34,  34,  34,  34,  34,  34,  34,  35,  35,  35,  35,  35,  35,  36,  37,  38,  39,  39,  39,  39,
+             34,  35,  35,  35,  35,  35,  35,  36,  36,  36,  36,  36,  36,  36,  37,  38,  39,  40,  40,  40,  40,  41,
+             35,  36,  36,  36,  37,  37,  37,  37,  37,  37,  38,  38,  38,  38,  38,  39,  41,  41,  41,  41,  41,  42,  44,
+             36,  37,  37,  38,  38,  38,  38,  38,  38,  39,  39,  39,  39,  39,  40,  41,  42,  43,  43,  43,  43,  44,  45,  46,
+             36,  37,  37,  38,  38,  38,  38,  38,  39,  39,  40,  40,  40,  40,  40,  41,  42,  43,  43,  43,  43,  44,  46,  47,  47,
+             36,  37,  37,  38,  38,  38,  38,  38,  39,  39,  40,  40,  40,  40,  40,  41,  42,  43,  43,  43,  43,  44,  46,  47,  47,  47,
+             36,  37,  37,  38,  38,  38,  38,  38,  39,  39,  40,  40,  40,  40,  40,  41,  42,  43,  43,  43,  43,  44,  46,  47,  47,  47,  47,
+             37,  37,  38,  38,  39,  39,  39,  39,  39,  40,  40,  40,  40,  40,  41,  42,  43,  43,  43,  43,  43,  44,  46,  47,  47,  47,  47,  47,
+             38,  39,  39,  40,  40,  40,  40,  40,  40,  40,  41,  41,  41,  41,  41,  42,  43,  44,  44,  44,  44,  45,  46,  47,  47,  47,  47,  47,  47,
+             40,  40,  40,  41,  41,  41,  41,  41,  41,  41,  42,  42,  42,  42,  42,  43,  44,  44,  44,  44,  44,  45,  46,  47,  47,  47,  47,  47,  48,  48,
+             41,  42,  42,  42,  42,  42,  42,  42,  42,  42,  42,  42,  42,  42,  43,  43,  44,  45,  45,  45,  45,  45,  46,  47,  47,  47,  47,  47,  48,  48,  48,
+             41,  42,  42,  42,  42,  42,  42,  42,  42,  42,  42,  42,  42,  42,  43,  43,  44,  45,  45,  45,  45,  45,  46,  47,  47,  47,  47,  47,  48,  48,  48,  48,
+        },
+    }, {
+        {
+             32,
+             31,  31,
+             31,  31,  31,
+             31,  31,  31,  31,
+             31,  31,  31,  31,  31,
+             31,  31,  31,  31,  31,  32,
+             31,  31,  31,  31,  31,  32,  32,
+             31,  31,  31,  31,  31,  32,  32,  32,
+             31,  31,  31,  31,  31,  32,  32,  32,  32,
+             31,  31,  31,  31,  31,  32,  32,  32,  32,  32,
+             31,  31,  31,  31,  31,  32,  32,  32,  32,  32,  32,
+             31,  31,  31,  31,  32,  32,  32,  32,  32,  32,  32,  32,
+             31,  31,  31,  31,  32,  32,  32,  32,  32,  32,  32,  32,  32,
+             31,  31,  31,  31,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,
+             31,  31,  31,  31,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,
+             31,  31,  31,  31,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,
+             31,  31,  31,  31,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,
+             31,  31,  31,  31,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,
+             31,  31,  31,  31,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,
+             31,  31,  31,  31,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,
+             31,  31,  31,  31,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,
+             31,  31,  31,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,
+             31,  31,  31,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,
+             31,  31,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  33,
+             31,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  33,  33,  33,
+             31,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  33,  33,  33,  33,
+             31,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  33,  33,  33,  33,  33,
+             31,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  33,  33,  33,  33,  33,  33,
+             31,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  33,  33,  33,  33,  33,  33,  33,
+             31,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  33,  33,  33,  33,  33,  33,  33,  33,
+             31,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  33,  33,  33,  33,  33,  33,  33,  33,  33,
+             32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  33,  33,  33,  33,  33,  33,  33,  33,  33,  33,  33,
+        }, {
+             32,
+             31,  31,
+             31,  31,  31,
+             31,  31,  31,  31,
+             31,  31,  31,  31,  31,
+             31,  31,  31,  31,  31,  31,
+             31,  31,  31,  31,  31,  31,  31,
+             31,  31,  31,  31,  31,  31,  31,  31,
+             31,  31,  31,  31,  31,  31,  31,  31,  31,
+             31,  31,  31,  31,  31,  31,  31,  31,  31,  31,
+             31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,
+             31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,
+             31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,
+             30,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,
+             30,  30,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,
+             30,  30,  30,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  32,
+             30,  30,  30,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  32,  32,
+             30,  30,  30,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  32,  32,  32,
+             30,  30,  30,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  32,  32,  32,  32,
+             30,  30,  30,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  32,  32,  32,  32,  32,
+             30,  30,  30,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  32,  32,  32,  32,  32,  32,
+             31,  31,  31,  31,  31,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  33,
+             31,  31,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  33,  33,  33,  33,  33,  33,  33,  33,  33,  34,  34,
+             32,  32,  32,  33,  33,  33,  33,  33,  33,  33,  33,  33,  33,  33,  34,  34,  34,  34,  34,  34,  34,  34,  35,  36,
+             33,  33,  33,  33,  33,  34,  34,  34,  34,  34,  34,  34,  34,  34,  34,  34,  34,  34,  34,  34,  34,  35,  36,  37,  37,
+             33,  33,  34,  34,  34,  34,  34,  34,  34,  34,  34,  35,  35,  35,  35,  35,  35,  35,  35,  35,  35,  36,  37,  37,  38,  39,
+             33,  33,  34,  34,  34,  34,  34,  34,  34,  34,  34,  35,  35,  35,  35,  35,  35,  35,  35,  35,  35,  36,  37,  37,  38,  39,  39,
+             33,  33,  34,  34,  34,  34,  34,  34,  34,  34,  34,  35,  35,  35,  35,  35,  35,  35,  35,  35,  35,  36,  37,  37,  38,  39,  39,  39,
+             33,  33,  34,  34,  34,  34,  34,  34,  34,  34,  34,  35,  35,  35,  35,  35,  35,  35,  35,  35,  35,  36,  37,  37,  38,  39,  39,  39,  39,
+             33,  33,  34,  34,  34,  34,  34,  34,  34,  34,  34,  35,  35,  35,  35,  35,  35,  35,  35,  35,  35,  36,  37,  37,  38,  39,  39,  39,  39,  39,
+             33,  33,  34,  34,  34,  34,  34,  34,  34,  34,  34,  35,  35,  35,  35,  35,  35,  35,  35,  35,  35,  36,  37,  37,  38,  39,  39,  39,  39,  39,  39,
+             34,  34,  34,  35,  35,  35,  35,  35,  35,  35,  35,  35,  35,  36,  36,  36,  36,  36,  36,  36,  36,  37,  37,  38,  39,  40,  40,  40,  40,  40,  40,  40,
+        },
+    }, {
+        {
+             32,
+             31,  31,
+             31,  31,  31,
+             31,  31,  31,  31,
+             31,  31,  31,  31,  31,
+             31,  31,  31,  31,  31,  31,
+             31,  31,  31,  31,  31,  31,  31,
+             31,  31,  31,  31,  31,  31,  31,  31,
+             31,  31,  31,  31,  31,  31,  31,  31,  31,
+             31,  31,  31,  31,  31,  31,  31,  31,  31,  31,
+             31,  31,  31,  31,  31,  31,  31,  31,  31,  32,  32,
+             31,  31,  31,  31,  31,  31,  31,  31,  31,  32,  32,  32,
+             31,  31,  31,  31,  31,  31,  31,  31,  31,  32,  32,  32,  32,
+             31,  31,  31,  31,  31,  31,  31,  31,  31,  32,  32,  32,  32,  32,
+             31,  31,  31,  31,  31,  31,  31,  31,  31,  32,  32,  32,  32,  32,  32,
+             31,  31,  31,  31,  31,  31,  31,  31,  31,  32,  32,  32,  32,  32,  32,  32,
+             31,  31,  31,  31,  31,  31,  31,  31,  31,  32,  32,  32,  32,  32,  32,  32,  32,
+             31,  31,  31,  31,  31,  31,  31,  31,  31,  32,  32,  32,  32,  32,  32,  32,  32,  32,
+             31,  31,  31,  31,  31,  31,  31,  31,  31,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,
+             31,  31,  31,  31,  31,  31,  31,  31,  31,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,
+             31,  31,  31,  31,  31,  31,  31,  31,  31,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,
+             31,  31,  31,  31,  31,  31,  31,  31,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,
+             31,  31,  31,  31,  31,  31,  31,  31,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,
+             31,  31,  31,  31,  31,  31,  31,  31,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,
+             31,  31,  31,  31,  31,  31,  31,  31,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,
+             31,  31,  31,  31,  31,  31,  31,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,
+             31,  31,  31,  31,  31,  31,  31,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,
+             31,  31,  31,  31,  31,  31,  31,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,
+             31,  31,  31,  31,  31,  31,  31,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,
+             31,  31,  31,  31,  31,  31,  31,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,
+             31,  31,  31,  31,  31,  31,  31,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,
+             31,  31,  31,  31,  31,  31,  31,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,  32,
+        }, {
+             32,
+             31,  31,
+             31,  31,  31,
+             31,  31,  31,  31,
+             31,  31,  31,  31,  31,
+             31,  31,  31,  31,  31,  31,
+             31,  31,  31,  31,  31,  31,  31,
+             31,  31,  31,  31,  31,  31,  31,  31,
+             31,  31,  31,  31,  31,  31,  31,  31,  31,
+             31,  31,  31,  31,  31,  31,  31,  31,  31,  31,
+             31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,
+             31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,
+             31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,
+             31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,
+             31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,
+             31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,
+             31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,
+             31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,
+             31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,
+             31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,
+             31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,
+             31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,
+             31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,
+             31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,
+             31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,
+             31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,
+             30,  30,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,
+             30,  30,  30,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,
+             30,  30,  30,  30,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,
+             30,  30,  30,  30,  30,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,
+             30,  30,  30,  30,  30,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  32,
+             30,  30,  30,  30,  30,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  31,  32,  32,
+        },
+    },
+};
+
+const uint8_t *av1_qm_tbl[16][2][N_RECT_TX_SIZES];
+static uint8_t pb_32x32[32 * 32];
+static uint8_t qm_tbl_4x4[15][2][16];
+static uint8_t qm_tbl_4x8[15][2][32];
+static uint8_t qm_tbl_4x16[15][2][64];
+static uint8_t qm_tbl_8x8[15][2][64];
+static uint8_t qm_tbl_8x16[15][2][128];
+static uint8_t qm_tbl_8x32[15][2][256];
+static uint8_t qm_tbl_16x16[15][2][256];
+static uint8_t qm_tbl_16x32[15][2][512];
+static uint8_t qm_tbl_32x32[15][2][1024];
+
+static void subsample(uint8_t *const dst, const uint8_t *const src,
+                      const int sz, const int step)
+{
+    for (int y = 0; y < sz; y++)
+        for (int x = 0; x < sz; x++)
+            dst[y * sz + x] = src[y * sz * step * step + x * step];
+}
+
+static void transpose(uint8_t *const dst, const uint8_t *const src,
+                      const int w, const int h)
+{
+    for (int y = 0, y_off = 0; y < h; y++, y_off += w)
+        for (int x = 0, x_off = 0; x < w; x++, x_off += h)
+            dst[x_off + y] = src[y_off + x];
+}
+
+static void untriangle(uint8_t *dst, const uint8_t *src, const int sz) {
+    for (int y = 0; y < sz; y++) {
+        memcpy(dst, src, y + 1);
+        const uint8_t *src_ptr = &src[y];
+        for (int x = y + 1; x < sz; x++) {
+            src_ptr += x;
+            dst[x] = *src_ptr;
+        }
+        dst += sz;
+        src += y + 1;
+    }
+}
+
+void av1_init_qm_tables(void) {
+    static int done = 0;
+    if (done) return;
+    done = 1;
+
+    for (int i = 0; i < 15; i++)
+        for (int j = 0; j < 2; j++) {
+            // note that the w/h in the assignment is inverted, this is on purpose
+            // because we store coefficients transposed
+            av1_qm_tbl[i][j][RTX_4X8  ] = qm_tbl_8x4[i][j];
+            av1_qm_tbl[i][j][RTX_8X4  ] = qm_tbl_4x8[i][j];
+            transpose(qm_tbl_4x8[i][j], qm_tbl_8x4[i][j], 8, 4);
+            av1_qm_tbl[i][j][RTX_4X16 ] = qm_tbl_16x4[i][j];
+            av1_qm_tbl[i][j][RTX_16X4 ] = qm_tbl_4x16[i][j];
+            transpose(qm_tbl_4x16[i][j], qm_tbl_16x4[i][j], 16, 4);
+            av1_qm_tbl[i][j][RTX_8X16 ] = qm_tbl_16x8[i][j];
+            av1_qm_tbl[i][j][RTX_16X8 ] = qm_tbl_8x16[i][j];
+            transpose(qm_tbl_8x16[i][j], qm_tbl_16x8[i][j], 16, 8);
+            av1_qm_tbl[i][j][RTX_8X32 ] = qm_tbl_32x8[i][j];
+            av1_qm_tbl[i][j][RTX_32X8 ] = qm_tbl_8x32[i][j];
+            transpose(qm_tbl_8x32[i][j], qm_tbl_32x8[i][j], 32, 8);
+            av1_qm_tbl[i][j][RTX_16X32] = qm_tbl_32x16[i][j];
+            av1_qm_tbl[i][j][RTX_32X16] = qm_tbl_16x32[i][j];
+            transpose(qm_tbl_16x32[i][j], qm_tbl_32x16[i][j], 32, 16);
+
+            av1_qm_tbl[i][j][ TX_4X4  ] = qm_tbl_4x4[i][j];
+            av1_qm_tbl[i][j][ TX_8X8  ] = qm_tbl_8x8[i][j];
+            av1_qm_tbl[i][j][ TX_16X16] = qm_tbl_16x16[i][j];
+            av1_qm_tbl[i][j][ TX_32X32] = qm_tbl_32x32[i][j];
+            untriangle(qm_tbl_4x4[i][j], qm_tbl_4x4_t[i][j], 4);
+            untriangle(qm_tbl_8x8[i][j], qm_tbl_8x8_t[i][j], 8);
+            untriangle(qm_tbl_32x32[i][j], qm_tbl_32x32_t[i][j], 32);
+            subsample(qm_tbl_16x16[i][j], qm_tbl_32x32[i][j], 16, 2);
+
+            av1_qm_tbl[i][j][ TX_64X64] = av1_qm_tbl[i][j][ TX_32X32];
+            av1_qm_tbl[i][j][RTX_64X32] = av1_qm_tbl[i][j][ TX_32X32];
+            av1_qm_tbl[i][j][RTX_64X16] = av1_qm_tbl[i][j][RTX_32X16];
+            av1_qm_tbl[i][j][RTX_32X64] = av1_qm_tbl[i][j][ TX_32X32];
+            av1_qm_tbl[i][j][RTX_16X64] = av1_qm_tbl[i][j][RTX_16X32];
+        }
+
+    memset(pb_32x32, 32, sizeof(pb_32x32));
+    for (int j = 0; j < 2; j++)
+        for (int k = 0; k < N_RECT_TX_SIZES; k++)
+            av1_qm_tbl[15][j][k] = pb_32x32;
+}
diff --git a/src/qm.h b/src/qm.h
new file mode 100644
index 0000000..94565a7
--- /dev/null
+++ b/src/qm.h
@@ -0,0 +1,37 @@
+/*
+ * Copyright © 2018, VideoLAN and dav1d authors
+ * Copyright © 2018, Two Orioles, LLC
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright notice, this
+ *    list of conditions and the following disclaimer.
+ *
+ * 2. Redistributions in binary form must reproduce the above copyright notice,
+ *    this list of conditions and the following disclaimer in the documentation
+ *    and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
+ * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#ifndef __DAV1D_SRC_QM_H__
+#define __DAV1D_SRC_QM_H__
+
+#include "src/levels.h"
+
+extern const uint8_t *av1_qm_tbl[16][2][N_RECT_TX_SIZES];
+
+void av1_init_qm_tables(void);
+
+#endif /* __DAV1D_SRC_QM_H__ */
diff --git a/src/recon.c b/src/recon.c
new file mode 100644
index 0000000..4d61565
--- /dev/null
+++ b/src/recon.c
@@ -0,0 +1,1503 @@
+/*
+ * Copyright © 2018, VideoLAN and dav1d authors
+ * Copyright © 2018, Two Orioles, LLC
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright notice, this
+ *    list of conditions and the following disclaimer.
+ *
+ * 2. Redistributions in binary form must reproduce the above copyright notice,
+ *    this list of conditions and the following disclaimer in the documentation
+ *    and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
+ * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#include "config.h"
+
+#include <string.h>
+#include <stdio.h>
+
+#include "common/attributes.h"
+#include "common/bitdepth.h"
+#include "common/dump.h"
+#include "common/intops.h"
+#include "common/mem.h"
+
+#include "src/cdef_apply.h"
+#include "src/ipred_prepare.h"
+#include "src/lf_apply.h"
+#include "src/lr_apply.h"
+#include "src/recon.h"
+#include "src/scan.h"
+#include "src/tables.h"
+#include "src/wedge.h"
+
+static unsigned read_golomb(MsacContext *const msac) {
+    int len = 0;
+    unsigned val = 1;
+
+    while (!msac_decode_bool(msac, 128 << 7) && len < 32) len++;
+    while (len--) val = (val << 1) | msac_decode_bool(msac, 128 << 7);
+
+    return val - 1;
+}
+
+static int decode_coefs(Dav1dTileContext *const t,
+                        uint8_t *const a, uint8_t *const l,
+                        const enum RectTxfmSize tx, const enum BlockSize bs,
+                        const Av1Block *const b, const int intra,
+                        const int plane, coef *cf,
+                        enum TxfmType *const txtp, uint8_t *res_ctx)
+{
+    Dav1dTileState *const ts = t->ts;
+    const int chroma = !!plane;
+    const Dav1dFrameContext *const f = t->f;
+    const TxfmInfo *const t_dim = &av1_txfm_dimensions[tx];
+    const int dbg = DEBUG_BLOCK_INFO && plane && 0;
+
+    if (dbg) printf("Start: r=%d\n", ts->msac.rng);
+
+    // does this block have any non-zero coefficients
+    const int sctx = get_coef_skip_ctx(t_dim, bs, a, l, chroma, f->cur.p.p.layout);
+    const int all_skip =
+        msac_decode_bool_adapt(&ts->msac, ts->cdf.coef.skip[t_dim->ctx][sctx]);
+    if (dbg)
+    printf("Post-non-zero[%d][%d][%d]: r=%d\n",
+           t_dim->ctx, sctx, all_skip, ts->msac.rng);
+    if (all_skip) {
+        *res_ctx = 0x40;
+        *txtp = f->frame_hdr.segmentation.lossless[b->seg_id] ? WHT_WHT :
+                                                                DCT_DCT;
+        return -1;
+    }
+
+    // transform type (chroma: derived, luma: explicitly coded)
+    if (chroma) {
+        if (intra) {
+            *txtp = get_uv_intra_txtp(b->uv_mode, tx, &f->frame_hdr, b->seg_id);
+        } else {
+            const enum TxfmType y_txtp = *txtp;
+            *txtp = get_uv_inter_txtp(t_dim, y_txtp, &f->frame_hdr, b->seg_id);
+        }
+    } else {
+        const enum TxfmTypeSet set = get_ext_txtp_set(tx, !intra,
+                                                      &f->frame_hdr, b->seg_id);
+        const unsigned set_cnt = av1_tx_type_count[set];
+        unsigned idx;
+        if (set_cnt == 1) {
+            idx = 0;
+        } else {
+            const int set_idx = av1_tx_type_set_index[!intra][set];
+            const enum IntraPredMode y_mode_nofilt = b->y_mode == FILTER_PRED ?
+                av1_filter_mode_to_y_mode[b->y_angle] : b->y_mode;
+            uint16_t *const txtp_cdf = intra ?
+                       ts->cdf.m.txtp_intra[set_idx][t_dim->min][y_mode_nofilt] :
+                       ts->cdf.m.txtp_inter[set_idx][t_dim->min];
+            idx = msac_decode_symbol_adapt(&ts->msac, txtp_cdf, set_cnt);
+            if (dbg)
+            printf("Post-txtp[%d->%d][%d->%d][%d][%d->%d]: r=%d\n",
+                   set, set_idx, tx, t_dim->min, b->intra ? y_mode_nofilt : -1,
+                   idx, av1_tx_types_per_set[set][idx], ts->msac.rng);
+        }
+        *txtp = av1_tx_types_per_set[set][idx];
+    }
+
+    // find end-of-block (eob)
+    int eob_bin;
+    const int tx2dszctx = imin(t_dim->lw, TX_32X32) + imin(t_dim->lh, TX_32X32);
+    const enum TxClass tx_class = av1_tx_type_class[*txtp];
+    const int is_1d = tx_class != TX_CLASS_2D;
+    switch (tx2dszctx) {
+#define case_sz(sz, bin) \
+    case sz: { \
+        uint16_t *const eob_bin_cdf = ts->cdf.coef.eob_bin_##bin[chroma][is_1d]; \
+        eob_bin = msac_decode_symbol_adapt(&ts->msac, eob_bin_cdf, 5 + sz); \
+        break; \
+    }
+    case_sz(0,   16);
+    case_sz(1,   32);
+    case_sz(2,   64);
+    case_sz(3,  128);
+    case_sz(4,  256);
+    case_sz(5,  512);
+    case_sz(6, 1024);
+#undef case_sz
+    }
+    if (dbg)
+    printf("Post-eob_bin_%d[%d][%d][%d]: r=%d\n",
+           16 << tx2dszctx, chroma, is_1d, eob_bin, ts->msac.rng);
+    int eob;
+    if (eob_bin > 1) {
+        eob = 1 << (eob_bin - 1);
+        uint16_t *const eob_hi_bit_cdf =
+            ts->cdf.coef.eob_hi_bit[t_dim->ctx][chroma][eob_bin];
+        const int eob_hi_bit = msac_decode_bool_adapt(&ts->msac, eob_hi_bit_cdf);
+        if (dbg)
+        printf("Post-eob_hi_bit[%d][%d][%d][%d]: r=%d\n",
+               t_dim->ctx, chroma, eob_bin, eob_hi_bit, ts->msac.rng);
+        unsigned mask = eob >> 1;
+        if (eob_hi_bit) eob |= mask;
+        for (mask >>= 1; mask; mask >>= 1) {
+            const int eob_bit = msac_decode_bool(&ts->msac, 128 << 7);
+            if (eob_bit) eob |= mask;
+        }
+        if (dbg)
+        printf("Post-eob[%d]: r=%d\n", eob, ts->msac.rng);
+    } else {
+        eob = eob_bin;
+    }
+
+    // base tokens
+    uint16_t (*const br_cdf)[5] =
+        ts->cdf.coef.br_tok[imin(t_dim->ctx, 3)][chroma];
+    const int16_t *const scan = av1_scans[tx][tx_class];
+    uint8_t levels[36 * 36];
+    ptrdiff_t stride = 4 * (imin(t_dim->h, 8) + 1);
+    memset(levels, 0, stride * 4 * (imin(t_dim->w, 8) + 1));
+    const int shift = 2 + imin(t_dim->lh, 3), mask = 4 * imin(t_dim->h, 8) - 1;
+    unsigned cul_level = 0;
+    for (int i = eob, is_last = 1; i >= 0; i--, is_last = 0) {
+        const int rc = scan[i], x = rc >> shift, y = rc & mask;
+
+        // lo tok
+        const int ctx = get_coef_nz_ctx(levels, i, rc, is_last, tx, tx_class);
+        uint16_t *const lo_cdf = is_last ?
+            ts->cdf.coef.eob_base_tok[t_dim->ctx][chroma][ctx] :
+            ts->cdf.coef.base_tok[t_dim->ctx][chroma][ctx];
+        int tok = msac_decode_symbol_adapt(&ts->msac, lo_cdf,
+                                           4 - is_last) + is_last;
+        if (dbg)
+        printf("Post-lo_tok[%d][%d][%d][%d=%d=%d]: r=%d\n",
+               t_dim->ctx, chroma, ctx, i, rc, tok, ts->msac.rng);
+        if (!tok) continue;
+
+        // hi tok
+        if (tok == 3) {
+            const int br_ctx = get_br_ctx(levels, rc, tx, tx_class);
+            do {
+                const int tok_br =
+                    msac_decode_symbol_adapt(&ts->msac, br_cdf[br_ctx], 4);
+                if (dbg)
+                printf("Post-hi_tok[%d][%d][%d][%d=%d=%d->%d]: r=%d\n",
+                       imin(t_dim->ctx, 3), chroma, br_ctx,
+                       i, rc, tok_br, tok, ts->msac.rng);
+                tok += tok_br;
+                if (tok_br < 3) break;
+            } while (tok < 15);
+        }
+
+        levels[x * stride + y] = cf[rc] = tok;
+    }
+
+    // residual and sign
+    int dc_sign = 1;
+    const uint16_t *const dq_tbl = ts->dq[b->seg_id][plane];
+    const uint8_t *const qm_tbl = f->qm[is_1d || *txtp == IDTX][tx][plane];
+    const int dq_shift = imax(0, t_dim->ctx - 2);
+    for (int i = 0; i <= eob; i++) {
+        const int rc = scan[i];
+        int tok = cf[rc];
+        if (!tok) continue;
+        int dq;
+
+        // sign
+        int sign;
+        if (i == 0) {
+            const int dc_sign_ctx = get_dc_sign_ctx(t_dim, a, l);
+            uint16_t *const dc_sign_cdf =
+                ts->cdf.coef.dc_sign[chroma][dc_sign_ctx];
+            sign = msac_decode_bool_adapt(&ts->msac, dc_sign_cdf);
+            if (dbg)
+            printf("Post-dc_sign[%d][%d][%d]: r=%d\n",
+                   chroma, dc_sign_ctx, sign, ts->msac.rng);
+            dc_sign = sign ? 0 : 2;
+            dq = (dq_tbl[0] * qm_tbl[0] + 16) >> 5;
+        } else {
+            sign = msac_decode_bool(&ts->msac, 128 << 7);
+            if (dbg)
+            printf("Post-sign[%d=%d=%d]: r=%d\n", i, rc, sign, ts->msac.rng);
+            dq = (dq_tbl[1] * qm_tbl[rc] + 16) >> 5;
+        }
+
+        // residual
+        if (tok == 15) {
+            tok += read_golomb(&ts->msac);
+            if (dbg)
+            printf("Post-residual[%d=%d=%d->%d]: r=%d\n",
+                   i, rc, tok - 15, tok, ts->msac.rng);
+        }
+
+        // dequant
+        cul_level += tok;
+        tok *= dq;
+        tok >>= dq_shift;
+        cf[rc] = sign ? -tok : tok;
+    }
+
+    // context
+    *res_ctx = imin(cul_level, 63) | (dc_sign << 6);
+
+    return eob;
+}
+
+static void read_coef_tree(Dav1dTileContext *const t,
+                           const enum BlockSize bs, const Av1Block *const b,
+                           const enum RectTxfmSize ytx, const int depth,
+                           const uint16_t *const tx_split,
+                           const int x_off, const int y_off, pixel *dst)
+{
+    const Dav1dFrameContext *const f = t->f;
+    Dav1dTileState *const ts = t->ts;
+    const Dav1dDSPContext *const dsp = f->dsp;
+    const TxfmInfo *const t_dim = &av1_txfm_dimensions[ytx];
+    const int txw = t_dim->w, txh = t_dim->h;
+
+    if (depth < 2 && tx_split[depth] & (1 << (y_off * 4 + x_off))) {
+        const enum RectTxfmSize sub = t_dim->sub;
+        const TxfmInfo *const sub_t_dim = &av1_txfm_dimensions[sub];
+        const int txsw = sub_t_dim->w, txsh = sub_t_dim->h;
+
+        read_coef_tree(t, bs, b, sub, depth + 1, tx_split,
+                       x_off * 2 + 0, y_off * 2 + 0, dst);
+        t->bx += txsw;
+        if (txw >= txh && t->bx < f->bw)
+            read_coef_tree(t, bs, b, sub, depth + 1, tx_split, x_off * 2 + 1,
+                           y_off * 2 + 0, dst ? &dst[4 * txsw] : NULL);
+        t->bx -= txsw;
+        t->by += txsh;
+        if (txh >= txw && t->by < f->bh) {
+            if (dst)
+                dst += 4 * txsh * PXSTRIDE(f->cur.p.stride[0]);
+            read_coef_tree(t, bs, b, sub, depth + 1, tx_split,
+                           x_off * 2 + 0, y_off * 2 + 1, dst);
+            t->bx += txsw;
+            if (txw >= txh && t->bx < f->bw)
+                read_coef_tree(t, bs, b, sub, depth + 1, tx_split, x_off * 2 + 1,
+                               y_off * 2 + 1, dst ? &dst[4 * txsw] : NULL);
+            t->bx -= txsw;
+        }
+        t->by -= txsh;
+    } else {
+        const int bx4 = t->bx & 31, by4 = t->by & 31;
+        enum TxfmType txtp;
+        uint8_t cf_ctx;
+        int eob;
+        coef *cf;
+        struct CodedBlockInfo *cbi;
+
+        if (f->frame_thread.pass) {
+            cf = ts->frame_thread.cf;
+            ts->frame_thread.cf += imin(t_dim->w, 8) * imin(t_dim->h, 8) * 16;
+            cbi = &f->frame_thread.cbi[t->by * f->b4_stride + t->bx];
+        } else {
+            cf = t->cf;
+        }
+        if (f->frame_thread.pass != 2) {
+            eob = decode_coefs(t, &t->a->lcoef[bx4], &t->l.lcoef[by4],
+                               ytx, bs, b, 0, 0, cf, &txtp, &cf_ctx);
+            if (DEBUG_BLOCK_INFO)
+                printf("Post-y-cf-blk[tx=%d,txtp=%d,eob=%d]: r=%d\n",
+                       ytx, txtp, eob, ts->msac.rng);
+            memset(&t->a->lcoef[bx4], cf_ctx, imin(txw, f->bw - t->bx));
+            memset(&t->l.lcoef[by4], cf_ctx, imin(txh, f->bh - t->by));
+            for (int y = 0; y < txh; y++)
+                memset(&t->txtp_map[(by4 + y) * 32 + bx4], txtp, txw);
+            if (f->frame_thread.pass == 1) {
+                cbi->eob[0] = eob;
+                cbi->txtp[0] = txtp;
+            }
+        } else {
+            eob = cbi->eob[0];
+            txtp = cbi->txtp[0];
+        }
+        if (!(f->frame_thread.pass & 1)) {
+            assert(dst);
+            if (eob >= 0) {
+                if (DEBUG_BLOCK_INFO && DEBUG_B_PIXELS)
+                    coef_dump(cf, imin(t_dim->h, 8) * 4, imin(t_dim->w, 8) * 4, 3, "dq");
+                dsp->itx.itxfm_add[ytx][txtp](dst, f->cur.p.stride[0], cf, eob);
+                if (DEBUG_BLOCK_INFO && DEBUG_B_PIXELS)
+                    hex_dump(dst, f->cur.p.stride[0], t_dim->w * 4, t_dim->h * 4, "recon");
+            }
+        }
+    }
+}
+
+void bytefn(read_coef_blocks)(Dav1dTileContext *const t,
+                              const enum BlockSize bs, const Av1Block *const b)
+{
+    const Dav1dFrameContext *const f = t->f;
+    const int ss_ver = f->cur.p.p.layout == DAV1D_PIXEL_LAYOUT_I420;
+    const int ss_hor = f->cur.p.p.layout != DAV1D_PIXEL_LAYOUT_I444;
+    const int bx4 = t->bx & 31, by4 = t->by & 31;
+    const int cbx4 = bx4 >> ss_hor, cby4 = by4 >> ss_ver;
+    const uint8_t *const b_dim = av1_block_dimensions[bs];
+    const int bw4 = b_dim[0], bh4 = b_dim[1];
+    const int cbw4 = (bw4 + 1) >> ss_hor, cbh4 = (bh4 + 1) >> ss_ver;
+    const int has_chroma = f->seq_hdr.layout != DAV1D_PIXEL_LAYOUT_I400 &&
+                           (bw4 > ss_hor || t->bx & 1) &&
+                           (bh4 > ss_ver || t->by & 1);
+
+    if (b->skip) {
+        memset(&t->a->lcoef[bx4], 0x40, bw4);
+        memset(&t->l.lcoef[by4], 0x40, bh4);
+        if (has_chroma) for (int pl = 0; pl < 2; pl++) {
+            memset(&t->a->ccoef[pl][cbx4], 0x40, cbw4);
+            memset(&t->l.ccoef[pl][cby4], 0x40, cbh4);
+        }
+        return;
+    }
+
+    Dav1dTileState *const ts = t->ts;
+    const int w4 = imin(bw4, f->bw - t->bx), h4 = imin(bh4, f->bh - t->by);
+    const int cw4 = (w4 + ss_hor) >> ss_hor, ch4 = (h4 + ss_ver) >> ss_ver;
+    assert(f->frame_thread.pass == 1);
+    assert(!b->skip);
+    const TxfmInfo *const uv_t_dim = &av1_txfm_dimensions[b->uvtx];
+    const TxfmInfo *const t_dim = &av1_txfm_dimensions[b->intra ? b->tx : b->max_ytx];
+
+    for (int init_y = 0; init_y < h4; init_y += 16) {
+        for (int init_x = 0; init_x < w4; init_x += 16) {
+            const int sub_h4 = imin(h4, 16 + init_y);
+            const int sub_w4 = imin(w4, init_x + 16);
+            int y_off = !!init_y, y, x;
+            for (y = init_y, t->by += init_y; y < sub_h4;
+                 y += t_dim->h, t->by += t_dim->h, y_off++)
+            {
+                struct CodedBlockInfo *const cbi =
+                    &f->frame_thread.cbi[t->by * f->b4_stride];
+                int x_off = !!init_x;
+                for (x = init_x, t->bx += init_x; x < sub_w4;
+                     x += t_dim->w, t->bx += t_dim->w, x_off++)
+                {
+                    if (!b->intra) {
+                        read_coef_tree(t, bs, b, b->max_ytx, 0, b->tx_split,
+                                       x_off, y_off, NULL);
+                    } else {
+                        uint8_t cf_ctx = 0x40;
+                        enum TxfmType txtp;
+                        const int eob = cbi[t->bx].eob[0] =
+                            decode_coefs(t, &t->a->lcoef[bx4 + x],
+                                         &t->l.lcoef[by4 + y], b->tx, bs, b, 1,
+                                         0, ts->frame_thread.cf, &txtp, &cf_ctx);
+                        if (DEBUG_BLOCK_INFO)
+                            printf("Post-y-cf-blk[tx=%d,txtp=%d,eob=%d]: r=%d\n",
+                                   b->tx, txtp, eob, ts->msac.rng);
+                        cbi[t->bx].txtp[0] = txtp;
+                        ts->frame_thread.cf += imin(t_dim->w, 8) * imin(t_dim->h, 8) * 16;
+                        memset(&t->a->lcoef[bx4 + x], cf_ctx,
+                               imin(t_dim->w, f->bw - t->bx));
+                        memset(&t->l.lcoef[by4 + y], cf_ctx,
+                               imin(t_dim->h, f->bh - t->by));
+                    }
+                }
+                t->bx -= x;
+            }
+            t->by -= y;
+
+            if (!has_chroma) continue;
+
+            const int sub_ch4 = imin(ch4, (init_y + 16) >> ss_ver);
+            const int sub_cw4 = imin(cw4, (init_x + 16) >> ss_hor);
+            for (int pl = 0; pl < 2; pl++) {
+                for (y = init_y >> ss_ver, t->by += init_y; y < sub_ch4;
+                     y += uv_t_dim->h, t->by += uv_t_dim->h << ss_ver)
+                {
+                    struct CodedBlockInfo *const cbi =
+                        &f->frame_thread.cbi[t->by * f->b4_stride];
+                    for (x = init_x >> ss_hor, t->bx += init_x; x < sub_cw4;
+                         x += uv_t_dim->w, t->bx += uv_t_dim->w << ss_hor)
+                    {
+                        uint8_t cf_ctx = 0x40;
+                        enum TxfmType txtp;
+                        if (!b->intra)
+                            txtp = t->txtp_map[(by4 + (y << ss_ver)) * 32 +
+                                                bx4 + (x << ss_hor)];
+                        const int eob = cbi[t->bx].eob[1 + pl] =
+                            decode_coefs(t, &t->a->ccoef[pl][cbx4 + x],
+                                         &t->l.ccoef[pl][cby4 + y], b->uvtx, bs,
+                                         b, b->intra, 1 + pl, ts->frame_thread.cf,
+                                         &txtp, &cf_ctx);
+                        if (DEBUG_BLOCK_INFO)
+                            printf("Post-uv-cf-blk[pl=%d,tx=%d,"
+                                   "txtp=%d,eob=%d]: r=%d\n",
+                                   pl, b->uvtx, txtp, eob, ts->msac.rng);
+                        cbi[t->bx].txtp[1 + pl] = txtp;
+                        ts->frame_thread.cf += uv_t_dim->w * uv_t_dim->h * 16;
+                        memset(&t->a->ccoef[pl][cbx4 + x], cf_ctx,
+                               imin(uv_t_dim->w, (f->bw - t->bx + ss_hor) >> ss_hor));
+                        memset(&t->l.ccoef[pl][cby4 + y], cf_ctx,
+                               imin(uv_t_dim->h, (f->bh - t->by + ss_ver) >> ss_ver));
+                    }
+                    t->bx -= x << ss_hor;
+                }
+                t->by -= y << ss_ver;
+            }
+        }
+    }
+}
+
+static void emu_edge(pixel *dst, const ptrdiff_t dst_stride,
+                     const pixel *ref, const ptrdiff_t ref_stride,
+                     const int bw, const int bh,
+                     const int iw, const int ih,
+                     const int x, const int y)
+{
+    // find offset in reference of visible block to copy
+    ref += iclip(y, 0, ih - 1) * PXSTRIDE(ref_stride) + iclip(x, 0, iw - 1);
+
+    // number of pixels to extend (left, right, top, bottom)
+    const int left_ext = iclip(-x, 0, bw - 1);
+    const int right_ext = iclip(x + bw - iw, 0, bw - 1);
+    assert(left_ext + right_ext < bw);
+    const int top_ext = iclip(-y, 0, bh - 1);
+    const int bottom_ext = iclip(y + bh - ih, 0, bh - 1);
+    assert(top_ext + bottom_ext < bh);
+
+    // copy visible portion first
+    pixel *blk = dst + top_ext * PXSTRIDE(dst_stride);
+    const int center_w = bw - left_ext - right_ext;
+    const int center_h = bh - top_ext - bottom_ext;
+    for (int y = 0; y < center_h; y++) {
+        pixel_copy(blk + left_ext, ref, center_w);
+        // extend left edge for this line
+        if (left_ext)
+            pixel_set(blk, blk[left_ext], left_ext);
+        // extend right edge for this line
+        if (right_ext)
+            pixel_set(blk + left_ext + center_w, blk[left_ext + center_w - 1],
+                      right_ext);
+        ref += PXSTRIDE(ref_stride);
+        blk += PXSTRIDE(dst_stride);
+    }
+
+    // copy top
+    blk = dst + top_ext * PXSTRIDE(dst_stride);
+    for (int y = 0; y < top_ext; y++) {
+        pixel_copy(dst, blk, bw);
+        dst += PXSTRIDE(dst_stride);
+    }
+
+    // copy bottom
+    dst += center_h * PXSTRIDE(dst_stride);
+    for (int y = 0; y < bottom_ext; y++) {
+        pixel_copy(dst, &dst[-PXSTRIDE(dst_stride)], bw);
+        dst += PXSTRIDE(dst_stride);
+    }
+}
+
+static void mc(Dav1dTileContext *const t,
+               pixel *const dst8, coef *const dst16, const ptrdiff_t dst_stride,
+               const int bw4, const int bh4,
+               const int bx, const int by, const int pl,
+               const mv mv, const Dav1dThreadPicture *const refp,
+               const enum Filter2d filter_2d)
+{
+    assert((dst8 != NULL) ^ (dst16 != NULL));
+    const Dav1dFrameContext *const f = t->f;
+    const int ss_ver = !!pl && f->cur.p.p.layout == DAV1D_PIXEL_LAYOUT_I420;
+    const int ss_hor = !!pl && f->cur.p.p.layout != DAV1D_PIXEL_LAYOUT_I444;
+    const int h_mul = 4 >> ss_hor, v_mul = 4 >> ss_ver;
+    const int mvx = mv.x, mvy = mv.y;
+    const int mx = mvx & (15 >> !ss_hor), my = mvy & (15 >> !ss_ver);
+    const int dx = bx * h_mul + (mvx >> (3 + ss_hor));
+    const int dy = by * v_mul + (mvy >> (3 + ss_ver));
+    ptrdiff_t ref_stride = refp->p.stride[!!pl];
+    const pixel *ref;
+
+    dav1d_thread_picture_wait(refp, dy + bh4 * v_mul + !!my * 4,
+                              PLANE_TYPE_Y + !!pl);
+    if (dx < 3 || dx + bw4 * h_mul + 4 > f->bw * h_mul ||
+        dy < 3 || dy + bh4 * v_mul + 4 > f->bh * v_mul)
+    {
+        emu_edge(t->emu_edge, 160 * sizeof(pixel), refp->p.data[pl], ref_stride,
+                 bw4 * h_mul + 7, bh4 * v_mul + 7, f->bw * h_mul, f->bh * v_mul,
+                 dx - 3, dy - 3);
+        ref = &t->emu_edge[160 * 3 + 3];
+        ref_stride = 160 * sizeof(pixel);
+    } else {
+        ref = ((pixel *) refp->p.data[pl]) + PXSTRIDE(ref_stride) * dy + dx;
+    }
+
+    if (dst8 != NULL) {
+        f->dsp->mc.mc[filter_2d](dst8, dst_stride, ref, ref_stride, bw4 * h_mul,
+                                 bh4 * v_mul, mx << !ss_hor, my << !ss_ver);
+    } else {
+        f->dsp->mc.mct[filter_2d](dst16, ref, ref_stride, bw4 * h_mul,
+                                  bh4 * v_mul, mx << !ss_hor, my << !ss_ver);
+    }
+}
+
+static void obmc(Dav1dTileContext *const t,
+                 pixel *const dst, const ptrdiff_t dst_stride,
+                 const uint8_t *const b_dim, const int pl,
+                 const int bx4, const int by4, const int w4, const int h4)
+{
+    assert(!(t->bx & 1) && !(t->by & 1));
+    const Dav1dFrameContext *const f = t->f;
+    const refmvs *const r = &f->mvs[t->by * f->b4_stride + t->bx];
+    pixel *const lap = t->scratch.lap;
+    static const uint8_t obmc_mask_2[2] = { 19,  0 };
+    static const uint8_t obmc_mask_4[4] = { 25, 14,  5,  0 };
+    static const uint8_t obmc_mask_8[8] = { 28, 22, 16, 11,  7,  3,  0,  0 };
+    static const uint8_t obmc_mask_16[16] = { 30, 27, 24, 21, 18, 15, 12, 10,
+                                               8,  6,  4,  3,  0,  0,  0,  0 };
+    static const uint8_t obmc_mask_32[32] = { 31, 29, 28, 26, 24, 23, 21, 20,
+                                              19, 17, 16, 14, 13, 12, 11,  9,
+                                               8,  7,  6,  5,  4,  4,  3,  2,
+                                               0,  0,  0,  0,  0,  0,  0,  0 };
+    static const uint8_t *const obmc_masks[] = {
+        obmc_mask_2, obmc_mask_4, obmc_mask_8, obmc_mask_16, obmc_mask_32
+    };
+    const int ss_ver = !!pl && f->cur.p.p.layout == DAV1D_PIXEL_LAYOUT_I420;
+    const int ss_hor = !!pl && f->cur.p.p.layout != DAV1D_PIXEL_LAYOUT_I444;
+    const int h_mul = 4 >> ss_hor, v_mul = 4 >> ss_ver;
+
+    if (t->by > t->ts->tiling.row_start &&
+        (!pl || b_dim[0] * h_mul + b_dim[1] * v_mul >= 16))
+    {
+        for (int i = 0, x = 0; x < w4 && i < imin(b_dim[2], 4); ) {
+            // only odd blocks are considered for overlap handling, hence +1
+            const refmvs *const a_r = &r[x - f->b4_stride + 1];
+            const uint8_t *const a_b_dim =
+                av1_block_dimensions[sbtype_to_bs[a_r->sb_type]];
+
+            if (a_r->ref[0] > 0) {
+                mc(t, lap, NULL, 128 * sizeof(pixel),
+                   iclip(a_b_dim[0], 2, b_dim[0]), imin(b_dim[1], 16) >> 1,
+                   t->bx + x, t->by, pl, a_r->mv[0],
+                   &f->refp[a_r->ref[0] - 1],
+                   av1_filter_2d[t->a->filter[1][bx4 + x + 1]][t->a->filter[0][bx4 + x + 1]]);
+                f->dsp->mc.blend(&dst[x * h_mul], dst_stride,
+                                 lap, 128 * sizeof(pixel),
+                                 h_mul * iclip(a_b_dim[0], 2, b_dim[0]),
+                                 v_mul * imin(b_dim[1], 16) >> 1,
+                                 obmc_masks[imin(b_dim[3], 4) - ss_ver], 1);
+                i++;
+            }
+            x += imax(a_b_dim[0], 2);
+        }
+    }
+
+    if (t->bx > t->ts->tiling.col_start)
+        for (int i = 0, y = 0; y < h4 && i < imin(b_dim[3], 4); ) {
+            // only odd blocks are considered for overlap handling, hence +1
+            const refmvs *const l_r = &r[(y + 1) * f->b4_stride - 1];
+            const uint8_t *const l_b_dim =
+                av1_block_dimensions[sbtype_to_bs[l_r->sb_type]];
+
+            if (l_r->ref[0] > 0) {
+                mc(t, lap, NULL, 32 * sizeof(pixel),
+                   imin(b_dim[0], 16) >> 1,
+                   iclip(l_b_dim[1], 2, b_dim[1]),
+                   t->bx, t->by + y, pl, l_r->mv[0],
+                   &f->refp[l_r->ref[0] - 1],
+                   av1_filter_2d[t->l.filter[1][by4 + y + 1]][t->l.filter[0][by4 + y + 1]]);
+                f->dsp->mc.blend(&dst[y * v_mul * PXSTRIDE(dst_stride)], dst_stride,
+                                 lap, 32 * sizeof(pixel),
+                                 h_mul * imin(b_dim[0], 16) >> 1,
+                                 v_mul * iclip(l_b_dim[1], 2, b_dim[1]),
+                                 obmc_masks[imin(b_dim[2], 4) - ss_hor], 0);
+                i++;
+            }
+            y += imax(l_b_dim[1], 2);
+        }
+}
+
+static void warp_affine(Dav1dTileContext *const t,
+                        pixel *dst8, coef *dst16, const ptrdiff_t dstride,
+                        const uint8_t *const b_dim, const int pl,
+                        const Dav1dThreadPicture *const refp,
+                        const WarpedMotionParams *const wmp)
+{
+    assert((dst8 != NULL) ^ (dst16 != NULL));
+    const Dav1dFrameContext *const f = t->f;
+    const Dav1dDSPContext *const dsp = f->dsp;
+    const int ss_ver = !!pl && f->cur.p.p.layout == DAV1D_PIXEL_LAYOUT_I420;
+    const int ss_hor = !!pl && f->cur.p.p.layout != DAV1D_PIXEL_LAYOUT_I444;
+    const int h_mul = 4 >> ss_hor, v_mul = 4 >> ss_ver;
+    assert(!((b_dim[0] * h_mul) & 7) && !((b_dim[1] * v_mul) & 7));
+    const int32_t *const mat = wmp->matrix;
+    const int width = f->bw * h_mul, height = f->bh * v_mul;
+
+    for (int y = 0; y < b_dim[1] * v_mul; y += 8) {
+        for (int x = 0; x < b_dim[0] * h_mul; x += 8) {
+            // calculate transformation relative to center of 8x8 block in
+            // luma pixel units
+            const int src_x = t->bx * 4 + ((x + 4) << ss_hor);
+            const int src_y = t->by * 4 + ((y + 4) << ss_ver);
+            const int mvx = (mat[2] * src_x + mat[3] * src_y + mat[0]) >> ss_hor;
+            const int mvy = (mat[4] * src_x + mat[5] * src_y + mat[1]) >> ss_ver;
+
+            const int dx = (mvx >> 16) - 4;
+            const int mx = ((mvx & 0xffff) - wmp->alpha * 4 -
+                                             wmp->beta  * 7) & ~0x3f;
+            const int dy = (mvy >> 16) - 4;
+            const int my = ((mvy & 0xffff) - wmp->gamma * 4 -
+                                             wmp->delta * 4) & ~0x3f;
+
+            const pixel *ref_ptr;
+            ptrdiff_t ref_stride = refp->p.stride[!!pl];
+
+            dav1d_thread_picture_wait(refp, dy + 4 + 8,
+                                      PLANE_TYPE_Y + !!pl);
+            if (dx < 3 || dx + 8 + 4 > width || dy < 3 || dy + 8 + 4 > height) {
+                emu_edge(t->emu_edge, 160 * sizeof(pixel), refp->p.data[pl],
+                         ref_stride, 15, 15, width, height, dx - 3, dy - 3);
+                ref_ptr = &t->emu_edge[160 * 3 + 3];
+                ref_stride = 160 * sizeof(pixel);
+            } else {
+                ref_ptr = ((pixel *) refp->p.data[pl]) + PXSTRIDE(ref_stride) * dy + dx;
+            }
+            if (dst16 != NULL)
+                dsp->mc.warp8x8t(&dst16[x], dstride, ref_ptr, ref_stride,
+                                 wmp->abcd, mx, my);
+            else
+                dsp->mc.warp8x8(&dst8[x], dstride, ref_ptr, ref_stride,
+                                wmp->abcd, mx, my);
+        }
+        if (dst8) dst8  += 8 * PXSTRIDE(dstride);
+        else      dst16 += 8 * dstride;
+    }
+}
+
+void bytefn(recon_b_intra)(Dav1dTileContext *const t, const enum BlockSize bs,
+                           const enum EdgeFlags intra_edge_flags,
+                           const Av1Block *const b)
+{
+    Dav1dTileState *const ts = t->ts;
+    const Dav1dFrameContext *const f = t->f;
+    const Dav1dDSPContext *const dsp = f->dsp;
+    const int bx4 = t->bx & 31, by4 = t->by & 31;
+    const int ss_ver = f->cur.p.p.layout == DAV1D_PIXEL_LAYOUT_I420;
+    const int ss_hor = f->cur.p.p.layout != DAV1D_PIXEL_LAYOUT_I444;
+    const int cbx4 = bx4 >> ss_hor, cby4 = by4 >> ss_ver;
+    const uint8_t *const b_dim = av1_block_dimensions[bs];
+    const int bw4 = b_dim[0], bh4 = b_dim[1];
+    const int w4 = imin(bw4, f->bw - t->bx), h4 = imin(bh4, f->bh - t->by);
+    const int cw4 = (w4 + ss_hor) >> ss_hor, ch4 = (h4 + ss_ver) >> ss_ver;
+    const int has_chroma = f->seq_hdr.layout != DAV1D_PIXEL_LAYOUT_I400 &&
+                           (bw4 > ss_hor || t->bx & 1) &&
+                           (bh4 > ss_ver || t->by & 1);
+    const TxfmInfo *const t_dim = &av1_txfm_dimensions[b->tx];
+    const TxfmInfo *const uv_t_dim = &av1_txfm_dimensions[b->uvtx];
+
+    // coefficient coding
+    pixel edge_mem[257], *const edge = &edge_mem[128];
+    const int cbw4 = (bw4 + ss_hor) >> ss_hor, cbh4 = (bh4 + ss_ver) >> ss_ver;
+
+    for (int init_y = 0; init_y < h4; init_y += 16) {
+        for (int init_x = 0; init_x < w4; init_x += 16) {
+            if (b->pal_sz[0]) {
+                pixel *dst = ((pixel *) f->cur.p.data[0]) +
+                             4 * (t->by * PXSTRIDE(f->cur.p.stride[0]) + t->bx);
+                const uint8_t *pal_idx;
+                if (f->frame_thread.pass) {
+                    pal_idx = ts->frame_thread.pal_idx;
+                    ts->frame_thread.pal_idx += bw4 * bh4 * 16;
+                } else {
+                    pal_idx = t->scratch.pal_idx;
+                }
+                const uint16_t *const pal = f->frame_thread.pass ?
+                    f->frame_thread.pal[((t->by >> 1) + (t->bx & 1)) * (f->b4_stride >> 1) +
+                                        ((t->bx >> 1) + (t->by & 1))][0] : t->pal[0];
+                f->dsp->ipred.pal_pred(dst, f->cur.p.stride[0], pal,
+                                       pal_idx, bw4 * 4, bh4 * 4);
+                if (DEBUG_BLOCK_INFO && DEBUG_B_PIXELS)
+                    hex_dump(dst, PXSTRIDE(f->cur.p.stride[0]),
+                             bw4 * 4, bh4 * 4, "y-pal-pred");
+            }
+
+            const int sm_fl = sm_flag(t->a, bx4) | sm_flag(&t->l, by4);
+            const int sb_has_tr = init_x + 16 < w4 ? 1 : init_y ? 0 :
+                              intra_edge_flags & EDGE_I444_TOP_HAS_RIGHT;
+            const int sb_has_bl = init_x ? 0 : init_y + 16 < h4 ? 1 :
+                              intra_edge_flags & EDGE_I444_LEFT_HAS_BOTTOM;
+            int y, x;
+            const int sub_h4 = imin(h4, 16 + init_y);
+            const int sub_w4 = imin(w4, init_x + 16);
+            for (y = init_y, t->by += init_y; y < sub_h4;
+                 y += t_dim->h, t->by += t_dim->h)
+            {
+                pixel *dst = ((pixel *) f->cur.p.data[0]) +
+                               4 * (t->by * PXSTRIDE(f->cur.p.stride[0]) +
+                                    t->bx + init_x);
+                for (x = init_x, t->bx += init_x; x < sub_w4;
+                     x += t_dim->w, t->bx += t_dim->w)
+                {
+                    if (b->pal_sz[0]) goto skip_y_pred;
+
+                    int angle = b->y_angle;
+                    const enum EdgeFlags edge_flags =
+                        (((y > init_y || !sb_has_tr) && (x + t_dim->w >= sub_w4)) ?
+                             0 : EDGE_I444_TOP_HAS_RIGHT) |
+                        ((x > init_x || (!sb_has_bl && y + t_dim->h >= sub_h4)) ?
+                             0 : EDGE_I444_LEFT_HAS_BOTTOM);
+                    const pixel *top_sb_edge = NULL;
+                    if (!(t->by & (f->sb_step - 1))) {
+                        top_sb_edge = f->ipred_edge[0];
+                        const int sby = t->by >> f->sb_shift;
+                        top_sb_edge += f->sb128w * 128 * (sby - 1);
+                    }
+                    const enum IntraPredMode m =
+                        bytefn(prepare_intra_edges)(t->bx,
+                                                    t->bx > ts->tiling.col_start,
+                                                    t->by,
+                                                    t->by > ts->tiling.row_start,
+                                                    ts->tiling.col_end,
+                                                    ts->tiling.row_end,
+                                                    edge_flags, dst,
+                                                    f->cur.p.stride[0], top_sb_edge,
+                                                    b->y_mode, &angle,
+                                                    t_dim->w, t_dim->h, edge);
+                    dsp->ipred.intra_pred[b->tx][m](dst, f->cur.p.stride[0],
+                                                    edge, angle | sm_fl);
+
+                    if (DEBUG_BLOCK_INFO && DEBUG_B_PIXELS) {
+                        hex_dump(edge - t_dim->h * 4, t_dim->h * 4,
+                                 t_dim->h * 4, 2, "l");
+                        hex_dump(edge, 0, 1, 1, "tl");
+                        hex_dump(edge + 1, t_dim->w * 4,
+                                 t_dim->w * 4, 2, "t");
+                        hex_dump(dst, f->cur.p.stride[0],
+                                 t_dim->w * 4, t_dim->h * 4, "y-intra-pred");
+                    }
+
+                skip_y_pred: {}
+                    if (!b->skip) {
+                        coef *cf;
+                        int eob;
+                        enum TxfmType txtp;
+                        if (f->frame_thread.pass) {
+                            cf = ts->frame_thread.cf;
+                            ts->frame_thread.cf += imin(t_dim->w, 8) * imin(t_dim->h, 8) * 16;
+                            const struct CodedBlockInfo *const cbi =
+                                &f->frame_thread.cbi[t->by * f->b4_stride + t->bx];
+                            eob = cbi->eob[0];
+                            txtp = cbi->txtp[0];
+                        } else {
+                            uint8_t cf_ctx;
+                            cf = t->cf;
+                            eob = decode_coefs(t, &t->a->lcoef[bx4 + x],
+                                               &t->l.lcoef[by4 + y], b->tx, bs,
+                                               b, 1, 0, cf, &txtp, &cf_ctx);
+                            if (DEBUG_BLOCK_INFO)
+                                printf("Post-y-cf-blk[tx=%d,txtp=%d,eob=%d]: r=%d\n",
+                                       b->tx, txtp, eob, ts->msac.rng);
+                            memset(&t->a->lcoef[bx4 + x], cf_ctx,
+                                   imin(t_dim->w, f->bw - t->bx));
+                            memset(&t->l.lcoef[by4 + y], cf_ctx,
+                                   imin(t_dim->h, f->bh - t->by));
+                        }
+                        if (eob >= 0) {
+                            if (DEBUG_BLOCK_INFO && DEBUG_B_PIXELS)
+                                coef_dump(cf, imin(t_dim->h, 8) * 4,
+                                          imin(t_dim->w, 8) * 4, 3, "dq");
+                            dsp->itx.itxfm_add[b->tx]
+                                              [txtp](dst,
+                                                     f->cur.p.stride[0],
+                                                     cf, eob);
+                            if (DEBUG_BLOCK_INFO && DEBUG_B_PIXELS)
+                                hex_dump(dst, f->cur.p.stride[0],
+                                         t_dim->w * 4, t_dim->h * 4, "recon");
+                        }
+                    } else if (!f->frame_thread.pass) {
+                        memset(&t->a->lcoef[bx4 + x], 0x40, t_dim->w);
+                        memset(&t->l.lcoef[by4 + y], 0x40, t_dim->h);
+                    }
+                    dst += 4 * t_dim->w;
+                }
+                t->bx -= x;
+            }
+            t->by -= y;
+
+            if (!has_chroma) continue;
+
+            const ptrdiff_t stride = f->cur.p.stride[1];
+
+            if (b->uv_mode == CFL_PRED) {
+                assert(!init_x && !init_y);
+
+                int16_t *const ac = t->scratch.ac;
+                ALIGN_STK_32(pixel, uv_pred, 2 * 32,);
+                pixel *y_src = ((pixel *) f->cur.p.data[0]) + 4 * (t->bx & ~ss_hor) +
+                                 4 * (t->by & ~ss_ver) * PXSTRIDE(f->cur.p.stride[0]);
+                const ptrdiff_t uv_off = 4 * ((t->bx >> ss_hor) +
+                                              (t->by >> ss_ver) * PXSTRIDE(stride));
+                pixel *const uv_dst[2] = { ((pixel *) f->cur.p.data[1]) + uv_off,
+                                           ((pixel *) f->cur.p.data[2]) + uv_off };
+                // cfl_uvtx can be different from uvtx in case of lossless
+                const enum RectTxfmSize cfl_uvtx =
+                    av1_max_txfm_size_for_bs[bs][f->cur.p.p.layout];
+                const TxfmInfo *const cfl_uv_t_dim =
+                    &av1_txfm_dimensions[cfl_uvtx];
+
+                for (int pl = 0; pl < 2; pl++) {
+                    int angle = 0;
+                    const pixel *top_sb_edge = NULL;
+                    if (!((t->by & ~ss_ver) & (f->sb_step - 1))) {
+                        top_sb_edge = f->ipred_edge[pl + 1];
+                        const int sby = t->by >> f->sb_shift;
+                        top_sb_edge += f->sb128w * 128 * (sby - 1);
+                    }
+                    const enum IntraPredMode m =
+                        bytefn(prepare_intra_edges)(t->bx >> ss_hor,
+                                                    (t->bx >> ss_hor) >
+                                                        (ts->tiling.col_start >> ss_hor),
+                                                    t->by >> ss_ver,
+                                                    (t->by >> ss_ver) >
+                                                        (ts->tiling.row_start >> ss_ver),
+                                                    ts->tiling.col_end >> ss_hor,
+                                                    ts->tiling.row_end >> ss_ver,
+                                                    0, uv_dst[pl], stride,
+                                                    top_sb_edge, DC_PRED, &angle,
+                                                    cfl_uv_t_dim->w,
+                                                    cfl_uv_t_dim->h, edge);
+                    dsp->ipred.intra_pred[cfl_uvtx][m](&uv_pred[32 * pl],
+                                                       0, edge, 0);
+                }
+                const int furthest_r =
+                    ((cw4 << ss_hor) + t_dim->w - 1) & ~(t_dim->w - 1);
+                const int furthest_b =
+                    ((ch4 << ss_ver) + t_dim->h - 1) & ~(t_dim->h - 1);
+                dsp->ipred.cfl_ac[f->cur.p.p.layout - 1]
+                                 [cfl_uvtx](ac, y_src, f->cur.p.stride[0],
+                                            cbw4 - (furthest_r >> ss_hor),
+                                            cbh4 - (furthest_b >> ss_ver));
+                dsp->ipred.cfl_pred[cfl_uv_t_dim->lw](uv_dst[0],
+                                                      uv_dst[1], stride,
+                                                      ac, uv_pred,
+                                                      b->cfl_alpha,
+                                                      cbh4 * 4);
+                if (DEBUG_BLOCK_INFO && DEBUG_B_PIXELS) {
+                    hex_dump(uv_dst[0], stride, cbw4 * 4, cbh4 * 4, "u-cfl-pred");
+                    hex_dump(uv_dst[1], stride, cbw4 * 4, cbh4 * 4, "v-cfl-pred");
+                }
+            } else if (b->pal_sz[1]) {
+                ptrdiff_t uv_dstoff = 4 * ((t->bx >> ss_hor) +
+                                           (t->by >> ss_ver) * PXSTRIDE(f->cur.p.stride[1]));
+                const uint8_t *pal_idx;
+                if (f->frame_thread.pass) {
+                    pal_idx = ts->frame_thread.pal_idx;
+                    ts->frame_thread.pal_idx += cbw4 * cbh4 * 16;
+                } else {
+                    pal_idx = &t->scratch.pal_idx[bw4 * bh4 * 16];
+                }
+                const uint16_t *const pal_u = f->frame_thread.pass ?
+                    f->frame_thread.pal[((t->by >> 1) + (t->bx & 1)) * (f->b4_stride >> 1) +
+                                        ((t->bx >> 1) + (t->by & 1))][1] : t->pal[1];
+                f->dsp->ipred.pal_pred(((pixel *) f->cur.p.data[1]) + uv_dstoff,
+                                       f->cur.p.stride[1], pal_u,
+                                       pal_idx, cbw4 * 4, cbh4 * 4);
+                const uint16_t *const pal_v = f->frame_thread.pass ?
+                    f->frame_thread.pal[((t->by >> 1) + (t->bx & 1)) * (f->b4_stride >> 1) +
+                                        ((t->bx >> 1) + (t->by & 1))][2] : t->pal[2];
+                f->dsp->ipred.pal_pred(((pixel *) f->cur.p.data[2]) + uv_dstoff,
+                                       f->cur.p.stride[1], pal_v,
+                                       pal_idx, cbw4 * 4, cbh4 * 4);
+                if (DEBUG_BLOCK_INFO && DEBUG_B_PIXELS) {
+                    hex_dump(((pixel *) f->cur.p.data[1]) + uv_dstoff,
+                             PXSTRIDE(f->cur.p.stride[1]),
+                             cbw4 * 4, cbh4 * 4, "u-pal-pred");
+                    hex_dump(((pixel *) f->cur.p.data[2]) + uv_dstoff,
+                             PXSTRIDE(f->cur.p.stride[1]),
+                             cbw4 * 4, cbh4 * 4, "v-pal-pred");
+                }
+            }
+
+            const int sm_uv_fl = sm_uv_flag(t->a, cbx4) |
+                                 sm_uv_flag(&t->l, cby4);
+            const int uv_sb_has_tr =
+                ((init_x + 16) >> ss_hor) < cw4 ? 1 : init_y ? 0 :
+                intra_edge_flags & (EDGE_I420_TOP_HAS_RIGHT >> (f->cur.p.p.layout - 1));
+            const int uv_sb_has_bl =
+                init_x ? 0 : ((init_y + 16) >> ss_ver) < ch4 ? 1 :
+                intra_edge_flags & (EDGE_I420_LEFT_HAS_BOTTOM >> (f->cur.p.p.layout - 1));
+            const int sub_ch4 = imin(ch4, (init_y + 16) >> ss_ver);
+            const int sub_cw4 = imin(cw4, (init_x + 16) >> ss_hor);
+            for (int pl = 0; pl < 2; pl++) {
+                for (y = init_y >> ss_ver, t->by += init_y; y < sub_ch4;
+                     y += uv_t_dim->h, t->by += uv_t_dim->h << ss_ver)
+                {
+                    pixel *dst = ((pixel *) f->cur.p.data[1 + pl]) +
+                                   4 * ((t->by >> ss_ver) * PXSTRIDE(stride) +
+                                        ((t->bx + init_x) >> ss_hor));
+                    for (x = init_x >> ss_hor, t->bx += init_x; x < sub_cw4;
+                         x += uv_t_dim->w, t->bx += uv_t_dim->w << ss_hor)
+                    {
+                        if (b->uv_mode == CFL_PRED || b->pal_sz[1])
+                            goto skip_uv_pred;
+
+                        int angle = b->uv_angle;
+                        // this probably looks weird because we're using
+                        // luma flags in a chroma loop, but that's because
+                        // prepare_intra_edges() expects luma flags as input
+                        const enum EdgeFlags edge_flags =
+                            (((y > (init_y >> ss_ver) || !uv_sb_has_tr) &&
+                              (x + uv_t_dim->w >= sub_cw4)) ?
+                                 0 : EDGE_I444_TOP_HAS_RIGHT) |
+                            ((x > (init_x >> ss_hor) ||
+                              (!uv_sb_has_bl && y + uv_t_dim->h >= sub_ch4)) ?
+                                 0 : EDGE_I444_LEFT_HAS_BOTTOM);
+                        const pixel *top_sb_edge = NULL;
+                        if (!((t->by & ~ss_ver) & (f->sb_step - 1))) {
+                            top_sb_edge = f->ipred_edge[1 + pl];
+                            const int sby = t->by >> f->sb_shift;
+                            top_sb_edge += f->sb128w * 128 * (sby - 1);
+                        }
+                        const enum IntraPredMode m =
+                            bytefn(prepare_intra_edges)(t->bx >> ss_hor,
+                                                        (t->bx >> ss_hor) >
+                                                            (ts->tiling.col_start >> ss_hor),
+                                                        t->by >> ss_ver,
+                                                        (t->by >> ss_ver) >
+                                                            (ts->tiling.row_start >> ss_ver),
+                                                        ts->tiling.col_end >> ss_hor,
+                                                        ts->tiling.row_end >> ss_ver,
+                                                        edge_flags, dst, stride,
+                                                        top_sb_edge, b->uv_mode,
+                                                        &angle, uv_t_dim->w,
+                                                        uv_t_dim->h, edge);
+                        dsp->ipred.intra_pred[b->uvtx][m](dst, stride,
+                                                          edge, angle | sm_uv_fl);
+                        if (DEBUG_BLOCK_INFO && DEBUG_B_PIXELS) {
+                            hex_dump(edge - uv_t_dim->h * 4, uv_t_dim->h * 4,
+                                     uv_t_dim->h * 4, 2, "l");
+                            hex_dump(edge, 0, 1, 1, "tl");
+                            hex_dump(edge + 1, uv_t_dim->w * 4,
+                                     uv_t_dim->w * 4, 2, "t");
+                            hex_dump(dst, stride, uv_t_dim->w * 4,
+                                     uv_t_dim->h * 4, pl ? "v-intra-pred" : "u-intra-pred");
+                        }
+
+                    skip_uv_pred: {}
+                        if (!b->skip) {
+                            enum TxfmType txtp;
+                            int eob;
+                            coef *cf;
+                            if (f->frame_thread.pass) {
+                                cf = ts->frame_thread.cf;
+                                ts->frame_thread.cf += uv_t_dim->w * uv_t_dim->h * 16;
+                                const struct CodedBlockInfo *const cbi =
+                                    &f->frame_thread.cbi[t->by * f->b4_stride + t->bx];
+                                eob = cbi->eob[pl + 1];
+                                txtp = cbi->txtp[pl + 1];
+                            } else {
+                                uint8_t cf_ctx;
+                                cf = t->cf;
+                                eob = decode_coefs(t, &t->a->ccoef[pl][cbx4 + x],
+                                                   &t->l.ccoef[pl][cby4 + y],
+                                                   b->uvtx, bs, b, 1, 1 + pl, cf,
+                                                   &txtp, &cf_ctx);
+                                if (DEBUG_BLOCK_INFO)
+                                    printf("Post-uv-cf-blk[pl=%d,tx=%d,"
+                                           "txtp=%d,eob=%d]: r=%d [x=%d,cbx4=%d]\n",
+                                           pl, b->uvtx, txtp, eob, ts->msac.rng, x, cbx4);
+                                memset(&t->a->ccoef[pl][cbx4 + x], cf_ctx,
+                                       imin(uv_t_dim->w, (f->bw - t->bx + ss_hor) >> ss_hor));
+                                memset(&t->l.ccoef[pl][cby4 + y], cf_ctx,
+                                       imin(uv_t_dim->h, (f->bh - t->by + ss_ver) >> ss_ver));
+                            }
+                            if (eob >= 0) {
+                                if (DEBUG_BLOCK_INFO && DEBUG_B_PIXELS)
+                                    coef_dump(cf, uv_t_dim->h * 4,
+                                              uv_t_dim->w * 4, 3, "dq");
+                                dsp->itx.itxfm_add[b->uvtx]
+                                                  [txtp](dst, stride,
+                                                         cf, eob);
+                                if (DEBUG_BLOCK_INFO && DEBUG_B_PIXELS)
+                                    hex_dump(dst, stride, uv_t_dim->w * 4,
+                                             uv_t_dim->h * 4, "recon");
+                            }
+                        } else if (!f->frame_thread.pass) {
+                            memset(&t->a->ccoef[pl][cbx4 + x], 0x40, uv_t_dim->w);
+                            memset(&t->l.ccoef[pl][cby4 + y], 0x40, uv_t_dim->h);
+                        }
+                        dst += uv_t_dim->w * 4;
+                    }
+                    t->bx -= x << ss_hor;
+                }
+                t->by -= y << ss_ver;
+            }
+        }
+    }
+}
+
+void bytefn(recon_b_inter)(Dav1dTileContext *const t, const enum BlockSize bs,
+                           const Av1Block *const b)
+{
+    Dav1dTileState *const ts = t->ts;
+    const Dav1dFrameContext *const f = t->f;
+    const Dav1dDSPContext *const dsp = f->dsp;
+    const int bx4 = t->bx & 31, by4 = t->by & 31;
+    const int ss_ver = f->cur.p.p.layout == DAV1D_PIXEL_LAYOUT_I420;
+    const int ss_hor = f->cur.p.p.layout != DAV1D_PIXEL_LAYOUT_I444;
+    const int cbx4 = bx4 >> ss_hor, cby4 = by4 >> ss_ver;
+    const uint8_t *const b_dim = av1_block_dimensions[bs];
+    const int bw4 = b_dim[0], bh4 = b_dim[1];
+    const int w4 = imin(bw4, f->bw - t->bx), h4 = imin(bh4, f->bh - t->by);
+    const int has_chroma = f->seq_hdr.layout != DAV1D_PIXEL_LAYOUT_I400 &&
+                           (bw4 > ss_hor || t->bx & 1) &&
+                           (bh4 > ss_ver || t->by & 1);
+    const int chr_layout_idx = f->cur.p.p.layout == DAV1D_PIXEL_LAYOUT_I400 ? 0 :
+                               DAV1D_PIXEL_LAYOUT_I444 - f->cur.p.p.layout;
+
+    // prediction
+    const int cbh4 = (bh4 + ss_ver) >> ss_ver, cbw4 = (bw4 + ss_hor) >> ss_hor;
+    pixel *dst = ((pixel *) f->cur.p.data[0]) +
+        4 * (t->by * PXSTRIDE(f->cur.p.stride[0]) + t->bx);
+    const ptrdiff_t uvdstoff =
+        4 * ((t->bx >> ss_hor) + (t->by >> ss_ver) * PXSTRIDE(f->cur.p.stride[1]));
+    if (!(f->frame_hdr.frame_type & 1)) {
+        // intrabc
+        mc(t, dst, NULL, f->cur.p.stride[0],
+           bw4, bh4, t->bx, t->by, 0, b->mv[0], &f->cur, FILTER_2D_BILINEAR);
+        if (has_chroma) for (int pl = 1; pl < 3; pl++)
+            mc(t, ((pixel *) f->cur.p.data[pl]) + uvdstoff, NULL, f->cur.p.stride[1],
+               bw4 << (bw4 == ss_hor), bh4 << (bh4 == ss_ver),
+               t->bx & ~ss_hor, t->by & ~ss_ver,
+               pl, b->mv[0], &f->cur, FILTER_2D_BILINEAR);
+    } else if (b->comp_type == COMP_INTER_NONE) {
+        const Dav1dThreadPicture *const refp = &f->refp[b->ref[0]];
+        const enum Filter2d filter_2d = b->filter2d;
+
+        if (imin(bw4, bh4) > 1 &&
+            ((b->inter_mode == GLOBALMV &&
+              f->frame_hdr.gmv[b->ref[0]].type > WM_TYPE_TRANSLATION) ||
+             (b->motion_mode == MM_WARP &&
+              t->warpmv.type > WM_TYPE_TRANSLATION)))
+        {
+            warp_affine(t, dst, NULL, f->cur.p.stride[0], b_dim, 0, refp,
+                        b->motion_mode == MM_WARP ? &t->warpmv :
+                            &f->frame_hdr.gmv[b->ref[0]]);
+        } else {
+            mc(t, dst, NULL, f->cur.p.stride[0],
+               bw4, bh4, t->bx, t->by, 0, b->mv[0], refp, filter_2d);
+            if (b->motion_mode == MM_OBMC)
+                obmc(t, dst, f->cur.p.stride[0], b_dim, 0, bx4, by4, w4, h4);
+        }
+        if (b->interintra_type) {
+            const enum RectTxfmSize ii_tx = av1_max_txfm_size_for_bs[bs][0];
+            pixel tl_edge_px[65], *const tl_edge = &tl_edge_px[32];
+            enum IntraPredMode m = b->interintra_mode == II_SMOOTH_PRED ?
+                                   SMOOTH_PRED : b->interintra_mode;
+            pixel *const tmp = t->scratch.interintra;
+            int angle = 0;
+            const pixel *top_sb_edge = NULL;
+            if (!(t->by & (f->sb_step - 1))) {
+                top_sb_edge = f->ipred_edge[0];
+                const int sby = t->by >> f->sb_shift;
+                top_sb_edge += f->sb128w * 128 * (sby - 1);
+            }
+            m = bytefn(prepare_intra_edges)(t->bx, t->bx > ts->tiling.col_start,
+                                            t->by, t->by > ts->tiling.row_start,
+                                            ts->tiling.col_end, ts->tiling.row_end,
+                                            0, dst, f->cur.p.stride[0], top_sb_edge,
+                                            m, &angle, bw4, bh4, tl_edge);
+            dsp->ipred.intra_pred[ii_tx][m](tmp, 4 * bw4 * sizeof(pixel), tl_edge, 0);
+            const uint8_t *const ii_mask =
+                b->interintra_type == INTER_INTRA_BLEND ?
+                     ii_masks[bs][0][b->interintra_mode] :
+                     wedge_masks[bs][0][0][b->wedge_idx];
+            dsp->mc.blend(dst, f->cur.p.stride[0], tmp, bw4 * 4 * sizeof(pixel),
+                          bw4 * 4, bh4 * 4, ii_mask, bw4 * 4);
+        }
+
+        if (!has_chroma) goto skip_inter_chroma_pred;
+
+        // sub8x8 derivation
+        int is_sub8x8 = bw4 == ss_hor || bh4 == ss_ver;
+        refmvs *r;
+        if (is_sub8x8) {
+            assert(ss_hor == 1);
+            r = &f->mvs[t->by * f->b4_stride + t->bx];
+            if (bw4 == 1) is_sub8x8 &= r[-1].ref[0] > 0;
+            if (bh4 == ss_ver) is_sub8x8 &= r[-f->b4_stride].ref[0] > 0;
+            if (bw4 == 1 && bh4 == ss_ver)
+                is_sub8x8 &= r[-(1 + f->b4_stride)].ref[0] > 0;
+        }
+
+        // chroma prediction
+        if (is_sub8x8) {
+            assert(ss_hor == 1);
+            int h_off = 0, v_off = 0;
+            if (bw4 == 1 && bh4 == ss_ver) {
+                for (int pl = 0; pl < 2; pl++)
+                    mc(t, ((pixel *) f->cur.p.data[1 + pl]) + uvdstoff,
+                       NULL, f->cur.p.stride[1],
+                       bw4, bh4, t->bx - 1, t->by - 1, 1 + pl,
+                       r[-(f->b4_stride + 1)].mv[0],
+                       &f->refp[r[-(f->b4_stride + 1)].ref[0] - 1],
+                       f->frame_thread.pass != 2 ? t->tl_4x4_filter :
+                           f->frame_thread.b[((t->by - 1) * f->b4_stride) + t->bx - 1].filter2d);
+                v_off = 2 * PXSTRIDE(f->cur.p.stride[1]);
+                h_off = 2;
+            }
+            if (bw4 == 1) {
+                const enum Filter2d left_filter_2d =
+                    av1_filter_2d[t->l.filter[1][by4]][t->l.filter[0][by4]];
+                for (int pl = 0; pl < 2; pl++)
+                    mc(t, ((pixel *) f->cur.p.data[1 + pl]) + uvdstoff + v_off, NULL,
+                       f->cur.p.stride[1], bw4, bh4, t->bx - 1,
+                       t->by, 1 + pl, r[-1].mv[0], &f->refp[r[-1].ref[0] - 1],
+                       f->frame_thread.pass != 2 ? left_filter_2d :
+                           f->frame_thread.b[(t->by * f->b4_stride) + t->bx - 1].filter2d);
+                h_off = 2;
+            }
+            if (bh4 == ss_ver) {
+                const enum Filter2d top_filter_2d =
+                    av1_filter_2d[t->a->filter[1][bx4]][t->a->filter[0][bx4]];
+                for (int pl = 0; pl < 2; pl++)
+                    mc(t, ((pixel *) f->cur.p.data[1 + pl]) + uvdstoff + h_off, NULL,
+                       f->cur.p.stride[1], bw4, bh4, t->bx, t->by - 1,
+                       1 + pl, r[-f->b4_stride].mv[0],
+                       &f->refp[r[-f->b4_stride].ref[0] - 1],
+                       f->frame_thread.pass != 2 ? top_filter_2d :
+                           f->frame_thread.b[((t->by - 1) * f->b4_stride) + t->bx].filter2d);
+                v_off = 2 * PXSTRIDE(f->cur.p.stride[1]);
+            }
+            for (int pl = 0; pl < 2; pl++)
+                mc(t, ((pixel *) f->cur.p.data[1 + pl]) + uvdstoff + h_off + v_off, NULL, f->cur.p.stride[1],
+                   bw4, bh4, t->bx, t->by, 1 + pl, b->mv[0], refp, filter_2d);
+        } else {
+            if (imin(cbw4, cbh4) > 1 &&
+                ((b->inter_mode == GLOBALMV &&
+                  f->frame_hdr.gmv[b->ref[0]].type > WM_TYPE_TRANSLATION) ||
+                 (b->motion_mode == MM_WARP &&
+                  t->warpmv.type > WM_TYPE_TRANSLATION)))
+            {
+                for (int pl = 0; pl < 2; pl++)
+                    warp_affine(t, ((pixel *) f->cur.p.data[1 + pl]) + uvdstoff, NULL,
+                                f->cur.p.stride[1], b_dim, 1 + pl, refp,
+                                b->motion_mode == MM_WARP ? &t->warpmv :
+                                    &f->frame_hdr.gmv[b->ref[0]]);
+            } else {
+                for (int pl = 0; pl < 2; pl++) {
+                    mc(t, ((pixel *) f->cur.p.data[1 + pl]) + uvdstoff,
+                       NULL, f->cur.p.stride[1],
+                       bw4 << (bw4 == ss_hor), bh4 << (bh4 == ss_ver),
+                       t->bx & ~ss_hor, t->by & ~ss_ver,
+                       1 + pl, b->mv[0], refp, filter_2d);
+                    if (b->motion_mode == MM_OBMC)
+                        obmc(t, ((pixel *) f->cur.p.data[1 + pl]) + uvdstoff,
+                             f->cur.p.stride[1], b_dim, 1 + pl, bx4, by4, w4, h4);
+                }
+            }
+            if (b->interintra_type) {
+                // FIXME for 8x32 with 4:2:2 subsampling, this probably does
+                // the wrong thing since it will select 4x16, not 4x32, as a
+                // transform size...
+                const enum RectTxfmSize ii_tx =
+                    av1_max_txfm_size_for_bs[bs][f->cur.p.p.layout];
+                const uint8_t *const ii_mask =
+                    b->interintra_type == INTER_INTRA_BLEND ?
+                         ii_masks[bs][chr_layout_idx][b->interintra_mode] :
+                         wedge_masks[bs][chr_layout_idx][0][b->wedge_idx];
+
+                for (int pl = 0; pl < 2; pl++) {
+                    pixel *const tmp = t->scratch.interintra;
+                    pixel tl_edge_px[65], *const tl_edge = &tl_edge_px[32];
+                    enum IntraPredMode m =
+                        b->interintra_mode == II_SMOOTH_PRED ?
+                        SMOOTH_PRED : b->interintra_mode;
+                    int angle = 0;
+                    pixel *const uvdst = ((pixel *) f->cur.p.data[1 + pl]) + uvdstoff;
+                    const pixel *top_sb_edge = NULL;
+                    if (!(t->by & (f->sb_step - 1))) {
+                        top_sb_edge = f->ipred_edge[pl + 1];
+                        const int sby = t->by >> f->sb_shift;
+                        top_sb_edge += f->sb128w * 128 * (sby - 1);
+                    }
+                    m = bytefn(prepare_intra_edges)(t->bx >> ss_hor,
+                                                    (t->bx >> ss_hor) >
+                                                        (ts->tiling.col_start >> ss_hor),
+                                                    t->by >> ss_ver,
+                                                    (t->by >> ss_ver) >
+                                                        (ts->tiling.row_start >> ss_ver),
+                                                    ts->tiling.col_end >> ss_hor,
+                                                    ts->tiling.row_end >> ss_ver,
+                                                    0, uvdst, f->cur.p.stride[1],
+                                                    top_sb_edge, m,
+                                                    &angle, cbw4, cbh4, tl_edge);
+                    dsp->ipred.intra_pred[ii_tx][m](tmp, cbw4 * 4, tl_edge, 0);
+                    dsp->mc.blend(uvdst, f->cur.p.stride[1], tmp, cbw4 * 4,
+                                  cbw4 * 4, cbh4 * 4, ii_mask, cbw4 * 4);
+                }
+            }
+        }
+
+    skip_inter_chroma_pred: {}
+        t->tl_4x4_filter = filter_2d;
+    } else {
+        const enum Filter2d filter_2d = b->filter2d;
+        coef (*tmp)[bw4 * bh4 * 16] = (coef (*)[bw4 * bh4 * 16]) t->scratch.compinter;
+        int jnt_weight;
+        uint8_t *const seg_mask = t->scratch_seg_mask;
+        const uint8_t *mask;
+
+        for (int i = 0; i < 2; i++) {
+            const Dav1dThreadPicture *const refp = &f->refp[b->ref[i]];
+
+            if (b->inter_mode == GLOBALMV_GLOBALMV &&
+                f->frame_hdr.gmv[b->ref[i]].type > WM_TYPE_TRANSLATION)
+            {
+                warp_affine(t, NULL, tmp[i], bw4 * 4, b_dim, 0, refp,
+                            &f->frame_hdr.gmv[b->ref[i]]);
+            } else {
+                mc(t, NULL, tmp[i], 0, bw4, bh4, t->bx, t->by, 0,
+                   b->mv[i], refp, filter_2d);
+            }
+        }
+        switch (b->comp_type) {
+        case COMP_INTER_AVG:
+            dsp->mc.avg(dst, f->cur.p.stride[0], tmp[0], tmp[1],
+                        bw4 * 4, bh4 * 4);
+            break;
+        case COMP_INTER_WEIGHTED_AVG:
+            jnt_weight = f->jnt_weights[b->ref[0]][b->ref[1]];
+            dsp->mc.w_avg(dst, f->cur.p.stride[0], tmp[0], tmp[1],
+                          bw4 * 4, bh4 * 4, jnt_weight);
+            break;
+        case COMP_INTER_SEG:
+            dsp->mc.w_mask[chr_layout_idx](dst, f->cur.p.stride[0],
+                                           tmp[b->mask_sign], tmp[!b->mask_sign],
+                                           bw4 * 4, bh4 * 4, seg_mask, b->mask_sign);
+            mask = seg_mask;
+            break;
+        case COMP_INTER_WEDGE:
+            mask = wedge_masks[bs][0][0][b->wedge_idx];
+            dsp->mc.mask(dst, f->cur.p.stride[0],
+                         tmp[b->mask_sign], tmp[!b->mask_sign],
+                         bw4 * 4, bh4 * 4, mask);
+            if (has_chroma)
+                mask = wedge_masks[bs][chr_layout_idx][b->mask_sign][b->wedge_idx];
+            break;
+        }
+
+        // chroma
+        if (has_chroma) for (int pl = 0; pl < 2; pl++) {
+            for (int i = 0; i < 2; i++) {
+                const Dav1dThreadPicture *const refp = &f->refp[b->ref[i]];
+                if (b->inter_mode == GLOBALMV_GLOBALMV &&
+                    imin(cbw4, cbh4) > 1 &&
+                    f->frame_hdr.gmv[b->ref[i]].type > WM_TYPE_TRANSLATION)
+                {
+                    warp_affine(t, NULL, tmp[i], bw4 * 2, b_dim, 1 + pl,
+                                refp, &f->frame_hdr.gmv[b->ref[i]]);
+                } else {
+                    mc(t, NULL, tmp[i], 0, bw4, bh4, t->bx, t->by,
+                       1 + pl, b->mv[i], refp, filter_2d);
+                }
+            }
+            pixel *const uvdst = ((pixel *) f->cur.p.data[1 + pl]) + uvdstoff;
+            switch (b->comp_type) {
+            case COMP_INTER_AVG:
+                dsp->mc.avg(uvdst, f->cur.p.stride[1], tmp[0], tmp[1],
+                            bw4 * 4 >> ss_hor, bh4 * 4 >> ss_ver);
+                break;
+            case COMP_INTER_WEIGHTED_AVG:
+                dsp->mc.w_avg(uvdst, f->cur.p.stride[1], tmp[0], tmp[1],
+                              bw4 * 4 >> ss_hor, bh4 * 4 >> ss_ver, jnt_weight);
+                break;
+            case COMP_INTER_WEDGE:
+            case COMP_INTER_SEG:
+                dsp->mc.mask(uvdst, f->cur.p.stride[1],
+                             tmp[b->mask_sign], tmp[!b->mask_sign],
+                             bw4 * 4 >> ss_hor, bh4 * 4 >> ss_ver, mask);
+                break;
+            }
+        }
+    }
+
+    if (DEBUG_BLOCK_INFO && DEBUG_B_PIXELS) {
+        hex_dump(dst, f->cur.p.stride[0], b_dim[0] * 4, b_dim[1] * 4, "y-pred");
+        if (has_chroma) {
+            hex_dump(&((pixel *) f->cur.p.data[1])[uvdstoff], f->cur.p.stride[1],
+                     cbw4 * 4, cbh4 * 4, "u-pred");
+            hex_dump(&((pixel *) f->cur.p.data[2])[uvdstoff], f->cur.p.stride[1],
+                     cbw4 * 4, cbh4 * 4, "v-pred");
+        }
+    }
+
+    const int cw4 = (w4 + ss_hor) >> ss_hor, ch4 = (h4 + ss_ver) >> ss_ver;
+
+    if (b->skip) {
+        // reset coef contexts
+        memset(&t->a->lcoef[bx4], 0x40, w4);
+        memset(&t->l.lcoef[by4], 0x40, h4);
+        if (has_chroma) {
+            memset(&t->a->ccoef[0][cbx4], 0x40, cw4);
+            memset(&t->l.ccoef[0][cby4], 0x40, ch4);
+            memset(&t->a->ccoef[1][cbx4], 0x40, cw4);
+            memset(&t->l.ccoef[1][cby4], 0x40, ch4);
+        }
+        return;
+    }
+
+    const TxfmInfo *const uvtx = &av1_txfm_dimensions[b->uvtx];
+    const TxfmInfo *const ytx = &av1_txfm_dimensions[b->max_ytx];
+
+    for (int init_y = 0; init_y < bh4; init_y += 16) {
+        for (int init_x = 0; init_x < bw4; init_x += 16) {
+            // coefficient coding & inverse transforms
+            int y_off = !!init_y, y;
+            dst += PXSTRIDE(f->cur.p.stride[0]) * 4 * init_y;
+            for (y = init_y, t->by += init_y; y < imin(h4, init_y + 16);
+                 y += ytx->h, y_off++)
+            {
+                int x, x_off = !!init_x;
+                for (x = init_x, t->bx += init_x; x < imin(w4, init_x + 16);
+                     x += ytx->w, x_off++)
+                {
+                    read_coef_tree(t, bs, b, b->max_ytx, 0, b->tx_split,
+                                   x_off, y_off, &dst[x * 4]);
+                    t->bx += ytx->w;
+                }
+                dst += PXSTRIDE(f->cur.p.stride[0]) * 4 * ytx->h;
+                t->bx -= x;
+                t->by += ytx->h;
+            }
+            dst -= PXSTRIDE(f->cur.p.stride[0]) * 4 * y;
+            t->by -= y;
+
+            // chroma coefs and inverse transform
+            if (has_chroma) for (int pl = 0; pl < 2; pl++) {
+                pixel *uvdst = ((pixel *) f->cur.p.data[1 + pl]) + uvdstoff +
+                    (PXSTRIDE(f->cur.p.stride[1]) * init_y * 4 >> ss_ver);
+                for (y = init_y >> ss_ver, t->by += init_y;
+                     y < imin(ch4, (init_y + 16) >> ss_ver); y += uvtx->h)
+                {
+                    int x;
+                    for (x = init_x >> ss_hor, t->bx += init_x;
+                         x < imin(cw4, (init_x + 16) >> ss_hor); x += uvtx->w)
+                    {
+                        coef *cf;
+                        int eob;
+                        enum TxfmType txtp;
+                        if (f->frame_thread.pass) {
+                            cf = ts->frame_thread.cf;
+                            ts->frame_thread.cf += uvtx->w * uvtx->h * 16;
+                            const struct CodedBlockInfo *const cbi =
+                                &f->frame_thread.cbi[t->by * f->b4_stride + t->bx];
+                            eob = cbi->eob[1 + pl];
+                            txtp = cbi->txtp[1 + pl];
+                        } else {
+                            uint8_t cf_ctx;
+                            cf = t->cf;
+                            txtp = t->txtp_map[(by4 + (y << ss_ver)) * 32 +
+                                                bx4 + (x << ss_hor)];
+                            eob = decode_coefs(t, &t->a->ccoef[pl][cbx4 + x],
+                                               &t->l.ccoef[pl][cby4 + y],
+                                               b->uvtx, bs, b, 0, 1 + pl,
+                                               cf, &txtp, &cf_ctx);
+                            if (DEBUG_BLOCK_INFO)
+                                printf("Post-uv-cf-blk[pl=%d,tx=%d,"
+                                       "txtp=%d,eob=%d]: r=%d\n",
+                                       pl, b->uvtx, txtp, eob, ts->msac.rng);
+                            memset(&t->a->ccoef[pl][cbx4 + x], cf_ctx,
+                                   imin(uvtx->w, (f->bw - t->bx + ss_hor) >> ss_hor));
+                            memset(&t->l.ccoef[pl][cby4 + y], cf_ctx,
+                                   imin(uvtx->h, (f->bh - t->by + ss_ver) >> ss_ver));
+                        }
+                        if (eob >= 0) {
+                            if (DEBUG_BLOCK_INFO && DEBUG_B_PIXELS)
+                                coef_dump(cf, uvtx->h * 4, uvtx->w * 4, 3, "dq");
+                            dsp->itx.itxfm_add[b->uvtx]
+                                              [txtp](&uvdst[4 * x],
+                                                     f->cur.p.stride[1],
+                                                     cf, eob);
+                            if (DEBUG_BLOCK_INFO && DEBUG_B_PIXELS)
+                                hex_dump(&uvdst[4 * x], f->cur.p.stride[1],
+                                         uvtx->w * 4, uvtx->h * 4, "recon");
+                        }
+                        t->bx += uvtx->w << ss_hor;
+                    }
+                    uvdst += PXSTRIDE(f->cur.p.stride[1]) * 4 * uvtx->h;
+                    t->bx -= x << ss_hor;
+                    t->by += uvtx->h << ss_ver;
+                }
+                t->by -= y << ss_ver;
+            }
+        }
+    }
+}
+
+void bytefn(filter_sbrow)(Dav1dFrameContext *const f, const int sby) {
+    const int ss_ver = f->cur.p.p.layout == DAV1D_PIXEL_LAYOUT_I420;
+    const int sbsz = f->sb_step, sbh = f->sbh;
+
+    if (f->frame_hdr.loopfilter.level_y[0] ||
+        f->frame_hdr.loopfilter.level_y[1])
+    {
+        int start_of_tile_row = 0;
+        if (f->frame_hdr.tiling.row_start_sb[f->lf.tile_row] == sby)
+            start_of_tile_row = f->lf.tile_row++;
+        bytefn(dav1d_loopfilter_sbrow)(f, f->lf.p, f->lf.mask_ptr, sby,
+                                       start_of_tile_row);
+    }
+
+    if (f->seq_hdr.restoration) {
+        // Store loop filtered pixels required by loop restoration
+        bytefn(dav1d_lr_copy_lpf)(f, f->lf.p, sby);
+    }
+    if (f->seq_hdr.cdef) {
+        if (sby) {
+            pixel *p_up[3] = {
+                f->lf.p[0] - 8 * PXSTRIDE(f->cur.p.stride[0]),
+                f->lf.p[1] - (8 * PXSTRIDE(f->cur.p.stride[1]) >> ss_ver),
+                f->lf.p[2] - (8 * PXSTRIDE(f->cur.p.stride[1]) >> ss_ver),
+            };
+            bytefn(dav1d_cdef_brow)(f, p_up, f->lf.prev_mask_ptr,
+                                    sby * sbsz - 2, sby * sbsz);
+        }
+        const int n_blks = sbsz - 2 * (sby + 1 < sbh);
+        bytefn(dav1d_cdef_brow)(f, f->lf.p, f->lf.mask_ptr, sby * sbsz,
+                                imin(sby * sbsz + n_blks, f->bh));
+    }
+    if (f->seq_hdr.restoration) {
+        bytefn(dav1d_lr_sbrow)(f, f->lf.p, sby);
+    }
+
+    f->lf.p[0] += sbsz * 4 * PXSTRIDE(f->cur.p.stride[0]);
+    f->lf.p[1] += sbsz * 4 * PXSTRIDE(f->cur.p.stride[1]) >> ss_ver;
+    f->lf.p[2] += sbsz * 4 * PXSTRIDE(f->cur.p.stride[1]) >> ss_ver;
+    f->lf.prev_mask_ptr = f->lf.mask_ptr;
+    if ((sby & 1) || f->seq_hdr.sb128) {
+        f->lf.mask_ptr += f->sb128w;
+    }
+}
+
+void bytefn(backup_ipred_edge)(Dav1dTileContext *const t) {
+    const Dav1dFrameContext *const f = t->f;
+    Dav1dTileState *const ts = t->ts;
+    const int ss_ver = f->cur.p.p.layout == DAV1D_PIXEL_LAYOUT_I420;
+    const int ss_hor = f->cur.p.p.layout != DAV1D_PIXEL_LAYOUT_I444;
+    const int sby = t->by >> f->sb_shift;
+    const int sby_off = f->sb128w * 128 * sby;
+    const int x_off = ts->tiling.col_start;
+
+    const pixel *const y =
+        ((const pixel *) f->cur.p.data[0]) + x_off * 4 +
+                    ((t->by + f->sb_step) * 4 - 1) * PXSTRIDE(f->cur.p.stride[0]);
+    pixel_copy(&f->ipred_edge[0][sby_off + x_off * 4], y,
+               4 * (ts->tiling.col_end - x_off));
+    const ptrdiff_t uv_off = (x_off * 4 >> ss_hor) +
+        (((t->by + f->sb_step) * 4 >> ss_ver) - 1) * PXSTRIDE(f->cur.p.stride[1]);
+    for (int pl = 1; pl <= 2; pl++)
+        pixel_copy(&f->ipred_edge[pl][sby_off + (x_off * 4 >> ss_hor)],
+                   &((const pixel *) f->cur.p.data[pl])[uv_off],
+                   4 * (ts->tiling.col_end - x_off) >> ss_hor);
+}
diff --git a/src/recon.h b/src/recon.h
new file mode 100644
index 0000000..73bc61c
--- /dev/null
+++ b/src/recon.h
@@ -0,0 +1,75 @@
+/*
+ * Copyright © 2018, VideoLAN and dav1d authors
+ * Copyright © 2018, Two Orioles, LLC
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright notice, this
+ *    list of conditions and the following disclaimer.
+ *
+ * 2. Redistributions in binary form must reproduce the above copyright notice,
+ *    this list of conditions and the following disclaimer in the documentation
+ *    and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
+ * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#ifndef __DAV1D_SRC_RECON_H__
+#define __DAV1D_SRC_RECON_H__
+
+#include "src/internal.h"
+#include "src/levels.h"
+
+#define DEBUG_BLOCK_INFO 0 && \
+        f->frame_hdr.frame_offset == 2 && t->by >= 0 && t->by < 4 && \
+        t->bx >= 8 && t->bx < 12
+#define DEBUG_B_PIXELS 0
+
+#define decl_recon_b_intra_fn(name) \
+void (name)(Dav1dTileContext *t, enum BlockSize bs, \
+            enum EdgeFlags intra_edge_flags, const Av1Block *b)
+typedef decl_recon_b_intra_fn(*recon_b_intra_fn);
+
+#define decl_recon_b_inter_fn(name) \
+void (name)(Dav1dTileContext *t, enum BlockSize bs, const Av1Block *b)
+typedef decl_recon_b_inter_fn(*recon_b_inter_fn);
+
+#define decl_filter_sbrow_fn(name) \
+void (name)(Dav1dFrameContext *f, int sby)
+typedef decl_filter_sbrow_fn(*filter_sbrow_fn);
+
+#define decl_backup_ipred_edge_fn(name) \
+void (name)(Dav1dTileContext *t)
+typedef decl_backup_ipred_edge_fn(*backup_ipred_edge_fn);
+
+#define decl_read_coef_blocks_fn(name) \
+void (name)(Dav1dTileContext *t, enum BlockSize bs, const Av1Block *b)
+typedef decl_read_coef_blocks_fn(*read_coef_blocks_fn);
+
+decl_recon_b_intra_fn(recon_b_intra_8bpc);
+decl_recon_b_intra_fn(recon_b_intra_16bpc);
+
+decl_recon_b_inter_fn(recon_b_inter_8bpc);
+decl_recon_b_inter_fn(recon_b_inter_16bpc);
+
+decl_filter_sbrow_fn(filter_sbrow_8bpc);
+decl_filter_sbrow_fn(filter_sbrow_16bpc);
+
+decl_backup_ipred_edge_fn(backup_ipred_edge_8bpc);
+decl_backup_ipred_edge_fn(backup_ipred_edge_16bpc);
+
+decl_read_coef_blocks_fn(read_coef_blocks_8bpc);
+decl_read_coef_blocks_fn(read_coef_blocks_16bpc);
+
+#endif /* __DAV1D_SRC_RECON_H__ */
diff --git a/src/ref.c b/src/ref.c
new file mode 100644
index 0000000..b0bf7ac
--- /dev/null
+++ b/src/ref.c
@@ -0,0 +1,60 @@
+/*
+ * Copyright © 2018, VideoLAN and dav1d authors
+ * Copyright © 2018, Two Orioles, LLC
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright notice, this
+ *    list of conditions and the following disclaimer.
+ *
+ * 2. Redistributions in binary form must reproduce the above copyright notice,
+ *    this list of conditions and the following disclaimer in the documentation
+ *    and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
+ * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#include "config.h"
+
+#include "common/mem.h"
+
+#include "src/ref.h"
+
+Dav1dRef *dav1d_ref_create(const size_t size) {
+    Dav1dRef *res = malloc(sizeof(Dav1dRef));
+    void *data = dav1d_alloc_aligned(size, 32);
+
+    if (!res || !data) {
+        if (res) free(res);
+        if (data) free(data);
+        return NULL;
+    }
+
+    res->size = size;
+    atomic_init(&res->ref_cnt, 1);
+    res->data = data;
+
+    return res;
+}
+
+void dav1d_ref_inc(Dav1dRef *const ref) {
+    atomic_fetch_add(&ref->ref_cnt, 1);
+}
+
+void dav1d_ref_dec(Dav1dRef *const ref) {
+    if (atomic_fetch_sub(&ref->ref_cnt, 1) == 1) {
+        dav1d_free_aligned(ref->data);
+        free(ref);
+    }
+}
diff --git a/src/ref.h b/src/ref.h
new file mode 100644
index 0000000..499966b
--- /dev/null
+++ b/src/ref.h
@@ -0,0 +1,46 @@
+/*
+ * Copyright © 2018, VideoLAN and dav1d authors
+ * Copyright © 2018, Two Orioles, LLC
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright notice, this
+ *    list of conditions and the following disclaimer.
+ *
+ * 2. Redistributions in binary form must reproduce the above copyright notice,
+ *    this list of conditions and the following disclaimer in the documentation
+ *    and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
+ * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#ifndef __DAV1D_SRC_REF_H__
+#define __DAV1D_SRC_REF_H__
+
+#include "dav1d/dav1d.h"
+
+#include <stdatomic.h>
+#include <stddef.h>
+
+struct Dav1dRef {
+    void *data;
+    size_t size;
+    atomic_int ref_cnt;
+};
+
+Dav1dRef *dav1d_ref_create(size_t size);
+void dav1d_ref_inc(Dav1dRef *ref);
+void dav1d_ref_dec(Dav1dRef *ref);
+
+#endif /* __DAV1D_SRC_REF_H__ */
diff --git a/src/ref_mvs.c b/src/ref_mvs.c
new file mode 100644
index 0000000..997c0af
--- /dev/null
+++ b/src/ref_mvs.c
@@ -0,0 +1,3550 @@
+/*
+ * Copyright (c) 2001-2016, Alliance for Open Media. All rights reserved
+ *
+ * This source code is subject to the terms of the BSD 2 Clause License and
+ * the Alliance for Open Media Patent License 1.0. If the BSD 2 Clause License
+ * was not distributed with this source code in the LICENSE file, you can
+ * obtain it at www.aomedia.org/license/software. If the Alliance for Open
+ * Media Patent License 1.0 was not distributed with this source code in the
+ * PATENTS file, you can obtain it at www.aomedia.org/license/patent.
+ */
+
+/*
+ * Changes made compared to libaom version:
+ * - we disable TMV and enable MV_COMPRESS so that the
+ *   input array for prev_frames can be at 4x4 instead of
+ *   8x8 resolution, and therefore shared between cur_frame
+ *   and prev_frame. To make enc/dec behave consistent, we
+ *   also make this change around line 2580:
+#if 0
+                AOMMIN(((mi_row >> 1) << 1) + 1 + (((xd->n8_h - 1) >> 1) << 1),
+                       mi_row_end - 1) *
+                    prev_frame_mvs_stride +
+                AOMMIN(((mi_col >> 1) << 1) + 1 + (((xd->n8_w - 1) >> 1) << 1),
+                       mi_col_end - 1)
+#else
+                (((mi_row >> 1) << 1) + 1) * prev_frame_mvs_stride +
+                (((mi_col >> 1) << 1) + 1)
+#endif
+ *   and the same change (swap mi_cols from prev_frame.mv_stride) on line 2407
+ * - we disable rect-block overhanging edge inclusion (see
+ *   line 2642):
+  if (num_8x8_blocks_wide == num_8x8_blocks_high || 1) {
+    mv_ref_search[5].row = -1;
+    mv_ref_search[5].col = 0;
+    mv_ref_search[6].row = 0;
+    mv_ref_search[6].col = -1;
+  } else {
+    mv_ref_search[5].row = -1;
+    mv_ref_search[5].col = num_8x8_blocks_wide;
+    mv_ref_search[6].row = num_8x8_blocks_high;
+    mv_ref_search[6].col = -1;
+  }
+ *   Note that this is a bitstream change and needs the same
+ *   change on the decoder side also.
+ * - we change xd->mi to be a pointer instead of a double ptr.
+ */
+
+#include "config.h"
+
+#include <assert.h>
+#include <limits.h>
+#include <stddef.h>
+#include <stdint.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include "common/intops.h"
+
+#define av1_zero(a) memset(a, 0, sizeof(a))
+
+#define ATTRIBUTE_PACKED
+#define INLINE inline
+#define IMPLIES(a, b) (!(a) || (b))  //  Logical 'a implies b' (or 'a -> b')
+
+#define ROUND_POWER_OF_TWO(value, n) (((value) + (((1 << (n)) >> 1))) >> (n))
+#define ROUND_POWER_OF_TWO_SIGNED(value, n)           \
+  (((value) < 0) ? -ROUND_POWER_OF_TWO(-(value), (n)) \
+                 : ROUND_POWER_OF_TWO((value), (n)))
+#define NELEMENTS(x) (int)(sizeof(x) / sizeof(x[0]))
+
+#define MAX_MV_REF_CANDIDATES 2
+
+#define MAX_REF_MV_STACK_SIZE 8
+#define REF_CAT_LEVEL 640
+
+#define FRAME_OFFSET_BITS 5
+#define MAX_FRAME_DISTANCE ((1 << FRAME_OFFSET_BITS) - 1)
+#define INVALID_MV 0x80008000
+
+#define COMP_NEWMV_CTXS 5
+#define REFMV_OFFSET 4
+#define REFMV_CTX_MASK ((1 << (8 - REFMV_OFFSET)) - 1)
+
+#define MV_IN_USE_BITS 14
+#define MV_UPP (1 << MV_IN_USE_BITS)
+#define MV_LOW (-(1 << MV_IN_USE_BITS))
+
+typedef struct MV {
+    int16_t row;
+    int16_t col;
+} MV;
+typedef union int_mv {
+    uint32_t as_int;
+    MV as_mv;
+} int_mv;
+typedef int8_t MV_REFERENCE_FRAME;
+#define MFMV_STACK_SIZE 3
+typedef struct {
+  int_mv mfmv0;
+  uint8_t ref_frame_offset;
+} TPL_MV_REF;
+typedef struct {
+    int_mv mv[2];
+    MV_REFERENCE_FRAME ref_frame[2];
+    int8_t mode, sb_type;
+} MV_REF;
+#define MB_MODE_INFO MV_REF
+
+#define AOMMAX(a,b) ((a)>(b)?(a):(b))
+#define AOMMIN(a,b) ((a)<(b)?(a):(b))
+
+typedef struct candidate_mv {
+    int_mv this_mv;
+    int_mv comp_mv;
+    int weight;
+} CANDIDATE_MV;
+#define NONE_FRAME -1
+#define INTRA_FRAME 0
+#define LAST_FRAME 1
+
+#define LAST2_FRAME 2
+#define LAST3_FRAME 3
+#define GOLDEN_FRAME 4
+#define BWDREF_FRAME 5
+#define ALTREF2_FRAME 6
+#define ALTREF_FRAME 7
+#define LAST_REF_FRAMES (LAST3_FRAME - LAST_FRAME + 1)
+
+#define INTER_REFS_PER_FRAME (ALTREF_FRAME - LAST_FRAME + 1)
+#define TOTAL_REFS_PER_FRAME (ALTREF_FRAME - INTRA_FRAME + 1)
+
+#define FWD_REFS (GOLDEN_FRAME - LAST_FRAME + 1)
+#define FWD_RF_OFFSET(ref) (ref - LAST_FRAME)
+#define BWD_REFS (ALTREF_FRAME - BWDREF_FRAME + 1)
+#define BWD_RF_OFFSET(ref) (ref - BWDREF_FRAME)
+#define FWD_REFS (GOLDEN_FRAME - LAST_FRAME + 1)
+#define SINGLE_REFS (FWD_REFS + BWD_REFS)
+typedef enum ATTRIBUTE_PACKED {
+  LAST_LAST2_FRAMES,      // { LAST_FRAME, LAST2_FRAME }
+  LAST_LAST3_FRAMES,      // { LAST_FRAME, LAST3_FRAME }
+  LAST_GOLDEN_FRAMES,     // { LAST_FRAME, GOLDEN_FRAME }
+  BWDREF_ALTREF_FRAMES,   // { BWDREF_FRAME, ALTREF_FRAME }
+  LAST2_LAST3_FRAMES,     // { LAST2_FRAME, LAST3_FRAME }
+  LAST2_GOLDEN_FRAMES,    // { LAST2_FRAME, GOLDEN_FRAME }
+  LAST3_GOLDEN_FRAMES,    // { LAST3_FRAME, GOLDEN_FRAME }
+  BWDREF_ALTREF2_FRAMES,  // { BWDREF_FRAME, ALTREF2_FRAME }
+  ALTREF2_ALTREF_FRAMES,  // { ALTREF2_FRAME, ALTREF_FRAME }
+  TOTAL_UNIDIR_COMP_REFS,
+  // NOTE: UNIDIR_COMP_REFS is the number of uni-directional reference pairs
+  //       that are explicitly signaled.
+  UNIDIR_COMP_REFS = BWDREF_ALTREF_FRAMES + 1,
+} UNIDIR_COMP_REF;
+#define TOTAL_COMP_REFS (FWD_REFS * BWD_REFS + TOTAL_UNIDIR_COMP_REFS)
+#define MODE_CTX_REF_FRAMES (TOTAL_REFS_PER_FRAME + TOTAL_COMP_REFS)
+
+#define GLOBALMV_OFFSET 3
+#define NEWMV_CTX_MASK ((1 << GLOBALMV_OFFSET) - 1)
+#define GLOBALMV_CTX_MASK ((1 << (REFMV_OFFSET - GLOBALMV_OFFSET)) - 1)
+#define MI_SIZE_LOG2 2
+#define MI_SIZE (1 << MI_SIZE_LOG2)
+#define MAX_SB_SIZE_LOG2 7
+#define MAX_MIB_SIZE_LOG2 (MAX_SB_SIZE_LOG2 - MI_SIZE_LOG2)
+#define MIN_MIB_SIZE_LOG2 (MIN_SB_SIZE_LOG2 - MI_SIZE_LOG2)
+#define MAX_MIB_SIZE (1 << MAX_MIB_SIZE_LOG2)
+#define MI_SIZE_64X64 (64 >> MI_SIZE_LOG2)
+#define MI_SIZE_128X128 (128 >> MI_SIZE_LOG2)
+#define REFMV_OFFSET 4
+
+typedef enum ATTRIBUTE_PACKED {
+  BLOCK_4X4,
+  BLOCK_4X8,
+  BLOCK_8X4,
+  BLOCK_8X8,
+  BLOCK_8X16,
+  BLOCK_16X8,
+  BLOCK_16X16,
+  BLOCK_16X32,
+  BLOCK_32X16,
+  BLOCK_32X32,
+  BLOCK_32X64,
+  BLOCK_64X32,
+  BLOCK_64X64,
+  BLOCK_64X128,
+  BLOCK_128X64,
+  BLOCK_128X128,
+  BLOCK_4X16,
+  BLOCK_16X4,
+  BLOCK_8X32,
+  BLOCK_32X8,
+  BLOCK_16X64,
+  BLOCK_64X16,
+  BLOCK_32X128,
+  BLOCK_128X32,
+  BLOCK_SIZES_ALL,
+  BLOCK_SIZES = BLOCK_4X16,
+  BLOCK_INVALID = 255,
+  BLOCK_LARGEST = (BLOCK_SIZES - 1)
+} BLOCK_SIZE;
+
+typedef enum ATTRIBUTE_PACKED {
+  PARTITION_NONE,
+  PARTITION_HORZ,
+  PARTITION_VERT,
+  PARTITION_SPLIT,
+  PARTITION_HORZ_A,  // HORZ split and the top partition is split again
+  PARTITION_HORZ_B,  // HORZ split and the bottom partition is split again
+  PARTITION_VERT_A,  // VERT split and the left partition is split again
+  PARTITION_VERT_B,  // VERT split and the right partition is split again
+  PARTITION_HORZ_4,  // 4:1 horizontal partition
+  PARTITION_VERT_4,  // 4:1 vertical partition
+  EXT_PARTITION_TYPES,
+  PARTITION_TYPES = PARTITION_SPLIT + 1,
+  PARTITION_INVALID = 255
+} PARTITION_TYPE;
+typedef struct CUR_MODE_INFO {
+  PARTITION_TYPE partition;
+} CUR_MODE_INFO ;
+
+typedef enum ATTRIBUTE_PACKED {
+  DC_PRED,        // Average of above and left pixels
+  V_PRED,         // Vertical
+  H_PRED,         // Horizontal
+  D45_PRED,       // Directional 45  deg = round(arctan(1/1) * 180/pi)
+  D135_PRED,      // Directional 135 deg = 180 - 45
+  D117_PRED,      // Directional 117 deg = 180 - 63
+  D153_PRED,      // Directional 153 deg = 180 - 27
+  D207_PRED,      // Directional 207 deg = 180 + 27
+  D63_PRED,       // Directional 63  deg = round(arctan(2/1) * 180/pi)
+  SMOOTH_PRED,    // Combination of horizontal and vertical interpolation
+  SMOOTH_V_PRED,  // Vertical interpolation
+  SMOOTH_H_PRED,  // Horizontal interpolation
+  PAETH_PRED,     // Predict from the direction of smallest gradient
+  NEARESTMV,
+  NEARMV,
+  GLOBALMV,
+  NEWMV,
+  // Compound ref compound modes
+  NEAREST_NEARESTMV,
+  NEAR_NEARMV,
+  NEAREST_NEWMV,
+  NEW_NEARESTMV,
+  NEAR_NEWMV,
+  NEW_NEARMV,
+  GLOBAL_GLOBALMV,
+  NEW_NEWMV,
+  MB_MODE_COUNT,
+  INTRA_MODES = PAETH_PRED + 1,  // PAETH_PRED has to be the last intra mode.
+  INTRA_INVALID = MB_MODE_COUNT  // For uv_mode in inter blocks
+} PREDICTION_MODE;
+typedef enum {
+  IDENTITY = 0,      // identity transformation, 0-parameter
+  TRANSLATION = 1,   // translational motion 2-parameter
+  ROTZOOM = 2,       // simplified affine with rotation + zoom only, 4-parameter
+  AFFINE = 3,        // affine, 6-parameter
+  TRANS_TYPES,
+} TransformationType;
+#if 0
+typedef enum {
+  KEY_FRAME = 0,
+  INTER_FRAME = 1,
+#if CONFIG_OBU
+  INTRA_ONLY_FRAME = 2,  // replaces intra-only
+  S_FRAME = 3,
+#endif
+  FRAME_TYPES,
+} FRAME_TYPE;
+#endif
+
+#define LEAST_SQUARES_SAMPLES_MAX_BITS 3
+#define LEAST_SQUARES_SAMPLES_MAX (1 << LEAST_SQUARES_SAMPLES_MAX_BITS)
+#define SAMPLES_ARRAY_SIZE (LEAST_SQUARES_SAMPLES_MAX * 2)
+
+static const uint8_t mi_size_wide[BLOCK_SIZES_ALL] = {
+  1, 1, 2, 2, 2, 4, 4, 4, 8, 8, 8, 16, 16,
+  16, 32, 32,  1, 4, 2, 8, 4, 16, 8, 32
+};
+static const uint8_t mi_size_high[BLOCK_SIZES_ALL] = {
+  1, 2, 1, 2, 4, 2, 4, 8, 4, 8, 16, 8, 16,
+  32, 16, 32,  4, 1, 8, 2, 16, 4, 32, 8
+};
+
+static const uint8_t block_size_wide[BLOCK_SIZES_ALL] = {
+  4,  4,
+  8,  8,
+  8,  16,
+  16, 16,
+  32, 32,
+  32, 64,
+  64, 64, 128, 128, 4,
+  16, 8,
+  32, 16,
+  64, 32, 128
+};
+
+static const uint8_t block_size_high[BLOCK_SIZES_ALL] = {
+  4,  8,
+  4,  8,
+  16, 8,
+  16, 32,
+  16, 32,
+  64, 32,
+  64, 128, 64, 128, 16,
+  4,  32,
+  8,  64,
+  16, 128, 32
+};
+
+static const uint8_t num_8x8_blocks_wide_lookup[BLOCK_SIZES_ALL] = {
+  1, 1,
+  1, 1,
+  1, 2,
+  2, 2,
+  4, 4,
+  4, 8,
+  8, 8, 16, 16, 1,
+  2, 1,
+  4, 2,
+  8, 4, 16
+};
+static const uint8_t num_8x8_blocks_high_lookup[BLOCK_SIZES_ALL] = {
+  1, 1,
+  1, 1,
+  2, 1,
+  2, 4,
+  2, 4,
+  8, 4,
+  8, 16, 8, 16, 2,
+  1, 4,
+  1, 8,
+  2, 16, 4
+};
+
+static INLINE int is_global_mv_block(const MB_MODE_INFO *const mbmi,
+                                     TransformationType type) {
+  const PREDICTION_MODE mode = mbmi->mode;
+  const BLOCK_SIZE bsize = mbmi->sb_type;
+  const int block_size_allowed =
+      AOMMIN(block_size_wide[bsize], block_size_high[bsize]) >= 8;
+  return (mode == GLOBALMV || mode == GLOBAL_GLOBALMV) && type > TRANSLATION &&
+         block_size_allowed;
+}
+
+typedef struct {
+  TransformationType wmtype;
+  int32_t wmmat[6];
+  int16_t alpha, beta, gamma, delta;
+} WarpedMotionParams;
+
+#define WARPEDMODEL_PREC_BITS 16
+static const WarpedMotionParams default_warp_params = {
+  IDENTITY,
+  { 0, 0, (1 << WARPEDMODEL_PREC_BITS), 0, 0, (1 << WARPEDMODEL_PREC_BITS) },
+  0, 0, 0, 0,
+};
+
+#define REF_FRAMES_LOG2 3
+#define REF_FRAMES (1 << REF_FRAMES_LOG2)
+#define FRAME_BUFFERS (REF_FRAMES + 7)
+typedef struct {
+#if 0
+  int ref_count;
+#endif
+
+  unsigned int cur_frame_offset;
+  unsigned int ref_frame_offset[INTER_REFS_PER_FRAME];
+
+  MV_REF *mvs;
+  ptrdiff_t mv_stride;
+#if 0
+#if CONFIG_SEGMENT_PRED_LAST
+  uint8_t *seg_map;
+#endif
+#endif
+  int mi_rows;
+  int mi_cols;
+#if 0
+  // Width and height give the size of the buffer (before any upscaling, unlike
+  // the sizes that can be derived from the buf structure)
+  int width;
+  int height;
+  WarpedMotionParams global_motion[TOTAL_REFS_PER_FRAME];
+#if CONFIG_FILM_GRAIN_SHOWEX
+  int showable_frame;  // frame can be used as show existing frame in future
+#endif
+#if CONFIG_FILM_GRAIN
+  int film_grain_params_present;
+  aom_film_grain_t film_grain_params;
+#endif
+  aom_codec_frame_buffer_t raw_frame_buffer;
+  YV12_BUFFER_CONFIG buf;
+#if CONFIG_HASH_ME
+  hash_table hash_table;
+#endif
+#endif
+  uint8_t intra_only;
+#if 0
+  FRAME_TYPE frame_type;
+  // The Following variables will only be used in frame parallel decode.
+
+  // frame_worker_owner indicates which FrameWorker owns this buffer. NULL means
+  // that no FrameWorker owns, or is decoding, this buffer.
+  AVxWorker *frame_worker_owner;
+
+  // row and col indicate which position frame has been decoded to in real
+  // pixel unit. They are reset to -1 when decoding begins and set to INT_MAX
+  // when the frame is fully decoded.
+  int row;
+  int col;
+#endif
+} RefCntBuffer;
+
+#define INVALID_IDX -1  // Invalid buffer index.
+typedef struct TileInfo {
+  int mi_row_start, mi_row_end;
+  int mi_col_start, mi_col_end;
+  int tg_horz_boundary;
+} TileInfo;
+typedef struct macroblockd {
+#if 0
+  struct macroblockd_plane plane[MAX_MB_PLANE];
+  uint8_t bmode_blocks_wl;
+  uint8_t bmode_blocks_hl;
+
+  FRAME_COUNTS *counts;
+#endif
+  TileInfo tile;
+  int mi_stride;
+
+  CUR_MODE_INFO cur_mi;
+  MB_MODE_INFO *mi;
+#if 0
+  MODE_INFO *left_mi;
+  MODE_INFO *above_mi;
+  MB_MODE_INFO *left_mbmi;
+  MB_MODE_INFO *above_mbmi;
+  MB_MODE_INFO *chroma_left_mbmi;
+  MB_MODE_INFO *chroma_above_mbmi;
+#endif
+  int up_available;
+  int left_available;
+#if 0
+  int chroma_up_available;
+  int chroma_left_available;
+#endif
+  /* Distance of MB away from frame edges in subpixels (1/8th pixel)  */
+  int mb_to_left_edge;
+  int mb_to_right_edge;
+  int mb_to_top_edge;
+  int mb_to_bottom_edge;
+#if 0
+  FRAME_CONTEXT *fc;
+
+  /* pointers to reference frames */
+  const RefBuffer *block_refs[2];
+
+  /* pointer to current frame */
+  const YV12_BUFFER_CONFIG *cur_buf;
+
+  ENTROPY_CONTEXT *above_context[MAX_MB_PLANE];
+  ENTROPY_CONTEXT left_context[MAX_MB_PLANE][2 * MAX_MIB_SIZE];
+
+  PARTITION_CONTEXT *above_seg_context;
+  PARTITION_CONTEXT left_seg_context[MAX_MIB_SIZE];
+
+  TXFM_CONTEXT *above_txfm_context;
+  TXFM_CONTEXT *left_txfm_context;
+  TXFM_CONTEXT left_txfm_context_buffer[2 * MAX_MIB_SIZE];
+
+#if CONFIG_LOOP_RESTORATION
+  WienerInfo wiener_info[MAX_MB_PLANE];
+  SgrprojInfo sgrproj_info[MAX_MB_PLANE];
+#endif  // CONFIG_LOOP_RESTORATION
+#endif
+  // block dimension in the unit of mode_info.
+  uint8_t n8_w, n8_h;
+#if 0
+  uint8_t ref_mv_count[MODE_CTX_REF_FRAMES];
+  CANDIDATE_MV ref_mv_stack[MODE_CTX_REF_FRAMES][MAX_REF_MV_STACK_SIZE];
+#endif
+  uint8_t is_sec_rect;
+
+#if 0
+  // Counts of each reference frame in the above and left neighboring blocks.
+  // NOTE: Take into account both single and comp references.
+  uint8_t neighbors_ref_counts[TOTAL_REFS_PER_FRAME];
+
+  FRAME_CONTEXT *tile_ctx;
+  /* Bit depth: 8, 10, 12 */
+  int bd;
+
+  int qindex[MAX_SEGMENTS];
+  int lossless[MAX_SEGMENTS];
+  int corrupted;
+  int cur_frame_force_integer_mv;
+// same with that in AV1_COMMON
+  struct aom_internal_error_info *error_info;
+  const WarpedMotionParams *global_motion;
+  int prev_qindex;
+  int delta_qindex;
+  int current_qindex;
+#if CONFIG_EXT_DELTA_Q
+  // Since actual frame level loop filtering level value is not available
+  // at the beginning of the tile (only available during actual filtering)
+  // at encoder side.we record the delta_lf (against the frame level loop
+  // filtering level) and code the delta between previous superblock's delta
+  // lf and current delta lf. It is equivalent to the delta between previous
+  // superblock's actual lf and current lf.
+  int prev_delta_lf_from_base;
+  int current_delta_lf_from_base;
+  // For this experiment, we have four frame filter levels for different plane
+  // and direction. So, to support the per superblock update, we need to add
+  // a few more params as below.
+  // 0: delta loop filter level for y plane vertical
+  // 1: delta loop filter level for y plane horizontal
+  // 2: delta loop filter level for u plane
+  // 3: delta loop filter level for v plane
+  // To make it consistent with the reference to each filter level in segment,
+  // we need to -1, since
+  // SEG_LVL_ALT_LF_Y_V = 1;
+  // SEG_LVL_ALT_LF_Y_H = 2;
+  // SEG_LVL_ALT_LF_U   = 3;
+  // SEG_LVL_ALT_LF_V   = 4;
+  int prev_delta_lf[FRAME_LF_COUNT];
+  int curr_delta_lf[FRAME_LF_COUNT];
+#endif
+
+  DECLARE_ALIGNED(16, uint8_t, seg_mask[2 * MAX_SB_SQUARE]);
+
+  CFL_CTX cfl;
+
+  JNT_COMP_PARAMS jcp_param;
+
+  int all_one_sided_refs;
+#endif
+} MACROBLOCKD;
+typedef struct RefBuffer {
+  int idx;  // frame buf idx
+#if 0
+  int map_idx;  // frame map idx
+  YV12_BUFFER_CONFIG *buf;
+  struct scale_factors sf;
+#endif
+} RefBuffer;
+typedef struct BufferPool {
+#if 0
+// Protect BufferPool from being accessed by several FrameWorkers at
+// the same time during frame parallel decode.
+// TODO(hkuang): Try to use atomic variable instead of locking the whole pool.
+#if CONFIG_MULTITHREAD
+  pthread_mutex_t pool_mutex;
+#endif
+
+  // Private data associated with the frame buffer callbacks.
+  void *cb_priv;
+
+  aom_get_frame_buffer_cb_fn_t get_fb_cb;
+  aom_release_frame_buffer_cb_fn_t release_fb_cb;
+#endif
+  RefCntBuffer frame_bufs[FRAME_BUFFERS];
+#if 0
+  // Frame buffers allocated internally by the codec.
+  InternalFrameBufferList int_frame_buffers;
+#endif
+} BufferPool;
+typedef struct AV1Common {
+#if 0
+  struct aom_internal_error_info error;
+  aom_color_primaries_t color_primaries;
+  aom_transfer_characteristics_t transfer_characteristics;
+  aom_matrix_coefficients_t matrix_coefficients;
+  int color_range;
+  int width;
+  int height;
+  int render_width;
+  int render_height;
+  int last_width;
+  int last_height;
+  int timing_info_present;
+  uint32_t num_units_in_tick;
+  uint32_t time_scale;
+  int equal_picture_interval;
+  uint32_t num_ticks_per_picture;
+
+  // TODO(jkoleszar): this implies chroma ss right now, but could vary per
+  // plane. Revisit as part of the future change to YV12_BUFFER_CONFIG to
+  // support additional planes.
+  int subsampling_x;
+  int subsampling_y;
+
+  int largest_tile_id;
+  size_t largest_tile_size;
+
+  // Scale of the current frame with respect to itself.
+  struct scale_factors sf_identity;
+
+  // Marks if we need to use 16bit frame buffers (1: yes, 0: no).
+  int use_highbitdepth;
+  YV12_BUFFER_CONFIG *frame_to_show;
+#endif
+
+  // TODO(hkuang): Combine this with cur_buf in macroblockd.
+  RefCntBuffer cur_frame;
+#if 0
+  int ref_frame_map[REF_FRAMES]; /* maps fb_idx to reference slot */
+
+  // Prepare ref_frame_map for the next frame.
+  // Only used in frame parallel decode.
+  int next_ref_frame_map[REF_FRAMES];
+
+  // TODO(jkoleszar): could expand active_ref_idx to 4, with 0 as intra, and
+  // roll new_fb_idx into it.
+#endif
+
+  // Each Inter frame can reference INTER_REFS_PER_FRAME buffers
+  RefBuffer frame_refs[INTER_REFS_PER_FRAME];
+
+#if 0
+  int is_skip_mode_allowed;
+  int skip_mode_flag;
+  int ref_frame_idx_0;
+  int ref_frame_idx_1;
+
+  int new_fb_idx;
+
+  FRAME_TYPE last_frame_type; /* last frame's frame type for motion search.*/
+  FRAME_TYPE frame_type;
+
+  int show_frame;
+#if CONFIG_FILM_GRAIN_SHOWEX
+  int showable_frame;  // frame can be used as show existing frame in future
+#endif
+  int last_show_frame;
+  int show_existing_frame;
+  // Flag for a frame used as a reference - not written to the bitstream
+  int is_reference_frame;
+
+#if CONFIG_FWD_KF
+  int reset_decoder_state;
+#endif  // CONFIG_FWD_KF
+
+  // Flag signaling that the frame is encoded using only INTRA modes.
+  uint8_t intra_only;
+  uint8_t last_intra_only;
+
+#if CONFIG_CDF_UPDATE_MODE
+  uint8_t disable_cdf_update;
+#endif  // CONFIG_CDF_UPDATE_MODE
+#endif
+  int allow_high_precision_mv;
+  int cur_frame_force_integer_mv;  // 0 the default in AOM, 1 only integer
+#if 0
+  int disable_intra_edge_filter;  // 1 - disable corner/edge/upsampling
+  int allow_screen_content_tools;
+  int allow_intrabc;
+  int allow_interintra_compound;
+  int allow_masked_compound;
+
+#if !CONFIG_NO_FRAME_CONTEXT_SIGNALING
+  // Flag signaling which frame contexts should be reset to default values.
+  RESET_FRAME_CONTEXT_MODE reset_frame_context;
+#endif
+
+  // MBs, mb_rows/cols is in 16-pixel units; mi_rows/cols is in
+  // MODE_INFO (8-pixel) units.
+  int MBs;
+  int mb_rows, mi_rows;
+  int mb_cols, mi_cols;
+#endif
+  int mi_rows;
+  int mi_cols;
+  int mi_stride;
+
+#if 0
+  /* profile settings */
+  TX_MODE tx_mode;
+
+  int base_qindex;
+  int y_dc_delta_q;
+  int u_dc_delta_q;
+  int v_dc_delta_q;
+  int u_ac_delta_q;
+  int v_ac_delta_q;
+
+  int separate_uv_delta_q;
+
+  // The dequantizers below are true dequntizers used only in the
+  // dequantization process.  They have the same coefficient
+  // shift/scale as TX.
+  int16_t y_dequant_QTX[MAX_SEGMENTS][2];
+  int16_t u_dequant_QTX[MAX_SEGMENTS][2];
+  int16_t v_dequant_QTX[MAX_SEGMENTS][2];
+
+  // Global quant matrix tables
+  const qm_val_t *giqmatrix[NUM_QM_LEVELS][3][TX_SIZES_ALL];
+  const qm_val_t *gqmatrix[NUM_QM_LEVELS][3][TX_SIZES_ALL];
+
+  // Local quant matrix tables for each frame
+  const qm_val_t *y_iqmatrix[MAX_SEGMENTS][TX_SIZES_ALL];
+  const qm_val_t *u_iqmatrix[MAX_SEGMENTS][TX_SIZES_ALL];
+  const qm_val_t *v_iqmatrix[MAX_SEGMENTS][TX_SIZES_ALL];
+
+  // Encoder
+  int using_qmatrix;
+#if CONFIG_AOM_QM_EXT
+  int qm_y;
+  int qm_u;
+  int qm_v;
+#endif  // CONFIG_AOM_QM_EXT
+  int min_qmlevel;
+  int max_qmlevel;
+
+  /* We allocate a MODE_INFO struct for each macroblock, together with
+     an extra row on top and column on the left to simplify prediction. */
+  int mi_alloc_size;
+  MODE_INFO *mip; /* Base of allocated array */
+  MODE_INFO *mi;  /* Corresponds to upper left visible macroblock */
+
+  // TODO(agrange): Move prev_mi into encoder structure.
+  // prev_mip and prev_mi will only be allocated in encoder.
+  MODE_INFO *prev_mip; /* MODE_INFO array 'mip' from last decoded frame */
+  MODE_INFO *prev_mi;  /* 'mi' from last frame (points into prev_mip) */
+
+  // Separate mi functions between encoder and decoder.
+  int (*alloc_mi)(struct AV1Common *cm, int mi_size);
+  void (*free_mi)(struct AV1Common *cm);
+  void (*setup_mi)(struct AV1Common *cm);
+
+  // Grid of pointers to 8x8 MODE_INFO structs.  Any 8x8 not in the visible
+  // area will be NULL.
+  MODE_INFO **mi_grid_base;
+  MODE_INFO **mi_grid_visible;
+  MODE_INFO **prev_mi_grid_base;
+  MODE_INFO **prev_mi_grid_visible;
+#endif
+  // Whether to use previous frame's motion vectors for prediction.
+  int allow_ref_frame_mvs;
+
+#if 0
+#if !CONFIG_SEGMENT_PRED_LAST
+  // Persistent mb segment id map used in prediction.
+  int seg_map_idx;
+  int prev_seg_map_idx;
+
+  uint8_t *seg_map_array[NUM_PING_PONG_BUFFERS];
+#endif
+  uint8_t *last_frame_seg_map;
+  uint8_t *current_frame_seg_map;
+  int seg_map_alloc_size;
+
+  InterpFilter interp_filter;
+
+  int switchable_motion_mode;
+
+  loop_filter_info_n lf_info;
+  // The denominator of the superres scale; the numerator is fixed.
+  uint8_t superres_scale_denominator;
+  int superres_upscaled_width;
+  int superres_upscaled_height;
+  RestorationInfo rst_info[MAX_MB_PLANE];
+
+  // rst_end_stripe[i] is one more than the index of the bottom stripe
+  // for tile row i.
+  int rst_end_stripe[MAX_TILE_ROWS];
+
+  // Pointer to a scratch buffer used by self-guided restoration
+  int32_t *rst_tmpbuf;
+
+  // Flag signaling how frame contexts should be updated at the end of
+  // a frame decode
+  REFRESH_FRAME_CONTEXT_MODE refresh_frame_context;
+#endif
+  int ref_frame_sign_bias[TOTAL_REFS_PER_FRAME]; /* Two state 0, 1 */
+#if 0
+  struct loopfilter lf;
+  struct segmentation seg;
+  int all_lossless;
+#endif
+  int frame_parallel_decode;  // frame-based threading.
+#if 0
+  int reduced_tx_set_used;
+
+  // Context probabilities for reference frame prediction
+  MV_REFERENCE_FRAME comp_fwd_ref[FWD_REFS];
+  MV_REFERENCE_FRAME comp_bwd_ref[BWD_REFS];
+  REFERENCE_MODE reference_mode;
+
+  FRAME_CONTEXT *fc;              /* this frame entropy */
+  FRAME_CONTEXT *frame_contexts;  // FRAME_CONTEXTS
+  FRAME_CONTEXT *pre_fc;          // Context referenced in this frame
+  unsigned int frame_context_idx; /* Context to use/update */
+#if CONFIG_NO_FRAME_CONTEXT_SIGNALING
+  int fb_of_context_type[REF_FRAMES];
+  int primary_ref_frame;
+#endif
+  FRAME_COUNTS counts;
+#endif
+
+  unsigned int frame_offset;
+
+#if 0
+  unsigned int current_video_frame;
+  BITSTREAM_PROFILE profile;
+
+  // AOM_BITS_8 in profile 0 or 1, AOM_BITS_10 or AOM_BITS_12 in profile 2 or 3.
+  aom_bit_depth_t bit_depth;
+  aom_bit_depth_t dequant_bit_depth;  // bit_depth of current dequantizer
+
+  int error_resilient_mode;
+
+  int tile_cols, tile_rows;
+  int last_tile_cols, last_tile_rows;
+
+  BOUNDARY_TYPE *boundary_info;
+  int boundary_info_alloc_size;
+
+#if CONFIG_MAX_TILE
+  int min_log2_tile_cols;
+  int max_log2_tile_cols;
+  int max_log2_tile_rows;
+  int min_log2_tile_rows;
+  int min_log2_tiles;
+  int max_tile_width_sb;
+  int max_tile_height_sb;
+  int uniform_tile_spacing_flag;
+  int log2_tile_cols;                        // only valid for uniform tiles
+  int log2_tile_rows;                        // only valid for uniform tiles
+  int tile_col_start_sb[MAX_TILE_COLS + 1];  // valid for 0 <= i <= tile_cols
+  int tile_row_start_sb[MAX_TILE_ROWS + 1];  // valid for 0 <= i <= tile_rows
+#if CONFIG_DEPENDENT_HORZTILES
+  int tile_row_independent[MAX_TILE_ROWS];  // valid for 0 <= i <  tile_rows
+#endif
+  int tile_width, tile_height;  // In MI units
+#else
+  int log2_tile_cols, log2_tile_rows;  // Used in non-large_scale_tile_coding.
+  int tile_width, tile_height;         // In MI units
+#endif  // CONFIG_MAX_TILE
+
+#if CONFIG_EXT_TILE
+  unsigned int large_scale_tile;
+  unsigned int single_tile_decoding;
+#endif  // CONFIG_EXT_TILE
+
+#if CONFIG_DEPENDENT_HORZTILES
+  int dependent_horz_tiles;
+  int tile_group_start_row[MAX_TILE_ROWS][MAX_TILE_COLS];
+  int tile_group_start_col[MAX_TILE_ROWS][MAX_TILE_COLS];
+#endif
+#if CONFIG_LOOPFILTERING_ACROSS_TILES
+#if CONFIG_LOOPFILTERING_ACROSS_TILES_EXT
+  int loop_filter_across_tiles_v_enabled;
+  int loop_filter_across_tiles_h_enabled;
+#else
+  int loop_filter_across_tiles_enabled;
+#endif  // CONFIG_LOOPFILTERING_ACROSS_TILES_EXT
+#endif  // CONFIG_LOOPFILTERING_ACROSS_TILES
+
+  int byte_alignment;
+  int skip_loop_filter;
+
+  // Private data associated with the frame buffer callbacks.
+  void *cb_priv;
+  aom_get_frame_buffer_cb_fn_t get_fb_cb;
+  aom_release_frame_buffer_cb_fn_t release_fb_cb;
+
+  // Handles memory for the codec.
+  InternalFrameBufferList int_frame_buffers;
+#endif
+  // External BufferPool passed from outside.
+  BufferPool buffer_pool;
+#if 0
+  PARTITION_CONTEXT *above_seg_context;
+  ENTROPY_CONTEXT *above_context[MAX_MB_PLANE];
+  TXFM_CONTEXT *above_txfm_context;
+  TXFM_CONTEXT *top_txfm_context[MAX_MB_PLANE];
+  TXFM_CONTEXT left_txfm_context[MAX_MB_PLANE][2 * MAX_MIB_SIZE];
+  int above_context_alloc_cols;
+#endif
+
+  WarpedMotionParams global_motion[TOTAL_REFS_PER_FRAME];
+#if 0
+#if CONFIG_FILM_GRAIN
+  int film_grain_params_present;
+  aom_film_grain_t film_grain_params;
+#endif
+  int cdef_pri_damping;
+  int cdef_sec_damping;
+  int nb_cdef_strengths;
+  int cdef_strengths[CDEF_MAX_STRENGTHS];
+  int cdef_uv_strengths[CDEF_MAX_STRENGTHS];
+  int cdef_bits;
+  int cdef_preset[4];
+
+  int delta_q_present_flag;
+  // Resolution of delta quant
+  int delta_q_res;
+#if CONFIG_EXT_DELTA_Q
+  int delta_lf_present_flag;
+  // Resolution of delta lf level
+  int delta_lf_res;
+  // This is a flag for number of deltas of loop filter level
+  // 0: use 1 delta, for y_vertical, y_horizontal, u, and v
+  // 1: use separate deltas for each filter level
+  int delta_lf_multi;
+#endif
+  int num_tg;
+#endif
+  struct {
+    BLOCK_SIZE sb_size;
+    int enable_order_hint;
+    int order_hint_bits_minus1;
+  } seq_params;
+#if 0
+  SequenceHeader seq_params;
+  int current_frame_id;
+  int ref_frame_id[REF_FRAMES];
+  int valid_for_referencing[REF_FRAMES];
+  int refresh_mask;
+  int invalid_delta_frame_id_minus1;
+  LV_MAP_CTX_TABLE coeff_ctx_table;
+#endif
+  TPL_MV_REF *tpl_mvs;
+#if 0
+  int tpl_mvs_mem_size;
+#endif
+  // TODO(jingning): This can be combined with sign_bias later.
+  int8_t ref_frame_side[TOTAL_REFS_PER_FRAME];
+
+#if 0
+  int frame_refs_short_signaling;
+
+#if CONFIG_SCALABILITY
+  int temporal_layer_id;
+  int enhancement_layer_id;
+  int enhancement_layers_cnt;
+#endif
+#if TXCOEFF_TIMER
+  int64_t cum_txcoeff_timer;
+  int64_t txcoeff_timer;
+  int txb_count;
+#endif
+
+#if TXCOEFF_COST_TIMER
+  int64_t cum_txcoeff_cost_timer;
+  int64_t txcoeff_cost_timer;
+  int64_t txcoeff_cost_count;
+#endif
+  const cfg_options_t *options;
+#endif
+
+    int ref_buf_idx[INTER_REFS_PER_FRAME];
+    int ref_order_hint[INTER_REFS_PER_FRAME];
+} AV1_COMMON;
+
+static INLINE void integer_mv_precision(MV *mv) {
+  int mod = (mv->row % 8);
+  if (mod != 0) {
+    mv->row -= mod;
+    if (abs(mod) > 4) {
+      if (mod > 0) {
+        mv->row += 8;
+      } else {
+        mv->row -= 8;
+      }
+    }
+  }
+
+  mod = (mv->col % 8);
+  if (mod != 0) {
+    mv->col -= mod;
+    if (abs(mod) > 4) {
+      if (mod > 0) {
+        mv->col += 8;
+      } else {
+        mv->col -= 8;
+      }
+    }
+  }
+}
+
+static INLINE int clamp(int value, int low, int high) {
+  return value < low ? low : (value > high ? high : value);
+}
+
+static INLINE void clamp_mv(MV *mv, int min_col, int max_col, int min_row,
+                            int max_row) {
+  mv->col = clamp(mv->col, min_col, max_col);
+  mv->row = clamp(mv->row, min_row, max_row);
+}
+
+#if 0
+static INLINE int frame_is_intra_only(const AV1_COMMON *const cm) {
+  return cm->frame_type == KEY_FRAME || cm->intra_only;
+}
+#endif
+
+static INLINE int is_intrabc_block(const MB_MODE_INFO *mbmi) {
+  return mbmi->ref_frame[0] == INTRA_FRAME && mbmi->mv[0].as_mv.row != -0x8000;
+  //return mbmi->use_intrabc;
+}
+
+static INLINE int is_inter_block(const MB_MODE_INFO *mbmi) {
+  if (is_intrabc_block(mbmi)) return 1;
+  return mbmi->ref_frame[0] > INTRA_FRAME;
+}
+
+static INLINE int has_second_ref(const MB_MODE_INFO *mbmi) {
+  return mbmi->ref_frame[1] > INTRA_FRAME;
+}
+
+static INLINE MV_REFERENCE_FRAME comp_ref0(int ref_idx) {
+  static const MV_REFERENCE_FRAME lut[] = {
+    LAST_FRAME,     // LAST_LAST2_FRAMES,
+    LAST_FRAME,     // LAST_LAST3_FRAMES,
+    LAST_FRAME,     // LAST_GOLDEN_FRAMES,
+    BWDREF_FRAME,   // BWDREF_ALTREF_FRAMES,
+    LAST2_FRAME,    // LAST2_LAST3_FRAMES
+    LAST2_FRAME,    // LAST2_GOLDEN_FRAMES,
+    LAST3_FRAME,    // LAST3_GOLDEN_FRAMES,
+    BWDREF_FRAME,   // BWDREF_ALTREF2_FRAMES,
+    ALTREF2_FRAME,  // ALTREF2_ALTREF_FRAMES,
+  };
+  assert(NELEMENTS(lut) == TOTAL_UNIDIR_COMP_REFS);
+  return lut[ref_idx];
+}
+
+static INLINE MV_REFERENCE_FRAME comp_ref1(int ref_idx) {
+  static const MV_REFERENCE_FRAME lut[] = {
+    LAST2_FRAME,    // LAST_LAST2_FRAMES,
+    LAST3_FRAME,    // LAST_LAST3_FRAMES,
+    GOLDEN_FRAME,   // LAST_GOLDEN_FRAMES,
+    ALTREF_FRAME,   // BWDREF_ALTREF_FRAMES,
+    LAST3_FRAME,    // LAST2_LAST3_FRAMES
+    GOLDEN_FRAME,   // LAST2_GOLDEN_FRAMES,
+    GOLDEN_FRAME,   // LAST3_GOLDEN_FRAMES,
+    ALTREF2_FRAME,  // BWDREF_ALTREF2_FRAMES,
+    ALTREF_FRAME,   // ALTREF2_ALTREF_FRAMES,
+  };
+  assert(NELEMENTS(lut) == TOTAL_UNIDIR_COMP_REFS);
+  return lut[ref_idx];
+}
+
+#define WARPEDMODEL_PREC_BITS 16
+#define GM_TRANS_ONLY_PREC_DIFF (WARPEDMODEL_PREC_BITS - 3)
+#define WARPEDMODEL_ROW3HOMO_PREC_BITS 16
+
+static INLINE int convert_to_trans_prec(int allow_hp, int coor) {
+  if (allow_hp)
+    return ROUND_POWER_OF_TWO_SIGNED(coor, WARPEDMODEL_PREC_BITS - 3);
+  else
+    return ROUND_POWER_OF_TWO_SIGNED(coor, WARPEDMODEL_PREC_BITS - 2) * 2;
+}
+
+static INLINE int block_center_x(int mi_col, BLOCK_SIZE bs) {
+  const int bw = block_size_wide[bs];
+  return mi_col * MI_SIZE + bw / 2 - 1;
+}
+
+static INLINE int block_center_y(int mi_row, BLOCK_SIZE bs) {
+  const int bh = block_size_high[bs];
+  return mi_row * MI_SIZE + bh / 2 - 1;
+}
+
+#if 0
+static INLINE MV_REFERENCE_FRAME comp_ref0(int ref_idx) {
+  static const MV_REFERENCE_FRAME lut[] = {
+    LAST_FRAME,    // LAST_LAST2_FRAMES,
+    LAST_FRAME,    // LAST_LAST3_FRAMES,
+    LAST_FRAME,    // LAST_GOLDEN_FRAMES,
+    BWDREF_FRAME,  // BWDREF_ALTREF_FRAMES,
+  };
+  assert(NELEMENTS(lut) == UNIDIR_COMP_REFS);
+  return lut[ref_idx];
+}
+
+static INLINE MV_REFERENCE_FRAME comp_ref1(int ref_idx) {
+  static const MV_REFERENCE_FRAME lut[] = {
+    LAST2_FRAME,   // LAST_LAST2_FRAMES,
+    LAST3_FRAME,   // LAST_LAST3_FRAMES,
+    GOLDEN_FRAME,  // LAST_GOLDEN_FRAMES,
+    ALTREF_FRAME,  // BWDREF_ALTREF_FRAMES,
+  };
+  assert(NELEMENTS(lut) == UNIDIR_COMP_REFS);
+  return lut[ref_idx];
+}
+#endif
+
+// Convert a global motion vector into a motion vector at the centre of the
+// given block.
+//
+// The resulting motion vector will have three fractional bits of precision. If
+// allow_hp is zero, the bottom bit will always be zero. If CONFIG_AMVR and
+// is_integer is true, the bottom three bits will be zero (so the motion vector
+// represents an integer)
+static INLINE int_mv gm_get_motion_vector(const WarpedMotionParams *gm,
+                                          int allow_hp, BLOCK_SIZE bsize,
+                                          int mi_col, int mi_row,
+                                          int is_integer) {
+  int_mv res;
+  const int32_t *mat = gm->wmmat;
+  int x, y, tx, ty;
+
+  if (gm->wmtype == TRANSLATION) {
+    // All global motion vectors are stored with WARPEDMODEL_PREC_BITS (16)
+    // bits of fractional precision. The offset for a translation is stored in
+    // entries 0 and 1. For translations, all but the top three (two if
+    // cm->allow_high_precision_mv is false) fractional bits are always zero.
+    //
+    // After the right shifts, there are 3 fractional bits of precision. If
+    // allow_hp is false, the bottom bit is always zero (so we don't need a
+    // call to convert_to_trans_prec here)
+    res.as_mv.row = gm->wmmat[0] >> GM_TRANS_ONLY_PREC_DIFF;
+    res.as_mv.col = gm->wmmat[1] >> GM_TRANS_ONLY_PREC_DIFF;
+    assert(IMPLIES(1 & (res.as_mv.row | res.as_mv.col), allow_hp));
+    if (is_integer) {
+      integer_mv_precision(&res.as_mv);
+    }
+    return res;
+  }
+
+  x = block_center_x(mi_col, bsize);
+  y = block_center_y(mi_row, bsize);
+
+  if (gm->wmtype == ROTZOOM) {
+    assert(gm->wmmat[5] == gm->wmmat[2]);
+    assert(gm->wmmat[4] == -gm->wmmat[3]);
+  }
+  if (gm->wmtype > AFFINE) {
+    int xc = (int)((int64_t)mat[2] * x + (int64_t)mat[3] * y + mat[0]);
+    int yc = (int)((int64_t)mat[4] * x + (int64_t)mat[5] * y + mat[1]);
+    const int Z = (int)((int64_t)mat[6] * x + (int64_t)mat[7] * y +
+                        (1 << WARPEDMODEL_ROW3HOMO_PREC_BITS));
+    xc *= 1 << (WARPEDMODEL_ROW3HOMO_PREC_BITS - WARPEDMODEL_PREC_BITS);
+    yc *= 1 << (WARPEDMODEL_ROW3HOMO_PREC_BITS - WARPEDMODEL_PREC_BITS);
+    xc = (int)(xc > 0 ? ((int64_t)xc + Z / 2) / Z : ((int64_t)xc - Z / 2) / Z);
+    yc = (int)(yc > 0 ? ((int64_t)yc + Z / 2) / Z : ((int64_t)yc - Z / 2) / Z);
+    tx = convert_to_trans_prec(allow_hp, xc) - (x << 3);
+    ty = convert_to_trans_prec(allow_hp, yc) - (y << 3);
+  } else {
+    const int xc =
+        (mat[2] - (1 << WARPEDMODEL_PREC_BITS)) * x + mat[3] * y + mat[0];
+    const int yc =
+        mat[4] * x + (mat[5] - (1 << WARPEDMODEL_PREC_BITS)) * y + mat[1];
+    tx = convert_to_trans_prec(allow_hp, xc);
+    ty = convert_to_trans_prec(allow_hp, yc);
+  }
+
+  res.as_mv.row = ty;
+  res.as_mv.col = tx;
+
+  if (is_integer) {
+    integer_mv_precision(&res.as_mv);
+  }
+  return res;
+}
+
+static INLINE int have_newmv_in_inter_mode(PREDICTION_MODE mode) {
+  return (mode == NEWMV || mode == NEW_NEWMV || mode == NEAREST_NEWMV ||
+          mode == NEW_NEARESTMV || mode == NEAR_NEWMV || mode == NEW_NEARMV);
+}
+
+/*
+ * Copyright (c) 2016, Alliance for Open Media. All rights reserved
+ *
+ * This source code is subject to the terms of the BSD 2 Clause License and
+ * the Alliance for Open Media Patent License 1.0. If the BSD 2 Clause License
+ * was not distributed with this source code in the LICENSE file, you can
+ * obtain it at www.aomedia.org/license/software. If the Alliance for Open
+ * Media Patent License 1.0 was not distributed with this source code in the
+ * PATENTS file, you can obtain it at www.aomedia.org/license/patent.
+ */
+#ifndef AV1_COMMON_MVREF_COMMON_H_
+#define AV1_COMMON_MVREF_COMMON_H_
+
+//#include "av1/common/onyxc_int.h"
+//#include "av1/common/blockd.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#define MVREF_ROW_COLS 3
+
+// Set the upper limit of the motion vector component magnitude.
+// This would make a motion vector fit in 26 bits. Plus 3 bits for the
+// reference frame index. A tuple of motion vector can hence be stored within
+// 32 bit range for efficient load/store operations.
+#define REFMVS_LIMIT ((1 << 12) - 1)
+
+typedef struct position {
+  int row;
+  int col;
+} POSITION;
+
+// clamp_mv_ref
+#define MV_BORDER (16 << 3)  // Allow 16 pels in 1/8th pel units
+
+static INLINE int get_relative_dist(const AV1_COMMON *cm, int a, int b) {
+  if (!cm->seq_params.enable_order_hint) return 0;
+
+  const int bits = cm->seq_params.order_hint_bits_minus1 + 1;
+
+  assert(bits >= 1);
+  assert(a >= 0 && a < (1 << bits));
+  assert(b >= 0 && b < (1 << bits));
+
+  int diff = a - b;
+  int m = 1 << (bits - 1);
+  diff = (diff & (m - 1)) - (diff & m);
+  return diff;
+}
+
+static INLINE void clamp_mv_ref(MV *mv, int bw, int bh, const MACROBLOCKD *xd) {
+  clamp_mv(mv, xd->mb_to_left_edge - bw * 8 - MV_BORDER,
+           xd->mb_to_right_edge + bw * 8 + MV_BORDER,
+           xd->mb_to_top_edge - bh * 8 - MV_BORDER,
+           xd->mb_to_bottom_edge + bh * 8 + MV_BORDER);
+}
+
+// This function returns either the appropriate sub block or block's mv
+// on whether the block_size < 8x8 and we have check_sub_blocks set.
+static INLINE int_mv get_sub_block_mv(const MB_MODE_INFO *candidate,
+                                      int which_mv, int search_col) {
+  (void)search_col;
+  return candidate->mv[which_mv];
+}
+
+static INLINE int_mv get_sub_block_pred_mv(const MB_MODE_INFO *candidate,
+                                           int which_mv, int search_col) {
+  (void)search_col;
+  return candidate->mv[which_mv];
+}
+
+// Performs mv sign inversion if indicated by the reference frame combination.
+static INLINE int_mv scale_mv(const MB_MODE_INFO *mbmi, int ref,
+                              const MV_REFERENCE_FRAME this_ref_frame,
+                              const int *ref_sign_bias) {
+  int_mv mv = mbmi->mv[ref];
+  if (ref_sign_bias[mbmi->ref_frame[ref]] != ref_sign_bias[this_ref_frame]) {
+    mv.as_mv.row *= -1;
+    mv.as_mv.col *= -1;
+  }
+  return mv;
+}
+
+// Checks that the given mi_row, mi_col and search point
+// are inside the borders of the tile.
+static INLINE int is_inside(const TileInfo *const tile, int mi_col, int mi_row,
+                            int mi_rows, const POSITION *mi_pos) {
+  const int dependent_horz_tile_flag = 0;
+  if (dependent_horz_tile_flag && !tile->tg_horz_boundary) {
+    return !(mi_row + mi_pos->row < 0 ||
+             mi_col + mi_pos->col < tile->mi_col_start ||
+             mi_row + mi_pos->row >= mi_rows ||
+             mi_col + mi_pos->col >= tile->mi_col_end);
+  } else {
+    return !(mi_row + mi_pos->row < tile->mi_row_start ||
+             mi_col + mi_pos->col < tile->mi_col_start ||
+             mi_row + mi_pos->row >= tile->mi_row_end ||
+             mi_col + mi_pos->col >= tile->mi_col_end);
+  }
+}
+
+static INLINE int find_valid_row_offset(const TileInfo *const tile, int mi_row,
+                                        int mi_rows, int row_offset) {
+  const int dependent_horz_tile_flag = 0;
+  if (dependent_horz_tile_flag && !tile->tg_horz_boundary)
+    return clamp(row_offset, -mi_row, mi_rows - mi_row - 1);
+  else
+    return clamp(row_offset, tile->mi_row_start - mi_row,
+                 tile->mi_row_end - mi_row - 1);
+}
+
+static INLINE int find_valid_col_offset(const TileInfo *const tile, int mi_col,
+                                        int col_offset) {
+  return clamp(col_offset, tile->mi_col_start - mi_col,
+               tile->mi_col_end - mi_col - 1);
+}
+
+static INLINE void lower_mv_precision(MV *mv, int allow_hp,
+                                      int is_integer) {
+  if (is_integer) {
+    integer_mv_precision(mv);
+  } else {
+    if (!allow_hp) {
+      if (mv->row & 1) mv->row += (mv->row > 0 ? -1 : 1);
+      if (mv->col & 1) mv->col += (mv->col > 0 ? -1 : 1);
+    }
+  }
+}
+
+static INLINE int8_t get_uni_comp_ref_idx(const MV_REFERENCE_FRAME *const rf) {
+  // Single ref pred
+  if (rf[1] <= INTRA_FRAME) return -1;
+
+  // Bi-directional comp ref pred
+  if ((rf[0] < BWDREF_FRAME) && (rf[1] >= BWDREF_FRAME)) return -1;
+
+  for (int8_t ref_idx = 0; ref_idx < TOTAL_UNIDIR_COMP_REFS; ++ref_idx) {
+    if (rf[0] == comp_ref0(ref_idx) && rf[1] == comp_ref1(ref_idx))
+      return ref_idx;
+  }
+  return -1;
+}
+
+static INLINE int8_t av1_ref_frame_type(const MV_REFERENCE_FRAME *const rf) {
+  if (rf[1] > INTRA_FRAME) {
+    const int8_t uni_comp_ref_idx = get_uni_comp_ref_idx(rf);
+    if (uni_comp_ref_idx >= 0) {
+      assert((REF_FRAMES + FWD_REFS * BWD_REFS + uni_comp_ref_idx) <
+             MODE_CTX_REF_FRAMES);
+      return REF_FRAMES + FWD_REFS * BWD_REFS + uni_comp_ref_idx;
+    } else {
+      return REF_FRAMES + FWD_RF_OFFSET(rf[0]) +
+             BWD_RF_OFFSET(rf[1]) * FWD_REFS;
+    }
+  }
+
+  return rf[0];
+}
+
+// clang-format off
+static MV_REFERENCE_FRAME ref_frame_map[TOTAL_COMP_REFS][2] = {
+  { LAST_FRAME, BWDREF_FRAME },  { LAST2_FRAME, BWDREF_FRAME },
+  { LAST3_FRAME, BWDREF_FRAME }, { GOLDEN_FRAME, BWDREF_FRAME },
+
+  { LAST_FRAME, ALTREF2_FRAME },  { LAST2_FRAME, ALTREF2_FRAME },
+  { LAST3_FRAME, ALTREF2_FRAME }, { GOLDEN_FRAME, ALTREF2_FRAME },
+
+  { LAST_FRAME, ALTREF_FRAME },  { LAST2_FRAME, ALTREF_FRAME },
+  { LAST3_FRAME, ALTREF_FRAME }, { GOLDEN_FRAME, ALTREF_FRAME },
+
+  { LAST_FRAME, LAST2_FRAME }, { LAST_FRAME, LAST3_FRAME },
+  { LAST_FRAME, GOLDEN_FRAME }, { BWDREF_FRAME, ALTREF_FRAME },
+
+  // NOTE: Following reference frame pairs are not supported to be explicitly
+  //       signalled, but they are possibly chosen by the use of skip_mode,
+  //       which may use the most recent one-sided reference frame pair.
+  { LAST2_FRAME, LAST3_FRAME }, { LAST2_FRAME, GOLDEN_FRAME },
+  { LAST3_FRAME, GOLDEN_FRAME }, {BWDREF_FRAME, ALTREF2_FRAME},
+  { ALTREF2_FRAME, ALTREF_FRAME }
+};
+// clang-format on
+
+static INLINE void av1_set_ref_frame(MV_REFERENCE_FRAME *rf,
+                                     int8_t ref_frame_type) {
+  if (ref_frame_type >= REF_FRAMES) {
+    rf[0] = ref_frame_map[ref_frame_type - REF_FRAMES][0];
+    rf[1] = ref_frame_map[ref_frame_type - REF_FRAMES][1];
+  } else {
+    rf[0] = ref_frame_type;
+    rf[1] = NONE_FRAME;
+    assert(ref_frame_type > NONE_FRAME);
+  }
+}
+
+static uint16_t compound_mode_ctx_map[3][COMP_NEWMV_CTXS] = {
+  { 0, 1, 1, 1, 1 },
+  { 1, 2, 3, 4, 4 },
+  { 4, 4, 5, 6, 7 },
+};
+
+static INLINE int16_t av1_mode_context_analyzer(
+    const int16_t *const mode_context, const MV_REFERENCE_FRAME *const rf) {
+  const int8_t ref_frame = av1_ref_frame_type(rf);
+
+  if (rf[1] <= INTRA_FRAME) return mode_context[ref_frame];
+
+  const int16_t newmv_ctx = mode_context[ref_frame] & NEWMV_CTX_MASK;
+  const int16_t refmv_ctx =
+      (mode_context[ref_frame] >> REFMV_OFFSET) & REFMV_CTX_MASK;
+
+  const int16_t comp_ctx = compound_mode_ctx_map[refmv_ctx >> 1][AOMMIN(
+      newmv_ctx, COMP_NEWMV_CTXS - 1)];
+  return comp_ctx;
+}
+
+static INLINE uint8_t av1_drl_ctx(const CANDIDATE_MV *ref_mv_stack,
+                                  int ref_idx) {
+  if (ref_mv_stack[ref_idx].weight >= REF_CAT_LEVEL &&
+      ref_mv_stack[ref_idx + 1].weight >= REF_CAT_LEVEL)
+    return 0;
+
+  if (ref_mv_stack[ref_idx].weight >= REF_CAT_LEVEL &&
+      ref_mv_stack[ref_idx + 1].weight < REF_CAT_LEVEL)
+    return 1;
+
+  if (ref_mv_stack[ref_idx].weight < REF_CAT_LEVEL &&
+      ref_mv_stack[ref_idx + 1].weight < REF_CAT_LEVEL)
+    return 2;
+
+  return 0;
+}
+
+void av1_setup_frame_buf_refs(AV1_COMMON *cm);
+void av1_setup_frame_sign_bias(AV1_COMMON *cm);
+void av1_setup_skip_mode_allowed(AV1_COMMON *cm);
+
+#if 0
+void av1_setup_motion_field(AV1_COMMON *cm);
+void av1_set_frame_refs(AV1_COMMON *const cm, int lst_map_idx, int gld_map_idx);
+#endif  // CONFIG_FRAME_REFS_SIGNALING
+
+#if 0
+static INLINE void av1_collect_neighbors_ref_counts(MACROBLOCKD *const xd) {
+  av1_zero(xd->neighbors_ref_counts);
+
+  uint8_t *const ref_counts = xd->neighbors_ref_counts;
+
+  const MB_MODE_INFO *const above_mbmi = xd->above_mbmi;
+  const MB_MODE_INFO *const left_mbmi = xd->left_mbmi;
+  const int above_in_image = xd->up_available;
+  const int left_in_image = xd->left_available;
+
+  // Above neighbor
+  if (above_in_image && is_inter_block(above_mbmi)) {
+    ref_counts[above_mbmi->ref_frame[0]]++;
+    if (has_second_ref(above_mbmi)) {
+      ref_counts[above_mbmi->ref_frame[1]]++;
+    }
+  }
+
+  // Left neighbor
+  if (left_in_image && is_inter_block(left_mbmi)) {
+    ref_counts[left_mbmi->ref_frame[0]]++;
+    if (has_second_ref(left_mbmi)) {
+      ref_counts[left_mbmi->ref_frame[1]]++;
+    }
+  }
+}
+#endif
+
+void av1_copy_frame_mvs(const AV1_COMMON *const cm, MB_MODE_INFO *mi,
+                        int mi_row, int mi_col, int x_mis, int y_mis);
+
+void av1_find_mv_refs(const AV1_COMMON *cm, const MACROBLOCKD *xd,
+                      MB_MODE_INFO *mi, MV_REFERENCE_FRAME ref_frame,
+                      uint8_t ref_mv_count[MODE_CTX_REF_FRAMES],
+                      CANDIDATE_MV ref_mv_stack[][MAX_REF_MV_STACK_SIZE],
+                      int_mv mv_ref_list[][MAX_MV_REF_CANDIDATES],
+                      int_mv *global_mvs, int mi_row, int mi_col,
+                      int16_t *mode_context);
+
+// check a list of motion vectors by sad score using a number rows of pixels
+// above and a number cols of pixels in the left to select the one with best
+// score to use as ref motion vector
+void av1_find_best_ref_mvs(int allow_hp, int_mv *mvlist, int_mv *nearest_mv,
+                           int_mv *near_mv, int is_integer);
+
+int selectSamples(MV *mv, int *pts, int *pts_inref, int len, BLOCK_SIZE bsize);
+int findSamples(const AV1_COMMON *cm, MACROBLOCKD *xd, int mi_row, int mi_col,
+                int *pts, int *pts_inref);
+
+#define INTRABC_DELAY_PIXELS 256  //  Delay of 256 pixels
+#define INTRABC_DELAY_SB64 (INTRABC_DELAY_PIXELS / 64)
+#define USE_WAVE_FRONT 1  // Use only top left area of frame for reference.
+
+static INLINE void av1_find_ref_dv(int_mv *ref_dv, const TileInfo *const tile,
+                                   int mib_size, int mi_row, int mi_col) {
+  (void)mi_col;
+  if (mi_row - mib_size < tile->mi_row_start) {
+    ref_dv->as_mv.row = 0;
+    ref_dv->as_mv.col = -MI_SIZE * mib_size - INTRABC_DELAY_PIXELS;
+  } else {
+    ref_dv->as_mv.row = -MI_SIZE * mib_size;
+    ref_dv->as_mv.col = 0;
+  }
+  ref_dv->as_mv.row *= 8;
+  ref_dv->as_mv.col *= 8;
+}
+
+static INLINE int av1_is_dv_valid(const MV dv, const AV1_COMMON *cm,
+                                  const MACROBLOCKD *xd, int mi_row, int mi_col,
+                                  BLOCK_SIZE bsize, int mib_size_log2) {
+  const int bw = block_size_wide[bsize];
+  const int bh = block_size_high[bsize];
+  const int SCALE_PX_TO_MV = 8;
+  // Disallow subpixel for now
+  // SUBPEL_MASK is not the correct scale
+  if (((dv.row & (SCALE_PX_TO_MV - 1)) || (dv.col & (SCALE_PX_TO_MV - 1))))
+    return 0;
+
+  const TileInfo *const tile = &xd->tile;
+  // Is the source top-left inside the current tile?
+  const int src_top_edge = mi_row * MI_SIZE * SCALE_PX_TO_MV + dv.row;
+  const int tile_top_edge = tile->mi_row_start * MI_SIZE * SCALE_PX_TO_MV;
+  if (src_top_edge < tile_top_edge) return 0;
+  const int src_left_edge = mi_col * MI_SIZE * SCALE_PX_TO_MV + dv.col;
+  const int tile_left_edge = tile->mi_col_start * MI_SIZE * SCALE_PX_TO_MV;
+  if (src_left_edge < tile_left_edge) return 0;
+  // Is the bottom right inside the current tile?
+  const int src_bottom_edge = (mi_row * MI_SIZE + bh) * SCALE_PX_TO_MV + dv.row;
+  const int tile_bottom_edge = tile->mi_row_end * MI_SIZE * SCALE_PX_TO_MV;
+  if (src_bottom_edge > tile_bottom_edge) return 0;
+  const int src_right_edge = (mi_col * MI_SIZE + bw) * SCALE_PX_TO_MV + dv.col;
+  const int tile_right_edge = tile->mi_col_end * MI_SIZE * SCALE_PX_TO_MV;
+  if (src_right_edge > tile_right_edge) return 0;
+
+#if 0
+  // Special case for sub 8x8 chroma cases, to prevent referring to chroma
+  // pixels outside current tile.
+  for (int plane = 1; plane < av1_num_planes(cm); ++plane) {
+    const struct macroblockd_plane *const pd = &xd->plane[plane];
+    if (is_chroma_reference(mi_row, mi_col, bsize, pd->subsampling_x,
+                            pd->subsampling_y)) {
+      if (bw < 8 && pd->subsampling_x)
+        if (src_left_edge < tile_left_edge + 4 * SCALE_PX_TO_MV) return 0;
+      if (bh < 8 && pd->subsampling_y)
+        if (src_top_edge < tile_top_edge + 4 * SCALE_PX_TO_MV) return 0;
+    }
+  }
+#endif
+
+  // Is the bottom right within an already coded SB? Also consider additional
+  // constraints to facilitate HW decoder.
+  const int max_mib_size = 1 << mib_size_log2;
+  const int active_sb_row = mi_row >> mib_size_log2;
+  const int active_sb64_col = (mi_col * MI_SIZE) >> 6;
+  const int sb_size = max_mib_size * MI_SIZE;
+  const int src_sb_row = ((src_bottom_edge >> 3) - 1) / sb_size;
+  const int src_sb64_col = ((src_right_edge >> 3) - 1) >> 6;
+  const int total_sb64_per_row =
+      ((tile->mi_col_end - tile->mi_col_start - 1) >> 4) + 1;
+  const int active_sb64 = active_sb_row * total_sb64_per_row + active_sb64_col;
+  const int src_sb64 = src_sb_row * total_sb64_per_row + src_sb64_col;
+  if (src_sb64 >= active_sb64 - INTRABC_DELAY_SB64) return 0;
+
+#if USE_WAVE_FRONT
+  const int gradient = 1 + INTRABC_DELAY_SB64 + (sb_size > 64);
+  const int wf_offset = gradient * (active_sb_row - src_sb_row);
+  if (src_sb_row > active_sb_row ||
+      src_sb64_col >= active_sb64_col - INTRABC_DELAY_SB64 + wf_offset)
+    return 0;
+#endif
+
+  return 1;
+}
+
+#ifdef __cplusplus
+}  // extern "C"
+#endif
+
+#endif  // AV1_COMMON_MVREF_COMMON_H_
+
+/*
+ * Copyright (c) 2016, Alliance for Open Media. All rights reserved
+ *
+ * This source code is subject to the terms of the BSD 2 Clause License and
+ * the Alliance for Open Media Patent License 1.0. If the BSD 2 Clause License
+ * was not distributed with this source code in the LICENSE file, you can
+ * obtain it at www.aomedia.org/license/software. If the Alliance for Open
+ * Media Patent License 1.0 was not distributed with this source code in the
+ * PATENTS file, you can obtain it at www.aomedia.org/license/patent.
+ */
+
+#include <stdlib.h>
+
+//#include "av1/common/mvref_common.h"
+//#include "av1/common/warped_motion.h"
+
+// Although we assign 32 bit integers, all the values are strictly under 14
+// bits.
+static int div_mult[32] = { 0,    16384, 8192, 5461, 4096, 3276, 2730, 2340,
+                            2048, 1820,  1638, 1489, 1365, 1260, 1170, 1092,
+                            1024, 963,   910,  862,  819,  780,  744,  712,
+                            682,  655,   630,  606,  585,  564,  546,  528 };
+
+// TODO(jingning): Consider the use of lookup table for (num / den)
+// altogether.
+static void get_mv_projection(MV *output, MV ref, int num, int den) {
+  den = AOMMIN(den, MAX_FRAME_DISTANCE);
+  num = num > 0 ? AOMMIN(num, MAX_FRAME_DISTANCE)
+                : AOMMAX(num, -MAX_FRAME_DISTANCE);
+  int mv_row = ROUND_POWER_OF_TWO_SIGNED(ref.row * num * div_mult[den], 14);
+  int mv_col = ROUND_POWER_OF_TWO_SIGNED(ref.col * num * div_mult[den], 14);
+  const int clamp_max = MV_UPP - 1;
+  const int clamp_min = MV_LOW + 1;
+  output->row = (int16_t)clamp(mv_row, clamp_min, clamp_max);
+  output->col = (int16_t)clamp(mv_col, clamp_min, clamp_max);
+}
+
+#if 0
+void av1_copy_frame_mvs(const AV1_COMMON *const cm, MB_MODE_INFO *mi,
+                        int mi_row, int mi_col, int x_mis, int y_mis) {
+  const int frame_mvs_stride = ROUND_POWER_OF_TWO(cm->mi_cols, 1);
+  MV_REF *frame_mvs =
+      cm->cur_frame.mvs + (mi_row >> 1) * frame_mvs_stride + (mi_col >> 1);
+  x_mis = ROUND_POWER_OF_TWO(x_mis, 1);
+  y_mis = ROUND_POWER_OF_TWO(y_mis, 1);
+  int w, h;
+
+  for (h = 0; h < y_mis; h++) {
+    MV_REF *mv = frame_mvs;
+    for (w = 0; w < x_mis; w++) {
+      mv->ref_frame = NONE_FRAME;
+      mv->mv.as_int = 0;
+
+      for (int idx = 0; idx < 2; ++idx) {
+        MV_REFERENCE_FRAME ref_frame = mi->ref_frame[idx];
+        if (ref_frame > INTRA_FRAME) {
+          int8_t ref_idx = cm->ref_frame_side[ref_frame];
+          if (ref_idx) continue;
+          if ((abs(mi->mv[idx].as_mv.row) > REFMVS_LIMIT) ||
+              (abs(mi->mv[idx].as_mv.col) > REFMVS_LIMIT))
+            continue;
+          mv->ref_frame = ref_frame;
+          mv->mv.as_int = mi->mv[idx].as_int;
+        }
+      }
+      mv++;
+    }
+    frame_mvs += frame_mvs_stride;
+  }
+}
+#endif
+
+static void add_ref_mv_candidate(
+    const MB_MODE_INFO *const candidate, const MV_REFERENCE_FRAME rf[2],
+    uint8_t *refmv_count, uint8_t *ref_match_count, uint8_t *newmv_count,
+    CANDIDATE_MV *ref_mv_stack, int_mv *gm_mv_candidates,
+    const WarpedMotionParams *gm_params, int col, int weight) {
+  if (!is_inter_block(candidate)) return;  // for intrabc
+  int index = 0, ref;
+  assert(weight % 2 == 0);
+
+  if (rf[1] == NONE_FRAME) {
+    // single reference frame
+    for (ref = 0; ref < 2; ++ref) {
+      if (candidate->ref_frame[ref] == rf[0]) {
+        int_mv this_refmv;
+        if (is_global_mv_block(candidate, gm_params[rf[0]].wmtype))
+          this_refmv = gm_mv_candidates[0];
+        else
+          this_refmv = get_sub_block_mv(candidate, ref, col);
+
+        for (index = 0; index < *refmv_count; ++index)
+          if (ref_mv_stack[index].this_mv.as_int == this_refmv.as_int) break;
+
+        if (index < *refmv_count) ref_mv_stack[index].weight += weight;
+
+        // Add a new item to the list.
+        if (index == *refmv_count && *refmv_count < MAX_REF_MV_STACK_SIZE) {
+          ref_mv_stack[index].this_mv = this_refmv;
+          ref_mv_stack[index].weight = weight;
+          ++(*refmv_count);
+        }
+        if (have_newmv_in_inter_mode(candidate->mode)) ++*newmv_count;
+        ++*ref_match_count;
+      }
+    }
+  } else {
+    // compound reference frame
+    if (candidate->ref_frame[0] == rf[0] && candidate->ref_frame[1] == rf[1]) {
+      int_mv this_refmv[2];
+
+      for (ref = 0; ref < 2; ++ref) {
+        if (is_global_mv_block(candidate, gm_params[rf[ref]].wmtype))
+          this_refmv[ref] = gm_mv_candidates[ref];
+        else
+          this_refmv[ref] = get_sub_block_mv(candidate, ref, col);
+      }
+
+      for (index = 0; index < *refmv_count; ++index)
+        if ((ref_mv_stack[index].this_mv.as_int == this_refmv[0].as_int) &&
+            (ref_mv_stack[index].comp_mv.as_int == this_refmv[1].as_int))
+          break;
+
+      if (index < *refmv_count) ref_mv_stack[index].weight += weight;
+
+      // Add a new item to the list.
+      if (index == *refmv_count && *refmv_count < MAX_REF_MV_STACK_SIZE) {
+        ref_mv_stack[index].this_mv = this_refmv[0];
+        ref_mv_stack[index].comp_mv = this_refmv[1];
+        ref_mv_stack[index].weight = weight;
+        ++(*refmv_count);
+      }
+      if (have_newmv_in_inter_mode(candidate->mode)) ++*newmv_count;
+      ++*ref_match_count;
+    }
+  }
+}
+
+static void scan_row_mbmi(const AV1_COMMON *cm, const MACROBLOCKD *xd,
+                          int mi_row, int mi_col,
+                          const MV_REFERENCE_FRAME rf[2], int row_offset,
+                          CANDIDATE_MV *ref_mv_stack, uint8_t *refmv_count,
+                          uint8_t *ref_match_count, uint8_t *newmv_count,
+                          int_mv *gm_mv_candidates, int max_row_offset,
+                          int *processed_rows) {
+  int end_mi = AOMMIN(xd->n8_w, cm->mi_cols - mi_col);
+  end_mi = AOMMIN(end_mi, mi_size_wide[BLOCK_64X64]);
+  const int n8_w_8 = mi_size_wide[BLOCK_8X8];
+  const int n8_w_16 = mi_size_wide[BLOCK_16X16];
+  int i;
+  int col_offset = 0;
+  const int shift = 0;
+  // TODO(jingning): Revisit this part after cb4x4 is stable.
+  if (abs(row_offset) > 1) {
+    col_offset = 1;
+    if ((mi_col & 0x01) && xd->n8_w < n8_w_8) --col_offset;
+  }
+  const int use_step_16 = (xd->n8_w >= 16);
+  MB_MODE_INFO *const candidate_mi0 = xd->mi + row_offset * xd->mi_stride;
+  (void)mi_row;
+
+  for (i = 0; i < end_mi;) {
+    const MB_MODE_INFO *const candidate = &candidate_mi0[col_offset + i];
+    const int candidate_bsize = candidate->sb_type;
+    const int n8_w = mi_size_wide[candidate_bsize];
+    int len = AOMMIN(xd->n8_w, n8_w);
+    if (use_step_16)
+      len = AOMMAX(n8_w_16, len);
+    else if (abs(row_offset) > 1)
+      len = AOMMAX(len, n8_w_8);
+
+    int weight = 2;
+    if (xd->n8_w >= n8_w_8 && xd->n8_w <= n8_w) {
+      int inc = AOMMIN(-max_row_offset + row_offset + 1,
+                       mi_size_high[candidate_bsize]);
+      // Obtain range used in weight calculation.
+      weight = AOMMAX(weight, (inc << shift));
+      // Update processed rows.
+      *processed_rows = inc - row_offset - 1;
+    }
+
+    add_ref_mv_candidate(candidate, rf, refmv_count, ref_match_count,
+                         newmv_count, ref_mv_stack, gm_mv_candidates,
+                         cm->global_motion, col_offset + i, len * weight);
+
+    i += len;
+  }
+}
+
+static void scan_col_mbmi(const AV1_COMMON *cm, const MACROBLOCKD *xd,
+                          int mi_row, int mi_col,
+                          const MV_REFERENCE_FRAME rf[2], int col_offset,
+                          CANDIDATE_MV *ref_mv_stack, uint8_t *refmv_count,
+                          uint8_t *ref_match_count, uint8_t *newmv_count,
+                          int_mv *gm_mv_candidates, int max_col_offset,
+                          int *processed_cols) {
+  int end_mi = AOMMIN(xd->n8_h, cm->mi_rows - mi_row);
+  end_mi = AOMMIN(end_mi, mi_size_high[BLOCK_64X64]);
+  const int n8_h_8 = mi_size_high[BLOCK_8X8];
+  const int n8_h_16 = mi_size_high[BLOCK_16X16];
+  int i;
+  int row_offset = 0;
+  const int shift = 0;
+  if (abs(col_offset) > 1) {
+    row_offset = 1;
+    if ((mi_row & 0x01) && xd->n8_h < n8_h_8) --row_offset;
+  }
+  const int use_step_16 = (xd->n8_h >= 16);
+  (void)mi_col;
+
+  for (i = 0; i < end_mi;) {
+    const MB_MODE_INFO *const candidate =
+        &xd->mi[(row_offset + i) * xd->mi_stride + col_offset];
+    const int candidate_bsize = candidate->sb_type;
+    const int n8_h = mi_size_high[candidate_bsize];
+    int len = AOMMIN(xd->n8_h, n8_h);
+    if (use_step_16)
+      len = AOMMAX(n8_h_16, len);
+    else if (abs(col_offset) > 1)
+      len = AOMMAX(len, n8_h_8);
+
+    int weight = 2;
+    if (xd->n8_h >= n8_h_8 && xd->n8_h <= n8_h) {
+      int inc = AOMMIN(-max_col_offset + col_offset + 1,
+                       mi_size_wide[candidate_bsize]);
+      // Obtain range used in weight calculation.
+      weight = AOMMAX(weight, (inc << shift));
+      // Update processed cols.
+      *processed_cols = inc - col_offset - 1;
+    }
+
+    add_ref_mv_candidate(candidate, rf, refmv_count, ref_match_count,
+                         newmv_count, ref_mv_stack, gm_mv_candidates,
+                         cm->global_motion, col_offset, len * weight);
+
+    i += len;
+  }
+}
+
+static void scan_blk_mbmi(const AV1_COMMON *cm, const MACROBLOCKD *xd,
+                          const int mi_row, const int mi_col,
+                          const MV_REFERENCE_FRAME rf[2], int row_offset,
+                          int col_offset, CANDIDATE_MV *ref_mv_stack,
+                          uint8_t *ref_match_count, uint8_t *newmv_count,
+                          int_mv *gm_mv_candidates,
+                          uint8_t refmv_count[MODE_CTX_REF_FRAMES]) {
+  const TileInfo *const tile = &xd->tile;
+  POSITION mi_pos;
+
+  mi_pos.row = row_offset;
+  mi_pos.col = col_offset;
+
+  if (is_inside(tile, mi_col, mi_row, cm->mi_rows, &mi_pos)) {
+    const MB_MODE_INFO *const candidate =
+        &xd->mi[mi_pos.row * xd->mi_stride + mi_pos.col];
+    const int len = mi_size_wide[BLOCK_8X8];
+
+    add_ref_mv_candidate(candidate, rf, refmv_count, ref_match_count,
+                         newmv_count, ref_mv_stack, gm_mv_candidates,
+                         cm->global_motion, mi_pos.col, 2 * len);
+  }  // Analyze a single 8x8 block motion information.
+}
+
+static int has_top_right(const AV1_COMMON *cm, const MACROBLOCKD *xd,
+                         int mi_row, int mi_col, int bs) {
+  const int sb_mi_size = mi_size_wide[cm->seq_params.sb_size];
+  const int mask_row = mi_row & (sb_mi_size - 1);
+  const int mask_col = mi_col & (sb_mi_size - 1);
+
+  if (bs > mi_size_wide[BLOCK_64X64]) return 0;
+
+  // In a split partition all apart from the bottom right has a top right
+  int has_tr = !((mask_row & bs) && (mask_col & bs));
+
+  // bs > 0 and bs is a power of 2
+  assert(bs > 0 && !(bs & (bs - 1)));
+
+  // For each 4x4 group of blocks, when the bottom right is decoded the blocks
+  // to the right have not been decoded therefore the bottom right does
+  // not have a top right
+  while (bs < sb_mi_size) {
+    if (mask_col & bs) {
+      if ((mask_col & (2 * bs)) && (mask_row & (2 * bs))) {
+        has_tr = 0;
+        break;
+      }
+    } else {
+      break;
+    }
+    bs <<= 1;
+  }
+
+  // The left hand of two vertical rectangles always has a top right (as the
+  // block above will have been decoded)
+  if (xd->n8_w < xd->n8_h)
+    if (!xd->is_sec_rect) has_tr = 1;
+
+  // The bottom of two horizontal rectangles never has a top right (as the block
+  // to the right won't have been decoded)
+  if (xd->n8_w > xd->n8_h)
+    if (xd->is_sec_rect) has_tr = 0;
+
+  // The bottom left square of a Vertical A (in the old format) does
+  // not have a top right as it is decoded before the right hand
+  // rectangle of the partition
+  if (xd->cur_mi.partition == PARTITION_VERT_A) {
+    if (xd->n8_w == xd->n8_h)
+      if (mask_row & bs) has_tr = 0;
+  }
+
+  return has_tr;
+}
+
+static int check_sb_border(const int mi_row, const int mi_col,
+                           const int row_offset, const int col_offset) {
+  const int sb_mi_size = mi_size_wide[BLOCK_64X64];
+  const int row = mi_row & (sb_mi_size - 1);
+  const int col = mi_col & (sb_mi_size - 1);
+
+  if (row + row_offset < 0 || row + row_offset >= sb_mi_size ||
+      col + col_offset < 0 || col + col_offset >= sb_mi_size)
+    return 0;
+
+  return 1;
+}
+
+static int add_tpl_ref_mv(const AV1_COMMON *cm, const MACROBLOCKD *xd,
+                          int mi_row, int mi_col, MV_REFERENCE_FRAME ref_frame,
+                          int blk_row, int blk_col, int_mv *gm_mv_candidates,
+                          uint8_t refmv_count[MODE_CTX_REF_FRAMES],
+                          CANDIDATE_MV ref_mv_stacks[][MAX_REF_MV_STACK_SIZE],
+                          int16_t *mode_context) {
+  POSITION mi_pos;
+  int idx;
+  const int weight_unit = 1;  // mi_size_wide[BLOCK_8X8];
+
+  mi_pos.row = (mi_row & 0x01) ? blk_row : blk_row + 1;
+  mi_pos.col = (mi_col & 0x01) ? blk_col : blk_col + 1;
+
+  if (!is_inside(&xd->tile, mi_col, mi_row, cm->mi_rows, &mi_pos)) return 0;
+
+  const TPL_MV_REF *prev_frame_mvs =
+      cm->tpl_mvs + ((mi_row + mi_pos.row) >> 1) * (cm->mi_stride >> 1) +
+      ((mi_col + mi_pos.col) >> 1);
+
+  MV_REFERENCE_FRAME rf[2];
+  av1_set_ref_frame(rf, ref_frame);
+
+  if (rf[1] == NONE_FRAME) {
+    int cur_frame_index = cm->cur_frame.cur_frame_offset;
+    int buf_idx_0 = cm->frame_refs[FWD_RF_OFFSET(rf[0])].idx;
+    int frame0_index = cm->buffer_pool.frame_bufs[buf_idx_0].cur_frame_offset;
+    int cur_offset_0 = get_relative_dist(cm, cur_frame_index, frame0_index);
+    CANDIDATE_MV *ref_mv_stack = ref_mv_stacks[rf[0]];
+
+    if (prev_frame_mvs->mfmv0.as_int != INVALID_MV) {
+      int_mv this_refmv;
+
+      get_mv_projection(&this_refmv.as_mv, prev_frame_mvs->mfmv0.as_mv,
+                        cur_offset_0, prev_frame_mvs->ref_frame_offset);
+      lower_mv_precision(&this_refmv.as_mv, cm->allow_high_precision_mv,
+                         cm->cur_frame_force_integer_mv);
+
+      if (blk_row == 0 && blk_col == 0)
+        if (abs(this_refmv.as_mv.row - gm_mv_candidates[0].as_mv.row) >= 16 ||
+            abs(this_refmv.as_mv.col - gm_mv_candidates[0].as_mv.col) >= 16)
+          mode_context[ref_frame] |= (1 << GLOBALMV_OFFSET);
+
+      for (idx = 0; idx < refmv_count[rf[0]]; ++idx)
+        if (this_refmv.as_int == ref_mv_stack[idx].this_mv.as_int) break;
+
+      if (idx < refmv_count[rf[0]]) ref_mv_stack[idx].weight += 2 * weight_unit;
+
+      if (idx == refmv_count[rf[0]] &&
+          refmv_count[rf[0]] < MAX_REF_MV_STACK_SIZE) {
+        ref_mv_stack[idx].this_mv.as_int = this_refmv.as_int;
+        ref_mv_stack[idx].weight = 2 * weight_unit;
+        ++(refmv_count[rf[0]]);
+      }
+
+      return 1;
+    }
+  } else {
+    // Process compound inter mode
+    int cur_frame_index = cm->cur_frame.cur_frame_offset;
+    int buf_idx_0 = cm->frame_refs[FWD_RF_OFFSET(rf[0])].idx;
+    int frame0_index = cm->buffer_pool.frame_bufs[buf_idx_0].cur_frame_offset;
+
+    int cur_offset_0 = get_relative_dist(cm, cur_frame_index, frame0_index);
+    int buf_idx_1 = cm->frame_refs[FWD_RF_OFFSET(rf[1])].idx;
+    int frame1_index = cm->buffer_pool.frame_bufs[buf_idx_1].cur_frame_offset;
+    int cur_offset_1 = get_relative_dist(cm, cur_frame_index, frame1_index);
+    CANDIDATE_MV *ref_mv_stack = ref_mv_stacks[ref_frame];
+
+    if (prev_frame_mvs->mfmv0.as_int != INVALID_MV) {
+      int_mv this_refmv;
+      int_mv comp_refmv;
+      get_mv_projection(&this_refmv.as_mv, prev_frame_mvs->mfmv0.as_mv,
+                        cur_offset_0, prev_frame_mvs->ref_frame_offset);
+      get_mv_projection(&comp_refmv.as_mv, prev_frame_mvs->mfmv0.as_mv,
+                        cur_offset_1, prev_frame_mvs->ref_frame_offset);
+
+      lower_mv_precision(&this_refmv.as_mv, cm->allow_high_precision_mv,
+                         cm->cur_frame_force_integer_mv);
+      lower_mv_precision(&comp_refmv.as_mv, cm->allow_high_precision_mv,
+                         cm->cur_frame_force_integer_mv);
+
+      if (blk_row == 0 && blk_col == 0)
+        if (abs(this_refmv.as_mv.row - gm_mv_candidates[0].as_mv.row) >= 16 ||
+            abs(this_refmv.as_mv.col - gm_mv_candidates[0].as_mv.col) >= 16 ||
+            abs(comp_refmv.as_mv.row - gm_mv_candidates[1].as_mv.row) >= 16 ||
+            abs(comp_refmv.as_mv.col - gm_mv_candidates[1].as_mv.col) >= 16)
+          mode_context[ref_frame] |= (1 << GLOBALMV_OFFSET);
+
+      for (idx = 0; idx < refmv_count[ref_frame]; ++idx)
+        if (this_refmv.as_int == ref_mv_stack[idx].this_mv.as_int &&
+            comp_refmv.as_int == ref_mv_stack[idx].comp_mv.as_int)
+          break;
+
+      if (idx < refmv_count[ref_frame])
+        ref_mv_stack[idx].weight += 2 * weight_unit;
+
+      if (idx == refmv_count[ref_frame] &&
+          refmv_count[ref_frame] < MAX_REF_MV_STACK_SIZE) {
+        ref_mv_stack[idx].this_mv.as_int = this_refmv.as_int;
+        ref_mv_stack[idx].comp_mv.as_int = comp_refmv.as_int;
+        ref_mv_stack[idx].weight = 2 * weight_unit;
+        ++(refmv_count[ref_frame]);
+      }
+      return 1;
+    }
+  }
+  return 0;
+}
+
+static void setup_ref_mv_list(
+    const AV1_COMMON *cm, const MACROBLOCKD *xd, MV_REFERENCE_FRAME ref_frame,
+    uint8_t refmv_count[MODE_CTX_REF_FRAMES],
+    CANDIDATE_MV ref_mv_stack[][MAX_REF_MV_STACK_SIZE],
+    int_mv mv_ref_list[][MAX_MV_REF_CANDIDATES], int_mv *gm_mv_candidates,
+    int mi_row, int mi_col, int16_t *mode_context) {
+  const int bs = AOMMAX(xd->n8_w, xd->n8_h);
+  const int has_tr = has_top_right(cm, xd, mi_row, mi_col, bs);
+  MV_REFERENCE_FRAME rf[2];
+
+  const TileInfo *const tile = &xd->tile;
+  int max_row_offset = 0, max_col_offset = 0;
+  const int row_adj = (xd->n8_h < mi_size_high[BLOCK_8X8]) && (mi_row & 0x01);
+  const int col_adj = (xd->n8_w < mi_size_wide[BLOCK_8X8]) && (mi_col & 0x01);
+  int processed_rows = 0;
+  int processed_cols = 0;
+
+  av1_set_ref_frame(rf, ref_frame);
+  mode_context[ref_frame] = 0;
+  refmv_count[ref_frame] = 0;
+
+  // Find valid maximum row/col offset.
+  if (xd->up_available) {
+    max_row_offset = -(MVREF_ROW_COLS << 1) + row_adj;
+
+    if (xd->n8_h < mi_size_high[BLOCK_8X8])
+      max_row_offset = -(2 << 1) + row_adj;
+
+    max_row_offset =
+        find_valid_row_offset(tile, mi_row, cm->mi_rows, max_row_offset);
+  }
+
+  if (xd->left_available) {
+    max_col_offset = -(MVREF_ROW_COLS << 1) + col_adj;
+
+    if (xd->n8_w < mi_size_wide[BLOCK_8X8])
+      max_col_offset = -(2 << 1) + col_adj;
+
+    max_col_offset = find_valid_col_offset(tile, mi_col, max_col_offset);
+  }
+
+  uint8_t col_match_count = 0;
+  uint8_t row_match_count = 0;
+  uint8_t newmv_count = 0;
+
+  // Scan the first above row mode info. row_offset = -1;
+  if (abs(max_row_offset) >= 1)
+    scan_row_mbmi(cm, xd, mi_row, mi_col, rf, -1, ref_mv_stack[ref_frame],
+                  &refmv_count[ref_frame], &row_match_count, &newmv_count,
+                  gm_mv_candidates, max_row_offset, &processed_rows);
+  // Scan the first left column mode info. col_offset = -1;
+  if (abs(max_col_offset) >= 1)
+    scan_col_mbmi(cm, xd, mi_row, mi_col, rf, -1, ref_mv_stack[ref_frame],
+                  &refmv_count[ref_frame], &col_match_count, &newmv_count,
+                  gm_mv_candidates, max_col_offset, &processed_cols);
+  // Check top-right boundary
+  if (has_tr)
+    scan_blk_mbmi(cm, xd, mi_row, mi_col, rf, -1, xd->n8_w,
+                  ref_mv_stack[ref_frame], &row_match_count, &newmv_count,
+                  gm_mv_candidates, &refmv_count[ref_frame]);
+
+  uint8_t nearest_match = (row_match_count > 0) + (col_match_count > 0);
+  uint8_t nearest_refmv_count = refmv_count[ref_frame];
+
+  // TODO(yunqing): for comp_search, do it for all 3 cases.
+  for (int idx = 0; idx < nearest_refmv_count; ++idx)
+    ref_mv_stack[ref_frame][idx].weight += REF_CAT_LEVEL;
+
+  if (cm->allow_ref_frame_mvs) {
+    int is_available = 0;
+    const int voffset = AOMMAX(mi_size_high[BLOCK_8X8], xd->n8_h);
+    const int hoffset = AOMMAX(mi_size_wide[BLOCK_8X8], xd->n8_w);
+    const int blk_row_end = AOMMIN(xd->n8_h, mi_size_high[BLOCK_64X64]);
+    const int blk_col_end = AOMMIN(xd->n8_w, mi_size_wide[BLOCK_64X64]);
+
+    const int tpl_sample_pos[3][2] = {
+      { voffset, -2 },
+      { voffset, hoffset },
+      { voffset - 2, hoffset },
+    };
+    const int allow_extension = (xd->n8_h >= mi_size_high[BLOCK_8X8]) &&
+                                (xd->n8_h < mi_size_high[BLOCK_64X64]) &&
+                                (xd->n8_w >= mi_size_wide[BLOCK_8X8]) &&
+                                (xd->n8_w < mi_size_wide[BLOCK_64X64]);
+
+    int step_h = (xd->n8_h >= mi_size_high[BLOCK_64X64])
+                     ? mi_size_high[BLOCK_16X16]
+                     : mi_size_high[BLOCK_8X8];
+    int step_w = (xd->n8_w >= mi_size_wide[BLOCK_64X64])
+                     ? mi_size_wide[BLOCK_16X16]
+                     : mi_size_wide[BLOCK_8X8];
+
+    for (int blk_row = 0; blk_row < blk_row_end; blk_row += step_h) {
+      for (int blk_col = 0; blk_col < blk_col_end; blk_col += step_w) {
+        int ret = add_tpl_ref_mv(cm, xd, mi_row, mi_col, ref_frame, blk_row,
+                                 blk_col, gm_mv_candidates, refmv_count,
+                                 ref_mv_stack, mode_context);
+        if (blk_row == 0 && blk_col == 0) is_available = ret;
+      }
+    }
+
+    if (is_available == 0) mode_context[ref_frame] |= (1 << GLOBALMV_OFFSET);
+
+    for (int i = 0; i < 3 && allow_extension; ++i) {
+      const int blk_row = tpl_sample_pos[i][0];
+      const int blk_col = tpl_sample_pos[i][1];
+
+      if (!check_sb_border(mi_row, mi_col, blk_row, blk_col)) continue;
+      add_tpl_ref_mv(cm, xd, mi_row, mi_col, ref_frame, blk_row, blk_col,
+                     gm_mv_candidates, refmv_count, ref_mv_stack, mode_context);
+    }
+  }
+
+  uint8_t dummy_newmv_count = 0;
+
+  // Scan the second outer area.
+  scan_blk_mbmi(cm, xd, mi_row, mi_col, rf, -1, -1, ref_mv_stack[ref_frame],
+                &row_match_count, &dummy_newmv_count, gm_mv_candidates,
+                &refmv_count[ref_frame]);
+
+  for (int idx = 2; idx <= MVREF_ROW_COLS; ++idx) {
+    const int row_offset = -(idx << 1) + 1 + row_adj;
+    const int col_offset = -(idx << 1) + 1 + col_adj;
+
+    if (abs(row_offset) <= abs(max_row_offset) &&
+        abs(row_offset) > processed_rows)
+      scan_row_mbmi(cm, xd, mi_row, mi_col, rf, row_offset,
+                    ref_mv_stack[ref_frame], &refmv_count[ref_frame],
+                    &row_match_count, &dummy_newmv_count, gm_mv_candidates,
+                    max_row_offset, &processed_rows);
+
+    if (abs(col_offset) <= abs(max_col_offset) &&
+        abs(col_offset) > processed_cols)
+      scan_col_mbmi(cm, xd, mi_row, mi_col, rf, col_offset,
+                    ref_mv_stack[ref_frame], &refmv_count[ref_frame],
+                    &col_match_count, &dummy_newmv_count, gm_mv_candidates,
+                    max_col_offset, &processed_cols);
+  }
+
+  uint8_t ref_match_count = (row_match_count > 0) + (col_match_count > 0);
+
+  switch (nearest_match) {
+    case 0:
+      mode_context[ref_frame] |= 0;
+      if (ref_match_count >= 1) mode_context[ref_frame] |= 1;
+      if (ref_match_count == 1)
+        mode_context[ref_frame] |= (1 << REFMV_OFFSET);
+      else if (ref_match_count >= 2)
+        mode_context[ref_frame] |= (2 << REFMV_OFFSET);
+      break;
+    case 1:
+      mode_context[ref_frame] |= (newmv_count > 0) ? 2 : 3;
+      if (ref_match_count == 1)
+        mode_context[ref_frame] |= (3 << REFMV_OFFSET);
+      else if (ref_match_count >= 2)
+        mode_context[ref_frame] |= (4 << REFMV_OFFSET);
+      break;
+    case 2:
+    default:
+      if (newmv_count >= 1)
+        mode_context[ref_frame] |= 4;
+      else
+        mode_context[ref_frame] |= 5;
+
+      mode_context[ref_frame] |= (5 << REFMV_OFFSET);
+      break;
+  }
+
+  // Rank the likelihood and assign nearest and near mvs.
+  int len = nearest_refmv_count;
+  while (len > 0) {
+    int nr_len = 0;
+    for (int idx = 1; idx < len; ++idx) {
+      if (ref_mv_stack[ref_frame][idx - 1].weight <
+          ref_mv_stack[ref_frame][idx].weight) {
+        CANDIDATE_MV tmp_mv = ref_mv_stack[ref_frame][idx - 1];
+        ref_mv_stack[ref_frame][idx - 1] = ref_mv_stack[ref_frame][idx];
+        ref_mv_stack[ref_frame][idx] = tmp_mv;
+        nr_len = idx;
+      }
+    }
+    len = nr_len;
+  }
+
+  len = refmv_count[ref_frame];
+  while (len > nearest_refmv_count) {
+    int nr_len = nearest_refmv_count;
+    for (int idx = nearest_refmv_count + 1; idx < len; ++idx) {
+      if (ref_mv_stack[ref_frame][idx - 1].weight <
+          ref_mv_stack[ref_frame][idx].weight) {
+        CANDIDATE_MV tmp_mv = ref_mv_stack[ref_frame][idx - 1];
+        ref_mv_stack[ref_frame][idx - 1] = ref_mv_stack[ref_frame][idx];
+        ref_mv_stack[ref_frame][idx] = tmp_mv;
+        nr_len = idx;
+      }
+    }
+    len = nr_len;
+  }
+
+  if (rf[1] > NONE_FRAME) {
+    // TODO(jingning, yunqing): Refactor and consolidate the compound and
+    // single reference frame modes. Reduce unnecessary redundancy.
+    if (refmv_count[ref_frame] < MAX_MV_REF_CANDIDATES) {
+      int_mv ref_id[2][2], ref_diff[2][2];
+      int ref_id_count[2] = { 0 }, ref_diff_count[2] = { 0 };
+
+      int mi_width = AOMMIN(mi_size_wide[BLOCK_64X64], xd->n8_w);
+      mi_width = AOMMIN(mi_width, cm->mi_cols - mi_col);
+      int mi_height = AOMMIN(mi_size_high[BLOCK_64X64], xd->n8_h);
+      mi_height = AOMMIN(mi_height, cm->mi_rows - mi_row);
+      int mi_size = AOMMIN(mi_width, mi_height);
+
+      for (int idx = 0; abs(max_row_offset) >= 1 && idx < mi_size;) {
+        const MB_MODE_INFO *const candidate = &xd->mi[-xd->mi_stride + idx];
+        const int candidate_bsize = candidate->sb_type;
+
+        for (int rf_idx = 0; rf_idx < 2; ++rf_idx) {
+          MV_REFERENCE_FRAME can_rf = candidate->ref_frame[rf_idx];
+
+          for (int cmp_idx = 0; cmp_idx < 2; ++cmp_idx) {
+            if (can_rf == rf[cmp_idx] && ref_id_count[cmp_idx] < 2) {
+              ref_id[cmp_idx][ref_id_count[cmp_idx]] = candidate->mv[rf_idx];
+              ++ref_id_count[cmp_idx];
+            } else if (can_rf > INTRA_FRAME && ref_diff_count[cmp_idx] < 2) {
+              int_mv this_mv = candidate->mv[rf_idx];
+              if (cm->ref_frame_sign_bias[can_rf] !=
+                  cm->ref_frame_sign_bias[rf[cmp_idx]]) {
+                this_mv.as_mv.row = -this_mv.as_mv.row;
+                this_mv.as_mv.col = -this_mv.as_mv.col;
+              }
+              ref_diff[cmp_idx][ref_diff_count[cmp_idx]] = this_mv;
+              ++ref_diff_count[cmp_idx];
+            }
+          }
+        }
+        idx += mi_size_wide[candidate_bsize];
+      }
+
+      for (int idx = 0; abs(max_col_offset) >= 1 && idx < mi_size;) {
+        const MB_MODE_INFO *const candidate = &xd->mi[idx * xd->mi_stride - 1];
+        const int candidate_bsize = candidate->sb_type;
+
+        for (int rf_idx = 0; rf_idx < 2; ++rf_idx) {
+          MV_REFERENCE_FRAME can_rf = candidate->ref_frame[rf_idx];
+
+          for (int cmp_idx = 0; cmp_idx < 2; ++cmp_idx) {
+            if (can_rf == rf[cmp_idx] && ref_id_count[cmp_idx] < 2) {
+              ref_id[cmp_idx][ref_id_count[cmp_idx]] = candidate->mv[rf_idx];
+              ++ref_id_count[cmp_idx];
+            } else if (can_rf > INTRA_FRAME && ref_diff_count[cmp_idx] < 2) {
+              int_mv this_mv = candidate->mv[rf_idx];
+              if (cm->ref_frame_sign_bias[can_rf] !=
+                  cm->ref_frame_sign_bias[rf[cmp_idx]]) {
+                this_mv.as_mv.row = -this_mv.as_mv.row;
+                this_mv.as_mv.col = -this_mv.as_mv.col;
+              }
+              ref_diff[cmp_idx][ref_diff_count[cmp_idx]] = this_mv;
+              ++ref_diff_count[cmp_idx];
+            }
+          }
+        }
+        idx += mi_size_high[candidate_bsize];
+      }
+
+      // Build up the compound mv predictor
+      int_mv comp_list[3][2];
+
+      for (int idx = 0; idx < 2; ++idx) {
+        int comp_idx = 0;
+        for (int list_idx = 0; list_idx < ref_id_count[idx] && comp_idx < 2;
+             ++list_idx, ++comp_idx)
+          comp_list[comp_idx][idx] = ref_id[idx][list_idx];
+        for (int list_idx = 0; list_idx < ref_diff_count[idx] && comp_idx < 2;
+             ++list_idx, ++comp_idx)
+          comp_list[comp_idx][idx] = ref_diff[idx][list_idx];
+        for (; comp_idx < 3; ++comp_idx)
+          comp_list[comp_idx][idx] = gm_mv_candidates[idx];
+      }
+
+      if (refmv_count[ref_frame]) {
+        assert(refmv_count[ref_frame] == 1);
+        if (comp_list[0][0].as_int ==
+                ref_mv_stack[ref_frame][0].this_mv.as_int &&
+            comp_list[0][1].as_int ==
+                ref_mv_stack[ref_frame][0].comp_mv.as_int) {
+          ref_mv_stack[ref_frame][refmv_count[ref_frame]].this_mv =
+              comp_list[1][0];
+          ref_mv_stack[ref_frame][refmv_count[ref_frame]].comp_mv =
+              comp_list[1][1];
+        } else {
+          ref_mv_stack[ref_frame][refmv_count[ref_frame]].this_mv =
+              comp_list[0][0];
+          ref_mv_stack[ref_frame][refmv_count[ref_frame]].comp_mv =
+              comp_list[0][1];
+        }
+        ref_mv_stack[ref_frame][refmv_count[ref_frame]].weight = 2;
+        ++refmv_count[ref_frame];
+      } else {
+        for (int idx = 0; idx < MAX_MV_REF_CANDIDATES; ++idx) {
+          ref_mv_stack[ref_frame][refmv_count[ref_frame]].this_mv =
+              comp_list[idx][0];
+          ref_mv_stack[ref_frame][refmv_count[ref_frame]].comp_mv =
+              comp_list[idx][1];
+          ref_mv_stack[ref_frame][refmv_count[ref_frame]].weight = 2;
+          ++refmv_count[ref_frame];
+        }
+      }
+    }
+
+    assert(refmv_count[ref_frame] >= 2);
+
+    for (int idx = 0; idx < refmv_count[ref_frame]; ++idx) {
+      clamp_mv_ref(&ref_mv_stack[ref_frame][idx].this_mv.as_mv,
+                   xd->n8_w << MI_SIZE_LOG2, xd->n8_h << MI_SIZE_LOG2, xd);
+      clamp_mv_ref(&ref_mv_stack[ref_frame][idx].comp_mv.as_mv,
+                   xd->n8_w << MI_SIZE_LOG2, xd->n8_h << MI_SIZE_LOG2, xd);
+    }
+  } else {
+    // Handle single reference frame extension
+    int mi_width = AOMMIN(mi_size_wide[BLOCK_64X64], xd->n8_w);
+    mi_width = AOMMIN(mi_width, cm->mi_cols - mi_col);
+    int mi_height = AOMMIN(mi_size_high[BLOCK_64X64], xd->n8_h);
+    mi_height = AOMMIN(mi_height, cm->mi_rows - mi_row);
+    int mi_size = AOMMIN(mi_width, mi_height);
+
+    for (int idx = 0; abs(max_row_offset) >= 1 && idx < mi_size &&
+                      refmv_count[ref_frame] < MAX_MV_REF_CANDIDATES;) {
+      const MB_MODE_INFO *const candidate = &xd->mi[-xd->mi_stride + idx];
+      const int candidate_bsize = candidate->sb_type;
+
+      // TODO(jingning): Refactor the following code.
+      for (int rf_idx = 0; rf_idx < 2; ++rf_idx) {
+        if (candidate->ref_frame[rf_idx] > INTRA_FRAME) {
+          int_mv this_mv = candidate->mv[rf_idx];
+          if (cm->ref_frame_sign_bias[candidate->ref_frame[rf_idx]] !=
+              cm->ref_frame_sign_bias[ref_frame]) {
+            this_mv.as_mv.row = -this_mv.as_mv.row;
+            this_mv.as_mv.col = -this_mv.as_mv.col;
+          }
+          int stack_idx;
+          for (stack_idx = 0; stack_idx < refmv_count[ref_frame]; ++stack_idx) {
+            int_mv stack_mv = ref_mv_stack[ref_frame][stack_idx].this_mv;
+            if (this_mv.as_int == stack_mv.as_int) break;
+          }
+
+          if (stack_idx == refmv_count[ref_frame]) {
+            ref_mv_stack[ref_frame][stack_idx].this_mv = this_mv;
+
+            // TODO(jingning): Set an arbitrary small number here. The weight
+            // doesn't matter as long as it is properly initialized.
+            ref_mv_stack[ref_frame][stack_idx].weight = 2;
+            ++refmv_count[ref_frame];
+          }
+        }
+      }
+      idx += mi_size_wide[candidate_bsize];
+    }
+
+    for (int idx = 0; abs(max_col_offset) >= 1 && idx < mi_size &&
+                      refmv_count[ref_frame] < MAX_MV_REF_CANDIDATES;) {
+      const MB_MODE_INFO *const candidate = &xd->mi[idx * xd->mi_stride - 1];
+      const int candidate_bsize = candidate->sb_type;
+
+      // TODO(jingning): Refactor the following code.
+      for (int rf_idx = 0; rf_idx < 2; ++rf_idx) {
+        if (candidate->ref_frame[rf_idx] > INTRA_FRAME) {
+          int_mv this_mv = candidate->mv[rf_idx];
+          if (cm->ref_frame_sign_bias[candidate->ref_frame[rf_idx]] !=
+              cm->ref_frame_sign_bias[ref_frame]) {
+            this_mv.as_mv.row = -this_mv.as_mv.row;
+            this_mv.as_mv.col = -this_mv.as_mv.col;
+          }
+          int stack_idx;
+          for (stack_idx = 0; stack_idx < refmv_count[ref_frame]; ++stack_idx) {
+            int_mv stack_mv = ref_mv_stack[ref_frame][stack_idx].this_mv;
+            if (this_mv.as_int == stack_mv.as_int) break;
+          }
+
+          if (stack_idx == refmv_count[ref_frame]) {
+            ref_mv_stack[ref_frame][stack_idx].this_mv = this_mv;
+
+            // TODO(jingning): Set an arbitrary small number here. The weight
+            // doesn't matter as long as it is properly initialized.
+            ref_mv_stack[ref_frame][stack_idx].weight = 2;
+            ++refmv_count[ref_frame];
+          }
+        }
+      }
+      idx += mi_size_high[candidate_bsize];
+    }
+
+    for (int idx = 0; idx < refmv_count[ref_frame]; ++idx) {
+      clamp_mv_ref(&ref_mv_stack[ref_frame][idx].this_mv.as_mv,
+                   xd->n8_w << MI_SIZE_LOG2, xd->n8_h << MI_SIZE_LOG2, xd);
+    }
+
+    if (mv_ref_list != NULL) {
+      for (int idx = refmv_count[ref_frame]; idx < MAX_MV_REF_CANDIDATES; ++idx)
+        mv_ref_list[rf[0]][idx].as_int = gm_mv_candidates[0].as_int;
+
+      for (int idx = 0;
+           idx < AOMMIN(MAX_MV_REF_CANDIDATES, refmv_count[ref_frame]); ++idx) {
+        mv_ref_list[rf[0]][idx].as_int =
+            ref_mv_stack[ref_frame][idx].this_mv.as_int;
+      }
+    }
+  }
+}
+
+void av1_find_mv_refs(const AV1_COMMON *cm, const MACROBLOCKD *xd,
+                      MB_MODE_INFO *mi, MV_REFERENCE_FRAME ref_frame,
+                      uint8_t ref_mv_count[MODE_CTX_REF_FRAMES],
+                      CANDIDATE_MV ref_mv_stack[][MAX_REF_MV_STACK_SIZE],
+                      int_mv mv_ref_list[][MAX_MV_REF_CANDIDATES],
+                      int_mv *global_mvs, int mi_row, int mi_col,
+                      int16_t *mode_context) {
+  int_mv zeromv[2];
+  BLOCK_SIZE bsize = mi->sb_type;
+  MV_REFERENCE_FRAME rf[2];
+  av1_set_ref_frame(rf, ref_frame);
+
+  if (ref_frame < REF_FRAMES) {
+    if (ref_frame != INTRA_FRAME) {
+      global_mvs[ref_frame] = gm_get_motion_vector(
+          &cm->global_motion[ref_frame], cm->allow_high_precision_mv, bsize,
+          mi_col, mi_row, cm->cur_frame_force_integer_mv);
+    } else {
+      global_mvs[ref_frame].as_int = INVALID_MV;
+    }
+  }
+
+  if (ref_frame != INTRA_FRAME) {
+    zeromv[0].as_int =
+        gm_get_motion_vector(&cm->global_motion[rf[0]],
+                             cm->allow_high_precision_mv, bsize, mi_col, mi_row,
+                             cm->cur_frame_force_integer_mv)
+            .as_int;
+    zeromv[1].as_int =
+        (rf[1] != NONE_FRAME)
+            ? gm_get_motion_vector(&cm->global_motion[rf[1]],
+                                   cm->allow_high_precision_mv, bsize, mi_col,
+                                   mi_row, cm->cur_frame_force_integer_mv)
+                  .as_int
+            : 0;
+  } else {
+    zeromv[0].as_int = zeromv[1].as_int = 0;
+  }
+
+  setup_ref_mv_list(cm, xd, ref_frame, ref_mv_count, ref_mv_stack, mv_ref_list,
+                    zeromv, mi_row, mi_col, mode_context);
+}
+
+void av1_find_best_ref_mvs(int allow_hp, int_mv *mvlist, int_mv *nearest_mv,
+                           int_mv *near_mv, int is_integer) {
+  int i;
+  // Make sure all the candidates are properly clamped etc
+  for (i = 0; i < MAX_MV_REF_CANDIDATES; ++i) {
+    lower_mv_precision(&mvlist[i].as_mv, allow_hp, is_integer);
+  }
+  *nearest_mv = mvlist[0];
+  *near_mv = mvlist[1];
+}
+
+void av1_setup_frame_buf_refs(AV1_COMMON *cm) {
+  cm->cur_frame.cur_frame_offset = cm->frame_offset;
+
+  MV_REFERENCE_FRAME ref_frame;
+  for (ref_frame = LAST_FRAME; ref_frame <= ALTREF_FRAME; ++ref_frame) {
+    const int buf_idx = cm->frame_refs[ref_frame - LAST_FRAME].idx;
+    if (buf_idx >= 0)
+      cm->cur_frame.ref_frame_offset[ref_frame - LAST_FRAME] =
+          cm->buffer_pool.frame_bufs[buf_idx].cur_frame_offset;
+  }
+}
+
+#if 0
+void av1_setup_frame_sign_bias(AV1_COMMON *cm) {
+  MV_REFERENCE_FRAME ref_frame;
+  for (ref_frame = LAST_FRAME; ref_frame <= ALTREF_FRAME; ++ref_frame) {
+    const int buf_idx = cm->frame_refs[ref_frame - LAST_FRAME].idx;
+    if (cm->seq_params.enable_order_hint && buf_idx != INVALID_IDX) {
+      const int ref_frame_offset =
+          cm->buffer_pool->frame_bufs[buf_idx].cur_frame_offset;
+      cm->ref_frame_sign_bias[ref_frame] =
+          (get_relative_dist(cm, ref_frame_offset, (int)cm->frame_offset) <= 0)
+              ? 0
+              : 1;
+    } else {
+      cm->ref_frame_sign_bias[ref_frame] = 0;
+    }
+  }
+}
+#endif
+
+#define MAX_OFFSET_WIDTH 64
+#define MAX_OFFSET_HEIGHT 0
+
+static int get_block_position(AV1_COMMON *cm, int *mi_r, int *mi_c, int blk_row,
+                              int blk_col, MV mv, int sign_bias) {
+  const int base_blk_row = (blk_row >> 3) << 3;
+  const int base_blk_col = (blk_col >> 3) << 3;
+
+  const int row_offset = (mv.row >= 0) ? (mv.row >> (4 + MI_SIZE_LOG2))
+                                       : -((-mv.row) >> (4 + MI_SIZE_LOG2));
+
+  const int col_offset = (mv.col >= 0) ? (mv.col >> (4 + MI_SIZE_LOG2))
+                                       : -((-mv.col) >> (4 + MI_SIZE_LOG2));
+
+  int row = (sign_bias == 1) ? blk_row - row_offset : blk_row + row_offset;
+  int col = (sign_bias == 1) ? blk_col - col_offset : blk_col + col_offset;
+
+  if (row < 0 || row >= (cm->mi_rows >> 1) || col < 0 ||
+      col >= (cm->mi_cols >> 1))
+    return 0;
+
+  if (row < base_blk_row - (MAX_OFFSET_HEIGHT >> 3) ||
+      row >= base_blk_row + 8 + (MAX_OFFSET_HEIGHT >> 3) ||
+      col < base_blk_col - (MAX_OFFSET_WIDTH >> 3) ||
+      col >= base_blk_col + 8 + (MAX_OFFSET_WIDTH >> 3))
+    return 0;
+
+  *mi_r = row;
+  *mi_c = col;
+
+  return 1;
+}
+
+static int motion_field_projection(AV1_COMMON *cm, MV_REFERENCE_FRAME ref_frame,
+                                   int dir,
+                                   const int from_x4, const int to_x4,
+                                   const int from_y4, const int to_y4) {
+  TPL_MV_REF *tpl_mvs_base = cm->tpl_mvs;
+  int ref_offset[TOTAL_REFS_PER_FRAME] = { 0 };
+  int ref_sign[TOTAL_REFS_PER_FRAME] = { 0 };
+
+  (void)dir;
+
+  int ref_frame_idx = cm->frame_refs[FWD_RF_OFFSET(ref_frame)].idx;
+  if (ref_frame_idx < 0) return 0;
+
+  if (cm->buffer_pool.frame_bufs[ref_frame_idx].intra_only) return 0;
+
+  if (cm->buffer_pool.frame_bufs[ref_frame_idx].mi_rows != cm->mi_rows ||
+      cm->buffer_pool.frame_bufs[ref_frame_idx].mi_cols != cm->mi_cols)
+    return 0;
+
+  int ref_frame_index =
+      cm->buffer_pool.frame_bufs[ref_frame_idx].cur_frame_offset;
+  unsigned int *ref_rf_idx =
+      &cm->buffer_pool.frame_bufs[ref_frame_idx].ref_frame_offset[0];
+   int cur_frame_index = cm->cur_frame.cur_frame_offset;
+  int ref_to_cur = get_relative_dist(cm, ref_frame_index, cur_frame_index);
+
+  for (MV_REFERENCE_FRAME rf = LAST_FRAME; rf <= INTER_REFS_PER_FRAME; ++rf) {
+    ref_offset[rf] =
+        get_relative_dist(cm, ref_frame_index, ref_rf_idx[rf - LAST_FRAME]);
+    // note the inverted sign
+    ref_sign[rf] =
+        get_relative_dist(cm, ref_rf_idx[rf - LAST_FRAME], ref_frame_index) < 0;
+  }
+
+  if (dir == 2) ref_to_cur = -ref_to_cur;
+
+  MV_REF *mv_ref_base = cm->buffer_pool.frame_bufs[ref_frame_idx].mvs;
+  const ptrdiff_t mv_stride =
+    cm->buffer_pool.frame_bufs[ref_frame_idx].mv_stride;
+  const int mvs_rows = (cm->mi_rows + 1) >> 1;
+  const int mvs_cols = (cm->mi_cols + 1) >> 1;
+
+  assert(from_y4 >= 0);
+  const int row_start8 = from_y4 >> 1;
+  const int row_end8 = imin(to_y4 >> 1, mvs_rows);
+  const int col_start8 = imax((from_x4 - (MAX_OFFSET_WIDTH >> 2)) >> 1, 0);
+  const int col_end8 = imin((to_x4 + (MAX_OFFSET_WIDTH >> 2)) >> 1, mvs_cols);
+  for (int blk_row = row_start8; blk_row < row_end8; ++blk_row) {
+    for (int blk_col = col_start8; blk_col < col_end8; ++blk_col) {
+      MV_REF *mv_ref = &mv_ref_base[((blk_row << 1) + 1) * mv_stride +
+                                     (blk_col << 1) + 1];
+      int diridx;
+      const int ref0 = mv_ref->ref_frame[0], ref1 = mv_ref->ref_frame[1];
+      if (ref1 > 0 && ref_sign[ref1] &&
+          abs(mv_ref->mv[1].as_mv.row) < (1 << 12) &&
+          abs(mv_ref->mv[1].as_mv.col) < (1 << 12))
+      {
+        diridx = 1;
+      } else if (ref0 > 0 && ref_sign[ref0] &&
+                 abs(mv_ref->mv[0].as_mv.row) < (1 << 12) &&
+                 abs(mv_ref->mv[0].as_mv.col) < (1 << 12))
+      {
+        diridx = 0;
+      } else {
+        continue;
+      }
+      MV fwd_mv = mv_ref->mv[diridx].as_mv;
+
+      if (mv_ref->ref_frame[diridx] > INTRA_FRAME) {
+        int_mv this_mv;
+        int mi_r, mi_c;
+        const int ref_frame_offset = ref_offset[mv_ref->ref_frame[diridx]];
+
+        int pos_valid = abs(ref_frame_offset) <= MAX_FRAME_DISTANCE &&
+                        ref_frame_offset > 0 &&
+                        abs(ref_to_cur) <= MAX_FRAME_DISTANCE;
+
+        if (pos_valid) {
+          get_mv_projection(&this_mv.as_mv, fwd_mv, ref_to_cur,
+                            ref_frame_offset);
+          pos_valid = get_block_position(cm, &mi_r, &mi_c, blk_row, blk_col,
+                                         this_mv.as_mv, dir >> 1);
+        }
+
+        if (pos_valid && mi_c >= (from_x4 >> 1) && mi_c < (to_x4 >> 1)) {
+          int mi_offset = mi_r * (cm->mi_stride >> 1) + mi_c;
+
+          tpl_mvs_base[mi_offset].mfmv0.as_mv.row = fwd_mv.row;
+          tpl_mvs_base[mi_offset].mfmv0.as_mv.col = fwd_mv.col;
+          tpl_mvs_base[mi_offset].ref_frame_offset = ref_frame_offset;
+        }
+      }
+    }
+  }
+
+  return 1;
+}
+
+#if 0
+void av1_setup_motion_field(AV1_COMMON *cm) {
+  memset(cm->ref_frame_side, 0, sizeof(cm->ref_frame_side));
+  if (!cm->seq_params.enable_order_hint) return;
+
+  TPL_MV_REF *tpl_mvs_base = cm->tpl_mvs;
+  int size = ((cm->mi_rows + MAX_MIB_SIZE) >> 1) * (cm->mi_stride >> 1);
+  for (int idx = 0; idx < size; ++idx) {
+    tpl_mvs_base[idx].mfmv0.as_int = INVALID_MV;
+    tpl_mvs_base[idx].ref_frame_offset = 0;
+  }
+
+  const int cur_order_hint = cm->cur_frame.cur_frame_offset;
+  RefCntBuffer *const frame_bufs = cm->buffer_pool->frame_bufs;
+
+  int ref_buf_idx[INTER_REFS_PER_FRAME];
+  int ref_order_hint[INTER_REFS_PER_FRAME];
+
+  for (int ref_frame = LAST_FRAME; ref_frame <= ALTREF_FRAME; ref_frame++) {
+    const int ref_idx = ref_frame - LAST_FRAME;
+    const int buf_idx = cm->frame_refs[ref_idx].idx;
+    int order_hint = 0;
+
+    if (buf_idx >= 0) order_hint = frame_bufs[buf_idx].cur_frame_offset;
+
+    ref_buf_idx[ref_idx] = buf_idx;
+    ref_order_hint[ref_idx] = order_hint;
+
+    if (get_relative_dist(cm, order_hint, cur_order_hint) > 0)
+      cm->ref_frame_side[ref_frame] = 1;
+    else if (order_hint == cur_order_hint)
+      cm->ref_frame_side[ref_frame] = -1;
+  }
+
+  int ref_stamp = MFMV_STACK_SIZE - 1;
+
+  if (ref_buf_idx[LAST_FRAME - LAST_FRAME] >= 0) {
+    const int alt_of_lst_order_hint =
+        frame_bufs[ref_buf_idx[LAST_FRAME - LAST_FRAME]]
+            .ref_frame_offset[ALTREF_FRAME - LAST_FRAME];
+
+    const int is_lst_overlay =
+        (alt_of_lst_order_hint == ref_order_hint[GOLDEN_FRAME - LAST_FRAME]);
+    if (!is_lst_overlay) motion_field_projection(cm, LAST_FRAME, 2);
+    --ref_stamp;
+  }
+
+  if (get_relative_dist(cm, ref_order_hint[BWDREF_FRAME - LAST_FRAME],
+                        cur_order_hint) > 0) {
+    if (motion_field_projection(cm, BWDREF_FRAME, 0)) --ref_stamp;
+  }
+
+  if (get_relative_dist(cm, ref_order_hint[ALTREF2_FRAME - LAST_FRAME],
+                        cur_order_hint) > 0) {
+    if (motion_field_projection(cm, ALTREF2_FRAME, 0)) --ref_stamp;
+  }
+
+  if (get_relative_dist(cm, ref_order_hint[ALTREF_FRAME - LAST_FRAME],
+                        cur_order_hint) > 0 &&
+      ref_stamp >= 0)
+    if (motion_field_projection(cm, ALTREF_FRAME, 0)) --ref_stamp;
+
+  if (ref_stamp >= 0 && ref_buf_idx[LAST2_FRAME - LAST_FRAME] >= 0)
+    if (motion_field_projection(cm, LAST2_FRAME, 2)) --ref_stamp;
+}
+#endif
+
+void av1_setup_motion_field(AV1_COMMON *cm) {
+  if (!cm->seq_params.enable_order_hint) return;
+
+  TPL_MV_REF *tpl_mvs_base = cm->tpl_mvs;
+  int size = (((cm->mi_rows + 31) & ~31) >> 1) * (cm->mi_stride >> 1);
+  for (int idx = 0; idx < size; ++idx) {
+    tpl_mvs_base[idx].mfmv0.as_int = INVALID_MV;
+    tpl_mvs_base[idx].ref_frame_offset = 0;
+  }
+
+  memset(cm->ref_frame_side, 0, sizeof(cm->ref_frame_side));
+  RefCntBuffer *const frame_bufs = cm->buffer_pool.frame_bufs;
+
+  const int cur_order_hint = cm->cur_frame.cur_frame_offset;
+  int *const ref_buf_idx = cm->ref_buf_idx;
+  int *const ref_order_hint = cm->ref_order_hint;
+
+  for (int ref_frame = LAST_FRAME; ref_frame <= ALTREF_FRAME; ref_frame++) {
+    const int ref_idx = ref_frame - LAST_FRAME;
+    const int buf_idx = cm->frame_refs[ref_idx].idx;
+    int order_hint = 0;
+
+    if (buf_idx >= 0) order_hint = frame_bufs[buf_idx].cur_frame_offset;
+
+    ref_buf_idx[ref_idx] = buf_idx;
+    ref_order_hint[ref_idx] = order_hint;
+
+    if (get_relative_dist(cm, order_hint, cur_order_hint) > 0)
+      cm->ref_frame_side[ref_frame] = 1;
+    else if (order_hint == cur_order_hint)
+      cm->ref_frame_side[ref_frame] = -1;
+  }
+}
+
+void av1_fill_motion_field(AV1_COMMON *cm,
+                           const int tile_col_start4, const int tile_col_end4,
+                           const int row_start4, int row_end4)
+{
+  RefCntBuffer *const frame_bufs = cm->buffer_pool.frame_bufs;
+  const int cur_order_hint = cm->cur_frame.cur_frame_offset;
+  int *const ref_buf_idx = cm->ref_buf_idx;
+  int *const ref_order_hint = cm->ref_order_hint;
+
+  int ref_stamp = MFMV_STACK_SIZE - 1;
+
+  if (ref_buf_idx[LAST_FRAME - LAST_FRAME] >= 0) {
+    const int alt_of_lst_order_hint =
+        frame_bufs[ref_buf_idx[LAST_FRAME - LAST_FRAME]]
+            .ref_frame_offset[ALTREF_FRAME - LAST_FRAME];
+
+    const int is_lst_overlay =
+        (alt_of_lst_order_hint == ref_order_hint[GOLDEN_FRAME - LAST_FRAME]);
+      if (!is_lst_overlay) motion_field_projection(cm, LAST_FRAME, 2,
+                                                   tile_col_start4, tile_col_end4,
+                                                   row_start4, row_end4);
+    --ref_stamp;
+  }
+
+  if (get_relative_dist(cm, ref_order_hint[BWDREF_FRAME - LAST_FRAME],
+                        cur_order_hint) > 0) {
+      if (motion_field_projection(cm, BWDREF_FRAME, 0,
+                                  tile_col_start4, tile_col_end4,
+                                  row_start4, row_end4)) --ref_stamp;
+  }
+
+  if (get_relative_dist(cm, ref_order_hint[ALTREF2_FRAME - LAST_FRAME],
+                        cur_order_hint) > 0) {
+      if (motion_field_projection(cm, ALTREF2_FRAME, 0,
+                                  tile_col_start4, tile_col_end4,
+                                  row_start4, row_end4)) --ref_stamp;
+  }
+
+  if (get_relative_dist(cm, ref_order_hint[ALTREF_FRAME - LAST_FRAME],
+                        cur_order_hint) > 0 &&
+      ref_stamp >= 0)
+      if (motion_field_projection(cm, ALTREF_FRAME, 0,
+                                  tile_col_start4, tile_col_end4,
+                                  row_start4, row_end4)) --ref_stamp;
+
+  if (ref_stamp >= 0 && ref_buf_idx[LAST2_FRAME - LAST_FRAME] >= 0)
+      if (motion_field_projection(cm, LAST2_FRAME, 2,
+                                  tile_col_start4, tile_col_end4,
+                                  row_start4, row_end4)) --ref_stamp;
+}
+
+#if 0
+static INLINE void record_samples(MB_MODE_INFO *mbmi, int *pts, int *pts_inref,
+                                  int row_offset, int sign_r, int col_offset,
+                                  int sign_c) {
+  int bw = block_size_wide[mbmi->sb_type];
+  int bh = block_size_high[mbmi->sb_type];
+  int x = col_offset * MI_SIZE + sign_c * AOMMAX(bw, MI_SIZE) / 2 - 1;
+  int y = row_offset * MI_SIZE + sign_r * AOMMAX(bh, MI_SIZE) / 2 - 1;
+
+  pts[0] = (x * 8);
+  pts[1] = (y * 8);
+  pts_inref[0] = (x * 8) + mbmi->mv[0].as_mv.col;
+  pts_inref[1] = (y * 8) + mbmi->mv[0].as_mv.row;
+}
+
+// Select samples according to the motion vector difference.
+int selectSamples(MV *mv, int *pts, int *pts_inref, int len, BLOCK_SIZE bsize) {
+  const int bw = block_size_wide[bsize];
+  const int bh = block_size_high[bsize];
+  const int thresh = clamp(AOMMAX(bw, bh), 16, 112);
+  int pts_mvd[SAMPLES_ARRAY_SIZE] = { 0 };
+  int i, j, k, l = len;
+  int ret = 0;
+  assert(len <= LEAST_SQUARES_SAMPLES_MAX);
+
+  // Obtain the motion vector difference.
+  for (i = 0; i < len; ++i) {
+    pts_mvd[i] = abs(pts_inref[2 * i] - pts[2 * i] - mv->col) +
+                 abs(pts_inref[2 * i + 1] - pts[2 * i + 1] - mv->row);
+
+    if (pts_mvd[i] > thresh)
+      pts_mvd[i] = -1;
+    else
+      ret++;
+  }
+
+  // Keep at least 1 sample.
+  if (!ret) return 1;
+
+  i = 0;
+  j = l - 1;
+  for (k = 0; k < l - ret; k++) {
+    while (pts_mvd[i] != -1) i++;
+    while (pts_mvd[j] == -1) j--;
+    assert(i != j);
+    if (i > j) break;
+
+    // Replace the discarded samples;
+    pts_mvd[i] = pts_mvd[j];
+    pts[2 * i] = pts[2 * j];
+    pts[2 * i + 1] = pts[2 * j + 1];
+    pts_inref[2 * i] = pts_inref[2 * j];
+    pts_inref[2 * i + 1] = pts_inref[2 * j + 1];
+    i++;
+    j--;
+  }
+
+  return ret;
+}
+
+// Note: Samples returned are at 1/8-pel precision
+// Sample are the neighbor block center point's coordinates relative to the
+// left-top pixel of current block.
+int findSamples(const AV1_COMMON *cm, MACROBLOCKD *xd, int mi_row, int mi_col,
+                int *pts, int *pts_inref) {
+  MB_MODE_INFO *const mbmi0 = xd->mi[0];
+  int ref_frame = mbmi0->ref_frame[0];
+  int up_available = xd->up_available;
+  int left_available = xd->left_available;
+  int i, mi_step = 1, np = 0;
+
+  const TileInfo *const tile = &xd->tile;
+  int do_tl = 1;
+  int do_tr = 1;
+
+  // scan the nearest above rows
+  if (up_available) {
+    int mi_row_offset = -1;
+    MB_MODE_INFO *mbmi = xd->mi[mi_row_offset * xd->mi_stride];
+    uint8_t n8_w = mi_size_wide[mbmi->sb_type];
+
+    if (xd->n8_w <= n8_w) {
+      // Handle "current block width <= above block width" case.
+      int col_offset = -mi_col % n8_w;
+
+      if (col_offset < 0) do_tl = 0;
+      if (col_offset + n8_w > xd->n8_w) do_tr = 0;
+
+      if (mbmi->ref_frame[0] == ref_frame && mbmi->ref_frame[1] == NONE_FRAME) {
+        record_samples(mbmi, pts, pts_inref, 0, -1, col_offset, 1);
+        pts += 2;
+        pts_inref += 2;
+        np++;
+        if (np >= LEAST_SQUARES_SAMPLES_MAX) return LEAST_SQUARES_SAMPLES_MAX;
+      }
+    } else {
+      // Handle "current block width > above block width" case.
+      for (i = 0; i < AOMMIN(xd->n8_w, cm->mi_cols - mi_col); i += mi_step) {
+        int mi_col_offset = i;
+        mi = xd->mi[mi_col_offset + mi_row_offset * xd->mi_stride];
+        mbmi = &mi->mbmi;
+        n8_w = mi_size_wide[mbmi->sb_type];
+        mi_step = AOMMIN(xd->n8_w, n8_w);
+
+        if (mbmi->ref_frame[0] == ref_frame &&
+            mbmi->ref_frame[1] == NONE_FRAME) {
+          record_samples(mbmi, pts, pts_inref, 0, -1, i, 1);
+          pts += 2;
+          pts_inref += 2;
+          np++;
+          if (np >= LEAST_SQUARES_SAMPLES_MAX) return LEAST_SQUARES_SAMPLES_MAX;
+        }
+      }
+    }
+  }
+  assert(np <= LEAST_SQUARES_SAMPLES_MAX);
+
+  // scan the nearest left columns
+  if (left_available) {
+    int mi_col_offset = -1;
+
+    MB_MODE_INFO *mi = xd->mi[mi_col_offset];
+    uint8_t n8_h = mi_size_high[mbmi->sb_type];
+
+    if (xd->n8_h <= n8_h) {
+      // Handle "current block height <= above block height" case.
+      int row_offset = -mi_row % n8_h;
+
+      if (row_offset < 0) do_tl = 0;
+
+      if (mbmi->ref_frame[0] == ref_frame && mbmi->ref_frame[1] == NONE_FRAME) {
+        record_samples(mbmi, pts, pts_inref, row_offset, 1, 0, -1);
+        pts += 2;
+        pts_inref += 2;
+        np++;
+        if (np >= LEAST_SQUARES_SAMPLES_MAX) return LEAST_SQUARES_SAMPLES_MAX;
+      }
+    } else {
+      // Handle "current block height > above block height" case.
+      for (i = 0; i < AOMMIN(xd->n8_h, cm->mi_rows - mi_row); i += mi_step) {
+        int mi_row_offset = i;
+        mbmi = xd->mi[mi_col_offset + mi_row_offset * xd->mi_stride];
+        n8_h = mi_size_high[mbmi->sb_type];
+        mi_step = AOMMIN(xd->n8_h, n8_h);
+
+        if (mbmi->ref_frame[0] == ref_frame &&
+            mbmi->ref_frame[1] == NONE_FRAME) {
+          record_samples(mbmi, pts, pts_inref, i, 1, 0, -1);
+          pts += 2;
+          pts_inref += 2;
+          np++;
+          if (np >= LEAST_SQUARES_SAMPLES_MAX) return LEAST_SQUARES_SAMPLES_MAX;
+        }
+      }
+    }
+  }
+  assert(np <= LEAST_SQUARES_SAMPLES_MAX);
+
+  // Top-left block
+  if (do_tl && left_available && up_available) {
+    int mi_row_offset = -1;
+    int mi_col_offset = -1;
+
+    MB_MODE_INFO *mbmi = xd->mi[mi_col_offset + mi_row_offset * xd->mi_stride];
+
+    if (mbmi->ref_frame[0] == ref_frame && mbmi->ref_frame[1] == NONE_FRAME) {
+      record_samples(mbmi, pts, pts_inref, 0, -1, 0, -1);
+      pts += 2;
+      pts_inref += 2;
+      np++;
+      if (np >= LEAST_SQUARES_SAMPLES_MAX) return LEAST_SQUARES_SAMPLES_MAX;
+    }
+  }
+  assert(np <= LEAST_SQUARES_SAMPLES_MAX);
+
+  // Top-right block
+  if (do_tr &&
+      has_top_right(cm, xd, mi_row, mi_col, AOMMAX(xd->n8_w, xd->n8_h))) {
+    POSITION trb_pos = { -1, xd->n8_w };
+
+    if (is_inside(tile, mi_col, mi_row, cm->mi_rows, &trb_pos)) {
+      int mi_row_offset = -1;
+      int mi_col_offset = xd->n8_w;
+
+      MB_MODE_INFO *mbmi =
+          xd->mi[mi_col_offset + mi_row_offset * xd->mi_stride];
+
+      if (mbmi->ref_frame[0] == ref_frame && mbmi->ref_frame[1] == NONE_FRAME) {
+        record_samples(mbmi, pts, pts_inref, 0, -1, xd->n8_w, 1);
+        np++;
+        if (np >= LEAST_SQUARES_SAMPLES_MAX) return LEAST_SQUARES_SAMPLES_MAX;
+      }
+    }
+  }
+  assert(np <= LEAST_SQUARES_SAMPLES_MAX);
+
+  return np;
+}
+
+void av1_setup_skip_mode_allowed(AV1_COMMON *cm) {
+  cm->is_skip_mode_allowed = 0;
+  cm->ref_frame_idx_0 = cm->ref_frame_idx_1 = INVALID_IDX;
+
+  if (!cm->seq_params.enable_order_hint || frame_is_intra_only(cm) ||
+      cm->reference_mode == SINGLE_REFERENCE)
+    return;
+
+  RefCntBuffer *const frame_bufs = cm->buffer_pool->frame_bufs;
+  const int cur_frame_offset = cm->frame_offset;
+  int ref_frame_offset[2] = { -1, INT_MAX };
+  int ref_idx[2] = { INVALID_IDX, INVALID_IDX };
+
+  // Identify the nearest forward and backward references.
+  for (int i = 0; i < INTER_REFS_PER_FRAME; ++i) {
+    const int buf_idx = cm->frame_refs[i].idx;
+    if (buf_idx == INVALID_IDX) continue;
+
+    const int ref_offset = frame_bufs[buf_idx].cur_frame_offset;
+    if (get_relative_dist(cm, ref_offset, cur_frame_offset) < 0) {
+      // Forward reference
+      if (ref_frame_offset[0] == -1 ||
+          get_relative_dist(cm, ref_offset, ref_frame_offset[0]) > 0) {
+        ref_frame_offset[0] = ref_offset;
+        ref_idx[0] = i;
+      }
+    } else if (get_relative_dist(cm, ref_offset, cur_frame_offset) > 0) {
+      // Backward reference
+      if (ref_frame_offset[1] == INT_MAX ||
+          get_relative_dist(cm, ref_offset, ref_frame_offset[1]) < 0) {
+        ref_frame_offset[1] = ref_offset;
+        ref_idx[1] = i;
+      }
+    }
+  }
+
+  if (ref_idx[0] != INVALID_IDX && ref_idx[1] != INVALID_IDX) {
+    // == Bi-directional prediction ==
+    cm->is_skip_mode_allowed = 1;
+    cm->ref_frame_idx_0 = AOMMIN(ref_idx[0], ref_idx[1]);
+    cm->ref_frame_idx_1 = AOMMAX(ref_idx[0], ref_idx[1]);
+  } else if (ref_idx[0] != INVALID_IDX && ref_idx[1] == INVALID_IDX) {
+    // == Forward prediction only ==
+    // Identify the second nearest forward reference.
+    ref_frame_offset[1] = -1;
+    for (int i = 0; i < INTER_REFS_PER_FRAME; ++i) {
+      const int buf_idx = cm->frame_refs[i].idx;
+      if (buf_idx == INVALID_IDX) continue;
+
+      const int ref_offset = frame_bufs[buf_idx].cur_frame_offset;
+      if ((ref_frame_offset[0] != -1 &&
+           get_relative_dist(cm, ref_offset, ref_frame_offset[0]) < 0) &&
+          (ref_frame_offset[1] == -1 ||
+           get_relative_dist(cm, ref_offset, ref_frame_offset[1]) > 0)) {
+        // Second closest forward reference
+        ref_frame_offset[1] = ref_offset;
+        ref_idx[1] = i;
+      }
+    }
+    if (ref_frame_offset[1] != -1) {
+      cm->is_skip_mode_allowed = 1;
+      cm->ref_frame_idx_0 = AOMMIN(ref_idx[0], ref_idx[1]);
+      cm->ref_frame_idx_1 = AOMMAX(ref_idx[0], ref_idx[1]);
+    }
+  }
+}
+
+typedef struct {
+  int map_idx;   // frame map index
+  int buf_idx;   // frame buffer index
+  int sort_idx;  // index based on the offset to be used for sorting
+} REF_FRAME_INFO;
+
+static int compare_ref_frame_info(const void *arg_a, const void *arg_b) {
+  const REF_FRAME_INFO *info_a = (REF_FRAME_INFO *)arg_a;
+  const REF_FRAME_INFO *info_b = (REF_FRAME_INFO *)arg_b;
+
+  if (info_a->sort_idx < info_b->sort_idx) return -1;
+  if (info_a->sort_idx > info_b->sort_idx) return 1;
+  return (info_a->map_idx < info_b->map_idx)
+             ? -1
+             : ((info_a->map_idx > info_b->map_idx) ? 1 : 0);
+}
+
+static void set_ref_frame_info(AV1_COMMON *const cm, int frame_idx,
+                               REF_FRAME_INFO *ref_info) {
+  assert(frame_idx >= 0 && frame_idx <= INTER_REFS_PER_FRAME);
+
+  const int buf_idx = ref_info->buf_idx;
+
+  cm->frame_refs[frame_idx].idx = buf_idx;
+  cm->frame_refs[frame_idx].buf = &cm->buffer_pool->frame_bufs[buf_idx].buf;
+  cm->frame_refs[frame_idx].map_idx = ref_info->map_idx;
+}
+
+void av1_set_frame_refs(AV1_COMMON *const cm, int lst_map_idx,
+                        int gld_map_idx) {
+  BufferPool *const pool = cm->buffer_pool;
+  RefCntBuffer *const frame_bufs = pool->frame_bufs;
+
+  assert(cm->seq_params.enable_order_hint);
+  assert(cm->seq_params.order_hint_bits_minus_1 >= 0);
+  const int cur_frame_offset = (int)cm->frame_offset;
+  const int cur_frame_sort_idx = 1 << cm->seq_params.order_hint_bits_minus_1;
+
+  REF_FRAME_INFO ref_frame_info[REF_FRAMES];
+  int ref_flag_list[INTER_REFS_PER_FRAME] = { 0, 0, 0, 0, 0, 0, 0 };
+
+  for (int i = 0; i < REF_FRAMES; ++i) {
+    const int map_idx = i;
+
+    ref_frame_info[i].map_idx = map_idx;
+    ref_frame_info[i].sort_idx = -1;
+
+    const int buf_idx = cm->ref_frame_map[map_idx];
+    ref_frame_info[i].buf_idx = buf_idx;
+
+    if (buf_idx < 0 || buf_idx >= FRAME_BUFFERS) continue;
+    // TODO(zoeliu@google.com): To verify the checking on ref_count.
+    if (frame_bufs[buf_idx].ref_count <= 0) continue;
+
+    const int offset = (int)frame_bufs[buf_idx].cur_frame_offset;
+    ref_frame_info[i].sort_idx =
+        (offset == -1) ? -1
+                       : cur_frame_sort_idx +
+                             get_relative_dist(cm, offset, cur_frame_offset);
+    assert(ref_frame_info[i].sort_idx >= -1);
+
+    if (map_idx == lst_map_idx) lst_frame_sort_idx = ref_frame_info[i].sort_idx;
+    if (map_idx == gld_map_idx) gld_frame_sort_idx = ref_frame_info[i].sort_idx;
+  }
+
+  // Confirm both LAST_FRAME and GOLDEN_FRAME are valid forward reference
+  // frames.
+  if (lst_frame_sort_idx == -1 || lst_frame_sort_idx >= cur_frame_sort_idx) {
+    aom_internal_error(&cm->error, AOM_CODEC_CORRUPT_FRAME,
+                       "Inter frame requests a look-ahead frame as LAST");
+  }
+  if (gld_frame_sort_idx == -1 || gld_frame_sort_idx >= cur_frame_sort_idx) {
+    aom_internal_error(&cm->error, AOM_CODEC_CORRUPT_FRAME,
+                       "Inter frame requests a look-ahead frame as GOLDEN");
+  }
+
+  // Sort ref frames based on their frame_offset values.
+  qsort(ref_frame_info, REF_FRAMES, sizeof(REF_FRAME_INFO),
+        compare_ref_frame_info);
+
+  // Identify forward and backward reference frames.
+  // Forward  reference: offset < cur_frame_offset
+  // Backward reference: offset >= cur_frame_offset
+  int fwd_start_idx = 0, fwd_end_idx = REF_FRAMES - 1;
+
+  for (int i = 0; i < REF_FRAMES; i++) {
+    if (ref_frame_info[i].sort_idx == -1) {
+      fwd_start_idx++;
+      continue;
+    }
+
+    if (ref_frame_info[i].sort_idx >= cur_frame_sort_idx) {
+      fwd_end_idx = i - 1;
+      break;
+    }
+  }
+
+  int bwd_start_idx = fwd_end_idx + 1;
+  int bwd_end_idx = REF_FRAMES - 1;
+
+  // === Backward Reference Frames ===
+
+  // == ALTREF_FRAME ==
+  if (bwd_start_idx <= bwd_end_idx) {
+    set_ref_frame_info(cm, ALTREF_FRAME - LAST_FRAME,
+                       &ref_frame_info[bwd_end_idx]);
+    ref_flag_list[ALTREF_FRAME - LAST_FRAME] = 1;
+    bwd_end_idx--;
+  }
+
+  // == BWDREF_FRAME ==
+  if (bwd_start_idx <= bwd_end_idx) {
+    set_ref_frame_info(cm, BWDREF_FRAME - LAST_FRAME,
+                       &ref_frame_info[bwd_start_idx]);
+    ref_flag_list[BWDREF_FRAME - LAST_FRAME] = 1;
+    bwd_start_idx++;
+  }
+
+  // == ALTREF2_FRAME ==
+  if (bwd_start_idx <= bwd_end_idx) {
+    set_ref_frame_info(cm, ALTREF2_FRAME - LAST_FRAME,
+                       &ref_frame_info[bwd_start_idx]);
+    ref_flag_list[ALTREF2_FRAME - LAST_FRAME] = 1;
+  }
+
+  // === Forward Reference Frames ===
+
+  for (int i = fwd_start_idx; i <= fwd_end_idx; ++i) {
+    // == LAST_FRAME ==
+    if (ref_frame_info[i].map_idx == lst_map_idx) {
+      set_ref_frame_info(cm, LAST_FRAME - LAST_FRAME, &ref_frame_info[i]);
+      ref_flag_list[LAST_FRAME - LAST_FRAME] = 1;
+    }
+
+    // == GOLDEN_FRAME ==
+    if (ref_frame_info[i].map_idx == gld_map_idx) {
+      set_ref_frame_info(cm, GOLDEN_FRAME - LAST_FRAME, &ref_frame_info[i]);
+      ref_flag_list[GOLDEN_FRAME - LAST_FRAME] = 1;
+    }
+  }
+
+  assert(ref_flag_list[LAST_FRAME - LAST_FRAME] == 1 &&
+         ref_flag_list[GOLDEN_FRAME - LAST_FRAME] == 1);
+
+  // == LAST2_FRAME ==
+  // == LAST3_FRAME ==
+  // == BWDREF_FRAME ==
+  // == ALTREF2_FRAME ==
+  // == ALTREF_FRAME ==
+
+  // Set up the reference frames in the anti-chronological order.
+  static const MV_REFERENCE_FRAME ref_frame_list[INTER_REFS_PER_FRAME - 2] = {
+    LAST2_FRAME, LAST3_FRAME, BWDREF_FRAME, ALTREF2_FRAME, ALTREF_FRAME
+  };
+
+  int ref_idx;
+  for (ref_idx = 0; ref_idx < (INTER_REFS_PER_FRAME - 2); ref_idx++) {
+    const MV_REFERENCE_FRAME ref_frame = ref_frame_list[ref_idx];
+
+    if (ref_flag_list[ref_frame - LAST_FRAME] == 1) continue;
+
+    while (fwd_start_idx <= fwd_end_idx &&
+           (ref_frame_info[fwd_end_idx].map_idx == lst_map_idx ||
+            ref_frame_info[fwd_end_idx].map_idx == gld_map_idx)) {
+      fwd_end_idx--;
+    }
+    if (fwd_start_idx > fwd_end_idx) break;
+
+    set_ref_frame_info(cm, ref_frame - LAST_FRAME,
+                       &ref_frame_info[fwd_end_idx]);
+    ref_flag_list[ref_frame - LAST_FRAME] = 1;
+
+    fwd_end_idx--;
+  }
+
+  // Assign all the remaining frame(s), if any, to the earliest reference frame.
+  for (; ref_idx < (INTER_REFS_PER_FRAME - 2); ref_idx++) {
+    const MV_REFERENCE_FRAME ref_frame = ref_frame_list[ref_idx];
+    if (ref_flag_list[ref_frame - LAST_FRAME] == 1) continue;
+    set_ref_frame_info(cm, ref_frame - LAST_FRAME,
+                       &ref_frame_info[fwd_start_idx]);
+    ref_flag_list[ref_frame - LAST_FRAME] = 1;
+  }
+
+  for (int i = 0; i < INTER_REFS_PER_FRAME; i++) {
+    assert(ref_flag_list[i] == 1);
+  }
+}
+#endif
+
+enum BlockSize {
+    BS_128x128,
+    BS_128x64,
+    BS_64x128,
+    BS_64x64,
+    BS_64x32,
+    BS_64x16,
+    BS_32x64,
+    BS_32x32,
+    BS_32x16,
+    BS_32x8,
+    BS_16x64,
+    BS_16x32,
+    BS_16x16,
+    BS_16x8,
+    BS_16x4,
+    BS_8x32,
+    BS_8x16,
+    BS_8x8,
+    BS_8x4,
+    BS_4x16,
+    BS_4x8,
+    BS_4x4,
+    N_BS_SIZES,
+};
+extern const uint8_t av1_block_dimensions[N_BS_SIZES][4];
+const uint8_t bs_to_sbtype[N_BS_SIZES] = {
+    [BS_128x128] = BLOCK_128X128,
+    [BS_128x64] = BLOCK_128X64,
+    [BS_64x128] = BLOCK_64X128,
+    [BS_64x64] = BLOCK_64X64,
+    [BS_64x32] = BLOCK_64X32,
+    [BS_64x16] = BLOCK_64X16,
+    [BS_32x64] = BLOCK_32X64,
+    [BS_32x32] = BLOCK_32X32,
+    [BS_32x16] = BLOCK_32X16,
+    [BS_32x8] = BLOCK_32X8,
+    [BS_16x64] = BLOCK_16X64,
+    [BS_16x32] = BLOCK_16X32,
+    [BS_16x16] = BLOCK_16X16,
+    [BS_16x8] = BLOCK_16X8,
+    [BS_16x4] = BLOCK_16X4,
+    [BS_8x32] = BLOCK_8X32,
+    [BS_8x16] = BLOCK_8X16,
+    [BS_8x8] = BLOCK_8X8,
+    [BS_8x4] = BLOCK_8X4,
+    [BS_4x16] = BLOCK_4X16,
+    [BS_4x8] = BLOCK_4X8,
+    [BS_4x4] = BLOCK_4X4,
+};
+const uint8_t sbtype_to_bs[BLOCK_SIZES_ALL] = {
+    [BLOCK_128X128] = BS_128x128,
+    [BLOCK_128X64] = BS_128x64,
+    [BLOCK_64X128] = BS_64x128,
+    [BLOCK_64X64] = BS_64x64,
+    [BLOCK_64X32] = BS_64x32,
+    [BLOCK_64X16] = BS_64x16,
+    [BLOCK_32X64] = BS_32x64,
+    [BLOCK_32X32] = BS_32x32,
+    [BLOCK_32X16] = BS_32x16,
+    [BLOCK_32X8] = BS_32x8,
+    [BLOCK_16X64] = BS_16x64,
+    [BLOCK_16X32] = BS_16x32,
+    [BLOCK_16X16] = BS_16x16,
+    [BLOCK_16X8] = BS_16x8,
+    [BLOCK_16X4] = BS_16x4,
+    [BLOCK_8X32] = BS_8x32,
+    [BLOCK_8X16] = BS_8x16,
+    [BLOCK_8X8] = BS_8x8,
+    [BLOCK_8X4] = BS_8x4,
+    [BLOCK_4X16] = BS_4x16,
+    [BLOCK_4X8] = BS_4x8,
+    [BLOCK_4X4] = BS_4x4,
+};
+
+static inline struct MV av1_clamp_mv(const struct MV mv,
+                                    const int bx4, const int by4,
+                                    const int bw4, const int bh4,
+                                    const int iw4, const int ih4)
+{
+    const int left = -(bx4 + bw4 + 4) * 4 * 8;
+    const int right = (iw4 - bx4 + 0 * bw4 + 4) * 4 * 8;
+    const int top = -(by4 + bh4 + 4) * 4 * 8;
+    const int bottom = (ih4 - by4 + 0 * bh4 + 4) * 4 * 8;
+
+    return (struct MV) { .col = iclip(mv.col, left, right),
+                         .row = iclip(mv.row, top, bottom) };
+}
+
+#include <stdio.h>
+
+void av1_find_ref_mvs(CANDIDATE_MV *mvstack, int *cnt, int_mv (*mvlist)[2],
+                      int *ctx, int refidx_dav1d[2],
+                      int w4, int h4, int bs, int bp, int by4, int bx4,
+                      int tile_col_start4, int tile_col_end4,
+                      int tile_row_start4, int tile_row_end4,
+                      AV1_COMMON *cm)
+{
+    const int bw4 = av1_block_dimensions[bs][0];
+    const int bh4 = av1_block_dimensions[bs][1];
+    int stride = cm->cur_frame.mv_stride;
+    MACROBLOCKD xd = (MACROBLOCKD) {
+        .n8_w = bw4,
+        .n8_h = bh4,
+        .mi_stride = stride,
+        .up_available = by4 > tile_row_start4,
+        .left_available = bx4 > tile_col_start4,
+        .tile = {
+            .mi_col_end = AOMMIN(w4, tile_col_end4),
+            .mi_row_end = AOMMIN(h4, tile_row_end4),
+            .tg_horz_boundary = 0,
+            .mi_row_start = tile_row_start4,
+            .mi_col_start = tile_col_start4,
+        },
+        .mi = (MB_MODE_INFO *) &cm->cur_frame.mvs[by4 * stride + bx4],
+        .mb_to_bottom_edge = (h4 - bh4 - by4) * 32,
+        .mb_to_left_edge = -bx4 * 32,
+        .mb_to_right_edge = (w4 - bw4 - bx4) * 32,
+        .mb_to_top_edge = -by4 * 32,
+        .is_sec_rect = 0,
+        .cur_mi = {
+            .partition = bp,
+        },
+    };
+    xd.mi->sb_type = bs_to_sbtype[bs];
+    if (xd.n8_w < xd.n8_h) {
+        // Only mark is_sec_rect as 1 for the last block.
+        // For PARTITION_VERT_4, it would be (0, 0, 0, 1);
+        // For other partitions, it would be (0, 1).
+        if (!((bx4 + xd.n8_w) & (xd.n8_h - 1))) xd.is_sec_rect = 1;
+    }
+
+    if (xd.n8_w > xd.n8_h)
+        if (by4 & (xd.n8_w - 1)) xd.is_sec_rect = 1;
+
+    MV_REFERENCE_FRAME rf[2] = { refidx_dav1d[0] + 1, refidx_dav1d[1] + 1 };
+    const int refidx = av1_ref_frame_type(rf);
+    int16_t single_context[MODE_CTX_REF_FRAMES];
+    uint8_t mv_cnt[MODE_CTX_REF_FRAMES] = { 0 };
+    CANDIDATE_MV mv_stack[MODE_CTX_REF_FRAMES][MAX_REF_MV_STACK_SIZE];
+    memset(mv_stack, 0, sizeof(mv_stack));
+    int_mv mv_list[MODE_CTX_REF_FRAMES][MAX_MV_REF_CANDIDATES] = { { { 0 } } };
+    int_mv gmvs[MODE_CTX_REF_FRAMES];
+#if 0
+    void av1_find_mv_refs(const AV1_COMMON *cm, const MACROBLOCKD *xd,
+                          MB_MODE_INFO *mi, MV_REFERENCE_FRAME ref_frame,
+                          uint8_t ref_mv_count[MODE_CTX_REF_FRAMES],
+                          CANDIDATE_MV ref_mv_stack[][MAX_REF_MV_STACK_SIZE],
+                          int_mv mv_ref_list[][MAX_MV_REF_CANDIDATES],
+                          int_mv *global_mvs, int mi_row, int mi_col,
+                          int16_t *mode_context)
+#endif
+    av1_find_mv_refs(cm, &xd, xd.mi, refidx, mv_cnt,
+                     mv_stack, mv_list, gmvs, by4, bx4,
+                     single_context);
+#if !defined(NDEBUG)
+    if (refidx_dav1d[1] == -1 && mv_cnt[refidx] >= 1) {
+        int_mv tmpa = { .as_int = mv_stack[refidx][0].this_mv.as_int };
+        clamp_mv_ref(&tmpa.as_mv, bw4 * 4, bh4 * 4, &xd);
+        int_mv tmp1 = { .as_mv =
+                 av1_clamp_mv(mv_stack[refidx][0].this_mv.as_mv,
+                              bx4, by4, bw4, bh4, w4, h4) };
+        assert(tmpa.as_int == tmp1.as_int);
+        assert(tmp1.as_int == mv_list[refidx][0].as_int);
+        if (mv_cnt[refidx] >= 2) {
+            int_mv tmpb = { .as_int = mv_stack[refidx][1].this_mv.as_int };
+            clamp_mv_ref(&tmpb.as_mv, bw4 * 4, bh4 * 4, &xd);
+            int_mv tmp2 = { .as_mv =
+                     av1_clamp_mv(mv_stack[refidx][1].this_mv.as_mv,
+                                  bx4, by4, bw4, bh4, w4, h4) };
+            assert(tmp2.as_int == tmpb.as_int);
+            assert(tmp2.as_int == mv_list[refidx][1].as_int);
+        }
+    }
+#endif
+    for (int i = 0; i < mv_cnt[refidx]; i++)
+        mvstack[i] = mv_stack[refidx][i];
+    *cnt = mv_cnt[refidx];
+
+    mvlist[0][0] = mv_list[refidx_dav1d[0] + 1][0];
+    mvlist[0][1] = mv_list[refidx_dav1d[0] + 1][1];
+    if (refidx_dav1d[1] != -1) {
+        mvlist[1][0] = mv_list[refidx_dav1d[1] + 1][0];
+        mvlist[1][1] = mv_list[refidx_dav1d[1] + 1][1];
+    }
+
+    if (ctx) {
+        if (refidx_dav1d[1] == -1)
+            *ctx = single_context[refidx_dav1d[0] + 1];
+        else
+            *ctx = av1_mode_context_analyzer(single_context, rf);
+    }
+
+    if (0 && bx4 == 38 && by4 == 15 && cm->frame_offset == 3 &&
+        refidx_dav1d[1] == -1 && refidx_dav1d[0] == 4 &&
+        bw4 == 1 && bh4 == 1 && bp == 3)
+    {
+        MV_REF *l = bx4 ? &cm->cur_frame.mvs[by4*stride+bx4-1] : NULL;
+        MV_REF *a = by4 ? &cm->cur_frame.mvs[by4*stride+bx4-stride] : NULL;
+        printf("Input: left=[0]y:%d,x:%d,r:%d,[1]y:%d,x:%d,r:%d,mode=%d, "
+               "above=[0]y:%d,x:%d,r:%d,[1]y:%d,x:%d,r:%d,mode=%d, "
+               "temp=y:%d,x:%d,r:%d [use_ref=%d]\n",
+               l ? l->mv[0].as_mv.row : -1,
+               l ? l->mv[0].as_mv.col : -1,
+               l ? l->ref_frame[0]: -1,
+               l ? l->mv[1].as_mv.row : -1,
+               l ? l->mv[1].as_mv.col : -1,
+               l ? l->ref_frame[1]: -1,
+               l ? l->mode : -1,
+               a ? a->mv[0].as_mv.row: -1,
+               a ? a->mv[0].as_mv.col : -1,
+               a ? a->ref_frame[0] : -1,
+               a ? a->mv[1].as_mv.row: -1,
+               a ? a->mv[1].as_mv.col : -1,
+               a ? a->ref_frame[1] : -1,
+               a ? a->mode : -1,
+               cm->tpl_mvs[(by4 >> 1) * (cm->mi_stride >> 1) + (bx4 >> 1)].mfmv0.as_mv.row,
+               cm->tpl_mvs[(by4 >> 1) * (cm->mi_stride >> 1) + (bx4 >> 1)].mfmv0.as_mv.col,
+               cm->tpl_mvs[(by4 >> 1) * (cm->mi_stride >> 1) +
+                           (bx4 >> 1)].ref_frame_offset,
+               cm->allow_ref_frame_mvs);
+        printf("Edges: l=%d,t=%d,r=%d,b=%d,w=%d,h=%d,border=%d\n",
+               xd.mb_to_left_edge,
+               xd.mb_to_top_edge,
+               xd.mb_to_right_edge,
+               xd.mb_to_bottom_edge,
+               xd.n8_w << MI_SIZE_LOG2,
+               xd.n8_h << MI_SIZE_LOG2,
+               MV_BORDER);
+        printf("bp=%d, x=%d, y=%d, refs=%d/%d, n_mvs: %d, "
+               "first mv: y=%d,x=%d | y=%d,x=%d, "
+               "first comp mv: y=%d,x=%d | y=%d,x=%d, "
+               "second mv: y=%d, x=%d | y=%d, x=%d, "
+               "second comp mv: y=%d, x=%d | y=%d, x=%d, "
+               "third mv: y=%d, x=%d, "
+               "ctx=%d\n",
+               bp, bx4, by4, refidx_dav1d[0], refidx_dav1d[1], mv_cnt[refidx],
+               mv_stack[refidx][0].this_mv.as_mv.row,
+               mv_stack[refidx][0].this_mv.as_mv.col,
+               mv_list[refidx_dav1d[0] + 1][0].as_mv.row,
+               mv_list[refidx_dav1d[0] + 1][0].as_mv.col,
+               mv_stack[refidx][0].comp_mv.as_mv.row,
+               mv_stack[refidx][0].comp_mv.as_mv.col,
+               mv_list[refidx_dav1d[1] + 1][0].as_mv.row,
+               mv_list[refidx_dav1d[1] + 1][0].as_mv.col,
+               mv_stack[refidx][1].this_mv.as_mv.row,
+               mv_stack[refidx][1].this_mv.as_mv.col,
+               mv_list[refidx_dav1d[0] + 1][1].as_mv.row,
+               mv_list[refidx_dav1d[0] + 1][1].as_mv.col,
+               mv_stack[refidx][1].comp_mv.as_mv.row,
+               mv_stack[refidx][1].comp_mv.as_mv.col,
+               mv_list[refidx_dav1d[1] + 1][1].as_mv.row,
+               mv_list[refidx_dav1d[1] + 1][1].as_mv.col,
+               mv_stack[refidx][2].this_mv.as_mv.row,
+               mv_stack[refidx][2].this_mv.as_mv.col,
+               *ctx);
+    }
+}
+
+void av1_init_ref_mv_common(AV1_COMMON *cm,
+                            const int w8, const int h8,
+                            const ptrdiff_t stride,
+                            const int allow_sb128,
+                            MV_REF *cur,
+                            MV_REF *ref_mvs[7],
+                            const unsigned cur_poc,
+                            const unsigned ref_poc[7],
+                            const unsigned ref_ref_poc[7][7],
+                            const WarpedMotionParams gmv[7],
+                            const int allow_hp,
+                            const int force_int_mv,
+                            const int allow_ref_frame_mvs,
+                            const int order_hint)
+{
+    if (cm->mi_cols != (w8 << 1) || cm->mi_rows != (h8 << 1)) {
+        const int align_h = (h8 + 15) & ~15;
+        if (cm->tpl_mvs) free(cm->tpl_mvs);
+        cm->tpl_mvs = malloc(sizeof(*cm->tpl_mvs) * (stride >> 1) * align_h);
+        for (int i = 0; i < 7; i++)
+            cm->frame_refs[i].idx = i;
+        cm->mi_cols = w8 << 1;
+        cm->mi_rows = h8 << 1;
+        cm->mi_stride = stride;
+        for (int i = 0; i < 7; i++) {
+            cm->buffer_pool.frame_bufs[i].mi_rows = cm->mi_rows;
+            cm->buffer_pool.frame_bufs[i].mi_cols = cm->mi_cols;
+            cm->buffer_pool.frame_bufs[i].mv_stride = stride;
+        }
+        cm->cur_frame.mv_stride = stride;
+    }
+
+    cm->allow_high_precision_mv = allow_hp;
+    cm->seq_params.sb_size = allow_sb128 ? BLOCK_128X128 : BLOCK_64X64;
+
+    cm->seq_params.enable_order_hint = !!order_hint;
+    cm->seq_params.order_hint_bits_minus1 = order_hint - 1;
+    // FIXME get these from the sequence/frame headers instead of hardcoding
+    cm->frame_parallel_decode = 0;
+    cm->cur_frame_force_integer_mv = force_int_mv;
+
+    memcpy(&cm->global_motion[1], gmv, sizeof(*gmv) * 7);
+
+    cm->frame_offset = cur_poc;
+    cm->allow_ref_frame_mvs = allow_ref_frame_mvs;
+    cm->cur_frame.mvs = cur;
+    for (int i = 0; i < 7; i++) {
+        cm->buffer_pool.frame_bufs[i].mvs = ref_mvs[i];
+        cm->buffer_pool.frame_bufs[i].intra_only = ref_mvs[i] == NULL;
+        cm->buffer_pool.frame_bufs[i].cur_frame_offset = ref_poc[i];
+        for (int j = 0; j < 7; j++)
+            cm->buffer_pool.frame_bufs[i].ref_frame_offset[j] =
+                ref_ref_poc[i][j];
+    }
+    av1_setup_frame_buf_refs(cm);
+    for (int i = 0; i < 7; i++) {
+        const int ref_poc = cm->buffer_pool.frame_bufs[i].cur_frame_offset;
+        cm->ref_frame_sign_bias[1 + i] = get_relative_dist(cm, ref_poc, cur_poc) > 0;
+    }
+    av1_setup_motion_field(cm);
+}
+
+void av1_init_ref_mv_tile_row(AV1_COMMON *cm,
+                              int tile_col_start4, int tile_col_end4,
+                              int row_start4, int row_end4)
+{
+    av1_fill_motion_field(cm, tile_col_start4, tile_col_end4,
+                          row_start4, row_end4);
+}
+
+AV1_COMMON *av1_alloc_ref_mv_common(void) {
+    AV1_COMMON *cm = malloc(sizeof(*cm));
+    memset(cm, 0, sizeof(*cm));
+    return cm;
+}
+
+void av1_free_ref_mv_common(AV1_COMMON *cm) {
+    if (cm->tpl_mvs) free(cm->tpl_mvs);
+    free(cm);
+}
diff --git a/src/ref_mvs.h b/src/ref_mvs.h
new file mode 100644
index 0000000..743ffb9
--- /dev/null
+++ b/src/ref_mvs.h
@@ -0,0 +1,185 @@
+/*
+ * Copyright (c) 2001-2016, Alliance for Open Media. All rights reserved
+ *
+ * This source code is subject to the terms of the BSD 2 Clause License and
+ * the Alliance for Open Media Patent License 1.0. If the BSD 2 Clause License
+ * was not distributed with this source code in the LICENSE file, you can
+ * obtain it at www.aomedia.org/license/software. If the Alliance for Open
+ * Media Patent License 1.0 was not distributed with this source code in the
+ * PATENTS file, you can obtain it at www.aomedia.org/license/patent.
+ */
+
+#ifndef __DAV1D_SRC_REF_MVS_H__
+#define __DAV1D_SRC_REF_MVS_H__
+
+#include <stddef.h>
+
+#include "src/levels.h"
+#include "src/tables.h"
+
+typedef struct refmvs {
+    mv mv[2];
+    int8_t ref[2]; // [0] = 0: intra=1, [1] = -1: comp=0
+    int8_t mode, sb_type;
+} refmvs;
+
+typedef struct candidate_mv {
+    mv this_mv;
+    mv comp_mv;
+    int weight;
+} candidate_mv;
+
+typedef struct AV1_COMMON AV1_COMMON;
+
+// call once per frame thread
+AV1_COMMON *av1_alloc_ref_mv_common(void);
+void av1_free_ref_mv_common(AV1_COMMON *cm);
+
+// call once per frame
+void av1_init_ref_mv_common(AV1_COMMON *cm,
+                            int w8, int h8,
+                            ptrdiff_t stride,
+                            int allow_sb128,
+                            refmvs *cur,
+                            refmvs *ref_mvs[7],
+                            unsigned cur_poc,
+                            const unsigned ref_poc[7],
+                            const unsigned ref_ref_poc[7][7],
+                            const WarpedMotionParams gmv[7],
+                            int allow_hp, int force_int_mv,
+                            int allow_ref_frame_mvs, int order_hint);
+
+// call for start of each sbrow per tile
+void av1_init_ref_mv_tile_row(AV1_COMMON *cm,
+                              int tile_col_start4, int tile_col_end4,
+                              int row_start4, int row_end4);
+
+// call for each block
+void av1_find_ref_mvs(candidate_mv *mvstack, int *cnt, mv (*mvlist)[2],
+                      int *ctx, int refidx[2], int w4, int h4,
+                      enum BlockSize bs, enum BlockPartition bp,
+                      int by4, int bx4, int tile_col_start4,
+                      int tile_col_end4, int tile_row_start4,
+                      int tile_row_end4, AV1_COMMON *cm);
+
+extern const uint8_t bs_to_sbtype[];
+extern const uint8_t sbtype_to_bs[];
+static inline void splat_oneref_mv(refmvs *r, const ptrdiff_t stride,
+                                   const int by4, const int bx4,
+                                   const enum BlockSize bs,
+                                   const enum InterPredMode mode,
+                                   const int ref, const mv mv,
+                                   const int is_interintra)
+{
+    const int bw4 = av1_block_dimensions[bs][0];
+    int bh4 = av1_block_dimensions[bs][1];
+
+    r += by4 * stride + bx4;
+    const refmvs tmpl = (refmvs) {
+        .ref = { ref + 1, is_interintra ? 0 : -1 },
+        .mv = { mv },
+        .sb_type = bs_to_sbtype[bs],
+        .mode = N_INTRA_PRED_MODES + mode,
+    };
+    do {
+        for (int x = 0; x < bw4; x++)
+            r[x] = tmpl;
+        r += stride;
+    } while (--bh4);
+}
+
+static inline void splat_intrabc_mv(refmvs *r, const ptrdiff_t stride,
+                                    const int by4, const int bx4,
+                                    const enum BlockSize bs, const mv mv)
+{
+    const int bw4 = av1_block_dimensions[bs][0];
+    int bh4 = av1_block_dimensions[bs][1];
+
+    r += by4 * stride + bx4;
+    const refmvs tmpl = (refmvs) {
+        .ref = { 0, -1 },
+        .mv = { mv },
+        .sb_type = bs_to_sbtype[bs],
+        .mode = DC_PRED,
+    };
+    do {
+        for (int x = 0; x < bw4; x++)
+            r[x] = tmpl;
+        r += stride;
+    } while (--bh4);
+}
+
+static inline void splat_tworef_mv(refmvs *r, const ptrdiff_t stride,
+                                   const int by4, const int bx4,
+                                   const enum BlockSize bs,
+                                   const enum CompInterPredMode mode,
+                                   const int ref1, const int ref2,
+                                   const mv mv1, const mv mv2)
+{
+    const int bw4 = av1_block_dimensions[bs][0];
+    int bh4 = av1_block_dimensions[bs][1];
+
+    r += by4 * stride + bx4;
+    const refmvs tmpl = (refmvs) {
+        .ref = { ref1 + 1, ref2 + 1 },
+        .mv = { mv1, mv2 },
+        .sb_type = bs_to_sbtype[bs],
+        .mode = N_INTRA_PRED_MODES + N_INTER_PRED_MODES + mode,
+    };
+    do {
+        for (int x = 0; x < bw4; x++)
+            r[x] = tmpl;
+        r += stride;
+    } while (--bh4);
+}
+
+static inline void splat_intraref(refmvs *r, const ptrdiff_t stride,
+                                  const int by4, const int bx4,
+                                  const enum BlockSize bs,
+                                  const enum IntraPredMode mode)
+{
+    const int bw4 = av1_block_dimensions[bs][0];
+    int bh4 = av1_block_dimensions[bs][1];
+
+    r += by4 * stride + bx4;
+    do {
+        int x;
+
+        for (x = 0; x < bw4; x++)
+            r[x] = (refmvs) {
+                .ref = { 0, -1 },
+                .mv = { [0] = { .y = -0x8000, .x = -0x8000 }, },
+                .sb_type = bs_to_sbtype[bs],
+                .mode = mode,
+            };
+        r += stride;
+    } while (--bh4);
+}
+
+// FIXME integer_mv
+static inline void unset_hp_bit(mv *const a) {
+    if (a->x & 1) {
+        if (a->x < 0) a->x++;
+        else          a->x--;
+    }
+    if (a->y & 1) {
+        if (a->y < 0) a->y++;
+        else          a->y--;
+    }
+}
+
+static inline mv av1_clamp_mv(const mv mv,
+                              const int bx4, const int by4,
+                              const int bw4, const int bh4,
+                              const int iw4, const int ih4)
+{
+    const int left = -(bx4 + bw4 + 4) * 4 * 8;
+    const int right = (iw4 - bx4 + 0 * bw4 + 4) * 4 * 8;
+    const int top = -(by4 + bh4 + 4) * 4 * 8;
+    const int bottom = (ih4 - by4 + 0 * bh4 + 4) * 4 * 8;
+
+    return (struct mv) { .x = iclip(mv.x, left, right),
+                         .y = iclip(mv.y, top, bottom) };
+}
+
+#endif /* __DAV1D_SRC_REF_MVS_H__ */
diff --git a/src/scan.c b/src/scan.c
new file mode 100644
index 0000000..942ffa5
--- /dev/null
+++ b/src/scan.c
@@ -0,0 +1,527 @@
+/*
+ * Copyright © 2018, VideoLAN and dav1d authors
+ * Copyright © 2018, Two Orioles, LLC
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright notice, this
+ *    list of conditions and the following disclaimer.
+ *
+ * 2. Redistributions in binary form must reproduce the above copyright notice,
+ *    this list of conditions and the following disclaimer in the documentation
+ *    and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
+ * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#include "config.h"
+
+#include "src/scan.h"
+
+static const int16_t av1_default_scan_4x4[] __attribute__((aligned(32))) = {
+     0,  4,  1,  2,
+     5,  8, 12,  9,
+     6,  3,  7, 10,
+    13, 14, 11, 15,
+};
+static const int16_t av1_mrow_scan_4x4[] __attribute__((aligned(32))) = {
+     0,  4,  8, 12,
+     1,  5,  9, 13,
+     2,  6, 10, 14,
+     3,  7, 11, 15,
+};
+static const int16_t av1_mcol_scan_4x4[] __attribute__((aligned(32))) = {
+     0,  1,  2,  3,
+     4,  5,  6,  7,
+     8,  9, 10, 11,
+    12, 13, 14, 15,
+};
+static const int16_t av1_default_scan_4x8[] __attribute__((aligned(32))) = {
+     0,  8,  1, 16,
+     9,  2, 24, 17,
+    10,  3, 25, 18,
+    11,  4, 26, 19,
+    12,  5, 27, 20,
+    13,  6, 28, 21,
+    14,  7, 29, 22,
+    15, 30, 23, 31,
+};
+static const int16_t av1_mrow_scan_4x8[] __attribute__((aligned(32))) = {
+     0,  8, 16, 24,
+     1,  9, 17, 25,
+     2, 10, 18, 26,
+     3, 11, 19, 27,
+     4, 12, 20, 28,
+     5, 13, 21, 29,
+     6, 14, 22, 30,
+     7, 15, 23, 31,
+};
+static const int16_t av1_mcol_scan_4x8[] __attribute__((aligned(32))) = {
+     0,  1,  2,  3,
+     4,  5,  6,  7,
+     8,  9, 10, 11,
+    12, 13, 14, 15,
+    16, 17, 18, 19,
+    20, 21, 22, 23,
+    24, 25, 26, 27,
+    28, 29, 30, 31,
+};
+static const int16_t av1_default_scan_4x16[] __attribute__((aligned(32))) = {
+     0, 16,  1, 32,
+    17,  2, 48, 33,
+    18,  3, 49, 34,
+    19,  4, 50, 35,
+    20,  5, 51, 36,
+    21,  6, 52, 37,
+    22,  7, 53, 38,
+    23,  8, 54, 39,
+    24,  9, 55, 40,
+    25, 10, 56, 41,
+    26, 11, 57, 42,
+    27, 12, 58, 43,
+    28, 13, 59, 44,
+    29, 14, 60, 45,
+    30, 15, 61, 46,
+    31, 62, 47, 63,
+};
+static const int16_t av1_mrow_scan_4x16[] __attribute__((aligned(32))) = {
+     0, 16, 32, 48,
+     1, 17, 33, 49,
+     2, 18, 34, 50,
+     3, 19, 35, 51,
+     4, 20, 36, 52,
+     5, 21, 37, 53,
+     6, 22, 38, 54,
+     7, 23, 39, 55,
+     8, 24, 40, 56,
+     9, 25, 41, 57,
+    10, 26, 42, 58,
+    11, 27, 43, 59,
+    12, 28, 44, 60,
+    13, 29, 45, 61,
+    14, 30, 46, 62,
+    15, 31, 47, 63,
+};
+static const int16_t av1_mcol_scan_4x16[] __attribute__((aligned(32))) = {
+     0,  1,  2,  3,
+     4,  5,  6,  7,
+     8,  9, 10, 11,
+    12, 13, 14, 15,
+    16, 17, 18, 19,
+    20, 21, 22, 23,
+    24, 25, 26, 27,
+    28, 29, 30, 31,
+    32, 33, 34, 35,
+    36, 37, 38, 39,
+    40, 41, 42, 43,
+    44, 45, 46, 47,
+    48, 49, 50, 51,
+    52, 53, 54, 55,
+    56, 57, 58, 59,
+    60, 61, 62, 63,
+};
+static const int16_t av1_default_scan_8x4[] __attribute__((aligned(32))) = {
+     0,  1,  4,  2,  5,  8,  3,  6,
+     9, 12,  7, 10, 13, 16, 11, 14,
+    17, 20, 15, 18, 21, 24, 19, 22,
+    25, 28, 23, 26, 29, 27, 30, 31,
+};
+static const int16_t av1_mrow_scan_8x4[] __attribute__((aligned(32))) = {
+     0,  4,  8, 12, 16, 20, 24, 28,
+     1,  5,  9, 13, 17, 21, 25, 29,
+     2,  6, 10, 14, 18, 22, 26, 30,
+     3,  7, 11, 15, 19, 23, 27, 31,
+};
+static const int16_t av1_mcol_scan_8x4[] __attribute__((aligned(32))) = {
+     0,  1,  2,  3,  4,  5,  6,  7,
+     8,  9, 10, 11, 12, 13, 14, 15,
+    16, 17, 18, 19, 20, 21, 22, 23,
+    24, 25, 26, 27, 28, 29, 30, 31,
+};
+static const int16_t av1_default_scan_8x8[] __attribute__((aligned(32))) = {
+     0,  8,  1,  2,  9, 16, 24, 17,
+    10,  3,  4, 11, 18, 25, 32, 40,
+    33, 26, 19, 12,  5,  6, 13, 20,
+    27, 34, 41, 48, 56, 49, 42, 35,
+    28, 21, 14,  7, 15, 22, 29, 36,
+    43, 50, 57, 58, 51, 44, 37, 30,
+    23, 31, 38, 45, 52, 59, 60, 53,
+    46, 39, 47, 54, 61, 62, 55, 63,
+};
+static const int16_t av1_mrow_scan_8x8[] __attribute__((aligned(32))) = {
+     0,  8, 16, 24, 32, 40, 48, 56,
+     1,  9, 17, 25, 33, 41, 49, 57,
+     2, 10, 18, 26, 34, 42, 50, 58,
+     3, 11, 19, 27, 35, 43, 51, 59,
+     4, 12, 20, 28, 36, 44, 52, 60,
+     5, 13, 21, 29, 37, 45, 53, 61,
+     6, 14, 22, 30, 38, 46, 54, 62,
+     7, 15, 23, 31, 39, 47, 55, 63,
+};
+static const int16_t av1_mcol_scan_8x8[] __attribute__((aligned(32))) = {
+     0,  1,  2,  3,  4,  5,  6,  7,
+     8,  9, 10, 11, 12, 13, 14, 15,
+    16, 17, 18, 19, 20, 21, 22, 23,
+    24, 25, 26, 27, 28, 29, 30, 31,
+    32, 33, 34, 35, 36, 37, 38, 39,
+    40, 41, 42, 43, 44, 45, 46, 47,
+    48, 49, 50, 51, 52, 53, 54, 55,
+    56, 57, 58, 59, 60, 61, 62, 63,
+};
+static const int16_t av1_default_scan_8x16[] __attribute__((aligned(32))) = {
+      0,  16,   1,  32,  17,   2,  48,  33,
+     18,   3,  64,  49,  34,  19,   4,  80,
+     65,  50,  35,  20,   5,  96,  81,  66,
+     51,  36,  21,   6, 112,  97,  82,  67,
+     52,  37,  22,   7, 113,  98,  83,  68,
+     53,  38,  23,   8, 114,  99,  84,  69,
+     54,  39,  24,   9, 115, 100,  85,  70,
+     55,  40,  25,  10, 116, 101,  86,  71,
+     56,  41,  26,  11, 117, 102,  87,  72,
+     57,  42,  27,  12, 118, 103,  88,  73,
+     58,  43,  28,  13, 119, 104,  89,  74,
+     59,  44,  29,  14, 120, 105,  90,  75,
+     60,  45,  30,  15, 121, 106,  91,  76,
+     61,  46,  31, 122, 107,  92,  77,  62,
+     47, 123, 108,  93,  78,  63, 124, 109,
+     94,  79, 125, 110,  95, 126, 111, 127,
+};
+static const int16_t av1_mrow_scan_8x16[] __attribute__((aligned(32))) = {
+      0,  16,  32,  48,  64,  80,  96, 112,
+      1,  17,  33,  49,  65,  81,  97, 113,
+      2,  18,  34,  50,  66,  82,  98, 114,
+      3,  19,  35,  51,  67,  83,  99, 115,
+      4,  20,  36,  52,  68,  84, 100, 116,
+      5,  21,  37,  53,  69,  85, 101, 117,
+      6,  22,  38,  54,  70,  86, 102, 118,
+      7,  23,  39,  55,  71,  87, 103, 119,
+      8,  24,  40,  56,  72,  88, 104, 120,
+      9,  25,  41,  57,  73,  89, 105, 121,
+     10,  26,  42,  58,  74,  90, 106, 122,
+     11,  27,  43,  59,  75,  91, 107, 123,
+     12,  28,  44,  60,  76,  92, 108, 124,
+     13,  29,  45,  61,  77,  93, 109, 125,
+     14,  30,  46,  62,  78,  94, 110, 126,
+     15,  31,  47,  63,  79,  95, 111, 127,
+};
+static const int16_t av1_mcol_scan_8x16[] __attribute__((aligned(32))) = {
+      0,   1,   2,   3,   4,   5,   6,   7,
+      8,   9,  10,  11,  12,  13,  14,  15,
+     16,  17,  18,  19,  20,  21,  22,  23,
+     24,  25,  26,  27,  28,  29,  30,  31,
+     32,  33,  34,  35,  36,  37,  38,  39,
+     40,  41,  42,  43,  44,  45,  46,  47,
+     48,  49,  50,  51,  52,  53,  54,  55,
+     56,  57,  58,  59,  60,  61,  62,  63,
+     64,  65,  66,  67,  68,  69,  70,  71,
+     72,  73,  74,  75,  76,  77,  78,  79,
+     80,  81,  82,  83,  84,  85,  86,  87,
+     88,  89,  90,  91,  92,  93,  94,  95,
+     96,  97,  98,  99, 100, 101, 102, 103,
+    104, 105, 106, 107, 108, 109, 110, 111,
+    112, 113, 114, 115, 116, 117, 118, 119,
+    120, 121, 122, 123, 124, 125, 126, 127,
+};
+static const int16_t av1_default_scan_8x32[] __attribute__((aligned(32))) = {
+      0,  32,   1,  64,  33,   2,  96,  65,
+     34,   3, 128,  97,  66,  35,   4, 160,
+    129,  98,  67,  36,   5, 192, 161, 130,
+     99,  68,  37,   6, 224, 193, 162, 131,
+    100,  69,  38,   7, 225, 194, 163, 132,
+    101,  70,  39,   8, 226, 195, 164, 133,
+    102,  71,  40,   9, 227, 196, 165, 134,
+    103,  72,  41,  10, 228, 197, 166, 135,
+    104,  73,  42,  11, 229, 198, 167, 136,
+    105,  74,  43,  12, 230, 199, 168, 137,
+    106,  75,  44,  13, 231, 200, 169, 138,
+    107,  76,  45,  14, 232, 201, 170, 139,
+    108,  77,  46,  15, 233, 202, 171, 140,
+    109,  78,  47,  16, 234, 203, 172, 141,
+    110,  79,  48,  17, 235, 204, 173, 142,
+    111,  80,  49,  18, 236, 205, 174, 143,
+    112,  81,  50,  19, 237, 206, 175, 144,
+    113,  82,  51,  20, 238, 207, 176, 145,
+    114,  83,  52,  21, 239, 208, 177, 146,
+    115,  84,  53,  22, 240, 209, 178, 147,
+    116,  85,  54,  23, 241, 210, 179, 148,
+    117,  86,  55,  24, 242, 211, 180, 149,
+    118,  87,  56,  25, 243, 212, 181, 150,
+    119,  88,  57,  26, 244, 213, 182, 151,
+    120,  89,  58,  27, 245, 214, 183, 152,
+    121,  90,  59,  28, 246, 215, 184, 153,
+    122,  91,  60,  29, 247, 216, 185, 154,
+    123,  92,  61,  30, 248, 217, 186, 155,
+    124,  93,  62,  31, 249, 218, 187, 156,
+    125,  94,  63, 250, 219, 188, 157, 126,
+     95, 251, 220, 189, 158, 127, 252, 221,
+    190, 159, 253, 222, 191, 254, 223, 255,
+};
+static const int16_t av1_default_scan_16x4[] __attribute__((aligned(32))) = {
+     0,  1,  4,  2,  5,  8,  3,  6,  9, 12,  7, 10, 13, 16, 11, 14,
+    17, 20, 15, 18, 21, 24, 19, 22, 25, 28, 23, 26, 29, 32, 27, 30,
+    33, 36, 31, 34, 37, 40, 35, 38, 41, 44, 39, 42, 45, 48, 43, 46,
+    49, 52, 47, 50, 53, 56, 51, 54, 57, 60, 55, 58, 61, 59, 62, 63,
+};
+static const int16_t av1_mrow_scan_16x4[] __attribute__((aligned(32))) = {
+     0,  4,  8, 12, 16, 20, 24, 28, 32, 36, 40, 44, 48, 52, 56, 60,
+     1,  5,  9, 13, 17, 21, 25, 29, 33, 37, 41, 45, 49, 53, 57, 61,
+     2,  6, 10, 14, 18, 22, 26, 30, 34, 38, 42, 46, 50, 54, 58, 62,
+     3,  7, 11, 15, 19, 23, 27, 31, 35, 39, 43, 47, 51, 55, 59, 63,
+};
+static const int16_t av1_mcol_scan_16x4[] __attribute__((aligned(32))) = {
+     0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11, 12, 13, 14, 15,
+    16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31,
+    32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47,
+    48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63,
+};
+static const int16_t av1_default_scan_16x8[] __attribute__((aligned(32))) = {
+      0,   1,   8,   2,   9,  16,   3,  10,  17,  24,   4,  11,  18,  25,  32,   5,
+     12,  19,  26,  33,  40,   6,  13,  20,  27,  34,  41,  48,   7,  14,  21,  28,
+     35,  42,  49,  56,  15,  22,  29,  36,  43,  50,  57,  64,  23,  30,  37,  44,
+     51,  58,  65,  72,  31,  38,  45,  52,  59,  66,  73,  80,  39,  46,  53,  60,
+     67,  74,  81,  88,  47,  54,  61,  68,  75,  82,  89,  96,  55,  62,  69,  76,
+     83,  90,  97, 104,  63,  70,  77,  84,  91,  98, 105, 112,  71,  78,  85,  92,
+     99, 106, 113, 120,  79,  86,  93, 100, 107, 114, 121,  87,  94, 101, 108, 115,
+    122,  95, 102, 109, 116, 123, 103, 110, 117, 124, 111, 118, 125, 119, 126, 127,
+};
+static const int16_t av1_mrow_scan_16x8[] __attribute__((aligned(32))) = {
+      0,   8,  16,  24,  32,  40,  48,  56,  64,  72,  80,  88,  96, 104, 112, 120,
+      1,   9,  17,  25,  33,  41,  49,  57,  65,  73,  81,  89,  97, 105, 113, 121,
+      2,  10,  18,  26,  34,  42,  50,  58,  66,  74,  82,  90,  98, 106, 114, 122,
+      3,  11,  19,  27,  35,  43,  51,  59,  67,  75,  83,  91,  99, 107, 115, 123,
+      4,  12,  20,  28,  36,  44,  52,  60,  68,  76,  84,  92, 100, 108, 116, 124,
+      5,  13,  21,  29,  37,  45,  53,  61,  69,  77,  85,  93, 101, 109, 117, 125,
+      6,  14,  22,  30,  38,  46,  54,  62,  70,  78,  86,  94, 102, 110, 118, 126,
+      7,  15,  23,  31,  39,  47,  55,  63,  71,  79,  87,  95, 103, 111, 119, 127,
+};
+static const int16_t av1_mcol_scan_16x8[] __attribute__((aligned(32))) = {
+      0,   1,   2,   3,   4,   5,   6,   7,   8,   9,  10,  11,  12,  13,  14,  15,
+     16,  17,  18,  19,  20,  21,  22,  23,  24,  25,  26,  27,  28,  29,  30,  31,
+     32,  33,  34,  35,  36,  37,  38,  39,  40,  41,  42,  43,  44,  45,  46,  47,
+     48,  49,  50,  51,  52,  53,  54,  55,  56,  57,  58,  59,  60,  61,  62,  63,
+     64,  65,  66,  67,  68,  69,  70,  71,  72,  73,  74,  75,  76,  77,  78,  79,
+     80,  81,  82,  83,  84,  85,  86,  87,  88,  89,  90,  91,  92,  93,  94,  95,
+     96,  97,  98,  99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111,
+    112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127,
+};
+static const int16_t av1_default_scan_16x16[] __attribute__((aligned(32))) = {
+      0,  16,   1,   2,  17,  32,  48,  33,  18,   3,   4,  19,  34,  49,  64,  80,
+     65,  50,  35,  20,   5,   6,  21,  36,  51,  66,  81,  96, 112,  97,  82,  67,
+     52,  37,  22,   7,   8,  23,  38,  53,  68,  83,  98, 113, 128, 144, 129, 114,
+     99,  84,  69,  54,  39,  24,   9,  10,  25,  40,  55,  70,  85, 100, 115, 130,
+    145, 160, 176, 161, 146, 131, 116, 101,  86,  71,  56,  41,  26,  11,  12,  27,
+     42,  57,  72,  87, 102, 117, 132, 147, 162, 177, 192, 208, 193, 178, 163, 148,
+    133, 118, 103,  88,  73,  58,  43,  28,  13,  14,  29,  44,  59,  74,  89, 104,
+    119, 134, 149, 164, 179, 194, 209, 224, 240, 225, 210, 195, 180, 165, 150, 135,
+    120, 105,  90,  75,  60,  45,  30,  15,  31,  46,  61,  76,  91, 106, 121, 136,
+    151, 166, 181, 196, 211, 226, 241, 242, 227, 212, 197, 182, 167, 152, 137, 122,
+    107,  92,  77,  62,  47,  63,  78,  93, 108, 123, 138, 153, 168, 183, 198, 213,
+    228, 243, 244, 229, 214, 199, 184, 169, 154, 139, 124, 109,  94,  79,  95, 110,
+    125, 140, 155, 170, 185, 200, 215, 230, 245, 246, 231, 216, 201, 186, 171, 156,
+    141, 126, 111, 127, 142, 157, 172, 187, 202, 217, 232, 247, 248, 233, 218, 203,
+    188, 173, 158, 143, 159, 174, 189, 204, 219, 234, 249, 250, 235, 220, 205, 190,
+    175, 191, 206, 221, 236, 251, 252, 237, 222, 207, 223, 238, 253, 254, 239, 255,
+};
+static const int16_t av1_mrow_scan_16x16[] __attribute__((aligned(32))) = {
+      0,  16,  32,  48,  64,  80,  96, 112, 128, 144, 160, 176, 192, 208, 224, 240,
+      1,  17,  33,  49,  65,  81,  97, 113, 129, 145, 161, 177, 193, 209, 225, 241,
+      2,  18,  34,  50,  66,  82,  98, 114, 130, 146, 162, 178, 194, 210, 226, 242,
+      3,  19,  35,  51,  67,  83,  99, 115, 131, 147, 163, 179, 195, 211, 227, 243,
+      4,  20,  36,  52,  68,  84, 100, 116, 132, 148, 164, 180, 196, 212, 228, 244,
+      5,  21,  37,  53,  69,  85, 101, 117, 133, 149, 165, 181, 197, 213, 229, 245,
+      6,  22,  38,  54,  70,  86, 102, 118, 134, 150, 166, 182, 198, 214, 230, 246,
+      7,  23,  39,  55,  71,  87, 103, 119, 135, 151, 167, 183, 199, 215, 231, 247,
+      8,  24,  40,  56,  72,  88, 104, 120, 136, 152, 168, 184, 200, 216, 232, 248,
+      9,  25,  41,  57,  73,  89, 105, 121, 137, 153, 169, 185, 201, 217, 233, 249,
+     10,  26,  42,  58,  74,  90, 106, 122, 138, 154, 170, 186, 202, 218, 234, 250,
+     11,  27,  43,  59,  75,  91, 107, 123, 139, 155, 171, 187, 203, 219, 235, 251,
+     12,  28,  44,  60,  76,  92, 108, 124, 140, 156, 172, 188, 204, 220, 236, 252,
+     13,  29,  45,  61,  77,  93, 109, 125, 141, 157, 173, 189, 205, 221, 237, 253,
+     14,  30,  46,  62,  78,  94, 110, 126, 142, 158, 174, 190, 206, 222, 238, 254,
+     15,  31,  47,  63,  79,  95, 111, 127, 143, 159, 175, 191, 207, 223, 239, 255,
+};
+static const int16_t av1_mcol_scan_16x16[] __attribute__((aligned(32))) = {
+      0,   1,   2,   3,   4,   5,   6,   7,   8,   9,  10,  11,  12,  13,  14,  15,
+     16,  17,  18,  19,  20,  21,  22,  23,  24,  25,  26,  27,  28,  29,  30,  31,
+     32,  33,  34,  35,  36,  37,  38,  39,  40,  41,  42,  43,  44,  45,  46,  47,
+     48,  49,  50,  51,  52,  53,  54,  55,  56,  57,  58,  59,  60,  61,  62,  63,
+     64,  65,  66,  67,  68,  69,  70,  71,  72,  73,  74,  75,  76,  77,  78,  79,
+     80,  81,  82,  83,  84,  85,  86,  87,  88,  89,  90,  91,  92,  93,  94,  95,
+     96,  97,  98,  99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111,
+    112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127,
+    128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143,
+    144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159,
+    160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, 175,
+    176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 191,
+    192, 193, 194, 195, 196, 197, 198, 199, 200, 201, 202, 203, 204, 205, 206, 207,
+    208, 209, 210, 211, 212, 213, 214, 215, 216, 217, 218, 219, 220, 221, 222, 223,
+    224, 225, 226, 227, 228, 229, 230, 231, 232, 233, 234, 235, 236, 237, 238, 239,
+    240, 241, 242, 243, 244, 245, 246, 247, 248, 249, 250, 251, 252, 253, 254, 255,
+};
+static const int16_t av1_default_scan_16x32[] __attribute__((aligned(32))) = {
+      0,  32,   1,  64,  33,   2,  96,  65,  34,   3, 128,  97,  66,  35,   4, 160,
+    129,  98,  67,  36,   5, 192, 161, 130,  99,  68,  37,   6, 224, 193, 162, 131,
+    100,  69,  38,   7, 256, 225, 194, 163, 132, 101,  70,  39,   8, 288, 257, 226,
+    195, 164, 133, 102,  71,  40,   9, 320, 289, 258, 227, 196, 165, 134, 103,  72,
+     41,  10, 352, 321, 290, 259, 228, 197, 166, 135, 104,  73,  42,  11, 384, 353,
+    322, 291, 260, 229, 198, 167, 136, 105,  74,  43,  12, 416, 385, 354, 323, 292,
+    261, 230, 199, 168, 137, 106,  75,  44,  13, 448, 417, 386, 355, 324, 293, 262,
+    231, 200, 169, 138, 107,  76,  45,  14, 480, 449, 418, 387, 356, 325, 294, 263,
+    232, 201, 170, 139, 108,  77,  46,  15, 481, 450, 419, 388, 357, 326, 295, 264,
+    233, 202, 171, 140, 109,  78,  47,  16, 482, 451, 420, 389, 358, 327, 296, 265,
+    234, 203, 172, 141, 110,  79,  48,  17, 483, 452, 421, 390, 359, 328, 297, 266,
+    235, 204, 173, 142, 111,  80,  49,  18, 484, 453, 422, 391, 360, 329, 298, 267,
+    236, 205, 174, 143, 112,  81,  50,  19, 485, 454, 423, 392, 361, 330, 299, 268,
+    237, 206, 175, 144, 113,  82,  51,  20, 486, 455, 424, 393, 362, 331, 300, 269,
+    238, 207, 176, 145, 114,  83,  52,  21, 487, 456, 425, 394, 363, 332, 301, 270,
+    239, 208, 177, 146, 115,  84,  53,  22, 488, 457, 426, 395, 364, 333, 302, 271,
+    240, 209, 178, 147, 116,  85,  54,  23, 489, 458, 427, 396, 365, 334, 303, 272,
+    241, 210, 179, 148, 117,  86,  55,  24, 490, 459, 428, 397, 366, 335, 304, 273,
+    242, 211, 180, 149, 118,  87,  56,  25, 491, 460, 429, 398, 367, 336, 305, 274,
+    243, 212, 181, 150, 119,  88,  57,  26, 492, 461, 430, 399, 368, 337, 306, 275,
+    244, 213, 182, 151, 120,  89,  58,  27, 493, 462, 431, 400, 369, 338, 307, 276,
+    245, 214, 183, 152, 121,  90,  59,  28, 494, 463, 432, 401, 370, 339, 308, 277,
+    246, 215, 184, 153, 122,  91,  60,  29, 495, 464, 433, 402, 371, 340, 309, 278,
+    247, 216, 185, 154, 123,  92,  61,  30, 496, 465, 434, 403, 372, 341, 310, 279,
+    248, 217, 186, 155, 124,  93,  62,  31, 497, 466, 435, 404, 373, 342, 311, 280,
+    249, 218, 187, 156, 125,  94,  63, 498, 467, 436, 405, 374, 343, 312, 281, 250,
+    219, 188, 157, 126,  95, 499, 468, 437, 406, 375, 344, 313, 282, 251, 220, 189,
+    158, 127, 500, 469, 438, 407, 376, 345, 314, 283, 252, 221, 190, 159, 501, 470,
+    439, 408, 377, 346, 315, 284, 253, 222, 191, 502, 471, 440, 409, 378, 347, 316,
+    285, 254, 223, 503, 472, 441, 410, 379, 348, 317, 286, 255, 504, 473, 442, 411,
+    380, 349, 318, 287, 505, 474, 443, 412, 381, 350, 319, 506, 475, 444, 413, 382,
+    351, 507, 476, 445, 414, 383, 508, 477, 446, 415, 509, 478, 447, 510, 479, 511,
+};
+static const int16_t av1_default_scan_32x8[] __attribute__((aligned(32))) = {
+      0,   1,   8,   2,   9,  16,   3,  10,  17,  24,   4,  11,  18,  25,  32,   5,  12,  19,  26,  33,  40,   6,  13,  20,  27,  34,  41,  48,   7,  14,  21,  28,
+     35,  42,  49,  56,  15,  22,  29,  36,  43,  50,  57,  64,  23,  30,  37,  44,  51,  58,  65,  72,  31,  38,  45,  52,  59,  66,  73,  80,  39,  46,  53,  60,
+     67,  74,  81,  88,  47,  54,  61,  68,  75,  82,  89,  96,  55,  62,  69,  76,  83,  90,  97, 104,  63,  70,  77,  84,  91,  98, 105, 112,  71,  78,  85,  92,
+     99, 106, 113, 120,  79,  86,  93, 100, 107, 114, 121, 128,  87,  94, 101, 108, 115, 122, 129, 136,  95, 102, 109, 116, 123, 130, 137, 144, 103, 110, 117, 124,
+    131, 138, 145, 152, 111, 118, 125, 132, 139, 146, 153, 160, 119, 126, 133, 140, 147, 154, 161, 168, 127, 134, 141, 148, 155, 162, 169, 176, 135, 142, 149, 156,
+    163, 170, 177, 184, 143, 150, 157, 164, 171, 178, 185, 192, 151, 158, 165, 172, 179, 186, 193, 200, 159, 166, 173, 180, 187, 194, 201, 208, 167, 174, 181, 188,
+    195, 202, 209, 216, 175, 182, 189, 196, 203, 210, 217, 224, 183, 190, 197, 204, 211, 218, 225, 232, 191, 198, 205, 212, 219, 226, 233, 240, 199, 206, 213, 220,
+    227, 234, 241, 248, 207, 214, 221, 228, 235, 242, 249, 215, 222, 229, 236, 243, 250, 223, 230, 237, 244, 251, 231, 238, 245, 252, 239, 246, 253, 247, 254, 255,
+};
+static const int16_t av1_default_scan_32x16[] __attribute__((aligned(32))) = {
+      0,   1,  16,   2,  17,  32,   3,  18,  33,  48,   4,  19,  34,  49,  64,   5,  20,  35,  50,  65,  80,   6,  21,  36,  51,  66,  81,  96,   7,  22,  37,  52,
+     67,  82,  97, 112,   8,  23,  38,  53,  68,  83,  98, 113, 128,   9,  24,  39,  54,  69,  84,  99, 114, 129, 144,  10,  25,  40,  55,  70,  85, 100, 115, 130,
+    145, 160,  11,  26,  41,  56,  71,  86, 101, 116, 131, 146, 161, 176,  12,  27,  42,  57,  72,  87, 102, 117, 132, 147, 162, 177, 192,  13,  28,  43,  58,  73,
+     88, 103, 118, 133, 148, 163, 178, 193, 208,  14,  29,  44,  59,  74,  89, 104, 119, 134, 149, 164, 179, 194, 209, 224,  15,  30,  45,  60,  75,  90, 105, 120,
+    135, 150, 165, 180, 195, 210, 225, 240,  31,  46,  61,  76,  91, 106, 121, 136, 151, 166, 181, 196, 211, 226, 241, 256,  47,  62,  77,  92, 107, 122, 137, 152,
+    167, 182, 197, 212, 227, 242, 257, 272,  63,  78,  93, 108, 123, 138, 153, 168, 183, 198, 213, 228, 243, 258, 273, 288,  79,  94, 109, 124, 139, 154, 169, 184,
+    199, 214, 229, 244, 259, 274, 289, 304,  95, 110, 125, 140, 155, 170, 185, 200, 215, 230, 245, 260, 275, 290, 305, 320, 111, 126, 141, 156, 171, 186, 201, 216,
+    231, 246, 261, 276, 291, 306, 321, 336, 127, 142, 157, 172, 187, 202, 217, 232, 247, 262, 277, 292, 307, 322, 337, 352, 143, 158, 173, 188, 203, 218, 233, 248,
+    263, 278, 293, 308, 323, 338, 353, 368, 159, 174, 189, 204, 219, 234, 249, 264, 279, 294, 309, 324, 339, 354, 369, 384, 175, 190, 205, 220, 235, 250, 265, 280,
+    295, 310, 325, 340, 355, 370, 385, 400, 191, 206, 221, 236, 251, 266, 281, 296, 311, 326, 341, 356, 371, 386, 401, 416, 207, 222, 237, 252, 267, 282, 297, 312,
+    327, 342, 357, 372, 387, 402, 417, 432, 223, 238, 253, 268, 283, 298, 313, 328, 343, 358, 373, 388, 403, 418, 433, 448, 239, 254, 269, 284, 299, 314, 329, 344,
+    359, 374, 389, 404, 419, 434, 449, 464, 255, 270, 285, 300, 315, 330, 345, 360, 375, 390, 405, 420, 435, 450, 465, 480, 271, 286, 301, 316, 331, 346, 361, 376,
+    391, 406, 421, 436, 451, 466, 481, 496, 287, 302, 317, 332, 347, 362, 377, 392, 407, 422, 437, 452, 467, 482, 497, 303, 318, 333, 348, 363, 378, 393, 408, 423,
+    438, 453, 468, 483, 498, 319, 334, 349, 364, 379, 394, 409, 424, 439, 454, 469, 484, 499, 335, 350, 365, 380, 395, 410, 425, 440, 455, 470, 485, 500, 351, 366,
+    381, 396, 411, 426, 441, 456, 471, 486, 501, 367, 382, 397, 412, 427, 442, 457, 472, 487, 502, 383, 398, 413, 428, 443, 458, 473, 488, 503, 399, 414, 429, 444,
+    459, 474, 489, 504, 415, 430, 445, 460, 475, 490, 505, 431, 446, 461, 476, 491, 506, 447, 462, 477, 492, 507, 463, 478, 493, 508, 479, 494, 509, 495, 510, 511,
+};
+static const int16_t av1_default_scan_32x32[] __attribute__((aligned(32))) = {
+       0,   32,    1,    2,   33,   64,   96,   65,   34,    3,    4,   35,   66,   97,  128,  160,  129,   98,   67,   36,    5,    6,   37,   68,   99,  130,  161,  192,  224,  193,  162,  131,
+     100,   69,   38,    7,    8,   39,   70,  101,  132,  163,  194,  225,  256,  288,  257,  226,  195,  164,  133,  102,   71,   40,    9,   10,   41,   72,  103,  134,  165,  196,  227,  258,
+     289,  320,  352,  321,  290,  259,  228,  197,  166,  135,  104,   73,   42,   11,   12,   43,   74,  105,  136,  167,  198,  229,  260,  291,  322,  353,  384,  416,  385,  354,  323,  292,
+     261,  230,  199,  168,  137,  106,   75,   44,   13,   14,   45,   76,  107,  138,  169,  200,  231,  262,  293,  324,  355,  386,  417,  448,  480,  449,  418,  387,  356,  325,  294,  263,
+     232,  201,  170,  139,  108,   77,   46,   15,   16,   47,   78,  109,  140,  171,  202,  233,  264,  295,  326,  357,  388,  419,  450,  481,  512,  544,  513,  482,  451,  420,  389,  358,
+     327,  296,  265,  234,  203,  172,  141,  110,   79,   48,   17,   18,   49,   80,  111,  142,  173,  204,  235,  266,  297,  328,  359,  390,  421,  452,  483,  514,  545,  576,  608,  577,
+     546,  515,  484,  453,  422,  391,  360,  329,  298,  267,  236,  205,  174,  143,  112,   81,   50,   19,   20,   51,   82,  113,  144,  175,  206,  237,  268,  299,  330,  361,  392,  423,
+     454,  485,  516,  547,  578,  609,  640,  672,  641,  610,  579,  548,  517,  486,  455,  424,  393,  362,  331,  300,  269,  238,  207,  176,  145,  114,   83,   52,   21,   22,   53,   84,
+     115,  146,  177,  208,  239,  270,  301,  332,  363,  394,  425,  456,  487,  518,  549,  580,  611,  642,  673,  704,  736,  705,  674,  643,  612,  581,  550,  519,  488,  457,  426,  395,
+     364,  333,  302,  271,  240,  209,  178,  147,  116,   85,   54,   23,   24,   55,   86,  117,  148,  179,  210,  241,  272,  303,  334,  365,  396,  427,  458,  489,  520,  551,  582,  613,
+     644,  675,  706,  737,  768,  800,  769,  738,  707,  676,  645,  614,  583,  552,  521,  490,  459,  428,  397,  366,  335,  304,  273,  242,  211,  180,  149,  118,   87,   56,   25,   26,
+      57,   88,  119,  150,  181,  212,  243,  274,  305,  336,  367,  398,  429,  460,  491,  522,  553,  584,  615,  646,  677,  708,  739,  770,  801,  832,  864,  833,  802,  771,  740,  709,
+     678,  647,  616,  585,  554,  523,  492,  461,  430,  399,  368,  337,  306,  275,  244,  213,  182,  151,  120,   89,   58,   27,   28,   59,   90,  121,  152,  183,  214,  245,  276,  307,
+     338,  369,  400,  431,  462,  493,  524,  555,  586,  617,  648,  679,  710,  741,  772,  803,  834,  865,  896,  928,  897,  866,  835,  804,  773,  742,  711,  680,  649,  618,  587,  556,
+     525,  494,  463,  432,  401,  370,  339,  308,  277,  246,  215,  184,  153,  122,   91,   60,   29,   30,   61,   92,  123,  154,  185,  216,  247,  278,  309,  340,  371,  402,  433,  464,
+     495,  526,  557,  588,  619,  650,  681,  712,  743,  774,  805,  836,  867,  898,  929,  960,  992,  961,  930,  899,  868,  837,  806,  775,  744,  713,  682,  651,  620,  589,  558,  527,
+     496,  465,  434,  403,  372,  341,  310,  279,  248,  217,  186,  155,  124,   93,   62,   31,   63,   94,  125,  156,  187,  218,  249,  280,  311,  342,  373,  404,  435,  466,  497,  528,
+     559,  590,  621,  652,  683,  714,  745,  776,  807,  838,  869,  900,  931,  962,  993,  994,  963,  932,  901,  870,  839,  808,  777,  746,  715,  684,  653,  622,  591,  560,  529,  498,
+     467,  436,  405,  374,  343,  312,  281,  250,  219,  188,  157,  126,   95,  127,  158,  189,  220,  251,  282,  313,  344,  375,  406,  437,  468,  499,  530,  561,  592,  623,  654,  685,
+     716,  747,  778,  809,  840,  871,  902,  933,  964,  995,  996,  965,  934,  903,  872,  841,  810,  779,  748,  717,  686,  655,  624,  593,  562,  531,  500,  469,  438,  407,  376,  345,
+     314,  283,  252,  221,  190,  159,  191,  222,  253,  284,  315,  346,  377,  408,  439,  470,  501,  532,  563,  594,  625,  656,  687,  718,  749,  780,  811,  842,  873,  904,  935,  966,
+     997,  998,  967,  936,  905,  874,  843,  812,  781,  750,  719,  688,  657,  626,  595,  564,  533,  502,  471,  440,  409,  378,  347,  316,  285,  254,  223,  255,  286,  317,  348,  379,
+     410,  441,  472,  503,  534,  565,  596,  627,  658,  689,  720,  751,  782,  813,  844,  875,  906,  937,  968,  999, 1000,  969,  938,  907,  876,  845,  814,  783,  752,  721,  690,  659,
+     628,  597,  566,  535,  504,  473,  442,  411,  380,  349,  318,  287,  319,  350,  381,  412,  443,  474,  505,  536,  567,  598,  629,  660,  691,  722,  753,  784,  815,  846,  877,  908,
+     939,  970, 1001, 1002,  971,  940,  909,  878,  847,  816,  785,  754,  723,  692,  661,  630,  599,  568,  537,  506,  475,  444,  413,  382,  351,  383,  414,  445,  476,  507,  538,  569,
+     600,  631,  662,  693,  724,  755,  786,  817,  848,  879,  910,  941,  972, 1003, 1004,  973,  942,  911,  880,  849,  818,  787,  756,  725,  694,  663,  632,  601,  570,  539,  508,  477,
+     446,  415,  447,  478,  509,  540,  571,  602,  633,  664,  695,  726,  757,  788,  819,  850,  881,  912,  943,  974, 1005, 1006,  975,  944,  913,  882,  851,  820,  789,  758,  727,  696,
+     665,  634,  603,  572,  541,  510,  479,  511,  542,  573,  604,  635,  666,  697,  728,  759,  790,  821,  852,  883,  914,  945,  976, 1007, 1008,  977,  946,  915,  884,  853,  822,  791,
+     760,  729,  698,  667,  636,  605,  574,  543,  575,  606,  637,  668,  699,  730,  761,  792,  823,  854,  885,  916,  947,  978, 1009, 1010,  979,  948,  917,  886,  855,  824,  793,  762,
+     731,  700,  669,  638,  607,  639,  670,  701,  732,  763,  794,  825,  856,  887,  918,  949,  980, 1011, 1012,  981,  950,  919,  888,  857,  826,  795,  764,  733,  702,  671,  703,  734,
+     765,  796,  827,  858,  889,  920,  951,  982, 1013, 1014,  983,  952,  921,  890,  859,  828,  797,  766,  735,  767,  798,  829,  860,  891,  922,  953,  984, 1015, 1016,  985,  954,  923,
+     892,  861,  830,  799,  831,  862,  893,  924,  955,  986, 1017, 1018,  987,  956,  925,  894,  863,  895,  926,  957,  988, 1019, 1020,  989,  958,  927,  959,  990, 1021, 1022,  991, 1023,
+};
+
+const int16_t *const av1_scans[N_RECT_TX_SIZES][3] = {
+    [TX_4X4] = {
+        [TX_CLASS_2D] = av1_default_scan_4x4,
+        [TX_CLASS_V]  = av1_mrow_scan_4x4,
+        [TX_CLASS_H]  = av1_mcol_scan_4x4,
+    }, [TX_8X8] = {
+        [TX_CLASS_2D] = av1_default_scan_8x8,
+        [TX_CLASS_V]  = av1_mrow_scan_8x8,
+        [TX_CLASS_H]  = av1_mcol_scan_8x8,
+    }, [TX_16X16] = {
+        [TX_CLASS_2D] = av1_default_scan_16x16,
+        [TX_CLASS_V]  = av1_mrow_scan_16x16,
+        [TX_CLASS_H]  = av1_mcol_scan_16x16,
+    }, [TX_32X32] = {
+        [TX_CLASS_2D] = av1_default_scan_32x32,
+    }, [TX_64X64] = {
+        [TX_CLASS_2D] = av1_default_scan_32x32,
+    }, [RTX_4X8] = {
+        [TX_CLASS_2D] = av1_default_scan_4x8,
+        [TX_CLASS_V]  = av1_mrow_scan_4x8,
+        [TX_CLASS_H]  = av1_mcol_scan_4x8,
+    }, [RTX_8X4] = {
+        [TX_CLASS_2D] = av1_default_scan_8x4,
+        [TX_CLASS_V]  = av1_mrow_scan_8x4,
+        [TX_CLASS_H]  = av1_mcol_scan_8x4,
+    }, [RTX_8X16] = {
+        [TX_CLASS_2D] = av1_default_scan_8x16,
+        [TX_CLASS_V]  = av1_mrow_scan_8x16,
+        [TX_CLASS_H]  = av1_mcol_scan_8x16,
+    }, [RTX_16X8] = {
+        [TX_CLASS_2D] = av1_default_scan_16x8,
+        [TX_CLASS_V]  = av1_mrow_scan_16x8,
+        [TX_CLASS_H]  = av1_mcol_scan_16x8,
+    }, [RTX_16X32] = {
+        [TX_CLASS_2D] = av1_default_scan_16x32,
+    }, [RTX_32X16] = {
+        [TX_CLASS_2D] = av1_default_scan_32x16,
+    }, [RTX_32X64] = {
+        [TX_CLASS_2D] = av1_default_scan_32x32,
+    }, [RTX_64X32] = {
+        [TX_CLASS_2D] = av1_default_scan_32x32,
+    }, [RTX_4X16] = {
+        [TX_CLASS_2D] = av1_default_scan_4x16,
+        [TX_CLASS_V]  = av1_mrow_scan_4x16,
+        [TX_CLASS_H]  = av1_mcol_scan_4x16,
+    }, [RTX_16X4] = {
+        [TX_CLASS_2D] = av1_default_scan_16x4,
+        [TX_CLASS_V]  = av1_mrow_scan_16x4,
+        [TX_CLASS_H]  = av1_mcol_scan_16x4,
+    }, [RTX_8X32] = {
+        [TX_CLASS_2D] = av1_default_scan_8x32,
+    }, [RTX_32X8] = {
+        [TX_CLASS_2D] = av1_default_scan_32x8,
+    }, [RTX_16X64] = {
+        [TX_CLASS_2D] = av1_default_scan_16x32,
+    }, [RTX_64X16] = {
+        [TX_CLASS_2D] = av1_default_scan_32x16,
+    },
+};
diff --git a/src/scan.h b/src/scan.h
new file mode 100644
index 0000000..c00a64b
--- /dev/null
+++ b/src/scan.h
@@ -0,0 +1,37 @@
+/*
+ * Copyright © 2018, VideoLAN and dav1d authors
+ * Copyright © 2018, Two Orioles, LLC
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright notice, this
+ *    list of conditions and the following disclaimer.
+ *
+ * 2. Redistributions in binary form must reproduce the above copyright notice,
+ *    this list of conditions and the following disclaimer in the documentation
+ *    and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
+ * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#ifndef __DAV1D_SCAN_H__
+#define __DAV1D_SCAN_H__
+
+#include <stdint.h>
+
+#include "src/levels.h"
+
+extern const int16_t *const av1_scans[N_RECT_TX_SIZES][3];
+
+#endif /* __DAV1D_SCAN_H__ */
diff --git a/src/tables.c b/src/tables.c
new file mode 100644
index 0000000..15f042a
--- /dev/null
+++ b/src/tables.c
@@ -0,0 +1,756 @@
+/*
+ * Copyright © 2018, VideoLAN and dav1d authors
+ * Copyright © 2018, Two Orioles, LLC
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright notice, this
+ *    list of conditions and the following disclaimer.
+ *
+ * 2. Redistributions in binary form must reproduce the above copyright notice,
+ *    this list of conditions and the following disclaimer in the documentation
+ *    and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
+ * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#include "config.h"
+
+#include <stdint.h>
+
+#include "src/levels.h"
+#include "src/tables.h"
+
+const uint8_t av1_al_part_ctx[2][N_BL_LEVELS][N_PARTITIONS] = {
+    {
+        // partitions:
+        // none,  h,    v, split,  tts,  tbs,  tls,  trs,   h4,   v4
+        { 0x00, 0x00, 0x10,   -1, 0x00, 0x10, 0x10, 0x10,   -1,   -1 }, // bl128
+        { 0x10, 0x10, 0x18,   -1, 0x10, 0x18, 0x18, 0x18, 0x10, 0x1c }, // bl64
+        { 0x18, 0x18, 0x1c,   -1, 0x18, 0x1c, 0x1c, 0x1c, 0x18, 0x1e }, // bl32
+        { 0x1c, 0x1c, 0x1e,   -1, 0x1c, 0x1e, 0x1e, 0x1e, 0x1c, 0x1f }, // bl16
+        { 0x1e, 0x1e, 0x1f, 0x1f,   -1,   -1,   -1,   -1,   -1,   -1 }, // bl8
+    }, {
+        { 0x00, 0x10, 0x00,   -1, 0x10, 0x10, 0x00, 0x10,   -1,   -1 }, // bl128
+        { 0x10, 0x18, 0x10,   -1, 0x18, 0x18, 0x10, 0x18, 0x1c, 0x10 }, // bl64
+        { 0x18, 0x1c, 0x18,   -1, 0x1c, 0x1c, 0x18, 0x1c, 0x1e, 0x18 }, // bl32
+        { 0x1c, 0x1e, 0x1c,   -1, 0x1e, 0x1e, 0x1c, 0x1e, 0x1f, 0x1c }, // bl16
+        { 0x1e, 0x1f, 0x1e, 0x1f,   -1,   -1,   -1,   -1,   -1,   -1 }, // bl8
+    }
+};
+
+const uint8_t /* enum BlockSize */
+    av1_block_sizes[N_BL_LEVELS][N_PARTITIONS][2] =
+{
+    [BL_128X128] = {
+        [PARTITION_NONE]           = { BS_128x128 },
+        [PARTITION_H]              = { BS_128x64 },
+        [PARTITION_V]              = { BS_64x128 },
+        [PARTITION_T_TOP_SPLIT]    = { BS_64x64, BS_128x64 },
+        [PARTITION_T_BOTTOM_SPLIT] = { BS_128x64, BS_64x64 },
+        [PARTITION_T_LEFT_SPLIT]   = { BS_64x64, BS_64x128 },
+        [PARTITION_T_RIGHT_SPLIT]  = { BS_64x128, BS_64x64 },
+    }, [BL_64X64] = {
+        [PARTITION_NONE]           = { BS_64x64 },
+        [PARTITION_H]              = { BS_64x32 },
+        [PARTITION_V]              = { BS_32x64 },
+        [PARTITION_T_TOP_SPLIT]    = { BS_32x32, BS_64x32 },
+        [PARTITION_T_BOTTOM_SPLIT] = { BS_64x32, BS_32x32 },
+        [PARTITION_T_LEFT_SPLIT]   = { BS_32x32, BS_32x64 },
+        [PARTITION_T_RIGHT_SPLIT]  = { BS_32x64, BS_32x32 },
+        [PARTITION_H4]             = { BS_64x16 },
+        [PARTITION_V4]             = { BS_16x64 },
+    }, [BL_32X32] = {
+        [PARTITION_NONE]           = { BS_32x32 },
+        [PARTITION_H]              = { BS_32x16 },
+        [PARTITION_V]              = { BS_16x32 },
+        [PARTITION_T_TOP_SPLIT]    = { BS_16x16, BS_32x16 },
+        [PARTITION_T_BOTTOM_SPLIT] = { BS_32x16, BS_16x16 },
+        [PARTITION_T_LEFT_SPLIT]   = { BS_16x16, BS_16x32 },
+        [PARTITION_T_RIGHT_SPLIT]  = { BS_16x32, BS_16x16 },
+        [PARTITION_H4]             = { BS_32x8  },
+        [PARTITION_V4]             = { BS_8x32  },
+    }, [BL_16X16] = {
+        [PARTITION_NONE]           = { BS_16x16 },
+        [PARTITION_H]              = { BS_16x8  },
+        [PARTITION_V]              = { BS_8x16  },
+        [PARTITION_T_TOP_SPLIT]    = { BS_8x8,   BS_16x8  },
+        [PARTITION_T_BOTTOM_SPLIT] = { BS_16x8,  BS_8x8   },
+        [PARTITION_T_LEFT_SPLIT]   = { BS_8x8,   BS_8x16  },
+        [PARTITION_T_RIGHT_SPLIT]  = { BS_8x16,  BS_8x8   },
+        [PARTITION_H4]             = { BS_16x4  },
+        [PARTITION_V4]             = { BS_4x16  },
+    }, [BL_8X8] = {
+        [PARTITION_NONE]           = { BS_8x8   },
+        [PARTITION_H]              = { BS_8x4   },
+        [PARTITION_V]              = { BS_4x8   },
+        [PARTITION_SPLIT]          = { BS_4x4   },
+    }
+};
+
+const uint8_t av1_block_dimensions[N_BS_SIZES][4] = {
+    [BS_128x128] = { 32, 32, 5, 5 },
+    [BS_128x64]  = { 32, 16, 5, 4 },
+    [BS_64x128]  = { 16, 32, 4, 5 },
+    [BS_64x64]   = { 16, 16, 4, 4 },
+    [BS_64x32]   = { 16,  8, 4, 3 },
+    [BS_64x16]   = { 16,  4, 4, 2 },
+    [BS_32x64]   = {  8, 16, 3, 4 },
+    [BS_32x32]   = {  8,  8, 3, 3 },
+    [BS_32x16]   = {  8,  4, 3, 2 },
+    [BS_32x8]    = {  8,  2, 3, 1 },
+    [BS_16x64]   = {  4, 16, 2, 4 },
+    [BS_16x32]   = {  4,  8, 2, 3 },
+    [BS_16x16]   = {  4,  4, 2, 2 },
+    [BS_16x8]    = {  4,  2, 2, 1 },
+    [BS_16x4]    = {  4,  1, 2, 0 },
+    [BS_8x32]    = {  2,  8, 1, 3 },
+    [BS_8x16]    = {  2,  4, 1, 2 },
+    [BS_8x8]     = {  2,  2, 1, 1 },
+    [BS_8x4]     = {  2,  1, 1, 0 },
+    [BS_4x16]    = {  1,  4, 0, 2 },
+    [BS_4x8]     = {  1,  2, 0, 1 },
+    [BS_4x4]     = {  1,  1, 0, 0 },
+};
+
+const TxfmInfo av1_txfm_dimensions[N_RECT_TX_SIZES] = {
+    [ TX_4X4]   = { .w = 1, .h = 1, .lw = 0, .lh = 0,
+                    .min = 0, .max = 0, .ctx = 0 },
+    [ TX_8X8]   = { .w = 2, .h = 2, .lw = 1, .lh = 1,
+                    .min = 1, .max = 1, .sub = TX_4X4, .ctx = 1 },
+    [ TX_16X16] = { .w = 4, .h = 4, .lw = 2, .lh = 2,
+                    .min = 2, .max = 2, .sub = TX_8X8, .ctx = 2 },
+    [ TX_32X32] = { .w = 8, .h = 8, .lw = 3, .lh = 3,
+                    .min = 3, .max = 3, .sub = TX_16X16, .ctx = 3 },
+    [ TX_64X64] = { .w = 16, .h = 16, .lw = 4, .lh = 4,
+                    .min = 4, .max = 4, .sub = TX_32X32, .ctx = 4 },
+    [RTX_4X8]   = { .w = 1, .h = 2, .lw = 0, .lh = 1,
+                    .min = 0, .max = 1, .sub = TX_4X4, .ctx = 1 },
+    [RTX_8X4]   = { .w = 2, .h = 1, .lw = 1, .lh = 0,
+                    .min = 0, .max = 1, .sub = TX_4X4, .ctx = 1 },
+    [RTX_8X16]  = { .w = 2, .h = 4, .lw = 1, .lh = 2,
+                    .min = 1, .max = 2, .sub = TX_8X8, .ctx = 2 },
+    [RTX_16X8]  = { .w = 4, .h = 2, .lw = 2, .lh = 1,
+                    .min = 1, .max = 2, .sub = TX_8X8, .ctx = 2 },
+    [RTX_16X32] = { .w = 4, .h = 8, .lw = 2, .lh = 3,
+                    .min = 2, .max = 3, .sub = TX_16X16, .ctx = 3 },
+    [RTX_32X16] = { .w = 8, .h = 4, .lw = 3, .lh = 2,
+                    .min = 2, .max = 3, .sub = TX_16X16, .ctx = 3 },
+    [RTX_32X64] = { .w = 8, .h = 16, .lw = 3, .lh = 4,
+                    .min = 3, .max = 4, .sub = TX_32X32, .ctx = 4 },
+    [RTX_64X32] = { .w = 16, .h = 8, .lw = 4, .lh = 3,
+                    .min = 3, .max = 4, .sub = TX_32X32, .ctx = 4 },
+    [RTX_4X16]  = { .w = 1, .h = 4, .lw = 0, .lh = 2,
+                    .min = 0, .max = 2, .sub = RTX_4X8, .ctx = 1 },
+    [RTX_16X4]  = { .w = 4, .h = 1, .lw = 2, .lh = 0,
+                    .min = 0, .max = 2, .sub = RTX_8X4, .ctx = 1 },
+    [RTX_8X32]  = { .w = 2, .h = 8, .lw = 1, .lh = 3,
+                    .min = 1, .max = 3, .sub = RTX_8X16, .ctx = 2 },
+    [RTX_32X8]  = { .w = 8, .h = 2, .lw = 3, .lh = 1,
+                    .min = 1, .max = 3, .sub = RTX_16X8, .ctx = 2 },
+    [RTX_16X64] = { .w = 4, .h = 16, .lw = 2, .lh = 4,
+                    .min = 2, .max = 4, .sub = RTX_16X32, .ctx = 3 },
+    [RTX_64X16] = { .w = 16, .h = 4, .lw = 4, .lh = 2,
+                    .min = 2, .max = 4, .sub = RTX_32X16, .ctx = 3 },
+};
+
+const uint8_t /* enum (Rect)TxfmSize */
+    av1_max_txfm_size_for_bs[N_BS_SIZES][4 /* y, 420, 422, 444 */] =
+{
+    [BS_128x128] = {  TX_64X64,  TX_32X32,  TX_32X32,  TX_32X32 },
+    [BS_128x64]  = {  TX_64X64,  TX_32X32,  TX_32X32,  TX_32X32 },
+    [BS_64x128]  = {  TX_64X64,  TX_32X32,       0,    TX_32X32 },
+    [BS_64x64]   = {  TX_64X64,  TX_32X32,  TX_32X32,  TX_32X32 },
+    [BS_64x32]   = { RTX_64X32, RTX_32X16,  TX_32X32,  TX_32X32 },
+    [BS_64x16]   = { RTX_64X16, RTX_32X8,  RTX_32X16, RTX_32X16 },
+    [BS_32x64]   = { RTX_32X64, RTX_16X32,       0,    TX_32X32 },
+    [BS_32x32]   = {  TX_32X32,  TX_16X16, RTX_16X32,  TX_32X32 },
+    [BS_32x16]   = { RTX_32X16, RTX_16X8,   TX_16X16, RTX_32X16 },
+    [BS_32x8]    = { RTX_32X8,  RTX_16X4,  RTX_16X8,  RTX_32X8  },
+    [BS_16x64]   = { RTX_16X64, RTX_8X32,        0,   RTX_16X32 },
+    [BS_16x32]   = { RTX_16X32, RTX_8X16,        0,   RTX_16X32 },
+    [BS_16x16]   = {  TX_16X16,  TX_8X8,   RTX_8X16,   TX_16X16 },
+    [BS_16x8]    = { RTX_16X8,  RTX_8X4,    TX_8X8,   RTX_16X8  },
+    [BS_16x4]    = { RTX_16X4,  RTX_8X4,   RTX_8X4,   RTX_16X4  },
+    [BS_8x32]    = { RTX_8X32,  RTX_4X16,       0,    RTX_8X32  },
+    [BS_8x16]    = { RTX_8X16,  RTX_4X8,        0,    RTX_8X16  },
+    [BS_8x8]     = {  TX_8X8,    TX_4X4,   RTX_4X8,    TX_8X8   },
+    [BS_8x4]     = { RTX_8X4,    TX_4X4,    TX_4X4,   RTX_8X4   },
+    [BS_4x16]    = { RTX_4X16,  RTX_4X8,        0,    RTX_4X16  },
+    [BS_4x8]     = { RTX_4X8,    TX_4X4,        0,    RTX_4X8   },
+    [BS_4x4]     = {  TX_4X4,    TX_4X4,    TX_4X4,    TX_4X4   },
+};
+
+const uint8_t /* enum TxfmType */
+    av1_txtp_from_uvmode[N_UV_INTRA_PRED_MODES] =
+{
+    [DC_PRED]              = DCT_DCT,
+    [VERT_PRED]            = ADST_DCT,
+    [HOR_PRED]             = DCT_ADST,
+    [DIAG_DOWN_LEFT_PRED]  = DCT_DCT,
+    [DIAG_DOWN_RIGHT_PRED] = ADST_ADST,
+    [VERT_RIGHT_PRED]      = ADST_DCT,
+    [HOR_DOWN_PRED]        = DCT_ADST,
+    [HOR_UP_PRED]          = DCT_ADST,
+    [VERT_LEFT_PRED]       = ADST_DCT,
+    [SMOOTH_PRED]          = ADST_ADST,
+    [SMOOTH_V_PRED]        = ADST_DCT,
+    [SMOOTH_H_PRED]        = DCT_ADST,
+    [PAETH_PRED]           = ADST_ADST,
+};
+
+const uint8_t /* enum InterPredMode */
+    av1_comp_inter_pred_modes[N_COMP_INTER_PRED_MODES][2] =
+{
+    [NEARESTMV_NEARESTMV] = { NEARESTMV, NEARESTMV },
+    [NEARMV_NEARMV]       = { NEARMV,    NEARMV    },
+    [NEWMV_NEWMV]         = { NEWMV,     NEWMV     },
+    [GLOBALMV_GLOBALMV]   = { GLOBALMV,  GLOBALMV  },
+    [NEWMV_NEARESTMV]     = { NEWMV,     NEARESTMV },
+    [NEWMV_NEARMV]        = { NEWMV,     NEARMV    },
+    [NEARESTMV_NEWMV]     = { NEARESTMV, NEWMV     },
+    [NEARMV_NEWMV]        = { NEARMV,    NEWMV     },
+};
+
+const uint8_t av1_tx_type_count[N_TXTP_SETS] = {
+    [TXTP_SET_DCT] = 1,
+    [TXTP_SET_DCT_ID] = 2,
+    [TXTP_SET_DT4_ID] = 5,
+    [TXTP_SET_DT4_ID_1D] = 7,
+    [TXTP_SET_DT9_ID_1D] = 12,
+    [TXTP_SET_ALL] = 16,
+    [TXTP_SET_LOSSLESS] = 1,
+};
+
+const uint8_t /* enum TxfmType */
+              av1_tx_types_per_set[N_TXTP_SETS][N_TX_TYPES] =
+{
+    [TXTP_SET_DCT]       = { DCT_DCT },
+    [TXTP_SET_DCT_ID]    = { IDTX, DCT_DCT },
+    [TXTP_SET_DT4_ID]    = { IDTX, DCT_DCT, ADST_ADST, ADST_DCT, DCT_ADST },
+    [TXTP_SET_DT4_ID_1D] = { IDTX, DCT_DCT, V_DCT, H_DCT, ADST_ADST, ADST_DCT,
+                             DCT_ADST },
+    [TXTP_SET_DT9_ID_1D] = { IDTX, V_DCT, H_DCT, DCT_DCT, ADST_DCT, DCT_ADST,
+                             FLIPADST_DCT, DCT_FLIPADST, ADST_ADST,
+                             FLIPADST_FLIPADST, ADST_FLIPADST, FLIPADST_ADST },
+    [TXTP_SET_ALL]       = { IDTX, V_DCT, H_DCT, V_ADST, H_ADST, V_FLIPADST,
+                             H_FLIPADST, DCT_DCT, ADST_DCT, DCT_ADST,
+                             FLIPADST_DCT, DCT_FLIPADST, ADST_ADST,
+                             FLIPADST_FLIPADST, ADST_FLIPADST, FLIPADST_ADST },
+    [TXTP_SET_LOSSLESS]  = { WHT_WHT },
+};
+
+const uint8_t av1_tx_type_set_index[2][N_TXTP_SETS] = {
+    { 0, -1,  2,  1, -1, -1, 3 },
+    { 0,  3, -1, -1,  2,  1, 4 },
+};
+
+const uint8_t av1_ymode_size_context[N_BS_SIZES] = {
+    [BS_128x128] = 3,
+    [BS_128x64]  = 3,
+    [BS_64x128]  = 3,
+    [BS_64x64]   = 3,
+    [BS_64x32]   = 3,
+    [BS_64x16]   = 2,
+    [BS_32x64]   = 3,
+    [BS_32x32]   = 3,
+    [BS_32x16]   = 2,
+    [BS_32x8 ]   = 1,
+    [BS_16x64]   = 2,
+    [BS_16x32]   = 2,
+    [BS_16x16]   = 2,
+    [BS_16x8 ]   = 1,
+    [BS_16x4 ]   = 0,
+    [BS_8x32 ]   = 1,
+    [BS_8x16 ]   = 1,
+    [BS_8x8  ]   = 1,
+    [BS_8x4  ]   = 0,
+    [BS_4x16 ]   = 0,
+    [BS_4x8  ]   = 0,
+    [BS_4x4  ]   = 0,
+};
+
+const uint8_t av1_nz_map_ctx_offset[N_RECT_TX_SIZES][5][5] = {
+    [TX_4X4] = {
+        { 0, 1, 6, 6 },
+        { 1, 6, 6, 21 },
+        { 6, 6, 21, 21 },
+        { 6, 21, 21, 21 },
+    }, [TX_8X8] = {
+        { 0, 1, 6, 6, 21 },
+        { 1, 6, 6, 21, 21 },
+        { 6, 6, 21, 21, 21 },
+        { 6, 21, 21, 21, 21 },
+        { 21, 21, 21, 21, 21 }
+    }, [TX_16X16] = {
+        { 0, 1, 6, 6, 21 },
+        { 1, 6, 6, 21, 21 },
+        { 6, 6, 21, 21, 21 },
+        { 6, 21, 21, 21, 21 },
+        { 21, 21, 21, 21, 21 }
+    }, [TX_32X32] = {
+        { 0, 1, 6, 6, 21 },
+        { 1, 6, 6, 21, 21 },
+        { 6, 6, 21, 21, 21 },
+        { 6, 21, 21, 21, 21 },
+        { 21, 21, 21, 21, 21 }
+    }, [TX_64X64] = {
+        { 0, 1, 6, 6, 21 },
+        { 1, 6, 6, 21, 21 },
+        { 6, 6, 21, 21, 21 },
+        { 6, 21, 21, 21, 21 },
+        { 21, 21, 21, 21, 21 }
+    }, [RTX_4X8] = {
+        { 0, 11, 11, 11 },
+        { 11, 11, 11, 11 },
+        { 6, 6, 21, 21 },
+        { 6, 21, 21, 21 },
+        { 21, 21, 21, 21 }
+    }, [RTX_8X4] = {
+        { 0, 16, 6, 6, 21 },
+        { 16, 16, 6, 21, 21 },
+        { 16, 16, 21, 21, 21 },
+        { 16, 16, 21, 21, 21 },
+    }, [RTX_8X16] = {
+        { 0, 11, 11, 11, 11 },
+        { 11, 11, 11, 11, 11 },
+        { 6, 6, 21, 21, 21 },
+        { 6, 21, 21, 21, 21 },
+        { 21, 21, 21, 21, 21 }
+    }, [RTX_16X8] = {
+        { 0, 16, 6, 6, 21 },
+        { 16, 16, 6, 21, 21 },
+        { 16, 16, 21, 21, 21 },
+        { 16, 16, 21, 21, 21 },
+        { 16, 16, 21, 21, 21 }
+    }, [RTX_16X32] = {
+        { 0, 11, 11, 11, 11 },
+        { 11, 11, 11, 11, 11 },
+        { 6, 6, 21, 21, 21 },
+        { 6, 21, 21, 21, 21 },
+        { 21, 21, 21, 21, 21 }
+    }, [RTX_32X16] = {
+        { 0, 16, 6, 6, 21 },
+        { 16, 16, 6, 21, 21 },
+        { 16, 16, 21, 21, 21 },
+        { 16, 16, 21, 21, 21 },
+        { 16, 16, 21, 21, 21 }
+    }, [RTX_32X64] = {
+        { 0, 11, 11, 11, 11 },
+        { 11, 11, 11, 11, 11 },
+        { 6, 6, 21, 21, 21 },
+        { 6, 21, 21, 21, 21 },
+        { 21, 21, 21, 21, 21 }
+    }, [RTX_64X32] = {
+        { 0, 16, 6, 6, 21 },
+        { 16, 16, 6, 21, 21 },
+        { 16, 16, 21, 21, 21 },
+        { 16, 16, 21, 21, 21 },
+        { 16, 16, 21, 21, 21 }
+    }, [RTX_4X16] = {
+        { 0, 11, 11, 11 },
+        { 11, 11, 11, 11 },
+        { 6, 6, 21, 21 },
+        { 6, 21, 21, 21 },
+        { 21, 21, 21, 21 }
+    }, [RTX_16X4] = {
+        { 0, 16, 6, 6, 21 },
+        { 16, 16, 6, 21, 21 },
+        { 16, 16, 21, 21, 21 },
+        { 16, 16, 21, 21, 21 },
+    }, [RTX_8X32] = {
+        { 0, 11, 11, 11, 11 },
+        { 11, 11, 11, 11, 11 },
+        { 6, 6, 21, 21, 21 },
+        { 6, 21, 21, 21, 21 },
+        { 21, 21, 21, 21, 21 }
+    }, [RTX_32X8] = {
+        { 0, 16, 6, 6, 21 },
+        { 16, 16, 6, 21, 21 },
+        { 16, 16, 21, 21, 21 },
+        { 16, 16, 21, 21, 21 },
+        { 16, 16, 21, 21, 21 }
+    }, [RTX_16X64] = {
+        { 0, 11, 11, 11, 11 },
+        { 11, 11, 11, 11, 11 },
+        { 6, 6, 21, 21, 21 },
+        { 6, 21, 21, 21, 21 },
+        { 21, 21, 21, 21, 21 }
+    }, [RTX_64X16] = {
+        { 0, 16, 6, 6, 21 },
+        { 16, 16, 6, 21, 21 },
+        { 16, 16, 21, 21, 21 },
+        { 16, 16, 21, 21, 21 },
+        { 16, 16, 21, 21, 21 }
+    }
+};
+
+const uint8_t /* enum TxClass */ av1_tx_type_class[N_TX_TYPES_PLUS_LL] = {
+    [DCT_DCT]           = TX_CLASS_2D,
+    [ADST_DCT]          = TX_CLASS_2D,
+    [DCT_ADST]          = TX_CLASS_2D,
+    [ADST_ADST]         = TX_CLASS_2D,
+    [FLIPADST_DCT]      = TX_CLASS_2D,
+    [DCT_FLIPADST]      = TX_CLASS_2D,
+    [FLIPADST_FLIPADST] = TX_CLASS_2D,
+    [ADST_FLIPADST]     = TX_CLASS_2D,
+    [FLIPADST_ADST]     = TX_CLASS_2D,
+    [IDTX]              = TX_CLASS_2D,
+    [V_DCT]             = TX_CLASS_V,
+    [H_DCT]             = TX_CLASS_H,
+    [V_ADST]            = TX_CLASS_V,
+    [H_ADST]            = TX_CLASS_H,
+    [V_FLIPADST]        = TX_CLASS_V,
+    [H_FLIPADST]        = TX_CLASS_H,
+    [WHT_WHT]           = TX_CLASS_2D,
+};
+
+const uint8_t /* enum Filter2d */ av1_filter_2d[N_FILTERS][N_FILTERS] = {
+    [FILTER_8TAP_REGULAR] = {
+        [FILTER_8TAP_REGULAR] = FILTER_2D_8TAP_REGULAR,
+        [FILTER_8TAP_SHARP]   = FILTER_2D_8TAP_REGULAR_SHARP,
+        [FILTER_8TAP_SMOOTH]  = FILTER_2D_8TAP_REGULAR_SMOOTH,
+    }, [FILTER_8TAP_SHARP] = {
+        [FILTER_8TAP_REGULAR] = FILTER_2D_8TAP_SHARP_REGULAR,
+        [FILTER_8TAP_SHARP]   = FILTER_2D_8TAP_SHARP,
+        [FILTER_8TAP_SMOOTH]  = FILTER_2D_8TAP_SHARP_SMOOTH,
+    }, [FILTER_8TAP_SMOOTH] = {
+        [FILTER_8TAP_REGULAR] = FILTER_2D_8TAP_SMOOTH_REGULAR,
+        [FILTER_8TAP_SHARP]   = FILTER_2D_8TAP_SMOOTH_SHARP,
+        [FILTER_8TAP_SMOOTH]  = FILTER_2D_8TAP_SMOOTH,
+    }, [FILTER_BILINEAR] = {
+        [FILTER_BILINEAR]     = FILTER_2D_BILINEAR,
+    }
+};
+
+const uint8_t /* enum FilterMode */ eve_av1_filter_dir[N_2D_FILTERS][2] = {
+    [FILTER_2D_8TAP_REGULAR]        = { FILTER_8TAP_REGULAR, FILTER_8TAP_REGULAR },
+    [FILTER_2D_8TAP_REGULAR_SMOOTH] = { FILTER_8TAP_SMOOTH,  FILTER_8TAP_REGULAR },
+    [FILTER_2D_8TAP_REGULAR_SHARP]  = { FILTER_8TAP_SHARP,   FILTER_8TAP_REGULAR },
+    [FILTER_2D_8TAP_SHARP_REGULAR]  = { FILTER_8TAP_REGULAR, FILTER_8TAP_SHARP   },
+    [FILTER_2D_8TAP_SHARP_SMOOTH]   = { FILTER_8TAP_SMOOTH,  FILTER_8TAP_SHARP   },
+    [FILTER_2D_8TAP_SHARP]          = { FILTER_8TAP_SHARP,   FILTER_8TAP_SHARP   },
+    [FILTER_2D_8TAP_SMOOTH_REGULAR] = { FILTER_8TAP_REGULAR, FILTER_8TAP_SMOOTH  },
+    [FILTER_2D_8TAP_SMOOTH]         = { FILTER_8TAP_SMOOTH,  FILTER_8TAP_SMOOTH  },
+    [FILTER_2D_8TAP_SMOOTH_SHARP]   = { FILTER_8TAP_SHARP,   FILTER_8TAP_SMOOTH  },
+    [FILTER_2D_BILINEAR]            = { FILTER_2D_BILINEAR,  FILTER_2D_BILINEAR  },
+};
+
+const uint8_t av1_filter_mode_to_y_mode[5] = {
+    DC_PRED, VERT_PRED, HOR_PRED, HOR_DOWN_PRED, DC_PRED
+};
+
+const uint8_t intra_mode_context[N_INTRA_PRED_MODES] = {
+    [DC_PRED]              = 0,
+    [VERT_PRED]            = 1,
+    [HOR_PRED]             = 2,
+    [DIAG_DOWN_LEFT_PRED]  = 3,
+    [DIAG_DOWN_RIGHT_PRED] = 4,
+    [VERT_RIGHT_PRED]      = 4,
+    [HOR_DOWN_PRED]        = 4,
+    [HOR_UP_PRED]          = 4,
+    [VERT_LEFT_PRED]       = 3,
+    [SMOOTH_PRED]          = 0,
+    [SMOOTH_V_PRED]        = 1,
+    [SMOOTH_H_PRED]        = 2,
+    [PAETH_PRED]           = 0,
+};
+
+const unsigned cfl_allowed_mask =
+    (1 << BS_32x32) |
+    (1 << BS_32x16) |
+    (1 << BS_32x8) |
+    (1 << BS_16x32) |
+    (1 << BS_16x16) |
+    (1 << BS_16x8) |
+    (1 << BS_16x4) |
+    (1 << BS_8x32) |
+    (1 << BS_8x16) |
+    (1 << BS_8x8) |
+    (1 << BS_8x4) |
+    (1 << BS_4x16) |
+    (1 << BS_4x8) |
+    (1 << BS_4x4);
+
+const unsigned wedge_allowed_mask =
+    (1 << BS_32x32) |
+    (1 << BS_32x16) |
+    (1 << BS_32x8) |
+    (1 << BS_16x32) |
+    (1 << BS_16x16) |
+    (1 << BS_16x8) |
+    (1 << BS_8x32) |
+    (1 << BS_8x16) |
+    (1 << BS_8x8);
+
+const unsigned interintra_allowed_mask =
+    (1 << BS_32x32) |
+    (1 << BS_32x16) |
+    (1 << BS_16x32) |
+    (1 << BS_16x16) |
+    (1 << BS_16x8) |
+    (1 << BS_8x16) |
+    (1 << BS_8x8);
+
+const uint8_t av1_wedge_ctx_lut[N_BS_SIZES] = {
+    [BS_32x32] = 6,
+    [BS_32x16] = 5,
+    [BS_32x8]  = 8,
+    [BS_16x32] = 4,
+    [BS_16x16] = 3,
+    [BS_16x8]  = 2,
+    [BS_8x32]  = 7,
+    [BS_8x16]  = 1,
+    [BS_8x8]   = 0,
+};
+
+const WarpedMotionParams default_wm_params = {
+    .type = WM_TYPE_IDENTITY,
+    .matrix = {
+        0, 0, 1 << 16,
+        0, 0, 1 << 16,
+    },
+    .alpha = 0,
+    .beta = 0,
+    .gamma = 0,
+    .delta = 0,
+};
+
+const int16_t sgr_params[16][4] = { // r0, r1, e0, e1
+    { 2, 1, 140, 3236 }, { 2, 1, 112, 2158 }, { 2, 1, 93, 1618 },
+    { 2, 1,  80, 1438 }, { 2, 1,  70, 1295 }, { 2, 1, 58, 1177 },
+    { 2, 1,  47, 1079 }, { 2, 1,  37,  996 }, { 2, 1, 30,  925 },
+    { 2, 1,  25,  863 }, { 0, 1,  -1, 2589 }, { 0, 1, -1, 1618 },
+    { 0, 1,  -1, 1177 }, { 0, 1,  -1,  925 }, { 2, 0, 56,   -1 },
+    { 2, 0,  22,   -1 },
+};
+
+const int16_t sgr_x_by_xplus1[256] = {
+  1,   128, 171, 192, 205, 213, 219, 224, 228, 230, 233, 235, 236, 238, 239,
+  240, 241, 242, 243, 243, 244, 244, 245, 245, 246, 246, 247, 247, 247, 247,
+  248, 248, 248, 248, 249, 249, 249, 249, 249, 250, 250, 250, 250, 250, 250,
+  250, 251, 251, 251, 251, 251, 251, 251, 251, 251, 251, 252, 252, 252, 252,
+  252, 252, 252, 252, 252, 252, 252, 252, 252, 252, 252, 252, 252, 253, 253,
+  253, 253, 253, 253, 253, 253, 253, 253, 253, 253, 253, 253, 253, 253, 253,
+  253, 253, 253, 253, 253, 253, 253, 253, 253, 253, 253, 253, 254, 254, 254,
+  254, 254, 254, 254, 254, 254, 254, 254, 254, 254, 254, 254, 254, 254, 254,
+  254, 254, 254, 254, 254, 254, 254, 254, 254, 254, 254, 254, 254, 254, 254,
+  254, 254, 254, 254, 254, 254, 254, 254, 254, 254, 254, 254, 254, 254, 254,
+  254, 254, 254, 254, 254, 254, 254, 254, 254, 254, 254, 254, 254, 254, 254,
+  254, 254, 254, 254, 254, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
+  255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
+  255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
+  255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
+  255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
+  255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
+  256,
+};
+
+const int16_t sgr_one_by_x[] = {
+  4096, 2048, 1365, 1024, 819, 683, 585, 512, 455, 410, 372, 341, 315,
+  293,  273,  256,  241,  228, 216, 205, 195, 186, 178, 171, 164,
+};
+
+const int8_t dav1d_mc_subpel_filters[5][15][8] = {
+    [FILTER_8TAP_REGULAR] = {
+        { 0, 2,  -6, 126,   8,  -2, 0, 0 },
+        { 0, 2, -10, 122,  18,  -4, 0, 0 },
+        { 0, 2, -12, 116,  28,  -8, 2, 0 },
+        { 0, 2, -14, 110,  38, -10, 2, 0 },
+        { 0, 2, -14, 102,  48, -12, 2, 0 },
+        { 0, 2, -16,  94,  58, -12, 2, 0 },
+        { 0, 2, -14,  84,  66, -12, 2, 0 },
+        { 0, 2, -14,  76,  76, -14, 2, 0 },
+        { 0, 2, -12,  66,  84, -14, 2, 0 },
+        { 0, 2, -12,  58,  94, -16, 2, 0 },
+        { 0, 2, -12,  48, 102, -14, 2, 0 },
+        { 0, 2, -10,  38, 110, -14, 2, 0 },
+        { 0, 2,  -8,  28, 116, -12, 2, 0 },
+        { 0, 0,  -4,  18, 122, -10, 2, 0 },
+        { 0, 0,  -2,   8, 126,  -6, 2, 0 }
+    }, [FILTER_8TAP_SHARP] = {
+        { -2,  2,  -6, 126,   8,  -2,  2,  0 },
+        { -2,  6, -12, 124,  16,  -6,  4, -2 },
+        { -2,  8, -18, 120,  26, -10,  6, -2 },
+        { -4, 10, -22, 116,  38, -14,  6, -2 },
+        { -4, 10, -22, 108,  48, -18,  8, -2 },
+        { -4, 10, -24, 100,  60, -20,  8, -2 },
+        { -4, 10, -24,  90,  70, -22, 10, -2 },
+        { -4, 12, -24,  80,  80, -24, 12, -4 },
+        { -2, 10, -22,  70,  90, -24, 10, -4 },
+        { -2,  8, -20,  60, 100, -24, 10, -4 },
+        { -2,  8, -18,  48, 108, -22, 10, -4 },
+        { -2,  6, -14,  38, 116, -22, 10, -4 },
+        { -2,  6, -10,  26, 120, -18,  8, -2 },
+        { -2,  4,  -6,  16, 124, -12,  6, -2 },
+        {  0,  2,  -2,   8, 126,  -6,  2, -2 }
+    }, [FILTER_8TAP_SMOOTH] = {
+        { 0,  2, 28,  62, 34,  2,  0, 0 },
+        { 0,  0, 26,  62, 36,  4,  0, 0 },
+        { 0,  0, 22,  62, 40,  4,  0, 0 },
+        { 0,  0, 20,  60, 42,  6,  0, 0 },
+        { 0,  0, 18,  58, 44,  8,  0, 0 },
+        { 0,  0, 16,  56, 46, 10,  0, 0 },
+        { 0, -2, 16,  54, 48, 12,  0, 0 },
+        { 0, -2, 14,  52, 52, 14, -2, 0 },
+        { 0,  0, 12,  48, 54, 16, -2, 0 },
+        { 0,  0, 10,  46, 56, 16,  0, 0 },
+        { 0,  0,  8,  44, 58, 18,  0, 0 },
+        { 0,  0,  6,  42, 60, 20,  0, 0 },
+        { 0,  0,  4,  40, 62, 22,  0, 0 },
+        { 0,  0,  4,  36, 62, 26,  0, 0 },
+        { 0,  0,  2,  34, 62, 28,  2, 0 },
+    },
+    /* width <= 4 */
+    [3 + FILTER_8TAP_REGULAR] = {
+        { 0, 0,  -4, 126,   8,  -2, 0, 0 },
+        { 0, 0,  -8, 122,  18,  -4, 0, 0 },
+        { 0, 0, -10, 116,  28,  -6, 0, 0 },
+        { 0, 0, -12, 110,  38,  -8, 0, 0 },
+        { 0, 0, -12, 102,  48, -10, 0, 0 },
+        { 0, 0, -14,  94,  58, -10, 0, 0 },
+        { 0, 0, -12,  84,  66, -10, 0, 0 },
+        { 0, 0, -12,  76,  76, -12, 0, 0 },
+        { 0, 0, -10,  66,  84, -12, 0, 0 },
+        { 0, 0, -10,  58,  94, -14, 0, 0 },
+        { 0, 0, -10,  48, 102, -12, 0, 0 },
+        { 0, 0,  -8,  38, 110, -12, 0, 0 },
+        { 0, 0,  -6,  28, 116, -10, 0, 0 },
+        { 0, 0,  -4,  18, 122,  -8, 0, 0 },
+        { 0, 0,  -2,   8, 126,  -4, 0, 0 }
+    }, [3 + FILTER_8TAP_SMOOTH] = {
+        { 0, 0, 30,  62, 34,  2, 0, 0 },
+        { 0, 0, 26,  62, 36,  4, 0, 0 },
+        { 0, 0, 22,  62, 40,  4, 0, 0 },
+        { 0, 0, 20,  60, 42,  6, 0, 0 },
+        { 0, 0, 18,  58, 44,  8, 0, 0 },
+        { 0, 0, 16,  56, 46, 10, 0, 0 },
+        { 0, 0, 14,  54, 48, 12, 0, 0 },
+        { 0, 0, 12,  52, 52, 12, 0, 0 },
+        { 0, 0, 12,  48, 54, 14, 0, 0 },
+        { 0, 0, 10,  46, 56, 16, 0, 0 },
+        { 0, 0,  8,  44, 58, 18, 0, 0 },
+        { 0, 0,  6,  42, 60, 20, 0, 0 },
+        { 0, 0,  4,  40, 62, 22, 0, 0 },
+        { 0, 0,  4,  36, 62, 26, 0, 0 },
+        { 0, 0,  2,  34, 62, 30, 0, 0 }
+    }
+};
+
+const int8_t dav1d_mc_warp_filter[][8] = {
+    // [-1, 0)
+    { 0,   0, 127,   1,   0, 0, 0, 0 }, { 0, - 1, 127,   2,   0, 0, 0, 0 },
+    { 1, - 3, 127,   4, - 1, 0, 0, 0 }, { 1, - 4, 126,   6, - 2, 1, 0, 0 },
+    { 1, - 5, 126,   8, - 3, 1, 0, 0 }, { 1, - 6, 125,  11, - 4, 1, 0, 0 },
+    { 1, - 7, 124,  13, - 4, 1, 0, 0 }, { 2, - 8, 123,  15, - 5, 1, 0, 0 },
+    { 2, - 9, 122,  18, - 6, 1, 0, 0 }, { 2, -10, 121,  20, - 6, 1, 0, 0 },
+    { 2, -11, 120,  22, - 7, 2, 0, 0 }, { 2, -12, 119,  25, - 8, 2, 0, 0 },
+    { 3, -13, 117,  27, - 8, 2, 0, 0 }, { 3, -13, 116,  29, - 9, 2, 0, 0 },
+    { 3, -14, 114,  32, -10, 3, 0, 0 }, { 3, -15, 113,  35, -10, 2, 0, 0 },
+    { 3, -15, 111,  37, -11, 3, 0, 0 }, { 3, -16, 109,  40, -11, 3, 0, 0 },
+    { 3, -16, 108,  42, -12, 3, 0, 0 }, { 4, -17, 106,  45, -13, 3, 0, 0 },
+    { 4, -17, 104,  47, -13, 3, 0, 0 }, { 4, -17, 102,  50, -14, 3, 0, 0 },
+    { 4, -17, 100,  52, -14, 3, 0, 0 }, { 4, -18,  98,  55, -15, 4, 0, 0 },
+    { 4, -18,  96,  58, -15, 3, 0, 0 }, { 4, -18,  94,  60, -16, 4, 0, 0 },
+    { 4, -18,  91,  63, -16, 4, 0, 0 }, { 4, -18,  89,  65, -16, 4, 0, 0 },
+    { 4, -18,  87,  68, -17, 4, 0, 0 }, { 4, -18,  85,  70, -17, 4, 0, 0 },
+    { 4, -18,  82,  73, -17, 4, 0, 0 }, { 4, -18,  80,  75, -17, 4, 0, 0 },
+    { 4, -18,  78,  78, -18, 4, 0, 0 }, { 4, -17,  75,  80, -18, 4, 0, 0 },
+    { 4, -17,  73,  82, -18, 4, 0, 0 }, { 4, -17,  70,  85, -18, 4, 0, 0 },
+    { 4, -17,  68,  87, -18, 4, 0, 0 }, { 4, -16,  65,  89, -18, 4, 0, 0 },
+    { 4, -16,  63,  91, -18, 4, 0, 0 }, { 4, -16,  60,  94, -18, 4, 0, 0 },
+    { 3, -15,  58,  96, -18, 4, 0, 0 }, { 4, -15,  55,  98, -18, 4, 0, 0 },
+    { 3, -14,  52, 100, -17, 4, 0, 0 }, { 3, -14,  50, 102, -17, 4, 0, 0 },
+    { 3, -13,  47, 104, -17, 4, 0, 0 }, { 3, -13,  45, 106, -17, 4, 0, 0 },
+    { 3, -12,  42, 108, -16, 3, 0, 0 }, { 3, -11,  40, 109, -16, 3, 0, 0 },
+    { 3, -11,  37, 111, -15, 3, 0, 0 }, { 2, -10,  35, 113, -15, 3, 0, 0 },
+    { 3, -10,  32, 114, -14, 3, 0, 0 }, { 2, - 9,  29, 116, -13, 3, 0, 0 },
+    { 2, - 8,  27, 117, -13, 3, 0, 0 }, { 2, - 8,  25, 119, -12, 2, 0, 0 },
+    { 2, - 7,  22, 120, -11, 2, 0, 0 }, { 1, - 6,  20, 121, -10, 2, 0, 0 },
+    { 1, - 6,  18, 122, - 9, 2, 0, 0 }, { 1, - 5,  15, 123, - 8, 2, 0, 0 },
+    { 1, - 4,  13, 124, - 7, 1, 0, 0 }, { 1, - 4,  11, 125, - 6, 1, 0, 0 },
+    { 1, - 3,   8, 126, - 5, 1, 0, 0 }, { 1, - 2,   6, 126, - 4, 1, 0, 0 },
+    { 0, - 1,   4, 127, - 3, 1, 0, 0 }, { 0,   0,   2, 127, - 1, 0, 0, 0 },
+
+    // [0, 1)
+    { 0,  0,   0, 127,   1,   0,  0,  0}, { 0,  0,  -1, 127,   2,   0,  0,  0},
+    { 0,  1,  -3, 127,   4,  -2,  1,  0}, { 0,  1,  -5, 127,   6,  -2,  1,  0},
+    { 0,  2,  -6, 126,   8,  -3,  1,  0}, {-1,  2,  -7, 126,  11,  -4,  2, -1},
+    {-1,  3,  -8, 125,  13,  -5,  2, -1}, {-1,  3, -10, 124,  16,  -6,  3, -1},
+    {-1,  4, -11, 123,  18,  -7,  3, -1}, {-1,  4, -12, 122,  20,  -7,  3, -1},
+    {-1,  4, -13, 121,  23,  -8,  3, -1}, {-2,  5, -14, 120,  25,  -9,  4, -1},
+    {-1,  5, -15, 119,  27, -10,  4, -1}, {-1,  5, -16, 118,  30, -11,  4, -1},
+    {-2,  6, -17, 116,  33, -12,  5, -1}, {-2,  6, -17, 114,  35, -12,  5, -1},
+    {-2,  6, -18, 113,  38, -13,  5, -1}, {-2,  7, -19, 111,  41, -14,  6, -2},
+    {-2,  7, -19, 110,  43, -15,  6, -2}, {-2,  7, -20, 108,  46, -15,  6, -2},
+    {-2,  7, -20, 106,  49, -16,  6, -2}, {-2,  7, -21, 104,  51, -16,  7, -2},
+    {-2,  7, -21, 102,  54, -17,  7, -2}, {-2,  8, -21, 100,  56, -18,  7, -2},
+    {-2,  8, -22,  98,  59, -18,  7, -2}, {-2,  8, -22,  96,  62, -19,  7, -2},
+    {-2,  8, -22,  94,  64, -19,  7, -2}, {-2,  8, -22,  91,  67, -20,  8, -2},
+    {-2,  8, -22,  89,  69, -20,  8, -2}, {-2,  8, -22,  87,  72, -21,  8, -2},
+    {-2,  8, -21,  84,  74, -21,  8, -2}, {-2,  8, -22,  82,  77, -21,  8, -2},
+    {-2,  8, -21,  79,  79, -21,  8, -2}, {-2,  8, -21,  77,  82, -22,  8, -2},
+    {-2,  8, -21,  74,  84, -21,  8, -2}, {-2,  8, -21,  72,  87, -22,  8, -2},
+    {-2,  8, -20,  69,  89, -22,  8, -2}, {-2,  8, -20,  67,  91, -22,  8, -2},
+    {-2,  7, -19,  64,  94, -22,  8, -2}, {-2,  7, -19,  62,  96, -22,  8, -2},
+    {-2,  7, -18,  59,  98, -22,  8, -2}, {-2,  7, -18,  56, 100, -21,  8, -2},
+    {-2,  7, -17,  54, 102, -21,  7, -2}, {-2,  7, -16,  51, 104, -21,  7, -2},
+    {-2,  6, -16,  49, 106, -20,  7, -2}, {-2,  6, -15,  46, 108, -20,  7, -2},
+    {-2,  6, -15,  43, 110, -19,  7, -2}, {-2,  6, -14,  41, 111, -19,  7, -2},
+    {-1,  5, -13,  38, 113, -18,  6, -2}, {-1,  5, -12,  35, 114, -17,  6, -2},
+    {-1,  5, -12,  33, 116, -17,  6, -2}, {-1,  4, -11,  30, 118, -16,  5, -1},
+    {-1,  4, -10,  27, 119, -15,  5, -1}, {-1,  4,  -9,  25, 120, -14,  5, -2},
+    {-1,  3,  -8,  23, 121, -13,  4, -1}, {-1,  3,  -7,  20, 122, -12,  4, -1},
+    {-1,  3,  -7,  18, 123, -11,  4, -1}, {-1,  3,  -6,  16, 124, -10,  3, -1},
+    {-1,  2,  -5,  13, 125,  -8,  3, -1}, {-1,  2,  -4,  11, 126,  -7,  2, -1},
+    { 0,  1,  -3,   8, 126,  -6,  2,  0}, { 0,  1,  -2,   6, 127,  -5,  1,  0},
+    { 0,  1,  -2,   4, 127,  -3,  1,  0}, { 0,  0,   0,   2, 127,  -1,  0,  0},
+
+    // [1, 2)
+    { 0, 0, 0,   1, 127,   0,   0, 0 }, { 0, 0, 0, - 1, 127,   2,   0, 0 },
+    { 0, 0, 1, - 3, 127,   4, - 1, 0 }, { 0, 0, 1, - 4, 126,   6, - 2, 1 },
+    { 0, 0, 1, - 5, 126,   8, - 3, 1 }, { 0, 0, 1, - 6, 125,  11, - 4, 1 },
+    { 0, 0, 1, - 7, 124,  13, - 4, 1 }, { 0, 0, 2, - 8, 123,  15, - 5, 1 },
+    { 0, 0, 2, - 9, 122,  18, - 6, 1 }, { 0, 0, 2, -10, 121,  20, - 6, 1 },
+    { 0, 0, 2, -11, 120,  22, - 7, 2 }, { 0, 0, 2, -12, 119,  25, - 8, 2 },
+    { 0, 0, 3, -13, 117,  27, - 8, 2 }, { 0, 0, 3, -13, 116,  29, - 9, 2 },
+    { 0, 0, 3, -14, 114,  32, -10, 3 }, { 0, 0, 3, -15, 113,  35, -10, 2 },
+    { 0, 0, 3, -15, 111,  37, -11, 3 }, { 0, 0, 3, -16, 109,  40, -11, 3 },
+    { 0, 0, 3, -16, 108,  42, -12, 3 }, { 0, 0, 4, -17, 106,  45, -13, 3 },
+    { 0, 0, 4, -17, 104,  47, -13, 3 }, { 0, 0, 4, -17, 102,  50, -14, 3 },
+    { 0, 0, 4, -17, 100,  52, -14, 3 }, { 0, 0, 4, -18,  98,  55, -15, 4 },
+    { 0, 0, 4, -18,  96,  58, -15, 3 }, { 0, 0, 4, -18,  94,  60, -16, 4 },
+    { 0, 0, 4, -18,  91,  63, -16, 4 }, { 0, 0, 4, -18,  89,  65, -16, 4 },
+    { 0, 0, 4, -18,  87,  68, -17, 4 }, { 0, 0, 4, -18,  85,  70, -17, 4 },
+    { 0, 0, 4, -18,  82,  73, -17, 4 }, { 0, 0, 4, -18,  80,  75, -17, 4 },
+    { 0, 0, 4, -18,  78,  78, -18, 4 }, { 0, 0, 4, -17,  75,  80, -18, 4 },
+    { 0, 0, 4, -17,  73,  82, -18, 4 }, { 0, 0, 4, -17,  70,  85, -18, 4 },
+    { 0, 0, 4, -17,  68,  87, -18, 4 }, { 0, 0, 4, -16,  65,  89, -18, 4 },
+    { 0, 0, 4, -16,  63,  91, -18, 4 }, { 0, 0, 4, -16,  60,  94, -18, 4 },
+    { 0, 0, 3, -15,  58,  96, -18, 4 }, { 0, 0, 4, -15,  55,  98, -18, 4 },
+    { 0, 0, 3, -14,  52, 100, -17, 4 }, { 0, 0, 3, -14,  50, 102, -17, 4 },
+    { 0, 0, 3, -13,  47, 104, -17, 4 }, { 0, 0, 3, -13,  45, 106, -17, 4 },
+    { 0, 0, 3, -12,  42, 108, -16, 3 }, { 0, 0, 3, -11,  40, 109, -16, 3 },
+    { 0, 0, 3, -11,  37, 111, -15, 3 }, { 0, 0, 2, -10,  35, 113, -15, 3 },
+    { 0, 0, 3, -10,  32, 114, -14, 3 }, { 0, 0, 2, - 9,  29, 116, -13, 3 },
+    { 0, 0, 2, - 8,  27, 117, -13, 3 }, { 0, 0, 2, - 8,  25, 119, -12, 2 },
+    { 0, 0, 2, - 7,  22, 120, -11, 2 }, { 0, 0, 1, - 6,  20, 121, -10, 2 },
+    { 0, 0, 1, - 6,  18, 122, - 9, 2 }, { 0, 0, 1, - 5,  15, 123, - 8, 2 },
+    { 0, 0, 1, - 4,  13, 124, - 7, 1 }, { 0, 0, 1, - 4,  11, 125, - 6, 1 },
+    { 0, 0, 1, - 3,   8, 126, - 5, 1 }, { 0, 0, 1, - 2,   6, 126, - 4, 1 },
+    { 0, 0, 0, - 1,   4, 127, - 3, 1 }, { 0, 0, 0,   0,   2, 127, - 1, 0 },
+
+    // dummy (replicate row index 191)
+    { 0, 0, 0,   0,   2, 127, - 1, 0 },
+};
diff --git a/src/tables.h b/src/tables.h
new file mode 100644
index 0000000..6d45d50
--- /dev/null
+++ b/src/tables.h
@@ -0,0 +1,84 @@
+/*
+ * Copyright © 2018, VideoLAN and dav1d authors
+ * Copyright © 2018, Two Orioles, LLC
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright notice, this
+ *    list of conditions and the following disclaimer.
+ *
+ * 2. Redistributions in binary form must reproduce the above copyright notice,
+ *    this list of conditions and the following disclaimer in the documentation
+ *    and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
+ * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#ifndef __DAV1D_SRC_TABLES_H__
+#define __DAV1D_SRC_TABLES_H__
+
+#include <stdint.h>
+
+#include "common/intops.h"
+
+#include "src/levels.h"
+
+extern const uint8_t av1_al_part_ctx[2][N_BL_LEVELS][N_PARTITIONS];
+extern const uint8_t /* enum BlockSize */
+                     av1_block_sizes[N_BL_LEVELS][N_PARTITIONS][2];
+// width, height (in 4px blocks), log2 versions of these two
+extern const uint8_t av1_block_dimensions[N_BS_SIZES][4];
+typedef struct TxfmInfo {
+    // width, height (in 4px blocks), log2 of them, min/max of log2, sub, pad
+    uint8_t w, h, lw, lh, min, max, sub, ctx;
+} TxfmInfo;
+extern const TxfmInfo av1_txfm_dimensions[N_RECT_TX_SIZES];
+extern const uint8_t /* enum (Rect)TxfmSize */
+                     av1_max_txfm_size_for_bs[N_BS_SIZES][4 /* y, 420, 422, 444 */];
+extern const uint8_t /* enum TxfmType */
+                     av1_txtp_from_uvmode[N_UV_INTRA_PRED_MODES];
+
+extern const uint8_t /* enum InterPredMode */
+                     av1_comp_inter_pred_modes[N_COMP_INTER_PRED_MODES][2];
+
+extern const uint8_t av1_tx_type_count[N_TXTP_SETS];
+extern const uint8_t /* enum TxfmType */
+                     av1_tx_types_per_set[N_TXTP_SETS][N_TX_TYPES];
+extern const uint8_t av1_tx_type_set_index[2][N_TXTP_SETS];
+
+extern const uint8_t av1_filter_mode_to_y_mode[5];
+extern const uint8_t av1_ymode_size_context[N_BS_SIZES];
+extern const uint8_t av1_nz_map_ctx_offset[N_RECT_TX_SIZES][5][5];
+extern const uint8_t /* enum TxClass */
+                     av1_tx_type_class[N_TX_TYPES_PLUS_LL];
+extern const uint8_t /* enum Filter2d */
+                     av1_filter_2d[N_FILTERS /* h */][N_FILTERS /* v */];
+extern const uint8_t /* enum FilterMode */ eve_av1_filter_dir[N_2D_FILTERS][2];
+extern const uint8_t intra_mode_context[N_INTRA_PRED_MODES];
+extern const uint8_t av1_wedge_ctx_lut[N_BS_SIZES];
+
+extern const unsigned cfl_allowed_mask;
+extern const unsigned wedge_allowed_mask;
+extern const unsigned interintra_allowed_mask;
+
+extern const WarpedMotionParams default_wm_params;
+
+extern const int16_t sgr_params[16][4];
+extern const int16_t sgr_x_by_xplus1[256];
+extern const int16_t sgr_one_by_x[25];
+
+extern const int8_t dav1d_mc_subpel_filters[5][15][8];
+extern const int8_t dav1d_mc_warp_filter[][8];
+
+#endif /* __DAV1D_SRC_TABLES_H__ */
diff --git a/src/thread_data.h b/src/thread_data.h
new file mode 100644
index 0000000..8736189
--- /dev/null
+++ b/src/thread_data.h
@@ -0,0 +1,37 @@
+/*
+ * Copyright © 2018, VideoLAN and dav1d authors
+ * Copyright © 2018, Two Orioles, LLC
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright notice, this
+ *    list of conditions and the following disclaimer.
+ *
+ * 2. Redistributions in binary form must reproduce the above copyright notice,
+ *    this list of conditions and the following disclaimer in the documentation
+ *    and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
+ * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#ifndef __DAV1D_SRC_THREAD_DATA_H__
+#define __DAV1D_SRC_THREAD_DATA_H__
+
+struct thread_data {
+    pthread_t thread;
+    pthread_cond_t cond;
+    pthread_mutex_t lock;
+};
+
+#endif /* __DAV1D_SRC_THREAD_DATA_H__ */
diff --git a/src/thread_task.c b/src/thread_task.c
new file mode 100644
index 0000000..3ef739f
--- /dev/null
+++ b/src/thread_task.c
@@ -0,0 +1,137 @@
+/*
+ * Copyright © 2018, VideoLAN and dav1d authors
+ * Copyright © 2018, Two Orioles, LLC
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright notice, this
+ *    list of conditions and the following disclaimer.
+ *
+ * 2. Redistributions in binary form must reproduce the above copyright notice,
+ *    this list of conditions and the following disclaimer in the documentation
+ *    and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
+ * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#include "config.h"
+
+#include "src/thread_task.h"
+
+void *dav1d_frame_task(void *const data) {
+    Dav1dFrameContext *const f = data;
+
+    for (;;) {
+        pthread_mutex_lock(&f->frame_thread.td.lock);
+        f->n_tile_data = 0;
+        int did_signal = 0;
+        while (!f->n_tile_data && !f->frame_thread.die) {
+            if (!did_signal) {
+                did_signal = 1;
+                pthread_cond_signal(&f->frame_thread.td.cond);
+            }
+            pthread_cond_wait(&f->frame_thread.td.cond,
+                              &f->frame_thread.td.lock);
+        }
+        if (f->frame_thread.die) {
+            pthread_mutex_unlock(&f->frame_thread.td.lock);
+            break;
+        }
+        pthread_mutex_unlock(&f->frame_thread.td.lock);
+
+        decode_frame(f);
+    }
+
+    pthread_exit(NULL);
+    return NULL;
+}
+
+void *dav1d_tile_task(void *const data) {
+    Dav1dTileContext *const t = data;
+    struct FrameTileThreadData *const fttd = t->tile_thread.fttd;
+    const Dav1dFrameContext *const f = t->f;
+    const int tile_thread_idx = t - f->tc;
+    const uint64_t mask = 1ULL << tile_thread_idx;
+
+    for (;;) {
+        pthread_mutex_lock(&fttd->lock);
+        fttd->available |= mask;
+        int did_signal = 0;
+        while (!fttd->tasks_left && !t->tile_thread.die) {
+            if (!did_signal) {
+                did_signal = 1;
+                pthread_cond_signal(&fttd->icond);
+            }
+            pthread_cond_wait(&fttd->cond, &fttd->lock);
+        }
+        if (t->tile_thread.die) {
+            pthread_mutex_unlock(&fttd->lock);
+            break;
+        }
+        fttd->available &= ~mask;
+        const int task_idx = fttd->num_tasks - fttd->tasks_left--;
+        pthread_mutex_unlock(&fttd->lock);
+
+        if (f->frame_thread.pass == 1 || f->n_tc >= f->frame_hdr.tiling.cols) {
+            // we can (or in fact, if >, we need to) do full tile decoding.
+            // loopfilter happens in the main thread
+            Dav1dTileState *const ts = t->ts = &f->ts[task_idx];
+            for (t->by = ts->tiling.row_start; t->by < ts->tiling.row_end;
+                 t->by += f->sb_step)
+            {
+                decode_tile_sbrow(t);
+
+                // signal progress
+                pthread_mutex_lock(&ts->tile_thread.lock);
+                atomic_store(&ts->progress, 1 + (t->by >> f->sb_shift));
+                pthread_cond_signal(&ts->tile_thread.cond);
+                pthread_mutex_unlock(&ts->tile_thread.lock);
+            }
+        } else {
+            const int sby = f->tile_thread.task_idx_to_sby_and_tile_idx[task_idx][0];
+            const int tile_idx = f->tile_thread.task_idx_to_sby_and_tile_idx[task_idx][1];
+            Dav1dTileState *const ts = &f->ts[tile_idx];
+
+            // the interleaved decoding can sometimes cause dependency issues
+            // if one part of the frame decodes signifcantly faster than others.
+            // Ideally, we'd "skip" tile_sbrows where dependencies are missing,
+            // and resume them later as dependencies are met. This also would
+            // solve the broadcast() below and allow us to use signal(). However,
+            // for now, we use linear dependency tracking because it's simpler.
+            if (atomic_load(&ts->progress) < sby) {
+                pthread_mutex_lock(&ts->tile_thread.lock);
+                while (atomic_load(&ts->progress) < sby)
+                    pthread_cond_wait(&ts->tile_thread.cond,
+                                      &ts->tile_thread.lock);
+                pthread_mutex_unlock(&ts->tile_thread.lock);
+            }
+
+            // we need to interleave sbrow decoding for all tile cols in a
+            // tile row, since otherwise subsequent threads will be blocked
+            // waiting for the post-filter to complete
+            t->ts = ts;
+            t->by = sby << f->sb_shift;
+            decode_tile_sbrow(t);
+
+            // signal progress
+            pthread_mutex_lock(&ts->tile_thread.lock);
+            atomic_store(&ts->progress, 1 + sby);
+            pthread_cond_broadcast(&ts->tile_thread.cond);
+            pthread_mutex_unlock(&ts->tile_thread.lock);
+        }
+    }
+
+    pthread_exit(NULL);
+    return NULL;
+}
diff --git a/src/thread_task.h b/src/thread_task.h
new file mode 100644
index 0000000..e94a5b7
--- /dev/null
+++ b/src/thread_task.h
@@ -0,0 +1,39 @@
+/*
+ * Copyright © 2018, VideoLAN and dav1d authors
+ * Copyright © 2018, Two Orioles, LLC
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright notice, this
+ *    list of conditions and the following disclaimer.
+ *
+ * 2. Redistributions in binary form must reproduce the above copyright notice,
+ *    this list of conditions and the following disclaimer in the documentation
+ *    and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
+ * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#ifndef __DAV1D_SRC_THREAD_TASK_H__
+#define __DAV1D_SRC_THREAD_TASK_H__
+
+#include "src/internal.h"
+
+int decode_frame(Dav1dFrameContext *f);
+void *dav1d_frame_task(void *data);
+
+int decode_tile_sbrow(Dav1dTileContext *t);
+void *dav1d_tile_task(void *data);
+
+#endif /* __DAV1D_SRC_THREAD_TASK_H__ */
diff --git a/src/warpmv.c b/src/warpmv.c
new file mode 100644
index 0000000..3b81e1f
--- /dev/null
+++ b/src/warpmv.c
@@ -0,0 +1,194 @@
+/*
+ * Copyright © 2018, VideoLAN and dav1d authors
+ * Copyright © 2018, Two Orioles, LLC
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright notice, this
+ *    list of conditions and the following disclaimer.
+ *
+ * 2. Redistributions in binary form must reproduce the above copyright notice,
+ *    this list of conditions and the following disclaimer in the documentation
+ *    and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
+ * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#include "config.h"
+
+#include <assert.h>
+#include <stdlib.h>
+
+#include "common/intops.h"
+
+#include "src/warpmv.h"
+
+static const uint16_t div_lut[257] = {
+    16384, 16320, 16257, 16194, 16132, 16070, 16009, 15948, 15888, 15828, 15768,
+    15709, 15650, 15592, 15534, 15477, 15420, 15364, 15308, 15252, 15197, 15142,
+    15087, 15033, 14980, 14926, 14873, 14821, 14769, 14717, 14665, 14614, 14564,
+    14513, 14463, 14413, 14364, 14315, 14266, 14218, 14170, 14122, 14075, 14028,
+    13981, 13935, 13888, 13843, 13797, 13752, 13707, 13662, 13618, 13574, 13530,
+    13487, 13443, 13400, 13358, 13315, 13273, 13231, 13190, 13148, 13107, 13066,
+    13026, 12985, 12945, 12906, 12866, 12827, 12788, 12749, 12710, 12672, 12633,
+    12596, 12558, 12520, 12483, 12446, 12409, 12373, 12336, 12300, 12264, 12228,
+    12193, 12157, 12122, 12087, 12053, 12018, 11984, 11950, 11916, 11882, 11848,
+    11815, 11782, 11749, 11716, 11683, 11651, 11619, 11586, 11555, 11523, 11491,
+    11460, 11429, 11398, 11367, 11336, 11305, 11275, 11245, 11215, 11185, 11155,
+    11125, 11096, 11067, 11038, 11009, 10980, 10951, 10923, 10894, 10866, 10838,
+    10810, 10782, 10755, 10727, 10700, 10673, 10645, 10618, 10592, 10565, 10538,
+    10512, 10486, 10460, 10434, 10408, 10382, 10356, 10331, 10305, 10280, 10255,
+    10230, 10205, 10180, 10156, 10131, 10107, 10082, 10058, 10034, 10010,  9986,
+     9963,  9939,  9916,  9892,  9869,  9846,  9823,  9800,  9777,  9754,  9732,
+     9709,  9687,  9664,  9642,  9620,  9598,  9576,  9554,  9533,  9511,  9489,
+     9468,  9447,  9425,  9404,  9383,  9362,  9341,  9321,  9300,  9279,  9259,
+     9239,  9218,  9198,  9178,  9158,  9138,  9118,  9098,  9079,  9059,  9039,
+     9020,  9001,  8981,  8962,  8943,  8924,  8905,  8886,  8867,  8849,  8830,
+     8812,  8793,  8775,  8756,  8738,  8720,  8702,  8684,  8666,  8648,  8630,
+     8613,  8595,  8577,  8560,  8542,  8525,  8508,  8490,  8473,  8456,  8439,
+     8422,  8405,  8389,  8372,  8355,  8339,  8322,  8306,  8289,  8273,  8257,
+     8240,  8224,  8208,  8192,
+};
+
+static inline int iclip_wmp(const int v) {
+    const int cv = iclip(v, INT16_MIN, INT16_MAX);
+
+    return apply_sign((abs(cv) + 32) >> 6, cv) * (1 << 6);
+}
+
+static inline int apply_sign64(const int v, const int64_t s) {
+    return s < 0 ? -v : v;
+}
+
+static inline int resolve_divisor_32(const unsigned d, int *const shift) {
+    *shift = ulog2(d);
+    const int e = d - (1 << *shift);
+    const int f = *shift > 8 ? (e + (1 << (*shift - 9))) >> (*shift - 8) :
+                               e << (8 - *shift);
+    assert(f <= 256);
+    *shift += 14;
+    // Use f as lookup into the precomputed table of multipliers
+    return div_lut[f];
+}
+
+int get_shear_params(WarpedMotionParams *const wm) {
+    const int32_t *const mat = wm->matrix;
+
+    if (mat[2] <= 0) return 1;
+
+    wm->alpha = iclip_wmp(mat[2] - 0x10000);
+    wm->beta = iclip_wmp(mat[3]);
+
+    int shift;
+    const int y = apply_sign(resolve_divisor_32(abs(mat[2]), &shift), mat[2]);
+    const int64_t v1 = ((int64_t) mat[4] * 0x10000) * y;
+    const int rnd = (1 << shift) >> 1;
+    wm->gamma = iclip_wmp(apply_sign64((llabs(v1) + rnd) >> shift, v1));
+    const int64_t v2 = ((int64_t) mat[3] * mat[4]) * y;
+    wm->delta = iclip_wmp(mat[5] -
+                          (int) apply_sign64((llabs(v2) + rnd) >> shift, v2) -
+                          0x10000);
+
+    return (4 * abs(wm->alpha) + 7 * abs(wm->beta) >= 0x10000) ||
+           (4 * abs(wm->gamma) + 4 * abs(wm->delta) >= 0x10000);
+}
+
+static int resolve_divisor_64(const uint64_t d, int *const shift) {
+    *shift = u64log2(d);
+    const int64_t e = d - (1LL << *shift);
+    const int64_t f = *shift > 8 ? (e + (1LL << (*shift - 9))) >> (*shift - 8) :
+                                   e << (8 - *shift);
+    assert(f <= 256);
+    *shift += 14;
+    // Use f as lookup into the precomputed table of multipliers
+    return div_lut[f];
+}
+
+static int get_mult_shift_ndiag(const int64_t px,
+                                const int idet, const int shift)
+{
+    const int64_t v1 = px * idet;
+    const int v2 = apply_sign64((llabs(v1) + ((1LL << shift) >> 1)) >> shift, v1);
+    return iclip(v2, -0x1fff, 0x1fff);
+}
+
+static int get_mult_shift_diag(const int64_t px,
+                               const int idet, const int shift)
+{
+    const int64_t v1 = px * idet;
+    const int v2 = apply_sign64((llabs(v1) + ((1LL << shift) >> 1)) >> shift, v1);
+    return iclip(v2, 0xe001, 0x11fff);
+}
+
+int find_affine_int(const int (*pts)[2][2], const int np,
+                    const int bw4, const int bh4,
+                    const mv mv, WarpedMotionParams *const wm,
+                    const int bx4, const int by4)
+{
+    int32_t *const mat = wm->matrix;
+    int a[2][2] = { { 0, 0 }, { 0, 0 } };
+    int bx[2] = { 0, 0 };
+    int by[2] = { 0, 0 };
+    const int rsuy = 2 * bh4 - 1;
+    const int rsux = 2 * bw4 - 1;
+    const int suy = rsuy * 8;
+    const int sux = rsux * 8;
+    const int duy = suy + mv.y;
+    const int dux = sux + mv.x;
+    const int isuy = by4 * 4 + rsuy;
+    const int isux = bx4 * 4 + rsux;
+
+    for (int i = 0; i < np; i++) {
+        const int dx = pts[i][1][0] - dux;
+        const int dy = pts[i][1][1] - duy;
+        const int sx = pts[i][0][0] - sux;
+        const int sy = pts[i][0][1] - suy;
+        if (abs(sx - dx) < 256 && abs(sy - dy) < 256) {
+            a[0][0] += ((sx * sx) >> 2) + sx * 2 + 8;
+            a[0][1] += ((sx * sy) >> 2) + sx + sy + 4;
+            a[1][1] += ((sy * sy) >> 2) + sy * 2 + 8;
+            bx[0] += ((sx * dx) >> 2) + sx + dx + 8;
+            bx[1] += ((sy * dx) >> 2) + sy + dx + 4;
+            by[0] += ((sx * dy) >> 2) + sx + dy + 4;
+            by[1] += ((sy * dy) >> 2) + sy + dy + 8;
+        }
+    }
+
+    // compute determinant of a
+    const int64_t det = (int64_t) a[0][0] * a[1][1] - (int64_t) a[0][1] * a[0][1];
+    if (det == 0) return 1;
+    int shift, idet = apply_sign64(resolve_divisor_64(llabs(det), &shift), det);
+    shift -= 16;
+    if (shift < 0) {
+        idet <<= -shift;
+        shift = 0;
+    }
+
+    // solve the least-squares
+    mat[2] = get_mult_shift_diag((int64_t) a[1][1] * bx[0] -
+                                 (int64_t) a[0][1] * bx[1], idet, shift);
+    mat[3] = get_mult_shift_ndiag((int64_t) a[0][0] * bx[1] -
+                                  (int64_t) a[0][1] * bx[0], idet, shift);
+    mat[4] = get_mult_shift_ndiag((int64_t) a[1][1] * by[0] -
+                                  (int64_t) a[0][1] * by[1], idet, shift);
+    mat[5] = get_mult_shift_diag((int64_t) a[0][0] * by[1] -
+                                 (int64_t) a[0][1] * by[0], idet, shift);
+
+    mat[0] = iclip(mv.x * 0x2000 - (isux * (mat[2] - 0x10000) + isuy * mat[3]),
+                   -0x800000, 0x7fffff);
+    mat[1] = iclip(mv.y * 0x2000 - (isux * mat[4] + isuy * (mat[5] - 0x10000)),
+                   -0x800000, 0x7fffff);
+
+    return 0;
+}
diff --git a/src/warpmv.h b/src/warpmv.h
new file mode 100644
index 0000000..ca9e0df
--- /dev/null
+++ b/src/warpmv.h
@@ -0,0 +1,37 @@
+/*
+ * Copyright © 2018, VideoLAN and dav1d authors
+ * Copyright © 2018, Two Orioles, LLC
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright notice, this
+ *    list of conditions and the following disclaimer.
+ *
+ * 2. Redistributions in binary form must reproduce the above copyright notice,
+ *    this list of conditions and the following disclaimer in the documentation
+ *    and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
+ * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#ifndef __DAV1D_SRC_WARPMV_H__
+#define __DAV1D_SRC_WARPMV_H__
+
+#include "src/levels.h"
+
+int get_shear_params(WarpedMotionParams *wm);
+int find_affine_int(const int (*pts)[2][2], int np, int bw4, int bh4,
+                    mv mv, WarpedMotionParams *wm, int by, int bx);
+
+#endif /* __DAV1D_SRC_WARPMV_H__ */
diff --git a/src/wedge.c b/src/wedge.c
new file mode 100644
index 0000000..114d493
--- /dev/null
+++ b/src/wedge.c
@@ -0,0 +1,334 @@
+/*
+ * Copyright © 2018, VideoLAN and dav1d authors
+ * Copyright © 2018, Two Orioles, LLC
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright notice, this
+ *    list of conditions and the following disclaimer.
+ *
+ * 2. Redistributions in binary form must reproduce the above copyright notice,
+ *    this list of conditions and the following disclaimer in the documentation
+ *    and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
+ * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#include "config.h"
+
+#include <stdint.h>
+#include <string.h>
+
+#include "common/intops.h"
+
+#include "src/wedge.h"
+
+enum WedgeDirectionType {
+    WEDGE_HORIZONTAL = 0,
+    WEDGE_VERTICAL = 1,
+    WEDGE_OBLIQUE27 = 2,
+    WEDGE_OBLIQUE63 = 3,
+    WEDGE_OBLIQUE117 = 4,
+    WEDGE_OBLIQUE153 = 5,
+    N_WEDGE_DIRECTIONS
+};
+
+typedef struct {
+    enum WedgeDirectionType direction;
+    int x_offset;
+    int y_offset;
+} wedge_code_type;
+
+static const wedge_code_type wedge_codebook_16_hgtw[16] = {
+    { WEDGE_OBLIQUE27, 4, 4 },  { WEDGE_OBLIQUE63, 4, 4 },
+    { WEDGE_OBLIQUE117, 4, 4 }, { WEDGE_OBLIQUE153, 4, 4 },
+    { WEDGE_HORIZONTAL, 4, 2 }, { WEDGE_HORIZONTAL, 4, 4 },
+    { WEDGE_HORIZONTAL, 4, 6 }, { WEDGE_VERTICAL, 4, 4 },
+    { WEDGE_OBLIQUE27, 4, 2 },  { WEDGE_OBLIQUE27, 4, 6 },
+    { WEDGE_OBLIQUE153, 4, 2 }, { WEDGE_OBLIQUE153, 4, 6 },
+    { WEDGE_OBLIQUE63, 2, 4 },  { WEDGE_OBLIQUE63, 6, 4 },
+    { WEDGE_OBLIQUE117, 2, 4 }, { WEDGE_OBLIQUE117, 6, 4 },
+};
+
+static const wedge_code_type wedge_codebook_16_hltw[16] = {
+    { WEDGE_OBLIQUE27, 4, 4 },  { WEDGE_OBLIQUE63, 4, 4 },
+    { WEDGE_OBLIQUE117, 4, 4 }, { WEDGE_OBLIQUE153, 4, 4 },
+    { WEDGE_VERTICAL, 2, 4 },   { WEDGE_VERTICAL, 4, 4 },
+    { WEDGE_VERTICAL, 6, 4 },   { WEDGE_HORIZONTAL, 4, 4 },
+    { WEDGE_OBLIQUE27, 4, 2 },  { WEDGE_OBLIQUE27, 4, 6 },
+    { WEDGE_OBLIQUE153, 4, 2 }, { WEDGE_OBLIQUE153, 4, 6 },
+    { WEDGE_OBLIQUE63, 2, 4 },  { WEDGE_OBLIQUE63, 6, 4 },
+    { WEDGE_OBLIQUE117, 2, 4 }, { WEDGE_OBLIQUE117, 6, 4 },
+};
+
+static const wedge_code_type wedge_codebook_16_heqw[16] = {
+    { WEDGE_OBLIQUE27, 4, 4 },  { WEDGE_OBLIQUE63, 4, 4 },
+    { WEDGE_OBLIQUE117, 4, 4 }, { WEDGE_OBLIQUE153, 4, 4 },
+    { WEDGE_HORIZONTAL, 4, 2 }, { WEDGE_HORIZONTAL, 4, 6 },
+    { WEDGE_VERTICAL, 2, 4 },   { WEDGE_VERTICAL, 6, 4 },
+    { WEDGE_OBLIQUE27, 4, 2 },  { WEDGE_OBLIQUE27, 4, 6 },
+    { WEDGE_OBLIQUE153, 4, 2 }, { WEDGE_OBLIQUE153, 4, 6 },
+    { WEDGE_OBLIQUE63, 2, 4 },  { WEDGE_OBLIQUE63, 6, 4 },
+    { WEDGE_OBLIQUE117, 2, 4 }, { WEDGE_OBLIQUE117, 6, 4 },
+};
+
+static uint8_t wedge_masks_444_32x32[2][16][32 * 32];
+static uint8_t wedge_masks_444_32x16[2][16][32 * 16];
+static uint8_t wedge_masks_444_32x8[2][16][32 * 8];
+static uint8_t wedge_masks_444_16x32[2][16][16 * 32];
+static uint8_t wedge_masks_444_16x16[2][16][16 * 16];
+static uint8_t wedge_masks_444_16x8[2][16][16 * 8];
+static uint8_t wedge_masks_444_8x32[2][16][8 * 32];
+static uint8_t wedge_masks_444_8x16[2][16][8 * 16];
+static uint8_t wedge_masks_444_8x8[2][16][8 * 8];
+
+static uint8_t wedge_masks_422_16x32[2][16][16 * 32];
+static uint8_t wedge_masks_422_16x16[2][16][16 * 16];
+static uint8_t wedge_masks_422_16x8[2][16][16 * 8];
+static uint8_t wedge_masks_422_8x32[2][16][8 * 32];
+static uint8_t wedge_masks_422_8x16[2][16][8 * 16];
+static uint8_t wedge_masks_422_8x8[2][16][8 * 8];
+static uint8_t wedge_masks_422_4x32[2][16][4 * 32];
+static uint8_t wedge_masks_422_4x16[2][16][4 * 16];
+static uint8_t wedge_masks_422_4x8[2][16][4 * 8];
+
+static uint8_t wedge_masks_420_16x16[2][16][16 * 16];
+static uint8_t wedge_masks_420_16x8[2][16][16 * 8];
+static uint8_t wedge_masks_420_16x4[2][16][16 * 4];
+static uint8_t wedge_masks_420_8x16[2][16][8 * 16];
+static uint8_t wedge_masks_420_8x8[2][16][8 * 8];
+static uint8_t wedge_masks_420_8x4[2][16][8 * 4];
+static uint8_t wedge_masks_420_4x16[2][16][4 * 16];
+static uint8_t wedge_masks_420_4x8[2][16][4 * 8];
+static uint8_t wedge_masks_420_4x4[2][16][4 * 4];
+
+const uint8_t *wedge_masks[N_BS_SIZES][3][2][16];
+
+static void insert_border(uint8_t *const dst, const uint8_t *src,
+                          const int ctr)
+{
+    if (ctr > 4) memset(dst, 0, ctr - 4);
+    memcpy(dst + imax(ctr, 4) - 4, src + imax(4 - ctr, 0), imin(64 - ctr, 8));
+    if (ctr < 64 - 4)
+        memset(dst + ctr + 4, 64, 64 - 4 - ctr);
+}
+
+static void transpose(uint8_t *const dst, const uint8_t *const src) {
+    for (int y = 0, y_off = 0; y < 64; y++, y_off += 64)
+        for (int x = 0, x_off = 0; x < 64; x++, x_off += 64)
+            dst[x_off + y] = src[y_off + x];
+}
+
+static void hflip(uint8_t *const dst, const uint8_t *const src) {
+    for (int y = 0, y_off = 0; y < 64; y++, y_off += 64)
+        for (int x = 0; x < 64; x++)
+            dst[y_off + 64 - 1 - x] = src[y_off + x];
+}
+
+static void invert(uint8_t *const dst, const uint8_t *const src,
+                   const int w, const int h)
+{
+    for (int y = 0, y_off = 0; y < h; y++, y_off += w)
+        for (int x = 0; x < w; x++)
+            dst[y_off + x] = 64 - src[y_off + x];
+}
+
+static void copy2d(uint8_t *dst, const uint8_t *src,
+                   const int w, const int h, const int x_off, const int y_off)
+{
+    src += y_off * 64 + x_off;
+    for (int y = 0; y < h; y++) {
+        memcpy(dst, src, w);
+        src += 64;
+        dst += w;
+    }
+}
+
+static void init_chroma(uint8_t *chroma, const uint8_t *luma,
+                        const int sign, const int w, const int h, const int ss_ver)
+{
+    for (int y = 0; y < h; y += 1 + ss_ver) {
+        for (int x = 0; x < w; x += 2) {
+            int sum = luma[x] + luma[x + 1] + 1;
+            if (ss_ver) sum += luma[w + x] + luma[w + x + 1] + 1;
+            chroma[x >> 1] = (sum - sign) >> (1 + ss_ver);
+        }
+        luma += w << ss_ver;
+        chroma += w >> 1;
+    }
+}
+
+static void fill2d_16x2(uint8_t *dst, const int w, const int h,
+                        const enum BlockSize bs,
+                        const uint8_t (*const master)[64 * 64],
+                        const wedge_code_type *const cb,
+                        uint8_t (*masks_444)[16][w * h],
+                        uint8_t (*masks_422)[16][w * h >> 1],
+                        uint8_t (*masks_420)[16][w * h >> 2],
+                        const unsigned signs)
+{
+    uint8_t *ptr = dst;
+    for (int n = 0; n < 16; n++) {
+        copy2d(ptr, master[cb[n].direction], w, h,
+               32 - (w * cb[n].x_offset >> 3), 32 - (h * cb[n].y_offset >> 3));
+        ptr += w * h;
+    }
+    for (int n = 0, off = 0; n < 16; n++, off += w * h)
+        invert(ptr + off, dst + off, w, h);
+    // assign pointers in externally visible array
+    for (int n = 0; n < 16; n++) {
+        const int sign = (signs >> n) & 1;
+        wedge_masks[bs][0][0][n] = masks_444[ sign][n];
+        wedge_masks[bs][0][1][n] = masks_444[ sign][n];
+        wedge_masks[bs][1][0][n] = masks_422[ sign][n];
+        wedge_masks[bs][1][1][n] = masks_422[!sign][n];
+        wedge_masks[bs][2][0][n] = masks_420[ sign][n];
+        wedge_masks[bs][2][1][n] = masks_420[!sign][n];
+    }
+    for (int n = 0; n < 16; n++) {
+        // since the pointers come from inside, we know that
+        // violation of the const is OK here. Any other approach
+        // means we would have to duplicate the sign correction
+        // logic in two places, which isn't very nice, or mark
+        // the table faced externally as non-const, which also sucks
+        init_chroma((uint8_t *) wedge_masks[bs][1][0][n],
+                    wedge_masks[bs][0][0][n], 0, w, h, 0);
+        init_chroma((uint8_t *) wedge_masks[bs][1][1][n],
+                    wedge_masks[bs][0][0][n], 1, w, h, 0);
+        init_chroma((uint8_t *) wedge_masks[bs][2][0][n],
+                    wedge_masks[bs][0][0][n], 0, w, h, 1);
+        init_chroma((uint8_t *) wedge_masks[bs][2][1][n],
+                    wedge_masks[bs][0][0][n], 1, w, h, 1);
+    }
+}
+
+void av1_init_wedge_masks(void) {
+    static int done = 0;
+    if (done) return;
+    done = 1;
+
+    enum WedgeMasterLineType {
+        WEDGE_MASTER_LINE_ODD,
+        WEDGE_MASTER_LINE_EVEN,
+        WEDGE_MASTER_LINE_VERT,
+        N_WEDGE_MASTER_LINES,
+    };
+    static const uint8_t wedge_master_border[N_WEDGE_MASTER_LINES][8] = {
+        [WEDGE_MASTER_LINE_ODD]  = {  1,  2,  6, 18, 37, 53, 60, 63 },
+        [WEDGE_MASTER_LINE_EVEN] = {  1,  4, 11, 27, 46, 58, 62, 63 },
+        [WEDGE_MASTER_LINE_VERT] = {  0,  2,  7, 21, 43, 57, 62, 64 },
+    };
+    uint8_t master[6][64 * 64];
+
+    // create master templates
+    for (int y = 0, off = 0; y < 64; y++, off += 64)
+        insert_border(&master[WEDGE_VERTICAL][off],
+                      wedge_master_border[WEDGE_MASTER_LINE_VERT], 32);
+    for (int y = 0, off = 0, ctr = 48; y < 64; y += 2, off += 128, ctr--)
+    {
+        insert_border(&master[WEDGE_OBLIQUE63][off],
+                      wedge_master_border[WEDGE_MASTER_LINE_EVEN], ctr);
+        insert_border(&master[WEDGE_OBLIQUE63][off + 64],
+                      wedge_master_border[WEDGE_MASTER_LINE_ODD], ctr - 1);
+    }
+
+    transpose(master[WEDGE_OBLIQUE27], master[WEDGE_OBLIQUE63]);
+    transpose(master[WEDGE_HORIZONTAL], master[WEDGE_VERTICAL]);
+    hflip(master[WEDGE_OBLIQUE117], master[WEDGE_OBLIQUE63]);
+    hflip(master[WEDGE_OBLIQUE153], master[WEDGE_OBLIQUE27]);
+
+#define fill(w, h, sz_422, sz_420, hvsw, signs) \
+    fill2d_16x2((uint8_t *) wedge_masks_444_##w##x##h,  w, h, BS_##w##x##h, \
+                master, wedge_codebook_16_##hvsw, wedge_masks_444_##w##x##h, \
+                wedge_masks_422_##sz_422, wedge_masks_420_##sz_420, signs)
+
+    fill(32, 32, 16x32, 16x16, heqw, 0x7bfb);
+    fill(32, 16, 16x16, 16x8,  hltw, 0x7beb);
+    fill(32,  8, 16x8,  16x4,  hltw, 0x6beb);
+    fill(16, 32,  8x32,  8x16, hgtw, 0x7beb);
+    fill(16, 16,  8x16,  8x8,  heqw, 0x7bfb);
+    fill(16,  8,  8x8,   8x4,  hltw, 0x7beb);
+    fill( 8, 32,  4x32,  4x16, hgtw, 0x7aeb);
+    fill( 8, 16,  4x16,  4x8,  hgtw, 0x7beb);
+    fill( 8,  8,  4x8,   4x4,  heqw, 0x7bfb);
+#undef fill
+}
+
+static uint8_t ii_dc_mask[32 * 32];
+static uint8_t ii_nondc_mask_32x32[N_INTER_INTRA_PRED_MODES - 1][32 * 32];
+static uint8_t ii_nondc_mask_16x32[N_INTER_INTRA_PRED_MODES - 1][16 * 32];
+static uint8_t ii_nondc_mask_16x16[N_INTER_INTRA_PRED_MODES - 1][16 * 16];
+static uint8_t ii_nondc_mask_8x32[N_INTER_INTRA_PRED_MODES - 1][8 * 32];
+static uint8_t ii_nondc_mask_8x16[N_INTER_INTRA_PRED_MODES - 1][8 * 16];
+static uint8_t ii_nondc_mask_8x8[N_INTER_INTRA_PRED_MODES - 1][8 * 8];
+static uint8_t ii_nondc_mask_4x16[N_INTER_INTRA_PRED_MODES - 1][4 * 16];
+static uint8_t ii_nondc_mask_4x8[N_INTER_INTRA_PRED_MODES - 1][4 * 8];
+static uint8_t ii_nondc_mask_4x4[N_INTER_INTRA_PRED_MODES - 1][4 * 4];
+
+#define set1(sz) \
+    [II_DC_PRED] = ii_dc_mask, \
+    [II_VERT_PRED] = ii_nondc_mask_##sz[II_VERT_PRED - 1], \
+    [II_HOR_PRED] = ii_nondc_mask_##sz[II_HOR_PRED - 1], \
+    [II_SMOOTH_PRED] = ii_nondc_mask_##sz[II_SMOOTH_PRED - 1]
+#define set(sz_444, sz_422, sz_420) \
+    { { set1(sz_444) }, { set1(sz_422) }, { set1(sz_420) } }
+const uint8_t *const ii_masks[N_BS_SIZES][3][N_INTER_INTRA_PRED_MODES] = {
+    [BS_8x8]   = set( 8x8,   4x8,   4x4),
+    [BS_8x16]  = set( 8x16,  4x16,  4x8),
+    [BS_16x8]  = set(16x16,  8x8,   8x8),
+    [BS_16x16] = set(16x16,  8x16,  8x8),
+    [BS_16x32] = set(16x32,  8x32,  8x16),
+    [BS_32x16] = set(32x32, 16x16, 16x16),
+    [BS_32x32] = set(32x32, 16x32, 16x16),
+};
+#undef set
+#undef set1
+
+static void build_nondc_ii_masks(uint8_t *const mask_v,
+                                 uint8_t *const mask_h,
+                                 uint8_t *const mask_sm,
+                                 const int w, const int h, const int step)
+{
+    static const uint8_t ii_weights_1d[] = {
+        60, 52, 45, 39, 34, 30, 26, 22, 19, 17, 15, 13, 11, 10,  8,  7,
+         6,  6,  5,  4,  4,  3,  3,  2,  2,  2,  2,  1,  1,  1,  1,  1,
+    };
+
+    for (int y = 0, off = 0; y < h; y++, off += w) {
+        memset(&mask_v[off], ii_weights_1d[y * step], w);
+        for (int x = 0; x < w; x++) {
+            mask_sm[off + x] = ii_weights_1d[imin(x, y) * step];
+            mask_h[off + x] = ii_weights_1d[x * step];
+        }
+    }
+}
+
+void av1_init_interintra_masks(void) {
+    static int done = 0;
+    if (done) return;
+    done = 1;
+
+    memset(ii_dc_mask, 32, 32 * 32);
+#define set(a) a[II_VERT_PRED - 1], a[II_HOR_PRED - 1], a[II_SMOOTH_PRED - 1]
+    build_nondc_ii_masks(set(ii_nondc_mask_32x32), 32, 32, 1);
+    build_nondc_ii_masks(set(ii_nondc_mask_16x32), 16, 32, 1);
+    build_nondc_ii_masks(set(ii_nondc_mask_16x16), 16, 16, 2);
+    build_nondc_ii_masks(set(ii_nondc_mask_8x32),   8, 32, 1);
+    build_nondc_ii_masks(set(ii_nondc_mask_8x16),   8, 16, 2);
+    build_nondc_ii_masks(set(ii_nondc_mask_8x8),    8,  8, 4);
+    build_nondc_ii_masks(set(ii_nondc_mask_4x16),   4, 16, 2);
+    build_nondc_ii_masks(set(ii_nondc_mask_4x8),    4,  8, 4);
+    build_nondc_ii_masks(set(ii_nondc_mask_4x4),    4,  4, 8);
+#undef set
+}
diff --git a/src/wedge.h b/src/wedge.h
new file mode 100644
index 0000000..72a7546
--- /dev/null
+++ b/src/wedge.h
@@ -0,0 +1,41 @@
+/*
+ * Copyright © 2018, VideoLAN and dav1d authors
+ * Copyright © 2018, Two Orioles, LLC
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright notice, this
+ *    list of conditions and the following disclaimer.
+ *
+ * 2. Redistributions in binary form must reproduce the above copyright notice,
+ *    this list of conditions and the following disclaimer in the documentation
+ *    and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
+ * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#ifndef __DAV1D_SRC_WEDGE_H__
+#define __DAV1D_SRC_WEDGE_H__
+
+#include "src/levels.h"
+
+void av1_init_wedge_masks(void);
+extern const uint8_t *wedge_masks[N_BS_SIZES][3 /* 444/luma, 422, 420 */]
+                                 [2 /* sign */][16 /* wedge_idx */];
+
+void av1_init_interintra_masks(void);
+extern const uint8_t *const ii_masks[N_BS_SIZES][3 /* 444/luma, 422, 420 */]
+                                    [N_INTER_INTRA_PRED_MODES];
+
+#endif /* __DAV1D_SRC_WEDGE_H__ */