diff --git a/doc/filters.texi b/doc/filters.texi
index 4f717527e5..770efa6ee1 100644
--- a/doc/filters.texi
+++ b/doc/filters.texi
@@ -15607,6 +15607,19 @@ Negate (invert) the input video.
 It accepts the following option:
 
 @table @option
+@item components
+Set components to negate.
+
+Available values for components are:
+@table @samp
+@item y
+@item u
+@item v
+@item a
+@item r
+@item g
+@item b
+@end table
 
 @item negate_alpha
 With value 1, it negates the alpha component, if present. Default value is 0.
diff --git a/libavfilter/Makefile b/libavfilter/Makefile
index eb5365a739..4e6d8bdeea 100644
--- a/libavfilter/Makefile
+++ b/libavfilter/Makefile
@@ -351,7 +351,7 @@ OBJS-$(CONFIG_MIX_FILTER)                    += vf_mix.o framesync.o
 OBJS-$(CONFIG_MONOCHROME_FILTER)             += vf_monochrome.o
 OBJS-$(CONFIG_MORPHO_FILTER)                 += vf_morpho.o
 OBJS-$(CONFIG_MPDECIMATE_FILTER)             += vf_mpdecimate.o
-OBJS-$(CONFIG_NEGATE_FILTER)                 += vf_lut.o
+OBJS-$(CONFIG_NEGATE_FILTER)                 += vf_negate.o
 OBJS-$(CONFIG_NLMEANS_FILTER)                += vf_nlmeans.o
 OBJS-$(CONFIG_NLMEANS_OPENCL_FILTER)         += vf_nlmeans_opencl.o opencl.o opencl/nlmeans.o
 OBJS-$(CONFIG_NNEDI_FILTER)                  += vf_nnedi.o
diff --git a/libavfilter/vf_lut.c b/libavfilter/vf_lut.c
index 64668039d1..fd5b364797 100644
--- a/libavfilter/vf_lut.c
+++ b/libavfilter/vf_lut.c
@@ -69,7 +69,6 @@ typedef struct LutContext {
     int is_planar;
     int is_16bit;
     int step;
-    int negate_alpha; /* only used by negate */
 } LutContext;
 
 #define Y 0
@@ -642,30 +641,3 @@ static av_cold int lutrgb_init(AVFilterContext *ctx)
 DEFINE_LUT_FILTER(lutrgb, "Compute and apply a lookup table to the RGB input video.",
                   lut);
 #endif
-
-#if CONFIG_NEGATE_FILTER
-
-static const AVOption negate_options[] = {
-    { "negate_alpha", NULL, OFFSET(negate_alpha), AV_OPT_TYPE_BOOL, { .i64 = 0 }, 0, 1, FLAGS },
-    { NULL }
-};
-
-AVFILTER_DEFINE_CLASS(negate);
-
-static av_cold int negate_init(AVFilterContext *ctx)
-{
-    LutContext *s = ctx->priv;
-
-    for (int i = 0; i < 4; i++) {
-        s->comp_expr_str[i] = av_strdup((i == 3 && !s->negate_alpha) ?
-                                          "val" : "negval");
-        if (!s->comp_expr_str[i])
-            return AVERROR(ENOMEM);
-    }
-
-    return 0;
-}
-
-DEFINE_LUT_FILTER(negate, "Negate input video.", negate);
-
-#endif
diff --git a/libavfilter/vf_negate.c b/libavfilter/vf_negate.c
new file mode 100644
index 0000000000..d782e63d3a
--- /dev/null
+++ b/libavfilter/vf_negate.c
@@ -0,0 +1,375 @@
+/*
+ * This file is part of FFmpeg.
+ *
+ * FFmpeg is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * FFmpeg is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with FFmpeg; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ */
+
+#include "libavutil/attributes.h"
+#include "libavutil/common.h"
+#include "libavutil/imgutils.h"
+#include "libavutil/opt.h"
+#include "libavutil/pixdesc.h"
+#include "avfilter.h"
+#include "drawutils.h"
+#include "formats.h"
+#include "internal.h"
+#include "video.h"
+
+#define COMP_R 0x01
+#define COMP_G 0x02
+#define COMP_B 0x04
+#define COMP_A 0x08
+#define COMP_Y 0x10
+#define COMP_U 0x20
+#define COMP_V 0x40
+
+typedef struct ThreadData {
+    AVFrame *in;
+    AVFrame *out;
+} ThreadData;
+
+typedef struct NegateContext {
+    const AVClass *class;
+    int negate_alpha;
+    int max;
+    int requested_components;
+    int components;
+    int planes;
+    int step;
+    int nb_planes;
+    int linesize[4];
+    int width[4];
+    int height[4];
+    uint8_t rgba_map[4];
+
+    void (*negate)(const uint8_t *src, uint8_t *dst,
+                   ptrdiff_t slinesize, ptrdiff_t dlinesize,
+                   int w, int h, int max, int step,
+                   int components);
+} NegateContext;
+
+#define OFFSET(x) offsetof(NegateContext, x)
+#define FLAGS AV_OPT_FLAG_FILTERING_PARAM|AV_OPT_FLAG_VIDEO_PARAM|AV_OPT_FLAG_RUNTIME_PARAM
+
+static const AVOption negate_options[] = {
+    { "components", "set components to negate",  OFFSET(requested_components), AV_OPT_TYPE_FLAGS, {.i64=0x77}, 1, 0xff, FLAGS, "flags"},
+    {      "y", "set luma component",  0, AV_OPT_TYPE_CONST, {.i64=COMP_Y}, 0, 0, FLAGS, "flags"},
+    {      "u", "set u component",     0, AV_OPT_TYPE_CONST, {.i64=COMP_U}, 0, 0, FLAGS, "flags"},
+    {      "v", "set v component",     0, AV_OPT_TYPE_CONST, {.i64=COMP_V}, 0, 0, FLAGS, "flags"},
+    {      "r", "set red component",   0, AV_OPT_TYPE_CONST, {.i64=COMP_R}, 0, 0, FLAGS, "flags"},
+    {      "g", "set green component", 0, AV_OPT_TYPE_CONST, {.i64=COMP_G}, 0, 0, FLAGS, "flags"},
+    {      "b", "set blue component",  0, AV_OPT_TYPE_CONST, {.i64=COMP_B}, 0, 0, FLAGS, "flags"},
+    {      "a", "set alpha component", 0, AV_OPT_TYPE_CONST, {.i64=COMP_A}, 0, 0, FLAGS, "flags"},
+    { "negate_alpha",  NULL,    OFFSET(negate_alpha), AV_OPT_TYPE_BOOL, {.i64=0},    0,    1, FLAGS },
+    { NULL }
+};
+
+AVFILTER_DEFINE_CLASS(negate);
+
+static const enum AVPixelFormat pix_fmts[] = {
+    AV_PIX_FMT_YUV444P,  AV_PIX_FMT_YUV422P,  AV_PIX_FMT_YUV420P,
+    AV_PIX_FMT_YUV411P,  AV_PIX_FMT_YUV410P,  AV_PIX_FMT_YUV440P,
+    AV_PIX_FMT_YUVA420P, AV_PIX_FMT_YUVA422P, AV_PIX_FMT_YUVA444P,
+    AV_PIX_FMT_YUVJ444P, AV_PIX_FMT_YUVJ422P, AV_PIX_FMT_YUVJ420P,
+    AV_PIX_FMT_YUVJ440P,
+    AV_PIX_FMT_YUV444P9, AV_PIX_FMT_YUV422P9, AV_PIX_FMT_YUV420P9,
+    AV_PIX_FMT_YUV444P10, AV_PIX_FMT_YUV422P10, AV_PIX_FMT_YUV420P10, AV_PIX_FMT_YUV440P10,
+    AV_PIX_FMT_YUV444P12, AV_PIX_FMT_YUV422P12, AV_PIX_FMT_YUV420P12, AV_PIX_FMT_YUV440P12,
+    AV_PIX_FMT_YUV444P14, AV_PIX_FMT_YUV422P14, AV_PIX_FMT_YUV420P14,
+    AV_PIX_FMT_YUV444P16, AV_PIX_FMT_YUV422P16, AV_PIX_FMT_YUV420P16,
+    AV_PIX_FMT_YUVA444P16, AV_PIX_FMT_YUVA422P16, AV_PIX_FMT_YUVA420P16,
+    AV_PIX_FMT_ARGB, AV_PIX_FMT_RGBA,
+    AV_PIX_FMT_ABGR, AV_PIX_FMT_BGRA,
+    AV_PIX_FMT_RGB24, AV_PIX_FMT_BGR24,
+    AV_PIX_FMT_RGB48, AV_PIX_FMT_RGBA64,
+    AV_PIX_FMT_BGR48, AV_PIX_FMT_BGRA64,
+    AV_PIX_FMT_GBRP, AV_PIX_FMT_GBRAP,
+    AV_PIX_FMT_GBRP9, AV_PIX_FMT_GBRP10,
+    AV_PIX_FMT_GBRAP10,
+    AV_PIX_FMT_GBRP12, AV_PIX_FMT_GBRP14,
+    AV_PIX_FMT_GBRP16, AV_PIX_FMT_GBRAP12,
+    AV_PIX_FMT_GBRAP16,
+    AV_PIX_FMT_GRAY8, AV_PIX_FMT_GRAY9, AV_PIX_FMT_GRAY10,
+    AV_PIX_FMT_GRAY12, AV_PIX_FMT_GRAY14, AV_PIX_FMT_GRAY16,
+    AV_PIX_FMT_NONE
+};
+
+static void negate8(const uint8_t *src, uint8_t *dst,
+                     ptrdiff_t slinesize, ptrdiff_t dlinesize,
+                     int w, int h, int max, int step,
+                     int components)
+{
+    for (int y = 0; y < h; y++) {
+        for (int x = 0; x < w; x++)
+            dst[x] = 255 - src[x];
+
+        dst += dlinesize;
+        src += slinesize;
+    }
+}
+
+static void negate_packed8(const uint8_t *ssrc, uint8_t *ddst,
+                           ptrdiff_t slinesize, ptrdiff_t dlinesize,
+                           int w, int h, int max, int step,
+                           int components)
+{
+    for (int y = 0; y < h; y++) {
+        const uint8_t *src = ssrc + y * slinesize;
+        uint8_t *dst = ddst + y * dlinesize;
+
+        for (int x = 0; x < w; x++) {
+            switch (step) {
+            case 4:  dst[3] = components & 8 ? 255 - src[3] : src[3];
+            case 3:  dst[2] = components & 4 ? 255 - src[2] : src[2];
+            case 2:  dst[1] = components & 2 ? 255 - src[1] : src[1];
+            default: dst[0] = components & 1 ? 255 - src[0] : src[0];
+            }
+
+            src += step;
+            dst += step;
+        }
+    }
+}
+
+static void negate16(const uint8_t *ssrc, uint8_t *ddst,
+                     ptrdiff_t slinesize, ptrdiff_t dlinesize,
+                     int w, int h, int max, int step,
+                     int components)
+{
+    const uint16_t *src = (const uint16_t *)ssrc;
+    uint16_t *dst = (uint16_t *)ddst;
+
+    dlinesize /= 2;
+    slinesize /= 2;
+
+    for (int y = 0; y < h; y++) {
+        for (int x = 0; x < w; x++)
+            dst[x] = max - src[x];
+
+        dst += dlinesize;
+        src += slinesize;
+    }
+}
+
+static void negate_packed16(const uint8_t *ssrc, uint8_t *ddst,
+                            ptrdiff_t slinesize, ptrdiff_t dlinesize,
+                            int w, int h, int max, int step,
+                            int components)
+{
+    for (int y = 0; y < h; y++) {
+        const uint16_t *src = (const uint16_t *)(ssrc + y * slinesize);
+        uint16_t *dst = (uint16_t *)(ddst + y * dlinesize);
+
+        for (int x = 0; x < w; x++) {
+            switch (step) {
+            case 4:  dst[3] = components & 8 ? max - src[3] : src[3];
+            case 3:  dst[2] = components & 4 ? max - src[2] : src[2];
+            case 2:  dst[1] = components & 2 ? max - src[1] : src[1];
+            default: dst[0] = components & 1 ? max - src[0] : src[0];
+            }
+
+            src += step;
+            dst += step;
+        }
+    }
+}
+
+static int config_input(AVFilterLink *inlink)
+{
+    AVFilterContext *ctx = inlink->dst;
+    NegateContext *s = ctx->priv;
+    const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(inlink->format);
+    int depth, vsub, hsub, ret, is_packed;
+    int comp_avail;
+
+    s->planes = s->negate_alpha ? 0xF : 0x7;
+    is_packed = !(desc->flags & AV_PIX_FMT_FLAG_PLANAR) &&
+                 (desc->nb_components > 1);
+    if (s->requested_components != 0x77) {
+        comp_avail = ((desc->flags & AV_PIX_FMT_FLAG_RGB) ? COMP_R|COMP_G|COMP_B :
+                                                     COMP_Y |
+                                    ((desc->nb_components > 2) ? COMP_U|COMP_V : 0)) |
+                      ((desc->flags & AV_PIX_FMT_FLAG_ALPHA) ? COMP_A : 0);
+        if (s->requested_components & ~comp_avail) {
+            av_log(ctx, AV_LOG_ERROR, "Requested components not available.\n");
+            return AVERROR(EINVAL);
+        }
+
+        s->planes = 0;
+        if (!(desc->flags & AV_PIX_FMT_FLAG_RGB)) {
+            if (s->requested_components & COMP_Y)
+                s->planes |= 1;
+            if (s->requested_components & COMP_U)
+                s->planes |= 2;
+            if (s->requested_components & COMP_V)
+                s->planes |= 4;
+            if (s->requested_components & COMP_A)
+                s->planes |= 8;
+        } else {
+            if (s->requested_components & COMP_R)
+                s->planes |= 4;
+            if (s->requested_components & COMP_G)
+                s->planes |= 1;
+            if (s->requested_components & COMP_B)
+                s->planes |= 2;
+            if (s->requested_components & COMP_A)
+                s->planes |= 8;
+        }
+    }
+    s->nb_planes = av_pix_fmt_count_planes(inlink->format);
+
+    s->components = 0;
+    if (desc->flags & AV_PIX_FMT_FLAG_RGB) {
+        ff_fill_rgba_map(s->rgba_map, inlink->format);
+
+        if (s->requested_components & COMP_R)
+            s->components |= 1 << s->rgba_map[0];
+        if (s->requested_components & COMP_G)
+            s->components |= 1 << s->rgba_map[1];
+        if (s->requested_components & COMP_B)
+            s->components |= 1 << s->rgba_map[2];
+        if (s->requested_components & COMP_A)
+            s->components |= 1 << s->rgba_map[3];
+    }
+
+    if ((ret = av_image_fill_linesizes(s->linesize, inlink->format, inlink->w)) < 0)
+        return ret;
+
+    depth = desc->comp[0].depth;
+    hsub = desc->log2_chroma_w;
+    vsub = desc->log2_chroma_h;
+    s->height[1] = s->height[2] = AV_CEIL_RSHIFT(inlink->h, vsub);
+    s->height[0] = s->height[3] = inlink->h;
+    s->width[1]  = s->width[2]  = AV_CEIL_RSHIFT(inlink->w, hsub);
+    s->width[0]  = s->width[3]  = inlink->w;
+
+    s->negate = depth <= 8 ? negate8 : negate16;
+    if (is_packed) {
+        s->negate = depth <= 8 ? negate_packed8 : negate_packed16;
+        s->planes = 1;
+    }
+    s->max = (1 << depth) - 1;
+    s->step = av_get_bits_per_pixel(desc) >> 3;
+    if (depth > 8)
+        s->step = s->step >> 1;
+
+    return 0;
+}
+
+static int filter_slice(AVFilterContext *ctx, void *arg, int jobnr, int nb_jobs)
+{
+    NegateContext *s = ctx->priv;
+    ThreadData *td = arg;
+    AVFrame *in = td->in;
+    AVFrame *out = td->out;
+
+    for (int p = 0; p < s->nb_planes; p++) {
+        const int h = s->height[p];
+        const int slice_start = (h * jobnr) / nb_jobs;
+        const int slice_end = (h * (jobnr+1)) / nb_jobs;
+
+        if (!((1 << p) & s->planes)) {
+            if (out != in)
+                av_image_copy_plane(out->data[p] + slice_start * out->linesize[p],
+                                    out->linesize[p],
+                                    in->data[p] + slice_start * in->linesize[p],
+                                    in->linesize[p],
+                                    s->linesize[p], slice_end - slice_start);
+            continue;
+        }
+
+        s->negate(in->data[p] + slice_start * in->linesize[p],
+                  out->data[p] + slice_start * out->linesize[p],
+                  in->linesize[p], out->linesize[p],
+                  s->width[p], slice_end - slice_start,
+                  s->max, s->step, s->components);
+    }
+
+    return 0;
+}
+
+static int filter_frame(AVFilterLink *inlink, AVFrame *in)
+{
+    AVFilterContext *ctx = inlink->dst;
+    NegateContext *s = ctx->priv;
+    AVFilterLink *outlink = ctx->outputs[0];
+    ThreadData td;
+    AVFrame *out;
+
+    if (av_frame_is_writable(in)) {
+        out = in;
+    } else {
+        out = ff_get_video_buffer(outlink, outlink->w, outlink->h);
+        if (!out) {
+            av_frame_free(&in);
+            return AVERROR(ENOMEM);
+        }
+        av_frame_copy_props(out, in);
+    }
+
+    td.out = out;
+    td.in = in;
+    ff_filter_execute(ctx, filter_slice, &td, NULL,
+                      FFMIN(s->height[2], ff_filter_get_nb_threads(ctx)));
+    if (out != in)
+        av_frame_free(&in);
+
+    return ff_filter_frame(outlink, out);
+}
+
+static int process_command(AVFilterContext *ctx, const char *cmd, const char *args,
+                           char *res, int res_len, int flags)
+{
+    NegateContext *s = ctx->priv;
+    int old_planes = s->planes;
+    int ret;
+
+    ret = ff_filter_process_command(ctx, cmd, args, res, res_len, flags);
+    if (ret < 0)
+        return ret;
+
+    ret = config_input(ctx->inputs[0]);
+    if (ret < 0)
+        s->planes = old_planes;
+    return ret;
+}
+
+static const AVFilterPad inputs[] = {
+    {
+        .name         = "default",
+        .type         = AVMEDIA_TYPE_VIDEO,
+        .filter_frame = filter_frame,
+        .config_props = config_input,
+    },
+};
+
+static const AVFilterPad outputs[] = {
+    {
+        .name = "default",
+        .type = AVMEDIA_TYPE_VIDEO,
+    },
+};
+
+const AVFilter ff_vf_negate = {
+    .name          = "negate",
+    .description   = NULL_IF_CONFIG_SMALL("Negate input video."),
+    .priv_size     = sizeof(NegateContext),
+    .priv_class    = &negate_class,
+    FILTER_INPUTS(inputs),
+    FILTER_OUTPUTS(outputs),
+    FILTER_PIXFMTS_ARRAY(pix_fmts),
+    .flags         = AVFILTER_FLAG_SUPPORT_TIMELINE_GENERIC | AVFILTER_FLAG_SLICE_THREADS,
+    .process_command = process_command,
+};
diff --git a/tests/ref/fate/filter-negate b/tests/ref/fate/filter-negate
index 88d04718ae..aa9a820c0d 100644
--- a/tests/ref/fate/filter-negate
+++ b/tests/ref/fate/filter-negate
@@ -3,53 +3,53 @@
 #codec_id 0: rawvideo
 #dimensions 0: 352x288
 #sar 0: 0/1
-0,          0,          0,        1,   152064, 0xef20e1ec
-0,          1,          1,        1,   152064, 0x899606ec
-0,          2,          2,        1,   152064, 0xaea175d2
-0,          3,          3,        1,   152064, 0x5201eb55
-0,          4,          4,        1,   152064, 0xf02bb525
-0,          5,          5,        1,   152064, 0x99fdc305
-0,          6,          6,        1,   152064, 0x3a8fefe7
-0,          7,          7,        1,   152064, 0x005edfbf
-0,          8,          8,        1,   152064, 0xe37aea50
-0,          9,          9,        1,   152064, 0xa5ad32f9
-0,         10,         10,        1,   152064, 0xb1e52485
-0,         11,         11,        1,   152064, 0x55b06e56
-0,         12,         12,        1,   152064, 0xdfb7be97
-0,         13,         13,        1,   152064, 0x191bca13
-0,         14,         14,        1,   152064, 0xa554dd3c
-0,         15,         15,        1,   152064, 0x36075b77
-0,         16,         16,        1,   152064, 0xbf6b1cbd
-0,         17,         17,        1,   152064, 0xf33432b6
-0,         18,         18,        1,   152064, 0x5d7100c3
-0,         19,         19,        1,   152064, 0x376f8f0c
-0,         20,         20,        1,   152064, 0x07ca75fa
-0,         21,         21,        1,   152064, 0xe3984704
-0,         22,         22,        1,   152064, 0xa8fb4e4c
-0,         23,         23,        1,   152064, 0xe8e102d8
-0,         24,         24,        1,   152064, 0xcc6771c9
-0,         25,         25,        1,   152064, 0xf646d238
-0,         26,         26,        1,   152064, 0xa52cd41e
-0,         27,         27,        1,   152064, 0x536d92c2
-0,         28,         28,        1,   152064, 0x7058c6a1
-0,         29,         29,        1,   152064, 0xcc6c05d0
-0,         30,         30,        1,   152064, 0x1fc2ffb8
-0,         31,         31,        1,   152064, 0x041ea59c
-0,         32,         32,        1,   152064, 0xfc006e07
-0,         33,         33,        1,   152064, 0x0246efe1
-0,         34,         34,        1,   152064, 0x079428e5
-0,         35,         35,        1,   152064, 0x64d9d773
-0,         36,         36,        1,   152064, 0x914d3454
-0,         37,         37,        1,   152064, 0xef69686e
-0,         38,         38,        1,   152064, 0x3c91129f
-0,         39,         39,        1,   152064, 0x2a611ca7
-0,         40,         40,        1,   152064, 0xaf56124f
-0,         41,         41,        1,   152064, 0xce48cd45
-0,         42,         42,        1,   152064, 0x75feac29
-0,         43,         43,        1,   152064, 0xfd2b4b5b
-0,         44,         44,        1,   152064, 0x8d2f675c
-0,         45,         45,        1,   152064, 0x1573ed3b
-0,         46,         46,        1,   152064, 0xb0fc17ca
-0,         47,         47,        1,   152064, 0x53e5a654
-0,         48,         48,        1,   152064, 0xe0cbb786
-0,         49,         49,        1,   152064, 0xcaa092fe
+0,          0,          0,        1,   152064, 0xdb0946b2
+0,          1,          1,        1,   152064, 0x950c6b50
+0,          2,          2,        1,   152064, 0x42e3da48
+0,          3,          3,        1,   152064, 0xb63d4ff1
+0,          4,          4,        1,   152064, 0x92dd1a4f
+0,          5,          5,        1,   152064, 0xf2fc27bb
+0,          6,          6,        1,   152064, 0xfea2547e
+0,          7,          7,        1,   152064, 0x860b44f5
+0,          8,          8,        1,   152064, 0xc1a5507b
+0,          9,          9,        1,   152064, 0x4f89978c
+0,         10,         10,        1,   152064, 0xde8c8941
+0,         11,         11,        1,   152064, 0xafcbd3bd
+0,         12,         12,        1,   152064, 0x19af2340
+0,         13,         13,        1,   152064, 0xbbd42e7e
+0,         14,         14,        1,   152064, 0x8e1c42c4
+0,         15,         15,        1,   152064, 0x37a4c19c
+0,         16,         16,        1,   152064, 0x528a8289
+0,         17,         17,        1,   152064, 0x2f6397d9
+0,         18,         18,        1,   152064, 0xee5265d5
+0,         19,         19,        1,   152064, 0xed64f493
+0,         20,         20,        1,   152064, 0xe436db22
+0,         21,         21,        1,   152064, 0x42f9ac8f
+0,         22,         22,        1,   152064, 0x9c63b348
+0,         23,         23,        1,   152064, 0xb19967b2
+0,         24,         24,        1,   152064, 0x12b7d6bc
+0,         25,         25,        1,   152064, 0x4b69376b
+0,         26,         26,        1,   152064, 0x9ce939ec
+0,         27,         27,        1,   152064, 0x0940f80b
+0,         28,         28,        1,   152064, 0x69ee2c4c
+0,         29,         29,        1,   152064, 0x72fd6b93
+0,         30,         30,        1,   152064, 0xd12365d7
+0,         31,         31,        1,   152064, 0xfe1c0b83
+0,         32,         32,        1,   152064, 0x095ad405
+0,         33,         33,        1,   152064, 0xfe825671
+0,         34,         34,        1,   152064, 0x60d68d29
+0,         35,         35,        1,   152064, 0xe6243ba6
+0,         36,         36,        1,   152064, 0x942998f6
+0,         37,         37,        1,   152064, 0x3bb3cea9
+0,         38,         38,        1,   152064, 0xd5b97755
+0,         39,         39,        1,   152064, 0x584d81c4
+0,         40,         40,        1,   152064, 0x0e4d777c
+0,         41,         41,        1,   152064, 0x0bdc3299
+0,         42,         42,        1,   152064, 0xbff210f8
+0,         43,         43,        1,   152064, 0x8964afb5
+0,         44,         44,        1,   152064, 0xe361cc30
+0,         45,         45,        1,   152064, 0x7f0c522e
+0,         46,         46,        1,   152064, 0xd6d17ca2
+0,         47,         47,        1,   152064, 0x72380adf
+0,         48,         48,        1,   152064, 0x25391c1e
+0,         49,         49,        1,   152064, 0x9506f7a8
