go-libwebp

libwebp_darwin_amd64.go (2234970B)

---

 // Code generated for darwin/amd64 by 'ccgo --goos=darwin --goarch=amd64 --package-name=webp -ignore-asm-errors -nostdinc -isystem /tmp/claude-1000/-home-jfm-Source-Personal-go-libwebp/63cfa3bd-5955-40ba-bf85-20c89d375570/scratchpad/zig-x86_64-linux-0.15.2/lib/include -isystem /tmp/claude-1000/-home-jfm-Source-Personal-go-libwebp/63cfa3bd-5955-40ba-bf85-20c89d375570/scratchpad/zig-x86_64-linux-0.15.2/lib/libc/include/any-macos-any -o /home/jfm/Source/Personal/go-libwebp/tools/../lib/transpiled/webp/libwebp_darwin_amd64.go -DNDEBUG -DHAVE_CONFIG_H -I/tmp/tmp.jLmqxibQOP -I. src/dec/alpha_dec.c src/dec/buffer_dec.c src/dec/frame_dec.c src/dec/idec_dec.c src/dec/io_dec.c src/dec/quant_dec.c src/dec/tree_dec.c src/dec/vp8_dec.c src/dec/vp8l_dec.c src/dec/webp_dec.c src/enc/alpha_enc.c src/enc/analysis_enc.c src/enc/backward_references_cost_enc.c src/enc/backward_references_enc.c src/enc/config_enc.c src/enc/cost_enc.c src/enc/filter_enc.c src/enc/frame_enc.c src/enc/histogram_enc.c src/enc/iterator_enc.c src/enc/near_lossless_enc.c src/enc/picture_csp_enc.c src/enc/picture_enc.c src/enc/picture_psnr_enc.c src/enc/picture_rescale_enc.c src/enc/picture_tools_enc.c src/enc/predictor_enc.c src/enc/quant_enc.c src/enc/syntax_enc.c src/enc/token_enc.c src/enc/tree_enc.c src/enc/vp8l_enc.c src/enc/webp_enc.c src/utils/bit_reader_utils.c src/utils/bit_writer_utils.c src/utils/color_cache_utils.c src/utils/filters_utils.c src/utils/huffman_encode_utils.c src/utils/huffman_utils.c src/utils/palette.c src/utils/quant_levels_dec_utils.c src/utils/quant_levels_utils.c src/utils/random_utils.c src/utils/rescaler_utils.c src/utils/thread_utils.c src/utils/utils.c src/dsp/alpha_processing.c src/dsp/alpha_processing_mips_dsp_r2.c src/dsp/alpha_processing_neon.c src/dsp/alpha_processing_sse2.c src/dsp/alpha_processing_sse41.c src/dsp/cost.c src/dsp/cost_mips32.c src/dsp/cost_mips_dsp_r2.c src/dsp/cost_neon.c src/dsp/cost_sse2.c src/dsp/cpu.c src/dsp/dec.c src/dsp/dec_clip_tables.c src/dsp/dec_mips32.c src/dsp/dec_mips_dsp_r2.c src/dsp/dec_msa.c src/dsp/dec_neon.c src/dsp/dec_sse2.c src/dsp/dec_sse41.c src/dsp/enc.c src/dsp/enc_mips32.c src/dsp/enc_mips_dsp_r2.c src/dsp/enc_msa.c src/dsp/enc_neon.c src/dsp/enc_sse2.c src/dsp/enc_sse41.c src/dsp/filters.c src/dsp/filters_mips_dsp_r2.c src/dsp/filters_msa.c src/dsp/filters_neon.c src/dsp/filters_sse2.c src/dsp/lossless_avx2.c src/dsp/lossless.c src/dsp/lossless_enc_avx2.c src/dsp/lossless_enc.c src/dsp/lossless_enc_mips32.c src/dsp/lossless_enc_mips_dsp_r2.c src/dsp/lossless_enc_msa.c src/dsp/lossless_enc_neon.c src/dsp/lossless_enc_sse2.c src/dsp/lossless_enc_sse41.c src/dsp/lossless_mips_dsp_r2.c src/dsp/lossless_msa.c src/dsp/lossless_neon.c src/dsp/lossless_sse2.c src/dsp/lossless_sse41.c src/dsp/rescaler.c src/dsp/rescaler_mips32.c src/dsp/rescaler_mips_dsp_r2.c src/dsp/rescaler_msa.c src/dsp/rescaler_neon.c src/dsp/rescaler_sse2.c src/dsp/ssim.c src/dsp/ssim_sse2.c src/dsp/upsampling.c src/dsp/upsampling_mips_dsp_r2.c src/dsp/upsampling_msa.c src/dsp/upsampling_neon.c src/dsp/upsampling_sse2.c src/dsp/upsampling_sse41.c src/dsp/yuv.c src/dsp/yuv_mips32.c src/dsp/yuv_mips_dsp_r2.c src/dsp/yuv_neon.c src/dsp/yuv_sse2.c src/dsp/yuv_sse41.c /home/jfm/Source/Personal/go-libwebp/tools/sharpyuv_stub.c', DO NOT EDIT.
 
 //go:build darwin && amd64
 
 package webp
 
 import (
 	"math"
 	"reflect"
 	"unsafe"
 
 	"modernc.org/libc"
 )
 
 var _ = math.Pi
 var _ reflect.Type
 var _ unsafe.Pointer
 
 const ALPHA_HEADER_LEN = 1
 const ALPHA_LOSSLESS_COMPRESSION = 1
 const ALPHA_NO_COMPRESSION = 0
 const ALPHA_PREPROCESSED_LEVELS = 1
 const ANIM_CHUNK_SIZE = 6
 const ANMF_CHUNK_SIZE = 16
 const ARGB_BLACK = 0xff000000
 const BADSIG = "SIG_ERR"
 const BIG_ENDIAN = "__DARWIN_BIG_ENDIAN"
 const BITS = 56
 const BITTRACE = 0
 const BPS = 32
 const BUS_ADRALN = 1
 const BUS_ADRERR = 2
 const BUS_NOOP = 0
 const BUS_OBJERR = 3
 const BYTE_ORDER = "__DARWIN_BYTE_ORDER"
 const CHUNK_HEADER_SIZE = 8
 const CHUNK_SIZE_BYTES = 4
 const CLD_CONTINUED = 6
 const CLD_DUMPED = 3
 const CLD_EXITED = 1
 const CLD_KILLED = 2
 const CLD_NOOP = 0
 const CLD_STOPPED = 5
 const CLD_TRAPPED = 4
 const CODE_LENGTH_CODES = 19
 const CPUMON_MAKE_FATAL = 0x1000
 const DEC_MAJ_VERSION = 1
 const DEC_MIN_VERSION = 6
 const DEC_REV_VERSION = 0
 const DEFAULT_CODE_LENGTH = 8
 const EXIT_FAILURE = 1
 const EXIT_SUCCESS = 0
 const FOOTPRINT_INTERVAL_RESET = 0x1
 const FPE_FLTDIV = 1
 const FPE_FLTINV = 5
 const FPE_FLTOVF = 2
 const FPE_FLTRES = 4
 const FPE_FLTSUB = 6
 const FPE_FLTUND = 3
 const FPE_INTDIV = 7
 const FPE_INTOVF = 8
 const FPE_NOOP = 0
 const FP_CHOP = 3
 const FP_PREC_24B = 0
 const FP_PREC_53B = 2
 const FP_PREC_64B = 3
 const FP_RND_DOWN = 1
 const FP_RND_NEAR = 0
 const FP_RND_UP = 2
 const FP_STATE_BYTES = 512
 const HAVE_BUILTIN_BSWAP16 = 1
 const HAVE_BUILTIN_BSWAP32 = 1
 const HAVE_BUILTIN_BSWAP64 = 1
 const HAVE_CONFIG_H = 1
 const HUFFMAN_CODES_PER_META_CODE = 5
 const HUFFMAN_PACKED_BITS = 6
 const HUFFMAN_TABLE_BITS = 8
 const ILL_BADSTK = 8
 const ILL_COPROC = 7
 const ILL_ILLADR = 5
 const ILL_ILLOPC = 1
 const ILL_ILLOPN = 4
 const ILL_ILLTRP = 2
 const ILL_NOOP = 0
 const ILL_PRVOPC = 3
 const ILL_PRVREG = 6
 const INT16_MAX = 32767
 const INT32_MAX = 2147483647
 const INT64_MAX = 9223372036854775807
 const INT8_MAX = 127
 const INTPTR_MAX = 9223372036854775807
 const INT_FAST16_MAX = "INT16_MAX"
 const INT_FAST16_MIN = "INT16_MIN"
 const INT_FAST32_MAX = "INT32_MAX"
 const INT_FAST32_MIN = "INT32_MIN"
 const INT_FAST64_MAX = "INT64_MAX"
 const INT_FAST64_MIN = "INT64_MIN"
 const INT_FAST8_MAX = "INT8_MAX"
 const INT_FAST8_MIN = "INT8_MIN"
 const INT_LEAST16_MAX = "INT16_MAX"
 const INT_LEAST16_MIN = "INT16_MIN"
 const INT_LEAST32_MAX = "INT32_MAX"
 const INT_LEAST32_MIN = "INT32_MIN"
 const INT_LEAST64_MAX = "INT64_MAX"
 const INT_LEAST64_MIN = "INT64_MIN"
 const INT_LEAST8_MAX = "INT8_MAX"
 const INT_LEAST8_MIN = "INT8_MIN"
 const IOPOL_APPLICATION = "IOPOL_STANDARD"
 const IOPOL_ATIME_UPDATES_DEFAULT = 0
 const IOPOL_ATIME_UPDATES_OFF = 1
 const IOPOL_DEFAULT = 0
 const IOPOL_IMPORTANT = 1
 const IOPOL_MATERIALIZE_DATALESS_FILES_DEFAULT = 0
 const IOPOL_MATERIALIZE_DATALESS_FILES_OFF = 1
 const IOPOL_MATERIALIZE_DATALESS_FILES_ON = 2
 const IOPOL_NORMAL = "IOPOL_IMPORTANT"
 const IOPOL_PASSIVE = 2
 const IOPOL_SCOPE_DARWIN_BG = 2
 const IOPOL_SCOPE_PROCESS = 0
 const IOPOL_SCOPE_THREAD = 1
 const IOPOL_STANDARD = 5
 const IOPOL_THROTTLE = 3
 const IOPOL_TYPE_DISK = 0
 const IOPOL_TYPE_VFS_ALLOW_LOW_SPACE_WRITES = 9
 const IOPOL_TYPE_VFS_ATIME_UPDATES = 2
 const IOPOL_TYPE_VFS_DISALLOW_RW_FOR_O_EVTONLY = 10
 const IOPOL_TYPE_VFS_IGNORE_CONTENT_PROTECTION = 6
 const IOPOL_TYPE_VFS_IGNORE_PERMISSIONS = 7
 const IOPOL_TYPE_VFS_MATERIALIZE_DATALESS_FILES = 3
 const IOPOL_TYPE_VFS_SKIP_MTIME_UPDATE = 8
 const IOPOL_TYPE_VFS_STATFS_NO_DATA_VOLUME = 4
 const IOPOL_TYPE_VFS_TRIGGER_RESOLVE = 5
 const IOPOL_UTILITY = 4
 const IOPOL_VFS_ALLOW_LOW_SPACE_WRITES_OFF = 0
 const IOPOL_VFS_ALLOW_LOW_SPACE_WRITES_ON = 1
 const IOPOL_VFS_CONTENT_PROTECTION_DEFAULT = 0
 const IOPOL_VFS_CONTENT_PROTECTION_IGNORE = 1
 const IOPOL_VFS_DISALLOW_RW_FOR_O_EVTONLY_DEFAULT = 0
 const IOPOL_VFS_DISALLOW_RW_FOR_O_EVTONLY_ON = 1
 const IOPOL_VFS_IGNORE_PERMISSIONS_OFF = 0
 const IOPOL_VFS_IGNORE_PERMISSIONS_ON = 1
 const IOPOL_VFS_NOCACHE_WRITE_FS_BLKSIZE_DEFAULT = 0
 const IOPOL_VFS_NOCACHE_WRITE_FS_BLKSIZE_ON = 1
 const IOPOL_VFS_SKIP_MTIME_UPDATE_IGNORE = 2
 const IOPOL_VFS_SKIP_MTIME_UPDATE_OFF = 0
 const IOPOL_VFS_SKIP_MTIME_UPDATE_ON = 1
 const IOPOL_VFS_STATFS_FORCE_NO_DATA_VOLUME = 1
 const IOPOL_VFS_STATFS_NO_DATA_VOLUME_DEFAULT = 0
 const IOPOL_VFS_TRIGGER_RESOLVE_DEFAULT = 0
 const IOPOL_VFS_TRIGGER_RESOLVE_OFF = 1
 const LENGTHS_TABLE_BITS = 7
 const LITTLE_ENDIAN = "__DARWIN_LITTLE_ENDIAN"
 const LOCAL_CLANG_VERSION = 0
 const MAC_OS_VERSION_11_0 = "__MAC_11_0"
 const MAC_OS_VERSION_11_1 = "__MAC_11_1"
 const MAC_OS_VERSION_11_3 = "__MAC_11_3"
 const MAC_OS_VERSION_11_4 = "__MAC_11_4"
 const MAC_OS_VERSION_11_5 = "__MAC_11_5"
 const MAC_OS_VERSION_11_6 = "__MAC_11_6"
 const MAC_OS_VERSION_12_0 = "__MAC_12_0"
 const MAC_OS_VERSION_12_1 = "__MAC_12_1"
 const MAC_OS_VERSION_12_2 = "__MAC_12_2"
 const MAC_OS_VERSION_12_3 = "__MAC_12_3"
 const MAC_OS_VERSION_12_4 = "__MAC_12_4"
 const MAC_OS_VERSION_12_5 = "__MAC_12_5"
 const MAC_OS_VERSION_12_6 = "__MAC_12_6"
 const MAC_OS_VERSION_12_7 = "__MAC_12_7"
 const MAC_OS_VERSION_13_0 = "__MAC_13_0"
 const MAC_OS_VERSION_13_1 = "__MAC_13_1"
 const MAC_OS_VERSION_13_2 = "__MAC_13_2"
 const MAC_OS_VERSION_13_3 = "__MAC_13_3"
 const MAC_OS_VERSION_13_4 = "__MAC_13_4"
 const MAC_OS_VERSION_13_5 = "__MAC_13_5"
 const MAC_OS_VERSION_13_6 = "__MAC_13_6"
 const MAC_OS_VERSION_13_7 = "__MAC_13_7"
 const MAC_OS_VERSION_14_0 = "__MAC_14_0"
 const MAC_OS_VERSION_14_1 = "__MAC_14_1"
 const MAC_OS_VERSION_14_2 = "__MAC_14_2"
 const MAC_OS_VERSION_14_3 = "__MAC_14_3"
 const MAC_OS_VERSION_14_4 = "__MAC_14_4"
 const MAC_OS_VERSION_14_5 = "__MAC_14_5"
 const MAC_OS_VERSION_14_6 = "__MAC_14_6"
 const MAC_OS_VERSION_14_7 = "__MAC_14_7"
 const MAC_OS_VERSION_15_0 = "__MAC_15_0"
 const MAC_OS_VERSION_15_1 = "__MAC_15_1"
 const MAC_OS_VERSION_15_2 = "__MAC_15_2"
 const MAC_OS_VERSION_15_3 = "__MAC_15_3"
 const MAC_OS_VERSION_15_4 = "__MAC_15_4"
 const MAC_OS_VERSION_15_5 = "__MAC_15_5"
 const MAC_OS_X_VERSION_10_0 = "__MAC_10_0"
 const MAC_OS_X_VERSION_10_1 = "__MAC_10_1"
 const MAC_OS_X_VERSION_10_10 = "__MAC_10_10"
 const MAC_OS_X_VERSION_10_10_2 = "__MAC_10_10_2"
 const MAC_OS_X_VERSION_10_10_3 = "__MAC_10_10_3"
 const MAC_OS_X_VERSION_10_11 = "__MAC_10_11"
 const MAC_OS_X_VERSION_10_11_2 = "__MAC_10_11_2"
 const MAC_OS_X_VERSION_10_11_3 = "__MAC_10_11_3"
 const MAC_OS_X_VERSION_10_11_4 = "__MAC_10_11_4"
 const MAC_OS_X_VERSION_10_12 = "__MAC_10_12"
 const MAC_OS_X_VERSION_10_12_1 = "__MAC_10_12_1"
 const MAC_OS_X_VERSION_10_12_2 = "__MAC_10_12_2"
 const MAC_OS_X_VERSION_10_12_4 = "__MAC_10_12_4"
 const MAC_OS_X_VERSION_10_13 = "__MAC_10_13"
 const MAC_OS_X_VERSION_10_13_1 = "__MAC_10_13_1"
 const MAC_OS_X_VERSION_10_13_2 = "__MAC_10_13_2"
 const MAC_OS_X_VERSION_10_13_4 = "__MAC_10_13_4"
 const MAC_OS_X_VERSION_10_14 = "__MAC_10_14"
 const MAC_OS_X_VERSION_10_14_1 = "__MAC_10_14_1"
 const MAC_OS_X_VERSION_10_14_4 = "__MAC_10_14_4"
 const MAC_OS_X_VERSION_10_14_5 = "__MAC_10_14_5"
 const MAC_OS_X_VERSION_10_14_6 = "__MAC_10_14_6"
 const MAC_OS_X_VERSION_10_15 = "__MAC_10_15"
 const MAC_OS_X_VERSION_10_15_1 = "__MAC_10_15_1"
 const MAC_OS_X_VERSION_10_15_4 = "__MAC_10_15_4"
 const MAC_OS_X_VERSION_10_16 = "__MAC_10_16"
 const MAC_OS_X_VERSION_10_2 = "__MAC_10_2"
 const MAC_OS_X_VERSION_10_3 = "__MAC_10_3"
 const MAC_OS_X_VERSION_10_4 = "__MAC_10_4"
 const MAC_OS_X_VERSION_10_5 = "__MAC_10_5"
 const MAC_OS_X_VERSION_10_6 = "__MAC_10_6"
 const MAC_OS_X_VERSION_10_7 = "__MAC_10_7"
 const MAC_OS_X_VERSION_10_8 = "__MAC_10_8"
 const MAC_OS_X_VERSION_10_9 = "__MAC_10_9"
 const MAX_ALLOWED_CODE_LENGTH = 15
 const MAX_CACHE_BITS = 11
 const MAX_COEFF_THRESH = 31
 const MAX_PALETTE_SIZE = 256
 const MB_CUR_MAX = "__mb_cur_max"
 const MINSIGSTKSZ = 32768
 const MIN_HUFFMAN_BITS = 2
 const MIN_TRANSFORM_BITS = 2
 const MIN_WIDTH_FOR_THREADS = 512
 const NDEBUG = 1
 const NSIG = "__DARWIN_NSIG"
 const NUM_DISTANCE_CODES = 40
 const NUM_HUFFMAN_BITS = 3
 const NUM_LENGTH_CODES = 24
 const NUM_LITERAL_CODES = 256
 const NUM_TRANSFORMS = 4
 const NUM_TRANSFORM_BITS = 3
 const PDP_ENDIAN = "__DARWIN_PDP_ENDIAN"
 const POLL_ERR = 4
 const POLL_HUP = 6
 const POLL_IN = 1
 const POLL_MSG = 3
 const POLL_OUT = 2
 const POLL_PRI = 5
 const PRIO_DARWIN_BG = 0x1000
 const PRIO_DARWIN_NONUI = 0x1001
 const PRIO_DARWIN_PROCESS = 4
 const PRIO_DARWIN_THREAD = 3
 const PRIO_MAX = 20
 const PRIO_PGRP = 1
 const PRIO_PROCESS = 0
 const PRIO_USER = 2
 const PRIX16 = "hX"
 const PRIX32 = "X"
 const PRIXFAST16 = "PRIX16"
 const PRIXFAST32 = "PRIX32"
 const PRIXFAST64 = "PRIX64"
 const PRIXFAST8 = "PRIX8"
 const PRIXLEAST16 = "PRIX16"
 const PRIXLEAST32 = "PRIX32"
 const PRIXLEAST64 = "PRIX64"
 const PRIXLEAST8 = "PRIX8"
 const PRIXPTR = "lX"
 const PRId16 = "hd"
 const PRId32 = "d"
 const PRIdFAST16 = "PRId16"
 const PRIdFAST32 = "PRId32"
 const PRIdFAST64 = "PRId64"
 const PRIdFAST8 = "PRId8"
 const PRIdLEAST16 = "PRId16"
 const PRIdLEAST32 = "PRId32"
 const PRIdLEAST64 = "PRId64"
 const PRIdLEAST8 = "PRId8"
 const PRIdPTR = "ld"
 const PRIi16 = "hi"
 const PRIi32 = "i"
 const PRIiFAST16 = "PRIi16"
 const PRIiFAST32 = "PRIi32"
 const PRIiFAST64 = "PRIi64"
 const PRIiFAST8 = "PRIi8"
 const PRIiLEAST16 = "PRIi16"
 const PRIiLEAST32 = "PRIi32"
 const PRIiLEAST64 = "PRIi64"
 const PRIiLEAST8 = "PRIi8"
 const PRIiPTR = "li"
 const PRIo16 = "ho"
 const PRIo32 = "o"
 const PRIoFAST16 = "PRIo16"
 const PRIoFAST32 = "PRIo32"
 const PRIoFAST64 = "PRIo64"
 const PRIoFAST8 = "PRIo8"
 const PRIoLEAST16 = "PRIo16"
 const PRIoLEAST32 = "PRIo32"
 const PRIoLEAST64 = "PRIo64"
 const PRIoLEAST8 = "PRIo8"
 const PRIoPTR = "lo"
 const PRIu16 = "hu"
 const PRIu32 = "u"
 const PRIuFAST16 = "PRIu16"
 const PRIuFAST32 = "PRIu32"
 const PRIuFAST64 = "PRIu64"
 const PRIuFAST8 = "PRIu8"
 const PRIuLEAST16 = "PRIu16"
 const PRIuLEAST32 = "PRIu32"
 const PRIuLEAST64 = "PRIu64"
 const PRIuLEAST8 = "PRIu8"
 const PRIuPTR = "lu"
 const PRIx16 = "hx"
 const PRIx32 = "x"
 const PRIxFAST16 = "PRIx16"
 const PRIxFAST32 = "PRIx32"
 const PRIxFAST64 = "PRIx64"
 const PRIxFAST8 = "PRIx8"
 const PRIxLEAST16 = "PRIx16"
 const PRIxLEAST32 = "PRIx32"
 const PRIxLEAST64 = "PRIx64"
 const PRIxLEAST8 = "PRIx8"
 const PRIxPTR = "lx"
 const PTRDIFF_MAX = "INTMAX_MAX"
 const PTRDIFF_MIN = "INTMAX_MIN"
 const RAND_MAX = 0x7fffffff
 const RIFF_HEADER_SIZE = 12
 const RLIMIT_AS = 5
 const RLIMIT_CORE = 4
 const RLIMIT_CPU = 0
 const RLIMIT_CPU_USAGE_MONITOR = 0x2
 const RLIMIT_DATA = 2
 const RLIMIT_FOOTPRINT_INTERVAL = 0x4
 const RLIMIT_FSIZE = 1
 const RLIMIT_MEMLOCK = 6
 const RLIMIT_NOFILE = 8
 const RLIMIT_NPROC = 7
 const RLIMIT_RSS = "RLIMIT_AS"
 const RLIMIT_STACK = 3
 const RLIMIT_THREAD_CPULIMITS = 0x3
 const RLIMIT_WAKEUPS_MONITOR = 0x1
 const RLIM_NLIMITS = 9
 const RLIM_SAVED_CUR = "RLIM_INFINITY"
 const RLIM_SAVED_MAX = "RLIM_INFINITY"
 const RUSAGE_INFO_CURRENT = "RUSAGE_INFO_V6"
 const RUSAGE_INFO_V0 = 0
 const RUSAGE_INFO_V1 = 1
 const RUSAGE_INFO_V2 = 2
 const RUSAGE_INFO_V3 = 3
 const RUSAGE_INFO_V4 = 4
 const RUSAGE_INFO_V5 = 5
 const RUSAGE_INFO_V6 = 6
 const RUSAGE_SELF = 0
 const RU_PROC_RUNS_RESLIDE = 0x00000001
 const SA_64REGSET = 0x0200
 const SA_NOCLDSTOP = 0x0008
 const SA_NOCLDWAIT = 0x0020
 const SA_NODEFER = 0x0010
 const SA_ONSTACK = 0x0001
 const SA_RESETHAND = 0x0004
 const SA_RESTART = 0x0002
 const SA_SIGINFO = 0x0040
 const SA_USERTRAMP = 0x0100
 const SCNd16 = "hd"
 const SCNd32 = "d"
 const SCNdFAST16 = "SCNd16"
 const SCNdFAST32 = "SCNd32"
 const SCNdFAST64 = "SCNd64"
 const SCNdFAST8 = "SCNd8"
 const SCNdLEAST16 = "SCNd16"
 const SCNdLEAST32 = "SCNd32"
 const SCNdLEAST64 = "SCNd64"
 const SCNdLEAST8 = "SCNd8"
 const SCNdPTR = "ld"
 const SCNi16 = "hi"
 const SCNi32 = "i"
 const SCNiFAST16 = "SCNi16"
 const SCNiFAST32 = "SCNi32"
 const SCNiFAST64 = "SCNi64"
 const SCNiFAST8 = "SCNi8"
 const SCNiLEAST16 = "SCNi16"
 const SCNiLEAST32 = "SCNi32"
 const SCNiLEAST64 = "SCNi64"
 const SCNiLEAST8 = "SCNi8"
 const SCNiPTR = "li"
 const SCNo16 = "ho"
 const SCNo32 = "o"
 const SCNoFAST16 = "SCNo16"
 const SCNoFAST32 = "SCNo32"
 const SCNoFAST64 = "SCNo64"
 const SCNoFAST8 = "SCNo8"
 const SCNoLEAST16 = "SCNo16"
 const SCNoLEAST32 = "SCNo32"
 const SCNoLEAST64 = "SCNo64"
 const SCNoLEAST8 = "SCNo8"
 const SCNoPTR = "lo"
 const SCNu16 = "hu"
 const SCNu32 = "u"
 const SCNuFAST16 = "SCNu16"
 const SCNuFAST32 = "SCNu32"
 const SCNuFAST64 = "SCNu64"
 const SCNuFAST8 = "SCNu8"
 const SCNuLEAST16 = "SCNu16"
 const SCNuLEAST32 = "SCNu32"
 const SCNuLEAST64 = "SCNu64"
 const SCNuLEAST8 = "SCNu8"
 const SCNuPTR = "lu"
 const SCNx16 = "hx"
 const SCNx32 = "x"
 const SCNxFAST16 = "SCNx16"
 const SCNxFAST32 = "SCNx32"
 const SCNxFAST64 = "SCNx64"
 const SCNxFAST8 = "SCNx8"
 const SCNxLEAST16 = "SCNx16"
 const SCNxLEAST32 = "SCNx32"
 const SCNxLEAST64 = "SCNx64"
 const SCNxLEAST8 = "SCNx8"
 const SCNxPTR = "lx"
 const SEGV_ACCERR = 2
 const SEGV_MAPERR = 1
 const SEGV_NOOP = 0
 const SIGABRT = 6
 const SIGALRM = 14
 const SIGBUS = 10
 const SIGCHLD = 20
 const SIGCONT = 19
 const SIGEMT = 7
 const SIGEV_NONE = 0
 const SIGEV_SIGNAL = 1
 const SIGEV_THREAD = 3
 const SIGFPE = 8
 const SIGHUP = 1
 const SIGILL = 4
 const SIGINFO = 29
 const SIGINT = 2
 const SIGIO = 23
 const SIGIOT = "SIGABRT"
 const SIGKILL = 9
 const SIGPIPE = 13
 const SIGPROF = 27
 const SIGQUIT = 3
 const SIGSEGV = 11
 const SIGSTKSZ = 131072
 const SIGSTOP = 17
 const SIGSYS = 12
 const SIGTERM = 15
 const SIGTRAP = 5
 const SIGTSTP = 18
 const SIGTTIN = 21
 const SIGTTOU = 22
 const SIGURG = 16
 const SIGUSR1 = 30
 const SIGUSR2 = 31
 const SIGVTALRM = 26
 const SIGWINCH = 28
 const SIGXCPU = 24
 const SIGXFSZ = 25
 const SIG_ATOMIC_MAX = "INT32_MAX"
 const SIG_ATOMIC_MIN = "INT32_MIN"
 const SIG_BLOCK = 1
 const SIG_SETMASK = 3
 const SIG_UNBLOCK = 2
 const SIZE_MAX = "UINTPTR_MAX"
 const SI_ASYNCIO = 0x10004
 const SI_MESGQ = 0x10005
 const SI_QUEUE = 0x10002
 const SI_TIMER = 0x10003
 const SI_USER = 0x10001
 const SS_DISABLE = 0x0004
 const SS_ONSTACK = 0x0001
 const SV_INTERRUPT = "SA_RESTART"
 const SV_NOCLDSTOP = "SA_NOCLDSTOP"
 const SV_NODEFER = "SA_NODEFER"
 const SV_ONSTACK = "SA_ONSTACK"
 const SV_RESETHAND = "SA_RESETHAND"
 const SV_SIGINFO = "SA_SIGINFO"
 const TAG_SIZE = 4
 const TRANSFORM_PRESENT = 1
 const TRAP_BRKPT = 1
 const TRAP_TRACE = 2
 const UINT16_MAX = 65535
 const UINT32_MAX = 4294967295
 const UINT64_MAX = "18446744073709551615U"
 const UINT8_MAX = 255
 const UINTPTR_MAX = 18446744073709551615
 const UINT_FAST16_MAX = "UINT16_MAX"
 const UINT_FAST32_MAX = "UINT32_MAX"
 const UINT_FAST64_MAX = "UINT64_MAX"
 const UINT_FAST8_MAX = "UINT8_MAX"
 const UINT_LEAST16_MAX = "UINT16_MAX"
 const UINT_LEAST32_MAX = "UINT32_MAX"
 const UINT_LEAST64_MAX = "UINT64_MAX"
 const UINT_LEAST8_MAX = "UINT8_MAX"
 const VP8L_FRAME_HEADER_SIZE = 5
 const VP8L_IMAGE_SIZE_BITS = 14
 const VP8L_LBITS = 64
 const VP8L_MAGIC_BYTE = 0x2f
 const VP8L_MAX_NUM_BIT_READ = 24
 const VP8L_SIGNATURE_SIZE = 1
 const VP8L_VERSION = 0
 const VP8L_VERSION_BITS = 3
 const VP8L_WBITS = 32
 const VP8X_CHUNK_SIZE = 10
 const VP8_DITHER_AMP_BITS = 7
 const VP8_DITHER_DESCALE = 4
 const VP8_FRAME_HEADER_SIZE = 10
 const VP8_RANDOM_DITHER_FIX = 8
 const VP8_RANDOM_TABLE_SIZE = 55
 const VP8_SIGNATURE = 0x9d012a
 const VP8_SSIM_KERNEL = 3
 const WAIT_MYPGRP = 0
 const WAKEMON_DISABLE = 0x02
 const WAKEMON_ENABLE = 0x01
 const WAKEMON_GET_PARAMS = 0x04
 const WAKEMON_MAKE_FATAL = 0x10
 const WAKEMON_SET_DEFAULTS = 0x08
 const WCHAR_MAX = "__WCHAR_MAX__"
 const WCONTINUED = 0x00000010
 const WCOREFLAG = 0200
 const WEBP_AARCH64 = 0
 const WEBP_ALIGN_CST = 31
 const WEBP_DECODER_ABI_VERSION = 528
 const WEBP_DSP_OMIT_C_CODE = 1
 const WEBP_INLINE = "inline"
 const WEBP_NEON_OMIT_C_CODE = 0
 const WEBP_NEON_WORK_AROUND_GCC = 0
 const WEBP_RESCALER_RFIX = 32
 const WEBP_RESTRICT = "__restrict__"
 const WEBP_SWAP_16BIT_CSP = 0
 const WEBP_TRANSFORM_AC3_C1 = 20091
 const WEBP_TRANSFORM_AC3_C2 = 35468
 const WEXITED = 0x00000004
 const WINT_MAX = "INT32_MAX"
 const WINT_MIN = "INT32_MIN"
 const WNOHANG = 0x00000001
 const WNOWAIT = 0x00000020
 const WSTOPPED = 0x00000008
 const WUNTRACED = 0x00000002
 const _DARWIN_FEATURE_64_BIT_INODE = 1
 const _DARWIN_FEATURE_ONLY_UNIX_CONFORMANCE = 1
 const _DARWIN_FEATURE_UNIX_CONFORMANCE = 3
 const _FORTIFY_SOURCE = 2
 const _I386_SIGNAL_H_ = 1
 const _LIBC_COUNT__MB_LEN_MAX = "_LIBC_UNSAFE_INDEXABLE"
 const _LIBC_COUNT__PATH_MAX = "_LIBC_UNSAFE_INDEXABLE"
 const _LP64 = 1
 const _QUAD_HIGHWORD = 1
 const _QUAD_LOWWORD = 0
 const _RLIMIT_POSIX_FLAG = 0x1000
 const _STRUCT_MCONTEXT = "_STRUCT_MCONTEXT64"
 const _WSTOPPED = 0177
 const _X86_INSTRUCTION_STATE_CACHELINE_SIZE = 64
 const __API_TO_BE_DEPRECATED = 100000
 const __API_TO_BE_DEPRECATED_DRIVERKIT = 100000
 const __API_TO_BE_DEPRECATED_IOS = 100000
 const __API_TO_BE_DEPRECATED_IOSAPPLICATIONEXTENSION = 100000
 const __API_TO_BE_DEPRECATED_KERNELKIT = 100000
 const __API_TO_BE_DEPRECATED_MACCATALYST = 100000
 const __API_TO_BE_DEPRECATED_MACCATALYSTAPPLICATIONEXTENSION = 100000
 const __API_TO_BE_DEPRECATED_MACOS = 100000
 const __API_TO_BE_DEPRECATED_MACOSAPPLICATIONEXTENSION = 100000
 const __API_TO_BE_DEPRECATED_TVOS = 100000
 const __API_TO_BE_DEPRECATED_TVOSAPPLICATIONEXTENSION = 100000
 const __API_TO_BE_DEPRECATED_VISIONOS = 100000
 const __API_TO_BE_DEPRECATED_VISIONOSAPPLICATIONEXTENSION = 100000
 const __API_TO_BE_DEPRECATED_WATCHOS = 100000
 const __API_TO_BE_DEPRECATED_WATCHOSAPPLICATIONEXTENSION = 100000
 const __ATOMIC_ACQUIRE = 2
 const __ATOMIC_ACQ_REL = 4
 const __ATOMIC_CONSUME = 1
 const __ATOMIC_HLE_ACQUIRE = 65536
 const __ATOMIC_HLE_RELEASE = 131072
 const __ATOMIC_RELAXED = 0
 const __ATOMIC_RELEASE = 3
 const __ATOMIC_SEQ_CST = 5
 const __AVAILABILITY_FILE = "AvailabilityVersions.h"
 const __AVAILABILITY_VERSIONS_VERSION_HASH = 93585900
 const __AVAILABILITY_VERSIONS_VERSION_STRING = "Local"
 const __BFLT16_DECIMAL_DIG__ = 4
 const __BFLT16_DENORM_MIN__ = "9.18354961579912115600575419704879436e-41B"
 const __BFLT16_DIG__ = 2
 const __BFLT16_EPSILON__ = "7.81250000000000000000000000000000000e-3B"
 const __BFLT16_HAS_DENORM__ = 1
 const __BFLT16_HAS_INFINITY__ = 1
 const __BFLT16_HAS_QUIET_NAN__ = 1
 const __BFLT16_IS_IEC_60559__ = 0
 const __BFLT16_MANT_DIG__ = 8
 const __BFLT16_MAX_10_EXP__ = 38
 const __BFLT16_MAX_EXP__ = 128
 const __BFLT16_MAX__ = "3.38953138925153547590470800371487867e+38B"
 const __BFLT16_MIN__ = "1.17549435082228750796873653722224568e-38B"
 const __BFLT16_NORM_MAX__ = "3.38953138925153547590470800371487867e+38B"
 const __BIGGEST_ALIGNMENT__ = 16
 const __BITINT_MAXWIDTH__ = 65535
 const __BRIDGEOS_2_0 = 20000
 const __BRIDGEOS_3_0 = 30000
 const __BRIDGEOS_3_1 = 30100
 const __BRIDGEOS_3_4 = 30400
 const __BRIDGEOS_4_0 = 40000
 const __BRIDGEOS_4_1 = 40100
 const __BRIDGEOS_5_0 = 50000
 const __BRIDGEOS_5_1 = 50100
 const __BRIDGEOS_5_3 = 50300
 const __BRIDGEOS_6_0 = 60000
 const __BRIDGEOS_6_2 = 60200
 const __BRIDGEOS_6_4 = 60400
 const __BRIDGEOS_6_5 = 60500
 const __BRIDGEOS_6_6 = 60600
 const __BRIDGEOS_7_0 = 70000
 const __BRIDGEOS_7_1 = 70100
 const __BRIDGEOS_7_2 = 70200
 const __BRIDGEOS_7_3 = 70300
 const __BRIDGEOS_7_4 = 70400
 const __BRIDGEOS_7_6 = 70600
 const __BRIDGEOS_8_0 = 80000
 const __BRIDGEOS_8_1 = 80100
 const __BRIDGEOS_8_2 = 80200
 const __BRIDGEOS_8_3 = 80300
 const __BRIDGEOS_8_4 = 80400
 const __BRIDGEOS_8_5 = 80500
 const __BRIDGEOS_8_6 = 80600
 const __BRIDGEOS_9_0 = 90000
 const __BRIDGEOS_9_1 = 90100
 const __BRIDGEOS_9_2 = 90200
 const __BRIDGEOS_9_3 = 90300
 const __BRIDGEOS_9_4 = 90400
 const __BRIDGEOS_9_5 = 90500
 const __BYTE_ORDER__ = "__ORDER_LITTLE_ENDIAN__"
 const __CCGO__ = 1
 const __CHAR_BIT__ = 8
 const __DARWIN_64_BIT_INO_T = 1
 const __DARWIN_BIG_ENDIAN = 4321
 const __DARWIN_BYTE_ORDER = "__DARWIN_LITTLE_ENDIAN"
 const __DARWIN_C_ANSI = 010000
 const __DARWIN_C_FULL = 900000
 const __DARWIN_C_LEVEL = "__DARWIN_C_FULL"
 const __DARWIN_LITTLE_ENDIAN = 1234
 const __DARWIN_NON_CANCELABLE = 0
 const __DARWIN_NO_LONG_LONG = 0
 const __DARWIN_NSIG = 32
 const __DARWIN_ONLY_64_BIT_INO_T = 0
 const __DARWIN_ONLY_UNIX_CONFORMANCE = 1
 const __DARWIN_ONLY_VERS_1050 = 0
 const __DARWIN_PDP_ENDIAN = 3412
 const __DARWIN_SUF_1050 = "$1050"
 const __DARWIN_SUF_64_BIT_INO_T = "$INODE64"
 const __DARWIN_SUF_EXTSN = "$DARWIN_EXTSN"
 const __DARWIN_UNIX03 = 1
 const __DARWIN_VERS_1050 = 1
 const __DARWIN_WCHAR_MAX = "__WCHAR_MAX__"
 const __DBL_DECIMAL_DIG__ = 17
 const __DBL_DIG__ = 15
 const __DBL_HAS_DENORM__ = 1
 const __DBL_HAS_INFINITY__ = 1
 const __DBL_HAS_QUIET_NAN__ = 1
 const __DBL_IS_IEC_60559__ = 1
 const __DBL_MANT_DIG__ = 53
 const __DBL_MAX_10_EXP__ = 308
 const __DBL_MAX_EXP__ = 1024
 const __DEC128_EPSILON__ = 1e-33
 const __DEC128_MANT_DIG__ = 34
 const __DEC128_MAX_EXP__ = 6145
 const __DEC128_MAX__ = "9.999999999999999999999999999999999E6144"
 const __DEC128_MIN__ = 1e-6143
 const __DEC128_SUBNORMAL_MIN__ = 0.000000000000000000000000000000001e-6143
 const __DEC32_EPSILON__ = 1e-6
 const __DEC32_MANT_DIG__ = 7
 const __DEC32_MAX_EXP__ = 97
 const __DEC32_MAX__ = 9.999999e96
 const __DEC32_MIN__ = 1e-95
 const __DEC32_SUBNORMAL_MIN__ = 0.000001e-95
 const __DEC64X_EPSILON__ = "1E-33D64x"
 const __DEC64X_MANT_DIG__ = 34
 const __DEC64X_MAX_EXP__ = 6145
 const __DEC64X_MAX__ = "9.999999999999999999999999999999999E6144D64x"
 const __DEC64X_MIN__ = "1E-6143D64x"
 const __DEC64X_SUBNORMAL_MIN__ = "0.000000000000000000000000000000001E-6143D64x"
 const __DEC64_EPSILON__ = 1e-15
 const __DEC64_MANT_DIG__ = 16
 const __DEC64_MAX_EXP__ = 385
 const __DEC64_MAX__ = "9.999999999999999E384"
 const __DEC64_MIN__ = 1e-383
 const __DEC64_SUBNORMAL_MIN__ = 0.000000000000001e-383
 const __DECIMAL_BID_FORMAT__ = 1
 const __DECIMAL_DIG__ = 17
 const __DEC_EVAL_METHOD__ = 2
 const __DRIVERKIT_19_0 = 190000
 const __DRIVERKIT_20_0 = 200000
 const __DRIVERKIT_21_0 = 210000
 const __DRIVERKIT_22_0 = 220000
 const __DRIVERKIT_22_4 = 220400
 const __DRIVERKIT_22_5 = 220500
 const __DRIVERKIT_22_6 = 220600
 const __DRIVERKIT_23_0 = 230000
 const __DRIVERKIT_23_1 = 230100
 const __DRIVERKIT_23_2 = 230200
 const __DRIVERKIT_23_3 = 230300
 const __DRIVERKIT_23_4 = 230400
 const __DRIVERKIT_23_5 = 230500
 const __DRIVERKIT_23_6 = 230600
 const __DRIVERKIT_24_0 = 240000
 const __DRIVERKIT_24_1 = 240100
 const __DRIVERKIT_24_2 = 240200
 const __DRIVERKIT_24_3 = 240300
 const __DRIVERKIT_24_4 = 240400
 const __DRIVERKIT_24_5 = 240500
 const __ELF__ = 1
 const __FINITE_MATH_ONLY__ = 0
 const __FLOAT_WORD_ORDER__ = "__ORDER_LITTLE_ENDIAN__"
 const __FLT128_DECIMAL_DIG__ = 36
 const __FLT128_DENORM_MIN__ = 6.47517511943802511092443895822764655e-4966
 const __FLT128_DIG__ = 33
 const __FLT128_EPSILON__ = 1.92592994438723585305597794258492732e-34
 const __FLT128_HAS_DENORM__ = 1
 const __FLT128_HAS_INFINITY__ = 1
 const __FLT128_HAS_QUIET_NAN__ = 1
 const __FLT128_IS_IEC_60559__ = 1
 const __FLT128_MANT_DIG__ = 113
 const __FLT128_MAX_10_EXP__ = 4932
 const __FLT128_MAX_EXP__ = 16384
 const __FLT128_MAX__ = "1.18973149535723176508575932662800702e+4932"
 const __FLT128_MIN__ = 3.36210314311209350626267781732175260e-4932
 const __FLT128_NORM_MAX__ = "1.18973149535723176508575932662800702e+4932"
 const __FLT16_DECIMAL_DIG__ = 5
 const __FLT16_DENORM_MIN__ = 5.96046447753906250000000000000000000e-8
 const __FLT16_DIG__ = 3
 const __FLT16_EPSILON__ = 9.76562500000000000000000000000000000e-4
 const __FLT16_HAS_DENORM__ = 1
 const __FLT16_HAS_INFINITY__ = 1
 const __FLT16_HAS_QUIET_NAN__ = 1
 const __FLT16_IS_IEC_60559__ = 1
 const __FLT16_MANT_DIG__ = 11
 const __FLT16_MAX_10_EXP__ = 4
 const __FLT16_MAX_EXP__ = 16
 const __FLT16_MAX__ = 6.55040000000000000000000000000000000e+4
 const __FLT16_MIN__ = 6.10351562500000000000000000000000000e-5
 const __FLT16_NORM_MAX__ = 6.55040000000000000000000000000000000e+4
 const __FLT32X_DECIMAL_DIG__ = 17
 const __FLT32X_DENORM_MIN__ = 4.94065645841246544176568792868221372e-324
 const __FLT32X_DIG__ = 15
 const __FLT32X_EPSILON__ = 2.22044604925031308084726333618164062e-16
 const __FLT32X_HAS_DENORM__ = 1
 const __FLT32X_HAS_INFINITY__ = 1
 const __FLT32X_HAS_QUIET_NAN__ = 1
 const __FLT32X_IS_IEC_60559__ = 1
 const __FLT32X_MANT_DIG__ = 53
 const __FLT32X_MAX_10_EXP__ = 308
 const __FLT32X_MAX_EXP__ = 1024
 const __FLT32X_MAX__ = 1.79769313486231570814527423731704357e+308
 const __FLT32X_MIN__ = 2.22507385850720138309023271733240406e-308
 const __FLT32X_NORM_MAX__ = 1.79769313486231570814527423731704357e+308
 const __FLT32_DECIMAL_DIG__ = 9
 const __FLT32_DENORM_MIN__ = 1.40129846432481707092372958328991613e-45
 const __FLT32_DIG__ = 6
 const __FLT32_EPSILON__ = 1.19209289550781250000000000000000000e-7
 const __FLT32_HAS_DENORM__ = 1
 const __FLT32_HAS_INFINITY__ = 1
 const __FLT32_HAS_QUIET_NAN__ = 1
 const __FLT32_IS_IEC_60559__ = 1
 const __FLT32_MANT_DIG__ = 24
 const __FLT32_MAX_10_EXP__ = 38
 const __FLT32_MAX_EXP__ = 128
 const __FLT32_MAX__ = 3.40282346638528859811704183484516925e+38
 const __FLT32_MIN__ = 1.17549435082228750796873653722224568e-38
 const __FLT32_NORM_MAX__ = 3.40282346638528859811704183484516925e+38
 const __FLT64X_DECIMAL_DIG__ = 36
 const __FLT64X_DENORM_MIN__ = 6.47517511943802511092443895822764655e-4966
 const __FLT64X_DIG__ = 33
 const __FLT64X_EPSILON__ = 1.92592994438723585305597794258492732e-34
 const __FLT64X_HAS_DENORM__ = 1
 const __FLT64X_HAS_INFINITY__ = 1
 const __FLT64X_HAS_QUIET_NAN__ = 1
 const __FLT64X_IS_IEC_60559__ = 1
 const __FLT64X_MANT_DIG__ = 113
 const __FLT64X_MAX_10_EXP__ = 4932
 const __FLT64X_MAX_EXP__ = 16384
 const __FLT64X_MAX__ = "1.18973149535723176508575932662800702e+4932"
 const __FLT64X_MIN__ = 3.36210314311209350626267781732175260e-4932
 const __FLT64X_NORM_MAX__ = "1.18973149535723176508575932662800702e+4932"
 const __FLT64_DECIMAL_DIG__ = 17
 const __FLT64_DENORM_MIN__ = 4.94065645841246544176568792868221372e-324
 const __FLT64_DIG__ = 15
 const __FLT64_EPSILON__ = 2.22044604925031308084726333618164062e-16
 const __FLT64_HAS_DENORM__ = 1
 const __FLT64_HAS_INFINITY__ = 1
 const __FLT64_HAS_QUIET_NAN__ = 1
 const __FLT64_IS_IEC_60559__ = 1
 const __FLT64_MANT_DIG__ = 53
 const __FLT64_MAX_10_EXP__ = 308
 const __FLT64_MAX_EXP__ = 1024
 const __FLT64_MAX__ = 1.79769313486231570814527423731704357e+308
 const __FLT64_MIN__ = 2.22507385850720138309023271733240406e-308
 const __FLT64_NORM_MAX__ = 1.79769313486231570814527423731704357e+308
 const __FLT_DECIMAL_DIG__ = 9
 const __FLT_DENORM_MIN__ = 1.40129846432481707092372958328991613e-45
 const __FLT_DIG__ = 6
 const __FLT_EPSILON__ = 1.19209289550781250000000000000000000e-7
 const __FLT_EVAL_METHOD_TS_18661_3__ = 0
 const __FLT_EVAL_METHOD__ = 0
 const __FLT_HAS_DENORM__ = 1
 const __FLT_HAS_INFINITY__ = 1
 const __FLT_HAS_QUIET_NAN__ = 1
 const __FLT_IS_IEC_60559__ = 1
 const __FLT_MANT_DIG__ = 24
 const __FLT_MAX_10_EXP__ = 38
 const __FLT_MAX_EXP__ = 128
 const __FLT_MAX__ = 3.40282346638528859811704183484516925e+38
 const __FLT_MIN__ = 1.17549435082228750796873653722224568e-38
 const __FLT_NORM_MAX__ = 3.40282346638528859811704183484516925e+38
 const __FLT_RADIX__ = 2
 const __FUNCTION__ = "__func__"
 const __FXSR__ = 1
 const __GCC_ASM_FLAG_OUTPUTS__ = 1
 const __GCC_ATOMIC_BOOL_LOCK_FREE = 2
 const __GCC_ATOMIC_CHAR16_T_LOCK_FREE = 2
 const __GCC_ATOMIC_CHAR32_T_LOCK_FREE = 2
 const __GCC_ATOMIC_CHAR8_T_LOCK_FREE = 2
 const __GCC_ATOMIC_CHAR_LOCK_FREE = 2
 const __GCC_ATOMIC_INT_LOCK_FREE = 2
 const __GCC_ATOMIC_LLONG_LOCK_FREE = 2
 const __GCC_ATOMIC_LONG_LOCK_FREE = 2
 const __GCC_ATOMIC_POINTER_LOCK_FREE = 2
 const __GCC_ATOMIC_SHORT_LOCK_FREE = 2
 const __GCC_ATOMIC_TEST_AND_SET_TRUEVAL = 1
 const __GCC_ATOMIC_WCHAR_T_LOCK_FREE = 2
 const __GCC_CONSTRUCTIVE_SIZE = 64
 const __GCC_DESTRUCTIVE_SIZE = 64
 const __GCC_HAVE_DWARF2_CFI_ASM = 1
 const __GCC_HAVE_SYNC_COMPARE_AND_SWAP_1 = 1
 const __GCC_HAVE_SYNC_COMPARE_AND_SWAP_2 = 1
 const __GCC_HAVE_SYNC_COMPARE_AND_SWAP_4 = 1
 const __GCC_HAVE_SYNC_COMPARE_AND_SWAP_8 = 1
 const __GCC_IEC_559 = 2
 const __GCC_IEC_559_COMPLEX = 2
 const __GNUC_EXECUTION_CHARSET_NAME = "UTF-8"
 const __GNUC_MINOR__ = 2
 const __GNUC_PATCHLEVEL__ = 1
 const __GNUC_STDC_INLINE__ = 1
 const __GNUC_WIDE_EXECUTION_CHARSET_NAME = "UTF-32LE"
 const __GNUC__ = 16
 const __GXX_ABI_VERSION = 1021
 const __HAVE_SPECULATION_SAFE_VALUE = 1
 const __INT16_MAX__ = 0x7fff
 const __INT32_MAX__ = 0x7fffffff
 const __INT32_TYPE__ = "int"
 const __INT64_MAX__ = 0x7fffffffffffffff
 const __INT8_MAX__ = 0x7f
 const __INTMAX_MAX__ = 0x7fffffffffffffff
 const __INTMAX_WIDTH__ = 64
 const __INTPTR_MAX__ = 0x7fffffffffffffff
 const __INTPTR_WIDTH__ = 64
 const __INT_FAST16_MAX__ = 0x7fffffffffffffff
 const __INT_FAST16_WIDTH__ = 64
 const __INT_FAST32_MAX__ = 0x7fffffffffffffff
 const __INT_FAST32_WIDTH__ = 64
 const __INT_FAST64_MAX__ = 0x7fffffffffffffff
 const __INT_FAST64_WIDTH__ = 64
 const __INT_FAST8_MAX__ = 0x7f
 const __INT_FAST8_WIDTH__ = 8
 const __INT_LEAST16_MAX__ = 0x7fff
 const __INT_LEAST16_WIDTH__ = 16
 const __INT_LEAST32_MAX__ = 0x7fffffff
 const __INT_LEAST32_TYPE__ = "int"
 const __INT_LEAST32_WIDTH__ = 32
 const __INT_LEAST64_MAX__ = 0x7fffffffffffffff
 const __INT_LEAST64_WIDTH__ = 64
 const __INT_LEAST8_MAX__ = 0x7f
 const __INT_LEAST8_WIDTH__ = 8
 const __INT_MAX__ = 0x7fffffff
 const __INT_WIDTH__ = 32
 const __IPHONE_10_0 = 100000
 const __IPHONE_10_1 = 100100
 const __IPHONE_10_2 = 100200
 const __IPHONE_10_3 = 100300
 const __IPHONE_11_0 = 110000
 const __IPHONE_11_1 = 110100
 const __IPHONE_11_2 = 110200
 const __IPHONE_11_3 = 110300
 const __IPHONE_11_4 = 110400
 const __IPHONE_12_0 = 120000
 const __IPHONE_12_1 = 120100
 const __IPHONE_12_2 = 120200
 const __IPHONE_12_3 = 120300
 const __IPHONE_12_4 = 120400
 const __IPHONE_13_0 = 130000
 const __IPHONE_13_1 = 130100
 const __IPHONE_13_2 = 130200
 const __IPHONE_13_3 = 130300
 const __IPHONE_13_4 = 130400
 const __IPHONE_13_5 = 130500
 const __IPHONE_13_6 = 130600
 const __IPHONE_13_7 = 130700
 const __IPHONE_14_0 = 140000
 const __IPHONE_14_1 = 140100
 const __IPHONE_14_2 = 140200
 const __IPHONE_14_3 = 140300
 const __IPHONE_14_4 = 140400
 const __IPHONE_14_5 = 140500
 const __IPHONE_14_6 = 140600
 const __IPHONE_14_7 = 140700
 const __IPHONE_14_8 = 140800
 const __IPHONE_15_0 = 150000
 const __IPHONE_15_1 = 150100
 const __IPHONE_15_2 = 150200
 const __IPHONE_15_3 = 150300
 const __IPHONE_15_4 = 150400
 const __IPHONE_15_5 = 150500
 const __IPHONE_15_6 = 150600
 const __IPHONE_15_7 = 150700
 const __IPHONE_15_8 = 150800
 const __IPHONE_16_0 = 160000
 const __IPHONE_16_1 = 160100
 const __IPHONE_16_2 = 160200
 const __IPHONE_16_3 = 160300
 const __IPHONE_16_4 = 160400
 const __IPHONE_16_5 = 160500
 const __IPHONE_16_6 = 160600
 const __IPHONE_16_7 = 160700
 const __IPHONE_17_0 = 170000
 const __IPHONE_17_1 = 170100
 const __IPHONE_17_2 = 170200
 const __IPHONE_17_3 = 170300
 const __IPHONE_17_4 = 170400
 const __IPHONE_17_5 = 170500
 const __IPHONE_17_6 = 170600
 const __IPHONE_17_7 = 170700
 const __IPHONE_18_0 = 180000
 const __IPHONE_18_1 = 180100
 const __IPHONE_18_2 = 180200
 const __IPHONE_18_3 = 180300
 const __IPHONE_18_4 = 180400
 const __IPHONE_18_5 = 180500
 const __IPHONE_2_0 = 20000
 const __IPHONE_2_1 = 20100
 const __IPHONE_2_2 = 20200
 const __IPHONE_3_0 = 30000
 const __IPHONE_3_1 = 30100
 const __IPHONE_3_2 = 30200
 const __IPHONE_4_0 = 40000
 const __IPHONE_4_1 = 40100
 const __IPHONE_4_2 = 40200
 const __IPHONE_4_3 = 40300
 const __IPHONE_5_0 = 50000
 const __IPHONE_5_1 = 50100
 const __IPHONE_6_0 = 60000
 const __IPHONE_6_1 = 60100
 const __IPHONE_7_0 = 70000
 const __IPHONE_7_1 = 70100
 const __IPHONE_8_0 = 80000
 const __IPHONE_8_1 = 80100
 const __IPHONE_8_2 = 80200
 const __IPHONE_8_3 = 80300
 const __IPHONE_8_4 = 80400
 const __IPHONE_9_0 = 90000
 const __IPHONE_9_1 = 90100
 const __IPHONE_9_2 = 90200
 const __IPHONE_9_3 = 90300
 const __LASTBRANCH_MAX = 32
 const __LDBL_DECIMAL_DIG__ = 17
 const __LDBL_DENORM_MIN__ = 4.94065645841246544176568792868221372e-324
 const __LDBL_DIG__ = 15
 const __LDBL_EPSILON__ = 2.22044604925031308084726333618164062e-16
 const __LDBL_HAS_DENORM__ = 1
 const __LDBL_HAS_INFINITY__ = 1
 const __LDBL_HAS_QUIET_NAN__ = 1
 const __LDBL_IS_IEC_60559__ = 1
 const __LDBL_MANT_DIG__ = 53
 const __LDBL_MAX_10_EXP__ = 308
 const __LDBL_MAX_EXP__ = 1024
 const __LDBL_MAX__ = 1.79769313486231570814527423731704357e+308
 const __LDBL_MIN__ = 2.22507385850720138309023271733240406e-308
 const __LDBL_NORM_MAX__ = 1.79769313486231570814527423731704357e+308
 const __LONG_DOUBLE_64__ = 1
 const __LONG_LONG_MAX__ = 0x7fffffffffffffff
 const __LONG_LONG_WIDTH__ = 64
 const __LONG_MAX__ = 0x7fffffffffffffff
 const __LONG_WIDTH__ = 64
 const __LP64__ = 1
 const __MAC_10_0 = 1000
 const __MAC_10_1 = 1010
 const __MAC_10_10 = 101000
 const __MAC_10_10_2 = 101002
 const __MAC_10_10_3 = 101003
 const __MAC_10_11 = 101100
 const __MAC_10_11_2 = 101102
 const __MAC_10_11_3 = 101103
 const __MAC_10_11_4 = 101104
 const __MAC_10_12 = 101200
 const __MAC_10_12_1 = 101201
 const __MAC_10_12_2 = 101202
 const __MAC_10_12_4 = 101204
 const __MAC_10_13 = 101300
 const __MAC_10_13_1 = 101301
 const __MAC_10_13_2 = 101302
 const __MAC_10_13_4 = 101304
 const __MAC_10_14 = 101400
 const __MAC_10_14_1 = 101401
 const __MAC_10_14_4 = 101404
 const __MAC_10_14_5 = 101405
 const __MAC_10_14_6 = 101406
 const __MAC_10_15 = 101500
 const __MAC_10_15_1 = 101501
 const __MAC_10_15_4 = 101504
 const __MAC_10_16 = 101600
 const __MAC_10_2 = 1020
 const __MAC_10_3 = 1030
 const __MAC_10_4 = 1040
 const __MAC_10_5 = 1050
 const __MAC_10_6 = 1060
 const __MAC_10_7 = 1070
 const __MAC_10_8 = 1080
 const __MAC_10_9 = 1090
 const __MAC_11_0 = 110000
 const __MAC_11_1 = 110100
 const __MAC_11_3 = 110300
 const __MAC_11_4 = 110400
 const __MAC_11_5 = 110500
 const __MAC_11_6 = 110600
 const __MAC_12_0 = 120000
 const __MAC_12_1 = 120100
 const __MAC_12_2 = 120200
 const __MAC_12_3 = 120300
 const __MAC_12_4 = 120400
 const __MAC_12_5 = 120500
 const __MAC_12_6 = 120600
 const __MAC_12_7 = 120700
 const __MAC_13_0 = 130000
 const __MAC_13_1 = 130100
 const __MAC_13_2 = 130200
 const __MAC_13_3 = 130300
 const __MAC_13_4 = 130400
 const __MAC_13_5 = 130500
 const __MAC_13_6 = 130600
 const __MAC_13_7 = 130700
 const __MAC_14_0 = 140000
 const __MAC_14_1 = 140100
 const __MAC_14_2 = 140200
 const __MAC_14_3 = 140300
 const __MAC_14_4 = 140400
 const __MAC_14_5 = 140500
 const __MAC_14_6 = 140600
 const __MAC_14_7 = 140700
 const __MAC_15_0 = 150000
 const __MAC_15_1 = 150100
 const __MAC_15_2 = 150200
 const __MAC_15_3 = 150300
 const __MAC_15_4 = 150400
 const __MAC_15_5 = 150500
 const __MMX_WITH_SSE__ = 1
 const __MMX__ = 1
 const __NO_INLINE__ = 1
 const __ORDER_BIG_ENDIAN__ = 4321
 const __ORDER_LITTLE_ENDIAN__ = 1234
 const __ORDER_PDP_ENDIAN__ = 3412
 const __PIC__ = 2
 const __PIE__ = 2
 const __PRAGMA_REDEFINE_EXTNAME = 1
 const __PRETTY_FUNCTION__ = "__func__"
 const __PRI_64_LENGTH_MODIFIER__ = "ll"
 const __PRI_8_LENGTH_MODIFIER__ = "hh"
 const __PRI_MAX_LENGTH_MODIFIER__ = "j"
 const __PTHREAD_ATTR_SIZE__ = 56
 const __PTHREAD_CONDATTR_SIZE__ = 8
 const __PTHREAD_COND_SIZE__ = 40
 const __PTHREAD_MUTEXATTR_SIZE__ = 8
 const __PTHREAD_MUTEX_SIZE__ = 56
 const __PTHREAD_ONCE_SIZE__ = 8
 const __PTHREAD_RWLOCKATTR_SIZE__ = 16
 const __PTHREAD_RWLOCK_SIZE__ = 192
 const __PTHREAD_SIZE__ = 8176
 const __PTRDIFF_MAX__ = 0x7fffffffffffffff
 const __PTRDIFF_WIDTH__ = 64
 const __SCHAR_MAX__ = 0x7f
 const __SCHAR_WIDTH__ = 8
 const __SCN_64_LENGTH_MODIFIER__ = "ll"
 const __SCN_MAX_LENGTH_MODIFIER__ = "j"
 const __SEG_FS = 1
 const __SEG_GS = 1
 const __SHRT_MAX__ = 0x7fff
 const __SHRT_WIDTH__ = 16
 const __SIG_ATOMIC_MAX__ = 0x7fffffff
 const __SIG_ATOMIC_TYPE__ = "int"
 const __SIG_ATOMIC_WIDTH__ = 32
 const __SIZEOF_DOUBLE__ = 8
 const __SIZEOF_FLOAT128__ = 16
 const __SIZEOF_FLOAT80__ = 16
 const __SIZEOF_FLOAT__ = 4
 const __SIZEOF_INT128__ = 16
 const __SIZEOF_INT__ = 4
 const __SIZEOF_LONG_DOUBLE__ = 8
 const __SIZEOF_LONG_LONG__ = 8
 const __SIZEOF_LONG__ = 8
 const __SIZEOF_POINTER__ = 8
 const __SIZEOF_PTRDIFF_T__ = 8
 const __SIZEOF_SHORT__ = 2
 const __SIZEOF_SIZE_T__ = 8
 const __SIZEOF_WCHAR_T__ = 4
 const __SIZEOF_WINT_T__ = 4
 const __SIZE_MAX__ = 0xffffffffffffffff
 const __SIZE_WIDTH__ = 64
 const __SSE2_MATH__ = 1
 const __SSE2__ = 1
 const __SSE_MATH__ = 1
 const __SSE__ = 1
 const __SSP_STRONG__ = 3
 const __STDC_EMBED_EMPTY__ = 2
 const __STDC_EMBED_FOUND__ = 1
 const __STDC_EMBED_NOT_FOUND__ = 0
 const __STDC_HOSTED__ = 1
 const __STDC_UTF_16__ = 1
 const __STDC_UTF_32__ = 1
 const __STDC_VERSION__ = 202311
 const __STDC_WANT_LIB_EXT1__ = 1
 const __STDC__ = 1
 const __TVOS_10_0 = 100000
 const __TVOS_10_0_1 = 100001
 const __TVOS_10_1 = 100100
 const __TVOS_10_2 = 100200
 const __TVOS_11_0 = 110000
 const __TVOS_11_1 = 110100
 const __TVOS_11_2 = 110200
 const __TVOS_11_3 = 110300
 const __TVOS_11_4 = 110400
 const __TVOS_12_0 = 120000
 const __TVOS_12_1 = 120100
 const __TVOS_12_2 = 120200
 const __TVOS_12_3 = 120300
 const __TVOS_12_4 = 120400
 const __TVOS_13_0 = 130000
 const __TVOS_13_2 = 130200
 const __TVOS_13_3 = 130300
 const __TVOS_13_4 = 130400
 const __TVOS_14_0 = 140000
 const __TVOS_14_1 = 140100
 const __TVOS_14_2 = 140200
 const __TVOS_14_3 = 140300
 const __TVOS_14_5 = 140500
 const __TVOS_14_6 = 140600
 const __TVOS_14_7 = 140700
 const __TVOS_15_0 = 150000
 const __TVOS_15_1 = 150100
 const __TVOS_15_2 = 150200
 const __TVOS_15_3 = 150300
 const __TVOS_15_4 = 150400
 const __TVOS_15_5 = 150500
 const __TVOS_15_6 = 150600
 const __TVOS_16_0 = 160000
 const __TVOS_16_1 = 160100
 const __TVOS_16_2 = 160200
 const __TVOS_16_3 = 160300
 const __TVOS_16_4 = 160400
 const __TVOS_16_5 = 160500
 const __TVOS_16_6 = 160600
 const __TVOS_17_0 = 170000
 const __TVOS_17_1 = 170100
 const __TVOS_17_2 = 170200
 const __TVOS_17_3 = 170300
 const __TVOS_17_4 = 170400
 const __TVOS_17_5 = 170500
 const __TVOS_17_6 = 170600
 const __TVOS_18_0 = 180000
 const __TVOS_18_1 = 180100
 const __TVOS_18_2 = 180200
 const __TVOS_18_3 = 180300
 const __TVOS_18_4 = 180400
 const __TVOS_18_5 = 180500
 const __TVOS_9_0 = 90000
 const __TVOS_9_1 = 90100
 const __TVOS_9_2 = 90200
 const __UINT16_MAX__ = 0xffff
 const __UINT32_MAX__ = 0xffffffff
 const __UINT64_MAX__ = 0xffffffffffffffff
 const __UINT8_MAX__ = 0xff
 const __UINTMAX_MAX__ = 0xffffffffffffffff
 const __UINTPTR_MAX__ = 0xffffffffffffffff
 const __UINT_FAST16_MAX__ = 0xffffffffffffffff
 const __UINT_FAST32_MAX__ = 0xffffffffffffffff
 const __UINT_FAST64_MAX__ = 0xffffffffffffffff
 const __UINT_FAST8_MAX__ = 0xff
 const __UINT_LEAST16_MAX__ = 0xffff
 const __UINT_LEAST32_MAX__ = 0xffffffff
 const __UINT_LEAST64_MAX__ = 0xffffffffffffffff
 const __UINT_LEAST8_MAX__ = 0xff
 const __VERSION__ = "16.2.1 20260810"
 const __VISIONOS_1_0 = 10000
 const __VISIONOS_1_1 = 10100
 const __VISIONOS_1_2 = 10200
 const __VISIONOS_1_3 = 10300
 const __VISIONOS_2_0 = 20000
 const __VISIONOS_2_1 = 20100
 const __VISIONOS_2_2 = 20200
 const __VISIONOS_2_3 = 20300
 const __VISIONOS_2_4 = 20400
 const __VISIONOS_2_5 = 20500
 const __WATCHOS_10_0 = 100000
 const __WATCHOS_10_1 = 100100
 const __WATCHOS_10_2 = 100200
 const __WATCHOS_10_3 = 100300
 const __WATCHOS_10_4 = 100400
 const __WATCHOS_10_5 = 100500
 const __WATCHOS_10_6 = 100600
 const __WATCHOS_10_7 = 100700
 const __WATCHOS_11_0 = 110000
 const __WATCHOS_11_1 = 110100
 const __WATCHOS_11_2 = 110200
 const __WATCHOS_11_3 = 110300
 const __WATCHOS_11_4 = 110400
 const __WATCHOS_11_5 = 110500
 const __WATCHOS_1_0 = 10000
 const __WATCHOS_2_0 = 20000
 const __WATCHOS_2_1 = 20100
 const __WATCHOS_2_2 = 20200
 const __WATCHOS_3_0 = 30000
 const __WATCHOS_3_1 = 30100
 const __WATCHOS_3_1_1 = 30101
 const __WATCHOS_3_2 = 30200
 const __WATCHOS_4_0 = 40000
 const __WATCHOS_4_1 = 40100
 const __WATCHOS_4_2 = 40200
 const __WATCHOS_4_3 = 40300
 const __WATCHOS_5_0 = 50000
 const __WATCHOS_5_1 = 50100
 const __WATCHOS_5_2 = 50200
 const __WATCHOS_5_3 = 50300
 const __WATCHOS_6_0 = 60000
 const __WATCHOS_6_1 = 60100
 const __WATCHOS_6_2 = 60200
 const __WATCHOS_7_0 = 70000
 const __WATCHOS_7_1 = 70100
 const __WATCHOS_7_2 = 70200
 const __WATCHOS_7_3 = 70300
 const __WATCHOS_7_4 = 70400
 const __WATCHOS_7_5 = 70500
 const __WATCHOS_7_6 = 70600
 const __WATCHOS_8_0 = 80000
 const __WATCHOS_8_1 = 80100
 const __WATCHOS_8_3 = 80300
 const __WATCHOS_8_4 = 80400
 const __WATCHOS_8_5 = 80500
 const __WATCHOS_8_6 = 80600
 const __WATCHOS_8_7 = 80700
 const __WATCHOS_8_8 = 80800
 const __WATCHOS_9_0 = 90000
 const __WATCHOS_9_1 = 90100
 const __WATCHOS_9_2 = 90200
 const __WATCHOS_9_3 = 90300
 const __WATCHOS_9_4 = 90400
 const __WATCHOS_9_5 = 90500
 const __WATCHOS_9_6 = 90600
 const __WCHAR_MAX__ = 0x7fffffff
 const __WCHAR_TYPE__ = "int"
 const __WCHAR_WIDTH__ = 32
 const __WINT_MAX__ = 0xffffffff
 const __WINT_MIN__ = 0
 const __WINT_WIDTH__ = 32
 const __WORDSIZE = 64
 const __amd64 = 1
 const __amd64__ = 1
 const __code_model_small__ = 1
 const __const = "const"
 const __gnu_linux__ = 1
 const __has_ptrcheck = 0
 const __has_safe_buffers = 0
 const __k8 = 1
 const __k8__ = 1
 const __linux = 1
 const __linux__ = 1
 const __pic__ = 2
 const __pie__ = 2
 const __restrict = "restrict"
 const __restrict_arr = "restrict"
 const __signed = "signed"
 const __unix = 1
 const __unix__ = 1
 const __volatile = "volatile"
 const __x86_64 = 1
 const __x86_64__ = 1
 const false1 = 0
 const linux = 1
 const ru_first = "ru_ixrss"
 const ru_last = "ru_nivcsw"
 const static_assert = "_Static_assert"
 const sv_onstack = "sv_flags"
 const true1 = 1
 const unix = 1
 
 /* C23 keywords, no longer defined as macros by <stdbool.h> and <stddef.h>. */
 
 type __builtin_va_list = uintptr
 
 type __predefined_size_t = uint64
 
 type __predefined_wchar_t = int32
 
 type __predefined_ptrdiff_t = int64
 
 type __int8_t = int8
 
 type __uint8_t = uint8
 
 type __int16_t = int16
 
 type __uint16_t = uint16
 
 type __int32_t = int32
 
 type __uint32_t = uint32
 
 type __int64_t = int64
 
 type __uint64_t = uint64
 
 type __darwin_intptr_t = int64
 
 type __darwin_natural_t = uint32
 
 type __darwin_ct_rune_t = int32
 
 type __mbstate_t = struct {
 	F_mbstateL  [0]int64
 	F__mbstate8 [128]int8
 }
 
 type __darwin_mbstate_t = struct {
 	F_mbstateL  [0]int64
 	F__mbstate8 [128]int8
 }
 
 type __darwin_ptrdiff_t = int64
 
 type __darwin_size_t = uint64
 
 type __darwin_va_list = uintptr
 
 type __darwin_wchar_t = int32
 
 type __darwin_rune_t = int32
 
 type __darwin_wint_t = uint32
 
 type __darwin_clock_t = uint64
 
 type __darwin_socklen_t = uint32
 
 type __darwin_ssize_t = int64
 
 type __darwin_time_t = int64
 
 type __darwin_blkcnt_t = int64
 
 type __darwin_blksize_t = int32
 
 type __darwin_dev_t = int32
 
 type __darwin_fsblkcnt_t = uint32
 
 type __darwin_fsfilcnt_t = uint32
 
 type __darwin_gid_t = uint32
 
 type __darwin_id_t = uint32
 
 type __darwin_ino64_t = uint64
 
 type __darwin_ino_t = uint64
 
 type __darwin_mach_port_name_t = uint32
 
 type __darwin_mach_port_t = uint32
 
 type __darwin_mode_t = uint16
 
 type __darwin_off_t = int64
 
 type __darwin_pid_t = int32
 
 type __darwin_sigset_t = uint32
 
 type __darwin_suseconds_t = int32
 
 type __darwin_uid_t = uint32
 
 type __darwin_useconds_t = uint32
 
 type __darwin_uuid_t = [16]uint8
 
 type __darwin_uuid_string_t = [37]int8
 
 type __darwin_pthread_handler_rec = struct {
 	F__routine uintptr
 	F__arg     uintptr
 	F__next    uintptr
 }
 
 type _opaque_pthread_attr_t = struct {
 	F__sig    int64
 	F__opaque [56]int8
 }
 
 type _opaque_pthread_cond_t = struct {
 	F__sig    int64
 	F__opaque [40]int8
 }
 
 type _opaque_pthread_condattr_t = struct {
 	F__sig    int64
 	F__opaque [8]int8
 }
 
 type _opaque_pthread_mutex_t = struct {
 	F__sig    int64
 	F__opaque [56]int8
 }
 
 type _opaque_pthread_mutexattr_t = struct {
 	F__sig    int64
 	F__opaque [8]int8
 }
 
 type _opaque_pthread_once_t = struct {
 	F__sig    int64
 	F__opaque [8]int8
 }
 
 type _opaque_pthread_rwlock_t = struct {
 	F__sig    int64
 	F__opaque [192]int8
 }
 
 type _opaque_pthread_rwlockattr_t = struct {
 	F__sig    int64
 	F__opaque [16]int8
 }
 
 type _opaque_pthread_t = struct {
 	F__sig           int64
 	F__cleanup_stack uintptr
 	F__opaque        [8176]int8
 }
 
 type __darwin_pthread_attr_t = struct {
 	F__sig    int64
 	F__opaque [56]int8
 }
 
 type __darwin_pthread_cond_t = struct {
 	F__sig    int64
 	F__opaque [40]int8
 }
 
 type __darwin_pthread_condattr_t = struct {
 	F__sig    int64
 	F__opaque [8]int8
 }
 
 type __darwin_pthread_key_t = uint64
 
 type __darwin_pthread_mutex_t = struct {
 	F__sig    int64
 	F__opaque [56]int8
 }
 
 type __darwin_pthread_mutexattr_t = struct {
 	F__sig    int64
 	F__opaque [8]int8
 }
 
 type __darwin_pthread_once_t = struct {
 	F__sig    int64
 	F__opaque [8]int8
 }
 
 type __darwin_pthread_rwlock_t = struct {
 	F__sig    int64
 	F__opaque [192]int8
 }
 
 type __darwin_pthread_rwlockattr_t = struct {
 	F__sig    int64
 	F__opaque [16]int8
 }
 
 type __darwin_pthread_t = uintptr
 
 type __darwin_nl_item = int32
 
 type __darwin_wctrans_t = int32
 
 type __darwin_wctype_t = uint32
 
 type idtype_t = int32
 
 const P_ALL = 0
 const P_PID = 1
 const P_PGID = 2
 
 type pid_t = int32
 
 type id_t = uint32
 
 type sig_atomic_t = int32
 
 type int8_t = int8
 
 type int16_t = int16
 
 type int32_t = int32
 
 type int64_t = int64
 
 type u_int8_t = uint8
 
 type u_int16_t = uint16
 
 type u_int32_t = uint32
 
 type u_int64_t = uint64
 
 type register_t = int64
 
 type intptr_t = int64
 
 type uintptr_t = uint64
 
 type user_addr_t = uint64
 
 type user_size_t = uint64
 
 type user_ssize_t = int64
 
 type user_long_t = int64
 
 type user_ulong_t = uint64
 
 type user_time_t = int64
 
 type user_off_t = int64
 
 type syscall_arg_t = uint64
 
 type __darwin_i386_thread_state = struct {
 	F__eax    uint32
 	F__ebx    uint32
 	F__ecx    uint32
 	F__edx    uint32
 	F__edi    uint32
 	F__esi    uint32
 	F__ebp    uint32
 	F__esp    uint32
 	F__ss     uint32
 	F__eflags uint32
 	F__eip    uint32
 	F__cs     uint32
 	F__ds     uint32
 	F__es     uint32
 	F__fs     uint32
 	F__gs     uint32
 }
 
 type __darwin_fp_control = struct {
 	F__ccgo0 uint16
 }
 
 type __darwin_fp_control_t = struct {
 	F__ccgo0 uint16
 }
 
 type __darwin_fp_status = struct {
 	F__ccgo0 uint16
 }
 
 type __darwin_fp_status_t = struct {
 	F__ccgo0 uint16
 }
 
 type __darwin_mmst_reg = struct {
 	F__mmst_reg  [10]int8
 	F__mmst_rsrv [6]int8
 }
 
 type __darwin_xmm_reg = struct {
 	F__xmm_reg [16]int8
 }
 
 type __darwin_ymm_reg = struct {
 	F__ymm_reg [32]int8
 }
 
 type __darwin_zmm_reg = struct {
 	F__zmm_reg [64]int8
 }
 
 type __darwin_opmask_reg = struct {
 	F__opmask_reg [8]int8
 }
 
 type __darwin_i386_float_state = struct {
 	F__fpu_reserved  [2]int32
 	F__fpu_fcw       __darwin_fp_control
 	F__fpu_fsw       __darwin_fp_status
 	F__fpu_ftw       __uint8_t
 	F__fpu_rsrv1     __uint8_t
 	F__fpu_fop       __uint16_t
 	F__fpu_ip        __uint32_t
 	F__fpu_cs        __uint16_t
 	F__fpu_rsrv2     __uint16_t
 	F__fpu_dp        __uint32_t
 	F__fpu_ds        __uint16_t
 	F__fpu_rsrv3     __uint16_t
 	F__fpu_mxcsr     __uint32_t
 	F__fpu_mxcsrmask __uint32_t
 	F__fpu_stmm0     __darwin_mmst_reg
 	F__fpu_stmm1     __darwin_mmst_reg
 	F__fpu_stmm2     __darwin_mmst_reg
 	F__fpu_stmm3     __darwin_mmst_reg
 	F__fpu_stmm4     __darwin_mmst_reg
 	F__fpu_stmm5     __darwin_mmst_reg
 	F__fpu_stmm6     __darwin_mmst_reg
 	F__fpu_stmm7     __darwin_mmst_reg
 	F__fpu_xmm0      __darwin_xmm_reg
 	F__fpu_xmm1      __darwin_xmm_reg
 	F__fpu_xmm2      __darwin_xmm_reg
 	F__fpu_xmm3      __darwin_xmm_reg
 	F__fpu_xmm4      __darwin_xmm_reg
 	F__fpu_xmm5      __darwin_xmm_reg
 	F__fpu_xmm6      __darwin_xmm_reg
 	F__fpu_xmm7      __darwin_xmm_reg
 	F__fpu_rsrv4     [224]int8
 	F__fpu_reserved1 int32
 }
 
 type __darwin_i386_avx_state = struct {
 	F__fpu_reserved  [2]int32
 	F__fpu_fcw       __darwin_fp_control
 	F__fpu_fsw       __darwin_fp_status
 	F__fpu_ftw       __uint8_t
 	F__fpu_rsrv1     __uint8_t
 	F__fpu_fop       __uint16_t
 	F__fpu_ip        __uint32_t
 	F__fpu_cs        __uint16_t
 	F__fpu_rsrv2     __uint16_t
 	F__fpu_dp        __uint32_t
 	F__fpu_ds        __uint16_t
 	F__fpu_rsrv3     __uint16_t
 	F__fpu_mxcsr     __uint32_t
 	F__fpu_mxcsrmask __uint32_t
 	F__fpu_stmm0     __darwin_mmst_reg
 	F__fpu_stmm1     __darwin_mmst_reg
 	F__fpu_stmm2     __darwin_mmst_reg
 	F__fpu_stmm3     __darwin_mmst_reg
 	F__fpu_stmm4     __darwin_mmst_reg
 	F__fpu_stmm5     __darwin_mmst_reg
 	F__fpu_stmm6     __darwin_mmst_reg
 	F__fpu_stmm7     __darwin_mmst_reg
 	F__fpu_xmm0      __darwin_xmm_reg
 	F__fpu_xmm1      __darwin_xmm_reg
 	F__fpu_xmm2      __darwin_xmm_reg
 	F__fpu_xmm3      __darwin_xmm_reg
 	F__fpu_xmm4      __darwin_xmm_reg
 	F__fpu_xmm5      __darwin_xmm_reg
 	F__fpu_xmm6      __darwin_xmm_reg
 	F__fpu_xmm7      __darwin_xmm_reg
 	F__fpu_rsrv4     [224]int8
 	F__fpu_reserved1 int32
 	F__avx_reserved1 [64]int8
 	F__fpu_ymmh0     __darwin_xmm_reg
 	F__fpu_ymmh1     __darwin_xmm_reg
 	F__fpu_ymmh2     __darwin_xmm_reg
 	F__fpu_ymmh3     __darwin_xmm_reg
 	F__fpu_ymmh4     __darwin_xmm_reg
 	F__fpu_ymmh5     __darwin_xmm_reg
 	F__fpu_ymmh6     __darwin_xmm_reg
 	F__fpu_ymmh7     __darwin_xmm_reg
 }
 
 type __darwin_i386_avx512_state = struct {
 	F__fpu_reserved  [2]int32
 	F__fpu_fcw       __darwin_fp_control
 	F__fpu_fsw       __darwin_fp_status
 	F__fpu_ftw       __uint8_t
 	F__fpu_rsrv1     __uint8_t
 	F__fpu_fop       __uint16_t
 	F__fpu_ip        __uint32_t
 	F__fpu_cs        __uint16_t
 	F__fpu_rsrv2     __uint16_t
 	F__fpu_dp        __uint32_t
 	F__fpu_ds        __uint16_t
 	F__fpu_rsrv3     __uint16_t
 	F__fpu_mxcsr     __uint32_t
 	F__fpu_mxcsrmask __uint32_t
 	F__fpu_stmm0     __darwin_mmst_reg
 	F__fpu_stmm1     __darwin_mmst_reg
 	F__fpu_stmm2     __darwin_mmst_reg
 	F__fpu_stmm3     __darwin_mmst_reg
 	F__fpu_stmm4     __darwin_mmst_reg
 	F__fpu_stmm5     __darwin_mmst_reg
 	F__fpu_stmm6     __darwin_mmst_reg
 	F__fpu_stmm7     __darwin_mmst_reg
 	F__fpu_xmm0      __darwin_xmm_reg
 	F__fpu_xmm1      __darwin_xmm_reg
 	F__fpu_xmm2      __darwin_xmm_reg
 	F__fpu_xmm3      __darwin_xmm_reg
 	F__fpu_xmm4      __darwin_xmm_reg
 	F__fpu_xmm5      __darwin_xmm_reg
 	F__fpu_xmm6      __darwin_xmm_reg
 	F__fpu_xmm7      __darwin_xmm_reg
 	F__fpu_rsrv4     [224]int8
 	F__fpu_reserved1 int32
 	F__avx_reserved1 [64]int8
 	F__fpu_ymmh0     __darwin_xmm_reg
 	F__fpu_ymmh1     __darwin_xmm_reg
 	F__fpu_ymmh2     __darwin_xmm_reg
 	F__fpu_ymmh3     __darwin_xmm_reg
 	F__fpu_ymmh4     __darwin_xmm_reg
 	F__fpu_ymmh5     __darwin_xmm_reg
 	F__fpu_ymmh6     __darwin_xmm_reg
 	F__fpu_ymmh7     __darwin_xmm_reg
 	F__fpu_k0        __darwin_opmask_reg
 	F__fpu_k1        __darwin_opmask_reg
 	F__fpu_k2        __darwin_opmask_reg
 	F__fpu_k3        __darwin_opmask_reg
 	F__fpu_k4        __darwin_opmask_reg
 	F__fpu_k5        __darwin_opmask_reg
 	F__fpu_k6        __darwin_opmask_reg
 	F__fpu_k7        __darwin_opmask_reg
 	F__fpu_zmmh0     __darwin_ymm_reg
 	F__fpu_zmmh1     __darwin_ymm_reg
 	F__fpu_zmmh2     __darwin_ymm_reg
 	F__fpu_zmmh3     __darwin_ymm_reg
 	F__fpu_zmmh4     __darwin_ymm_reg
 	F__fpu_zmmh5     __darwin_ymm_reg
 	F__fpu_zmmh6     __darwin_ymm_reg
 	F__fpu_zmmh7     __darwin_ymm_reg
 }
 
 type __darwin_i386_exception_state = struct {
 	F__trapno     __uint16_t
 	F__cpu        __uint16_t
 	F__err        __uint32_t
 	F__faultvaddr __uint32_t
 }
 
 type __darwin_x86_debug_state32 = struct {
 	F__dr0 uint32
 	F__dr1 uint32
 	F__dr2 uint32
 	F__dr3 uint32
 	F__dr4 uint32
 	F__dr5 uint32
 	F__dr6 uint32
 	F__dr7 uint32
 }
 
 type __x86_instruction_state = struct {
 	F__insn_stream_valid_bytes int32
 	F__insn_offset             int32
 	F__out_of_synch            int32
 	F__insn_bytes              [2380]__uint8_t
 	F__insn_cacheline          [64]__uint8_t
 }
 
 type __last_branch_record = struct {
 	F__from_ip __uint64_t
 	F__to_ip   __uint64_t
 	F__ccgo16  uint32
 }
 
 type __last_branch_state = struct {
 	F__lbr_count int32
 	F__ccgo4     uint32
 	F__lbrs      [32]__last_branch_record
 }
 
 type __x86_pagein_state = struct {
 	F__pagein_error int32
 }
 
 type __darwin_x86_thread_state64 = struct {
 	F__rax    __uint64_t
 	F__rbx    __uint64_t
 	F__rcx    __uint64_t
 	F__rdx    __uint64_t
 	F__rdi    __uint64_t
 	F__rsi    __uint64_t
 	F__rbp    __uint64_t
 	F__rsp    __uint64_t
 	F__r8     __uint64_t
 	F__r9     __uint64_t
 	F__r10    __uint64_t
 	F__r11    __uint64_t
 	F__r12    __uint64_t
 	F__r13    __uint64_t
 	F__r14    __uint64_t
 	F__r15    __uint64_t
 	F__rip    __uint64_t
 	F__rflags __uint64_t
 	F__cs     __uint64_t
 	F__fs     __uint64_t
 	F__gs     __uint64_t
 }
 
 type __darwin_x86_thread_full_state64 = struct {
 	F__ss64   __darwin_x86_thread_state64
 	F__ds     __uint64_t
 	F__es     __uint64_t
 	F__ss     __uint64_t
 	F__gsbase __uint64_t
 }
 
 type __darwin_x86_float_state64 = struct {
 	F__fpu_reserved  [2]int32
 	F__fpu_fcw       __darwin_fp_control
 	F__fpu_fsw       __darwin_fp_status
 	F__fpu_ftw       __uint8_t
 	F__fpu_rsrv1     __uint8_t
 	F__fpu_fop       __uint16_t
 	F__fpu_ip        __uint32_t
 	F__fpu_cs        __uint16_t
 	F__fpu_rsrv2     __uint16_t
 	F__fpu_dp        __uint32_t
 	F__fpu_ds        __uint16_t
 	F__fpu_rsrv3     __uint16_t
 	F__fpu_mxcsr     __uint32_t
 	F__fpu_mxcsrmask __uint32_t
 	F__fpu_stmm0     __darwin_mmst_reg
 	F__fpu_stmm1     __darwin_mmst_reg
 	F__fpu_stmm2     __darwin_mmst_reg
 	F__fpu_stmm3     __darwin_mmst_reg
 	F__fpu_stmm4     __darwin_mmst_reg
 	F__fpu_stmm5     __darwin_mmst_reg
 	F__fpu_stmm6     __darwin_mmst_reg
 	F__fpu_stmm7     __darwin_mmst_reg
 	F__fpu_xmm0      __darwin_xmm_reg
 	F__fpu_xmm1      __darwin_xmm_reg
 	F__fpu_xmm2      __darwin_xmm_reg
 	F__fpu_xmm3      __darwin_xmm_reg
 	F__fpu_xmm4      __darwin_xmm_reg
 	F__fpu_xmm5      __darwin_xmm_reg
 	F__fpu_xmm6      __darwin_xmm_reg
 	F__fpu_xmm7      __darwin_xmm_reg
 	F__fpu_xmm8      __darwin_xmm_reg
 	F__fpu_xmm9      __darwin_xmm_reg
 	F__fpu_xmm10     __darwin_xmm_reg
 	F__fpu_xmm11     __darwin_xmm_reg
 	F__fpu_xmm12     __darwin_xmm_reg
 	F__fpu_xmm13     __darwin_xmm_reg
 	F__fpu_xmm14     __darwin_xmm_reg
 	F__fpu_xmm15     __darwin_xmm_reg
 	F__fpu_rsrv4     [96]int8
 	F__fpu_reserved1 int32
 }
 
 type __darwin_x86_avx_state64 = struct {
 	F__fpu_reserved  [2]int32
 	F__fpu_fcw       __darwin_fp_control
 	F__fpu_fsw       __darwin_fp_status
 	F__fpu_ftw       __uint8_t
 	F__fpu_rsrv1     __uint8_t
 	F__fpu_fop       __uint16_t
 	F__fpu_ip        __uint32_t
 	F__fpu_cs        __uint16_t
 	F__fpu_rsrv2     __uint16_t
 	F__fpu_dp        __uint32_t
 	F__fpu_ds        __uint16_t
 	F__fpu_rsrv3     __uint16_t
 	F__fpu_mxcsr     __uint32_t
 	F__fpu_mxcsrmask __uint32_t
 	F__fpu_stmm0     __darwin_mmst_reg
 	F__fpu_stmm1     __darwin_mmst_reg
 	F__fpu_stmm2     __darwin_mmst_reg
 	F__fpu_stmm3     __darwin_mmst_reg
 	F__fpu_stmm4     __darwin_mmst_reg
 	F__fpu_stmm5     __darwin_mmst_reg
 	F__fpu_stmm6     __darwin_mmst_reg
 	F__fpu_stmm7     __darwin_mmst_reg
 	F__fpu_xmm0      __darwin_xmm_reg
 	F__fpu_xmm1      __darwin_xmm_reg
 	F__fpu_xmm2      __darwin_xmm_reg
 	F__fpu_xmm3      __darwin_xmm_reg
 	F__fpu_xmm4      __darwin_xmm_reg
 	F__fpu_xmm5      __darwin_xmm_reg
 	F__fpu_xmm6      __darwin_xmm_reg
 	F__fpu_xmm7      __darwin_xmm_reg
 	F__fpu_xmm8      __darwin_xmm_reg
 	F__fpu_xmm9      __darwin_xmm_reg
 	F__fpu_xmm10     __darwin_xmm_reg
 	F__fpu_xmm11     __darwin_xmm_reg
 	F__fpu_xmm12     __darwin_xmm_reg
 	F__fpu_xmm13     __darwin_xmm_reg
 	F__fpu_xmm14     __darwin_xmm_reg
 	F__fpu_xmm15     __darwin_xmm_reg
 	F__fpu_rsrv4     [96]int8
 	F__fpu_reserved1 int32
 	F__avx_reserved1 [64]int8
 	F__fpu_ymmh0     __darwin_xmm_reg
 	F__fpu_ymmh1     __darwin_xmm_reg
 	F__fpu_ymmh2     __darwin_xmm_reg
 	F__fpu_ymmh3     __darwin_xmm_reg
 	F__fpu_ymmh4     __darwin_xmm_reg
 	F__fpu_ymmh5     __darwin_xmm_reg
 	F__fpu_ymmh6     __darwin_xmm_reg
 	F__fpu_ymmh7     __darwin_xmm_reg
 	F__fpu_ymmh8     __darwin_xmm_reg
 	F__fpu_ymmh9     __darwin_xmm_reg
 	F__fpu_ymmh10    __darwin_xmm_reg
 	F__fpu_ymmh11    __darwin_xmm_reg
 	F__fpu_ymmh12    __darwin_xmm_reg
 	F__fpu_ymmh13    __darwin_xmm_reg
 	F__fpu_ymmh14    __darwin_xmm_reg
 	F__fpu_ymmh15    __darwin_xmm_reg
 }
 
 type __darwin_x86_avx512_state64 = struct {
 	F__fpu_reserved  [2]int32
 	F__fpu_fcw       __darwin_fp_control
 	F__fpu_fsw       __darwin_fp_status
 	F__fpu_ftw       __uint8_t
 	F__fpu_rsrv1     __uint8_t
 	F__fpu_fop       __uint16_t
 	F__fpu_ip        __uint32_t
 	F__fpu_cs        __uint16_t
 	F__fpu_rsrv2     __uint16_t
 	F__fpu_dp        __uint32_t
 	F__fpu_ds        __uint16_t
 	F__fpu_rsrv3     __uint16_t
 	F__fpu_mxcsr     __uint32_t
 	F__fpu_mxcsrmask __uint32_t
 	F__fpu_stmm0     __darwin_mmst_reg
 	F__fpu_stmm1     __darwin_mmst_reg
 	F__fpu_stmm2     __darwin_mmst_reg
 	F__fpu_stmm3     __darwin_mmst_reg
 	F__fpu_stmm4     __darwin_mmst_reg
 	F__fpu_stmm5     __darwin_mmst_reg
 	F__fpu_stmm6     __darwin_mmst_reg
 	F__fpu_stmm7     __darwin_mmst_reg
 	F__fpu_xmm0      __darwin_xmm_reg
 	F__fpu_xmm1      __darwin_xmm_reg
 	F__fpu_xmm2      __darwin_xmm_reg
 	F__fpu_xmm3      __darwin_xmm_reg
 	F__fpu_xmm4      __darwin_xmm_reg
 	F__fpu_xmm5      __darwin_xmm_reg
 	F__fpu_xmm6      __darwin_xmm_reg
 	F__fpu_xmm7      __darwin_xmm_reg
 	F__fpu_xmm8      __darwin_xmm_reg
 	F__fpu_xmm9      __darwin_xmm_reg
 	F__fpu_xmm10     __darwin_xmm_reg
 	F__fpu_xmm11     __darwin_xmm_reg
 	F__fpu_xmm12     __darwin_xmm_reg
 	F__fpu_xmm13     __darwin_xmm_reg
 	F__fpu_xmm14     __darwin_xmm_reg
 	F__fpu_xmm15     __darwin_xmm_reg
 	F__fpu_rsrv4     [96]int8
 	F__fpu_reserved1 int32
 	F__avx_reserved1 [64]int8
 	F__fpu_ymmh0     __darwin_xmm_reg
 	F__fpu_ymmh1     __darwin_xmm_reg
 	F__fpu_ymmh2     __darwin_xmm_reg
 	F__fpu_ymmh3     __darwin_xmm_reg
 	F__fpu_ymmh4     __darwin_xmm_reg
 	F__fpu_ymmh5     __darwin_xmm_reg
 	F__fpu_ymmh6     __darwin_xmm_reg
 	F__fpu_ymmh7     __darwin_xmm_reg
 	F__fpu_ymmh8     __darwin_xmm_reg
 	F__fpu_ymmh9     __darwin_xmm_reg
 	F__fpu_ymmh10    __darwin_xmm_reg
 	F__fpu_ymmh11    __darwin_xmm_reg
 	F__fpu_ymmh12    __darwin_xmm_reg
 	F__fpu_ymmh13    __darwin_xmm_reg
 	F__fpu_ymmh14    __darwin_xmm_reg
 	F__fpu_ymmh15    __darwin_xmm_reg
 	F__fpu_k0        __darwin_opmask_reg
 	F__fpu_k1        __darwin_opmask_reg
 	F__fpu_k2        __darwin_opmask_reg
 	F__fpu_k3        __darwin_opmask_reg
 	F__fpu_k4        __darwin_opmask_reg
 	F__fpu_k5        __darwin_opmask_reg
 	F__fpu_k6        __darwin_opmask_reg
 	F__fpu_k7        __darwin_opmask_reg
 	F__fpu_zmmh0     __darwin_ymm_reg
 	F__fpu_zmmh1     __darwin_ymm_reg
 	F__fpu_zmmh2     __darwin_ymm_reg
 	F__fpu_zmmh3     __darwin_ymm_reg
 	F__fpu_zmmh4     __darwin_ymm_reg
 	F__fpu_zmmh5     __darwin_ymm_reg
 	F__fpu_zmmh6     __darwin_ymm_reg
 	F__fpu_zmmh7     __darwin_ymm_reg
 	F__fpu_zmmh8     __darwin_ymm_reg
 	F__fpu_zmmh9     __darwin_ymm_reg
 	F__fpu_zmmh10    __darwin_ymm_reg
 	F__fpu_zmmh11    __darwin_ymm_reg
 	F__fpu_zmmh12    __darwin_ymm_reg
 	F__fpu_zmmh13    __darwin_ymm_reg
 	F__fpu_zmmh14    __darwin_ymm_reg
 	F__fpu_zmmh15    __darwin_ymm_reg
 	F__fpu_zmm16     __darwin_zmm_reg
 	F__fpu_zmm17     __darwin_zmm_reg
 	F__fpu_zmm18     __darwin_zmm_reg
 	F__fpu_zmm19     __darwin_zmm_reg
 	F__fpu_zmm20     __darwin_zmm_reg
 	F__fpu_zmm21     __darwin_zmm_reg
 	F__fpu_zmm22     __darwin_zmm_reg
 	F__fpu_zmm23     __darwin_zmm_reg
 	F__fpu_zmm24     __darwin_zmm_reg
 	F__fpu_zmm25     __darwin_zmm_reg
 	F__fpu_zmm26     __darwin_zmm_reg
 	F__fpu_zmm27     __darwin_zmm_reg
 	F__fpu_zmm28     __darwin_zmm_reg
 	F__fpu_zmm29     __darwin_zmm_reg
 	F__fpu_zmm30     __darwin_zmm_reg
 	F__fpu_zmm31     __darwin_zmm_reg
 }
 
 type __darwin_x86_exception_state64 = struct {
 	F__trapno     __uint16_t
 	F__cpu        __uint16_t
 	F__err        __uint32_t
 	F__faultvaddr __uint64_t
 }
 
 type __darwin_x86_debug_state64 = struct {
 	F__dr0 __uint64_t
 	F__dr1 __uint64_t
 	F__dr2 __uint64_t
 	F__dr3 __uint64_t
 	F__dr4 __uint64_t
 	F__dr5 __uint64_t
 	F__dr6 __uint64_t
 	F__dr7 __uint64_t
 }
 
 type __darwin_x86_cpmu_state64 = struct {
 	F__ctrs [16]__uint64_t
 }
 
 type __darwin_mcontext32 = struct {
 	F__es __darwin_i386_exception_state
 	F__ss __darwin_i386_thread_state
 	F__fs __darwin_i386_float_state
 }
 
 type __darwin_mcontext_avx32 = struct {
 	F__es __darwin_i386_exception_state
 	F__ss __darwin_i386_thread_state
 	F__fs __darwin_i386_avx_state
 }
 
 type __darwin_mcontext_avx512_32 = struct {
 	F__es __darwin_i386_exception_state
 	F__ss __darwin_i386_thread_state
 	F__fs __darwin_i386_avx512_state
 }
 
 type __darwin_mcontext64 = struct {
 	F__es __darwin_x86_exception_state64
 	F__ss __darwin_x86_thread_state64
 	F__fs __darwin_x86_float_state64
 }
 
 type __darwin_mcontext64_full = struct {
 	F__es __darwin_x86_exception_state64
 	F__ss __darwin_x86_thread_full_state64
 	F__fs __darwin_x86_float_state64
 }
 
 type __darwin_mcontext_avx64 = struct {
 	F__es __darwin_x86_exception_state64
 	F__ss __darwin_x86_thread_state64
 	F__fs __darwin_x86_avx_state64
 }
 
 type __darwin_mcontext_avx64_full = struct {
 	F__es __darwin_x86_exception_state64
 	F__ss __darwin_x86_thread_full_state64
 	F__fs __darwin_x86_avx_state64
 }
 
 type __darwin_mcontext_avx512_64 = struct {
 	F__es __darwin_x86_exception_state64
 	F__ss __darwin_x86_thread_state64
 	F__fs __darwin_x86_avx512_state64
 }
 
 type __darwin_mcontext_avx512_64_full = struct {
 	F__es __darwin_x86_exception_state64
 	F__ss __darwin_x86_thread_full_state64
 	F__fs __darwin_x86_avx512_state64
 }
 
 type mcontext_t = uintptr
 
 type pthread_attr_t = struct {
 	F__sig    int64
 	F__opaque [56]int8
 }
 
 type __darwin_sigaltstack = struct {
 	Fss_sp    uintptr
 	Fss_size  __darwin_size_t
 	Fss_flags int32
 }
 
 type stack_t = struct {
 	Fss_sp    uintptr
 	Fss_size  __darwin_size_t
 	Fss_flags int32
 }
 
 type __darwin_ucontext = struct {
 	Fuc_onstack  int32
 	Fuc_sigmask  __darwin_sigset_t
 	Fuc_stack    __darwin_sigaltstack
 	Fuc_link     uintptr
 	Fuc_mcsize   __darwin_size_t
 	Fuc_mcontext uintptr
 }
 
 type ucontext_t = struct {
 	Fuc_onstack  int32
 	Fuc_sigmask  __darwin_sigset_t
 	Fuc_stack    __darwin_sigaltstack
 	Fuc_link     uintptr
 	Fuc_mcsize   __darwin_size_t
 	Fuc_mcontext uintptr
 }
 
 type sigset_t = uint32
 
 type size_t = uint64
 
 type uid_t = uint32
 
 type sigval = struct {
 	Fsival_ptr   [0]uintptr
 	Fsival_int   int32
 	F__ccgo_pad2 [4]byte
 }
 
 type sigevent = struct {
 	Fsigev_notify            int32
 	Fsigev_signo             int32
 	Fsigev_value             sigval
 	Fsigev_notify_function   uintptr
 	Fsigev_notify_attributes uintptr
 }
 
 type siginfo_t = struct {
 	Fsi_signo  int32
 	Fsi_errno  int32
 	Fsi_code   int32
 	Fsi_pid    pid_t
 	Fsi_uid    uid_t
 	Fsi_status int32
 	Fsi_addr   uintptr
 	Fsi_value  sigval
 	Fsi_band   int64
 	F__pad     [7]uint64
 }
 
 type __siginfo = siginfo_t
 
 type __sigaction_u = struct {
 	F__sa_sigaction [0]uintptr
 	F__sa_handler   uintptr
 }
 
 type __sigaction = struct {
 	F__sigaction_u __sigaction_u
 	Fsa_tramp      uintptr
 	Fsa_mask       sigset_t
 	Fsa_flags      int32
 }
 
 type sigaction1 = struct {
 	F__sigaction_u __sigaction_u
 	Fsa_mask       sigset_t
 	Fsa_flags      int32
 }
 
 type sig_t = uintptr
 
 type sigvec = struct {
 	Fsv_handler uintptr
 	Fsv_mask    int32
 	Fsv_flags   int32
 }
 
 type sigstack = struct {
 	Fss_sp      uintptr
 	Fss_onstack int32
 }
 
 type uint8_t = uint8
 
 type uint16_t = uint16
 
 type uint32_t = uint32
 
 type uint64_t = uint64
 
 type int_least8_t = int8
 
 type int_least16_t = int16
 
 type int_least32_t = int32
 
 type int_least64_t = int64
 
 type uint_least8_t = uint8
 
 type uint_least16_t = uint16
 
 type uint_least32_t = uint32
 
 type uint_least64_t = uint64
 
 type int_fast8_t = int8
 
 type int_fast16_t = int16
 
 type int_fast32_t = int32
 
 type int_fast64_t = int64
 
 type uint_fast8_t = uint8
 
 type uint_fast16_t = uint16
 
 type uint_fast32_t = uint32
 
 type uint_fast64_t = uint64
 
 type intmax_t = int64
 
 type uintmax_t = uint64
 
 type timeval = struct {
 	Ftv_sec  __darwin_time_t
 	Ftv_usec __darwin_suseconds_t
 }
 
 type rlim_t = uint64
 
 type rusage = struct {
 	Fru_utime    timeval
 	Fru_stime    timeval
 	Fru_maxrss   int64
 	Fru_ixrss    int64
 	Fru_idrss    int64
 	Fru_isrss    int64
 	Fru_minflt   int64
 	Fru_majflt   int64
 	Fru_nswap    int64
 	Fru_inblock  int64
 	Fru_oublock  int64
 	Fru_msgsnd   int64
 	Fru_msgrcv   int64
 	Fru_nsignals int64
 	Fru_nvcsw    int64
 	Fru_nivcsw   int64
 }
 
 type rusage_info_t = uintptr
 
 type rusage_info_v0 = struct {
 	Fri_uuid               [16]uint8_t
 	Fri_user_time          uint64_t
 	Fri_system_time        uint64_t
 	Fri_pkg_idle_wkups     uint64_t
 	Fri_interrupt_wkups    uint64_t
 	Fri_pageins            uint64_t
 	Fri_wired_size         uint64_t
 	Fri_resident_size      uint64_t
 	Fri_phys_footprint     uint64_t
 	Fri_proc_start_abstime uint64_t
 	Fri_proc_exit_abstime  uint64_t
 }
 
 type rusage_info_v1 = struct {
 	Fri_uuid                  [16]uint8_t
 	Fri_user_time             uint64_t
 	Fri_system_time           uint64_t
 	Fri_pkg_idle_wkups        uint64_t
 	Fri_interrupt_wkups       uint64_t
 	Fri_pageins               uint64_t
 	Fri_wired_size            uint64_t
 	Fri_resident_size         uint64_t
 	Fri_phys_footprint        uint64_t
 	Fri_proc_start_abstime    uint64_t
 	Fri_proc_exit_abstime     uint64_t
 	Fri_child_user_time       uint64_t
 	Fri_child_system_time     uint64_t
 	Fri_child_pkg_idle_wkups  uint64_t
 	Fri_child_interrupt_wkups uint64_t
 	Fri_child_pageins         uint64_t
 	Fri_child_elapsed_abstime uint64_t
 }
 
 type rusage_info_v2 = struct {
 	Fri_uuid                  [16]uint8_t
 	Fri_user_time             uint64_t
 	Fri_system_time           uint64_t
 	Fri_pkg_idle_wkups        uint64_t
 	Fri_interrupt_wkups       uint64_t
 	Fri_pageins               uint64_t
 	Fri_wired_size            uint64_t
 	Fri_resident_size         uint64_t
 	Fri_phys_footprint        uint64_t
 	Fri_proc_start_abstime    uint64_t
 	Fri_proc_exit_abstime     uint64_t
 	Fri_child_user_time       uint64_t
 	Fri_child_system_time     uint64_t
 	Fri_child_pkg_idle_wkups  uint64_t
 	Fri_child_interrupt_wkups uint64_t
 	Fri_child_pageins         uint64_t
 	Fri_child_elapsed_abstime uint64_t
 	Fri_diskio_bytesread      uint64_t
 	Fri_diskio_byteswritten   uint64_t
 }
 
 type rusage_info_v3 = struct {
 	Fri_uuid                          [16]uint8_t
 	Fri_user_time                     uint64_t
 	Fri_system_time                   uint64_t
 	Fri_pkg_idle_wkups                uint64_t
 	Fri_interrupt_wkups               uint64_t
 	Fri_pageins                       uint64_t
 	Fri_wired_size                    uint64_t
 	Fri_resident_size                 uint64_t
 	Fri_phys_footprint                uint64_t
 	Fri_proc_start_abstime            uint64_t
 	Fri_proc_exit_abstime             uint64_t
 	Fri_child_user_time               uint64_t
 	Fri_child_system_time             uint64_t
 	Fri_child_pkg_idle_wkups          uint64_t
 	Fri_child_interrupt_wkups         uint64_t
 	Fri_child_pageins                 uint64_t
 	Fri_child_elapsed_abstime         uint64_t
 	Fri_diskio_bytesread              uint64_t
 	Fri_diskio_byteswritten           uint64_t
 	Fri_cpu_time_qos_default          uint64_t
 	Fri_cpu_time_qos_maintenance      uint64_t
 	Fri_cpu_time_qos_background       uint64_t
 	Fri_cpu_time_qos_utility          uint64_t
 	Fri_cpu_time_qos_legacy           uint64_t
 	Fri_cpu_time_qos_user_initiated   uint64_t
 	Fri_cpu_time_qos_user_interactive uint64_t
 	Fri_billed_system_time            uint64_t
 	Fri_serviced_system_time          uint64_t
 }
 
 type rusage_info_v4 = struct {
 	Fri_uuid                          [16]uint8_t
 	Fri_user_time                     uint64_t
 	Fri_system_time                   uint64_t
 	Fri_pkg_idle_wkups                uint64_t
 	Fri_interrupt_wkups               uint64_t
 	Fri_pageins                       uint64_t
 	Fri_wired_size                    uint64_t
 	Fri_resident_size                 uint64_t
 	Fri_phys_footprint                uint64_t
 	Fri_proc_start_abstime            uint64_t
 	Fri_proc_exit_abstime             uint64_t
 	Fri_child_user_time               uint64_t
 	Fri_child_system_time             uint64_t
 	Fri_child_pkg_idle_wkups          uint64_t
 	Fri_child_interrupt_wkups         uint64_t
 	Fri_child_pageins                 uint64_t
 	Fri_child_elapsed_abstime         uint64_t
 	Fri_diskio_bytesread              uint64_t
 	Fri_diskio_byteswritten           uint64_t
 	Fri_cpu_time_qos_default          uint64_t
 	Fri_cpu_time_qos_maintenance      uint64_t
 	Fri_cpu_time_qos_background       uint64_t
 	Fri_cpu_time_qos_utility          uint64_t
 	Fri_cpu_time_qos_legacy           uint64_t
 	Fri_cpu_time_qos_user_initiated   uint64_t
 	Fri_cpu_time_qos_user_interactive uint64_t
 	Fri_billed_system_time            uint64_t
 	Fri_serviced_system_time          uint64_t
 	Fri_logical_writes                uint64_t
 	Fri_lifetime_max_phys_footprint   uint64_t
 	Fri_instructions                  uint64_t
 	Fri_cycles                        uint64_t
 	Fri_billed_energy                 uint64_t
 	Fri_serviced_energy               uint64_t
 	Fri_interval_max_phys_footprint   uint64_t
 	Fri_runnable_time                 uint64_t
 }
 
 type rusage_info_v5 = struct {
 	Fri_uuid                          [16]uint8_t
 	Fri_user_time                     uint64_t
 	Fri_system_time                   uint64_t
 	Fri_pkg_idle_wkups                uint64_t
 	Fri_interrupt_wkups               uint64_t
 	Fri_pageins                       uint64_t
 	Fri_wired_size                    uint64_t
 	Fri_resident_size                 uint64_t
 	Fri_phys_footprint                uint64_t
 	Fri_proc_start_abstime            uint64_t
 	Fri_proc_exit_abstime             uint64_t
 	Fri_child_user_time               uint64_t
 	Fri_child_system_time             uint64_t
 	Fri_child_pkg_idle_wkups          uint64_t
 	Fri_child_interrupt_wkups         uint64_t
 	Fri_child_pageins                 uint64_t
 	Fri_child_elapsed_abstime         uint64_t
 	Fri_diskio_bytesread              uint64_t
 	Fri_diskio_byteswritten           uint64_t
 	Fri_cpu_time_qos_default          uint64_t
 	Fri_cpu_time_qos_maintenance      uint64_t
 	Fri_cpu_time_qos_background       uint64_t
 	Fri_cpu_time_qos_utility          uint64_t
 	Fri_cpu_time_qos_legacy           uint64_t
 	Fri_cpu_time_qos_user_initiated   uint64_t
 	Fri_cpu_time_qos_user_interactive uint64_t
 	Fri_billed_system_time            uint64_t
 	Fri_serviced_system_time          uint64_t
 	Fri_logical_writes                uint64_t
 	Fri_lifetime_max_phys_footprint   uint64_t
 	Fri_instructions                  uint64_t
 	Fri_cycles                        uint64_t
 	Fri_billed_energy                 uint64_t
 	Fri_serviced_energy               uint64_t
 	Fri_interval_max_phys_footprint   uint64_t
 	Fri_runnable_time                 uint64_t
 	Fri_flags                         uint64_t
 }
 
 type rusage_info_v6 = struct {
 	Fri_uuid                          [16]uint8_t
 	Fri_user_time                     uint64_t
 	Fri_system_time                   uint64_t
 	Fri_pkg_idle_wkups                uint64_t
 	Fri_interrupt_wkups               uint64_t
 	Fri_pageins                       uint64_t
 	Fri_wired_size                    uint64_t
 	Fri_resident_size                 uint64_t
 	Fri_phys_footprint                uint64_t
 	Fri_proc_start_abstime            uint64_t
 	Fri_proc_exit_abstime             uint64_t
 	Fri_child_user_time               uint64_t
 	Fri_child_system_time             uint64_t
 	Fri_child_pkg_idle_wkups          uint64_t
 	Fri_child_interrupt_wkups         uint64_t
 	Fri_child_pageins                 uint64_t
 	Fri_child_elapsed_abstime         uint64_t
 	Fri_diskio_bytesread              uint64_t
 	Fri_diskio_byteswritten           uint64_t
 	Fri_cpu_time_qos_default          uint64_t
 	Fri_cpu_time_qos_maintenance      uint64_t
 	Fri_cpu_time_qos_background       uint64_t
 	Fri_cpu_time_qos_utility          uint64_t
 	Fri_cpu_time_qos_legacy           uint64_t
 	Fri_cpu_time_qos_user_initiated   uint64_t
 	Fri_cpu_time_qos_user_interactive uint64_t
 	Fri_billed_system_time            uint64_t
 	Fri_serviced_system_time          uint64_t
 	Fri_logical_writes                uint64_t
 	Fri_lifetime_max_phys_footprint   uint64_t
 	Fri_instructions                  uint64_t
 	Fri_cycles                        uint64_t
 	Fri_billed_energy                 uint64_t
 	Fri_serviced_energy               uint64_t
 	Fri_interval_max_phys_footprint   uint64_t
 	Fri_runnable_time                 uint64_t
 	Fri_flags                         uint64_t
 	Fri_user_ptime                    uint64_t
 	Fri_system_ptime                  uint64_t
 	Fri_pinstructions                 uint64_t
 	Fri_pcycles                       uint64_t
 	Fri_energy_nj                     uint64_t
 	Fri_penergy_nj                    uint64_t
 	Fri_secure_time_in_system         uint64_t
 	Fri_secure_ptime_in_system        uint64_t
 	Fri_neural_footprint              uint64_t
 	Fri_lifetime_max_neural_footprint uint64_t
 	Fri_interval_max_neural_footprint uint64_t
 	Fri_reserved                      [9]uint64_t
 }
 
 type rusage_info_current = struct {
 	Fri_uuid                          [16]uint8_t
 	Fri_user_time                     uint64_t
 	Fri_system_time                   uint64_t
 	Fri_pkg_idle_wkups                uint64_t
 	Fri_interrupt_wkups               uint64_t
 	Fri_pageins                       uint64_t
 	Fri_wired_size                    uint64_t
 	Fri_resident_size                 uint64_t
 	Fri_phys_footprint                uint64_t
 	Fri_proc_start_abstime            uint64_t
 	Fri_proc_exit_abstime             uint64_t
 	Fri_child_user_time               uint64_t
 	Fri_child_system_time             uint64_t
 	Fri_child_pkg_idle_wkups          uint64_t
 	Fri_child_interrupt_wkups         uint64_t
 	Fri_child_pageins                 uint64_t
 	Fri_child_elapsed_abstime         uint64_t
 	Fri_diskio_bytesread              uint64_t
 	Fri_diskio_byteswritten           uint64_t
 	Fri_cpu_time_qos_default          uint64_t
 	Fri_cpu_time_qos_maintenance      uint64_t
 	Fri_cpu_time_qos_background       uint64_t
 	Fri_cpu_time_qos_utility          uint64_t
 	Fri_cpu_time_qos_legacy           uint64_t
 	Fri_cpu_time_qos_user_initiated   uint64_t
 	Fri_cpu_time_qos_user_interactive uint64_t
 	Fri_billed_system_time            uint64_t
 	Fri_serviced_system_time          uint64_t
 	Fri_logical_writes                uint64_t
 	Fri_lifetime_max_phys_footprint   uint64_t
 	Fri_instructions                  uint64_t
 	Fri_cycles                        uint64_t
 	Fri_billed_energy                 uint64_t
 	Fri_serviced_energy               uint64_t
 	Fri_interval_max_phys_footprint   uint64_t
 	Fri_runnable_time                 uint64_t
 	Fri_flags                         uint64_t
 	Fri_user_ptime                    uint64_t
 	Fri_system_ptime                  uint64_t
 	Fri_pinstructions                 uint64_t
 	Fri_pcycles                       uint64_t
 	Fri_energy_nj                     uint64_t
 	Fri_penergy_nj                    uint64_t
 	Fri_secure_time_in_system         uint64_t
 	Fri_secure_ptime_in_system        uint64_t
 	Fri_neural_footprint              uint64_t
 	Fri_lifetime_max_neural_footprint uint64_t
 	Fri_interval_max_neural_footprint uint64_t
 	Fri_reserved                      [9]uint64_t
 }
 
 type rlimit = struct {
 	Frlim_cur rlim_t
 	Frlim_max rlim_t
 }
 
 type proc_rlimit_control_wakeupmon = struct {
 	Fwm_flags uint32_t
 	Fwm_rate  int32_t
 }
 
 type wait = struct {
 	Fw_T [0]struct {
 		F__ccgo0 uint32
 	}
 	Fw_S [0]struct {
 		F__ccgo0 uint32
 	}
 	Fw_status int32
 }
 
 type ct_rune_t = int32
 
 type rune_t = int32
 
 type wchar_t = int32
 
 type div_t = struct {
 	Fquot int32
 	Frem  int32
 }
 
 type ldiv_t = struct {
 	Fquot int64
 	Frem  int64
 }
 
 type lldiv_t = struct {
 	Fquot int64
 	Frem  int64
 }
 
 type malloc_type_id_t = uint64
 
 type dev_t = int32
 
 type mode_t = uint16
 
 type ptrdiff_t = int64
 
 type rsize_t = uint64
 
 type nullptr_t = uintptr
 
 type max_align_t = struct {
 	F__clang_max_align_nonce1 int64
 	F__clang_max_align_nonce2 float64
 }
 
 type imaxdiv_t = struct {
 	Fquot intmax_t
 	Frem  intmax_t
 }
 
 type WebPRGBABuffer = struct {
 	Frgba   uintptr
 	Fstride int32
 	Fsize   size_t
 }
 
 type WebPYUVABuffer = struct {
 	Fy        uintptr
 	Fu        uintptr
 	Fv        uintptr
 	Fa        uintptr
 	Fy_stride int32
 	Fu_stride int32
 	Fv_stride int32
 	Fa_stride int32
 	Fy_size   size_t
 	Fu_size   size_t
 	Fv_size   size_t
 	Fa_size   size_t
 }
 
 type WebPDecBuffer = struct {
 	Fcolorspace         WEBP_CSP_MODE1
 	Fwidth              int32
 	Fheight             int32
 	Fis_external_memory int32
 	Fu                  struct {
 		FYUVA        [0]WebPYUVABuffer
 		FRGBA        WebPRGBABuffer
 		F__ccgo_pad2 [56]byte
 	}
 	Fpad            [4]uint32_t
 	Fprivate_memory uintptr
 }
 
 type WEBP_CSP_MODE = int32
 
 const MODE_RGB = 0
 const MODE_RGBA = 1
 const MODE_BGR = 2
 const MODE_BGRA = 3
 const MODE_ARGB = 4
 const MODE_RGBA_4444 = 5
 const MODE_RGB_565 = 6
 const MODE_rgbA = 7
 const MODE_bgrA = 8
 const MODE_Argb = 9
 const MODE_rgbA_4444 = 10
 const MODE_YUV = 11
 const MODE_YUVA = 12
 const MODE_LAST = 13
 
 type WebPBitstreamFeatures = struct {
 	Fwidth         int32
 	Fheight        int32
 	Fhas_alpha     int32
 	Fhas_animation int32
 	Fformat        int32
 	Fpad           [5]uint32_t
 }
 
 type WebPDecoderOptions = struct {
 	Fbypass_filtering         int32
 	Fno_fancy_upsampling      int32
 	Fuse_cropping             int32
 	Fcrop_left                int32
 	Fcrop_top                 int32
 	Fcrop_width               int32
 	Fcrop_height              int32
 	Fuse_scaling              int32
 	Fscaled_width             int32
 	Fscaled_height            int32
 	Fuse_threads              int32
 	Fdithering_strength       int32
 	Fflip                     int32
 	Falpha_dithering_strength int32
 	Fpad                      [5]uint32_t
 }
 
 type WebPDecoderConfig = struct {
 	Finput   WebPBitstreamFeatures
 	Foutput  WebPDecBuffer
 	Foptions WebPDecoderOptions
 }
 
 type WEBP_CSP_MODE1 = int32
 
 type VP8StatusCode1 = int32
 
 type VP8StatusCode = int32
 
 const VP8_STATUS_OK = 0
 const VP8_STATUS_OUT_OF_MEMORY = 1
 const VP8_STATUS_INVALID_PARAM = 2
 const VP8_STATUS_BITSTREAM_ERROR = 3
 const VP8_STATUS_UNSUPPORTED_FEATURE = 4
 const VP8_STATUS_SUSPENDED = 5
 const VP8_STATUS_USER_ABORT = 6
 const VP8_STATUS_NOT_ENOUGH_DATA = 7
 
 type VP8Io = struct {
 	Fwidth            int32
 	Fheight           int32
 	Fmb_y             int32
 	Fmb_w             int32
 	Fmb_h             int32
 	Fy                uintptr
 	Fu                uintptr
 	Fv                uintptr
 	Fy_stride         int32
 	Fuv_stride        int32
 	Fopaque           uintptr
 	Fput              VP8IoPutHook
 	Fsetup            VP8IoSetupHook
 	Fteardown         VP8IoTeardownHook
 	Ffancy_upsampling int32
 	Fdata_size        size_t
 	Fdata             uintptr
 	Fbypass_filtering int32
 	Fuse_cropping     int32
 	Fcrop_left        int32
 	Fcrop_right       int32
 	Fcrop_top         int32
 	Fcrop_bottom      int32
 	Fuse_scaling      int32
 	Fscaled_width     int32
 	Fscaled_height    int32
 	Fa                uintptr
 }
 
 type VP8IoPutHook = uintptr
 
 type VP8IoSetupHook = uintptr
 
 type VP8IoTeardownHook = uintptr
 
 type VP8Decoder = struct {
 	Fstatus              VP8StatusCode1
 	Fready               int32
 	Ferror_msg           uintptr
 	Fbr                  VP8BitReader
 	Fincremental         int32
 	Ffrm_hdr             VP8FrameHeader
 	Fpic_hdr             VP8PictureHeader
 	Ffilter_hdr          VP8FilterHeader
 	Fsegment_hdr         VP8SegmentHeader
 	Fworker              WebPWorker
 	Fmt_method           int32
 	Fcache_id            int32
 	Fnum_caches          int32
 	Fthread_ctx          VP8ThreadContext
 	Fmb_w                int32
 	Fmb_h                int32
 	Ftl_mb_x             int32
 	Ftl_mb_y             int32
 	Fbr_mb_x             int32
 	Fbr_mb_y             int32
 	Fnum_parts_minus_one uint32_t
 	Fparts               [8]VP8BitReader
 	Fdither              int32
 	Fdithering_rg        VP8Random
 	Fdqm                 [4]VP8QuantMatrix
 	Fproba               VP8Proba
 	Fuse_skip_proba      int32
 	Fskip_p              uint8_t
 	Fintra_t             uintptr
 	Fintra_l             [4]uint8_t
 	Fyuv_t               uintptr
 	Fmb_info             uintptr
 	Ff_info              uintptr
 	Fyuv_b               uintptr
 	Fcache_y             uintptr
 	Fcache_u             uintptr
 	Fcache_v             uintptr
 	Fcache_y_stride      int32
 	Fcache_uv_stride     int32
 	Fmem                 uintptr
 	Fmem_size            size_t
 	Fmb_x                int32
 	Fmb_y                int32
 	Fmb_data             uintptr
 	Ffilter_type         int32
 	Ffstrengths          [4][2]VP8FInfo
 	Falph_dec            uintptr
 	Falpha_data          uintptr
 	Falpha_data_size     size_t
 	Fis_alpha_decoded    int32
 	Falpha_plane_mem     uintptr
 	Falpha_plane         uintptr
 	Falpha_prev_line     uintptr
 	Falpha_dithering     int32
 }
 
 type rescaler_t = uint32
 
 type WebPRescaler = struct {
 	Fx_expand     int32
 	Fy_expand     int32
 	Fnum_channels int32
 	Ffx_scale     uint32_t
 	Ffy_scale     uint32_t
 	Ffxy_scale    uint32_t
 	Fy_accum      int32
 	Fy_add        int32
 	Fy_sub        int32
 	Fx_add        int32
 	Fx_sub        int32
 	Fsrc_width    int32
 	Fsrc_height   int32
 	Fdst_width    int32
 	Fdst_height   int32
 	Fsrc_y        int32
 	Fdst_y        int32
 	Fdst          uintptr
 	Fdst_stride   int32
 	Firow         uintptr
 	Ffrow         uintptr
 }
 
 type WebPDecParams = struct {
 	Foutput         uintptr
 	Ftmp_y          uintptr
 	Ftmp_u          uintptr
 	Ftmp_v          uintptr
 	Flast_y         int32
 	Foptions        uintptr
 	Fscaler_y       uintptr
 	Fscaler_u       uintptr
 	Fscaler_v       uintptr
 	Fscaler_a       uintptr
 	Fmemory         uintptr
 	Femit           OutputFunc
 	Femit_alpha     OutputAlphaFunc
 	Femit_alpha_row OutputRowFunc
 }
 
 type OutputFunc = uintptr
 
 type OutputAlphaFunc = uintptr
 
 type OutputRowFunc = uintptr
 
 type WebPHeaderStructure = struct {
 	Fdata            uintptr
 	Fdata_size       size_t
 	Fhave_all_data   int32
 	Foffset          size_t
 	Falpha_data      uintptr
 	Falpha_data_size size_t
 	Fcompressed_size size_t
 	Friff_size       size_t
 	Fis_lossless     int32
 }
 
 type CPUFeature = int32
 
 const kSSE2 = 0
 const kSSE3 = 1
 const kSlowSSSE3 = 2
 const kSSE4_1 = 3
 const kAVX = 4
 const kAVX2 = 5
 const kNEON = 6
 const kMIPS32 = 7
 const kMIPSdspR2 = 8
 const kMSA = 9
 
 type VP8CPUInfo = uintptr
 
 type VP8Idct = uintptr
 
 type VP8Fdct = uintptr
 
 type VP8WHT = uintptr
 
 type VP8IntraPreds = uintptr
 
 type VP8Intra4Preds = uintptr
 
 type VP8Metric = uintptr
 
 type VP8WMetric = uintptr
 
 type VP8MeanMetric = uintptr
 
 type VP8BlockCopy = uintptr
 
 type VP8QuantizeBlock = uintptr
 
 type VP8Quantize2Blocks = uintptr
 
 type VP8QuantizeBlockWHT = uintptr
 
 type VP8Histogram = struct {
 	Fmax_value     int32
 	Flast_non_zero int32
 }
 
 type VP8CHisto = uintptr
 
 type VP8SetResidualCoeffsFunc = uintptr
 
 type VP8GetResidualCostFunc = uintptr
 
 type VP8DistoStats = struct {
 	Fw   uint32_t
 	Fxm  uint32_t
 	Fym  uint32_t
 	Fxxm uint32_t
 	Fxym uint32_t
 	Fyym uint32_t
 }
 
 type VP8SSIMGetClippedFunc = uintptr
 
 type VP8SSIMGetFunc = uintptr
 
 type VP8AccumulateSSEFunc = uintptr
 
 type VP8DecIdct = uintptr
 
 type VP8DecIdct2 = uintptr
 
 type VP8PredFunc = uintptr
 
 type VP8SimpleFilterFunc = uintptr
 
 type VP8LumaFilterFunc = uintptr
 
 type VP8ChromaFilterFunc = uintptr
 
 type WebPUpsampleLinePairFunc = uintptr
 
 type WebPSamplerRowFunc = uintptr
 
 type WebPYUV444Converter = uintptr
 
 type WebPRescalerImportRowFunc = uintptr
 
 type WebPRescalerExportRowFunc = uintptr
 
 type WEBP_FILTER_TYPE = int32
 
 const WEBP_FILTER_NONE = 0
 const WEBP_FILTER_HORIZONTAL = 1
 const WEBP_FILTER_VERTICAL = 2
 const WEBP_FILTER_GRADIENT = 3
 const WEBP_FILTER_LAST = 4
 const WEBP_FILTER_BEST = 5
 const WEBP_FILTER_FAST = 6
 
 type WebPFilterFunc = uintptr
 
 type WebPUnfilterFunc = uintptr
 
 type VP8LDecoder = struct {
 	Fstatus           VP8StatusCode1
 	Fstate            VP8LDecodeState
 	Fio               uintptr
 	Foutput           uintptr
 	Fpixels           uintptr
 	Fargb_cache       uintptr
 	Fbr               VP8LBitReader
 	Fincremental      int32
 	Fsaved_br         VP8LBitReader
 	Fsaved_last_pixel int32
 	Fwidth            int32
 	Fheight           int32
 	Flast_row         int32
 	Flast_pixel       int32
 	Flast_out_row     int32
 	Fhdr              VP8LMetadata
 	Fnext_transform   int32
 	Ftransforms       [4]VP8LTransform
 	Ftransforms_seen  uint32_t
 	Frescaler_memory  uintptr
 	Frescaler         uintptr
 }
 
 const READ_DATA = 0
 const READ_HDR = 1
 const READ_DIM = 2
 
 type ALPHDecoder = struct {
 	Fwidth          int32
 	Fheight         int32
 	Fmethod         int32
 	Ffilter         WEBP_FILTER_TYPE
 	Fpre_processing int32
 	Fvp8l_dec       uintptr
 	Fio             VP8Io
 	Fuse_8b_decode  int32
 	Foutput         uintptr
 	Fprev_line      uintptr
 }
 
 type errno_t = int32
 
 type ssize_t = int64
 
 const B_DC_PRED = 0
 const B_TM_PRED = 1
 const B_VE_PRED = 2
 const B_HE_PRED = 3
 const B_RD_PRED = 4
 const B_VR_PRED = 5
 const B_LD_PRED = 6
 const B_VL_PRED = 7
 const B_HD_PRED = 8
 const B_HU_PRED = 9
 const NUM_BMODES = 10
 const DC_PRED = 0
 const V_PRED = 2
 const H_PRED = 3
 const TM_PRED = 1
 const B_PRED = 10
 const NUM_PRED_MODES = 4
 const B_DC_PRED_NOTOP = 4
 const B_DC_PRED_NOLEFT = 5
 const B_DC_PRED_NOTOPLEFT = 6
 const NUM_B_DC_MODES = 7
 const MB_FEATURE_TREE_PROBS = 3
 const NUM_MB_SEGMENTS = 4
 const NUM_REF_LF_DELTAS = 4
 const NUM_MODE_LF_DELTAS = 4
 const MAX_NUM_PARTITIONS = 8
 const NUM_TYPES = 4
 const NUM_BANDS = 8
 const NUM_CTX = 3
 const NUM_PROBAS = 11
 
 type bit_t = uint64
 
 type range_t = uint32
 
 type VP8BitReader = struct {
 	Fvalue   bit_t
 	Frange1  range_t
 	Fbits    int32
 	Fbuf     uintptr
 	Fbuf_end uintptr
 	Fbuf_max uintptr
 	Feof     int32
 }
 
 type vp8l_val_t = uint64
 
 type VP8LBitReader = struct {
 	Fval     vp8l_val_t
 	Fbuf     uintptr
 	Flen1    size_t
 	Fpos     size_t
 	Fbit_pos int32
 	Feos     int32
 }
 
 type VP8LColorCache = struct {
 	Fcolors     uintptr
 	Fhash_shift int32
 	Fhash_bits  int32
 }
 
 var kHashMul = uint32(0x1e35a7bd)
 
 type VP8LImageTransformType = int32
 
 const PREDICTOR_TRANSFORM = 0
 const CROSS_COLOR_TRANSFORM = 1
 const SUBTRACT_GREEN_TRANSFORM = 2
 const COLOR_INDEXING_TRANSFORM = 3
 
 type HuffmanCode = struct {
 	Fbits  uint8_t
 	Fvalue uint16_t
 }
 
 type HuffmanCode32 = struct {
 	Fbits  int32
 	Fvalue uint32_t
 }
 
 type HuffmanTablesSegment = struct {
 	Fstart      uintptr
 	Fcurr_table uintptr
 	Fnext       uintptr
 	Fsize       int32
 }
 
 type HuffmanTables = struct {
 	Froot         HuffmanTablesSegment
 	Fcurr_segment uintptr
 }
 
 type HTreeGroup = struct {
 	Fhtrees             [5]uintptr
 	Fis_trivial_literal int32
 	Fliteral_arb        uint32_t
 	Fis_trivial_code    int32
 	Fuse_packed_table   int32
 	Fpacked_table       [64]HuffmanCode32
 }
 
 type VP8LDecodeState = int32
 
 type VP8LTransform = struct {
 	Ftype1 VP8LImageTransformType
 	Fbits  int32
 	Fxsize int32
 	Fysize int32
 	Fdata  uintptr
 }
 
 type VP8LMetadata = struct {
 	Fcolor_cache_size       int32
 	Fcolor_cache            VP8LColorCache
 	Fsaved_color_cache      VP8LColorCache
 	Fhuffman_mask           int32
 	Fhuffman_subsample_bits int32
 	Fhuffman_xsize          int32
 	Fhuffman_image          uintptr
 	Fnum_htree_groups       int32
 	Fhtree_groups           uintptr
 	Fhuffman_tables         HuffmanTables
 }
 
 type VP8Random = struct {
 	Findex1 int32
 	Findex2 int32
 	Ftab    [55]uint32_t
 	Famp    int32
 }
 
 type WebPWorkerStatus = int32
 
 const NOT_OK = 0
 const OK = 1
 const WORK = 2
 
 type WebPWorkerHook = uintptr
 
 type WebPWorker = struct {
 	Fimpl      uintptr
 	Fstatus    WebPWorkerStatus
 	Fhook      WebPWorkerHook
 	Fdata1     uintptr
 	Fdata2     uintptr
 	Fhad_error int32
 }
 
 type WebPWorkerInterface = struct {
 	FInit    uintptr
 	FReset   uintptr
 	FSync    uintptr
 	FLaunch  uintptr
 	FExecute uintptr
 	FEnd     uintptr
 }
 
 type VP8FrameHeader = struct {
 	Fkey_frame        uint8_t
 	Fprofile          uint8_t
 	Fshow             uint8_t
 	Fpartition_length uint32_t
 }
 
 type VP8PictureHeader = struct {
 	Fwidth      uint16_t
 	Fheight     uint16_t
 	Fxscale     uint8_t
 	Fyscale     uint8_t
 	Fcolorspace uint8_t
 	Fclamp_type uint8_t
 }
 
 type VP8SegmentHeader = struct {
 	Fuse_segment     int32
 	Fupdate_map      int32
 	Fabsolute_delta  int32
 	Fquantizer       [4]int8_t
 	Ffilter_strength [4]int8_t
 }
 
 type VP8ProbaArray = [11]uint8_t
 
 type VP8BandProbas = struct {
 	Fprobas [3]VP8ProbaArray
 }
 
 type VP8Proba = struct {
 	Fsegments  [3]uint8_t
 	Fbands     [4][8]VP8BandProbas
 	Fbands_ptr [4][17]uintptr
 }
 
 type VP8FilterHeader = struct {
 	Fsimple        int32
 	Flevel         int32
 	Fsharpness     int32
 	Fuse_lf_delta  int32
 	Fref_lf_delta  [4]int32
 	Fmode_lf_delta [4]int32
 }
 
 type VP8FInfo = struct {
 	Ff_limit    uint8_t
 	Ff_ilevel   uint8_t
 	Ff_inner    uint8_t
 	Fhev_thresh uint8_t
 }
 
 type VP8MB = struct {
 	Fnz    uint8_t
 	Fnz_dc uint8_t
 }
 
 type quant_t = [2]int32
 
 type VP8QuantMatrix = struct {
 	Fy1_mat   quant_t
 	Fy2_mat   quant_t
 	Fuv_mat   quant_t
 	Fuv_quant int32
 	Fdither   int32
 }
 
 type VP8MBData = struct {
 	Fcoeffs      [384]int16_t
 	Fis_i4x4     uint8_t
 	Fimodes      [16]uint8_t
 	Fuvmode      uint8_t
 	Fnon_zero_y  uint32_t
 	Fnon_zero_uv uint32_t
 	Fdither      uint8_t
 	Fskip        uint8_t
 	Fsegment     uint8_t
 }
 
 type VP8ThreadContext = struct {
 	Fid         int32
 	Fmb_y       int32
 	Ffilter_row int32
 	Ff_info     uintptr
 	Fmb_data    uintptr
 	Fio         VP8Io
 }
 
 type VP8TopSamples = struct {
 	Fy [16]uint8_t
 	Fu [8]uint8_t
 	Fv [8]uint8_t
 }
 
 //------------------------------------------------------------------------------
 
 // Copyright 2010 Google Inc. All Rights Reserved.
 //
 // Use of this source code is governed by a BSD-style license
 // that can be found in the COPYING file in the root of the source
 // tree. An additional intellectual property rights grant can be found
 // in the file PATENTS. All contributing project authors may
 // be found in the AUTHORS file in the root of the source tree.
 // -----------------------------------------------------------------------------
 //
 //  Main decoding functions for WebP images.
 //
 // Author: Skal (pascal.massimino@gmail.com)
 
 // Copyright 2012 Google Inc. All Rights Reserved.
 //
 // Use of this source code is governed by a BSD-style license
 // that can be found in the COPYING file in the root of the source
 // tree. An additional intellectual property rights grant can be found
 // in the file PATENTS. All contributing project authors may
 // be found in the AUTHORS file in the root of the source tree.
 // -----------------------------------------------------------------------------
 //
 //  Internal header for constants related to WebP file format.
 //
 // Author: Urvang (urvang@google.com)
 
 // Copyright 2010 Google Inc. All Rights Reserved.
 //
 // Use of this source code is governed by a BSD-style license
 // that can be found in the COPYING file in the root of the source
 // tree. An additional intellectual property rights grant can be found
 // in the file PATENTS. All contributing project authors may
 // be found in the AUTHORS file in the root of the source tree.
 // -----------------------------------------------------------------------------
 //
 //  Common types + memory wrappers
 //
 // Author: Skal (pascal.massimino@gmail.com)
 
 //------------------------------------------------------------------------------
 // ALPHDecoder object.
 
 // C documentation
 //
 //	// Allocates a new alpha decoder instance.
 func ALPHNew(tls *libc.TLS) (r uintptr) {
 	var dec uintptr
 	_ = dec
 	dec = WebPSafeCalloc(tls, uint64(1), uint64(216))
 	return dec
 }
 
 // C documentation
 //
 //	// Clears and deallocates an alpha decoder instance.
 func ALPHDelete(tls *libc.TLS, dec uintptr) {
 	if dec != libc.UintptrFromInt32(0) {
 		VP8LDelete(tls, (*ALPHDecoder)(unsafe.Pointer(dec)).Fvp8l_dec)
 		(*ALPHDecoder)(unsafe.Pointer(dec)).Fvp8l_dec = libc.UintptrFromInt32(0)
 		WebPSafeFree(tls, dec)
 	}
 }
 
 //------------------------------------------------------------------------------
 // Decoding.
 
 // C documentation
 //
 //	// Initialize alpha decoding by parsing the alpha header and decoding the image
 //	// header for alpha data stored using lossless compression.
 //	// Returns false in case of error in alpha header (data too short, invalid
 //	// compression method or filter, error in lossless header data etc).
 func ALPHInit(tls *libc.TLS, dec uintptr, data uintptr, data_size size_t, src_io uintptr, output uintptr) (r int32) {
 	var alpha_data, io1 uintptr
 	var alpha_data_size, alpha_decoded_size size_t
 	var ok, rsrv, v1 int32
 	_, _, _, _, _, _, _ = alpha_data, alpha_data_size, alpha_decoded_size, io1, ok, rsrv, v1
 	ok = 0
 	alpha_data = data + uintptr(ALPHA_HEADER_LEN)
 	alpha_data_size = data_size - uint64(ALPHA_HEADER_LEN)
 	io1 = dec + 32
 	VP8FiltersInit(tls)
 	(*ALPHDecoder)(unsafe.Pointer(dec)).Foutput = output
 	(*ALPHDecoder)(unsafe.Pointer(dec)).Fwidth = (*VP8Io)(unsafe.Pointer(src_io)).Fwidth
 	(*ALPHDecoder)(unsafe.Pointer(dec)).Fheight = (*VP8Io)(unsafe.Pointer(src_io)).Fheight
 	if data_size <= uint64(ALPHA_HEADER_LEN) {
 		return 0
 	}
 	(*ALPHDecoder)(unsafe.Pointer(dec)).Fmethod = libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(data))) >> 0 & int32(0x03)
 	(*ALPHDecoder)(unsafe.Pointer(dec)).Ffilter = libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(data))) >> libc.Int32FromInt32(2) & libc.Int32FromInt32(0x03)
 	(*ALPHDecoder)(unsafe.Pointer(dec)).Fpre_processing = libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(data))) >> int32(4) & int32(0x03)
 	rsrv = libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(data))) >> int32(6) & int32(0x03)
 	if (*ALPHDecoder)(unsafe.Pointer(dec)).Fmethod < ALPHA_NO_COMPRESSION || (*ALPHDecoder)(unsafe.Pointer(dec)).Fmethod > int32(ALPHA_LOSSLESS_COMPRESSION) || (*ALPHDecoder)(unsafe.Pointer(dec)).Ffilter >= int32(WEBP_FILTER_LAST) || (*ALPHDecoder)(unsafe.Pointer(dec)).Fpre_processing > int32(ALPHA_PREPROCESSED_LEVELS) || rsrv != 0 {
 		return 0
 	}
 	// Copy the necessary parameters from src_io to io
 	v1 = VP8InitIoInternal(tls, io1, int32(WEBP_DECODER_ABI_VERSION))
 	goto _2
 _2:
 	if !(v1 != 0) {
 		return 0
 	}
 	WebPInitCustomIo(tls, libc.UintptrFromInt32(0), io1)
 	(*VP8Io)(unsafe.Pointer(io1)).Fopaque = dec
 	(*VP8Io)(unsafe.Pointer(io1)).Fwidth = (*VP8Io)(unsafe.Pointer(src_io)).Fwidth
 	(*VP8Io)(unsafe.Pointer(io1)).Fheight = (*VP8Io)(unsafe.Pointer(src_io)).Fheight
 	(*VP8Io)(unsafe.Pointer(io1)).Fuse_cropping = (*VP8Io)(unsafe.Pointer(src_io)).Fuse_cropping
 	(*VP8Io)(unsafe.Pointer(io1)).Fcrop_left = (*VP8Io)(unsafe.Pointer(src_io)).Fcrop_left
 	(*VP8Io)(unsafe.Pointer(io1)).Fcrop_right = (*VP8Io)(unsafe.Pointer(src_io)).Fcrop_right
 	(*VP8Io)(unsafe.Pointer(io1)).Fcrop_top = (*VP8Io)(unsafe.Pointer(src_io)).Fcrop_top
 	(*VP8Io)(unsafe.Pointer(io1)).Fcrop_bottom = (*VP8Io)(unsafe.Pointer(src_io)).Fcrop_bottom
 	// No need to copy the scaling parameters.
 	if (*ALPHDecoder)(unsafe.Pointer(dec)).Fmethod == ALPHA_NO_COMPRESSION {
 		alpha_decoded_size = libc.Uint64FromInt32((*ALPHDecoder)(unsafe.Pointer(dec)).Fwidth * (*ALPHDecoder)(unsafe.Pointer(dec)).Fheight)
 		ok = libc.BoolInt32(alpha_data_size >= alpha_decoded_size)
 	} else {
 		ok = VP8LDecodeAlphaHeader(tls, dec, alpha_data, alpha_data_size)
 	}
 	return ok
 }
 
 // C documentation
 //
 //	// Decodes, unfilters and dequantizes *at least* 'num_rows' rows of alpha
 //	// starting from row number 'row'. It assumes that rows up to (row - 1) have
 //	// already been decoded.
 //	// Returns false in case of bitstream error.
 func ALPHDecode(tls *libc.TLS, dec uintptr, row int32, num_rows int32) (r int32) {
 	var alph_dec, deltas, dst, prev_line uintptr
 	var height, width, y int32
 	_, _, _, _, _, _, _ = alph_dec, deltas, dst, height, prev_line, width, y
 	alph_dec = (*VP8Decoder)(unsafe.Pointer(dec)).Falph_dec
 	width = (*ALPHDecoder)(unsafe.Pointer(alph_dec)).Fwidth
 	height = (*ALPHDecoder)(unsafe.Pointer(alph_dec)).Fio.Fcrop_bottom
 	if (*ALPHDecoder)(unsafe.Pointer(alph_dec)).Fmethod == ALPHA_NO_COMPRESSION {
 		prev_line = (*VP8Decoder)(unsafe.Pointer(dec)).Falpha_prev_line
 		deltas = (*VP8Decoder)(unsafe.Pointer(dec)).Falpha_data + uintptr(ALPHA_HEADER_LEN) + uintptr(row*width)
 		dst = (*VP8Decoder)(unsafe.Pointer(dec)).Falpha_plane + uintptr(row*width)
 		y = 0
 		for {
 			if !(y < num_rows) {
 				break
 			}
 			(*(*func(*libc.TLS, uintptr, uintptr, uintptr, int32))(unsafe.Pointer(&struct{ uintptr }{WebPUnfilters[(*ALPHDecoder)(unsafe.Pointer(alph_dec)).Ffilter]})))(tls, prev_line, deltas, dst, width)
 			prev_line = dst
 			dst = dst + uintptr(width)
 			deltas = deltas + uintptr(width)
 			goto _1
 		_1:
 			;
 			y = y + 1
 		}
 		(*VP8Decoder)(unsafe.Pointer(dec)).Falpha_prev_line = prev_line
 	} else { // alph_dec->method == ALPHA_LOSSLESS_COMPRESSION
 		if !(VP8LDecodeAlphaImageStream(tls, alph_dec, row+num_rows) != 0) {
 			return 0
 		}
 	}
 	if row+num_rows >= height {
 		(*VP8Decoder)(unsafe.Pointer(dec)).Fis_alpha_decoded = int32(1)
 	}
 	return int32(1)
 }
 
 func AllocateAlphaPlane(tls *libc.TLS, dec uintptr, io uintptr) (r int32) {
 	var alpha_size uint64_t
 	var height, stride int32
 	_, _, _ = alpha_size, height, stride
 	stride = (*VP8Io)(unsafe.Pointer(io)).Fwidth
 	height = (*VP8Io)(unsafe.Pointer(io)).Fcrop_bottom
 	alpha_size = libc.Uint64FromInt32(stride) * libc.Uint64FromInt32(height)
 	(*VP8Decoder)(unsafe.Pointer(dec)).Falpha_plane_mem = WebPSafeMalloc(tls, alpha_size, uint64(1))
 	if (*VP8Decoder)(unsafe.Pointer(dec)).Falpha_plane_mem == libc.UintptrFromInt32(0) {
 		return VP8SetError(tls, dec, int32(VP8_STATUS_OUT_OF_MEMORY), __ccgo_ts)
 	}
 	(*VP8Decoder)(unsafe.Pointer(dec)).Falpha_plane = (*VP8Decoder)(unsafe.Pointer(dec)).Falpha_plane_mem
 	(*VP8Decoder)(unsafe.Pointer(dec)).Falpha_prev_line = libc.UintptrFromInt32(0)
 	return int32(1)
 }
 
 func WebPDeallocateAlphaMemory(tls *libc.TLS, dec uintptr) {
 	WebPSafeFree(tls, (*VP8Decoder)(unsafe.Pointer(dec)).Falpha_plane_mem)
 	(*VP8Decoder)(unsafe.Pointer(dec)).Falpha_plane_mem = libc.UintptrFromInt32(0)
 	(*VP8Decoder)(unsafe.Pointer(dec)).Falpha_plane = libc.UintptrFromInt32(0)
 	ALPHDelete(tls, (*VP8Decoder)(unsafe.Pointer(dec)).Falph_dec)
 	(*VP8Decoder)(unsafe.Pointer(dec)).Falph_dec = libc.UintptrFromInt32(0)
 }
 
 // ------------------------------------------------------------------------------
 // Main entry point.
 func VP8DecompressAlphaRows(tls *libc.TLS, dec uintptr, io uintptr, row int32, num_rows int32) (r uintptr) {
 	var alpha, vp8l_dec uintptr
 	var height, width, v1 int32
 	_, _, _, _, _ = alpha, height, vp8l_dec, width, v1
 	width = (*VP8Io)(unsafe.Pointer(io)).Fwidth
 	height = (*VP8Io)(unsafe.Pointer(io)).Fcrop_bottom
 	if row < 0 || num_rows <= 0 || row+num_rows > height {
 		return libc.UintptrFromInt32(0)
 	}
 	if !((*VP8Decoder)(unsafe.Pointer(dec)).Fis_alpha_decoded != 0) {
 		if (*VP8Decoder)(unsafe.Pointer(dec)).Falph_dec == libc.UintptrFromInt32(0) { // Initialize decoder.
 			(*VP8Decoder)(unsafe.Pointer(dec)).Falph_dec = ALPHNew(tls)
 			if (*VP8Decoder)(unsafe.Pointer(dec)).Falph_dec == libc.UintptrFromInt32(0) {
 				VP8SetError(tls, dec, int32(VP8_STATUS_OUT_OF_MEMORY), __ccgo_ts)
 				return libc.UintptrFromInt32(0)
 			}
 			if !(AllocateAlphaPlane(tls, dec, io) != 0) {
 				goto Error
 			}
 			if !(ALPHInit(tls, (*VP8Decoder)(unsafe.Pointer(dec)).Falph_dec, (*VP8Decoder)(unsafe.Pointer(dec)).Falpha_data, (*VP8Decoder)(unsafe.Pointer(dec)).Falpha_data_size, io, (*VP8Decoder)(unsafe.Pointer(dec)).Falpha_plane) != 0) {
 				vp8l_dec = (*ALPHDecoder)(unsafe.Pointer((*VP8Decoder)(unsafe.Pointer(dec)).Falph_dec)).Fvp8l_dec
 				if vp8l_dec == libc.UintptrFromInt32(0) {
 					v1 = int32(VP8_STATUS_OUT_OF_MEMORY)
 				} else {
 					v1 = (*VP8LDecoder)(unsafe.Pointer(vp8l_dec)).Fstatus
 				}
 				VP8SetError(tls, dec, v1, __ccgo_ts)
 				goto Error
 			}
 			// if we allowed use of alpha dithering, check whether it's needed at all
 			if (*ALPHDecoder)(unsafe.Pointer((*VP8Decoder)(unsafe.Pointer(dec)).Falph_dec)).Fpre_processing != int32(ALPHA_PREPROCESSED_LEVELS) {
 				(*VP8Decoder)(unsafe.Pointer(dec)).Falpha_dithering = 0 // disable dithering
 			} else {
 				num_rows = height - row // decode everything in one pass
 			}
 		}
 		if !(ALPHDecode(tls, dec, row, num_rows) != 0) {
 			goto Error
 		}
 		if (*VP8Decoder)(unsafe.Pointer(dec)).Fis_alpha_decoded != 0 { // finished?
 			ALPHDelete(tls, (*VP8Decoder)(unsafe.Pointer(dec)).Falph_dec)
 			(*VP8Decoder)(unsafe.Pointer(dec)).Falph_dec = libc.UintptrFromInt32(0)
 			if (*VP8Decoder)(unsafe.Pointer(dec)).Falpha_dithering > 0 {
 				alpha = (*VP8Decoder)(unsafe.Pointer(dec)).Falpha_plane + uintptr((*VP8Io)(unsafe.Pointer(io)).Fcrop_top*width) + uintptr((*VP8Io)(unsafe.Pointer(io)).Fcrop_left)
 				if !(WebPDequantizeLevels(tls, alpha, (*VP8Io)(unsafe.Pointer(io)).Fcrop_right-(*VP8Io)(unsafe.Pointer(io)).Fcrop_left, (*VP8Io)(unsafe.Pointer(io)).Fcrop_bottom-(*VP8Io)(unsafe.Pointer(io)).Fcrop_top, width, (*VP8Decoder)(unsafe.Pointer(dec)).Falpha_dithering) != 0) {
 					goto Error
 				}
 			}
 		}
 	}
 	// Return a pointer to the current decoded row.
 	return (*VP8Decoder)(unsafe.Pointer(dec)).Falpha_plane + uintptr(row*width)
 	goto Error
 Error:
 	;
 	WebPDeallocateAlphaMemory(tls, dec)
 	return libc.UintptrFromInt32(0)
 }
 
 var kHashMul1 = uint32(0x1e35a7bd)
 
 //------------------------------------------------------------------------------
 
 // Copyright 2010 Google Inc. All Rights Reserved.
 //
 // Use of this source code is governed by a BSD-style license
 // that can be found in the COPYING file in the root of the source
 // tree. An additional intellectual property rights grant can be found
 // in the file PATENTS. All contributing project authors may
 // be found in the AUTHORS file in the root of the source tree.
 // -----------------------------------------------------------------------------
 //
 //  Main decoding functions for WebP images.
 //
 // Author: Skal (pascal.massimino@gmail.com)
 
 // Copyright 2010 Google Inc. All Rights Reserved.
 //
 // Use of this source code is governed by a BSD-style license
 // that can be found in the COPYING file in the root of the source
 // tree. An additional intellectual property rights grant can be found
 // in the file PATENTS. All contributing project authors may
 // be found in the AUTHORS file in the root of the source tree.
 // -----------------------------------------------------------------------------
 //
 //  Common types + memory wrappers
 //
 // Author: Skal (pascal.massimino@gmail.com)
 
 //------------------------------------------------------------------------------
 // WebPDecBuffer
 
 // C documentation
 //
 //	// Number of bytes per pixel for the different color-spaces.
 var kModeBpp = [13]uint8_t{
 	0:  uint8(3),
 	1:  uint8(4),
 	2:  uint8(3),
 	3:  uint8(4),
 	4:  uint8(4),
 	5:  uint8(2),
 	6:  uint8(2),
 	7:  uint8(4),
 	8:  uint8(4),
 	9:  uint8(4),
 	10: uint8(2),
 	11: uint8(1),
 	12: uint8(1),
 }
 
 // C documentation
 //
 //	// Convert to an integer to handle both the unsigned/signed enum cases
 //	// without the need for casting to remove type limit warnings.
 func IsValidColorspace(tls *libc.TLS, webp_csp_mode int32) (r int32) {
 	return libc.BoolInt32(webp_csp_mode >= int32(MODE_RGB) && webp_csp_mode < int32(MODE_LAST))
 }
 
 // strictly speaking, the very last (or first, if flipped) row
 // doesn't require padding.
 
 func CheckDecBuffer(tls *libc.TLS, buffer uintptr) (r VP8StatusCode1) {
 	var a_size, size, u_size, v_size, y_size uint64_t
 	var a_stride, height, ok, stride, u_stride, uv_height, uv_width, v_stride, width, y_stride, v1 int32
 	var buf, buf1 uintptr
 	var mode1 WEBP_CSP_MODE1
 	_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = a_size, a_stride, buf, buf1, height, mode1, ok, size, stride, u_size, u_stride, uv_height, uv_width, v_size, v_stride, width, y_size, y_stride, v1
 	ok = int32(1)
 	mode1 = (*WebPDecBuffer)(unsafe.Pointer(buffer)).Fcolorspace
 	width = (*WebPDecBuffer)(unsafe.Pointer(buffer)).Fwidth
 	height = (*WebPDecBuffer)(unsafe.Pointer(buffer)).Fheight
 	if !(IsValidColorspace(tls, mode1) != 0) {
 		ok = 0
 	} else {
 		v1 = libc.BoolInt32(mode1 < int32(MODE_YUV))
 		goto _2
 	_2:
 		if !(v1 != 0) { // YUV checks
 			buf = buffer + 16
 			uv_width = (width + int32(1)) / int32(2)
 			uv_height = (height + int32(1)) / int32(2)
 			y_stride = libc.Xabs(tls, (*WebPYUVABuffer)(unsafe.Pointer(buf)).Fy_stride)
 			u_stride = libc.Xabs(tls, (*WebPYUVABuffer)(unsafe.Pointer(buf)).Fu_stride)
 			v_stride = libc.Xabs(tls, (*WebPYUVABuffer)(unsafe.Pointer(buf)).Fv_stride)
 			a_stride = libc.Xabs(tls, (*WebPYUVABuffer)(unsafe.Pointer(buf)).Fa_stride)
 			y_size = libc.Uint64FromInt32(y_stride)*libc.Uint64FromInt32(height-libc.Int32FromInt32(1)) + libc.Uint64FromInt32(width)
 			u_size = libc.Uint64FromInt32(u_stride)*libc.Uint64FromInt32(uv_height-libc.Int32FromInt32(1)) + libc.Uint64FromInt32(uv_width)
 			v_size = libc.Uint64FromInt32(v_stride)*libc.Uint64FromInt32(uv_height-libc.Int32FromInt32(1)) + libc.Uint64FromInt32(uv_width)
 			a_size = libc.Uint64FromInt32(a_stride)*libc.Uint64FromInt32(height-libc.Int32FromInt32(1)) + libc.Uint64FromInt32(width)
 			ok = ok & libc.BoolInt32(y_size <= (*WebPYUVABuffer)(unsafe.Pointer(buf)).Fy_size)
 			ok = ok & libc.BoolInt32(u_size <= (*WebPYUVABuffer)(unsafe.Pointer(buf)).Fu_size)
 			ok = ok & libc.BoolInt32(v_size <= (*WebPYUVABuffer)(unsafe.Pointer(buf)).Fv_size)
 			ok = ok & libc.BoolInt32(y_stride >= width)
 			ok = ok & libc.BoolInt32(u_stride >= uv_width)
 			ok = ok & libc.BoolInt32(v_stride >= uv_width)
 			ok = ok & libc.BoolInt32((*WebPYUVABuffer)(unsafe.Pointer(buf)).Fy != libc.UintptrFromInt32(0))
 			ok = ok & libc.BoolInt32((*WebPYUVABuffer)(unsafe.Pointer(buf)).Fu != libc.UintptrFromInt32(0))
 			ok = ok & libc.BoolInt32((*WebPYUVABuffer)(unsafe.Pointer(buf)).Fv != libc.UintptrFromInt32(0))
 			if mode1 == int32(MODE_YUVA) {
 				ok = ok & libc.BoolInt32(a_stride >= width)
 				ok = ok & libc.BoolInt32(a_size <= (*WebPYUVABuffer)(unsafe.Pointer(buf)).Fa_size)
 				ok = ok & libc.BoolInt32((*WebPYUVABuffer)(unsafe.Pointer(buf)).Fa != libc.UintptrFromInt32(0))
 			}
 		} else { // RGB checks
 			buf1 = buffer + 16
 			stride = libc.Xabs(tls, (*WebPRGBABuffer)(unsafe.Pointer(buf1)).Fstride)
 			size = libc.Uint64FromInt32(stride)*libc.Uint64FromInt32(height-libc.Int32FromInt32(1)) + libc.Uint64FromInt32(width)*uint64(kModeBpp[mode1])
 			ok = ok & libc.BoolInt32(size <= (*WebPRGBABuffer)(unsafe.Pointer(buf1)).Fsize)
 			ok = ok & libc.BoolInt32(stride >= width*libc.Int32FromUint8(kModeBpp[mode1]))
 			ok = ok & libc.BoolInt32((*WebPRGBABuffer)(unsafe.Pointer(buf1)).Frgba != libc.UintptrFromInt32(0))
 		}
 	}
 	if ok != 0 {
 		v1 = int32(VP8_STATUS_OK)
 	} else {
 		v1 = int32(VP8_STATUS_INVALID_PARAM)
 	}
 	return v1
 }
 
 func AllocateBuffer(tls *libc.TLS, buffer uintptr) (r VP8StatusCode1) {
 	var a_size, size, total_size, uv_size uint64_t
 	var a_stride, h, stride, uv_stride, w, v1 int32
 	var buf, buf1, output uintptr
 	var mode1 WEBP_CSP_MODE1
 	_, _, _, _, _, _, _, _, _, _, _, _, _, _ = a_size, a_stride, buf, buf1, h, mode1, output, size, stride, total_size, uv_size, uv_stride, w, v1
 	w = (*WebPDecBuffer)(unsafe.Pointer(buffer)).Fwidth
 	h = (*WebPDecBuffer)(unsafe.Pointer(buffer)).Fheight
 	mode1 = (*WebPDecBuffer)(unsafe.Pointer(buffer)).Fcolorspace
 	if w <= 0 || h <= 0 || !(IsValidColorspace(tls, mode1) != 0) {
 		return int32(VP8_STATUS_INVALID_PARAM)
 	}
 	if (*WebPDecBuffer)(unsafe.Pointer(buffer)).Fis_external_memory <= 0 && (*WebPDecBuffer)(unsafe.Pointer(buffer)).Fprivate_memory == libc.UintptrFromInt32(0) {
 		uv_stride = 0
 		a_stride = 0
 		uv_size = uint64(0)
 		a_size = uint64(0)
 		if libc.Uint64FromInt32(w)*uint64(kModeBpp[mode1]) >= libc.Uint64FromUint64(1)<<libc.Int32FromInt32(31) {
 			return int32(VP8_STATUS_INVALID_PARAM)
 		}
 		stride = w * libc.Int32FromUint8(kModeBpp[mode1])
 		size = libc.Uint64FromInt32(stride) * libc.Uint64FromInt32(h)
 		v1 = libc.BoolInt32(mode1 < int32(MODE_YUV))
 		goto _2
 	_2:
 		if !(v1 != 0) {
 			uv_stride = (w + int32(1)) / int32(2)
 			uv_size = libc.Uint64FromInt32(uv_stride) * libc.Uint64FromInt32((h+libc.Int32FromInt32(1))/libc.Int32FromInt32(2))
 			if mode1 == int32(MODE_YUVA) {
 				a_stride = w
 				a_size = libc.Uint64FromInt32(a_stride) * libc.Uint64FromInt32(h)
 			}
 		}
 		total_size = size + uint64(2)*uv_size + a_size
 		output = WebPSafeMalloc(tls, total_size, uint64(1))
 		if output == libc.UintptrFromInt32(0) {
 			return int32(VP8_STATUS_OUT_OF_MEMORY)
 		}
 		(*WebPDecBuffer)(unsafe.Pointer(buffer)).Fprivate_memory = output
 		v1 = libc.BoolInt32(mode1 < int32(MODE_YUV))
 		goto _4
 	_4:
 		if !(v1 != 0) { // YUVA initialization
 			buf = buffer + 16
 			(*WebPYUVABuffer)(unsafe.Pointer(buf)).Fy = output
 			(*WebPYUVABuffer)(unsafe.Pointer(buf)).Fy_stride = stride
 			(*WebPYUVABuffer)(unsafe.Pointer(buf)).Fy_size = size
 			(*WebPYUVABuffer)(unsafe.Pointer(buf)).Fu = output + uintptr(size)
 			(*WebPYUVABuffer)(unsafe.Pointer(buf)).Fu_stride = uv_stride
 			(*WebPYUVABuffer)(unsafe.Pointer(buf)).Fu_size = uv_size
 			(*WebPYUVABuffer)(unsafe.Pointer(buf)).Fv = output + uintptr(size) + uintptr(uv_size)
 			(*WebPYUVABuffer)(unsafe.Pointer(buf)).Fv_stride = uv_stride
 			(*WebPYUVABuffer)(unsafe.Pointer(buf)).Fv_size = uv_size
 			if mode1 == int32(MODE_YUVA) {
 				(*WebPYUVABuffer)(unsafe.Pointer(buf)).Fa = output + uintptr(size) + uintptr(uint64(2)*uv_size)
 			}
 			(*WebPYUVABuffer)(unsafe.Pointer(buf)).Fa_size = a_size
 			(*WebPYUVABuffer)(unsafe.Pointer(buf)).Fa_stride = a_stride
 		} else { // RGBA initialization
 			buf1 = buffer + 16
 			(*WebPRGBABuffer)(unsafe.Pointer(buf1)).Frgba = output
 			(*WebPRGBABuffer)(unsafe.Pointer(buf1)).Fstride = stride
 			(*WebPRGBABuffer)(unsafe.Pointer(buf1)).Fsize = size
 		}
 	}
 	return CheckDecBuffer(tls, buffer)
 }
 
 func WebPFlipBuffer(tls *libc.TLS, buffer uintptr) (r VP8StatusCode1) {
 	var H int64_t
 	var buf, buf1 uintptr
 	var v1 int32
 	_, _, _, _ = H, buf, buf1, v1
 	if buffer == libc.UintptrFromInt32(0) {
 		return int32(VP8_STATUS_INVALID_PARAM)
 	}
 	v1 = libc.BoolInt32((*WebPDecBuffer)(unsafe.Pointer(buffer)).Fcolorspace < int32(MODE_YUV))
 	goto _2
 _2:
 	if v1 != 0 {
 		buf = buffer + 16
 		**(**uintptr)(__ccgo_up(buf)) += uintptr(int64((*WebPDecBuffer)(unsafe.Pointer(buffer)).Fheight-libc.Int32FromInt32(1)) * int64((*WebPRGBABuffer)(unsafe.Pointer(buf)).Fstride))
 		(*WebPRGBABuffer)(unsafe.Pointer(buf)).Fstride = -(*WebPRGBABuffer)(unsafe.Pointer(buf)).Fstride
 	} else {
 		buf1 = buffer + 16
 		H = int64((*WebPDecBuffer)(unsafe.Pointer(buffer)).Fheight)
 		**(**uintptr)(__ccgo_up(buf1)) += uintptr((H - int64(1)) * int64((*WebPYUVABuffer)(unsafe.Pointer(buf1)).Fy_stride))
 		(*WebPYUVABuffer)(unsafe.Pointer(buf1)).Fy_stride = -(*WebPYUVABuffer)(unsafe.Pointer(buf1)).Fy_stride
 		**(**uintptr)(__ccgo_up(buf1 + 8)) += uintptr((H - int64(1)) >> int32(1) * int64((*WebPYUVABuffer)(unsafe.Pointer(buf1)).Fu_stride))
 		(*WebPYUVABuffer)(unsafe.Pointer(buf1)).Fu_stride = -(*WebPYUVABuffer)(unsafe.Pointer(buf1)).Fu_stride
 		**(**uintptr)(__ccgo_up(buf1 + 16)) += uintptr((H - int64(1)) >> int32(1) * int64((*WebPYUVABuffer)(unsafe.Pointer(buf1)).Fv_stride))
 		(*WebPYUVABuffer)(unsafe.Pointer(buf1)).Fv_stride = -(*WebPYUVABuffer)(unsafe.Pointer(buf1)).Fv_stride
 		if (*WebPYUVABuffer)(unsafe.Pointer(buf1)).Fa != libc.UintptrFromInt32(0) {
 			**(**uintptr)(__ccgo_up(buf1 + 24)) += uintptr((H - int64(1)) * int64((*WebPYUVABuffer)(unsafe.Pointer(buf1)).Fa_stride))
 			(*WebPYUVABuffer)(unsafe.Pointer(buf1)).Fa_stride = -(*WebPYUVABuffer)(unsafe.Pointer(buf1)).Fa_stride
 		}
 	}
 	return int32(VP8_STATUS_OK)
 }
 
 func WebPAllocateDecBuffer(tls *libc.TLS, width int32, height int32, options uintptr, buffer uintptr) (r VP8StatusCode1) {
 	bp := tls.Alloc(16)
 	defer tls.Free(16)
 	var ch, cw, x, y int32
 	var status VP8StatusCode1
 	var _ /* scaled_height at bp+4 */ int32
 	var _ /* scaled_width at bp+0 */ int32
 	_, _, _, _, _ = ch, cw, status, x, y
 	if buffer == libc.UintptrFromInt32(0) || width <= 0 || height <= 0 {
 		return int32(VP8_STATUS_INVALID_PARAM)
 	}
 	if options != libc.UintptrFromInt32(0) { // First, apply options if there is any.
 		if (*WebPDecoderOptions)(unsafe.Pointer(options)).Fuse_cropping != 0 {
 			cw = (*WebPDecoderOptions)(unsafe.Pointer(options)).Fcrop_width
 			ch = (*WebPDecoderOptions)(unsafe.Pointer(options)).Fcrop_height
 			x = (*WebPDecoderOptions)(unsafe.Pointer(options)).Fcrop_left & ^libc.Int32FromInt32(1)
 			y = (*WebPDecoderOptions)(unsafe.Pointer(options)).Fcrop_top & ^libc.Int32FromInt32(1)
 			if !(WebPCheckCropDimensions(tls, width, height, x, y, cw, ch) != 0) {
 				return int32(VP8_STATUS_INVALID_PARAM) // out of frame boundary.
 			}
 			width = cw
 			height = ch
 		}
 		if (*WebPDecoderOptions)(unsafe.Pointer(options)).Fuse_scaling != 0 {
 			**(**int32)(__ccgo_up(bp)) = (*WebPDecoderOptions)(unsafe.Pointer(options)).Fscaled_width
 			**(**int32)(__ccgo_up(bp + 4)) = (*WebPDecoderOptions)(unsafe.Pointer(options)).Fscaled_height
 			if !(WebPRescalerGetScaledDimensions(tls, width, height, bp, bp+4) != 0) {
 				return int32(VP8_STATUS_INVALID_PARAM)
 			}
 			width = **(**int32)(__ccgo_up(bp))
 			height = **(**int32)(__ccgo_up(bp + 4))
 		}
 	}
 	(*WebPDecBuffer)(unsafe.Pointer(buffer)).Fwidth = width
 	(*WebPDecBuffer)(unsafe.Pointer(buffer)).Fheight = height
 	// Then, allocate buffer for real.
 	status = AllocateBuffer(tls, buffer)
 	if status != int32(VP8_STATUS_OK) {
 		return status
 	}
 	// Use the stride trick if vertical flip is needed.
 	if options != libc.UintptrFromInt32(0) && (*WebPDecoderOptions)(unsafe.Pointer(options)).Fflip != 0 {
 		status = WebPFlipBuffer(tls, buffer)
 	}
 	return status
 }
 
 //------------------------------------------------------------------------------
 // constructors / destructors
 
 func WebPInitDecBufferInternal(tls *libc.TLS, buffer uintptr, version int32) (r int32) {
 	if version>>int32(8) != libc.Int32FromInt32(WEBP_DECODER_ABI_VERSION)>>libc.Int32FromInt32(8) {
 		return 0 // version mismatch
 	}
 	if buffer == libc.UintptrFromInt32(0) {
 		return 0
 	}
 	libc.X__builtin___memset_chk(tls, buffer, 0, uint64(120), ^__predefined_size_t(0))
 	return int32(1)
 }
 
 func WebPFreeDecBuffer(tls *libc.TLS, buffer uintptr) {
 	if buffer != libc.UintptrFromInt32(0) {
 		if (*WebPDecBuffer)(unsafe.Pointer(buffer)).Fis_external_memory <= 0 {
 			WebPSafeFree(tls, (*WebPDecBuffer)(unsafe.Pointer(buffer)).Fprivate_memory)
 		}
 		(*WebPDecBuffer)(unsafe.Pointer(buffer)).Fprivate_memory = libc.UintptrFromInt32(0)
 	}
 }
 
 func WebPCopyDecBuffer(tls *libc.TLS, src uintptr, dst uintptr) {
 	if src != libc.UintptrFromInt32(0) && dst != libc.UintptrFromInt32(0) {
 		**(**WebPDecBuffer)(__ccgo_up(dst)) = **(**WebPDecBuffer)(__ccgo_up(src))
 		if (*WebPDecBuffer)(unsafe.Pointer(src)).Fprivate_memory != libc.UintptrFromInt32(0) {
 			(*WebPDecBuffer)(unsafe.Pointer(dst)).Fis_external_memory = int32(1) // dst buffer doesn't own the memory.
 			(*WebPDecBuffer)(unsafe.Pointer(dst)).Fprivate_memory = libc.UintptrFromInt32(0)
 		}
 	}
 }
 
 // C documentation
 //
 //	// Copy and transfer ownership from src to dst (beware of parameter order!)
 func WebPGrabDecBuffer(tls *libc.TLS, src uintptr, dst uintptr) {
 	if src != libc.UintptrFromInt32(0) && dst != libc.UintptrFromInt32(0) {
 		**(**WebPDecBuffer)(__ccgo_up(dst)) = **(**WebPDecBuffer)(__ccgo_up(src))
 		if (*WebPDecBuffer)(unsafe.Pointer(src)).Fprivate_memory != libc.UintptrFromInt32(0) {
 			(*WebPDecBuffer)(unsafe.Pointer(src)).Fis_external_memory = int32(1) // src relinquishes ownership
 			(*WebPDecBuffer)(unsafe.Pointer(src)).Fprivate_memory = libc.UintptrFromInt32(0)
 		}
 	}
 }
 
 func WebPCopyDecBufferPixels(tls *libc.TLS, src_buf uintptr, dst_buf uintptr) (r VP8StatusCode1) {
 	var dst, dst1, src, src1 uintptr
 	var v1, v4 int32
 	var v3, v6 WEBP_CSP_MODE1
 	var v9 bool
 	_, _, _, _, _, _, _, _, _ = dst, dst1, src, src1, v1, v3, v4, v6, v9
 	(*WebPDecBuffer)(unsafe.Pointer(dst_buf)).Fwidth = (*WebPDecBuffer)(unsafe.Pointer(src_buf)).Fwidth
 	(*WebPDecBuffer)(unsafe.Pointer(dst_buf)).Fheight = (*WebPDecBuffer)(unsafe.Pointer(src_buf)).Fheight
 	if CheckDecBuffer(tls, dst_buf) != int32(VP8_STATUS_OK) {
 		return int32(VP8_STATUS_INVALID_PARAM)
 	}
 	v1 = libc.BoolInt32((*WebPDecBuffer)(unsafe.Pointer(src_buf)).Fcolorspace < int32(MODE_YUV))
 	goto _2
 _2:
 	if v1 != 0 {
 		src = src_buf + 16
 		dst = dst_buf + 16
 		WebPCopyPlane(tls, (*WebPRGBABuffer)(unsafe.Pointer(src)).Frgba, (*WebPRGBABuffer)(unsafe.Pointer(src)).Fstride, (*WebPRGBABuffer)(unsafe.Pointer(dst)).Frgba, (*WebPRGBABuffer)(unsafe.Pointer(dst)).Fstride, (*WebPDecBuffer)(unsafe.Pointer(src_buf)).Fwidth*libc.Int32FromUint8(kModeBpp[(*WebPDecBuffer)(unsafe.Pointer(src_buf)).Fcolorspace]), (*WebPDecBuffer)(unsafe.Pointer(src_buf)).Fheight)
 	} else {
 		src1 = src_buf + 16
 		dst1 = dst_buf + 16
 		WebPCopyPlane(tls, (*WebPYUVABuffer)(unsafe.Pointer(src1)).Fy, (*WebPYUVABuffer)(unsafe.Pointer(src1)).Fy_stride, (*WebPYUVABuffer)(unsafe.Pointer(dst1)).Fy, (*WebPYUVABuffer)(unsafe.Pointer(dst1)).Fy_stride, (*WebPDecBuffer)(unsafe.Pointer(src_buf)).Fwidth, (*WebPDecBuffer)(unsafe.Pointer(src_buf)).Fheight)
 		WebPCopyPlane(tls, (*WebPYUVABuffer)(unsafe.Pointer(src1)).Fu, (*WebPYUVABuffer)(unsafe.Pointer(src1)).Fu_stride, (*WebPYUVABuffer)(unsafe.Pointer(dst1)).Fu, (*WebPYUVABuffer)(unsafe.Pointer(dst1)).Fu_stride, ((*WebPDecBuffer)(unsafe.Pointer(src_buf)).Fwidth+int32(1))/int32(2), ((*WebPDecBuffer)(unsafe.Pointer(src_buf)).Fheight+int32(1))/int32(2))
 		WebPCopyPlane(tls, (*WebPYUVABuffer)(unsafe.Pointer(src1)).Fv, (*WebPYUVABuffer)(unsafe.Pointer(src1)).Fv_stride, (*WebPYUVABuffer)(unsafe.Pointer(dst1)).Fv, (*WebPYUVABuffer)(unsafe.Pointer(dst1)).Fv_stride, ((*WebPDecBuffer)(unsafe.Pointer(src_buf)).Fwidth+int32(1))/int32(2), ((*WebPDecBuffer)(unsafe.Pointer(src_buf)).Fheight+int32(1))/int32(2))
 		v3 = (*WebPDecBuffer)(unsafe.Pointer(src_buf)).Fcolorspace
 		if v9 = v3 == int32(MODE_RGBA) || v3 == int32(MODE_BGRA) || v3 == int32(MODE_ARGB) || v3 == int32(MODE_RGBA_4444) || v3 == int32(MODE_YUVA); !v9 {
 			v6 = v3
 			v4 = libc.BoolInt32(v6 == int32(MODE_rgbA) || v6 == int32(MODE_bgrA) || v6 == int32(MODE_Argb) || v6 == int32(MODE_rgbA_4444))
 			goto _8
 		_8:
 		}
 		v1 = libc.BoolInt32(v9 || v4 != 0)
 		goto _5
 	_5:
 		if v1 != 0 {
 			WebPCopyPlane(tls, (*WebPYUVABuffer)(unsafe.Pointer(src1)).Fa, (*WebPYUVABuffer)(unsafe.Pointer(src1)).Fa_stride, (*WebPYUVABuffer)(unsafe.Pointer(dst1)).Fa, (*WebPYUVABuffer)(unsafe.Pointer(dst1)).Fa_stride, (*WebPDecBuffer)(unsafe.Pointer(src_buf)).Fwidth, (*WebPDecBuffer)(unsafe.Pointer(src_buf)).Fheight)
 		}
 	}
 	return int32(VP8_STATUS_OK)
 }
 
 func WebPAvoidSlowMemory(tls *libc.TLS, output uintptr, features uintptr) (r int32) {
 	var v1 WEBP_CSP_MODE1
 	var v2 int32
 	var v4 bool
 	_, _, _ = v1, v2, v4
 	if v4 = (*WebPDecBuffer)(unsafe.Pointer(output)).Fis_external_memory >= int32(2); v4 {
 		v1 = (*WebPDecBuffer)(unsafe.Pointer(output)).Fcolorspace
 		v2 = libc.BoolInt32(v1 == int32(MODE_rgbA) || v1 == int32(MODE_bgrA) || v1 == int32(MODE_Argb) || v1 == int32(MODE_rgbA_4444))
 		goto _3
 	_3:
 	}
 	return libc.BoolInt32(v4 && v2 != 0 && (features != libc.UintptrFromInt32(0) && (*WebPBitstreamFeatures)(unsafe.Pointer(features)).Fhas_alpha != 0))
 }
 
 const DITHER_AMP_TAB_SIZE = 12
 const MIN_DITHER_AMP = 4
 
 var kHashMul2 = uint32(0x1e35a7bd)
 
 //------------------------------------------------------------------------------
 
 // Copyright 2010 Google Inc. All Rights Reserved.
 //
 // Use of this source code is governed by a BSD-style license
 // that can be found in the COPYING file in the root of the source
 // tree. An additional intellectual property rights grant can be found
 // in the file PATENTS. All contributing project authors may
 // be found in the AUTHORS file in the root of the source tree.
 // -----------------------------------------------------------------------------
 //
 //  Main decoding functions for WebP images.
 //
 // Author: Skal (pascal.massimino@gmail.com)
 
 // Copyright 2010 Google Inc. All Rights Reserved.
 //
 // Use of this source code is governed by a BSD-style license
 // that can be found in the COPYING file in the root of the source
 // tree. An additional intellectual property rights grant can be found
 // in the file PATENTS. All contributing project authors may
 // be found in the AUTHORS file in the root of the source tree.
 // -----------------------------------------------------------------------------
 //
 //  Common types + memory wrappers
 //
 // Author: Skal (pascal.massimino@gmail.com)
 
 //------------------------------------------------------------------------------
 // Main reconstruction function.
 
 var kScan = [16]uint16_t{
 	1:  libc.Uint16FromInt32(libc.Int32FromInt32(4) + libc.Int32FromInt32(0)*libc.Int32FromInt32(BPS)),
 	2:  libc.Uint16FromInt32(libc.Int32FromInt32(8) + libc.Int32FromInt32(0)*libc.Int32FromInt32(BPS)),
 	3:  libc.Uint16FromInt32(libc.Int32FromInt32(12) + libc.Int32FromInt32(0)*libc.Int32FromInt32(BPS)),
 	4:  libc.Uint16FromInt32(libc.Int32FromInt32(0) + libc.Int32FromInt32(4)*libc.Int32FromInt32(BPS)),
 	5:  libc.Uint16FromInt32(libc.Int32FromInt32(4) + libc.Int32FromInt32(4)*libc.Int32FromInt32(BPS)),
 	6:  libc.Uint16FromInt32(libc.Int32FromInt32(8) + libc.Int32FromInt32(4)*libc.Int32FromInt32(BPS)),
 	7:  libc.Uint16FromInt32(libc.Int32FromInt32(12) + libc.Int32FromInt32(4)*libc.Int32FromInt32(BPS)),
 	8:  libc.Uint16FromInt32(libc.Int32FromInt32(0) + libc.Int32FromInt32(8)*libc.Int32FromInt32(BPS)),
 	9:  libc.Uint16FromInt32(libc.Int32FromInt32(4) + libc.Int32FromInt32(8)*libc.Int32FromInt32(BPS)),
 	10: libc.Uint16FromInt32(libc.Int32FromInt32(8) + libc.Int32FromInt32(8)*libc.Int32FromInt32(BPS)),
 	11: libc.Uint16FromInt32(libc.Int32FromInt32(12) + libc.Int32FromInt32(8)*libc.Int32FromInt32(BPS)),
 	12: libc.Uint16FromInt32(libc.Int32FromInt32(0) + libc.Int32FromInt32(12)*libc.Int32FromInt32(BPS)),
 	13: libc.Uint16FromInt32(libc.Int32FromInt32(4) + libc.Int32FromInt32(12)*libc.Int32FromInt32(BPS)),
 	14: libc.Uint16FromInt32(libc.Int32FromInt32(8) + libc.Int32FromInt32(12)*libc.Int32FromInt32(BPS)),
 	15: libc.Uint16FromInt32(libc.Int32FromInt32(12) + libc.Int32FromInt32(12)*libc.Int32FromInt32(BPS)),
 }
 
 func CheckMode(tls *libc.TLS, mb_x int32, mb_y int32, mode int32) (r int32) {
 	var v1 int32
 	_ = v1
 	if mode == int32(B_DC_PRED) {
 		if mb_x == 0 {
 			if mb_y == 0 {
 				v1 = int32(B_DC_PRED_NOTOPLEFT)
 			} else {
 				v1 = int32(B_DC_PRED_NOLEFT)
 			}
 			return v1
 		} else {
 			if mb_y == 0 {
 				v1 = int32(B_DC_PRED_NOTOP)
 			} else {
 				v1 = int32(B_DC_PRED)
 			}
 			return v1
 		}
 	}
 	return mode
 }
 
 func Copy32b(tls *libc.TLS, dst uintptr, src uintptr) {
 	libc.X__builtin___memcpy_chk(tls, dst, src, uint64(4), ^__predefined_size_t(0))
 }
 
 func DoTransform(tls *libc.TLS, bits uint32_t, src uintptr, dst uintptr) {
 	switch bits >> libc.Int32FromInt32(30) {
 	case uint32(3):
 		(*(*func(*libc.TLS, uintptr, uintptr, int32))(unsafe.Pointer(&struct{ uintptr }{VP8Transform})))(tls, src, dst, 0)
 	case uint32(2):
 		(*(*func(*libc.TLS, uintptr, uintptr))(unsafe.Pointer(&struct{ uintptr }{VP8TransformAC3})))(tls, src, dst)
 	case uint32(1):
 		(*(*func(*libc.TLS, uintptr, uintptr))(unsafe.Pointer(&struct{ uintptr }{VP8TransformDC})))(tls, src, dst)
 	default:
 		break
 	}
 }
 
 func DoUVTransform(tls *libc.TLS, bits uint32_t, src uintptr, dst uintptr) {
 	if bits&uint32(0xff) != 0 { // any non-zero coeff at all?
 		if bits&uint32(0xaa) != 0 { // any non-zero AC coefficient?
 			(*(*func(*libc.TLS, uintptr, uintptr))(unsafe.Pointer(&struct{ uintptr }{VP8TransformUV})))(tls, src, dst) // note we don't use the AC3 variant for U/V
 		} else {
 			(*(*func(*libc.TLS, uintptr, uintptr))(unsafe.Pointer(&struct{ uintptr }{VP8TransformDCUV})))(tls, src, dst)
 		}
 	}
 }
 
 func ReconstructRow(tls *libc.TLS, dec uintptr, ctx uintptr) {
 	var bits, bits_uv, v8, v9 uint32_t
 	var block, coeffs, dst, top_right, top_yuv, u_dst, u_out, v_dst, v_out, y_dst, y_out uintptr
 	var cache_id, j, mb_x, mb_y, n, pred_func, pred_func1, uv_offset, y_offset int32
 	var v3, v4 uint8_t
 	_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = bits, bits_uv, block, cache_id, coeffs, dst, j, mb_x, mb_y, n, pred_func, pred_func1, top_right, top_yuv, u_dst, u_out, uv_offset, v_dst, v_out, y_dst, y_offset, y_out, v3, v4, v8, v9
 	mb_y = (*VP8ThreadContext)(unsafe.Pointer(ctx)).Fmb_y
 	cache_id = (*VP8ThreadContext)(unsafe.Pointer(ctx)).Fid
 	y_dst = (*VP8Decoder)(unsafe.Pointer(dec)).Fyuv_b + uintptr(libc.Int32FromInt32(BPS)*libc.Int32FromInt32(1)+libc.Int32FromInt32(8))
 	u_dst = (*VP8Decoder)(unsafe.Pointer(dec)).Fyuv_b + uintptr(libc.Int32FromInt32(BPS)*libc.Int32FromInt32(1)+libc.Int32FromInt32(8)+libc.Int32FromInt32(BPS)*libc.Int32FromInt32(16)+libc.Int32FromInt32(BPS))
 	v_dst = (*VP8Decoder)(unsafe.Pointer(dec)).Fyuv_b + uintptr(libc.Int32FromInt32(BPS)*libc.Int32FromInt32(1)+libc.Int32FromInt32(8)+libc.Int32FromInt32(BPS)*libc.Int32FromInt32(16)+libc.Int32FromInt32(BPS)+libc.Int32FromInt32(16))
 	// Initialize left-most block.
 	j = 0
 	for {
 		if !(j < int32(16)) {
 			break
 		}
 		**(**uint8_t)(__ccgo_up(y_dst + uintptr(j*int32(BPS)-int32(1)))) = uint8(129)
 		goto _1
 	_1:
 		;
 		j = j + 1
 	}
 	j = 0
 	for {
 		if !(j < int32(8)) {
 			break
 		}
 		**(**uint8_t)(__ccgo_up(u_dst + uintptr(j*int32(BPS)-int32(1)))) = uint8(129)
 		**(**uint8_t)(__ccgo_up(v_dst + uintptr(j*int32(BPS)-int32(1)))) = uint8(129)
 		goto _2
 	_2:
 		;
 		j = j + 1
 	}
 	// Init top-left sample on left column too.
 	if mb_y > 0 {
 		v4 = libc.Uint8FromInt32(129)
 		**(**uint8_t)(__ccgo_up(v_dst + uintptr(-libc.Int32FromInt32(1)-libc.Int32FromInt32(BPS)))) = v4
 		v3 = v4
 		**(**uint8_t)(__ccgo_up(u_dst + uintptr(-libc.Int32FromInt32(1)-libc.Int32FromInt32(BPS)))) = v3
 		**(**uint8_t)(__ccgo_up(y_dst + uintptr(-libc.Int32FromInt32(1)-libc.Int32FromInt32(BPS)))) = v3
 	} else {
 		// we only need to do this init once at block (0,0).
 		// Afterward, it remains valid for the whole topmost row.
 		libc.X__builtin___memset_chk(tls, y_dst-uintptr(BPS)-uintptr(1), int32(127), libc.Uint64FromInt32(libc.Int32FromInt32(16)+libc.Int32FromInt32(4)+libc.Int32FromInt32(1)), ^__predefined_size_t(0))
 		libc.X__builtin___memset_chk(tls, u_dst-uintptr(BPS)-uintptr(1), int32(127), libc.Uint64FromInt32(libc.Int32FromInt32(8)+libc.Int32FromInt32(1)), ^__predefined_size_t(0))
 		libc.X__builtin___memset_chk(tls, v_dst-uintptr(BPS)-uintptr(1), int32(127), libc.Uint64FromInt32(libc.Int32FromInt32(8)+libc.Int32FromInt32(1)), ^__predefined_size_t(0))
 	}
 	// Reconstruct one row.
 	mb_x = 0
 	for {
 		if !(mb_x < (*VP8Decoder)(unsafe.Pointer(dec)).Fmb_w) {
 			break
 		}
 		block = (*VP8ThreadContext)(unsafe.Pointer(ctx)).Fmb_data + uintptr(mb_x)*800
 		// Rotate in the left samples from previously decoded block. We move four
 		// pixels at a time for alignment reason, and because of in-loop filter.
 		if mb_x > 0 {
 			j = -int32(1)
 			for {
 				if !(j < int32(16)) {
 					break
 				}
 				Copy32b(tls, y_dst+uintptr(j*int32(BPS)-int32(4)), y_dst+uintptr(j*int32(BPS)+int32(12)))
 				goto _6
 			_6:
 				;
 				j = j + 1
 			}
 			j = -int32(1)
 			for {
 				if !(j < int32(8)) {
 					break
 				}
 				Copy32b(tls, u_dst+uintptr(j*int32(BPS)-int32(4)), u_dst+uintptr(j*int32(BPS)+int32(4)))
 				Copy32b(tls, v_dst+uintptr(j*int32(BPS)-int32(4)), v_dst+uintptr(j*int32(BPS)+int32(4)))
 				goto _7
 			_7:
 				;
 				j = j + 1
 			}
 		}
 		// bring top samples into the cache
 		top_yuv = (*VP8Decoder)(unsafe.Pointer(dec)).Fyuv_t + uintptr(mb_x)*32
 		coeffs = block
 		bits = (*VP8MBData)(unsafe.Pointer(block)).Fnon_zero_y
 		if mb_y > 0 {
 			libc.X__builtin___memcpy_chk(tls, y_dst-uintptr(BPS), top_yuv, uint64(16), ^__predefined_size_t(0))
 			libc.X__builtin___memcpy_chk(tls, u_dst-uintptr(BPS), top_yuv+16, uint64(8), ^__predefined_size_t(0))
 			libc.X__builtin___memcpy_chk(tls, v_dst-uintptr(BPS), top_yuv+24, uint64(8), ^__predefined_size_t(0))
 		}
 		// predict and add residuals
 		if (*VP8MBData)(unsafe.Pointer(block)).Fis_i4x4 != 0 { // 4x4
 			top_right = y_dst - libc.UintptrFromInt32(BPS) + libc.UintptrFromInt32(16)
 			if mb_y > 0 {
 				if mb_x >= (*VP8Decoder)(unsafe.Pointer(dec)).Fmb_w-int32(1) { // on rightmost border
 					libc.X__builtin___memset_chk(tls, top_right, libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(top_yuv + 15))), uint64(4), ^__predefined_size_t(0))
 				} else {
 					libc.X__builtin___memcpy_chk(tls, top_right, top_yuv+1*32, uint64(4), ^__predefined_size_t(0))
 				}
 			}
 			// replicate the top-right pixels below
 			v9 = **(**uint32_t)(__ccgo_up(top_right))
 			**(**uint32_t)(__ccgo_up(top_right + uintptr(libc.Int32FromInt32(3)*libc.Int32FromInt32(BPS))*4)) = v9
 			v8 = v9
 			**(**uint32_t)(__ccgo_up(top_right + uintptr(libc.Int32FromInt32(2)*libc.Int32FromInt32(BPS))*4)) = v8
 			**(**uint32_t)(__ccgo_up(top_right + 32*4)) = v8
 			// predict and add residuals for all 4x4 blocks in turn.
 			n = 0
 			for {
 				if !(n < int32(16)) {
 					break
 				}
 				dst = y_dst + uintptr(kScan[n])
 				(*(*func(*libc.TLS, uintptr))(unsafe.Pointer(&struct{ uintptr }{VP8PredLuma4[**(**uint8_t)(__ccgo_up(block + 769 + uintptr(n)))]})))(tls, dst)
 				DoTransform(tls, bits, coeffs+uintptr(n*int32(16))*2, dst)
 				goto _10
 			_10:
 				;
 				n = n + 1
 				bits = bits << uint32(2)
 			}
 		} else { // 16x16
 			pred_func = CheckMode(tls, mb_x, mb_y, libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(block + 769))))
 			(*(*func(*libc.TLS, uintptr))(unsafe.Pointer(&struct{ uintptr }{VP8PredLuma16[pred_func]})))(tls, y_dst)
 			if bits != uint32(0) {
 				n = 0
 				for {
 					if !(n < int32(16)) {
 						break
 					}
 					DoTransform(tls, bits, coeffs+uintptr(n*int32(16))*2, y_dst+uintptr(kScan[n]))
 					goto _11
 				_11:
 					;
 					n = n + 1
 					bits = bits << uint32(2)
 				}
 			}
 		}
 		// Chroma
 		bits_uv = (*VP8MBData)(unsafe.Pointer(block)).Fnon_zero_uv
 		pred_func1 = CheckMode(tls, mb_x, mb_y, libc.Int32FromUint8((*VP8MBData)(unsafe.Pointer(block)).Fuvmode))
 		(*(*func(*libc.TLS, uintptr))(unsafe.Pointer(&struct{ uintptr }{VP8PredChroma8[pred_func1]})))(tls, u_dst)
 		(*(*func(*libc.TLS, uintptr))(unsafe.Pointer(&struct{ uintptr }{VP8PredChroma8[pred_func1]})))(tls, v_dst)
 		DoUVTransform(tls, bits_uv>>0, coeffs+uintptr(libc.Int32FromInt32(16)*libc.Int32FromInt32(16))*2, u_dst)
 		DoUVTransform(tls, bits_uv>>int32(8), coeffs+uintptr(libc.Int32FromInt32(20)*libc.Int32FromInt32(16))*2, v_dst)
 		// stash away top samples for next block
 		if mb_y < (*VP8Decoder)(unsafe.Pointer(dec)).Fmb_h-int32(1) {
 			libc.X__builtin___memcpy_chk(tls, top_yuv, y_dst+uintptr(libc.Int32FromInt32(15)*libc.Int32FromInt32(BPS)), uint64(16), ^__predefined_size_t(0))
 			libc.X__builtin___memcpy_chk(tls, top_yuv+16, u_dst+uintptr(libc.Int32FromInt32(7)*libc.Int32FromInt32(BPS)), uint64(8), ^__predefined_size_t(0))
 			libc.X__builtin___memcpy_chk(tls, top_yuv+24, v_dst+uintptr(libc.Int32FromInt32(7)*libc.Int32FromInt32(BPS)), uint64(8), ^__predefined_size_t(0))
 		}
 		// Transfer reconstructed samples from yuv_b cache to final destination.
 		y_offset = cache_id * int32(16) * (*VP8Decoder)(unsafe.Pointer(dec)).Fcache_y_stride
 		uv_offset = cache_id * int32(8) * (*VP8Decoder)(unsafe.Pointer(dec)).Fcache_uv_stride
 		y_out = (*VP8Decoder)(unsafe.Pointer(dec)).Fcache_y + uintptr(mb_x*int32(16)) + uintptr(y_offset)
 		u_out = (*VP8Decoder)(unsafe.Pointer(dec)).Fcache_u + uintptr(mb_x*int32(8)) + uintptr(uv_offset)
 		v_out = (*VP8Decoder)(unsafe.Pointer(dec)).Fcache_v + uintptr(mb_x*int32(8)) + uintptr(uv_offset)
 		j = 0
 		for {
 			if !(j < int32(16)) {
 				break
 			}
 			libc.X__builtin___memcpy_chk(tls, y_out+uintptr(j*(*VP8Decoder)(unsafe.Pointer(dec)).Fcache_y_stride), y_dst+uintptr(j*int32(BPS)), uint64(16), ^__predefined_size_t(0))
 			goto _12
 		_12:
 			;
 			j = j + 1
 		}
 		j = 0
 		for {
 			if !(j < int32(8)) {
 				break
 			}
 			libc.X__builtin___memcpy_chk(tls, u_out+uintptr(j*(*VP8Decoder)(unsafe.Pointer(dec)).Fcache_uv_stride), u_dst+uintptr(j*int32(BPS)), uint64(8), ^__predefined_size_t(0))
 			libc.X__builtin___memcpy_chk(tls, v_out+uintptr(j*(*VP8Decoder)(unsafe.Pointer(dec)).Fcache_uv_stride), v_dst+uintptr(j*int32(BPS)), uint64(8), ^__predefined_size_t(0))
 			goto _13
 		_13:
 			;
 			j = j + 1
 		}
 		goto _5
 	_5:
 		;
 		mb_x = mb_x + 1
 	}
 }
 
 //------------------------------------------------------------------------------
 // Filtering
 
 // C documentation
 //
 //	// kFilterExtraRows[] = How many extra lines are needed on the MB boundary
 //	// for caching, given a filtering level.
 //	// Simple filter:  up to 2 luma samples are read and 1 is written.
 //	// Complex filter: up to 4 luma samples are read and 3 are written. Same for
 //	//                 U/V, so it's 8 samples total (because of the 2x upsampling).
 var kFilterExtraRows = [3]uint8_t{
 	1: uint8(2),
 	2: uint8(8),
 }
 
 func DoFilter(tls *libc.TLS, dec uintptr, mb_x int32, mb_y int32) {
 	var cache_id, hev_thresh, ilevel, limit, uv_bps, y_bps int32
 	var ctx, f_info, u_dst, v_dst, y_dst uintptr
 	_, _, _, _, _, _, _, _, _, _, _ = cache_id, ctx, f_info, hev_thresh, ilevel, limit, u_dst, uv_bps, v_dst, y_bps, y_dst
 	ctx = dec + 216
 	cache_id = (*VP8ThreadContext)(unsafe.Pointer(ctx)).Fid
 	y_bps = (*VP8Decoder)(unsafe.Pointer(dec)).Fcache_y_stride
 	f_info = (*VP8ThreadContext)(unsafe.Pointer(ctx)).Ff_info + uintptr(mb_x)*4
 	y_dst = (*VP8Decoder)(unsafe.Pointer(dec)).Fcache_y + uintptr(cache_id*int32(16)*y_bps) + uintptr(mb_x*int32(16))
 	ilevel = libc.Int32FromUint8((*VP8FInfo)(unsafe.Pointer(f_info)).Ff_ilevel)
 	limit = libc.Int32FromUint8((*VP8FInfo)(unsafe.Pointer(f_info)).Ff_limit)
 	if limit == 0 {
 		return
 	}
 	if (*VP8Decoder)(unsafe.Pointer(dec)).Ffilter_type == int32(1) { // simple
 		if mb_x > 0 {
 			(*(*func(*libc.TLS, uintptr, int32, int32))(unsafe.Pointer(&struct{ uintptr }{VP8SimpleHFilter16})))(tls, y_dst, y_bps, limit+int32(4))
 		}
 		if (*VP8FInfo)(unsafe.Pointer(f_info)).Ff_inner != 0 {
 			(*(*func(*libc.TLS, uintptr, int32, int32))(unsafe.Pointer(&struct{ uintptr }{VP8SimpleHFilter16i})))(tls, y_dst, y_bps, limit)
 		}
 		if mb_y > 0 {
 			(*(*func(*libc.TLS, uintptr, int32, int32))(unsafe.Pointer(&struct{ uintptr }{VP8SimpleVFilter16})))(tls, y_dst, y_bps, limit+int32(4))
 		}
 		if (*VP8FInfo)(unsafe.Pointer(f_info)).Ff_inner != 0 {
 			(*(*func(*libc.TLS, uintptr, int32, int32))(unsafe.Pointer(&struct{ uintptr }{VP8SimpleVFilter16i})))(tls, y_dst, y_bps, limit)
 		}
 	} else { // complex
 		uv_bps = (*VP8Decoder)(unsafe.Pointer(dec)).Fcache_uv_stride
 		u_dst = (*VP8Decoder)(unsafe.Pointer(dec)).Fcache_u + uintptr(cache_id*int32(8)*uv_bps) + uintptr(mb_x*int32(8))
 		v_dst = (*VP8Decoder)(unsafe.Pointer(dec)).Fcache_v + uintptr(cache_id*int32(8)*uv_bps) + uintptr(mb_x*int32(8))
 		hev_thresh = libc.Int32FromUint8((*VP8FInfo)(unsafe.Pointer(f_info)).Fhev_thresh)
 		if mb_x > 0 {
 			(*(*func(*libc.TLS, uintptr, int32, int32, int32, int32))(unsafe.Pointer(&struct{ uintptr }{VP8HFilter16})))(tls, y_dst, y_bps, limit+int32(4), ilevel, hev_thresh)
 			(*(*func(*libc.TLS, uintptr, uintptr, int32, int32, int32, int32))(unsafe.Pointer(&struct{ uintptr }{VP8HFilter8})))(tls, u_dst, v_dst, uv_bps, limit+int32(4), ilevel, hev_thresh)
 		}
 		if (*VP8FInfo)(unsafe.Pointer(f_info)).Ff_inner != 0 {
 			(*(*func(*libc.TLS, uintptr, int32, int32, int32, int32))(unsafe.Pointer(&struct{ uintptr }{VP8HFilter16i})))(tls, y_dst, y_bps, limit, ilevel, hev_thresh)
 			(*(*func(*libc.TLS, uintptr, uintptr, int32, int32, int32, int32))(unsafe.Pointer(&struct{ uintptr }{VP8HFilter8i})))(tls, u_dst, v_dst, uv_bps, limit, ilevel, hev_thresh)
 		}
 		if mb_y > 0 {
 			(*(*func(*libc.TLS, uintptr, int32, int32, int32, int32))(unsafe.Pointer(&struct{ uintptr }{VP8VFilter16})))(tls, y_dst, y_bps, limit+int32(4), ilevel, hev_thresh)
 			(*(*func(*libc.TLS, uintptr, uintptr, int32, int32, int32, int32))(unsafe.Pointer(&struct{ uintptr }{VP8VFilter8})))(tls, u_dst, v_dst, uv_bps, limit+int32(4), ilevel, hev_thresh)
 		}
 		if (*VP8FInfo)(unsafe.Pointer(f_info)).Ff_inner != 0 {
 			(*(*func(*libc.TLS, uintptr, int32, int32, int32, int32))(unsafe.Pointer(&struct{ uintptr }{VP8VFilter16i})))(tls, y_dst, y_bps, limit, ilevel, hev_thresh)
 			(*(*func(*libc.TLS, uintptr, uintptr, int32, int32, int32, int32))(unsafe.Pointer(&struct{ uintptr }{VP8VFilter8i})))(tls, u_dst, v_dst, uv_bps, limit, ilevel, hev_thresh)
 		}
 	}
 }
 
 // C documentation
 //
 //	// Filter the decoded macroblock row (if needed)
 func FilterRow(tls *libc.TLS, dec uintptr) {
 	var mb_x, mb_y int32
 	_, _ = mb_x, mb_y
 	mb_y = (*VP8Decoder)(unsafe.Pointer(dec)).Fthread_ctx.Fmb_y
 	mb_x = (*VP8Decoder)(unsafe.Pointer(dec)).Ftl_mb_x
 	for {
 		if !(mb_x < (*VP8Decoder)(unsafe.Pointer(dec)).Fbr_mb_x) {
 			break
 		}
 		DoFilter(tls, dec, mb_x, mb_y)
 		goto _1
 	_1:
 		;
 		mb_x = mb_x + 1
 	}
 }
 
 //------------------------------------------------------------------------------
 // Precompute the filtering strength for each segment and each i4x4/i16x16 mode.
 
 func PrecomputeFilterStrengths(tls *libc.TLS, dec uintptr) {
 	var base_level, i4x4, ilevel, level, s, v3, v4 int32
 	var hdr, info uintptr
 	_, _, _, _, _, _, _, _, _ = base_level, hdr, i4x4, ilevel, info, level, s, v3, v4
 	if (*VP8Decoder)(unsafe.Pointer(dec)).Ffilter_type > 0 {
 		hdr = dec + 84
 		s = 0
 		for {
 			if !(s < int32(NUM_MB_SEGMENTS)) {
 				break
 			}
 			if (*VP8Decoder)(unsafe.Pointer(dec)).Fsegment_hdr.Fuse_segment != 0 {
 				base_level = int32(**(**int8_t)(__ccgo_up(dec + 132 + 16 + uintptr(s))))
 				if !((*VP8Decoder)(unsafe.Pointer(dec)).Fsegment_hdr.Fabsolute_delta != 0) {
 					base_level = base_level + (*VP8FilterHeader)(unsafe.Pointer(hdr)).Flevel
 				}
 			} else {
 				base_level = (*VP8FilterHeader)(unsafe.Pointer(hdr)).Flevel
 			}
 			i4x4 = 0
 			for {
 				if !(i4x4 <= int32(1)) {
 					break
 				}
 				info = dec + 2924 + uintptr(s)*8 + uintptr(i4x4)*4
 				level = base_level
 				if (*VP8FilterHeader)(unsafe.Pointer(hdr)).Fuse_lf_delta != 0 {
 					level = level + **(**int32)(__ccgo_up(hdr + 16))
 					if i4x4 != 0 {
 						level = level + **(**int32)(__ccgo_up(hdr + 32))
 					}
 				}
 				if level < 0 {
 					v3 = 0
 				} else {
 					if level > int32(63) {
 						v4 = int32(63)
 					} else {
 						v4 = level
 					}
 					v3 = v4
 				}
 				level = v3
 				if level > 0 {
 					ilevel = level
 					if (*VP8FilterHeader)(unsafe.Pointer(hdr)).Fsharpness > 0 {
 						if (*VP8FilterHeader)(unsafe.Pointer(hdr)).Fsharpness > int32(4) {
 							ilevel = ilevel >> int32(2)
 						} else {
 							ilevel = ilevel >> int32(1)
 						}
 						if ilevel > int32(9)-(*VP8FilterHeader)(unsafe.Pointer(hdr)).Fsharpness {
 							ilevel = int32(9) - (*VP8FilterHeader)(unsafe.Pointer(hdr)).Fsharpness
 						}
 					}
 					if ilevel < int32(1) {
 						ilevel = int32(1)
 					}
 					(*VP8FInfo)(unsafe.Pointer(info)).Ff_ilevel = libc.Uint8FromInt32(ilevel)
 					(*VP8FInfo)(unsafe.Pointer(info)).Ff_limit = libc.Uint8FromInt32(int32(2)*level + ilevel)
 					if level >= int32(40) {
 						v3 = int32(2)
 					} else {
 						if level >= int32(15) {
 							v4 = int32(1)
 						} else {
 							v4 = 0
 						}
 						v3 = v4
 					}
 					(*VP8FInfo)(unsafe.Pointer(info)).Fhev_thresh = libc.Uint8FromInt32(v3)
 				} else {
 					(*VP8FInfo)(unsafe.Pointer(info)).Ff_limit = uint8(0) // no filtering
 				}
 				(*VP8FInfo)(unsafe.Pointer(info)).Ff_inner = libc.Uint8FromInt32(i4x4)
 				goto _2
 			_2:
 				;
 				i4x4 = i4x4 + 1
 			}
 			goto _1
 		_1:
 			;
 			s = s + 1
 		}
 	}
 }
 
 //------------------------------------------------------------------------------
 // Dithering
 
 // minimal amp that will provide a non-zero dithering effect
 
 var kQuantToDitherAmp = [12]uint8_t{
 	0:  uint8(8),
 	1:  uint8(7),
 	2:  uint8(6),
 	3:  uint8(4),
 	4:  uint8(4),
 	5:  uint8(2),
 	6:  uint8(2),
 	7:  uint8(2),
 	8:  uint8(1),
 	9:  uint8(1),
 	10: uint8(1),
 	11: uint8(1),
 }
 
 func VP8InitDithering(tls *libc.TLS, options uintptr, dec uintptr) {
 	var all_amp, d, f, idx, max_amp, s, v1, v2, v4 int32
 	var dqm uintptr
 	_, _, _, _, _, _, _, _, _, _ = all_amp, d, dqm, f, idx, max_amp, s, v1, v2, v4
 	if options != libc.UintptrFromInt32(0) {
 		d = (*WebPDecoderOptions)(unsafe.Pointer(options)).Fdithering_strength
 		max_amp = libc.Int32FromInt32(1)<<libc.Int32FromInt32(VP8_RANDOM_DITHER_FIX) - libc.Int32FromInt32(1)
 		if d < 0 {
 			v1 = 0
 		} else {
 			if d > int32(100) {
 				v2 = max_amp
 			} else {
 				v2 = d * max_amp / int32(100)
 			}
 			v1 = v2
 		}
 		f = v1
 		if f > 0 {
 			all_amp = 0
 			s = 0
 			for {
 				if !(s < int32(NUM_MB_SEGMENTS)) {
 					break
 				}
 				dqm = dec + 1060 + uintptr(s)*32
 				if (*VP8QuantMatrix)(unsafe.Pointer(dqm)).Fuv_quant < int32(DITHER_AMP_TAB_SIZE) {
 					if (*VP8QuantMatrix)(unsafe.Pointer(dqm)).Fuv_quant < 0 {
 						v4 = 0
 					} else {
 						v4 = (*VP8QuantMatrix)(unsafe.Pointer(dqm)).Fuv_quant
 					}
 					idx = v4
 					(*VP8QuantMatrix)(unsafe.Pointer(dqm)).Fdither = f * libc.Int32FromUint8(kQuantToDitherAmp[idx]) >> int32(3)
 				}
 				all_amp = all_amp | (*VP8QuantMatrix)(unsafe.Pointer(dqm)).Fdither
 				goto _3
 			_3:
 				;
 				s = s + 1
 			}
 			if all_amp != 0 {
 				VP8InitRandom(tls, dec+828, libc.Float32FromFloat32(1))
 				(*VP8Decoder)(unsafe.Pointer(dec)).Fdither = int32(1)
 			}
 		}
 		// potentially allow alpha dithering
 		(*VP8Decoder)(unsafe.Pointer(dec)).Falpha_dithering = (*WebPDecoderOptions)(unsafe.Pointer(options)).Falpha_dithering_strength
 		if (*VP8Decoder)(unsafe.Pointer(dec)).Falpha_dithering > int32(100) {
 			(*VP8Decoder)(unsafe.Pointer(dec)).Falpha_dithering = int32(100)
 		} else {
 			if (*VP8Decoder)(unsafe.Pointer(dec)).Falpha_dithering < 0 {
 				(*VP8Decoder)(unsafe.Pointer(dec)).Falpha_dithering = 0
 			}
 		}
 	}
 }
 
 // C documentation
 //
 //	// Convert to range: [-2,2] for dither=50, [-4,4] for dither=100
 func Dither8x8(tls *libc.TLS, rg1 uintptr, dst uintptr, bps int32, amp1 int32) {
 	bp := tls.Alloc(64)
 	defer tls.Free(64)
 	var diff, i, v3, v4, v6, v8 int32
 	var v2, v5, v7 uintptr
 	var _ /* dither at bp+0 */ [64]uint8_t
 	_, _, _, _, _, _, _, _, _ = diff, i, v2, v3, v4, v5, v6, v7, v8
 	i = 0
 	for {
 		if !(i < libc.Int32FromInt32(8)*libc.Int32FromInt32(8)) {
 			break
 		}
 		v2 = rg1
 		v3 = libc.Int32FromInt32(VP8_DITHER_AMP_BITS) + libc.Int32FromInt32(1)
 		diff = libc.Int32FromUint32(**(**uint32_t)(__ccgo_up(v2 + 8 + uintptr((*VP8Random)(unsafe.Pointer(v2)).Findex1)*4)) - **(**uint32_t)(__ccgo_up(v2 + 8 + uintptr((*VP8Random)(unsafe.Pointer(v2)).Findex2)*4)))
 		if diff < libc.Int32FromInt32(0) {
 			diff = libc.Int32FromUint32(uint32(diff) + libc.Uint32FromUint32(1)<<libc.Int32FromInt32(31))
 		}
 		**(**uint32_t)(__ccgo_up(v2 + 8 + uintptr((*VP8Random)(unsafe.Pointer(v2)).Findex1)*4)) = libc.Uint32FromInt32(diff)
 		v5 = v2
 		*(*int32)(unsafe.Pointer(v5)) = *(*int32)(unsafe.Pointer(v5)) + 1
 		v4 = *(*int32)(unsafe.Pointer(v5))
 		if v4 == libc.Int32FromInt32(VP8_RANDOM_TABLE_SIZE) {
 			(*VP8Random)(unsafe.Pointer(v2)).Findex1 = 0
 		}
 		v7 = v2 + 4
 		*(*int32)(unsafe.Pointer(v7)) = *(*int32)(unsafe.Pointer(v7)) + 1
 		v6 = *(*int32)(unsafe.Pointer(v7))
 		if v6 == libc.Int32FromInt32(VP8_RANDOM_TABLE_SIZE) {
 			(*VP8Random)(unsafe.Pointer(v2)).Findex2 = 0
 		}
 		diff = libc.Int32FromUint32(libc.Uint32FromInt32(diff)<<libc.Int32FromInt32(1)) >> (int32(32) - v3)
 		diff = diff * amp1 >> int32(VP8_RANDOM_DITHER_FIX)
 		diff = diff + int32(1)<<(v3-int32(1))
 		v8 = diff
 		goto _9
 	_9:
 		(**(**[64]uint8_t)(__ccgo_up(bp)))[i] = libc.Uint8FromInt32(v8)
 		goto _1
 	_1:
 		;
 		i = i + 1
 	}
 	(*(*func(*libc.TLS, uintptr, uintptr, int32))(unsafe.Pointer(&struct{ uintptr }{VP8DitherCombine8x8})))(tls, bp, dst, bps)
 }
 
 func DitherRow(tls *libc.TLS, dec uintptr) {
 	var cache_id, mb_x, uv_bps int32
 	var ctx, data, u_dst, v_dst uintptr
 	_, _, _, _, _, _, _ = cache_id, ctx, data, mb_x, u_dst, uv_bps, v_dst
 	mb_x = (*VP8Decoder)(unsafe.Pointer(dec)).Ftl_mb_x
 	for {
 		if !(mb_x < (*VP8Decoder)(unsafe.Pointer(dec)).Fbr_mb_x) {
 			break
 		}
 		ctx = dec + 216
 		data = (*VP8ThreadContext)(unsafe.Pointer(ctx)).Fmb_data + uintptr(mb_x)*800
 		cache_id = (*VP8ThreadContext)(unsafe.Pointer(ctx)).Fid
 		uv_bps = (*VP8Decoder)(unsafe.Pointer(dec)).Fcache_uv_stride
 		if libc.Int32FromUint8((*VP8MBData)(unsafe.Pointer(data)).Fdither) >= int32(MIN_DITHER_AMP) {
 			u_dst = (*VP8Decoder)(unsafe.Pointer(dec)).Fcache_u + uintptr(cache_id*int32(8)*uv_bps) + uintptr(mb_x*int32(8))
 			v_dst = (*VP8Decoder)(unsafe.Pointer(dec)).Fcache_v + uintptr(cache_id*int32(8)*uv_bps) + uintptr(mb_x*int32(8))
 			Dither8x8(tls, dec+828, u_dst, uv_bps, libc.Int32FromUint8((*VP8MBData)(unsafe.Pointer(data)).Fdither))
 			Dither8x8(tls, dec+828, v_dst, uv_bps, libc.Int32FromUint8((*VP8MBData)(unsafe.Pointer(data)).Fdither))
 		}
 		goto _1
 	_1:
 		;
 		mb_x = mb_x + 1
 	}
 }
 
 //------------------------------------------------------------------------------
 // This function is called after a row of macroblocks is finished decoding.
 // It also takes into account the following restrictions:
 //  * In case of in-loop filtering, we must hold off sending some of the bottom
 //    pixels as they are yet unfiltered. They will be when the next macroblock
 //    row is decoded. Meanwhile, we must preserve them by rotating them in the
 //    cache area. This doesn't hold for the very bottom row of the uncropped
 //    picture of course.
 //  * we must clip the remaining pixels against the cropping area. The VP8Io
 //    struct must have the following fields set correctly before calling put():
 
 // C documentation
 //
 //	// Finalize and transmit a complete row. Return false in case of user-abort.
 func FinishRow(tls *libc.TLS, arg1 uintptr, arg2 uintptr) (r int32) {
 	var cache_id, delta_y, extra_y_rows, is_first_row, is_last_row, mb_y, ok, uv_offset, uvsize, y_end, y_offset, y_start, ysize int32
 	var ctx, dec, io, udst, vdst, ydst uintptr
 	_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = cache_id, ctx, dec, delta_y, extra_y_rows, io, is_first_row, is_last_row, mb_y, ok, udst, uv_offset, uvsize, vdst, y_end, y_offset, y_start, ydst, ysize
 	dec = arg1
 	io = arg2
 	ok = int32(1)
 	ctx = dec + 216
 	cache_id = (*VP8ThreadContext)(unsafe.Pointer(ctx)).Fid
 	extra_y_rows = libc.Int32FromUint8(kFilterExtraRows[(*VP8Decoder)(unsafe.Pointer(dec)).Ffilter_type])
 	ysize = extra_y_rows * (*VP8Decoder)(unsafe.Pointer(dec)).Fcache_y_stride
 	uvsize = extra_y_rows / int32(2) * (*VP8Decoder)(unsafe.Pointer(dec)).Fcache_uv_stride
 	y_offset = cache_id * int32(16) * (*VP8Decoder)(unsafe.Pointer(dec)).Fcache_y_stride
 	uv_offset = cache_id * int32(8) * (*VP8Decoder)(unsafe.Pointer(dec)).Fcache_uv_stride
 	ydst = (*VP8Decoder)(unsafe.Pointer(dec)).Fcache_y - uintptr(ysize) + uintptr(y_offset)
 	udst = (*VP8Decoder)(unsafe.Pointer(dec)).Fcache_u - uintptr(uvsize) + uintptr(uv_offset)
 	vdst = (*VP8Decoder)(unsafe.Pointer(dec)).Fcache_v - uintptr(uvsize) + uintptr(uv_offset)
 	mb_y = (*VP8ThreadContext)(unsafe.Pointer(ctx)).Fmb_y
 	is_first_row = libc.BoolInt32(mb_y == libc.Int32FromInt32(0))
 	is_last_row = libc.BoolInt32(mb_y >= (*VP8Decoder)(unsafe.Pointer(dec)).Fbr_mb_y-libc.Int32FromInt32(1))
 	if (*VP8Decoder)(unsafe.Pointer(dec)).Fmt_method == int32(2) {
 		ReconstructRow(tls, dec, ctx)
 	}
 	if (*VP8ThreadContext)(unsafe.Pointer(ctx)).Ffilter_row != 0 {
 		FilterRow(tls, dec)
 	}
 	if (*VP8Decoder)(unsafe.Pointer(dec)).Fdither != 0 {
 		DitherRow(tls, dec)
 	}
 	if (*VP8Io)(unsafe.Pointer(io)).Fput != libc.UintptrFromInt32(0) {
 		y_start = mb_y * int32(16)
 		y_end = (mb_y + int32(1)) * int32(16)
 		if !(is_first_row != 0) {
 			y_start = y_start - extra_y_rows
 			(*VP8Io)(unsafe.Pointer(io)).Fy = ydst
 			(*VP8Io)(unsafe.Pointer(io)).Fu = udst
 			(*VP8Io)(unsafe.Pointer(io)).Fv = vdst
 		} else {
 			(*VP8Io)(unsafe.Pointer(io)).Fy = (*VP8Decoder)(unsafe.Pointer(dec)).Fcache_y + uintptr(y_offset)
 			(*VP8Io)(unsafe.Pointer(io)).Fu = (*VP8Decoder)(unsafe.Pointer(dec)).Fcache_u + uintptr(uv_offset)
 			(*VP8Io)(unsafe.Pointer(io)).Fv = (*VP8Decoder)(unsafe.Pointer(dec)).Fcache_v + uintptr(uv_offset)
 		}
 		if !(is_last_row != 0) {
 			y_end = y_end - extra_y_rows
 		}
 		if y_end > (*VP8Io)(unsafe.Pointer(io)).Fcrop_bottom {
 			y_end = (*VP8Io)(unsafe.Pointer(io)).Fcrop_bottom // make sure we don't overflow on last row.
 		}
 		// If dec->alpha_data is not NULL, we have some alpha plane present.
 		(*VP8Io)(unsafe.Pointer(io)).Fa = libc.UintptrFromInt32(0)
 		if (*VP8Decoder)(unsafe.Pointer(dec)).Falpha_data != libc.UintptrFromInt32(0) && y_start < y_end {
 			(*VP8Io)(unsafe.Pointer(io)).Fa = VP8DecompressAlphaRows(tls, dec, io, y_start, y_end-y_start)
 			if (*VP8Io)(unsafe.Pointer(io)).Fa == libc.UintptrFromInt32(0) {
 				return VP8SetError(tls, dec, int32(VP8_STATUS_BITSTREAM_ERROR), __ccgo_ts+37)
 			}
 		}
 		if y_start < (*VP8Io)(unsafe.Pointer(io)).Fcrop_top {
 			delta_y = (*VP8Io)(unsafe.Pointer(io)).Fcrop_top - y_start
 			y_start = (*VP8Io)(unsafe.Pointer(io)).Fcrop_top
 			**(**uintptr)(__ccgo_up(io + 24)) += uintptr((*VP8Decoder)(unsafe.Pointer(dec)).Fcache_y_stride * delta_y)
 			**(**uintptr)(__ccgo_up(io + 32)) += uintptr((*VP8Decoder)(unsafe.Pointer(dec)).Fcache_uv_stride * (delta_y >> libc.Int32FromInt32(1)))
 			**(**uintptr)(__ccgo_up(io + 40)) += uintptr((*VP8Decoder)(unsafe.Pointer(dec)).Fcache_uv_stride * (delta_y >> libc.Int32FromInt32(1)))
 			if (*VP8Io)(unsafe.Pointer(io)).Fa != libc.UintptrFromInt32(0) {
 				**(**uintptr)(__ccgo_up(io + 152)) += uintptr((*VP8Io)(unsafe.Pointer(io)).Fwidth * delta_y)
 			}
 		}
 		if y_start < y_end {
 			**(**uintptr)(__ccgo_up(io + 24)) += uintptr((*VP8Io)(unsafe.Pointer(io)).Fcrop_left)
 			**(**uintptr)(__ccgo_up(io + 32)) += uintptr((*VP8Io)(unsafe.Pointer(io)).Fcrop_left >> int32(1))
 			**(**uintptr)(__ccgo_up(io + 40)) += uintptr((*VP8Io)(unsafe.Pointer(io)).Fcrop_left >> int32(1))
 			if (*VP8Io)(unsafe.Pointer(io)).Fa != libc.UintptrFromInt32(0) {
 				**(**uintptr)(__ccgo_up(io + 152)) += uintptr((*VP8Io)(unsafe.Pointer(io)).Fcrop_left)
 			}
 			(*VP8Io)(unsafe.Pointer(io)).Fmb_y = y_start - (*VP8Io)(unsafe.Pointer(io)).Fcrop_top
 			(*VP8Io)(unsafe.Pointer(io)).Fmb_w = (*VP8Io)(unsafe.Pointer(io)).Fcrop_right - (*VP8Io)(unsafe.Pointer(io)).Fcrop_left
 			(*VP8Io)(unsafe.Pointer(io)).Fmb_h = y_end - y_start
 			ok = (*(*func(*libc.TLS, uintptr) int32)(unsafe.Pointer(&struct{ uintptr }{(*VP8Io)(unsafe.Pointer(io)).Fput})))(tls, io)
 		}
 	}
 	// rotate top samples if needed
 	if cache_id+int32(1) == (*VP8Decoder)(unsafe.Pointer(dec)).Fnum_caches {
 		if !(is_last_row != 0) {
 			libc.X__builtin___memcpy_chk(tls, (*VP8Decoder)(unsafe.Pointer(dec)).Fcache_y-uintptr(ysize), ydst+uintptr(int32(16)*(*VP8Decoder)(unsafe.Pointer(dec)).Fcache_y_stride), libc.Uint64FromInt32(ysize), ^__predefined_size_t(0))
 			libc.X__builtin___memcpy_chk(tls, (*VP8Decoder)(unsafe.Pointer(dec)).Fcache_u-uintptr(uvsize), udst+uintptr(int32(8)*(*VP8Decoder)(unsafe.Pointer(dec)).Fcache_uv_stride), libc.Uint64FromInt32(uvsize), ^__predefined_size_t(0))
 			libc.X__builtin___memcpy_chk(tls, (*VP8Decoder)(unsafe.Pointer(dec)).Fcache_v-uintptr(uvsize), vdst+uintptr(int32(8)*(*VP8Decoder)(unsafe.Pointer(dec)).Fcache_uv_stride), libc.Uint64FromInt32(uvsize), ^__predefined_size_t(0))
 		}
 	}
 	return ok
 }
 
 //------------------------------------------------------------------------------
 
 func VP8ProcessRow(tls *libc.TLS, dec uintptr, io uintptr) (r int32) {
 	var ctx, tmp, tmp1, worker, v2 uintptr
 	var filter_row, ok, v1 int32
 	_, _, _, _, _, _, _, _ = ctx, filter_row, ok, tmp, tmp1, worker, v1, v2
 	ok = int32(1)
 	ctx = dec + 216
 	filter_row = libc.BoolInt32((*VP8Decoder)(unsafe.Pointer(dec)).Ffilter_type > 0 && (*VP8Decoder)(unsafe.Pointer(dec)).Fmb_y >= (*VP8Decoder)(unsafe.Pointer(dec)).Ftl_mb_y && (*VP8Decoder)(unsafe.Pointer(dec)).Fmb_y <= (*VP8Decoder)(unsafe.Pointer(dec)).Fbr_mb_y)
 	if (*VP8Decoder)(unsafe.Pointer(dec)).Fmt_method == 0 {
 		// ctx->id and ctx->f_info are already set
 		(*VP8ThreadContext)(unsafe.Pointer(ctx)).Fmb_y = (*VP8Decoder)(unsafe.Pointer(dec)).Fmb_y
 		(*VP8ThreadContext)(unsafe.Pointer(ctx)).Ffilter_row = filter_row
 		ReconstructRow(tls, dec, ctx)
 		ok = FinishRow(tls, dec, io)
 	} else {
 		worker = dec + 152
 		// Finish previous job *before* updating context
 		ok = ok & (*(*func(*libc.TLS, uintptr) int32)(unsafe.Pointer(&struct{ uintptr }{(*WebPWorkerInterface)(unsafe.Pointer(WebPGetWorkerInterface(tls))).FSync})))(tls, worker)
 		if ok != 0 { // spawn a new deblocking/output job
 			(*VP8ThreadContext)(unsafe.Pointer(ctx)).Fio = **(**VP8Io)(__ccgo_up(io))
 			(*VP8ThreadContext)(unsafe.Pointer(ctx)).Fid = (*VP8Decoder)(unsafe.Pointer(dec)).Fcache_id
 			(*VP8ThreadContext)(unsafe.Pointer(ctx)).Fmb_y = (*VP8Decoder)(unsafe.Pointer(dec)).Fmb_y
 			(*VP8ThreadContext)(unsafe.Pointer(ctx)).Ffilter_row = filter_row
 			if (*VP8Decoder)(unsafe.Pointer(dec)).Fmt_method == int32(2) { // swap macroblock data
 				tmp = (*VP8ThreadContext)(unsafe.Pointer(ctx)).Fmb_data
 				(*VP8ThreadContext)(unsafe.Pointer(ctx)).Fmb_data = (*VP8Decoder)(unsafe.Pointer(dec)).Fmb_data
 				(*VP8Decoder)(unsafe.Pointer(dec)).Fmb_data = tmp
 			} else {
 				// perform reconstruction directly in main thread
 				ReconstructRow(tls, dec, ctx)
 			}
 			if filter_row != 0 { // swap filter info
 				tmp1 = (*VP8ThreadContext)(unsafe.Pointer(ctx)).Ff_info
 				(*VP8ThreadContext)(unsafe.Pointer(ctx)).Ff_info = (*VP8Decoder)(unsafe.Pointer(dec)).Ff_info
 				(*VP8Decoder)(unsafe.Pointer(dec)).Ff_info = tmp1
 			}
 			// (reconstruct)+filter in parallel
 			(*(*func(*libc.TLS, uintptr))(unsafe.Pointer(&struct{ uintptr }{(*WebPWorkerInterface)(unsafe.Pointer(WebPGetWorkerInterface(tls))).FLaunch})))(tls, worker)
 			v2 = dec + 204
 			*(*int32)(unsafe.Pointer(v2)) = *(*int32)(unsafe.Pointer(v2)) + 1
 			v1 = *(*int32)(unsafe.Pointer(v2))
 			if v1 == (*VP8Decoder)(unsafe.Pointer(dec)).Fnum_caches {
 				(*VP8Decoder)(unsafe.Pointer(dec)).Fcache_id = 0
 			}
 		}
 	}
 	return ok
 }
 
 //------------------------------------------------------------------------------
 // Finish setting up the decoding parameter once user's setup() is called.
 
 func VP8EnterCritical(tls *libc.TLS, dec uintptr, io uintptr) (r VP8StatusCode1) {
 	var extra_pixels int32
 	_ = extra_pixels
 	// Call setup() first. This may trigger additional decoding features on 'io'.
 	// Note: Afterward, we must call teardown() no matter what.
 	if (*VP8Io)(unsafe.Pointer(io)).Fsetup != libc.UintptrFromInt32(0) && !((*(*func(*libc.TLS, uintptr) int32)(unsafe.Pointer(&struct{ uintptr }{(*VP8Io)(unsafe.Pointer(io)).Fsetup})))(tls, io) != 0) {
 		VP8SetError(tls, dec, int32(VP8_STATUS_USER_ABORT), __ccgo_ts+66)
 		return (*VP8Decoder)(unsafe.Pointer(dec)).Fstatus
 	}
 	// Disable filtering per user request
 	if (*VP8Io)(unsafe.Pointer(io)).Fbypass_filtering != 0 {
 		(*VP8Decoder)(unsafe.Pointer(dec)).Ffilter_type = 0
 	}
 	// Define the area where we can skip in-loop filtering, in case of cropping.
 	//
 	// 'Simple' filter reads two luma samples outside of the macroblock
 	// and filters one. It doesn't filter the chroma samples. Hence, we can
 	// avoid doing the in-loop filtering before crop_top/crop_left position.
 	// For the 'Complex' filter, 3 samples are read and up to 3 are filtered.
 	// Means: there's a dependency chain that goes all the way up to the
 	// top-left corner of the picture (MB #0). We must filter all the previous
 	// macroblocks.
 	extra_pixels = libc.Int32FromUint8(kFilterExtraRows[(*VP8Decoder)(unsafe.Pointer(dec)).Ffilter_type])
 	if (*VP8Decoder)(unsafe.Pointer(dec)).Ffilter_type == int32(2) {
 		// For complex filter, we need to preserve the dependency chain.
 		(*VP8Decoder)(unsafe.Pointer(dec)).Ftl_mb_x = 0
 		(*VP8Decoder)(unsafe.Pointer(dec)).Ftl_mb_y = 0
 	} else {
 		// For simple filter, we can filter only the cropped region.
 		// We include 'extra_pixels' on the other side of the boundary, since
 		// vertical or horizontal filtering of the previous macroblock can
 		// modify some abutting pixels.
 		(*VP8Decoder)(unsafe.Pointer(dec)).Ftl_mb_x = ((*VP8Io)(unsafe.Pointer(io)).Fcrop_left - extra_pixels) >> int32(4)
 		(*VP8Decoder)(unsafe.Pointer(dec)).Ftl_mb_y = ((*VP8Io)(unsafe.Pointer(io)).Fcrop_top - extra_pixels) >> int32(4)
 		if (*VP8Decoder)(unsafe.Pointer(dec)).Ftl_mb_x < 0 {
 			(*VP8Decoder)(unsafe.Pointer(dec)).Ftl_mb_x = 0
 		}
 		if (*VP8Decoder)(unsafe.Pointer(dec)).Ftl_mb_y < 0 {
 			(*VP8Decoder)(unsafe.Pointer(dec)).Ftl_mb_y = 0
 		}
 	}
 	// We need some 'extra' pixels on the right/bottom.
 	(*VP8Decoder)(unsafe.Pointer(dec)).Fbr_mb_y = ((*VP8Io)(unsafe.Pointer(io)).Fcrop_bottom + int32(15) + extra_pixels) >> int32(4)
 	(*VP8Decoder)(unsafe.Pointer(dec)).Fbr_mb_x = ((*VP8Io)(unsafe.Pointer(io)).Fcrop_right + int32(15) + extra_pixels) >> int32(4)
 	if (*VP8Decoder)(unsafe.Pointer(dec)).Fbr_mb_x > (*VP8Decoder)(unsafe.Pointer(dec)).Fmb_w {
 		(*VP8Decoder)(unsafe.Pointer(dec)).Fbr_mb_x = (*VP8Decoder)(unsafe.Pointer(dec)).Fmb_w
 	}
 	if (*VP8Decoder)(unsafe.Pointer(dec)).Fbr_mb_y > (*VP8Decoder)(unsafe.Pointer(dec)).Fmb_h {
 		(*VP8Decoder)(unsafe.Pointer(dec)).Fbr_mb_y = (*VP8Decoder)(unsafe.Pointer(dec)).Fmb_h
 	}
 	PrecomputeFilterStrengths(tls, dec)
 	return int32(VP8_STATUS_OK)
 }
 
 func VP8ExitCritical(tls *libc.TLS, dec uintptr, io uintptr) (r int32) {
 	var ok int32
 	_ = ok
 	ok = int32(1)
 	if (*VP8Decoder)(unsafe.Pointer(dec)).Fmt_method > 0 {
 		ok = (*(*func(*libc.TLS, uintptr) int32)(unsafe.Pointer(&struct{ uintptr }{(*WebPWorkerInterface)(unsafe.Pointer(WebPGetWorkerInterface(tls))).FSync})))(tls, dec+152)
 	}
 	if (*VP8Io)(unsafe.Pointer(io)).Fteardown != libc.UintptrFromInt32(0) {
 		(*(*func(*libc.TLS, uintptr))(unsafe.Pointer(&struct{ uintptr }{(*VP8Io)(unsafe.Pointer(io)).Fteardown})))(tls, io)
 	}
 	return ok
 }
 
 //------------------------------------------------------------------------------
 // For multi-threaded decoding we need to use 3 rows of 16 pixels as delay line.
 //
 // Reason is: the deblocking filter cannot deblock the bottom horizontal edges
 // immediately, and needs to wait for first few rows of the next macroblock to
 // be decoded. Hence, deblocking is lagging behind by 4 or 8 pixels (depending
 // on strength).
 // With two threads, the vertical positions of the rows being decoded are:
 // Decode:  [ 0..15][16..31][32..47][48..63][64..79][...
 // Deblock:         [ 0..11][12..27][28..43][44..59][...
 // If we use two threads and two caches of 16 pixels, the sequence would be:
 // Decode:  [ 0..15][16..31][ 0..15!!][16..31][ 0..15][...
 // Deblock:         [ 0..11][12..27!!][-4..11][12..27][...
 // The problem occurs during row [12..15!!] that both the decoding and
 // deblocking threads are writing simultaneously.
 // With 3 cache lines, one get a safe write pattern:
 // Decode:  [ 0..15][16..31][32..47][ 0..15][16..31][32..47][0..
 // Deblock:         [ 0..11][12..27][28..43][-4..11][12..27][28...
 // Note that multi-threaded output _without_ deblocking can make use of two
 // cache lines of 16 pixels only, since there's no lagging behind. The decoding
 // and output process have non-concurrent writing:
 // Decode:  [ 0..15][16..31][ 0..15][16..31][...
 // io->put:         [ 0..15][16..31][ 0..15][...
 
 // C documentation
 //
 //	// Initialize multi/single-thread worker
 func InitThreadContext(tls *libc.TLS, dec uintptr) (r int32) {
 	var worker uintptr
 	var v1 int32
 	_, _ = worker, v1
 	(*VP8Decoder)(unsafe.Pointer(dec)).Fcache_id = 0
 	if (*VP8Decoder)(unsafe.Pointer(dec)).Fmt_method > 0 {
 		worker = dec + 152
 		if !((*(*func(*libc.TLS, uintptr) int32)(unsafe.Pointer(&struct{ uintptr }{(*WebPWorkerInterface)(unsafe.Pointer(WebPGetWorkerInterface(tls))).FReset})))(tls, worker) != 0) {
 			return VP8SetError(tls, dec, int32(VP8_STATUS_OUT_OF_MEMORY), __ccgo_ts+85)
 		}
 		(*WebPWorker)(unsafe.Pointer(worker)).Fdata1 = dec
 		(*WebPWorker)(unsafe.Pointer(worker)).Fdata2 = dec + 216 + 32
 		(*WebPWorker)(unsafe.Pointer(worker)).Fhook = __ccgo_fp(FinishRow)
 		if (*VP8Decoder)(unsafe.Pointer(dec)).Ffilter_type > 0 {
 			v1 = int32(3)
 		} else {
 			v1 = libc.Int32FromInt32(3) - libc.Int32FromInt32(1)
 		}
 		(*VP8Decoder)(unsafe.Pointer(dec)).Fnum_caches = v1
 	} else {
 		(*VP8Decoder)(unsafe.Pointer(dec)).Fnum_caches = int32(1)
 	}
 	return int32(1)
 }
 
 func VP8GetThreadMethod(tls *libc.TLS, options uintptr, headers uintptr, width int32, height int32) (r int32) {
 	if options == libc.UintptrFromInt32(0) || (*WebPDecoderOptions)(unsafe.Pointer(options)).Fuse_threads == 0 {
 		return 0
 	}
 	_ = headers
 	_ = width
 	_ = height
 	return 0
 }
 
 //------------------------------------------------------------------------------
 // Memory setup
 
 func AllocateMemory(tls *libc.TLS, dec uintptr) (r int32) {
 	var alpha_size, needed, v5 uint64_t
 	var cache_height, cache_size, f_info_size, intra_pred_mode_size, mb_data_size, mb_info_size, top_size, yuv_size size_t
 	var extra_rows, extra_uv, extra_y, mb_w, num_caches, v2, v3, v6 int32
 	var mem, v8 uintptr
 	var v1, v4 uint64
 	_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = alpha_size, cache_height, cache_size, extra_rows, extra_uv, extra_y, f_info_size, intra_pred_mode_size, mb_data_size, mb_info_size, mb_w, mem, needed, num_caches, top_size, yuv_size, v1, v2, v3, v4, v5, v6, v8
 	num_caches = (*VP8Decoder)(unsafe.Pointer(dec)).Fnum_caches
 	mb_w = (*VP8Decoder)(unsafe.Pointer(dec)).Fmb_w
 	// Note: we use 'size_t' when there's no overflow risk, uint64_t otherwise.
 	intra_pred_mode_size = libc.Uint64FromInt32(int32(4)*mb_w) * uint64(1)
 	top_size = uint64(32) * libc.Uint64FromInt32(mb_w)
 	mb_info_size = libc.Uint64FromInt32(mb_w+libc.Int32FromInt32(1)) * uint64(2)
 	if (*VP8Decoder)(unsafe.Pointer(dec)).Ffilter_type > 0 {
 		if (*VP8Decoder)(unsafe.Pointer(dec)).Fmt_method > 0 {
 			v2 = int32(2)
 		} else {
 			v2 = int32(1)
 		}
 		v1 = libc.Uint64FromInt32(mb_w*v2) * uint64(4)
 	} else {
 		v1 = uint64(0)
 	}
 	f_info_size = v1
 	yuv_size = libc.Uint64FromInt32(libc.Int32FromInt32(BPS)*libc.Int32FromInt32(17)+libc.Int32FromInt32(BPS)*libc.Int32FromInt32(9)) * libc.Uint64FromInt64(1)
 	if (*VP8Decoder)(unsafe.Pointer(dec)).Fmt_method == int32(2) {
 		v3 = int32(2)
 	} else {
 		v3 = int32(1)
 	}
 	mb_data_size = libc.Uint64FromInt32(v3*mb_w) * uint64(800)
 	cache_height = libc.Uint64FromInt32((int32(16)*num_caches + libc.Int32FromUint8(kFilterExtraRows[(*VP8Decoder)(unsafe.Pointer(dec)).Ffilter_type])) * int32(3) / int32(2))
 	cache_size = top_size * cache_height
 	if (*VP8Decoder)(unsafe.Pointer(dec)).Falpha_data != libc.UintptrFromInt32(0) {
 		v4 = uint64((*VP8Decoder)(unsafe.Pointer(dec)).Fpic_hdr.Fwidth) * uint64((*VP8Decoder)(unsafe.Pointer(dec)).Fpic_hdr.Fheight)
 	} else {
 		v4 = 0
 	}
 	// alpha_size is the only one that scales as width x height.
 	alpha_size = v4
 	needed = intra_pred_mode_size + top_size + mb_info_size + f_info_size + yuv_size + mb_data_size + cache_size + alpha_size + uint64(WEBP_ALIGN_CST)
 	v5 = needed
 	v6 = libc.BoolInt32(v5 == v5)
 	goto _7
 _7:
 	if !(v6 != 0) {
 		return 0
 	} // check for overflow
 	if needed > (*VP8Decoder)(unsafe.Pointer(dec)).Fmem_size {
 		WebPSafeFree(tls, (*VP8Decoder)(unsafe.Pointer(dec)).Fmem)
 		(*VP8Decoder)(unsafe.Pointer(dec)).Fmem_size = uint64(0)
 		(*VP8Decoder)(unsafe.Pointer(dec)).Fmem = WebPSafeMalloc(tls, needed, uint64(1))
 		if (*VP8Decoder)(unsafe.Pointer(dec)).Fmem == libc.UintptrFromInt32(0) {
 			return VP8SetError(tls, dec, int32(VP8_STATUS_OUT_OF_MEMORY), __ccgo_ts+115)
 		}
 		// down-cast is ok, thanks to WebPSafeMalloc() above.
 		(*VP8Decoder)(unsafe.Pointer(dec)).Fmem_size = needed
 	}
 	mem = (*VP8Decoder)(unsafe.Pointer(dec)).Fmem
 	(*VP8Decoder)(unsafe.Pointer(dec)).Fintra_t = mem
 	mem = mem + uintptr(intra_pred_mode_size)
 	(*VP8Decoder)(unsafe.Pointer(dec)).Fyuv_t = mem
 	mem = mem + uintptr(top_size)
 	(*VP8Decoder)(unsafe.Pointer(dec)).Fmb_info = mem + uintptr(1)*2
 	mem = mem + uintptr(mb_info_size)
 	if f_info_size != 0 {
 		v8 = mem
 	} else {
 		v8 = libc.UintptrFromInt32(0)
 	}
 	(*VP8Decoder)(unsafe.Pointer(dec)).Ff_info = v8
 	mem = mem + uintptr(f_info_size)
 	(*VP8Decoder)(unsafe.Pointer(dec)).Fthread_ctx.Fid = 0
 	(*VP8Decoder)(unsafe.Pointer(dec)).Fthread_ctx.Ff_info = (*VP8Decoder)(unsafe.Pointer(dec)).Ff_info
 	if (*VP8Decoder)(unsafe.Pointer(dec)).Ffilter_type > 0 && (*VP8Decoder)(unsafe.Pointer(dec)).Fmt_method > 0 {
 		// secondary cache line. The deblocking process need to make use of the
 		// filtering strength from previous macroblock row, while the new ones
 		// are being decoded in parallel. We'll just swap the pointers.
 		(*VP8Decoder)(unsafe.Pointer(dec)).Fthread_ctx.Ff_info += uintptr(mb_w) * 4
 	}
 	mem = uintptr((uint64(mem) + libc.Uint64FromInt32(WEBP_ALIGN_CST)) & ^libc.Uint64FromInt32(WEBP_ALIGN_CST))
 	(*VP8Decoder)(unsafe.Pointer(dec)).Fyuv_b = mem
 	mem = mem + uintptr(yuv_size)
 	(*VP8Decoder)(unsafe.Pointer(dec)).Fmb_data = mem
 	(*VP8Decoder)(unsafe.Pointer(dec)).Fthread_ctx.Fmb_data = mem
 	if (*VP8Decoder)(unsafe.Pointer(dec)).Fmt_method == int32(2) {
 		(*VP8Decoder)(unsafe.Pointer(dec)).Fthread_ctx.Fmb_data += uintptr(mb_w) * 800
 	}
 	mem = mem + uintptr(mb_data_size)
 	(*VP8Decoder)(unsafe.Pointer(dec)).Fcache_y_stride = int32(16) * mb_w
 	(*VP8Decoder)(unsafe.Pointer(dec)).Fcache_uv_stride = int32(8) * mb_w
 	extra_rows = libc.Int32FromUint8(kFilterExtraRows[(*VP8Decoder)(unsafe.Pointer(dec)).Ffilter_type])
 	extra_y = extra_rows * (*VP8Decoder)(unsafe.Pointer(dec)).Fcache_y_stride
 	extra_uv = extra_rows / int32(2) * (*VP8Decoder)(unsafe.Pointer(dec)).Fcache_uv_stride
 	(*VP8Decoder)(unsafe.Pointer(dec)).Fcache_y = mem + uintptr(extra_y)
 	(*VP8Decoder)(unsafe.Pointer(dec)).Fcache_u = (*VP8Decoder)(unsafe.Pointer(dec)).Fcache_y + uintptr(int32(16)*num_caches*(*VP8Decoder)(unsafe.Pointer(dec)).Fcache_y_stride) + uintptr(extra_uv)
 	(*VP8Decoder)(unsafe.Pointer(dec)).Fcache_v = (*VP8Decoder)(unsafe.Pointer(dec)).Fcache_u + uintptr(int32(8)*num_caches*(*VP8Decoder)(unsafe.Pointer(dec)).Fcache_uv_stride) + uintptr(extra_uv)
 	(*VP8Decoder)(unsafe.Pointer(dec)).Fcache_id = 0
 	mem = mem + uintptr(cache_size)
 	// alpha plane
 	if alpha_size != 0 {
 		v8 = mem
 	} else {
 		v8 = libc.UintptrFromInt32(0)
 	}
 	(*VP8Decoder)(unsafe.Pointer(dec)).Falpha_plane = v8
 	mem = mem + uintptr(alpha_size)
 	// note: left/top-info is initialized once for all.
 	libc.X__builtin___memset_chk(tls, (*VP8Decoder)(unsafe.Pointer(dec)).Fmb_info-uintptr(1)*2, 0, mb_info_size, ^__predefined_size_t(0))
 	VP8InitScanline(tls, dec) // initialize left too.
 	// initialize top
 	libc.X__builtin___memset_chk(tls, (*VP8Decoder)(unsafe.Pointer(dec)).Fintra_t, int32(B_DC_PRED), intra_pred_mode_size, ^__predefined_size_t(0))
 	return int32(1)
 }
 
 func InitIo(tls *libc.TLS, dec uintptr, io uintptr) {
 	// prepare 'io'
 	(*VP8Io)(unsafe.Pointer(io)).Fmb_y = 0
 	(*VP8Io)(unsafe.Pointer(io)).Fy = (*VP8Decoder)(unsafe.Pointer(dec)).Fcache_y
 	(*VP8Io)(unsafe.Pointer(io)).Fu = (*VP8Decoder)(unsafe.Pointer(dec)).Fcache_u
 	(*VP8Io)(unsafe.Pointer(io)).Fv = (*VP8Decoder)(unsafe.Pointer(dec)).Fcache_v
 	(*VP8Io)(unsafe.Pointer(io)).Fy_stride = (*VP8Decoder)(unsafe.Pointer(dec)).Fcache_y_stride
 	(*VP8Io)(unsafe.Pointer(io)).Fuv_stride = (*VP8Decoder)(unsafe.Pointer(dec)).Fcache_uv_stride
 	(*VP8Io)(unsafe.Pointer(io)).Fa = libc.UintptrFromInt32(0)
 }
 
 func VP8InitFrame(tls *libc.TLS, dec uintptr, io uintptr) (r int32) {
 	if !(InitThreadContext(tls, dec) != 0) {
 		return 0
 	} // call first. Sets dec->num_caches.
 	if !(AllocateMemory(tls, dec) != 0) {
 		return 0
 	}
 	InitIo(tls, dec, io)
 	VP8DspInit(tls) // Init critical function pointers and look-up tables.
 	return int32(1)
 }
 
 const CHUNK_SIZE = 4096
 const MAX_MB_SIZE = 4096
 
 type WebPIDecoder = struct {
 	Fstate        DecState
 	Fparams       WebPDecParams
 	Fis_lossless  int32
 	Fdec          uintptr
 	Fio           VP8Io
 	Fmem          MemBuffer
 	Foutput       WebPDecBuffer
 	Ffinal_output uintptr
 	Fchunk_size   size_t
 	Flast_mb_y    int32
 }
 
 const STATE_WEBP_HEADER = 0
 const // All the data before that of the VP8/VP8L chunk.
 STATE_VP8_HEADER = 1
 const // The VP8 Frame header (within the VP8 chunk).
 STATE_VP8_PARTS0 = 2
 const STATE_VP8_DATA = 3
 const STATE_VP8L_HEADER = 4
 const STATE_VP8L_DATA = 5
 const STATE_DONE = 6
 const STATE_ERROR = 7
 
 var kHashMul3 = uint32(0x1e35a7bd)
 
 //------------------------------------------------------------------------------
 
 // Copyright 2010 Google Inc. All Rights Reserved.
 //
 // Use of this source code is governed by a BSD-style license
 // that can be found in the COPYING file in the root of the source
 // tree. An additional intellectual property rights grant can be found
 // in the file PATENTS. All contributing project authors may
 // be found in the AUTHORS file in the root of the source tree.
 // -----------------------------------------------------------------------------
 //
 //  Main decoding functions for WebP images.
 //
 // Author: Skal (pascal.massimino@gmail.com)
 
 // Copyright 2012 Google Inc. All Rights Reserved.
 //
 // Use of this source code is governed by a BSD-style license
 // that can be found in the COPYING file in the root of the source
 // tree. An additional intellectual property rights grant can be found
 // in the file PATENTS. All contributing project authors may
 // be found in the AUTHORS file in the root of the source tree.
 // -----------------------------------------------------------------------------
 //
 //  Internal header for constants related to WebP file format.
 //
 // Author: Urvang (urvang@google.com)
 
 // Copyright 2010 Google Inc. All Rights Reserved.
 //
 // Use of this source code is governed by a BSD-style license
 // that can be found in the COPYING file in the root of the source
 // tree. An additional intellectual property rights grant can be found
 // in the file PATENTS. All contributing project authors may
 // be found in the AUTHORS file in the root of the source tree.
 // -----------------------------------------------------------------------------
 //
 //  Common types + memory wrappers
 //
 // Author: Skal (pascal.massimino@gmail.com)
 
 // In append mode, buffer allocations increase as multiples of this value.
 // Needs to be a power of 2.
 
 //------------------------------------------------------------------------------
 // Data structures for memory and states
 
 // C documentation
 //
 //	// Decoding states. State normally flows as:
 //	// WEBP_HEADER->VP8_HEADER->VP8_PARTS0->VP8_DATA->DONE for a lossy image, and
 //	// WEBP_HEADER->VP8L_HEADER->VP8L_DATA->DONE for a lossless image.
 //	// If there is any error the decoder goes into state ERROR.
 type DecState = int32
 
 // C documentation
 //
 //	// Operating state for the MemBuffer
 type MemBufferMode = int32
 
 const MEM_MODE_NONE = 0
 const MEM_MODE_APPEND = 1
 const MEM_MODE_MAP = 2
 
 // C documentation
 //
 //	// storage for partition #0 and partial data (in a rolling fashion)
 type MemBuffer = struct {
 	Fmode       MemBufferMode
 	Fstart      size_t
 	Fend        size_t
 	Fbuf_size   size_t
 	Fbuf        uintptr
 	Fpart0_size size_t
 	Fpart0_buf  uintptr
 }
 
 // C documentation
 //
 //	// MB context to restore in case VP8DecodeMB() fails
 type MBContext = struct {
 	Fleft     VP8MB
 	Finfo     VP8MB
 	Ftoken_br VP8BitReader
 }
 
 //------------------------------------------------------------------------------
 // MemBuffer: incoming data handling
 
 func MemDataSize(tls *libc.TLS, mem uintptr) (r size_t) {
 	return (*MemBuffer)(unsafe.Pointer(mem)).Fend - (*MemBuffer)(unsafe.Pointer(mem)).Fstart
 }
 
 // C documentation
 //
 //	// Check if we need to preserve the compressed alpha data, as it may not have
 //	// been decoded yet.
 func NeedCompressedAlpha(tls *libc.TLS, idec uintptr) (r int32) {
 	var dec uintptr
 	_ = dec
 	if (*WebPIDecoder)(unsafe.Pointer(idec)).Fstate == int32(STATE_WEBP_HEADER) {
 		// We haven't parsed the headers yet, so we don't know whether the image is
 		// lossy or lossless. This also means that we haven't parsed the ALPH chunk.
 		return 0
 	}
 	if (*WebPIDecoder)(unsafe.Pointer(idec)).Fis_lossless != 0 {
 		return 0 // ALPH chunk is not present for lossless images.
 	} else {
 		dec = (*WebPIDecoder)(unsafe.Pointer(idec)).Fdec
 		// Must be true as idec->state != STATE_WEBP_HEADER.
 		return libc.BoolInt32((*VP8Decoder)(unsafe.Pointer(dec)).Falpha_data != libc.UintptrFromInt32(0) && !((*VP8Decoder)(unsafe.Pointer(dec)).Fis_alpha_decoded != 0))
 	}
 	return r
 }
 
 func DoRemap(tls *libc.TLS, idec uintptr, offset ptrdiff_t) {
 	var alph_dec, alph_vp8l_dec, dec, dec1, last_start, mem, new_base uintptr
 	var last_part, p uint32_t
 	_, _, _, _, _, _, _, _, _ = alph_dec, alph_vp8l_dec, dec, dec1, last_part, last_start, mem, new_base, p
 	mem = idec + 296
 	new_base = (*MemBuffer)(unsafe.Pointer(mem)).Fbuf + uintptr((*MemBuffer)(unsafe.Pointer(mem)).Fstart)
 	// note: for VP8, setting up idec->io is only really needed at the beginning
 	// of the decoding, till partition #0 is complete.
 	(*WebPIDecoder)(unsafe.Pointer(idec)).Fio.Fdata = new_base
 	(*WebPIDecoder)(unsafe.Pointer(idec)).Fio.Fdata_size = MemDataSize(tls, mem)
 	if (*WebPIDecoder)(unsafe.Pointer(idec)).Fdec != libc.UintptrFromInt32(0) {
 		if !((*WebPIDecoder)(unsafe.Pointer(idec)).Fis_lossless != 0) {
 			dec = (*WebPIDecoder)(unsafe.Pointer(idec)).Fdec
 			last_part = (*VP8Decoder)(unsafe.Pointer(dec)).Fnum_parts_minus_one
 			if offset != 0 {
 				p = uint32(0)
 				for {
 					if !(p <= last_part) {
 						break
 					}
 					VP8RemapBitReader(tls, dec+440+uintptr(p)*48, offset)
 					goto _1
 				_1:
 					;
 					p = p + 1
 				}
 				// Remap partition #0 data pointer to new offset, but only in MAP
 				// mode (in APPEND mode, partition #0 is copied into a fixed memory).
 				if (*MemBuffer)(unsafe.Pointer(mem)).Fmode == int32(MEM_MODE_MAP) {
 					VP8RemapBitReader(tls, dec+16, offset)
 				}
 			}
 			last_start = (**(**VP8BitReader)(__ccgo_up(dec + 440 + uintptr(last_part)*48))).Fbuf
 			// 'last_start' will be NULL when 'idec->state' is < STATE_VP8_PARTS0
 			// and through a portion of that state (when there isn't enough data to
 			// parse the partitions). The bitreader is only used meaningfully when
 			// there is enough data to begin parsing partition 0.
 			if last_start != libc.UintptrFromInt32(0) {
 				VP8BitReaderSetBuffer(tls, dec+440+uintptr(last_part)*48, last_start, libc.Uint64FromInt64(int64((*MemBuffer)(unsafe.Pointer(mem)).Fbuf+uintptr((*MemBuffer)(unsafe.Pointer(mem)).Fend))-int64(last_start)))
 			}
 			if NeedCompressedAlpha(tls, idec) != 0 {
 				alph_dec = (*VP8Decoder)(unsafe.Pointer(dec)).Falph_dec
 				**(**uintptr)(__ccgo_up(dec + 2968)) += uintptr(offset)
 				if alph_dec != libc.UintptrFromInt32(0) && (*ALPHDecoder)(unsafe.Pointer(alph_dec)).Fvp8l_dec != libc.UintptrFromInt32(0) {
 					if (*ALPHDecoder)(unsafe.Pointer(alph_dec)).Fmethod == int32(ALPHA_LOSSLESS_COMPRESSION) {
 						alph_vp8l_dec = (*ALPHDecoder)(unsafe.Pointer(alph_dec)).Fvp8l_dec
 						VP8LBitReaderSetBuffer(tls, alph_vp8l_dec+40, (*VP8Decoder)(unsafe.Pointer(dec)).Falpha_data+uintptr(ALPHA_HEADER_LEN), (*VP8Decoder)(unsafe.Pointer(dec)).Falpha_data_size-uint64(ALPHA_HEADER_LEN))
 					} else { // alph_dec->method == ALPHA_NO_COMPRESSION
 						// Nothing special to do in this case.
 					}
 				}
 			}
 		} else { // Resize lossless bitreader
 			dec1 = (*WebPIDecoder)(unsafe.Pointer(idec)).Fdec
 			VP8LBitReaderSetBuffer(tls, dec1+40, new_base, MemDataSize(tls, mem))
 		}
 	}
 }
 
 // C documentation
 //
 //	// Appends data to the end of MemBuffer->buf. It expands the allocated memory
 //	// size if required and also updates VP8BitReader's if new memory is allocated.
 func AppendToMemBuffer(tls *libc.TLS, idec uintptr, data uintptr, data_size size_t) (r int32) {
 	var current_size, new_mem_start size_t
 	var dec, mem, new_buf, old_base, old_start, v1, v2 uintptr
 	var extra_size, new_size uint64_t
 	var need_compressed_alpha int32
 	_, _, _, _, _, _, _, _, _, _, _, _ = current_size, dec, extra_size, mem, need_compressed_alpha, new_buf, new_mem_start, new_size, old_base, old_start, v1, v2
 	dec = (*WebPIDecoder)(unsafe.Pointer(idec)).Fdec
 	mem = idec + 296
 	need_compressed_alpha = NeedCompressedAlpha(tls, idec)
 	if (*MemBuffer)(unsafe.Pointer(mem)).Fbuf == libc.UintptrFromInt32(0) {
 		v1 = libc.UintptrFromInt32(0)
 	} else {
 		v1 = (*MemBuffer)(unsafe.Pointer(mem)).Fbuf + uintptr((*MemBuffer)(unsafe.Pointer(mem)).Fstart)
 	}
 	old_start = v1
 	if need_compressed_alpha != 0 {
 		v2 = (*VP8Decoder)(unsafe.Pointer(dec)).Falpha_data
 	} else {
 		v2 = old_start
 	}
 	old_base = v2
 	if data_size > uint64(^libc.Uint32FromUint32(0)-libc.Uint32FromInt32(CHUNK_HEADER_SIZE)-libc.Uint32FromInt32(1)) {
 		// security safeguard: trying to allocate more than what the format
 		// allows for a chunk should be considered a smoke smell.
 		return 0
 	}
 	if (*MemBuffer)(unsafe.Pointer(mem)).Fend+data_size > (*MemBuffer)(unsafe.Pointer(mem)).Fbuf_size { // Need some free memory
 		new_mem_start = libc.Uint64FromInt64(int64(old_start) - int64(old_base))
 		current_size = MemDataSize(tls, mem) + new_mem_start
 		new_size = current_size + data_size
 		extra_size = (new_size + uint64(CHUNK_SIZE) - uint64(1)) & libc.Uint64FromInt32(^(libc.Int32FromInt32(CHUNK_SIZE) - libc.Int32FromInt32(1)))
 		new_buf = WebPSafeMalloc(tls, extra_size, uint64(1))
 		if new_buf == libc.UintptrFromInt32(0) {
 			return 0
 		}
 		if old_base != libc.UintptrFromInt32(0) {
 			libc.X__builtin___memcpy_chk(tls, new_buf, old_base, current_size, ^__predefined_size_t(0))
 		}
 		WebPSafeFree(tls, (*MemBuffer)(unsafe.Pointer(mem)).Fbuf)
 		(*MemBuffer)(unsafe.Pointer(mem)).Fbuf = new_buf
 		(*MemBuffer)(unsafe.Pointer(mem)).Fbuf_size = extra_size
 		(*MemBuffer)(unsafe.Pointer(mem)).Fstart = new_mem_start
 		(*MemBuffer)(unsafe.Pointer(mem)).Fend = current_size
 	}
 	libc.X__builtin___memcpy_chk(tls, (*MemBuffer)(unsafe.Pointer(mem)).Fbuf+uintptr((*MemBuffer)(unsafe.Pointer(mem)).Fend), data, data_size, ^__predefined_size_t(0))
 	**(**size_t)(__ccgo_up(mem + 16)) += data_size
 	DoRemap(tls, idec, int64((*MemBuffer)(unsafe.Pointer(mem)).Fbuf+uintptr((*MemBuffer)(unsafe.Pointer(mem)).Fstart))-int64(old_start))
 	return int32(1)
 }
 
 func RemapMemBuffer(tls *libc.TLS, idec uintptr, data uintptr, data_size size_t) (r int32) {
 	var mem, old_buf, old_start, v1 uintptr
 	var v2 size_t
 	_, _, _, _, _ = mem, old_buf, old_start, v1, v2
 	mem = idec + 296
 	old_buf = (*MemBuffer)(unsafe.Pointer(mem)).Fbuf
 	if old_buf == libc.UintptrFromInt32(0) {
 		v1 = libc.UintptrFromInt32(0)
 	} else {
 		v1 = old_buf + uintptr((*MemBuffer)(unsafe.Pointer(mem)).Fstart)
 	}
 	old_start = v1
 	if data_size < (*MemBuffer)(unsafe.Pointer(mem)).Fbuf_size {
 		return 0
 	} // can't remap to a shorter buffer!
 	(*MemBuffer)(unsafe.Pointer(mem)).Fbuf = data
 	v2 = data_size
 	(*MemBuffer)(unsafe.Pointer(mem)).Fbuf_size = v2
 	(*MemBuffer)(unsafe.Pointer(mem)).Fend = v2
 	DoRemap(tls, idec, int64((*MemBuffer)(unsafe.Pointer(mem)).Fbuf+uintptr((*MemBuffer)(unsafe.Pointer(mem)).Fstart))-int64(old_start))
 	return int32(1)
 }
 
 func InitMemBuffer(tls *libc.TLS, mem uintptr) {
 	(*MemBuffer)(unsafe.Pointer(mem)).Fmode = int32(MEM_MODE_NONE)
 	(*MemBuffer)(unsafe.Pointer(mem)).Fbuf = libc.UintptrFromInt32(0)
 	(*MemBuffer)(unsafe.Pointer(mem)).Fbuf_size = uint64(0)
 	(*MemBuffer)(unsafe.Pointer(mem)).Fpart0_buf = libc.UintptrFromInt32(0)
 	(*MemBuffer)(unsafe.Pointer(mem)).Fpart0_size = uint64(0)
 }
 
 func ClearMemBuffer(tls *libc.TLS, mem uintptr) {
 	if (*MemBuffer)(unsafe.Pointer(mem)).Fmode == int32(MEM_MODE_APPEND) {
 		WebPSafeFree(tls, (*MemBuffer)(unsafe.Pointer(mem)).Fbuf)
 		WebPSafeFree(tls, (*MemBuffer)(unsafe.Pointer(mem)).Fpart0_buf)
 	}
 }
 
 func CheckMemBufferMode(tls *libc.TLS, mem uintptr, expected MemBufferMode) (r int32) {
 	if (*MemBuffer)(unsafe.Pointer(mem)).Fmode == int32(MEM_MODE_NONE) {
 		(*MemBuffer)(unsafe.Pointer(mem)).Fmode = expected // switch to the expected mode
 	} else {
 		if (*MemBuffer)(unsafe.Pointer(mem)).Fmode != expected {
 			return 0 // we mixed the modes => error
 		}
 	}
 	// mode is ok
 	return int32(1)
 }
 
 // C documentation
 //
 //	// To be called last.
 func FinishDecoding(tls *libc.TLS, idec uintptr) (r VP8StatusCode1) {
 	var options, output uintptr
 	var status, status1 VP8StatusCode1
 	_, _, _, _ = options, output, status, status1
 	options = (*WebPIDecoder)(unsafe.Pointer(idec)).Fparams.Foptions
 	output = (*WebPIDecoder)(unsafe.Pointer(idec)).Fparams.Foutput
 	(*WebPIDecoder)(unsafe.Pointer(idec)).Fstate = int32(STATE_DONE)
 	if options != libc.UintptrFromInt32(0) && (*WebPDecoderOptions)(unsafe.Pointer(options)).Fflip != 0 {
 		status = WebPFlipBuffer(tls, output)
 		if status != int32(VP8_STATUS_OK) {
 			return status
 		}
 	}
 	if (*WebPIDecoder)(unsafe.Pointer(idec)).Ffinal_output != libc.UintptrFromInt32(0) {
 		status1 = WebPCopyDecBufferPixels(tls, output, (*WebPIDecoder)(unsafe.Pointer(idec)).Ffinal_output) // do the slow-copy
 		WebPFreeDecBuffer(tls, idec+352)
 		if status1 != int32(VP8_STATUS_OK) {
 			return status1
 		}
 		**(**WebPDecBuffer)(__ccgo_up(output)) = **(**WebPDecBuffer)(__ccgo_up((*WebPIDecoder)(unsafe.Pointer(idec)).Ffinal_output))
 		(*WebPIDecoder)(unsafe.Pointer(idec)).Ffinal_output = libc.UintptrFromInt32(0)
 	}
 	return int32(VP8_STATUS_OK)
 }
 
 //------------------------------------------------------------------------------
 // Macroblock-decoding contexts
 
 func SaveContext(tls *libc.TLS, dec uintptr, token_br uintptr, context uintptr) {
 	(*MBContext)(unsafe.Pointer(context)).Fleft = **(**VP8MB)(__ccgo_up((*VP8Decoder)(unsafe.Pointer(dec)).Fmb_info + uintptr(-libc.Int32FromInt32(1))*2))
 	(*MBContext)(unsafe.Pointer(context)).Finfo = **(**VP8MB)(__ccgo_up((*VP8Decoder)(unsafe.Pointer(dec)).Fmb_info + uintptr((*VP8Decoder)(unsafe.Pointer(dec)).Fmb_x)*2))
 	(*MBContext)(unsafe.Pointer(context)).Ftoken_br = **(**VP8BitReader)(__ccgo_up(token_br))
 }
 
 func RestoreContext(tls *libc.TLS, context uintptr, dec uintptr, token_br uintptr) {
 	**(**VP8MB)(__ccgo_up((*VP8Decoder)(unsafe.Pointer(dec)).Fmb_info + uintptr(-libc.Int32FromInt32(1))*2)) = (*MBContext)(unsafe.Pointer(context)).Fleft
 	**(**VP8MB)(__ccgo_up((*VP8Decoder)(unsafe.Pointer(dec)).Fmb_info + uintptr((*VP8Decoder)(unsafe.Pointer(dec)).Fmb_x)*2)) = (*MBContext)(unsafe.Pointer(context)).Finfo
 	**(**VP8BitReader)(__ccgo_up(token_br)) = (*MBContext)(unsafe.Pointer(context)).Ftoken_br
 }
 
 //------------------------------------------------------------------------------
 
 func IDecError(tls *libc.TLS, idec uintptr, error1 VP8StatusCode1) (r VP8StatusCode1) {
 	if (*WebPIDecoder)(unsafe.Pointer(idec)).Fstate == int32(STATE_VP8_DATA) {
 		// Synchronize the thread, clean-up and check for errors.
 		VP8ExitCritical(tls, (*WebPIDecoder)(unsafe.Pointer(idec)).Fdec, idec+136)
 	}
 	(*WebPIDecoder)(unsafe.Pointer(idec)).Fstate = int32(STATE_ERROR)
 	return error1
 }
 
 func ChangeState(tls *libc.TLS, idec uintptr, new_state DecState, consumed_bytes size_t) {
 	var mem uintptr
 	_ = mem
 	mem = idec + 296
 	(*WebPIDecoder)(unsafe.Pointer(idec)).Fstate = new_state
 	**(**size_t)(__ccgo_up(mem + 8)) += consumed_bytes
 	(*WebPIDecoder)(unsafe.Pointer(idec)).Fio.Fdata = (*MemBuffer)(unsafe.Pointer(mem)).Fbuf + uintptr((*MemBuffer)(unsafe.Pointer(mem)).Fstart)
 	(*WebPIDecoder)(unsafe.Pointer(idec)).Fio.Fdata_size = MemDataSize(tls, mem)
 }
 
 // C documentation
 //
 //	// Headers
 func DecodeWebPHeaders(tls *libc.TLS, idec uintptr) (r VP8StatusCode1) {
 	bp := tls.Alloc(80)
 	defer tls.Free(80)
 	var curr_size size_t
 	var data, dec, dec1, mem uintptr
 	var status VP8StatusCode1
 	var _ /* headers at bp+0 */ WebPHeaderStructure
 	_, _, _, _, _, _ = curr_size, data, dec, dec1, mem, status
 	mem = idec + 296
 	data = (*MemBuffer)(unsafe.Pointer(mem)).Fbuf + uintptr((*MemBuffer)(unsafe.Pointer(mem)).Fstart)
 	curr_size = MemDataSize(tls, mem)
 	(**(**WebPHeaderStructure)(__ccgo_up(bp))).Fdata = data
 	(**(**WebPHeaderStructure)(__ccgo_up(bp))).Fdata_size = curr_size
 	(**(**WebPHeaderStructure)(__ccgo_up(bp))).Fhave_all_data = 0
 	status = WebPParseHeaders(tls, bp)
 	if status == int32(VP8_STATUS_NOT_ENOUGH_DATA) {
 		return int32(VP8_STATUS_SUSPENDED) // We haven't found a VP8 chunk yet.
 	} else {
 		if status != int32(VP8_STATUS_OK) {
 			return IDecError(tls, idec, status)
 		}
 	}
 	(*WebPIDecoder)(unsafe.Pointer(idec)).Fchunk_size = (**(**WebPHeaderStructure)(__ccgo_up(bp))).Fcompressed_size
 	(*WebPIDecoder)(unsafe.Pointer(idec)).Fis_lossless = (**(**WebPHeaderStructure)(__ccgo_up(bp))).Fis_lossless
 	if !((*WebPIDecoder)(unsafe.Pointer(idec)).Fis_lossless != 0) {
 		dec = VP8New(tls)
 		if dec == libc.UintptrFromInt32(0) {
 			return int32(VP8_STATUS_OUT_OF_MEMORY)
 		}
 		(*VP8Decoder)(unsafe.Pointer(dec)).Fincremental = int32(1)
 		(*WebPIDecoder)(unsafe.Pointer(idec)).Fdec = dec
 		(*VP8Decoder)(unsafe.Pointer(dec)).Falpha_data = (**(**WebPHeaderStructure)(__ccgo_up(bp))).Falpha_data
 		(*VP8Decoder)(unsafe.Pointer(dec)).Falpha_data_size = (**(**WebPHeaderStructure)(__ccgo_up(bp))).Falpha_data_size
 		ChangeState(tls, idec, int32(STATE_VP8_HEADER), (**(**WebPHeaderStructure)(__ccgo_up(bp))).Foffset)
 	} else {
 		dec1 = VP8LNew(tls)
 		if dec1 == libc.UintptrFromInt32(0) {
 			return int32(VP8_STATUS_OUT_OF_MEMORY)
 		}
 		(*WebPIDecoder)(unsafe.Pointer(idec)).Fdec = dec1
 		ChangeState(tls, idec, int32(STATE_VP8L_HEADER), (**(**WebPHeaderStructure)(__ccgo_up(bp))).Foffset)
 	}
 	return int32(VP8_STATUS_OK)
 }
 
 func DecodeVP8FrameHeader(tls *libc.TLS, idec uintptr) (r VP8StatusCode1) {
 	bp := tls.Alloc(16)
 	defer tls.Free(16)
 	var bits uint32_t
 	var curr_size size_t
 	var data uintptr
 	var _ /* height at bp+4 */ int32
 	var _ /* width at bp+0 */ int32
 	_, _, _ = bits, curr_size, data
 	data = (*WebPIDecoder)(unsafe.Pointer(idec)).Fmem.Fbuf + uintptr((*WebPIDecoder)(unsafe.Pointer(idec)).Fmem.Fstart)
 	curr_size = MemDataSize(tls, idec+296)
 	if curr_size < uint64(VP8_FRAME_HEADER_SIZE) {
 		// Not enough data bytes to extract VP8 Frame Header.
 		return int32(VP8_STATUS_SUSPENDED)
 	}
 	if !(VP8GetInfo(tls, data, curr_size, (*WebPIDecoder)(unsafe.Pointer(idec)).Fchunk_size, bp, bp+4) != 0) {
 		return IDecError(tls, idec, int32(VP8_STATUS_BITSTREAM_ERROR))
 	}
 	bits = libc.Uint32FromInt32(libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(data))) | libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(data + 1)))<<int32(8) | libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(data + 2)))<<int32(16))
 	(*WebPIDecoder)(unsafe.Pointer(idec)).Fmem.Fpart0_size = uint64(bits>>libc.Int32FromInt32(5) + uint32(VP8_FRAME_HEADER_SIZE))
 	(*WebPIDecoder)(unsafe.Pointer(idec)).Fio.Fdata = data
 	(*WebPIDecoder)(unsafe.Pointer(idec)).Fio.Fdata_size = curr_size
 	(*WebPIDecoder)(unsafe.Pointer(idec)).Fstate = int32(STATE_VP8_PARTS0)
 	return int32(VP8_STATUS_OK)
 }
 
 // C documentation
 //
 //	// Partition #0
 func CopyParts0Data(tls *libc.TLS, idec uintptr) (r VP8StatusCode1) {
 	var br, dec, mem, part0_buf uintptr
 	var part_size size_t
 	_, _, _, _, _ = br, dec, mem, part0_buf, part_size
 	dec = (*WebPIDecoder)(unsafe.Pointer(idec)).Fdec
 	br = dec + 16
 	part_size = libc.Uint64FromInt64(int64((*VP8BitReader)(unsafe.Pointer(br)).Fbuf_end) - int64((*VP8BitReader)(unsafe.Pointer(br)).Fbuf))
 	mem = idec + 296
 	// the following is a format limitation, no need for runtime check:
 	if part_size == uint64(0) { // can't have zero-size partition #0
 		return int32(VP8_STATUS_BITSTREAM_ERROR)
 	}
 	if (*MemBuffer)(unsafe.Pointer(mem)).Fmode == int32(MEM_MODE_APPEND) {
 		// We copy and grab ownership of the partition #0 data.
 		part0_buf = WebPSafeMalloc(tls, uint64(1), part_size)
 		if part0_buf == libc.UintptrFromInt32(0) {
 			return int32(VP8_STATUS_OUT_OF_MEMORY)
 		}
 		libc.X__builtin___memcpy_chk(tls, part0_buf, (*VP8BitReader)(unsafe.Pointer(br)).Fbuf, part_size, ^__predefined_size_t(0))
 		(*MemBuffer)(unsafe.Pointer(mem)).Fpart0_buf = part0_buf
 		VP8BitReaderSetBuffer(tls, br, part0_buf, part_size)
 	} else {
 		// Else: just keep pointers to the partition #0's data in dec->br.
 	}
 	**(**size_t)(__ccgo_up(mem + 8)) += part_size
 	return int32(VP8_STATUS_OK)
 }
 
 func DecodePartition0(tls *libc.TLS, idec uintptr) (r VP8StatusCode1) {
 	var dec, io, output, params uintptr
 	var status VP8StatusCode1
 	_, _, _, _, _ = dec, io, output, params, status
 	dec = (*WebPIDecoder)(unsafe.Pointer(idec)).Fdec
 	io = idec + 136
 	params = idec + 8
 	output = (*WebPDecParams)(unsafe.Pointer(params)).Foutput
 	// Wait till we have enough data for the whole partition #0
 	if MemDataSize(tls, idec+296) < (*WebPIDecoder)(unsafe.Pointer(idec)).Fmem.Fpart0_size {
 		return int32(VP8_STATUS_SUSPENDED)
 	}
 	if !(VP8GetHeaders(tls, dec, io) != 0) {
 		status = (*VP8Decoder)(unsafe.Pointer(dec)).Fstatus
 		if status == int32(VP8_STATUS_SUSPENDED) || status == int32(VP8_STATUS_NOT_ENOUGH_DATA) {
 			// treating NOT_ENOUGH_DATA as SUSPENDED state
 			return int32(VP8_STATUS_SUSPENDED)
 		}
 		return IDecError(tls, idec, status)
 	}
 	// Allocate/Verify output buffer now
 	(*VP8Decoder)(unsafe.Pointer(dec)).Fstatus = WebPAllocateDecBuffer(tls, (*VP8Io)(unsafe.Pointer(io)).Fwidth, (*VP8Io)(unsafe.Pointer(io)).Fheight, (*WebPDecParams)(unsafe.Pointer(params)).Foptions, output)
 	if (*VP8Decoder)(unsafe.Pointer(dec)).Fstatus != int32(VP8_STATUS_OK) {
 		return IDecError(tls, idec, (*VP8Decoder)(unsafe.Pointer(dec)).Fstatus)
 	}
 	// This change must be done before calling VP8InitFrame()
 	(*VP8Decoder)(unsafe.Pointer(dec)).Fmt_method = VP8GetThreadMethod(tls, (*WebPDecParams)(unsafe.Pointer(params)).Foptions, libc.UintptrFromInt32(0), (*VP8Io)(unsafe.Pointer(io)).Fwidth, (*VP8Io)(unsafe.Pointer(io)).Fheight)
 	VP8InitDithering(tls, (*WebPDecParams)(unsafe.Pointer(params)).Foptions, dec)
 	(*VP8Decoder)(unsafe.Pointer(dec)).Fstatus = CopyParts0Data(tls, idec)
 	if (*VP8Decoder)(unsafe.Pointer(dec)).Fstatus != int32(VP8_STATUS_OK) {
 		return IDecError(tls, idec, (*VP8Decoder)(unsafe.Pointer(dec)).Fstatus)
 	}
 	// Finish setting up the decoding parameters. Will call io->setup().
 	if VP8EnterCritical(tls, dec, io) != int32(VP8_STATUS_OK) {
 		return IDecError(tls, idec, (*VP8Decoder)(unsafe.Pointer(dec)).Fstatus)
 	}
 	// Note: past this point, teardown() must always be called
 	// in case of error.
 	(*WebPIDecoder)(unsafe.Pointer(idec)).Fstate = int32(STATE_VP8_DATA)
 	// Allocate memory and prepare everything.
 	if !(VP8InitFrame(tls, dec, io) != 0) {
 		return IDecError(tls, idec, (*VP8Decoder)(unsafe.Pointer(dec)).Fstatus)
 	}
 	return int32(VP8_STATUS_OK)
 }
 
 // C documentation
 //
 //	// Remaining partitions
 func DecodeRemaining(tls *libc.TLS, idec uintptr) (r VP8StatusCode1) {
 	bp := tls.Alloc(64)
 	defer tls.Free(64)
 	var dec, io, token_br uintptr
 	var _ /* context at bp+0 */ MBContext
 	_, _, _ = dec, io, token_br
 	dec = (*WebPIDecoder)(unsafe.Pointer(idec)).Fdec
 	io = idec + 136
 	// Make sure partition #0 has been read before, to set dec to ready.
 	if !((*VP8Decoder)(unsafe.Pointer(dec)).Fready != 0) {
 		return IDecError(tls, idec, int32(VP8_STATUS_BITSTREAM_ERROR))
 	}
 	for {
 		if !((*VP8Decoder)(unsafe.Pointer(dec)).Fmb_y < (*VP8Decoder)(unsafe.Pointer(dec)).Fmb_h) {
 			break
 		}
 		if (*WebPIDecoder)(unsafe.Pointer(idec)).Flast_mb_y != (*VP8Decoder)(unsafe.Pointer(dec)).Fmb_y {
 			if !(VP8ParseIntraModeRow(tls, dec+16, dec) != 0) {
 				// note: normally, error shouldn't occur since we already have the whole
 				// partition0 available here in DecodeRemaining(). Reaching EOF while
 				// reading intra modes really means a BITSTREAM_ERROR.
 				return IDecError(tls, idec, int32(VP8_STATUS_BITSTREAM_ERROR))
 			}
 			(*WebPIDecoder)(unsafe.Pointer(idec)).Flast_mb_y = (*VP8Decoder)(unsafe.Pointer(dec)).Fmb_y
 		}
 		for {
 			if !((*VP8Decoder)(unsafe.Pointer(dec)).Fmb_x < (*VP8Decoder)(unsafe.Pointer(dec)).Fmb_w) {
 				break
 			}
 			token_br = dec + 440 + uintptr(libc.Uint32FromInt32((*VP8Decoder)(unsafe.Pointer(dec)).Fmb_y)&(*VP8Decoder)(unsafe.Pointer(dec)).Fnum_parts_minus_one)*48
 			SaveContext(tls, dec, token_br, bp)
 			if !(VP8DecodeMB(tls, dec, token_br) != 0) {
 				// We shouldn't fail when MAX_MB data was available
 				if (*VP8Decoder)(unsafe.Pointer(dec)).Fnum_parts_minus_one == uint32(0) && MemDataSize(tls, idec+296) > uint64(MAX_MB_SIZE) {
 					return IDecError(tls, idec, int32(VP8_STATUS_BITSTREAM_ERROR))
 				}
 				// Synchronize the threads.
 				if (*VP8Decoder)(unsafe.Pointer(dec)).Fmt_method > 0 {
 					if !((*(*func(*libc.TLS, uintptr) int32)(unsafe.Pointer(&struct{ uintptr }{(*WebPWorkerInterface)(unsafe.Pointer(WebPGetWorkerInterface(tls))).FSync})))(tls, dec+152) != 0) {
 						return IDecError(tls, idec, int32(VP8_STATUS_BITSTREAM_ERROR))
 					}
 				}
 				RestoreContext(tls, bp, dec, token_br)
 				return int32(VP8_STATUS_SUSPENDED)
 			}
 			// Release buffer only if there is only one partition
 			if (*VP8Decoder)(unsafe.Pointer(dec)).Fnum_parts_minus_one == uint32(0) {
 				(*WebPIDecoder)(unsafe.Pointer(idec)).Fmem.Fstart = libc.Uint64FromInt64(int64((*VP8BitReader)(unsafe.Pointer(token_br)).Fbuf) - int64((*WebPIDecoder)(unsafe.Pointer(idec)).Fmem.Fbuf))
 			}
 			goto _2
 		_2:
 			;
 			(*VP8Decoder)(unsafe.Pointer(dec)).Fmb_x = (*VP8Decoder)(unsafe.Pointer(dec)).Fmb_x + 1
 		}
 		VP8InitScanline(tls, dec) // Prepare for next scanline
 		// Reconstruct, filter and emit the row.
 		if !(VP8ProcessRow(tls, dec, io) != 0) {
 			return IDecError(tls, idec, int32(VP8_STATUS_USER_ABORT))
 		}
 		goto _1
 	_1:
 		;
 		(*VP8Decoder)(unsafe.Pointer(dec)).Fmb_y = (*VP8Decoder)(unsafe.Pointer(dec)).Fmb_y + 1
 	}
 	// Synchronize the thread and check for errors.
 	if !(VP8ExitCritical(tls, dec, io) != 0) {
 		(*WebPIDecoder)(unsafe.Pointer(idec)).Fstate = int32(STATE_ERROR) // prevent re-entry in IDecError
 		return IDecError(tls, idec, int32(VP8_STATUS_USER_ABORT))
 	}
 	(*VP8Decoder)(unsafe.Pointer(dec)).Fready = 0
 	return FinishDecoding(tls, idec)
 }
 
 func ErrorStatusLossless(tls *libc.TLS, idec uintptr, status VP8StatusCode1) (r VP8StatusCode1) {
 	if status == int32(VP8_STATUS_SUSPENDED) || status == int32(VP8_STATUS_NOT_ENOUGH_DATA) {
 		return int32(VP8_STATUS_SUSPENDED)
 	}
 	return IDecError(tls, idec, status)
 }
 
 func DecodeVP8LHeader(tls *libc.TLS, idec uintptr) (r VP8StatusCode1) {
 	var curr_size size_t
 	var dec, io, output, params uintptr
 	_, _, _, _, _ = curr_size, dec, io, output, params
 	io = idec + 136
 	dec = (*WebPIDecoder)(unsafe.Pointer(idec)).Fdec
 	params = idec + 8
 	output = (*WebPDecParams)(unsafe.Pointer(params)).Foutput
 	curr_size = MemDataSize(tls, idec+296)
 	// Wait until there's enough data for decoding header.
 	if curr_size < (*WebPIDecoder)(unsafe.Pointer(idec)).Fchunk_size>>libc.Int32FromInt32(3) {
 		(*VP8LDecoder)(unsafe.Pointer(dec)).Fstatus = int32(VP8_STATUS_SUSPENDED)
 		return ErrorStatusLossless(tls, idec, (*VP8LDecoder)(unsafe.Pointer(dec)).Fstatus)
 	}
 	if !(VP8LDecodeHeader(tls, dec, io) != 0) {
 		if (*VP8LDecoder)(unsafe.Pointer(dec)).Fstatus == int32(VP8_STATUS_BITSTREAM_ERROR) && curr_size < (*WebPIDecoder)(unsafe.Pointer(idec)).Fchunk_size {
 			(*VP8LDecoder)(unsafe.Pointer(dec)).Fstatus = int32(VP8_STATUS_SUSPENDED)
 		}
 		return ErrorStatusLossless(tls, idec, (*VP8LDecoder)(unsafe.Pointer(dec)).Fstatus)
 	}
 	// Allocate/verify output buffer now.
 	(*VP8LDecoder)(unsafe.Pointer(dec)).Fstatus = WebPAllocateDecBuffer(tls, (*VP8Io)(unsafe.Pointer(io)).Fwidth, (*VP8Io)(unsafe.Pointer(io)).Fheight, (*WebPDecParams)(unsafe.Pointer(params)).Foptions, output)
 	if (*VP8LDecoder)(unsafe.Pointer(dec)).Fstatus != int32(VP8_STATUS_OK) {
 		return IDecError(tls, idec, (*VP8LDecoder)(unsafe.Pointer(dec)).Fstatus)
 	}
 	(*WebPIDecoder)(unsafe.Pointer(idec)).Fstate = int32(STATE_VP8L_DATA)
 	return int32(VP8_STATUS_OK)
 }
 
 func DecodeVP8LData(tls *libc.TLS, idec uintptr) (r VP8StatusCode1) {
 	var curr_size size_t
 	var dec uintptr
 	var v1 int32
 	_, _, _ = curr_size, dec, v1
 	dec = (*WebPIDecoder)(unsafe.Pointer(idec)).Fdec
 	curr_size = MemDataSize(tls, idec+296)
 	// Switch to incremental decoding if we don't have all the bytes available.
 	(*VP8LDecoder)(unsafe.Pointer(dec)).Fincremental = libc.BoolInt32(curr_size < (*WebPIDecoder)(unsafe.Pointer(idec)).Fchunk_size)
 	if !(VP8LDecodeImage(tls, dec) != 0) {
 		return ErrorStatusLossless(tls, idec, (*VP8LDecoder)(unsafe.Pointer(dec)).Fstatus)
 	}
 	if (*VP8LDecoder)(unsafe.Pointer(dec)).Fstatus == int32(VP8_STATUS_SUSPENDED) {
 		v1 = (*VP8LDecoder)(unsafe.Pointer(dec)).Fstatus
 	} else {
 		v1 = FinishDecoding(tls, idec)
 	}
 	return v1
 }
 
 // C documentation
 //
 //	// Main decoding loop
 func IDecode(tls *libc.TLS, idec uintptr) (r VP8StatusCode1) {
 	var dec uintptr
 	var status VP8StatusCode1
 	_, _ = dec, status
 	status = int32(VP8_STATUS_SUSPENDED)
 	if (*WebPIDecoder)(unsafe.Pointer(idec)).Fstate == int32(STATE_WEBP_HEADER) {
 		status = DecodeWebPHeaders(tls, idec)
 	} else {
 		if (*WebPIDecoder)(unsafe.Pointer(idec)).Fdec == libc.UintptrFromInt32(0) {
 			return int32(VP8_STATUS_SUSPENDED) // can't continue if we have no decoder.
 		}
 	}
 	if (*WebPIDecoder)(unsafe.Pointer(idec)).Fstate == int32(STATE_VP8_HEADER) {
 		status = DecodeVP8FrameHeader(tls, idec)
 	}
 	if (*WebPIDecoder)(unsafe.Pointer(idec)).Fstate == int32(STATE_VP8_PARTS0) {
 		status = DecodePartition0(tls, idec)
 	}
 	if (*WebPIDecoder)(unsafe.Pointer(idec)).Fstate == int32(STATE_VP8_DATA) {
 		dec = (*WebPIDecoder)(unsafe.Pointer(idec)).Fdec
 		if dec == libc.UintptrFromInt32(0) {
 			return int32(VP8_STATUS_SUSPENDED) // can't continue if we have no decoder.
 		}
 		status = DecodeRemaining(tls, idec)
 	}
 	if (*WebPIDecoder)(unsafe.Pointer(idec)).Fstate == int32(STATE_VP8L_HEADER) {
 		status = DecodeVP8LHeader(tls, idec)
 	}
 	if (*WebPIDecoder)(unsafe.Pointer(idec)).Fstate == int32(STATE_VP8L_DATA) {
 		status = DecodeVP8LData(tls, idec)
 	}
 	return status
 }
 
 // ------------------------------------------------------------------------------
 // Internal constructor
 func NewDecoder(tls *libc.TLS, output_buffer uintptr, features uintptr) (r uintptr) {
 	var idec uintptr
 	var v1, v3 int32
 	var v5 bool
 	_, _, _, _ = idec, v1, v3, v5
 	idec = WebPSafeCalloc(tls, uint64(1), uint64(496))
 	if idec == libc.UintptrFromInt32(0) {
 		return libc.UintptrFromInt32(0)
 	}
 	(*WebPIDecoder)(unsafe.Pointer(idec)).Fstate = int32(STATE_WEBP_HEADER)
 	(*WebPIDecoder)(unsafe.Pointer(idec)).Fchunk_size = uint64(0)
 	(*WebPIDecoder)(unsafe.Pointer(idec)).Flast_mb_y = -int32(1)
 	InitMemBuffer(tls, idec+296)
 	v1 = WebPInitDecBufferInternal(tls, idec+352, int32(WEBP_DECODER_ABI_VERSION))
 	goto _2
 _2:
 	;
 	if v5 = !(v1 != 0); !v5 {
 		v3 = VP8InitIoInternal(tls, idec+136, int32(WEBP_DECODER_ABI_VERSION))
 		goto _4
 	_4:
 	}
 	if v5 || !(v3 != 0) {
 		WebPSafeFree(tls, idec)
 		return libc.UintptrFromInt32(0)
 	}
 	WebPResetDecParams(tls, idec+8)
 	if output_buffer == libc.UintptrFromInt32(0) || WebPAvoidSlowMemory(tls, output_buffer, features) != 0 {
 		(*WebPIDecoder)(unsafe.Pointer(idec)).Fparams.Foutput = idec + 352
 		(*WebPIDecoder)(unsafe.Pointer(idec)).Ffinal_output = output_buffer
 		if output_buffer != libc.UintptrFromInt32(0) {
 			(*WebPDecBuffer)(unsafe.Pointer((*WebPIDecoder)(unsafe.Pointer(idec)).Fparams.Foutput)).Fcolorspace = (*WebPDecBuffer)(unsafe.Pointer(output_buffer)).Fcolorspace
 		}
 	} else {
 		(*WebPIDecoder)(unsafe.Pointer(idec)).Fparams.Foutput = output_buffer
 		(*WebPIDecoder)(unsafe.Pointer(idec)).Ffinal_output = libc.UintptrFromInt32(0)
 	}
 	WebPInitCustomIo(tls, idec+8, idec+136) // Plug the I/O functions.
 	return idec
 }
 
 //------------------------------------------------------------------------------
 // Public functions
 
 func WebPINewDecoder(tls *libc.TLS, output_buffer uintptr) (r uintptr) {
 	return NewDecoder(tls, output_buffer, libc.UintptrFromInt32(0))
 }
 
 func WebPIDecode(tls *libc.TLS, data1 uintptr, data_size1 size_t, config uintptr) (r uintptr) {
 	bp := tls.Alloc(48)
 	defer tls.Free(48)
 	var features1, idec, v1 uintptr
 	var v2 VP8StatusCode1
 	var _ /* tmp_features at bp+0 */ WebPBitstreamFeatures
 	_, _, _, _ = features1, idec, v1, v2
 	if config == libc.UintptrFromInt32(0) {
 		v1 = bp
 	} else {
 		v1 = config
 	}
 	features1 = v1
 	libc.X__builtin___memset_chk(tls, bp, 0, uint64(40), ^__predefined_size_t(0))
 	// Parse the bitstream's features, if requested:
 	if data1 != libc.UintptrFromInt32(0) && data_size1 > uint64(0) {
 		v2 = WebPGetFeaturesInternal(tls, data1, data_size1, features1, int32(WEBP_DECODER_ABI_VERSION))
 		goto _3
 	_3:
 		if v2 != int32(VP8_STATUS_OK) {
 			return libc.UintptrFromInt32(0)
 		}
 	}
 	// Create an instance of the incremental decoder
 	if config != libc.UintptrFromInt32(0) {
 		v1 = NewDecoder(tls, config+40, features1)
 	} else {
 		v1 = NewDecoder(tls, libc.UintptrFromInt32(0), features1)
 	}
 	idec = v1
 	if idec == libc.UintptrFromInt32(0) {
 		return libc.UintptrFromInt32(0)
 	}
 	// Finish initialization
 	if config != libc.UintptrFromInt32(0) {
 		(*WebPIDecoder)(unsafe.Pointer(idec)).Fparams.Foptions = config + 160
 	}
 	return idec
 }
 
 func WebPIDelete(tls *libc.TLS, idec uintptr) {
 	if idec == libc.UintptrFromInt32(0) {
 		return
 	}
 	if (*WebPIDecoder)(unsafe.Pointer(idec)).Fdec != libc.UintptrFromInt32(0) {
 		if !((*WebPIDecoder)(unsafe.Pointer(idec)).Fis_lossless != 0) {
 			if (*WebPIDecoder)(unsafe.Pointer(idec)).Fstate == int32(STATE_VP8_DATA) {
 				// Synchronize the thread, clean-up and check for errors.
 				// TODO(vrabaud) do we care about the return result?
 				VP8ExitCritical(tls, (*WebPIDecoder)(unsafe.Pointer(idec)).Fdec, idec+136)
 			}
 			VP8Delete(tls, (*WebPIDecoder)(unsafe.Pointer(idec)).Fdec)
 		} else {
 			VP8LDelete(tls, (*WebPIDecoder)(unsafe.Pointer(idec)).Fdec)
 		}
 	}
 	ClearMemBuffer(tls, idec+296)
 	WebPFreeDecBuffer(tls, idec+352)
 	WebPSafeFree(tls, idec)
 }
 
 //------------------------------------------------------------------------------
 // Wrapper toward WebPINewDecoder
 
 func WebPINewRGB(tls *libc.TLS, csp WEBP_CSP_MODE1, output_buffer uintptr, output_buffer_size size_t, output_stride int32) (r uintptr) {
 	var idec uintptr
 	var is_external_memory, v1 int32
 	_, _, _ = idec, is_external_memory, v1
 	if output_buffer != libc.UintptrFromInt32(0) {
 		v1 = int32(1)
 	} else {
 		v1 = 0
 	}
 	is_external_memory = v1
 	if csp >= int32(MODE_YUV) {
 		return libc.UintptrFromInt32(0)
 	}
 	if is_external_memory == 0 { // Overwrite parameters to sane values.
 		output_buffer_size = uint64(0)
 		output_stride = 0
 	} else { // A buffer was passed. Validate the other params.
 		if output_stride == 0 || output_buffer_size == uint64(0) {
 			return libc.UintptrFromInt32(0) // invalid parameter.
 		}
 	}
 	idec = WebPINewDecoder(tls, libc.UintptrFromInt32(0))
 	if idec == libc.UintptrFromInt32(0) {
 		return libc.UintptrFromInt32(0)
 	}
 	(*WebPIDecoder)(unsafe.Pointer(idec)).Foutput.Fcolorspace = csp
 	(*WebPIDecoder)(unsafe.Pointer(idec)).Foutput.Fis_external_memory = is_external_memory
 	*(*uintptr)(unsafe.Pointer(idec + 352 + 16)) = output_buffer
 	*(*int32)(unsafe.Pointer(idec + 352 + 16 + 8)) = output_stride
 	*(*size_t)(unsafe.Pointer(idec + 352 + 16 + 16)) = output_buffer_size
 	return idec
 }
 
 func WebPINewYUVA(tls *libc.TLS, luma uintptr, luma_size size_t, luma_stride int32, u uintptr, u_size size_t, u_stride int32, v uintptr, v_size size_t, v_stride int32, a uintptr, a_size size_t, a_stride int32) (r uintptr) {
 	var colorspace WEBP_CSP_MODE1
 	var idec, v8, v9 uintptr
 	var is_external_memory, v1, v5, v6 int32
 	var v2, v3, v4 size_t
 	_, _, _, _, _, _, _, _, _, _, _ = colorspace, idec, is_external_memory, v1, v2, v3, v4, v5, v6, v8, v9
 	if luma != libc.UintptrFromInt32(0) {
 		v1 = int32(1)
 	} else {
 		v1 = 0
 	}
 	is_external_memory = v1
 	if is_external_memory == 0 { // Overwrite parameters to sane values.
 		v4 = libc.Uint64FromInt32(0)
 		a_size = v4
 		v3 = v4
 		v_size = v3
 		v2 = v3
 		u_size = v2
 		luma_size = v2
 		v6 = libc.Int32FromInt32(0)
 		a_stride = v6
 		v5 = v6
 		v_stride = v5
 		v1 = v5
 		u_stride = v1
 		luma_stride = v1
 		v9 = libc.UintptrFromInt32(0)
 		a = v9
 		v8 = v9
 		v = v8
 		u = v8
 		colorspace = int32(MODE_YUVA)
 	} else { // A luma buffer was passed. Validate the other parameters.
 		if u == libc.UintptrFromInt32(0) || v == libc.UintptrFromInt32(0) {
 			return libc.UintptrFromInt32(0)
 		}
 		if luma_size == uint64(0) || u_size == uint64(0) || v_size == uint64(0) {
 			return libc.UintptrFromInt32(0)
 		}
 		if luma_stride == 0 || u_stride == 0 || v_stride == 0 {
 			return libc.UintptrFromInt32(0)
 		}
 		if a != libc.UintptrFromInt32(0) {
 			if a_size == uint64(0) || a_stride == 0 {
 				return libc.UintptrFromInt32(0)
 			}
 		}
 		if a == libc.UintptrFromInt32(0) {
 			v1 = int32(MODE_YUV)
 		} else {
 			v1 = int32(MODE_YUVA)
 		}
 		colorspace = v1
 	}
 	idec = WebPINewDecoder(tls, libc.UintptrFromInt32(0))
 	if idec == libc.UintptrFromInt32(0) {
 		return libc.UintptrFromInt32(0)
 	}
 	(*WebPIDecoder)(unsafe.Pointer(idec)).Foutput.Fcolorspace = colorspace
 	(*WebPIDecoder)(unsafe.Pointer(idec)).Foutput.Fis_external_memory = is_external_memory
 	*(*uintptr)(unsafe.Pointer(idec + 352 + 16)) = luma
 	*(*int32)(unsafe.Pointer(idec + 352 + 16 + 32)) = luma_stride
 	*(*size_t)(unsafe.Pointer(idec + 352 + 16 + 48)) = luma_size
 	*(*uintptr)(unsafe.Pointer(idec + 352 + 16 + 8)) = u
 	*(*int32)(unsafe.Pointer(idec + 352 + 16 + 36)) = u_stride
 	*(*size_t)(unsafe.Pointer(idec + 352 + 16 + 56)) = u_size
 	*(*uintptr)(unsafe.Pointer(idec + 352 + 16 + 16)) = v
 	*(*int32)(unsafe.Pointer(idec + 352 + 16 + 40)) = v_stride
 	*(*size_t)(unsafe.Pointer(idec + 352 + 16 + 64)) = v_size
 	*(*uintptr)(unsafe.Pointer(idec + 352 + 16 + 24)) = a
 	*(*int32)(unsafe.Pointer(idec + 352 + 16 + 44)) = a_stride
 	*(*size_t)(unsafe.Pointer(idec + 352 + 16 + 72)) = a_size
 	return idec
 }
 
 func WebPINewYUV(tls *libc.TLS, luma uintptr, luma_size size_t, luma_stride int32, u uintptr, u_size size_t, u_stride int32, v uintptr, v_size size_t, v_stride int32) (r uintptr) {
 	return WebPINewYUVA(tls, luma, luma_size, luma_stride, u, u_size, u_stride, v, v_size, v_stride, libc.UintptrFromInt32(0), uint64(0), 0)
 }
 
 //------------------------------------------------------------------------------
 
 func IDecCheckStatus(tls *libc.TLS, idec uintptr) (r VP8StatusCode1) {
 	if (*WebPIDecoder)(unsafe.Pointer(idec)).Fstate == int32(STATE_ERROR) {
 		return int32(VP8_STATUS_BITSTREAM_ERROR)
 	}
 	if (*WebPIDecoder)(unsafe.Pointer(idec)).Fstate == int32(STATE_DONE) {
 		return int32(VP8_STATUS_OK)
 	}
 	return int32(VP8_STATUS_SUSPENDED)
 }
 
 func WebPIAppend(tls *libc.TLS, idec uintptr, data uintptr, data_size size_t) (r VP8StatusCode1) {
 	var status VP8StatusCode1
 	_ = status
 	if idec == libc.UintptrFromInt32(0) || data == libc.UintptrFromInt32(0) {
 		return int32(VP8_STATUS_INVALID_PARAM)
 	}
 	status = IDecCheckStatus(tls, idec)
 	if status != int32(VP8_STATUS_SUSPENDED) {
 		return status
 	}
 	// Check mixed calls between RemapMemBuffer and AppendToMemBuffer.
 	if !(CheckMemBufferMode(tls, idec+296, int32(MEM_MODE_APPEND)) != 0) {
 		return int32(VP8_STATUS_INVALID_PARAM)
 	}
 	// Append data to memory buffer
 	if !(AppendToMemBuffer(tls, idec, data, data_size) != 0) {
 		return int32(VP8_STATUS_OUT_OF_MEMORY)
 	}
 	return IDecode(tls, idec)
 }
 
 func WebPIUpdate(tls *libc.TLS, idec uintptr, data uintptr, data_size size_t) (r VP8StatusCode1) {
 	var status VP8StatusCode1
 	_ = status
 	if idec == libc.UintptrFromInt32(0) || data == libc.UintptrFromInt32(0) {
 		return int32(VP8_STATUS_INVALID_PARAM)
 	}
 	status = IDecCheckStatus(tls, idec)
 	if status != int32(VP8_STATUS_SUSPENDED) {
 		return status
 	}
 	// Check mixed calls between RemapMemBuffer and AppendToMemBuffer.
 	if !(CheckMemBufferMode(tls, idec+296, int32(MEM_MODE_MAP)) != 0) {
 		return int32(VP8_STATUS_INVALID_PARAM)
 	}
 	// Make the memory buffer point to the new buffer
 	if !(RemapMemBuffer(tls, idec, data, data_size) != 0) {
 		return int32(VP8_STATUS_INVALID_PARAM)
 	}
 	return IDecode(tls, idec)
 }
 
 //------------------------------------------------------------------------------
 
 func GetOutputBuffer(tls *libc.TLS, idec uintptr) (r uintptr) {
 	if idec == libc.UintptrFromInt32(0) || (*WebPIDecoder)(unsafe.Pointer(idec)).Fdec == libc.UintptrFromInt32(0) {
 		return libc.UintptrFromInt32(0)
 	}
 	if (*WebPIDecoder)(unsafe.Pointer(idec)).Fstate <= int32(STATE_VP8_PARTS0) {
 		return libc.UintptrFromInt32(0)
 	}
 	if (*WebPIDecoder)(unsafe.Pointer(idec)).Ffinal_output != libc.UintptrFromInt32(0) {
 		return libc.UintptrFromInt32(0) // not yet slow-copied
 	}
 	return (*WebPIDecoder)(unsafe.Pointer(idec)).Fparams.Foutput
 }
 
 func WebPIDecodedArea(tls *libc.TLS, idec uintptr, left uintptr, top uintptr, width uintptr, height uintptr) (r uintptr) {
 	var src uintptr
 	_ = src
 	src = GetOutputBuffer(tls, idec)
 	if left != libc.UintptrFromInt32(0) {
 		**(**int32)(__ccgo_up(left)) = 0
 	}
 	if top != libc.UintptrFromInt32(0) {
 		**(**int32)(__ccgo_up(top)) = 0
 	}
 	if src != libc.UintptrFromInt32(0) {
 		if width != libc.UintptrFromInt32(0) {
 			**(**int32)(__ccgo_up(width)) = (*WebPDecBuffer)(unsafe.Pointer(src)).Fwidth
 		}
 		if height != libc.UintptrFromInt32(0) {
 			**(**int32)(__ccgo_up(height)) = (*WebPIDecoder)(unsafe.Pointer(idec)).Fparams.Flast_y
 		}
 	} else {
 		if width != libc.UintptrFromInt32(0) {
 			**(**int32)(__ccgo_up(width)) = 0
 		}
 		if height != libc.UintptrFromInt32(0) {
 			**(**int32)(__ccgo_up(height)) = 0
 		}
 	}
 	return src
 }
 
 func WebPIDecGetRGB(tls *libc.TLS, idec uintptr, last_y uintptr, width uintptr, height uintptr, stride uintptr) (r uintptr) {
 	var src uintptr
 	_ = src
 	src = GetOutputBuffer(tls, idec)
 	if src == libc.UintptrFromInt32(0) {
 		return libc.UintptrFromInt32(0)
 	}
 	if (*WebPDecBuffer)(unsafe.Pointer(src)).Fcolorspace >= int32(MODE_YUV) {
 		return libc.UintptrFromInt32(0)
 	}
 	if last_y != libc.UintptrFromInt32(0) {
 		**(**int32)(__ccgo_up(last_y)) = (*WebPIDecoder)(unsafe.Pointer(idec)).Fparams.Flast_y
 	}
 	if width != libc.UintptrFromInt32(0) {
 		**(**int32)(__ccgo_up(width)) = (*WebPDecBuffer)(unsafe.Pointer(src)).Fwidth
 	}
 	if height != libc.UintptrFromInt32(0) {
 		**(**int32)(__ccgo_up(height)) = (*WebPDecBuffer)(unsafe.Pointer(src)).Fheight
 	}
 	if stride != libc.UintptrFromInt32(0) {
 		**(**int32)(__ccgo_up(stride)) = (*WebPDecBuffer)(unsafe.Pointer(src)).Fu.FRGBA.Fstride
 	}
 	return (*WebPDecBuffer)(unsafe.Pointer(src)).Fu.FRGBA.Frgba
 }
 
 func WebPIDecGetYUVA(tls *libc.TLS, idec uintptr, last_y uintptr, u uintptr, v uintptr, a uintptr, width uintptr, height uintptr, stride uintptr, uv_stride uintptr, a_stride uintptr) (r uintptr) {
 	var src uintptr
 	_ = src
 	src = GetOutputBuffer(tls, idec)
 	if src == libc.UintptrFromInt32(0) {
 		return libc.UintptrFromInt32(0)
 	}
 	if (*WebPDecBuffer)(unsafe.Pointer(src)).Fcolorspace < int32(MODE_YUV) {
 		return libc.UintptrFromInt32(0)
 	}
 	if last_y != libc.UintptrFromInt32(0) {
 		**(**int32)(__ccgo_up(last_y)) = (*WebPIDecoder)(unsafe.Pointer(idec)).Fparams.Flast_y
 	}
 	if u != libc.UintptrFromInt32(0) {
 		**(**uintptr)(__ccgo_up(u)) = (*(*WebPYUVABuffer)(unsafe.Pointer(src + 16))).Fu
 	}
 	if v != libc.UintptrFromInt32(0) {
 		**(**uintptr)(__ccgo_up(v)) = (*(*WebPYUVABuffer)(unsafe.Pointer(src + 16))).Fv
 	}
 	if a != libc.UintptrFromInt32(0) {
 		**(**uintptr)(__ccgo_up(a)) = (*(*WebPYUVABuffer)(unsafe.Pointer(src + 16))).Fa
 	}
 	if width != libc.UintptrFromInt32(0) {
 		**(**int32)(__ccgo_up(width)) = (*WebPDecBuffer)(unsafe.Pointer(src)).Fwidth
 	}
 	if height != libc.UintptrFromInt32(0) {
 		**(**int32)(__ccgo_up(height)) = (*WebPDecBuffer)(unsafe.Pointer(src)).Fheight
 	}
 	if stride != libc.UintptrFromInt32(0) {
 		**(**int32)(__ccgo_up(stride)) = (*(*WebPYUVABuffer)(unsafe.Pointer(src + 16))).Fy_stride
 	}
 	if uv_stride != libc.UintptrFromInt32(0) {
 		**(**int32)(__ccgo_up(uv_stride)) = (*(*WebPYUVABuffer)(unsafe.Pointer(src + 16))).Fu_stride
 	}
 	if a_stride != libc.UintptrFromInt32(0) {
 		**(**int32)(__ccgo_up(a_stride)) = (*(*WebPYUVABuffer)(unsafe.Pointer(src + 16))).Fa_stride
 	}
 	return (*(*WebPYUVABuffer)(unsafe.Pointer(src + 16))).Fy
 }
 
 type __ccgo_fp__XWebPISetIOHooks_1 = func(*libc.TLS, uintptr) int32
 
 type __ccgo_fp__XWebPISetIOHooks_2 = func(*libc.TLS, uintptr) int32
 
 type __ccgo_fp__XWebPISetIOHooks_3 = func(*libc.TLS, uintptr)
 
 func WebPISetIOHooks(tls *libc.TLS, idec uintptr, __ccgo_fp_put VP8IoPutHook, __ccgo_fp_setup VP8IoSetupHook, __ccgo_fp_teardown VP8IoTeardownHook, user_data uintptr) (r int32) {
 	if idec == libc.UintptrFromInt32(0) || (*WebPIDecoder)(unsafe.Pointer(idec)).Fstate > int32(STATE_WEBP_HEADER) {
 		return 0
 	}
 	(*WebPIDecoder)(unsafe.Pointer(idec)).Fio.Fput = __ccgo_fp_put
 	(*WebPIDecoder)(unsafe.Pointer(idec)).Fio.Fsetup = __ccgo_fp_setup
 	(*WebPIDecoder)(unsafe.Pointer(idec)).Fio.Fteardown = __ccgo_fp_teardown
 	(*WebPIDecoder)(unsafe.Pointer(idec)).Fio.Fopaque = user_data
 	return int32(1)
 }
 
 var kHashMul4 = uint32(0x1e35a7bd)
 
 const YUV_FIX = 16
 const YUV_HALF = 32768
 const YUV_FIX2 = 6
 const YUV_MASK2 = 16383
 
 //------------------------------------------------------------------------------
 
 // Copyright 2010 Google Inc. All Rights Reserved.
 //
 // Use of this source code is governed by a BSD-style license
 // that can be found in the COPYING file in the root of the source
 // tree. An additional intellectual property rights grant can be found
 // in the file PATENTS. All contributing project authors may
 // be found in the AUTHORS file in the root of the source tree.
 // -----------------------------------------------------------------------------
 //
 //  Main decoding functions for WebP images.
 //
 // Author: Skal (pascal.massimino@gmail.com)
 
 //------------------------------------------------------------------------------
 // Main YUV<->RGB conversion functions
 
 func EmitYUV(tls *libc.TLS, io uintptr, p uintptr) (r int32) {
 	var buf, output, u_dst, v_dst, y_dst uintptr
 	var mb_h, mb_w, uv_h, uv_w int32
 	_, _, _, _, _, _, _, _, _ = buf, mb_h, mb_w, output, u_dst, uv_h, uv_w, v_dst, y_dst
 	output = (*WebPDecParams)(unsafe.Pointer(p)).Foutput
 	buf = output + 16
 	y_dst = (*WebPYUVABuffer)(unsafe.Pointer(buf)).Fy + uintptr(int64((*VP8Io)(unsafe.Pointer(io)).Fmb_y)*int64((*WebPYUVABuffer)(unsafe.Pointer(buf)).Fy_stride))
 	u_dst = (*WebPYUVABuffer)(unsafe.Pointer(buf)).Fu + uintptr(int64((*VP8Io)(unsafe.Pointer(io)).Fmb_y>>libc.Int32FromInt32(1))*int64((*WebPYUVABuffer)(unsafe.Pointer(buf)).Fu_stride))
 	v_dst = (*WebPYUVABuffer)(unsafe.Pointer(buf)).Fv + uintptr(int64((*VP8Io)(unsafe.Pointer(io)).Fmb_y>>libc.Int32FromInt32(1))*int64((*WebPYUVABuffer)(unsafe.Pointer(buf)).Fv_stride))
 	mb_w = (*VP8Io)(unsafe.Pointer(io)).Fmb_w
 	mb_h = (*VP8Io)(unsafe.Pointer(io)).Fmb_h
 	uv_w = (mb_w + int32(1)) / int32(2)
 	uv_h = (mb_h + int32(1)) / int32(2)
 	WebPCopyPlane(tls, (*VP8Io)(unsafe.Pointer(io)).Fy, (*VP8Io)(unsafe.Pointer(io)).Fy_stride, y_dst, (*WebPYUVABuffer)(unsafe.Pointer(buf)).Fy_stride, mb_w, mb_h)
 	WebPCopyPlane(tls, (*VP8Io)(unsafe.Pointer(io)).Fu, (*VP8Io)(unsafe.Pointer(io)).Fuv_stride, u_dst, (*WebPYUVABuffer)(unsafe.Pointer(buf)).Fu_stride, uv_w, uv_h)
 	WebPCopyPlane(tls, (*VP8Io)(unsafe.Pointer(io)).Fv, (*VP8Io)(unsafe.Pointer(io)).Fuv_stride, v_dst, (*WebPYUVABuffer)(unsafe.Pointer(buf)).Fv_stride, uv_w, uv_h)
 	return (*VP8Io)(unsafe.Pointer(io)).Fmb_h
 }
 
 // C documentation
 //
 //	// Point-sampling U/V sampler.
 func EmitSampledRGB(tls *libc.TLS, io uintptr, p uintptr) (r int32) {
 	var buf, dst, output uintptr
 	_, _, _ = buf, dst, output
 	output = (*WebPDecParams)(unsafe.Pointer(p)).Foutput
 	buf = output + 16
 	dst = (*WebPRGBABuffer)(unsafe.Pointer(buf)).Frgba + uintptr(int64((*VP8Io)(unsafe.Pointer(io)).Fmb_y)*int64((*WebPRGBABuffer)(unsafe.Pointer(buf)).Fstride))
 	WebPSamplerProcessPlane(tls, (*VP8Io)(unsafe.Pointer(io)).Fy, (*VP8Io)(unsafe.Pointer(io)).Fy_stride, (*VP8Io)(unsafe.Pointer(io)).Fu, (*VP8Io)(unsafe.Pointer(io)).Fv, (*VP8Io)(unsafe.Pointer(io)).Fuv_stride, dst, (*WebPRGBABuffer)(unsafe.Pointer(buf)).Fstride, (*VP8Io)(unsafe.Pointer(io)).Fmb_w, (*VP8Io)(unsafe.Pointer(io)).Fmb_h, WebPSamplers[(*WebPDecBuffer)(unsafe.Pointer(output)).Fcolorspace])
 	return (*VP8Io)(unsafe.Pointer(io)).Fmb_h
 }
 
 //------------------------------------------------------------------------------
 // Fancy upsampling
 
 func EmitFancyRGB(tls *libc.TLS, io uintptr, p uintptr) (r int32) {
 	var buf, cur_u, cur_v, cur_y, dst, top_u, top_v uintptr
 	var mb_w, num_lines_out, uv_w, y, y_end int32
 	var upsample WebPUpsampleLinePairFunc
 	_, _, _, _, _, _, _, _, _, _, _, _, _ = buf, cur_u, cur_v, cur_y, dst, mb_w, num_lines_out, top_u, top_v, upsample, uv_w, y, y_end
 	num_lines_out = (*VP8Io)(unsafe.Pointer(io)).Fmb_h // a priori guess
 	buf = (*WebPDecParams)(unsafe.Pointer(p)).Foutput + 16
 	dst = (*WebPRGBABuffer)(unsafe.Pointer(buf)).Frgba + uintptr(int64((*VP8Io)(unsafe.Pointer(io)).Fmb_y)*int64((*WebPRGBABuffer)(unsafe.Pointer(buf)).Fstride))
 	upsample = WebPUpsamplers[(*WebPDecBuffer)(unsafe.Pointer((*WebPDecParams)(unsafe.Pointer(p)).Foutput)).Fcolorspace]
 	cur_y = (*VP8Io)(unsafe.Pointer(io)).Fy
 	cur_u = (*VP8Io)(unsafe.Pointer(io)).Fu
 	cur_v = (*VP8Io)(unsafe.Pointer(io)).Fv
 	top_u = (*WebPDecParams)(unsafe.Pointer(p)).Ftmp_u
 	top_v = (*WebPDecParams)(unsafe.Pointer(p)).Ftmp_v
 	y = (*VP8Io)(unsafe.Pointer(io)).Fmb_y
 	y_end = (*VP8Io)(unsafe.Pointer(io)).Fmb_y + (*VP8Io)(unsafe.Pointer(io)).Fmb_h
 	mb_w = (*VP8Io)(unsafe.Pointer(io)).Fmb_w
 	uv_w = (mb_w + int32(1)) / int32(2)
 	if y == 0 {
 		// First line is special cased. We mirror the u/v samples at boundary.
 		(*(*func(*libc.TLS, uintptr, uintptr, uintptr, uintptr, uintptr, uintptr, uintptr, uintptr, int32))(unsafe.Pointer(&struct{ uintptr }{upsample})))(tls, cur_y, libc.UintptrFromInt32(0), cur_u, cur_v, cur_u, cur_v, dst, libc.UintptrFromInt32(0), mb_w)
 	} else {
 		// We can finish the left-over line from previous call.
 		(*(*func(*libc.TLS, uintptr, uintptr, uintptr, uintptr, uintptr, uintptr, uintptr, uintptr, int32))(unsafe.Pointer(&struct{ uintptr }{upsample})))(tls, (*WebPDecParams)(unsafe.Pointer(p)).Ftmp_y, cur_y, top_u, top_v, cur_u, cur_v, dst-uintptr((*WebPRGBABuffer)(unsafe.Pointer(buf)).Fstride), dst, mb_w)
 		num_lines_out = num_lines_out + 1
 	}
 	// Loop over each output pairs of row.
 	for {
 		if !(y+int32(2) < y_end) {
 			break
 		}
 		top_u = cur_u
 		top_v = cur_v
 		cur_u = cur_u + uintptr((*VP8Io)(unsafe.Pointer(io)).Fuv_stride)
 		cur_v = cur_v + uintptr((*VP8Io)(unsafe.Pointer(io)).Fuv_stride)
 		dst = dst + uintptr(int32(2)*(*WebPRGBABuffer)(unsafe.Pointer(buf)).Fstride)
 		cur_y = cur_y + uintptr(int32(2)*(*VP8Io)(unsafe.Pointer(io)).Fy_stride)
 		(*(*func(*libc.TLS, uintptr, uintptr, uintptr, uintptr, uintptr, uintptr, uintptr, uintptr, int32))(unsafe.Pointer(&struct{ uintptr }{upsample})))(tls, cur_y-uintptr((*VP8Io)(unsafe.Pointer(io)).Fy_stride), cur_y, top_u, top_v, cur_u, cur_v, dst-uintptr((*WebPRGBABuffer)(unsafe.Pointer(buf)).Fstride), dst, mb_w)
 		goto _1
 	_1:
 		;
 		y = y + int32(2)
 	}
 	// move to last row
 	cur_y = cur_y + uintptr((*VP8Io)(unsafe.Pointer(io)).Fy_stride)
 	if (*VP8Io)(unsafe.Pointer(io)).Fcrop_top+y_end < (*VP8Io)(unsafe.Pointer(io)).Fcrop_bottom {
 		// Save the unfinished samples for next call (as we're not done yet).
 		libc.X__builtin___memcpy_chk(tls, (*WebPDecParams)(unsafe.Pointer(p)).Ftmp_y, cur_y, libc.Uint64FromInt32(mb_w)*uint64(1), ^__predefined_size_t(0))
 		libc.X__builtin___memcpy_chk(tls, (*WebPDecParams)(unsafe.Pointer(p)).Ftmp_u, cur_u, libc.Uint64FromInt32(uv_w)*uint64(1), ^__predefined_size_t(0))
 		libc.X__builtin___memcpy_chk(tls, (*WebPDecParams)(unsafe.Pointer(p)).Ftmp_v, cur_v, libc.Uint64FromInt32(uv_w)*uint64(1), ^__predefined_size_t(0))
 		// The fancy upsampler leaves a row unfinished behind
 		// (except for the very last row)
 		num_lines_out = num_lines_out - 1
 	} else {
 		// Process the very last row of even-sized picture
 		if !(y_end&libc.Int32FromInt32(1) != 0) {
 			(*(*func(*libc.TLS, uintptr, uintptr, uintptr, uintptr, uintptr, uintptr, uintptr, uintptr, int32))(unsafe.Pointer(&struct{ uintptr }{upsample})))(tls, cur_y, libc.UintptrFromInt32(0), cur_u, cur_v, cur_u, cur_v, dst+uintptr((*WebPRGBABuffer)(unsafe.Pointer(buf)).Fstride), libc.UintptrFromInt32(0), mb_w)
 		}
 	}
 	return num_lines_out
 }
 
 //------------------------------------------------------------------------------
 
 func FillAlphaPlane(tls *libc.TLS, dst uintptr, w int32, h int32, stride int32) {
 	var j int32
 	_ = j
 	j = 0
 	for {
 		if !(j < h) {
 			break
 		}
 		libc.X__builtin___memset_chk(tls, dst, int32(0xff), libc.Uint64FromInt32(w)*uint64(1), ^__predefined_size_t(0))
 		dst = dst + uintptr(stride)
 		goto _1
 	_1:
 		;
 		j = j + 1
 	}
 }
 
 func EmitAlphaYUV(tls *libc.TLS, io uintptr, p uintptr, expected_num_lines_out int32) (r int32) {
 	var alpha, buf, dst uintptr
 	var j, mb_h, mb_w int32
 	_, _, _, _, _, _ = alpha, buf, dst, j, mb_h, mb_w
 	alpha = (*VP8Io)(unsafe.Pointer(io)).Fa
 	buf = (*WebPDecParams)(unsafe.Pointer(p)).Foutput + 16
 	mb_w = (*VP8Io)(unsafe.Pointer(io)).Fmb_w
 	mb_h = (*VP8Io)(unsafe.Pointer(io)).Fmb_h
 	dst = (*WebPYUVABuffer)(unsafe.Pointer(buf)).Fa + uintptr(int64((*VP8Io)(unsafe.Pointer(io)).Fmb_y)*int64((*WebPYUVABuffer)(unsafe.Pointer(buf)).Fa_stride))
 	_ = expected_num_lines_out
 	if alpha != libc.UintptrFromInt32(0) {
 		j = 0
 		for {
 			if !(j < mb_h) {
 				break
 			}
 			libc.X__builtin___memcpy_chk(tls, dst, alpha, libc.Uint64FromInt32(mb_w)*uint64(1), ^__predefined_size_t(0))
 			alpha = alpha + uintptr((*VP8Io)(unsafe.Pointer(io)).Fwidth)
 			dst = dst + uintptr((*WebPYUVABuffer)(unsafe.Pointer(buf)).Fa_stride)
 			goto _1
 		_1:
 			;
 			j = j + 1
 		}
 	} else {
 		if (*WebPYUVABuffer)(unsafe.Pointer(buf)).Fa != libc.UintptrFromInt32(0) {
 			// the user requested alpha, but there is none, set it to opaque.
 			FillAlphaPlane(tls, dst, mb_w, mb_h, (*WebPYUVABuffer)(unsafe.Pointer(buf)).Fa_stride)
 		}
 	}
 	return 0
 }
 
 func GetAlphaSourceRow(tls *libc.TLS, io uintptr, alpha uintptr, num_rows uintptr) (r int32) {
 	var start_y int32
 	_ = start_y
 	start_y = (*VP8Io)(unsafe.Pointer(io)).Fmb_y
 	**(**int32)(__ccgo_up(num_rows)) = (*VP8Io)(unsafe.Pointer(io)).Fmb_h
 	// Compensate for the 1-line delay of the fancy upscaler.
 	// This is similar to EmitFancyRGB().
 	if (*VP8Io)(unsafe.Pointer(io)).Ffancy_upsampling != 0 {
 		if start_y == 0 {
 			// We don't process the last row yet. It'll be done during the next call.
 			**(**int32)(__ccgo_up(num_rows)) = **(**int32)(__ccgo_up(num_rows)) - 1
 		} else {
 			start_y = start_y - 1
 			// Fortunately, *alpha data is persistent, so we can go back
 			// one row and finish alpha blending, now that the fancy upscaler
 			// completed the YUV->RGB interpolation.
 			**(**uintptr)(__ccgo_up(alpha)) -= uintptr((*VP8Io)(unsafe.Pointer(io)).Fwidth)
 		}
 		if (*VP8Io)(unsafe.Pointer(io)).Fcrop_top+(*VP8Io)(unsafe.Pointer(io)).Fmb_y+(*VP8Io)(unsafe.Pointer(io)).Fmb_h == (*VP8Io)(unsafe.Pointer(io)).Fcrop_bottom {
 			// If it's the very last call, we process all the remaining rows!
 			**(**int32)(__ccgo_up(num_rows)) = (*VP8Io)(unsafe.Pointer(io)).Fcrop_bottom - (*VP8Io)(unsafe.Pointer(io)).Fcrop_top - start_y
 		}
 	}
 	return start_y
 }
 
 func EmitAlphaRGB(tls *libc.TLS, io uintptr, p uintptr, expected_num_lines_out int32) (r int32) {
 	bp := tls.Alloc(16)
 	defer tls.Free(16)
 	var alpha_first, has_alpha, mb_w, start_y, v1 int32
 	var base_rgba, buf, dst uintptr
 	var colorspace, v2 WEBP_CSP_MODE1
 	var v5 bool
 	var _ /* alpha at bp+0 */ uintptr
 	var _ /* num_rows at bp+8 */ int32
 	_, _, _, _, _, _, _, _, _, _, _ = alpha_first, base_rgba, buf, colorspace, dst, has_alpha, mb_w, start_y, v1, v2, v5
 	**(**uintptr)(__ccgo_up(bp)) = (*VP8Io)(unsafe.Pointer(io)).Fa
 	if **(**uintptr)(__ccgo_up(bp)) != libc.UintptrFromInt32(0) {
 		mb_w = (*VP8Io)(unsafe.Pointer(io)).Fmb_w
 		colorspace = (*WebPDecBuffer)(unsafe.Pointer((*WebPDecParams)(unsafe.Pointer(p)).Foutput)).Fcolorspace
 		alpha_first = libc.BoolInt32(colorspace == int32(MODE_ARGB) || colorspace == int32(MODE_Argb))
 		buf = (*WebPDecParams)(unsafe.Pointer(p)).Foutput + 16
 		start_y = GetAlphaSourceRow(tls, io, bp, bp+8)
 		base_rgba = (*WebPRGBABuffer)(unsafe.Pointer(buf)).Frgba + uintptr(int64(start_y)*int64((*WebPRGBABuffer)(unsafe.Pointer(buf)).Fstride))
 		if alpha_first != 0 {
 			v1 = 0
 		} else {
 			v1 = int32(3)
 		}
 		dst = base_rgba + uintptr(v1)
 		has_alpha = (*(*func(*libc.TLS, uintptr, int32, int32, int32, uintptr, int32) int32)(unsafe.Pointer(&struct{ uintptr }{WebPDispatchAlpha})))(tls, **(**uintptr)(__ccgo_up(bp)), (*VP8Io)(unsafe.Pointer(io)).Fwidth, mb_w, **(**int32)(__ccgo_up(bp + 8)), dst, (*WebPRGBABuffer)(unsafe.Pointer(buf)).Fstride)
 		_ = expected_num_lines_out
 		// has_alpha is true if there's non-trivial alpha to premultiply with.
 		if v5 = has_alpha != 0; v5 {
 			v2 = colorspace
 			v1 = libc.BoolInt32(v2 == int32(MODE_rgbA) || v2 == int32(MODE_bgrA) || v2 == int32(MODE_Argb) || v2 == int32(MODE_rgbA_4444))
 			goto _4
 		_4:
 		}
 		if v5 && v1 != 0 {
 			(*(*func(*libc.TLS, uintptr, int32, int32, int32, int32))(unsafe.Pointer(&struct{ uintptr }{WebPApplyAlphaMultiply})))(tls, base_rgba, alpha_first, mb_w, **(**int32)(__ccgo_up(bp + 8)), (*WebPRGBABuffer)(unsafe.Pointer(buf)).Fstride)
 		}
 	}
 	return 0
 }
 
 func EmitAlphaRGBA4444(tls *libc.TLS, io uintptr, p uintptr, expected_num_lines_out int32) (r int32) {
 	bp := tls.Alloc(16)
 	defer tls.Free(16)
 	var alpha_dst, base_rgba, buf uintptr
 	var alpha_mask, alpha_value uint32_t
 	var colorspace, v3 WEBP_CSP_MODE1
 	var i, j, mb_w, start_y, v4 int32
 	var v6 bool
 	var _ /* alpha at bp+0 */ uintptr
 	var _ /* num_rows at bp+8 */ int32
 	_, _, _, _, _, _, _, _, _, _, _, _, _ = alpha_dst, alpha_mask, alpha_value, base_rgba, buf, colorspace, i, j, mb_w, start_y, v3, v4, v6
 	**(**uintptr)(__ccgo_up(bp)) = (*VP8Io)(unsafe.Pointer(io)).Fa
 	if **(**uintptr)(__ccgo_up(bp)) != libc.UintptrFromInt32(0) {
 		mb_w = (*VP8Io)(unsafe.Pointer(io)).Fmb_w
 		colorspace = (*WebPDecBuffer)(unsafe.Pointer((*WebPDecParams)(unsafe.Pointer(p)).Foutput)).Fcolorspace
 		buf = (*WebPDecParams)(unsafe.Pointer(p)).Foutput + 16
 		start_y = GetAlphaSourceRow(tls, io, bp, bp+8)
 		base_rgba = (*WebPRGBABuffer)(unsafe.Pointer(buf)).Frgba + uintptr(int64(start_y)*int64((*WebPRGBABuffer)(unsafe.Pointer(buf)).Fstride))
 		alpha_dst = base_rgba + uintptr(1)
 		alpha_mask = uint32(0x0f)
 		j = 0
 		for {
 			if !(j < **(**int32)(__ccgo_up(bp + 8))) {
 				break
 			}
 			i = 0
 			for {
 				if !(i < mb_w) {
 					break
 				}
 				// Fill in the alpha value (converted to 4 bits).
 				alpha_value = libc.Uint32FromInt32(libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(**(**uintptr)(__ccgo_up(bp)) + uintptr(i)))) >> int32(4))
 				**(**uint8_t)(__ccgo_up(alpha_dst + uintptr(int32(2)*i))) = uint8(libc.Uint32FromInt32(libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(alpha_dst + uintptr(int32(2)*i))))&libc.Int32FromInt32(0xf0)) | alpha_value)
 				alpha_mask = alpha_mask & alpha_value
 				goto _2
 			_2:
 				;
 				i = i + 1
 			}
 			**(**uintptr)(__ccgo_up(bp)) = **(**uintptr)(__ccgo_up(bp)) + uintptr((*VP8Io)(unsafe.Pointer(io)).Fwidth)
 			alpha_dst = alpha_dst + uintptr((*WebPRGBABuffer)(unsafe.Pointer(buf)).Fstride)
 			goto _1
 		_1:
 			;
 			j = j + 1
 		}
 		_ = expected_num_lines_out
 		if v6 = alpha_mask != uint32(0x0f); v6 {
 			v3 = colorspace
 			v4 = libc.BoolInt32(v3 == int32(MODE_rgbA) || v3 == int32(MODE_bgrA) || v3 == int32(MODE_Argb) || v3 == int32(MODE_rgbA_4444))
 			goto _5
 		_5:
 		}
 		if v6 && v4 != 0 {
 			(*(*func(*libc.TLS, uintptr, int32, int32, int32))(unsafe.Pointer(&struct{ uintptr }{WebPApplyAlphaMultiply4444})))(tls, base_rgba, mb_w, **(**int32)(__ccgo_up(bp + 8)), (*WebPRGBABuffer)(unsafe.Pointer(buf)).Fstride)
 		}
 	}
 	return 0
 }
 
 //------------------------------------------------------------------------------
 // YUV rescaling (no final RGB conversion needed)
 
 func Rescale(tls *libc.TLS, src uintptr, src_stride int32, new_lines int32, wrk uintptr) (r int32) {
 	var lines_in, num_lines_out int32
 	_, _ = lines_in, num_lines_out
 	num_lines_out = 0
 	for new_lines > 0 { // import new contributions of source rows.
 		lines_in = WebPRescalerImport(tls, wrk, new_lines, src, src_stride)
 		src = src + uintptr(lines_in*src_stride)
 		new_lines = new_lines - lines_in
 		num_lines_out = num_lines_out + WebPRescalerExport(tls, wrk) // emit output row(s)
 	}
 	return num_lines_out
 }
 
 func EmitRescaledYUV(tls *libc.TLS, io uintptr, p uintptr) (r int32) {
 	var mb_h, num_lines_out, uv_mb_h, v2, v5 int32
 	var scaler uintptr
 	var v1, v4 WEBP_CSP_MODE1
 	var v7 bool
 	_, _, _, _, _, _, _, _, _ = mb_h, num_lines_out, scaler, uv_mb_h, v1, v2, v4, v5, v7
 	mb_h = (*VP8Io)(unsafe.Pointer(io)).Fmb_h
 	uv_mb_h = (mb_h + int32(1)) >> int32(1)
 	scaler = (*WebPDecParams)(unsafe.Pointer(p)).Fscaler_y
 	num_lines_out = 0
 	v1 = (*WebPDecBuffer)(unsafe.Pointer((*WebPDecParams)(unsafe.Pointer(p)).Foutput)).Fcolorspace
 	if v7 = v1 == int32(MODE_RGBA) || v1 == int32(MODE_BGRA) || v1 == int32(MODE_ARGB) || v1 == int32(MODE_RGBA_4444) || v1 == int32(MODE_YUVA); !v7 {
 		v4 = v1
 		v5 = libc.BoolInt32(v4 == int32(MODE_rgbA) || v4 == int32(MODE_bgrA) || v4 == int32(MODE_Argb) || v4 == int32(MODE_rgbA_4444))
 		goto _6
 	_6:
 	}
 	v2 = libc.BoolInt32(v7 || v5 != 0)
 	goto _3
 _3:
 	;
 	if v2 != 0 && (*VP8Io)(unsafe.Pointer(io)).Fa != libc.UintptrFromInt32(0) {
 		// Before rescaling, we premultiply the luma directly into the io->y
 		// internal buffer. This is OK since these samples are not used for
 		// intra-prediction (the top samples are saved in cache_y/u/v).
 		// But we need to cast the const away, though.
 		WebPMultRows(tls, (*VP8Io)(unsafe.Pointer(io)).Fy, (*VP8Io)(unsafe.Pointer(io)).Fy_stride, (*VP8Io)(unsafe.Pointer(io)).Fa, (*VP8Io)(unsafe.Pointer(io)).Fwidth, (*VP8Io)(unsafe.Pointer(io)).Fmb_w, mb_h, 0)
 	}
 	num_lines_out = Rescale(tls, (*VP8Io)(unsafe.Pointer(io)).Fy, (*VP8Io)(unsafe.Pointer(io)).Fy_stride, mb_h, scaler)
 	Rescale(tls, (*VP8Io)(unsafe.Pointer(io)).Fu, (*VP8Io)(unsafe.Pointer(io)).Fuv_stride, uv_mb_h, (*WebPDecParams)(unsafe.Pointer(p)).Fscaler_u)
 	Rescale(tls, (*VP8Io)(unsafe.Pointer(io)).Fv, (*VP8Io)(unsafe.Pointer(io)).Fuv_stride, uv_mb_h, (*WebPDecParams)(unsafe.Pointer(p)).Fscaler_v)
 	return num_lines_out
 }
 
 func EmitRescaledAlphaYUV(tls *libc.TLS, io uintptr, p uintptr, expected_num_lines_out int32) (r int32) {
 	var buf, dst_a, dst_y uintptr
 	var num_lines_out int32
 	_, _, _, _ = buf, dst_a, dst_y, num_lines_out
 	buf = (*WebPDecParams)(unsafe.Pointer(p)).Foutput + 16
 	dst_a = (*WebPYUVABuffer)(unsafe.Pointer(buf)).Fa + uintptr(int64((*WebPDecParams)(unsafe.Pointer(p)).Flast_y)*int64((*WebPYUVABuffer)(unsafe.Pointer(buf)).Fa_stride))
 	if (*VP8Io)(unsafe.Pointer(io)).Fa != libc.UintptrFromInt32(0) {
 		dst_y = (*WebPYUVABuffer)(unsafe.Pointer(buf)).Fy + uintptr(int64((*WebPDecParams)(unsafe.Pointer(p)).Flast_y)*int64((*WebPYUVABuffer)(unsafe.Pointer(buf)).Fy_stride))
 		num_lines_out = Rescale(tls, (*VP8Io)(unsafe.Pointer(io)).Fa, (*VP8Io)(unsafe.Pointer(io)).Fwidth, (*VP8Io)(unsafe.Pointer(io)).Fmb_h, (*WebPDecParams)(unsafe.Pointer(p)).Fscaler_a)
 		if num_lines_out > 0 { // unmultiply the Y
 			WebPMultRows(tls, dst_y, (*WebPYUVABuffer)(unsafe.Pointer(buf)).Fy_stride, dst_a, (*WebPYUVABuffer)(unsafe.Pointer(buf)).Fa_stride, (*WebPRescaler)(unsafe.Pointer((*WebPDecParams)(unsafe.Pointer(p)).Fscaler_a)).Fdst_width, num_lines_out, int32(1))
 		}
 	} else {
 		if (*WebPYUVABuffer)(unsafe.Pointer(buf)).Fa != libc.UintptrFromInt32(0) {
 			// the user requested alpha, but there is none, set it to opaque.
 			FillAlphaPlane(tls, dst_a, (*VP8Io)(unsafe.Pointer(io)).Fscaled_width, expected_num_lines_out, (*WebPYUVABuffer)(unsafe.Pointer(buf)).Fa_stride)
 		}
 	}
 	return 0
 }
 
 func InitYUVRescaler(tls *libc.TLS, io uintptr, p uintptr) (r int32) {
 	var buf, scalers, work, v12 uintptr
 	var has_alpha, num_rescalers, out_height, out_width, uv_in_height, uv_in_width, uv_out_height, uv_out_width, v2, v5, v8 int32
 	var rescaler_size, uv_work_size, work_size size_t
 	var total_size, v9 uint64_t
 	var v1, v4 WEBP_CSP_MODE1
 	var v7 bool
 	_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = buf, has_alpha, num_rescalers, out_height, out_width, rescaler_size, scalers, total_size, uv_in_height, uv_in_width, uv_out_height, uv_out_width, uv_work_size, work, work_size, v1, v12, v2, v4, v5, v7, v8, v9
 	v1 = (*WebPDecBuffer)(unsafe.Pointer((*WebPDecParams)(unsafe.Pointer(p)).Foutput)).Fcolorspace
 	if v7 = v1 == int32(MODE_RGBA) || v1 == int32(MODE_BGRA) || v1 == int32(MODE_ARGB) || v1 == int32(MODE_RGBA_4444) || v1 == int32(MODE_YUVA); !v7 {
 		v4 = v1
 		v5 = libc.BoolInt32(v4 == int32(MODE_rgbA) || v4 == int32(MODE_bgrA) || v4 == int32(MODE_Argb) || v4 == int32(MODE_rgbA_4444))
 		goto _6
 	_6:
 	}
 	v2 = libc.BoolInt32(v7 || v5 != 0)
 	goto _3
 _3:
 	has_alpha = v2
 	buf = (*WebPDecParams)(unsafe.Pointer(p)).Foutput + 16
 	out_width = (*VP8Io)(unsafe.Pointer(io)).Fscaled_width
 	out_height = (*VP8Io)(unsafe.Pointer(io)).Fscaled_height
 	uv_out_width = (out_width + int32(1)) >> int32(1)
 	uv_out_height = (out_height + int32(1)) >> int32(1)
 	uv_in_width = ((*VP8Io)(unsafe.Pointer(io)).Fmb_w + int32(1)) >> int32(1)
 	uv_in_height = ((*VP8Io)(unsafe.Pointer(io)).Fmb_h + int32(1)) >> int32(1)
 	// scratch memory for luma rescaler
 	work_size = uint64(2) * libc.Uint64FromInt32(out_width)
 	uv_work_size = libc.Uint64FromInt32(int32(2) * uv_out_width)
 	if has_alpha != 0 {
 		v8 = int32(4)
 	} else {
 		v8 = int32(3)
 	}
 	num_rescalers = v8
 	total_size = (work_size + uint64(2)*uv_work_size) * uint64(4)
 	if has_alpha != 0 {
 		total_size = total_size + work_size*uint64(4)
 	}
 	rescaler_size = libc.Uint64FromInt32(num_rescalers)*uint64(104) + uint64(WEBP_ALIGN_CST)
 	total_size = total_size + rescaler_size
 	v9 = total_size
 	v2 = libc.BoolInt32(v9 == v9)
 	goto _11
 _11:
 	if !(v2 != 0) {
 		return 0
 	}
 	(*WebPDecParams)(unsafe.Pointer(p)).Fmemory = WebPSafeMalloc(tls, uint64(1), total_size)
 	if (*WebPDecParams)(unsafe.Pointer(p)).Fmemory == libc.UintptrFromInt32(0) {
 		return 0 // memory error
 	}
 	work = (*WebPDecParams)(unsafe.Pointer(p)).Fmemory
 	scalers = uintptr((uint64(work+uintptr(total_size)-uintptr(rescaler_size)) + libc.Uint64FromInt32(WEBP_ALIGN_CST)) & ^libc.Uint64FromInt32(WEBP_ALIGN_CST))
 	(*WebPDecParams)(unsafe.Pointer(p)).Fscaler_y = scalers
 	(*WebPDecParams)(unsafe.Pointer(p)).Fscaler_u = scalers + 1*104
 	(*WebPDecParams)(unsafe.Pointer(p)).Fscaler_v = scalers + 2*104
 	if has_alpha != 0 {
 		v12 = scalers + 3*104
 	} else {
 		v12 = libc.UintptrFromInt32(0)
 	}
 	(*WebPDecParams)(unsafe.Pointer(p)).Fscaler_a = v12
 	if !(WebPRescalerInit(tls, (*WebPDecParams)(unsafe.Pointer(p)).Fscaler_y, (*VP8Io)(unsafe.Pointer(io)).Fmb_w, (*VP8Io)(unsafe.Pointer(io)).Fmb_h, (*WebPYUVABuffer)(unsafe.Pointer(buf)).Fy, out_width, out_height, (*WebPYUVABuffer)(unsafe.Pointer(buf)).Fy_stride, int32(1), work) != 0) || !(WebPRescalerInit(tls, (*WebPDecParams)(unsafe.Pointer(p)).Fscaler_u, uv_in_width, uv_in_height, (*WebPYUVABuffer)(unsafe.Pointer(buf)).Fu, uv_out_width, uv_out_height, (*WebPYUVABuffer)(unsafe.Pointer(buf)).Fu_stride, int32(1), work+uintptr(work_size)*4) != 0) || !(WebPRescalerInit(tls, (*WebPDecParams)(unsafe.Pointer(p)).Fscaler_v, uv_in_width, uv_in_height, (*WebPYUVABuffer)(unsafe.Pointer(buf)).Fv, uv_out_width, uv_out_height, (*WebPYUVABuffer)(unsafe.Pointer(buf)).Fv_stride, int32(1), work+uintptr(work_size)*4+uintptr(uv_work_size)*4) != 0) {
 		return 0
 	}
 	(*WebPDecParams)(unsafe.Pointer(p)).Femit = __ccgo_fp(EmitRescaledYUV)
 	if has_alpha != 0 {
 		if !(WebPRescalerInit(tls, (*WebPDecParams)(unsafe.Pointer(p)).Fscaler_a, (*VP8Io)(unsafe.Pointer(io)).Fmb_w, (*VP8Io)(unsafe.Pointer(io)).Fmb_h, (*WebPYUVABuffer)(unsafe.Pointer(buf)).Fa, out_width, out_height, (*WebPYUVABuffer)(unsafe.Pointer(buf)).Fa_stride, int32(1), work+uintptr(work_size)*4+uintptr(uint64(2)*uv_work_size)*4) != 0) {
 			return 0
 		}
 		(*WebPDecParams)(unsafe.Pointer(p)).Femit_alpha = __ccgo_fp(EmitRescaledAlphaYUV)
 		WebPInitAlphaProcessing(tls)
 	}
 	return int32(1)
 }
 
 //------------------------------------------------------------------------------
 // RGBA rescaling
 
 func ExportRGB(tls *libc.TLS, p uintptr, y_pos int32) (r int32) {
 	var buf, dst, v1, v10, v4, v7 uintptr
 	var convert WebPYUV444Converter
 	var num_lines_out, v11, v2, v5, v8 int32
 	var v13 bool
 	_, _, _, _, _, _, _, _, _, _, _, _, _ = buf, convert, dst, num_lines_out, v1, v10, v11, v13, v2, v4, v5, v7, v8
 	convert = WebPYUV444Converters[(*WebPDecBuffer)(unsafe.Pointer((*WebPDecParams)(unsafe.Pointer(p)).Foutput)).Fcolorspace]
 	buf = (*WebPDecParams)(unsafe.Pointer(p)).Foutput + 16
 	dst = (*WebPRGBABuffer)(unsafe.Pointer(buf)).Frgba + uintptr(int64(y_pos)*int64((*WebPRGBABuffer)(unsafe.Pointer(buf)).Fstride))
 	num_lines_out = 0
 	// For RGB rescaling, because of the YUV420, current scan position
 	// U/V can be +1/-1 line from the Y one.  Hence the double test.
 	for {
 		v1 = (*WebPDecParams)(unsafe.Pointer(p)).Fscaler_y
 		v4 = v1
 		v5 = libc.BoolInt32((*WebPRescaler)(unsafe.Pointer(v4)).Fdst_y >= (*WebPRescaler)(unsafe.Pointer(v4)).Fdst_height)
 		goto _6
 	_6:
 		;
 		v2 = libc.BoolInt32(!(v5 != 0) && (*WebPRescaler)(unsafe.Pointer(v1)).Fy_accum <= 0)
 		goto _3
 	_3:
 		;
 		if v13 = v2 != 0; v13 {
 			v7 = (*WebPDecParams)(unsafe.Pointer(p)).Fscaler_u
 			v10 = v7
 			v11 = libc.BoolInt32((*WebPRescaler)(unsafe.Pointer(v10)).Fdst_y >= (*WebPRescaler)(unsafe.Pointer(v10)).Fdst_height)
 			goto _12
 		_12:
 			;
 			v8 = libc.BoolInt32(!(v11 != 0) && (*WebPRescaler)(unsafe.Pointer(v7)).Fy_accum <= 0)
 			goto _9
 		_9:
 		}
 		if !(v13 && v8 != 0) {
 			break
 		}
 		WebPRescalerExportRow(tls, (*WebPDecParams)(unsafe.Pointer(p)).Fscaler_y)
 		WebPRescalerExportRow(tls, (*WebPDecParams)(unsafe.Pointer(p)).Fscaler_u)
 		WebPRescalerExportRow(tls, (*WebPDecParams)(unsafe.Pointer(p)).Fscaler_v)
 		(*(*func(*libc.TLS, uintptr, uintptr, uintptr, uintptr, int32))(unsafe.Pointer(&struct{ uintptr }{convert})))(tls, (*WebPRescaler)(unsafe.Pointer((*WebPDecParams)(unsafe.Pointer(p)).Fscaler_y)).Fdst, (*WebPRescaler)(unsafe.Pointer((*WebPDecParams)(unsafe.Pointer(p)).Fscaler_u)).Fdst, (*WebPRescaler)(unsafe.Pointer((*WebPDecParams)(unsafe.Pointer(p)).Fscaler_v)).Fdst, dst, (*WebPRescaler)(unsafe.Pointer((*WebPDecParams)(unsafe.Pointer(p)).Fscaler_y)).Fdst_width)
 		dst = dst + uintptr((*WebPRGBABuffer)(unsafe.Pointer(buf)).Fstride)
 		num_lines_out = num_lines_out + 1
 	}
 	return num_lines_out
 }
 
 func EmitRescaledRGB(tls *libc.TLS, io uintptr, p uintptr) (r int32) {
 	var j, mb_h, num_lines_out, u_lines_in, uv_j, uv_mb_h, v_lines_in, y_lines_in int32
 	_, _, _, _, _, _, _, _ = j, mb_h, num_lines_out, u_lines_in, uv_j, uv_mb_h, v_lines_in, y_lines_in
 	mb_h = (*VP8Io)(unsafe.Pointer(io)).Fmb_h
 	uv_mb_h = (mb_h + int32(1)) >> int32(1)
 	j = 0
 	uv_j = 0
 	num_lines_out = 0
 	for j < mb_h {
 		y_lines_in = WebPRescalerImport(tls, (*WebPDecParams)(unsafe.Pointer(p)).Fscaler_y, mb_h-j, (*VP8Io)(unsafe.Pointer(io)).Fy+uintptr(int64(j)*int64((*VP8Io)(unsafe.Pointer(io)).Fy_stride)), (*VP8Io)(unsafe.Pointer(io)).Fy_stride)
 		j = j + y_lines_in
 		if WebPRescaleNeededLines(tls, (*WebPDecParams)(unsafe.Pointer(p)).Fscaler_u, uv_mb_h-uv_j) != 0 {
 			u_lines_in = WebPRescalerImport(tls, (*WebPDecParams)(unsafe.Pointer(p)).Fscaler_u, uv_mb_h-uv_j, (*VP8Io)(unsafe.Pointer(io)).Fu+uintptr(int64(uv_j)*int64((*VP8Io)(unsafe.Pointer(io)).Fuv_stride)), (*VP8Io)(unsafe.Pointer(io)).Fuv_stride)
 			v_lines_in = WebPRescalerImport(tls, (*WebPDecParams)(unsafe.Pointer(p)).Fscaler_v, uv_mb_h-uv_j, (*VP8Io)(unsafe.Pointer(io)).Fv+uintptr(int64(uv_j)*int64((*VP8Io)(unsafe.Pointer(io)).Fuv_stride)), (*VP8Io)(unsafe.Pointer(io)).Fuv_stride)
 			_ = v_lines_in // remove a gcc warning
 			uv_j = uv_j + u_lines_in
 		}
 		num_lines_out = num_lines_out + ExportRGB(tls, p, (*WebPDecParams)(unsafe.Pointer(p)).Flast_y+num_lines_out)
 	}
 	return num_lines_out
 }
 
 func ExportAlpha(tls *libc.TLS, p uintptr, y_pos int32, max_lines_out int32) (r int32) {
 	var alpha_first, is_premult_alpha, num_lines_out, width, v1, v3, v6, v9 int32
 	var base_rgba, buf, dst, v5, v8 uintptr
 	var colorspace, v2 WEBP_CSP_MODE1
 	var non_opaque uint32_t
 	_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = alpha_first, base_rgba, buf, colorspace, dst, is_premult_alpha, non_opaque, num_lines_out, width, v1, v2, v3, v5, v6, v8, v9
 	buf = (*WebPDecParams)(unsafe.Pointer(p)).Foutput + 16
 	base_rgba = (*WebPRGBABuffer)(unsafe.Pointer(buf)).Frgba + uintptr(int64(y_pos)*int64((*WebPRGBABuffer)(unsafe.Pointer(buf)).Fstride))
 	colorspace = (*WebPDecBuffer)(unsafe.Pointer((*WebPDecParams)(unsafe.Pointer(p)).Foutput)).Fcolorspace
 	alpha_first = libc.BoolInt32(colorspace == int32(MODE_ARGB) || colorspace == int32(MODE_Argb))
 	if alpha_first != 0 {
 		v1 = 0
 	} else {
 		v1 = int32(3)
 	}
 	dst = base_rgba + uintptr(v1)
 	num_lines_out = 0
 	v2 = colorspace
 	v3 = libc.BoolInt32(v2 == int32(MODE_rgbA) || v2 == int32(MODE_bgrA) || v2 == int32(MODE_Argb) || v2 == int32(MODE_rgbA_4444))
 	goto _4
 _4:
 	is_premult_alpha = v3
 	non_opaque = uint32(0)
 	width = (*WebPRescaler)(unsafe.Pointer((*WebPDecParams)(unsafe.Pointer(p)).Fscaler_a)).Fdst_width
 	for {
 		v5 = (*WebPDecParams)(unsafe.Pointer(p)).Fscaler_a
 		v8 = v5
 		v9 = libc.BoolInt32((*WebPRescaler)(unsafe.Pointer(v8)).Fdst_y >= (*WebPRescaler)(unsafe.Pointer(v8)).Fdst_height)
 		goto _10
 	_10:
 		;
 		v6 = libc.BoolInt32(!(v9 != 0) && (*WebPRescaler)(unsafe.Pointer(v5)).Fy_accum <= 0)
 		goto _7
 	_7:
 		;
 		if !(v6 != 0 && num_lines_out < max_lines_out) {
 			break
 		}
 		WebPRescalerExportRow(tls, (*WebPDecParams)(unsafe.Pointer(p)).Fscaler_a)
 		non_opaque = non_opaque | libc.Uint32FromInt32((*(*func(*libc.TLS, uintptr, int32, int32, int32, uintptr, int32) int32)(unsafe.Pointer(&struct{ uintptr }{WebPDispatchAlpha})))(tls, (*WebPRescaler)(unsafe.Pointer((*WebPDecParams)(unsafe.Pointer(p)).Fscaler_a)).Fdst, 0, width, int32(1), dst, 0))
 		dst = dst + uintptr((*WebPRGBABuffer)(unsafe.Pointer(buf)).Fstride)
 		num_lines_out = num_lines_out + 1
 	}
 	if is_premult_alpha != 0 && non_opaque != 0 {
 		(*(*func(*libc.TLS, uintptr, int32, int32, int32, int32))(unsafe.Pointer(&struct{ uintptr }{WebPApplyAlphaMultiply})))(tls, base_rgba, alpha_first, width, num_lines_out, (*WebPRGBABuffer)(unsafe.Pointer(buf)).Fstride)
 	}
 	return num_lines_out
 }
 
 func ExportAlphaRGBA4444(tls *libc.TLS, p uintptr, y_pos int32, max_lines_out int32) (r int32) {
 	var alpha_dst, base_rgba, buf, v4, v7 uintptr
 	var alpha_mask, alpha_value uint32_t
 	var colorspace, v1 WEBP_CSP_MODE1
 	var i, is_premult_alpha, num_lines_out, width, v2, v5, v8 int32
 	_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = alpha_dst, alpha_mask, alpha_value, base_rgba, buf, colorspace, i, is_premult_alpha, num_lines_out, width, v1, v2, v4, v5, v7, v8
 	buf = (*WebPDecParams)(unsafe.Pointer(p)).Foutput + 16
 	base_rgba = (*WebPRGBABuffer)(unsafe.Pointer(buf)).Frgba + uintptr(int64(y_pos)*int64((*WebPRGBABuffer)(unsafe.Pointer(buf)).Fstride))
 	alpha_dst = base_rgba + uintptr(1)
 	num_lines_out = 0
 	colorspace = (*WebPDecBuffer)(unsafe.Pointer((*WebPDecParams)(unsafe.Pointer(p)).Foutput)).Fcolorspace
 	width = (*WebPRescaler)(unsafe.Pointer((*WebPDecParams)(unsafe.Pointer(p)).Fscaler_a)).Fdst_width
 	v1 = colorspace
 	v2 = libc.BoolInt32(v1 == int32(MODE_rgbA) || v1 == int32(MODE_bgrA) || v1 == int32(MODE_Argb) || v1 == int32(MODE_rgbA_4444))
 	goto _3
 _3:
 	is_premult_alpha = v2
 	alpha_mask = uint32(0x0f)
 	for {
 		v4 = (*WebPDecParams)(unsafe.Pointer(p)).Fscaler_a
 		v7 = v4
 		v8 = libc.BoolInt32((*WebPRescaler)(unsafe.Pointer(v7)).Fdst_y >= (*WebPRescaler)(unsafe.Pointer(v7)).Fdst_height)
 		goto _9
 	_9:
 		;
 		v5 = libc.BoolInt32(!(v8 != 0) && (*WebPRescaler)(unsafe.Pointer(v4)).Fy_accum <= 0)
 		goto _6
 	_6:
 		;
 		if !(v5 != 0 && num_lines_out < max_lines_out) {
 			break
 		}
 		WebPRescalerExportRow(tls, (*WebPDecParams)(unsafe.Pointer(p)).Fscaler_a)
 		i = 0
 		for {
 			if !(i < width) {
 				break
 			}
 			// Fill in the alpha value (converted to 4 bits).
 			alpha_value = libc.Uint32FromInt32(libc.Int32FromUint8(**(**uint8_t)(__ccgo_up((*WebPRescaler)(unsafe.Pointer((*WebPDecParams)(unsafe.Pointer(p)).Fscaler_a)).Fdst + uintptr(i)))) >> int32(4))
 			**(**uint8_t)(__ccgo_up(alpha_dst + uintptr(int32(2)*i))) = uint8(libc.Uint32FromInt32(libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(alpha_dst + uintptr(int32(2)*i))))&libc.Int32FromInt32(0xf0)) | alpha_value)
 			alpha_mask = alpha_mask & alpha_value
 			goto _10
 		_10:
 			;
 			i = i + 1
 		}
 		alpha_dst = alpha_dst + uintptr((*WebPRGBABuffer)(unsafe.Pointer(buf)).Fstride)
 		num_lines_out = num_lines_out + 1
 	}
 	if is_premult_alpha != 0 && alpha_mask != uint32(0x0f) {
 		(*(*func(*libc.TLS, uintptr, int32, int32, int32))(unsafe.Pointer(&struct{ uintptr }{WebPApplyAlphaMultiply4444})))(tls, base_rgba, width, num_lines_out, (*WebPRGBABuffer)(unsafe.Pointer(buf)).Fstride)
 	}
 	return num_lines_out
 }
 
 func EmitRescaledAlphaRGB(tls *libc.TLS, io uintptr, p uintptr, expected_num_out_lines int32) (r int32) {
 	var lines_left, y_end int32
 	var row_offset int64_t
 	var scaler uintptr
 	_, _, _, _ = lines_left, row_offset, scaler, y_end
 	if (*VP8Io)(unsafe.Pointer(io)).Fa != libc.UintptrFromInt32(0) {
 		scaler = (*WebPDecParams)(unsafe.Pointer(p)).Fscaler_a
 		lines_left = expected_num_out_lines
 		y_end = (*WebPDecParams)(unsafe.Pointer(p)).Flast_y + lines_left
 		for lines_left > 0 {
 			row_offset = int64((*WebPRescaler)(unsafe.Pointer(scaler)).Fsrc_y) - int64((*VP8Io)(unsafe.Pointer(io)).Fmb_y)
 			WebPRescalerImport(tls, scaler, (*VP8Io)(unsafe.Pointer(io)).Fmb_h+(*VP8Io)(unsafe.Pointer(io)).Fmb_y-(*WebPRescaler)(unsafe.Pointer(scaler)).Fsrc_y, (*VP8Io)(unsafe.Pointer(io)).Fa+uintptr(row_offset*int64((*VP8Io)(unsafe.Pointer(io)).Fwidth)), (*VP8Io)(unsafe.Pointer(io)).Fwidth)
 			lines_left = lines_left - (*(*func(*libc.TLS, uintptr, int32, int32) int32)(unsafe.Pointer(&struct{ uintptr }{(*WebPDecParams)(unsafe.Pointer(p)).Femit_alpha_row})))(tls, p, y_end-lines_left, lines_left)
 		}
 	}
 	return 0
 }
 
 func InitRGBRescaler(tls *libc.TLS, io uintptr, p uintptr) (r int32) {
 	var has_alpha, num_rescalers, out_height, out_width, uv_in_height, uv_in_width, v2, v5, v8 int32
 	var rescaler_size, work_size size_t
 	var scalers, tmp, work, v12 uintptr
 	var tmp_size1, tmp_size2, total_size, v9 uint64_t
 	var v1, v4 WEBP_CSP_MODE1
 	var v7 bool
 	_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = has_alpha, num_rescalers, out_height, out_width, rescaler_size, scalers, tmp, tmp_size1, tmp_size2, total_size, uv_in_height, uv_in_width, work, work_size, v1, v12, v2, v4, v5, v7, v8, v9
 	v1 = (*WebPDecBuffer)(unsafe.Pointer((*WebPDecParams)(unsafe.Pointer(p)).Foutput)).Fcolorspace
 	if v7 = v1 == int32(MODE_RGBA) || v1 == int32(MODE_BGRA) || v1 == int32(MODE_ARGB) || v1 == int32(MODE_RGBA_4444) || v1 == int32(MODE_YUVA); !v7 {
 		v4 = v1
 		v5 = libc.BoolInt32(v4 == int32(MODE_rgbA) || v4 == int32(MODE_bgrA) || v4 == int32(MODE_Argb) || v4 == int32(MODE_rgbA_4444))
 		goto _6
 	_6:
 	}
 	v2 = libc.BoolInt32(v7 || v5 != 0)
 	goto _3
 _3:
 	has_alpha = v2
 	out_width = (*VP8Io)(unsafe.Pointer(io)).Fscaled_width
 	out_height = (*VP8Io)(unsafe.Pointer(io)).Fscaled_height
 	uv_in_width = ((*VP8Io)(unsafe.Pointer(io)).Fmb_w + int32(1)) >> int32(1)
 	uv_in_height = ((*VP8Io)(unsafe.Pointer(io)).Fmb_h + int32(1)) >> int32(1)
 	// scratch memory for one rescaler
 	work_size = uint64(2) * libc.Uint64FromInt32(out_width)
 	if has_alpha != 0 {
 		v8 = int32(4)
 	} else {
 		v8 = int32(3)
 	}
 	num_rescalers = v8
 	tmp_size1 = libc.Uint64FromInt32(num_rescalers) * work_size
 	tmp_size2 = libc.Uint64FromInt32(num_rescalers) * libc.Uint64FromInt32(out_width)
 	total_size = tmp_size1*uint64(4) + tmp_size2*uint64(1)
 	rescaler_size = libc.Uint64FromInt32(num_rescalers)*uint64(104) + uint64(WEBP_ALIGN_CST)
 	total_size = total_size + rescaler_size
 	v9 = total_size
 	v2 = libc.BoolInt32(v9 == v9)
 	goto _11
 _11:
 	if !(v2 != 0) {
 		return 0
 	}
 	(*WebPDecParams)(unsafe.Pointer(p)).Fmemory = WebPSafeMalloc(tls, uint64(1), total_size)
 	if (*WebPDecParams)(unsafe.Pointer(p)).Fmemory == libc.UintptrFromInt32(0) {
 		return 0 // memory error
 	}
 	work = (*WebPDecParams)(unsafe.Pointer(p)).Fmemory
 	tmp = work + uintptr(tmp_size1)*4
 	scalers = uintptr((uint64(work+uintptr(total_size)-uintptr(rescaler_size)) + libc.Uint64FromInt32(WEBP_ALIGN_CST)) & ^libc.Uint64FromInt32(WEBP_ALIGN_CST))
 	(*WebPDecParams)(unsafe.Pointer(p)).Fscaler_y = scalers
 	(*WebPDecParams)(unsafe.Pointer(p)).Fscaler_u = scalers + 1*104
 	(*WebPDecParams)(unsafe.Pointer(p)).Fscaler_v = scalers + 2*104
 	if has_alpha != 0 {
 		v12 = scalers + 3*104
 	} else {
 		v12 = libc.UintptrFromInt32(0)
 	}
 	(*WebPDecParams)(unsafe.Pointer(p)).Fscaler_a = v12
 	if !(WebPRescalerInit(tls, (*WebPDecParams)(unsafe.Pointer(p)).Fscaler_y, (*VP8Io)(unsafe.Pointer(io)).Fmb_w, (*VP8Io)(unsafe.Pointer(io)).Fmb_h, tmp+uintptr(0*out_width), out_width, out_height, 0, int32(1), work+uintptr(uint64(0)*work_size)*4) != 0) || !(WebPRescalerInit(tls, (*WebPDecParams)(unsafe.Pointer(p)).Fscaler_u, uv_in_width, uv_in_height, tmp+uintptr(int32(1)*out_width), out_width, out_height, 0, int32(1), work+uintptr(uint64(1)*work_size)*4) != 0) || !(WebPRescalerInit(tls, (*WebPDecParams)(unsafe.Pointer(p)).Fscaler_v, uv_in_width, uv_in_height, tmp+uintptr(int32(2)*out_width), out_width, out_height, 0, int32(1), work+uintptr(uint64(2)*work_size)*4) != 0) {
 		return 0
 	}
 	(*WebPDecParams)(unsafe.Pointer(p)).Femit = __ccgo_fp(EmitRescaledRGB)
 	WebPInitYUV444Converters(tls)
 	if has_alpha != 0 {
 		if !(WebPRescalerInit(tls, (*WebPDecParams)(unsafe.Pointer(p)).Fscaler_a, (*VP8Io)(unsafe.Pointer(io)).Fmb_w, (*VP8Io)(unsafe.Pointer(io)).Fmb_h, tmp+uintptr(int32(3)*out_width), out_width, out_height, 0, int32(1), work+uintptr(uint64(3)*work_size)*4) != 0) {
 			return 0
 		}
 		(*WebPDecParams)(unsafe.Pointer(p)).Femit_alpha = __ccgo_fp(EmitRescaledAlphaRGB)
 		if (*WebPDecBuffer)(unsafe.Pointer((*WebPDecParams)(unsafe.Pointer(p)).Foutput)).Fcolorspace == int32(MODE_RGBA_4444) || (*WebPDecBuffer)(unsafe.Pointer((*WebPDecParams)(unsafe.Pointer(p)).Foutput)).Fcolorspace == int32(MODE_rgbA_4444) {
 			(*WebPDecParams)(unsafe.Pointer(p)).Femit_alpha_row = __ccgo_fp(ExportAlphaRGBA4444)
 		} else {
 			(*WebPDecParams)(unsafe.Pointer(p)).Femit_alpha_row = __ccgo_fp(ExportAlpha)
 		}
 		WebPInitAlphaProcessing(tls)
 	}
 	return int32(1)
 }
 
 //------------------------------------------------------------------------------
 // Default custom functions
 
 func CustomSetup(tls *libc.TLS, io uintptr) (r int32) {
 	var colorspace, v3, v6 WEBP_CSP_MODE1
 	var is_alpha, is_rgb, ok, uv_width, v1, v4, v7 int32
 	var p, v16, v17 uintptr
 	var v9 bool
 	_, _, _, _, _, _, _, _, _, _, _, _, _, _ = colorspace, is_alpha, is_rgb, ok, p, uv_width, v1, v16, v17, v3, v4, v6, v7, v9
 	p = (*VP8Io)(unsafe.Pointer(io)).Fopaque
 	colorspace = (*WebPDecBuffer)(unsafe.Pointer((*WebPDecParams)(unsafe.Pointer(p)).Foutput)).Fcolorspace
 	v1 = libc.BoolInt32(colorspace < int32(MODE_YUV))
 	goto _2
 _2:
 	is_rgb = v1
 	v3 = colorspace
 	if v9 = v3 == int32(MODE_RGBA) || v3 == int32(MODE_BGRA) || v3 == int32(MODE_ARGB) || v3 == int32(MODE_RGBA_4444) || v3 == int32(MODE_YUVA); !v9 {
 		v6 = v3
 		v7 = libc.BoolInt32(v6 == int32(MODE_rgbA) || v6 == int32(MODE_bgrA) || v6 == int32(MODE_Argb) || v6 == int32(MODE_rgbA_4444))
 		goto _8
 	_8:
 	}
 	v4 = libc.BoolInt32(v9 || v7 != 0)
 	goto _5
 _5:
 	is_alpha = v4
 	(*WebPDecParams)(unsafe.Pointer(p)).Fmemory = libc.UintptrFromInt32(0)
 	(*WebPDecParams)(unsafe.Pointer(p)).Femit = libc.UintptrFromInt32(0)
 	(*WebPDecParams)(unsafe.Pointer(p)).Femit_alpha = libc.UintptrFromInt32(0)
 	(*WebPDecParams)(unsafe.Pointer(p)).Femit_alpha_row = libc.UintptrFromInt32(0)
 	if is_alpha != 0 {
 		v1 = int32(MODE_YUV)
 	} else {
 		v1 = int32(MODE_YUVA)
 	}
 	if !(WebPIoInitFromOptions(tls, (*WebPDecParams)(unsafe.Pointer(p)).Foptions, io, v1) != 0) {
 		return 0
 	}
 	if v9 = is_alpha != 0; v9 {
 		v3 = colorspace
 		v1 = libc.BoolInt32(v3 == int32(MODE_rgbA) || v3 == int32(MODE_bgrA) || v3 == int32(MODE_Argb) || v3 == int32(MODE_rgbA_4444))
 		goto _13
 	_13:
 	}
 	if v9 && v1 != 0 {
 		WebPInitUpsamplers(tls)
 	}
 	if (*VP8Io)(unsafe.Pointer(io)).Fuse_scaling != 0 {
 		if is_rgb != 0 {
 			v1 = InitRGBRescaler(tls, io, p)
 		} else {
 			v1 = InitYUVRescaler(tls, io, p)
 		}
 		ok = v1
 		if !(ok != 0) {
 			return 0 // memory error
 		}
 	} else {
 		if is_rgb != 0 {
 			WebPInitSamplers(tls)
 			(*WebPDecParams)(unsafe.Pointer(p)).Femit = __ccgo_fp(EmitSampledRGB) // default
 			if (*VP8Io)(unsafe.Pointer(io)).Ffancy_upsampling != 0 {
 				uv_width = ((*VP8Io)(unsafe.Pointer(io)).Fmb_w + int32(1)) >> int32(1)
 				(*WebPDecParams)(unsafe.Pointer(p)).Fmemory = WebPSafeMalloc(tls, uint64(1), libc.Uint64FromInt32((*VP8Io)(unsafe.Pointer(io)).Fmb_w+libc.Int32FromInt32(2)*uv_width))
 				if (*WebPDecParams)(unsafe.Pointer(p)).Fmemory == libc.UintptrFromInt32(0) {
 					return 0 // memory error.
 				}
 				(*WebPDecParams)(unsafe.Pointer(p)).Ftmp_y = (*WebPDecParams)(unsafe.Pointer(p)).Fmemory
 				(*WebPDecParams)(unsafe.Pointer(p)).Ftmp_u = (*WebPDecParams)(unsafe.Pointer(p)).Ftmp_y + uintptr((*VP8Io)(unsafe.Pointer(io)).Fmb_w)
 				(*WebPDecParams)(unsafe.Pointer(p)).Ftmp_v = (*WebPDecParams)(unsafe.Pointer(p)).Ftmp_u + uintptr(uv_width)
 				(*WebPDecParams)(unsafe.Pointer(p)).Femit = __ccgo_fp(EmitFancyRGB)
 				WebPInitUpsamplers(tls)
 			}
 		} else {
 			(*WebPDecParams)(unsafe.Pointer(p)).Femit = __ccgo_fp(EmitYUV)
 		}
 		if is_alpha != 0 { // need transparency output
 			if colorspace == int32(MODE_RGBA_4444) || colorspace == int32(MODE_rgbA_4444) {
 				v16 = __ccgo_fp(EmitAlphaRGBA4444)
 			} else {
 				if is_rgb != 0 {
 					v17 = __ccgo_fp(EmitAlphaRGB)
 				} else {
 					v17 = __ccgo_fp(EmitAlphaYUV)
 				}
 				v16 = v17
 			}
 			(*WebPDecParams)(unsafe.Pointer(p)).Femit_alpha = v16
 			if is_rgb != 0 {
 				WebPInitAlphaProcessing(tls)
 			}
 		}
 	}
 	return int32(1)
 }
 
 //------------------------------------------------------------------------------
 
 func CustomPut(tls *libc.TLS, io uintptr) (r int32) {
 	var mb_h, mb_w, num_lines_out int32
 	var p uintptr
 	_, _, _, _ = mb_h, mb_w, num_lines_out, p
 	p = (*VP8Io)(unsafe.Pointer(io)).Fopaque
 	mb_w = (*VP8Io)(unsafe.Pointer(io)).Fmb_w
 	mb_h = (*VP8Io)(unsafe.Pointer(io)).Fmb_h
 	if mb_w <= 0 || mb_h <= 0 {
 		return 0
 	}
 	num_lines_out = (*(*func(*libc.TLS, uintptr, uintptr) int32)(unsafe.Pointer(&struct{ uintptr }{(*WebPDecParams)(unsafe.Pointer(p)).Femit})))(tls, io, p)
 	if (*WebPDecParams)(unsafe.Pointer(p)).Femit_alpha != libc.UintptrFromInt32(0) {
 		(*(*func(*libc.TLS, uintptr, uintptr, int32) int32)(unsafe.Pointer(&struct{ uintptr }{(*WebPDecParams)(unsafe.Pointer(p)).Femit_alpha})))(tls, io, p, num_lines_out)
 	}
 	**(**int32)(__ccgo_up(p + 32)) += num_lines_out
 	return int32(1)
 }
 
 //------------------------------------------------------------------------------
 
 func CustomTeardown(tls *libc.TLS, io uintptr) {
 	var p uintptr
 	_ = p
 	p = (*VP8Io)(unsafe.Pointer(io)).Fopaque
 	WebPSafeFree(tls, (*WebPDecParams)(unsafe.Pointer(p)).Fmemory)
 	(*WebPDecParams)(unsafe.Pointer(p)).Fmemory = libc.UintptrFromInt32(0)
 }
 
 //------------------------------------------------------------------------------
 // Main entry point
 
 func WebPInitCustomIo(tls *libc.TLS, params uintptr, io uintptr) {
 	(*VP8Io)(unsafe.Pointer(io)).Fput = __ccgo_fp(CustomPut)
 	(*VP8Io)(unsafe.Pointer(io)).Fsetup = __ccgo_fp(CustomSetup)
 	(*VP8Io)(unsafe.Pointer(io)).Fteardown = __ccgo_fp(CustomTeardown)
 	(*VP8Io)(unsafe.Pointer(io)).Fopaque = params
 }
 
 var kHashMul5 = uint32(0x1e35a7bd)
 
 //------------------------------------------------------------------------------
 
 // Copyright 2010 Google Inc. All Rights Reserved.
 //
 // Use of this source code is governed by a BSD-style license
 // that can be found in the COPYING file in the root of the source
 // tree. An additional intellectual property rights grant can be found
 // in the file PATENTS. All contributing project authors may
 // be found in the AUTHORS file in the root of the source tree.
 // -----------------------------------------------------------------------------
 //
 // Boolean decoder
 //
 // Author: Skal (pascal.massimino@gmail.com)
 //         Vikas Arora (vikaas.arora@gmail.com)
 
 // Copyright 2010 Google Inc. All Rights Reserved.
 //
 // Use of this source code is governed by a BSD-style license
 // that can be found in the COPYING file in the root of the source
 // tree. An additional intellectual property rights grant can be found
 // in the file PATENTS. All contributing project authors may
 // be found in the AUTHORS file in the root of the source tree.
 // -----------------------------------------------------------------------------
 //
 //  Common types + memory wrappers
 //
 // Author: Skal (pascal.massimino@gmail.com)
 
 func clip(tls *libc.TLS, v int32, M int32) (r int32) {
 	var v1, v2 int32
 	_, _ = v1, v2
 	if v < 0 {
 		v1 = 0
 	} else {
 		if v > M {
 			v2 = M
 		} else {
 			v2 = v
 		}
 		v1 = v2
 	}
 	return v1
 }
 
 // C documentation
 //
 //	// Paragraph 14.1
 var kDcTable = [128]uint8_t{
 	0:   uint8(4),
 	1:   uint8(5),
 	2:   uint8(6),
 	3:   uint8(7),
 	4:   uint8(8),
 	5:   uint8(9),
 	6:   uint8(10),
 	7:   uint8(10),
 	8:   uint8(11),
 	9:   uint8(12),
 	10:  uint8(13),
 	11:  uint8(14),
 	12:  uint8(15),
 	13:  uint8(16),
 	14:  uint8(17),
 	15:  uint8(17),
 	16:  uint8(18),
 	17:  uint8(19),
 	18:  uint8(20),
 	19:  uint8(20),
 	20:  uint8(21),
 	21:  uint8(21),
 	22:  uint8(22),
 	23:  uint8(22),
 	24:  uint8(23),
 	25:  uint8(23),
 	26:  uint8(24),
 	27:  uint8(25),
 	28:  uint8(25),
 	29:  uint8(26),
 	30:  uint8(27),
 	31:  uint8(28),
 	32:  uint8(29),
 	33:  uint8(30),
 	34:  uint8(31),
 	35:  uint8(32),
 	36:  uint8(33),
 	37:  uint8(34),
 	38:  uint8(35),
 	39:  uint8(36),
 	40:  uint8(37),
 	41:  uint8(37),
 	42:  uint8(38),
 	43:  uint8(39),
 	44:  uint8(40),
 	45:  uint8(41),
 	46:  uint8(42),
 	47:  uint8(43),
 	48:  uint8(44),
 	49:  uint8(45),
 	50:  uint8(46),
 	51:  uint8(46),
 	52:  uint8(47),
 	53:  uint8(48),
 	54:  uint8(49),
 	55:  uint8(50),
 	56:  uint8(51),
 	57:  uint8(52),
 	58:  uint8(53),
 	59:  uint8(54),
 	60:  uint8(55),
 	61:  uint8(56),
 	62:  uint8(57),
 	63:  uint8(58),
 	64:  uint8(59),
 	65:  uint8(60),
 	66:  uint8(61),
 	67:  uint8(62),
 	68:  uint8(63),
 	69:  uint8(64),
 	70:  uint8(65),
 	71:  uint8(66),
 	72:  uint8(67),
 	73:  uint8(68),
 	74:  uint8(69),
 	75:  uint8(70),
 	76:  uint8(71),
 	77:  uint8(72),
 	78:  uint8(73),
 	79:  uint8(74),
 	80:  uint8(75),
 	81:  uint8(76),
 	82:  uint8(76),
 	83:  uint8(77),
 	84:  uint8(78),
 	85:  uint8(79),
 	86:  uint8(80),
 	87:  uint8(81),
 	88:  uint8(82),
 	89:  uint8(83),
 	90:  uint8(84),
 	91:  uint8(85),
 	92:  uint8(86),
 	93:  uint8(87),
 	94:  uint8(88),
 	95:  uint8(89),
 	96:  uint8(91),
 	97:  uint8(93),
 	98:  uint8(95),
 	99:  uint8(96),
 	100: uint8(98),
 	101: uint8(100),
 	102: uint8(101),
 	103: uint8(102),
 	104: uint8(104),
 	105: uint8(106),
 	106: uint8(108),
 	107: uint8(110),
 	108: uint8(112),
 	109: uint8(114),
 	110: uint8(116),
 	111: uint8(118),
 	112: uint8(122),
 	113: uint8(124),
 	114: uint8(126),
 	115: uint8(128),
 	116: uint8(130),
 	117: uint8(132),
 	118: uint8(134),
 	119: uint8(136),
 	120: uint8(138),
 	121: uint8(140),
 	122: uint8(143),
 	123: uint8(145),
 	124: uint8(148),
 	125: uint8(151),
 	126: uint8(154),
 	127: uint8(157),
 }
 
 var kAcTable = [128]uint16_t{
 	0:   uint16(4),
 	1:   uint16(5),
 	2:   uint16(6),
 	3:   uint16(7),
 	4:   uint16(8),
 	5:   uint16(9),
 	6:   uint16(10),
 	7:   uint16(11),
 	8:   uint16(12),
 	9:   uint16(13),
 	10:  uint16(14),
 	11:  uint16(15),
 	12:  uint16(16),
 	13:  uint16(17),
 	14:  uint16(18),
 	15:  uint16(19),
 	16:  uint16(20),
 	17:  uint16(21),
 	18:  uint16(22),
 	19:  uint16(23),
 	20:  uint16(24),
 	21:  uint16(25),
 	22:  uint16(26),
 	23:  uint16(27),
 	24:  uint16(28),
 	25:  uint16(29),
 	26:  uint16(30),
 	27:  uint16(31),
 	28:  uint16(32),
 	29:  uint16(33),
 	30:  uint16(34),
 	31:  uint16(35),
 	32:  uint16(36),
 	33:  uint16(37),
 	34:  uint16(38),
 	35:  uint16(39),
 	36:  uint16(40),
 	37:  uint16(41),
 	38:  uint16(42),
 	39:  uint16(43),
 	40:  uint16(44),
 	41:  uint16(45),
 	42:  uint16(46),
 	43:  uint16(47),
 	44:  uint16(48),
 	45:  uint16(49),
 	46:  uint16(50),
 	47:  uint16(51),
 	48:  uint16(52),
 	49:  uint16(53),
 	50:  uint16(54),
 	51:  uint16(55),
 	52:  uint16(56),
 	53:  uint16(57),
 	54:  uint16(58),
 	55:  uint16(60),
 	56:  uint16(62),
 	57:  uint16(64),
 	58:  uint16(66),
 	59:  uint16(68),
 	60:  uint16(70),
 	61:  uint16(72),
 	62:  uint16(74),
 	63:  uint16(76),
 	64:  uint16(78),
 	65:  uint16(80),
 	66:  uint16(82),
 	67:  uint16(84),
 	68:  uint16(86),
 	69:  uint16(88),
 	70:  uint16(90),
 	71:  uint16(92),
 	72:  uint16(94),
 	73:  uint16(96),
 	74:  uint16(98),
 	75:  uint16(100),
 	76:  uint16(102),
 	77:  uint16(104),
 	78:  uint16(106),
 	79:  uint16(108),
 	80:  uint16(110),
 	81:  uint16(112),
 	82:  uint16(114),
 	83:  uint16(116),
 	84:  uint16(119),
 	85:  uint16(122),
 	86:  uint16(125),
 	87:  uint16(128),
 	88:  uint16(131),
 	89:  uint16(134),
 	90:  uint16(137),
 	91:  uint16(140),
 	92:  uint16(143),
 	93:  uint16(146),
 	94:  uint16(149),
 	95:  uint16(152),
 	96:  uint16(155),
 	97:  uint16(158),
 	98:  uint16(161),
 	99:  uint16(164),
 	100: uint16(167),
 	101: uint16(170),
 	102: uint16(173),
 	103: uint16(177),
 	104: uint16(181),
 	105: uint16(185),
 	106: uint16(189),
 	107: uint16(193),
 	108: uint16(197),
 	109: uint16(201),
 	110: uint16(205),
 	111: uint16(209),
 	112: uint16(213),
 	113: uint16(217),
 	114: uint16(221),
 	115: uint16(225),
 	116: uint16(229),
 	117: uint16(234),
 	118: uint16(239),
 	119: uint16(245),
 	120: uint16(249),
 	121: uint16(254),
 	122: uint16(259),
 	123: uint16(264),
 	124: uint16(269),
 	125: uint16(274),
 	126: uint16(279),
 	127: uint16(284),
 }
 
 //------------------------------------------------------------------------------
 // Paragraph 9.6
 
 func VP8ParseQuant(tls *libc.TLS, dec uintptr) {
 	var base_q0, dquv_ac, dquv_dc, dqy1_dc, dqy2_ac, dqy2_dc, i, q, v1, v2, v3, v4, v5 int32
 	var br, hdr, m uintptr
 	_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = base_q0, br, dquv_ac, dquv_dc, dqy1_dc, dqy2_ac, dqy2_dc, hdr, i, m, q, v1, v2, v3, v4, v5
 	br = dec + 16
 	base_q0 = libc.Int32FromUint32(VP8GetValue(tls, br, int32(7)))
 	if VP8GetValue(tls, br, int32(1)) != 0 {
 		v1 = VP8GetSignedValue(tls, br, int32(4))
 	} else {
 		v1 = 0
 	}
 	dqy1_dc = v1
 	if VP8GetValue(tls, br, int32(1)) != 0 {
 		v2 = VP8GetSignedValue(tls, br, int32(4))
 	} else {
 		v2 = 0
 	}
 	dqy2_dc = v2
 	if VP8GetValue(tls, br, int32(1)) != 0 {
 		v3 = VP8GetSignedValue(tls, br, int32(4))
 	} else {
 		v3 = 0
 	}
 	dqy2_ac = v3
 	if VP8GetValue(tls, br, int32(1)) != 0 {
 		v4 = VP8GetSignedValue(tls, br, int32(4))
 	} else {
 		v4 = 0
 	}
 	dquv_dc = v4
 	if VP8GetValue(tls, br, int32(1)) != 0 {
 		v5 = VP8GetSignedValue(tls, br, int32(4))
 	} else {
 		v5 = 0
 	}
 	dquv_ac = v5
 	hdr = dec + 132
 	i = 0
 	for {
 		if !(i < int32(NUM_MB_SEGMENTS)) {
 			break
 		}
 		if (*VP8SegmentHeader)(unsafe.Pointer(hdr)).Fuse_segment != 0 {
 			q = int32(**(**int8_t)(__ccgo_up(hdr + 12 + uintptr(i))))
 			if !((*VP8SegmentHeader)(unsafe.Pointer(hdr)).Fabsolute_delta != 0) {
 				q = q + base_q0
 			}
 		} else {
 			if i > 0 {
 				**(**VP8QuantMatrix)(__ccgo_up(dec + 1060 + uintptr(i)*32)) = **(**VP8QuantMatrix)(__ccgo_up(dec + 1060))
 				goto _6
 			} else {
 				q = base_q0
 			}
 		}
 		m = dec + 1060 + uintptr(i)*32
 		**(**int32)(__ccgo_up(m)) = libc.Int32FromUint8(kDcTable[clip(tls, q+dqy1_dc, int32(127))])
 		**(**int32)(__ccgo_up(m + 1*4)) = libc.Int32FromUint16(kAcTable[clip(tls, q+0, int32(127))])
 		**(**int32)(__ccgo_up(m + 8)) = libc.Int32FromUint8(kDcTable[clip(tls, q+dqy2_dc, int32(127))]) * int32(2)
 		// For all x in [0..284], x*155/100 is bitwise equal to (x*101581) >> 16.
 		// The smallest precision for that is '(x*6349) >> 12' but 16 is a good
 		// word size.
 		**(**int32)(__ccgo_up(m + 8 + 1*4)) = libc.Int32FromUint16(kAcTable[clip(tls, q+dqy2_ac, int32(127))]) * int32(101581) >> int32(16)
 		if **(**int32)(__ccgo_up(m + 8 + 1*4)) < int32(8) {
 			**(**int32)(__ccgo_up(m + 8 + 1*4)) = int32(8)
 		}
 		**(**int32)(__ccgo_up(m + 16)) = libc.Int32FromUint8(kDcTable[clip(tls, q+dquv_dc, int32(117))])
 		**(**int32)(__ccgo_up(m + 16 + 1*4)) = libc.Int32FromUint16(kAcTable[clip(tls, q+dquv_ac, int32(127))])
 		(*VP8QuantMatrix)(unsafe.Pointer(m)).Fuv_quant = q + dquv_ac // for dithering strength evaluation
 		goto _6
 	_6:
 		;
 		i = i + 1
 	}
 }
 
 const USE_GENERIC_TREE = 1
 
 var kHashMul6 = uint32(0x1e35a7bd)
 
 type lbit_t = uint64
 
 // Copyright 2010 Google Inc. All Rights Reserved.
 //
 // Use of this source code is governed by a BSD-style license
 // that can be found in the COPYING file in the root of the source
 // tree. An additional intellectual property rights grant can be found
 // in the file PATENTS. All contributing project authors may
 // be found in the AUTHORS file in the root of the source tree.
 // -----------------------------------------------------------------------------
 //
 // Boolean decoder
 //
 // Author: Skal (pascal.massimino@gmail.com)
 //         Vikas Arora (vikaas.arora@gmail.com)
 
 // using a table is ~1-2% slower on ARM. Prefer the coded-tree approach then.
 
 var kYModesIntra4 = [18]int8_t{
 	1:  int8(1),
 	2:  int8(-int32(B_TM_PRED)),
 	3:  int8(2),
 	4:  int8(-int32(B_VE_PRED)),
 	5:  int8(3),
 	6:  int8(4),
 	7:  int8(6),
 	8:  int8(-int32(B_HE_PRED)),
 	9:  int8(5),
 	10: int8(-int32(B_RD_PRED)),
 	11: int8(-int32(B_VR_PRED)),
 	12: int8(-int32(B_LD_PRED)),
 	13: int8(7),
 	14: int8(-int32(B_VL_PRED)),
 	15: int8(8),
 	16: int8(-int32(B_HD_PRED)),
 	17: int8(-int32(B_HU_PRED)),
 }
 
 //------------------------------------------------------------------------------
 // Default probabilities
 
 // C documentation
 //
 //	// Paragraph 13.5
 
 var CoeffsProba0 = [4][8][3][11]uint8_t{
 	0: {
 		0: {
 			0: {
 				0:  uint8(128),
 				1:  uint8(128),
 				2:  uint8(128),
 				3:  uint8(128),
 				4:  uint8(128),
 				5:  uint8(128),
 				6:  uint8(128),
 				7:  uint8(128),
 				8:  uint8(128),
 				9:  uint8(128),
 				10: uint8(128),
 			},
 			1: {
 				0:  uint8(128),
 				1:  uint8(128),
 				2:  uint8(128),
 				3:  uint8(128),
 				4:  uint8(128),
 				5:  uint8(128),
 				6:  uint8(128),
 				7:  uint8(128),
 				8:  uint8(128),
 				9:  uint8(128),
 				10: uint8(128),
 			},
 			2: {
 				0:  uint8(128),
 				1:  uint8(128),
 				2:  uint8(128),
 				3:  uint8(128),
 				4:  uint8(128),
 				5:  uint8(128),
 				6:  uint8(128),
 				7:  uint8(128),
 				8:  uint8(128),
 				9:  uint8(128),
 				10: uint8(128),
 			},
 		},
 		1: {
 			0: {
 				0:  uint8(253),
 				1:  uint8(136),
 				2:  uint8(254),
 				3:  uint8(255),
 				4:  uint8(228),
 				5:  uint8(219),
 				6:  uint8(128),
 				7:  uint8(128),
 				8:  uint8(128),
 				9:  uint8(128),
 				10: uint8(128),
 			},
 			1: {
 				0:  uint8(189),
 				1:  uint8(129),
 				2:  uint8(242),
 				3:  uint8(255),
 				4:  uint8(227),
 				5:  uint8(213),
 				6:  uint8(255),
 				7:  uint8(219),
 				8:  uint8(128),
 				9:  uint8(128),
 				10: uint8(128),
 			},
 			2: {
 				0:  uint8(106),
 				1:  uint8(126),
 				2:  uint8(227),
 				3:  uint8(252),
 				4:  uint8(214),
 				5:  uint8(209),
 				6:  uint8(255),
 				7:  uint8(255),
 				8:  uint8(128),
 				9:  uint8(128),
 				10: uint8(128),
 			},
 		},
 		2: {
 			0: {
 				0:  uint8(1),
 				1:  uint8(98),
 				2:  uint8(248),
 				3:  uint8(255),
 				4:  uint8(236),
 				5:  uint8(226),
 				6:  uint8(255),
 				7:  uint8(255),
 				8:  uint8(128),
 				9:  uint8(128),
 				10: uint8(128),
 			},
 			1: {
 				0:  uint8(181),
 				1:  uint8(133),
 				2:  uint8(238),
 				3:  uint8(254),
 				4:  uint8(221),
 				5:  uint8(234),
 				6:  uint8(255),
 				7:  uint8(154),
 				8:  uint8(128),
 				9:  uint8(128),
 				10: uint8(128),
 			},
 			2: {
 				0:  uint8(78),
 				1:  uint8(134),
 				2:  uint8(202),
 				3:  uint8(247),
 				4:  uint8(198),
 				5:  uint8(180),
 				6:  uint8(255),
 				7:  uint8(219),
 				8:  uint8(128),
 				9:  uint8(128),
 				10: uint8(128),
 			},
 		},
 		3: {
 			0: {
 				0:  uint8(1),
 				1:  uint8(185),
 				2:  uint8(249),
 				3:  uint8(255),
 				4:  uint8(243),
 				5:  uint8(255),
 				6:  uint8(128),
 				7:  uint8(128),
 				8:  uint8(128),
 				9:  uint8(128),
 				10: uint8(128),
 			},
 			1: {
 				0:  uint8(184),
 				1:  uint8(150),
 				2:  uint8(247),
 				3:  uint8(255),
 				4:  uint8(236),
 				5:  uint8(224),
 				6:  uint8(128),
 				7:  uint8(128),
 				8:  uint8(128),
 				9:  uint8(128),
 				10: uint8(128),
 			},
 			2: {
 				0:  uint8(77),
 				1:  uint8(110),
 				2:  uint8(216),
 				3:  uint8(255),
 				4:  uint8(236),
 				5:  uint8(230),
 				6:  uint8(128),
 				7:  uint8(128),
 				8:  uint8(128),
 				9:  uint8(128),
 				10: uint8(128),
 			},
 		},
 		4: {
 			0: {
 				0:  uint8(1),
 				1:  uint8(101),
 				2:  uint8(251),
 				3:  uint8(255),
 				4:  uint8(241),
 				5:  uint8(255),
 				6:  uint8(128),
 				7:  uint8(128),
 				8:  uint8(128),
 				9:  uint8(128),
 				10: uint8(128),
 			},
 			1: {
 				0:  uint8(170),
 				1:  uint8(139),
 				2:  uint8(241),
 				3:  uint8(252),
 				4:  uint8(236),
 				5:  uint8(209),
 				6:  uint8(255),
 				7:  uint8(255),
 				8:  uint8(128),
 				9:  uint8(128),
 				10: uint8(128),
 			},
 			2: {
 				0:  uint8(37),
 				1:  uint8(116),
 				2:  uint8(196),
 				3:  uint8(243),
 				4:  uint8(228),
 				5:  uint8(255),
 				6:  uint8(255),
 				7:  uint8(255),
 				8:  uint8(128),
 				9:  uint8(128),
 				10: uint8(128),
 			},
 		},
 		5: {
 			0: {
 				0:  uint8(1),
 				1:  uint8(204),
 				2:  uint8(254),
 				3:  uint8(255),
 				4:  uint8(245),
 				5:  uint8(255),
 				6:  uint8(128),
 				7:  uint8(128),
 				8:  uint8(128),
 				9:  uint8(128),
 				10: uint8(128),
 			},
 			1: {
 				0:  uint8(207),
 				1:  uint8(160),
 				2:  uint8(250),
 				3:  uint8(255),
 				4:  uint8(238),
 				5:  uint8(128),
 				6:  uint8(128),
 				7:  uint8(128),
 				8:  uint8(128),
 				9:  uint8(128),
 				10: uint8(128),
 			},
 			2: {
 				0:  uint8(102),
 				1:  uint8(103),
 				2:  uint8(231),
 				3:  uint8(255),
 				4:  uint8(211),
 				5:  uint8(171),
 				6:  uint8(128),
 				7:  uint8(128),
 				8:  uint8(128),
 				9:  uint8(128),
 				10: uint8(128),
 			},
 		},
 		6: {
 			0: {
 				0:  uint8(1),
 				1:  uint8(152),
 				2:  uint8(252),
 				3:  uint8(255),
 				4:  uint8(240),
 				5:  uint8(255),
 				6:  uint8(128),
 				7:  uint8(128),
 				8:  uint8(128),
 				9:  uint8(128),
 				10: uint8(128),
 			},
 			1: {
 				0:  uint8(177),
 				1:  uint8(135),
 				2:  uint8(243),
 				3:  uint8(255),
 				4:  uint8(234),
 				5:  uint8(225),
 				6:  uint8(128),
 				7:  uint8(128),
 				8:  uint8(128),
 				9:  uint8(128),
 				10: uint8(128),
 			},
 			2: {
 				0:  uint8(80),
 				1:  uint8(129),
 				2:  uint8(211),
 				3:  uint8(255),
 				4:  uint8(194),
 				5:  uint8(224),
 				6:  uint8(128),
 				7:  uint8(128),
 				8:  uint8(128),
 				9:  uint8(128),
 				10: uint8(128),
 			},
 		},
 		7: {
 			0: {
 				0:  uint8(1),
 				1:  uint8(1),
 				2:  uint8(255),
 				3:  uint8(128),
 				4:  uint8(128),
 				5:  uint8(128),
 				6:  uint8(128),
 				7:  uint8(128),
 				8:  uint8(128),
 				9:  uint8(128),
 				10: uint8(128),
 			},
 			1: {
 				0:  uint8(246),
 				1:  uint8(1),
 				2:  uint8(255),
 				3:  uint8(128),
 				4:  uint8(128),
 				5:  uint8(128),
 				6:  uint8(128),
 				7:  uint8(128),
 				8:  uint8(128),
 				9:  uint8(128),
 				10: uint8(128),
 			},
 			2: {
 				0:  uint8(255),
 				1:  uint8(128),
 				2:  uint8(128),
 				3:  uint8(128),
 				4:  uint8(128),
 				5:  uint8(128),
 				6:  uint8(128),
 				7:  uint8(128),
 				8:  uint8(128),
 				9:  uint8(128),
 				10: uint8(128),
 			},
 		},
 	},
 	1: {
 		0: {
 			0: {
 				0:  uint8(198),
 				1:  uint8(35),
 				2:  uint8(237),
 				3:  uint8(223),
 				4:  uint8(193),
 				5:  uint8(187),
 				6:  uint8(162),
 				7:  uint8(160),
 				8:  uint8(145),
 				9:  uint8(155),
 				10: uint8(62),
 			},
 			1: {
 				0:  uint8(131),
 				1:  uint8(45),
 				2:  uint8(198),
 				3:  uint8(221),
 				4:  uint8(172),
 				5:  uint8(176),
 				6:  uint8(220),
 				7:  uint8(157),
 				8:  uint8(252),
 				9:  uint8(221),
 				10: uint8(1),
 			},
 			2: {
 				0:  uint8(68),
 				1:  uint8(47),
 				2:  uint8(146),
 				3:  uint8(208),
 				4:  uint8(149),
 				5:  uint8(167),
 				6:  uint8(221),
 				7:  uint8(162),
 				8:  uint8(255),
 				9:  uint8(223),
 				10: uint8(128),
 			},
 		},
 		1: {
 			0: {
 				0:  uint8(1),
 				1:  uint8(149),
 				2:  uint8(241),
 				3:  uint8(255),
 				4:  uint8(221),
 				5:  uint8(224),
 				6:  uint8(255),
 				7:  uint8(255),
 				8:  uint8(128),
 				9:  uint8(128),
 				10: uint8(128),
 			},
 			1: {
 				0:  uint8(184),
 				1:  uint8(141),
 				2:  uint8(234),
 				3:  uint8(253),
 				4:  uint8(222),
 				5:  uint8(220),
 				6:  uint8(255),
 				7:  uint8(199),
 				8:  uint8(128),
 				9:  uint8(128),
 				10: uint8(128),
 			},
 			2: {
 				0:  uint8(81),
 				1:  uint8(99),
 				2:  uint8(181),
 				3:  uint8(242),
 				4:  uint8(176),
 				5:  uint8(190),
 				6:  uint8(249),
 				7:  uint8(202),
 				8:  uint8(255),
 				9:  uint8(255),
 				10: uint8(128),
 			},
 		},
 		2: {
 			0: {
 				0:  uint8(1),
 				1:  uint8(129),
 				2:  uint8(232),
 				3:  uint8(253),
 				4:  uint8(214),
 				5:  uint8(197),
 				6:  uint8(242),
 				7:  uint8(196),
 				8:  uint8(255),
 				9:  uint8(255),
 				10: uint8(128),
 			},
 			1: {
 				0:  uint8(99),
 				1:  uint8(121),
 				2:  uint8(210),
 				3:  uint8(250),
 				4:  uint8(201),
 				5:  uint8(198),
 				6:  uint8(255),
 				7:  uint8(202),
 				8:  uint8(128),
 				9:  uint8(128),
 				10: uint8(128),
 			},
 			2: {
 				0:  uint8(23),
 				1:  uint8(91),
 				2:  uint8(163),
 				3:  uint8(242),
 				4:  uint8(170),
 				5:  uint8(187),
 				6:  uint8(247),
 				7:  uint8(210),
 				8:  uint8(255),
 				9:  uint8(255),
 				10: uint8(128),
 			},
 		},
 		3: {
 			0: {
 				0:  uint8(1),
 				1:  uint8(200),
 				2:  uint8(246),
 				3:  uint8(255),
 				4:  uint8(234),
 				5:  uint8(255),
 				6:  uint8(128),
 				7:  uint8(128),
 				8:  uint8(128),
 				9:  uint8(128),
 				10: uint8(128),
 			},
 			1: {
 				0:  uint8(109),
 				1:  uint8(178),
 				2:  uint8(241),
 				3:  uint8(255),
 				4:  uint8(231),
 				5:  uint8(245),
 				6:  uint8(255),
 				7:  uint8(255),
 				8:  uint8(128),
 				9:  uint8(128),
 				10: uint8(128),
 			},
 			2: {
 				0:  uint8(44),
 				1:  uint8(130),
 				2:  uint8(201),
 				3:  uint8(253),
 				4:  uint8(205),
 				5:  uint8(192),
 				6:  uint8(255),
 				7:  uint8(255),
 				8:  uint8(128),
 				9:  uint8(128),
 				10: uint8(128),
 			},
 		},
 		4: {
 			0: {
 				0:  uint8(1),
 				1:  uint8(132),
 				2:  uint8(239),
 				3:  uint8(251),
 				4:  uint8(219),
 				5:  uint8(209),
 				6:  uint8(255),
 				7:  uint8(165),
 				8:  uint8(128),
 				9:  uint8(128),
 				10: uint8(128),
 			},
 			1: {
 				0:  uint8(94),
 				1:  uint8(136),
 				2:  uint8(225),
 				3:  uint8(251),
 				4:  uint8(218),
 				5:  uint8(190),
 				6:  uint8(255),
 				7:  uint8(255),
 				8:  uint8(128),
 				9:  uint8(128),
 				10: uint8(128),
 			},
 			2: {
 				0:  uint8(22),
 				1:  uint8(100),
 				2:  uint8(174),
 				3:  uint8(245),
 				4:  uint8(186),
 				5:  uint8(161),
 				6:  uint8(255),
 				7:  uint8(199),
 				8:  uint8(128),
 				9:  uint8(128),
 				10: uint8(128),
 			},
 		},
 		5: {
 			0: {
 				0:  uint8(1),
 				1:  uint8(182),
 				2:  uint8(249),
 				3:  uint8(255),
 				4:  uint8(232),
 				5:  uint8(235),
 				6:  uint8(128),
 				7:  uint8(128),
 				8:  uint8(128),
 				9:  uint8(128),
 				10: uint8(128),
 			},
 			1: {
 				0:  uint8(124),
 				1:  uint8(143),
 				2:  uint8(241),
 				3:  uint8(255),
 				4:  uint8(227),
 				5:  uint8(234),
 				6:  uint8(128),
 				7:  uint8(128),
 				8:  uint8(128),
 				9:  uint8(128),
 				10: uint8(128),
 			},
 			2: {
 				0:  uint8(35),
 				1:  uint8(77),
 				2:  uint8(181),
 				3:  uint8(251),
 				4:  uint8(193),
 				5:  uint8(211),
 				6:  uint8(255),
 				7:  uint8(205),
 				8:  uint8(128),
 				9:  uint8(128),
 				10: uint8(128),
 			},
 		},
 		6: {
 			0: {
 				0:  uint8(1),
 				1:  uint8(157),
 				2:  uint8(247),
 				3:  uint8(255),
 				4:  uint8(236),
 				5:  uint8(231),
 				6:  uint8(255),
 				7:  uint8(255),
 				8:  uint8(128),
 				9:  uint8(128),
 				10: uint8(128),
 			},
 			1: {
 				0:  uint8(121),
 				1:  uint8(141),
 				2:  uint8(235),
 				3:  uint8(255),
 				4:  uint8(225),
 				5:  uint8(227),
 				6:  uint8(255),
 				7:  uint8(255),
 				8:  uint8(128),
 				9:  uint8(128),
 				10: uint8(128),
 			},
 			2: {
 				0:  uint8(45),
 				1:  uint8(99),
 				2:  uint8(188),
 				3:  uint8(251),
 				4:  uint8(195),
 				5:  uint8(217),
 				6:  uint8(255),
 				7:  uint8(224),
 				8:  uint8(128),
 				9:  uint8(128),
 				10: uint8(128),
 			},
 		},
 		7: {
 			0: {
 				0:  uint8(1),
 				1:  uint8(1),
 				2:  uint8(251),
 				3:  uint8(255),
 				4:  uint8(213),
 				5:  uint8(255),
 				6:  uint8(128),
 				7:  uint8(128),
 				8:  uint8(128),
 				9:  uint8(128),
 				10: uint8(128),
 			},
 			1: {
 				0:  uint8(203),
 				1:  uint8(1),
 				2:  uint8(248),
 				3:  uint8(255),
 				4:  uint8(255),
 				5:  uint8(128),
 				6:  uint8(128),
 				7:  uint8(128),
 				8:  uint8(128),
 				9:  uint8(128),
 				10: uint8(128),
 			},
 			2: {
 				0:  uint8(137),
 				1:  uint8(1),
 				2:  uint8(177),
 				3:  uint8(255),
 				4:  uint8(224),
 				5:  uint8(255),
 				6:  uint8(128),
 				7:  uint8(128),
 				8:  uint8(128),
 				9:  uint8(128),
 				10: uint8(128),
 			},
 		},
 	},
 	2: {
 		0: {
 			0: {
 				0:  uint8(253),
 				1:  uint8(9),
 				2:  uint8(248),
 				3:  uint8(251),
 				4:  uint8(207),
 				5:  uint8(208),
 				6:  uint8(255),
 				7:  uint8(192),
 				8:  uint8(128),
 				9:  uint8(128),
 				10: uint8(128),
 			},
 			1: {
 				0:  uint8(175),
 				1:  uint8(13),
 				2:  uint8(224),
 				3:  uint8(243),
 				4:  uint8(193),
 				5:  uint8(185),
 				6:  uint8(249),
 				7:  uint8(198),
 				8:  uint8(255),
 				9:  uint8(255),
 				10: uint8(128),
 			},
 			2: {
 				0:  uint8(73),
 				1:  uint8(17),
 				2:  uint8(171),
 				3:  uint8(221),
 				4:  uint8(161),
 				5:  uint8(179),
 				6:  uint8(236),
 				7:  uint8(167),
 				8:  uint8(255),
 				9:  uint8(234),
 				10: uint8(128),
 			},
 		},
 		1: {
 			0: {
 				0:  uint8(1),
 				1:  uint8(95),
 				2:  uint8(247),
 				3:  uint8(253),
 				4:  uint8(212),
 				5:  uint8(183),
 				6:  uint8(255),
 				7:  uint8(255),
 				8:  uint8(128),
 				9:  uint8(128),
 				10: uint8(128),
 			},
 			1: {
 				0:  uint8(239),
 				1:  uint8(90),
 				2:  uint8(244),
 				3:  uint8(250),
 				4:  uint8(211),
 				5:  uint8(209),
 				6:  uint8(255),
 				7:  uint8(255),
 				8:  uint8(128),
 				9:  uint8(128),
 				10: uint8(128),
 			},
 			2: {
 				0:  uint8(155),
 				1:  uint8(77),
 				2:  uint8(195),
 				3:  uint8(248),
 				4:  uint8(188),
 				5:  uint8(195),
 				6:  uint8(255),
 				7:  uint8(255),
 				8:  uint8(128),
 				9:  uint8(128),
 				10: uint8(128),
 			},
 		},
 		2: {
 			0: {
 				0:  uint8(1),
 				1:  uint8(24),
 				2:  uint8(239),
 				3:  uint8(251),
 				4:  uint8(218),
 				5:  uint8(219),
 				6:  uint8(255),
 				7:  uint8(205),
 				8:  uint8(128),
 				9:  uint8(128),
 				10: uint8(128),
 			},
 			1: {
 				0:  uint8(201),
 				1:  uint8(51),
 				2:  uint8(219),
 				3:  uint8(255),
 				4:  uint8(196),
 				5:  uint8(186),
 				6:  uint8(128),
 				7:  uint8(128),
 				8:  uint8(128),
 				9:  uint8(128),
 				10: uint8(128),
 			},
 			2: {
 				0:  uint8(69),
 				1:  uint8(46),
 				2:  uint8(190),
 				3:  uint8(239),
 				4:  uint8(201),
 				5:  uint8(218),
 				6:  uint8(255),
 				7:  uint8(228),
 				8:  uint8(128),
 				9:  uint8(128),
 				10: uint8(128),
 			},
 		},
 		3: {
 			0: {
 				0:  uint8(1),
 				1:  uint8(191),
 				2:  uint8(251),
 				3:  uint8(255),
 				4:  uint8(255),
 				5:  uint8(128),
 				6:  uint8(128),
 				7:  uint8(128),
 				8:  uint8(128),
 				9:  uint8(128),
 				10: uint8(128),
 			},
 			1: {
 				0:  uint8(223),
 				1:  uint8(165),
 				2:  uint8(249),
 				3:  uint8(255),
 				4:  uint8(213),
 				5:  uint8(255),
 				6:  uint8(128),
 				7:  uint8(128),
 				8:  uint8(128),
 				9:  uint8(128),
 				10: uint8(128),
 			},
 			2: {
 				0:  uint8(141),
 				1:  uint8(124),
 				2:  uint8(248),
 				3:  uint8(255),
 				4:  uint8(255),
 				5:  uint8(128),
 				6:  uint8(128),
 				7:  uint8(128),
 				8:  uint8(128),
 				9:  uint8(128),
 				10: uint8(128),
 			},
 		},
 		4: {
 			0: {
 				0:  uint8(1),
 				1:  uint8(16),
 				2:  uint8(248),
 				3:  uint8(255),
 				4:  uint8(255),
 				5:  uint8(128),
 				6:  uint8(128),
 				7:  uint8(128),
 				8:  uint8(128),
 				9:  uint8(128),
 				10: uint8(128),
 			},
 			1: {
 				0:  uint8(190),
 				1:  uint8(36),
 				2:  uint8(230),
 				3:  uint8(255),
 				4:  uint8(236),
 				5:  uint8(255),
 				6:  uint8(128),
 				7:  uint8(128),
 				8:  uint8(128),
 				9:  uint8(128),
 				10: uint8(128),
 			},
 			2: {
 				0:  uint8(149),
 				1:  uint8(1),
 				2:  uint8(255),
 				3:  uint8(128),
 				4:  uint8(128),
 				5:  uint8(128),
 				6:  uint8(128),
 				7:  uint8(128),
 				8:  uint8(128),
 				9:  uint8(128),
 				10: uint8(128),
 			},
 		},
 		5: {
 			0: {
 				0:  uint8(1),
 				1:  uint8(226),
 				2:  uint8(255),
 				3:  uint8(128),
 				4:  uint8(128),
 				5:  uint8(128),
 				6:  uint8(128),
 				7:  uint8(128),
 				8:  uint8(128),
 				9:  uint8(128),
 				10: uint8(128),
 			},
 			1: {
 				0:  uint8(247),
 				1:  uint8(192),
 				2:  uint8(255),
 				3:  uint8(128),
 				4:  uint8(128),
 				5:  uint8(128),
 				6:  uint8(128),
 				7:  uint8(128),
 				8:  uint8(128),
 				9:  uint8(128),
 				10: uint8(128),
 			},
 			2: {
 				0:  uint8(240),
 				1:  uint8(128),
 				2:  uint8(255),
 				3:  uint8(128),
 				4:  uint8(128),
 				5:  uint8(128),
 				6:  uint8(128),
 				7:  uint8(128),
 				8:  uint8(128),
 				9:  uint8(128),
 				10: uint8(128),
 			},
 		},
 		6: {
 			0: {
 				0:  uint8(1),
 				1:  uint8(134),
 				2:  uint8(252),
 				3:  uint8(255),
 				4:  uint8(255),
 				5:  uint8(128),
 				6:  uint8(128),
 				7:  uint8(128),
 				8:  uint8(128),
 				9:  uint8(128),
 				10: uint8(128),
 			},
 			1: {
 				0:  uint8(213),
 				1:  uint8(62),
 				2:  uint8(250),
 				3:  uint8(255),
 				4:  uint8(255),
 				5:  uint8(128),
 				6:  uint8(128),
 				7:  uint8(128),
 				8:  uint8(128),
 				9:  uint8(128),
 				10: uint8(128),
 			},
 			2: {
 				0:  uint8(55),
 				1:  uint8(93),
 				2:  uint8(255),
 				3:  uint8(128),
 				4:  uint8(128),
 				5:  uint8(128),
 				6:  uint8(128),
 				7:  uint8(128),
 				8:  uint8(128),
 				9:  uint8(128),
 				10: uint8(128),
 			},
 		},
 		7: {
 			0: {
 				0:  uint8(128),
 				1:  uint8(128),
 				2:  uint8(128),
 				3:  uint8(128),
 				4:  uint8(128),
 				5:  uint8(128),
 				6:  uint8(128),
 				7:  uint8(128),
 				8:  uint8(128),
 				9:  uint8(128),
 				10: uint8(128),
 			},
 			1: {
 				0:  uint8(128),
 				1:  uint8(128),
 				2:  uint8(128),
 				3:  uint8(128),
 				4:  uint8(128),
 				5:  uint8(128),
 				6:  uint8(128),
 				7:  uint8(128),
 				8:  uint8(128),
 				9:  uint8(128),
 				10: uint8(128),
 			},
 			2: {
 				0:  uint8(128),
 				1:  uint8(128),
 				2:  uint8(128),
 				3:  uint8(128),
 				4:  uint8(128),
 				5:  uint8(128),
 				6:  uint8(128),
 				7:  uint8(128),
 				8:  uint8(128),
 				9:  uint8(128),
 				10: uint8(128),
 			},
 		},
 	},
 	3: {
 		0: {
 			0: {
 				0:  uint8(202),
 				1:  uint8(24),
 				2:  uint8(213),
 				3:  uint8(235),
 				4:  uint8(186),
 				5:  uint8(191),
 				6:  uint8(220),
 				7:  uint8(160),
 				8:  uint8(240),
 				9:  uint8(175),
 				10: uint8(255),
 			},
 			1: {
 				0:  uint8(126),
 				1:  uint8(38),
 				2:  uint8(182),
 				3:  uint8(232),
 				4:  uint8(169),
 				5:  uint8(184),
 				6:  uint8(228),
 				7:  uint8(174),
 				8:  uint8(255),
 				9:  uint8(187),
 				10: uint8(128),
 			},
 			2: {
 				0:  uint8(61),
 				1:  uint8(46),
 				2:  uint8(138),
 				3:  uint8(219),
 				4:  uint8(151),
 				5:  uint8(178),
 				6:  uint8(240),
 				7:  uint8(170),
 				8:  uint8(255),
 				9:  uint8(216),
 				10: uint8(128),
 			},
 		},
 		1: {
 			0: {
 				0:  uint8(1),
 				1:  uint8(112),
 				2:  uint8(230),
 				3:  uint8(250),
 				4:  uint8(199),
 				5:  uint8(191),
 				6:  uint8(247),
 				7:  uint8(159),
 				8:  uint8(255),
 				9:  uint8(255),
 				10: uint8(128),
 			},
 			1: {
 				0:  uint8(166),
 				1:  uint8(109),
 				2:  uint8(228),
 				3:  uint8(252),
 				4:  uint8(211),
 				5:  uint8(215),
 				6:  uint8(255),
 				7:  uint8(174),
 				8:  uint8(128),
 				9:  uint8(128),
 				10: uint8(128),
 			},
 			2: {
 				0:  uint8(39),
 				1:  uint8(77),
 				2:  uint8(162),
 				3:  uint8(232),
 				4:  uint8(172),
 				5:  uint8(180),
 				6:  uint8(245),
 				7:  uint8(178),
 				8:  uint8(255),
 				9:  uint8(255),
 				10: uint8(128),
 			},
 		},
 		2: {
 			0: {
 				0:  uint8(1),
 				1:  uint8(52),
 				2:  uint8(220),
 				3:  uint8(246),
 				4:  uint8(198),
 				5:  uint8(199),
 				6:  uint8(249),
 				7:  uint8(220),
 				8:  uint8(255),
 				9:  uint8(255),
 				10: uint8(128),
 			},
 			1: {
 				0:  uint8(124),
 				1:  uint8(74),
 				2:  uint8(191),
 				3:  uint8(243),
 				4:  uint8(183),
 				5:  uint8(193),
 				6:  uint8(250),
 				7:  uint8(221),
 				8:  uint8(255),
 				9:  uint8(255),
 				10: uint8(128),
 			},
 			2: {
 				0:  uint8(24),
 				1:  uint8(71),
 				2:  uint8(130),
 				3:  uint8(219),
 				4:  uint8(154),
 				5:  uint8(170),
 				6:  uint8(243),
 				7:  uint8(182),
 				8:  uint8(255),
 				9:  uint8(255),
 				10: uint8(128),
 			},
 		},
 		3: {
 			0: {
 				0:  uint8(1),
 				1:  uint8(182),
 				2:  uint8(225),
 				3:  uint8(249),
 				4:  uint8(219),
 				5:  uint8(240),
 				6:  uint8(255),
 				7:  uint8(224),
 				8:  uint8(128),
 				9:  uint8(128),
 				10: uint8(128),
 			},
 			1: {
 				0:  uint8(149),
 				1:  uint8(150),
 				2:  uint8(226),
 				3:  uint8(252),
 				4:  uint8(216),
 				5:  uint8(205),
 				6:  uint8(255),
 				7:  uint8(171),
 				8:  uint8(128),
 				9:  uint8(128),
 				10: uint8(128),
 			},
 			2: {
 				0:  uint8(28),
 				1:  uint8(108),
 				2:  uint8(170),
 				3:  uint8(242),
 				4:  uint8(183),
 				5:  uint8(194),
 				6:  uint8(254),
 				7:  uint8(223),
 				8:  uint8(255),
 				9:  uint8(255),
 				10: uint8(128),
 			},
 		},
 		4: {
 			0: {
 				0:  uint8(1),
 				1:  uint8(81),
 				2:  uint8(230),
 				3:  uint8(252),
 				4:  uint8(204),
 				5:  uint8(203),
 				6:  uint8(255),
 				7:  uint8(192),
 				8:  uint8(128),
 				9:  uint8(128),
 				10: uint8(128),
 			},
 			1: {
 				0:  uint8(123),
 				1:  uint8(102),
 				2:  uint8(209),
 				3:  uint8(247),
 				4:  uint8(188),
 				5:  uint8(196),
 				6:  uint8(255),
 				7:  uint8(233),
 				8:  uint8(128),
 				9:  uint8(128),
 				10: uint8(128),
 			},
 			2: {
 				0:  uint8(20),
 				1:  uint8(95),
 				2:  uint8(153),
 				3:  uint8(243),
 				4:  uint8(164),
 				5:  uint8(173),
 				6:  uint8(255),
 				7:  uint8(203),
 				8:  uint8(128),
 				9:  uint8(128),
 				10: uint8(128),
 			},
 		},
 		5: {
 			0: {
 				0:  uint8(1),
 				1:  uint8(222),
 				2:  uint8(248),
 				3:  uint8(255),
 				4:  uint8(216),
 				5:  uint8(213),
 				6:  uint8(128),
 				7:  uint8(128),
 				8:  uint8(128),
 				9:  uint8(128),
 				10: uint8(128),
 			},
 			1: {
 				0:  uint8(168),
 				1:  uint8(175),
 				2:  uint8(246),
 				3:  uint8(252),
 				4:  uint8(235),
 				5:  uint8(205),
 				6:  uint8(255),
 				7:  uint8(255),
 				8:  uint8(128),
 				9:  uint8(128),
 				10: uint8(128),
 			},
 			2: {
 				0:  uint8(47),
 				1:  uint8(116),
 				2:  uint8(215),
 				3:  uint8(255),
 				4:  uint8(211),
 				5:  uint8(212),
 				6:  uint8(255),
 				7:  uint8(255),
 				8:  uint8(128),
 				9:  uint8(128),
 				10: uint8(128),
 			},
 		},
 		6: {
 			0: {
 				0:  uint8(1),
 				1:  uint8(121),
 				2:  uint8(236),
 				3:  uint8(253),
 				4:  uint8(212),
 				5:  uint8(214),
 				6:  uint8(255),
 				7:  uint8(255),
 				8:  uint8(128),
 				9:  uint8(128),
 				10: uint8(128),
 			},
 			1: {
 				0:  uint8(141),
 				1:  uint8(84),
 				2:  uint8(213),
 				3:  uint8(252),
 				4:  uint8(201),
 				5:  uint8(202),
 				6:  uint8(255),
 				7:  uint8(219),
 				8:  uint8(128),
 				9:  uint8(128),
 				10: uint8(128),
 			},
 			2: {
 				0:  uint8(42),
 				1:  uint8(80),
 				2:  uint8(160),
 				3:  uint8(240),
 				4:  uint8(162),
 				5:  uint8(185),
 				6:  uint8(255),
 				7:  uint8(205),
 				8:  uint8(128),
 				9:  uint8(128),
 				10: uint8(128),
 			},
 		},
 		7: {
 			0: {
 				0:  uint8(1),
 				1:  uint8(1),
 				2:  uint8(255),
 				3:  uint8(128),
 				4:  uint8(128),
 				5:  uint8(128),
 				6:  uint8(128),
 				7:  uint8(128),
 				8:  uint8(128),
 				9:  uint8(128),
 				10: uint8(128),
 			},
 			1: {
 				0:  uint8(244),
 				1:  uint8(1),
 				2:  uint8(255),
 				3:  uint8(128),
 				4:  uint8(128),
 				5:  uint8(128),
 				6:  uint8(128),
 				7:  uint8(128),
 				8:  uint8(128),
 				9:  uint8(128),
 				10: uint8(128),
 			},
 			2: {
 				0:  uint8(238),
 				1:  uint8(1),
 				2:  uint8(255),
 				3:  uint8(128),
 				4:  uint8(128),
 				5:  uint8(128),
 				6:  uint8(128),
 				7:  uint8(128),
 				8:  uint8(128),
 				9:  uint8(128),
 				10: uint8(128),
 			},
 		},
 	},
 }
 
 // C documentation
 //
 //	// Paragraph 11.5
 var kBModesProba = [10][10][9]uint8_t{
 	0: {
 		0: {
 			0: uint8(231),
 			1: uint8(120),
 			2: uint8(48),
 			3: uint8(89),
 			4: uint8(115),
 			5: uint8(113),
 			6: uint8(120),
 			7: uint8(152),
 			8: uint8(112),
 		},
 		1: {
 			0: uint8(152),
 			1: uint8(179),
 			2: uint8(64),
 			3: uint8(126),
 			4: uint8(170),
 			5: uint8(118),
 			6: uint8(46),
 			7: uint8(70),
 			8: uint8(95),
 		},
 		2: {
 			0: uint8(175),
 			1: uint8(69),
 			2: uint8(143),
 			3: uint8(80),
 			4: uint8(85),
 			5: uint8(82),
 			6: uint8(72),
 			7: uint8(155),
 			8: uint8(103),
 		},
 		3: {
 			0: uint8(56),
 			1: uint8(58),
 			2: uint8(10),
 			3: uint8(171),
 			4: uint8(218),
 			5: uint8(189),
 			6: uint8(17),
 			7: uint8(13),
 			8: uint8(152),
 		},
 		4: {
 			0: uint8(114),
 			1: uint8(26),
 			2: uint8(17),
 			3: uint8(163),
 			4: uint8(44),
 			5: uint8(195),
 			6: uint8(21),
 			7: uint8(10),
 			8: uint8(173),
 		},
 		5: {
 			0: uint8(121),
 			1: uint8(24),
 			2: uint8(80),
 			3: uint8(195),
 			4: uint8(26),
 			5: uint8(62),
 			6: uint8(44),
 			7: uint8(64),
 			8: uint8(85),
 		},
 		6: {
 			0: uint8(144),
 			1: uint8(71),
 			2: uint8(10),
 			3: uint8(38),
 			4: uint8(171),
 			5: uint8(213),
 			6: uint8(144),
 			7: uint8(34),
 			8: uint8(26),
 		},
 		7: {
 			0: uint8(170),
 			1: uint8(46),
 			2: uint8(55),
 			3: uint8(19),
 			4: uint8(136),
 			5: uint8(160),
 			6: uint8(33),
 			7: uint8(206),
 			8: uint8(71),
 		},
 		8: {
 			0: uint8(63),
 			1: uint8(20),
 			2: uint8(8),
 			3: uint8(114),
 			4: uint8(114),
 			5: uint8(208),
 			6: uint8(12),
 			7: uint8(9),
 			8: uint8(226),
 		},
 		9: {
 			0: uint8(81),
 			1: uint8(40),
 			2: uint8(11),
 			3: uint8(96),
 			4: uint8(182),
 			5: uint8(84),
 			6: uint8(29),
 			7: uint8(16),
 			8: uint8(36),
 		},
 	},
 	1: {
 		0: {
 			0: uint8(134),
 			1: uint8(183),
 			2: uint8(89),
 			3: uint8(137),
 			4: uint8(98),
 			5: uint8(101),
 			6: uint8(106),
 			7: uint8(165),
 			8: uint8(148),
 		},
 		1: {
 			0: uint8(72),
 			1: uint8(187),
 			2: uint8(100),
 			3: uint8(130),
 			4: uint8(157),
 			5: uint8(111),
 			6: uint8(32),
 			7: uint8(75),
 			8: uint8(80),
 		},
 		2: {
 			0: uint8(66),
 			1: uint8(102),
 			2: uint8(167),
 			3: uint8(99),
 			4: uint8(74),
 			5: uint8(62),
 			6: uint8(40),
 			7: uint8(234),
 			8: uint8(128),
 		},
 		3: {
 			0: uint8(41),
 			1: uint8(53),
 			2: uint8(9),
 			3: uint8(178),
 			4: uint8(241),
 			5: uint8(141),
 			6: uint8(26),
 			7: uint8(8),
 			8: uint8(107),
 		},
 		4: {
 			0: uint8(74),
 			1: uint8(43),
 			2: uint8(26),
 			3: uint8(146),
 			4: uint8(73),
 			5: uint8(166),
 			6: uint8(49),
 			7: uint8(23),
 			8: uint8(157),
 		},
 		5: {
 			0: uint8(65),
 			1: uint8(38),
 			2: uint8(105),
 			3: uint8(160),
 			4: uint8(51),
 			5: uint8(52),
 			6: uint8(31),
 			7: uint8(115),
 			8: uint8(128),
 		},
 		6: {
 			0: uint8(104),
 			1: uint8(79),
 			2: uint8(12),
 			3: uint8(27),
 			4: uint8(217),
 			5: uint8(255),
 			6: uint8(87),
 			7: uint8(17),
 			8: uint8(7),
 		},
 		7: {
 			0: uint8(87),
 			1: uint8(68),
 			2: uint8(71),
 			3: uint8(44),
 			4: uint8(114),
 			5: uint8(51),
 			6: uint8(15),
 			7: uint8(186),
 			8: uint8(23),
 		},
 		8: {
 			0: uint8(47),
 			1: uint8(41),
 			2: uint8(14),
 			3: uint8(110),
 			4: uint8(182),
 			5: uint8(183),
 			6: uint8(21),
 			7: uint8(17),
 			8: uint8(194),
 		},
 		9: {
 			0: uint8(66),
 			1: uint8(45),
 			2: uint8(25),
 			3: uint8(102),
 			4: uint8(197),
 			5: uint8(189),
 			6: uint8(23),
 			7: uint8(18),
 			8: uint8(22),
 		},
 	},
 	2: {
 		0: {
 			0: uint8(88),
 			1: uint8(88),
 			2: uint8(147),
 			3: uint8(150),
 			4: uint8(42),
 			5: uint8(46),
 			6: uint8(45),
 			7: uint8(196),
 			8: uint8(205),
 		},
 		1: {
 			0: uint8(43),
 			1: uint8(97),
 			2: uint8(183),
 			3: uint8(117),
 			4: uint8(85),
 			5: uint8(38),
 			6: uint8(35),
 			7: uint8(179),
 			8: uint8(61),
 		},
 		2: {
 			0: uint8(39),
 			1: uint8(53),
 			2: uint8(200),
 			3: uint8(87),
 			4: uint8(26),
 			5: uint8(21),
 			6: uint8(43),
 			7: uint8(232),
 			8: uint8(171),
 		},
 		3: {
 			0: uint8(56),
 			1: uint8(34),
 			2: uint8(51),
 			3: uint8(104),
 			4: uint8(114),
 			5: uint8(102),
 			6: uint8(29),
 			7: uint8(93),
 			8: uint8(77),
 		},
 		4: {
 			0: uint8(39),
 			1: uint8(28),
 			2: uint8(85),
 			3: uint8(171),
 			4: uint8(58),
 			5: uint8(165),
 			6: uint8(90),
 			7: uint8(98),
 			8: uint8(64),
 		},
 		5: {
 			0: uint8(34),
 			1: uint8(22),
 			2: uint8(116),
 			3: uint8(206),
 			4: uint8(23),
 			5: uint8(34),
 			6: uint8(43),
 			7: uint8(166),
 			8: uint8(73),
 		},
 		6: {
 			0: uint8(107),
 			1: uint8(54),
 			2: uint8(32),
 			3: uint8(26),
 			4: uint8(51),
 			5: uint8(1),
 			6: uint8(81),
 			7: uint8(43),
 			8: uint8(31),
 		},
 		7: {
 			0: uint8(68),
 			1: uint8(25),
 			2: uint8(106),
 			3: uint8(22),
 			4: uint8(64),
 			5: uint8(171),
 			6: uint8(36),
 			7: uint8(225),
 			8: uint8(114),
 		},
 		8: {
 			0: uint8(34),
 			1: uint8(19),
 			2: uint8(21),
 			3: uint8(102),
 			4: uint8(132),
 			5: uint8(188),
 			6: uint8(16),
 			7: uint8(76),
 			8: uint8(124),
 		},
 		9: {
 			0: uint8(62),
 			1: uint8(18),
 			2: uint8(78),
 			3: uint8(95),
 			4: uint8(85),
 			5: uint8(57),
 			6: uint8(50),
 			7: uint8(48),
 			8: uint8(51),
 		},
 	},
 	3: {
 		0: {
 			0: uint8(193),
 			1: uint8(101),
 			2: uint8(35),
 			3: uint8(159),
 			4: uint8(215),
 			5: uint8(111),
 			6: uint8(89),
 			7: uint8(46),
 			8: uint8(111),
 		},
 		1: {
 			0: uint8(60),
 			1: uint8(148),
 			2: uint8(31),
 			3: uint8(172),
 			4: uint8(219),
 			5: uint8(228),
 			6: uint8(21),
 			7: uint8(18),
 			8: uint8(111),
 		},
 		2: {
 			0: uint8(112),
 			1: uint8(113),
 			2: uint8(77),
 			3: uint8(85),
 			4: uint8(179),
 			5: uint8(255),
 			6: uint8(38),
 			7: uint8(120),
 			8: uint8(114),
 		},
 		3: {
 			0: uint8(40),
 			1: uint8(42),
 			2: uint8(1),
 			3: uint8(196),
 			4: uint8(245),
 			5: uint8(209),
 			6: uint8(10),
 			7: uint8(25),
 			8: uint8(109),
 		},
 		4: {
 			0: uint8(88),
 			1: uint8(43),
 			2: uint8(29),
 			3: uint8(140),
 			4: uint8(166),
 			5: uint8(213),
 			6: uint8(37),
 			7: uint8(43),
 			8: uint8(154),
 		},
 		5: {
 			0: uint8(61),
 			1: uint8(63),
 			2: uint8(30),
 			3: uint8(155),
 			4: uint8(67),
 			5: uint8(45),
 			6: uint8(68),
 			7: uint8(1),
 			8: uint8(209),
 		},
 		6: {
 			0: uint8(100),
 			1: uint8(80),
 			2: uint8(8),
 			3: uint8(43),
 			4: uint8(154),
 			5: uint8(1),
 			6: uint8(51),
 			7: uint8(26),
 			8: uint8(71),
 		},
 		7: {
 			0: uint8(142),
 			1: uint8(78),
 			2: uint8(78),
 			3: uint8(16),
 			4: uint8(255),
 			5: uint8(128),
 			6: uint8(34),
 			7: uint8(197),
 			8: uint8(171),
 		},
 		8: {
 			0: uint8(41),
 			1: uint8(40),
 			2: uint8(5),
 			3: uint8(102),
 			4: uint8(211),
 			5: uint8(183),
 			6: uint8(4),
 			7: uint8(1),
 			8: uint8(221),
 		},
 		9: {
 			0: uint8(51),
 			1: uint8(50),
 			2: uint8(17),
 			3: uint8(168),
 			4: uint8(209),
 			5: uint8(192),
 			6: uint8(23),
 			7: uint8(25),
 			8: uint8(82),
 		},
 	},
 	4: {
 		0: {
 			0: uint8(138),
 			1: uint8(31),
 			2: uint8(36),
 			3: uint8(171),
 			4: uint8(27),
 			5: uint8(166),
 			6: uint8(38),
 			7: uint8(44),
 			8: uint8(229),
 		},
 		1: {
 			0: uint8(67),
 			1: uint8(87),
 			2: uint8(58),
 			3: uint8(169),
 			4: uint8(82),
 			5: uint8(115),
 			6: uint8(26),
 			7: uint8(59),
 			8: uint8(179),
 		},
 		2: {
 			0: uint8(63),
 			1: uint8(59),
 			2: uint8(90),
 			3: uint8(180),
 			4: uint8(59),
 			5: uint8(166),
 			6: uint8(93),
 			7: uint8(73),
 			8: uint8(154),
 		},
 		3: {
 			0: uint8(40),
 			1: uint8(40),
 			2: uint8(21),
 			3: uint8(116),
 			4: uint8(143),
 			5: uint8(209),
 			6: uint8(34),
 			7: uint8(39),
 			8: uint8(175),
 		},
 		4: {
 			0: uint8(47),
 			1: uint8(15),
 			2: uint8(16),
 			3: uint8(183),
 			4: uint8(34),
 			5: uint8(223),
 			6: uint8(49),
 			7: uint8(45),
 			8: uint8(183),
 		},
 		5: {
 			0: uint8(46),
 			1: uint8(17),
 			2: uint8(33),
 			3: uint8(183),
 			4: uint8(6),
 			5: uint8(98),
 			6: uint8(15),
 			7: uint8(32),
 			8: uint8(183),
 		},
 		6: {
 			0: uint8(57),
 			1: uint8(46),
 			2: uint8(22),
 			3: uint8(24),
 			4: uint8(128),
 			5: uint8(1),
 			6: uint8(54),
 			7: uint8(17),
 			8: uint8(37),
 		},
 		7: {
 			0: uint8(65),
 			1: uint8(32),
 			2: uint8(73),
 			3: uint8(115),
 			4: uint8(28),
 			5: uint8(128),
 			6: uint8(23),
 			7: uint8(128),
 			8: uint8(205),
 		},
 		8: {
 			0: uint8(40),
 			1: uint8(3),
 			2: uint8(9),
 			3: uint8(115),
 			4: uint8(51),
 			5: uint8(192),
 			6: uint8(18),
 			7: uint8(6),
 			8: uint8(223),
 		},
 		9: {
 			0: uint8(87),
 			1: uint8(37),
 			2: uint8(9),
 			3: uint8(115),
 			4: uint8(59),
 			5: uint8(77),
 			6: uint8(64),
 			7: uint8(21),
 			8: uint8(47),
 		},
 	},
 	5: {
 		0: {
 			0: uint8(104),
 			1: uint8(55),
 			2: uint8(44),
 			3: uint8(218),
 			4: uint8(9),
 			5: uint8(54),
 			6: uint8(53),
 			7: uint8(130),
 			8: uint8(226),
 		},
 		1: {
 			0: uint8(64),
 			1: uint8(90),
 			2: uint8(70),
 			3: uint8(205),
 			4: uint8(40),
 			5: uint8(41),
 			6: uint8(23),
 			7: uint8(26),
 			8: uint8(57),
 		},
 		2: {
 			0: uint8(54),
 			1: uint8(57),
 			2: uint8(112),
 			3: uint8(184),
 			4: uint8(5),
 			5: uint8(41),
 			6: uint8(38),
 			7: uint8(166),
 			8: uint8(213),
 		},
 		3: {
 			0: uint8(30),
 			1: uint8(34),
 			2: uint8(26),
 			3: uint8(133),
 			4: uint8(152),
 			5: uint8(116),
 			6: uint8(10),
 			7: uint8(32),
 			8: uint8(134),
 		},
 		4: {
 			0: uint8(39),
 			1: uint8(19),
 			2: uint8(53),
 			3: uint8(221),
 			4: uint8(26),
 			5: uint8(114),
 			6: uint8(32),
 			7: uint8(73),
 			8: uint8(255),
 		},
 		5: {
 			0: uint8(31),
 			1: uint8(9),
 			2: uint8(65),
 			3: uint8(234),
 			4: uint8(2),
 			5: uint8(15),
 			6: uint8(1),
 			7: uint8(118),
 			8: uint8(73),
 		},
 		6: {
 			0: uint8(75),
 			1: uint8(32),
 			2: uint8(12),
 			3: uint8(51),
 			4: uint8(192),
 			5: uint8(255),
 			6: uint8(160),
 			7: uint8(43),
 			8: uint8(51),
 		},
 		7: {
 			0: uint8(88),
 			1: uint8(31),
 			2: uint8(35),
 			3: uint8(67),
 			4: uint8(102),
 			5: uint8(85),
 			6: uint8(55),
 			7: uint8(186),
 			8: uint8(85),
 		},
 		8: {
 			0: uint8(56),
 			1: uint8(21),
 			2: uint8(23),
 			3: uint8(111),
 			4: uint8(59),
 			5: uint8(205),
 			6: uint8(45),
 			7: uint8(37),
 			8: uint8(192),
 		},
 		9: {
 			0: uint8(55),
 			1: uint8(38),
 			2: uint8(70),
 			3: uint8(124),
 			4: uint8(73),
 			5: uint8(102),
 			6: uint8(1),
 			7: uint8(34),
 			8: uint8(98),
 		},
 	},
 	6: {
 		0: {
 			0: uint8(125),
 			1: uint8(98),
 			2: uint8(42),
 			3: uint8(88),
 			4: uint8(104),
 			5: uint8(85),
 			6: uint8(117),
 			7: uint8(175),
 			8: uint8(82),
 		},
 		1: {
 			0: uint8(95),
 			1: uint8(84),
 			2: uint8(53),
 			3: uint8(89),
 			4: uint8(128),
 			5: uint8(100),
 			6: uint8(113),
 			7: uint8(101),
 			8: uint8(45),
 		},
 		2: {
 			0: uint8(75),
 			1: uint8(79),
 			2: uint8(123),
 			3: uint8(47),
 			4: uint8(51),
 			5: uint8(128),
 			6: uint8(81),
 			7: uint8(171),
 			8: uint8(1),
 		},
 		3: {
 			0: uint8(57),
 			1: uint8(17),
 			2: uint8(5),
 			3: uint8(71),
 			4: uint8(102),
 			5: uint8(57),
 			6: uint8(53),
 			7: uint8(41),
 			8: uint8(49),
 		},
 		4: {
 			0: uint8(38),
 			1: uint8(33),
 			2: uint8(13),
 			3: uint8(121),
 			4: uint8(57),
 			5: uint8(73),
 			6: uint8(26),
 			7: uint8(1),
 			8: uint8(85),
 		},
 		5: {
 			0: uint8(41),
 			1: uint8(10),
 			2: uint8(67),
 			3: uint8(138),
 			4: uint8(77),
 			5: uint8(110),
 			6: uint8(90),
 			7: uint8(47),
 			8: uint8(114),
 		},
 		6: {
 			0: uint8(115),
 			1: uint8(21),
 			2: uint8(2),
 			3: uint8(10),
 			4: uint8(102),
 			5: uint8(255),
 			6: uint8(166),
 			7: uint8(23),
 			8: uint8(6),
 		},
 		7: {
 			0: uint8(101),
 			1: uint8(29),
 			2: uint8(16),
 			3: uint8(10),
 			4: uint8(85),
 			5: uint8(128),
 			6: uint8(101),
 			7: uint8(196),
 			8: uint8(26),
 		},
 		8: {
 			0: uint8(57),
 			1: uint8(18),
 			2: uint8(10),
 			3: uint8(102),
 			4: uint8(102),
 			5: uint8(213),
 			6: uint8(34),
 			7: uint8(20),
 			8: uint8(43),
 		},
 		9: {
 			0: uint8(117),
 			1: uint8(20),
 			2: uint8(15),
 			3: uint8(36),
 			4: uint8(163),
 			5: uint8(128),
 			6: uint8(68),
 			7: uint8(1),
 			8: uint8(26),
 		},
 	},
 	7: {
 		0: {
 			0: uint8(102),
 			1: uint8(61),
 			2: uint8(71),
 			3: uint8(37),
 			4: uint8(34),
 			5: uint8(53),
 			6: uint8(31),
 			7: uint8(243),
 			8: uint8(192),
 		},
 		1: {
 			0: uint8(69),
 			1: uint8(60),
 			2: uint8(71),
 			3: uint8(38),
 			4: uint8(73),
 			5: uint8(119),
 			6: uint8(28),
 			7: uint8(222),
 			8: uint8(37),
 		},
 		2: {
 			0: uint8(68),
 			1: uint8(45),
 			2: uint8(128),
 			3: uint8(34),
 			4: uint8(1),
 			5: uint8(47),
 			6: uint8(11),
 			7: uint8(245),
 			8: uint8(171),
 		},
 		3: {
 			0: uint8(62),
 			1: uint8(17),
 			2: uint8(19),
 			3: uint8(70),
 			4: uint8(146),
 			5: uint8(85),
 			6: uint8(55),
 			7: uint8(62),
 			8: uint8(70),
 		},
 		4: {
 			0: uint8(37),
 			1: uint8(43),
 			2: uint8(37),
 			3: uint8(154),
 			4: uint8(100),
 			5: uint8(163),
 			6: uint8(85),
 			7: uint8(160),
 			8: uint8(1),
 		},
 		5: {
 			0: uint8(63),
 			1: uint8(9),
 			2: uint8(92),
 			3: uint8(136),
 			4: uint8(28),
 			5: uint8(64),
 			6: uint8(32),
 			7: uint8(201),
 			8: uint8(85),
 		},
 		6: {
 			0: uint8(75),
 			1: uint8(15),
 			2: uint8(9),
 			3: uint8(9),
 			4: uint8(64),
 			5: uint8(255),
 			6: uint8(184),
 			7: uint8(119),
 			8: uint8(16),
 		},
 		7: {
 			0: uint8(86),
 			1: uint8(6),
 			2: uint8(28),
 			3: uint8(5),
 			4: uint8(64),
 			5: uint8(255),
 			6: uint8(25),
 			7: uint8(248),
 			8: uint8(1),
 		},
 		8: {
 			0: uint8(56),
 			1: uint8(8),
 			2: uint8(17),
 			3: uint8(132),
 			4: uint8(137),
 			5: uint8(255),
 			6: uint8(55),
 			7: uint8(116),
 			8: uint8(128),
 		},
 		9: {
 			0: uint8(58),
 			1: uint8(15),
 			2: uint8(20),
 			3: uint8(82),
 			4: uint8(135),
 			5: uint8(57),
 			6: uint8(26),
 			7: uint8(121),
 			8: uint8(40),
 		},
 	},
 	8: {
 		0: {
 			0: uint8(164),
 			1: uint8(50),
 			2: uint8(31),
 			3: uint8(137),
 			4: uint8(154),
 			5: uint8(133),
 			6: uint8(25),
 			7: uint8(35),
 			8: uint8(218),
 		},
 		1: {
 			0: uint8(51),
 			1: uint8(103),
 			2: uint8(44),
 			3: uint8(131),
 			4: uint8(131),
 			5: uint8(123),
 			6: uint8(31),
 			7: uint8(6),
 			8: uint8(158),
 		},
 		2: {
 			0: uint8(86),
 			1: uint8(40),
 			2: uint8(64),
 			3: uint8(135),
 			4: uint8(148),
 			5: uint8(224),
 			6: uint8(45),
 			7: uint8(183),
 			8: uint8(128),
 		},
 		3: {
 			0: uint8(22),
 			1: uint8(26),
 			2: uint8(17),
 			3: uint8(131),
 			4: uint8(240),
 			5: uint8(154),
 			6: uint8(14),
 			7: uint8(1),
 			8: uint8(209),
 		},
 		4: {
 			0: uint8(45),
 			1: uint8(16),
 			2: uint8(21),
 			3: uint8(91),
 			4: uint8(64),
 			5: uint8(222),
 			6: uint8(7),
 			7: uint8(1),
 			8: uint8(197),
 		},
 		5: {
 			0: uint8(56),
 			1: uint8(21),
 			2: uint8(39),
 			3: uint8(155),
 			4: uint8(60),
 			5: uint8(138),
 			6: uint8(23),
 			7: uint8(102),
 			8: uint8(213),
 		},
 		6: {
 			0: uint8(83),
 			1: uint8(12),
 			2: uint8(13),
 			3: uint8(54),
 			4: uint8(192),
 			5: uint8(255),
 			6: uint8(68),
 			7: uint8(47),
 			8: uint8(28),
 		},
 		7: {
 			0: uint8(85),
 			1: uint8(26),
 			2: uint8(85),
 			3: uint8(85),
 			4: uint8(128),
 			5: uint8(128),
 			6: uint8(32),
 			7: uint8(146),
 			8: uint8(171),
 		},
 		8: {
 			0: uint8(18),
 			1: uint8(11),
 			2: uint8(7),
 			3: uint8(63),
 			4: uint8(144),
 			5: uint8(171),
 			6: uint8(4),
 			7: uint8(4),
 			8: uint8(246),
 		},
 		9: {
 			0: uint8(35),
 			1: uint8(27),
 			2: uint8(10),
 			3: uint8(146),
 			4: uint8(174),
 			5: uint8(171),
 			6: uint8(12),
 			7: uint8(26),
 			8: uint8(128),
 		},
 	},
 	9: {
 		0: {
 			0: uint8(190),
 			1: uint8(80),
 			2: uint8(35),
 			3: uint8(99),
 			4: uint8(180),
 			5: uint8(80),
 			6: uint8(126),
 			7: uint8(54),
 			8: uint8(45),
 		},
 		1: {
 			0: uint8(85),
 			1: uint8(126),
 			2: uint8(47),
 			3: uint8(87),
 			4: uint8(176),
 			5: uint8(51),
 			6: uint8(41),
 			7: uint8(20),
 			8: uint8(32),
 		},
 		2: {
 			0: uint8(101),
 			1: uint8(75),
 			2: uint8(128),
 			3: uint8(139),
 			4: uint8(118),
 			5: uint8(146),
 			6: uint8(116),
 			7: uint8(128),
 			8: uint8(85),
 		},
 		3: {
 			0: uint8(56),
 			1: uint8(41),
 			2: uint8(15),
 			3: uint8(176),
 			4: uint8(236),
 			5: uint8(85),
 			6: uint8(37),
 			7: uint8(9),
 			8: uint8(62),
 		},
 		4: {
 			0: uint8(71),
 			1: uint8(30),
 			2: uint8(17),
 			3: uint8(119),
 			4: uint8(118),
 			5: uint8(255),
 			6: uint8(17),
 			7: uint8(18),
 			8: uint8(138),
 		},
 		5: {
 			0: uint8(101),
 			1: uint8(38),
 			2: uint8(60),
 			3: uint8(138),
 			4: uint8(55),
 			5: uint8(70),
 			6: uint8(43),
 			7: uint8(26),
 			8: uint8(142),
 		},
 		6: {
 			0: uint8(146),
 			1: uint8(36),
 			2: uint8(19),
 			3: uint8(30),
 			4: uint8(171),
 			5: uint8(255),
 			6: uint8(97),
 			7: uint8(27),
 			8: uint8(20),
 		},
 		7: {
 			0: uint8(138),
 			1: uint8(45),
 			2: uint8(61),
 			3: uint8(62),
 			4: uint8(219),
 			5: uint8(1),
 			6: uint8(81),
 			7: uint8(188),
 			8: uint8(64),
 		},
 		8: {
 			0: uint8(32),
 			1: uint8(41),
 			2: uint8(20),
 			3: uint8(117),
 			4: uint8(151),
 			5: uint8(142),
 			6: uint8(20),
 			7: uint8(21),
 			8: uint8(163),
 		},
 		9: {
 			0: uint8(112),
 			1: uint8(19),
 			2: uint8(12),
 			3: uint8(61),
 			4: uint8(195),
 			5: uint8(128),
 			6: uint8(48),
 			7: uint8(4),
 			8: uint8(24),
 		},
 	},
 }
 
 func VP8ResetProba(tls *libc.TLS, proba uintptr) {
 	libc.X__builtin___memset_chk(tls, proba, libc.Int32FromUint32(255), uint64(3), ^__predefined_size_t(0))
 	// proba->bands[][] is initialized later
 }
 
 func ParseIntraMode(tls *libc.TLS, br2 uintptr, dec uintptr, mb_x int32) {
 	bp := tls.Alloc(16)
 	defer tls.Free(16)
 	var bit, i, pos, shift, x1, y, ymode, ymode1, v1, v14, v16, v22, v24, v30, v32, v6, v8 int32
 	var bits bit_t
 	var block, left, modes, prob1, top, v10, v11, v18, v19, v2, v3 uintptr
 	var range1, split, value range_t
 	var v12, v20, v4 uint64_t
 	var _ /* in_bits at bp+0 */ lbit_t
 	_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = bit, bits, block, i, left, modes, pos, prob1, range1, shift, split, top, value, x1, y, ymode, ymode1, v1, v10, v11, v12, v14, v16, v18, v19, v2, v20, v22, v24, v3, v30, v32, v4, v6, v8
 	top = (*VP8Decoder)(unsafe.Pointer(dec)).Fintra_t + uintptr(int32(4)*mb_x)
 	left = dec + 2816
 	block = (*VP8Decoder)(unsafe.Pointer(dec)).Fmb_data + uintptr(mb_x)*800
 	// Note: we don't save segment map (yet), as we don't expect
 	// to decode more than 1 keyframe.
 	if (*VP8Decoder)(unsafe.Pointer(dec)).Fsegment_hdr.Fupdate_map != 0 {
 		// Hardcoded tree parsing
 		v2 = br2
 		range1 = (*VP8BitReader)(unsafe.Pointer(v2)).Frange1
 		if (*VP8BitReader)(unsafe.Pointer(v2)).Fbits < libc.Int32FromInt32(0) {
 			v3 = v2
 			if (*VP8BitReader)(unsafe.Pointer(v3)).Fbuf < (*VP8BitReader)(unsafe.Pointer(v3)).Fbuf_max {
 				libc.X__builtin___memcpy_chk(tls, bp, (*VP8BitReader)(unsafe.Pointer(v3)).Fbuf, uint64(8), ^__predefined_size_t(0))
 				**(**uintptr)(__ccgo_up(v3 + 16)) += uintptr(libc.Int32FromInt32(BITS) >> libc.Int32FromInt32(3))
 				v4 = uint64(libc.X__builtin_bswap64(tls, uint64(**(**lbit_t)(__ccgo_up(bp)))))
 				goto _5
 			_5:
 				bits = v4
 				bits = bits >> libc.Uint64FromInt32(libc.Int32FromInt32(64)-libc.Int32FromInt32(BITS))
 				(*VP8BitReader)(unsafe.Pointer(v3)).Fvalue = bits | (*VP8BitReader)(unsafe.Pointer(v3)).Fvalue<<libc.Int32FromInt32(BITS)
 				**(**int32)(__ccgo_up(v3 + 12)) += int32(BITS)
 			} else {
 				VP8LoadFinalBytes(tls, v3)
 			}
 		}
 		pos = (*VP8BitReader)(unsafe.Pointer(v2)).Fbits
 		split = range1 * libc.Uint32FromInt32(libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(dec + 1192)))) >> int32(8)
 		value = uint32((*VP8BitReader)(unsafe.Pointer(v2)).Fvalue >> pos)
 		bit = libc.BoolInt32(value > split)
 		if bit != 0 {
 			range1 = range1 - split
 			**(**bit_t)(__ccgo_up(v2)) -= uint64(split+libc.Uint32FromInt32(1)) << pos
 		} else {
 			range1 = split + uint32(1)
 		}
 		v6 = int32(31) ^ libc.X__builtin_clz(tls, range1)
 		goto _7
 	_7:
 		shift = int32(7) ^ v6
 		range1 = range1 << libc.Uint32FromInt32(shift)
 		**(**int32)(__ccgo_up(v2 + 12)) -= shift
 		(*VP8BitReader)(unsafe.Pointer(v2)).Frange1 = range1 - uint32(1)
 		v8 = bit
 		goto _9
 	_9:
 		if !(v8 != 0) {
 			v10 = br2
 			range1 = (*VP8BitReader)(unsafe.Pointer(v10)).Frange1
 			if (*VP8BitReader)(unsafe.Pointer(v10)).Fbits < libc.Int32FromInt32(0) {
 				v11 = v10
 				if (*VP8BitReader)(unsafe.Pointer(v11)).Fbuf < (*VP8BitReader)(unsafe.Pointer(v11)).Fbuf_max {
 					libc.X__builtin___memcpy_chk(tls, bp, (*VP8BitReader)(unsafe.Pointer(v11)).Fbuf, uint64(8), ^__predefined_size_t(0))
 					**(**uintptr)(__ccgo_up(v11 + 16)) += uintptr(libc.Int32FromInt32(BITS) >> libc.Int32FromInt32(3))
 					v12 = uint64(libc.X__builtin_bswap64(tls, uint64(**(**lbit_t)(__ccgo_up(bp)))))
 					goto _13
 				_13:
 					bits = v12
 					bits = bits >> libc.Uint64FromInt32(libc.Int32FromInt32(64)-libc.Int32FromInt32(BITS))
 					(*VP8BitReader)(unsafe.Pointer(v11)).Fvalue = bits | (*VP8BitReader)(unsafe.Pointer(v11)).Fvalue<<libc.Int32FromInt32(BITS)
 					**(**int32)(__ccgo_up(v11 + 12)) += int32(BITS)
 				} else {
 					VP8LoadFinalBytes(tls, v11)
 				}
 			}
 			pos = (*VP8BitReader)(unsafe.Pointer(v10)).Fbits
 			split = range1 * libc.Uint32FromInt32(libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(dec + 1192 + 1)))) >> int32(8)
 			value = uint32((*VP8BitReader)(unsafe.Pointer(v10)).Fvalue >> pos)
 			bit = libc.BoolInt32(value > split)
 			if bit != 0 {
 				range1 = range1 - split
 				**(**bit_t)(__ccgo_up(v10)) -= uint64(split+libc.Uint32FromInt32(1)) << pos
 			} else {
 				range1 = split + uint32(1)
 			}
 			v14 = int32(31) ^ libc.X__builtin_clz(tls, range1)
 			goto _15
 		_15:
 			shift = int32(7) ^ v14
 			range1 = range1 << libc.Uint32FromInt32(shift)
 			**(**int32)(__ccgo_up(v10 + 12)) -= shift
 			(*VP8BitReader)(unsafe.Pointer(v10)).Frange1 = range1 - uint32(1)
 			v16 = bit
 			goto _17
 		_17:
 			v1 = v16
 		} else {
 			v18 = br2
 			range1 = (*VP8BitReader)(unsafe.Pointer(v18)).Frange1
 			if (*VP8BitReader)(unsafe.Pointer(v18)).Fbits < libc.Int32FromInt32(0) {
 				v19 = v18
 				if (*VP8BitReader)(unsafe.Pointer(v19)).Fbuf < (*VP8BitReader)(unsafe.Pointer(v19)).Fbuf_max {
 					libc.X__builtin___memcpy_chk(tls, bp, (*VP8BitReader)(unsafe.Pointer(v19)).Fbuf, uint64(8), ^__predefined_size_t(0))
 					**(**uintptr)(__ccgo_up(v19 + 16)) += uintptr(libc.Int32FromInt32(BITS) >> libc.Int32FromInt32(3))
 					v20 = uint64(libc.X__builtin_bswap64(tls, uint64(**(**lbit_t)(__ccgo_up(bp)))))
 					goto _21
 				_21:
 					bits = v20
 					bits = bits >> libc.Uint64FromInt32(libc.Int32FromInt32(64)-libc.Int32FromInt32(BITS))
 					(*VP8BitReader)(unsafe.Pointer(v19)).Fvalue = bits | (*VP8BitReader)(unsafe.Pointer(v19)).Fvalue<<libc.Int32FromInt32(BITS)
 					**(**int32)(__ccgo_up(v19 + 12)) += int32(BITS)
 				} else {
 					VP8LoadFinalBytes(tls, v19)
 				}
 			}
 			pos = (*VP8BitReader)(unsafe.Pointer(v18)).Fbits
 			split = range1 * libc.Uint32FromInt32(libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(dec + 1192 + 2)))) >> int32(8)
 			value = uint32((*VP8BitReader)(unsafe.Pointer(v18)).Fvalue >> pos)
 			bit = libc.BoolInt32(value > split)
 			if bit != 0 {
 				range1 = range1 - split
 				**(**bit_t)(__ccgo_up(v18)) -= uint64(split+libc.Uint32FromInt32(1)) << pos
 			} else {
 				range1 = split + uint32(1)
 			}
 			v22 = int32(31) ^ libc.X__builtin_clz(tls, range1)
 			goto _23
 		_23:
 			shift = int32(7) ^ v22
 			range1 = range1 << libc.Uint32FromInt32(shift)
 			**(**int32)(__ccgo_up(v18 + 12)) -= shift
 			(*VP8BitReader)(unsafe.Pointer(v18)).Frange1 = range1 - uint32(1)
 			v24 = bit
 			goto _25
 		_25:
 			v1 = v24 + int32(2)
 		}
 		(*VP8MBData)(unsafe.Pointer(block)).Fsegment = libc.Uint8FromInt32(v1)
 	} else {
 		(*VP8MBData)(unsafe.Pointer(block)).Fsegment = uint8(0) // default for intra
 	}
 	if (*VP8Decoder)(unsafe.Pointer(dec)).Fuse_skip_proba != 0 {
 		v2 = br2
 		range1 = (*VP8BitReader)(unsafe.Pointer(v2)).Frange1
 		if (*VP8BitReader)(unsafe.Pointer(v2)).Fbits < libc.Int32FromInt32(0) {
 			v3 = v2
 			if (*VP8BitReader)(unsafe.Pointer(v3)).Fbuf < (*VP8BitReader)(unsafe.Pointer(v3)).Fbuf_max {
 				libc.X__builtin___memcpy_chk(tls, bp, (*VP8BitReader)(unsafe.Pointer(v3)).Fbuf, uint64(8), ^__predefined_size_t(0))
 				**(**uintptr)(__ccgo_up(v3 + 16)) += uintptr(libc.Int32FromInt32(BITS) >> libc.Int32FromInt32(3))
 				v4 = uint64(libc.X__builtin_bswap64(tls, uint64(**(**lbit_t)(__ccgo_up(bp)))))
 				goto _29
 			_29:
 				bits = v4
 				bits = bits >> libc.Uint64FromInt32(libc.Int32FromInt32(64)-libc.Int32FromInt32(BITS))
 				(*VP8BitReader)(unsafe.Pointer(v3)).Fvalue = bits | (*VP8BitReader)(unsafe.Pointer(v3)).Fvalue<<libc.Int32FromInt32(BITS)
 				**(**int32)(__ccgo_up(v3 + 12)) += int32(BITS)
 			} else {
 				VP8LoadFinalBytes(tls, v3)
 			}
 		}
 		pos = (*VP8BitReader)(unsafe.Pointer(v2)).Fbits
 		split = range1 * libc.Uint32FromInt32(libc.Int32FromUint8((*VP8Decoder)(unsafe.Pointer(dec)).Fskip_p)) >> int32(8)
 		value = uint32((*VP8BitReader)(unsafe.Pointer(v2)).Fvalue >> pos)
 		bit = libc.BoolInt32(value > split)
 		if bit != 0 {
 			range1 = range1 - split
 			**(**bit_t)(__ccgo_up(v2)) -= uint64(split+libc.Uint32FromInt32(1)) << pos
 		} else {
 			range1 = split + uint32(1)
 		}
 		v1 = int32(31) ^ libc.X__builtin_clz(tls, range1)
 		goto _31
 	_31:
 		shift = int32(7) ^ v1
 		range1 = range1 << libc.Uint32FromInt32(shift)
 		**(**int32)(__ccgo_up(v2 + 12)) -= shift
 		(*VP8BitReader)(unsafe.Pointer(v2)).Frange1 = range1 - uint32(1)
 		v6 = bit
 		goto _33
 	_33:
 		(*VP8MBData)(unsafe.Pointer(block)).Fskip = libc.Uint8FromInt32(v6)
 	}
 	v2 = br2
 	range1 = (*VP8BitReader)(unsafe.Pointer(v2)).Frange1
 	if (*VP8BitReader)(unsafe.Pointer(v2)).Fbits < libc.Int32FromInt32(0) {
 		v3 = v2
 		if (*VP8BitReader)(unsafe.Pointer(v3)).Fbuf < (*VP8BitReader)(unsafe.Pointer(v3)).Fbuf_max {
 			libc.X__builtin___memcpy_chk(tls, bp, (*VP8BitReader)(unsafe.Pointer(v3)).Fbuf, uint64(8), ^__predefined_size_t(0))
 			**(**uintptr)(__ccgo_up(v3 + 16)) += uintptr(libc.Int32FromInt32(BITS) >> libc.Int32FromInt32(3))
 			v4 = uint64(libc.X__builtin_bswap64(tls, uint64(**(**lbit_t)(__ccgo_up(bp)))))
 			goto _37
 		_37:
 			bits = v4
 			bits = bits >> libc.Uint64FromInt32(libc.Int32FromInt32(64)-libc.Int32FromInt32(BITS))
 			(*VP8BitReader)(unsafe.Pointer(v3)).Fvalue = bits | (*VP8BitReader)(unsafe.Pointer(v3)).Fvalue<<libc.Int32FromInt32(BITS)
 			**(**int32)(__ccgo_up(v3 + 12)) += int32(BITS)
 		} else {
 			VP8LoadFinalBytes(tls, v3)
 		}
 	}
 	pos = (*VP8BitReader)(unsafe.Pointer(v2)).Fbits
 	split = range1 * libc.Uint32FromInt32(int32(145)) >> int32(8)
 	value = uint32((*VP8BitReader)(unsafe.Pointer(v2)).Fvalue >> pos)
 	bit = libc.BoolInt32(value > split)
 	if bit != 0 {
 		range1 = range1 - split
 		**(**bit_t)(__ccgo_up(v2)) -= uint64(split+libc.Uint32FromInt32(1)) << pos
 	} else {
 		range1 = split + uint32(1)
 	}
 	v1 = int32(31) ^ libc.X__builtin_clz(tls, range1)
 	goto _39
 _39:
 	shift = int32(7) ^ v1
 	range1 = range1 << libc.Uint32FromInt32(shift)
 	**(**int32)(__ccgo_up(v2 + 12)) -= shift
 	(*VP8BitReader)(unsafe.Pointer(v2)).Frange1 = range1 - uint32(1)
 	v6 = bit
 	goto _41
 _41:
 	(*VP8MBData)(unsafe.Pointer(block)).Fis_i4x4 = libc.BoolUint8(!(v6 != 0))
 	if !((*VP8MBData)(unsafe.Pointer(block)).Fis_i4x4 != 0) {
 		v2 = br2
 		range1 = (*VP8BitReader)(unsafe.Pointer(v2)).Frange1
 		if (*VP8BitReader)(unsafe.Pointer(v2)).Fbits < libc.Int32FromInt32(0) {
 			v3 = v2
 			if (*VP8BitReader)(unsafe.Pointer(v3)).Fbuf < (*VP8BitReader)(unsafe.Pointer(v3)).Fbuf_max {
 				libc.X__builtin___memcpy_chk(tls, bp, (*VP8BitReader)(unsafe.Pointer(v3)).Fbuf, uint64(8), ^__predefined_size_t(0))
 				**(**uintptr)(__ccgo_up(v3 + 16)) += uintptr(libc.Int32FromInt32(BITS) >> libc.Int32FromInt32(3))
 				v4 = uint64(libc.X__builtin_bswap64(tls, uint64(**(**lbit_t)(__ccgo_up(bp)))))
 				goto _46
 			_46:
 				bits = v4
 				bits = bits >> libc.Uint64FromInt32(libc.Int32FromInt32(64)-libc.Int32FromInt32(BITS))
 				(*VP8BitReader)(unsafe.Pointer(v3)).Fvalue = bits | (*VP8BitReader)(unsafe.Pointer(v3)).Fvalue<<libc.Int32FromInt32(BITS)
 				**(**int32)(__ccgo_up(v3 + 12)) += int32(BITS)
 			} else {
 				VP8LoadFinalBytes(tls, v3)
 			}
 		}
 		pos = (*VP8BitReader)(unsafe.Pointer(v2)).Fbits
 		split = range1 * libc.Uint32FromInt32(int32(156)) >> int32(8)
 		value = uint32((*VP8BitReader)(unsafe.Pointer(v2)).Fvalue >> pos)
 		bit = libc.BoolInt32(value > split)
 		if bit != 0 {
 			range1 = range1 - split
 			**(**bit_t)(__ccgo_up(v2)) -= uint64(split+libc.Uint32FromInt32(1)) << pos
 		} else {
 			range1 = split + uint32(1)
 		}
 		v6 = int32(31) ^ libc.X__builtin_clz(tls, range1)
 		goto _48
 	_48:
 		shift = int32(7) ^ v6
 		range1 = range1 << libc.Uint32FromInt32(shift)
 		**(**int32)(__ccgo_up(v2 + 12)) -= shift
 		(*VP8BitReader)(unsafe.Pointer(v2)).Frange1 = range1 - uint32(1)
 		v8 = bit
 		goto _50
 	_50:
 		if v8 != 0 {
 			v10 = br2
 			range1 = (*VP8BitReader)(unsafe.Pointer(v10)).Frange1
 			if (*VP8BitReader)(unsafe.Pointer(v10)).Fbits < libc.Int32FromInt32(0) {
 				v11 = v10
 				if (*VP8BitReader)(unsafe.Pointer(v11)).Fbuf < (*VP8BitReader)(unsafe.Pointer(v11)).Fbuf_max {
 					libc.X__builtin___memcpy_chk(tls, bp, (*VP8BitReader)(unsafe.Pointer(v11)).Fbuf, uint64(8), ^__predefined_size_t(0))
 					**(**uintptr)(__ccgo_up(v11 + 16)) += uintptr(libc.Int32FromInt32(BITS) >> libc.Int32FromInt32(3))
 					v12 = uint64(libc.X__builtin_bswap64(tls, uint64(**(**lbit_t)(__ccgo_up(bp)))))
 					goto _55
 				_55:
 					bits = v12
 					bits = bits >> libc.Uint64FromInt32(libc.Int32FromInt32(64)-libc.Int32FromInt32(BITS))
 					(*VP8BitReader)(unsafe.Pointer(v11)).Fvalue = bits | (*VP8BitReader)(unsafe.Pointer(v11)).Fvalue<<libc.Int32FromInt32(BITS)
 					**(**int32)(__ccgo_up(v11 + 12)) += int32(BITS)
 				} else {
 					VP8LoadFinalBytes(tls, v11)
 				}
 			}
 			pos = (*VP8BitReader)(unsafe.Pointer(v10)).Fbits
 			split = range1 * libc.Uint32FromInt32(int32(128)) >> int32(8)
 			value = uint32((*VP8BitReader)(unsafe.Pointer(v10)).Fvalue >> pos)
 			bit = libc.BoolInt32(value > split)
 			if bit != 0 {
 				range1 = range1 - split
 				**(**bit_t)(__ccgo_up(v10)) -= uint64(split+libc.Uint32FromInt32(1)) << pos
 			} else {
 				range1 = split + uint32(1)
 			}
 			v16 = int32(31) ^ libc.X__builtin_clz(tls, range1)
 			goto _57
 		_57:
 			shift = int32(7) ^ v16
 			range1 = range1 << libc.Uint32FromInt32(shift)
 			**(**int32)(__ccgo_up(v10 + 12)) -= shift
 			(*VP8BitReader)(unsafe.Pointer(v10)).Frange1 = range1 - uint32(1)
 			v22 = bit
 			goto _59
 		_59:
 			if v22 != 0 {
 				v14 = int32(TM_PRED)
 			} else {
 				v14 = int32(H_PRED)
 			}
 			v1 = v14
 		} else {
 			v18 = br2
 			range1 = (*VP8BitReader)(unsafe.Pointer(v18)).Frange1
 			if (*VP8BitReader)(unsafe.Pointer(v18)).Fbits < libc.Int32FromInt32(0) {
 				v19 = v18
 				if (*VP8BitReader)(unsafe.Pointer(v19)).Fbuf < (*VP8BitReader)(unsafe.Pointer(v19)).Fbuf_max {
 					libc.X__builtin___memcpy_chk(tls, bp, (*VP8BitReader)(unsafe.Pointer(v19)).Fbuf, uint64(8), ^__predefined_size_t(0))
 					**(**uintptr)(__ccgo_up(v19 + 16)) += uintptr(libc.Int32FromInt32(BITS) >> libc.Int32FromInt32(3))
 					v20 = uint64(libc.X__builtin_bswap64(tls, uint64(**(**lbit_t)(__ccgo_up(bp)))))
 					goto _64
 				_64:
 					bits = v20
 					bits = bits >> libc.Uint64FromInt32(libc.Int32FromInt32(64)-libc.Int32FromInt32(BITS))
 					(*VP8BitReader)(unsafe.Pointer(v19)).Fvalue = bits | (*VP8BitReader)(unsafe.Pointer(v19)).Fvalue<<libc.Int32FromInt32(BITS)
 					**(**int32)(__ccgo_up(v19 + 12)) += int32(BITS)
 				} else {
 					VP8LoadFinalBytes(tls, v19)
 				}
 			}
 			pos = (*VP8BitReader)(unsafe.Pointer(v18)).Fbits
 			split = range1 * libc.Uint32FromInt32(int32(163)) >> int32(8)
 			value = uint32((*VP8BitReader)(unsafe.Pointer(v18)).Fvalue >> pos)
 			bit = libc.BoolInt32(value > split)
 			if bit != 0 {
 				range1 = range1 - split
 				**(**bit_t)(__ccgo_up(v18)) -= uint64(split+libc.Uint32FromInt32(1)) << pos
 			} else {
 				range1 = split + uint32(1)
 			}
 			v30 = int32(31) ^ libc.X__builtin_clz(tls, range1)
 			goto _66
 		_66:
 			shift = int32(7) ^ v30
 			range1 = range1 << libc.Uint32FromInt32(shift)
 			**(**int32)(__ccgo_up(v18 + 12)) -= shift
 			(*VP8BitReader)(unsafe.Pointer(v18)).Frange1 = range1 - uint32(1)
 			v32 = bit
 			goto _68
 		_68:
 			if v32 != 0 {
 				v24 = int32(V_PRED)
 			} else {
 				v24 = int32(DC_PRED)
 			}
 			v1 = v24
 		}
 		// Hardcoded 16x16 intra-mode decision tree.
 		ymode = v1
 		**(**uint8_t)(__ccgo_up(block + 769)) = libc.Uint8FromInt32(ymode)
 		libc.X__builtin___memset_chk(tls, top, ymode, libc.Uint64FromInt32(4)*libc.Uint64FromInt64(1), ^__predefined_size_t(0))
 		libc.X__builtin___memset_chk(tls, left, ymode, libc.Uint64FromInt32(4)*libc.Uint64FromInt64(1), ^__predefined_size_t(0))
 	} else {
 		modes = block + 769
 		y = 0
 		for {
 			if !(y < int32(4)) {
 				break
 			}
 			ymode1 = libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(left + uintptr(y))))
 			x1 = 0
 			for {
 				if !(x1 < int32(4)) {
 					break
 				}
 				prob1 = uintptr(unsafe.Pointer(&kBModesProba)) + uintptr(**(**uint8_t)(__ccgo_up(top + uintptr(x1))))*90 + uintptr(ymode1)*9
 				v2 = br2
 				range1 = (*VP8BitReader)(unsafe.Pointer(v2)).Frange1
 				if (*VP8BitReader)(unsafe.Pointer(v2)).Fbits < libc.Int32FromInt32(0) {
 					v3 = v2
 					if (*VP8BitReader)(unsafe.Pointer(v3)).Fbuf < (*VP8BitReader)(unsafe.Pointer(v3)).Fbuf_max {
 						libc.X__builtin___memcpy_chk(tls, bp, (*VP8BitReader)(unsafe.Pointer(v3)).Fbuf, uint64(8), ^__predefined_size_t(0))
 						**(**uintptr)(__ccgo_up(v3 + 16)) += uintptr(libc.Int32FromInt32(BITS) >> libc.Int32FromInt32(3))
 						v4 = uint64(libc.X__builtin_bswap64(tls, uint64(**(**lbit_t)(__ccgo_up(bp)))))
 						goto _74
 					_74:
 						bits = v4
 						bits = bits >> libc.Uint64FromInt32(libc.Int32FromInt32(64)-libc.Int32FromInt32(BITS))
 						(*VP8BitReader)(unsafe.Pointer(v3)).Fvalue = bits | (*VP8BitReader)(unsafe.Pointer(v3)).Fvalue<<libc.Int32FromInt32(BITS)
 						**(**int32)(__ccgo_up(v3 + 12)) += int32(BITS)
 					} else {
 						VP8LoadFinalBytes(tls, v3)
 					}
 				}
 				pos = (*VP8BitReader)(unsafe.Pointer(v2)).Fbits
 				split = range1 * libc.Uint32FromInt32(libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(prob1)))) >> int32(8)
 				value = uint32((*VP8BitReader)(unsafe.Pointer(v2)).Fvalue >> pos)
 				bit = libc.BoolInt32(value > split)
 				if bit != 0 {
 					range1 = range1 - split
 					**(**bit_t)(__ccgo_up(v2)) -= uint64(split+libc.Uint32FromInt32(1)) << pos
 				} else {
 					range1 = split + uint32(1)
 				}
 				v1 = int32(31) ^ libc.X__builtin_clz(tls, range1)
 				goto _76
 			_76:
 				shift = int32(7) ^ v1
 				range1 = range1 << libc.Uint32FromInt32(shift)
 				**(**int32)(__ccgo_up(v2 + 12)) -= shift
 				(*VP8BitReader)(unsafe.Pointer(v2)).Frange1 = range1 - uint32(1)
 				v6 = bit
 				goto _78
 			_78:
 				// Generic tree-parsing
 				i = int32(kYModesIntra4[v6])
 				for i > 0 {
 					v10 = br2
 					range1 = (*VP8BitReader)(unsafe.Pointer(v10)).Frange1
 					if (*VP8BitReader)(unsafe.Pointer(v10)).Fbits < libc.Int32FromInt32(0) {
 						v11 = v10
 						if (*VP8BitReader)(unsafe.Pointer(v11)).Fbuf < (*VP8BitReader)(unsafe.Pointer(v11)).Fbuf_max {
 							libc.X__builtin___memcpy_chk(tls, bp, (*VP8BitReader)(unsafe.Pointer(v11)).Fbuf, uint64(8), ^__predefined_size_t(0))
 							**(**uintptr)(__ccgo_up(v11 + 16)) += uintptr(libc.Int32FromInt32(BITS) >> libc.Int32FromInt32(3))
 							v12 = uint64(libc.X__builtin_bswap64(tls, uint64(**(**lbit_t)(__ccgo_up(bp)))))
 							goto _82
 						_82:
 							bits = v12
 							bits = bits >> libc.Uint64FromInt32(libc.Int32FromInt32(64)-libc.Int32FromInt32(BITS))
 							(*VP8BitReader)(unsafe.Pointer(v11)).Fvalue = bits | (*VP8BitReader)(unsafe.Pointer(v11)).Fvalue<<libc.Int32FromInt32(BITS)
 							**(**int32)(__ccgo_up(v11 + 12)) += int32(BITS)
 						} else {
 							VP8LoadFinalBytes(tls, v11)
 						}
 					}
 					pos = (*VP8BitReader)(unsafe.Pointer(v10)).Fbits
 					split = range1 * libc.Uint32FromInt32(libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(prob1 + uintptr(i))))) >> int32(8)
 					value = uint32((*VP8BitReader)(unsafe.Pointer(v10)).Fvalue >> pos)
 					bit = libc.BoolInt32(value > split)
 					if bit != 0 {
 						range1 = range1 - split
 						**(**bit_t)(__ccgo_up(v10)) -= uint64(split+libc.Uint32FromInt32(1)) << pos
 					} else {
 						range1 = split + uint32(1)
 					}
 					v8 = int32(31) ^ libc.X__builtin_clz(tls, range1)
 					goto _84
 				_84:
 					shift = int32(7) ^ v8
 					range1 = range1 << libc.Uint32FromInt32(shift)
 					**(**int32)(__ccgo_up(v10 + 12)) -= shift
 					(*VP8BitReader)(unsafe.Pointer(v10)).Frange1 = range1 - uint32(1)
 					v14 = bit
 					goto _86
 				_86:
 					i = int32(kYModesIntra4[int32(2)*i+v14])
 				}
 				ymode1 = -i
 				**(**uint8_t)(__ccgo_up(top + uintptr(x1))) = libc.Uint8FromInt32(ymode1)
 				goto _70
 			_70:
 				;
 				x1 = x1 + 1
 			}
 			libc.X__builtin___memcpy_chk(tls, modes, top, libc.Uint64FromInt32(4)*libc.Uint64FromInt64(1), ^__predefined_size_t(0))
 			modes = modes + uintptr(4)
 			**(**uint8_t)(__ccgo_up(left + uintptr(y))) = libc.Uint8FromInt32(ymode1)
 			goto _69
 		_69:
 			;
 			y = y + 1
 		}
 	}
 	// Hardcoded UVMode decision tree
 	v2 = br2
 	range1 = (*VP8BitReader)(unsafe.Pointer(v2)).Frange1
 	if (*VP8BitReader)(unsafe.Pointer(v2)).Fbits < libc.Int32FromInt32(0) {
 		v3 = v2
 		if (*VP8BitReader)(unsafe.Pointer(v3)).Fbuf < (*VP8BitReader)(unsafe.Pointer(v3)).Fbuf_max {
 			libc.X__builtin___memcpy_chk(tls, bp, (*VP8BitReader)(unsafe.Pointer(v3)).Fbuf, uint64(8), ^__predefined_size_t(0))
 			**(**uintptr)(__ccgo_up(v3 + 16)) += uintptr(libc.Int32FromInt32(BITS) >> libc.Int32FromInt32(3))
 			v4 = uint64(libc.X__builtin_bswap64(tls, uint64(**(**lbit_t)(__ccgo_up(bp)))))
 			goto _91
 		_91:
 			bits = v4
 			bits = bits >> libc.Uint64FromInt32(libc.Int32FromInt32(64)-libc.Int32FromInt32(BITS))
 			(*VP8BitReader)(unsafe.Pointer(v3)).Fvalue = bits | (*VP8BitReader)(unsafe.Pointer(v3)).Fvalue<<libc.Int32FromInt32(BITS)
 			**(**int32)(__ccgo_up(v3 + 12)) += int32(BITS)
 		} else {
 			VP8LoadFinalBytes(tls, v3)
 		}
 	}
 	pos = (*VP8BitReader)(unsafe.Pointer(v2)).Fbits
 	split = range1 * libc.Uint32FromInt32(int32(142)) >> int32(8)
 	value = uint32((*VP8BitReader)(unsafe.Pointer(v2)).Fvalue >> pos)
 	bit = libc.BoolInt32(value > split)
 	if bit != 0 {
 		range1 = range1 - split
 		**(**bit_t)(__ccgo_up(v2)) -= uint64(split+libc.Uint32FromInt32(1)) << pos
 	} else {
 		range1 = split + uint32(1)
 	}
 	v6 = int32(31) ^ libc.X__builtin_clz(tls, range1)
 	goto _93
 _93:
 	shift = int32(7) ^ v6
 	range1 = range1 << libc.Uint32FromInt32(shift)
 	**(**int32)(__ccgo_up(v2 + 12)) -= shift
 	(*VP8BitReader)(unsafe.Pointer(v2)).Frange1 = range1 - uint32(1)
 	v8 = bit
 	goto _95
 _95:
 	if !(v8 != 0) {
 		v1 = int32(DC_PRED)
 	} else {
 		v10 = br2
 		range1 = (*VP8BitReader)(unsafe.Pointer(v10)).Frange1
 		if (*VP8BitReader)(unsafe.Pointer(v10)).Fbits < libc.Int32FromInt32(0) {
 			v11 = v10
 			if (*VP8BitReader)(unsafe.Pointer(v11)).Fbuf < (*VP8BitReader)(unsafe.Pointer(v11)).Fbuf_max {
 				libc.X__builtin___memcpy_chk(tls, bp, (*VP8BitReader)(unsafe.Pointer(v11)).Fbuf, uint64(8), ^__predefined_size_t(0))
 				**(**uintptr)(__ccgo_up(v11 + 16)) += uintptr(libc.Int32FromInt32(BITS) >> libc.Int32FromInt32(3))
 				v12 = uint64(libc.X__builtin_bswap64(tls, uint64(**(**lbit_t)(__ccgo_up(bp)))))
 				goto _100
 			_100:
 				bits = v12
 				bits = bits >> libc.Uint64FromInt32(libc.Int32FromInt32(64)-libc.Int32FromInt32(BITS))
 				(*VP8BitReader)(unsafe.Pointer(v11)).Fvalue = bits | (*VP8BitReader)(unsafe.Pointer(v11)).Fvalue<<libc.Int32FromInt32(BITS)
 				**(**int32)(__ccgo_up(v11 + 12)) += int32(BITS)
 			} else {
 				VP8LoadFinalBytes(tls, v11)
 			}
 		}
 		pos = (*VP8BitReader)(unsafe.Pointer(v10)).Fbits
 		split = range1 * libc.Uint32FromInt32(int32(114)) >> int32(8)
 		value = uint32((*VP8BitReader)(unsafe.Pointer(v10)).Fvalue >> pos)
 		bit = libc.BoolInt32(value > split)
 		if bit != 0 {
 			range1 = range1 - split
 			**(**bit_t)(__ccgo_up(v10)) -= uint64(split+libc.Uint32FromInt32(1)) << pos
 		} else {
 			range1 = split + uint32(1)
 		}
 		v16 = int32(31) ^ libc.X__builtin_clz(tls, range1)
 		goto _102
 	_102:
 		shift = int32(7) ^ v16
 		range1 = range1 << libc.Uint32FromInt32(shift)
 		**(**int32)(__ccgo_up(v10 + 12)) -= shift
 		(*VP8BitReader)(unsafe.Pointer(v10)).Frange1 = range1 - uint32(1)
 		v22 = bit
 		goto _104
 	_104:
 		if !(v22 != 0) {
 			v14 = int32(V_PRED)
 		} else {
 			v18 = br2
 			range1 = (*VP8BitReader)(unsafe.Pointer(v18)).Frange1
 			if (*VP8BitReader)(unsafe.Pointer(v18)).Fbits < libc.Int32FromInt32(0) {
 				v19 = v18
 				if (*VP8BitReader)(unsafe.Pointer(v19)).Fbuf < (*VP8BitReader)(unsafe.Pointer(v19)).Fbuf_max {
 					libc.X__builtin___memcpy_chk(tls, bp, (*VP8BitReader)(unsafe.Pointer(v19)).Fbuf, uint64(8), ^__predefined_size_t(0))
 					**(**uintptr)(__ccgo_up(v19 + 16)) += uintptr(libc.Int32FromInt32(BITS) >> libc.Int32FromInt32(3))
 					v20 = uint64(libc.X__builtin_bswap64(tls, uint64(**(**lbit_t)(__ccgo_up(bp)))))
 					goto _109
 				_109:
 					bits = v20
 					bits = bits >> libc.Uint64FromInt32(libc.Int32FromInt32(64)-libc.Int32FromInt32(BITS))
 					(*VP8BitReader)(unsafe.Pointer(v19)).Fvalue = bits | (*VP8BitReader)(unsafe.Pointer(v19)).Fvalue<<libc.Int32FromInt32(BITS)
 					**(**int32)(__ccgo_up(v19 + 12)) += int32(BITS)
 				} else {
 					VP8LoadFinalBytes(tls, v19)
 				}
 			}
 			pos = (*VP8BitReader)(unsafe.Pointer(v18)).Fbits
 			split = range1 * libc.Uint32FromInt32(int32(183)) >> int32(8)
 			value = uint32((*VP8BitReader)(unsafe.Pointer(v18)).Fvalue >> pos)
 			bit = libc.BoolInt32(value > split)
 			if bit != 0 {
 				range1 = range1 - split
 				**(**bit_t)(__ccgo_up(v18)) -= uint64(split+libc.Uint32FromInt32(1)) << pos
 			} else {
 				range1 = split + uint32(1)
 			}
 			v30 = int32(31) ^ libc.X__builtin_clz(tls, range1)
 			goto _111
 		_111:
 			shift = int32(7) ^ v30
 			range1 = range1 << libc.Uint32FromInt32(shift)
 			**(**int32)(__ccgo_up(v18 + 12)) -= shift
 			(*VP8BitReader)(unsafe.Pointer(v18)).Frange1 = range1 - uint32(1)
 			v32 = bit
 			goto _113
 		_113:
 			if v32 != 0 {
 				v24 = int32(TM_PRED)
 			} else {
 				v24 = int32(H_PRED)
 			}
 			v14 = v24
 		}
 		v1 = v14
 	}
 	(*VP8MBData)(unsafe.Pointer(block)).Fuvmode = libc.Uint8FromInt32(v1)
 }
 
 func VP8ParseIntraModeRow(tls *libc.TLS, br uintptr, dec uintptr) (r int32) {
 	var mb_x int32
 	_ = mb_x
 	mb_x = 0
 	for {
 		if !(mb_x < (*VP8Decoder)(unsafe.Pointer(dec)).Fmb_w) {
 			break
 		}
 		ParseIntraMode(tls, br, dec, mb_x)
 		goto _1
 	_1:
 		;
 		mb_x = mb_x + 1
 	}
 	return libc.BoolInt32(!((*VP8Decoder)(unsafe.Pointer(dec)).Fbr.Feof != 0))
 }
 
 //------------------------------------------------------------------------------
 // Paragraph 13
 
 var CoeffsUpdateProba = [4][8][3][11]uint8_t{
 	0: {
 		0: {
 			0: {
 				0:  uint8(255),
 				1:  uint8(255),
 				2:  uint8(255),
 				3:  uint8(255),
 				4:  uint8(255),
 				5:  uint8(255),
 				6:  uint8(255),
 				7:  uint8(255),
 				8:  uint8(255),
 				9:  uint8(255),
 				10: uint8(255),
 			},
 			1: {
 				0:  uint8(255),
 				1:  uint8(255),
 				2:  uint8(255),
 				3:  uint8(255),
 				4:  uint8(255),
 				5:  uint8(255),
 				6:  uint8(255),
 				7:  uint8(255),
 				8:  uint8(255),
 				9:  uint8(255),
 				10: uint8(255),
 			},
 			2: {
 				0:  uint8(255),
 				1:  uint8(255),
 				2:  uint8(255),
 				3:  uint8(255),
 				4:  uint8(255),
 				5:  uint8(255),
 				6:  uint8(255),
 				7:  uint8(255),
 				8:  uint8(255),
 				9:  uint8(255),
 				10: uint8(255),
 			},
 		},
 		1: {
 			0: {
 				0:  uint8(176),
 				1:  uint8(246),
 				2:  uint8(255),
 				3:  uint8(255),
 				4:  uint8(255),
 				5:  uint8(255),
 				6:  uint8(255),
 				7:  uint8(255),
 				8:  uint8(255),
 				9:  uint8(255),
 				10: uint8(255),
 			},
 			1: {
 				0:  uint8(223),
 				1:  uint8(241),
 				2:  uint8(252),
 				3:  uint8(255),
 				4:  uint8(255),
 				5:  uint8(255),
 				6:  uint8(255),
 				7:  uint8(255),
 				8:  uint8(255),
 				9:  uint8(255),
 				10: uint8(255),
 			},
 			2: {
 				0:  uint8(249),
 				1:  uint8(253),
 				2:  uint8(253),
 				3:  uint8(255),
 				4:  uint8(255),
 				5:  uint8(255),
 				6:  uint8(255),
 				7:  uint8(255),
 				8:  uint8(255),
 				9:  uint8(255),
 				10: uint8(255),
 			},
 		},
 		2: {
 			0: {
 				0:  uint8(255),
 				1:  uint8(244),
 				2:  uint8(252),
 				3:  uint8(255),
 				4:  uint8(255),
 				5:  uint8(255),
 				6:  uint8(255),
 				7:  uint8(255),
 				8:  uint8(255),
 				9:  uint8(255),
 				10: uint8(255),
 			},
 			1: {
 				0:  uint8(234),
 				1:  uint8(254),
 				2:  uint8(254),
 				3:  uint8(255),
 				4:  uint8(255),
 				5:  uint8(255),
 				6:  uint8(255),
 				7:  uint8(255),
 				8:  uint8(255),
 				9:  uint8(255),
 				10: uint8(255),
 			},
 			2: {
 				0:  uint8(253),
 				1:  uint8(255),
 				2:  uint8(255),
 				3:  uint8(255),
 				4:  uint8(255),
 				5:  uint8(255),
 				6:  uint8(255),
 				7:  uint8(255),
 				8:  uint8(255),
 				9:  uint8(255),
 				10: uint8(255),
 			},
 		},
 		3: {
 			0: {
 				0:  uint8(255),
 				1:  uint8(246),
 				2:  uint8(254),
 				3:  uint8(255),
 				4:  uint8(255),
 				5:  uint8(255),
 				6:  uint8(255),
 				7:  uint8(255),
 				8:  uint8(255),
 				9:  uint8(255),
 				10: uint8(255),
 			},
 			1: {
 				0:  uint8(239),
 				1:  uint8(253),
 				2:  uint8(254),
 				3:  uint8(255),
 				4:  uint8(255),
 				5:  uint8(255),
 				6:  uint8(255),
 				7:  uint8(255),
 				8:  uint8(255),
 				9:  uint8(255),
 				10: uint8(255),
 			},
 			2: {
 				0:  uint8(254),
 				1:  uint8(255),
 				2:  uint8(254),
 				3:  uint8(255),
 				4:  uint8(255),
 				5:  uint8(255),
 				6:  uint8(255),
 				7:  uint8(255),
 				8:  uint8(255),
 				9:  uint8(255),
 				10: uint8(255),
 			},
 		},
 		4: {
 			0: {
 				0:  uint8(255),
 				1:  uint8(248),
 				2:  uint8(254),
 				3:  uint8(255),
 				4:  uint8(255),
 				5:  uint8(255),
 				6:  uint8(255),
 				7:  uint8(255),
 				8:  uint8(255),
 				9:  uint8(255),
 				10: uint8(255),
 			},
 			1: {
 				0:  uint8(251),
 				1:  uint8(255),
 				2:  uint8(254),
 				3:  uint8(255),
 				4:  uint8(255),
 				5:  uint8(255),
 				6:  uint8(255),
 				7:  uint8(255),
 				8:  uint8(255),
 				9:  uint8(255),
 				10: uint8(255),
 			},
 			2: {
 				0:  uint8(255),
 				1:  uint8(255),
 				2:  uint8(255),
 				3:  uint8(255),
 				4:  uint8(255),
 				5:  uint8(255),
 				6:  uint8(255),
 				7:  uint8(255),
 				8:  uint8(255),
 				9:  uint8(255),
 				10: uint8(255),
 			},
 		},
 		5: {
 			0: {
 				0:  uint8(255),
 				1:  uint8(253),
 				2:  uint8(254),
 				3:  uint8(255),
 				4:  uint8(255),
 				5:  uint8(255),
 				6:  uint8(255),
 				7:  uint8(255),
 				8:  uint8(255),
 				9:  uint8(255),
 				10: uint8(255),
 			},
 			1: {
 				0:  uint8(251),
 				1:  uint8(254),
 				2:  uint8(254),
 				3:  uint8(255),
 				4:  uint8(255),
 				5:  uint8(255),
 				6:  uint8(255),
 				7:  uint8(255),
 				8:  uint8(255),
 				9:  uint8(255),
 				10: uint8(255),
 			},
 			2: {
 				0:  uint8(254),
 				1:  uint8(255),
 				2:  uint8(254),
 				3:  uint8(255),
 				4:  uint8(255),
 				5:  uint8(255),
 				6:  uint8(255),
 				7:  uint8(255),
 				8:  uint8(255),
 				9:  uint8(255),
 				10: uint8(255),
 			},
 		},
 		6: {
 			0: {
 				0:  uint8(255),
 				1:  uint8(254),
 				2:  uint8(253),
 				3:  uint8(255),
 				4:  uint8(254),
 				5:  uint8(255),
 				6:  uint8(255),
 				7:  uint8(255),
 				8:  uint8(255),
 				9:  uint8(255),
 				10: uint8(255),
 			},
 			1: {
 				0:  uint8(250),
 				1:  uint8(255),
 				2:  uint8(254),
 				3:  uint8(255),
 				4:  uint8(254),
 				5:  uint8(255),
 				6:  uint8(255),
 				7:  uint8(255),
 				8:  uint8(255),
 				9:  uint8(255),
 				10: uint8(255),
 			},
 			2: {
 				0:  uint8(254),
 				1:  uint8(255),
 				2:  uint8(255),
 				3:  uint8(255),
 				4:  uint8(255),
 				5:  uint8(255),
 				6:  uint8(255),
 				7:  uint8(255),
 				8:  uint8(255),
 				9:  uint8(255),
 				10: uint8(255),
 			},
 		},
 		7: {
 			0: {
 				0:  uint8(255),
 				1:  uint8(255),
 				2:  uint8(255),
 				3:  uint8(255),
 				4:  uint8(255),
 				5:  uint8(255),
 				6:  uint8(255),
 				7:  uint8(255),
 				8:  uint8(255),
 				9:  uint8(255),
 				10: uint8(255),
 			},
 			1: {
 				0:  uint8(255),
 				1:  uint8(255),
 				2:  uint8(255),
 				3:  uint8(255),
 				4:  uint8(255),
 				5:  uint8(255),
 				6:  uint8(255),
 				7:  uint8(255),
 				8:  uint8(255),
 				9:  uint8(255),
 				10: uint8(255),
 			},
 			2: {
 				0:  uint8(255),
 				1:  uint8(255),
 				2:  uint8(255),
 				3:  uint8(255),
 				4:  uint8(255),
 				5:  uint8(255),
 				6:  uint8(255),
 				7:  uint8(255),
 				8:  uint8(255),
 				9:  uint8(255),
 				10: uint8(255),
 			},
 		},
 	},
 	1: {
 		0: {
 			0: {
 				0:  uint8(217),
 				1:  uint8(255),
 				2:  uint8(255),
 				3:  uint8(255),
 				4:  uint8(255),
 				5:  uint8(255),
 				6:  uint8(255),
 				7:  uint8(255),
 				8:  uint8(255),
 				9:  uint8(255),
 				10: uint8(255),
 			},
 			1: {
 				0:  uint8(225),
 				1:  uint8(252),
 				2:  uint8(241),
 				3:  uint8(253),
 				4:  uint8(255),
 				5:  uint8(255),
 				6:  uint8(254),
 				7:  uint8(255),
 				8:  uint8(255),
 				9:  uint8(255),
 				10: uint8(255),
 			},
 			2: {
 				0:  uint8(234),
 				1:  uint8(250),
 				2:  uint8(241),
 				3:  uint8(250),
 				4:  uint8(253),
 				5:  uint8(255),
 				6:  uint8(253),
 				7:  uint8(254),
 				8:  uint8(255),
 				9:  uint8(255),
 				10: uint8(255),
 			},
 		},
 		1: {
 			0: {
 				0:  uint8(255),
 				1:  uint8(254),
 				2:  uint8(255),
 				3:  uint8(255),
 				4:  uint8(255),
 				5:  uint8(255),
 				6:  uint8(255),
 				7:  uint8(255),
 				8:  uint8(255),
 				9:  uint8(255),
 				10: uint8(255),
 			},
 			1: {
 				0:  uint8(223),
 				1:  uint8(254),
 				2:  uint8(254),
 				3:  uint8(255),
 				4:  uint8(255),
 				5:  uint8(255),
 				6:  uint8(255),
 				7:  uint8(255),
 				8:  uint8(255),
 				9:  uint8(255),
 				10: uint8(255),
 			},
 			2: {
 				0:  uint8(238),
 				1:  uint8(253),
 				2:  uint8(254),
 				3:  uint8(254),
 				4:  uint8(255),
 				5:  uint8(255),
 				6:  uint8(255),
 				7:  uint8(255),
 				8:  uint8(255),
 				9:  uint8(255),
 				10: uint8(255),
 			},
 		},
 		2: {
 			0: {
 				0:  uint8(255),
 				1:  uint8(248),
 				2:  uint8(254),
 				3:  uint8(255),
 				4:  uint8(255),
 				5:  uint8(255),
 				6:  uint8(255),
 				7:  uint8(255),
 				8:  uint8(255),
 				9:  uint8(255),
 				10: uint8(255),
 			},
 			1: {
 				0:  uint8(249),
 				1:  uint8(254),
 				2:  uint8(255),
 				3:  uint8(255),
 				4:  uint8(255),
 				5:  uint8(255),
 				6:  uint8(255),
 				7:  uint8(255),
 				8:  uint8(255),
 				9:  uint8(255),
 				10: uint8(255),
 			},
 			2: {
 				0:  uint8(255),
 				1:  uint8(255),
 				2:  uint8(255),
 				3:  uint8(255),
 				4:  uint8(255),
 				5:  uint8(255),
 				6:  uint8(255),
 				7:  uint8(255),
 				8:  uint8(255),
 				9:  uint8(255),
 				10: uint8(255),
 			},
 		},
 		3: {
 			0: {
 				0:  uint8(255),
 				1:  uint8(253),
 				2:  uint8(255),
 				3:  uint8(255),
 				4:  uint8(255),
 				5:  uint8(255),
 				6:  uint8(255),
 				7:  uint8(255),
 				8:  uint8(255),
 				9:  uint8(255),
 				10: uint8(255),
 			},
 			1: {
 				0:  uint8(247),
 				1:  uint8(254),
 				2:  uint8(255),
 				3:  uint8(255),
 				4:  uint8(255),
 				5:  uint8(255),
 				6:  uint8(255),
 				7:  uint8(255),
 				8:  uint8(255),
 				9:  uint8(255),
 				10: uint8(255),
 			},
 			2: {
 				0:  uint8(255),
 				1:  uint8(255),
 				2:  uint8(255),
 				3:  uint8(255),
 				4:  uint8(255),
 				5:  uint8(255),
 				6:  uint8(255),
 				7:  uint8(255),
 				8:  uint8(255),
 				9:  uint8(255),
 				10: uint8(255),
 			},
 		},
 		4: {
 			0: {
 				0:  uint8(255),
 				1:  uint8(253),
 				2:  uint8(254),
 				3:  uint8(255),
 				4:  uint8(255),
 				5:  uint8(255),
 				6:  uint8(255),
 				7:  uint8(255),
 				8:  uint8(255),
 				9:  uint8(255),
 				10: uint8(255),
 			},
 			1: {
 				0:  uint8(252),
 				1:  uint8(255),
 				2:  uint8(255),
 				3:  uint8(255),
 				4:  uint8(255),
 				5:  uint8(255),
 				6:  uint8(255),
 				7:  uint8(255),
 				8:  uint8(255),
 				9:  uint8(255),
 				10: uint8(255),
 			},
 			2: {
 				0:  uint8(255),
 				1:  uint8(255),
 				2:  uint8(255),
 				3:  uint8(255),
 				4:  uint8(255),
 				5:  uint8(255),
 				6:  uint8(255),
 				7:  uint8(255),
 				8:  uint8(255),
 				9:  uint8(255),
 				10: uint8(255),
 			},
 		},
 		5: {
 			0: {
 				0:  uint8(255),
 				1:  uint8(254),
 				2:  uint8(254),
 				3:  uint8(255),
 				4:  uint8(255),
 				5:  uint8(255),
 				6:  uint8(255),
 				7:  uint8(255),
 				8:  uint8(255),
 				9:  uint8(255),
 				10: uint8(255),
 			},
 			1: {
 				0:  uint8(253),
 				1:  uint8(255),
 				2:  uint8(255),
 				3:  uint8(255),
 				4:  uint8(255),
 				5:  uint8(255),
 				6:  uint8(255),
 				7:  uint8(255),
 				8:  uint8(255),
 				9:  uint8(255),
 				10: uint8(255),
 			},
 			2: {
 				0:  uint8(255),
 				1:  uint8(255),
 				2:  uint8(255),
 				3:  uint8(255),
 				4:  uint8(255),
 				5:  uint8(255),
 				6:  uint8(255),
 				7:  uint8(255),
 				8:  uint8(255),
 				9:  uint8(255),
 				10: uint8(255),
 			},
 		},
 		6: {
 			0: {
 				0:  uint8(255),
 				1:  uint8(254),
 				2:  uint8(253),
 				3:  uint8(255),
 				4:  uint8(255),
 				5:  uint8(255),
 				6:  uint8(255),
 				7:  uint8(255),
 				8:  uint8(255),
 				9:  uint8(255),
 				10: uint8(255),
 			},
 			1: {
 				0:  uint8(250),
 				1:  uint8(255),
 				2:  uint8(255),
 				3:  uint8(255),
 				4:  uint8(255),
 				5:  uint8(255),
 				6:  uint8(255),
 				7:  uint8(255),
 				8:  uint8(255),
 				9:  uint8(255),
 				10: uint8(255),
 			},
 			2: {
 				0:  uint8(254),
 				1:  uint8(255),
 				2:  uint8(255),
 				3:  uint8(255),
 				4:  uint8(255),
 				5:  uint8(255),
 				6:  uint8(255),
 				7:  uint8(255),
 				8:  uint8(255),
 				9:  uint8(255),
 				10: uint8(255),
 			},
 		},
 		7: {
 			0: {
 				0:  uint8(255),
 				1:  uint8(255),
 				2:  uint8(255),
 				3:  uint8(255),
 				4:  uint8(255),
 				5:  uint8(255),
 				6:  uint8(255),
 				7:  uint8(255),
 				8:  uint8(255),
 				9:  uint8(255),
 				10: uint8(255),
 			},
 			1: {
 				0:  uint8(255),
 				1:  uint8(255),
 				2:  uint8(255),
 				3:  uint8(255),
 				4:  uint8(255),
 				5:  uint8(255),
 				6:  uint8(255),
 				7:  uint8(255),
 				8:  uint8(255),
 				9:  uint8(255),
 				10: uint8(255),
 			},
 			2: {
 				0:  uint8(255),
 				1:  uint8(255),
 				2:  uint8(255),
 				3:  uint8(255),
 				4:  uint8(255),
 				5:  uint8(255),
 				6:  uint8(255),
 				7:  uint8(255),
 				8:  uint8(255),
 				9:  uint8(255),
 				10: uint8(255),
 			},
 		},
 	},
 	2: {
 		0: {
 			0: {
 				0:  uint8(186),
 				1:  uint8(251),
 				2:  uint8(250),
 				3:  uint8(255),
 				4:  uint8(255),
 				5:  uint8(255),
 				6:  uint8(255),
 				7:  uint8(255),
 				8:  uint8(255),
 				9:  uint8(255),
 				10: uint8(255),
 			},
 			1: {
 				0:  uint8(234),
 				1:  uint8(251),
 				2:  uint8(244),
 				3:  uint8(254),
 				4:  uint8(255),
 				5:  uint8(255),
 				6:  uint8(255),
 				7:  uint8(255),
 				8:  uint8(255),
 				9:  uint8(255),
 				10: uint8(255),
 			},
 			2: {
 				0:  uint8(251),
 				1:  uint8(251),
 				2:  uint8(243),
 				3:  uint8(253),
 				4:  uint8(254),
 				5:  uint8(255),
 				6:  uint8(254),
 				7:  uint8(255),
 				8:  uint8(255),
 				9:  uint8(255),
 				10: uint8(255),
 			},
 		},
 		1: {
 			0: {
 				0:  uint8(255),
 				1:  uint8(253),
 				2:  uint8(254),
 				3:  uint8(255),
 				4:  uint8(255),
 				5:  uint8(255),
 				6:  uint8(255),
 				7:  uint8(255),
 				8:  uint8(255),
 				9:  uint8(255),
 				10: uint8(255),
 			},
 			1: {
 				0:  uint8(236),
 				1:  uint8(253),
 				2:  uint8(254),
 				3:  uint8(255),
 				4:  uint8(255),
 				5:  uint8(255),
 				6:  uint8(255),
 				7:  uint8(255),
 				8:  uint8(255),
 				9:  uint8(255),
 				10: uint8(255),
 			},
 			2: {
 				0:  uint8(251),
 				1:  uint8(253),
 				2:  uint8(253),
 				3:  uint8(254),
 				4:  uint8(254),
 				5:  uint8(255),
 				6:  uint8(255),
 				7:  uint8(255),
 				8:  uint8(255),
 				9:  uint8(255),
 				10: uint8(255),
 			},
 		},
 		2: {
 			0: {
 				0:  uint8(255),
 				1:  uint8(254),
 				2:  uint8(254),
 				3:  uint8(255),
 				4:  uint8(255),
 				5:  uint8(255),
 				6:  uint8(255),
 				7:  uint8(255),
 				8:  uint8(255),
 				9:  uint8(255),
 				10: uint8(255),
 			},
 			1: {
 				0:  uint8(254),
 				1:  uint8(254),
 				2:  uint8(254),
 				3:  uint8(255),
 				4:  uint8(255),
 				5:  uint8(255),
 				6:  uint8(255),
 				7:  uint8(255),
 				8:  uint8(255),
 				9:  uint8(255),
 				10: uint8(255),
 			},
 			2: {
 				0:  uint8(255),
 				1:  uint8(255),
 				2:  uint8(255),
 				3:  uint8(255),
 				4:  uint8(255),
 				5:  uint8(255),
 				6:  uint8(255),
 				7:  uint8(255),
 				8:  uint8(255),
 				9:  uint8(255),
 				10: uint8(255),
 			},
 		},
 		3: {
 			0: {
 				0:  uint8(255),
 				1:  uint8(254),
 				2:  uint8(255),
 				3:  uint8(255),
 				4:  uint8(255),
 				5:  uint8(255),
 				6:  uint8(255),
 				7:  uint8(255),
 				8:  uint8(255),
 				9:  uint8(255),
 				10: uint8(255),
 			},
 			1: {
 				0:  uint8(254),
 				1:  uint8(254),
 				2:  uint8(255),
 				3:  uint8(255),
 				4:  uint8(255),
 				5:  uint8(255),
 				6:  uint8(255),
 				7:  uint8(255),
 				8:  uint8(255),
 				9:  uint8(255),
 				10: uint8(255),
 			},
 			2: {
 				0:  uint8(254),
 				1:  uint8(255),
 				2:  uint8(255),
 				3:  uint8(255),
 				4:  uint8(255),
 				5:  uint8(255),
 				6:  uint8(255),
 				7:  uint8(255),
 				8:  uint8(255),
 				9:  uint8(255),
 				10: uint8(255),
 			},
 		},
 		4: {
 			0: {
 				0:  uint8(255),
 				1:  uint8(255),
 				2:  uint8(255),
 				3:  uint8(255),
 				4:  uint8(255),
 				5:  uint8(255),
 				6:  uint8(255),
 				7:  uint8(255),
 				8:  uint8(255),
 				9:  uint8(255),
 				10: uint8(255),
 			},
 			1: {
 				0:  uint8(254),
 				1:  uint8(255),
 				2:  uint8(255),
 				3:  uint8(255),
 				4:  uint8(255),
 				5:  uint8(255),
 				6:  uint8(255),
 				7:  uint8(255),
 				8:  uint8(255),
 				9:  uint8(255),
 				10: uint8(255),
 			},
 			2: {
 				0:  uint8(255),
 				1:  uint8(255),
 				2:  uint8(255),
 				3:  uint8(255),
 				4:  uint8(255),
 				5:  uint8(255),
 				6:  uint8(255),
 				7:  uint8(255),
 				8:  uint8(255),
 				9:  uint8(255),
 				10: uint8(255),
 			},
 		},
 		5: {
 			0: {
 				0:  uint8(255),
 				1:  uint8(255),
 				2:  uint8(255),
 				3:  uint8(255),
 				4:  uint8(255),
 				5:  uint8(255),
 				6:  uint8(255),
 				7:  uint8(255),
 				8:  uint8(255),
 				9:  uint8(255),
 				10: uint8(255),
 			},
 			1: {
 				0:  uint8(255),
 				1:  uint8(255),
 				2:  uint8(255),
 				3:  uint8(255),
 				4:  uint8(255),
 				5:  uint8(255),
 				6:  uint8(255),
 				7:  uint8(255),
 				8:  uint8(255),
 				9:  uint8(255),
 				10: uint8(255),
 			},
 			2: {
 				0:  uint8(255),
 				1:  uint8(255),
 				2:  uint8(255),
 				3:  uint8(255),
 				4:  uint8(255),
 				5:  uint8(255),
 				6:  uint8(255),
 				7:  uint8(255),
 				8:  uint8(255),
 				9:  uint8(255),
 				10: uint8(255),
 			},
 		},
 		6: {
 			0: {
 				0:  uint8(255),
 				1:  uint8(255),
 				2:  uint8(255),
 				3:  uint8(255),
 				4:  uint8(255),
 				5:  uint8(255),
 				6:  uint8(255),
 				7:  uint8(255),
 				8:  uint8(255),
 				9:  uint8(255),
 				10: uint8(255),
 			},
 			1: {
 				0:  uint8(255),
 				1:  uint8(255),
 				2:  uint8(255),
 				3:  uint8(255),
 				4:  uint8(255),
 				5:  uint8(255),
 				6:  uint8(255),
 				7:  uint8(255),
 				8:  uint8(255),
 				9:  uint8(255),
 				10: uint8(255),
 			},
 			2: {
 				0:  uint8(255),
 				1:  uint8(255),
 				2:  uint8(255),
 				3:  uint8(255),
 				4:  uint8(255),
 				5:  uint8(255),
 				6:  uint8(255),
 				7:  uint8(255),
 				8:  uint8(255),
 				9:  uint8(255),
 				10: uint8(255),
 			},
 		},
 		7: {
 			0: {
 				0:  uint8(255),
 				1:  uint8(255),
 				2:  uint8(255),
 				3:  uint8(255),
 				4:  uint8(255),
 				5:  uint8(255),
 				6:  uint8(255),
 				7:  uint8(255),
 				8:  uint8(255),
 				9:  uint8(255),
 				10: uint8(255),
 			},
 			1: {
 				0:  uint8(255),
 				1:  uint8(255),
 				2:  uint8(255),
 				3:  uint8(255),
 				4:  uint8(255),
 				5:  uint8(255),
 				6:  uint8(255),
 				7:  uint8(255),
 				8:  uint8(255),
 				9:  uint8(255),
 				10: uint8(255),
 			},
 			2: {
 				0:  uint8(255),
 				1:  uint8(255),
 				2:  uint8(255),
 				3:  uint8(255),
 				4:  uint8(255),
 				5:  uint8(255),
 				6:  uint8(255),
 				7:  uint8(255),
 				8:  uint8(255),
 				9:  uint8(255),
 				10: uint8(255),
 			},
 		},
 	},
 	3: {
 		0: {
 			0: {
 				0:  uint8(248),
 				1:  uint8(255),
 				2:  uint8(255),
 				3:  uint8(255),
 				4:  uint8(255),
 				5:  uint8(255),
 				6:  uint8(255),
 				7:  uint8(255),
 				8:  uint8(255),
 				9:  uint8(255),
 				10: uint8(255),
 			},
 			1: {
 				0:  uint8(250),
 				1:  uint8(254),
 				2:  uint8(252),
 				3:  uint8(254),
 				4:  uint8(255),
 				5:  uint8(255),
 				6:  uint8(255),
 				7:  uint8(255),
 				8:  uint8(255),
 				9:  uint8(255),
 				10: uint8(255),
 			},
 			2: {
 				0:  uint8(248),
 				1:  uint8(254),
 				2:  uint8(249),
 				3:  uint8(253),
 				4:  uint8(255),
 				5:  uint8(255),
 				6:  uint8(255),
 				7:  uint8(255),
 				8:  uint8(255),
 				9:  uint8(255),
 				10: uint8(255),
 			},
 		},
 		1: {
 			0: {
 				0:  uint8(255),
 				1:  uint8(253),
 				2:  uint8(253),
 				3:  uint8(255),
 				4:  uint8(255),
 				5:  uint8(255),
 				6:  uint8(255),
 				7:  uint8(255),
 				8:  uint8(255),
 				9:  uint8(255),
 				10: uint8(255),
 			},
 			1: {
 				0:  uint8(246),
 				1:  uint8(253),
 				2:  uint8(253),
 				3:  uint8(255),
 				4:  uint8(255),
 				5:  uint8(255),
 				6:  uint8(255),
 				7:  uint8(255),
 				8:  uint8(255),
 				9:  uint8(255),
 				10: uint8(255),
 			},
 			2: {
 				0:  uint8(252),
 				1:  uint8(254),
 				2:  uint8(251),
 				3:  uint8(254),
 				4:  uint8(254),
 				5:  uint8(255),
 				6:  uint8(255),
 				7:  uint8(255),
 				8:  uint8(255),
 				9:  uint8(255),
 				10: uint8(255),
 			},
 		},
 		2: {
 			0: {
 				0:  uint8(255),
 				1:  uint8(254),
 				2:  uint8(252),
 				3:  uint8(255),
 				4:  uint8(255),
 				5:  uint8(255),
 				6:  uint8(255),
 				7:  uint8(255),
 				8:  uint8(255),
 				9:  uint8(255),
 				10: uint8(255),
 			},
 			1: {
 				0:  uint8(248),
 				1:  uint8(254),
 				2:  uint8(253),
 				3:  uint8(255),
 				4:  uint8(255),
 				5:  uint8(255),
 				6:  uint8(255),
 				7:  uint8(255),
 				8:  uint8(255),
 				9:  uint8(255),
 				10: uint8(255),
 			},
 			2: {
 				0:  uint8(253),
 				1:  uint8(255),
 				2:  uint8(254),
 				3:  uint8(254),
 				4:  uint8(255),
 				5:  uint8(255),
 				6:  uint8(255),
 				7:  uint8(255),
 				8:  uint8(255),
 				9:  uint8(255),
 				10: uint8(255),
 			},
 		},
 		3: {
 			0: {
 				0:  uint8(255),
 				1:  uint8(251),
 				2:  uint8(254),
 				3:  uint8(255),
 				4:  uint8(255),
 				5:  uint8(255),
 				6:  uint8(255),
 				7:  uint8(255),
 				8:  uint8(255),
 				9:  uint8(255),
 				10: uint8(255),
 			},
 			1: {
 				0:  uint8(245),
 				1:  uint8(251),
 				2:  uint8(254),
 				3:  uint8(255),
 				4:  uint8(255),
 				5:  uint8(255),
 				6:  uint8(255),
 				7:  uint8(255),
 				8:  uint8(255),
 				9:  uint8(255),
 				10: uint8(255),
 			},
 			2: {
 				0:  uint8(253),
 				1:  uint8(253),
 				2:  uint8(254),
 				3:  uint8(255),
 				4:  uint8(255),
 				5:  uint8(255),
 				6:  uint8(255),
 				7:  uint8(255),
 				8:  uint8(255),
 				9:  uint8(255),
 				10: uint8(255),
 			},
 		},
 		4: {
 			0: {
 				0:  uint8(255),
 				1:  uint8(251),
 				2:  uint8(253),
 				3:  uint8(255),
 				4:  uint8(255),
 				5:  uint8(255),
 				6:  uint8(255),
 				7:  uint8(255),
 				8:  uint8(255),
 				9:  uint8(255),
 				10: uint8(255),
 			},
 			1: {
 				0:  uint8(252),
 				1:  uint8(253),
 				2:  uint8(254),
 				3:  uint8(255),
 				4:  uint8(255),
 				5:  uint8(255),
 				6:  uint8(255),
 				7:  uint8(255),
 				8:  uint8(255),
 				9:  uint8(255),
 				10: uint8(255),
 			},
 			2: {
 				0:  uint8(255),
 				1:  uint8(254),
 				2:  uint8(255),
 				3:  uint8(255),
 				4:  uint8(255),
 				5:  uint8(255),
 				6:  uint8(255),
 				7:  uint8(255),
 				8:  uint8(255),
 				9:  uint8(255),
 				10: uint8(255),
 			},
 		},
 		5: {
 			0: {
 				0:  uint8(255),
 				1:  uint8(252),
 				2:  uint8(255),
 				3:  uint8(255),
 				4:  uint8(255),
 				5:  uint8(255),
 				6:  uint8(255),
 				7:  uint8(255),
 				8:  uint8(255),
 				9:  uint8(255),
 				10: uint8(255),
 			},
 			1: {
 				0:  uint8(249),
 				1:  uint8(255),
 				2:  uint8(254),
 				3:  uint8(255),
 				4:  uint8(255),
 				5:  uint8(255),
 				6:  uint8(255),
 				7:  uint8(255),
 				8:  uint8(255),
 				9:  uint8(255),
 				10: uint8(255),
 			},
 			2: {
 				0:  uint8(255),
 				1:  uint8(255),
 				2:  uint8(254),
 				3:  uint8(255),
 				4:  uint8(255),
 				5:  uint8(255),
 				6:  uint8(255),
 				7:  uint8(255),
 				8:  uint8(255),
 				9:  uint8(255),
 				10: uint8(255),
 			},
 		},
 		6: {
 			0: {
 				0:  uint8(255),
 				1:  uint8(255),
 				2:  uint8(253),
 				3:  uint8(255),
 				4:  uint8(255),
 				5:  uint8(255),
 				6:  uint8(255),
 				7:  uint8(255),
 				8:  uint8(255),
 				9:  uint8(255),
 				10: uint8(255),
 			},
 			1: {
 				0:  uint8(250),
 				1:  uint8(255),
 				2:  uint8(255),
 				3:  uint8(255),
 				4:  uint8(255),
 				5:  uint8(255),
 				6:  uint8(255),
 				7:  uint8(255),
 				8:  uint8(255),
 				9:  uint8(255),
 				10: uint8(255),
 			},
 			2: {
 				0:  uint8(255),
 				1:  uint8(255),
 				2:  uint8(255),
 				3:  uint8(255),
 				4:  uint8(255),
 				5:  uint8(255),
 				6:  uint8(255),
 				7:  uint8(255),
 				8:  uint8(255),
 				9:  uint8(255),
 				10: uint8(255),
 			},
 		},
 		7: {
 			0: {
 				0:  uint8(255),
 				1:  uint8(255),
 				2:  uint8(255),
 				3:  uint8(255),
 				4:  uint8(255),
 				5:  uint8(255),
 				6:  uint8(255),
 				7:  uint8(255),
 				8:  uint8(255),
 				9:  uint8(255),
 				10: uint8(255),
 			},
 			1: {
 				0:  uint8(254),
 				1:  uint8(255),
 				2:  uint8(255),
 				3:  uint8(255),
 				4:  uint8(255),
 				5:  uint8(255),
 				6:  uint8(255),
 				7:  uint8(255),
 				8:  uint8(255),
 				9:  uint8(255),
 				10: uint8(255),
 			},
 			2: {
 				0:  uint8(255),
 				1:  uint8(255),
 				2:  uint8(255),
 				3:  uint8(255),
 				4:  uint8(255),
 				5:  uint8(255),
 				6:  uint8(255),
 				7:  uint8(255),
 				8:  uint8(255),
 				9:  uint8(255),
 				10: uint8(255),
 			},
 		},
 	},
 }
 
 // Paragraph 9.9
 
 var kBands = [17]uint8_t{
 	1:  uint8(1),
 	2:  uint8(2),
 	3:  uint8(3),
 	4:  uint8(6),
 	5:  uint8(4),
 	6:  uint8(5),
 	7:  uint8(6),
 	8:  uint8(6),
 	9:  uint8(6),
 	10: uint8(6),
 	11: uint8(6),
 	12: uint8(6),
 	13: uint8(6),
 	14: uint8(6),
 	15: uint8(7),
 }
 
 func VP8ParseProba(tls *libc.TLS, br2 uintptr, dec uintptr) {
 	bp := tls.Alloc(16)
 	defer tls.Free(16)
 	var b, bit, c, p, pos, shift, t, v, v10, v12 int32
 	var bits bit_t
 	var proba, v6, v7 uintptr
 	var range1, split, value range_t
 	var v5 uint32
 	var v8 uint64_t
 	var _ /* in_bits at bp+0 */ lbit_t
 	_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = b, bit, bits, c, p, pos, proba, range1, shift, split, t, v, value, v10, v12, v5, v6, v7, v8
 	proba = dec + 1192
 	t = 0
 	for {
 		if !(t < int32(NUM_TYPES)) {
 			break
 		}
 		b = 0
 		for {
 			if !(b < int32(NUM_BANDS)) {
 				break
 			}
 			c = 0
 			for {
 				if !(c < int32(NUM_CTX)) {
 					break
 				}
 				p = 0
 				for {
 					if !(p < int32(NUM_PROBAS)) {
 						break
 					}
 					v6 = br2
 					range1 = (*VP8BitReader)(unsafe.Pointer(v6)).Frange1
 					if (*VP8BitReader)(unsafe.Pointer(v6)).Fbits < libc.Int32FromInt32(0) {
 						v7 = v6
 						if (*VP8BitReader)(unsafe.Pointer(v7)).Fbuf < (*VP8BitReader)(unsafe.Pointer(v7)).Fbuf_max {
 							libc.X__builtin___memcpy_chk(tls, bp, (*VP8BitReader)(unsafe.Pointer(v7)).Fbuf, uint64(8), ^__predefined_size_t(0))
 							**(**uintptr)(__ccgo_up(v7 + 16)) += uintptr(libc.Int32FromInt32(BITS) >> libc.Int32FromInt32(3))
 							v8 = uint64(libc.X__builtin_bswap64(tls, uint64(**(**lbit_t)(__ccgo_up(bp)))))
 							goto _9
 						_9:
 							bits = v8
 							bits = bits >> libc.Uint64FromInt32(libc.Int32FromInt32(64)-libc.Int32FromInt32(BITS))
 							(*VP8BitReader)(unsafe.Pointer(v7)).Fvalue = bits | (*VP8BitReader)(unsafe.Pointer(v7)).Fvalue<<libc.Int32FromInt32(BITS)
 							**(**int32)(__ccgo_up(v7 + 12)) += int32(BITS)
 						} else {
 							VP8LoadFinalBytes(tls, v7)
 						}
 					}
 					pos = (*VP8BitReader)(unsafe.Pointer(v6)).Fbits
 					split = range1 * libc.Uint32FromInt32(libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(uintptr(unsafe.Pointer(&CoeffsUpdateProba)) + uintptr(t)*264 + uintptr(b)*33 + uintptr(c)*11 + uintptr(p))))) >> int32(8)
 					value = uint32((*VP8BitReader)(unsafe.Pointer(v6)).Fvalue >> pos)
 					bit = libc.BoolInt32(value > split)
 					if bit != 0 {
 						range1 = range1 - split
 						**(**bit_t)(__ccgo_up(v6)) -= uint64(split+libc.Uint32FromInt32(1)) << pos
 					} else {
 						range1 = split + uint32(1)
 					}
 					v10 = int32(31) ^ libc.X__builtin_clz(tls, range1)
 					goto _11
 				_11:
 					shift = int32(7) ^ v10
 					range1 = range1 << libc.Uint32FromInt32(shift)
 					**(**int32)(__ccgo_up(v6 + 12)) -= shift
 					(*VP8BitReader)(unsafe.Pointer(v6)).Frange1 = range1 - uint32(1)
 					v12 = bit
 					goto _13
 				_13:
 					if v12 != 0 {
 						v5 = VP8GetValue(tls, br2, int32(8))
 					} else {
 						v5 = uint32(**(**uint8_t)(__ccgo_up(uintptr(unsafe.Pointer(&CoeffsProba0)) + uintptr(t)*264 + uintptr(b)*33 + uintptr(c)*11 + uintptr(p))))
 					}
 					v = libc.Int32FromUint32(v5)
 					**(**uint8_t)(__ccgo_up(proba + 3 + uintptr(t)*264 + uintptr(b)*33 + uintptr(c)*11 + uintptr(p))) = libc.Uint8FromInt32(v)
 					goto _4
 				_4:
 					;
 					p = p + 1
 				}
 				goto _3
 			_3:
 				;
 				c = c + 1
 			}
 			goto _2
 		_2:
 			;
 			b = b + 1
 		}
 		b = 0
 		for {
 			if !(b < libc.Int32FromInt32(16)+libc.Int32FromInt32(1)) {
 				break
 			}
 			**(**uintptr)(__ccgo_up(proba + 1064 + uintptr(t)*136 + uintptr(b)*8)) = proba + 3 + uintptr(t)*264 + uintptr(kBands[b])*33
 			goto _14
 		_14:
 			;
 			b = b + 1
 		}
 		goto _1
 	_1:
 		;
 		t = t + 1
 	}
 	(*VP8Decoder)(unsafe.Pointer(dec)).Fuse_skip_proba = libc.Int32FromUint32(VP8GetValue(tls, br2, int32(1)))
 	if (*VP8Decoder)(unsafe.Pointer(dec)).Fuse_skip_proba != 0 {
 		(*VP8Decoder)(unsafe.Pointer(dec)).Fskip_p = uint8(VP8GetValue(tls, br2, int32(8)))
 	}
 }
 
 var kHashMul7 = uint32(0x1e35a7bd)
 
 // Copyright 2010 Google Inc. All Rights Reserved.
 //
 // Use of this source code is governed by a BSD-style license
 // that can be found in the COPYING file in the root of the source
 // tree. An additional intellectual property rights grant can be found
 // in the file PATENTS. All contributing project authors may
 // be found in the AUTHORS file in the root of the source tree.
 // -----------------------------------------------------------------------------
 //
 // Boolean decoder
 //
 // Author: Skal (pascal.massimino@gmail.com)
 //         Vikas Arora (vikaas.arora@gmail.com)
 
 // Copyright 2011 Google Inc. All Rights Reserved.
 //
 // Use of this source code is governed by a BSD-style license
 // that can be found in the COPYING file in the root of the source
 // tree. An additional intellectual property rights grant can be found
 // in the file PATENTS. All contributing project authors may
 // be found in the AUTHORS file in the root of the source tree.
 // -----------------------------------------------------------------------------
 //
 // Multi-threaded worker
 //
 // Author: Skal (pascal.massimino@gmail.com)
 
 // Copyright 2012 Google Inc. All Rights Reserved.
 //
 // Use of this source code is governed by a BSD-style license
 // that can be found in the COPYING file in the root of the source
 // tree. An additional intellectual property rights grant can be found
 // in the file PATENTS. All contributing project authors may
 // be found in the AUTHORS file in the root of the source tree.
 // -----------------------------------------------------------------------------
 //
 // Misc. common utility functions
 //
 // Authors: Skal (pascal.massimino@gmail.com)
 //          Urvang (urvang@google.com)
 
 // Copyright 2010 Google Inc. All Rights Reserved.
 //
 // Use of this source code is governed by a BSD-style license
 // that can be found in the COPYING file in the root of the source
 // tree. An additional intellectual property rights grant can be found
 // in the file PATENTS. All contributing project authors may
 // be found in the AUTHORS file in the root of the source tree.
 // -----------------------------------------------------------------------------
 //
 //  Main decoding functions for WebP images.
 //
 // Author: Skal (pascal.massimino@gmail.com)
 
 // Copyright 2012 Google Inc. All Rights Reserved.
 //
 // Use of this source code is governed by a BSD-style license
 // that can be found in the COPYING file in the root of the source
 // tree. An additional intellectual property rights grant can be found
 // in the file PATENTS. All contributing project authors may
 // be found in the AUTHORS file in the root of the source tree.
 // -----------------------------------------------------------------------------
 //
 //  Internal header for constants related to WebP file format.
 //
 // Author: Urvang (urvang@google.com)
 
 // Copyright 2010 Google Inc. All Rights Reserved.
 //
 // Use of this source code is governed by a BSD-style license
 // that can be found in the COPYING file in the root of the source
 // tree. An additional intellectual property rights grant can be found
 // in the file PATENTS. All contributing project authors may
 // be found in the AUTHORS file in the root of the source tree.
 // -----------------------------------------------------------------------------
 //
 //  Common types + memory wrappers
 //
 // Author: Skal (pascal.massimino@gmail.com)
 
 //------------------------------------------------------------------------------
 
 func WebPGetDecoderVersion(tls *libc.TLS) (r int32) {
 	return libc.Int32FromInt32(DEC_MAJ_VERSION)<<libc.Int32FromInt32(16) | libc.Int32FromInt32(DEC_MIN_VERSION)<<libc.Int32FromInt32(8) | libc.Int32FromInt32(DEC_REV_VERSION)
 }
 
 //------------------------------------------------------------------------------
 // Signature and pointer-to-function for GetCoeffs() variants below.
 
 type GetCoeffsFunc = uintptr
 
 var GetCoeffs = uintptr(0)
 
 func init() {
 	p := unsafe.Pointer(&GetCoeffs)
 	*(*uintptr)(unsafe.Add(p, 0)) = libc.UintptrFromInt32(0)
 }
 
 //------------------------------------------------------------------------------
 // VP8Decoder
 
 func SetOk(tls *libc.TLS, dec uintptr) {
 	(*VP8Decoder)(unsafe.Pointer(dec)).Fstatus = int32(VP8_STATUS_OK)
 	(*VP8Decoder)(unsafe.Pointer(dec)).Ferror_msg = __ccgo_ts + 154
 }
 
 func VP8InitIoInternal(tls *libc.TLS, io uintptr, version int32) (r int32) {
 	if version>>int32(8) != libc.Int32FromInt32(WEBP_DECODER_ABI_VERSION)>>libc.Int32FromInt32(8) {
 		return 0 // mismatch error
 	}
 	if io != libc.UintptrFromInt32(0) {
 		libc.X__builtin___memset_chk(tls, io, 0, uint64(160), ^__predefined_size_t(0))
 	}
 	return int32(1)
 }
 
 func VP8New(tls *libc.TLS) (r uintptr) {
 	var dec uintptr
 	_ = dec
 	dec = WebPSafeCalloc(tls, uint64(1), uint64(3024))
 	if dec != libc.UintptrFromInt32(0) {
 		SetOk(tls, dec)
 		(*(*func(*libc.TLS, uintptr))(unsafe.Pointer(&struct{ uintptr }{(*WebPWorkerInterface)(unsafe.Pointer(WebPGetWorkerInterface(tls))).FInit})))(tls, dec+152)
 		(*VP8Decoder)(unsafe.Pointer(dec)).Fready = 0
 		(*VP8Decoder)(unsafe.Pointer(dec)).Fnum_parts_minus_one = uint32(0)
 		InitGetCoeffs(tls)
 	}
 	return dec
 }
 
 func VP8Status(tls *libc.TLS, dec uintptr) (r VP8StatusCode1) {
 	if !(dec != 0) {
 		return int32(VP8_STATUS_INVALID_PARAM)
 	}
 	return (*VP8Decoder)(unsafe.Pointer(dec)).Fstatus
 }
 
 func VP8StatusMessage(tls *libc.TLS, dec uintptr) (r uintptr) {
 	if dec == libc.UintptrFromInt32(0) {
 		return __ccgo_ts + 157
 	}
 	if !((*VP8Decoder)(unsafe.Pointer(dec)).Ferror_msg != 0) {
 		return __ccgo_ts + 154
 	}
 	return (*VP8Decoder)(unsafe.Pointer(dec)).Ferror_msg
 }
 
 func VP8Delete(tls *libc.TLS, dec uintptr) {
 	if dec != libc.UintptrFromInt32(0) {
 		VP8Clear(tls, dec)
 		WebPSafeFree(tls, dec)
 	}
 }
 
 func VP8SetError(tls *libc.TLS, dec uintptr, error1 VP8StatusCode1, msg uintptr) (r int32) {
 	// VP8_STATUS_SUSPENDED is only meaningful in incremental decoding.
 	// The oldest error reported takes precedence over the new one.
 	if (*VP8Decoder)(unsafe.Pointer(dec)).Fstatus == int32(VP8_STATUS_OK) {
 		(*VP8Decoder)(unsafe.Pointer(dec)).Fstatus = error1
 		(*VP8Decoder)(unsafe.Pointer(dec)).Ferror_msg = msg
 		(*VP8Decoder)(unsafe.Pointer(dec)).Fready = 0
 	}
 	return 0
 }
 
 //------------------------------------------------------------------------------
 
 func VP8CheckSignature(tls *libc.TLS, data uintptr, data_size size_t) (r int32) {
 	return libc.BoolInt32(data_size >= uint64(3) && libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(data))) == int32(0x9d) && libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(data + 1))) == int32(0x01) && libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(data + 2))) == int32(0x2a))
 }
 
 func VP8GetInfo(tls *libc.TLS, data uintptr, data_size size_t, chunk_size size_t, width uintptr, height uintptr) (r int32) {
 	var bits uint32_t
 	var h, key_frame, w int32
 	_, _, _, _ = bits, h, key_frame, w
 	if data == libc.UintptrFromInt32(0) || data_size < uint64(VP8_FRAME_HEADER_SIZE) {
 		return 0 // not enough data
 	}
 	// check signature
 	if !(VP8CheckSignature(tls, data+uintptr(3), data_size-uint64(3)) != 0) {
 		return 0 // Wrong signature.
 	} else {
 		bits = libc.Uint32FromInt32(libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(data))) | libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(data + 1)))<<int32(8) | libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(data + 2)))<<int32(16))
 		key_frame = libc.BoolInt32(!(bits&libc.Uint32FromInt32(1) != 0))
 		w = (libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(data + 7)))<<int32(8) | libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(data + 6)))) & int32(0x3fff)
 		h = (libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(data + 9)))<<int32(8) | libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(data + 8)))) & int32(0x3fff)
 		if !(key_frame != 0) { // Not a keyframe.
 			return 0
 		}
 		if bits>>libc.Int32FromInt32(1)&uint32(7) > uint32(3) {
 			return 0 // unknown profile
 		}
 		if !(bits>>libc.Int32FromInt32(4)&libc.Uint32FromInt32(1) != 0) {
 			return 0 // first frame is invisible!
 		}
 		if uint64(bits>>libc.Int32FromInt32(5)) >= chunk_size { // partition_length
 			return 0 // inconsistent size information.
 		}
 		if w == 0 || h == 0 {
 			return 0 // We don't support both width and height to be zero.
 		}
 		if width != 0 {
 			**(**int32)(__ccgo_up(width)) = w
 		}
 		if height != 0 {
 			**(**int32)(__ccgo_up(height)) = h
 		}
 		return int32(1)
 	}
 	return r
 }
 
 //------------------------------------------------------------------------------
 // Header parsing
 
 func ResetSegmentHeader(tls *libc.TLS, hdr uintptr) {
 	(*VP8SegmentHeader)(unsafe.Pointer(hdr)).Fuse_segment = 0
 	(*VP8SegmentHeader)(unsafe.Pointer(hdr)).Fupdate_map = 0
 	(*VP8SegmentHeader)(unsafe.Pointer(hdr)).Fabsolute_delta = int32(1)
 	libc.X__builtin___memset_chk(tls, hdr+12, 0, uint64(4), ^__predefined_size_t(0))
 	libc.X__builtin___memset_chk(tls, hdr+16, 0, uint64(4), ^__predefined_size_t(0))
 }
 
 // C documentation
 //
 //	// Paragraph 9.3
 func ParseSegmentHeader(tls *libc.TLS, br uintptr, hdr uintptr, proba uintptr) (r int32) {
 	var s, s1, v2 int32
 	var v6 uint32
 	_, _, _, _ = s, s1, v2, v6
 	(*VP8SegmentHeader)(unsafe.Pointer(hdr)).Fuse_segment = libc.Int32FromUint32(VP8GetValue(tls, br, int32(1)))
 	if (*VP8SegmentHeader)(unsafe.Pointer(hdr)).Fuse_segment != 0 {
 		(*VP8SegmentHeader)(unsafe.Pointer(hdr)).Fupdate_map = libc.Int32FromUint32(VP8GetValue(tls, br, int32(1)))
 		if VP8GetValue(tls, br, int32(1)) != 0 {
 			(*VP8SegmentHeader)(unsafe.Pointer(hdr)).Fabsolute_delta = libc.Int32FromUint32(VP8GetValue(tls, br, int32(1)))
 			s = 0
 			for {
 				if !(s < int32(NUM_MB_SEGMENTS)) {
 					break
 				}
 				if VP8GetValue(tls, br, int32(1)) != 0 {
 					v2 = VP8GetSignedValue(tls, br, int32(7))
 				} else {
 					v2 = 0
 				}
 				**(**int8_t)(__ccgo_up(hdr + 12 + uintptr(s))) = int8(v2)
 				goto _1
 			_1:
 				;
 				s = s + 1
 			}
 			s = 0
 			for {
 				if !(s < int32(NUM_MB_SEGMENTS)) {
 					break
 				}
 				if VP8GetValue(tls, br, int32(1)) != 0 {
 					v2 = VP8GetSignedValue(tls, br, int32(6))
 				} else {
 					v2 = 0
 				}
 				**(**int8_t)(__ccgo_up(hdr + 16 + uintptr(s))) = int8(v2)
 				goto _3
 			_3:
 				;
 				s = s + 1
 			}
 		}
 		if (*VP8SegmentHeader)(unsafe.Pointer(hdr)).Fupdate_map != 0 {
 			s1 = 0
 			for {
 				if !(s1 < int32(MB_FEATURE_TREE_PROBS)) {
 					break
 				}
 				if VP8GetValue(tls, br, int32(1)) != 0 {
 					v6 = VP8GetValue(tls, br, int32(8))
 				} else {
 					v6 = uint32(255)
 				}
 				**(**uint8_t)(__ccgo_up(proba + uintptr(s1))) = uint8(v6)
 				goto _5
 			_5:
 				;
 				s1 = s1 + 1
 			}
 		}
 	} else {
 		(*VP8SegmentHeader)(unsafe.Pointer(hdr)).Fupdate_map = 0
 	}
 	return libc.BoolInt32(!((*VP8BitReader)(unsafe.Pointer(br)).Feof != 0))
 }
 
 // C documentation
 //
 //	// Paragraph 9.5
 //	// If we don't have all the necessary data in 'buf', this function returns
 //	// VP8_STATUS_SUSPENDED in incremental decoding, VP8_STATUS_NOT_ENOUGH_DATA
 //	// otherwise.
 //	// In incremental decoding, this case is not necessarily an error. Still, no
 //	// bitreader is ever initialized to make it possible to read unavailable memory.
 //	// If we don't even have the partitions' sizes, then VP8_STATUS_NOT_ENOUGH_DATA
 //	// is returned, and this is an unrecoverable error.
 //	// If the partitions were positioned ok, VP8_STATUS_OK is returned.
 func ParsePartitions(tls *libc.TLS, dec uintptr, buf uintptr, size size_t) (r VP8StatusCode1) {
 	var br, buf_end, part_start, sz uintptr
 	var last_part, p, psize, size_left size_t
 	var v2 int32
 	_, _, _, _, _, _, _, _, _ = br, buf_end, last_part, p, part_start, psize, size_left, sz, v2
 	br = dec + 16
 	sz = buf
 	buf_end = buf + uintptr(size)
 	size_left = size
 	(*VP8Decoder)(unsafe.Pointer(dec)).Fnum_parts_minus_one = libc.Uint32FromInt32(int32(1)<<VP8GetValue(tls, br, int32(2)) - int32(1))
 	last_part = uint64((*VP8Decoder)(unsafe.Pointer(dec)).Fnum_parts_minus_one)
 	if size < uint64(3)*last_part {
 		// we can't even read the sizes with sz[]! That's a failure.
 		return int32(VP8_STATUS_NOT_ENOUGH_DATA)
 	}
 	part_start = buf + uintptr(last_part*uint64(3))
 	size_left = size_left - last_part*uint64(3)
 	p = uint64(0)
 	for {
 		if !(p < last_part) {
 			break
 		}
 		psize = libc.Uint64FromInt32(libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(sz))) | libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(sz + 1)))<<int32(8) | libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(sz + 2)))<<int32(16))
 		if psize > size_left {
 			psize = size_left
 		}
 		VP8InitBitReader(tls, dec+440+uintptr(p)*48, part_start, psize)
 		part_start = part_start + uintptr(psize)
 		size_left = size_left - psize
 		sz = sz + uintptr(3)
 		goto _1
 	_1:
 		;
 		p = p + 1
 	}
 	VP8InitBitReader(tls, dec+440+uintptr(last_part)*48, part_start, size_left)
 	if part_start < buf_end {
 		return int32(VP8_STATUS_OK)
 	}
 	if (*VP8Decoder)(unsafe.Pointer(dec)).Fincremental != 0 {
 		v2 = int32(VP8_STATUS_SUSPENDED)
 	} else {
 		v2 = int32(VP8_STATUS_NOT_ENOUGH_DATA)
 	}
 	return v2
 }
 
 // C documentation
 //
 //	// Paragraph 9.4
 func ParseFilterHeader(tls *libc.TLS, br uintptr, dec uintptr) (r int32) {
 	var hdr uintptr
 	var i, v3, v4 int32
 	_, _, _, _ = hdr, i, v3, v4
 	hdr = dec + 84
 	(*VP8FilterHeader)(unsafe.Pointer(hdr)).Fsimple = libc.Int32FromUint32(VP8GetValue(tls, br, int32(1)))
 	(*VP8FilterHeader)(unsafe.Pointer(hdr)).Flevel = libc.Int32FromUint32(VP8GetValue(tls, br, int32(6)))
 	(*VP8FilterHeader)(unsafe.Pointer(hdr)).Fsharpness = libc.Int32FromUint32(VP8GetValue(tls, br, int32(3)))
 	(*VP8FilterHeader)(unsafe.Pointer(hdr)).Fuse_lf_delta = libc.Int32FromUint32(VP8GetValue(tls, br, int32(1)))
 	if (*VP8FilterHeader)(unsafe.Pointer(hdr)).Fuse_lf_delta != 0 {
 		if VP8GetValue(tls, br, int32(1)) != 0 {
 			i = 0
 			for {
 				if !(i < int32(NUM_REF_LF_DELTAS)) {
 					break
 				}
 				if VP8GetValue(tls, br, int32(1)) != 0 {
 					**(**int32)(__ccgo_up(hdr + 16 + uintptr(i)*4)) = VP8GetSignedValue(tls, br, int32(6))
 				}
 				goto _1
 			_1:
 				;
 				i = i + 1
 			}
 			i = 0
 			for {
 				if !(i < int32(NUM_MODE_LF_DELTAS)) {
 					break
 				}
 				if VP8GetValue(tls, br, int32(1)) != 0 {
 					**(**int32)(__ccgo_up(hdr + 32 + uintptr(i)*4)) = VP8GetSignedValue(tls, br, int32(6))
 				}
 				goto _2
 			_2:
 				;
 				i = i + 1
 			}
 		}
 	}
 	if (*VP8FilterHeader)(unsafe.Pointer(hdr)).Flevel == 0 {
 		v3 = 0
 	} else {
 		if (*VP8FilterHeader)(unsafe.Pointer(hdr)).Fsimple != 0 {
 			v4 = int32(1)
 		} else {
 			v4 = int32(2)
 		}
 		v3 = v4
 	}
 	(*VP8Decoder)(unsafe.Pointer(dec)).Ffilter_type = v3
 	return libc.BoolInt32(!((*VP8BitReader)(unsafe.Pointer(br)).Feof != 0))
 }
 
 // C documentation
 //
 //	// Topmost call
 func VP8GetHeaders(tls *libc.TLS, dec uintptr, io uintptr) (r int32) {
 	var bits uint32_t
 	var br, buf, frm_hdr, pic_hdr uintptr
 	var buf_size size_t
 	var status VP8StatusCode1
 	_, _, _, _, _, _, _ = bits, br, buf, buf_size, frm_hdr, pic_hdr, status
 	if dec == libc.UintptrFromInt32(0) {
 		return 0
 	}
 	SetOk(tls, dec)
 	if io == libc.UintptrFromInt32(0) {
 		return VP8SetError(tls, dec, int32(VP8_STATUS_INVALID_PARAM), __ccgo_ts+167)
 	}
 	buf = (*VP8Io)(unsafe.Pointer(io)).Fdata
 	buf_size = (*VP8Io)(unsafe.Pointer(io)).Fdata_size
 	if buf_size < uint64(4) {
 		return VP8SetError(tls, dec, int32(VP8_STATUS_NOT_ENOUGH_DATA), __ccgo_ts+204)
 	}
 	// Paragraph 9.1
 	bits = libc.Uint32FromInt32(libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(buf))) | libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(buf + 1)))<<int32(8) | libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(buf + 2)))<<int32(16))
 	frm_hdr = dec + 68
 	(*VP8FrameHeader)(unsafe.Pointer(frm_hdr)).Fkey_frame = libc.BoolUint8(!(bits&libc.Uint32FromInt32(1) != 0))
 	(*VP8FrameHeader)(unsafe.Pointer(frm_hdr)).Fprofile = uint8(bits >> libc.Int32FromInt32(1) & uint32(7))
 	(*VP8FrameHeader)(unsafe.Pointer(frm_hdr)).Fshow = uint8(bits >> libc.Int32FromInt32(4) & uint32(1))
 	(*VP8FrameHeader)(unsafe.Pointer(frm_hdr)).Fpartition_length = bits >> libc.Int32FromInt32(5)
 	if libc.Int32FromUint8((*VP8FrameHeader)(unsafe.Pointer(frm_hdr)).Fprofile) > int32(3) {
 		return VP8SetError(tls, dec, int32(VP8_STATUS_BITSTREAM_ERROR), __ccgo_ts+222)
 	}
 	if !((*VP8FrameHeader)(unsafe.Pointer(frm_hdr)).Fshow != 0) {
 		return VP8SetError(tls, dec, int32(VP8_STATUS_UNSUPPORTED_FEATURE), __ccgo_ts+253)
 	}
 	buf = buf + uintptr(3)
 	buf_size = buf_size - uint64(3)
 	pic_hdr = dec + 76
 	if (*VP8FrameHeader)(unsafe.Pointer(frm_hdr)).Fkey_frame != 0 {
 		// Paragraph 9.2
 		if buf_size < uint64(7) {
 			return VP8SetError(tls, dec, int32(VP8_STATUS_NOT_ENOUGH_DATA), __ccgo_ts+276)
 		}
 		if !(VP8CheckSignature(tls, buf, buf_size) != 0) {
 			return VP8SetError(tls, dec, int32(VP8_STATUS_BITSTREAM_ERROR), __ccgo_ts+304)
 		}
 		(*VP8PictureHeader)(unsafe.Pointer(pic_hdr)).Fwidth = libc.Uint16FromInt32((libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(buf + 4)))<<int32(8) | libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(buf + 3)))) & int32(0x3fff))
 		(*VP8PictureHeader)(unsafe.Pointer(pic_hdr)).Fxscale = libc.Uint8FromInt32(libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(buf + 4))) >> int32(6)) // ratio: 1, 5/4 5/3 or 2
 		(*VP8PictureHeader)(unsafe.Pointer(pic_hdr)).Fheight = libc.Uint16FromInt32((libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(buf + 6)))<<int32(8) | libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(buf + 5)))) & int32(0x3fff))
 		(*VP8PictureHeader)(unsafe.Pointer(pic_hdr)).Fyscale = libc.Uint8FromInt32(libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(buf + 6))) >> int32(6))
 		buf = buf + uintptr(7)
 		buf_size = buf_size - uint64(7)
 		(*VP8Decoder)(unsafe.Pointer(dec)).Fmb_w = (libc.Int32FromUint16((*VP8PictureHeader)(unsafe.Pointer(pic_hdr)).Fwidth) + int32(15)) >> int32(4)
 		(*VP8Decoder)(unsafe.Pointer(dec)).Fmb_h = (libc.Int32FromUint16((*VP8PictureHeader)(unsafe.Pointer(pic_hdr)).Fheight) + int32(15)) >> int32(4)
 		// Setup default output area (can be later modified during io->setup())
 		(*VP8Io)(unsafe.Pointer(io)).Fwidth = libc.Int32FromUint16((*VP8PictureHeader)(unsafe.Pointer(pic_hdr)).Fwidth)
 		(*VP8Io)(unsafe.Pointer(io)).Fheight = libc.Int32FromUint16((*VP8PictureHeader)(unsafe.Pointer(pic_hdr)).Fheight)
 		// IMPORTANT! use some sane dimensions in crop* and scaled* fields.
 		// So they can be used interchangeably without always testing for
 		// 'use_cropping'.
 		(*VP8Io)(unsafe.Pointer(io)).Fuse_cropping = 0
 		(*VP8Io)(unsafe.Pointer(io)).Fcrop_top = 0
 		(*VP8Io)(unsafe.Pointer(io)).Fcrop_left = 0
 		(*VP8Io)(unsafe.Pointer(io)).Fcrop_right = (*VP8Io)(unsafe.Pointer(io)).Fwidth
 		(*VP8Io)(unsafe.Pointer(io)).Fcrop_bottom = (*VP8Io)(unsafe.Pointer(io)).Fheight
 		(*VP8Io)(unsafe.Pointer(io)).Fuse_scaling = 0
 		(*VP8Io)(unsafe.Pointer(io)).Fscaled_width = (*VP8Io)(unsafe.Pointer(io)).Fwidth
 		(*VP8Io)(unsafe.Pointer(io)).Fscaled_height = (*VP8Io)(unsafe.Pointer(io)).Fheight
 		(*VP8Io)(unsafe.Pointer(io)).Fmb_w = (*VP8Io)(unsafe.Pointer(io)).Fwidth  // for soundness
 		(*VP8Io)(unsafe.Pointer(io)).Fmb_h = (*VP8Io)(unsafe.Pointer(io)).Fheight // ditto
 		VP8ResetProba(tls, dec+1192)
 		ResetSegmentHeader(tls, dec+132)
 	}
 	// Check if we have all the partition #0 available, and initialize dec->br
 	// to read this partition (and this partition only).
 	if uint64((*VP8FrameHeader)(unsafe.Pointer(frm_hdr)).Fpartition_length) > buf_size {
 		return VP8SetError(tls, dec, int32(VP8_STATUS_NOT_ENOUGH_DATA), __ccgo_ts+318)
 	}
 	br = dec + 16
 	VP8InitBitReader(tls, br, buf, uint64((*VP8FrameHeader)(unsafe.Pointer(frm_hdr)).Fpartition_length))
 	buf = buf + uintptr((*VP8FrameHeader)(unsafe.Pointer(frm_hdr)).Fpartition_length)
 	buf_size = buf_size - uint64((*VP8FrameHeader)(unsafe.Pointer(frm_hdr)).Fpartition_length)
 	if (*VP8FrameHeader)(unsafe.Pointer(frm_hdr)).Fkey_frame != 0 {
 		(*VP8PictureHeader)(unsafe.Pointer(pic_hdr)).Fcolorspace = uint8(VP8GetValue(tls, br, int32(1)))
 		(*VP8PictureHeader)(unsafe.Pointer(pic_hdr)).Fclamp_type = uint8(VP8GetValue(tls, br, int32(1)))
 	}
 	if !(ParseSegmentHeader(tls, br, dec+132, dec+1192) != 0) {
 		return VP8SetError(tls, dec, int32(VP8_STATUS_BITSTREAM_ERROR), __ccgo_ts+339)
 	}
 	// Filter specs
 	if !(ParseFilterHeader(tls, br, dec) != 0) {
 		return VP8SetError(tls, dec, int32(VP8_STATUS_BITSTREAM_ERROR), __ccgo_ts+367)
 	}
 	status = ParsePartitions(tls, dec, buf, buf_size)
 	if status != int32(VP8_STATUS_OK) {
 		return VP8SetError(tls, dec, status, __ccgo_ts+394)
 	}
 	// quantizer change
 	VP8ParseQuant(tls, dec)
 	// Frame buffer marking
 	if !((*VP8FrameHeader)(unsafe.Pointer(frm_hdr)).Fkey_frame != 0) {
 		return VP8SetError(tls, dec, int32(VP8_STATUS_UNSUPPORTED_FEATURE), __ccgo_ts+418)
 	}
 	VP8GetValue(tls, br, int32(1)) // ignore the value of 'update_proba'
 	VP8ParseProba(tls, br, dec)
 	// sanitized state
 	(*VP8Decoder)(unsafe.Pointer(dec)).Fready = int32(1)
 	return int32(1)
 }
 
 //------------------------------------------------------------------------------
 // Residual decoding (Paragraph 13.2 / 13.3)
 
 var kCat3 = [4]uint8_t{
 	0: uint8(173),
 	1: uint8(148),
 	2: uint8(140),
 }
 var kCat4 = [5]uint8_t{
 	0: uint8(176),
 	1: uint8(155),
 	2: uint8(140),
 	3: uint8(135),
 }
 var kCat5 = [6]uint8_t{
 	0: uint8(180),
 	1: uint8(157),
 	2: uint8(141),
 	3: uint8(134),
 	4: uint8(130),
 }
 var kCat6 = [12]uint8_t{
 	0:  uint8(254),
 	1:  uint8(254),
 	2:  uint8(243),
 	3:  uint8(230),
 	4:  uint8(196),
 	5:  uint8(177),
 	6:  uint8(153),
 	7:  uint8(140),
 	8:  uint8(133),
 	9:  uint8(130),
 	10: uint8(129),
 }
 var kCat3456 = [4]uintptr{
 	0: uintptr(unsafe.Pointer(&kCat3)),
 	1: uintptr(unsafe.Pointer(&kCat4)),
 	2: uintptr(unsafe.Pointer(&kCat5)),
 	3: uintptr(unsafe.Pointer(&kCat6)),
 }
 var kZigzag = [16]uint8_t{
 	1:  uint8(1),
 	2:  uint8(4),
 	3:  uint8(8),
 	4:  uint8(5),
 	5:  uint8(2),
 	6:  uint8(3),
 	7:  uint8(6),
 	8:  uint8(9),
 	9:  uint8(12),
 	10: uint8(13),
 	11: uint8(10),
 	12: uint8(7),
 	13: uint8(11),
 	14: uint8(14),
 	15: uint8(15),
 }
 
 // C documentation
 //
 //	// See section 13-2: https://datatracker.ietf.org/doc/html/rfc6386#section-13.2
 func GetLargeValue(tls *libc.TLS, br2 uintptr, p uintptr) (r int32) {
 	bp := tls.Alloc(16)
 	defer tls.Free(16)
 	var bit, bit0, bit1, cat, pos, shift, v, v13, v15, v21, v23, v5, v7 int32
 	var bits bit_t
 	var range1, split, value range_t
 	var tab, v1, v10, v17, v18, v2, v9 uintptr
 	var v11, v19, v3 uint64_t
 	var _ /* in_bits at bp+0 */ lbit_t
 	_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = bit, bit0, bit1, bits, cat, pos, range1, shift, split, tab, v, value, v1, v10, v11, v13, v15, v17, v18, v19, v2, v21, v23, v3, v5, v7, v9
 	v1 = br2
 	range1 = (*VP8BitReader)(unsafe.Pointer(v1)).Frange1
 	if (*VP8BitReader)(unsafe.Pointer(v1)).Fbits < libc.Int32FromInt32(0) {
 		v2 = v1
 		if (*VP8BitReader)(unsafe.Pointer(v2)).Fbuf < (*VP8BitReader)(unsafe.Pointer(v2)).Fbuf_max {
 			libc.X__builtin___memcpy_chk(tls, bp, (*VP8BitReader)(unsafe.Pointer(v2)).Fbuf, uint64(8), ^__predefined_size_t(0))
 			**(**uintptr)(__ccgo_up(v2 + 16)) += uintptr(libc.Int32FromInt32(BITS) >> libc.Int32FromInt32(3))
 			v3 = uint64(libc.X__builtin_bswap64(tls, uint64(**(**lbit_t)(__ccgo_up(bp)))))
 			goto _4
 		_4:
 			bits = v3
 			bits = bits >> libc.Uint64FromInt32(libc.Int32FromInt32(64)-libc.Int32FromInt32(BITS))
 			(*VP8BitReader)(unsafe.Pointer(v2)).Fvalue = bits | (*VP8BitReader)(unsafe.Pointer(v2)).Fvalue<<libc.Int32FromInt32(BITS)
 			**(**int32)(__ccgo_up(v2 + 12)) += int32(BITS)
 		} else {
 			VP8LoadFinalBytes(tls, v2)
 		}
 	}
 	pos = (*VP8BitReader)(unsafe.Pointer(v1)).Fbits
 	split = range1 * libc.Uint32FromInt32(libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(p + 3)))) >> int32(8)
 	value = uint32((*VP8BitReader)(unsafe.Pointer(v1)).Fvalue >> pos)
 	bit = libc.BoolInt32(value > split)
 	if bit != 0 {
 		range1 = range1 - split
 		**(**bit_t)(__ccgo_up(v1)) -= uint64(split+libc.Uint32FromInt32(1)) << pos
 	} else {
 		range1 = split + uint32(1)
 	}
 	v5 = int32(31) ^ libc.X__builtin_clz(tls, range1)
 	goto _6
 _6:
 	shift = int32(7) ^ v5
 	range1 = range1 << libc.Uint32FromInt32(shift)
 	**(**int32)(__ccgo_up(v1 + 12)) -= shift
 	(*VP8BitReader)(unsafe.Pointer(v1)).Frange1 = range1 - uint32(1)
 	v7 = bit
 	goto _8
 _8:
 	if !(v7 != 0) {
 		v9 = br2
 		range1 = (*VP8BitReader)(unsafe.Pointer(v9)).Frange1
 		if (*VP8BitReader)(unsafe.Pointer(v9)).Fbits < libc.Int32FromInt32(0) {
 			v10 = v9
 			if (*VP8BitReader)(unsafe.Pointer(v10)).Fbuf < (*VP8BitReader)(unsafe.Pointer(v10)).Fbuf_max {
 				libc.X__builtin___memcpy_chk(tls, bp, (*VP8BitReader)(unsafe.Pointer(v10)).Fbuf, uint64(8), ^__predefined_size_t(0))
 				**(**uintptr)(__ccgo_up(v10 + 16)) += uintptr(libc.Int32FromInt32(BITS) >> libc.Int32FromInt32(3))
 				v11 = uint64(libc.X__builtin_bswap64(tls, uint64(**(**lbit_t)(__ccgo_up(bp)))))
 				goto _12
 			_12:
 				bits = v11
 				bits = bits >> libc.Uint64FromInt32(libc.Int32FromInt32(64)-libc.Int32FromInt32(BITS))
 				(*VP8BitReader)(unsafe.Pointer(v10)).Fvalue = bits | (*VP8BitReader)(unsafe.Pointer(v10)).Fvalue<<libc.Int32FromInt32(BITS)
 				**(**int32)(__ccgo_up(v10 + 12)) += int32(BITS)
 			} else {
 				VP8LoadFinalBytes(tls, v10)
 			}
 		}
 		pos = (*VP8BitReader)(unsafe.Pointer(v9)).Fbits
 		split = range1 * libc.Uint32FromInt32(libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(p + 4)))) >> int32(8)
 		value = uint32((*VP8BitReader)(unsafe.Pointer(v9)).Fvalue >> pos)
 		bit = libc.BoolInt32(value > split)
 		if bit != 0 {
 			range1 = range1 - split
 			**(**bit_t)(__ccgo_up(v9)) -= uint64(split+libc.Uint32FromInt32(1)) << pos
 		} else {
 			range1 = split + uint32(1)
 		}
 		v13 = int32(31) ^ libc.X__builtin_clz(tls, range1)
 		goto _14
 	_14:
 		shift = int32(7) ^ v13
 		range1 = range1 << libc.Uint32FromInt32(shift)
 		**(**int32)(__ccgo_up(v9 + 12)) -= shift
 		(*VP8BitReader)(unsafe.Pointer(v9)).Frange1 = range1 - uint32(1)
 		v15 = bit
 		goto _16
 	_16:
 		if !(v15 != 0) {
 			v = int32(2)
 		} else {
 			v1 = br2
 			range1 = (*VP8BitReader)(unsafe.Pointer(v1)).Frange1
 			if (*VP8BitReader)(unsafe.Pointer(v1)).Fbits < libc.Int32FromInt32(0) {
 				v2 = v1
 				if (*VP8BitReader)(unsafe.Pointer(v2)).Fbuf < (*VP8BitReader)(unsafe.Pointer(v2)).Fbuf_max {
 					libc.X__builtin___memcpy_chk(tls, bp, (*VP8BitReader)(unsafe.Pointer(v2)).Fbuf, uint64(8), ^__predefined_size_t(0))
 					**(**uintptr)(__ccgo_up(v2 + 16)) += uintptr(libc.Int32FromInt32(BITS) >> libc.Int32FromInt32(3))
 					v3 = uint64(libc.X__builtin_bswap64(tls, uint64(**(**lbit_t)(__ccgo_up(bp)))))
 					goto _20
 				_20:
 					bits = v3
 					bits = bits >> libc.Uint64FromInt32(libc.Int32FromInt32(64)-libc.Int32FromInt32(BITS))
 					(*VP8BitReader)(unsafe.Pointer(v2)).Fvalue = bits | (*VP8BitReader)(unsafe.Pointer(v2)).Fvalue<<libc.Int32FromInt32(BITS)
 					**(**int32)(__ccgo_up(v2 + 12)) += int32(BITS)
 				} else {
 					VP8LoadFinalBytes(tls, v2)
 				}
 			}
 			pos = (*VP8BitReader)(unsafe.Pointer(v1)).Fbits
 			split = range1 * libc.Uint32FromInt32(libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(p + 5)))) >> int32(8)
 			value = uint32((*VP8BitReader)(unsafe.Pointer(v1)).Fvalue >> pos)
 			bit = libc.BoolInt32(value > split)
 			if bit != 0 {
 				range1 = range1 - split
 				**(**bit_t)(__ccgo_up(v1)) -= uint64(split+libc.Uint32FromInt32(1)) << pos
 			} else {
 				range1 = split + uint32(1)
 			}
 			v5 = int32(31) ^ libc.X__builtin_clz(tls, range1)
 			goto _22
 		_22:
 			shift = int32(7) ^ v5
 			range1 = range1 << libc.Uint32FromInt32(shift)
 			**(**int32)(__ccgo_up(v1 + 12)) -= shift
 			(*VP8BitReader)(unsafe.Pointer(v1)).Frange1 = range1 - uint32(1)
 			v7 = bit
 			goto _24
 		_24:
 			v = int32(3) + v7
 		}
 	} else {
 		v1 = br2
 		range1 = (*VP8BitReader)(unsafe.Pointer(v1)).Frange1
 		if (*VP8BitReader)(unsafe.Pointer(v1)).Fbits < libc.Int32FromInt32(0) {
 			v2 = v1
 			if (*VP8BitReader)(unsafe.Pointer(v2)).Fbuf < (*VP8BitReader)(unsafe.Pointer(v2)).Fbuf_max {
 				libc.X__builtin___memcpy_chk(tls, bp, (*VP8BitReader)(unsafe.Pointer(v2)).Fbuf, uint64(8), ^__predefined_size_t(0))
 				**(**uintptr)(__ccgo_up(v2 + 16)) += uintptr(libc.Int32FromInt32(BITS) >> libc.Int32FromInt32(3))
 				v3 = uint64(libc.X__builtin_bswap64(tls, uint64(**(**lbit_t)(__ccgo_up(bp)))))
 				goto _28
 			_28:
 				bits = v3
 				bits = bits >> libc.Uint64FromInt32(libc.Int32FromInt32(64)-libc.Int32FromInt32(BITS))
 				(*VP8BitReader)(unsafe.Pointer(v2)).Fvalue = bits | (*VP8BitReader)(unsafe.Pointer(v2)).Fvalue<<libc.Int32FromInt32(BITS)
 				**(**int32)(__ccgo_up(v2 + 12)) += int32(BITS)
 			} else {
 				VP8LoadFinalBytes(tls, v2)
 			}
 		}
 		pos = (*VP8BitReader)(unsafe.Pointer(v1)).Fbits
 		split = range1 * libc.Uint32FromInt32(libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(p + 6)))) >> int32(8)
 		value = uint32((*VP8BitReader)(unsafe.Pointer(v1)).Fvalue >> pos)
 		bit = libc.BoolInt32(value > split)
 		if bit != 0 {
 			range1 = range1 - split
 			**(**bit_t)(__ccgo_up(v1)) -= uint64(split+libc.Uint32FromInt32(1)) << pos
 		} else {
 			range1 = split + uint32(1)
 		}
 		v5 = int32(31) ^ libc.X__builtin_clz(tls, range1)
 		goto _30
 	_30:
 		shift = int32(7) ^ v5
 		range1 = range1 << libc.Uint32FromInt32(shift)
 		**(**int32)(__ccgo_up(v1 + 12)) -= shift
 		(*VP8BitReader)(unsafe.Pointer(v1)).Frange1 = range1 - uint32(1)
 		v7 = bit
 		goto _32
 	_32:
 		if !(v7 != 0) {
 			v9 = br2
 			range1 = (*VP8BitReader)(unsafe.Pointer(v9)).Frange1
 			if (*VP8BitReader)(unsafe.Pointer(v9)).Fbits < libc.Int32FromInt32(0) {
 				v10 = v9
 				if (*VP8BitReader)(unsafe.Pointer(v10)).Fbuf < (*VP8BitReader)(unsafe.Pointer(v10)).Fbuf_max {
 					libc.X__builtin___memcpy_chk(tls, bp, (*VP8BitReader)(unsafe.Pointer(v10)).Fbuf, uint64(8), ^__predefined_size_t(0))
 					**(**uintptr)(__ccgo_up(v10 + 16)) += uintptr(libc.Int32FromInt32(BITS) >> libc.Int32FromInt32(3))
 					v11 = uint64(libc.X__builtin_bswap64(tls, uint64(**(**lbit_t)(__ccgo_up(bp)))))
 					goto _36
 				_36:
 					bits = v11
 					bits = bits >> libc.Uint64FromInt32(libc.Int32FromInt32(64)-libc.Int32FromInt32(BITS))
 					(*VP8BitReader)(unsafe.Pointer(v10)).Fvalue = bits | (*VP8BitReader)(unsafe.Pointer(v10)).Fvalue<<libc.Int32FromInt32(BITS)
 					**(**int32)(__ccgo_up(v10 + 12)) += int32(BITS)
 				} else {
 					VP8LoadFinalBytes(tls, v10)
 				}
 			}
 			pos = (*VP8BitReader)(unsafe.Pointer(v9)).Fbits
 			split = range1 * libc.Uint32FromInt32(libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(p + 7)))) >> int32(8)
 			value = uint32((*VP8BitReader)(unsafe.Pointer(v9)).Fvalue >> pos)
 			bit = libc.BoolInt32(value > split)
 			if bit != 0 {
 				range1 = range1 - split
 				**(**bit_t)(__ccgo_up(v9)) -= uint64(split+libc.Uint32FromInt32(1)) << pos
 			} else {
 				range1 = split + uint32(1)
 			}
 			v13 = int32(31) ^ libc.X__builtin_clz(tls, range1)
 			goto _38
 		_38:
 			shift = int32(7) ^ v13
 			range1 = range1 << libc.Uint32FromInt32(shift)
 			**(**int32)(__ccgo_up(v9 + 12)) -= shift
 			(*VP8BitReader)(unsafe.Pointer(v9)).Frange1 = range1 - uint32(1)
 			v15 = bit
 			goto _40
 		_40:
 			if !(v15 != 0) {
 				v17 = br2
 				range1 = (*VP8BitReader)(unsafe.Pointer(v17)).Frange1
 				if (*VP8BitReader)(unsafe.Pointer(v17)).Fbits < libc.Int32FromInt32(0) {
 					v18 = v17
 					if (*VP8BitReader)(unsafe.Pointer(v18)).Fbuf < (*VP8BitReader)(unsafe.Pointer(v18)).Fbuf_max {
 						libc.X__builtin___memcpy_chk(tls, bp, (*VP8BitReader)(unsafe.Pointer(v18)).Fbuf, uint64(8), ^__predefined_size_t(0))
 						**(**uintptr)(__ccgo_up(v18 + 16)) += uintptr(libc.Int32FromInt32(BITS) >> libc.Int32FromInt32(3))
 						v19 = uint64(libc.X__builtin_bswap64(tls, uint64(**(**lbit_t)(__ccgo_up(bp)))))
 						goto _44
 					_44:
 						bits = v19
 						bits = bits >> libc.Uint64FromInt32(libc.Int32FromInt32(64)-libc.Int32FromInt32(BITS))
 						(*VP8BitReader)(unsafe.Pointer(v18)).Fvalue = bits | (*VP8BitReader)(unsafe.Pointer(v18)).Fvalue<<libc.Int32FromInt32(BITS)
 						**(**int32)(__ccgo_up(v18 + 12)) += int32(BITS)
 					} else {
 						VP8LoadFinalBytes(tls, v18)
 					}
 				}
 				pos = (*VP8BitReader)(unsafe.Pointer(v17)).Fbits
 				split = range1 * libc.Uint32FromInt32(int32(159)) >> int32(8)
 				value = uint32((*VP8BitReader)(unsafe.Pointer(v17)).Fvalue >> pos)
 				bit = libc.BoolInt32(value > split)
 				if bit != 0 {
 					range1 = range1 - split
 					**(**bit_t)(__ccgo_up(v17)) -= uint64(split+libc.Uint32FromInt32(1)) << pos
 				} else {
 					range1 = split + uint32(1)
 				}
 				v21 = int32(31) ^ libc.X__builtin_clz(tls, range1)
 				goto _46
 			_46:
 				shift = int32(7) ^ v21
 				range1 = range1 << libc.Uint32FromInt32(shift)
 				**(**int32)(__ccgo_up(v17 + 12)) -= shift
 				(*VP8BitReader)(unsafe.Pointer(v17)).Frange1 = range1 - uint32(1)
 				v23 = bit
 				goto _48
 			_48:
 				v = int32(5) + v23
 			} else {
 				v1 = br2
 				range1 = (*VP8BitReader)(unsafe.Pointer(v1)).Frange1
 				if (*VP8BitReader)(unsafe.Pointer(v1)).Fbits < libc.Int32FromInt32(0) {
 					v2 = v1
 					if (*VP8BitReader)(unsafe.Pointer(v2)).Fbuf < (*VP8BitReader)(unsafe.Pointer(v2)).Fbuf_max {
 						libc.X__builtin___memcpy_chk(tls, bp, (*VP8BitReader)(unsafe.Pointer(v2)).Fbuf, uint64(8), ^__predefined_size_t(0))
 						**(**uintptr)(__ccgo_up(v2 + 16)) += uintptr(libc.Int32FromInt32(BITS) >> libc.Int32FromInt32(3))
 						v3 = uint64(libc.X__builtin_bswap64(tls, uint64(**(**lbit_t)(__ccgo_up(bp)))))
 						goto _52
 					_52:
 						bits = v3
 						bits = bits >> libc.Uint64FromInt32(libc.Int32FromInt32(64)-libc.Int32FromInt32(BITS))
 						(*VP8BitReader)(unsafe.Pointer(v2)).Fvalue = bits | (*VP8BitReader)(unsafe.Pointer(v2)).Fvalue<<libc.Int32FromInt32(BITS)
 						**(**int32)(__ccgo_up(v2 + 12)) += int32(BITS)
 					} else {
 						VP8LoadFinalBytes(tls, v2)
 					}
 				}
 				pos = (*VP8BitReader)(unsafe.Pointer(v1)).Fbits
 				split = range1 * libc.Uint32FromInt32(int32(165)) >> int32(8)
 				value = uint32((*VP8BitReader)(unsafe.Pointer(v1)).Fvalue >> pos)
 				bit = libc.BoolInt32(value > split)
 				if bit != 0 {
 					range1 = range1 - split
 					**(**bit_t)(__ccgo_up(v1)) -= uint64(split+libc.Uint32FromInt32(1)) << pos
 				} else {
 					range1 = split + uint32(1)
 				}
 				v5 = int32(31) ^ libc.X__builtin_clz(tls, range1)
 				goto _54
 			_54:
 				shift = int32(7) ^ v5
 				range1 = range1 << libc.Uint32FromInt32(shift)
 				**(**int32)(__ccgo_up(v1 + 12)) -= shift
 				(*VP8BitReader)(unsafe.Pointer(v1)).Frange1 = range1 - uint32(1)
 				v7 = bit
 				goto _56
 			_56:
 				v = int32(7) + int32(2)*v7
 				v1 = br2
 				range1 = (*VP8BitReader)(unsafe.Pointer(v1)).Frange1
 				if (*VP8BitReader)(unsafe.Pointer(v1)).Fbits < libc.Int32FromInt32(0) {
 					v2 = v1
 					if (*VP8BitReader)(unsafe.Pointer(v2)).Fbuf < (*VP8BitReader)(unsafe.Pointer(v2)).Fbuf_max {
 						libc.X__builtin___memcpy_chk(tls, bp, (*VP8BitReader)(unsafe.Pointer(v2)).Fbuf, uint64(8), ^__predefined_size_t(0))
 						**(**uintptr)(__ccgo_up(v2 + 16)) += uintptr(libc.Int32FromInt32(BITS) >> libc.Int32FromInt32(3))
 						v3 = uint64(libc.X__builtin_bswap64(tls, uint64(**(**lbit_t)(__ccgo_up(bp)))))
 						goto _60
 					_60:
 						bits = v3
 						bits = bits >> libc.Uint64FromInt32(libc.Int32FromInt32(64)-libc.Int32FromInt32(BITS))
 						(*VP8BitReader)(unsafe.Pointer(v2)).Fvalue = bits | (*VP8BitReader)(unsafe.Pointer(v2)).Fvalue<<libc.Int32FromInt32(BITS)
 						**(**int32)(__ccgo_up(v2 + 12)) += int32(BITS)
 					} else {
 						VP8LoadFinalBytes(tls, v2)
 					}
 				}
 				pos = (*VP8BitReader)(unsafe.Pointer(v1)).Fbits
 				split = range1 * libc.Uint32FromInt32(int32(145)) >> int32(8)
 				value = uint32((*VP8BitReader)(unsafe.Pointer(v1)).Fvalue >> pos)
 				bit = libc.BoolInt32(value > split)
 				if bit != 0 {
 					range1 = range1 - split
 					**(**bit_t)(__ccgo_up(v1)) -= uint64(split+libc.Uint32FromInt32(1)) << pos
 				} else {
 					range1 = split + uint32(1)
 				}
 				v5 = int32(31) ^ libc.X__builtin_clz(tls, range1)
 				goto _62
 			_62:
 				shift = int32(7) ^ v5
 				range1 = range1 << libc.Uint32FromInt32(shift)
 				**(**int32)(__ccgo_up(v1 + 12)) -= shift
 				(*VP8BitReader)(unsafe.Pointer(v1)).Frange1 = range1 - uint32(1)
 				v7 = bit
 				goto _64
 			_64:
 				v = v + v7
 			}
 		} else {
 			v1 = br2
 			range1 = (*VP8BitReader)(unsafe.Pointer(v1)).Frange1
 			if (*VP8BitReader)(unsafe.Pointer(v1)).Fbits < libc.Int32FromInt32(0) {
 				v2 = v1
 				if (*VP8BitReader)(unsafe.Pointer(v2)).Fbuf < (*VP8BitReader)(unsafe.Pointer(v2)).Fbuf_max {
 					libc.X__builtin___memcpy_chk(tls, bp, (*VP8BitReader)(unsafe.Pointer(v2)).Fbuf, uint64(8), ^__predefined_size_t(0))
 					**(**uintptr)(__ccgo_up(v2 + 16)) += uintptr(libc.Int32FromInt32(BITS) >> libc.Int32FromInt32(3))
 					v3 = uint64(libc.X__builtin_bswap64(tls, uint64(**(**lbit_t)(__ccgo_up(bp)))))
 					goto _68
 				_68:
 					bits = v3
 					bits = bits >> libc.Uint64FromInt32(libc.Int32FromInt32(64)-libc.Int32FromInt32(BITS))
 					(*VP8BitReader)(unsafe.Pointer(v2)).Fvalue = bits | (*VP8BitReader)(unsafe.Pointer(v2)).Fvalue<<libc.Int32FromInt32(BITS)
 					**(**int32)(__ccgo_up(v2 + 12)) += int32(BITS)
 				} else {
 					VP8LoadFinalBytes(tls, v2)
 				}
 			}
 			pos = (*VP8BitReader)(unsafe.Pointer(v1)).Fbits
 			split = range1 * libc.Uint32FromInt32(libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(p + 8)))) >> int32(8)
 			value = uint32((*VP8BitReader)(unsafe.Pointer(v1)).Fvalue >> pos)
 			bit = libc.BoolInt32(value > split)
 			if bit != 0 {
 				range1 = range1 - split
 				**(**bit_t)(__ccgo_up(v1)) -= uint64(split+libc.Uint32FromInt32(1)) << pos
 			} else {
 				range1 = split + uint32(1)
 			}
 			v5 = int32(31) ^ libc.X__builtin_clz(tls, range1)
 			goto _70
 		_70:
 			shift = int32(7) ^ v5
 			range1 = range1 << libc.Uint32FromInt32(shift)
 			**(**int32)(__ccgo_up(v1 + 12)) -= shift
 			(*VP8BitReader)(unsafe.Pointer(v1)).Frange1 = range1 - uint32(1)
 			v7 = bit
 			goto _72
 		_72:
 			bit1 = v7
 			v9 = br2
 			range1 = (*VP8BitReader)(unsafe.Pointer(v9)).Frange1
 			if (*VP8BitReader)(unsafe.Pointer(v9)).Fbits < libc.Int32FromInt32(0) {
 				v10 = v9
 				if (*VP8BitReader)(unsafe.Pointer(v10)).Fbuf < (*VP8BitReader)(unsafe.Pointer(v10)).Fbuf_max {
 					libc.X__builtin___memcpy_chk(tls, bp, (*VP8BitReader)(unsafe.Pointer(v10)).Fbuf, uint64(8), ^__predefined_size_t(0))
 					**(**uintptr)(__ccgo_up(v10 + 16)) += uintptr(libc.Int32FromInt32(BITS) >> libc.Int32FromInt32(3))
 					v11 = uint64(libc.X__builtin_bswap64(tls, uint64(**(**lbit_t)(__ccgo_up(bp)))))
 					goto _76
 				_76:
 					bits = v11
 					bits = bits >> libc.Uint64FromInt32(libc.Int32FromInt32(64)-libc.Int32FromInt32(BITS))
 					(*VP8BitReader)(unsafe.Pointer(v10)).Fvalue = bits | (*VP8BitReader)(unsafe.Pointer(v10)).Fvalue<<libc.Int32FromInt32(BITS)
 					**(**int32)(__ccgo_up(v10 + 12)) += int32(BITS)
 				} else {
 					VP8LoadFinalBytes(tls, v10)
 				}
 			}
 			pos = (*VP8BitReader)(unsafe.Pointer(v9)).Fbits
 			split = range1 * libc.Uint32FromInt32(libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(p + uintptr(int32(9)+bit1))))) >> int32(8)
 			value = uint32((*VP8BitReader)(unsafe.Pointer(v9)).Fvalue >> pos)
 			bit = libc.BoolInt32(value > split)
 			if bit != 0 {
 				range1 = range1 - split
 				**(**bit_t)(__ccgo_up(v9)) -= uint64(split+libc.Uint32FromInt32(1)) << pos
 			} else {
 				range1 = split + uint32(1)
 			}
 			v13 = int32(31) ^ libc.X__builtin_clz(tls, range1)
 			goto _78
 		_78:
 			shift = int32(7) ^ v13
 			range1 = range1 << libc.Uint32FromInt32(shift)
 			**(**int32)(__ccgo_up(v9 + 12)) -= shift
 			(*VP8BitReader)(unsafe.Pointer(v9)).Frange1 = range1 - uint32(1)
 			v15 = bit
 			goto _80
 		_80:
 			bit0 = v15
 			cat = int32(2)*bit1 + bit0
 			v = 0
 			tab = kCat3456[cat]
 			for {
 				if !(**(**uint8_t)(__ccgo_up(tab)) != 0) {
 					break
 				}
 				v1 = br2
 				range1 = (*VP8BitReader)(unsafe.Pointer(v1)).Frange1
 				if (*VP8BitReader)(unsafe.Pointer(v1)).Fbits < libc.Int32FromInt32(0) {
 					v2 = v1
 					if (*VP8BitReader)(unsafe.Pointer(v2)).Fbuf < (*VP8BitReader)(unsafe.Pointer(v2)).Fbuf_max {
 						libc.X__builtin___memcpy_chk(tls, bp, (*VP8BitReader)(unsafe.Pointer(v2)).Fbuf, uint64(8), ^__predefined_size_t(0))
 						**(**uintptr)(__ccgo_up(v2 + 16)) += uintptr(libc.Int32FromInt32(BITS) >> libc.Int32FromInt32(3))
 						v3 = uint64(libc.X__builtin_bswap64(tls, uint64(**(**lbit_t)(__ccgo_up(bp)))))
 						goto _85
 					_85:
 						bits = v3
 						bits = bits >> libc.Uint64FromInt32(libc.Int32FromInt32(64)-libc.Int32FromInt32(BITS))
 						(*VP8BitReader)(unsafe.Pointer(v2)).Fvalue = bits | (*VP8BitReader)(unsafe.Pointer(v2)).Fvalue<<libc.Int32FromInt32(BITS)
 						**(**int32)(__ccgo_up(v2 + 12)) += int32(BITS)
 					} else {
 						VP8LoadFinalBytes(tls, v2)
 					}
 				}
 				pos = (*VP8BitReader)(unsafe.Pointer(v1)).Fbits
 				split = range1 * libc.Uint32FromInt32(libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(tab)))) >> int32(8)
 				value = uint32((*VP8BitReader)(unsafe.Pointer(v1)).Fvalue >> pos)
 				bit = libc.BoolInt32(value > split)
 				if bit != 0 {
 					range1 = range1 - split
 					**(**bit_t)(__ccgo_up(v1)) -= uint64(split+libc.Uint32FromInt32(1)) << pos
 				} else {
 					range1 = split + uint32(1)
 				}
 				v5 = int32(31) ^ libc.X__builtin_clz(tls, range1)
 				goto _87
 			_87:
 				shift = int32(7) ^ v5
 				range1 = range1 << libc.Uint32FromInt32(shift)
 				**(**int32)(__ccgo_up(v1 + 12)) -= shift
 				(*VP8BitReader)(unsafe.Pointer(v1)).Frange1 = range1 - uint32(1)
 				v7 = bit
 				goto _89
 			_89:
 				v = v + (v + v7)
 				goto _81
 			_81:
 				;
 				tab = tab + 1
 			}
 			v = v + (int32(3) + int32(8)<<cat)
 		}
 	}
 	return v
 }
 
 // C documentation
 //
 //	// Returns the position of the last non-zero coeff plus one
 func GetCoeffsFast(tls *libc.TLS, br3 uintptr, prob1 uintptr, ctx int32, dq uintptr, n1 int32, out uintptr) (r int32) {
 	bp := tls.Alloc(16)
 	defer tls.Free(16)
 	var bit, pos, pos1, shift, v1, v14, v6, v8 int32
 	var bits bit_t
 	var mask int32_t
 	var p, p_ctx, v2, v3 uintptr
 	var range1, split, split1, value, value1 range_t
 	var v4 uint64_t
 	var _ /* in_bits at bp+0 */ lbit_t
 	_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = bit, bits, mask, p, p_ctx, pos, pos1, range1, shift, split, split1, v1, value, value1, v14, v2, v3, v4, v6, v8
 	p = **(**uintptr)(__ccgo_up(prob1 + uintptr(n1)*8)) + uintptr(ctx)*11
 	for {
 		if !(n1 < int32(16)) {
 			break
 		}
 		v2 = br3
 		range1 = (*VP8BitReader)(unsafe.Pointer(v2)).Frange1
 		if (*VP8BitReader)(unsafe.Pointer(v2)).Fbits < libc.Int32FromInt32(0) {
 			v3 = v2
 			if (*VP8BitReader)(unsafe.Pointer(v3)).Fbuf < (*VP8BitReader)(unsafe.Pointer(v3)).Fbuf_max {
 				libc.X__builtin___memcpy_chk(tls, bp, (*VP8BitReader)(unsafe.Pointer(v3)).Fbuf, uint64(8), ^__predefined_size_t(0))
 				**(**uintptr)(__ccgo_up(v3 + 16)) += uintptr(libc.Int32FromInt32(BITS) >> libc.Int32FromInt32(3))
 				v4 = uint64(libc.X__builtin_bswap64(tls, uint64(**(**lbit_t)(__ccgo_up(bp)))))
 				goto _5
 			_5:
 				bits = v4
 				bits = bits >> libc.Uint64FromInt32(libc.Int32FromInt32(64)-libc.Int32FromInt32(BITS))
 				(*VP8BitReader)(unsafe.Pointer(v3)).Fvalue = bits | (*VP8BitReader)(unsafe.Pointer(v3)).Fvalue<<libc.Int32FromInt32(BITS)
 				**(**int32)(__ccgo_up(v3 + 12)) += int32(BITS)
 			} else {
 				VP8LoadFinalBytes(tls, v3)
 			}
 		}
 		pos = (*VP8BitReader)(unsafe.Pointer(v2)).Fbits
 		split = range1 * libc.Uint32FromInt32(libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(p)))) >> int32(8)
 		value = uint32((*VP8BitReader)(unsafe.Pointer(v2)).Fvalue >> pos)
 		bit = libc.BoolInt32(value > split)
 		if bit != 0 {
 			range1 = range1 - split
 			**(**bit_t)(__ccgo_up(v2)) -= uint64(split+libc.Uint32FromInt32(1)) << pos
 		} else {
 			range1 = split + uint32(1)
 		}
 		v6 = int32(31) ^ libc.X__builtin_clz(tls, range1)
 		goto _7
 	_7:
 		shift = int32(7) ^ v6
 		range1 = range1 << libc.Uint32FromInt32(shift)
 		**(**int32)(__ccgo_up(v2 + 12)) -= shift
 		(*VP8BitReader)(unsafe.Pointer(v2)).Frange1 = range1 - uint32(1)
 		v8 = bit
 		goto _9
 	_9:
 		if !(v8 != 0) {
 			return n1 // previous coeff was last non-zero coeff
 		}
 		for {
 			v2 = br3
 			range1 = (*VP8BitReader)(unsafe.Pointer(v2)).Frange1
 			if (*VP8BitReader)(unsafe.Pointer(v2)).Fbits < libc.Int32FromInt32(0) {
 				v3 = v2
 				if (*VP8BitReader)(unsafe.Pointer(v3)).Fbuf < (*VP8BitReader)(unsafe.Pointer(v3)).Fbuf_max {
 					libc.X__builtin___memcpy_chk(tls, bp, (*VP8BitReader)(unsafe.Pointer(v3)).Fbuf, uint64(8), ^__predefined_size_t(0))
 					**(**uintptr)(__ccgo_up(v3 + 16)) += uintptr(libc.Int32FromInt32(BITS) >> libc.Int32FromInt32(3))
 					v4 = uint64(libc.X__builtin_bswap64(tls, uint64(**(**lbit_t)(__ccgo_up(bp)))))
 					goto _13
 				_13:
 					bits = v4
 					bits = bits >> libc.Uint64FromInt32(libc.Int32FromInt32(64)-libc.Int32FromInt32(BITS))
 					(*VP8BitReader)(unsafe.Pointer(v3)).Fvalue = bits | (*VP8BitReader)(unsafe.Pointer(v3)).Fvalue<<libc.Int32FromInt32(BITS)
 					**(**int32)(__ccgo_up(v3 + 12)) += int32(BITS)
 				} else {
 					VP8LoadFinalBytes(tls, v3)
 				}
 			}
 			pos = (*VP8BitReader)(unsafe.Pointer(v2)).Fbits
 			split = range1 * libc.Uint32FromInt32(libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(p + 1)))) >> int32(8)
 			value = uint32((*VP8BitReader)(unsafe.Pointer(v2)).Fvalue >> pos)
 			bit = libc.BoolInt32(value > split)
 			if bit != 0 {
 				range1 = range1 - split
 				**(**bit_t)(__ccgo_up(v2)) -= uint64(split+libc.Uint32FromInt32(1)) << pos
 			} else {
 				range1 = split + uint32(1)
 			}
 			v6 = int32(31) ^ libc.X__builtin_clz(tls, range1)
 			goto _15
 		_15:
 			shift = int32(7) ^ v6
 			range1 = range1 << libc.Uint32FromInt32(shift)
 			**(**int32)(__ccgo_up(v2 + 12)) -= shift
 			(*VP8BitReader)(unsafe.Pointer(v2)).Frange1 = range1 - uint32(1)
 			v8 = bit
 			goto _17
 		_17:
 			if !!(v8 != 0) {
 				break
 			} // sequence of zero coeffs
 			n1 = n1 + 1
 			v14 = n1
 			p = **(**uintptr)(__ccgo_up(prob1 + uintptr(v14)*8))
 			if n1 == int32(16) {
 				return int32(16)
 			}
 		}
 		// non zero coeff
 		p_ctx = **(**uintptr)(__ccgo_up(prob1 + uintptr(n1+int32(1))*8))
 		v2 = br3
 		range1 = (*VP8BitReader)(unsafe.Pointer(v2)).Frange1
 		if (*VP8BitReader)(unsafe.Pointer(v2)).Fbits < libc.Int32FromInt32(0) {
 			v3 = v2
 			if (*VP8BitReader)(unsafe.Pointer(v3)).Fbuf < (*VP8BitReader)(unsafe.Pointer(v3)).Fbuf_max {
 				libc.X__builtin___memcpy_chk(tls, bp, (*VP8BitReader)(unsafe.Pointer(v3)).Fbuf, uint64(8), ^__predefined_size_t(0))
 				**(**uintptr)(__ccgo_up(v3 + 16)) += uintptr(libc.Int32FromInt32(BITS) >> libc.Int32FromInt32(3))
 				v4 = uint64(libc.X__builtin_bswap64(tls, uint64(**(**lbit_t)(__ccgo_up(bp)))))
 				goto _22
 			_22:
 				bits = v4
 				bits = bits >> libc.Uint64FromInt32(libc.Int32FromInt32(64)-libc.Int32FromInt32(BITS))
 				(*VP8BitReader)(unsafe.Pointer(v3)).Fvalue = bits | (*VP8BitReader)(unsafe.Pointer(v3)).Fvalue<<libc.Int32FromInt32(BITS)
 				**(**int32)(__ccgo_up(v3 + 12)) += int32(BITS)
 			} else {
 				VP8LoadFinalBytes(tls, v3)
 			}
 		}
 		pos = (*VP8BitReader)(unsafe.Pointer(v2)).Fbits
 		split = range1 * libc.Uint32FromInt32(libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(p + 2)))) >> int32(8)
 		value = uint32((*VP8BitReader)(unsafe.Pointer(v2)).Fvalue >> pos)
 		bit = libc.BoolInt32(value > split)
 		if bit != 0 {
 			range1 = range1 - split
 			**(**bit_t)(__ccgo_up(v2)) -= uint64(split+libc.Uint32FromInt32(1)) << pos
 		} else {
 			range1 = split + uint32(1)
 		}
 		v6 = int32(31) ^ libc.X__builtin_clz(tls, range1)
 		goto _24
 	_24:
 		shift = int32(7) ^ v6
 		range1 = range1 << libc.Uint32FromInt32(shift)
 		**(**int32)(__ccgo_up(v2 + 12)) -= shift
 		(*VP8BitReader)(unsafe.Pointer(v2)).Frange1 = range1 - uint32(1)
 		v8 = bit
 		goto _26
 	_26:
 		if !(v8 != 0) {
 			v1 = int32(1)
 			p = p_ctx + 1*11
 		} else {
 			v1 = GetLargeValue(tls, br3, p)
 			p = p_ctx + 2*11
 		}
 		v2 = br3
 		if (*VP8BitReader)(unsafe.Pointer(v2)).Fbits < libc.Int32FromInt32(0) {
 			v3 = v2
 			if (*VP8BitReader)(unsafe.Pointer(v3)).Fbuf < (*VP8BitReader)(unsafe.Pointer(v3)).Fbuf_max {
 				libc.X__builtin___memcpy_chk(tls, bp, (*VP8BitReader)(unsafe.Pointer(v3)).Fbuf, uint64(8), ^__predefined_size_t(0))
 				**(**uintptr)(__ccgo_up(v3 + 16)) += uintptr(libc.Int32FromInt32(BITS) >> libc.Int32FromInt32(3))
 				v4 = uint64(libc.X__builtin_bswap64(tls, uint64(**(**lbit_t)(__ccgo_up(bp)))))
 				goto _30
 			_30:
 				bits = v4
 				bits = bits >> libc.Uint64FromInt32(libc.Int32FromInt32(64)-libc.Int32FromInt32(BITS))
 				(*VP8BitReader)(unsafe.Pointer(v3)).Fvalue = bits | (*VP8BitReader)(unsafe.Pointer(v3)).Fvalue<<libc.Int32FromInt32(BITS)
 				**(**int32)(__ccgo_up(v3 + 12)) += int32(BITS)
 			} else {
 				VP8LoadFinalBytes(tls, v3)
 			}
 		}
 		pos1 = (*VP8BitReader)(unsafe.Pointer(v2)).Fbits
 		split1 = (*VP8BitReader)(unsafe.Pointer(v2)).Frange1 >> int32(1)
 		value1 = uint32((*VP8BitReader)(unsafe.Pointer(v2)).Fvalue >> pos1)
 		mask = libc.Int32FromUint32(split1-value1) >> int32(31)
 		**(**int32)(__ccgo_up(v2 + 12)) -= int32(1)
 		**(**range_t)(__ccgo_up(v2 + 8)) += libc.Uint32FromInt32(mask)
 		**(**range_t)(__ccgo_up(v2 + 8)) |= uint32(1)
 		**(**bit_t)(__ccgo_up(v2)) -= uint64((split1+libc.Uint32FromInt32(1))&libc.Uint32FromInt32(mask)) << pos1
 		v6 = v1 ^ mask - mask
 		goto _32
 	_32:
 		**(**int16_t)(__ccgo_up(out + uintptr(kZigzag[n1])*2)) = int16(v6 * **(**int32)(__ccgo_up(dq + libc.BoolUintptr(n1 > 0)*4)))
 		goto _1
 	_1:
 		;
 		n1 = n1 + 1
 	}
 	return int32(16)
 }
 
 // C documentation
 //
 //	// This version of GetCoeffs() uses VP8GetBitAlt() which is an alternate version
 //	// of VP8GetBitAlt() targeting specific platforms.
 func GetCoeffsAlt(tls *libc.TLS, br3 uintptr, prob1 uintptr, ctx int32, dq uintptr, n int32, out uintptr) (r int32) {
 	bp := tls.Alloc(16)
 	defer tls.Free(16)
 	var bit, pos, pos1, shift, v1, v12, v6 int32
 	var bits bit_t
 	var mask int32_t
 	var p, p_ctx, v2, v3 uintptr
 	var range1, split, split1, value, value1 range_t
 	var v4 uint64_t
 	var _ /* in_bits at bp+0 */ lbit_t
 	_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = bit, bits, mask, p, p_ctx, pos, pos1, range1, shift, split, split1, v1, value, value1, v12, v2, v3, v4, v6
 	p = **(**uintptr)(__ccgo_up(prob1 + uintptr(n)*8)) + uintptr(ctx)*11
 	for {
 		if !(n < int32(16)) {
 			break
 		}
 		v2 = br3
 		range1 = (*VP8BitReader)(unsafe.Pointer(v2)).Frange1
 		if (*VP8BitReader)(unsafe.Pointer(v2)).Fbits < libc.Int32FromInt32(0) {
 			v3 = v2
 			if (*VP8BitReader)(unsafe.Pointer(v3)).Fbuf < (*VP8BitReader)(unsafe.Pointer(v3)).Fbuf_max {
 				libc.X__builtin___memcpy_chk(tls, bp, (*VP8BitReader)(unsafe.Pointer(v3)).Fbuf, uint64(8), ^__predefined_size_t(0))
 				**(**uintptr)(__ccgo_up(v3 + 16)) += uintptr(libc.Int32FromInt32(BITS) >> libc.Int32FromInt32(3))
 				v4 = uint64(libc.X__builtin_bswap64(tls, uint64(**(**lbit_t)(__ccgo_up(bp)))))
 				goto _5
 			_5:
 				bits = v4
 				bits = bits >> libc.Uint64FromInt32(libc.Int32FromInt32(64)-libc.Int32FromInt32(BITS))
 				(*VP8BitReader)(unsafe.Pointer(v3)).Fvalue = bits | (*VP8BitReader)(unsafe.Pointer(v3)).Fvalue<<libc.Int32FromInt32(BITS)
 				**(**int32)(__ccgo_up(v3 + 12)) += int32(BITS)
 			} else {
 				VP8LoadFinalBytes(tls, v3)
 			}
 		}
 		pos1 = (*VP8BitReader)(unsafe.Pointer(v2)).Fbits
 		split1 = range1 * libc.Uint32FromInt32(libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(p)))) >> int32(8)
 		value1 = uint32((*VP8BitReader)(unsafe.Pointer(v2)).Fvalue >> pos1)
 		if value1 > split1 {
 			range1 = range1 - (split1 + uint32(1))
 			**(**bit_t)(__ccgo_up(v2)) -= uint64(split1+libc.Uint32FromInt32(1)) << pos1
 			bit = int32(1)
 		} else {
 			range1 = split1
 			bit = 0
 		}
 		if range1 <= libc.Uint32FromInt32(0x7e) {
 			shift = libc.Int32FromUint8(kVP8Log2Range[range1])
 			range1 = uint32(kVP8NewRange[range1])
 			**(**int32)(__ccgo_up(v2 + 12)) -= shift
 		}
 		(*VP8BitReader)(unsafe.Pointer(v2)).Frange1 = range1
 		v6 = bit
 		goto _7
 	_7:
 		if !(v6 != 0) {
 			return n // previous coeff was last non-zero coeff
 		}
 		for {
 			v2 = br3
 			range1 = (*VP8BitReader)(unsafe.Pointer(v2)).Frange1
 			if (*VP8BitReader)(unsafe.Pointer(v2)).Fbits < libc.Int32FromInt32(0) {
 				v3 = v2
 				if (*VP8BitReader)(unsafe.Pointer(v3)).Fbuf < (*VP8BitReader)(unsafe.Pointer(v3)).Fbuf_max {
 					libc.X__builtin___memcpy_chk(tls, bp, (*VP8BitReader)(unsafe.Pointer(v3)).Fbuf, uint64(8), ^__predefined_size_t(0))
 					**(**uintptr)(__ccgo_up(v3 + 16)) += uintptr(libc.Int32FromInt32(BITS) >> libc.Int32FromInt32(3))
 					v4 = uint64(libc.X__builtin_bswap64(tls, uint64(**(**lbit_t)(__ccgo_up(bp)))))
 					goto _11
 				_11:
 					bits = v4
 					bits = bits >> libc.Uint64FromInt32(libc.Int32FromInt32(64)-libc.Int32FromInt32(BITS))
 					(*VP8BitReader)(unsafe.Pointer(v3)).Fvalue = bits | (*VP8BitReader)(unsafe.Pointer(v3)).Fvalue<<libc.Int32FromInt32(BITS)
 					**(**int32)(__ccgo_up(v3 + 12)) += int32(BITS)
 				} else {
 					VP8LoadFinalBytes(tls, v3)
 				}
 			}
 			pos1 = (*VP8BitReader)(unsafe.Pointer(v2)).Fbits
 			split1 = range1 * libc.Uint32FromInt32(libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(p + 1)))) >> int32(8)
 			value1 = uint32((*VP8BitReader)(unsafe.Pointer(v2)).Fvalue >> pos1)
 			if value1 > split1 {
 				range1 = range1 - (split1 + uint32(1))
 				**(**bit_t)(__ccgo_up(v2)) -= uint64(split1+libc.Uint32FromInt32(1)) << pos1
 				bit = int32(1)
 			} else {
 				range1 = split1
 				bit = 0
 			}
 			if range1 <= libc.Uint32FromInt32(0x7e) {
 				shift = libc.Int32FromUint8(kVP8Log2Range[range1])
 				range1 = uint32(kVP8NewRange[range1])
 				**(**int32)(__ccgo_up(v2 + 12)) -= shift
 			}
 			(*VP8BitReader)(unsafe.Pointer(v2)).Frange1 = range1
 			v6 = bit
 			goto _13
 		_13:
 			if !!(v6 != 0) {
 				break
 			} // sequence of zero coeffs
 			n = n + 1
 			v12 = n
 			p = **(**uintptr)(__ccgo_up(prob1 + uintptr(v12)*8))
 			if n == int32(16) {
 				return int32(16)
 			}
 		}
 		// non zero coeff
 		p_ctx = **(**uintptr)(__ccgo_up(prob1 + uintptr(n+int32(1))*8))
 		v2 = br3
 		range1 = (*VP8BitReader)(unsafe.Pointer(v2)).Frange1
 		if (*VP8BitReader)(unsafe.Pointer(v2)).Fbits < libc.Int32FromInt32(0) {
 			v3 = v2
 			if (*VP8BitReader)(unsafe.Pointer(v3)).Fbuf < (*VP8BitReader)(unsafe.Pointer(v3)).Fbuf_max {
 				libc.X__builtin___memcpy_chk(tls, bp, (*VP8BitReader)(unsafe.Pointer(v3)).Fbuf, uint64(8), ^__predefined_size_t(0))
 				**(**uintptr)(__ccgo_up(v3 + 16)) += uintptr(libc.Int32FromInt32(BITS) >> libc.Int32FromInt32(3))
 				v4 = uint64(libc.X__builtin_bswap64(tls, uint64(**(**lbit_t)(__ccgo_up(bp)))))
 				goto _18
 			_18:
 				bits = v4
 				bits = bits >> libc.Uint64FromInt32(libc.Int32FromInt32(64)-libc.Int32FromInt32(BITS))
 				(*VP8BitReader)(unsafe.Pointer(v3)).Fvalue = bits | (*VP8BitReader)(unsafe.Pointer(v3)).Fvalue<<libc.Int32FromInt32(BITS)
 				**(**int32)(__ccgo_up(v3 + 12)) += int32(BITS)
 			} else {
 				VP8LoadFinalBytes(tls, v3)
 			}
 		}
 		pos1 = (*VP8BitReader)(unsafe.Pointer(v2)).Fbits
 		split1 = range1 * libc.Uint32FromInt32(libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(p + 2)))) >> int32(8)
 		value1 = uint32((*VP8BitReader)(unsafe.Pointer(v2)).Fvalue >> pos1)
 		if value1 > split1 {
 			range1 = range1 - (split1 + uint32(1))
 			**(**bit_t)(__ccgo_up(v2)) -= uint64(split1+libc.Uint32FromInt32(1)) << pos1
 			bit = int32(1)
 		} else {
 			range1 = split1
 			bit = 0
 		}
 		if range1 <= libc.Uint32FromInt32(0x7e) {
 			shift = libc.Int32FromUint8(kVP8Log2Range[range1])
 			range1 = uint32(kVP8NewRange[range1])
 			**(**int32)(__ccgo_up(v2 + 12)) -= shift
 		}
 		(*VP8BitReader)(unsafe.Pointer(v2)).Frange1 = range1
 		v6 = bit
 		goto _20
 	_20:
 		if !(v6 != 0) {
 			v1 = int32(1)
 			p = p_ctx + 1*11
 		} else {
 			v1 = GetLargeValue(tls, br3, p)
 			p = p_ctx + 2*11
 		}
 		v2 = br3
 		if (*VP8BitReader)(unsafe.Pointer(v2)).Fbits < libc.Int32FromInt32(0) {
 			v3 = v2
 			if (*VP8BitReader)(unsafe.Pointer(v3)).Fbuf < (*VP8BitReader)(unsafe.Pointer(v3)).Fbuf_max {
 				libc.X__builtin___memcpy_chk(tls, bp, (*VP8BitReader)(unsafe.Pointer(v3)).Fbuf, uint64(8), ^__predefined_size_t(0))
 				**(**uintptr)(__ccgo_up(v3 + 16)) += uintptr(libc.Int32FromInt32(BITS) >> libc.Int32FromInt32(3))
 				v4 = uint64(libc.X__builtin_bswap64(tls, uint64(**(**lbit_t)(__ccgo_up(bp)))))
 				goto _24
 			_24:
 				bits = v4
 				bits = bits >> libc.Uint64FromInt32(libc.Int32FromInt32(64)-libc.Int32FromInt32(BITS))
 				(*VP8BitReader)(unsafe.Pointer(v3)).Fvalue = bits | (*VP8BitReader)(unsafe.Pointer(v3)).Fvalue<<libc.Int32FromInt32(BITS)
 				**(**int32)(__ccgo_up(v3 + 12)) += int32(BITS)
 			} else {
 				VP8LoadFinalBytes(tls, v3)
 			}
 		}
 		pos = (*VP8BitReader)(unsafe.Pointer(v2)).Fbits
 		split = (*VP8BitReader)(unsafe.Pointer(v2)).Frange1 >> int32(1)
 		value = uint32((*VP8BitReader)(unsafe.Pointer(v2)).Fvalue >> pos)
 		mask = libc.Int32FromUint32(split-value) >> int32(31)
 		**(**int32)(__ccgo_up(v2 + 12)) -= int32(1)
 		**(**range_t)(__ccgo_up(v2 + 8)) += libc.Uint32FromInt32(mask)
 		**(**range_t)(__ccgo_up(v2 + 8)) |= uint32(1)
 		**(**bit_t)(__ccgo_up(v2)) -= uint64((split+libc.Uint32FromInt32(1))&libc.Uint32FromInt32(mask)) << pos
 		v6 = v1 ^ mask - mask
 		goto _26
 	_26:
 		**(**int16_t)(__ccgo_up(out + uintptr(kZigzag[n])*2)) = int16(v6 * **(**int32)(__ccgo_up(dq + libc.BoolUintptr(n > 0)*4)))
 		goto _1
 	_1:
 		;
 		n = n + 1
 	}
 	return int32(16)
 }
 
 func InitGetCoeffs(tls *libc.TLS) {
 	if libc.AtomicLoadPUintptr(uintptr(unsafe.Pointer(&InitGetCoeffs_body_last_cpuinfo_used))) == VP8GetCPUInfo {
 		goto _1
 	}
 	InitGetCoeffs_body(tls)
 	libc.AtomicStorePUintptr(uintptr(unsafe.Pointer(&InitGetCoeffs_body_last_cpuinfo_used)), VP8GetCPUInfo)
 	goto _2
 _2:
 	;
 	goto _1
 _1: /**/ //
 }
 
 var InitGetCoeffs_body_last_cpuinfo_used = uintptr(0)
 
 func init() {
 	p := unsafe.Pointer(&InitGetCoeffs_body_last_cpuinfo_used)
 	*(*uintptr)(unsafe.Add(p, 0)) = uintptr(unsafe.Pointer(&InitGetCoeffs_body_last_cpuinfo_used))
 }
 
 func InitGetCoeffs_body(tls *libc.TLS) {
 	if VP8GetCPUInfo != libc.UintptrFromInt32(0) && (*(*func(*libc.TLS, CPUFeature) int32)(unsafe.Pointer(&struct{ uintptr }{VP8GetCPUInfo})))(tls, int32(kSlowSSSE3)) != 0 {
 		GetCoeffs = __ccgo_fp(GetCoeffsAlt)
 	} else {
 		GetCoeffs = __ccgo_fp(GetCoeffsFast)
 	}
 }
 
 func NzCodeBits(tls *libc.TLS, nz_coeffs uint32_t, nz int32, dc_nz int32) (r uint32_t) {
 	var v1, v2 int32
 	_, _ = v1, v2
 	nz_coeffs = nz_coeffs << uint32(2)
 	if nz > int32(3) {
 		v1 = int32(3)
 	} else {
 		if nz > int32(1) {
 			v2 = int32(2)
 		} else {
 			v2 = dc_nz
 		}
 		v1 = v2
 	}
 	nz_coeffs = nz_coeffs | libc.Uint32FromInt32(v1)
 	return nz_coeffs
 }
 
 func ParseResiduals(tls *libc.TLS, dec uintptr, mb uintptr, token_br uintptr) (r int32) {
 	bp := tls.Alloc(32)
 	defer tls.Free(32)
 	var ac_proba, bands, block, dst, left_mb, q uintptr
 	var ch, ctx, ctx1, ctx2, dc0, first, i, l, l1, nz, nz1, nz2, x, y, v8 int32
 	var lnz, tnz, v1 uint8_t
 	var non_zero_uv, non_zero_y, nz_coeffs, nz_coeffs1, out_l_nz, out_t_nz uint32_t
 	var _ /* dc at bp+0 */ [16]int16_t
 	_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = ac_proba, bands, block, ch, ctx, ctx1, ctx2, dc0, dst, first, i, l, l1, left_mb, lnz, non_zero_uv, non_zero_y, nz, nz1, nz2, nz_coeffs, nz_coeffs1, out_l_nz, out_t_nz, q, tnz, x, y, v1, v8
 	bands = dec + 1192 + 1064
 	block = (*VP8Decoder)(unsafe.Pointer(dec)).Fmb_data + uintptr((*VP8Decoder)(unsafe.Pointer(dec)).Fmb_x)*800
 	q = dec + 1060 + uintptr((*VP8MBData)(unsafe.Pointer(block)).Fsegment)*32
 	dst = block
 	left_mb = (*VP8Decoder)(unsafe.Pointer(dec)).Fmb_info - uintptr(1)*2
 	non_zero_y = uint32(0)
 	non_zero_uv = uint32(0)
 	libc.X__builtin___memset_chk(tls, dst, 0, libc.Uint64FromInt32(384)*libc.Uint64FromInt64(2), ^__predefined_size_t(0))
 	if !((*VP8MBData)(unsafe.Pointer(block)).Fis_i4x4 != 0) { // parse DC
 		**(**[16]int16_t)(__ccgo_up(bp)) = [16]int16_t{}
 		ctx = libc.Int32FromUint8((*VP8MB)(unsafe.Pointer(mb)).Fnz_dc) + libc.Int32FromUint8((*VP8MB)(unsafe.Pointer(left_mb)).Fnz_dc)
 		nz = (*(*func(*libc.TLS, uintptr, uintptr, int32, uintptr, int32, uintptr) int32)(unsafe.Pointer(&struct{ uintptr }{GetCoeffs})))(tls, token_br, bands+1*136, ctx, q+8, 0, bp)
 		v1 = libc.BoolUint8(nz > libc.Int32FromInt32(0))
 		(*VP8MB)(unsafe.Pointer(left_mb)).Fnz_dc = v1
 		(*VP8MB)(unsafe.Pointer(mb)).Fnz_dc = v1
 		if nz > int32(1) { // more than just the DC -> perform the full transform
 			(*(*func(*libc.TLS, uintptr, uintptr))(unsafe.Pointer(&struct{ uintptr }{VP8TransformWHT})))(tls, bp, dst)
 		} else {
 			dc0 = (int32((**(**[16]int16_t)(__ccgo_up(bp)))[0]) + int32(3)) >> int32(3)
 			i = 0
 			for {
 				if !(i < libc.Int32FromInt32(16)*libc.Int32FromInt32(16)) {
 					break
 				}
 				**(**int16_t)(__ccgo_up(dst + uintptr(i)*2)) = int16(dc0)
 				goto _2
 			_2:
 				;
 				i = i + int32(16)
 			}
 		}
 		first = int32(1)
 		ac_proba = bands
 	} else {
 		first = 0
 		ac_proba = bands + 3*136
 	}
 	tnz = libc.Uint8FromInt32(libc.Int32FromUint8((*VP8MB)(unsafe.Pointer(mb)).Fnz) & int32(0x0f))
 	lnz = libc.Uint8FromInt32(libc.Int32FromUint8((*VP8MB)(unsafe.Pointer(left_mb)).Fnz) & int32(0x0f))
 	y = 0
 	for {
 		if !(y < int32(4)) {
 			break
 		}
 		l = libc.Int32FromUint8(lnz) & int32(1)
 		nz_coeffs = uint32(0)
 		x = 0
 		for {
 			if !(x < int32(4)) {
 				break
 			}
 			ctx1 = l + libc.Int32FromUint8(tnz)&int32(1)
 			nz1 = (*(*func(*libc.TLS, uintptr, uintptr, int32, uintptr, int32, uintptr) int32)(unsafe.Pointer(&struct{ uintptr }{GetCoeffs})))(tls, token_br, ac_proba, ctx1, q, first, dst)
 			l = libc.BoolInt32(nz1 > first)
 			tnz = libc.Uint8FromInt32(libc.Int32FromUint8(tnz)>>int32(1) | l<<int32(7))
 			nz_coeffs = NzCodeBits(tls, nz_coeffs, nz1, libc.BoolInt32(int32(**(**int16_t)(__ccgo_up(dst))) != 0))
 			dst = dst + uintptr(16)*2
 			goto _4
 		_4:
 			;
 			x = x + 1
 		}
 		tnz = libc.Uint8FromInt32(int32(tnz) >> libc.Int32FromInt32(4))
 		lnz = libc.Uint8FromInt32(libc.Int32FromUint8(lnz)>>int32(1) | l<<int32(7))
 		non_zero_y = non_zero_y<<libc.Int32FromInt32(8) | nz_coeffs
 		goto _3
 	_3:
 		;
 		y = y + 1
 	}
 	out_t_nz = uint32(tnz)
 	out_l_nz = libc.Uint32FromInt32(libc.Int32FromUint8(lnz) >> int32(4))
 	ch = 0
 	for {
 		if !(ch < int32(4)) {
 			break
 		}
 		nz_coeffs1 = uint32(0)
 		tnz = libc.Uint8FromInt32(libc.Int32FromUint8((*VP8MB)(unsafe.Pointer(mb)).Fnz) >> (int32(4) + ch))
 		lnz = libc.Uint8FromInt32(libc.Int32FromUint8((*VP8MB)(unsafe.Pointer(left_mb)).Fnz) >> (int32(4) + ch))
 		y = 0
 		for {
 			if !(y < int32(2)) {
 				break
 			}
 			l1 = libc.Int32FromUint8(lnz) & int32(1)
 			x = 0
 			for {
 				if !(x < int32(2)) {
 					break
 				}
 				ctx2 = l1 + libc.Int32FromUint8(tnz)&int32(1)
 				nz2 = (*(*func(*libc.TLS, uintptr, uintptr, int32, uintptr, int32, uintptr) int32)(unsafe.Pointer(&struct{ uintptr }{GetCoeffs})))(tls, token_br, bands+2*136, ctx2, q+16, 0, dst)
 				l1 = libc.BoolInt32(nz2 > 0)
 				tnz = libc.Uint8FromInt32(libc.Int32FromUint8(tnz)>>int32(1) | l1<<int32(3))
 				nz_coeffs1 = NzCodeBits(tls, nz_coeffs1, nz2, libc.BoolInt32(int32(**(**int16_t)(__ccgo_up(dst))) != 0))
 				dst = dst + uintptr(16)*2
 				goto _7
 			_7:
 				;
 				x = x + 1
 			}
 			tnz = libc.Uint8FromInt32(int32(tnz) >> libc.Int32FromInt32(2))
 			lnz = libc.Uint8FromInt32(libc.Int32FromUint8(lnz)>>int32(1) | l1<<int32(5))
 			goto _6
 		_6:
 			;
 			y = y + 1
 		}
 		// Note: we don't really need the per-4x4 details for U/V blocks.
 		non_zero_uv = non_zero_uv | nz_coeffs1<<(int32(4)*ch)
 		out_t_nz = out_t_nz | libc.Uint32FromInt32(libc.Int32FromUint8(tnz)<<int32(4)<<ch)
 		out_l_nz = out_l_nz | libc.Uint32FromInt32(libc.Int32FromUint8(lnz)&int32(0xf0)<<ch)
 		goto _5
 	_5:
 		;
 		ch = ch + int32(2)
 	}
 	(*VP8MB)(unsafe.Pointer(mb)).Fnz = uint8(out_t_nz)
 	(*VP8MB)(unsafe.Pointer(left_mb)).Fnz = uint8(out_l_nz)
 	(*VP8MBData)(unsafe.Pointer(block)).Fnon_zero_y = non_zero_y
 	(*VP8MBData)(unsafe.Pointer(block)).Fnon_zero_uv = non_zero_uv
 	// We look at the mode-code of each block and check if some blocks have less
 	// than three non-zero coeffs (code < 2). This is to avoid dithering flat and
 	// empty blocks.
 	if non_zero_uv&uint32(0xaaaa) != 0 {
 		v8 = 0
 	} else {
 		v8 = (*VP8QuantMatrix)(unsafe.Pointer(q)).Fdither
 	}
 	(*VP8MBData)(unsafe.Pointer(block)).Fdither = libc.Uint8FromInt32(v8)
 	return libc.BoolInt32(!(non_zero_y|non_zero_uv != 0)) // will be used for further optimization
 }
 
 //------------------------------------------------------------------------------
 // Main loop
 
 func VP8DecodeMB(tls *libc.TLS, dec uintptr, token_br uintptr) (r int32) {
 	var block, finfo, left, mb, v4 uintptr
 	var skip, v1 int32
 	var v2 uint8_t
 	_, _, _, _, _, _, _, _ = block, finfo, left, mb, skip, v1, v2, v4
 	left = (*VP8Decoder)(unsafe.Pointer(dec)).Fmb_info - uintptr(1)*2
 	mb = (*VP8Decoder)(unsafe.Pointer(dec)).Fmb_info + uintptr((*VP8Decoder)(unsafe.Pointer(dec)).Fmb_x)*2
 	block = (*VP8Decoder)(unsafe.Pointer(dec)).Fmb_data + uintptr((*VP8Decoder)(unsafe.Pointer(dec)).Fmb_x)*800
 	if (*VP8Decoder)(unsafe.Pointer(dec)).Fuse_skip_proba != 0 {
 		v1 = libc.Int32FromUint8((*VP8MBData)(unsafe.Pointer(block)).Fskip)
 	} else {
 		v1 = 0
 	}
 	skip = v1
 	if !(skip != 0) {
 		skip = ParseResiduals(tls, dec, mb, token_br)
 	} else {
 		v2 = libc.Uint8FromInt32(0)
 		(*VP8MB)(unsafe.Pointer(mb)).Fnz = v2
 		(*VP8MB)(unsafe.Pointer(left)).Fnz = v2
 		if !((*VP8MBData)(unsafe.Pointer(block)).Fis_i4x4 != 0) {
 			v2 = libc.Uint8FromInt32(0)
 			(*VP8MB)(unsafe.Pointer(mb)).Fnz_dc = v2
 			(*VP8MB)(unsafe.Pointer(left)).Fnz_dc = v2
 		}
 		(*VP8MBData)(unsafe.Pointer(block)).Fnon_zero_y = uint32(0)
 		(*VP8MBData)(unsafe.Pointer(block)).Fnon_zero_uv = uint32(0)
 		(*VP8MBData)(unsafe.Pointer(block)).Fdither = uint8(0)
 	}
 	if (*VP8Decoder)(unsafe.Pointer(dec)).Ffilter_type > 0 { // store filter info
 		finfo = (*VP8Decoder)(unsafe.Pointer(dec)).Ff_info + uintptr((*VP8Decoder)(unsafe.Pointer(dec)).Fmb_x)*4
 		**(**VP8FInfo)(__ccgo_up(finfo)) = **(**VP8FInfo)(__ccgo_up(dec + 2924 + uintptr((*VP8MBData)(unsafe.Pointer(block)).Fsegment)*8 + uintptr((*VP8MBData)(unsafe.Pointer(block)).Fis_i4x4)*4))
 		v4 = finfo + 2
 		*(*uint8_t)(unsafe.Pointer(v4)) = uint8_t(int32(*(*uint8_t)(unsafe.Pointer(v4))) | libc.BoolInt32(!(skip != 0)))
 	}
 	return libc.BoolInt32(!((*VP8BitReader)(unsafe.Pointer(token_br)).Feof != 0))
 }
 
 func VP8InitScanline(tls *libc.TLS, dec uintptr) {
 	var left uintptr
 	_ = left
 	left = (*VP8Decoder)(unsafe.Pointer(dec)).Fmb_info - uintptr(1)*2
 	(*VP8MB)(unsafe.Pointer(left)).Fnz = uint8(0)
 	(*VP8MB)(unsafe.Pointer(left)).Fnz_dc = uint8(0)
 	libc.X__builtin___memset_chk(tls, dec+2816, int32(B_DC_PRED), uint64(4), ^__predefined_size_t(0))
 	(*VP8Decoder)(unsafe.Pointer(dec)).Fmb_x = 0
 }
 
 func ParseFrame(tls *libc.TLS, dec uintptr, io uintptr) (r int32) {
 	var token_br uintptr
 	_ = token_br
 	(*VP8Decoder)(unsafe.Pointer(dec)).Fmb_y = 0
 	for {
 		if !((*VP8Decoder)(unsafe.Pointer(dec)).Fmb_y < (*VP8Decoder)(unsafe.Pointer(dec)).Fbr_mb_y) {
 			break
 		}
 		// Parse bitstream for this row.
 		token_br = dec + 440 + uintptr(libc.Uint32FromInt32((*VP8Decoder)(unsafe.Pointer(dec)).Fmb_y)&(*VP8Decoder)(unsafe.Pointer(dec)).Fnum_parts_minus_one)*48
 		if !(VP8ParseIntraModeRow(tls, dec+16, dec) != 0) {
 			return VP8SetError(tls, dec, int32(VP8_STATUS_NOT_ENOUGH_DATA), __ccgo_ts+435)
 		}
 		for {
 			if !((*VP8Decoder)(unsafe.Pointer(dec)).Fmb_x < (*VP8Decoder)(unsafe.Pointer(dec)).Fmb_w) {
 				break
 			}
 			if !(VP8DecodeMB(tls, dec, token_br) != 0) {
 				return VP8SetError(tls, dec, int32(VP8_STATUS_NOT_ENOUGH_DATA), __ccgo_ts+476)
 			}
 			goto _2
 		_2:
 			;
 			(*VP8Decoder)(unsafe.Pointer(dec)).Fmb_x = (*VP8Decoder)(unsafe.Pointer(dec)).Fmb_x + 1
 		}
 		VP8InitScanline(tls, dec) // Prepare for next scanline
 		// Reconstruct, filter and emit the row.
 		if !(VP8ProcessRow(tls, dec, io) != 0) {
 			return VP8SetError(tls, dec, int32(VP8_STATUS_USER_ABORT), __ccgo_ts+511)
 		}
 		goto _1
 	_1:
 		;
 		(*VP8Decoder)(unsafe.Pointer(dec)).Fmb_y = (*VP8Decoder)(unsafe.Pointer(dec)).Fmb_y + 1
 	}
 	if (*VP8Decoder)(unsafe.Pointer(dec)).Fmt_method > 0 {
 		if !((*(*func(*libc.TLS, uintptr) int32)(unsafe.Pointer(&struct{ uintptr }{(*WebPWorkerInterface)(unsafe.Pointer(WebPGetWorkerInterface(tls))).FSync})))(tls, dec+152) != 0) {
 			return 0
 		}
 	}
 	return int32(1)
 }
 
 // C documentation
 //
 //	// Main entry point
 func VP8Decode(tls *libc.TLS, dec uintptr, io uintptr) (r int32) {
 	var ok int32
 	_ = ok
 	ok = 0
 	if dec == libc.UintptrFromInt32(0) {
 		return 0
 	}
 	if io == libc.UintptrFromInt32(0) {
 		return VP8SetError(tls, dec, int32(VP8_STATUS_INVALID_PARAM), __ccgo_ts+527)
 	}
 	if !((*VP8Decoder)(unsafe.Pointer(dec)).Fready != 0) {
 		if !(VP8GetHeaders(tls, dec, io) != 0) {
 			return 0
 		}
 	}
 	// Finish setting up the decoding parameter. Will call io->setup().
 	ok = libc.BoolInt32(VP8EnterCritical(tls, dec, io) == int32(VP8_STATUS_OK))
 	if ok != 0 { // good to go.
 		// Will allocate memory and prepare everything.
 		if ok != 0 {
 			ok = VP8InitFrame(tls, dec, io)
 		}
 		// Main decoding loop
 		if ok != 0 {
 			ok = ParseFrame(tls, dec, io)
 		}
 		// Exit.
 		ok = ok & VP8ExitCritical(tls, dec, io)
 	}
 	if !(ok != 0) {
 		VP8Clear(tls, dec)
 		return 0
 	}
 	(*VP8Decoder)(unsafe.Pointer(dec)).Fready = 0
 	return ok
 }
 
 func VP8Clear(tls *libc.TLS, dec uintptr) {
 	if dec == libc.UintptrFromInt32(0) {
 		return
 	}
 	(*(*func(*libc.TLS, uintptr))(unsafe.Pointer(&struct{ uintptr }{(*WebPWorkerInterface)(unsafe.Pointer(WebPGetWorkerInterface(tls))).FEnd})))(tls, dec+152)
 	WebPDeallocateAlphaMemory(tls, dec)
 	WebPSafeFree(tls, (*VP8Decoder)(unsafe.Pointer(dec)).Fmem)
 	(*VP8Decoder)(unsafe.Pointer(dec)).Fmem = libc.UintptrFromInt32(0)
 	(*VP8Decoder)(unsafe.Pointer(dec)).Fmem_size = uint64(0)
 	libc.X__builtin___memset_chk(tls, dec+16, 0, uint64(48), ^__predefined_size_t(0))
 	(*VP8Decoder)(unsafe.Pointer(dec)).Fready = 0
 }
 
 const APPROX_LOG_MAX = 4096
 const APPROX_LOG_WITH_CORRECTION_MAX = 65536
 const BITS_SPECIAL_MARKER = 256
 const CODE_TO_PLANE_CODES = 120
 const LOG_2_PRECISION_BITS = 23
 const LOG_2_RECIPROCAL = 1.44269504088896338700465094007086
 const LOG_2_RECIPROCAL_FIXED_DOUBLE = 12102203.161561485379934310913085937500
 const LOG_LOOKUP_IDX_MAX = 256
 const NUM_ARGB_CACHE_ROWS = 16
 const NUM_CODE_LENGTH_CODES = 19
 const PACKED_NON_LITERAL_CODE = 0
 const PREFIX_LOOKUP_IDX_MAX = 512
 const SYNC_EVERY_N_ROWS = 8
 const VP8L_MAGIC_BYTE1 = 47
 
 var kHashMul8 = uint32(0x1e35a7bd)
 
 type VP8LPredictorFunc = uintptr
 
 type VP8LPredictorAddSubFunc = uintptr
 
 type VP8LProcessDecBlueAndRedFunc = uintptr
 
 type VP8LMultipliers = struct {
 	Fgreen_to_red  uint8_t
 	Fgreen_to_blue uint8_t
 	Fred_to_blue   uint8_t
 }
 
 type VP8LTransformColorInverseFunc = uintptr
 
 type VP8LConvertFunc = uintptr
 
 type VP8LMapARGBFunc = uintptr
 
 type VP8LMapAlphaFunc = uintptr
 
 type VP8LProcessEncBlueAndRedFunc = uintptr
 
 type VP8LTransformColorFunc = uintptr
 
 type VP8LCollectColorBlueTransformsFunc = uintptr
 
 type VP8LCollectColorRedTransformsFunc = uintptr
 
 type VP8LCostFunc = uintptr
 
 type VP8LCombinedShannonEntropyFunc = uintptr
 
 type VP8LShannonEntropyFunc = uintptr
 
 type VP8LStreaks = struct {
 	Fcounts  [2]int32
 	Fstreaks [2][2]int32
 }
 
 type VP8LBitEntropy = struct {
 	Fentropy      uint64_t
 	Fsum          uint32_t
 	Fnonzeros     int32
 	Fmax_val      uint32_t
 	Fnonzero_code uint32_t
 }
 
 type VP8LGetCombinedEntropyUnrefinedFunc = uintptr
 
 type VP8LGetEntropyUnrefinedFunc = uintptr
 
 type VP8LAddVectorFunc = uintptr
 
 type VP8LAddVectorEqFunc = uintptr
 
 type VP8LVectorMismatchFunc = uintptr
 
 type VP8LBundleColorMapFunc = uintptr
 
 type VP8LFastLog2SlowFunc = uintptr
 
 type VP8LFastSLog2SlowFunc = uintptr
 
 type VP8LPrefixCode = struct {
 	Fcode       int8_t
 	Fextra_bits int8_t
 }
 
 //------------------------------------------------------------------------------
 // Transform-related functions used in both encoding and decoding.
 
 // Macros used to create a batch predictor that iteratively uses a
 // one-pixel predictor.
 
 // The predictor is added to the output pixel (which
 // is therefore considered as a residual) to get the final prediction.
 
 // Copyright 2010 Google Inc. All Rights Reserved.
 //
 // Use of this source code is governed by a BSD-style license
 // that can be found in the COPYING file in the root of the source
 // tree. An additional intellectual property rights grant can be found
 // in the file PATENTS. All contributing project authors may
 // be found in the AUTHORS file in the root of the source tree.
 // -----------------------------------------------------------------------------
 //
 // Boolean decoder
 //
 // Author: Skal (pascal.massimino@gmail.com)
 //         Vikas Arora (vikaas.arora@gmail.com)
 
 // Copyright 2012 Google Inc. All Rights Reserved.
 //
 // Use of this source code is governed by a BSD-style license
 // that can be found in the COPYING file in the root of the source
 // tree. An additional intellectual property rights grant can be found
 // in the file PATENTS. All contributing project authors may
 // be found in the AUTHORS file in the root of the source tree.
 // -----------------------------------------------------------------------------
 //
 // Color Cache for WebP Lossless
 //
 // Authors: Jyrki Alakuijala (jyrki@google.com)
 //          Urvang Joshi (urvang@google.com)
 
 // Copyright 2012 Google Inc. All Rights Reserved.
 //
 // Use of this source code is governed by a BSD-style license
 // that can be found in the COPYING file in the root of the source
 // tree. An additional intellectual property rights grant can be found
 // in the file PATENTS. All contributing project authors may
 // be found in the AUTHORS file in the root of the source tree.
 // -----------------------------------------------------------------------------
 //
 // Utilities for building and looking up Huffman trees.
 //
 // Author: Urvang Joshi (urvang@google.com)
 
 // Copyright 2012 Google Inc. All Rights Reserved.
 //
 // Use of this source code is governed by a BSD-style license
 // that can be found in the COPYING file in the root of the source
 // tree. An additional intellectual property rights grant can be found
 // in the file PATENTS. All contributing project authors may
 // be found in the AUTHORS file in the root of the source tree.
 // -----------------------------------------------------------------------------
 //
 // Rescaling functions
 //
 // Author: Skal (pascal.massimino@gmail.com)
 
 // Copyright 2012 Google Inc. All Rights Reserved.
 //
 // Use of this source code is governed by a BSD-style license
 // that can be found in the COPYING file in the root of the source
 // tree. An additional intellectual property rights grant can be found
 // in the file PATENTS. All contributing project authors may
 // be found in the AUTHORS file in the root of the source tree.
 // -----------------------------------------------------------------------------
 //
 // Misc. common utility functions
 //
 // Authors: Skal (pascal.massimino@gmail.com)
 //          Urvang (urvang@google.com)
 
 // Copyright 2010 Google Inc. All Rights Reserved.
 //
 // Use of this source code is governed by a BSD-style license
 // that can be found in the COPYING file in the root of the source
 // tree. An additional intellectual property rights grant can be found
 // in the file PATENTS. All contributing project authors may
 // be found in the AUTHORS file in the root of the source tree.
 // -----------------------------------------------------------------------------
 //
 //  Main decoding functions for WebP images.
 //
 // Author: Skal (pascal.massimino@gmail.com)
 
 // Copyright 2012 Google Inc. All Rights Reserved.
 //
 // Use of this source code is governed by a BSD-style license
 // that can be found in the COPYING file in the root of the source
 // tree. An additional intellectual property rights grant can be found
 // in the file PATENTS. All contributing project authors may
 // be found in the AUTHORS file in the root of the source tree.
 // -----------------------------------------------------------------------------
 //
 //  Internal header for constants related to WebP file format.
 //
 // Author: Urvang (urvang@google.com)
 
 // Copyright 2010 Google Inc. All Rights Reserved.
 //
 // Use of this source code is governed by a BSD-style license
 // that can be found in the COPYING file in the root of the source
 // tree. An additional intellectual property rights grant can be found
 // in the file PATENTS. All contributing project authors may
 // be found in the AUTHORS file in the root of the source tree.
 // -----------------------------------------------------------------------------
 //
 //  Common types + memory wrappers
 //
 // Author: Skal (pascal.massimino@gmail.com)
 
 var kCodeLengthLiterals = int32(16)
 var kCodeLengthRepeatCode = int32(16)
 var kCodeLengthExtraBits = [3]uint8_t{
 	0: uint8(2),
 	1: uint8(3),
 	2: uint8(7),
 }
 var kCodeLengthRepeatOffsets = [3]uint8_t{
 	0: uint8(3),
 	1: uint8(3),
 	2: uint8(11),
 }
 
 // C documentation
 //
 //	// -----------------------------------------------------------------------------
 //	//  Five Huffman codes are used at each meta code:
 //	//  1. green + length prefix codes + color cache codes,
 //	//  2. alpha,
 //	//  3. red,
 //	//  4. blue, and,
 //	//  5. distance prefix codes.
 type HuffIndex = int32
 
 const GREEN = 0
 const RED = 1
 const BLUE = 2
 const ALPHA = 3
 const DIST = 4
 
 var kAlphabetSize = [5]uint16_t{
 	0: libc.Uint16FromInt32(libc.Int32FromInt32(NUM_LITERAL_CODES) + libc.Int32FromInt32(NUM_LENGTH_CODES)),
 	1: uint16(NUM_LITERAL_CODES),
 	2: uint16(NUM_LITERAL_CODES),
 	3: uint16(NUM_LITERAL_CODES),
 	4: uint16(NUM_DISTANCE_CODES),
 }
 
 var kLiteralMap = [5]uint8_t{
 	1: uint8(1),
 	2: uint8(1),
 	3: uint8(1),
 }
 
 var kCodeLengthCodeOrder = [19]uint8_t{
 	0:  uint8(17),
 	1:  uint8(18),
 	3:  uint8(1),
 	4:  uint8(2),
 	5:  uint8(3),
 	6:  uint8(4),
 	7:  uint8(5),
 	8:  uint8(16),
 	9:  uint8(6),
 	10: uint8(7),
 	11: uint8(8),
 	12: uint8(9),
 	13: uint8(10),
 	14: uint8(11),
 	15: uint8(12),
 	16: uint8(13),
 	17: uint8(14),
 	18: uint8(15),
 }
 
 var kCodeToPlane = [120]uint8_t{
 	0:   uint8(0x18),
 	1:   uint8(0x07),
 	2:   uint8(0x17),
 	3:   uint8(0x19),
 	4:   uint8(0x28),
 	5:   uint8(0x06),
 	6:   uint8(0x27),
 	7:   uint8(0x29),
 	8:   uint8(0x16),
 	9:   uint8(0x1a),
 	10:  uint8(0x26),
 	11:  uint8(0x2a),
 	12:  uint8(0x38),
 	13:  uint8(0x05),
 	14:  uint8(0x37),
 	15:  uint8(0x39),
 	16:  uint8(0x15),
 	17:  uint8(0x1b),
 	18:  uint8(0x36),
 	19:  uint8(0x3a),
 	20:  uint8(0x25),
 	21:  uint8(0x2b),
 	22:  uint8(0x48),
 	23:  uint8(0x04),
 	24:  uint8(0x47),
 	25:  uint8(0x49),
 	26:  uint8(0x14),
 	27:  uint8(0x1c),
 	28:  uint8(0x35),
 	29:  uint8(0x3b),
 	30:  uint8(0x46),
 	31:  uint8(0x4a),
 	32:  uint8(0x24),
 	33:  uint8(0x2c),
 	34:  uint8(0x58),
 	35:  uint8(0x45),
 	36:  uint8(0x4b),
 	37:  uint8(0x34),
 	38:  uint8(0x3c),
 	39:  uint8(0x03),
 	40:  uint8(0x57),
 	41:  uint8(0x59),
 	42:  uint8(0x13),
 	43:  uint8(0x1d),
 	44:  uint8(0x56),
 	45:  uint8(0x5a),
 	46:  uint8(0x23),
 	47:  uint8(0x2d),
 	48:  uint8(0x44),
 	49:  uint8(0x4c),
 	50:  uint8(0x55),
 	51:  uint8(0x5b),
 	52:  uint8(0x33),
 	53:  uint8(0x3d),
 	54:  uint8(0x68),
 	55:  uint8(0x02),
 	56:  uint8(0x67),
 	57:  uint8(0x69),
 	58:  uint8(0x12),
 	59:  uint8(0x1e),
 	60:  uint8(0x66),
 	61:  uint8(0x6a),
 	62:  uint8(0x22),
 	63:  uint8(0x2e),
 	64:  uint8(0x54),
 	65:  uint8(0x5c),
 	66:  uint8(0x43),
 	67:  uint8(0x4d),
 	68:  uint8(0x65),
 	69:  uint8(0x6b),
 	70:  uint8(0x32),
 	71:  uint8(0x3e),
 	72:  uint8(0x78),
 	73:  uint8(0x01),
 	74:  uint8(0x77),
 	75:  uint8(0x79),
 	76:  uint8(0x53),
 	77:  uint8(0x5d),
 	78:  uint8(0x11),
 	79:  uint8(0x1f),
 	80:  uint8(0x64),
 	81:  uint8(0x6c),
 	82:  uint8(0x42),
 	83:  uint8(0x4e),
 	84:  uint8(0x76),
 	85:  uint8(0x7a),
 	86:  uint8(0x21),
 	87:  uint8(0x2f),
 	88:  uint8(0x75),
 	89:  uint8(0x7b),
 	90:  uint8(0x31),
 	91:  uint8(0x3f),
 	92:  uint8(0x63),
 	93:  uint8(0x6d),
 	94:  uint8(0x52),
 	95:  uint8(0x5e),
 	97:  uint8(0x74),
 	98:  uint8(0x7c),
 	99:  uint8(0x41),
 	100: uint8(0x4f),
 	101: uint8(0x10),
 	102: uint8(0x20),
 	103: uint8(0x62),
 	104: uint8(0x6e),
 	105: uint8(0x30),
 	106: uint8(0x73),
 	107: uint8(0x7d),
 	108: uint8(0x51),
 	109: uint8(0x5f),
 	110: uint8(0x40),
 	111: uint8(0x72),
 	112: uint8(0x7e),
 	113: uint8(0x61),
 	114: uint8(0x6f),
 	115: uint8(0x50),
 	116: uint8(0x71),
 	117: uint8(0x7f),
 	118: uint8(0x60),
 	119: uint8(0x70),
 }
 
 // C documentation
 //
 //	// Memory needed for lookup tables of one Huffman tree group. Red, blue, alpha
 //	// and distance alphabets are constant (256 for red, blue and alpha, 40 for
 //	// distance) and lookup table sizes for them in worst case are 630 and 410
 //	// respectively. Size of green alphabet depends on color cache size and is equal
 //	// to 256 (green component values) + 24 (length prefix values)
 //	// + color_cache_size (between 0 and 2048).
 //	// All values computed for 8-bit first level lookup with Mark Adler's tool:
 //	// https://github.com/madler/zlib/blob/v1.2.5/examples/enough.c
 var kTableSize = [12]uint16_t{
 	0:  libc.Uint16FromInt32(libc.Int32FromInt32(630)*libc.Int32FromInt32(3) + libc.Int32FromInt32(410) + libc.Int32FromInt32(654)),
 	1:  libc.Uint16FromInt32(libc.Int32FromInt32(630)*libc.Int32FromInt32(3) + libc.Int32FromInt32(410) + libc.Int32FromInt32(656)),
 	2:  libc.Uint16FromInt32(libc.Int32FromInt32(630)*libc.Int32FromInt32(3) + libc.Int32FromInt32(410) + libc.Int32FromInt32(658)),
 	3:  libc.Uint16FromInt32(libc.Int32FromInt32(630)*libc.Int32FromInt32(3) + libc.Int32FromInt32(410) + libc.Int32FromInt32(662)),
 	4:  libc.Uint16FromInt32(libc.Int32FromInt32(630)*libc.Int32FromInt32(3) + libc.Int32FromInt32(410) + libc.Int32FromInt32(670)),
 	5:  libc.Uint16FromInt32(libc.Int32FromInt32(630)*libc.Int32FromInt32(3) + libc.Int32FromInt32(410) + libc.Int32FromInt32(686)),
 	6:  libc.Uint16FromInt32(libc.Int32FromInt32(630)*libc.Int32FromInt32(3) + libc.Int32FromInt32(410) + libc.Int32FromInt32(718)),
 	7:  libc.Uint16FromInt32(libc.Int32FromInt32(630)*libc.Int32FromInt32(3) + libc.Int32FromInt32(410) + libc.Int32FromInt32(782)),
 	8:  libc.Uint16FromInt32(libc.Int32FromInt32(630)*libc.Int32FromInt32(3) + libc.Int32FromInt32(410) + libc.Int32FromInt32(912)),
 	9:  libc.Uint16FromInt32(libc.Int32FromInt32(630)*libc.Int32FromInt32(3) + libc.Int32FromInt32(410) + libc.Int32FromInt32(1168)),
 	10: libc.Uint16FromInt32(libc.Int32FromInt32(630)*libc.Int32FromInt32(3) + libc.Int32FromInt32(410) + libc.Int32FromInt32(1680)),
 	11: libc.Uint16FromInt32(libc.Int32FromInt32(630)*libc.Int32FromInt32(3) + libc.Int32FromInt32(410) + libc.Int32FromInt32(2704)),
 }
 
 func VP8LSetError(tls *libc.TLS, dec uintptr, error1 VP8StatusCode1) (r int32) {
 	// The oldest error reported takes precedence over the new one.
 	if (*VP8LDecoder)(unsafe.Pointer(dec)).Fstatus == int32(VP8_STATUS_OK) || (*VP8LDecoder)(unsafe.Pointer(dec)).Fstatus == int32(VP8_STATUS_SUSPENDED) {
 		(*VP8LDecoder)(unsafe.Pointer(dec)).Fstatus = error1
 	}
 	return 0
 }
 
 //------------------------------------------------------------------------------
 
 func VP8LCheckSignature(tls *libc.TLS, data uintptr, size size_t) (r int32) {
 	return libc.BoolInt32(size >= uint64(VP8L_FRAME_HEADER_SIZE) && libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(data))) == int32(VP8L_MAGIC_BYTE1) && libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(data + 4)))>>int32(5) == 0) // version
 }
 
 func ReadImageInfo(tls *libc.TLS, br uintptr, width uintptr, height uintptr, has_alpha uintptr) (r int32) {
 	if VP8LReadBits(tls, br, int32(8)) != uint32(VP8L_MAGIC_BYTE1) {
 		return 0
 	}
 	**(**int32)(__ccgo_up(width)) = libc.Int32FromUint32(VP8LReadBits(tls, br, int32(VP8L_IMAGE_SIZE_BITS)) + uint32(1))
 	**(**int32)(__ccgo_up(height)) = libc.Int32FromUint32(VP8LReadBits(tls, br, int32(VP8L_IMAGE_SIZE_BITS)) + uint32(1))
 	**(**int32)(__ccgo_up(has_alpha)) = libc.Int32FromUint32(VP8LReadBits(tls, br, int32(1)))
 	if VP8LReadBits(tls, br, int32(VP8L_VERSION_BITS)) != uint32(0) {
 		return 0
 	}
 	return libc.BoolInt32(!((*VP8LBitReader)(unsafe.Pointer(br)).Feos != 0))
 }
 
 func VP8LGetInfo(tls *libc.TLS, data uintptr, data_size size_t, width uintptr, height uintptr, has_alpha uintptr) (r int32) {
 	bp := tls.Alloc(64)
 	defer tls.Free(64)
 	var _ /* a at bp+8 */ int32
 	var _ /* br at bp+16 */ VP8LBitReader
 	var _ /* h at bp+4 */ int32
 	var _ /* w at bp+0 */ int32
 	if data == libc.UintptrFromInt32(0) || data_size < uint64(VP8L_FRAME_HEADER_SIZE) {
 		return 0 // not enough data
 	} else {
 		if !(VP8LCheckSignature(tls, data, data_size) != 0) {
 			return 0 // bad signature
 		} else {
 			VP8LInitBitReader(tls, bp+16, data, data_size)
 			if !(ReadImageInfo(tls, bp+16, bp, bp+4, bp+8) != 0) {
 				return 0
 			}
 			if width != libc.UintptrFromInt32(0) {
 				**(**int32)(__ccgo_up(width)) = **(**int32)(__ccgo_up(bp))
 			}
 			if height != libc.UintptrFromInt32(0) {
 				**(**int32)(__ccgo_up(height)) = **(**int32)(__ccgo_up(bp + 4))
 			}
 			if has_alpha != libc.UintptrFromInt32(0) {
 				**(**int32)(__ccgo_up(has_alpha)) = **(**int32)(__ccgo_up(bp + 8))
 			}
 			return int32(1)
 		}
 	}
 	return r
 }
 
 //------------------------------------------------------------------------------
 
 func GetCopyDistance(tls *libc.TLS, distance_symbol int32, br uintptr) (r int32) {
 	var extra_bits, offset int32
 	_, _ = extra_bits, offset
 	if distance_symbol < int32(4) {
 		return distance_symbol + int32(1)
 	}
 	extra_bits = (distance_symbol - int32(2)) >> int32(1)
 	offset = (int32(2) + distance_symbol&int32(1)) << extra_bits
 	return libc.Int32FromUint32(libc.Uint32FromInt32(offset) + VP8LReadBits(tls, br, extra_bits) + uint32(1))
 }
 
 func GetCopyLength(tls *libc.TLS, length_symbol int32, br uintptr) (r int32) {
 	// Length and distance prefixes are encoded the same way.
 	return GetCopyDistance(tls, length_symbol, br)
 }
 
 func PlaneCodeToDistance(tls *libc.TLS, xsize int32, plane_code int32) (r int32) {
 	var dist, dist_code, xoffset, yoffset, v1 int32
 	_, _, _, _, _ = dist, dist_code, xoffset, yoffset, v1
 	if plane_code > int32(CODE_TO_PLANE_CODES) {
 		return plane_code - int32(CODE_TO_PLANE_CODES)
 	} else {
 		dist_code = libc.Int32FromUint8(kCodeToPlane[plane_code-int32(1)])
 		yoffset = dist_code >> int32(4)
 		xoffset = int32(8) - dist_code&int32(0xf)
 		dist = yoffset*xsize + xoffset
 		if dist >= int32(1) {
 			v1 = dist
 		} else {
 			v1 = int32(1)
 		}
 		return v1 // dist<1 can happen if xsize is very small
 	}
 	return r
 }
 
 // C documentation
 //
 //	//------------------------------------------------------------------------------
 //	// Decodes the next Huffman code from bit-stream.
 //	// VP8LFillBitWindow(br) needs to be called at minimum every second call
 //	// to ReadSymbol, in order to pre-fetch enough bits.
 func ReadSymbol(tls *libc.TLS, table uintptr, br2 uintptr) (r int32) {
 	var nbits int32
 	var val1, v2 uint32_t
 	var v1 uintptr
 	_, _, _, _ = nbits, val1, v1, v2
 	v1 = br2
 	v2 = uint32((*VP8LBitReader)(unsafe.Pointer(v1)).Fval >> ((*VP8LBitReader)(unsafe.Pointer(v1)).Fbit_pos & (libc.Int32FromInt32(VP8L_LBITS) - libc.Int32FromInt32(1))))
 	goto _3
 _3:
 	val1 = v2
 	table = table + uintptr(val1&libc.Uint32FromInt32(libc.Int32FromInt32(1)<<libc.Int32FromInt32(HUFFMAN_TABLE_BITS)-libc.Int32FromInt32(1)))*4
 	nbits = libc.Int32FromUint8((*HuffmanCode)(unsafe.Pointer(table)).Fbits) - int32(HUFFMAN_TABLE_BITS)
 	if nbits > 0 {
 		(*VP8LBitReader)(unsafe.Pointer(br2)).Fbit_pos = (*VP8LBitReader)(unsafe.Pointer(br2)).Fbit_pos + int32(HUFFMAN_TABLE_BITS)
 		v1 = br2
 		v2 = uint32((*VP8LBitReader)(unsafe.Pointer(v1)).Fval >> ((*VP8LBitReader)(unsafe.Pointer(v1)).Fbit_pos & (libc.Int32FromInt32(VP8L_LBITS) - libc.Int32FromInt32(1))))
 		goto _6
 	_6:
 		val1 = v2
 		table = table + uintptr((*HuffmanCode)(unsafe.Pointer(table)).Fvalue)*4
 		table = table + uintptr(val1&libc.Uint32FromInt32(libc.Int32FromInt32(1)<<nbits-libc.Int32FromInt32(1)))*4
 	}
 	(*VP8LBitReader)(unsafe.Pointer(br2)).Fbit_pos = (*VP8LBitReader)(unsafe.Pointer(br2)).Fbit_pos + libc.Int32FromUint8((*HuffmanCode)(unsafe.Pointer(table)).Fbits)
 	return libc.Int32FromUint16((*HuffmanCode)(unsafe.Pointer(table)).Fvalue)
 }
 
 // C documentation
 //
 //	// Reads packed symbol depending on GREEN channel
 func ReadPackedSymbols(tls *libc.TLS, group uintptr, br2 uintptr, dst uintptr) (r int32) {
 	var code HuffmanCode32
 	var val1, v2 uint32_t
 	var v1 uintptr
 	_, _, _, _ = code, val1, v1, v2
 	v1 = br2
 	v2 = uint32((*VP8LBitReader)(unsafe.Pointer(v1)).Fval >> ((*VP8LBitReader)(unsafe.Pointer(v1)).Fbit_pos & (libc.Int32FromInt32(VP8L_LBITS) - libc.Int32FromInt32(1))))
 	goto _3
 _3:
 	val1 = v2 & (libc.Uint32FromUint32(1)<<libc.Int32FromInt32(HUFFMAN_PACKED_BITS) - libc.Uint32FromInt32(1))
 	code = **(**HuffmanCode32)(__ccgo_up(group + 56 + uintptr(val1)*8))
 	if code.Fbits < int32(BITS_SPECIAL_MARKER) {
 		(*VP8LBitReader)(unsafe.Pointer(br2)).Fbit_pos = (*VP8LBitReader)(unsafe.Pointer(br2)).Fbit_pos + code.Fbits
 		**(**uint32_t)(__ccgo_up(dst)) = code.Fvalue
 		return PACKED_NON_LITERAL_CODE
 	} else {
 		(*VP8LBitReader)(unsafe.Pointer(br2)).Fbit_pos = (*VP8LBitReader)(unsafe.Pointer(br2)).Fbit_pos + code.Fbits - int32(BITS_SPECIAL_MARKER)
 		return libc.Int32FromUint32(code.Fvalue)
 	}
 	return r
 }
 
 func AccumulateHCode(tls *libc.TLS, hcode HuffmanCode, shift int32, huff uintptr) (r int32) {
 	**(**int32)(__ccgo_up(huff)) += libc.Int32FromUint8(hcode.Fbits)
 	**(**uint32_t)(__ccgo_up(huff + 4)) |= uint32(hcode.Fvalue) << shift
 	return libc.Int32FromUint8(hcode.Fbits)
 }
 
 func BuildPackedTable(tls *libc.TLS, htree_group uintptr) {
 	var bits, code uint32_t
 	var hcode HuffmanCode
 	var huff uintptr
 	_, _, _, _ = bits, code, hcode, huff
 	code = uint32(0)
 	for {
 		if !(code < libc.Uint32FromUint32(1)<<libc.Int32FromInt32(HUFFMAN_PACKED_BITS)) {
 			break
 		}
 		bits = code
 		huff = htree_group + 56 + uintptr(bits)*8
 		hcode = **(**HuffmanCode)(__ccgo_up(**(**uintptr)(__ccgo_up(htree_group + uintptr(GREEN)*8)) + uintptr(bits)*4))
 		if libc.Int32FromUint16(hcode.Fvalue) >= int32(NUM_LITERAL_CODES) {
 			(*HuffmanCode32)(unsafe.Pointer(huff)).Fbits = libc.Int32FromUint8(hcode.Fbits) + int32(BITS_SPECIAL_MARKER)
 			(*HuffmanCode32)(unsafe.Pointer(huff)).Fvalue = uint32(hcode.Fvalue)
 		} else {
 			(*HuffmanCode32)(unsafe.Pointer(huff)).Fbits = 0
 			(*HuffmanCode32)(unsafe.Pointer(huff)).Fvalue = uint32(0)
 			bits = bits >> libc.Uint32FromInt32(AccumulateHCode(tls, hcode, int32(8), huff))
 			bits = bits >> libc.Uint32FromInt32(AccumulateHCode(tls, **(**HuffmanCode)(__ccgo_up(**(**uintptr)(__ccgo_up(htree_group + uintptr(RED)*8)) + uintptr(bits)*4)), int32(16), huff))
 			bits = bits >> libc.Uint32FromInt32(AccumulateHCode(tls, **(**HuffmanCode)(__ccgo_up(**(**uintptr)(__ccgo_up(htree_group + uintptr(BLUE)*8)) + uintptr(bits)*4)), 0, huff))
 			bits = bits >> libc.Uint32FromInt32(AccumulateHCode(tls, **(**HuffmanCode)(__ccgo_up(**(**uintptr)(__ccgo_up(htree_group + uintptr(ALPHA)*8)) + uintptr(bits)*4)), int32(24), huff))
 			_ = bits
 		}
 		goto _1
 	_1:
 		;
 		code = code + 1
 	}
 }
 
 func ReadHuffmanCodeLengths(tls *libc.TLS, dec uintptr, code_length_code_lengths uintptr, num_symbols int32, code_lengths uintptr) (r int32) {
 	bp := tls.Alloc(48)
 	defer tls.Free(48)
 	var br3, p, v2 uintptr
 	var code_len, extra_bits, length, length_nbits, max_symbol, ok, prev_code_len, repeat, repeat_offset, slot, symbol, use_prev, v1, v6, v7 int32
 	var v4 uint32_t
 	var _ /* tables at bp+0 */ HuffmanTables
 	_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = br3, code_len, extra_bits, length, length_nbits, max_symbol, ok, p, prev_code_len, repeat, repeat_offset, slot, symbol, use_prev, v1, v2, v4, v6, v7
 	ok = 0
 	br3 = dec + 40
 	prev_code_len = int32(DEFAULT_CODE_LENGTH)
 	if !(VP8LHuffmanTablesAllocate(tls, libc.Int32FromInt32(1)<<libc.Int32FromInt32(LENGTHS_TABLE_BITS), bp) != 0) || !(VP8LBuildHuffmanTable(tls, bp, int32(LENGTHS_TABLE_BITS), code_length_code_lengths, int32(NUM_CODE_LENGTH_CODES)) != 0) {
 		goto End
 	}
 	if VP8LReadBits(tls, br3, int32(1)) != 0 { // use length
 		length_nbits = libc.Int32FromUint32(uint32(2) + uint32(2)*VP8LReadBits(tls, br3, int32(3)))
 		max_symbol = libc.Int32FromUint32(uint32(2) + VP8LReadBits(tls, br3, length_nbits))
 		if max_symbol > num_symbols {
 			goto End
 		}
 	} else {
 		max_symbol = num_symbols
 	}
 	symbol = 0
 	for symbol < num_symbols {
 		v1 = max_symbol
 		max_symbol = max_symbol - 1
 		if v1 == 0 {
 			break
 		}
 		v2 = br3
 		if (*VP8LBitReader)(unsafe.Pointer(v2)).Fbit_pos >= libc.Int32FromInt32(VP8L_WBITS) {
 			VP8LDoFillBitWindow(tls, v2)
 		}
 		v2 = br3
 		v4 = uint32((*VP8LBitReader)(unsafe.Pointer(v2)).Fval >> ((*VP8LBitReader)(unsafe.Pointer(v2)).Fbit_pos & (libc.Int32FromInt32(VP8L_LBITS) - libc.Int32FromInt32(1))))
 		goto _5
 	_5:
 		p = (*HuffmanTablesSegment)(unsafe.Pointer((**(**HuffmanTables)(__ccgo_up(bp))).Fcurr_segment)).Fstart + uintptr(v4&libc.Uint32FromInt32(libc.Int32FromInt32(1)<<libc.Int32FromInt32(LENGTHS_TABLE_BITS)-libc.Int32FromInt32(1)))*4
 		(*VP8LBitReader)(unsafe.Pointer(br3)).Fbit_pos = (*VP8LBitReader)(unsafe.Pointer(br3)).Fbit_pos + libc.Int32FromUint8((*HuffmanCode)(unsafe.Pointer(p)).Fbits)
 		code_len = libc.Int32FromUint16((*HuffmanCode)(unsafe.Pointer(p)).Fvalue)
 		if code_len < kCodeLengthLiterals {
 			v1 = symbol
 			symbol = symbol + 1
 			**(**int32)(__ccgo_up(code_lengths + uintptr(v1)*4)) = code_len
 			if code_len != 0 {
 				prev_code_len = code_len
 			}
 		} else {
 			use_prev = libc.BoolInt32(code_len == kCodeLengthRepeatCode)
 			slot = code_len - kCodeLengthLiterals
 			extra_bits = libc.Int32FromUint8(kCodeLengthExtraBits[slot])
 			repeat_offset = libc.Int32FromUint8(kCodeLengthRepeatOffsets[slot])
 			repeat = libc.Int32FromUint32(VP8LReadBits(tls, br3, extra_bits) + libc.Uint32FromInt32(repeat_offset))
 			if symbol+repeat > num_symbols {
 				goto End
 			} else {
 				if use_prev != 0 {
 					v1 = prev_code_len
 				} else {
 					v1 = 0
 				}
 				length = v1
 				for {
 					v6 = repeat
 					repeat = repeat - 1
 					if !(v6 > 0) {
 						break
 					}
 					v7 = symbol
 					symbol = symbol + 1
 					**(**int32)(__ccgo_up(code_lengths + uintptr(v7)*4)) = length
 				}
 			}
 		}
 	}
 	ok = int32(1)
 	goto End
 End:
 	;
 	VP8LHuffmanTablesDeallocate(tls, bp)
 	if !(ok != 0) {
 		return VP8LSetError(tls, dec, int32(VP8_STATUS_BITSTREAM_ERROR))
 	}
 	return ok
 }
 
 // C documentation
 //
 //	// 'code_lengths' is pre-allocated temporary buffer, used for creating Huffman
 //	// tree.
 func ReadHuffmanCode(tls *libc.TLS, alphabet_size int32, dec uintptr, code_lengths uintptr, table uintptr) (r int32) {
 	bp := tls.Alloc(80)
 	defer tls.Free(80)
 	var br uintptr
 	var first_symbol_len_code, i, num_codes, num_symbols, ok, simple_code, size, symbol, v1 int32
 	var _ /* code_length_code_lengths at bp+0 */ [19]int32
 	_, _, _, _, _, _, _, _, _, _ = br, first_symbol_len_code, i, num_codes, num_symbols, ok, simple_code, size, symbol, v1
 	ok = 0
 	size = 0
 	br = dec + 40
 	simple_code = libc.Int32FromUint32(VP8LReadBits(tls, br, int32(1)))
 	libc.X__builtin___memset_chk(tls, code_lengths, 0, libc.Uint64FromInt32(alphabet_size)*uint64(4), ^__predefined_size_t(0))
 	if simple_code != 0 { // Read symbols, codes & code lengths directly.
 		num_symbols = libc.Int32FromUint32(VP8LReadBits(tls, br, int32(1)) + uint32(1))
 		first_symbol_len_code = libc.Int32FromUint32(VP8LReadBits(tls, br, int32(1)))
 		if first_symbol_len_code == 0 {
 			v1 = int32(1)
 		} else {
 			v1 = int32(8)
 		}
 		// The first code is either 1 bit or 8 bit code.
 		symbol = libc.Int32FromUint32(VP8LReadBits(tls, br, v1))
 		**(**int32)(__ccgo_up(code_lengths + uintptr(symbol)*4)) = int32(1)
 		// The second code (if present), is always 8 bits long.
 		if num_symbols == int32(2) {
 			symbol = libc.Int32FromUint32(VP8LReadBits(tls, br, int32(8)))
 			**(**int32)(__ccgo_up(code_lengths + uintptr(symbol)*4)) = int32(1)
 		}
 		ok = int32(1)
 	} else {
 		**(**[19]int32)(__ccgo_up(bp)) = [19]int32{}
 		num_codes = libc.Int32FromUint32(VP8LReadBits(tls, br, int32(4)) + uint32(4))
 		i = 0
 		for {
 			if !(i < num_codes) {
 				break
 			}
 			(**(**[19]int32)(__ccgo_up(bp)))[kCodeLengthCodeOrder[i]] = libc.Int32FromUint32(VP8LReadBits(tls, br, int32(3)))
 			goto _2
 		_2:
 			;
 			i = i + 1
 		}
 		ok = ReadHuffmanCodeLengths(tls, dec, bp, alphabet_size, code_lengths)
 	}
 	ok = libc.BoolInt32(ok != 0 && !((*VP8LBitReader)(unsafe.Pointer(br)).Feos != 0))
 	if ok != 0 {
 		size = VP8LBuildHuffmanTable(tls, table, int32(HUFFMAN_TABLE_BITS), code_lengths, alphabet_size)
 	}
 	if !(ok != 0) || size == 0 {
 		return VP8LSetError(tls, dec, int32(VP8_STATUS_BITSTREAM_ERROR))
 	}
 	return size
 }
 
 func ReadHuffmanCodes(tls *libc.TLS, dec uintptr, xsize int32, ysize int32, color_cache_bits int32, allow_recursion int32) (r int32) {
 	bp := tls.Alloc(16)
 	defer tls.Free(16)
 	var br, hdr, huffman_tables, mapped_group, mapping uintptr
 	var group, huffman_pixs, huffman_precision, huffman_xsize, huffman_ysize, i, num_htree_groups, num_htree_groups_max, ok, v9 int32
 	var v1, v2, v4, v5 uint32_t
 	var _ /* htree_groups at bp+8 */ uintptr
 	var _ /* huffman_image at bp+0 */ uintptr
 	_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = br, group, hdr, huffman_pixs, huffman_precision, huffman_tables, huffman_xsize, huffman_ysize, i, mapped_group, mapping, num_htree_groups, num_htree_groups_max, ok, v1, v2, v4, v5, v9
 	br = dec + 40
 	hdr = dec + 152
 	**(**uintptr)(__ccgo_up(bp)) = libc.UintptrFromInt32(0)
 	**(**uintptr)(__ccgo_up(bp + 8)) = libc.UintptrFromInt32(0)
 	huffman_tables = hdr + 80
 	num_htree_groups = int32(1)
 	num_htree_groups_max = int32(1)
 	mapping = libc.UintptrFromInt32(0)
 	ok = 0
 	// Check the table has been 0 initialized (through InitMetadata).
 	if allow_recursion != 0 && VP8LReadBits(tls, br, int32(1)) != 0 {
 		// use meta Huffman codes.
 		huffman_precision = libc.Int32FromUint32(uint32(MIN_HUFFMAN_BITS) + VP8LReadBits(tls, br, int32(NUM_HUFFMAN_BITS)))
 		v1 = libc.Uint32FromInt32(huffman_precision)
 		v2 = (libc.Uint32FromInt32(xsize) + libc.Uint32FromInt32(libc.Int32FromInt32(1)<<v1) - uint32(1)) >> v1
 		goto _3
 	_3:
 		huffman_xsize = libc.Int32FromUint32(v2)
 		v4 = libc.Uint32FromInt32(huffman_precision)
 		v5 = (libc.Uint32FromInt32(ysize) + libc.Uint32FromInt32(libc.Int32FromInt32(1)<<v4) - uint32(1)) >> v4
 		goto _6
 	_6:
 		huffman_ysize = libc.Int32FromUint32(v5)
 		huffman_pixs = huffman_xsize * huffman_ysize
 		if !(DecodeImageStream(tls, huffman_xsize, huffman_ysize, 0, dec, bp) != 0) {
 			goto Error
 		}
 		(*VP8LMetadata)(unsafe.Pointer(hdr)).Fhuffman_subsample_bits = huffman_precision
 		i = 0
 		for {
 			if !(i < huffman_pixs) {
 				break
 			}
 			// The huffman data is stored in red and green bytes.
 			group = libc.Int32FromUint32(**(**uint32_t)(__ccgo_up(**(**uintptr)(__ccgo_up(bp)) + uintptr(i)*4)) >> libc.Int32FromInt32(8) & uint32(0xffff))
 			**(**uint32_t)(__ccgo_up(**(**uintptr)(__ccgo_up(bp)) + uintptr(i)*4)) = libc.Uint32FromInt32(group)
 			if group >= num_htree_groups_max {
 				num_htree_groups_max = group + int32(1)
 			}
 			goto _7
 		_7:
 			;
 			i = i + 1
 		}
 		// Check the validity of num_htree_groups_max. If it seems too big, use a
 		// smaller value for later. This will prevent big memory allocations to end
 		// up with a bad bitstream anyway.
 		// The value of 1000 is totally arbitrary. We know that num_htree_groups_max
 		// is smaller than (1 << 16) and should be smaller than the number of pixels
 		// (though the format allows it to be bigger).
 		if num_htree_groups_max > int32(1000) || num_htree_groups_max > xsize*ysize {
 			// Create a mapping from the used indices to the minimal set of used
 			// values [0, num_htree_groups)
 			mapping = WebPSafeMalloc(tls, libc.Uint64FromInt32(num_htree_groups_max), uint64(4))
 			if mapping == libc.UintptrFromInt32(0) {
 				VP8LSetError(tls, dec, int32(VP8_STATUS_OUT_OF_MEMORY))
 				goto Error
 			}
 			// -1 means a value is unmapped, and therefore unused in the Huffman
 			// image.
 			libc.X__builtin___memset_chk(tls, mapping, int32(0xff), libc.Uint64FromInt32(num_htree_groups_max)*uint64(4), ^__predefined_size_t(0))
 			num_htree_groups = 0
 			i = libc.Int32FromInt32(0)
 			for {
 				if !(i < huffman_pixs) {
 					break
 				}
 				// Get the current mapping for the group and remap the Huffman image.
 				mapped_group = mapping + uintptr(**(**uint32_t)(__ccgo_up(**(**uintptr)(__ccgo_up(bp)) + uintptr(i)*4)))*4
 				if **(**int32)(__ccgo_up(mapped_group)) == -int32(1) {
 					v9 = num_htree_groups
 					num_htree_groups = num_htree_groups + 1
 					**(**int32)(__ccgo_up(mapped_group)) = v9
 				}
 				**(**uint32_t)(__ccgo_up(**(**uintptr)(__ccgo_up(bp)) + uintptr(i)*4)) = libc.Uint32FromInt32(**(**int32)(__ccgo_up(mapped_group)))
 				goto _8
 			_8:
 				;
 				i = i + 1
 			}
 		} else {
 			num_htree_groups = num_htree_groups_max
 		}
 	}
 	if (*VP8LBitReader)(unsafe.Pointer(br)).Feos != 0 {
 		goto Error
 	}
 	if !(ReadHuffmanCodesHelper(tls, color_cache_bits, num_htree_groups, num_htree_groups_max, mapping, dec, huffman_tables, bp+8) != 0) {
 		goto Error
 	}
 	ok = int32(1)
 	// All OK. Finalize pointers.
 	(*VP8LMetadata)(unsafe.Pointer(hdr)).Fhuffman_image = **(**uintptr)(__ccgo_up(bp))
 	(*VP8LMetadata)(unsafe.Pointer(hdr)).Fnum_htree_groups = num_htree_groups
 	(*VP8LMetadata)(unsafe.Pointer(hdr)).Fhtree_groups = **(**uintptr)(__ccgo_up(bp + 8))
 	goto Error
 Error:
 	;
 	WebPSafeFree(tls, mapping)
 	if !(ok != 0) {
 		WebPSafeFree(tls, **(**uintptr)(__ccgo_up(bp)))
 		VP8LHuffmanTablesDeallocate(tls, huffman_tables)
 		VP8LHtreeGroupsFree(tls, **(**uintptr)(__ccgo_up(bp + 8)))
 	}
 	return ok
 }
 
 func ReadHuffmanCodesHelper(tls *libc.TLS, color_cache_bits int32, num_htree_groups int32, num_htree_groups_max int32, mapping uintptr, dec uintptr, huffman_tables uintptr, htree_groups uintptr) (r int32) {
 	var alpha, alphabet_size, alphabet_size1, blue, i, is_trivial_literal, j, k, local_max_bits, max_alphabet_size, max_bits, ok, red, size, table_size, total_size, v1 int32
 	var code_lengths, htree_group, htrees uintptr
 	_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = alpha, alphabet_size, alphabet_size1, blue, code_lengths, htree_group, htrees, i, is_trivial_literal, j, k, local_max_bits, max_alphabet_size, max_bits, ok, red, size, table_size, total_size, v1
 	ok = 0
 	if color_cache_bits > 0 {
 		v1 = int32(1) << color_cache_bits
 	} else {
 		v1 = 0
 	}
 	max_alphabet_size = libc.Int32FromUint16(kAlphabetSize[0]) + v1
 	table_size = libc.Int32FromUint16(kTableSize[color_cache_bits])
 	code_lengths = libc.UintptrFromInt32(0)
 	if mapping == libc.UintptrFromInt32(0) && num_htree_groups != num_htree_groups_max || num_htree_groups > num_htree_groups_max {
 		goto Error
 	}
 	code_lengths = WebPSafeCalloc(tls, libc.Uint64FromInt32(max_alphabet_size), uint64(4))
 	**(**uintptr)(__ccgo_up(htree_groups)) = VP8LHtreeGroupsNew(tls, num_htree_groups)
 	if **(**uintptr)(__ccgo_up(htree_groups)) == libc.UintptrFromInt32(0) || code_lengths == libc.UintptrFromInt32(0) || !(VP8LHuffmanTablesAllocate(tls, num_htree_groups*table_size, huffman_tables) != 0) {
 		VP8LSetError(tls, dec, int32(VP8_STATUS_OUT_OF_MEMORY))
 		goto Error
 	}
 	i = 0
 	for {
 		if !(i < num_htree_groups_max) {
 			break
 		}
 		// If the index "i" is unused in the Huffman image, just make sure the
 		// coefficients are valid but do not store them.
 		if mapping != libc.UintptrFromInt32(0) && **(**int32)(__ccgo_up(mapping + uintptr(i)*4)) == -int32(1) {
 			j = 0
 			for {
 				if !(j < int32(HUFFMAN_CODES_PER_META_CODE)) {
 					break
 				}
 				alphabet_size = libc.Int32FromUint16(kAlphabetSize[j])
 				if j == 0 && color_cache_bits > 0 {
 					alphabet_size = alphabet_size + int32(1)<<color_cache_bits
 				}
 				// Passing in NULL so that nothing gets filled.
 				if !(ReadHuffmanCode(tls, alphabet_size, dec, code_lengths, libc.UintptrFromInt32(0)) != 0) {
 					goto Error
 				}
 				goto _3
 			_3:
 				;
 				j = j + 1
 			}
 		} else {
 			if mapping == libc.UintptrFromInt32(0) {
 				v1 = i
 			} else {
 				v1 = **(**int32)(__ccgo_up(mapping + uintptr(i)*4))
 			}
 			htree_group = **(**uintptr)(__ccgo_up(htree_groups)) + uintptr(v1)*568
 			htrees = htree_group
 			total_size = 0
 			is_trivial_literal = int32(1)
 			max_bits = 0
 			j = 0
 			for {
 				if !(j < int32(HUFFMAN_CODES_PER_META_CODE)) {
 					break
 				}
 				alphabet_size1 = libc.Int32FromUint16(kAlphabetSize[j])
 				if j == 0 && color_cache_bits > 0 {
 					alphabet_size1 = alphabet_size1 + int32(1)<<color_cache_bits
 				}
 				size = ReadHuffmanCode(tls, alphabet_size1, dec, code_lengths, huffman_tables)
 				**(**uintptr)(__ccgo_up(htrees + uintptr(j)*8)) = (*HuffmanTablesSegment)(unsafe.Pointer((*HuffmanTables)(unsafe.Pointer(huffman_tables)).Fcurr_segment)).Fcurr_table
 				if size == 0 {
 					goto Error
 				}
 				if is_trivial_literal != 0 && libc.Int32FromUint8(kLiteralMap[j]) == int32(1) {
 					is_trivial_literal = libc.BoolInt32(libc.Int32FromUint8((*HuffmanCode)(unsafe.Pointer(**(**uintptr)(__ccgo_up(htrees + uintptr(j)*8)))).Fbits) == 0)
 				}
 				total_size = total_size + libc.Int32FromUint8((*HuffmanCode)(unsafe.Pointer(**(**uintptr)(__ccgo_up(htrees + uintptr(j)*8)))).Fbits)
 				**(**uintptr)(__ccgo_up((*HuffmanTables)(unsafe.Pointer(huffman_tables)).Fcurr_segment + 8)) += uintptr(size) * 4
 				if j <= int32(ALPHA) {
 					local_max_bits = **(**int32)(__ccgo_up(code_lengths))
 					k = int32(1)
 					for {
 						if !(k < alphabet_size1) {
 							break
 						}
 						if **(**int32)(__ccgo_up(code_lengths + uintptr(k)*4)) > local_max_bits {
 							local_max_bits = **(**int32)(__ccgo_up(code_lengths + uintptr(k)*4))
 						}
 						goto _6
 					_6:
 						;
 						k = k + 1
 					}
 					max_bits = max_bits + local_max_bits
 				}
 				goto _5
 			_5:
 				;
 				j = j + 1
 			}
 			(*HTreeGroup)(unsafe.Pointer(htree_group)).Fis_trivial_literal = is_trivial_literal
 			(*HTreeGroup)(unsafe.Pointer(htree_group)).Fis_trivial_code = 0
 			if is_trivial_literal != 0 {
 				red = libc.Int32FromUint16((**(**HuffmanCode)(__ccgo_up(**(**uintptr)(__ccgo_up(htrees + uintptr(RED)*8))))).Fvalue)
 				blue = libc.Int32FromUint16((**(**HuffmanCode)(__ccgo_up(**(**uintptr)(__ccgo_up(htrees + uintptr(BLUE)*8))))).Fvalue)
 				alpha = libc.Int32FromUint16((**(**HuffmanCode)(__ccgo_up(**(**uintptr)(__ccgo_up(htrees + uintptr(ALPHA)*8))))).Fvalue)
 				(*HTreeGroup)(unsafe.Pointer(htree_group)).Fliteral_arb = libc.Uint32FromInt32(alpha)<<libc.Int32FromInt32(24) | libc.Uint32FromInt32(red<<libc.Int32FromInt32(16)) | libc.Uint32FromInt32(blue)
 				if total_size == 0 && libc.Int32FromUint16((**(**HuffmanCode)(__ccgo_up(**(**uintptr)(__ccgo_up(htrees + uintptr(GREEN)*8))))).Fvalue) < int32(NUM_LITERAL_CODES) {
 					(*HTreeGroup)(unsafe.Pointer(htree_group)).Fis_trivial_code = int32(1)
 					**(**uint32_t)(__ccgo_up(htree_group + 44)) |= libc.Uint32FromInt32(libc.Int32FromUint16((**(**HuffmanCode)(__ccgo_up(**(**uintptr)(__ccgo_up(htrees + uintptr(GREEN)*8))))).Fvalue) << int32(8))
 				}
 			}
 			(*HTreeGroup)(unsafe.Pointer(htree_group)).Fuse_packed_table = libc.BoolInt32(!((*HTreeGroup)(unsafe.Pointer(htree_group)).Fis_trivial_code != 0) && max_bits < int32(HUFFMAN_PACKED_BITS))
 			if (*HTreeGroup)(unsafe.Pointer(htree_group)).Fuse_packed_table != 0 {
 				BuildPackedTable(tls, htree_group)
 			}
 		}
 		goto _2
 	_2:
 		;
 		i = i + 1
 	}
 	ok = int32(1)
 	goto Error
 Error:
 	;
 	WebPSafeFree(tls, code_lengths)
 	if !(ok != 0) {
 		VP8LHuffmanTablesDeallocate(tls, huffman_tables)
 		VP8LHtreeGroupsFree(tls, **(**uintptr)(__ccgo_up(htree_groups)))
 		**(**uintptr)(__ccgo_up(htree_groups)) = libc.UintptrFromInt32(0)
 	}
 	return ok
 }
 
 //------------------------------------------------------------------------------
 // Scaling.
 
 func AllocateAndInitRescaler(tls *libc.TLS, dec uintptr, io uintptr) (r int32) {
 	var in_height, in_width, num_channels, out_height, out_width int32
 	var memory, scaled_data, work uintptr
 	var memory_size, scaled_data_size, work_size uint64_t
 	_, _, _, _, _, _, _, _, _, _, _ = in_height, in_width, memory, memory_size, num_channels, out_height, out_width, scaled_data, scaled_data_size, work, work_size
 	num_channels = int32(4)
 	in_width = (*VP8Io)(unsafe.Pointer(io)).Fmb_w
 	out_width = (*VP8Io)(unsafe.Pointer(io)).Fscaled_width
 	in_height = (*VP8Io)(unsafe.Pointer(io)).Fmb_h
 	out_height = (*VP8Io)(unsafe.Pointer(io)).Fscaled_height
 	work_size = libc.Uint64FromInt32(int32(2)*num_channels) * libc.Uint64FromInt32(out_width) // Rescaler work area.
 	scaled_data_size = libc.Uint64FromInt32(out_width)                                        // Temporary storage for scaled BGRA data.
 	memory_size = uint64(104) + work_size*uint64(4) + scaled_data_size*uint64(4)
 	memory = WebPSafeMalloc(tls, memory_size, uint64(1))
 	if memory == libc.UintptrFromInt32(0) {
 		return VP8LSetError(tls, dec, int32(VP8_STATUS_OUT_OF_MEMORY))
 	}
 	(*VP8LDecoder)(unsafe.Pointer(dec)).Frescaler_memory = memory
 	(*VP8LDecoder)(unsafe.Pointer(dec)).Frescaler = memory
 	memory = memory + uintptr(104)
 	work = memory
 	memory = memory + uintptr(work_size*uint64(4))
 	scaled_data = memory
 	if !(WebPRescalerInit(tls, (*VP8LDecoder)(unsafe.Pointer(dec)).Frescaler, in_width, in_height, scaled_data, out_width, out_height, 0, num_channels, work) != 0) {
 		return 0
 	}
 	return int32(1)
 }
 
 //------------------------------------------------------------------------------
 // Export to ARGB
 
 // C documentation
 //
 //	// We have special "export" function since we need to convert from BGRA
 func Export(tls *libc.TLS, rescaler2 uintptr, colorspace WEBP_CSP_MODE1, rgba_stride int32, rgba uintptr) (r int32) {
 	var dst, src, v1, v4 uintptr
 	var dst_width, num_lines_out, v2, v5 int32
 	_, _, _, _, _, _, _, _ = dst, dst_width, num_lines_out, src, v1, v2, v4, v5
 	src = (*WebPRescaler)(unsafe.Pointer(rescaler2)).Fdst
 	dst = rgba
 	dst_width = (*WebPRescaler)(unsafe.Pointer(rescaler2)).Fdst_width
 	num_lines_out = 0
 	for {
 		v1 = rescaler2
 		v4 = v1
 		v5 = libc.BoolInt32((*WebPRescaler)(unsafe.Pointer(v4)).Fdst_y >= (*WebPRescaler)(unsafe.Pointer(v4)).Fdst_height)
 		goto _6
 	_6:
 		;
 		v2 = libc.BoolInt32(!(v5 != 0) && (*WebPRescaler)(unsafe.Pointer(v1)).Fy_accum <= 0)
 		goto _3
 	_3:
 		if !(v2 != 0) {
 			break
 		}
 		WebPRescalerExportRow(tls, rescaler2)
 		(*(*func(*libc.TLS, uintptr, int32, int32))(unsafe.Pointer(&struct{ uintptr }{WebPMultARGBRow})))(tls, src, dst_width, int32(1))
 		VP8LConvertFromBGRA(tls, src, dst_width, colorspace, dst)
 		dst = dst + uintptr(rgba_stride)
 		num_lines_out = num_lines_out + 1
 	}
 	return num_lines_out
 }
 
 // C documentation
 //
 //	// Emit scaled rows.
 func EmitRescaledRowsRGBA(tls *libc.TLS, dec uintptr, in uintptr, in_stride int32, mb_h int32, out uintptr, out_stride int32) (r int32) {
 	var colorspace WEBP_CSP_MODE1
 	var lines_imported, lines_left, needed_lines, num_lines_in, num_lines_out int32
 	var row_in, row_out uintptr
 	_, _, _, _, _, _, _, _ = colorspace, lines_imported, lines_left, needed_lines, num_lines_in, num_lines_out, row_in, row_out
 	colorspace = (*WebPDecBuffer)(unsafe.Pointer((*VP8LDecoder)(unsafe.Pointer(dec)).Foutput)).Fcolorspace
 	num_lines_in = 0
 	num_lines_out = 0
 	for num_lines_in < mb_h {
 		row_in = in + uintptr(int64(num_lines_in)*int64(in_stride))
 		row_out = out + uintptr(int64(num_lines_out)*int64(out_stride))
 		lines_left = mb_h - num_lines_in
 		needed_lines = WebPRescaleNeededLines(tls, (*VP8LDecoder)(unsafe.Pointer(dec)).Frescaler, lines_left)
 		WebPMultARGBRows(tls, row_in, in_stride, (*WebPRescaler)(unsafe.Pointer((*VP8LDecoder)(unsafe.Pointer(dec)).Frescaler)).Fsrc_width, needed_lines, 0)
 		lines_imported = WebPRescalerImport(tls, (*VP8LDecoder)(unsafe.Pointer(dec)).Frescaler, lines_left, row_in, in_stride)
 		num_lines_in = num_lines_in + lines_imported
 		num_lines_out = num_lines_out + Export(tls, (*VP8LDecoder)(unsafe.Pointer(dec)).Frescaler, colorspace, out_stride, row_out)
 	}
 	return num_lines_out
 }
 
 // C documentation
 //
 //	// Emit rows without any scaling.
 func EmitRows(tls *libc.TLS, colorspace WEBP_CSP_MODE1, row_in uintptr, in_stride int32, mb_w int32, mb_h int32, out uintptr, out_stride int32) (r int32) {
 	var lines, v1 int32
 	var row_out uintptr
 	_, _, _ = lines, row_out, v1
 	lines = mb_h
 	row_out = out
 	for {
 		v1 = lines
 		lines = lines - 1
 		if !(v1 > 0) {
 			break
 		}
 		VP8LConvertFromBGRA(tls, row_in, mb_w, colorspace, row_out)
 		row_in = row_in + uintptr(in_stride)
 		row_out = row_out + uintptr(out_stride)
 	}
 	return mb_h // Num rows out == num rows in.
 }
 
 //------------------------------------------------------------------------------
 // Export to YUVA
 
 func ConvertToYUVA(tls *libc.TLS, src uintptr, width int32, y_pos int32, output uintptr) {
 	var a, buf, u, v uintptr
 	_, _, _, _ = a, buf, u, v
 	buf = output + 16
 	// first, the luma plane
 	(*(*func(*libc.TLS, uintptr, uintptr, int32))(unsafe.Pointer(&struct{ uintptr }{WebPConvertARGBToY})))(tls, src, (*WebPYUVABuffer)(unsafe.Pointer(buf)).Fy+uintptr(y_pos*(*WebPYUVABuffer)(unsafe.Pointer(buf)).Fy_stride), width)
 	// then U/V planes
 	u = (*WebPYUVABuffer)(unsafe.Pointer(buf)).Fu + uintptr(y_pos>>int32(1)*(*WebPYUVABuffer)(unsafe.Pointer(buf)).Fu_stride)
 	v = (*WebPYUVABuffer)(unsafe.Pointer(buf)).Fv + uintptr(y_pos>>int32(1)*(*WebPYUVABuffer)(unsafe.Pointer(buf)).Fv_stride)
 	// even lines: store values
 	// odd lines: average with previous values
 	(*(*func(*libc.TLS, uintptr, uintptr, uintptr, int32, int32))(unsafe.Pointer(&struct{ uintptr }{WebPConvertARGBToUV})))(tls, src, u, v, width, libc.BoolInt32(!(y_pos&libc.Int32FromInt32(1) != 0)))
 	// Lastly, store alpha if needed.
 	if (*WebPYUVABuffer)(unsafe.Pointer(buf)).Fa != libc.UintptrFromInt32(0) {
 		a = (*WebPYUVABuffer)(unsafe.Pointer(buf)).Fa + uintptr(y_pos*(*WebPYUVABuffer)(unsafe.Pointer(buf)).Fa_stride)
 		(*(*func(*libc.TLS, uintptr, int32, int32, int32, uintptr, int32) int32)(unsafe.Pointer(&struct{ uintptr }{WebPExtractAlpha})))(tls, src+uintptr(3), 0, width, int32(1), a, 0)
 	}
 }
 
 func ExportYUVA(tls *libc.TLS, dec uintptr, y_pos int32) (r int32) {
 	var dst_width, num_lines_out, v2, v5 int32
 	var rescaler2, src, v1, v4 uintptr
 	_, _, _, _, _, _, _, _ = dst_width, num_lines_out, rescaler2, src, v1, v2, v4, v5
 	rescaler2 = (*VP8LDecoder)(unsafe.Pointer(dec)).Frescaler
 	src = (*WebPRescaler)(unsafe.Pointer(rescaler2)).Fdst
 	dst_width = (*WebPRescaler)(unsafe.Pointer(rescaler2)).Fdst_width
 	num_lines_out = 0
 	for {
 		v1 = rescaler2
 		v4 = v1
 		v5 = libc.BoolInt32((*WebPRescaler)(unsafe.Pointer(v4)).Fdst_y >= (*WebPRescaler)(unsafe.Pointer(v4)).Fdst_height)
 		goto _6
 	_6:
 		;
 		v2 = libc.BoolInt32(!(v5 != 0) && (*WebPRescaler)(unsafe.Pointer(v1)).Fy_accum <= 0)
 		goto _3
 	_3:
 		if !(v2 != 0) {
 			break
 		}
 		WebPRescalerExportRow(tls, rescaler2)
 		(*(*func(*libc.TLS, uintptr, int32, int32))(unsafe.Pointer(&struct{ uintptr }{WebPMultARGBRow})))(tls, src, dst_width, int32(1))
 		ConvertToYUVA(tls, src, dst_width, y_pos, (*VP8LDecoder)(unsafe.Pointer(dec)).Foutput)
 		y_pos = y_pos + 1
 		num_lines_out = num_lines_out + 1
 	}
 	return num_lines_out
 }
 
 func EmitRescaledRowsYUVA(tls *libc.TLS, dec uintptr, in uintptr, in_stride int32, mb_h int32) (r int32) {
 	var lines_imported, lines_left, needed_lines, num_lines_in, y_pos int32
 	_, _, _, _, _ = lines_imported, lines_left, needed_lines, num_lines_in, y_pos
 	num_lines_in = 0
 	y_pos = (*VP8LDecoder)(unsafe.Pointer(dec)).Flast_out_row
 	for num_lines_in < mb_h {
 		lines_left = mb_h - num_lines_in
 		needed_lines = WebPRescaleNeededLines(tls, (*VP8LDecoder)(unsafe.Pointer(dec)).Frescaler, lines_left)
 		WebPMultARGBRows(tls, in, in_stride, (*WebPRescaler)(unsafe.Pointer((*VP8LDecoder)(unsafe.Pointer(dec)).Frescaler)).Fsrc_width, needed_lines, 0)
 		lines_imported = WebPRescalerImport(tls, (*VP8LDecoder)(unsafe.Pointer(dec)).Frescaler, lines_left, in, in_stride)
 		num_lines_in = num_lines_in + lines_imported
 		in = in + uintptr(needed_lines*in_stride)
 		y_pos = y_pos + ExportYUVA(tls, dec, y_pos)
 	}
 	return y_pos
 }
 
 func EmitRowsYUVA(tls *libc.TLS, dec uintptr, in uintptr, in_stride int32, mb_w int32, num_rows int32) (r int32) {
 	var y_pos, v1 int32
 	_, _ = y_pos, v1
 	y_pos = (*VP8LDecoder)(unsafe.Pointer(dec)).Flast_out_row
 	for {
 		v1 = num_rows
 		num_rows = num_rows - 1
 		if !(v1 > 0) {
 			break
 		}
 		ConvertToYUVA(tls, in, mb_w, y_pos, (*VP8LDecoder)(unsafe.Pointer(dec)).Foutput)
 		in = in + uintptr(in_stride)
 		y_pos = y_pos + 1
 	}
 	return y_pos
 }
 
 //------------------------------------------------------------------------------
 // Cropping.
 
 // C documentation
 //
 //	// Sets io->mb_y, io->mb_h & io->mb_w according to start row, end row and
 //	// crop options. Also updates the input data pointer, so that it points to the
 //	// start of the cropped window. Note that pixels are in ARGB format even if
 //	// 'in_data' is uint8_t*.
 //	// Returns true if the crop window is not empty.
 func SetCropWindow(tls *libc.TLS, io uintptr, y_start int32, y_end int32, in_data uintptr, pixel_stride int32) (r int32) {
 	var delta int32
 	_ = delta
 	if y_end > (*VP8Io)(unsafe.Pointer(io)).Fcrop_bottom {
 		y_end = (*VP8Io)(unsafe.Pointer(io)).Fcrop_bottom // make sure we don't overflow on last row.
 	}
 	if y_start < (*VP8Io)(unsafe.Pointer(io)).Fcrop_top {
 		delta = (*VP8Io)(unsafe.Pointer(io)).Fcrop_top - y_start
 		y_start = (*VP8Io)(unsafe.Pointer(io)).Fcrop_top
 		**(**uintptr)(__ccgo_up(in_data)) += uintptr(delta * pixel_stride)
 	}
 	if y_start >= y_end {
 		return 0
 	} // Crop window is empty.
 	**(**uintptr)(__ccgo_up(in_data)) += uintptr(libc.Uint64FromInt32((*VP8Io)(unsafe.Pointer(io)).Fcrop_left) * uint64(4))
 	(*VP8Io)(unsafe.Pointer(io)).Fmb_y = y_start - (*VP8Io)(unsafe.Pointer(io)).Fcrop_top
 	(*VP8Io)(unsafe.Pointer(io)).Fmb_w = (*VP8Io)(unsafe.Pointer(io)).Fcrop_right - (*VP8Io)(unsafe.Pointer(io)).Fcrop_left
 	(*VP8Io)(unsafe.Pointer(io)).Fmb_h = y_end - y_start
 	return int32(1) // Non-empty crop window.
 }
 
 //------------------------------------------------------------------------------
 
 func GetMetaIndex(tls *libc.TLS, image uintptr, xsize int32, bits int32, x int32, y int32) (r int32) {
 	if bits == 0 {
 		return 0
 	}
 	return libc.Int32FromUint32(**(**uint32_t)(__ccgo_up(image + uintptr(xsize*(y>>bits)+x>>bits)*4)))
 }
 
 func GetHtreeGroupForPos(tls *libc.TLS, hdr uintptr, x int32, y int32) (r uintptr) {
 	var meta_index int32
 	_ = meta_index
 	meta_index = GetMetaIndex(tls, (*VP8LMetadata)(unsafe.Pointer(hdr)).Fhuffman_image, (*VP8LMetadata)(unsafe.Pointer(hdr)).Fhuffman_xsize, (*VP8LMetadata)(unsafe.Pointer(hdr)).Fhuffman_subsample_bits, x, y)
 	return (*VP8LMetadata)(unsafe.Pointer(hdr)).Fhtree_groups + uintptr(meta_index)*568
 }
 
 //------------------------------------------------------------------------------
 // Main loop, with custom row-processing function
 
 type ProcessRowsFunc = uintptr
 
 func ApplyInverseTransforms(tls *libc.TLS, dec uintptr, start_row int32, num_rows int32, rows uintptr) {
 	var cache_pixs, end_row, n, v1 int32
 	var rows_in, rows_out, transform uintptr
 	_, _, _, _, _, _, _ = cache_pixs, end_row, n, rows_in, rows_out, transform, v1
 	n = (*VP8LDecoder)(unsafe.Pointer(dec)).Fnext_transform
 	cache_pixs = (*VP8LDecoder)(unsafe.Pointer(dec)).Fwidth * num_rows
 	end_row = start_row + num_rows
 	rows_in = rows
 	rows_out = (*VP8LDecoder)(unsafe.Pointer(dec)).Fargb_cache
 	// Inverse transforms.
 	for {
 		v1 = n
 		n = n - 1
 		if !(v1 > 0) {
 			break
 		}
 		transform = dec + 280 + uintptr(n)*24
 		VP8LInverseTransform(tls, transform, start_row, end_row, rows_in, rows_out)
 		rows_in = rows_out
 	}
 	if rows_in != rows_out {
 		// No transform called, hence just copy.
 		libc.X__builtin___memcpy_chk(tls, rows_out, rows_in, libc.Uint64FromInt32(cache_pixs)*uint64(4), ^__predefined_size_t(0))
 	}
 }
 
 // C documentation
 //
 //	// Processes (transforms, scales & color-converts) the rows decoded after the
 //	// last call.
 func ProcessRows(tls *libc.TLS, dec uintptr, row int32) {
 	bp := tls.Alloc(16)
 	defer tls.Free(16)
 	var buf, io, output, rgba, rows uintptr
 	var in_stride, num_rows, num_rows_out, v1, v3 int32
 	var _ /* rows_data at bp+0 */ uintptr
 	_, _, _, _, _, _, _, _, _, _ = buf, in_stride, io, num_rows, num_rows_out, output, rgba, rows, v1, v3
 	rows = (*VP8LDecoder)(unsafe.Pointer(dec)).Fpixels + uintptr((*VP8LDecoder)(unsafe.Pointer(dec)).Fwidth*(*VP8LDecoder)(unsafe.Pointer(dec)).Flast_row)*4
 	num_rows = row - (*VP8LDecoder)(unsafe.Pointer(dec)).Flast_row
 	// We can't process more than NUM_ARGB_CACHE_ROWS at a time (that's the size
 	// of argb_cache), but we currently don't need more than that.
 	if num_rows > 0 { // Emit output.
 		io = (*VP8LDecoder)(unsafe.Pointer(dec)).Fio
 		**(**uintptr)(__ccgo_up(bp)) = (*VP8LDecoder)(unsafe.Pointer(dec)).Fargb_cache
 		in_stride = libc.Int32FromUint64(libc.Uint64FromInt32((*VP8Io)(unsafe.Pointer(io)).Fwidth) * uint64(4)) // in unit of RGBA
 		ApplyInverseTransforms(tls, dec, (*VP8LDecoder)(unsafe.Pointer(dec)).Flast_row, num_rows, rows)
 		if !(SetCropWindow(tls, io, (*VP8LDecoder)(unsafe.Pointer(dec)).Flast_row, row, bp, in_stride) != 0) {
 			// Nothing to output (this time).
 		} else {
 			output = (*VP8LDecoder)(unsafe.Pointer(dec)).Foutput
 			v1 = libc.BoolInt32((*WebPDecBuffer)(unsafe.Pointer(output)).Fcolorspace < int32(MODE_YUV))
 			goto _2
 		_2:
 			if v1 != 0 { // convert to RGBA
 				buf = output + 16
 				rgba = (*WebPRGBABuffer)(unsafe.Pointer(buf)).Frgba + uintptr(int64((*VP8LDecoder)(unsafe.Pointer(dec)).Flast_out_row)*int64((*WebPRGBABuffer)(unsafe.Pointer(buf)).Fstride))
 				if (*VP8Io)(unsafe.Pointer(io)).Fuse_scaling != 0 {
 					v3 = EmitRescaledRowsRGBA(tls, dec, **(**uintptr)(__ccgo_up(bp)), in_stride, (*VP8Io)(unsafe.Pointer(io)).Fmb_h, rgba, (*WebPRGBABuffer)(unsafe.Pointer(buf)).Fstride)
 				} else {
 					v3 = EmitRows(tls, (*WebPDecBuffer)(unsafe.Pointer(output)).Fcolorspace, **(**uintptr)(__ccgo_up(bp)), in_stride, (*VP8Io)(unsafe.Pointer(io)).Fmb_w, (*VP8Io)(unsafe.Pointer(io)).Fmb_h, rgba, (*WebPRGBABuffer)(unsafe.Pointer(buf)).Fstride)
 				}
 				num_rows_out = v3
 				// Update 'last_out_row'.
 				**(**int32)(__ccgo_up(dec + 148)) += num_rows_out
 			} else { // convert to YUVA
 				if (*VP8Io)(unsafe.Pointer(io)).Fuse_scaling != 0 {
 					v1 = EmitRescaledRowsYUVA(tls, dec, **(**uintptr)(__ccgo_up(bp)), in_stride, (*VP8Io)(unsafe.Pointer(io)).Fmb_h)
 				} else {
 					v1 = EmitRowsYUVA(tls, dec, **(**uintptr)(__ccgo_up(bp)), in_stride, (*VP8Io)(unsafe.Pointer(io)).Fmb_w, (*VP8Io)(unsafe.Pointer(io)).Fmb_h)
 				}
 				(*VP8LDecoder)(unsafe.Pointer(dec)).Flast_out_row = v1
 			}
 		}
 	}
 	// Update 'last_row'.
 	(*VP8LDecoder)(unsafe.Pointer(dec)).Flast_row = row
 }
 
 // C documentation
 //
 //	// Row-processing for the special case when alpha data contains only one
 //	// transform (color indexing), and trivial non-green literals.
 func Is8bOptimizable(tls *libc.TLS, hdr uintptr) (r int32) {
 	var htrees uintptr
 	var i int32
 	_, _ = htrees, i
 	if (*VP8LMetadata)(unsafe.Pointer(hdr)).Fcolor_cache_size > 0 {
 		return 0
 	}
 	// When the Huffman tree contains only one symbol, we can skip the
 	// call to ReadSymbol() for red/blue/alpha channels.
 	i = 0
 	for {
 		if !(i < (*VP8LMetadata)(unsafe.Pointer(hdr)).Fnum_htree_groups) {
 			break
 		}
 		htrees = (*VP8LMetadata)(unsafe.Pointer(hdr)).Fhtree_groups + uintptr(i)*568
 		if libc.Int32FromUint8((**(**HuffmanCode)(__ccgo_up(**(**uintptr)(__ccgo_up(htrees + uintptr(RED)*8))))).Fbits) > 0 {
 			return 0
 		}
 		if libc.Int32FromUint8((**(**HuffmanCode)(__ccgo_up(**(**uintptr)(__ccgo_up(htrees + uintptr(BLUE)*8))))).Fbits) > 0 {
 			return 0
 		}
 		if libc.Int32FromUint8((**(**HuffmanCode)(__ccgo_up(**(**uintptr)(__ccgo_up(htrees + uintptr(ALPHA)*8))))).Fbits) > 0 {
 			return 0
 		}
 		goto _1
 	_1:
 		;
 		i = i + 1
 	}
 	return int32(1)
 }
 
 func AlphaApplyFilter(tls *libc.TLS, alph_dec uintptr, first_row int32, last_row int32, out uintptr, stride int32) {
 	var prev_line uintptr
 	var y int32
 	_, _ = prev_line, y
 	if (*ALPHDecoder)(unsafe.Pointer(alph_dec)).Ffilter != int32(WEBP_FILTER_NONE) {
 		prev_line = (*ALPHDecoder)(unsafe.Pointer(alph_dec)).Fprev_line
 		y = first_row
 		for {
 			if !(y < last_row) {
 				break
 			}
 			(*(*func(*libc.TLS, uintptr, uintptr, uintptr, int32))(unsafe.Pointer(&struct{ uintptr }{WebPUnfilters[(*ALPHDecoder)(unsafe.Pointer(alph_dec)).Ffilter]})))(tls, prev_line, out, out, stride)
 			prev_line = out
 			out = out + uintptr(stride)
 			goto _1
 		_1:
 			;
 			y = y + 1
 		}
 		(*ALPHDecoder)(unsafe.Pointer(alph_dec)).Fprev_line = prev_line
 	}
 }
 
 func ExtractPalettedAlphaRows(tls *libc.TLS, dec uintptr, last_row int32) {
 	var alph_dec, in, out, transform uintptr
 	var first_row, top_row, width, v1, v2 int32
 	_, _, _, _, _, _, _, _, _ = alph_dec, first_row, in, out, top_row, transform, width, v1, v2
 	// For vertical and gradient filtering, we need to decode the part above the
 	// crop_top row, in order to have the correct spatial predictors.
 	alph_dec = (*VP8Io)(unsafe.Pointer((*VP8LDecoder)(unsafe.Pointer(dec)).Fio)).Fopaque
 	if (*ALPHDecoder)(unsafe.Pointer(alph_dec)).Ffilter == int32(WEBP_FILTER_NONE) || (*ALPHDecoder)(unsafe.Pointer(alph_dec)).Ffilter == int32(WEBP_FILTER_HORIZONTAL) {
 		v1 = (*VP8Io)(unsafe.Pointer((*VP8LDecoder)(unsafe.Pointer(dec)).Fio)).Fcrop_top
 	} else {
 		v1 = (*VP8LDecoder)(unsafe.Pointer(dec)).Flast_row
 	}
 	top_row = v1
 	if (*VP8LDecoder)(unsafe.Pointer(dec)).Flast_row < top_row {
 		v2 = top_row
 	} else {
 		v2 = (*VP8LDecoder)(unsafe.Pointer(dec)).Flast_row
 	}
 	first_row = v2
 	if last_row > first_row {
 		// Special method for paletted alpha data. We only process the cropped area.
 		width = (*VP8Io)(unsafe.Pointer((*VP8LDecoder)(unsafe.Pointer(dec)).Fio)).Fwidth
 		out = (*ALPHDecoder)(unsafe.Pointer(alph_dec)).Foutput + uintptr(width*first_row)
 		in = (*VP8LDecoder)(unsafe.Pointer(dec)).Fpixels + uintptr((*VP8LDecoder)(unsafe.Pointer(dec)).Fwidth*first_row)
 		transform = dec + 280
 		VP8LColorIndexInverseTransformAlpha(tls, transform, first_row, last_row, in, out)
 		AlphaApplyFilter(tls, alph_dec, first_row, last_row, out, width)
 	}
 	v1 = last_row
 	(*VP8LDecoder)(unsafe.Pointer(dec)).Flast_out_row = v1
 	(*VP8LDecoder)(unsafe.Pointer(dec)).Flast_row = v1
 }
 
 //------------------------------------------------------------------------------
 // Helper functions for fast pattern copy (8b and 32b)
 
 // C documentation
 //
 //	// cyclic rotation of pattern word
 func Rotate8b(tls *libc.TLS, V uint32_t) (r uint32_t) {
 	return V&uint32(0xff)<<int32(24) | V>>libc.Int32FromInt32(8)
 }
 
 // C documentation
 //
 //	// copy 1, 2 or 4-bytes pattern
 func CopySmallPattern8b(tls *libc.TLS, src uintptr, dst uintptr, length int32, pattern uint32_t) {
 	var i int32
 	var v1, v2 uintptr
 	_, _, _ = i, v1, v2
 	// align 'dst' to 4-bytes boundary. Adjust the pattern along the way.
 	for uint64(dst)&uint64(3) != 0 {
 		v1 = dst
 		dst = dst + 1
 		v2 = src
 		src = src + 1
 		**(**uint8_t)(__ccgo_up(v1)) = **(**uint8_t)(__ccgo_up(v2))
 		pattern = Rotate8b(tls, pattern)
 		length = length - 1
 	}
 	// Copy the pattern 4 bytes at a time.
 	i = 0
 	for {
 		if !(i < length>>int32(2)) {
 			break
 		}
 		**(**uint32_t)(__ccgo_up(dst + uintptr(i)*4)) = pattern
 		goto _3
 	_3:
 		;
 		i = i + 1
 	}
 	// Finish with left-overs. 'pattern' is still correctly positioned,
 	// so no Rotate8b() call is needed.
 	i = i << int32(2)
 	for {
 		if !(i < length) {
 			break
 		}
 		**(**uint8_t)(__ccgo_up(dst + uintptr(i))) = **(**uint8_t)(__ccgo_up(src + uintptr(i)))
 		goto _4
 	_4:
 		;
 		i = i + 1
 	}
 }
 
 func CopyBlock8b(tls *libc.TLS, dst uintptr, dist int32, length int32) {
 	bp := tls.Alloc(16)
 	defer tls.Free(16)
 	var i int32
 	var src uintptr
 	var _ /* pattern at bp+0 */ uint32_t
 	_, _ = i, src
 	src = dst - uintptr(dist)
 	if length >= int32(8) {
 		**(**uint32_t)(__ccgo_up(bp)) = uint32(0)
 		switch dist {
 		case int32(1):
 			**(**uint32_t)(__ccgo_up(bp)) = uint32(**(**uint8_t)(__ccgo_up(src)))
 			**(**uint32_t)(__ccgo_up(bp)) = uint32(0x01010101) * **(**uint32_t)(__ccgo_up(bp))
 		case int32(2):
 			libc.X__builtin___memcpy_chk(tls, bp, src, uint64(2), ^__predefined_size_t(0))
 			**(**uint32_t)(__ccgo_up(bp)) = uint32(0x00010001) * **(**uint32_t)(__ccgo_up(bp))
 		case int32(4):
 			libc.X__builtin___memcpy_chk(tls, bp, src, uint64(4), ^__predefined_size_t(0))
 		default:
 			goto Copy
 		}
 		CopySmallPattern8b(tls, src, dst, length, **(**uint32_t)(__ccgo_up(bp)))
 		return
 	}
 	goto Copy
 Copy:
 	;
 	if dist >= length { // no overlap -> use memcpy()
 		libc.X__builtin___memcpy_chk(tls, dst, src, libc.Uint64FromInt32(length)*uint64(1), ^__predefined_size_t(0))
 	} else {
 		i = 0
 		for {
 			if !(i < length) {
 				break
 			}
 			**(**uint8_t)(__ccgo_up(dst + uintptr(i))) = **(**uint8_t)(__ccgo_up(src + uintptr(i)))
 			goto _1
 		_1:
 			;
 			i = i + 1
 		}
 	}
 }
 
 // C documentation
 //
 //	// copy pattern of 1 or 2 uint32_t's
 func CopySmallPattern32b(tls *libc.TLS, src uintptr, dst uintptr, length int32, pattern uint64_t) {
 	var i int32
 	var v1, v2 uintptr
 	_, _, _ = i, v1, v2
 	if uint64(dst)&uint64(4) != 0 { // Align 'dst' to 8-bytes boundary.
 		v1 = dst
 		dst += 4
 		v2 = src
 		src += 4
 		**(**uint32_t)(__ccgo_up(v1)) = **(**uint32_t)(__ccgo_up(v2))
 		pattern = pattern>>libc.Int32FromInt32(32) | pattern<<libc.Int32FromInt32(32)
 		length = length - 1
 	}
 	i = 0
 	for {
 		if !(i < length>>int32(1)) {
 			break
 		}
 		**(**uint64_t)(__ccgo_up(dst + uintptr(i)*8)) = pattern // Copy the pattern 8 bytes at a time.
 		goto _3
 	_3:
 		;
 		i = i + 1
 	}
 	if length&int32(1) != 0 { // Finish with left-over.
 		**(**uint32_t)(__ccgo_up(dst + uintptr(i<<int32(1))*4)) = **(**uint32_t)(__ccgo_up(src + uintptr(i<<int32(1))*4))
 	}
 }
 
 func CopyBlock32b(tls *libc.TLS, dst uintptr, dist int32, length int32) {
 	bp := tls.Alloc(16)
 	defer tls.Free(16)
 	var i int32
 	var src uintptr
 	var _ /* pattern at bp+0 */ uint64_t
 	_, _ = i, src
 	src = dst - uintptr(dist)*4
 	if dist <= int32(2) && length >= int32(4) && uint64(dst)&uint64(3) == uint64(0) {
 		if dist == int32(1) {
 			**(**uint64_t)(__ccgo_up(bp)) = uint64(**(**uint32_t)(__ccgo_up(src)))
 			**(**uint64_t)(__ccgo_up(bp)) = **(**uint64_t)(__ccgo_up(bp)) | **(**uint64_t)(__ccgo_up(bp))<<int32(32)
 		} else {
 			libc.X__builtin___memcpy_chk(tls, bp, src, uint64(8), ^__predefined_size_t(0))
 		}
 		CopySmallPattern32b(tls, src, dst, length, **(**uint64_t)(__ccgo_up(bp)))
 	} else {
 		if dist >= length { // no overlap
 			libc.X__builtin___memcpy_chk(tls, dst, src, libc.Uint64FromInt32(length)*uint64(4), ^__predefined_size_t(0))
 		} else {
 			i = 0
 			for {
 				if !(i < length) {
 					break
 				}
 				**(**uint32_t)(__ccgo_up(dst + uintptr(i)*4)) = **(**uint32_t)(__ccgo_up(src + uintptr(i)*4))
 				goto _1
 			_1:
 				;
 				i = i + 1
 			}
 		}
 	}
 }
 
 //------------------------------------------------------------------------------
 
 func DecodeAlphaData(tls *libc.TLS, dec uintptr, data uintptr, width int32, height int32, last_row int32) (r int32) {
 	var br2, hdr, htree_group, v1 uintptr
 	var code, col, dist, dist_code, dist_symbol, end, last, len_code_limit, length, length_sym, mask, ok, pos, row, v5 int32
 	_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = br2, code, col, dist, dist_code, dist_symbol, end, hdr, htree_group, last, len_code_limit, length, length_sym, mask, ok, pos, row, v1, v5
 	ok = int32(1)
 	row = (*VP8LDecoder)(unsafe.Pointer(dec)).Flast_pixel / width
 	col = (*VP8LDecoder)(unsafe.Pointer(dec)).Flast_pixel % width
 	br2 = dec + 40
 	hdr = dec + 152
 	pos = (*VP8LDecoder)(unsafe.Pointer(dec)).Flast_pixel // current position
 	end = width * height                                  // End of data
 	last = width * last_row                               // Last pixel to decode
 	len_code_limit = libc.Int32FromInt32(NUM_LITERAL_CODES) + libc.Int32FromInt32(NUM_LENGTH_CODES)
 	mask = (*VP8LMetadata)(unsafe.Pointer(hdr)).Fhuffman_mask
 	if pos < last {
 		v1 = GetHtreeGroupForPos(tls, hdr, col, row)
 	} else {
 		v1 = libc.UintptrFromInt32(0)
 	}
 	htree_group = v1
 	for !((*VP8LBitReader)(unsafe.Pointer(br2)).Feos != 0) && pos < last {
 		// Only update when changing tile.
 		if col&mask == 0 {
 			htree_group = GetHtreeGroupForPos(tls, hdr, col, row)
 		}
 		v1 = br2
 		if (*VP8LBitReader)(unsafe.Pointer(v1)).Fbit_pos >= libc.Int32FromInt32(VP8L_WBITS) {
 			VP8LDoFillBitWindow(tls, v1)
 		}
 		code = ReadSymbol(tls, **(**uintptr)(__ccgo_up(htree_group + uintptr(GREEN)*8)), br2)
 		if code < int32(NUM_LITERAL_CODES) { // Literal
 			**(**uint8_t)(__ccgo_up(data + uintptr(pos))) = libc.Uint8FromInt32(code)
 			pos = pos + 1
 			col = col + 1
 			if col >= width {
 				col = 0
 				row = row + 1
 				if row <= last_row && row%int32(NUM_ARGB_CACHE_ROWS) == 0 {
 					ExtractPalettedAlphaRows(tls, dec, row)
 				}
 			}
 		} else {
 			if code < len_code_limit {
 				length_sym = code - int32(NUM_LITERAL_CODES)
 				length = GetCopyLength(tls, length_sym, br2)
 				dist_symbol = ReadSymbol(tls, **(**uintptr)(__ccgo_up(htree_group + uintptr(DIST)*8)), br2)
 				v1 = br2
 				if (*VP8LBitReader)(unsafe.Pointer(v1)).Fbit_pos >= libc.Int32FromInt32(VP8L_WBITS) {
 					VP8LDoFillBitWindow(tls, v1)
 				}
 				dist_code = GetCopyDistance(tls, dist_symbol, br2)
 				dist = PlaneCodeToDistance(tls, width, dist_code)
 				if pos >= dist && end-pos >= length {
 					CopyBlock8b(tls, data+uintptr(pos), dist, length)
 				} else {
 					ok = 0
 					goto End
 				}
 				pos = pos + length
 				col = col + length
 				for col >= width {
 					col = col - width
 					row = row + 1
 					if row <= last_row && row%int32(NUM_ARGB_CACHE_ROWS) == 0 {
 						ExtractPalettedAlphaRows(tls, dec, row)
 					}
 				}
 				if pos < last && col&mask != 0 {
 					htree_group = GetHtreeGroupForPos(tls, hdr, col, row)
 				}
 			} else { // Not reached
 				ok = 0
 				goto End
 			}
 		}
 		v1 = br2
 		v5 = libc.BoolInt32((*VP8LBitReader)(unsafe.Pointer(v1)).Feos != 0 || (*VP8LBitReader)(unsafe.Pointer(v1)).Fpos == (*VP8LBitReader)(unsafe.Pointer(v1)).Flen1 && (*VP8LBitReader)(unsafe.Pointer(v1)).Fbit_pos > int32(VP8L_LBITS))
 		goto _6
 	_6:
 		(*VP8LBitReader)(unsafe.Pointer(br2)).Feos = v5
 	}
 	// Process the remaining rows corresponding to last row-block.
 	if row > last_row {
 		v5 = last_row
 	} else {
 		v5 = row
 	}
 	ExtractPalettedAlphaRows(tls, dec, v5)
 	goto End
 End:
 	;
 	v1 = br2
 	v5 = libc.BoolInt32((*VP8LBitReader)(unsafe.Pointer(v1)).Feos != 0 || (*VP8LBitReader)(unsafe.Pointer(v1)).Fpos == (*VP8LBitReader)(unsafe.Pointer(v1)).Flen1 && (*VP8LBitReader)(unsafe.Pointer(v1)).Fbit_pos > int32(VP8L_LBITS))
 	goto _10
 _10:
 	(*VP8LBitReader)(unsafe.Pointer(br2)).Feos = v5
 	if !(ok != 0) || (*VP8LBitReader)(unsafe.Pointer(br2)).Feos != 0 && pos < end {
 		if (*VP8LBitReader)(unsafe.Pointer(br2)).Feos != 0 {
 			v5 = int32(VP8_STATUS_SUSPENDED)
 		} else {
 			v5 = int32(VP8_STATUS_BITSTREAM_ERROR)
 		}
 		return VP8LSetError(tls, dec, v5)
 	}
 	(*VP8LDecoder)(unsafe.Pointer(dec)).Flast_pixel = pos
 	return ok
 }
 
 func SaveState(tls *libc.TLS, dec uintptr, last_pixel int32) {
 	(*VP8LDecoder)(unsafe.Pointer(dec)).Fsaved_br = (*VP8LDecoder)(unsafe.Pointer(dec)).Fbr
 	(*VP8LDecoder)(unsafe.Pointer(dec)).Fsaved_last_pixel = last_pixel
 	if (*VP8LDecoder)(unsafe.Pointer(dec)).Fhdr.Fcolor_cache_size > 0 {
 		VP8LColorCacheCopy(tls, dec+152+8, dec+152+24)
 	}
 }
 
 func RestoreState(tls *libc.TLS, dec uintptr) {
 	(*VP8LDecoder)(unsafe.Pointer(dec)).Fstatus = int32(VP8_STATUS_SUSPENDED)
 	(*VP8LDecoder)(unsafe.Pointer(dec)).Fbr = (*VP8LDecoder)(unsafe.Pointer(dec)).Fsaved_br
 	(*VP8LDecoder)(unsafe.Pointer(dec)).Flast_pixel = (*VP8LDecoder)(unsafe.Pointer(dec)).Fsaved_last_pixel
 	if (*VP8LDecoder)(unsafe.Pointer(dec)).Fhdr.Fcolor_cache_size > 0 {
 		VP8LColorCacheCopy(tls, dec+152+24, dec+152+8)
 	}
 }
 
 func DecodeImageData(tls *libc.TLS, dec uintptr, data uintptr, width int32, height int32, last_row int32, __ccgo_fp_process_func ProcessRowsFunc) (r int32) {
 	var alpha, blue, code, col, color_cache_limit, dist, dist_code, dist_symbol, key1, key2, len_code_limit, length, length_sym, mask, next_sync_row, red, row, v1 int32
 	var br2, color_cache, hdr, htree_group, last_cached, src, src_end, src_last, v2, v3 uintptr
 	var v21 uint32_t
 	_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = alpha, blue, br2, code, col, color_cache, color_cache_limit, dist, dist_code, dist_symbol, hdr, htree_group, key1, key2, last_cached, len_code_limit, length, length_sym, mask, next_sync_row, red, row, src, src_end, src_last, v1, v2, v21, v3
 	row = (*VP8LDecoder)(unsafe.Pointer(dec)).Flast_pixel / width
 	col = (*VP8LDecoder)(unsafe.Pointer(dec)).Flast_pixel % width
 	br2 = dec + 40
 	hdr = dec + 152
 	src = data + uintptr((*VP8LDecoder)(unsafe.Pointer(dec)).Flast_pixel)*4
 	last_cached = src
 	src_end = data + uintptr(width*height)*4    // End of data
 	src_last = data + uintptr(width*last_row)*4 // Last pixel to decode
 	len_code_limit = libc.Int32FromInt32(NUM_LITERAL_CODES) + libc.Int32FromInt32(NUM_LENGTH_CODES)
 	color_cache_limit = len_code_limit + (*VP8LMetadata)(unsafe.Pointer(hdr)).Fcolor_cache_size
 	if (*VP8LDecoder)(unsafe.Pointer(dec)).Fincremental != 0 {
 		v1 = row
 	} else {
 		v1 = libc.Int32FromInt32(1) << libc.Int32FromInt32(24)
 	}
 	next_sync_row = v1
 	if (*VP8LMetadata)(unsafe.Pointer(hdr)).Fcolor_cache_size > 0 {
 		v2 = hdr + 8
 	} else {
 		v2 = libc.UintptrFromInt32(0)
 	}
 	color_cache = v2
 	mask = (*VP8LMetadata)(unsafe.Pointer(hdr)).Fhuffman_mask
 	if src < src_last {
 		v3 = GetHtreeGroupForPos(tls, hdr, col, row)
 	} else {
 		v3 = libc.UintptrFromInt32(0)
 	}
 	htree_group = v3
 _5:
 	;
 	if !(src < src_last) {
 		goto _4
 	}
 	if row >= next_sync_row {
 		SaveState(tls, dec, int32((int64(src)-int64(data))/4))
 		next_sync_row = row + int32(SYNC_EVERY_N_ROWS)
 	}
 	// Only update when changing tile. Note we could use this test:
 	// if "((((prev_col ^ col) | prev_row ^ row)) > mask)" -> tile changed
 	// but that's actually slower and needs storing the previous col/row.
 	if col&mask == 0 {
 		htree_group = GetHtreeGroupForPos(tls, hdr, col, row)
 	}
 	if (*HTreeGroup)(unsafe.Pointer(htree_group)).Fis_trivial_code != 0 {
 		**(**uint32_t)(__ccgo_up(src)) = (*HTreeGroup)(unsafe.Pointer(htree_group)).Fliteral_arb
 		goto AdvanceByOne
 	}
 	v2 = br2
 	if (*VP8LBitReader)(unsafe.Pointer(v2)).Fbit_pos >= libc.Int32FromInt32(VP8L_WBITS) {
 		VP8LDoFillBitWindow(tls, v2)
 	}
 	if (*HTreeGroup)(unsafe.Pointer(htree_group)).Fuse_packed_table != 0 {
 		code = ReadPackedSymbols(tls, htree_group, br2, src)
 		v2 = br2
 		v1 = libc.BoolInt32((*VP8LBitReader)(unsafe.Pointer(v2)).Feos != 0 || (*VP8LBitReader)(unsafe.Pointer(v2)).Fpos == (*VP8LBitReader)(unsafe.Pointer(v2)).Flen1 && (*VP8LBitReader)(unsafe.Pointer(v2)).Fbit_pos > int32(VP8L_LBITS))
 		goto _9
 	_9:
 		if v1 != 0 {
 			goto _4
 		}
 		if code == PACKED_NON_LITERAL_CODE {
 			goto AdvanceByOne
 		}
 	} else {
 		code = ReadSymbol(tls, **(**uintptr)(__ccgo_up(htree_group + uintptr(GREEN)*8)), br2)
 	}
 	v2 = br2
 	v1 = libc.BoolInt32((*VP8LBitReader)(unsafe.Pointer(v2)).Feos != 0 || (*VP8LBitReader)(unsafe.Pointer(v2)).Fpos == (*VP8LBitReader)(unsafe.Pointer(v2)).Flen1 && (*VP8LBitReader)(unsafe.Pointer(v2)).Fbit_pos > int32(VP8L_LBITS))
 	goto _12
 _12:
 	if v1 != 0 {
 		goto _4
 	}
 	if !(code < int32(NUM_LITERAL_CODES)) {
 		goto _13
 	} // Literal
 	if (*HTreeGroup)(unsafe.Pointer(htree_group)).Fis_trivial_literal != 0 {
 		**(**uint32_t)(__ccgo_up(src)) = (*HTreeGroup)(unsafe.Pointer(htree_group)).Fliteral_arb | libc.Uint32FromInt32(code<<libc.Int32FromInt32(8))
 	} else {
 		red = ReadSymbol(tls, **(**uintptr)(__ccgo_up(htree_group + uintptr(RED)*8)), br2)
 		v2 = br2
 		if (*VP8LBitReader)(unsafe.Pointer(v2)).Fbit_pos >= libc.Int32FromInt32(VP8L_WBITS) {
 			VP8LDoFillBitWindow(tls, v2)
 		}
 		blue = ReadSymbol(tls, **(**uintptr)(__ccgo_up(htree_group + uintptr(BLUE)*8)), br2)
 		alpha = ReadSymbol(tls, **(**uintptr)(__ccgo_up(htree_group + uintptr(ALPHA)*8)), br2)
 		v2 = br2
 		v1 = libc.BoolInt32((*VP8LBitReader)(unsafe.Pointer(v2)).Feos != 0 || (*VP8LBitReader)(unsafe.Pointer(v2)).Fpos == (*VP8LBitReader)(unsafe.Pointer(v2)).Flen1 && (*VP8LBitReader)(unsafe.Pointer(v2)).Fbit_pos > int32(VP8L_LBITS))
 		goto _18
 	_18:
 		if v1 != 0 {
 			goto _4
 		}
 		**(**uint32_t)(__ccgo_up(src)) = libc.Uint32FromInt32(alpha)<<libc.Int32FromInt32(24) | libc.Uint32FromInt32(red<<libc.Int32FromInt32(16)) | libc.Uint32FromInt32(code<<libc.Int32FromInt32(8)) | libc.Uint32FromInt32(blue)
 	}
 	goto AdvanceByOne
 AdvanceByOne:
 	;
 	src += 4
 	col = col + 1
 	if col >= width {
 		col = 0
 		row = row + 1
 		if __ccgo_fp_process_func != libc.UintptrFromInt32(0) {
 			if row <= last_row && row%int32(NUM_ARGB_CACHE_ROWS) == 0 {
 				(*(*func(*libc.TLS, uintptr, int32))(unsafe.Pointer(&struct{ uintptr }{__ccgo_fp_process_func})))(tls, dec, row)
 			}
 		}
 		if color_cache != libc.UintptrFromInt32(0) {
 			for last_cached < src {
 				v2 = last_cached
 				last_cached += 4
 				v3 = color_cache
 				v21 = **(**uint32_t)(__ccgo_up(v2))
 				v1 = libc.Int32FromUint32(v21 * kHashMul8 >> (*VP8LColorCache)(unsafe.Pointer(v3)).Fhash_shift)
 				goto _23
 			_23:
 				key1 = v1
 				**(**uint32_t)(__ccgo_up((*VP8LColorCache)(unsafe.Pointer(v3)).Fcolors + uintptr(key1)*4)) = v21
 			}
 		}
 	}
 	goto _14
 _13:
 	;
 	if code < len_code_limit {
 		length_sym = code - int32(NUM_LITERAL_CODES)
 		length = GetCopyLength(tls, length_sym, br2)
 		dist_symbol = ReadSymbol(tls, **(**uintptr)(__ccgo_up(htree_group + uintptr(DIST)*8)), br2)
 		v2 = br2
 		if (*VP8LBitReader)(unsafe.Pointer(v2)).Fbit_pos >= libc.Int32FromInt32(VP8L_WBITS) {
 			VP8LDoFillBitWindow(tls, v2)
 		}
 		dist_code = GetCopyDistance(tls, dist_symbol, br2)
 		dist = PlaneCodeToDistance(tls, width, dist_code)
 		v2 = br2
 		v1 = libc.BoolInt32((*VP8LBitReader)(unsafe.Pointer(v2)).Feos != 0 || (*VP8LBitReader)(unsafe.Pointer(v2)).Fpos == (*VP8LBitReader)(unsafe.Pointer(v2)).Flen1 && (*VP8LBitReader)(unsafe.Pointer(v2)).Fbit_pos > int32(VP8L_LBITS))
 		goto _27
 	_27:
 		if v1 != 0 {
 			goto _4
 		}
 		if (int64(src)-int64(data))/4 < int64(dist) || (int64(src_end)-int64(src))/4 < int64(length) {
 			goto Error
 		} else {
 			CopyBlock32b(tls, src, dist, length)
 		}
 		src = src + uintptr(length)*4
 		col = col + length
 		for col >= width {
 			col = col - width
 			row = row + 1
 			if __ccgo_fp_process_func != libc.UintptrFromInt32(0) {
 				if row <= last_row && row%int32(NUM_ARGB_CACHE_ROWS) == 0 {
 					(*(*func(*libc.TLS, uintptr, int32))(unsafe.Pointer(&struct{ uintptr }{__ccgo_fp_process_func})))(tls, dec, row)
 				}
 			}
 		}
 		// Because of the check done above (before 'src' was incremented by
 		// 'length'), the following holds true.
 		if col&mask != 0 {
 			htree_group = GetHtreeGroupForPos(tls, hdr, col, row)
 		}
 		if color_cache != libc.UintptrFromInt32(0) {
 			for last_cached < src {
 				v2 = last_cached
 				last_cached += 4
 				v3 = color_cache
 				v21 = **(**uint32_t)(__ccgo_up(v2))
 				v1 = libc.Int32FromUint32(v21 * kHashMul8 >> (*VP8LColorCache)(unsafe.Pointer(v3)).Fhash_shift)
 				goto _32
 			_32:
 				key1 = v1
 				**(**uint32_t)(__ccgo_up((*VP8LColorCache)(unsafe.Pointer(v3)).Fcolors + uintptr(key1)*4)) = v21
 			}
 		}
 	} else {
 		if code < color_cache_limit { // Color cache
 			key2 = code - len_code_limit
 			for last_cached < src {
 				v2 = last_cached
 				last_cached += 4
 				v3 = color_cache
 				v21 = **(**uint32_t)(__ccgo_up(v2))
 				v1 = libc.Int32FromUint32(v21 * kHashMul8 >> (*VP8LColorCache)(unsafe.Pointer(v3)).Fhash_shift)
 				goto _37
 			_37:
 				key1 = v1
 				**(**uint32_t)(__ccgo_up((*VP8LColorCache)(unsafe.Pointer(v3)).Fcolors + uintptr(key1)*4)) = v21
 			}
 			v21 = **(**uint32_t)(__ccgo_up((*VP8LColorCache)(unsafe.Pointer(color_cache)).Fcolors + uintptr(libc.Uint32FromInt32(key2))*4))
 			goto _39
 		_39:
 			**(**uint32_t)(__ccgo_up(src)) = v21
 			goto AdvanceByOne
 		} else { // Not reached
 			goto Error
 		}
 	}
 _14:
 	;
 	goto _5
 _4:
 	;
 	v2 = br2
 	v1 = libc.BoolInt32((*VP8LBitReader)(unsafe.Pointer(v2)).Feos != 0 || (*VP8LBitReader)(unsafe.Pointer(v2)).Fpos == (*VP8LBitReader)(unsafe.Pointer(v2)).Flen1 && (*VP8LBitReader)(unsafe.Pointer(v2)).Fbit_pos > int32(VP8L_LBITS))
 	goto _42
 _42:
 	(*VP8LBitReader)(unsafe.Pointer(br2)).Feos = v1
 	// In incremental decoding:
 	// br->eos && src < src_last: if 'br' reached the end of the buffer and
 	// 'src_last' has not been reached yet, there is not enough data. 'dec' has to
 	// be reset until there is more data.
 	// !br->eos && src < src_last: this cannot happen as either the buffer is
 	// fully read, either enough has been read to reach 'src_last'.
 	// src >= src_last: 'src_last' is reached, all is fine. 'src' can actually go
 	// beyond 'src_last' in case the image is cropped and an LZ77 goes further.
 	// The buffer might have been enough or there is some left. 'br->eos' does
 	// not matter.
 	if (*VP8LDecoder)(unsafe.Pointer(dec)).Fincremental != 0 && (*VP8LBitReader)(unsafe.Pointer(br2)).Feos != 0 && src < src_last {
 		RestoreState(tls, dec)
 	} else {
 		if (*VP8LDecoder)(unsafe.Pointer(dec)).Fincremental != 0 && src >= src_last || !((*VP8LBitReader)(unsafe.Pointer(br2)).Feos != 0) {
 			// Process the remaining rows corresponding to last row-block.
 			if __ccgo_fp_process_func != libc.UintptrFromInt32(0) {
 				if row > last_row {
 					v1 = last_row
 				} else {
 					v1 = row
 				}
 				(*(*func(*libc.TLS, uintptr, int32))(unsafe.Pointer(&struct{ uintptr }{__ccgo_fp_process_func})))(tls, dec, v1)
 			}
 			(*VP8LDecoder)(unsafe.Pointer(dec)).Fstatus = int32(VP8_STATUS_OK)
 			(*VP8LDecoder)(unsafe.Pointer(dec)).Flast_pixel = int32((int64(src) - int64(data)) / 4) // end-of-scan marker
 		} else {
 			// if not incremental, and we are past the end of buffer (eos=1), then this
 			// is a real bitstream error.
 			goto Error
 		}
 	}
 	return int32(1)
 	goto Error
 Error:
 	;
 	return VP8LSetError(tls, dec, int32(VP8_STATUS_BITSTREAM_ERROR))
 	return r
 }
 
 // -----------------------------------------------------------------------------
 // VP8LTransform
 
 func ClearTransform(tls *libc.TLS, transform uintptr) {
 	WebPSafeFree(tls, (*VP8LTransform)(unsafe.Pointer(transform)).Fdata)
 	(*VP8LTransform)(unsafe.Pointer(transform)).Fdata = libc.UintptrFromInt32(0)
 }
 
 // C documentation
 //
 //	// For security reason, we need to remap the color map to span
 //	// the total possible bundled values, and not just the num_colors.
 func ExpandColorMap(tls *libc.TLS, num_colors int32, transform uintptr) (r int32) {
 	var data, new_color_map, new_data uintptr
 	var final_num_colors, i int32
 	_, _, _, _, _ = data, final_num_colors, i, new_color_map, new_data
 	final_num_colors = int32(1) << (int32(8) >> (*VP8LTransform)(unsafe.Pointer(transform)).Fbits)
 	new_color_map = WebPSafeMalloc(tls, libc.Uint64FromInt32(final_num_colors), uint64(4))
 	if new_color_map == libc.UintptrFromInt32(0) {
 		return 0
 	} else {
 		data = (*VP8LTransform)(unsafe.Pointer(transform)).Fdata
 		new_data = new_color_map
 		**(**uint32_t)(__ccgo_up(new_color_map)) = **(**uint32_t)(__ccgo_up((*VP8LTransform)(unsafe.Pointer(transform)).Fdata))
 		i = int32(4)
 		for {
 			if !(i < int32(4)*num_colors) {
 				break
 			}
 			// Equivalent to VP8LAddPixels(), on a byte-basis.
 			**(**uint8_t)(__ccgo_up(new_data + uintptr(i))) = libc.Uint8FromInt32((libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(data + uintptr(i)))) + libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(new_data + uintptr(i-int32(4)))))) & int32(0xff))
 			goto _1
 		_1:
 			;
 			i = i + 1
 		}
 		for {
 			if !(i < int32(4)*final_num_colors) {
 				break
 			}
 			**(**uint8_t)(__ccgo_up(new_data + uintptr(i))) = uint8(0) // black tail.
 			goto _2
 		_2:
 			;
 			i = i + 1
 		}
 		WebPSafeFree(tls, (*VP8LTransform)(unsafe.Pointer(transform)).Fdata)
 		(*VP8LTransform)(unsafe.Pointer(transform)).Fdata = new_color_map
 	}
 	return int32(1)
 }
 
 func ReadTransform(tls *libc.TLS, xsize uintptr, ysize uintptr, dec uintptr) (r int32) {
 	var bits, num_colors, ok, v7, v8, v9 int32
 	var br, transform uintptr
 	var type1 VP8LImageTransformType
 	var v1, v2, v4, v5 uint32_t
 	_, _, _, _, _, _, _, _, _, _, _, _, _ = bits, br, num_colors, ok, transform, type1, v1, v2, v4, v5, v7, v8, v9
 	ok = int32(1)
 	br = dec + 40
 	transform = dec + 280 + uintptr((*VP8LDecoder)(unsafe.Pointer(dec)).Fnext_transform)*24
 	type1 = libc.Int32FromUint32(VP8LReadBits(tls, br, int32(2)))
 	// Each transform type can only be present once in the stream.
 	if (*VP8LDecoder)(unsafe.Pointer(dec)).Ftransforms_seen&(uint32(1)<<type1) != 0 {
 		return 0 // Already there, let's not accept the second same transform.
 	}
 	**(**uint32_t)(__ccgo_up(dec + 376)) |= uint32(1) << type1
 	(*VP8LTransform)(unsafe.Pointer(transform)).Ftype1 = type1
 	(*VP8LTransform)(unsafe.Pointer(transform)).Fxsize = **(**int32)(__ccgo_up(xsize))
 	(*VP8LTransform)(unsafe.Pointer(transform)).Fysize = **(**int32)(__ccgo_up(ysize))
 	(*VP8LTransform)(unsafe.Pointer(transform)).Fdata = libc.UintptrFromInt32(0)
 	(*VP8LDecoder)(unsafe.Pointer(dec)).Fnext_transform = (*VP8LDecoder)(unsafe.Pointer(dec)).Fnext_transform + 1
 	switch type1 {
 	case int32(PREDICTOR_TRANSFORM):
 		fallthrough
 	case int32(CROSS_COLOR_TRANSFORM):
 		(*VP8LTransform)(unsafe.Pointer(transform)).Fbits = libc.Int32FromUint32(uint32(MIN_TRANSFORM_BITS) + VP8LReadBits(tls, br, int32(NUM_TRANSFORM_BITS)))
 		v1 = libc.Uint32FromInt32((*VP8LTransform)(unsafe.Pointer(transform)).Fbits)
 		v2 = (libc.Uint32FromInt32((*VP8LTransform)(unsafe.Pointer(transform)).Fxsize) + libc.Uint32FromInt32(libc.Int32FromInt32(1)<<v1) - uint32(1)) >> v1
 		goto _3
 	_3:
 		v4 = libc.Uint32FromInt32((*VP8LTransform)(unsafe.Pointer(transform)).Fbits)
 		v5 = (libc.Uint32FromInt32((*VP8LTransform)(unsafe.Pointer(transform)).Fysize) + libc.Uint32FromInt32(libc.Int32FromInt32(1)<<v4) - uint32(1)) >> v4
 		goto _6
 	_6:
 		ok = DecodeImageStream(tls, libc.Int32FromUint32(v2), libc.Int32FromUint32(v5), 0, dec, transform+16)
 	case int32(COLOR_INDEXING_TRANSFORM):
 		num_colors = libc.Int32FromUint32(VP8LReadBits(tls, br, int32(8)) + uint32(1))
 		if num_colors > int32(16) {
 			v7 = 0
 		} else {
 			if num_colors > int32(4) {
 				v8 = int32(1)
 			} else {
 				if num_colors > int32(2) {
 					v9 = int32(2)
 				} else {
 					v9 = int32(3)
 				}
 				v8 = v9
 			}
 			v7 = v8
 		}
 		bits = v7
 		v1 = libc.Uint32FromInt32(bits)
 		v2 = (libc.Uint32FromInt32((*VP8LTransform)(unsafe.Pointer(transform)).Fxsize) + libc.Uint32FromInt32(libc.Int32FromInt32(1)<<v1) - uint32(1)) >> v1
 		goto _12
 	_12:
 		**(**int32)(__ccgo_up(xsize)) = libc.Int32FromUint32(v2)
 		(*VP8LTransform)(unsafe.Pointer(transform)).Fbits = bits
 		ok = DecodeImageStream(tls, num_colors, int32(1), 0, dec, transform+16)
 		if ok != 0 && !(ExpandColorMap(tls, num_colors, transform) != 0) {
 			return VP8LSetError(tls, dec, int32(VP8_STATUS_OUT_OF_MEMORY))
 		}
 	case int32(SUBTRACT_GREEN_TRANSFORM):
 	default:
 		// can't happen
 		break
 	}
 	return ok
 }
 
 // -----------------------------------------------------------------------------
 // VP8LMetadata
 
 func InitMetadata(tls *libc.TLS, hdr uintptr) {
 	libc.X__builtin___memset_chk(tls, hdr, 0, uint64(120), ^__predefined_size_t(0))
 }
 
 func ClearMetadata(tls *libc.TLS, hdr uintptr) {
 	WebPSafeFree(tls, (*VP8LMetadata)(unsafe.Pointer(hdr)).Fhuffman_image)
 	VP8LHuffmanTablesDeallocate(tls, hdr+80)
 	VP8LHtreeGroupsFree(tls, (*VP8LMetadata)(unsafe.Pointer(hdr)).Fhtree_groups)
 	VP8LColorCacheClear(tls, hdr+8)
 	VP8LColorCacheClear(tls, hdr+24)
 	InitMetadata(tls, hdr)
 }
 
 // -----------------------------------------------------------------------------
 // VP8LDecoder
 
 func VP8LNew(tls *libc.TLS) (r uintptr) {
 	var dec uintptr
 	_ = dec
 	dec = WebPSafeCalloc(tls, uint64(1), uint64(400))
 	if dec == libc.UintptrFromInt32(0) {
 		return libc.UintptrFromInt32(0)
 	}
 	(*VP8LDecoder)(unsafe.Pointer(dec)).Fstatus = int32(VP8_STATUS_OK)
 	(*VP8LDecoder)(unsafe.Pointer(dec)).Fstate = int32(READ_DIM)
 	VP8LDspInit(tls) // Init critical function pointers.
 	return dec
 }
 
 // C documentation
 //
 //	// Resets the decoder in its initial state, reclaiming memory.
 //	// Preserves the dec->status value.
 func VP8LClear(tls *libc.TLS, dec uintptr) {
 	var i int32
 	_ = i
 	if dec == libc.UintptrFromInt32(0) {
 		return
 	}
 	ClearMetadata(tls, dec+152)
 	WebPSafeFree(tls, (*VP8LDecoder)(unsafe.Pointer(dec)).Fpixels)
 	(*VP8LDecoder)(unsafe.Pointer(dec)).Fpixels = libc.UintptrFromInt32(0)
 	i = 0
 	for {
 		if !(i < (*VP8LDecoder)(unsafe.Pointer(dec)).Fnext_transform) {
 			break
 		}
 		ClearTransform(tls, dec+280+uintptr(i)*24)
 		goto _1
 	_1:
 		;
 		i = i + 1
 	}
 	(*VP8LDecoder)(unsafe.Pointer(dec)).Fnext_transform = 0
 	(*VP8LDecoder)(unsafe.Pointer(dec)).Ftransforms_seen = uint32(0)
 	WebPSafeFree(tls, (*VP8LDecoder)(unsafe.Pointer(dec)).Frescaler_memory)
 	(*VP8LDecoder)(unsafe.Pointer(dec)).Frescaler_memory = libc.UintptrFromInt32(0)
 	(*VP8LDecoder)(unsafe.Pointer(dec)).Foutput = libc.UintptrFromInt32(0) // leave no trace behind
 }
 
 func VP8LDelete(tls *libc.TLS, dec uintptr) {
 	if dec != libc.UintptrFromInt32(0) {
 		VP8LClear(tls, dec)
 		WebPSafeFree(tls, dec)
 	}
 }
 
 func UpdateDecoder(tls *libc.TLS, dec uintptr, width int32, height int32) {
 	var hdr uintptr
 	var num_bits, v4 int32
 	var v1, v2 uint32_t
 	_, _, _, _, _ = hdr, num_bits, v1, v2, v4
 	hdr = dec + 152
 	num_bits = (*VP8LMetadata)(unsafe.Pointer(hdr)).Fhuffman_subsample_bits
 	(*VP8LDecoder)(unsafe.Pointer(dec)).Fwidth = width
 	(*VP8LDecoder)(unsafe.Pointer(dec)).Fheight = height
 	v1 = libc.Uint32FromInt32(num_bits)
 	v2 = (libc.Uint32FromInt32(width) + libc.Uint32FromInt32(libc.Int32FromInt32(1)<<v1) - uint32(1)) >> v1
 	goto _3
 _3:
 	(*VP8LMetadata)(unsafe.Pointer(hdr)).Fhuffman_xsize = libc.Int32FromUint32(v2)
 	if num_bits == 0 {
 		v4 = ^libc.Int32FromInt32(0)
 	} else {
 		v4 = int32(1)<<num_bits - int32(1)
 	}
 	(*VP8LMetadata)(unsafe.Pointer(hdr)).Fhuffman_mask = v4
 }
 
 func DecodeImageStream(tls *libc.TLS, xsize int32, ysize int32, is_level0 int32, dec uintptr, decoded_data uintptr) (r int32) {
 	bp := tls.Alloc(16)
 	defer tls.Free(16)
 	var br, data, hdr uintptr
 	var color_cache_bits, ok int32
 	var total_size uint64_t
 	var _ /* transform_xsize at bp+0 */ int32
 	var _ /* transform_ysize at bp+4 */ int32
 	_, _, _, _, _, _ = br, color_cache_bits, data, hdr, ok, total_size
 	ok = int32(1)
 	**(**int32)(__ccgo_up(bp)) = xsize
 	**(**int32)(__ccgo_up(bp + 4)) = ysize
 	br = dec + 40
 	hdr = dec + 152
 	data = libc.UintptrFromInt32(0)
 	color_cache_bits = 0
 	// Read the transforms (may recurse).
 	if is_level0 != 0 {
 		for ok != 0 && VP8LReadBits(tls, br, int32(1)) != 0 {
 			ok = ReadTransform(tls, bp, bp+4, dec)
 		}
 	}
 	// Color cache
 	if ok != 0 && VP8LReadBits(tls, br, int32(1)) != 0 {
 		color_cache_bits = libc.Int32FromUint32(VP8LReadBits(tls, br, int32(4)))
 		ok = libc.BoolInt32(color_cache_bits >= int32(1) && color_cache_bits <= int32(MAX_CACHE_BITS))
 		if !(ok != 0) {
 			VP8LSetError(tls, dec, int32(VP8_STATUS_BITSTREAM_ERROR))
 			goto End
 		}
 	}
 	// Read the Huffman codes (may recurse).
 	ok = libc.BoolInt32(ok != 0 && ReadHuffmanCodes(tls, dec, **(**int32)(__ccgo_up(bp)), **(**int32)(__ccgo_up(bp + 4)), color_cache_bits, is_level0) != 0)
 	if !(ok != 0) {
 		VP8LSetError(tls, dec, int32(VP8_STATUS_BITSTREAM_ERROR))
 		goto End
 	}
 	// Finish setting up the color-cache
 	if color_cache_bits > 0 {
 		(*VP8LMetadata)(unsafe.Pointer(hdr)).Fcolor_cache_size = int32(1) << color_cache_bits
 		if !(VP8LColorCacheInit(tls, hdr+8, color_cache_bits) != 0) {
 			ok = VP8LSetError(tls, dec, int32(VP8_STATUS_OUT_OF_MEMORY))
 			goto End
 		}
 	} else {
 		(*VP8LMetadata)(unsafe.Pointer(hdr)).Fcolor_cache_size = 0
 	}
 	UpdateDecoder(tls, dec, **(**int32)(__ccgo_up(bp)), **(**int32)(__ccgo_up(bp + 4)))
 	if is_level0 != 0 { // level 0 complete
 		(*VP8LDecoder)(unsafe.Pointer(dec)).Fstate = int32(READ_HDR)
 		goto End
 	}
 	total_size = libc.Uint64FromInt32(**(**int32)(__ccgo_up(bp))) * libc.Uint64FromInt32(**(**int32)(__ccgo_up(bp + 4)))
 	data = WebPSafeMalloc(tls, total_size, uint64(4))
 	if data == libc.UintptrFromInt32(0) {
 		ok = VP8LSetError(tls, dec, int32(VP8_STATUS_OUT_OF_MEMORY))
 		goto End
 	}
 	// Use the Huffman trees to decode the LZ77 encoded data.
 	ok = DecodeImageData(tls, dec, data, **(**int32)(__ccgo_up(bp)), **(**int32)(__ccgo_up(bp + 4)), **(**int32)(__ccgo_up(bp + 4)), libc.UintptrFromInt32(0))
 	ok = libc.BoolInt32(ok != 0 && !((*VP8LBitReader)(unsafe.Pointer(br)).Feos != 0))
 	goto End
 End:
 	;
 	if !(ok != 0) {
 		WebPSafeFree(tls, data)
 		ClearMetadata(tls, hdr)
 	} else {
 		if decoded_data != libc.UintptrFromInt32(0) {
 			**(**uintptr)(__ccgo_up(decoded_data)) = data
 		} else {
 			// We allocate image data in this function only for transforms. At level 0
 			// (that is: not the transforms), we shouldn't have allocated anything.
 		}
 		(*VP8LDecoder)(unsafe.Pointer(dec)).Flast_pixel = 0 // Reset for future DECODE_DATA_FUNC() calls.
 		if !(is_level0 != 0) {
 			ClearMetadata(tls, hdr)
 		} // Clean up temporary data behind.
 	}
 	return ok
 }
 
 // C documentation
 //
 //	//------------------------------------------------------------------------------
 //	// Allocate internal buffers dec->pixels and dec->argb_cache.
 func AllocateInternalBuffers32b(tls *libc.TLS, dec uintptr, final_width int32) (r int32) {
 	var cache_pixels, cache_top_pixels, num_pixels, total_num_pixels uint64_t
 	_, _, _, _ = cache_pixels, cache_top_pixels, num_pixels, total_num_pixels
 	num_pixels = libc.Uint64FromInt32((*VP8LDecoder)(unsafe.Pointer(dec)).Fwidth) * libc.Uint64FromInt32((*VP8LDecoder)(unsafe.Pointer(dec)).Fheight)
 	// Scratch buffer corresponding to top-prediction row for transforming the
 	// first row in the row-blocks. Not needed for paletted alpha.
 	cache_top_pixels = uint64(libc.Uint16FromInt32(final_width))
 	// Scratch buffer for temporary BGRA storage. Not needed for paletted alpha.
 	cache_pixels = libc.Uint64FromInt32(final_width) * uint64(NUM_ARGB_CACHE_ROWS)
 	total_num_pixels = num_pixels + cache_top_pixels + cache_pixels
 	(*VP8LDecoder)(unsafe.Pointer(dec)).Fpixels = WebPSafeMalloc(tls, total_num_pixels, uint64(4))
 	if (*VP8LDecoder)(unsafe.Pointer(dec)).Fpixels == libc.UintptrFromInt32(0) {
 		(*VP8LDecoder)(unsafe.Pointer(dec)).Fargb_cache = libc.UintptrFromInt32(0) // for soundness
 		return VP8LSetError(tls, dec, int32(VP8_STATUS_OUT_OF_MEMORY))
 	}
 	(*VP8LDecoder)(unsafe.Pointer(dec)).Fargb_cache = (*VP8LDecoder)(unsafe.Pointer(dec)).Fpixels + uintptr(num_pixels)*4 + uintptr(cache_top_pixels)*4
 	return int32(1)
 }
 
 func AllocateInternalBuffers8b(tls *libc.TLS, dec uintptr) (r int32) {
 	var total_num_pixels uint64_t
 	_ = total_num_pixels
 	total_num_pixels = libc.Uint64FromInt32((*VP8LDecoder)(unsafe.Pointer(dec)).Fwidth) * libc.Uint64FromInt32((*VP8LDecoder)(unsafe.Pointer(dec)).Fheight)
 	(*VP8LDecoder)(unsafe.Pointer(dec)).Fargb_cache = libc.UintptrFromInt32(0) // for soundness
 	(*VP8LDecoder)(unsafe.Pointer(dec)).Fpixels = WebPSafeMalloc(tls, total_num_pixels, uint64(1))
 	if (*VP8LDecoder)(unsafe.Pointer(dec)).Fpixels == libc.UintptrFromInt32(0) {
 		return VP8LSetError(tls, dec, int32(VP8_STATUS_OUT_OF_MEMORY))
 	}
 	return int32(1)
 }
 
 //------------------------------------------------------------------------------
 
 // C documentation
 //
 //	// Special row-processing that only stores the alpha data.
 func ExtractAlphaRows(tls *libc.TLS, dec uintptr, last_row int32) {
 	var alph_dec, dst, in, output, src uintptr
 	var cache_pixs, cur_row, num_rows, num_rows_to_process, width, v1 int32
 	_, _, _, _, _, _, _, _, _, _, _ = alph_dec, cache_pixs, cur_row, dst, in, num_rows, num_rows_to_process, output, src, width, v1
 	cur_row = (*VP8LDecoder)(unsafe.Pointer(dec)).Flast_row
 	num_rows = last_row - cur_row
 	in = (*VP8LDecoder)(unsafe.Pointer(dec)).Fpixels + uintptr((*VP8LDecoder)(unsafe.Pointer(dec)).Fwidth*cur_row)*4
 	for num_rows > 0 {
 		if num_rows > int32(NUM_ARGB_CACHE_ROWS) {
 			v1 = int32(NUM_ARGB_CACHE_ROWS)
 		} else {
 			v1 = num_rows
 		}
 		num_rows_to_process = v1
 		// Extract alpha (which is stored in the green plane).
 		alph_dec = (*VP8Io)(unsafe.Pointer((*VP8LDecoder)(unsafe.Pointer(dec)).Fio)).Fopaque
 		output = (*ALPHDecoder)(unsafe.Pointer(alph_dec)).Foutput
 		width = (*VP8Io)(unsafe.Pointer((*VP8LDecoder)(unsafe.Pointer(dec)).Fio)).Fwidth // the final width (!= dec->width)
 		cache_pixs = width * num_rows_to_process
 		dst = output + uintptr(width*cur_row)
 		src = (*VP8LDecoder)(unsafe.Pointer(dec)).Fargb_cache
 		ApplyInverseTransforms(tls, dec, cur_row, num_rows_to_process, in)
 		(*(*func(*libc.TLS, uintptr, uintptr, int32))(unsafe.Pointer(&struct{ uintptr }{WebPExtractGreen})))(tls, src, dst, cache_pixs)
 		AlphaApplyFilter(tls, alph_dec, cur_row, cur_row+num_rows_to_process, dst, width)
 		num_rows = num_rows - num_rows_to_process
 		in = in + uintptr(num_rows_to_process*(*VP8LDecoder)(unsafe.Pointer(dec)).Fwidth)*4
 		cur_row = cur_row + num_rows_to_process
 	}
 	v1 = last_row
 	(*VP8LDecoder)(unsafe.Pointer(dec)).Flast_out_row = v1
 	(*VP8LDecoder)(unsafe.Pointer(dec)).Flast_row = v1
 }
 
 func VP8LDecodeAlphaHeader(tls *libc.TLS, alph_dec uintptr, data uintptr, data_size size_t) (r int32) {
 	var dec uintptr
 	var ok int32
 	_, _ = dec, ok
 	ok = 0
 	dec = VP8LNew(tls)
 	if dec == libc.UintptrFromInt32(0) {
 		return 0
 	}
 	(*VP8LDecoder)(unsafe.Pointer(dec)).Fwidth = (*ALPHDecoder)(unsafe.Pointer(alph_dec)).Fwidth
 	(*VP8LDecoder)(unsafe.Pointer(dec)).Fheight = (*ALPHDecoder)(unsafe.Pointer(alph_dec)).Fheight
 	(*VP8LDecoder)(unsafe.Pointer(dec)).Fio = alph_dec + 32
 	(*VP8Io)(unsafe.Pointer((*VP8LDecoder)(unsafe.Pointer(dec)).Fio)).Fopaque = alph_dec
 	(*VP8Io)(unsafe.Pointer((*VP8LDecoder)(unsafe.Pointer(dec)).Fio)).Fwidth = (*ALPHDecoder)(unsafe.Pointer(alph_dec)).Fwidth
 	(*VP8Io)(unsafe.Pointer((*VP8LDecoder)(unsafe.Pointer(dec)).Fio)).Fheight = (*ALPHDecoder)(unsafe.Pointer(alph_dec)).Fheight
 	(*VP8LDecoder)(unsafe.Pointer(dec)).Fstatus = int32(VP8_STATUS_OK)
 	VP8LInitBitReader(tls, dec+40, data, data_size)
 	if !(DecodeImageStream(tls, (*ALPHDecoder)(unsafe.Pointer(alph_dec)).Fwidth, (*ALPHDecoder)(unsafe.Pointer(alph_dec)).Fheight, int32(1), dec, libc.UintptrFromInt32(0)) != 0) {
 		goto Err
 	}
 	// Special case: if alpha data uses only the color indexing transform and
 	// doesn't use color cache (a frequent case), we will use DecodeAlphaData()
 	// method that only needs allocation of 1 byte per pixel (alpha channel).
 	if (*VP8LDecoder)(unsafe.Pointer(dec)).Fnext_transform == int32(1) && (**(**VP8LTransform)(__ccgo_up(dec + 280))).Ftype1 == int32(COLOR_INDEXING_TRANSFORM) && Is8bOptimizable(tls, dec+152) != 0 {
 		(*ALPHDecoder)(unsafe.Pointer(alph_dec)).Fuse_8b_decode = int32(1)
 		ok = AllocateInternalBuffers8b(tls, dec)
 	} else {
 		// Allocate internal buffers (note that dec->width may have changed here).
 		(*ALPHDecoder)(unsafe.Pointer(alph_dec)).Fuse_8b_decode = 0
 		ok = AllocateInternalBuffers32b(tls, dec, (*ALPHDecoder)(unsafe.Pointer(alph_dec)).Fwidth)
 	}
 	if !(ok != 0) {
 		goto Err
 	}
 	// Only set here, once we are sure it is valid (to avoid thread races).
 	(*ALPHDecoder)(unsafe.Pointer(alph_dec)).Fvp8l_dec = dec
 	return int32(1)
 	goto Err
 Err:
 	;
 	VP8LDelete(tls, dec)
 	return 0
 }
 
 func VP8LDecodeAlphaImageStream(tls *libc.TLS, alph_dec uintptr, last_row int32) (r int32) {
 	var dec uintptr
 	var v1 int32
 	_, _ = dec, v1
 	dec = (*ALPHDecoder)(unsafe.Pointer(alph_dec)).Fvp8l_dec
 	if (*VP8LDecoder)(unsafe.Pointer(dec)).Flast_row >= last_row {
 		return int32(1) // done
 	}
 	if !((*ALPHDecoder)(unsafe.Pointer(alph_dec)).Fuse_8b_decode != 0) {
 		WebPInitAlphaProcessing(tls)
 	}
 	// Decode (with special row processing).
 	if (*ALPHDecoder)(unsafe.Pointer(alph_dec)).Fuse_8b_decode != 0 {
 		v1 = DecodeAlphaData(tls, dec, (*VP8LDecoder)(unsafe.Pointer(dec)).Fpixels, (*VP8LDecoder)(unsafe.Pointer(dec)).Fwidth, (*VP8LDecoder)(unsafe.Pointer(dec)).Fheight, last_row)
 	} else {
 		v1 = DecodeImageData(tls, dec, (*VP8LDecoder)(unsafe.Pointer(dec)).Fpixels, (*VP8LDecoder)(unsafe.Pointer(dec)).Fwidth, (*VP8LDecoder)(unsafe.Pointer(dec)).Fheight, last_row, __ccgo_fp(ExtractAlphaRows))
 	}
 	return v1
 }
 
 //------------------------------------------------------------------------------
 
 func VP8LDecodeHeader(tls *libc.TLS, dec uintptr, io uintptr) (r int32) {
 	bp := tls.Alloc(16)
 	defer tls.Free(16)
 	var _ /* has_alpha at bp+8 */ int32
 	var _ /* height at bp+4 */ int32
 	var _ /* width at bp+0 */ int32
 	if dec == libc.UintptrFromInt32(0) {
 		return 0
 	}
 	if io == libc.UintptrFromInt32(0) {
 		return VP8LSetError(tls, dec, int32(VP8_STATUS_INVALID_PARAM))
 	}
 	(*VP8LDecoder)(unsafe.Pointer(dec)).Fio = io
 	(*VP8LDecoder)(unsafe.Pointer(dec)).Fstatus = int32(VP8_STATUS_OK)
 	VP8LInitBitReader(tls, dec+40, (*VP8Io)(unsafe.Pointer(io)).Fdata, (*VP8Io)(unsafe.Pointer(io)).Fdata_size)
 	if !(ReadImageInfo(tls, dec+40, bp, bp+4, bp+8) != 0) {
 		VP8LSetError(tls, dec, int32(VP8_STATUS_BITSTREAM_ERROR))
 		goto Error
 	}
 	(*VP8LDecoder)(unsafe.Pointer(dec)).Fstate = int32(READ_DIM)
 	(*VP8Io)(unsafe.Pointer(io)).Fwidth = **(**int32)(__ccgo_up(bp))
 	(*VP8Io)(unsafe.Pointer(io)).Fheight = **(**int32)(__ccgo_up(bp + 4))
 	if !(DecodeImageStream(tls, **(**int32)(__ccgo_up(bp)), **(**int32)(__ccgo_up(bp + 4)), int32(1), dec, libc.UintptrFromInt32(0)) != 0) {
 		goto Error
 	}
 	return int32(1)
 	goto Error
 Error:
 	;
 	VP8LClear(tls, dec)
 	return 0
 }
 
 func VP8LDecodeImage(tls *libc.TLS, dec uintptr) (r int32) {
 	var io, params uintptr
 	var v1 WEBP_CSP_MODE1
 	var v2 int32
 	var v4 bool
 	_, _, _, _, _ = io, params, v1, v2, v4
 	io = libc.UintptrFromInt32(0)
 	params = libc.UintptrFromInt32(0)
 	if dec == libc.UintptrFromInt32(0) {
 		return 0
 	}
 	io = (*VP8LDecoder)(unsafe.Pointer(dec)).Fio
 	params = (*VP8Io)(unsafe.Pointer(io)).Fopaque
 	// Initialization.
 	if (*VP8LDecoder)(unsafe.Pointer(dec)).Fstate != int32(READ_DATA) {
 		(*VP8LDecoder)(unsafe.Pointer(dec)).Foutput = (*WebPDecParams)(unsafe.Pointer(params)).Foutput
 		if !(WebPIoInitFromOptions(tls, (*WebPDecParams)(unsafe.Pointer(params)).Foptions, io, int32(MODE_BGRA)) != 0) {
 			VP8LSetError(tls, dec, int32(VP8_STATUS_INVALID_PARAM))
 			goto Err
 		}
 		if !(AllocateInternalBuffers32b(tls, dec, (*VP8Io)(unsafe.Pointer(io)).Fwidth) != 0) {
 			goto Err
 		}
 		if (*VP8Io)(unsafe.Pointer(io)).Fuse_scaling != 0 && !(AllocateAndInitRescaler(tls, dec, io) != 0) {
 			goto Err
 		}
 		if v4 = (*VP8Io)(unsafe.Pointer(io)).Fuse_scaling != 0; !v4 {
 			v1 = (*WebPDecBuffer)(unsafe.Pointer((*VP8LDecoder)(unsafe.Pointer(dec)).Foutput)).Fcolorspace
 			v2 = libc.BoolInt32(v1 == int32(MODE_rgbA) || v1 == int32(MODE_bgrA) || v1 == int32(MODE_Argb) || v1 == int32(MODE_rgbA_4444))
 			goto _3
 		_3:
 		}
 		if v4 || v2 != 0 {
 			// need the alpha-multiply functions for premultiplied output or rescaling
 			WebPInitAlphaProcessing(tls)
 		}
 		v2 = libc.BoolInt32((*WebPDecBuffer)(unsafe.Pointer((*VP8LDecoder)(unsafe.Pointer(dec)).Foutput)).Fcolorspace < int32(MODE_YUV))
 		goto _6
 	_6:
 		if !(v2 != 0) {
 			WebPInitConvertARGBToYUV(tls)
 			if (*(*WebPYUVABuffer)(unsafe.Pointer((*VP8LDecoder)(unsafe.Pointer(dec)).Foutput + 16))).Fa != libc.UintptrFromInt32(0) {
 				WebPInitAlphaProcessing(tls)
 			}
 		}
 		if (*VP8LDecoder)(unsafe.Pointer(dec)).Fincremental != 0 {
 			if (*VP8LDecoder)(unsafe.Pointer(dec)).Fhdr.Fcolor_cache_size > 0 && (*VP8LDecoder)(unsafe.Pointer(dec)).Fhdr.Fsaved_color_cache.Fcolors == libc.UintptrFromInt32(0) {
 				if !(VP8LColorCacheInit(tls, dec+152+24, (*VP8LDecoder)(unsafe.Pointer(dec)).Fhdr.Fcolor_cache.Fhash_bits) != 0) {
 					VP8LSetError(tls, dec, int32(VP8_STATUS_OUT_OF_MEMORY))
 					goto Err
 				}
 			}
 		}
 		(*VP8LDecoder)(unsafe.Pointer(dec)).Fstate = int32(READ_DATA)
 	}
 	// Decode.
 	if !(DecodeImageData(tls, dec, (*VP8LDecoder)(unsafe.Pointer(dec)).Fpixels, (*VP8LDecoder)(unsafe.Pointer(dec)).Fwidth, (*VP8LDecoder)(unsafe.Pointer(dec)).Fheight, (*VP8Io)(unsafe.Pointer(io)).Fcrop_bottom, __ccgo_fp(ProcessRows)) != 0) {
 		goto Err
 	}
 	(*WebPDecParams)(unsafe.Pointer(params)).Flast_y = (*VP8LDecoder)(unsafe.Pointer(dec)).Flast_out_row
 	return int32(1)
 	goto Err
 Err:
 	;
 	VP8LClear(tls, dec)
 	return 0
 }
 
 const VP8L_MAGIC_BYTE2 = 0x2f
 
 var kHashMul9 = uint32(0x1e35a7bd)
 
 type WebPData = struct {
 	Fbytes uintptr
 	Fsize  size_t
 }
 
 type WebPFeatureFlags1 = int32
 
 type WebPFeatureFlags = int32
 
 const ANIMATION_FLAG = 2
 const XMP_FLAG = 4
 const EXIF_FLAG = 8
 const ALPHA_FLAG = 16
 const ICCP_FLAG = 32
 const ALL_VALID_FLAGS = 62
 
 type WebPMuxAnimDispose1 = int32
 
 type WebPMuxAnimDispose = int32
 
 const WEBP_MUX_DISPOSE_NONE = 0
 const WEBP_MUX_DISPOSE_BACKGROUND = 1
 
 type WebPMuxAnimBlend1 = int32
 
 type WebPMuxAnimBlend = int32
 
 const WEBP_MUX_BLEND = 0
 const WEBP_MUX_NO_BLEND = 1
 
 // Copyright 2010 Google Inc. All Rights Reserved.
 //
 // Use of this source code is governed by a BSD-style license
 // that can be found in the COPYING file in the root of the source
 // tree. An additional intellectual property rights grant can be found
 // in the file PATENTS. All contributing project authors may
 // be found in the AUTHORS file in the root of the source tree.
 // -----------------------------------------------------------------------------
 //
 //  Common types + memory wrappers
 //
 // Author: Skal (pascal.massimino@gmail.com)
 
 //------------------------------------------------------------------------------
 // RIFF layout is:
 //   Offset  tag
 //   0...3   "RIFF" 4-byte tag
 //   4...7   size of image data (including metadata) starting at offset 8
 //   8...11  "WEBP"   our form-type signature
 // The RIFF container (12 bytes) is followed by appropriate chunks:
 //   12..15  "VP8 ": 4-bytes tags, signaling the use of VP8 video format
 //   16..19  size of the raw VP8 image data, starting at offset 20
 //   20....  the VP8 bytes
 // Or,
 //   12..15  "VP8L": 4-bytes tags, signaling the use of VP8L lossless format
 //   16..19  size of the raw VP8L image data, starting at offset 20
 //   20....  the VP8L bytes
 // Or,
 //   12..15  "VP8X": 4-bytes tags, describing the extended-VP8 chunk.
 //   16..19  size of the VP8X chunk starting at offset 20.
 //   20..23  VP8X flags bit-map corresponding to the chunk-types present.
 //   24..26  Width of the Canvas Image.
 //   27..29  Height of the Canvas Image.
 // There can be extra chunks after the "VP8X" chunk (ICCP, ANMF, VP8, VP8L,
 // XMP, EXIF  ...)
 // All sizes are in little-endian order.
 // Note: chunk data size must be padded to multiple of 2 when written.
 
 // C documentation
 //
 //	// Validates the RIFF container (if detected) and skips over it.
 //	// If a RIFF container is detected, returns:
 //	//     VP8_STATUS_BITSTREAM_ERROR for invalid header,
 //	//     VP8_STATUS_NOT_ENOUGH_DATA for truncated data if have_all_data is true,
 //	// and VP8_STATUS_OK otherwise.
 //	// In case there are not enough bytes (partial RIFF container), return 0 for
 //	// *riff_size. Else return the RIFF size extracted from the header.
 func ParseRIFF(tls *libc.TLS, data2 uintptr, data_size uintptr, have_all_data int32, riff_size uintptr) (r VP8StatusCode1) {
 	var size, v2 uint32_t
 	var v1, v4, v7 uintptr
 	var v5, v8 int32
 	_, _, _, _, _, _, _ = size, v1, v2, v4, v5, v7, v8
 	**(**size_t)(__ccgo_up(riff_size)) = uint64(0) // Default: no RIFF present.
 	if **(**size_t)(__ccgo_up(data_size)) >= uint64(RIFF_HEADER_SIZE) && !(libc.Xmemcmp(tls, **(**uintptr)(__ccgo_up(data2)), __ccgo_ts+564, uint64(TAG_SIZE)) != 0) {
 		if libc.Xmemcmp(tls, **(**uintptr)(__ccgo_up(data2))+uintptr(8), __ccgo_ts+569, uint64(TAG_SIZE)) != 0 {
 			return int32(VP8_STATUS_BITSTREAM_ERROR) // Wrong image file signature.
 		} else {
 			v1 = **(**uintptr)(__ccgo_up(data2)) + uintptr(TAG_SIZE)
 			v4 = v1
 			v5 = libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(v4)))<<libc.Int32FromInt32(0) | libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(v4 + 1)))<<int32(8)
 			goto _6
 		_6:
 			v7 = v1 + uintptr(2)
 			v8 = libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(v7)))<<libc.Int32FromInt32(0) | libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(v7 + 1)))<<int32(8)
 			goto _9
 		_9:
 			v2 = libc.Uint32FromInt32(v5) | libc.Uint32FromInt32(v8)<<libc.Int32FromInt32(16)
 			goto _3
 		_3:
 			size = v2
 			// Check that we have at least one chunk (i.e "WEBP" + "VP8?nnnn").
 			if size < libc.Uint32FromInt32(libc.Int32FromInt32(TAG_SIZE)+libc.Int32FromInt32(CHUNK_HEADER_SIZE)) {
 				return int32(VP8_STATUS_BITSTREAM_ERROR)
 			}
 			if size > ^libc.Uint32FromUint32(0)-libc.Uint32FromInt32(CHUNK_HEADER_SIZE)-libc.Uint32FromInt32(1) {
 				return int32(VP8_STATUS_BITSTREAM_ERROR)
 			}
 			if have_all_data != 0 && uint64(size) > **(**size_t)(__ccgo_up(data_size))-uint64(CHUNK_HEADER_SIZE) {
 				return int32(VP8_STATUS_NOT_ENOUGH_DATA) // Truncated bitstream.
 			}
 			// We have a RIFF container. Skip it.
 			**(**size_t)(__ccgo_up(riff_size)) = uint64(size)
 			**(**uintptr)(__ccgo_up(data2)) += uintptr(RIFF_HEADER_SIZE)
 			**(**size_t)(__ccgo_up(data_size)) -= uint64(RIFF_HEADER_SIZE)
 		}
 	}
 	return int32(VP8_STATUS_OK)
 }
 
 // C documentation
 //
 //	// Validates the VP8X header and skips over it.
 //	// Returns VP8_STATUS_BITSTREAM_ERROR for invalid VP8X header,
 //	//         VP8_STATUS_NOT_ENOUGH_DATA in case of insufficient data, and
 //	//         VP8_STATUS_OK otherwise.
 //	// If a VP8X chunk is found, found_vp8x is set to true and *width_ptr,
 //	// *height_ptr and *flags_ptr are set to the corresponding values extracted
 //	// from the VP8X chunk.
 func ParseVP8X(tls *libc.TLS, data3 uintptr, data_size uintptr, found_vp8x uintptr, width_ptr uintptr, height_ptr uintptr, flags_ptr uintptr) (r VP8StatusCode1) {
 	var chunk_size, flags, vp8x_size, v2 uint32_t
 	var height, width, v5, v8 int32
 	var v1, v4, v7 uintptr
 	_, _, _, _, _, _, _, _, _, _, _ = chunk_size, flags, height, vp8x_size, width, v1, v2, v4, v5, v7, v8
 	vp8x_size = libc.Uint32FromInt32(libc.Int32FromInt32(CHUNK_HEADER_SIZE) + libc.Int32FromInt32(VP8X_CHUNK_SIZE))
 	**(**int32)(__ccgo_up(found_vp8x)) = 0
 	if **(**size_t)(__ccgo_up(data_size)) < uint64(CHUNK_HEADER_SIZE) {
 		return int32(VP8_STATUS_NOT_ENOUGH_DATA) // Insufficient data.
 	}
 	if !(libc.Xmemcmp(tls, **(**uintptr)(__ccgo_up(data3)), __ccgo_ts+574, uint64(TAG_SIZE)) != 0) {
 		v1 = **(**uintptr)(__ccgo_up(data3)) + uintptr(TAG_SIZE)
 		v4 = v1
 		v5 = libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(v4)))<<libc.Int32FromInt32(0) | libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(v4 + 1)))<<int32(8)
 		goto _6
 	_6:
 		v7 = v1 + uintptr(2)
 		v8 = libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(v7)))<<libc.Int32FromInt32(0) | libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(v7 + 1)))<<int32(8)
 		goto _9
 	_9:
 		v2 = libc.Uint32FromInt32(v5) | libc.Uint32FromInt32(v8)<<libc.Int32FromInt32(16)
 		goto _3
 	_3:
 		chunk_size = v2
 		if chunk_size != uint32(VP8X_CHUNK_SIZE) {
 			return int32(VP8_STATUS_BITSTREAM_ERROR) // Wrong chunk size.
 		}
 		// Verify if enough data is available to validate the VP8X chunk.
 		if **(**size_t)(__ccgo_up(data_size)) < uint64(vp8x_size) {
 			return int32(VP8_STATUS_NOT_ENOUGH_DATA) // Insufficient data.
 		}
 		v1 = **(**uintptr)(__ccgo_up(data3)) + uintptr(8)
 		v4 = v1
 		v5 = libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(v4)))<<libc.Int32FromInt32(0) | libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(v4 + 1)))<<int32(8)
 		goto _15
 	_15:
 		v7 = v1 + uintptr(2)
 		v8 = libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(v7)))<<libc.Int32FromInt32(0) | libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(v7 + 1)))<<int32(8)
 		goto _18
 	_18:
 		v2 = libc.Uint32FromInt32(v5) | libc.Uint32FromInt32(v8)<<libc.Int32FromInt32(16)
 		goto _12
 	_12:
 		flags = v2
 		v1 = **(**uintptr)(__ccgo_up(data3)) + uintptr(12)
 		v4 = v1
 		v8 = libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(v4)))<<libc.Int32FromInt32(0) | libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(v4 + 1)))<<int32(8)
 		goto _24
 	_24:
 		v5 = v8 | libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(v1 + 2)))<<int32(16)
 		goto _21
 	_21:
 		width = int32(1) + v5
 		v1 = **(**uintptr)(__ccgo_up(data3)) + uintptr(15)
 		v4 = v1
 		v8 = libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(v4)))<<libc.Int32FromInt32(0) | libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(v4 + 1)))<<int32(8)
 		goto _30
 	_30:
 		v5 = v8 | libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(v1 + 2)))<<int32(16)
 		goto _27
 	_27:
 		height = int32(1) + v5
 		if libc.Uint64FromInt32(width)*libc.Uint64FromInt32(height) >= libc.Uint64FromUint64(1)<<libc.Int32FromInt32(32) {
 			return int32(VP8_STATUS_BITSTREAM_ERROR) // image is too large
 		}
 		if flags_ptr != libc.UintptrFromInt32(0) {
 			**(**uint32_t)(__ccgo_up(flags_ptr)) = flags
 		}
 		if width_ptr != libc.UintptrFromInt32(0) {
 			**(**int32)(__ccgo_up(width_ptr)) = width
 		}
 		if height_ptr != libc.UintptrFromInt32(0) {
 			**(**int32)(__ccgo_up(height_ptr)) = height
 		}
 		// Skip over VP8X header bytes.
 		**(**uintptr)(__ccgo_up(data3)) += uintptr(vp8x_size)
 		**(**size_t)(__ccgo_up(data_size)) -= uint64(vp8x_size)
 		**(**int32)(__ccgo_up(found_vp8x)) = int32(1)
 	}
 	return int32(VP8_STATUS_OK)
 }
 
 // C documentation
 //
 //	// Skips to the next VP8/VP8L chunk header in the data given the size of the
 //	// RIFF chunk 'riff_size'.
 //	// Returns VP8_STATUS_BITSTREAM_ERROR if any invalid chunk size is encountered,
 //	//         VP8_STATUS_NOT_ENOUGH_DATA in case of insufficient data, and
 //	//         VP8_STATUS_OK otherwise.
 //	// If an alpha chunk is found, *alpha_data and *alpha_size are set
 //	// appropriately.
 func ParseOptionalChunks(tls *libc.TLS, data2 uintptr, data_size uintptr, riff_size size_t, alpha_data uintptr, alpha_size uintptr) (r VP8StatusCode1) {
 	var buf, v1, v4, v7 uintptr
 	var buf_size size_t
 	var chunk_size, disk_chunk_size, total_size, v2 uint32_t
 	var v5, v8 int32
 	_, _, _, _, _, _, _, _, _, _, _ = buf, buf_size, chunk_size, disk_chunk_size, total_size, v1, v2, v4, v5, v7, v8
 	total_size = libc.Uint32FromInt32(libc.Int32FromInt32(TAG_SIZE) + libc.Int32FromInt32(CHUNK_HEADER_SIZE) + libc.Int32FromInt32(VP8X_CHUNK_SIZE)) // data.
 	buf = **(**uintptr)(__ccgo_up(data2))
 	buf_size = **(**size_t)(__ccgo_up(data_size))
 	**(**uintptr)(__ccgo_up(alpha_data)) = libc.UintptrFromInt32(0)
 	**(**size_t)(__ccgo_up(alpha_size)) = uint64(0)
 	for int32(1) != 0 { // chunk_size with padding
 		**(**uintptr)(__ccgo_up(data2)) = buf
 		**(**size_t)(__ccgo_up(data_size)) = buf_size
 		if buf_size < uint64(CHUNK_HEADER_SIZE) { // Insufficient data.
 			return int32(VP8_STATUS_NOT_ENOUGH_DATA)
 		}
 		v1 = buf + uintptr(TAG_SIZE)
 		v4 = v1
 		v5 = libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(v4)))<<libc.Int32FromInt32(0) | libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(v4 + 1)))<<int32(8)
 		goto _6
 	_6:
 		v7 = v1 + uintptr(2)
 		v8 = libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(v7)))<<libc.Int32FromInt32(0) | libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(v7 + 1)))<<int32(8)
 		goto _9
 	_9:
 		v2 = libc.Uint32FromInt32(v5) | libc.Uint32FromInt32(v8)<<libc.Int32FromInt32(16)
 		goto _3
 	_3:
 		chunk_size = v2
 		if chunk_size > ^libc.Uint32FromUint32(0)-libc.Uint32FromInt32(CHUNK_HEADER_SIZE)-libc.Uint32FromInt32(1) {
 			return int32(VP8_STATUS_BITSTREAM_ERROR) // Not a valid chunk size.
 		}
 		// For odd-sized chunk-payload, there's one byte padding at the end.
 		disk_chunk_size = (uint32(CHUNK_HEADER_SIZE) + chunk_size + uint32(1)) & ^libc.Uint32FromUint32(1)
 		total_size = total_size + disk_chunk_size
 		// Check that total bytes skipped so far does not exceed riff_size.
 		if riff_size > uint64(0) && uint64(total_size) > riff_size {
 			return int32(VP8_STATUS_BITSTREAM_ERROR) // Not a valid chunk size.
 		}
 		// Start of a (possibly incomplete) VP8/VP8L chunk implies that we have
 		// parsed all the optional chunks.
 		// Note: This check must occur before the check 'buf_size < disk_chunk_size'
 		// below to allow incomplete VP8/VP8L chunks.
 		if !(libc.Xmemcmp(tls, buf, __ccgo_ts+579, uint64(TAG_SIZE)) != 0) || !(libc.Xmemcmp(tls, buf, __ccgo_ts+584, uint64(TAG_SIZE)) != 0) {
 			return int32(VP8_STATUS_OK)
 		}
 		if buf_size < uint64(disk_chunk_size) { // Insufficient data.
 			return int32(VP8_STATUS_NOT_ENOUGH_DATA)
 		}
 		if !(libc.Xmemcmp(tls, buf, __ccgo_ts+589, uint64(TAG_SIZE)) != 0) { // A valid ALPH header.
 			**(**uintptr)(__ccgo_up(alpha_data)) = buf + uintptr(CHUNK_HEADER_SIZE)
 			**(**size_t)(__ccgo_up(alpha_size)) = uint64(chunk_size)
 		}
 		// We have a full and valid chunk; skip it.
 		buf = buf + uintptr(disk_chunk_size)
 		buf_size = buf_size - uint64(disk_chunk_size)
 	}
 	return r
 }
 
 // C documentation
 //
 //	// Validates the VP8/VP8L Header ("VP8 nnnn" or "VP8L nnnn") and skips over it.
 //	// Returns VP8_STATUS_BITSTREAM_ERROR for invalid (chunk larger than
 //	//         riff_size) VP8/VP8L header,
 //	//         VP8_STATUS_NOT_ENOUGH_DATA in case of insufficient data, and
 //	//         VP8_STATUS_OK otherwise.
 //	// If a VP8/VP8L chunk is found, *chunk_size is set to the total number of bytes
 //	// extracted from the VP8/VP8L chunk header.
 //	// The flag '*is_lossless' is set to 1 in case of VP8L chunk / raw VP8L data.
 func ParseVP8Header(tls *libc.TLS, data_ptr uintptr, data_size uintptr, have_all_data int32, riff_size size_t, chunk_size uintptr, is_lossless uintptr) (r VP8StatusCode1) {
 	var data2, v1, v4, v7 uintptr
 	var is_vp8, is_vp8l, v5, v8 int32
 	var minimal_size, size, v2 uint32_t
 	_, _, _, _, _, _, _, _, _, _, _ = data2, is_vp8, is_vp8l, minimal_size, size, v1, v2, v4, v5, v7, v8
 	data2 = **(**uintptr)(__ccgo_up(data_ptr))
 	is_vp8 = libc.BoolInt32(!(libc.Xmemcmp(tls, data2, __ccgo_ts+579, uint64(TAG_SIZE)) != 0))
 	is_vp8l = libc.BoolInt32(!(libc.Xmemcmp(tls, data2, __ccgo_ts+584, uint64(TAG_SIZE)) != 0))
 	minimal_size = libc.Uint32FromInt32(libc.Int32FromInt32(TAG_SIZE) + libc.Int32FromInt32(CHUNK_HEADER_SIZE)) // "WEBP" + "VP8 nnnn" OR
 	// "WEBP" + "VP8Lnnnn"
 	if **(**size_t)(__ccgo_up(data_size)) < uint64(CHUNK_HEADER_SIZE) {
 		return int32(VP8_STATUS_NOT_ENOUGH_DATA) // Insufficient data.
 	}
 	if is_vp8 != 0 || is_vp8l != 0 {
 		v1 = data2 + uintptr(TAG_SIZE)
 		v4 = v1
 		v5 = libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(v4)))<<libc.Int32FromInt32(0) | libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(v4 + 1)))<<int32(8)
 		goto _6
 	_6:
 		v7 = v1 + uintptr(2)
 		v8 = libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(v7)))<<libc.Int32FromInt32(0) | libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(v7 + 1)))<<int32(8)
 		goto _9
 	_9:
 		v2 = libc.Uint32FromInt32(v5) | libc.Uint32FromInt32(v8)<<libc.Int32FromInt32(16)
 		goto _3
 	_3:
 		// Bitstream contains VP8/VP8L header.
 		size = v2
 		if riff_size >= uint64(minimal_size) && uint64(size) > riff_size-uint64(minimal_size) {
 			return int32(VP8_STATUS_BITSTREAM_ERROR) // Inconsistent size information.
 		}
 		if have_all_data != 0 && uint64(size) > **(**size_t)(__ccgo_up(data_size))-uint64(CHUNK_HEADER_SIZE) {
 			return int32(VP8_STATUS_NOT_ENOUGH_DATA) // Truncated bitstream.
 		}
 		// Skip over CHUNK_HEADER_SIZE bytes from VP8/VP8L Header.
 		**(**size_t)(__ccgo_up(chunk_size)) = uint64(size)
 		**(**uintptr)(__ccgo_up(data_ptr)) += uintptr(CHUNK_HEADER_SIZE)
 		**(**size_t)(__ccgo_up(data_size)) -= uint64(CHUNK_HEADER_SIZE)
 		**(**int32)(__ccgo_up(is_lossless)) = is_vp8l
 	} else {
 		// Raw VP8/VP8L bitstream (no header).
 		**(**int32)(__ccgo_up(is_lossless)) = VP8LCheckSignature(tls, data2, **(**size_t)(__ccgo_up(data_size)))
 		**(**size_t)(__ccgo_up(chunk_size)) = **(**size_t)(__ccgo_up(data_size))
 	}
 	return int32(VP8_STATUS_OK)
 }
 
 //------------------------------------------------------------------------------
 
 // C documentation
 //
 //	// Fetch '*width', '*height', '*has_alpha' and fill out 'headers' based on
 //	// 'data'. All the output parameters may be NULL. If 'headers' is NULL only the
 //	// minimal amount will be read to fetch the remaining parameters.
 //	// If 'headers' is non-NULL this function will attempt to locate both alpha
 //	// data (with or without a VP8X chunk) and the bitstream chunk (VP8/VP8L).
 //	// Note: The following chunk sequences (before the raw VP8/VP8L data) are
 //	// considered valid by this function:
 //	// RIFF + VP8(L)
 //	// RIFF + VP8X + (optional chunks) + VP8(L)
 //	// ALPH + VP8 <-- Not a valid WebP format: only allowed for internal purpose.
 //	// VP8(L)     <-- Not a valid WebP format: only allowed for internal purpose.
 func ParseHeadersInternal(tls *libc.TLS, _data uintptr, _data_size size_t, width uintptr, height uintptr, has_alpha uintptr, has_animation uintptr, format uintptr, headers uintptr) (r VP8StatusCode1) {
 	bp := tls.Alloc(128)
 	defer tls.Free(128)
 	*(*uintptr)(unsafe.Pointer(bp)) = _data
 	*(*size_t)(unsafe.Pointer(bp + 8)) = _data_size
 	var animation_present, found_riff, have_all_data, v1 int32
 	var status VP8StatusCode1
 	var _ /* canvas_height at bp+20 */ int32
 	var _ /* canvas_width at bp+16 */ int32
 	var _ /* flags at bp+112 */ uint32_t
 	var _ /* found_vp8x at bp+32 */ int32
 	var _ /* hdrs at bp+40 */ WebPHeaderStructure
 	var _ /* image_height at bp+28 */ int32
 	var _ /* image_width at bp+24 */ int32
 	_, _, _, _, _ = animation_present, found_riff, have_all_data, status, v1
 	**(**int32)(__ccgo_up(bp + 16)) = 0
 	**(**int32)(__ccgo_up(bp + 20)) = 0
 	**(**int32)(__ccgo_up(bp + 24)) = 0
 	**(**int32)(__ccgo_up(bp + 28)) = 0
 	found_riff = 0
 	**(**int32)(__ccgo_up(bp + 32)) = 0
 	animation_present = 0
 	if headers != libc.UintptrFromInt32(0) {
 		v1 = (*WebPHeaderStructure)(unsafe.Pointer(headers)).Fhave_all_data
 	} else {
 		v1 = 0
 	}
 	have_all_data = v1
 	if **(**uintptr)(__ccgo_up(bp)) == libc.UintptrFromInt32(0) || **(**size_t)(__ccgo_up(bp + 8)) < uint64(RIFF_HEADER_SIZE) {
 		return int32(VP8_STATUS_NOT_ENOUGH_DATA)
 	}
 	libc.X__builtin___memset_chk(tls, bp+40, 0, uint64(72), ^__predefined_size_t(0))
 	(**(**WebPHeaderStructure)(__ccgo_up(bp + 40))).Fdata = **(**uintptr)(__ccgo_up(bp))
 	(**(**WebPHeaderStructure)(__ccgo_up(bp + 40))).Fdata_size = **(**size_t)(__ccgo_up(bp + 8))
 	// Skip over RIFF header.
 	status = ParseRIFF(tls, bp, bp+8, have_all_data, bp+40+56)
 	if status != int32(VP8_STATUS_OK) {
 		return status // Wrong RIFF header / insufficient data.
 	}
 	found_riff = libc.BoolInt32((**(**WebPHeaderStructure)(__ccgo_up(bp + 40))).Friff_size > uint64(0))
 	// Skip over VP8X.
 	**(**uint32_t)(__ccgo_up(bp + 112)) = uint32(0)
 	status = ParseVP8X(tls, bp, bp+8, bp+32, bp+16, bp+20, bp+112)
 	if status != int32(VP8_STATUS_OK) {
 		return status // Wrong VP8X / insufficient data.
 	}
 	animation_present = libc.BoolInt32(!!(**(**uint32_t)(__ccgo_up(bp + 112))&uint32(ANIMATION_FLAG) != 0))
 	if !(found_riff != 0) && **(**int32)(__ccgo_up(bp + 32)) != 0 {
 		// Note: This restriction may be removed in the future, if it becomes
 		// necessary to send VP8X chunk to the decoder.
 		return int32(VP8_STATUS_BITSTREAM_ERROR)
 	}
 	if has_alpha != libc.UintptrFromInt32(0) {
 		**(**int32)(__ccgo_up(has_alpha)) = libc.BoolInt32(!!(**(**uint32_t)(__ccgo_up(bp + 112))&uint32(ALPHA_FLAG) != 0))
 	}
 	if has_animation != libc.UintptrFromInt32(0) {
 		**(**int32)(__ccgo_up(has_animation)) = animation_present
 	}
 	if format != libc.UintptrFromInt32(0) {
 		**(**int32)(__ccgo_up(format)) = 0
 	} // default = undefined
 	**(**int32)(__ccgo_up(bp + 24)) = **(**int32)(__ccgo_up(bp + 16))
 	**(**int32)(__ccgo_up(bp + 28)) = **(**int32)(__ccgo_up(bp + 20))
 	if **(**int32)(__ccgo_up(bp + 32)) != 0 && animation_present != 0 && headers == libc.UintptrFromInt32(0) {
 		status = int32(VP8_STATUS_OK)
 		goto ReturnWidthHeight // Just return features from VP8X header.
 	}
 	if **(**size_t)(__ccgo_up(bp + 8)) < uint64(TAG_SIZE) {
 		status = int32(VP8_STATUS_NOT_ENOUGH_DATA)
 		goto ReturnWidthHeight
 	}
 	// Skip over optional chunks if data started with "RIFF + VP8X" or "ALPH".
 	if found_riff != 0 && **(**int32)(__ccgo_up(bp + 32)) != 0 || !(found_riff != 0) && !(**(**int32)(__ccgo_up(bp + 32)) != 0) && !(libc.Xmemcmp(tls, **(**uintptr)(__ccgo_up(bp)), __ccgo_ts+589, uint64(TAG_SIZE)) != 0) {
 		status = ParseOptionalChunks(tls, bp, bp+8, (**(**WebPHeaderStructure)(__ccgo_up(bp + 40))).Friff_size, bp+40+32, bp+40+40)
 		if status != int32(VP8_STATUS_OK) {
 			goto ReturnWidthHeight // Invalid chunk size / insufficient data.
 		}
 	}
 	// Skip over VP8/VP8L header.
 	status = ParseVP8Header(tls, bp, bp+8, have_all_data, (**(**WebPHeaderStructure)(__ccgo_up(bp + 40))).Friff_size, bp+40+48, bp+40+64)
 	if status != int32(VP8_STATUS_OK) {
 		goto ReturnWidthHeight // Wrong VP8/VP8L chunk-header / insufficient data.
 	}
 	if (**(**WebPHeaderStructure)(__ccgo_up(bp + 40))).Fcompressed_size > uint64(^libc.Uint32FromUint32(0)-libc.Uint32FromInt32(CHUNK_HEADER_SIZE)-libc.Uint32FromInt32(1)) {
 		return int32(VP8_STATUS_BITSTREAM_ERROR)
 	}
 	if format != libc.UintptrFromInt32(0) && !(animation_present != 0) {
 		if (**(**WebPHeaderStructure)(__ccgo_up(bp + 40))).Fis_lossless != 0 {
 			v1 = int32(2)
 		} else {
 			v1 = int32(1)
 		}
 		**(**int32)(__ccgo_up(format)) = v1
 	}
 	if !((**(**WebPHeaderStructure)(__ccgo_up(bp + 40))).Fis_lossless != 0) {
 		if **(**size_t)(__ccgo_up(bp + 8)) < uint64(VP8_FRAME_HEADER_SIZE) {
 			status = int32(VP8_STATUS_NOT_ENOUGH_DATA)
 			goto ReturnWidthHeight
 		}
 		// Validates raw VP8 data.
 		if !(VP8GetInfo(tls, **(**uintptr)(__ccgo_up(bp)), **(**size_t)(__ccgo_up(bp + 8)), uint64(uint32((**(**WebPHeaderStructure)(__ccgo_up(bp + 40))).Fcompressed_size)), bp+24, bp+28) != 0) {
 			return int32(VP8_STATUS_BITSTREAM_ERROR)
 		}
 	} else {
 		if **(**size_t)(__ccgo_up(bp + 8)) < uint64(VP8L_FRAME_HEADER_SIZE) {
 			status = int32(VP8_STATUS_NOT_ENOUGH_DATA)
 			goto ReturnWidthHeight
 		}
 		// Validates raw VP8L data.
 		if !(VP8LGetInfo(tls, **(**uintptr)(__ccgo_up(bp)), **(**size_t)(__ccgo_up(bp + 8)), bp+24, bp+28, has_alpha) != 0) {
 			return int32(VP8_STATUS_BITSTREAM_ERROR)
 		}
 	}
 	// Validates image size coherency.
 	if **(**int32)(__ccgo_up(bp + 32)) != 0 {
 		if **(**int32)(__ccgo_up(bp + 16)) != **(**int32)(__ccgo_up(bp + 24)) || **(**int32)(__ccgo_up(bp + 20)) != **(**int32)(__ccgo_up(bp + 28)) {
 			return int32(VP8_STATUS_BITSTREAM_ERROR)
 		}
 	}
 	if headers != libc.UintptrFromInt32(0) {
 		**(**WebPHeaderStructure)(__ccgo_up(headers)) = **(**WebPHeaderStructure)(__ccgo_up(bp + 40))
 		(*WebPHeaderStructure)(unsafe.Pointer(headers)).Foffset = libc.Uint64FromInt64(int64(**(**uintptr)(__ccgo_up(bp))) - int64((*WebPHeaderStructure)(unsafe.Pointer(headers)).Fdata))
 	}
 	goto ReturnWidthHeight
 ReturnWidthHeight:
 	;
 	if status == int32(VP8_STATUS_OK) || status == int32(VP8_STATUS_NOT_ENOUGH_DATA) && **(**int32)(__ccgo_up(bp + 32)) != 0 && headers == libc.UintptrFromInt32(0) {
 		if has_alpha != libc.UintptrFromInt32(0) {
 			// If the data did not contain a VP8X/VP8L chunk the only definitive way
 			// to set this is by looking for alpha data (from an ALPH chunk).
 			**(**int32)(__ccgo_up(has_alpha)) |= libc.BoolInt32((**(**WebPHeaderStructure)(__ccgo_up(bp + 40))).Falpha_data != libc.UintptrFromInt32(0))
 		}
 		if width != libc.UintptrFromInt32(0) {
 			**(**int32)(__ccgo_up(width)) = **(**int32)(__ccgo_up(bp + 24))
 		}
 		if height != libc.UintptrFromInt32(0) {
 			**(**int32)(__ccgo_up(height)) = **(**int32)(__ccgo_up(bp + 28))
 		}
 		return int32(VP8_STATUS_OK)
 	} else {
 		return status
 	}
 	return r
 }
 
 func WebPParseHeaders(tls *libc.TLS, headers uintptr) (r VP8StatusCode1) {
 	bp := tls.Alloc(16)
 	defer tls.Free(16)
 	var status VP8StatusCode1
 	var _ /* has_animation at bp+0 */ int32
 	_ = status
 	**(**int32)(__ccgo_up(bp)) = 0
 	// fill out headers, ignore width/height/has_alpha.
 	status = ParseHeadersInternal(tls, (*WebPHeaderStructure)(unsafe.Pointer(headers)).Fdata, (*WebPHeaderStructure)(unsafe.Pointer(headers)).Fdata_size, libc.UintptrFromInt32(0), libc.UintptrFromInt32(0), libc.UintptrFromInt32(0), bp, libc.UintptrFromInt32(0), headers)
 	if status == int32(VP8_STATUS_OK) || status == int32(VP8_STATUS_NOT_ENOUGH_DATA) {
 		// The WebPDemux API + libwebp can be used to decode individual
 		// uncomposited frames or the WebPAnimDecoder can be used to fully
 		// reconstruct them (see webp/demux.h).
 		if **(**int32)(__ccgo_up(bp)) != 0 {
 			status = int32(VP8_STATUS_UNSUPPORTED_FEATURE)
 		}
 	}
 	return status
 }
 
 //------------------------------------------------------------------------------
 // WebPDecParams
 
 func WebPResetDecParams(tls *libc.TLS, params uintptr) {
 	if params != libc.UintptrFromInt32(0) {
 		libc.X__builtin___memset_chk(tls, params, 0, uint64(112), ^__predefined_size_t(0))
 	}
 }
 
 //------------------------------------------------------------------------------
 // "Into" decoding variants
 
 // C documentation
 //
 //	// Main flow
 func DecodeInto(tls *libc.TLS, data uintptr, data_size size_t, params uintptr) (r VP8StatusCode1) {
 	bp := tls.Alloc(240)
 	defer tls.Free(240)
 	var dec, dec1 uintptr
 	var status VP8StatusCode1
 	var v1 int32
 	var _ /* headers at bp+160 */ WebPHeaderStructure
 	var _ /* io at bp+0 */ VP8Io
 	_, _, _, _ = dec, dec1, status, v1
 	(**(**WebPHeaderStructure)(__ccgo_up(bp + 160))).Fdata = data
 	(**(**WebPHeaderStructure)(__ccgo_up(bp + 160))).Fdata_size = data_size
 	(**(**WebPHeaderStructure)(__ccgo_up(bp + 160))).Fhave_all_data = int32(1)
 	status = WebPParseHeaders(tls, bp+160) // Process Pre-VP8 chunks.
 	if status != int32(VP8_STATUS_OK) {
 		return status
 	}
 	v1 = VP8InitIoInternal(tls, bp, int32(WEBP_DECODER_ABI_VERSION))
 	goto _2
 _2:
 	if !(v1 != 0) {
 		return int32(VP8_STATUS_INVALID_PARAM)
 	}
 	(**(**VP8Io)(__ccgo_up(bp))).Fdata = (**(**WebPHeaderStructure)(__ccgo_up(bp + 160))).Fdata + uintptr((**(**WebPHeaderStructure)(__ccgo_up(bp + 160))).Foffset)
 	(**(**VP8Io)(__ccgo_up(bp))).Fdata_size = (**(**WebPHeaderStructure)(__ccgo_up(bp + 160))).Fdata_size - (**(**WebPHeaderStructure)(__ccgo_up(bp + 160))).Foffset
 	WebPInitCustomIo(tls, params, bp) // Plug the I/O functions.
 	if !((**(**WebPHeaderStructure)(__ccgo_up(bp + 160))).Fis_lossless != 0) {
 		dec = VP8New(tls)
 		if dec == libc.UintptrFromInt32(0) {
 			return int32(VP8_STATUS_OUT_OF_MEMORY)
 		}
 		(*VP8Decoder)(unsafe.Pointer(dec)).Falpha_data = (**(**WebPHeaderStructure)(__ccgo_up(bp + 160))).Falpha_data
 		(*VP8Decoder)(unsafe.Pointer(dec)).Falpha_data_size = (**(**WebPHeaderStructure)(__ccgo_up(bp + 160))).Falpha_data_size
 		// Decode bitstream header, update io->width/io->height.
 		if !(VP8GetHeaders(tls, dec, bp) != 0) {
 			status = (*VP8Decoder)(unsafe.Pointer(dec)).Fstatus // An error occurred. Grab error status.
 		} else {
 			// Allocate/check output buffers.
 			status = WebPAllocateDecBuffer(tls, (**(**VP8Io)(__ccgo_up(bp))).Fwidth, (**(**VP8Io)(__ccgo_up(bp))).Fheight, (*WebPDecParams)(unsafe.Pointer(params)).Foptions, (*WebPDecParams)(unsafe.Pointer(params)).Foutput)
 			if status == int32(VP8_STATUS_OK) { // Decode
 				// This change must be done before calling VP8Decode()
 				(*VP8Decoder)(unsafe.Pointer(dec)).Fmt_method = VP8GetThreadMethod(tls, (*WebPDecParams)(unsafe.Pointer(params)).Foptions, bp+160, (**(**VP8Io)(__ccgo_up(bp))).Fwidth, (**(**VP8Io)(__ccgo_up(bp))).Fheight)
 				VP8InitDithering(tls, (*WebPDecParams)(unsafe.Pointer(params)).Foptions, dec)
 				if !(VP8Decode(tls, dec, bp) != 0) {
 					status = (*VP8Decoder)(unsafe.Pointer(dec)).Fstatus
 				}
 			}
 		}
 		VP8Delete(tls, dec)
 	} else {
 		dec1 = VP8LNew(tls)
 		if dec1 == libc.UintptrFromInt32(0) {
 			return int32(VP8_STATUS_OUT_OF_MEMORY)
 		}
 		if !(VP8LDecodeHeader(tls, dec1, bp) != 0) {
 			status = (*VP8LDecoder)(unsafe.Pointer(dec1)).Fstatus // An error occurred. Grab error status.
 		} else {
 			// Allocate/check output buffers.
 			status = WebPAllocateDecBuffer(tls, (**(**VP8Io)(__ccgo_up(bp))).Fwidth, (**(**VP8Io)(__ccgo_up(bp))).Fheight, (*WebPDecParams)(unsafe.Pointer(params)).Foptions, (*WebPDecParams)(unsafe.Pointer(params)).Foutput)
 			if status == int32(VP8_STATUS_OK) { // Decode
 				if !(VP8LDecodeImage(tls, dec1) != 0) {
 					status = (*VP8LDecoder)(unsafe.Pointer(dec1)).Fstatus
 				}
 			}
 		}
 		VP8LDelete(tls, dec1)
 	}
 	if status != int32(VP8_STATUS_OK) {
 		WebPFreeDecBuffer(tls, (*WebPDecParams)(unsafe.Pointer(params)).Foutput)
 	} else {
 		if (*WebPDecParams)(unsafe.Pointer(params)).Foptions != libc.UintptrFromInt32(0) && (*WebPDecoderOptions)(unsafe.Pointer((*WebPDecParams)(unsafe.Pointer(params)).Foptions)).Fflip != 0 {
 			// This restores the original stride values if options->flip was used
 			// during the call to WebPAllocateDecBuffer above.
 			status = WebPFlipBuffer(tls, (*WebPDecParams)(unsafe.Pointer(params)).Foutput)
 		}
 	}
 	return status
 }
 
 // C documentation
 //
 //	// Helpers
 func DecodeIntoRGBABuffer(tls *libc.TLS, colorspace WEBP_CSP_MODE1, data uintptr, data_size size_t, rgba uintptr, stride int32, size size_t) (r uintptr) {
 	bp := tls.Alloc(240)
 	defer tls.Free(240)
 	var v1 int32
 	var v3 bool
 	var _ /* buf at bp+112 */ WebPDecBuffer
 	var _ /* params at bp+0 */ WebPDecParams
 	_, _ = v1, v3
 	if v3 = rgba == libc.UintptrFromInt32(0); !v3 {
 		v1 = WebPInitDecBufferInternal(tls, bp+112, int32(WEBP_DECODER_ABI_VERSION))
 		goto _2
 	_2:
 	}
 	if v3 || !(v1 != 0) {
 		return libc.UintptrFromInt32(0)
 	}
 	WebPResetDecParams(tls, bp)
 	(**(**WebPDecParams)(__ccgo_up(bp))).Foutput = bp + 112
 	(**(**WebPDecBuffer)(__ccgo_up(bp + 112))).Fcolorspace = colorspace
 	*(*uintptr)(unsafe.Pointer(bp + 112 + 16)) = rgba
 	*(*int32)(unsafe.Pointer(bp + 112 + 16 + 8)) = stride
 	*(*size_t)(unsafe.Pointer(bp + 112 + 16 + 16)) = size
 	(**(**WebPDecBuffer)(__ccgo_up(bp + 112))).Fis_external_memory = int32(1)
 	if DecodeInto(tls, data, data_size, bp) != int32(VP8_STATUS_OK) {
 		return libc.UintptrFromInt32(0)
 	}
 	return rgba
 }
 
 func WebPDecodeRGBInto(tls *libc.TLS, data uintptr, data_size size_t, output uintptr, size size_t, stride int32) (r uintptr) {
 	return DecodeIntoRGBABuffer(tls, int32(MODE_RGB), data, data_size, output, stride, size)
 }
 
 func WebPDecodeRGBAInto(tls *libc.TLS, data uintptr, data_size size_t, output uintptr, size size_t, stride int32) (r uintptr) {
 	return DecodeIntoRGBABuffer(tls, int32(MODE_RGBA), data, data_size, output, stride, size)
 }
 
 func WebPDecodeARGBInto(tls *libc.TLS, data uintptr, data_size size_t, output uintptr, size size_t, stride int32) (r uintptr) {
 	return DecodeIntoRGBABuffer(tls, int32(MODE_ARGB), data, data_size, output, stride, size)
 }
 
 func WebPDecodeBGRInto(tls *libc.TLS, data uintptr, data_size size_t, output uintptr, size size_t, stride int32) (r uintptr) {
 	return DecodeIntoRGBABuffer(tls, int32(MODE_BGR), data, data_size, output, stride, size)
 }
 
 func WebPDecodeBGRAInto(tls *libc.TLS, data uintptr, data_size size_t, output uintptr, size size_t, stride int32) (r uintptr) {
 	return DecodeIntoRGBABuffer(tls, int32(MODE_BGRA), data, data_size, output, stride, size)
 }
 
 func WebPDecodeYUVInto(tls *libc.TLS, data uintptr, data_size size_t, luma uintptr, luma_size size_t, luma_stride int32, u uintptr, u_size size_t, u_stride int32, v uintptr, v_size size_t, v_stride int32) (r uintptr) {
 	bp := tls.Alloc(240)
 	defer tls.Free(240)
 	var v1 int32
 	var v3 bool
 	var _ /* output at bp+112 */ WebPDecBuffer
 	var _ /* params at bp+0 */ WebPDecParams
 	_, _ = v1, v3
 	if v3 = luma == libc.UintptrFromInt32(0); !v3 {
 		v1 = WebPInitDecBufferInternal(tls, bp+112, int32(WEBP_DECODER_ABI_VERSION))
 		goto _2
 	_2:
 	}
 	if v3 || !(v1 != 0) {
 		return libc.UintptrFromInt32(0)
 	}
 	WebPResetDecParams(tls, bp)
 	(**(**WebPDecParams)(__ccgo_up(bp))).Foutput = bp + 112
 	(**(**WebPDecBuffer)(__ccgo_up(bp + 112))).Fcolorspace = int32(MODE_YUV)
 	*(*uintptr)(unsafe.Pointer(bp + 112 + 16)) = luma
 	*(*int32)(unsafe.Pointer(bp + 112 + 16 + 32)) = luma_stride
 	*(*size_t)(unsafe.Pointer(bp + 112 + 16 + 48)) = luma_size
 	*(*uintptr)(unsafe.Pointer(bp + 112 + 16 + 8)) = u
 	*(*int32)(unsafe.Pointer(bp + 112 + 16 + 36)) = u_stride
 	*(*size_t)(unsafe.Pointer(bp + 112 + 16 + 56)) = u_size
 	*(*uintptr)(unsafe.Pointer(bp + 112 + 16 + 16)) = v
 	*(*int32)(unsafe.Pointer(bp + 112 + 16 + 40)) = v_stride
 	*(*size_t)(unsafe.Pointer(bp + 112 + 16 + 64)) = v_size
 	(**(**WebPDecBuffer)(__ccgo_up(bp + 112))).Fis_external_memory = int32(1)
 	if DecodeInto(tls, data, data_size, bp) != int32(VP8_STATUS_OK) {
 		return libc.UintptrFromInt32(0)
 	}
 	return luma
 }
 
 // ------------------------------------------------------------------------------
 func Decode(tls *libc.TLS, mode1 WEBP_CSP_MODE1, data uintptr, data_size size_t, width uintptr, height uintptr, keep_info uintptr) (r uintptr) {
 	bp := tls.Alloc(240)
 	defer tls.Free(240)
 	var v1 int32
 	var v3 uintptr
 	var _ /* output at bp+112 */ WebPDecBuffer
 	var _ /* params at bp+0 */ WebPDecParams
 	_, _ = v1, v3
 	v1 = WebPInitDecBufferInternal(tls, bp+112, int32(WEBP_DECODER_ABI_VERSION))
 	goto _2
 _2:
 	if !(v1 != 0) {
 		return libc.UintptrFromInt32(0)
 	}
 	WebPResetDecParams(tls, bp)
 	(**(**WebPDecParams)(__ccgo_up(bp))).Foutput = bp + 112
 	(**(**WebPDecBuffer)(__ccgo_up(bp + 112))).Fcolorspace = mode1
 	// Retrieve (and report back) the required dimensions from bitstream.
 	if !(WebPGetInfo(tls, data, data_size, bp+112+4, bp+112+8) != 0) {
 		return libc.UintptrFromInt32(0)
 	}
 	if width != libc.UintptrFromInt32(0) {
 		**(**int32)(__ccgo_up(width)) = (**(**WebPDecBuffer)(__ccgo_up(bp + 112))).Fwidth
 	}
 	if height != libc.UintptrFromInt32(0) {
 		**(**int32)(__ccgo_up(height)) = (**(**WebPDecBuffer)(__ccgo_up(bp + 112))).Fheight
 	}
 	// Decode
 	if DecodeInto(tls, data, data_size, bp) != int32(VP8_STATUS_OK) {
 		return libc.UintptrFromInt32(0)
 	}
 	if keep_info != libc.UintptrFromInt32(0) { // keep track of the side-info
 		WebPCopyDecBuffer(tls, bp+112, keep_info)
 	}
 	// return decoded samples (don't clear 'output'!)
 	v1 = libc.BoolInt32(mode1 < int32(MODE_YUV))
 	goto _5
 _5:
 	if v1 != 0 {
 		v3 = *(*uintptr)(unsafe.Pointer(bp + 112 + 16))
 	} else {
 		v3 = *(*uintptr)(unsafe.Pointer(bp + 112 + 16))
 	}
 	return v3
 }
 
 func WebPDecodeRGB(tls *libc.TLS, data uintptr, data_size size_t, width uintptr, height uintptr) (r uintptr) {
 	return Decode(tls, int32(MODE_RGB), data, data_size, width, height, libc.UintptrFromInt32(0))
 }
 
 func WebPDecodeRGBA(tls *libc.TLS, data uintptr, data_size size_t, width uintptr, height uintptr) (r uintptr) {
 	return Decode(tls, int32(MODE_RGBA), data, data_size, width, height, libc.UintptrFromInt32(0))
 }
 
 func WebPDecodeARGB(tls *libc.TLS, data uintptr, data_size size_t, width uintptr, height uintptr) (r uintptr) {
 	return Decode(tls, int32(MODE_ARGB), data, data_size, width, height, libc.UintptrFromInt32(0))
 }
 
 func WebPDecodeBGR(tls *libc.TLS, data uintptr, data_size size_t, width uintptr, height uintptr) (r uintptr) {
 	return Decode(tls, int32(MODE_BGR), data, data_size, width, height, libc.UintptrFromInt32(0))
 }
 
 func WebPDecodeBGRA(tls *libc.TLS, data uintptr, data_size size_t, width uintptr, height uintptr) (r uintptr) {
 	return Decode(tls, int32(MODE_BGRA), data, data_size, width, height, libc.UintptrFromInt32(0))
 }
 
 func WebPDecodeYUV(tls *libc.TLS, data uintptr, data_size size_t, width uintptr, height uintptr, u uintptr, v uintptr, stride uintptr, uv_stride uintptr) (r uintptr) {
 	bp := tls.Alloc(128)
 	defer tls.Free(128)
 	var buf, out uintptr
 	var _ /* output at bp+0 */ WebPDecBuffer
 	_, _ = buf, out
 	// data, width and height are checked by Decode().
 	if u == libc.UintptrFromInt32(0) || v == libc.UintptrFromInt32(0) || stride == libc.UintptrFromInt32(0) || uv_stride == libc.UintptrFromInt32(0) {
 		return libc.UintptrFromInt32(0)
 	}
 	// only to preserve the side-infos
 	out = Decode(tls, int32(MODE_YUV), data, data_size, width, height, bp)
 	if out != libc.UintptrFromInt32(0) {
 		buf = bp + 16
 		**(**uintptr)(__ccgo_up(u)) = (*WebPYUVABuffer)(unsafe.Pointer(buf)).Fu
 		**(**uintptr)(__ccgo_up(v)) = (*WebPYUVABuffer)(unsafe.Pointer(buf)).Fv
 		**(**int32)(__ccgo_up(stride)) = (*WebPYUVABuffer)(unsafe.Pointer(buf)).Fy_stride
 		**(**int32)(__ccgo_up(uv_stride)) = (*WebPYUVABuffer)(unsafe.Pointer(buf)).Fu_stride
 	}
 	return out
 	return r
 }
 
 func DefaultFeatures(tls *libc.TLS, features uintptr) {
 	libc.X__builtin___memset_chk(tls, features, 0, uint64(40), ^__predefined_size_t(0))
 }
 
 func GetFeatures(tls *libc.TLS, data uintptr, data_size size_t, features uintptr) (r VP8StatusCode1) {
 	if features == libc.UintptrFromInt32(0) || data == libc.UintptrFromInt32(0) {
 		return int32(VP8_STATUS_INVALID_PARAM)
 	}
 	DefaultFeatures(tls, features)
 	// Only parse enough of the data to retrieve the features.
 	return ParseHeadersInternal(tls, data, data_size, features, features+4, features+8, features+12, features+16, libc.UintptrFromInt32(0))
 }
 
 //------------------------------------------------------------------------------
 // WebPGetInfo()
 
 func WebPGetInfo(tls *libc.TLS, data uintptr, data_size size_t, width uintptr, height uintptr) (r int32) {
 	bp := tls.Alloc(48)
 	defer tls.Free(48)
 	var _ /* features at bp+0 */ WebPBitstreamFeatures
 	if GetFeatures(tls, data, data_size, bp) != int32(VP8_STATUS_OK) {
 		return 0
 	}
 	if width != libc.UintptrFromInt32(0) {
 		**(**int32)(__ccgo_up(width)) = (**(**WebPBitstreamFeatures)(__ccgo_up(bp))).Fwidth
 	}
 	if height != libc.UintptrFromInt32(0) {
 		**(**int32)(__ccgo_up(height)) = (**(**WebPBitstreamFeatures)(__ccgo_up(bp))).Fheight
 	}
 	return int32(1)
 }
 
 //------------------------------------------------------------------------------
 // Advance decoding API
 
 func WebPInitDecoderConfigInternal(tls *libc.TLS, config uintptr, version int32) (r int32) {
 	var v1 int32
 	_ = v1
 	if version>>int32(8) != libc.Int32FromInt32(WEBP_DECODER_ABI_VERSION)>>libc.Int32FromInt32(8) {
 		return 0 // version mismatch
 	}
 	if config == libc.UintptrFromInt32(0) {
 		return 0
 	}
 	libc.X__builtin___memset_chk(tls, config, 0, uint64(240), ^__predefined_size_t(0))
 	DefaultFeatures(tls, config)
 	v1 = WebPInitDecBufferInternal(tls, config+40, int32(WEBP_DECODER_ABI_VERSION))
 	goto _2
 _2:
 	if !(v1 != 0) {
 		return 0
 	}
 	return int32(1)
 }
 
 func WebPCheckCropDimensionsBasic(tls *libc.TLS, x int32, y int32, w int32, h int32) (r int32) {
 	return libc.BoolInt32(!(x < 0 || y < 0 || w <= 0 || h <= 0))
 }
 
 func WebPValidateDecoderConfig(tls *libc.TLS, config uintptr) (r int32) {
 	bp := tls.Alloc(16)
 	defer tls.Free(16)
 	var options uintptr
 	var _ /* scaled_height at bp+4 */ int32
 	var _ /* scaled_width at bp+0 */ int32
 	_ = options
 	if config == libc.UintptrFromInt32(0) {
 		return 0
 	}
 	if !(IsValidColorspace(tls, (*WebPDecoderConfig)(unsafe.Pointer(config)).Foutput.Fcolorspace) != 0) {
 		return 0
 	}
 	options = config + 160
 	// bypass_filtering, no_fancy_upsampling, use_cropping, use_scaling,
 	// use_threads, flip can be any integer and are interpreted as boolean.
 	// Check for cropping.
 	if (*WebPDecoderOptions)(unsafe.Pointer(options)).Fuse_cropping != 0 && !(WebPCheckCropDimensionsBasic(tls, (*WebPDecoderOptions)(unsafe.Pointer(options)).Fcrop_left, (*WebPDecoderOptions)(unsafe.Pointer(options)).Fcrop_top, (*WebPDecoderOptions)(unsafe.Pointer(options)).Fcrop_width, (*WebPDecoderOptions)(unsafe.Pointer(options)).Fcrop_height) != 0) {
 		return 0
 	}
 	// Check for scaling.
 	if (*WebPDecoderOptions)(unsafe.Pointer(options)).Fuse_scaling != 0 && ((*WebPDecoderOptions)(unsafe.Pointer(options)).Fscaled_width < 0 || (*WebPDecoderOptions)(unsafe.Pointer(options)).Fscaled_height < 0 || (*WebPDecoderOptions)(unsafe.Pointer(options)).Fscaled_width == 0 && (*WebPDecoderOptions)(unsafe.Pointer(options)).Fscaled_height == 0) {
 		return 0
 	}
 	// In case the WebPBitstreamFeatures has been filled in, check further.
 	if (*WebPDecoderConfig)(unsafe.Pointer(config)).Finput.Fwidth > 0 || (*WebPDecoderConfig)(unsafe.Pointer(config)).Finput.Fheight > 0 {
 		**(**int32)(__ccgo_up(bp)) = (*WebPDecoderOptions)(unsafe.Pointer(options)).Fscaled_width
 		**(**int32)(__ccgo_up(bp + 4)) = (*WebPDecoderOptions)(unsafe.Pointer(options)).Fscaled_height
 		if (*WebPDecoderOptions)(unsafe.Pointer(options)).Fuse_cropping != 0 && !(WebPCheckCropDimensions(tls, (*WebPDecoderConfig)(unsafe.Pointer(config)).Finput.Fwidth, (*WebPDecoderConfig)(unsafe.Pointer(config)).Finput.Fheight, (*WebPDecoderOptions)(unsafe.Pointer(options)).Fcrop_left, (*WebPDecoderOptions)(unsafe.Pointer(options)).Fcrop_top, (*WebPDecoderOptions)(unsafe.Pointer(options)).Fcrop_width, (*WebPDecoderOptions)(unsafe.Pointer(options)).Fcrop_height) != 0) {
 			return 0
 		}
 		if (*WebPDecoderOptions)(unsafe.Pointer(options)).Fuse_scaling != 0 && !(WebPRescalerGetScaledDimensions(tls, (*WebPDecoderConfig)(unsafe.Pointer(config)).Finput.Fwidth, (*WebPDecoderConfig)(unsafe.Pointer(config)).Finput.Fheight, bp, bp+4) != 0) {
 			return 0
 		}
 	}
 	// Check for dithering.
 	if (*WebPDecoderOptions)(unsafe.Pointer(options)).Fdithering_strength < 0 || (*WebPDecoderOptions)(unsafe.Pointer(options)).Fdithering_strength > int32(100) || (*WebPDecoderOptions)(unsafe.Pointer(options)).Falpha_dithering_strength < 0 || (*WebPDecoderOptions)(unsafe.Pointer(options)).Falpha_dithering_strength > int32(100) {
 		return 0
 	}
 	return int32(1)
 }
 
 func WebPGetFeaturesInternal(tls *libc.TLS, data uintptr, data_size size_t, features uintptr, version int32) (r VP8StatusCode1) {
 	if version>>int32(8) != libc.Int32FromInt32(WEBP_DECODER_ABI_VERSION)>>libc.Int32FromInt32(8) {
 		return int32(VP8_STATUS_INVALID_PARAM) // version mismatch
 	}
 	if features == libc.UintptrFromInt32(0) {
 		return int32(VP8_STATUS_INVALID_PARAM)
 	}
 	return GetFeatures(tls, data, data_size, features)
 }
 
 func WebPDecode(tls *libc.TLS, data uintptr, data_size size_t, config uintptr) (r VP8StatusCode1) {
 	bp := tls.Alloc(240)
 	defer tls.Free(240)
 	var status VP8StatusCode1
 	var v1 int32
 	var _ /* in_mem_buffer at bp+112 */ WebPDecBuffer
 	var _ /* params at bp+0 */ WebPDecParams
 	_, _ = status, v1
 	if config == libc.UintptrFromInt32(0) {
 		return int32(VP8_STATUS_INVALID_PARAM)
 	}
 	status = GetFeatures(tls, data, data_size, config)
 	if status != int32(VP8_STATUS_OK) {
 		if status == int32(VP8_STATUS_NOT_ENOUGH_DATA) {
 			return int32(VP8_STATUS_BITSTREAM_ERROR) // Not-enough-data treated as error.
 		}
 		return status
 	}
 	WebPResetDecParams(tls, bp)
 	(**(**WebPDecParams)(__ccgo_up(bp))).Foptions = config + 160
 	(**(**WebPDecParams)(__ccgo_up(bp))).Foutput = config + 40
 	if WebPAvoidSlowMemory(tls, (**(**WebPDecParams)(__ccgo_up(bp))).Foutput, config) != 0 {
 		v1 = WebPInitDecBufferInternal(tls, bp+112, int32(WEBP_DECODER_ABI_VERSION))
 		goto _2
 	_2:
 		if !(v1 != 0) {
 			return int32(VP8_STATUS_INVALID_PARAM)
 		}
 		(**(**WebPDecBuffer)(__ccgo_up(bp + 112))).Fcolorspace = (*WebPDecoderConfig)(unsafe.Pointer(config)).Foutput.Fcolorspace
 		(**(**WebPDecBuffer)(__ccgo_up(bp + 112))).Fwidth = (*WebPDecoderConfig)(unsafe.Pointer(config)).Finput.Fwidth
 		(**(**WebPDecBuffer)(__ccgo_up(bp + 112))).Fheight = (*WebPDecoderConfig)(unsafe.Pointer(config)).Finput.Fheight
 		(**(**WebPDecParams)(__ccgo_up(bp))).Foutput = bp + 112
 		status = DecodeInto(tls, data, data_size, bp)
 		if status == int32(VP8_STATUS_OK) { // do the slow-copy
 			status = WebPCopyDecBufferPixels(tls, bp+112, config+40)
 		}
 		WebPFreeDecBuffer(tls, bp+112)
 	} else {
 		status = DecodeInto(tls, data, data_size, bp)
 	}
 	return status
 }
 
 //------------------------------------------------------------------------------
 // Cropping and rescaling.
 
 func WebPCheckCropDimensions(tls *libc.TLS, image_width int32, image_height int32, x int32, y int32, w int32, h int32) (r int32) {
 	return libc.BoolInt32(WebPCheckCropDimensionsBasic(tls, x, y, w, h) != 0 && !(x >= image_width || w > image_width || w > image_width-x || y >= image_height || h > image_height || h > image_height-y))
 }
 
 func WebPIoInitFromOptions(tls *libc.TLS, options uintptr, io uintptr, src_colorspace WEBP_CSP_MODE1) (r int32) {
 	bp := tls.Alloc(16)
 	defer tls.Free(16)
 	var H, W, h, w, x, y, v1 int32
 	var _ /* scaled_height at bp+4 */ int32
 	var _ /* scaled_width at bp+0 */ int32
 	_, _, _, _, _, _, _ = H, W, h, w, x, y, v1
 	W = (*VP8Io)(unsafe.Pointer(io)).Fwidth
 	H = (*VP8Io)(unsafe.Pointer(io)).Fheight
 	x = 0
 	y = 0
 	w = W
 	h = H
 	// Cropping
 	(*VP8Io)(unsafe.Pointer(io)).Fuse_cropping = libc.BoolInt32(options != libc.UintptrFromInt32(0) && (*WebPDecoderOptions)(unsafe.Pointer(options)).Fuse_cropping != 0)
 	if (*VP8Io)(unsafe.Pointer(io)).Fuse_cropping != 0 {
 		w = (*WebPDecoderOptions)(unsafe.Pointer(options)).Fcrop_width
 		h = (*WebPDecoderOptions)(unsafe.Pointer(options)).Fcrop_height
 		x = (*WebPDecoderOptions)(unsafe.Pointer(options)).Fcrop_left
 		y = (*WebPDecoderOptions)(unsafe.Pointer(options)).Fcrop_top
 		v1 = libc.BoolInt32(src_colorspace < int32(MODE_YUV))
 		goto _2
 	_2:
 		if !(v1 != 0) { // only snap for YUV420
 			x = x & ^libc.Int32FromInt32(1)
 			y = y & ^libc.Int32FromInt32(1)
 		}
 		if !(WebPCheckCropDimensions(tls, W, H, x, y, w, h) != 0) {
 			return 0 // out of frame boundary error
 		}
 	}
 	(*VP8Io)(unsafe.Pointer(io)).Fcrop_left = x
 	(*VP8Io)(unsafe.Pointer(io)).Fcrop_top = y
 	(*VP8Io)(unsafe.Pointer(io)).Fcrop_right = x + w
 	(*VP8Io)(unsafe.Pointer(io)).Fcrop_bottom = y + h
 	(*VP8Io)(unsafe.Pointer(io)).Fmb_w = w
 	(*VP8Io)(unsafe.Pointer(io)).Fmb_h = h
 	// Scaling
 	(*VP8Io)(unsafe.Pointer(io)).Fuse_scaling = libc.BoolInt32(options != libc.UintptrFromInt32(0) && (*WebPDecoderOptions)(unsafe.Pointer(options)).Fuse_scaling != 0)
 	if (*VP8Io)(unsafe.Pointer(io)).Fuse_scaling != 0 {
 		**(**int32)(__ccgo_up(bp)) = (*WebPDecoderOptions)(unsafe.Pointer(options)).Fscaled_width
 		**(**int32)(__ccgo_up(bp + 4)) = (*WebPDecoderOptions)(unsafe.Pointer(options)).Fscaled_height
 		if !(WebPRescalerGetScaledDimensions(tls, w, h, bp, bp+4) != 0) {
 			return 0
 		}
 		(*VP8Io)(unsafe.Pointer(io)).Fscaled_width = **(**int32)(__ccgo_up(bp))
 		(*VP8Io)(unsafe.Pointer(io)).Fscaled_height = **(**int32)(__ccgo_up(bp + 4))
 	}
 	// Filter
 	(*VP8Io)(unsafe.Pointer(io)).Fbypass_filtering = libc.BoolInt32(options != libc.UintptrFromInt32(0) && (*WebPDecoderOptions)(unsafe.Pointer(options)).Fbypass_filtering != 0)
 	// Fancy upsampler
 	(*VP8Io)(unsafe.Pointer(io)).Ffancy_upsampling = libc.BoolInt32(options == libc.UintptrFromInt32(0) || !((*WebPDecoderOptions)(unsafe.Pointer(options)).Fno_fancy_upsampling != 0))
 	if (*VP8Io)(unsafe.Pointer(io)).Fuse_scaling != 0 {
 		// disable filter (only for large downscaling ratio).
 		**(**int32)(__ccgo_up(io + 112)) |= libc.BoolInt32((*VP8Io)(unsafe.Pointer(io)).Fscaled_width < W*int32(3)/int32(4) && (*VP8Io)(unsafe.Pointer(io)).Fscaled_height < H*int32(3)/int32(4))
 		(*VP8Io)(unsafe.Pointer(io)).Ffancy_upsampling = 0
 	}
 	return int32(1)
 }
 
 const ENC_MAJ_VERSION = 1
 const ENC_MIN_VERSION = 6
 const ENC_REV_VERSION = 0
 const ERROR_DIFFUSION_QUALITY = 98
 const HASH_BITS = 18
 const MAX_COLOR_CACHE_BITS = 10
 const MAX_LENGTH_BITS = 12
 const MAX_REFS_BLOCK_PER_IMAGE = 16
 const QFIX = 17
 const U_OFF_ENC = 16
 const VP8L_WRITER_BITS = 32
 const VP8L_WRITER_BYTES = 4
 const VP8L_WRITER_MAX_BITS = 64
 const WEBP_ENCODER_ABI_VERSION = 528
 const WEBP_MAX_DIMENSION = 16383
 const WEBP_NEAR_LOSSLESS = 1
 const WINDOW_SIZE_BITS = 20
 const WSWAP = "HToLE32"
 const Y_OFF_ENC = 0
 
 type VP8Matrix = struct {
 	Fq       [16]uint16_t
 	Fiq      [16]uint16_t
 	Fbias    [16]uint32_t
 	Fzthresh [16]uint32_t
 	Fsharpen [16]uint16_t
 }
 
 type VP8BitWriter = struct {
 	Frange1  int32_t
 	Fvalue   int32_t
 	Frun     int32
 	Fnb_bits int32
 	Fbuf     uintptr
 	Fpos     size_t
 	Fmax_pos size_t
 	Ferror1  int32
 }
 
 type vp8l_atype_t = uint64
 
 type vp8l_wtype_t = uint32
 
 type VP8LBitWriter = struct {
 	Fbits   vp8l_atype_t
 	Fused   int32
 	Fbuf    uintptr
 	Fcur    uintptr
 	Fend    uintptr
 	Ferror1 int32
 }
 
 type WebPPicture = struct {
 	Fuse_argb        int32
 	Fcolorspace      WebPEncCSP1
 	Fwidth           int32
 	Fheight          int32
 	Fy               uintptr
 	Fu               uintptr
 	Fv               uintptr
 	Fy_stride        int32
 	Fuv_stride       int32
 	Fa               uintptr
 	Fa_stride        int32
 	Fpad1            [2]uint32_t
 	Fargb            uintptr
 	Fargb_stride     int32
 	Fpad2            [3]uint32_t
 	Fwriter          WebPWriterFunction
 	Fcustom_ptr      uintptr
 	Fextra_info_type int32
 	Fextra_info      uintptr
 	Fstats           uintptr
 	Ferror_code      WebPEncodingError1
 	Fprogress_hook   WebPProgressHook
 	Fuser_data       uintptr
 	Fpad3            [3]uint32_t
 	Fpad4            uintptr
 	Fpad5            uintptr
 	Fpad6            [8]uint32_t
 	Fmemory_         uintptr
 	Fmemory_argb_    uintptr
 	Fpad7            [2]uintptr
 }
 
 type WebPEncCSP = int32
 
 const WEBP_YUV420 = 0
 const WEBP_YUV420A = 4
 const WEBP_CSP_UV_MASK = 3
 const WEBP_CSP_ALPHA_BIT = 4
 
 type WebPEncodingError = int32
 
 const VP8_ENC_OK = 0
 const VP8_ENC_ERROR_OUT_OF_MEMORY = 1
 const VP8_ENC_ERROR_BITSTREAM_OUT_OF_MEMORY = 2
 const VP8_ENC_ERROR_NULL_PARAMETER = 3
 const VP8_ENC_ERROR_INVALID_CONFIGURATION = 4
 const VP8_ENC_ERROR_BAD_DIMENSION = 5
 const VP8_ENC_ERROR_PARTITION0_OVERFLOW = 6
 const VP8_ENC_ERROR_PARTITION_OVERFLOW = 7
 const VP8_ENC_ERROR_BAD_WRITE = 8
 const VP8_ENC_ERROR_FILE_TOO_BIG = 9
 const VP8_ENC_ERROR_USER_ABORT = 10
 const VP8_ENC_ERROR_LAST = 11
 
 type WebPConfig = struct {
 	Flossless          int32
 	Fquality           float32
 	Fmethod            int32
 	Fimage_hint        WebPImageHint1
 	Ftarget_size       int32
 	Ftarget_PSNR       float32
 	Fsegments          int32
 	Fsns_strength      int32
 	Ffilter_strength   int32
 	Ffilter_sharpness  int32
 	Ffilter_type       int32
 	Fautofilter        int32
 	Falpha_compression int32
 	Falpha_filtering   int32
 	Falpha_quality     int32
 	Fpass              int32
 	Fshow_compressed   int32
 	Fpreprocessing     int32
 	Fpartitions        int32
 	Fpartition_limit   int32
 	Femulate_jpeg_size int32
 	Fthread_level      int32
 	Flow_memory        int32
 	Fnear_lossless     int32
 	Fexact             int32
 	Fuse_delta_palette int32
 	Fuse_sharp_yuv     int32
 	Fqmin              int32
 	Fqmax              int32
 }
 
 type WebPImageHint = int32
 
 const WEBP_HINT_DEFAULT = 0
 const WEBP_HINT_PICTURE = 1
 const WEBP_HINT_PHOTO = 2
 const WEBP_HINT_GRAPH = 3
 const WEBP_HINT_LAST = 4
 
 type WebPAuxStats = struct {
 	Fcoded_size                 int32
 	FPSNR                       [5]float32
 	Fblock_count                [3]int32
 	Fheader_bytes               [2]int32
 	Fresidual_bytes             [3][4]int32
 	Fsegment_size               [4]int32
 	Fsegment_quant              [4]int32
 	Fsegment_level              [4]int32
 	Falpha_data_size            int32
 	Flayer_data_size            int32
 	Flossless_features          uint32_t
 	Fhistogram_bits             int32
 	Ftransform_bits             int32
 	Fcache_bits                 int32
 	Fpalette_size               int32
 	Flossless_size              int32
 	Flossless_hdr_size          int32
 	Flossless_data_size         int32
 	Fcross_color_transform_bits int32
 	Fpad                        [1]uint32_t
 }
 
 type WebPMemoryWriter = struct {
 	Fmem      uintptr
 	Fsize     size_t
 	Fmax_size size_t
 	Fpad      [1]uint32_t
 }
 
 type WebPImageHint1 = int32
 
 type WebPPreset1 = int32
 
 type WebPPreset = int32
 
 const WEBP_PRESET_DEFAULT = 0
 const WEBP_PRESET_PICTURE = 1
 const WEBP_PRESET_PHOTO = 2
 const WEBP_PRESET_DRAWING = 3
 const WEBP_PRESET_ICON = 4
 const WEBP_PRESET_TEXT = 5
 
 type WebPWriterFunction = uintptr
 
 type WebPProgressHook = uintptr
 
 type WebPEncCSP1 = int32
 
 type WebPEncodingError1 = int32
 
 const MAX_LF_LEVELS = 64
 const MAX_VARIABLE_LEVEL = 67
 const MAX_LEVEL = 2047
 
 type VP8RDLevel = int32
 
 const RD_OPT_NONE = 0
 const RD_OPT_BASIC = 1
 const RD_OPT_TRELLIS = 2
 const RD_OPT_TRELLIS_ALL = 3
 
 type score_t = int64
 
 type proba_t = uint32
 
 type ProbaArray = [3][11]uint8_t
 
 type StatsArray = [3][11]proba_t
 
 type CostArray = [3][68]uint16_t
 
 type CostArrayPtr = uintptr
 
 type CostArrayMap = [16][3]uintptr
 
 type LFStats = [4][64]float64
 
 type VP8Encoder = struct {
 	Fconfig             uintptr
 	Fpic                uintptr
 	Ffilter_hdr         VP8EncFilterHeader
 	Fsegment_hdr        VP8EncSegmentHeader
 	Fprofile            int32
 	Fmb_w               int32
 	Fmb_h               int32
 	Fpreds_w            int32
 	Fnum_parts          int32
 	Fbw                 VP8BitWriter
 	Fparts              [8]VP8BitWriter
 	Ftokens             VP8TBuffer
 	Fpercent            int32
 	Fhas_alpha          int32
 	Falpha_data         uintptr
 	Falpha_data_size    uint32_t
 	Falpha_worker       WebPWorker
 	Fdqm                [4]VP8SegmentInfo
 	Fbase_quant         int32
 	Falpha              int32
 	Fuv_alpha           int32
 	Fdq_y1_dc           int32
 	Fdq_y2_dc           int32
 	Fdq_y2_ac           int32
 	Fdq_uv_dc           int32
 	Fdq_uv_ac           int32
 	Fproba              VP8EncProba
 	Fsse                [4]uint64_t
 	Fsse_count          uint64_t
 	Fcoded_size         int32
 	Fresidual_bytes     [3][4]int32
 	Fblock_count        [3]int32
 	Fmethod             int32
 	Frd_opt_level       VP8RDLevel
 	Fmax_i4_header_bits int32
 	Fmb_header_limit    int32
 	Fthread_level       int32
 	Fdo_search          int32
 	Fuse_tokens         int32
 	Fmb_info            uintptr
 	Fpreds              uintptr
 	Fnz                 uintptr
 	Fy_top              uintptr
 	Fuv_top             uintptr
 	Flf_stats           uintptr
 	Ftop_derr           uintptr
 }
 
 type VP8EncSegmentHeader = struct {
 	Fnum_segments int32
 	Fupdate_map   int32
 	Fsize         int32
 }
 
 type VP8EncProba = struct {
 	Fsegments       [3]uint8_t
 	Fskip_proba     uint8_t
 	Fcoeffs         [4][8]ProbaArray
 	Fstats          [4][8]StatsArray
 	Flevel_cost     [4][8]CostArray
 	Fremapped_costs [4]CostArrayMap
 	Fdirty          int32
 	Fuse_skip_proba int32
 	Fnb_skip        int32
 }
 
 type VP8EncFilterHeader = struct {
 	Fsimple        int32
 	Flevel         int32
 	Fsharpness     int32
 	Fi4x4_lf_delta int32
 }
 
 type VP8MBInfo = struct {
 	F__ccgo_align [0]uint32
 	F__ccgo0      uint8
 	Falpha        uint8_t
 }
 
 type VP8SegmentInfo = struct {
 	Fy1                 VP8Matrix
 	Fy2                 VP8Matrix
 	Fuv                 VP8Matrix
 	Falpha              int32
 	Fbeta               int32
 	Fquant              int32
 	Ffstrength          int32
 	Fmax_edge           int32
 	Fmin_disto          int32
 	Flambda_i16         int32
 	Flambda_i4          int32
 	Flambda_uv          int32
 	Flambda_mode        int32
 	Flambda_trellis     int32
 	Ftlambda            int32
 	Flambda_trellis_i16 int32
 	Flambda_trellis_i4  int32
 	Flambda_trellis_uv  int32
 	Fi4_penalty         score_t
 }
 
 type DError = [2][2]int8_t
 
 type VP8ModeScore = struct {
 	FD           score_t
 	FSD          score_t
 	FH           score_t
 	FR           score_t
 	Fscore       score_t
 	Fy_dc_levels [16]int16_t
 	Fy_ac_levels [16][16]int16_t
 	Fuv_levels   [8][16]int16_t
 	Fmode_i16    int32
 	Fmodes_i4    [16]uint8_t
 	Fmode_uv     int32
 	Fnz          uint32_t
 	Fderr        [2][3]int8_t
 }
 
 type VP8EncIterator = struct {
 	Fx            int32
 	Fy            int32
 	Fyuv_in       uintptr
 	Fyuv_out      uintptr
 	Fyuv_out2     uintptr
 	Fyuv_p        uintptr
 	Fenc          uintptr
 	Fmb           uintptr
 	Fbw           uintptr
 	Fpreds        uintptr
 	Fnz           uintptr
 	Fi4_boundary  [37]uint8_t
 	Fi4_top       uintptr
 	Fi4           int32
 	Ftop_nz       [9]int32
 	Fleft_nz      [9]int32
 	Fbit_count    [4][3]uint64_t
 	Fluma_bits    uint64_t
 	Fuv_bits      uint64_t
 	Flf_stats     uintptr
 	Fdo_trellis   int32
 	Fcount_down   int32
 	Fcount_down0  int32
 	Fpercent0     int32
 	Fleft_derr    DError
 	Ftop_derr     uintptr
 	Fy_left       uintptr
 	Fu_left       uintptr
 	Fv_left       uintptr
 	Fy_top        uintptr
 	Fuv_top       uintptr
 	Fyuv_left_mem [88]uint8_t
 	Fyuv_mem      [3359]uint8_t
 }
 
 type VP8TBuffer = struct {
 	Fpages     uintptr
 	Flast_page uintptr
 	Ftokens    uintptr
 	Fleft      int32
 	Fpage_size int32
 	Ferror1    int32
 }
 
 type Mode = int32
 
 const kLiteral = 0
 const kCacheIdx = 1
 const kCopy = 2
 const kNone = 3
 
 type PixOrCopy = struct {
 	Fmode             uint8_t
 	Flen1             uint16_t
 	Fargb_or_distance uint32_t
 }
 
 type VP8LHashChain = struct {
 	Foffset_length uintptr
 	Fsize          int32
 }
 
 type VP8LBackwardRefs = struct {
 	Fblock_size  int32
 	Ferror1      int32
 	Frefs        uintptr
 	Ftail        uintptr
 	Ffree_blocks uintptr
 	Flast_block  uintptr
 }
 
 type VP8LRefsCursor = struct {
 	Fcur_pos   uintptr
 	Fcur_block uintptr
 	Flast_pos  uintptr
 }
 
 type VP8LLZ77Type = int32
 
 const kLZ77Standard = 1
 const kLZ77RLE = 2
 const kLZ77Box = 4
 
 type VP8LHistogram = struct {
 	Fliteral           uintptr
 	Fred               [256]uint32_t
 	Fblue              [256]uint32_t
 	Falpha             [256]uint32_t
 	Fdistance          [40]uint32_t
 	Fpalette_code_bits int32
 	Ftrivial_symbol    [5]uint16_t
 	Fbit_cost          uint64_t
 	Fcosts             [5]uint64_t
 	Fis_used           [5]uint8_t
 	Fbin_id            uint16_t
 }
 
 type VP8LHistogramSet = struct {
 	Fsize       int32
 	Fmax_size   int32
 	Fhistograms uintptr
 }
 
 type VP8LEncoderARGBContent = int32
 
 const kEncoderNone = 0
 const kEncoderARGB = 1
 const kEncoderNearLossless = 2
 const kEncoderPalette = 3
 
 type VP8LEncoder = struct {
 	Fconfig                     uintptr
 	Fpic                        uintptr
 	Fargb                       uintptr
 	Fargb_content               VP8LEncoderARGBContent
 	Fargb_scratch               uintptr
 	Ftransform_data             uintptr
 	Ftransform_mem              uintptr
 	Ftransform_mem_size         size_t
 	Fcurrent_width              int32
 	Fhisto_bits                 int32
 	Fpredictor_transform_bits   int32
 	Fcross_color_transform_bits int32
 	Fcache_bits                 int32
 	Fuse_cross_color            int32
 	Fuse_subtract_green         int32
 	Fuse_predict                int32
 	Fuse_palette                int32
 	Fpalette_size               int32
 	Fpalette                    [256]uint32_t
 	Fpalette_sorted             [256]uint32_t
 	Frefs                       [4]VP8LBackwardRefs
 	Fhash_chain                 VP8LHashChain
 }
 
 //------------------------------------------------------------------------------
 
 func EncodeLossless(tls *libc.TLS, data uintptr, width int32, height int32, effort_level int32, use_quality_100 int32, bw uintptr, stats uintptr) (r int32) {
 	bp := tls.Alloc(384)
 	defer tls.Free(384)
 	var ok, v1 int32
 	var v5 float32
 	var _ /* config at bp+0 */ WebPConfig
 	var _ /* picture at bp+120 */ WebPPicture
 	_, _, _ = ok, v1, v5
 	ok = 0
 	v1 = WebPPictureInitInternal(tls, bp+120, int32(WEBP_ENCODER_ABI_VERSION))
 	goto _2
 _2:
 	if !(v1 != 0) {
 		return 0
 	}
 	(**(**WebPPicture)(__ccgo_up(bp + 120))).Fwidth = width
 	(**(**WebPPicture)(__ccgo_up(bp + 120))).Fheight = height
 	(**(**WebPPicture)(__ccgo_up(bp + 120))).Fuse_argb = int32(1)
 	(**(**WebPPicture)(__ccgo_up(bp + 120))).Fstats = stats
 	if !(WebPPictureAlloc(tls, bp+120) != 0) {
 		return 0
 	}
 	// Transfer the alpha values to the green channel.
 	(*(*func(*libc.TLS, uintptr, int32, int32, int32, uintptr, int32))(unsafe.Pointer(&struct{ uintptr }{WebPDispatchAlphaToGreen})))(tls, data, width, (**(**WebPPicture)(__ccgo_up(bp + 120))).Fwidth, (**(**WebPPicture)(__ccgo_up(bp + 120))).Fheight, (**(**WebPPicture)(__ccgo_up(bp + 120))).Fargb, (**(**WebPPicture)(__ccgo_up(bp + 120))).Fargb_stride)
 	v1 = WebPConfigInitInternal(tls, bp, int32(WEBP_PRESET_DEFAULT), libc.Float32FromFloat32(75), int32(WEBP_ENCODER_ABI_VERSION))
 	goto _4
 _4:
 	if !(v1 != 0) {
 		return 0
 	}
 	(**(**WebPConfig)(__ccgo_up(bp))).Flossless = int32(1)
 	// Enable exact, or it would alter RGB values of transparent alpha, which is
 	// normally OK but not here since we are not encoding the input image but  an
 	// internal encoding-related image containing necessary exact information in
 	// RGB channels.
 	(**(**WebPConfig)(__ccgo_up(bp))).Fexact = int32(1)
 	(**(**WebPConfig)(__ccgo_up(bp))).Fmethod = effort_level // impact is very small
 	// Set a low default quality for encoding alpha. Ensure that Alpha quality at
 	// lower methods (3 and below) is less than the threshold for triggering
 	// costly 'BackwardReferencesTraceBackwards'.
 	// If the alpha quality is set to 100 and the method to 6, allow for a high
 	// lossless quality to trigger the cruncher.
 	if use_quality_100 != 0 && effort_level == int32(6) {
 		v5 = libc.Float32FromInt32(100)
 	} else {
 		v5 = float32(libc.Float32FromFloat32(8) * float32(effort_level))
 	}
 	(**(**WebPConfig)(__ccgo_up(bp))).Fquality = v5
 	ok = VP8LEncodeStream(tls, bp, bp+120, bw)
 	WebPPictureFree(tls, bp+120)
 	ok = libc.BoolInt32(ok != 0 && !((*VP8LBitWriter)(unsafe.Pointer(bw)).Ferror1 != 0))
 	if !(ok != 0) {
 		VP8LBitWriterWipeOut(tls, bw)
 		return 0
 	}
 	return int32(1)
 }
 
 // -----------------------------------------------------------------------------
 
 // C documentation
 //
 //	// Small struct to hold the result of a filter mode compression attempt.
 type FilterTrial = struct {
 	Fscore size_t
 	Fbw    VP8BitWriter
 	Fstats WebPAuxStats
 }
 
 // C documentation
 //
 //	// This function always returns an initialized 'bw' object, even upon error.
 func EncodeAlphaInternal(tls *libc.TLS, data uintptr, width int32, height int32, method int32, filter int32, reduce_levels int32, effort_level int32, tmp_alpha uintptr, result uintptr) (r int32) {
 	bp := tls.Alloc(64)
 	defer tls.Free(64)
 	var alpha_src, output, v1 uintptr
 	var data_size, output_size, v2 size_t
 	var filter_func WebPFilterFunc
 	var ok int32
 	var _ /* header at bp+0 */ uint8_t
 	var _ /* tmp_bw at bp+8 */ VP8LBitWriter
 	_, _, _, _, _, _, _, _ = alpha_src, data_size, filter_func, ok, output, output_size, v1, v2
 	ok = 0
 	data_size = libc.Uint64FromInt32(width * height)
 	output = libc.UintptrFromInt32(0)
 	output_size = uint64(0)
 	// as per spec
 	filter_func = WebPFilters[filter]
 	if filter_func != libc.UintptrFromInt32(0) {
 		(*(*func(*libc.TLS, uintptr, int32, int32, int32, uintptr))(unsafe.Pointer(&struct{ uintptr }{filter_func})))(tls, data, width, height, width, tmp_alpha)
 		alpha_src = tmp_alpha
 	} else {
 		alpha_src = data
 	}
 	if method != ALPHA_NO_COMPRESSION {
 		ok = VP8LBitWriterInit(tls, bp+8, data_size>>int32(3))
 		ok = libc.BoolInt32(ok != 0 && EncodeLossless(tls, alpha_src, width, height, effort_level, libc.BoolInt32(!(reduce_levels != 0)), bp+8, result+56) != 0)
 		if ok != 0 {
 			output = VP8LBitWriterFinish(tls, bp+8)
 			if (**(**VP8LBitWriter)(__ccgo_up(bp + 8))).Ferror1 != 0 {
 				VP8LBitWriterWipeOut(tls, bp+8)
 				libc.X__builtin___memset_chk(tls, result+8, 0, uint64(48), ^__predefined_size_t(0))
 				return 0
 			}
 			v1 = bp + 8
 			v2 = libc.Uint64FromInt64(int64((*VP8LBitWriter)(unsafe.Pointer(v1)).Fcur) - int64((*VP8LBitWriter)(unsafe.Pointer(v1)).Fbuf) + int64(((*VP8LBitWriter)(unsafe.Pointer(v1)).Fused+libc.Int32FromInt32(7))>>libc.Int32FromInt32(3)))
 			goto _3
 		_3:
 			output_size = v2
 			if output_size > data_size {
 				// compressed size is larger than source! Revert to uncompressed mode.
 				method = ALPHA_NO_COMPRESSION
 				VP8LBitWriterWipeOut(tls, bp+8)
 			}
 		} else {
 			VP8LBitWriterWipeOut(tls, bp+8)
 			libc.X__builtin___memset_chk(tls, result+8, 0, uint64(48), ^__predefined_size_t(0))
 			return 0
 		}
 	}
 	if method == ALPHA_NO_COMPRESSION {
 		output = alpha_src
 		output_size = data_size
 		ok = int32(1)
 	}
 	// Emit final result.
 	**(**uint8_t)(__ccgo_up(bp)) = libc.Uint8FromInt32(method | filter<<int32(2))
 	if reduce_levels != 0 {
 		**(**uint8_t)(__ccgo_up(bp)) = libc.Uint8FromInt32(int32(**(**uint8_t)(__ccgo_up(bp))) | libc.Int32FromInt32(ALPHA_PREPROCESSED_LEVELS)<<libc.Int32FromInt32(4))
 	}
 	if !(VP8BitWriterInit(tls, result+8, uint64(ALPHA_HEADER_LEN)+output_size) != 0) {
 		ok = 0
 	}
 	ok = libc.BoolInt32(ok != 0 && VP8BitWriterAppend(tls, result+8, bp, uint64(ALPHA_HEADER_LEN)) != 0)
 	ok = libc.BoolInt32(ok != 0 && VP8BitWriterAppend(tls, result+8, output, output_size) != 0)
 	if method != ALPHA_NO_COMPRESSION {
 		VP8LBitWriterWipeOut(tls, bp+8)
 	}
 	ok = libc.BoolInt32(ok != 0 && !((*FilterTrial)(unsafe.Pointer(result)).Fbw.Ferror1 != 0))
 	v2 = (*VP8BitWriter)(unsafe.Pointer(result + 8)).Fpos
 	goto _5
 _5:
 	(*FilterTrial)(unsafe.Pointer(result)).Fscore = v2
 	return ok
 }
 
 // -----------------------------------------------------------------------------
 
 func GetNumColors(tls *libc.TLS, data uintptr, width int32, height int32, stride int32) (r int32) {
 	var color [256]uint8_t
 	var colors, i, j int32
 	var p uintptr
 	_, _, _, _, _ = color, colors, i, j, p
 	colors = 0
 	color = [256]uint8_t{}
 	j = 0
 	for {
 		if !(j < height) {
 			break
 		}
 		p = data + uintptr(j*stride)
 		i = 0
 		for {
 			if !(i < width) {
 				break
 			}
 			color[**(**uint8_t)(__ccgo_up(p + uintptr(i)))] = uint8(1)
 			goto _2
 		_2:
 			;
 			i = i + 1
 		}
 		goto _1
 	_1:
 		;
 		j = j + 1
 	}
 	j = 0
 	for {
 		if !(j < int32(256)) {
 			break
 		}
 		if libc.Int32FromUint8(color[j]) > 0 {
 			colors = colors + 1
 		}
 		goto _3
 	_3:
 		;
 		j = j + 1
 	}
 	return colors
 }
 
 // C documentation
 //
 //	// Given the input 'filter' option, return an OR'd bit-set of filters to try.
 func GetFilterMap(tls *libc.TLS, alpha uintptr, width int32, height int32, filter int32, effort_level int32) (r uint32_t) {
 	var bit_map uint32_t
 	var kMaxColorsForFilterNone, kMinColorsForFilterNone, num_colors, try_filter_none, v1 int32
 	_, _, _, _, _, _ = bit_map, kMaxColorsForFilterNone, kMinColorsForFilterNone, num_colors, try_filter_none, v1
 	bit_map = 0
 	if filter == int32(WEBP_FILTER_FAST) {
 		// Quick estimate of the best candidate.
 		try_filter_none = libc.BoolInt32(effort_level > int32(3))
 		kMinColorsForFilterNone = int32(16)
 		kMaxColorsForFilterNone = int32(192)
 		num_colors = GetNumColors(tls, alpha, width, height, width)
 		// For low number of colors, NONE yields better compression.
 		if num_colors <= kMinColorsForFilterNone {
 			v1 = int32(WEBP_FILTER_NONE)
 		} else {
 			v1 = WebPEstimateBestFilter(tls, alpha, width, height, width)
 		}
 		filter = v1
 		bit_map = bit_map | libc.Uint32FromInt32(int32(1)<<filter)
 		// For large number of colors, try FILTER_NONE in addition to the best
 		// filter as well.
 		if try_filter_none != 0 || num_colors > kMaxColorsForFilterNone {
 			bit_map = bit_map | libc.Uint32FromInt32(libc.Int32FromInt32(1)<<int32(WEBP_FILTER_NONE))
 		}
 	} else {
 		if filter == int32(WEBP_FILTER_NONE) {
 			bit_map = libc.Uint32FromInt32(libc.Int32FromInt32(1) << int32(WEBP_FILTER_NONE))
 		} else { // WEBP_FILTER_BEST -> try all
 			bit_map = libc.Uint32FromInt32(libc.Int32FromInt32(1)<<int32(WEBP_FILTER_LAST) - libc.Int32FromInt32(1))
 		}
 	}
 	return bit_map
 }
 
 func InitFilterTrial(tls *libc.TLS, score uintptr) {
 	(*FilterTrial)(unsafe.Pointer(score)).Fscore = uint64(^libc.Uint32FromUint32(0))
 	VP8BitWriterInit(tls, score+8, uint64(0))
 }
 
 func ApplyFiltersAndEncode(tls *libc.TLS, alpha uintptr, width int32, height int32, data_size size_t, method int32, filter int32, reduce_levels int32, effort_level int32, output uintptr, output_size uintptr, stats uintptr) (r int32) {
 	bp := tls.Alloc(496)
 	defer tls.Free(496)
 	var filtered_alpha, v4 uintptr
 	var ok int32
 	var try_map uint32_t
 	var v2 size_t
 	var _ /* best at bp+0 */ FilterTrial
 	var _ /* trial at bp+248 */ FilterTrial
 	_, _, _, _, _ = filtered_alpha, ok, try_map, v2, v4
 	ok = int32(1)
 	try_map = GetFilterMap(tls, alpha, width, height, filter, effort_level)
 	InitFilterTrial(tls, bp)
 	if try_map != libc.Uint32FromInt32(libc.Int32FromInt32(1)<<int32(WEBP_FILTER_NONE)) {
 		filtered_alpha = WebPSafeMalloc(tls, uint64(1), data_size)
 		if filtered_alpha == libc.UintptrFromInt32(0) {
 			return 0
 		}
 		filter = int32(WEBP_FILTER_NONE)
 		for {
 			if !(ok != 0 && try_map != 0) {
 				break
 			}
 			if try_map&uint32(1) != 0 {
 				ok = EncodeAlphaInternal(tls, alpha, width, height, method, filter, reduce_levels, effort_level, filtered_alpha, bp+248)
 				if ok != 0 && (**(**FilterTrial)(__ccgo_up(bp + 248))).Fscore < (**(**FilterTrial)(__ccgo_up(bp))).Fscore {
 					VP8BitWriterWipeOut(tls, bp+8)
 					**(**FilterTrial)(__ccgo_up(bp)) = **(**FilterTrial)(__ccgo_up(bp + 248))
 				} else {
 					VP8BitWriterWipeOut(tls, bp+248+8)
 				}
 			}
 			goto _1
 		_1:
 			;
 			filter = filter + 1
 			try_map = try_map >> uint32(1)
 		}
 		WebPSafeFree(tls, filtered_alpha)
 	} else {
 		ok = EncodeAlphaInternal(tls, alpha, width, height, method, int32(WEBP_FILTER_NONE), reduce_levels, effort_level, libc.UintptrFromInt32(0), bp)
 	}
 	if ok != 0 {
 		if stats != libc.UintptrFromInt32(0) {
 			(*WebPAuxStats)(unsafe.Pointer(stats)).Flossless_features = (**(**FilterTrial)(__ccgo_up(bp))).Fstats.Flossless_features
 			(*WebPAuxStats)(unsafe.Pointer(stats)).Fhistogram_bits = (**(**FilterTrial)(__ccgo_up(bp))).Fstats.Fhistogram_bits
 			(*WebPAuxStats)(unsafe.Pointer(stats)).Ftransform_bits = (**(**FilterTrial)(__ccgo_up(bp))).Fstats.Ftransform_bits
 			(*WebPAuxStats)(unsafe.Pointer(stats)).Fcross_color_transform_bits = (**(**FilterTrial)(__ccgo_up(bp))).Fstats.Fcross_color_transform_bits
 			(*WebPAuxStats)(unsafe.Pointer(stats)).Fcache_bits = (**(**FilterTrial)(__ccgo_up(bp))).Fstats.Fcache_bits
 			(*WebPAuxStats)(unsafe.Pointer(stats)).Fpalette_size = (**(**FilterTrial)(__ccgo_up(bp))).Fstats.Fpalette_size
 			(*WebPAuxStats)(unsafe.Pointer(stats)).Flossless_size = (**(**FilterTrial)(__ccgo_up(bp))).Fstats.Flossless_size
 			(*WebPAuxStats)(unsafe.Pointer(stats)).Flossless_hdr_size = (**(**FilterTrial)(__ccgo_up(bp))).Fstats.Flossless_hdr_size
 			(*WebPAuxStats)(unsafe.Pointer(stats)).Flossless_data_size = (**(**FilterTrial)(__ccgo_up(bp))).Fstats.Flossless_data_size
 		}
 		v2 = (*VP8BitWriter)(unsafe.Pointer(bp + 8)).Fpos
 		goto _3
 	_3:
 		**(**size_t)(__ccgo_up(output_size)) = v2
 		v4 = (*VP8BitWriter)(unsafe.Pointer(bp + 8)).Fbuf
 		goto _5
 	_5:
 		**(**uintptr)(__ccgo_up(output)) = v4
 	} else {
 		VP8BitWriterWipeOut(tls, bp+8)
 	}
 	return ok
 }
 
 func EncodeAlpha(tls *libc.TLS, enc uintptr, quality int32, method int32, filter int32, effort_level int32, output uintptr, output_size uintptr) (r int32) {
 	bp := tls.Alloc(16)
 	defer tls.Free(16)
 	var alpha_levels, height, ok, reduce_levels, width, v1 int32
 	var data_size size_t
 	var pic, quant_alpha uintptr
 	var _ /* sse at bp+0 */ uint64_t
 	_, _, _, _, _, _, _, _, _ = alpha_levels, data_size, height, ok, pic, quant_alpha, reduce_levels, width, v1
 	pic = (*VP8Encoder)(unsafe.Pointer(enc)).Fpic
 	width = (*WebPPicture)(unsafe.Pointer(pic)).Fwidth
 	height = (*WebPPicture)(unsafe.Pointer(pic)).Fheight
 	quant_alpha = libc.UintptrFromInt32(0)
 	data_size = libc.Uint64FromInt32(width * height)
 	**(**uint64_t)(__ccgo_up(bp)) = uint64(0)
 	ok = int32(1)
 	reduce_levels = libc.BoolInt32(quality < libc.Int32FromInt32(100))
 	// quick correctness checks
 	// as per spec
 	if quality < 0 || quality > int32(100) {
 		return WebPEncodingSetError(tls, pic, int32(VP8_ENC_ERROR_INVALID_CONFIGURATION))
 	}
 	if method < ALPHA_NO_COMPRESSION || method > int32(ALPHA_LOSSLESS_COMPRESSION) {
 		return WebPEncodingSetError(tls, pic, int32(VP8_ENC_ERROR_INVALID_CONFIGURATION))
 	}
 	if method == ALPHA_NO_COMPRESSION {
 		// Don't filter, as filtering will make no impact on compressed size.
 		filter = int32(WEBP_FILTER_NONE)
 	}
 	quant_alpha = WebPSafeMalloc(tls, uint64(1), data_size)
 	if quant_alpha == libc.UintptrFromInt32(0) {
 		return WebPEncodingSetError(tls, pic, int32(VP8_ENC_ERROR_OUT_OF_MEMORY))
 	}
 	// Extract alpha data (width x height) from raw_data (stride x height).
 	WebPCopyPlane(tls, (*WebPPicture)(unsafe.Pointer(pic)).Fa, (*WebPPicture)(unsafe.Pointer(pic)).Fa_stride, quant_alpha, width, width, height)
 	if reduce_levels != 0 {
 		if quality <= int32(70) {
 			v1 = int32(2) + quality/int32(5)
 		} else {
 			v1 = int32(16) + (quality-int32(70))*int32(8)
 		} // No Quantization required for 'quality = 100'.
 		// 16 alpha levels gives quite a low MSE w.r.t original alpha plane hence
 		// mapped to moderate quality 70. Hence Quality:[0, 70] -> Levels:[2, 16]
 		// and Quality:]70, 100] -> Levels:]16, 256].
 		alpha_levels = v1
 		ok = QuantizeLevels(tls, quant_alpha, width, height, alpha_levels, bp)
 	}
 	if ok != 0 {
 		VP8FiltersInit(tls)
 		ok = ApplyFiltersAndEncode(tls, quant_alpha, width, height, data_size, method, filter, reduce_levels, effort_level, output, output_size, (*WebPPicture)(unsafe.Pointer(pic)).Fstats)
 		if !(ok != 0) {
 			WebPEncodingSetError(tls, pic, int32(VP8_ENC_ERROR_OUT_OF_MEMORY)) // imprecise
 		}
 		if (*WebPPicture)(unsafe.Pointer(pic)).Fstats != libc.UintptrFromInt32(0) { // need stats?
 			**(**int32)(__ccgo_up((*WebPPicture)(unsafe.Pointer(pic)).Fstats)) += libc.Int32FromUint64(**(**size_t)(__ccgo_up(output_size)))
 			**(**uint64_t)(__ccgo_up(enc + 23512 + 3*8)) = **(**uint64_t)(__ccgo_up(bp))
 		}
 	}
 	WebPSafeFree(tls, quant_alpha)
 	return ok
 }
 
 //------------------------------------------------------------------------------
 // Main calls
 
 func CompressAlphaJob(tls *libc.TLS, arg1 uintptr, unused uintptr) (r int32) {
 	bp := tls.Alloc(16)
 	defer tls.Free(16)
 	var config, enc uintptr
 	var effort_level, v1, v2 int32
 	var filter WEBP_FILTER_TYPE
 	var _ /* alpha_data at bp+0 */ uintptr
 	var _ /* alpha_size at bp+8 */ size_t
 	_, _, _, _, _, _ = config, effort_level, enc, filter, v1, v2
 	enc = arg1
 	config = (*VP8Encoder)(unsafe.Pointer(enc)).Fconfig
 	**(**uintptr)(__ccgo_up(bp)) = libc.UintptrFromInt32(0)
 	**(**size_t)(__ccgo_up(bp + 8)) = uint64(0)
 	effort_level = (*WebPConfig)(unsafe.Pointer(config)).Fmethod
 	if (*WebPConfig)(unsafe.Pointer(config)).Falpha_filtering == 0 {
 		v1 = int32(WEBP_FILTER_NONE)
 	} else {
 		if (*WebPConfig)(unsafe.Pointer(config)).Falpha_filtering == int32(1) {
 			v2 = int32(WEBP_FILTER_FAST)
 		} else {
 			v2 = int32(WEBP_FILTER_BEST)
 		}
 		v1 = v2
 	} // maps to [0..6]
 	filter = v1
 	if !(EncodeAlpha(tls, enc, (*WebPConfig)(unsafe.Pointer(config)).Falpha_quality, (*WebPConfig)(unsafe.Pointer(config)).Falpha_compression, filter, effort_level, bp, bp+8) != 0) {
 		return 0
 	}
 	if **(**size_t)(__ccgo_up(bp + 8)) != uint64(uint32(**(**size_t)(__ccgo_up(bp + 8)))) { // Soundness check.
 		WebPSafeFree(tls, **(**uintptr)(__ccgo_up(bp)))
 		return 0
 	}
 	(*VP8Encoder)(unsafe.Pointer(enc)).Falpha_data_size = uint32(**(**size_t)(__ccgo_up(bp + 8)))
 	(*VP8Encoder)(unsafe.Pointer(enc)).Falpha_data = **(**uintptr)(__ccgo_up(bp))
 	_ = unused
 	return int32(1)
 }
 
 func VP8EncInitAlpha(tls *libc.TLS, enc uintptr) {
 	var worker uintptr
 	_ = worker
 	WebPInitAlphaProcessing(tls)
 	(*VP8Encoder)(unsafe.Pointer(enc)).Fhas_alpha = WebPPictureHasTransparency(tls, (*VP8Encoder)(unsafe.Pointer(enc)).Fpic)
 	(*VP8Encoder)(unsafe.Pointer(enc)).Falpha_data = libc.UintptrFromInt32(0)
 	(*VP8Encoder)(unsafe.Pointer(enc)).Falpha_data_size = uint32(0)
 	if (*VP8Encoder)(unsafe.Pointer(enc)).Fthread_level > 0 {
 		worker = enc + 560
 		(*(*func(*libc.TLS, uintptr))(unsafe.Pointer(&struct{ uintptr }{(*WebPWorkerInterface)(unsafe.Pointer(WebPGetWorkerInterface(tls))).FInit})))(tls, worker)
 		(*WebPWorker)(unsafe.Pointer(worker)).Fdata1 = enc
 		(*WebPWorker)(unsafe.Pointer(worker)).Fdata2 = libc.UintptrFromInt32(0)
 		(*WebPWorker)(unsafe.Pointer(worker)).Fhook = __ccgo_fp(CompressAlphaJob)
 	}
 }
 
 func VP8EncStartAlpha(tls *libc.TLS, enc uintptr) (r int32) {
 	var worker uintptr
 	_ = worker
 	if (*VP8Encoder)(unsafe.Pointer(enc)).Fhas_alpha != 0 {
 		if (*VP8Encoder)(unsafe.Pointer(enc)).Fthread_level > 0 {
 			worker = enc + 560
 			// Makes sure worker is good to go.
 			if !((*(*func(*libc.TLS, uintptr) int32)(unsafe.Pointer(&struct{ uintptr }{(*WebPWorkerInterface)(unsafe.Pointer(WebPGetWorkerInterface(tls))).FReset})))(tls, worker) != 0) {
 				return WebPEncodingSetError(tls, (*VP8Encoder)(unsafe.Pointer(enc)).Fpic, int32(VP8_ENC_ERROR_OUT_OF_MEMORY))
 			}
 			(*(*func(*libc.TLS, uintptr))(unsafe.Pointer(&struct{ uintptr }{(*WebPWorkerInterface)(unsafe.Pointer(WebPGetWorkerInterface(tls))).FLaunch})))(tls, worker)
 			return int32(1)
 		} else {
 			return CompressAlphaJob(tls, enc, libc.UintptrFromInt32(0)) // just do the job right away
 		}
 	}
 	return int32(1)
 }
 
 func VP8EncFinishAlpha(tls *libc.TLS, enc uintptr) (r int32) {
 	var worker uintptr
 	_ = worker
 	if (*VP8Encoder)(unsafe.Pointer(enc)).Fhas_alpha != 0 {
 		if (*VP8Encoder)(unsafe.Pointer(enc)).Fthread_level > 0 {
 			worker = enc + 560
 			if !((*(*func(*libc.TLS, uintptr) int32)(unsafe.Pointer(&struct{ uintptr }{(*WebPWorkerInterface)(unsafe.Pointer(WebPGetWorkerInterface(tls))).FSync})))(tls, worker) != 0) {
 				return 0
 			} // error
 		}
 	}
 	return WebPReportProgress(tls, (*VP8Encoder)(unsafe.Pointer(enc)).Fpic, (*VP8Encoder)(unsafe.Pointer(enc)).Fpercent+int32(20), enc+536)
 }
 
 func VP8EncDeleteAlpha(tls *libc.TLS, enc uintptr) (r int32) {
 	var ok int32
 	var worker uintptr
 	_, _ = ok, worker
 	ok = int32(1)
 	if (*VP8Encoder)(unsafe.Pointer(enc)).Fthread_level > 0 {
 		worker = enc + 560
 		// finish anything left in flight
 		ok = (*(*func(*libc.TLS, uintptr) int32)(unsafe.Pointer(&struct{ uintptr }{(*WebPWorkerInterface)(unsafe.Pointer(WebPGetWorkerInterface(tls))).FSync})))(tls, worker)
 		// still need to end the worker, even if !ok
 		(*(*func(*libc.TLS, uintptr))(unsafe.Pointer(&struct{ uintptr }{(*WebPWorkerInterface)(unsafe.Pointer(WebPGetWorkerInterface(tls))).FEnd})))(tls, worker)
 	}
 	WebPSafeFree(tls, (*VP8Encoder)(unsafe.Pointer(enc)).Falpha_data)
 	(*VP8Encoder)(unsafe.Pointer(enc)).Falpha_data = libc.UintptrFromInt32(0)
 	(*VP8Encoder)(unsafe.Pointer(enc)).Falpha_data_size = uint32(0)
 	(*VP8Encoder)(unsafe.Pointer(enc)).Fhas_alpha = 0
 	return ok
 }
 
 const MAX_ALPHA = 255
 const MAX_INTRA16_MODE = 2
 const MAX_INTRA4_MODE = 2
 const MAX_ITERS_K_MEANS = 6
 const MAX_UV_MODE = 2
 
 //------------------------------------------------------------------------------
 
 // Copyright 2011 Google Inc. All Rights Reserved.
 //
 // Use of this source code is governed by a BSD-style license
 // that can be found in the COPYING file in the root of the source
 // tree. An additional intellectual property rights grant can be found
 // in the file PATENTS. All contributing project authors may
 // be found in the AUTHORS file in the root of the source tree.
 // -----------------------------------------------------------------------------
 //
 // Multi-threaded worker
 //
 // Author: Skal (pascal.massimino@gmail.com)
 
 // Copyright 2012 Google Inc. All Rights Reserved.
 //
 // Use of this source code is governed by a BSD-style license
 // that can be found in the COPYING file in the root of the source
 // tree. An additional intellectual property rights grant can be found
 // in the file PATENTS. All contributing project authors may
 // be found in the AUTHORS file in the root of the source tree.
 // -----------------------------------------------------------------------------
 //
 // Misc. common utility functions
 //
 // Authors: Skal (pascal.massimino@gmail.com)
 //          Urvang (urvang@google.com)
 
 // Copyright 2011 Google Inc. All Rights Reserved.
 //
 // Use of this source code is governed by a BSD-style license
 // that can be found in the COPYING file in the root of the source
 // tree. An additional intellectual property rights grant can be found
 // in the file PATENTS. All contributing project authors may
 // be found in the AUTHORS file in the root of the source tree.
 // -----------------------------------------------------------------------------
 //
 //   WebP encoder: main interface
 //
 // Author: Skal (pascal.massimino@gmail.com)
 
 // Copyright 2010 Google Inc. All Rights Reserved.
 //
 // Use of this source code is governed by a BSD-style license
 // that can be found in the COPYING file in the root of the source
 // tree. An additional intellectual property rights grant can be found
 // in the file PATENTS. All contributing project authors may
 // be found in the AUTHORS file in the root of the source tree.
 // -----------------------------------------------------------------------------
 //
 //  Common types + memory wrappers
 //
 // Author: Skal (pascal.massimino@gmail.com)
 
 //------------------------------------------------------------------------------
 // Smooth the segment map by replacing isolated block by the majority of its
 // neighbours.
 
 func SmoothSegmentMap(tls *libc.TLS, enc uintptr) {
 	var cnt [4]int32
 	var h, majority_cnt_3_x_3_grid, majority_seg, n, w, x, y int32
 	var mb, mb1, tmp uintptr
 	_, _, _, _, _, _, _, _, _, _, _ = cnt, h, majority_cnt_3_x_3_grid, majority_seg, mb, mb1, n, tmp, w, x, y
 	w = (*VP8Encoder)(unsafe.Pointer(enc)).Fmb_w
 	h = (*VP8Encoder)(unsafe.Pointer(enc)).Fmb_h
 	majority_cnt_3_x_3_grid = int32(5)
 	tmp = WebPSafeMalloc(tls, libc.Uint64FromInt32(w*h), uint64(1))
 	// no overflow, as per spec
 	if tmp == libc.UintptrFromInt32(0) {
 		return
 	}
 	y = int32(1)
 	for {
 		if !(y < h-int32(1)) {
 			break
 		}
 		x = int32(1)
 		for {
 			if !(x < w-int32(1)) {
 				break
 			}
 			cnt = [4]int32{}
 			mb = (*VP8Encoder)(unsafe.Pointer(enc)).Fmb_info + uintptr(x+w*y)*4
 			majority_seg = int32(uint32(*(*uint8)(unsafe.Pointer(mb + 0)) & 0x60 >> 5))
 			// Check the 8 neighbouring segment values.
 			cnt[int32(uint32(*(*uint8)(unsafe.Pointer(mb + uintptr(-w-int32(1))*4 + 0))&0x60>>5))] = cnt[int32(uint32(*(*uint8)(unsafe.Pointer(mb + uintptr(-w-int32(1))*4 + 0))&0x60>>5))] + 1                         // top-left
 			cnt[int32(uint32(*(*uint8)(unsafe.Pointer(mb + uintptr(-w+0)*4 + 0))&0x60>>5))] = cnt[int32(uint32(*(*uint8)(unsafe.Pointer(mb + uintptr(-w+0)*4 + 0))&0x60>>5))] + 1                                       // top
 			cnt[int32(uint32(*(*uint8)(unsafe.Pointer(mb + uintptr(-w+int32(1))*4 + 0))&0x60>>5))] = cnt[int32(uint32(*(*uint8)(unsafe.Pointer(mb + uintptr(-w+int32(1))*4 + 0))&0x60>>5))] + 1                         // top-right
 			cnt[int32(uint32(*(*uint8)(unsafe.Pointer(mb + uintptr(-libc.Int32FromInt32(1))*4 + 0))&0x60>>5))] = cnt[int32(uint32(*(*uint8)(unsafe.Pointer(mb + uintptr(-libc.Int32FromInt32(1))*4 + 0))&0x60>>5))] + 1 // left
 			cnt[int32(uint32(*(*uint8)(unsafe.Pointer(mb + uintptr(+libc.Int32FromInt32(1))*4 + 0))&0x60>>5))] = cnt[int32(uint32(*(*uint8)(unsafe.Pointer(mb + uintptr(+libc.Int32FromInt32(1))*4 + 0))&0x60>>5))] + 1 // right
 			cnt[int32(uint32(*(*uint8)(unsafe.Pointer(mb + uintptr(w-int32(1))*4 + 0))&0x60>>5))] = cnt[int32(uint32(*(*uint8)(unsafe.Pointer(mb + uintptr(w-int32(1))*4 + 0))&0x60>>5))] + 1                           // bottom-left
 			cnt[int32(uint32(*(*uint8)(unsafe.Pointer(mb + uintptr(w+0)*4 + 0))&0x60>>5))] = cnt[int32(uint32(*(*uint8)(unsafe.Pointer(mb + uintptr(w+0)*4 + 0))&0x60>>5))] + 1                                         // bottom
 			cnt[int32(uint32(*(*uint8)(unsafe.Pointer(mb + uintptr(w+int32(1))*4 + 0))&0x60>>5))] = cnt[int32(uint32(*(*uint8)(unsafe.Pointer(mb + uintptr(w+int32(1))*4 + 0))&0x60>>5))] + 1                           // bottom-right
 			n = 0
 			for {
 				if !(n < int32(NUM_MB_SEGMENTS)) {
 					break
 				}
 				if cnt[n] >= majority_cnt_3_x_3_grid {
 					majority_seg = n
 					break
 				}
 				goto _3
 			_3:
 				;
 				n = n + 1
 			}
 			**(**uint8_t)(__ccgo_up(tmp + uintptr(x+y*w))) = libc.Uint8FromInt32(majority_seg)
 			goto _2
 		_2:
 			;
 			x = x + 1
 		}
 		goto _1
 	_1:
 		;
 		y = y + 1
 	}
 	y = int32(1)
 	for {
 		if !(y < h-int32(1)) {
 			break
 		}
 		x = int32(1)
 		for {
 			if !(x < w-int32(1)) {
 				break
 			}
 			mb1 = (*VP8Encoder)(unsafe.Pointer(enc)).Fmb_info + uintptr(x+w*y)*4
 			libc.SetBitFieldPtr8Uint32(mb1+0, uint32(**(**uint8_t)(__ccgo_up(tmp + uintptr(x+y*w)))), 5, 0x60)
 			goto _5
 		_5:
 			;
 			x = x + 1
 		}
 		goto _4
 	_4:
 		;
 		y = y + 1
 	}
 	WebPSafeFree(tls, tmp)
 }
 
 //------------------------------------------------------------------------------
 // set segment susceptibility 'alpha' / 'beta'
 
 func clip1(tls *libc.TLS, v int32, m int32, M int32) (r int32) {
 	var v1, v2 int32
 	_, _ = v1, v2
 	if v < m {
 		v1 = m
 	} else {
 		if v > M {
 			v2 = M
 		} else {
 			v2 = v
 		}
 		v1 = v2
 	}
 	return v1
 }
 
 func SetSegmentAlphas(tls *libc.TLS, enc uintptr, centers uintptr, mid int32) {
 	var alpha, beta, max, min, n, nb int32
 	_, _, _, _, _, _ = alpha, beta, max, min, n, nb
 	nb = (*VP8Encoder)(unsafe.Pointer(enc)).Fsegment_hdr.Fnum_segments
 	min = **(**int32)(__ccgo_up(centers))
 	max = **(**int32)(__ccgo_up(centers))
 	if nb > int32(1) {
 		n = 0
 		for {
 			if !(n < nb) {
 				break
 			}
 			if min > **(**int32)(__ccgo_up(centers + uintptr(n)*4)) {
 				min = **(**int32)(__ccgo_up(centers + uintptr(n)*4))
 			}
 			if max < **(**int32)(__ccgo_up(centers + uintptr(n)*4)) {
 				max = **(**int32)(__ccgo_up(centers + uintptr(n)*4))
 			}
 			goto _1
 		_1:
 			;
 			n = n + 1
 		}
 	}
 	if max == min {
 		max = min + int32(1)
 	}
 	n = 0
 	for {
 		if !(n < nb) {
 			break
 		}
 		alpha = int32(255) * (**(**int32)(__ccgo_up(centers + uintptr(n)*4)) - mid) / (max - min)
 		beta = int32(255) * (**(**int32)(__ccgo_up(centers + uintptr(n)*4)) - min) / (max - min)
 		(**(**VP8SegmentInfo)(__ccgo_up(enc + 608 + uintptr(n)*744))).Falpha = clip1(tls, alpha, -int32(127), int32(127))
 		(**(**VP8SegmentInfo)(__ccgo_up(enc + 608 + uintptr(n)*744))).Fbeta = clip1(tls, beta, 0, int32(255))
 		goto _2
 	_2:
 		;
 		n = n + 1
 	}
 }
 
 //------------------------------------------------------------------------------
 // Compute susceptibility based on DCT-coeff histograms:
 // the higher, the "easier" the macroblock is to compress.
 
 func FinalAlphaValue(tls *libc.TLS, alpha int32) (r int32) {
 	alpha = int32(MAX_ALPHA) - alpha
 	return clip1(tls, alpha, 0, int32(MAX_ALPHA))
 }
 
 func GetAlpha(tls *libc.TLS, histo uintptr) (r int32) {
 	var alpha, last_non_zero, max_value, v1 int32
 	_, _, _, _ = alpha, last_non_zero, max_value, v1
 	// 'alpha' will later be clipped to [0..MAX_ALPHA] range, clamping outer
 	// values which happen to be mostly noise. This leaves the maximum precision
 	// for handling the useful small values which contribute most.
 	max_value = (*VP8Histogram)(unsafe.Pointer(histo)).Fmax_value
 	last_non_zero = (*VP8Histogram)(unsafe.Pointer(histo)).Flast_non_zero
 	if max_value > int32(1) {
 		v1 = libc.Int32FromInt32(2) * libc.Int32FromInt32(MAX_ALPHA) * last_non_zero / max_value
 	} else {
 		v1 = 0
 	}
 	alpha = v1
 	return alpha
 }
 
 func InitHistogram(tls *libc.TLS, histo uintptr) {
 	(*VP8Histogram)(unsafe.Pointer(histo)).Fmax_value = 0
 	(*VP8Histogram)(unsafe.Pointer(histo)).Flast_non_zero = int32(1)
 }
 
 //------------------------------------------------------------------------------
 // Simplified k-Means, to assign Nb segments based on alpha-histogram
 
 func AssignSegments(tls *libc.TLS, enc uintptr, alphas uintptr) {
 	bp := tls.Alloc(48)
 	defer tls.Free(48)
 	var a, alpha, displaced, k, max_a, min_a, n, nb, new_center, range_a, smooth, total_weight, weighted_average, v1 int32
 	var map1 [256]int32
 	var mb uintptr
 	var _ /* accum at bp+16 */ [4]int32
 	var _ /* centers at bp+0 */ [4]int32
 	var _ /* dist_accum at bp+32 */ [4]int32
 	_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = a, alpha, displaced, k, map1, max_a, mb, min_a, n, nb, new_center, range_a, smooth, total_weight, weighted_average, v1
 	if (*VP8Encoder)(unsafe.Pointer(enc)).Fsegment_hdr.Fnum_segments < int32(NUM_MB_SEGMENTS) {
 		v1 = (*VP8Encoder)(unsafe.Pointer(enc)).Fsegment_hdr.Fnum_segments
 	} else {
 		v1 = int32(NUM_MB_SEGMENTS)
 	}
 	// 'num_segments' is previously validated and <= NUM_MB_SEGMENTS, but an
 	// explicit check is needed to avoid spurious warning about 'n + 1' exceeding
 	// array bounds of 'centers' with some compilers (noticed with gcc-4.9).
 	nb = v1
 	weighted_average = 0
 	min_a = 0
 	max_a = int32(MAX_ALPHA)
 	// bracket the input
 	n = 0
 	for {
 		if !(n <= int32(MAX_ALPHA) && **(**int32)(__ccgo_up(alphas + uintptr(n)*4)) == 0) {
 			break
 		}
 		goto _2
 	_2:
 		;
 		n = n + 1
 	}
 	min_a = n
 	n = int32(MAX_ALPHA)
 	for {
 		if !(n > min_a && **(**int32)(__ccgo_up(alphas + uintptr(n)*4)) == 0) {
 			break
 		}
 		goto _3
 	_3:
 		;
 		n = n - 1
 	}
 	max_a = n
 	range_a = max_a - min_a
 	// Spread initial centers evenly
 	k = 0
 	n = libc.Int32FromInt32(1)
 	for {
 		if !(k < nb) {
 			break
 		}
 		(**(**[4]int32)(__ccgo_up(bp)))[k] = min_a + n*range_a/(int32(2)*nb)
 		goto _4
 	_4:
 		;
 		k = k + 1
 		n = n + int32(2)
 	}
 	k = 0
 	for {
 		if !(k < int32(MAX_ITERS_K_MEANS)) {
 			break
 		}
 		// Reset stats
 		n = 0
 		for {
 			if !(n < nb) {
 				break
 			}
 			(**(**[4]int32)(__ccgo_up(bp + 16)))[n] = 0
 			(**(**[4]int32)(__ccgo_up(bp + 32)))[n] = 0
 			goto _6
 		_6:
 			;
 			n = n + 1
 		}
 		// Assign nearest center for each 'a'
 		n = 0 // track the nearest center for current 'a'
 		a = min_a
 		for {
 			if !(a <= max_a) {
 				break
 			}
 			if **(**int32)(__ccgo_up(alphas + uintptr(a)*4)) != 0 {
 				for n+int32(1) < nb && libc.Xabs(tls, a-(**(**[4]int32)(__ccgo_up(bp)))[n+int32(1)]) < libc.Xabs(tls, a-(**(**[4]int32)(__ccgo_up(bp)))[n]) {
 					n = n + 1
 				}
 				map1[a] = n
 				// accumulate contribution into best centroid
 				**(**int32)(__ccgo_up(bp + 32 + uintptr(n)*4)) += a * **(**int32)(__ccgo_up(alphas + uintptr(a)*4))
 				**(**int32)(__ccgo_up(bp + 16 + uintptr(n)*4)) += **(**int32)(__ccgo_up(alphas + uintptr(a)*4))
 			}
 			goto _7
 		_7:
 			;
 			a = a + 1
 		}
 		// All point are classified. Move the centroids to the
 		// center of their respective cloud.
 		displaced = 0
 		weighted_average = 0
 		total_weight = 0
 		n = 0
 		for {
 			if !(n < nb) {
 				break
 			}
 			if (**(**[4]int32)(__ccgo_up(bp + 16)))[n] != 0 {
 				new_center = ((**(**[4]int32)(__ccgo_up(bp + 32)))[n] + (**(**[4]int32)(__ccgo_up(bp + 16)))[n]/int32(2)) / (**(**[4]int32)(__ccgo_up(bp + 16)))[n]
 				displaced = displaced + libc.Xabs(tls, (**(**[4]int32)(__ccgo_up(bp)))[n]-new_center)
 				(**(**[4]int32)(__ccgo_up(bp)))[n] = new_center
 				weighted_average = weighted_average + new_center*(**(**[4]int32)(__ccgo_up(bp + 16)))[n]
 				total_weight = total_weight + (**(**[4]int32)(__ccgo_up(bp + 16)))[n]
 			}
 			goto _8
 		_8:
 			;
 			n = n + 1
 		}
 		weighted_average = (weighted_average + total_weight/int32(2)) / total_weight
 		if displaced < int32(5) {
 			break
 		} // no need to keep on looping...
 		goto _5
 	_5:
 		;
 		k = k + 1
 	}
 	// Map each original value to the closest centroid
 	n = 0
 	for {
 		if !(n < (*VP8Encoder)(unsafe.Pointer(enc)).Fmb_w*(*VP8Encoder)(unsafe.Pointer(enc)).Fmb_h) {
 			break
 		}
 		mb = (*VP8Encoder)(unsafe.Pointer(enc)).Fmb_info + uintptr(n)*4
 		alpha = libc.Int32FromUint8((*VP8MBInfo)(unsafe.Pointer(mb)).Falpha)
 		libc.SetBitFieldPtr8Uint32(mb+0, libc.Uint32FromInt32(map1[alpha]), 5, 0x60)
 		(*VP8MBInfo)(unsafe.Pointer(mb)).Falpha = libc.Uint8FromInt32((**(**[4]int32)(__ccgo_up(bp)))[map1[alpha]]) // for the record.
 		goto _9
 	_9:
 		;
 		n = n + 1
 	}
 	if nb > int32(1) {
 		smooth = (*WebPConfig)(unsafe.Pointer((*VP8Encoder)(unsafe.Pointer(enc)).Fconfig)).Fpreprocessing & libc.Int32FromInt32(1)
 		if smooth != 0 {
 			SmoothSegmentMap(tls, enc)
 		}
 	}
 	SetSegmentAlphas(tls, enc, bp, weighted_average) // pick some alphas.
 }
 
 //------------------------------------------------------------------------------
 // Macroblock analysis: collect histogram for each mode, deduce the maximal
 // susceptibility and set best modes for this macroblock.
 // Segment assignment is done later.
 
 // Number of modes to inspect for 'alpha' evaluation. We don't need to test all
 // the possible modes during the analysis phase: we risk falling into a local
 // optimum, or be subject to boundary effect
 
 func MBAnalyzeBestIntra16Mode(tls *libc.TLS, it uintptr) (r int32) {
 	bp := tls.Alloc(16)
 	defer tls.Free(16)
 	var alpha, best_alpha, best_mode, max_mode, mode int32
 	var _ /* histo at bp+0 */ VP8Histogram
 	_, _, _, _, _ = alpha, best_alpha, best_mode, max_mode, mode
 	max_mode = int32(MAX_INTRA16_MODE)
 	best_alpha = -int32(1)
 	best_mode = 0
 	VP8MakeLuma16Preds(tls, it)
 	mode = 0
 	for {
 		if !(mode < max_mode) {
 			break
 		}
 		InitHistogram(tls, bp)
 		(*(*func(*libc.TLS, uintptr, uintptr, int32, int32, uintptr))(unsafe.Pointer(&struct{ uintptr }{VP8CollectHistogram})))(tls, (*VP8EncIterator)(unsafe.Pointer(it)).Fyuv_in+uintptr(libc.Int32FromInt32(Y_OFF_ENC)), (*VP8EncIterator)(unsafe.Pointer(it)).Fyuv_p+uintptr(VP8I16ModeOffsets[mode]), 0, int32(16), bp)
 		alpha = GetAlpha(tls, bp)
 		if alpha > best_alpha {
 			best_alpha = alpha
 			best_mode = mode
 		}
 		goto _1
 	_1:
 		;
 		mode = mode + 1
 	}
 	VP8SetIntra16Mode(tls, it, best_mode)
 	return best_alpha
 }
 
 func FastMBAnalyze(tls *libc.TLS, it uintptr) (r int32) {
 	bp := tls.Alloc(80)
 	defer tls.Free(80)
 	var k, q int32
 	var kThreshold, m, m2 uint32_t
 	var _ /* dc at bp+0 */ [16]uint32_t
 	var _ /* modes at bp+64 */ [16]uint8_t
 	_, _, _, _, _ = k, kThreshold, m, m2, q
 	// Empirical cut-off value, should be around 16 (~=block size). We use the
 	// [8-17] range and favor intra4 at high quality, intra16 for low quality.
 	q = int32((*WebPConfig)(unsafe.Pointer((*VP8Encoder)(unsafe.Pointer((*VP8EncIterator)(unsafe.Pointer(it)).Fenc)).Fconfig)).Fquality)
 	kThreshold = libc.Uint32FromInt32(int32(8) + (libc.Int32FromInt32(17)-libc.Int32FromInt32(8))*q/int32(100))
 	k = 0
 	for {
 		if !(k < int32(16)) {
 			break
 		}
 		(*(*func(*libc.TLS, uintptr, uintptr))(unsafe.Pointer(&struct{ uintptr }{VP8Mean16x4})))(tls, (*VP8EncIterator)(unsafe.Pointer(it)).Fyuv_in+uintptr(libc.Int32FromInt32(Y_OFF_ENC))+uintptr(k*int32(BPS)), bp+uintptr(k)*4)
 		goto _1
 	_1:
 		;
 		k = k + int32(4)
 	}
 	m = uint32(0)
 	m2 = uint32(0)
 	k = libc.Int32FromInt32(0)
 	for {
 		if !(k < int32(16)) {
 			break
 		}
 		m = m + (**(**[16]uint32_t)(__ccgo_up(bp)))[k]
 		m2 = m2 + (**(**[16]uint32_t)(__ccgo_up(bp)))[k]*(**(**[16]uint32_t)(__ccgo_up(bp)))[k]
 		goto _2
 	_2:
 		;
 		k = k + 1
 	}
 	if kThreshold*m2 < m*m {
 		VP8SetIntra16Mode(tls, it, 0) // DC16
 	} else {
 		**(**[16]uint8_t)(__ccgo_up(bp + 64)) = [16]uint8_t{} // DC4
 		VP8SetIntra4Mode(tls, it, bp+64)
 	}
 	return 0
 }
 
 func MBAnalyzeBestUVMode(tls *libc.TLS, it uintptr) (r int32) {
 	bp := tls.Alloc(16)
 	defer tls.Free(16)
 	var alpha, best_alpha, best_mode, max_mode, mode, smallest_alpha int32
 	var _ /* histo at bp+0 */ VP8Histogram
 	_, _, _, _, _, _ = alpha, best_alpha, best_mode, max_mode, mode, smallest_alpha
 	best_alpha = -int32(1)
 	smallest_alpha = 0
 	best_mode = 0
 	max_mode = int32(MAX_UV_MODE)
 	VP8MakeChroma8Preds(tls, it)
 	mode = 0
 	for {
 		if !(mode < max_mode) {
 			break
 		}
 		InitHistogram(tls, bp)
 		(*(*func(*libc.TLS, uintptr, uintptr, int32, int32, uintptr))(unsafe.Pointer(&struct{ uintptr }{VP8CollectHistogram})))(tls, (*VP8EncIterator)(unsafe.Pointer(it)).Fyuv_in+uintptr(libc.Int32FromInt32(U_OFF_ENC)), (*VP8EncIterator)(unsafe.Pointer(it)).Fyuv_p+uintptr(VP8UVModeOffsets[mode]), int32(16), libc.Int32FromInt32(16)+libc.Int32FromInt32(4)+libc.Int32FromInt32(4), bp)
 		alpha = GetAlpha(tls, bp)
 		if alpha > best_alpha {
 			best_alpha = alpha
 		}
 		// The best prediction mode tends to be the one with the smallest alpha.
 		if mode == 0 || alpha < smallest_alpha {
 			smallest_alpha = alpha
 			best_mode = mode
 		}
 		goto _1
 	_1:
 		;
 		mode = mode + 1
 	}
 	VP8SetIntraUVMode(tls, it, best_mode)
 	return best_alpha
 }
 
 func MBAnalyze(tls *libc.TLS, it uintptr, alphas uintptr, alpha uintptr, uv_alpha uintptr) {
 	var best_alpha, best_uv_alpha int32
 	var enc uintptr
 	_, _, _ = best_alpha, best_uv_alpha, enc
 	enc = (*VP8EncIterator)(unsafe.Pointer(it)).Fenc
 	VP8SetIntra16Mode(tls, it, 0) // default: Intra16, DC_PRED
 	VP8SetSkip(tls, it, 0)        // not skipped
 	VP8SetSegment(tls, it, 0)     // default segment, spec-wise.
 	if (*VP8Encoder)(unsafe.Pointer(enc)).Fmethod <= int32(1) {
 		best_alpha = FastMBAnalyze(tls, it)
 	} else {
 		best_alpha = MBAnalyzeBestIntra16Mode(tls, it)
 	}
 	best_uv_alpha = MBAnalyzeBestUVMode(tls, it)
 	// Final susceptibility mix
 	best_alpha = (int32(3)*best_alpha + best_uv_alpha + int32(2)) >> int32(2)
 	best_alpha = FinalAlphaValue(tls, best_alpha)
 	**(**int32)(__ccgo_up(alphas + uintptr(best_alpha)*4)) = **(**int32)(__ccgo_up(alphas + uintptr(best_alpha)*4)) + 1
 	(*VP8MBInfo)(unsafe.Pointer((*VP8EncIterator)(unsafe.Pointer(it)).Fmb)).Falpha = libc.Uint8FromInt32(best_alpha) // for later remapping.
 	// Accumulate for later complexity analysis.
 	**(**int32)(__ccgo_up(alpha)) += best_alpha // mixed susceptibility (not just luma)
 	**(**int32)(__ccgo_up(uv_alpha)) += best_uv_alpha
 }
 
 func DefaultMBInfo(tls *libc.TLS, mb uintptr) {
 	libc.SetBitFieldPtr8Uint32(mb+0, libc.Uint32FromInt32(1), 0, 0x3) // I16x16
 	libc.SetBitFieldPtr8Uint32(mb+0, libc.Uint32FromInt32(0), 2, 0xc)
 	libc.SetBitFieldPtr8Uint32(mb+0, libc.Uint32FromInt32(0), 4, 0x10) // not skipped
 	libc.SetBitFieldPtr8Uint32(mb+0, libc.Uint32FromInt32(0), 5, 0x60) // default segment
 	(*VP8MBInfo)(unsafe.Pointer(mb)).Falpha = uint8(0)
 }
 
 //------------------------------------------------------------------------------
 // Main analysis loop:
 // Collect all susceptibilities for each macroblock and record their
 // distribution in alphas[]. Segments is assigned a-posteriori, based on
 // this histogram.
 // We also pick an intra16 prediction mode, which shouldn't be considered
 // final except for fast-encode settings. We can also pick some intra4 modes
 // and decide intra4/intra16, but that's usually almost always a bad choice at
 // this stage.
 
 func ResetAllMBInfo(tls *libc.TLS, enc uintptr) {
 	var n int32
 	_ = n
 	n = 0
 	for {
 		if !(n < (*VP8Encoder)(unsafe.Pointer(enc)).Fmb_w*(*VP8Encoder)(unsafe.Pointer(enc)).Fmb_h) {
 			break
 		}
 		DefaultMBInfo(tls, (*VP8Encoder)(unsafe.Pointer(enc)).Fmb_info+uintptr(n)*4)
 		goto _1
 	_1:
 		;
 		n = n + 1
 	}
 	// Default susceptibilities.
 	(**(**VP8SegmentInfo)(__ccgo_up(enc + 608))).Falpha = 0
 	(**(**VP8SegmentInfo)(__ccgo_up(enc + 608))).Fbeta = 0
 	// Note: we can't compute this 'alpha' / 'uv_alpha' -> set to default value.
 	(*VP8Encoder)(unsafe.Pointer(enc)).Falpha = 0
 	(*VP8Encoder)(unsafe.Pointer(enc)).Fuv_alpha = 0
 	WebPReportProgress(tls, (*VP8Encoder)(unsafe.Pointer(enc)).Fpic, (*VP8Encoder)(unsafe.Pointer(enc)).Fpercent+int32(20), enc+536)
 }
 
 // C documentation
 //
 //	// struct used to collect job result
 type SegmentJob = struct {
 	Fworker         WebPWorker
 	Falphas         [256]int32
 	Falpha          int32
 	Fuv_alpha       int32
 	Fit             VP8EncIterator
 	Fdelta_progress int32
 }
 
 // C documentation
 //
 //	// main work call
 func DoSegmentsJob(tls *libc.TLS, arg1 uintptr, arg2 uintptr) (r int32) {
 	bp := tls.Alloc(64)
 	defer tls.Free(64)
 	var it, job, scratch uintptr
 	var ok int32
 	var _ /* tmp at bp+0 */ [63]uint8_t
 	_, _, _, _ = it, job, ok, scratch
 	job = arg1
 	it = arg2
 	ok = int32(1)
 	if !(VP8IteratorIsDone(tls, it) != 0) {
 		scratch = uintptr((uintptr_t(bp) + libc.Uint64FromInt32(WEBP_ALIGN_CST)) & ^libc.Uint64FromInt32(WEBP_ALIGN_CST))
 		for cond := true; cond; cond = ok != 0 && VP8IteratorNext(tls, it) != 0 {
 			// Let's pretend we have perfect lossless reconstruction.
 			VP8IteratorImport(tls, it, scratch)
 			MBAnalyze(tls, it, job+48, job+1072, job+1076)
 			ok = VP8IteratorProgress(tls, it, (*SegmentJob)(unsafe.Pointer(job)).Fdelta_progress)
 		}
 	}
 	return ok
 }
 
 // C documentation
 //
 //	// initialize the job struct with some tasks to perform
 func InitSegmentJob(tls *libc.TLS, enc uintptr, job uintptr, start_row int32, end_row int32) {
 	var v1 int32
 	_ = v1
 	(*(*func(*libc.TLS, uintptr))(unsafe.Pointer(&struct{ uintptr }{(*WebPWorkerInterface)(unsafe.Pointer(WebPGetWorkerInterface(tls))).FInit})))(tls, job)
 	(*SegmentJob)(unsafe.Pointer(job)).Fworker.Fdata1 = job
 	(*SegmentJob)(unsafe.Pointer(job)).Fworker.Fdata2 = job + 1080
 	(*SegmentJob)(unsafe.Pointer(job)).Fworker.Fhook = __ccgo_fp(DoSegmentsJob)
 	VP8IteratorInit(tls, enc, job+1080)
 	VP8IteratorSetRow(tls, job+1080, start_row)
 	VP8IteratorSetCountDown(tls, job+1080, (end_row-start_row)*(*VP8Encoder)(unsafe.Pointer(enc)).Fmb_w)
 	libc.X__builtin___memset_chk(tls, job+48, 0, uint64(1024), ^__predefined_size_t(0))
 	(*SegmentJob)(unsafe.Pointer(job)).Falpha = 0
 	(*SegmentJob)(unsafe.Pointer(job)).Fuv_alpha = 0
 	// only one of both jobs can record the progress, since we don't
 	// expect the user's hook to be multi-thread safe
 	if start_row == 0 {
 		v1 = int32(20)
 	} else {
 		v1 = 0
 	}
 	(*SegmentJob)(unsafe.Pointer(job)).Fdelta_progress = v1
 }
 
 // C documentation
 //
 //	// main entry point
 func VP8EncAnalyze(tls *libc.TLS, enc uintptr) (r int32) {
 	bp := tls.Alloc(4944)
 	defer tls.Free(4944)
 	var do_mt, do_segments, last_row, ok, total_mb int32
 	var worker_interface uintptr
 	var _ /* main_job at bp+0 */ SegmentJob
 	_, _, _, _, _, _ = do_mt, do_segments, last_row, ok, total_mb, worker_interface
 	ok = int32(1)
 	do_segments = libc.BoolInt32((*WebPConfig)(unsafe.Pointer((*VP8Encoder)(unsafe.Pointer(enc)).Fconfig)).Femulate_jpeg_size != 0 || (*VP8Encoder)(unsafe.Pointer(enc)).Fsegment_hdr.Fnum_segments > int32(1) || (*VP8Encoder)(unsafe.Pointer(enc)).Fmethod <= int32(1)) // for method 0 - 1, we need preds[] to be filled.
 	if do_segments != 0 {
 		last_row = (*VP8Encoder)(unsafe.Pointer(enc)).Fmb_h
 		total_mb = last_row * (*VP8Encoder)(unsafe.Pointer(enc)).Fmb_w
 		do_mt = 0
 		worker_interface = WebPGetWorkerInterface(tls)
 		if do_mt != 0 {
 		} else {
 			// Even for single-thread case, we use the generic Worker tools.
 			InitSegmentJob(tls, enc, bp, 0, last_row)
 			(*(*func(*libc.TLS, uintptr))(unsafe.Pointer(&struct{ uintptr }{(*WebPWorkerInterface)(unsafe.Pointer(worker_interface)).FExecute})))(tls, bp)
 			ok = ok & (*(*func(*libc.TLS, uintptr) int32)(unsafe.Pointer(&struct{ uintptr }{(*WebPWorkerInterface)(unsafe.Pointer(worker_interface)).FSync})))(tls, bp)
 		}
 		(*(*func(*libc.TLS, uintptr))(unsafe.Pointer(&struct{ uintptr }{(*WebPWorkerInterface)(unsafe.Pointer(worker_interface)).FEnd})))(tls, bp)
 		if ok != 0 {
 			(*VP8Encoder)(unsafe.Pointer(enc)).Falpha = (**(**SegmentJob)(__ccgo_up(bp))).Falpha / total_mb
 			(*VP8Encoder)(unsafe.Pointer(enc)).Fuv_alpha = (**(**SegmentJob)(__ccgo_up(bp))).Fuv_alpha / total_mb
 			AssignSegments(tls, enc, bp+48)
 		}
 	} else { // Use only one default segment.
 		ResetAllMBInfo(tls, enc)
 	}
 	if !(ok != 0) {
 		return WebPEncodingSetError(tls, (*VP8Encoder)(unsafe.Pointer(enc)).Fpic, int32(VP8_ENC_ERROR_OUT_OF_MEMORY)) // imprecise
 	}
 	return ok
 }
 
 const COST_CACHE_INTERVAL_SIZE_MAX = 500
 const COST_MANAGER_MAX_FREE_LIST = 10
 const VALUES_IN_BYTE = 256
 
 var kHashMul10 = uint32(0x1e35a7bd)
 
 type CostModel = struct {
 	Falpha    [256]uint32_t
 	Fred      [256]uint32_t
 	Fblue     [256]uint32_t
 	Fdistance [40]uint32_t
 	Fliteral  uintptr
 }
 
 func ConvertPopulationCountTableToBitEstimates(tls *libc.TLS, num_symbols int32, population_counts uintptr, output uintptr) {
 	var i, nonzeros int32
 	var logsum, sum, v2, v3, v7, v8 uint32_t
 	var v10, v5 uint32
 	_, _, _, _, _, _, _, _, _, _ = i, logsum, nonzeros, sum, v10, v2, v3, v5, v7, v8
 	sum = uint32(0)
 	nonzeros = 0
 	i = 0
 	for {
 		if !(i < num_symbols) {
 			break
 		}
 		sum = sum + **(**uint32_t)(__ccgo_up(population_counts + uintptr(i)*4))
 		if **(**uint32_t)(__ccgo_up(population_counts + uintptr(i)*4)) > uint32(0) {
 			nonzeros = nonzeros + 1
 		}
 		goto _1
 	_1:
 		;
 		i = i + 1
 	}
 	if nonzeros <= int32(1) {
 		libc.X__builtin___memset_chk(tls, output, 0, libc.Uint64FromInt32(num_symbols)*uint64(4), ^__predefined_size_t(0))
 	} else {
 		v2 = sum
 		if v2 < uint32(LOG_LOOKUP_IDX_MAX) {
 			v5 = kLog2Table[v2]
 		} else {
 			v5 = (*(*func(*libc.TLS, uint32_t) uint32_t)(unsafe.Pointer(&struct{ uintptr }{VP8LFastLog2Slow})))(tls, v2)
 		}
 		v3 = v5
 		goto _4
 	_4:
 		logsum = v3
 		i = 0
 		for {
 			if !(i < num_symbols) {
 				break
 			}
 			v7 = **(**uint32_t)(__ccgo_up(population_counts + uintptr(i)*4))
 			if v7 < uint32(LOG_LOOKUP_IDX_MAX) {
 				v10 = kLog2Table[v7]
 			} else {
 				v10 = (*(*func(*libc.TLS, uint32_t) uint32_t)(unsafe.Pointer(&struct{ uintptr }{VP8LFastLog2Slow})))(tls, v7)
 			}
 			v8 = v10
 			goto _9
 		_9:
 			**(**uint32_t)(__ccgo_up(output + uintptr(i)*4)) = logsum - v8
 			goto _6
 		_6:
 			;
 			i = i + 1
 		}
 	}
 }
 
 func CostModelBuild(tls *libc.TLS, m uintptr, xsize int32, cache_bits int32, refs uintptr) (r int32) {
 	var histo uintptr
 	var ok, v1, v2, v4 int32
 	_, _, _, _, _ = histo, ok, v1, v2, v4
 	ok = 0
 	histo = VP8LAllocateHistogram(tls, cache_bits)
 	if histo == libc.UintptrFromInt32(0) {
 		goto Error
 	}
 	// The following code is similar to VP8LHistogramCreate but converts the
 	// distance to plane code.
 	VP8LHistogramInit(tls, histo, cache_bits, int32(1))
 	VP8LHistogramStoreRefs(tls, refs, __ccgo_fp(VP8LDistanceToPlaneCode), xsize, histo)
 	v1 = (*VP8LHistogram)(unsafe.Pointer(histo)).Fpalette_code_bits
 	if v1 > 0 {
 		v4 = int32(1) << v1
 	} else {
 		v4 = 0
 	}
 	v2 = libc.Int32FromInt32(NUM_LITERAL_CODES) + libc.Int32FromInt32(NUM_LENGTH_CODES) + v4
 	goto _3
 _3:
 	ConvertPopulationCountTableToBitEstimates(tls, v2, (*VP8LHistogram)(unsafe.Pointer(histo)).Fliteral, (*CostModel)(unsafe.Pointer(m)).Fliteral)
 	ConvertPopulationCountTableToBitEstimates(tls, int32(VALUES_IN_BYTE), histo+8, m+1024)
 	ConvertPopulationCountTableToBitEstimates(tls, int32(VALUES_IN_BYTE), histo+1032, m+2048)
 	ConvertPopulationCountTableToBitEstimates(tls, int32(VALUES_IN_BYTE), histo+2056, m)
 	ConvertPopulationCountTableToBitEstimates(tls, int32(NUM_DISTANCE_CODES), histo+3080, m+3072)
 	ok = int32(1)
 	goto Error
 Error:
 	;
 	VP8LFreeHistogram(tls, histo)
 	return ok
 }
 
 func GetLiteralCost(tls *libc.TLS, m uintptr, v uint32_t) (r int64_t) {
 	return libc.Int64FromUint32(**(**uint32_t)(__ccgo_up(m + uintptr(v>>int32(24))*4))) + libc.Int64FromUint32(**(**uint32_t)(__ccgo_up(m + 1024 + uintptr(v>>libc.Int32FromInt32(16)&uint32(0xff))*4))) + libc.Int64FromUint32(**(**uint32_t)(__ccgo_up((*CostModel)(unsafe.Pointer(m)).Fliteral + uintptr(v>>libc.Int32FromInt32(8)&uint32(0xff))*4))) + libc.Int64FromUint32(**(**uint32_t)(__ccgo_up(m + 2048 + uintptr(v&uint32(0xff))*4)))
 }
 
 func GetCacheCost(tls *libc.TLS, m uintptr, idx uint32_t) (r int64_t) {
 	var literal_idx int32
 	_ = literal_idx
 	literal_idx = libc.Int32FromUint32(libc.Uint32FromInt32(libc.Int32FromInt32(VALUES_IN_BYTE)+libc.Int32FromInt32(NUM_LENGTH_CODES)) + idx)
 	return libc.Int64FromUint32(**(**uint32_t)(__ccgo_up((*CostModel)(unsafe.Pointer(m)).Fliteral + uintptr(literal_idx)*4)))
 }
 
 func GetLengthCost(tls *libc.TLS, m uintptr, length uint32_t) (r int64_t) {
 	bp := tls.Alloc(16)
 	defer tls.Free(16)
 	var highest_bit, second_highest_bit, v1, v4, v5, v6 int32
 	var prefix_code VP8LPrefixCode
 	var v2, v3 uintptr
 	var _ /* code at bp+0 */ int32
 	var _ /* extra_bits at bp+4 */ int32
 	_, _, _, _, _, _, _, _, _ = highest_bit, prefix_code, second_highest_bit, v1, v2, v3, v4, v5, v6
 	v1 = libc.Int32FromUint32(length)
 	v2 = bp
 	v3 = bp + 4
 	if v1 < libc.Int32FromInt32(PREFIX_LOOKUP_IDX_MAX) {
 		prefix_code = kPrefixEncodeCode[v1]
 		**(**int32)(__ccgo_up(v2)) = int32(prefix_code.Fcode)
 		**(**int32)(__ccgo_up(v3)) = int32(prefix_code.Fextra_bits)
 	} else {
 		v4 = v1
 		v4 = v4 - 1
 		v5 = v4
 		v6 = int32(31) ^ libc.X__builtin_clz(tls, libc.Uint32FromInt32(v5))
 		goto _7
 	_7:
 		highest_bit = v6
 		second_highest_bit = v4 >> (highest_bit - int32(1)) & int32(1)
 		**(**int32)(__ccgo_up(v3)) = highest_bit - int32(1)
 		**(**int32)(__ccgo_up(v2)) = int32(2)*highest_bit + second_highest_bit
 	}
 	return libc.Int64FromUint32(**(**uint32_t)(__ccgo_up((*CostModel)(unsafe.Pointer(m)).Fliteral + uintptr(int32(VALUES_IN_BYTE)+**(**int32)(__ccgo_up(bp)))*4))) + int64(**(**int32)(__ccgo_up(bp + 4)))<<libc.Int32FromInt32(LOG_2_PRECISION_BITS)
 }
 
 func GetDistanceCost(tls *libc.TLS, m uintptr, distance2 uint32_t) (r int64_t) {
 	bp := tls.Alloc(16)
 	defer tls.Free(16)
 	var highest_bit, second_highest_bit, v1, v4, v5, v6 int32
 	var prefix_code VP8LPrefixCode
 	var v2, v3 uintptr
 	var _ /* code at bp+0 */ int32
 	var _ /* extra_bits at bp+4 */ int32
 	_, _, _, _, _, _, _, _, _ = highest_bit, prefix_code, second_highest_bit, v1, v2, v3, v4, v5, v6
 	v1 = libc.Int32FromUint32(distance2)
 	v2 = bp
 	v3 = bp + 4
 	if v1 < libc.Int32FromInt32(PREFIX_LOOKUP_IDX_MAX) {
 		prefix_code = kPrefixEncodeCode[v1]
 		**(**int32)(__ccgo_up(v2)) = int32(prefix_code.Fcode)
 		**(**int32)(__ccgo_up(v3)) = int32(prefix_code.Fextra_bits)
 	} else {
 		v4 = v1
 		v4 = v4 - 1
 		v5 = v4
 		v6 = int32(31) ^ libc.X__builtin_clz(tls, libc.Uint32FromInt32(v5))
 		goto _7
 	_7:
 		highest_bit = v6
 		second_highest_bit = v4 >> (highest_bit - int32(1)) & int32(1)
 		**(**int32)(__ccgo_up(v3)) = highest_bit - int32(1)
 		**(**int32)(__ccgo_up(v2)) = int32(2)*highest_bit + second_highest_bit
 	}
 	return libc.Int64FromUint32(**(**uint32_t)(__ccgo_up(m + 3072 + uintptr(**(**int32)(__ccgo_up(bp)))*4))) + int64(**(**int32)(__ccgo_up(bp + 4)))<<libc.Int32FromInt32(LOG_2_PRECISION_BITS)
 }
 
 func AddSingleLiteralWithCostModel(tls *libc.TLS, argb3 uintptr, hashers uintptr, cost_model uintptr, idx int32, use_color_cache int32, prev_cost int64_t, cost uintptr, dist_array uintptr) {
 	var color, v3 uint32_t
 	var cost_val, v10, v11, v9 int64_t
 	var ix, key, key1, v1, v4, v6, v8 int32
 	var v13 int64
 	var v2 uintptr
 	_, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = color, cost_val, ix, key, key1, v1, v10, v11, v13, v2, v3, v4, v6, v8, v9
 	cost_val = prev_cost
 	color = **(**uint32_t)(__ccgo_up(argb3 + uintptr(idx)*4))
 	if use_color_cache != 0 {
 		v2 = hashers
 		v3 = color
 		v4 = libc.Int32FromUint32(v3 * kHashMul10 >> (*VP8LColorCache)(unsafe.Pointer(v2)).Fhash_shift)
 		goto _5
 	_5:
 		key1 = v4
 		if **(**uint32_t)(__ccgo_up((*VP8LColorCache)(unsafe.Pointer(v2)).Fcolors + uintptr(key1)*4)) == v3 {
 			v8 = key1
 		} else {
 			v8 = -int32(1)
 		}
 		v6 = v8
 		goto _7
 	_7:
 		v1 = v6
 	} else {
 		v1 = -int32(1)
 	}
 	ix = v1
 	if ix >= 0 {
 		// use_color_cache is true and hashers contains color
 		v9 = GetCacheCost(tls, cost_model, libc.Uint32FromInt32(ix)) * int64(68)
 		v10 = int64(100)
 		if libc.BoolInt32(v9 < 0) == libc.BoolInt32(v10 < 0) {
 			v13 = (v9 + v10/int64(2)) / v10
 		} else {
 			v13 = (v9 - v10/int64(2)) / v10
 		}
 		v11 = v13
 		goto _12
 	_12:
 		cost_val = cost_val + v11
 	} else {
 		if use_color_cache != 0 {
 			v2 = hashers
 			v3 = color
 			v1 = libc.Int32FromUint32(v3 * kHashMul10 >> (*VP8LColorCache)(unsafe.Pointer(v2)).Fhash_shift)
 			goto _17
 		_17:
 			key = v1
 			**(**uint32_t)(__ccgo_up((*VP8LColorCache)(unsafe.Pointer(v2)).Fcolors + uintptr(key)*4)) = v3
 		}
 		v9 = GetLiteralCost(tls, cost_model, color) * int64(82)
 		v10 = int64(100)
 		if libc.BoolInt32(v9 < 0) == libc.BoolInt32(v10 < 0) {
 			v13 = (v9 + v10/int64(2)) / v10
 		} else {
 			v13 = (v9 - v10/int64(2)) / v10
 		}
 		v11 = v13
 		goto _21
 	_21:
 		cost_val = cost_val + v11
 	}
 	if **(**int64_t)(__ccgo_up(cost + uintptr(idx)*8)) > cost_val {
 		**(**int64_t)(__ccgo_up(cost + uintptr(idx)*8)) = cost_val
 		**(**uint16_t)(__ccgo_up(dist_array + uintptr(idx)*2)) = uint16(1) // only one is inserted.
 	}
 }
 
 // -----------------------------------------------------------------------------
 // CostManager and interval handling
 
 // Empirical value to avoid high memory consumption but good for performance.
 
 // C documentation
 //
 //	// To perform backward reference every pixel at index 'index' is considered and
 //	// the cost for the MAX_LENGTH following pixels computed. Those following pixels
 //	// at index 'index' + k (k from 0 to MAX_LENGTH) have a cost of:
 //	//     cost = distance cost at index + GetLengthCost(cost_model, k)
 //	// and the minimum value is kept. GetLengthCost(cost_model, k) is cached in an
 //	// array of size MAX_LENGTH.
 //	// Instead of performing MAX_LENGTH comparisons per pixel, we keep track of the
 //	// minimal values using intervals of constant cost.
 //	// An interval is defined by the 'index' of the pixel that generated it and
 //	// is only useful in a range of indices from 'start' to 'end' (exclusive), i.e.
 //	// it contains the minimum value for pixels between start and end.
 //	// Intervals are stored in a linked list and ordered by 'start'. When a new
 //	// interval has a better value, old intervals are split or removed. There are
 //	// therefore no overlapping intervals.
 type CostInterval = struct {
 	Fcost     int64_t
 	Fstart    int32
 	Fend      int32
 	Findex    int32
 	Fprevious uintptr
 	Fnext     uintptr
 }
 
 // C documentation
 //
 //	// The GetLengthCost(cost_model, k) are cached in a CostCacheInterval.
 type CostCacheInterval = struct {
 	Fcost  int64_t
 	Fstart int32
 	Fend   int32
 }
 
 // C documentation
 //
 //	// This structure is in charge of managing intervals and costs.
 //	// It caches the different CostCacheInterval, caches the different
 //	// GetLengthCost(cost_model, k) in cost_cache and the CostInterval's (whose
 //	// 'count' is limited by COST_CACHE_INTERVAL_SIZE_MAX).
 type CostManager = struct {
 	Fhead                 uintptr
 	Fcount                int32
 	Fcache_intervals      uintptr
 	Fcache_intervals_size size_t
 	Fcost_cache           [4095]int64_t
 	Fcosts                uintptr
 	Fdist_array           uintptr
 	Fintervals            [10]CostInterval
 	Ffree_intervals       uintptr
 	Frecycled_intervals   uintptr
 }
 
 func CostIntervalAddToFreeList(tls *libc.TLS, manager uintptr, interval uintptr) {
 	(*CostInterval)(unsafe.Pointer(interval)).Fnext = (*CostManager)(unsafe.Pointer(manager)).Ffree_intervals
 	(*CostManager)(unsafe.Pointer(manager)).Ffree_intervals = interval
 }
 
 func CostIntervalIsInFreeList(tls *libc.TLS, manager uintptr, interval uintptr) (r int32) {
 	return libc.BoolInt32(interval >= manager+32808 && interval <= manager+32808+uintptr(libc.Int32FromInt32(COST_MANAGER_MAX_FREE_LIST)-libc.Int32FromInt32(1))*40)
 }
 
 func CostManagerInitFreeList(tls *libc.TLS, manager uintptr) {
 	var i int32
 	_ = i
 	(*CostManager)(unsafe.Pointer(manager)).Ffree_intervals = libc.UintptrFromInt32(0)
 	i = 0
 	for {
 		if !(i < int32(COST_MANAGER_MAX_FREE_LIST)) {
 			break
 		}
 		CostIntervalAddToFreeList(tls, manager, manager+32808+uintptr(i)*40)
 		goto _1
 	_1:
 		;
 		i = i + 1
 	}
 }
 
 func DeleteIntervalList(tls *libc.TLS, manager uintptr, interval uintptr) {
 	var next uintptr
 	_ = next
 	for interval != libc.UintptrFromInt32(0) {
 		next = (*CostInterval)(unsafe.Pointer(interval)).Fnext
 		if !(CostIntervalIsInFreeList(tls, manager, interval) != 0) {
 			WebPSafeFree(tls, interval)
 		} // else: do nothing
 		interval = next
 	}
 }
 
 func CostManagerClear(tls *libc.TLS, manager uintptr) {
 	if manager == libc.UintptrFromInt32(0) {
 		return
 	}
 	WebPSafeFree(tls, (*CostManager)(unsafe.Pointer(manager)).Fcosts)
 	WebPSafeFree(tls, (*CostManager)(unsafe.Pointer(manager)).Fcache_intervals)
 	// Clear the interval lists.
 	DeleteIntervalList(tls, manager, (*CostManager)(unsafe.Pointer(manager)).Fhead)
 	(*CostManager)(unsafe.Pointer(manager)).Fhead = libc.UintptrFromInt32(0)
 	DeleteIntervalList(tls, manager, (*CostManager)(unsafe.Pointer(manager)).Frecycled_intervals)
 	(*CostManager)(unsafe.Pointer(manager)).Frecycled_intervals = libc.UintptrFromInt32(0)
 	// Reset pointers, 'count' and 'cache_intervals_size'.
 	libc.X__builtin___memset_chk(tls, manager, 0, uint64(33224), ^__predefined_size_t(0))
 	CostManagerInitFreeList(tls, manager)
 }
 
 func CostManagerInit(tls *libc.TLS, manager uintptr, dist_array uintptr, pix_count int32, cost_model uintptr) (r int32) {
 	var cost_cache_size, i, v1 int32
 	var cost_val int64_t
 	var cur uintptr
 	_, _, _, _, _ = cost_cache_size, cost_val, cur, i, v1
 	if pix_count > libc.Int32FromInt32(1)<<libc.Int32FromInt32(MAX_LENGTH_BITS)-libc.Int32FromInt32(1) {
 		v1 = libc.Int32FromInt32(1)<<libc.Int32FromInt32(MAX_LENGTH_BITS) - libc.Int32FromInt32(1)
 	} else {
 		v1 = pix_count
 	}
 	cost_cache_size = v1
 	(*CostManager)(unsafe.Pointer(manager)).Fcosts = libc.UintptrFromInt32(0)
 	(*CostManager)(unsafe.Pointer(manager)).Fcache_intervals = libc.UintptrFromInt32(0)
 	(*CostManager)(unsafe.Pointer(manager)).Fhead = libc.UintptrFromInt32(0)
 	(*CostManager)(unsafe.Pointer(manager)).Frecycled_intervals = libc.UintptrFromInt32(0)
 	(*CostManager)(unsafe.Pointer(manager)).Fcount = 0
 	(*CostManager)(unsafe.Pointer(manager)).Fdist_array = dist_array
 	CostManagerInitFreeList(tls, manager)
 	// Fill in the 'cost_cache'.
 	// Has to be done in two passes due to a GCC bug on i686
 	// related to https://gcc.gnu.org/bugzilla/show_bug.cgi?id=323
 	i = 0
 	for {
 		if !(i < cost_cache_size) {
 			break
 		}
 		**(**int64_t)(__ccgo_up(manager + 32 + uintptr(i)*8)) = GetLengthCost(tls, cost_model, libc.Uint32FromInt32(i))
 		goto _2
 	_2:
 		;
 		i = i + 1
 	}
 	(*CostManager)(unsafe.Pointer(manager)).Fcache_intervals_size = uint64(1)
 	i = int32(1)
 	for {
 		if !(i < cost_cache_size) {
 			break
 		}
 		// Get the number of bound intervals.
 		if **(**int64_t)(__ccgo_up(manager + 32 + uintptr(i)*8)) != **(**int64_t)(__ccgo_up(manager + 32 + uintptr(i-int32(1))*8)) {
 			(*CostManager)(unsafe.Pointer(manager)).Fcache_intervals_size = (*CostManager)(unsafe.Pointer(manager)).Fcache_intervals_size + 1
 		}
 		goto _3
 	_3:
 		;
 		i = i + 1
 	}
 	// With the current cost model, we usually have below 20 intervals.
 	// The worst case scenario with a cost model would be if every length has a
 	// different cost, hence MAX_LENGTH but that is impossible with the current
 	// implementation that spirals around a pixel.
 	(*CostManager)(unsafe.Pointer(manager)).Fcache_intervals = WebPSafeMalloc(tls, (*CostManager)(unsafe.Pointer(manager)).Fcache_intervals_size, uint64(16))
 	if (*CostManager)(unsafe.Pointer(manager)).Fcache_intervals == libc.UintptrFromInt32(0) {
 		CostManagerClear(tls, manager)
 		return 0
 	}
 	// Fill in the 'cache_intervals'.
 	cur = (*CostManager)(unsafe.Pointer(manager)).Fcache_intervals
 	// Consecutive values in 'cost_cache' are compared and if a big enough
 	// difference is found, a new interval is created and bounded.
 	(*CostCacheInterval)(unsafe.Pointer(cur)).Fstart = 0
 	(*CostCacheInterval)(unsafe.Pointer(cur)).Fend = int32(1)
 	(*CostCacheInterval)(unsafe.Pointer(cur)).Fcost = **(**int64_t)(__ccgo_up(manager + 32))
 	i = int32(1)
 	for {
 		if !(i < cost_cache_size) {
 			break
 		}
 		cost_val = **(**int64_t)(__ccgo_up(manager + 32 + uintptr(i)*8))
 		if cost_val != (*CostCacheInterval)(unsafe.Pointer(cur)).Fcost {
 			cur += 16
 			// Initialize an interval.
 			(*CostCacheInterval)(unsafe.Pointer(cur)).Fstart = i
 			(*CostCacheInterval)(unsafe.Pointer(cur)).Fcost = cost_val
 		}
 		(*CostCacheInterval)(unsafe.Pointer(cur)).Fend = i + int32(1)
 		goto _4
 	_4:
 		;
 		i = i + 1
 	}
 	(*CostManager)(unsafe.Pointer(manager)).Fcosts = WebPSafeMalloc(tls, libc.Uint64FromInt32(pix_count), uint64(8))
 	if (*CostManager)(unsafe.Pointer(manager)).Fcosts == libc.UintptrFromInt32(0) {
 		CostManagerClear(tls, manager)
 		return 0
 	}
 	// Set the initial 'costs' to INT64_MAX for every pixel as we will keep the
 	// minimum.
 	i = 0
 	for {
 		if !(i < pix_count) {
 			break
 		}
 		**(**int64_t)(__ccgo_up((*CostManager)(unsafe.Pointer(manager)).Fcosts + uintptr(i)*8)) = libc.Int64FromUint64(libc.Uint64FromUint64(1)<<libc.Int32FromInt32(63) - libc.Uint64FromInt32(1))
 		goto _5
 	_5:
 		;
 		i = i + 1
 	}
 	return int32(1)
 }
 
 // C documentation
 //
 //	// Given the cost and the position that define an interval, update the cost at
 //	// pixel 'i' if it is smaller than the previously computed value.
 func UpdateCost(tls *libc.TLS, manager uintptr, i int32, position int32, cost int64_t) {
 	var k int32
 	_ = k
 	k = i - position
 	if **(**int64_t)(__ccgo_up((*CostManager)(unsafe.Pointer(manager)).Fcosts + uintptr(i)*8)) > cost {
 		**(**int64_t)(__ccgo_up((*CostManager)(unsafe.Pointer(manager)).Fcosts + uintptr(i)*8)) = cost
 		**(**uint16_t)(__ccgo_up((*CostManager)(unsafe.Pointer(manager)).Fdist_array + uintptr(i)*2)) = libc.Uint16FromInt32(k + int32(1))
 	}
 }
 
 // C documentation
 //
 //	// Given the cost and the position that define an interval, update the cost for
 //	// all the pixels between 'start' and 'end' excluded.
 func UpdateCostPerInterval(tls *libc.TLS, manager uintptr, start int32, end int32, position int32, cost int64_t) {
 	var i int32
 	_ = i
 	i = start
 	for {
 		if !(i < end) {
 			break
 		}
 		UpdateCost(tls, manager, i, position, cost)
 		goto _1
 	_1:
 		;
 		i = i + 1
 	}
 }
 
 // C documentation
 //
 //	// Given two intervals, make 'prev' be the previous one of 'next' in 'manager'.
 func ConnectIntervals(tls *libc.TLS, manager uintptr, prev uintptr, next uintptr) {
 	if prev != libc.UintptrFromInt32(0) {
 		(*CostInterval)(unsafe.Pointer(prev)).Fnext = next
 	} else {
 		(*CostManager)(unsafe.Pointer(manager)).Fhead = next
 	}
 	if next != libc.UintptrFromInt32(0) {
 		(*CostInterval)(unsafe.Pointer(next)).Fprevious = prev
 	}
 }
 
 // C documentation
 //
 //	// Pop an interval in the manager.
 func PopInterval(tls *libc.TLS, manager uintptr, interval uintptr) {
 	if interval == libc.UintptrFromInt32(0) {
 		return
 	}
 	ConnectIntervals(tls, manager, (*CostInterval)(unsafe.Pointer(interval)).Fprevious, (*CostInterval)(unsafe.Pointer(interval)).Fnext)
 	if CostIntervalIsInFreeList(tls, manager, interval) != 0 {
 		CostIntervalAddToFreeList(tls, manager, interval)
 	} else { // recycle regularly malloc'd intervals too
 		(*CostInterval)(unsafe.Pointer(interval)).Fnext = (*CostManager)(unsafe.Pointer(manager)).Frecycled_intervals
 		(*CostManager)(unsafe.Pointer(manager)).Frecycled_intervals = interval
 	}
 	(*CostManager)(unsafe.Pointer(manager)).Fcount = (*CostManager)(unsafe.Pointer(manager)).Fcount - 1
 }
 
 // C documentation
 //
 //	// Update the cost at index i by going over all the stored intervals that
 //	// overlap with i.
 //	// If 'do_clean_intervals' is set to something different than 0, intervals that
 //	// end before 'i' will be popped.
 func UpdateCostAtIndex(tls *libc.TLS, manager uintptr, i int32, do_clean_intervals int32) {
 	var current, next uintptr
 	_, _ = current, next
 	current = (*CostManager)(unsafe.Pointer(manager)).Fhead
 	for current != libc.UintptrFromInt32(0) && (*CostInterval)(unsafe.Pointer(current)).Fstart <= i {
 		next = (*CostInterval)(unsafe.Pointer(current)).Fnext
 		if (*CostInterval)(unsafe.Pointer(current)).Fend <= i {
 			if do_clean_intervals != 0 {
 				// We have an outdated interval, remove it.
 				PopInterval(tls, manager, current)
 			}
 		} else {
 			UpdateCost(tls, manager, i, (*CostInterval)(unsafe.Pointer(current)).Findex, (*CostInterval)(unsafe.Pointer(current)).Fcost)
 		}
 		current = next
 	}
 }
 
 // C documentation
 //
 //	// Given a current orphan interval and its previous interval, before
 //	// it was orphaned (which can be NULL), set it at the right place in the list
 //	// of intervals using the 'start' ordering and the previous interval as a hint.
 func PositionOrphanInterval(tls *libc.TLS, manager uintptr, current uintptr, previous uintptr) {
 	if previous == libc.UintptrFromInt32(0) {
 		previous = (*CostManager)(unsafe.Pointer(manager)).Fhead
 	}
 	for previous != libc.UintptrFromInt32(0) && (*CostInterval)(unsafe.Pointer(current)).Fstart < (*CostInterval)(unsafe.Pointer(previous)).Fstart {
 		previous = (*CostInterval)(unsafe.Pointer(previous)).Fprevious
 	}
 	for previous != libc.UintptrFromInt32(0) && (*CostInterval)(unsafe.Pointer(previous)).Fnext != libc.UintptrFromInt32(0) && (*CostInterval)(unsafe.Pointer((*CostInterval)(unsafe.Pointer(previous)).Fnext)).Fstart < (*CostInterval)(unsafe.Pointer(current)).Fstart {
 		previous = (*CostInterval)(unsafe.Pointer(previous)).Fnext
 	}
 	if previous != libc.UintptrFromInt32(0) {
 		ConnectIntervals(tls, manager, current, (*CostInterval)(unsafe.Pointer(previous)).Fnext)
 	} else {
 		ConnectIntervals(tls, manager, current, (*CostManager)(unsafe.Pointer(manager)).Fhead)
 	}
 	ConnectIntervals(tls, manager, previous, current)
 }
 
 // C documentation
 //
 //	// Insert an interval in the list contained in the manager by starting at
 //	// 'interval_in' as a hint. The intervals are sorted by 'start' value.
 func InsertInterval(tls *libc.TLS, manager uintptr, interval_in uintptr, cost int64_t, position int32, start int32, end int32) {
 	var interval_new uintptr
 	_ = interval_new
 	if start >= end {
 		return
 	}
 	if (*CostManager)(unsafe.Pointer(manager)).Fcount >= int32(COST_CACHE_INTERVAL_SIZE_MAX) {
 		// Serialize the interval if we cannot store it.
 		UpdateCostPerInterval(tls, manager, start, end, position, cost)
 		return
 	}
 	if (*CostManager)(unsafe.Pointer(manager)).Ffree_intervals != libc.UintptrFromInt32(0) {
 		interval_new = (*CostManager)(unsafe.Pointer(manager)).Ffree_intervals
 		(*CostManager)(unsafe.Pointer(manager)).Ffree_intervals = (*CostInterval)(unsafe.Pointer(interval_new)).Fnext
 	} else {
 		if (*CostManager)(unsafe.Pointer(manager)).Frecycled_intervals != libc.UintptrFromInt32(0) {
 			interval_new = (*CostManager)(unsafe.Pointer(manager)).Frecycled_intervals
 			(*CostManager)(unsafe.Pointer(manager)).Frecycled_intervals = (*CostInterval)(unsafe.Pointer(interval_new)).Fnext
 		} else { // malloc for good
 			interval_new = WebPSafeMalloc(tls, uint64(1), uint64(40))
 			if interval_new == libc.UintptrFromInt32(0) {
 				// Write down the interval if we cannot create it.
 				UpdateCostPerInterval(tls, manager, start, end, position, cost)
 				return
 			}
 		}
 	}
 	(*CostInterval)(unsafe.Pointer(interval_new)).Fcost = cost
 	(*CostInterval)(unsafe.Pointer(interval_new)).Findex = position
 	(*CostInterval)(unsafe.Pointer(interval_new)).Fstart = start
 	(*CostInterval)(unsafe.Pointer(interval_new)).Fend = end
 	PositionOrphanInterval(tls, manager, interval_new, interval_in)
 	(*CostManager)(unsafe.Pointer(manager)).Fcount = (*CostManager)(unsafe.Pointer(manager)).Fcount + 1
 }
 
 // C documentation
 //
 //	// Given a new cost interval defined by its start at position, its length value
 //	// and distance_cost, add its contributions to the previous intervals and costs.
 //	// If handling the interval or one of its subintervals becomes to heavy, its
 //	// contribution is added to the costs right away.
 func PushInterval(tls *libc.TLS, manager uintptr, distance_cost int64_t, position int32, len1 int32) {
 	var cost, cost_tmp int64_t
 	var cost_cache_intervals, interval, interval_next uintptr
 	var end, end_original, j, k, kSkipDistance, start, start_new, v3 int32
 	var i size_t
 	_, _, _, _, _, _, _, _, _, _, _, _, _, _ = cost, cost_cache_intervals, cost_tmp, end, end_original, i, interval, interval_next, j, k, kSkipDistance, start, start_new, v3
 	interval = (*CostManager)(unsafe.Pointer(manager)).Fhead
 	cost_cache_intervals = (*CostManager)(unsafe.Pointer(manager)).Fcache_intervals
 	// If the interval is small enough, no need to deal with the heavy
 	// interval logic, just serialize it right away. This constant is empirical.
 	kSkipDistance = int32(10)
 	if len1 < kSkipDistance {
 		j = position
 		for {
 			if !(j < position+len1) {
 				break
 			}
 			k = j - position
 			cost_tmp = distance_cost + **(**int64_t)(__ccgo_up(manager + 32 + uintptr(k)*8))
 			if **(**int64_t)(__ccgo_up((*CostManager)(unsafe.Pointer(manager)).Fcosts + uintptr(j)*8)) > cost_tmp {
 				**(**int64_t)(__ccgo_up((*CostManager)(unsafe.Pointer(manager)).Fcosts + uintptr(j)*8)) = cost_tmp
 				**(**uint16_t)(__ccgo_up((*CostManager)(unsafe.Pointer(manager)).Fdist_array + uintptr(j)*2)) = libc.Uint16FromInt32(k + int32(1))
 			}
 			goto _1
 		_1:
 			;
 			j = j + 1
 		}
 		return
 	}
 	i = uint64(0)
 	for {
 		if !(i < (*CostManager)(unsafe.Pointer(manager)).Fcache_intervals_size && (**(**CostCacheInterval)(__ccgo_up(cost_cache_intervals + uintptr(i)*16))).Fstart < len1) {
 			break
 		}
 		// Define the intersection of the ith interval with the new one.
 		start = position + (**(**CostCacheInterval)(__ccgo_up(cost_cache_intervals + uintptr(i)*16))).Fstart
 		if (**(**CostCacheInterval)(__ccgo_up(cost_cache_intervals + uintptr(i)*16))).Fend > len1 {
 			v3 = len1
 		} else {
 			v3 = (**(**CostCacheInterval)(__ccgo_up(cost_cache_intervals + uintptr(i)*16))).Fend
 		}
 		end = position + v3
 		cost = distance_cost + (**(**CostCacheInterval)(__ccgo_up(cost_cache_intervals + uintptr(i)*16))).Fcost
 		for {
 			if !(interval != libc.UintptrFromInt32(0) && (*CostInterval)(unsafe.Pointer(interval)).Fstart < end) {
 				break
 			}
 			interval_next = (*CostInterval)(unsafe.Pointer(interval)).Fnext
 			// Make sure we have some overlap
 			if start >= (*CostInterval)(unsafe.Pointer(interval)).Fend {
 				goto _4
 			}
 			if cost >= (*CostInterval)(unsafe.Pointer(interval)).Fcost {
 				// When intervals are represented, the lower, the better.
 				// [**********************************************************[
 				// start                                                    end
 				//                   [----------------------------------[
 				//                   interval->start        interval->end
 				// If we are worse than what we already have, add whatever we have so
 				// far up to interval.
 				start_new = (*CostInterval)(unsafe.Pointer(interval)).Fend
 				InsertInterval(tls, manager, interval, cost, position, start, (*CostInterval)(unsafe.Pointer(interval)).Fstart)
 				start = start_new
 				if start >= end {
 					break
 				}
 				goto _4
 			}
 			if start <= (*CostInterval)(unsafe.Pointer(interval)).Fstart {
 				if (*CostInterval)(unsafe.Pointer(interval)).Fend <= end {
 					//                   [----------------------------------[
 					//                   interval->start        interval->end
 					// [**************************************************************[
 					// start                                                        end
 					// We can safely remove the old interval as it is fully included.
 					PopInterval(tls, manager, interval)
 				} else {
 					//              [------------------------------------[
 					//              interval->start          interval->end
 					// [*****************************[
 					// start                       end
 					(*CostInterval)(unsafe.Pointer(interval)).Fstart = end
 					break
 				}
 			} else {
 				if end < (*CostInterval)(unsafe.Pointer(interval)).Fend {
 					// [--------------------------------------------------------------[
 					// interval->start                                    interval->end
 					//                     [*****************************[
 					//                     start                       end
 					// We have to split the old interval as it fully contains the new one.
 					end_original = (*CostInterval)(unsafe.Pointer(interval)).Fend
 					(*CostInterval)(unsafe.Pointer(interval)).Fend = start
 					InsertInterval(tls, manager, interval, (*CostInterval)(unsafe.Pointer(interval)).Fcost, (*CostInterval)(unsafe.Pointer(interval)).Findex, end, end_original)
 					interval = (*CostInterval)(unsafe.Pointer(interval)).Fnext
 					break
 				} else {
 					// [------------------------------------[
 					// interval->start          interval->end
 					//                     [*****************************[
 					//                     start                       end
 					(*CostInterval)(unsafe.Pointer(interval)).Fend = start
 				}
 			}
 			goto _4
 		_4:
 			;
 			interval = interval_next
 		}
 		// Insert the remaining interval from start to end.
 		InsertInterval(tls, manager, interval, cost, position, start, end)
 		goto _2
 	_2:
 		;
 		i = i + 1
 	}
 }
 
 func BackwardReferencesHashChainDistanceOnly(tls *libc.TLS, xsize int32, ysize int32, argb uintptr, cache_bits int32, hash_chain uintptr, refs uintptr, dist_array uintptr) (r int32) {
 	bp := tls.Alloc(32)
 	defer tls.Free(32)
 	var cc_init, code, first_offset_is_constant, i, j, len_prev, offset_prev, ok, pix_count, reach, use_color_cache, v1, v2, v4 int32
 	var cost_manager, cost_model, v6 uintptr
 	var cost_model_size, literal_array_size size_t
 	var offset_cost, prev_cost int64_t
 	var _ /* hashers at bp+0 */ VP8LColorCache
 	var _ /* len at bp+20 */ int32
 	var _ /* len_j at bp+28 */ int32
 	var _ /* offset at bp+16 */ int32
 	var _ /* offset_j at bp+24 */ int32
 	_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = cc_init, code, cost_manager, cost_model, cost_model_size, first_offset_is_constant, i, j, len_prev, literal_array_size, offset_cost, offset_prev, ok, pix_count, prev_cost, reach, use_color_cache, v1, v2, v4, v6
 	ok = 0
 	cc_init = 0
 	pix_count = xsize * ysize
 	use_color_cache = libc.BoolInt32(cache_bits > libc.Int32FromInt32(0))
 	v1 = cache_bits
 	if v1 > 0 {
 		v4 = int32(1) << v1
 	} else {
 		v4 = 0
 	}
 	v2 = libc.Int32FromInt32(NUM_LITERAL_CODES) + libc.Int32FromInt32(NUM_LENGTH_CODES) + v4
 	goto _3
 _3:
 	literal_array_size = uint64(4) * libc.Uint64FromInt32(v2)
 	cost_model_size = uint64(3240) + literal_array_size
 	cost_model = WebPSafeCalloc(tls, uint64(1), cost_model_size)
 	cost_manager = WebPSafeCalloc(tls, uint64(1), uint64(33224))
 	offset_prev = -int32(1)
 	len_prev = -int32(1)
 	offset_cost = int64(-int32(1))
 	first_offset_is_constant = -int32(1) // initialized with 'impossible' value
 	reach = 0
 	if cost_model == libc.UintptrFromInt32(0) || cost_manager == libc.UintptrFromInt32(0) {
 		goto Error
 	}
 	(*CostModel)(unsafe.Pointer(cost_model)).Fliteral = cost_model + libc.UintptrFromInt32(1)*3240
 	if use_color_cache != 0 {
 		cc_init = VP8LColorCacheInit(tls, bp, cache_bits)
 		if !(cc_init != 0) {
 			goto Error
 		}
 	}
 	if !(CostModelBuild(tls, cost_model, xsize, cache_bits, refs) != 0) {
 		goto Error
 	}
 	if !(CostManagerInit(tls, cost_manager, dist_array, pix_count, cost_model) != 0) {
 		goto Error
 	}
 	// We loop one pixel at a time, but store all currently best points to
 	// non-processed locations from this point.
 	**(**uint16_t)(__ccgo_up(dist_array)) = uint16(0)
 	// Add first pixel as literal.
 	AddSingleLiteralWithCostModel(tls, argb, bp, cost_model, 0, use_color_cache, 0, (*CostManager)(unsafe.Pointer(cost_manager)).Fcosts, dist_array)
 	i = int32(1)
 	for {
 		if !(i < pix_count) {
 			break
 		}
 		prev_cost = **(**int64_t)(__ccgo_up((*CostManager)(unsafe.Pointer(cost_manager)).Fcosts + uintptr(i-int32(1))*8))
 		v6 = hash_chain
 		v1 = i
 		v2 = libc.Int32FromUint32(**(**uint32_t)(__ccgo_up((*VP8LHashChain)(unsafe.Pointer(v6)).Foffset_length + uintptr(v1)*4)) >> int32(MAX_LENGTH_BITS))
 		goto _9
 	_9:
 		**(**int32)(__ccgo_up(bp + 16)) = v2
 		v4 = libc.Int32FromUint32(**(**uint32_t)(__ccgo_up((*VP8LHashChain)(unsafe.Pointer(v6)).Foffset_length + uintptr(v1)*4)) & (libc.Uint32FromUint32(1)<<libc.Int32FromInt32(MAX_LENGTH_BITS) - libc.Uint32FromInt32(1)))
 		goto _11
 	_11:
 		**(**int32)(__ccgo_up(bp + 20)) = v4
 		// Try adding the pixel as a literal.
 		AddSingleLiteralWithCostModel(tls, argb, bp, cost_model, i, use_color_cache, prev_cost, (*CostManager)(unsafe.Pointer(cost_manager)).Fcosts, dist_array)
 		// If we are dealing with a non-literal.
 		if **(**int32)(__ccgo_up(bp + 20)) >= int32(2) {
 			if **(**int32)(__ccgo_up(bp + 16)) != offset_prev {
 				code = VP8LDistanceToPlaneCode(tls, xsize, **(**int32)(__ccgo_up(bp + 16)))
 				offset_cost = GetDistanceCost(tls, cost_model, libc.Uint32FromInt32(code))
 				first_offset_is_constant = int32(1)
 				PushInterval(tls, cost_manager, prev_cost+offset_cost, i, **(**int32)(__ccgo_up(bp + 20)))
 			} else {
 				// Instead of considering all contributions from a pixel i by calling:
 				//         PushInterval(cost_manager, prev_cost + offset_cost, i, len);
 				// we optimize these contributions in case offset_cost stays the same
 				// for consecutive pixels. This describes a set of pixels similar to a
 				// previous set (e.g. constant color regions).
 				if first_offset_is_constant != 0 {
 					reach = i - int32(1) + len_prev - int32(1)
 					first_offset_is_constant = 0
 				}
 				if i+**(**int32)(__ccgo_up(bp + 20))-int32(1) > reach {
 					**(**int32)(__ccgo_up(bp + 28)) = 0
 					// Figure out the last consecutive pixel within [i, reach + 1] with
 					// the same offset.
 					j = i
 					for {
 						if !(j <= reach) {
 							break
 						}
 						v6 = hash_chain
 						v1 = j + int32(1)
 						v2 = libc.Int32FromUint32(**(**uint32_t)(__ccgo_up((*VP8LHashChain)(unsafe.Pointer(v6)).Foffset_length + uintptr(v1)*4)) >> int32(MAX_LENGTH_BITS))
 						goto _16
 					_16:
 						**(**int32)(__ccgo_up(bp + 24)) = v2
 						v4 = libc.Int32FromUint32(**(**uint32_t)(__ccgo_up((*VP8LHashChain)(unsafe.Pointer(v6)).Foffset_length + uintptr(v1)*4)) & (libc.Uint32FromUint32(1)<<libc.Int32FromInt32(MAX_LENGTH_BITS) - libc.Uint32FromInt32(1)))
 						goto _18
 					_18:
 						**(**int32)(__ccgo_up(bp + 28)) = v4
 						if **(**int32)(__ccgo_up(bp + 24)) != **(**int32)(__ccgo_up(bp + 16)) {
 							v6 = hash_chain
 							v1 = j
 							v2 = libc.Int32FromUint32(**(**uint32_t)(__ccgo_up((*VP8LHashChain)(unsafe.Pointer(v6)).Foffset_length + uintptr(v1)*4)) >> int32(MAX_LENGTH_BITS))
 							goto _22
 						_22:
 							**(**int32)(__ccgo_up(bp + 24)) = v2
 							v4 = libc.Int32FromUint32(**(**uint32_t)(__ccgo_up((*VP8LHashChain)(unsafe.Pointer(v6)).Foffset_length + uintptr(v1)*4)) & (libc.Uint32FromUint32(1)<<libc.Int32FromInt32(MAX_LENGTH_BITS) - libc.Uint32FromInt32(1)))
 							goto _24
 						_24:
 							**(**int32)(__ccgo_up(bp + 28)) = v4
 							break
 						}
 						goto _12
 					_12:
 						;
 						j = j + 1
 					}
 					// Update the cost at j - 1 and j.
 					UpdateCostAtIndex(tls, cost_manager, j-int32(1), 0)
 					UpdateCostAtIndex(tls, cost_manager, j, 0)
 					PushInterval(tls, cost_manager, **(**int64_t)(__ccgo_up((*CostManager)(unsafe.Pointer(cost_manager)).Fcosts + uintptr(j-int32(1))*8))+offset_cost, j, **(**int32)(__ccgo_up(bp + 28)))
 					reach = j + **(**int32)(__ccgo_up(bp + 28)) - int32(1)
 				}
 			}
 		}
 		UpdateCostAtIndex(tls, cost_manager, i, int32(1))
 		offset_prev = **(**int32)(__ccgo_up(bp + 16))
 		len_prev = **(**int32)(__ccgo_up(bp + 20))
 		goto _5
 	_5:
 		;
 		i = i + 1
 	}
 	ok = libc.BoolInt32(!((*VP8LBackwardRefs)(unsafe.Pointer(refs)).Ferror1 != 0))
 	goto Error
 Error:
 	;
 	if cc_init != 0 {
 		VP8LColorCacheClear(tls, bp)
 	}
 	CostManagerClear(tls, cost_manager)
 	WebPSafeFree(tls, cost_model)
 	WebPSafeFree(tls, cost_manager)
 	return ok
 }
 
 // C documentation
 //
 //	// We pack the path at the end of *dist_array and return
 //	// a pointer to this part of the array. Example:
 //	// dist_array = [1x2xx3x2] => packed [1x2x1232], chosen_path = [1232]
 func TraceBackwards(tls *libc.TLS, dist_array uintptr, dist_array_size int32, chosen_path uintptr, chosen_path_size uintptr) {
 	var cur, path uintptr
 	var k int32
 	_, _, _ = cur, k, path
 	path = dist_array + uintptr(dist_array_size)*2
 	cur = dist_array + uintptr(dist_array_size)*2 - uintptr(1)*2
 	for cur >= dist_array {
 		k = libc.Int32FromUint16(**(**uint16_t)(__ccgo_up(cur)))
 		path -= 2
 		**(**uint16_t)(__ccgo_up(path)) = libc.Uint16FromInt32(k)
 		cur = cur - uintptr(k)*2
 	}
 	**(**uintptr)(__ccgo_up(chosen_path)) = path
 	**(**int32)(__ccgo_up(chosen_path_size)) = int32((int64(dist_array+uintptr(dist_array_size)*2) - int64(path)) / 2)
 }
 
 func BackwardReferencesHashChainFollowChosenPath(tls *libc.TLS, argb4 uintptr, cache_bits int32, chosen_path uintptr, chosen_path_size int32, hash_chain uintptr, refs uintptr) (r int32) {
 	bp := tls.Alloc(16)
 	defer tls.Free(16)
 	var cc_init, i, idx1, ix, k, key, key1, len1, offset, ok, use_color_cache, v11, v14, v2, v9 int32
 	var retval, retval1, retval2, v, v4 PixOrCopy
 	var v7 uintptr
 	var v8 uint32_t
 	var _ /* hashers at bp+0 */ VP8LColorCache
 	_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = cc_init, i, idx1, ix, k, key, key1, len1, offset, ok, retval, retval1, retval2, use_color_cache, v, v11, v14, v2, v4, v7, v8, v9
 	use_color_cache = libc.BoolInt32(cache_bits > libc.Int32FromInt32(0))
 	i = 0
 	ok = 0
 	cc_init = 0
 	if use_color_cache != 0 {
 		cc_init = VP8LColorCacheInit(tls, bp, cache_bits)
 		if !(cc_init != 0) {
 			goto Error
 		}
 	}
 	VP8LClearBackwardRefs(tls, refs)
 	ix = 0
 	for {
 		if !(ix < chosen_path_size) {
 			break
 		}
 		len1 = libc.Int32FromUint16(**(**uint16_t)(__ccgo_up(chosen_path + uintptr(ix)*2)))
 		if len1 != int32(1) {
 			v2 = libc.Int32FromUint32(**(**uint32_t)(__ccgo_up((*VP8LHashChain)(unsafe.Pointer(hash_chain)).Foffset_length + uintptr(i)*4)) >> int32(MAX_LENGTH_BITS))
 			goto _3
 		_3:
 			offset = v2
 			retval.Fmode = uint8(kCopy)
 			retval.Fargb_or_distance = libc.Uint32FromInt32(offset)
 			retval.Flen1 = libc.Uint16FromInt32(len1)
 			v4 = retval
 			goto _5
 		_5:
 			VP8LBackwardRefsCursorAdd(tls, refs, v4)
 			if use_color_cache != 0 {
 				k = 0
 				for {
 					if !(k < len1) {
 						break
 					}
 					v7 = bp
 					v8 = **(**uint32_t)(__ccgo_up(argb4 + uintptr(i+k)*4))
 					v2 = libc.Int32FromUint32(v8 * kHashMul10 >> (*VP8LColorCache)(unsafe.Pointer(v7)).Fhash_shift)
 					goto _10
 				_10:
 					key = v2
 					**(**uint32_t)(__ccgo_up((*VP8LColorCache)(unsafe.Pointer(v7)).Fcolors + uintptr(key)*4)) = v8
 					goto _6
 				_6:
 					;
 					k = k + 1
 				}
 			}
 			i = i + len1
 		} else {
 			if use_color_cache != 0 {
 				v7 = bp
 				v8 = **(**uint32_t)(__ccgo_up(argb4 + uintptr(i)*4))
 				v9 = libc.Int32FromUint32(v8 * kHashMul10 >> (*VP8LColorCache)(unsafe.Pointer(v7)).Fhash_shift)
 				goto _15
 			_15:
 				key1 = v9
 				if **(**uint32_t)(__ccgo_up((*VP8LColorCache)(unsafe.Pointer(v7)).Fcolors + uintptr(key1)*4)) == v8 {
 					v14 = key1
 				} else {
 					v14 = -int32(1)
 				}
 				v11 = v14
 				goto _17
 			_17:
 				v2 = v11
 			} else {
 				v2 = -int32(1)
 			}
 			idx1 = v2
 			if idx1 >= 0 {
 				// use_color_cache is true and hashers contains argb[i]
 				// push pixel as a color cache index
 				retval1.Fmode = uint8(kCacheIdx)
 				retval1.Fargb_or_distance = libc.Uint32FromInt32(idx1)
 				retval1.Flen1 = uint16(1)
 				v4 = retval1
 				goto _20
 			_20:
 				v = v4
 			} else {
 				if use_color_cache != 0 {
 					v7 = bp
 					v8 = **(**uint32_t)(__ccgo_up(argb4 + uintptr(i)*4))
 					v2 = libc.Int32FromUint32(v8 * kHashMul10 >> (*VP8LColorCache)(unsafe.Pointer(v7)).Fhash_shift)
 					goto _24
 				_24:
 					key = v2
 					**(**uint32_t)(__ccgo_up((*VP8LColorCache)(unsafe.Pointer(v7)).Fcolors + uintptr(key)*4)) = v8
 				}
 				retval2.Fmode = uint8(kLiteral)
 				retval2.Fargb_or_distance = **(**uint32_t)(__ccgo_up(argb4 + uintptr(i)*4))
 				retval2.Flen1 = uint16(1)
 				v4 = retval2
 				goto _26
 			_26:
 				v = v4
 			}
 			VP8LBackwardRefsCursorAdd(tls, refs, v)
 			i = i + 1
 		}
 		goto _1
 	_1:
 		;
 		ix = ix + 1
 	}
 	ok = libc.BoolInt32(!((*VP8LBackwardRefs)(unsafe.Pointer(refs)).Ferror1 != 0))
 	goto Error
 Error:
 	;
 	if cc_init != 0 {
 		VP8LColorCacheClear(tls, bp)
 	}
 	return ok
 }
 
 func VP8LBackwardReferencesTraceBackwards(tls *libc.TLS, xsize int32, ysize int32, argb uintptr, cache_bits int32, hash_chain uintptr, refs_src uintptr, refs_dst uintptr) (r int32) {
 	bp := tls.Alloc(16)
 	defer tls.Free(16)
 	var dist_array uintptr
 	var dist_array_size, ok int32
 	var _ /* chosen_path at bp+0 */ uintptr
 	var _ /* chosen_path_size at bp+8 */ int32
 	_, _, _ = dist_array, dist_array_size, ok
 	ok = 0
 	dist_array_size = xsize * ysize
 	**(**uintptr)(__ccgo_up(bp)) = libc.UintptrFromInt32(0)
 	**(**int32)(__ccgo_up(bp + 8)) = 0
 	dist_array = WebPSafeMalloc(tls, libc.Uint64FromInt32(dist_array_size), uint64(2))
 	if dist_array == libc.UintptrFromInt32(0) {
 		goto Error
 	}
 	if !(BackwardReferencesHashChainDistanceOnly(tls, xsize, ysize, argb, cache_bits, hash_chain, refs_src, dist_array) != 0) {
 		goto Error
 	}
 	TraceBackwards(tls, dist_array, dist_array_size, bp, bp+8)
 	if !(BackwardReferencesHashChainFollowChosenPath(tls, argb, cache_bits, **(**uintptr)(__ccgo_up(bp)), **(**int32)(__ccgo_up(bp + 8)), hash_chain, refs_dst) != 0) {
 		goto Error
 	}
 	ok = int32(1)
 	goto Error
 Error:
 	;
 	WebPSafeFree(tls, dist_array)
 	return ok
 }
 
 const MIN_BLOCK_SIZE = 256
 const MIN_LENGTH = 4
 const WINDOW_OFFSETS_SIZE_MAX = 32
 
 type PixOrCopyBlock = struct {
 	Fnext  uintptr
 	Fstart uintptr
 	Fsize  int32
 }
 
 var kHashMul11 = uint32(0x1e35a7bd)
 
 //------------------------------------------------------------------------------
 
 // Copyright 2012 Google Inc. All Rights Reserved.
 //
 // Use of this source code is governed by a BSD-style license
 // that can be found in the COPYING file in the root of the source
 // tree. An additional intellectual property rights grant can be found
 // in the file PATENTS. All contributing project authors may
 // be found in the AUTHORS file in the root of the source tree.
 // -----------------------------------------------------------------------------
 //
 // Misc. common utility functions
 //
 // Authors: Skal (pascal.massimino@gmail.com)
 //          Urvang (urvang@google.com)
 
 // Copyright 2011 Google Inc. All Rights Reserved.
 //
 // Use of this source code is governed by a BSD-style license
 // that can be found in the COPYING file in the root of the source
 // tree. An additional intellectual property rights grant can be found
 // in the file PATENTS. All contributing project authors may
 // be found in the AUTHORS file in the root of the source tree.
 // -----------------------------------------------------------------------------
 //
 //   WebP encoder: main interface
 //
 // Author: Skal (pascal.massimino@gmail.com)
 
 // Copyright 2012 Google Inc. All Rights Reserved.
 //
 // Use of this source code is governed by a BSD-style license
 // that can be found in the COPYING file in the root of the source
 // tree. An additional intellectual property rights grant can be found
 // in the file PATENTS. All contributing project authors may
 // be found in the AUTHORS file in the root of the source tree.
 // -----------------------------------------------------------------------------
 //
 //  Internal header for constants related to WebP file format.
 //
 // Author: Urvang (urvang@google.com)
 
 // Copyright 2010 Google Inc. All Rights Reserved.
 //
 // Use of this source code is governed by a BSD-style license
 // that can be found in the COPYING file in the root of the source
 // tree. An additional intellectual property rights grant can be found
 // in the file PATENTS. All contributing project authors may
 // be found in the AUTHORS file in the root of the source tree.
 // -----------------------------------------------------------------------------
 //
 //  Common types + memory wrappers
 //
 // Author: Skal (pascal.massimino@gmail.com)
 
 // 1M window (4M bytes) minus 120 special codes for short distances.
 
 // Minimum number of pixels for which it is cheaper to encode a
 // distance + length instead of each pixel as a literal.
 
 // -----------------------------------------------------------------------------
 
 var plane_to_code_lut = [128]uint8_t{
 	0:   uint8(96),
 	1:   uint8(73),
 	2:   uint8(55),
 	3:   uint8(39),
 	4:   uint8(23),
 	5:   uint8(13),
 	6:   uint8(5),
 	7:   uint8(1),
 	8:   uint8(255),
 	9:   uint8(255),
 	10:  uint8(255),
 	11:  uint8(255),
 	12:  uint8(255),
 	13:  uint8(255),
 	14:  uint8(255),
 	15:  uint8(255),
 	16:  uint8(101),
 	17:  uint8(78),
 	18:  uint8(58),
 	19:  uint8(42),
 	20:  uint8(26),
 	21:  uint8(16),
 	22:  uint8(8),
 	23:  uint8(2),
 	25:  uint8(3),
 	26:  uint8(9),
 	27:  uint8(17),
 	28:  uint8(27),
 	29:  uint8(43),
 	30:  uint8(59),
 	31:  uint8(79),
 	32:  uint8(102),
 	33:  uint8(86),
 	34:  uint8(62),
 	35:  uint8(46),
 	36:  uint8(32),
 	37:  uint8(20),
 	38:  uint8(10),
 	39:  uint8(6),
 	40:  uint8(4),
 	41:  uint8(7),
 	42:  uint8(11),
 	43:  uint8(21),
 	44:  uint8(33),
 	45:  uint8(47),
 	46:  uint8(63),
 	47:  uint8(87),
 	48:  uint8(105),
 	49:  uint8(90),
 	50:  uint8(70),
 	51:  uint8(52),
 	52:  uint8(37),
 	53:  uint8(28),
 	54:  uint8(18),
 	55:  uint8(14),
 	56:  uint8(12),
 	57:  uint8(15),
 	58:  uint8(19),
 	59:  uint8(29),
 	60:  uint8(38),
 	61:  uint8(53),
 	62:  uint8(71),
 	63:  uint8(91),
 	64:  uint8(110),
 	65:  uint8(99),
 	66:  uint8(82),
 	67:  uint8(66),
 	68:  uint8(48),
 	69:  uint8(35),
 	70:  uint8(30),
 	71:  uint8(24),
 	72:  uint8(22),
 	73:  uint8(25),
 	74:  uint8(31),
 	75:  uint8(36),
 	76:  uint8(49),
 	77:  uint8(67),
 	78:  uint8(83),
 	79:  uint8(100),
 	80:  uint8(115),
 	81:  uint8(108),
 	82:  uint8(94),
 	83:  uint8(76),
 	84:  uint8(64),
 	85:  uint8(50),
 	86:  uint8(44),
 	87:  uint8(40),
 	88:  uint8(34),
 	89:  uint8(41),
 	90:  uint8(45),
 	91:  uint8(51),
 	92:  uint8(65),
 	93:  uint8(77),
 	94:  uint8(95),
 	95:  uint8(109),
 	96:  uint8(118),
 	97:  uint8(113),
 	98:  uint8(103),
 	99:  uint8(92),
 	100: uint8(80),
 	101: uint8(68),
 	102: uint8(60),
 	103: uint8(56),
 	104: uint8(54),
 	105: uint8(57),
 	106: uint8(61),
 	107: uint8(69),
 	108: uint8(81),
 	109: uint8(93),
 	110: uint8(104),
 	111: uint8(114),
 	112: uint8(119),
 	113: uint8(116),
 	114: uint8(111),
 	115: uint8(106),
 	116: uint8(97),
 	117: uint8(88),
 	118: uint8(84),
 	119: uint8(74),
 	120: uint8(72),
 	121: uint8(75),
 	122: uint8(85),
 	123: uint8(89),
 	124: uint8(98),
 	125: uint8(107),
 	126: uint8(112),
 	127: uint8(117),
 }
 
 func VP8LDistanceToPlaneCode(tls *libc.TLS, xsize int32, dist int32) (r int32) {
 	var xoffset, yoffset int32
 	_, _ = xoffset, yoffset
 	yoffset = dist / xsize
 	xoffset = dist - yoffset*xsize
 	if xoffset <= int32(8) && yoffset < int32(8) {
 		return libc.Int32FromUint8(plane_to_code_lut[yoffset*int32(16)+int32(8)-xoffset]) + int32(1)
 	} else {
 		if xoffset > xsize-int32(8) && yoffset < int32(7) {
 			return libc.Int32FromUint8(plane_to_code_lut[(yoffset+int32(1))*int32(16)+int32(8)+(xsize-xoffset)]) + int32(1)
 		}
 	}
 	return dist + int32(120)
 }
 
 // C documentation
 //
 //	// Returns the exact index where array1 and array2 are different. For an index
 //	// inferior or equal to best_len_match, the return value just has to be strictly
 //	// inferior to best_len_match. The current behavior is to return 0 if this index
 //	// is best_len_match, and the index itself otherwise.
 //	// If no two elements are the same, it returns max_limit.
 func FindMatchLength(tls *libc.TLS, array1 uintptr, array2 uintptr, best_len_match int32, max_limit int32) (r int32) {
 	// Before 'expensive' linear match, check if the two arrays match at the
 	// current best length index.
 	if **(**uint32_t)(__ccgo_up(array1 + uintptr(best_len_match)*4)) != **(**uint32_t)(__ccgo_up(array2 + uintptr(best_len_match)*4)) {
 		return 0
 	}
 	return (*(*func(*libc.TLS, uintptr, uintptr, int32) int32)(unsafe.Pointer(&struct{ uintptr }{VP8LVectorMismatch})))(tls, array1, array2, max_limit)
 }
 
 func VP8LClearBackwardRefs(tls *libc.TLS, refs uintptr) {
 	if (*VP8LBackwardRefs)(unsafe.Pointer(refs)).Ftail != libc.UintptrFromInt32(0) {
 		**(**uintptr)(__ccgo_up((*VP8LBackwardRefs)(unsafe.Pointer(refs)).Ftail)) = (*VP8LBackwardRefs)(unsafe.Pointer(refs)).Ffree_blocks // recycle all blocks at once
 	}
 	(*VP8LBackwardRefs)(unsafe.Pointer(refs)).Ffree_blocks = (*VP8LBackwardRefs)(unsafe.Pointer(refs)).Frefs
 	(*VP8LBackwardRefs)(unsafe.Pointer(refs)).Ftail = refs + 8
 	(*VP8LBackwardRefs)(unsafe.Pointer(refs)).Flast_block = libc.UintptrFromInt32(0)
 	(*VP8LBackwardRefs)(unsafe.Pointer(refs)).Frefs = libc.UintptrFromInt32(0)
 }
 
 func VP8LBackwardRefsClear(tls *libc.TLS, refs uintptr) {
 	var next uintptr
 	_ = next
 	VP8LClearBackwardRefs(tls, refs)
 	for (*VP8LBackwardRefs)(unsafe.Pointer(refs)).Ffree_blocks != libc.UintptrFromInt32(0) {
 		next = (*PixOrCopyBlock)(unsafe.Pointer((*VP8LBackwardRefs)(unsafe.Pointer(refs)).Ffree_blocks)).Fnext
 		WebPSafeFree(tls, (*VP8LBackwardRefs)(unsafe.Pointer(refs)).Ffree_blocks)
 		(*VP8LBackwardRefs)(unsafe.Pointer(refs)).Ffree_blocks = next
 	}
 }
 
 // C documentation
 //
 //	// Swaps the content of two VP8LBackwardRefs.
 func BackwardRefsSwap(tls *libc.TLS, refs1 uintptr, refs2 uintptr) {
 	var point_to_refs1, point_to_refs2 int32
 	var tmp VP8LBackwardRefs
 	_, _, _ = point_to_refs1, point_to_refs2, tmp
 	point_to_refs1 = libc.BoolInt32((*VP8LBackwardRefs)(unsafe.Pointer(refs1)).Ftail != libc.UintptrFromInt32(0) && (*VP8LBackwardRefs)(unsafe.Pointer(refs1)).Ftail == refs1+8)
 	point_to_refs2 = libc.BoolInt32((*VP8LBackwardRefs)(unsafe.Pointer(refs2)).Ftail != libc.UintptrFromInt32(0) && (*VP8LBackwardRefs)(unsafe.Pointer(refs2)).Ftail == refs2+8)
 	tmp = **(**VP8LBackwardRefs)(__ccgo_up(refs1))
 	**(**VP8LBackwardRefs)(__ccgo_up(refs1)) = **(**VP8LBackwardRefs)(__ccgo_up(refs2))
 	**(**VP8LBackwardRefs)(__ccgo_up(refs2)) = tmp
 	if point_to_refs2 != 0 {
 		(*VP8LBackwardRefs)(unsafe.Pointer(refs1)).Ftail = refs1 + 8
 	}
 	if point_to_refs1 != 0 {
 		(*VP8LBackwardRefs)(unsafe.Pointer(refs2)).Ftail = refs2 + 8
 	}
 }
 
 func VP8LBackwardRefsInit(tls *libc.TLS, refs uintptr, block_size int32) {
 	var v1 int32
 	_ = v1
 	libc.X__builtin___memset_chk(tls, refs, 0, uint64(40), ^__predefined_size_t(0))
 	(*VP8LBackwardRefs)(unsafe.Pointer(refs)).Ftail = refs + 8
 	if block_size < int32(MIN_BLOCK_SIZE) {
 		v1 = int32(MIN_BLOCK_SIZE)
 	} else {
 		v1 = block_size
 	}
 	(*VP8LBackwardRefs)(unsafe.Pointer(refs)).Fblock_size = v1
 }
 
 func VP8LRefsCursorInit(tls *libc.TLS, refs uintptr) (r VP8LRefsCursor) {
 	var c VP8LRefsCursor
 	_ = c
 	c.Fcur_block = (*VP8LBackwardRefs)(unsafe.Pointer(refs)).Frefs
 	if (*VP8LBackwardRefs)(unsafe.Pointer(refs)).Frefs != libc.UintptrFromInt32(0) {
 		c.Fcur_pos = (*PixOrCopyBlock)(unsafe.Pointer(c.Fcur_block)).Fstart
 		c.Flast_pos = c.Fcur_pos + uintptr((*PixOrCopyBlock)(unsafe.Pointer(c.Fcur_block)).Fsize)*8
 	} else {
 		c.Fcur_pos = libc.UintptrFromInt32(0)
 		c.Flast_pos = libc.UintptrFromInt32(0)
 	}
 	return c
 }
 
 func VP8LRefsCursorNextBlock(tls *libc.TLS, c uintptr) {
 	var b, v1 uintptr
 	_, _ = b, v1
 	b = (*PixOrCopyBlock)(unsafe.Pointer((*VP8LRefsCursor)(unsafe.Pointer(c)).Fcur_block)).Fnext
 	if b == libc.UintptrFromInt32(0) {
 		v1 = libc.UintptrFromInt32(0)
 	} else {
 		v1 = (*PixOrCopyBlock)(unsafe.Pointer(b)).Fstart
 	}
 	(*VP8LRefsCursor)(unsafe.Pointer(c)).Fcur_pos = v1
 	if b == libc.UintptrFromInt32(0) {
 		v1 = libc.UintptrFromInt32(0)
 	} else {
 		v1 = (*PixOrCopyBlock)(unsafe.Pointer(b)).Fstart + uintptr((*PixOrCopyBlock)(unsafe.Pointer(b)).Fsize)*8
 	}
 	(*VP8LRefsCursor)(unsafe.Pointer(c)).Flast_pos = v1
 	(*VP8LRefsCursor)(unsafe.Pointer(c)).Fcur_block = b
 }
 
 // C documentation
 //
 //	// Create a new block, either from the free list or allocated
 func BackwardRefsNewBlock(tls *libc.TLS, refs uintptr) (r uintptr) {
 	var b uintptr
 	var total_size size_t
 	_, _ = b, total_size
 	b = (*VP8LBackwardRefs)(unsafe.Pointer(refs)).Ffree_blocks
 	if b == libc.UintptrFromInt32(0) { // allocate new memory chunk
 		total_size = uint64(24) + libc.Uint64FromInt32((*VP8LBackwardRefs)(unsafe.Pointer(refs)).Fblock_size)*uint64(8)
 		b = WebPSafeMalloc(tls, uint64(1), total_size)
 		if b == libc.UintptrFromInt32(0) {
 			**(**int32)(__ccgo_up(refs + 4)) |= int32(1)
 			return libc.UintptrFromInt32(0)
 		}
 		(*PixOrCopyBlock)(unsafe.Pointer(b)).Fstart = b + libc.UintptrFromInt64(24) // not always aligned
 	} else { // recycle from free-list
 		(*VP8LBackwardRefs)(unsafe.Pointer(refs)).Ffree_blocks = (*PixOrCopyBlock)(unsafe.Pointer(b)).Fnext
 	}
 	**(**uintptr)(__ccgo_up((*VP8LBackwardRefs)(unsafe.Pointer(refs)).Ftail)) = b
 	(*VP8LBackwardRefs)(unsafe.Pointer(refs)).Ftail = b
 	(*VP8LBackwardRefs)(unsafe.Pointer(refs)).Flast_block = b
 	(*PixOrCopyBlock)(unsafe.Pointer(b)).Fnext = libc.UintptrFromInt32(0)
 	(*PixOrCopyBlock)(unsafe.Pointer(b)).Fsize = 0
 	return b
 }
 
 // C documentation
 //
 //	// Return 1 on success, 0 on error.
 func BackwardRefsClone(tls *libc.TLS, from uintptr, to uintptr) (r int32) {
 	var block_from, block_to uintptr
 	_, _ = block_from, block_to
 	block_from = (*VP8LBackwardRefs)(unsafe.Pointer(from)).Frefs
 	VP8LClearBackwardRefs(tls, to)
 	for block_from != libc.UintptrFromInt32(0) {
 		block_to = BackwardRefsNewBlock(tls, to)
 		if block_to == libc.UintptrFromInt32(0) {
 			return 0
 		}
 		libc.X__builtin___memcpy_chk(tls, (*PixOrCopyBlock)(unsafe.Pointer(block_to)).Fstart, (*PixOrCopyBlock)(unsafe.Pointer(block_from)).Fstart, libc.Uint64FromInt32((*PixOrCopyBlock)(unsafe.Pointer(block_from)).Fsize)*uint64(8), ^__predefined_size_t(0))
 		(*PixOrCopyBlock)(unsafe.Pointer(block_to)).Fsize = (*PixOrCopyBlock)(unsafe.Pointer(block_from)).Fsize
 		block_from = (*PixOrCopyBlock)(unsafe.Pointer(block_from)).Fnext
 	}
 	return int32(1)
 }
 
 func VP8LBackwardRefsCursorAdd(tls *libc.TLS, refs uintptr, v PixOrCopy) {
 	var b, v2 uintptr
 	var v1 int32
 	_, _, _ = b, v1, v2
 	b = (*VP8LBackwardRefs)(unsafe.Pointer(refs)).Flast_block
 	if b == libc.UintptrFromInt32(0) || (*PixOrCopyBlock)(unsafe.Pointer(b)).Fsize == (*VP8LBackwardRefs)(unsafe.Pointer(refs)).Fblock_size {
 		b = BackwardRefsNewBlock(tls, refs)
 		if b == libc.UintptrFromInt32(0) {
 			return
 		} // refs->error is set
 	}
 	v2 = b + 16
 	v1 = *(*int32)(unsafe.Pointer(v2))
 	*(*int32)(unsafe.Pointer(v2)) = *(*int32)(unsafe.Pointer(v2)) + 1
 	**(**PixOrCopy)(__ccgo_up((*PixOrCopyBlock)(unsafe.Pointer(b)).Fstart + uintptr(v1)*8)) = v
 }
 
 // -----------------------------------------------------------------------------
 // Hash chains
 
 func VP8LHashChainInit(tls *libc.TLS, p uintptr, size int32) (r int32) {
 	(*VP8LHashChain)(unsafe.Pointer(p)).Foffset_length = WebPSafeMalloc(tls, libc.Uint64FromInt32(size), uint64(4))
 	if (*VP8LHashChain)(unsafe.Pointer(p)).Foffset_length == libc.UintptrFromInt32(0) {
 		return 0
 	}
 	(*VP8LHashChain)(unsafe.Pointer(p)).Fsize = size
 	return int32(1)
 }
 
 func VP8LHashChainClear(tls *libc.TLS, p uintptr) {
 	WebPSafeFree(tls, (*VP8LHashChain)(unsafe.Pointer(p)).Foffset_length)
 	(*VP8LHashChain)(unsafe.Pointer(p)).Fsize = 0
 	(*VP8LHashChain)(unsafe.Pointer(p)).Foffset_length = libc.UintptrFromInt32(0)
 }
 
 // -----------------------------------------------------------------------------
 
 var kHashMultiplierHi = uint32(0xc6a4a793)
 var kHashMultiplierLo = uint32(0x5bd1e996)
 
 func GetPixPairHash64(tls *libc.TLS, argb uintptr) (r uint32_t) {
 	var key uint32_t
 	_ = key
 	key = **(**uint32_t)(__ccgo_up(argb + 1*4)) * kHashMultiplierHi
 	key = key + **(**uint32_t)(__ccgo_up(argb))*kHashMultiplierLo
 	key = key >> (libc.Int32FromInt32(32) - libc.Int32FromInt32(HASH_BITS))
 	return key
 }
 
 // C documentation
 //
 //	// Returns the maximum number of hash chain lookups to do for a
 //	// given compression quality. Return value in range [8, 86].
 func GetMaxItersForQuality(tls *libc.TLS, quality int32) (r int32) {
 	return int32(8) + quality*quality/int32(128)
 }
 
 func GetWindowSizeForHashChain(tls *libc.TLS, quality int32, xsize int32) (r int32) {
 	var max_window_size, v1, v2, v3 int32
 	_, _, _, _ = max_window_size, v1, v2, v3
 	if quality > int32(75) {
 		v1 = libc.Int32FromInt32(1)<<libc.Int32FromInt32(WINDOW_SIZE_BITS) - libc.Int32FromInt32(120)
 	} else {
 		if quality > int32(50) {
 			v2 = xsize << int32(8)
 		} else {
 			if quality > int32(25) {
 				v3 = xsize << int32(6)
 			} else {
 				v3 = xsize << int32(4)
 			}
 			v2 = v3
 		}
 		v1 = v2
 	}
 	max_window_size = v1
 	if max_window_size > libc.Int32FromInt32(1)<<libc.Int32FromInt32(WINDOW_SIZE_BITS)-libc.Int32FromInt32(120) {
 		v1 = libc.Int32FromInt32(1)<<libc.Int32FromInt32(WINDOW_SIZE_BITS) - libc.Int32FromInt32(120)
 	} else {
 		v1 = max_window_size
 	}
 	return v1
 }
 
 func MaxFindCopyLength(tls *libc.TLS, len1 int32) (r int32) {
 	var v1 int32
 	_ = v1
 	if len1 < libc.Int32FromInt32(1)<<libc.Int32FromInt32(MAX_LENGTH_BITS)-libc.Int32FromInt32(1) {
 		v1 = len1
 	} else {
 		v1 = libc.Int32FromInt32(1)<<libc.Int32FromInt32(MAX_LENGTH_BITS) - libc.Int32FromInt32(1)
 	}
 	return v1
 }
 
 func VP8LHashChainFill(tls *libc.TLS, p uintptr, quality int32, argb uintptr, xsize int32, ysize int32, low_effort int32, pic uintptr, percent_range int32, percent uintptr) (r int32) {
 	bp := tls.Alloc(16)
 	defer tls.Free(16)
 	var argb_comp, argb_comp_next, best_length, curr_length, curr_length1, iter, iter_max, length_max, max_len, min_pos, percent_start, pos, remaining_percent, size, v4 int32
 	var argb_start, chain, hash_to_first_index uintptr
 	var base_position, best_argb, best_distance, hash_code, len1, max_base_position, window_size, v1 uint32_t
 	var v12 bool
 	var v8 uint32
 	var _ /* tmp at bp+0 */ [2]uint32_t
 	_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = argb_comp, argb_comp_next, argb_start, base_position, best_argb, best_distance, best_length, chain, curr_length, curr_length1, hash_code, hash_to_first_index, iter, iter_max, len1, length_max, max_base_position, max_len, min_pos, percent_start, pos, remaining_percent, size, window_size, v1, v12, v4, v8
 	size = xsize * ysize
 	iter_max = GetMaxItersForQuality(tls, quality)
 	window_size = libc.Uint32FromInt32(GetWindowSizeForHashChain(tls, quality, xsize))
 	remaining_percent = percent_range
 	percent_start = **(**int32)(__ccgo_up(percent))
 	// Temporarily use the p->offset_length as a hash chain.
 	chain = (*VP8LHashChain)(unsafe.Pointer(p)).Foffset_length
 	if size <= int32(2) {
 		v1 = libc.Uint32FromInt32(0)
 		**(**uint32_t)(__ccgo_up((*VP8LHashChain)(unsafe.Pointer(p)).Foffset_length + uintptr(size-int32(1))*4)) = v1
 		**(**uint32_t)(__ccgo_up((*VP8LHashChain)(unsafe.Pointer(p)).Foffset_length)) = v1
 		return int32(1)
 	}
 	hash_to_first_index = WebPSafeMalloc(tls, libc.Uint64FromInt32(libc.Int32FromInt32(1)<<libc.Int32FromInt32(HASH_BITS)), uint64(4))
 	if hash_to_first_index == libc.UintptrFromInt32(0) {
 		return WebPEncodingSetError(tls, pic, int32(VP8_ENC_ERROR_OUT_OF_MEMORY))
 	}
 	percent_range = remaining_percent / int32(2)
 	remaining_percent = remaining_percent - percent_range
 	// Set the int32_t array to -1.
 	libc.X__builtin___memset_chk(tls, hash_to_first_index, int32(0xff), libc.Uint64FromInt32(libc.Int32FromInt32(1)<<libc.Int32FromInt32(HASH_BITS))*libc.Uint64FromInt64(4), ^__predefined_size_t(0))
 	// Fill the chain linking pixels with the same hash.
 	argb_comp = libc.BoolInt32(**(**uint32_t)(__ccgo_up(argb)) == **(**uint32_t)(__ccgo_up(argb + 1*4)))
 	pos = 0
 	for {
 		if !(pos < size-int32(2)) {
 			break
 		}
 		argb_comp_next = libc.BoolInt32(**(**uint32_t)(__ccgo_up(argb + uintptr(pos+int32(1))*4)) == **(**uint32_t)(__ccgo_up(argb + uintptr(pos+int32(2))*4)))
 		if argb_comp != 0 && argb_comp_next != 0 {
 			len1 = uint32(1)
 			(**(**[2]uint32_t)(__ccgo_up(bp)))[0] = **(**uint32_t)(__ccgo_up(argb + uintptr(pos)*4))
 			// Figure out how far the pixels are the same.
 			// The last pixel has a different 64 bit hash, as its next pixel does
 			// not have the same color, so we just need to get to the last pixel equal
 			// to its follower.
 			for pos+libc.Int32FromUint32(len1)+int32(2) < size && **(**uint32_t)(__ccgo_up(argb + uintptr(libc.Uint32FromInt32(pos)+len1+uint32(2))*4)) == **(**uint32_t)(__ccgo_up(argb + uintptr(pos)*4)) {
 				len1 = len1 + 1
 			}
 			if len1 > libc.Uint32FromInt32(libc.Int32FromInt32(1)<<libc.Int32FromInt32(MAX_LENGTH_BITS)-libc.Int32FromInt32(1)) {
 				// Skip the pixels that match for distance=1 and length>MAX_LENGTH
 				// because they are linked to their predecessor and we automatically
 				// check that in the main for loop below. Skipping means setting no
 				// predecessor in the chain, hence -1.
 				libc.X__builtin___memset_chk(tls, chain+uintptr(pos)*4, int32(0xff), uint64(len1-libc.Uint32FromInt32(libc.Int32FromInt32(1)<<libc.Int32FromInt32(MAX_LENGTH_BITS)-libc.Int32FromInt32(1)))*uint64(4), ^__predefined_size_t(0))
 				pos = libc.Int32FromUint32(uint32(pos) + (len1 - libc.Uint32FromInt32(libc.Int32FromInt32(1)<<libc.Int32FromInt32(MAX_LENGTH_BITS)-libc.Int32FromInt32(1))))
 				len1 = libc.Uint32FromInt32(libc.Int32FromInt32(1)<<libc.Int32FromInt32(MAX_LENGTH_BITS) - libc.Int32FromInt32(1))
 			}
 			// Process the rest of the hash chain.
 			for len1 != 0 {
 				v1 = len1
 				len1 = len1 - 1
 				(**(**[2]uint32_t)(__ccgo_up(bp)))[int32(1)] = v1
 				hash_code = GetPixPairHash64(tls, bp)
 				**(**int32_t)(__ccgo_up(chain + uintptr(pos)*4)) = **(**int32_t)(__ccgo_up(hash_to_first_index + uintptr(hash_code)*4))
 				v4 = pos
 				pos = pos + 1
 				**(**int32_t)(__ccgo_up(hash_to_first_index + uintptr(hash_code)*4)) = v4
 			}
 			argb_comp = 0
 		} else {
 			// Just move one pixel forward.
 			hash_code = GetPixPairHash64(tls, argb+uintptr(pos)*4)
 			**(**int32_t)(__ccgo_up(chain + uintptr(pos)*4)) = **(**int32_t)(__ccgo_up(hash_to_first_index + uintptr(hash_code)*4))
 			v4 = pos
 			pos = pos + 1
 			**(**int32_t)(__ccgo_up(hash_to_first_index + uintptr(hash_code)*4)) = v4
 			argb_comp = argb_comp_next
 		}
 		if !(WebPReportProgress(tls, pic, percent_start+percent_range*pos/(size-int32(2)), percent) != 0) {
 			WebPSafeFree(tls, hash_to_first_index)
 			return 0
 		}
 		goto _2
 	_2:
 	}
 	// Process the penultimate pixel.
 	**(**int32_t)(__ccgo_up(chain + uintptr(pos)*4)) = **(**int32_t)(__ccgo_up(hash_to_first_index + uintptr(GetPixPairHash64(tls, argb+uintptr(pos)*4))*4))
 	WebPSafeFree(tls, hash_to_first_index)
 	percent_start = percent_start + percent_range
 	if !(WebPReportProgress(tls, pic, percent_start, percent) != 0) {
 		return 0
 	}
 	percent_range = remaining_percent
 	// Find the best match interval at each pixel, defined by an offset to the
 	// pixel and a length. The right-most pixel cannot match anything to the right
 	// (hence a best length of 0) and the left-most pixel nothing to the left
 	// (hence an offset of 0).
 	v1 = libc.Uint32FromInt32(0)
 	**(**uint32_t)(__ccgo_up((*VP8LHashChain)(unsafe.Pointer(p)).Foffset_length + uintptr(size-int32(1))*4)) = v1
 	**(**uint32_t)(__ccgo_up((*VP8LHashChain)(unsafe.Pointer(p)).Foffset_length)) = v1
 	base_position = libc.Uint32FromInt32(size - int32(2))
 	for {
 		if !(base_position > uint32(0)) {
 			break
 		}
 		max_len = MaxFindCopyLength(tls, libc.Int32FromUint32(libc.Uint32FromInt32(size-int32(1))-base_position))
 		argb_start = argb + uintptr(base_position)*4
 		iter = iter_max
 		best_length = 0
 		best_distance = uint32(0)
 		if base_position > window_size {
 			v8 = base_position - window_size
 		} else {
 			v8 = uint32(0)
 		}
 		min_pos = libc.Int32FromUint32(v8)
 		if max_len < int32(256) {
 			v4 = max_len
 		} else {
 			v4 = int32(256)
 		}
 		length_max = v4
 		pos = **(**int32_t)(__ccgo_up(chain + uintptr(base_position)*4))
 		if !(low_effort != 0) {
 			// Heuristic: use the comparison with the above line as an initialization.
 			if base_position >= libc.Uint32FromInt32(xsize) {
 				curr_length = FindMatchLength(tls, argb_start-uintptr(xsize)*4, argb_start, best_length, max_len)
 				if curr_length > best_length {
 					best_length = curr_length
 					best_distance = libc.Uint32FromInt32(xsize)
 				}
 				iter = iter - 1
 			}
 			// Heuristic: compare to the previous pixel.
 			curr_length = FindMatchLength(tls, argb_start-uintptr(1)*4, argb_start, best_length, max_len)
 			if curr_length > best_length {
 				best_length = curr_length
 				best_distance = uint32(1)
 			}
 			iter = iter - 1
 			// Skip the for loop if we already have the maximum.
 			if best_length == libc.Int32FromInt32(1)<<libc.Int32FromInt32(MAX_LENGTH_BITS)-libc.Int32FromInt32(1) {
 				pos = min_pos - int32(1)
 			}
 		}
 		best_argb = **(**uint32_t)(__ccgo_up(argb_start + uintptr(best_length)*4))
 		for {
 			if v12 = pos >= min_pos; v12 {
 				iter = iter - 1
 				v4 = iter
 			}
 			if !(v12 && v4 != 0) {
 				break
 			}
 			if **(**uint32_t)(__ccgo_up(argb + uintptr(pos+best_length)*4)) != best_argb {
 				goto _10
 			}
 			curr_length1 = (*(*func(*libc.TLS, uintptr, uintptr, int32) int32)(unsafe.Pointer(&struct{ uintptr }{VP8LVectorMismatch})))(tls, argb+uintptr(pos)*4, argb_start, max_len)
 			if best_length < curr_length1 {
 				best_length = curr_length1
 				best_distance = base_position - libc.Uint32FromInt32(pos)
 				best_argb = **(**uint32_t)(__ccgo_up(argb_start + uintptr(best_length)*4))
 				// Stop if we have reached a good enough length.
 				if best_length >= length_max {
 					break
 				}
 			}
 			goto _10
 		_10:
 			;
 			pos = **(**int32_t)(__ccgo_up(chain + uintptr(pos)*4))
 		}
 		// We have the best match but in case the two intervals continue matching
 		// to the left, we have the best matches for the left-extended pixels.
 		max_base_position = base_position
 		for int32(1) != 0 {
 			**(**uint32_t)(__ccgo_up((*VP8LHashChain)(unsafe.Pointer(p)).Foffset_length + uintptr(base_position)*4)) = best_distance<<libc.Int32FromInt32(MAX_LENGTH_BITS) | libc.Uint32FromInt32(best_length)
 			base_position = base_position - 1
 			// Stop if we don't have a match or if we are out of bounds.
 			if best_distance == uint32(0) || base_position == uint32(0) {
 				break
 			}
 			// Stop if we cannot extend the matching intervals to the left.
 			if base_position < best_distance || **(**uint32_t)(__ccgo_up(argb + uintptr(base_position-best_distance)*4)) != **(**uint32_t)(__ccgo_up(argb + uintptr(base_position)*4)) {
 				break
 			}
 			// Stop if we are matching at its limit because there could be a closer
 			// matching interval with the same maximum length. Then again, if the
 			// matching interval is as close as possible (best_distance == 1), we will
 			// never find anything better so let's continue.
 			if best_length == libc.Int32FromInt32(1)<<libc.Int32FromInt32(MAX_LENGTH_BITS)-libc.Int32FromInt32(1) && best_distance != uint32(1) && base_position+libc.Uint32FromInt32(libc.Int32FromInt32(1)<<libc.Int32FromInt32(MAX_LENGTH_BITS)-libc.Int32FromInt32(1)) < max_base_position {
 				break
 			}
 			if best_length < libc.Int32FromInt32(1)<<libc.Int32FromInt32(MAX_LENGTH_BITS)-libc.Int32FromInt32(1) {
 				best_length = best_length + 1
 				max_base_position = base_position
 			}
 		}
 		if !(WebPReportProgress(tls, pic, libc.Int32FromUint32(libc.Uint32FromInt32(percent_start)+libc.Uint32FromInt32(percent_range)*(libc.Uint32FromInt32(size-int32(2))-base_position)/libc.Uint32FromInt32(size-libc.Int32FromInt32(2))), percent) != 0) {
 			return 0
 		}
 		goto _7
 	_7:
 	}
 	return WebPReportProgress(tls, pic, percent_start+percent_range, percent)
 }
 
 func AddSingleLiteral(tls *libc.TLS, pixel uint32_t, use_color_cache int32, hashers uintptr, refs uintptr) {
 	var key2, v5 uint32_t
 	var retval, retval1, v, v7 PixOrCopy
 	var v1, v3 int32
 	_, _, _, _, _, _, _, _ = key2, retval, retval1, v, v1, v3, v5, v7
 	if use_color_cache != 0 {
 		v3 = libc.Int32FromUint32(pixel * kHashMul11 >> (*VP8LColorCache)(unsafe.Pointer(hashers)).Fhash_shift)
 		goto _4
 	_4:
 		v1 = v3
 		goto _2
 	_2:
 		key2 = libc.Uint32FromInt32(v1)
 		v5 = **(**uint32_t)(__ccgo_up((*VP8LColorCache)(unsafe.Pointer(hashers)).Fcolors + uintptr(key2)*4))
 		goto _6
 	_6:
 		if v5 == pixel {
 			retval.Fmode = uint8(kCacheIdx)
 			retval.Fargb_or_distance = libc.Uint32FromInt32(libc.Int32FromUint32(key2))
 			retval.Flen1 = uint16(1)
 			v7 = retval
 			goto _8
 		_8:
 			v = v7
 		} else {
 			retval1.Fmode = uint8(kLiteral)
 			retval1.Fargb_or_distance = pixel
 			retval1.Flen1 = uint16(1)
 			v7 = retval1
 			goto _10
 		_10:
 			v = v7
 			**(**uint32_t)(__ccgo_up((*VP8LColorCache)(unsafe.Pointer(hashers)).Fcolors + uintptr(key2)*4)) = pixel
 		}
 	} else {
 		retval1.Fmode = uint8(kLiteral)
 		retval1.Fargb_or_distance = pixel
 		retval1.Flen1 = uint16(1)
 		v7 = retval1
 		goto _12
 	_12:
 		v = v7
 	}
 	VP8LBackwardRefsCursorAdd(tls, refs, v)
 }
 
 func BackwardReferencesRle(tls *libc.TLS, xsize int32, ysize int32, argb2 uintptr, cache_bits int32, refs uintptr) (r int32) {
 	bp := tls.Alloc(16)
 	defer tls.Free(16)
 	var i, k, key, max_len, pix_count, prev_row_len, rle_len, use_color_cache, v1 int32
 	var retval, v2 PixOrCopy
 	var v7 uintptr
 	var v8 uint32_t
 	var _ /* hashers at bp+0 */ VP8LColorCache
 	_, _, _, _, _, _, _, _, _, _, _, _, _ = i, k, key, max_len, pix_count, prev_row_len, retval, rle_len, use_color_cache, v1, v2, v7, v8
 	pix_count = xsize * ysize
 	use_color_cache = libc.BoolInt32(cache_bits > libc.Int32FromInt32(0))
 	if use_color_cache != 0 && !(VP8LColorCacheInit(tls, bp, cache_bits) != 0) {
 		return 0
 	}
 	VP8LClearBackwardRefs(tls, refs)
 	// Add first pixel as literal.
 	AddSingleLiteral(tls, **(**uint32_t)(__ccgo_up(argb2)), use_color_cache, bp, refs)
 	i = int32(1)
 	for i < pix_count {
 		max_len = MaxFindCopyLength(tls, pix_count-i)
 		rle_len = FindMatchLength(tls, argb2+uintptr(i)*4, argb2+uintptr(i)*4-uintptr(1)*4, 0, max_len)
 		if i < xsize {
 			v1 = 0
 		} else {
 			v1 = FindMatchLength(tls, argb2+uintptr(i)*4, argb2+uintptr(i)*4-uintptr(xsize)*4, 0, max_len)
 		}
 		prev_row_len = v1
 		if rle_len >= prev_row_len && rle_len >= int32(MIN_LENGTH) {
 			retval.Fmode = uint8(kCopy)
 			retval.Fargb_or_distance = uint32(1)
 			retval.Flen1 = libc.Uint16FromInt32(rle_len)
 			v2 = retval
 			goto _3
 		_3:
 			VP8LBackwardRefsCursorAdd(tls, refs, v2)
 			// We don't need to update the color cache here since it is always the
 			// same pixel being copied, and that does not change the color cache
 			// state.
 			i = i + rle_len
 		} else {
 			if prev_row_len >= int32(MIN_LENGTH) {
 				retval.Fmode = uint8(kCopy)
 				retval.Fargb_or_distance = libc.Uint32FromInt32(xsize)
 				retval.Flen1 = libc.Uint16FromInt32(prev_row_len)
 				v2 = retval
 				goto _5
 			_5:
 				VP8LBackwardRefsCursorAdd(tls, refs, v2)
 				if use_color_cache != 0 {
 					k = 0
 					for {
 						if !(k < prev_row_len) {
 							break
 						}
 						v7 = bp
 						v8 = **(**uint32_t)(__ccgo_up(argb2 + uintptr(i+k)*4))
 						v1 = libc.Int32FromUint32(v8 * kHashMul11 >> (*VP8LColorCache)(unsafe.Pointer(v7)).Fhash_shift)
 						goto _10
 					_10:
 						key = v1
 						**(**uint32_t)(__ccgo_up((*VP8LColorCache)(unsafe.Pointer(v7)).Fcolors + uintptr(key)*4)) = v8
 						goto _6
 					_6:
 						;
 						k = k + 1
 					}
 				}
 				i = i + prev_row_len
 			} else {
 				AddSingleLiteral(tls, **(**uint32_t)(__ccgo_up(argb2 + uintptr(i)*4)), use_color_cache, bp, refs)
 				i = i + 1
 			}
 		}
 	}
 	if use_color_cache != 0 {
 		VP8LColorCacheClear(tls, bp)
 	}
 	return libc.BoolInt32(!((*VP8LBackwardRefs)(unsafe.Pointer(refs)).Ferror1 != 0))
 }
 
 func BackwardReferencesLz77(tls *libc.TLS, xsize int32, ysize int32, argb2 uintptr, cache_bits int32, hash_chain uintptr, refs uintptr) (r int32) {
 	bp := tls.Alloc(32)
 	defer tls.Free(32)
 	var cc_init, i, i_last_check, j, j_max, key, len_ini, len_j, max_reach, ok, pix_count, reach, use_color_cache, v3, v4, v6 int32
 	var retval, v14 PixOrCopy
 	var v2 uintptr
 	var v18 uint32_t
 	var _ /* hashers at bp+0 */ VP8LColorCache
 	var _ /* len at bp+20 */ int32
 	var _ /* offset at bp+16 */ int32
 	_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = cc_init, i, i_last_check, j, j_max, key, len_ini, len_j, max_reach, ok, pix_count, reach, retval, use_color_cache, v14, v18, v2, v3, v4, v6
 	i_last_check = -int32(1)
 	ok = 0
 	cc_init = 0
 	use_color_cache = libc.BoolInt32(cache_bits > libc.Int32FromInt32(0))
 	pix_count = xsize * ysize
 	if use_color_cache != 0 {
 		cc_init = VP8LColorCacheInit(tls, bp, cache_bits)
 		if !(cc_init != 0) {
 			goto Error
 		}
 	}
 	VP8LClearBackwardRefs(tls, refs)
 	i = 0
 	for {
 		if !(i < pix_count) {
 			break
 		}
 		// Alternative#1: Code the pixels starting at 'i' using backward reference.
 		**(**int32)(__ccgo_up(bp + 16)) = 0
 		**(**int32)(__ccgo_up(bp + 20)) = 0
 		v2 = hash_chain
 		v3 = i
 		v4 = libc.Int32FromUint32(**(**uint32_t)(__ccgo_up((*VP8LHashChain)(unsafe.Pointer(v2)).Foffset_length + uintptr(v3)*4)) >> int32(MAX_LENGTH_BITS))
 		goto _5
 	_5:
 		**(**int32)(__ccgo_up(bp + 16)) = v4
 		v6 = libc.Int32FromUint32(**(**uint32_t)(__ccgo_up((*VP8LHashChain)(unsafe.Pointer(v2)).Foffset_length + uintptr(v3)*4)) & (libc.Uint32FromUint32(1)<<libc.Int32FromInt32(MAX_LENGTH_BITS) - libc.Uint32FromInt32(1)))
 		goto _7
 	_7:
 		**(**int32)(__ccgo_up(bp + 20)) = v6
 		if **(**int32)(__ccgo_up(bp + 20)) >= int32(MIN_LENGTH) {
 			len_ini = **(**int32)(__ccgo_up(bp + 20))
 			max_reach = 0
 			if i+len_ini >= pix_count {
 				v3 = pix_count - int32(1)
 			} else {
 				v3 = i + len_ini
 			}
 			j_max = v3
 			// Only start from what we have not checked already.
 			if i > i_last_check {
 				v4 = i
 			} else {
 				v4 = i_last_check
 			}
 			i_last_check = v4
 			// We know the best match for the current pixel but we try to find the
 			// best matches for the current pixel AND the next one combined.
 			// The naive method would use the intervals:
 			// [i,i+len) + [i+len, length of best match at i+len)
 			// while we check if we can use:
 			// [i,j) (where j<=i+len) + [j, length of best match at j)
 			j = i_last_check + int32(1)
 			for {
 				if !(j <= j_max) {
 					break
 				}
 				v3 = libc.Int32FromUint32(**(**uint32_t)(__ccgo_up((*VP8LHashChain)(unsafe.Pointer(hash_chain)).Foffset_length + uintptr(j)*4)) & (libc.Uint32FromUint32(1)<<libc.Int32FromInt32(MAX_LENGTH_BITS) - libc.Uint32FromInt32(1)))
 				goto _12
 			_12:
 				len_j = v3
 				if len_j >= int32(MIN_LENGTH) {
 					v4 = len_j
 				} else {
 					v4 = int32(1)
 				}
 				reach = j + v4 // 1 for single literal.
 				if reach > max_reach {
 					**(**int32)(__ccgo_up(bp + 20)) = j - i
 					max_reach = reach
 					if max_reach >= pix_count {
 						break
 					}
 				}
 				goto _10
 			_10:
 				;
 				j = j + 1
 			}
 		} else {
 			**(**int32)(__ccgo_up(bp + 20)) = int32(1)
 		}
 		// Go with literal or backward reference.
 		if **(**int32)(__ccgo_up(bp + 20)) == int32(1) {
 			AddSingleLiteral(tls, **(**uint32_t)(__ccgo_up(argb2 + uintptr(i)*4)), use_color_cache, bp, refs)
 		} else {
 			retval.Fmode = uint8(kCopy)
 			retval.Fargb_or_distance = libc.Uint32FromInt32(**(**int32)(__ccgo_up(bp + 16)))
 			retval.Flen1 = libc.Uint16FromInt32(**(**int32)(__ccgo_up(bp + 20)))
 			v14 = retval
 			goto _15
 		_15:
 			VP8LBackwardRefsCursorAdd(tls, refs, v14)
 			if use_color_cache != 0 {
 				j = i
 				for {
 					if !(j < i+**(**int32)(__ccgo_up(bp + 20))) {
 						break
 					}
 					v2 = bp
 					v18 = **(**uint32_t)(__ccgo_up(argb2 + uintptr(j)*4))
 					v3 = libc.Int32FromUint32(v18 * kHashMul11 >> (*VP8LColorCache)(unsafe.Pointer(v2)).Fhash_shift)
 					goto _20
 				_20:
 					key = v3
 					**(**uint32_t)(__ccgo_up((*VP8LColorCache)(unsafe.Pointer(v2)).Fcolors + uintptr(key)*4)) = v18
 					goto _16
 				_16:
 					;
 					j = j + 1
 				}
 			}
 		}
 		i = i + **(**int32)(__ccgo_up(bp + 20))
 		goto _1
 	_1:
 	}
 	ok = libc.BoolInt32(!((*VP8LBackwardRefs)(unsafe.Pointer(refs)).Ferror1 != 0))
 	goto Error
 Error:
 	;
 	if cc_init != 0 {
 		VP8LColorCacheClear(tls, bp)
 	}
 	return ok
 }
 
 // C documentation
 //
 //	// Compute an LZ77 by forcing matches to happen within a given distance cost.
 //	// We therefore limit the algorithm to the lowest 32 values in the PlaneCode
 //	// definition.
 func BackwardReferencesLz77Box(tls *libc.TLS, xsize int32, ysize int32, argb uintptr, cache_bits int32, hash_chain_best uintptr, hash_chain uintptr, refs uintptr) (r int32) {
 	var best_length, best_length_prev, best_offset, best_offset_prev, counts_j, counts_j_offset, curr_length, do_compute, i, ind, is_reachable, j, j1, j_offset, num_ind, offset, pix_count, plane_code, use_prev, window_offsets_new_size, window_offsets_size, x, y, v5, v9 int32
 	var counts, counts_ini uintptr
 	var window_offsets, window_offsets_new [32]int32
 	_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = best_length, best_length_prev, best_offset, best_offset_prev, counts, counts_ini, counts_j, counts_j_offset, curr_length, do_compute, i, ind, is_reachable, j, j1, j_offset, num_ind, offset, pix_count, plane_code, use_prev, window_offsets, window_offsets_new, window_offsets_new_size, window_offsets_size, x, y, v5, v9
 	pix_count = xsize * ysize
 	window_offsets = [32]int32{}
 	window_offsets_new = [32]int32{}
 	window_offsets_size = 0
 	window_offsets_new_size = 0
 	counts_ini = WebPSafeMalloc(tls, libc.Uint64FromInt32(xsize*ysize), uint64(2))
 	best_offset_prev = -int32(1)
 	best_length_prev = -int32(1)
 	if counts_ini == libc.UintptrFromInt32(0) {
 		return 0
 	}
 	// counts[i] counts how many times a pixel is repeated starting at position i.
 	i = pix_count - int32(2)
 	counts = counts_ini + uintptr(i)*2
 	**(**uint16_t)(__ccgo_up(counts + 1*2)) = uint16(1)
 	for {
 		if !(i >= 0) {
 			break
 		}
 		if **(**uint32_t)(__ccgo_up(argb + uintptr(i)*4)) == **(**uint32_t)(__ccgo_up(argb + uintptr(i+int32(1))*4)) {
 			// Max out the counts to MAX_LENGTH.
 			**(**uint16_t)(__ccgo_up(counts)) = libc.Uint16FromInt32(libc.Int32FromUint16(**(**uint16_t)(__ccgo_up(counts + 1*2))) + libc.BoolInt32(libc.Int32FromUint16(**(**uint16_t)(__ccgo_up(counts + 1*2))) != libc.Int32FromInt32(1)<<libc.Int32FromInt32(MAX_LENGTH_BITS)-libc.Int32FromInt32(1)))
 		} else {
 			**(**uint16_t)(__ccgo_up(counts)) = uint16(1)
 		}
 		goto _1
 	_1:
 		;
 		i = i - 1
 		counts -= 2
 	}
 	// Figure out the window offsets around a pixel. They are stored in a
 	// spiraling order around the pixel as defined by VP8LDistanceToPlaneCode.
 	y = 0
 	for {
 		if !(y <= int32(6)) {
 			break
 		}
 		x = -int32(6)
 		for {
 			if !(x <= int32(6)) {
 				break
 			}
 			offset = y*xsize + x
 			// Ignore offsets that bring us after the pixel.
 			if offset <= 0 {
 				goto _3
 			}
 			plane_code = VP8LDistanceToPlaneCode(tls, xsize, offset) - int32(1)
 			if plane_code >= int32(WINDOW_OFFSETS_SIZE_MAX) {
 				goto _3
 			}
 			window_offsets[plane_code] = offset
 			goto _3
 		_3:
 			;
 			x = x + 1
 		}
 		goto _2
 	_2:
 		;
 		y = y + 1
 	}
 	// For narrow images, not all plane codes are reached, so remove those.
 	i = 0
 	for {
 		if !(i < int32(WINDOW_OFFSETS_SIZE_MAX)) {
 			break
 		}
 		if window_offsets[i] == 0 {
 			goto _4
 		}
 		v5 = window_offsets_size
 		window_offsets_size = window_offsets_size + 1
 		window_offsets[v5] = window_offsets[i]
 		goto _4
 	_4:
 		;
 		i = i + 1
 	}
 	// Given a pixel P, find the offsets that reach pixels unreachable from P-1
 	// with any of the offsets in window_offsets[].
 	i = 0
 	for {
 		if !(i < window_offsets_size) {
 			break
 		}
 		is_reachable = 0
 		j = 0
 		for {
 			if !(j < window_offsets_size && !(is_reachable != 0)) {
 				break
 			}
 			is_reachable = is_reachable | libc.BoolInt32(window_offsets[i] == window_offsets[j]+int32(1))
 			goto _7
 		_7:
 			;
 			j = j + 1
 		}
 		if !(is_reachable != 0) {
 			window_offsets_new[window_offsets_new_size] = window_offsets[i]
 			window_offsets_new_size = window_offsets_new_size + 1
 		}
 		goto _6
 	_6:
 		;
 		i = i + 1
 	}
 	**(**uint32_t)(__ccgo_up((*VP8LHashChain)(unsafe.Pointer(hash_chain)).Foffset_length)) = uint32(0)
 	i = int32(1)
 	for {
 		if !(i < pix_count) {
 			break
 		}
 		v5 = libc.Int32FromUint32(**(**uint32_t)(__ccgo_up((*VP8LHashChain)(unsafe.Pointer(hash_chain_best)).Foffset_length + uintptr(i)*4)) & (libc.Uint32FromUint32(1)<<libc.Int32FromInt32(MAX_LENGTH_BITS) - libc.Uint32FromInt32(1)))
 		goto _10
 	_10:
 		best_length = v5
 		do_compute = int32(1)
 		if best_length >= libc.Int32FromInt32(1)<<libc.Int32FromInt32(MAX_LENGTH_BITS)-libc.Int32FromInt32(1) {
 			// Do not recompute the best match if we already have a maximal one in the
 			// window.
 			v9 = libc.Int32FromUint32(**(**uint32_t)(__ccgo_up((*VP8LHashChain)(unsafe.Pointer(hash_chain_best)).Foffset_length + uintptr(i)*4)) >> int32(MAX_LENGTH_BITS))
 			goto _12
 		_12:
 			best_offset = v9
 			ind = 0
 			for {
 				if !(ind < window_offsets_size) {
 					break
 				}
 				if best_offset == window_offsets[ind] {
 					do_compute = 0
 					break
 				}
 				goto _13
 			_13:
 				;
 				ind = ind + 1
 			}
 		}
 		if do_compute != 0 {
 			// Figure out if we should use the offset/length from the previous pixel
 			// as an initial guess and therefore only inspect the offsets in
 			// window_offsets_new[].
 			use_prev = libc.BoolInt32(best_length_prev > int32(1) && best_length_prev < libc.Int32FromInt32(1)<<libc.Int32FromInt32(MAX_LENGTH_BITS)-libc.Int32FromInt32(1))
 			if use_prev != 0 {
 				v5 = window_offsets_new_size
 			} else {
 				v5 = window_offsets_size
 			}
 			num_ind = v5
 			if use_prev != 0 {
 				v9 = best_length_prev - int32(1)
 			} else {
 				v9 = 0
 			}
 			best_length = v9
 			if use_prev != 0 {
 				v5 = best_offset_prev
 			} else {
 				v5 = 0
 			}
 			best_offset = v5
 			// Find the longest match in a window around the pixel.
 			ind = 0
 			for {
 				if !(ind < num_ind) {
 					break
 				}
 				curr_length = 0
 				j1 = i
 				if use_prev != 0 {
 					v5 = i - window_offsets_new[ind]
 				} else {
 					v5 = i - window_offsets[ind]
 				}
 				j_offset = v5
 				if j_offset < 0 || **(**uint32_t)(__ccgo_up(argb + uintptr(j_offset)*4)) != **(**uint32_t)(__ccgo_up(argb + uintptr(i)*4)) {
 					goto _17
 				}
 				// The longest match is the sum of how many times each pixel is
 				// repeated.
 				for cond := true; cond; cond = curr_length <= libc.Int32FromInt32(1)<<libc.Int32FromInt32(MAX_LENGTH_BITS)-libc.Int32FromInt32(1) && j1 < pix_count && **(**uint32_t)(__ccgo_up(argb + uintptr(j_offset)*4)) == **(**uint32_t)(__ccgo_up(argb + uintptr(j1)*4)) {
 					counts_j_offset = libc.Int32FromUint16(**(**uint16_t)(__ccgo_up(counts_ini + uintptr(j_offset)*2)))
 					counts_j = libc.Int32FromUint16(**(**uint16_t)(__ccgo_up(counts_ini + uintptr(j1)*2)))
 					if counts_j_offset != counts_j {
 						if counts_j_offset < counts_j {
 							v5 = counts_j_offset
 						} else {
 							v5 = counts_j
 						}
 						curr_length = curr_length + v5
 						break
 					}
 					// The same color is repeated counts_pos times at j_offset and j.
 					curr_length = curr_length + counts_j_offset
 					j_offset = j_offset + counts_j_offset
 					j1 = j1 + counts_j_offset
 				}
 				if best_length < curr_length {
 					if use_prev != 0 {
 						v5 = window_offsets_new[ind]
 					} else {
 						v5 = window_offsets[ind]
 					}
 					best_offset = v5
 					if curr_length >= libc.Int32FromInt32(1)<<libc.Int32FromInt32(MAX_LENGTH_BITS)-libc.Int32FromInt32(1) {
 						best_length = libc.Int32FromInt32(1)<<libc.Int32FromInt32(MAX_LENGTH_BITS) - libc.Int32FromInt32(1)
 						break
 					} else {
 						best_length = curr_length
 					}
 				}
 				goto _17
 			_17:
 				;
 				ind = ind + 1
 			}
 		}
 		if best_length <= int32(MIN_LENGTH) {
 			**(**uint32_t)(__ccgo_up((*VP8LHashChain)(unsafe.Pointer(hash_chain)).Foffset_length + uintptr(i)*4)) = uint32(0)
 			best_offset_prev = 0
 			best_length_prev = 0
 		} else {
 			**(**uint32_t)(__ccgo_up((*VP8LHashChain)(unsafe.Pointer(hash_chain)).Foffset_length + uintptr(i)*4)) = libc.Uint32FromInt32(best_offset<<libc.Int32FromInt32(MAX_LENGTH_BITS)) | libc.Uint32FromInt32(best_length)
 			best_offset_prev = best_offset
 			best_length_prev = best_length
 		}
 		goto _8
 	_8:
 		;
 		i = i + 1
 	}
 	**(**uint32_t)(__ccgo_up((*VP8LHashChain)(unsafe.Pointer(hash_chain)).Foffset_length)) = uint32(0)
 	WebPSafeFree(tls, counts_ini)
 	return BackwardReferencesLz77(tls, xsize, ysize, argb, cache_bits, hash_chain, refs)
 }
 
 // -----------------------------------------------------------------------------
 
 func BackwardReferences2DLocality(tls *libc.TLS, xsize int32, refs uintptr) {
 	bp := tls.Alloc(32)
 	defer tls.Free(32)
 	var dist, transformed_dist, v1, v3 int32
 	var v5, v6, v7 uintptr
 	var _ /* c at bp+0 */ VP8LRefsCursor
 	_, _, _, _, _, _, _ = dist, transformed_dist, v1, v3, v5, v6, v7
 	**(**VP8LRefsCursor)(__ccgo_up(bp)) = VP8LRefsCursorInit(tls, refs)
 	for {
 		v1 = libc.BoolInt32((*VP8LRefsCursor)(unsafe.Pointer(bp)).Fcur_pos != libc.UintptrFromInt32(0))
 		goto _2
 	_2:
 		if !(v1 != 0) {
 			break
 		}
 		v3 = libc.BoolInt32(libc.Int32FromUint8((*PixOrCopy)(unsafe.Pointer((**(**VP8LRefsCursor)(__ccgo_up(bp))).Fcur_pos)).Fmode) == int32(kCopy))
 		goto _4
 	_4:
 		if v3 != 0 {
 			dist = libc.Int32FromUint32((*PixOrCopy)(unsafe.Pointer((**(**VP8LRefsCursor)(__ccgo_up(bp))).Fcur_pos)).Fargb_or_distance)
 			transformed_dist = VP8LDistanceToPlaneCode(tls, xsize, dist)
 			(*PixOrCopy)(unsafe.Pointer((**(**VP8LRefsCursor)(__ccgo_up(bp))).Fcur_pos)).Fargb_or_distance = libc.Uint32FromInt32(transformed_dist)
 		}
 		v5 = bp
 		v7 = v5
 		*(*uintptr)(unsafe.Pointer(v7)) += 8
 		v6 = *(*uintptr)(unsafe.Pointer(v7))
 		if v6 == (*VP8LRefsCursor)(unsafe.Pointer(v5)).Flast_pos {
 			VP8LRefsCursorNextBlock(tls, v5)
 		}
 	}
 }
 
 // C documentation
 //
 //	// Evaluate optimal cache bits for the local color cache.
 //	// The input *best_cache_bits sets the maximum cache bits to use (passing 0
 //	// implies disabling the local color cache). The local color cache is also
 //	// disabled for the lower (<= 25) quality.
 //	// Returns 0 in case of memory error.
 func CalculateBestCacheSize(tls *libc.TLS, argb2 uintptr, quality int32, refs uintptr, best_cache_bits uintptr) (r1 int32) {
 	bp := tls.Alloc(224)
 	defer tls.Free(224)
 	var a, argb_prev, b, g, pix, r, v11 uint32_t
 	var cache_bits_max, highest_bit, i, key2, key3, len1, ok, second_highest_bit, v1, v3, v5, v8 int32
 	var cc_init [11]int32
 	var entropy, entropy_min uint64_t
 	var histos [11]uintptr
 	var prefix_code VP8LPrefixCode
 	var v, v16, v17, v18, v7 uintptr
 	var _ /* c at bp+176 */ VP8LRefsCursor
 	var _ /* code at bp+200 */ int32
 	var _ /* extra_bits at bp+204 */ int32
 	var _ /* extra_bits_value at bp+208 */ int32
 	var _ /* hashers at bp+0 */ [11]VP8LColorCache
 	_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = a, argb_prev, b, cache_bits_max, cc_init, entropy, entropy_min, g, highest_bit, histos, i, key2, key3, len1, ok, pix, prefix_code, r, second_highest_bit, v, v1, v11, v16, v17, v18, v3, v5, v7, v8
 	if quality <= int32(25) {
 		v1 = 0
 	} else {
 		v1 = **(**int32)(__ccgo_up(best_cache_bits))
 	}
 	cache_bits_max = v1
 	entropy_min = ^libc.Uint64FromUint64(0)
 	cc_init = [11]int32{}
 	**(**VP8LRefsCursor)(__ccgo_up(bp + 176)) = VP8LRefsCursorInit(tls, refs)
 	histos = [11]uintptr{}
 	ok = 0
 	if cache_bits_max == 0 {
 		**(**int32)(__ccgo_up(best_cache_bits)) = 0
 		// Local color cache is disabled.
 		return int32(1)
 	}
 	// Allocate data.
 	i = 0
 	for {
 		if !(i <= cache_bits_max) {
 			break
 		}
 		histos[i] = VP8LAllocateHistogram(tls, i)
 		if histos[i] == libc.UintptrFromInt32(0) {
 			goto Error
 		}
 		VP8LHistogramInit(tls, histos[i], i, int32(1))
 		if i == 0 {
 			goto _2
 		}
 		cc_init[i] = VP8LColorCacheInit(tls, bp+uintptr(i)*16, i)
 		if !(cc_init[i] != 0) {
 			goto Error
 		}
 		goto _2
 	_2:
 		;
 		i = i + 1
 	}
 	// Find the cache_bits giving the lowest entropy. The search is done in a
 	// brute-force way as the function (entropy w.r.t cache_bits) can be
 	// anything in practice.
 	for {
 		v1 = libc.BoolInt32((*VP8LRefsCursor)(unsafe.Pointer(bp+176)).Fcur_pos != libc.UintptrFromInt32(0))
 		goto _4
 	_4:
 		if !(v1 != 0) {
 			break
 		}
 		v = (**(**VP8LRefsCursor)(__ccgo_up(bp + 176))).Fcur_pos
 		v3 = libc.BoolInt32(libc.Int32FromUint8((*PixOrCopy)(unsafe.Pointer(v)).Fmode) == int32(kLiteral))
 		goto _6
 	_6:
 		if v3 != 0 {
 			v7 = argb2
 			argb2 += 4
 			pix = **(**uint32_t)(__ccgo_up(v7))
 			a = pix >> libc.Int32FromInt32(24) & uint32(0xff)
 			r = pix >> libc.Int32FromInt32(16) & uint32(0xff)
 			g = pix >> libc.Int32FromInt32(8) & uint32(0xff)
 			b = pix >> libc.Int32FromInt32(0) & uint32(0xff)
 			v5 = libc.Int32FromUint32(pix * kHashMul11 >> (int32(32) - cache_bits_max))
 			goto _9
 		_9:
 			// The keys of the caches can be derived from the longest one.
 			key2 = v5
 			// Do not use the color cache for cache_bits = 0.
 			**(**uint32_t)(__ccgo_up(histos[0] + 1032 + uintptr(b)*4)) = **(**uint32_t)(__ccgo_up(histos[0] + 1032 + uintptr(b)*4)) + 1
 			**(**uint32_t)(__ccgo_up((*VP8LHistogram)(unsafe.Pointer(histos[0])).Fliteral + uintptr(g)*4)) = **(**uint32_t)(__ccgo_up((*VP8LHistogram)(unsafe.Pointer(histos[0])).Fliteral + uintptr(g)*4)) + 1
 			**(**uint32_t)(__ccgo_up(histos[0] + 8 + uintptr(r)*4)) = **(**uint32_t)(__ccgo_up(histos[0] + 8 + uintptr(r)*4)) + 1
 			**(**uint32_t)(__ccgo_up(histos[0] + 2056 + uintptr(a)*4)) = **(**uint32_t)(__ccgo_up(histos[0] + 2056 + uintptr(a)*4)) + 1
 			// Deal with cache_bits > 0.
 			i = cache_bits_max
 			for {
 				if !(i >= int32(1)) {
 					break
 				}
 				v11 = **(**uint32_t)(__ccgo_up((*VP8LColorCache)(unsafe.Pointer(bp+uintptr(i)*16)).Fcolors + uintptr(libc.Uint32FromInt32(key2))*4))
 				goto _12
 			_12:
 				if v11 == pix {
 					**(**uint32_t)(__ccgo_up((*VP8LHistogram)(unsafe.Pointer(histos[i])).Fliteral + uintptr(libc.Int32FromInt32(NUM_LITERAL_CODES)+libc.Int32FromInt32(NUM_LENGTH_CODES)+key2)*4)) = **(**uint32_t)(__ccgo_up((*VP8LHistogram)(unsafe.Pointer(histos[i])).Fliteral + uintptr(libc.Int32FromInt32(NUM_LITERAL_CODES)+libc.Int32FromInt32(NUM_LENGTH_CODES)+key2)*4)) + 1
 				} else {
 					**(**uint32_t)(__ccgo_up((*VP8LColorCache)(unsafe.Pointer(bp+uintptr(i)*16)).Fcolors + uintptr(libc.Uint32FromInt32(key2))*4)) = pix
 					**(**uint32_t)(__ccgo_up(histos[i] + 1032 + uintptr(b)*4)) = **(**uint32_t)(__ccgo_up(histos[i] + 1032 + uintptr(b)*4)) + 1
 					**(**uint32_t)(__ccgo_up((*VP8LHistogram)(unsafe.Pointer(histos[i])).Fliteral + uintptr(g)*4)) = **(**uint32_t)(__ccgo_up((*VP8LHistogram)(unsafe.Pointer(histos[i])).Fliteral + uintptr(g)*4)) + 1
 					**(**uint32_t)(__ccgo_up(histos[i] + 8 + uintptr(r)*4)) = **(**uint32_t)(__ccgo_up(histos[i] + 8 + uintptr(r)*4)) + 1
 					**(**uint32_t)(__ccgo_up(histos[i] + 2056 + uintptr(a)*4)) = **(**uint32_t)(__ccgo_up(histos[i] + 2056 + uintptr(a)*4)) + 1
 				}
 				goto _10
 			_10:
 				;
 				i = i - 1
 				key2 = key2 >> int32(1)
 			}
 		} else {
 			v11 = uint32((*PixOrCopy)(unsafe.Pointer(v)).Flen1)
 			goto _14
 		_14:
 			// We should compute the contribution of the (distance,length)
 			// histograms but those are the same independently from the cache size.
 			// As those constant contributions are in the end added to the other
 			// histogram contributions, we can ignore them, except for the length
 			// prefix that is part of the 'literal' histogram.
 			len1 = libc.Int32FromUint32(v11)
 			argb_prev = **(**uint32_t)(__ccgo_up(argb2)) ^ uint32(0xffffffff)
 			v1 = len1
 			v7 = bp + 200
 			v16 = bp + 204
 			v17 = bp + 208
 			if v1 < libc.Int32FromInt32(PREFIX_LOOKUP_IDX_MAX) {
 				prefix_code = kPrefixEncodeCode[v1]
 				**(**int32)(__ccgo_up(v7)) = int32(prefix_code.Fcode)
 				**(**int32)(__ccgo_up(v16)) = int32(prefix_code.Fextra_bits)
 				**(**int32)(__ccgo_up(v17)) = libc.Int32FromUint8(kPrefixEncodeExtraBitsValue[v1])
 			} else {
 				v3 = v1
 				v18 = v16
 				v3 = v3 - 1
 				v5 = v3
 				v8 = int32(31) ^ libc.X__builtin_clz(tls, libc.Uint32FromInt32(v5))
 				goto _23
 			_23:
 				highest_bit = v8
 				second_highest_bit = v3 >> (highest_bit - int32(1)) & int32(1)
 				**(**int32)(__ccgo_up(v18)) = highest_bit - int32(1)
 				**(**int32)(__ccgo_up(v17)) = v3 & (int32(1)<<**(**int32)(__ccgo_up(v18)) - int32(1))
 				**(**int32)(__ccgo_up(v7)) = int32(2)*highest_bit + second_highest_bit
 			}
 			i = 0
 			for {
 				if !(i <= cache_bits_max) {
 					break
 				}
 				**(**uint32_t)(__ccgo_up((*VP8LHistogram)(unsafe.Pointer(histos[i])).Fliteral + uintptr(int32(NUM_LITERAL_CODES)+**(**int32)(__ccgo_up(bp + 200)))*4)) = **(**uint32_t)(__ccgo_up((*VP8LHistogram)(unsafe.Pointer(histos[i])).Fliteral + uintptr(int32(NUM_LITERAL_CODES)+**(**int32)(__ccgo_up(bp + 200)))*4)) + 1
 				goto _24
 			_24:
 				;
 				i = i + 1
 			}
 			// Update the color caches.
 			for {
 				if **(**uint32_t)(__ccgo_up(argb2)) != argb_prev {
 					v3 = libc.Int32FromUint32(**(**uint32_t)(__ccgo_up(argb2)) * kHashMul11 >> (int32(32) - cache_bits_max))
 					goto _28
 				_28:
 					// Efficiency: insert only if the color changes.
 					key3 = v3
 					i = cache_bits_max
 					for {
 						if !(i >= int32(1)) {
 							break
 						}
 						**(**uint32_t)(__ccgo_up((**(**[11]VP8LColorCache)(__ccgo_up(bp)))[i].Fcolors + uintptr(key3)*4)) = **(**uint32_t)(__ccgo_up(argb2))
 						goto _29
 					_29:
 						;
 						i = i - 1
 						key3 = key3 >> int32(1)
 					}
 					argb_prev = **(**uint32_t)(__ccgo_up(argb2))
 				}
 				argb2 += 4
 				goto _26
 			_26:
 				;
 				len1 = len1 - 1
 				v1 = len1
 				if !(v1 != 0) {
 					break
 				}
 			}
 		}
 		v7 = bp + 176
 		v17 = v7
 		*(*uintptr)(unsafe.Pointer(v17)) += 8
 		v16 = *(*uintptr)(unsafe.Pointer(v17))
 		if v16 == (*VP8LRefsCursor)(unsafe.Pointer(v7)).Flast_pos {
 			VP8LRefsCursorNextBlock(tls, v7)
 		}
 	}
 	i = 0
 	for {
 		if !(i <= cache_bits_max) {
 			break
 		}
 		entropy = VP8LHistogramEstimateBits(tls, histos[i])
 		if i == 0 || entropy < entropy_min {
 			entropy_min = entropy
 			**(**int32)(__ccgo_up(best_cache_bits)) = i
 		}
 		goto _33
 	_33:
 		;
 		i = i + 1
 	}
 	ok = int32(1)
 	goto Error
 Error:
 	;
 	i = 0
 	for {
 		if !(i <= cache_bits_max) {
 			break
 		}
 		if cc_init[i] != 0 {
 			VP8LColorCacheClear(tls, bp+uintptr(i)*16)
 		}
 		VP8LFreeHistogram(tls, histos[i])
 		goto _34
 	_34:
 		;
 		i = i + 1
 	}
 	return ok
 }
 
 // C documentation
 //
 //	// Update (in-place) backward references for specified cache_bits.
 func BackwardRefsWithLocalCache(tls *libc.TLS, argb3 uintptr, cache_bits int32, refs uintptr) (r int32) {
 	bp := tls.Alloc(48)
 	defer tls.Free(48)
 	var argb_literal, v6 uint32_t
 	var ix, k, key, key1, pixel_index, v1, v11, v3, v7, v9 int32
 	var retval, v12 PixOrCopy
 	var v, v14, v20, v5 uintptr
 	var _ /* c at bp+16 */ VP8LRefsCursor
 	var _ /* hashers at bp+0 */ VP8LColorCache
 	_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = argb_literal, ix, k, key, key1, pixel_index, retval, v, v1, v11, v12, v14, v20, v3, v5, v6, v7, v9
 	pixel_index = 0
 	**(**VP8LRefsCursor)(__ccgo_up(bp + 16)) = VP8LRefsCursorInit(tls, refs)
 	if !(VP8LColorCacheInit(tls, bp, cache_bits) != 0) {
 		return 0
 	}
 	for {
 		v1 = libc.BoolInt32((*VP8LRefsCursor)(unsafe.Pointer(bp+16)).Fcur_pos != libc.UintptrFromInt32(0))
 		goto _2
 	_2:
 		if !(v1 != 0) {
 			break
 		}
 		v = (**(**VP8LRefsCursor)(__ccgo_up(bp + 16))).Fcur_pos
 		v3 = libc.BoolInt32(libc.Int32FromUint8((*PixOrCopy)(unsafe.Pointer(v)).Fmode) == int32(kLiteral))
 		goto _4
 	_4:
 		if v3 != 0 {
 			argb_literal = (*PixOrCopy)(unsafe.Pointer(v)).Fargb_or_distance
 			v5 = bp
 			v6 = argb_literal
 			v7 = libc.Int32FromUint32(v6 * kHashMul11 >> (*VP8LColorCache)(unsafe.Pointer(v5)).Fhash_shift)
 			goto _8
 		_8:
 			key1 = v7
 			if **(**uint32_t)(__ccgo_up((*VP8LColorCache)(unsafe.Pointer(v5)).Fcolors + uintptr(key1)*4)) == v6 {
 				v11 = key1
 			} else {
 				v11 = -int32(1)
 			}
 			v9 = v11
 			goto _10
 		_10:
 			ix = v9
 			if ix >= 0 {
 				// hashers contains argb_literal
 				retval.Fmode = uint8(kCacheIdx)
 				retval.Fargb_or_distance = libc.Uint32FromInt32(ix)
 				retval.Flen1 = uint16(1)
 				v12 = retval
 				goto _13
 			_13:
 				**(**PixOrCopy)(__ccgo_up(v)) = v12
 			} else {
 				v5 = bp
 				v6 = argb_literal
 				v1 = libc.Int32FromUint32(v6 * kHashMul11 >> (*VP8LColorCache)(unsafe.Pointer(v5)).Fhash_shift)
 				goto _17
 			_17:
 				key = v1
 				**(**uint32_t)(__ccgo_up((*VP8LColorCache)(unsafe.Pointer(v5)).Fcolors + uintptr(key)*4)) = v6
 			}
 			pixel_index = pixel_index + 1
 		} else {
 			k = 0
 			for {
 				if !(k < libc.Int32FromUint16((*PixOrCopy)(unsafe.Pointer(v)).Flen1)) {
 					break
 				}
 				v1 = pixel_index
 				pixel_index = pixel_index + 1
 				v5 = bp
 				v6 = **(**uint32_t)(__ccgo_up(argb3 + uintptr(v1)*4))
 				v3 = libc.Int32FromUint32(v6 * kHashMul11 >> (*VP8LColorCache)(unsafe.Pointer(v5)).Fhash_shift)
 				goto _23
 			_23:
 				key = v3
 				**(**uint32_t)(__ccgo_up((*VP8LColorCache)(unsafe.Pointer(v5)).Fcolors + uintptr(key)*4)) = v6
 				goto _18
 			_18:
 				;
 				k = k + 1
 			}
 		}
 		v5 = bp + 16
 		v20 = v5
 		*(*uintptr)(unsafe.Pointer(v20)) += 8
 		v14 = *(*uintptr)(unsafe.Pointer(v20))
 		if v14 == (*VP8LRefsCursor)(unsafe.Pointer(v5)).Flast_pos {
 			VP8LRefsCursorNextBlock(tls, v5)
 		}
 	}
 	VP8LColorCacheClear(tls, bp)
 	return int32(1)
 }
 
 func GetBackwardReferencesLowEffort(tls *libc.TLS, width int32, height int32, argb uintptr, cache_bits uintptr, hash_chain uintptr, refs_lz77 uintptr) (r uintptr) {
 	**(**int32)(__ccgo_up(cache_bits)) = 0
 	if !(BackwardReferencesLz77(tls, width, height, argb, 0, hash_chain, refs_lz77) != 0) {
 		return libc.UintptrFromInt32(0)
 	}
 	BackwardReferences2DLocality(tls, width, refs_lz77)
 	return refs_lz77
 }
 
 func GetBackwardReferences(tls *libc.TLS, width int32, height int32, argb uintptr, quality int32, lz77_types_to_try int32, cache_bits_max int32, do_no_cache int32, hash_chain uintptr, refs uintptr, cache_bits_best uintptr) (r int32) {
 	bp := tls.Alloc(32)
 	defer tls.Free(32)
 	var bit_cost, bit_cost_trace uint64_t
 	var bit_costs_best [2]uint64_t
 	var cache_bits1, i, lz77_type, res, status, v1 int32
 	var hash_chain_tmp, histo, refs_tmp, v6 uintptr
 	var lz77_types_best [2]int32
 	var _ /* cache_bits at bp+16 */ int32
 	var _ /* hash_chain_box at bp+0 */ VP8LHashChain
 	_, _, _, _, _, _, _, _, _, _, _, _, _, _ = bit_cost, bit_cost_trace, bit_costs_best, cache_bits1, hash_chain_tmp, histo, i, lz77_type, lz77_types_best, refs_tmp, res, status, v1, v6
 	histo = libc.UintptrFromInt32(0)
 	// Index 0 is for a color cache, index 1 for no cache (if needed).
 	lz77_types_best = [2]int32{}
 	bit_costs_best = [2]uint64_t{
 		0: ^libc.Uint64FromUint64(0),
 		1: ^libc.Uint64FromUint64(0),
 	}
 	if do_no_cache != 0 {
 		v1 = int32(2)
 	} else {
 		v1 = int32(1)
 	}
 	refs_tmp = refs + uintptr(v1)*40
 	status = 0
 	libc.X__builtin___memset_chk(tls, bp, 0, uint64(16), ^__predefined_size_t(0))
 	histo = VP8LAllocateHistogram(tls, int32(MAX_COLOR_CACHE_BITS))
 	if histo == libc.UintptrFromInt32(0) {
 		goto Error
 	}
 	lz77_type = int32(1)
 	for {
 		if !(lz77_types_to_try != 0) {
 			break
 		}
 		res = 0
 		bit_cost = 0
 		if lz77_types_to_try&lz77_type == 0 {
 			goto _2
 		}
 		switch lz77_type {
 		case int32(kLZ77RLE):
 			res = BackwardReferencesRle(tls, width, height, argb, 0, refs_tmp)
 		case int32(kLZ77Standard):
 			// Compute LZ77 with no cache (0 bits), as the ideal LZ77 with a color
 			// cache is not that different in practice.
 			res = BackwardReferencesLz77(tls, width, height, argb, 0, hash_chain, refs_tmp)
 		case int32(kLZ77Box):
 			if !(VP8LHashChainInit(tls, bp, width*height) != 0) {
 				goto Error
 			}
 			res = BackwardReferencesLz77Box(tls, width, height, argb, 0, hash_chain, bp, refs_tmp)
 		default:
 		}
 		if !(res != 0) {
 			goto Error
 		}
 		// Start with the no color cache case.
 		i = int32(1)
 		for {
 			if !(i >= 0) {
 				break
 			}
 			if i == int32(1) {
 				v1 = 0
 			} else {
 				v1 = cache_bits_max
 			}
 			**(**int32)(__ccgo_up(bp + 16)) = v1
 			if i == int32(1) && !(do_no_cache != 0) {
 				goto _3
 			}
 			if i == 0 {
 				// Try with a color cache.
 				if !(CalculateBestCacheSize(tls, argb, quality, refs_tmp, bp+16) != 0) {
 					goto Error
 				}
 				if **(**int32)(__ccgo_up(bp + 16)) > 0 {
 					if !(BackwardRefsWithLocalCache(tls, argb, **(**int32)(__ccgo_up(bp + 16)), refs_tmp) != 0) {
 						goto Error
 					}
 				}
 			}
 			if i == 0 && do_no_cache != 0 && **(**int32)(__ccgo_up(bp + 16)) == 0 {
 				// No need to re-compute bit_cost as it was computed at i == 1.
 			} else {
 				VP8LHistogramCreate(tls, histo, refs_tmp, **(**int32)(__ccgo_up(bp + 16)))
 				bit_cost = VP8LHistogramEstimateBits(tls, histo)
 			}
 			if bit_cost < bit_costs_best[i] {
 				if i == int32(1) {
 					// Do not swap as the full cache analysis would have the wrong
 					// VP8LBackwardRefs to start with.
 					if !(BackwardRefsClone(tls, refs_tmp, refs+1*40) != 0) {
 						goto Error
 					}
 				} else {
 					BackwardRefsSwap(tls, refs_tmp, refs)
 				}
 				bit_costs_best[i] = bit_cost
 				lz77_types_best[i] = lz77_type
 				if i == 0 {
 					**(**int32)(__ccgo_up(cache_bits_best)) = **(**int32)(__ccgo_up(bp + 16))
 				}
 			}
 			goto _3
 		_3:
 			;
 			i = i - 1
 		}
 		goto _2
 	_2:
 		;
 		lz77_types_to_try = lz77_types_to_try & ^lz77_type
 		lz77_type = lz77_type << int32(1)
 	}
 	// Improve on simple LZ77 but only for high quality (TraceBackwards is
 	// costly).
 	i = int32(1)
 	for {
 		if !(i >= 0) {
 			break
 		}
 		if i == int32(1) && !(do_no_cache != 0) {
 			goto _5
 		}
 		if (lz77_types_best[i] == int32(kLZ77Standard) || lz77_types_best[i] == int32(kLZ77Box)) && quality >= int32(25) {
 			if lz77_types_best[i] == int32(kLZ77Standard) {
 				v6 = hash_chain
 			} else {
 				v6 = bp
 			}
 			hash_chain_tmp = v6
 			if i == int32(1) {
 				v1 = 0
 			} else {
 				v1 = **(**int32)(__ccgo_up(cache_bits_best))
 			}
 			cache_bits1 = v1
 			if !(VP8LBackwardReferencesTraceBackwards(tls, width, height, argb, cache_bits1, hash_chain_tmp, refs+uintptr(i)*40, refs_tmp) != 0) {
 				goto Error
 			}
 			VP8LHistogramCreate(tls, histo, refs_tmp, cache_bits1)
 			bit_cost_trace = VP8LHistogramEstimateBits(tls, histo)
 			if bit_cost_trace < bit_costs_best[i] {
 				BackwardRefsSwap(tls, refs_tmp, refs+uintptr(i)*40)
 			}
 		}
 		BackwardReferences2DLocality(tls, width, refs+uintptr(i)*40)
 		if i == int32(1) && lz77_types_best[0] == lz77_types_best[int32(1)] && **(**int32)(__ccgo_up(cache_bits_best)) == 0 {
 			// If the best cache size is 0 and we have the same best LZ77, just copy
 			// the data over and stop here.
 			if !(BackwardRefsClone(tls, refs+1*40, refs) != 0) {
 				goto Error
 			}
 			break
 		}
 		goto _5
 	_5:
 		;
 		i = i - 1
 	}
 	status = int32(1)
 	goto Error
 Error:
 	;
 	VP8LHashChainClear(tls, bp)
 	VP8LFreeHistogram(tls, histo)
 	return status
 }
 
 func VP8LGetBackwardReferences(tls *libc.TLS, width int32, height int32, argb uintptr, quality int32, low_effort int32, lz77_types_to_try int32, cache_bits_max int32, do_no_cache int32, hash_chain uintptr, refs uintptr, cache_bits_best uintptr, pic uintptr, percent_range int32, percent uintptr) (r int32) {
 	var refs_best uintptr
 	_ = refs_best
 	if low_effort != 0 {
 		**(**int32)(__ccgo_up(cache_bits_best)) = cache_bits_max
 		refs_best = GetBackwardReferencesLowEffort(tls, width, height, argb, cache_bits_best, hash_chain, refs)
 		if refs_best == libc.UintptrFromInt32(0) {
 			return WebPEncodingSetError(tls, pic, int32(VP8_ENC_ERROR_OUT_OF_MEMORY))
 		}
 		// Set it in first position.
 		BackwardRefsSwap(tls, refs_best, refs)
 	} else {
 		if !(GetBackwardReferences(tls, width, height, argb, quality, lz77_types_to_try, cache_bits_max, do_no_cache, hash_chain, refs, cache_bits_best) != 0) {
 			return WebPEncodingSetError(tls, pic, int32(VP8_ENC_ERROR_OUT_OF_MEMORY))
 		}
 	}
 	return WebPReportProgress(tls, pic, **(**int32)(__ccgo_up(percent))+percent_range, percent)
 }
 
 const MAX_LEVEL1 = 9
 
 //------------------------------------------------------------------------------
 
 // Copyright 2010 Google Inc. All Rights Reserved.
 //
 // Use of this source code is governed by a BSD-style license
 // that can be found in the COPYING file in the root of the source
 // tree. An additional intellectual property rights grant can be found
 // in the file PATENTS. All contributing project authors may
 // be found in the AUTHORS file in the root of the source tree.
 // -----------------------------------------------------------------------------
 //
 //  Common types + memory wrappers
 //
 // Author: Skal (pascal.massimino@gmail.com)
 
 //------------------------------------------------------------------------------
 // WebPConfig
 //------------------------------------------------------------------------------
 
 func WebPConfigInitInternal(tls *libc.TLS, config uintptr, preset WebPPreset1, quality float32, version int32) (r int32) {
 	if version>>int32(8) != libc.Int32FromInt32(WEBP_ENCODER_ABI_VERSION)>>libc.Int32FromInt32(8) {
 		return 0 // caller/system version mismatch!
 	}
 	if config == libc.UintptrFromInt32(0) {
 		return 0
 	}
 	(*WebPConfig)(unsafe.Pointer(config)).Fquality = quality
 	(*WebPConfig)(unsafe.Pointer(config)).Ftarget_size = 0
 	(*WebPConfig)(unsafe.Pointer(config)).Ftarget_PSNR = float32(0)
 	(*WebPConfig)(unsafe.Pointer(config)).Fmethod = int32(4)
 	(*WebPConfig)(unsafe.Pointer(config)).Fsns_strength = int32(50)
 	(*WebPConfig)(unsafe.Pointer(config)).Ffilter_strength = int32(60) // mid-filtering
 	(*WebPConfig)(unsafe.Pointer(config)).Ffilter_sharpness = 0
 	(*WebPConfig)(unsafe.Pointer(config)).Ffilter_type = int32(1) // default: strong (so U/V is filtered too)
 	(*WebPConfig)(unsafe.Pointer(config)).Fpartitions = 0
 	(*WebPConfig)(unsafe.Pointer(config)).Fsegments = int32(4)
 	(*WebPConfig)(unsafe.Pointer(config)).Fpass = int32(1)
 	(*WebPConfig)(unsafe.Pointer(config)).Fqmin = 0
 	(*WebPConfig)(unsafe.Pointer(config)).Fqmax = int32(100)
 	(*WebPConfig)(unsafe.Pointer(config)).Fshow_compressed = 0
 	(*WebPConfig)(unsafe.Pointer(config)).Fpreprocessing = 0
 	(*WebPConfig)(unsafe.Pointer(config)).Fautofilter = 0
 	(*WebPConfig)(unsafe.Pointer(config)).Fpartition_limit = 0
 	(*WebPConfig)(unsafe.Pointer(config)).Falpha_compression = int32(1)
 	(*WebPConfig)(unsafe.Pointer(config)).Falpha_filtering = int32(1)
 	(*WebPConfig)(unsafe.Pointer(config)).Falpha_quality = int32(100)
 	(*WebPConfig)(unsafe.Pointer(config)).Flossless = 0
 	(*WebPConfig)(unsafe.Pointer(config)).Fexact = 0
 	(*WebPConfig)(unsafe.Pointer(config)).Fimage_hint = int32(WEBP_HINT_DEFAULT)
 	(*WebPConfig)(unsafe.Pointer(config)).Femulate_jpeg_size = 0
 	(*WebPConfig)(unsafe.Pointer(config)).Fthread_level = 0
 	(*WebPConfig)(unsafe.Pointer(config)).Flow_memory = 0
 	(*WebPConfig)(unsafe.Pointer(config)).Fnear_lossless = int32(100)
 	(*WebPConfig)(unsafe.Pointer(config)).Fuse_sharp_yuv = 0
 	// TODO(skal): tune.
 	switch preset {
 	case int32(WEBP_PRESET_PICTURE):
 		(*WebPConfig)(unsafe.Pointer(config)).Fsns_strength = int32(80)
 		(*WebPConfig)(unsafe.Pointer(config)).Ffilter_sharpness = int32(4)
 		(*WebPConfig)(unsafe.Pointer(config)).Ffilter_strength = int32(35)
 		**(**int32)(__ccgo_up(config + 68)) &= ^libc.Int32FromInt32(2) // no dithering
 	case int32(WEBP_PRESET_PHOTO):
 		(*WebPConfig)(unsafe.Pointer(config)).Fsns_strength = int32(80)
 		(*WebPConfig)(unsafe.Pointer(config)).Ffilter_sharpness = int32(3)
 		(*WebPConfig)(unsafe.Pointer(config)).Ffilter_strength = int32(30)
 		**(**int32)(__ccgo_up(config + 68)) |= int32(2)
 	case int32(WEBP_PRESET_DRAWING):
 		(*WebPConfig)(unsafe.Pointer(config)).Fsns_strength = int32(25)
 		(*WebPConfig)(unsafe.Pointer(config)).Ffilter_sharpness = int32(6)
 		(*WebPConfig)(unsafe.Pointer(config)).Ffilter_strength = int32(10)
 	case int32(WEBP_PRESET_ICON):
 		(*WebPConfig)(unsafe.Pointer(config)).Fsns_strength = 0
 		(*WebPConfig)(unsafe.Pointer(config)).Ffilter_strength = 0     // disable filtering to retain sharpness
 		**(**int32)(__ccgo_up(config + 68)) &= ^libc.Int32FromInt32(2) // no dithering
 	case int32(WEBP_PRESET_TEXT):
 		(*WebPConfig)(unsafe.Pointer(config)).Fsns_strength = 0
 		(*WebPConfig)(unsafe.Pointer(config)).Ffilter_strength = 0     // disable filtering to retain sharpness
 		**(**int32)(__ccgo_up(config + 68)) &= ^libc.Int32FromInt32(2) // no dithering
 		(*WebPConfig)(unsafe.Pointer(config)).Fsegments = int32(2)
 	case int32(WEBP_PRESET_DEFAULT):
 		fallthrough
 	default:
 		break
 	}
 	return WebPValidateConfig(tls, config)
 }
 
 func WebPValidateConfig(tls *libc.TLS, config uintptr) (r int32) {
 	if config == libc.UintptrFromInt32(0) {
 		return 0
 	}
 	if (*WebPConfig)(unsafe.Pointer(config)).Fquality < libc.Float32FromInt32(0) || (*WebPConfig)(unsafe.Pointer(config)).Fquality > libc.Float32FromInt32(100) {
 		return 0
 	}
 	if (*WebPConfig)(unsafe.Pointer(config)).Ftarget_size < 0 {
 		return 0
 	}
 	if (*WebPConfig)(unsafe.Pointer(config)).Ftarget_PSNR < libc.Float32FromInt32(0) {
 		return 0
 	}
 	if (*WebPConfig)(unsafe.Pointer(config)).Fmethod < 0 || (*WebPConfig)(unsafe.Pointer(config)).Fmethod > int32(6) {
 		return 0
 	}
 	if (*WebPConfig)(unsafe.Pointer(config)).Fsegments < int32(1) || (*WebPConfig)(unsafe.Pointer(config)).Fsegments > int32(4) {
 		return 0
 	}
 	if (*WebPConfig)(unsafe.Pointer(config)).Fsns_strength < 0 || (*WebPConfig)(unsafe.Pointer(config)).Fsns_strength > int32(100) {
 		return 0
 	}
 	if (*WebPConfig)(unsafe.Pointer(config)).Ffilter_strength < 0 || (*WebPConfig)(unsafe.Pointer(config)).Ffilter_strength > int32(100) {
 		return 0
 	}
 	if (*WebPConfig)(unsafe.Pointer(config)).Ffilter_sharpness < 0 || (*WebPConfig)(unsafe.Pointer(config)).Ffilter_sharpness > int32(7) {
 		return 0
 	}
 	if (*WebPConfig)(unsafe.Pointer(config)).Ffilter_type < 0 || (*WebPConfig)(unsafe.Pointer(config)).Ffilter_type > int32(1) {
 		return 0
 	}
 	if (*WebPConfig)(unsafe.Pointer(config)).Fautofilter < 0 || (*WebPConfig)(unsafe.Pointer(config)).Fautofilter > int32(1) {
 		return 0
 	}
 	if (*WebPConfig)(unsafe.Pointer(config)).Fpass < int32(1) || (*WebPConfig)(unsafe.Pointer(config)).Fpass > int32(10) {
 		return 0
 	}
 	if (*WebPConfig)(unsafe.Pointer(config)).Fqmin < 0 || (*WebPConfig)(unsafe.Pointer(config)).Fqmax > int32(100) || (*WebPConfig)(unsafe.Pointer(config)).Fqmin > (*WebPConfig)(unsafe.Pointer(config)).Fqmax {
 		return 0
 	}
 	if (*WebPConfig)(unsafe.Pointer(config)).Fshow_compressed < 0 || (*WebPConfig)(unsafe.Pointer(config)).Fshow_compressed > int32(1) {
 		return 0
 	}
 	if (*WebPConfig)(unsafe.Pointer(config)).Fpreprocessing < 0 || (*WebPConfig)(unsafe.Pointer(config)).Fpreprocessing > int32(7) {
 		return 0
 	}
 	if (*WebPConfig)(unsafe.Pointer(config)).Fpartitions < 0 || (*WebPConfig)(unsafe.Pointer(config)).Fpartitions > int32(3) {
 		return 0
 	}
 	if (*WebPConfig)(unsafe.Pointer(config)).Fpartition_limit < 0 || (*WebPConfig)(unsafe.Pointer(config)).Fpartition_limit > int32(100) {
 		return 0
 	}
 	if (*WebPConfig)(unsafe.Pointer(config)).Falpha_compression < 0 {
 		return 0
 	}
 	if (*WebPConfig)(unsafe.Pointer(config)).Falpha_filtering < 0 {
 		return 0
 	}
 	if (*WebPConfig)(unsafe.Pointer(config)).Falpha_quality < 0 || (*WebPConfig)(unsafe.Pointer(config)).Falpha_quality > int32(100) {
 		return 0
 	}
 	if (*WebPConfig)(unsafe.Pointer(config)).Flossless < 0 || (*WebPConfig)(unsafe.Pointer(config)).Flossless > int32(1) {
 		return 0
 	}
 	if (*WebPConfig)(unsafe.Pointer(config)).Fnear_lossless < 0 || (*WebPConfig)(unsafe.Pointer(config)).Fnear_lossless > int32(100) {
 		return 0
 	}
 	if (*WebPConfig)(unsafe.Pointer(config)).Fimage_hint >= int32(WEBP_HINT_LAST) {
 		return 0
 	}
 	if (*WebPConfig)(unsafe.Pointer(config)).Femulate_jpeg_size < 0 || (*WebPConfig)(unsafe.Pointer(config)).Femulate_jpeg_size > int32(1) {
 		return 0
 	}
 	if (*WebPConfig)(unsafe.Pointer(config)).Fthread_level < 0 || (*WebPConfig)(unsafe.Pointer(config)).Fthread_level > int32(1) {
 		return 0
 	}
 	if (*WebPConfig)(unsafe.Pointer(config)).Flow_memory < 0 || (*WebPConfig)(unsafe.Pointer(config)).Flow_memory > int32(1) {
 		return 0
 	}
 	if (*WebPConfig)(unsafe.Pointer(config)).Fexact < 0 || (*WebPConfig)(unsafe.Pointer(config)).Fexact > int32(1) {
 		return 0
 	}
 	if (*WebPConfig)(unsafe.Pointer(config)).Fuse_sharp_yuv < 0 || (*WebPConfig)(unsafe.Pointer(config)).Fuse_sharp_yuv > int32(1) {
 		return 0
 	}
 	return int32(1)
 }
 
 //------------------------------------------------------------------------------
 
 // C documentation
 //
 //	// Mapping between -z level and -m / -q parameter settings.
 var kLosslessPresets = [10]struct {
 	Fmethod  uint8_t
 	Fquality uint8_t
 }{
 	0: {},
 	1: {
 		Fmethod:  uint8(1),
 		Fquality: uint8(20),
 	},
 	2: {
 		Fmethod:  uint8(2),
 		Fquality: uint8(25),
 	},
 	3: {
 		Fmethod:  uint8(3),
 		Fquality: uint8(30),
 	},
 	4: {
 		Fmethod:  uint8(3),
 		Fquality: uint8(50),
 	},
 	5: {
 		Fmethod:  uint8(4),
 		Fquality: uint8(50),
 	},
 	6: {
 		Fmethod:  uint8(4),
 		Fquality: uint8(75),
 	},
 	7: {
 		Fmethod:  uint8(4),
 		Fquality: uint8(90),
 	},
 	8: {
 		Fmethod:  uint8(5),
 		Fquality: uint8(90),
 	},
 	9: {
 		Fmethod:  uint8(6),
 		Fquality: uint8(100),
 	},
 }
 
 func WebPConfigLosslessPreset(tls *libc.TLS, config uintptr, level int32) (r int32) {
 	if config == libc.UintptrFromInt32(0) || level < 0 || level > int32(MAX_LEVEL1) {
 		return 0
 	}
 	(*WebPConfig)(unsafe.Pointer(config)).Flossless = int32(1)
 	(*WebPConfig)(unsafe.Pointer(config)).Fmethod = libc.Int32FromUint8(kLosslessPresets[level].Fmethod)
 	(*WebPConfig)(unsafe.Pointer(config)).Fquality = float32(kLosslessPresets[level].Fquality)
 	return int32(1)
 }
 
 type VP8Residual = struct {
 	Ffirst      int32
 	Flast       int32
 	Fcoeffs     uintptr
 	Fcoeff_type int32
 	Fprob       uintptr
 	Fstats      uintptr
 	Fcosts      CostArrayPtr
 }
 
 //------------------------------------------------------------------------------
 
 // Copyright 2011 Google Inc. All Rights Reserved.
 //
 // Use of this source code is governed by a BSD-style license
 // that can be found in the COPYING file in the root of the source
 // tree. An additional intellectual property rights grant can be found
 // in the file PATENTS. All contributing project authors may
 // be found in the AUTHORS file in the root of the source tree.
 // -----------------------------------------------------------------------------
 //
 //   WebP encoder: internal header.
 //
 // Author: Skal (pascal.massimino@gmail.com)
 
 //------------------------------------------------------------------------------
 // Level cost tables
 
 // C documentation
 //
 //	// For each given level, the following table gives the pattern of contexts to
 //	// use for coding it (in [][0]) as well as the bit value to use for each
 //	// context (in [][1]).
 var VP8LevelCodes = [67][2]uint16_t{
 	0: {
 		0: uint16(0x001),
 	},
 	1: {
 		0: uint16(0x007),
 		1: uint16(0x001),
 	},
 	2: {
 		0: uint16(0x00f),
 		1: uint16(0x005),
 	},
 	3: {
 		0: uint16(0x00f),
 		1: uint16(0x00d),
 	},
 	4: {
 		0: uint16(0x033),
 		1: uint16(0x003),
 	},
 	5: {
 		0: uint16(0x033),
 		1: uint16(0x003),
 	},
 	6: {
 		0: uint16(0x033),
 		1: uint16(0x023),
 	},
 	7: {
 		0: uint16(0x033),
 		1: uint16(0x023),
 	},
 	8: {
 		0: uint16(0x033),
 		1: uint16(0x023),
 	},
 	9: {
 		0: uint16(0x033),
 		1: uint16(0x023),
 	},
 	10: {
 		0: uint16(0x0d3),
 		1: uint16(0x013),
 	},
 	11: {
 		0: uint16(0x0d3),
 		1: uint16(0x013),
 	},
 	12: {
 		0: uint16(0x0d3),
 		1: uint16(0x013),
 	},
 	13: {
 		0: uint16(0x0d3),
 		1: uint16(0x013),
 	},
 	14: {
 		0: uint16(0x0d3),
 		1: uint16(0x013),
 	},
 	15: {
 		0: uint16(0x0d3),
 		1: uint16(0x013),
 	},
 	16: {
 		0: uint16(0x0d3),
 		1: uint16(0x013),
 	},
 	17: {
 		0: uint16(0x0d3),
 		1: uint16(0x013),
 	},
 	18: {
 		0: uint16(0x0d3),
 		1: uint16(0x093),
 	},
 	19: {
 		0: uint16(0x0d3),
 		1: uint16(0x093),
 	},
 	20: {
 		0: uint16(0x0d3),
 		1: uint16(0x093),
 	},
 	21: {
 		0: uint16(0x0d3),
 		1: uint16(0x093),
 	},
 	22: {
 		0: uint16(0x0d3),
 		1: uint16(0x093),
 	},
 	23: {
 		0: uint16(0x0d3),
 		1: uint16(0x093),
 	},
 	24: {
 		0: uint16(0x0d3),
 		1: uint16(0x093),
 	},
 	25: {
 		0: uint16(0x0d3),
 		1: uint16(0x093),
 	},
 	26: {
 		0: uint16(0x0d3),
 		1: uint16(0x093),
 	},
 	27: {
 		0: uint16(0x0d3),
 		1: uint16(0x093),
 	},
 	28: {
 		0: uint16(0x0d3),
 		1: uint16(0x093),
 	},
 	29: {
 		0: uint16(0x0d3),
 		1: uint16(0x093),
 	},
 	30: {
 		0: uint16(0x0d3),
 		1: uint16(0x093),
 	},
 	31: {
 		0: uint16(0x0d3),
 		1: uint16(0x093),
 	},
 	32: {
 		0: uint16(0x0d3),
 		1: uint16(0x093),
 	},
 	33: {
 		0: uint16(0x0d3),
 		1: uint16(0x093),
 	},
 	34: {
 		0: uint16(0x153),
 		1: uint16(0x053),
 	},
 	35: {
 		0: uint16(0x153),
 		1: uint16(0x053),
 	},
 	36: {
 		0: uint16(0x153),
 		1: uint16(0x053),
 	},
 	37: {
 		0: uint16(0x153),
 		1: uint16(0x053),
 	},
 	38: {
 		0: uint16(0x153),
 		1: uint16(0x053),
 	},
 	39: {
 		0: uint16(0x153),
 		1: uint16(0x053),
 	},
 	40: {
 		0: uint16(0x153),
 		1: uint16(0x053),
 	},
 	41: {
 		0: uint16(0x153),
 		1: uint16(0x053),
 	},
 	42: {
 		0: uint16(0x153),
 		1: uint16(0x053),
 	},
 	43: {
 		0: uint16(0x153),
 		1: uint16(0x053),
 	},
 	44: {
 		0: uint16(0x153),
 		1: uint16(0x053),
 	},
 	45: {
 		0: uint16(0x153),
 		1: uint16(0x053),
 	},
 	46: {
 		0: uint16(0x153),
 		1: uint16(0x053),
 	},
 	47: {
 		0: uint16(0x153),
 		1: uint16(0x053),
 	},
 	48: {
 		0: uint16(0x153),
 		1: uint16(0x053),
 	},
 	49: {
 		0: uint16(0x153),
 		1: uint16(0x053),
 	},
 	50: {
 		0: uint16(0x153),
 		1: uint16(0x053),
 	},
 	51: {
 		0: uint16(0x153),
 		1: uint16(0x053),
 	},
 	52: {
 		0: uint16(0x153),
 		1: uint16(0x053),
 	},
 	53: {
 		0: uint16(0x153),
 		1: uint16(0x053),
 	},
 	54: {
 		0: uint16(0x153),
 		1: uint16(0x053),
 	},
 	55: {
 		0: uint16(0x153),
 		1: uint16(0x053),
 	},
 	56: {
 		0: uint16(0x153),
 		1: uint16(0x053),
 	},
 	57: {
 		0: uint16(0x153),
 		1: uint16(0x053),
 	},
 	58: {
 		0: uint16(0x153),
 		1: uint16(0x053),
 	},
 	59: {
 		0: uint16(0x153),
 		1: uint16(0x053),
 	},
 	60: {
 		0: uint16(0x153),
 		1: uint16(0x053),
 	},
 	61: {
 		0: uint16(0x153),
 		1: uint16(0x053),
 	},
 	62: {
 		0: uint16(0x153),
 		1: uint16(0x053),
 	},
 	63: {
 		0: uint16(0x153),
 		1: uint16(0x053),
 	},
 	64: {
 		0: uint16(0x153),
 		1: uint16(0x053),
 	},
 	65: {
 		0: uint16(0x153),
 		1: uint16(0x053),
 	},
 	66: {
 		0: uint16(0x153),
 		1: uint16(0x153),
 	},
 }
 
 func VariableLevelCost(tls *libc.TLS, level int32, probas uintptr) (r int32) {
 	var bits, cost, i, pattern, v3, v5 int32
 	var v2 uint8_t
 	_, _, _, _, _, _, _ = bits, cost, i, pattern, v2, v3, v5
 	pattern = libc.Int32FromUint16(**(**uint16_t)(__ccgo_up(uintptr(unsafe.Pointer(&VP8LevelCodes)) + uintptr(level-int32(1))*4)))
 	bits = libc.Int32FromUint16(**(**uint16_t)(__ccgo_up(uintptr(unsafe.Pointer(&VP8LevelCodes)) + uintptr(level-int32(1))*4 + 1*2)))
 	cost = 0
 	i = int32(2)
 	for {
 		if !(pattern != 0) {
 			break
 		}
 		if pattern&int32(1) != 0 {
 			v2 = **(**uint8_t)(__ccgo_up(probas + uintptr(i)))
 			if !(bits&int32(1) != 0) {
 				v5 = libc.Int32FromUint16(VP8EntropyCost[v2])
 			} else {
 				v5 = libc.Int32FromUint16(VP8EntropyCost[int32(255)-libc.Int32FromUint8(v2)])
 			}
 			v3 = v5
 			goto _4
 		_4:
 			cost = cost + v3
 		}
 		bits = bits >> int32(1)
 		pattern = pattern >> int32(1)
 		goto _1
 	_1:
 		;
 		i = i + 1
 	}
 	return cost
 }
 
 //------------------------------------------------------------------------------
 // Pre-calc level costs once for all
 
 func VP8CalculateLevelCosts(tls *libc.TLS, proba1 uintptr) {
 	var band, cost0, cost_base, ctx, ctype, n, v, v10, v12, v14, v16, v4, v6, v8 int32
 	var p, table uintptr
 	var v13, v5, v9 uint8_t
 	_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = band, cost0, cost_base, ctx, ctype, n, p, table, v, v10, v12, v13, v14, v16, v4, v5, v6, v8, v9
 	if !((*VP8EncProba)(unsafe.Pointer(proba1)).Fdirty != 0) {
 		return
 	} // nothing to do.
 	ctype = 0
 	for {
 		if !(ctype < int32(NUM_TYPES)) {
 			break
 		}
 		band = 0
 		for {
 			if !(band < int32(NUM_BANDS)) {
 				break
 			}
 			ctx = 0
 			for {
 				if !(ctx < int32(NUM_CTX)) {
 					break
 				}
 				p = proba1 + 4 + uintptr(ctype)*264 + uintptr(band)*33 + uintptr(ctx)*11
 				table = proba1 + 5284 + uintptr(ctype)*3264 + uintptr(band)*408 + uintptr(ctx)*136
 				if ctx > 0 {
 					v5 = **(**uint8_t)(__ccgo_up(p))
 					if !(int32(1) != 0) {
 						v8 = libc.Int32FromUint16(VP8EntropyCost[v5])
 					} else {
 						v8 = libc.Int32FromUint16(VP8EntropyCost[int32(255)-libc.Int32FromUint8(v5)])
 					}
 					v6 = v8
 					goto _7
 				_7:
 					v4 = v6
 				} else {
 					v4 = 0
 				}
 				cost0 = v4
 				v9 = **(**uint8_t)(__ccgo_up(p + 1))
 				if !(int32(1) != 0) {
 					v12 = libc.Int32FromUint16(VP8EntropyCost[v9])
 				} else {
 					v12 = libc.Int32FromUint16(VP8EntropyCost[int32(255)-libc.Int32FromUint8(v9)])
 				}
 				v10 = v12
 				goto _11
 			_11:
 				cost_base = v10 + cost0
 				v13 = **(**uint8_t)(__ccgo_up(p + 1))
 				if !(0 != 0) {
 					v16 = libc.Int32FromUint16(VP8EntropyCost[v13])
 				} else {
 					v16 = libc.Int32FromUint16(VP8EntropyCost[int32(255)-libc.Int32FromUint8(v13)])
 				}
 				v14 = v16
 				goto _15
 			_15:
 				**(**uint16_t)(__ccgo_up(table)) = libc.Uint16FromInt32(v14 + cost0)
 				v = int32(1)
 				for {
 					if !(v <= int32(MAX_VARIABLE_LEVEL)) {
 						break
 					}
 					**(**uint16_t)(__ccgo_up(table + uintptr(v)*2)) = libc.Uint16FromInt32(cost_base + VariableLevelCost(tls, v, p))
 					goto _17
 				_17:
 					;
 					v = v + 1
 				}
 				// Starting at level 67 and up, the variable part of the cost is
 				// actually constant.
 				goto _3
 			_3:
 				;
 				ctx = ctx + 1
 			}
 			goto _2
 		_2:
 			;
 			band = band + 1
 		}
 		n = 0
 		for {
 			if !(n < int32(16)) {
 				break
 			} // replicate bands. We don't need to sentinel.
 			ctx = 0
 			for {
 				if !(ctx < int32(NUM_CTX)) {
 					break
 				}
 				**(**uintptr)(__ccgo_up(proba1 + 18344 + uintptr(ctype)*384 + uintptr(n)*24 + uintptr(ctx)*8)) = proba1 + 5284 + uintptr(ctype)*3264 + uintptr(VP8EncBands[n])*408 + uintptr(ctx)*136
 				goto _19
 			_19:
 				;
 				ctx = ctx + 1
 			}
 			goto _18
 		_18:
 			;
 			n = n + 1
 		}
 		goto _1
 	_1:
 		;
 		ctype = ctype + 1
 	}
 	(*VP8EncProba)(unsafe.Pointer(proba1)).Fdirty = 0
 }
 
 //------------------------------------------------------------------------------
 // helper functions for residuals struct VP8Residual.
 
 func VP8InitResidual(tls *libc.TLS, first int32, coeff_type int32, enc uintptr, res uintptr) {
 	(*VP8Residual)(unsafe.Pointer(res)).Fcoeff_type = coeff_type
 	(*VP8Residual)(unsafe.Pointer(res)).Fprob = enc + 3616 + 4 + uintptr(coeff_type)*264
 	(*VP8Residual)(unsafe.Pointer(res)).Fstats = enc + 3616 + 1060 + uintptr(coeff_type)*1056
 	(*VP8Residual)(unsafe.Pointer(res)).Fcosts = enc + 3616 + 18344 + uintptr(coeff_type)*384
 	(*VP8Residual)(unsafe.Pointer(res)).Ffirst = first
 }
 
 //------------------------------------------------------------------------------
 // Mode costs
 
 func VP8GetCostLuma4(tls *libc.TLS, it uintptr, levels uintptr) (r int32) {
 	bp := tls.Alloc(48)
 	defer tls.Free(48)
 	var R, ctx, x, y int32
 	var enc uintptr
 	var _ /* res at bp+0 */ VP8Residual
 	_, _, _, _, _ = R, ctx, enc, x, y
 	x = (*VP8EncIterator)(unsafe.Pointer(it)).Fi4 & libc.Int32FromInt32(3)
 	y = (*VP8EncIterator)(unsafe.Pointer(it)).Fi4 >> libc.Int32FromInt32(2)
 	enc = (*VP8EncIterator)(unsafe.Pointer(it)).Fenc
 	R = 0
 	VP8InitResidual(tls, 0, int32(3), enc, bp)
 	ctx = **(**int32)(__ccgo_up(it + 132 + uintptr(x)*4)) + **(**int32)(__ccgo_up(it + 168 + uintptr(y)*4))
 	(*(*func(*libc.TLS, uintptr, uintptr))(unsafe.Pointer(&struct{ uintptr }{VP8SetResidualCoeffs})))(tls, levels, bp)
 	R = R + (*(*func(*libc.TLS, int32, uintptr) int32)(unsafe.Pointer(&struct{ uintptr }{VP8GetResidualCost})))(tls, ctx, bp)
 	return R
 }
 
 func VP8GetCostLuma16(tls *libc.TLS, it uintptr, rd uintptr) (r int32) {
 	bp := tls.Alloc(48)
 	defer tls.Free(48)
 	var R, ctx, x, y, v3 int32
 	var enc uintptr
 	var _ /* res at bp+0 */ VP8Residual
 	_, _, _, _, _, _ = R, ctx, enc, x, y, v3
 	enc = (*VP8EncIterator)(unsafe.Pointer(it)).Fenc
 	R = 0
 	VP8IteratorNzToBytes(tls, it) // re-import the non-zero context
 	// DC
 	VP8InitResidual(tls, 0, int32(1), enc, bp)
 	(*(*func(*libc.TLS, uintptr, uintptr))(unsafe.Pointer(&struct{ uintptr }{VP8SetResidualCoeffs})))(tls, rd+40, bp)
 	R = R + (*(*func(*libc.TLS, int32, uintptr) int32)(unsafe.Pointer(&struct{ uintptr }{VP8GetResidualCost})))(tls, **(**int32)(__ccgo_up(it + 132 + 8*4))+**(**int32)(__ccgo_up(it + 168 + 8*4)), bp)
 	// AC
 	VP8InitResidual(tls, int32(1), 0, enc, bp)
 	y = 0
 	for {
 		if !(y < int32(4)) {
 			break
 		}
 		x = 0
 		for {
 			if !(x < int32(4)) {
 				break
 			}
 			ctx = **(**int32)(__ccgo_up(it + 132 + uintptr(x)*4)) + **(**int32)(__ccgo_up(it + 168 + uintptr(y)*4))
 			(*(*func(*libc.TLS, uintptr, uintptr))(unsafe.Pointer(&struct{ uintptr }{VP8SetResidualCoeffs})))(tls, rd+72+uintptr(x+y*int32(4))*32, bp)
 			R = R + (*(*func(*libc.TLS, int32, uintptr) int32)(unsafe.Pointer(&struct{ uintptr }{VP8GetResidualCost})))(tls, ctx, bp)
 			v3 = libc.BoolInt32((**(**VP8Residual)(__ccgo_up(bp))).Flast >= libc.Int32FromInt32(0))
 			**(**int32)(__ccgo_up(it + 168 + uintptr(y)*4)) = v3
 			**(**int32)(__ccgo_up(it + 132 + uintptr(x)*4)) = v3
 			goto _2
 		_2:
 			;
 			x = x + 1
 		}
 		goto _1
 	_1:
 		;
 		y = y + 1
 	}
 	return R
 }
 
 func VP8GetCostUV(tls *libc.TLS, it uintptr, rd uintptr) (r int32) {
 	bp := tls.Alloc(48)
 	defer tls.Free(48)
 	var R, ch, ctx, x, y, v4 int32
 	var enc uintptr
 	var _ /* res at bp+0 */ VP8Residual
 	_, _, _, _, _, _, _ = R, ch, ctx, enc, x, y, v4
 	enc = (*VP8EncIterator)(unsafe.Pointer(it)).Fenc
 	R = 0
 	VP8IteratorNzToBytes(tls, it) // re-import the non-zero context
 	VP8InitResidual(tls, 0, int32(2), enc, bp)
 	ch = 0
 	for {
 		if !(ch <= int32(2)) {
 			break
 		}
 		y = 0
 		for {
 			if !(y < int32(2)) {
 				break
 			}
 			x = 0
 			for {
 				if !(x < int32(2)) {
 					break
 				}
 				ctx = **(**int32)(__ccgo_up(it + 132 + uintptr(int32(4)+ch+x)*4)) + **(**int32)(__ccgo_up(it + 168 + uintptr(int32(4)+ch+y)*4))
 				(*(*func(*libc.TLS, uintptr, uintptr))(unsafe.Pointer(&struct{ uintptr }{VP8SetResidualCoeffs})))(tls, rd+584+uintptr(ch*int32(2)+x+y*int32(2))*32, bp)
 				R = R + (*(*func(*libc.TLS, int32, uintptr) int32)(unsafe.Pointer(&struct{ uintptr }{VP8GetResidualCost})))(tls, ctx, bp)
 				v4 = libc.BoolInt32((**(**VP8Residual)(__ccgo_up(bp))).Flast >= libc.Int32FromInt32(0))
 				**(**int32)(__ccgo_up(it + 168 + uintptr(int32(4)+ch+y)*4)) = v4
 				**(**int32)(__ccgo_up(it + 132 + uintptr(int32(4)+ch+x)*4)) = v4
 				goto _3
 			_3:
 				;
 				x = x + 1
 			}
 			goto _2
 		_2:
 			;
 			y = y + 1
 		}
 		goto _1
 	_1:
 		;
 		ch = ch + int32(2)
 	}
 	return R
 }
 
 //------------------------------------------------------------------------------
 // Recording of token probabilities.
 
 // We keep the table-free variant around for reference, in case.
 
 // C documentation
 //
 //	// Simulate block coding, but only record statistics.
 //	// Note: no need to record the fixed probas.
 func VP8RecordCoeffs(tls *libc.TLS, ctx int32, res uintptr) (r int32) {
 	var bits, i, mask, n, pattern, v, v1, v4, v7 int32
 	var p proba_t
 	var s, v2 uintptr
 	_, _, _, _, _, _, _, _, _, _, _, _ = bits, i, mask, n, p, pattern, s, v, v1, v2, v4, v7
 	n = (*VP8Residual)(unsafe.Pointer(res)).Ffirst
 	// should be stats[VP8EncBands[n]], but it's equivalent for n=0 or 1
 	s = (*VP8Residual)(unsafe.Pointer(res)).Fstats + uintptr(n)*132 + uintptr(ctx)*44
 	if (*VP8Residual)(unsafe.Pointer(res)).Flast < 0 {
 		v1 = 0
 		v2 = s + uintptr(0)*4
 		p = **(**proba_t)(__ccgo_up(v2))
 		if p >= libc.Uint32FromUint32(0xfffe0000) {
 			p = (p + uint32(1)) >> int32(1) & uint32(0x7fff7fff)
 		}
 		p = p + (uint32(0x00010000) + libc.Uint32FromInt32(v1))
 		**(**proba_t)(__ccgo_up(v2)) = p
 		_ = v1
 		goto _3
 	_3:
 		;
 		return 0
 	}
 	for n <= (*VP8Residual)(unsafe.Pointer(res)).Flast {
 		v1 = int32(1)
 		v2 = s + uintptr(0)*4
 		p = **(**proba_t)(__ccgo_up(v2))
 		if p >= libc.Uint32FromUint32(0xfffe0000) {
 			p = (p + uint32(1)) >> int32(1) & uint32(0x7fff7fff)
 		}
 		p = p + (uint32(0x00010000) + libc.Uint32FromInt32(v1))
 		**(**proba_t)(__ccgo_up(v2)) = p
 		_ = v1
 		goto _6
 	_6:
 		; // order of record doesn't matter
 		for {
 			v4 = n
 			n = n + 1
 			v1 = int32(**(**int16_t)(__ccgo_up((*VP8Residual)(unsafe.Pointer(res)).Fcoeffs + uintptr(v4)*2)))
 			v = v1
 			if !(v1 == 0) {
 				break
 			}
 			v7 = 0
 			v2 = s + uintptr(1)*4
 			p = **(**proba_t)(__ccgo_up(v2))
 			if p >= libc.Uint32FromUint32(0xfffe0000) {
 				p = (p + uint32(1)) >> int32(1) & uint32(0x7fff7fff)
 			}
 			p = p + (uint32(0x00010000) + libc.Uint32FromInt32(v7))
 			**(**proba_t)(__ccgo_up(v2)) = p
 			_ = v7
 			goto _11
 		_11:
 			;
 			s = (*VP8Residual)(unsafe.Pointer(res)).Fstats + uintptr(VP8EncBands[n])*132
 		}
 		v1 = int32(1)
 		v2 = s + uintptr(1)*4
 		p = **(**proba_t)(__ccgo_up(v2))
 		if p >= libc.Uint32FromUint32(0xfffe0000) {
 			p = (p + uint32(1)) >> int32(1) & uint32(0x7fff7fff)
 		}
 		p = p + (uint32(0x00010000) + libc.Uint32FromInt32(v1))
 		**(**proba_t)(__ccgo_up(v2)) = p
 		_ = v1
 		goto _14
 	_14:
 		;
 		v1 = libc.BoolInt32(uint32(2) < libc.Uint32FromInt32(v+libc.Int32FromInt32(1)))
 		v2 = s + uintptr(2)*4
 		p = **(**proba_t)(__ccgo_up(v2))
 		if p >= libc.Uint32FromUint32(0xfffe0000) {
 			p = (p + uint32(1)) >> int32(1) & uint32(0x7fff7fff)
 		}
 		p = p + (uint32(0x00010000) + libc.Uint32FromInt32(v1))
 		**(**proba_t)(__ccgo_up(v2)) = p
 		v4 = v1
 		goto _18
 	_18:
 		if !(v4 != 0) { // v = -1 or 1
 			s = (*VP8Residual)(unsafe.Pointer(res)).Fstats + uintptr(VP8EncBands[n])*132 + 1*44
 		} else {
 			v = libc.Xabs(tls, v)
 			if v > int32(MAX_VARIABLE_LEVEL) {
 				v = int32(MAX_VARIABLE_LEVEL)
 			}
 			bits = libc.Int32FromUint16(**(**uint16_t)(__ccgo_up(uintptr(unsafe.Pointer(&VP8LevelCodes)) + uintptr(v-int32(1))*4 + 1*2)))
 			pattern = libc.Int32FromUint16(**(**uint16_t)(__ccgo_up(uintptr(unsafe.Pointer(&VP8LevelCodes)) + uintptr(v-int32(1))*4)))
 			i = 0
 			for {
 				pattern = pattern >> int32(1)
 				if !(pattern != 0) {
 					break
 				}
 				mask = int32(2) << i
 				if pattern&int32(1) != 0 {
 					v1 = libc.BoolInt32(!!(bits&mask != 0))
 					v2 = s + uintptr(3)*4 + uintptr(i)*4
 					p = **(**proba_t)(__ccgo_up(v2))
 					if p >= libc.Uint32FromUint32(0xfffe0000) {
 						p = (p + uint32(1)) >> int32(1) & uint32(0x7fff7fff)
 					}
 					p = p + (uint32(0x00010000) + libc.Uint32FromInt32(v1))
 					**(**proba_t)(__ccgo_up(v2)) = p
 					_ = v1
 					goto _22
 				_22:
 				}
 				goto _19
 			_19:
 				;
 				i = i + 1
 			}
 			s = (*VP8Residual)(unsafe.Pointer(res)).Fstats + uintptr(VP8EncBands[n])*132 + 2*44
 		}
 	}
 	if n < int32(16) {
 		v1 = 0
 		v2 = s + uintptr(0)*4
 		p = **(**proba_t)(__ccgo_up(v2))
 		if p >= libc.Uint32FromUint32(0xfffe0000) {
 			p = (p + uint32(1)) >> int32(1) & uint32(0x7fff7fff)
 		}
 		p = p + (uint32(0x00010000) + libc.Uint32FromInt32(v1))
 		**(**proba_t)(__ccgo_up(v2)) = p
 		_ = v1
 		goto _25
 	_25:
 	}
 	return int32(1)
 }
 
 const MAX_DELTA_SIZE = 64
 
 //------------------------------------------------------------------------------
 
 // C documentation
 //
 //	// This table gives, for a given sharpness, the filtering strength to be
 //	// used (at least) in order to filter a given edge step delta.
 //	// This is constructed by brute force inspection: for all delta, we iterate
 //	// over all possible filtering strength / thresh until needs_filter() returns
 //	// true.
 var kLevelsFromDelta = [8][64]uint8_t{
 	0: {
 		1:  uint8(1),
 		2:  uint8(2),
 		3:  uint8(3),
 		4:  uint8(4),
 		5:  uint8(5),
 		6:  uint8(6),
 		7:  uint8(7),
 		8:  uint8(8),
 		9:  uint8(9),
 		10: uint8(10),
 		11: uint8(11),
 		12: uint8(12),
 		13: uint8(13),
 		14: uint8(14),
 		15: uint8(15),
 		16: uint8(16),
 		17: uint8(17),
 		18: uint8(18),
 		19: uint8(19),
 		20: uint8(20),
 		21: uint8(21),
 		22: uint8(22),
 		23: uint8(23),
 		24: uint8(24),
 		25: uint8(25),
 		26: uint8(26),
 		27: uint8(27),
 		28: uint8(28),
 		29: uint8(29),
 		30: uint8(30),
 		31: uint8(31),
 		32: uint8(32),
 		33: uint8(33),
 		34: uint8(34),
 		35: uint8(35),
 		36: uint8(36),
 		37: uint8(37),
 		38: uint8(38),
 		39: uint8(39),
 		40: uint8(40),
 		41: uint8(41),
 		42: uint8(42),
 		43: uint8(43),
 		44: uint8(44),
 		45: uint8(45),
 		46: uint8(46),
 		47: uint8(47),
 		48: uint8(48),
 		49: uint8(49),
 		50: uint8(50),
 		51: uint8(51),
 		52: uint8(52),
 		53: uint8(53),
 		54: uint8(54),
 		55: uint8(55),
 		56: uint8(56),
 		57: uint8(57),
 		58: uint8(58),
 		59: uint8(59),
 		60: uint8(60),
 		61: uint8(61),
 		62: uint8(62),
 		63: uint8(63),
 	},
 	1: {
 		1:  uint8(1),
 		2:  uint8(2),
 		3:  uint8(3),
 		4:  uint8(5),
 		5:  uint8(6),
 		6:  uint8(7),
 		7:  uint8(8),
 		8:  uint8(9),
 		9:  uint8(11),
 		10: uint8(12),
 		11: uint8(13),
 		12: uint8(14),
 		13: uint8(15),
 		14: uint8(17),
 		15: uint8(18),
 		16: uint8(20),
 		17: uint8(21),
 		18: uint8(23),
 		19: uint8(24),
 		20: uint8(26),
 		21: uint8(27),
 		22: uint8(29),
 		23: uint8(30),
 		24: uint8(32),
 		25: uint8(33),
 		26: uint8(35),
 		27: uint8(36),
 		28: uint8(38),
 		29: uint8(39),
 		30: uint8(41),
 		31: uint8(42),
 		32: uint8(44),
 		33: uint8(45),
 		34: uint8(47),
 		35: uint8(48),
 		36: uint8(50),
 		37: uint8(51),
 		38: uint8(53),
 		39: uint8(54),
 		40: uint8(56),
 		41: uint8(57),
 		42: uint8(59),
 		43: uint8(60),
 		44: uint8(62),
 		45: uint8(63),
 		46: uint8(63),
 		47: uint8(63),
 		48: uint8(63),
 		49: uint8(63),
 		50: uint8(63),
 		51: uint8(63),
 		52: uint8(63),
 		53: uint8(63),
 		54: uint8(63),
 		55: uint8(63),
 		56: uint8(63),
 		57: uint8(63),
 		58: uint8(63),
 		59: uint8(63),
 		60: uint8(63),
 		61: uint8(63),
 		62: uint8(63),
 		63: uint8(63),
 	},
 	2: {
 		1:  uint8(1),
 		2:  uint8(2),
 		3:  uint8(3),
 		4:  uint8(5),
 		5:  uint8(6),
 		6:  uint8(7),
 		7:  uint8(8),
 		8:  uint8(9),
 		9:  uint8(11),
 		10: uint8(12),
 		11: uint8(13),
 		12: uint8(14),
 		13: uint8(16),
 		14: uint8(17),
 		15: uint8(19),
 		16: uint8(20),
 		17: uint8(22),
 		18: uint8(23),
 		19: uint8(25),
 		20: uint8(26),
 		21: uint8(28),
 		22: uint8(29),
 		23: uint8(31),
 		24: uint8(32),
 		25: uint8(34),
 		26: uint8(35),
 		27: uint8(37),
 		28: uint8(38),
 		29: uint8(40),
 		30: uint8(41),
 		31: uint8(43),
 		32: uint8(44),
 		33: uint8(46),
 		34: uint8(47),
 		35: uint8(49),
 		36: uint8(50),
 		37: uint8(52),
 		38: uint8(53),
 		39: uint8(55),
 		40: uint8(56),
 		41: uint8(58),
 		42: uint8(59),
 		43: uint8(61),
 		44: uint8(62),
 		45: uint8(63),
 		46: uint8(63),
 		47: uint8(63),
 		48: uint8(63),
 		49: uint8(63),
 		50: uint8(63),
 		51: uint8(63),
 		52: uint8(63),
 		53: uint8(63),
 		54: uint8(63),
 		55: uint8(63),
 		56: uint8(63),
 		57: uint8(63),
 		58: uint8(63),
 		59: uint8(63),
 		60: uint8(63),
 		61: uint8(63),
 		62: uint8(63),
 		63: uint8(63),
 	},
 	3: {
 		1:  uint8(1),
 		2:  uint8(2),
 		3:  uint8(3),
 		4:  uint8(5),
 		5:  uint8(6),
 		6:  uint8(7),
 		7:  uint8(8),
 		8:  uint8(9),
 		9:  uint8(11),
 		10: uint8(12),
 		11: uint8(13),
 		12: uint8(15),
 		13: uint8(16),
 		14: uint8(18),
 		15: uint8(19),
 		16: uint8(21),
 		17: uint8(22),
 		18: uint8(24),
 		19: uint8(25),
 		20: uint8(27),
 		21: uint8(28),
 		22: uint8(30),
 		23: uint8(31),
 		24: uint8(33),
 		25: uint8(34),
 		26: uint8(36),
 		27: uint8(37),
 		28: uint8(39),
 		29: uint8(40),
 		30: uint8(42),
 		31: uint8(43),
 		32: uint8(45),
 		33: uint8(46),
 		34: uint8(48),
 		35: uint8(49),
 		36: uint8(51),
 		37: uint8(52),
 		38: uint8(54),
 		39: uint8(55),
 		40: uint8(57),
 		41: uint8(58),
 		42: uint8(60),
 		43: uint8(61),
 		44: uint8(63),
 		45: uint8(63),
 		46: uint8(63),
 		47: uint8(63),
 		48: uint8(63),
 		49: uint8(63),
 		50: uint8(63),
 		51: uint8(63),
 		52: uint8(63),
 		53: uint8(63),
 		54: uint8(63),
 		55: uint8(63),
 		56: uint8(63),
 		57: uint8(63),
 		58: uint8(63),
 		59: uint8(63),
 		60: uint8(63),
 		61: uint8(63),
 		62: uint8(63),
 		63: uint8(63),
 	},
 	4: {
 		1:  uint8(1),
 		2:  uint8(2),
 		3:  uint8(3),
 		4:  uint8(5),
 		5:  uint8(6),
 		6:  uint8(7),
 		7:  uint8(8),
 		8:  uint8(9),
 		9:  uint8(11),
 		10: uint8(12),
 		11: uint8(14),
 		12: uint8(15),
 		13: uint8(17),
 		14: uint8(18),
 		15: uint8(20),
 		16: uint8(21),
 		17: uint8(23),
 		18: uint8(24),
 		19: uint8(26),
 		20: uint8(27),
 		21: uint8(29),
 		22: uint8(30),
 		23: uint8(32),
 		24: uint8(33),
 		25: uint8(35),
 		26: uint8(36),
 		27: uint8(38),
 		28: uint8(39),
 		29: uint8(41),
 		30: uint8(42),
 		31: uint8(44),
 		32: uint8(45),
 		33: uint8(47),
 		34: uint8(48),
 		35: uint8(50),
 		36: uint8(51),
 		37: uint8(53),
 		38: uint8(54),
 		39: uint8(56),
 		40: uint8(57),
 		41: uint8(59),
 		42: uint8(60),
 		43: uint8(62),
 		44: uint8(63),
 		45: uint8(63),
 		46: uint8(63),
 		47: uint8(63),
 		48: uint8(63),
 		49: uint8(63),
 		50: uint8(63),
 		51: uint8(63),
 		52: uint8(63),
 		53: uint8(63),
 		54: uint8(63),
 		55: uint8(63),
 		56: uint8(63),
 		57: uint8(63),
 		58: uint8(63),
 		59: uint8(63),
 		60: uint8(63),
 		61: uint8(63),
 		62: uint8(63),
 		63: uint8(63),
 	},
 	5: {
 		1:  uint8(1),
 		2:  uint8(2),
 		3:  uint8(4),
 		4:  uint8(5),
 		5:  uint8(7),
 		6:  uint8(8),
 		7:  uint8(9),
 		8:  uint8(11),
 		9:  uint8(12),
 		10: uint8(13),
 		11: uint8(15),
 		12: uint8(16),
 		13: uint8(17),
 		14: uint8(19),
 		15: uint8(20),
 		16: uint8(22),
 		17: uint8(23),
 		18: uint8(25),
 		19: uint8(26),
 		20: uint8(28),
 		21: uint8(29),
 		22: uint8(31),
 		23: uint8(32),
 		24: uint8(34),
 		25: uint8(35),
 		26: uint8(37),
 		27: uint8(38),
 		28: uint8(40),
 		29: uint8(41),
 		30: uint8(43),
 		31: uint8(44),
 		32: uint8(46),
 		33: uint8(47),
 		34: uint8(49),
 		35: uint8(50),
 		36: uint8(52),
 		37: uint8(53),
 		38: uint8(55),
 		39: uint8(56),
 		40: uint8(58),
 		41: uint8(59),
 		42: uint8(61),
 		43: uint8(62),
 		44: uint8(63),
 		45: uint8(63),
 		46: uint8(63),
 		47: uint8(63),
 		48: uint8(63),
 		49: uint8(63),
 		50: uint8(63),
 		51: uint8(63),
 		52: uint8(63),
 		53: uint8(63),
 		54: uint8(63),
 		55: uint8(63),
 		56: uint8(63),
 		57: uint8(63),
 		58: uint8(63),
 		59: uint8(63),
 		60: uint8(63),
 		61: uint8(63),
 		62: uint8(63),
 		63: uint8(63),
 	},
 	6: {
 		1:  uint8(1),
 		2:  uint8(2),
 		3:  uint8(4),
 		4:  uint8(5),
 		5:  uint8(7),
 		6:  uint8(8),
 		7:  uint8(9),
 		8:  uint8(11),
 		9:  uint8(12),
 		10: uint8(13),
 		11: uint8(15),
 		12: uint8(16),
 		13: uint8(18),
 		14: uint8(19),
 		15: uint8(21),
 		16: uint8(22),
 		17: uint8(24),
 		18: uint8(25),
 		19: uint8(27),
 		20: uint8(28),
 		21: uint8(30),
 		22: uint8(31),
 		23: uint8(33),
 		24: uint8(34),
 		25: uint8(36),
 		26: uint8(37),
 		27: uint8(39),
 		28: uint8(40),
 		29: uint8(42),
 		30: uint8(43),
 		31: uint8(45),
 		32: uint8(46),
 		33: uint8(48),
 		34: uint8(49),
 		35: uint8(51),
 		36: uint8(52),
 		37: uint8(54),
 		38: uint8(55),
 		39: uint8(57),
 		40: uint8(58),
 		41: uint8(60),
 		42: uint8(61),
 		43: uint8(63),
 		44: uint8(63),
 		45: uint8(63),
 		46: uint8(63),
 		47: uint8(63),
 		48: uint8(63),
 		49: uint8(63),
 		50: uint8(63),
 		51: uint8(63),
 		52: uint8(63),
 		53: uint8(63),
 		54: uint8(63),
 		55: uint8(63),
 		56: uint8(63),
 		57: uint8(63),
 		58: uint8(63),
 		59: uint8(63),
 		60: uint8(63),
 		61: uint8(63),
 		62: uint8(63),
 		63: uint8(63),
 	},
 	7: {
 		1:  uint8(1),
 		2:  uint8(2),
 		3:  uint8(4),
 		4:  uint8(5),
 		5:  uint8(7),
 		6:  uint8(8),
 		7:  uint8(9),
 		8:  uint8(11),
 		9:  uint8(12),
 		10: uint8(14),
 		11: uint8(15),
 		12: uint8(17),
 		13: uint8(18),
 		14: uint8(20),
 		15: uint8(21),
 		16: uint8(23),
 		17: uint8(24),
 		18: uint8(26),
 		19: uint8(27),
 		20: uint8(29),
 		21: uint8(30),
 		22: uint8(32),
 		23: uint8(33),
 		24: uint8(35),
 		25: uint8(36),
 		26: uint8(38),
 		27: uint8(39),
 		28: uint8(41),
 		29: uint8(42),
 		30: uint8(44),
 		31: uint8(45),
 		32: uint8(47),
 		33: uint8(48),
 		34: uint8(50),
 		35: uint8(51),
 		36: uint8(53),
 		37: uint8(54),
 		38: uint8(56),
 		39: uint8(57),
 		40: uint8(59),
 		41: uint8(60),
 		42: uint8(62),
 		43: uint8(63),
 		44: uint8(63),
 		45: uint8(63),
 		46: uint8(63),
 		47: uint8(63),
 		48: uint8(63),
 		49: uint8(63),
 		50: uint8(63),
 		51: uint8(63),
 		52: uint8(63),
 		53: uint8(63),
 		54: uint8(63),
 		55: uint8(63),
 		56: uint8(63),
 		57: uint8(63),
 		58: uint8(63),
 		59: uint8(63),
 		60: uint8(63),
 		61: uint8(63),
 		62: uint8(63),
 		63: uint8(63),
 	},
 }
 
 func VP8FilterStrengthFromDelta(tls *libc.TLS, sharpness int32, delta int32) (r int32) {
 	var pos, v1 int32
 	_, _ = pos, v1
 	if delta < int32(MAX_DELTA_SIZE) {
 		v1 = delta
 	} else {
 		v1 = libc.Int32FromInt32(MAX_DELTA_SIZE) - libc.Int32FromInt32(1)
 	}
 	pos = v1
 	return libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(uintptr(unsafe.Pointer(&kLevelsFromDelta)) + uintptr(sharpness)*64 + uintptr(pos))))
 }
 
 //------------------------------------------------------------------------------
 // Paragraph 15.4: compute the inner-edge filtering strength
 
 func GetILevel(tls *libc.TLS, sharpness int32, level int32) (r int32) {
 	if sharpness > 0 {
 		if sharpness > int32(4) {
 			level = level >> int32(2)
 		} else {
 			level = level >> int32(1)
 		}
 		if level > int32(9)-sharpness {
 			level = int32(9) - sharpness
 		}
 	}
 	if level < int32(1) {
 		level = int32(1)
 	}
 	return level
 }
 
 func DoFilter1(tls *libc.TLS, it uintptr, level int32) {
 	var enc, u_dst, v_dst, y_dst uintptr
 	var hev_thresh, ilevel, limit, v1, v2 int32
 	_, _, _, _, _, _, _, _, _ = enc, hev_thresh, ilevel, limit, u_dst, v_dst, y_dst, v1, v2
 	enc = (*VP8EncIterator)(unsafe.Pointer(it)).Fenc
 	ilevel = GetILevel(tls, (*WebPConfig)(unsafe.Pointer((*VP8Encoder)(unsafe.Pointer(enc)).Fconfig)).Ffilter_sharpness, level)
 	limit = int32(2)*level + ilevel
 	y_dst = (*VP8EncIterator)(unsafe.Pointer(it)).Fyuv_out2 + uintptr(libc.Int32FromInt32(Y_OFF_ENC))
 	u_dst = (*VP8EncIterator)(unsafe.Pointer(it)).Fyuv_out2 + uintptr(libc.Int32FromInt32(U_OFF_ENC))
 	v_dst = (*VP8EncIterator)(unsafe.Pointer(it)).Fyuv_out2 + uintptr(libc.Int32FromInt32(16)+libc.Int32FromInt32(8))
 	// copy current block to yuv_out2
 	libc.X__builtin___memcpy_chk(tls, y_dst, (*VP8EncIterator)(unsafe.Pointer(it)).Fyuv_out, libc.Uint64FromInt32(libc.Int32FromInt32(BPS)*libc.Int32FromInt32(16))*libc.Uint64FromInt64(1), ^__predefined_size_t(0))
 	if (*VP8Encoder)(unsafe.Pointer(enc)).Ffilter_hdr.Fsimple == int32(1) { // simple
 		(*(*func(*libc.TLS, uintptr, int32, int32))(unsafe.Pointer(&struct{ uintptr }{VP8SimpleHFilter16i})))(tls, y_dst, int32(BPS), limit)
 		(*(*func(*libc.TLS, uintptr, int32, int32))(unsafe.Pointer(&struct{ uintptr }{VP8SimpleVFilter16i})))(tls, y_dst, int32(BPS), limit)
 	} else {
 		if level >= int32(40) {
 			v1 = int32(2)
 		} else {
 			if level >= int32(15) {
 				v2 = int32(1)
 			} else {
 				v2 = 0
 			}
 			v1 = v2
 		} // complex
 		hev_thresh = v1
 		(*(*func(*libc.TLS, uintptr, int32, int32, int32, int32))(unsafe.Pointer(&struct{ uintptr }{VP8HFilter16i})))(tls, y_dst, int32(BPS), limit, ilevel, hev_thresh)
 		(*(*func(*libc.TLS, uintptr, uintptr, int32, int32, int32, int32))(unsafe.Pointer(&struct{ uintptr }{VP8HFilter8i})))(tls, u_dst, v_dst, int32(BPS), limit, ilevel, hev_thresh)
 		(*(*func(*libc.TLS, uintptr, int32, int32, int32, int32))(unsafe.Pointer(&struct{ uintptr }{VP8VFilter16i})))(tls, y_dst, int32(BPS), limit, ilevel, hev_thresh)
 		(*(*func(*libc.TLS, uintptr, uintptr, int32, int32, int32, int32))(unsafe.Pointer(&struct{ uintptr }{VP8VFilter8i})))(tls, u_dst, v_dst, int32(BPS), limit, ilevel, hev_thresh)
 	}
 }
 
 //------------------------------------------------------------------------------
 // SSIM metric for one macroblock
 
 func GetMBSSIM(tls *libc.TLS, yuv1 uintptr, yuv2 uintptr) (r float64) {
 	var sum float64
 	var x, y int32
 	_, _, _ = sum, x, y
 	sum = float64(0)
 	// compute SSIM in a 10 x 10 window
 	y = int32(VP8_SSIM_KERNEL)
 	for {
 		if !(y < libc.Int32FromInt32(16)-libc.Int32FromInt32(VP8_SSIM_KERNEL)) {
 			break
 		}
 		x = int32(VP8_SSIM_KERNEL)
 		for {
 			if !(x < libc.Int32FromInt32(16)-libc.Int32FromInt32(VP8_SSIM_KERNEL)) {
 				break
 			}
 			sum = sum + (*(*func(*libc.TLS, uintptr, int32, uintptr, int32, int32, int32, int32, int32) float64)(unsafe.Pointer(&struct{ uintptr }{VP8SSIMGetClipped})))(tls, yuv1+uintptr(libc.Int32FromInt32(Y_OFF_ENC)), int32(BPS), yuv2+uintptr(libc.Int32FromInt32(Y_OFF_ENC)), int32(BPS), x, y, int32(16), int32(16))
 			goto _2
 		_2:
 			;
 			x = x + 1
 		}
 		goto _1
 	_1:
 		;
 		y = y + 1
 	}
 	x = int32(1)
 	for {
 		if !(x < int32(7)) {
 			break
 		}
 		y = int32(1)
 		for {
 			if !(y < int32(7)) {
 				break
 			}
 			sum = sum + (*(*func(*libc.TLS, uintptr, int32, uintptr, int32, int32, int32, int32, int32) float64)(unsafe.Pointer(&struct{ uintptr }{VP8SSIMGetClipped})))(tls, yuv1+uintptr(libc.Int32FromInt32(U_OFF_ENC)), int32(BPS), yuv2+uintptr(libc.Int32FromInt32(U_OFF_ENC)), int32(BPS), x, y, int32(8), int32(8))
 			sum = sum + (*(*func(*libc.TLS, uintptr, int32, uintptr, int32, int32, int32, int32, int32) float64)(unsafe.Pointer(&struct{ uintptr }{VP8SSIMGetClipped})))(tls, yuv1+uintptr(libc.Int32FromInt32(16)+libc.Int32FromInt32(8)), int32(BPS), yuv2+uintptr(libc.Int32FromInt32(16)+libc.Int32FromInt32(8)), int32(BPS), x, y, int32(8), int32(8))
 			goto _4
 		_4:
 			;
 			y = y + 1
 		}
 		goto _3
 	_3:
 		;
 		x = x + 1
 	}
 	return sum
 }
 
 //------------------------------------------------------------------------------
 // Exposed APIs: Encoder should call the following 3 functions to adjust
 // loop filter strength
 
 func VP8InitFilter(tls *libc.TLS, it uintptr) {
 	var i, s int32
 	_, _ = i, s
 	if (*VP8EncIterator)(unsafe.Pointer(it)).Flf_stats != libc.UintptrFromInt32(0) {
 		s = 0
 		for {
 			if !(s < int32(NUM_MB_SEGMENTS)) {
 				break
 			}
 			i = 0
 			for {
 				if !(i < int32(MAX_LF_LEVELS)) {
 					break
 				}
 				**(**float64)(__ccgo_up((*VP8EncIterator)(unsafe.Pointer(it)).Flf_stats + uintptr(s)*512 + uintptr(i)*8)) = libc.Float64FromInt32(0)
 				goto _2
 			_2:
 				;
 				i = i + 1
 			}
 			goto _1
 		_1:
 			;
 			s = s + 1
 		}
 		VP8SSIMDspInit(tls)
 	}
 }
 
 func VP8StoreFilterStats(tls *libc.TLS, it uintptr) {
 	var d, delta_max, delta_min, level, level0, s, step_size, v1 int32
 	var enc uintptr
 	_, _, _, _, _, _, _, _, _ = d, delta_max, delta_min, enc, level, level0, s, step_size, v1
 	enc = (*VP8EncIterator)(unsafe.Pointer(it)).Fenc
 	s = int32(uint32(*(*uint8)(unsafe.Pointer((*VP8EncIterator)(unsafe.Pointer(it)).Fmb + 0)) & 0x60 >> 5))
 	level0 = (**(**VP8SegmentInfo)(__ccgo_up(enc + 608 + uintptr(s)*744))).Ffstrength
 	// explore +/-quant range of values around level0
 	delta_min = -(**(**VP8SegmentInfo)(__ccgo_up(enc + 608 + uintptr(s)*744))).Fquant
 	delta_max = (**(**VP8SegmentInfo)(__ccgo_up(enc + 608 + uintptr(s)*744))).Fquant
 	if delta_max-delta_min >= int32(4) {
 		v1 = int32(4)
 	} else {
 		v1 = int32(1)
 	}
 	step_size = v1
 	if (*VP8EncIterator)(unsafe.Pointer(it)).Flf_stats == libc.UintptrFromInt32(0) {
 		return
 	}
 	// NOTE: Currently we are applying filter only across the sublock edges
 	// There are two reasons for that.
 	// 1. Applying filter on macro block edges will change the pixels in
 	// the left and top macro blocks. That will be hard to restore
 	// 2. Macro Blocks on the bottom and right are not yet compressed. So we
 	// cannot apply filter on the right and bottom macro block edges.
 	if int32(uint32(*(*uint8)(unsafe.Pointer((*VP8EncIterator)(unsafe.Pointer(it)).Fmb + 0))&0x3>>0)) == int32(1) && int32(uint32(*(*uint8)(unsafe.Pointer((*VP8EncIterator)(unsafe.Pointer(it)).Fmb + 0))&0x10>>4)) != 0 {
 		return
 	}
 	// Always try filter level  zero
 	**(**float64)(__ccgo_up((*VP8EncIterator)(unsafe.Pointer(it)).Flf_stats + uintptr(s)*512)) += GetMBSSIM(tls, (*VP8EncIterator)(unsafe.Pointer(it)).Fyuv_in, (*VP8EncIterator)(unsafe.Pointer(it)).Fyuv_out)
 	d = delta_min
 	for {
 		if !(d <= delta_max) {
 			break
 		}
 		level = level0 + d
 		if level <= 0 || level >= int32(MAX_LF_LEVELS) {
 			goto _2
 		}
 		DoFilter1(tls, it, level)
 		**(**float64)(__ccgo_up((*VP8EncIterator)(unsafe.Pointer(it)).Flf_stats + uintptr(s)*512 + uintptr(level)*8)) += GetMBSSIM(tls, (*VP8EncIterator)(unsafe.Pointer(it)).Fyuv_in, (*VP8EncIterator)(unsafe.Pointer(it)).Fyuv_out2)
 		goto _2
 	_2:
 		;
 		d = d + step_size
 	}
 }
 
 func VP8AdjustFilterStrength(tls *libc.TLS, it uintptr) {
 	var best_level, delta, i, level, max_level, s, s1 int32
 	var best_v, v float64
 	var dqm, enc uintptr
 	_, _, _, _, _, _, _, _, _, _, _ = best_level, best_v, delta, dqm, enc, i, level, max_level, s, s1, v
 	enc = (*VP8EncIterator)(unsafe.Pointer(it)).Fenc
 	if (*VP8EncIterator)(unsafe.Pointer(it)).Flf_stats != libc.UintptrFromInt32(0) {
 		s = 0
 		for {
 			if !(s < int32(NUM_MB_SEGMENTS)) {
 				break
 			}
 			best_level = 0
 			// Improvement over filter level 0 should be at least 1e-5 (relatively)
 			best_v = float64(float64(1.00001) * **(**float64)(__ccgo_up((*VP8EncIterator)(unsafe.Pointer(it)).Flf_stats + uintptr(s)*512)))
 			i = int32(1)
 			for {
 				if !(i < int32(MAX_LF_LEVELS)) {
 					break
 				}
 				v = **(**float64)(__ccgo_up((*VP8EncIterator)(unsafe.Pointer(it)).Flf_stats + uintptr(s)*512 + uintptr(i)*8))
 				if v > best_v {
 					best_v = v
 					best_level = i
 				}
 				goto _2
 			_2:
 				;
 				i = i + 1
 			}
 			(**(**VP8SegmentInfo)(__ccgo_up(enc + 608 + uintptr(s)*744))).Ffstrength = best_level
 			goto _1
 		_1:
 			;
 			s = s + 1
 		}
 		return
 	}
 	if (*WebPConfig)(unsafe.Pointer((*VP8Encoder)(unsafe.Pointer(enc)).Fconfig)).Ffilter_strength > 0 {
 		max_level = 0
 		s1 = 0
 		for {
 			if !(s1 < int32(NUM_MB_SEGMENTS)) {
 				break
 			}
 			dqm = enc + 608 + uintptr(s1)*744
 			// this '>> 3' accounts for some inverse WHT scaling
 			delta = (*VP8SegmentInfo)(unsafe.Pointer(dqm)).Fmax_edge * libc.Int32FromUint16(**(**uint16_t)(__ccgo_up(dqm + 224 + 1*2))) >> int32(3)
 			level = VP8FilterStrengthFromDelta(tls, (*VP8Encoder)(unsafe.Pointer(enc)).Ffilter_hdr.Fsharpness, delta)
 			if level > (*VP8SegmentInfo)(unsafe.Pointer(dqm)).Ffstrength {
 				(*VP8SegmentInfo)(unsafe.Pointer(dqm)).Ffstrength = level
 			}
 			if max_level < (*VP8SegmentInfo)(unsafe.Pointer(dqm)).Ffstrength {
 				max_level = (*VP8SegmentInfo)(unsafe.Pointer(dqm)).Ffstrength
 			}
 			goto _3
 		_3:
 			;
 			s1 = s1 + 1
 		}
 		(*VP8Encoder)(unsafe.Pointer(enc)).Ffilter_hdr.Flevel = max_level
 	}
 }
 
 const DEBUG_SEARCH = 0
 const DOMAIN = 1
 const DQ_LIMIT = 0.4
 const FP_INFINITE = 2
 const FP_NAN = 1
 const FP_NORMAL = 4
 const FP_QNAN = "FP_NAN"
 const FP_SNAN = "FP_NAN"
 const FP_SUBNORMAL = 5
 const FP_SUPERNORMAL = 6
 const FP_ZERO = 3
 const HUGE = "MAXFLOAT"
 const INFINITY = "HUGE_VALF"
 const MATH_ERREXCEPT = 2
 const MATH_ERRNO = 1
 const MAXFLOAT = "0x1.fffffep+127f"
 const MIN_COUNT = 96
 const M_1_PI = 0.318309886183790671537767526745028724
 const M_2_PI = 0.636619772367581343075535053490057448
 const M_2_SQRTPI = 1.12837916709551257389615890312154517
 const M_E = 2.71828182845904523536028747135266250
 const M_LN10 = 2.30258509299404568401799145468436421
 const M_LN2 = 0.693147180559945309417232121458176568
 const M_LOG10E = 0.434294481903251827651128918916605082
 const M_LOG2E = 1.44269504088896340735992468100189214
 const M_PI = 3.14159265358979323846264338327950288
 const M_PI_2 = 1.57079632679489661923132169163975144
 const M_PI_4 = 0.785398163397448309615660845819875721
 const M_SQRT1_2 = 0.707106781186547524400844362104849039
 const M_SQRT2 = 1.41421356237309504880168872420969808
 const OVERFLOW = 3
 const PLOSS = 6
 const SEGMENT_VISU = 0
 const SING = 2
 const SKIP_PROBA_THRESHOLD = 250
 const TLOSS = 5
 const UNDERFLOW = 4
 const X_TLOSS = 1.41484755040568800000e+16
 const __FLT_MIN__1 = 1.1754943508222875e-38
 
 type float_t = float32
 
 type double_t = float64
 
 type __float2 = struct {
 	F__sinval float32
 	F__cosval float32
 }
 
 type __double2 = struct {
 	F__sinval float64
 	F__cosval float64
 }
 
 type exception = struct {
 	Ftype1  int32
 	Fname   uintptr
 	Farg1   float64
 	Farg2   float64
 	Fretval float64
 }
 
 // Alpha related constants.
 
 // Mux related constants.
 
 // Maximum chunk payload is such that adding the header and padding won't
 // overflow a uint32_t.
 
 //------------------------------------------------------------------------------
 // multi-pass convergence
 
 // we allow 2k of extra head-room in PARTITION0 limit.
 
 func Clamp(tls *libc.TLS, v float32, min float32, max float32) (r float32) {
 	var v1, v2 float32
 	_, _ = v1, v2
 	if v < min {
 		v1 = min
 	} else {
 		if v > max {
 			v2 = max
 		} else {
 			v2 = v
 		}
 		v1 = v2
 	}
 	return v1
 }
 
 type PassStats = struct {
 	Fis_first       int32
 	Fdq             float32
 	Fq              float32
 	Flast_q         float32
 	Fqmin           float32
 	Fqmax           float32
 	Fvalue          float64
 	Flast_value     float64
 	Ftarget         float64
 	Fdo_size_search int32
 }
 
 func InitPassStats(tls *libc.TLS, enc uintptr, s uintptr) (r int32) {
 	var do_size_search int32
 	var target_PSNR, v1 float32
 	var target_size uint64_t
 	var v2, v3 float64
 	_, _, _, _, _, _ = do_size_search, target_PSNR, target_size, v1, v2, v3
 	target_size = libc.Uint64FromInt32((*WebPConfig)(unsafe.Pointer((*VP8Encoder)(unsafe.Pointer(enc)).Fconfig)).Ftarget_size)
 	do_size_search = libc.BoolInt32(target_size != libc.Uint64FromInt32(0))
 	target_PSNR = (*WebPConfig)(unsafe.Pointer((*VP8Encoder)(unsafe.Pointer(enc)).Fconfig)).Ftarget_PSNR
 	(*PassStats)(unsafe.Pointer(s)).Fis_first = int32(1)
 	(*PassStats)(unsafe.Pointer(s)).Fdq = libc.Float32FromFloat32(10)
 	(*PassStats)(unsafe.Pointer(s)).Fqmin = float32(libc.Float32FromFloat32(1) * float32((*WebPConfig)(unsafe.Pointer((*VP8Encoder)(unsafe.Pointer(enc)).Fconfig)).Fqmin))
 	(*PassStats)(unsafe.Pointer(s)).Fqmax = float32(libc.Float32FromFloat32(1) * float32((*WebPConfig)(unsafe.Pointer((*VP8Encoder)(unsafe.Pointer(enc)).Fconfig)).Fqmax))
 	v1 = Clamp(tls, (*WebPConfig)(unsafe.Pointer((*VP8Encoder)(unsafe.Pointer(enc)).Fconfig)).Fquality, (*PassStats)(unsafe.Pointer(s)).Fqmin, (*PassStats)(unsafe.Pointer(s)).Fqmax)
 	(*PassStats)(unsafe.Pointer(s)).Flast_q = v1
 	(*PassStats)(unsafe.Pointer(s)).Fq = v1
 	if do_size_search != 0 {
 		v2 = float64(target_size)
 	} else {
 		if float64(target_PSNR) > float64(0) {
 			v3 = float64(target_PSNR)
 		} else {
 			v3 = float64(40)
 		}
 		v2 = v3
 	}
 	(*PassStats)(unsafe.Pointer(s)).Ftarget = v2 // default, just in case
 	v2 = libc.Float64FromFloat64(0)
 	(*PassStats)(unsafe.Pointer(s)).Flast_value = v2
 	(*PassStats)(unsafe.Pointer(s)).Fvalue = v2
 	(*PassStats)(unsafe.Pointer(s)).Fdo_size_search = do_size_search
 	return do_size_search
 }
 
 func ComputeNextQ(tls *libc.TLS, s uintptr) (r float32) {
 	var dq, v1 float32
 	var slope float64
 	_, _, _ = dq, slope, v1
 	if (*PassStats)(unsafe.Pointer(s)).Fis_first != 0 {
 		if (*PassStats)(unsafe.Pointer(s)).Fvalue > (*PassStats)(unsafe.Pointer(s)).Ftarget {
 			v1 = -(*PassStats)(unsafe.Pointer(s)).Fdq
 		} else {
 			v1 = (*PassStats)(unsafe.Pointer(s)).Fdq
 		}
 		dq = v1
 		(*PassStats)(unsafe.Pointer(s)).Fis_first = 0
 	} else {
 		if (*PassStats)(unsafe.Pointer(s)).Fvalue != (*PassStats)(unsafe.Pointer(s)).Flast_value {
 			slope = ((*PassStats)(unsafe.Pointer(s)).Ftarget - (*PassStats)(unsafe.Pointer(s)).Fvalue) / ((*PassStats)(unsafe.Pointer(s)).Flast_value - (*PassStats)(unsafe.Pointer(s)).Fvalue)
 			dq = float32(float64(slope * float64((*PassStats)(unsafe.Pointer(s)).Flast_q-(*PassStats)(unsafe.Pointer(s)).Fq)))
 		} else {
 			dq = float32(0) // we're done?!
 		}
 	}
 	// Limit variable to avoid large swings.
 	(*PassStats)(unsafe.Pointer(s)).Fdq = Clamp(tls, dq, -libc.Float32FromFloat32(30), libc.Float32FromFloat32(30))
 	(*PassStats)(unsafe.Pointer(s)).Flast_q = (*PassStats)(unsafe.Pointer(s)).Fq
 	(*PassStats)(unsafe.Pointer(s)).Flast_value = (*PassStats)(unsafe.Pointer(s)).Fvalue
 	(*PassStats)(unsafe.Pointer(s)).Fq = Clamp(tls, (*PassStats)(unsafe.Pointer(s)).Fq+(*PassStats)(unsafe.Pointer(s)).Fdq, (*PassStats)(unsafe.Pointer(s)).Fqmin, (*PassStats)(unsafe.Pointer(s)).Fqmax)
 	return (*PassStats)(unsafe.Pointer(s)).Fq
 }
 
 //------------------------------------------------------------------------------
 // Reset the statistics about: number of skips, token proba, level cost,...
 
 func ResetStats(tls *libc.TLS, enc uintptr) {
 	var proba uintptr
 	_ = proba
 	proba = enc + 3616
 	VP8CalculateLevelCosts(tls, proba)
 	(*VP8EncProba)(unsafe.Pointer(proba)).Fnb_skip = 0
 }
 
 //------------------------------------------------------------------------------
 // Skip decision probability
 
 func CalcSkipProba(tls *libc.TLS, nb uint64_t, total uint64_t) (r int32) {
 	var v1 uint64
 	_ = v1
 	if total != 0 {
 		v1 = (total - nb) * uint64(255) / total
 	} else {
 		v1 = uint64(255)
 	}
 	return libc.Int32FromUint64(v1)
 }
 
 // C documentation
 //
 //	// Returns the bit-cost for coding the skip probability.
 func FinalizeSkipProba(tls *libc.TLS, enc uintptr) (r int32) {
 	var nb_events, nb_mbs, size, v2, v4, v6, v8 int32
 	var proba1 uintptr
 	var v1, v5 uint8_t
 	_, _, _, _, _, _, _, _, _, _ = nb_events, nb_mbs, proba1, size, v1, v2, v4, v5, v6, v8
 	proba1 = enc + 3616
 	nb_mbs = (*VP8Encoder)(unsafe.Pointer(enc)).Fmb_w * (*VP8Encoder)(unsafe.Pointer(enc)).Fmb_h
 	nb_events = (*VP8EncProba)(unsafe.Pointer(proba1)).Fnb_skip
 	(*VP8EncProba)(unsafe.Pointer(proba1)).Fskip_proba = libc.Uint8FromInt32(CalcSkipProba(tls, libc.Uint64FromInt32(nb_events), libc.Uint64FromInt32(nb_mbs)))
 	(*VP8EncProba)(unsafe.Pointer(proba1)).Fuse_skip_proba = libc.BoolInt32(libc.Int32FromUint8((*VP8EncProba)(unsafe.Pointer(proba1)).Fskip_proba) < int32(SKIP_PROBA_THRESHOLD))
 	size = int32(256) // 'use_skip_proba' bit
 	if (*VP8EncProba)(unsafe.Pointer(proba1)).Fuse_skip_proba != 0 {
 		v1 = (*VP8EncProba)(unsafe.Pointer(proba1)).Fskip_proba
 		if !(int32(1) != 0) {
 			v4 = libc.Int32FromUint16(VP8EntropyCost[v1])
 		} else {
 			v4 = libc.Int32FromUint16(VP8EntropyCost[int32(255)-libc.Int32FromUint8(v1)])
 		}
 		v2 = v4
 		goto _3
 	_3:
 		v5 = (*VP8EncProba)(unsafe.Pointer(proba1)).Fskip_proba
 		if !(0 != 0) {
 			v8 = libc.Int32FromUint16(VP8EntropyCost[v5])
 		} else {
 			v8 = libc.Int32FromUint16(VP8EntropyCost[int32(255)-libc.Int32FromUint8(v5)])
 		}
 		v6 = v8
 		goto _7
 	_7:
 		size = size + (nb_events*v2 + (nb_mbs-nb_events)*v6)
 		size = size + libc.Int32FromInt32(8)*libc.Int32FromInt32(256) // cost of signaling the 'skip_proba' itself.
 	}
 	return size
 }
 
 // C documentation
 //
 //	// Collect statistics and deduce probabilities for next coding pass.
 //	// Return the total bit-cost for coding the probability updates.
 func CalcTokenProba(tls *libc.TLS, nb int32, total int32) (r int32) {
 	var v1 int32
 	_ = v1
 	if nb != 0 {
 		v1 = int32(255) - nb*int32(255)/total
 	} else {
 		v1 = int32(255)
 	}
 	return v1
 }
 
 // C documentation
 //
 //	// Cost of coding 'nb' 1's and 'total-nb' 0's using 'proba' probability.
 func BranchCost(tls *libc.TLS, nb int32, total int32, proba1 int32) (r int32) {
 	var v1, v5 uint8_t
 	var v2, v4, v6, v8 int32
 	_, _, _, _, _, _ = v1, v2, v4, v5, v6, v8
 	v1 = libc.Uint8FromInt32(proba1)
 	if !(int32(1) != 0) {
 		v4 = libc.Int32FromUint16(VP8EntropyCost[v1])
 	} else {
 		v4 = libc.Int32FromUint16(VP8EntropyCost[int32(255)-libc.Int32FromUint8(v1)])
 	}
 	v2 = v4
 	goto _3
 _3:
 	v5 = libc.Uint8FromInt32(proba1)
 	if !(0 != 0) {
 		v8 = libc.Int32FromUint16(VP8EntropyCost[v5])
 	} else {
 		v8 = libc.Int32FromUint16(VP8EntropyCost[int32(255)-libc.Int32FromUint8(v5)])
 	}
 	v6 = v8
 	goto _7
 _7:
 	return nb*v2 + (total-nb)*v6
 }
 
 func ResetTokenStats(tls *libc.TLS, enc uintptr) {
 	var proba uintptr
 	_ = proba
 	proba = enc + 3616
 	libc.X__builtin___memset_chk(tls, proba+1060, 0, uint64(4224), ^__predefined_size_t(0))
 }
 
 func FinalizeTokenProbas(tls *libc.TLS, proba1 uintptr) (r int32) {
 	var b, c, has_changed, nb, new_cost, new_p, old_cost, old_p, p, size, t, total, update_proba, use_new_p, v10, v12, v14, v16, v6, v8 int32
 	var stats proba_t
 	var v13, v5, v9 uint8_t
 	_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = b, c, has_changed, nb, new_cost, new_p, old_cost, old_p, p, size, stats, t, total, update_proba, use_new_p, v10, v12, v13, v14, v16, v5, v6, v8, v9
 	has_changed = 0
 	size = 0
 	t = 0
 	for {
 		if !(t < int32(NUM_TYPES)) {
 			break
 		}
 		b = 0
 		for {
 			if !(b < int32(NUM_BANDS)) {
 				break
 			}
 			c = 0
 			for {
 				if !(c < int32(NUM_CTX)) {
 					break
 				}
 				p = 0
 				for {
 					if !(p < int32(NUM_PROBAS)) {
 						break
 					}
 					stats = **(**proba_t)(__ccgo_up(proba1 + 1060 + uintptr(t)*1056 + uintptr(b)*132 + uintptr(c)*44 + uintptr(p)*4))
 					nb = libc.Int32FromUint32(stats >> libc.Int32FromInt32(0) & uint32(0xffff))
 					total = libc.Int32FromUint32(stats >> libc.Int32FromInt32(16) & uint32(0xffff))
 					update_proba = libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(uintptr(unsafe.Pointer(&VP8CoeffsUpdateProba)) + uintptr(t)*264 + uintptr(b)*33 + uintptr(c)*11 + uintptr(p))))
 					old_p = libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(uintptr(unsafe.Pointer(&VP8CoeffsProba0)) + uintptr(t)*264 + uintptr(b)*33 + uintptr(c)*11 + uintptr(p))))
 					new_p = CalcTokenProba(tls, nb, total)
 					v5 = libc.Uint8FromInt32(update_proba)
 					if !(0 != 0) {
 						v8 = libc.Int32FromUint16(VP8EntropyCost[v5])
 					} else {
 						v8 = libc.Int32FromUint16(VP8EntropyCost[int32(255)-libc.Int32FromUint8(v5)])
 					}
 					v6 = v8
 					goto _7
 				_7:
 					old_cost = BranchCost(tls, nb, total, old_p) + v6
 					v9 = libc.Uint8FromInt32(update_proba)
 					if !(int32(1) != 0) {
 						v12 = libc.Int32FromUint16(VP8EntropyCost[v9])
 					} else {
 						v12 = libc.Int32FromUint16(VP8EntropyCost[int32(255)-libc.Int32FromUint8(v9)])
 					}
 					v10 = v12
 					goto _11
 				_11:
 					new_cost = BranchCost(tls, nb, total, new_p) + v10 + libc.Int32FromInt32(8)*libc.Int32FromInt32(256)
 					use_new_p = libc.BoolInt32(old_cost > new_cost)
 					v13 = libc.Uint8FromInt32(update_proba)
 					if !(use_new_p != 0) {
 						v16 = libc.Int32FromUint16(VP8EntropyCost[v13])
 					} else {
 						v16 = libc.Int32FromUint16(VP8EntropyCost[int32(255)-libc.Int32FromUint8(v13)])
 					}
 					v14 = v16
 					goto _15
 				_15:
 					size = size + v14
 					if use_new_p != 0 { // only use proba that seem meaningful enough.
 						**(**uint8_t)(__ccgo_up(proba1 + 4 + uintptr(t)*264 + uintptr(b)*33 + uintptr(c)*11 + uintptr(p))) = libc.Uint8FromInt32(new_p)
 						has_changed = has_changed | libc.BoolInt32(new_p != old_p)
 						size = size + libc.Int32FromInt32(8)*libc.Int32FromInt32(256)
 					} else {
 						**(**uint8_t)(__ccgo_up(proba1 + 4 + uintptr(t)*264 + uintptr(b)*33 + uintptr(c)*11 + uintptr(p))) = libc.Uint8FromInt32(old_p)
 					}
 					goto _4
 				_4:
 					;
 					p = p + 1
 				}
 				goto _3
 			_3:
 				;
 				c = c + 1
 			}
 			goto _2
 		_2:
 			;
 			b = b + 1
 		}
 		goto _1
 	_1:
 		;
 		t = t + 1
 	}
 	(*VP8EncProba)(unsafe.Pointer(proba1)).Fdirty = has_changed
 	return size
 }
 
 //------------------------------------------------------------------------------
 // Finalize Segment probability based on the coding tree
 
 func GetProba(tls *libc.TLS, a int32, b int32) (r int32) {
 	var total, v1 int32
 	_, _ = total, v1
 	total = a + b
 	if total == 0 {
 		v1 = int32(255)
 	} else {
 		v1 = (int32(255)*a + total/int32(2)) / total
 	}
 	return v1 // rounded proba
 }
 
 func ResetSegments(tls *libc.TLS, enc uintptr) {
 	var n int32
 	_ = n
 	n = 0
 	for {
 		if !(n < (*VP8Encoder)(unsafe.Pointer(enc)).Fmb_w*(*VP8Encoder)(unsafe.Pointer(enc)).Fmb_h) {
 			break
 		}
 		libc.SetBitFieldPtr8Uint32((*VP8Encoder)(unsafe.Pointer(enc)).Fmb_info+uintptr(n)*4+0, libc.Uint32FromInt32(0), 5, 0x60)
 		goto _1
 	_1:
 		;
 		n = n + 1
 	}
 }
 
 func SetSegmentProbas(tls *libc.TLS, enc uintptr) {
 	var mb, probas uintptr
 	var n, v10, v12, v14, v16, v18, v20, v22, v24, v26, v28, v30, v32, v34, v4, v6, v8 int32
 	var p [4]int32
 	var v11, v15, v19, v23, v27, v3, v31, v7 uint8_t
 	_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = mb, n, p, probas, v10, v11, v12, v14, v15, v16, v18, v19, v20, v22, v23, v24, v26, v27, v28, v3, v30, v31, v32, v34, v4, v6, v7, v8
 	p = [4]int32{}
 	n = 0
 	for {
 		if !(n < (*VP8Encoder)(unsafe.Pointer(enc)).Fmb_w*(*VP8Encoder)(unsafe.Pointer(enc)).Fmb_h) {
 			break
 		}
 		mb = (*VP8Encoder)(unsafe.Pointer(enc)).Fmb_info + uintptr(n)*4
 		p[int32(uint32(*(*uint8)(unsafe.Pointer(mb + 0))&0x60>>5))] = p[int32(uint32(*(*uint8)(unsafe.Pointer(mb + 0))&0x60>>5))] + 1
 		goto _1
 	_1:
 		;
 		n = n + 1
 	}
 	if (*WebPPicture)(unsafe.Pointer((*VP8Encoder)(unsafe.Pointer(enc)).Fpic)).Fstats != libc.UintptrFromInt32(0) {
 		n = 0
 		for {
 			if !(n < int32(NUM_MB_SEGMENTS)) {
 				break
 			}
 			**(**int32)(__ccgo_up((*WebPPicture)(unsafe.Pointer((*VP8Encoder)(unsafe.Pointer(enc)).Fpic)).Fstats + 92 + uintptr(n)*4)) = p[n]
 			goto _2
 		_2:
 			;
 			n = n + 1
 		}
 	}
 	if (*VP8Encoder)(unsafe.Pointer(enc)).Fsegment_hdr.Fnum_segments > int32(1) {
 		probas = enc + 3616
 		**(**uint8_t)(__ccgo_up(probas)) = libc.Uint8FromInt32(GetProba(tls, p[0]+p[int32(1)], p[int32(2)]+p[int32(3)]))
 		**(**uint8_t)(__ccgo_up(probas + 1)) = libc.Uint8FromInt32(GetProba(tls, p[0], p[int32(1)]))
 		**(**uint8_t)(__ccgo_up(probas + 2)) = libc.Uint8FromInt32(GetProba(tls, p[int32(2)], p[int32(3)]))
 		(*VP8Encoder)(unsafe.Pointer(enc)).Fsegment_hdr.Fupdate_map = libc.BoolInt32(libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(probas))) != int32(255) || libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(probas + 1))) != int32(255) || libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(probas + 2))) != int32(255))
 		if !((*VP8Encoder)(unsafe.Pointer(enc)).Fsegment_hdr.Fupdate_map != 0) {
 			ResetSegments(tls, enc)
 		}
 		v3 = **(**uint8_t)(__ccgo_up(probas))
 		if !(0 != 0) {
 			v6 = libc.Int32FromUint16(VP8EntropyCost[v3])
 		} else {
 			v6 = libc.Int32FromUint16(VP8EntropyCost[int32(255)-libc.Int32FromUint8(v3)])
 		}
 		v4 = v6
 		goto _5
 	_5:
 		v7 = **(**uint8_t)(__ccgo_up(probas + 1))
 		if !(0 != 0) {
 			v10 = libc.Int32FromUint16(VP8EntropyCost[v7])
 		} else {
 			v10 = libc.Int32FromUint16(VP8EntropyCost[int32(255)-libc.Int32FromUint8(v7)])
 		}
 		v8 = v10
 		goto _9
 	_9:
 		v11 = **(**uint8_t)(__ccgo_up(probas))
 		if !(0 != 0) {
 			v14 = libc.Int32FromUint16(VP8EntropyCost[v11])
 		} else {
 			v14 = libc.Int32FromUint16(VP8EntropyCost[int32(255)-libc.Int32FromUint8(v11)])
 		}
 		v12 = v14
 		goto _13
 	_13:
 		v15 = **(**uint8_t)(__ccgo_up(probas + 1))
 		if !(int32(1) != 0) {
 			v18 = libc.Int32FromUint16(VP8EntropyCost[v15])
 		} else {
 			v18 = libc.Int32FromUint16(VP8EntropyCost[int32(255)-libc.Int32FromUint8(v15)])
 		}
 		v16 = v18
 		goto _17
 	_17:
 		v19 = **(**uint8_t)(__ccgo_up(probas))
 		if !(int32(1) != 0) {
 			v22 = libc.Int32FromUint16(VP8EntropyCost[v19])
 		} else {
 			v22 = libc.Int32FromUint16(VP8EntropyCost[int32(255)-libc.Int32FromUint8(v19)])
 		}
 		v20 = v22
 		goto _21
 	_21:
 		v23 = **(**uint8_t)(__ccgo_up(probas + 2))
 		if !(0 != 0) {
 			v26 = libc.Int32FromUint16(VP8EntropyCost[v23])
 		} else {
 			v26 = libc.Int32FromUint16(VP8EntropyCost[int32(255)-libc.Int32FromUint8(v23)])
 		}
 		v24 = v26
 		goto _25
 	_25:
 		v27 = **(**uint8_t)(__ccgo_up(probas))
 		if !(int32(1) != 0) {
 			v30 = libc.Int32FromUint16(VP8EntropyCost[v27])
 		} else {
 			v30 = libc.Int32FromUint16(VP8EntropyCost[int32(255)-libc.Int32FromUint8(v27)])
 		}
 		v28 = v30
 		goto _29
 	_29:
 		v31 = **(**uint8_t)(__ccgo_up(probas + 2))
 		if !(int32(1) != 0) {
 			v34 = libc.Int32FromUint16(VP8EntropyCost[v31])
 		} else {
 			v34 = libc.Int32FromUint16(VP8EntropyCost[int32(255)-libc.Int32FromUint8(v31)])
 		}
 		v32 = v34
 		goto _33
 	_33:
 		(*VP8Encoder)(unsafe.Pointer(enc)).Fsegment_hdr.Fsize = p[0]*(v4+v8) + p[int32(1)]*(v12+v16) + p[int32(2)]*(v20+v24) + p[int32(3)]*(v28+v32)
 	} else {
 		(*VP8Encoder)(unsafe.Pointer(enc)).Fsegment_hdr.Fupdate_map = 0
 		(*VP8Encoder)(unsafe.Pointer(enc)).Fsegment_hdr.Fsize = 0
 	}
 }
 
 //------------------------------------------------------------------------------
 // Coefficient coding
 
 func PutCoeffs(tls *libc.TLS, bw uintptr, ctx int32, res uintptr) (r int32) {
 	var c, mask, n, sign, v, v1, v2 int32
 	var p, tab, v3 uintptr
 	_, _, _, _, _, _, _, _, _, _ = c, mask, n, p, sign, tab, v, v1, v2, v3
 	n = (*VP8Residual)(unsafe.Pointer(res)).Ffirst
 	// should be prob[VP8EncBands[n]], but it's equivalent for n=0 or 1
 	p = (*VP8Residual)(unsafe.Pointer(res)).Fprob + uintptr(n)*33 + uintptr(ctx)*11
 	if !(VP8PutBit(tls, bw, libc.BoolInt32((*VP8Residual)(unsafe.Pointer(res)).Flast >= 0), libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(p)))) != 0) {
 		return 0
 	}
 	for n < int32(16) {
 		v1 = n
 		n = n + 1
 		c = int32(**(**int16_t)(__ccgo_up((*VP8Residual)(unsafe.Pointer(res)).Fcoeffs + uintptr(v1)*2)))
 		sign = libc.BoolInt32(c < 0)
 		if sign != 0 {
 			v2 = -c
 		} else {
 			v2 = c
 		}
 		v = v2
 		if !(VP8PutBit(tls, bw, libc.BoolInt32(v != 0), libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(p + 1)))) != 0) {
 			p = (*VP8Residual)(unsafe.Pointer(res)).Fprob + uintptr(VP8EncBands[n])*33
 			continue
 		}
 		if !(VP8PutBit(tls, bw, libc.BoolInt32(v > int32(1)), libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(p + 2)))) != 0) {
 			p = (*VP8Residual)(unsafe.Pointer(res)).Fprob + uintptr(VP8EncBands[n])*33 + 1*11
 		} else {
 			if !(VP8PutBit(tls, bw, libc.BoolInt32(v > int32(4)), libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(p + 3)))) != 0) {
 				if VP8PutBit(tls, bw, libc.BoolInt32(v != int32(2)), libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(p + 4)))) != 0 {
 					VP8PutBit(tls, bw, libc.BoolInt32(v == int32(4)), libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(p + 5))))
 				}
 			} else {
 				if !(VP8PutBit(tls, bw, libc.BoolInt32(v > int32(10)), libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(p + 6)))) != 0) {
 					if !(VP8PutBit(tls, bw, libc.BoolInt32(v > int32(6)), libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(p + 7)))) != 0) {
 						VP8PutBit(tls, bw, libc.BoolInt32(v == int32(6)), int32(159))
 					} else {
 						VP8PutBit(tls, bw, libc.BoolInt32(v >= int32(9)), int32(165))
 						VP8PutBit(tls, bw, libc.BoolInt32(!(v&libc.Int32FromInt32(1) != 0)), int32(145))
 					}
 				} else {
 					if v < libc.Int32FromInt32(3)+libc.Int32FromInt32(8)<<libc.Int32FromInt32(1) { // VP8Cat3  (3b)
 						VP8PutBit(tls, bw, 0, libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(p + 8))))
 						VP8PutBit(tls, bw, 0, libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(p + 9))))
 						v = v - (libc.Int32FromInt32(3) + libc.Int32FromInt32(8)<<libc.Int32FromInt32(0))
 						mask = libc.Int32FromInt32(1) << libc.Int32FromInt32(2)
 						tab = uintptr(unsafe.Pointer(&VP8Cat3))
 					} else {
 						if v < libc.Int32FromInt32(3)+libc.Int32FromInt32(8)<<libc.Int32FromInt32(2) { // VP8Cat4  (4b)
 							VP8PutBit(tls, bw, 0, libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(p + 8))))
 							VP8PutBit(tls, bw, int32(1), libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(p + 9))))
 							v = v - (libc.Int32FromInt32(3) + libc.Int32FromInt32(8)<<libc.Int32FromInt32(1))
 							mask = libc.Int32FromInt32(1) << libc.Int32FromInt32(3)
 							tab = uintptr(unsafe.Pointer(&VP8Cat4))
 						} else {
 							if v < libc.Int32FromInt32(3)+libc.Int32FromInt32(8)<<libc.Int32FromInt32(3) { // VP8Cat5  (5b)
 								VP8PutBit(tls, bw, int32(1), libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(p + 8))))
 								VP8PutBit(tls, bw, 0, libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(p + 10))))
 								v = v - (libc.Int32FromInt32(3) + libc.Int32FromInt32(8)<<libc.Int32FromInt32(2))
 								mask = libc.Int32FromInt32(1) << libc.Int32FromInt32(4)
 								tab = uintptr(unsafe.Pointer(&VP8Cat5))
 							} else { // VP8Cat6 (11b)
 								VP8PutBit(tls, bw, int32(1), libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(p + 8))))
 								VP8PutBit(tls, bw, int32(1), libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(p + 10))))
 								v = v - (libc.Int32FromInt32(3) + libc.Int32FromInt32(8)<<libc.Int32FromInt32(3))
 								mask = libc.Int32FromInt32(1) << libc.Int32FromInt32(10)
 								tab = uintptr(unsafe.Pointer(&VP8Cat6))
 							}
 						}
 					}
 					for mask != 0 {
 						v3 = tab
 						tab = tab + 1
 						VP8PutBit(tls, bw, libc.BoolInt32(!!(v&mask != 0)), libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(v3))))
 						mask = mask >> int32(1)
 					}
 				}
 			}
 			p = (*VP8Residual)(unsafe.Pointer(res)).Fprob + uintptr(VP8EncBands[n])*33 + 2*11
 		}
 		VP8PutBitUniform(tls, bw, sign)
 		if n == int32(16) || !(VP8PutBit(tls, bw, libc.BoolInt32(n <= (*VP8Residual)(unsafe.Pointer(res)).Flast), libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(p)))) != 0) {
 			return int32(1) // EOB
 		}
 	}
 	return int32(1)
 }
 
 func CodeResiduals(tls *libc.TLS, bw1 uintptr, it uintptr, rd uintptr) {
 	bp := tls.Alloc(48)
 	defer tls.Free(48)
 	var ch, ctx, ctx1, i16, segment, x, y, v4 int32
 	var enc, v1 uintptr
 	var nb_bits, pos1, pos2, pos3, v2 uint64_t
 	var _ /* res at bp+0 */ VP8Residual
 	_, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = ch, ctx, ctx1, enc, i16, nb_bits, pos1, pos2, pos3, segment, x, y, v1, v2, v4
 	i16 = libc.BoolInt32(int32(uint32(*(*uint8)(unsafe.Pointer((*VP8EncIterator)(unsafe.Pointer(it)).Fmb + 0))&0x3>>0)) == libc.Int32FromInt32(1))
 	segment = int32(uint32(*(*uint8)(unsafe.Pointer((*VP8EncIterator)(unsafe.Pointer(it)).Fmb + 0)) & 0x60 >> 5))
 	enc = (*VP8EncIterator)(unsafe.Pointer(it)).Fenc
 	VP8IteratorNzToBytes(tls, it)
 	v1 = bw1
 	nb_bits = libc.Uint64FromInt32(int32(8) + (*VP8BitWriter)(unsafe.Pointer(v1)).Fnb_bits)
 	v2 = uint64(((*VP8BitWriter)(unsafe.Pointer(v1)).Fpos+libc.Uint64FromInt32((*VP8BitWriter)(unsafe.Pointer(v1)).Frun))*uint64(8)) + nb_bits
 	goto _3
 _3:
 	pos1 = v2
 	if i16 != 0 {
 		VP8InitResidual(tls, 0, int32(1), enc, bp)
 		(*(*func(*libc.TLS, uintptr, uintptr))(unsafe.Pointer(&struct{ uintptr }{VP8SetResidualCoeffs})))(tls, rd+40, bp)
 		v4 = PutCoeffs(tls, bw1, **(**int32)(__ccgo_up(it + 132 + 8*4))+**(**int32)(__ccgo_up(it + 168 + 8*4)), bp)
 		**(**int32)(__ccgo_up(it + 168 + 8*4)) = v4
 		**(**int32)(__ccgo_up(it + 132 + 8*4)) = v4
 		VP8InitResidual(tls, int32(1), 0, enc, bp)
 	} else {
 		VP8InitResidual(tls, 0, int32(3), enc, bp)
 	}
 	// luma-AC
 	y = 0
 	for {
 		if !(y < int32(4)) {
 			break
 		}
 		x = 0
 		for {
 			if !(x < int32(4)) {
 				break
 			}
 			ctx = **(**int32)(__ccgo_up(it + 132 + uintptr(x)*4)) + **(**int32)(__ccgo_up(it + 168 + uintptr(y)*4))
 			(*(*func(*libc.TLS, uintptr, uintptr))(unsafe.Pointer(&struct{ uintptr }{VP8SetResidualCoeffs})))(tls, rd+72+uintptr(x+y*int32(4))*32, bp)
 			v4 = PutCoeffs(tls, bw1, ctx, bp)
 			**(**int32)(__ccgo_up(it + 168 + uintptr(y)*4)) = v4
 			**(**int32)(__ccgo_up(it + 132 + uintptr(x)*4)) = v4
 			goto _6
 		_6:
 			;
 			x = x + 1
 		}
 		goto _5
 	_5:
 		;
 		y = y + 1
 	}
 	v1 = bw1
 	nb_bits = libc.Uint64FromInt32(int32(8) + (*VP8BitWriter)(unsafe.Pointer(v1)).Fnb_bits)
 	v2 = uint64(((*VP8BitWriter)(unsafe.Pointer(v1)).Fpos+libc.Uint64FromInt32((*VP8BitWriter)(unsafe.Pointer(v1)).Frun))*uint64(8)) + nb_bits
 	goto _10
 _10:
 	pos2 = v2
 	// U/V
 	VP8InitResidual(tls, 0, int32(2), enc, bp)
 	ch = 0
 	for {
 		if !(ch <= int32(2)) {
 			break
 		}
 		y = 0
 		for {
 			if !(y < int32(2)) {
 				break
 			}
 			x = 0
 			for {
 				if !(x < int32(2)) {
 					break
 				}
 				ctx1 = **(**int32)(__ccgo_up(it + 132 + uintptr(int32(4)+ch+x)*4)) + **(**int32)(__ccgo_up(it + 168 + uintptr(int32(4)+ch+y)*4))
 				(*(*func(*libc.TLS, uintptr, uintptr))(unsafe.Pointer(&struct{ uintptr }{VP8SetResidualCoeffs})))(tls, rd+584+uintptr(ch*int32(2)+x+y*int32(2))*32, bp)
 				v4 = PutCoeffs(tls, bw1, ctx1, bp)
 				**(**int32)(__ccgo_up(it + 168 + uintptr(int32(4)+ch+y)*4)) = v4
 				**(**int32)(__ccgo_up(it + 132 + uintptr(int32(4)+ch+x)*4)) = v4
 				goto _13
 			_13:
 				;
 				x = x + 1
 			}
 			goto _12
 		_12:
 			;
 			y = y + 1
 		}
 		goto _11
 	_11:
 		;
 		ch = ch + int32(2)
 	}
 	v1 = bw1
 	nb_bits = libc.Uint64FromInt32(int32(8) + (*VP8BitWriter)(unsafe.Pointer(v1)).Fnb_bits)
 	v2 = uint64(((*VP8BitWriter)(unsafe.Pointer(v1)).Fpos+libc.Uint64FromInt32((*VP8BitWriter)(unsafe.Pointer(v1)).Frun))*uint64(8)) + nb_bits
 	goto _17
 _17:
 	pos3 = v2
 	(*VP8EncIterator)(unsafe.Pointer(it)).Fluma_bits = pos2 - pos1
 	(*VP8EncIterator)(unsafe.Pointer(it)).Fuv_bits = pos3 - pos2
 	**(**uint64_t)(__ccgo_up(it + 208 + uintptr(segment)*24 + uintptr(i16)*8)) += (*VP8EncIterator)(unsafe.Pointer(it)).Fluma_bits
 	**(**uint64_t)(__ccgo_up(it + 208 + uintptr(segment)*24 + 2*8)) += (*VP8EncIterator)(unsafe.Pointer(it)).Fuv_bits
 	VP8IteratorBytesToNz(tls, it)
 }
 
 // C documentation
 //
 //	// Same as CodeResiduals, but doesn't actually write anything.
 //	// Instead, it just records the event distribution.
 func RecordResiduals(tls *libc.TLS, it uintptr, rd uintptr) {
 	bp := tls.Alloc(48)
 	defer tls.Free(48)
 	var ch, ctx, ctx1, x, y, v1 int32
 	var enc uintptr
 	var _ /* res at bp+0 */ VP8Residual
 	_, _, _, _, _, _, _ = ch, ctx, ctx1, enc, x, y, v1
 	enc = (*VP8EncIterator)(unsafe.Pointer(it)).Fenc
 	VP8IteratorNzToBytes(tls, it)
 	if int32(uint32(*(*uint8)(unsafe.Pointer((*VP8EncIterator)(unsafe.Pointer(it)).Fmb + 0))&0x3>>0)) == int32(1) { // i16x16
 		VP8InitResidual(tls, 0, int32(1), enc, bp)
 		(*(*func(*libc.TLS, uintptr, uintptr))(unsafe.Pointer(&struct{ uintptr }{VP8SetResidualCoeffs})))(tls, rd+40, bp)
 		v1 = VP8RecordCoeffs(tls, **(**int32)(__ccgo_up(it + 132 + 8*4))+**(**int32)(__ccgo_up(it + 168 + 8*4)), bp)
 		**(**int32)(__ccgo_up(it + 168 + 8*4)) = v1
 		**(**int32)(__ccgo_up(it + 132 + 8*4)) = v1
 		VP8InitResidual(tls, int32(1), 0, enc, bp)
 	} else {
 		VP8InitResidual(tls, 0, int32(3), enc, bp)
 	}
 	// luma-AC
 	y = 0
 	for {
 		if !(y < int32(4)) {
 			break
 		}
 		x = 0
 		for {
 			if !(x < int32(4)) {
 				break
 			}
 			ctx = **(**int32)(__ccgo_up(it + 132 + uintptr(x)*4)) + **(**int32)(__ccgo_up(it + 168 + uintptr(y)*4))
 			(*(*func(*libc.TLS, uintptr, uintptr))(unsafe.Pointer(&struct{ uintptr }{VP8SetResidualCoeffs})))(tls, rd+72+uintptr(x+y*int32(4))*32, bp)
 			v1 = VP8RecordCoeffs(tls, ctx, bp)
 			**(**int32)(__ccgo_up(it + 168 + uintptr(y)*4)) = v1
 			**(**int32)(__ccgo_up(it + 132 + uintptr(x)*4)) = v1
 			goto _3
 		_3:
 			;
 			x = x + 1
 		}
 		goto _2
 	_2:
 		;
 		y = y + 1
 	}
 	// U/V
 	VP8InitResidual(tls, 0, int32(2), enc, bp)
 	ch = 0
 	for {
 		if !(ch <= int32(2)) {
 			break
 		}
 		y = 0
 		for {
 			if !(y < int32(2)) {
 				break
 			}
 			x = 0
 			for {
 				if !(x < int32(2)) {
 					break
 				}
 				ctx1 = **(**int32)(__ccgo_up(it + 132 + uintptr(int32(4)+ch+x)*4)) + **(**int32)(__ccgo_up(it + 168 + uintptr(int32(4)+ch+y)*4))
 				(*(*func(*libc.TLS, uintptr, uintptr))(unsafe.Pointer(&struct{ uintptr }{VP8SetResidualCoeffs})))(tls, rd+584+uintptr(ch*int32(2)+x+y*int32(2))*32, bp)
 				v1 = VP8RecordCoeffs(tls, ctx1, bp)
 				**(**int32)(__ccgo_up(it + 168 + uintptr(int32(4)+ch+y)*4)) = v1
 				**(**int32)(__ccgo_up(it + 132 + uintptr(int32(4)+ch+x)*4)) = v1
 				goto _7
 			_7:
 				;
 				x = x + 1
 			}
 			goto _6
 		_6:
 			;
 			y = y + 1
 		}
 		goto _5
 	_5:
 		;
 		ch = ch + int32(2)
 	}
 	VP8IteratorBytesToNz(tls, it)
 }
 
 //------------------------------------------------------------------------------
 // Token buffer
 
 func RecordTokens(tls *libc.TLS, it uintptr, rd uintptr, tokens uintptr) (r int32) {
 	bp := tls.Alloc(48)
 	defer tls.Free(48)
 	var ch, ctx, ctx1, ctx2, x, y, v1 int32
 	var enc uintptr
 	var _ /* res at bp+0 */ VP8Residual
 	_, _, _, _, _, _, _, _ = ch, ctx, ctx1, ctx2, enc, x, y, v1
 	enc = (*VP8EncIterator)(unsafe.Pointer(it)).Fenc
 	VP8IteratorNzToBytes(tls, it)
 	if int32(uint32(*(*uint8)(unsafe.Pointer((*VP8EncIterator)(unsafe.Pointer(it)).Fmb + 0))&0x3>>0)) == int32(1) { // i16x16
 		ctx = **(**int32)(__ccgo_up(it + 132 + 8*4)) + **(**int32)(__ccgo_up(it + 168 + 8*4))
 		VP8InitResidual(tls, 0, int32(1), enc, bp)
 		(*(*func(*libc.TLS, uintptr, uintptr))(unsafe.Pointer(&struct{ uintptr }{VP8SetResidualCoeffs})))(tls, rd+40, bp)
 		v1 = VP8RecordCoeffTokens(tls, ctx, bp, tokens)
 		**(**int32)(__ccgo_up(it + 168 + 8*4)) = v1
 		**(**int32)(__ccgo_up(it + 132 + 8*4)) = v1
 		VP8InitResidual(tls, int32(1), 0, enc, bp)
 	} else {
 		VP8InitResidual(tls, 0, int32(3), enc, bp)
 	}
 	// luma-AC
 	y = 0
 	for {
 		if !(y < int32(4)) {
 			break
 		}
 		x = 0
 		for {
 			if !(x < int32(4)) {
 				break
 			}
 			ctx1 = **(**int32)(__ccgo_up(it + 132 + uintptr(x)*4)) + **(**int32)(__ccgo_up(it + 168 + uintptr(y)*4))
 			(*(*func(*libc.TLS, uintptr, uintptr))(unsafe.Pointer(&struct{ uintptr }{VP8SetResidualCoeffs})))(tls, rd+72+uintptr(x+y*int32(4))*32, bp)
 			v1 = VP8RecordCoeffTokens(tls, ctx1, bp, tokens)
 			**(**int32)(__ccgo_up(it + 168 + uintptr(y)*4)) = v1
 			**(**int32)(__ccgo_up(it + 132 + uintptr(x)*4)) = v1
 			goto _3
 		_3:
 			;
 			x = x + 1
 		}
 		goto _2
 	_2:
 		;
 		y = y + 1
 	}
 	// U/V
 	VP8InitResidual(tls, 0, int32(2), enc, bp)
 	ch = 0
 	for {
 		if !(ch <= int32(2)) {
 			break
 		}
 		y = 0
 		for {
 			if !(y < int32(2)) {
 				break
 			}
 			x = 0
 			for {
 				if !(x < int32(2)) {
 					break
 				}
 				ctx2 = **(**int32)(__ccgo_up(it + 132 + uintptr(int32(4)+ch+x)*4)) + **(**int32)(__ccgo_up(it + 168 + uintptr(int32(4)+ch+y)*4))
 				(*(*func(*libc.TLS, uintptr, uintptr))(unsafe.Pointer(&struct{ uintptr }{VP8SetResidualCoeffs})))(tls, rd+584+uintptr(ch*int32(2)+x+y*int32(2))*32, bp)
 				v1 = VP8RecordCoeffTokens(tls, ctx2, bp, tokens)
 				**(**int32)(__ccgo_up(it + 168 + uintptr(int32(4)+ch+y)*4)) = v1
 				**(**int32)(__ccgo_up(it + 132 + uintptr(int32(4)+ch+x)*4)) = v1
 				goto _7
 			_7:
 				;
 				x = x + 1
 			}
 			goto _6
 		_6:
 			;
 			y = y + 1
 		}
 		goto _5
 	_5:
 		;
 		ch = ch + int32(2)
 	}
 	VP8IteratorBytesToNz(tls, it)
 	return libc.BoolInt32(!((*VP8TBuffer)(unsafe.Pointer(tokens)).Ferror1 != 0))
 }
 
 //------------------------------------------------------------------------------
 // ExtraInfo map / Debug function
 
 func ResetSSE(tls *libc.TLS, enc uintptr) {
 	**(**uint64_t)(__ccgo_up(enc + 23512)) = uint64(0)
 	**(**uint64_t)(__ccgo_up(enc + 23512 + 1*8)) = uint64(0)
 	**(**uint64_t)(__ccgo_up(enc + 23512 + 2*8)) = uint64(0)
 	// Note: enc->sse[3] is managed by alpha.c
 	(*VP8Encoder)(unsafe.Pointer(enc)).Fsse_count = uint64(0)
 }
 
 func StoreSSE(tls *libc.TLS, it uintptr) {
 	var enc, in, out uintptr
 	_, _, _ = enc, in, out
 	enc = (*VP8EncIterator)(unsafe.Pointer(it)).Fenc
 	in = (*VP8EncIterator)(unsafe.Pointer(it)).Fyuv_in
 	out = (*VP8EncIterator)(unsafe.Pointer(it)).Fyuv_out
 	// Note: not totally accurate at boundary. And doesn't include in-loop filter.
 	**(**uint64_t)(__ccgo_up(enc + 23512)) += libc.Uint64FromInt32((*(*func(*libc.TLS, uintptr, uintptr) int32)(unsafe.Pointer(&struct{ uintptr }{VP8SSE16x16})))(tls, in+uintptr(libc.Int32FromInt32(Y_OFF_ENC)), out+uintptr(libc.Int32FromInt32(Y_OFF_ENC))))
 	**(**uint64_t)(__ccgo_up(enc + 23512 + 1*8)) += libc.Uint64FromInt32((*(*func(*libc.TLS, uintptr, uintptr) int32)(unsafe.Pointer(&struct{ uintptr }{VP8SSE8x8})))(tls, in+uintptr(libc.Int32FromInt32(U_OFF_ENC)), out+uintptr(libc.Int32FromInt32(U_OFF_ENC))))
 	**(**uint64_t)(__ccgo_up(enc + 23512 + 2*8)) += libc.Uint64FromInt32((*(*func(*libc.TLS, uintptr, uintptr) int32)(unsafe.Pointer(&struct{ uintptr }{VP8SSE8x8})))(tls, in+uintptr(libc.Int32FromInt32(16)+libc.Int32FromInt32(8)), out+uintptr(libc.Int32FromInt32(16)+libc.Int32FromInt32(8))))
 	**(**uint64_t)(__ccgo_up(enc + 23544)) += libc.Uint64FromInt32(libc.Int32FromInt32(16) * libc.Int32FromInt32(16))
 }
 
 func StoreSideInfo(tls *libc.TLS, it uintptr) {
 	var b, v1 int32
 	var enc, info, mb, pic uintptr
 	_, _, _, _, _, _ = b, enc, info, mb, pic, v1
 	enc = (*VP8EncIterator)(unsafe.Pointer(it)).Fenc
 	mb = (*VP8EncIterator)(unsafe.Pointer(it)).Fmb
 	pic = (*VP8Encoder)(unsafe.Pointer(enc)).Fpic
 	if (*WebPPicture)(unsafe.Pointer(pic)).Fstats != libc.UintptrFromInt32(0) {
 		StoreSSE(tls, it)
 		**(**int32)(__ccgo_up(enc + 23604)) += libc.BoolInt32(int32(uint32(*(*uint8)(unsafe.Pointer(mb + 0))&0x3>>0)) == 0)
 		**(**int32)(__ccgo_up(enc + 23604 + 1*4)) += libc.BoolInt32(int32(uint32(*(*uint8)(unsafe.Pointer(mb + 0))&0x3>>0)) == int32(1))
 		**(**int32)(__ccgo_up(enc + 23604 + 2*4)) += libc.BoolInt32(int32(uint32(*(*uint8)(unsafe.Pointer(mb + 0))&0x10>>4)) != 0)
 	}
 	if (*WebPPicture)(unsafe.Pointer(pic)).Fextra_info != libc.UintptrFromInt32(0) {
 		info = (*WebPPicture)(unsafe.Pointer(pic)).Fextra_info + uintptr((*VP8EncIterator)(unsafe.Pointer(it)).Fx+(*VP8EncIterator)(unsafe.Pointer(it)).Fy*(*VP8Encoder)(unsafe.Pointer(enc)).Fmb_w)
 		switch (*WebPPicture)(unsafe.Pointer(pic)).Fextra_info_type {
 		case int32(1):
 			**(**uint8_t)(__ccgo_up(info)) = libc.Uint8FromInt32(int32(uint32(*(*uint8)(unsafe.Pointer(mb + 0)) & 0x3 >> 0)))
 		case int32(2):
 			**(**uint8_t)(__ccgo_up(info)) = libc.Uint8FromInt32(int32(uint32(*(*uint8)(unsafe.Pointer(mb + 0)) & 0x60 >> 5)))
 		case int32(3):
 			**(**uint8_t)(__ccgo_up(info)) = libc.Uint8FromInt32((**(**VP8SegmentInfo)(__ccgo_up(enc + 608 + uintptr(int32(uint32(*(*uint8)(unsafe.Pointer(mb + 0))&0x60>>5)))*744))).Fquant)
 		case int32(4):
 			if int32(uint32(*(*uint8)(unsafe.Pointer(mb + 0))&0x3>>0)) == int32(1) {
 				v1 = libc.Int32FromUint8(**(**uint8_t)(__ccgo_up((*VP8EncIterator)(unsafe.Pointer(it)).Fpreds)))
 			} else {
 				v1 = int32(0xff)
 			}
 			**(**uint8_t)(__ccgo_up(info)) = libc.Uint8FromInt32(v1)
 		case int32(5):
 			**(**uint8_t)(__ccgo_up(info)) = libc.Uint8FromInt32(int32(uint32(*(*uint8)(unsafe.Pointer(mb + 0)) & 0xc >> 2)))
 		case int32(6):
 			b = libc.Int32FromUint64(((*VP8EncIterator)(unsafe.Pointer(it)).Fluma_bits + (*VP8EncIterator)(unsafe.Pointer(it)).Fuv_bits + libc.Uint64FromInt32(7)) >> libc.Int32FromInt32(3))
 			if b > int32(255) {
 				v1 = int32(255)
 			} else {
 				v1 = b
 			}
 			**(**uint8_t)(__ccgo_up(info)) = libc.Uint8FromInt32(v1)
 		case int32(7):
 			**(**uint8_t)(__ccgo_up(info)) = (*VP8MBInfo)(unsafe.Pointer(mb)).Falpha
 		default:
 			**(**uint8_t)(__ccgo_up(info)) = uint8(0)
 			break
 		}
 	}
 }
 
 func ResetSideInfo(tls *libc.TLS, it uintptr) {
 	var enc, pic uintptr
 	_, _ = enc, pic
 	enc = (*VP8EncIterator)(unsafe.Pointer(it)).Fenc
 	pic = (*VP8Encoder)(unsafe.Pointer(enc)).Fpic
 	if (*WebPPicture)(unsafe.Pointer(pic)).Fstats != libc.UintptrFromInt32(0) {
 		libc.X__builtin___memset_chk(tls, enc+23604, 0, uint64(12), ^__predefined_size_t(0))
 	}
 	ResetSSE(tls, enc)
 }
 
 func GetPSNR(tls *libc.TLS, mse uint64_t, size uint64_t) (r float64) {
 	var v1 float64
 	_ = v1
 	if mse > uint64(0) && size > uint64(0) {
 		v1 = float64(float64(10) * libc.Xlog10(tls, float64(float64(libc.Float64FromFloat64(255)*libc.Float64FromFloat64(255))*float64(size))/float64(mse)))
 	} else {
 		v1 = libc.Float64FromInt32(99)
 	}
 	return v1
 }
 
 //------------------------------------------------------------------------------
 //  StatLoop(): only collect statistics (number of skips, token usage, ...).
 //  This is used for deciding optimal probabilities. It also modifies the
 //  quantizer value if some target (size, PSNR) was specified.
 
 func SetLoopParams(tls *libc.TLS, enc uintptr, q float32) {
 	// Make sure the quality parameter is inside valid bounds
 	q = Clamp(tls, q, libc.Float32FromFloat32(0), libc.Float32FromFloat32(100))
 	VP8SetSegmentParams(tls, enc, q) // setup segment quantizations and filters
 	SetSegmentProbas(tls, enc)       // compute segment probabilities
 	ResetStats(tls, enc)
 	ResetSSE(tls, enc)
 }
 
 func OneStatPass(tls *libc.TLS, enc uintptr, rd_opt VP8RDLevel, nb_mbs int32, percent_delta int32, s uintptr) (r uint64_t) {
 	bp := tls.Alloc(4736)
 	defer tls.Free(4736)
 	var distortion, pixel_count, size, size_p0 uint64_t
 	var v1 int32
 	var v2 bool
 	var _ /* info at bp+3848 */ VP8ModeScore
 	var _ /* it at bp+0 */ VP8EncIterator
 	_, _, _, _, _, _ = distortion, pixel_count, size, size_p0, v1, v2
 	size = uint64(0)
 	size_p0 = uint64(0)
 	distortion = uint64(0)
 	pixel_count = libc.Uint64FromInt32(nb_mbs) * uint64(384)
 	VP8IteratorInit(tls, enc, bp)
 	SetLoopParams(tls, enc, (*PassStats)(unsafe.Pointer(s)).Fq)
 	for {
 		VP8IteratorImport(tls, bp, libc.UintptrFromInt32(0))
 		if VP8Decimate(tls, bp, bp+3848, rd_opt) != 0 {
 			// Just record the number of skips and act like skip_proba is not used.
 			(*VP8Encoder)(unsafe.Pointer(enc)).Fproba.Fnb_skip = (*VP8Encoder)(unsafe.Pointer(enc)).Fproba.Fnb_skip + 1
 		}
 		RecordResiduals(tls, bp, bp+3848)
 		size = size + libc.Uint64FromInt64((**(**VP8ModeScore)(__ccgo_up(bp + 3848))).FR+(**(**VP8ModeScore)(__ccgo_up(bp + 3848))).FH)
 		size_p0 = size_p0 + libc.Uint64FromInt64((**(**VP8ModeScore)(__ccgo_up(bp + 3848))).FH)
 		distortion = distortion + libc.Uint64FromInt64((**(**VP8ModeScore)(__ccgo_up(bp + 3848))).FD)
 		if percent_delta != 0 && !(VP8IteratorProgress(tls, bp, percent_delta) != 0) {
 			return uint64(0)
 		}
 		VP8IteratorSaveBoundary(tls, bp)
 		goto _3
 	_3:
 		;
 		if v2 = VP8IteratorNext(tls, bp) != 0; v2 {
 			nb_mbs = nb_mbs - 1
 			v1 = nb_mbs
 		}
 		if !(v2 && v1 > 0) {
 			break
 		}
 	}
 	size_p0 = size_p0 + libc.Uint64FromInt32((*VP8Encoder)(unsafe.Pointer(enc)).Fsegment_hdr.Fsize)
 	if (*PassStats)(unsafe.Pointer(s)).Fdo_size_search != 0 {
 		size = size + libc.Uint64FromInt32(FinalizeSkipProba(tls, enc))
 		size = size + libc.Uint64FromInt32(FinalizeTokenProbas(tls, enc+3616))
 		size = (size+size_p0+uint64(1024))>>int32(11) + libc.Uint64FromInt32(libc.Int32FromInt32(RIFF_HEADER_SIZE)+libc.Int32FromInt32(CHUNK_HEADER_SIZE)+libc.Int32FromInt32(VP8_FRAME_HEADER_SIZE))
 		(*PassStats)(unsafe.Pointer(s)).Fvalue = float64(size)
 	} else {
 		(*PassStats)(unsafe.Pointer(s)).Fvalue = GetPSNR(tls, distortion, pixel_count)
 	}
 	return size_p0
 }
 
 func StatLoop(tls *libc.TLS, enc uintptr) (r int32) {
 	bp := tls.Alloc(64)
 	defer tls.Free(64)
 	var do_search, fast_probe, final_percent, is_last_pass, method, nb_mbs, num_pass_left, percent_per_pass, task_percent, v1 int32
 	var rd_opt VP8RDLevel
 	var size_p0 uint64_t
 	var _ /* stats at bp+0 */ PassStats
 	_, _, _, _, _, _, _, _, _, _, _, _ = do_search, fast_probe, final_percent, is_last_pass, method, nb_mbs, num_pass_left, percent_per_pass, rd_opt, size_p0, task_percent, v1
 	method = (*VP8Encoder)(unsafe.Pointer(enc)).Fmethod
 	do_search = (*VP8Encoder)(unsafe.Pointer(enc)).Fdo_search
 	fast_probe = libc.BoolInt32((method == 0 || method == int32(3)) && !(do_search != 0))
 	num_pass_left = (*WebPConfig)(unsafe.Pointer((*VP8Encoder)(unsafe.Pointer(enc)).Fconfig)).Fpass
 	task_percent = int32(20)
 	percent_per_pass = (task_percent + num_pass_left/int32(2)) / num_pass_left
 	final_percent = (*VP8Encoder)(unsafe.Pointer(enc)).Fpercent + task_percent
 	if method >= int32(3) || do_search != 0 {
 		v1 = int32(RD_OPT_BASIC)
 	} else {
 		v1 = int32(RD_OPT_NONE)
 	}
 	rd_opt = v1
 	nb_mbs = (*VP8Encoder)(unsafe.Pointer(enc)).Fmb_w * (*VP8Encoder)(unsafe.Pointer(enc)).Fmb_h
 	InitPassStats(tls, enc, bp)
 	ResetTokenStats(tls, enc)
 	// Fast mode: quick analysis pass over few mbs. Better than nothing.
 	if fast_probe != 0 {
 		if method == int32(3) { // we need more stats for method 3 to be reliable.
 			if nb_mbs > int32(200) {
 				v1 = nb_mbs >> int32(1)
 			} else {
 				v1 = int32(100)
 			}
 			nb_mbs = v1
 		} else {
 			if nb_mbs > int32(200) {
 				v1 = nb_mbs >> int32(2)
 			} else {
 				v1 = int32(50)
 			}
 			nb_mbs = v1
 		}
 	}
 	for {
 		v1 = num_pass_left
 		num_pass_left = num_pass_left - 1
 		if !(v1 > 0) {
 			break
 		}
 		is_last_pass = libc.BoolInt32(libc.Xfabs(tls, float64((**(**PassStats)(__ccgo_up(bp))).Fdq)) <= float64(DQ_LIMIT) || num_pass_left == 0 || (*VP8Encoder)(unsafe.Pointer(enc)).Fmax_i4_header_bits == 0)
 		size_p0 = OneStatPass(tls, enc, rd_opt, nb_mbs, percent_per_pass, bp)
 		if size_p0 == uint64(0) {
 			return 0
 		}
 		if (*VP8Encoder)(unsafe.Pointer(enc)).Fmax_i4_header_bits > 0 && size_p0 > (libc.Uint64FromInt32(libc.Int32FromInt32(1)<<libc.Int32FromInt32(19))-libc.Uint64FromUint64(2048))<<libc.Int32FromInt32(11) {
 			num_pass_left = num_pass_left + 1
 			**(**int32)(__ccgo_up(enc + 23624)) >>= int32(1) // strengthen header bit limitation...
 			continue                                         // ...and start over
 		}
 		if is_last_pass != 0 {
 			break
 		}
 		// If no target size: just do several pass without changing 'q'
 		if do_search != 0 {
 			ComputeNextQ(tls, bp)
 			if libc.Xfabs(tls, float64((**(**PassStats)(__ccgo_up(bp))).Fdq)) <= float64(DQ_LIMIT) {
 				break
 			}
 		}
 	}
 	if !(do_search != 0) || !((**(**PassStats)(__ccgo_up(bp))).Fdo_size_search != 0) {
 		// Need to finalize probas now, since it wasn't done during the search.
 		FinalizeSkipProba(tls, enc)
 		FinalizeTokenProbas(tls, enc+3616)
 	}
 	VP8CalculateLevelCosts(tls, enc+3616) // finalize costs
 	return WebPReportProgress(tls, (*VP8Encoder)(unsafe.Pointer(enc)).Fpic, final_percent, enc+536)
 }
 
 //------------------------------------------------------------------------------
 // Main loops
 //
 
 var kAverageBytesPerMB = [8]uint8_t{
 	0: uint8(50),
 	1: uint8(24),
 	2: uint8(16),
 	3: uint8(9),
 	4: uint8(7),
 	5: uint8(5),
 	6: uint8(3),
 	7: uint8(2),
 }
 
 func PreLoopInitialize(tls *libc.TLS, enc uintptr) (r int32) {
 	var average_bytes_per_MB, bytes_per_parts, ok, p int32
 	_, _, _, _ = average_bytes_per_MB, bytes_per_parts, ok, p
 	ok = int32(1)
 	average_bytes_per_MB = libc.Int32FromUint8(kAverageBytesPerMB[(*VP8Encoder)(unsafe.Pointer(enc)).Fbase_quant>>int32(4)])
 	bytes_per_parts = (*VP8Encoder)(unsafe.Pointer(enc)).Fmb_w * (*VP8Encoder)(unsafe.Pointer(enc)).Fmb_h * average_bytes_per_MB / (*VP8Encoder)(unsafe.Pointer(enc)).Fnum_parts
 	// Initialize the bit-writers
 	p = 0
 	for {
 		if !(ok != 0 && p < (*VP8Encoder)(unsafe.Pointer(enc)).Fnum_parts) {
 			break
 		}
 		ok = VP8BitWriterInit(tls, enc+112+uintptr(p)*48, libc.Uint64FromInt32(bytes_per_parts))
 		goto _1
 	_1:
 		;
 		p = p + 1
 	}
 	if !(ok != 0) {
 		VP8EncFreeBitWriters(tls, enc) // malloc error occurred
 		return WebPEncodingSetError(tls, (*VP8Encoder)(unsafe.Pointer(enc)).Fpic, int32(VP8_ENC_ERROR_OUT_OF_MEMORY))
 	}
 	return ok
 }
 
 func PostLoopFinalize(tls *libc.TLS, it uintptr, ok int32) (r int32) {
 	var enc uintptr
 	var i, p, s int32
 	_, _, _, _ = enc, i, p, s
 	enc = (*VP8EncIterator)(unsafe.Pointer(it)).Fenc
 	if ok != 0 {
 		p = 0
 		for {
 			if !(p < (*VP8Encoder)(unsafe.Pointer(enc)).Fnum_parts) {
 				break
 			}
 			VP8BitWriterFinish(tls, enc+112+uintptr(p)*48)
 			ok = ok & libc.BoolInt32(!((**(**VP8BitWriter)(__ccgo_up(enc + 112 + uintptr(p)*48))).Ferror1 != 0))
 			goto _1
 		_1:
 			;
 			p = p + 1
 		}
 	}
 	if ok != 0 { // All good. Finish up.
 		if (*WebPPicture)(unsafe.Pointer((*VP8Encoder)(unsafe.Pointer(enc)).Fpic)).Fstats != libc.UintptrFromInt32(0) {
 			i = 0
 			for {
 				if !(i <= int32(2)) {
 					break
 				}
 				s = 0
 				for {
 					if !(s < int32(NUM_MB_SEGMENTS)) {
 						break
 					}
 					**(**int32)(__ccgo_up(enc + 23556 + uintptr(i)*16 + uintptr(s)*4)) = libc.Int32FromUint64((**(**uint64_t)(__ccgo_up(it + 208 + uintptr(s)*24 + uintptr(i)*8)) + libc.Uint64FromInt32(7)) >> libc.Int32FromInt32(3))
 					goto _3
 				_3:
 					;
 					s = s + 1
 				}
 				goto _2
 			_2:
 				;
 				i = i + 1
 			}
 		}
 		VP8AdjustFilterStrength(tls, it) // ...and store filter stats.
 	} else {
 		// Something bad happened -> need to do some memory cleanup.
 		VP8EncFreeBitWriters(tls, enc)
 		return WebPEncodingSetError(tls, (*VP8Encoder)(unsafe.Pointer(enc)).Fpic, int32(VP8_ENC_ERROR_OUT_OF_MEMORY))
 	}
 	return ok
 }
 
 //------------------------------------------------------------------------------
 //  VP8EncLoop(): does the final bitstream coding.
 
 func ResetAfterSkip(tls *libc.TLS, it uintptr) {
 	if int32(uint32(*(*uint8)(unsafe.Pointer((*VP8EncIterator)(unsafe.Pointer(it)).Fmb + 0))&0x3>>0)) == int32(1) {
 		**(**uint32_t)(__ccgo_up((*VP8EncIterator)(unsafe.Pointer(it)).Fnz)) = uint32(0) // reset all predictors
 		**(**int32)(__ccgo_up(it + 168 + 8*4)) = 0
 	} else {
 		**(**uint32_t)(__ccgo_up((*VP8EncIterator)(unsafe.Pointer(it)).Fnz)) &= libc.Uint32FromInt32(libc.Int32FromInt32(1) << libc.Int32FromInt32(24)) // preserve the dc_nz bit
 	}
 }
 
 func VP8EncLoop(tls *libc.TLS, enc uintptr) (r int32) {
 	bp := tls.Alloc(4736)
 	defer tls.Free(4736)
 	var dont_use_skip, ok int32
 	var rd_opt VP8RDLevel
 	var _ /* info at bp+3848 */ VP8ModeScore
 	var _ /* it at bp+0 */ VP8EncIterator
 	_, _, _ = dont_use_skip, ok, rd_opt
 	ok = PreLoopInitialize(tls, enc)
 	if !(ok != 0) {
 		return 0
 	}
 	StatLoop(tls, enc) // stats-collection loop
 	VP8IteratorInit(tls, enc, bp)
 	VP8InitFilter(tls, bp)
 	for cond := true; cond; cond = ok != 0 && VP8IteratorNext(tls, bp) != 0 {
 		dont_use_skip = libc.BoolInt32(!((*VP8Encoder)(unsafe.Pointer(enc)).Fproba.Fuse_skip_proba != 0))
 		rd_opt = (*VP8Encoder)(unsafe.Pointer(enc)).Frd_opt_level
 		VP8IteratorImport(tls, bp, libc.UintptrFromInt32(0))
 		// Warning! order is important: first call VP8Decimate() and
 		// *then* decide how to code the skip decision if there's one.
 		if !(VP8Decimate(tls, bp, bp+3848, rd_opt) != 0) || dont_use_skip != 0 {
 			CodeResiduals(tls, (**(**VP8EncIterator)(__ccgo_up(bp))).Fbw, bp, bp+3848)
 			if (*VP8BitWriter)(unsafe.Pointer((**(**VP8EncIterator)(__ccgo_up(bp))).Fbw)).Ferror1 != 0 {
 				// enc->pic->error_code is set in PostLoopFinalize().
 				ok = 0
 				break
 			}
 		} else { // reset predictors after a skip
 			ResetAfterSkip(tls, bp)
 		}
 		StoreSideInfo(tls, bp)
 		VP8StoreFilterStats(tls, bp)
 		VP8IteratorExport(tls, bp)
 		ok = VP8IteratorProgress(tls, bp, int32(20))
 		VP8IteratorSaveBoundary(tls, bp)
 	}
 	return PostLoopFinalize(tls, bp, ok)
 }
 
 //------------------------------------------------------------------------------
 // Single pass using Token Buffer.
 
 func VP8EncTokenLoop(tls *libc.TLS, enc uintptr) (r int32) {
 	bp := tls.Alloc(4784)
 	defer tls.Free(4784)
 	var cnt, do_search, is_last_pass, max_count, num_pass_left, ok, pass_progress, remaining_progress, v1 int32
 	var distortion, pixel_count, size, size_p0 uint64_t
 	var proba uintptr
 	var rd_opt VP8RDLevel
 	var v2 bool
 	var _ /* info at bp+3904 */ VP8ModeScore
 	var _ /* it at bp+0 */ VP8EncIterator
 	var _ /* stats at bp+3848 */ PassStats
 	_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = cnt, distortion, do_search, is_last_pass, max_count, num_pass_left, ok, pass_progress, pixel_count, proba, rd_opt, remaining_progress, size, size_p0, v1, v2
 	// Roughly refresh the proba eight times per pass
 	max_count = (*VP8Encoder)(unsafe.Pointer(enc)).Fmb_w * (*VP8Encoder)(unsafe.Pointer(enc)).Fmb_h >> int32(3)
 	num_pass_left = (*WebPConfig)(unsafe.Pointer((*VP8Encoder)(unsafe.Pointer(enc)).Fconfig)).Fpass
 	remaining_progress = int32(40) // percents
 	do_search = (*VP8Encoder)(unsafe.Pointer(enc)).Fdo_search
 	proba = enc + 3616
 	rd_opt = (*VP8Encoder)(unsafe.Pointer(enc)).Frd_opt_level
 	pixel_count = libc.Uint64FromInt32((*VP8Encoder)(unsafe.Pointer(enc)).Fmb_w) * libc.Uint64FromInt32((*VP8Encoder)(unsafe.Pointer(enc)).Fmb_h) * uint64(384)
 	InitPassStats(tls, enc, bp+3848)
 	ok = PreLoopInitialize(tls, enc)
 	if !(ok != 0) {
 		return 0
 	}
 	if max_count < int32(MIN_COUNT) {
 		max_count = int32(MIN_COUNT)
 	}
 	// otherwise, token-buffer won't be useful
 	for {
 		if v2 = ok != 0; v2 {
 			v1 = num_pass_left
 			num_pass_left = num_pass_left - 1
 		}
 		if !(v2 && v1 > 0) {
 			break
 		}
 		is_last_pass = libc.BoolInt32(libc.Xfabs(tls, float64((**(**PassStats)(__ccgo_up(bp + 3848))).Fdq)) <= float64(DQ_LIMIT) || num_pass_left == 0 || (*VP8Encoder)(unsafe.Pointer(enc)).Fmax_i4_header_bits == 0)
 		size_p0 = uint64(0)
 		distortion = uint64(0)
 		cnt = max_count
 		// The final number of passes is not trivial to know in advance.
 		pass_progress = remaining_progress / (int32(2) + num_pass_left)
 		remaining_progress = remaining_progress - pass_progress
 		VP8IteratorInit(tls, enc, bp)
 		SetLoopParams(tls, enc, (**(**PassStats)(__ccgo_up(bp + 3848))).Fq)
 		if is_last_pass != 0 {
 			ResetTokenStats(tls, enc)
 			VP8InitFilter(tls, bp) // don't collect stats until last pass (too costly)
 		}
 		VP8TBufferClear(tls, enc+496)
 		for cond := true; cond; cond = ok != 0 && VP8IteratorNext(tls, bp) != 0 {
 			VP8IteratorImport(tls, bp, libc.UintptrFromInt32(0))
 			cnt = cnt - 1
 			v1 = cnt
 			if v1 < 0 {
 				FinalizeTokenProbas(tls, proba)
 				VP8CalculateLevelCosts(tls, proba) // refresh cost tables for rd-opt
 				cnt = max_count
 			}
 			VP8Decimate(tls, bp, bp+3904, rd_opt)
 			ok = RecordTokens(tls, bp, bp+3904, enc+496)
 			if !(ok != 0) {
 				WebPEncodingSetError(tls, (*VP8Encoder)(unsafe.Pointer(enc)).Fpic, int32(VP8_ENC_ERROR_OUT_OF_MEMORY))
 				break
 			}
 			size_p0 = size_p0 + libc.Uint64FromInt64((**(**VP8ModeScore)(__ccgo_up(bp + 3904))).FH)
 			distortion = distortion + libc.Uint64FromInt64((**(**VP8ModeScore)(__ccgo_up(bp + 3904))).FD)
 			if is_last_pass != 0 {
 				StoreSideInfo(tls, bp)
 				VP8StoreFilterStats(tls, bp)
 				VP8IteratorExport(tls, bp)
 				ok = VP8IteratorProgress(tls, bp, pass_progress)
 			}
 			VP8IteratorSaveBoundary(tls, bp)
 		}
 		if !(ok != 0) {
 			break
 		}
 		size_p0 = size_p0 + libc.Uint64FromInt32((*VP8Encoder)(unsafe.Pointer(enc)).Fsegment_hdr.Fsize)
 		if (**(**PassStats)(__ccgo_up(bp + 3848))).Fdo_size_search != 0 {
 			size = libc.Uint64FromInt32(FinalizeTokenProbas(tls, enc+3616))
 			size = size + VP8EstimateTokenSize(tls, enc+496, proba+4)
 			size = (size + size_p0 + uint64(1024)) >> int32(11) // -> size in bytes
 			size = size + libc.Uint64FromInt32(libc.Int32FromInt32(RIFF_HEADER_SIZE)+libc.Int32FromInt32(CHUNK_HEADER_SIZE)+libc.Int32FromInt32(VP8_FRAME_HEADER_SIZE))
 			(**(**PassStats)(__ccgo_up(bp + 3848))).Fvalue = float64(size)
 		} else { // compute and store PSNR
 			(**(**PassStats)(__ccgo_up(bp + 3848))).Fvalue = GetPSNR(tls, distortion, pixel_count)
 		}
 		if (*VP8Encoder)(unsafe.Pointer(enc)).Fmax_i4_header_bits > 0 && size_p0 > (libc.Uint64FromInt32(libc.Int32FromInt32(1)<<libc.Int32FromInt32(19))-libc.Uint64FromUint64(2048))<<libc.Int32FromInt32(11) {
 			num_pass_left = num_pass_left + 1
 			**(**int32)(__ccgo_up(enc + 23624)) >>= int32(1) // strengthen header bit limitation...
 			if is_last_pass != 0 {
 				ResetSideInfo(tls, bp)
 			}
 			continue // ...and start over
 		}
 		if is_last_pass != 0 {
 			break // done
 		}
 		if do_search != 0 {
 			ComputeNextQ(tls, bp+3848) // Adjust q
 		}
 	}
 	if ok != 0 {
 		if !((**(**PassStats)(__ccgo_up(bp + 3848))).Fdo_size_search != 0) {
 			FinalizeTokenProbas(tls, enc+3616)
 		}
 		ok = VP8EmitTokens(tls, enc+496, enc+112+uintptr(0)*48, proba+4, int32(1))
 	}
 	ok = libc.BoolInt32(ok != 0 && WebPReportProgress(tls, (*VP8Encoder)(unsafe.Pointer(enc)).Fpic, (*VP8Encoder)(unsafe.Pointer(enc)).Fpercent+remaining_progress, enc+536) != 0)
 	return PostLoopFinalize(tls, bp, ok)
 }
 
 const MAX_HISTO_GREEDY = 100
 const NUM_PARTITIONS = 4
 const __FLT_MIN__2 = 1.17549435082228750796873653722224568e-38
 
 //------------------------------------------------------------------------------
 
 // Copyright 2012 Google Inc. All Rights Reserved.
 //
 // Use of this source code is governed by a BSD-style license
 // that can be found in the COPYING file in the root of the source
 // tree. An additional intellectual property rights grant can be found
 // in the file PATENTS. All contributing project authors may
 // be found in the AUTHORS file in the root of the source tree.
 // -----------------------------------------------------------------------------
 //
 // Misc. common utility functions
 //
 // Authors: Skal (pascal.massimino@gmail.com)
 //          Urvang (urvang@google.com)
 
 // Copyright 2011 Google Inc. All Rights Reserved.
 //
 // Use of this source code is governed by a BSD-style license
 // that can be found in the COPYING file in the root of the source
 // tree. An additional intellectual property rights grant can be found
 // in the file PATENTS. All contributing project authors may
 // be found in the AUTHORS file in the root of the source tree.
 // -----------------------------------------------------------------------------
 //
 //   WebP encoder: main interface
 //
 // Author: Skal (pascal.massimino@gmail.com)
 
 // Copyright 2012 Google Inc. All Rights Reserved.
 //
 // Use of this source code is governed by a BSD-style license
 // that can be found in the COPYING file in the root of the source
 // tree. An additional intellectual property rights grant can be found
 // in the file PATENTS. All contributing project authors may
 // be found in the AUTHORS file in the root of the source tree.
 // -----------------------------------------------------------------------------
 //
 //  Internal header for constants related to WebP file format.
 //
 // Author: Urvang (urvang@google.com)
 
 // Copyright 2010 Google Inc. All Rights Reserved.
 //
 // Use of this source code is governed by a BSD-style license
 // that can be found in the COPYING file in the root of the source
 // tree. An additional intellectual property rights grant can be found
 // in the file PATENTS. All contributing project authors may
 // be found in the AUTHORS file in the root of the source tree.
 // -----------------------------------------------------------------------------
 //
 //  Common types + memory wrappers
 //
 // Author: Skal (pascal.massimino@gmail.com)
 
 // Number of partitions for the three dominant (literal, red and blue) symbol
 // costs.
 // The size of the bin-hash corresponding to the three dominant costs.
 // Maximum number of histograms allowed in greedy combining algorithm.
 
 // C documentation
 //
 //	// Enum to meaningfully access the elements of the Histogram arrays.
 type HistogramIndex = int32
 
 const LITERAL = 0
 const DISTANCE = 4
 
 // C documentation
 //
 //	// Return the size of the histogram for a given cache_bits.
 func GetHistogramSize(tls *libc.TLS, cache_bits int32) (r int32) {
 	var literal_size, v1, v2, v4 int32
 	var total_size size_t
 	_, _, _, _, _ = literal_size, total_size, v1, v2, v4
 	v1 = cache_bits
 	if v1 > 0 {
 		v4 = int32(1) << v1
 	} else {
 		v4 = 0
 	}
 	v2 = libc.Int32FromInt32(NUM_LITERAL_CODES) + libc.Int32FromInt32(NUM_LENGTH_CODES) + v4
 	goto _3
 _3:
 	literal_size = v2
 	total_size = uint64(3312) + uint64(4)*libc.Uint64FromInt32(literal_size)
 	return libc.Int32FromUint64(total_size)
 }
 
 func HistogramStatsClear(tls *libc.TLS, h uintptr) {
 	var i int32
 	_ = i
 	i = 0
 	for {
 		if !(i < int32(5)) {
 			break
 		}
 		**(**uint16_t)(__ccgo_up(h + 3244 + uintptr(i)*2)) = libc.Uint16FromInt32(libc.Int32FromInt32(0xffff))
 		// By default, the histogram is assumed to be used.
 		**(**uint8_t)(__ccgo_up(h + 3304 + uintptr(i))) = uint8(1)
 		goto _1
 	_1:
 		;
 		i = i + 1
 	}
 	(*VP8LHistogram)(unsafe.Pointer(h)).Fbit_cost = uint64(0)
 	libc.X__builtin___memset_chk(tls, h+3264, 0, uint64(40), ^__predefined_size_t(0))
 }
 
 func HistogramClear(tls *libc.TLS, h uintptr) {
 	var cache_bits, histo_size int32
 	var literal uintptr
 	_, _, _ = cache_bits, histo_size, literal
 	literal = (*VP8LHistogram)(unsafe.Pointer(h)).Fliteral
 	cache_bits = (*VP8LHistogram)(unsafe.Pointer(h)).Fpalette_code_bits
 	histo_size = GetHistogramSize(tls, cache_bits)
 	libc.X__builtin___memset_chk(tls, h, 0, libc.Uint64FromInt32(histo_size), ^__predefined_size_t(0))
 	(*VP8LHistogram)(unsafe.Pointer(h)).Fpalette_code_bits = cache_bits
 	(*VP8LHistogram)(unsafe.Pointer(h)).Fliteral = literal
 	HistogramStatsClear(tls, h)
 }
 
 // C documentation
 //
 //	// Swap two histogram pointers.
 func HistogramSwap(tls *libc.TLS, h1 uintptr, h2 uintptr) {
 	var tmp uintptr
 	_ = tmp
 	tmp = **(**uintptr)(__ccgo_up(h1))
 	**(**uintptr)(__ccgo_up(h1)) = **(**uintptr)(__ccgo_up(h2))
 	**(**uintptr)(__ccgo_up(h2)) = tmp
 }
 
 func HistogramCopy(tls *libc.TLS, src uintptr, dst uintptr) {
 	var dst_cache_bits, histo_size, literal_size, v1, v2, v4 int32
 	var dst_literal uintptr
 	_, _, _, _, _, _, _ = dst_cache_bits, dst_literal, histo_size, literal_size, v1, v2, v4
 	dst_literal = (*VP8LHistogram)(unsafe.Pointer(dst)).Fliteral
 	dst_cache_bits = (*VP8LHistogram)(unsafe.Pointer(dst)).Fpalette_code_bits
 	v1 = dst_cache_bits
 	if v1 > 0 {
 		v4 = int32(1) << v1
 	} else {
 		v4 = 0
 	}
 	v2 = libc.Int32FromInt32(NUM_LITERAL_CODES) + libc.Int32FromInt32(NUM_LENGTH_CODES) + v4
 	goto _3
 _3:
 	literal_size = v2
 	histo_size = GetHistogramSize(tls, dst_cache_bits)
 	libc.X__builtin___memcpy_chk(tls, dst, src, libc.Uint64FromInt32(histo_size), ^__predefined_size_t(0))
 	(*VP8LHistogram)(unsafe.Pointer(dst)).Fliteral = dst_literal
 	libc.X__builtin___memcpy_chk(tls, (*VP8LHistogram)(unsafe.Pointer(dst)).Fliteral, (*VP8LHistogram)(unsafe.Pointer(src)).Fliteral, libc.Uint64FromInt32(literal_size)*uint64(4), ^__predefined_size_t(0))
 }
 
 func VP8LFreeHistogram(tls *libc.TLS, h uintptr) {
 	WebPSafeFree(tls, h)
 }
 
 func VP8LFreeHistogramSet(tls *libc.TLS, histograms uintptr) {
 	WebPSafeFree(tls, histograms)
 }
 
 func VP8LHistogramCreate(tls *libc.TLS, h uintptr, refs uintptr, palette_code_bits int32) {
 	if palette_code_bits >= 0 {
 		(*VP8LHistogram)(unsafe.Pointer(h)).Fpalette_code_bits = palette_code_bits
 	}
 	HistogramClear(tls, h)
 	VP8LHistogramStoreRefs(tls, refs, libc.UintptrFromInt32(0), 0, h)
 }
 
 func VP8LHistogramInit(tls *libc.TLS, h uintptr, palette_code_bits int32, init_arrays int32) {
 	(*VP8LHistogram)(unsafe.Pointer(h)).Fpalette_code_bits = palette_code_bits
 	if init_arrays != 0 {
 		HistogramClear(tls, h)
 	} else {
 		HistogramStatsClear(tls, h)
 	}
 }
 
 func VP8LAllocateHistogram(tls *libc.TLS, cache_bits int32) (r uintptr) {
 	var histo, memory uintptr
 	var total_size int32
 	_, _, _ = histo, memory, total_size
 	histo = libc.UintptrFromInt32(0)
 	total_size = GetHistogramSize(tls, cache_bits)
 	memory = WebPSafeMalloc(tls, libc.Uint64FromInt32(total_size), uint64(1))
 	if memory == libc.UintptrFromInt32(0) {
 		return libc.UintptrFromInt32(0)
 	}
 	histo = memory
 	// 'literal' won't necessary be aligned.
 	(*VP8LHistogram)(unsafe.Pointer(histo)).Fliteral = memory + libc.UintptrFromInt64(3312)
 	VP8LHistogramInit(tls, histo, cache_bits, 0)
 	return histo
 }
 
 // C documentation
 //
 //	// Resets the pointers of the histograms to point to the bit buffer in the set.
 func HistogramSetResetPointers(tls *libc.TLS, set uintptr, cache_bits int32) {
 	var histo_size, i int32
 	var memory uintptr
 	_, _, _ = histo_size, i, memory
 	histo_size = GetHistogramSize(tls, cache_bits)
 	memory = (*VP8LHistogramSet)(unsafe.Pointer(set)).Fhistograms
 	memory = memory + uintptr(libc.Uint64FromInt32((*VP8LHistogramSet)(unsafe.Pointer(set)).Fmax_size)*uint64(8))
 	i = 0
 	for {
 		if !(i < (*VP8LHistogramSet)(unsafe.Pointer(set)).Fmax_size) {
 			break
 		}
 		memory = uintptr((uint64(memory) + libc.Uint64FromInt32(WEBP_ALIGN_CST)) & ^libc.Uint64FromInt32(WEBP_ALIGN_CST))
 		**(**uintptr)(__ccgo_up((*VP8LHistogramSet)(unsafe.Pointer(set)).Fhistograms + uintptr(i)*8)) = memory
 		// 'literal' won't necessary be aligned.
 		(*VP8LHistogram)(unsafe.Pointer(**(**uintptr)(__ccgo_up((*VP8LHistogramSet)(unsafe.Pointer(set)).Fhistograms + uintptr(i)*8)))).Fliteral = memory + libc.UintptrFromInt64(3312)
 		memory = memory + uintptr(histo_size)
 		goto _1
 	_1:
 		;
 		i = i + 1
 	}
 }
 
 // C documentation
 //
 //	// Returns the total size of the VP8LHistogramSet.
 func HistogramSetTotalSize(tls *libc.TLS, size int32, cache_bits int32) (r size_t) {
 	var histo_size int32
 	_ = histo_size
 	histo_size = GetHistogramSize(tls, cache_bits)
 	return libc.Uint64FromInt64(16) + libc.Uint64FromInt32(size)*(libc.Uint64FromInt64(8)+libc.Uint64FromInt32(histo_size)+libc.Uint64FromInt32(WEBP_ALIGN_CST))
 }
 
 func VP8LAllocateHistogramSet(tls *libc.TLS, size int32, cache_bits int32) (r uintptr) {
 	var i int32
 	var memory, set uintptr
 	var total_size size_t
 	_, _, _, _ = i, memory, set, total_size
 	total_size = HistogramSetTotalSize(tls, size, cache_bits)
 	memory = WebPSafeMalloc(tls, total_size, uint64(1))
 	if memory == libc.UintptrFromInt32(0) {
 		return libc.UintptrFromInt32(0)
 	}
 	set = memory
 	memory = memory + uintptr(16)
 	(*VP8LHistogramSet)(unsafe.Pointer(set)).Fhistograms = memory
 	(*VP8LHistogramSet)(unsafe.Pointer(set)).Fmax_size = size
 	(*VP8LHistogramSet)(unsafe.Pointer(set)).Fsize = size
 	HistogramSetResetPointers(tls, set, cache_bits)
 	i = 0
 	for {
 		if !(i < size) {
 			break
 		}
 		VP8LHistogramInit(tls, **(**uintptr)(__ccgo_up((*VP8LHistogramSet)(unsafe.Pointer(set)).Fhistograms + uintptr(i)*8)), cache_bits, 0)
 		goto _1
 	_1:
 		;
 		i = i + 1
 	}
 	return set
 }
 
 func VP8LHistogramSetClear(tls *libc.TLS, set uintptr) {
 	var cache_bits, i, size int32
 	var memory uintptr
 	var total_size size_t
 	_, _, _, _, _ = cache_bits, i, memory, size, total_size
 	cache_bits = (*VP8LHistogram)(unsafe.Pointer(**(**uintptr)(__ccgo_up((*VP8LHistogramSet)(unsafe.Pointer(set)).Fhistograms)))).Fpalette_code_bits
 	size = (*VP8LHistogramSet)(unsafe.Pointer(set)).Fmax_size
 	total_size = HistogramSetTotalSize(tls, size, cache_bits)
 	memory = set
 	libc.X__builtin___memset_chk(tls, memory, 0, total_size, ^__predefined_size_t(0))
 	memory = memory + uintptr(16)
 	(*VP8LHistogramSet)(unsafe.Pointer(set)).Fhistograms = memory
 	(*VP8LHistogramSet)(unsafe.Pointer(set)).Fmax_size = size
 	(*VP8LHistogramSet)(unsafe.Pointer(set)).Fsize = size
 	HistogramSetResetPointers(tls, set, cache_bits)
 	i = 0
 	for {
 		if !(i < size) {
 			break
 		}
 		(*VP8LHistogram)(unsafe.Pointer(**(**uintptr)(__ccgo_up((*VP8LHistogramSet)(unsafe.Pointer(set)).Fhistograms + uintptr(i)*8)))).Fpalette_code_bits = cache_bits
 		goto _1
 	_1:
 		;
 		i = i + 1
 	}
 }
 
 // C documentation
 //
 //	// Removes the histogram 'i' from 'set'.
 func HistogramSetRemoveHistogram(tls *libc.TLS, set uintptr, i int32) {
 	**(**uintptr)(__ccgo_up((*VP8LHistogramSet)(unsafe.Pointer(set)).Fhistograms + uintptr(i)*8)) = **(**uintptr)(__ccgo_up((*VP8LHistogramSet)(unsafe.Pointer(set)).Fhistograms + uintptr((*VP8LHistogramSet)(unsafe.Pointer(set)).Fsize-int32(1))*8))
 	(*VP8LHistogramSet)(unsafe.Pointer(set)).Fsize = (*VP8LHistogramSet)(unsafe.Pointer(set)).Fsize - 1
 }
 
 // -----------------------------------------------------------------------------
 
 func HistogramAddSinglePixOrCopy(tls *libc.TLS, histo uintptr, v uintptr, __ccgo_fp_distance_modifier uintptr, distance_modifier_arg0 int32) {
 	bp := tls.Alloc(16)
 	defer tls.Free(16)
 	var highest_bit, literal_ix, second_highest_bit, v1, v11, v17, v20 int32
 	var prefix_code VP8LPrefixCode
 	var v3 uint32_t
 	var v18, v19 uintptr
 	var _ /* code at bp+0 */ int32
 	var _ /* extra_bits at bp+4 */ int32
 	_, _, _, _, _, _, _, _, _, _, _ = highest_bit, literal_ix, prefix_code, second_highest_bit, v1, v11, v17, v18, v19, v20, v3
 	v1 = libc.BoolInt32(libc.Int32FromUint8((*PixOrCopy)(unsafe.Pointer(v)).Fmode) == int32(kLiteral))
 	goto _2
 _2:
 	if v1 != 0 {
 		v3 = (*PixOrCopy)(unsafe.Pointer(v)).Fargb_or_distance >> (int32(3) * libc.Int32FromInt32(8)) & uint32(0xff)
 		goto _4
 	_4:
 		**(**uint32_t)(__ccgo_up(histo + 2056 + uintptr(v3)*4)) = **(**uint32_t)(__ccgo_up(histo + 2056 + uintptr(v3)*4)) + 1
 		v3 = (*PixOrCopy)(unsafe.Pointer(v)).Fargb_or_distance >> (int32(2) * libc.Int32FromInt32(8)) & uint32(0xff)
 		goto _6
 	_6:
 		**(**uint32_t)(__ccgo_up(histo + 8 + uintptr(v3)*4)) = **(**uint32_t)(__ccgo_up(histo + 8 + uintptr(v3)*4)) + 1
 		v3 = (*PixOrCopy)(unsafe.Pointer(v)).Fargb_or_distance >> (int32(1) * libc.Int32FromInt32(8)) & uint32(0xff)
 		goto _8
 	_8:
 		**(**uint32_t)(__ccgo_up((*VP8LHistogram)(unsafe.Pointer(histo)).Fliteral + uintptr(v3)*4)) = **(**uint32_t)(__ccgo_up((*VP8LHistogram)(unsafe.Pointer(histo)).Fliteral + uintptr(v3)*4)) + 1
 		v3 = (*PixOrCopy)(unsafe.Pointer(v)).Fargb_or_distance >> (0 * libc.Int32FromInt32(8)) & uint32(0xff)
 		goto _10
 	_10:
 		**(**uint32_t)(__ccgo_up(histo + 1032 + uintptr(v3)*4)) = **(**uint32_t)(__ccgo_up(histo + 1032 + uintptr(v3)*4)) + 1
 	} else {
 		v1 = libc.BoolInt32(libc.Int32FromUint8((*PixOrCopy)(unsafe.Pointer(v)).Fmode) == int32(kCacheIdx))
 		goto _12
 	_12:
 		if v1 != 0 {
 			v3 = (*PixOrCopy)(unsafe.Pointer(v)).Fargb_or_distance
 			goto _14
 		_14:
 			literal_ix = libc.Int32FromUint32(libc.Uint32FromInt32(libc.Int32FromInt32(NUM_LITERAL_CODES)+libc.Int32FromInt32(NUM_LENGTH_CODES)) + v3)
 			**(**uint32_t)(__ccgo_up((*VP8LHistogram)(unsafe.Pointer(histo)).Fliteral + uintptr(literal_ix)*4)) = **(**uint32_t)(__ccgo_up((*VP8LHistogram)(unsafe.Pointer(histo)).Fliteral + uintptr(literal_ix)*4)) + 1
 		} else {
 			v3 = uint32((*PixOrCopy)(unsafe.Pointer(v)).Flen1)
 			goto _16
 		_16:
 			v1 = libc.Int32FromUint32(v3)
 			v18 = bp
 			v19 = bp + 4
 			if v1 < libc.Int32FromInt32(PREFIX_LOOKUP_IDX_MAX) {
 				prefix_code = kPrefixEncodeCode[v1]
 				**(**int32)(__ccgo_up(v18)) = int32(prefix_code.Fcode)
 				**(**int32)(__ccgo_up(v19)) = int32(prefix_code.Fextra_bits)
 			} else {
 				v11 = v1
 				v11 = v11 - 1
 				v17 = v11
 				v20 = int32(31) ^ libc.X__builtin_clz(tls, libc.Uint32FromInt32(v17))
 				goto _23
 			_23:
 				highest_bit = v20
 				second_highest_bit = v11 >> (highest_bit - int32(1)) & int32(1)
 				**(**int32)(__ccgo_up(v19)) = highest_bit - int32(1)
 				**(**int32)(__ccgo_up(v18)) = int32(2)*highest_bit + second_highest_bit
 			}
 			**(**uint32_t)(__ccgo_up((*VP8LHistogram)(unsafe.Pointer(histo)).Fliteral + uintptr(int32(NUM_LITERAL_CODES)+**(**int32)(__ccgo_up(bp)))*4)) = **(**uint32_t)(__ccgo_up((*VP8LHistogram)(unsafe.Pointer(histo)).Fliteral + uintptr(int32(NUM_LITERAL_CODES)+**(**int32)(__ccgo_up(bp)))*4)) + 1
 			if __ccgo_fp_distance_modifier == libc.UintptrFromInt32(0) {
 				v3 = (*PixOrCopy)(unsafe.Pointer(v)).Fargb_or_distance
 				goto _25
 			_25:
 				v1 = libc.Int32FromUint32(v3)
 				v18 = bp
 				v19 = bp + 4
 				if v1 < libc.Int32FromInt32(PREFIX_LOOKUP_IDX_MAX) {
 					prefix_code = kPrefixEncodeCode[v1]
 					**(**int32)(__ccgo_up(v18)) = int32(prefix_code.Fcode)
 					**(**int32)(__ccgo_up(v19)) = int32(prefix_code.Fextra_bits)
 				} else {
 					v11 = v1
 					v11 = v11 - 1
 					v17 = v11
 					v20 = int32(31) ^ libc.X__builtin_clz(tls, libc.Uint32FromInt32(v17))
 					goto _32
 				_32:
 					highest_bit = v20
 					second_highest_bit = v11 >> (highest_bit - int32(1)) & int32(1)
 					**(**int32)(__ccgo_up(v19)) = highest_bit - int32(1)
 					**(**int32)(__ccgo_up(v18)) = int32(2)*highest_bit + second_highest_bit
 				}
 			} else {
 				v3 = (*PixOrCopy)(unsafe.Pointer(v)).Fargb_or_distance
 				goto _34
 			_34:
 				v1 = (*(*func(*libc.TLS, int32, int32) int32)(unsafe.Pointer(&struct{ uintptr }{__ccgo_fp_distance_modifier})))(tls, distance_modifier_arg0, libc.Int32FromUint32(v3))
 				v18 = bp
 				v19 = bp + 4
 				if v1 < libc.Int32FromInt32(PREFIX_LOOKUP_IDX_MAX) {
 					prefix_code = kPrefixEncodeCode[v1]
 					**(**int32)(__ccgo_up(v18)) = int32(prefix_code.Fcode)
 					**(**int32)(__ccgo_up(v19)) = int32(prefix_code.Fextra_bits)
 				} else {
 					v11 = v1
 					v11 = v11 - 1
 					v17 = v11
 					v20 = int32(31) ^ libc.X__builtin_clz(tls, libc.Uint32FromInt32(v17))
 					goto _41
 				_41:
 					highest_bit = v20
 					second_highest_bit = v11 >> (highest_bit - int32(1)) & int32(1)
 					**(**int32)(__ccgo_up(v19)) = highest_bit - int32(1)
 					**(**int32)(__ccgo_up(v18)) = int32(2)*highest_bit + second_highest_bit
 				}
 			}
 			**(**uint32_t)(__ccgo_up(histo + 3080 + uintptr(**(**int32)(__ccgo_up(bp)))*4)) = **(**uint32_t)(__ccgo_up(histo + 3080 + uintptr(**(**int32)(__ccgo_up(bp)))*4)) + 1
 		}
 	}
 }
 
 type __ccgo_fp__XVP8LHistogramStoreRefs_1 = func(*libc.TLS, int32, int32) int32
 
 func VP8LHistogramStoreRefs(tls *libc.TLS, refs uintptr, __ccgo_fp_distance_modifier uintptr, distance_modifier_arg0 int32, histo uintptr) {
 	bp := tls.Alloc(32)
 	defer tls.Free(32)
 	var v1 int32
 	var v3, v4, v5 uintptr
 	var _ /* c at bp+0 */ VP8LRefsCursor
 	_, _, _, _ = v1, v3, v4, v5
 	**(**VP8LRefsCursor)(__ccgo_up(bp)) = VP8LRefsCursorInit(tls, refs)
 	for {
 		v1 = libc.BoolInt32((*VP8LRefsCursor)(unsafe.Pointer(bp)).Fcur_pos != libc.UintptrFromInt32(0))
 		goto _2
 	_2:
 		if !(v1 != 0) {
 			break
 		}
 		HistogramAddSinglePixOrCopy(tls, histo, (**(**VP8LRefsCursor)(__ccgo_up(bp))).Fcur_pos, __ccgo_fp_distance_modifier, distance_modifier_arg0)
 		v3 = bp
 		v5 = v3
 		*(*uintptr)(unsafe.Pointer(v5)) += 8
 		v4 = *(*uintptr)(unsafe.Pointer(v5))
 		if v4 == (*VP8LRefsCursor)(unsafe.Pointer(v3)).Flast_pos {
 			VP8LRefsCursorNextBlock(tls, v3)
 		}
 	}
 }
 
 // -----------------------------------------------------------------------------
 // Entropy-related functions.
 
 func BitsEntropyRefine(tls *libc.TLS, entropy uintptr) (r uint64_t) {
 	var min_limit, mix uint64_t
 	var v1, v2, v3 int64_t
 	var v5 int64
 	var v11 uint64
 	_, _, _, _, _, _, _ = min_limit, mix, v1, v11, v2, v3, v5
 	if (*VP8LBitEntropy)(unsafe.Pointer(entropy)).Fnonzeros < int32(5) {
 		if (*VP8LBitEntropy)(unsafe.Pointer(entropy)).Fnonzeros <= int32(1) {
 			return uint64(0)
 		}
 		// Two symbols, they will be 0 and 1 in a Huffman code.
 		// Let's mix in a bit of entropy to favor good clustering when
 		// distributions of these are combined.
 		if (*VP8LBitEntropy)(unsafe.Pointer(entropy)).Fnonzeros == int32(2) {
 			v1 = libc.Int64FromUint64(uint64(99)*(uint64((*VP8LBitEntropy)(unsafe.Pointer(entropy)).Fsum)<<libc.Int32FromInt32(LOG_2_PRECISION_BITS)) + (*VP8LBitEntropy)(unsafe.Pointer(entropy)).Fentropy)
 			v2 = int64(100)
 			if libc.BoolInt32(v1 < 0) == libc.BoolInt32(v2 < 0) {
 				v5 = (v1 + v2/int64(2)) / v2
 			} else {
 				v5 = (v1 - v2/int64(2)) / v2
 			}
 			v3 = v5
 			goto _4
 		_4:
 			return libc.Uint64FromInt64(v3)
 		}
 		// No matter what the entropy says, we cannot be better than min_limit
 		// with Huffman coding. I am mixing a bit of entropy into the
 		// min_limit since it produces much better (~0.5 %) compression results
 		// perhaps because of better entropy clustering.
 		if (*VP8LBitEntropy)(unsafe.Pointer(entropy)).Fnonzeros == int32(3) {
 			mix = uint64(950)
 		} else {
 			mix = uint64(700) // nonzeros == 4.
 		}
 	} else {
 		mix = uint64(627)
 	}
 	min_limit = uint64(libc.Uint32FromInt32(2)*(*VP8LBitEntropy)(unsafe.Pointer(entropy)).Fsum-(*VP8LBitEntropy)(unsafe.Pointer(entropy)).Fmax_val) << int32(LOG_2_PRECISION_BITS)
 	v1 = libc.Int64FromUint64(mix*min_limit + (uint64(1000)-mix)*(*VP8LBitEntropy)(unsafe.Pointer(entropy)).Fentropy)
 	v2 = int64(1000)
 	if libc.BoolInt32(v1 < 0) == libc.BoolInt32(v2 < 0) {
 		v5 = (v1 + v2/int64(2)) / v2
 	} else {
 		v5 = (v1 - v2/int64(2)) / v2
 	}
 	v3 = v5
 	goto _9
 _9:
 	min_limit = libc.Uint64FromInt64(v3)
 	if (*VP8LBitEntropy)(unsafe.Pointer(entropy)).Fentropy < min_limit {
 		v11 = min_limit
 	} else {
 		v11 = (*VP8LBitEntropy)(unsafe.Pointer(entropy)).Fentropy
 	}
 	return v11
 	return r
 }
 
 func VP8LBitsEntropy(tls *libc.TLS, array uintptr, n int32) (r uint64_t) {
 	bp := tls.Alloc(32)
 	defer tls.Free(32)
 	var _ /* entropy at bp+0 */ VP8LBitEntropy
 	VP8LBitsEntropyUnrefined(tls, array, n, bp)
 	return BitsEntropyRefine(tls, bp)
 }
 
 func InitialHuffmanCost(tls *libc.TLS) (r uint64_t) {
 	var v1, v2, v3 int64_t
 	var v5 int64
 	_, _, _, _ = v1, v2, v3, v5
 	// Subtract a bias of 9.1.
 	v1 = libc.Int64FromInt64(91) << libc.Int32FromInt32(LOG_2_PRECISION_BITS)
 	v2 = int64(10)
 	if libc.BoolInt32(v1 < 0) == libc.BoolInt32(v2 < 0) {
 		v5 = (v1 + v2/int64(2)) / v2
 	} else {
 		v5 = (v1 - v2/int64(2)) / v2
 	}
 	v3 = v5
 	goto _4
 _4:
 	return kHuffmanCodeOfHuffmanCodeSize<<libc.Int32FromInt32(LOG_2_PRECISION_BITS) - libc.Uint64FromInt64(v3)
 }
 
 // Small bias because Huffman code length is typically not stored in
 // full length.
 var kHuffmanCodeOfHuffmanCodeSize = libc.Uint64FromInt32(libc.Int32FromInt32(CODE_LENGTH_CODES) * libc.Int32FromInt32(3))
 
 // C documentation
 //
 //	// Finalize the Huffman cost based on streak numbers and length type (<3 or >=3)
 func FinalHuffmanCost(tls *libc.TLS, stats uintptr) (r uint64_t) {
 	var retval uint64_t
 	var retval_extra uint32_t
 	_, _ = retval, retval_extra
 	// The constants in this function are empirical and got rounded from
 	// their original values in 1/8 when switched to 1/1024.
 	retval = InitialHuffmanCost(tls)
 	// Second coefficient: Many zeros in the histogram are covered efficiently
 	// by a run-length encode. Originally 2/8.
 	retval_extra = libc.Uint32FromInt32(**(**int32)(__ccgo_up(stats))*int32(1600) + int32(240)***(**int32)(__ccgo_up(stats + 8 + 1*4)))
 	// Second coefficient: Constant values are encoded less efficiently, but still
 	// RLE'ed. Originally 6/8.
 	retval_extra = retval_extra + libc.Uint32FromInt32(**(**int32)(__ccgo_up(stats + 1*4))*int32(2640)+int32(720)***(**int32)(__ccgo_up(stats + 8 + 1*8 + 1*4)))
 	// 0s are usually encoded more efficiently than non-0s.
 	// Originally 15/8.
 	retval_extra = retval_extra + libc.Uint32FromInt32(int32(1840)***(**int32)(__ccgo_up(stats + 8)))
 	// Originally 26/8.
 	retval_extra = retval_extra + libc.Uint32FromInt32(int32(3360)***(**int32)(__ccgo_up(stats + 8 + 1*8)))
 	return retval + uint64(retval_extra)<<(libc.Int32FromInt32(LOG_2_PRECISION_BITS)-libc.Int32FromInt32(10))
 }
 
 // C documentation
 //
 //	// Get the symbol entropy for the distribution 'population'.
 //	// Set 'trivial_sym', if there's only one symbol present in the distribution.
 func PopulationCost(tls *libc.TLS, population uintptr, length int32, trivial_sym uintptr, is_used uintptr) (r uint64_t) {
 	bp := tls.Alloc(48)
 	defer tls.Free(48)
 	var v1 uint32
 	var _ /* bit_entropy at bp+0 */ VP8LBitEntropy
 	var _ /* stats at bp+24 */ VP8LStreaks
 	_ = v1
 	(*(*func(*libc.TLS, uintptr, int32, uintptr, uintptr))(unsafe.Pointer(&struct{ uintptr }{VP8LGetEntropyUnrefined})))(tls, population, length, bp, bp+24)
 	if trivial_sym != libc.UintptrFromInt32(0) {
 		if (**(**VP8LBitEntropy)(__ccgo_up(bp))).Fnonzeros == int32(1) {
 			v1 = (**(**VP8LBitEntropy)(__ccgo_up(bp))).Fnonzero_code
 		} else {
 			v1 = uint32(libc.Uint16FromInt32(libc.Int32FromInt32(0xffff)))
 		}
 		**(**uint16_t)(__ccgo_up(trivial_sym)) = uint16(v1)
 	}
 	if is_used != libc.UintptrFromInt32(0) {
 		// The histogram is used if there is at least one non-zero streak.
 		**(**uint8_t)(__ccgo_up(is_used)) = libc.BoolUint8(**(**int32)(__ccgo_up(bp + 24 + 8 + 1*8)) != 0 || **(**int32)(__ccgo_up(bp + 24 + 8 + 1*8 + 1*4)) != 0)
 	}
 	return BitsEntropyRefine(tls, bp) + FinalHuffmanCost(tls, bp+24)
 }
 
 func GetPopulationInfo(tls *libc.TLS, histo uintptr, index HistogramIndex, population uintptr, length uintptr) {
 	var v1, v2, v4 int32
 	_, _, _ = v1, v2, v4
 	switch index {
 	case int32(LITERAL):
 		**(**uintptr)(__ccgo_up(population)) = (*VP8LHistogram)(unsafe.Pointer(histo)).Fliteral
 		v1 = (*VP8LHistogram)(unsafe.Pointer(histo)).Fpalette_code_bits
 		if v1 > 0 {
 			v4 = int32(1) << v1
 		} else {
 			v4 = 0
 		}
 		v2 = libc.Int32FromInt32(NUM_LITERAL_CODES) + libc.Int32FromInt32(NUM_LENGTH_CODES) + v4
 		goto _3
 	_3:
 		**(**int32)(__ccgo_up(length)) = v2
 	case int32(RED):
 		**(**uintptr)(__ccgo_up(population)) = histo + 8
 		**(**int32)(__ccgo_up(length)) = int32(NUM_LITERAL_CODES)
 	case int32(BLUE):
 		**(**uintptr)(__ccgo_up(population)) = histo + 1032
 		**(**int32)(__ccgo_up(length)) = int32(NUM_LITERAL_CODES)
 	case int32(ALPHA):
 		**(**uintptr)(__ccgo_up(population)) = histo + 2056
 		**(**int32)(__ccgo_up(length)) = int32(NUM_LITERAL_CODES)
 	case int32(DISTANCE):
 		**(**uintptr)(__ccgo_up(population)) = histo + 3080
 		**(**int32)(__ccgo_up(length)) = int32(NUM_DISTANCE_CODES)
 		break
 	}
 }
 
 // C documentation
 //
 //	// trivial_at_end is 1 if the two histograms only have one element that is
 //	// non-zero: both the zero-th one, or both the last one.
 //	// 'index' is the index of the symbol in the histogram (literal, red, blue,
 //	// alpha, distance).
 func GetCombinedEntropy(tls *libc.TLS, h1 uintptr, h2 uintptr, index HistogramIndex) (r uint64_t) {
 	bp := tls.Alloc(80)
 	defer tls.Free(80)
 	var is_h1_used, is_h2_used, is_trivial int32
 	var _ /* X at bp+0 */ uintptr
 	var _ /* Y at bp+8 */ uintptr
 	var _ /* bit_entropy at bp+48 */ VP8LBitEntropy
 	var _ /* length at bp+16 */ int32
 	var _ /* stats at bp+20 */ VP8LStreaks
 	_, _, _ = is_h1_used, is_h2_used, is_trivial
 	is_h1_used = libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(h1 + 3304 + uintptr(index))))
 	is_h2_used = libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(h2 + 3304 + uintptr(index))))
 	is_trivial = libc.BoolInt32(libc.Int32FromUint16(**(**uint16_t)(__ccgo_up(h1 + 3244 + uintptr(index)*2))) != libc.Int32FromUint16(libc.Uint16FromInt32(libc.Int32FromInt32(0xffff))) && libc.Int32FromUint16(**(**uint16_t)(__ccgo_up(h1 + 3244 + uintptr(index)*2))) == libc.Int32FromUint16(**(**uint16_t)(__ccgo_up(h2 + 3244 + uintptr(index)*2))))
 	if is_trivial != 0 || !(is_h1_used != 0) || !(is_h2_used != 0) {
 		if is_h1_used != 0 {
 			return **(**uint64_t)(__ccgo_up(h1 + 3264 + uintptr(index)*8))
 		}
 		return **(**uint64_t)(__ccgo_up(h2 + 3264 + uintptr(index)*8))
 	}
 	GetPopulationInfo(tls, h1, index, bp, bp+16)
 	GetPopulationInfo(tls, h2, index, bp+8, bp+16)
 	(*(*func(*libc.TLS, uintptr, uintptr, int32, uintptr, uintptr))(unsafe.Pointer(&struct{ uintptr }{VP8LGetCombinedEntropyUnrefined})))(tls, **(**uintptr)(__ccgo_up(bp)), **(**uintptr)(__ccgo_up(bp + 8)), **(**int32)(__ccgo_up(bp + 16)), bp+48, bp+20)
 	return BitsEntropyRefine(tls, bp+48) + FinalHuffmanCost(tls, bp+20)
 }
 
 // C documentation
 //
 //	// Estimates the Entropy + Huffman + other block overhead size cost.
 func VP8LHistogramEstimateBits(tls *libc.TLS, h uintptr) (r uint64_t) {
 	bp := tls.Alloc(16)
 	defer tls.Free(16)
 	var cost uint64_t
 	var i int32
 	var _ /* length at bp+0 */ int32
 	var _ /* population at bp+8 */ uintptr
 	_, _ = cost, i
 	cost = uint64(0)
 	i = 0
 	for {
 		if !(i < int32(5)) {
 			break
 		}
 		GetPopulationInfo(tls, h, i, bp+8, bp)
 		cost = cost + PopulationCost(tls, **(**uintptr)(__ccgo_up(bp + 8)), **(**int32)(__ccgo_up(bp)), libc.UintptrFromInt32(0), libc.UintptrFromInt32(0))
 		goto _1
 	_1:
 		;
 		i = i + 1
 	}
 	cost = cost + uint64((*(*func(*libc.TLS, uintptr, int32) uint32_t)(unsafe.Pointer(&struct{ uintptr }{VP8LExtraCost})))(tls, (*VP8LHistogram)(unsafe.Pointer(h)).Fliteral+uintptr(NUM_LITERAL_CODES)*4, int32(NUM_LENGTH_CODES))+(*(*func(*libc.TLS, uintptr, int32) uint32_t)(unsafe.Pointer(&struct{ uintptr }{VP8LExtraCost})))(tls, h+3080, int32(NUM_DISTANCE_CODES)))<<libc.Int32FromInt32(LOG_2_PRECISION_BITS)
 	return cost
 }
 
 // -----------------------------------------------------------------------------
 // Various histogram combine/cost-eval functions
 
 // C documentation
 //
 //	// Set a + b in b, saturating at WEBP_INT64_MAX.
 func SaturateAdd(tls *libc.TLS, a uint64_t, b uintptr) {
 	if **(**int64_t)(__ccgo_up(b)) < 0 || libc.Int64FromUint64(a) <= libc.Int64FromUint64(libc.Uint64FromUint64(1)<<libc.Int32FromInt32(63)-libc.Uint64FromInt32(1))-**(**int64_t)(__ccgo_up(b)) {
 		**(**int64_t)(__ccgo_up(b)) += libc.Int64FromUint64(a)
 	} else {
 		**(**int64_t)(__ccgo_up(b)) = libc.Int64FromUint64(libc.Uint64FromUint64(1)<<libc.Int32FromInt32(63) - libc.Uint64FromInt32(1))
 	}
 }
 
 // C documentation
 //
 //	// Returns 1 if the cost of the combined histogram is less than the threshold.
 //	// Otherwise returns 0 and the cost is invalid due to early bail-out.
 func GetCombinedHistogramEntropy(tls *libc.TLS, a uintptr, b uintptr, cost_threshold_in int64_t, cost uintptr, costs uintptr) (r int32) {
 	var cost_threshold uint64_t
 	var i int32
 	_, _ = cost_threshold, i
 	cost_threshold = libc.Uint64FromInt64(cost_threshold_in)
 	if cost_threshold_in <= 0 {
 		return 0
 	}
 	**(**uint64_t)(__ccgo_up(cost)) = uint64(0)
 	// No need to add the extra cost for length and distance as it is a constant
 	// that does not influence the histograms.
 	i = 0
 	for {
 		if !(i < int32(5)) {
 			break
 		}
 		**(**uint64_t)(__ccgo_up(costs + uintptr(i)*8)) = GetCombinedEntropy(tls, a, b, i)
 		**(**uint64_t)(__ccgo_up(cost)) += **(**uint64_t)(__ccgo_up(costs + uintptr(i)*8))
 		if **(**uint64_t)(__ccgo_up(cost)) >= cost_threshold {
 			return 0
 		}
 		goto _1
 	_1:
 		;
 		i = i + 1
 	}
 	return int32(1)
 }
 
 func HistogramAdd(tls *libc.TLS, h1 uintptr, h2 uintptr, hout uintptr) {
 	bp := tls.Alloc(32)
 	defer tls.Free(32)
 	var i, v3 int32
 	var pout uintptr
 	var _ /* length at bp+0 */ int32
 	var _ /* p1 at bp+8 */ uintptr
 	var _ /* p2 at bp+16 */ uintptr
 	var _ /* pout_const at bp+24 */ uintptr
 	_, _, _ = i, pout, v3
 	i = 0
 	for {
 		if !(i < int32(5)) {
 			break
 		}
 		GetPopulationInfo(tls, h1, i, bp+8, bp)
 		GetPopulationInfo(tls, h2, i, bp+16, bp)
 		GetPopulationInfo(tls, hout, i, bp+24, bp)
 		pout = **(**uintptr)(__ccgo_up(bp + 24))
 		if h2 == hout {
 			if **(**uint8_t)(__ccgo_up(h1 + 3304 + uintptr(i))) != 0 {
 				if **(**uint8_t)(__ccgo_up(hout + 3304 + uintptr(i))) != 0 {
 					(*(*func(*libc.TLS, uintptr, uintptr, int32))(unsafe.Pointer(&struct{ uintptr }{VP8LAddVectorEq})))(tls, **(**uintptr)(__ccgo_up(bp + 8)), pout, **(**int32)(__ccgo_up(bp)))
 				} else {
 					libc.X__builtin___memcpy_chk(tls, pout, **(**uintptr)(__ccgo_up(bp + 8)), libc.Uint64FromInt32(**(**int32)(__ccgo_up(bp)))*uint64(4), ^__predefined_size_t(0))
 				}
 			}
 		} else {
 			if **(**uint8_t)(__ccgo_up(h1 + 3304 + uintptr(i))) != 0 {
 				if **(**uint8_t)(__ccgo_up(h2 + 3304 + uintptr(i))) != 0 {
 					(*(*func(*libc.TLS, uintptr, uintptr, uintptr, int32))(unsafe.Pointer(&struct{ uintptr }{VP8LAddVector})))(tls, **(**uintptr)(__ccgo_up(bp + 8)), **(**uintptr)(__ccgo_up(bp + 16)), pout, **(**int32)(__ccgo_up(bp)))
 				} else {
 					libc.X__builtin___memcpy_chk(tls, pout, **(**uintptr)(__ccgo_up(bp + 8)), libc.Uint64FromInt32(**(**int32)(__ccgo_up(bp)))*uint64(4), ^__predefined_size_t(0))
 				}
 			} else {
 				if **(**uint8_t)(__ccgo_up(h2 + 3304 + uintptr(i))) != 0 {
 					libc.X__builtin___memcpy_chk(tls, pout, **(**uintptr)(__ccgo_up(bp + 16)), libc.Uint64FromInt32(**(**int32)(__ccgo_up(bp)))*uint64(4), ^__predefined_size_t(0))
 				} else {
 					libc.X__builtin___memset_chk(tls, pout, 0, libc.Uint64FromInt32(**(**int32)(__ccgo_up(bp)))*uint64(4), ^__predefined_size_t(0))
 				}
 			}
 		}
 		goto _1
 	_1:
 		;
 		i = i + 1
 	}
 	i = 0
 	for {
 		if !(i < int32(5)) {
 			break
 		}
 		if libc.Int32FromUint16(**(**uint16_t)(__ccgo_up(h1 + 3244 + uintptr(i)*2))) == libc.Int32FromUint16(**(**uint16_t)(__ccgo_up(h2 + 3244 + uintptr(i)*2))) {
 			v3 = libc.Int32FromUint16(**(**uint16_t)(__ccgo_up(h1 + 3244 + uintptr(i)*2)))
 		} else {
 			v3 = libc.Int32FromUint16(libc.Uint16FromInt32(libc.Int32FromInt32(0xffff)))
 		}
 		**(**uint16_t)(__ccgo_up(hout + 3244 + uintptr(i)*2)) = libc.Uint16FromInt32(v3)
 		**(**uint8_t)(__ccgo_up(hout + 3304 + uintptr(i))) = libc.BoolUint8(**(**uint8_t)(__ccgo_up(h1 + 3304 + uintptr(i))) != 0 || **(**uint8_t)(__ccgo_up(h2 + 3304 + uintptr(i))) != 0)
 		goto _2
 	_2:
 		;
 		i = i + 1
 	}
 }
 
 func UpdateHistogramCost(tls *libc.TLS, bit_cost uint64_t, costs uintptr, h uintptr) {
 	var i int32
 	_ = i
 	(*VP8LHistogram)(unsafe.Pointer(h)).Fbit_cost = bit_cost
 	i = 0
 	for {
 		if !(i < int32(5)) {
 			break
 		}
 		**(**uint64_t)(__ccgo_up(h + 3264 + uintptr(i)*8)) = **(**uint64_t)(__ccgo_up(costs + uintptr(i)*8))
 		goto _1
 	_1:
 		;
 		i = i + 1
 	}
 }
 
 // C documentation
 //
 //	// Performs out = a + b, computing the cost C(a+b) - C(a) - C(b) while comparing
 //	// to the threshold value 'cost_threshold'. The score returned is
 //	//  Score = C(a+b) - C(a) - C(b), where C(a) + C(b) is known and fixed.
 //	// Since the previous score passed is 'cost_threshold', we only need to compare
 //	// the partial cost against 'cost_threshold + C(a) + C(b)' to possibly bail-out
 //	// early.
 //	// Returns 1 if the cost is less than the threshold.
 //	// Otherwise returns 0 and the cost is invalid due to early bail-out.
 func HistogramAddEval(tls *libc.TLS, a uintptr, b uintptr, out uintptr, _cost_threshold int64_t) (r int32) {
 	bp := tls.Alloc(64)
 	defer tls.Free(64)
 	*(*int64_t)(unsafe.Pointer(bp)) = _cost_threshold
 	var sum_cost uint64_t
 	var _ /* bit_cost at bp+8 */ uint64_t
 	var _ /* costs at bp+16 */ [5]uint64_t
 	_ = sum_cost
 	sum_cost = (*VP8LHistogram)(unsafe.Pointer(a)).Fbit_cost + (*VP8LHistogram)(unsafe.Pointer(b)).Fbit_cost
 	SaturateAdd(tls, sum_cost, bp)
 	if !(GetCombinedHistogramEntropy(tls, a, b, **(**int64_t)(__ccgo_up(bp)), bp+8, bp+16) != 0) {
 		return 0
 	}
 	HistogramAdd(tls, a, b, out)
 	UpdateHistogramCost(tls, **(**uint64_t)(__ccgo_up(bp + 8)), bp+16, out)
 	return int32(1)
 }
 
 // C documentation
 //
 //	// Same as HistogramAddEval(), except that the resulting histogram
 //	// is not stored. Only the cost C(a+b) - C(a) is evaluated. We omit
 //	// the term C(b) which is constant over all the evaluations.
 //	// Returns 1 if the cost is less than the threshold.
 //	// Otherwise returns 0 and the cost is invalid due to early bail-out.
 func HistogramAddThresh(tls *libc.TLS, a uintptr, b uintptr, _cost_threshold int64_t, cost_out uintptr) (r int32) {
 	bp := tls.Alloc(64)
 	defer tls.Free(64)
 	*(*int64_t)(unsafe.Pointer(bp)) = _cost_threshold
 	var _ /* cost at bp+8 */ uint64_t
 	var _ /* costs at bp+16 */ [5]uint64_t
 	SaturateAdd(tls, (*VP8LHistogram)(unsafe.Pointer(a)).Fbit_cost, bp)
 	if !(GetCombinedHistogramEntropy(tls, a, b, **(**int64_t)(__ccgo_up(bp)), bp+8, bp+16) != 0) {
 		return 0
 	}
 	**(**int64_t)(__ccgo_up(cost_out)) = libc.Int64FromUint64(**(**uint64_t)(__ccgo_up(bp + 8))) - libc.Int64FromUint64((*VP8LHistogram)(unsafe.Pointer(a)).Fbit_cost)
 	return int32(1)
 }
 
 // -----------------------------------------------------------------------------
 
 // C documentation
 //
 //	// The structure to keep track of cost range for the three dominant entropy
 //	// symbols.
 type DominantCostRange = struct {
 	Fliteral_max uint64_t
 	Fliteral_min uint64_t
 	Fred_max     uint64_t
 	Fred_min     uint64_t
 	Fblue_max    uint64_t
 	Fblue_min    uint64_t
 }
 
 func DominantCostRangeInit(tls *libc.TLS, c uintptr) {
 	(*DominantCostRange)(unsafe.Pointer(c)).Fliteral_max = uint64(0)
 	(*DominantCostRange)(unsafe.Pointer(c)).Fliteral_min = ^libc.Uint64FromUint64(0)
 	(*DominantCostRange)(unsafe.Pointer(c)).Fred_max = uint64(0)
 	(*DominantCostRange)(unsafe.Pointer(c)).Fred_min = ^libc.Uint64FromUint64(0)
 	(*DominantCostRange)(unsafe.Pointer(c)).Fblue_max = uint64(0)
 	(*DominantCostRange)(unsafe.Pointer(c)).Fblue_min = ^libc.Uint64FromUint64(0)
 }
 
 func UpdateDominantCostRange(tls *libc.TLS, h uintptr, c uintptr) {
 	if (*DominantCostRange)(unsafe.Pointer(c)).Fliteral_max < **(**uint64_t)(__ccgo_up(h + 3264 + uintptr(LITERAL)*8)) {
 		(*DominantCostRange)(unsafe.Pointer(c)).Fliteral_max = **(**uint64_t)(__ccgo_up(h + 3264 + uintptr(LITERAL)*8))
 	}
 	if (*DominantCostRange)(unsafe.Pointer(c)).Fliteral_min > **(**uint64_t)(__ccgo_up(h + 3264 + uintptr(LITERAL)*8)) {
 		(*DominantCostRange)(unsafe.Pointer(c)).Fliteral_min = **(**uint64_t)(__ccgo_up(h + 3264 + uintptr(LITERAL)*8))
 	}
 	if (*DominantCostRange)(unsafe.Pointer(c)).Fred_max < **(**uint64_t)(__ccgo_up(h + 3264 + uintptr(RED)*8)) {
 		(*DominantCostRange)(unsafe.Pointer(c)).Fred_max = **(**uint64_t)(__ccgo_up(h + 3264 + uintptr(RED)*8))
 	}
 	if (*DominantCostRange)(unsafe.Pointer(c)).Fred_min > **(**uint64_t)(__ccgo_up(h + 3264 + uintptr(RED)*8)) {
 		(*DominantCostRange)(unsafe.Pointer(c)).Fred_min = **(**uint64_t)(__ccgo_up(h + 3264 + uintptr(RED)*8))
 	}
 	if (*DominantCostRange)(unsafe.Pointer(c)).Fblue_max < **(**uint64_t)(__ccgo_up(h + 3264 + uintptr(BLUE)*8)) {
 		(*DominantCostRange)(unsafe.Pointer(c)).Fblue_max = **(**uint64_t)(__ccgo_up(h + 3264 + uintptr(BLUE)*8))
 	}
 	if (*DominantCostRange)(unsafe.Pointer(c)).Fblue_min > **(**uint64_t)(__ccgo_up(h + 3264 + uintptr(BLUE)*8)) {
 		(*DominantCostRange)(unsafe.Pointer(c)).Fblue_min = **(**uint64_t)(__ccgo_up(h + 3264 + uintptr(BLUE)*8))
 	}
 }
 
 func ComputeHistogramCost(tls *libc.TLS, h uintptr) {
 	bp := tls.Alloc(16)
 	defer tls.Free(16)
 	var i int32
 	var _ /* length at bp+8 */ int32
 	var _ /* population at bp+0 */ uintptr
 	_ = i
 	// No need to add the extra cost for length and distance as it is a constant
 	// that does not influence the histograms.
 	i = 0
 	for {
 		if !(i < int32(5)) {
 			break
 		}
 		GetPopulationInfo(tls, h, i, bp, bp+8)
 		**(**uint64_t)(__ccgo_up(h + 3264 + uintptr(i)*8)) = PopulationCost(tls, **(**uintptr)(__ccgo_up(bp)), **(**int32)(__ccgo_up(bp + 8)), h+3244+uintptr(i)*2, h+3304+uintptr(i))
 		goto _1
 	_1:
 		;
 		i = i + 1
 	}
 	(*VP8LHistogram)(unsafe.Pointer(h)).Fbit_cost = **(**uint64_t)(__ccgo_up(h + 3264 + uintptr(LITERAL)*8)) + **(**uint64_t)(__ccgo_up(h + 3264 + uintptr(RED)*8)) + **(**uint64_t)(__ccgo_up(h + 3264 + uintptr(BLUE)*8)) + **(**uint64_t)(__ccgo_up(h + 3264 + uintptr(ALPHA)*8)) + **(**uint64_t)(__ccgo_up(h + 3264 + uintptr(DISTANCE)*8))
 }
 
 func GetBinIdForEntropy(tls *libc.TLS, min uint64_t, max uint64_t, val uint64_t) (r int32) {
 	var delta, range1 uint64_t
 	_, _ = delta, range1
 	range1 = max - min
 	if range1 > uint64(0) {
 		delta = val - min
 		return int32(float64((libc.Float64FromInt32(NUM_PARTITIONS)-libc.Float64FromFloat64(1e-06))*float64(delta)) / float64(range1))
 	} else {
 		return 0
 	}
 	return r
 }
 
 func GetHistoBinIndex(tls *libc.TLS, h uintptr, c uintptr, low_effort int32) (r int32) {
 	var bin_id int32
 	_ = bin_id
 	bin_id = GetBinIdForEntropy(tls, (*DominantCostRange)(unsafe.Pointer(c)).Fliteral_min, (*DominantCostRange)(unsafe.Pointer(c)).Fliteral_max, **(**uint64_t)(__ccgo_up(h + 3264 + uintptr(LITERAL)*8)))
 	if !(low_effort != 0) {
 		bin_id = bin_id*int32(NUM_PARTITIONS) + GetBinIdForEntropy(tls, (*DominantCostRange)(unsafe.Pointer(c)).Fred_min, (*DominantCostRange)(unsafe.Pointer(c)).Fred_max, **(**uint64_t)(__ccgo_up(h + 3264 + uintptr(RED)*8)))
 		bin_id = bin_id*int32(NUM_PARTITIONS) + GetBinIdForEntropy(tls, (*DominantCostRange)(unsafe.Pointer(c)).Fblue_min, (*DominantCostRange)(unsafe.Pointer(c)).Fblue_max, **(**uint64_t)(__ccgo_up(h + 3264 + uintptr(BLUE)*8)))
 	}
 	return bin_id
 }
 
 // C documentation
 //
 //	// Construct the histograms from backward references.
 func HistogramBuild(tls *libc.TLS, xsize int32, histo_bits int32, backward_refs uintptr, image_histo uintptr) {
 	bp := tls.Alloc(32)
 	defer tls.Free(32)
 	var histo_xsize, ix, x, y, v4 int32
 	var histograms, v, v10, v8, v9 uintptr
 	var v1, v2 uint32_t
 	var _ /* c at bp+0 */ VP8LRefsCursor
 	_, _, _, _, _, _, _, _, _, _, _, _ = histo_xsize, histograms, ix, v, x, y, v1, v10, v2, v4, v8, v9
 	x = 0
 	y = 0
 	v1 = libc.Uint32FromInt32(histo_bits)
 	v2 = (libc.Uint32FromInt32(xsize) + libc.Uint32FromInt32(libc.Int32FromInt32(1)<<v1) - uint32(1)) >> v1
 	goto _3
 _3:
 	histo_xsize = libc.Int32FromUint32(v2)
 	histograms = (*VP8LHistogramSet)(unsafe.Pointer(image_histo)).Fhistograms
 	**(**VP8LRefsCursor)(__ccgo_up(bp)) = VP8LRefsCursorInit(tls, backward_refs)
 	VP8LHistogramSetClear(tls, image_histo)
 	for {
 		v4 = libc.BoolInt32((*VP8LRefsCursor)(unsafe.Pointer(bp)).Fcur_pos != libc.UintptrFromInt32(0))
 		goto _5
 	_5:
 		if !(v4 != 0) {
 			break
 		}
 		v = (**(**VP8LRefsCursor)(__ccgo_up(bp))).Fcur_pos
 		ix = y>>histo_bits*histo_xsize + x>>histo_bits
 		HistogramAddSinglePixOrCopy(tls, **(**uintptr)(__ccgo_up(histograms + uintptr(ix)*8)), v, libc.UintptrFromInt32(0), 0)
 		v1 = uint32((*PixOrCopy)(unsafe.Pointer(v)).Flen1)
 		goto _7
 	_7:
 		x = libc.Int32FromUint32(uint32(x) + v1)
 		for x >= xsize {
 			x = x - xsize
 			y = y + 1
 		}
 		v8 = bp
 		v10 = v8
 		*(*uintptr)(unsafe.Pointer(v10)) += 8
 		v9 = *(*uintptr)(unsafe.Pointer(v10))
 		if v9 == (*VP8LRefsCursor)(unsafe.Pointer(v8)).Flast_pos {
 			VP8LRefsCursorNextBlock(tls, v8)
 		}
 	}
 }
 
 // C documentation
 //
 //	// Copies the histograms and computes its bit_cost.
 func HistogramCopyAndAnalyze(tls *libc.TLS, orig_histo uintptr, image_histo uintptr) {
 	var histo, histograms, orig_histograms uintptr
 	var i int32
 	_, _, _, _ = histo, histograms, i, orig_histograms
 	orig_histograms = (*VP8LHistogramSet)(unsafe.Pointer(orig_histo)).Fhistograms
 	histograms = (*VP8LHistogramSet)(unsafe.Pointer(image_histo)).Fhistograms
 	(*VP8LHistogramSet)(unsafe.Pointer(image_histo)).Fsize = 0
 	i = 0
 	for {
 		if !(i < (*VP8LHistogramSet)(unsafe.Pointer(orig_histo)).Fmax_size) {
 			break
 		}
 		histo = **(**uintptr)(__ccgo_up(orig_histograms + uintptr(i)*8))
 		ComputeHistogramCost(tls, histo)
 		// Skip the histogram if it is completely empty, which can happen for tiles
 		// with no information (when they are skipped because of LZ77).
 		if !(**(**uint8_t)(__ccgo_up(histo + 3304 + uintptr(LITERAL))) != 0) && !(**(**uint8_t)(__ccgo_up(histo + 3304 + uintptr(RED))) != 0) && !(**(**uint8_t)(__ccgo_up(histo + 3304 + uintptr(BLUE))) != 0) && !(**(**uint8_t)(__ccgo_up(histo + 3304 + uintptr(ALPHA))) != 0) && !(**(**uint8_t)(__ccgo_up(histo + 3304 + uintptr(DISTANCE))) != 0) {
 			// The first histogram is always used.
 			**(**uintptr)(__ccgo_up(orig_histograms + uintptr(i)*8)) = libc.UintptrFromInt32(0)
 		} else {
 			// Copy histograms from orig_histo[] to image_histo[].
 			HistogramCopy(tls, histo, **(**uintptr)(__ccgo_up(histograms + uintptr((*VP8LHistogramSet)(unsafe.Pointer(image_histo)).Fsize)*8)))
 			(*VP8LHistogramSet)(unsafe.Pointer(image_histo)).Fsize = (*VP8LHistogramSet)(unsafe.Pointer(image_histo)).Fsize + 1
 		}
 		goto _1
 	_1:
 		;
 		i = i + 1
 	}
 }
 
 // C documentation
 //
 //	// Partition histograms to different entropy bins for three dominant (literal,
 //	// red and blue) symbol costs and compute the histogram aggregate bit_cost.
 func HistogramAnalyzeEntropyBin(tls *libc.TLS, image_histo uintptr, low_effort int32) {
 	bp := tls.Alloc(48)
 	defer tls.Free(48)
 	var histo_size, i int32
 	var histograms uintptr
 	var _ /* cost_range at bp+0 */ DominantCostRange
 	_, _, _ = histo_size, histograms, i
 	histograms = (*VP8LHistogramSet)(unsafe.Pointer(image_histo)).Fhistograms
 	histo_size = (*VP8LHistogramSet)(unsafe.Pointer(image_histo)).Fsize
 	DominantCostRangeInit(tls, bp)
 	// Analyze the dominant (literal, red and blue) entropy costs.
 	i = 0
 	for {
 		if !(i < histo_size) {
 			break
 		}
 		UpdateDominantCostRange(tls, **(**uintptr)(__ccgo_up(histograms + uintptr(i)*8)), bp)
 		goto _1
 	_1:
 		;
 		i = i + 1
 	}
 	// bin-hash histograms on three of the dominant (literal, red and blue)
 	// symbol costs and store the resulting bin_id for each histogram.
 	i = 0
 	for {
 		if !(i < histo_size) {
 			break
 		}
 		(*VP8LHistogram)(unsafe.Pointer(**(**uintptr)(__ccgo_up(histograms + uintptr(i)*8)))).Fbin_id = libc.Uint16FromInt32(GetHistoBinIndex(tls, **(**uintptr)(__ccgo_up(histograms + uintptr(i)*8)), bp, low_effort))
 		goto _2
 	_2:
 		;
 		i = i + 1
 	}
 }
 
 // C documentation
 //
 //	// Merges some histograms with same bin_id together if it's advantageous.
 //	// Sets the remaining histograms to NULL.
 //	// 'combine_cost_factor' has to be divided by 100.
 func HistogramCombineEntropyBin(tls *libc.TLS, image_histo uintptr, _cur_combo uintptr, num_bins int32, combine_cost_factor int32_t, low_effort int32) {
 	bp := tls.Alloc(16)
 	defer tls.Free(16)
 	*(*uintptr)(unsafe.Pointer(bp)) = _cur_combo
 	var bin_id, first, idx, max_combine_failures, try_combine int32
 	var bin_info [64]struct {
 		Ffirst                int16_t
 		Fnum_combine_failures uint16_t
 	}
 	var bit_cost uint64_t
 	var bit_cost_thresh, v3, v4, v5 int64_t
 	var histograms uintptr
 	var v7 int64
 	_, _, _, _, _, _, _, _, _, _, _, _, _ = bin_id, bin_info, bit_cost, bit_cost_thresh, first, histograms, idx, max_combine_failures, try_combine, v3, v4, v5, v7
 	histograms = (*VP8LHistogramSet)(unsafe.Pointer(image_histo)).Fhistograms
 	idx = 0
 	for {
 		if !(idx < num_bins) {
 			break
 		}
 		bin_info[idx].Ffirst = int16(-int32(1))
 		bin_info[idx].Fnum_combine_failures = uint16(0)
 		goto _1
 	_1:
 		;
 		idx = idx + 1
 	}
 	idx = 0
 	for {
 		if !(idx < (*VP8LHistogramSet)(unsafe.Pointer(image_histo)).Fsize) {
 			break
 		}
 		bin_id = libc.Int32FromUint16((*VP8LHistogram)(unsafe.Pointer(**(**uintptr)(__ccgo_up(histograms + uintptr(idx)*8)))).Fbin_id)
 		first = int32(bin_info[bin_id].Ffirst)
 		if first == -int32(1) {
 			bin_info[bin_id].Ffirst = int16(idx)
 			idx = idx + 1
 		} else {
 			if low_effort != 0 {
 				HistogramAdd(tls, **(**uintptr)(__ccgo_up(histograms + uintptr(idx)*8)), **(**uintptr)(__ccgo_up(histograms + uintptr(first)*8)), **(**uintptr)(__ccgo_up(histograms + uintptr(first)*8)))
 				HistogramSetRemoveHistogram(tls, image_histo, idx)
 			} else {
 				// try to merge #idx into #first (both share the same bin_id)
 				bit_cost = (*VP8LHistogram)(unsafe.Pointer(**(**uintptr)(__ccgo_up(histograms + uintptr(idx)*8)))).Fbit_cost
 				v3 = libc.Int64FromUint64(bit_cost) * int64(combine_cost_factor)
 				v4 = int64(100)
 				if libc.BoolInt32(v3 < 0) == libc.BoolInt32(v4 < 0) {
 					v7 = (v3 + v4/int64(2)) / v4
 				} else {
 					v7 = (v3 - v4/int64(2)) / v4
 				}
 				v5 = v7
 				goto _6
 			_6:
 				bit_cost_thresh = -v5
 				if HistogramAddEval(tls, **(**uintptr)(__ccgo_up(histograms + uintptr(first)*8)), **(**uintptr)(__ccgo_up(histograms + uintptr(idx)*8)), **(**uintptr)(__ccgo_up(bp)), bit_cost_thresh) != 0 {
 					max_combine_failures = int32(32)
 					// Try to merge two histograms only if the combo is a trivial one or
 					// the two candidate histograms are already non-trivial.
 					// For some images, 'try_combine' turns out to be false for a lot of
 					// histogram pairs. In that case, we fallback to combining
 					// histograms as usual to avoid increasing the header size.
 					try_combine = libc.BoolInt32(libc.Int32FromUint16(**(**uint16_t)(__ccgo_up(**(**uintptr)(__ccgo_up(bp)) + 3244 + uintptr(RED)*2))) != libc.Int32FromUint16(libc.Uint16FromInt32(libc.Int32FromInt32(0xffff))) && libc.Int32FromUint16(**(**uint16_t)(__ccgo_up(**(**uintptr)(__ccgo_up(bp)) + 3244 + uintptr(BLUE)*2))) != libc.Int32FromUint16(libc.Uint16FromInt32(libc.Int32FromInt32(0xffff))) && libc.Int32FromUint16(**(**uint16_t)(__ccgo_up(**(**uintptr)(__ccgo_up(bp)) + 3244 + uintptr(ALPHA)*2))) != libc.Int32FromUint16(libc.Uint16FromInt32(libc.Int32FromInt32(0xffff))))
 					if !(try_combine != 0) {
 						try_combine = libc.BoolInt32(libc.Int32FromUint16(**(**uint16_t)(__ccgo_up(**(**uintptr)(__ccgo_up(histograms + uintptr(idx)*8)) + 3244 + uintptr(RED)*2))) == libc.Int32FromUint16(libc.Uint16FromInt32(libc.Int32FromInt32(0xffff))) || libc.Int32FromUint16(**(**uint16_t)(__ccgo_up(**(**uintptr)(__ccgo_up(histograms + uintptr(idx)*8)) + 3244 + uintptr(BLUE)*2))) == libc.Int32FromUint16(libc.Uint16FromInt32(libc.Int32FromInt32(0xffff))) || libc.Int32FromUint16(**(**uint16_t)(__ccgo_up(**(**uintptr)(__ccgo_up(histograms + uintptr(idx)*8)) + 3244 + uintptr(ALPHA)*2))) == libc.Int32FromUint16(libc.Uint16FromInt32(libc.Int32FromInt32(0xffff))))
 						try_combine = try_combine & libc.BoolInt32(libc.Int32FromUint16(**(**uint16_t)(__ccgo_up(**(**uintptr)(__ccgo_up(histograms + uintptr(first)*8)) + 3244 + uintptr(RED)*2))) == libc.Int32FromUint16(libc.Uint16FromInt32(libc.Int32FromInt32(0xffff))) || libc.Int32FromUint16(**(**uint16_t)(__ccgo_up(**(**uintptr)(__ccgo_up(histograms + uintptr(first)*8)) + 3244 + uintptr(BLUE)*2))) == libc.Int32FromUint16(libc.Uint16FromInt32(libc.Int32FromInt32(0xffff))) || libc.Int32FromUint16(**(**uint16_t)(__ccgo_up(**(**uintptr)(__ccgo_up(histograms + uintptr(first)*8)) + 3244 + uintptr(ALPHA)*2))) == libc.Int32FromUint16(libc.Uint16FromInt32(libc.Int32FromInt32(0xffff))))
 					}
 					if try_combine != 0 || libc.Int32FromUint16(bin_info[bin_id].Fnum_combine_failures) >= max_combine_failures {
 						// move the (better) merged histogram to its final slot
 						HistogramSwap(tls, bp, histograms+uintptr(first)*8)
 						HistogramSetRemoveHistogram(tls, image_histo, idx)
 					} else {
 						bin_info[bin_id].Fnum_combine_failures = bin_info[bin_id].Fnum_combine_failures + 1
 						idx = idx + 1
 					}
 				} else {
 					idx = idx + 1
 				}
 			}
 		}
 		goto _2
 	_2:
 	}
 	if low_effort != 0 {
 		// for low_effort case, update the final cost when everything is merged
 		idx = 0
 		for {
 			if !(idx < (*VP8LHistogramSet)(unsafe.Pointer(image_histo)).Fsize) {
 				break
 			}
 			ComputeHistogramCost(tls, **(**uintptr)(__ccgo_up(histograms + uintptr(idx)*8)))
 			goto _8
 		_8:
 			;
 			idx = idx + 1
 		}
 	}
 }
 
 // C documentation
 //
 //	// Implement a Lehmer random number generator with a multiplicative constant of
 //	// 48271 and a modulo constant of 2^31 - 1.
 func MyRand(tls *libc.TLS, seed uintptr) (r uint32_t) {
 	**(**uint32_t)(__ccgo_up(seed)) = uint32(uint64(**(**uint32_t)(__ccgo_up(seed))) * libc.Uint64FromUint32(48271) % libc.Uint64FromUint32(2147483647))
 	return **(**uint32_t)(__ccgo_up(seed))
 }
 
 // -----------------------------------------------------------------------------
 // Histogram pairs priority queue
 
 // C documentation
 //
 //	// Pair of histograms. Negative idx1 value means that pair is out-of-date.
 type HistogramPair = struct {
 	Fidx1       int32
 	Fidx2       int32
 	Fcost_diff  int64_t
 	Fcost_combo uint64_t
 	Fcosts      [5]uint64_t
 }
 
 type HistoQueue = struct {
 	Fqueue    uintptr
 	Fsize     int32
 	Fmax_size int32
 }
 
 func HistoQueueInit(tls *libc.TLS, histo_queue uintptr, max_size int32) (r int32) {
 	(*HistoQueue)(unsafe.Pointer(histo_queue)).Fsize = 0
 	(*HistoQueue)(unsafe.Pointer(histo_queue)).Fmax_size = max_size
 	// We allocate max_size + 1 because the last element at index "size" is
 	// used as temporary data (and it could be up to max_size).
 	(*HistoQueue)(unsafe.Pointer(histo_queue)).Fqueue = WebPSafeMalloc(tls, libc.Uint64FromInt32((*HistoQueue)(unsafe.Pointer(histo_queue)).Fmax_size+int32(1)), uint64(64))
 	return libc.BoolInt32((*HistoQueue)(unsafe.Pointer(histo_queue)).Fqueue != libc.UintptrFromInt32(0))
 }
 
 func HistoQueueClear(tls *libc.TLS, histo_queue uintptr) {
 	WebPSafeFree(tls, (*HistoQueue)(unsafe.Pointer(histo_queue)).Fqueue)
 	(*HistoQueue)(unsafe.Pointer(histo_queue)).Fsize = 0
 	(*HistoQueue)(unsafe.Pointer(histo_queue)).Fmax_size = 0
 }
 
 // C documentation
 //
 //	// Pop a specific pair in the queue by replacing it with the last one
 //	// and shrinking the queue.
 func HistoQueuePopPair(tls *libc.TLS, histo_queue uintptr, pair uintptr) {
 	**(**HistogramPair)(__ccgo_up(pair)) = **(**HistogramPair)(__ccgo_up((*HistoQueue)(unsafe.Pointer(histo_queue)).Fqueue + uintptr((*HistoQueue)(unsafe.Pointer(histo_queue)).Fsize-int32(1))*64))
 	(*HistoQueue)(unsafe.Pointer(histo_queue)).Fsize = (*HistoQueue)(unsafe.Pointer(histo_queue)).Fsize - 1
 }
 
 // C documentation
 //
 //	// Check whether a pair in the queue should be updated as head or not.
 func HistoQueueUpdateHead(tls *libc.TLS, histo_queue uintptr, pair uintptr) {
 	var tmp HistogramPair
 	_ = tmp
 	if (*HistogramPair)(unsafe.Pointer(pair)).Fcost_diff < (**(**HistogramPair)(__ccgo_up((*HistoQueue)(unsafe.Pointer(histo_queue)).Fqueue))).Fcost_diff {
 		// Replace the best pair.
 		tmp = **(**HistogramPair)(__ccgo_up((*HistoQueue)(unsafe.Pointer(histo_queue)).Fqueue))
 		**(**HistogramPair)(__ccgo_up((*HistoQueue)(unsafe.Pointer(histo_queue)).Fqueue)) = **(**HistogramPair)(__ccgo_up(pair))
 		**(**HistogramPair)(__ccgo_up(pair)) = tmp
 	}
 }
 
 // C documentation
 //
 //	// Replaces the bad_id with good_id in the pair.
 func HistoQueueFixPair(tls *libc.TLS, bad_id int32, good_id int32, pair uintptr) {
 	var tmp int32
 	_ = tmp
 	if (*HistogramPair)(unsafe.Pointer(pair)).Fidx1 == bad_id {
 		(*HistogramPair)(unsafe.Pointer(pair)).Fidx1 = good_id
 	}
 	if (*HistogramPair)(unsafe.Pointer(pair)).Fidx2 == bad_id {
 		(*HistogramPair)(unsafe.Pointer(pair)).Fidx2 = good_id
 	}
 	if (*HistogramPair)(unsafe.Pointer(pair)).Fidx1 > (*HistogramPair)(unsafe.Pointer(pair)).Fidx2 {
 		tmp = (*HistogramPair)(unsafe.Pointer(pair)).Fidx1
 		(*HistogramPair)(unsafe.Pointer(pair)).Fidx1 = (*HistogramPair)(unsafe.Pointer(pair)).Fidx2
 		(*HistogramPair)(unsafe.Pointer(pair)).Fidx2 = tmp
 	}
 }
 
 // C documentation
 //
 //	// Update the cost diff and combo of a pair of histograms. This needs to be
 //	// called when the histograms have been merged with a third one.
 //	// Returns 1 if the cost diff is less than the threshold.
 //	// Otherwise returns 0 and the cost is invalid due to early bail-out.
 func HistoQueueUpdatePair(tls *libc.TLS, h1 uintptr, h2 uintptr, _cost_threshold int64_t, pair uintptr) (r int32) {
 	bp := tls.Alloc(16)
 	defer tls.Free(16)
 	*(*int64_t)(unsafe.Pointer(bp)) = _cost_threshold
 	var sum_cost int64_t
 	_ = sum_cost
 	sum_cost = libc.Int64FromUint64((*VP8LHistogram)(unsafe.Pointer(h1)).Fbit_cost + (*VP8LHistogram)(unsafe.Pointer(h2)).Fbit_cost)
 	SaturateAdd(tls, libc.Uint64FromInt64(sum_cost), bp)
 	if !(GetCombinedHistogramEntropy(tls, h1, h2, **(**int64_t)(__ccgo_up(bp)), pair+16, pair+24) != 0) {
 		return 0
 	}
 	(*HistogramPair)(unsafe.Pointer(pair)).Fcost_diff = libc.Int64FromUint64((*HistogramPair)(unsafe.Pointer(pair)).Fcost_combo) - sum_cost
 	return int32(1)
 }
 
 // C documentation
 //
 //	// Create a pair from indices "idx1" and "idx2" provided its cost
 //	// is inferior to "threshold", a negative entropy.
 //	// It returns the cost of the pair, or 0 if it superior to threshold.
 func HistoQueuePush(tls *libc.TLS, histo_queue uintptr, histograms uintptr, idx1 int32, idx2 int32, threshold int64_t) (r int64_t) {
 	bp := tls.Alloc(64)
 	defer tls.Free(64)
 	var h1, h2, v2 uintptr
 	var tmp, v1 int32
 	var _ /* pair at bp+0 */ HistogramPair
 	_, _, _, _, _ = h1, h2, tmp, v1, v2
 	// Stop here if the queue is full.
 	if (*HistoQueue)(unsafe.Pointer(histo_queue)).Fsize == (*HistoQueue)(unsafe.Pointer(histo_queue)).Fmax_size {
 		return 0
 	}
 	if idx1 > idx2 {
 		tmp = idx2
 		idx2 = idx1
 		idx1 = tmp
 	}
 	(**(**HistogramPair)(__ccgo_up(bp))).Fidx1 = idx1
 	(**(**HistogramPair)(__ccgo_up(bp))).Fidx2 = idx2
 	h1 = **(**uintptr)(__ccgo_up(histograms + uintptr(idx1)*8))
 	h2 = **(**uintptr)(__ccgo_up(histograms + uintptr(idx2)*8))
 	// Do not even consider the pair if it does not improve the entropy.
 	if !(HistoQueueUpdatePair(tls, h1, h2, threshold, bp) != 0) {
 		return 0
 	}
 	v2 = histo_queue + 8
 	v1 = *(*int32)(unsafe.Pointer(v2))
 	*(*int32)(unsafe.Pointer(v2)) = *(*int32)(unsafe.Pointer(v2)) + 1
 	**(**HistogramPair)(__ccgo_up((*HistoQueue)(unsafe.Pointer(histo_queue)).Fqueue + uintptr(v1)*64)) = **(**HistogramPair)(__ccgo_up(bp))
 	HistoQueueUpdateHead(tls, histo_queue, (*HistoQueue)(unsafe.Pointer(histo_queue)).Fqueue+uintptr((*HistoQueue)(unsafe.Pointer(histo_queue)).Fsize-int32(1))*64)
 	return (**(**HistogramPair)(__ccgo_up(bp))).Fcost_diff
 }
 
 // -----------------------------------------------------------------------------
 
 // C documentation
 //
 //	// Combines histograms by continuously choosing the one with the highest cost
 //	// reduction.
 func HistogramCombineGreedy(tls *libc.TLS, image_histo uintptr) (r int32) {
 	bp := tls.Alloc(16)
 	defer tls.Free(16)
 	var histograms, p uintptr
 	var i, idx1, idx2, image_histo_size, j, ok int32
 	var _ /* histo_queue at bp+0 */ HistoQueue
 	_, _, _, _, _, _, _, _ = histograms, i, idx1, idx2, image_histo_size, j, ok, p
 	ok = 0
 	image_histo_size = (*VP8LHistogramSet)(unsafe.Pointer(image_histo)).Fsize
 	histograms = (*VP8LHistogramSet)(unsafe.Pointer(image_histo)).Fhistograms
 	// image_histo_size^2 for the queue size is safe. If you look at
 	// HistogramCombineGreedy, and imagine that UpdateQueueFront always pushes
 	// data to the queue, you insert at most:
 	// - image_histo_size*(image_histo_size-1)/2 (the first two for loops)
 	// - image_histo_size - 1 in the last for loop at the first iteration of
 	//   the while loop, image_histo_size - 2 at the second iteration ...
 	//   therefore image_histo_size*(image_histo_size-1)/2 overall too
 	if !(HistoQueueInit(tls, bp, image_histo_size*image_histo_size) != 0) {
 		goto End
 	}
 	// Initialize the queue.
 	i = 0
 	for {
 		if !(i < image_histo_size) {
 			break
 		}
 		j = i + int32(1)
 		for {
 			if !(j < image_histo_size) {
 				break
 			}
 			HistoQueuePush(tls, bp, histograms, i, j, 0)
 			goto _2
 		_2:
 			;
 			j = j + 1
 		}
 		goto _1
 	_1:
 		;
 		i = i + 1
 	}
 	for (**(**HistoQueue)(__ccgo_up(bp))).Fsize > 0 {
 		idx1 = (**(**HistogramPair)(__ccgo_up((**(**HistoQueue)(__ccgo_up(bp))).Fqueue))).Fidx1
 		idx2 = (**(**HistogramPair)(__ccgo_up((**(**HistoQueue)(__ccgo_up(bp))).Fqueue))).Fidx2
 		HistogramAdd(tls, **(**uintptr)(__ccgo_up(histograms + uintptr(idx2)*8)), **(**uintptr)(__ccgo_up(histograms + uintptr(idx1)*8)), **(**uintptr)(__ccgo_up(histograms + uintptr(idx1)*8)))
 		UpdateHistogramCost(tls, (**(**HistogramPair)(__ccgo_up((**(**HistoQueue)(__ccgo_up(bp))).Fqueue))).Fcost_combo, (**(**HistoQueue)(__ccgo_up(bp))).Fqueue+24, **(**uintptr)(__ccgo_up(histograms + uintptr(idx1)*8)))
 		// Remove merged histogram.
 		HistogramSetRemoveHistogram(tls, image_histo, idx2)
 		// Remove pairs intersecting the just combined best pair.
 		i = 0
 		for {
 			if !(i < (**(**HistoQueue)(__ccgo_up(bp))).Fsize) {
 				break
 			}
 			p = (**(**HistoQueue)(__ccgo_up(bp))).Fqueue + uintptr(i)*64
 			if (*HistogramPair)(unsafe.Pointer(p)).Fidx1 == idx1 || (*HistogramPair)(unsafe.Pointer(p)).Fidx2 == idx1 || (*HistogramPair)(unsafe.Pointer(p)).Fidx1 == idx2 || (*HistogramPair)(unsafe.Pointer(p)).Fidx2 == idx2 {
 				HistoQueuePopPair(tls, bp, p)
 			} else {
 				HistoQueueFixPair(tls, (*VP8LHistogramSet)(unsafe.Pointer(image_histo)).Fsize, idx2, p)
 				HistoQueueUpdateHead(tls, bp, p)
 				i = i + 1
 			}
 			goto _3
 		_3:
 		}
 		// Push new pairs formed with combined histogram to the queue.
 		i = 0
 		for {
 			if !(i < (*VP8LHistogramSet)(unsafe.Pointer(image_histo)).Fsize) {
 				break
 			}
 			if i == idx1 {
 				goto _4
 			}
 			HistoQueuePush(tls, bp, (*VP8LHistogramSet)(unsafe.Pointer(image_histo)).Fhistograms, idx1, i, 0)
 			goto _4
 		_4:
 			;
 			i = i + 1
 		}
 	}
 	ok = int32(1)
 	goto End
 End:
 	;
 	HistoQueueClear(tls, bp)
 	return ok
 }
 
 // C documentation
 //
 //	// Perform histogram aggregation using a stochastic approach.
 //	// 'do_greedy' is set to 1 if a greedy approach needs to be performed
 //	// afterwards, 0 otherwise.
 func HistogramCombineStochastic(tls *libc.TLS, image_histo uintptr, min_cluster_size int32, do_greedy uintptr) (r int32) {
 	bp := tls.Alloc(32)
 	defer tls.Free(32)
 	var best_cost, curr_cost int64_t
 	var best_idx1, best_idx2, is_idx1_best, is_idx2_best, iter, j, kHistoQueueSize, num_tries, num_tries_no_success, ok, outer_iters, tries_with_no_success, v2 int32
 	var histograms, p uintptr
 	var idx1, idx2, rand_range, tmp uint32_t
 	var v3 bool
 	var v4 int64
 	var _ /* histo_queue at bp+8 */ HistoQueue
 	var _ /* seed at bp+0 */ uint32_t
 	_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = best_cost, best_idx1, best_idx2, curr_cost, histograms, idx1, idx2, is_idx1_best, is_idx2_best, iter, j, kHistoQueueSize, num_tries, num_tries_no_success, ok, outer_iters, p, rand_range, tmp, tries_with_no_success, v2, v3, v4
 	**(**uint32_t)(__ccgo_up(bp)) = uint32(1)
 	tries_with_no_success = 0
 	outer_iters = (*VP8LHistogramSet)(unsafe.Pointer(image_histo)).Fsize
 	num_tries_no_success = outer_iters / int32(2)
 	histograms = (*VP8LHistogramSet)(unsafe.Pointer(image_histo)).Fhistograms
 	kHistoQueueSize = int32(9)
 	ok = 0
 	if (*VP8LHistogramSet)(unsafe.Pointer(image_histo)).Fsize < min_cluster_size {
 		**(**int32)(__ccgo_up(do_greedy)) = int32(1)
 		return int32(1)
 	}
 	if !(HistoQueueInit(tls, bp+8, kHistoQueueSize) != 0) {
 		goto End
 	}
 	// Collapse similar histograms in 'image_histo'.
 	iter = 0
 	for {
 		if v3 = iter < outer_iters && (*VP8LHistogramSet)(unsafe.Pointer(image_histo)).Fsize >= min_cluster_size; v3 {
 			tries_with_no_success = tries_with_no_success + 1
 			v2 = tries_with_no_success
 		}
 		if !(v3 && v2 < num_tries_no_success) {
 			break
 		}
 		if (**(**HistoQueue)(__ccgo_up(bp + 8))).Fsize == 0 {
 			v4 = 0
 		} else {
 			v4 = (**(**HistogramPair)(__ccgo_up((**(**HistoQueue)(__ccgo_up(bp + 8))).Fqueue))).Fcost_diff
 		}
 		best_cost = v4
 		best_idx1 = -int32(1)
 		best_idx2 = int32(1)
 		rand_range = libc.Uint32FromInt32(((*VP8LHistogramSet)(unsafe.Pointer(image_histo)).Fsize - int32(1)) * (*VP8LHistogramSet)(unsafe.Pointer(image_histo)).Fsize)
 		// (image_histo->size) / 2 was chosen empirically. Less means faster but
 		// worse compression.
 		num_tries = (*VP8LHistogramSet)(unsafe.Pointer(image_histo)).Fsize / int32(2)
 		// Pick random samples.
 		j = 0
 		for {
 			if !((*VP8LHistogramSet)(unsafe.Pointer(image_histo)).Fsize >= int32(2) && j < num_tries) {
 				break
 			}
 			// Choose two different histograms at random and try to combine them.
 			tmp = MyRand(tls, bp) % rand_range
 			idx1 = tmp / libc.Uint32FromInt32((*VP8LHistogramSet)(unsafe.Pointer(image_histo)).Fsize-libc.Int32FromInt32(1))
 			idx2 = tmp % libc.Uint32FromInt32((*VP8LHistogramSet)(unsafe.Pointer(image_histo)).Fsize-libc.Int32FromInt32(1))
 			if idx2 >= idx1 {
 				idx2 = idx2 + 1
 			}
 			// Calculate cost reduction on combination.
 			curr_cost = HistoQueuePush(tls, bp+8, histograms, libc.Int32FromUint32(idx1), libc.Int32FromUint32(idx2), best_cost)
 			if curr_cost < 0 { // found a better pair?
 				best_cost = curr_cost
 				// Empty the queue if we reached full capacity.
 				if (**(**HistoQueue)(__ccgo_up(bp + 8))).Fsize == (**(**HistoQueue)(__ccgo_up(bp + 8))).Fmax_size {
 					break
 				}
 			}
 			goto _5
 		_5:
 			;
 			j = j + 1
 		}
 		if (**(**HistoQueue)(__ccgo_up(bp + 8))).Fsize == 0 {
 			goto _1
 		}
 		// Get the best histograms.
 		best_idx1 = (**(**HistogramPair)(__ccgo_up((**(**HistoQueue)(__ccgo_up(bp + 8))).Fqueue))).Fidx1
 		best_idx2 = (**(**HistogramPair)(__ccgo_up((**(**HistoQueue)(__ccgo_up(bp + 8))).Fqueue))).Fidx2
 		// Merge the histograms and remove best_idx2 from the queue.
 		HistogramAdd(tls, **(**uintptr)(__ccgo_up(histograms + uintptr(best_idx2)*8)), **(**uintptr)(__ccgo_up(histograms + uintptr(best_idx1)*8)), **(**uintptr)(__ccgo_up(histograms + uintptr(best_idx1)*8)))
 		UpdateHistogramCost(tls, (**(**HistogramPair)(__ccgo_up((**(**HistoQueue)(__ccgo_up(bp + 8))).Fqueue))).Fcost_combo, (**(**HistoQueue)(__ccgo_up(bp + 8))).Fqueue+24, **(**uintptr)(__ccgo_up(histograms + uintptr(best_idx1)*8)))
 		HistogramSetRemoveHistogram(tls, image_histo, best_idx2)
 		// Parse the queue and update each pair that deals with best_idx1,
 		// best_idx2 or image_histo_size.
 		j = 0
 		for {
 			if !(j < (**(**HistoQueue)(__ccgo_up(bp + 8))).Fsize) {
 				break
 			}
 			p = (**(**HistoQueue)(__ccgo_up(bp + 8))).Fqueue + uintptr(j)*64
 			is_idx1_best = libc.BoolInt32((*HistogramPair)(unsafe.Pointer(p)).Fidx1 == best_idx1 || (*HistogramPair)(unsafe.Pointer(p)).Fidx1 == best_idx2)
 			is_idx2_best = libc.BoolInt32((*HistogramPair)(unsafe.Pointer(p)).Fidx2 == best_idx1 || (*HistogramPair)(unsafe.Pointer(p)).Fidx2 == best_idx2)
 			// The front pair could have been duplicated by a random pick so
 			// check for it all the time nevertheless.
 			if is_idx1_best != 0 && is_idx2_best != 0 {
 				HistoQueuePopPair(tls, bp+8, p)
 				goto _6
 			}
 			// Any pair containing one of the two best indices should only refer to
 			// best_idx1. Its cost should also be updated.
 			if is_idx1_best != 0 || is_idx2_best != 0 {
 				HistoQueueFixPair(tls, best_idx2, best_idx1, p)
 				// Re-evaluate the cost of an updated pair.
 				if !(HistoQueueUpdatePair(tls, **(**uintptr)(__ccgo_up(histograms + uintptr((*HistogramPair)(unsafe.Pointer(p)).Fidx1)*8)), **(**uintptr)(__ccgo_up(histograms + uintptr((*HistogramPair)(unsafe.Pointer(p)).Fidx2)*8)), 0, p) != 0) {
 					HistoQueuePopPair(tls, bp+8, p)
 					goto _6
 				}
 			}
 			HistoQueueFixPair(tls, (*VP8LHistogramSet)(unsafe.Pointer(image_histo)).Fsize, best_idx2, p)
 			HistoQueueUpdateHead(tls, bp+8, p)
 			j = j + 1
 			goto _6
 		_6:
 		}
 		tries_with_no_success = 0
 		goto _1
 	_1:
 		;
 		iter = iter + 1
 	}
 	**(**int32)(__ccgo_up(do_greedy)) = libc.BoolInt32((*VP8LHistogramSet)(unsafe.Pointer(image_histo)).Fsize <= min_cluster_size)
 	ok = int32(1)
 	goto End
 End:
 	;
 	HistoQueueClear(tls, bp+8)
 	return ok
 }
 
 // -----------------------------------------------------------------------------
 // Histogram refinement
 
 // C documentation
 //
 //	// Find the best 'out' histogram for each of the 'in' histograms.
 //	// At call-time, 'out' contains the histograms of the clusters.
 //	// Note: we assume that out[]->bit_cost is already up-to-date.
 func HistogramRemap(tls *libc.TLS, in uintptr, out uintptr, symbols uintptr) {
 	bp := tls.Alloc(16)
 	defer tls.Free(16)
 	var best_bits int64_t
 	var best_out, i, idx, in_size, k, out_size int32
 	var in_histo, out_histo uintptr
 	var _ /* cur_bits at bp+0 */ int64_t
 	_, _, _, _, _, _, _, _, _ = best_bits, best_out, i, idx, in_histo, in_size, k, out_histo, out_size
 	in_histo = (*VP8LHistogramSet)(unsafe.Pointer(in)).Fhistograms
 	out_histo = (*VP8LHistogramSet)(unsafe.Pointer(out)).Fhistograms
 	in_size = (*VP8LHistogramSet)(unsafe.Pointer(out)).Fmax_size
 	out_size = (*VP8LHistogramSet)(unsafe.Pointer(out)).Fsize
 	if out_size > int32(1) {
 		i = 0
 		for {
 			if !(i < in_size) {
 				break
 			}
 			best_out = 0
 			best_bits = libc.Int64FromUint64(libc.Uint64FromUint64(1)<<libc.Int32FromInt32(63) - libc.Uint64FromInt32(1))
 			if **(**uintptr)(__ccgo_up(in_histo + uintptr(i)*8)) == libc.UintptrFromInt32(0) {
 				// Arbitrarily set to the previous value if unused to help future LZ77.
 				**(**uint32_t)(__ccgo_up(symbols + uintptr(i)*4)) = **(**uint32_t)(__ccgo_up(symbols + uintptr(i-int32(1))*4))
 				goto _1
 			}
 			k = 0
 			for {
 				if !(k < out_size) {
 					break
 				}
 				if HistogramAddThresh(tls, **(**uintptr)(__ccgo_up(out_histo + uintptr(k)*8)), **(**uintptr)(__ccgo_up(in_histo + uintptr(i)*8)), best_bits, bp) != 0 {
 					best_bits = **(**int64_t)(__ccgo_up(bp))
 					best_out = k
 				}
 				goto _2
 			_2:
 				;
 				k = k + 1
 			}
 			**(**uint32_t)(__ccgo_up(symbols + uintptr(i)*4)) = libc.Uint32FromInt32(best_out)
 			goto _1
 		_1:
 			;
 			i = i + 1
 		}
 	} else {
 		i = 0
 		for {
 			if !(i < in_size) {
 				break
 			}
 			**(**uint32_t)(__ccgo_up(symbols + uintptr(i)*4)) = uint32(0)
 			goto _3
 		_3:
 			;
 			i = i + 1
 		}
 	}
 	// Recompute each out based on raw and symbols.
 	VP8LHistogramSetClear(tls, out)
 	(*VP8LHistogramSet)(unsafe.Pointer(out)).Fsize = out_size
 	i = 0
 	for {
 		if !(i < in_size) {
 			break
 		}
 		if **(**uintptr)(__ccgo_up(in_histo + uintptr(i)*8)) == libc.UintptrFromInt32(0) {
 			goto _4
 		}
 		idx = libc.Int32FromUint32(**(**uint32_t)(__ccgo_up(symbols + uintptr(i)*4)))
 		HistogramAdd(tls, **(**uintptr)(__ccgo_up(in_histo + uintptr(i)*8)), **(**uintptr)(__ccgo_up(out_histo + uintptr(idx)*8)), **(**uintptr)(__ccgo_up(out_histo + uintptr(idx)*8)))
 		goto _4
 	_4:
 		;
 		i = i + 1
 	}
 }
 
 func GetCombineCostFactor(tls *libc.TLS, histo_size int32, quality int32) (r int32_t) {
 	var combine_cost_factor int32_t
 	_ = combine_cost_factor
 	combine_cost_factor = int32(16)
 	if quality < int32(90) {
 		if histo_size > int32(256) {
 			combine_cost_factor = combine_cost_factor / int32(2)
 		}
 		if histo_size > int32(512) {
 			combine_cost_factor = combine_cost_factor / int32(2)
 		}
 		if histo_size > int32(1024) {
 			combine_cost_factor = combine_cost_factor / int32(2)
 		}
 		if quality <= int32(50) {
 			combine_cost_factor = combine_cost_factor / int32(2)
 		}
 	}
 	return combine_cost_factor
 }
 
 func VP8LGetHistoImageSymbols(tls *libc.TLS, xsize int32, ysize int32, refs uintptr, quality int32, low_effort int32, histogram_bits int32, cache_bits int32, image_histo uintptr, tmp_histo uintptr, histogram_symbols uintptr, pic uintptr, percent_range int32, percent uintptr) (r int32) {
 	bp := tls.Alloc(16)
 	defer tls.Free(16)
 	var combine_cost_factor int32_t
 	var entropy_combine, entropy_combine_num_bins, histo_xsize, histo_ysize, image_histo_raw_size, threshold_size, v9 int32
 	var orig_histo uintptr
 	var v1, v5 uint32
 	var v10, v11, v12 int64_t
 	var v14 int64
 	var v2, v3, v6, v7 uint32_t
 	var _ /* do_greedy at bp+0 */ int32
 	_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = combine_cost_factor, entropy_combine, entropy_combine_num_bins, histo_xsize, histo_ysize, image_histo_raw_size, orig_histo, threshold_size, v1, v10, v11, v12, v14, v2, v3, v5, v6, v7, v9
 	if histogram_bits != 0 {
 		v2 = libc.Uint32FromInt32(histogram_bits)
 		v3 = (libc.Uint32FromInt32(xsize) + libc.Uint32FromInt32(libc.Int32FromInt32(1)<<v2) - uint32(1)) >> v2
 		goto _4
 	_4:
 		v1 = v3
 	} else {
 		v1 = uint32(1)
 	}
 	histo_xsize = libc.Int32FromUint32(v1)
 	if histogram_bits != 0 {
 		v6 = libc.Uint32FromInt32(histogram_bits)
 		v7 = (libc.Uint32FromInt32(ysize) + libc.Uint32FromInt32(libc.Int32FromInt32(1)<<v6) - uint32(1)) >> v6
 		goto _8
 	_8:
 		v5 = v7
 	} else {
 		v5 = uint32(1)
 	}
 	histo_ysize = libc.Int32FromUint32(v5)
 	image_histo_raw_size = histo_xsize * histo_ysize
 	orig_histo = VP8LAllocateHistogramSet(tls, image_histo_raw_size, cache_bits)
 	if low_effort != 0 {
 		v9 = int32(NUM_PARTITIONS)
 	} else {
 		v9 = libc.Int32FromInt32(NUM_PARTITIONS) * libc.Int32FromInt32(NUM_PARTITIONS) * libc.Int32FromInt32(NUM_PARTITIONS)
 	}
 	// Don't attempt linear bin-partition heuristic for
 	// histograms of small sizes (as bin_map will be very sparse) and
 	// maximum quality q==100 (to preserve the compression gains at that level).
 	entropy_combine_num_bins = v9
 	if orig_histo == libc.UintptrFromInt32(0) {
 		WebPEncodingSetError(tls, pic, int32(VP8_ENC_ERROR_OUT_OF_MEMORY))
 		goto Error
 	}
 	// Construct the histograms from backward references.
 	HistogramBuild(tls, xsize, histogram_bits, refs, orig_histo)
 	HistogramCopyAndAnalyze(tls, orig_histo, image_histo)
 	entropy_combine = libc.BoolInt32((*VP8LHistogramSet)(unsafe.Pointer(image_histo)).Fsize > entropy_combine_num_bins*int32(2) && quality < int32(100))
 	if entropy_combine != 0 {
 		combine_cost_factor = GetCombineCostFactor(tls, image_histo_raw_size, quality)
 		HistogramAnalyzeEntropyBin(tls, image_histo, low_effort)
 		// Collapse histograms with similar entropy.
 		HistogramCombineEntropyBin(tls, image_histo, tmp_histo, entropy_combine_num_bins, combine_cost_factor, low_effort)
 	}
 	// Don't combine the histograms using stochastic and greedy heuristics for
 	// low-effort compression mode.
 	if !(low_effort != 0) || !(entropy_combine != 0) {
 		v10 = int64(quality * quality * quality * (libc.Int32FromInt32(MAX_HISTO_GREEDY) - libc.Int32FromInt32(1)))
 		v11 = int64(libc.Int32FromInt32(100) * libc.Int32FromInt32(100) * libc.Int32FromInt32(100))
 		if libc.BoolInt32(v10 < 0) == libc.BoolInt32(v11 < 0) {
 			v14 = (v10 + v11/int64(2)) / v11
 		} else {
 			v14 = (v10 - v11/int64(2)) / v11
 		}
 		v12 = v14
 		goto _13
 	_13:
 		// cubic ramp between 1 and MAX_HISTO_GREEDY:
 		threshold_size = int32(libc.Int64FromInt32(1) + v12)
 		if !(HistogramCombineStochastic(tls, image_histo, threshold_size, bp) != 0) {
 			WebPEncodingSetError(tls, pic, int32(VP8_ENC_ERROR_OUT_OF_MEMORY))
 			goto Error
 		}
 		if **(**int32)(__ccgo_up(bp)) != 0 {
 			if !(HistogramCombineGreedy(tls, image_histo) != 0) {
 				WebPEncodingSetError(tls, pic, int32(VP8_ENC_ERROR_OUT_OF_MEMORY))
 				goto Error
 			}
 		}
 	}
 	// Find the optimal map from original histograms to the final ones.
 	HistogramRemap(tls, orig_histo, image_histo, histogram_symbols)
 	if !(WebPReportProgress(tls, pic, **(**int32)(__ccgo_up(percent))+percent_range, percent) != 0) {
 		goto Error
 	}
 	goto Error
 Error:
 	;
 	VP8LFreeHistogramSet(tls, orig_histo)
 	return libc.BoolInt32((*WebPPicture)(unsafe.Pointer(pic)).Ferror_code == int32(VP8_ENC_OK))
 }
 
 //------------------------------------------------------------------------------
 
 // Copyright 2012 Google Inc. All Rights Reserved.
 //
 // Use of this source code is governed by a BSD-style license
 // that can be found in the COPYING file in the root of the source
 // tree. An additional intellectual property rights grant can be found
 // in the file PATENTS. All contributing project authors may
 // be found in the AUTHORS file in the root of the source tree.
 // -----------------------------------------------------------------------------
 //
 // Misc. common utility functions
 //
 // Authors: Skal (pascal.massimino@gmail.com)
 //          Urvang (urvang@google.com)
 
 // Copyright 2010 Google Inc. All Rights Reserved.
 //
 // Use of this source code is governed by a BSD-style license
 // that can be found in the COPYING file in the root of the source
 // tree. An additional intellectual property rights grant can be found
 // in the file PATENTS. All contributing project authors may
 // be found in the AUTHORS file in the root of the source tree.
 // -----------------------------------------------------------------------------
 //
 //  Common types + memory wrappers
 //
 // Author: Skal (pascal.massimino@gmail.com)
 
 //------------------------------------------------------------------------------
 // VP8Iterator
 //------------------------------------------------------------------------------
 
 func InitLeft(tls *libc.TLS, it uintptr) {
 	var v1, v2 uint8_t
 	var v3 int32
 	_, _, _ = v1, v2, v3
 	if (*VP8EncIterator)(unsafe.Pointer(it)).Fy > 0 {
 		v3 = int32(129)
 	} else {
 		v3 = int32(127)
 	}
 	v2 = libc.Uint8FromInt32(v3)
 	**(**uint8_t)(__ccgo_up((*VP8EncIterator)(unsafe.Pointer(it)).Fv_left + uintptr(-libc.Int32FromInt32(1)))) = v2
 	v1 = v2
 	**(**uint8_t)(__ccgo_up((*VP8EncIterator)(unsafe.Pointer(it)).Fu_left + uintptr(-libc.Int32FromInt32(1)))) = v1
 	**(**uint8_t)(__ccgo_up((*VP8EncIterator)(unsafe.Pointer(it)).Fy_left + uintptr(-libc.Int32FromInt32(1)))) = v1
 	libc.X__builtin___memset_chk(tls, (*VP8EncIterator)(unsafe.Pointer(it)).Fy_left, int32(129), uint64(16), ^__predefined_size_t(0))
 	libc.X__builtin___memset_chk(tls, (*VP8EncIterator)(unsafe.Pointer(it)).Fu_left, int32(129), uint64(8), ^__predefined_size_t(0))
 	libc.X__builtin___memset_chk(tls, (*VP8EncIterator)(unsafe.Pointer(it)).Fv_left, int32(129), uint64(8), ^__predefined_size_t(0))
 	**(**int32)(__ccgo_up(it + 168 + 8*4)) = 0
 	if (*VP8EncIterator)(unsafe.Pointer(it)).Ftop_derr != libc.UintptrFromInt32(0) {
 		libc.X__builtin___memset_chk(tls, it+344, 0, uint64(4), ^__predefined_size_t(0))
 	}
 }
 
 func InitTop(tls *libc.TLS, it uintptr) {
 	var enc uintptr
 	var top_size size_t
 	_, _ = enc, top_size
 	enc = (*VP8EncIterator)(unsafe.Pointer(it)).Fenc
 	top_size = libc.Uint64FromInt32((*VP8Encoder)(unsafe.Pointer(enc)).Fmb_w * int32(16))
 	libc.X__builtin___memset_chk(tls, (*VP8Encoder)(unsafe.Pointer(enc)).Fy_top, int32(127), uint64(2)*top_size, ^__predefined_size_t(0))
 	libc.X__builtin___memset_chk(tls, (*VP8Encoder)(unsafe.Pointer(enc)).Fnz, 0, libc.Uint64FromInt32((*VP8Encoder)(unsafe.Pointer(enc)).Fmb_w)*uint64(4), ^__predefined_size_t(0))
 	if (*VP8Encoder)(unsafe.Pointer(enc)).Ftop_derr != libc.UintptrFromInt32(0) {
 		libc.X__builtin___memset_chk(tls, (*VP8Encoder)(unsafe.Pointer(enc)).Ftop_derr, 0, libc.Uint64FromInt32((*VP8Encoder)(unsafe.Pointer(enc)).Fmb_w)*uint64(4), ^__predefined_size_t(0))
 	}
 }
 
 func VP8IteratorSetRow(tls *libc.TLS, it uintptr, y int32) {
 	var enc uintptr
 	_ = enc
 	enc = (*VP8EncIterator)(unsafe.Pointer(it)).Fenc
 	(*VP8EncIterator)(unsafe.Pointer(it)).Fx = 0
 	(*VP8EncIterator)(unsafe.Pointer(it)).Fy = y
 	(*VP8EncIterator)(unsafe.Pointer(it)).Fbw = enc + 112 + uintptr(y&((*VP8Encoder)(unsafe.Pointer(enc)).Fnum_parts-int32(1)))*48
 	(*VP8EncIterator)(unsafe.Pointer(it)).Fpreds = (*VP8Encoder)(unsafe.Pointer(enc)).Fpreds + uintptr(y*int32(4)*(*VP8Encoder)(unsafe.Pointer(enc)).Fpreds_w)
 	(*VP8EncIterator)(unsafe.Pointer(it)).Fnz = (*VP8Encoder)(unsafe.Pointer(enc)).Fnz
 	(*VP8EncIterator)(unsafe.Pointer(it)).Fmb = (*VP8Encoder)(unsafe.Pointer(enc)).Fmb_info + uintptr(y*(*VP8Encoder)(unsafe.Pointer(enc)).Fmb_w)*4
 	(*VP8EncIterator)(unsafe.Pointer(it)).Fy_top = (*VP8Encoder)(unsafe.Pointer(enc)).Fy_top
 	(*VP8EncIterator)(unsafe.Pointer(it)).Fuv_top = (*VP8Encoder)(unsafe.Pointer(enc)).Fuv_top
 	InitLeft(tls, it)
 }
 
 // C documentation
 //
 //	// restart a scan
 func VP8IteratorReset(tls *libc.TLS, it uintptr) {
 	var enc uintptr
 	_ = enc
 	enc = (*VP8EncIterator)(unsafe.Pointer(it)).Fenc
 	VP8IteratorSetRow(tls, it, 0)
 	VP8IteratorSetCountDown(tls, it, (*VP8Encoder)(unsafe.Pointer(enc)).Fmb_w*(*VP8Encoder)(unsafe.Pointer(enc)).Fmb_h) // default
 	InitTop(tls, it)
 	libc.X__builtin___memset_chk(tls, it+208, 0, uint64(96), ^__predefined_size_t(0))
 	(*VP8EncIterator)(unsafe.Pointer(it)).Fdo_trellis = 0
 }
 
 func VP8IteratorSetCountDown(tls *libc.TLS, it uintptr, count_down int32) {
 	var v1 int32
 	_ = v1
 	v1 = count_down
 	(*VP8EncIterator)(unsafe.Pointer(it)).Fcount_down0 = v1
 	(*VP8EncIterator)(unsafe.Pointer(it)).Fcount_down = v1
 }
 
 func VP8IteratorIsDone(tls *libc.TLS, it uintptr) (r int32) {
 	return libc.BoolInt32((*VP8EncIterator)(unsafe.Pointer(it)).Fcount_down <= 0)
 }
 
 func VP8IteratorInit(tls *libc.TLS, enc uintptr, it uintptr) {
 	(*VP8EncIterator)(unsafe.Pointer(it)).Fenc = enc
 	(*VP8EncIterator)(unsafe.Pointer(it)).Fyuv_in = uintptr((uintptr_t(it+488) + libc.Uint64FromInt32(WEBP_ALIGN_CST)) & ^libc.Uint64FromInt32(WEBP_ALIGN_CST))
 	(*VP8EncIterator)(unsafe.Pointer(it)).Fyuv_out = (*VP8EncIterator)(unsafe.Pointer(it)).Fyuv_in + uintptr(libc.Int32FromInt32(BPS)*libc.Int32FromInt32(16))
 	(*VP8EncIterator)(unsafe.Pointer(it)).Fyuv_out2 = (*VP8EncIterator)(unsafe.Pointer(it)).Fyuv_out + uintptr(libc.Int32FromInt32(BPS)*libc.Int32FromInt32(16))
 	(*VP8EncIterator)(unsafe.Pointer(it)).Fyuv_p = (*VP8EncIterator)(unsafe.Pointer(it)).Fyuv_out2 + uintptr(libc.Int32FromInt32(BPS)*libc.Int32FromInt32(16))
 	(*VP8EncIterator)(unsafe.Pointer(it)).Flf_stats = (*VP8Encoder)(unsafe.Pointer(enc)).Flf_stats
 	(*VP8EncIterator)(unsafe.Pointer(it)).Fpercent0 = (*VP8Encoder)(unsafe.Pointer(enc)).Fpercent
 	(*VP8EncIterator)(unsafe.Pointer(it)).Fy_left = uintptr((uint64(it+400+libc.UintptrFromInt32(1)) + libc.Uint64FromInt32(WEBP_ALIGN_CST)) & ^libc.Uint64FromInt32(WEBP_ALIGN_CST))
 	(*VP8EncIterator)(unsafe.Pointer(it)).Fu_left = (*VP8EncIterator)(unsafe.Pointer(it)).Fy_left + uintptr(16) + uintptr(16)
 	(*VP8EncIterator)(unsafe.Pointer(it)).Fv_left = (*VP8EncIterator)(unsafe.Pointer(it)).Fu_left + uintptr(16)
 	(*VP8EncIterator)(unsafe.Pointer(it)).Ftop_derr = (*VP8Encoder)(unsafe.Pointer(enc)).Ftop_derr
 	VP8IteratorReset(tls, it)
 }
 
 func VP8IteratorProgress(tls *libc.TLS, it uintptr, delta int32) (r int32) {
 	var done, percent, v1 int32
 	var enc uintptr
 	_, _, _, _ = done, enc, percent, v1
 	enc = (*VP8EncIterator)(unsafe.Pointer(it)).Fenc
 	if delta != 0 && (*WebPPicture)(unsafe.Pointer((*VP8Encoder)(unsafe.Pointer(enc)).Fpic)).Fprogress_hook != libc.UintptrFromInt32(0) {
 		done = (*VP8EncIterator)(unsafe.Pointer(it)).Fcount_down0 - (*VP8EncIterator)(unsafe.Pointer(it)).Fcount_down
 		if (*VP8EncIterator)(unsafe.Pointer(it)).Fcount_down0 <= 0 {
 			v1 = (*VP8EncIterator)(unsafe.Pointer(it)).Fpercent0
 		} else {
 			v1 = (*VP8EncIterator)(unsafe.Pointer(it)).Fpercent0 + delta*done/(*VP8EncIterator)(unsafe.Pointer(it)).Fcount_down0
 		}
 		percent = v1
 		return WebPReportProgress(tls, (*VP8Encoder)(unsafe.Pointer(enc)).Fpic, percent, enc+536)
 	}
 	return int32(1)
 }
 
 //------------------------------------------------------------------------------
 // Import the source samples into the cache. Takes care of replicating
 // boundary pixels if necessary.
 
 func MinSize(tls *libc.TLS, a int32, b int32) (r int32) {
 	var v1 int32
 	_ = v1
 	if a < b {
 		v1 = a
 	} else {
 		v1 = b
 	}
 	return v1
 }
 
 func ImportBlock(tls *libc.TLS, src uintptr, src_stride int32, dst uintptr, w int32, h int32, size int32) {
 	var i int32
 	_ = i
 	i = 0
 	for {
 		if !(i < h) {
 			break
 		}
 		libc.X__builtin___memcpy_chk(tls, dst, src, libc.Uint64FromInt32(w), ^__predefined_size_t(0))
 		if w < size {
 			libc.X__builtin___memset_chk(tls, dst+uintptr(w), libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(dst + uintptr(w-int32(1))))), libc.Uint64FromInt32(size-w), ^__predefined_size_t(0))
 		}
 		dst = dst + uintptr(BPS)
 		src = src + uintptr(src_stride)
 		goto _1
 	_1:
 		;
 		i = i + 1
 	}
 	i = h
 	for {
 		if !(i < size) {
 			break
 		}
 		libc.X__builtin___memcpy_chk(tls, dst, dst-uintptr(BPS), libc.Uint64FromInt32(size), ^__predefined_size_t(0))
 		dst = dst + uintptr(BPS)
 		goto _2
 	_2:
 		;
 		i = i + 1
 	}
 }
 
 func ImportLine(tls *libc.TLS, src uintptr, src_stride int32, dst uintptr, len1 int32, total_len int32) {
 	var i int32
 	_ = i
 	i = 0
 	for {
 		if !(i < len1) {
 			break
 		}
 		**(**uint8_t)(__ccgo_up(dst + uintptr(i))) = **(**uint8_t)(__ccgo_up(src))
 		goto _1
 	_1:
 		;
 		i = i + 1
 		src = src + uintptr(src_stride)
 	}
 	for {
 		if !(i < total_len) {
 			break
 		}
 		**(**uint8_t)(__ccgo_up(dst + uintptr(i))) = **(**uint8_t)(__ccgo_up(dst + uintptr(len1-int32(1))))
 		goto _2
 	_2:
 		;
 		i = i + 1
 	}
 }
 
 func VP8IteratorImport(tls *libc.TLS, it uintptr, tmp_32 uintptr) {
 	var enc, pic, usrc, vsrc, ysrc uintptr
 	var h, uv_h, uv_w, w, x, y int32
 	var v1, v2 uint8_t
 	_, _, _, _, _, _, _, _, _, _, _, _, _ = enc, h, pic, usrc, uv_h, uv_w, vsrc, w, x, y, ysrc, v1, v2
 	enc = (*VP8EncIterator)(unsafe.Pointer(it)).Fenc
 	x = (*VP8EncIterator)(unsafe.Pointer(it)).Fx
 	y = (*VP8EncIterator)(unsafe.Pointer(it)).Fy
 	pic = (*VP8Encoder)(unsafe.Pointer(enc)).Fpic
 	ysrc = (*WebPPicture)(unsafe.Pointer(pic)).Fy + uintptr((y*(*WebPPicture)(unsafe.Pointer(pic)).Fy_stride+x)*int32(16))
 	usrc = (*WebPPicture)(unsafe.Pointer(pic)).Fu + uintptr((y*(*WebPPicture)(unsafe.Pointer(pic)).Fuv_stride+x)*int32(8))
 	vsrc = (*WebPPicture)(unsafe.Pointer(pic)).Fv + uintptr((y*(*WebPPicture)(unsafe.Pointer(pic)).Fuv_stride+x)*int32(8))
 	w = MinSize(tls, (*WebPPicture)(unsafe.Pointer(pic)).Fwidth-x*int32(16), int32(16))
 	h = MinSize(tls, (*WebPPicture)(unsafe.Pointer(pic)).Fheight-y*int32(16), int32(16))
 	uv_w = (w + int32(1)) >> int32(1)
 	uv_h = (h + int32(1)) >> int32(1)
 	ImportBlock(tls, ysrc, (*WebPPicture)(unsafe.Pointer(pic)).Fy_stride, (*VP8EncIterator)(unsafe.Pointer(it)).Fyuv_in+uintptr(libc.Int32FromInt32(Y_OFF_ENC)), w, h, int32(16))
 	ImportBlock(tls, usrc, (*WebPPicture)(unsafe.Pointer(pic)).Fuv_stride, (*VP8EncIterator)(unsafe.Pointer(it)).Fyuv_in+uintptr(libc.Int32FromInt32(U_OFF_ENC)), uv_w, uv_h, int32(8))
 	ImportBlock(tls, vsrc, (*WebPPicture)(unsafe.Pointer(pic)).Fuv_stride, (*VP8EncIterator)(unsafe.Pointer(it)).Fyuv_in+uintptr(libc.Int32FromInt32(16)+libc.Int32FromInt32(8)), uv_w, uv_h, int32(8))
 	if tmp_32 == libc.UintptrFromInt32(0) {
 		return
 	}
 	// Import source (uncompressed) samples into boundary.
 	if x == 0 {
 		InitLeft(tls, it)
 	} else {
 		if y == 0 {
 			v2 = libc.Uint8FromInt32(127)
 			**(**uint8_t)(__ccgo_up((*VP8EncIterator)(unsafe.Pointer(it)).Fv_left + uintptr(-libc.Int32FromInt32(1)))) = v2
 			v1 = v2
 			**(**uint8_t)(__ccgo_up((*VP8EncIterator)(unsafe.Pointer(it)).Fu_left + uintptr(-libc.Int32FromInt32(1)))) = v1
 			**(**uint8_t)(__ccgo_up((*VP8EncIterator)(unsafe.Pointer(it)).Fy_left + uintptr(-libc.Int32FromInt32(1)))) = v1
 		} else {
 			**(**uint8_t)(__ccgo_up((*VP8EncIterator)(unsafe.Pointer(it)).Fy_left + uintptr(-libc.Int32FromInt32(1)))) = **(**uint8_t)(__ccgo_up(ysrc + uintptr(-int32(1)-(*WebPPicture)(unsafe.Pointer(pic)).Fy_stride)))
 			**(**uint8_t)(__ccgo_up((*VP8EncIterator)(unsafe.Pointer(it)).Fu_left + uintptr(-libc.Int32FromInt32(1)))) = **(**uint8_t)(__ccgo_up(usrc + uintptr(-int32(1)-(*WebPPicture)(unsafe.Pointer(pic)).Fuv_stride)))
 			**(**uint8_t)(__ccgo_up((*VP8EncIterator)(unsafe.Pointer(it)).Fv_left + uintptr(-libc.Int32FromInt32(1)))) = **(**uint8_t)(__ccgo_up(vsrc + uintptr(-int32(1)-(*WebPPicture)(unsafe.Pointer(pic)).Fuv_stride)))
 		}
 		ImportLine(tls, ysrc-uintptr(1), (*WebPPicture)(unsafe.Pointer(pic)).Fy_stride, (*VP8EncIterator)(unsafe.Pointer(it)).Fy_left, h, int32(16))
 		ImportLine(tls, usrc-uintptr(1), (*WebPPicture)(unsafe.Pointer(pic)).Fuv_stride, (*VP8EncIterator)(unsafe.Pointer(it)).Fu_left, uv_h, int32(8))
 		ImportLine(tls, vsrc-uintptr(1), (*WebPPicture)(unsafe.Pointer(pic)).Fuv_stride, (*VP8EncIterator)(unsafe.Pointer(it)).Fv_left, uv_h, int32(8))
 	}
 	(*VP8EncIterator)(unsafe.Pointer(it)).Fy_top = tmp_32 + uintptr(0)
 	(*VP8EncIterator)(unsafe.Pointer(it)).Fuv_top = tmp_32 + uintptr(16)
 	if y == 0 {
 		libc.X__builtin___memset_chk(tls, tmp_32, int32(127), libc.Uint64FromInt32(32)*libc.Uint64FromInt64(1), ^__predefined_size_t(0))
 	} else {
 		ImportLine(tls, ysrc-uintptr((*WebPPicture)(unsafe.Pointer(pic)).Fy_stride), int32(1), tmp_32, w, int32(16))
 		ImportLine(tls, usrc-uintptr((*WebPPicture)(unsafe.Pointer(pic)).Fuv_stride), int32(1), tmp_32+uintptr(16), uv_w, int32(8))
 		ImportLine(tls, vsrc-uintptr((*WebPPicture)(unsafe.Pointer(pic)).Fuv_stride), int32(1), tmp_32+uintptr(16)+uintptr(8), uv_w, int32(8))
 	}
 }
 
 //------------------------------------------------------------------------------
 // Copy back the compressed samples into user space if requested.
 
 func ExportBlock(tls *libc.TLS, src uintptr, dst uintptr, dst_stride int32, w int32, h int32) {
 	var v1 int32
 	_ = v1
 	for {
 		v1 = h
 		h = h - 1
 		if !(v1 > 0) {
 			break
 		}
 		libc.X__builtin___memcpy_chk(tls, dst, src, libc.Uint64FromInt32(w), ^__predefined_size_t(0))
 		dst = dst + uintptr(dst_stride)
 		src = src + uintptr(BPS)
 	}
 }
 
 func VP8IteratorExport(tls *libc.TLS, it uintptr) {
 	var enc, pic, udst, usrc, vdst, vsrc, ydst, ysrc uintptr
 	var h, uv_h, uv_w, w, x, y int32
 	_, _, _, _, _, _, _, _, _, _, _, _, _, _ = enc, h, pic, udst, usrc, uv_h, uv_w, vdst, vsrc, w, x, y, ydst, ysrc
 	enc = (*VP8EncIterator)(unsafe.Pointer(it)).Fenc
 	if (*WebPConfig)(unsafe.Pointer((*VP8Encoder)(unsafe.Pointer(enc)).Fconfig)).Fshow_compressed != 0 {
 		x = (*VP8EncIterator)(unsafe.Pointer(it)).Fx
 		y = (*VP8EncIterator)(unsafe.Pointer(it)).Fy
 		ysrc = (*VP8EncIterator)(unsafe.Pointer(it)).Fyuv_out + uintptr(libc.Int32FromInt32(Y_OFF_ENC))
 		usrc = (*VP8EncIterator)(unsafe.Pointer(it)).Fyuv_out + uintptr(libc.Int32FromInt32(U_OFF_ENC))
 		vsrc = (*VP8EncIterator)(unsafe.Pointer(it)).Fyuv_out + uintptr(libc.Int32FromInt32(16)+libc.Int32FromInt32(8))
 		pic = (*VP8Encoder)(unsafe.Pointer(enc)).Fpic
 		ydst = (*WebPPicture)(unsafe.Pointer(pic)).Fy + uintptr((y*(*WebPPicture)(unsafe.Pointer(pic)).Fy_stride+x)*int32(16))
 		udst = (*WebPPicture)(unsafe.Pointer(pic)).Fu + uintptr((y*(*WebPPicture)(unsafe.Pointer(pic)).Fuv_stride+x)*int32(8))
 		vdst = (*WebPPicture)(unsafe.Pointer(pic)).Fv + uintptr((y*(*WebPPicture)(unsafe.Pointer(pic)).Fuv_stride+x)*int32(8))
 		w = (*WebPPicture)(unsafe.Pointer(pic)).Fwidth - x*int32(16)
 		h = (*WebPPicture)(unsafe.Pointer(pic)).Fheight - y*int32(16)
 		if w > int32(16) {
 			w = int32(16)
 		}
 		if h > int32(16) {
 			h = int32(16)
 		}
 		// Luma plane
 		ExportBlock(tls, ysrc, ydst, (*WebPPicture)(unsafe.Pointer(pic)).Fy_stride, w, h)
 		// U/V planes
 		uv_w = (w + int32(1)) >> int32(1)
 		uv_h = (h + int32(1)) >> int32(1)
 		ExportBlock(tls, usrc, udst, (*WebPPicture)(unsafe.Pointer(pic)).Fuv_stride, uv_w, uv_h)
 		ExportBlock(tls, vsrc, vdst, (*WebPPicture)(unsafe.Pointer(pic)).Fuv_stride, uv_w, uv_h)
 	}
 }
 
 //------------------------------------------------------------------------------
 // Non-zero contexts setup/teardown
 
 // Nz bits:
 //  0  1  2  3  Y
 //  4  5  6  7
 //  8  9 10 11
 // 12 13 14 15
 // 16 17        U
 // 18 19
 // 20 21        V
 // 22 23
 // 24           DC-intra16
 
 // Convert packed context to byte array
 
 func VP8IteratorNzToBytes(tls *libc.TLS, it uintptr) {
 	var left_nz, top_nz uintptr
 	var lnz, tnz int32
 	_, _, _, _ = left_nz, lnz, tnz, top_nz
 	tnz = libc.Int32FromUint32(**(**uint32_t)(__ccgo_up((*VP8EncIterator)(unsafe.Pointer(it)).Fnz)))
 	lnz = libc.Int32FromUint32(**(**uint32_t)(__ccgo_up((*VP8EncIterator)(unsafe.Pointer(it)).Fnz + uintptr(-libc.Int32FromInt32(1))*4)))
 	top_nz = it + 132
 	left_nz = it + 168
 	// Top-Y
 	**(**int32)(__ccgo_up(top_nz)) = libc.BoolInt32(!!(tnz&(libc.Int32FromInt32(1)<<libc.Int32FromInt32(12)) != 0))
 	**(**int32)(__ccgo_up(top_nz + 1*4)) = libc.BoolInt32(!!(tnz&(libc.Int32FromInt32(1)<<libc.Int32FromInt32(13)) != 0))
 	**(**int32)(__ccgo_up(top_nz + 2*4)) = libc.BoolInt32(!!(tnz&(libc.Int32FromInt32(1)<<libc.Int32FromInt32(14)) != 0))
 	**(**int32)(__ccgo_up(top_nz + 3*4)) = libc.BoolInt32(!!(tnz&(libc.Int32FromInt32(1)<<libc.Int32FromInt32(15)) != 0))
 	// Top-U
 	**(**int32)(__ccgo_up(top_nz + 4*4)) = libc.BoolInt32(!!(tnz&(libc.Int32FromInt32(1)<<libc.Int32FromInt32(18)) != 0))
 	**(**int32)(__ccgo_up(top_nz + 5*4)) = libc.BoolInt32(!!(tnz&(libc.Int32FromInt32(1)<<libc.Int32FromInt32(19)) != 0))
 	// Top-V
 	**(**int32)(__ccgo_up(top_nz + 6*4)) = libc.BoolInt32(!!(tnz&(libc.Int32FromInt32(1)<<libc.Int32FromInt32(22)) != 0))
 	**(**int32)(__ccgo_up(top_nz + 7*4)) = libc.BoolInt32(!!(tnz&(libc.Int32FromInt32(1)<<libc.Int32FromInt32(23)) != 0))
 	// DC
 	**(**int32)(__ccgo_up(top_nz + 8*4)) = libc.BoolInt32(!!(tnz&(libc.Int32FromInt32(1)<<libc.Int32FromInt32(24)) != 0))
 	// left-Y
 	**(**int32)(__ccgo_up(left_nz)) = libc.BoolInt32(!!(lnz&(libc.Int32FromInt32(1)<<libc.Int32FromInt32(3)) != 0))
 	**(**int32)(__ccgo_up(left_nz + 1*4)) = libc.BoolInt32(!!(lnz&(libc.Int32FromInt32(1)<<libc.Int32FromInt32(7)) != 0))
 	**(**int32)(__ccgo_up(left_nz + 2*4)) = libc.BoolInt32(!!(lnz&(libc.Int32FromInt32(1)<<libc.Int32FromInt32(11)) != 0))
 	**(**int32)(__ccgo_up(left_nz + 3*4)) = libc.BoolInt32(!!(lnz&(libc.Int32FromInt32(1)<<libc.Int32FromInt32(15)) != 0))
 	// left-U
 	**(**int32)(__ccgo_up(left_nz + 4*4)) = libc.BoolInt32(!!(lnz&(libc.Int32FromInt32(1)<<libc.Int32FromInt32(17)) != 0))
 	**(**int32)(__ccgo_up(left_nz + 5*4)) = libc.BoolInt32(!!(lnz&(libc.Int32FromInt32(1)<<libc.Int32FromInt32(19)) != 0))
 	// left-V
 	**(**int32)(__ccgo_up(left_nz + 6*4)) = libc.BoolInt32(!!(lnz&(libc.Int32FromInt32(1)<<libc.Int32FromInt32(21)) != 0))
 	**(**int32)(__ccgo_up(left_nz + 7*4)) = libc.BoolInt32(!!(lnz&(libc.Int32FromInt32(1)<<libc.Int32FromInt32(23)) != 0))
 	// left-DC is special, iterated separately
 }
 
 func VP8IteratorBytesToNz(tls *libc.TLS, it uintptr) {
 	var left_nz, top_nz uintptr
 	var nz uint32_t
 	_, _, _ = left_nz, nz, top_nz
 	nz = uint32(0)
 	top_nz = it + 132
 	left_nz = it + 168
 	// top
 	nz = nz | libc.Uint32FromInt32(**(**int32)(__ccgo_up(top_nz))<<libc.Int32FromInt32(12)|**(**int32)(__ccgo_up(top_nz + 1*4))<<libc.Int32FromInt32(13))
 	nz = nz | libc.Uint32FromInt32(**(**int32)(__ccgo_up(top_nz + 2*4))<<libc.Int32FromInt32(14)|**(**int32)(__ccgo_up(top_nz + 3*4))<<libc.Int32FromInt32(15))
 	nz = nz | libc.Uint32FromInt32(**(**int32)(__ccgo_up(top_nz + 4*4))<<libc.Int32FromInt32(18)|**(**int32)(__ccgo_up(top_nz + 5*4))<<libc.Int32FromInt32(19))
 	nz = nz | libc.Uint32FromInt32(**(**int32)(__ccgo_up(top_nz + 6*4))<<libc.Int32FromInt32(22)|**(**int32)(__ccgo_up(top_nz + 7*4))<<libc.Int32FromInt32(23))
 	nz = nz | libc.Uint32FromInt32(**(**int32)(__ccgo_up(top_nz + 8*4))<<libc.Int32FromInt32(24)) // we propagate the _top_ bit, esp. for intra4
 	// left
 	nz = nz | libc.Uint32FromInt32(**(**int32)(__ccgo_up(left_nz))<<libc.Int32FromInt32(3)|**(**int32)(__ccgo_up(left_nz + 1*4))<<libc.Int32FromInt32(7))
 	nz = nz | libc.Uint32FromInt32(**(**int32)(__ccgo_up(left_nz + 2*4))<<libc.Int32FromInt32(11))
 	nz = nz | libc.Uint32FromInt32(**(**int32)(__ccgo_up(left_nz + 4*4))<<libc.Int32FromInt32(17)|**(**int32)(__ccgo_up(left_nz + 6*4))<<libc.Int32FromInt32(21))
 	**(**uint32_t)(__ccgo_up((*VP8EncIterator)(unsafe.Pointer(it)).Fnz)) = nz
 }
 
 //------------------------------------------------------------------------------
 // Advance to the next position, doing the bookkeeping.
 
 func VP8IteratorSaveBoundary(tls *libc.TLS, it uintptr) {
 	var enc, uvsrc, ysrc uintptr
 	var i, x, y int32
 	_, _, _, _, _, _ = enc, i, uvsrc, x, y, ysrc
 	enc = (*VP8EncIterator)(unsafe.Pointer(it)).Fenc
 	x = (*VP8EncIterator)(unsafe.Pointer(it)).Fx
 	y = (*VP8EncIterator)(unsafe.Pointer(it)).Fy
 	ysrc = (*VP8EncIterator)(unsafe.Pointer(it)).Fyuv_out + uintptr(libc.Int32FromInt32(Y_OFF_ENC))
 	uvsrc = (*VP8EncIterator)(unsafe.Pointer(it)).Fyuv_out + uintptr(libc.Int32FromInt32(U_OFF_ENC))
 	if x < (*VP8Encoder)(unsafe.Pointer(enc)).Fmb_w-int32(1) {
 		i = 0
 		for {
 			if !(i < int32(16)) {
 				break
 			}
 			**(**uint8_t)(__ccgo_up((*VP8EncIterator)(unsafe.Pointer(it)).Fy_left + uintptr(i))) = **(**uint8_t)(__ccgo_up(ysrc + uintptr(int32(15)+i*int32(BPS))))
 			goto _1
 		_1:
 			;
 			i = i + 1
 		}
 		i = 0
 		for {
 			if !(i < int32(8)) {
 				break
 			}
 			**(**uint8_t)(__ccgo_up((*VP8EncIterator)(unsafe.Pointer(it)).Fu_left + uintptr(i))) = **(**uint8_t)(__ccgo_up(uvsrc + uintptr(int32(7)+i*int32(BPS))))
 			**(**uint8_t)(__ccgo_up((*VP8EncIterator)(unsafe.Pointer(it)).Fv_left + uintptr(i))) = **(**uint8_t)(__ccgo_up(uvsrc + uintptr(int32(15)+i*int32(BPS))))
 			goto _2
 		_2:
 			;
 			i = i + 1
 		}
 		// top-left (before 'top'!)
 		**(**uint8_t)(__ccgo_up((*VP8EncIterator)(unsafe.Pointer(it)).Fy_left + uintptr(-libc.Int32FromInt32(1)))) = **(**uint8_t)(__ccgo_up((*VP8EncIterator)(unsafe.Pointer(it)).Fy_top + 15))
 		**(**uint8_t)(__ccgo_up((*VP8EncIterator)(unsafe.Pointer(it)).Fu_left + uintptr(-libc.Int32FromInt32(1)))) = **(**uint8_t)(__ccgo_up((*VP8EncIterator)(unsafe.Pointer(it)).Fuv_top + uintptr(libc.Int32FromInt32(0)+libc.Int32FromInt32(7))))
 		**(**uint8_t)(__ccgo_up((*VP8EncIterator)(unsafe.Pointer(it)).Fv_left + uintptr(-libc.Int32FromInt32(1)))) = **(**uint8_t)(__ccgo_up((*VP8EncIterator)(unsafe.Pointer(it)).Fuv_top + uintptr(libc.Int32FromInt32(8)+libc.Int32FromInt32(7))))
 	}
 	if y < (*VP8Encoder)(unsafe.Pointer(enc)).Fmb_h-int32(1) { // top
 		libc.X__builtin___memcpy_chk(tls, (*VP8EncIterator)(unsafe.Pointer(it)).Fy_top, ysrc+uintptr(libc.Int32FromInt32(15)*libc.Int32FromInt32(BPS)), uint64(16), ^__predefined_size_t(0))
 		libc.X__builtin___memcpy_chk(tls, (*VP8EncIterator)(unsafe.Pointer(it)).Fuv_top, uvsrc+uintptr(libc.Int32FromInt32(7)*libc.Int32FromInt32(BPS)), libc.Uint64FromInt32(libc.Int32FromInt32(8)+libc.Int32FromInt32(8)), ^__predefined_size_t(0))
 	}
 }
 
 func VP8IteratorNext(tls *libc.TLS, it uintptr) (r int32) {
 	var v1, v3 int32
 	var v2, v4 uintptr
 	_, _, _, _ = v1, v2, v3, v4
 	v2 = it
 	*(*int32)(unsafe.Pointer(v2)) = *(*int32)(unsafe.Pointer(v2)) + 1
 	v1 = *(*int32)(unsafe.Pointer(v2))
 	if v1 == (*VP8Encoder)(unsafe.Pointer((*VP8EncIterator)(unsafe.Pointer(it)).Fenc)).Fmb_w {
 		v4 = it + 4
 		*(*int32)(unsafe.Pointer(v4)) = *(*int32)(unsafe.Pointer(v4)) + 1
 		v3 = *(*int32)(unsafe.Pointer(v4))
 		VP8IteratorSetRow(tls, it, v3)
 	} else {
 		**(**uintptr)(__ccgo_up(it + 64)) += uintptr(4)
 		**(**uintptr)(__ccgo_up(it + 48)) += uintptr(1) * 4
 		**(**uintptr)(__ccgo_up(it + 72)) += uintptr(1) * 4
 		**(**uintptr)(__ccgo_up(it + 384)) += uintptr(16)
 		**(**uintptr)(__ccgo_up(it + 392)) += uintptr(16)
 	}
 	v2 = it + 332
 	*(*int32)(unsafe.Pointer(v2)) = *(*int32)(unsafe.Pointer(v2)) - 1
 	v1 = *(*int32)(unsafe.Pointer(v2))
 	return libc.BoolInt32(0 < v1)
 }
 
 //------------------------------------------------------------------------------
 // Helper function to set mode properties
 
 func VP8SetIntra16Mode(tls *libc.TLS, it uintptr, mode int32) {
 	var preds uintptr
 	var y int32
 	_, _ = preds, y
 	preds = (*VP8EncIterator)(unsafe.Pointer(it)).Fpreds
 	y = 0
 	for {
 		if !(y < int32(4)) {
 			break
 		}
 		libc.X__builtin___memset_chk(tls, preds, mode, uint64(4), ^__predefined_size_t(0))
 		preds = preds + uintptr((*VP8Encoder)(unsafe.Pointer((*VP8EncIterator)(unsafe.Pointer(it)).Fenc)).Fpreds_w)
 		goto _1
 	_1:
 		;
 		y = y + 1
 	}
 	libc.SetBitFieldPtr8Uint32((*VP8EncIterator)(unsafe.Pointer(it)).Fmb+0, libc.Uint32FromInt32(1), 0, 0x3)
 }
 
 func VP8SetIntra4Mode(tls *libc.TLS, it uintptr, modes uintptr) {
 	var preds uintptr
 	var y int32
 	_, _ = preds, y
 	preds = (*VP8EncIterator)(unsafe.Pointer(it)).Fpreds
 	y = int32(4)
 	for {
 		if !(y > 0) {
 			break
 		}
 		libc.X__builtin___memcpy_chk(tls, preds, modes, libc.Uint64FromInt32(4)*libc.Uint64FromInt64(1), ^__predefined_size_t(0))
 		preds = preds + uintptr((*VP8Encoder)(unsafe.Pointer((*VP8EncIterator)(unsafe.Pointer(it)).Fenc)).Fpreds_w)
 		modes = modes + uintptr(4)
 		goto _1
 	_1:
 		;
 		y = y - 1
 	}
 	libc.SetBitFieldPtr8Uint32((*VP8EncIterator)(unsafe.Pointer(it)).Fmb+0, libc.Uint32FromInt32(0), 0, 0x3)
 }
 
 func VP8SetIntraUVMode(tls *libc.TLS, it uintptr, mode int32) {
 	libc.SetBitFieldPtr8Uint32((*VP8EncIterator)(unsafe.Pointer(it)).Fmb+0, libc.Uint32FromInt32(mode), 2, 0xc)
 }
 
 func VP8SetSkip(tls *libc.TLS, it uintptr, skip int32) {
 	libc.SetBitFieldPtr8Uint32((*VP8EncIterator)(unsafe.Pointer(it)).Fmb+0, libc.Uint32FromInt32(skip), 4, 0x10)
 }
 
 func VP8SetSegment(tls *libc.TLS, it uintptr, segment int32) {
 	libc.SetBitFieldPtr8Uint32((*VP8EncIterator)(unsafe.Pointer(it)).Fmb+0, libc.Uint32FromInt32(segment), 5, 0x60)
 }
 
 //------------------------------------------------------------------------------
 // Intra4x4 sub-blocks iteration
 //
 //  We store and update the boundary samples into an array of 37 pixels. They
 //  are updated as we iterate and reconstructs each intra4x4 blocks in turn.
 //  The position of the samples has the following snake pattern:
 //
 // 16|17 18 19 20|21 22 23 24|25 26 27 28|29 30 31 32|33 34 35 36  <- Top-right
 // --+-----------+-----------+-----------+-----------+
 // 15|         19|         23|         27|         31|
 // 14|         18|         22|         26|         30|
 // 13|         17|         21|         25|         29|
 // 12|13 14 15 16|17 18 19 20|21 22 23 24|25 26 27 28|
 // --+-----------+-----------+-----------+-----------+
 // 11|         15|         19|         23|         27|
 // 10|         14|         18|         22|         26|
 //  9|         13|         17|         21|         25|
 //  8| 9 10 11 12|13 14 15 16|17 18 19 20|21 22 23 24|
 // --+-----------+-----------+-----------+-----------+
 //  7|         11|         15|         19|         23|
 //  6|         10|         14|         18|         22|
 //  5|          9|         13|         17|         21|
 //  4| 5  6  7  8| 9 10 11 12|13 14 15 16|17 18 19 20|
 // --+-----------+-----------+-----------+-----------+
 //  3|          7|         11|         15|         19|
 //  2|          6|         10|         14|         18|
 //  1|          5|          9|         13|         17|
 //  0| 1  2  3  4| 5  6  7  8| 9 10 11 12|13 14 15 16|
 // --+-----------+-----------+-----------+-----------+
 
 // C documentation
 //
 //	// Array to record the position of the top sample to pass to the prediction
 //	// functions in dsp.c.
 var VP8TopLeftI4 = [16]uint8_t{
 	0:  uint8(17),
 	1:  uint8(21),
 	2:  uint8(25),
 	3:  uint8(29),
 	4:  uint8(13),
 	5:  uint8(17),
 	6:  uint8(21),
 	7:  uint8(25),
 	8:  uint8(9),
 	9:  uint8(13),
 	10: uint8(17),
 	11: uint8(21),
 	12: uint8(5),
 	13: uint8(9),
 	14: uint8(13),
 	15: uint8(17),
 }
 
 func VP8IteratorStartI4(tls *libc.TLS, it uintptr) {
 	var enc uintptr
 	var i int32
 	_, _ = enc, i
 	enc = (*VP8EncIterator)(unsafe.Pointer(it)).Fenc
 	(*VP8EncIterator)(unsafe.Pointer(it)).Fi4 = 0 // first 4x4 sub-block
 	(*VP8EncIterator)(unsafe.Pointer(it)).Fi4_top = it + 80 + uintptr(VP8TopLeftI4[0])
 	// Import the boundary samples
 	i = 0
 	for {
 		if !(i < int32(17)) {
 			break
 		} // left
 		**(**uint8_t)(__ccgo_up(it + 80 + uintptr(i))) = **(**uint8_t)(__ccgo_up((*VP8EncIterator)(unsafe.Pointer(it)).Fy_left + uintptr(int32(15)-i)))
 		goto _1
 	_1:
 		;
 		i = i + 1
 	}
 	i = 0
 	for {
 		if !(i < int32(16)) {
 			break
 		} // top
 		**(**uint8_t)(__ccgo_up(it + 80 + uintptr(int32(17)+i))) = **(**uint8_t)(__ccgo_up((*VP8EncIterator)(unsafe.Pointer(it)).Fy_top + uintptr(i)))
 		goto _2
 	_2:
 		;
 		i = i + 1
 	}
 	// top-right samples have a special case on the far right of the picture
 	if (*VP8EncIterator)(unsafe.Pointer(it)).Fx < (*VP8Encoder)(unsafe.Pointer(enc)).Fmb_w-int32(1) {
 		i = int32(16)
 		for {
 			if !(i < libc.Int32FromInt32(16)+libc.Int32FromInt32(4)) {
 				break
 			}
 			**(**uint8_t)(__ccgo_up(it + 80 + uintptr(int32(17)+i))) = **(**uint8_t)(__ccgo_up((*VP8EncIterator)(unsafe.Pointer(it)).Fy_top + uintptr(i)))
 			goto _3
 		_3:
 			;
 			i = i + 1
 		}
 	} else { // else, replicate the last valid pixel four times
 		i = int32(16)
 		for {
 			if !(i < libc.Int32FromInt32(16)+libc.Int32FromInt32(4)) {
 				break
 			}
 			**(**uint8_t)(__ccgo_up(it + 80 + uintptr(int32(17)+i))) = **(**uint8_t)(__ccgo_up(it + 80 + uintptr(libc.Int32FromInt32(17)+libc.Int32FromInt32(15))))
 			goto _4
 		_4:
 			;
 			i = i + 1
 		}
 	}
 	VP8IteratorNzToBytes(tls, it) // import the non-zero context
 }
 
 func VP8IteratorRotateI4(tls *libc.TLS, it uintptr, yuv_out uintptr) (r int32) {
 	var blk, top uintptr
 	var i int32
 	_, _, _ = blk, i, top
 	blk = yuv_out + uintptr(VP8Scan[(*VP8EncIterator)(unsafe.Pointer(it)).Fi4])
 	top = (*VP8EncIterator)(unsafe.Pointer(it)).Fi4_top
 	// Update the cache with 7 fresh samples
 	i = 0
 	for {
 		if !(i <= int32(3)) {
 			break
 		}
 		**(**uint8_t)(__ccgo_up(top + uintptr(-int32(4)+i))) = **(**uint8_t)(__ccgo_up(blk + uintptr(i+libc.Int32FromInt32(3)*libc.Int32FromInt32(BPS)))) // store future top samples
 		goto _1
 	_1:
 		;
 		i = i + 1
 	}
 	if (*VP8EncIterator)(unsafe.Pointer(it)).Fi4&int32(3) != int32(3) { // if not on the right sub-blocks #3, #7, #11, #15
 		i = 0
 		for {
 			if !(i <= int32(2)) {
 				break
 			} // store future left samples
 			**(**uint8_t)(__ccgo_up(top + uintptr(i))) = **(**uint8_t)(__ccgo_up(blk + uintptr(int32(3)+(int32(2)-i)*int32(BPS))))
 			goto _2
 		_2:
 			;
 			i = i + 1
 		}
 	} else { // else replicate top-right samples, as says the specs.
 		i = 0
 		for {
 			if !(i <= int32(3)) {
 				break
 			}
 			**(**uint8_t)(__ccgo_up(top + uintptr(i))) = **(**uint8_t)(__ccgo_up(top + uintptr(i+int32(4))))
 			goto _3
 		_3:
 			;
 			i = i + 1
 		}
 	}
 	// move pointers to next sub-block
 	(*VP8EncIterator)(unsafe.Pointer(it)).Fi4 = (*VP8EncIterator)(unsafe.Pointer(it)).Fi4 + 1
 	if (*VP8EncIterator)(unsafe.Pointer(it)).Fi4 == int32(16) { // we're done
 		return 0
 	}
 	(*VP8EncIterator)(unsafe.Pointer(it)).Fi4_top = it + 80 + uintptr(VP8TopLeftI4[(*VP8EncIterator)(unsafe.Pointer(it)).Fi4])
 	return int32(1)
 }
 
 const MAX_LIMIT_BITS = 5
 const MIN_DIM_FOR_NEAR_LOSSLESS = 64
 
 //------------------------------------------------------------------------------
 
 // Copyright 2012 Google Inc. All Rights Reserved.
 //
 // Use of this source code is governed by a BSD-style license
 // that can be found in the COPYING file in the root of the source
 // tree. An additional intellectual property rights grant can be found
 // in the file PATENTS. All contributing project authors may
 // be found in the AUTHORS file in the root of the source tree.
 // -----------------------------------------------------------------------------
 //
 // Misc. common utility functions
 //
 // Authors: Skal (pascal.massimino@gmail.com)
 //          Urvang (urvang@google.com)
 
 // Copyright 2011 Google Inc. All Rights Reserved.
 //
 // Use of this source code is governed by a BSD-style license
 // that can be found in the COPYING file in the root of the source
 // tree. An additional intellectual property rights grant can be found
 // in the file PATENTS. All contributing project authors may
 // be found in the AUTHORS file in the root of the source tree.
 // -----------------------------------------------------------------------------
 //
 //   WebP encoder: main interface
 //
 // Author: Skal (pascal.massimino@gmail.com)
 
 // C documentation
 //
 //	// Quantizes the value up or down to a multiple of 1<<bits (or to 255),
 //	// choosing the closer one, resolving ties using bankers' rounding.
 func FindClosestDiscretized(tls *libc.TLS, a uint32_t, bits int32) (r uint32_t) {
 	var biased, mask uint32_t
 	_, _ = biased, mask
 	mask = uint32(1)<<bits - uint32(1)
 	biased = a + mask>>libc.Int32FromInt32(1) + a>>bits&uint32(1)
 	if biased > uint32(0xff) {
 		return uint32(0xff)
 	}
 	return biased & ^mask
 }
 
 // C documentation
 //
 //	// Applies FindClosestDiscretized to all channels of pixel.
 func ClosestDiscretizedArgb(tls *libc.TLS, a uint32_t, bits int32) (r uint32_t) {
 	return FindClosestDiscretized(tls, a>>int32(24), bits)<<libc.Int32FromInt32(24) | FindClosestDiscretized(tls, a>>libc.Int32FromInt32(16)&uint32(0xff), bits)<<libc.Int32FromInt32(16) | FindClosestDiscretized(tls, a>>libc.Int32FromInt32(8)&uint32(0xff), bits)<<libc.Int32FromInt32(8) | FindClosestDiscretized(tls, a&uint32(0xff), bits)
 }
 
 // C documentation
 //
 //	// Checks if distance between corresponding channel values of pixels a and b
 //	// is within the given limit.
 func IsNear(tls *libc.TLS, a uint32_t, b uint32_t, limit int32) (r int32) {
 	var delta, k int32
 	_, _ = delta, k
 	k = 0
 	for {
 		if !(k < int32(4)) {
 			break
 		}
 		delta = libc.Int32FromUint32(a>>(k*libc.Int32FromInt32(8))&libc.Uint32FromInt32(0xff)) - libc.Int32FromUint32(b>>(k*libc.Int32FromInt32(8))&libc.Uint32FromInt32(0xff))
 		if delta >= limit || delta <= -limit {
 			return 0
 		}
 		goto _1
 	_1:
 		;
 		k = k + 1
 	}
 	return int32(1)
 }
 
 func IsSmooth(tls *libc.TLS, prev_row uintptr, curr_row uintptr, next_row uintptr, ix int32, limit int32) (r int32) {
 	// Check that all pixels in 4-connected neighborhood are smooth.
 	return libc.BoolInt32(IsNear(tls, **(**uint32_t)(__ccgo_up(curr_row + uintptr(ix)*4)), **(**uint32_t)(__ccgo_up(curr_row + uintptr(ix-int32(1))*4)), limit) != 0 && IsNear(tls, **(**uint32_t)(__ccgo_up(curr_row + uintptr(ix)*4)), **(**uint32_t)(__ccgo_up(curr_row + uintptr(ix+int32(1))*4)), limit) != 0 && IsNear(tls, **(**uint32_t)(__ccgo_up(curr_row + uintptr(ix)*4)), **(**uint32_t)(__ccgo_up(prev_row + uintptr(ix)*4)), limit) != 0 && IsNear(tls, **(**uint32_t)(__ccgo_up(curr_row + uintptr(ix)*4)), **(**uint32_t)(__ccgo_up(next_row + uintptr(ix)*4)), limit) != 0)
 }
 
 // C documentation
 //
 //	// Adjusts pixel values of image with given maximum error.
 func NearLossless(tls *libc.TLS, xsize int32, ysize int32, argb_src uintptr, stride int32, limit_bits int32, copy_buffer uintptr, argb_dst uintptr) {
 	var curr_row, next_row, prev_row, temp uintptr
 	var limit, x, y int32
 	_, _, _, _, _, _, _ = curr_row, limit, next_row, prev_row, temp, x, y
 	limit = int32(1) << limit_bits
 	prev_row = copy_buffer
 	curr_row = prev_row + uintptr(xsize)*4
 	next_row = curr_row + uintptr(xsize)*4
 	libc.X__builtin___memcpy_chk(tls, curr_row, argb_src, libc.Uint64FromInt32(xsize)*uint64(4), ^__predefined_size_t(0))
 	libc.X__builtin___memcpy_chk(tls, next_row, argb_src+uintptr(stride)*4, libc.Uint64FromInt32(xsize)*uint64(4), ^__predefined_size_t(0))
 	y = 0
 	for {
 		if !(y < ysize) {
 			break
 		}
 		if y == 0 || y == ysize-int32(1) {
 			libc.X__builtin___memcpy_chk(tls, argb_dst, argb_src, libc.Uint64FromInt32(xsize)*uint64(4), ^__predefined_size_t(0))
 		} else {
 			libc.X__builtin___memcpy_chk(tls, next_row, argb_src+uintptr(stride)*4, libc.Uint64FromInt32(xsize)*uint64(4), ^__predefined_size_t(0))
 			**(**uint32_t)(__ccgo_up(argb_dst)) = **(**uint32_t)(__ccgo_up(argb_src))
 			**(**uint32_t)(__ccgo_up(argb_dst + uintptr(xsize-int32(1))*4)) = **(**uint32_t)(__ccgo_up(argb_src + uintptr(xsize-int32(1))*4))
 			x = int32(1)
 			for {
 				if !(x < xsize-int32(1)) {
 					break
 				}
 				if IsSmooth(tls, prev_row, curr_row, next_row, x, limit) != 0 {
 					**(**uint32_t)(__ccgo_up(argb_dst + uintptr(x)*4)) = **(**uint32_t)(__ccgo_up(curr_row + uintptr(x)*4))
 				} else {
 					**(**uint32_t)(__ccgo_up(argb_dst + uintptr(x)*4)) = ClosestDiscretizedArgb(tls, **(**uint32_t)(__ccgo_up(curr_row + uintptr(x)*4)), limit_bits)
 				}
 				goto _2
 			_2:
 				;
 				x = x + 1
 			}
 		}
 		// Three-way swap.
 		temp = prev_row
 		prev_row = curr_row
 		curr_row = next_row
 		next_row = temp
 		goto _1
 	_1:
 		;
 		y = y + 1
 		argb_src = argb_src + uintptr(stride)*4
 		argb_dst = argb_dst + uintptr(xsize)*4
 	}
 }
 
 func VP8ApplyNearLossless(tls *libc.TLS, picture uintptr, quality int32, argb_dst uintptr) (r int32) {
 	var copy_buffer uintptr
 	var i, limit_bits, stride, xsize, ysize, v1 int32
 	_, _, _, _, _, _, _ = copy_buffer, i, limit_bits, stride, xsize, ysize, v1
 	xsize = (*WebPPicture)(unsafe.Pointer(picture)).Fwidth
 	ysize = (*WebPPicture)(unsafe.Pointer(picture)).Fheight
 	stride = (*WebPPicture)(unsafe.Pointer(picture)).Fargb_stride
 	copy_buffer = WebPSafeMalloc(tls, libc.Uint64FromInt32(xsize*int32(3)), uint64(4))
 	v1 = int32(5) - quality/int32(20)
 	goto _2
 _2:
 	limit_bits = v1
 	if copy_buffer == libc.UintptrFromInt32(0) {
 		return 0
 	}
 	// For small icon images, don't attempt to apply near-lossless compression.
 	if xsize < int32(MIN_DIM_FOR_NEAR_LOSSLESS) && ysize < int32(MIN_DIM_FOR_NEAR_LOSSLESS) || ysize < int32(3) {
 		i = 0
 		for {
 			if !(i < ysize) {
 				break
 			}
 			libc.X__builtin___memcpy_chk(tls, argb_dst+uintptr(i*xsize)*4, (*WebPPicture)(unsafe.Pointer(picture)).Fargb+uintptr(i*(*WebPPicture)(unsafe.Pointer(picture)).Fargb_stride)*4, libc.Uint64FromInt32(xsize)*uint64(4), ^__predefined_size_t(0))
 			goto _3
 		_3:
 			;
 			i = i + 1
 		}
 		WebPSafeFree(tls, copy_buffer)
 		return int32(1)
 	}
 	NearLossless(tls, xsize, ysize, (*WebPPicture)(unsafe.Pointer(picture)).Fargb, stride, limit_bits, copy_buffer, argb_dst)
 	i = limit_bits - int32(1)
 	for {
 		if !(i != 0) {
 			break
 		}
 		NearLossless(tls, xsize, ysize, argb_dst, xsize, i, copy_buffer, argb_dst)
 		goto _4
 	_4:
 		;
 		i = i - 1
 	}
 	WebPSafeFree(tls, copy_buffer)
 	return int32(1)
 }
 
 const GAMMA_FIX = 12
 const GAMMA_TAB_FIX = 7
 const SHARPYUV_INLINE = "inline"
 const SHARPYUV_VERSION_MAJOR = 0
 const SHARPYUV_VERSION_MINOR = 4
 const SHARPYUV_VERSION_PATCH = 2
 const __FLT_MIN__3 = 1.1754943508222875e-38
 
 type SharpYuvConversionMatrix = struct {
 	Frgb_to_y [4]int32
 	Frgb_to_u [4]int32
 	Frgb_to_v [4]int32
 }
 
 type SharpYuvOptions = struct {
 	Fyuv_matrix    uintptr
 	Ftransfer_type SharpYuvTransferFunctionType1
 }
 
 type SharpYuvTransferFunctionType = int32
 
 const kSharpYuvTransferFunctionBt709 = 1
 const kSharpYuvTransferFunctionBt470M = 4
 const kSharpYuvTransferFunctionBt470Bg = 5
 const kSharpYuvTransferFunctionBt601 = 6
 const kSharpYuvTransferFunctionSmpte240 = 7
 const kSharpYuvTransferFunctionLinear = 8
 const kSharpYuvTransferFunctionLog100 = 9
 const kSharpYuvTransferFunctionLog100_Sqrt10 = 10
 const kSharpYuvTransferFunctionIec61966 = 11
 const kSharpYuvTransferFunctionBt1361 = 12
 const kSharpYuvTransferFunctionSrgb = 13
 const kSharpYuvTransferFunctionBt2020_10Bit = 14
 const kSharpYuvTransferFunctionBt2020_12Bit = 15
 const kSharpYuvTransferFunctionSmpte2084 = 16
 const kSharpYuvTransferFunctionSmpte428 = 17
 const kSharpYuvTransferFunctionHlg = 18
 const kSharpYuvTransferFunctionNum = 19
 
 type SharpYuvTransferFunctionType1 = int32
 
 type SharpYuvRange = int32
 
 const kSharpYuvRangeFull = 0
 const kSharpYuvRangeLimited = 1
 
 type SharpYuvColorSpace = struct {
 	Fkr        float32
 	Fkb        float32
 	Fbit_depth int32
 	Frange1    SharpYuvRange
 }
 
 type SharpYuvMatrixType = int32
 
 const kSharpYuvMatrixWebp = 0
 const kSharpYuvMatrixRec601Limited = 1
 const kSharpYuvMatrixRec601Full = 2
 const kSharpYuvMatrixRec709Limited = 3
 const kSharpYuvMatrixRec709Full = 4
 const kSharpYuvMatrixNum = 5
 
 // Copyright 2012 Google Inc. All Rights Reserved.
 //
 // Use of this source code is governed by a BSD-style license
 // that can be found in the COPYING file in the root of the source
 // tree. An additional intellectual property rights grant can be found
 // in the file PATENTS. All contributing project authors may
 // be found in the AUTHORS file in the root of the source tree.
 // -----------------------------------------------------------------------------
 //
 // Misc. common utility functions
 //
 // Authors: Skal (pascal.massimino@gmail.com)
 //          Urvang (urvang@google.com)
 
 // Copyright 2011 Google Inc. All Rights Reserved.
 //
 // Use of this source code is governed by a BSD-style license
 // that can be found in the COPYING file in the root of the source
 // tree. An additional intellectual property rights grant can be found
 // in the file PATENTS. All contributing project authors may
 // be found in the AUTHORS file in the root of the source tree.
 // -----------------------------------------------------------------------------
 //
 //   WebP encoder: main interface
 //
 // Author: Skal (pascal.massimino@gmail.com)
 
 // Copyright 2010 Google Inc. All Rights Reserved.
 //
 // Use of this source code is governed by a BSD-style license
 // that can be found in the COPYING file in the root of the source
 // tree. An additional intellectual property rights grant can be found
 // in the file PATENTS. All contributing project authors may
 // be found in the AUTHORS file in the root of the source tree.
 // -----------------------------------------------------------------------------
 //
 //  Common types + memory wrappers
 //
 // Author: Skal (pascal.massimino@gmail.com)
 
 // Uncomment to disable gamma-compression during RGB->U/V averaging
 
 // If defined, use table to compute x / alpha.
 
 // uint32_t 0xff000000 is 0x00,00,00,ff in memory
 
 //------------------------------------------------------------------------------
 // Detection of non-trivial transparency
 
 // C documentation
 //
 //	// Returns true if alpha[] has non-0xff values.
 func CheckNonOpaque(tls *libc.TLS, alpha uintptr, width int32, height int32, x_step int32, y_step int32) (r int32) {
 	var v2 int32
 	_ = v2
 	if alpha == libc.UintptrFromInt32(0) {
 		return 0
 	}
 	WebPInitAlphaProcessing(tls)
 	if x_step == int32(1) {
 		for {
 			v2 = height
 			height = height - 1
 			if !(v2 > 0) {
 				break
 			}
 			if (*(*func(*libc.TLS, uintptr, int32) int32)(unsafe.Pointer(&struct{ uintptr }{WebPHasAlpha8b})))(tls, alpha, width) != 0 {
 				return int32(1)
 			}
 			goto _1
 		_1:
 			;
 			alpha = alpha + uintptr(y_step)
 		}
 	} else {
 		for {
 			v2 = height
 			height = height - 1
 			if !(v2 > 0) {
 				break
 			}
 			if (*(*func(*libc.TLS, uintptr, int32) int32)(unsafe.Pointer(&struct{ uintptr }{WebPHasAlpha32b})))(tls, alpha, width) != 0 {
 				return int32(1)
 			}
 			goto _3
 		_3:
 			;
 			alpha = alpha + uintptr(y_step)
 		}
 	}
 	return 0
 }
 
 // C documentation
 //
 //	// Checking for the presence of non-opaque alpha.
 func WebPPictureHasTransparency(tls *libc.TLS, picture uintptr) (r int32) {
 	if picture == libc.UintptrFromInt32(0) {
 		return 0
 	}
 	if (*WebPPicture)(unsafe.Pointer(picture)).Fuse_argb != 0 {
 		if (*WebPPicture)(unsafe.Pointer(picture)).Fargb != libc.UintptrFromInt32(0) {
 			return CheckNonOpaque(tls, (*WebPPicture)(unsafe.Pointer(picture)).Fargb+uintptr(libc.Int32FromInt32(3)-libc.Int32FromInt32(0)), (*WebPPicture)(unsafe.Pointer(picture)).Fwidth, (*WebPPicture)(unsafe.Pointer(picture)).Fheight, int32(4), libc.Int32FromUint64(libc.Uint64FromInt32((*WebPPicture)(unsafe.Pointer(picture)).Fargb_stride)*uint64(4)))
 		}
 		return 0
 	}
 	return CheckNonOpaque(tls, (*WebPPicture)(unsafe.Pointer(picture)).Fa, (*WebPPicture)(unsafe.Pointer(picture)).Fwidth, (*WebPPicture)(unsafe.Pointer(picture)).Fheight, int32(1), (*WebPPicture)(unsafe.Pointer(picture)).Fa_stride)
 }
 
 //------------------------------------------------------------------------------
 // Code for gamma correction
 
 // C documentation
 //
 //	// Gamma correction compensates loss of resolution during chroma subsampling.
 var kGamma = float64(0.8)
 var kGammaScale = libc.Int32FromInt32(1)<<libc.Int32FromInt32(GAMMA_FIX) - libc.Int32FromInt32(1)
 var kGammaTabScale = libc.Int32FromInt32(1) << libc.Int32FromInt32(GAMMA_TAB_FIX)
 var kGammaTabRounder = libc.Int32FromInt32(1) << libc.Int32FromInt32(GAMMA_TAB_FIX) >> libc.Int32FromInt32(1)
 
 var kLinearToGammaTab [33]int32
 var kGammaToLinearTab [256]uint16_t
 var kGammaTablesOk = int32(0)
 
 func InitGammaTables(tls *libc.TLS) {
 	if libc.AtomicLoadPUintptr(uintptr(unsafe.Pointer(&InitGammaTables_body_last_cpuinfo_used))) == VP8GetCPUInfo {
 		goto _1
 	}
 	InitGammaTables_body(tls)
 	libc.AtomicStorePUintptr(uintptr(unsafe.Pointer(&InitGammaTables_body_last_cpuinfo_used)), VP8GetCPUInfo)
 	goto _2
 _2:
 	;
 	goto _1
 _1: /**/ //
 }
 
 var InitGammaTables_body_last_cpuinfo_used = uintptr(0)
 
 func init() {
 	p := unsafe.Pointer(&InitGammaTables_body_last_cpuinfo_used)
 	*(*uintptr)(unsafe.Add(p, 0)) = uintptr(unsafe.Pointer(&InitGammaTables_body_last_cpuinfo_used))
 }
 
 func InitGammaTables_body(tls *libc.TLS) {
 	var norm, scale float64
 	var v int32
 	_, _, _ = norm, scale, v
 	if !(libc.AtomicLoadPInt32(uintptr(unsafe.Pointer(&kGammaTablesOk))) != 0) {
 		scale = float64(libc.Int32FromInt32(1)<<libc.Int32FromInt32(GAMMA_TAB_FIX)) / float64(kGammaScale)
 		norm = libc.Float64FromFloat64(1) / libc.Float64FromFloat64(255)
 		v = 0
 		for {
 			if !(v <= int32(255)) {
 				break
 			}
 			kGammaToLinearTab[v] = uint16(float64(libc.Xpow(tls, float64(norm*float64(v)), kGamma)*float64(kGammaScale)) + libc.Float64FromFloat64(0.5))
 			goto _1
 		_1:
 			;
 			v = v + 1
 		}
 		v = 0
 		for {
 			if !(v <= libc.Int32FromInt32(1)<<(libc.Int32FromInt32(GAMMA_FIX)-libc.Int32FromInt32(GAMMA_TAB_FIX))) {
 				break
 			}
 			kLinearToGammaTab[v] = int32(float64(libc.Float64FromFloat64(255)*libc.Xpow(tls, float64(scale*float64(v)), float64(1)/kGamma)) + libc.Float64FromFloat64(0.5))
 			goto _2
 		_2:
 			;
 			v = v + 1
 		}
 		libc.AtomicStorePInt32(uintptr(unsafe.Pointer(&kGammaTablesOk)), int32(1))
 	}
 }
 
 func GammaToLinear(tls *libc.TLS, v uint8_t) (r uint32_t) {
 	return uint32(kGammaToLinearTab[v])
 }
 
 func Interpolate(tls *libc.TLS, v int32) (r int32) {
 	var tab_pos, v0, v1, x, y int32
 	_, _, _, _, _ = tab_pos, v0, v1, x, y
 	tab_pos = v >> (libc.Int32FromInt32(GAMMA_TAB_FIX) + libc.Int32FromInt32(2)) // integer part
 	x = v & (kGammaTabScale<<libc.Int32FromInt32(2) - int32(1))                  // fractional part
 	v0 = kLinearToGammaTab[tab_pos]
 	v1 = kLinearToGammaTab[tab_pos+int32(1)]
 	y = v1*x + v0*(kGammaTabScale<<libc.Int32FromInt32(2)-x) // interpolate
 	return y
 }
 
 // C documentation
 //
 //	// Convert a linear value 'v' to YUV_FIX+2 fixed-point precision
 //	// U/V value, suitable for RGBToU/V calls.
 func LinearToGamma(tls *libc.TLS, base_value uint32_t, shift int32) (r int32) {
 	var y int32
 	_ = y
 	y = Interpolate(tls, libc.Int32FromUint32(base_value<<shift)) // final uplifted value
 	return (y + kGammaTabRounder) >> int32(GAMMA_TAB_FIX)         // descale
 }
 
 //------------------------------------------------------------------------------
 // RGB -> YUV conversion
 
 func RGBToY(tls *libc.TLS, r1 int32, g1 int32, b1 int32, rg2 uintptr) (r int32) {
 	var diff, luma, v1, v11, v13, v15, v2, v5, v8, v9 int32
 	var v10, v12, v4, v7 uintptr
 	_, _, _, _, _, _, _, _, _, _, _, _, _, _ = diff, luma, v1, v10, v11, v12, v13, v15, v2, v4, v5, v7, v8, v9
 	if rg2 == libc.UintptrFromInt32(0) {
 		luma = int32(16839)*r1 + int32(33059)*g1 + int32(6420)*b1
 		v2 = (luma + int32(YUV_HALF) + libc.Int32FromInt32(16)<<int32(YUV_FIX)) >> int32(YUV_FIX)
 		goto _3
 	_3:
 		v1 = v2
 	} else {
 		v4 = rg2
 		v7 = v4
 		v8 = int32(YUV_FIX)
 		diff = libc.Int32FromUint32(**(**uint32_t)(__ccgo_up(v7 + 8 + uintptr((*VP8Random)(unsafe.Pointer(v7)).Findex1)*4)) - **(**uint32_t)(__ccgo_up(v7 + 8 + uintptr((*VP8Random)(unsafe.Pointer(v7)).Findex2)*4)))
 		if diff < libc.Int32FromInt32(0) {
 			diff = libc.Int32FromUint32(uint32(diff) + libc.Uint32FromUint32(1)<<libc.Int32FromInt32(31))
 		}
 		**(**uint32_t)(__ccgo_up(v7 + 8 + uintptr((*VP8Random)(unsafe.Pointer(v7)).Findex1)*4)) = libc.Uint32FromInt32(diff)
 		v10 = v7
 		*(*int32)(unsafe.Pointer(v10)) = *(*int32)(unsafe.Pointer(v10)) + 1
 		v9 = *(*int32)(unsafe.Pointer(v10))
 		if v9 == libc.Int32FromInt32(VP8_RANDOM_TABLE_SIZE) {
 			(*VP8Random)(unsafe.Pointer(v7)).Findex1 = 0
 		}
 		v12 = v7 + 4
 		*(*int32)(unsafe.Pointer(v12)) = *(*int32)(unsafe.Pointer(v12)) + 1
 		v11 = *(*int32)(unsafe.Pointer(v12))
 		if v11 == libc.Int32FromInt32(VP8_RANDOM_TABLE_SIZE) {
 			(*VP8Random)(unsafe.Pointer(v7)).Findex2 = 0
 		}
 		diff = libc.Int32FromUint32(libc.Uint32FromInt32(diff)<<libc.Int32FromInt32(1)) >> (int32(32) - v8)
 		diff = diff * (*VP8Random)(unsafe.Pointer(v4)).Famp >> int32(VP8_RANDOM_DITHER_FIX)
 		diff = diff + int32(1)<<(v8-int32(1))
 		v13 = diff
 		goto _14
 	_14:
 		v5 = v13
 		goto _6
 	_6:
 		luma = int32(16839)*r1 + int32(33059)*g1 + int32(6420)*b1
 		v15 = (luma + v5 + libc.Int32FromInt32(16)<<int32(YUV_FIX)) >> int32(YUV_FIX)
 		goto _16
 	_16:
 		v1 = v15
 	}
 	return v1
 }
 
 func RGBToU(tls *libc.TLS, r1 int32, g1 int32, b1 int32, rg2 uintptr) (r int32) {
 	var diff, u, v1, v10, v13, v14, v16, v18, v2, v20, v22, v23, v25, v26, v4, v5, v7, v8 int32
 	var v12, v15, v17, v9 uintptr
 	_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = diff, u, v1, v10, v12, v13, v14, v15, v16, v17, v18, v2, v20, v22, v23, v25, v26, v4, v5, v7, v8, v9
 	if rg2 == libc.UintptrFromInt32(0) {
 		u = -int32(9719)*r1 - int32(19081)*g1 + int32(28800)*b1
 		v4 = u
 		v4 = (v4 + int32(YUV_HALF)<<libc.Int32FromInt32(2) + libc.Int32FromInt32(128)<<(int32(YUV_FIX)+libc.Int32FromInt32(2))) >> (int32(YUV_FIX) + libc.Int32FromInt32(2))
 		if v4 & ^libc.Int32FromInt32(0xff) == 0 {
 			v7 = v4
 		} else {
 			if v4 < 0 {
 				v8 = 0
 			} else {
 				v8 = int32(255)
 			}
 			v7 = v8
 		}
 		v5 = v7
 		goto _6
 	_6:
 		v2 = v5
 		goto _3
 	_3:
 		v1 = v2
 	} else {
 		v9 = rg2
 		v12 = v9
 		v13 = int32(YUV_FIX) + libc.Int32FromInt32(2)
 		diff = libc.Int32FromUint32(**(**uint32_t)(__ccgo_up(v12 + 8 + uintptr((*VP8Random)(unsafe.Pointer(v12)).Findex1)*4)) - **(**uint32_t)(__ccgo_up(v12 + 8 + uintptr((*VP8Random)(unsafe.Pointer(v12)).Findex2)*4)))
 		if diff < libc.Int32FromInt32(0) {
 			diff = libc.Int32FromUint32(uint32(diff) + libc.Uint32FromUint32(1)<<libc.Int32FromInt32(31))
 		}
 		**(**uint32_t)(__ccgo_up(v12 + 8 + uintptr((*VP8Random)(unsafe.Pointer(v12)).Findex1)*4)) = libc.Uint32FromInt32(diff)
 		v15 = v12
 		*(*int32)(unsafe.Pointer(v15)) = *(*int32)(unsafe.Pointer(v15)) + 1
 		v14 = *(*int32)(unsafe.Pointer(v15))
 		if v14 == libc.Int32FromInt32(VP8_RANDOM_TABLE_SIZE) {
 			(*VP8Random)(unsafe.Pointer(v12)).Findex1 = 0
 		}
 		v17 = v12 + 4
 		*(*int32)(unsafe.Pointer(v17)) = *(*int32)(unsafe.Pointer(v17)) + 1
 		v16 = *(*int32)(unsafe.Pointer(v17))
 		if v16 == libc.Int32FromInt32(VP8_RANDOM_TABLE_SIZE) {
 			(*VP8Random)(unsafe.Pointer(v12)).Findex2 = 0
 		}
 		diff = libc.Int32FromUint32(libc.Uint32FromInt32(diff)<<libc.Int32FromInt32(1)) >> (int32(32) - v13)
 		diff = diff * (*VP8Random)(unsafe.Pointer(v9)).Famp >> int32(VP8_RANDOM_DITHER_FIX)
 		diff = diff + int32(1)<<(v13-int32(1))
 		v18 = diff
 		goto _19
 	_19:
 		v10 = v18
 		goto _11
 	_11:
 		u = -int32(9719)*r1 - int32(19081)*g1 + int32(28800)*b1
 		v22 = u
 		v22 = (v22 + v10 + libc.Int32FromInt32(128)<<(int32(YUV_FIX)+libc.Int32FromInt32(2))) >> (int32(YUV_FIX) + libc.Int32FromInt32(2))
 		if v22 & ^libc.Int32FromInt32(0xff) == 0 {
 			v25 = v22
 		} else {
 			if v22 < 0 {
 				v26 = 0
 			} else {
 				v26 = int32(255)
 			}
 			v25 = v26
 		}
 		v23 = v25
 		goto _24
 	_24:
 		v20 = v23
 		goto _21
 	_21:
 		v1 = v20
 	}
 	return v1
 }
 
 func RGBToV(tls *libc.TLS, r1 int32, g1 int32, b1 int32, rg2 uintptr) (r int32) {
 	var diff, v, v1, v10, v13, v14, v16, v18, v2, v20, v22, v23, v25, v26, v4, v5, v7, v8 int32
 	var v12, v15, v17, v9 uintptr
 	_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = diff, v, v1, v10, v12, v13, v14, v15, v16, v17, v18, v2, v20, v22, v23, v25, v26, v4, v5, v7, v8, v9
 	if rg2 == libc.UintptrFromInt32(0) {
 		v = +libc.Int32FromInt32(28800)*r1 - int32(24116)*g1 - int32(4684)*b1
 		v4 = v
 		v4 = (v4 + int32(YUV_HALF)<<libc.Int32FromInt32(2) + libc.Int32FromInt32(128)<<(int32(YUV_FIX)+libc.Int32FromInt32(2))) >> (int32(YUV_FIX) + libc.Int32FromInt32(2))
 		if v4 & ^libc.Int32FromInt32(0xff) == 0 {
 			v7 = v4
 		} else {
 			if v4 < 0 {
 				v8 = 0
 			} else {
 				v8 = int32(255)
 			}
 			v7 = v8
 		}
 		v5 = v7
 		goto _6
 	_6:
 		v2 = v5
 		goto _3
 	_3:
 		v1 = v2
 	} else {
 		v9 = rg2
 		v12 = v9
 		v13 = int32(YUV_FIX) + libc.Int32FromInt32(2)
 		diff = libc.Int32FromUint32(**(**uint32_t)(__ccgo_up(v12 + 8 + uintptr((*VP8Random)(unsafe.Pointer(v12)).Findex1)*4)) - **(**uint32_t)(__ccgo_up(v12 + 8 + uintptr((*VP8Random)(unsafe.Pointer(v12)).Findex2)*4)))
 		if diff < libc.Int32FromInt32(0) {
 			diff = libc.Int32FromUint32(uint32(diff) + libc.Uint32FromUint32(1)<<libc.Int32FromInt32(31))
 		}
 		**(**uint32_t)(__ccgo_up(v12 + 8 + uintptr((*VP8Random)(unsafe.Pointer(v12)).Findex1)*4)) = libc.Uint32FromInt32(diff)
 		v15 = v12
 		*(*int32)(unsafe.Pointer(v15)) = *(*int32)(unsafe.Pointer(v15)) + 1
 		v14 = *(*int32)(unsafe.Pointer(v15))
 		if v14 == libc.Int32FromInt32(VP8_RANDOM_TABLE_SIZE) {
 			(*VP8Random)(unsafe.Pointer(v12)).Findex1 = 0
 		}
 		v17 = v12 + 4
 		*(*int32)(unsafe.Pointer(v17)) = *(*int32)(unsafe.Pointer(v17)) + 1
 		v16 = *(*int32)(unsafe.Pointer(v17))
 		if v16 == libc.Int32FromInt32(VP8_RANDOM_TABLE_SIZE) {
 			(*VP8Random)(unsafe.Pointer(v12)).Findex2 = 0
 		}
 		diff = libc.Int32FromUint32(libc.Uint32FromInt32(diff)<<libc.Int32FromInt32(1)) >> (int32(32) - v13)
 		diff = diff * (*VP8Random)(unsafe.Pointer(v9)).Famp >> int32(VP8_RANDOM_DITHER_FIX)
 		diff = diff + int32(1)<<(v13-int32(1))
 		v18 = diff
 		goto _19
 	_19:
 		v10 = v18
 		goto _11
 	_11:
 		v = +libc.Int32FromInt32(28800)*r1 - int32(24116)*g1 - int32(4684)*b1
 		v22 = v
 		v22 = (v22 + v10 + libc.Int32FromInt32(128)<<(int32(YUV_FIX)+libc.Int32FromInt32(2))) >> (int32(YUV_FIX) + libc.Int32FromInt32(2))
 		if v22 & ^libc.Int32FromInt32(0xff) == 0 {
 			v25 = v22
 		} else {
 			if v22 < 0 {
 				v26 = 0
 			} else {
 				v26 = int32(255)
 			}
 			v25 = v26
 		}
 		v23 = v25
 		goto _24
 	_24:
 		v20 = v23
 		goto _21
 	_21:
 		v1 = v20
 	}
 	return v1
 }
 
 //------------------------------------------------------------------------------
 // Sharp RGB->YUV conversion
 
 var kMinDimensionIterativeConversion = int32(4)
 
 //------------------------------------------------------------------------------
 // Main function
 
 func PreprocessARGB(tls *libc.TLS, r_ptr uintptr, g_ptr uintptr, b_ptr uintptr, step int32, rgb_stride int32, picture uintptr) (r int32) {
 	var ok int32
 	_ = ok
 	ok = SharpYuvConvert(tls, r_ptr, g_ptr, b_ptr, step, rgb_stride, int32(8), (*WebPPicture)(unsafe.Pointer(picture)).Fy, (*WebPPicture)(unsafe.Pointer(picture)).Fy_stride, (*WebPPicture)(unsafe.Pointer(picture)).Fu, (*WebPPicture)(unsafe.Pointer(picture)).Fuv_stride, (*WebPPicture)(unsafe.Pointer(picture)).Fv, (*WebPPicture)(unsafe.Pointer(picture)).Fuv_stride, int32(8), (*WebPPicture)(unsafe.Pointer(picture)).Fwidth, (*WebPPicture)(unsafe.Pointer(picture)).Fheight, SharpYuvGetConversionMatrix(tls, int32(kSharpYuvMatrixWebp)))
 	if !(ok != 0) {
 		return WebPEncodingSetError(tls, picture, int32(VP8_ENC_ERROR_OUT_OF_MEMORY))
 	}
 	return ok
 }
 
 //------------------------------------------------------------------------------
 // "Fast" regular RGB->YUV
 
 var kAlphaFix = int32(19)
 
 // C documentation
 //
 //	// Following table is (1 << kAlphaFix) / a. The (v * kInvAlpha[a]) >> kAlphaFix
 //	// formula is then equal to v / a in most (99.6%) cases. Note that this table
 //	// and constant are adjusted very tightly to fit 32b arithmetic.
 //	// In particular, they use the fact that the operands for 'v / a' are actually
 //	// derived as v = (a0.p0 + a1.p1 + a2.p2 + a3.p3) and a = a0 + a1 + a2 + a3
 //	// with ai in [0..255] and pi in [0..1<<GAMMA_FIX). The constraint to avoid
 //	// overflow is: GAMMA_FIX + kAlphaFix <= 31.
 var kInvAlpha = [1021]uint32_t{
 	1:    uint32(524288),
 	2:    uint32(262144),
 	3:    uint32(174762),
 	4:    uint32(131072),
 	5:    uint32(104857),
 	6:    uint32(87381),
 	7:    uint32(74898),
 	8:    uint32(65536),
 	9:    uint32(58254),
 	10:   uint32(52428),
 	11:   uint32(47662),
 	12:   uint32(43690),
 	13:   uint32(40329),
 	14:   uint32(37449),
 	15:   uint32(34952),
 	16:   uint32(32768),
 	17:   uint32(30840),
 	18:   uint32(29127),
 	19:   uint32(27594),
 	20:   uint32(26214),
 	21:   uint32(24966),
 	22:   uint32(23831),
 	23:   uint32(22795),
 	24:   uint32(21845),
 	25:   uint32(20971),
 	26:   uint32(20164),
 	27:   uint32(19418),
 	28:   uint32(18724),
 	29:   uint32(18078),
 	30:   uint32(17476),
 	31:   uint32(16912),
 	32:   uint32(16384),
 	33:   uint32(15887),
 	34:   uint32(15420),
 	35:   uint32(14979),
 	36:   uint32(14563),
 	37:   uint32(14169),
 	38:   uint32(13797),
 	39:   uint32(13443),
 	40:   uint32(13107),
 	41:   uint32(12787),
 	42:   uint32(12483),
 	43:   uint32(12192),
 	44:   uint32(11915),
 	45:   uint32(11650),
 	46:   uint32(11397),
 	47:   uint32(11155),
 	48:   uint32(10922),
 	49:   uint32(10699),
 	50:   uint32(10485),
 	51:   uint32(10280),
 	52:   uint32(10082),
 	53:   uint32(9892),
 	54:   uint32(9709),
 	55:   uint32(9532),
 	56:   uint32(9362),
 	57:   uint32(9198),
 	58:   uint32(9039),
 	59:   uint32(8886),
 	60:   uint32(8738),
 	61:   uint32(8594),
 	62:   uint32(8456),
 	63:   uint32(8322),
 	64:   uint32(8192),
 	65:   uint32(8065),
 	66:   uint32(7943),
 	67:   uint32(7825),
 	68:   uint32(7710),
 	69:   uint32(7598),
 	70:   uint32(7489),
 	71:   uint32(7384),
 	72:   uint32(7281),
 	73:   uint32(7182),
 	74:   uint32(7084),
 	75:   uint32(6990),
 	76:   uint32(6898),
 	77:   uint32(6808),
 	78:   uint32(6721),
 	79:   uint32(6636),
 	80:   uint32(6553),
 	81:   uint32(6472),
 	82:   uint32(6393),
 	83:   uint32(6316),
 	84:   uint32(6241),
 	85:   uint32(6168),
 	86:   uint32(6096),
 	87:   uint32(6026),
 	88:   uint32(5957),
 	89:   uint32(5890),
 	90:   uint32(5825),
 	91:   uint32(5761),
 	92:   uint32(5698),
 	93:   uint32(5637),
 	94:   uint32(5577),
 	95:   uint32(5518),
 	96:   uint32(5461),
 	97:   uint32(5405),
 	98:   uint32(5349),
 	99:   uint32(5295),
 	100:  uint32(5242),
 	101:  uint32(5190),
 	102:  uint32(5140),
 	103:  uint32(5090),
 	104:  uint32(5041),
 	105:  uint32(4993),
 	106:  uint32(4946),
 	107:  uint32(4899),
 	108:  uint32(4854),
 	109:  uint32(4809),
 	110:  uint32(4766),
 	111:  uint32(4723),
 	112:  uint32(4681),
 	113:  uint32(4639),
 	114:  uint32(4599),
 	115:  uint32(4559),
 	116:  uint32(4519),
 	117:  uint32(4481),
 	118:  uint32(4443),
 	119:  uint32(4405),
 	120:  uint32(4369),
 	121:  uint32(4332),
 	122:  uint32(4297),
 	123:  uint32(4262),
 	124:  uint32(4228),
 	125:  uint32(4194),
 	126:  uint32(4161),
 	127:  uint32(4128),
 	128:  uint32(4096),
 	129:  uint32(4064),
 	130:  uint32(4032),
 	131:  uint32(4002),
 	132:  uint32(3971),
 	133:  uint32(3942),
 	134:  uint32(3912),
 	135:  uint32(3883),
 	136:  uint32(3855),
 	137:  uint32(3826),
 	138:  uint32(3799),
 	139:  uint32(3771),
 	140:  uint32(3744),
 	141:  uint32(3718),
 	142:  uint32(3692),
 	143:  uint32(3666),
 	144:  uint32(3640),
 	145:  uint32(3615),
 	146:  uint32(3591),
 	147:  uint32(3566),
 	148:  uint32(3542),
 	149:  uint32(3518),
 	150:  uint32(3495),
 	151:  uint32(3472),
 	152:  uint32(3449),
 	153:  uint32(3426),
 	154:  uint32(3404),
 	155:  uint32(3382),
 	156:  uint32(3360),
 	157:  uint32(3339),
 	158:  uint32(3318),
 	159:  uint32(3297),
 	160:  uint32(3276),
 	161:  uint32(3256),
 	162:  uint32(3236),
 	163:  uint32(3216),
 	164:  uint32(3196),
 	165:  uint32(3177),
 	166:  uint32(3158),
 	167:  uint32(3139),
 	168:  uint32(3120),
 	169:  uint32(3102),
 	170:  uint32(3084),
 	171:  uint32(3066),
 	172:  uint32(3048),
 	173:  uint32(3030),
 	174:  uint32(3013),
 	175:  uint32(2995),
 	176:  uint32(2978),
 	177:  uint32(2962),
 	178:  uint32(2945),
 	179:  uint32(2928),
 	180:  uint32(2912),
 	181:  uint32(2896),
 	182:  uint32(2880),
 	183:  uint32(2864),
 	184:  uint32(2849),
 	185:  uint32(2833),
 	186:  uint32(2818),
 	187:  uint32(2803),
 	188:  uint32(2788),
 	189:  uint32(2774),
 	190:  uint32(2759),
 	191:  uint32(2744),
 	192:  uint32(2730),
 	193:  uint32(2716),
 	194:  uint32(2702),
 	195:  uint32(2688),
 	196:  uint32(2674),
 	197:  uint32(2661),
 	198:  uint32(2647),
 	199:  uint32(2634),
 	200:  uint32(2621),
 	201:  uint32(2608),
 	202:  uint32(2595),
 	203:  uint32(2582),
 	204:  uint32(2570),
 	205:  uint32(2557),
 	206:  uint32(2545),
 	207:  uint32(2532),
 	208:  uint32(2520),
 	209:  uint32(2508),
 	210:  uint32(2496),
 	211:  uint32(2484),
 	212:  uint32(2473),
 	213:  uint32(2461),
 	214:  uint32(2449),
 	215:  uint32(2438),
 	216:  uint32(2427),
 	217:  uint32(2416),
 	218:  uint32(2404),
 	219:  uint32(2394),
 	220:  uint32(2383),
 	221:  uint32(2372),
 	222:  uint32(2361),
 	223:  uint32(2351),
 	224:  uint32(2340),
 	225:  uint32(2330),
 	226:  uint32(2319),
 	227:  uint32(2309),
 	228:  uint32(2299),
 	229:  uint32(2289),
 	230:  uint32(2279),
 	231:  uint32(2269),
 	232:  uint32(2259),
 	233:  uint32(2250),
 	234:  uint32(2240),
 	235:  uint32(2231),
 	236:  uint32(2221),
 	237:  uint32(2212),
 	238:  uint32(2202),
 	239:  uint32(2193),
 	240:  uint32(2184),
 	241:  uint32(2175),
 	242:  uint32(2166),
 	243:  uint32(2157),
 	244:  uint32(2148),
 	245:  uint32(2139),
 	246:  uint32(2131),
 	247:  uint32(2122),
 	248:  uint32(2114),
 	249:  uint32(2105),
 	250:  uint32(2097),
 	251:  uint32(2088),
 	252:  uint32(2080),
 	253:  uint32(2072),
 	254:  uint32(2064),
 	255:  uint32(2056),
 	256:  uint32(2048),
 	257:  uint32(2040),
 	258:  uint32(2032),
 	259:  uint32(2024),
 	260:  uint32(2016),
 	261:  uint32(2008),
 	262:  uint32(2001),
 	263:  uint32(1993),
 	264:  uint32(1985),
 	265:  uint32(1978),
 	266:  uint32(1971),
 	267:  uint32(1963),
 	268:  uint32(1956),
 	269:  uint32(1949),
 	270:  uint32(1941),
 	271:  uint32(1934),
 	272:  uint32(1927),
 	273:  uint32(1920),
 	274:  uint32(1913),
 	275:  uint32(1906),
 	276:  uint32(1899),
 	277:  uint32(1892),
 	278:  uint32(1885),
 	279:  uint32(1879),
 	280:  uint32(1872),
 	281:  uint32(1865),
 	282:  uint32(1859),
 	283:  uint32(1852),
 	284:  uint32(1846),
 	285:  uint32(1839),
 	286:  uint32(1833),
 	287:  uint32(1826),
 	288:  uint32(1820),
 	289:  uint32(1814),
 	290:  uint32(1807),
 	291:  uint32(1801),
 	292:  uint32(1795),
 	293:  uint32(1789),
 	294:  uint32(1783),
 	295:  uint32(1777),
 	296:  uint32(1771),
 	297:  uint32(1765),
 	298:  uint32(1759),
 	299:  uint32(1753),
 	300:  uint32(1747),
 	301:  uint32(1741),
 	302:  uint32(1736),
 	303:  uint32(1730),
 	304:  uint32(1724),
 	305:  uint32(1718),
 	306:  uint32(1713),
 	307:  uint32(1707),
 	308:  uint32(1702),
 	309:  uint32(1696),
 	310:  uint32(1691),
 	311:  uint32(1685),
 	312:  uint32(1680),
 	313:  uint32(1675),
 	314:  uint32(1669),
 	315:  uint32(1664),
 	316:  uint32(1659),
 	317:  uint32(1653),
 	318:  uint32(1648),
 	319:  uint32(1643),
 	320:  uint32(1638),
 	321:  uint32(1633),
 	322:  uint32(1628),
 	323:  uint32(1623),
 	324:  uint32(1618),
 	325:  uint32(1613),
 	326:  uint32(1608),
 	327:  uint32(1603),
 	328:  uint32(1598),
 	329:  uint32(1593),
 	330:  uint32(1588),
 	331:  uint32(1583),
 	332:  uint32(1579),
 	333:  uint32(1574),
 	334:  uint32(1569),
 	335:  uint32(1565),
 	336:  uint32(1560),
 	337:  uint32(1555),
 	338:  uint32(1551),
 	339:  uint32(1546),
 	340:  uint32(1542),
 	341:  uint32(1537),
 	342:  uint32(1533),
 	343:  uint32(1528),
 	344:  uint32(1524),
 	345:  uint32(1519),
 	346:  uint32(1515),
 	347:  uint32(1510),
 	348:  uint32(1506),
 	349:  uint32(1502),
 	350:  uint32(1497),
 	351:  uint32(1493),
 	352:  uint32(1489),
 	353:  uint32(1485),
 	354:  uint32(1481),
 	355:  uint32(1476),
 	356:  uint32(1472),
 	357:  uint32(1468),
 	358:  uint32(1464),
 	359:  uint32(1460),
 	360:  uint32(1456),
 	361:  uint32(1452),
 	362:  uint32(1448),
 	363:  uint32(1444),
 	364:  uint32(1440),
 	365:  uint32(1436),
 	366:  uint32(1432),
 	367:  uint32(1428),
 	368:  uint32(1424),
 	369:  uint32(1420),
 	370:  uint32(1416),
 	371:  uint32(1413),
 	372:  uint32(1409),
 	373:  uint32(1405),
 	374:  uint32(1401),
 	375:  uint32(1398),
 	376:  uint32(1394),
 	377:  uint32(1390),
 	378:  uint32(1387),
 	379:  uint32(1383),
 	380:  uint32(1379),
 	381:  uint32(1376),
 	382:  uint32(1372),
 	383:  uint32(1368),
 	384:  uint32(1365),
 	385:  uint32(1361),
 	386:  uint32(1358),
 	387:  uint32(1354),
 	388:  uint32(1351),
 	389:  uint32(1347),
 	390:  uint32(1344),
 	391:  uint32(1340),
 	392:  uint32(1337),
 	393:  uint32(1334),
 	394:  uint32(1330),
 	395:  uint32(1327),
 	396:  uint32(1323),
 	397:  uint32(1320),
 	398:  uint32(1317),
 	399:  uint32(1314),
 	400:  uint32(1310),
 	401:  uint32(1307),
 	402:  uint32(1304),
 	403:  uint32(1300),
 	404:  uint32(1297),
 	405:  uint32(1294),
 	406:  uint32(1291),
 	407:  uint32(1288),
 	408:  uint32(1285),
 	409:  uint32(1281),
 	410:  uint32(1278),
 	411:  uint32(1275),
 	412:  uint32(1272),
 	413:  uint32(1269),
 	414:  uint32(1266),
 	415:  uint32(1263),
 	416:  uint32(1260),
 	417:  uint32(1257),
 	418:  uint32(1254),
 	419:  uint32(1251),
 	420:  uint32(1248),
 	421:  uint32(1245),
 	422:  uint32(1242),
 	423:  uint32(1239),
 	424:  uint32(1236),
 	425:  uint32(1233),
 	426:  uint32(1230),
 	427:  uint32(1227),
 	428:  uint32(1224),
 	429:  uint32(1222),
 	430:  uint32(1219),
 	431:  uint32(1216),
 	432:  uint32(1213),
 	433:  uint32(1210),
 	434:  uint32(1208),
 	435:  uint32(1205),
 	436:  uint32(1202),
 	437:  uint32(1199),
 	438:  uint32(1197),
 	439:  uint32(1194),
 	440:  uint32(1191),
 	441:  uint32(1188),
 	442:  uint32(1186),
 	443:  uint32(1183),
 	444:  uint32(1180),
 	445:  uint32(1178),
 	446:  uint32(1175),
 	447:  uint32(1172),
 	448:  uint32(1170),
 	449:  uint32(1167),
 	450:  uint32(1165),
 	451:  uint32(1162),
 	452:  uint32(1159),
 	453:  uint32(1157),
 	454:  uint32(1154),
 	455:  uint32(1152),
 	456:  uint32(1149),
 	457:  uint32(1147),
 	458:  uint32(1144),
 	459:  uint32(1142),
 	460:  uint32(1139),
 	461:  uint32(1137),
 	462:  uint32(1134),
 	463:  uint32(1132),
 	464:  uint32(1129),
 	465:  uint32(1127),
 	466:  uint32(1125),
 	467:  uint32(1122),
 	468:  uint32(1120),
 	469:  uint32(1117),
 	470:  uint32(1115),
 	471:  uint32(1113),
 	472:  uint32(1110),
 	473:  uint32(1108),
 	474:  uint32(1106),
 	475:  uint32(1103),
 	476:  uint32(1101),
 	477:  uint32(1099),
 	478:  uint32(1096),
 	479:  uint32(1094),
 	480:  uint32(1092),
 	481:  uint32(1089),
 	482:  uint32(1087),
 	483:  uint32(1085),
 	484:  uint32(1083),
 	485:  uint32(1081),
 	486:  uint32(1078),
 	487:  uint32(1076),
 	488:  uint32(1074),
 	489:  uint32(1072),
 	490:  uint32(1069),
 	491:  uint32(1067),
 	492:  uint32(1065),
 	493:  uint32(1063),
 	494:  uint32(1061),
 	495:  uint32(1059),
 	496:  uint32(1057),
 	497:  uint32(1054),
 	498:  uint32(1052),
 	499:  uint32(1050),
 	500:  uint32(1048),
 	501:  uint32(1046),
 	502:  uint32(1044),
 	503:  uint32(1042),
 	504:  uint32(1040),
 	505:  uint32(1038),
 	506:  uint32(1036),
 	507:  uint32(1034),
 	508:  uint32(1032),
 	509:  uint32(1030),
 	510:  uint32(1028),
 	511:  uint32(1026),
 	512:  uint32(1024),
 	513:  uint32(1022),
 	514:  uint32(1020),
 	515:  uint32(1018),
 	516:  uint32(1016),
 	517:  uint32(1014),
 	518:  uint32(1012),
 	519:  uint32(1010),
 	520:  uint32(1008),
 	521:  uint32(1006),
 	522:  uint32(1004),
 	523:  uint32(1002),
 	524:  uint32(1000),
 	525:  uint32(998),
 	526:  uint32(996),
 	527:  uint32(994),
 	528:  uint32(992),
 	529:  uint32(991),
 	530:  uint32(989),
 	531:  uint32(987),
 	532:  uint32(985),
 	533:  uint32(983),
 	534:  uint32(981),
 	535:  uint32(979),
 	536:  uint32(978),
 	537:  uint32(976),
 	538:  uint32(974),
 	539:  uint32(972),
 	540:  uint32(970),
 	541:  uint32(969),
 	542:  uint32(967),
 	543:  uint32(965),
 	544:  uint32(963),
 	545:  uint32(961),
 	546:  uint32(960),
 	547:  uint32(958),
 	548:  uint32(956),
 	549:  uint32(954),
 	550:  uint32(953),
 	551:  uint32(951),
 	552:  uint32(949),
 	553:  uint32(948),
 	554:  uint32(946),
 	555:  uint32(944),
 	556:  uint32(942),
 	557:  uint32(941),
 	558:  uint32(939),
 	559:  uint32(937),
 	560:  uint32(936),
 	561:  uint32(934),
 	562:  uint32(932),
 	563:  uint32(931),
 	564:  uint32(929),
 	565:  uint32(927),
 	566:  uint32(926),
 	567:  uint32(924),
 	568:  uint32(923),
 	569:  uint32(921),
 	570:  uint32(919),
 	571:  uint32(918),
 	572:  uint32(916),
 	573:  uint32(914),
 	574:  uint32(913),
 	575:  uint32(911),
 	576:  uint32(910),
 	577:  uint32(908),
 	578:  uint32(907),
 	579:  uint32(905),
 	580:  uint32(903),
 	581:  uint32(902),
 	582:  uint32(900),
 	583:  uint32(899),
 	584:  uint32(897),
 	585:  uint32(896),
 	586:  uint32(894),
 	587:  uint32(893),
 	588:  uint32(891),
 	589:  uint32(890),
 	590:  uint32(888),
 	591:  uint32(887),
 	592:  uint32(885),
 	593:  uint32(884),
 	594:  uint32(882),
 	595:  uint32(881),
 	596:  uint32(879),
 	597:  uint32(878),
 	598:  uint32(876),
 	599:  uint32(875),
 	600:  uint32(873),
 	601:  uint32(872),
 	602:  uint32(870),
 	603:  uint32(869),
 	604:  uint32(868),
 	605:  uint32(866),
 	606:  uint32(865),
 	607:  uint32(863),
 	608:  uint32(862),
 	609:  uint32(860),
 	610:  uint32(859),
 	611:  uint32(858),
 	612:  uint32(856),
 	613:  uint32(855),
 	614:  uint32(853),
 	615:  uint32(852),
 	616:  uint32(851),
 	617:  uint32(849),
 	618:  uint32(848),
 	619:  uint32(846),
 	620:  uint32(845),
 	621:  uint32(844),
 	622:  uint32(842),
 	623:  uint32(841),
 	624:  uint32(840),
 	625:  uint32(838),
 	626:  uint32(837),
 	627:  uint32(836),
 	628:  uint32(834),
 	629:  uint32(833),
 	630:  uint32(832),
 	631:  uint32(830),
 	632:  uint32(829),
 	633:  uint32(828),
 	634:  uint32(826),
 	635:  uint32(825),
 	636:  uint32(824),
 	637:  uint32(823),
 	638:  uint32(821),
 	639:  uint32(820),
 	640:  uint32(819),
 	641:  uint32(817),
 	642:  uint32(816),
 	643:  uint32(815),
 	644:  uint32(814),
 	645:  uint32(812),
 	646:  uint32(811),
 	647:  uint32(810),
 	648:  uint32(809),
 	649:  uint32(807),
 	650:  uint32(806),
 	651:  uint32(805),
 	652:  uint32(804),
 	653:  uint32(802),
 	654:  uint32(801),
 	655:  uint32(800),
 	656:  uint32(799),
 	657:  uint32(798),
 	658:  uint32(796),
 	659:  uint32(795),
 	660:  uint32(794),
 	661:  uint32(793),
 	662:  uint32(791),
 	663:  uint32(790),
 	664:  uint32(789),
 	665:  uint32(788),
 	666:  uint32(787),
 	667:  uint32(786),
 	668:  uint32(784),
 	669:  uint32(783),
 	670:  uint32(782),
 	671:  uint32(781),
 	672:  uint32(780),
 	673:  uint32(779),
 	674:  uint32(777),
 	675:  uint32(776),
 	676:  uint32(775),
 	677:  uint32(774),
 	678:  uint32(773),
 	679:  uint32(772),
 	680:  uint32(771),
 	681:  uint32(769),
 	682:  uint32(768),
 	683:  uint32(767),
 	684:  uint32(766),
 	685:  uint32(765),
 	686:  uint32(764),
 	687:  uint32(763),
 	688:  uint32(762),
 	689:  uint32(760),
 	690:  uint32(759),
 	691:  uint32(758),
 	692:  uint32(757),
 	693:  uint32(756),
 	694:  uint32(755),
 	695:  uint32(754),
 	696:  uint32(753),
 	697:  uint32(752),
 	698:  uint32(751),
 	699:  uint32(750),
 	700:  uint32(748),
 	701:  uint32(747),
 	702:  uint32(746),
 	703:  uint32(745),
 	704:  uint32(744),
 	705:  uint32(743),
 	706:  uint32(742),
 	707:  uint32(741),
 	708:  uint32(740),
 	709:  uint32(739),
 	710:  uint32(738),
 	711:  uint32(737),
 	712:  uint32(736),
 	713:  uint32(735),
 	714:  uint32(734),
 	715:  uint32(733),
 	716:  uint32(732),
 	717:  uint32(731),
 	718:  uint32(730),
 	719:  uint32(729),
 	720:  uint32(728),
 	721:  uint32(727),
 	722:  uint32(726),
 	723:  uint32(725),
 	724:  uint32(724),
 	725:  uint32(723),
 	726:  uint32(722),
 	727:  uint32(721),
 	728:  uint32(720),
 	729:  uint32(719),
 	730:  uint32(718),
 	731:  uint32(717),
 	732:  uint32(716),
 	733:  uint32(715),
 	734:  uint32(714),
 	735:  uint32(713),
 	736:  uint32(712),
 	737:  uint32(711),
 	738:  uint32(710),
 	739:  uint32(709),
 	740:  uint32(708),
 	741:  uint32(707),
 	742:  uint32(706),
 	743:  uint32(705),
 	744:  uint32(704),
 	745:  uint32(703),
 	746:  uint32(702),
 	747:  uint32(701),
 	748:  uint32(700),
 	749:  uint32(699),
 	750:  uint32(699),
 	751:  uint32(698),
 	752:  uint32(697),
 	753:  uint32(696),
 	754:  uint32(695),
 	755:  uint32(694),
 	756:  uint32(693),
 	757:  uint32(692),
 	758:  uint32(691),
 	759:  uint32(690),
 	760:  uint32(689),
 	761:  uint32(688),
 	762:  uint32(688),
 	763:  uint32(687),
 	764:  uint32(686),
 	765:  uint32(685),
 	766:  uint32(684),
 	767:  uint32(683),
 	768:  uint32(682),
 	769:  uint32(681),
 	770:  uint32(680),
 	771:  uint32(680),
 	772:  uint32(679),
 	773:  uint32(678),
 	774:  uint32(677),
 	775:  uint32(676),
 	776:  uint32(675),
 	777:  uint32(674),
 	778:  uint32(673),
 	779:  uint32(673),
 	780:  uint32(672),
 	781:  uint32(671),
 	782:  uint32(670),
 	783:  uint32(669),
 	784:  uint32(668),
 	785:  uint32(667),
 	786:  uint32(667),
 	787:  uint32(666),
 	788:  uint32(665),
 	789:  uint32(664),
 	790:  uint32(663),
 	791:  uint32(662),
 	792:  uint32(661),
 	793:  uint32(661),
 	794:  uint32(660),
 	795:  uint32(659),
 	796:  uint32(658),
 	797:  uint32(657),
 	798:  uint32(657),
 	799:  uint32(656),
 	800:  uint32(655),
 	801:  uint32(654),
 	802:  uint32(653),
 	803:  uint32(652),
 	804:  uint32(652),
 	805:  uint32(651),
 	806:  uint32(650),
 	807:  uint32(649),
 	808:  uint32(648),
 	809:  uint32(648),
 	810:  uint32(647),
 	811:  uint32(646),
 	812:  uint32(645),
 	813:  uint32(644),
 	814:  uint32(644),
 	815:  uint32(643),
 	816:  uint32(642),
 	817:  uint32(641),
 	818:  uint32(640),
 	819:  uint32(640),
 	820:  uint32(639),
 	821:  uint32(638),
 	822:  uint32(637),
 	823:  uint32(637),
 	824:  uint32(636),
 	825:  uint32(635),
 	826:  uint32(634),
 	827:  uint32(633),
 	828:  uint32(633),
 	829:  uint32(632),
 	830:  uint32(631),
 	831:  uint32(630),
 	832:  uint32(630),
 	833:  uint32(629),
 	834:  uint32(628),
 	835:  uint32(627),
 	836:  uint32(627),
 	837:  uint32(626),
 	838:  uint32(625),
 	839:  uint32(624),
 	840:  uint32(624),
 	841:  uint32(623),
 	842:  uint32(622),
 	843:  uint32(621),
 	844:  uint32(621),
 	845:  uint32(620),
 	846:  uint32(619),
 	847:  uint32(618),
 	848:  uint32(618),
 	849:  uint32(617),
 	850:  uint32(616),
 	851:  uint32(616),
 	852:  uint32(615),
 	853:  uint32(614),
 	854:  uint32(613),
 	855:  uint32(613),
 	856:  uint32(612),
 	857:  uint32(611),
 	858:  uint32(611),
 	859:  uint32(610),
 	860:  uint32(609),
 	861:  uint32(608),
 	862:  uint32(608),
 	863:  uint32(607),
 	864:  uint32(606),
 	865:  uint32(606),
 	866:  uint32(605),
 	867:  uint32(604),
 	868:  uint32(604),
 	869:  uint32(603),
 	870:  uint32(602),
 	871:  uint32(601),
 	872:  uint32(601),
 	873:  uint32(600),
 	874:  uint32(599),
 	875:  uint32(599),
 	876:  uint32(598),
 	877:  uint32(597),
 	878:  uint32(597),
 	879:  uint32(596),
 	880:  uint32(595),
 	881:  uint32(595),
 	882:  uint32(594),
 	883:  uint32(593),
 	884:  uint32(593),
 	885:  uint32(592),
 	886:  uint32(591),
 	887:  uint32(591),
 	888:  uint32(590),
 	889:  uint32(589),
 	890:  uint32(589),
 	891:  uint32(588),
 	892:  uint32(587),
 	893:  uint32(587),
 	894:  uint32(586),
 	895:  uint32(585),
 	896:  uint32(585),
 	897:  uint32(584),
 	898:  uint32(583),
 	899:  uint32(583),
 	900:  uint32(582),
 	901:  uint32(581),
 	902:  uint32(581),
 	903:  uint32(580),
 	904:  uint32(579),
 	905:  uint32(579),
 	906:  uint32(578),
 	907:  uint32(578),
 	908:  uint32(577),
 	909:  uint32(576),
 	910:  uint32(576),
 	911:  uint32(575),
 	912:  uint32(574),
 	913:  uint32(574),
 	914:  uint32(573),
 	915:  uint32(572),
 	916:  uint32(572),
 	917:  uint32(571),
 	918:  uint32(571),
 	919:  uint32(570),
 	920:  uint32(569),
 	921:  uint32(569),
 	922:  uint32(568),
 	923:  uint32(568),
 	924:  uint32(567),
 	925:  uint32(566),
 	926:  uint32(566),
 	927:  uint32(565),
 	928:  uint32(564),
 	929:  uint32(564),
 	930:  uint32(563),
 	931:  uint32(563),
 	932:  uint32(562),
 	933:  uint32(561),
 	934:  uint32(561),
 	935:  uint32(560),
 	936:  uint32(560),
 	937:  uint32(559),
 	938:  uint32(558),
 	939:  uint32(558),
 	940:  uint32(557),
 	941:  uint32(557),
 	942:  uint32(556),
 	943:  uint32(555),
 	944:  uint32(555),
 	945:  uint32(554),
 	946:  uint32(554),
 	947:  uint32(553),
 	948:  uint32(553),
 	949:  uint32(552),
 	950:  uint32(551),
 	951:  uint32(551),
 	952:  uint32(550),
 	953:  uint32(550),
 	954:  uint32(549),
 	955:  uint32(548),
 	956:  uint32(548),
 	957:  uint32(547),
 	958:  uint32(547),
 	959:  uint32(546),
 	960:  uint32(546),
 	961:  uint32(545),
 	962:  uint32(544),
 	963:  uint32(544),
 	964:  uint32(543),
 	965:  uint32(543),
 	966:  uint32(542),
 	967:  uint32(542),
 	968:  uint32(541),
 	969:  uint32(541),
 	970:  uint32(540),
 	971:  uint32(539),
 	972:  uint32(539),
 	973:  uint32(538),
 	974:  uint32(538),
 	975:  uint32(537),
 	976:  uint32(537),
 	977:  uint32(536),
 	978:  uint32(536),
 	979:  uint32(535),
 	980:  uint32(534),
 	981:  uint32(534),
 	982:  uint32(533),
 	983:  uint32(533),
 	984:  uint32(532),
 	985:  uint32(532),
 	986:  uint32(531),
 	987:  uint32(531),
 	988:  uint32(530),
 	989:  uint32(530),
 	990:  uint32(529),
 	991:  uint32(529),
 	992:  uint32(528),
 	993:  uint32(527),
 	994:  uint32(527),
 	995:  uint32(526),
 	996:  uint32(526),
 	997:  uint32(525),
 	998:  uint32(525),
 	999:  uint32(524),
 	1000: uint32(524),
 	1001: uint32(523),
 	1002: uint32(523),
 	1003: uint32(522),
 	1004: uint32(522),
 	1005: uint32(521),
 	1006: uint32(521),
 	1007: uint32(520),
 	1008: uint32(520),
 	1009: uint32(519),
 	1010: uint32(519),
 	1011: uint32(518),
 	1012: uint32(518),
 	1013: uint32(517),
 	1014: uint32(517),
 	1015: uint32(516),
 	1016: uint32(516),
 	1017: uint32(515),
 	1018: uint32(515),
 	1019: uint32(514),
 	1020: uint32(514),
 }
 
 // Note that LinearToGamma() expects the values to be premultiplied by 4,
 // so we incorporate this factor 4 inside the DIVIDE_BY_ALPHA macro directly.
 
 func LinearToGammaWeighted(tls *libc.TLS, src uintptr, a_ptr uintptr, total_a uint32_t, step int32, rgb_stride int32) (r int32) {
 	var sum uint32_t
 	_ = sum
 	sum = uint32(**(**uint8_t)(__ccgo_up(a_ptr)))*GammaToLinear(tls, **(**uint8_t)(__ccgo_up(src))) + uint32(**(**uint8_t)(__ccgo_up(a_ptr + uintptr(step))))*GammaToLinear(tls, **(**uint8_t)(__ccgo_up(src + uintptr(step)))) + uint32(**(**uint8_t)(__ccgo_up(a_ptr + uintptr(rgb_stride))))*GammaToLinear(tls, **(**uint8_t)(__ccgo_up(src + uintptr(rgb_stride)))) + uint32(**(**uint8_t)(__ccgo_up(a_ptr + uintptr(rgb_stride+step))))*GammaToLinear(tls, **(**uint8_t)(__ccgo_up(src + uintptr(rgb_stride+step))))
 	return LinearToGamma(tls, sum*kInvAlpha[total_a]>>(kAlphaFix-libc.Int32FromInt32(2)), 0)
 }
 
 func ConvertRowToY(tls *libc.TLS, r_ptr uintptr, g_ptr uintptr, b_ptr uintptr, step int32, dst_y uintptr, width int32, rg uintptr) {
 	var i, j int32
 	_, _ = i, j
 	i = 0
 	j = libc.Int32FromInt32(0)
 	for {
 		if !(i < width) {
 			break
 		}
 		**(**uint8_t)(__ccgo_up(dst_y + uintptr(i))) = libc.Uint8FromInt32(RGBToY(tls, libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(r_ptr + uintptr(j)))), libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(g_ptr + uintptr(j)))), libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(b_ptr + uintptr(j)))), rg))
 		goto _1
 	_1:
 		;
 		i = i + int32(1)
 		j = j + step
 	}
 }
 
 func AccumulateRGBA(tls *libc.TLS, r_ptr uintptr, g_ptr uintptr, b_ptr uintptr, a_ptr uintptr, rgb_stride int32, dst uintptr, width int32) {
 	var a, a1 uint32_t
 	var b, b1, g, g1, i, j, r, r1 int32
 	_, _, _, _, _, _, _, _, _, _ = a, a1, b, b1, g, g1, i, j, r, r1
 	// we loop over 2x2 blocks and produce one R/G/B/A value for each.
 	i = 0
 	j = libc.Int32FromInt32(0)
 	for {
 		if !(i < width>>int32(1)) {
 			break
 		}
 		a = libc.Uint32FromInt32(libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(a_ptr + uintptr(j)))) + libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(a_ptr + uintptr(j) + uintptr(rgb_stride)))) + (libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(a_ptr + uintptr(j) + libc.UintptrFromInt32(4)))) + libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(a_ptr + uintptr(j) + libc.UintptrFromInt32(4) + uintptr(rgb_stride))))))
 		if a == libc.Uint32FromInt32(libc.Int32FromInt32(4)*libc.Int32FromInt32(0xff)) || a == uint32(0) {
 			r = LinearToGamma(tls, GammaToLinear(tls, **(**uint8_t)(__ccgo_up(r_ptr + uintptr(j))))+GammaToLinear(tls, **(**uint8_t)(__ccgo_up(r_ptr + uintptr(j) + 4)))+GammaToLinear(tls, **(**uint8_t)(__ccgo_up(r_ptr + uintptr(j) + uintptr(rgb_stride))))+GammaToLinear(tls, **(**uint8_t)(__ccgo_up(r_ptr + uintptr(j) + uintptr(rgb_stride+int32(4))))), 0)
 			g = LinearToGamma(tls, GammaToLinear(tls, **(**uint8_t)(__ccgo_up(g_ptr + uintptr(j))))+GammaToLinear(tls, **(**uint8_t)(__ccgo_up(g_ptr + uintptr(j) + 4)))+GammaToLinear(tls, **(**uint8_t)(__ccgo_up(g_ptr + uintptr(j) + uintptr(rgb_stride))))+GammaToLinear(tls, **(**uint8_t)(__ccgo_up(g_ptr + uintptr(j) + uintptr(rgb_stride+int32(4))))), 0)
 			b = LinearToGamma(tls, GammaToLinear(tls, **(**uint8_t)(__ccgo_up(b_ptr + uintptr(j))))+GammaToLinear(tls, **(**uint8_t)(__ccgo_up(b_ptr + uintptr(j) + 4)))+GammaToLinear(tls, **(**uint8_t)(__ccgo_up(b_ptr + uintptr(j) + uintptr(rgb_stride))))+GammaToLinear(tls, **(**uint8_t)(__ccgo_up(b_ptr + uintptr(j) + uintptr(rgb_stride+int32(4))))), 0)
 		} else {
 			r = LinearToGammaWeighted(tls, r_ptr+uintptr(j), a_ptr+uintptr(j), a, int32(4), rgb_stride)
 			g = LinearToGammaWeighted(tls, g_ptr+uintptr(j), a_ptr+uintptr(j), a, int32(4), rgb_stride)
 			b = LinearToGammaWeighted(tls, b_ptr+uintptr(j), a_ptr+uintptr(j), a, int32(4), rgb_stride)
 		}
 		**(**uint16_t)(__ccgo_up(dst)) = libc.Uint16FromInt32(r)
 		**(**uint16_t)(__ccgo_up(dst + 1*2)) = libc.Uint16FromInt32(g)
 		**(**uint16_t)(__ccgo_up(dst + 2*2)) = libc.Uint16FromInt32(b)
 		**(**uint16_t)(__ccgo_up(dst + 3*2)) = uint16(a)
 		goto _1
 	_1:
 		;
 		i = i + int32(1)
 		j = j + libc.Int32FromInt32(2)*libc.Int32FromInt32(4)
 		dst = dst + uintptr(4)*2
 	}
 	if width&int32(1) != 0 {
 		a1 = uint32(2) * libc.Uint32FromInt32(libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(a_ptr + uintptr(j))))+libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(a_ptr + uintptr(j) + uintptr(rgb_stride)))))
 		if a1 == libc.Uint32FromInt32(libc.Int32FromInt32(4)*libc.Int32FromInt32(0xff)) || a1 == uint32(0) {
 			r1 = LinearToGamma(tls, GammaToLinear(tls, **(**uint8_t)(__ccgo_up(r_ptr + uintptr(j))))+GammaToLinear(tls, **(**uint8_t)(__ccgo_up(r_ptr + uintptr(j) + uintptr(rgb_stride)))), int32(1))
 			g1 = LinearToGamma(tls, GammaToLinear(tls, **(**uint8_t)(__ccgo_up(g_ptr + uintptr(j))))+GammaToLinear(tls, **(**uint8_t)(__ccgo_up(g_ptr + uintptr(j) + uintptr(rgb_stride)))), int32(1))
 			b1 = LinearToGamma(tls, GammaToLinear(tls, **(**uint8_t)(__ccgo_up(b_ptr + uintptr(j))))+GammaToLinear(tls, **(**uint8_t)(__ccgo_up(b_ptr + uintptr(j) + uintptr(rgb_stride)))), int32(1))
 		} else {
 			r1 = LinearToGammaWeighted(tls, r_ptr+uintptr(j), a_ptr+uintptr(j), a1, 0, rgb_stride)
 			g1 = LinearToGammaWeighted(tls, g_ptr+uintptr(j), a_ptr+uintptr(j), a1, 0, rgb_stride)
 			b1 = LinearToGammaWeighted(tls, b_ptr+uintptr(j), a_ptr+uintptr(j), a1, 0, rgb_stride)
 		}
 		**(**uint16_t)(__ccgo_up(dst)) = libc.Uint16FromInt32(r1)
 		**(**uint16_t)(__ccgo_up(dst + 1*2)) = libc.Uint16FromInt32(g1)
 		**(**uint16_t)(__ccgo_up(dst + 2*2)) = libc.Uint16FromInt32(b1)
 		**(**uint16_t)(__ccgo_up(dst + 3*2)) = uint16(a1)
 	}
 }
 
 func AccumulateRGB(tls *libc.TLS, r_ptr uintptr, g_ptr uintptr, b_ptr uintptr, step int32, rgb_stride int32, dst uintptr, width int32) {
 	var i, j int32
 	_, _ = i, j
 	i = 0
 	j = libc.Int32FromInt32(0)
 	for {
 		if !(i < width>>int32(1)) {
 			break
 		}
 		**(**uint16_t)(__ccgo_up(dst)) = libc.Uint16FromInt32(LinearToGamma(tls, GammaToLinear(tls, **(**uint8_t)(__ccgo_up(r_ptr + uintptr(j))))+GammaToLinear(tls, **(**uint8_t)(__ccgo_up(r_ptr + uintptr(j) + uintptr(step))))+GammaToLinear(tls, **(**uint8_t)(__ccgo_up(r_ptr + uintptr(j) + uintptr(rgb_stride))))+GammaToLinear(tls, **(**uint8_t)(__ccgo_up(r_ptr + uintptr(j) + uintptr(rgb_stride+step)))), 0))
 		**(**uint16_t)(__ccgo_up(dst + 1*2)) = libc.Uint16FromInt32(LinearToGamma(tls, GammaToLinear(tls, **(**uint8_t)(__ccgo_up(g_ptr + uintptr(j))))+GammaToLinear(tls, **(**uint8_t)(__ccgo_up(g_ptr + uintptr(j) + uintptr(step))))+GammaToLinear(tls, **(**uint8_t)(__ccgo_up(g_ptr + uintptr(j) + uintptr(rgb_stride))))+GammaToLinear(tls, **(**uint8_t)(__ccgo_up(g_ptr + uintptr(j) + uintptr(rgb_stride+step)))), 0))
 		**(**uint16_t)(__ccgo_up(dst + 2*2)) = libc.Uint16FromInt32(LinearToGamma(tls, GammaToLinear(tls, **(**uint8_t)(__ccgo_up(b_ptr + uintptr(j))))+GammaToLinear(tls, **(**uint8_t)(__ccgo_up(b_ptr + uintptr(j) + uintptr(step))))+GammaToLinear(tls, **(**uint8_t)(__ccgo_up(b_ptr + uintptr(j) + uintptr(rgb_stride))))+GammaToLinear(tls, **(**uint8_t)(__ccgo_up(b_ptr + uintptr(j) + uintptr(rgb_stride+step)))), 0))
 		// MemorySanitizer may raise false positives with data that passes through
 		// RGBA32PackedToPlanar_16b_SSE41() due to incorrect modeling of shuffles.
 		// See https://crbug.com/webp/573.
 		goto _1
 	_1:
 		;
 		i = i + int32(1)
 		j = j + int32(2)*step
 		dst = dst + uintptr(4)*2
 	}
 	if width&int32(1) != 0 {
 		**(**uint16_t)(__ccgo_up(dst)) = libc.Uint16FromInt32(LinearToGamma(tls, GammaToLinear(tls, **(**uint8_t)(__ccgo_up(r_ptr + uintptr(j))))+GammaToLinear(tls, **(**uint8_t)(__ccgo_up(r_ptr + uintptr(j) + uintptr(rgb_stride)))), int32(1)))
 		**(**uint16_t)(__ccgo_up(dst + 1*2)) = libc.Uint16FromInt32(LinearToGamma(tls, GammaToLinear(tls, **(**uint8_t)(__ccgo_up(g_ptr + uintptr(j))))+GammaToLinear(tls, **(**uint8_t)(__ccgo_up(g_ptr + uintptr(j) + uintptr(rgb_stride)))), int32(1)))
 		**(**uint16_t)(__ccgo_up(dst + 2*2)) = libc.Uint16FromInt32(LinearToGamma(tls, GammaToLinear(tls, **(**uint8_t)(__ccgo_up(b_ptr + uintptr(j))))+GammaToLinear(tls, **(**uint8_t)(__ccgo_up(b_ptr + uintptr(j) + uintptr(rgb_stride)))), int32(1)))
 	}
 }
 
 func ConvertRowsToUV(tls *libc.TLS, rgb uintptr, dst_u uintptr, dst_v uintptr, width int32, rg uintptr) {
 	var b, g, i, r int32
 	_, _, _, _ = b, g, i, r
 	i = 0
 	for {
 		if !(i < width) {
 			break
 		}
 		r = libc.Int32FromUint16(**(**uint16_t)(__ccgo_up(rgb)))
 		g = libc.Int32FromUint16(**(**uint16_t)(__ccgo_up(rgb + 1*2)))
 		b = libc.Int32FromUint16(**(**uint16_t)(__ccgo_up(rgb + 2*2)))
 		**(**uint8_t)(__ccgo_up(dst_u + uintptr(i))) = libc.Uint8FromInt32(RGBToU(tls, r, g, b, rg))
 		**(**uint8_t)(__ccgo_up(dst_v + uintptr(i))) = libc.Uint8FromInt32(RGBToV(tls, r, g, b, rg))
 		goto _1
 	_1:
 		;
 		i = i + int32(1)
 		rgb = rgb + uintptr(4)*2
 	}
 }
 
 func ImportYUVAFromRGBA(tls *libc.TLS, r_ptr uintptr, g_ptr uintptr, b_ptr uintptr, a_ptr uintptr, step int32, rgb_stride int32, dithering float32, use_iterative_conversion int32, picture uintptr) (r int32) {
 	bp := tls.Alloc(240)
 	defer tls.Free(240)
 	var dst_a, dst_u, dst_v, dst_y, rg, tmp_rgb uintptr
 	var has_alpha, height, is_rgb, row_has_alpha, rows_have_alpha, use_dsp, uv_width, width, y, v1 int32
 	var _ /* base_rg at bp+0 */ VP8Random
 	_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = dst_a, dst_u, dst_v, dst_y, has_alpha, height, is_rgb, rg, row_has_alpha, rows_have_alpha, tmp_rgb, use_dsp, uv_width, width, y, v1
 	width = (*WebPPicture)(unsafe.Pointer(picture)).Fwidth
 	height = (*WebPPicture)(unsafe.Pointer(picture)).Fheight
 	has_alpha = CheckNonOpaque(tls, a_ptr, width, height, step, rgb_stride)
 	is_rgb = libc.BoolInt32(r_ptr < b_ptr) // otherwise it's bgr
 	if has_alpha != 0 {
 		v1 = int32(WEBP_YUV420A)
 	} else {
 		v1 = int32(WEBP_YUV420)
 	}
 	(*WebPPicture)(unsafe.Pointer(picture)).Fcolorspace = v1
 	(*WebPPicture)(unsafe.Pointer(picture)).Fuse_argb = 0
 	// disable smart conversion if source is too small (overkill).
 	if width < kMinDimensionIterativeConversion || height < kMinDimensionIterativeConversion {
 		use_iterative_conversion = 0
 	}
 	if !(WebPPictureAllocYUVA(tls, picture) != 0) {
 		return 0
 	}
 	if has_alpha != 0 {
 	}
 	if use_iterative_conversion != 0 {
 		SharpYuvInit(tls, VP8GetCPUInfo)
 		if !(PreprocessARGB(tls, r_ptr, g_ptr, b_ptr, step, rgb_stride, picture) != 0) {
 			return 0
 		}
 		if has_alpha != 0 {
 			(*(*func(*libc.TLS, uintptr, int32, int32, int32, uintptr, int32) int32)(unsafe.Pointer(&struct{ uintptr }{WebPExtractAlpha})))(tls, a_ptr, rgb_stride, width, height, (*WebPPicture)(unsafe.Pointer(picture)).Fa, (*WebPPicture)(unsafe.Pointer(picture)).Fa_stride)
 		}
 	} else {
 		uv_width = (width + int32(1)) >> int32(1)
 		use_dsp = libc.BoolInt32(step == int32(3)) // use special function in this case
 		// temporary storage for accumulated R/G/B values during conversion to U/V
 		tmp_rgb = WebPSafeMalloc(tls, libc.Uint64FromInt32(int32(4)*uv_width), uint64(2))
 		dst_y = (*WebPPicture)(unsafe.Pointer(picture)).Fy
 		dst_u = (*WebPPicture)(unsafe.Pointer(picture)).Fu
 		dst_v = (*WebPPicture)(unsafe.Pointer(picture)).Fv
 		dst_a = (*WebPPicture)(unsafe.Pointer(picture)).Fa
 		rg = libc.UintptrFromInt32(0)
 		if float64(dithering) > float64(0) {
 			VP8InitRandom(tls, bp, dithering)
 			rg = bp
 			use_dsp = 0 // can't use dsp in this case
 		}
 		WebPInitConvertARGBToYUV(tls)
 		InitGammaTables(tls)
 		if tmp_rgb == libc.UintptrFromInt32(0) {
 			return WebPEncodingSetError(tls, picture, int32(VP8_ENC_ERROR_OUT_OF_MEMORY))
 		}
 		// Downsample Y/U/V planes, two rows at a time
 		y = 0
 		for {
 			if !(y < height>>libc.Int32FromInt32(1)) {
 				break
 			}
 			rows_have_alpha = has_alpha
 			if use_dsp != 0 {
 				if is_rgb != 0 {
 					(*(*func(*libc.TLS, uintptr, uintptr, int32))(unsafe.Pointer(&struct{ uintptr }{WebPConvertRGB24ToY})))(tls, r_ptr, dst_y, width)
 					(*(*func(*libc.TLS, uintptr, uintptr, int32))(unsafe.Pointer(&struct{ uintptr }{WebPConvertRGB24ToY})))(tls, r_ptr+uintptr(rgb_stride), dst_y+uintptr((*WebPPicture)(unsafe.Pointer(picture)).Fy_stride), width)
 				} else {
 					(*(*func(*libc.TLS, uintptr, uintptr, int32))(unsafe.Pointer(&struct{ uintptr }{WebPConvertBGR24ToY})))(tls, b_ptr, dst_y, width)
 					(*(*func(*libc.TLS, uintptr, uintptr, int32))(unsafe.Pointer(&struct{ uintptr }{WebPConvertBGR24ToY})))(tls, b_ptr+uintptr(rgb_stride), dst_y+uintptr((*WebPPicture)(unsafe.Pointer(picture)).Fy_stride), width)
 				}
 			} else {
 				ConvertRowToY(tls, r_ptr, g_ptr, b_ptr, step, dst_y, width, rg)
 				ConvertRowToY(tls, r_ptr+uintptr(rgb_stride), g_ptr+uintptr(rgb_stride), b_ptr+uintptr(rgb_stride), step, dst_y+uintptr((*WebPPicture)(unsafe.Pointer(picture)).Fy_stride), width, rg)
 			}
 			dst_y = dst_y + uintptr(int32(2)*(*WebPPicture)(unsafe.Pointer(picture)).Fy_stride)
 			if has_alpha != 0 {
 				rows_have_alpha = rows_have_alpha & libc.BoolInt32(!((*(*func(*libc.TLS, uintptr, int32, int32, int32, uintptr, int32) int32)(unsafe.Pointer(&struct{ uintptr }{WebPExtractAlpha})))(tls, a_ptr, rgb_stride, width, int32(2), dst_a, (*WebPPicture)(unsafe.Pointer(picture)).Fa_stride) != 0))
 				dst_a = dst_a + uintptr(int32(2)*(*WebPPicture)(unsafe.Pointer(picture)).Fa_stride)
 			}
 			// Collect averaged R/G/B(/A)
 			if !(rows_have_alpha != 0) {
 				AccumulateRGB(tls, r_ptr, g_ptr, b_ptr, step, rgb_stride, tmp_rgb, width)
 			} else {
 				AccumulateRGBA(tls, r_ptr, g_ptr, b_ptr, a_ptr, rgb_stride, tmp_rgb, width)
 			}
 			// Convert to U/V
 			if rg == libc.UintptrFromInt32(0) {
 				(*(*func(*libc.TLS, uintptr, uintptr, uintptr, int32))(unsafe.Pointer(&struct{ uintptr }{WebPConvertRGBA32ToUV})))(tls, tmp_rgb, dst_u, dst_v, uv_width)
 			} else {
 				ConvertRowsToUV(tls, tmp_rgb, dst_u, dst_v, uv_width, rg)
 			}
 			dst_u = dst_u + uintptr((*WebPPicture)(unsafe.Pointer(picture)).Fuv_stride)
 			dst_v = dst_v + uintptr((*WebPPicture)(unsafe.Pointer(picture)).Fuv_stride)
 			r_ptr = r_ptr + uintptr(int32(2)*rgb_stride)
 			b_ptr = b_ptr + uintptr(int32(2)*rgb_stride)
 			g_ptr = g_ptr + uintptr(int32(2)*rgb_stride)
 			if has_alpha != 0 {
 				a_ptr = a_ptr + uintptr(int32(2)*rgb_stride)
 			}
 			goto _2
 		_2:
 			;
 			y = y + 1
 		}
 		if height&int32(1) != 0 { // extra last row
 			row_has_alpha = has_alpha
 			if use_dsp != 0 {
 				if r_ptr < b_ptr {
 					(*(*func(*libc.TLS, uintptr, uintptr, int32))(unsafe.Pointer(&struct{ uintptr }{WebPConvertRGB24ToY})))(tls, r_ptr, dst_y, width)
 				} else {
 					(*(*func(*libc.TLS, uintptr, uintptr, int32))(unsafe.Pointer(&struct{ uintptr }{WebPConvertBGR24ToY})))(tls, b_ptr, dst_y, width)
 				}
 			} else {
 				ConvertRowToY(tls, r_ptr, g_ptr, b_ptr, step, dst_y, width, rg)
 			}
 			if row_has_alpha != 0 {
 				row_has_alpha = row_has_alpha & libc.BoolInt32(!((*(*func(*libc.TLS, uintptr, int32, int32, int32, uintptr, int32) int32)(unsafe.Pointer(&struct{ uintptr }{WebPExtractAlpha})))(tls, a_ptr, 0, width, int32(1), dst_a, 0) != 0))
 			}
 			// Collect averaged R/G/B(/A)
 			if !(row_has_alpha != 0) {
 				// Collect averaged R/G/B
 				AccumulateRGB(tls, r_ptr, g_ptr, b_ptr, step, 0, tmp_rgb, width)
 			} else {
 				AccumulateRGBA(tls, r_ptr, g_ptr, b_ptr, a_ptr, 0, tmp_rgb, width)
 			}
 			if rg == libc.UintptrFromInt32(0) {
 				(*(*func(*libc.TLS, uintptr, uintptr, uintptr, int32))(unsafe.Pointer(&struct{ uintptr }{WebPConvertRGBA32ToUV})))(tls, tmp_rgb, dst_u, dst_v, uv_width)
 			} else {
 				ConvertRowsToUV(tls, tmp_rgb, dst_u, dst_v, uv_width, rg)
 			}
 		}
 		WebPSafeFree(tls, tmp_rgb)
 	}
 	return int32(1)
 }
 
 //------------------------------------------------------------------------------
 // call for ARGB->YUVA conversion
 
 func PictureARGBToYUVA(tls *libc.TLS, picture uintptr, colorspace WebPEncCSP1, dithering float32, use_iterative_conversion int32) (r1 int32) {
 	var a, argb, b, g, r uintptr
 	_, _, _, _, _ = a, argb, b, g, r
 	if picture == libc.UintptrFromInt32(0) {
 		return 0
 	}
 	if (*WebPPicture)(unsafe.Pointer(picture)).Fargb == libc.UintptrFromInt32(0) {
 		return WebPEncodingSetError(tls, picture, int32(VP8_ENC_ERROR_NULL_PARAMETER))
 	} else {
 		if colorspace&int32(WEBP_CSP_UV_MASK) != int32(WEBP_YUV420) {
 			return WebPEncodingSetError(tls, picture, int32(VP8_ENC_ERROR_INVALID_CONFIGURATION))
 		} else {
 			argb = (*WebPPicture)(unsafe.Pointer(picture)).Fargb
 			a = argb + uintptr(libc.Int32FromInt32(3)-libc.Int32FromInt32(0))
 			r = argb + uintptr(libc.Int32FromInt32(3)-libc.Int32FromInt32(1))
 			g = argb + uintptr(libc.Int32FromInt32(3)-libc.Int32FromInt32(2))
 			b = argb + uintptr(libc.Int32FromInt32(3)-libc.Int32FromInt32(3))
 			(*WebPPicture)(unsafe.Pointer(picture)).Fcolorspace = int32(WEBP_YUV420)
 			return ImportYUVAFromRGBA(tls, r, g, b, a, int32(4), int32(4)*(*WebPPicture)(unsafe.Pointer(picture)).Fargb_stride, dithering, use_iterative_conversion, picture)
 		}
 	}
 	return r1
 }
 
 func WebPPictureARGBToYUVADithered(tls *libc.TLS, picture uintptr, colorspace WebPEncCSP1, dithering float32) (r int32) {
 	return PictureARGBToYUVA(tls, picture, colorspace, dithering, 0)
 }
 
 func WebPPictureARGBToYUVA(tls *libc.TLS, picture uintptr, colorspace WebPEncCSP1) (r int32) {
 	return PictureARGBToYUVA(tls, picture, colorspace, libc.Float32FromFloat32(0), 0)
 }
 
 func WebPPictureSharpARGBToYUVA(tls *libc.TLS, picture uintptr) (r int32) {
 	return PictureARGBToYUVA(tls, picture, int32(WEBP_YUV420), libc.Float32FromFloat32(0), int32(1))
 }
 
 // C documentation
 //
 //	// for backward compatibility
 func WebPPictureSmartARGBToYUVA(tls *libc.TLS, picture uintptr) (r int32) {
 	return WebPPictureSharpARGBToYUVA(tls, picture)
 }
 
 //------------------------------------------------------------------------------
 // call for YUVA -> ARGB conversion
 
 func WebPPictureYUVAToARGB(tls *libc.TLS, picture uintptr) (r int32) {
 	var argb_dst, cur_u, cur_v, cur_y, dst, src, top_u, top_v uintptr
 	var argb_stride, height, width, x, y int32
 	var upsample WebPUpsampleLinePairFunc
 	_, _, _, _, _, _, _, _, _, _, _, _, _, _ = argb_dst, argb_stride, cur_u, cur_v, cur_y, dst, height, src, top_u, top_v, upsample, width, x, y
 	if picture == libc.UintptrFromInt32(0) {
 		return 0
 	}
 	if (*WebPPicture)(unsafe.Pointer(picture)).Fy == libc.UintptrFromInt32(0) || (*WebPPicture)(unsafe.Pointer(picture)).Fu == libc.UintptrFromInt32(0) || (*WebPPicture)(unsafe.Pointer(picture)).Fv == libc.UintptrFromInt32(0) {
 		return WebPEncodingSetError(tls, picture, int32(VP8_ENC_ERROR_NULL_PARAMETER))
 	}
 	if (*WebPPicture)(unsafe.Pointer(picture)).Fcolorspace&int32(WEBP_CSP_ALPHA_BIT) != 0 && (*WebPPicture)(unsafe.Pointer(picture)).Fa == libc.UintptrFromInt32(0) {
 		return WebPEncodingSetError(tls, picture, int32(VP8_ENC_ERROR_NULL_PARAMETER))
 	}
 	if (*WebPPicture)(unsafe.Pointer(picture)).Fcolorspace&int32(WEBP_CSP_UV_MASK) != int32(WEBP_YUV420) {
 		return WebPEncodingSetError(tls, picture, int32(VP8_ENC_ERROR_INVALID_CONFIGURATION))
 	}
 	// Allocate a new argb buffer (discarding the previous one).
 	if !(WebPPictureAllocARGB(tls, picture) != 0) {
 		return 0
 	}
 	(*WebPPicture)(unsafe.Pointer(picture)).Fuse_argb = int32(1)
 	// Convert
 	width = (*WebPPicture)(unsafe.Pointer(picture)).Fwidth
 	height = (*WebPPicture)(unsafe.Pointer(picture)).Fheight
 	argb_stride = int32(4) * (*WebPPicture)(unsafe.Pointer(picture)).Fargb_stride
 	dst = (*WebPPicture)(unsafe.Pointer(picture)).Fargb
 	cur_u = (*WebPPicture)(unsafe.Pointer(picture)).Fu
 	cur_v = (*WebPPicture)(unsafe.Pointer(picture)).Fv
 	cur_y = (*WebPPicture)(unsafe.Pointer(picture)).Fy
 	upsample = WebPGetLinePairConverter(tls, libc.BoolInt32(libc.Int32FromInt32(3)-libc.Int32FromInt32(0) > 0))
 	// First row, with replicated top samples.
 	(*(*func(*libc.TLS, uintptr, uintptr, uintptr, uintptr, uintptr, uintptr, uintptr, uintptr, int32))(unsafe.Pointer(&struct{ uintptr }{upsample})))(tls, cur_y, libc.UintptrFromInt32(0), cur_u, cur_v, cur_u, cur_v, dst, libc.UintptrFromInt32(0), width)
 	cur_y = cur_y + uintptr((*WebPPicture)(unsafe.Pointer(picture)).Fy_stride)
 	dst = dst + uintptr(argb_stride)
 	// Center rows.
 	y = int32(1)
 	for {
 		if !(y+int32(1) < height) {
 			break
 		}
 		top_u = cur_u
 		top_v = cur_v
 		cur_u = cur_u + uintptr((*WebPPicture)(unsafe.Pointer(picture)).Fuv_stride)
 		cur_v = cur_v + uintptr((*WebPPicture)(unsafe.Pointer(picture)).Fuv_stride)
 		(*(*func(*libc.TLS, uintptr, uintptr, uintptr, uintptr, uintptr, uintptr, uintptr, uintptr, int32))(unsafe.Pointer(&struct{ uintptr }{upsample})))(tls, cur_y, cur_y+uintptr((*WebPPicture)(unsafe.Pointer(picture)).Fy_stride), top_u, top_v, cur_u, cur_v, dst, dst+uintptr(argb_stride), width)
 		cur_y = cur_y + uintptr(int32(2)*(*WebPPicture)(unsafe.Pointer(picture)).Fy_stride)
 		dst = dst + uintptr(int32(2)*argb_stride)
 		goto _1
 	_1:
 		;
 		y = y + int32(2)
 	}
 	// Last row (if needed), with replicated bottom samples.
 	if height > int32(1) && !(height&libc.Int32FromInt32(1) != 0) {
 		(*(*func(*libc.TLS, uintptr, uintptr, uintptr, uintptr, uintptr, uintptr, uintptr, uintptr, int32))(unsafe.Pointer(&struct{ uintptr }{upsample})))(tls, cur_y, libc.UintptrFromInt32(0), cur_u, cur_v, cur_u, cur_v, dst, libc.UintptrFromInt32(0), width)
 	}
 	// Insert alpha values if needed, in replacement for the default 0xff ones.
 	if (*WebPPicture)(unsafe.Pointer(picture)).Fcolorspace&int32(WEBP_CSP_ALPHA_BIT) != 0 {
 		y = 0
 		for {
 			if !(y < height) {
 				break
 			}
 			argb_dst = (*WebPPicture)(unsafe.Pointer(picture)).Fargb + uintptr(y*(*WebPPicture)(unsafe.Pointer(picture)).Fargb_stride)*4
 			src = (*WebPPicture)(unsafe.Pointer(picture)).Fa + uintptr(y*(*WebPPicture)(unsafe.Pointer(picture)).Fa_stride)
 			x = 0
 			for {
 				if !(x < width) {
 					break
 				}
 				**(**uint32_t)(__ccgo_up(argb_dst + uintptr(x)*4)) = **(**uint32_t)(__ccgo_up(argb_dst + uintptr(x)*4))&uint32(0x00ffffff) | uint32(**(**uint8_t)(__ccgo_up(src + uintptr(x))))<<libc.Int32FromInt32(24)
 				goto _3
 			_3:
 				;
 				x = x + 1
 			}
 			goto _2
 		_2:
 			;
 			y = y + 1
 		}
 	}
 	return int32(1)
 }
 
 //------------------------------------------------------------------------------
 // automatic import / conversion
 
 func Import(tls *libc.TLS, picture uintptr, rgb uintptr, rgb_stride int32, step int32, swap_rb int32, import_alpha int32) (r int32) {
 	var a_ptr, b_ptr, dst, dst1, g_ptr, r_ptr, v4 uintptr
 	var do_copy, height, width, y, v1, v2, v3 int32
 	_, _, _, _, _, _, _, _, _, _, _, _, _, _ = a_ptr, b_ptr, do_copy, dst, dst1, g_ptr, height, r_ptr, width, y, v1, v2, v3, v4
 	if swap_rb != 0 {
 		v1 = int32(2)
 	} else {
 		v1 = 0
 	}
 	// swap_rb -> b,g,r,a , !swap_rb -> r,g,b,a
 	r_ptr = rgb + uintptr(v1)
 	g_ptr = rgb + uintptr(1)
 	if swap_rb != 0 {
 		v2 = 0
 	} else {
 		v2 = int32(2)
 	}
 	b_ptr = rgb + uintptr(v2)
 	width = (*WebPPicture)(unsafe.Pointer(picture)).Fwidth
 	height = (*WebPPicture)(unsafe.Pointer(picture)).Fheight
 	if import_alpha != 0 {
 		v3 = int32(4)
 	} else {
 		v3 = int32(3)
 	}
 	if libc.Xabs(tls, rgb_stride) < v3*width {
 		return 0
 	}
 	if !((*WebPPicture)(unsafe.Pointer(picture)).Fuse_argb != 0) {
 		if import_alpha != 0 {
 			v4 = rgb + uintptr(3)
 		} else {
 			v4 = libc.UintptrFromInt32(0)
 		}
 		a_ptr = v4
 		return ImportYUVAFromRGBA(tls, r_ptr, g_ptr, b_ptr, a_ptr, step, rgb_stride, libc.Float32FromFloat32(0), 0, picture)
 	}
 	if !(WebPPictureAlloc(tls, picture) != 0) {
 		return 0
 	}
 	VP8LDspInit(tls)
 	WebPInitAlphaProcessing(tls)
 	if import_alpha != 0 {
 		// dst[] byte order is {a,r,g,b} for big-endian, {b,g,r,a} for little endian
 		dst = (*WebPPicture)(unsafe.Pointer(picture)).Fargb
 		do_copy = libc.BoolInt32(libc.Bool(libc.Int32FromInt32(3)-libc.Int32FromInt32(0) == int32(3)) && swap_rb != 0)
 		if do_copy != 0 {
 			y = 0
 			for {
 				if !(y < height) {
 					break
 				}
 				libc.X__builtin___memcpy_chk(tls, dst, rgb, libc.Uint64FromInt32(width*int32(4)), ^__predefined_size_t(0))
 				rgb = rgb + uintptr(rgb_stride)
 				dst = dst + uintptr((*WebPPicture)(unsafe.Pointer(picture)).Fargb_stride)*4
 				goto _5
 			_5:
 				;
 				y = y + 1
 			}
 		} else {
 			y = 0
 			for {
 				if !(y < height) {
 					break
 				}
 				// RGBA input order. Need to swap R and B.
 				(*(*func(*libc.TLS, uintptr, int32, uintptr))(unsafe.Pointer(&struct{ uintptr }{VP8LConvertBGRAToRGBA})))(tls, rgb, width, dst)
 				rgb = rgb + uintptr(rgb_stride)
 				dst = dst + uintptr((*WebPPicture)(unsafe.Pointer(picture)).Fargb_stride)*4
 				goto _6
 			_6:
 				;
 				y = y + 1
 			}
 		}
 	} else {
 		dst1 = (*WebPPicture)(unsafe.Pointer(picture)).Fargb
 		y = 0
 		for {
 			if !(y < height) {
 				break
 			}
 			(*(*func(*libc.TLS, uintptr, uintptr, uintptr, int32, int32, uintptr))(unsafe.Pointer(&struct{ uintptr }{WebPPackRGB})))(tls, r_ptr, g_ptr, b_ptr, width, step, dst1)
 			r_ptr = r_ptr + uintptr(rgb_stride)
 			g_ptr = g_ptr + uintptr(rgb_stride)
 			b_ptr = b_ptr + uintptr(rgb_stride)
 			dst1 = dst1 + uintptr((*WebPPicture)(unsafe.Pointer(picture)).Fargb_stride)*4
 			goto _7
 		_7:
 			;
 			y = y + 1
 		}
 	}
 	return int32(1)
 }
 
 // Public API
 
 func WebPPictureImportBGR(tls *libc.TLS, picture uintptr, bgr uintptr, bgr_stride int32) (r int32) {
 	var v1 int32
 	_ = v1
 	if picture != libc.UintptrFromInt32(0) && bgr != libc.UintptrFromInt32(0) {
 		v1 = Import(tls, picture, bgr, bgr_stride, int32(3), int32(1), 0)
 	} else {
 		v1 = 0
 	}
 	return v1
 }
 
 func WebPPictureImportBGRA(tls *libc.TLS, picture uintptr, bgra uintptr, bgra_stride int32) (r int32) {
 	var v1 int32
 	_ = v1
 	if picture != libc.UintptrFromInt32(0) && bgra != libc.UintptrFromInt32(0) {
 		v1 = Import(tls, picture, bgra, bgra_stride, int32(4), int32(1), int32(1))
 	} else {
 		v1 = 0
 	}
 	return v1
 }
 
 func WebPPictureImportBGRX(tls *libc.TLS, picture uintptr, bgrx uintptr, bgrx_stride int32) (r int32) {
 	var v1 int32
 	_ = v1
 	if picture != libc.UintptrFromInt32(0) && bgrx != libc.UintptrFromInt32(0) {
 		v1 = Import(tls, picture, bgrx, bgrx_stride, int32(4), int32(1), 0)
 	} else {
 		v1 = 0
 	}
 	return v1
 }
 
 func WebPPictureImportRGB(tls *libc.TLS, picture uintptr, rgb uintptr, rgb_stride int32) (r int32) {
 	var v1 int32
 	_ = v1
 	if picture != libc.UintptrFromInt32(0) && rgb != libc.UintptrFromInt32(0) {
 		v1 = Import(tls, picture, rgb, rgb_stride, int32(3), 0, 0)
 	} else {
 		v1 = 0
 	}
 	return v1
 }
 
 func WebPPictureImportRGBA(tls *libc.TLS, picture uintptr, rgba uintptr, rgba_stride int32) (r int32) {
 	var v1 int32
 	_ = v1
 	if picture != libc.UintptrFromInt32(0) && rgba != libc.UintptrFromInt32(0) {
 		v1 = Import(tls, picture, rgba, rgba_stride, int32(4), 0, int32(1))
 	} else {
 		v1 = 0
 	}
 	return v1
 }
 
 func WebPPictureImportRGBX(tls *libc.TLS, picture uintptr, rgbx uintptr, rgbx_stride int32) (r int32) {
 	var v1 int32
 	_ = v1
 	if picture != libc.UintptrFromInt32(0) && rgbx != libc.UintptrFromInt32(0) {
 		v1 = Import(tls, picture, rgbx, rgbx_stride, int32(4), 0, 0)
 	} else {
 		v1 = 0
 	}
 	return v1
 }
 
 const BC_BASE_MAX = 99
 const BC_DIM_MAX = 2048
 const BC_SCALE_MAX = 99
 const BC_STRING_MAX = 1000
 const BITINT_MAXWIDTH = "__BITINT_MAXWIDTH__"
 const BOOL_WIDTH = "__BOOL_WIDTH__"
 const CHARCLASS_NAME_MAX = 14
 const CHAR_WIDTH = "CHAR_BIT"
 const CHILD_MAX = 266
 const CLK_TCK = "__DARWIN_CLK_TCK"
 const COLL_WEIGHTS_MAX = 2
 const EQUIV_CLASS_MAX = 2
 const EXPR_NEST_MAX = 32
 const GID_MAX = 2147483647
 const INT_WIDTH = "__INT_WIDTH__"
 const IOV_MAX = 1024
 const LINE_MAX = 2048
 const LINK_MAX = 32767
 const LLONG_WIDTH = "__LLONG_WIDTH__"
 const LONG_BIT = 64
 const LONG_WIDTH = "__LONG_WIDTH__"
 const LOSSLESS_DEFAULT_QUALITY = 70
 const MAX_CANON = 1024
 const MAX_INPUT = 1024
 const NAME_MAX = 255
 const NGROUPS_MAX = 16
 const NL_ARGMAX = 9
 const NL_LANGMAX = 14
 const NL_MSGMAX = 32767
 const NL_NMAX = 1
 const NL_SETMAX = 255
 const NL_TEXTMAX = 2048
 const NZERO = 20
 const OFF_MAX = "LLONG_MAX"
 const OFF_MIN = "LLONG_MIN"
 const OPEN_MAX = 10240
 const PASS_MAX = 128
 const PATH_MAX = 1024
 const PIPE_BUF = 512
 const PTHREAD_DESTRUCTOR_ITERATIONS = 4
 const PTHREAD_KEYS_MAX = 512
 const PTHREAD_STACK_MIN = 8192
 const QUAD_MAX = "LLONG_MAX"
 const QUAD_MIN = "LLONG_MIN"
 const RE_DUP_MAX = 255
 const SCHAR_WIDTH = "CHAR_BIT"
 const SHRT_WIDTH = "__SHRT_WIDTH__"
 const SIZE_T_MAX = "ULONG_MAX"
 const SSIZE_MAX = "LONG_MAX"
 const UCHAR_WIDTH = "CHAR_BIT"
 const UID_MAX = 2147483647
 const UINT_WIDTH = "__INT_WIDTH__"
 const ULLONG_WIDTH = "__LLONG_WIDTH__"
 const ULONG_WIDTH = "__LONG_WIDTH__"
 const UQUAD_MAX = "ULLONG_MAX"
 const USHRT_WIDTH = "__SHRT_WIDTH__"
 const WORD_BIT = 32
 const _POSIX2_BC_BASE_MAX = 99
 const _POSIX2_BC_DIM_MAX = 2048
 const _POSIX2_BC_SCALE_MAX = 99
 const _POSIX2_BC_STRING_MAX = 1000
 const _POSIX2_CHARCLASS_NAME_MAX = 14
 const _POSIX2_COLL_WEIGHTS_MAX = 2
 const _POSIX2_EQUIV_CLASS_MAX = 2
 const _POSIX2_EXPR_NEST_MAX = 32
 const _POSIX2_LINE_MAX = 2048
 const _POSIX2_RE_DUP_MAX = 255
 const _POSIX_AIO_LISTIO_MAX = 2
 const _POSIX_AIO_MAX = 1
 const _POSIX_ARG_MAX = 4096
 const _POSIX_CHILD_MAX = 25
 const _POSIX_CLOCKRES_MIN = 20000000
 const _POSIX_DELAYTIMER_MAX = 32
 const _POSIX_HOST_NAME_MAX = 255
 const _POSIX_LINK_MAX = 8
 const _POSIX_LOGIN_NAME_MAX = 9
 const _POSIX_MAX_CANON = 255
 const _POSIX_MAX_INPUT = 255
 const _POSIX_MQ_OPEN_MAX = 8
 const _POSIX_MQ_PRIO_MAX = 32
 const _POSIX_NAME_MAX = 14
 const _POSIX_NGROUPS_MAX = 8
 const _POSIX_OPEN_MAX = 20
 const _POSIX_PATH_MAX = 256
 const _POSIX_PIPE_BUF = 512
 const _POSIX_RE_DUP_MAX = "_POSIX2_RE_DUP_MAX"
 const _POSIX_RTSIG_MAX = 8
 const _POSIX_SEM_NSEMS_MAX = 256
 const _POSIX_SEM_VALUE_MAX = 32767
 const _POSIX_SIGQUEUE_MAX = 32
 const _POSIX_SSIZE_MAX = 32767
 const _POSIX_SS_REPL_MAX = 4
 const _POSIX_STREAM_MAX = 8
 const _POSIX_SYMLINK_MAX = 255
 const _POSIX_SYMLOOP_MAX = 8
 const _POSIX_THREAD_DESTRUCTOR_ITERATIONS = 4
 const _POSIX_THREAD_KEYS_MAX = 128
 const _POSIX_THREAD_THREADS_MAX = 64
 const _POSIX_TIMER_MAX = 32
 const _POSIX_TRACE_EVENT_NAME_MAX = 30
 const _POSIX_TRACE_NAME_MAX = 8
 const _POSIX_TRACE_SYS_MAX = 8
 const _POSIX_TRACE_USER_EVENT_MAX = 32
 const _POSIX_TTY_NAME_MAX = 9
 const _POSIX_TZNAME_MAX = 6
 const _XOPEN_IOV_MAX = 16
 const _XOPEN_NAME_MAX = 255
 const _XOPEN_PATH_MAX = 1024
 const __DARWIN_CLK_TCK = 100
 const __FLT_MIN__4 = 1.17549435082228750796873653722224568e-38
 const __INT_MAX__1 = 2147483647
 
 //------------------------------------------------------------------------------
 
 // Copyright 2012 Google Inc. All Rights Reserved.
 //
 // Use of this source code is governed by a BSD-style license
 // that can be found in the COPYING file in the root of the source
 // tree. An additional intellectual property rights grant can be found
 // in the file PATENTS. All contributing project authors may
 // be found in the AUTHORS file in the root of the source tree.
 // -----------------------------------------------------------------------------
 //
 // Misc. common utility functions
 //
 // Authors: Skal (pascal.massimino@gmail.com)
 //          Urvang (urvang@google.com)
 
 // Copyright 2011 Google Inc. All Rights Reserved.
 //
 // Use of this source code is governed by a BSD-style license
 // that can be found in the COPYING file in the root of the source
 // tree. An additional intellectual property rights grant can be found
 // in the file PATENTS. All contributing project authors may
 // be found in the AUTHORS file in the root of the source tree.
 // -----------------------------------------------------------------------------
 //
 //   WebP encoder: main interface
 //
 // Author: Skal (pascal.massimino@gmail.com)
 
 // Copyright 2010 Google Inc. All Rights Reserved.
 //
 // Use of this source code is governed by a BSD-style license
 // that can be found in the COPYING file in the root of the source
 // tree. An additional intellectual property rights grant can be found
 // in the file PATENTS. All contributing project authors may
 // be found in the AUTHORS file in the root of the source tree.
 // -----------------------------------------------------------------------------
 //
 //  Common types + memory wrappers
 //
 // Author: Skal (pascal.massimino@gmail.com)
 
 //------------------------------------------------------------------------------
 // WebPPicture
 //------------------------------------------------------------------------------
 
 func DummyWriter(tls *libc.TLS, data uintptr, data_size size_t, picture uintptr) (r int32) {
 	// The following are to prevent 'unused variable' error message.
 	_ = data
 	_ = data_size
 	_ = picture
 	return int32(1)
 }
 
 func WebPPictureInitInternal(tls *libc.TLS, picture uintptr, version int32) (r int32) {
 	if version>>int32(8) != libc.Int32FromInt32(WEBP_ENCODER_ABI_VERSION)>>libc.Int32FromInt32(8) {
 		return 0 // caller/system version mismatch!
 	}
 	if picture != libc.UintptrFromInt32(0) {
 		libc.X__builtin___memset_chk(tls, picture, 0, uint64(256), ^__predefined_size_t(0))
 		(*WebPPicture)(unsafe.Pointer(picture)).Fwriter = __ccgo_fp(DummyWriter)
 		WebPEncodingSetError(tls, picture, int32(VP8_ENC_OK))
 	}
 	return int32(1)
 }
 
 //------------------------------------------------------------------------------
 
 func WebPValidatePicture(tls *libc.TLS, picture uintptr) (r int32) {
 	if picture == libc.UintptrFromInt32(0) {
 		return 0
 	}
 	if (*WebPPicture)(unsafe.Pointer(picture)).Fwidth <= 0 || (*WebPPicture)(unsafe.Pointer(picture)).Fheight <= 0 {
 		return WebPEncodingSetError(tls, picture, int32(VP8_ENC_ERROR_BAD_DIMENSION))
 	}
 	if (*WebPPicture)(unsafe.Pointer(picture)).Fwidth <= 0 || (*WebPPicture)(unsafe.Pointer(picture)).Fwidth/int32(4) > libc.Int32FromInt32(__INT_MAX__1)/libc.Int32FromInt32(4) || (*WebPPicture)(unsafe.Pointer(picture)).Fheight <= 0 || (*WebPPicture)(unsafe.Pointer(picture)).Fheight/int32(4) > libc.Int32FromInt32(__INT_MAX__1)/libc.Int32FromInt32(4) {
 		return WebPEncodingSetError(tls, picture, int32(VP8_ENC_ERROR_BAD_DIMENSION))
 	}
 	if (*WebPPicture)(unsafe.Pointer(picture)).Fcolorspace != int32(WEBP_YUV420) && (*WebPPicture)(unsafe.Pointer(picture)).Fcolorspace != int32(WEBP_YUV420A) {
 		return WebPEncodingSetError(tls, picture, int32(VP8_ENC_ERROR_INVALID_CONFIGURATION))
 	}
 	return int32(1)
 }
 
 func WebPPictureResetBufferARGB(tls *libc.TLS, picture uintptr) {
 	(*WebPPicture)(unsafe.Pointer(picture)).Fmemory_argb_ = libc.UintptrFromInt32(0)
 	(*WebPPicture)(unsafe.Pointer(picture)).Fargb = libc.UintptrFromInt32(0)
 	(*WebPPicture)(unsafe.Pointer(picture)).Fargb_stride = 0
 }
 
 func WebPPictureResetBufferYUVA(tls *libc.TLS, picture uintptr) {
 	var v1, v2, v3 uintptr
 	var v4 int32
 	_, _, _, _ = v1, v2, v3, v4
 	(*WebPPicture)(unsafe.Pointer(picture)).Fmemory_ = libc.UintptrFromInt32(0)
 	v3 = libc.UintptrFromInt32(0)
 	(*WebPPicture)(unsafe.Pointer(picture)).Fa = v3
 	v2 = v3
 	(*WebPPicture)(unsafe.Pointer(picture)).Fv = v2
 	v1 = v2
 	(*WebPPicture)(unsafe.Pointer(picture)).Fu = v1
 	(*WebPPicture)(unsafe.Pointer(picture)).Fy = v1
 	v4 = libc.Int32FromInt32(0)
 	(*WebPPicture)(unsafe.Pointer(picture)).Fuv_stride = v4
 	(*WebPPicture)(unsafe.Pointer(picture)).Fy_stride = v4
 	(*WebPPicture)(unsafe.Pointer(picture)).Fa_stride = 0
 }
 
 func WebPPictureResetBuffers(tls *libc.TLS, picture uintptr) {
 	WebPPictureResetBufferARGB(tls, picture)
 	WebPPictureResetBufferYUVA(tls, picture)
 }
 
 func WebPPictureAllocARGB(tls *libc.TLS, picture uintptr) (r int32) {
 	var argb_size uint64_t
 	var height, width int32
 	var memory uintptr
 	_, _, _, _ = argb_size, height, memory, width
 	width = (*WebPPicture)(unsafe.Pointer(picture)).Fwidth
 	height = (*WebPPicture)(unsafe.Pointer(picture)).Fheight
 	argb_size = libc.Uint64FromInt32(width) * libc.Uint64FromInt32(height)
 	if !(WebPValidatePicture(tls, picture) != 0) {
 		return 0
 	}
 	WebPSafeFree(tls, (*WebPPicture)(unsafe.Pointer(picture)).Fmemory_argb_)
 	WebPPictureResetBufferARGB(tls, picture)
 	// allocate a new buffer.
 	memory = WebPSafeMalloc(tls, argb_size+uint64(WEBP_ALIGN_CST), uint64(4))
 	if memory == libc.UintptrFromInt32(0) {
 		return WebPEncodingSetError(tls, picture, int32(VP8_ENC_ERROR_OUT_OF_MEMORY))
 	}
 	(*WebPPicture)(unsafe.Pointer(picture)).Fmemory_argb_ = memory
 	(*WebPPicture)(unsafe.Pointer(picture)).Fargb = uintptr((uint64(memory) + libc.Uint64FromInt32(WEBP_ALIGN_CST)) & ^libc.Uint64FromInt32(WEBP_ALIGN_CST))
 	(*WebPPicture)(unsafe.Pointer(picture)).Fargb_stride = width
 	return int32(1)
 }
 
 func WebPPictureAllocYUVA(tls *libc.TLS, picture uintptr) (r int32) {
 	var a_size, total_size, uv_size, y_size uint64_t
 	var a_stride, a_width, has_alpha, height, uv_height, uv_stride, uv_width, width, y_stride, v1 int32
 	var mem uintptr
 	_, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = a_size, a_stride, a_width, has_alpha, height, mem, total_size, uv_height, uv_size, uv_stride, uv_width, width, y_size, y_stride, v1
 	has_alpha = (*WebPPicture)(unsafe.Pointer(picture)).Fcolorspace & int32(WEBP_CSP_ALPHA_BIT)
 	width = (*WebPPicture)(unsafe.Pointer(picture)).Fwidth
 	height = (*WebPPicture)(unsafe.Pointer(picture)).Fheight
 	y_stride = width
 	uv_width = int32((int64(width) + libc.Int64FromInt32(1)) >> libc.Int32FromInt32(1))
 	uv_height = int32((int64(height) + libc.Int64FromInt32(1)) >> libc.Int32FromInt32(1))
 	uv_stride = uv_width
 	if !(WebPValidatePicture(tls, picture) != 0) {
 		return 0
 	}
 	WebPSafeFree(tls, (*WebPPicture)(unsafe.Pointer(picture)).Fmemory_)
 	WebPPictureResetBufferYUVA(tls, picture)
 	// alpha
 	if has_alpha != 0 {
 		v1 = width
 	} else {
 		v1 = 0
 	}
 	a_width = v1
 	a_stride = a_width
 	y_size = libc.Uint64FromInt32(y_stride) * libc.Uint64FromInt32(height)
 	uv_size = libc.Uint64FromInt32(uv_stride) * libc.Uint64FromInt32(uv_height)
 	a_size = libc.Uint64FromInt32(a_stride) * libc.Uint64FromInt32(height)
 	total_size = y_size + a_size + uint64(2)*uv_size
 	// Security and validation checks
 	if width <= 0 || height <= 0 || uv_width <= 0 || uv_height <= 0 { // u/v param error
 		return WebPEncodingSetError(tls, picture, int32(VP8_ENC_ERROR_BAD_DIMENSION))
 	}
 	// allocate a new buffer.
 	mem = WebPSafeMalloc(tls, total_size, uint64(1))
 	if mem == libc.UintptrFromInt32(0) {
 		return WebPEncodingSetError(tls, picture, int32(VP8_ENC_ERROR_OUT_OF_MEMORY))
 	}
 	// From now on, we're in the clear, we can no longer fail...
 	(*WebPPicture)(unsafe.Pointer(picture)).Fmemory_ = mem
 	(*WebPPicture)(unsafe.Pointer(picture)).Fy_stride = y_stride
 	(*WebPPicture)(unsafe.Pointer(picture)).Fuv_stride = uv_stride
 	(*WebPPicture)(unsafe.Pointer(picture)).Fa_stride = a_stride
 	// TODO(skal): we could align the y/u/v planes and adjust stride.
 	(*WebPPicture)(unsafe.Pointer(picture)).Fy = mem
 	mem = mem + uintptr(y_size)
 	(*WebPPicture)(unsafe.Pointer(picture)).Fu = mem
 	mem = mem + uintptr(uv_size)
 	(*WebPPicture)(unsafe.Pointer(picture)).Fv = mem
 	mem = mem + uintptr(uv_size)
 	if a_size > uint64(0) {
 		(*WebPPicture)(unsafe.Pointer(picture)).Fa = mem
 		mem = mem + uintptr(a_size)
 	}
 	_ = mem // makes the static analyzer happy
 	return int32(1)
 }
 
 func WebPPictureAlloc(tls *libc.TLS, picture uintptr) (r int32) {
 	if picture != libc.UintptrFromInt32(0) {
 		WebPPictureFree(tls, picture) // erase previous buffer
 		if !((*WebPPicture)(unsafe.Pointer(picture)).Fuse_argb != 0) {
 			return WebPPictureAllocYUVA(tls, picture)
 		} else {
 			return WebPPictureAllocARGB(tls, picture)
 		}
 	}
 	return int32(1)
 }
 
 func WebPPictureFree(tls *libc.TLS, picture uintptr) {
 	if picture != libc.UintptrFromInt32(0) {
 		WebPSafeFree(tls, (*WebPPicture)(unsafe.Pointer(picture)).Fmemory_)
 		WebPSafeFree(tls, (*WebPPicture)(unsafe.Pointer(picture)).Fmemory_argb_)
 		WebPPictureResetBuffers(tls, picture)
 	}
 }
 
 //------------------------------------------------------------------------------
 // WebPMemoryWriter: Write-to-memory
 
 func WebPMemoryWriterInit(tls *libc.TLS, writer uintptr) {
 	(*WebPMemoryWriter)(unsafe.Pointer(writer)).Fmem = libc.UintptrFromInt32(0)
 	(*WebPMemoryWriter)(unsafe.Pointer(writer)).Fsize = uint64(0)
 	(*WebPMemoryWriter)(unsafe.Pointer(writer)).Fmax_size = uint64(0)
 }
 
 func WebPMemoryWrite(tls *libc.TLS, data uintptr, data_size size_t, picture uintptr) (r int32) {
 	var new_mem, w uintptr
 	var next_max_size, next_size uint64_t
 	_, _, _, _ = new_mem, next_max_size, next_size, w
 	w = (*WebPPicture)(unsafe.Pointer(picture)).Fcustom_ptr
 	if w == libc.UintptrFromInt32(0) {
 		return int32(1)
 	}
 	next_size = (*WebPMemoryWriter)(unsafe.Pointer(w)).Fsize + data_size
 	if next_size > (*WebPMemoryWriter)(unsafe.Pointer(w)).Fmax_size {
 		next_max_size = uint64(2) * (*WebPMemoryWriter)(unsafe.Pointer(w)).Fmax_size
 		if next_max_size < next_size {
 			next_max_size = next_size
 		}
 		if next_max_size < uint64(8192) {
 			next_max_size = uint64(8192)
 		}
 		new_mem = WebPSafeMalloc(tls, next_max_size, uint64(1))
 		if new_mem == libc.UintptrFromInt32(0) {
 			return 0
 		}
 		if (*WebPMemoryWriter)(unsafe.Pointer(w)).Fsize > uint64(0) {
 			libc.X__builtin___memcpy_chk(tls, new_mem, (*WebPMemoryWriter)(unsafe.Pointer(w)).Fmem, (*WebPMemoryWriter)(unsafe.Pointer(w)).Fsize, ^__predefined_size_t(0))
 		}
 		WebPSafeFree(tls, (*WebPMemoryWriter)(unsafe.Pointer(w)).Fmem)
 		(*WebPMemoryWriter)(unsafe.Pointer(w)).Fmem = new_mem
 		// down-cast is ok, thanks to WebPSafeMalloc
 		(*WebPMemoryWriter)(unsafe.Pointer(w)).Fmax_size = next_max_size
 	}
 	if data_size > uint64(0) {
 		libc.X__builtin___memcpy_chk(tls, (*WebPMemoryWriter)(unsafe.Pointer(w)).Fmem+uintptr((*WebPMemoryWriter)(unsafe.Pointer(w)).Fsize), data, data_size, ^__predefined_size_t(0))
 		**(**size_t)(__ccgo_up(w + 8)) += data_size
 	}
 	return int32(1)
 }
 
 func WebPMemoryWriterClear(tls *libc.TLS, writer uintptr) {
 	if writer != libc.UintptrFromInt32(0) {
 		WebPSafeFree(tls, (*WebPMemoryWriter)(unsafe.Pointer(writer)).Fmem)
 		WebPMemoryWriterInit(tls, writer)
 	}
 }
 
 //------------------------------------------------------------------------------
 // Simplest high-level calls:
 
 type Importer = uintptr
 
 func Encode(tls *libc.TLS, rgba uintptr, width int32, height int32, stride int32, __ccgo_fp_import Importer, quality_factor float32, lossless int32, output uintptr) (r size_t) {
 	bp := tls.Alloc(416)
 	defer tls.Free(416)
 	var ok, v1, v3 int32
 	var v5 bool
 	var _ /* config at bp+256 */ WebPConfig
 	var _ /* pic at bp+0 */ WebPPicture
 	var _ /* wrt at bp+376 */ WebPMemoryWriter
 	_, _, _, _ = ok, v1, v3, v5
 	if output == libc.UintptrFromInt32(0) {
 		return uint64(0)
 	}
 	v1 = WebPConfigInitInternal(tls, bp+256, int32(WEBP_PRESET_DEFAULT), quality_factor, int32(WEBP_ENCODER_ABI_VERSION))
 	goto _2
 _2:
 	;
 	if v5 = !(v1 != 0); !v5 {
 		v3 = WebPPictureInitInternal(tls, bp, int32(WEBP_ENCODER_ABI_VERSION))
 		goto _4
 	_4:
 	}
 	if v5 || !(v3 != 0) {
 		return uint64(0) // shouldn't happen, except if system installation is broken
 	}
 	(**(**WebPConfig)(__ccgo_up(bp + 256))).Flossless = libc.BoolInt32(!!(lossless != 0))
 	(**(**WebPPicture)(__ccgo_up(bp))).Fuse_argb = libc.BoolInt32(!!(lossless != 0))
 	(**(**WebPPicture)(__ccgo_up(bp))).Fwidth = width
 	(**(**WebPPicture)(__ccgo_up(bp))).Fheight = height
 	(**(**WebPPicture)(__ccgo_up(bp))).Fwriter = __ccgo_fp(WebPMemoryWrite)
 	(**(**WebPPicture)(__ccgo_up(bp))).Fcustom_ptr = bp + 376
 	WebPMemoryWriterInit(tls, bp+376)
 	ok = libc.BoolInt32((*(*func(*libc.TLS, uintptr, uintptr, int32) int32)(unsafe.Pointer(&struct{ uintptr }{__ccgo_fp_import})))(tls, bp, rgba, stride) != 0 && WebPEncode(tls, bp+256, bp) != 0)
 	WebPPictureFree(tls, bp)
 	if !(ok != 0) {
 		WebPMemoryWriterClear(tls, bp+376)
 		**(**uintptr)(__ccgo_up(output)) = libc.UintptrFromInt32(0)
 		return uint64(0)
 	}
 	**(**uintptr)(__ccgo_up(output)) = (**(**WebPMemoryWriter)(__ccgo_up(bp + 376))).Fmem
 	return (**(**WebPMemoryWriter)(__ccgo_up(bp + 376))).Fsize
 }
 
 func WebPEncodeRGB(tls *libc.TLS, in uintptr, w int32, h int32, bps int32, q float32, out uintptr) (r size_t) {
 	return Encode(tls, in, w, h, bps, __ccgo_fp(WebPPictureImportRGB), q, 0, out)
 }
 
 func WebPEncodeRGBA(tls *libc.TLS, in uintptr, w int32, h int32, bps int32, q float32, out uintptr) (r size_t) {
 	return Encode(tls, in, w, h, bps, __ccgo_fp(WebPPictureImportRGBA), q, 0, out)
 }
 
 func WebPEncodeBGR(tls *libc.TLS, in uintptr, w int32, h int32, bps int32, q float32, out uintptr) (r size_t) {
 	return Encode(tls, in, w, h, bps, __ccgo_fp(WebPPictureImportBGR), q, 0, out)
 }
 
 func WebPEncodeBGRA(tls *libc.TLS, in uintptr, w int32, h int32, bps int32, q float32, out uintptr) (r size_t) {
 	return Encode(tls, in, w, h, bps, __ccgo_fp(WebPPictureImportBGRA), q, 0, out)
 }
 
 func WebPEncodeLosslessRGB(tls *libc.TLS, in uintptr, w int32, h int32, bps int32, out uintptr) (r size_t) {
 	return Encode(tls, in, w, h, bps, __ccgo_fp(WebPPictureImportRGB), float32(70), int32(1), out)
 }
 
 func WebPEncodeLosslessRGBA(tls *libc.TLS, in uintptr, w int32, h int32, bps int32, out uintptr) (r size_t) {
 	return Encode(tls, in, w, h, bps, __ccgo_fp(WebPPictureImportRGBA), float32(70), int32(1), out)
 }
 
 func WebPEncodeLosslessBGR(tls *libc.TLS, in uintptr, w int32, h int32, bps int32, out uintptr) (r size_t) {
 	return Encode(tls, in, w, h, bps, __ccgo_fp(WebPPictureImportBGR), float32(70), int32(1), out)
 }
 
 func WebPEncodeLosslessBGRA(tls *libc.TLS, in uintptr, w int32, h int32, bps int32, out uintptr) (r size_t) {
 	return Encode(tls, in, w, h, bps, __ccgo_fp(WebPPictureImportBGRA), float32(70), int32(1), out)
 }
 
 const __FLT_MIN__5 = 1.1754943508222875e-38
 const __INT_MAX__2 = 0x7fffffff
 
 //------------------------------------------------------------------------------
 
 // Copyright 2012 Google Inc. All Rights Reserved.
 //
 // Use of this source code is governed by a BSD-style license
 // that can be found in the COPYING file in the root of the source
 // tree. An additional intellectual property rights grant can be found
 // in the file PATENTS. All contributing project authors may
 // be found in the AUTHORS file in the root of the source tree.
 // -----------------------------------------------------------------------------
 //
 // Misc. common utility functions
 //
 // Authors: Skal (pascal.massimino@gmail.com)
 //          Urvang (urvang@google.com)
 
 type AccumulateFunc = uintptr
 
 //------------------------------------------------------------------------------
 // local-min distortion
 //
 // For every pixel in the *reference* picture, we search for the local best
 // match in the compressed image. This is not a symmetrical measure.
 
 func AccumulateLSIM(tls *libc.TLS, src uintptr, src_stride int32, ref uintptr, ref_stride int32, w int32, h int32) (r float64) {
 	var best_sse, diff, sse, total_sse, value float64
 	var i, j, x, x_0, x_1, y, y_0, y_1, v2, v3, v5, v6 int32
 	var s uintptr
 	_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = best_sse, diff, i, j, s, sse, total_sse, value, x, x_0, x_1, y, y_0, y_1, v2, v3, v5, v6
 	total_sse = float64(0)
 	y = 0
 	for {
 		if !(y < h) {
 			break
 		}
 		if y-int32(2) < 0 {
 			v2 = 0
 		} else {
 			v2 = y - int32(2)
 		}
 		y_0 = v2
 		if y+int32(2)+int32(1) >= h {
 			v3 = h
 		} else {
 			v3 = y + int32(2) + int32(1)
 		}
 		y_1 = v3
 		x = 0
 		for {
 			if !(x < w) {
 				break
 			}
 			if x-int32(2) < 0 {
 				v5 = 0
 			} else {
 				v5 = x - int32(2)
 			}
 			x_0 = v5
 			if x+int32(2)+int32(1) >= w {
 				v6 = w
 			} else {
 				v6 = x + int32(2) + int32(1)
 			}
 			x_1 = v6
 			best_sse = float64(libc.Float64FromFloat64(255) * libc.Float64FromFloat64(255))
 			value = float64(**(**uint8_t)(__ccgo_up(ref + uintptr(y*ref_stride+x))))
 			j = y_0
 			for {
 				if !(j < y_1) {
 					break
 				}
 				s = src + uintptr(j*src_stride)
 				i = x_0
 				for {
 					if !(i < x_1) {
 						break
 					}
 					diff = float64(**(**uint8_t)(__ccgo_up(s + uintptr(i)))) - value
 					sse = float64(diff * diff)
 					if sse < best_sse {
 						best_sse = sse
 					}
 					goto _8
 				_8:
 					;
 					i = i + 1
 				}
 				goto _7
 			_7:
 				;
 				j = j + 1
 			}
 			total_sse = total_sse + best_sse
 			goto _4
 		_4:
 			;
 			x = x + 1
 		}
 		goto _1
 	_1:
 		;
 		y = y + 1
 	}
 	return total_sse
 }
 
 func AccumulateSSE(tls *libc.TLS, src uintptr, src_stride int32, ref uintptr, ref_stride int32, w int32, h int32) (r float64) {
 	var total_sse float64
 	var y int32
 	_, _ = total_sse, y
 	total_sse = float64(0)
 	y = 0
 	for {
 		if !(y < h) {
 			break
 		}
 		total_sse = total_sse + float64((*(*func(*libc.TLS, uintptr, uintptr, int32) uint32_t)(unsafe.Pointer(&struct{ uintptr }{VP8AccumulateSSE})))(tls, src, ref, w))
 		src = src + uintptr(src_stride)
 		ref = ref + uintptr(ref_stride)
 		goto _1
 	_1:
 		;
 		y = y + 1
 	}
 	return total_sse
 }
 
 //------------------------------------------------------------------------------
 
 func AccumulateSSIM(tls *libc.TLS, src uintptr, src_stride int32, ref uintptr, ref_stride int32, w int32, h int32) (r float64) {
 	var h0, h1, off1, off2, w0, w1, x, y, v1, v2 int32
 	var sum float64
 	_, _, _, _, _, _, _, _, _, _, _ = h0, h1, off1, off2, sum, w0, w1, x, y, v1, v2
 	if w < int32(VP8_SSIM_KERNEL) {
 		v1 = w
 	} else {
 		v1 = int32(VP8_SSIM_KERNEL)
 	}
 	w0 = v1
 	w1 = w - int32(VP8_SSIM_KERNEL) - int32(1)
 	if h < int32(VP8_SSIM_KERNEL) {
 		v2 = h
 	} else {
 		v2 = int32(VP8_SSIM_KERNEL)
 	}
 	h0 = v2
 	h1 = h - int32(VP8_SSIM_KERNEL) - int32(1)
 	sum = float64(0)
 	y = 0
 	for {
 		if !(y < h0) {
 			break
 		}
 		x = 0
 		for {
 			if !(x < w) {
 				break
 			}
 			sum = sum + (*(*func(*libc.TLS, uintptr, int32, uintptr, int32, int32, int32, int32, int32) float64)(unsafe.Pointer(&struct{ uintptr }{VP8SSIMGetClipped})))(tls, src, src_stride, ref, ref_stride, x, y, w, h)
 			goto _4
 		_4:
 			;
 			x = x + 1
 		}
 		goto _3
 	_3:
 		;
 		y = y + 1
 	}
 	for {
 		if !(y < h1) {
 			break
 		}
 		x = 0
 		for {
 			if !(x < w0) {
 				break
 			}
 			sum = sum + (*(*func(*libc.TLS, uintptr, int32, uintptr, int32, int32, int32, int32, int32) float64)(unsafe.Pointer(&struct{ uintptr }{VP8SSIMGetClipped})))(tls, src, src_stride, ref, ref_stride, x, y, w, h)
 			goto _6
 		_6:
 			;
 			x = x + 1
 		}
 		for {
 			if !(x < w1) {
 				break
 			}
 			off1 = x - int32(VP8_SSIM_KERNEL) + (y-int32(VP8_SSIM_KERNEL))*src_stride
 			off2 = x - int32(VP8_SSIM_KERNEL) + (y-int32(VP8_SSIM_KERNEL))*ref_stride
 			sum = sum + (*(*func(*libc.TLS, uintptr, int32, uintptr, int32) float64)(unsafe.Pointer(&struct{ uintptr }{VP8SSIMGet})))(tls, src+uintptr(off1), src_stride, ref+uintptr(off2), ref_stride)
 			goto _7
 		_7:
 			;
 			x = x + 1
 		}
 		for {
 			if !(x < w) {
 				break
 			}
 			sum = sum + (*(*func(*libc.TLS, uintptr, int32, uintptr, int32, int32, int32, int32, int32) float64)(unsafe.Pointer(&struct{ uintptr }{VP8SSIMGetClipped})))(tls, src, src_stride, ref, ref_stride, x, y, w, h)
 			goto _8
 		_8:
 			;
 			x = x + 1
 		}
 		goto _5
 	_5:
 		;
 		y = y + 1
 	}
 	for {
 		if !(y < h) {
 			break
 		}
 		x = 0
 		for {
 			if !(x < w) {
 				break
 			}
 			sum = sum + (*(*func(*libc.TLS, uintptr, int32, uintptr, int32, int32, int32, int32, int32) float64)(unsafe.Pointer(&struct{ uintptr }{VP8SSIMGetClipped})))(tls, src, src_stride, ref, ref_stride, x, y, w, h)
 			goto _10
 		_10:
 			;
 			x = x + 1
 		}
 		goto _9
 	_9:
 		;
 		y = y + 1
 	}
 	return sum
 }
 
 //------------------------------------------------------------------------------
 // Distortion
 
 // C documentation
 //
 //	// Max value returned in case of exact similarity.
 var kMinDistortion_dB = float64(99)
 
 func GetPSNR1(tls *libc.TLS, v float64, size float64) (r float64) {
 	var v1 float64
 	_ = v1
 	if v > float64(0) && size > float64(0) {
 		v1 = float64(-libc.Float64FromFloat64(4.3429448) * libc.Xlog(tls, v/float64(float64(size*libc.Float64FromInt32(255))*float64(255))))
 	} else {
 		v1 = kMinDistortion_dB
 	}
 	return v1
 }
 
 func GetLogSSIM(tls *libc.TLS, v float64, size float64) (r float64) {
 	var v1 float64
 	_ = v1
 	if size > float64(0) {
 		v1 = v / size
 	} else {
 		v1 = float64(1)
 	}
 	v = v1
 	if v < float64(1) {
 		v1 = float64(-libc.Float64FromFloat64(10) * libc.Xlog10(tls, float64(1)-v))
 	} else {
 		v1 = kMinDistortion_dB
 	}
 	return v1
 }
 
 func WebPPlaneDistortion(tls *libc.TLS, src uintptr, src_stride size_t, ref uintptr, ref_stride size_t, width int32, height int32, x_step size_t, type1 int32, distortion uintptr, result uintptr) (r int32) {
 	var allocated, tmp1, tmp2, v1, v2 uintptr
 	var metric AccumulateFunc
 	var x, y int32
 	var v5 float32
 	_, _, _, _, _, _, _, _, _ = allocated, metric, tmp1, tmp2, x, y, v1, v2, v5
 	allocated = libc.UintptrFromInt32(0)
 	if type1 == 0 {
 		v1 = __ccgo_fp(AccumulateSSE)
 	} else {
 		if type1 == int32(1) {
 			v2 = __ccgo_fp(AccumulateSSIM)
 		} else {
 			v2 = __ccgo_fp(AccumulateLSIM)
 		}
 		v1 = v2
 	}
 	metric = v1
 	if src == libc.UintptrFromInt32(0) || ref == libc.UintptrFromInt32(0) || src_stride < x_step*libc.Uint64FromInt32(width) || ref_stride < x_step*libc.Uint64FromInt32(width) || result == libc.UintptrFromInt32(0) || distortion == libc.UintptrFromInt32(0) {
 		return 0
 	}
 	VP8SSIMDspInit(tls)
 	if x_step != uint64(1) {
 		allocated = WebPSafeMalloc(tls, uint64(2)*libc.Uint64FromInt32(width)*libc.Uint64FromInt32(height), uint64(1))
 		if allocated == libc.UintptrFromInt32(0) {
 			return 0
 		}
 		tmp1 = allocated
 		tmp2 = tmp1 + uintptr(libc.Uint64FromInt32(width)*libc.Uint64FromInt32(height))
 		y = 0
 		for {
 			if !(y < height) {
 				break
 			}
 			x = 0
 			for {
 				if !(x < width) {
 					break
 				}
 				**(**uint8_t)(__ccgo_up(tmp1 + uintptr(x+y*width))) = **(**uint8_t)(__ccgo_up(src + uintptr(libc.Uint64FromInt32(x)*x_step+libc.Uint64FromInt32(y)*src_stride)))
 				**(**uint8_t)(__ccgo_up(tmp2 + uintptr(x+y*width))) = **(**uint8_t)(__ccgo_up(ref + uintptr(libc.Uint64FromInt32(x)*x_step+libc.Uint64FromInt32(y)*ref_stride)))
 				goto _4
 			_4:
 				;
 				x = x + 1
 			}
 			goto _3
 		_3:
 			;
 			y = y + 1
 		}
 		src = tmp1
 		ref = tmp2
 	}
 	**(**float32)(__ccgo_up(distortion)) = float32((*(*func(*libc.TLS, uintptr, int32, uintptr, int32, int32, int32) float64)(unsafe.Pointer(&struct{ uintptr }{metric})))(tls, src, width, ref, width, width, height))
 	WebPSafeFree(tls, allocated)
 	if type1 == int32(1) {
 		v5 = float32(GetLogSSIM(tls, float64(**(**float32)(__ccgo_up(distortion))), float64(float64(width)*float64(height))))
 	} else {
 		v5 = float32(GetPSNR1(tls, float64(**(**float32)(__ccgo_up(distortion))), float64(float64(width)*float64(height))))
 	}
 	**(**float32)(__ccgo_up(result)) = v5
 	return int32(1)
 }
 
 func WebPPictureDistortion(tls *libc.TLS, src uintptr, ref uintptr, type1 int32, results uintptr) (r int32) {
 	bp := tls.Alloc(528)
 	defer tls.Free(528)
 	var c, h, offset, ok, w, v1, v3 int32
 	var stride0, stride1 size_t
 	var total_distortion, total_size float64
 	var v5 bool
 	var v7 float32
 	var _ /* distortion at bp+512 */ float32
 	var _ /* p0 at bp+0 */ WebPPicture
 	var _ /* p1 at bp+256 */ WebPPicture
 	_, _, _, _, _, _, _, _, _, _, _, _, _ = c, h, offset, ok, stride0, stride1, total_distortion, total_size, w, v1, v3, v5, v7
 	ok = 0
 	total_size = float64(0)
 	total_distortion = float64(0)
 	if src == libc.UintptrFromInt32(0) || ref == libc.UintptrFromInt32(0) || (*WebPPicture)(unsafe.Pointer(src)).Fwidth != (*WebPPicture)(unsafe.Pointer(ref)).Fwidth || (*WebPPicture)(unsafe.Pointer(src)).Fheight != (*WebPPicture)(unsafe.Pointer(ref)).Fheight || results == libc.UintptrFromInt32(0) {
 		return 0
 	}
 	VP8SSIMDspInit(tls)
 	v1 = WebPPictureInitInternal(tls, bp, int32(WEBP_ENCODER_ABI_VERSION))
 	goto _2
 _2:
 	;
 	if v5 = !(v1 != 0); !v5 {
 		v3 = WebPPictureInitInternal(tls, bp+256, int32(WEBP_ENCODER_ABI_VERSION))
 		goto _4
 	_4:
 	}
 	if v5 || !(v3 != 0) {
 		return 0
 	}
 	w = (*WebPPicture)(unsafe.Pointer(src)).Fwidth
 	h = (*WebPPicture)(unsafe.Pointer(src)).Fheight
 	if !(WebPPictureView(tls, src, 0, 0, w, h, bp) != 0) {
 		goto Error
 	}
 	if !(WebPPictureView(tls, ref, 0, 0, w, h, bp+256) != 0) {
 		goto Error
 	}
 	// We always measure distortion in ARGB space.
 	if (**(**WebPPicture)(__ccgo_up(bp))).Fuse_argb == 0 && !(WebPPictureYUVAToARGB(tls, bp) != 0) {
 		goto Error
 	}
 	if (**(**WebPPicture)(__ccgo_up(bp + 256))).Fuse_argb == 0 && !(WebPPictureYUVAToARGB(tls, bp+256) != 0) {
 		goto Error
 	}
 	c = 0
 	for {
 		if !(c < int32(4)) {
 			break
 		}
 		stride0 = uint64(4) * libc.Uint64FromInt32((**(**WebPPicture)(__ccgo_up(bp))).Fargb_stride)
 		stride1 = uint64(4) * libc.Uint64FromInt32((**(**WebPPicture)(__ccgo_up(bp + 256))).Fargb_stride)
 		// results are reported as BGRA
 		offset = c ^ 0
 		if !(WebPPlaneDistortion(tls, (**(**WebPPicture)(__ccgo_up(bp))).Fargb+uintptr(offset), stride0, (**(**WebPPicture)(__ccgo_up(bp + 256))).Fargb+uintptr(offset), stride1, w, h, uint64(4), type1, bp+512, results+uintptr(c)*4) != 0) {
 			goto Error
 		}
 		total_distortion = total_distortion + float64(**(**float32)(__ccgo_up(bp + 512)))
 		total_size = total_size + float64(w*h)
 		goto _6
 	_6:
 		;
 		c = c + 1
 	}
 	if type1 == int32(1) {
 		v7 = float32(GetLogSSIM(tls, total_distortion, total_size))
 	} else {
 		v7 = float32(GetPSNR1(tls, total_distortion, total_size))
 	}
 	**(**float32)(__ccgo_up(results + 4*4)) = v7
 	ok = int32(1)
 	goto Error
 Error:
 	;
 	WebPPictureFree(tls, bp)
 	WebPPictureFree(tls, bp+256)
 	return ok
 }
 
 const __FLT_MIN__6 = 1.17549435082228750796873653722224568e-38
 
 //------------------------------------------------------------------------------
 
 // Copyright 2012 Google Inc. All Rights Reserved.
 //
 // Use of this source code is governed by a BSD-style license
 // that can be found in the COPYING file in the root of the source
 // tree. An additional intellectual property rights grant can be found
 // in the file PATENTS. All contributing project authors may
 // be found in the AUTHORS file in the root of the source tree.
 // -----------------------------------------------------------------------------
 //
 // Misc. common utility functions
 //
 // Authors: Skal (pascal.massimino@gmail.com)
 //          Urvang (urvang@google.com)
 
 // C documentation
 //
 //	// Grab the 'specs' (writer, *opaque, width, height...) from 'src' and copy them
 //	// into 'dst'. Mark 'dst' as not owning any memory.
 func PictureGrabSpecs(tls *libc.TLS, src uintptr, dst uintptr) {
 	**(**WebPPicture)(__ccgo_up(dst)) = **(**WebPPicture)(__ccgo_up(src))
 	WebPPictureResetBuffers(tls, dst)
 }
 
 //------------------------------------------------------------------------------
 
 // C documentation
 //
 //	// Adjust top-left corner to chroma sample position.
 func SnapTopLeftPosition(tls *libc.TLS, pic uintptr, left uintptr, top uintptr) {
 	if !((*WebPPicture)(unsafe.Pointer(pic)).Fuse_argb != 0) {
 		**(**int32)(__ccgo_up(left)) &= ^libc.Int32FromInt32(1)
 		**(**int32)(__ccgo_up(top)) &= ^libc.Int32FromInt32(1)
 	}
 }
 
 // C documentation
 //
 //	// Adjust top-left corner and verify that the sub-rectangle is valid.
 func AdjustAndCheckRectangle(tls *libc.TLS, pic uintptr, left uintptr, top uintptr, width int32, height int32) (r int32) {
 	SnapTopLeftPosition(tls, pic, left, top)
 	if **(**int32)(__ccgo_up(left)) < 0 || **(**int32)(__ccgo_up(top)) < 0 {
 		return 0
 	}
 	if width <= 0 || height <= 0 {
 		return 0
 	}
 	if **(**int32)(__ccgo_up(left))+width > (*WebPPicture)(unsafe.Pointer(pic)).Fwidth {
 		return 0
 	}
 	if **(**int32)(__ccgo_up(top))+height > (*WebPPicture)(unsafe.Pointer(pic)).Fheight {
 		return 0
 	}
 	return int32(1)
 }
 
 func WebPPictureCopy(tls *libc.TLS, src uintptr, dst uintptr) (r int32) {
 	if src == libc.UintptrFromInt32(0) || dst == libc.UintptrFromInt32(0) {
 		return 0
 	}
 	if src == dst {
 		return int32(1)
 	}
 	PictureGrabSpecs(tls, src, dst)
 	if !(WebPPictureAlloc(tls, dst) != 0) {
 		return 0
 	}
 	if !((*WebPPicture)(unsafe.Pointer(src)).Fuse_argb != 0) {
 		WebPCopyPlane(tls, (*WebPPicture)(unsafe.Pointer(src)).Fy, (*WebPPicture)(unsafe.Pointer(src)).Fy_stride, (*WebPPicture)(unsafe.Pointer(dst)).Fy, (*WebPPicture)(unsafe.Pointer(dst)).Fy_stride, (*WebPPicture)(unsafe.Pointer(dst)).Fwidth, (*WebPPicture)(unsafe.Pointer(dst)).Fheight)
 		WebPCopyPlane(tls, (*WebPPicture)(unsafe.Pointer(src)).Fu, (*WebPPicture)(unsafe.Pointer(src)).Fuv_stride, (*WebPPicture)(unsafe.Pointer(dst)).Fu, (*WebPPicture)(unsafe.Pointer(dst)).Fuv_stride, ((*WebPPicture)(unsafe.Pointer(dst)).Fwidth+int32(1))>>int32(1), ((*WebPPicture)(unsafe.Pointer(dst)).Fheight+int32(1))>>int32(1))
 		WebPCopyPlane(tls, (*WebPPicture)(unsafe.Pointer(src)).Fv, (*WebPPicture)(unsafe.Pointer(src)).Fuv_stride, (*WebPPicture)(unsafe.Pointer(dst)).Fv, (*WebPPicture)(unsafe.Pointer(dst)).Fuv_stride, ((*WebPPicture)(unsafe.Pointer(dst)).Fwidth+int32(1))>>int32(1), ((*WebPPicture)(unsafe.Pointer(dst)).Fheight+int32(1))>>int32(1))
 		if (*WebPPicture)(unsafe.Pointer(dst)).Fa != libc.UintptrFromInt32(0) {
 			WebPCopyPlane(tls, (*WebPPicture)(unsafe.Pointer(src)).Fa, (*WebPPicture)(unsafe.Pointer(src)).Fa_stride, (*WebPPicture)(unsafe.Pointer(dst)).Fa, (*WebPPicture)(unsafe.Pointer(dst)).Fa_stride, (*WebPPicture)(unsafe.Pointer(dst)).Fwidth, (*WebPPicture)(unsafe.Pointer(dst)).Fheight)
 		}
 	} else {
 		WebPCopyPlane(tls, (*WebPPicture)(unsafe.Pointer(src)).Fargb, int32(4)*(*WebPPicture)(unsafe.Pointer(src)).Fargb_stride, (*WebPPicture)(unsafe.Pointer(dst)).Fargb, int32(4)*(*WebPPicture)(unsafe.Pointer(dst)).Fargb_stride, int32(4)*(*WebPPicture)(unsafe.Pointer(dst)).Fwidth, (*WebPPicture)(unsafe.Pointer(dst)).Fheight)
 	}
 	return int32(1)
 }
 
 func WebPPictureIsView(tls *libc.TLS, picture uintptr) (r int32) {
 	if picture == libc.UintptrFromInt32(0) {
 		return 0
 	}
 	if (*WebPPicture)(unsafe.Pointer(picture)).Fuse_argb != 0 {
 		return libc.BoolInt32((*WebPPicture)(unsafe.Pointer(picture)).Fmemory_argb_ == libc.UintptrFromInt32(0))
 	}
 	return libc.BoolInt32((*WebPPicture)(unsafe.Pointer(picture)).Fmemory_ == libc.UintptrFromInt32(0))
 }
 
 func WebPPictureView(tls *libc.TLS, src uintptr, _left int32, _top int32, width int32, height int32, dst uintptr) (r int32) {
 	bp := tls.Alloc(16)
 	defer tls.Free(16)
 	*(*int32)(unsafe.Pointer(bp)) = _left
 	*(*int32)(unsafe.Pointer(bp + 4)) = _top
 	if src == libc.UintptrFromInt32(0) || dst == libc.UintptrFromInt32(0) {
 		return 0
 	}
 	// verify rectangle position.
 	if !(AdjustAndCheckRectangle(tls, src, bp, bp+4, width, height) != 0) {
 		return 0
 	}
 	if src != dst { // beware of aliasing! We don't want to leak 'memory_'.
 		PictureGrabSpecs(tls, src, dst)
 	}
 	(*WebPPicture)(unsafe.Pointer(dst)).Fwidth = width
 	(*WebPPicture)(unsafe.Pointer(dst)).Fheight = height
 	if !((*WebPPicture)(unsafe.Pointer(src)).Fuse_argb != 0) {
 		(*WebPPicture)(unsafe.Pointer(dst)).Fy = (*WebPPicture)(unsafe.Pointer(src)).Fy + uintptr(**(**int32)(__ccgo_up(bp + 4))*(*WebPPicture)(unsafe.Pointer(src)).Fy_stride) + uintptr(**(**int32)(__ccgo_up(bp)))
 		(*WebPPicture)(unsafe.Pointer(dst)).Fu = (*WebPPicture)(unsafe.Pointer(src)).Fu + uintptr(**(**int32)(__ccgo_up(bp + 4))>>int32(1)*(*WebPPicture)(unsafe.Pointer(src)).Fuv_stride) + uintptr(**(**int32)(__ccgo_up(bp))>>libc.Int32FromInt32(1))
 		(*WebPPicture)(unsafe.Pointer(dst)).Fv = (*WebPPicture)(unsafe.Pointer(src)).Fv + uintptr(**(**int32)(__ccgo_up(bp + 4))>>int32(1)*(*WebPPicture)(unsafe.Pointer(src)).Fuv_stride) + uintptr(**(**int32)(__ccgo_up(bp))>>libc.Int32FromInt32(1))
 		(*WebPPicture)(unsafe.Pointer(dst)).Fy_stride = (*WebPPicture)(unsafe.Pointer(src)).Fy_stride
 		(*WebPPicture)(unsafe.Pointer(dst)).Fuv_stride = (*WebPPicture)(unsafe.Pointer(src)).Fuv_stride
 		if (*WebPPicture)(unsafe.Pointer(src)).Fa != libc.UintptrFromInt32(0) {
 			(*WebPPicture)(unsafe.Pointer(dst)).Fa = (*WebPPicture)(unsafe.Pointer(src)).Fa + uintptr(**(**int32)(__ccgo_up(bp + 4))*(*WebPPicture)(unsafe.Pointer(src)).Fa_stride) + uintptr(**(**int32)(__ccgo_up(bp)))
 			(*WebPPicture)(unsafe.Pointer(dst)).Fa_stride = (*WebPPicture)(unsafe.Pointer(src)).Fa_stride
 		}
 	} else {
 		(*WebPPicture)(unsafe.Pointer(dst)).Fargb = (*WebPPicture)(unsafe.Pointer(src)).Fargb + uintptr(**(**int32)(__ccgo_up(bp + 4))*(*WebPPicture)(unsafe.Pointer(src)).Fargb_stride)*4 + uintptr(**(**int32)(__ccgo_up(bp)))*4
 		(*WebPPicture)(unsafe.Pointer(dst)).Fargb_stride = (*WebPPicture)(unsafe.Pointer(src)).Fargb_stride
 	}
 	return int32(1)
 }
 
 //------------------------------------------------------------------------------
 // Picture cropping
 
 func WebPPictureCrop(tls *libc.TLS, pic uintptr, _left int32, _top int32, width int32, height int32) (r int32) {
 	bp := tls.Alloc(272)
 	defer tls.Free(272)
 	*(*int32)(unsafe.Pointer(bp)) = _left
 	*(*int32)(unsafe.Pointer(bp + 4)) = _top
 	var a_offset, uv_offset, y_offset int32
 	var src uintptr
 	var _ /* tmp at bp+8 */ WebPPicture
 	_, _, _, _ = a_offset, src, uv_offset, y_offset
 	if pic == libc.UintptrFromInt32(0) {
 		return 0
 	}
 	if !(AdjustAndCheckRectangle(tls, pic, bp, bp+4, width, height) != 0) {
 		return 0
 	}
 	PictureGrabSpecs(tls, pic, bp+8)
 	(**(**WebPPicture)(__ccgo_up(bp + 8))).Fwidth = width
 	(**(**WebPPicture)(__ccgo_up(bp + 8))).Fheight = height
 	if !(WebPPictureAlloc(tls, bp+8) != 0) {
 		return WebPEncodingSetError(tls, pic, (**(**WebPPicture)(__ccgo_up(bp + 8))).Ferror_code)
 	}
 	if !((*WebPPicture)(unsafe.Pointer(pic)).Fuse_argb != 0) {
 		y_offset = **(**int32)(__ccgo_up(bp + 4))*(*WebPPicture)(unsafe.Pointer(pic)).Fy_stride + **(**int32)(__ccgo_up(bp))
 		uv_offset = **(**int32)(__ccgo_up(bp + 4))/int32(2)*(*WebPPicture)(unsafe.Pointer(pic)).Fuv_stride + **(**int32)(__ccgo_up(bp))/int32(2)
 		WebPCopyPlane(tls, (*WebPPicture)(unsafe.Pointer(pic)).Fy+uintptr(y_offset), (*WebPPicture)(unsafe.Pointer(pic)).Fy_stride, (**(**WebPPicture)(__ccgo_up(bp + 8))).Fy, (**(**WebPPicture)(__ccgo_up(bp + 8))).Fy_stride, width, height)
 		WebPCopyPlane(tls, (*WebPPicture)(unsafe.Pointer(pic)).Fu+uintptr(uv_offset), (*WebPPicture)(unsafe.Pointer(pic)).Fuv_stride, (**(**WebPPicture)(__ccgo_up(bp + 8))).Fu, (**(**WebPPicture)(__ccgo_up(bp + 8))).Fuv_stride, (width+int32(1))>>int32(1), (height+int32(1))>>int32(1))
 		WebPCopyPlane(tls, (*WebPPicture)(unsafe.Pointer(pic)).Fv+uintptr(uv_offset), (*WebPPicture)(unsafe.Pointer(pic)).Fuv_stride, (**(**WebPPicture)(__ccgo_up(bp + 8))).Fv, (**(**WebPPicture)(__ccgo_up(bp + 8))).Fuv_stride, (width+int32(1))>>int32(1), (height+int32(1))>>int32(1))
 		if (**(**WebPPicture)(__ccgo_up(bp + 8))).Fa != libc.UintptrFromInt32(0) {
 			a_offset = **(**int32)(__ccgo_up(bp + 4))*(*WebPPicture)(unsafe.Pointer(pic)).Fa_stride + **(**int32)(__ccgo_up(bp))
 			WebPCopyPlane(tls, (*WebPPicture)(unsafe.Pointer(pic)).Fa+uintptr(a_offset), (*WebPPicture)(unsafe.Pointer(pic)).Fa_stride, (**(**WebPPicture)(__ccgo_up(bp + 8))).Fa, (**(**WebPPicture)(__ccgo_up(bp + 8))).Fa_stride, width, height)
 		}
 	} else {
 		src = (*WebPPicture)(unsafe.Pointer(pic)).Fargb + uintptr(**(**int32)(__ccgo_up(bp + 4))*(*WebPPicture)(unsafe.Pointer(pic)).Fargb_stride)*4 + uintptr(**(**int32)(__ccgo_up(bp)))*4
 		WebPCopyPlane(tls, src, (*WebPPicture)(unsafe.Pointer(pic)).Fargb_stride*int32(4), (**(**WebPPicture)(__ccgo_up(bp + 8))).Fargb, (**(**WebPPicture)(__ccgo_up(bp + 8))).Fargb_stride*int32(4), width*int32(4), height)
 	}
 	WebPPictureFree(tls, pic)
 	**(**WebPPicture)(__ccgo_up(pic)) = **(**WebPPicture)(__ccgo_up(bp + 8))
 	return int32(1)
 }
 
 //------------------------------------------------------------------------------
 // Simple picture rescaler
 
 func RescalePlane(tls *libc.TLS, src uintptr, src_width int32, src_height int32, src_stride int32, dst uintptr, dst_width int32, dst_height int32, dst_stride int32, work uintptr, num_channels int32) (r int32) {
 	bp := tls.Alloc(112)
 	defer tls.Free(112)
 	var y int32
 	var _ /* rescaler at bp+0 */ WebPRescaler
 	_ = y
 	y = 0
 	if !(WebPRescalerInit(tls, bp, src_width, src_height, dst, dst_width, dst_height, dst_stride, num_channels, work) != 0) {
 		return 0
 	}
 	for y < src_height {
 		y = y + WebPRescalerImport(tls, bp, src_height-y, src+uintptr(y*src_stride), src_stride)
 		WebPRescalerExport(tls, bp)
 	}
 	return int32(1)
 }
 
 func AlphaMultiplyARGB(tls *libc.TLS, pic uintptr, inverse int32) {
 	WebPMultARGBRows(tls, (*WebPPicture)(unsafe.Pointer(pic)).Fargb, libc.Int32FromUint64(libc.Uint64FromInt32((*WebPPicture)(unsafe.Pointer(pic)).Fargb_stride)*uint64(4)), (*WebPPicture)(unsafe.Pointer(pic)).Fwidth, (*WebPPicture)(unsafe.Pointer(pic)).Fheight, inverse)
 }
 
 func AlphaMultiplyY(tls *libc.TLS, pic uintptr, inverse int32) {
 	if (*WebPPicture)(unsafe.Pointer(pic)).Fa != libc.UintptrFromInt32(0) {
 		WebPMultRows(tls, (*WebPPicture)(unsafe.Pointer(pic)).Fy, (*WebPPicture)(unsafe.Pointer(pic)).Fy_stride, (*WebPPicture)(unsafe.Pointer(pic)).Fa, (*WebPPicture)(unsafe.Pointer(pic)).Fa_stride, (*WebPPicture)(unsafe.Pointer(pic)).Fwidth, (*WebPPicture)(unsafe.Pointer(pic)).Fheight, inverse)
 	}
 }
 
 func WebPPictureRescale(tls *libc.TLS, picture uintptr, _width int32, _height int32) (r int32) {
 	bp := tls.Alloc(272)
 	defer tls.Free(272)
 	*(*int32)(unsafe.Pointer(bp)) = _width
 	*(*int32)(unsafe.Pointer(bp + 4)) = _height
 	var prev_height, prev_width int32
 	var work uintptr
 	var _ /* tmp at bp+8 */ WebPPicture
 	_, _, _ = prev_height, prev_width, work
 	if picture == libc.UintptrFromInt32(0) {
 		return 0
 	}
 	prev_width = (*WebPPicture)(unsafe.Pointer(picture)).Fwidth
 	prev_height = (*WebPPicture)(unsafe.Pointer(picture)).Fheight
 	if !(WebPRescalerGetScaledDimensions(tls, prev_width, prev_height, bp, bp+4) != 0) {
 		return WebPEncodingSetError(tls, picture, int32(VP8_ENC_ERROR_BAD_DIMENSION))
 	}
 	PictureGrabSpecs(tls, picture, bp+8)
 	(**(**WebPPicture)(__ccgo_up(bp + 8))).Fwidth = **(**int32)(__ccgo_up(bp))
 	(**(**WebPPicture)(__ccgo_up(bp + 8))).Fheight = **(**int32)(__ccgo_up(bp + 4))
 	if !(WebPPictureAlloc(tls, bp+8) != 0) {
 		return WebPEncodingSetError(tls, picture, (**(**WebPPicture)(__ccgo_up(bp + 8))).Ferror_code)
 	}
 	if !((*WebPPicture)(unsafe.Pointer(picture)).Fuse_argb != 0) {
 		work = WebPSafeMalloc(tls, uint64(2)*libc.Uint64FromInt32(**(**int32)(__ccgo_up(bp))), uint64(4))
 		if work == libc.UintptrFromInt32(0) {
 			WebPPictureFree(tls, bp+8)
 			return WebPEncodingSetError(tls, picture, int32(VP8_ENC_ERROR_OUT_OF_MEMORY))
 		}
 		// If present, we need to rescale alpha first (for AlphaMultiplyY).
 		if (*WebPPicture)(unsafe.Pointer(picture)).Fa != libc.UintptrFromInt32(0) {
 			WebPInitAlphaProcessing(tls)
 			if !(RescalePlane(tls, (*WebPPicture)(unsafe.Pointer(picture)).Fa, prev_width, prev_height, (*WebPPicture)(unsafe.Pointer(picture)).Fa_stride, (**(**WebPPicture)(__ccgo_up(bp + 8))).Fa, **(**int32)(__ccgo_up(bp)), **(**int32)(__ccgo_up(bp + 4)), (**(**WebPPicture)(__ccgo_up(bp + 8))).Fa_stride, work, int32(1)) != 0) {
 				return WebPEncodingSetError(tls, picture, int32(VP8_ENC_ERROR_BAD_DIMENSION))
 			}
 		}
 		// We take transparency into account on the luma plane only. That's not
 		// totally exact blending, but still is a good approximation.
 		AlphaMultiplyY(tls, picture, 0)
 		if !(RescalePlane(tls, (*WebPPicture)(unsafe.Pointer(picture)).Fy, prev_width, prev_height, (*WebPPicture)(unsafe.Pointer(picture)).Fy_stride, (**(**WebPPicture)(__ccgo_up(bp + 8))).Fy, **(**int32)(__ccgo_up(bp)), **(**int32)(__ccgo_up(bp + 4)), (**(**WebPPicture)(__ccgo_up(bp + 8))).Fy_stride, work, int32(1)) != 0) || !(RescalePlane(tls, (*WebPPicture)(unsafe.Pointer(picture)).Fu, (prev_width+int32(1))>>int32(1), (prev_height+int32(1))>>int32(1), (*WebPPicture)(unsafe.Pointer(picture)).Fuv_stride, (**(**WebPPicture)(__ccgo_up(bp + 8))).Fu, (**(**int32)(__ccgo_up(bp))+int32(1))>>int32(1), (**(**int32)(__ccgo_up(bp + 4))+int32(1))>>int32(1), (**(**WebPPicture)(__ccgo_up(bp + 8))).Fuv_stride, work, int32(1)) != 0) || !(RescalePlane(tls, (*WebPPicture)(unsafe.Pointer(picture)).Fv, (prev_width+int32(1))>>int32(1), (prev_height+int32(1))>>int32(1), (*WebPPicture)(unsafe.Pointer(picture)).Fuv_stride, (**(**WebPPicture)(__ccgo_up(bp + 8))).Fv, (**(**int32)(__ccgo_up(bp))+int32(1))>>int32(1), (**(**int32)(__ccgo_up(bp + 4))+int32(1))>>int32(1), (**(**WebPPicture)(__ccgo_up(bp + 8))).Fuv_stride, work, int32(1)) != 0) {
 			return WebPEncodingSetError(tls, picture, int32(VP8_ENC_ERROR_BAD_DIMENSION))
 		}
 		AlphaMultiplyY(tls, bp+8, int32(1))
 	} else {
 		work = WebPSafeMalloc(tls, uint64(2)*libc.Uint64FromInt32(**(**int32)(__ccgo_up(bp)))*uint64(4), uint64(4))
 		if work == libc.UintptrFromInt32(0) {
 			WebPPictureFree(tls, bp+8)
 			return WebPEncodingSetError(tls, picture, int32(VP8_ENC_ERROR_OUT_OF_MEMORY))
 		}
 		// In order to correctly interpolate colors, we need to apply the alpha
 		// weighting first (black-matting), scale the RGB values, and remove
 		// the premultiplication afterward (while preserving the alpha channel).
 		WebPInitAlphaProcessing(tls)
 		AlphaMultiplyARGB(tls, picture, 0)
 		if !(RescalePlane(tls, (*WebPPicture)(unsafe.Pointer(picture)).Fargb, prev_width, prev_height, (*WebPPicture)(unsafe.Pointer(picture)).Fargb_stride*int32(4), (**(**WebPPicture)(__ccgo_up(bp + 8))).Fargb, **(**int32)(__ccgo_up(bp)), **(**int32)(__ccgo_up(bp + 4)), (**(**WebPPicture)(__ccgo_up(bp + 8))).Fargb_stride*int32(4), work, int32(4)) != 0) {
 			return WebPEncodingSetError(tls, picture, int32(VP8_ENC_ERROR_BAD_DIMENSION))
 		}
 		AlphaMultiplyARGB(tls, bp+8, int32(1))
 	}
 	WebPPictureFree(tls, picture)
 	WebPSafeFree(tls, work)
 	**(**WebPPicture)(__ccgo_up(picture)) = **(**WebPPicture)(__ccgo_up(bp + 8))
 	return int32(1)
 }
 
 //------------------------------------------------------------------------------
 
 // Copyright 2011 Google Inc. All Rights Reserved.
 //
 // Use of this source code is governed by a BSD-style license
 // that can be found in the COPYING file in the root of the source
 // tree. An additional intellectual property rights grant can be found
 // in the file PATENTS. All contributing project authors may
 // be found in the AUTHORS file in the root of the source tree.
 // -----------------------------------------------------------------------------
 //
 //   WebP encoder: main interface
 //
 // Author: Skal (pascal.massimino@gmail.com)
 
 // Copyright 2010 Google Inc. All Rights Reserved.
 //
 // Use of this source code is governed by a BSD-style license
 // that can be found in the COPYING file in the root of the source
 // tree. An additional intellectual property rights grant can be found
 // in the file PATENTS. All contributing project authors may
 // be found in the AUTHORS file in the root of the source tree.
 // -----------------------------------------------------------------------------
 //
 //  Common types + memory wrappers
 //
 // Author: Skal (pascal.massimino@gmail.com)
 
 //------------------------------------------------------------------------------
 // Helper: clean up fully transparent area to help compressibility.
 
 func IsTransparentARGBArea(tls *libc.TLS, ptr uintptr, stride int32, size int32) (r int32) {
 	var x, y int32
 	_, _ = x, y
 	y = 0
 	for {
 		if !(y < size) {
 			break
 		}
 		x = 0
 		for {
 			if !(x < size) {
 				break
 			}
 			if **(**uint32_t)(__ccgo_up(ptr + uintptr(x)*4))&uint32(0xff000000) != 0 {
 				return 0
 			}
 			goto _2
 		_2:
 			;
 			x = x + 1
 		}
 		ptr = ptr + uintptr(stride)*4
 		goto _1
 	_1:
 		;
 		y = y + 1
 	}
 	return int32(1)
 }
 
 func Flatten(tls *libc.TLS, ptr uintptr, v int32, stride int32, size int32) {
 	var y int32
 	_ = y
 	y = 0
 	for {
 		if !(y < size) {
 			break
 		}
 		libc.X__builtin___memset_chk(tls, ptr, v, libc.Uint64FromInt32(size), ^__predefined_size_t(0))
 		ptr = ptr + uintptr(stride)
 		goto _1
 	_1:
 		;
 		y = y + 1
 	}
 }
 
 func FlattenARGB(tls *libc.TLS, ptr uintptr, v uint32_t, stride int32, size int32) {
 	var x, y int32
 	_, _ = x, y
 	y = 0
 	for {
 		if !(y < size) {
 			break
 		}
 		x = 0
 		for {
 			if !(x < size) {
 				break
 			}
 			**(**uint32_t)(__ccgo_up(ptr + uintptr(x)*4)) = v
 			goto _2
 		_2:
 			;
 			x = x + 1
 		}
 		ptr = ptr + uintptr(stride)*4
 		goto _1
 	_1:
 		;
 		y = y + 1
 	}
 }
 
 // C documentation
 //
 //	// Smoothen the luma components of transparent pixels. Return true if the whole
 //	// block is transparent.
 func SmoothenBlock(tls *libc.TLS, a_ptr uintptr, a_stride int32, y_ptr uintptr, y_stride int32, width int32, height int32) (r int32) {
 	var alpha_ptr, luma_ptr uintptr
 	var avg_u8 uint8_t
 	var count, sum, x, y int32
 	_, _, _, _, _, _, _ = alpha_ptr, avg_u8, count, luma_ptr, sum, x, y
 	sum = 0
 	count = 0
 	alpha_ptr = a_ptr
 	luma_ptr = y_ptr
 	y = 0
 	for {
 		if !(y < height) {
 			break
 		}
 		x = 0
 		for {
 			if !(x < width) {
 				break
 			}
 			if libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(alpha_ptr + uintptr(x)))) != 0 {
 				count = count + 1
 				sum = sum + libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(luma_ptr + uintptr(x))))
 			}
 			goto _2
 		_2:
 			;
 			x = x + 1
 		}
 		alpha_ptr = alpha_ptr + uintptr(a_stride)
 		luma_ptr = luma_ptr + uintptr(y_stride)
 		goto _1
 	_1:
 		;
 		y = y + 1
 	}
 	if count > 0 && count < width*height {
 		avg_u8 = libc.Uint8FromInt32(sum / count)
 		alpha_ptr = a_ptr
 		luma_ptr = y_ptr
 		y = 0
 		for {
 			if !(y < height) {
 				break
 			}
 			x = 0
 			for {
 				if !(x < width) {
 					break
 				}
 				if libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(alpha_ptr + uintptr(x)))) == 0 {
 					**(**uint8_t)(__ccgo_up(luma_ptr + uintptr(x))) = avg_u8
 				}
 				goto _4
 			_4:
 				;
 				x = x + 1
 			}
 			alpha_ptr = alpha_ptr + uintptr(a_stride)
 			luma_ptr = luma_ptr + uintptr(y_stride)
 			goto _3
 		_3:
 			;
 			y = y + 1
 		}
 	}
 	return libc.BoolInt32(count == 0)
 }
 
 func WebPReplaceTransparentPixels(tls *libc.TLS, pic uintptr, color uint32_t) {
 	var argb uintptr
 	var y, v1 int32
 	_, _, _ = argb, y, v1
 	if pic != libc.UintptrFromInt32(0) && (*WebPPicture)(unsafe.Pointer(pic)).Fuse_argb != 0 {
 		y = (*WebPPicture)(unsafe.Pointer(pic)).Fheight
 		argb = (*WebPPicture)(unsafe.Pointer(pic)).Fargb
 		color = color & uint32(0xffffff) // force alpha=0
 		WebPInitAlphaProcessing(tls)
 		for {
 			v1 = y
 			y = y - 1
 			if !(v1 > 0) {
 				break
 			}
 			(*(*func(*libc.TLS, uintptr, int32, uint32_t))(unsafe.Pointer(&struct{ uintptr }{WebPAlphaReplace})))(tls, argb, (*WebPPicture)(unsafe.Pointer(pic)).Fwidth, color)
 			argb = argb + uintptr((*WebPPicture)(unsafe.Pointer(pic)).Fargb_stride)*4
 		}
 	}
 }
 
 func WebPCleanupTransparentArea(tls *libc.TLS, pic uintptr) {
 	var a_ptr, u_ptr, v_ptr, y_ptr uintptr
 	var a_stride, h, height, need_reset, need_reset1, off, sub_height, uv_stride, w, width, x, y, y_stride int32
 	var argb_value uint32_t
 	var values [3]int32
 	_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = a_ptr, a_stride, argb_value, h, height, need_reset, need_reset1, off, sub_height, u_ptr, uv_stride, v_ptr, values, w, width, x, y, y_ptr, y_stride
 	if pic == libc.UintptrFromInt32(0) {
 		return
 	}
 	w = (*WebPPicture)(unsafe.Pointer(pic)).Fwidth / int32(8)
 	h = (*WebPPicture)(unsafe.Pointer(pic)).Fheight / int32(8)
 	// note: we ignore the left-overs on right/bottom, except for SmoothenBlock().
 	if (*WebPPicture)(unsafe.Pointer(pic)).Fuse_argb != 0 {
 		argb_value = uint32(0)
 		y = 0
 		for {
 			if !(y < h) {
 				break
 			}
 			need_reset = int32(1)
 			x = 0
 			for {
 				if !(x < w) {
 					break
 				}
 				off = (y*(*WebPPicture)(unsafe.Pointer(pic)).Fargb_stride + x) * int32(8)
 				if IsTransparentARGBArea(tls, (*WebPPicture)(unsafe.Pointer(pic)).Fargb+uintptr(off)*4, (*WebPPicture)(unsafe.Pointer(pic)).Fargb_stride, int32(8)) != 0 {
 					if need_reset != 0 {
 						argb_value = **(**uint32_t)(__ccgo_up((*WebPPicture)(unsafe.Pointer(pic)).Fargb + uintptr(off)*4))
 						need_reset = 0
 					}
 					FlattenARGB(tls, (*WebPPicture)(unsafe.Pointer(pic)).Fargb+uintptr(off)*4, argb_value, (*WebPPicture)(unsafe.Pointer(pic)).Fargb_stride, int32(8))
 				} else {
 					need_reset = int32(1)
 				}
 				goto _2
 			_2:
 				;
 				x = x + 1
 			}
 			goto _1
 		_1:
 			;
 			y = y + 1
 		}
 	} else {
 		width = (*WebPPicture)(unsafe.Pointer(pic)).Fwidth
 		height = (*WebPPicture)(unsafe.Pointer(pic)).Fheight
 		y_stride = (*WebPPicture)(unsafe.Pointer(pic)).Fy_stride
 		uv_stride = (*WebPPicture)(unsafe.Pointer(pic)).Fuv_stride
 		a_stride = (*WebPPicture)(unsafe.Pointer(pic)).Fa_stride
 		y_ptr = (*WebPPicture)(unsafe.Pointer(pic)).Fy
 		u_ptr = (*WebPPicture)(unsafe.Pointer(pic)).Fu
 		v_ptr = (*WebPPicture)(unsafe.Pointer(pic)).Fv
 		a_ptr = (*WebPPicture)(unsafe.Pointer(pic)).Fa
 		values = [3]int32{}
 		if a_ptr == libc.UintptrFromInt32(0) || y_ptr == libc.UintptrFromInt32(0) || u_ptr == libc.UintptrFromInt32(0) || v_ptr == libc.UintptrFromInt32(0) {
 			return
 		}
 		y = 0
 		for {
 			if !(y+int32(8) <= height) {
 				break
 			}
 			need_reset1 = int32(1)
 			x = 0
 			for {
 				if !(x+int32(8) <= width) {
 					break
 				}
 				if SmoothenBlock(tls, a_ptr+uintptr(x), a_stride, y_ptr+uintptr(x), y_stride, int32(8), int32(8)) != 0 {
 					if need_reset1 != 0 {
 						values[0] = libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(y_ptr + uintptr(x))))
 						values[int32(1)] = libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(u_ptr + uintptr(x>>int32(1)))))
 						values[int32(2)] = libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(v_ptr + uintptr(x>>int32(1)))))
 						need_reset1 = 0
 					}
 					Flatten(tls, y_ptr+uintptr(x), values[0], y_stride, int32(8))
 					Flatten(tls, u_ptr+uintptr(x>>libc.Int32FromInt32(1)), values[int32(1)], uv_stride, libc.Int32FromInt32(8)/libc.Int32FromInt32(2))
 					Flatten(tls, v_ptr+uintptr(x>>libc.Int32FromInt32(1)), values[int32(2)], uv_stride, libc.Int32FromInt32(8)/libc.Int32FromInt32(2))
 				} else {
 					need_reset1 = int32(1)
 				}
 				goto _4
 			_4:
 				;
 				x = x + int32(8)
 			}
 			if x < width {
 				SmoothenBlock(tls, a_ptr+uintptr(x), a_stride, y_ptr+uintptr(x), y_stride, width-x, int32(8))
 			}
 			a_ptr = a_ptr + uintptr(int32(8)*a_stride)
 			y_ptr = y_ptr + uintptr(int32(8)*y_stride)
 			u_ptr = u_ptr + uintptr(libc.Int32FromInt32(8)/libc.Int32FromInt32(2)*uv_stride)
 			v_ptr = v_ptr + uintptr(libc.Int32FromInt32(8)/libc.Int32FromInt32(2)*uv_stride)
 			goto _3
 		_3:
 			;
 			y = y + int32(8)
 		}
 		if y < height {
 			sub_height = height - y
 			x = 0
 			for {
 				if !(x+int32(8) <= width) {
 					break
 				}
 				SmoothenBlock(tls, a_ptr+uintptr(x), a_stride, y_ptr+uintptr(x), y_stride, int32(8), sub_height)
 				goto _5
 			_5:
 				;
 				x = x + int32(8)
 			}
 			if x < width {
 				SmoothenBlock(tls, a_ptr+uintptr(x), a_stride, y_ptr+uintptr(x), y_stride, width-x, sub_height)
 			}
 		}
 	}
 }
 
 //------------------------------------------------------------------------------
 // Blend color and remove transparency info
 
 func MakeARGB32(tls *libc.TLS, r int32, g int32, b int32) (r1 uint32_t) {
 	return libc.Uint32FromUint32(0xff000000) | libc.Uint32FromInt32(r<<libc.Int32FromInt32(16)) | libc.Uint32FromInt32(g<<libc.Int32FromInt32(8)) | libc.Uint32FromInt32(b)
 }
 
 func WebPBlendAlpha(tls *libc.TLS, picture uintptr, background_rgb uint32_t) {
 	var U0, V0, Y0, alpha3, b3, blue, g3, green, has_alpha, luma, r3, red, u, uv_width, v, x, y, v1, v10, v12, v13, v15, v16, v3, v5, v6, v8, v9 int32
 	var a_ptr, a_ptr2, argb, u_ptr, v_ptr, y_ptr, v19 uintptr
 	var alpha uint8_t
 	var alpha1, alpha2, background uint32_t
 	_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = U0, V0, Y0, a_ptr, a_ptr2, alpha, alpha1, alpha2, alpha3, argb, b3, background, blue, g3, green, has_alpha, luma, r3, red, u, u_ptr, uv_width, v, v_ptr, x, y, y_ptr, v1, v10, v12, v13, v15, v16, v19, v3, v5, v6, v8, v9
 	red = libc.Int32FromUint32(background_rgb >> libc.Int32FromInt32(16) & uint32(0xff))
 	green = libc.Int32FromUint32(background_rgb >> libc.Int32FromInt32(8) & uint32(0xff))
 	blue = libc.Int32FromUint32(background_rgb >> libc.Int32FromInt32(0) & uint32(0xff))
 	if picture == libc.UintptrFromInt32(0) {
 		return
 	}
 	if !((*WebPPicture)(unsafe.Pointer(picture)).Fuse_argb != 0) {
 		// omit last pixel during u/v loop
 		uv_width = (*WebPPicture)(unsafe.Pointer(picture)).Fwidth >> libc.Int32FromInt32(1)
 		luma = int32(16839)*red + int32(33059)*green + int32(6420)*blue
 		v1 = (luma + int32(YUV_HALF) + libc.Int32FromInt32(16)<<int32(YUV_FIX)) >> int32(YUV_FIX)
 		goto _2
 	_2:
 		Y0 = v1
 		u = -int32(9719)*(int32(4)*red) - int32(19081)*(int32(4)*green) + int32(28800)*(int32(4)*blue)
 		v5 = u
 		v5 = (v5 + libc.Int32FromInt32(4)*int32(YUV_HALF) + libc.Int32FromInt32(128)<<(int32(YUV_FIX)+libc.Int32FromInt32(2))) >> (int32(YUV_FIX) + libc.Int32FromInt32(2))
 		if v5 & ^libc.Int32FromInt32(0xff) == 0 {
 			v8 = v5
 		} else {
 			if v5 < 0 {
 				v9 = 0
 			} else {
 				v9 = int32(255)
 			}
 			v8 = v9
 		}
 		v6 = v8
 		goto _7
 	_7:
 		v3 = v6
 		goto _4
 	_4:
 		// VP8RGBToU/V expects the u/v values summed over four pixels
 		U0 = v3
 		v = +libc.Int32FromInt32(28800)*(int32(4)*red) - int32(24116)*(int32(4)*green) - int32(4684)*(int32(4)*blue)
 		v12 = v
 		v12 = (v12 + libc.Int32FromInt32(4)*int32(YUV_HALF) + libc.Int32FromInt32(128)<<(int32(YUV_FIX)+libc.Int32FromInt32(2))) >> (int32(YUV_FIX) + libc.Int32FromInt32(2))
 		if v12 & ^libc.Int32FromInt32(0xff) == 0 {
 			v15 = v12
 		} else {
 			if v12 < 0 {
 				v16 = 0
 			} else {
 				v16 = int32(255)
 			}
 			v15 = v16
 		}
 		v13 = v15
 		goto _14
 	_14:
 		v10 = v13
 		goto _11
 	_11:
 		V0 = v10
 		has_alpha = (*WebPPicture)(unsafe.Pointer(picture)).Fcolorspace & int32(WEBP_CSP_ALPHA_BIT)
 		y_ptr = (*WebPPicture)(unsafe.Pointer(picture)).Fy
 		u_ptr = (*WebPPicture)(unsafe.Pointer(picture)).Fu
 		v_ptr = (*WebPPicture)(unsafe.Pointer(picture)).Fv
 		a_ptr = (*WebPPicture)(unsafe.Pointer(picture)).Fa
 		if !(has_alpha != 0) || a_ptr == libc.UintptrFromInt32(0) {
 			return
 		} // nothing to do
 		y = 0
 		for {
 			if !(y < (*WebPPicture)(unsafe.Pointer(picture)).Fheight) {
 				break
 			}
 			// Luma blending
 			x = 0
 			for {
 				if !(x < (*WebPPicture)(unsafe.Pointer(picture)).Fwidth) {
 					break
 				}
 				alpha = **(**uint8_t)(__ccgo_up(a_ptr + uintptr(x)))
 				if libc.Int32FromUint8(alpha) < int32(0xff) {
 					**(**uint8_t)(__ccgo_up(y_ptr + uintptr(x))) = libc.Uint8FromInt32(((Y0*(libc.Int32FromInt32(255)-libc.Int32FromUint8(alpha))+libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(y_ptr + uintptr(x))))*libc.Int32FromUint8(alpha))*libc.Int32FromInt32(0x101) + libc.Int32FromInt32(256)) >> libc.Int32FromInt32(16))
 				}
 				goto _18
 			_18:
 				;
 				x = x + 1
 			}
 			// Chroma blending every even line
 			if y&int32(1) == 0 {
 				if y+int32(1) == (*WebPPicture)(unsafe.Pointer(picture)).Fheight {
 					v19 = a_ptr
 				} else {
 					v19 = a_ptr + uintptr((*WebPPicture)(unsafe.Pointer(picture)).Fa_stride)
 				}
 				a_ptr2 = v19
 				x = 0
 				for {
 					if !(x < uv_width) {
 						break
 					}
 					// Average four alpha values into a single blending weight.
 					// TODO(skal): might lead to visible contouring. Can we do better?
 					alpha1 = libc.Uint32FromInt32(libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(a_ptr + uintptr(int32(2)*x+0)))) + libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(a_ptr + uintptr(int32(2)*x+int32(1))))) + libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(a_ptr2 + uintptr(int32(2)*x+0)))) + libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(a_ptr2 + uintptr(int32(2)*x+int32(1))))))
 					**(**uint8_t)(__ccgo_up(u_ptr + uintptr(x))) = uint8(((libc.Uint32FromInt32(U0)*(libc.Uint32FromInt32(1020)-alpha1)+uint32(**(**uint8_t)(__ccgo_up(u_ptr + uintptr(x))))*alpha1)*libc.Uint32FromInt32(0x101) + libc.Uint32FromInt32(1024)) >> libc.Int32FromInt32(18))
 					**(**uint8_t)(__ccgo_up(v_ptr + uintptr(x))) = uint8(((libc.Uint32FromInt32(V0)*(libc.Uint32FromInt32(1020)-alpha1)+uint32(**(**uint8_t)(__ccgo_up(v_ptr + uintptr(x))))*alpha1)*libc.Uint32FromInt32(0x101) + libc.Uint32FromInt32(1024)) >> libc.Int32FromInt32(18))
 					goto _20
 				_20:
 					;
 					x = x + 1
 				}
 				if (*WebPPicture)(unsafe.Pointer(picture)).Fwidth&int32(1) != 0 { // rightmost pixel
 					alpha2 = libc.Uint32FromInt32(int32(2) * (libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(a_ptr + uintptr(int32(2)*x+0)))) + libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(a_ptr2 + uintptr(int32(2)*x+0))))))
 					**(**uint8_t)(__ccgo_up(u_ptr + uintptr(x))) = uint8(((libc.Uint32FromInt32(U0)*(libc.Uint32FromInt32(1020)-alpha2)+uint32(**(**uint8_t)(__ccgo_up(u_ptr + uintptr(x))))*alpha2)*libc.Uint32FromInt32(0x101) + libc.Uint32FromInt32(1024)) >> libc.Int32FromInt32(18))
 					**(**uint8_t)(__ccgo_up(v_ptr + uintptr(x))) = uint8(((libc.Uint32FromInt32(V0)*(libc.Uint32FromInt32(1020)-alpha2)+uint32(**(**uint8_t)(__ccgo_up(v_ptr + uintptr(x))))*alpha2)*libc.Uint32FromInt32(0x101) + libc.Uint32FromInt32(1024)) >> libc.Int32FromInt32(18))
 				}
 			} else {
 				u_ptr = u_ptr + uintptr((*WebPPicture)(unsafe.Pointer(picture)).Fuv_stride)
 				v_ptr = v_ptr + uintptr((*WebPPicture)(unsafe.Pointer(picture)).Fuv_stride)
 			}
 			libc.X__builtin___memset_chk(tls, a_ptr, int32(0xff), libc.Uint64FromInt32((*WebPPicture)(unsafe.Pointer(picture)).Fwidth), ^__predefined_size_t(0)) // reset alpha value to opaque
 			a_ptr = a_ptr + uintptr((*WebPPicture)(unsafe.Pointer(picture)).Fa_stride)
 			y_ptr = y_ptr + uintptr((*WebPPicture)(unsafe.Pointer(picture)).Fy_stride)
 			goto _17
 		_17:
 			;
 			y = y + 1
 		}
 	} else {
 		argb = (*WebPPicture)(unsafe.Pointer(picture)).Fargb
 		background = MakeARGB32(tls, red, green, blue)
 		y = 0
 		for {
 			if !(y < (*WebPPicture)(unsafe.Pointer(picture)).Fheight) {
 				break
 			}
 			x = 0
 			for {
 				if !(x < (*WebPPicture)(unsafe.Pointer(picture)).Fwidth) {
 					break
 				}
 				alpha3 = libc.Int32FromUint32(**(**uint32_t)(__ccgo_up(argb + uintptr(x)*4)) >> libc.Int32FromInt32(24) & uint32(0xff))
 				if alpha3 != int32(0xff) {
 					if alpha3 > 0 {
 						r3 = libc.Int32FromUint32(**(**uint32_t)(__ccgo_up(argb + uintptr(x)*4)) >> libc.Int32FromInt32(16) & uint32(0xff))
 						g3 = libc.Int32FromUint32(**(**uint32_t)(__ccgo_up(argb + uintptr(x)*4)) >> libc.Int32FromInt32(8) & uint32(0xff))
 						b3 = libc.Int32FromUint32(**(**uint32_t)(__ccgo_up(argb + uintptr(x)*4)) >> libc.Int32FromInt32(0) & uint32(0xff))
 						r3 = ((red*(int32(255)-alpha3)+r3*alpha3)*int32(0x101) + int32(256)) >> int32(16)
 						g3 = ((green*(int32(255)-alpha3)+g3*alpha3)*int32(0x101) + int32(256)) >> int32(16)
 						b3 = ((blue*(int32(255)-alpha3)+b3*alpha3)*int32(0x101) + int32(256)) >> int32(16)
 						**(**uint32_t)(__ccgo_up(argb + uintptr(x)*4)) = MakeARGB32(tls, r3, g3, b3)
 					} else {
 						**(**uint32_t)(__ccgo_up(argb + uintptr(x)*4)) = background
 					}
 				}
 				goto _22
 			_22:
 				;
 				x = x + 1
 			}
 			argb = argb + uintptr((*WebPPicture)(unsafe.Pointer(picture)).Fargb_stride)*4
 			goto _21
 		_21:
 			;
 			y = y + 1
 		}
 	}
 }
 
 const ARGB_BLACK1 = 4278190080
 
 //------------------------------------------------------------------------------
 
 // Copyright 2012 Google Inc. All Rights Reserved.
 //
 // Use of this source code is governed by a BSD-style license
 // that can be found in the COPYING file in the root of the source
 // tree. An additional intellectual property rights grant can be found
 // in the file PATENTS. All contributing project authors may
 // be found in the AUTHORS file in the root of the source tree.
 // -----------------------------------------------------------------------------
 //
 // Misc. common utility functions
 //
 // Authors: Skal (pascal.massimino@gmail.com)
 //          Urvang (urvang@google.com)
 
 // Copyright 2011 Google Inc. All Rights Reserved.
 //
 // Use of this source code is governed by a BSD-style license
 // that can be found in the COPYING file in the root of the source
 // tree. An additional intellectual property rights grant can be found
 // in the file PATENTS. All contributing project authors may
 // be found in the AUTHORS file in the root of the source tree.
 // -----------------------------------------------------------------------------
 //
 //   WebP encoder: main interface
 //
 // Author: Skal (pascal.massimino@gmail.com)
 
 // Copyright 2012 Google Inc. All Rights Reserved.
 //
 // Use of this source code is governed by a BSD-style license
 // that can be found in the COPYING file in the root of the source
 // tree. An additional intellectual property rights grant can be found
 // in the file PATENTS. All contributing project authors may
 // be found in the AUTHORS file in the root of the source tree.
 // -----------------------------------------------------------------------------
 //
 //  Internal header for constants related to WebP file format.
 //
 // Author: Urvang (urvang@google.com)
 
 // Copyright 2010 Google Inc. All Rights Reserved.
 //
 // Use of this source code is governed by a BSD-style license
 // that can be found in the COPYING file in the root of the source
 // tree. An additional intellectual property rights grant can be found
 // in the file PATENTS. All contributing project authors may
 // be found in the AUTHORS file in the root of the source tree.
 // -----------------------------------------------------------------------------
 //
 //  Common types + memory wrappers
 //
 // Author: Skal (pascal.massimino@gmail.com)
 
 var kSpatialPredictorBias = libc.Int64FromInt64(15) << libc.Int32FromInt32(LOG_2_PRECISION_BITS)
 var kPredLowEffort = int32(11)
 var kMaskAlpha = uint32(0xff000000)
 var kNumPredModes = int32(14)
 
 // C documentation
 //
 //	// Mostly used to reduce code size + readability
 func GetMin(tls *libc.TLS, a int32, b int32) (r int32) {
 	var v1 int32
 	_ = v1
 	if a > b {
 		v1 = b
 	} else {
 		v1 = a
 	}
 	return v1
 }
 
 func GetMax(tls *libc.TLS, a int32, b int32) (r int32) {
 	var v1 int32
 	_ = v1
 	if a < b {
 		v1 = b
 	} else {
 		v1 = a
 	}
 	return v1
 }
 
 //------------------------------------------------------------------------------
 // Methods to calculate Entropy (Shannon).
 
 // C documentation
 //
 //	// Compute a bias for prediction entropy using a global heuristic to favor
 //	// values closer to 0. Hence the final negative sign.
 //	// 'exp_val' has a scaling factor of 1/100.
 func PredictionCostBias(tls *libc.TLS, counts uintptr, weight_0 uint64_t, exp_val uint64_t) (r int64_t) {
 	var bits, exp_decay_factor uint64_t
 	var i, significant_symbols int32
 	var v6 int64
 	var v2, v3, v4 int64_t
 	_, _, _, _, _, _, _, _ = bits, exp_decay_factor, i, significant_symbols, v2, v3, v4, v6
 	significant_symbols = libc.Int32FromInt32(256) >> libc.Int32FromInt32(4)
 	exp_decay_factor = uint64(6) // has a scaling factor of 1/10
 	bits = weight_0 * uint64(**(**uint32_t)(__ccgo_up(counts))) << int32(LOG_2_PRECISION_BITS)
 	exp_val = exp_val << uint64(LOG_2_PRECISION_BITS)
 	i = int32(1)
 	for {
 		if !(i < significant_symbols) {
 			break
 		}
 		v2 = libc.Int64FromUint64(exp_val * uint64(**(**uint32_t)(__ccgo_up(counts + uintptr(i)*4))+**(**uint32_t)(__ccgo_up(counts + uintptr(int32(256)-i)*4))))
 		v3 = int64(100)
 		if libc.BoolInt32(v2 < 0) == libc.BoolInt32(v3 < 0) {
 			v6 = (v2 + v3/int64(2)) / v3
 		} else {
 			v6 = (v2 - v3/int64(2)) / v3
 		}
 		v4 = v6
 		goto _5
 	_5:
 		bits = bits + libc.Uint64FromInt64(v4)
 		v2 = libc.Int64FromUint64(exp_decay_factor * exp_val)
 		v3 = int64(10)
 		if libc.BoolInt32(v2 < 0) == libc.BoolInt32(v3 < 0) {
 			v6 = (v2 + v3/int64(2)) / v3
 		} else {
 			v6 = (v2 - v3/int64(2)) / v3
 		}
 		v4 = v6
 		goto _10
 	_10:
 		exp_val = libc.Uint64FromInt64(v4)
 		goto _1
 	_1:
 		;
 		i = i + 1
 	}
 	v2 = libc.Int64FromUint64(bits)
 	v3 = int64(10)
 	if libc.BoolInt32(v2 < 0) == libc.BoolInt32(v3 < 0) {
 		v6 = (v2 + v3/int64(2)) / v3
 	} else {
 		v6 = (v2 - v3/int64(2)) / v3
 	}
 	v4 = v6
 	goto _15
 _15:
 	return -v4
 }
 
 func PredictionCostSpatialHistogram(tls *libc.TLS, accumulated uintptr, tile uintptr, mode int32, left_mode int32, above_mode int32) (r int64_t) {
 	var i int32
 	var kExpValue uint64_t
 	var retval int64_t
 	_, _, _ = i, kExpValue, retval
 	retval = 0
 	i = 0
 	for {
 		if !(i < int32(4)) {
 			break
 		}
 		kExpValue = uint64(94)
 		retval = retval + PredictionCostBias(tls, tile+uintptr(i*int32(256))*4, uint64(1), kExpValue)
 		// Compute the new cost if 'tile' is added to 'accumulate' but also add the
 		// cost of the current histogram to guide the spatial predictor selection.
 		// Basically, favor low entropy, locally and globally.
 		retval = retval + libc.Int64FromUint64((*(*func(*libc.TLS, uintptr, uintptr) uint64_t)(unsafe.Pointer(&struct{ uintptr }{VP8LCombinedShannonEntropy})))(tls, tile+uintptr(i*int32(256))*4, accumulated+uintptr(i*int32(256))*4))
 		goto _1
 	_1:
 		;
 		i = i + 1
 	}
 	// Favor keeping the areas locally similar.
 	if mode == left_mode {
 		retval = retval - kSpatialPredictorBias
 	}
 	if mode == above_mode {
 		retval = retval - kSpatialPredictorBias
 	}
 	return retval
 }
 
 func UpdateHisto(tls *libc.TLS, histo_argb uintptr, argb uint32_t) {
 	**(**uint32_t)(__ccgo_up(histo_argb + uintptr(libc.Uint32FromInt32(libc.Int32FromInt32(0)*libc.Int32FromInt32(256))+argb>>libc.Int32FromInt32(24))*4)) = **(**uint32_t)(__ccgo_up(histo_argb + uintptr(libc.Uint32FromInt32(libc.Int32FromInt32(0)*libc.Int32FromInt32(256))+argb>>libc.Int32FromInt32(24))*4)) + 1
 	**(**uint32_t)(__ccgo_up(histo_argb + uintptr(libc.Uint32FromInt32(libc.Int32FromInt32(1)*libc.Int32FromInt32(256))+argb>>libc.Int32FromInt32(16)&uint32(0xff))*4)) = **(**uint32_t)(__ccgo_up(histo_argb + uintptr(libc.Uint32FromInt32(libc.Int32FromInt32(1)*libc.Int32FromInt32(256))+argb>>libc.Int32FromInt32(16)&uint32(0xff))*4)) + 1
 	**(**uint32_t)(__ccgo_up(histo_argb + uintptr(libc.Uint32FromInt32(libc.Int32FromInt32(2)*libc.Int32FromInt32(256))+argb>>libc.Int32FromInt32(8)&uint32(0xff))*4)) = **(**uint32_t)(__ccgo_up(histo_argb + uintptr(libc.Uint32FromInt32(libc.Int32FromInt32(2)*libc.Int32FromInt32(256))+argb>>libc.Int32FromInt32(8)&uint32(0xff))*4)) + 1
 	**(**uint32_t)(__ccgo_up(histo_argb + uintptr(libc.Uint32FromInt32(libc.Int32FromInt32(3)*libc.Int32FromInt32(256))+argb&uint32(0xff))*4)) = **(**uint32_t)(__ccgo_up(histo_argb + uintptr(libc.Uint32FromInt32(libc.Int32FromInt32(3)*libc.Int32FromInt32(256))+argb&uint32(0xff))*4)) + 1
 }
 
 //------------------------------------------------------------------------------
 // Spatial transform functions.
 
 func PredictBatch(tls *libc.TLS, mode int32, x_start int32, y int32, num_pixels int32, current uintptr, upper uintptr, out uintptr) {
 	if x_start == 0 {
 		if y == 0 {
 			// ARGB_BLACK.
 			(*(*func(*libc.TLS, uintptr, uintptr, int32, uintptr))(unsafe.Pointer(&struct{ uintptr }{VP8LPredictorsSub[libc.Int32FromInt32(0)]})))(tls, current, libc.UintptrFromInt32(0), int32(1), out)
 		} else {
 			// Top one.
 			(*(*func(*libc.TLS, uintptr, uintptr, int32, uintptr))(unsafe.Pointer(&struct{ uintptr }{VP8LPredictorsSub[libc.Int32FromInt32(2)]})))(tls, current, upper, int32(1), out)
 		}
 		x_start = x_start + 1
 		out += 4
 		num_pixels = num_pixels - 1
 	}
 	if y == 0 {
 		// Left one.
 		(*(*func(*libc.TLS, uintptr, uintptr, int32, uintptr))(unsafe.Pointer(&struct{ uintptr }{VP8LPredictorsSub[libc.Int32FromInt32(1)]})))(tls, current+uintptr(x_start)*4, libc.UintptrFromInt32(0), num_pixels, out)
 	} else {
 		(*(*func(*libc.TLS, uintptr, uintptr, int32, uintptr))(unsafe.Pointer(&struct{ uintptr }{VP8LPredictorsSub[mode]})))(tls, current+uintptr(x_start)*4, upper+uintptr(x_start)*4, num_pixels, out)
 	}
 }
 
 func MaxDiffBetweenPixels(tls *libc.TLS, p1 uint32_t, p2 uint32_t) (r int32) {
 	var diff_a, diff_b, diff_g, diff_r int32
 	_, _, _, _ = diff_a, diff_b, diff_g, diff_r
 	diff_a = libc.Xabs(tls, libc.Int32FromUint32(p1>>libc.Int32FromInt32(24))-libc.Int32FromUint32(p2>>libc.Int32FromInt32(24)))
 	diff_r = libc.Xabs(tls, libc.Int32FromUint32(p1>>libc.Int32FromInt32(16)&libc.Uint32FromInt32(0xff))-libc.Int32FromUint32(p2>>libc.Int32FromInt32(16)&libc.Uint32FromInt32(0xff)))
 	diff_g = libc.Xabs(tls, libc.Int32FromUint32(p1>>libc.Int32FromInt32(8)&libc.Uint32FromInt32(0xff))-libc.Int32FromUint32(p2>>libc.Int32FromInt32(8)&libc.Uint32FromInt32(0xff)))
 	diff_b = libc.Xabs(tls, libc.Int32FromUint32(p1&libc.Uint32FromInt32(0xff))-libc.Int32FromUint32(p2&libc.Uint32FromInt32(0xff)))
 	return GetMax(tls, GetMax(tls, diff_a, diff_r), GetMax(tls, diff_g, diff_b))
 }
 
 func MaxDiffAroundPixel(tls *libc.TLS, current uint32_t, up uint32_t, down uint32_t, left uint32_t, right uint32_t) (r int32) {
 	var diff_down, diff_left, diff_right, diff_up int32
 	_, _, _, _ = diff_down, diff_left, diff_right, diff_up
 	diff_up = MaxDiffBetweenPixels(tls, current, up)
 	diff_down = MaxDiffBetweenPixels(tls, current, down)
 	diff_left = MaxDiffBetweenPixels(tls, current, left)
 	diff_right = MaxDiffBetweenPixels(tls, current, right)
 	return GetMax(tls, GetMax(tls, diff_up, diff_down), GetMax(tls, diff_left, diff_right))
 }
 
 func AddGreenToBlueAndRed(tls *libc.TLS, argb uint32_t) (r uint32_t) {
 	var green, red_blue uint32_t
 	_, _ = green, red_blue
 	green = argb >> libc.Int32FromInt32(8) & uint32(0xff)
 	red_blue = argb & uint32(0x00ff00ff)
 	red_blue = red_blue + (green<<libc.Int32FromInt32(16) | green)
 	red_blue = red_blue & uint32(0x00ff00ff)
 	return argb&uint32(0xff00ff00) | red_blue
 }
 
 func MaxDiffsForRow(tls *libc.TLS, width int32, stride int32, argb uintptr, max_diffs uintptr, used_subtract_green int32) {
 	var current, down, left, right, up uint32_t
 	var x int32
 	_, _, _, _, _, _ = current, down, left, right, up, x
 	if width <= int32(2) {
 		return
 	}
 	current = **(**uint32_t)(__ccgo_up(argb))
 	right = **(**uint32_t)(__ccgo_up(argb + 1*4))
 	if used_subtract_green != 0 {
 		current = AddGreenToBlueAndRed(tls, current)
 		right = AddGreenToBlueAndRed(tls, right)
 	}
 	// max_diffs[0] and max_diffs[width - 1] are never used.
 	x = int32(1)
 	for {
 		if !(x < width-int32(1)) {
 			break
 		}
 		up = **(**uint32_t)(__ccgo_up(argb + uintptr(-stride+x)*4))
 		down = **(**uint32_t)(__ccgo_up(argb + uintptr(stride+x)*4))
 		left = current
 		current = right
 		right = **(**uint32_t)(__ccgo_up(argb + uintptr(x+int32(1))*4))
 		if used_subtract_green != 0 {
 			up = AddGreenToBlueAndRed(tls, up)
 			down = AddGreenToBlueAndRed(tls, down)
 			right = AddGreenToBlueAndRed(tls, right)
 		}
 		**(**uint8_t)(__ccgo_up(max_diffs + uintptr(x))) = libc.Uint8FromInt32(MaxDiffAroundPixel(tls, current, up, down, left, right))
 		goto _1
 	_1:
 		;
 		x = x + 1
 	}
 }
 
 // C documentation
 //
 //	// Quantize the difference between the actual component value and its prediction
 //	// to a multiple of quantization, working modulo 256, taking care not to cross
 //	// a boundary (inclusive upper limit).
 func NearLosslessComponent(tls *libc.TLS, value uint8_t, predict uint8_t, boundary uint8_t, quantization int32) (r uint8_t) {
 	var bias, boundary_residual, lower, residual, upper int32
 	_, _, _, _, _ = bias, boundary_residual, lower, residual, upper
 	residual = (libc.Int32FromUint8(value) - libc.Int32FromUint8(predict)) & int32(0xff)
 	boundary_residual = (libc.Int32FromUint8(boundary) - libc.Int32FromUint8(predict)) & int32(0xff)
 	lower = residual & ^(quantization - libc.Int32FromInt32(1))
 	upper = lower + quantization
 	// Resolve ties towards a value closer to the prediction (i.e. towards lower
 	// if value comes after prediction and towards upper otherwise).
 	bias = libc.BoolInt32((libc.Int32FromUint8(boundary)-libc.Int32FromUint8(value))&int32(0xff) < boundary_residual)
 	if residual-lower < upper-residual+bias {
 		// lower is closer to residual than upper.
 		if residual > boundary_residual && lower <= boundary_residual {
 			// Halve quantization step to avoid crossing boundary. This midpoint is
 			// on the same side of boundary as residual because midpoint >= residual
 			// (since lower is closer than upper) and residual is above the boundary.
 			return libc.Uint8FromInt32(lower + quantization>>int32(1))
 		}
 		return libc.Uint8FromInt32(lower)
 	} else {
 		// upper is closer to residual than lower.
 		if residual <= boundary_residual && upper > boundary_residual {
 			// Halve quantization step to avoid crossing boundary. This midpoint is
 			// on the same side of boundary as residual because midpoint <= residual
 			// (since upper is closer than lower) and residual is below the boundary.
 			return libc.Uint8FromInt32(lower + quantization>>int32(1))
 		}
 		return libc.Uint8FromInt32(upper & int32(0xff))
 	}
 	return r
 }
 
 func NearLosslessDiff(tls *libc.TLS, a uint8_t, b uint8_t) (r uint8_t) {
 	return libc.Uint8FromInt32((libc.Int32FromUint8(a) - libc.Int32FromUint8(b)) & libc.Int32FromInt32(0xff))
 }
 
 // C documentation
 //
 //	// Quantize every component of the difference between the actual pixel value and
 //	// its prediction to a multiple of a quantization (a power of 2, not larger than
 //	// max_quantization which is a power of 2, smaller than max_diff). Take care if
 //	// value and predict have undergone subtract green, which means that red and
 //	// blue are represented as offsets from green.
 func NearLossless1(tls *libc.TLS, value uint32_t, predict uint32_t, max_quantization int32, max_diff int32, used_subtract_green int32) (r1 uint32_t) {
 	var a1, b1, g, green_diff, new_green, r uint8_t
 	var alpha_and_green, red_and_blue, v1, v2, v3 uint32_t
 	var quantization int32
 	_, _, _, _, _, _, _, _, _, _, _, _ = a1, alpha_and_green, b1, g, green_diff, new_green, quantization, r, red_and_blue, v1, v2, v3
 	new_green = uint8(0)
 	green_diff = uint8(0)
 	if max_diff <= int32(2) {
 		v1 = value
 		v2 = predict
 		alpha_and_green = uint32(0x00ff00ff) + v1&uint32(0xff00ff00) - v2&uint32(0xff00ff00)
 		red_and_blue = uint32(0xff00ff00) + v1&uint32(0x00ff00ff) - v2&uint32(0x00ff00ff)
 		v3 = alpha_and_green&uint32(0xff00ff00) | red_and_blue&uint32(0x00ff00ff)
 		goto _4
 	_4:
 		return v3
 	}
 	quantization = max_quantization
 	for quantization >= max_diff {
 		quantization = quantization >> int32(1)
 	}
 	if value>>libc.Int32FromInt32(24) == uint32(0) || value>>libc.Int32FromInt32(24) == uint32(0xff) {
 		// Preserve transparency of fully transparent or fully opaque pixels.
 		a1 = NearLosslessDiff(tls, uint8(value>>libc.Int32FromInt32(24)&uint32(0xff)), uint8(predict>>libc.Int32FromInt32(24)&uint32(0xff)))
 	} else {
 		a1 = NearLosslessComponent(tls, uint8(value>>int32(24)), uint8(predict>>int32(24)), uint8(0xff), quantization)
 	}
 	g = NearLosslessComponent(tls, uint8(value>>libc.Int32FromInt32(8)&uint32(0xff)), uint8(predict>>libc.Int32FromInt32(8)&uint32(0xff)), uint8(0xff), quantization)
 	if used_subtract_green != 0 {
 		// The green offset will be added to red and blue components during decoding
 		// to obtain the actual red and blue values.
 		new_green = uint8((predict>>libc.Int32FromInt32(8) + uint32(g)) & uint32(0xff))
 		// The amount by which green has been adjusted during quantization. It is
 		// subtracted from red and blue for compensation, to avoid accumulating two
 		// quantization errors in them.
 		green_diff = NearLosslessDiff(tls, new_green, uint8(value>>libc.Int32FromInt32(8)&uint32(0xff)))
 	}
 	r = NearLosslessComponent(tls, NearLosslessDiff(tls, uint8(value>>libc.Int32FromInt32(16)&uint32(0xff)), green_diff), uint8(predict>>libc.Int32FromInt32(16)&uint32(0xff)), libc.Uint8FromInt32(int32(0xff)-libc.Int32FromUint8(new_green)), quantization)
 	b1 = NearLosslessComponent(tls, NearLosslessDiff(tls, uint8(value&uint32(0xff)), green_diff), uint8(predict&uint32(0xff)), libc.Uint8FromInt32(int32(0xff)-libc.Int32FromUint8(new_green)), quantization)
 	return uint32(a1)<<libc.Int32FromInt32(24) | uint32(r)<<libc.Int32FromInt32(16) | uint32(g)<<libc.Int32FromInt32(8) | uint32(b1)
 }
 
 // C documentation
 //
 //	// Stores the difference between the pixel and its prediction in "out".
 //	// In case of a lossy encoding, updates the source image to avoid propagating
 //	// the deviation further to pixels which depend on the current pixel for their
 //	// predictions.
 func GetResidual(tls *libc.TLS, width int32, height int32, upper_row uintptr, current_row uintptr, max_diffs uintptr, mode int32, x_start int32, x_end int32, y int32, max_quantization int32, exact int32, used_subtract_green int32, out uintptr) {
 	var alpha_and_green, alpha_and_green1, predict, red_and_blue, red_and_blue1, residual, v3, v4, v5 uint32_t
 	var pred_func VP8LPredictorFunc
 	var x int32
 	var v2 uint32
 	_, _, _, _, _, _, _, _, _, _, _, _ = alpha_and_green, alpha_and_green1, pred_func, predict, red_and_blue, red_and_blue1, residual, x, v2, v3, v4, v5
 	if exact != 0 {
 		PredictBatch(tls, mode, x_start, y, x_end-x_start, current_row, upper_row, out)
 	} else {
 		pred_func = VP8LPredictors[mode]
 		x = x_start
 		for {
 			if !(x < x_end) {
 				break
 			}
 			if y == 0 {
 				if x == 0 {
 					v2 = uint32(ARGB_BLACK1)
 				} else {
 					v2 = **(**uint32_t)(__ccgo_up(current_row + uintptr(x-int32(1))*4))
 				}
 				predict = v2 // Left.
 			} else {
 				if x == 0 {
 					predict = **(**uint32_t)(__ccgo_up(upper_row + uintptr(x)*4)) // Top.
 				} else {
 					predict = (*(*func(*libc.TLS, uintptr, uintptr) uint32_t)(unsafe.Pointer(&struct{ uintptr }{pred_func})))(tls, current_row+uintptr(x-int32(1))*4, upper_row+uintptr(x)*4)
 				}
 			}
 			if max_quantization == int32(1) || mode == 0 || y == 0 || y == height-int32(1) || x == 0 || x == width-int32(1) {
 				v3 = **(**uint32_t)(__ccgo_up(current_row + uintptr(x)*4))
 				v4 = predict
 				alpha_and_green1 = uint32(0x00ff00ff) + v3&uint32(0xff00ff00) - v4&uint32(0xff00ff00)
 				red_and_blue1 = uint32(0xff00ff00) + v3&uint32(0x00ff00ff) - v4&uint32(0x00ff00ff)
 				v5 = alpha_and_green1&uint32(0xff00ff00) | red_and_blue1&uint32(0x00ff00ff)
 				goto _6
 			_6:
 				residual = v5
 			} else {
 				residual = NearLossless1(tls, **(**uint32_t)(__ccgo_up(current_row + uintptr(x)*4)), predict, max_quantization, libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(max_diffs + uintptr(x)))), used_subtract_green)
 				// Update the source image.
 				v3 = predict
 				v4 = residual
 				alpha_and_green = v3&uint32(0xff00ff00) + v4&uint32(0xff00ff00)
 				red_and_blue = v3&uint32(0x00ff00ff) + v4&uint32(0x00ff00ff)
 				v5 = alpha_and_green&uint32(0xff00ff00) | red_and_blue&uint32(0x00ff00ff)
 				goto _10
 			_10:
 				**(**uint32_t)(__ccgo_up(current_row + uintptr(x)*4)) = v5
 				// x is never 0 here so we do not need to update upper_row like below.
 			}
 			if **(**uint32_t)(__ccgo_up(current_row + uintptr(x)*4))&kMaskAlpha == uint32(0) {
 				// If alpha is 0, cleanup RGB. We can choose the RGB values of the
 				// residual for best compression. The prediction of alpha itself can be
 				// non-zero and must be kept though. We choose RGB of the residual to be
 				// 0.
 				residual = residual & kMaskAlpha
 				// Update the source image.
 				**(**uint32_t)(__ccgo_up(current_row + uintptr(x)*4)) = predict & ^kMaskAlpha
 				// The prediction for the rightmost pixel in a row uses the leftmost
 				// pixel
 				// in that row as its top-right context pixel. Hence if we change the
 				// leftmost pixel of current_row, the corresponding change must be
 				// applied
 				// to upper_row as well where top-right context is being read from.
 				if x == 0 && y != 0 {
 					**(**uint32_t)(__ccgo_up(upper_row + uintptr(width)*4)) = **(**uint32_t)(__ccgo_up(current_row))
 				}
 			}
 			**(**uint32_t)(__ccgo_up(out + uintptr(x-x_start)*4)) = residual
 			goto _1
 		_1:
 			;
 			x = x + 1
 		}
 	}
 }
 
 // C documentation
 //
 //	// Accessors to residual histograms.
 func GetHistoArgb(tls *libc.TLS, all_histos uintptr, subsampling_index int32, mode int32) (r uintptr) {
 	return all_histos + uintptr((subsampling_index*kNumPredModes+mode)*(libc.Int32FromInt32(4)*libc.Int32FromInt32(256)))*4
 }
 
 func GetHistoArgbConst(tls *libc.TLS, all_histos uintptr, subsampling_index int32, mode int32) (r uintptr) {
 	return all_histos + uintptr(subsampling_index*kNumPredModes*(libc.Int32FromInt32(4)*libc.Int32FromInt32(256))+mode*(libc.Int32FromInt32(4)*libc.Int32FromInt32(256)))*4
 }
 
 // C documentation
 //
 //	// Accessors to accumulated residual histogram.
 func GetAccumulatedHisto(tls *libc.TLS, all_accumulated uintptr, subsampling_index int32) (r uintptr) {
 	return all_accumulated + uintptr(subsampling_index*(libc.Int32FromInt32(4)*libc.Int32FromInt32(256)))*4
 }
 
 // C documentation
 //
 //	// Find and store the best predictor for a tile at subsampling
 //	// 'subsampling_index'.
 func GetBestPredictorForTile(tls *libc.TLS, all_argb uintptr, subsampling_index int32, tile_x int32, tile_y int32, tiles_per_row int32, all_accumulated_argb uintptr, all_modes uintptr, all_pred_histos uintptr) {
 	var above_mode, left_mode, mode int32
 	var accumulated_argb, best_histo, histo_argb, modes, pred_histos uintptr
 	var best_diff, cur_diff int64_t
 	var best_mode uint32_t
 	var v1, v2 uint32
 	_, _, _, _, _, _, _, _, _, _, _, _, _ = above_mode, accumulated_argb, best_diff, best_histo, best_mode, cur_diff, histo_argb, left_mode, mode, modes, pred_histos, v1, v2
 	accumulated_argb = GetAccumulatedHisto(tls, all_accumulated_argb, subsampling_index)
 	modes = **(**uintptr)(__ccgo_up(all_modes + uintptr(subsampling_index)*8))
 	pred_histos = all_pred_histos + uintptr(subsampling_index*kNumPredModes)*4
 	if tile_x > 0 {
 		v1 = **(**uint32_t)(__ccgo_up(modes + uintptr(tile_y*tiles_per_row+tile_x-int32(1))*4)) >> libc.Int32FromInt32(8) & uint32(0xff)
 	} else {
 		v1 = uint32(0xff)
 	}
 	// Prediction modes of the left and above neighbor tiles.
 	left_mode = libc.Int32FromUint32(v1)
 	if tile_y > 0 {
 		v2 = **(**uint32_t)(__ccgo_up(modes + uintptr((tile_y-int32(1))*tiles_per_row+tile_x)*4)) >> libc.Int32FromInt32(8) & uint32(0xff)
 	} else {
 		v2 = uint32(0xff)
 	}
 	above_mode = libc.Int32FromUint32(v2)
 	best_diff = libc.Int64FromUint64(libc.Uint64FromUint64(1)<<libc.Int32FromInt32(63) - libc.Uint64FromInt32(1))
 	best_mode = uint32(0)
 	best_histo = GetHistoArgbConst(tls, all_argb, 0, libc.Int32FromUint32(best_mode))
 	mode = 0
 	for {
 		if !(mode < kNumPredModes) {
 			break
 		}
 		histo_argb = GetHistoArgbConst(tls, all_argb, subsampling_index, mode)
 		cur_diff = PredictionCostSpatialHistogram(tls, accumulated_argb, histo_argb, mode, left_mode, above_mode)
 		if cur_diff < best_diff {
 			best_histo = histo_argb
 			best_diff = cur_diff
 			best_mode = libc.Uint32FromInt32(mode)
 		}
 		goto _3
 	_3:
 		;
 		mode = mode + 1
 	}
 	// Update the accumulated histogram.
 	(*(*func(*libc.TLS, uintptr, uintptr, int32))(unsafe.Pointer(&struct{ uintptr }{VP8LAddVectorEq})))(tls, best_histo, accumulated_argb, libc.Int32FromInt32(4)*libc.Int32FromInt32(256))
 	**(**uint32_t)(__ccgo_up(modes + uintptr(tile_y*tiles_per_row+tile_x)*4)) = uint32(ARGB_BLACK1) | best_mode<<libc.Int32FromInt32(8)
 	**(**uint32_t)(__ccgo_up(pred_histos + uintptr(best_mode)*4)) = **(**uint32_t)(__ccgo_up(pred_histos + uintptr(best_mode)*4)) + 1
 }
 
 // C documentation
 //
 //	// Computes the residuals for the different predictors.
 //	// If max_quantization > 1, assumes that near lossless processing will be
 //	// applied, quantizing residuals to multiples of quantization levels up to
 //	// max_quantization (the actual quantization level depends on smoothness near
 //	// the given pixel).
 func ComputeResidualsForTile(tls *libc.TLS, width int32, height int32, tile_x int32, tile_y int32, min_bits int32, update_up_to_index uint32_t, all_argb uintptr, argb_scratch uintptr, argb uintptr, max_quantization int32, exact int32, used_subtract_green int32) {
 	bp := tls.Alloc(2048)
 	defer tls.Free(2048)
 	var context_start_x, context_width, have_left, max_x, max_y, mode, relative_x, relative_y, start_x, start_y, tile_size, y int32
 	var current_row, histo_argb, max_diffs, super_histo, tmp, upper_row uintptr
 	var subsampling_index uint32_t
 	var _ /* residuals at bp+0 */ [512]uint32_t
 	_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = context_start_x, context_width, current_row, have_left, histo_argb, max_diffs, max_x, max_y, mode, relative_x, relative_y, start_x, start_y, subsampling_index, super_histo, tile_size, tmp, upper_row, y
 	start_x = tile_x << min_bits
 	start_y = tile_y << min_bits
 	tile_size = int32(1) << min_bits
 	max_y = GetMin(tls, tile_size, height-start_y)
 	max_x = GetMin(tls, tile_size, width-start_x)
 	// Whether there exist columns just outside the tile.
 	have_left = libc.BoolInt32(start_x > libc.Int32FromInt32(0))
 	// Position and size of the strip covering the tile and adjacent columns if
 	// they exist.
 	context_start_x = start_x - have_left
 	context_width = max_x + have_left + libc.BoolInt32(max_x < width-start_x)
 	// The width of upper_row and current_row is one pixel larger than image width
 	// to allow the top right pixel to point to the leftmost pixel of the next row
 	// when at the right edge.
 	upper_row = argb_scratch
 	current_row = upper_row + uintptr(width)*4 + uintptr(1)*4
 	max_diffs = current_row + uintptr(width)*4 + libc.UintptrFromInt32(1)*4
 	mode = 0
 	for {
 		if !(mode < kNumPredModes) {
 			break
 		}
 		histo_argb = GetHistoArgb(tls, all_argb, 0, mode)
 		if start_y > 0 {
 			// Read the row above the tile which will become the first upper_row.
 			// Include a pixel to the left if it exists; include a pixel to the right
 			// in all cases (wrapping to the leftmost pixel of the next row if it does
 			// not exist).
 			libc.X__builtin___memcpy_chk(tls, current_row+uintptr(context_start_x)*4, argb+uintptr((start_y-int32(1))*width)*4+uintptr(context_start_x)*4, uint64(4)*libc.Uint64FromInt32(max_x+have_left+libc.Int32FromInt32(1)), ^__predefined_size_t(0))
 		}
 		relative_y = 0
 		for {
 			if !(relative_y < max_y) {
 				break
 			}
 			y = start_y + relative_y
 			tmp = upper_row
 			upper_row = current_row
 			current_row = tmp
 			// Read current_row. Include a pixel to the left if it exists; include a
 			// pixel to the right in all cases except at the bottom right corner of
 			// the image (wrapping to the leftmost pixel of the next row if it does
 			// not exist in the current row).
 			libc.X__builtin___memcpy_chk(tls, current_row+uintptr(context_start_x)*4, argb+uintptr(y*width)*4+uintptr(context_start_x)*4, uint64(4)*libc.Uint64FromInt32(max_x+have_left+libc.BoolInt32(y+libc.Int32FromInt32(1) < height)), ^__predefined_size_t(0))
 			if max_quantization > int32(1) && y >= int32(1) && y+int32(1) < height {
 				MaxDiffsForRow(tls, context_width, width, argb+uintptr(y*width)*4+uintptr(context_start_x)*4, max_diffs+uintptr(context_start_x), used_subtract_green)
 			}
 			GetResidual(tls, width, height, upper_row, current_row, max_diffs, mode, start_x, start_x+max_x, y, max_quantization, exact, used_subtract_green, bp)
 			relative_x = 0
 			for {
 				if !(relative_x < max_x) {
 					break
 				}
 				UpdateHisto(tls, histo_argb, (**(**[512]uint32_t)(__ccgo_up(bp)))[relative_x])
 				goto _3
 			_3:
 				;
 				relative_x = relative_x + 1
 			}
 			if update_up_to_index > uint32(0) {
 				subsampling_index = uint32(1)
 				for {
 					if !(subsampling_index <= update_up_to_index) {
 						break
 					}
 					super_histo = GetHistoArgb(tls, all_argb, libc.Int32FromUint32(subsampling_index), mode)
 					relative_x = 0
 					for {
 						if !(relative_x < max_x) {
 							break
 						}
 						UpdateHisto(tls, super_histo, (**(**[512]uint32_t)(__ccgo_up(bp)))[relative_x])
 						goto _5
 					_5:
 						;
 						relative_x = relative_x + 1
 					}
 					goto _4
 				_4:
 					;
 					subsampling_index = subsampling_index + 1
 				}
 			}
 			goto _2
 		_2:
 			;
 			relative_y = relative_y + 1
 		}
 		goto _1
 	_1:
 		;
 		mode = mode + 1
 	}
 }
 
 // C documentation
 //
 //	// Converts pixels of the image to residuals with respect to predictions.
 //	// If max_quantization > 1, applies near lossless processing, quantizing
 //	// residuals to multiples of quantization levels up to max_quantization
 //	// (the actual quantization level depends on smoothness near the given pixel).
 func CopyImageWithPrediction(tls *libc.TLS, width int32, height int32, bits int32, modes uintptr, argb_scratch uintptr, argb uintptr, low_effort int32, max_quantization int32, exact int32, used_subtract_green int32) {
 	var current_max_diffs, current_row, lower_max_diffs, tmp32, tmp8, upper_row uintptr
 	var mode, tiles_per_row, x, x_end, y int32
 	var v1, v2 uint32_t
 	_, _, _, _, _, _, _, _, _, _, _, _, _ = current_max_diffs, current_row, lower_max_diffs, mode, tiles_per_row, tmp32, tmp8, upper_row, x, x_end, y, v1, v2
 	v1 = libc.Uint32FromInt32(bits)
 	v2 = (libc.Uint32FromInt32(width) + libc.Uint32FromInt32(libc.Int32FromInt32(1)<<v1) - uint32(1)) >> v1
 	goto _3
 _3:
 	tiles_per_row = libc.Int32FromUint32(v2)
 	// The width of upper_row and current_row is one pixel larger than image width
 	// to allow the top right pixel to point to the leftmost pixel of the next row
 	// when at the right edge.
 	upper_row = argb_scratch
 	current_row = upper_row + uintptr(width)*4 + uintptr(1)*4
 	current_max_diffs = current_row + uintptr(width)*4 + libc.UintptrFromInt32(1)*4
 	lower_max_diffs = current_max_diffs + uintptr(width)
 	y = 0
 	for {
 		if !(y < height) {
 			break
 		}
 		tmp32 = upper_row
 		upper_row = current_row
 		current_row = tmp32
 		libc.X__builtin___memcpy_chk(tls, current_row, argb+uintptr(y*width)*4, uint64(4)*libc.Uint64FromInt32(width+libc.BoolInt32(y+libc.Int32FromInt32(1) < height)), ^__predefined_size_t(0))
 		if low_effort != 0 {
 			PredictBatch(tls, kPredLowEffort, 0, y, width, current_row, upper_row, argb+uintptr(y*width)*4)
 		} else {
 			if max_quantization > int32(1) {
 				// Compute max_diffs for the lower row now, because that needs the
 				// contents of argb for the current row, which we will overwrite with
 				// residuals before proceeding with the next row.
 				tmp8 = current_max_diffs
 				current_max_diffs = lower_max_diffs
 				lower_max_diffs = tmp8
 				if y+int32(2) < height {
 					MaxDiffsForRow(tls, width, width, argb+uintptr((y+int32(1))*width)*4, lower_max_diffs, used_subtract_green)
 				}
 			}
 			x = 0
 			for {
 				if !(x < width) {
 					break
 				}
 				mode = libc.Int32FromUint32(**(**uint32_t)(__ccgo_up(modes + uintptr(y>>bits*tiles_per_row+x>>bits)*4)) >> libc.Int32FromInt32(8) & uint32(0xff))
 				x_end = x + int32(1)<<bits
 				if x_end > width {
 					x_end = width
 				}
 				GetResidual(tls, width, height, upper_row, current_row, current_max_diffs, mode, x, x_end, y, max_quantization, exact, used_subtract_green, argb+uintptr(y*width)*4+uintptr(x)*4)
 				x = x_end
 				goto _5
 			_5:
 			}
 		}
 		goto _4
 	_4:
 		;
 		y = y + 1
 	}
 }
 
 // C documentation
 //
 //	// Checks whether 'image' can be subsampled by finding the biggest power of 2
 //	// squares (defined by 'best_bits') of uniform value it is made out of.
 func VP8LOptimizeSampling(tls *libc.TLS, image uintptr, full_width int32, full_height int32, bits int32, max_bits int32, best_bits_out uintptr) {
 	var best_bits, height, i, is_good, is_good1, new_square_size, old_width, square_size, width, x, y int32
 	var v1, v2, v4, v5 uint32_t
 	_, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = best_bits, height, i, is_good, is_good1, new_square_size, old_width, square_size, width, x, y, v1, v2, v4, v5
 	v1 = libc.Uint32FromInt32(bits)
 	v2 = (libc.Uint32FromInt32(full_width) + libc.Uint32FromInt32(libc.Int32FromInt32(1)<<v1) - uint32(1)) >> v1
 	goto _3
 _3:
 	width = libc.Int32FromUint32(v2)
 	v4 = libc.Uint32FromInt32(bits)
 	v5 = (libc.Uint32FromInt32(full_height) + libc.Uint32FromInt32(libc.Int32FromInt32(1)<<v4) - uint32(1)) >> v4
 	goto _6
 _6:
 	height = libc.Int32FromUint32(v5)
 	best_bits = bits
 	**(**int32)(__ccgo_up(best_bits_out)) = bits
 	// Check rows first.
 	for best_bits < max_bits {
 		new_square_size = int32(1) << (best_bits + int32(1) - bits)
 		is_good = int32(1)
 		square_size = int32(1) << (best_bits - bits)
 		y = 0
 		for {
 			if !(y+square_size < height) {
 				break
 			}
 			// Check the first lines of consecutive line groups.
 			if libc.Xmemcmp(tls, image+uintptr(y*width)*4, image+uintptr((y+square_size)*width)*4, libc.Uint64FromInt32(width)*uint64(4)) != 0 {
 				is_good = 0
 				break
 			}
 			goto _7
 		_7:
 			;
 			y = y + new_square_size
 		}
 		if is_good != 0 {
 			best_bits = best_bits + 1
 		} else {
 			break
 		}
 	}
 	if best_bits == bits {
 		return
 	}
 	// Check columns.
 	for best_bits > bits {
 		is_good1 = int32(1)
 		square_size = int32(1) << (best_bits - bits)
 		y = 0
 		for {
 			if !(is_good1 != 0 && y < height) {
 				break
 			}
 			x = 0
 			for {
 				if !(is_good1 != 0 && x < width) {
 					break
 				}
 				i = x + int32(1)
 				for {
 					if !(i < GetMin(tls, x+square_size, width)) {
 						break
 					}
 					if **(**uint32_t)(__ccgo_up(image + uintptr(y*width+i)*4)) != **(**uint32_t)(__ccgo_up(image + uintptr(y*width+x)*4)) {
 						is_good1 = 0
 						break
 					}
 					goto _10
 				_10:
 					;
 					i = i + 1
 				}
 				goto _9
 			_9:
 				;
 				x = x + square_size
 			}
 			goto _8
 		_8:
 			;
 			y = y + 1
 		}
 		if is_good1 != 0 {
 			break
 		}
 		best_bits = best_bits - 1
 	}
 	if best_bits == bits {
 		return
 	}
 	// Subsample the image.
 	old_width = width
 	square_size = int32(1) << (best_bits - bits)
 	v1 = libc.Uint32FromInt32(best_bits)
 	v2 = (libc.Uint32FromInt32(full_width) + libc.Uint32FromInt32(libc.Int32FromInt32(1)<<v1) - uint32(1)) >> v1
 	goto _13
 _13:
 	width = libc.Int32FromUint32(v2)
 	v1 = libc.Uint32FromInt32(best_bits)
 	v2 = (libc.Uint32FromInt32(full_height) + libc.Uint32FromInt32(libc.Int32FromInt32(1)<<v1) - uint32(1)) >> v1
 	goto _16
 _16:
 	height = libc.Int32FromUint32(v2)
 	y = 0
 	for {
 		if !(y < height) {
 			break
 		}
 		x = 0
 		for {
 			if !(x < width) {
 				break
 			}
 			**(**uint32_t)(__ccgo_up(image + uintptr(y*width+x)*4)) = **(**uint32_t)(__ccgo_up(image + uintptr(square_size*(y*old_width+x))*4))
 			goto _18
 		_18:
 			;
 			x = x + 1
 		}
 		goto _17
 	_17:
 		;
 		y = y + 1
 	}
 	**(**int32)(__ccgo_up(best_bits_out)) = best_bits
 }
 
 // C documentation
 //
 //	// Computes the best predictor image.
 //	// Finds the best predictors per tile. Once done, finds the best predictor image
 //	// sampling.
 //	// best_bits is set to 0 in case of error.
 //	// The following requires some glossary:
 //	// - a tile is a square of side 2^min_bits pixels.
 //	// - a super-tile of a tile is a square of side 2^bits pixels with bits in
 //	// [min_bits+1, max_bits].
 //	// - the max-tile of a tile is the square of 2^max_bits pixels containing it.
 //	//   If this max-tile crosses the border of an image, it is cropped.
 //	// - tile, super-tiles and max_tile are aligned on powers of 2 in the original
 //	//   image.
 //	// - coordinates for tile, super-tile, max-tile are respectively named
 //	//   tile_x, super_tile_x, max_tile_x at their bit scale.
 //	// - in the max-tile, a tile has local coordinates (local_tile_x, local_tile_y).
 //	// The tiles are processed in the following zigzag order to complete the
 //	// super-tiles as soon as possible:
 //	//   1  2|  5  6
 //	//   3  4|  7  8
 //	// --------------
 //	//   9 10| 13 14
 //	//  11 12| 15 16
 //	// When computing the residuals for a tile, the histogram of the above
 //	// super-tile is updated. If this super-tile is finished, its histogram is used
 //	// to update the histogram of the next super-tile and so on up to the max-tile.
 func GetBestPredictorsAndSubSampling(tls *libc.TLS, width int32, height int32, min_bits int32, max_bits int32, argb_scratch uintptr, argb uintptr, max_quantization int32, exact int32, used_subtract_green int32, pic uintptr, percent_range int32, percent uintptr, all_modes uintptr, best_bits uintptr, best_mode uintptr) {
 	var accumulated, all_accumulated_argb, all_argb, all_pred_histos, raw_data uintptr
 	var best_cost, cost int64_t
 	var coord_x, coord_y, local_tile_x, local_tile_y, max_subsampling_index, max_tile_x, max_tile_y, subsampling_index, super_tile_x, super_tile_y, super_tiles_per_row, tile_x, tile_y, tiles_per_col, tiles_per_row, update_up_to_index, v1, v2, v4, v5 uint32_t
 	var max_tile_size, num_accumulated_rgb, num_argb, num_predictors, percent_start, plane int32
 	_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = accumulated, all_accumulated_argb, all_argb, all_pred_histos, best_cost, coord_x, coord_y, cost, local_tile_x, local_tile_y, max_subsampling_index, max_tile_size, max_tile_x, max_tile_y, num_accumulated_rgb, num_argb, num_predictors, percent_start, plane, raw_data, subsampling_index, super_tile_x, super_tile_y, super_tiles_per_row, tile_x, tile_y, tiles_per_col, tiles_per_row, update_up_to_index, v1, v2, v4, v5
 	v1 = libc.Uint32FromInt32(min_bits)
 	v2 = (libc.Uint32FromInt32(width) + libc.Uint32FromInt32(libc.Int32FromInt32(1)<<v1) - uint32(1)) >> v1
 	goto _3
 _3:
 	tiles_per_row = v2
 	v4 = libc.Uint32FromInt32(min_bits)
 	v5 = (libc.Uint32FromInt32(height) + libc.Uint32FromInt32(libc.Int32FromInt32(1)<<v4) - uint32(1)) >> v4
 	goto _6
 _6:
 	tiles_per_col = v5
 	max_subsampling_index = libc.Uint32FromInt32(max_bits - min_bits)
 	// Compute the needed memory size for residual histograms, accumulated
 	// residual histograms and predictor histograms.
 	num_argb = libc.Int32FromUint32((max_subsampling_index + uint32(1)) * libc.Uint32FromInt32(kNumPredModes) * libc.Uint32FromInt32(libc.Int32FromInt32(4)*libc.Int32FromInt32(256)))
 	num_accumulated_rgb = libc.Int32FromUint32((max_subsampling_index + uint32(1)) * libc.Uint32FromInt32(libc.Int32FromInt32(4)*libc.Int32FromInt32(256)))
 	num_predictors = libc.Int32FromUint32((max_subsampling_index + uint32(1)) * libc.Uint32FromInt32(kNumPredModes))
 	raw_data = WebPSafeCalloc(tls, libc.Uint64FromInt32(num_argb+num_accumulated_rgb+num_predictors), uint64(4))
 	all_argb = raw_data
 	all_accumulated_argb = all_argb + uintptr(num_argb)*4
 	all_pred_histos = all_accumulated_argb + uintptr(num_accumulated_rgb)*4
 	max_tile_size = int32(1) << max_subsampling_index // in tile size
 	percent_start = **(**int32)(__ccgo_up(percent))
 	// When using the residuals of a tile for its super-tiles, you can either:
 	// - use each residual to update the histogram of the super-tile, with a cost
 	//   of 4 * (1<<n)^2 increment operations (4 for the number of channels, and
 	//   (1<<n)^2 for the number of pixels in the tile)
 	// - use the histogram of the tile to update the histogram of the super-tile,
 	//   with a cost of HISTO_SIZE (1024)
 	// The first method is therefore faster until n==4. 'update_up_to_index'
 	// defines the maximum subsampling_index for which the residuals should be
 	// individually added to the super-tile histogram.
 	update_up_to_index = libc.Uint32FromInt32(GetMax(tls, GetMin(tls, int32(4), max_bits), min_bits) - min_bits)
 	// Coordinates in the max-tile in tile units.
 	local_tile_x = uint32(0)
 	local_tile_y = uint32(0)
 	max_tile_x = uint32(0)
 	max_tile_y = uint32(0)
 	tile_x = uint32(0)
 	tile_y = uint32(0)
 	**(**int32)(__ccgo_up(best_bits)) = 0
 	**(**uintptr)(__ccgo_up(best_mode)) = libc.UintptrFromInt32(0)
 	if raw_data == libc.UintptrFromInt32(0) {
 		return
 	}
 	for tile_y < tiles_per_col {
 		ComputeResidualsForTile(tls, width, height, libc.Int32FromUint32(tile_x), libc.Int32FromUint32(tile_y), min_bits, update_up_to_index, all_argb, argb_scratch, argb, max_quantization, exact, used_subtract_green)
 		// Update all the super-tiles that are complete.
 		subsampling_index = uint32(0)
 		for int32(1) != 0 {
 			super_tile_x = tile_x >> subsampling_index
 			super_tile_y = tile_y >> subsampling_index
 			v1 = libc.Uint32FromInt32(min_bits) + subsampling_index
 			v2 = (libc.Uint32FromInt32(width) + libc.Uint32FromInt32(libc.Int32FromInt32(1)<<v1) - uint32(1)) >> v1
 			goto _9
 		_9:
 			super_tiles_per_row = v2
 			GetBestPredictorForTile(tls, all_argb, libc.Int32FromUint32(subsampling_index), libc.Int32FromUint32(super_tile_x), libc.Int32FromUint32(super_tile_y), libc.Int32FromUint32(super_tiles_per_row), all_accumulated_argb, all_modes, all_pred_histos)
 			if subsampling_index == max_subsampling_index {
 				break
 			}
 			// Update the following super-tile histogram if it has not been updated
 			// yet.
 			subsampling_index = subsampling_index + 1
 			if subsampling_index > update_up_to_index && subsampling_index <= max_subsampling_index {
 				(*(*func(*libc.TLS, uintptr, uintptr, int32))(unsafe.Pointer(&struct{ uintptr }{VP8LAddVectorEq})))(tls, GetHistoArgbConst(tls, all_argb, libc.Int32FromUint32(subsampling_index-uint32(1)), 0), GetHistoArgb(tls, all_argb, libc.Int32FromUint32(subsampling_index), 0), libc.Int32FromInt32(4)*libc.Int32FromInt32(256)*kNumPredModes)
 			}
 			// Check whether the super-tile is not complete (if the smallest tile
 			// is not at the end of a line/column or at the beginning of a super-tile
 			// of size (1 << subsampling_index)).
 			if !((tile_x == tiles_per_row-uint32(1) || (local_tile_x+uint32(1))%libc.Uint32FromInt32(libc.Int32FromInt32(1)<<subsampling_index) == uint32(0)) && (tile_y == tiles_per_col-uint32(1) || (local_tile_y+uint32(1))%libc.Uint32FromInt32(libc.Int32FromInt32(1)<<subsampling_index) == uint32(0))) {
 				subsampling_index = subsampling_index - 1
 				// subsampling_index now is the index of the last finished super-tile.
 				break
 			}
 		}
 		// Reset all the histograms belonging to finished tiles.
 		libc.X__builtin___memset_chk(tls, all_argb, 0, uint64(libc.Uint32FromInt32(libc.Int32FromInt32(4)*libc.Int32FromInt32(256)*kNumPredModes)*(subsampling_index+uint32(1)))*uint64(4), ^__predefined_size_t(0))
 		if subsampling_index == max_subsampling_index {
 			// If a new max-tile is started.
 			if tile_x == tiles_per_row-uint32(1) {
 				max_tile_x = uint32(0)
 				max_tile_y = max_tile_y + 1
 			} else {
 				max_tile_x = max_tile_x + 1
 			}
 			local_tile_x = uint32(0)
 			local_tile_y = uint32(0)
 		} else {
 			// Proceed with the Z traversal.
 			coord_x = local_tile_x >> subsampling_index
 			coord_y = local_tile_y >> subsampling_index
 			if tile_x == tiles_per_row-uint32(1) && coord_x%uint32(2) == uint32(0) {
 				coord_y = coord_y + 1
 			} else {
 				if coord_x%uint32(2) == uint32(0) {
 					coord_x = coord_x + 1
 				} else {
 					// Z traversal.
 					coord_y = coord_y + 1
 					coord_x = coord_x - 1
 				}
 			}
 			local_tile_x = coord_x << subsampling_index
 			local_tile_y = coord_y << subsampling_index
 		}
 		tile_x = max_tile_x*libc.Uint32FromInt32(max_tile_size) + local_tile_x
 		tile_y = max_tile_y*libc.Uint32FromInt32(max_tile_size) + local_tile_y
 		if tile_x == uint32(0) && !(WebPReportProgress(tls, pic, libc.Int32FromUint32(libc.Uint32FromInt32(percent_start)+libc.Uint32FromInt32(percent_range)*tile_y/tiles_per_col), percent) != 0) {
 			WebPSafeFree(tls, raw_data)
 			return
 		}
 	}
 	// Figure out the best sampling.
 	best_cost = libc.Int64FromUint64(libc.Uint64FromUint64(1)<<libc.Int32FromInt32(63) - libc.Uint64FromInt32(1))
 	subsampling_index = uint32(0)
 	for {
 		if !(subsampling_index <= max_subsampling_index) {
 			break
 		}
 		accumulated = GetAccumulatedHisto(tls, all_accumulated_argb, libc.Int32FromUint32(subsampling_index))
 		cost = libc.Int64FromUint64((*(*func(*libc.TLS, uintptr, int32) uint64_t)(unsafe.Pointer(&struct{ uintptr }{VP8LShannonEntropy})))(tls, all_pred_histos+uintptr(subsampling_index*libc.Uint32FromInt32(kNumPredModes))*4, kNumPredModes))
 		plane = 0
 		for {
 			if !(plane < int32(4)) {
 				break
 			}
 			cost = libc.Int64FromUint64(uint64(cost) + (*(*func(*libc.TLS, uintptr, int32) uint64_t)(unsafe.Pointer(&struct{ uintptr }{VP8LShannonEntropy})))(tls, accumulated+uintptr(plane*int32(256))*4, int32(256)))
 			goto _11
 		_11:
 			;
 			plane = plane + 1
 		}
 		if cost < best_cost {
 			best_cost = cost
 			**(**int32)(__ccgo_up(best_bits)) = libc.Int32FromUint32(libc.Uint32FromInt32(min_bits) + subsampling_index)
 			**(**uintptr)(__ccgo_up(best_mode)) = **(**uintptr)(__ccgo_up(all_modes + uintptr(subsampling_index)*8))
 		}
 		goto _10
 	_10:
 		;
 		subsampling_index = subsampling_index + 1
 	}
 	WebPSafeFree(tls, raw_data)
 	VP8LOptimizeSampling(tls, **(**uintptr)(__ccgo_up(best_mode)), width, height, **(**int32)(__ccgo_up(best_bits)), libc.Int32FromInt32(MIN_TRANSFORM_BITS)+libc.Int32FromInt32(1)<<libc.Int32FromInt32(NUM_TRANSFORM_BITS)-libc.Int32FromInt32(1), best_bits)
 }
 
 // C documentation
 //
 //	// Finds the best predictor for each tile, and converts the image to residuals
 //	// with respect to predictions. If near_lossless_quality < 100, applies
 //	// near lossless processing, shaving off more bits of residuals for lower
 //	// qualities.
 func VP8LResidualImage(tls *libc.TLS, width int32, height int32, min_bits int32, max_bits int32, low_effort int32, argb uintptr, argb_scratch uintptr, image uintptr, near_lossless_quality1 int32, exact int32, used_subtract_green int32, pic uintptr, percent_range int32, percent uintptr, best_bits uintptr) (r int32) {
 	bp := tls.Alloc(96)
 	defer tls.Free(96)
 	var bits, i, max_quantization, percent_start, tiles_per_col, tiles_per_col1, tiles_per_row, tiles_per_row1, v1 int32
 	var modes_raw uintptr
 	var num_pixels [10]uint32_t
 	var sum_num_pixels, v3, v4, v6, v7 uint32_t
 	var _ /* best_mode at bp+0 */ uintptr
 	var _ /* modes at bp+8 */ [10]uintptr
 	_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = bits, i, max_quantization, modes_raw, num_pixels, percent_start, sum_num_pixels, tiles_per_col, tiles_per_col1, tiles_per_row, tiles_per_row1, v1, v3, v4, v6, v7
 	percent_start = **(**int32)(__ccgo_up(percent))
 	v1 = int32(5) - near_lossless_quality1/int32(20)
 	goto _2
 _2:
 	max_quantization = int32(1) << v1
 	if low_effort != 0 {
 		v3 = libc.Uint32FromInt32(max_bits)
 		v4 = (libc.Uint32FromInt32(width) + libc.Uint32FromInt32(libc.Int32FromInt32(1)<<v3) - uint32(1)) >> v3
 		goto _5
 	_5:
 		tiles_per_row = libc.Int32FromUint32(v4)
 		v6 = libc.Uint32FromInt32(max_bits)
 		v7 = (libc.Uint32FromInt32(height) + libc.Uint32FromInt32(libc.Int32FromInt32(1)<<v6) - uint32(1)) >> v6
 		goto _8
 	_8:
 		tiles_per_col = libc.Int32FromUint32(v7)
 		i = 0
 		for {
 			if !(i < tiles_per_row*tiles_per_col) {
 				break
 			}
 			**(**uint32_t)(__ccgo_up(image + uintptr(i)*4)) = uint32(ARGB_BLACK1) | libc.Uint32FromInt32(kPredLowEffort<<libc.Int32FromInt32(8))
 			goto _9
 		_9:
 			;
 			i = i + 1
 		}
 		**(**int32)(__ccgo_up(best_bits)) = max_bits
 	} else {
 		sum_num_pixels = 0
 		bits = min_bits
 		for {
 			if !(bits <= max_bits) {
 				break
 			}
 			v3 = libc.Uint32FromInt32(bits)
 			v4 = (libc.Uint32FromInt32(width) + libc.Uint32FromInt32(libc.Int32FromInt32(1)<<v3) - uint32(1)) >> v3
 			goto _13
 		_13:
 			tiles_per_row1 = libc.Int32FromUint32(v4)
 			v6 = libc.Uint32FromInt32(bits)
 			v7 = (libc.Uint32FromInt32(height) + libc.Uint32FromInt32(libc.Int32FromInt32(1)<<v6) - uint32(1)) >> v6
 			goto _16
 		_16:
 			tiles_per_col1 = libc.Int32FromUint32(v7)
 			num_pixels[bits] = libc.Uint32FromInt32(tiles_per_row1 * tiles_per_col1)
 			sum_num_pixels = sum_num_pixels + num_pixels[bits]
 			goto _10
 		_10:
 			;
 			bits = bits + 1
 		}
 		modes_raw = WebPSafeMalloc(tls, uint64(sum_num_pixels), uint64(4))
 		if modes_raw == libc.UintptrFromInt32(0) {
 			return 0
 		}
 		// Have modes point to the right global memory modes_raw.
 		(**(**[10]uintptr)(__ccgo_up(bp + 8)))[min_bits] = modes_raw
 		bits = min_bits + int32(1)
 		for {
 			if !(bits <= max_bits) {
 				break
 			}
 			(**(**[10]uintptr)(__ccgo_up(bp + 8)))[bits] = (**(**[10]uintptr)(__ccgo_up(bp + 8)))[bits-int32(1)] + uintptr(num_pixels[bits-int32(1)])*4
 			goto _17
 		_17:
 			;
 			bits = bits + 1
 		}
 		// Find the best sampling.
 		GetBestPredictorsAndSubSampling(tls, width, height, min_bits, max_bits, argb_scratch, argb, max_quantization, exact, used_subtract_green, pic, percent_range, percent, bp+8+uintptr(min_bits)*8, best_bits, bp)
 		if **(**int32)(__ccgo_up(best_bits)) == 0 {
 			WebPSafeFree(tls, modes_raw)
 			return 0
 		}
 		// Keep the best predictor image.
 		v3 = libc.Uint32FromInt32(**(**int32)(__ccgo_up(best_bits)))
 		v4 = (libc.Uint32FromInt32(width) + libc.Uint32FromInt32(libc.Int32FromInt32(1)<<v3) - uint32(1)) >> v3
 		goto _20
 	_20:
 		v6 = libc.Uint32FromInt32(**(**int32)(__ccgo_up(best_bits)))
 		v7 = (libc.Uint32FromInt32(height) + libc.Uint32FromInt32(libc.Int32FromInt32(1)<<v6) - uint32(1)) >> v6
 		goto _23
 	_23:
 		libc.X__builtin___memcpy_chk(tls, image, **(**uintptr)(__ccgo_up(bp)), uint64(v4*v7)*uint64(4), ^__predefined_size_t(0))
 		WebPSafeFree(tls, modes_raw)
 	}
 	CopyImageWithPrediction(tls, width, height, **(**int32)(__ccgo_up(best_bits)), image, argb_scratch, argb, low_effort, max_quantization, exact, used_subtract_green)
 	return WebPReportProgress(tls, pic, percent_start+percent_range, percent)
 }
 
 //------------------------------------------------------------------------------
 // Color transform functions.
 
 func MultipliersClear(tls *libc.TLS, m uintptr) {
 	(*VP8LMultipliers)(unsafe.Pointer(m)).Fgreen_to_red = uint8(0)
 	(*VP8LMultipliers)(unsafe.Pointer(m)).Fgreen_to_blue = uint8(0)
 	(*VP8LMultipliers)(unsafe.Pointer(m)).Fred_to_blue = uint8(0)
 }
 
 func ColorCodeToMultipliers(tls *libc.TLS, color_code uint32_t, m uintptr) {
 	(*VP8LMultipliers)(unsafe.Pointer(m)).Fgreen_to_red = uint8(color_code >> libc.Int32FromInt32(0) & uint32(0xff))
 	(*VP8LMultipliers)(unsafe.Pointer(m)).Fgreen_to_blue = uint8(color_code >> libc.Int32FromInt32(8) & uint32(0xff))
 	(*VP8LMultipliers)(unsafe.Pointer(m)).Fred_to_blue = uint8(color_code >> libc.Int32FromInt32(16) & uint32(0xff))
 }
 
 func MultipliersToColorCode(tls *libc.TLS, m uintptr) (r uint32_t) {
 	return uint32(0xff000000) | uint32((*VP8LMultipliers)(unsafe.Pointer(m)).Fred_to_blue)<<libc.Int32FromInt32(16) | uint32((*VP8LMultipliers)(unsafe.Pointer(m)).Fgreen_to_blue)<<libc.Int32FromInt32(8) | uint32((*VP8LMultipliers)(unsafe.Pointer(m)).Fgreen_to_red)
 }
 
 func PredictionCostCrossColor(tls *libc.TLS, accumulated uintptr, counts uintptr) (r int64_t) {
 	return libc.Int64FromUint64((*(*func(*libc.TLS, uintptr, uintptr) uint64_t)(unsafe.Pointer(&struct{ uintptr }{VP8LCombinedShannonEntropy})))(tls, counts, accumulated)) + PredictionCostBias(tls, counts, uint64(3), kExpValue)
 }
 
 // Favor low entropy, locally and globally.
 // Favor small absolute values for PredictionCostSpatial
 var kExpValue = uint64(240)
 
 func GetPredictionCostCrossColorRed(tls *libc.TLS, argb uintptr, stride int32, tile_width int32, tile_height int32, prev_x VP8LMultipliers, prev_y VP8LMultipliers, green_to_red int32, accumulated_red_histo uintptr) (r int64_t) {
 	bp := tls.Alloc(1024)
 	defer tls.Free(1024)
 	var cur_diff int64_t
 	var _ /* histo at bp+0 */ [256]uint32_t
 	_ = cur_diff
 	**(**[256]uint32_t)(__ccgo_up(bp)) = [256]uint32_t{}
 	(*(*func(*libc.TLS, uintptr, int32, int32, int32, int32, uintptr))(unsafe.Pointer(&struct{ uintptr }{VP8LCollectColorRedTransforms})))(tls, argb, stride, tile_width, tile_height, green_to_red, bp)
 	cur_diff = PredictionCostCrossColor(tls, accumulated_red_histo, bp)
 	if libc.Int32FromUint8(libc.Uint8FromInt32(green_to_red)) == libc.Int32FromUint8(prev_x.Fgreen_to_red) {
 		// favor keeping the areas locally similar
 		cur_diff = cur_diff - libc.Int64FromInt64(3)<<libc.Int32FromInt32(LOG_2_PRECISION_BITS)
 	}
 	if libc.Int32FromUint8(libc.Uint8FromInt32(green_to_red)) == libc.Int32FromUint8(prev_y.Fgreen_to_red) {
 		// favor keeping the areas locally similar
 		cur_diff = cur_diff - libc.Int64FromInt64(3)<<libc.Int32FromInt32(LOG_2_PRECISION_BITS)
 	}
 	if green_to_red == 0 {
 		cur_diff = cur_diff - libc.Int64FromInt64(3)<<libc.Int32FromInt32(LOG_2_PRECISION_BITS)
 	}
 	return cur_diff
 }
 
 func GetBestGreenToRed(tls *libc.TLS, argb uintptr, stride int32, tile_width int32, tile_height int32, prev_x VP8LMultipliers, prev_y VP8LMultipliers, quality int32, accumulated_red_histo uintptr, best_tx uintptr) {
 	var best_diff, cur_diff int64_t
 	var delta, green_to_red_best, green_to_red_cur, iter, kMaxIters, offset int32
 	_, _, _, _, _, _, _, _ = best_diff, cur_diff, delta, green_to_red_best, green_to_red_cur, iter, kMaxIters, offset
 	kMaxIters = int32(4) + int32(7)*quality>>int32(8) // in range [4..6]
 	green_to_red_best = 0
 	best_diff = GetPredictionCostCrossColorRed(tls, argb, stride, tile_width, tile_height, prev_x, prev_y, green_to_red_best, accumulated_red_histo)
 	iter = 0
 	for {
 		if !(iter < kMaxIters) {
 			break
 		}
 		// ColorTransformDelta is a 3.5 bit fixed point, so 32 is equal to
 		// one in color computation. Having initial delta here as 1 is sufficient
 		// to explore the range of (-2, 2).
 		delta = int32(32) >> iter
 		// Try a negative and a positive delta from the best known value.
 		offset = -delta
 		for {
 			if !(offset <= delta) {
 				break
 			}
 			green_to_red_cur = offset + green_to_red_best
 			cur_diff = GetPredictionCostCrossColorRed(tls, argb, stride, tile_width, tile_height, prev_x, prev_y, green_to_red_cur, accumulated_red_histo)
 			if cur_diff < best_diff {
 				best_diff = cur_diff
 				green_to_red_best = green_to_red_cur
 			}
 			goto _2
 		_2:
 			;
 			offset = offset + int32(2)*delta
 		}
 		goto _1
 	_1:
 		;
 		iter = iter + 1
 	}
 	(*VP8LMultipliers)(unsafe.Pointer(best_tx)).Fgreen_to_red = libc.Uint8FromInt32(green_to_red_best & libc.Int32FromInt32(0xff))
 }
 
 func GetPredictionCostCrossColorBlue(tls *libc.TLS, argb uintptr, stride int32, tile_width int32, tile_height int32, prev_x VP8LMultipliers, prev_y VP8LMultipliers, green_to_blue int32, red_to_blue int32, accumulated_blue_histo uintptr) (r int64_t) {
 	bp := tls.Alloc(1024)
 	defer tls.Free(1024)
 	var cur_diff int64_t
 	var _ /* histo at bp+0 */ [256]uint32_t
 	_ = cur_diff
 	**(**[256]uint32_t)(__ccgo_up(bp)) = [256]uint32_t{}
 	(*(*func(*libc.TLS, uintptr, int32, int32, int32, int32, int32, uintptr))(unsafe.Pointer(&struct{ uintptr }{VP8LCollectColorBlueTransforms})))(tls, argb, stride, tile_width, tile_height, green_to_blue, red_to_blue, bp)
 	cur_diff = PredictionCostCrossColor(tls, accumulated_blue_histo, bp)
 	if libc.Int32FromUint8(libc.Uint8FromInt32(green_to_blue)) == libc.Int32FromUint8(prev_x.Fgreen_to_blue) {
 		// favor keeping the areas locally similar
 		cur_diff = cur_diff - libc.Int64FromInt64(3)<<libc.Int32FromInt32(LOG_2_PRECISION_BITS)
 	}
 	if libc.Int32FromUint8(libc.Uint8FromInt32(green_to_blue)) == libc.Int32FromUint8(prev_y.Fgreen_to_blue) {
 		// favor keeping the areas locally similar
 		cur_diff = cur_diff - libc.Int64FromInt64(3)<<libc.Int32FromInt32(LOG_2_PRECISION_BITS)
 	}
 	if libc.Int32FromUint8(libc.Uint8FromInt32(red_to_blue)) == libc.Int32FromUint8(prev_x.Fred_to_blue) {
 		// favor keeping the areas locally similar
 		cur_diff = cur_diff - libc.Int64FromInt64(3)<<libc.Int32FromInt32(LOG_2_PRECISION_BITS)
 	}
 	if libc.Int32FromUint8(libc.Uint8FromInt32(red_to_blue)) == libc.Int32FromUint8(prev_y.Fred_to_blue) {
 		// favor keeping the areas locally similar
 		cur_diff = cur_diff - libc.Int64FromInt64(3)<<libc.Int32FromInt32(LOG_2_PRECISION_BITS)
 	}
 	if green_to_blue == 0 {
 		cur_diff = cur_diff - libc.Int64FromInt64(3)<<libc.Int32FromInt32(LOG_2_PRECISION_BITS)
 	}
 	if red_to_blue == 0 {
 		cur_diff = cur_diff - libc.Int64FromInt64(3)<<libc.Int32FromInt32(LOG_2_PRECISION_BITS)
 	}
 	return cur_diff
 }
 
 func GetBestGreenRedToBlue(tls *libc.TLS, argb uintptr, stride int32, tile_width int32, tile_height int32, prev_x VP8LMultipliers, prev_y VP8LMultipliers, quality int32, accumulated_blue_histo uintptr, best_tx uintptr) {
 	bp := tls.Alloc(16)
 	defer tls.Free(16)
 	var axis, delta, green_to_blue_best, green_to_blue_cur, iter, iters, red_to_blue_best, red_to_blue_cur, v1, v2 int32
 	var best_diff, cur_diff int64_t
 	var delta_lut [7]int8_t
 	var _ /* offset at bp+0 */ [8][2]int8_t
 	_, _, _, _, _, _, _, _, _, _, _, _, _ = axis, best_diff, cur_diff, delta, delta_lut, green_to_blue_best, green_to_blue_cur, iter, iters, red_to_blue_best, red_to_blue_cur, v1, v2
 	**(**[8][2]int8_t)(__ccgo_up(bp)) = [8][2]int8_t{
 		0: {
 			1: int8(-int32(1)),
 		},
 		1: {
 			1: int8(1),
 		},
 		2: {
 			0: int8(-int32(1)),
 		},
 		3: {
 			0: int8(1),
 		},
 		4: {
 			0: int8(-int32(1)),
 			1: int8(-int32(1)),
 		},
 		5: {
 			0: int8(-int32(1)),
 			1: int8(1),
 		},
 		6: {
 			0: int8(1),
 			1: int8(-int32(1)),
 		},
 		7: {
 			0: int8(1),
 			1: int8(1),
 		},
 	}
 	delta_lut = [7]int8_t{
 		0: int8(16),
 		1: int8(16),
 		2: int8(8),
 		3: int8(4),
 		4: int8(2),
 		5: int8(2),
 		6: int8(2),
 	}
 	if quality < int32(25) {
 		v1 = int32(1)
 	} else {
 		if quality > int32(50) {
 			v2 = int32(7)
 		} else {
 			v2 = int32(4)
 		}
 		v1 = v2
 	}
 	iters = v1
 	green_to_blue_best = 0
 	red_to_blue_best = 0
 	// Initial value at origin:
 	best_diff = GetPredictionCostCrossColorBlue(tls, argb, stride, tile_width, tile_height, prev_x, prev_y, green_to_blue_best, red_to_blue_best, accumulated_blue_histo)
 	iter = 0
 	for {
 		if !(iter < iters) {
 			break
 		}
 		delta = int32(delta_lut[iter])
 		axis = 0
 		for {
 			if !(axis < int32(8)) {
 				break
 			}
 			green_to_blue_cur = int32(**(**int8_t)(__ccgo_up(bp + uintptr(axis)*2)))*delta + green_to_blue_best
 			red_to_blue_cur = int32(**(**int8_t)(__ccgo_up(bp + uintptr(axis)*2 + 1)))*delta + red_to_blue_best
 			cur_diff = GetPredictionCostCrossColorBlue(tls, argb, stride, tile_width, tile_height, prev_x, prev_y, green_to_blue_cur, red_to_blue_cur, accumulated_blue_histo)
 			if cur_diff < best_diff {
 				best_diff = cur_diff
 				green_to_blue_best = green_to_blue_cur
 				red_to_blue_best = red_to_blue_cur
 			}
 			if quality < int32(25) && iter == int32(4) {
 				// Only axis aligned diffs for lower quality.
 				break // next iter.
 			}
 			goto _4
 		_4:
 			;
 			axis = axis + 1
 		}
 		if delta == int32(2) && green_to_blue_best == 0 && red_to_blue_best == 0 {
 			// Further iterations would not help.
 			break // out of iter-loop.
 		}
 		goto _3
 	_3:
 		;
 		iter = iter + 1
 	}
 	(*VP8LMultipliers)(unsafe.Pointer(best_tx)).Fgreen_to_blue = libc.Uint8FromInt32(green_to_blue_best & int32(0xff))
 	(*VP8LMultipliers)(unsafe.Pointer(best_tx)).Fred_to_blue = libc.Uint8FromInt32(red_to_blue_best & int32(0xff))
 }
 
 func GetBestColorTransformForTile(tls *libc.TLS, tile_x int32, tile_y int32, bits int32, prev_x VP8LMultipliers, prev_y VP8LMultipliers, quality int32, xsize int32, ysize int32, accumulated_red_histo uintptr, accumulated_blue_histo uintptr, argb uintptr) (r VP8LMultipliers) {
 	bp := tls.Alloc(16)
 	defer tls.Free(16)
 	var all_x_max, all_y_max, max_tile_size, tile_height, tile_width, tile_x_offset, tile_y_offset int32
 	var tile_argb uintptr
 	var _ /* best_tx at bp+0 */ VP8LMultipliers
 	_, _, _, _, _, _, _, _ = all_x_max, all_y_max, max_tile_size, tile_argb, tile_height, tile_width, tile_x_offset, tile_y_offset
 	max_tile_size = int32(1) << bits
 	tile_y_offset = tile_y * max_tile_size
 	tile_x_offset = tile_x * max_tile_size
 	all_x_max = GetMin(tls, tile_x_offset+max_tile_size, xsize)
 	all_y_max = GetMin(tls, tile_y_offset+max_tile_size, ysize)
 	tile_width = all_x_max - tile_x_offset
 	tile_height = all_y_max - tile_y_offset
 	tile_argb = argb + uintptr(tile_y_offset*xsize)*4 + uintptr(tile_x_offset)*4
 	MultipliersClear(tls, bp)
 	GetBestGreenToRed(tls, tile_argb, xsize, tile_width, tile_height, prev_x, prev_y, quality, accumulated_red_histo, bp)
 	GetBestGreenRedToBlue(tls, tile_argb, xsize, tile_width, tile_height, prev_x, prev_y, quality, accumulated_blue_histo, bp)
 	return **(**VP8LMultipliers)(__ccgo_up(bp))
 }
 
 func CopyTileWithColorTransform(tls *libc.TLS, xsize int32, ysize int32, tile_x int32, tile_y int32, max_tile_size int32, _color_transform VP8LMultipliers, argb uintptr) {
 	bp := tls.Alloc(16)
 	defer tls.Free(16)
 	*(*VP8LMultipliers)(unsafe.Pointer(bp)) = _color_transform
 	var xscan, yscan, v1 int32
 	_, _, _ = xscan, yscan, v1
 	xscan = GetMin(tls, max_tile_size, xsize-tile_x)
 	yscan = GetMin(tls, max_tile_size, ysize-tile_y)
 	argb = argb + uintptr(tile_y*xsize+tile_x)*4
 	for {
 		v1 = yscan
 		yscan = yscan - 1
 		if !(v1 > 0) {
 			break
 		}
 		(*(*func(*libc.TLS, uintptr, uintptr, int32))(unsafe.Pointer(&struct{ uintptr }{VP8LTransformColor})))(tls, bp, argb, xscan)
 		argb = argb + uintptr(xsize)*4
 	}
 }
 
 func VP8LColorSpaceTransform(tls *libc.TLS, width int32, height int32, bits int32, quality int32, argb uintptr, image uintptr, pic uintptr, percent_range int32, percent uintptr, best_bits uintptr) (r int32) {
 	bp := tls.Alloc(2064)
 	defer tls.Free(2064)
 	var all_x_max, all_y_max, ix, ix_end, max_tile_size, offset, percent_start, tile_x, tile_x_offset, tile_xsize, tile_y, tile_y_offset, tile_ysize, y int32
 	var pix, v1, v2, v4, v5 uint32_t
 	var _ /* accumulated_blue_histo at bp+1024 */ [256]uint32_t
 	var _ /* accumulated_red_histo at bp+0 */ [256]uint32_t
 	var _ /* prev_x at bp+2049 */ VP8LMultipliers
 	var _ /* prev_y at bp+2052 */ VP8LMultipliers
 	_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = all_x_max, all_y_max, ix, ix_end, max_tile_size, offset, percent_start, pix, tile_x, tile_x_offset, tile_xsize, tile_y, tile_y_offset, tile_ysize, y, v1, v2, v4, v5
 	max_tile_size = int32(1) << bits
 	v1 = libc.Uint32FromInt32(bits)
 	v2 = (libc.Uint32FromInt32(width) + libc.Uint32FromInt32(libc.Int32FromInt32(1)<<v1) - uint32(1)) >> v1
 	goto _3
 _3:
 	tile_xsize = libc.Int32FromUint32(v2)
 	v4 = libc.Uint32FromInt32(bits)
 	v5 = (libc.Uint32FromInt32(height) + libc.Uint32FromInt32(libc.Int32FromInt32(1)<<v4) - uint32(1)) >> v4
 	goto _6
 _6:
 	tile_ysize = libc.Int32FromUint32(v5)
 	percent_start = **(**int32)(__ccgo_up(percent))
 	**(**[256]uint32_t)(__ccgo_up(bp)) = [256]uint32_t{}
 	**(**[256]uint32_t)(__ccgo_up(bp + 1024)) = [256]uint32_t{}
 	MultipliersClear(tls, bp+2052)
 	MultipliersClear(tls, bp+2049)
 	tile_y = 0
 	for {
 		if !(tile_y < tile_ysize) {
 			break
 		}
 		tile_x = 0
 		for {
 			if !(tile_x < tile_xsize) {
 				break
 			}
 			tile_x_offset = tile_x * max_tile_size
 			tile_y_offset = tile_y * max_tile_size
 			all_x_max = GetMin(tls, tile_x_offset+max_tile_size, width)
 			all_y_max = GetMin(tls, tile_y_offset+max_tile_size, height)
 			offset = tile_y*tile_xsize + tile_x
 			if tile_y != 0 {
 				ColorCodeToMultipliers(tls, **(**uint32_t)(__ccgo_up(image + uintptr(offset-tile_xsize)*4)), bp+2052)
 			}
 			**(**VP8LMultipliers)(__ccgo_up(bp + 2049)) = GetBestColorTransformForTile(tls, tile_x, tile_y, bits, **(**VP8LMultipliers)(__ccgo_up(bp + 2049)), **(**VP8LMultipliers)(__ccgo_up(bp + 2052)), quality, width, height, bp, bp+1024, argb)
 			**(**uint32_t)(__ccgo_up(image + uintptr(offset)*4)) = MultipliersToColorCode(tls, bp+2049)
 			CopyTileWithColorTransform(tls, width, height, tile_x_offset, tile_y_offset, max_tile_size, **(**VP8LMultipliers)(__ccgo_up(bp + 2049)), argb)
 			// Gather accumulated histogram data.
 			y = tile_y_offset
 			for {
 				if !(y < all_y_max) {
 					break
 				}
 				ix = y*width + tile_x_offset
 				ix_end = ix + all_x_max - tile_x_offset
 				for {
 					if !(ix < ix_end) {
 						break
 					}
 					pix = **(**uint32_t)(__ccgo_up(argb + uintptr(ix)*4))
 					if ix >= int32(2) && pix == **(**uint32_t)(__ccgo_up(argb + uintptr(ix-int32(2))*4)) && pix == **(**uint32_t)(__ccgo_up(argb + uintptr(ix-int32(1))*4)) {
 						goto _10 // repeated pixels are handled by backward references
 					}
 					if ix >= width+int32(2) && **(**uint32_t)(__ccgo_up(argb + uintptr(ix-int32(2))*4)) == **(**uint32_t)(__ccgo_up(argb + uintptr(ix-width-int32(2))*4)) && **(**uint32_t)(__ccgo_up(argb + uintptr(ix-int32(1))*4)) == **(**uint32_t)(__ccgo_up(argb + uintptr(ix-width-int32(1))*4)) && pix == **(**uint32_t)(__ccgo_up(argb + uintptr(ix-width)*4)) {
 						goto _10 // repeated pixels are handled by backward references
 					}
 					(**(**[256]uint32_t)(__ccgo_up(bp)))[pix>>libc.Int32FromInt32(16)&uint32(0xff)] = (**(**[256]uint32_t)(__ccgo_up(bp)))[pix>>libc.Int32FromInt32(16)&uint32(0xff)] + 1
 					(**(**[256]uint32_t)(__ccgo_up(bp + 1024)))[pix>>libc.Int32FromInt32(0)&uint32(0xff)] = (**(**[256]uint32_t)(__ccgo_up(bp + 1024)))[pix>>libc.Int32FromInt32(0)&uint32(0xff)] + 1
 					goto _10
 				_10:
 					;
 					ix = ix + 1
 				}
 				goto _9
 			_9:
 				;
 				y = y + 1
 			}
 			goto _8
 		_8:
 			;
 			tile_x = tile_x + 1
 		}
 		if !(WebPReportProgress(tls, pic, percent_start+percent_range*tile_y/tile_ysize, percent) != 0) {
 			return 0
 		}
 		goto _7
 	_7:
 		;
 		tile_y = tile_y + 1
 	}
 	VP8LOptimizeSampling(tls, image, width, height, bits, libc.Int32FromInt32(MIN_TRANSFORM_BITS)+libc.Int32FromInt32(1)<<libc.Int32FromInt32(NUM_TRANSFORM_BITS)-libc.Int32FromInt32(1), best_bits)
 	return int32(1)
 }
 
 const DO_TRELLIS_I16 = 1
 const DO_TRELLIS_I4 = 1
 const DO_TRELLIS_UV = 0
 const FLATNESS_LIMIT_I16 = 0
 const FLATNESS_LIMIT_I4 = 3
 const FLATNESS_LIMIT_UV = 2
 const FLATNESS_PENALTY = 140
 const FSTRENGTH_CUTOFF = 2
 const IsFlat = "IsFlat_C"
 const MAX_ALPHA1 = 100
 const MAX_DELTA = 1
 const MAX_DQ_UV = 6
 const MID_ALPHA = 64
 const MIN_ALPHA = 30
 const MIN_DELTA = 0
 const RD_DISTO_MULT = 256
 const SHARPEN_BITS = 11
 const SNS_TO_DQ = 0.9
 const USE_TDISTO = 1
 const __FLT_MIN__7 = 1.1754943508222875e-38
 
 //------------------------------------------------------------------------------
 
 // Copyright 2011 Google Inc. All Rights Reserved.
 //
 // Use of this source code is governed by a BSD-style license
 // that can be found in the COPYING file in the root of the source
 // tree. An additional intellectual property rights grant can be found
 // in the file PATENTS. All contributing project authors may
 // be found in the AUTHORS file in the root of the source tree.
 // -----------------------------------------------------------------------------
 //
 //   WebP encoder: internal header.
 //
 // Author: Skal (pascal.massimino@gmail.com)
 
 // Copyright 2010 Google Inc. All Rights Reserved.
 //
 // Use of this source code is governed by a BSD-style license
 // that can be found in the COPYING file in the root of the source
 // tree. An additional intellectual property rights grant can be found
 // in the file PATENTS. All contributing project authors may
 // be found in the AUTHORS file in the root of the source tree.
 // -----------------------------------------------------------------------------
 //
 //  Common types + memory wrappers
 //
 // Author: Skal (pascal.massimino@gmail.com)
 
 // power-law modulation. Must be strictly less than 1.
 
 // number of non-zero coeffs below which we consider the block very flat
 // (and apply a penalty to complex predictions)
 
 // #define DEBUG_BLOCK
 
 //------------------------------------------------------------------------------
 
 //------------------------------------------------------------------------------
 
 func clip2(tls *libc.TLS, v int32, m int32, M int32) (r int32) {
 	var v1, v2 int32
 	_, _ = v1, v2
 	if v < m {
 		v1 = m
 	} else {
 		if v > M {
 			v2 = M
 		} else {
 			v2 = v
 		}
 		v1 = v2
 	}
 	return v1
 }
 
 var kZigzag1 = [16]uint8_t{
 	1:  uint8(1),
 	2:  uint8(4),
 	3:  uint8(8),
 	4:  uint8(5),
 	5:  uint8(2),
 	6:  uint8(3),
 	7:  uint8(6),
 	8:  uint8(9),
 	9:  uint8(12),
 	10: uint8(13),
 	11: uint8(10),
 	12: uint8(7),
 	13: uint8(11),
 	14: uint8(14),
 	15: uint8(15),
 }
 
 var kDcTable1 = [128]uint8_t{
 	0:   uint8(4),
 	1:   uint8(5),
 	2:   uint8(6),
 	3:   uint8(7),
 	4:   uint8(8),
 	5:   uint8(9),
 	6:   uint8(10),
 	7:   uint8(10),
 	8:   uint8(11),
 	9:   uint8(12),
 	10:  uint8(13),
 	11:  uint8(14),
 	12:  uint8(15),
 	13:  uint8(16),
 	14:  uint8(17),
 	15:  uint8(17),
 	16:  uint8(18),
 	17:  uint8(19),
 	18:  uint8(20),
 	19:  uint8(20),
 	20:  uint8(21),
 	21:  uint8(21),
 	22:  uint8(22),
 	23:  uint8(22),
 	24:  uint8(23),
 	25:  uint8(23),
 	26:  uint8(24),
 	27:  uint8(25),
 	28:  uint8(25),
 	29:  uint8(26),
 	30:  uint8(27),
 	31:  uint8(28),
 	32:  uint8(29),
 	33:  uint8(30),
 	34:  uint8(31),
 	35:  uint8(32),
 	36:  uint8(33),
 	37:  uint8(34),
 	38:  uint8(35),
 	39:  uint8(36),
 	40:  uint8(37),
 	41:  uint8(37),
 	42:  uint8(38),
 	43:  uint8(39),
 	44:  uint8(40),
 	45:  uint8(41),
 	46:  uint8(42),
 	47:  uint8(43),
 	48:  uint8(44),
 	49:  uint8(45),
 	50:  uint8(46),
 	51:  uint8(46),
 	52:  uint8(47),
 	53:  uint8(48),
 	54:  uint8(49),
 	55:  uint8(50),
 	56:  uint8(51),
 	57:  uint8(52),
 	58:  uint8(53),
 	59:  uint8(54),
 	60:  uint8(55),
 	61:  uint8(56),
 	62:  uint8(57),
 	63:  uint8(58),
 	64:  uint8(59),
 	65:  uint8(60),
 	66:  uint8(61),
 	67:  uint8(62),
 	68:  uint8(63),
 	69:  uint8(64),
 	70:  uint8(65),
 	71:  uint8(66),
 	72:  uint8(67),
 	73:  uint8(68),
 	74:  uint8(69),
 	75:  uint8(70),
 	76:  uint8(71),
 	77:  uint8(72),
 	78:  uint8(73),
 	79:  uint8(74),
 	80:  uint8(75),
 	81:  uint8(76),
 	82:  uint8(76),
 	83:  uint8(77),
 	84:  uint8(78),
 	85:  uint8(79),
 	86:  uint8(80),
 	87:  uint8(81),
 	88:  uint8(82),
 	89:  uint8(83),
 	90:  uint8(84),
 	91:  uint8(85),
 	92:  uint8(86),
 	93:  uint8(87),
 	94:  uint8(88),
 	95:  uint8(89),
 	96:  uint8(91),
 	97:  uint8(93),
 	98:  uint8(95),
 	99:  uint8(96),
 	100: uint8(98),
 	101: uint8(100),
 	102: uint8(101),
 	103: uint8(102),
 	104: uint8(104),
 	105: uint8(106),
 	106: uint8(108),
 	107: uint8(110),
 	108: uint8(112),
 	109: uint8(114),
 	110: uint8(116),
 	111: uint8(118),
 	112: uint8(122),
 	113: uint8(124),
 	114: uint8(126),
 	115: uint8(128),
 	116: uint8(130),
 	117: uint8(132),
 	118: uint8(134),
 	119: uint8(136),
 	120: uint8(138),
 	121: uint8(140),
 	122: uint8(143),
 	123: uint8(145),
 	124: uint8(148),
 	125: uint8(151),
 	126: uint8(154),
 	127: uint8(157),
 }
 
 var kAcTable1 = [128]uint16_t{
 	0:   uint16(4),
 	1:   uint16(5),
 	2:   uint16(6),
 	3:   uint16(7),
 	4:   uint16(8),
 	5:   uint16(9),
 	6:   uint16(10),
 	7:   uint16(11),
 	8:   uint16(12),
 	9:   uint16(13),
 	10:  uint16(14),
 	11:  uint16(15),
 	12:  uint16(16),
 	13:  uint16(17),
 	14:  uint16(18),
 	15:  uint16(19),
 	16:  uint16(20),
 	17:  uint16(21),
 	18:  uint16(22),
 	19:  uint16(23),
 	20:  uint16(24),
 	21:  uint16(25),
 	22:  uint16(26),
 	23:  uint16(27),
 	24:  uint16(28),
 	25:  uint16(29),
 	26:  uint16(30),
 	27:  uint16(31),
 	28:  uint16(32),
 	29:  uint16(33),
 	30:  uint16(34),
 	31:  uint16(35),
 	32:  uint16(36),
 	33:  uint16(37),
 	34:  uint16(38),
 	35:  uint16(39),
 	36:  uint16(40),
 	37:  uint16(41),
 	38:  uint16(42),
 	39:  uint16(43),
 	40:  uint16(44),
 	41:  uint16(45),
 	42:  uint16(46),
 	43:  uint16(47),
 	44:  uint16(48),
 	45:  uint16(49),
 	46:  uint16(50),
 	47:  uint16(51),
 	48:  uint16(52),
 	49:  uint16(53),
 	50:  uint16(54),
 	51:  uint16(55),
 	52:  uint16(56),
 	53:  uint16(57),
 	54:  uint16(58),
 	55:  uint16(60),
 	56:  uint16(62),
 	57:  uint16(64),
 	58:  uint16(66),
 	59:  uint16(68),
 	60:  uint16(70),
 	61:  uint16(72),
 	62:  uint16(74),
 	63:  uint16(76),
 	64:  uint16(78),
 	65:  uint16(80),
 	66:  uint16(82),
 	67:  uint16(84),
 	68:  uint16(86),
 	69:  uint16(88),
 	70:  uint16(90),
 	71:  uint16(92),
 	72:  uint16(94),
 	73:  uint16(96),
 	74:  uint16(98),
 	75:  uint16(100),
 	76:  uint16(102),
 	77:  uint16(104),
 	78:  uint16(106),
 	79:  uint16(108),
 	80:  uint16(110),
 	81:  uint16(112),
 	82:  uint16(114),
 	83:  uint16(116),
 	84:  uint16(119),
 	85:  uint16(122),
 	86:  uint16(125),
 	87:  uint16(128),
 	88:  uint16(131),
 	89:  uint16(134),
 	90:  uint16(137),
 	91:  uint16(140),
 	92:  uint16(143),
 	93:  uint16(146),
 	94:  uint16(149),
 	95:  uint16(152),
 	96:  uint16(155),
 	97:  uint16(158),
 	98:  uint16(161),
 	99:  uint16(164),
 	100: uint16(167),
 	101: uint16(170),
 	102: uint16(173),
 	103: uint16(177),
 	104: uint16(181),
 	105: uint16(185),
 	106: uint16(189),
 	107: uint16(193),
 	108: uint16(197),
 	109: uint16(201),
 	110: uint16(205),
 	111: uint16(209),
 	112: uint16(213),
 	113: uint16(217),
 	114: uint16(221),
 	115: uint16(225),
 	116: uint16(229),
 	117: uint16(234),
 	118: uint16(239),
 	119: uint16(245),
 	120: uint16(249),
 	121: uint16(254),
 	122: uint16(259),
 	123: uint16(264),
 	124: uint16(269),
 	125: uint16(274),
 	126: uint16(279),
 	127: uint16(284),
 }
 
 var kAcTable2 = [128]uint16_t{
 	0:   uint16(8),
 	1:   uint16(8),
 	2:   uint16(9),
 	3:   uint16(10),
 	4:   uint16(12),
 	5:   uint16(13),
 	6:   uint16(15),
 	7:   uint16(17),
 	8:   uint16(18),
 	9:   uint16(20),
 	10:  uint16(21),
 	11:  uint16(23),
 	12:  uint16(24),
 	13:  uint16(26),
 	14:  uint16(27),
 	15:  uint16(29),
 	16:  uint16(31),
 	17:  uint16(32),
 	18:  uint16(34),
 	19:  uint16(35),
 	20:  uint16(37),
 	21:  uint16(38),
 	22:  uint16(40),
 	23:  uint16(41),
 	24:  uint16(43),
 	25:  uint16(44),
 	26:  uint16(46),
 	27:  uint16(48),
 	28:  uint16(49),
 	29:  uint16(51),
 	30:  uint16(52),
 	31:  uint16(54),
 	32:  uint16(55),
 	33:  uint16(57),
 	34:  uint16(58),
 	35:  uint16(60),
 	36:  uint16(62),
 	37:  uint16(63),
 	38:  uint16(65),
 	39:  uint16(66),
 	40:  uint16(68),
 	41:  uint16(69),
 	42:  uint16(71),
 	43:  uint16(72),
 	44:  uint16(74),
 	45:  uint16(75),
 	46:  uint16(77),
 	47:  uint16(79),
 	48:  uint16(80),
 	49:  uint16(82),
 	50:  uint16(83),
 	51:  uint16(85),
 	52:  uint16(86),
 	53:  uint16(88),
 	54:  uint16(89),
 	55:  uint16(93),
 	56:  uint16(96),
 	57:  uint16(99),
 	58:  uint16(102),
 	59:  uint16(105),
 	60:  uint16(108),
 	61:  uint16(111),
 	62:  uint16(114),
 	63:  uint16(117),
 	64:  uint16(120),
 	65:  uint16(124),
 	66:  uint16(127),
 	67:  uint16(130),
 	68:  uint16(133),
 	69:  uint16(136),
 	70:  uint16(139),
 	71:  uint16(142),
 	72:  uint16(145),
 	73:  uint16(148),
 	74:  uint16(151),
 	75:  uint16(155),
 	76:  uint16(158),
 	77:  uint16(161),
 	78:  uint16(164),
 	79:  uint16(167),
 	80:  uint16(170),
 	81:  uint16(173),
 	82:  uint16(176),
 	83:  uint16(179),
 	84:  uint16(184),
 	85:  uint16(189),
 	86:  uint16(193),
 	87:  uint16(198),
 	88:  uint16(203),
 	89:  uint16(207),
 	90:  uint16(212),
 	91:  uint16(217),
 	92:  uint16(221),
 	93:  uint16(226),
 	94:  uint16(230),
 	95:  uint16(235),
 	96:  uint16(240),
 	97:  uint16(244),
 	98:  uint16(249),
 	99:  uint16(254),
 	100: uint16(258),
 	101: uint16(263),
 	102: uint16(268),
 	103: uint16(274),
 	104: uint16(280),
 	105: uint16(286),
 	106: uint16(292),
 	107: uint16(299),
 	108: uint16(305),
 	109: uint16(311),
 	110: uint16(317),
 	111: uint16(323),
 	112: uint16(330),
 	113: uint16(336),
 	114: uint16(342),
 	115: uint16(348),
 	116: uint16(354),
 	117: uint16(362),
 	118: uint16(370),
 	119: uint16(379),
 	120: uint16(385),
 	121: uint16(393),
 	122: uint16(401),
 	123: uint16(409),
 	124: uint16(416),
 	125: uint16(424),
 	126: uint16(432),
 	127: uint16(440),
 }
 
 var kBiasMatrices = [3][2]uint8_t{
 	0: {
 		0: uint8(96),
 		1: uint8(110),
 	},
 	1: {
 		0: uint8(96),
 		1: uint8(108),
 	},
 	2: {
 		0: uint8(110),
 		1: uint8(115),
 	},
 }
 
 // C documentation
 //
 //	// Sharpening by (slightly) raising the hi-frequency coeffs.
 //	// Hack-ish but helpful for mid-bitrate range. Use with care.
 var kFreqSharpening = [16]uint8_t{
 	1:  uint8(30),
 	2:  uint8(60),
 	3:  uint8(90),
 	4:  uint8(30),
 	5:  uint8(60),
 	6:  uint8(90),
 	7:  uint8(90),
 	8:  uint8(60),
 	9:  uint8(90),
 	10: uint8(90),
 	11: uint8(90),
 	12: uint8(90),
 	13: uint8(90),
 	14: uint8(90),
 	15: uint8(90),
 }
 
 //------------------------------------------------------------------------------
 // Initialize quantization parameters in VP8Matrix
 
 // C documentation
 //
 //	// Returns the average quantizer
 func ExpandMatrix(tls *libc.TLS, m uintptr, type1 int32) (r int32) {
 	var bias, i, is_ac_coeff, sum int32
 	_, _, _, _ = bias, i, is_ac_coeff, sum
 	i = 0
 	for {
 		if !(i < int32(2)) {
 			break
 		}
 		is_ac_coeff = libc.BoolInt32(i > libc.Int32FromInt32(0))
 		bias = libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(uintptr(unsafe.Pointer(&kBiasMatrices)) + uintptr(type1)*2 + uintptr(is_ac_coeff))))
 		**(**uint16_t)(__ccgo_up(m + 32 + uintptr(i)*2)) = libc.Uint16FromInt32(libc.Int32FromInt32(1) << libc.Int32FromInt32(QFIX) / libc.Int32FromUint16(**(**uint16_t)(__ccgo_up(m + uintptr(i)*2))))
 		**(**uint32_t)(__ccgo_up(m + 64 + uintptr(i)*4)) = libc.Uint32FromInt32(bias << (libc.Int32FromInt32(QFIX) - libc.Int32FromInt32(8)))
 		// zthresh is the exact value such that QUANTDIV(coeff, iQ, B) is:
 		//   * zero if coeff <= zthresh
 		//   * non-zero if coeff > zthresh
 		**(**uint32_t)(__ccgo_up(m + 128 + uintptr(i)*4)) = (libc.Uint32FromInt32(libc.Int32FromInt32(1)<<libc.Int32FromInt32(QFIX)-libc.Int32FromInt32(1)) - **(**uint32_t)(__ccgo_up(m + 64 + uintptr(i)*4))) / uint32(**(**uint16_t)(__ccgo_up(m + 32 + uintptr(i)*2)))
 		goto _1
 	_1:
 		;
 		i = i + 1
 	}
 	i = int32(2)
 	for {
 		if !(i < int32(16)) {
 			break
 		}
 		**(**uint16_t)(__ccgo_up(m + uintptr(i)*2)) = **(**uint16_t)(__ccgo_up(m + 1*2))
 		**(**uint16_t)(__ccgo_up(m + 32 + uintptr(i)*2)) = **(**uint16_t)(__ccgo_up(m + 32 + 1*2))
 		**(**uint32_t)(__ccgo_up(m + 64 + uintptr(i)*4)) = **(**uint32_t)(__ccgo_up(m + 64 + 1*4))
 		**(**uint32_t)(__ccgo_up(m + 128 + uintptr(i)*4)) = **(**uint32_t)(__ccgo_up(m + 128 + 1*4))
 		goto _2
 	_2:
 		;
 		i = i + 1
 	}
 	sum = 0
 	i = libc.Int32FromInt32(0)
 	for {
 		if !(i < int32(16)) {
 			break
 		}
 		if type1 == 0 { // we only use sharpening for AC luma coeffs
 			**(**uint16_t)(__ccgo_up(m + 192 + uintptr(i)*2)) = libc.Uint16FromInt32(libc.Int32FromUint8(kFreqSharpening[i]) * libc.Int32FromUint16(**(**uint16_t)(__ccgo_up(m + uintptr(i)*2))) >> int32(SHARPEN_BITS))
 		} else {
 			**(**uint16_t)(__ccgo_up(m + 192 + uintptr(i)*2)) = uint16(0)
 		}
 		sum = sum + libc.Int32FromUint16(**(**uint16_t)(__ccgo_up(m + uintptr(i)*2)))
 		goto _3
 	_3:
 		;
 		i = i + 1
 	}
 	return (sum + int32(8)) >> int32(4)
 }
 
 func CheckLambdaValue(tls *libc.TLS, v uintptr) {
 	if **(**int32)(__ccgo_up(v)) < int32(1) {
 		**(**int32)(__ccgo_up(v)) = int32(1)
 	}
 }
 
 func SetupMatrices(tls *libc.TLS, enc uintptr) {
 	var i, num_segments, q, q_i16, q_i4, q_uv, tlambda_scale, v1 int32
 	var m uintptr
 	_, _, _, _, _, _, _, _, _ = i, m, num_segments, q, q_i16, q_i4, q_uv, tlambda_scale, v1
 	if (*VP8Encoder)(unsafe.Pointer(enc)).Fmethod >= int32(4) {
 		v1 = (*WebPConfig)(unsafe.Pointer((*VP8Encoder)(unsafe.Pointer(enc)).Fconfig)).Fsns_strength
 	} else {
 		v1 = 0
 	}
 	tlambda_scale = v1
 	num_segments = (*VP8Encoder)(unsafe.Pointer(enc)).Fsegment_hdr.Fnum_segments
 	i = 0
 	for {
 		if !(i < num_segments) {
 			break
 		}
 		m = enc + 608 + uintptr(i)*744
 		q = (*VP8SegmentInfo)(unsafe.Pointer(m)).Fquant
 		**(**uint16_t)(__ccgo_up(m)) = uint16(kDcTable1[clip2(tls, q+(*VP8Encoder)(unsafe.Pointer(enc)).Fdq_y1_dc, 0, int32(127))])
 		**(**uint16_t)(__ccgo_up(m + 1*2)) = kAcTable1[clip2(tls, q, 0, int32(127))]
 		**(**uint16_t)(__ccgo_up(m + 224)) = libc.Uint16FromInt32(libc.Int32FromUint8(kDcTable1[clip2(tls, q+(*VP8Encoder)(unsafe.Pointer(enc)).Fdq_y2_dc, 0, int32(127))]) * int32(2))
 		**(**uint16_t)(__ccgo_up(m + 224 + 1*2)) = kAcTable2[clip2(tls, q+(*VP8Encoder)(unsafe.Pointer(enc)).Fdq_y2_ac, 0, int32(127))]
 		**(**uint16_t)(__ccgo_up(m + 448)) = uint16(kDcTable1[clip2(tls, q+(*VP8Encoder)(unsafe.Pointer(enc)).Fdq_uv_dc, 0, int32(117))])
 		**(**uint16_t)(__ccgo_up(m + 448 + 1*2)) = kAcTable1[clip2(tls, q+(*VP8Encoder)(unsafe.Pointer(enc)).Fdq_uv_ac, 0, int32(127))]
 		q_i4 = ExpandMatrix(tls, m, 0)
 		q_i16 = ExpandMatrix(tls, m+224, int32(1))
 		q_uv = ExpandMatrix(tls, m+448, int32(2))
 		(*VP8SegmentInfo)(unsafe.Pointer(m)).Flambda_i4 = int32(3) * q_i4 * q_i4 >> int32(7)
 		(*VP8SegmentInfo)(unsafe.Pointer(m)).Flambda_i16 = int32(3) * q_i16 * q_i16
 		(*VP8SegmentInfo)(unsafe.Pointer(m)).Flambda_uv = int32(3) * q_uv * q_uv >> int32(6)
 		(*VP8SegmentInfo)(unsafe.Pointer(m)).Flambda_mode = int32(1) * q_i4 * q_i4 >> int32(7)
 		(*VP8SegmentInfo)(unsafe.Pointer(m)).Flambda_trellis_i4 = int32(7) * q_i4 * q_i4 >> int32(3)
 		(*VP8SegmentInfo)(unsafe.Pointer(m)).Flambda_trellis_i16 = q_i16 * q_i16 >> int32(2)
 		(*VP8SegmentInfo)(unsafe.Pointer(m)).Flambda_trellis_uv = q_uv * q_uv << int32(1)
 		(*VP8SegmentInfo)(unsafe.Pointer(m)).Ftlambda = tlambda_scale * q_i4 >> int32(5)
 		// none of these constants should be < 1
 		CheckLambdaValue(tls, m+700)
 		CheckLambdaValue(tls, m+696)
 		CheckLambdaValue(tls, m+704)
 		CheckLambdaValue(tls, m+708)
 		CheckLambdaValue(tls, m+724)
 		CheckLambdaValue(tls, m+720)
 		CheckLambdaValue(tls, m+728)
 		CheckLambdaValue(tls, m+716)
 		(*VP8SegmentInfo)(unsafe.Pointer(m)).Fmin_disto = int32(20) * libc.Int32FromUint16(**(**uint16_t)(__ccgo_up(m))) // quantization-aware min disto
 		(*VP8SegmentInfo)(unsafe.Pointer(m)).Fmax_edge = 0
 		(*VP8SegmentInfo)(unsafe.Pointer(m)).Fi4_penalty = int64(int32(1000) * q_i4 * q_i4)
 		goto _2
 	_2:
 		;
 		i = i + 1
 	}
 }
 
 //------------------------------------------------------------------------------
 // Initialize filtering parameters
 
 // Very small filter-strength values have close to no visual effect. So we can
 // save a little decoding-CPU by turning filtering off for these.
 
 func SetupFilterStrength(tls *libc.TLS, enc uintptr) {
 	var base_strength, f, i, level0, qstep, v2, v3 int32
 	var m uintptr
 	_, _, _, _, _, _, _, _ = base_strength, f, i, level0, m, qstep, v2, v3
 	// level0 is in [0..500]. Using '-f 50' as filter_strength is mid-filtering.
 	level0 = int32(5) * (*WebPConfig)(unsafe.Pointer((*VP8Encoder)(unsafe.Pointer(enc)).Fconfig)).Ffilter_strength
 	i = 0
 	for {
 		if !(i < int32(NUM_MB_SEGMENTS)) {
 			break
 		}
 		m = enc + 608 + uintptr(i)*744
 		// We focus on the quantization of AC coeffs.
 		qstep = libc.Int32FromUint16(kAcTable1[clip2(tls, (*VP8SegmentInfo)(unsafe.Pointer(m)).Fquant, 0, int32(127))]) >> int32(2)
 		base_strength = VP8FilterStrengthFromDelta(tls, (*VP8Encoder)(unsafe.Pointer(enc)).Ffilter_hdr.Fsharpness, qstep)
 		// Segments with lower complexity ('beta') will be less filtered.
 		f = base_strength * level0 / (int32(256) + (*VP8SegmentInfo)(unsafe.Pointer(m)).Fbeta)
 		if f < int32(FSTRENGTH_CUTOFF) {
 			v2 = 0
 		} else {
 			if f > int32(63) {
 				v3 = int32(63)
 			} else {
 				v3 = f
 			}
 			v2 = v3
 		}
 		(*VP8SegmentInfo)(unsafe.Pointer(m)).Ffstrength = v2
 		goto _1
 	_1:
 		;
 		i = i + 1
 	}
 	// We record the initial strength (mainly for the case of 1-segment only).
 	(*VP8Encoder)(unsafe.Pointer(enc)).Ffilter_hdr.Flevel = (**(**VP8SegmentInfo)(__ccgo_up(enc + 608))).Ffstrength
 	(*VP8Encoder)(unsafe.Pointer(enc)).Ffilter_hdr.Fsimple = libc.BoolInt32((*WebPConfig)(unsafe.Pointer((*VP8Encoder)(unsafe.Pointer(enc)).Fconfig)).Ffilter_type == 0)
 	(*VP8Encoder)(unsafe.Pointer(enc)).Ffilter_hdr.Fsharpness = (*WebPConfig)(unsafe.Pointer((*VP8Encoder)(unsafe.Pointer(enc)).Fconfig)).Ffilter_sharpness
 }
 
 //------------------------------------------------------------------------------
 
 // Note: if you change the values below, remember that the max range
 // allowed by the syntax for DQ_UV is [-16,16].
 
 // C documentation
 //
 //	// We want to emulate jpeg-like behaviour where the expected "good" quality
 //	// is around q=75. Internally, our "good" middle is around c=50. So we
 //	// map accordingly using linear piece-wise function
 func QualityToCompression(tls *libc.TLS, c float64) (r float64) {
 	var linear_c, v, v1 float64
 	_, _, _ = linear_c, v, v1
 	if c < float64(0.75) {
 		v1 = float64(c * (libc.Float64FromFloat64(2) / libc.Float64FromFloat64(3)))
 	} else {
 		v1 = float64(float64(2)*c) - float64(1)
 	}
 	linear_c = v1
 	// The file size roughly scales as pow(quantizer, 3.). Actually, the
 	// exponent is somewhere between 2.8 and 3.2, but we're mostly interested
 	// in the mid-quant range. So we scale the compressibility inversely to
 	// this power-law: quant ~= compression ^ 1/3. This law holds well for
 	// low quant. Finer modeling for high-quant would make use of kAcTable[]
 	// more explicitly.
 	v = libc.Xpow(tls, linear_c, libc.Float64FromInt32(1)/libc.Float64FromFloat64(3))
 	return v
 }
 
 func QualityToJPEGCompression(tls *libc.TLS, c float64, alpha float64) (r float64) {
 	var amax, amin, exp_max, exp_min, expn, slope, v, v1, v2 float64
 	_, _, _, _, _, _, _, _, _ = amax, amin, exp_max, exp_min, expn, slope, v, v1, v2
 	// We map the complexity 'alpha' and quality setting 'c' to a compression
 	// exponent empirically matched to the compression curve of libjpeg6b.
 	// On average, the WebP output size will be roughly similar to that of a
 	// JPEG file compressed with same quality factor.
 	amin = float64(0.3)
 	amax = float64(0.85)
 	exp_min = float64(0.4)
 	exp_max = float64(0.9)
 	slope = (exp_min - exp_max) / (amax - amin)
 	if alpha > amax {
 		v1 = exp_min
 	} else {
 		if alpha < amin {
 			v2 = exp_max
 		} else {
 			v2 = exp_max + float64(slope*(alpha-amin))
 		}
 		v1 = v2
 	}
 	// Linearly interpolate 'expn' from exp_min to exp_max
 	// in the [amin, amax] range.
 	expn = v1
 	v = libc.Xpow(tls, c, expn)
 	return v
 }
 
 func SegmentsAreEquivalent(tls *libc.TLS, S1 uintptr, S2 uintptr) (r int32) {
 	return libc.BoolInt32((*VP8SegmentInfo)(unsafe.Pointer(S1)).Fquant == (*VP8SegmentInfo)(unsafe.Pointer(S2)).Fquant && (*VP8SegmentInfo)(unsafe.Pointer(S1)).Ffstrength == (*VP8SegmentInfo)(unsafe.Pointer(S2)).Ffstrength)
 }
 
 func SimplifySegments(tls *libc.TLS, enc uintptr) {
 	var S1, S2 uintptr
 	var found, i, num_final_segments, num_segments, s1, s2, v1 int32
 	var map1 [4]int32
 	_, _, _, _, _, _, _, _, _, _ = S1, S2, found, i, map1, num_final_segments, num_segments, s1, s2, v1
 	map1 = [4]int32{
 		1: int32(1),
 		2: int32(2),
 		3: int32(3),
 	}
 	if (*VP8Encoder)(unsafe.Pointer(enc)).Fsegment_hdr.Fnum_segments < int32(NUM_MB_SEGMENTS) {
 		v1 = (*VP8Encoder)(unsafe.Pointer(enc)).Fsegment_hdr.Fnum_segments
 	} else {
 		v1 = int32(NUM_MB_SEGMENTS)
 	}
 	// 'num_segments' is previously validated and <= NUM_MB_SEGMENTS, but an
 	// explicit check is needed to avoid a spurious warning about 'i' exceeding
 	// array bounds of 'dqm' with some compilers (noticed with gcc-4.9).
 	num_segments = v1
 	num_final_segments = int32(1)
 	s1 = int32(1)
 	for {
 		if !(s1 < num_segments) {
 			break
 		} // find similar segments
 		S1 = enc + 608 + uintptr(s1)*744
 		found = 0
 		// check if we already have similar segment
 		s2 = 0
 		for {
 			if !(s2 < num_final_segments) {
 				break
 			}
 			S2 = enc + 608 + uintptr(s2)*744
 			if SegmentsAreEquivalent(tls, S1, S2) != 0 {
 				found = int32(1)
 				break
 			}
 			goto _3
 		_3:
 			;
 			s2 = s2 + 1
 		}
 		map1[s1] = s2
 		if !(found != 0) {
 			if num_final_segments != s1 {
 				**(**VP8SegmentInfo)(__ccgo_up(enc + 608 + uintptr(num_final_segments)*744)) = **(**VP8SegmentInfo)(__ccgo_up(enc + 608 + uintptr(s1)*744))
 			}
 			num_final_segments = num_final_segments + 1
 		}
 		goto _2
 	_2:
 		;
 		s1 = s1 + 1
 	}
 	if num_final_segments < num_segments { // Remap
 		i = (*VP8Encoder)(unsafe.Pointer(enc)).Fmb_w * (*VP8Encoder)(unsafe.Pointer(enc)).Fmb_h
 		for {
 			v1 = i
 			i = i - 1
 			if !(v1 > 0) {
 				break
 			}
 			libc.SetBitFieldPtr8Uint32((*VP8Encoder)(unsafe.Pointer(enc)).Fmb_info+uintptr(i)*4+0, libc.Uint32FromInt32(map1[int32(uint32(*(*uint8)(unsafe.Pointer((*VP8Encoder)(unsafe.Pointer(enc)).Fmb_info + uintptr(i)*4 + 0))&0x60>>5))]), 5, 0x60)
 		}
 		(*VP8Encoder)(unsafe.Pointer(enc)).Fsegment_hdr.Fnum_segments = num_final_segments
 		// Replicate the trailing segment infos (it's mostly cosmetics)
 		i = num_final_segments
 		for {
 			if !(i < num_segments) {
 				break
 			}
 			**(**VP8SegmentInfo)(__ccgo_up(enc + 608 + uintptr(i)*744)) = **(**VP8SegmentInfo)(__ccgo_up(enc + 608 + uintptr(num_final_segments-int32(1))*744))
 			goto _5
 		_5:
 			;
 			i = i + 1
 		}
 	}
 }
 
 func VP8SetSegmentParams(tls *libc.TLS, enc uintptr, quality float32) {
 	var Q, amp, c, c_base, expn, v1 float64
 	var dq_uv_ac, dq_uv_dc, i, num_segments, q int32
 	_, _, _, _, _, _, _, _, _, _, _ = Q, amp, c, c_base, dq_uv_ac, dq_uv_dc, expn, i, num_segments, q, v1
 	num_segments = (*VP8Encoder)(unsafe.Pointer(enc)).Fsegment_hdr.Fnum_segments
 	amp = float64(float64(SNS_TO_DQ)*float64((*WebPConfig)(unsafe.Pointer((*VP8Encoder)(unsafe.Pointer(enc)).Fconfig)).Fsns_strength)) / float64(100) / float64(128)
 	Q = float64(quality) / float64(100)
 	if (*WebPConfig)(unsafe.Pointer((*VP8Encoder)(unsafe.Pointer(enc)).Fconfig)).Femulate_jpeg_size != 0 {
 		v1 = QualityToJPEGCompression(tls, Q, float64((*VP8Encoder)(unsafe.Pointer(enc)).Falpha)/float64(255))
 	} else {
 		v1 = QualityToCompression(tls, Q)
 	}
 	c_base = v1
 	i = 0
 	for {
 		if !(i < num_segments) {
 			break
 		}
 		// We modulate the base coefficient to accommodate for the quantization
 		// susceptibility and allow denser segments to be quantized more.
 		expn = float64(1) - float64(amp*float64((**(**VP8SegmentInfo)(__ccgo_up(enc + 608 + uintptr(i)*744))).Falpha))
 		c = libc.Xpow(tls, c_base, expn)
 		q = int32(float64(libc.Float64FromFloat64(127) * (libc.Float64FromFloat64(1) - c)))
 		(**(**VP8SegmentInfo)(__ccgo_up(enc + 608 + uintptr(i)*744))).Fquant = clip2(tls, q, 0, int32(127))
 		goto _2
 	_2:
 		;
 		i = i + 1
 	}
 	// purely indicative in the bitstream (except for the 1-segment case)
 	(*VP8Encoder)(unsafe.Pointer(enc)).Fbase_quant = (**(**VP8SegmentInfo)(__ccgo_up(enc + 608))).Fquant
 	// fill-in values for the unused segments (required by the syntax)
 	i = num_segments
 	for {
 		if !(i < int32(NUM_MB_SEGMENTS)) {
 			break
 		}
 		(**(**VP8SegmentInfo)(__ccgo_up(enc + 608 + uintptr(i)*744))).Fquant = (*VP8Encoder)(unsafe.Pointer(enc)).Fbase_quant
 		goto _3
 	_3:
 		;
 		i = i + 1
 	}
 	// uv_alpha is normally spread around ~60. The useful range is
 	// typically ~30 (quite bad) to ~100 (ok to decimate UV more).
 	// We map it to the safe maximal range of MAX/MIN_DQ_UV for dq_uv.
 	dq_uv_ac = ((*VP8Encoder)(unsafe.Pointer(enc)).Fuv_alpha - int32(MID_ALPHA)) * (libc.Int32FromInt32(MAX_DQ_UV) - -libc.Int32FromInt32(4)) / (libc.Int32FromInt32(MAX_ALPHA1) - libc.Int32FromInt32(MIN_ALPHA))
 	// we rescale by the user-defined strength of adaptation
 	dq_uv_ac = dq_uv_ac * (*WebPConfig)(unsafe.Pointer((*VP8Encoder)(unsafe.Pointer(enc)).Fconfig)).Fsns_strength / int32(100)
 	// and make it safe.
 	dq_uv_ac = clip2(tls, dq_uv_ac, -int32(4), int32(MAX_DQ_UV))
 	// We also boost the dc-uv-quant a little, based on sns-strength, since
 	// U/V channels are quite more reactive to high quants (flat DC-blocks
 	// tend to appear, and are unpleasant).
 	dq_uv_dc = -int32(4) * (*WebPConfig)(unsafe.Pointer((*VP8Encoder)(unsafe.Pointer(enc)).Fconfig)).Fsns_strength / int32(100)
 	dq_uv_dc = clip2(tls, dq_uv_dc, -int32(15), int32(15)) // 4bit-signed max allowed
 	(*VP8Encoder)(unsafe.Pointer(enc)).Fdq_y1_dc = 0       // TODO(skal): dq-lum
 	(*VP8Encoder)(unsafe.Pointer(enc)).Fdq_y2_dc = 0
 	(*VP8Encoder)(unsafe.Pointer(enc)).Fdq_y2_ac = 0
 	(*VP8Encoder)(unsafe.Pointer(enc)).Fdq_uv_dc = dq_uv_dc
 	(*VP8Encoder)(unsafe.Pointer(enc)).Fdq_uv_ac = dq_uv_ac
 	SetupFilterStrength(tls, enc) // initialize segments' filtering, eventually
 	if num_segments > int32(1) {
 		SimplifySegments(tls, enc)
 	}
 	SetupMatrices(tls, enc) // finalize quantization matrices
 }
 
 // C documentation
 //
 //	// Must be indexed using {B_DC_PRED -> B_HU_PRED} as index
 var VP8I4ModeOffsets = [10]uint16_t{
 	0: libc.Uint16FromInt32(libc.Int32FromInt32(3)*libc.Int32FromInt32(16)*libc.Int32FromInt32(BPS) + libc.Int32FromInt32(0)),
 	1: libc.Uint16FromInt32(libc.Int32FromInt32(3)*libc.Int32FromInt32(16)*libc.Int32FromInt32(BPS) + libc.Int32FromInt32(0) + libc.Int32FromInt32(4)),
 	2: libc.Uint16FromInt32(libc.Int32FromInt32(3)*libc.Int32FromInt32(16)*libc.Int32FromInt32(BPS) + libc.Int32FromInt32(0) + libc.Int32FromInt32(8)),
 	3: libc.Uint16FromInt32(libc.Int32FromInt32(3)*libc.Int32FromInt32(16)*libc.Int32FromInt32(BPS) + libc.Int32FromInt32(0) + libc.Int32FromInt32(12)),
 	4: libc.Uint16FromInt32(libc.Int32FromInt32(3)*libc.Int32FromInt32(16)*libc.Int32FromInt32(BPS) + libc.Int32FromInt32(0) + libc.Int32FromInt32(16)),
 	5: libc.Uint16FromInt32(libc.Int32FromInt32(3)*libc.Int32FromInt32(16)*libc.Int32FromInt32(BPS) + libc.Int32FromInt32(0) + libc.Int32FromInt32(20)),
 	6: libc.Uint16FromInt32(libc.Int32FromInt32(3)*libc.Int32FromInt32(16)*libc.Int32FromInt32(BPS) + libc.Int32FromInt32(0) + libc.Int32FromInt32(24)),
 	7: libc.Uint16FromInt32(libc.Int32FromInt32(3)*libc.Int32FromInt32(16)*libc.Int32FromInt32(BPS) + libc.Int32FromInt32(0) + libc.Int32FromInt32(28)),
 	8: libc.Uint16FromInt32(libc.Int32FromInt32(3)*libc.Int32FromInt32(16)*libc.Int32FromInt32(BPS) + libc.Int32FromInt32(4)*libc.Int32FromInt32(BPS)),
 	9: libc.Uint16FromInt32(libc.Int32FromInt32(3)*libc.Int32FromInt32(16)*libc.Int32FromInt32(BPS) + libc.Int32FromInt32(4)*libc.Int32FromInt32(BPS) + libc.Int32FromInt32(4)),
 }
 
 func VP8MakeLuma16Preds(tls *libc.TLS, it uintptr) {
 	var left, top, v1, v2 uintptr
 	_, _, _, _ = left, top, v1, v2
 	if (*VP8EncIterator)(unsafe.Pointer(it)).Fx != 0 {
 		v1 = (*VP8EncIterator)(unsafe.Pointer(it)).Fy_left
 	} else {
 		v1 = libc.UintptrFromInt32(0)
 	}
 	left = v1
 	if (*VP8EncIterator)(unsafe.Pointer(it)).Fy != 0 {
 		v2 = (*VP8EncIterator)(unsafe.Pointer(it)).Fy_top
 	} else {
 		v2 = libc.UintptrFromInt32(0)
 	}
 	top = v2
 	(*(*func(*libc.TLS, uintptr, uintptr, uintptr))(unsafe.Pointer(&struct{ uintptr }{VP8EncPredLuma16})))(tls, (*VP8EncIterator)(unsafe.Pointer(it)).Fyuv_p, left, top)
 }
 
 func VP8MakeChroma8Preds(tls *libc.TLS, it uintptr) {
 	var left, top, v1, v2 uintptr
 	_, _, _, _ = left, top, v1, v2
 	if (*VP8EncIterator)(unsafe.Pointer(it)).Fx != 0 {
 		v1 = (*VP8EncIterator)(unsafe.Pointer(it)).Fu_left
 	} else {
 		v1 = libc.UintptrFromInt32(0)
 	}
 	left = v1
 	if (*VP8EncIterator)(unsafe.Pointer(it)).Fy != 0 {
 		v2 = (*VP8EncIterator)(unsafe.Pointer(it)).Fuv_top
 	} else {
 		v2 = libc.UintptrFromInt32(0)
 	}
 	top = v2
 	(*(*func(*libc.TLS, uintptr, uintptr, uintptr))(unsafe.Pointer(&struct{ uintptr }{VP8EncPredChroma8})))(tls, (*VP8EncIterator)(unsafe.Pointer(it)).Fyuv_p, left, top)
 }
 
 // C documentation
 //
 //	// Form all the ten Intra4x4 predictions in the 'yuv_p' cache
 //	// for the 4x4 block it->i4
 func MakeIntra4Preds(tls *libc.TLS, it uintptr) {
 	(*(*func(*libc.TLS, uintptr, uintptr))(unsafe.Pointer(&struct{ uintptr }{VP8EncPredLuma4})))(tls, (*VP8EncIterator)(unsafe.Pointer(it)).Fyuv_p, (*VP8EncIterator)(unsafe.Pointer(it)).Fi4_top)
 }
 
 var VP8ScanUV = [8]uint16_t{
 	1: libc.Uint16FromInt32(libc.Int32FromInt32(4) + libc.Int32FromInt32(0)*libc.Int32FromInt32(BPS)),
 	2: libc.Uint16FromInt32(libc.Int32FromInt32(0) + libc.Int32FromInt32(4)*libc.Int32FromInt32(BPS)),
 	3: libc.Uint16FromInt32(libc.Int32FromInt32(4) + libc.Int32FromInt32(4)*libc.Int32FromInt32(BPS)),
 	4: libc.Uint16FromInt32(libc.Int32FromInt32(8) + libc.Int32FromInt32(0)*libc.Int32FromInt32(BPS)),
 	5: libc.Uint16FromInt32(libc.Int32FromInt32(12) + libc.Int32FromInt32(0)*libc.Int32FromInt32(BPS)),
 	6: libc.Uint16FromInt32(libc.Int32FromInt32(8) + libc.Int32FromInt32(4)*libc.Int32FromInt32(BPS)),
 	7: libc.Uint16FromInt32(libc.Int32FromInt32(12) + libc.Int32FromInt32(4)*libc.Int32FromInt32(BPS)),
 }
 
 //------------------------------------------------------------------------------
 // Distortion measurement
 
 var kWeightY = [16]uint16_t{
 	0:  uint16(38),
 	1:  uint16(32),
 	2:  uint16(20),
 	3:  uint16(9),
 	4:  uint16(32),
 	5:  uint16(28),
 	6:  uint16(17),
 	7:  uint16(7),
 	8:  uint16(20),
 	9:  uint16(17),
 	10: uint16(10),
 	11: uint16(4),
 	12: uint16(9),
 	13: uint16(7),
 	14: uint16(4),
 	15: uint16(2),
 }
 
 var kWeightTrellis = [16]uint16_t{
 	0:  uint16(30),
 	1:  uint16(27),
 	2:  uint16(19),
 	3:  uint16(11),
 	4:  uint16(27),
 	5:  uint16(24),
 	6:  uint16(17),
 	7:  uint16(10),
 	8:  uint16(19),
 	9:  uint16(17),
 	10: uint16(12),
 	11: uint16(8),
 	12: uint16(11),
 	13: uint16(10),
 	14: uint16(8),
 	15: uint16(6),
 }
 
 // C documentation
 //
 //	// Init/Copy the common fields in score.
 func InitScore(tls *libc.TLS, rd uintptr) {
 	(*VP8ModeScore)(unsafe.Pointer(rd)).FD = 0
 	(*VP8ModeScore)(unsafe.Pointer(rd)).FSD = 0
 	(*VP8ModeScore)(unsafe.Pointer(rd)).FR = 0
 	(*VP8ModeScore)(unsafe.Pointer(rd)).FH = 0
 	(*VP8ModeScore)(unsafe.Pointer(rd)).Fnz = uint32(0)
 	(*VP8ModeScore)(unsafe.Pointer(rd)).Fscore = libc.Int64FromInt64(0x7fffffffffffff)
 }
 
 func CopyScore(tls *libc.TLS, dst uintptr, src uintptr) {
 	(*VP8ModeScore)(unsafe.Pointer(dst)).FD = (*VP8ModeScore)(unsafe.Pointer(src)).FD
 	(*VP8ModeScore)(unsafe.Pointer(dst)).FSD = (*VP8ModeScore)(unsafe.Pointer(src)).FSD
 	(*VP8ModeScore)(unsafe.Pointer(dst)).FR = (*VP8ModeScore)(unsafe.Pointer(src)).FR
 	(*VP8ModeScore)(unsafe.Pointer(dst)).FH = (*VP8ModeScore)(unsafe.Pointer(src)).FH
 	(*VP8ModeScore)(unsafe.Pointer(dst)).Fnz = (*VP8ModeScore)(unsafe.Pointer(src)).Fnz // note that nz is not accumulated, but just copied.
 	(*VP8ModeScore)(unsafe.Pointer(dst)).Fscore = (*VP8ModeScore)(unsafe.Pointer(src)).Fscore
 }
 
 func AddScore(tls *libc.TLS, dst uintptr, src uintptr) {
 	**(**score_t)(__ccgo_up(dst)) += (*VP8ModeScore)(unsafe.Pointer(src)).FD
 	**(**score_t)(__ccgo_up(dst + 8)) += (*VP8ModeScore)(unsafe.Pointer(src)).FSD
 	**(**score_t)(__ccgo_up(dst + 24)) += (*VP8ModeScore)(unsafe.Pointer(src)).FR
 	**(**score_t)(__ccgo_up(dst + 16)) += (*VP8ModeScore)(unsafe.Pointer(src)).FH
 	**(**uint32_t)(__ccgo_up(dst + 864)) |= (*VP8ModeScore)(unsafe.Pointer(src)).Fnz // here, new nz bits are accumulated.
 	**(**score_t)(__ccgo_up(dst + 32)) += (*VP8ModeScore)(unsafe.Pointer(src)).Fscore
 }
 
 //------------------------------------------------------------------------------
 // Performs trellis-optimized quantization.
 
 // C documentation
 //
 //	// Trellis node
 type Node = struct {
 	Fprev  int8_t
 	Fsign  int8_t
 	Flevel int16_t
 }
 
 // C documentation
 //
 //	// Score state
 type ScoreState = struct {
 	Fscore score_t
 	Fcosts uintptr
 }
 
 // If a coefficient was quantized to a value Q (using a neutral bias),
 // we test all alternate possibilities between [Q-MIN_DELTA, Q+MAX_DELTA]
 // We don't test negative values though.
 
 func SetRDScore(tls *libc.TLS, lambda int32, rd uintptr) {
 	(*VP8ModeScore)(unsafe.Pointer(rd)).Fscore = ((*VP8ModeScore)(unsafe.Pointer(rd)).FR+(*VP8ModeScore)(unsafe.Pointer(rd)).FH)*int64(lambda) + int64(RD_DISTO_MULT)*((*VP8ModeScore)(unsafe.Pointer(rd)).FD+(*VP8ModeScore)(unsafe.Pointer(rd)).FSD)
 }
 
 func RDScoreTrellis(tls *libc.TLS, lambda int32, rate score_t, distortion score_t) (r score_t) {
 	return rate*int64(lambda) + int64(RD_DISTO_MULT)*distortion
 }
 
 const TYPE_I16_AC = 0
 const TYPE_I16_DC = 1
 const TYPE_CHROMA_A = 2
 const TYPE_I4_AC = 3
 
 func TrellisQuantizeBlock(tls *libc.TLS, enc uintptr, in uintptr, out uintptr, ctx0 int32, coeff_type int32, mtx uintptr, lambda int32) (r int32) {
 	bp := tls.Alloc(192)
 	defer tls.Free(192)
 	var B1, Q, coeff0, iQ1 uint32_t
 	var band, best_node, best_prev, ctx, delta_error, err, first, j, j1, j2, last, last_proba, level0, level1, m, n1, new_error, nz, p, sign, thresh, thresh_level, v1, v4, v6 int32
 	var base_score, best_cur_score, best_score, cost, cost1, last_pos_cost, last_pos_score, rate, score score_t
 	var best_path [3]int32
 	var costs CostArrayPtr
 	var cur, node, probas, ss_cur, ss_prev, tmp uintptr
 	var v3 uint8_t
 	var _ /* nodes at bp+0 */ [16][2]Node
 	var _ /* score_states at bp+128 */ [2][2]ScoreState
 	_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = B1, Q, band, base_score, best_cur_score, best_node, best_path, best_prev, best_score, coeff0, cost, cost1, costs, ctx, cur, delta_error, err, first, iQ1, j, j1, j2, last, last_pos_cost, last_pos_score, last_proba, level0, level1, m, n1, new_error, node, nz, p, probas, rate, score, sign, ss_cur, ss_prev, thresh, thresh_level, tmp, v1, v3, v4, v6
 	probas = enc + 3616 + 4 + uintptr(coeff_type)*264
 	costs = enc + 3616 + 18344 + uintptr(coeff_type)*384
 	if coeff_type == int32(TYPE_I16_AC) {
 		v1 = int32(1)
 	} else {
 		v1 = 0
 	}
 	first = v1
 	ss_cur = bp + 128 + uintptr(libc.Int32FromInt32(MIN_DELTA)+libc.Int32FromInt32(MIN_DELTA))*16
 	ss_prev = bp + 128 + 1*32 + uintptr(libc.Int32FromInt32(MIN_DELTA)+libc.Int32FromInt32(MIN_DELTA))*16
 	best_path = [3]int32{
 		0: -int32(1),
 		1: -int32(1),
 		2: -int32(1),
 	}
 	thresh = libc.Int32FromUint16(**(**uint16_t)(__ccgo_up(mtx + 1*2))) * libc.Int32FromUint16(**(**uint16_t)(__ccgo_up(mtx + 1*2))) / int32(4)
 	last_proba = libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(probas + uintptr(VP8EncBands[first])*33 + uintptr(ctx0)*11)))
 	// compute the position of the last interesting coefficient
 	last = first - int32(1)
 	n1 = int32(15)
 	for {
 		if !(n1 >= first) {
 			break
 		}
 		j = libc.Int32FromUint8(kZigzag1[n1])
 		err = int32(**(**int16_t)(__ccgo_up(in + uintptr(j)*2))) * int32(**(**int16_t)(__ccgo_up(in + uintptr(j)*2)))
 		if err > thresh {
 			last = n1
 			break
 		}
 		goto _2
 	_2:
 		;
 		n1 = n1 - 1
 	}
 	// we don't need to go inspect up to n = 16 coeffs. We can just go up
 	// to last + 1 (inclusive) without losing much.
 	if last < int32(15) {
 		last = last + 1
 	}
 	// compute 'skip' score. This is the max score one can do.
 	v3 = libc.Uint8FromInt32(last_proba)
 	if !(0 != 0) {
 		v4 = libc.Int32FromUint16(VP8EntropyCost[v3])
 	} else {
 		v4 = libc.Int32FromUint16(VP8EntropyCost[int32(255)-libc.Int32FromUint8(v3)])
 	}
 	v1 = v4
 	goto _5
 _5:
 	cost = int64(v1)
 	best_score = RDScoreTrellis(tls, lambda, cost, 0)
 	// initialize source node.
 	m = -MIN_DELTA
 	for {
 		if !(m <= int32(MAX_DELTA)) {
 			break
 		}
 		if ctx0 == 0 {
 			v3 = libc.Uint8FromInt32(last_proba)
 			if !(int32(1) != 0) {
 				v6 = libc.Int32FromUint16(VP8EntropyCost[v3])
 			} else {
 				v6 = libc.Int32FromUint16(VP8EntropyCost[int32(255)-libc.Int32FromUint8(v3)])
 			}
 			v4 = v6
 			goto _11
 		_11:
 			v1 = v4
 		} else {
 			v1 = 0
 		}
 		rate = int64(v1)
 		(**(**ScoreState)(__ccgo_up(ss_cur + uintptr(m)*16))).Fscore = RDScoreTrellis(tls, lambda, rate, 0)
 		(**(**ScoreState)(__ccgo_up(ss_cur + uintptr(m)*16))).Fcosts = **(**uintptr)(__ccgo_up(costs + uintptr(first)*24 + uintptr(ctx0)*8))
 		goto _7
 	_7:
 		;
 		m = m + 1
 	}
 	// traverse trellis.
 	n1 = first
 	for {
 		if !(n1 <= last) {
 			break
 		}
 		j1 = libc.Int32FromUint8(kZigzag1[n1])
 		Q = uint32(**(**uint16_t)(__ccgo_up(mtx + uintptr(j1)*2)))
 		iQ1 = uint32(**(**uint16_t)(__ccgo_up(mtx + 32 + uintptr(j1)*2)))
 		B1 = libc.Uint32FromInt32(libc.Int32FromInt32(0x00) << (libc.Int32FromInt32(QFIX) - libc.Int32FromInt32(8))) // neutral bias
 		// note: it's important to take sign of the _original_ coeff,
 		// so we don't have to consider level < 0 afterward.
 		sign = libc.BoolInt32(int32(**(**int16_t)(__ccgo_up(in + uintptr(j1)*2))) < libc.Int32FromInt32(0))
 		if sign != 0 {
 			v1 = -int32(**(**int16_t)(__ccgo_up(in + uintptr(j1)*2)))
 		} else {
 			v1 = int32(**(**int16_t)(__ccgo_up(in + uintptr(j1)*2)))
 		}
 		coeff0 = libc.Uint32FromInt32(v1 + libc.Int32FromUint16(**(**uint16_t)(__ccgo_up(mtx + 192 + uintptr(j1)*2))))
 		v4 = libc.Int32FromUint32((coeff0*iQ1 + B1) >> libc.Int32FromInt32(QFIX))
 		goto _16
 	_16:
 		level0 = v4
 		v6 = libc.Int32FromUint32((coeff0*iQ1 + libc.Uint32FromInt32(libc.Int32FromInt32(0x80)<<(libc.Int32FromInt32(QFIX)-libc.Int32FromInt32(8)))) >> libc.Int32FromInt32(QFIX))
 		goto _18
 	_18:
 		thresh_level = v6
 		if thresh_level > int32(MAX_LEVEL) {
 			thresh_level = int32(MAX_LEVEL)
 		}
 		if level0 > int32(MAX_LEVEL) {
 			level0 = int32(MAX_LEVEL)
 		}
 		// Swap current and previous score states
 		tmp = ss_cur
 		ss_cur = ss_prev
 		ss_prev = tmp
 		// test all alternate level values around level0.
 		m = -MIN_DELTA
 		for {
 			if !(m <= int32(MAX_DELTA)) {
 				break
 			}
 			cur = bp + uintptr(n1)*8 + uintptr(m+MIN_DELTA)*4
 			level1 = level0 + m
 			if level1 > int32(2) {
 				v1 = int32(2)
 			} else {
 				v1 = level1
 			}
 			ctx = v1
 			band = libc.Int32FromUint8(VP8EncBands[n1+int32(1)])
 			(**(**ScoreState)(__ccgo_up(ss_cur + uintptr(m)*16))).Fcosts = **(**uintptr)(__ccgo_up(costs + uintptr(n1+int32(1))*24 + uintptr(ctx)*8))
 			if level1 < 0 || level1 > thresh_level {
 				(**(**ScoreState)(__ccgo_up(ss_cur + uintptr(m)*16))).Fscore = libc.Int64FromInt64(0x7fffffffffffff)
 				// Node is dead.
 				goto _19
 			}
 			// Compute delta_error = how much coding this level will
 			// subtract to max_error as distortion.
 			// Here, distortion = sum of (|coeff_i| - level_i * Q_i)^2
 			new_error = libc.Int32FromUint32(coeff0 - libc.Uint32FromInt32(level1)*Q)
 			delta_error = libc.Int32FromUint32(uint32(kWeightTrellis[j1]) * (libc.Uint32FromInt32(new_error*new_error) - coeff0*coeff0))
 			base_score = RDScoreTrellis(tls, lambda, 0, int64(delta_error))
 			// Inspect all possible non-dead predecessors. Retain only the best one.
 			// The base_score is added to all scores so it is only added for the final
 			// value after the loop.
 			v1 = level1
 			if v1 > int32(MAX_VARIABLE_LEVEL) {
 				v6 = int32(MAX_VARIABLE_LEVEL)
 			} else {
 				v6 = v1
 			}
 			v4 = libc.Int32FromUint16(VP8LevelFixedCosts[v1]) + libc.Int32FromUint16(**(**uint16_t)(__ccgo_up((**(**ScoreState)(__ccgo_up(ss_prev + uintptr(-libc.Int32FromInt32(MIN_DELTA))*16))).Fcosts + uintptr(v6)*2)))
 			goto _23
 		_23:
 			cost1 = int64(v4)
 			best_cur_score = (**(**ScoreState)(__ccgo_up(ss_prev + uintptr(-libc.Int32FromInt32(MIN_DELTA))*16))).Fscore + RDScoreTrellis(tls, lambda, cost1, 0)
 			best_prev = -MIN_DELTA
 			p = -libc.Int32FromInt32(MIN_DELTA) + libc.Int32FromInt32(1)
 			for {
 				if !(p <= int32(MAX_DELTA)) {
 					break
 				}
 				// Dead nodes (with ss_prev[p].score >= MAX_COST) are automatically
 				// eliminated since their score can't be better than the current best.
 				v1 = level1
 				if v1 > int32(MAX_VARIABLE_LEVEL) {
 					v6 = int32(MAX_VARIABLE_LEVEL)
 				} else {
 					v6 = v1
 				}
 				v4 = libc.Int32FromUint16(VP8LevelFixedCosts[v1]) + libc.Int32FromUint16(**(**uint16_t)(__ccgo_up((**(**ScoreState)(__ccgo_up(ss_prev + uintptr(p)*16))).Fcosts + uintptr(v6)*2)))
 				goto _28
 			_28:
 				cost1 = int64(v4)
 				// Examine node assuming it's a non-terminal one.
 				score = (**(**ScoreState)(__ccgo_up(ss_prev + uintptr(p)*16))).Fscore + RDScoreTrellis(tls, lambda, cost1, 0)
 				if score < best_cur_score {
 					best_cur_score = score
 					best_prev = p
 				}
 				goto _25
 			_25:
 				;
 				p = p + 1
 			}
 			best_cur_score = best_cur_score + base_score
 			// Store best finding in current node.
 			(*Node)(unsafe.Pointer(cur)).Fsign = int8(sign)
 			(*Node)(unsafe.Pointer(cur)).Flevel = int16(level1)
 			(*Node)(unsafe.Pointer(cur)).Fprev = int8(best_prev)
 			(**(**ScoreState)(__ccgo_up(ss_cur + uintptr(m)*16))).Fscore = best_cur_score
 			// Now, record best terminal node (and thus best entry in the graph).
 			if level1 != 0 && best_cur_score < best_score {
 				if n1 < int32(15) {
 					v3 = **(**uint8_t)(__ccgo_up(probas + uintptr(band)*33 + uintptr(ctx)*11))
 					if !(0 != 0) {
 						v6 = libc.Int32FromUint16(VP8EntropyCost[v3])
 					} else {
 						v6 = libc.Int32FromUint16(VP8EntropyCost[int32(255)-libc.Int32FromUint8(v3)])
 					}
 					v4 = v6
 					goto _33
 				_33:
 					v1 = v4
 				} else {
 					v1 = 0
 				}
 				last_pos_cost = int64(v1)
 				last_pos_score = RDScoreTrellis(tls, lambda, last_pos_cost, 0)
 				score = best_cur_score + last_pos_score
 				if score < best_score {
 					best_score = score
 					best_path[0] = n1               // best eob position
 					best_path[int32(1)] = m         // best node index
 					best_path[int32(2)] = best_prev // best predecessor
 				}
 			}
 			goto _19
 		_19:
 			;
 			m = m + 1
 		}
 		goto _13
 	_13:
 		;
 		n1 = n1 + 1
 	}
 	// Fresh start
 	// Beware! We must preserve in[0]/out[0] value for TYPE_I16_AC case.
 	if coeff_type == int32(TYPE_I16_AC) {
 		libc.X__builtin___memset_chk(tls, in+uintptr(1)*2, 0, libc.Uint64FromInt32(15)*libc.Uint64FromInt64(2), ^__predefined_size_t(0))
 		libc.X__builtin___memset_chk(tls, out+uintptr(1)*2, 0, libc.Uint64FromInt32(15)*libc.Uint64FromInt64(2), ^__predefined_size_t(0))
 	} else {
 		libc.X__builtin___memset_chk(tls, in, 0, libc.Uint64FromInt32(16)*libc.Uint64FromInt64(2), ^__predefined_size_t(0))
 		libc.X__builtin___memset_chk(tls, out, 0, libc.Uint64FromInt32(16)*libc.Uint64FromInt64(2), ^__predefined_size_t(0))
 	}
 	if best_path[0] == -int32(1) {
 		return 0 // skip!
 	}
 	// Unwind the best path.
 	// Note: best-prev on terminal node is not necessarily equal to the
 	// best_prev for non-terminal. So we patch best_path[2] in.
 	nz = 0
 	best_node = best_path[int32(1)]
 	n1 = best_path[0]
 	(**(**Node)(__ccgo_up(bp + uintptr(n1)*8 + uintptr(best_node+MIN_DELTA)*4))).Fprev = int8(best_path[int32(2)]) // force best-prev for terminal
 	for {
 		if !(n1 >= first) {
 			break
 		}
 		node = bp + uintptr(n1)*8 + uintptr(best_node+MIN_DELTA)*4
 		j2 = libc.Int32FromUint8(kZigzag1[n1])
 		if (*Node)(unsafe.Pointer(node)).Fsign != 0 {
 			v1 = -int32((*Node)(unsafe.Pointer(node)).Flevel)
 		} else {
 			v1 = int32((*Node)(unsafe.Pointer(node)).Flevel)
 		}
 		**(**int16_t)(__ccgo_up(out + uintptr(n1)*2)) = int16(v1)
 		nz = nz | int32((*Node)(unsafe.Pointer(node)).Flevel)
 		**(**int16_t)(__ccgo_up(in + uintptr(j2)*2)) = int16(int32(**(**int16_t)(__ccgo_up(out + uintptr(n1)*2))) * libc.Int32FromUint16(**(**uint16_t)(__ccgo_up(mtx + uintptr(j2)*2))))
 		best_node = int32((*Node)(unsafe.Pointer(node)).Fprev)
 		goto _35
 	_35:
 		;
 		n1 = n1 - 1
 	}
 	return libc.BoolInt32(nz != 0)
 	return r
 }
 
 //------------------------------------------------------------------------------
 // Performs: difference, transform, quantize, back-transform, add
 // all at once. Output is the reconstructed block in *yuv_out, and the
 // quantized levels in *levels.
 
 func ReconstructIntra16(tls *libc.TLS, it uintptr, rd uintptr, yuv_out uintptr, mode int32) (r int32) {
 	bp := tls.Alloc(544)
 	defer tls.Free(544)
 	var ctx, n, non_zero, nz, x, y, v4 int32
 	var dqm, enc, ref, src uintptr
 	var v6 int16_t
 	var _ /* dc_tmp at bp+512 */ [16]int16_t
 	var _ /* tmp at bp+0 */ [16][16]int16_t
 	_, _, _, _, _, _, _, _, _, _, _, _ = ctx, dqm, enc, n, non_zero, nz, ref, src, x, y, v4, v6
 	enc = (*VP8EncIterator)(unsafe.Pointer(it)).Fenc
 	ref = (*VP8EncIterator)(unsafe.Pointer(it)).Fyuv_p + uintptr(VP8I16ModeOffsets[mode])
 	src = (*VP8EncIterator)(unsafe.Pointer(it)).Fyuv_in + uintptr(libc.Int32FromInt32(Y_OFF_ENC))
 	dqm = enc + 608 + uintptr(int32(uint32(*(*uint8)(unsafe.Pointer((*VP8EncIterator)(unsafe.Pointer(it)).Fmb + 0))&0x60>>5)))*744
 	nz = 0
 	n = 0
 	for {
 		if !(n < int32(16)) {
 			break
 		}
 		(*(*func(*libc.TLS, uintptr, uintptr, uintptr))(unsafe.Pointer(&struct{ uintptr }{VP8FTransform2})))(tls, src+uintptr(VP8Scan[n]), ref+uintptr(VP8Scan[n]), bp+uintptr(n)*32)
 		goto _1
 	_1:
 		;
 		n = n + int32(2)
 	}
 	(*(*func(*libc.TLS, uintptr, uintptr))(unsafe.Pointer(&struct{ uintptr }{VP8FTransformWHT})))(tls, bp, bp+512)
 	nz = nz | (*(*func(*libc.TLS, uintptr, uintptr, uintptr) int32)(unsafe.Pointer(&struct{ uintptr }{VP8EncQuantizeBlockWHT})))(tls, bp+512, rd+40, dqm+224)<<int32(24)
 	if libc.Bool(int32(DO_TRELLIS_I16) != 0) && (*VP8EncIterator)(unsafe.Pointer(it)).Fdo_trellis != 0 {
 		VP8IteratorNzToBytes(tls, it)
 		y = 0
 		n = libc.Int32FromInt32(0)
 		for {
 			if !(y < int32(4)) {
 				break
 			}
 			x = 0
 			for {
 				if !(x < int32(4)) {
 					break
 				}
 				ctx = **(**int32)(__ccgo_up(it + 132 + uintptr(x)*4)) + **(**int32)(__ccgo_up(it + 168 + uintptr(y)*4))
 				non_zero = TrellisQuantizeBlock(tls, enc, bp+uintptr(n)*32, rd+72+uintptr(n)*32, ctx, int32(TYPE_I16_AC), dqm, (*VP8SegmentInfo)(unsafe.Pointer(dqm)).Flambda_trellis_i16)
 				v4 = non_zero
 				**(**int32)(__ccgo_up(it + 168 + uintptr(y)*4)) = v4
 				**(**int32)(__ccgo_up(it + 132 + uintptr(x)*4)) = v4
 				**(**int16_t)(__ccgo_up(rd + 72 + uintptr(n)*32)) = 0
 				nz = nz | non_zero<<n
 				goto _3
 			_3:
 				;
 				x = x + 1
 				n = n + 1
 			}
 			goto _2
 		_2:
 			;
 			y = y + 1
 		}
 	} else {
 		n = 0
 		for {
 			if !(n < int32(16)) {
 				break
 			}
 			// Zero-out the first coeff, so that: a) nz is correct below, and
 			// b) finding 'last' non-zero coeffs in SetResidualCoeffs() is simplified.
 			v6 = libc.Int16FromInt32(0)
 			**(**int16_t)(__ccgo_up(bp + uintptr(n+int32(1))*32)) = v6
 			**(**int16_t)(__ccgo_up(bp + uintptr(n)*32)) = v6
 			nz = nz | (*(*func(*libc.TLS, uintptr, uintptr, uintptr) int32)(unsafe.Pointer(&struct{ uintptr }{VP8EncQuantize2Blocks})))(tls, bp+uintptr(n)*32, rd+72+uintptr(n)*32, dqm)<<n
 			goto _5
 		_5:
 			;
 			n = n + int32(2)
 		}
 	}
 	// Transform back
 	(*(*func(*libc.TLS, uintptr, uintptr))(unsafe.Pointer(&struct{ uintptr }{VP8TransformWHT})))(tls, bp+512, bp)
 	n = 0
 	for {
 		if !(n < int32(16)) {
 			break
 		}
 		(*(*func(*libc.TLS, uintptr, uintptr, uintptr, int32))(unsafe.Pointer(&struct{ uintptr }{VP8ITransform})))(tls, ref+uintptr(VP8Scan[n]), bp+uintptr(n)*32, yuv_out+uintptr(VP8Scan[n]), int32(1))
 		goto _7
 	_7:
 		;
 		n = n + int32(2)
 	}
 	return nz
 }
 
 func ReconstructIntra4(tls *libc.TLS, it uintptr, levels uintptr, src uintptr, yuv_out uintptr, mode int32) (r int32) {
 	bp := tls.Alloc(32)
 	defer tls.Free(32)
 	var ctx, nz, x, y int32
 	var dqm, enc, ref uintptr
 	var _ /* tmp at bp+0 */ [16]int16_t
 	_, _, _, _, _, _, _ = ctx, dqm, enc, nz, ref, x, y
 	enc = (*VP8EncIterator)(unsafe.Pointer(it)).Fenc
 	ref = (*VP8EncIterator)(unsafe.Pointer(it)).Fyuv_p + uintptr(VP8I4ModeOffsets[mode])
 	dqm = enc + 608 + uintptr(int32(uint32(*(*uint8)(unsafe.Pointer((*VP8EncIterator)(unsafe.Pointer(it)).Fmb + 0))&0x60>>5)))*744
 	nz = 0
 	(*(*func(*libc.TLS, uintptr, uintptr, uintptr))(unsafe.Pointer(&struct{ uintptr }{VP8FTransform})))(tls, src, ref, bp)
 	if libc.Bool(int32(DO_TRELLIS_I4) != 0) && (*VP8EncIterator)(unsafe.Pointer(it)).Fdo_trellis != 0 {
 		x = (*VP8EncIterator)(unsafe.Pointer(it)).Fi4 & int32(3)
 		y = (*VP8EncIterator)(unsafe.Pointer(it)).Fi4 >> int32(2)
 		ctx = **(**int32)(__ccgo_up(it + 132 + uintptr(x)*4)) + **(**int32)(__ccgo_up(it + 168 + uintptr(y)*4))
 		nz = TrellisQuantizeBlock(tls, enc, bp, levels, ctx, int32(TYPE_I4_AC), dqm, (*VP8SegmentInfo)(unsafe.Pointer(dqm)).Flambda_trellis_i4)
 	} else {
 		nz = (*(*func(*libc.TLS, uintptr, uintptr, uintptr) int32)(unsafe.Pointer(&struct{ uintptr }{VP8EncQuantizeBlock})))(tls, bp, levels, dqm)
 	}
 	(*(*func(*libc.TLS, uintptr, uintptr, uintptr, int32))(unsafe.Pointer(&struct{ uintptr }{VP8ITransform})))(tls, ref, bp, yuv_out, 0)
 	return nz
 }
 
 //------------------------------------------------------------------------------
 // DC-error diffusion
 
 // Diffusion weights. We under-correct a bit (15/16th of the error is actually
 // diffused) to avoid 'rainbow' chessboard pattern of blocks at q~=0.
 
 // C documentation
 //
 //	// Quantize as usual, but also compute and return the quantization error.
 //	// Error is already divided by DSHIFT.
 func QuantizeSingle(tls *libc.TLS, v uintptr, mtx uintptr) (r int32) {
 	var V, err, qV, sign, v1, v3 int32
 	_, _, _, _, _, _ = V, err, qV, sign, v1, v3
 	V = int32(**(**int16_t)(__ccgo_up(v)))
 	sign = libc.BoolInt32(V < libc.Int32FromInt32(0))
 	if sign != 0 {
 		V = -V
 	}
 	if V > libc.Int32FromUint32(**(**uint32_t)(__ccgo_up(mtx + 128))) {
 		v1 = libc.Int32FromUint32((libc.Uint32FromInt32(V)*uint32(**(**uint16_t)(__ccgo_up(mtx + 32))) + **(**uint32_t)(__ccgo_up(mtx + 64))) >> libc.Int32FromInt32(QFIX))
 		goto _2
 	_2:
 		qV = v1 * libc.Int32FromUint16(**(**uint16_t)(__ccgo_up(mtx)))
 		err = V - qV
 		if sign != 0 {
 			v3 = -qV
 		} else {
 			v3 = qV
 		}
 		**(**int16_t)(__ccgo_up(v)) = int16(v3)
 		if sign != 0 {
 			v1 = -err
 		} else {
 			v1 = err
 		}
 		return v1 >> int32(1)
 	}
 	**(**int16_t)(__ccgo_up(v)) = 0
 	if sign != 0 {
 		v1 = -V
 	} else {
 		v1 = V
 	}
 	return v1 >> int32(1)
 }
 
 func CorrectDCValues(tls *libc.TLS, it uintptr, mtx uintptr, tmp uintptr, rd uintptr) {
 	var c, left, top, v2 uintptr
 	var ch, err0, err1, err2, err3 int32
 	_, _, _, _, _, _, _, _, _ = c, ch, err0, err1, err2, err3, left, top, v2
 	ch = 0
 	for {
 		if !(ch <= int32(1)) {
 			break
 		}
 		top = (*VP8EncIterator)(unsafe.Pointer(it)).Ftop_derr + uintptr((*VP8EncIterator)(unsafe.Pointer(it)).Fx)*4 + uintptr(ch)*2
 		left = it + 344 + uintptr(ch)*2
 		c = tmp + uintptr(ch*int32(4))*32
 		v2 = c
 		*(*int16_t)(unsafe.Pointer(v2)) = int16_t(int32(*(*int16_t)(unsafe.Pointer(v2))) + (libc.Int32FromInt32(7)*int32(**(**int8_t)(__ccgo_up(top)))+libc.Int32FromInt32(8)*int32(**(**int8_t)(__ccgo_up(left))))>>(libc.Int32FromInt32(4)-libc.Int32FromInt32(1)))
 		err0 = QuantizeSingle(tls, c, mtx)
 		v2 = c + 1*32
 		*(*int16_t)(unsafe.Pointer(v2)) = int16_t(int32(*(*int16_t)(unsafe.Pointer(v2))) + (libc.Int32FromInt32(7)*int32(**(**int8_t)(__ccgo_up(top + 1)))+libc.Int32FromInt32(8)*err0)>>(libc.Int32FromInt32(4)-libc.Int32FromInt32(1)))
 		err1 = QuantizeSingle(tls, c+1*32, mtx)
 		v2 = c + 2*32
 		*(*int16_t)(unsafe.Pointer(v2)) = int16_t(int32(*(*int16_t)(unsafe.Pointer(v2))) + (libc.Int32FromInt32(7)*err0+libc.Int32FromInt32(8)*int32(**(**int8_t)(__ccgo_up(left + 1))))>>(libc.Int32FromInt32(4)-libc.Int32FromInt32(1)))
 		err2 = QuantizeSingle(tls, c+2*32, mtx)
 		v2 = c + 3*32
 		*(*int16_t)(unsafe.Pointer(v2)) = int16_t(int32(*(*int16_t)(unsafe.Pointer(v2))) + (libc.Int32FromInt32(7)*err1+libc.Int32FromInt32(8)*err2)>>(libc.Int32FromInt32(4)-libc.Int32FromInt32(1)))
 		err3 = QuantizeSingle(tls, c+3*32, mtx)
 		// error 'err' is bounded by mtx->q[0] which is 132 at max. Hence
 		// err >> DSCALE will fit in an int8_t type if DSCALE>=1.
 		**(**int8_t)(__ccgo_up(rd + 868 + uintptr(ch)*3)) = int8(err1)
 		**(**int8_t)(__ccgo_up(rd + 868 + uintptr(ch)*3 + 1)) = int8(err2)
 		**(**int8_t)(__ccgo_up(rd + 868 + uintptr(ch)*3 + 2)) = int8(err3)
 		goto _1
 	_1:
 		;
 		ch = ch + 1
 	}
 }
 
 func StoreDiffusionErrors(tls *libc.TLS, it uintptr, rd uintptr) {
 	var ch int32
 	var left, top uintptr
 	_, _, _ = ch, left, top
 	ch = 0
 	for {
 		if !(ch <= int32(1)) {
 			break
 		}
 		top = (*VP8EncIterator)(unsafe.Pointer(it)).Ftop_derr + uintptr((*VP8EncIterator)(unsafe.Pointer(it)).Fx)*4 + uintptr(ch)*2
 		left = it + 344 + uintptr(ch)*2
 		**(**int8_t)(__ccgo_up(left)) = **(**int8_t)(__ccgo_up(rd + 868 + uintptr(ch)*3))                                                                // restore err1
 		**(**int8_t)(__ccgo_up(left + 1)) = int8(int32(3) * int32(**(**int8_t)(__ccgo_up(rd + 868 + uintptr(ch)*3 + 2))) >> int32(2))                    //     ... 3/4th of err3
 		**(**int8_t)(__ccgo_up(top)) = **(**int8_t)(__ccgo_up(rd + 868 + uintptr(ch)*3 + 1))                                                             //     ... err2
 		**(**int8_t)(__ccgo_up(top + 1)) = int8(int32(**(**int8_t)(__ccgo_up(rd + 868 + uintptr(ch)*3 + 2))) - int32(**(**int8_t)(__ccgo_up(left + 1)))) //     ... 1/4th of err3.
 		goto _1
 	_1:
 		;
 		ch = ch + 1
 	}
 }
 
 //------------------------------------------------------------------------------
 
 func ReconstructUV(tls *libc.TLS, it uintptr, rd uintptr, yuv_out uintptr, mode int32) (r int32) {
 	bp := tls.Alloc(256)
 	defer tls.Free(256)
 	var ch, ctx, n, non_zero, nz, x, y, v5 int32
 	var dqm, enc, ref, src uintptr
 	var _ /* tmp at bp+0 */ [8][16]int16_t
 	_, _, _, _, _, _, _, _, _, _, _, _ = ch, ctx, dqm, enc, n, non_zero, nz, ref, src, x, y, v5
 	enc = (*VP8EncIterator)(unsafe.Pointer(it)).Fenc
 	ref = (*VP8EncIterator)(unsafe.Pointer(it)).Fyuv_p + uintptr(VP8UVModeOffsets[mode])
 	src = (*VP8EncIterator)(unsafe.Pointer(it)).Fyuv_in + uintptr(libc.Int32FromInt32(U_OFF_ENC))
 	dqm = enc + 608 + uintptr(int32(uint32(*(*uint8)(unsafe.Pointer((*VP8EncIterator)(unsafe.Pointer(it)).Fmb + 0))&0x60>>5)))*744
 	nz = 0
 	n = 0
 	for {
 		if !(n < int32(8)) {
 			break
 		}
 		(*(*func(*libc.TLS, uintptr, uintptr, uintptr))(unsafe.Pointer(&struct{ uintptr }{VP8FTransform2})))(tls, src+uintptr(VP8ScanUV[n]), ref+uintptr(VP8ScanUV[n]), bp+uintptr(n)*32)
 		goto _1
 	_1:
 		;
 		n = n + int32(2)
 	}
 	if (*VP8EncIterator)(unsafe.Pointer(it)).Ftop_derr != libc.UintptrFromInt32(0) {
 		CorrectDCValues(tls, it, dqm+448, bp, rd)
 	}
 	if libc.Bool(DO_TRELLIS_UV != 0) && (*VP8EncIterator)(unsafe.Pointer(it)).Fdo_trellis != 0 {
 		ch = 0
 		n = libc.Int32FromInt32(0)
 		for {
 			if !(ch <= int32(2)) {
 				break
 			}
 			y = 0
 			for {
 				if !(y < int32(2)) {
 					break
 				}
 				x = 0
 				for {
 					if !(x < int32(2)) {
 						break
 					}
 					ctx = **(**int32)(__ccgo_up(it + 132 + uintptr(int32(4)+ch+x)*4)) + **(**int32)(__ccgo_up(it + 168 + uintptr(int32(4)+ch+y)*4))
 					non_zero = TrellisQuantizeBlock(tls, enc, bp+uintptr(n)*32, rd+584+uintptr(n)*32, ctx, int32(TYPE_CHROMA_A), dqm+448, (*VP8SegmentInfo)(unsafe.Pointer(dqm)).Flambda_trellis_uv)
 					v5 = non_zero
 					**(**int32)(__ccgo_up(it + 168 + uintptr(int32(4)+ch+y)*4)) = v5
 					**(**int32)(__ccgo_up(it + 132 + uintptr(int32(4)+ch+x)*4)) = v5
 					nz = nz | non_zero<<n
 					goto _4
 				_4:
 					;
 					x = x + 1
 					n = n + 1
 				}
 				goto _3
 			_3:
 				;
 				y = y + 1
 			}
 			goto _2
 		_2:
 			;
 			ch = ch + int32(2)
 		}
 	} else {
 		n = 0
 		for {
 			if !(n < int32(8)) {
 				break
 			}
 			nz = nz | (*(*func(*libc.TLS, uintptr, uintptr, uintptr) int32)(unsafe.Pointer(&struct{ uintptr }{VP8EncQuantize2Blocks})))(tls, bp+uintptr(n)*32, rd+584+uintptr(n)*32, dqm+448)<<n
 			goto _6
 		_6:
 			;
 			n = n + int32(2)
 		}
 	}
 	n = 0
 	for {
 		if !(n < int32(8)) {
 			break
 		}
 		(*(*func(*libc.TLS, uintptr, uintptr, uintptr, int32))(unsafe.Pointer(&struct{ uintptr }{VP8ITransform})))(tls, ref+uintptr(VP8ScanUV[n]), bp+uintptr(n)*32, yuv_out+uintptr(VP8ScanUV[n]), int32(1))
 		goto _7
 	_7:
 		;
 		n = n + int32(2)
 	}
 	return nz << int32(16)
 }
 
 //------------------------------------------------------------------------------
 // RD-opt decision. Reconstruct each modes, evalue distortion and bit-cost.
 // Pick the mode is lower RD-cost = Rate + lambda * Distortion.
 
 func StoreMaxDelta(tls *libc.TLS, dqm uintptr, DCs uintptr) {
 	var max_v, v0, v1, v2, v11, v21 int32
 	_, _, _, _, _, _ = max_v, v0, v1, v2, v11, v21
 	// We look at the first three AC coefficients to determine what is the average
 	// delta between each sub-4x4 block.
 	v0 = libc.Xabs(tls, int32(**(**int16_t)(__ccgo_up(DCs + 1*2))))
 	v1 = libc.Xabs(tls, int32(**(**int16_t)(__ccgo_up(DCs + 2*2))))
 	v2 = libc.Xabs(tls, int32(**(**int16_t)(__ccgo_up(DCs + 4*2))))
 	if v1 > v0 {
 		v11 = v1
 	} else {
 		v11 = v0
 	}
 	max_v = v11
 	if v2 > max_v {
 		v21 = v2
 	} else {
 		v21 = max_v
 	}
 	max_v = v21
 	if max_v > (*VP8SegmentInfo)(unsafe.Pointer(dqm)).Fmax_edge {
 		(*VP8SegmentInfo)(unsafe.Pointer(dqm)).Fmax_edge = max_v
 	}
 }
 
 func SwapModeScore(tls *libc.TLS, a uintptr, b uintptr) {
 	var tmp uintptr
 	_ = tmp
 	tmp = **(**uintptr)(__ccgo_up(a))
 	**(**uintptr)(__ccgo_up(a)) = **(**uintptr)(__ccgo_up(b))
 	**(**uintptr)(__ccgo_up(b)) = tmp
 }
 
 func SwapPtr(tls *libc.TLS, a uintptr, b uintptr) {
 	var tmp uintptr
 	_ = tmp
 	tmp = **(**uintptr)(__ccgo_up(a))
 	**(**uintptr)(__ccgo_up(a)) = **(**uintptr)(__ccgo_up(b))
 	**(**uintptr)(__ccgo_up(b)) = tmp
 }
 
 func SwapOut(tls *libc.TLS, it uintptr) {
 	SwapPtr(tls, it+16, it+24)
 }
 
 func PickBestIntra16(tls *libc.TLS, it uintptr, rd uintptr) {
 	bp := tls.Alloc(912)
 	defer tls.Free(912)
 	var dqm, src1, tmp_dst, v1 uintptr
 	var i, i1, is_flat, kNumBlocks, lambda, mode, score, tlambda, v3, v6, v8 int32
 	var _ /* rd_best at bp+896 */ uintptr
 	var _ /* rd_cur at bp+888 */ uintptr
 	var _ /* rd_tmp at bp+8 */ VP8ModeScore
 	var _ /* v at bp+0 */ uint32_t
 	_, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = dqm, i, i1, is_flat, kNumBlocks, lambda, mode, score, src1, tlambda, tmp_dst, v1, v3, v6, v8
 	kNumBlocks = int32(16)
 	dqm = (*VP8EncIterator)(unsafe.Pointer(it)).Fenc + 608 + uintptr(int32(uint32(*(*uint8)(unsafe.Pointer((*VP8EncIterator)(unsafe.Pointer(it)).Fmb + 0))&0x60>>5)))*744
 	lambda = (*VP8SegmentInfo)(unsafe.Pointer(dqm)).Flambda_i16
 	tlambda = (*VP8SegmentInfo)(unsafe.Pointer(dqm)).Ftlambda
 	src1 = (*VP8EncIterator)(unsafe.Pointer(it)).Fyuv_in + uintptr(libc.Int32FromInt32(Y_OFF_ENC))
 	**(**uintptr)(__ccgo_up(bp + 888)) = bp + 8
 	**(**uintptr)(__ccgo_up(bp + 896)) = rd
 	v1 = (*VP8EncIterator)(unsafe.Pointer(it)).Fyuv_in + uintptr(libc.Int32FromInt32(Y_OFF_ENC))
 	**(**uint32_t)(__ccgo_up(bp)) = uint32(**(**uint8_t)(__ccgo_up(v1))) * uint32(0x01010101)
 	i1 = libc.Int32FromInt32(0)
 	for {
 		if !(i1 < libc.Int32FromInt32(16)) {
 			break
 		}
 		if libc.Xmemcmp(tls, v1+uintptr(0), bp, uint64(4)) != 0 || libc.Xmemcmp(tls, v1+uintptr(4), bp, uint64(4)) != 0 || libc.Xmemcmp(tls, v1+uintptr(8), bp, uint64(4)) != 0 || libc.Xmemcmp(tls, v1+uintptr(12), bp, uint64(4)) != 0 {
 			v3 = 0
 			goto _4
 		}
 		v1 = v1 + uintptr(BPS)
 		goto _2
 	_2:
 		;
 		i1 = i1 + 1
 	}
 	v3 = int32(1)
 	goto _4
 _4:
 	is_flat = v3
 	(*VP8ModeScore)(unsafe.Pointer(rd)).Fmode_i16 = -int32(1)
 	mode = 0
 	for {
 		if !(mode < int32(NUM_PRED_MODES)) {
 			break
 		}
 		tmp_dst = (*VP8EncIterator)(unsafe.Pointer(it)).Fyuv_out2 + uintptr(libc.Int32FromInt32(Y_OFF_ENC)) // scratch buffer
 		(*VP8ModeScore)(unsafe.Pointer(**(**uintptr)(__ccgo_up(bp + 888)))).Fmode_i16 = mode
 		// Reconstruct
 		(*VP8ModeScore)(unsafe.Pointer(**(**uintptr)(__ccgo_up(bp + 888)))).Fnz = libc.Uint32FromInt32(ReconstructIntra16(tls, it, **(**uintptr)(__ccgo_up(bp + 888)), tmp_dst, mode))
 		// Measure RD-score
 		(*VP8ModeScore)(unsafe.Pointer(**(**uintptr)(__ccgo_up(bp + 888)))).FD = int64((*(*func(*libc.TLS, uintptr, uintptr) int32)(unsafe.Pointer(&struct{ uintptr }{VP8SSE16x16})))(tls, src1, tmp_dst))
 		if tlambda != 0 {
 			v3 = (tlambda*(*(*func(*libc.TLS, uintptr, uintptr, uintptr) int32)(unsafe.Pointer(&struct{ uintptr }{VP8TDisto16x16})))(tls, src1, tmp_dst, uintptr(unsafe.Pointer(&kWeightY))) + int32(128)) >> int32(8)
 		} else {
 			v3 = 0
 		}
 		(*VP8ModeScore)(unsafe.Pointer(**(**uintptr)(__ccgo_up(bp + 888)))).FSD = int64(v3)
 		(*VP8ModeScore)(unsafe.Pointer(**(**uintptr)(__ccgo_up(bp + 888)))).FH = libc.Int64FromUint16(VP8FixedCostsI16[mode])
 		(*VP8ModeScore)(unsafe.Pointer(**(**uintptr)(__ccgo_up(bp + 888)))).FR = int64(VP8GetCostLuma16(tls, it, **(**uintptr)(__ccgo_up(bp + 888))))
 		if is_flat != 0 {
 			// refine the first impression (which was in pixel space)
 			v1 = **(**uintptr)(__ccgo_up(bp + 888)) + 72
 			v3 = kNumBlocks
 			score = 0
 			for {
 				v6 = v3
 				v3 = v3 - 1
 				if !(v6 > libc.Int32FromInt32(0)) {
 					break
 				}
 				i = libc.Int32FromInt32(1)
 				for {
 					if !(i < libc.Int32FromInt32(16)) {
 						break
 					}
 					score = score + libc.BoolInt32(int32(**(**int16_t)(__ccgo_up(v1 + uintptr(i)*2))) != 0)
 					if score > FLATNESS_LIMIT_I16 {
 						v8 = 0
 						goto _12
 					}
 					goto _10
 				_10:
 					;
 					i = i + 1
 				}
 				v1 = v1 + uintptr(16)*2
 			}
 			v8 = int32(1)
 			goto _12
 		_12:
 			is_flat = v8
 			if is_flat != 0 {
 				// Block is very flat. We put emphasis on the distortion being very low!
 				**(**score_t)(__ccgo_up(**(**uintptr)(__ccgo_up(bp + 888)))) *= int64(2)
 				**(**score_t)(__ccgo_up(**(**uintptr)(__ccgo_up(bp + 888)) + 8)) *= int64(2)
 			}
 		}
 		// Since we always examine Intra16 first, we can overwrite *rd directly.
 		SetRDScore(tls, lambda, **(**uintptr)(__ccgo_up(bp + 888)))
 		if mode == 0 || (*VP8ModeScore)(unsafe.Pointer(**(**uintptr)(__ccgo_up(bp + 888)))).Fscore < (*VP8ModeScore)(unsafe.Pointer(**(**uintptr)(__ccgo_up(bp + 896)))).Fscore {
 			SwapModeScore(tls, bp+888, bp+896)
 			SwapOut(tls, it)
 		}
 		goto _5
 	_5:
 		;
 		mode = mode + 1
 	}
 	if **(**uintptr)(__ccgo_up(bp + 896)) != rd {
 		libc.X__builtin___memcpy_chk(tls, rd, **(**uintptr)(__ccgo_up(bp + 896)), uint64(880), ^__predefined_size_t(0))
 	}
 	SetRDScore(tls, (*VP8SegmentInfo)(unsafe.Pointer(dqm)).Flambda_mode, rd) // finalize score for mode decision.
 	VP8SetIntra16Mode(tls, it, (*VP8ModeScore)(unsafe.Pointer(rd)).Fmode_i16)
 	// we have a blocky macroblock (only DCs are non-zero) with fairly high
 	// distortion, record max delta so we can later adjust the minimal filtering
 	// strength needed to smooth these blocks out.
 	if (*VP8ModeScore)(unsafe.Pointer(rd)).Fnz&uint32(0x100ffff) == uint32(0x1000000) && (*VP8ModeScore)(unsafe.Pointer(rd)).FD > int64((*VP8SegmentInfo)(unsafe.Pointer(dqm)).Fmin_disto) {
 		StoreMaxDelta(tls, dqm, rd+40)
 	}
 }
 
 //------------------------------------------------------------------------------
 
 // C documentation
 //
 //	// return the cost array corresponding to the surrounding prediction modes.
 func GetCostModeI4(tls *libc.TLS, it uintptr, modes uintptr) (r uintptr) {
 	var left, preds_w, top, x, y, v1, v2 int32
 	_, _, _, _, _, _, _ = left, preds_w, top, x, y, v1, v2
 	preds_w = (*VP8Encoder)(unsafe.Pointer((*VP8EncIterator)(unsafe.Pointer(it)).Fenc)).Fpreds_w
 	x = (*VP8EncIterator)(unsafe.Pointer(it)).Fi4 & libc.Int32FromInt32(3)
 	y = (*VP8EncIterator)(unsafe.Pointer(it)).Fi4 >> int32(2)
 	if x == 0 {
 		v1 = libc.Int32FromUint8(**(**uint8_t)(__ccgo_up((*VP8EncIterator)(unsafe.Pointer(it)).Fpreds + uintptr(y*preds_w-int32(1)))))
 	} else {
 		v1 = libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(modes + uintptr((*VP8EncIterator)(unsafe.Pointer(it)).Fi4-int32(1)))))
 	}
 	left = v1
 	if y == 0 {
 		v2 = libc.Int32FromUint8(**(**uint8_t)(__ccgo_up((*VP8EncIterator)(unsafe.Pointer(it)).Fpreds + uintptr(-preds_w+x))))
 	} else {
 		v2 = libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(modes + uintptr((*VP8EncIterator)(unsafe.Pointer(it)).Fi4-int32(4)))))
 	}
 	top = v2
 	return uintptr(unsafe.Pointer(&VP8FixedCostsI4)) + uintptr(top)*200 + uintptr(left)*20
 }
 
 func PickBestIntra4(tls *libc.TLS, it uintptr, rd uintptr) (r int32) {
 	bp := tls.Alloc(2688)
 	defer tls.Free(2688)
 	var best_blocks, dqm, enc, mode_costs, src, src0, v3 uintptr
 	var best_mode, i, kNumBlocks, lambda, mode, score, tlambda, total_header_bits, v2, v4, v5 int32
 	var v9 bool
 	var _ /* best_block at bp+1760 */ uintptr
 	var _ /* rd_best at bp+0 */ VP8ModeScore
 	var _ /* rd_i4 at bp+880 */ VP8ModeScore
 	var _ /* rd_tmp at bp+1776 */ VP8ModeScore
 	var _ /* tmp_dst at bp+1768 */ uintptr
 	var _ /* tmp_levels at bp+2656 */ [16]int16_t
 	_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = best_blocks, best_mode, dqm, enc, i, kNumBlocks, lambda, mode, mode_costs, score, src, src0, tlambda, total_header_bits, v2, v3, v4, v5, v9
 	enc = (*VP8EncIterator)(unsafe.Pointer(it)).Fenc
 	dqm = enc + 608 + uintptr(int32(uint32(*(*uint8)(unsafe.Pointer((*VP8EncIterator)(unsafe.Pointer(it)).Fmb + 0))&0x60>>5)))*744
 	lambda = (*VP8SegmentInfo)(unsafe.Pointer(dqm)).Flambda_i4
 	tlambda = (*VP8SegmentInfo)(unsafe.Pointer(dqm)).Ftlambda
 	src0 = (*VP8EncIterator)(unsafe.Pointer(it)).Fyuv_in + uintptr(libc.Int32FromInt32(Y_OFF_ENC))
 	best_blocks = (*VP8EncIterator)(unsafe.Pointer(it)).Fyuv_out2 + uintptr(libc.Int32FromInt32(Y_OFF_ENC))
 	total_header_bits = 0
 	if (*VP8Encoder)(unsafe.Pointer(enc)).Fmax_i4_header_bits == 0 {
 		return 0
 	}
 	InitScore(tls, bp)
 	(**(**VP8ModeScore)(__ccgo_up(bp))).FH = int64(211) // '211' is the value of VP8BitCost(0, 145)
 	SetRDScore(tls, (*VP8SegmentInfo)(unsafe.Pointer(dqm)).Flambda_mode, bp)
 	VP8IteratorStartI4(tls, it)
 	for cond := true; cond; cond = VP8IteratorRotateI4(tls, it, best_blocks) != 0 {
 		kNumBlocks = int32(1)
 		best_mode = -int32(1)
 		src = src0 + uintptr(VP8Scan[(*VP8EncIterator)(unsafe.Pointer(it)).Fi4])
 		mode_costs = GetCostModeI4(tls, it, rd+844)
 		**(**uintptr)(__ccgo_up(bp + 1760)) = best_blocks + uintptr(VP8Scan[(*VP8EncIterator)(unsafe.Pointer(it)).Fi4])
 		**(**uintptr)(__ccgo_up(bp + 1768)) = (*VP8EncIterator)(unsafe.Pointer(it)).Fyuv_p + uintptr(libc.Int32FromInt32(3)*libc.Int32FromInt32(16)*libc.Int32FromInt32(BPS)+libc.Int32FromInt32(4)*libc.Int32FromInt32(BPS)+libc.Int32FromInt32(8)) // scratch buffer.
 		InitScore(tls, bp+880)
 		MakeIntra4Preds(tls, it)
 		mode = 0
 		for {
 			if !(mode < int32(NUM_BMODES)) {
 				break
 			}
 			// Reconstruct
 			(**(**VP8ModeScore)(__ccgo_up(bp + 1776))).Fnz = libc.Uint32FromInt32(ReconstructIntra4(tls, it, bp+2656, src, **(**uintptr)(__ccgo_up(bp + 1768)), mode) << (*VP8EncIterator)(unsafe.Pointer(it)).Fi4)
 			// Compute RD-score
 			(**(**VP8ModeScore)(__ccgo_up(bp + 1776))).FD = int64((*(*func(*libc.TLS, uintptr, uintptr) int32)(unsafe.Pointer(&struct{ uintptr }{VP8SSE4x4})))(tls, src, **(**uintptr)(__ccgo_up(bp + 1768))))
 			if tlambda != 0 {
 				v2 = (tlambda*(*(*func(*libc.TLS, uintptr, uintptr, uintptr) int32)(unsafe.Pointer(&struct{ uintptr }{VP8TDisto4x4})))(tls, src, **(**uintptr)(__ccgo_up(bp + 1768)), uintptr(unsafe.Pointer(&kWeightY))) + int32(128)) >> int32(8)
 			} else {
 				v2 = 0
 			}
 			(**(**VP8ModeScore)(__ccgo_up(bp + 1776))).FSD = int64(v2)
 			(**(**VP8ModeScore)(__ccgo_up(bp + 1776))).FH = libc.Int64FromUint16(**(**uint16_t)(__ccgo_up(mode_costs + uintptr(mode)*2)))
 			// Add flatness penalty, to avoid flat area to be mispredicted
 			// by a complex mode.
 			if v9 = mode > 0; v9 {
 				v3 = bp + 2656
 				v2 = kNumBlocks
 				score = 0
 				for {
 					v4 = v2
 					v2 = v2 - 1
 					if !(v4 > libc.Int32FromInt32(0)) {
 						break
 					}
 					i = libc.Int32FromInt32(1)
 					for {
 						if !(i < libc.Int32FromInt32(16)) {
 							break
 						}
 						score = score + libc.BoolInt32(int32(**(**int16_t)(__ccgo_up(v3 + uintptr(i)*2))) != 0)
 						if score > int32(FLATNESS_LIMIT_I4) {
 							v5 = 0
 							goto _8
 						}
 						goto _6
 					_6:
 						;
 						i = i + 1
 					}
 					v3 = v3 + uintptr(16)*2
 				}
 				v5 = int32(1)
 				goto _8
 			_8:
 			}
 			if v9 && v5 != 0 {
 				(**(**VP8ModeScore)(__ccgo_up(bp + 1776))).FR = int64(int32(FLATNESS_PENALTY) * kNumBlocks)
 			} else {
 				(**(**VP8ModeScore)(__ccgo_up(bp + 1776))).FR = 0
 			}
 			// early-out check
 			SetRDScore(tls, lambda, bp+1776)
 			if best_mode >= 0 && (**(**VP8ModeScore)(__ccgo_up(bp + 1776))).Fscore >= (**(**VP8ModeScore)(__ccgo_up(bp + 880))).Fscore {
 				goto _1
 			}
 			// finish computing score
 			(**(**VP8ModeScore)(__ccgo_up(bp + 1776))).FR += int64(VP8GetCostLuma4(tls, it, bp+2656))
 			SetRDScore(tls, lambda, bp+1776)
 			if best_mode < 0 || (**(**VP8ModeScore)(__ccgo_up(bp + 1776))).Fscore < (**(**VP8ModeScore)(__ccgo_up(bp + 880))).Fscore {
 				CopyScore(tls, bp+880, bp+1776)
 				best_mode = mode
 				SwapPtr(tls, bp+1768, bp+1760)
 				libc.X__builtin___memcpy_chk(tls, bp+72+uintptr((*VP8EncIterator)(unsafe.Pointer(it)).Fi4)*32, bp+2656, uint64(32), ^__predefined_size_t(0))
 			}
 			goto _1
 		_1:
 			;
 			mode = mode + 1
 		}
 		SetRDScore(tls, (*VP8SegmentInfo)(unsafe.Pointer(dqm)).Flambda_mode, bp+880)
 		AddScore(tls, bp, bp+880)
 		if (**(**VP8ModeScore)(__ccgo_up(bp))).Fscore >= (*VP8ModeScore)(unsafe.Pointer(rd)).Fscore {
 			return 0
 		}
 		total_header_bits = total_header_bits + int32((**(**VP8ModeScore)(__ccgo_up(bp + 880))).FH) // <- equal to mode_costs[best_mode];
 		if total_header_bits > (*VP8Encoder)(unsafe.Pointer(enc)).Fmax_i4_header_bits {
 			return 0
 		}
 		// Copy selected samples if not in the right place already.
 		if **(**uintptr)(__ccgo_up(bp + 1760)) != best_blocks+uintptr(VP8Scan[(*VP8EncIterator)(unsafe.Pointer(it)).Fi4]) {
 			(*(*func(*libc.TLS, uintptr, uintptr))(unsafe.Pointer(&struct{ uintptr }{VP8Copy4x4})))(tls, **(**uintptr)(__ccgo_up(bp + 1760)), best_blocks+uintptr(VP8Scan[(*VP8EncIterator)(unsafe.Pointer(it)).Fi4]))
 		}
 		**(**uint8_t)(__ccgo_up(rd + 844 + uintptr((*VP8EncIterator)(unsafe.Pointer(it)).Fi4))) = libc.Uint8FromInt32(best_mode)
 		if (**(**VP8ModeScore)(__ccgo_up(bp + 880))).Fnz != 0 {
 			v4 = int32(1)
 		} else {
 			v4 = 0
 		}
 		v2 = v4
 		**(**int32)(__ccgo_up(it + 168 + uintptr((*VP8EncIterator)(unsafe.Pointer(it)).Fi4>>int32(2))*4)) = v2
 		**(**int32)(__ccgo_up(it + 132 + uintptr((*VP8EncIterator)(unsafe.Pointer(it)).Fi4&int32(3))*4)) = v2
 	}
 	// finalize state
 	CopyScore(tls, rd, bp)
 	VP8SetIntra4Mode(tls, it, rd+844)
 	SwapOut(tls, it)
 	libc.X__builtin___memcpy_chk(tls, rd+72, bp+72, uint64(512), ^__predefined_size_t(0))
 	return int32(1) // select intra4x4 over intra16x16
 }
 
 //------------------------------------------------------------------------------
 
 func PickBestUV(tls *libc.TLS, it uintptr, rd uintptr) {
 	bp := tls.Alloc(1776)
 	defer tls.Free(1776)
 	var dqm, dst0, src, v2 uintptr
 	var i, kNumBlocks, lambda, mode, score, v3, v4, v6 int32
 	var v8 bool
 	var _ /* dst at bp+8 */ uintptr
 	var _ /* rd_best at bp+16 */ VP8ModeScore
 	var _ /* rd_uv at bp+896 */ VP8ModeScore
 	var _ /* tmp_dst at bp+0 */ uintptr
 	_, _, _, _, _, _, _, _, _, _, _, _, _ = dqm, dst0, i, kNumBlocks, lambda, mode, score, src, v2, v3, v4, v6, v8
 	kNumBlocks = int32(8)
 	dqm = (*VP8EncIterator)(unsafe.Pointer(it)).Fenc + 608 + uintptr(int32(uint32(*(*uint8)(unsafe.Pointer((*VP8EncIterator)(unsafe.Pointer(it)).Fmb + 0))&0x60>>5)))*744
 	lambda = (*VP8SegmentInfo)(unsafe.Pointer(dqm)).Flambda_uv
 	src = (*VP8EncIterator)(unsafe.Pointer(it)).Fyuv_in + uintptr(libc.Int32FromInt32(U_OFF_ENC))
 	**(**uintptr)(__ccgo_up(bp)) = (*VP8EncIterator)(unsafe.Pointer(it)).Fyuv_out2 + uintptr(libc.Int32FromInt32(U_OFF_ENC)) // scratch buffer
 	dst0 = (*VP8EncIterator)(unsafe.Pointer(it)).Fyuv_out + uintptr(libc.Int32FromInt32(U_OFF_ENC))
 	**(**uintptr)(__ccgo_up(bp + 8)) = dst0
 	(*VP8ModeScore)(unsafe.Pointer(rd)).Fmode_uv = -int32(1)
 	InitScore(tls, bp+16)
 	mode = 0
 	for {
 		if !(mode < int32(NUM_PRED_MODES)) {
 			break
 		}
 		// Reconstruct
 		(**(**VP8ModeScore)(__ccgo_up(bp + 896))).Fnz = libc.Uint32FromInt32(ReconstructUV(tls, it, bp+896, **(**uintptr)(__ccgo_up(bp)), mode))
 		// Compute RD-score
 		(**(**VP8ModeScore)(__ccgo_up(bp + 896))).FD = int64((*(*func(*libc.TLS, uintptr, uintptr) int32)(unsafe.Pointer(&struct{ uintptr }{VP8SSE16x8})))(tls, src, **(**uintptr)(__ccgo_up(bp))))
 		(**(**VP8ModeScore)(__ccgo_up(bp + 896))).FSD = 0 // not calling TDisto here: it tends to flatten areas.
 		(**(**VP8ModeScore)(__ccgo_up(bp + 896))).FH = libc.Int64FromUint16(VP8FixedCostsUV[mode])
 		(**(**VP8ModeScore)(__ccgo_up(bp + 896))).FR = int64(VP8GetCostUV(tls, it, bp+896))
 		if v8 = mode > 0; v8 {
 			v2 = bp + 896 + 584
 			v3 = kNumBlocks
 			score = 0
 			for {
 				v4 = v3
 				v3 = v3 - 1
 				if !(v4 > libc.Int32FromInt32(0)) {
 					break
 				}
 				i = libc.Int32FromInt32(1)
 				for {
 					if !(i < libc.Int32FromInt32(16)) {
 						break
 					}
 					score = score + libc.BoolInt32(int32(**(**int16_t)(__ccgo_up(v2 + uintptr(i)*2))) != 0)
 					if score > int32(FLATNESS_LIMIT_UV) {
 						v6 = 0
 						goto _7
 					}
 					goto _5
 				_5:
 					;
 					i = i + 1
 				}
 				v2 = v2 + uintptr(16)*2
 			}
 			v6 = int32(1)
 			goto _7
 		_7:
 		}
 		if v8 && v6 != 0 {
 			(**(**VP8ModeScore)(__ccgo_up(bp + 896))).FR += int64(int32(FLATNESS_PENALTY) * kNumBlocks)
 		}
 		SetRDScore(tls, lambda, bp+896)
 		if mode == 0 || (**(**VP8ModeScore)(__ccgo_up(bp + 896))).Fscore < (**(**VP8ModeScore)(__ccgo_up(bp + 16))).Fscore {
 			CopyScore(tls, bp+16, bp+896)
 			(*VP8ModeScore)(unsafe.Pointer(rd)).Fmode_uv = mode
 			libc.X__builtin___memcpy_chk(tls, rd+584, bp+896+584, uint64(256), ^__predefined_size_t(0))
 			if (*VP8EncIterator)(unsafe.Pointer(it)).Ftop_derr != libc.UintptrFromInt32(0) {
 				libc.X__builtin___memcpy_chk(tls, rd+868, bp+896+868, uint64(6), ^__predefined_size_t(0))
 			}
 			SwapPtr(tls, bp+8, bp)
 		}
 		goto _1
 	_1:
 		;
 		mode = mode + 1
 	}
 	VP8SetIntraUVMode(tls, it, (*VP8ModeScore)(unsafe.Pointer(rd)).Fmode_uv)
 	AddScore(tls, rd, bp+16)
 	if **(**uintptr)(__ccgo_up(bp + 8)) != dst0 { // copy 16x8 block if needed
 		(*(*func(*libc.TLS, uintptr, uintptr))(unsafe.Pointer(&struct{ uintptr }{VP8Copy16x8})))(tls, **(**uintptr)(__ccgo_up(bp + 8)), dst0)
 	}
 	if (*VP8EncIterator)(unsafe.Pointer(it)).Ftop_derr != libc.UintptrFromInt32(0) { // store diffusion errors for next block
 		StoreDiffusionErrors(tls, it, rd)
 	}
 }
 
 //------------------------------------------------------------------------------
 // Final reconstruction and quantization.
 
 func SimpleQuantize(tls *libc.TLS, it uintptr, rd uintptr) {
 	var dst, enc, src uintptr
 	var is_i16, mode, nz int32
 	_, _, _, _, _, _ = dst, enc, is_i16, mode, nz, src
 	enc = (*VP8EncIterator)(unsafe.Pointer(it)).Fenc
 	is_i16 = libc.BoolInt32(int32(uint32(*(*uint8)(unsafe.Pointer((*VP8EncIterator)(unsafe.Pointer(it)).Fmb + 0))&0x3>>0)) == libc.Int32FromInt32(1))
 	nz = 0
 	if is_i16 != 0 {
 		nz = ReconstructIntra16(tls, it, rd, (*VP8EncIterator)(unsafe.Pointer(it)).Fyuv_out+uintptr(libc.Int32FromInt32(Y_OFF_ENC)), libc.Int32FromUint8(**(**uint8_t)(__ccgo_up((*VP8EncIterator)(unsafe.Pointer(it)).Fpreds))))
 	} else {
 		VP8IteratorStartI4(tls, it)
 		for cond := true; cond; cond = VP8IteratorRotateI4(tls, it, (*VP8EncIterator)(unsafe.Pointer(it)).Fyuv_out+uintptr(libc.Int32FromInt32(Y_OFF_ENC))) != 0 {
 			mode = libc.Int32FromUint8(**(**uint8_t)(__ccgo_up((*VP8EncIterator)(unsafe.Pointer(it)).Fpreds + uintptr((*VP8EncIterator)(unsafe.Pointer(it)).Fi4&int32(3)+(*VP8EncIterator)(unsafe.Pointer(it)).Fi4>>int32(2)*(*VP8Encoder)(unsafe.Pointer(enc)).Fpreds_w))))
 			src = (*VP8EncIterator)(unsafe.Pointer(it)).Fyuv_in + uintptr(libc.Int32FromInt32(Y_OFF_ENC)) + uintptr(VP8Scan[(*VP8EncIterator)(unsafe.Pointer(it)).Fi4])
 			dst = (*VP8EncIterator)(unsafe.Pointer(it)).Fyuv_out + uintptr(libc.Int32FromInt32(Y_OFF_ENC)) + uintptr(VP8Scan[(*VP8EncIterator)(unsafe.Pointer(it)).Fi4])
 			MakeIntra4Preds(tls, it)
 			nz = nz | ReconstructIntra4(tls, it, rd+72+uintptr((*VP8EncIterator)(unsafe.Pointer(it)).Fi4)*32, src, dst, mode)<<(*VP8EncIterator)(unsafe.Pointer(it)).Fi4
 		}
 	}
 	nz = nz | ReconstructUV(tls, it, rd, (*VP8EncIterator)(unsafe.Pointer(it)).Fyuv_out+uintptr(libc.Int32FromInt32(U_OFF_ENC)), int32(uint32(*(*uint8)(unsafe.Pointer((*VP8EncIterator)(unsafe.Pointer(it)).Fmb + 0))&0xc>>2)))
 	(*VP8ModeScore)(unsafe.Pointer(rd)).Fnz = libc.Uint32FromInt32(nz)
 }
 
 // C documentation
 //
 //	// Refine intra16/intra4 sub-modes based on distortion only (not rate).
 func RefineUsingDistortion(tls *libc.TLS, it uintptr, try_both_modes int32, refine_uv_mode int32, rd uintptr) {
 	bp := tls.Alloc(16)
 	defer tls.Free(16)
 	var best_i4_mode, best_mode, best_mode1, i, is_i16, lambda_d_i16, lambda_d_i4, lambda_d_uv, mode, nz, v5, v7 int32
 	var best_i4_score, best_score, best_uv_score, bit_limit, i4_bit_sum, score, score1, score2, score_i4 score_t
 	var dqm, mode_costs, ref, ref1, ref2, src1, src2, src3, tmp_dst, v3 uintptr
 	var v1 int64
 	var _ /* v at bp+0 */ uint32_t
 	_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = best_i4_mode, best_i4_score, best_mode, best_mode1, best_score, best_uv_score, bit_limit, dqm, i, i4_bit_sum, is_i16, lambda_d_i16, lambda_d_i4, lambda_d_uv, mode, mode_costs, nz, ref, ref1, ref2, score, score1, score2, score_i4, src1, src2, src3, tmp_dst, v1, v3, v5, v7
 	best_score = libc.Int64FromInt64(0x7fffffffffffff)
 	nz = 0
 	is_i16 = libc.BoolInt32(try_both_modes != 0 || int32(uint32(*(*uint8)(unsafe.Pointer((*VP8EncIterator)(unsafe.Pointer(it)).Fmb + 0))&0x3>>0)) == int32(1))
 	dqm = (*VP8EncIterator)(unsafe.Pointer(it)).Fenc + 608 + uintptr(int32(uint32(*(*uint8)(unsafe.Pointer((*VP8EncIterator)(unsafe.Pointer(it)).Fmb + 0))&0x60>>5)))*744
 	// Some empiric constants, of approximate order of magnitude.
 	lambda_d_i16 = int32(106)
 	lambda_d_i4 = int32(11)
 	lambda_d_uv = int32(120)
 	score_i4 = (*VP8SegmentInfo)(unsafe.Pointer(dqm)).Fi4_penalty
 	i4_bit_sum = 0
 	if try_both_modes != 0 {
 		v1 = int64((*VP8Encoder)(unsafe.Pointer((*VP8EncIterator)(unsafe.Pointer(it)).Fenc)).Fmb_header_limit)
 	} else {
 		v1 = libc.Int64FromInt64(0x7fffffffffffff)
 	}
 	bit_limit = v1   // no early-out allowed
 	if is_i16 != 0 { // First, evaluate Intra16 distortion
 		best_mode = -int32(1)
 		src1 = (*VP8EncIterator)(unsafe.Pointer(it)).Fyuv_in + uintptr(libc.Int32FromInt32(Y_OFF_ENC))
 		mode = 0
 		for {
 			if !(mode < int32(NUM_PRED_MODES)) {
 				break
 			}
 			ref = (*VP8EncIterator)(unsafe.Pointer(it)).Fyuv_p + uintptr(VP8I16ModeOffsets[mode])
 			score = int64((*(*func(*libc.TLS, uintptr, uintptr) int32)(unsafe.Pointer(&struct{ uintptr }{VP8SSE16x16})))(tls, src1, ref))*int64(RD_DISTO_MULT) + int64(libc.Int32FromUint16(VP8FixedCostsI16[mode])*lambda_d_i16)
 			if mode > 0 && libc.Int64FromUint16(VP8FixedCostsI16[mode]) > bit_limit {
 				goto _2
 			}
 			if score < best_score {
 				best_mode = mode
 				best_score = score
 			}
 			goto _2
 		_2:
 			;
 			mode = mode + 1
 		}
 		if (*VP8EncIterator)(unsafe.Pointer(it)).Fx == 0 || (*VP8EncIterator)(unsafe.Pointer(it)).Fy == 0 {
 			// avoid starting a checkerboard resonance from the border. See bug #432.
 			v3 = src1
 			**(**uint32_t)(__ccgo_up(bp)) = uint32(**(**uint8_t)(__ccgo_up(v3))) * uint32(0x01010101)
 			i = libc.Int32FromInt32(0)
 			for {
 				if !(i < libc.Int32FromInt32(16)) {
 					break
 				}
 				if libc.Xmemcmp(tls, v3+uintptr(0), bp, uint64(4)) != 0 || libc.Xmemcmp(tls, v3+uintptr(4), bp, uint64(4)) != 0 || libc.Xmemcmp(tls, v3+uintptr(8), bp, uint64(4)) != 0 || libc.Xmemcmp(tls, v3+uintptr(12), bp, uint64(4)) != 0 {
 					v5 = 0
 					goto _6
 				}
 				v3 = v3 + uintptr(BPS)
 				goto _4
 			_4:
 				;
 				i = i + 1
 			}
 			v5 = int32(1)
 			goto _6
 		_6:
 			if v5 != 0 {
 				if (*VP8EncIterator)(unsafe.Pointer(it)).Fx == 0 {
 					v7 = 0
 				} else {
 					v7 = int32(2)
 				}
 				best_mode = v7
 				try_both_modes = 0 // stick to i16
 			}
 		}
 		VP8SetIntra16Mode(tls, it, best_mode)
 		// we'll reconstruct later, if i16 mode actually gets selected
 	}
 	// Next, evaluate Intra4
 	if try_both_modes != 0 || !(is_i16 != 0) {
 		// We don't evaluate the rate here, but just account for it through a
 		// constant penalty (i4 mode usually needs more bits compared to i16).
 		is_i16 = 0
 		VP8IteratorStartI4(tls, it)
 		for cond := true; cond; cond = VP8IteratorRotateI4(tls, it, (*VP8EncIterator)(unsafe.Pointer(it)).Fyuv_out2+uintptr(libc.Int32FromInt32(Y_OFF_ENC))) != 0 {
 			best_i4_mode = -int32(1)
 			best_i4_score = libc.Int64FromInt64(0x7fffffffffffff)
 			src2 = (*VP8EncIterator)(unsafe.Pointer(it)).Fyuv_in + uintptr(libc.Int32FromInt32(Y_OFF_ENC)) + uintptr(VP8Scan[(*VP8EncIterator)(unsafe.Pointer(it)).Fi4])
 			mode_costs = GetCostModeI4(tls, it, rd+844)
 			MakeIntra4Preds(tls, it)
 			mode = 0
 			for {
 				if !(mode < int32(NUM_BMODES)) {
 					break
 				}
 				ref1 = (*VP8EncIterator)(unsafe.Pointer(it)).Fyuv_p + uintptr(VP8I4ModeOffsets[mode])
 				score1 = int64((*(*func(*libc.TLS, uintptr, uintptr) int32)(unsafe.Pointer(&struct{ uintptr }{VP8SSE4x4})))(tls, src2, ref1)*int32(RD_DISTO_MULT) + libc.Int32FromUint16(**(**uint16_t)(__ccgo_up(mode_costs + uintptr(mode)*2)))*lambda_d_i4)
 				if score1 < best_i4_score {
 					best_i4_mode = mode
 					best_i4_score = score1
 				}
 				goto _8
 			_8:
 				;
 				mode = mode + 1
 			}
 			i4_bit_sum = i4_bit_sum + libc.Int64FromUint16(**(**uint16_t)(__ccgo_up(mode_costs + uintptr(best_i4_mode)*2)))
 			**(**uint8_t)(__ccgo_up(rd + 844 + uintptr((*VP8EncIterator)(unsafe.Pointer(it)).Fi4))) = libc.Uint8FromInt32(best_i4_mode)
 			score_i4 = score_i4 + best_i4_score
 			if score_i4 >= best_score || i4_bit_sum > bit_limit {
 				// Intra4 won't be better than Intra16. Bail out and pick Intra16.
 				is_i16 = int32(1)
 				break
 			} else { // reconstruct partial block inside yuv_out2 buffer
 				tmp_dst = (*VP8EncIterator)(unsafe.Pointer(it)).Fyuv_out2 + uintptr(libc.Int32FromInt32(Y_OFF_ENC)) + uintptr(VP8Scan[(*VP8EncIterator)(unsafe.Pointer(it)).Fi4])
 				nz = nz | ReconstructIntra4(tls, it, rd+72+uintptr((*VP8EncIterator)(unsafe.Pointer(it)).Fi4)*32, src2, tmp_dst, best_i4_mode)<<(*VP8EncIterator)(unsafe.Pointer(it)).Fi4
 			}
 		}
 	}
 	// Final reconstruction, depending on which mode is selected.
 	if !(is_i16 != 0) {
 		VP8SetIntra4Mode(tls, it, rd+844)
 		SwapOut(tls, it)
 		best_score = score_i4
 	} else {
 		nz = ReconstructIntra16(tls, it, rd, (*VP8EncIterator)(unsafe.Pointer(it)).Fyuv_out+uintptr(libc.Int32FromInt32(Y_OFF_ENC)), libc.Int32FromUint8(**(**uint8_t)(__ccgo_up((*VP8EncIterator)(unsafe.Pointer(it)).Fpreds))))
 	}
 	// ... and UV!
 	if refine_uv_mode != 0 {
 		best_mode1 = -int32(1)
 		best_uv_score = libc.Int64FromInt64(0x7fffffffffffff)
 		src3 = (*VP8EncIterator)(unsafe.Pointer(it)).Fyuv_in + uintptr(libc.Int32FromInt32(U_OFF_ENC))
 		mode = 0
 		for {
 			if !(mode < int32(NUM_PRED_MODES)) {
 				break
 			}
 			ref2 = (*VP8EncIterator)(unsafe.Pointer(it)).Fyuv_p + uintptr(VP8UVModeOffsets[mode])
 			score2 = int64((*(*func(*libc.TLS, uintptr, uintptr) int32)(unsafe.Pointer(&struct{ uintptr }{VP8SSE16x8})))(tls, src3, ref2)*int32(RD_DISTO_MULT) + libc.Int32FromUint16(VP8FixedCostsUV[mode])*lambda_d_uv)
 			if score2 < best_uv_score {
 				best_mode1 = mode
 				best_uv_score = score2
 			}
 			goto _9
 		_9:
 			;
 			mode = mode + 1
 		}
 		VP8SetIntraUVMode(tls, it, best_mode1)
 	}
 	nz = nz | ReconstructUV(tls, it, rd, (*VP8EncIterator)(unsafe.Pointer(it)).Fyuv_out+uintptr(libc.Int32FromInt32(U_OFF_ENC)), int32(uint32(*(*uint8)(unsafe.Pointer((*VP8EncIterator)(unsafe.Pointer(it)).Fmb + 0))&0xc>>2)))
 	(*VP8ModeScore)(unsafe.Pointer(rd)).Fnz = libc.Uint32FromInt32(nz)
 	(*VP8ModeScore)(unsafe.Pointer(rd)).Fscore = best_score
 }
 
 //------------------------------------------------------------------------------
 // Entry point
 
 func VP8Decimate(tls *libc.TLS, it uintptr, rd uintptr, rd_opt VP8RDLevel) (r int32) {
 	var is_skipped, method int32
 	_, _ = is_skipped, method
 	method = (*VP8Encoder)(unsafe.Pointer((*VP8EncIterator)(unsafe.Pointer(it)).Fenc)).Fmethod
 	InitScore(tls, rd)
 	// We can perform predictions for Luma16x16 and Chroma8x8 already.
 	// Luma4x4 predictions needs to be done as-we-go.
 	VP8MakeLuma16Preds(tls, it)
 	VP8MakeChroma8Preds(tls, it)
 	if rd_opt > int32(RD_OPT_NONE) {
 		(*VP8EncIterator)(unsafe.Pointer(it)).Fdo_trellis = libc.BoolInt32(rd_opt >= int32(RD_OPT_TRELLIS_ALL))
 		PickBestIntra16(tls, it, rd)
 		if method >= int32(2) {
 			PickBestIntra4(tls, it, rd)
 		}
 		PickBestUV(tls, it, rd)
 		if rd_opt == int32(RD_OPT_TRELLIS) { // finish off with trellis-optim now
 			(*VP8EncIterator)(unsafe.Pointer(it)).Fdo_trellis = int32(1)
 			SimpleQuantize(tls, it, rd)
 		}
 	} else {
 		// At this point we have heuristically decided intra16 / intra4.
 		// For method >= 2, pick the best intra4/intra16 based on SSE (~tad slower).
 		// For method <= 1, we don't re-examine the decision but just go ahead with
 		// quantization/reconstruction.
 		RefineUsingDistortion(tls, it, libc.BoolInt32(method >= int32(2)), libc.BoolInt32(method >= int32(1)), rd)
 	}
 	is_skipped = libc.BoolInt32((*VP8ModeScore)(unsafe.Pointer(rd)).Fnz == uint32(0))
 	VP8SetSkip(tls, it, is_skipped)
 	return is_skipped
 }
 
 const ARGB_BLACK2 = 0xff000000
 const VP8_SIGNATURE1 = 10289450
 const __FLT_MIN__8 = 1.17549435082228750796873653722224568e-38
 
 //------------------------------------------------------------------------------
 // Helper functions
 
 func IsVP8XNeeded(tls *libc.TLS, enc uintptr) (r int32) {
 	return libc.BoolInt32(!!((*VP8Encoder)(unsafe.Pointer(enc)).Fhas_alpha != 0)) // Currently the only case when VP8X is needed.
 	// This could change in the future.
 }
 
 func PutPaddingByte(tls *libc.TLS, pic uintptr) (r int32) {
 	bp := tls.Alloc(16)
 	defer tls.Free(16)
 	var _ /* pad_byte at bp+0 */ [1]uint8_t
 	**(**[1]uint8_t)(__ccgo_up(bp)) = [1]uint8_t{}
 	return libc.BoolInt32(!!((*(*func(*libc.TLS, uintptr, size_t, uintptr) int32)(unsafe.Pointer(&struct{ uintptr }{(*WebPPicture)(unsafe.Pointer(pic)).Fwriter})))(tls, bp, uint64(1), pic) != 0))
 }
 
 //------------------------------------------------------------------------------
 // Writers for header's various pieces (in order of appearance)
 
 func PutRIFFHeader(tls *libc.TLS, enc uintptr, riff_size size_t) (r WebPEncodingError1) {
 	bp := tls.Alloc(16)
 	defer tls.Free(16)
 	var pic, v1, v3, v5 uintptr
 	var v2 uint32_t
 	var v4, v6 int32
 	var _ /* riff at bp+0 */ [12]uint8_t
 	_, _, _, _, _, _, _ = pic, v1, v2, v3, v4, v5, v6
 	pic = (*VP8Encoder)(unsafe.Pointer(enc)).Fpic
 	**(**[12]uint8_t)(__ccgo_up(bp)) = [12]uint8_t{
 		0:  uint8('R'),
 		1:  uint8('I'),
 		2:  uint8('F'),
 		3:  uint8('F'),
 		8:  uint8('W'),
 		9:  uint8('E'),
 		10: uint8('B'),
 		11: uint8('P'),
 	}
 	v1 = bp + uintptr(TAG_SIZE)
 	v2 = uint32(riff_size)
 	v3 = v1
 	v4 = libc.Int32FromUint32(v2 & libc.Uint32FromInt32(0xffff))
 	**(**uint8_t)(__ccgo_up(v3)) = libc.Uint8FromInt32(v4 >> 0 & int32(0xff))
 	**(**uint8_t)(__ccgo_up(v3 + 1)) = libc.Uint8FromInt32(v4 >> int32(8) & int32(0xff))
 	v5 = v1 + uintptr(2)
 	v6 = libc.Int32FromUint32(v2 >> libc.Int32FromInt32(16))
 	**(**uint8_t)(__ccgo_up(v5)) = libc.Uint8FromInt32(v6 >> 0 & int32(0xff))
 	**(**uint8_t)(__ccgo_up(v5 + 1)) = libc.Uint8FromInt32(v6 >> int32(8) & int32(0xff))
 	if !((*(*func(*libc.TLS, uintptr, size_t, uintptr) int32)(unsafe.Pointer(&struct{ uintptr }{(*WebPPicture)(unsafe.Pointer(pic)).Fwriter})))(tls, bp, uint64(12), pic) != 0) {
 		return int32(VP8_ENC_ERROR_BAD_WRITE)
 	}
 	return int32(VP8_ENC_OK)
 }
 
 func PutVP8XHeader(tls *libc.TLS, enc uintptr) (r WebPEncodingError1) {
 	bp := tls.Alloc(32)
 	defer tls.Free(32)
 	var flags, v2 uint32_t
 	var pic, v1, v3, v5 uintptr
 	var v4, v6 int32
 	var _ /* vp8x at bp+0 */ [18]uint8_t
 	_, _, _, _, _, _, _, _ = flags, pic, v1, v2, v3, v4, v5, v6
 	pic = (*VP8Encoder)(unsafe.Pointer(enc)).Fpic
 	**(**[18]uint8_t)(__ccgo_up(bp)) = [18]uint8_t{
 		0: uint8('V'),
 		1: uint8('P'),
 		2: uint8('8'),
 		3: uint8('X'),
 	}
 	flags = uint32(0)
 	if (*VP8Encoder)(unsafe.Pointer(enc)).Fhas_alpha != 0 {
 		flags = flags | uint32(ALPHA_FLAG)
 	}
 	v1 = bp + uintptr(TAG_SIZE)
 	v2 = uint32(VP8X_CHUNK_SIZE)
 	v3 = v1
 	v4 = libc.Int32FromUint32(v2 & libc.Uint32FromInt32(0xffff))
 	**(**uint8_t)(__ccgo_up(v3)) = libc.Uint8FromInt32(v4 >> 0 & int32(0xff))
 	**(**uint8_t)(__ccgo_up(v3 + 1)) = libc.Uint8FromInt32(v4 >> int32(8) & int32(0xff))
 	v5 = v1 + uintptr(2)
 	v6 = libc.Int32FromUint32(v2 >> libc.Int32FromInt32(16))
 	**(**uint8_t)(__ccgo_up(v5)) = libc.Uint8FromInt32(v6 >> 0 & int32(0xff))
 	**(**uint8_t)(__ccgo_up(v5 + 1)) = libc.Uint8FromInt32(v6 >> int32(8) & int32(0xff))
 	v1 = bp + uintptr(CHUNK_HEADER_SIZE)
 	v2 = flags
 	v3 = v1
 	v4 = libc.Int32FromUint32(v2 & libc.Uint32FromInt32(0xffff))
 	**(**uint8_t)(__ccgo_up(v3)) = libc.Uint8FromInt32(v4 >> 0 & int32(0xff))
 	**(**uint8_t)(__ccgo_up(v3 + 1)) = libc.Uint8FromInt32(v4 >> int32(8) & int32(0xff))
 	v5 = v1 + uintptr(2)
 	v6 = libc.Int32FromUint32(v2 >> libc.Int32FromInt32(16))
 	**(**uint8_t)(__ccgo_up(v5)) = libc.Uint8FromInt32(v6 >> 0 & int32(0xff))
 	**(**uint8_t)(__ccgo_up(v5 + 1)) = libc.Uint8FromInt32(v6 >> int32(8) & int32(0xff))
 	v1 = bp + uintptr(CHUNK_HEADER_SIZE) + uintptr(4)
 	v4 = (*WebPPicture)(unsafe.Pointer(pic)).Fwidth - int32(1)
 	v3 = v1
 	v6 = v4 & int32(0xffff)
 	**(**uint8_t)(__ccgo_up(v3)) = libc.Uint8FromInt32(v6 >> 0 & int32(0xff))
 	**(**uint8_t)(__ccgo_up(v3 + 1)) = libc.Uint8FromInt32(v6 >> int32(8) & int32(0xff))
 	**(**uint8_t)(__ccgo_up(v1 + 2)) = libc.Uint8FromInt32(v4 >> int32(16) & int32(0xff))
 	v1 = bp + uintptr(CHUNK_HEADER_SIZE) + uintptr(7)
 	v4 = (*WebPPicture)(unsafe.Pointer(pic)).Fheight - int32(1)
 	v3 = v1
 	v6 = v4 & int32(0xffff)
 	**(**uint8_t)(__ccgo_up(v3)) = libc.Uint8FromInt32(v6 >> 0 & int32(0xff))
 	**(**uint8_t)(__ccgo_up(v3 + 1)) = libc.Uint8FromInt32(v6 >> int32(8) & int32(0xff))
 	**(**uint8_t)(__ccgo_up(v1 + 2)) = libc.Uint8FromInt32(v4 >> int32(16) & int32(0xff))
 	if !((*(*func(*libc.TLS, uintptr, size_t, uintptr) int32)(unsafe.Pointer(&struct{ uintptr }{(*WebPPicture)(unsafe.Pointer(pic)).Fwriter})))(tls, bp, uint64(18), pic) != 0) {
 		return int32(VP8_ENC_ERROR_BAD_WRITE)
 	}
 	return int32(VP8_ENC_OK)
 }
 
 func PutAlphaChunk(tls *libc.TLS, enc uintptr) (r WebPEncodingError1) {
 	bp := tls.Alloc(16)
 	defer tls.Free(16)
 	var pic, v1, v3, v5 uintptr
 	var v2 uint32_t
 	var v4, v6 int32
 	var _ /* alpha_chunk_hdr at bp+0 */ [8]uint8_t
 	_, _, _, _, _, _, _ = pic, v1, v2, v3, v4, v5, v6
 	pic = (*VP8Encoder)(unsafe.Pointer(enc)).Fpic
 	**(**[8]uint8_t)(__ccgo_up(bp)) = [8]uint8_t{
 		0: uint8('A'),
 		1: uint8('L'),
 		2: uint8('P'),
 		3: uint8('H'),
 	}
 	// Alpha chunk header.
 	v1 = bp + uintptr(TAG_SIZE)
 	v2 = (*VP8Encoder)(unsafe.Pointer(enc)).Falpha_data_size
 	v3 = v1
 	v4 = libc.Int32FromUint32(v2 & libc.Uint32FromInt32(0xffff))
 	**(**uint8_t)(__ccgo_up(v3)) = libc.Uint8FromInt32(v4 >> 0 & int32(0xff))
 	**(**uint8_t)(__ccgo_up(v3 + 1)) = libc.Uint8FromInt32(v4 >> int32(8) & int32(0xff))
 	v5 = v1 + uintptr(2)
 	v6 = libc.Int32FromUint32(v2 >> libc.Int32FromInt32(16))
 	**(**uint8_t)(__ccgo_up(v5)) = libc.Uint8FromInt32(v6 >> 0 & int32(0xff))
 	**(**uint8_t)(__ccgo_up(v5 + 1)) = libc.Uint8FromInt32(v6 >> int32(8) & int32(0xff))
 	if !((*(*func(*libc.TLS, uintptr, size_t, uintptr) int32)(unsafe.Pointer(&struct{ uintptr }{(*WebPPicture)(unsafe.Pointer(pic)).Fwriter})))(tls, bp, uint64(8), pic) != 0) {
 		return int32(VP8_ENC_ERROR_BAD_WRITE)
 	}
 	// Alpha chunk data.
 	if !((*(*func(*libc.TLS, uintptr, size_t, uintptr) int32)(unsafe.Pointer(&struct{ uintptr }{(*WebPPicture)(unsafe.Pointer(pic)).Fwriter})))(tls, (*VP8Encoder)(unsafe.Pointer(enc)).Falpha_data, uint64((*VP8Encoder)(unsafe.Pointer(enc)).Falpha_data_size), pic) != 0) {
 		return int32(VP8_ENC_ERROR_BAD_WRITE)
 	}
 	// Padding.
 	if (*VP8Encoder)(unsafe.Pointer(enc)).Falpha_data_size&uint32(1) != 0 && !(PutPaddingByte(tls, pic) != 0) {
 		return int32(VP8_ENC_ERROR_BAD_WRITE)
 	}
 	return int32(VP8_ENC_OK)
 }
 
 func PutVP8Header(tls *libc.TLS, pic uintptr, vp8_size size_t) (r WebPEncodingError1) {
 	bp := tls.Alloc(16)
 	defer tls.Free(16)
 	var v1, v3, v5 uintptr
 	var v2 uint32_t
 	var v4, v6 int32
 	var _ /* vp8_chunk_hdr at bp+0 */ [8]uint8_t
 	_, _, _, _, _, _ = v1, v2, v3, v4, v5, v6
 	**(**[8]uint8_t)(__ccgo_up(bp)) = [8]uint8_t{
 		0: uint8('V'),
 		1: uint8('P'),
 		2: uint8('8'),
 		3: uint8(' '),
 	}
 	v1 = bp + uintptr(TAG_SIZE)
 	v2 = uint32(vp8_size)
 	v3 = v1
 	v4 = libc.Int32FromUint32(v2 & libc.Uint32FromInt32(0xffff))
 	**(**uint8_t)(__ccgo_up(v3)) = libc.Uint8FromInt32(v4 >> 0 & int32(0xff))
 	**(**uint8_t)(__ccgo_up(v3 + 1)) = libc.Uint8FromInt32(v4 >> int32(8) & int32(0xff))
 	v5 = v1 + uintptr(2)
 	v6 = libc.Int32FromUint32(v2 >> libc.Int32FromInt32(16))
 	**(**uint8_t)(__ccgo_up(v5)) = libc.Uint8FromInt32(v6 >> 0 & int32(0xff))
 	**(**uint8_t)(__ccgo_up(v5 + 1)) = libc.Uint8FromInt32(v6 >> int32(8) & int32(0xff))
 	if !((*(*func(*libc.TLS, uintptr, size_t, uintptr) int32)(unsafe.Pointer(&struct{ uintptr }{(*WebPPicture)(unsafe.Pointer(pic)).Fwriter})))(tls, bp, uint64(8), pic) != 0) {
 		return int32(VP8_ENC_ERROR_BAD_WRITE)
 	}
 	return int32(VP8_ENC_OK)
 }
 
 func PutVP8FrameHeader(tls *libc.TLS, pic uintptr, profile int32, size0 size_t) (r WebPEncodingError1) {
 	bp := tls.Alloc(16)
 	defer tls.Free(16)
 	var bits uint32_t
 	var _ /* vp8_frm_hdr at bp+0 */ [10]uint8_t
 	_ = bits
 	if size0 >= libc.Uint64FromInt32(libc.Int32FromInt32(1)<<libc.Int32FromInt32(19)) { // partition #0 is too big to fit
 		return int32(VP8_ENC_ERROR_PARTITION0_OVERFLOW)
 	}
 	// Paragraph 9.1.
 	bits = libc.Uint32FromInt32(0|profile<<int32(1)|libc.Int32FromInt32(1)<<libc.Int32FromInt32(4)) | uint32(size0)<<libc.Int32FromInt32(5) // partition length (19b)
 	(**(**[10]uint8_t)(__ccgo_up(bp)))[0] = uint8(bits >> libc.Int32FromInt32(0) & uint32(0xff))
 	(**(**[10]uint8_t)(__ccgo_up(bp)))[int32(1)] = uint8(bits >> libc.Int32FromInt32(8) & uint32(0xff))
 	(**(**[10]uint8_t)(__ccgo_up(bp)))[int32(2)] = uint8(bits >> libc.Int32FromInt32(16) & uint32(0xff))
 	// signature
 	(**(**[10]uint8_t)(__ccgo_up(bp)))[int32(3)] = libc.Uint8FromInt32(libc.Int32FromInt32(VP8_SIGNATURE1) >> libc.Int32FromInt32(16) & libc.Int32FromInt32(0xff))
 	(**(**[10]uint8_t)(__ccgo_up(bp)))[int32(4)] = libc.Uint8FromInt32(libc.Int32FromInt32(VP8_SIGNATURE1) >> libc.Int32FromInt32(8) & libc.Int32FromInt32(0xff))
 	(**(**[10]uint8_t)(__ccgo_up(bp)))[int32(5)] = libc.Uint8FromInt32(libc.Int32FromInt32(VP8_SIGNATURE1) >> libc.Int32FromInt32(0) & libc.Int32FromInt32(0xff))
 	// dimensions
 	(**(**[10]uint8_t)(__ccgo_up(bp)))[int32(6)] = libc.Uint8FromInt32((*WebPPicture)(unsafe.Pointer(pic)).Fwidth & int32(0xff))
 	(**(**[10]uint8_t)(__ccgo_up(bp)))[int32(7)] = libc.Uint8FromInt32((*WebPPicture)(unsafe.Pointer(pic)).Fwidth >> int32(8))
 	(**(**[10]uint8_t)(__ccgo_up(bp)))[int32(8)] = libc.Uint8FromInt32((*WebPPicture)(unsafe.Pointer(pic)).Fheight & int32(0xff))
 	(**(**[10]uint8_t)(__ccgo_up(bp)))[int32(9)] = libc.Uint8FromInt32((*WebPPicture)(unsafe.Pointer(pic)).Fheight >> int32(8))
 	if !((*(*func(*libc.TLS, uintptr, size_t, uintptr) int32)(unsafe.Pointer(&struct{ uintptr }{(*WebPPicture)(unsafe.Pointer(pic)).Fwriter})))(tls, bp, uint64(10), pic) != 0) {
 		return int32(VP8_ENC_ERROR_BAD_WRITE)
 	}
 	return int32(VP8_ENC_OK)
 }
 
 // C documentation
 //
 //	// WebP Headers.
 func PutWebPHeaders(tls *libc.TLS, enc uintptr, size0 size_t, vp8_size size_t, riff_size size_t) (r int32) {
 	var err WebPEncodingError1
 	var pic uintptr
 	_, _ = err, pic
 	pic = (*VP8Encoder)(unsafe.Pointer(enc)).Fpic
 	err = int32(VP8_ENC_OK)
 	// RIFF header.
 	err = PutRIFFHeader(tls, enc, riff_size)
 	if err != int32(VP8_ENC_OK) {
 		goto Error
 	}
 	// VP8X.
 	if IsVP8XNeeded(tls, enc) != 0 {
 		err = PutVP8XHeader(tls, enc)
 		if err != int32(VP8_ENC_OK) {
 			goto Error
 		}
 	}
 	// Alpha.
 	if (*VP8Encoder)(unsafe.Pointer(enc)).Fhas_alpha != 0 {
 		err = PutAlphaChunk(tls, enc)
 		if err != int32(VP8_ENC_OK) {
 			goto Error
 		}
 	}
 	// VP8 header.
 	err = PutVP8Header(tls, pic, vp8_size)
 	if err != int32(VP8_ENC_OK) {
 		goto Error
 	}
 	// VP8 frame header.
 	err = PutVP8FrameHeader(tls, pic, (*VP8Encoder)(unsafe.Pointer(enc)).Fprofile, size0)
 	if err != int32(VP8_ENC_OK) {
 		goto Error
 	}
 	// All OK.
 	return int32(1)
 	// Error.
 	goto Error
 Error:
 	;
 	return WebPEncodingSetError(tls, pic, err)
 	return r
 }
 
 // C documentation
 //
 //	// Segmentation header
 func PutSegmentHeader(tls *libc.TLS, bw uintptr, enc uintptr) {
 	var hdr, proba uintptr
 	var s, update_data int32
 	_, _, _, _ = hdr, proba, s, update_data
 	hdr = enc + 32
 	proba = enc + 3616
 	if VP8PutBitUniform(tls, bw, libc.BoolInt32((*VP8EncSegmentHeader)(unsafe.Pointer(hdr)).Fnum_segments > int32(1))) != 0 {
 		// We always 'update' the quant and filter strength values
 		update_data = int32(1)
 		VP8PutBitUniform(tls, bw, (*VP8EncSegmentHeader)(unsafe.Pointer(hdr)).Fupdate_map)
 		if VP8PutBitUniform(tls, bw, update_data) != 0 {
 			// we always use absolute values, not relative ones
 			VP8PutBitUniform(tls, bw, int32(1)) // (segment_feature_mode = 1. Paragraph 9.3.)
 			s = 0
 			for {
 				if !(s < int32(NUM_MB_SEGMENTS)) {
 					break
 				}
 				VP8PutSignedBits(tls, bw, (**(**VP8SegmentInfo)(__ccgo_up(enc + 608 + uintptr(s)*744))).Fquant, int32(7))
 				goto _1
 			_1:
 				;
 				s = s + 1
 			}
 			s = 0
 			for {
 				if !(s < int32(NUM_MB_SEGMENTS)) {
 					break
 				}
 				VP8PutSignedBits(tls, bw, (**(**VP8SegmentInfo)(__ccgo_up(enc + 608 + uintptr(s)*744))).Ffstrength, int32(6))
 				goto _2
 			_2:
 				;
 				s = s + 1
 			}
 		}
 		if (*VP8EncSegmentHeader)(unsafe.Pointer(hdr)).Fupdate_map != 0 {
 			s = 0
 			for {
 				if !(s < int32(3)) {
 					break
 				}
 				if VP8PutBitUniform(tls, bw, libc.BoolInt32(uint32(**(**uint8_t)(__ccgo_up(proba + uintptr(s)))) != uint32(255))) != 0 {
 					VP8PutBits(tls, bw, uint32(**(**uint8_t)(__ccgo_up(proba + uintptr(s)))), int32(8))
 				}
 				goto _3
 			_3:
 				;
 				s = s + 1
 			}
 		}
 	}
 }
 
 // C documentation
 //
 //	// Filtering parameters header
 func PutFilterHeader(tls *libc.TLS, bw uintptr, hdr uintptr) {
 	var need_update, use_lf_delta int32
 	_, _ = need_update, use_lf_delta
 	use_lf_delta = libc.BoolInt32((*VP8EncFilterHeader)(unsafe.Pointer(hdr)).Fi4x4_lf_delta != libc.Int32FromInt32(0))
 	VP8PutBitUniform(tls, bw, (*VP8EncFilterHeader)(unsafe.Pointer(hdr)).Fsimple)
 	VP8PutBits(tls, bw, libc.Uint32FromInt32((*VP8EncFilterHeader)(unsafe.Pointer(hdr)).Flevel), int32(6))
 	VP8PutBits(tls, bw, libc.Uint32FromInt32((*VP8EncFilterHeader)(unsafe.Pointer(hdr)).Fsharpness), int32(3))
 	if VP8PutBitUniform(tls, bw, use_lf_delta) != 0 {
 		// '0' is the default value for i4x4_lf_delta at frame #0.
 		need_update = libc.BoolInt32((*VP8EncFilterHeader)(unsafe.Pointer(hdr)).Fi4x4_lf_delta != libc.Int32FromInt32(0))
 		if VP8PutBitUniform(tls, bw, need_update) != 0 {
 			// we don't use ref_lf_delta => emit four 0 bits
 			VP8PutBits(tls, bw, uint32(0), int32(4))
 			// we use mode_lf_delta for i4x4
 			VP8PutSignedBits(tls, bw, (*VP8EncFilterHeader)(unsafe.Pointer(hdr)).Fi4x4_lf_delta, int32(6))
 			VP8PutBits(tls, bw, uint32(0), int32(3)) // all others unused
 		}
 	}
 }
 
 // C documentation
 //
 //	// Nominal quantization parameters
 func PutQuant(tls *libc.TLS, bw uintptr, enc uintptr) {
 	VP8PutBits(tls, bw, libc.Uint32FromInt32((*VP8Encoder)(unsafe.Pointer(enc)).Fbase_quant), int32(7))
 	VP8PutSignedBits(tls, bw, (*VP8Encoder)(unsafe.Pointer(enc)).Fdq_y1_dc, int32(4))
 	VP8PutSignedBits(tls, bw, (*VP8Encoder)(unsafe.Pointer(enc)).Fdq_y2_dc, int32(4))
 	VP8PutSignedBits(tls, bw, (*VP8Encoder)(unsafe.Pointer(enc)).Fdq_y2_ac, int32(4))
 	VP8PutSignedBits(tls, bw, (*VP8Encoder)(unsafe.Pointer(enc)).Fdq_uv_dc, int32(4))
 	VP8PutSignedBits(tls, bw, (*VP8Encoder)(unsafe.Pointer(enc)).Fdq_uv_ac, int32(4))
 }
 
 // C documentation
 //
 //	// Partition sizes
 func EmitPartitionsSize(tls *libc.TLS, enc uintptr, pic uintptr) (r int32) {
 	bp := tls.Alloc(32)
 	defer tls.Free(32)
 	var p int32
 	var part_size, v2 size_t
 	var _ /* buf at bp+0 */ [21]uint8_t
 	_, _, _ = p, part_size, v2
 	p = 0
 	for {
 		if !(p < (*VP8Encoder)(unsafe.Pointer(enc)).Fnum_parts-int32(1)) {
 			break
 		}
 		v2 = (*VP8BitWriter)(unsafe.Pointer(enc + 112 + uintptr(p)*48)).Fpos
 		goto _3
 	_3:
 		part_size = v2
 		if part_size >= libc.Uint64FromInt32(libc.Int32FromInt32(1)<<libc.Int32FromInt32(24)) {
 			return WebPEncodingSetError(tls, pic, int32(VP8_ENC_ERROR_PARTITION_OVERFLOW))
 		}
 		(**(**[21]uint8_t)(__ccgo_up(bp)))[int32(3)*p+0] = uint8(part_size >> libc.Int32FromInt32(0) & uint64(0xff))
 		(**(**[21]uint8_t)(__ccgo_up(bp)))[int32(3)*p+int32(1)] = uint8(part_size >> libc.Int32FromInt32(8) & uint64(0xff))
 		(**(**[21]uint8_t)(__ccgo_up(bp)))[int32(3)*p+int32(2)] = uint8(part_size >> libc.Int32FromInt32(16) & uint64(0xff))
 		goto _1
 	_1:
 		;
 		p = p + 1
 	}
 	if p != 0 && !((*(*func(*libc.TLS, uintptr, size_t, uintptr) int32)(unsafe.Pointer(&struct{ uintptr }{(*WebPPicture)(unsafe.Pointer(pic)).Fwriter})))(tls, bp, libc.Uint64FromInt32(int32(3)*p), pic) != 0) {
 		return WebPEncodingSetError(tls, pic, int32(VP8_ENC_ERROR_BAD_WRITE))
 	}
 	return int32(1)
 }
 
 //------------------------------------------------------------------------------
 
 func GeneratePartition0(tls *libc.TLS, enc uintptr) (r int32) {
 	var bw1, v1 uintptr
 	var mb_size, v4, v5, v6 int32
 	var nb_bits, pos1, pos2, pos3, v2 uint64_t
 	_, _, _, _, _, _, _, _, _, _, _ = bw1, mb_size, nb_bits, pos1, pos2, pos3, v1, v2, v4, v5, v6
 	bw1 = enc + 64
 	mb_size = (*VP8Encoder)(unsafe.Pointer(enc)).Fmb_w * (*VP8Encoder)(unsafe.Pointer(enc)).Fmb_h
 	v1 = bw1
 	nb_bits = libc.Uint64FromInt32(int32(8) + (*VP8BitWriter)(unsafe.Pointer(v1)).Fnb_bits)
 	v2 = uint64(((*VP8BitWriter)(unsafe.Pointer(v1)).Fpos+libc.Uint64FromInt32((*VP8BitWriter)(unsafe.Pointer(v1)).Frun))*uint64(8)) + nb_bits
 	goto _3
 _3:
 	pos1 = v2
 	if !(VP8BitWriterInit(tls, bw1, libc.Uint64FromInt32(mb_size*int32(7)/int32(8))) != 0) { // ~7 bits per macroblock
 		return WebPEncodingSetError(tls, (*VP8Encoder)(unsafe.Pointer(enc)).Fpic, int32(VP8_ENC_ERROR_OUT_OF_MEMORY))
 	}
 	VP8PutBitUniform(tls, bw1, 0) // colorspace
 	VP8PutBitUniform(tls, bw1, 0) // clamp type
 	PutSegmentHeader(tls, bw1, enc)
 	PutFilterHeader(tls, bw1, enc+16)
 	if (*VP8Encoder)(unsafe.Pointer(enc)).Fnum_parts == int32(8) {
 		v4 = int32(3)
 	} else {
 		if (*VP8Encoder)(unsafe.Pointer(enc)).Fnum_parts == int32(4) {
 			v5 = int32(2)
 		} else {
 			if (*VP8Encoder)(unsafe.Pointer(enc)).Fnum_parts == int32(2) {
 				v6 = int32(1)
 			} else {
 				v6 = 0
 			}
 			v5 = v6
 		}
 		v4 = v5
 	}
 	VP8PutBits(tls, bw1, libc.Uint32FromInt32(v4), int32(2))
 	PutQuant(tls, bw1, enc)
 	VP8PutBitUniform(tls, bw1, 0) // no proba update
 	VP8WriteProbas(tls, bw1, enc+3616)
 	v1 = bw1
 	nb_bits = libc.Uint64FromInt32(int32(8) + (*VP8BitWriter)(unsafe.Pointer(v1)).Fnb_bits)
 	v2 = uint64(((*VP8BitWriter)(unsafe.Pointer(v1)).Fpos+libc.Uint64FromInt32((*VP8BitWriter)(unsafe.Pointer(v1)).Frun))*uint64(8)) + nb_bits
 	goto _9
 _9:
 	pos2 = v2
 	VP8CodeIntraModes(tls, enc)
 	VP8BitWriterFinish(tls, bw1)
 	v1 = bw1
 	nb_bits = libc.Uint64FromInt32(int32(8) + (*VP8BitWriter)(unsafe.Pointer(v1)).Fnb_bits)
 	v2 = uint64(((*VP8BitWriter)(unsafe.Pointer(v1)).Fpos+libc.Uint64FromInt32((*VP8BitWriter)(unsafe.Pointer(v1)).Frun))*uint64(8)) + nb_bits
 	goto _12
 _12:
 	pos3 = v2
 	if (*WebPPicture)(unsafe.Pointer((*VP8Encoder)(unsafe.Pointer(enc)).Fpic)).Fstats != 0 {
 		**(**int32)(__ccgo_up((*WebPPicture)(unsafe.Pointer((*VP8Encoder)(unsafe.Pointer(enc)).Fpic)).Fstats + 36)) = libc.Int32FromUint64((pos2 - pos1 + libc.Uint64FromInt32(7)) >> libc.Int32FromInt32(3))
 		**(**int32)(__ccgo_up((*WebPPicture)(unsafe.Pointer((*VP8Encoder)(unsafe.Pointer(enc)).Fpic)).Fstats + 36 + 1*4)) = libc.Int32FromUint64((pos3 - pos2 + libc.Uint64FromInt32(7)) >> libc.Int32FromInt32(3))
 		(*WebPAuxStats)(unsafe.Pointer((*WebPPicture)(unsafe.Pointer((*VP8Encoder)(unsafe.Pointer(enc)).Fpic)).Fstats)).Falpha_data_size = libc.Int32FromUint32((*VP8Encoder)(unsafe.Pointer(enc)).Falpha_data_size)
 	}
 	if (*VP8BitWriter)(unsafe.Pointer(bw1)).Ferror1 != 0 {
 		return WebPEncodingSetError(tls, (*VP8Encoder)(unsafe.Pointer(enc)).Fpic, int32(VP8_ENC_ERROR_OUT_OF_MEMORY))
 	}
 	return int32(1)
 }
 
 func VP8EncFreeBitWriters(tls *libc.TLS, enc uintptr) {
 	var p int32
 	_ = p
 	VP8BitWriterWipeOut(tls, enc+64)
 	p = 0
 	for {
 		if !(p < (*VP8Encoder)(unsafe.Pointer(enc)).Fnum_parts) {
 			break
 		}
 		VP8BitWriterWipeOut(tls, enc+112+uintptr(p)*48)
 		goto _1
 	_1:
 		;
 		p = p + 1
 	}
 }
 
 func VP8EncWrite(tls *libc.TLS, enc uintptr) (r int32) {
 	var buf, bw2, part0, pic, v6 uintptr
 	var final_percent, ok, p, percent_per_part, task_percent int32
 	var pad, riff_size, size, size0, vp8_size, v1 size_t
 	var padded_alpha_size uint32_t
 	_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = buf, bw2, final_percent, ok, p, pad, padded_alpha_size, part0, percent_per_part, pic, riff_size, size, size0, task_percent, vp8_size, v1, v6
 	pic = (*VP8Encoder)(unsafe.Pointer(enc)).Fpic
 	bw2 = enc + 64
 	task_percent = int32(19)
 	percent_per_part = task_percent / (*VP8Encoder)(unsafe.Pointer(enc)).Fnum_parts
 	final_percent = (*VP8Encoder)(unsafe.Pointer(enc)).Fpercent + task_percent
 	ok = 0
 	// Partition #0 with header and partition sizes
 	ok = GeneratePartition0(tls, enc)
 	if !(ok != 0) {
 		return 0
 	}
 	// Compute VP8 size
 	v1 = (*VP8BitWriter)(unsafe.Pointer(bw2)).Fpos
 	goto _2
 _2:
 	vp8_size = uint64(VP8_FRAME_HEADER_SIZE) + v1 + libc.Uint64FromInt32(int32(3)*((*VP8Encoder)(unsafe.Pointer(enc)).Fnum_parts-int32(1)))
 	p = 0
 	for {
 		if !(p < (*VP8Encoder)(unsafe.Pointer(enc)).Fnum_parts) {
 			break
 		}
 		v1 = (*VP8BitWriter)(unsafe.Pointer(enc + 112 + uintptr(p)*48)).Fpos
 		goto _5
 	_5:
 		vp8_size = vp8_size + v1
 		goto _3
 	_3:
 		;
 		p = p + 1
 	}
 	pad = vp8_size & uint64(1)
 	vp8_size = vp8_size + pad
 	// Compute RIFF size
 	// At the minimum it is: "WEBPVP8 nnnn" + VP8 data size.
 	riff_size = libc.Uint64FromInt32(libc.Int32FromInt32(TAG_SIZE)+libc.Int32FromInt32(CHUNK_HEADER_SIZE)) + vp8_size
 	if IsVP8XNeeded(tls, enc) != 0 { // Add size for: VP8X header + data.
 		riff_size = riff_size + libc.Uint64FromInt32(libc.Int32FromInt32(CHUNK_HEADER_SIZE)+libc.Int32FromInt32(VP8X_CHUNK_SIZE))
 	}
 	if (*VP8Encoder)(unsafe.Pointer(enc)).Fhas_alpha != 0 { // Add size for: ALPH header + data.
 		padded_alpha_size = (*VP8Encoder)(unsafe.Pointer(enc)).Falpha_data_size + (*VP8Encoder)(unsafe.Pointer(enc)).Falpha_data_size&uint32(1)
 		riff_size = riff_size + uint64(uint32(CHUNK_HEADER_SIZE)+padded_alpha_size)
 	}
 	// RIFF size should fit in 32-bits.
 	if riff_size > uint64(0xfffffffe) {
 		return WebPEncodingSetError(tls, pic, int32(VP8_ENC_ERROR_FILE_TOO_BIG))
 	}
 	// Emit headers and partition #0
 	v6 = (*VP8BitWriter)(unsafe.Pointer(bw2)).Fbuf
 	goto _7
 _7:
 	part0 = v6
 	v1 = (*VP8BitWriter)(unsafe.Pointer(bw2)).Fpos
 	goto _9
 _9:
 	size0 = v1
 	ok = libc.BoolInt32(ok != 0 && PutWebPHeaders(tls, enc, size0, vp8_size, riff_size) != 0 && (*(*func(*libc.TLS, uintptr, size_t, uintptr) int32)(unsafe.Pointer(&struct{ uintptr }{(*WebPPicture)(unsafe.Pointer(pic)).Fwriter})))(tls, part0, size0, pic) != 0 && EmitPartitionsSize(tls, enc, pic) != 0)
 	VP8BitWriterWipeOut(tls, bw2) // will free the internal buffer.
 	// Token partitions
 	p = 0
 	for {
 		if !(p < (*VP8Encoder)(unsafe.Pointer(enc)).Fnum_parts) {
 			break
 		}
 		v6 = (*VP8BitWriter)(unsafe.Pointer(enc + 112 + uintptr(p)*48)).Fbuf
 		goto _12
 	_12:
 		buf = v6
 		v1 = (*VP8BitWriter)(unsafe.Pointer(enc + 112 + uintptr(p)*48)).Fpos
 		goto _14
 	_14:
 		size = v1
 		if size != 0 {
 			ok = libc.BoolInt32(ok != 0 && (*(*func(*libc.TLS, uintptr, size_t, uintptr) int32)(unsafe.Pointer(&struct{ uintptr }{(*WebPPicture)(unsafe.Pointer(pic)).Fwriter})))(tls, buf, size, pic) != 0)
 		}
 		VP8BitWriterWipeOut(tls, enc+112+uintptr(p)*48) // will free the internal buffer.
 		ok = libc.BoolInt32(ok != 0 && WebPReportProgress(tls, pic, (*VP8Encoder)(unsafe.Pointer(enc)).Fpercent+percent_per_part, enc+536) != 0)
 		goto _10
 	_10:
 		;
 		p = p + 1
 	}
 	// Padding byte
 	if ok != 0 && pad != 0 {
 		ok = PutPaddingByte(tls, pic)
 	}
 	(*VP8Encoder)(unsafe.Pointer(enc)).Fcoded_size = libc.Int32FromUint64(libc.Uint64FromInt32(CHUNK_HEADER_SIZE) + riff_size)
 	ok = libc.BoolInt32(ok != 0 && WebPReportProgress(tls, pic, final_percent, enc+536) != 0)
 	if !(ok != 0) {
 		WebPEncodingSetError(tls, pic, int32(VP8_ENC_ERROR_BAD_WRITE))
 	}
 	return ok
 }
 
 const MIN_PAGE_SIZE = 8192
 
 type VP8Tokens = struct {
 	Fnext uintptr
 }
 
 //------------------------------------------------------------------------------
 
 // Copyright 2011 Google Inc. All Rights Reserved.
 //
 // Use of this source code is governed by a BSD-style license
 // that can be found in the COPYING file in the root of the source
 // tree. An additional intellectual property rights grant can be found
 // in the file PATENTS. All contributing project authors may
 // be found in the AUTHORS file in the root of the source tree.
 // -----------------------------------------------------------------------------
 //
 //   WebP encoder: internal header.
 //
 // Author: Skal (pascal.massimino@gmail.com)
 
 // Copyright 2011 Google Inc. All Rights Reserved.
 //
 // Use of this source code is governed by a BSD-style license
 // that can be found in the COPYING file in the root of the source
 // tree. An additional intellectual property rights grant can be found
 // in the file PATENTS. All contributing project authors may
 // be found in the AUTHORS file in the root of the source tree.
 // -----------------------------------------------------------------------------
 //
 // Bit writing and boolean coder
 //
 // Author: Skal (pascal.massimino@gmail.com)
 
 // Copyright 2012 Google Inc. All Rights Reserved.
 //
 // Use of this source code is governed by a BSD-style license
 // that can be found in the COPYING file in the root of the source
 // tree. An additional intellectual property rights grant can be found
 // in the file PATENTS. All contributing project authors may
 // be found in the AUTHORS file in the root of the source tree.
 // -----------------------------------------------------------------------------
 //
 // Misc. common utility functions
 //
 // Authors: Skal (pascal.massimino@gmail.com)
 //          Urvang (urvang@google.com)
 
 // Copyright 2010 Google Inc. All Rights Reserved.
 //
 // Use of this source code is governed by a BSD-style license
 // that can be found in the COPYING file in the root of the source
 // tree. An additional intellectual property rights grant can be found
 // in the file PATENTS. All contributing project authors may
 // be found in the AUTHORS file in the root of the source tree.
 // -----------------------------------------------------------------------------
 //
 //  Common types + memory wrappers
 //
 // Author: Skal (pascal.massimino@gmail.com)
 
 // we use pages to reduce the number of memcpy()
 
 type token_t = uint16
 
 // Token data is located in memory just after the 'next' field.
 // This macro is used to return their address and hide the trick.
 
 //------------------------------------------------------------------------------
 
 func VP8TBufferInit(tls *libc.TLS, b uintptr, page_size int32) {
 	var v1 int32
 	_ = v1
 	(*VP8TBuffer)(unsafe.Pointer(b)).Ftokens = libc.UintptrFromInt32(0)
 	(*VP8TBuffer)(unsafe.Pointer(b)).Fpages = libc.UintptrFromInt32(0)
 	(*VP8TBuffer)(unsafe.Pointer(b)).Flast_page = b
 	(*VP8TBuffer)(unsafe.Pointer(b)).Fleft = 0
 	if page_size < int32(MIN_PAGE_SIZE) {
 		v1 = int32(MIN_PAGE_SIZE)
 	} else {
 		v1 = page_size
 	}
 	(*VP8TBuffer)(unsafe.Pointer(b)).Fpage_size = v1
 	(*VP8TBuffer)(unsafe.Pointer(b)).Ferror1 = 0
 }
 
 func VP8TBufferClear(tls *libc.TLS, b uintptr) {
 	var next, p uintptr
 	_, _ = next, p
 	if b != libc.UintptrFromInt32(0) {
 		p = (*VP8TBuffer)(unsafe.Pointer(b)).Fpages
 		for p != libc.UintptrFromInt32(0) {
 			next = (*VP8Tokens)(unsafe.Pointer(p)).Fnext
 			WebPSafeFree(tls, p)
 			p = next
 		}
 		VP8TBufferInit(tls, b, (*VP8TBuffer)(unsafe.Pointer(b)).Fpage_size)
 	}
 }
 
 func TBufferNewPage(tls *libc.TLS, b uintptr) (r int32) {
 	var page uintptr
 	var size size_t
 	_, _ = page, size
 	page = libc.UintptrFromInt32(0)
 	if !((*VP8TBuffer)(unsafe.Pointer(b)).Ferror1 != 0) {
 		size = uint64(8) + libc.Uint64FromInt32((*VP8TBuffer)(unsafe.Pointer(b)).Fpage_size)*uint64(2)
 		page = WebPSafeMalloc(tls, uint64(1), size)
 	}
 	if page == libc.UintptrFromInt32(0) {
 		(*VP8TBuffer)(unsafe.Pointer(b)).Ferror1 = int32(1)
 		return 0
 	}
 	(*VP8Tokens)(unsafe.Pointer(page)).Fnext = libc.UintptrFromInt32(0)
 	**(**uintptr)(__ccgo_up((*VP8TBuffer)(unsafe.Pointer(b)).Flast_page)) = page
 	(*VP8TBuffer)(unsafe.Pointer(b)).Flast_page = page
 	(*VP8TBuffer)(unsafe.Pointer(b)).Fleft = (*VP8TBuffer)(unsafe.Pointer(b)).Fpage_size
 	(*VP8TBuffer)(unsafe.Pointer(b)).Ftokens = page + 1*8
 	return int32(1)
 }
 
 //------------------------------------------------------------------------------
 
 func AddToken(tls *libc.TLS, b uintptr, bit1 uint32_t, proba_idx uint32_t, stats1 uintptr) (r uint32_t) {
 	var p proba_t
 	var slot, v1 int32
 	var v2 uintptr
 	_, _, _, _ = p, slot, v1, v2
 	if (*VP8TBuffer)(unsafe.Pointer(b)).Fleft > 0 || TBufferNewPage(tls, b) != 0 {
 		v2 = b + 24
 		*(*int32)(unsafe.Pointer(v2)) = *(*int32)(unsafe.Pointer(v2)) - 1
 		v1 = *(*int32)(unsafe.Pointer(v2))
 		slot = v1
 		**(**uint16_t)(__ccgo_up((*VP8TBuffer)(unsafe.Pointer(b)).Ftokens + uintptr(slot)*2)) = uint16(bit1<<libc.Int32FromInt32(15) | proba_idx)
 	}
 	v1 = libc.Int32FromUint32(bit1)
 	v2 = stats1
 	p = **(**proba_t)(__ccgo_up(v2))
 	if p >= libc.Uint32FromUint32(0xfffe0000) {
 		p = (p + uint32(1)) >> int32(1) & uint32(0x7fff7fff)
 	}
 	p = p + (uint32(0x00010000) + libc.Uint32FromInt32(v1))
 	**(**proba_t)(__ccgo_up(v2)) = p
 	_ = v1
 	goto _5
 _5:
 	;
 	return bit1
 }
 
 func AddConstantToken(tls *libc.TLS, b uintptr, bit uint32_t, proba uint32_t) {
 	var slot, v1 int32
 	var v2 uintptr
 	_, _, _ = slot, v1, v2
 	if (*VP8TBuffer)(unsafe.Pointer(b)).Fleft > 0 || TBufferNewPage(tls, b) != 0 {
 		v2 = b + 24
 		*(*int32)(unsafe.Pointer(v2)) = *(*int32)(unsafe.Pointer(v2)) - 1
 		v1 = *(*int32)(unsafe.Pointer(v2))
 		slot = v1
 		**(**uint16_t)(__ccgo_up((*VP8TBuffer)(unsafe.Pointer(b)).Ftokens + uintptr(slot)*2)) = uint16(bit<<libc.Int32FromInt32(15) | libc.Uint32FromUint32(1)<<libc.Int32FromInt32(14) | proba)
 	}
 }
 
 func VP8RecordCoeffTokens(tls *libc.TLS, ctx int32, res uintptr, tokens uintptr) (r int32) {
 	var base_id, residue, v uint32_t
 	var c, coeff_type, last, mask, n, sign, v1, v2 int32
 	var coeffs, s, tab, v3 uintptr
 	_, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = base_id, c, coeff_type, coeffs, last, mask, n, residue, s, sign, tab, v, v1, v2, v3
 	coeffs = (*VP8Residual)(unsafe.Pointer(res)).Fcoeffs
 	coeff_type = (*VP8Residual)(unsafe.Pointer(res)).Fcoeff_type
 	last = (*VP8Residual)(unsafe.Pointer(res)).Flast
 	n = (*VP8Residual)(unsafe.Pointer(res)).Ffirst
 	base_id = libc.Uint32FromInt32(int32(NUM_PROBAS) * (ctx + int32(NUM_CTX)*(n+int32(NUM_BANDS)*coeff_type)))
 	// should be stats[VP8EncBands[n]], but it's equivalent for n=0 or 1
 	s = (*VP8Residual)(unsafe.Pointer(res)).Fstats + uintptr(n)*132 + uintptr(ctx)*44
 	if !(AddToken(tls, tokens, libc.BoolUint32(last >= 0), base_id+uint32(0), s+uintptr(0)*4) != 0) {
 		return 0
 	}
 	for n < int32(16) {
 		v1 = n
 		n = n + 1
 		c = int32(**(**int16_t)(__ccgo_up(coeffs + uintptr(v1)*2)))
 		sign = libc.BoolInt32(c < 0)
 		if sign != 0 {
 			v2 = -c
 		} else {
 			v2 = c
 		}
 		v = libc.Uint32FromInt32(v2)
 		if !(AddToken(tls, tokens, libc.BoolUint32(v != uint32(0)), base_id+uint32(1), s+uintptr(1)*4) != 0) {
 			base_id = libc.Uint32FromInt32(int32(NUM_PROBAS) * (libc.Int32FromInt32(0) + int32(NUM_CTX)*(libc.Int32FromUint8(VP8EncBands[n])+int32(NUM_BANDS)*coeff_type))) // ctx=0
 			s = (*VP8Residual)(unsafe.Pointer(res)).Fstats + uintptr(VP8EncBands[n])*132
 			continue
 		}
 		if !(AddToken(tls, tokens, libc.BoolUint32(v > uint32(1)), base_id+uint32(2), s+uintptr(2)*4) != 0) {
 			base_id = libc.Uint32FromInt32(int32(NUM_PROBAS) * (libc.Int32FromInt32(1) + int32(NUM_CTX)*(libc.Int32FromUint8(VP8EncBands[n])+int32(NUM_BANDS)*coeff_type))) // ctx=1
 			s = (*VP8Residual)(unsafe.Pointer(res)).Fstats + uintptr(VP8EncBands[n])*132 + 1*44
 		} else {
 			if !(AddToken(tls, tokens, libc.BoolUint32(v > uint32(4)), base_id+uint32(3), s+uintptr(3)*4) != 0) {
 				if AddToken(tls, tokens, libc.BoolUint32(v != uint32(2)), base_id+uint32(4), s+uintptr(4)*4) != 0 {
 					AddToken(tls, tokens, libc.BoolUint32(v == uint32(4)), base_id+uint32(5), s+uintptr(5)*4)
 				}
 			} else {
 				if !(AddToken(tls, tokens, libc.BoolUint32(v > uint32(10)), base_id+uint32(6), s+uintptr(6)*4) != 0) {
 					if !(AddToken(tls, tokens, libc.BoolUint32(v > uint32(6)), base_id+uint32(7), s+uintptr(7)*4) != 0) {
 						AddConstantToken(tls, tokens, libc.BoolUint32(v == uint32(6)), uint32(159))
 					} else {
 						AddConstantToken(tls, tokens, libc.BoolUint32(v >= uint32(9)), uint32(165))
 						AddConstantToken(tls, tokens, libc.BoolUint32(!(v&libc.Uint32FromInt32(1) != 0)), uint32(145))
 					}
 				} else {
 					residue = v - uint32(3)
 					if residue < libc.Uint32FromInt32(libc.Int32FromInt32(8)<<libc.Int32FromInt32(1)) { // VP8Cat3  (3b)
 						AddToken(tls, tokens, uint32(0), base_id+uint32(8), s+uintptr(8)*4)
 						AddToken(tls, tokens, uint32(0), base_id+uint32(9), s+uintptr(9)*4)
 						residue = residue - libc.Uint32FromInt32(libc.Int32FromInt32(8)<<libc.Int32FromInt32(0))
 						mask = libc.Int32FromInt32(1) << libc.Int32FromInt32(2)
 						tab = uintptr(unsafe.Pointer(&VP8Cat3))
 					} else {
 						if residue < libc.Uint32FromInt32(libc.Int32FromInt32(8)<<libc.Int32FromInt32(2)) { // VP8Cat4  (4b)
 							AddToken(tls, tokens, uint32(0), base_id+uint32(8), s+uintptr(8)*4)
 							AddToken(tls, tokens, uint32(1), base_id+uint32(9), s+uintptr(9)*4)
 							residue = residue - libc.Uint32FromInt32(libc.Int32FromInt32(8)<<libc.Int32FromInt32(1))
 							mask = libc.Int32FromInt32(1) << libc.Int32FromInt32(3)
 							tab = uintptr(unsafe.Pointer(&VP8Cat4))
 						} else {
 							if residue < libc.Uint32FromInt32(libc.Int32FromInt32(8)<<libc.Int32FromInt32(3)) { // VP8Cat5  (5b)
 								AddToken(tls, tokens, uint32(1), base_id+uint32(8), s+uintptr(8)*4)
 								AddToken(tls, tokens, uint32(0), base_id+uint32(10), s+uintptr(9)*4)
 								residue = residue - libc.Uint32FromInt32(libc.Int32FromInt32(8)<<libc.Int32FromInt32(2))
 								mask = libc.Int32FromInt32(1) << libc.Int32FromInt32(4)
 								tab = uintptr(unsafe.Pointer(&VP8Cat5))
 							} else { // VP8Cat6 (11b)
 								AddToken(tls, tokens, uint32(1), base_id+uint32(8), s+uintptr(8)*4)
 								AddToken(tls, tokens, uint32(1), base_id+uint32(10), s+uintptr(9)*4)
 								residue = residue - libc.Uint32FromInt32(libc.Int32FromInt32(8)<<libc.Int32FromInt32(3))
 								mask = libc.Int32FromInt32(1) << libc.Int32FromInt32(10)
 								tab = uintptr(unsafe.Pointer(&VP8Cat6))
 							}
 						}
 					}
 					for mask != 0 {
 						v3 = tab
 						tab = tab + 1
 						AddConstantToken(tls, tokens, libc.BoolUint32(!!(residue&libc.Uint32FromInt32(mask) != 0)), uint32(**(**uint8_t)(__ccgo_up(v3))))
 						mask = mask >> int32(1)
 					}
 				}
 			}
 			base_id = libc.Uint32FromInt32(int32(NUM_PROBAS) * (libc.Int32FromInt32(2) + int32(NUM_CTX)*(libc.Int32FromUint8(VP8EncBands[n])+int32(NUM_BANDS)*coeff_type))) // ctx=2
 			s = (*VP8Residual)(unsafe.Pointer(res)).Fstats + uintptr(VP8EncBands[n])*132 + 2*44
 		}
 		AddConstantToken(tls, tokens, libc.Uint32FromInt32(sign), uint32(128))
 		if n == int32(16) || !(AddToken(tls, tokens, libc.BoolUint32(n <= last), base_id+uint32(0), s+uintptr(0)*4) != 0) {
 			return int32(1) // EOB
 		}
 	}
 	return int32(1)
 }
 
 //------------------------------------------------------------------------------
 // Final coding pass, with known probabilities
 
 func VP8EmitTokens(tls *libc.TLS, b uintptr, bw uintptr, probas uintptr, final_pass int32) (r int32) {
 	var N, bit, n, v1, v2 int32
 	var next, p, tokens uintptr
 	var token token_t
 	_, _, _, _, _, _, _, _, _ = N, bit, n, next, p, token, tokens, v1, v2
 	p = (*VP8TBuffer)(unsafe.Pointer(b)).Fpages
 	for p != libc.UintptrFromInt32(0) {
 		next = (*VP8Tokens)(unsafe.Pointer(p)).Fnext
 		if next == libc.UintptrFromInt32(0) {
 			v1 = (*VP8TBuffer)(unsafe.Pointer(b)).Fleft
 		} else {
 			v1 = 0
 		}
 		N = v1
 		n = (*VP8TBuffer)(unsafe.Pointer(b)).Fpage_size
 		tokens = p + 1*8
 		for {
 			v2 = n
 			n = n - 1
 			if !(v2 > N) {
 				break
 			}
 			token = **(**token_t)(__ccgo_up(tokens + uintptr(n)*2))
 			bit = libc.Int32FromUint16(token) >> int32(15) & int32(1)
 			if uint32(token)&(libc.Uint32FromUint32(1)<<libc.Int32FromInt32(14)) != 0 {
 				VP8PutBit(tls, bw, bit, libc.Int32FromUint32(uint32(token)&uint32(0xff))) // constant proba
 			} else {
 				VP8PutBit(tls, bw, bit, libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(probas + uintptr(uint32(token)&uint32(0x3fff))))))
 			}
 		}
 		if final_pass != 0 {
 			WebPSafeFree(tls, p)
 		}
 		p = next
 	}
 	if final_pass != 0 {
 		(*VP8TBuffer)(unsafe.Pointer(b)).Fpages = libc.UintptrFromInt32(0)
 	}
 	return int32(1)
 }
 
 // C documentation
 //
 //	// Size estimation
 func VP8EstimateTokenSize(tls *libc.TLS, b uintptr, probas uintptr) (r size_t) {
 	var N, bit1, n, v1, v2, v4, v6 int32
 	var next, p, tokens uintptr
 	var size size_t
 	var token token_t
 	var v3 uint8_t
 	_, _, _, _, _, _, _, _, _, _, _, _, _ = N, bit1, n, next, p, size, token, tokens, v1, v2, v3, v4, v6
 	size = uint64(0)
 	p = (*VP8TBuffer)(unsafe.Pointer(b)).Fpages
 	for p != libc.UintptrFromInt32(0) {
 		next = (*VP8Tokens)(unsafe.Pointer(p)).Fnext
 		if next == libc.UintptrFromInt32(0) {
 			v1 = (*VP8TBuffer)(unsafe.Pointer(b)).Fleft
 		} else {
 			v1 = 0
 		}
 		N = v1
 		n = (*VP8TBuffer)(unsafe.Pointer(b)).Fpage_size
 		tokens = p + 1*8
 		for {
 			v2 = n
 			n = n - 1
 			if !(v2 > N) {
 				break
 			}
 			token = **(**token_t)(__ccgo_up(tokens + uintptr(n)*2))
 			bit1 = libc.Int32FromUint16(token) & (libc.Int32FromInt32(1) << libc.Int32FromInt32(15))
 			if uint32(token)&(libc.Uint32FromUint32(1)<<libc.Int32FromInt32(14)) != 0 {
 				v3 = uint8(uint32(token) & uint32(0xff))
 				if !(bit1 != 0) {
 					v6 = libc.Int32FromUint16(VP8EntropyCost[v3])
 				} else {
 					v6 = libc.Int32FromUint16(VP8EntropyCost[int32(255)-libc.Int32FromUint8(v3)])
 				}
 				v4 = v6
 				goto _5
 			_5:
 				size = size + libc.Uint64FromInt32(v4)
 			} else {
 				v3 = **(**uint8_t)(__ccgo_up(probas + uintptr(uint32(token)&uint32(0x3fff))))
 				if !(bit1 != 0) {
 					v2 = libc.Int32FromUint16(VP8EntropyCost[v3])
 				} else {
 					v2 = libc.Int32FromUint16(VP8EntropyCost[int32(255)-libc.Int32FromUint8(v3)])
 				}
 				v1 = v2
 				goto _9
 			_9:
 				size = size + libc.Uint64FromInt32(v1)
 			}
 		}
 		p = next
 	}
 	return size
 }
 
 func VP8DefaultProbas(tls *libc.TLS, enc uintptr) {
 	var probas uintptr
 	_ = probas
 	probas = enc + 3616
 	(*VP8EncProba)(unsafe.Pointer(probas)).Fuse_skip_proba = 0
 	libc.X__builtin___memset_chk(tls, probas, libc.Int32FromUint32(255), uint64(3), ^__predefined_size_t(0))
 	libc.X__builtin___memcpy_chk(tls, probas+4, uintptr(unsafe.Pointer(&VP8CoeffsProba0)), uint64(1056), ^__predefined_size_t(0))
 	// Note: we could hard-code the level_costs corresponding to VP8CoeffsProba0,
 	// but that's ~11k of static data. Better call VP8CalculateLevelCosts() later.
 	(*VP8EncProba)(unsafe.Pointer(probas)).Fdirty = int32(1)
 }
 
 // C documentation
 //
 //	// Paragraph 11.5.  900bytes.
 var kBModesProba1 = [10][10][9]uint8_t{
 	0: {
 		0: {
 			0: uint8(231),
 			1: uint8(120),
 			2: uint8(48),
 			3: uint8(89),
 			4: uint8(115),
 			5: uint8(113),
 			6: uint8(120),
 			7: uint8(152),
 			8: uint8(112),
 		},
 		1: {
 			0: uint8(152),
 			1: uint8(179),
 			2: uint8(64),
 			3: uint8(126),
 			4: uint8(170),
 			5: uint8(118),
 			6: uint8(46),
 			7: uint8(70),
 			8: uint8(95),
 		},
 		2: {
 			0: uint8(175),
 			1: uint8(69),
 			2: uint8(143),
 			3: uint8(80),
 			4: uint8(85),
 			5: uint8(82),
 			6: uint8(72),
 			7: uint8(155),
 			8: uint8(103),
 		},
 		3: {
 			0: uint8(56),
 			1: uint8(58),
 			2: uint8(10),
 			3: uint8(171),
 			4: uint8(218),
 			5: uint8(189),
 			6: uint8(17),
 			7: uint8(13),
 			8: uint8(152),
 		},
 		4: {
 			0: uint8(114),
 			1: uint8(26),
 			2: uint8(17),
 			3: uint8(163),
 			4: uint8(44),
 			5: uint8(195),
 			6: uint8(21),
 			7: uint8(10),
 			8: uint8(173),
 		},
 		5: {
 			0: uint8(121),
 			1: uint8(24),
 			2: uint8(80),
 			3: uint8(195),
 			4: uint8(26),
 			5: uint8(62),
 			6: uint8(44),
 			7: uint8(64),
 			8: uint8(85),
 		},
 		6: {
 			0: uint8(144),
 			1: uint8(71),
 			2: uint8(10),
 			3: uint8(38),
 			4: uint8(171),
 			5: uint8(213),
 			6: uint8(144),
 			7: uint8(34),
 			8: uint8(26),
 		},
 		7: {
 			0: uint8(170),
 			1: uint8(46),
 			2: uint8(55),
 			3: uint8(19),
 			4: uint8(136),
 			5: uint8(160),
 			6: uint8(33),
 			7: uint8(206),
 			8: uint8(71),
 		},
 		8: {
 			0: uint8(63),
 			1: uint8(20),
 			2: uint8(8),
 			3: uint8(114),
 			4: uint8(114),
 			5: uint8(208),
 			6: uint8(12),
 			7: uint8(9),
 			8: uint8(226),
 		},
 		9: {
 			0: uint8(81),
 			1: uint8(40),
 			2: uint8(11),
 			3: uint8(96),
 			4: uint8(182),
 			5: uint8(84),
 			6: uint8(29),
 			7: uint8(16),
 			8: uint8(36),
 		},
 	},
 	1: {
 		0: {
 			0: uint8(134),
 			1: uint8(183),
 			2: uint8(89),
 			3: uint8(137),
 			4: uint8(98),
 			5: uint8(101),
 			6: uint8(106),
 			7: uint8(165),
 			8: uint8(148),
 		},
 		1: {
 			0: uint8(72),
 			1: uint8(187),
 			2: uint8(100),
 			3: uint8(130),
 			4: uint8(157),
 			5: uint8(111),
 			6: uint8(32),
 			7: uint8(75),
 			8: uint8(80),
 		},
 		2: {
 			0: uint8(66),
 			1: uint8(102),
 			2: uint8(167),
 			3: uint8(99),
 			4: uint8(74),
 			5: uint8(62),
 			6: uint8(40),
 			7: uint8(234),
 			8: uint8(128),
 		},
 		3: {
 			0: uint8(41),
 			1: uint8(53),
 			2: uint8(9),
 			3: uint8(178),
 			4: uint8(241),
 			5: uint8(141),
 			6: uint8(26),
 			7: uint8(8),
 			8: uint8(107),
 		},
 		4: {
 			0: uint8(74),
 			1: uint8(43),
 			2: uint8(26),
 			3: uint8(146),
 			4: uint8(73),
 			5: uint8(166),
 			6: uint8(49),
 			7: uint8(23),
 			8: uint8(157),
 		},
 		5: {
 			0: uint8(65),
 			1: uint8(38),
 			2: uint8(105),
 			3: uint8(160),
 			4: uint8(51),
 			5: uint8(52),
 			6: uint8(31),
 			7: uint8(115),
 			8: uint8(128),
 		},
 		6: {
 			0: uint8(104),
 			1: uint8(79),
 			2: uint8(12),
 			3: uint8(27),
 			4: uint8(217),
 			5: uint8(255),
 			6: uint8(87),
 			7: uint8(17),
 			8: uint8(7),
 		},
 		7: {
 			0: uint8(87),
 			1: uint8(68),
 			2: uint8(71),
 			3: uint8(44),
 			4: uint8(114),
 			5: uint8(51),
 			6: uint8(15),
 			7: uint8(186),
 			8: uint8(23),
 		},
 		8: {
 			0: uint8(47),
 			1: uint8(41),
 			2: uint8(14),
 			3: uint8(110),
 			4: uint8(182),
 			5: uint8(183),
 			6: uint8(21),
 			7: uint8(17),
 			8: uint8(194),
 		},
 		9: {
 			0: uint8(66),
 			1: uint8(45),
 			2: uint8(25),
 			3: uint8(102),
 			4: uint8(197),
 			5: uint8(189),
 			6: uint8(23),
 			7: uint8(18),
 			8: uint8(22),
 		},
 	},
 	2: {
 		0: {
 			0: uint8(88),
 			1: uint8(88),
 			2: uint8(147),
 			3: uint8(150),
 			4: uint8(42),
 			5: uint8(46),
 			6: uint8(45),
 			7: uint8(196),
 			8: uint8(205),
 		},
 		1: {
 			0: uint8(43),
 			1: uint8(97),
 			2: uint8(183),
 			3: uint8(117),
 			4: uint8(85),
 			5: uint8(38),
 			6: uint8(35),
 			7: uint8(179),
 			8: uint8(61),
 		},
 		2: {
 			0: uint8(39),
 			1: uint8(53),
 			2: uint8(200),
 			3: uint8(87),
 			4: uint8(26),
 			5: uint8(21),
 			6: uint8(43),
 			7: uint8(232),
 			8: uint8(171),
 		},
 		3: {
 			0: uint8(56),
 			1: uint8(34),
 			2: uint8(51),
 			3: uint8(104),
 			4: uint8(114),
 			5: uint8(102),
 			6: uint8(29),
 			7: uint8(93),
 			8: uint8(77),
 		},
 		4: {
 			0: uint8(39),
 			1: uint8(28),
 			2: uint8(85),
 			3: uint8(171),
 			4: uint8(58),
 			5: uint8(165),
 			6: uint8(90),
 			7: uint8(98),
 			8: uint8(64),
 		},
 		5: {
 			0: uint8(34),
 			1: uint8(22),
 			2: uint8(116),
 			3: uint8(206),
 			4: uint8(23),
 			5: uint8(34),
 			6: uint8(43),
 			7: uint8(166),
 			8: uint8(73),
 		},
 		6: {
 			0: uint8(107),
 			1: uint8(54),
 			2: uint8(32),
 			3: uint8(26),
 			4: uint8(51),
 			5: uint8(1),
 			6: uint8(81),
 			7: uint8(43),
 			8: uint8(31),
 		},
 		7: {
 			0: uint8(68),
 			1: uint8(25),
 			2: uint8(106),
 			3: uint8(22),
 			4: uint8(64),
 			5: uint8(171),
 			6: uint8(36),
 			7: uint8(225),
 			8: uint8(114),
 		},
 		8: {
 			0: uint8(34),
 			1: uint8(19),
 			2: uint8(21),
 			3: uint8(102),
 			4: uint8(132),
 			5: uint8(188),
 			6: uint8(16),
 			7: uint8(76),
 			8: uint8(124),
 		},
 		9: {
 			0: uint8(62),
 			1: uint8(18),
 			2: uint8(78),
 			3: uint8(95),
 			4: uint8(85),
 			5: uint8(57),
 			6: uint8(50),
 			7: uint8(48),
 			8: uint8(51),
 		},
 	},
 	3: {
 		0: {
 			0: uint8(193),
 			1: uint8(101),
 			2: uint8(35),
 			3: uint8(159),
 			4: uint8(215),
 			5: uint8(111),
 			6: uint8(89),
 			7: uint8(46),
 			8: uint8(111),
 		},
 		1: {
 			0: uint8(60),
 			1: uint8(148),
 			2: uint8(31),
 			3: uint8(172),
 			4: uint8(219),
 			5: uint8(228),
 			6: uint8(21),
 			7: uint8(18),
 			8: uint8(111),
 		},
 		2: {
 			0: uint8(112),
 			1: uint8(113),
 			2: uint8(77),
 			3: uint8(85),
 			4: uint8(179),
 			5: uint8(255),
 			6: uint8(38),
 			7: uint8(120),
 			8: uint8(114),
 		},
 		3: {
 			0: uint8(40),
 			1: uint8(42),
 			2: uint8(1),
 			3: uint8(196),
 			4: uint8(245),
 			5: uint8(209),
 			6: uint8(10),
 			7: uint8(25),
 			8: uint8(109),
 		},
 		4: {
 			0: uint8(88),
 			1: uint8(43),
 			2: uint8(29),
 			3: uint8(140),
 			4: uint8(166),
 			5: uint8(213),
 			6: uint8(37),
 			7: uint8(43),
 			8: uint8(154),
 		},
 		5: {
 			0: uint8(61),
 			1: uint8(63),
 			2: uint8(30),
 			3: uint8(155),
 			4: uint8(67),
 			5: uint8(45),
 			6: uint8(68),
 			7: uint8(1),
 			8: uint8(209),
 		},
 		6: {
 			0: uint8(100),
 			1: uint8(80),
 			2: uint8(8),
 			3: uint8(43),
 			4: uint8(154),
 			5: uint8(1),
 			6: uint8(51),
 			7: uint8(26),
 			8: uint8(71),
 		},
 		7: {
 			0: uint8(142),
 			1: uint8(78),
 			2: uint8(78),
 			3: uint8(16),
 			4: uint8(255),
 			5: uint8(128),
 			6: uint8(34),
 			7: uint8(197),
 			8: uint8(171),
 		},
 		8: {
 			0: uint8(41),
 			1: uint8(40),
 			2: uint8(5),
 			3: uint8(102),
 			4: uint8(211),
 			5: uint8(183),
 			6: uint8(4),
 			7: uint8(1),
 			8: uint8(221),
 		},
 		9: {
 			0: uint8(51),
 			1: uint8(50),
 			2: uint8(17),
 			3: uint8(168),
 			4: uint8(209),
 			5: uint8(192),
 			6: uint8(23),
 			7: uint8(25),
 			8: uint8(82),
 		},
 	},
 	4: {
 		0: {
 			0: uint8(138),
 			1: uint8(31),
 			2: uint8(36),
 			3: uint8(171),
 			4: uint8(27),
 			5: uint8(166),
 			6: uint8(38),
 			7: uint8(44),
 			8: uint8(229),
 		},
 		1: {
 			0: uint8(67),
 			1: uint8(87),
 			2: uint8(58),
 			3: uint8(169),
 			4: uint8(82),
 			5: uint8(115),
 			6: uint8(26),
 			7: uint8(59),
 			8: uint8(179),
 		},
 		2: {
 			0: uint8(63),
 			1: uint8(59),
 			2: uint8(90),
 			3: uint8(180),
 			4: uint8(59),
 			5: uint8(166),
 			6: uint8(93),
 			7: uint8(73),
 			8: uint8(154),
 		},
 		3: {
 			0: uint8(40),
 			1: uint8(40),
 			2: uint8(21),
 			3: uint8(116),
 			4: uint8(143),
 			5: uint8(209),
 			6: uint8(34),
 			7: uint8(39),
 			8: uint8(175),
 		},
 		4: {
 			0: uint8(47),
 			1: uint8(15),
 			2: uint8(16),
 			3: uint8(183),
 			4: uint8(34),
 			5: uint8(223),
 			6: uint8(49),
 			7: uint8(45),
 			8: uint8(183),
 		},
 		5: {
 			0: uint8(46),
 			1: uint8(17),
 			2: uint8(33),
 			3: uint8(183),
 			4: uint8(6),
 			5: uint8(98),
 			6: uint8(15),
 			7: uint8(32),
 			8: uint8(183),
 		},
 		6: {
 			0: uint8(57),
 			1: uint8(46),
 			2: uint8(22),
 			3: uint8(24),
 			4: uint8(128),
 			5: uint8(1),
 			6: uint8(54),
 			7: uint8(17),
 			8: uint8(37),
 		},
 		7: {
 			0: uint8(65),
 			1: uint8(32),
 			2: uint8(73),
 			3: uint8(115),
 			4: uint8(28),
 			5: uint8(128),
 			6: uint8(23),
 			7: uint8(128),
 			8: uint8(205),
 		},
 		8: {
 			0: uint8(40),
 			1: uint8(3),
 			2: uint8(9),
 			3: uint8(115),
 			4: uint8(51),
 			5: uint8(192),
 			6: uint8(18),
 			7: uint8(6),
 			8: uint8(223),
 		},
 		9: {
 			0: uint8(87),
 			1: uint8(37),
 			2: uint8(9),
 			3: uint8(115),
 			4: uint8(59),
 			5: uint8(77),
 			6: uint8(64),
 			7: uint8(21),
 			8: uint8(47),
 		},
 	},
 	5: {
 		0: {
 			0: uint8(104),
 			1: uint8(55),
 			2: uint8(44),
 			3: uint8(218),
 			4: uint8(9),
 			5: uint8(54),
 			6: uint8(53),
 			7: uint8(130),
 			8: uint8(226),
 		},
 		1: {
 			0: uint8(64),
 			1: uint8(90),
 			2: uint8(70),
 			3: uint8(205),
 			4: uint8(40),
 			5: uint8(41),
 			6: uint8(23),
 			7: uint8(26),
 			8: uint8(57),
 		},
 		2: {
 			0: uint8(54),
 			1: uint8(57),
 			2: uint8(112),
 			3: uint8(184),
 			4: uint8(5),
 			5: uint8(41),
 			6: uint8(38),
 			7: uint8(166),
 			8: uint8(213),
 		},
 		3: {
 			0: uint8(30),
 			1: uint8(34),
 			2: uint8(26),
 			3: uint8(133),
 			4: uint8(152),
 			5: uint8(116),
 			6: uint8(10),
 			7: uint8(32),
 			8: uint8(134),
 		},
 		4: {
 			0: uint8(39),
 			1: uint8(19),
 			2: uint8(53),
 			3: uint8(221),
 			4: uint8(26),
 			5: uint8(114),
 			6: uint8(32),
 			7: uint8(73),
 			8: uint8(255),
 		},
 		5: {
 			0: uint8(31),
 			1: uint8(9),
 			2: uint8(65),
 			3: uint8(234),
 			4: uint8(2),
 			5: uint8(15),
 			6: uint8(1),
 			7: uint8(118),
 			8: uint8(73),
 		},
 		6: {
 			0: uint8(75),
 			1: uint8(32),
 			2: uint8(12),
 			3: uint8(51),
 			4: uint8(192),
 			5: uint8(255),
 			6: uint8(160),
 			7: uint8(43),
 			8: uint8(51),
 		},
 		7: {
 			0: uint8(88),
 			1: uint8(31),
 			2: uint8(35),
 			3: uint8(67),
 			4: uint8(102),
 			5: uint8(85),
 			6: uint8(55),
 			7: uint8(186),
 			8: uint8(85),
 		},
 		8: {
 			0: uint8(56),
 			1: uint8(21),
 			2: uint8(23),
 			3: uint8(111),
 			4: uint8(59),
 			5: uint8(205),
 			6: uint8(45),
 			7: uint8(37),
 			8: uint8(192),
 		},
 		9: {
 			0: uint8(55),
 			1: uint8(38),
 			2: uint8(70),
 			3: uint8(124),
 			4: uint8(73),
 			5: uint8(102),
 			6: uint8(1),
 			7: uint8(34),
 			8: uint8(98),
 		},
 	},
 	6: {
 		0: {
 			0: uint8(125),
 			1: uint8(98),
 			2: uint8(42),
 			3: uint8(88),
 			4: uint8(104),
 			5: uint8(85),
 			6: uint8(117),
 			7: uint8(175),
 			8: uint8(82),
 		},
 		1: {
 			0: uint8(95),
 			1: uint8(84),
 			2: uint8(53),
 			3: uint8(89),
 			4: uint8(128),
 			5: uint8(100),
 			6: uint8(113),
 			7: uint8(101),
 			8: uint8(45),
 		},
 		2: {
 			0: uint8(75),
 			1: uint8(79),
 			2: uint8(123),
 			3: uint8(47),
 			4: uint8(51),
 			5: uint8(128),
 			6: uint8(81),
 			7: uint8(171),
 			8: uint8(1),
 		},
 		3: {
 			0: uint8(57),
 			1: uint8(17),
 			2: uint8(5),
 			3: uint8(71),
 			4: uint8(102),
 			5: uint8(57),
 			6: uint8(53),
 			7: uint8(41),
 			8: uint8(49),
 		},
 		4: {
 			0: uint8(38),
 			1: uint8(33),
 			2: uint8(13),
 			3: uint8(121),
 			4: uint8(57),
 			5: uint8(73),
 			6: uint8(26),
 			7: uint8(1),
 			8: uint8(85),
 		},
 		5: {
 			0: uint8(41),
 			1: uint8(10),
 			2: uint8(67),
 			3: uint8(138),
 			4: uint8(77),
 			5: uint8(110),
 			6: uint8(90),
 			7: uint8(47),
 			8: uint8(114),
 		},
 		6: {
 			0: uint8(115),
 			1: uint8(21),
 			2: uint8(2),
 			3: uint8(10),
 			4: uint8(102),
 			5: uint8(255),
 			6: uint8(166),
 			7: uint8(23),
 			8: uint8(6),
 		},
 		7: {
 			0: uint8(101),
 			1: uint8(29),
 			2: uint8(16),
 			3: uint8(10),
 			4: uint8(85),
 			5: uint8(128),
 			6: uint8(101),
 			7: uint8(196),
 			8: uint8(26),
 		},
 		8: {
 			0: uint8(57),
 			1: uint8(18),
 			2: uint8(10),
 			3: uint8(102),
 			4: uint8(102),
 			5: uint8(213),
 			6: uint8(34),
 			7: uint8(20),
 			8: uint8(43),
 		},
 		9: {
 			0: uint8(117),
 			1: uint8(20),
 			2: uint8(15),
 			3: uint8(36),
 			4: uint8(163),
 			5: uint8(128),
 			6: uint8(68),
 			7: uint8(1),
 			8: uint8(26),
 		},
 	},
 	7: {
 		0: {
 			0: uint8(102),
 			1: uint8(61),
 			2: uint8(71),
 			3: uint8(37),
 			4: uint8(34),
 			5: uint8(53),
 			6: uint8(31),
 			7: uint8(243),
 			8: uint8(192),
 		},
 		1: {
 			0: uint8(69),
 			1: uint8(60),
 			2: uint8(71),
 			3: uint8(38),
 			4: uint8(73),
 			5: uint8(119),
 			6: uint8(28),
 			7: uint8(222),
 			8: uint8(37),
 		},
 		2: {
 			0: uint8(68),
 			1: uint8(45),
 			2: uint8(128),
 			3: uint8(34),
 			4: uint8(1),
 			5: uint8(47),
 			6: uint8(11),
 			7: uint8(245),
 			8: uint8(171),
 		},
 		3: {
 			0: uint8(62),
 			1: uint8(17),
 			2: uint8(19),
 			3: uint8(70),
 			4: uint8(146),
 			5: uint8(85),
 			6: uint8(55),
 			7: uint8(62),
 			8: uint8(70),
 		},
 		4: {
 			0: uint8(37),
 			1: uint8(43),
 			2: uint8(37),
 			3: uint8(154),
 			4: uint8(100),
 			5: uint8(163),
 			6: uint8(85),
 			7: uint8(160),
 			8: uint8(1),
 		},
 		5: {
 			0: uint8(63),
 			1: uint8(9),
 			2: uint8(92),
 			3: uint8(136),
 			4: uint8(28),
 			5: uint8(64),
 			6: uint8(32),
 			7: uint8(201),
 			8: uint8(85),
 		},
 		6: {
 			0: uint8(75),
 			1: uint8(15),
 			2: uint8(9),
 			3: uint8(9),
 			4: uint8(64),
 			5: uint8(255),
 			6: uint8(184),
 			7: uint8(119),
 			8: uint8(16),
 		},
 		7: {
 			0: uint8(86),
 			1: uint8(6),
 			2: uint8(28),
 			3: uint8(5),
 			4: uint8(64),
 			5: uint8(255),
 			6: uint8(25),
 			7: uint8(248),
 			8: uint8(1),
 		},
 		8: {
 			0: uint8(56),
 			1: uint8(8),
 			2: uint8(17),
 			3: uint8(132),
 			4: uint8(137),
 			5: uint8(255),
 			6: uint8(55),
 			7: uint8(116),
 			8: uint8(128),
 		},
 		9: {
 			0: uint8(58),
 			1: uint8(15),
 			2: uint8(20),
 			3: uint8(82),
 			4: uint8(135),
 			5: uint8(57),
 			6: uint8(26),
 			7: uint8(121),
 			8: uint8(40),
 		},
 	},
 	8: {
 		0: {
 			0: uint8(164),
 			1: uint8(50),
 			2: uint8(31),
 			3: uint8(137),
 			4: uint8(154),
 			5: uint8(133),
 			6: uint8(25),
 			7: uint8(35),
 			8: uint8(218),
 		},
 		1: {
 			0: uint8(51),
 			1: uint8(103),
 			2: uint8(44),
 			3: uint8(131),
 			4: uint8(131),
 			5: uint8(123),
 			6: uint8(31),
 			7: uint8(6),
 			8: uint8(158),
 		},
 		2: {
 			0: uint8(86),
 			1: uint8(40),
 			2: uint8(64),
 			3: uint8(135),
 			4: uint8(148),
 			5: uint8(224),
 			6: uint8(45),
 			7: uint8(183),
 			8: uint8(128),
 		},
 		3: {
 			0: uint8(22),
 			1: uint8(26),
 			2: uint8(17),
 			3: uint8(131),
 			4: uint8(240),
 			5: uint8(154),
 			6: uint8(14),
 			7: uint8(1),
 			8: uint8(209),
 		},
 		4: {
 			0: uint8(45),
 			1: uint8(16),
 			2: uint8(21),
 			3: uint8(91),
 			4: uint8(64),
 			5: uint8(222),
 			6: uint8(7),
 			7: uint8(1),
 			8: uint8(197),
 		},
 		5: {
 			0: uint8(56),
 			1: uint8(21),
 			2: uint8(39),
 			3: uint8(155),
 			4: uint8(60),
 			5: uint8(138),
 			6: uint8(23),
 			7: uint8(102),
 			8: uint8(213),
 		},
 		6: {
 			0: uint8(83),
 			1: uint8(12),
 			2: uint8(13),
 			3: uint8(54),
 			4: uint8(192),
 			5: uint8(255),
 			6: uint8(68),
 			7: uint8(47),
 			8: uint8(28),
 		},
 		7: {
 			0: uint8(85),
 			1: uint8(26),
 			2: uint8(85),
 			3: uint8(85),
 			4: uint8(128),
 			5: uint8(128),
 			6: uint8(32),
 			7: uint8(146),
 			8: uint8(171),
 		},
 		8: {
 			0: uint8(18),
 			1: uint8(11),
 			2: uint8(7),
 			3: uint8(63),
 			4: uint8(144),
 			5: uint8(171),
 			6: uint8(4),
 			7: uint8(4),
 			8: uint8(246),
 		},
 		9: {
 			0: uint8(35),
 			1: uint8(27),
 			2: uint8(10),
 			3: uint8(146),
 			4: uint8(174),
 			5: uint8(171),
 			6: uint8(12),
 			7: uint8(26),
 			8: uint8(128),
 		},
 	},
 	9: {
 		0: {
 			0: uint8(190),
 			1: uint8(80),
 			2: uint8(35),
 			3: uint8(99),
 			4: uint8(180),
 			5: uint8(80),
 			6: uint8(126),
 			7: uint8(54),
 			8: uint8(45),
 		},
 		1: {
 			0: uint8(85),
 			1: uint8(126),
 			2: uint8(47),
 			3: uint8(87),
 			4: uint8(176),
 			5: uint8(51),
 			6: uint8(41),
 			7: uint8(20),
 			8: uint8(32),
 		},
 		2: {
 			0: uint8(101),
 			1: uint8(75),
 			2: uint8(128),
 			3: uint8(139),
 			4: uint8(118),
 			5: uint8(146),
 			6: uint8(116),
 			7: uint8(128),
 			8: uint8(85),
 		},
 		3: {
 			0: uint8(56),
 			1: uint8(41),
 			2: uint8(15),
 			3: uint8(176),
 			4: uint8(236),
 			5: uint8(85),
 			6: uint8(37),
 			7: uint8(9),
 			8: uint8(62),
 		},
 		4: {
 			0: uint8(71),
 			1: uint8(30),
 			2: uint8(17),
 			3: uint8(119),
 			4: uint8(118),
 			5: uint8(255),
 			6: uint8(17),
 			7: uint8(18),
 			8: uint8(138),
 		},
 		5: {
 			0: uint8(101),
 			1: uint8(38),
 			2: uint8(60),
 			3: uint8(138),
 			4: uint8(55),
 			5: uint8(70),
 			6: uint8(43),
 			7: uint8(26),
 			8: uint8(142),
 		},
 		6: {
 			0: uint8(146),
 			1: uint8(36),
 			2: uint8(19),
 			3: uint8(30),
 			4: uint8(171),
 			5: uint8(255),
 			6: uint8(97),
 			7: uint8(27),
 			8: uint8(20),
 		},
 		7: {
 			0: uint8(138),
 			1: uint8(45),
 			2: uint8(61),
 			3: uint8(62),
 			4: uint8(219),
 			5: uint8(1),
 			6: uint8(81),
 			7: uint8(188),
 			8: uint8(64),
 		},
 		8: {
 			0: uint8(32),
 			1: uint8(41),
 			2: uint8(20),
 			3: uint8(117),
 			4: uint8(151),
 			5: uint8(142),
 			6: uint8(20),
 			7: uint8(21),
 			8: uint8(163),
 		},
 		9: {
 			0: uint8(112),
 			1: uint8(19),
 			2: uint8(12),
 			3: uint8(61),
 			4: uint8(195),
 			5: uint8(128),
 			6: uint8(48),
 			7: uint8(4),
 			8: uint8(24),
 		},
 	},
 }
 
 func PutI4Mode(tls *libc.TLS, bw uintptr, mode int32, prob uintptr) (r int32) {
 	if VP8PutBit(tls, bw, libc.BoolInt32(mode != int32(B_DC_PRED)), libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(prob)))) != 0 {
 		if VP8PutBit(tls, bw, libc.BoolInt32(mode != int32(B_TM_PRED)), libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(prob + 1)))) != 0 {
 			if VP8PutBit(tls, bw, libc.BoolInt32(mode != int32(B_VE_PRED)), libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(prob + 2)))) != 0 {
 				if !(VP8PutBit(tls, bw, libc.BoolInt32(mode >= int32(B_LD_PRED)), libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(prob + 3)))) != 0) {
 					if VP8PutBit(tls, bw, libc.BoolInt32(mode != int32(B_HE_PRED)), libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(prob + 4)))) != 0 {
 						VP8PutBit(tls, bw, libc.BoolInt32(mode != int32(B_RD_PRED)), libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(prob + 5))))
 					}
 				} else {
 					if VP8PutBit(tls, bw, libc.BoolInt32(mode != int32(B_LD_PRED)), libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(prob + 6)))) != 0 {
 						if VP8PutBit(tls, bw, libc.BoolInt32(mode != int32(B_VL_PRED)), libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(prob + 7)))) != 0 {
 							VP8PutBit(tls, bw, libc.BoolInt32(mode != int32(B_HD_PRED)), libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(prob + 8))))
 						}
 					}
 				}
 			}
 		}
 	}
 	return mode
 }
 
 func PutI16Mode(tls *libc.TLS, bw uintptr, mode int32) {
 	if VP8PutBit(tls, bw, libc.BoolInt32(mode == int32(TM_PRED) || mode == int32(H_PRED)), int32(156)) != 0 {
 		VP8PutBit(tls, bw, libc.BoolInt32(mode == int32(TM_PRED)), int32(128)) // TM or HE
 	} else {
 		VP8PutBit(tls, bw, libc.BoolInt32(mode == int32(V_PRED)), int32(163)) // VE or DC
 	}
 }
 
 func PutUVMode(tls *libc.TLS, bw uintptr, uv_mode int32) {
 	if VP8PutBit(tls, bw, libc.BoolInt32(uv_mode != int32(DC_PRED)), int32(142)) != 0 {
 		if VP8PutBit(tls, bw, libc.BoolInt32(uv_mode != int32(V_PRED)), int32(114)) != 0 {
 			VP8PutBit(tls, bw, libc.BoolInt32(uv_mode != int32(H_PRED)), int32(183)) // else: TM_PRED
 		}
 	}
 }
 
 func PutSegment(tls *libc.TLS, bw uintptr, s int32, p uintptr) {
 	if VP8PutBit(tls, bw, libc.BoolInt32(s >= int32(2)), libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(p)))) != 0 {
 		p = p + uintptr(1)
 	}
 	VP8PutBit(tls, bw, s&int32(1), libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(p + 1))))
 }
 
 func VP8CodeIntraModes(tls *libc.TLS, enc uintptr) {
 	bp := tls.Alloc(3856)
 	defer tls.Free(3856)
 	var bw, mb, preds, probas, top_pred uintptr
 	var left, preds_w, x, y int32
 	var _ /* it at bp+0 */ VP8EncIterator
 	_, _, _, _, _, _, _, _, _ = bw, left, mb, preds, preds_w, probas, top_pred, x, y
 	bw = enc + 64
 	VP8IteratorInit(tls, enc, bp)
 	for cond := true; cond; cond = VP8IteratorNext(tls, bp) != 0 {
 		mb = (**(**VP8EncIterator)(__ccgo_up(bp))).Fmb
 		preds = (**(**VP8EncIterator)(__ccgo_up(bp))).Fpreds
 		if (*VP8Encoder)(unsafe.Pointer(enc)).Fsegment_hdr.Fupdate_map != 0 {
 			PutSegment(tls, bw, int32(uint32(*(*uint8)(unsafe.Pointer(mb + 0))&0x60>>5)), enc+3616)
 		}
 		if (*VP8Encoder)(unsafe.Pointer(enc)).Fproba.Fuse_skip_proba != 0 {
 			VP8PutBit(tls, bw, int32(uint32(*(*uint8)(unsafe.Pointer(mb + 0))&0x10>>4)), libc.Int32FromUint8((*VP8Encoder)(unsafe.Pointer(enc)).Fproba.Fskip_proba))
 		}
 		if VP8PutBit(tls, bw, libc.BoolInt32(int32(uint32(*(*uint8)(unsafe.Pointer(mb + 0))&0x3>>0)) != 0), int32(145)) != 0 { // i16x16
 			PutI16Mode(tls, bw, libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(preds))))
 		} else {
 			preds_w = (*VP8Encoder)(unsafe.Pointer(enc)).Fpreds_w
 			top_pred = preds - uintptr(preds_w)
 			y = 0
 			for {
 				if !(y < int32(4)) {
 					break
 				}
 				left = libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(preds + uintptr(-libc.Int32FromInt32(1)))))
 				x = 0
 				for {
 					if !(x < int32(4)) {
 						break
 					}
 					probas = uintptr(unsafe.Pointer(&kBModesProba1)) + uintptr(**(**uint8_t)(__ccgo_up(top_pred + uintptr(x))))*90 + uintptr(left)*9
 					left = PutI4Mode(tls, bw, libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(preds + uintptr(x)))), probas)
 					goto _2
 				_2:
 					;
 					x = x + 1
 				}
 				top_pred = preds
 				preds = preds + uintptr(preds_w)
 				goto _1
 			_1:
 				;
 				y = y + 1
 			}
 		}
 		PutUVMode(tls, bw, int32(uint32(*(*uint8)(unsafe.Pointer(mb + 0))&0xc>>2)))
 	}
 }
 
 func VP8WriteProbas(tls *libc.TLS, bw uintptr, probas uintptr) {
 	var b, c, p, t, update int32
 	var p0 uint8_t
 	_, _, _, _, _, _ = b, c, p, p0, t, update
 	t = 0
 	for {
 		if !(t < int32(NUM_TYPES)) {
 			break
 		}
 		b = 0
 		for {
 			if !(b < int32(NUM_BANDS)) {
 				break
 			}
 			c = 0
 			for {
 				if !(c < int32(NUM_CTX)) {
 					break
 				}
 				p = 0
 				for {
 					if !(p < int32(NUM_PROBAS)) {
 						break
 					}
 					p0 = **(**uint8_t)(__ccgo_up(probas + 4 + uintptr(t)*264 + uintptr(b)*33 + uintptr(c)*11 + uintptr(p)))
 					update = libc.BoolInt32(libc.Int32FromUint8(p0) != libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(uintptr(unsafe.Pointer(&VP8CoeffsProba0)) + uintptr(t)*264 + uintptr(b)*33 + uintptr(c)*11 + uintptr(p)))))
 					if VP8PutBit(tls, bw, update, libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(uintptr(unsafe.Pointer(&VP8CoeffsUpdateProba)) + uintptr(t)*264 + uintptr(b)*33 + uintptr(c)*11 + uintptr(p))))) != 0 {
 						VP8PutBits(tls, bw, uint32(p0), int32(8))
 					}
 					goto _4
 				_4:
 					;
 					p = p + 1
 				}
 				goto _3
 			_3:
 				;
 				c = c + 1
 			}
 			goto _2
 		_2:
 			;
 			b = b + 1
 		}
 		goto _1
 	_1:
 		;
 		t = t + 1
 	}
 	if VP8PutBitUniform(tls, bw, (*VP8EncProba)(unsafe.Pointer(probas)).Fuse_skip_proba) != 0 {
 		VP8PutBits(tls, bw, uint32((*VP8EncProba)(unsafe.Pointer(probas)).Fskip_proba), int32(8))
 	}
 }
 
 const MAX_HUFF_IMAGE_SIZE = 2600
 const NUM_BUCKETS = 256
 const VP8L_MAGIC_BYTE3 = 47
 const VP8_SIGNATURE2 = 0x9d012a
 
 type HuffmanTreeToken = struct {
 	Fcode       uint8_t
 	Fextra_bits uint8_t
 }
 
 type HuffmanTreeCode = struct {
 	Fnum_symbols  int32
 	Fcode_lengths uintptr
 	Fcodes        uintptr
 }
 
 type HuffmanTree = struct {
 	Ftotal_count      uint32_t
 	Fvalue            int32
 	Fpool_index_left  int32
 	Fpool_index_right int32
 }
 
 type PaletteSorting1 = int32
 
 type PaletteSorting = int32
 
 const kSortedDefault = 0
 const kMinimizeDelta = 1
 const kModifiedZeng = 2
 const kUnusedPalette = 3
 const kPaletteSortingNum = 4
 
 // Copyright 2011 Google Inc. All Rights Reserved.
 //
 // Use of this source code is governed by a BSD-style license
 // that can be found in the COPYING file in the root of the source
 // tree. An additional intellectual property rights grant can be found
 // in the file PATENTS. All contributing project authors may
 // be found in the AUTHORS file in the root of the source tree.
 // -----------------------------------------------------------------------------
 //
 // Multi-threaded worker
 //
 // Author: Skal (pascal.massimino@gmail.com)
 
 // Copyright 2012 Google Inc. All Rights Reserved.
 //
 // Use of this source code is governed by a BSD-style license
 // that can be found in the COPYING file in the root of the source
 // tree. An additional intellectual property rights grant can be found
 // in the file PATENTS. All contributing project authors may
 // be found in the AUTHORS file in the root of the source tree.
 // -----------------------------------------------------------------------------
 //
 // Misc. common utility functions
 //
 // Authors: Skal (pascal.massimino@gmail.com)
 //          Urvang (urvang@google.com)
 
 // Copyright 2011 Google Inc. All Rights Reserved.
 //
 // Use of this source code is governed by a BSD-style license
 // that can be found in the COPYING file in the root of the source
 // tree. An additional intellectual property rights grant can be found
 // in the file PATENTS. All contributing project authors may
 // be found in the AUTHORS file in the root of the source tree.
 // -----------------------------------------------------------------------------
 //
 //   WebP encoder: main interface
 //
 // Author: Skal (pascal.massimino@gmail.com)
 
 // Copyright 2012 Google Inc. All Rights Reserved.
 //
 // Use of this source code is governed by a BSD-style license
 // that can be found in the COPYING file in the root of the source
 // tree. An additional intellectual property rights grant can be found
 // in the file PATENTS. All contributing project authors may
 // be found in the AUTHORS file in the root of the source tree.
 // -----------------------------------------------------------------------------
 //
 //  Internal header for constants related to WebP file format.
 //
 // Author: Urvang (urvang@google.com)
 
 // Copyright 2010 Google Inc. All Rights Reserved.
 //
 // Use of this source code is governed by a BSD-style license
 // that can be found in the COPYING file in the root of the source
 // tree. An additional intellectual property rights grant can be found
 // in the file PATENTS. All contributing project authors may
 // be found in the AUTHORS file in the root of the source tree.
 // -----------------------------------------------------------------------------
 //
 //  Common types + memory wrappers
 //
 // Author: Skal (pascal.massimino@gmail.com)
 
 // Maximum number of histogram images (sub-blocks).
 // Empirical value for which it becomes too computationally expensive to
 // compute the best predictor image.
 
 // -----------------------------------------------------------------------------
 // Palette
 
 // C documentation
 //
 //	// These five modes are evaluated and their respective entropy is computed.
 type EntropyIx = int32
 
 const kDirect = 0
 const kSpatial = 1
 const kSubGreen = 2
 const kSpatialSubGreen = 3
 const kPalette = 4
 const kPaletteAndSpatial = 5
 const kNumEntropyIx = 6
 
 type HistoIx = int32
 
 const kHistoAlpha = 0
 const kHistoAlphaPred = 1
 const kHistoGreen = 2
 const kHistoGreenPred = 3
 const kHistoRed = 4
 const kHistoRedPred = 5
 const kHistoBlue = 6
 const kHistoBluePred = 7
 const kHistoRedSubGreen = 8
 const kHistoRedPredSubGreen = 9
 const kHistoBlueSubGreen = 10
 const kHistoBluePredSubGreen = 11
 const kHistoPalette = 12
 const kHistoTotal = 13
 
 type HistogramBuckets = [256]uint32_t
 
 // C documentation
 //
 //	// Keeping track of histograms, indexed by HistoIx.
 //	// Ideally, this would just be a struct with meaningful fields, but the
 //	// calculation of `entropy_comp` uses the index. One refactoring at a time :)
 type Histograms = struct {
 	Fcategory [13]HistogramBuckets
 }
 
 func AddSingleSubGreen(tls *libc.TLS, p uint32_t, r uintptr, b uintptr) {
 	var green int32
 	_ = green
 	green = libc.Int32FromUint32(p) >> int32(8) // The upper bits are masked away later.
 	**(**uint32_t)(__ccgo_up(r + uintptr((libc.Int32FromUint32(p)>>int32(16)-green)&int32(0xff))*4)) = **(**uint32_t)(__ccgo_up(r + uintptr((libc.Int32FromUint32(p)>>int32(16)-green)&int32(0xff))*4)) + 1
 	**(**uint32_t)(__ccgo_up(b + uintptr((libc.Int32FromUint32(p)>>0-green)&int32(0xff))*4)) = **(**uint32_t)(__ccgo_up(b + uintptr((libc.Int32FromUint32(p)>>0-green)&int32(0xff))*4)) + 1
 }
 
 func AddSingle(tls *libc.TLS, p uint32_t, a uintptr, r uintptr, g uintptr, b uintptr) {
 	**(**uint32_t)(__ccgo_up(a + uintptr(p>>libc.Int32FromInt32(24)&uint32(0xff))*4)) = **(**uint32_t)(__ccgo_up(a + uintptr(p>>libc.Int32FromInt32(24)&uint32(0xff))*4)) + 1
 	**(**uint32_t)(__ccgo_up(r + uintptr(p>>libc.Int32FromInt32(16)&uint32(0xff))*4)) = **(**uint32_t)(__ccgo_up(r + uintptr(p>>libc.Int32FromInt32(16)&uint32(0xff))*4)) + 1
 	**(**uint32_t)(__ccgo_up(g + uintptr(p>>libc.Int32FromInt32(8)&uint32(0xff))*4)) = **(**uint32_t)(__ccgo_up(g + uintptr(p>>libc.Int32FromInt32(8)&uint32(0xff))*4)) + 1
 	**(**uint32_t)(__ccgo_up(b + uintptr(p>>libc.Int32FromInt32(0)&uint32(0xff))*4)) = **(**uint32_t)(__ccgo_up(b + uintptr(p>>libc.Int32FromInt32(0)&uint32(0xff))*4)) + 1
 }
 
 func HashPix(tls *libc.TLS, pix uint32_t) (r uint8_t) {
 	// Note that masking with 0xffffffffu is for preventing an
 	// 'unsigned int overflow' warning. Doesn't impact the compiled code.
 	return uint8((uint64(pix) + uint64(pix>>libc.Int32FromInt32(19))) * uint64(0x39c5fba7) & uint64(0xffffffff) >> int32(24))
 }
 
 func AnalyzeEntropy(tls *libc.TLS, argb uintptr, width int32, height int32, argb_stride int32, use_palette int32, palette_size int32, transform_bits int32, min_entropy_ix uintptr, red_and_blue_always_zero uintptr) (r int32) {
 	bp := tls.Alloc(48)
 	defer tls.Free(48)
 	var alpha_and_green, pix, pix_diff, pix_prev, red_and_blue, v10, v12, v3, v4, v5, v9 uint32_t
 	var blue_histo, curr_row, histo, prev_row, red_histo uintptr
 	var entropy_comp [13]uint64_t
 	var hash uint8_t
 	var i, j, k, last_mode_to_analyze, x, y, v7 int32
 	var v18 uint32
 	var _ /* entropy at bp+0 */ [6]uint64_t
 	_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = alpha_and_green, blue_histo, curr_row, entropy_comp, hash, histo, i, j, k, last_mode_to_analyze, pix, pix_diff, pix_prev, prev_row, red_and_blue, red_histo, x, y, v10, v12, v18, v3, v4, v5, v7, v9
 	if use_palette != 0 && palette_size <= int32(16) {
 		// In the case of small palettes, we pack 2, 4 or 8 pixels together. In
 		// practice, small palettes are better than any other transform.
 		**(**EntropyIx)(__ccgo_up(min_entropy_ix)) = int32(kPalette)
 		**(**int32)(__ccgo_up(red_and_blue_always_zero)) = int32(1)
 		return int32(1)
 	}
 	histo = WebPSafeCalloc(tls, uint64(1), uint64(13312))
 	if histo != libc.UintptrFromInt32(0) {
 		prev_row = libc.UintptrFromInt32(0)
 		curr_row = argb
 		pix_prev = **(**uint32_t)(__ccgo_up(argb)) // Skip the first pixel.
 		y = 0
 		for {
 			if !(y < height) {
 				break
 			}
 			x = 0
 			for {
 				if !(x < width) {
 					break
 				}
 				pix = **(**uint32_t)(__ccgo_up(curr_row + uintptr(x)*4))
 				v3 = pix
 				v4 = pix_prev
 				alpha_and_green = uint32(0x00ff00ff) + v3&uint32(0xff00ff00) - v4&uint32(0xff00ff00)
 				red_and_blue = uint32(0xff00ff00) + v3&uint32(0x00ff00ff) - v4&uint32(0x00ff00ff)
 				v5 = alpha_and_green&uint32(0xff00ff00) | red_and_blue&uint32(0x00ff00ff)
 				goto _6
 			_6:
 				pix_diff = v5
 				pix_prev = pix
 				if pix_diff == uint32(0) || prev_row != libc.UintptrFromInt32(0) && pix == **(**uint32_t)(__ccgo_up(prev_row + uintptr(x)*4)) {
 					goto _2
 				}
 				AddSingle(tls, pix, histo+uintptr(kHistoAlpha)*1024, histo+uintptr(kHistoRed)*1024, histo+uintptr(kHistoGreen)*1024, histo+uintptr(kHistoBlue)*1024)
 				AddSingle(tls, pix_diff, histo+uintptr(kHistoAlphaPred)*1024, histo+uintptr(kHistoRedPred)*1024, histo+uintptr(kHistoGreenPred)*1024, histo+uintptr(kHistoBluePred)*1024)
 				AddSingleSubGreen(tls, pix, histo+uintptr(kHistoRedSubGreen)*1024, histo+uintptr(kHistoBlueSubGreen)*1024)
 				AddSingleSubGreen(tls, pix_diff, histo+uintptr(kHistoRedPredSubGreen)*1024, histo+uintptr(kHistoBluePredSubGreen)*1024)
 				// Approximate the palette by the entropy of the multiplicative hash.
 				hash = HashPix(tls, pix)
 				**(**uint32_t)(__ccgo_up(histo + uintptr(kHistoPalette)*1024 + uintptr(hash)*4)) = **(**uint32_t)(__ccgo_up(histo + uintptr(kHistoPalette)*1024 + uintptr(hash)*4)) + 1
 				goto _2
 			_2:
 				;
 				x = x + 1
 			}
 			prev_row = curr_row
 			curr_row = curr_row + uintptr(argb_stride)*4
 			goto _1
 		_1:
 			;
 			y = y + 1
 		}
 		if use_palette != 0 {
 			v7 = int32(kPalette)
 		} else {
 			v7 = int32(kSpatialSubGreen)
 		}
 		last_mode_to_analyze = v7
 		// Let's add one zero to the predicted histograms. The zeros are removed
 		// too efficiently by the pix_diff == 0 comparison, at least one of the
 		// zeros is likely to exist.
 		**(**uint32_t)(__ccgo_up(histo + uintptr(kHistoRedPredSubGreen)*1024)) = **(**uint32_t)(__ccgo_up(histo + uintptr(kHistoRedPredSubGreen)*1024)) + 1
 		**(**uint32_t)(__ccgo_up(histo + uintptr(kHistoBluePredSubGreen)*1024)) = **(**uint32_t)(__ccgo_up(histo + uintptr(kHistoBluePredSubGreen)*1024)) + 1
 		**(**uint32_t)(__ccgo_up(histo + uintptr(kHistoRedPred)*1024)) = **(**uint32_t)(__ccgo_up(histo + uintptr(kHistoRedPred)*1024)) + 1
 		**(**uint32_t)(__ccgo_up(histo + uintptr(kHistoGreenPred)*1024)) = **(**uint32_t)(__ccgo_up(histo + uintptr(kHistoGreenPred)*1024)) + 1
 		**(**uint32_t)(__ccgo_up(histo + uintptr(kHistoBluePred)*1024)) = **(**uint32_t)(__ccgo_up(histo + uintptr(kHistoBluePred)*1024)) + 1
 		**(**uint32_t)(__ccgo_up(histo + uintptr(kHistoAlphaPred)*1024)) = **(**uint32_t)(__ccgo_up(histo + uintptr(kHistoAlphaPred)*1024)) + 1
 		j = 0
 		for {
 			if !(j < int32(kHistoTotal)) {
 				break
 			}
 			entropy_comp[j] = VP8LBitsEntropy(tls, histo+uintptr(j)*1024, int32(NUM_BUCKETS))
 			goto _8
 		_8:
 			;
 			j = j + 1
 		}
 		(**(**[6]uint64_t)(__ccgo_up(bp)))[int32(kDirect)] = entropy_comp[int32(kHistoAlpha)] + entropy_comp[int32(kHistoRed)] + entropy_comp[int32(kHistoGreen)] + entropy_comp[int32(kHistoBlue)]
 		(**(**[6]uint64_t)(__ccgo_up(bp)))[int32(kSpatial)] = entropy_comp[int32(kHistoAlphaPred)] + entropy_comp[int32(kHistoRedPred)] + entropy_comp[int32(kHistoGreenPred)] + entropy_comp[int32(kHistoBluePred)]
 		(**(**[6]uint64_t)(__ccgo_up(bp)))[int32(kSubGreen)] = entropy_comp[int32(kHistoAlpha)] + entropy_comp[int32(kHistoRedSubGreen)] + entropy_comp[int32(kHistoGreen)] + entropy_comp[int32(kHistoBlueSubGreen)]
 		(**(**[6]uint64_t)(__ccgo_up(bp)))[int32(kSpatialSubGreen)] = entropy_comp[int32(kHistoAlphaPred)] + entropy_comp[int32(kHistoRedPredSubGreen)] + entropy_comp[int32(kHistoGreenPred)] + entropy_comp[int32(kHistoBluePredSubGreen)]
 		(**(**[6]uint64_t)(__ccgo_up(bp)))[int32(kPalette)] = entropy_comp[int32(kHistoPalette)]
 		// When including transforms, there is an overhead in bits from
 		// storing them. This overhead is small but matters for small images.
 		// For spatial, there are 14 transformations.
 		v3 = libc.Uint32FromInt32(transform_bits)
 		v4 = (libc.Uint32FromInt32(width) + libc.Uint32FromInt32(libc.Int32FromInt32(1)<<v3) - uint32(1)) >> v3
 		goto _11
 	_11:
 		v5 = libc.Uint32FromInt32(transform_bits)
 		v9 = (libc.Uint32FromInt32(height) + libc.Uint32FromInt32(libc.Int32FromInt32(1)<<v5) - uint32(1)) >> v5
 		goto _14
 	_14:
 		v10 = uint32(14)
 		if v10 < uint32(LOG_LOOKUP_IDX_MAX) {
 			v18 = kLog2Table[v10]
 		} else {
 			v18 = (*(*func(*libc.TLS, uint32_t) uint32_t)(unsafe.Pointer(&struct{ uintptr }{VP8LFastLog2Slow})))(tls, v10)
 		}
 		v12 = v18
 		goto _17
 	_17:
 		**(**uint64_t)(__ccgo_up(bp + uintptr(kSpatial)*8)) += uint64(v4) * uint64(v9) * uint64(v12)
 		// For color transforms: 24 as only 3 channels are considered in a
 		// ColorTransformElement.
 		v3 = libc.Uint32FromInt32(transform_bits)
 		v4 = (libc.Uint32FromInt32(width) + libc.Uint32FromInt32(libc.Int32FromInt32(1)<<v3) - uint32(1)) >> v3
 		goto _21
 	_21:
 		v5 = libc.Uint32FromInt32(transform_bits)
 		v9 = (libc.Uint32FromInt32(height) + libc.Uint32FromInt32(libc.Int32FromInt32(1)<<v5) - uint32(1)) >> v5
 		goto _24
 	_24:
 		v10 = uint32(24)
 		if v10 < uint32(LOG_LOOKUP_IDX_MAX) {
 			v18 = kLog2Table[v10]
 		} else {
 			v18 = (*(*func(*libc.TLS, uint32_t) uint32_t)(unsafe.Pointer(&struct{ uintptr }{VP8LFastLog2Slow})))(tls, v10)
 		}
 		v12 = v18
 		goto _27
 	_27:
 		**(**uint64_t)(__ccgo_up(bp + uintptr(kSpatialSubGreen)*8)) += uint64(v4) * uint64(v9) * uint64(v12)
 		// For palettes, add the cost of storing the palette.
 		// We empirically estimate the cost of a compressed entry as 8 bits.
 		// The palette is differential-coded when compressed hence a much
 		// lower cost than sizeof(uint32_t)*8.
 		**(**uint64_t)(__ccgo_up(bp + uintptr(kPalette)*8)) += libc.Uint64FromInt32(palette_size) * uint64(8) << int32(LOG_2_PRECISION_BITS)
 		**(**EntropyIx)(__ccgo_up(min_entropy_ix)) = int32(kDirect)
 		k = int32(kDirect) + libc.Int32FromInt32(1)
 		for {
 			if !(k <= last_mode_to_analyze) {
 				break
 			}
 			if (**(**[6]uint64_t)(__ccgo_up(bp)))[**(**EntropyIx)(__ccgo_up(min_entropy_ix))] > (**(**[6]uint64_t)(__ccgo_up(bp)))[k] {
 				**(**EntropyIx)(__ccgo_up(min_entropy_ix)) = k
 			}
 			goto _29
 		_29:
 			;
 			k = k + 1
 		}
 		**(**int32)(__ccgo_up(red_and_blue_always_zero)) = int32(1)
 		red_histo = histo + uintptr(**(**uint8_t)(__ccgo_up(uintptr(unsafe.Pointer(&kHistoPairs)) + uintptr(**(**EntropyIx)(__ccgo_up(min_entropy_ix)))*2)))*1024
 		blue_histo = histo + uintptr(**(**uint8_t)(__ccgo_up(uintptr(unsafe.Pointer(&kHistoPairs)) + uintptr(**(**EntropyIx)(__ccgo_up(min_entropy_ix)))*2 + 1)))*1024
 		i = int32(1)
 		for {
 			if !(i < int32(NUM_BUCKETS)) {
 				break
 			}
 			if **(**uint32_t)(__ccgo_up(red_histo + uintptr(i)*4))|**(**uint32_t)(__ccgo_up(blue_histo + uintptr(i)*4)) != uint32(0) {
 				**(**int32)(__ccgo_up(red_and_blue_always_zero)) = 0
 				break
 			}
 			goto _30
 		_30:
 			;
 			i = i + 1
 		}
 		WebPSafeFree(tls, histo)
 		return int32(1)
 	} else {
 		return 0
 	}
 	return r
 }
 
 // Let's check if the histogram of the chosen entropy mode has
 // non-zero red and blue values. If all are zero, we can later skip
 // the cross color optimization.
 
 var kHistoPairs = [5][2]uint8_t{
 	0: {
 		0: uint8(kHistoRed),
 		1: uint8(kHistoBlue),
 	},
 	1: {
 		0: uint8(kHistoRedPred),
 		1: uint8(kHistoBluePred),
 	},
 	2: {
 		0: uint8(kHistoRedSubGreen),
 		1: uint8(kHistoBlueSubGreen),
 	},
 	3: {
 		0: uint8(kHistoRedPredSubGreen),
 		1: uint8(kHistoBluePredSubGreen),
 	},
 	4: {
 		0: uint8(kHistoRed),
 		1: uint8(kHistoBlue),
 	},
 }
 
 // C documentation
 //
 //	// Clamp histogram and transform bits.
 func ClampBits(tls *libc.TLS, width int32, height int32, bits int32, min_bits int32, max_bits int32, image_size_max int32) (r int32) {
 	var image_size, v1, v2 int32
 	var v3, v4, v6, v7 uint32_t
 	_, _, _, _, _, _, _ = image_size, v1, v2, v3, v4, v6, v7
 	if bits < min_bits {
 		v1 = min_bits
 	} else {
 		if bits > max_bits {
 			v2 = max_bits
 		} else {
 			v2 = bits
 		}
 		v1 = v2
 	}
 	bits = v1
 	v3 = libc.Uint32FromInt32(bits)
 	v4 = (libc.Uint32FromInt32(width) + libc.Uint32FromInt32(libc.Int32FromInt32(1)<<v3) - uint32(1)) >> v3
 	goto _5
 _5:
 	v6 = libc.Uint32FromInt32(bits)
 	v7 = (libc.Uint32FromInt32(height) + libc.Uint32FromInt32(libc.Int32FromInt32(1)<<v6) - uint32(1)) >> v6
 	goto _8
 _8:
 	image_size = libc.Int32FromUint32(v4 * v7)
 	for bits < max_bits && image_size > image_size_max {
 		bits = bits + 1
 		v3 = libc.Uint32FromInt32(bits)
 		v4 = (libc.Uint32FromInt32(width) + libc.Uint32FromInt32(libc.Int32FromInt32(1)<<v3) - uint32(1)) >> v3
 		goto _11
 	_11:
 		v6 = libc.Uint32FromInt32(bits)
 		v7 = (libc.Uint32FromInt32(height) + libc.Uint32FromInt32(libc.Int32FromInt32(1)<<v6) - uint32(1)) >> v6
 		goto _14
 	_14:
 		image_size = libc.Int32FromUint32(v4 * v7)
 	}
 	// In case the bits reduce the image too much, choose the smallest value
 	// setting the histogram image size to 1.
 	for bits > min_bits && image_size == int32(1) {
 		v3 = libc.Uint32FromInt32(bits - int32(1))
 		v4 = (libc.Uint32FromInt32(width) + libc.Uint32FromInt32(libc.Int32FromInt32(1)<<v3) - uint32(1)) >> v3
 		goto _17
 	_17:
 		v6 = libc.Uint32FromInt32(bits - int32(1))
 		v7 = (libc.Uint32FromInt32(height) + libc.Uint32FromInt32(libc.Int32FromInt32(1)<<v6) - uint32(1)) >> v6
 		goto _20
 	_20:
 		image_size = libc.Int32FromUint32(v4 * v7)
 		if image_size != int32(1) {
 			break
 		}
 		bits = bits - 1
 	}
 	return bits
 }
 
 func GetHistoBits(tls *libc.TLS, method int32, use_palette int32, width int32, height int32) (r int32) {
 	var histo_bits, v1 int32
 	_, _ = histo_bits, v1
 	if use_palette != 0 {
 		v1 = int32(9)
 	} else {
 		v1 = int32(7)
 	}
 	// Make tile size a function of encoding method (Range: 0 to 6).
 	histo_bits = v1 - method
 	return ClampBits(tls, width, height, histo_bits, int32(MIN_HUFFMAN_BITS), libc.Int32FromInt32(MIN_HUFFMAN_BITS)+libc.Int32FromInt32(1)<<libc.Int32FromInt32(NUM_HUFFMAN_BITS)-libc.Int32FromInt32(1), int32(MAX_HUFF_IMAGE_SIZE))
 }
 
 func GetTransformBits(tls *libc.TLS, method int32, histo_bits int32) (r int32) {
 	var max_transform_bits, res, v1, v2, v3 int32
 	_, _, _, _, _ = max_transform_bits, res, v1, v2, v3
 	if method < int32(4) {
 		v1 = int32(6)
 	} else {
 		if method > int32(4) {
 			v2 = int32(4)
 		} else {
 			v2 = int32(5)
 		}
 		v1 = v2
 	}
 	max_transform_bits = v1
 	if histo_bits > max_transform_bits {
 		v3 = max_transform_bits
 	} else {
 		v3 = histo_bits
 	}
 	res = v3
 	return res
 }
 
 // C documentation
 //
 //	// Set of parameters to be used in each iteration of the cruncher.
 type CrunchSubConfig = struct {
 	Flz77        int32
 	Fdo_no_cache int32
 }
 
 type CrunchConfig = struct {
 	Fentropy_idx          int32
 	Fpalette_sorting_type PaletteSorting1
 	Fsub_configs          [2]CrunchSubConfig
 	Fsub_configs_size     int32
 }
 
 // +2 because we add a palette sorting configuration for kPalette and
 // kPaletteAndSpatial.
 
 func EncoderAnalyze(tls *libc.TLS, enc uintptr, crunch_configs uintptr, crunch_configs_size uintptr, red_and_blue_always_zero uintptr) (r int32) {
 	bp := tls.Alloc(16)
 	defer tls.Free(16)
 	var config, pic uintptr
 	var do_no_cache, height, i, j, low_effort, method, n_lz77s, sorting_method, transform_bits, use_palette, width, v1 int32
 	var typed_sorting_method PaletteSorting1
 	var _ /* min_entropy_ix at bp+0 */ EntropyIx
 	_, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = config, do_no_cache, height, i, j, low_effort, method, n_lz77s, pic, sorting_method, transform_bits, typed_sorting_method, use_palette, width, v1
 	pic = (*VP8LEncoder)(unsafe.Pointer(enc)).Fpic
 	width = (*WebPPicture)(unsafe.Pointer(pic)).Fwidth
 	height = (*WebPPicture)(unsafe.Pointer(pic)).Fheight
 	config = (*VP8LEncoder)(unsafe.Pointer(enc)).Fconfig
 	method = (*WebPConfig)(unsafe.Pointer(config)).Fmethod
 	low_effort = libc.BoolInt32((*WebPConfig)(unsafe.Pointer(config)).Fmethod == libc.Int32FromInt32(0))
 	// If set to 0, analyze the cache with the computed cache value. If 1, also
 	// analyze with no-cache.
 	do_no_cache = 0
 	// Check whether a palette is possible.
 	(*VP8LEncoder)(unsafe.Pointer(enc)).Fpalette_size = GetColorPalette(tls, pic, enc+1128)
 	use_palette = libc.BoolInt32((*VP8LEncoder)(unsafe.Pointer(enc)).Fpalette_size <= int32(MAX_PALETTE_SIZE))
 	if !(use_palette != 0) {
 		(*VP8LEncoder)(unsafe.Pointer(enc)).Fpalette_size = 0
 	}
 	// Empirical bit sizes.
 	(*VP8LEncoder)(unsafe.Pointer(enc)).Fhisto_bits = GetHistoBits(tls, method, use_palette, (*WebPPicture)(unsafe.Pointer(pic)).Fwidth, (*WebPPicture)(unsafe.Pointer(pic)).Fheight)
 	transform_bits = GetTransformBits(tls, method, (*VP8LEncoder)(unsafe.Pointer(enc)).Fhisto_bits)
 	(*VP8LEncoder)(unsafe.Pointer(enc)).Fpredictor_transform_bits = transform_bits
 	(*VP8LEncoder)(unsafe.Pointer(enc)).Fcross_color_transform_bits = transform_bits
 	if low_effort != 0 {
 		// AnalyzeEntropy is somewhat slow.
 		if use_palette != 0 {
 			v1 = int32(kPalette)
 		} else {
 			v1 = int32(kSpatialSubGreen)
 		}
 		(**(**CrunchConfig)(__ccgo_up(crunch_configs))).Fentropy_idx = v1
 		if use_palette != 0 {
 			v1 = int32(kSortedDefault)
 		} else {
 			v1 = int32(kUnusedPalette)
 		}
 		(**(**CrunchConfig)(__ccgo_up(crunch_configs))).Fpalette_sorting_type = v1
 		n_lz77s = int32(1)
 		**(**int32)(__ccgo_up(crunch_configs_size)) = int32(1)
 	} else {
 		// Try out multiple LZ77 on images with few colors.
 		if (*VP8LEncoder)(unsafe.Pointer(enc)).Fpalette_size > 0 && (*VP8LEncoder)(unsafe.Pointer(enc)).Fpalette_size <= int32(16) {
 			v1 = int32(2)
 		} else {
 			v1 = int32(1)
 		}
 		n_lz77s = v1
 		if !(AnalyzeEntropy(tls, (*WebPPicture)(unsafe.Pointer(pic)).Fargb, width, height, (*WebPPicture)(unsafe.Pointer(pic)).Fargb_stride, use_palette, (*VP8LEncoder)(unsafe.Pointer(enc)).Fpalette_size, transform_bits, bp, red_and_blue_always_zero) != 0) {
 			return 0
 		}
 		if method == int32(6) && (*WebPConfig)(unsafe.Pointer(config)).Fquality == libc.Float32FromInt32(100) {
 			do_no_cache = int32(1)
 			// Go brute force on all transforms.
 			**(**int32)(__ccgo_up(crunch_configs_size)) = 0
 			i = 0
 			for {
 				if !(i < int32(kNumEntropyIx)) {
 					break
 				}
 				// We can only apply kPalette or kPaletteAndSpatial if we can indeed use
 				// a palette.
 				if i != int32(kPalette) && i != int32(kPaletteAndSpatial) || use_palette != 0 {
 					if use_palette != 0 && (i == int32(kPalette) || i == int32(kPaletteAndSpatial)) {
 						sorting_method = 0
 						for {
 							if !(sorting_method < int32(kPaletteSortingNum)) {
 								break
 							}
 							typed_sorting_method = sorting_method
 							// TODO(vrabaud) kSortedDefault should be tested. It is omitted
 							// for now for backward compatibility.
 							if typed_sorting_method == int32(kUnusedPalette) || typed_sorting_method == int32(kSortedDefault) {
 								goto _5
 							}
 							(**(**CrunchConfig)(__ccgo_up(crunch_configs + uintptr(**(**int32)(__ccgo_up(crunch_configs_size)))*28))).Fentropy_idx = i
 							(**(**CrunchConfig)(__ccgo_up(crunch_configs + uintptr(**(**int32)(__ccgo_up(crunch_configs_size)))*28))).Fpalette_sorting_type = typed_sorting_method
 							**(**int32)(__ccgo_up(crunch_configs_size)) = **(**int32)(__ccgo_up(crunch_configs_size)) + 1
 							goto _5
 						_5:
 							;
 							sorting_method = sorting_method + 1
 						}
 					} else {
 						(**(**CrunchConfig)(__ccgo_up(crunch_configs + uintptr(**(**int32)(__ccgo_up(crunch_configs_size)))*28))).Fentropy_idx = i
 						(**(**CrunchConfig)(__ccgo_up(crunch_configs + uintptr(**(**int32)(__ccgo_up(crunch_configs_size)))*28))).Fpalette_sorting_type = int32(kUnusedPalette)
 						**(**int32)(__ccgo_up(crunch_configs_size)) = **(**int32)(__ccgo_up(crunch_configs_size)) + 1
 					}
 				}
 				goto _4
 			_4:
 				;
 				i = i + 1
 			}
 		} else {
 			// Only choose the guessed best transform.
 			**(**int32)(__ccgo_up(crunch_configs_size)) = int32(1)
 			(**(**CrunchConfig)(__ccgo_up(crunch_configs))).Fentropy_idx = **(**EntropyIx)(__ccgo_up(bp))
 			if use_palette != 0 {
 				v1 = int32(kMinimizeDelta)
 			} else {
 				v1 = int32(kUnusedPalette)
 			}
 			(**(**CrunchConfig)(__ccgo_up(crunch_configs))).Fpalette_sorting_type = v1
 			if (*WebPConfig)(unsafe.Pointer(config)).Fquality >= libc.Float32FromInt32(75) && method == int32(5) {
 				// Test with and without color cache.
 				do_no_cache = int32(1)
 				// If we have a palette, also check in combination with spatial.
 				if **(**EntropyIx)(__ccgo_up(bp)) == int32(kPalette) {
 					**(**int32)(__ccgo_up(crunch_configs_size)) = int32(2)
 					(**(**CrunchConfig)(__ccgo_up(crunch_configs + 1*28))).Fentropy_idx = int32(kPaletteAndSpatial)
 					(**(**CrunchConfig)(__ccgo_up(crunch_configs + 1*28))).Fpalette_sorting_type = int32(kMinimizeDelta)
 				}
 			}
 		}
 	}
 	// Fill in the different LZ77s.
 	i = 0
 	for {
 		if !(i < **(**int32)(__ccgo_up(crunch_configs_size))) {
 			break
 		}
 		j = 0
 		for {
 			if !(j < n_lz77s) {
 				break
 			}
 			if j == 0 {
 				v1 = int32(kLZ77Standard) | int32(kLZ77RLE)
 			} else {
 				v1 = int32(kLZ77Box)
 			}
 			(**(**CrunchSubConfig)(__ccgo_up(crunch_configs + uintptr(i)*28 + 8 + uintptr(j)*8))).Flz77 = v1
 			(**(**CrunchSubConfig)(__ccgo_up(crunch_configs + uintptr(i)*28 + 8 + uintptr(j)*8))).Fdo_no_cache = do_no_cache
 			goto _8
 		_8:
 			;
 			j = j + 1
 		}
 		(**(**CrunchConfig)(__ccgo_up(crunch_configs + uintptr(i)*28))).Fsub_configs_size = n_lz77s
 		goto _7
 	_7:
 		;
 		i = i + 1
 	}
 	return int32(1)
 }
 
 func EncoderInit(tls *libc.TLS, enc uintptr) (r int32) {
 	var height, i, pix_cnt, refs_block_size, width int32
 	var pic uintptr
 	_, _, _, _, _, _ = height, i, pic, pix_cnt, refs_block_size, width
 	pic = (*VP8LEncoder)(unsafe.Pointer(enc)).Fpic
 	width = (*WebPPicture)(unsafe.Pointer(pic)).Fwidth
 	height = (*WebPPicture)(unsafe.Pointer(pic)).Fheight
 	pix_cnt = width * height
 	// we round the block size up, so we're guaranteed to have
 	// at most MAX_REFS_BLOCK_PER_IMAGE blocks used:
 	refs_block_size = (pix_cnt-int32(1))/int32(MAX_REFS_BLOCK_PER_IMAGE) + int32(1)
 	if !(VP8LHashChainInit(tls, enc+2312, pix_cnt) != 0) {
 		return 0
 	}
 	i = 0
 	for {
 		if !(i < int32(4)) {
 			break
 		}
 		VP8LBackwardRefsInit(tls, enc+2152+uintptr(i)*40, refs_block_size)
 		goto _1
 	_1:
 		;
 		i = i + 1
 	}
 	return int32(1)
 }
 
 // C documentation
 //
 //	// Returns false in case of memory error.
 func GetHuffBitLengthsAndCodes(tls *libc.TLS, histogram_image uintptr, huffman_codes uintptr) (r int32) {
 	var bit_length, histogram_image_size, i, k, max_num_symbols, num_symbols, ok, v3, v4, v5, v7, v8 int32
 	var buf_rle, codes, codes1, codes2, histo, histo1, huff_tree, lengths, mem_buf uintptr
 	var total_length_size uint64_t
 	_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = bit_length, buf_rle, codes, codes1, codes2, histo, histo1, histogram_image_size, huff_tree, i, k, lengths, max_num_symbols, mem_buf, num_symbols, ok, total_length_size, v3, v4, v5, v7, v8
 	ok = 0
 	total_length_size = uint64(0)
 	mem_buf = libc.UintptrFromInt32(0)
 	histogram_image_size = (*VP8LHistogramSet)(unsafe.Pointer(histogram_image)).Fsize
 	max_num_symbols = 0
 	buf_rle = libc.UintptrFromInt32(0)
 	huff_tree = libc.UintptrFromInt32(0)
 	// Iterate over all histograms and get the aggregate number of codes used.
 	i = 0
 	for {
 		if !(i < histogram_image_size) {
 			break
 		}
 		histo = **(**uintptr)(__ccgo_up((*VP8LHistogramSet)(unsafe.Pointer(histogram_image)).Fhistograms + uintptr(i)*8))
 		codes = huffman_codes + uintptr(int32(5)*i)*24
 		k = 0
 		for {
 			if !(k < int32(5)) {
 				break
 			}
 			if k == 0 {
 				v4 = (*VP8LHistogram)(unsafe.Pointer(histo)).Fpalette_code_bits
 				if v4 > 0 {
 					v7 = int32(1) << v4
 				} else {
 					v7 = 0
 				}
 				v5 = libc.Int32FromInt32(NUM_LITERAL_CODES) + libc.Int32FromInt32(NUM_LENGTH_CODES) + v7
 				goto _6
 			_6:
 				v3 = v5
 			} else {
 				if k == int32(4) {
 					v8 = int32(NUM_DISTANCE_CODES)
 				} else {
 					v8 = int32(256)
 				}
 				v3 = v8
 			}
 			num_symbols = v3
 			(**(**HuffmanTreeCode)(__ccgo_up(codes + uintptr(k)*24))).Fnum_symbols = num_symbols
 			total_length_size = total_length_size + libc.Uint64FromInt32(num_symbols)
 			goto _2
 		_2:
 			;
 			k = k + 1
 		}
 		goto _1
 	_1:
 		;
 		i = i + 1
 	}
 	// Allocate and Set Huffman codes.
 	mem_buf = WebPSafeCalloc(tls, total_length_size, libc.Uint64FromInt64(1)+libc.Uint64FromInt64(2))
 	if mem_buf == libc.UintptrFromInt32(0) {
 		goto End
 	}
 	codes1 = mem_buf
 	lengths = codes1 + uintptr(total_length_size)*2
 	i = 0
 	for {
 		if !(i < int32(5)*histogram_image_size) {
 			break
 		}
 		bit_length = (**(**HuffmanTreeCode)(__ccgo_up(huffman_codes + uintptr(i)*24))).Fnum_symbols
 		(**(**HuffmanTreeCode)(__ccgo_up(huffman_codes + uintptr(i)*24))).Fcodes = codes1
 		(**(**HuffmanTreeCode)(__ccgo_up(huffman_codes + uintptr(i)*24))).Fcode_lengths = lengths
 		codes1 = codes1 + uintptr(bit_length)*2
 		lengths = lengths + uintptr(bit_length)
 		if max_num_symbols < bit_length {
 			max_num_symbols = bit_length
 		}
 		goto _9
 	_9:
 		;
 		i = i + 1
 	}
 	buf_rle = WebPSafeMalloc(tls, uint64(1), libc.Uint64FromInt32(max_num_symbols))
 	huff_tree = WebPSafeMalloc(tls, uint64(3)*libc.Uint64FromInt32(max_num_symbols), uint64(16))
 	if buf_rle == libc.UintptrFromInt32(0) || huff_tree == libc.UintptrFromInt32(0) {
 		goto End
 	}
 	// Create Huffman trees.
 	i = 0
 	for {
 		if !(i < histogram_image_size) {
 			break
 		}
 		codes2 = huffman_codes + uintptr(int32(5)*i)*24
 		histo1 = **(**uintptr)(__ccgo_up((*VP8LHistogramSet)(unsafe.Pointer(histogram_image)).Fhistograms + uintptr(i)*8))
 		VP8LCreateHuffmanTree(tls, (*VP8LHistogram)(unsafe.Pointer(histo1)).Fliteral, int32(15), buf_rle, huff_tree, codes2+uintptr(0)*24)
 		VP8LCreateHuffmanTree(tls, histo1+8, int32(15), buf_rle, huff_tree, codes2+uintptr(1)*24)
 		VP8LCreateHuffmanTree(tls, histo1+1032, int32(15), buf_rle, huff_tree, codes2+uintptr(2)*24)
 		VP8LCreateHuffmanTree(tls, histo1+2056, int32(15), buf_rle, huff_tree, codes2+uintptr(3)*24)
 		VP8LCreateHuffmanTree(tls, histo1+3080, int32(15), buf_rle, huff_tree, codes2+uintptr(4)*24)
 		goto _10
 	_10:
 		;
 		i = i + 1
 	}
 	ok = int32(1)
 	goto End
 End:
 	;
 	WebPSafeFree(tls, huff_tree)
 	WebPSafeFree(tls, buf_rle)
 	if !(ok != 0) {
 		WebPSafeFree(tls, mem_buf)
 		libc.X__builtin___memset_chk(tls, huffman_codes, 0, libc.Uint64FromInt32(int32(5)*histogram_image_size)*uint64(24), ^__predefined_size_t(0))
 	}
 	return ok
 }
 
 func StoreHuffmanTreeOfHuffmanTreeToBitMask(tls *libc.TLS, bw1 uintptr, code_length_bitdepth uintptr) {
 	var codes_to_store, i, v4 int32
 	var v2 uintptr
 	var v3 uint32_t
 	_, _, _, _, _ = codes_to_store, i, v2, v3, v4
 	// Throw away trailing zeros:
 	codes_to_store = int32(CODE_LENGTH_CODES)
 	for {
 		if !(codes_to_store > int32(4)) {
 			break
 		}
 		if libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(code_length_bitdepth + uintptr(kStorageOrder[codes_to_store-int32(1)])))) != 0 {
 			break
 		}
 		goto _1
 	_1:
 		;
 		codes_to_store = codes_to_store - 1
 	}
 	v2 = bw1
 	v3 = libc.Uint32FromInt32(codes_to_store - int32(4))
 	v4 = int32(4)
 	if libc.Uint64FromInt64(4) == libc.Uint64FromInt32(4) {
 		if v4 > libc.Int32FromInt32(0) {
 			if (*VP8LBitWriter)(unsafe.Pointer(v2)).Fused >= libc.Int32FromInt32(32) {
 				VP8LPutBitsFlushBits(tls, v2)
 			}
 			**(**vp8l_atype_t)(__ccgo_up(v2)) |= uint64(v3) << (*VP8LBitWriter)(unsafe.Pointer(v2)).Fused
 			**(**int32)(__ccgo_up(v2 + 8)) += v4
 		}
 	} else {
 		VP8LPutBitsInternal(tls, v2, v3, v4)
 	}
 	i = 0
 	for {
 		if !(i < codes_to_store) {
 			break
 		}
 		v2 = bw1
 		v3 = uint32(**(**uint8_t)(__ccgo_up(code_length_bitdepth + uintptr(kStorageOrder[i]))))
 		v4 = int32(3)
 		if libc.Uint64FromInt64(4) == libc.Uint64FromInt32(4) {
 			if v4 > libc.Int32FromInt32(0) {
 				if (*VP8LBitWriter)(unsafe.Pointer(v2)).Fused >= libc.Int32FromInt32(32) {
 					VP8LPutBitsFlushBits(tls, v2)
 				}
 				**(**vp8l_atype_t)(__ccgo_up(v2)) |= uint64(v3) << (*VP8LBitWriter)(unsafe.Pointer(v2)).Fused
 				**(**int32)(__ccgo_up(v2 + 8)) += v4
 			}
 		} else {
 			VP8LPutBitsInternal(tls, v2, v3, v4)
 		}
 		goto _5
 	_5:
 		;
 		i = i + 1
 	}
 }
 
 // RFC 1951 will calm you down if you are worried about this funny sequence.
 // This sequence is tuned from that, but more weighted for lower symbol count,
 // and more spiking histograms.
 var kStorageOrder = [19]uint8_t{
 	0:  uint8(17),
 	1:  uint8(18),
 	3:  uint8(1),
 	4:  uint8(2),
 	5:  uint8(3),
 	6:  uint8(4),
 	7:  uint8(5),
 	8:  uint8(16),
 	9:  uint8(6),
 	10: uint8(7),
 	11: uint8(8),
 	12: uint8(9),
 	13: uint8(10),
 	14: uint8(11),
 	15: uint8(12),
 	16: uint8(13),
 	17: uint8(14),
 	18: uint8(15),
 }
 
 func ClearHuffmanTreeIfOnlyOneSymbol(tls *libc.TLS, huffman_code uintptr) {
 	var count, k int32
 	_, _ = count, k
 	count = 0
 	k = 0
 	for {
 		if !(k < (*HuffmanTreeCode)(unsafe.Pointer(huffman_code)).Fnum_symbols) {
 			break
 		}
 		if libc.Int32FromUint8(**(**uint8_t)(__ccgo_up((*HuffmanTreeCode)(unsafe.Pointer(huffman_code)).Fcode_lengths + uintptr(k)))) != 0 {
 			count = count + 1
 			if count > int32(1) {
 				return
 			}
 		}
 		goto _1
 	_1:
 		;
 		k = k + 1
 	}
 	k = 0
 	for {
 		if !(k < (*HuffmanTreeCode)(unsafe.Pointer(huffman_code)).Fnum_symbols) {
 			break
 		}
 		**(**uint8_t)(__ccgo_up((*HuffmanTreeCode)(unsafe.Pointer(huffman_code)).Fcode_lengths + uintptr(k))) = uint8(0)
 		**(**uint16_t)(__ccgo_up((*HuffmanTreeCode)(unsafe.Pointer(huffman_code)).Fcodes + uintptr(k)*2)) = uint16(0)
 		goto _2
 	_2:
 		;
 		k = k + 1
 	}
 }
 
 func StoreHuffmanTreeToBitMask(tls *libc.TLS, bw1 uintptr, tokens uintptr, num_tokens int32, huffman_code uintptr) {
 	var extra_bits, i, ix, v4 int32
 	var v2 uintptr
 	var v3 uint32_t
 	_, _, _, _, _, _ = extra_bits, i, ix, v2, v3, v4
 	i = 0
 	for {
 		if !(i < num_tokens) {
 			break
 		}
 		ix = libc.Int32FromUint8((**(**HuffmanTreeToken)(__ccgo_up(tokens + uintptr(i)*2))).Fcode)
 		extra_bits = libc.Int32FromUint8((**(**HuffmanTreeToken)(__ccgo_up(tokens + uintptr(i)*2))).Fextra_bits)
 		v2 = bw1
 		v3 = uint32(**(**uint16_t)(__ccgo_up((*HuffmanTreeCode)(unsafe.Pointer(huffman_code)).Fcodes + uintptr(ix)*2)))
 		v4 = libc.Int32FromUint8(**(**uint8_t)(__ccgo_up((*HuffmanTreeCode)(unsafe.Pointer(huffman_code)).Fcode_lengths + uintptr(ix))))
 		if libc.Uint64FromInt64(4) == libc.Uint64FromInt32(4) {
 			if v4 > libc.Int32FromInt32(0) {
 				if (*VP8LBitWriter)(unsafe.Pointer(v2)).Fused >= libc.Int32FromInt32(32) {
 					VP8LPutBitsFlushBits(tls, v2)
 				}
 				**(**vp8l_atype_t)(__ccgo_up(v2)) |= uint64(v3) << (*VP8LBitWriter)(unsafe.Pointer(v2)).Fused
 				**(**int32)(__ccgo_up(v2 + 8)) += v4
 			}
 		} else {
 			VP8LPutBitsInternal(tls, v2, v3, v4)
 		}
 		switch ix {
 		case int32(16):
 			v2 = bw1
 			v3 = libc.Uint32FromInt32(extra_bits)
 			v4 = int32(2)
 			if libc.Uint64FromInt64(4) == libc.Uint64FromInt32(4) {
 				if v4 > libc.Int32FromInt32(0) {
 					if (*VP8LBitWriter)(unsafe.Pointer(v2)).Fused >= libc.Int32FromInt32(32) {
 						VP8LPutBitsFlushBits(tls, v2)
 					}
 					**(**vp8l_atype_t)(__ccgo_up(v2)) |= uint64(v3) << (*VP8LBitWriter)(unsafe.Pointer(v2)).Fused
 					**(**int32)(__ccgo_up(v2 + 8)) += v4
 				}
 			} else {
 				VP8LPutBitsInternal(tls, v2, v3, v4)
 			}
 		case int32(17):
 			v2 = bw1
 			v3 = libc.Uint32FromInt32(extra_bits)
 			v4 = int32(3)
 			if libc.Uint64FromInt64(4) == libc.Uint64FromInt32(4) {
 				if v4 > libc.Int32FromInt32(0) {
 					if (*VP8LBitWriter)(unsafe.Pointer(v2)).Fused >= libc.Int32FromInt32(32) {
 						VP8LPutBitsFlushBits(tls, v2)
 					}
 					**(**vp8l_atype_t)(__ccgo_up(v2)) |= uint64(v3) << (*VP8LBitWriter)(unsafe.Pointer(v2)).Fused
 					**(**int32)(__ccgo_up(v2 + 8)) += v4
 				}
 			} else {
 				VP8LPutBitsInternal(tls, v2, v3, v4)
 			}
 		case int32(18):
 			v2 = bw1
 			v3 = libc.Uint32FromInt32(extra_bits)
 			v4 = int32(7)
 			if libc.Uint64FromInt64(4) == libc.Uint64FromInt32(4) {
 				if v4 > libc.Int32FromInt32(0) {
 					if (*VP8LBitWriter)(unsafe.Pointer(v2)).Fused >= libc.Int32FromInt32(32) {
 						VP8LPutBitsFlushBits(tls, v2)
 					}
 					**(**vp8l_atype_t)(__ccgo_up(v2)) |= uint64(v3) << (*VP8LBitWriter)(unsafe.Pointer(v2)).Fused
 					**(**int32)(__ccgo_up(v2 + 8)) += v4
 				}
 			} else {
 				VP8LPutBitsInternal(tls, v2, v3, v4)
 			}
 			break
 		}
 		goto _1
 	_1:
 		;
 		i = i + 1
 	}
 }
 
 // C documentation
 //
 //	// 'huff_tree' and 'tokens' are pre-alloacted buffers.
 func StoreFullHuffmanCode(tls *libc.TLS, bw1 uintptr, huff_tree uintptr, tokens uintptr, tree uintptr) {
 	bp := tls.Alloc(192)
 	defer tls.Free(192)
 	var i, i1, ix, length, max_tokens, nbitpairs, nbits, num_tokens, trailing_zero_bits, trimmed_length, write_trimmed_length, v3 int32
 	var v1 uintptr
 	var v2 uint32_t
 	var _ /* buf_rle at bp+164 */ [19]uint8_t
 	var _ /* code_length_bitdepth at bp+0 */ [19]uint8_t
 	var _ /* code_length_bitdepth_symbols at bp+20 */ [19]uint16_t
 	var _ /* histogram at bp+88 */ [19]uint32_t
 	var _ /* huffman_code at bp+64 */ HuffmanTreeCode
 	_, _, _, _, _, _, _, _, _, _, _, _, _, _ = i, i1, ix, length, max_tokens, nbitpairs, nbits, num_tokens, trailing_zero_bits, trimmed_length, write_trimmed_length, v1, v2, v3
 	**(**[19]uint8_t)(__ccgo_up(bp)) = [19]uint8_t{}
 	**(**[19]uint16_t)(__ccgo_up(bp + 20)) = [19]uint16_t{}
 	max_tokens = (*HuffmanTreeCode)(unsafe.Pointer(tree)).Fnum_symbols
 	(**(**HuffmanTreeCode)(__ccgo_up(bp + 64))).Fnum_symbols = int32(CODE_LENGTH_CODES)
 	(**(**HuffmanTreeCode)(__ccgo_up(bp + 64))).Fcode_lengths = bp
 	(**(**HuffmanTreeCode)(__ccgo_up(bp + 64))).Fcodes = bp + 20
 	v1 = bw1
 	v2 = uint32(0)
 	v3 = int32(1)
 	if libc.Uint64FromInt64(4) == libc.Uint64FromInt32(4) {
 		if v3 > libc.Int32FromInt32(0) {
 			if (*VP8LBitWriter)(unsafe.Pointer(v1)).Fused >= libc.Int32FromInt32(32) {
 				VP8LPutBitsFlushBits(tls, v1)
 			}
 			**(**vp8l_atype_t)(__ccgo_up(v1)) |= uint64(v2) << (*VP8LBitWriter)(unsafe.Pointer(v1)).Fused
 			**(**int32)(__ccgo_up(v1 + 8)) += v3
 		}
 	} else {
 		VP8LPutBitsInternal(tls, v1, v2, v3)
 	}
 	num_tokens = VP8LCreateCompressedHuffmanTree(tls, tree, tokens, max_tokens)
 	**(**[19]uint32_t)(__ccgo_up(bp + 88)) = [19]uint32_t{}
 	**(**[19]uint8_t)(__ccgo_up(bp + 164)) = [19]uint8_t{}
 	i = 0
 	for {
 		if !(i < num_tokens) {
 			break
 		}
 		(**(**[19]uint32_t)(__ccgo_up(bp + 88)))[(**(**HuffmanTreeToken)(__ccgo_up(tokens + uintptr(i)*2))).Fcode] = (**(**[19]uint32_t)(__ccgo_up(bp + 88)))[(**(**HuffmanTreeToken)(__ccgo_up(tokens + uintptr(i)*2))).Fcode] + 1
 		goto _4
 	_4:
 		;
 		i = i + 1
 	}
 	VP8LCreateHuffmanTree(tls, bp+88, int32(7), bp+164, huff_tree, bp+64)
 	StoreHuffmanTreeOfHuffmanTreeToBitMask(tls, bw1, bp)
 	ClearHuffmanTreeIfOnlyOneSymbol(tls, bp+64)
 	trailing_zero_bits = 0
 	trimmed_length = num_tokens
 	i1 = num_tokens
 	for {
 		v3 = i1
 		i1 = i1 - 1
 		if !(v3 > 0) {
 			break
 		}
 		ix = libc.Int32FromUint8((**(**HuffmanTreeToken)(__ccgo_up(tokens + uintptr(i1)*2))).Fcode)
 		if ix == 0 || ix == int32(17) || ix == int32(18) {
 			trimmed_length = trimmed_length - 1 // discount trailing zeros
 			trailing_zero_bits = trailing_zero_bits + libc.Int32FromUint8((**(**[19]uint8_t)(__ccgo_up(bp)))[ix])
 			if ix == int32(17) {
 				trailing_zero_bits = trailing_zero_bits + int32(3)
 			} else {
 				if ix == int32(18) {
 					trailing_zero_bits = trailing_zero_bits + int32(7)
 				}
 			}
 		} else {
 			break
 		}
 	}
 	write_trimmed_length = libc.BoolInt32(trimmed_length > int32(1) && trailing_zero_bits > int32(12))
 	if write_trimmed_length != 0 {
 		v3 = trimmed_length
 	} else {
 		v3 = num_tokens
 	}
 	length = v3
 	v1 = bw1
 	v2 = libc.Uint32FromInt32(write_trimmed_length)
 	v3 = int32(1)
 	if libc.Uint64FromInt64(4) == libc.Uint64FromInt32(4) {
 		if v3 > libc.Int32FromInt32(0) {
 			if (*VP8LBitWriter)(unsafe.Pointer(v1)).Fused >= libc.Int32FromInt32(32) {
 				VP8LPutBitsFlushBits(tls, v1)
 			}
 			**(**vp8l_atype_t)(__ccgo_up(v1)) |= uint64(v2) << (*VP8LBitWriter)(unsafe.Pointer(v1)).Fused
 			**(**int32)(__ccgo_up(v1 + 8)) += v3
 		}
 	} else {
 		VP8LPutBitsInternal(tls, v1, v2, v3)
 	}
 	if write_trimmed_length != 0 {
 		if trimmed_length == int32(2) {
 			v1 = bw1
 			v2 = uint32(0)
 			v3 = libc.Int32FromInt32(3) + libc.Int32FromInt32(2)
 			if libc.Uint64FromInt64(4) == libc.Uint64FromInt32(4) {
 				if v3 > libc.Int32FromInt32(0) {
 					if (*VP8LBitWriter)(unsafe.Pointer(v1)).Fused >= libc.Int32FromInt32(32) {
 						VP8LPutBitsFlushBits(tls, v1)
 					}
 					**(**vp8l_atype_t)(__ccgo_up(v1)) |= uint64(v2) << (*VP8LBitWriter)(unsafe.Pointer(v1)).Fused
 					**(**int32)(__ccgo_up(v1 + 8)) += v3
 				}
 			} else {
 				VP8LPutBitsInternal(tls, v1, v2, v3)
 			} // nbitpairs=1, trimmed_length=2
 		} else {
 			v3 = int32(31) ^ libc.X__builtin_clz(tls, libc.Uint32FromInt32(trimmed_length-int32(2)))
 			goto _14
 		_14:
 			nbits = v3
 			nbitpairs = nbits/int32(2) + int32(1)
 			v1 = bw1
 			v2 = libc.Uint32FromInt32(nbitpairs - int32(1))
 			v3 = int32(3)
 			if libc.Uint64FromInt64(4) == libc.Uint64FromInt32(4) {
 				if v3 > libc.Int32FromInt32(0) {
 					if (*VP8LBitWriter)(unsafe.Pointer(v1)).Fused >= libc.Int32FromInt32(32) {
 						VP8LPutBitsFlushBits(tls, v1)
 					}
 					**(**vp8l_atype_t)(__ccgo_up(v1)) |= uint64(v2) << (*VP8LBitWriter)(unsafe.Pointer(v1)).Fused
 					**(**int32)(__ccgo_up(v1 + 8)) += v3
 				}
 			} else {
 				VP8LPutBitsInternal(tls, v1, v2, v3)
 			}
 			v1 = bw1
 			v2 = libc.Uint32FromInt32(trimmed_length - int32(2))
 			v3 = nbitpairs * int32(2)
 			if libc.Uint64FromInt64(4) == libc.Uint64FromInt32(4) {
 				if v3 > libc.Int32FromInt32(0) {
 					if (*VP8LBitWriter)(unsafe.Pointer(v1)).Fused >= libc.Int32FromInt32(32) {
 						VP8LPutBitsFlushBits(tls, v1)
 					}
 					**(**vp8l_atype_t)(__ccgo_up(v1)) |= uint64(v2) << (*VP8LBitWriter)(unsafe.Pointer(v1)).Fused
 					**(**int32)(__ccgo_up(v1 + 8)) += v3
 				}
 			} else {
 				VP8LPutBitsInternal(tls, v1, v2, v3)
 			}
 		}
 	}
 	StoreHuffmanTreeToBitMask(tls, bw1, tokens, length, bp+64)
 }
 
 // C documentation
 //
 //	// 'huff_tree' and 'tokens' are pre-alloacted buffers.
 func StoreHuffmanCode(tls *libc.TLS, bw1 uintptr, huff_tree uintptr, tokens uintptr, huffman_code uintptr) {
 	var count, i, kMaxBits, kMaxSymbol, v4 int32
 	var symbols [2]int32
 	var v2 uintptr
 	var v3 uint32_t
 	_, _, _, _, _, _, _, _ = count, i, kMaxBits, kMaxSymbol, symbols, v2, v3, v4
 	count = 0
 	symbols = [2]int32{}
 	kMaxBits = int32(8)
 	kMaxSymbol = int32(1) << kMaxBits
 	// Check whether it's a small tree.
 	i = 0
 	for {
 		if !(i < (*HuffmanTreeCode)(unsafe.Pointer(huffman_code)).Fnum_symbols && count < int32(3)) {
 			break
 		}
 		if libc.Int32FromUint8(**(**uint8_t)(__ccgo_up((*HuffmanTreeCode)(unsafe.Pointer(huffman_code)).Fcode_lengths + uintptr(i)))) != 0 {
 			if count < int32(2) {
 				symbols[count] = i
 			}
 			count = count + 1
 		}
 		goto _1
 	_1:
 		;
 		i = i + 1
 	}
 	if count == 0 { // emit minimal tree for empty cases
 		// bits: small tree marker: 1, count-1: 0, large 8-bit code: 0, code: 0
 		v2 = bw1
 		v3 = uint32(0x01)
 		v4 = int32(4)
 		if libc.Uint64FromInt64(4) == libc.Uint64FromInt32(4) {
 			if v4 > libc.Int32FromInt32(0) {
 				if (*VP8LBitWriter)(unsafe.Pointer(v2)).Fused >= libc.Int32FromInt32(32) {
 					VP8LPutBitsFlushBits(tls, v2)
 				}
 				**(**vp8l_atype_t)(__ccgo_up(v2)) |= uint64(v3) << (*VP8LBitWriter)(unsafe.Pointer(v2)).Fused
 				**(**int32)(__ccgo_up(v2 + 8)) += v4
 			}
 		} else {
 			VP8LPutBitsInternal(tls, v2, v3, v4)
 		}
 	} else {
 		if count <= int32(2) && symbols[0] < kMaxSymbol && symbols[int32(1)] < kMaxSymbol {
 			v2 = bw1
 			v3 = uint32(1)
 			v4 = int32(1)
 			if libc.Uint64FromInt64(4) == libc.Uint64FromInt32(4) {
 				if v4 > libc.Int32FromInt32(0) {
 					if (*VP8LBitWriter)(unsafe.Pointer(v2)).Fused >= libc.Int32FromInt32(32) {
 						VP8LPutBitsFlushBits(tls, v2)
 					}
 					**(**vp8l_atype_t)(__ccgo_up(v2)) |= uint64(v3) << (*VP8LBitWriter)(unsafe.Pointer(v2)).Fused
 					**(**int32)(__ccgo_up(v2 + 8)) += v4
 				}
 			} else {
 				VP8LPutBitsInternal(tls, v2, v3, v4)
 			} // Small tree marker to encode 1 or 2 symbols.
 			v2 = bw1
 			v3 = libc.Uint32FromInt32(count - int32(1))
 			v4 = int32(1)
 			if libc.Uint64FromInt64(4) == libc.Uint64FromInt32(4) {
 				if v4 > libc.Int32FromInt32(0) {
 					if (*VP8LBitWriter)(unsafe.Pointer(v2)).Fused >= libc.Int32FromInt32(32) {
 						VP8LPutBitsFlushBits(tls, v2)
 					}
 					**(**vp8l_atype_t)(__ccgo_up(v2)) |= uint64(v3) << (*VP8LBitWriter)(unsafe.Pointer(v2)).Fused
 					**(**int32)(__ccgo_up(v2 + 8)) += v4
 				}
 			} else {
 				VP8LPutBitsInternal(tls, v2, v3, v4)
 			}
 			if symbols[0] <= int32(1) {
 				v2 = bw1
 				v3 = uint32(0)
 				v4 = int32(1)
 				if libc.Uint64FromInt64(4) == libc.Uint64FromInt32(4) {
 					if v4 > libc.Int32FromInt32(0) {
 						if (*VP8LBitWriter)(unsafe.Pointer(v2)).Fused >= libc.Int32FromInt32(32) {
 							VP8LPutBitsFlushBits(tls, v2)
 						}
 						**(**vp8l_atype_t)(__ccgo_up(v2)) |= uint64(v3) << (*VP8LBitWriter)(unsafe.Pointer(v2)).Fused
 						**(**int32)(__ccgo_up(v2 + 8)) += v4
 					}
 				} else {
 					VP8LPutBitsInternal(tls, v2, v3, v4)
 				} // Code bit for small (1 bit) symbol value.
 				v2 = bw1
 				v3 = libc.Uint32FromInt32(symbols[0])
 				v4 = int32(1)
 				if libc.Uint64FromInt64(4) == libc.Uint64FromInt32(4) {
 					if v4 > libc.Int32FromInt32(0) {
 						if (*VP8LBitWriter)(unsafe.Pointer(v2)).Fused >= libc.Int32FromInt32(32) {
 							VP8LPutBitsFlushBits(tls, v2)
 						}
 						**(**vp8l_atype_t)(__ccgo_up(v2)) |= uint64(v3) << (*VP8LBitWriter)(unsafe.Pointer(v2)).Fused
 						**(**int32)(__ccgo_up(v2 + 8)) += v4
 					}
 				} else {
 					VP8LPutBitsInternal(tls, v2, v3, v4)
 				}
 			} else {
 				v2 = bw1
 				v3 = uint32(1)
 				v4 = int32(1)
 				if libc.Uint64FromInt64(4) == libc.Uint64FromInt32(4) {
 					if v4 > libc.Int32FromInt32(0) {
 						if (*VP8LBitWriter)(unsafe.Pointer(v2)).Fused >= libc.Int32FromInt32(32) {
 							VP8LPutBitsFlushBits(tls, v2)
 						}
 						**(**vp8l_atype_t)(__ccgo_up(v2)) |= uint64(v3) << (*VP8LBitWriter)(unsafe.Pointer(v2)).Fused
 						**(**int32)(__ccgo_up(v2 + 8)) += v4
 					}
 				} else {
 					VP8LPutBitsInternal(tls, v2, v3, v4)
 				}
 				v2 = bw1
 				v3 = libc.Uint32FromInt32(symbols[0])
 				v4 = int32(8)
 				if libc.Uint64FromInt64(4) == libc.Uint64FromInt32(4) {
 					if v4 > libc.Int32FromInt32(0) {
 						if (*VP8LBitWriter)(unsafe.Pointer(v2)).Fused >= libc.Int32FromInt32(32) {
 							VP8LPutBitsFlushBits(tls, v2)
 						}
 						**(**vp8l_atype_t)(__ccgo_up(v2)) |= uint64(v3) << (*VP8LBitWriter)(unsafe.Pointer(v2)).Fused
 						**(**int32)(__ccgo_up(v2 + 8)) += v4
 					}
 				} else {
 					VP8LPutBitsInternal(tls, v2, v3, v4)
 				}
 			}
 			if count == int32(2) {
 				v2 = bw1
 				v3 = libc.Uint32FromInt32(symbols[int32(1)])
 				v4 = int32(8)
 				if libc.Uint64FromInt64(4) == libc.Uint64FromInt32(4) {
 					if v4 > libc.Int32FromInt32(0) {
 						if (*VP8LBitWriter)(unsafe.Pointer(v2)).Fused >= libc.Int32FromInt32(32) {
 							VP8LPutBitsFlushBits(tls, v2)
 						}
 						**(**vp8l_atype_t)(__ccgo_up(v2)) |= uint64(v3) << (*VP8LBitWriter)(unsafe.Pointer(v2)).Fused
 						**(**int32)(__ccgo_up(v2 + 8)) += v4
 					}
 				} else {
 					VP8LPutBitsInternal(tls, v2, v3, v4)
 				}
 			}
 		} else {
 			StoreFullHuffmanCode(tls, bw1, huff_tree, tokens, huffman_code)
 		}
 	}
 }
 
 func WriteHuffmanCode(tls *libc.TLS, bw1 uintptr, code uintptr, code_index int32) {
 	var depth, symbol, v3 int32
 	var v1 uintptr
 	var v2 uint32_t
 	_, _, _, _, _ = depth, symbol, v1, v2, v3
 	depth = libc.Int32FromUint8(**(**uint8_t)(__ccgo_up((*HuffmanTreeCode)(unsafe.Pointer(code)).Fcode_lengths + uintptr(code_index))))
 	symbol = libc.Int32FromUint16(**(**uint16_t)(__ccgo_up((*HuffmanTreeCode)(unsafe.Pointer(code)).Fcodes + uintptr(code_index)*2)))
 	v1 = bw1
 	v2 = libc.Uint32FromInt32(symbol)
 	v3 = depth
 	if libc.Uint64FromInt64(4) == libc.Uint64FromInt32(4) {
 		if v3 > libc.Int32FromInt32(0) {
 			if (*VP8LBitWriter)(unsafe.Pointer(v1)).Fused >= libc.Int32FromInt32(32) {
 				VP8LPutBitsFlushBits(tls, v1)
 			}
 			**(**vp8l_atype_t)(__ccgo_up(v1)) |= uint64(v2) << (*VP8LBitWriter)(unsafe.Pointer(v1)).Fused
 			**(**int32)(__ccgo_up(v1 + 8)) += v3
 		}
 	} else {
 		VP8LPutBitsInternal(tls, v1, v2, v3)
 	}
 }
 
 func WriteHuffmanCodeWithExtraBits(tls *libc.TLS, bw1 uintptr, code uintptr, code_index int32, bits1 int32, n_bits1 int32) {
 	var depth, symbol, v3 int32
 	var v1 uintptr
 	var v2 uint32_t
 	_, _, _, _, _ = depth, symbol, v1, v2, v3
 	depth = libc.Int32FromUint8(**(**uint8_t)(__ccgo_up((*HuffmanTreeCode)(unsafe.Pointer(code)).Fcode_lengths + uintptr(code_index))))
 	symbol = libc.Int32FromUint16(**(**uint16_t)(__ccgo_up((*HuffmanTreeCode)(unsafe.Pointer(code)).Fcodes + uintptr(code_index)*2)))
 	v1 = bw1
 	v2 = libc.Uint32FromInt32(bits1<<depth | symbol)
 	v3 = depth + n_bits1
 	if libc.Uint64FromInt64(4) == libc.Uint64FromInt32(4) {
 		if v3 > libc.Int32FromInt32(0) {
 			if (*VP8LBitWriter)(unsafe.Pointer(v1)).Fused >= libc.Int32FromInt32(32) {
 				VP8LPutBitsFlushBits(tls, v1)
 			}
 			**(**vp8l_atype_t)(__ccgo_up(v1)) |= uint64(v2) << (*VP8LBitWriter)(unsafe.Pointer(v1)).Fused
 			**(**int32)(__ccgo_up(v1 + 8)) += v3
 		}
 	} else {
 		VP8LPutBitsInternal(tls, v1, v2, v3)
 	}
 }
 
 func StoreImageToBitMask(tls *libc.TLS, bw1 uintptr, width int32, histo_bits int32, refs uintptr, histogram_symbols uintptr, huffman_codes uintptr, pic uintptr) (r int32) {
 	bp := tls.Alloc(48)
 	defer tls.Free(48)
 	var code2, code3, distance2, highest_bit, histo_xsize, histogram_ix, k, literal_ix, second_highest_bit, tile_mask, tile_x, tile_y, x, y, v13, v5, v6, v8 int32
 	var codes, v, v20, v21, v22, v24 uintptr
 	var prefix_code VP8LPrefixCode
 	var v1 uint32
 	var v2, v3 uint32_t
 	var _ /* bits at bp+24 */ int32
 	var _ /* c at bp+0 */ VP8LRefsCursor
 	var _ /* code at bp+32 */ int32
 	var _ /* n_bits at bp+28 */ int32
 	_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = code2, code3, codes, distance2, highest_bit, histo_xsize, histogram_ix, k, literal_ix, prefix_code, second_highest_bit, tile_mask, tile_x, tile_y, v, x, y, v1, v13, v2, v20, v21, v22, v24, v3, v5, v6, v8
 	if histo_bits != 0 {
 		v2 = libc.Uint32FromInt32(histo_bits)
 		v3 = (libc.Uint32FromInt32(width) + libc.Uint32FromInt32(libc.Int32FromInt32(1)<<v2) - uint32(1)) >> v2
 		goto _4
 	_4:
 		v1 = v3
 	} else {
 		v1 = uint32(1)
 	}
 	histo_xsize = libc.Int32FromUint32(v1)
 	if histo_bits == 0 {
 		v5 = 0
 	} else {
 		v5 = -(int32(1) << histo_bits)
 	}
 	tile_mask = v5
 	// x and y trace the position in the image.
 	x = 0
 	y = 0
 	tile_x = x & tile_mask
 	tile_y = y & tile_mask
 	histogram_ix = libc.Int32FromUint32(**(**uint32_t)(__ccgo_up(histogram_symbols)) >> libc.Int32FromInt32(8) & uint32(0xffff))
 	codes = huffman_codes + uintptr(int32(5)*histogram_ix)*24
 	**(**VP8LRefsCursor)(__ccgo_up(bp)) = VP8LRefsCursorInit(tls, refs)
 	for {
 		v6 = libc.BoolInt32((*VP8LRefsCursor)(unsafe.Pointer(bp)).Fcur_pos != libc.UintptrFromInt32(0))
 		goto _7
 	_7:
 		if !(v6 != 0) {
 			break
 		}
 		v = (**(**VP8LRefsCursor)(__ccgo_up(bp))).Fcur_pos
 		if tile_x != x&tile_mask || tile_y != y&tile_mask {
 			tile_x = x & tile_mask
 			tile_y = y & tile_mask
 			histogram_ix = libc.Int32FromUint32(**(**uint32_t)(__ccgo_up(histogram_symbols + uintptr(y>>histo_bits*histo_xsize+x>>histo_bits)*4)) >> libc.Int32FromInt32(8) & uint32(0xffff))
 			codes = huffman_codes + uintptr(int32(5)*histogram_ix)*24
 		}
 		v5 = libc.BoolInt32(libc.Int32FromUint8((*PixOrCopy)(unsafe.Pointer(v)).Fmode) == int32(kLiteral))
 		goto _9
 	_9:
 		if v5 != 0 {
 			k = 0
 			for {
 				if !(k < int32(4)) {
 					break
 				}
 				v2 = (*PixOrCopy)(unsafe.Pointer(v)).Fargb_or_distance >> (libc.Int32FromUint8(order[k]) * libc.Int32FromInt32(8)) & uint32(0xff)
 				goto _12
 			_12:
 				code2 = libc.Int32FromUint32(v2)
 				WriteHuffmanCode(tls, bw1, codes+uintptr(k)*24, code2)
 				goto _10
 			_10:
 				;
 				k = k + 1
 			}
 		} else {
 			v5 = libc.BoolInt32(libc.Int32FromUint8((*PixOrCopy)(unsafe.Pointer(v)).Fmode) == int32(kCacheIdx))
 			goto _14
 		_14:
 			if v5 != 0 {
 				v2 = (*PixOrCopy)(unsafe.Pointer(v)).Fargb_or_distance
 				goto _16
 			_16:
 				code3 = libc.Int32FromUint32(v2)
 				literal_ix = libc.Int32FromInt32(256) + libc.Int32FromInt32(NUM_LENGTH_CODES) + code3
 				WriteHuffmanCode(tls, bw1, codes, literal_ix)
 			} else {
 				v2 = (*PixOrCopy)(unsafe.Pointer(v)).Fargb_or_distance
 				goto _18
 			_18:
 				distance2 = libc.Int32FromUint32(v2)
 				v5 = libc.Int32FromUint16((*PixOrCopy)(unsafe.Pointer(v)).Flen1)
 				v20 = bp + 32
 				v21 = bp + 28
 				v22 = bp + 24
 				if v5 < libc.Int32FromInt32(PREFIX_LOOKUP_IDX_MAX) {
 					prefix_code = kPrefixEncodeCode[v5]
 					**(**int32)(__ccgo_up(v20)) = int32(prefix_code.Fcode)
 					**(**int32)(__ccgo_up(v21)) = int32(prefix_code.Fextra_bits)
 					**(**int32)(__ccgo_up(v22)) = libc.Int32FromUint8(kPrefixEncodeExtraBitsValue[v5])
 				} else {
 					v6 = v5
 					v24 = v21
 					v6 = v6 - 1
 					v8 = v6
 					v13 = int32(31) ^ libc.X__builtin_clz(tls, libc.Uint32FromInt32(v8))
 					goto _27
 				_27:
 					highest_bit = v13
 					second_highest_bit = v6 >> (highest_bit - int32(1)) & int32(1)
 					**(**int32)(__ccgo_up(v24)) = highest_bit - int32(1)
 					**(**int32)(__ccgo_up(v22)) = v6 & (int32(1)<<**(**int32)(__ccgo_up(v24)) - int32(1))
 					**(**int32)(__ccgo_up(v20)) = int32(2)*highest_bit + second_highest_bit
 				}
 				WriteHuffmanCodeWithExtraBits(tls, bw1, codes, int32(256)+**(**int32)(__ccgo_up(bp + 32)), **(**int32)(__ccgo_up(bp + 24)), **(**int32)(__ccgo_up(bp + 28)))
 				// Don't write the distance with the extra bits code since
 				// the distance can be up to 18 bits of extra bits, and the prefix
 				// 15 bits, totaling to 33, and our PutBits only supports up to 32 bits.
 				v5 = distance2
 				v20 = bp + 32
 				v21 = bp + 28
 				v22 = bp + 24
 				if v5 < libc.Int32FromInt32(PREFIX_LOOKUP_IDX_MAX) {
 					prefix_code = kPrefixEncodeCode[v5]
 					**(**int32)(__ccgo_up(v20)) = int32(prefix_code.Fcode)
 					**(**int32)(__ccgo_up(v21)) = int32(prefix_code.Fextra_bits)
 					**(**int32)(__ccgo_up(v22)) = libc.Int32FromUint8(kPrefixEncodeExtraBitsValue[v5])
 				} else {
 					v6 = v5
 					v24 = v21
 					v6 = v6 - 1
 					v8 = v6
 					v13 = int32(31) ^ libc.X__builtin_clz(tls, libc.Uint32FromInt32(v8))
 					goto _36
 				_36:
 					highest_bit = v13
 					second_highest_bit = v6 >> (highest_bit - int32(1)) & int32(1)
 					**(**int32)(__ccgo_up(v24)) = highest_bit - int32(1)
 					**(**int32)(__ccgo_up(v22)) = v6 & (int32(1)<<**(**int32)(__ccgo_up(v24)) - int32(1))
 					**(**int32)(__ccgo_up(v20)) = int32(2)*highest_bit + second_highest_bit
 				}
 				WriteHuffmanCode(tls, bw1, codes+uintptr(4)*24, **(**int32)(__ccgo_up(bp + 32)))
 				v20 = bw1
 				v2 = libc.Uint32FromInt32(**(**int32)(__ccgo_up(bp + 24)))
 				v5 = **(**int32)(__ccgo_up(bp + 28))
 				if libc.Uint64FromInt64(4) == libc.Uint64FromInt32(4) {
 					if v5 > libc.Int32FromInt32(0) {
 						if (*VP8LBitWriter)(unsafe.Pointer(v20)).Fused >= libc.Int32FromInt32(32) {
 							VP8LPutBitsFlushBits(tls, v20)
 						}
 						**(**vp8l_atype_t)(__ccgo_up(v20)) |= uint64(v2) << (*VP8LBitWriter)(unsafe.Pointer(v20)).Fused
 						**(**int32)(__ccgo_up(v20 + 8)) += v5
 					}
 				} else {
 					VP8LPutBitsInternal(tls, v20, v2, v5)
 				}
 			}
 		}
 		v2 = uint32((*PixOrCopy)(unsafe.Pointer(v)).Flen1)
 		goto _41
 	_41:
 		x = libc.Int32FromUint32(uint32(x) + v2)
 		for x >= width {
 			x = x - width
 			y = y + 1
 		}
 		v20 = bp
 		v22 = v20
 		*(*uintptr)(unsafe.Pointer(v22)) += 8
 		v21 = *(*uintptr)(unsafe.Pointer(v22))
 		if v21 == (*VP8LRefsCursor)(unsafe.Pointer(v20)).Flast_pos {
 			VP8LRefsCursorNextBlock(tls, v20)
 		}
 	}
 	if (*VP8LBitWriter)(unsafe.Pointer(bw1)).Ferror1 != 0 {
 		return WebPEncodingSetError(tls, pic, int32(VP8_ENC_ERROR_OUT_OF_MEMORY))
 	}
 	return int32(1)
 }
 
 var order = [4]uint8_t{
 	0: uint8(1),
 	1: uint8(2),
 	3: uint8(3),
 }
 
 // C documentation
 //
 //	// Special case of EncodeImageInternal() for cache-bits=0, histo_bits=31.
 //	// pic and percent are for progress.
 func EncodeImageNoHuffman(tls *libc.TLS, bw1 uintptr, argb uintptr, hash_chain uintptr, refs_array uintptr, width int32, height int32, quality int32, low_effort int32, pic uintptr, percent_range int32, percent uintptr) (r int32) {
 	bp := tls.Alloc(128)
 	defer tls.Free(128)
 	var codes, codes1, histogram_image, huff_tree, refs, tokens, v1 uintptr
 	var i, max_tokens, v3 int32
 	var v2 uint32_t
 	var _ /* cache_bits at bp+124 */ int32
 	var _ /* histogram_symbols at bp+120 */ [1]uint32_t
 	var _ /* huffman_codes at bp+0 */ [5]HuffmanTreeCode
 	_, _, _, _, _, _, _, _, _, _, _ = codes, codes1, histogram_image, huff_tree, i, max_tokens, refs, tokens, v1, v2, v3
 	max_tokens = 0
 	tokens = libc.UintptrFromInt32(0)
 	**(**[5]HuffmanTreeCode)(__ccgo_up(bp)) = [5]HuffmanTreeCode{}
 	**(**[1]uint32_t)(__ccgo_up(bp + 120)) = [1]uint32_t{} // only one tree, one symbol
 	**(**int32)(__ccgo_up(bp + 124)) = 0
 	histogram_image = libc.UintptrFromInt32(0)
 	huff_tree = WebPSafeMalloc(tls, libc.Uint64FromUint64(3)*libc.Uint64FromInt32(CODE_LENGTH_CODES), uint64(16))
 	if huff_tree == libc.UintptrFromInt32(0) {
 		WebPEncodingSetError(tls, pic, int32(VP8_ENC_ERROR_OUT_OF_MEMORY))
 		goto Error
 	}
 	// Calculate backward references from ARGB image.
 	if !(VP8LHashChainFill(tls, hash_chain, quality, argb, width, height, low_effort, pic, percent_range/int32(2), percent) != 0) {
 		goto Error
 	}
 	if !(VP8LGetBackwardReferences(tls, width, height, argb, quality, 0, int32(kLZ77Standard)|int32(kLZ77RLE), **(**int32)(__ccgo_up(bp + 124)), 0, hash_chain, refs_array, bp+124, pic, percent_range-percent_range/int32(2), percent) != 0) {
 		goto Error
 	}
 	refs = refs_array
 	histogram_image = VP8LAllocateHistogramSet(tls, int32(1), **(**int32)(__ccgo_up(bp + 124)))
 	if histogram_image == libc.UintptrFromInt32(0) {
 		WebPEncodingSetError(tls, pic, int32(VP8_ENC_ERROR_OUT_OF_MEMORY))
 		goto Error
 	}
 	VP8LHistogramSetClear(tls, histogram_image)
 	// Build histogram image and symbols from backward references.
 	VP8LHistogramStoreRefs(tls, refs, libc.UintptrFromInt32(0), 0, **(**uintptr)(__ccgo_up((*VP8LHistogramSet)(unsafe.Pointer(histogram_image)).Fhistograms)))
 	// Create Huffman bit lengths and codes for each histogram image.
 	if !(GetHuffBitLengthsAndCodes(tls, histogram_image, bp) != 0) {
 		WebPEncodingSetError(tls, pic, int32(VP8_ENC_ERROR_OUT_OF_MEMORY))
 		goto Error
 	}
 	// No color cache, no Huffman image.
 	v1 = bw1
 	v2 = uint32(0)
 	v3 = int32(1)
 	if libc.Uint64FromInt64(4) == libc.Uint64FromInt32(4) {
 		if v3 > libc.Int32FromInt32(0) {
 			if (*VP8LBitWriter)(unsafe.Pointer(v1)).Fused >= libc.Int32FromInt32(32) {
 				VP8LPutBitsFlushBits(tls, v1)
 			}
 			**(**vp8l_atype_t)(__ccgo_up(v1)) |= uint64(v2) << (*VP8LBitWriter)(unsafe.Pointer(v1)).Fused
 			**(**int32)(__ccgo_up(v1 + 8)) += v3
 		}
 	} else {
 		VP8LPutBitsInternal(tls, v1, v2, v3)
 	}
 	// Find maximum number of symbols for the huffman tree-set.
 	i = 0
 	for {
 		if !(i < int32(5)) {
 			break
 		}
 		codes = bp + uintptr(i)*24
 		if max_tokens < (*HuffmanTreeCode)(unsafe.Pointer(codes)).Fnum_symbols {
 			max_tokens = (*HuffmanTreeCode)(unsafe.Pointer(codes)).Fnum_symbols
 		}
 		goto _4
 	_4:
 		;
 		i = i + 1
 	}
 	tokens = WebPSafeMalloc(tls, libc.Uint64FromInt32(max_tokens), uint64(2))
 	if tokens == libc.UintptrFromInt32(0) {
 		WebPEncodingSetError(tls, pic, int32(VP8_ENC_ERROR_OUT_OF_MEMORY))
 		goto Error
 	}
 	// Store Huffman codes.
 	i = 0
 	for {
 		if !(i < int32(5)) {
 			break
 		}
 		codes1 = bp + uintptr(i)*24
 		StoreHuffmanCode(tls, bw1, huff_tree, tokens, codes1)
 		ClearHuffmanTreeIfOnlyOneSymbol(tls, codes1)
 		goto _5
 	_5:
 		;
 		i = i + 1
 	}
 	// Store actual literals.
 	if !(StoreImageToBitMask(tls, bw1, width, 0, refs, bp+120, bp, pic) != 0) {
 		goto Error
 	}
 	goto Error
 Error:
 	;
 	WebPSafeFree(tls, tokens)
 	WebPSafeFree(tls, huff_tree)
 	VP8LFreeHistogramSet(tls, histogram_image)
 	WebPSafeFree(tls, (**(**[5]HuffmanTreeCode)(__ccgo_up(bp)))[0].Fcodes)
 	return libc.BoolInt32((*WebPPicture)(unsafe.Pointer(pic)).Ferror_code == int32(VP8_ENC_OK))
 }
 
 // C documentation
 //
 //	// pic and percent are for progress.
 func EncodeImageInternal(tls *libc.TLS, bw2 uintptr, argb uintptr, hash_chain uintptr, refs_array uintptr, width int32, height int32, quality int32, low_effort int32, config uintptr, cache_bits uintptr, histogram_bits_in int32, init_byte_position size_t, hdr_size uintptr, data_size uintptr, pic uintptr, percent_range int32, percent uintptr) (r int32) {
 	bp := tls.Alloc(128)
 	defer tls.Free(128)
 	var bit_array_size, bw_size_best, v37, v40 size_t
 	var cache_bits_init, cache_bits_tmp, hdr_size_tmp, i_cache, i_percent_range, i_remaining_percent, max_tokens, percent_start, remaining_percent, sub_configs_idx, write_histogram_image, v10, v7 int32
 	var codes, codes1, histogram_argb, histogram_image, huff_tree, huffman_codes, sub_config, tmp_histo, tokens, v12, v15 uintptr
 	var histogram_image_size, histogram_image_xysize, i, v1, v2, v4, v5 uint32_t
 	var _ /* bw_best at bp+48 */ VP8LBitWriter
 	var _ /* bw_init at bp+0 */ VP8LBitWriter
 	var _ /* cache_bits_best at bp+112 */ int32
 	var _ /* hash_chain_histogram at bp+96 */ VP8LHashChain
 	var _ /* histogram_bits at bp+116 */ int32
 	_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = bit_array_size, bw_size_best, cache_bits_init, cache_bits_tmp, codes, codes1, hdr_size_tmp, histogram_argb, histogram_image, histogram_image_size, histogram_image_xysize, huff_tree, huffman_codes, i, i_cache, i_percent_range, i_remaining_percent, max_tokens, percent_start, remaining_percent, sub_config, sub_configs_idx, tmp_histo, tokens, write_histogram_image, v1, v10, v12, v15, v2, v37, v4, v40, v5, v7
 	v1 = libc.Uint32FromInt32(histogram_bits_in)
 	v2 = (libc.Uint32FromInt32(width) + libc.Uint32FromInt32(libc.Int32FromInt32(1)<<v1) - uint32(1)) >> v1
 	goto _3
 _3:
 	v4 = libc.Uint32FromInt32(histogram_bits_in)
 	v5 = (libc.Uint32FromInt32(height) + libc.Uint32FromInt32(libc.Int32FromInt32(1)<<v4) - uint32(1)) >> v4
 	goto _6
 _6:
 	histogram_image_xysize = v2 * v5
 	remaining_percent = percent_range
 	percent_start = **(**int32)(__ccgo_up(percent))
 	histogram_image = libc.UintptrFromInt32(0)
 	tmp_histo = libc.UintptrFromInt32(0)
 	histogram_image_size = uint32(0)
 	bit_array_size = uint64(0)
 	huff_tree = WebPSafeMalloc(tls, libc.Uint64FromUint64(3)*libc.Uint64FromInt32(CODE_LENGTH_CODES), uint64(16))
 	tokens = libc.UintptrFromInt32(0)
 	huffman_codes = libc.UintptrFromInt32(0)
 	histogram_argb = WebPSafeMalloc(tls, uint64(histogram_image_xysize), uint64(4))
 	**(**VP8LBitWriter)(__ccgo_up(bp)) = **(**VP8LBitWriter)(__ccgo_up(bw2)) // histogram image hash chain
 	bw_size_best = ^libc.Uint64FromInt32(0)
 	libc.X__builtin___memset_chk(tls, bp+96, 0, uint64(16), ^__predefined_size_t(0))
 	if !(VP8LBitWriterInit(tls, bp+48, uint64(0)) != 0) {
 		WebPEncodingSetError(tls, pic, int32(VP8_ENC_ERROR_OUT_OF_MEMORY))
 		goto Error
 	}
 	// Make sure we can allocate the different objects.
 	if huff_tree == libc.UintptrFromInt32(0) || histogram_argb == libc.UintptrFromInt32(0) || !(VP8LHashChainInit(tls, bp+96, libc.Int32FromUint32(histogram_image_xysize)) != 0) {
 		WebPEncodingSetError(tls, pic, int32(VP8_ENC_ERROR_OUT_OF_MEMORY))
 		goto Error
 	}
 	percent_range = remaining_percent / int32(5)
 	if !(VP8LHashChainFill(tls, hash_chain, quality, argb, width, height, low_effort, pic, percent_range, percent) != 0) {
 		goto Error
 	}
 	percent_start = percent_start + percent_range
 	remaining_percent = remaining_percent - percent_range
 	// If the value is different from zero, it has been set during the palette
 	// analysis.
 	if **(**int32)(__ccgo_up(cache_bits)) == 0 {
 		v7 = int32(MAX_COLOR_CACHE_BITS)
 	} else {
 		v7 = **(**int32)(__ccgo_up(cache_bits))
 	}
 	cache_bits_init = v7
 	// If several iterations will happen, clone into bw_best.
 	if ((*CrunchConfig)(unsafe.Pointer(config)).Fsub_configs_size > int32(1) || (**(**CrunchSubConfig)(__ccgo_up(config + 8))).Fdo_no_cache != 0) && !(VP8LBitWriterClone(tls, bw2, bp+48) != 0) {
 		WebPEncodingSetError(tls, pic, int32(VP8_ENC_ERROR_OUT_OF_MEMORY))
 		goto Error
 	}
 	sub_configs_idx = 0
 	for {
 		if !(sub_configs_idx < (*CrunchConfig)(unsafe.Pointer(config)).Fsub_configs_size) {
 			break
 		}
 		sub_config = config + 8 + uintptr(sub_configs_idx)*8
 		i_remaining_percent = remaining_percent / (*CrunchConfig)(unsafe.Pointer(config)).Fsub_configs_size
 		i_percent_range = i_remaining_percent / int32(4)
 		i_remaining_percent = i_remaining_percent - i_percent_range
 		if !(VP8LGetBackwardReferences(tls, width, height, argb, quality, low_effort, (*CrunchSubConfig)(unsafe.Pointer(sub_config)).Flz77, cache_bits_init, (*CrunchSubConfig)(unsafe.Pointer(sub_config)).Fdo_no_cache, hash_chain, refs_array, bp+112, pic, i_percent_range, percent) != 0) {
 			goto Error
 		}
 		i_cache = 0
 		for {
 			if (*CrunchSubConfig)(unsafe.Pointer(sub_config)).Fdo_no_cache != 0 {
 				v7 = int32(2)
 			} else {
 				v7 = int32(1)
 			}
 			if !(i_cache < v7) {
 				break
 			}
 			if i_cache == 0 {
 				v10 = **(**int32)(__ccgo_up(bp + 112))
 			} else {
 				v10 = 0
 			}
 			cache_bits_tmp = v10
 			**(**int32)(__ccgo_up(bp + 116)) = histogram_bits_in
 			// Speed-up: no need to study the no-cache case if it was already studied
 			// in i_cache == 0.
 			if i_cache == int32(1) && **(**int32)(__ccgo_up(bp + 112)) == 0 {
 				break
 			}
 			// Reset the bit writer for this iteration.
 			VP8LBitWriterReset(tls, bp, bw2)
 			// Build histogram image and symbols from backward references.
 			histogram_image = VP8LAllocateHistogramSet(tls, libc.Int32FromUint32(histogram_image_xysize), cache_bits_tmp)
 			tmp_histo = VP8LAllocateHistogram(tls, cache_bits_tmp)
 			if histogram_image == libc.UintptrFromInt32(0) || tmp_histo == libc.UintptrFromInt32(0) {
 				WebPEncodingSetError(tls, pic, int32(VP8_ENC_ERROR_OUT_OF_MEMORY))
 				goto Error
 			}
 			i_percent_range = i_remaining_percent / int32(3)
 			i_remaining_percent = i_remaining_percent - i_percent_range
 			if !(VP8LGetHistoImageSymbols(tls, width, height, refs_array+uintptr(i_cache)*40, quality, low_effort, **(**int32)(__ccgo_up(bp + 116)), cache_bits_tmp, histogram_image, tmp_histo, histogram_argb, pic, i_percent_range, percent) != 0) {
 				goto Error
 			}
 			// Create Huffman bit lengths and codes for each histogram image.
 			histogram_image_size = libc.Uint32FromInt32((*VP8LHistogramSet)(unsafe.Pointer(histogram_image)).Fsize)
 			bit_array_size = uint64(uint32(5) * histogram_image_size)
 			huffman_codes = WebPSafeCalloc(tls, bit_array_size, uint64(24))
 			// Note: some histogram_image entries may point to tmp_histos[], so the
 			// latter need to outlive the following call to
 			// GetHuffBitLengthsAndCodes().
 			if huffman_codes == libc.UintptrFromInt32(0) || !(GetHuffBitLengthsAndCodes(tls, histogram_image, huffman_codes) != 0) {
 				WebPEncodingSetError(tls, pic, int32(VP8_ENC_ERROR_OUT_OF_MEMORY))
 				goto Error
 			}
 			// Free combined histograms.
 			VP8LFreeHistogramSet(tls, histogram_image)
 			histogram_image = libc.UintptrFromInt32(0)
 			// Free scratch histograms.
 			VP8LFreeHistogram(tls, tmp_histo)
 			tmp_histo = libc.UintptrFromInt32(0)
 			// Color Cache parameters.
 			if cache_bits_tmp > 0 {
 				v12 = bw2
 				v1 = uint32(1)
 				v7 = int32(1)
 				if libc.Uint64FromInt64(4) == libc.Uint64FromInt32(4) {
 					if v7 > libc.Int32FromInt32(0) {
 						if (*VP8LBitWriter)(unsafe.Pointer(v12)).Fused >= libc.Int32FromInt32(32) {
 							VP8LPutBitsFlushBits(tls, v12)
 						}
 						**(**vp8l_atype_t)(__ccgo_up(v12)) |= uint64(v1) << (*VP8LBitWriter)(unsafe.Pointer(v12)).Fused
 						**(**int32)(__ccgo_up(v12 + 8)) += v7
 					}
 				} else {
 					VP8LPutBitsInternal(tls, v12, v1, v7)
 				}
 				v12 = bw2
 				v1 = libc.Uint32FromInt32(cache_bits_tmp)
 				v7 = int32(4)
 				if libc.Uint64FromInt64(4) == libc.Uint64FromInt32(4) {
 					if v7 > libc.Int32FromInt32(0) {
 						if (*VP8LBitWriter)(unsafe.Pointer(v12)).Fused >= libc.Int32FromInt32(32) {
 							VP8LPutBitsFlushBits(tls, v12)
 						}
 						**(**vp8l_atype_t)(__ccgo_up(v12)) |= uint64(v1) << (*VP8LBitWriter)(unsafe.Pointer(v12)).Fused
 						**(**int32)(__ccgo_up(v12 + 8)) += v7
 					}
 				} else {
 					VP8LPutBitsInternal(tls, v12, v1, v7)
 				}
 			} else {
 				v12 = bw2
 				v1 = uint32(0)
 				v7 = int32(1)
 				if libc.Uint64FromInt64(4) == libc.Uint64FromInt32(4) {
 					if v7 > libc.Int32FromInt32(0) {
 						if (*VP8LBitWriter)(unsafe.Pointer(v12)).Fused >= libc.Int32FromInt32(32) {
 							VP8LPutBitsFlushBits(tls, v12)
 						}
 						**(**vp8l_atype_t)(__ccgo_up(v12)) |= uint64(v1) << (*VP8LBitWriter)(unsafe.Pointer(v12)).Fused
 						**(**int32)(__ccgo_up(v12 + 8)) += v7
 					}
 				} else {
 					VP8LPutBitsInternal(tls, v12, v1, v7)
 				}
 			}
 			// Huffman image + meta huffman.
 			histogram_image_size = uint32(0)
 			i = uint32(0)
 			for {
 				if !(i < histogram_image_xysize) {
 					break
 				}
 				if **(**uint32_t)(__ccgo_up(histogram_argb + uintptr(i)*4)) >= histogram_image_size {
 					histogram_image_size = **(**uint32_t)(__ccgo_up(histogram_argb + uintptr(i)*4)) + uint32(1)
 				}
 				**(**uint32_t)(__ccgo_up(histogram_argb + uintptr(i)*4)) <<= uint32(8)
 				goto _21
 			_21:
 				;
 				i = i + 1
 			}
 			write_histogram_image = libc.BoolInt32(histogram_image_size > uint32(1))
 			v12 = bw2
 			v1 = libc.Uint32FromInt32(write_histogram_image)
 			v7 = int32(1)
 			if libc.Uint64FromInt64(4) == libc.Uint64FromInt32(4) {
 				if v7 > libc.Int32FromInt32(0) {
 					if (*VP8LBitWriter)(unsafe.Pointer(v12)).Fused >= libc.Int32FromInt32(32) {
 						VP8LPutBitsFlushBits(tls, v12)
 					}
 					**(**vp8l_atype_t)(__ccgo_up(v12)) |= uint64(v1) << (*VP8LBitWriter)(unsafe.Pointer(v12)).Fused
 					**(**int32)(__ccgo_up(v12 + 8)) += v7
 				}
 			} else {
 				VP8LPutBitsInternal(tls, v12, v1, v7)
 			}
 			if write_histogram_image != 0 {
 				VP8LOptimizeSampling(tls, histogram_argb, width, height, histogram_bits_in, libc.Int32FromInt32(MIN_HUFFMAN_BITS)+libc.Int32FromInt32(1)<<libc.Int32FromInt32(NUM_HUFFMAN_BITS)-libc.Int32FromInt32(1), bp+116)
 				v12 = bw2
 				v1 = libc.Uint32FromInt32(**(**int32)(__ccgo_up(bp + 116)) - int32(2))
 				v7 = int32(3)
 				if libc.Uint64FromInt64(4) == libc.Uint64FromInt32(4) {
 					if v7 > libc.Int32FromInt32(0) {
 						if (*VP8LBitWriter)(unsafe.Pointer(v12)).Fused >= libc.Int32FromInt32(32) {
 							VP8LPutBitsFlushBits(tls, v12)
 						}
 						**(**vp8l_atype_t)(__ccgo_up(v12)) |= uint64(v1) << (*VP8LBitWriter)(unsafe.Pointer(v12)).Fused
 						**(**int32)(__ccgo_up(v12 + 8)) += v7
 					}
 				} else {
 					VP8LPutBitsInternal(tls, v12, v1, v7)
 				}
 				i_percent_range = i_remaining_percent / int32(2)
 				i_remaining_percent = i_remaining_percent - i_percent_range
 				v1 = libc.Uint32FromInt32(**(**int32)(__ccgo_up(bp + 116)))
 				v2 = (libc.Uint32FromInt32(width) + libc.Uint32FromInt32(libc.Int32FromInt32(1)<<v1) - uint32(1)) >> v1
 				goto _30
 			_30:
 				v4 = libc.Uint32FromInt32(**(**int32)(__ccgo_up(bp + 116)))
 				v5 = (libc.Uint32FromInt32(height) + libc.Uint32FromInt32(libc.Int32FromInt32(1)<<v4) - uint32(1)) >> v4
 				goto _33
 			_33:
 				if !(EncodeImageNoHuffman(tls, bw2, histogram_argb, bp+96, refs_array+2*40, libc.Int32FromUint32(v2), libc.Int32FromUint32(v5), quality, low_effort, pic, i_percent_range, percent) != 0) {
 					goto Error
 				}
 			}
 			// Store Huffman codes.
 			max_tokens = 0
 			// Find maximum number of symbols for the huffman tree-set.
 			i = uint32(0)
 			for {
 				if !(i < uint32(5)*histogram_image_size) {
 					break
 				}
 				codes = huffman_codes + uintptr(i)*24
 				if max_tokens < (*HuffmanTreeCode)(unsafe.Pointer(codes)).Fnum_symbols {
 					max_tokens = (*HuffmanTreeCode)(unsafe.Pointer(codes)).Fnum_symbols
 				}
 				goto _34
 			_34:
 				;
 				i = i + 1
 			}
 			tokens = WebPSafeMalloc(tls, libc.Uint64FromInt32(max_tokens), uint64(2))
 			if tokens == libc.UintptrFromInt32(0) {
 				WebPEncodingSetError(tls, pic, int32(VP8_ENC_ERROR_OUT_OF_MEMORY))
 				goto Error
 			}
 			i = uint32(0)
 			for {
 				if !(i < uint32(5)*histogram_image_size) {
 					break
 				}
 				codes1 = huffman_codes + uintptr(i)*24
 				StoreHuffmanCode(tls, bw2, huff_tree, tokens, codes1)
 				ClearHuffmanTreeIfOnlyOneSymbol(tls, codes1)
 				goto _35
 			_35:
 				;
 				i = i + 1
 			}
 			// Store actual literals.
 			v12 = bw2
 			v37 = libc.Uint64FromInt64(int64((*VP8LBitWriter)(unsafe.Pointer(v12)).Fcur) - int64((*VP8LBitWriter)(unsafe.Pointer(v12)).Fbuf) + int64(((*VP8LBitWriter)(unsafe.Pointer(v12)).Fused+libc.Int32FromInt32(7))>>libc.Int32FromInt32(3)))
 			goto _38
 		_38:
 			hdr_size_tmp = libc.Int32FromUint64(v37 - init_byte_position)
 			if !(StoreImageToBitMask(tls, bw2, width, **(**int32)(__ccgo_up(bp + 116)), refs_array+uintptr(i_cache)*40, histogram_argb, huffman_codes, pic) != 0) {
 				goto Error
 			}
 			// Keep track of the smallest image so far.
 			v12 = bw2
 			v37 = libc.Uint64FromInt64(int64((*VP8LBitWriter)(unsafe.Pointer(v12)).Fcur) - int64((*VP8LBitWriter)(unsafe.Pointer(v12)).Fbuf) + int64(((*VP8LBitWriter)(unsafe.Pointer(v12)).Fused+libc.Int32FromInt32(7))>>libc.Int32FromInt32(3)))
 			goto _41
 		_41:
 			if v37 < bw_size_best {
 				v15 = bw2
 				v40 = libc.Uint64FromInt64(int64((*VP8LBitWriter)(unsafe.Pointer(v15)).Fcur) - int64((*VP8LBitWriter)(unsafe.Pointer(v15)).Fbuf) + int64(((*VP8LBitWriter)(unsafe.Pointer(v15)).Fused+libc.Int32FromInt32(7))>>libc.Int32FromInt32(3)))
 				goto _44
 			_44:
 				bw_size_best = v40
 				**(**int32)(__ccgo_up(cache_bits)) = cache_bits_tmp
 				**(**int32)(__ccgo_up(hdr_size)) = hdr_size_tmp
 				v12 = bw2
 				v37 = libc.Uint64FromInt64(int64((*VP8LBitWriter)(unsafe.Pointer(v12)).Fcur) - int64((*VP8LBitWriter)(unsafe.Pointer(v12)).Fbuf) + int64(((*VP8LBitWriter)(unsafe.Pointer(v12)).Fused+libc.Int32FromInt32(7))>>libc.Int32FromInt32(3)))
 				goto _47
 			_47:
 				**(**int32)(__ccgo_up(data_size)) = libc.Int32FromUint64(v37 - init_byte_position - libc.Uint64FromInt32(**(**int32)(__ccgo_up(hdr_size))))
 				VP8LBitWriterSwap(tls, bw2, bp+48)
 			}
 			WebPSafeFree(tls, tokens)
 			tokens = libc.UintptrFromInt32(0)
 			if huffman_codes != libc.UintptrFromInt32(0) {
 				WebPSafeFree(tls, (*HuffmanTreeCode)(unsafe.Pointer(huffman_codes)).Fcodes)
 				WebPSafeFree(tls, huffman_codes)
 				huffman_codes = libc.UintptrFromInt32(0)
 			}
 			goto _9
 		_9:
 			;
 			i_cache = i_cache + 1
 		}
 		goto _8
 	_8:
 		;
 		sub_configs_idx = sub_configs_idx + 1
 	}
 	VP8LBitWriterSwap(tls, bw2, bp+48)
 	if !(WebPReportProgress(tls, pic, percent_start+remaining_percent, percent) != 0) {
 		goto Error
 	}
 	goto Error
 Error:
 	;
 	WebPSafeFree(tls, tokens)
 	WebPSafeFree(tls, huff_tree)
 	VP8LFreeHistogramSet(tls, histogram_image)
 	VP8LFreeHistogram(tls, tmp_histo)
 	VP8LHashChainClear(tls, bp+96)
 	if huffman_codes != libc.UintptrFromInt32(0) {
 		WebPSafeFree(tls, (*HuffmanTreeCode)(unsafe.Pointer(huffman_codes)).Fcodes)
 		WebPSafeFree(tls, huffman_codes)
 	}
 	WebPSafeFree(tls, histogram_argb)
 	VP8LBitWriterWipeOut(tls, bp+48)
 	return libc.BoolInt32((*WebPPicture)(unsafe.Pointer(pic)).Ferror_code == int32(VP8_ENC_OK))
 }
 
 // -----------------------------------------------------------------------------
 // Transforms
 
 func ApplySubtractGreen(tls *libc.TLS, enc uintptr, width int32, height int32, bw1 uintptr) {
 	var v1 uintptr
 	var v2 uint32_t
 	var v3 int32
 	_, _, _ = v1, v2, v3
 	v1 = bw1
 	v2 = uint32(TRANSFORM_PRESENT)
 	v3 = int32(1)
 	if libc.Uint64FromInt64(4) == libc.Uint64FromInt32(4) {
 		if v3 > libc.Int32FromInt32(0) {
 			if (*VP8LBitWriter)(unsafe.Pointer(v1)).Fused >= libc.Int32FromInt32(32) {
 				VP8LPutBitsFlushBits(tls, v1)
 			}
 			**(**vp8l_atype_t)(__ccgo_up(v1)) |= uint64(v2) << (*VP8LBitWriter)(unsafe.Pointer(v1)).Fused
 			**(**int32)(__ccgo_up(v1 + 8)) += v3
 		}
 	} else {
 		VP8LPutBitsInternal(tls, v1, v2, v3)
 	}
 	v1 = bw1
 	v2 = uint32(SUBTRACT_GREEN_TRANSFORM)
 	v3 = int32(2)
 	if libc.Uint64FromInt64(4) == libc.Uint64FromInt32(4) {
 		if v3 > libc.Int32FromInt32(0) {
 			if (*VP8LBitWriter)(unsafe.Pointer(v1)).Fused >= libc.Int32FromInt32(32) {
 				VP8LPutBitsFlushBits(tls, v1)
 			}
 			**(**vp8l_atype_t)(__ccgo_up(v1)) |= uint64(v2) << (*VP8LBitWriter)(unsafe.Pointer(v1)).Fused
 			**(**int32)(__ccgo_up(v1 + 8)) += v3
 		}
 	} else {
 		VP8LPutBitsInternal(tls, v1, v2, v3)
 	}
 	(*(*func(*libc.TLS, uintptr, int32))(unsafe.Pointer(&struct{ uintptr }{VP8LSubtractGreenFromBlueAndRed})))(tls, (*VP8LEncoder)(unsafe.Pointer(enc)).Fargb, width*height)
 }
 
 func ApplyPredictFilter(tls *libc.TLS, enc uintptr, width int32, height int32, quality int32, low_effort int32, used_subtract_green int32, bw1 uintptr, percent_range int32, percent uintptr, best_bits uintptr) (r int32) {
 	var max_bits, min_bits, near_lossless_strength, v1, v2 int32
 	var v10, v12, v4, v7 uint32_t
 	var v3 uintptr
 	_, _, _, _, _, _, _, _, _, _ = max_bits, min_bits, near_lossless_strength, v1, v10, v12, v2, v3, v4, v7
 	if (*VP8LEncoder)(unsafe.Pointer(enc)).Fuse_palette != 0 {
 		v1 = int32(100)
 	} else {
 		v1 = (*WebPConfig)(unsafe.Pointer((*VP8LEncoder)(unsafe.Pointer(enc)).Fconfig)).Fnear_lossless
 	}
 	near_lossless_strength = v1
 	max_bits = ClampBits(tls, width, height, (*VP8LEncoder)(unsafe.Pointer(enc)).Fpredictor_transform_bits, int32(MIN_TRANSFORM_BITS), libc.Int32FromInt32(MIN_TRANSFORM_BITS)+libc.Int32FromInt32(1)<<libc.Int32FromInt32(NUM_TRANSFORM_BITS)-libc.Int32FromInt32(1), libc.Int32FromInt32(1)<<libc.Int32FromInt32(14))
 	if (*WebPConfig)(unsafe.Pointer((*VP8LEncoder)(unsafe.Pointer(enc)).Fconfig)).Fmethod > int32(4) {
 		v2 = (*WebPConfig)(unsafe.Pointer((*VP8LEncoder)(unsafe.Pointer(enc)).Fconfig)).Fmethod - int32(4)
 	} else {
 		v2 = 0
 	}
 	min_bits = ClampBits(tls, width, height, max_bits-int32(2)*v2, int32(MIN_TRANSFORM_BITS), libc.Int32FromInt32(MIN_TRANSFORM_BITS)+libc.Int32FromInt32(1)<<libc.Int32FromInt32(NUM_TRANSFORM_BITS)-libc.Int32FromInt32(1), libc.Int32FromInt32(1)<<libc.Int32FromInt32(14))
 	if !(VP8LResidualImage(tls, width, height, min_bits, max_bits, low_effort, (*VP8LEncoder)(unsafe.Pointer(enc)).Fargb, (*VP8LEncoder)(unsafe.Pointer(enc)).Fargb_scratch, (*VP8LEncoder)(unsafe.Pointer(enc)).Ftransform_data, near_lossless_strength, (*WebPConfig)(unsafe.Pointer((*VP8LEncoder)(unsafe.Pointer(enc)).Fconfig)).Fexact, used_subtract_green, (*VP8LEncoder)(unsafe.Pointer(enc)).Fpic, percent_range/int32(2), percent, best_bits) != 0) {
 		return 0
 	}
 	v3 = bw1
 	v4 = uint32(TRANSFORM_PRESENT)
 	v1 = int32(1)
 	if libc.Uint64FromInt64(4) == libc.Uint64FromInt32(4) {
 		if v1 > libc.Int32FromInt32(0) {
 			if (*VP8LBitWriter)(unsafe.Pointer(v3)).Fused >= libc.Int32FromInt32(32) {
 				VP8LPutBitsFlushBits(tls, v3)
 			}
 			**(**vp8l_atype_t)(__ccgo_up(v3)) |= uint64(v4) << (*VP8LBitWriter)(unsafe.Pointer(v3)).Fused
 			**(**int32)(__ccgo_up(v3 + 8)) += v1
 		}
 	} else {
 		VP8LPutBitsInternal(tls, v3, v4, v1)
 	}
 	v3 = bw1
 	v4 = uint32(PREDICTOR_TRANSFORM)
 	v1 = int32(2)
 	if libc.Uint64FromInt64(4) == libc.Uint64FromInt32(4) {
 		if v1 > libc.Int32FromInt32(0) {
 			if (*VP8LBitWriter)(unsafe.Pointer(v3)).Fused >= libc.Int32FromInt32(32) {
 				VP8LPutBitsFlushBits(tls, v3)
 			}
 			**(**vp8l_atype_t)(__ccgo_up(v3)) |= uint64(v4) << (*VP8LBitWriter)(unsafe.Pointer(v3)).Fused
 			**(**int32)(__ccgo_up(v3 + 8)) += v1
 		}
 	} else {
 		VP8LPutBitsInternal(tls, v3, v4, v1)
 	}
 	v3 = bw1
 	v4 = libc.Uint32FromInt32(**(**int32)(__ccgo_up(best_bits)) - int32(MIN_TRANSFORM_BITS))
 	v1 = int32(NUM_TRANSFORM_BITS)
 	if libc.Uint64FromInt64(4) == libc.Uint64FromInt32(4) {
 		if v1 > libc.Int32FromInt32(0) {
 			if (*VP8LBitWriter)(unsafe.Pointer(v3)).Fused >= libc.Int32FromInt32(32) {
 				VP8LPutBitsFlushBits(tls, v3)
 			}
 			**(**vp8l_atype_t)(__ccgo_up(v3)) |= uint64(v4) << (*VP8LBitWriter)(unsafe.Pointer(v3)).Fused
 			**(**int32)(__ccgo_up(v3 + 8)) += v1
 		}
 	} else {
 		VP8LPutBitsInternal(tls, v3, v4, v1)
 	}
 	v4 = libc.Uint32FromInt32(**(**int32)(__ccgo_up(best_bits)))
 	v7 = (libc.Uint32FromInt32(width) + libc.Uint32FromInt32(libc.Int32FromInt32(1)<<v4) - uint32(1)) >> v4
 	goto _14
 _14:
 	v10 = libc.Uint32FromInt32(**(**int32)(__ccgo_up(best_bits)))
 	v12 = (libc.Uint32FromInt32(height) + libc.Uint32FromInt32(libc.Int32FromInt32(1)<<v10) - uint32(1)) >> v10
 	goto _17
 _17:
 	return EncodeImageNoHuffman(tls, bw1, (*VP8LEncoder)(unsafe.Pointer(enc)).Ftransform_data, enc+2312, enc+2152, libc.Int32FromUint32(v7), libc.Int32FromUint32(v12), quality, low_effort, (*VP8LEncoder)(unsafe.Pointer(enc)).Fpic, percent_range-percent_range/int32(2), percent)
 }
 
 func ApplyCrossColorFilter(tls *libc.TLS, enc uintptr, width int32, height int32, quality int32, low_effort int32, bw1 uintptr, percent_range int32, percent uintptr, best_bits uintptr) (r int32) {
 	var min_bits, v3 int32
 	var v1 uintptr
 	var v10, v2, v5, v8 uint32_t
 	_, _, _, _, _, _, _ = min_bits, v1, v10, v2, v3, v5, v8
 	min_bits = (*VP8LEncoder)(unsafe.Pointer(enc)).Fcross_color_transform_bits
 	if !(VP8LColorSpaceTransform(tls, width, height, min_bits, quality, (*VP8LEncoder)(unsafe.Pointer(enc)).Fargb, (*VP8LEncoder)(unsafe.Pointer(enc)).Ftransform_data, (*VP8LEncoder)(unsafe.Pointer(enc)).Fpic, percent_range/int32(2), percent, best_bits) != 0) {
 		return 0
 	}
 	v1 = bw1
 	v2 = uint32(TRANSFORM_PRESENT)
 	v3 = int32(1)
 	if libc.Uint64FromInt64(4) == libc.Uint64FromInt32(4) {
 		if v3 > libc.Int32FromInt32(0) {
 			if (*VP8LBitWriter)(unsafe.Pointer(v1)).Fused >= libc.Int32FromInt32(32) {
 				VP8LPutBitsFlushBits(tls, v1)
 			}
 			**(**vp8l_atype_t)(__ccgo_up(v1)) |= uint64(v2) << (*VP8LBitWriter)(unsafe.Pointer(v1)).Fused
 			**(**int32)(__ccgo_up(v1 + 8)) += v3
 		}
 	} else {
 		VP8LPutBitsInternal(tls, v1, v2, v3)
 	}
 	v1 = bw1
 	v2 = uint32(CROSS_COLOR_TRANSFORM)
 	v3 = int32(2)
 	if libc.Uint64FromInt64(4) == libc.Uint64FromInt32(4) {
 		if v3 > libc.Int32FromInt32(0) {
 			if (*VP8LBitWriter)(unsafe.Pointer(v1)).Fused >= libc.Int32FromInt32(32) {
 				VP8LPutBitsFlushBits(tls, v1)
 			}
 			**(**vp8l_atype_t)(__ccgo_up(v1)) |= uint64(v2) << (*VP8LBitWriter)(unsafe.Pointer(v1)).Fused
 			**(**int32)(__ccgo_up(v1 + 8)) += v3
 		}
 	} else {
 		VP8LPutBitsInternal(tls, v1, v2, v3)
 	}
 	v1 = bw1
 	v2 = libc.Uint32FromInt32(**(**int32)(__ccgo_up(best_bits)) - int32(MIN_TRANSFORM_BITS))
 	v3 = int32(NUM_TRANSFORM_BITS)
 	if libc.Uint64FromInt64(4) == libc.Uint64FromInt32(4) {
 		if v3 > libc.Int32FromInt32(0) {
 			if (*VP8LBitWriter)(unsafe.Pointer(v1)).Fused >= libc.Int32FromInt32(32) {
 				VP8LPutBitsFlushBits(tls, v1)
 			}
 			**(**vp8l_atype_t)(__ccgo_up(v1)) |= uint64(v2) << (*VP8LBitWriter)(unsafe.Pointer(v1)).Fused
 			**(**int32)(__ccgo_up(v1 + 8)) += v3
 		}
 	} else {
 		VP8LPutBitsInternal(tls, v1, v2, v3)
 	}
 	v2 = libc.Uint32FromInt32(**(**int32)(__ccgo_up(best_bits)))
 	v5 = (libc.Uint32FromInt32(width) + libc.Uint32FromInt32(libc.Int32FromInt32(1)<<v2) - uint32(1)) >> v2
 	goto _12
 _12:
 	v8 = libc.Uint32FromInt32(**(**int32)(__ccgo_up(best_bits)))
 	v10 = (libc.Uint32FromInt32(height) + libc.Uint32FromInt32(libc.Int32FromInt32(1)<<v8) - uint32(1)) >> v8
 	goto _15
 _15:
 	return EncodeImageNoHuffman(tls, bw1, (*VP8LEncoder)(unsafe.Pointer(enc)).Ftransform_data, enc+2312, enc+2152, libc.Int32FromUint32(v5), libc.Int32FromUint32(v10), quality, low_effort, (*VP8LEncoder)(unsafe.Pointer(enc)).Fpic, percent_range-percent_range/int32(2), percent)
 }
 
 // -----------------------------------------------------------------------------
 
 func WriteRiffHeader(tls *libc.TLS, pic uintptr, riff_size size_t, vp8l_size size_t) (r int32) {
 	bp := tls.Alloc(32)
 	defer tls.Free(32)
 	var v1, v3, v5 uintptr
 	var v4, v6 int32
 	var v2 uint32_t
 	var _ /* riff at bp+0 */ [21]uint8_t
 	_, _, _, _, _, _ = v1, v2, v3, v4, v5, v6
 	**(**[21]uint8_t)(__ccgo_up(bp)) = [21]uint8_t{
 		0:  uint8('R'),
 		1:  uint8('I'),
 		2:  uint8('F'),
 		3:  uint8('F'),
 		8:  uint8('W'),
 		9:  uint8('E'),
 		10: uint8('B'),
 		11: uint8('P'),
 		12: uint8('V'),
 		13: uint8('P'),
 		14: uint8('8'),
 		15: uint8('L'),
 		20: uint8(VP8L_MAGIC_BYTE3),
 	}
 	v1 = bp + uintptr(TAG_SIZE)
 	v2 = uint32(riff_size)
 	v3 = v1
 	v4 = libc.Int32FromUint32(v2 & libc.Uint32FromInt32(0xffff))
 	**(**uint8_t)(__ccgo_up(v3)) = libc.Uint8FromInt32(v4 >> 0 & int32(0xff))
 	**(**uint8_t)(__ccgo_up(v3 + 1)) = libc.Uint8FromInt32(v4 >> int32(8) & int32(0xff))
 	v5 = v1 + uintptr(2)
 	v6 = libc.Int32FromUint32(v2 >> libc.Int32FromInt32(16))
 	**(**uint8_t)(__ccgo_up(v5)) = libc.Uint8FromInt32(v6 >> 0 & int32(0xff))
 	**(**uint8_t)(__ccgo_up(v5 + 1)) = libc.Uint8FromInt32(v6 >> int32(8) & int32(0xff))
 	v1 = bp + uintptr(RIFF_HEADER_SIZE) + uintptr(TAG_SIZE)
 	v2 = uint32(vp8l_size)
 	v3 = v1
 	v4 = libc.Int32FromUint32(v2 & libc.Uint32FromInt32(0xffff))
 	**(**uint8_t)(__ccgo_up(v3)) = libc.Uint8FromInt32(v4 >> 0 & int32(0xff))
 	**(**uint8_t)(__ccgo_up(v3 + 1)) = libc.Uint8FromInt32(v4 >> int32(8) & int32(0xff))
 	v5 = v1 + uintptr(2)
 	v6 = libc.Int32FromUint32(v2 >> libc.Int32FromInt32(16))
 	**(**uint8_t)(__ccgo_up(v5)) = libc.Uint8FromInt32(v6 >> 0 & int32(0xff))
 	**(**uint8_t)(__ccgo_up(v5 + 1)) = libc.Uint8FromInt32(v6 >> int32(8) & int32(0xff))
 	return (*(*func(*libc.TLS, uintptr, size_t, uintptr) int32)(unsafe.Pointer(&struct{ uintptr }{(*WebPPicture)(unsafe.Pointer(pic)).Fwriter})))(tls, bp, uint64(21), pic)
 }
 
 func WriteImageSize(tls *libc.TLS, pic uintptr, bw1 uintptr) (r int32) {
 	var height, width, v3 int32
 	var v1 uintptr
 	var v2 uint32_t
 	_, _, _, _, _ = height, width, v1, v2, v3
 	width = (*WebPPicture)(unsafe.Pointer(pic)).Fwidth - int32(1)
 	height = (*WebPPicture)(unsafe.Pointer(pic)).Fheight - int32(1)
 	v1 = bw1
 	v2 = libc.Uint32FromInt32(width)
 	v3 = int32(VP8L_IMAGE_SIZE_BITS)
 	if libc.Uint64FromInt64(4) == libc.Uint64FromInt32(4) {
 		if v3 > libc.Int32FromInt32(0) {
 			if (*VP8LBitWriter)(unsafe.Pointer(v1)).Fused >= libc.Int32FromInt32(32) {
 				VP8LPutBitsFlushBits(tls, v1)
 			}
 			**(**vp8l_atype_t)(__ccgo_up(v1)) |= uint64(v2) << (*VP8LBitWriter)(unsafe.Pointer(v1)).Fused
 			**(**int32)(__ccgo_up(v1 + 8)) += v3
 		}
 	} else {
 		VP8LPutBitsInternal(tls, v1, v2, v3)
 	}
 	v1 = bw1
 	v2 = libc.Uint32FromInt32(height)
 	v3 = int32(VP8L_IMAGE_SIZE_BITS)
 	if libc.Uint64FromInt64(4) == libc.Uint64FromInt32(4) {
 		if v3 > libc.Int32FromInt32(0) {
 			if (*VP8LBitWriter)(unsafe.Pointer(v1)).Fused >= libc.Int32FromInt32(32) {
 				VP8LPutBitsFlushBits(tls, v1)
 			}
 			**(**vp8l_atype_t)(__ccgo_up(v1)) |= uint64(v2) << (*VP8LBitWriter)(unsafe.Pointer(v1)).Fused
 			**(**int32)(__ccgo_up(v1 + 8)) += v3
 		}
 	} else {
 		VP8LPutBitsInternal(tls, v1, v2, v3)
 	}
 	return libc.BoolInt32(!((*VP8LBitWriter)(unsafe.Pointer(bw1)).Ferror1 != 0))
 }
 
 func WriteRealAlphaAndVersion(tls *libc.TLS, bw1 uintptr, has_alpha int32) (r int32) {
 	var v1 uintptr
 	var v2 uint32_t
 	var v3 int32
 	_, _, _ = v1, v2, v3
 	v1 = bw1
 	v2 = libc.Uint32FromInt32(has_alpha)
 	v3 = int32(1)
 	if libc.Uint64FromInt64(4) == libc.Uint64FromInt32(4) {
 		if v3 > libc.Int32FromInt32(0) {
 			if (*VP8LBitWriter)(unsafe.Pointer(v1)).Fused >= libc.Int32FromInt32(32) {
 				VP8LPutBitsFlushBits(tls, v1)
 			}
 			**(**vp8l_atype_t)(__ccgo_up(v1)) |= uint64(v2) << (*VP8LBitWriter)(unsafe.Pointer(v1)).Fused
 			**(**int32)(__ccgo_up(v1 + 8)) += v3
 		}
 	} else {
 		VP8LPutBitsInternal(tls, v1, v2, v3)
 	}
 	v1 = bw1
 	v2 = uint32(VP8L_VERSION)
 	v3 = int32(VP8L_VERSION_BITS)
 	if libc.Uint64FromInt64(4) == libc.Uint64FromInt32(4) {
 		if v3 > libc.Int32FromInt32(0) {
 			if (*VP8LBitWriter)(unsafe.Pointer(v1)).Fused >= libc.Int32FromInt32(32) {
 				VP8LPutBitsFlushBits(tls, v1)
 			}
 			**(**vp8l_atype_t)(__ccgo_up(v1)) |= uint64(v2) << (*VP8LBitWriter)(unsafe.Pointer(v1)).Fused
 			**(**int32)(__ccgo_up(v1 + 8)) += v3
 		}
 	} else {
 		VP8LPutBitsInternal(tls, v1, v2, v3)
 	}
 	return libc.BoolInt32(!((*VP8LBitWriter)(unsafe.Pointer(bw1)).Ferror1 != 0))
 }
 
 func WriteImage(tls *libc.TLS, pic uintptr, bw1 uintptr, coded_size uintptr) (r int32) {
 	bp := tls.Alloc(16)
 	defer tls.Free(16)
 	var pad, riff_size, vp8l_size, webpll_size, v2 size_t
 	var webpll_data, v1 uintptr
 	var _ /* pad_byte at bp+0 */ [1]uint8_t
 	_, _, _, _, _, _, _ = pad, riff_size, vp8l_size, webpll_data, webpll_size, v1, v2
 	webpll_data = VP8LBitWriterFinish(tls, bw1)
 	v1 = bw1
 	v2 = libc.Uint64FromInt64(int64((*VP8LBitWriter)(unsafe.Pointer(v1)).Fcur) - int64((*VP8LBitWriter)(unsafe.Pointer(v1)).Fbuf) + int64(((*VP8LBitWriter)(unsafe.Pointer(v1)).Fused+libc.Int32FromInt32(7))>>libc.Int32FromInt32(3)))
 	goto _3
 _3:
 	webpll_size = v2
 	vp8l_size = uint64(VP8L_SIGNATURE_SIZE) + webpll_size
 	pad = vp8l_size & uint64(1)
 	riff_size = libc.Uint64FromInt32(libc.Int32FromInt32(TAG_SIZE)+libc.Int32FromInt32(CHUNK_HEADER_SIZE)) + vp8l_size + pad
 	**(**size_t)(__ccgo_up(coded_size)) = uint64(0)
 	if (*VP8LBitWriter)(unsafe.Pointer(bw1)).Ferror1 != 0 {
 		return WebPEncodingSetError(tls, pic, int32(VP8_ENC_ERROR_OUT_OF_MEMORY))
 	}
 	if !(WriteRiffHeader(tls, pic, riff_size, vp8l_size) != 0) || !((*(*func(*libc.TLS, uintptr, size_t, uintptr) int32)(unsafe.Pointer(&struct{ uintptr }{(*WebPPicture)(unsafe.Pointer(pic)).Fwriter})))(tls, webpll_data, webpll_size, pic) != 0) {
 		return WebPEncodingSetError(tls, pic, int32(VP8_ENC_ERROR_BAD_WRITE))
 	}
 	if pad != 0 {
 		**(**[1]uint8_t)(__ccgo_up(bp)) = [1]uint8_t{}
 		if !((*(*func(*libc.TLS, uintptr, size_t, uintptr) int32)(unsafe.Pointer(&struct{ uintptr }{(*WebPPicture)(unsafe.Pointer(pic)).Fwriter})))(tls, bp, uint64(1), pic) != 0) {
 			return WebPEncodingSetError(tls, pic, int32(VP8_ENC_ERROR_BAD_WRITE))
 		}
 	}
 	**(**size_t)(__ccgo_up(coded_size)) = uint64(CHUNK_HEADER_SIZE) + riff_size
 	return int32(1)
 }
 
 // -----------------------------------------------------------------------------
 
 func ClearTransformBuffer(tls *libc.TLS, enc uintptr) {
 	WebPSafeFree(tls, (*VP8LEncoder)(unsafe.Pointer(enc)).Ftransform_mem)
 	(*VP8LEncoder)(unsafe.Pointer(enc)).Ftransform_mem = libc.UintptrFromInt32(0)
 	(*VP8LEncoder)(unsafe.Pointer(enc)).Ftransform_mem_size = uint64(0)
 }
 
 // C documentation
 //
 //	// Allocates the memory for argb (W x H) buffer, 2 rows of context for
 //	// prediction and transform data.
 //	// Flags influencing the memory allocated:
 //	//  enc->transform_bits
 //	//  enc->use_predict, enc->use_cross_color
 func AllocateTransformBuffer(tls *libc.TLS, enc uintptr, width int32, height int32) (r int32) {
 	var argb_scratch_size, image_size, max_alignment_in_words, mem_size, transform_data_size uint64_t
 	var mem uintptr
 	var v1, v2 uint64
 	var v3, v4, v6, v7 uint32_t
 	_, _, _, _, _, _, _, _, _, _, _, _ = argb_scratch_size, image_size, max_alignment_in_words, mem, mem_size, transform_data_size, v1, v2, v3, v4, v6, v7
 	image_size = libc.Uint64FromInt32(width) * libc.Uint64FromInt32(height)
 	if (*VP8LEncoder)(unsafe.Pointer(enc)).Fuse_predict != 0 {
 		v1 = libc.Uint64FromInt32((width+int32(1))*int32(2)) + (libc.Uint64FromInt32(width*int32(2))+uint64(4)-uint64(1))/uint64(4)
 	} else {
 		v1 = uint64(0)
 	}
 	// VP8LResidualImage needs room for 2 scanlines of uint32 pixels with an extra
 	// pixel in each, plus 2 regular scanlines of bytes.
 	// TODO(skal): Clean up by using arithmetic in bytes instead of words.
 	argb_scratch_size = v1
 	if (*VP8LEncoder)(unsafe.Pointer(enc)).Fuse_predict != 0 || (*VP8LEncoder)(unsafe.Pointer(enc)).Fuse_cross_color != 0 {
 		v3 = uint32(MIN_TRANSFORM_BITS)
 		v4 = (libc.Uint32FromInt32(width) + libc.Uint32FromInt32(libc.Int32FromInt32(1)<<v3) - uint32(1)) >> v3
 		goto _5
 	_5:
 		v6 = uint32(MIN_TRANSFORM_BITS)
 		v7 = (libc.Uint32FromInt32(height) + libc.Uint32FromInt32(libc.Int32FromInt32(1)<<v6) - uint32(1)) >> v6
 		goto _8
 	_8:
 		v2 = uint64(v4) * uint64(v7)
 	} else {
 		v2 = uint64(0)
 	}
 	transform_data_size = v2
 	max_alignment_in_words = uint64((libc.Uint64FromInt32(WEBP_ALIGN_CST) + libc.Uint64FromInt64(4) - libc.Uint64FromInt32(1)) / libc.Uint64FromInt64(4))
 	mem_size = image_size + max_alignment_in_words + argb_scratch_size + max_alignment_in_words + transform_data_size
 	mem = (*VP8LEncoder)(unsafe.Pointer(enc)).Ftransform_mem
 	if mem == libc.UintptrFromInt32(0) || mem_size > (*VP8LEncoder)(unsafe.Pointer(enc)).Ftransform_mem_size {
 		ClearTransformBuffer(tls, enc)
 		mem = WebPSafeMalloc(tls, mem_size, uint64(4))
 		if mem == libc.UintptrFromInt32(0) {
 			return WebPEncodingSetError(tls, (*VP8LEncoder)(unsafe.Pointer(enc)).Fpic, int32(VP8_ENC_ERROR_OUT_OF_MEMORY))
 		}
 		(*VP8LEncoder)(unsafe.Pointer(enc)).Ftransform_mem = mem
 		(*VP8LEncoder)(unsafe.Pointer(enc)).Ftransform_mem_size = mem_size
 		(*VP8LEncoder)(unsafe.Pointer(enc)).Fargb_content = int32(kEncoderNone)
 	}
 	(*VP8LEncoder)(unsafe.Pointer(enc)).Fargb = mem
 	mem = uintptr((uint64(mem+uintptr(image_size)*4) + libc.Uint64FromInt32(WEBP_ALIGN_CST)) & ^libc.Uint64FromInt32(WEBP_ALIGN_CST))
 	(*VP8LEncoder)(unsafe.Pointer(enc)).Fargb_scratch = mem
 	mem = uintptr((uint64(mem+uintptr(argb_scratch_size)*4) + libc.Uint64FromInt32(WEBP_ALIGN_CST)) & ^libc.Uint64FromInt32(WEBP_ALIGN_CST))
 	(*VP8LEncoder)(unsafe.Pointer(enc)).Ftransform_data = mem
 	(*VP8LEncoder)(unsafe.Pointer(enc)).Fcurrent_width = width
 	return int32(1)
 }
 
 func MakeInputImageCopy(tls *libc.TLS, enc uintptr) (r int32) {
 	var dst, picture, src uintptr
 	var height, width, y int32
 	_, _, _, _, _, _ = dst, height, picture, src, width, y
 	picture = (*VP8LEncoder)(unsafe.Pointer(enc)).Fpic
 	width = (*WebPPicture)(unsafe.Pointer(picture)).Fwidth
 	height = (*WebPPicture)(unsafe.Pointer(picture)).Fheight
 	if !(AllocateTransformBuffer(tls, enc, width, height) != 0) {
 		return 0
 	}
 	if (*VP8LEncoder)(unsafe.Pointer(enc)).Fargb_content == int32(kEncoderARGB) {
 		return int32(1)
 	}
 	dst = (*VP8LEncoder)(unsafe.Pointer(enc)).Fargb
 	src = (*WebPPicture)(unsafe.Pointer(picture)).Fargb
 	y = 0
 	for {
 		if !(y < height) {
 			break
 		}
 		libc.X__builtin___memcpy_chk(tls, dst, src, libc.Uint64FromInt32(width)*uint64(4), ^__predefined_size_t(0))
 		dst = dst + uintptr(width)*4
 		src = src + uintptr((*WebPPicture)(unsafe.Pointer(picture)).Fargb_stride)*4
 		goto _1
 	_1:
 		;
 		y = y + 1
 	}
 	(*VP8LEncoder)(unsafe.Pointer(enc)).Fargb_content = int32(kEncoderARGB)
 	return int32(1)
 }
 
 // -----------------------------------------------------------------------------
 
 func SearchColorGreedy(tls *libc.TLS, palette uintptr, palette_size int32, color uint32_t) (r uint32_t) {
 	_ = palette_size
 	if color == **(**uint32_t)(__ccgo_up(palette)) {
 		return uint32(0)
 	}
 	if color == **(**uint32_t)(__ccgo_up(palette + 1*4)) {
 		return uint32(1)
 	}
 	if color == **(**uint32_t)(__ccgo_up(palette + 2*4)) {
 		return uint32(2)
 	}
 	return uint32(3)
 }
 
 func ApplyPaletteHash0(tls *libc.TLS, color uint32_t) (r uint32_t) {
 	// Focus on the green color.
 	return color >> libc.Int32FromInt32(8) & uint32(0xff)
 }
 
 func ApplyPaletteHash1(tls *libc.TLS, color uint32_t) (r uint32_t) {
 	// Forget about alpha.
 	return uint32(uint64(color&libc.Uint32FromUint32(0x00ffffff))*libc.Uint64FromUint64(4222244071)) >> (libc.Int32FromInt32(32) - libc.Int32FromInt32(11))
 }
 
 func ApplyPaletteHash2(tls *libc.TLS, color uint32_t) (r uint32_t) {
 	// Forget about alpha.
 	return uint32(uint64(color&libc.Uint32FromUint32(0x00ffffff))*(libc.Uint64FromUint64(1)<<libc.Int32FromInt32(31)-libc.Uint64FromInt32(1))) >> (libc.Int32FromInt32(32) - libc.Int32FromInt32(11))
 }
 
 // Use 1 pixel cache for ARGB pixels.
 
 // C documentation
 //
 //	// Remap argb values in src[] to packed palettes entries in dst[]
 //	// using 'row' as a temporary buffer of size 'width'.
 //	// We assume that all src[] values have a corresponding entry in the palette.
 //	// Note: src[] can be the same as dst[]
 func ApplyPalette(tls *libc.TLS, src uintptr, src_stride uint32_t, dst uintptr, dst_stride uint32_t, palette uintptr, palette_size int32, width int32, height int32, xbits int32, pic uintptr) (r int32) {
 	bp := tls.Alloc(6144)
 	defer tls.Free(6144)
 	var hash_functions [3]uintptr
 	var i, j, use_LUT, x, y int32
 	var ind, pix, pix1, pix2, pix3, pix4, prev_idx, prev_idx1, prev_idx2, prev_idx3, prev_idx4, prev_pix, prev_pix1, prev_pix2, prev_pix3, prev_pix4 uint32_t
 	var tmp_row uintptr
 	var _ /* buffer at bp+0 */ [2048]uint16_t
 	var _ /* idx_map at bp+4096 */ [256]uint32_t
 	var _ /* palette_sorted at bp+5120 */ [256]uint32_t
 	_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = hash_functions, i, ind, j, pix, pix1, pix2, pix3, pix4, prev_idx, prev_idx1, prev_idx2, prev_idx3, prev_idx4, prev_pix, prev_pix1, prev_pix2, prev_pix3, prev_pix4, tmp_row, use_LUT, x, y
 	// TODO(skal): this tmp buffer is not needed if VP8LBundleColorMap() can be
 	// made to work in-place.
 	tmp_row = WebPSafeMalloc(tls, libc.Uint64FromInt32(width), uint64(1))
 	if tmp_row == libc.UintptrFromInt32(0) {
 		return WebPEncodingSetError(tls, pic, int32(VP8_ENC_ERROR_OUT_OF_MEMORY))
 	}
 	if palette_size < int32(4) {
 		prev_pix = **(**uint32_t)(__ccgo_up(palette))
 		prev_idx = uint32(0)
 		y = 0
 		for {
 			if !(y < height) {
 				break
 			}
 			x = 0
 			for {
 				if !(x < width) {
 					break
 				}
 				pix = **(**uint32_t)(__ccgo_up(src + uintptr(x)*4))
 				if pix != prev_pix {
 					prev_idx = SearchColorGreedy(tls, palette, palette_size, pix)
 					prev_pix = pix
 				}
 				**(**uint8_t)(__ccgo_up(tmp_row + uintptr(x))) = uint8(prev_idx)
 				goto _2
 			_2:
 				;
 				x = x + 1
 			}
 			(*(*func(*libc.TLS, uintptr, int32, int32, uintptr))(unsafe.Pointer(&struct{ uintptr }{VP8LBundleColorMap})))(tls, tmp_row, width, xbits, dst)
 			src = src + uintptr(src_stride)*4
 			dst = dst + uintptr(dst_stride)*4
 			goto _1
 		_1:
 			;
 			y = y + 1
 		}
 	} else {
 		hash_functions = [3]uintptr{
 			0: __ccgo_fp(ApplyPaletteHash0),
 			1: __ccgo_fp(ApplyPaletteHash1),
 			2: __ccgo_fp(ApplyPaletteHash2),
 		}
 		// Try to find a perfect hash function able to go from a color to an index
 		// within 1 << PALETTE_INV_SIZE_BITS in order to build a hash map to go
 		// from color to index in palette.
 		i = 0
 		for {
 			if !(i < int32(3)) {
 				break
 			}
 			use_LUT = int32(1)
 			// Set each element in buffer to max uint16_t.
 			libc.X__builtin___memset_chk(tls, bp, int32(0xff), uint64(4096), ^__predefined_size_t(0))
 			j = 0
 			for {
 				if !(j < palette_size) {
 					break
 				}
 				ind = (*(*func(*libc.TLS, uint32_t) uint32_t)(unsafe.Pointer(&struct{ uintptr }{hash_functions[i]})))(tls, **(**uint32_t)(__ccgo_up(palette + uintptr(j)*4)))
 				if uint32((**(**[2048]uint16_t)(__ccgo_up(bp)))[ind]) != uint32(0xffff) {
 					use_LUT = 0
 					break
 				} else {
 					(**(**[2048]uint16_t)(__ccgo_up(bp)))[ind] = libc.Uint16FromInt32(j)
 				}
 				goto _4
 			_4:
 				;
 				j = j + 1
 			}
 			if use_LUT != 0 {
 				break
 			}
 			goto _3
 		_3:
 			;
 			i = i + 1
 		}
 		if i == 0 {
 			prev_pix1 = **(**uint32_t)(__ccgo_up(palette))
 			prev_idx1 = uint32(0)
 			y = 0
 			for {
 				if !(y < height) {
 					break
 				}
 				x = 0
 				for {
 					if !(x < width) {
 						break
 					}
 					pix1 = **(**uint32_t)(__ccgo_up(src + uintptr(x)*4))
 					if pix1 != prev_pix1 {
 						prev_idx1 = uint32((**(**[2048]uint16_t)(__ccgo_up(bp)))[ApplyPaletteHash0(tls, pix1)])
 						prev_pix1 = pix1
 					}
 					**(**uint8_t)(__ccgo_up(tmp_row + uintptr(x))) = uint8(prev_idx1)
 					goto _6
 				_6:
 					;
 					x = x + 1
 				}
 				(*(*func(*libc.TLS, uintptr, int32, int32, uintptr))(unsafe.Pointer(&struct{ uintptr }{VP8LBundleColorMap})))(tls, tmp_row, width, xbits, dst)
 				src = src + uintptr(src_stride)*4
 				dst = dst + uintptr(dst_stride)*4
 				goto _5
 			_5:
 				;
 				y = y + 1
 			}
 		} else {
 			if i == int32(1) {
 				prev_pix2 = **(**uint32_t)(__ccgo_up(palette))
 				prev_idx2 = uint32(0)
 				y = 0
 				for {
 					if !(y < height) {
 						break
 					}
 					x = 0
 					for {
 						if !(x < width) {
 							break
 						}
 						pix2 = **(**uint32_t)(__ccgo_up(src + uintptr(x)*4))
 						if pix2 != prev_pix2 {
 							prev_idx2 = uint32((**(**[2048]uint16_t)(__ccgo_up(bp)))[ApplyPaletteHash1(tls, pix2)])
 							prev_pix2 = pix2
 						}
 						**(**uint8_t)(__ccgo_up(tmp_row + uintptr(x))) = uint8(prev_idx2)
 						goto _8
 					_8:
 						;
 						x = x + 1
 					}
 					(*(*func(*libc.TLS, uintptr, int32, int32, uintptr))(unsafe.Pointer(&struct{ uintptr }{VP8LBundleColorMap})))(tls, tmp_row, width, xbits, dst)
 					src = src + uintptr(src_stride)*4
 					dst = dst + uintptr(dst_stride)*4
 					goto _7
 				_7:
 					;
 					y = y + 1
 				}
 			} else {
 				if i == int32(2) {
 					prev_pix3 = **(**uint32_t)(__ccgo_up(palette))
 					prev_idx3 = uint32(0)
 					y = 0
 					for {
 						if !(y < height) {
 							break
 						}
 						x = 0
 						for {
 							if !(x < width) {
 								break
 							}
 							pix3 = **(**uint32_t)(__ccgo_up(src + uintptr(x)*4))
 							if pix3 != prev_pix3 {
 								prev_idx3 = uint32((**(**[2048]uint16_t)(__ccgo_up(bp)))[ApplyPaletteHash2(tls, pix3)])
 								prev_pix3 = pix3
 							}
 							**(**uint8_t)(__ccgo_up(tmp_row + uintptr(x))) = uint8(prev_idx3)
 							goto _10
 						_10:
 							;
 							x = x + 1
 						}
 						(*(*func(*libc.TLS, uintptr, int32, int32, uintptr))(unsafe.Pointer(&struct{ uintptr }{VP8LBundleColorMap})))(tls, tmp_row, width, xbits, dst)
 						src = src + uintptr(src_stride)*4
 						dst = dst + uintptr(dst_stride)*4
 						goto _9
 					_9:
 						;
 						y = y + 1
 					}
 				} else {
 					PrepareMapToPalette(tls, palette, libc.Uint32FromInt32(palette_size), bp+5120, bp+4096)
 					prev_pix4 = **(**uint32_t)(__ccgo_up(palette))
 					prev_idx4 = uint32(0)
 					y = 0
 					for {
 						if !(y < height) {
 							break
 						}
 						x = 0
 						for {
 							if !(x < width) {
 								break
 							}
 							pix4 = **(**uint32_t)(__ccgo_up(src + uintptr(x)*4))
 							if pix4 != prev_pix4 {
 								prev_idx4 = (**(**[256]uint32_t)(__ccgo_up(bp + 4096)))[SearchColorNoIdx(tls, bp+5120, pix4, palette_size)]
 								prev_pix4 = pix4
 							}
 							**(**uint8_t)(__ccgo_up(tmp_row + uintptr(x))) = uint8(prev_idx4)
 							goto _12
 						_12:
 							;
 							x = x + 1
 						}
 						(*(*func(*libc.TLS, uintptr, int32, int32, uintptr))(unsafe.Pointer(&struct{ uintptr }{VP8LBundleColorMap})))(tls, tmp_row, width, xbits, dst)
 						src = src + uintptr(src_stride)*4
 						dst = dst + uintptr(dst_stride)*4
 						goto _11
 					_11:
 						;
 						y = y + 1
 					}
 				}
 			}
 		}
 	}
 	WebPSafeFree(tls, tmp_row)
 	return int32(1)
 }
 
 // C documentation
 //
 //	// Note: Expects "enc->palette" to be set properly.
 func MapImageFromPalette(tls *libc.TLS, enc uintptr) (r int32) {
 	var height, palette_size, width, xbits, v1 int32
 	var palette, pic uintptr
 	var v3, v4 uint32_t
 	_, _, _, _, _, _, _, _, _ = height, palette, palette_size, pic, width, xbits, v1, v3, v4
 	pic = (*VP8LEncoder)(unsafe.Pointer(enc)).Fpic
 	width = (*WebPPicture)(unsafe.Pointer(pic)).Fwidth
 	height = (*WebPPicture)(unsafe.Pointer(pic)).Fheight
 	palette = enc + 104
 	palette_size = (*VP8LEncoder)(unsafe.Pointer(enc)).Fpalette_size
 	// Replace each input pixel by corresponding palette index.
 	// This is done line by line.
 	if palette_size <= int32(4) {
 		if palette_size <= int32(2) {
 			v1 = int32(3)
 		} else {
 			v1 = int32(2)
 		}
 		xbits = v1
 	} else {
 		if palette_size <= int32(16) {
 			v1 = int32(1)
 		} else {
 			v1 = 0
 		}
 		xbits = v1
 	}
 	v3 = libc.Uint32FromInt32(xbits)
 	v4 = (libc.Uint32FromInt32(width) + libc.Uint32FromInt32(libc.Int32FromInt32(1)<<v3) - uint32(1)) >> v3
 	goto _5
 _5:
 	if !(AllocateTransformBuffer(tls, enc, libc.Int32FromUint32(v4), height) != 0) {
 		return 0
 	}
 	if !(ApplyPalette(tls, (*WebPPicture)(unsafe.Pointer(pic)).Fargb, libc.Uint32FromInt32((*WebPPicture)(unsafe.Pointer(pic)).Fargb_stride), (*VP8LEncoder)(unsafe.Pointer(enc)).Fargb, libc.Uint32FromInt32((*VP8LEncoder)(unsafe.Pointer(enc)).Fcurrent_width), palette, palette_size, width, height, xbits, pic) != 0) {
 		return 0
 	}
 	(*VP8LEncoder)(unsafe.Pointer(enc)).Fargb_content = int32(kEncoderPalette)
 	return int32(1)
 }
 
 // C documentation
 //
 //	// Save palette[] to bitstream.
 func EncodePalette(tls *libc.TLS, bw1 uintptr, low_effort int32, enc uintptr, percent_range int32, percent uintptr) (r int32) {
 	bp := tls.Alloc(1024)
 	defer tls.Free(1024)
 	var alpha_and_green, encoded_palette_size, red_and_blue, v3, v6, v9 uint32_t
 	var i, palette_size, v1, v4 int32
 	var palette, v2 uintptr
 	var _ /* tmp_palette at bp+0 */ [256]uint32_t
 	_, _, _, _, _, _, _, _, _, _, _, _ = alpha_and_green, encoded_palette_size, i, palette, palette_size, red_and_blue, v1, v2, v3, v4, v6, v9
 	palette_size = (*VP8LEncoder)(unsafe.Pointer(enc)).Fpalette_size
 	palette = enc + 104
 	if **(**uint32_t)(__ccgo_up(enc + 104 + uintptr(palette_size-int32(1))*4)) == uint32(0) && palette_size > int32(17) {
 		v1 = palette_size - int32(1)
 	} else {
 		v1 = palette_size
 	}
 	// If the last element is 0, do not store it and count on automatic palette
 	// 0-filling. This can only happen if there is no pixel packing, hence if
 	// there are strictly more than 16 colors (after 0 is removed).
 	encoded_palette_size = libc.Uint32FromInt32(v1)
 	v2 = bw1
 	v3 = uint32(TRANSFORM_PRESENT)
 	v4 = int32(1)
 	if libc.Uint64FromInt64(4) == libc.Uint64FromInt32(4) {
 		if v4 > libc.Int32FromInt32(0) {
 			if (*VP8LBitWriter)(unsafe.Pointer(v2)).Fused >= libc.Int32FromInt32(32) {
 				VP8LPutBitsFlushBits(tls, v2)
 			}
 			**(**vp8l_atype_t)(__ccgo_up(v2)) |= uint64(v3) << (*VP8LBitWriter)(unsafe.Pointer(v2)).Fused
 			**(**int32)(__ccgo_up(v2 + 8)) += v4
 		}
 	} else {
 		VP8LPutBitsInternal(tls, v2, v3, v4)
 	}
 	v2 = bw1
 	v3 = uint32(COLOR_INDEXING_TRANSFORM)
 	v1 = int32(2)
 	if libc.Uint64FromInt64(4) == libc.Uint64FromInt32(4) {
 		if v1 > libc.Int32FromInt32(0) {
 			if (*VP8LBitWriter)(unsafe.Pointer(v2)).Fused >= libc.Int32FromInt32(32) {
 				VP8LPutBitsFlushBits(tls, v2)
 			}
 			**(**vp8l_atype_t)(__ccgo_up(v2)) |= uint64(v3) << (*VP8LBitWriter)(unsafe.Pointer(v2)).Fused
 			**(**int32)(__ccgo_up(v2 + 8)) += v1
 		}
 	} else {
 		VP8LPutBitsInternal(tls, v2, v3, v1)
 	}
 	v2 = bw1
 	v3 = encoded_palette_size - uint32(1)
 	v1 = int32(8)
 	if libc.Uint64FromInt64(4) == libc.Uint64FromInt32(4) {
 		if v1 > libc.Int32FromInt32(0) {
 			if (*VP8LBitWriter)(unsafe.Pointer(v2)).Fused >= libc.Int32FromInt32(32) {
 				VP8LPutBitsFlushBits(tls, v2)
 			}
 			**(**vp8l_atype_t)(__ccgo_up(v2)) |= uint64(v3) << (*VP8LBitWriter)(unsafe.Pointer(v2)).Fused
 			**(**int32)(__ccgo_up(v2 + 8)) += v1
 		}
 	} else {
 		VP8LPutBitsInternal(tls, v2, v3, v1)
 	}
 	i = libc.Int32FromUint32(encoded_palette_size - uint32(1))
 	for {
 		if !(i >= int32(1)) {
 			break
 		}
 		v3 = **(**uint32_t)(__ccgo_up(palette + uintptr(i)*4))
 		v6 = **(**uint32_t)(__ccgo_up(palette + uintptr(i-int32(1))*4))
 		alpha_and_green = uint32(0x00ff00ff) + v3&uint32(0xff00ff00) - v6&uint32(0xff00ff00)
 		red_and_blue = uint32(0xff00ff00) + v3&uint32(0x00ff00ff) - v6&uint32(0x00ff00ff)
 		v9 = alpha_and_green&uint32(0xff00ff00) | red_and_blue&uint32(0x00ff00ff)
 		goto _15
 	_15:
 		(**(**[256]uint32_t)(__ccgo_up(bp)))[i] = v9
 		goto _11
 	_11:
 		;
 		i = i - 1
 	}
 	(**(**[256]uint32_t)(__ccgo_up(bp)))[0] = **(**uint32_t)(__ccgo_up(palette))
 	return EncodeImageNoHuffman(tls, bw1, bp, enc+2312, enc+2152, libc.Int32FromUint32(encoded_palette_size), int32(1), int32(20), low_effort, (*VP8LEncoder)(unsafe.Pointer(enc)).Fpic, percent_range, percent)
 }
 
 // -----------------------------------------------------------------------------
 // VP8LEncoder
 
 func VP8LEncoderNew(tls *libc.TLS, config uintptr, picture uintptr) (r uintptr) {
 	var enc uintptr
 	_ = enc
 	enc = WebPSafeCalloc(tls, uint64(1), uint64(2328))
 	if enc == libc.UintptrFromInt32(0) {
 		WebPEncodingSetError(tls, picture, int32(VP8_ENC_ERROR_OUT_OF_MEMORY))
 		return libc.UintptrFromInt32(0)
 	}
 	(*VP8LEncoder)(unsafe.Pointer(enc)).Fconfig = config
 	(*VP8LEncoder)(unsafe.Pointer(enc)).Fpic = picture
 	(*VP8LEncoder)(unsafe.Pointer(enc)).Fargb_content = int32(kEncoderNone)
 	VP8LEncDspInit(tls)
 	return enc
 }
 
 func VP8LEncoderDelete(tls *libc.TLS, enc uintptr) {
 	var i int32
 	_ = i
 	if enc != libc.UintptrFromInt32(0) {
 		VP8LHashChainClear(tls, enc+2312)
 		i = 0
 		for {
 			if !(i < int32(4)) {
 				break
 			}
 			VP8LBackwardRefsClear(tls, enc+2152+uintptr(i)*40)
 			goto _1
 		_1:
 			;
 			i = i + 1
 		}
 		ClearTransformBuffer(tls, enc)
 		WebPSafeFree(tls, enc)
 	}
 }
 
 // -----------------------------------------------------------------------------
 // Main call
 
 type StreamEncodeContext = struct {
 	Fconfig                   uintptr
 	Fpicture                  uintptr
 	Fbw                       uintptr
 	Fenc                      uintptr
 	Fcrunch_configs           [14]CrunchConfig
 	Fnum_crunch_configs       int32
 	Fred_and_blue_always_zero int32
 	Fstats                    uintptr
 }
 
 func EncodeStreamHook(tls *libc.TLS, input uintptr, data2 uintptr) (r int32) {
 	bp := tls.Alloc(128)
 	defer tls.Free(128)
 	var best_size, byte_position, v12, v2 size_t
 	var bw2, config, crunch_configs, enc, params, picture, stats, v1, v8 uintptr
 	var entropy_idx, height, idx, low_effort, num_crunch_configs, percent_range, quality, red_and_blue_always_zero, remaining_percent, use_near_lossless, width, v5 int32
 	var v9 uint32_t
 	var _ /* bw_best at bp+64 */ VP8LBitWriter
 	var _ /* bw_init at bp+16 */ VP8LBitWriter
 	var _ /* cross_color_transform_bits at bp+116 */ int32
 	var _ /* data_size at bp+8 */ int32
 	var _ /* hdr_size at bp+4 */ int32
 	var _ /* percent at bp+0 */ int32
 	var _ /* predictor_transform_bits at bp+112 */ int32
 	_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = best_size, bw2, byte_position, config, crunch_configs, enc, entropy_idx, height, idx, low_effort, num_crunch_configs, params, percent_range, picture, quality, red_and_blue_always_zero, remaining_percent, stats, use_near_lossless, width, v1, v12, v2, v5, v8, v9
 	params = input
 	config = (*StreamEncodeContext)(unsafe.Pointer(params)).Fconfig
 	picture = (*StreamEncodeContext)(unsafe.Pointer(params)).Fpicture
 	bw2 = (*StreamEncodeContext)(unsafe.Pointer(params)).Fbw
 	enc = (*StreamEncodeContext)(unsafe.Pointer(params)).Fenc
 	crunch_configs = params + 32
 	num_crunch_configs = (*StreamEncodeContext)(unsafe.Pointer(params)).Fnum_crunch_configs
 	red_and_blue_always_zero = (*StreamEncodeContext)(unsafe.Pointer(params)).Fred_and_blue_always_zero
 	stats = (*StreamEncodeContext)(unsafe.Pointer(params)).Fstats
 	quality = int32((*WebPConfig)(unsafe.Pointer(config)).Fquality)
 	low_effort = libc.BoolInt32((*WebPConfig)(unsafe.Pointer(config)).Fmethod == libc.Int32FromInt32(0))
 	width = (*WebPPicture)(unsafe.Pointer(picture)).Fwidth
 	height = (*WebPPicture)(unsafe.Pointer(picture)).Fheight
 	v1 = bw2
 	v2 = libc.Uint64FromInt64(int64((*VP8LBitWriter)(unsafe.Pointer(v1)).Fcur) - int64((*VP8LBitWriter)(unsafe.Pointer(v1)).Fbuf) + int64(((*VP8LBitWriter)(unsafe.Pointer(v1)).Fused+libc.Int32FromInt32(7))>>libc.Int32FromInt32(3)))
 	goto _3
 _3:
 	byte_position = v2
 	**(**int32)(__ccgo_up(bp)) = int32(2) // for WebPProgressHook
 	use_near_lossless = 0
 	**(**int32)(__ccgo_up(bp + 4)) = 0
 	**(**int32)(__ccgo_up(bp + 8)) = 0
 	best_size = ^libc.Uint64FromInt32(0)
 	**(**VP8LBitWriter)(__ccgo_up(bp + 16)) = **(**VP8LBitWriter)(__ccgo_up(bw2))
 	_ = data2
 	if !(VP8LBitWriterInit(tls, bp+64, uint64(0)) != 0) || num_crunch_configs > int32(1) && !(VP8LBitWriterClone(tls, bw2, bp+64) != 0) {
 		WebPEncodingSetError(tls, picture, int32(VP8_ENC_ERROR_OUT_OF_MEMORY))
 		goto Error
 	}
 	idx = 0
 	for {
 		if !(idx < num_crunch_configs) {
 			break
 		}
 		entropy_idx = (**(**CrunchConfig)(__ccgo_up(crunch_configs + uintptr(idx)*28))).Fentropy_idx
 		remaining_percent = int32(97) / num_crunch_configs
 		**(**int32)(__ccgo_up(bp + 112)) = 0
 		**(**int32)(__ccgo_up(bp + 116)) = 0
 		(*VP8LEncoder)(unsafe.Pointer(enc)).Fuse_palette = libc.BoolInt32(entropy_idx == int32(kPalette) || entropy_idx == int32(kPaletteAndSpatial))
 		(*VP8LEncoder)(unsafe.Pointer(enc)).Fuse_subtract_green = libc.BoolInt32(entropy_idx == int32(kSubGreen) || entropy_idx == int32(kSpatialSubGreen))
 		(*VP8LEncoder)(unsafe.Pointer(enc)).Fuse_predict = libc.BoolInt32(entropy_idx == int32(kSpatial) || entropy_idx == int32(kSpatialSubGreen) || entropy_idx == int32(kPaletteAndSpatial))
 		// When using a palette, R/B==0, hence no need to test for cross-color.
 		if low_effort != 0 || (*VP8LEncoder)(unsafe.Pointer(enc)).Fuse_palette != 0 {
 			(*VP8LEncoder)(unsafe.Pointer(enc)).Fuse_cross_color = 0
 		} else {
 			if red_and_blue_always_zero != 0 {
 				v5 = 0
 			} else {
 				v5 = (*VP8LEncoder)(unsafe.Pointer(enc)).Fuse_predict
 			}
 			(*VP8LEncoder)(unsafe.Pointer(enc)).Fuse_cross_color = v5
 		}
 		// Reset any parameter in the encoder that is set in the previous iteration.
 		(*VP8LEncoder)(unsafe.Pointer(enc)).Fcache_bits = 0
 		VP8LBackwardRefsClear(tls, enc+2152)
 		VP8LBackwardRefsClear(tls, enc+2152+1*40)
 		// Apply near-lossless preprocessing.
 		use_near_lossless = libc.BoolInt32((*WebPConfig)(unsafe.Pointer(config)).Fnear_lossless < int32(100) && !((*VP8LEncoder)(unsafe.Pointer(enc)).Fuse_palette != 0) && !((*VP8LEncoder)(unsafe.Pointer(enc)).Fuse_predict != 0))
 		if use_near_lossless != 0 {
 			if !(AllocateTransformBuffer(tls, enc, width, height) != 0) {
 				goto Error
 			}
 			if (*VP8LEncoder)(unsafe.Pointer(enc)).Fargb_content != int32(kEncoderNearLossless) && !(VP8ApplyNearLossless(tls, picture, (*WebPConfig)(unsafe.Pointer(config)).Fnear_lossless, (*VP8LEncoder)(unsafe.Pointer(enc)).Fargb) != 0) {
 				WebPEncodingSetError(tls, picture, int32(VP8_ENC_ERROR_OUT_OF_MEMORY))
 				goto Error
 			}
 			(*VP8LEncoder)(unsafe.Pointer(enc)).Fargb_content = int32(kEncoderNearLossless)
 		} else {
 			(*VP8LEncoder)(unsafe.Pointer(enc)).Fargb_content = int32(kEncoderNone)
 		}
 		// Encode palette
 		if (*VP8LEncoder)(unsafe.Pointer(enc)).Fuse_palette != 0 {
 			if !(PaletteSort(tls, (**(**CrunchConfig)(__ccgo_up(crunch_configs + uintptr(idx)*28))).Fpalette_sorting_type, (*VP8LEncoder)(unsafe.Pointer(enc)).Fpic, enc+1128, libc.Uint32FromInt32((*VP8LEncoder)(unsafe.Pointer(enc)).Fpalette_size), enc+104) != 0) {
 				WebPEncodingSetError(tls, (*VP8LEncoder)(unsafe.Pointer(enc)).Fpic, int32(VP8_ENC_ERROR_OUT_OF_MEMORY))
 				goto Error
 			}
 			percent_range = remaining_percent / int32(4)
 			if !(EncodePalette(tls, bw2, low_effort, enc, percent_range, bp) != 0) {
 				goto Error
 			}
 			remaining_percent = remaining_percent - percent_range
 			if !(MapImageFromPalette(tls, enc) != 0) {
 				goto Error
 			}
 			// If using a color cache, do not have it bigger than the number of
 			// colors.
 			if (*VP8LEncoder)(unsafe.Pointer(enc)).Fpalette_size < libc.Int32FromInt32(1)<<libc.Int32FromInt32(MAX_COLOR_CACHE_BITS) {
 				v5 = int32(31) ^ libc.X__builtin_clz(tls, libc.Uint32FromInt32((*VP8LEncoder)(unsafe.Pointer(enc)).Fpalette_size))
 				goto _7
 			_7:
 				(*VP8LEncoder)(unsafe.Pointer(enc)).Fcache_bits = v5 + int32(1)
 			}
 		}
 		// In case image is not packed.
 		if (*VP8LEncoder)(unsafe.Pointer(enc)).Fargb_content != int32(kEncoderNearLossless) && (*VP8LEncoder)(unsafe.Pointer(enc)).Fargb_content != int32(kEncoderPalette) {
 			if !(MakeInputImageCopy(tls, enc) != 0) {
 				goto Error
 			}
 		}
 		// -------------------------------------------------------------------------
 		// Apply transforms and write transform data.
 		if (*VP8LEncoder)(unsafe.Pointer(enc)).Fuse_subtract_green != 0 {
 			ApplySubtractGreen(tls, enc, (*VP8LEncoder)(unsafe.Pointer(enc)).Fcurrent_width, height, bw2)
 		}
 		if (*VP8LEncoder)(unsafe.Pointer(enc)).Fuse_predict != 0 {
 			percent_range = remaining_percent / int32(3)
 			if !(ApplyPredictFilter(tls, enc, (*VP8LEncoder)(unsafe.Pointer(enc)).Fcurrent_width, height, quality, low_effort, (*VP8LEncoder)(unsafe.Pointer(enc)).Fuse_subtract_green, bw2, percent_range, bp, bp+112) != 0) {
 				goto Error
 			}
 			remaining_percent = remaining_percent - percent_range
 		}
 		if (*VP8LEncoder)(unsafe.Pointer(enc)).Fuse_cross_color != 0 {
 			percent_range = remaining_percent / int32(2)
 			if !(ApplyCrossColorFilter(tls, enc, (*VP8LEncoder)(unsafe.Pointer(enc)).Fcurrent_width, height, quality, low_effort, bw2, percent_range, bp, bp+116) != 0) {
 				goto Error
 			}
 			remaining_percent = remaining_percent - percent_range
 		}
 		v1 = bw2
 		v9 = libc.BoolUint32(!(libc.Int32FromInt32(TRANSFORM_PRESENT) != 0))
 		v5 = int32(1)
 		if libc.Uint64FromInt64(4) == libc.Uint64FromInt32(4) {
 			if v5 > libc.Int32FromInt32(0) {
 				if (*VP8LBitWriter)(unsafe.Pointer(v1)).Fused >= libc.Int32FromInt32(32) {
 					VP8LPutBitsFlushBits(tls, v1)
 				}
 				**(**vp8l_atype_t)(__ccgo_up(v1)) |= uint64(v9) << (*VP8LBitWriter)(unsafe.Pointer(v1)).Fused
 				**(**int32)(__ccgo_up(v1 + 8)) += v5
 			}
 		} else {
 			VP8LPutBitsInternal(tls, v1, v9, v5)
 		} // No more transforms.
 		// -------------------------------------------------------------------------
 		// Encode and write the transformed image.
 		if !(EncodeImageInternal(tls, bw2, (*VP8LEncoder)(unsafe.Pointer(enc)).Fargb, enc+2312, enc+2152, (*VP8LEncoder)(unsafe.Pointer(enc)).Fcurrent_width, height, quality, low_effort, crunch_configs+uintptr(idx)*28, enc+80, (*VP8LEncoder)(unsafe.Pointer(enc)).Fhisto_bits, byte_position, bp+4, bp+8, picture, remaining_percent, bp) != 0) {
 			goto Error
 		}
 		// If we are better than what we already have.
 		v1 = bw2
 		v2 = libc.Uint64FromInt64(int64((*VP8LBitWriter)(unsafe.Pointer(v1)).Fcur) - int64((*VP8LBitWriter)(unsafe.Pointer(v1)).Fbuf) + int64(((*VP8LBitWriter)(unsafe.Pointer(v1)).Fused+libc.Int32FromInt32(7))>>libc.Int32FromInt32(3)))
 		goto _13
 	_13:
 		if v2 < best_size {
 			v8 = bw2
 			v12 = libc.Uint64FromInt64(int64((*VP8LBitWriter)(unsafe.Pointer(v8)).Fcur) - int64((*VP8LBitWriter)(unsafe.Pointer(v8)).Fbuf) + int64(((*VP8LBitWriter)(unsafe.Pointer(v8)).Fused+libc.Int32FromInt32(7))>>libc.Int32FromInt32(3)))
 			goto _16
 		_16:
 			best_size = v12
 			// Store the BitWriter.
 			VP8LBitWriterSwap(tls, bw2, bp+64)
 			// Update the stats.
 			if stats != libc.UintptrFromInt32(0) {
 				(*WebPAuxStats)(unsafe.Pointer(stats)).Flossless_features = uint32(0)
 				if (*VP8LEncoder)(unsafe.Pointer(enc)).Fuse_predict != 0 {
 					**(**uint32_t)(__ccgo_up(stats + 148)) |= uint32(1)
 				}
 				if (*VP8LEncoder)(unsafe.Pointer(enc)).Fuse_cross_color != 0 {
 					**(**uint32_t)(__ccgo_up(stats + 148)) |= uint32(2)
 				}
 				if (*VP8LEncoder)(unsafe.Pointer(enc)).Fuse_subtract_green != 0 {
 					**(**uint32_t)(__ccgo_up(stats + 148)) |= uint32(4)
 				}
 				if (*VP8LEncoder)(unsafe.Pointer(enc)).Fuse_palette != 0 {
 					**(**uint32_t)(__ccgo_up(stats + 148)) |= uint32(8)
 				}
 				(*WebPAuxStats)(unsafe.Pointer(stats)).Fhistogram_bits = (*VP8LEncoder)(unsafe.Pointer(enc)).Fhisto_bits
 				(*WebPAuxStats)(unsafe.Pointer(stats)).Ftransform_bits = **(**int32)(__ccgo_up(bp + 112))
 				(*WebPAuxStats)(unsafe.Pointer(stats)).Fcross_color_transform_bits = **(**int32)(__ccgo_up(bp + 116))
 				(*WebPAuxStats)(unsafe.Pointer(stats)).Fcache_bits = (*VP8LEncoder)(unsafe.Pointer(enc)).Fcache_bits
 				(*WebPAuxStats)(unsafe.Pointer(stats)).Fpalette_size = (*VP8LEncoder)(unsafe.Pointer(enc)).Fpalette_size
 				(*WebPAuxStats)(unsafe.Pointer(stats)).Flossless_size = libc.Int32FromUint64(best_size - byte_position)
 				(*WebPAuxStats)(unsafe.Pointer(stats)).Flossless_hdr_size = **(**int32)(__ccgo_up(bp + 4))
 				(*WebPAuxStats)(unsafe.Pointer(stats)).Flossless_data_size = **(**int32)(__ccgo_up(bp + 8))
 			}
 		}
 		// Reset the bit writer for the following iteration if any.
 		if num_crunch_configs > int32(1) {
 			VP8LBitWriterReset(tls, bp+16, bw2)
 		}
 		goto _4
 	_4:
 		;
 		idx = idx + 1
 	}
 	VP8LBitWriterSwap(tls, bp+64, bw2)
 	goto Error
 Error:
 	;
 	VP8LBitWriterWipeOut(tls, bp+64)
 	// The hook should return false in case of error.
 	return libc.BoolInt32((*WebPPicture)(unsafe.Pointer((*StreamEncodeContext)(unsafe.Pointer(params)).Fpicture)).Ferror_code == int32(VP8_ENC_OK))
 }
 
 func VP8LEncodeStream(tls *libc.TLS, config uintptr, picture1 uintptr, bw_main uintptr) (r int32) {
 	bp := tls.Alloc(1872)
 	defer tls.Free(1872)
 	var enc_main, enc_side, param, worker, worker_interface, v7, v8 uintptr
 	var idx, num_crunch_configs_side, ok_main, ok_side, params_size, v1 int32
 	var v11, v14 size_t
 	var _ /* bw_side at bp+1568 */ VP8LBitWriter
 	var _ /* crunch_configs at bp+0 */ [14]CrunchConfig
 	var _ /* num_crunch_configs_main at bp+392 */ int32
 	var _ /* params_main at bp+496 */ StreamEncodeContext
 	var _ /* params_side at bp+936 */ StreamEncodeContext
 	var _ /* picture_side at bp+1616 */ WebPPicture
 	var _ /* red_and_blue_always_zero at bp+396 */ int32
 	var _ /* stats_side at bp+1376 */ WebPAuxStats
 	var _ /* worker_main at bp+400 */ WebPWorker
 	var _ /* worker_side at bp+448 */ WebPWorker
 	_, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = enc_main, enc_side, idx, num_crunch_configs_side, ok_main, ok_side, param, params_size, worker, worker_interface, v1, v11, v14, v7, v8
 	enc_main = VP8LEncoderNew(tls, config, picture1)
 	enc_side = libc.UintptrFromInt32(0)
 	num_crunch_configs_side = 0
 	**(**int32)(__ccgo_up(bp + 396)) = 0
 	worker_interface = WebPGetWorkerInterface(tls)
 	if enc_main == libc.UintptrFromInt32(0) || !(VP8LBitWriterInit(tls, bp+1568, uint64(0)) != 0) {
 		VP8LEncoderDelete(tls, enc_main)
 		return WebPEncodingSetError(tls, picture1, int32(VP8_ENC_ERROR_OUT_OF_MEMORY))
 	}
 	// Avoid "garbage value" error from Clang's static analysis tool.
 	v1 = WebPPictureInitInternal(tls, bp+1616, int32(WEBP_ENCODER_ABI_VERSION))
 	goto _2
 _2:
 	if !(v1 != 0) {
 		goto Error
 	}
 	// Analyze image (entropy, num_palettes etc)
 	if !(EncoderAnalyze(tls, enc_main, bp, bp+392, bp+396) != 0) || !(EncoderInit(tls, enc_main) != 0) {
 		WebPEncodingSetError(tls, picture1, int32(VP8_ENC_ERROR_OUT_OF_MEMORY))
 		goto Error
 	}
 	// Split the configs between the main and side threads (if any).
 	if (*WebPConfig)(unsafe.Pointer(config)).Fthread_level > 0 {
 		num_crunch_configs_side = **(**int32)(__ccgo_up(bp + 392)) / int32(2)
 		idx = 0
 		for {
 			if !(idx < num_crunch_configs_side) {
 				break
 			}
 			**(**CrunchConfig)(__ccgo_up(bp + 936 + 32 + uintptr(idx)*28)) = (**(**[14]CrunchConfig)(__ccgo_up(bp)))[**(**int32)(__ccgo_up(bp + 392))-num_crunch_configs_side+idx]
 			goto _3
 		_3:
 			;
 			idx = idx + 1
 		}
 		(**(**StreamEncodeContext)(__ccgo_up(bp + 936))).Fnum_crunch_configs = num_crunch_configs_side
 	}
 	**(**int32)(__ccgo_up(bp + 392)) = **(**int32)(__ccgo_up(bp + 392)) - num_crunch_configs_side
 	idx = 0
 	for {
 		if !(idx < **(**int32)(__ccgo_up(bp + 392))) {
 			break
 		}
 		**(**CrunchConfig)(__ccgo_up(bp + 496 + 32 + uintptr(idx)*28)) = (**(**[14]CrunchConfig)(__ccgo_up(bp)))[idx]
 		goto _4
 	_4:
 		;
 		idx = idx + 1
 	}
 	(**(**StreamEncodeContext)(__ccgo_up(bp + 496))).Fnum_crunch_configs = **(**int32)(__ccgo_up(bp + 392))
 	// Fill in the parameters for the thread workers.
 	if num_crunch_configs_side > 0 {
 		v1 = int32(2)
 	} else {
 		v1 = int32(1)
 	}
 	params_size = v1
 	idx = 0
 	for {
 		if !(idx < params_size) {
 			break
 		}
 		if idx == 0 {
 			v7 = bp + 400
 		} else {
 			v7 = bp + 448
 		}
 		// Create the parameters for each worker.
 		worker = v7
 		if idx == 0 {
 			v8 = bp + 496
 		} else {
 			v8 = bp + 936
 		}
 		param = v8
 		(*StreamEncodeContext)(unsafe.Pointer(param)).Fconfig = config
 		(*StreamEncodeContext)(unsafe.Pointer(param)).Fred_and_blue_always_zero = **(**int32)(__ccgo_up(bp + 396))
 		if idx == 0 {
 			(*StreamEncodeContext)(unsafe.Pointer(param)).Fpicture = picture1
 			(*StreamEncodeContext)(unsafe.Pointer(param)).Fstats = (*WebPPicture)(unsafe.Pointer(picture1)).Fstats
 			(*StreamEncodeContext)(unsafe.Pointer(param)).Fbw = bw_main
 			(*StreamEncodeContext)(unsafe.Pointer(param)).Fenc = enc_main
 		} else {
 			// Create a side picture (error_code is not thread-safe).
 			if !(WebPPictureView(tls, picture1, 0, 0, (*WebPPicture)(unsafe.Pointer(picture1)).Fwidth, (*WebPPicture)(unsafe.Pointer(picture1)).Fheight, bp+1616) != 0) {
 			}
 			(**(**WebPPicture)(__ccgo_up(bp + 1616))).Fprogress_hook = libc.UintptrFromInt32(0) // Progress hook is not thread-safe.
 			(*StreamEncodeContext)(unsafe.Pointer(param)).Fpicture = bp + 1616                  // No need to free a view afterwards.
 			if (*WebPPicture)(unsafe.Pointer(picture1)).Fstats == libc.UintptrFromInt32(0) {
 				v7 = libc.UintptrFromInt32(0)
 			} else {
 				v7 = bp + 1376
 			}
 			(*StreamEncodeContext)(unsafe.Pointer(param)).Fstats = v7
 			// Create a side bit writer.
 			if !(VP8LBitWriterClone(tls, bw_main, bp+1568) != 0) {
 				WebPEncodingSetError(tls, picture1, int32(VP8_ENC_ERROR_OUT_OF_MEMORY))
 				goto Error
 			}
 			(*StreamEncodeContext)(unsafe.Pointer(param)).Fbw = bp + 1568
 			// Create a side encoder.
 			enc_side = VP8LEncoderNew(tls, config, bp+1616)
 			if enc_side == libc.UintptrFromInt32(0) || !(EncoderInit(tls, enc_side) != 0) {
 				WebPEncodingSetError(tls, picture1, int32(VP8_ENC_ERROR_OUT_OF_MEMORY))
 				goto Error
 			}
 			// Copy the values that were computed for the main encoder.
 			(*VP8LEncoder)(unsafe.Pointer(enc_side)).Fhisto_bits = (*VP8LEncoder)(unsafe.Pointer(enc_main)).Fhisto_bits
 			(*VP8LEncoder)(unsafe.Pointer(enc_side)).Fpredictor_transform_bits = (*VP8LEncoder)(unsafe.Pointer(enc_main)).Fpredictor_transform_bits
 			(*VP8LEncoder)(unsafe.Pointer(enc_side)).Fcross_color_transform_bits = (*VP8LEncoder)(unsafe.Pointer(enc_main)).Fcross_color_transform_bits
 			(*VP8LEncoder)(unsafe.Pointer(enc_side)).Fpalette_size = (*VP8LEncoder)(unsafe.Pointer(enc_main)).Fpalette_size
 			libc.X__builtin___memcpy_chk(tls, enc_side+104, enc_main+104, uint64(1024), ^__predefined_size_t(0))
 			libc.X__builtin___memcpy_chk(tls, enc_side+1128, enc_main+1128, uint64(1024), ^__predefined_size_t(0))
 			(*StreamEncodeContext)(unsafe.Pointer(param)).Fenc = enc_side
 		}
 		// Create the workers.
 		(*(*func(*libc.TLS, uintptr))(unsafe.Pointer(&struct{ uintptr }{(*WebPWorkerInterface)(unsafe.Pointer(worker_interface)).FInit})))(tls, worker)
 		(*WebPWorker)(unsafe.Pointer(worker)).Fdata1 = param
 		(*WebPWorker)(unsafe.Pointer(worker)).Fdata2 = libc.UintptrFromInt32(0)
 		(*WebPWorker)(unsafe.Pointer(worker)).Fhook = __ccgo_fp(EncodeStreamHook)
 		goto _6
 	_6:
 		;
 		idx = idx + 1
 	}
 	// Start the second thread if needed.
 	if num_crunch_configs_side != 0 {
 		if !((*(*func(*libc.TLS, uintptr) int32)(unsafe.Pointer(&struct{ uintptr }{(*WebPWorkerInterface)(unsafe.Pointer(worker_interface)).FReset})))(tls, bp+448) != 0) {
 			WebPEncodingSetError(tls, picture1, int32(VP8_ENC_ERROR_OUT_OF_MEMORY))
 			goto Error
 		}
 		// This line is here and not in the param initialization above to remove a
 		// Clang static analyzer warning.
 		if (*WebPPicture)(unsafe.Pointer(picture1)).Fstats != libc.UintptrFromInt32(0) {
 			libc.X__builtin___memcpy_chk(tls, bp+1376, (*WebPPicture)(unsafe.Pointer(picture1)).Fstats, uint64(188), ^__predefined_size_t(0))
 		}
 		(*(*func(*libc.TLS, uintptr))(unsafe.Pointer(&struct{ uintptr }{(*WebPWorkerInterface)(unsafe.Pointer(worker_interface)).FLaunch})))(tls, bp+448)
 	}
 	// Execute the main thread.
 	(*(*func(*libc.TLS, uintptr))(unsafe.Pointer(&struct{ uintptr }{(*WebPWorkerInterface)(unsafe.Pointer(worker_interface)).FExecute})))(tls, bp+400)
 	ok_main = (*(*func(*libc.TLS, uintptr) int32)(unsafe.Pointer(&struct{ uintptr }{(*WebPWorkerInterface)(unsafe.Pointer(worker_interface)).FSync})))(tls, bp+400)
 	(*(*func(*libc.TLS, uintptr))(unsafe.Pointer(&struct{ uintptr }{(*WebPWorkerInterface)(unsafe.Pointer(worker_interface)).FEnd})))(tls, bp+400)
 	if num_crunch_configs_side != 0 {
 		// Wait for the second thread.
 		ok_side = (*(*func(*libc.TLS, uintptr) int32)(unsafe.Pointer(&struct{ uintptr }{(*WebPWorkerInterface)(unsafe.Pointer(worker_interface)).FSync})))(tls, bp+448)
 		(*(*func(*libc.TLS, uintptr))(unsafe.Pointer(&struct{ uintptr }{(*WebPWorkerInterface)(unsafe.Pointer(worker_interface)).FEnd})))(tls, bp+448)
 		if !(ok_main != 0) || !(ok_side != 0) {
 			if (*WebPPicture)(unsafe.Pointer(picture1)).Ferror_code == int32(VP8_ENC_OK) {
 				WebPEncodingSetError(tls, picture1, (**(**WebPPicture)(__ccgo_up(bp + 1616))).Ferror_code)
 			}
 			goto Error
 		}
 		v7 = bp + 1568
 		v11 = libc.Uint64FromInt64(int64((*VP8LBitWriter)(unsafe.Pointer(v7)).Fcur) - int64((*VP8LBitWriter)(unsafe.Pointer(v7)).Fbuf) + int64(((*VP8LBitWriter)(unsafe.Pointer(v7)).Fused+libc.Int32FromInt32(7))>>libc.Int32FromInt32(3)))
 		goto _12
 	_12:
 		v8 = bw_main
 		v14 = libc.Uint64FromInt64(int64((*VP8LBitWriter)(unsafe.Pointer(v8)).Fcur) - int64((*VP8LBitWriter)(unsafe.Pointer(v8)).Fbuf) + int64(((*VP8LBitWriter)(unsafe.Pointer(v8)).Fused+libc.Int32FromInt32(7))>>libc.Int32FromInt32(3)))
 		goto _15
 	_15:
 		if v11 < v14 {
 			VP8LBitWriterSwap(tls, bw_main, bp+1568)
 			if (*WebPPicture)(unsafe.Pointer(picture1)).Fstats != libc.UintptrFromInt32(0) {
 				libc.X__builtin___memcpy_chk(tls, (*WebPPicture)(unsafe.Pointer(picture1)).Fstats, bp+1376, uint64(188), ^__predefined_size_t(0))
 			}
 		}
 	}
 	goto Error
 Error:
 	;
 	VP8LBitWriterWipeOut(tls, bp+1568)
 	VP8LEncoderDelete(tls, enc_main)
 	VP8LEncoderDelete(tls, enc_side)
 	return libc.BoolInt32((*WebPPicture)(unsafe.Pointer(picture1)).Ferror_code == int32(VP8_ENC_OK))
 }
 
 func VP8LEncodeImage(tls *libc.TLS, config uintptr, picture uintptr) (r int32) {
 	bp := tls.Alloc(64)
 	defer tls.Free(64)
 	var has_alpha, height, initial_size, mb_h, mb_w, width, v1 int32
 	var stats uintptr
 	var _ /* bw at bp+16 */ VP8LBitWriter
 	var _ /* coded_size at bp+0 */ size_t
 	var _ /* percent at bp+8 */ int32
 	_, _, _, _, _, _, _, _ = has_alpha, height, initial_size, mb_h, mb_w, stats, width, v1
 	**(**int32)(__ccgo_up(bp + 8)) = 0
 	if picture == libc.UintptrFromInt32(0) {
 		return 0
 	}
 	if config == libc.UintptrFromInt32(0) || (*WebPPicture)(unsafe.Pointer(picture)).Fargb == libc.UintptrFromInt32(0) {
 		return WebPEncodingSetError(tls, picture, int32(VP8_ENC_ERROR_NULL_PARAMETER))
 	}
 	width = (*WebPPicture)(unsafe.Pointer(picture)).Fwidth
 	height = (*WebPPicture)(unsafe.Pointer(picture)).Fheight
 	// Initialize BitWriter with size corresponding to 16 bpp to photo images and
 	// 8 bpp for graphical images.
 	if (*WebPConfig)(unsafe.Pointer(config)).Fimage_hint == int32(WEBP_HINT_GRAPH) {
 		v1 = width * height
 	} else {
 		v1 = width * height * int32(2)
 	}
 	initial_size = v1
 	if !(VP8LBitWriterInit(tls, bp+16, libc.Uint64FromInt32(initial_size)) != 0) {
 		WebPEncodingSetError(tls, picture, int32(VP8_ENC_ERROR_OUT_OF_MEMORY))
 		goto Error
 	}
 	if !!(WebPReportProgress(tls, picture, int32(1), bp+8) != 0) {
 		goto _2
 	}
 	goto UserAbort
 UserAbort:
 	;
 	WebPEncodingSetError(tls, picture, int32(VP8_ENC_ERROR_USER_ABORT))
 	goto Error
 _2:
 	;
 	// Reset stats (for pure lossless coding)
 	if (*WebPPicture)(unsafe.Pointer(picture)).Fstats != libc.UintptrFromInt32(0) {
 		stats = (*WebPPicture)(unsafe.Pointer(picture)).Fstats
 		libc.X__builtin___memset_chk(tls, stats, 0, uint64(188), ^__predefined_size_t(0))
 		**(**float32)(__ccgo_up(stats + 4)) = libc.Float32FromFloat32(99)
 		**(**float32)(__ccgo_up(stats + 4 + 1*4)) = libc.Float32FromFloat32(99)
 		**(**float32)(__ccgo_up(stats + 4 + 2*4)) = libc.Float32FromFloat32(99)
 		**(**float32)(__ccgo_up(stats + 4 + 3*4)) = libc.Float32FromFloat32(99)
 		**(**float32)(__ccgo_up(stats + 4 + 4*4)) = libc.Float32FromFloat32(99)
 	}
 	// Write image size.
 	if !(WriteImageSize(tls, picture, bp+16) != 0) {
 		WebPEncodingSetError(tls, picture, int32(VP8_ENC_ERROR_OUT_OF_MEMORY))
 		goto Error
 	}
 	has_alpha = WebPPictureHasTransparency(tls, picture)
 	// Write the non-trivial Alpha flag and lossless version.
 	if !(WriteRealAlphaAndVersion(tls, bp+16, has_alpha) != 0) {
 		WebPEncodingSetError(tls, picture, int32(VP8_ENC_ERROR_OUT_OF_MEMORY))
 		goto Error
 	}
 	if !(WebPReportProgress(tls, picture, int32(2), bp+8) != 0) {
 		goto UserAbort
 	}
 	// Encode main image stream.
 	if !(VP8LEncodeStream(tls, config, picture, bp+16) != 0) {
 		goto Error
 	}
 	if !(WebPReportProgress(tls, picture, int32(99), bp+8) != 0) {
 		goto UserAbort
 	}
 	// Finish the RIFF chunk.
 	if !(WriteImage(tls, picture, bp+16, bp) != 0) {
 		goto Error
 	}
 	if !(WebPReportProgress(tls, picture, int32(100), bp+8) != 0) {
 		goto UserAbort
 	}
 	// Save size.
 	if (*WebPPicture)(unsafe.Pointer(picture)).Fstats != libc.UintptrFromInt32(0) {
 		**(**int32)(__ccgo_up((*WebPPicture)(unsafe.Pointer(picture)).Fstats)) += libc.Int32FromUint64(**(**size_t)(__ccgo_up(bp)))
 		(*WebPAuxStats)(unsafe.Pointer((*WebPPicture)(unsafe.Pointer(picture)).Fstats)).Flossless_size = libc.Int32FromUint64(**(**size_t)(__ccgo_up(bp)))
 	}
 	if (*WebPPicture)(unsafe.Pointer(picture)).Fextra_info != libc.UintptrFromInt32(0) {
 		mb_w = (width + int32(15)) >> int32(4)
 		mb_h = (height + int32(15)) >> int32(4)
 		libc.X__builtin___memset_chk(tls, (*WebPPicture)(unsafe.Pointer(picture)).Fextra_info, 0, libc.Uint64FromInt32(mb_w*mb_h)*uint64(1), ^__predefined_size_t(0))
 	}
 	goto Error
 Error:
 	;
 	if (**(**VP8LBitWriter)(__ccgo_up(bp + 16))).Ferror1 != 0 {
 		WebPEncodingSetError(tls, picture, int32(VP8_ENC_ERROR_OUT_OF_MEMORY))
 	}
 	VP8LBitWriterWipeOut(tls, bp+16)
 	return libc.BoolInt32((*WebPPicture)(unsafe.Pointer(picture)).Ferror_code == int32(VP8_ENC_OK))
 }
 
 const VP8L_MAGIC_BYTE4 = 0x2f
 const __FLT_MIN__9 = 1.1754943508222875e-38
 
 //------------------------------------------------------------------------------
 
 // Copyright 2012 Google Inc. All Rights Reserved.
 //
 // Use of this source code is governed by a BSD-style license
 // that can be found in the COPYING file in the root of the source
 // tree. An additional intellectual property rights grant can be found
 // in the file PATENTS. All contributing project authors may
 // be found in the AUTHORS file in the root of the source tree.
 // -----------------------------------------------------------------------------
 //
 // Misc. common utility functions
 //
 // Authors: Skal (pascal.massimino@gmail.com)
 //          Urvang (urvang@google.com)
 
 // Copyright 2011 Google Inc. All Rights Reserved.
 //
 // Use of this source code is governed by a BSD-style license
 // that can be found in the COPYING file in the root of the source
 // tree. An additional intellectual property rights grant can be found
 // in the file PATENTS. All contributing project authors may
 // be found in the AUTHORS file in the root of the source tree.
 // -----------------------------------------------------------------------------
 //
 //   WebP encoder: main interface
 //
 // Author: Skal (pascal.massimino@gmail.com)
 
 // #define PRINT_MEMORY_INFO
 
 //------------------------------------------------------------------------------
 
 func WebPGetEncoderVersion(tls *libc.TLS) (r int32) {
 	return libc.Int32FromInt32(ENC_MAJ_VERSION)<<libc.Int32FromInt32(16) | libc.Int32FromInt32(ENC_MIN_VERSION)<<libc.Int32FromInt32(8) | libc.Int32FromInt32(ENC_REV_VERSION)
 }
 
 //------------------------------------------------------------------------------
 // VP8Encoder
 //------------------------------------------------------------------------------
 
 func ResetSegmentHeader1(tls *libc.TLS, enc uintptr) {
 	var hdr uintptr
 	_ = hdr
 	hdr = enc + 32
 	(*VP8EncSegmentHeader)(unsafe.Pointer(hdr)).Fnum_segments = (*WebPConfig)(unsafe.Pointer((*VP8Encoder)(unsafe.Pointer(enc)).Fconfig)).Fsegments
 	(*VP8EncSegmentHeader)(unsafe.Pointer(hdr)).Fupdate_map = libc.BoolInt32((*VP8EncSegmentHeader)(unsafe.Pointer(hdr)).Fnum_segments > int32(1))
 	(*VP8EncSegmentHeader)(unsafe.Pointer(hdr)).Fsize = 0
 }
 
 func ResetFilterHeader(tls *libc.TLS, enc uintptr) {
 	var hdr uintptr
 	_ = hdr
 	hdr = enc + 16
 	(*VP8EncFilterHeader)(unsafe.Pointer(hdr)).Fsimple = int32(1)
 	(*VP8EncFilterHeader)(unsafe.Pointer(hdr)).Flevel = 0
 	(*VP8EncFilterHeader)(unsafe.Pointer(hdr)).Fsharpness = 0
 	(*VP8EncFilterHeader)(unsafe.Pointer(hdr)).Fi4x4_lf_delta = 0
 }
 
 func ResetBoundaryPredictions(tls *libc.TLS, enc uintptr) {
 	var i int32
 	var left, top uintptr
 	_, _, _ = i, left, top
 	top = (*VP8Encoder)(unsafe.Pointer(enc)).Fpreds - uintptr((*VP8Encoder)(unsafe.Pointer(enc)).Fpreds_w)
 	left = (*VP8Encoder)(unsafe.Pointer(enc)).Fpreds - uintptr(1)
 	i = -int32(1)
 	for {
 		if !(i < int32(4)*(*VP8Encoder)(unsafe.Pointer(enc)).Fmb_w) {
 			break
 		}
 		**(**uint8_t)(__ccgo_up(top + uintptr(i))) = uint8(B_DC_PRED)
 		goto _1
 	_1:
 		;
 		i = i + 1
 	}
 	i = 0
 	for {
 		if !(i < int32(4)*(*VP8Encoder)(unsafe.Pointer(enc)).Fmb_h) {
 			break
 		}
 		**(**uint8_t)(__ccgo_up(left + uintptr(i*(*VP8Encoder)(unsafe.Pointer(enc)).Fpreds_w))) = uint8(B_DC_PRED)
 		goto _2
 	_2:
 		;
 		i = i + 1
 	}
 	**(**uint32_t)(__ccgo_up((*VP8Encoder)(unsafe.Pointer(enc)).Fnz + uintptr(-libc.Int32FromInt32(1))*4)) = uint32(0) // constant
 }
 
 // Mapping from config->method to coding tools used.
 //-------------------+---+---+---+---+---+---+---+
 //   Method          | 0 | 1 | 2 | 3 |(4)| 5 | 6 |
 //-------------------+---+---+---+---+---+---+---+
 // fast probe        | x |   |   | x |   |   |   |
 //-------------------+---+---+---+---+---+---+---+
 // dynamic proba     | ~ | x | x | x | x | x | x |
 //-------------------+---+---+---+---+---+---+---+
 // fast mode analysis|[x]|[x]|   |   | x | x | x |
 //-------------------+---+---+---+---+---+---+---+
 // basic rd-opt      |   |   |   | x | x | x | x |
 //-------------------+---+---+---+---+---+---+---+
 // disto-refine i4/16| x | x | x |   |   |   |   |
 //-------------------+---+---+---+---+---+---+---+
 // disto-refine uv   |   | x | x |   |   |   |   |
 //-------------------+---+---+---+---+---+---+---+
 // rd-opt i4/16      |   |   | ~ | x | x | x | x |
 //-------------------+---+---+---+---+---+---+---+
 // token buffer (opt)|   |   |   | x | x | x | x |
 //-------------------+---+---+---+---+---+---+---+
 // Trellis           |   |   |   |   |   | x |Ful|
 //-------------------+---+---+---+---+---+---+---+
 // full-SNS          |   |   |   |   | x | x | x |
 //-------------------+---+---+---+---+---+---+---+
 
 func MapConfigToTools(tls *libc.TLS, enc uintptr) {
 	var config uintptr
 	var limit, method, v1, v2, v3 int32
 	_, _, _, _, _, _ = config, limit, method, v1, v2, v3
 	config = (*VP8Encoder)(unsafe.Pointer(enc)).Fconfig
 	method = (*WebPConfig)(unsafe.Pointer(config)).Fmethod
 	limit = int32(100) - (*WebPConfig)(unsafe.Pointer(config)).Fpartition_limit
 	(*VP8Encoder)(unsafe.Pointer(enc)).Fmethod = method
 	if method >= int32(6) {
 		v1 = int32(RD_OPT_TRELLIS_ALL)
 	} else {
 		if method >= int32(5) {
 			v2 = int32(RD_OPT_TRELLIS)
 		} else {
 			if method >= int32(3) {
 				v3 = int32(RD_OPT_BASIC)
 			} else {
 				v3 = int32(RD_OPT_NONE)
 			}
 			v2 = v3
 		}
 		v1 = v2
 	}
 	(*VP8Encoder)(unsafe.Pointer(enc)).Frd_opt_level = v1
 	(*VP8Encoder)(unsafe.Pointer(enc)).Fmax_i4_header_bits = libc.Int32FromInt32(256) * libc.Int32FromInt32(16) * libc.Int32FromInt32(16) * (limit * limit) / (libc.Int32FromInt32(100) * libc.Int32FromInt32(100)) // ... modulated with a quadratic curve.
 	// partition0 = 512k max.
 	(*VP8Encoder)(unsafe.Pointer(enc)).Fmb_header_limit = int32(libc.Int64FromInt32(256) * libc.Int64FromInt32(510) * libc.Int64FromInt32(8) * libc.Int64FromInt32(1024) / int64((*VP8Encoder)(unsafe.Pointer(enc)).Fmb_w*(*VP8Encoder)(unsafe.Pointer(enc)).Fmb_h))
 	(*VP8Encoder)(unsafe.Pointer(enc)).Fthread_level = (*WebPConfig)(unsafe.Pointer(config)).Fthread_level
 	(*VP8Encoder)(unsafe.Pointer(enc)).Fdo_search = libc.BoolInt32((*WebPConfig)(unsafe.Pointer(config)).Ftarget_size > 0 || (*WebPConfig)(unsafe.Pointer(config)).Ftarget_PSNR > libc.Float32FromInt32(0))
 	if !((*WebPConfig)(unsafe.Pointer(config)).Flow_memory != 0) {
 		(*VP8Encoder)(unsafe.Pointer(enc)).Fuse_tokens = libc.BoolInt32((*VP8Encoder)(unsafe.Pointer(enc)).Frd_opt_level >= int32(RD_OPT_BASIC)) // need rd stats
 		if (*VP8Encoder)(unsafe.Pointer(enc)).Fuse_tokens != 0 {
 			(*VP8Encoder)(unsafe.Pointer(enc)).Fnum_parts = int32(1) // doesn't work with multi-partition
 		}
 	}
 }
 
 // Memory scaling with dimensions:
 //  memory (bytes) ~= 2.25 * w + 0.0625 * w * h
 //
 // Typical memory footprint (614x440 picture)
 //              encoder: 22111
 //                 info: 4368
 //                preds: 17741
 //          top samples: 1263
 //             non-zero: 175
 //             lf-stats: 0
 //                total: 45658
 // Transient object sizes:
 //       VP8EncIterator: 3360
 //         VP8ModeScore: 872
 //       VP8SegmentInfo: 732
 //          VP8EncProba: 18352
 //              LFStats: 2048
 // Picture size (yuv): 419328
 
 func InitVP8Encoder(tls *libc.TLS, config uintptr, picture uintptr) (r uintptr) {
 	var enc, mem, v3 uintptr
 	var info_size, lf_stats_size, nz_size, preds_size, samples_size, top_derr_size size_t
 	var mb_h, mb_w, preds_h, preds_w, top_stride, use_filter, v5, v6 int32
 	var scale float32
 	var size uint64_t
 	var v1, v2 uint64
 	_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = enc, info_size, lf_stats_size, mb_h, mb_w, mem, nz_size, preds_h, preds_size, preds_w, samples_size, scale, size, top_derr_size, top_stride, use_filter, v1, v2, v3, v5, v6
 	use_filter = libc.BoolInt32((*WebPConfig)(unsafe.Pointer(config)).Ffilter_strength > 0 || (*WebPConfig)(unsafe.Pointer(config)).Fautofilter > 0)
 	mb_w = ((*WebPPicture)(unsafe.Pointer(picture)).Fwidth + int32(15)) >> int32(4)
 	mb_h = ((*WebPPicture)(unsafe.Pointer(picture)).Fheight + int32(15)) >> int32(4)
 	preds_w = int32(4)*mb_w + int32(1)
 	preds_h = int32(4)*mb_h + int32(1)
 	preds_size = libc.Uint64FromInt32(preds_w*preds_h) * uint64(1)
 	top_stride = mb_w * int32(16)
 	nz_size = libc.Uint64FromInt32(mb_w+libc.Int32FromInt32(1))*uint64(4) + uint64(WEBP_ALIGN_CST)
 	info_size = libc.Uint64FromInt32(mb_w*mb_h) * uint64(4)
 	samples_size = libc.Uint64FromInt32(int32(2)*top_stride)*uint64(1) + uint64(WEBP_ALIGN_CST)
 	if (*WebPConfig)(unsafe.Pointer(config)).Fautofilter != 0 {
 		v1 = libc.Uint64FromInt64(2048) + libc.Uint64FromInt32(WEBP_ALIGN_CST)
 	} else {
 		v1 = uint64(0)
 	} // align all
 	lf_stats_size = v1
 	if (*WebPConfig)(unsafe.Pointer(config)).Fquality <= libc.Float32FromInt32(ERROR_DIFFUSION_QUALITY) || (*WebPConfig)(unsafe.Pointer(config)).Fpass > int32(1) {
 		v2 = libc.Uint64FromInt32(mb_w) * uint64(4)
 	} else {
 		v2 = uint64(0)
 	}
 	top_derr_size = v2
 	size = libc.Uint64FromInt64(23704) + libc.Uint64FromInt32(WEBP_ALIGN_CST) + info_size + preds_size + samples_size + top_derr_size + nz_size + lf_stats_size // autofilter stats
 	mem = WebPSafeMalloc(tls, size, uint64(1))
 	if mem == libc.UintptrFromInt32(0) {
 		WebPEncodingSetError(tls, picture, int32(VP8_ENC_ERROR_OUT_OF_MEMORY))
 		return libc.UintptrFromInt32(0)
 	}
 	enc = mem
 	mem = uintptr((uint64(mem+libc.UintptrFromInt64(23704)) + libc.Uint64FromInt32(WEBP_ALIGN_CST)) & ^libc.Uint64FromInt32(WEBP_ALIGN_CST))
 	libc.X__builtin___memset_chk(tls, enc, 0, uint64(23704), ^__predefined_size_t(0))
 	(*VP8Encoder)(unsafe.Pointer(enc)).Fnum_parts = int32(1) << (*WebPConfig)(unsafe.Pointer(config)).Fpartitions
 	(*VP8Encoder)(unsafe.Pointer(enc)).Fmb_w = mb_w
 	(*VP8Encoder)(unsafe.Pointer(enc)).Fmb_h = mb_h
 	(*VP8Encoder)(unsafe.Pointer(enc)).Fpreds_w = preds_w
 	(*VP8Encoder)(unsafe.Pointer(enc)).Fmb_info = mem
 	mem = mem + uintptr(info_size)
 	(*VP8Encoder)(unsafe.Pointer(enc)).Fpreds = mem + uintptr(1) + uintptr((*VP8Encoder)(unsafe.Pointer(enc)).Fpreds_w)
 	mem = mem + uintptr(preds_size)
 	(*VP8Encoder)(unsafe.Pointer(enc)).Fnz = uintptr(1)*4 + uintptr((uint64(mem)+libc.Uint64FromInt32(WEBP_ALIGN_CST)) & ^libc.Uint64FromInt32(WEBP_ALIGN_CST))
 	mem = mem + uintptr(nz_size)
 	if lf_stats_size != 0 {
 		v3 = uintptr((uint64(mem) + libc.Uint64FromInt32(WEBP_ALIGN_CST)) & ^libc.Uint64FromInt32(WEBP_ALIGN_CST))
 	} else {
 		v3 = libc.UintptrFromInt32(0)
 	}
 	(*VP8Encoder)(unsafe.Pointer(enc)).Flf_stats = v3
 	mem = mem + uintptr(lf_stats_size)
 	// top samples (all 16-aligned)
 	mem = uintptr((uint64(mem) + libc.Uint64FromInt32(WEBP_ALIGN_CST)) & ^libc.Uint64FromInt32(WEBP_ALIGN_CST))
 	(*VP8Encoder)(unsafe.Pointer(enc)).Fy_top = mem
 	(*VP8Encoder)(unsafe.Pointer(enc)).Fuv_top = (*VP8Encoder)(unsafe.Pointer(enc)).Fy_top + uintptr(top_stride)
 	mem = mem + uintptr(int32(2)*top_stride)
 	if top_derr_size != 0 {
 		v3 = mem
 	} else {
 		v3 = libc.UintptrFromInt32(0)
 	}
 	(*VP8Encoder)(unsafe.Pointer(enc)).Ftop_derr = v3
 	mem = mem + uintptr(top_derr_size)
 	(*VP8Encoder)(unsafe.Pointer(enc)).Fconfig = config
 	if use_filter != 0 {
 		if (*WebPConfig)(unsafe.Pointer(config)).Ffilter_type == int32(1) {
 			v6 = 0
 		} else {
 			v6 = int32(1)
 		}
 		v5 = v6
 	} else {
 		v5 = int32(2)
 	}
 	(*VP8Encoder)(unsafe.Pointer(enc)).Fprofile = v5
 	(*VP8Encoder)(unsafe.Pointer(enc)).Fpic = picture
 	(*VP8Encoder)(unsafe.Pointer(enc)).Fpercent = 0
 	MapConfigToTools(tls, enc)
 	VP8EncDspInit(tls)
 	VP8DefaultProbas(tls, enc)
 	ResetSegmentHeader1(tls, enc)
 	ResetFilterHeader(tls, enc)
 	ResetBoundaryPredictions(tls, enc)
 	VP8EncDspCostInit(tls)
 	VP8EncInitAlpha(tls, enc)
 	// lower quality means smaller output -> we modulate a little the page
 	// size based on quality. This is just a crude 1rst-order prediction.
 	scale = libc.Float32FromFloat32(1) + float32((*WebPConfig)(unsafe.Pointer(config)).Fquality*libc.Float32FromFloat32(5))/libc.Float32FromFloat32(100) // in [1,6]
 	VP8TBufferInit(tls, enc+496, int32(float32(float32(mb_w*mb_h*libc.Int32FromInt32(4))*scale)))
 	return enc
 }
 
 func DeleteVP8Encoder(tls *libc.TLS, enc uintptr) (r int32) {
 	var ok int32
 	_ = ok
 	ok = int32(1)
 	if enc != libc.UintptrFromInt32(0) {
 		ok = VP8EncDeleteAlpha(tls, enc)
 		VP8TBufferClear(tls, enc+496)
 		WebPSafeFree(tls, enc)
 	}
 	return ok
 }
 
 //------------------------------------------------------------------------------
 
 func GetPSNR2(tls *libc.TLS, err uint64_t, size uint64_t) (r float64) {
 	var v1 float64
 	_ = v1
 	if err > uint64(0) && size > uint64(0) {
 		v1 = float64(float64(10) * libc.Xlog10(tls, float64(float64(libc.Float64FromFloat64(255)*libc.Float64FromFloat64(255))*float64(size))/float64(err)))
 	} else {
 		v1 = float64(99)
 	}
 	return v1
 }
 
 func FinalizePSNR(tls *libc.TLS, enc uintptr) {
 	var size uint64_t
 	var sse, stats uintptr
 	_, _, _ = size, sse, stats
 	stats = (*WebPPicture)(unsafe.Pointer((*VP8Encoder)(unsafe.Pointer(enc)).Fpic)).Fstats
 	size = (*VP8Encoder)(unsafe.Pointer(enc)).Fsse_count
 	sse = enc + 23512
 	**(**float32)(__ccgo_up(stats + 4)) = float32(GetPSNR2(tls, **(**uint64_t)(__ccgo_up(sse)), size))
 	**(**float32)(__ccgo_up(stats + 4 + 1*4)) = float32(GetPSNR2(tls, **(**uint64_t)(__ccgo_up(sse + 1*8)), size/uint64(4)))
 	**(**float32)(__ccgo_up(stats + 4 + 2*4)) = float32(GetPSNR2(tls, **(**uint64_t)(__ccgo_up(sse + 2*8)), size/uint64(4)))
 	**(**float32)(__ccgo_up(stats + 4 + 3*4)) = float32(GetPSNR2(tls, **(**uint64_t)(__ccgo_up(sse))+**(**uint64_t)(__ccgo_up(sse + 1*8))+**(**uint64_t)(__ccgo_up(sse + 2*8)), size*uint64(3)/uint64(2)))
 	**(**float32)(__ccgo_up(stats + 4 + 4*4)) = float32(GetPSNR2(tls, **(**uint64_t)(__ccgo_up(sse + 3*8)), size))
 }
 
 func StoreStats(tls *libc.TLS, enc uintptr) {
 	var i, s int32
 	var stats uintptr
 	_, _, _ = i, s, stats
 	stats = (*WebPPicture)(unsafe.Pointer((*VP8Encoder)(unsafe.Pointer(enc)).Fpic)).Fstats
 	if stats != libc.UintptrFromInt32(0) {
 		i = 0
 		for {
 			if !(i < int32(NUM_MB_SEGMENTS)) {
 				break
 			}
 			**(**int32)(__ccgo_up(stats + 124 + uintptr(i)*4)) = (**(**VP8SegmentInfo)(__ccgo_up(enc + 608 + uintptr(i)*744))).Ffstrength
 			**(**int32)(__ccgo_up(stats + 108 + uintptr(i)*4)) = (**(**VP8SegmentInfo)(__ccgo_up(enc + 608 + uintptr(i)*744))).Fquant
 			s = 0
 			for {
 				if !(s <= int32(2)) {
 					break
 				}
 				**(**int32)(__ccgo_up(stats + 44 + uintptr(s)*16 + uintptr(i)*4)) = **(**int32)(__ccgo_up(enc + 23556 + uintptr(s)*16 + uintptr(i)*4))
 				goto _2
 			_2:
 				;
 				s = s + 1
 			}
 			goto _1
 		_1:
 			;
 			i = i + 1
 		}
 		FinalizePSNR(tls, enc)
 		(*WebPAuxStats)(unsafe.Pointer(stats)).Fcoded_size = (*VP8Encoder)(unsafe.Pointer(enc)).Fcoded_size
 		i = 0
 		for {
 			if !(i < int32(3)) {
 				break
 			}
 			**(**int32)(__ccgo_up(stats + 24 + uintptr(i)*4)) = **(**int32)(__ccgo_up(enc + 23604 + uintptr(i)*4))
 			goto _3
 		_3:
 			;
 			i = i + 1
 		}
 	}
 }
 
 func WebPEncodingSetError(tls *libc.TLS, pic uintptr, error1 WebPEncodingError1) (r int32) {
 	// The oldest error reported takes precedence over the new one.
 	if (*WebPPicture)(unsafe.Pointer(pic)).Ferror_code == int32(VP8_ENC_OK) {
 		(*WebPPicture)(unsafe.Pointer(pic)).Ferror_code = error1
 	}
 	return 0
 }
 
 func WebPReportProgress(tls *libc.TLS, pic uintptr, percent int32, percent_store uintptr) (r int32) {
 	if percent_store != libc.UintptrFromInt32(0) && percent != **(**int32)(__ccgo_up(percent_store)) {
 		**(**int32)(__ccgo_up(percent_store)) = percent
 		if (*WebPPicture)(unsafe.Pointer(pic)).Fprogress_hook != 0 && !((*(*func(*libc.TLS, int32, uintptr) int32)(unsafe.Pointer(&struct{ uintptr }{(*WebPPicture)(unsafe.Pointer(pic)).Fprogress_hook})))(tls, percent, pic) != 0) {
 			// user abort requested
 			return WebPEncodingSetError(tls, pic, int32(VP8_ENC_ERROR_USER_ABORT))
 		}
 	}
 	return int32(1) // ok
 }
 
 //------------------------------------------------------------------------------
 
 func WebPEncode(tls *libc.TLS, config uintptr, pic uintptr) (r int32) {
 	var dithering, x, x2 float32
 	var enc uintptr
 	var ok int32
 	_, _, _, _, _ = dithering, enc, ok, x, x2
 	ok = 0
 	if pic == libc.UintptrFromInt32(0) {
 		return 0
 	}
 	(*WebPPicture)(unsafe.Pointer(pic)).Ferror_code = int32(VP8_ENC_OK) // all ok so far
 	if config == libc.UintptrFromInt32(0) {                             // bad params
 		return WebPEncodingSetError(tls, pic, int32(VP8_ENC_ERROR_NULL_PARAMETER))
 	}
 	if !(WebPValidateConfig(tls, config) != 0) {
 		return WebPEncodingSetError(tls, pic, int32(VP8_ENC_ERROR_INVALID_CONFIGURATION))
 	}
 	if !(WebPValidatePicture(tls, pic) != 0) {
 		return 0
 	}
 	if (*WebPPicture)(unsafe.Pointer(pic)).Fwidth > int32(WEBP_MAX_DIMENSION) || (*WebPPicture)(unsafe.Pointer(pic)).Fheight > int32(WEBP_MAX_DIMENSION) {
 		return WebPEncodingSetError(tls, pic, int32(VP8_ENC_ERROR_BAD_DIMENSION))
 	}
 	if (*WebPPicture)(unsafe.Pointer(pic)).Fstats != libc.UintptrFromInt32(0) {
 		libc.X__builtin___memset_chk(tls, (*WebPPicture)(unsafe.Pointer(pic)).Fstats, 0, uint64(188), ^__predefined_size_t(0))
 	}
 	if !((*WebPConfig)(unsafe.Pointer(config)).Flossless != 0) {
 		enc = libc.UintptrFromInt32(0)
 		if (*WebPPicture)(unsafe.Pointer(pic)).Fuse_argb != 0 || (*WebPPicture)(unsafe.Pointer(pic)).Fy == libc.UintptrFromInt32(0) || (*WebPPicture)(unsafe.Pointer(pic)).Fu == libc.UintptrFromInt32(0) || (*WebPPicture)(unsafe.Pointer(pic)).Fv == libc.UintptrFromInt32(0) {
 			// Make sure we have YUVA samples.
 			if (*WebPConfig)(unsafe.Pointer(config)).Fuse_sharp_yuv != 0 || (*WebPConfig)(unsafe.Pointer(config)).Fpreprocessing&int32(4) != 0 {
 				if !(WebPPictureSharpARGBToYUVA(tls, pic) != 0) {
 					return 0
 				}
 			} else {
 				dithering = libc.Float32FromFloat32(0)
 				if (*WebPConfig)(unsafe.Pointer(config)).Fpreprocessing&int32(2) != 0 {
 					x = (*WebPConfig)(unsafe.Pointer(config)).Fquality / libc.Float32FromFloat32(100)
 					x2 = float32(x * x)
 					// slowly decreasing from max dithering at low quality (q->0)
 					// to 0.5 dithering amplitude at high quality (q->100)
 					dithering = libc.Float32FromFloat32(1) + float32(float32((libc.Float32FromFloat32(0.5)-libc.Float32FromFloat32(1))*x2)*x2)
 				}
 				if !(WebPPictureARGBToYUVADithered(tls, pic, int32(WEBP_YUV420), dithering) != 0) {
 					return 0
 				}
 			}
 		}
 		if !((*WebPConfig)(unsafe.Pointer(config)).Fexact != 0) {
 			WebPCleanupTransparentArea(tls, pic)
 		}
 		enc = InitVP8Encoder(tls, config, pic)
 		if enc == libc.UintptrFromInt32(0) {
 			return 0
 		} // pic->error is already set.
 		// Note: each of the tasks below account for 20% in the progress report.
 		ok = VP8EncAnalyze(tls, enc)
 		// Analysis is done, proceed to actual coding.
 		ok = libc.BoolInt32(ok != 0 && VP8EncStartAlpha(tls, enc) != 0) // possibly done in parallel
 		if !((*VP8Encoder)(unsafe.Pointer(enc)).Fuse_tokens != 0) {
 			ok = libc.BoolInt32(ok != 0 && VP8EncLoop(tls, enc) != 0)
 		} else {
 			ok = libc.BoolInt32(ok != 0 && VP8EncTokenLoop(tls, enc) != 0)
 		}
 		ok = libc.BoolInt32(ok != 0 && VP8EncFinishAlpha(tls, enc) != 0)
 		ok = libc.BoolInt32(ok != 0 && VP8EncWrite(tls, enc) != 0)
 		StoreStats(tls, enc)
 		if !(ok != 0) {
 			VP8EncFreeBitWriters(tls, enc)
 		}
 		ok = ok & DeleteVP8Encoder(tls, enc) // must always be called, even if !ok
 	} else {
 		// Make sure we have ARGB samples.
 		if (*WebPPicture)(unsafe.Pointer(pic)).Fargb == libc.UintptrFromInt32(0) && !(WebPPictureYUVAToARGB(tls, pic) != 0) {
 			return 0
 		}
 		if !((*WebPConfig)(unsafe.Pointer(config)).Fexact != 0) {
 			WebPReplaceTransparentPixels(tls, pic, uint32(0x000000))
 		}
 		ok = VP8LEncodeImage(tls, config, pic) // Sets pic->error in case of problem.
 	}
 	return ok
 }
 
 const VP8L_LOG8_WBITS = 4
 const __FLT_MIN__10 = 1.17549435082228750796873653722224568e-38
 
 // Copyright 2010 Google Inc. All Rights Reserved.
 //
 // Use of this source code is governed by a BSD-style license
 // that can be found in the COPYING file in the root of the source
 // tree. An additional intellectual property rights grant can be found
 // in the file PATENTS. All contributing project authors may
 // be found in the AUTHORS file in the root of the source tree.
 // -----------------------------------------------------------------------------
 //
 // Boolean decoder
 //
 // Author: Skal (pascal.massimino@gmail.com)
 //         Vikas Arora (vikaas.arora@gmail.com)
 
 // Copyright 2014 Google Inc. All Rights Reserved.
 //
 // Use of this source code is governed by a BSD-style license
 // that can be found in the COPYING file in the root of the source
 // tree. An additional intellectual property rights grant can be found
 // in the file PATENTS. All contributing project authors may
 // be found in the AUTHORS file in the root of the source tree.
 // -----------------------------------------------------------------------------
 //
 // Endian related functions.
 
 // Copyright 2012 Google Inc. All Rights Reserved.
 //
 // Use of this source code is governed by a BSD-style license
 // that can be found in the COPYING file in the root of the source
 // tree. An additional intellectual property rights grant can be found
 // in the file PATENTS. All contributing project authors may
 // be found in the AUTHORS file in the root of the source tree.
 // -----------------------------------------------------------------------------
 //
 // Misc. common utility functions
 //
 // Authors: Skal (pascal.massimino@gmail.com)
 //          Urvang (urvang@google.com)
 
 //------------------------------------------------------------------------------
 // VP8BitReader
 
 func VP8BitReaderSetBuffer(tls *libc.TLS, br uintptr, start uintptr, size size_t) {
 	var v1 uintptr
 	_ = v1
 	(*VP8BitReader)(unsafe.Pointer(br)).Fbuf = start
 	(*VP8BitReader)(unsafe.Pointer(br)).Fbuf_end = start + uintptr(size)
 	if size >= uint64(8) {
 		v1 = start + uintptr(size) - uintptr(8) + uintptr(1)
 	} else {
 		v1 = start
 	}
 	(*VP8BitReader)(unsafe.Pointer(br)).Fbuf_max = v1
 }
 
 func VP8InitBitReader(tls *libc.TLS, br1 uintptr, start uintptr, size size_t) {
 	bp := tls.Alloc(16)
 	defer tls.Free(16)
 	var bits bit_t
 	var v1 uintptr
 	var v2 uint64_t
 	var _ /* in_bits at bp+0 */ lbit_t
 	_, _, _ = bits, v1, v2
 	// limit ensured by format and upstream checks
 	(*VP8BitReader)(unsafe.Pointer(br1)).Frange1 = libc.Uint32FromInt32(libc.Int32FromInt32(255) - libc.Int32FromInt32(1))
 	(*VP8BitReader)(unsafe.Pointer(br1)).Fvalue = uint64(0)
 	(*VP8BitReader)(unsafe.Pointer(br1)).Fbits = -int32(8) // to load the very first 8bits
 	(*VP8BitReader)(unsafe.Pointer(br1)).Feof = 0
 	VP8BitReaderSetBuffer(tls, br1, start, size)
 	v1 = br1
 	if (*VP8BitReader)(unsafe.Pointer(v1)).Fbuf < (*VP8BitReader)(unsafe.Pointer(v1)).Fbuf_max {
 		libc.X__builtin___memcpy_chk(tls, bp, (*VP8BitReader)(unsafe.Pointer(v1)).Fbuf, uint64(8), ^__predefined_size_t(0))
 		**(**uintptr)(__ccgo_up(v1 + 16)) += uintptr(libc.Int32FromInt32(BITS) >> libc.Int32FromInt32(3))
 		v2 = uint64(libc.X__builtin_bswap64(tls, uint64(**(**lbit_t)(__ccgo_up(bp)))))
 		goto _3
 	_3:
 		bits = v2
 		bits = bits >> libc.Uint64FromInt32(libc.Int32FromInt32(64)-libc.Int32FromInt32(BITS))
 		(*VP8BitReader)(unsafe.Pointer(v1)).Fvalue = bits | (*VP8BitReader)(unsafe.Pointer(v1)).Fvalue<<libc.Int32FromInt32(BITS)
 		**(**int32)(__ccgo_up(v1 + 12)) += int32(BITS)
 	} else {
 		VP8LoadFinalBytes(tls, v1)
 	}
 }
 
 func VP8RemapBitReader(tls *libc.TLS, br uintptr, offset ptrdiff_t) {
 	if (*VP8BitReader)(unsafe.Pointer(br)).Fbuf != libc.UintptrFromInt32(0) {
 		**(**uintptr)(__ccgo_up(br + 16)) += uintptr(offset)
 		**(**uintptr)(__ccgo_up(br + 24)) += uintptr(offset)
 		**(**uintptr)(__ccgo_up(br + 32)) += uintptr(offset)
 	}
 }
 
 func VP8LoadFinalBytes(tls *libc.TLS, br uintptr) {
 	var v1, v2 uintptr
 	_, _ = v1, v2
 	// Only read 8bits at a time
 	if (*VP8BitReader)(unsafe.Pointer(br)).Fbuf < (*VP8BitReader)(unsafe.Pointer(br)).Fbuf_end {
 		**(**int32)(__ccgo_up(br + 12)) += int32(8)
 		v2 = br + 16
 		v1 = *(*uintptr)(unsafe.Pointer(v2))
 		*(*uintptr)(unsafe.Pointer(v2)) = *(*uintptr)(unsafe.Pointer(v2)) + 1
 		(*VP8BitReader)(unsafe.Pointer(br)).Fvalue = uint64(**(**uint8_t)(__ccgo_up(v1))) | (*VP8BitReader)(unsafe.Pointer(br)).Fvalue<<libc.Int32FromInt32(8)
 	} else {
 		if !((*VP8BitReader)(unsafe.Pointer(br)).Feof != 0) {
 			**(**bit_t)(__ccgo_up(br)) <<= uint64(8)
 			**(**int32)(__ccgo_up(br + 12)) += int32(8)
 			(*VP8BitReader)(unsafe.Pointer(br)).Feof = int32(1)
 		} else {
 			(*VP8BitReader)(unsafe.Pointer(br)).Fbits = 0 // This is to avoid undefined behaviour with shifts.
 		}
 	}
 }
 
 //------------------------------------------------------------------------------
 // Higher-level calls
 
 func VP8GetValue(tls *libc.TLS, br2 uintptr, bits1 int32) (r uint32_t) {
 	bp := tls.Alloc(16)
 	defer tls.Free(16)
 	var bit, pos, shift, v1, v6, v8 int32
 	var bits bit_t
 	var range1, split, value range_t
 	var v uint32_t
 	var v2, v3 uintptr
 	var v4 uint64_t
 	var _ /* in_bits at bp+0 */ lbit_t
 	_, _, _, _, _, _, _, _, _, _, _, _, _, _ = bit, bits, pos, range1, shift, split, v, value, v1, v2, v3, v4, v6, v8
 	v = uint32(0)
 	for {
 		v1 = bits1
 		bits1 = bits1 - 1
 		if !(v1 > 0) {
 			break
 		}
 		v2 = br2
 		range1 = (*VP8BitReader)(unsafe.Pointer(v2)).Frange1
 		if (*VP8BitReader)(unsafe.Pointer(v2)).Fbits < libc.Int32FromInt32(0) {
 			v3 = v2
 			if (*VP8BitReader)(unsafe.Pointer(v3)).Fbuf < (*VP8BitReader)(unsafe.Pointer(v3)).Fbuf_max {
 				libc.X__builtin___memcpy_chk(tls, bp, (*VP8BitReader)(unsafe.Pointer(v3)).Fbuf, uint64(8), ^__predefined_size_t(0))
 				**(**uintptr)(__ccgo_up(v3 + 16)) += uintptr(libc.Int32FromInt32(BITS) >> libc.Int32FromInt32(3))
 				v4 = uint64(libc.X__builtin_bswap64(tls, uint64(**(**lbit_t)(__ccgo_up(bp)))))
 				goto _5
 			_5:
 				bits = v4
 				bits = bits >> libc.Uint64FromInt32(libc.Int32FromInt32(64)-libc.Int32FromInt32(BITS))
 				(*VP8BitReader)(unsafe.Pointer(v3)).Fvalue = bits | (*VP8BitReader)(unsafe.Pointer(v3)).Fvalue<<libc.Int32FromInt32(BITS)
 				**(**int32)(__ccgo_up(v3 + 12)) += int32(BITS)
 			} else {
 				VP8LoadFinalBytes(tls, v3)
 			}
 		}
 		pos = (*VP8BitReader)(unsafe.Pointer(v2)).Fbits
 		split = range1 * libc.Uint32FromInt32(int32(0x80)) >> int32(8)
 		value = uint32((*VP8BitReader)(unsafe.Pointer(v2)).Fvalue >> pos)
 		bit = libc.BoolInt32(value > split)
 		if bit != 0 {
 			range1 = range1 - split
 			**(**bit_t)(__ccgo_up(v2)) -= uint64(split+libc.Uint32FromInt32(1)) << pos
 		} else {
 			range1 = split + uint32(1)
 		}
 		v6 = int32(31) ^ libc.X__builtin_clz(tls, range1)
 		goto _7
 	_7:
 		shift = int32(7) ^ v6
 		range1 = range1 << libc.Uint32FromInt32(shift)
 		**(**int32)(__ccgo_up(v2 + 12)) -= shift
 		(*VP8BitReader)(unsafe.Pointer(v2)).Frange1 = range1 - uint32(1)
 		v8 = bit
 		goto _9
 	_9:
 		v = v | libc.Uint32FromInt32(v8<<bits1)
 	}
 	return v
 }
 
 func VP8GetSignedValue(tls *libc.TLS, br uintptr, bits int32) (r int32_t) {
 	var value, v1 int32
 	_, _ = value, v1
 	value = libc.Int32FromUint32(VP8GetValue(tls, br, bits))
 	if VP8GetValue(tls, br, int32(1)) != 0 {
 		v1 = -value
 	} else {
 		v1 = value
 	}
 	return v1
 }
 
 //------------------------------------------------------------------------------
 // VP8LBitReader
 
 var kBitMask = [25]uint32_t{
 	1:  uint32(0x000001),
 	2:  uint32(0x000003),
 	3:  uint32(0x000007),
 	4:  uint32(0x00000f),
 	5:  uint32(0x00001f),
 	6:  uint32(0x00003f),
 	7:  uint32(0x00007f),
 	8:  uint32(0x0000ff),
 	9:  uint32(0x0001ff),
 	10: uint32(0x0003ff),
 	11: uint32(0x0007ff),
 	12: uint32(0x000fff),
 	13: uint32(0x001fff),
 	14: uint32(0x003fff),
 	15: uint32(0x007fff),
 	16: uint32(0x00ffff),
 	17: uint32(0x01ffff),
 	18: uint32(0x03ffff),
 	19: uint32(0x07ffff),
 	20: uint32(0x0fffff),
 	21: uint32(0x1fffff),
 	22: uint32(0x3fffff),
 	23: uint32(0x7fffff),
 	24: uint32(0xffffff),
 }
 
 func VP8LInitBitReader(tls *libc.TLS, br uintptr, start uintptr, length size_t) {
 	var i size_t
 	var value vp8l_val_t
 	_, _ = i, value
 	value = uint64(0)
 	// can't happen with a RIFF chunk.
 	(*VP8LBitReader)(unsafe.Pointer(br)).Flen1 = length
 	(*VP8LBitReader)(unsafe.Pointer(br)).Fval = uint64(0)
 	(*VP8LBitReader)(unsafe.Pointer(br)).Fbit_pos = 0
 	(*VP8LBitReader)(unsafe.Pointer(br)).Feos = 0
 	if length > uint64(8) {
 		length = uint64(8)
 	}
 	i = uint64(0)
 	for {
 		if !(i < length) {
 			break
 		}
 		value = value | uint64(**(**uint8_t)(__ccgo_up(start + uintptr(i))))<<(uint64(8)*i)
 		goto _1
 	_1:
 		;
 		i = i + 1
 	}
 	(*VP8LBitReader)(unsafe.Pointer(br)).Fval = value
 	(*VP8LBitReader)(unsafe.Pointer(br)).Fpos = length
 	(*VP8LBitReader)(unsafe.Pointer(br)).Fbuf = start
 }
 
 func VP8LBitReaderSetBuffer(tls *libc.TLS, br1 uintptr, buf uintptr, len1 size_t) {
 	var v1 uintptr
 	var v2 int32
 	var v4 bool
 	_, _, _ = v1, v2, v4
 	// can't happen with a RIFF chunk.
 	(*VP8LBitReader)(unsafe.Pointer(br1)).Fbuf = buf
 	(*VP8LBitReader)(unsafe.Pointer(br1)).Flen1 = len1
 	// 'pos' > 'len' should be considered a param error.
 	if v4 = (*VP8LBitReader)(unsafe.Pointer(br1)).Fpos > (*VP8LBitReader)(unsafe.Pointer(br1)).Flen1; !v4 {
 		v1 = br1
 		v2 = libc.BoolInt32((*VP8LBitReader)(unsafe.Pointer(v1)).Feos != 0 || (*VP8LBitReader)(unsafe.Pointer(v1)).Fpos == (*VP8LBitReader)(unsafe.Pointer(v1)).Flen1 && (*VP8LBitReader)(unsafe.Pointer(v1)).Fbit_pos > int32(VP8L_LBITS))
 		goto _3
 	_3:
 	}
 	(*VP8LBitReader)(unsafe.Pointer(br1)).Feos = libc.BoolInt32(v4 || v2 != 0)
 }
 
 func VP8LSetEndOfStream(tls *libc.TLS, br uintptr) {
 	(*VP8LBitReader)(unsafe.Pointer(br)).Feos = int32(1)
 	(*VP8LBitReader)(unsafe.Pointer(br)).Fbit_pos = 0 // To avoid undefined behaviour with shifts.
 }
 
 // C documentation
 //
 //	// If not at EOS, reload up to VP8L_LBITS byte-by-byte
 func ShiftBytes(tls *libc.TLS, br1 uintptr) {
 	var v1 uintptr
 	var v2 int32
 	_, _ = v1, v2
 	for (*VP8LBitReader)(unsafe.Pointer(br1)).Fbit_pos >= int32(8) && (*VP8LBitReader)(unsafe.Pointer(br1)).Fpos < (*VP8LBitReader)(unsafe.Pointer(br1)).Flen1 {
 		**(**vp8l_val_t)(__ccgo_up(br1)) >>= uint64(8)
 		**(**vp8l_val_t)(__ccgo_up(br1)) |= uint64(**(**uint8_t)(__ccgo_up((*VP8LBitReader)(unsafe.Pointer(br1)).Fbuf + uintptr((*VP8LBitReader)(unsafe.Pointer(br1)).Fpos)))) << (libc.Int32FromInt32(VP8L_LBITS) - libc.Int32FromInt32(8))
 		(*VP8LBitReader)(unsafe.Pointer(br1)).Fpos = (*VP8LBitReader)(unsafe.Pointer(br1)).Fpos + 1
 		**(**int32)(__ccgo_up(br1 + 32)) -= int32(8)
 	}
 	v1 = br1
 	v2 = libc.BoolInt32((*VP8LBitReader)(unsafe.Pointer(v1)).Feos != 0 || (*VP8LBitReader)(unsafe.Pointer(v1)).Fpos == (*VP8LBitReader)(unsafe.Pointer(v1)).Flen1 && (*VP8LBitReader)(unsafe.Pointer(v1)).Fbit_pos > int32(VP8L_LBITS))
 	goto _3
 _3:
 	if v2 != 0 {
 		VP8LSetEndOfStream(tls, br1)
 	}
 }
 
 func VP8LDoFillBitWindow(tls *libc.TLS, br uintptr) {
 	bp := tls.Alloc(16)
 	defer tls.Free(16)
 	var v1 uint32_t
 	var _ /* A at bp+0 */ uint32_t
 	_ = v1
 	if (*VP8LBitReader)(unsafe.Pointer(br)).Fpos+uint64(8) < (*VP8LBitReader)(unsafe.Pointer(br)).Flen1 {
 		**(**vp8l_val_t)(__ccgo_up(br)) >>= uint64(VP8L_WBITS)
 		**(**int32)(__ccgo_up(br + 32)) -= int32(VP8L_WBITS)
 		libc.X__builtin___memcpy_chk(tls, bp, (*VP8LBitReader)(unsafe.Pointer(br)).Fbuf+uintptr((*VP8LBitReader)(unsafe.Pointer(br)).Fpos), uint64(4), ^__predefined_size_t(0))
 		v1 = **(**uint32_t)(__ccgo_up(bp))
 		goto _2
 	_2:
 		**(**vp8l_val_t)(__ccgo_up(br)) |= uint64(v1) << (libc.Int32FromInt32(VP8L_LBITS) - libc.Int32FromInt32(VP8L_WBITS))
 		**(**size_t)(__ccgo_up(br + 24)) += uint64(VP8L_LOG8_WBITS)
 		return
 	}
 	ShiftBytes(tls, br) // Slow path.
 }
 
 func VP8LReadBits(tls *libc.TLS, br1 uintptr, n_bits int32) (r uint32_t) {
 	var new_bits int32
 	var val, v2 uint32_t
 	var v1 uintptr
 	_, _, _, _ = new_bits, val, v1, v2
 	// Flag an error if end_of_stream or n_bits is more than allowed limit.
 	if !((*VP8LBitReader)(unsafe.Pointer(br1)).Feos != 0) && n_bits <= int32(VP8L_MAX_NUM_BIT_READ) {
 		v1 = br1
 		v2 = uint32((*VP8LBitReader)(unsafe.Pointer(v1)).Fval >> ((*VP8LBitReader)(unsafe.Pointer(v1)).Fbit_pos & (libc.Int32FromInt32(VP8L_LBITS) - libc.Int32FromInt32(1))))
 		goto _3
 	_3:
 		val = v2 & kBitMask[n_bits]
 		new_bits = (*VP8LBitReader)(unsafe.Pointer(br1)).Fbit_pos + n_bits
 		(*VP8LBitReader)(unsafe.Pointer(br1)).Fbit_pos = new_bits
 		ShiftBytes(tls, br1)
 		return val
 	} else {
 		VP8LSetEndOfStream(tls, br1)
 		return uint32(0)
 	}
 	return r
 }
 
 const MIN_EXTRA_SIZE = 32768
 
 //------------------------------------------------------------------------------
 
 //------------------------------------------------------------------------------
 // VP8BitWriter
 
 func BitWriterResize(tls *libc.TLS, bw uintptr, extra_size size_t) (r int32) {
 	var needed_size, new_size size_t
 	var needed_size_64b uint64_t
 	var new_buf uintptr
 	_, _, _, _ = needed_size, needed_size_64b, new_buf, new_size
 	needed_size_64b = (*VP8BitWriter)(unsafe.Pointer(bw)).Fpos + extra_size
 	needed_size = needed_size_64b
 	if needed_size_64b != needed_size {
 		(*VP8BitWriter)(unsafe.Pointer(bw)).Ferror1 = int32(1)
 		return 0
 	}
 	if needed_size <= (*VP8BitWriter)(unsafe.Pointer(bw)).Fmax_pos {
 		return int32(1)
 	}
 	// If the following line wraps over 32bit, the test just after will catch it.
 	new_size = uint64(2) * (*VP8BitWriter)(unsafe.Pointer(bw)).Fmax_pos
 	if new_size < needed_size {
 		new_size = needed_size
 	}
 	if new_size < uint64(1024) {
 		new_size = uint64(1024)
 	}
 	new_buf = WebPSafeMalloc(tls, uint64(1), new_size)
 	if new_buf == libc.UintptrFromInt32(0) {
 		(*VP8BitWriter)(unsafe.Pointer(bw)).Ferror1 = int32(1)
 		return 0
 	}
 	if (*VP8BitWriter)(unsafe.Pointer(bw)).Fpos > uint64(0) {
 		libc.X__builtin___memcpy_chk(tls, new_buf, (*VP8BitWriter)(unsafe.Pointer(bw)).Fbuf, (*VP8BitWriter)(unsafe.Pointer(bw)).Fpos, ^__predefined_size_t(0))
 	}
 	WebPSafeFree(tls, (*VP8BitWriter)(unsafe.Pointer(bw)).Fbuf)
 	(*VP8BitWriter)(unsafe.Pointer(bw)).Fbuf = new_buf
 	(*VP8BitWriter)(unsafe.Pointer(bw)).Fmax_pos = new_size
 	return int32(1)
 }
 
 func Flush(tls *libc.TLS, bw uintptr) {
 	var bits int32_t
 	var pos, v3 size_t
 	var s, value, v1 int32
 	_, _, _, _, _, _ = bits, pos, s, value, v1, v3
 	s = int32(8) + (*VP8BitWriter)(unsafe.Pointer(bw)).Fnb_bits
 	bits = (*VP8BitWriter)(unsafe.Pointer(bw)).Fvalue >> s
 	**(**int32_t)(__ccgo_up(bw + 4)) -= bits << s
 	**(**int32)(__ccgo_up(bw + 12)) -= int32(8)
 	if bits&int32(0xff) != int32(0xff) {
 		pos = (*VP8BitWriter)(unsafe.Pointer(bw)).Fpos
 		if !(BitWriterResize(tls, bw, libc.Uint64FromInt32((*VP8BitWriter)(unsafe.Pointer(bw)).Frun+int32(1))) != 0) {
 			return
 		}
 		if bits&int32(0x100) != 0 { // overflow -> propagate carry over pending 0xff's
 			if pos > uint64(0) {
 				**(**uint8_t)(__ccgo_up((*VP8BitWriter)(unsafe.Pointer(bw)).Fbuf + uintptr(pos-uint64(1)))) = **(**uint8_t)(__ccgo_up((*VP8BitWriter)(unsafe.Pointer(bw)).Fbuf + uintptr(pos-uint64(1)))) + 1
 			}
 		}
 		if (*VP8BitWriter)(unsafe.Pointer(bw)).Frun > 0 {
 			if bits&int32(0x100) != 0 {
 				v1 = 0x00
 			} else {
 				v1 = int32(0xff)
 			}
 			value = v1
 			for {
 				if !((*VP8BitWriter)(unsafe.Pointer(bw)).Frun > 0) {
 					break
 				}
 				v3 = pos
 				pos = pos + 1
 				**(**uint8_t)(__ccgo_up((*VP8BitWriter)(unsafe.Pointer(bw)).Fbuf + uintptr(v3))) = libc.Uint8FromInt32(value)
 				goto _2
 			_2:
 				;
 				(*VP8BitWriter)(unsafe.Pointer(bw)).Frun = (*VP8BitWriter)(unsafe.Pointer(bw)).Frun - 1
 			}
 		}
 		v3 = pos
 		pos = pos + 1
 		**(**uint8_t)(__ccgo_up((*VP8BitWriter)(unsafe.Pointer(bw)).Fbuf + uintptr(v3))) = libc.Uint8FromInt32(bits & int32(0xff))
 		(*VP8BitWriter)(unsafe.Pointer(bw)).Fpos = pos
 	} else {
 		(*VP8BitWriter)(unsafe.Pointer(bw)).Frun = (*VP8BitWriter)(unsafe.Pointer(bw)).Frun + 1 // delay writing of bytes 0xff, pending eventual carry.
 	}
 }
 
 //------------------------------------------------------------------------------
 // renormalization
 
 var kNorm = [128]uint8_t{
 	0:   uint8(7),
 	1:   uint8(6),
 	2:   uint8(6),
 	3:   uint8(5),
 	4:   uint8(5),
 	5:   uint8(5),
 	6:   uint8(5),
 	7:   uint8(4),
 	8:   uint8(4),
 	9:   uint8(4),
 	10:  uint8(4),
 	11:  uint8(4),
 	12:  uint8(4),
 	13:  uint8(4),
 	14:  uint8(4),
 	15:  uint8(3),
 	16:  uint8(3),
 	17:  uint8(3),
 	18:  uint8(3),
 	19:  uint8(3),
 	20:  uint8(3),
 	21:  uint8(3),
 	22:  uint8(3),
 	23:  uint8(3),
 	24:  uint8(3),
 	25:  uint8(3),
 	26:  uint8(3),
 	27:  uint8(3),
 	28:  uint8(3),
 	29:  uint8(3),
 	30:  uint8(3),
 	31:  uint8(2),
 	32:  uint8(2),
 	33:  uint8(2),
 	34:  uint8(2),
 	35:  uint8(2),
 	36:  uint8(2),
 	37:  uint8(2),
 	38:  uint8(2),
 	39:  uint8(2),
 	40:  uint8(2),
 	41:  uint8(2),
 	42:  uint8(2),
 	43:  uint8(2),
 	44:  uint8(2),
 	45:  uint8(2),
 	46:  uint8(2),
 	47:  uint8(2),
 	48:  uint8(2),
 	49:  uint8(2),
 	50:  uint8(2),
 	51:  uint8(2),
 	52:  uint8(2),
 	53:  uint8(2),
 	54:  uint8(2),
 	55:  uint8(2),
 	56:  uint8(2),
 	57:  uint8(2),
 	58:  uint8(2),
 	59:  uint8(2),
 	60:  uint8(2),
 	61:  uint8(2),
 	62:  uint8(2),
 	63:  uint8(1),
 	64:  uint8(1),
 	65:  uint8(1),
 	66:  uint8(1),
 	67:  uint8(1),
 	68:  uint8(1),
 	69:  uint8(1),
 	70:  uint8(1),
 	71:  uint8(1),
 	72:  uint8(1),
 	73:  uint8(1),
 	74:  uint8(1),
 	75:  uint8(1),
 	76:  uint8(1),
 	77:  uint8(1),
 	78:  uint8(1),
 	79:  uint8(1),
 	80:  uint8(1),
 	81:  uint8(1),
 	82:  uint8(1),
 	83:  uint8(1),
 	84:  uint8(1),
 	85:  uint8(1),
 	86:  uint8(1),
 	87:  uint8(1),
 	88:  uint8(1),
 	89:  uint8(1),
 	90:  uint8(1),
 	91:  uint8(1),
 	92:  uint8(1),
 	93:  uint8(1),
 	94:  uint8(1),
 	95:  uint8(1),
 	96:  uint8(1),
 	97:  uint8(1),
 	98:  uint8(1),
 	99:  uint8(1),
 	100: uint8(1),
 	101: uint8(1),
 	102: uint8(1),
 	103: uint8(1),
 	104: uint8(1),
 	105: uint8(1),
 	106: uint8(1),
 	107: uint8(1),
 	108: uint8(1),
 	109: uint8(1),
 	110: uint8(1),
 	111: uint8(1),
 	112: uint8(1),
 	113: uint8(1),
 	114: uint8(1),
 	115: uint8(1),
 	116: uint8(1),
 	117: uint8(1),
 	118: uint8(1),
 	119: uint8(1),
 	120: uint8(1),
 	121: uint8(1),
 	122: uint8(1),
 	123: uint8(1),
 	124: uint8(1),
 	125: uint8(1),
 	126: uint8(1),
 }
 
 // C documentation
 //
 //	// range = ((range + 1) << kVP8Log2Range[range]) - 1
 var kNewRange = [128]uint8_t{
 	0:   uint8(127),
 	1:   uint8(127),
 	2:   uint8(191),
 	3:   uint8(127),
 	4:   uint8(159),
 	5:   uint8(191),
 	6:   uint8(223),
 	7:   uint8(127),
 	8:   uint8(143),
 	9:   uint8(159),
 	10:  uint8(175),
 	11:  uint8(191),
 	12:  uint8(207),
 	13:  uint8(223),
 	14:  uint8(239),
 	15:  uint8(127),
 	16:  uint8(135),
 	17:  uint8(143),
 	18:  uint8(151),
 	19:  uint8(159),
 	20:  uint8(167),
 	21:  uint8(175),
 	22:  uint8(183),
 	23:  uint8(191),
 	24:  uint8(199),
 	25:  uint8(207),
 	26:  uint8(215),
 	27:  uint8(223),
 	28:  uint8(231),
 	29:  uint8(239),
 	30:  uint8(247),
 	31:  uint8(127),
 	32:  uint8(131),
 	33:  uint8(135),
 	34:  uint8(139),
 	35:  uint8(143),
 	36:  uint8(147),
 	37:  uint8(151),
 	38:  uint8(155),
 	39:  uint8(159),
 	40:  uint8(163),
 	41:  uint8(167),
 	42:  uint8(171),
 	43:  uint8(175),
 	44:  uint8(179),
 	45:  uint8(183),
 	46:  uint8(187),
 	47:  uint8(191),
 	48:  uint8(195),
 	49:  uint8(199),
 	50:  uint8(203),
 	51:  uint8(207),
 	52:  uint8(211),
 	53:  uint8(215),
 	54:  uint8(219),
 	55:  uint8(223),
 	56:  uint8(227),
 	57:  uint8(231),
 	58:  uint8(235),
 	59:  uint8(239),
 	60:  uint8(243),
 	61:  uint8(247),
 	62:  uint8(251),
 	63:  uint8(127),
 	64:  uint8(129),
 	65:  uint8(131),
 	66:  uint8(133),
 	67:  uint8(135),
 	68:  uint8(137),
 	69:  uint8(139),
 	70:  uint8(141),
 	71:  uint8(143),
 	72:  uint8(145),
 	73:  uint8(147),
 	74:  uint8(149),
 	75:  uint8(151),
 	76:  uint8(153),
 	77:  uint8(155),
 	78:  uint8(157),
 	79:  uint8(159),
 	80:  uint8(161),
 	81:  uint8(163),
 	82:  uint8(165),
 	83:  uint8(167),
 	84:  uint8(169),
 	85:  uint8(171),
 	86:  uint8(173),
 	87:  uint8(175),
 	88:  uint8(177),
 	89:  uint8(179),
 	90:  uint8(181),
 	91:  uint8(183),
 	92:  uint8(185),
 	93:  uint8(187),
 	94:  uint8(189),
 	95:  uint8(191),
 	96:  uint8(193),
 	97:  uint8(195),
 	98:  uint8(197),
 	99:  uint8(199),
 	100: uint8(201),
 	101: uint8(203),
 	102: uint8(205),
 	103: uint8(207),
 	104: uint8(209),
 	105: uint8(211),
 	106: uint8(213),
 	107: uint8(215),
 	108: uint8(217),
 	109: uint8(219),
 	110: uint8(221),
 	111: uint8(223),
 	112: uint8(225),
 	113: uint8(227),
 	114: uint8(229),
 	115: uint8(231),
 	116: uint8(233),
 	117: uint8(235),
 	118: uint8(237),
 	119: uint8(239),
 	120: uint8(241),
 	121: uint8(243),
 	122: uint8(245),
 	123: uint8(247),
 	124: uint8(249),
 	125: uint8(251),
 	126: uint8(253),
 	127: uint8(127),
 }
 
 func VP8PutBit(tls *libc.TLS, bw uintptr, bit int32, prob int32) (r int32) {
 	var shift, split int32
 	_, _ = shift, split
 	split = (*VP8BitWriter)(unsafe.Pointer(bw)).Frange1 * prob >> int32(8)
 	if bit != 0 {
 		**(**int32_t)(__ccgo_up(bw + 4)) += split + int32(1)
 		**(**int32_t)(__ccgo_up(bw)) -= split + int32(1)
 	} else {
 		(*VP8BitWriter)(unsafe.Pointer(bw)).Frange1 = split
 	}
 	if (*VP8BitWriter)(unsafe.Pointer(bw)).Frange1 < int32(127) { // emit 'shift' bits out and renormalize
 		shift = libc.Int32FromUint8(kNorm[(*VP8BitWriter)(unsafe.Pointer(bw)).Frange1])
 		(*VP8BitWriter)(unsafe.Pointer(bw)).Frange1 = libc.Int32FromUint8(kNewRange[(*VP8BitWriter)(unsafe.Pointer(bw)).Frange1])
 		**(**int32_t)(__ccgo_up(bw + 4)) <<= shift
 		**(**int32)(__ccgo_up(bw + 12)) += shift
 		if (*VP8BitWriter)(unsafe.Pointer(bw)).Fnb_bits > 0 {
 			Flush(tls, bw)
 		}
 	}
 	return bit
 }
 
 func VP8PutBitUniform(tls *libc.TLS, bw uintptr, bit int32) (r int32) {
 	var split int32
 	_ = split
 	split = (*VP8BitWriter)(unsafe.Pointer(bw)).Frange1 >> int32(1)
 	if bit != 0 {
 		**(**int32_t)(__ccgo_up(bw + 4)) += split + int32(1)
 		**(**int32_t)(__ccgo_up(bw)) -= split + int32(1)
 	} else {
 		(*VP8BitWriter)(unsafe.Pointer(bw)).Frange1 = split
 	}
 	if (*VP8BitWriter)(unsafe.Pointer(bw)).Frange1 < int32(127) {
 		(*VP8BitWriter)(unsafe.Pointer(bw)).Frange1 = libc.Int32FromUint8(kNewRange[(*VP8BitWriter)(unsafe.Pointer(bw)).Frange1])
 		**(**int32_t)(__ccgo_up(bw + 4)) <<= int32(1)
 		**(**int32)(__ccgo_up(bw + 12)) += int32(1)
 		if (*VP8BitWriter)(unsafe.Pointer(bw)).Fnb_bits > 0 {
 			Flush(tls, bw)
 		}
 	}
 	return bit
 }
 
 func VP8PutBits(tls *libc.TLS, bw uintptr, value uint32_t, nb_bits int32) {
 	var mask uint32_t
 	_ = mask
 	mask = uint32(1) << (nb_bits - int32(1))
 	for {
 		if !(mask != 0) {
 			break
 		}
 		VP8PutBitUniform(tls, bw, libc.Int32FromUint32(value&mask))
 		goto _1
 	_1:
 		;
 		mask = mask >> uint32(1)
 	}
 }
 
 func VP8PutSignedBits(tls *libc.TLS, bw uintptr, value int32, nb_bits int32) {
 	if !(VP8PutBitUniform(tls, bw, libc.BoolInt32(value != 0)) != 0) {
 		return
 	}
 	if value < 0 {
 		VP8PutBits(tls, bw, libc.Uint32FromInt32(-value<<int32(1)|int32(1)), nb_bits+int32(1))
 	} else {
 		VP8PutBits(tls, bw, libc.Uint32FromInt32(value<<int32(1)), nb_bits+int32(1))
 	}
 }
 
 //------------------------------------------------------------------------------
 
 func VP8BitWriterInit(tls *libc.TLS, bw uintptr, expected_size size_t) (r int32) {
 	var v1 int32
 	_ = v1
 	(*VP8BitWriter)(unsafe.Pointer(bw)).Frange1 = libc.Int32FromInt32(255) - libc.Int32FromInt32(1)
 	(*VP8BitWriter)(unsafe.Pointer(bw)).Fvalue = 0
 	(*VP8BitWriter)(unsafe.Pointer(bw)).Frun = 0
 	(*VP8BitWriter)(unsafe.Pointer(bw)).Fnb_bits = -int32(8)
 	(*VP8BitWriter)(unsafe.Pointer(bw)).Fpos = uint64(0)
 	(*VP8BitWriter)(unsafe.Pointer(bw)).Fmax_pos = uint64(0)
 	(*VP8BitWriter)(unsafe.Pointer(bw)).Ferror1 = 0
 	(*VP8BitWriter)(unsafe.Pointer(bw)).Fbuf = libc.UintptrFromInt32(0)
 	if expected_size > uint64(0) {
 		v1 = BitWriterResize(tls, bw, expected_size)
 	} else {
 		v1 = int32(1)
 	}
 	return v1
 }
 
 func VP8BitWriterFinish(tls *libc.TLS, bw uintptr) (r uintptr) {
 	VP8PutBits(tls, bw, uint32(0), int32(9)-(*VP8BitWriter)(unsafe.Pointer(bw)).Fnb_bits)
 	(*VP8BitWriter)(unsafe.Pointer(bw)).Fnb_bits = 0 // pad with zeroes
 	Flush(tls, bw)
 	return (*VP8BitWriter)(unsafe.Pointer(bw)).Fbuf
 }
 
 func VP8BitWriterAppend(tls *libc.TLS, bw uintptr, data uintptr, size size_t) (r int32) {
 	if (*VP8BitWriter)(unsafe.Pointer(bw)).Fnb_bits != -int32(8) {
 		return 0
 	} // Flush() must have been called
 	if !(BitWriterResize(tls, bw, size) != 0) {
 		return 0
 	}
 	libc.X__builtin___memcpy_chk(tls, (*VP8BitWriter)(unsafe.Pointer(bw)).Fbuf+uintptr((*VP8BitWriter)(unsafe.Pointer(bw)).Fpos), data, size, ^__predefined_size_t(0))
 	**(**size_t)(__ccgo_up(bw + 24)) += size
 	return int32(1)
 }
 
 func VP8BitWriterWipeOut(tls *libc.TLS, bw uintptr) {
 	if bw != libc.UintptrFromInt32(0) {
 		WebPSafeFree(tls, (*VP8BitWriter)(unsafe.Pointer(bw)).Fbuf)
 		libc.X__builtin___memset_chk(tls, bw, 0, uint64(48), ^__predefined_size_t(0))
 	}
 }
 
 //------------------------------------------------------------------------------
 // VP8LBitWriter
 
 // This is the minimum amount of size the memory buffer is guaranteed to grow
 // when extra space is needed.
 
 // C documentation
 //
 //	// Returns 1 on success.
 func VP8LBitWriterResize(tls *libc.TLS, bw uintptr, extra_size size_t) (r int32) {
 	var allocated_buf uintptr
 	var allocated_size, current_size, max_bytes, size_required size_t
 	var size_required_64b uint64_t
 	_, _, _, _, _, _ = allocated_buf, allocated_size, current_size, max_bytes, size_required, size_required_64b
 	max_bytes = libc.Uint64FromInt64(int64((*VP8LBitWriter)(unsafe.Pointer(bw)).Fend) - int64((*VP8LBitWriter)(unsafe.Pointer(bw)).Fbuf))
 	current_size = libc.Uint64FromInt64(int64((*VP8LBitWriter)(unsafe.Pointer(bw)).Fcur) - int64((*VP8LBitWriter)(unsafe.Pointer(bw)).Fbuf))
 	size_required_64b = current_size + extra_size
 	size_required = size_required_64b
 	if size_required != size_required_64b {
 		(*VP8LBitWriter)(unsafe.Pointer(bw)).Ferror1 = int32(1)
 		return 0
 	}
 	if max_bytes > uint64(0) && size_required <= max_bytes {
 		return int32(1)
 	}
 	allocated_size = uint64(3) * max_bytes >> int32(1)
 	if allocated_size < size_required {
 		allocated_size = size_required
 	}
 	// make allocated size multiple of 1k
 	allocated_size = (allocated_size>>libc.Int32FromInt32(10) + libc.Uint64FromInt32(1)) << libc.Int32FromInt32(10)
 	allocated_buf = WebPSafeMalloc(tls, uint64(1), allocated_size)
 	if allocated_buf == libc.UintptrFromInt32(0) {
 		(*VP8LBitWriter)(unsafe.Pointer(bw)).Ferror1 = int32(1)
 		return 0
 	}
 	if current_size > uint64(0) {
 		libc.X__builtin___memcpy_chk(tls, allocated_buf, (*VP8LBitWriter)(unsafe.Pointer(bw)).Fbuf, current_size, ^__predefined_size_t(0))
 	}
 	WebPSafeFree(tls, (*VP8LBitWriter)(unsafe.Pointer(bw)).Fbuf)
 	(*VP8LBitWriter)(unsafe.Pointer(bw)).Fbuf = allocated_buf
 	(*VP8LBitWriter)(unsafe.Pointer(bw)).Fcur = (*VP8LBitWriter)(unsafe.Pointer(bw)).Fbuf + uintptr(current_size)
 	(*VP8LBitWriter)(unsafe.Pointer(bw)).Fend = (*VP8LBitWriter)(unsafe.Pointer(bw)).Fbuf + uintptr(allocated_size)
 	return int32(1)
 }
 
 func VP8LBitWriterInit(tls *libc.TLS, bw uintptr, expected_size size_t) (r int32) {
 	libc.X__builtin___memset_chk(tls, bw, 0, uint64(48), ^__predefined_size_t(0))
 	return VP8LBitWriterResize(tls, bw, expected_size)
 }
 
 func VP8LBitWriterClone(tls *libc.TLS, src uintptr, dst uintptr) (r int32) {
 	var current_size size_t
 	_ = current_size
 	current_size = libc.Uint64FromInt64(int64((*VP8LBitWriter)(unsafe.Pointer(src)).Fcur) - int64((*VP8LBitWriter)(unsafe.Pointer(src)).Fbuf))
 	if !(VP8LBitWriterResize(tls, dst, current_size) != 0) {
 		return 0
 	}
 	libc.X__builtin___memcpy_chk(tls, (*VP8LBitWriter)(unsafe.Pointer(dst)).Fbuf, (*VP8LBitWriter)(unsafe.Pointer(src)).Fbuf, current_size, ^__predefined_size_t(0))
 	(*VP8LBitWriter)(unsafe.Pointer(dst)).Fbits = (*VP8LBitWriter)(unsafe.Pointer(src)).Fbits
 	(*VP8LBitWriter)(unsafe.Pointer(dst)).Fused = (*VP8LBitWriter)(unsafe.Pointer(src)).Fused
 	(*VP8LBitWriter)(unsafe.Pointer(dst)).Ferror1 = (*VP8LBitWriter)(unsafe.Pointer(src)).Ferror1
 	(*VP8LBitWriter)(unsafe.Pointer(dst)).Fcur = (*VP8LBitWriter)(unsafe.Pointer(dst)).Fbuf + uintptr(current_size)
 	return int32(1)
 }
 
 func VP8LBitWriterWipeOut(tls *libc.TLS, bw uintptr) {
 	if bw != libc.UintptrFromInt32(0) {
 		WebPSafeFree(tls, (*VP8LBitWriter)(unsafe.Pointer(bw)).Fbuf)
 		libc.X__builtin___memset_chk(tls, bw, 0, uint64(48), ^__predefined_size_t(0))
 	}
 }
 
 func VP8LBitWriterReset(tls *libc.TLS, bw_init uintptr, bw uintptr) {
 	(*VP8LBitWriter)(unsafe.Pointer(bw)).Fbits = (*VP8LBitWriter)(unsafe.Pointer(bw_init)).Fbits
 	(*VP8LBitWriter)(unsafe.Pointer(bw)).Fused = (*VP8LBitWriter)(unsafe.Pointer(bw_init)).Fused
 	(*VP8LBitWriter)(unsafe.Pointer(bw)).Fcur = (*VP8LBitWriter)(unsafe.Pointer(bw)).Fbuf + uintptr(int64((*VP8LBitWriter)(unsafe.Pointer(bw_init)).Fcur)-int64((*VP8LBitWriter)(unsafe.Pointer(bw_init)).Fbuf))
 	(*VP8LBitWriter)(unsafe.Pointer(bw)).Ferror1 = (*VP8LBitWriter)(unsafe.Pointer(bw_init)).Ferror1
 }
 
 func VP8LBitWriterSwap(tls *libc.TLS, src uintptr, dst uintptr) {
 	var tmp VP8LBitWriter
 	_ = tmp
 	tmp = **(**VP8LBitWriter)(__ccgo_up(src))
 	**(**VP8LBitWriter)(__ccgo_up(src)) = **(**VP8LBitWriter)(__ccgo_up(dst))
 	**(**VP8LBitWriter)(__ccgo_up(dst)) = tmp
 }
 
 func VP8LPutBitsFlushBits(tls *libc.TLS, bw uintptr) {
 	var extra_size, v1 uint64_t
 	var v2 int32
 	_, _, _ = extra_size, v1, v2
 	// If needed, make some room by flushing some bits out.
 	if (*VP8LBitWriter)(unsafe.Pointer(bw)).Fcur+uintptr(VP8L_WRITER_BYTES) > (*VP8LBitWriter)(unsafe.Pointer(bw)).Fend {
 		extra_size = libc.Uint64FromInt64(int64((*VP8LBitWriter)(unsafe.Pointer(bw)).Fend)-int64((*VP8LBitWriter)(unsafe.Pointer(bw)).Fbuf)) + uint64(32768)
 		v1 = extra_size
 		v2 = libc.BoolInt32(v1 == v1)
 		goto _3
 	_3:
 		;
 		if !(v2 != 0) || !(VP8LBitWriterResize(tls, bw, extra_size) != 0) {
 			(*VP8LBitWriter)(unsafe.Pointer(bw)).Fcur = (*VP8LBitWriter)(unsafe.Pointer(bw)).Fbuf
 			(*VP8LBitWriter)(unsafe.Pointer(bw)).Ferror1 = int32(1)
 			return
 		}
 	}
 	**(**vp8l_wtype_t)(__ccgo_up((*VP8LBitWriter)(unsafe.Pointer(bw)).Fcur)) = uint32((*VP8LBitWriter)(unsafe.Pointer(bw)).Fbits)
 	**(**uintptr)(__ccgo_up(bw + 24)) += uintptr(VP8L_WRITER_BYTES)
 	**(**vp8l_atype_t)(__ccgo_up(bw)) >>= uint64(VP8L_WRITER_BITS)
 	**(**int32)(__ccgo_up(bw + 8)) -= int32(VP8L_WRITER_BITS)
 }
 
 func VP8LPutBitsInternal(tls *libc.TLS, bw uintptr, bits uint32_t, n_bits int32) {
 	var extra_size, v1 uint64_t
 	var lbits vp8l_atype_t
 	var used, v2 int32
 	_, _, _, _, _ = extra_size, lbits, used, v1, v2
 	// That's the max we can handle:
 	if n_bits > 0 {
 		lbits = (*VP8LBitWriter)(unsafe.Pointer(bw)).Fbits
 		used = (*VP8LBitWriter)(unsafe.Pointer(bw)).Fused
 		// Special case of overflow handling for 32bit accumulator (2-steps flush).
 		// If needed, make some room by flushing some bits out.
 		for used >= int32(VP8L_WRITER_BITS) {
 			if (*VP8LBitWriter)(unsafe.Pointer(bw)).Fcur+uintptr(VP8L_WRITER_BYTES) > (*VP8LBitWriter)(unsafe.Pointer(bw)).Fend {
 				extra_size = libc.Uint64FromInt64(int64((*VP8LBitWriter)(unsafe.Pointer(bw)).Fend)-int64((*VP8LBitWriter)(unsafe.Pointer(bw)).Fbuf)) + uint64(32768)
 				v1 = extra_size
 				v2 = libc.BoolInt32(v1 == v1)
 				goto _3
 			_3:
 				;
 				if !(v2 != 0) || !(VP8LBitWriterResize(tls, bw, extra_size) != 0) {
 					(*VP8LBitWriter)(unsafe.Pointer(bw)).Fcur = (*VP8LBitWriter)(unsafe.Pointer(bw)).Fbuf
 					(*VP8LBitWriter)(unsafe.Pointer(bw)).Ferror1 = int32(1)
 					return
 				}
 			}
 			**(**vp8l_wtype_t)(__ccgo_up((*VP8LBitWriter)(unsafe.Pointer(bw)).Fcur)) = uint32(lbits)
 			**(**uintptr)(__ccgo_up(bw + 24)) += uintptr(VP8L_WRITER_BYTES)
 			lbits = lbits >> uint64(VP8L_WRITER_BITS)
 			used = used - int32(VP8L_WRITER_BITS)
 		}
 		(*VP8LBitWriter)(unsafe.Pointer(bw)).Fbits = lbits | uint64(bits)<<used
 		(*VP8LBitWriter)(unsafe.Pointer(bw)).Fused = used + n_bits
 	}
 }
 
 func VP8LBitWriterFinish(tls *libc.TLS, bw uintptr) (r uintptr) {
 	var v1, v2 uintptr
 	_, _ = v1, v2
 	// flush leftover bits
 	if VP8LBitWriterResize(tls, bw, libc.Uint64FromInt32(((*VP8LBitWriter)(unsafe.Pointer(bw)).Fused+int32(7))>>int32(3))) != 0 {
 		for (*VP8LBitWriter)(unsafe.Pointer(bw)).Fused > 0 {
 			v2 = bw + 24
 			v1 = *(*uintptr)(unsafe.Pointer(v2))
 			*(*uintptr)(unsafe.Pointer(v2)) = *(*uintptr)(unsafe.Pointer(v2)) + 1
 			**(**uint8_t)(__ccgo_up(v1)) = uint8((*VP8LBitWriter)(unsafe.Pointer(bw)).Fbits)
 			**(**vp8l_atype_t)(__ccgo_up(bw)) >>= uint64(8)
 			**(**int32)(__ccgo_up(bw + 8)) -= int32(8)
 		}
 		(*VP8LBitWriter)(unsafe.Pointer(bw)).Fused = 0
 	}
 	return (*VP8LBitWriter)(unsafe.Pointer(bw)).Fbuf
 }
 
 var kHashMul12 = uint32(0x1e35a7bd)
 
 //------------------------------------------------------------------------------
 
 //------------------------------------------------------------------------------
 // VP8LColorCache.
 
 func VP8LColorCacheInit(tls *libc.TLS, color_cache uintptr, hash_bits int32) (r int32) {
 	var hash_size int32
 	_ = hash_size
 	hash_size = int32(1) << hash_bits
 	(*VP8LColorCache)(unsafe.Pointer(color_cache)).Fcolors = WebPSafeCalloc(tls, libc.Uint64FromInt32(hash_size), uint64(4))
 	if (*VP8LColorCache)(unsafe.Pointer(color_cache)).Fcolors == libc.UintptrFromInt32(0) {
 		return 0
 	}
 	(*VP8LColorCache)(unsafe.Pointer(color_cache)).Fhash_shift = int32(32) - hash_bits
 	(*VP8LColorCache)(unsafe.Pointer(color_cache)).Fhash_bits = hash_bits
 	return int32(1)
 }
 
 func VP8LColorCacheClear(tls *libc.TLS, color_cache uintptr) {
 	if color_cache != libc.UintptrFromInt32(0) {
 		WebPSafeFree(tls, (*VP8LColorCache)(unsafe.Pointer(color_cache)).Fcolors)
 		(*VP8LColorCache)(unsafe.Pointer(color_cache)).Fcolors = libc.UintptrFromInt32(0)
 	}
 }
 
 func VP8LColorCacheCopy(tls *libc.TLS, src uintptr, dst uintptr) {
 	libc.X__builtin___memcpy_chk(tls, (*VP8LColorCache)(unsafe.Pointer(dst)).Fcolors, (*VP8LColorCache)(unsafe.Pointer(src)).Fcolors, libc.Uint64FromUint32(1)<<(*VP8LColorCache)(unsafe.Pointer(dst)).Fhash_bits*uint64(4), ^__predefined_size_t(0))
 }
 
 // -----------------------------------------------------------------------------
 // Quick estimate of a potentially interesting filter mode to try.
 
 func GradientPredictor(tls *libc.TLS, a uint8_t, b uint8_t, c uint8_t) (r int32) {
 	var g, v1, v2 int32
 	_, _, _ = g, v1, v2
 	g = libc.Int32FromUint8(a) + libc.Int32FromUint8(b) - libc.Int32FromUint8(c)
 	if g & ^libc.Int32FromInt32(0xff) == 0 {
 		v1 = g
 	} else {
 		if g < 0 {
 			v2 = 0
 		} else {
 			v2 = int32(255)
 		}
 		v1 = v2
 	}
 	return v1 // clip to 8bit
 }
 
 func WebPEstimateBestFilter(tls *libc.TLS, data uintptr, width int32, height int32, stride int32) (r WEBP_FILTER_TYPE) {
 	bp := tls.Alloc(256)
 	defer tls.Free(256)
 	var best_filter WEBP_FILTER_TYPE
 	var best_score, diff0, diff1, diff2, diff3, filter, grad_pred, i, j, mean, score int32
 	var p uintptr
 	var _ /* bins at bp+0 */ [4][16]int32
 	_, _, _, _, _, _, _, _, _, _, _, _, _ = best_filter, best_score, diff0, diff1, diff2, diff3, filter, grad_pred, i, j, mean, p, score
 	libc.X__builtin___memset_chk(tls, bp, 0, uint64(256), ^__predefined_size_t(0))
 	// We only sample every other pixels. That's enough.
 	j = int32(2)
 	for {
 		if !(j < height-int32(1)) {
 			break
 		}
 		p = data + uintptr(j*stride)
 		mean = libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(p)))
 		i = int32(2)
 		for {
 			if !(i < width-int32(1)) {
 				break
 			}
 			diff0 = libc.Xabs(tls, libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(p + uintptr(i))))-mean) >> libc.Int32FromInt32(4)
 			diff1 = libc.Xabs(tls, libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(p + uintptr(i))))-libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(p + uintptr(i-int32(1)))))) >> libc.Int32FromInt32(4)
 			diff2 = libc.Xabs(tls, libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(p + uintptr(i))))-libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(p + uintptr(i-width))))) >> libc.Int32FromInt32(4)
 			grad_pred = GradientPredictor(tls, **(**uint8_t)(__ccgo_up(p + uintptr(i-int32(1)))), **(**uint8_t)(__ccgo_up(p + uintptr(i-width))), **(**uint8_t)(__ccgo_up(p + uintptr(i-width-int32(1)))))
 			diff3 = libc.Xabs(tls, libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(p + uintptr(i))))-grad_pred) >> libc.Int32FromInt32(4)
 			**(**int32)(__ccgo_up(bp + uintptr(WEBP_FILTER_NONE)*64 + uintptr(diff0)*4)) = int32(1)
 			**(**int32)(__ccgo_up(bp + uintptr(WEBP_FILTER_HORIZONTAL)*64 + uintptr(diff1)*4)) = int32(1)
 			**(**int32)(__ccgo_up(bp + uintptr(WEBP_FILTER_VERTICAL)*64 + uintptr(diff2)*4)) = int32(1)
 			**(**int32)(__ccgo_up(bp + uintptr(WEBP_FILTER_GRADIENT)*64 + uintptr(diff3)*4)) = int32(1)
 			mean = (int32(3)*mean + libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(p + uintptr(i)))) + int32(2)) >> int32(2)
 			goto _2
 		_2:
 			;
 			i = i + int32(2)
 		}
 		goto _1
 	_1:
 		;
 		j = j + int32(2)
 	}
 	best_filter = int32(WEBP_FILTER_NONE)
 	best_score = int32(0x7fffffff)
 	filter = int32(WEBP_FILTER_NONE)
 	for {
 		if !(filter < int32(WEBP_FILTER_LAST)) {
 			break
 		}
 		score = 0
 		i = 0
 		for {
 			if !(i < int32(16)) {
 				break
 			}
 			if **(**int32)(__ccgo_up(bp + uintptr(filter)*64 + uintptr(i)*4)) > 0 {
 				score = score + i
 			}
 			goto _4
 		_4:
 			;
 			i = i + 1
 		}
 		if score < best_score {
 			best_score = score
 			best_filter = filter
 		}
 		goto _3
 	_3:
 		;
 		filter = filter + 1
 	}
 	return best_filter
 	return r
 }
 
 // Alpha related constants.
 
 // Mux related constants.
 
 // Maximum chunk payload is such that adding the header and padding won't
 // overflow a uint32_t.
 
 // -----------------------------------------------------------------------------
 // Util function to optimize the symbol map for RLE coding
 
 // C documentation
 //
 //	// Heuristics for selecting the stride ranges to collapse.
 func ValuesShouldBeCollapsedToStrideAverage(tls *libc.TLS, a int32, b int32) (r int32) {
 	return libc.BoolInt32(libc.Xabs(tls, a-b) < int32(4))
 }
 
 // C documentation
 //
 //	// Change the population counts in a way that the consequent
 //	// Huffman tree compression, especially its RLE-part, give smaller output.
 func OptimizeHuffmanForRle(tls *libc.TLS, length int32, good_for_rle uintptr, counts uintptr) {
 	var count, k1, limit, stride1, sum, symbol uint32_t
 	var i, k, stride int32
 	_, _, _, _, _, _, _, _, _ = count, i, k, k1, limit, stride, stride1, sum, symbol
 	for {
 		if !(length >= 0) {
 			break
 		}
 		if length == 0 {
 			return // All zeros.
 		}
 		if **(**uint32_t)(__ccgo_up(counts + uintptr(length-int32(1))*4)) != uint32(0) {
 			// Now counts[0..length - 1] does not have trailing zeros.
 			break
 		}
 		goto _1
 	_1:
 		;
 		length = length - 1
 	}
 	// 2) Let's mark all population counts that already can be encoded
 	// with an rle code.
 	// Let's not spoil any of the existing good rle codes.
 	// Mark any seq of 0's that is longer as 5 as a good_for_rle.
 	// Mark any seq of non-0's that is longer as 7 as a good_for_rle.
 	symbol = **(**uint32_t)(__ccgo_up(counts))
 	stride = 0
 	i = 0
 	for {
 		if !(i < length+int32(1)) {
 			break
 		}
 		if i == length || **(**uint32_t)(__ccgo_up(counts + uintptr(i)*4)) != symbol {
 			if symbol == uint32(0) && stride >= int32(5) || symbol != uint32(0) && stride >= int32(7) {
 				k = 0
 				for {
 					if !(k < stride) {
 						break
 					}
 					**(**uint8_t)(__ccgo_up(good_for_rle + uintptr(i-k-int32(1)))) = uint8(1)
 					goto _3
 				_3:
 					;
 					k = k + 1
 				}
 			}
 			stride = int32(1)
 			if i != length {
 				symbol = **(**uint32_t)(__ccgo_up(counts + uintptr(i)*4))
 			}
 		} else {
 			stride = stride + 1
 		}
 		goto _2
 	_2:
 		;
 		i = i + 1
 	}
 	// 3) Let's replace those population counts that lead to more rle codes.
 	stride1 = uint32(0)
 	limit = **(**uint32_t)(__ccgo_up(counts))
 	sum = uint32(0)
 	i = 0
 	for {
 		if !(i < length+int32(1)) {
 			break
 		}
 		if i == length || **(**uint8_t)(__ccgo_up(good_for_rle + uintptr(i))) != 0 || i != 0 && **(**uint8_t)(__ccgo_up(good_for_rle + uintptr(i-int32(1)))) != 0 || !(ValuesShouldBeCollapsedToStrideAverage(tls, libc.Int32FromUint32(**(**uint32_t)(__ccgo_up(counts + uintptr(i)*4))), libc.Int32FromUint32(limit)) != 0) {
 			if stride1 >= uint32(4) || stride1 >= uint32(3) && sum == uint32(0) {
 				// The stride must end, collapse what we have, if we have enough (4).
 				count = (sum + stride1/uint32(2)) / stride1
 				if count < uint32(1) {
 					count = uint32(1)
 				}
 				if sum == uint32(0) {
 					// Don't make an all zeros stride to be upgraded to ones.
 					count = uint32(0)
 				}
 				k1 = uint32(0)
 				for {
 					if !(k1 < stride1) {
 						break
 					}
 					// We don't want to change value at counts[i],
 					// that is already belonging to the next stride. Thus - 1.
 					**(**uint32_t)(__ccgo_up(counts + uintptr(libc.Uint32FromInt32(i)-k1-uint32(1))*4)) = count
 					goto _5
 				_5:
 					;
 					k1 = k1 + 1
 				}
 			}
 			stride1 = uint32(0)
 			sum = uint32(0)
 			if i < length-int32(3) {
 				// All interesting strides have a count of at least 4,
 				// at least when non-zeros.
 				limit = (**(**uint32_t)(__ccgo_up(counts + uintptr(i)*4)) + **(**uint32_t)(__ccgo_up(counts + uintptr(i+int32(1))*4)) + **(**uint32_t)(__ccgo_up(counts + uintptr(i+int32(2))*4)) + **(**uint32_t)(__ccgo_up(counts + uintptr(i+int32(3))*4)) + uint32(2)) / uint32(4)
 			} else {
 				if i < length {
 					limit = **(**uint32_t)(__ccgo_up(counts + uintptr(i)*4))
 				} else {
 					limit = uint32(0)
 				}
 			}
 		}
 		stride1 = stride1 + 1
 		if i != length {
 			sum = sum + **(**uint32_t)(__ccgo_up(counts + uintptr(i)*4))
 			if stride1 >= uint32(4) {
 				limit = (sum + stride1/uint32(2)) / stride1
 			}
 		}
 		goto _4
 	_4:
 		;
 		i = i + 1
 	}
 }
 
 // C documentation
 //
 //	// A comparer function for two Huffman trees: sorts first by 'total count'
 //	// (more comes first), and then by 'value' (more comes first).
 func CompareHuffmanTrees(tls *libc.TLS, ptr1 uintptr, ptr2 uintptr) (r int32) {
 	var t1, t2 uintptr
 	var v1 int32
 	_, _, _ = t1, t2, v1
 	t1 = ptr1
 	t2 = ptr2
 	if (*HuffmanTree)(unsafe.Pointer(t1)).Ftotal_count > (*HuffmanTree)(unsafe.Pointer(t2)).Ftotal_count {
 		return -int32(1)
 	} else {
 		if (*HuffmanTree)(unsafe.Pointer(t1)).Ftotal_count < (*HuffmanTree)(unsafe.Pointer(t2)).Ftotal_count {
 			return int32(1)
 		} else {
 			if (*HuffmanTree)(unsafe.Pointer(t1)).Fvalue < (*HuffmanTree)(unsafe.Pointer(t2)).Fvalue {
 				v1 = -int32(1)
 			} else {
 				v1 = int32(1)
 			}
 			return v1
 		}
 	}
 	return r
 }
 
 func SetBitDepths(tls *libc.TLS, tree uintptr, pool uintptr, bit_depths uintptr, level int32) {
 	if (*HuffmanTree)(unsafe.Pointer(tree)).Fpool_index_left >= 0 {
 		SetBitDepths(tls, pool+uintptr((*HuffmanTree)(unsafe.Pointer(tree)).Fpool_index_left)*16, pool, bit_depths, level+int32(1))
 		SetBitDepths(tls, pool+uintptr((*HuffmanTree)(unsafe.Pointer(tree)).Fpool_index_right)*16, pool, bit_depths, level+int32(1))
 	} else {
 		**(**uint8_t)(__ccgo_up(bit_depths + uintptr((*HuffmanTree)(unsafe.Pointer(tree)).Fvalue))) = libc.Uint8FromInt32(level)
 	}
 }
 
 // C documentation
 //
 //	// Create an optimal Huffman tree.
 //	//
 //	// (data,length): population counts.
 //	// tree_limit: maximum bit depth (inclusive) of the codes.
 //	// bit_depths[]: how many bits are used for the symbol.
 //	//
 //	// Returns 0 when an error has occurred.
 //	//
 //	// The catch here is that the tree cannot be arbitrarily deep
 //	//
 //	// count_limit is the value that is to be faked as the minimum value
 //	// and this minimum value is raised until the tree matches the
 //	// maximum length requirement.
 //	//
 //	// This algorithm is not of excellent performance for very long data blocks,
 //	// especially when population counts are longer than 2**tree_limit, but
 //	// we are not planning to use this with extremely long blocks.
 //	//
 //	// See https://en.wikipedia.org/wiki/Huffman_coding
 func GenerateOptimalTree(tls *libc.TLS, histogram uintptr, histogram_size int32, tree uintptr, tree_depth_limit int32, bit_depths uintptr) {
 	var count, count1, count_min uint32_t
 	var i, idx, j, k, max_depth, tree_pool_size, tree_size, tree_size_orig, v5 int32
 	var tree_pool uintptr
 	var v4 uint32
 	_, _, _, _, _, _, _, _, _, _, _, _, _, _ = count, count1, count_min, i, idx, j, k, max_depth, tree_pool, tree_pool_size, tree_size, tree_size_orig, v4, v5
 	tree_size_orig = 0
 	i = 0
 	for {
 		if !(i < histogram_size) {
 			break
 		}
 		if **(**uint32_t)(__ccgo_up(histogram + uintptr(i)*4)) != uint32(0) {
 			tree_size_orig = tree_size_orig + 1
 		}
 		goto _1
 	_1:
 		;
 		i = i + 1
 	}
 	if tree_size_orig == 0 { // pretty optimal already!
 		return
 	}
 	tree_pool = tree + uintptr(tree_size_orig)*16
 	// For block sizes with less than 64k symbols we never need to do a
 	// second iteration of this loop.
 	// If we actually start running inside this loop a lot, we would perhaps
 	// be better off with the Katajainen algorithm.
 	count_min = uint32(1)
 	for {
 		tree_size = tree_size_orig
 		// We need to pack the Huffman tree in tree_depth_limit bits.
 		// So, we try by faking histogram entries to be at least 'count_min'.
 		idx = 0
 		j = 0
 		for {
 			if !(j < histogram_size) {
 				break
 			}
 			if **(**uint32_t)(__ccgo_up(histogram + uintptr(j)*4)) != uint32(0) {
 				if **(**uint32_t)(__ccgo_up(histogram + uintptr(j)*4)) < count_min {
 					v4 = count_min
 				} else {
 					v4 = **(**uint32_t)(__ccgo_up(histogram + uintptr(j)*4))
 				}
 				count = v4
 				(**(**HuffmanTree)(__ccgo_up(tree + uintptr(idx)*16))).Ftotal_count = count
 				(**(**HuffmanTree)(__ccgo_up(tree + uintptr(idx)*16))).Fvalue = j
 				(**(**HuffmanTree)(__ccgo_up(tree + uintptr(idx)*16))).Fpool_index_left = -int32(1)
 				(**(**HuffmanTree)(__ccgo_up(tree + uintptr(idx)*16))).Fpool_index_right = -int32(1)
 				idx = idx + 1
 			}
 			goto _3
 		_3:
 			;
 			j = j + 1
 		}
 		// Build the Huffman tree.
 		libc.Xqsort(tls, tree, libc.Uint64FromInt32(tree_size), uint64(16), __ccgo_fp(CompareHuffmanTrees))
 		if tree_size > int32(1) { // Normal case.
 			tree_pool_size = 0
 			for tree_size > int32(1) {
 				v5 = tree_pool_size
 				tree_pool_size = tree_pool_size + 1
 				**(**HuffmanTree)(__ccgo_up(tree_pool + uintptr(v5)*16)) = **(**HuffmanTree)(__ccgo_up(tree + uintptr(tree_size-int32(1))*16))
 				v5 = tree_pool_size
 				tree_pool_size = tree_pool_size + 1
 				**(**HuffmanTree)(__ccgo_up(tree_pool + uintptr(v5)*16)) = **(**HuffmanTree)(__ccgo_up(tree + uintptr(tree_size-int32(2))*16))
 				count1 = (**(**HuffmanTree)(__ccgo_up(tree_pool + uintptr(tree_pool_size-int32(1))*16))).Ftotal_count + (**(**HuffmanTree)(__ccgo_up(tree_pool + uintptr(tree_pool_size-int32(2))*16))).Ftotal_count
 				tree_size = tree_size - int32(2)
 				k = 0
 				for {
 					if !(k < tree_size) {
 						break
 					}
 					if (**(**HuffmanTree)(__ccgo_up(tree + uintptr(k)*16))).Ftotal_count <= count1 {
 						break
 					}
 					goto _7
 				_7:
 					;
 					k = k + 1
 				}
 				libc.X__builtin___memmove_chk(tls, tree+uintptr(k+libc.Int32FromInt32(1))*16, tree+uintptr(k)*16, libc.Uint64FromInt32(tree_size-k)*uint64(16), ^__predefined_size_t(0))
 				(**(**HuffmanTree)(__ccgo_up(tree + uintptr(k)*16))).Ftotal_count = count1
 				(**(**HuffmanTree)(__ccgo_up(tree + uintptr(k)*16))).Fvalue = -int32(1)
 				(**(**HuffmanTree)(__ccgo_up(tree + uintptr(k)*16))).Fpool_index_left = tree_pool_size - int32(1)
 				(**(**HuffmanTree)(__ccgo_up(tree + uintptr(k)*16))).Fpool_index_right = tree_pool_size - int32(2)
 				tree_size = tree_size + int32(1)
 			}
 			SetBitDepths(tls, tree, tree_pool, bit_depths, 0)
 		} else {
 			if tree_size == int32(1) { // Trivial case: only one element.
 				**(**uint8_t)(__ccgo_up(bit_depths + uintptr((**(**HuffmanTree)(__ccgo_up(tree))).Fvalue))) = uint8(1)
 			}
 		}
 		// Test if this Huffman tree satisfies our 'tree_depth_limit' criteria.
 		max_depth = libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(bit_depths)))
 		j = int32(1)
 		for {
 			if !(j < histogram_size) {
 				break
 			}
 			if max_depth < libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(bit_depths + uintptr(j)))) {
 				max_depth = libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(bit_depths + uintptr(j))))
 			}
 			goto _8
 		_8:
 			;
 			j = j + 1
 		}
 		if max_depth <= tree_depth_limit {
 			break
 		}
 		goto _2
 	_2:
 		;
 		count_min = count_min * uint32(2)
 	}
 }
 
 // -----------------------------------------------------------------------------
 // Coding of the Huffman tree values
 
 func CodeRepeatedValues(tls *libc.TLS, repetitions int32, tokens uintptr, value int32, prev_value int32) (r uintptr) {
 	var i int32
 	_ = i
 	if value != prev_value {
 		(*HuffmanTreeToken)(unsafe.Pointer(tokens)).Fcode = libc.Uint8FromInt32(value)
 		(*HuffmanTreeToken)(unsafe.Pointer(tokens)).Fextra_bits = uint8(0)
 		tokens += 2
 		repetitions = repetitions - 1
 	}
 	for repetitions >= int32(1) {
 		if repetitions < int32(3) {
 			i = 0
 			for {
 				if !(i < repetitions) {
 					break
 				}
 				(*HuffmanTreeToken)(unsafe.Pointer(tokens)).Fcode = libc.Uint8FromInt32(value)
 				(*HuffmanTreeToken)(unsafe.Pointer(tokens)).Fextra_bits = uint8(0)
 				tokens += 2
 				goto _1
 			_1:
 				;
 				i = i + 1
 			}
 			break
 		} else {
 			if repetitions < int32(7) {
 				(*HuffmanTreeToken)(unsafe.Pointer(tokens)).Fcode = uint8(16)
 				(*HuffmanTreeToken)(unsafe.Pointer(tokens)).Fextra_bits = libc.Uint8FromInt32(repetitions - int32(3))
 				tokens += 2
 				break
 			} else {
 				(*HuffmanTreeToken)(unsafe.Pointer(tokens)).Fcode = uint8(16)
 				(*HuffmanTreeToken)(unsafe.Pointer(tokens)).Fextra_bits = uint8(3)
 				tokens += 2
 				repetitions = repetitions - int32(6)
 			}
 		}
 	}
 	return tokens
 }
 
 func CodeRepeatedZeros(tls *libc.TLS, repetitions int32, tokens uintptr) (r uintptr) {
 	var i int32
 	_ = i
 	for repetitions >= int32(1) {
 		if repetitions < int32(3) {
 			i = 0
 			for {
 				if !(i < repetitions) {
 					break
 				}
 				(*HuffmanTreeToken)(unsafe.Pointer(tokens)).Fcode = uint8(0) // 0-value
 				(*HuffmanTreeToken)(unsafe.Pointer(tokens)).Fextra_bits = uint8(0)
 				tokens += 2
 				goto _1
 			_1:
 				;
 				i = i + 1
 			}
 			break
 		} else {
 			if repetitions < int32(11) {
 				(*HuffmanTreeToken)(unsafe.Pointer(tokens)).Fcode = uint8(17)
 				(*HuffmanTreeToken)(unsafe.Pointer(tokens)).Fextra_bits = libc.Uint8FromInt32(repetitions - int32(3))
 				tokens += 2
 				break
 			} else {
 				if repetitions < int32(139) {
 					(*HuffmanTreeToken)(unsafe.Pointer(tokens)).Fcode = uint8(18)
 					(*HuffmanTreeToken)(unsafe.Pointer(tokens)).Fextra_bits = libc.Uint8FromInt32(repetitions - int32(11))
 					tokens += 2
 					break
 				} else {
 					(*HuffmanTreeToken)(unsafe.Pointer(tokens)).Fcode = uint8(18)
 					(*HuffmanTreeToken)(unsafe.Pointer(tokens)).Fextra_bits = uint8(0x7f) // 138 repeated 0s
 					tokens += 2
 					repetitions = repetitions - int32(138)
 				}
 			}
 		}
 	}
 	return tokens
 }
 
 func VP8LCreateCompressedHuffmanTree(tls *libc.TLS, tree uintptr, tokens uintptr, max_tokens int32) (r int32) {
 	var depth_size, i, k, prev_value, runs, value int32
 	var ending_token, starting_token uintptr
 	_, _, _, _, _, _, _, _ = depth_size, ending_token, i, k, prev_value, runs, starting_token, value
 	starting_token = tokens
 	ending_token = tokens + uintptr(max_tokens)*2
 	depth_size = (*HuffmanTreeCode)(unsafe.Pointer(tree)).Fnum_symbols
 	prev_value = int32(8) // 8 is the initial value for rle.
 	i = 0
 	for i < depth_size {
 		value = libc.Int32FromUint8(**(**uint8_t)(__ccgo_up((*HuffmanTreeCode)(unsafe.Pointer(tree)).Fcode_lengths + uintptr(i))))
 		k = i + int32(1)
 		for k < depth_size && libc.Int32FromUint8(**(**uint8_t)(__ccgo_up((*HuffmanTreeCode)(unsafe.Pointer(tree)).Fcode_lengths + uintptr(k)))) == value {
 			k = k + 1
 		}
 		runs = k - i
 		if value == 0 {
 			tokens = CodeRepeatedZeros(tls, runs, tokens)
 		} else {
 			tokens = CodeRepeatedValues(tls, runs, tokens, value, prev_value)
 			prev_value = value
 		}
 		i = i + runs
 	}
 	_ = ending_token // suppress 'unused variable' warning
 	return int32((int64(tokens) - int64(starting_token)) / 2)
 }
 
 // -----------------------------------------------------------------------------
 
 // C documentation
 //
 //	// Pre-reversed 4-bit values.
 var kReversedBits = [16]uint8_t{
 	1:  uint8(0x8),
 	2:  uint8(0x4),
 	3:  uint8(0xc),
 	4:  uint8(0x2),
 	5:  uint8(0xa),
 	6:  uint8(0x6),
 	7:  uint8(0xe),
 	8:  uint8(0x1),
 	9:  uint8(0x9),
 	10: uint8(0x5),
 	11: uint8(0xd),
 	12: uint8(0x3),
 	13: uint8(0xb),
 	14: uint8(0x7),
 	15: uint8(0xf),
 }
 
 func ReverseBits(tls *libc.TLS, num_bits int32, bits uint32_t) (r uint32_t) {
 	var i int32
 	var retval uint32_t
 	_, _ = i, retval
 	retval = uint32(0)
 	i = 0
 	for i < num_bits {
 		i = i + int32(4)
 		retval = retval | libc.Uint32FromInt32(libc.Int32FromUint8(kReversedBits[bits&uint32(0xf)])<<(libc.Int32FromInt32(MAX_ALLOWED_CODE_LENGTH)+libc.Int32FromInt32(1)-i))
 		bits = bits >> uint32(4)
 	}
 	retval = retval >> libc.Uint32FromInt32(libc.Int32FromInt32(MAX_ALLOWED_CODE_LENGTH)+libc.Int32FromInt32(1)-num_bits)
 	return retval
 }
 
 // C documentation
 //
 //	// Get the actual bit values for a tree of bit depths.
 func ConvertBitDepthsToSymbols(tls *libc.TLS, tree uintptr) {
 	bp := tls.Alloc(64)
 	defer tls.Free(64)
 	var code, v4 uint32_t
 	var code_length, code_length1, i, len1 int32
 	var depth_count [16]int32
 	var v5 uintptr
 	var _ /* next_code at bp+0 */ [16]uint32_t
 	_, _, _, _, _, _, _, _ = code, code_length, code_length1, depth_count, i, len1, v4, v5
 	depth_count = [16]int32{}
 	len1 = (*HuffmanTreeCode)(unsafe.Pointer(tree)).Fnum_symbols
 	i = 0
 	for {
 		if !(i < len1) {
 			break
 		}
 		code_length = libc.Int32FromUint8(**(**uint8_t)(__ccgo_up((*HuffmanTreeCode)(unsafe.Pointer(tree)).Fcode_lengths + uintptr(i))))
 		depth_count[code_length] = depth_count[code_length] + 1
 		goto _1
 	_1:
 		;
 		i = i + 1
 	}
 	depth_count[0] = 0 // ignore unused symbol
 	(**(**[16]uint32_t)(__ccgo_up(bp)))[0] = uint32(0)
 	code = uint32(0)
 	i = int32(1)
 	for {
 		if !(i <= int32(MAX_ALLOWED_CODE_LENGTH)) {
 			break
 		}
 		code = (code + libc.Uint32FromInt32(depth_count[i-int32(1)])) << int32(1)
 		(**(**[16]uint32_t)(__ccgo_up(bp)))[i] = code
 		goto _2
 	_2:
 		;
 		i = i + 1
 	}
 	i = 0
 	for {
 		if !(i < len1) {
 			break
 		}
 		code_length1 = libc.Int32FromUint8(**(**uint8_t)(__ccgo_up((*HuffmanTreeCode)(unsafe.Pointer(tree)).Fcode_lengths + uintptr(i))))
 		v5 = bp + uintptr(code_length1)*4
 		v4 = *(*uint32_t)(unsafe.Pointer(v5))
 		*(*uint32_t)(unsafe.Pointer(v5)) = *(*uint32_t)(unsafe.Pointer(v5)) + 1
 		**(**uint16_t)(__ccgo_up((*HuffmanTreeCode)(unsafe.Pointer(tree)).Fcodes + uintptr(i)*2)) = uint16(ReverseBits(tls, code_length1, v4))
 		goto _3
 	_3:
 		;
 		i = i + 1
 	}
 }
 
 // -----------------------------------------------------------------------------
 // Main entry point
 
 func VP8LCreateHuffmanTree(tls *libc.TLS, histogram uintptr, tree_depth_limit int32, buf_rle uintptr, huff_tree uintptr, huff_code uintptr) {
 	var num_symbols int32
 	_ = num_symbols
 	num_symbols = (*HuffmanTreeCode)(unsafe.Pointer(huff_code)).Fnum_symbols
 	libc.X__builtin___memset_chk(tls, buf_rle, 0, libc.Uint64FromInt32(num_symbols)*uint64(1), ^__predefined_size_t(0))
 	OptimizeHuffmanForRle(tls, num_symbols, buf_rle, histogram)
 	GenerateOptimalTree(tls, histogram, num_symbols, huff_tree, tree_depth_limit, (*HuffmanTreeCode)(unsafe.Pointer(huff_code)).Fcode_lengths)
 	// Create the actual bit codes for the bit lengths.
 	ConvertBitDepthsToSymbols(tls, huff_code)
 }
 
 const MAX_HTREE_GROUPS = 0x10000
 const SORTED_SIZE_CUTOFF = 512
 
 //------------------------------------------------------------------------------
 
 // Copyright 2012 Google Inc. All Rights Reserved.
 //
 // Use of this source code is governed by a BSD-style license
 // that can be found in the COPYING file in the root of the source
 // tree. An additional intellectual property rights grant can be found
 // in the file PATENTS. All contributing project authors may
 // be found in the AUTHORS file in the root of the source tree.
 // -----------------------------------------------------------------------------
 //
 //  Internal header for constants related to WebP file format.
 //
 // Author: Urvang (urvang@google.com)
 
 // Copyright 2010 Google Inc. All Rights Reserved.
 //
 // Use of this source code is governed by a BSD-style license
 // that can be found in the COPYING file in the root of the source
 // tree. An additional intellectual property rights grant can be found
 // in the file PATENTS. All contributing project authors may
 // be found in the AUTHORS file in the root of the source tree.
 // -----------------------------------------------------------------------------
 //
 //  Common types + memory wrappers
 //
 // Author: Skal (pascal.massimino@gmail.com)
 
 // Huffman data read via DecodeImageStream is represented in two (red and green)
 // bytes.
 
 func VP8LHtreeGroupsNew(tls *libc.TLS, num_htree_groups int32) (r uintptr) {
 	var htree_groups uintptr
 	_ = htree_groups
 	htree_groups = WebPSafeMalloc(tls, libc.Uint64FromInt32(num_htree_groups), uint64(568))
 	if htree_groups == libc.UintptrFromInt32(0) {
 		return libc.UintptrFromInt32(0)
 	}
 	return htree_groups
 }
 
 func VP8LHtreeGroupsFree(tls *libc.TLS, htree_groups uintptr) {
 	if htree_groups != libc.UintptrFromInt32(0) {
 		WebPSafeFree(tls, htree_groups)
 	}
 }
 
 // C documentation
 //
 //	// Returns reverse(reverse(key, len) + 1, len), where reverse(key, len) is the
 //	// bit-wise reversal of the len least significant bits of key.
 func GetNextKey(tls *libc.TLS, key uint32_t, len1 int32) (r uint32_t) {
 	var step uint32_t
 	var v1 uint32
 	_, _ = step, v1
 	step = libc.Uint32FromInt32(int32(1) << (len1 - int32(1)))
 	for key&step != 0 {
 		step = step >> uint32(1)
 	}
 	if step != 0 {
 		v1 = key&(step-uint32(1)) + step
 	} else {
 		v1 = key
 	}
 	return v1
 }
 
 // C documentation
 //
 //	// Stores code in table[0], table[step], table[2*step], ..., table[end].
 //	// Assumes that end is an integer multiple of step.
 func ReplicateValue(tls *libc.TLS, table uintptr, step int32, end int32, code HuffmanCode) {
 	for cond := true; cond; cond = end > 0 {
 		end = end - step
 		**(**HuffmanCode)(__ccgo_up(table + uintptr(end)*4)) = code
 	}
 }
 
 // C documentation
 //
 //	// Returns the table width of the next 2nd level table. count is the histogram
 //	// of bit lengths for the remaining symbols, len is the code length of the next
 //	// processed symbol
 func NextTableBitSize(tls *libc.TLS, count uintptr, len1 int32, root_bits int32) (r int32) {
 	var left int32
 	_ = left
 	left = int32(1) << (len1 - root_bits)
 	for len1 < int32(MAX_ALLOWED_CODE_LENGTH) {
 		left = left - **(**int32)(__ccgo_up(count + uintptr(len1)*4))
 		if left <= 0 {
 			break
 		}
 		len1 = len1 + 1
 		left = left << int32(1)
 	}
 	return len1 - root_bits
 }
 
 // C documentation
 //
 //	// sorted[code_lengths_size] is a pre-allocated array for sorting symbols
 //	// by code length.
 func BuildHuffmanTable(tls *libc.TLS, root_table uintptr, root_bits int32, code_lengths uintptr, code_lengths_size int32, sorted uintptr) (r int32) {
 	bp := tls.Alloc(128)
 	defer tls.Free(128)
 	var code, code1, code2 HuffmanCode
 	var key, low, mask uint32_t
 	var len1, num_nodes, num_open, step, symbol, symbol_code_length, table_bits, table_size, total_size, v4 int32
 	var table, v5 uintptr
 	var _ /* count at bp+0 */ [16]int32
 	var _ /* offset at bp+64 */ [16]int32
 	_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = code, code1, code2, key, len1, low, mask, num_nodes, num_open, step, symbol, symbol_code_length, table, table_bits, table_size, total_size, v4, v5
 	table = root_table                 // next available space in table
 	total_size = int32(1) << root_bits // symbol index in original or sorted table
 	// number of codes of each length:
 	**(**[16]int32)(__ccgo_up(bp)) = [16]int32{}
 	// Build histogram of code lengths.
 	symbol = 0
 	for {
 		if !(symbol < code_lengths_size) {
 			break
 		}
 		if **(**int32)(__ccgo_up(code_lengths + uintptr(symbol)*4)) > int32(MAX_ALLOWED_CODE_LENGTH) {
 			return 0
 		}
 		(**(**[16]int32)(__ccgo_up(bp)))[**(**int32)(__ccgo_up(code_lengths + uintptr(symbol)*4))] = (**(**[16]int32)(__ccgo_up(bp)))[**(**int32)(__ccgo_up(code_lengths + uintptr(symbol)*4))] + 1
 		goto _1
 	_1:
 		;
 		symbol = symbol + 1
 	}
 	// Error, all code lengths are zeros.
 	if (**(**[16]int32)(__ccgo_up(bp)))[0] == code_lengths_size {
 		return 0
 	}
 	// Generate offsets into sorted symbol table by code length.
 	(**(**[16]int32)(__ccgo_up(bp + 64)))[int32(1)] = 0
 	len1 = int32(1)
 	for {
 		if !(len1 < int32(MAX_ALLOWED_CODE_LENGTH)) {
 			break
 		}
 		if (**(**[16]int32)(__ccgo_up(bp)))[len1] > int32(1)<<len1 {
 			return 0
 		}
 		(**(**[16]int32)(__ccgo_up(bp + 64)))[len1+int32(1)] = (**(**[16]int32)(__ccgo_up(bp + 64)))[len1] + (**(**[16]int32)(__ccgo_up(bp)))[len1]
 		goto _2
 	_2:
 		;
 		len1 = len1 + 1
 	}
 	// Sort symbols by length, by symbol order within each length.
 	symbol = 0
 	for {
 		if !(symbol < code_lengths_size) {
 			break
 		}
 		symbol_code_length = **(**int32)(__ccgo_up(code_lengths + uintptr(symbol)*4))
 		if **(**int32)(__ccgo_up(code_lengths + uintptr(symbol)*4)) > 0 {
 			if sorted != libc.UintptrFromInt32(0) {
 				if (**(**[16]int32)(__ccgo_up(bp + 64)))[symbol_code_length] >= code_lengths_size {
 					return 0
 				}
 				v5 = bp + 64 + uintptr(symbol_code_length)*4
 				v4 = *(*int32)(unsafe.Pointer(v5))
 				*(*int32)(unsafe.Pointer(v5)) = *(*int32)(unsafe.Pointer(v5)) + 1
 				**(**uint16_t)(__ccgo_up(sorted + uintptr(v4)*2)) = libc.Uint16FromInt32(symbol)
 			} else {
 				(**(**[16]int32)(__ccgo_up(bp + 64)))[symbol_code_length] = (**(**[16]int32)(__ccgo_up(bp + 64)))[symbol_code_length] + 1
 			}
 		}
 		goto _3
 	_3:
 		;
 		symbol = symbol + 1
 	}
 	// Special case code with only one value.
 	if (**(**[16]int32)(__ccgo_up(bp + 64)))[int32(MAX_ALLOWED_CODE_LENGTH)] == int32(1) {
 		if sorted != libc.UintptrFromInt32(0) {
 			code.Fbits = uint8(0)
 			code.Fvalue = **(**uint16_t)(__ccgo_up(sorted))
 			ReplicateValue(tls, table, int32(1), total_size, code)
 		}
 		return total_size
 	}
 	// step size to replicate values in current table
 	low = uint32(0xffffffff)                           // low bits for current root entry
 	mask = libc.Uint32FromInt32(total_size - int32(1)) // mask for low bits
 	key = uint32(0)                                    // reversed prefix code
 	num_nodes = int32(1)                               // number of Huffman tree nodes
 	num_open = int32(1)                                // number of open branches in current tree level
 	table_bits = root_bits                             // key length of current table
 	table_size = int32(1) << table_bits                // size of current table
 	symbol = 0
 	// Fill in root table.
 	len1 = int32(1)
 	step = libc.Int32FromInt32(2)
 	for {
 		if !(len1 <= root_bits) {
 			break
 		}
 		num_open = num_open << int32(1)
 		num_nodes = num_nodes + num_open
 		num_open = num_open - (**(**[16]int32)(__ccgo_up(bp)))[len1]
 		if num_open < 0 {
 			return 0
 		}
 		if root_table == libc.UintptrFromInt32(0) {
 			goto _6
 		}
 		for {
 			if !((**(**[16]int32)(__ccgo_up(bp)))[len1] > 0) {
 				break
 			}
 			code1.Fbits = libc.Uint8FromInt32(len1)
 			v4 = symbol
 			symbol = symbol + 1
 			code1.Fvalue = **(**uint16_t)(__ccgo_up(sorted + uintptr(v4)*2))
 			ReplicateValue(tls, table+uintptr(key)*4, step, table_size, code1)
 			key = GetNextKey(tls, key, len1)
 			goto _7
 		_7:
 			;
 			(**(**[16]int32)(__ccgo_up(bp)))[len1] = (**(**[16]int32)(__ccgo_up(bp)))[len1] - 1
 		}
 		goto _6
 	_6:
 		;
 		len1 = len1 + 1
 		step = step << int32(1)
 	}
 	// Fill in 2nd level tables and add pointers to root table.
 	len1 = root_bits + int32(1)
 	step = libc.Int32FromInt32(2)
 	for {
 		if !(len1 <= int32(MAX_ALLOWED_CODE_LENGTH)) {
 			break
 		}
 		num_open = num_open << int32(1)
 		num_nodes = num_nodes + num_open
 		num_open = num_open - (**(**[16]int32)(__ccgo_up(bp)))[len1]
 		if num_open < 0 {
 			return 0
 		}
 		for {
 			if !((**(**[16]int32)(__ccgo_up(bp)))[len1] > 0) {
 				break
 			}
 			if key&mask != low {
 				if root_table != libc.UintptrFromInt32(0) {
 					table = table + uintptr(table_size)*4
 				}
 				table_bits = NextTableBitSize(tls, bp, len1, root_bits)
 				table_size = int32(1) << table_bits
 				total_size = total_size + table_size
 				low = key & mask
 				if root_table != libc.UintptrFromInt32(0) {
 					(**(**HuffmanCode)(__ccgo_up(root_table + uintptr(low)*4))).Fbits = libc.Uint8FromInt32(table_bits + root_bits)
 					(**(**HuffmanCode)(__ccgo_up(root_table + uintptr(low)*4))).Fvalue = libc.Uint16FromInt64((int64(table)-int64(root_table))/4 - libc.Int64FromUint32(low))
 				}
 			}
 			if root_table != libc.UintptrFromInt32(0) {
 				code2.Fbits = libc.Uint8FromInt32(len1 - root_bits)
 				v4 = symbol
 				symbol = symbol + 1
 				code2.Fvalue = **(**uint16_t)(__ccgo_up(sorted + uintptr(v4)*2))
 				ReplicateValue(tls, table+uintptr(key>>root_bits)*4, step, table_size, code2)
 			}
 			key = GetNextKey(tls, key, len1)
 			goto _10
 		_10:
 			;
 			(**(**[16]int32)(__ccgo_up(bp)))[len1] = (**(**[16]int32)(__ccgo_up(bp)))[len1] - 1
 		}
 		goto _9
 	_9:
 		;
 		len1 = len1 + 1
 		step = step << int32(1)
 	}
 	// Check if tree is full.
 	if num_nodes != int32(2)*(**(**[16]int32)(__ccgo_up(bp + 64)))[int32(MAX_ALLOWED_CODE_LENGTH)]-int32(1) {
 		return 0
 	}
 	return total_size
 }
 
 // C documentation
 //
 //	// Maximum code_lengths_size is 2328 (reached for 11-bit color_cache_bits).
 //	// More commonly, the value is around ~280.
 //	// Cut-off value for switching between heap and stack allocation.
 func VP8LBuildHuffmanTable(tls *libc.TLS, root_table uintptr, root_bits int32, code_lengths uintptr, code_lengths_size int32) (r int32) {
 	bp := tls.Alloc(1024)
 	defer tls.Free(1024)
 	var next, sorted1 uintptr
 	var segment_size, total_size, v1 int32
 	var _ /* sorted at bp+0 */ [512]uint16_t
 	_, _, _, _, _ = next, segment_size, sorted1, total_size, v1
 	total_size = BuildHuffmanTable(tls, libc.UintptrFromInt32(0), root_bits, code_lengths, code_lengths_size, libc.UintptrFromInt32(0))
 	if total_size == 0 || root_table == libc.UintptrFromInt32(0) {
 		return total_size
 	}
 	if (*HuffmanTablesSegment)(unsafe.Pointer((*HuffmanTables)(unsafe.Pointer(root_table)).Fcurr_segment)).Fcurr_table+uintptr(total_size)*4 >= (*HuffmanTablesSegment)(unsafe.Pointer((*HuffmanTables)(unsafe.Pointer(root_table)).Fcurr_segment)).Fstart+uintptr((*HuffmanTablesSegment)(unsafe.Pointer((*HuffmanTables)(unsafe.Pointer(root_table)).Fcurr_segment)).Fsize)*4 {
 		// If 'root_table' does not have enough memory, allocate a new segment.
 		// The available part of root_table->curr_segment is left unused because we
 		// need a contiguous buffer.
 		segment_size = (*HuffmanTablesSegment)(unsafe.Pointer((*HuffmanTables)(unsafe.Pointer(root_table)).Fcurr_segment)).Fsize
 		next = WebPSafeMalloc(tls, uint64(1), uint64(32))
 		if next == libc.UintptrFromInt32(0) {
 			return 0
 		}
 		// Fill the new segment.
 		// We need at least 'total_size' but if that value is small, it is better to
 		// allocate a big chunk to prevent more allocations later. 'segment_size' is
 		// therefore chosen (any other arbitrary value could be chosen).
 		if total_size > segment_size {
 			v1 = total_size
 		} else {
 			v1 = segment_size
 		}
 		(*HuffmanTablesSegment)(unsafe.Pointer(next)).Fsize = v1
 		(*HuffmanTablesSegment)(unsafe.Pointer(next)).Fstart = WebPSafeMalloc(tls, libc.Uint64FromInt32((*HuffmanTablesSegment)(unsafe.Pointer(next)).Fsize), uint64(4))
 		if (*HuffmanTablesSegment)(unsafe.Pointer(next)).Fstart == libc.UintptrFromInt32(0) {
 			WebPSafeFree(tls, next)
 			return 0
 		}
 		(*HuffmanTablesSegment)(unsafe.Pointer(next)).Fcurr_table = (*HuffmanTablesSegment)(unsafe.Pointer(next)).Fstart
 		(*HuffmanTablesSegment)(unsafe.Pointer(next)).Fnext = libc.UintptrFromInt32(0)
 		// Point to the new segment.
 		(*HuffmanTablesSegment)(unsafe.Pointer((*HuffmanTables)(unsafe.Pointer(root_table)).Fcurr_segment)).Fnext = next
 		(*HuffmanTables)(unsafe.Pointer(root_table)).Fcurr_segment = next
 	}
 	if code_lengths_size <= int32(SORTED_SIZE_CUTOFF) {
 		BuildHuffmanTable(tls, (*HuffmanTablesSegment)(unsafe.Pointer((*HuffmanTables)(unsafe.Pointer(root_table)).Fcurr_segment)).Fcurr_table, root_bits, code_lengths, code_lengths_size, bp)
 	} else { // rare case. Use heap allocation.
 		sorted1 = WebPSafeMalloc(tls, libc.Uint64FromInt32(code_lengths_size), uint64(2))
 		if sorted1 == libc.UintptrFromInt32(0) {
 			return 0
 		}
 		BuildHuffmanTable(tls, (*HuffmanTablesSegment)(unsafe.Pointer((*HuffmanTables)(unsafe.Pointer(root_table)).Fcurr_segment)).Fcurr_table, root_bits, code_lengths, code_lengths_size, sorted1)
 		WebPSafeFree(tls, sorted1)
 	}
 	return total_size
 }
 
 func VP8LHuffmanTablesAllocate(tls *libc.TLS, size int32, huffman_tables uintptr) (r int32) {
 	var root uintptr
 	_ = root
 	// Have 'segment' point to the first segment for now, 'root'.
 	root = huffman_tables
 	(*HuffmanTables)(unsafe.Pointer(huffman_tables)).Fcurr_segment = root
 	(*HuffmanTablesSegment)(unsafe.Pointer(root)).Fnext = libc.UintptrFromInt32(0)
 	// Allocate root.
 	(*HuffmanTablesSegment)(unsafe.Pointer(root)).Fstart = WebPSafeMalloc(tls, libc.Uint64FromInt32(size), uint64(4))
 	if (*HuffmanTablesSegment)(unsafe.Pointer(root)).Fstart == libc.UintptrFromInt32(0) {
 		return 0
 	}
 	(*HuffmanTablesSegment)(unsafe.Pointer(root)).Fcurr_table = (*HuffmanTablesSegment)(unsafe.Pointer(root)).Fstart
 	(*HuffmanTablesSegment)(unsafe.Pointer(root)).Fsize = size
 	return int32(1)
 }
 
 func VP8LHuffmanTablesDeallocate(tls *libc.TLS, huffman_tables uintptr) {
 	var current, next uintptr
 	_, _ = current, next
 	if huffman_tables == libc.UintptrFromInt32(0) {
 		return
 	}
 	// Free the root node.
 	current = huffman_tables
 	next = (*HuffmanTablesSegment)(unsafe.Pointer(current)).Fnext
 	WebPSafeFree(tls, (*HuffmanTablesSegment)(unsafe.Pointer(current)).Fstart)
 	(*HuffmanTablesSegment)(unsafe.Pointer(current)).Fstart = libc.UintptrFromInt32(0)
 	(*HuffmanTablesSegment)(unsafe.Pointer(current)).Fnext = libc.UintptrFromInt32(0)
 	current = next
 	// Free the following nodes.
 	for current != libc.UintptrFromInt32(0) {
 		next = (*HuffmanTablesSegment)(unsafe.Pointer(current)).Fnext
 		WebPSafeFree(tls, (*HuffmanTablesSegment)(unsafe.Pointer(current)).Fstart)
 		WebPSafeFree(tls, current)
 		current = next
 	}
 }
 
 var kHashMul13 = uint32(0x1e35a7bd)
 
 // Alpha related constants.
 
 // Mux related constants.
 
 // Maximum chunk payload is such that adding the header and padding won't
 // overflow a uint32_t.
 
 // Copyright 2010 Google Inc. All Rights Reserved.
 //
 // Use of this source code is governed by a BSD-style license
 // that can be found in the COPYING file in the root of the source
 // tree. An additional intellectual property rights grant can be found
 // in the file PATENTS. All contributing project authors may
 // be found in the AUTHORS file in the root of the source tree.
 // -----------------------------------------------------------------------------
 //
 //  Common types + memory wrappers
 //
 // Author: Skal (pascal.massimino@gmail.com)
 
 // -----------------------------------------------------------------------------
 
 // Palette reordering for smaller sum of deltas (and for smaller storage).
 
 func PaletteCompareColorsForQsort(tls *libc.TLS, p1 uintptr, p2 uintptr) (r int32) {
 	bp := tls.Alloc(16)
 	defer tls.Free(16)
 	var a, b, v1, v3 uint32_t
 	var v5 int32
 	var _ /* A at bp+0 */ uint32_t
 	_, _, _, _, _ = a, b, v1, v3, v5
 	libc.X__builtin___memcpy_chk(tls, bp, p1, uint64(4), ^__predefined_size_t(0))
 	v1 = **(**uint32_t)(__ccgo_up(bp))
 	goto _2
 _2:
 	a = v1
 	libc.X__builtin___memcpy_chk(tls, bp, p2, uint64(4), ^__predefined_size_t(0))
 	v3 = **(**uint32_t)(__ccgo_up(bp))
 	goto _4
 _4:
 	b = v3
 	if a < b {
 		v5 = -int32(1)
 	} else {
 		v5 = int32(1)
 	}
 	return v5
 }
 
 func PaletteComponentDistance(tls *libc.TLS, v uint32_t) (r uint32_t) {
 	var v1 uint32
 	_ = v1
 	if v <= uint32(128) {
 		v1 = v
 	} else {
 		v1 = uint32(256) - v
 	}
 	return v1
 }
 
 // C documentation
 //
 //	// Computes a value that is related to the entropy created by the
 //	// palette entry diff.
 //	//
 //	// Note that the last & 0xff is a no-operation in the next statement, but
 //	// removed by most compilers and is here only for regularity of the code.
 func PaletteColorDistance(tls *libc.TLS, col1 uint32_t, col2 uint32_t) (r uint32_t) {
 	var alpha_and_green, diff, red_and_blue, score, v1, v2, v3 uint32_t
 	var kMoreWeightForRGBThanForAlpha int32
 	_, _, _, _, _, _, _, _ = alpha_and_green, diff, kMoreWeightForRGBThanForAlpha, red_and_blue, score, v1, v2, v3
 	v1 = col1
 	v2 = col2
 	alpha_and_green = uint32(0x00ff00ff) + v1&uint32(0xff00ff00) - v2&uint32(0xff00ff00)
 	red_and_blue = uint32(0xff00ff00) + v1&uint32(0x00ff00ff) - v2&uint32(0x00ff00ff)
 	v3 = alpha_and_green&uint32(0xff00ff00) | red_and_blue&uint32(0x00ff00ff)
 	goto _4
 _4:
 	diff = v3
 	kMoreWeightForRGBThanForAlpha = int32(9)
 	score = PaletteComponentDistance(tls, diff>>libc.Int32FromInt32(0)&uint32(0xff))
 	score = score + PaletteComponentDistance(tls, diff>>libc.Int32FromInt32(8)&uint32(0xff))
 	score = score + PaletteComponentDistance(tls, diff>>libc.Int32FromInt32(16)&uint32(0xff))
 	score = score * libc.Uint32FromInt32(kMoreWeightForRGBThanForAlpha)
 	score = score + PaletteComponentDistance(tls, diff>>libc.Int32FromInt32(24)&uint32(0xff))
 	return score
 }
 
 func SwapColor(tls *libc.TLS, col1 uintptr, col2 uintptr) {
 	var tmp uint32_t
 	_ = tmp
 	tmp = **(**uint32_t)(__ccgo_up(col1))
 	**(**uint32_t)(__ccgo_up(col1)) = **(**uint32_t)(__ccgo_up(col2))
 	**(**uint32_t)(__ccgo_up(col2)) = tmp
 }
 
 func SearchColorNoIdx(tls *libc.TLS, sorted uintptr, color uint32_t, num_colors int32) (r int32) {
 	var hi, low, mid int32
 	_, _, _ = hi, low, mid
 	low = 0
 	hi = num_colors
 	if **(**uint32_t)(__ccgo_up(sorted + uintptr(low)*4)) == color {
 		return low
 	} // loop invariant: sorted[low] != color
 	for int32(1) != 0 {
 		mid = (low + hi) >> int32(1)
 		if **(**uint32_t)(__ccgo_up(sorted + uintptr(mid)*4)) == color {
 			return mid
 		} else {
 			if **(**uint32_t)(__ccgo_up(sorted + uintptr(mid)*4)) < color {
 				low = mid
 			} else {
 				hi = mid
 			}
 		}
 	}
 	return 0
 }
 
 func PrepareMapToPalette(tls *libc.TLS, palette uintptr, num_colors uint32_t, sorted uintptr, idx_map uintptr) {
 	var i uint32_t
 	_ = i
 	libc.X__builtin___memcpy_chk(tls, sorted, palette, uint64(num_colors)*uint64(4), ^__predefined_size_t(0))
 	libc.Xqsort(tls, sorted, uint64(num_colors), uint64(4), __ccgo_fp(PaletteCompareColorsForQsort))
 	i = uint32(0)
 	for {
 		if !(i < num_colors) {
 			break
 		}
 		**(**uint32_t)(__ccgo_up(idx_map + uintptr(SearchColorNoIdx(tls, sorted, **(**uint32_t)(__ccgo_up(palette + uintptr(i)*4)), libc.Int32FromUint32(num_colors)))*4)) = i
 		goto _1
 	_1:
 		;
 		i = i + 1
 	}
 }
 
 //------------------------------------------------------------------------------
 
 func GetColorPalette(tls *libc.TLS, pic uintptr, palette uintptr) (r int32) {
 	var argb1 uintptr
 	var colors [1024]uint32_t
 	var height, i, key, num_colors, width, x, y, v3 int32
 	var in_use [1024]uint8_t
 	var last_pix uint32_t
 	_, _, _, _, _, _, _, _, _, _, _, _ = argb1, colors, height, i, in_use, key, last_pix, num_colors, width, x, y, v3
 	num_colors = 0
 	in_use = [1024]uint8_t{}
 	colors = [1024]uint32_t{}
 	argb1 = (*WebPPicture)(unsafe.Pointer(pic)).Fargb
 	width = (*WebPPicture)(unsafe.Pointer(pic)).Fwidth
 	height = (*WebPPicture)(unsafe.Pointer(pic)).Fheight
 	last_pix = ^**(**uint32_t)(__ccgo_up(argb1)) // so we're sure that last_pix != argb[0]
 	y = 0
 	for {
 		if !(y < height) {
 			break
 		}
 		x = 0
 		for {
 			if !(x < width) {
 				break
 			}
 			if **(**uint32_t)(__ccgo_up(argb1 + uintptr(x)*4)) == last_pix {
 				goto _2
 			}
 			last_pix = **(**uint32_t)(__ccgo_up(argb1 + uintptr(x)*4))
 			v3 = libc.Int32FromUint32(last_pix * kHashMul13 >> int32(22))
 			goto _4
 		_4:
 			key = v3
 			for int32(1) != 0 {
 				if !(in_use[key] != 0) {
 					colors[key] = last_pix
 					in_use[key] = uint8(1)
 					num_colors = num_colors + 1
 					if num_colors > int32(MAX_PALETTE_SIZE) {
 						return libc.Int32FromInt32(MAX_PALETTE_SIZE) + libc.Int32FromInt32(1) // Exact count not needed.
 					}
 					break
 				} else {
 					if colors[key] == last_pix {
 						break // The color is already there.
 					} else {
 						// Some other color sits here, so do linear conflict resolution.
 						key = key + 1
 						key = key & (libc.Int32FromInt32(MAX_PALETTE_SIZE)*libc.Int32FromInt32(4) - libc.Int32FromInt32(1)) // Key mask.
 					}
 				}
 			}
 			goto _2
 		_2:
 			;
 			x = x + 1
 		}
 		argb1 = argb1 + uintptr((*WebPPicture)(unsafe.Pointer(pic)).Fargb_stride)*4
 		goto _1
 	_1:
 		;
 		y = y + 1
 	}
 	if palette != libc.UintptrFromInt32(0) { // Fill the colors into palette.
 		num_colors = 0
 		i = 0
 		for {
 			if !(i < libc.Int32FromInt32(MAX_PALETTE_SIZE)*libc.Int32FromInt32(4)) {
 				break
 			}
 			if in_use[i] != 0 {
 				**(**uint32_t)(__ccgo_up(palette + uintptr(num_colors)*4)) = colors[i]
 				num_colors = num_colors + 1
 			}
 			goto _5
 		_5:
 			;
 			i = i + 1
 		}
 		libc.Xqsort(tls, palette, libc.Uint64FromInt32(num_colors), uint64(4), __ccgo_fp(PaletteCompareColorsForQsort))
 	}
 	return num_colors
 }
 
 // -----------------------------------------------------------------------------
 
 // C documentation
 //
 //	// The palette has been sorted by alpha. This function checks if the other
 //	// components of the palette have a monotonic development with regards to
 //	// position in the palette. If all have monotonic development, there is
 //	// no benefit to re-organize them greedily. A monotonic development
 //	// would be spotted in green-only situations (like lossy alpha) or gray-scale
 //	// images.
 func PaletteHasNonMonotonousDeltas(tls *libc.TLS, palette uintptr, num_colors int32) (r int32) {
 	var alpha_and_green, diff, predict, red_and_blue, v2, v3, v4 uint32_t
 	var bd, gd, rd, sign_found uint8_t
 	var i, v6 int32
 	_, _, _, _, _, _, _, _, _, _, _, _, _ = alpha_and_green, bd, diff, gd, i, predict, rd, red_and_blue, sign_found, v2, v3, v4, v6
 	predict = uint32(0x000000)
 	sign_found = uint8(0x00)
 	i = 0
 	for {
 		if !(i < num_colors) {
 			break
 		}
 		v2 = **(**uint32_t)(__ccgo_up(palette + uintptr(i)*4))
 		v3 = predict
 		alpha_and_green = uint32(0x00ff00ff) + v2&uint32(0xff00ff00) - v3&uint32(0xff00ff00)
 		red_and_blue = uint32(0xff00ff00) + v2&uint32(0x00ff00ff) - v3&uint32(0x00ff00ff)
 		v4 = alpha_and_green&uint32(0xff00ff00) | red_and_blue&uint32(0x00ff00ff)
 		goto _5
 	_5:
 		diff = v4
 		rd = uint8(diff >> libc.Int32FromInt32(16) & uint32(0xff))
 		gd = uint8(diff >> libc.Int32FromInt32(8) & uint32(0xff))
 		bd = uint8(diff >> libc.Int32FromInt32(0) & uint32(0xff))
 		if libc.Int32FromUint8(rd) != 0x00 {
 			if libc.Int32FromUint8(rd) < int32(0x80) {
 				v6 = int32(1)
 			} else {
 				v6 = int32(2)
 			}
 			sign_found = libc.Uint8FromInt32(int32(sign_found) | v6)
 		}
 		if libc.Int32FromUint8(gd) != 0x00 {
 			if libc.Int32FromUint8(gd) < int32(0x80) {
 				v6 = int32(8)
 			} else {
 				v6 = int32(16)
 			}
 			sign_found = libc.Uint8FromInt32(int32(sign_found) | v6)
 		}
 		if libc.Int32FromUint8(bd) != 0x00 {
 			if libc.Int32FromUint8(bd) < int32(0x80) {
 				v6 = int32(64)
 			} else {
 				v6 = int32(128)
 			}
 			sign_found = libc.Uint8FromInt32(int32(sign_found) | v6)
 		}
 		predict = **(**uint32_t)(__ccgo_up(palette + uintptr(i)*4))
 		goto _1
 	_1:
 		;
 		i = i + 1
 	}
 	return libc.BoolInt32(libc.Int32FromUint8(sign_found)&(libc.Int32FromUint8(sign_found)<<int32(1)) != 0) // two consequent signs.
 }
 
 func PaletteSortMinimizeDeltas(tls *libc.TLS, palette_sorted uintptr, num_colors int32, palette uintptr) {
 	var best_ix, i, k int32
 	var best_score, cur_score, predict uint32_t
 	_, _, _, _, _, _ = best_ix, best_score, cur_score, i, k, predict
 	predict = uint32(0x00000000)
 	libc.X__builtin___memcpy_chk(tls, palette, palette_sorted, libc.Uint64FromInt32(num_colors)*uint64(4), ^__predefined_size_t(0))
 	if !(PaletteHasNonMonotonousDeltas(tls, palette_sorted, num_colors) != 0) {
 		return
 	}
 	// Find greedily always the closest color of the predicted color to minimize
 	// deltas in the palette. This reduces storage needs since the
 	// palette is stored with delta encoding.
 	if num_colors > int32(17) {
 		if **(**uint32_t)(__ccgo_up(palette)) == uint32(0) {
 			num_colors = num_colors - 1
 			SwapColor(tls, palette+uintptr(num_colors)*4, palette)
 		}
 	}
 	i = 0
 	for {
 		if !(i < num_colors) {
 			break
 		}
 		best_ix = i
 		best_score = ^libc.Uint32FromUint32(0)
 		k = i
 		for {
 			if !(k < num_colors) {
 				break
 			}
 			cur_score = PaletteColorDistance(tls, **(**uint32_t)(__ccgo_up(palette + uintptr(k)*4)), predict)
 			if best_score > cur_score {
 				best_score = cur_score
 				best_ix = k
 			}
 			goto _2
 		_2:
 			;
 			k = k + 1
 		}
 		SwapColor(tls, palette+uintptr(best_ix)*4, palette+uintptr(i)*4)
 		predict = **(**uint32_t)(__ccgo_up(palette + uintptr(i)*4))
 		goto _1
 	_1:
 		;
 		i = i + 1
 	}
 }
 
 // -----------------------------------------------------------------------------
 // Modified Zeng method from "A Survey on Palette Reordering
 // Methods for Improving the Compression of Color-Indexed Images" by Armando J.
 // Pinho and Antonio J. R. Neves.
 
 // C documentation
 //
 //	// Finds the biggest cooccurrence in the matrix.
 func CoOccurrenceFindMax(tls *libc.TLS, cooccurrence uintptr, num_colors uint32_t, c1 uintptr, c2 uintptr) {
 	var best_cooccurrence, best_sum, i, j, sum uint32_t
 	_, _, _, _, _ = best_cooccurrence, best_sum, i, j, sum
 	// Find the index that is most frequently located adjacent to other
 	// (different) indexes.
 	best_sum = 0
 	**(**uint8_t)(__ccgo_up(c1)) = 0
 	i = uint32(0)
 	for {
 		if !(i < num_colors) {
 			break
 		}
 		sum = uint32(0)
 		j = uint32(0)
 		for {
 			if !(j < num_colors) {
 				break
 			}
 			sum = sum + **(**uint32_t)(__ccgo_up(cooccurrence + uintptr(i*num_colors+j)*4))
 			goto _2
 		_2:
 			;
 			j = j + 1
 		}
 		if sum > best_sum {
 			best_sum = sum
 			**(**uint8_t)(__ccgo_up(c1)) = uint8(i)
 		}
 		goto _1
 	_1:
 		;
 		i = i + 1
 	}
 	// Find the index that is most frequently found adjacent to *c1.
 	**(**uint8_t)(__ccgo_up(c2)) = 0
 	best_cooccurrence = 0
 	i = uint32(0)
 	for {
 		if !(i < num_colors) {
 			break
 		}
 		if **(**uint32_t)(__ccgo_up(cooccurrence + uintptr(uint32(**(**uint8_t)(__ccgo_up(c1)))*num_colors+i)*4)) > best_cooccurrence {
 			best_cooccurrence = **(**uint32_t)(__ccgo_up(cooccurrence + uintptr(uint32(**(**uint8_t)(__ccgo_up(c1)))*num_colors+i)*4))
 			**(**uint8_t)(__ccgo_up(c2)) = uint8(i)
 		}
 		goto _3
 	_3:
 		;
 		i = i + 1
 	}
 }
 
 // C documentation
 //
 //	// Builds the cooccurrence matrix
 func CoOccurrenceBuild(tls *libc.TLS, pic uintptr, palette uintptr, num_colors uint32_t, cooccurrence uintptr) (r int32) {
 	bp := tls.Alloc(2048)
 	defer tls.Free(2048)
 	var left_idx, pix, prev_idx, prev_pix, top_idx uint32_t
 	var line_current, line_tmp, line_top, lines, src uintptr
 	var x, y int32
 	var _ /* idx_map at bp+0 */ [256]uint32_t
 	var _ /* palette_sorted at bp+1024 */ [256]uint32_t
 	_, _, _, _, _, _, _, _, _, _, _, _ = left_idx, line_current, line_tmp, line_top, lines, pix, prev_idx, prev_pix, src, top_idx, x, y
 	src = (*WebPPicture)(unsafe.Pointer(pic)).Fargb
 	prev_pix = ^**(**uint32_t)(__ccgo_up(src))
 	prev_idx = 0
 	**(**[256]uint32_t)(__ccgo_up(bp)) = [256]uint32_t{}
 	lines = WebPSafeMalloc(tls, libc.Uint64FromInt32(int32(2)*(*WebPPicture)(unsafe.Pointer(pic)).Fwidth), uint64(4))
 	if lines == libc.UintptrFromInt32(0) {
 		return 0
 	}
 	line_top = lines
 	line_current = lines + uintptr((*WebPPicture)(unsafe.Pointer(pic)).Fwidth)*4
 	PrepareMapToPalette(tls, palette, num_colors, bp+1024, bp)
 	y = 0
 	for {
 		if !(y < (*WebPPicture)(unsafe.Pointer(pic)).Fheight) {
 			break
 		}
 		x = 0
 		for {
 			if !(x < (*WebPPicture)(unsafe.Pointer(pic)).Fwidth) {
 				break
 			}
 			pix = **(**uint32_t)(__ccgo_up(src + uintptr(x)*4))
 			if pix != prev_pix {
 				prev_idx = (**(**[256]uint32_t)(__ccgo_up(bp)))[SearchColorNoIdx(tls, bp+1024, pix, libc.Int32FromUint32(num_colors))]
 				prev_pix = pix
 			}
 			**(**uint32_t)(__ccgo_up(line_current + uintptr(x)*4)) = prev_idx
 			// 4-connectivity is what works best as mentioned in "On the relation
 			// between Memon's and the modified Zeng's palette reordering methods".
 			if x > 0 && prev_idx != **(**uint32_t)(__ccgo_up(line_current + uintptr(x-int32(1))*4)) {
 				left_idx = **(**uint32_t)(__ccgo_up(line_current + uintptr(x-int32(1))*4))
 				**(**uint32_t)(__ccgo_up(cooccurrence + uintptr(prev_idx*num_colors+left_idx)*4)) = **(**uint32_t)(__ccgo_up(cooccurrence + uintptr(prev_idx*num_colors+left_idx)*4)) + 1
 				**(**uint32_t)(__ccgo_up(cooccurrence + uintptr(left_idx*num_colors+prev_idx)*4)) = **(**uint32_t)(__ccgo_up(cooccurrence + uintptr(left_idx*num_colors+prev_idx)*4)) + 1
 			}
 			if y > 0 && prev_idx != **(**uint32_t)(__ccgo_up(line_top + uintptr(x)*4)) {
 				top_idx = **(**uint32_t)(__ccgo_up(line_top + uintptr(x)*4))
 				**(**uint32_t)(__ccgo_up(cooccurrence + uintptr(prev_idx*num_colors+top_idx)*4)) = **(**uint32_t)(__ccgo_up(cooccurrence + uintptr(prev_idx*num_colors+top_idx)*4)) + 1
 				**(**uint32_t)(__ccgo_up(cooccurrence + uintptr(top_idx*num_colors+prev_idx)*4)) = **(**uint32_t)(__ccgo_up(cooccurrence + uintptr(top_idx*num_colors+prev_idx)*4)) + 1
 			}
 			goto _2
 		_2:
 			;
 			x = x + 1
 		}
 		line_tmp = line_top
 		line_top = line_current
 		line_current = line_tmp
 		src = src + uintptr((*WebPPicture)(unsafe.Pointer(pic)).Fargb_stride)*4
 		goto _1
 	_1:
 		;
 		y = y + 1
 	}
 	WebPSafeFree(tls, lines)
 	return int32(1)
 }
 
 type Sum = struct {
 	Findex uint8_t
 	Fsum   uint32_t
 }
 
 func PaletteSortModifiedZeng(tls *libc.TLS, pic uintptr, palette_in uintptr, num_colors uint32_t, palette uintptr) (r int32) {
 	bp := tls.Alloc(2304)
 	defer tls.Free(2304)
 	var best_index uint8_t
 	var best_sum, cooccurrence uintptr
 	var delta, n int32_t
 	var first, i, ind, j, last, num_sums uint32_t
 	var l_j uint16_t
 	var v3 uint32
 	var _ /* remapping at bp+0 */ [256]uint8_t
 	var _ /* sums at bp+256 */ [256]Sum
 	_, _, _, _, _, _, _, _, _, _, _, _, _ = best_index, best_sum, cooccurrence, delta, first, i, ind, j, l_j, last, n, num_sums, v3
 	// TODO(vrabaud) check whether one color images should use palette or not.
 	if num_colors <= uint32(1) {
 		return int32(1)
 	}
 	// Build the co-occurrence matrix.
 	cooccurrence = WebPSafeCalloc(tls, uint64(num_colors*num_colors), uint64(4))
 	if cooccurrence == libc.UintptrFromInt32(0) {
 		return 0
 	}
 	if !(CoOccurrenceBuild(tls, pic, palette_in, num_colors, cooccurrence) != 0) {
 		WebPSafeFree(tls, cooccurrence)
 		return 0
 	}
 	// Initialize the mapping list with the two best indices.
 	CoOccurrenceFindMax(tls, cooccurrence, num_colors, bp, bp+1)
 	// We need to append and prepend to the list of remapping. To this end, we
 	// actually define the next start/end of the list as indices in a vector (with
 	// a wrap around when the end is reached).
 	first = uint32(0)
 	last = uint32(1)
 	num_sums = num_colors - uint32(2) // -2 because we know the first two values
 	if num_sums > uint32(0) {
 		// Initialize the sums with the first two remappings and find the best one
 		best_sum = bp + 256
 		(*Sum)(unsafe.Pointer(best_sum)).Findex = 0
 		(*Sum)(unsafe.Pointer(best_sum)).Fsum = 0
 		i = uint32(0)
 		j = libc.Uint32FromInt32(0)
 		for {
 			if !(i < num_colors) {
 				break
 			}
 			if i == uint32((**(**[256]uint8_t)(__ccgo_up(bp)))[0]) || i == uint32((**(**[256]uint8_t)(__ccgo_up(bp)))[int32(1)]) {
 				goto _1
 			}
 			(**(**[256]Sum)(__ccgo_up(bp + 256)))[j].Findex = uint8(i)
 			(**(**[256]Sum)(__ccgo_up(bp + 256)))[j].Fsum = **(**uint32_t)(__ccgo_up(cooccurrence + uintptr(i*num_colors+uint32((**(**[256]uint8_t)(__ccgo_up(bp)))[0]))*4)) + **(**uint32_t)(__ccgo_up(cooccurrence + uintptr(i*num_colors+uint32((**(**[256]uint8_t)(__ccgo_up(bp)))[int32(1)]))*4))
 			if (**(**[256]Sum)(__ccgo_up(bp + 256)))[j].Fsum > (*Sum)(unsafe.Pointer(best_sum)).Fsum {
 				best_sum = bp + 256 + uintptr(j)*8
 			}
 			j = j + 1
 			goto _1
 		_1:
 			;
 			i = i + 1
 		}
 		for num_sums > uint32(0) {
 			best_index = (*Sum)(unsafe.Pointer(best_sum)).Findex
 			// Compute delta to know if we need to prepend or append the best index.
 			delta = 0
 			n = libc.Int32FromUint32(num_colors - num_sums)
 			ind = first
 			j = libc.Uint32FromInt32(0)
 			for {
 				if !((ind+j)%num_colors != last+uint32(1)) {
 					break
 				}
 				l_j = uint16((**(**[256]uint8_t)(__ccgo_up(bp)))[(ind+j)%num_colors])
 				delta = delta + (n-int32(1)-int32(2)*libc.Int32FromUint32(j))*libc.Int32FromUint32(**(**uint32_t)(__ccgo_up(cooccurrence + uintptr(uint32(best_index)*num_colors+uint32(l_j))*4)))
 				goto _2
 			_2:
 				;
 				j = j + 1
 			}
 			if delta > 0 {
 				if first == uint32(0) {
 					v3 = num_colors - uint32(1)
 				} else {
 					v3 = first - uint32(1)
 				}
 				first = v3
 				(**(**[256]uint8_t)(__ccgo_up(bp)))[first] = best_index
 			} else {
 				last = last + 1
 				(**(**[256]uint8_t)(__ccgo_up(bp)))[last] = best_index
 			}
 			// Remove best_sum from sums.
 			**(**Sum)(__ccgo_up(best_sum)) = (**(**[256]Sum)(__ccgo_up(bp + 256)))[num_sums-uint32(1)]
 			num_sums = num_sums - 1
 			// Update all the sums and find the best one.
 			best_sum = bp + 256
 			i = uint32(0)
 			for {
 				if !(i < num_sums) {
 					break
 				}
 				(**(**[256]Sum)(__ccgo_up(bp + 256)))[i].Fsum += **(**uint32_t)(__ccgo_up(cooccurrence + uintptr(uint32(best_index)*num_colors+uint32((**(**[256]Sum)(__ccgo_up(bp + 256)))[i].Findex))*4))
 				if (**(**[256]Sum)(__ccgo_up(bp + 256)))[i].Fsum > (*Sum)(unsafe.Pointer(best_sum)).Fsum {
 					best_sum = bp + 256 + uintptr(i)*8
 				}
 				goto _4
 			_4:
 				;
 				i = i + 1
 			}
 		}
 	}
 	WebPSafeFree(tls, cooccurrence)
 	// Re-map the palette.
 	i = uint32(0)
 	for {
 		if !(i < num_colors) {
 			break
 		}
 		**(**uint32_t)(__ccgo_up(palette + uintptr(i)*4)) = **(**uint32_t)(__ccgo_up(palette_in + uintptr((**(**[256]uint8_t)(__ccgo_up(bp)))[(first+i)%num_colors])*4))
 		goto _5
 	_5:
 		;
 		i = i + 1
 	}
 	return int32(1)
 }
 
 // -----------------------------------------------------------------------------
 
 func PaletteSort(tls *libc.TLS, method PaletteSorting1, pic uintptr, palette_sorted uintptr, num_colors uint32_t, palette uintptr) (r int32) {
 	switch method {
 	case int32(kSortedDefault):
 		if **(**uint32_t)(__ccgo_up(palette_sorted)) == uint32(0) && num_colors > uint32(17) {
 			libc.X__builtin___memcpy_chk(tls, palette, palette_sorted+uintptr(1)*4, uint64(num_colors-libc.Uint32FromInt32(1))*uint64(4), ^__predefined_size_t(0))
 			**(**uint32_t)(__ccgo_up(palette + uintptr(num_colors-uint32(1))*4)) = uint32(0)
 		} else {
 			libc.X__builtin___memcpy_chk(tls, palette, palette_sorted, uint64(num_colors)*uint64(4), ^__predefined_size_t(0))
 		}
 		return int32(1)
 	case int32(kMinimizeDelta):
 		PaletteSortMinimizeDeltas(tls, palette_sorted, libc.Int32FromUint32(num_colors), palette)
 		return int32(1)
 	case int32(kModifiedZeng):
 		return PaletteSortModifiedZeng(tls, pic, palette_sorted, num_colors, palette)
 	case int32(kUnusedPalette):
 		fallthrough
 	case int32(kPaletteSortingNum):
 		break
 	}
 	return 0
 }
 
 const DFIX = 0
 const FIX = 16
 const LFIX = 2
 
 //------------------------------------------------------------------------------
 
 // Copyright 2010 Google Inc. All Rights Reserved.
 //
 // Use of this source code is governed by a BSD-style license
 // that can be found in the COPYING file in the root of the source
 // tree. An additional intellectual property rights grant can be found
 // in the file PATENTS. All contributing project authors may
 // be found in the AUTHORS file in the root of the source tree.
 // -----------------------------------------------------------------------------
 //
 //  Common types + memory wrappers
 //
 // Author: Skal (pascal.massimino@gmail.com)
 
 // #define USE_DITHERING   // uncomment to enable ordered dithering (not vital)
 
 type SmoothParams = struct {
 	Fwidth          int32
 	Fheight         int32
 	Fstride         int32
 	Frow            int32
 	Fsrc            uintptr
 	Fdst            uintptr
 	Fradius         int32
 	Fscale          int32
 	Fmem            uintptr
 	Fstart          uintptr
 	Fcur            uintptr
 	Fend            uintptr
 	Ftop            uintptr
 	Faverage        uintptr
 	Fnum_levels     int32
 	Fmin            int32
 	Fmax            int32
 	Fmin_level_dist int32
 	Fcorrection     uintptr
 }
 
 //------------------------------------------------------------------------------
 
 func clip_8b(tls *libc.TLS, v int32) (r uint8_t) {
 	var v1, v2 uint32
 	_, _ = v1, v2
 	if !(v&libc.Int32FromUint32(^libc.Uint32FromUint32(0)<<(libc.Int32FromInt32(8)+libc.Int32FromInt32(DFIX))) != 0) {
 		v1 = uint32(libc.Uint8FromInt32(v >> libc.Int32FromInt32(DFIX)))
 	} else {
 		if v < 0 {
 			v2 = 0
 		} else {
 			v2 = uint32(255)
 		}
 		v1 = v2
 	}
 	return uint8(v1)
 }
 
 // C documentation
 //
 //	// vertical accumulation
 func VFilter(tls *libc.TLS, p uintptr) {
 	var cur, out, src, top uintptr
 	var new_value, sum uint16_t
 	var w, x int32
 	_, _, _, _, _, _, _, _ = cur, new_value, out, src, sum, top, w, x
 	src = (*SmoothParams)(unsafe.Pointer(p)).Fsrc
 	w = (*SmoothParams)(unsafe.Pointer(p)).Fwidth
 	cur = (*SmoothParams)(unsafe.Pointer(p)).Fcur
 	top = (*SmoothParams)(unsafe.Pointer(p)).Ftop
 	out = (*SmoothParams)(unsafe.Pointer(p)).Fend
 	sum = uint16(0)
 	x = 0
 	for {
 		if !(x < w) {
 			break
 		}
 		sum = libc.Uint16FromInt32(int32(sum) + libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(src + uintptr(x)))))
 		new_value = libc.Uint16FromInt32(libc.Int32FromUint16(**(**uint16_t)(__ccgo_up(top + uintptr(x)*2))) + libc.Int32FromUint16(sum))
 		**(**uint16_t)(__ccgo_up(out + uintptr(x)*2)) = libc.Uint16FromInt32(libc.Int32FromUint16(new_value) - libc.Int32FromUint16(**(**uint16_t)(__ccgo_up(cur + uintptr(x)*2)))) // vertical sum of 'r' pixels.
 		**(**uint16_t)(__ccgo_up(cur + uintptr(x)*2)) = new_value
 		goto _1
 	_1:
 		;
 		x = x + 1
 	}
 	// move input pointers one row down
 	(*SmoothParams)(unsafe.Pointer(p)).Ftop = (*SmoothParams)(unsafe.Pointer(p)).Fcur
 	**(**uintptr)(__ccgo_up(p + 56)) += uintptr(w) * 2
 	if (*SmoothParams)(unsafe.Pointer(p)).Fcur == (*SmoothParams)(unsafe.Pointer(p)).Fend {
 		(*SmoothParams)(unsafe.Pointer(p)).Fcur = (*SmoothParams)(unsafe.Pointer(p)).Fstart
 	} // roll-over
 	// We replicate edges, as it's somewhat easier as a boundary condition.
 	// That's why we don't update the 'src' pointer on top/bottom area:
 	if (*SmoothParams)(unsafe.Pointer(p)).Frow >= 0 && (*SmoothParams)(unsafe.Pointer(p)).Frow < (*SmoothParams)(unsafe.Pointer(p)).Fheight-int32(1) {
 		**(**uintptr)(__ccgo_up(p + 16)) += uintptr((*SmoothParams)(unsafe.Pointer(p)).Fstride)
 	}
 }
 
 // C documentation
 //
 //	// horizontal accumulation. We use mirror replication of missing pixels, as it's
 //	// a little easier to implement (surprisingly).
 func HFilter(tls *libc.TLS, p uintptr) {
 	var delta, delta1, delta2 uint16_t
 	var in, out uintptr
 	var r, w, x int32
 	var scale uint32_t
 	_, _, _, _, _, _, _, _, _ = delta, delta1, delta2, in, out, r, scale, w, x
 	in = (*SmoothParams)(unsafe.Pointer(p)).Fend
 	out = (*SmoothParams)(unsafe.Pointer(p)).Faverage
 	scale = libc.Uint32FromInt32((*SmoothParams)(unsafe.Pointer(p)).Fscale)
 	w = (*SmoothParams)(unsafe.Pointer(p)).Fwidth
 	r = (*SmoothParams)(unsafe.Pointer(p)).Fradius
 	x = 0
 	for {
 		if !(x <= r) {
 			break
 		} // left mirroring
 		delta = libc.Uint16FromInt32(libc.Int32FromUint16(**(**uint16_t)(__ccgo_up(in + uintptr(x+r-int32(1))*2))) + libc.Int32FromUint16(**(**uint16_t)(__ccgo_up(in + uintptr(r-x)*2))))
 		**(**uint16_t)(__ccgo_up(out + uintptr(x)*2)) = uint16(uint32(delta) * scale >> int32(FIX))
 		goto _1
 	_1:
 		;
 		x = x + 1
 	}
 	for {
 		if !(x < w-r) {
 			break
 		} // bulk middle run
 		delta1 = libc.Uint16FromInt32(libc.Int32FromUint16(**(**uint16_t)(__ccgo_up(in + uintptr(x+r)*2))) - libc.Int32FromUint16(**(**uint16_t)(__ccgo_up(in + uintptr(x-r-int32(1))*2))))
 		**(**uint16_t)(__ccgo_up(out + uintptr(x)*2)) = uint16(uint32(delta1) * scale >> int32(FIX))
 		goto _2
 	_2:
 		;
 		x = x + 1
 	}
 	for {
 		if !(x < w) {
 			break
 		} // right mirroring
 		delta2 = libc.Uint16FromInt32(int32(2)*libc.Int32FromUint16(**(**uint16_t)(__ccgo_up(in + uintptr(w-int32(1))*2))) - libc.Int32FromUint16(**(**uint16_t)(__ccgo_up(in + uintptr(int32(2)*w-int32(2)-r-x)*2))) - libc.Int32FromUint16(**(**uint16_t)(__ccgo_up(in + uintptr(x-r-int32(1))*2))))
 		**(**uint16_t)(__ccgo_up(out + uintptr(x)*2)) = uint16(uint32(delta2) * scale >> int32(FIX))
 		goto _3
 	_3:
 		;
 		x = x + 1
 	}
 }
 
 // C documentation
 //
 //	// emit one filtered output row
 func ApplyFilter(tls *libc.TLS, p uintptr) {
 	var average, correction, dst uintptr
 	var c, v, w, x int32
 	_, _, _, _, _, _, _ = average, c, correction, dst, v, w, x
 	average = (*SmoothParams)(unsafe.Pointer(p)).Faverage
 	w = (*SmoothParams)(unsafe.Pointer(p)).Fwidth
 	correction = (*SmoothParams)(unsafe.Pointer(p)).Fcorrection
 	dst = (*SmoothParams)(unsafe.Pointer(p)).Fdst
 	x = 0
 	for {
 		if !(x < w) {
 			break
 		}
 		v = libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(dst + uintptr(x))))
 		if v < (*SmoothParams)(unsafe.Pointer(p)).Fmax && v > (*SmoothParams)(unsafe.Pointer(p)).Fmin {
 			c = v<<libc.Int32FromInt32(DFIX) + int32(**(**int16_t)(__ccgo_up(correction + uintptr(libc.Int32FromUint16(**(**uint16_t)(__ccgo_up(average + uintptr(x)*2)))-v<<libc.Int32FromInt32(LFIX))*2)))
 			**(**uint8_t)(__ccgo_up(dst + uintptr(x))) = clip_8b(tls, c)
 		}
 		goto _1
 	_1:
 		;
 		x = x + 1
 	}
 	**(**uintptr)(__ccgo_up(p + 24)) += uintptr((*SmoothParams)(unsafe.Pointer(p)).Fstride) // advance output pointer
 }
 
 //------------------------------------------------------------------------------
 // Initialize correction table
 
 func InitCorrectionLUT(tls *libc.TLS, lut uintptr, min_dist int32) {
 	var c, delta, i, max_threshold, threshold1, threshold2, v2, v3 int32
 	_, _, _, _, _, _, _, _ = c, delta, i, max_threshold, threshold1, threshold2, v2, v3
 	// The correction curve is:
 	//   f(x) = x for x <= threshold2
 	//   f(x) = 0 for x >= threshold1
 	// and a linear interpolation for range x=[threshold2, threshold1]
 	// (along with f(-x) = -f(x) symmetry).
 	// Note that: threshold2 = 3/4 * threshold1
 	threshold1 = min_dist << int32(LFIX)
 	threshold2 = int32(3) * threshold1 >> int32(2)
 	max_threshold = threshold2 << DFIX
 	delta = threshold1 - threshold2
 	i = int32(1)
 	for {
 		if !(i <= libc.Int32FromInt32(1)<<(libc.Int32FromInt32(8)+libc.Int32FromInt32(LFIX))-libc.Int32FromInt32(1)) {
 			break
 		}
 		if i <= threshold2 {
 			v2 = i << DFIX
 		} else {
 			if i < threshold1 {
 				v3 = max_threshold * (threshold1 - i) / delta
 			} else {
 				v3 = 0
 			}
 			v2 = v3
 		}
 		c = v2
 		c = c >> int32(LFIX)
 		**(**int16_t)(__ccgo_up(lut + uintptr(+i)*2)) = int16(+c)
 		**(**int16_t)(__ccgo_up(lut + uintptr(-i)*2)) = int16(-c)
 		goto _1
 	_1:
 		;
 		i = i + 1
 	}
 	**(**int16_t)(__ccgo_up(lut)) = 0
 }
 
 func CountLevels(tls *libc.TLS, p uintptr) {
 	var data uintptr
 	var i, j, last_level, level_dist, v int32
 	var used_levels [256]uint8_t
 	_, _, _, _, _, _, _ = data, i, j, last_level, level_dist, used_levels, v
 	used_levels = [256]uint8_t{}
 	data = (*SmoothParams)(unsafe.Pointer(p)).Fsrc
 	(*SmoothParams)(unsafe.Pointer(p)).Fmin = int32(255)
 	(*SmoothParams)(unsafe.Pointer(p)).Fmax = 0
 	j = 0
 	for {
 		if !(j < (*SmoothParams)(unsafe.Pointer(p)).Fheight) {
 			break
 		}
 		i = 0
 		for {
 			if !(i < (*SmoothParams)(unsafe.Pointer(p)).Fwidth) {
 				break
 			}
 			v = libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(data + uintptr(i))))
 			if v < (*SmoothParams)(unsafe.Pointer(p)).Fmin {
 				(*SmoothParams)(unsafe.Pointer(p)).Fmin = v
 			}
 			if v > (*SmoothParams)(unsafe.Pointer(p)).Fmax {
 				(*SmoothParams)(unsafe.Pointer(p)).Fmax = v
 			}
 			used_levels[v] = uint8(1)
 			goto _2
 		_2:
 			;
 			i = i + 1
 		}
 		data = data + uintptr((*SmoothParams)(unsafe.Pointer(p)).Fstride)
 		goto _1
 	_1:
 		;
 		j = j + 1
 	}
 	// Compute the mininum distance between two non-zero levels.
 	(*SmoothParams)(unsafe.Pointer(p)).Fmin_level_dist = (*SmoothParams)(unsafe.Pointer(p)).Fmax - (*SmoothParams)(unsafe.Pointer(p)).Fmin
 	last_level = -int32(1)
 	i = 0
 	for {
 		if !(i < int32(256)) {
 			break
 		}
 		if used_levels[i] != 0 {
 			(*SmoothParams)(unsafe.Pointer(p)).Fnum_levels = (*SmoothParams)(unsafe.Pointer(p)).Fnum_levels + 1
 			if last_level >= 0 {
 				level_dist = i - last_level
 				if level_dist < (*SmoothParams)(unsafe.Pointer(p)).Fmin_level_dist {
 					(*SmoothParams)(unsafe.Pointer(p)).Fmin_level_dist = level_dist
 				}
 			}
 			last_level = i
 		}
 		goto _3
 	_3:
 		;
 		i = i + 1
 	}
 }
 
 // C documentation
 //
 //	// Initialize all params.
 func InitParams(tls *libc.TLS, data uintptr, width int32, height int32, stride int32, radius int32, p uintptr) (r int32) {
 	var R int32
 	var mem uintptr
 	var size_lut, size_m, size_scratch_m, total_size size_t
 	_, _, _, _, _, _ = R, mem, size_lut, size_m, size_scratch_m, total_size
 	R = int32(2)*radius + int32(1) // total size of the kernel
 	size_scratch_m = libc.Uint64FromInt32((R+int32(1))*width) * uint64(2)
 	size_m = libc.Uint64FromInt32(width) * uint64(2)
 	size_lut = libc.Uint64FromInt32(libc.Int32FromInt32(1)+libc.Int32FromInt32(2)*(libc.Int32FromInt32(1)<<(libc.Int32FromInt32(8)+libc.Int32FromInt32(LFIX))-libc.Int32FromInt32(1))) * libc.Uint64FromInt64(2)
 	total_size = size_scratch_m + size_m + size_lut
 	mem = WebPSafeMalloc(tls, uint64(1), total_size)
 	if mem == libc.UintptrFromInt32(0) {
 		return 0
 	}
 	(*SmoothParams)(unsafe.Pointer(p)).Fmem = mem
 	(*SmoothParams)(unsafe.Pointer(p)).Fstart = mem
 	(*SmoothParams)(unsafe.Pointer(p)).Fcur = (*SmoothParams)(unsafe.Pointer(p)).Fstart
 	(*SmoothParams)(unsafe.Pointer(p)).Fend = (*SmoothParams)(unsafe.Pointer(p)).Fstart + uintptr(R*width)*2
 	(*SmoothParams)(unsafe.Pointer(p)).Ftop = (*SmoothParams)(unsafe.Pointer(p)).Fend - uintptr(width)*2
 	libc.X__builtin___memset_chk(tls, (*SmoothParams)(unsafe.Pointer(p)).Ftop, 0, libc.Uint64FromInt32(width)*uint64(2), ^__predefined_size_t(0))
 	mem = mem + uintptr(size_scratch_m)
 	(*SmoothParams)(unsafe.Pointer(p)).Faverage = mem
 	mem = mem + uintptr(size_m)
 	(*SmoothParams)(unsafe.Pointer(p)).Fwidth = width
 	(*SmoothParams)(unsafe.Pointer(p)).Fheight = height
 	(*SmoothParams)(unsafe.Pointer(p)).Fstride = stride
 	(*SmoothParams)(unsafe.Pointer(p)).Fsrc = data
 	(*SmoothParams)(unsafe.Pointer(p)).Fdst = data
 	(*SmoothParams)(unsafe.Pointer(p)).Fradius = radius
 	(*SmoothParams)(unsafe.Pointer(p)).Fscale = libc.Int32FromInt32(1) << (libc.Int32FromInt32(FIX) + libc.Int32FromInt32(LFIX)) / (R * R) // normalization constant
 	(*SmoothParams)(unsafe.Pointer(p)).Frow = -radius
 	// analyze the input distribution so we can best-fit the threshold
 	CountLevels(tls, p)
 	// correction table
 	(*SmoothParams)(unsafe.Pointer(p)).Fcorrection = mem + uintptr(libc.Int32FromInt32(1)<<(libc.Int32FromInt32(8)+libc.Int32FromInt32(LFIX))-libc.Int32FromInt32(1))*2
 	InitCorrectionLUT(tls, (*SmoothParams)(unsafe.Pointer(p)).Fcorrection, (*SmoothParams)(unsafe.Pointer(p)).Fmin_level_dist)
 	return int32(1)
 }
 
 func CleanupParams(tls *libc.TLS, p uintptr) {
 	WebPSafeFree(tls, (*SmoothParams)(unsafe.Pointer(p)).Fmem)
 }
 
 func WebPDequantizeLevels(tls *libc.TLS, data uintptr, width int32, height int32, stride int32, strength int32) (r int32) {
 	bp := tls.Alloc(112)
 	defer tls.Free(112)
 	var radius int32
 	var _ /* p at bp+0 */ SmoothParams
 	_ = radius
 	radius = int32(4) * strength / int32(100)
 	if strength < 0 || strength > int32(100) {
 		return 0
 	}
 	if data == libc.UintptrFromInt32(0) || width <= 0 || height <= 0 {
 		return 0
 	} // bad params
 	// limit the filter size to not exceed the image dimensions
 	if int32(2)*radius+int32(1) > width {
 		radius = (width - int32(1)) >> int32(1)
 	}
 	if int32(2)*radius+int32(1) > height {
 		radius = (height - int32(1)) >> int32(1)
 	}
 	if radius > 0 {
 		libc.X__builtin___memset_chk(tls, bp, 0, uint64(112), ^__predefined_size_t(0))
 		if !(InitParams(tls, data, width, height, stride, radius, bp) != 0) {
 			return 0
 		}
 		if (**(**SmoothParams)(__ccgo_up(bp))).Fnum_levels > int32(2) {
 			for {
 				if !((**(**SmoothParams)(__ccgo_up(bp))).Frow < (**(**SmoothParams)(__ccgo_up(bp))).Fheight) {
 					break
 				}
 				VFilter(tls, bp) // accumulate average of input
 				// Need to wait few rows in order to prime the filter,
 				// before emitting some output.
 				if (**(**SmoothParams)(__ccgo_up(bp))).Frow >= (**(**SmoothParams)(__ccgo_up(bp))).Fradius {
 					HFilter(tls, bp)
 					ApplyFilter(tls, bp)
 				}
 				goto _1
 			_1:
 				;
 				(**(**SmoothParams)(__ccgo_up(bp))).Frow = (**(**SmoothParams)(__ccgo_up(bp))).Frow + 1
 			}
 		}
 		CleanupParams(tls, bp)
 	}
 	return int32(1)
 }
 
 const ERROR_THRESHOLD = 0.0001
 const MAX_ITER = 6
 const NUM_SYMBOLS = 256
 
 // -----------------------------------------------------------------------------
 // Quantize levels.
 
 func QuantizeLevels(tls *libc.TLS, data uintptr, width int32, height int32, num_levels int32, sse uintptr) (r int32) {
 	bp := tls.Alloc(4096)
 	defer tls.Free(4096)
 	var count, err, err_threshold, error1, last_err float64
 	var data_size, n, n1 size_t
 	var freq, q_level [256]int32
 	var i, iter, max_s, min_s, num_levels_in, s, s1, slot, slot1 int32
 	var inv_q_level [256]float64
 	var map1 [256]uint8_t
 	var _ /* q_count at bp+2048 */ [256]float64
 	var _ /* q_sum at bp+0 */ [256]float64
 	_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = count, data_size, err, err_threshold, error1, freq, i, inv_q_level, iter, last_err, map1, max_s, min_s, n, n1, num_levels_in, q_level, s, s1, slot, slot1
 	freq = [256]int32{}
 	q_level = [256]int32{}
 	inv_q_level = [256]float64{}
 	min_s = int32(255)
 	max_s = 0
 	data_size = libc.Uint64FromInt32(height * width)
 	last_err = float64(1e+38)
 	err = float64(0)
 	err_threshold = float64(float64(0.0001) * float64(data_size))
 	if data == libc.UintptrFromInt32(0) {
 		return 0
 	}
 	if width <= 0 || height <= 0 {
 		return 0
 	}
 	if num_levels < int32(2) || num_levels > int32(256) {
 		return 0
 	}
 	num_levels_in = 0
 	n = uint64(0)
 	for {
 		if !(n < data_size) {
 			break
 		}
 		num_levels_in = num_levels_in + libc.BoolInt32(freq[**(**uint8_t)(__ccgo_up(data + uintptr(n)))] == 0)
 		if min_s > libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(data + uintptr(n)))) {
 			min_s = libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(data + uintptr(n))))
 		}
 		if max_s < libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(data + uintptr(n)))) {
 			max_s = libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(data + uintptr(n))))
 		}
 		freq[**(**uint8_t)(__ccgo_up(data + uintptr(n)))] = freq[**(**uint8_t)(__ccgo_up(data + uintptr(n)))] + 1
 		goto _1
 	_1:
 		;
 		n = n + 1
 	}
 	if num_levels_in <= num_levels {
 		goto End
 	} // nothing to do!
 	// Start with uniformly spread centroids.
 	i = 0
 	for {
 		if !(i < num_levels) {
 			break
 		}
 		inv_q_level[i] = float64(min_s) + float64(float64(max_s-min_s)*float64(i))/float64(num_levels-libc.Int32FromInt32(1))
 		goto _2
 	_2:
 		;
 		i = i + 1
 	}
 	// Fixed values. Won't be changed.
 	q_level[min_s] = 0
 	q_level[max_s] = num_levels - int32(1)
 	// k-Means iterations.
 	iter = 0
 	for {
 		if !(iter < int32(MAX_ITER)) {
 			break
 		}
 		**(**[256]float64)(__ccgo_up(bp)) = [256]float64{}
 		**(**[256]float64)(__ccgo_up(bp + 2048)) = [256]float64{}
 		slot = 0
 		// Assign classes to representatives.
 		s = min_s
 		for {
 			if !(s <= max_s) {
 				break
 			}
 			// Keep track of the nearest neighbour 'slot'
 			for slot < num_levels-int32(1) && float64(int32(2)*s) > inv_q_level[slot]+inv_q_level[slot+int32(1)] {
 				slot = slot + 1
 			}
 			if freq[s] > 0 {
 				**(**float64)(__ccgo_up(bp + uintptr(slot)*8)) += float64(s * freq[s])
 				**(**float64)(__ccgo_up(bp + 2048 + uintptr(slot)*8)) += float64(freq[s])
 			}
 			q_level[s] = slot
 			goto _4
 		_4:
 			;
 			s = s + 1
 		}
 		// Assign new representatives to classes.
 		if num_levels > int32(2) {
 			slot = int32(1)
 			for {
 				if !(slot < num_levels-int32(1)) {
 					break
 				}
 				count = (**(**[256]float64)(__ccgo_up(bp + 2048)))[slot]
 				if count > float64(0) {
 					inv_q_level[slot] = (**(**[256]float64)(__ccgo_up(bp)))[slot] / count
 				}
 				goto _5
 			_5:
 				;
 				slot = slot + 1
 			}
 		}
 		// Compute convergence error.
 		err = float64(0)
 		s = min_s
 		for {
 			if !(s <= max_s) {
 				break
 			}
 			error1 = float64(s) - inv_q_level[q_level[s]]
 			err = err + float64(float64(float64(freq[s])*error1)*error1)
 			goto _6
 		_6:
 			;
 			s = s + 1
 		}
 		// Check for convergence: we stop as soon as the error is no
 		// longer improving.
 		if last_err-err < err_threshold {
 			break
 		}
 		last_err = err
 		goto _3
 	_3:
 		;
 		iter = iter + 1
 	}
 	// Remap the alpha plane to quantized values.
 	s1 = min_s
 	for {
 		if !(s1 <= max_s) {
 			break
 		}
 		slot1 = q_level[s1]
 		map1[s1] = uint8(inv_q_level[slot1] + libc.Float64FromFloat64(0.5))
 		goto _7
 	_7:
 		;
 		s1 = s1 + 1
 	}
 	// Final pass.
 	n1 = uint64(0)
 	for {
 		if !(n1 < data_size) {
 			break
 		}
 		**(**uint8_t)(__ccgo_up(data + uintptr(n1))) = map1[**(**uint8_t)(__ccgo_up(data + uintptr(n1)))]
 		goto _8
 	_8:
 		;
 		n1 = n1 + 1
 	}
 	goto End
 End:
 	;
 	// Store sum of squared error if needed.
 	if sse != libc.UintptrFromInt32(0) {
 		**(**uint64_t)(__ccgo_up(sse)) = uint64(err)
 	}
 	return int32(1)
 }
 
 //------------------------------------------------------------------------------
 
 // C documentation
 //
 //	// 31b-range values
 var kRandomTable = [55]uint32_t{
 	0:  uint32(0x0de15230),
 	1:  uint32(0x03b31886),
 	2:  uint32(0x775faccb),
 	3:  uint32(0x1c88626a),
 	4:  uint32(0x68385c55),
 	5:  uint32(0x14b3b828),
 	6:  uint32(0x4a85fef8),
 	7:  uint32(0x49ddb84b),
 	8:  uint32(0x64fcf397),
 	9:  uint32(0x5c550289),
 	10: uint32(0x4a290000),
 	11: uint32(0x0d7ec1da),
 	12: uint32(0x5940b7ab),
 	13: uint32(0x5492577d),
 	14: uint32(0x4e19ca72),
 	15: uint32(0x38d38c69),
 	16: uint32(0x0c01ee65),
 	17: uint32(0x32a1755f),
 	18: uint32(0x5437f652),
 	19: uint32(0x5abb2c32),
 	20: uint32(0x0faa57b1),
 	21: uint32(0x73f533e7),
 	22: uint32(0x685feeda),
 	23: uint32(0x7563cce2),
 	24: uint32(0x6e990e83),
 	25: uint32(0x4730a7ed),
 	26: uint32(0x4fc0d9c6),
 	27: uint32(0x496b153c),
 	28: uint32(0x4f1403fa),
 	29: uint32(0x541afb0c),
 	30: uint32(0x73990b32),
 	31: uint32(0x26d7cb1c),
 	32: uint32(0x6fcc3706),
 	33: uint32(0x2cbb77d8),
 	34: uint32(0x75762f2a),
 	35: uint32(0x6425ccdd),
 	36: uint32(0x24b35461),
 	37: uint32(0x0a7d8715),
 	38: uint32(0x220414a8),
 	39: uint32(0x141ebf67),
 	40: uint32(0x56b41583),
 	41: uint32(0x73e502e3),
 	42: uint32(0x44cab16f),
 	43: uint32(0x28264d42),
 	44: uint32(0x73baaefb),
 	45: uint32(0x0a50ebed),
 	46: uint32(0x1d6ab6fb),
 	47: uint32(0x0d3ad40b),
 	48: uint32(0x35db3b68),
 	49: uint32(0x2b081e83),
 	50: uint32(0x77ce6b95),
 	51: uint32(0x5181e5f0),
 	52: uint32(0x78853bbc),
 	53: uint32(0x009f9494),
 	54: uint32(0x27e5ed3c),
 }
 
 func VP8InitRandom(tls *libc.TLS, rg uintptr, dithering float32) {
 	var v1, v2 uint32
 	_, _ = v1, v2
 	libc.X__builtin___memcpy_chk(tls, rg+8, uintptr(unsafe.Pointer(&kRandomTable)), uint64(220), ^__predefined_size_t(0))
 	(*VP8Random)(unsafe.Pointer(rg)).Findex1 = 0
 	(*VP8Random)(unsafe.Pointer(rg)).Findex2 = int32(31)
 	if float64(dithering) < float64(0) {
 		v1 = uint32(0)
 	} else {
 		if float64(dithering) > float64(1) {
 			v2 = libc.Uint32FromInt32(libc.Int32FromInt32(1) << libc.Int32FromInt32(VP8_RANDOM_DITHER_FIX))
 		} else {
 			v2 = uint32(float32(float32(libc.Int32FromInt32(1)<<libc.Int32FromInt32(VP8_RANDOM_DITHER_FIX)) * dithering))
 		}
 		v1 = v2
 	}
 	(*VP8Random)(unsafe.Pointer(rg)).Famp = libc.Int32FromUint32(v1)
 }
 
 const __INT_MAX__3 = 2147483647
 
 //------------------------------------------------------------------------------
 
 //------------------------------------------------------------------------------
 
 func WebPRescalerInit(tls *libc.TLS, rescaler uintptr, src_width int32, src_height int32, dst uintptr, dst_width int32, dst_height int32, dst_stride int32, num_channels int32, work uintptr) (r int32) {
 	var den, num, ratio, total_size, v1 uint64_t
 	var x_add, x_sub, y_add, y_sub, v2 int32
 	_, _, _, _, _, _, _, _, _, _ = den, num, ratio, total_size, x_add, x_sub, y_add, y_sub, v1, v2
 	x_add = src_width
 	x_sub = dst_width
 	y_add = src_height
 	y_sub = dst_height
 	total_size = uint64(2) * libc.Uint64FromInt32(dst_width) * libc.Uint64FromInt32(num_channels) * uint64(4)
 	v1 = total_size
 	v2 = libc.BoolInt32(v1 == v1)
 	goto _3
 _3:
 	if !(v2 != 0) {
 		return 0
 	}
 	(*WebPRescaler)(unsafe.Pointer(rescaler)).Fx_expand = libc.BoolInt32(src_width < dst_width)
 	(*WebPRescaler)(unsafe.Pointer(rescaler)).Fy_expand = libc.BoolInt32(src_height < dst_height)
 	(*WebPRescaler)(unsafe.Pointer(rescaler)).Fsrc_width = src_width
 	(*WebPRescaler)(unsafe.Pointer(rescaler)).Fsrc_height = src_height
 	(*WebPRescaler)(unsafe.Pointer(rescaler)).Fdst_width = dst_width
 	(*WebPRescaler)(unsafe.Pointer(rescaler)).Fdst_height = dst_height
 	(*WebPRescaler)(unsafe.Pointer(rescaler)).Fsrc_y = 0
 	(*WebPRescaler)(unsafe.Pointer(rescaler)).Fdst_y = 0
 	(*WebPRescaler)(unsafe.Pointer(rescaler)).Fdst = dst
 	(*WebPRescaler)(unsafe.Pointer(rescaler)).Fdst_stride = dst_stride
 	(*WebPRescaler)(unsafe.Pointer(rescaler)).Fnum_channels = num_channels
 	// for 'x_expand', we use bilinear interpolation
 	if (*WebPRescaler)(unsafe.Pointer(rescaler)).Fx_expand != 0 {
 		v2 = x_sub - int32(1)
 	} else {
 		v2 = x_add
 	}
 	(*WebPRescaler)(unsafe.Pointer(rescaler)).Fx_add = v2
 	if (*WebPRescaler)(unsafe.Pointer(rescaler)).Fx_expand != 0 {
 		v2 = x_add - int32(1)
 	} else {
 		v2 = x_sub
 	}
 	(*WebPRescaler)(unsafe.Pointer(rescaler)).Fx_sub = v2
 	if !((*WebPRescaler)(unsafe.Pointer(rescaler)).Fx_expand != 0) { // fx_scale is not used otherwise
 		(*WebPRescaler)(unsafe.Pointer(rescaler)).Ffx_scale = uint32(libc.Uint64FromInt32(libc.Int32FromInt32(1)) << libc.Int32FromInt32(WEBP_RESCALER_RFIX) / libc.Uint64FromInt32((*WebPRescaler)(unsafe.Pointer(rescaler)).Fx_sub))
 	}
 	// vertical scaling parameters
 	if (*WebPRescaler)(unsafe.Pointer(rescaler)).Fy_expand != 0 {
 		v2 = y_add - int32(1)
 	} else {
 		v2 = y_add
 	}
 	(*WebPRescaler)(unsafe.Pointer(rescaler)).Fy_add = v2
 	if (*WebPRescaler)(unsafe.Pointer(rescaler)).Fy_expand != 0 {
 		v2 = y_sub - int32(1)
 	} else {
 		v2 = y_sub
 	}
 	(*WebPRescaler)(unsafe.Pointer(rescaler)).Fy_sub = v2
 	if (*WebPRescaler)(unsafe.Pointer(rescaler)).Fy_expand != 0 {
 		v2 = (*WebPRescaler)(unsafe.Pointer(rescaler)).Fy_sub
 	} else {
 		v2 = (*WebPRescaler)(unsafe.Pointer(rescaler)).Fy_add
 	}
 	(*WebPRescaler)(unsafe.Pointer(rescaler)).Fy_accum = v2
 	if !((*WebPRescaler)(unsafe.Pointer(rescaler)).Fy_expand != 0) {
 		// This is WEBP_RESCALER_FRAC(dst_height, x_add * y_add) without the cast.
 		// Its value is <= WEBP_RESCALER_ONE, because dst_height <= rescaler->y_add
 		// and rescaler->x_add >= 1;
 		num = libc.Uint64FromInt32(dst_height) * (libc.Uint64FromUint64(1) << libc.Int32FromInt32(WEBP_RESCALER_RFIX))
 		den = libc.Uint64FromInt32((*WebPRescaler)(unsafe.Pointer(rescaler)).Fx_add) * libc.Uint64FromInt32((*WebPRescaler)(unsafe.Pointer(rescaler)).Fy_add)
 		ratio = num / den
 		if ratio != uint64(uint32(ratio)) {
 			// When ratio == WEBP_RESCALER_ONE, we can't represent the ratio with the
 			// current fixed-point precision. This happens when src_height ==
 			// rescaler->y_add (which == src_height), and rescaler->x_add == 1.
 			// => We special-case fxy_scale = 0, in WebPRescalerExportRow().
 			(*WebPRescaler)(unsafe.Pointer(rescaler)).Ffxy_scale = uint32(0)
 		} else {
 			(*WebPRescaler)(unsafe.Pointer(rescaler)).Ffxy_scale = uint32(ratio)
 		}
 		(*WebPRescaler)(unsafe.Pointer(rescaler)).Ffy_scale = uint32(libc.Uint64FromInt32(libc.Int32FromInt32(1)) << libc.Int32FromInt32(WEBP_RESCALER_RFIX) / libc.Uint64FromInt32((*WebPRescaler)(unsafe.Pointer(rescaler)).Fy_sub))
 	} else {
 		(*WebPRescaler)(unsafe.Pointer(rescaler)).Ffy_scale = uint32(libc.Uint64FromInt32(libc.Int32FromInt32(1)) << libc.Int32FromInt32(WEBP_RESCALER_RFIX) / libc.Uint64FromInt32((*WebPRescaler)(unsafe.Pointer(rescaler)).Fx_add))
 		// rescaler->fxy_scale is unused here.
 	}
 	(*WebPRescaler)(unsafe.Pointer(rescaler)).Firow = work
 	(*WebPRescaler)(unsafe.Pointer(rescaler)).Ffrow = work + uintptr(num_channels*dst_width)*4
 	libc.X__builtin___memset_chk(tls, work, 0, total_size, ^__predefined_size_t(0))
 	WebPRescalerDspInit(tls)
 	return int32(1)
 }
 
 func WebPRescalerGetScaledDimensions(tls *libc.TLS, src_width int32, src_height int32, scaled_width uintptr, scaled_height uintptr) (r int32) {
 	var height, max_size, width int32
 	_, _, _ = height, max_size, width
 	width = **(**int32)(__ccgo_up(scaled_width))
 	height = **(**int32)(__ccgo_up(scaled_height))
 	max_size = libc.Int32FromInt32(__INT_MAX__3) / libc.Int32FromInt32(2)
 	// if width is unspecified, scale original proportionally to height ratio.
 	if width == 0 && src_height > 0 {
 		width = libc.Int32FromUint64((libc.Uint64FromInt32(src_width)*libc.Uint64FromInt32(height) + libc.Uint64FromInt32(src_height) - libc.Uint64FromInt32(1)) / libc.Uint64FromInt32(src_height))
 	}
 	// if height is unspecified, scale original proportionally to width ratio.
 	if height == 0 && src_width > 0 {
 		height = libc.Int32FromUint64((libc.Uint64FromInt32(src_height)*libc.Uint64FromInt32(width) + libc.Uint64FromInt32(src_width) - libc.Uint64FromInt32(1)) / libc.Uint64FromInt32(src_width))
 	}
 	// Check if the overall dimensions still make sense.
 	if width <= 0 || height <= 0 || width > max_size || height > max_size {
 		return 0
 	}
 	**(**int32)(__ccgo_up(scaled_width)) = width
 	**(**int32)(__ccgo_up(scaled_height)) = height
 	return int32(1)
 	return r
 }
 
 //------------------------------------------------------------------------------
 // all-in-one calls
 
 func WebPRescaleNeededLines(tls *libc.TLS, rescaler uintptr, max_num_lines int32) (r int32) {
 	var num_lines, v1 int32
 	_, _ = num_lines, v1
 	num_lines = ((*WebPRescaler)(unsafe.Pointer(rescaler)).Fy_accum + (*WebPRescaler)(unsafe.Pointer(rescaler)).Fy_sub - int32(1)) / (*WebPRescaler)(unsafe.Pointer(rescaler)).Fy_sub
 	if num_lines > max_num_lines {
 		v1 = max_num_lines
 	} else {
 		v1 = num_lines
 	}
 	return v1
 }
 
 func WebPRescalerImport(tls *libc.TLS, rescaler2 uintptr, num_lines int32, src uintptr, src_stride int32) (r int32) {
 	var tmp, v1, v4 uintptr
 	var total_imported, x, v2, v5 int32
 	var v7 bool
 	_, _, _, _, _, _, _, _ = tmp, total_imported, x, v1, v2, v4, v5, v7
 	total_imported = 0
 	for {
 		if v7 = total_imported < num_lines; v7 {
 			v1 = rescaler2
 			v4 = v1
 			v5 = libc.BoolInt32((*WebPRescaler)(unsafe.Pointer(v4)).Fdst_y >= (*WebPRescaler)(unsafe.Pointer(v4)).Fdst_height)
 			goto _6
 		_6:
 			;
 			v2 = libc.BoolInt32(!(v5 != 0) && (*WebPRescaler)(unsafe.Pointer(v1)).Fy_accum <= 0)
 			goto _3
 		_3:
 		}
 		if !(v7 && !(v2 != 0)) {
 			break
 		}
 		if (*WebPRescaler)(unsafe.Pointer(rescaler2)).Fy_expand != 0 {
 			tmp = (*WebPRescaler)(unsafe.Pointer(rescaler2)).Firow
 			(*WebPRescaler)(unsafe.Pointer(rescaler2)).Firow = (*WebPRescaler)(unsafe.Pointer(rescaler2)).Ffrow
 			(*WebPRescaler)(unsafe.Pointer(rescaler2)).Ffrow = tmp
 		}
 		WebPRescalerImportRow(tls, rescaler2, src)
 		if !((*WebPRescaler)(unsafe.Pointer(rescaler2)).Fy_expand != 0) {
 			x = 0
 			for {
 				if !(x < (*WebPRescaler)(unsafe.Pointer(rescaler2)).Fnum_channels*(*WebPRescaler)(unsafe.Pointer(rescaler2)).Fdst_width) {
 					break
 				}
 				**(**rescaler_t)(__ccgo_up((*WebPRescaler)(unsafe.Pointer(rescaler2)).Firow + uintptr(x)*4)) += **(**rescaler_t)(__ccgo_up((*WebPRescaler)(unsafe.Pointer(rescaler2)).Ffrow + uintptr(x)*4))
 				goto _8
 			_8:
 				;
 				x = x + 1
 			}
 		}
 		(*WebPRescaler)(unsafe.Pointer(rescaler2)).Fsrc_y = (*WebPRescaler)(unsafe.Pointer(rescaler2)).Fsrc_y + 1
 		src = src + uintptr(src_stride)
 		total_imported = total_imported + 1
 		**(**int32)(__ccgo_up(rescaler2 + 24)) -= (*WebPRescaler)(unsafe.Pointer(rescaler2)).Fy_sub
 	}
 	return total_imported
 }
 
 func WebPRescalerExport(tls *libc.TLS, rescaler2 uintptr) (r int32) {
 	var total_exported, v2, v5 int32
 	var v1, v4 uintptr
 	_, _, _, _, _ = total_exported, v1, v2, v4, v5
 	total_exported = 0
 	for {
 		v1 = rescaler2
 		v4 = v1
 		v5 = libc.BoolInt32((*WebPRescaler)(unsafe.Pointer(v4)).Fdst_y >= (*WebPRescaler)(unsafe.Pointer(v4)).Fdst_height)
 		goto _6
 	_6:
 		;
 		v2 = libc.BoolInt32(!(v5 != 0) && (*WebPRescaler)(unsafe.Pointer(v1)).Fy_accum <= 0)
 		goto _3
 	_3:
 		if !(v2 != 0) {
 			break
 		}
 		WebPRescalerExportRow(tls, rescaler2)
 		total_exported = total_exported + 1
 	}
 	return total_exported
 }
 
 const __INT_MAX__4 = 0x7fffffff
 
 //------------------------------------------------------------------------------
 
 //------------------------------------------------------------------------------
 
 func Init(tls *libc.TLS, worker uintptr) {
 	libc.X__builtin___memset_chk(tls, worker, 0, uint64(48), ^__predefined_size_t(0))
 	(*WebPWorker)(unsafe.Pointer(worker)).Fstatus = int32(NOT_OK)
 }
 
 func Sync(tls *libc.TLS, worker uintptr) (r int32) {
 	return libc.BoolInt32(!((*WebPWorker)(unsafe.Pointer(worker)).Fhad_error != 0))
 }
 
 func Reset(tls *libc.TLS, worker uintptr) (r int32) {
 	var ok int32
 	_ = ok
 	ok = int32(1)
 	(*WebPWorker)(unsafe.Pointer(worker)).Fhad_error = 0
 	if (*WebPWorker)(unsafe.Pointer(worker)).Fstatus < int32(OK) {
 		(*WebPWorker)(unsafe.Pointer(worker)).Fstatus = int32(OK)
 	} else {
 		if (*WebPWorker)(unsafe.Pointer(worker)).Fstatus > int32(OK) {
 			ok = Sync(tls, worker)
 		}
 	}
 	return ok
 }
 
 func Execute(tls *libc.TLS, worker uintptr) {
 	if (*WebPWorker)(unsafe.Pointer(worker)).Fhook != libc.UintptrFromInt32(0) {
 		**(**int32)(__ccgo_up(worker + 40)) |= libc.BoolInt32(!((*(*func(*libc.TLS, uintptr, uintptr) int32)(unsafe.Pointer(&struct{ uintptr }{(*WebPWorker)(unsafe.Pointer(worker)).Fhook})))(tls, (*WebPWorker)(unsafe.Pointer(worker)).Fdata1, (*WebPWorker)(unsafe.Pointer(worker)).Fdata2) != 0))
 	}
 }
 
 func Launch(tls *libc.TLS, worker uintptr) {
 	Execute(tls, worker)
 }
 
 func End(tls *libc.TLS, worker uintptr) {
 	(*WebPWorker)(unsafe.Pointer(worker)).Fstatus = int32(NOT_OK)
 }
 
 //------------------------------------------------------------------------------
 
 var g_worker_interface = WebPWorkerInterface{}
 
 func init() {
 	p := unsafe.Pointer(&g_worker_interface)
 	*(*uintptr)(unsafe.Add(p, 0)) = __ccgo_fp(Init)
 	*(*uintptr)(unsafe.Add(p, 8)) = __ccgo_fp(Reset)
 	*(*uintptr)(unsafe.Add(p, 16)) = __ccgo_fp(Sync)
 	*(*uintptr)(unsafe.Add(p, 24)) = __ccgo_fp(Launch)
 	*(*uintptr)(unsafe.Add(p, 32)) = __ccgo_fp(Execute)
 	*(*uintptr)(unsafe.Add(p, 40)) = __ccgo_fp(End)
 }
 
 func WebPSetWorkerInterface(tls *libc.TLS, winterface uintptr) (r int32) {
 	if winterface == libc.UintptrFromInt32(0) || (*WebPWorkerInterface)(unsafe.Pointer(winterface)).FInit == libc.UintptrFromInt32(0) || (*WebPWorkerInterface)(unsafe.Pointer(winterface)).FReset == libc.UintptrFromInt32(0) || (*WebPWorkerInterface)(unsafe.Pointer(winterface)).FSync == libc.UintptrFromInt32(0) || (*WebPWorkerInterface)(unsafe.Pointer(winterface)).FLaunch == libc.UintptrFromInt32(0) || (*WebPWorkerInterface)(unsafe.Pointer(winterface)).FExecute == libc.UintptrFromInt32(0) || (*WebPWorkerInterface)(unsafe.Pointer(winterface)).FEnd == libc.UintptrFromInt32(0) {
 		return 0
 	}
 	g_worker_interface = **(**WebPWorkerInterface)(__ccgo_up(winterface))
 	return int32(1)
 }
 
 func WebPGetWorkerInterface(tls *libc.TLS) (r uintptr) {
 	return uintptr(unsafe.Pointer(&g_worker_interface))
 }
 
 //------------------------------------------------------------------------------
 
 // If PRINT_MEM_INFO is defined, extra info (like total memory used, number of
 // alloc/free etc) is printed. For debugging/tuning purpose only (it's slow,
 // and not multi-thread safe!).
 // An interesting alternative is valgrind's 'massif' tool:
 //    https://valgrind.org/docs/manual/ms-manual.html
 // Here is an example command line:
 /*    valgrind --tool=massif --massif-out-file=massif.out                --stacks=yes --alloc-fn=WebPSafeMalloc --alloc-fn=WebPSafeCalloc
       ms_print massif.out
 */
 // In addition:
 // * if PRINT_MEM_TRAFFIC is defined, all the details of the malloc/free cycles
 //   are printed.
 // * if MALLOC_FAIL_AT is defined, the global environment variable
 //   $MALLOC_FAIL_AT is used to simulate a memory error when calloc or malloc
 //   is called for the nth time. Example usage:
 //   export MALLOC_FAIL_AT=50 && ./examples/cwebp input.png
 // * if MALLOC_LIMIT is defined, the global environment variable $MALLOC_LIMIT
 //   sets the maximum amount of memory (in bytes) made available to libwebp.
 //   This can be used to emulate environment with very limited memory.
 //   Example: export MALLOC_LIMIT=64000000 && ./examples/dwebp picture.webp
 
 // #define PRINT_MEM_INFO
 // #define PRINT_MEM_TRAFFIC
 // #define MALLOC_FAIL_AT
 // #define MALLOC_LIMIT
 
 //------------------------------------------------------------------------------
 // Checked memory allocation
 
 // C documentation
 //
 //	// Returns 0 in case of overflow of nmemb * size.
 func CheckSizeArgumentsOverflow(tls *libc.TLS, nmemb uint64_t, size1 size_t) (r int32) {
 	var total_size, v1 uint64_t
 	var v2 int32
 	_, _, _ = total_size, v1, v2
 	total_size = nmemb * size1
 	if nmemb == uint64(0) {
 		return int32(1)
 	}
 	if size1 > libc.Uint64FromUint64(1)<<libc.Int32FromInt32(34)/nmemb {
 		return 0
 	}
 	v1 = total_size
 	v2 = libc.BoolInt32(v1 == v1)
 	goto _3
 _3:
 	if !(v2 != 0) {
 		return 0
 	}
 	return int32(1)
 }
 
 func WebPSafeMalloc(tls *libc.TLS, nmemb uint64_t, size size_t) (r uintptr) {
 	var ptr uintptr
 	_ = ptr
 	if !(CheckSizeArgumentsOverflow(tls, nmemb, size) != 0) {
 		return libc.UintptrFromInt32(0)
 	}
 	ptr = libc.Xmalloc(tls, nmemb*size)
 	return ptr
 }
 
 func WebPSafeCalloc(tls *libc.TLS, nmemb uint64_t, size size_t) (r uintptr) {
 	var ptr uintptr
 	_ = ptr
 	if !(CheckSizeArgumentsOverflow(tls, nmemb, size) != 0) {
 		return libc.UintptrFromInt32(0)
 	}
 	ptr = libc.Xcalloc(tls, nmemb, size)
 	return ptr
 }
 
 func WebPSafeFree(tls *libc.TLS, ptr uintptr) {
 	if ptr != libc.UintptrFromInt32(0) {
 	}
 	libc.Xfree(tls, ptr)
 }
 
 // Public API functions.
 
 func WebPMalloc(tls *libc.TLS, size size_t) (r uintptr) {
 	return WebPSafeMalloc(tls, uint64(1), size)
 }
 
 func WebPFree(tls *libc.TLS, ptr uintptr) {
 	WebPSafeFree(tls, ptr)
 }
 
 //------------------------------------------------------------------------------
 
 func WebPCopyPlane(tls *libc.TLS, src uintptr, src_stride int32, dst uintptr, dst_stride int32, width int32, height int32) {
 	var v1 int32
 	_ = v1
 	for {
 		v1 = height
 		height = height - 1
 		if !(v1 > 0) {
 			break
 		}
 		libc.X__builtin___memcpy_chk(tls, dst, src, libc.Uint64FromInt32(width), ^__predefined_size_t(0))
 		src = src + uintptr(src_stride)
 		dst = dst + uintptr(dst_stride)
 	}
 }
 
 func WebPCopyPixels(tls *libc.TLS, src uintptr, dst uintptr) {
 	WebPCopyPlane(tls, (*WebPPicture)(unsafe.Pointer(src)).Fargb, int32(4)*(*WebPPicture)(unsafe.Pointer(src)).Fargb_stride, (*WebPPicture)(unsafe.Pointer(dst)).Fargb, int32(4)*(*WebPPicture)(unsafe.Pointer(dst)).Fargb_stride, int32(4)*(*WebPPicture)(unsafe.Pointer(src)).Fwidth, (*WebPPicture)(unsafe.Pointer(src)).Fheight)
 }
 
 //------------------------------------------------------------------------------
 
 func WebPGetColorPalette(tls *libc.TLS, pic uintptr, palette uintptr) (r int32) {
 	return GetColorPalette(tls, pic, palette)
 }
 
 const USE_TABLES_FOR_ALPHA_MULT = 0
 
 // Copyright 2010 Google Inc. All Rights Reserved.
 //
 // Use of this source code is governed by a BSD-style license
 // that can be found in the COPYING file in the root of the source
 // tree. An additional intellectual property rights grant can be found
 // in the file PATENTS. All contributing project authors may
 // be found in the AUTHORS file in the root of the source tree.
 // -----------------------------------------------------------------------------
 //
 //  Common types + memory wrappers
 //
 // Author: Skal (pascal.massimino@gmail.com)
 
 // Tables can be faster on some platform but incur some extra binary size (~2k).
 
 // -----------------------------------------------------------------------------
 
 func Mult(tls *libc.TLS, x uint8_t, mult uint32_t) (r uint32_t) {
 	var v uint32_t
 	_ = v
 	v = (uint32(x)*mult + libc.Uint32FromUint32(1)<<libc.Int32FromInt32(24)>>libc.Int32FromInt32(1)) >> int32(24)
 	// <- 24bit precision is enough to ensure that.
 	return v
 }
 
 func GetScale(tls *libc.TLS, a uint32_t, inverse int32) (r uint32_t) {
 	var v1 uint32
 	_ = v1
 	if inverse != 0 {
 		v1 = libc.Uint32FromUint32(255) << libc.Int32FromInt32(24) / a
 	} else {
 		v1 = a * (libc.Uint32FromUint32(1) << libc.Int32FromInt32(24) / libc.Uint32FromUint32(255))
 	}
 	return v1
 }
 
 func WebPMultARGBRow_C(tls *libc.TLS, ptr uintptr, width int32, inverse int32) {
 	var alpha, argb, out, scale uint32_t
 	var x int32
 	_, _, _, _, _ = alpha, argb, out, scale, x
 	x = 0
 	for {
 		if !(x < width) {
 			break
 		}
 		argb = **(**uint32_t)(__ccgo_up(ptr + uintptr(x)*4))
 		if argb < uint32(0xff000000) { // alpha < 255
 			if argb <= uint32(0x00ffffff) { // alpha == 0
 				**(**uint32_t)(__ccgo_up(ptr + uintptr(x)*4)) = uint32(0)
 			} else {
 				alpha = argb >> libc.Int32FromInt32(24) & uint32(0xff)
 				scale = GetScale(tls, alpha, inverse)
 				out = argb & uint32(0xff000000)
 				out = out | Mult(tls, uint8(argb>>0), scale)<<0
 				out = out | Mult(tls, uint8(argb>>int32(8)), scale)<<int32(8)
 				out = out | Mult(tls, uint8(argb>>int32(16)), scale)<<int32(16)
 				**(**uint32_t)(__ccgo_up(ptr + uintptr(x)*4)) = out
 			}
 		}
 		goto _1
 	_1:
 		;
 		x = x + 1
 	}
 }
 
 func WebPMultRow_C(tls *libc.TLS, ptr uintptr, alpha uintptr, width int32, inverse int32) {
 	var a, scale uint32_t
 	var x int32
 	_, _, _ = a, scale, x
 	x = 0
 	for {
 		if !(x < width) {
 			break
 		}
 		a = uint32(**(**uint8_t)(__ccgo_up(alpha + uintptr(x))))
 		if a != uint32(255) {
 			if a == uint32(0) {
 				**(**uint8_t)(__ccgo_up(ptr + uintptr(x))) = uint8(0)
 			} else {
 				scale = GetScale(tls, a, inverse)
 				**(**uint8_t)(__ccgo_up(ptr + uintptr(x))) = uint8(Mult(tls, **(**uint8_t)(__ccgo_up(ptr + uintptr(x))), scale))
 			}
 		}
 		goto _1
 	_1:
 		;
 		x = x + 1
 	}
 }
 
 //------------------------------------------------------------------------------
 // Generic per-plane calls
 
 func WebPMultARGBRows(tls *libc.TLS, ptr uintptr, stride int32, width int32, num_rows int32, inverse int32) {
 	var n int32
 	_ = n
 	n = 0
 	for {
 		if !(n < num_rows) {
 			break
 		}
 		(*(*func(*libc.TLS, uintptr, int32, int32))(unsafe.Pointer(&struct{ uintptr }{WebPMultARGBRow})))(tls, ptr, width, inverse)
 		ptr = ptr + uintptr(stride)
 		goto _1
 	_1:
 		;
 		n = n + 1
 	}
 }
 
 func WebPMultRows(tls *libc.TLS, ptr uintptr, stride int32, alpha uintptr, alpha_stride int32, width int32, num_rows int32, inverse int32) {
 	var n int32
 	_ = n
 	n = 0
 	for {
 		if !(n < num_rows) {
 			break
 		}
 		(*(*func(*libc.TLS, uintptr, uintptr, int32, int32))(unsafe.Pointer(&struct{ uintptr }{WebPMultRow})))(tls, ptr, alpha, width, inverse)
 		ptr = ptr + uintptr(stride)
 		alpha = alpha + uintptr(alpha_stride)
 		goto _1
 	_1:
 		;
 		n = n + 1
 	}
 }
 
 //------------------------------------------------------------------------------
 // Premultiplied modes
 
 // non dithered-modes
 
 // (x * a * 32897) >> 23 is bit-wise equivalent to (int)(x * a / 255.)
 // for all 8bit x or a. For bit-wise equivalence to (int)(x * a / 255. + .5),
 // one can use instead: (x * a * 65793 + (1 << 23)) >> 24
 
 func ApplyAlphaMultiply_C(tls *libc.TLS, rgba uintptr, alpha_first int32, w int32, h int32, stride int32) {
 	var a, mult uint32_t
 	var alpha, rgb uintptr
 	var i, v1, v2, v3 int32
 	_, _, _, _, _, _, _, _ = a, alpha, i, mult, rgb, v1, v2, v3
 	for {
 		v1 = h
 		h = h - 1
 		if !(v1 > 0) {
 			break
 		}
 		if alpha_first != 0 {
 			v2 = int32(1)
 		} else {
 			v2 = 0
 		}
 		rgb = rgba + uintptr(v2)
 		if alpha_first != 0 {
 			v3 = 0
 		} else {
 			v3 = int32(3)
 		}
 		alpha = rgba + uintptr(v3)
 		i = 0
 		for {
 			if !(i < w) {
 				break
 			}
 			a = uint32(**(**uint8_t)(__ccgo_up(alpha + uintptr(int32(4)*i))))
 			if a != uint32(0xff) {
 				mult = a * libc.Uint32FromUint32(32897)
 				**(**uint8_t)(__ccgo_up(rgb + uintptr(int32(4)*i+0))) = uint8(uint32(**(**uint8_t)(__ccgo_up(rgb + uintptr(int32(4)*i+0)))) * mult >> libc.Int32FromInt32(23))
 				**(**uint8_t)(__ccgo_up(rgb + uintptr(int32(4)*i+int32(1)))) = uint8(uint32(**(**uint8_t)(__ccgo_up(rgb + uintptr(int32(4)*i+int32(1))))) * mult >> libc.Int32FromInt32(23))
 				**(**uint8_t)(__ccgo_up(rgb + uintptr(int32(4)*i+int32(2)))) = uint8(uint32(**(**uint8_t)(__ccgo_up(rgb + uintptr(int32(4)*i+int32(2))))) * mult >> libc.Int32FromInt32(23))
 			}
 			goto _4
 		_4:
 			;
 			i = i + 1
 		}
 		rgba = rgba + uintptr(stride)
 	}
 }
 
 // rgbA4444
 
 func dither_hi(tls *libc.TLS, x uint8_t) (r uint8_t) {
 	return libc.Uint8FromInt32(libc.Int32FromUint8(x)&int32(0xf0) | libc.Int32FromUint8(x)>>int32(4))
 }
 
 func dither_lo(tls *libc.TLS, x uint8_t) (r uint8_t) {
 	return libc.Uint8FromInt32(libc.Int32FromUint8(x)&int32(0x0f) | libc.Int32FromUint8(x)<<int32(4))
 }
 
 func multiply(tls *libc.TLS, x uint8_t, m uint32_t) (r uint8_t) {
 	return uint8(uint32(x) * m >> int32(16))
 }
 
 func ApplyAlphaMultiply4444_C(tls *libc.TLS, rgba4444 uintptr, w int32, h int32, stride int32, rg_byte_pos int32) {
 	var a, b, g, r uint8_t
 	var ba, mult, rg uint32_t
 	var i, v1 int32
 	_, _, _, _, _, _, _, _, _ = a, b, ba, g, i, mult, r, rg, v1
 	for {
 		v1 = h
 		h = h - 1
 		if !(v1 > 0) {
 			break
 		}
 		i = 0
 		for {
 			if !(i < w) {
 				break
 			}
 			rg = uint32(**(**uint8_t)(__ccgo_up(rgba4444 + uintptr(int32(2)*i+rg_byte_pos))))
 			ba = uint32(**(**uint8_t)(__ccgo_up(rgba4444 + uintptr(int32(2)*i+(rg_byte_pos^int32(1))))))
 			a = uint8(ba & uint32(0x0f))
 			mult = libc.Uint32FromInt32(libc.Int32FromUint8(a) * libc.Int32FromInt32(0x1111))
 			r = multiply(tls, dither_hi(tls, uint8(rg)), mult)
 			g = multiply(tls, dither_lo(tls, uint8(rg)), mult)
 			b = multiply(tls, dither_hi(tls, uint8(ba)), mult)
 			**(**uint8_t)(__ccgo_up(rgba4444 + uintptr(int32(2)*i+rg_byte_pos))) = libc.Uint8FromInt32(libc.Int32FromUint8(r)&int32(0xf0) | libc.Int32FromUint8(g)>>int32(4)&int32(0x0f))
 			**(**uint8_t)(__ccgo_up(rgba4444 + uintptr(int32(2)*i+(rg_byte_pos^int32(1))))) = libc.Uint8FromInt32(libc.Int32FromUint8(b)&int32(0xf0) | libc.Int32FromUint8(a))
 			goto _2
 		_2:
 			;
 			i = i + 1
 		}
 		rgba4444 = rgba4444 + uintptr(stride)
 	}
 }
 
 func ApplyAlphaMultiply_16b_C(tls *libc.TLS, rgba4444 uintptr, w int32, h int32, stride int32) {
 	ApplyAlphaMultiply4444_C(tls, rgba4444, w, h, stride, 0)
 }
 
 func DispatchAlpha_C(tls *libc.TLS, alpha uintptr, alpha_stride int32, width int32, height int32, dst uintptr, dst_stride int32) (r int32) {
 	var alpha_mask, alpha_value uint32_t
 	var i, j int32
 	_, _, _, _ = alpha_mask, alpha_value, i, j
 	alpha_mask = uint32(0xff)
 	j = 0
 	for {
 		if !(j < height) {
 			break
 		}
 		i = 0
 		for {
 			if !(i < width) {
 				break
 			}
 			alpha_value = uint32(**(**uint8_t)(__ccgo_up(alpha + uintptr(i))))
 			**(**uint8_t)(__ccgo_up(dst + uintptr(int32(4)*i))) = uint8(alpha_value)
 			alpha_mask = alpha_mask & alpha_value
 			goto _2
 		_2:
 			;
 			i = i + 1
 		}
 		alpha = alpha + uintptr(alpha_stride)
 		dst = dst + uintptr(dst_stride)
 		goto _1
 	_1:
 		;
 		j = j + 1
 	}
 	return libc.BoolInt32(alpha_mask != uint32(0xff))
 }
 
 func DispatchAlphaToGreen_C(tls *libc.TLS, alpha uintptr, alpha_stride int32, width int32, height int32, dst uintptr, dst_stride int32) {
 	var i, j int32
 	_, _ = i, j
 	j = 0
 	for {
 		if !(j < height) {
 			break
 		}
 		i = 0
 		for {
 			if !(i < width) {
 				break
 			}
 			**(**uint32_t)(__ccgo_up(dst + uintptr(i)*4)) = libc.Uint32FromInt32(libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(alpha + uintptr(i)))) << int32(8)) // leave A/R/B channels zero'd.
 			goto _2
 		_2:
 			;
 			i = i + 1
 		}
 		alpha = alpha + uintptr(alpha_stride)
 		dst = dst + uintptr(dst_stride)*4
 		goto _1
 	_1:
 		;
 		j = j + 1
 	}
 }
 
 func ExtractAlpha_C(tls *libc.TLS, argb uintptr, argb_stride int32, width int32, height int32, alpha uintptr, alpha_stride int32) (r int32) {
 	var alpha_mask, alpha_value uint8_t
 	var i, j int32
 	_, _, _, _ = alpha_mask, alpha_value, i, j
 	alpha_mask = uint8(0xff)
 	j = 0
 	for {
 		if !(j < height) {
 			break
 		}
 		i = 0
 		for {
 			if !(i < width) {
 				break
 			}
 			alpha_value = **(**uint8_t)(__ccgo_up(argb + uintptr(int32(4)*i)))
 			**(**uint8_t)(__ccgo_up(alpha + uintptr(i))) = alpha_value
 			alpha_mask = libc.Uint8FromInt32(int32(alpha_mask) & libc.Int32FromUint8(alpha_value))
 			goto _2
 		_2:
 			;
 			i = i + 1
 		}
 		argb = argb + uintptr(argb_stride)
 		alpha = alpha + uintptr(alpha_stride)
 		goto _1
 	_1:
 		;
 		j = j + 1
 	}
 	return libc.BoolInt32(libc.Int32FromUint8(alpha_mask) == int32(0xff))
 }
 
 func ExtractGreen_C(tls *libc.TLS, argb uintptr, alpha uintptr, size int32) {
 	var i int32
 	_ = i
 	i = 0
 	for {
 		if !(i < size) {
 			break
 		}
 		**(**uint8_t)(__ccgo_up(alpha + uintptr(i))) = uint8(**(**uint32_t)(__ccgo_up(argb + uintptr(i)*4)) >> int32(8))
 		goto _1
 	_1:
 		;
 		i = i + 1
 	}
 }
 
 //------------------------------------------------------------------------------
 
 func HasAlpha8b_C(tls *libc.TLS, src uintptr, length int32) (r int32) {
 	var v1 int32
 	var v2 uintptr
 	_, _ = v1, v2
 	for {
 		v1 = length
 		length = length - 1
 		if !(v1 > 0) {
 			break
 		}
 		v2 = src
 		src = src + 1
 		if libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(v2))) != int32(0xff) {
 			return int32(1)
 		}
 	}
 	return 0
 }
 
 func HasAlpha32b_C(tls *libc.TLS, src uintptr, length int32) (r int32) {
 	var x, v2 int32
 	_, _ = x, v2
 	x = 0
 	for {
 		v2 = length
 		length = length - 1
 		if !(v2 > 0) {
 			break
 		}
 		if libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(src + uintptr(x)))) != int32(0xff) {
 			return int32(1)
 		}
 		goto _1
 	_1:
 		;
 		x = x + int32(4)
 	}
 	return 0
 }
 
 func AlphaReplace_C(tls *libc.TLS, src uintptr, length int32, color uint32_t) {
 	var x int32
 	_ = x
 	x = 0
 	for {
 		if !(x < length) {
 			break
 		}
 		if **(**uint32_t)(__ccgo_up(src + uintptr(x)*4))>>libc.Int32FromInt32(24) == uint32(0) {
 			**(**uint32_t)(__ccgo_up(src + uintptr(x)*4)) = color
 		}
 		goto _1
 	_1:
 		;
 		x = x + 1
 	}
 }
 
 //------------------------------------------------------------------------------
 // Simple channel manipulations.
 
 func MakeARGB321(tls *libc.TLS, a int32, r int32, g int32, b int32) (r1 uint32_t) {
 	return libc.Uint32FromInt32(a)<<libc.Int32FromInt32(24) | libc.Uint32FromInt32(r<<libc.Int32FromInt32(16)) | libc.Uint32FromInt32(g<<libc.Int32FromInt32(8)) | libc.Uint32FromInt32(b)
 }
 
 func PackRGB_C(tls *libc.TLS, r uintptr, g uintptr, b uintptr, len1 int32, step int32, out uintptr) {
 	var i, offset int32
 	_, _ = i, offset
 	offset = 0
 	i = 0
 	for {
 		if !(i < len1) {
 			break
 		}
 		**(**uint32_t)(__ccgo_up(out + uintptr(i)*4)) = MakeARGB321(tls, int32(0xff), libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(r + uintptr(offset)))), libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(g + uintptr(offset)))), libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(b + uintptr(offset)))))
 		offset = offset + step
 		goto _1
 	_1:
 		;
 		i = i + 1
 	}
 }
 
 func WebPInitAlphaProcessing(tls *libc.TLS) {
 	if libc.AtomicLoadPUintptr(uintptr(unsafe.Pointer(&WebPInitAlphaProcessing_body_last_cpuinfo_used))) == VP8GetCPUInfo {
 		goto _1
 	}
 	WebPInitAlphaProcessing_body(tls)
 	libc.AtomicStorePUintptr(uintptr(unsafe.Pointer(&WebPInitAlphaProcessing_body_last_cpuinfo_used)), VP8GetCPUInfo)
 	goto _2
 _2:
 	;
 	goto _1
 _1: /**/ //
 }
 
 var WebPInitAlphaProcessing_body_last_cpuinfo_used = uintptr(0)
 
 func init() {
 	p := unsafe.Pointer(&WebPInitAlphaProcessing_body_last_cpuinfo_used)
 	*(*uintptr)(unsafe.Add(p, 0)) = uintptr(unsafe.Pointer(&WebPInitAlphaProcessing_body_last_cpuinfo_used))
 }
 
 func WebPInitAlphaProcessing_body(tls *libc.TLS) {
 	WebPMultARGBRow = __ccgo_fp(WebPMultARGBRow_C)
 	WebPMultRow = __ccgo_fp(WebPMultRow_C)
 	WebPApplyAlphaMultiply4444 = __ccgo_fp(ApplyAlphaMultiply_16b_C)
 	WebPPackRGB = __ccgo_fp(PackRGB_C)
 	WebPApplyAlphaMultiply = __ccgo_fp(ApplyAlphaMultiply_C)
 	WebPDispatchAlpha = __ccgo_fp(DispatchAlpha_C)
 	WebPDispatchAlphaToGreen = __ccgo_fp(DispatchAlphaToGreen_C)
 	WebPExtractAlpha = __ccgo_fp(ExtractAlpha_C)
 	WebPExtractGreen = __ccgo_fp(ExtractGreen_C)
 	WebPHasAlpha8b = __ccgo_fp(HasAlpha8b_C)
 	WebPHasAlpha32b = __ccgo_fp(HasAlpha32b_C)
 	WebPAlphaReplace = __ccgo_fp(AlphaReplace_C)
 	// If defined, use CPUInfo() to overwrite some pointers with faster versions.
 	if VP8GetCPUInfo != libc.UintptrFromInt32(0) {
 	}
 }
 
 func WebPInitAlphaProcessingMIPSdspR2(tls *libc.TLS) {
 }
 
 func WebPInitAlphaProcessingNEON(tls *libc.TLS) {
 }
 
 func WebPInitAlphaProcessingSSE2(tls *libc.TLS) {
 }
 
 func WebPInitAlphaProcessingSSE41(tls *libc.TLS) {
 }
 
 //------------------------------------------------------------------------------
 // Mode costs
 
 func GetResidualCost_C(tls *libc.TLS, ctx0 int32, res uintptr) (r int32) {
 	var b, cost, ctx, ctx1, last_p0, n, p0, v, v1, v11, v3, v5, v7, v9 int32
 	var costs CostArrayPtr
 	var t uintptr
 	var v2, v6 uint8_t
 	_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = b, cost, costs, ctx, ctx1, last_p0, n, p0, t, v, v1, v11, v2, v3, v5, v6, v7, v9
 	n = (*VP8Residual)(unsafe.Pointer(res)).Ffirst
 	// should be prob[VP8EncBands[n]], but it's equivalent for n=0 or 1
 	p0 = libc.Int32FromUint8(**(**uint8_t)(__ccgo_up((*VP8Residual)(unsafe.Pointer(res)).Fprob + uintptr(n)*33 + uintptr(ctx0)*11)))
 	costs = (*VP8Residual)(unsafe.Pointer(res)).Fcosts
 	t = **(**uintptr)(__ccgo_up(costs + uintptr(n)*24 + uintptr(ctx0)*8))
 	if ctx0 == 0 {
 		v2 = libc.Uint8FromInt32(p0)
 		if !(int32(1) != 0) {
 			v5 = libc.Int32FromUint16(VP8EntropyCost[v2])
 		} else {
 			v5 = libc.Int32FromUint16(VP8EntropyCost[int32(255)-libc.Int32FromUint8(v2)])
 		}
 		v3 = v5
 		goto _4
 	_4:
 		v11 = v3
 	} else {
 		v11 = 0
 	}
 	// bit_cost(1, p0) is already incorporated in t[] tables, but only if ctx != 0
 	// (as required by the syntax). For ctx0 == 0, we need to add it here or it'll
 	// be missing during the loop.
 	cost = v11
 	if (*VP8Residual)(unsafe.Pointer(res)).Flast < 0 {
 		v6 = libc.Uint8FromInt32(p0)
 		if !(0 != 0) {
 			v9 = libc.Int32FromUint16(VP8EntropyCost[v6])
 		} else {
 			v9 = libc.Int32FromUint16(VP8EntropyCost[int32(255)-libc.Int32FromUint8(v6)])
 		}
 		v7 = v9
 		goto _8
 	_8:
 		return v7
 	}
 	for {
 		if !(n < (*VP8Residual)(unsafe.Pointer(res)).Flast) {
 			break
 		}
 		v = libc.Xabs(tls, int32(**(**int16_t)(__ccgo_up((*VP8Residual)(unsafe.Pointer(res)).Fcoeffs + uintptr(n)*2))))
 		if v >= int32(2) {
 			v11 = int32(2)
 		} else {
 			v11 = v
 		}
 		ctx = v11
 		v3 = v
 		if v3 > int32(MAX_VARIABLE_LEVEL) {
 			v7 = int32(MAX_VARIABLE_LEVEL)
 		} else {
 			v7 = v3
 		}
 		v5 = libc.Int32FromUint16(VP8LevelFixedCosts[v3]) + libc.Int32FromUint16(**(**uint16_t)(__ccgo_up(t + uintptr(v7)*2)))
 		goto _14
 	_14:
 		cost = cost + v5
 		t = **(**uintptr)(__ccgo_up(costs + uintptr(n+int32(1))*24 + uintptr(ctx)*8))
 		goto _10
 	_10:
 		;
 		n = n + 1
 	}
 	// Last coefficient is always non-zero
 	v1 = libc.Xabs(tls, int32(**(**int16_t)(__ccgo_up((*VP8Residual)(unsafe.Pointer(res)).Fcoeffs + uintptr(n)*2))))
 	v11 = v1
 	if v11 > int32(MAX_VARIABLE_LEVEL) {
 		v5 = int32(MAX_VARIABLE_LEVEL)
 	} else {
 		v5 = v11
 	}
 	v3 = libc.Int32FromUint16(VP8LevelFixedCosts[v11]) + libc.Int32FromUint16(**(**uint16_t)(__ccgo_up(t + uintptr(v5)*2)))
 	goto _18
 _18:
 	cost = cost + v3
 	if n < int32(15) {
 		b = libc.Int32FromUint8(VP8EncBands[n+int32(1)])
 		if v1 == int32(1) {
 			v11 = int32(1)
 		} else {
 			v11 = int32(2)
 		}
 		ctx1 = v11
 		last_p0 = libc.Int32FromUint8(**(**uint8_t)(__ccgo_up((*VP8Residual)(unsafe.Pointer(res)).Fprob + uintptr(b)*33 + uintptr(ctx1)*11)))
 		v2 = libc.Uint8FromInt32(last_p0)
 		if !(0 != 0) {
 			v5 = libc.Int32FromUint16(VP8EntropyCost[v2])
 		} else {
 			v5 = libc.Int32FromUint16(VP8EntropyCost[int32(255)-libc.Int32FromUint8(v2)])
 		}
 		v3 = v5
 		goto _23
 	_23:
 		cost = cost + v3
 	}
 	return cost
 }
 
 func SetResidualCoeffs_C(tls *libc.TLS, coeffs uintptr, res uintptr) {
 	var n int32
 	_ = n
 	(*VP8Residual)(unsafe.Pointer(res)).Flast = -int32(1)
 	n = int32(15)
 	for {
 		if !(n >= 0) {
 			break
 		}
 		if **(**int16_t)(__ccgo_up(coeffs + uintptr(n)*2)) != 0 {
 			(*VP8Residual)(unsafe.Pointer(res)).Flast = n
 			break
 		}
 		goto _1
 	_1:
 		;
 		n = n - 1
 	}
 	(*VP8Residual)(unsafe.Pointer(res)).Fcoeffs = coeffs
 }
 
 func VP8EncDspCostInit(tls *libc.TLS) {
 	if libc.AtomicLoadPUintptr(uintptr(unsafe.Pointer(&VP8EncDspCostInit_body_last_cpuinfo_used))) == VP8GetCPUInfo {
 		goto _1
 	}
 	VP8EncDspCostInit_body(tls)
 	libc.AtomicStorePUintptr(uintptr(unsafe.Pointer(&VP8EncDspCostInit_body_last_cpuinfo_used)), VP8GetCPUInfo)
 	goto _2
 _2:
 	;
 	goto _1
 _1: /**/ //
 }
 
 var VP8EncDspCostInit_body_last_cpuinfo_used = uintptr(0)
 
 func init() {
 	p := unsafe.Pointer(&VP8EncDspCostInit_body_last_cpuinfo_used)
 	*(*uintptr)(unsafe.Add(p, 0)) = uintptr(unsafe.Pointer(&VP8EncDspCostInit_body_last_cpuinfo_used))
 }
 
 func VP8EncDspCostInit_body(tls *libc.TLS) {
 	VP8GetResidualCost = __ccgo_fp(GetResidualCost_C)
 	VP8SetResidualCoeffs = __ccgo_fp(SetResidualCoeffs_C)
 	// If defined, use CPUInfo() to overwrite some pointers with faster versions.
 	if VP8GetCPUInfo != libc.UintptrFromInt32(0) {
 	}
 }
 
 func VP8EncDspCostInitMIPS32(tls *libc.TLS) {
 }
 
 func VP8EncDspCostInitMIPSdspR2(tls *libc.TLS) {
 }
 
 func VP8EncDspCostInitNEON(tls *libc.TLS) {
 }
 
 func VP8EncDspCostInitSSE2(tls *libc.TLS) {
 }
 
 /*===---- __stddef_wchar.h - Definition of wchar_t -------------------------===
  *
  * Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
  * See https://llvm.org/LICENSE.txt for license information.
  * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
  *
  *===-----------------------------------------------------------------------===
  */
 
 /*
  * When -fbuiltin-headers-in-system-modules is set this is a non-modular header
  * and needs to behave as if it was textual.
  */
 
 /*===---- __stddef_nullptr_t.h - Definition of nullptr_t -------------------===
  *
  * Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
  * See https://llvm.org/LICENSE.txt for license information.
  * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
  *
  *===-----------------------------------------------------------------------===
  */
 
 /*
  * When -fbuiltin-headers-in-system-modules is set this is a non-modular header
  * and needs to behave as if it was textual.
  */
 
 /*===---- __stddef_unreachable.h - Definition of unreachable ---------------===
  *
  * Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
  * See https://llvm.org/LICENSE.txt for license information.
  * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
  *
  *===-----------------------------------------------------------------------===
  */
 
 /*
  * When -fbuiltin-headers-in-system-modules is set this is a non-modular header
  * and needs to behave as if it was textual.
  */
 
 /*===---- __stddef_max_align_t.h - Definition of max_align_t ---------------===
  *
  * Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
  * See https://llvm.org/LICENSE.txt for license information.
  * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
  *
  *===-----------------------------------------------------------------------===
  */
 
 /*===---- __stddef_offsetof.h - Definition of offsetof ---------------------===
  *
  * Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
  * See https://llvm.org/LICENSE.txt for license information.
  * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
  *
  *===-----------------------------------------------------------------------===
  */
 
 /*
  * When -fbuiltin-headers-in-system-modules is set this is a non-modular header
  * and needs to behave as if it was textual.
  */
 
 /* Some C libraries expect to see a wint_t here. Others (notably MinGW) will use
 __WINT_TYPE__ directly; accommodate both by requiring __need_wint_t */
 
 // Copyright 2010 Google Inc. All Rights Reserved.
 //
 // Use of this source code is governed by a BSD-style license
 // that can be found in the COPYING file in the root of the source
 // tree. An additional intellectual property rights grant can be found
 // in the file PATENTS. All contributing project authors may
 // be found in the AUTHORS file in the root of the source tree.
 // -----------------------------------------------------------------------------
 //
 //  Common types + memory wrappers
 //
 // Author: Skal (pascal.massimino@gmail.com)
 
 //------------------------------------------------------------------------------
 // SSE2 detection.
 //
 
 // C documentation
 //
 //	// apple/darwin gcc-4.0.1 defines __PIC__, but not __pic__ with -fPIC.
 func GetCPUInfo(tls *libc.TLS, cpu_info uintptr, info_type int32) {
 	//   __asm__ volatile (
 	//     "cpuid\n"
 	//     : "=a"(cpu_info[0]), "=b"(cpu_info[1]), "=c"(cpu_info[2]), "=d"(cpu_info[3])
 	//     : "a"(info_type), "c"(0));
 	libc.X__assert_fail(tls, __ccgo_ts+594, __ccgo_ts+629, 45, __ccgo_ts+635)
 }
 
 // C documentation
 //
 //	// NaCl has no support for xgetbv or the raw opcode.
 func xgetbv(tls *libc.TLS) (r uint64_t) {
 	var eax, ecx, edx uint32_t
 	_, _, _ = eax, ecx, edx
 	ecx = uint32(0)
 	// Use the raw opcode for xgetbv for compatibility with older toolchains.
 	//   // Use the raw opcode for xgetbv for compatibility with older toolchains.
 	//   __asm__ volatile (
 	//     ".byte 0x0f, 0x01, 0xd0\n"
 	//     : "=a"(eax), "=d"(edx) : "c" (ecx));
 	libc.X__assert_fail(tls, __ccgo_ts+594, __ccgo_ts+629, 70, __ccgo_ts+646)
 	return uint64(edx)<<libc.Int32FromInt32(32) | uint64(eax)
 }
 
 // C documentation
 //
 //	// helper function for run-time detection of slow SSSE3 platforms
 func CheckSlowModel(tls *libc.TLS, info int32) (r int32) {
 	var family, model uint32_t
 	var i size_t
 	_, _, _ = family, i, model
 	model = libc.Uint32FromInt32(info&int32(0xf0000)>>int32(12) | info>>int32(4)&int32(0xf))
 	family = libc.Uint32FromInt32(info >> int32(8) & int32(0xf))
 	if family == uint32(0x06) {
 		i = uint64(0)
 		for {
 			if !(i < libc.Uint64FromInt64(6)/libc.Uint64FromInt64(1)) {
 				break
 			}
 			if model == uint32(kSlowModels[i]) {
 				return int32(1)
 			}
 			goto _1
 		_1:
 			;
 			i = i + 1
 		}
 	}
 	return 0
 }
 
 // Table listing display models with longer latencies for the bsr instruction
 // (ie 2 cycles vs 10/16 cycles) and some SSSE3 instructions like pshufb.
 // Refer to Intel 64 and IA-32 Architectures Optimization Reference Manual.
 var kSlowModels = [6]uint8_t{
 	0: uint8(0x37),
 	1: uint8(0x4a),
 	2: uint8(0x4d),
 	3: uint8(0x1c),
 	4: uint8(0x26),
 	5: uint8(0x27),
 }
 
 func x86CPUInfo(tls *libc.TLS, feature CPUFeature) (r int32) {
 	bp := tls.Alloc(16)
 	defer tls.Free(16)
 	var VENDOR_ID_INTEL_EBX, VENDOR_ID_INTEL_ECX, VENDOR_ID_INTEL_EDX, is_intel, max_cpuid_value int32
 	var _ /* cpu_info at bp+0 */ [4]int32
 	_, _, _, _, _ = VENDOR_ID_INTEL_EBX, VENDOR_ID_INTEL_ECX, VENDOR_ID_INTEL_EDX, is_intel, max_cpuid_value
 	is_intel = 0
 	// get the highest feature value cpuid supports
 	GetCPUInfo(tls, bp, 0)
 	max_cpuid_value = (**(**[4]int32)(__ccgo_up(bp)))[0]
 	if max_cpuid_value < int32(1) {
 		return 0
 	} else {
 		VENDOR_ID_INTEL_EBX = int32(0x756e6547)                                                                                                                                                                                             // uneG
 		VENDOR_ID_INTEL_EDX = int32(0x49656e69)                                                                                                                                                                                             // Ieni
 		VENDOR_ID_INTEL_ECX = int32(0x6c65746e)                                                                                                                                                                                             // letn
 		is_intel = libc.BoolInt32((**(**[4]int32)(__ccgo_up(bp)))[int32(1)] == VENDOR_ID_INTEL_EBX && (**(**[4]int32)(__ccgo_up(bp)))[int32(2)] == VENDOR_ID_INTEL_ECX && (**(**[4]int32)(__ccgo_up(bp)))[int32(3)] == VENDOR_ID_INTEL_EDX) // genuine Intel?
 	}
 	GetCPUInfo(tls, bp, int32(1))
 	if feature == int32(kSSE2) {
 		return libc.BoolInt32(!!((**(**[4]int32)(__ccgo_up(bp)))[int32(3)]&(libc.Int32FromInt32(1)<<libc.Int32FromInt32(26)) != 0))
 	}
 	if feature == int32(kSSE3) {
 		return libc.BoolInt32(!!((**(**[4]int32)(__ccgo_up(bp)))[int32(2)]&(libc.Int32FromInt32(1)<<libc.Int32FromInt32(0)) != 0))
 	}
 	if feature == int32(kSlowSSSE3) {
 		if is_intel != 0 && (**(**[4]int32)(__ccgo_up(bp)))[int32(2)]&(libc.Int32FromInt32(1)<<libc.Int32FromInt32(9)) != 0 { // SSSE3?
 			return CheckSlowModel(tls, (**(**[4]int32)(__ccgo_up(bp)))[0])
 		}
 		return 0
 	}
 	if feature == int32(kSSE4_1) {
 		return libc.BoolInt32(!!((**(**[4]int32)(__ccgo_up(bp)))[int32(2)]&(libc.Int32FromInt32(1)<<libc.Int32FromInt32(19)) != 0))
 	}
 	if feature == int32(kAVX) {
 		// bits 27 (OSXSAVE) & 28 (256-bit AVX)
 		if (**(**[4]int32)(__ccgo_up(bp)))[int32(2)]&int32(0x18000000) == int32(0x18000000) {
 			// XMM state and YMM state enabled by the OS.
 			return libc.BoolInt32(xgetbv(tls)&uint64(0x6) == uint64(0x6))
 		}
 	}
 	if feature == int32(kAVX2) {
 		if x86CPUInfo(tls, int32(kAVX)) != 0 && max_cpuid_value >= int32(7) {
 			GetCPUInfo(tls, bp, int32(7))
 			return libc.BoolInt32(!!((**(**[4]int32)(__ccgo_up(bp)))[int32(1)]&(libc.Int32FromInt32(1)<<libc.Int32FromInt32(5)) != 0))
 		}
 	}
 	return 0
 }
 
 func init() {
 	p := unsafe.Pointer(&VP8GetCPUInfo)
 	*(*uintptr)(unsafe.Add(p, 0)) = __ccgo_fp(x86CPUInfo)
 }
 
 var kHashMul14 = uint32(0x1e35a7bd)
 
 //------------------------------------------------------------------------------
 
 // Copyright 2010 Google Inc. All Rights Reserved.
 //
 // Use of this source code is governed by a BSD-style license
 // that can be found in the COPYING file in the root of the source
 // tree. An additional intellectual property rights grant can be found
 // in the file PATENTS. All contributing project authors may
 // be found in the AUTHORS file in the root of the source tree.
 // -----------------------------------------------------------------------------
 //
 //  Common types + memory wrappers
 //
 // Author: Skal (pascal.massimino@gmail.com)
 
 //------------------------------------------------------------------------------
 
 func clip_8b1(tls *libc.TLS, v int32) (r uint8_t) {
 	var v1, v2 int32
 	_, _ = v1, v2
 	if !(v & ^libc.Int32FromInt32(0xff) != 0) {
 		v1 = v
 	} else {
 		if v < 0 {
 			v2 = 0
 		} else {
 			v2 = int32(255)
 		}
 		v1 = v2
 	}
 	return libc.Uint8FromInt32(v1)
 }
 
 //------------------------------------------------------------------------------
 // Transforms (Paragraph 14.4)
 
 func TransformOne_C(tls *libc.TLS, in uintptr, dst uintptr) {
 	bp := tls.Alloc(64)
 	defer tls.Free(64)
 	var a, a1, b, b1, c, c1, d, d1, dc, i int32
 	var tmp uintptr
 	var _ /* C at bp+0 */ [16]int32
 	_, _, _, _, _, _, _, _, _, _, _ = a, a1, b, b1, c, c1, d, d1, dc, i, tmp
 	tmp = bp
 	i = 0
 	for {
 		if !(i < int32(4)) {
 			break
 		} // vertical pass
 		a = int32(**(**int16_t)(__ccgo_up(in))) + int32(**(**int16_t)(__ccgo_up(in + 8*2)))                                                                                                                                       // [-4096, 4094]
 		b = int32(**(**int16_t)(__ccgo_up(in))) - int32(**(**int16_t)(__ccgo_up(in + 8*2)))                                                                                                                                       // [-4095, 4095]
 		c = int32(**(**int16_t)(__ccgo_up(in + 4*2)))*int32(WEBP_TRANSFORM_AC3_C2)>>int32(16) - (int32(**(**int16_t)(__ccgo_up(in + 12*2)))*int32(WEBP_TRANSFORM_AC3_C1)>>int32(16) + int32(**(**int16_t)(__ccgo_up(in + 12*2)))) // [-3783, 3783]
 		d = int32(**(**int16_t)(__ccgo_up(in + 4*2)))*int32(WEBP_TRANSFORM_AC3_C1)>>int32(16) + int32(**(**int16_t)(__ccgo_up(in + 4*2))) + int32(**(**int16_t)(__ccgo_up(in + 12*2)))*int32(WEBP_TRANSFORM_AC3_C2)>>int32(16)    // [-3785, 3781]
 		**(**int32)(__ccgo_up(tmp)) = a + d                                                                                                                                                                                       // [-7881, 7875]
 		**(**int32)(__ccgo_up(tmp + 1*4)) = b + c                                                                                                                                                                                 // [-7878, 7878]
 		**(**int32)(__ccgo_up(tmp + 2*4)) = b - c                                                                                                                                                                                 // [-7878, 7878]
 		**(**int32)(__ccgo_up(tmp + 3*4)) = a - d                                                                                                                                                                                 // [-7877, 7879]
 		tmp = tmp + uintptr(4)*4
 		in += 2
 		goto _1
 	_1:
 		;
 		i = i + 1
 	}
 	// Each pass is expanding the dynamic range by ~3.85 (upper bound).
 	// The exact value is (2. + (20091 + 35468) / 65536).
 	// After the second pass, maximum interval is [-3794, 3794], assuming
 	// an input in [-2048, 2047] interval. We then need to add a dst value
 	// in the [0, 255] range.
 	// In the worst case scenario, the input to clip_8b() can be as large as
 	// [-60713, 60968].
 	tmp = bp
 	i = 0
 	for {
 		if !(i < int32(4)) {
 			break
 		} // horizontal pass
 		dc = **(**int32)(__ccgo_up(tmp)) + int32(4)
 		a1 = dc + **(**int32)(__ccgo_up(tmp + 8*4))
 		b1 = dc - **(**int32)(__ccgo_up(tmp + 8*4))
 		c1 = **(**int32)(__ccgo_up(tmp + 4*4))*int32(WEBP_TRANSFORM_AC3_C2)>>int32(16) - (**(**int32)(__ccgo_up(tmp + 12*4))*int32(WEBP_TRANSFORM_AC3_C1)>>int32(16) + **(**int32)(__ccgo_up(tmp + 12*4)))
 		d1 = **(**int32)(__ccgo_up(tmp + 4*4))*int32(WEBP_TRANSFORM_AC3_C1)>>int32(16) + **(**int32)(__ccgo_up(tmp + 4*4)) + **(**int32)(__ccgo_up(tmp + 12*4))*int32(WEBP_TRANSFORM_AC3_C2)>>int32(16)
 		**(**uint8_t)(__ccgo_up(dst + uintptr(libc.Int32FromInt32(0)+libc.Int32FromInt32(0)*libc.Int32FromInt32(BPS)))) = clip_8b1(tls, libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(dst + uintptr(libc.Int32FromInt32(0)+libc.Int32FromInt32(0)*libc.Int32FromInt32(BPS)))))+(a1+d1)>>int32(3))
 		**(**uint8_t)(__ccgo_up(dst + uintptr(libc.Int32FromInt32(1)+libc.Int32FromInt32(0)*libc.Int32FromInt32(BPS)))) = clip_8b1(tls, libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(dst + uintptr(libc.Int32FromInt32(1)+libc.Int32FromInt32(0)*libc.Int32FromInt32(BPS)))))+(b1+c1)>>int32(3))
 		**(**uint8_t)(__ccgo_up(dst + uintptr(libc.Int32FromInt32(2)+libc.Int32FromInt32(0)*libc.Int32FromInt32(BPS)))) = clip_8b1(tls, libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(dst + uintptr(libc.Int32FromInt32(2)+libc.Int32FromInt32(0)*libc.Int32FromInt32(BPS)))))+(b1-c1)>>int32(3))
 		**(**uint8_t)(__ccgo_up(dst + uintptr(libc.Int32FromInt32(3)+libc.Int32FromInt32(0)*libc.Int32FromInt32(BPS)))) = clip_8b1(tls, libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(dst + uintptr(libc.Int32FromInt32(3)+libc.Int32FromInt32(0)*libc.Int32FromInt32(BPS)))))+(a1-d1)>>int32(3))
 		tmp += 4
 		dst = dst + uintptr(BPS)
 		goto _2
 	_2:
 		;
 		i = i + 1
 	}
 }
 
 // C documentation
 //
 //	// Simplified transform when only in[0], in[1] and in[4] are non-zero
 func TransformAC3_C(tls *libc.TLS, in uintptr, dst uintptr) {
 	var DC, DC1, DC2, DC3, a, c1, c4, d1, d4 int32
 	_, _, _, _, _, _, _, _, _ = DC, DC1, DC2, DC3, a, c1, c4, d1, d4
 	a = int32(**(**int16_t)(__ccgo_up(in))) + int32(4)
 	c4 = int32(**(**int16_t)(__ccgo_up(in + 4*2))) * libc.Int32FromInt32(WEBP_TRANSFORM_AC3_C2) >> libc.Int32FromInt32(16)
 	d4 = int32(**(**int16_t)(__ccgo_up(in + 4*2)))*libc.Int32FromInt32(WEBP_TRANSFORM_AC3_C1)>>libc.Int32FromInt32(16) + int32(**(**int16_t)(__ccgo_up(in + 4*2)))
 	c1 = int32(**(**int16_t)(__ccgo_up(in + 1*2))) * libc.Int32FromInt32(WEBP_TRANSFORM_AC3_C2) >> libc.Int32FromInt32(16)
 	d1 = int32(**(**int16_t)(__ccgo_up(in + 1*2)))*libc.Int32FromInt32(WEBP_TRANSFORM_AC3_C1)>>libc.Int32FromInt32(16) + int32(**(**int16_t)(__ccgo_up(in + 1*2)))
 	DC = a + d4
 	**(**uint8_t)(__ccgo_up(dst + uintptr(libc.Int32FromInt32(0)+libc.Int32FromInt32(0)*libc.Int32FromInt32(BPS)))) = clip_8b1(tls, libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(dst + uintptr(libc.Int32FromInt32(0)+libc.Int32FromInt32(0)*libc.Int32FromInt32(BPS)))))+(DC+d1)>>int32(3))
 	**(**uint8_t)(__ccgo_up(dst + uintptr(libc.Int32FromInt32(1)+libc.Int32FromInt32(0)*libc.Int32FromInt32(BPS)))) = clip_8b1(tls, libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(dst + uintptr(libc.Int32FromInt32(1)+libc.Int32FromInt32(0)*libc.Int32FromInt32(BPS)))))+(DC+c1)>>int32(3))
 	**(**uint8_t)(__ccgo_up(dst + uintptr(libc.Int32FromInt32(2)+libc.Int32FromInt32(0)*libc.Int32FromInt32(BPS)))) = clip_8b1(tls, libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(dst + uintptr(libc.Int32FromInt32(2)+libc.Int32FromInt32(0)*libc.Int32FromInt32(BPS)))))+(DC-c1)>>int32(3))
 	**(**uint8_t)(__ccgo_up(dst + uintptr(libc.Int32FromInt32(3)+libc.Int32FromInt32(0)*libc.Int32FromInt32(BPS)))) = clip_8b1(tls, libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(dst + uintptr(libc.Int32FromInt32(3)+libc.Int32FromInt32(0)*libc.Int32FromInt32(BPS)))))+(DC-d1)>>int32(3))
 	DC1 = a + c4
 	**(**uint8_t)(__ccgo_up(dst + uintptr(libc.Int32FromInt32(0)+libc.Int32FromInt32(1)*libc.Int32FromInt32(BPS)))) = clip_8b1(tls, libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(dst + uintptr(libc.Int32FromInt32(0)+libc.Int32FromInt32(1)*libc.Int32FromInt32(BPS)))))+(DC1+d1)>>int32(3))
 	**(**uint8_t)(__ccgo_up(dst + uintptr(libc.Int32FromInt32(1)+libc.Int32FromInt32(1)*libc.Int32FromInt32(BPS)))) = clip_8b1(tls, libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(dst + uintptr(libc.Int32FromInt32(1)+libc.Int32FromInt32(1)*libc.Int32FromInt32(BPS)))))+(DC1+c1)>>int32(3))
 	**(**uint8_t)(__ccgo_up(dst + uintptr(libc.Int32FromInt32(2)+libc.Int32FromInt32(1)*libc.Int32FromInt32(BPS)))) = clip_8b1(tls, libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(dst + uintptr(libc.Int32FromInt32(2)+libc.Int32FromInt32(1)*libc.Int32FromInt32(BPS)))))+(DC1-c1)>>int32(3))
 	**(**uint8_t)(__ccgo_up(dst + uintptr(libc.Int32FromInt32(3)+libc.Int32FromInt32(1)*libc.Int32FromInt32(BPS)))) = clip_8b1(tls, libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(dst + uintptr(libc.Int32FromInt32(3)+libc.Int32FromInt32(1)*libc.Int32FromInt32(BPS)))))+(DC1-d1)>>int32(3))
 	DC2 = a - c4
 	**(**uint8_t)(__ccgo_up(dst + uintptr(libc.Int32FromInt32(0)+libc.Int32FromInt32(2)*libc.Int32FromInt32(BPS)))) = clip_8b1(tls, libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(dst + uintptr(libc.Int32FromInt32(0)+libc.Int32FromInt32(2)*libc.Int32FromInt32(BPS)))))+(DC2+d1)>>int32(3))
 	**(**uint8_t)(__ccgo_up(dst + uintptr(libc.Int32FromInt32(1)+libc.Int32FromInt32(2)*libc.Int32FromInt32(BPS)))) = clip_8b1(tls, libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(dst + uintptr(libc.Int32FromInt32(1)+libc.Int32FromInt32(2)*libc.Int32FromInt32(BPS)))))+(DC2+c1)>>int32(3))
 	**(**uint8_t)(__ccgo_up(dst + uintptr(libc.Int32FromInt32(2)+libc.Int32FromInt32(2)*libc.Int32FromInt32(BPS)))) = clip_8b1(tls, libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(dst + uintptr(libc.Int32FromInt32(2)+libc.Int32FromInt32(2)*libc.Int32FromInt32(BPS)))))+(DC2-c1)>>int32(3))
 	**(**uint8_t)(__ccgo_up(dst + uintptr(libc.Int32FromInt32(3)+libc.Int32FromInt32(2)*libc.Int32FromInt32(BPS)))) = clip_8b1(tls, libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(dst + uintptr(libc.Int32FromInt32(3)+libc.Int32FromInt32(2)*libc.Int32FromInt32(BPS)))))+(DC2-d1)>>int32(3))
 	DC3 = a - d4
 	**(**uint8_t)(__ccgo_up(dst + uintptr(libc.Int32FromInt32(0)+libc.Int32FromInt32(3)*libc.Int32FromInt32(BPS)))) = clip_8b1(tls, libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(dst + uintptr(libc.Int32FromInt32(0)+libc.Int32FromInt32(3)*libc.Int32FromInt32(BPS)))))+(DC3+d1)>>int32(3))
 	**(**uint8_t)(__ccgo_up(dst + uintptr(libc.Int32FromInt32(1)+libc.Int32FromInt32(3)*libc.Int32FromInt32(BPS)))) = clip_8b1(tls, libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(dst + uintptr(libc.Int32FromInt32(1)+libc.Int32FromInt32(3)*libc.Int32FromInt32(BPS)))))+(DC3+c1)>>int32(3))
 	**(**uint8_t)(__ccgo_up(dst + uintptr(libc.Int32FromInt32(2)+libc.Int32FromInt32(3)*libc.Int32FromInt32(BPS)))) = clip_8b1(tls, libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(dst + uintptr(libc.Int32FromInt32(2)+libc.Int32FromInt32(3)*libc.Int32FromInt32(BPS)))))+(DC3-c1)>>int32(3))
 	**(**uint8_t)(__ccgo_up(dst + uintptr(libc.Int32FromInt32(3)+libc.Int32FromInt32(3)*libc.Int32FromInt32(BPS)))) = clip_8b1(tls, libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(dst + uintptr(libc.Int32FromInt32(3)+libc.Int32FromInt32(3)*libc.Int32FromInt32(BPS)))))+(DC3-d1)>>int32(3))
 }
 
 func TransformTwo_C(tls *libc.TLS, in uintptr, dst uintptr, do_two int32) {
 	TransformOne_C(tls, in, dst)
 	if do_two != 0 {
 		TransformOne_C(tls, in+uintptr(16)*2, dst+uintptr(4))
 	}
 }
 
 func TransformUV_C(tls *libc.TLS, in uintptr, dst uintptr) {
 	(*(*func(*libc.TLS, uintptr, uintptr, int32))(unsafe.Pointer(&struct{ uintptr }{VP8Transform})))(tls, in+uintptr(libc.Int32FromInt32(0)*libc.Int32FromInt32(16))*2, dst, int32(1))
 	(*(*func(*libc.TLS, uintptr, uintptr, int32))(unsafe.Pointer(&struct{ uintptr }{VP8Transform})))(tls, in+uintptr(libc.Int32FromInt32(2)*libc.Int32FromInt32(16))*2, dst+uintptr(libc.Int32FromInt32(4)*libc.Int32FromInt32(BPS)), int32(1))
 }
 
 func TransformDC_C(tls *libc.TLS, in uintptr, dst uintptr) {
 	var DC, i, j int32
 	_, _, _ = DC, i, j
 	DC = int32(**(**int16_t)(__ccgo_up(in))) + int32(4)
 	j = 0
 	for {
 		if !(j < int32(4)) {
 			break
 		}
 		i = 0
 		for {
 			if !(i < int32(4)) {
 				break
 			}
 			**(**uint8_t)(__ccgo_up(dst + uintptr(i+j*int32(BPS)))) = clip_8b1(tls, libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(dst + uintptr(i+j*int32(BPS)))))+DC>>libc.Int32FromInt32(3))
 			goto _2
 		_2:
 			;
 			i = i + 1
 		}
 		goto _1
 	_1:
 		;
 		j = j + 1
 	}
 }
 
 func TransformDCUV_C(tls *libc.TLS, in uintptr, dst uintptr) {
 	if **(**int16_t)(__ccgo_up(in + uintptr(libc.Int32FromInt32(0)*libc.Int32FromInt32(16))*2)) != 0 {
 		(*(*func(*libc.TLS, uintptr, uintptr))(unsafe.Pointer(&struct{ uintptr }{VP8TransformDC})))(tls, in+uintptr(libc.Int32FromInt32(0)*libc.Int32FromInt32(16))*2, dst)
 	}
 	if **(**int16_t)(__ccgo_up(in + uintptr(libc.Int32FromInt32(1)*libc.Int32FromInt32(16))*2)) != 0 {
 		(*(*func(*libc.TLS, uintptr, uintptr))(unsafe.Pointer(&struct{ uintptr }{VP8TransformDC})))(tls, in+uintptr(libc.Int32FromInt32(1)*libc.Int32FromInt32(16))*2, dst+uintptr(4))
 	}
 	if **(**int16_t)(__ccgo_up(in + uintptr(libc.Int32FromInt32(2)*libc.Int32FromInt32(16))*2)) != 0 {
 		(*(*func(*libc.TLS, uintptr, uintptr))(unsafe.Pointer(&struct{ uintptr }{VP8TransformDC})))(tls, in+uintptr(libc.Int32FromInt32(2)*libc.Int32FromInt32(16))*2, dst+uintptr(libc.Int32FromInt32(4)*libc.Int32FromInt32(BPS)))
 	}
 	if **(**int16_t)(__ccgo_up(in + uintptr(libc.Int32FromInt32(3)*libc.Int32FromInt32(16))*2)) != 0 {
 		(*(*func(*libc.TLS, uintptr, uintptr))(unsafe.Pointer(&struct{ uintptr }{VP8TransformDC})))(tls, in+uintptr(libc.Int32FromInt32(3)*libc.Int32FromInt32(16))*2, dst+uintptr(libc.Int32FromInt32(4)*libc.Int32FromInt32(BPS))+uintptr(4))
 	}
 }
 
 //------------------------------------------------------------------------------
 // Paragraph 14.3
 
 func TransformWHT_C(tls *libc.TLS, in uintptr, out uintptr) {
 	var a0, a01, a1, a11, a2, a21, a3, a31, dc, i int32
 	var tmp [16]int32
 	_, _, _, _, _, _, _, _, _, _, _ = a0, a01, a1, a11, a2, a21, a3, a31, dc, i, tmp
 	i = 0
 	for {
 		if !(i < int32(4)) {
 			break
 		}
 		a0 = int32(**(**int16_t)(__ccgo_up(in + uintptr(0+i)*2))) + int32(**(**int16_t)(__ccgo_up(in + uintptr(int32(12)+i)*2)))
 		a1 = int32(**(**int16_t)(__ccgo_up(in + uintptr(int32(4)+i)*2))) + int32(**(**int16_t)(__ccgo_up(in + uintptr(int32(8)+i)*2)))
 		a2 = int32(**(**int16_t)(__ccgo_up(in + uintptr(int32(4)+i)*2))) - int32(**(**int16_t)(__ccgo_up(in + uintptr(int32(8)+i)*2)))
 		a3 = int32(**(**int16_t)(__ccgo_up(in + uintptr(0+i)*2))) - int32(**(**int16_t)(__ccgo_up(in + uintptr(int32(12)+i)*2)))
 		tmp[0+i] = a0 + a1
 		tmp[int32(8)+i] = a0 - a1
 		tmp[int32(4)+i] = a3 + a2
 		tmp[int32(12)+i] = a3 - a2
 		goto _1
 	_1:
 		;
 		i = i + 1
 	}
 	i = 0
 	for {
 		if !(i < int32(4)) {
 			break
 		}
 		dc = tmp[0+i*int32(4)] + int32(3) // w/ rounder
 		a01 = dc + tmp[int32(3)+i*int32(4)]
 		a11 = tmp[int32(1)+i*int32(4)] + tmp[int32(2)+i*int32(4)]
 		a21 = tmp[int32(1)+i*int32(4)] - tmp[int32(2)+i*int32(4)]
 		a31 = dc - tmp[int32(3)+i*int32(4)]
 		**(**int16_t)(__ccgo_up(out)) = int16((a01 + a11) >> int32(3))
 		**(**int16_t)(__ccgo_up(out + 16*2)) = int16((a31 + a21) >> int32(3))
 		**(**int16_t)(__ccgo_up(out + 32*2)) = int16((a01 - a11) >> int32(3))
 		**(**int16_t)(__ccgo_up(out + 48*2)) = int16((a31 - a21) >> int32(3))
 		out = out + uintptr(64)*2
 		goto _2
 	_2:
 		;
 		i = i + 1
 	}
 }
 
 //------------------------------------------------------------------------------
 // Intra predictions
 
 func TrueMotion(tls *libc.TLS, dst uintptr, size int32) {
 	var clip, clip0, top uintptr
 	var x, y int32
 	_, _, _, _, _ = clip, clip0, top, x, y
 	top = dst - uintptr(BPS)
 	clip0 = VP8kclip1 - uintptr(**(**uint8_t)(__ccgo_up(top + uintptr(-libc.Int32FromInt32(1)))))
 	y = 0
 	for {
 		if !(y < size) {
 			break
 		}
 		clip = clip0 + uintptr(**(**uint8_t)(__ccgo_up(dst + uintptr(-libc.Int32FromInt32(1)))))
 		x = 0
 		for {
 			if !(x < size) {
 				break
 			}
 			**(**uint8_t)(__ccgo_up(dst + uintptr(x))) = **(**uint8_t)(__ccgo_up(clip + uintptr(**(**uint8_t)(__ccgo_up(top + uintptr(x))))))
 			goto _2
 		_2:
 			;
 			x = x + 1
 		}
 		dst = dst + uintptr(BPS)
 		goto _1
 	_1:
 		;
 		y = y + 1
 	}
 }
 
 func TM4_C(tls *libc.TLS, dst uintptr) {
 	TrueMotion(tls, dst, int32(4))
 }
 
 func TM8uv_C(tls *libc.TLS, dst uintptr) {
 	TrueMotion(tls, dst, int32(8))
 }
 
 func TM16_C(tls *libc.TLS, dst uintptr) {
 	TrueMotion(tls, dst, int32(16))
 }
 
 //------------------------------------------------------------------------------
 // 16x16
 
 func VE16_C(tls *libc.TLS, dst uintptr) {
 	var j int32
 	_ = j
 	j = 0
 	for {
 		if !(j < int32(16)) {
 			break
 		}
 		libc.X__builtin___memcpy_chk(tls, dst+uintptr(j*int32(BPS)), dst-uintptr(BPS), uint64(16), ^__predefined_size_t(0))
 		goto _1
 	_1:
 		;
 		j = j + 1
 	}
 }
 
 func HE16_C(tls *libc.TLS, dst uintptr) {
 	var j int32
 	_ = j
 	j = int32(16)
 	for {
 		if !(j > 0) {
 			break
 		}
 		libc.X__builtin___memset_chk(tls, dst, libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(dst + uintptr(-libc.Int32FromInt32(1))))), uint64(16), ^__predefined_size_t(0))
 		dst = dst + uintptr(BPS)
 		goto _1
 	_1:
 		;
 		j = j - 1
 	}
 }
 
 func Put16(tls *libc.TLS, v int32, dst uintptr) {
 	var j int32
 	_ = j
 	j = 0
 	for {
 		if !(j < int32(16)) {
 			break
 		}
 		libc.X__builtin___memset_chk(tls, dst+uintptr(j*int32(BPS)), v, uint64(16), ^__predefined_size_t(0))
 		goto _1
 	_1:
 		;
 		j = j + 1
 	}
 }
 
 func DC16_C(tls *libc.TLS, dst uintptr) {
 	var DC, j int32
 	_, _ = DC, j // DC
 	DC = int32(16)
 	j = 0
 	for {
 		if !(j < int32(16)) {
 			break
 		}
 		DC = DC + (libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(dst + uintptr(-int32(1)+j*int32(BPS))))) + libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(dst + uintptr(j-int32(BPS))))))
 		goto _1
 	_1:
 		;
 		j = j + 1
 	}
 	Put16(tls, DC>>int32(5), dst)
 }
 
 func DC16NoTop_C(tls *libc.TLS, dst uintptr) {
 	var DC, j int32
 	_, _ = DC, j // DC with top samples not available
 	DC = int32(8)
 	j = 0
 	for {
 		if !(j < int32(16)) {
 			break
 		}
 		DC = DC + libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(dst + uintptr(-int32(1)+j*int32(BPS)))))
 		goto _1
 	_1:
 		;
 		j = j + 1
 	}
 	Put16(tls, DC>>int32(4), dst)
 }
 
 func DC16NoLeft_C(tls *libc.TLS, dst uintptr) {
 	var DC, i int32
 	_, _ = DC, i // DC with left samples not available
 	DC = int32(8)
 	i = 0
 	for {
 		if !(i < int32(16)) {
 			break
 		}
 		DC = DC + libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(dst + uintptr(i-int32(BPS)))))
 		goto _1
 	_1:
 		;
 		i = i + 1
 	}
 	Put16(tls, DC>>int32(4), dst)
 }
 
 func DC16NoTopLeft_C(tls *libc.TLS, dst uintptr) {
 	// DC with no top and left samples
 	Put16(tls, int32(0x80), dst)
 }
 
 //------------------------------------------------------------------------------
 // 4x4
 
 func VE4_C(tls *libc.TLS, dst uintptr) {
 	bp := tls.Alloc(16)
 	defer tls.Free(16)
 	var i int32
 	var top uintptr
 	var _ /* vals at bp+0 */ [4]uint8_t
 	_, _ = i, top // vertical
 	top = dst - uintptr(BPS)
 	**(**[4]uint8_t)(__ccgo_up(bp)) = [4]uint8_t{
 		0: libc.Uint8FromInt32((libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(top + uintptr(-libc.Int32FromInt32(1))))) + libc.Int32FromInt32(2)*libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(top))) + libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(top + 1))) + libc.Int32FromInt32(2)) >> libc.Int32FromInt32(2)),
 		1: libc.Uint8FromInt32((libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(top))) + libc.Int32FromInt32(2)*libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(top + 1))) + libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(top + 2))) + libc.Int32FromInt32(2)) >> libc.Int32FromInt32(2)),
 		2: libc.Uint8FromInt32((libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(top + 1))) + libc.Int32FromInt32(2)*libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(top + 2))) + libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(top + 3))) + libc.Int32FromInt32(2)) >> libc.Int32FromInt32(2)),
 		3: libc.Uint8FromInt32((libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(top + 2))) + libc.Int32FromInt32(2)*libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(top + 3))) + libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(top + 4))) + libc.Int32FromInt32(2)) >> libc.Int32FromInt32(2)),
 	}
 	i = 0
 	for {
 		if !(i < int32(4)) {
 			break
 		}
 		libc.X__builtin___memcpy_chk(tls, dst+uintptr(i*int32(BPS)), bp, uint64(4), ^__predefined_size_t(0))
 		goto _1
 	_1:
 		;
 		i = i + 1
 	}
 }
 
 func HE4_C(tls *libc.TLS, dst uintptr) {
 	bp := tls.Alloc(16)
 	defer tls.Free(16)
 	var A, B, C, D, E int32
 	var v1 uintptr
 	var v2 uint32_t
 	_, _, _, _, _, _, _ = A, B, C, D, E, v1, v2 // horizontal
 	A = libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(dst + uintptr(-libc.Int32FromInt32(1)-libc.Int32FromInt32(BPS)))))
 	B = libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(dst + uintptr(-libc.Int32FromInt32(1)))))
 	C = libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(dst + uintptr(-libc.Int32FromInt32(1)+libc.Int32FromInt32(BPS)))))
 	D = libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(dst + uintptr(-libc.Int32FromInt32(1)+libc.Int32FromInt32(2)*libc.Int32FromInt32(BPS)))))
 	E = libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(dst + uintptr(-libc.Int32FromInt32(1)+libc.Int32FromInt32(3)*libc.Int32FromInt32(BPS)))))
 	v1 = dst + uintptr(libc.Int32FromInt32(0)*libc.Int32FromInt32(BPS))
 	v2 = uint32(0x01010101) * uint32(libc.Uint8FromInt32((A+libc.Int32FromInt32(2)*B+C+libc.Int32FromInt32(2))>>libc.Int32FromInt32(2)))
 	*(*uint32_t)(unsafe.Pointer(bp)) = v2
 	libc.X__builtin___memcpy_chk(tls, v1, bp, uint64(4), ^__predefined_size_t(0))
 	v1 = dst + uintptr(libc.Int32FromInt32(1)*libc.Int32FromInt32(BPS))
 	v2 = uint32(0x01010101) * uint32(libc.Uint8FromInt32((B+libc.Int32FromInt32(2)*C+D+libc.Int32FromInt32(2))>>libc.Int32FromInt32(2)))
 	*(*uint32_t)(unsafe.Pointer(bp)) = v2
 	libc.X__builtin___memcpy_chk(tls, v1, bp, uint64(4), ^__predefined_size_t(0))
 	v1 = dst + uintptr(libc.Int32FromInt32(2)*libc.Int32FromInt32(BPS))
 	v2 = uint32(0x01010101) * uint32(libc.Uint8FromInt32((C+libc.Int32FromInt32(2)*D+E+libc.Int32FromInt32(2))>>libc.Int32FromInt32(2)))
 	*(*uint32_t)(unsafe.Pointer(bp)) = v2
 	libc.X__builtin___memcpy_chk(tls, v1, bp, uint64(4), ^__predefined_size_t(0))
 	v1 = dst + uintptr(libc.Int32FromInt32(3)*libc.Int32FromInt32(BPS))
 	v2 = uint32(0x01010101) * uint32(libc.Uint8FromInt32((D+libc.Int32FromInt32(2)*E+E+libc.Int32FromInt32(2))>>libc.Int32FromInt32(2)))
 	*(*uint32_t)(unsafe.Pointer(bp)) = v2
 	libc.X__builtin___memcpy_chk(tls, v1, bp, uint64(4), ^__predefined_size_t(0))
 }
 
 func DC4_C(tls *libc.TLS, dst uintptr) {
 	var dc uint32_t
 	var i int32
 	_, _ = dc, i // DC
 	dc = uint32(4)
 	i = 0
 	for {
 		if !(i < int32(4)) {
 			break
 		}
 		dc = dc + libc.Uint32FromInt32(libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(dst + uintptr(i-int32(BPS)))))+libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(dst + uintptr(-int32(1)+i*int32(BPS))))))
 		goto _1
 	_1:
 		;
 		i = i + 1
 	}
 	dc = dc >> uint32(3)
 	i = 0
 	for {
 		if !(i < int32(4)) {
 			break
 		}
 		libc.X__builtin___memset_chk(tls, dst+uintptr(i*int32(BPS)), libc.Int32FromUint32(dc), uint64(4), ^__predefined_size_t(0))
 		goto _2
 	_2:
 		;
 		i = i + 1
 	}
 }
 
 func RD4_C(tls *libc.TLS, dst uintptr) {
 	var A, B, C, D, I, J, K, L, X int32
 	var v1, v2, v3 uint8_t
 	_, _, _, _, _, _, _, _, _, _, _, _ = A, B, C, D, I, J, K, L, X, v1, v2, v3 // Down-right
 	I = libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(dst + uintptr(-libc.Int32FromInt32(1)+libc.Int32FromInt32(0)*libc.Int32FromInt32(BPS)))))
 	J = libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(dst + uintptr(-libc.Int32FromInt32(1)+libc.Int32FromInt32(1)*libc.Int32FromInt32(BPS)))))
 	K = libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(dst + uintptr(-libc.Int32FromInt32(1)+libc.Int32FromInt32(2)*libc.Int32FromInt32(BPS)))))
 	L = libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(dst + uintptr(-libc.Int32FromInt32(1)+libc.Int32FromInt32(3)*libc.Int32FromInt32(BPS)))))
 	X = libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(dst + uintptr(-libc.Int32FromInt32(1)-libc.Int32FromInt32(BPS)))))
 	A = libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(dst + uintptr(libc.Int32FromInt32(0)-libc.Int32FromInt32(BPS)))))
 	B = libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(dst + uintptr(libc.Int32FromInt32(1)-libc.Int32FromInt32(BPS)))))
 	C = libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(dst + uintptr(libc.Int32FromInt32(2)-libc.Int32FromInt32(BPS)))))
 	D = libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(dst + uintptr(libc.Int32FromInt32(3)-libc.Int32FromInt32(BPS)))))
 	**(**uint8_t)(__ccgo_up(dst + uintptr(libc.Int32FromInt32(0)+libc.Int32FromInt32(3)*libc.Int32FromInt32(BPS)))) = libc.Uint8FromInt32((J + libc.Int32FromInt32(2)*K + L + libc.Int32FromInt32(2)) >> libc.Int32FromInt32(2))
 	v1 = libc.Uint8FromInt32((I + libc.Int32FromInt32(2)*J + K + libc.Int32FromInt32(2)) >> libc.Int32FromInt32(2))
 	**(**uint8_t)(__ccgo_up(dst + uintptr(libc.Int32FromInt32(0)+libc.Int32FromInt32(2)*libc.Int32FromInt32(BPS)))) = v1
 	**(**uint8_t)(__ccgo_up(dst + uintptr(libc.Int32FromInt32(1)+libc.Int32FromInt32(3)*libc.Int32FromInt32(BPS)))) = v1
 	v2 = libc.Uint8FromInt32((X + libc.Int32FromInt32(2)*I + J + libc.Int32FromInt32(2)) >> libc.Int32FromInt32(2))
 	**(**uint8_t)(__ccgo_up(dst + uintptr(libc.Int32FromInt32(0)+libc.Int32FromInt32(1)*libc.Int32FromInt32(BPS)))) = v2
 	v1 = v2
 	**(**uint8_t)(__ccgo_up(dst + uintptr(libc.Int32FromInt32(1)+libc.Int32FromInt32(2)*libc.Int32FromInt32(BPS)))) = v1
 	**(**uint8_t)(__ccgo_up(dst + uintptr(libc.Int32FromInt32(2)+libc.Int32FromInt32(3)*libc.Int32FromInt32(BPS)))) = v1
 	v3 = libc.Uint8FromInt32((A + libc.Int32FromInt32(2)*X + I + libc.Int32FromInt32(2)) >> libc.Int32FromInt32(2))
 	**(**uint8_t)(__ccgo_up(dst + uintptr(libc.Int32FromInt32(0)+libc.Int32FromInt32(0)*libc.Int32FromInt32(BPS)))) = v3
 	v2 = v3
 	**(**uint8_t)(__ccgo_up(dst + uintptr(libc.Int32FromInt32(1)+libc.Int32FromInt32(1)*libc.Int32FromInt32(BPS)))) = v2
 	v1 = v2
 	**(**uint8_t)(__ccgo_up(dst + uintptr(libc.Int32FromInt32(2)+libc.Int32FromInt32(2)*libc.Int32FromInt32(BPS)))) = v1
 	**(**uint8_t)(__ccgo_up(dst + uintptr(libc.Int32FromInt32(3)+libc.Int32FromInt32(3)*libc.Int32FromInt32(BPS)))) = v1
 	v2 = libc.Uint8FromInt32((B + libc.Int32FromInt32(2)*A + X + libc.Int32FromInt32(2)) >> libc.Int32FromInt32(2))
 	**(**uint8_t)(__ccgo_up(dst + uintptr(libc.Int32FromInt32(1)+libc.Int32FromInt32(0)*libc.Int32FromInt32(BPS)))) = v2
 	v1 = v2
 	**(**uint8_t)(__ccgo_up(dst + uintptr(libc.Int32FromInt32(2)+libc.Int32FromInt32(1)*libc.Int32FromInt32(BPS)))) = v1
 	**(**uint8_t)(__ccgo_up(dst + uintptr(libc.Int32FromInt32(3)+libc.Int32FromInt32(2)*libc.Int32FromInt32(BPS)))) = v1
 	v1 = libc.Uint8FromInt32((C + libc.Int32FromInt32(2)*B + A + libc.Int32FromInt32(2)) >> libc.Int32FromInt32(2))
 	**(**uint8_t)(__ccgo_up(dst + uintptr(libc.Int32FromInt32(2)+libc.Int32FromInt32(0)*libc.Int32FromInt32(BPS)))) = v1
 	**(**uint8_t)(__ccgo_up(dst + uintptr(libc.Int32FromInt32(3)+libc.Int32FromInt32(1)*libc.Int32FromInt32(BPS)))) = v1
 	**(**uint8_t)(__ccgo_up(dst + uintptr(libc.Int32FromInt32(3)+libc.Int32FromInt32(0)*libc.Int32FromInt32(BPS)))) = libc.Uint8FromInt32((D + libc.Int32FromInt32(2)*C + B + libc.Int32FromInt32(2)) >> libc.Int32FromInt32(2))
 }
 
 func LD4_C(tls *libc.TLS, dst uintptr) {
 	var A, B, C, D, E, F, G, H int32
 	var v1, v2, v3 uint8_t
 	_, _, _, _, _, _, _, _, _, _, _ = A, B, C, D, E, F, G, H, v1, v2, v3 // Down-Left
 	A = libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(dst + uintptr(libc.Int32FromInt32(0)-libc.Int32FromInt32(BPS)))))
 	B = libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(dst + uintptr(libc.Int32FromInt32(1)-libc.Int32FromInt32(BPS)))))
 	C = libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(dst + uintptr(libc.Int32FromInt32(2)-libc.Int32FromInt32(BPS)))))
 	D = libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(dst + uintptr(libc.Int32FromInt32(3)-libc.Int32FromInt32(BPS)))))
 	E = libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(dst + uintptr(libc.Int32FromInt32(4)-libc.Int32FromInt32(BPS)))))
 	F = libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(dst + uintptr(libc.Int32FromInt32(5)-libc.Int32FromInt32(BPS)))))
 	G = libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(dst + uintptr(libc.Int32FromInt32(6)-libc.Int32FromInt32(BPS)))))
 	H = libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(dst + uintptr(libc.Int32FromInt32(7)-libc.Int32FromInt32(BPS)))))
 	**(**uint8_t)(__ccgo_up(dst + uintptr(libc.Int32FromInt32(0)+libc.Int32FromInt32(0)*libc.Int32FromInt32(BPS)))) = libc.Uint8FromInt32((A + libc.Int32FromInt32(2)*B + C + libc.Int32FromInt32(2)) >> libc.Int32FromInt32(2))
 	v1 = libc.Uint8FromInt32((B + libc.Int32FromInt32(2)*C + D + libc.Int32FromInt32(2)) >> libc.Int32FromInt32(2))
 	**(**uint8_t)(__ccgo_up(dst + uintptr(libc.Int32FromInt32(0)+libc.Int32FromInt32(1)*libc.Int32FromInt32(BPS)))) = v1
 	**(**uint8_t)(__ccgo_up(dst + uintptr(libc.Int32FromInt32(1)+libc.Int32FromInt32(0)*libc.Int32FromInt32(BPS)))) = v1
 	v2 = libc.Uint8FromInt32((C + libc.Int32FromInt32(2)*D + E + libc.Int32FromInt32(2)) >> libc.Int32FromInt32(2))
 	**(**uint8_t)(__ccgo_up(dst + uintptr(libc.Int32FromInt32(0)+libc.Int32FromInt32(2)*libc.Int32FromInt32(BPS)))) = v2
 	v1 = v2
 	**(**uint8_t)(__ccgo_up(dst + uintptr(libc.Int32FromInt32(1)+libc.Int32FromInt32(1)*libc.Int32FromInt32(BPS)))) = v1
 	**(**uint8_t)(__ccgo_up(dst + uintptr(libc.Int32FromInt32(2)+libc.Int32FromInt32(0)*libc.Int32FromInt32(BPS)))) = v1
 	v3 = libc.Uint8FromInt32((D + libc.Int32FromInt32(2)*E + F + libc.Int32FromInt32(2)) >> libc.Int32FromInt32(2))
 	**(**uint8_t)(__ccgo_up(dst + uintptr(libc.Int32FromInt32(0)+libc.Int32FromInt32(3)*libc.Int32FromInt32(BPS)))) = v3
 	v2 = v3
 	**(**uint8_t)(__ccgo_up(dst + uintptr(libc.Int32FromInt32(1)+libc.Int32FromInt32(2)*libc.Int32FromInt32(BPS)))) = v2
 	v1 = v2
 	**(**uint8_t)(__ccgo_up(dst + uintptr(libc.Int32FromInt32(2)+libc.Int32FromInt32(1)*libc.Int32FromInt32(BPS)))) = v1
 	**(**uint8_t)(__ccgo_up(dst + uintptr(libc.Int32FromInt32(3)+libc.Int32FromInt32(0)*libc.Int32FromInt32(BPS)))) = v1
 	v2 = libc.Uint8FromInt32((E + libc.Int32FromInt32(2)*F + G + libc.Int32FromInt32(2)) >> libc.Int32FromInt32(2))
 	**(**uint8_t)(__ccgo_up(dst + uintptr(libc.Int32FromInt32(1)+libc.Int32FromInt32(3)*libc.Int32FromInt32(BPS)))) = v2
 	v1 = v2
 	**(**uint8_t)(__ccgo_up(dst + uintptr(libc.Int32FromInt32(2)+libc.Int32FromInt32(2)*libc.Int32FromInt32(BPS)))) = v1
 	**(**uint8_t)(__ccgo_up(dst + uintptr(libc.Int32FromInt32(3)+libc.Int32FromInt32(1)*libc.Int32FromInt32(BPS)))) = v1
 	v1 = libc.Uint8FromInt32((F + libc.Int32FromInt32(2)*G + H + libc.Int32FromInt32(2)) >> libc.Int32FromInt32(2))
 	**(**uint8_t)(__ccgo_up(dst + uintptr(libc.Int32FromInt32(2)+libc.Int32FromInt32(3)*libc.Int32FromInt32(BPS)))) = v1
 	**(**uint8_t)(__ccgo_up(dst + uintptr(libc.Int32FromInt32(3)+libc.Int32FromInt32(2)*libc.Int32FromInt32(BPS)))) = v1
 	**(**uint8_t)(__ccgo_up(dst + uintptr(libc.Int32FromInt32(3)+libc.Int32FromInt32(3)*libc.Int32FromInt32(BPS)))) = libc.Uint8FromInt32((G + libc.Int32FromInt32(2)*H + H + libc.Int32FromInt32(2)) >> libc.Int32FromInt32(2))
 }
 
 func VR4_C(tls *libc.TLS, dst uintptr) {
 	var A, B, C, D, I, J, K, X int32
 	var v1 uint8_t
 	_, _, _, _, _, _, _, _, _ = A, B, C, D, I, J, K, X, v1 // Vertical-Right
 	I = libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(dst + uintptr(-libc.Int32FromInt32(1)+libc.Int32FromInt32(0)*libc.Int32FromInt32(BPS)))))
 	J = libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(dst + uintptr(-libc.Int32FromInt32(1)+libc.Int32FromInt32(1)*libc.Int32FromInt32(BPS)))))
 	K = libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(dst + uintptr(-libc.Int32FromInt32(1)+libc.Int32FromInt32(2)*libc.Int32FromInt32(BPS)))))
 	X = libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(dst + uintptr(-libc.Int32FromInt32(1)-libc.Int32FromInt32(BPS)))))
 	A = libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(dst + uintptr(libc.Int32FromInt32(0)-libc.Int32FromInt32(BPS)))))
 	B = libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(dst + uintptr(libc.Int32FromInt32(1)-libc.Int32FromInt32(BPS)))))
 	C = libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(dst + uintptr(libc.Int32FromInt32(2)-libc.Int32FromInt32(BPS)))))
 	D = libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(dst + uintptr(libc.Int32FromInt32(3)-libc.Int32FromInt32(BPS)))))
 	v1 = libc.Uint8FromInt32((X + A + libc.Int32FromInt32(1)) >> libc.Int32FromInt32(1))
 	**(**uint8_t)(__ccgo_up(dst + uintptr(libc.Int32FromInt32(1)+libc.Int32FromInt32(2)*libc.Int32FromInt32(BPS)))) = v1
 	**(**uint8_t)(__ccgo_up(dst + uintptr(libc.Int32FromInt32(0)+libc.Int32FromInt32(0)*libc.Int32FromInt32(BPS)))) = v1
 	v1 = libc.Uint8FromInt32((A + B + libc.Int32FromInt32(1)) >> libc.Int32FromInt32(1))
 	**(**uint8_t)(__ccgo_up(dst + uintptr(libc.Int32FromInt32(2)+libc.Int32FromInt32(2)*libc.Int32FromInt32(BPS)))) = v1
 	**(**uint8_t)(__ccgo_up(dst + uintptr(libc.Int32FromInt32(1)+libc.Int32FromInt32(0)*libc.Int32FromInt32(BPS)))) = v1
 	v1 = libc.Uint8FromInt32((B + C + libc.Int32FromInt32(1)) >> libc.Int32FromInt32(1))
 	**(**uint8_t)(__ccgo_up(dst + uintptr(libc.Int32FromInt32(3)+libc.Int32FromInt32(2)*libc.Int32FromInt32(BPS)))) = v1
 	**(**uint8_t)(__ccgo_up(dst + uintptr(libc.Int32FromInt32(2)+libc.Int32FromInt32(0)*libc.Int32FromInt32(BPS)))) = v1
 	**(**uint8_t)(__ccgo_up(dst + uintptr(libc.Int32FromInt32(3)+libc.Int32FromInt32(0)*libc.Int32FromInt32(BPS)))) = libc.Uint8FromInt32((C + D + libc.Int32FromInt32(1)) >> libc.Int32FromInt32(1))
 	**(**uint8_t)(__ccgo_up(dst + uintptr(libc.Int32FromInt32(0)+libc.Int32FromInt32(3)*libc.Int32FromInt32(BPS)))) = libc.Uint8FromInt32((K + libc.Int32FromInt32(2)*J + I + libc.Int32FromInt32(2)) >> libc.Int32FromInt32(2))
 	**(**uint8_t)(__ccgo_up(dst + uintptr(libc.Int32FromInt32(0)+libc.Int32FromInt32(2)*libc.Int32FromInt32(BPS)))) = libc.Uint8FromInt32((J + libc.Int32FromInt32(2)*I + X + libc.Int32FromInt32(2)) >> libc.Int32FromInt32(2))
 	v1 = libc.Uint8FromInt32((I + libc.Int32FromInt32(2)*X + A + libc.Int32FromInt32(2)) >> libc.Int32FromInt32(2))
 	**(**uint8_t)(__ccgo_up(dst + uintptr(libc.Int32FromInt32(1)+libc.Int32FromInt32(3)*libc.Int32FromInt32(BPS)))) = v1
 	**(**uint8_t)(__ccgo_up(dst + uintptr(libc.Int32FromInt32(0)+libc.Int32FromInt32(1)*libc.Int32FromInt32(BPS)))) = v1
 	v1 = libc.Uint8FromInt32((X + libc.Int32FromInt32(2)*A + B + libc.Int32FromInt32(2)) >> libc.Int32FromInt32(2))
 	**(**uint8_t)(__ccgo_up(dst + uintptr(libc.Int32FromInt32(2)+libc.Int32FromInt32(3)*libc.Int32FromInt32(BPS)))) = v1
 	**(**uint8_t)(__ccgo_up(dst + uintptr(libc.Int32FromInt32(1)+libc.Int32FromInt32(1)*libc.Int32FromInt32(BPS)))) = v1
 	v1 = libc.Uint8FromInt32((A + libc.Int32FromInt32(2)*B + C + libc.Int32FromInt32(2)) >> libc.Int32FromInt32(2))
 	**(**uint8_t)(__ccgo_up(dst + uintptr(libc.Int32FromInt32(3)+libc.Int32FromInt32(3)*libc.Int32FromInt32(BPS)))) = v1
 	**(**uint8_t)(__ccgo_up(dst + uintptr(libc.Int32FromInt32(2)+libc.Int32FromInt32(1)*libc.Int32FromInt32(BPS)))) = v1
 	**(**uint8_t)(__ccgo_up(dst + uintptr(libc.Int32FromInt32(3)+libc.Int32FromInt32(1)*libc.Int32FromInt32(BPS)))) = libc.Uint8FromInt32((B + libc.Int32FromInt32(2)*C + D + libc.Int32FromInt32(2)) >> libc.Int32FromInt32(2))
 }
 
 func VL4_C(tls *libc.TLS, dst uintptr) {
 	var A, B, C, D, E, F, G, H int32
 	var v1 uint8_t
 	_, _, _, _, _, _, _, _, _ = A, B, C, D, E, F, G, H, v1 // Vertical-Left
 	A = libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(dst + uintptr(libc.Int32FromInt32(0)-libc.Int32FromInt32(BPS)))))
 	B = libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(dst + uintptr(libc.Int32FromInt32(1)-libc.Int32FromInt32(BPS)))))
 	C = libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(dst + uintptr(libc.Int32FromInt32(2)-libc.Int32FromInt32(BPS)))))
 	D = libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(dst + uintptr(libc.Int32FromInt32(3)-libc.Int32FromInt32(BPS)))))
 	E = libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(dst + uintptr(libc.Int32FromInt32(4)-libc.Int32FromInt32(BPS)))))
 	F = libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(dst + uintptr(libc.Int32FromInt32(5)-libc.Int32FromInt32(BPS)))))
 	G = libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(dst + uintptr(libc.Int32FromInt32(6)-libc.Int32FromInt32(BPS)))))
 	H = libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(dst + uintptr(libc.Int32FromInt32(7)-libc.Int32FromInt32(BPS)))))
 	**(**uint8_t)(__ccgo_up(dst + uintptr(libc.Int32FromInt32(0)+libc.Int32FromInt32(0)*libc.Int32FromInt32(BPS)))) = libc.Uint8FromInt32((A + B + libc.Int32FromInt32(1)) >> libc.Int32FromInt32(1))
 	v1 = libc.Uint8FromInt32((B + C + libc.Int32FromInt32(1)) >> libc.Int32FromInt32(1))
 	**(**uint8_t)(__ccgo_up(dst + uintptr(libc.Int32FromInt32(0)+libc.Int32FromInt32(2)*libc.Int32FromInt32(BPS)))) = v1
 	**(**uint8_t)(__ccgo_up(dst + uintptr(libc.Int32FromInt32(1)+libc.Int32FromInt32(0)*libc.Int32FromInt32(BPS)))) = v1
 	v1 = libc.Uint8FromInt32((C + D + libc.Int32FromInt32(1)) >> libc.Int32FromInt32(1))
 	**(**uint8_t)(__ccgo_up(dst + uintptr(libc.Int32FromInt32(1)+libc.Int32FromInt32(2)*libc.Int32FromInt32(BPS)))) = v1
 	**(**uint8_t)(__ccgo_up(dst + uintptr(libc.Int32FromInt32(2)+libc.Int32FromInt32(0)*libc.Int32FromInt32(BPS)))) = v1
 	v1 = libc.Uint8FromInt32((D + E + libc.Int32FromInt32(1)) >> libc.Int32FromInt32(1))
 	**(**uint8_t)(__ccgo_up(dst + uintptr(libc.Int32FromInt32(2)+libc.Int32FromInt32(2)*libc.Int32FromInt32(BPS)))) = v1
 	**(**uint8_t)(__ccgo_up(dst + uintptr(libc.Int32FromInt32(3)+libc.Int32FromInt32(0)*libc.Int32FromInt32(BPS)))) = v1
 	**(**uint8_t)(__ccgo_up(dst + uintptr(libc.Int32FromInt32(0)+libc.Int32FromInt32(1)*libc.Int32FromInt32(BPS)))) = libc.Uint8FromInt32((A + libc.Int32FromInt32(2)*B + C + libc.Int32FromInt32(2)) >> libc.Int32FromInt32(2))
 	v1 = libc.Uint8FromInt32((B + libc.Int32FromInt32(2)*C + D + libc.Int32FromInt32(2)) >> libc.Int32FromInt32(2))
 	**(**uint8_t)(__ccgo_up(dst + uintptr(libc.Int32FromInt32(0)+libc.Int32FromInt32(3)*libc.Int32FromInt32(BPS)))) = v1
 	**(**uint8_t)(__ccgo_up(dst + uintptr(libc.Int32FromInt32(1)+libc.Int32FromInt32(1)*libc.Int32FromInt32(BPS)))) = v1
 	v1 = libc.Uint8FromInt32((C + libc.Int32FromInt32(2)*D + E + libc.Int32FromInt32(2)) >> libc.Int32FromInt32(2))
 	**(**uint8_t)(__ccgo_up(dst + uintptr(libc.Int32FromInt32(1)+libc.Int32FromInt32(3)*libc.Int32FromInt32(BPS)))) = v1
 	**(**uint8_t)(__ccgo_up(dst + uintptr(libc.Int32FromInt32(2)+libc.Int32FromInt32(1)*libc.Int32FromInt32(BPS)))) = v1
 	v1 = libc.Uint8FromInt32((D + libc.Int32FromInt32(2)*E + F + libc.Int32FromInt32(2)) >> libc.Int32FromInt32(2))
 	**(**uint8_t)(__ccgo_up(dst + uintptr(libc.Int32FromInt32(2)+libc.Int32FromInt32(3)*libc.Int32FromInt32(BPS)))) = v1
 	**(**uint8_t)(__ccgo_up(dst + uintptr(libc.Int32FromInt32(3)+libc.Int32FromInt32(1)*libc.Int32FromInt32(BPS)))) = v1
 	**(**uint8_t)(__ccgo_up(dst + uintptr(libc.Int32FromInt32(3)+libc.Int32FromInt32(2)*libc.Int32FromInt32(BPS)))) = libc.Uint8FromInt32((E + libc.Int32FromInt32(2)*F + G + libc.Int32FromInt32(2)) >> libc.Int32FromInt32(2))
 	**(**uint8_t)(__ccgo_up(dst + uintptr(libc.Int32FromInt32(3)+libc.Int32FromInt32(3)*libc.Int32FromInt32(BPS)))) = libc.Uint8FromInt32((F + libc.Int32FromInt32(2)*G + H + libc.Int32FromInt32(2)) >> libc.Int32FromInt32(2))
 }
 
 func HU4_C(tls *libc.TLS, dst uintptr) {
 	var I, J, K, L int32
 	var v1, v2, v3, v4, v5 uint8_t
 	_, _, _, _, _, _, _, _, _ = I, J, K, L, v1, v2, v3, v4, v5 // Horizontal-Up
 	I = libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(dst + uintptr(-libc.Int32FromInt32(1)+libc.Int32FromInt32(0)*libc.Int32FromInt32(BPS)))))
 	J = libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(dst + uintptr(-libc.Int32FromInt32(1)+libc.Int32FromInt32(1)*libc.Int32FromInt32(BPS)))))
 	K = libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(dst + uintptr(-libc.Int32FromInt32(1)+libc.Int32FromInt32(2)*libc.Int32FromInt32(BPS)))))
 	L = libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(dst + uintptr(-libc.Int32FromInt32(1)+libc.Int32FromInt32(3)*libc.Int32FromInt32(BPS)))))
 	**(**uint8_t)(__ccgo_up(dst + uintptr(libc.Int32FromInt32(0)+libc.Int32FromInt32(0)*libc.Int32FromInt32(BPS)))) = libc.Uint8FromInt32((I + J + libc.Int32FromInt32(1)) >> libc.Int32FromInt32(1))
 	v1 = libc.Uint8FromInt32((J + K + libc.Int32FromInt32(1)) >> libc.Int32FromInt32(1))
 	**(**uint8_t)(__ccgo_up(dst + uintptr(libc.Int32FromInt32(0)+libc.Int32FromInt32(1)*libc.Int32FromInt32(BPS)))) = v1
 	**(**uint8_t)(__ccgo_up(dst + uintptr(libc.Int32FromInt32(2)+libc.Int32FromInt32(0)*libc.Int32FromInt32(BPS)))) = v1
 	v1 = libc.Uint8FromInt32((K + L + libc.Int32FromInt32(1)) >> libc.Int32FromInt32(1))
 	**(**uint8_t)(__ccgo_up(dst + uintptr(libc.Int32FromInt32(0)+libc.Int32FromInt32(2)*libc.Int32FromInt32(BPS)))) = v1
 	**(**uint8_t)(__ccgo_up(dst + uintptr(libc.Int32FromInt32(2)+libc.Int32FromInt32(1)*libc.Int32FromInt32(BPS)))) = v1
 	**(**uint8_t)(__ccgo_up(dst + uintptr(libc.Int32FromInt32(1)+libc.Int32FromInt32(0)*libc.Int32FromInt32(BPS)))) = libc.Uint8FromInt32((I + libc.Int32FromInt32(2)*J + K + libc.Int32FromInt32(2)) >> libc.Int32FromInt32(2))
 	v1 = libc.Uint8FromInt32((J + libc.Int32FromInt32(2)*K + L + libc.Int32FromInt32(2)) >> libc.Int32FromInt32(2))
 	**(**uint8_t)(__ccgo_up(dst + uintptr(libc.Int32FromInt32(1)+libc.Int32FromInt32(1)*libc.Int32FromInt32(BPS)))) = v1
 	**(**uint8_t)(__ccgo_up(dst + uintptr(libc.Int32FromInt32(3)+libc.Int32FromInt32(0)*libc.Int32FromInt32(BPS)))) = v1
 	v1 = libc.Uint8FromInt32((K + libc.Int32FromInt32(2)*L + L + libc.Int32FromInt32(2)) >> libc.Int32FromInt32(2))
 	**(**uint8_t)(__ccgo_up(dst + uintptr(libc.Int32FromInt32(1)+libc.Int32FromInt32(2)*libc.Int32FromInt32(BPS)))) = v1
 	**(**uint8_t)(__ccgo_up(dst + uintptr(libc.Int32FromInt32(3)+libc.Int32FromInt32(1)*libc.Int32FromInt32(BPS)))) = v1
 	v5 = libc.Uint8FromInt32(L)
 	**(**uint8_t)(__ccgo_up(dst + uintptr(libc.Int32FromInt32(3)+libc.Int32FromInt32(3)*libc.Int32FromInt32(BPS)))) = v5
 	v4 = v5
 	**(**uint8_t)(__ccgo_up(dst + uintptr(libc.Int32FromInt32(2)+libc.Int32FromInt32(3)*libc.Int32FromInt32(BPS)))) = v4
 	v3 = v4
 	**(**uint8_t)(__ccgo_up(dst + uintptr(libc.Int32FromInt32(1)+libc.Int32FromInt32(3)*libc.Int32FromInt32(BPS)))) = v3
 	v2 = v3
 	**(**uint8_t)(__ccgo_up(dst + uintptr(libc.Int32FromInt32(0)+libc.Int32FromInt32(3)*libc.Int32FromInt32(BPS)))) = v2
 	v1 = v2
 	**(**uint8_t)(__ccgo_up(dst + uintptr(libc.Int32FromInt32(2)+libc.Int32FromInt32(2)*libc.Int32FromInt32(BPS)))) = v1
 	**(**uint8_t)(__ccgo_up(dst + uintptr(libc.Int32FromInt32(3)+libc.Int32FromInt32(2)*libc.Int32FromInt32(BPS)))) = v1
 }
 
 func HD4_C(tls *libc.TLS, dst uintptr) {
 	var A, B, C, I, J, K, L, X int32
 	var v1 uint8_t
 	_, _, _, _, _, _, _, _, _ = A, B, C, I, J, K, L, X, v1 // Horizontal-Down
 	I = libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(dst + uintptr(-libc.Int32FromInt32(1)+libc.Int32FromInt32(0)*libc.Int32FromInt32(BPS)))))
 	J = libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(dst + uintptr(-libc.Int32FromInt32(1)+libc.Int32FromInt32(1)*libc.Int32FromInt32(BPS)))))
 	K = libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(dst + uintptr(-libc.Int32FromInt32(1)+libc.Int32FromInt32(2)*libc.Int32FromInt32(BPS)))))
 	L = libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(dst + uintptr(-libc.Int32FromInt32(1)+libc.Int32FromInt32(3)*libc.Int32FromInt32(BPS)))))
 	X = libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(dst + uintptr(-libc.Int32FromInt32(1)-libc.Int32FromInt32(BPS)))))
 	A = libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(dst + uintptr(libc.Int32FromInt32(0)-libc.Int32FromInt32(BPS)))))
 	B = libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(dst + uintptr(libc.Int32FromInt32(1)-libc.Int32FromInt32(BPS)))))
 	C = libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(dst + uintptr(libc.Int32FromInt32(2)-libc.Int32FromInt32(BPS)))))
 	v1 = libc.Uint8FromInt32((I + X + libc.Int32FromInt32(1)) >> libc.Int32FromInt32(1))
 	**(**uint8_t)(__ccgo_up(dst + uintptr(libc.Int32FromInt32(2)+libc.Int32FromInt32(1)*libc.Int32FromInt32(BPS)))) = v1
 	**(**uint8_t)(__ccgo_up(dst + uintptr(libc.Int32FromInt32(0)+libc.Int32FromInt32(0)*libc.Int32FromInt32(BPS)))) = v1
 	v1 = libc.Uint8FromInt32((J + I + libc.Int32FromInt32(1)) >> libc.Int32FromInt32(1))
 	**(**uint8_t)(__ccgo_up(dst + uintptr(libc.Int32FromInt32(2)+libc.Int32FromInt32(2)*libc.Int32FromInt32(BPS)))) = v1
 	**(**uint8_t)(__ccgo_up(dst + uintptr(libc.Int32FromInt32(0)+libc.Int32FromInt32(1)*libc.Int32FromInt32(BPS)))) = v1
 	v1 = libc.Uint8FromInt32((K + J + libc.Int32FromInt32(1)) >> libc.Int32FromInt32(1))
 	**(**uint8_t)(__ccgo_up(dst + uintptr(libc.Int32FromInt32(2)+libc.Int32FromInt32(3)*libc.Int32FromInt32(BPS)))) = v1
 	**(**uint8_t)(__ccgo_up(dst + uintptr(libc.Int32FromInt32(0)+libc.Int32FromInt32(2)*libc.Int32FromInt32(BPS)))) = v1
 	**(**uint8_t)(__ccgo_up(dst + uintptr(libc.Int32FromInt32(0)+libc.Int32FromInt32(3)*libc.Int32FromInt32(BPS)))) = libc.Uint8FromInt32((L + K + libc.Int32FromInt32(1)) >> libc.Int32FromInt32(1))
 	**(**uint8_t)(__ccgo_up(dst + uintptr(libc.Int32FromInt32(3)+libc.Int32FromInt32(0)*libc.Int32FromInt32(BPS)))) = libc.Uint8FromInt32((A + libc.Int32FromInt32(2)*B + C + libc.Int32FromInt32(2)) >> libc.Int32FromInt32(2))
 	**(**uint8_t)(__ccgo_up(dst + uintptr(libc.Int32FromInt32(2)+libc.Int32FromInt32(0)*libc.Int32FromInt32(BPS)))) = libc.Uint8FromInt32((X + libc.Int32FromInt32(2)*A + B + libc.Int32FromInt32(2)) >> libc.Int32FromInt32(2))
 	v1 = libc.Uint8FromInt32((I + libc.Int32FromInt32(2)*X + A + libc.Int32FromInt32(2)) >> libc.Int32FromInt32(2))
 	**(**uint8_t)(__ccgo_up(dst + uintptr(libc.Int32FromInt32(3)+libc.Int32FromInt32(1)*libc.Int32FromInt32(BPS)))) = v1
 	**(**uint8_t)(__ccgo_up(dst + uintptr(libc.Int32FromInt32(1)+libc.Int32FromInt32(0)*libc.Int32FromInt32(BPS)))) = v1
 	v1 = libc.Uint8FromInt32((J + libc.Int32FromInt32(2)*I + X + libc.Int32FromInt32(2)) >> libc.Int32FromInt32(2))
 	**(**uint8_t)(__ccgo_up(dst + uintptr(libc.Int32FromInt32(3)+libc.Int32FromInt32(2)*libc.Int32FromInt32(BPS)))) = v1
 	**(**uint8_t)(__ccgo_up(dst + uintptr(libc.Int32FromInt32(1)+libc.Int32FromInt32(1)*libc.Int32FromInt32(BPS)))) = v1
 	v1 = libc.Uint8FromInt32((K + libc.Int32FromInt32(2)*J + I + libc.Int32FromInt32(2)) >> libc.Int32FromInt32(2))
 	**(**uint8_t)(__ccgo_up(dst + uintptr(libc.Int32FromInt32(3)+libc.Int32FromInt32(3)*libc.Int32FromInt32(BPS)))) = v1
 	**(**uint8_t)(__ccgo_up(dst + uintptr(libc.Int32FromInt32(1)+libc.Int32FromInt32(2)*libc.Int32FromInt32(BPS)))) = v1
 	**(**uint8_t)(__ccgo_up(dst + uintptr(libc.Int32FromInt32(1)+libc.Int32FromInt32(3)*libc.Int32FromInt32(BPS)))) = libc.Uint8FromInt32((L + libc.Int32FromInt32(2)*K + J + libc.Int32FromInt32(2)) >> libc.Int32FromInt32(2))
 }
 
 //------------------------------------------------------------------------------
 // Chroma
 
 func VE8uv_C(tls *libc.TLS, dst uintptr) {
 	var j int32
 	_ = j
 	j = 0
 	for {
 		if !(j < int32(8)) {
 			break
 		}
 		libc.X__builtin___memcpy_chk(tls, dst+uintptr(j*int32(BPS)), dst-uintptr(BPS), uint64(8), ^__predefined_size_t(0))
 		goto _1
 	_1:
 		;
 		j = j + 1
 	}
 }
 
 func HE8uv_C(tls *libc.TLS, dst uintptr) {
 	var j int32
 	_ = j
 	j = 0
 	for {
 		if !(j < int32(8)) {
 			break
 		}
 		libc.X__builtin___memset_chk(tls, dst, libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(dst + uintptr(-libc.Int32FromInt32(1))))), uint64(8), ^__predefined_size_t(0))
 		dst = dst + uintptr(BPS)
 		goto _1
 	_1:
 		;
 		j = j + 1
 	}
 }
 
 // C documentation
 //
 //	// helper for chroma-DC predictions
 func Put8x8uv(tls *libc.TLS, value uint8_t, dst uintptr) {
 	var j int32
 	_ = j
 	j = 0
 	for {
 		if !(j < int32(8)) {
 			break
 		}
 		libc.X__builtin___memset_chk(tls, dst+uintptr(j*int32(BPS)), libc.Int32FromUint8(value), uint64(8), ^__predefined_size_t(0))
 		goto _1
 	_1:
 		;
 		j = j + 1
 	}
 }
 
 func DC8uv_C(tls *libc.TLS, dst uintptr) {
 	var dc0, i int32
 	_, _ = dc0, i // DC
 	dc0 = int32(8)
 	i = 0
 	for {
 		if !(i < int32(8)) {
 			break
 		}
 		dc0 = dc0 + (libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(dst + uintptr(i-int32(BPS))))) + libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(dst + uintptr(-int32(1)+i*int32(BPS))))))
 		goto _1
 	_1:
 		;
 		i = i + 1
 	}
 	Put8x8uv(tls, libc.Uint8FromInt32(dc0>>int32(4)), dst)
 }
 
 func DC8uvNoLeft_C(tls *libc.TLS, dst uintptr) {
 	var dc0, i int32
 	_, _ = dc0, i // DC with no left samples
 	dc0 = int32(4)
 	i = 0
 	for {
 		if !(i < int32(8)) {
 			break
 		}
 		dc0 = dc0 + libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(dst + uintptr(i-int32(BPS)))))
 		goto _1
 	_1:
 		;
 		i = i + 1
 	}
 	Put8x8uv(tls, libc.Uint8FromInt32(dc0>>int32(3)), dst)
 }
 
 func DC8uvNoTop_C(tls *libc.TLS, dst uintptr) {
 	var dc0, i int32
 	_, _ = dc0, i // DC with no top samples
 	dc0 = int32(4)
 	i = 0
 	for {
 		if !(i < int32(8)) {
 			break
 		}
 		dc0 = dc0 + libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(dst + uintptr(-int32(1)+i*int32(BPS)))))
 		goto _1
 	_1:
 		;
 		i = i + 1
 	}
 	Put8x8uv(tls, libc.Uint8FromInt32(dc0>>int32(3)), dst)
 }
 
 func DC8uvNoTopLeft_C(tls *libc.TLS, dst uintptr) {
 	// DC with nothing
 	Put8x8uv(tls, uint8(0x80), dst)
 }
 
 //------------------------------------------------------------------------------
 // Edge filtering functions
 
 // C documentation
 //
 //	// 4 pixels in, 2 pixels out
 func DoFilter2_C(tls *libc.TLS, p uintptr, step int32) {
 	var a, a1, a2, p0, p1, q0, q1 int32
 	_, _, _, _, _, _, _ = a, a1, a2, p0, p1, q0, q1
 	p1 = libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(p + uintptr(-int32(2)*step))))
 	p0 = libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(p + uintptr(-step))))
 	q0 = libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(p)))
 	q1 = libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(p + uintptr(step))))
 	a = int32(3)*(q0-p0) + int32(**(**int8_t)(__ccgo_up(VP8ksclip1 + uintptr(p1-q1)))) // in [-893,892]
 	a1 = int32(**(**int8_t)(__ccgo_up(VP8ksclip2 + uintptr((a+int32(4))>>int32(3)))))  // in [-16,15]
 	a2 = int32(**(**int8_t)(__ccgo_up(VP8ksclip2 + uintptr((a+int32(3))>>int32(3)))))
 	**(**uint8_t)(__ccgo_up(p + uintptr(-step))) = **(**uint8_t)(__ccgo_up(VP8kclip1 + uintptr(p0+a2)))
 	**(**uint8_t)(__ccgo_up(p)) = **(**uint8_t)(__ccgo_up(VP8kclip1 + uintptr(q0-a1)))
 }
 
 // C documentation
 //
 //	// 4 pixels in, 4 pixels out
 func DoFilter4_C(tls *libc.TLS, p uintptr, step int32) {
 	var a, a1, a2, a3, p0, p1, q0, q1 int32
 	_, _, _, _, _, _, _, _ = a, a1, a2, a3, p0, p1, q0, q1
 	p1 = libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(p + uintptr(-int32(2)*step))))
 	p0 = libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(p + uintptr(-step))))
 	q0 = libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(p)))
 	q1 = libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(p + uintptr(step))))
 	a = int32(3) * (q0 - p0)
 	a1 = int32(**(**int8_t)(__ccgo_up(VP8ksclip2 + uintptr((a+int32(4))>>int32(3)))))
 	a2 = int32(**(**int8_t)(__ccgo_up(VP8ksclip2 + uintptr((a+int32(3))>>int32(3)))))
 	a3 = (a1 + int32(1)) >> int32(1)
 	**(**uint8_t)(__ccgo_up(p + uintptr(-int32(2)*step))) = **(**uint8_t)(__ccgo_up(VP8kclip1 + uintptr(p1+a3)))
 	**(**uint8_t)(__ccgo_up(p + uintptr(-step))) = **(**uint8_t)(__ccgo_up(VP8kclip1 + uintptr(p0+a2)))
 	**(**uint8_t)(__ccgo_up(p)) = **(**uint8_t)(__ccgo_up(VP8kclip1 + uintptr(q0-a1)))
 	**(**uint8_t)(__ccgo_up(p + uintptr(step))) = **(**uint8_t)(__ccgo_up(VP8kclip1 + uintptr(q1-a3)))
 }
 
 // C documentation
 //
 //	// 6 pixels in, 6 pixels out
 func DoFilter6_C(tls *libc.TLS, p uintptr, step int32) {
 	var a, a1, a2, a3, p0, p1, p2, q0, q1, q2 int32
 	_, _, _, _, _, _, _, _, _, _ = a, a1, a2, a3, p0, p1, p2, q0, q1, q2
 	p2 = libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(p + uintptr(-int32(3)*step))))
 	p1 = libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(p + uintptr(-int32(2)*step))))
 	p0 = libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(p + uintptr(-step))))
 	q0 = libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(p)))
 	q1 = libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(p + uintptr(step))))
 	q2 = libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(p + uintptr(int32(2)*step))))
 	a = int32(**(**int8_t)(__ccgo_up(VP8ksclip1 + uintptr(int32(3)*(q0-p0)+int32(**(**int8_t)(__ccgo_up(VP8ksclip1 + uintptr(p1-q1))))))))
 	// a is in [-128,127], a1 in [-27,27], a2 in [-18,18] and a3 in [-9,9]
 	a1 = (int32(27)*a + int32(63)) >> int32(7) // eq. to ((3 * a + 7) * 9) >> 7
 	a2 = (int32(18)*a + int32(63)) >> int32(7) // eq. to ((2 * a + 7) * 9) >> 7
 	a3 = (int32(9)*a + int32(63)) >> int32(7)  // eq. to ((1 * a + 7) * 9) >> 7
 	**(**uint8_t)(__ccgo_up(p + uintptr(-int32(3)*step))) = **(**uint8_t)(__ccgo_up(VP8kclip1 + uintptr(p2+a3)))
 	**(**uint8_t)(__ccgo_up(p + uintptr(-int32(2)*step))) = **(**uint8_t)(__ccgo_up(VP8kclip1 + uintptr(p1+a2)))
 	**(**uint8_t)(__ccgo_up(p + uintptr(-step))) = **(**uint8_t)(__ccgo_up(VP8kclip1 + uintptr(p0+a1)))
 	**(**uint8_t)(__ccgo_up(p)) = **(**uint8_t)(__ccgo_up(VP8kclip1 + uintptr(q0-a1)))
 	**(**uint8_t)(__ccgo_up(p + uintptr(step))) = **(**uint8_t)(__ccgo_up(VP8kclip1 + uintptr(q1-a2)))
 	**(**uint8_t)(__ccgo_up(p + uintptr(int32(2)*step))) = **(**uint8_t)(__ccgo_up(VP8kclip1 + uintptr(q2-a3)))
 }
 
 func Hev(tls *libc.TLS, p uintptr, step int32, thresh int32) (r int32) {
 	var p0, p1, q0, q1 int32
 	_, _, _, _ = p0, p1, q0, q1
 	p1 = libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(p + uintptr(-int32(2)*step))))
 	p0 = libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(p + uintptr(-step))))
 	q0 = libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(p)))
 	q1 = libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(p + uintptr(step))))
 	return libc.BoolInt32(libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(VP8kabs0 + uintptr(p1-p0)))) > thresh || libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(VP8kabs0 + uintptr(q1-q0)))) > thresh)
 }
 
 func NeedsFilter_C(tls *libc.TLS, p uintptr, step int32, t int32) (r int32) {
 	var p0, p1, q0, q1 int32
 	_, _, _, _ = p0, p1, q0, q1
 	p1 = libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(p + uintptr(-int32(2)*step))))
 	p0 = libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(p + uintptr(-step))))
 	q0 = libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(p)))
 	q1 = libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(p + uintptr(step))))
 	return libc.BoolInt32(int32(4)*libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(VP8kabs0 + uintptr(p0-q0))))+libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(VP8kabs0 + uintptr(p1-q1)))) <= t)
 }
 
 func NeedsFilter2_C(tls *libc.TLS, p uintptr, step int32, t int32, it int32) (r int32) {
 	var p0, p1, p2, p3, q0, q1, q2, q3 int32
 	_, _, _, _, _, _, _, _ = p0, p1, p2, p3, q0, q1, q2, q3
 	p3 = libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(p + uintptr(-int32(4)*step))))
 	p2 = libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(p + uintptr(-int32(3)*step))))
 	p1 = libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(p + uintptr(-int32(2)*step))))
 	p0 = libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(p + uintptr(-step))))
 	q0 = libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(p)))
 	q1 = libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(p + uintptr(step))))
 	q2 = libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(p + uintptr(int32(2)*step))))
 	q3 = libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(p + uintptr(int32(3)*step))))
 	if int32(4)*libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(VP8kabs0 + uintptr(p0-q0))))+libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(VP8kabs0 + uintptr(p1-q1)))) > t {
 		return 0
 	}
 	return libc.BoolInt32(libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(VP8kabs0 + uintptr(p3-p2)))) <= it && libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(VP8kabs0 + uintptr(p2-p1)))) <= it && libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(VP8kabs0 + uintptr(p1-p0)))) <= it && libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(VP8kabs0 + uintptr(q3-q2)))) <= it && libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(VP8kabs0 + uintptr(q2-q1)))) <= it && libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(VP8kabs0 + uintptr(q1-q0)))) <= it)
 }
 
 //------------------------------------------------------------------------------
 // Simple In-loop filtering (Paragraph 15.2)
 
 func SimpleVFilter16_C(tls *libc.TLS, p uintptr, stride int32, thresh int32) {
 	var i, thresh2 int32
 	_, _ = i, thresh2
 	thresh2 = int32(2)*thresh + int32(1)
 	i = 0
 	for {
 		if !(i < int32(16)) {
 			break
 		}
 		if NeedsFilter_C(tls, p+uintptr(i), stride, thresh2) != 0 {
 			DoFilter2_C(tls, p+uintptr(i), stride)
 		}
 		goto _1
 	_1:
 		;
 		i = i + 1
 	}
 }
 
 func SimpleHFilter16_C(tls *libc.TLS, p uintptr, stride int32, thresh int32) {
 	var i, thresh2 int32
 	_, _ = i, thresh2
 	thresh2 = int32(2)*thresh + int32(1)
 	i = 0
 	for {
 		if !(i < int32(16)) {
 			break
 		}
 		if NeedsFilter_C(tls, p+uintptr(i*stride), int32(1), thresh2) != 0 {
 			DoFilter2_C(tls, p+uintptr(i*stride), int32(1))
 		}
 		goto _1
 	_1:
 		;
 		i = i + 1
 	}
 }
 
 func SimpleVFilter16i_C(tls *libc.TLS, p uintptr, stride int32, thresh int32) {
 	var k int32
 	_ = k
 	k = int32(3)
 	for {
 		if !(k > 0) {
 			break
 		}
 		p = p + uintptr(int32(4)*stride)
 		SimpleVFilter16_C(tls, p, stride, thresh)
 		goto _1
 	_1:
 		;
 		k = k - 1
 	}
 }
 
 func SimpleHFilter16i_C(tls *libc.TLS, p uintptr, stride int32, thresh int32) {
 	var k int32
 	_ = k
 	k = int32(3)
 	for {
 		if !(k > 0) {
 			break
 		}
 		p = p + uintptr(4)
 		SimpleHFilter16_C(tls, p, stride, thresh)
 		goto _1
 	_1:
 		;
 		k = k - 1
 	}
 }
 
 //------------------------------------------------------------------------------
 // Complex In-loop filtering (Paragraph 15.3)
 
 func FilterLoop26_C(tls *libc.TLS, p uintptr, hstride int32, vstride int32, size int32, thresh int32, ithresh int32, hev_thresh int32) {
 	var thresh2, v1 int32
 	_, _ = thresh2, v1
 	thresh2 = int32(2)*thresh + int32(1)
 	for {
 		v1 = size
 		size = size - 1
 		if !(v1 > 0) {
 			break
 		}
 		if NeedsFilter2_C(tls, p, hstride, thresh2, ithresh) != 0 {
 			if Hev(tls, p, hstride, hev_thresh) != 0 {
 				DoFilter2_C(tls, p, hstride)
 			} else {
 				DoFilter6_C(tls, p, hstride)
 			}
 		}
 		p = p + uintptr(vstride)
 	}
 }
 
 func FilterLoop24_C(tls *libc.TLS, p uintptr, hstride int32, vstride int32, size int32, thresh int32, ithresh int32, hev_thresh int32) {
 	var thresh2, v1 int32
 	_, _ = thresh2, v1
 	thresh2 = int32(2)*thresh + int32(1)
 	for {
 		v1 = size
 		size = size - 1
 		if !(v1 > 0) {
 			break
 		}
 		if NeedsFilter2_C(tls, p, hstride, thresh2, ithresh) != 0 {
 			if Hev(tls, p, hstride, hev_thresh) != 0 {
 				DoFilter2_C(tls, p, hstride)
 			} else {
 				DoFilter4_C(tls, p, hstride)
 			}
 		}
 		p = p + uintptr(vstride)
 	}
 }
 
 // C documentation
 //
 //	// on macroblock edges
 func VFilter16_C(tls *libc.TLS, p uintptr, stride int32, thresh int32, ithresh int32, hev_thresh int32) {
 	FilterLoop26_C(tls, p, stride, int32(1), int32(16), thresh, ithresh, hev_thresh)
 }
 
 func HFilter16_C(tls *libc.TLS, p uintptr, stride int32, thresh int32, ithresh int32, hev_thresh int32) {
 	FilterLoop26_C(tls, p, int32(1), stride, int32(16), thresh, ithresh, hev_thresh)
 }
 
 // C documentation
 //
 //	// on three inner edges
 func VFilter16i_C(tls *libc.TLS, p uintptr, stride int32, thresh int32, ithresh int32, hev_thresh int32) {
 	var k int32
 	_ = k
 	k = int32(3)
 	for {
 		if !(k > 0) {
 			break
 		}
 		p = p + uintptr(int32(4)*stride)
 		FilterLoop24_C(tls, p, stride, int32(1), int32(16), thresh, ithresh, hev_thresh)
 		goto _1
 	_1:
 		;
 		k = k - 1
 	}
 }
 
 func HFilter16i_C(tls *libc.TLS, p uintptr, stride int32, thresh int32, ithresh int32, hev_thresh int32) {
 	var k int32
 	_ = k
 	k = int32(3)
 	for {
 		if !(k > 0) {
 			break
 		}
 		p = p + uintptr(4)
 		FilterLoop24_C(tls, p, int32(1), stride, int32(16), thresh, ithresh, hev_thresh)
 		goto _1
 	_1:
 		;
 		k = k - 1
 	}
 }
 
 // C documentation
 //
 //	// 8-pixels wide variant, for chroma filtering
 func VFilter8_C(tls *libc.TLS, u uintptr, v uintptr, stride int32, thresh int32, ithresh int32, hev_thresh int32) {
 	FilterLoop26_C(tls, u, stride, int32(1), int32(8), thresh, ithresh, hev_thresh)
 	FilterLoop26_C(tls, v, stride, int32(1), int32(8), thresh, ithresh, hev_thresh)
 }
 
 func HFilter8_C(tls *libc.TLS, u uintptr, v uintptr, stride int32, thresh int32, ithresh int32, hev_thresh int32) {
 	FilterLoop26_C(tls, u, int32(1), stride, int32(8), thresh, ithresh, hev_thresh)
 	FilterLoop26_C(tls, v, int32(1), stride, int32(8), thresh, ithresh, hev_thresh)
 }
 
 func VFilter8i_C(tls *libc.TLS, u uintptr, v uintptr, stride int32, thresh int32, ithresh int32, hev_thresh int32) {
 	FilterLoop24_C(tls, u+uintptr(int32(4)*stride), stride, int32(1), int32(8), thresh, ithresh, hev_thresh)
 	FilterLoop24_C(tls, v+uintptr(int32(4)*stride), stride, int32(1), int32(8), thresh, ithresh, hev_thresh)
 }
 
 func HFilter8i_C(tls *libc.TLS, u uintptr, v uintptr, stride int32, thresh int32, ithresh int32, hev_thresh int32) {
 	FilterLoop24_C(tls, u+uintptr(4), int32(1), stride, int32(8), thresh, ithresh, hev_thresh)
 	FilterLoop24_C(tls, v+uintptr(4), int32(1), stride, int32(8), thresh, ithresh, hev_thresh)
 }
 
 //------------------------------------------------------------------------------
 
 func DitherCombine8x8_C(tls *libc.TLS, dither uintptr, dst uintptr, dst_stride int32) {
 	var delta0, delta1, i, j int32
 	_, _, _, _ = delta0, delta1, i, j
 	j = 0
 	for {
 		if !(j < int32(8)) {
 			break
 		}
 		i = 0
 		for {
 			if !(i < int32(8)) {
 				break
 			}
 			delta0 = libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(dither + uintptr(i)))) - libc.Int32FromInt32(1)<<libc.Int32FromInt32(VP8_DITHER_AMP_BITS)
 			delta1 = (delta0 + libc.Int32FromInt32(1)<<(libc.Int32FromInt32(VP8_DITHER_DESCALE)-libc.Int32FromInt32(1))) >> int32(VP8_DITHER_DESCALE)
 			**(**uint8_t)(__ccgo_up(dst + uintptr(i))) = clip_8b1(tls, libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(dst + uintptr(i))))+delta1)
 			goto _2
 		_2:
 			;
 			i = i + 1
 		}
 		dst = dst + uintptr(dst_stride)
 		dither = dither + uintptr(8)
 		goto _1
 	_1:
 		;
 		j = j + 1
 	}
 }
 
 func VP8DspInit(tls *libc.TLS) {
 	if libc.AtomicLoadPUintptr(uintptr(unsafe.Pointer(&VP8DspInit_body_last_cpuinfo_used))) == VP8GetCPUInfo {
 		goto _1
 	}
 	VP8DspInit_body(tls)
 	libc.AtomicStorePUintptr(uintptr(unsafe.Pointer(&VP8DspInit_body_last_cpuinfo_used)), VP8GetCPUInfo)
 	goto _2
 _2:
 	;
 	goto _1
 _1: /**/ //
 }
 
 var VP8DspInit_body_last_cpuinfo_used = uintptr(0)
 
 func init() {
 	p := unsafe.Pointer(&VP8DspInit_body_last_cpuinfo_used)
 	*(*uintptr)(unsafe.Add(p, 0)) = uintptr(unsafe.Pointer(&VP8DspInit_body_last_cpuinfo_used))
 }
 
 func VP8DspInit_body(tls *libc.TLS) {
 	VP8InitClipTables(tls)
 	VP8TransformWHT = __ccgo_fp(TransformWHT_C)
 	VP8Transform = __ccgo_fp(TransformTwo_C)
 	VP8TransformDC = __ccgo_fp(TransformDC_C)
 	VP8TransformAC3 = __ccgo_fp(TransformAC3_C)
 	VP8TransformUV = __ccgo_fp(TransformUV_C)
 	VP8TransformDCUV = __ccgo_fp(TransformDCUV_C)
 	VP8VFilter16 = __ccgo_fp(VFilter16_C)
 	VP8VFilter16i = __ccgo_fp(VFilter16i_C)
 	VP8HFilter16 = __ccgo_fp(HFilter16_C)
 	VP8VFilter8 = __ccgo_fp(VFilter8_C)
 	VP8VFilter8i = __ccgo_fp(VFilter8i_C)
 	VP8SimpleVFilter16 = __ccgo_fp(SimpleVFilter16_C)
 	VP8SimpleHFilter16 = __ccgo_fp(SimpleHFilter16_C)
 	VP8SimpleVFilter16i = __ccgo_fp(SimpleVFilter16i_C)
 	VP8SimpleHFilter16i = __ccgo_fp(SimpleHFilter16i_C)
 	VP8HFilter16i = __ccgo_fp(HFilter16i_C)
 	VP8HFilter8 = __ccgo_fp(HFilter8_C)
 	VP8HFilter8i = __ccgo_fp(HFilter8i_C)
 	VP8PredLuma4[0] = __ccgo_fp(DC4_C)
 	VP8PredLuma4[int32(1)] = __ccgo_fp(TM4_C)
 	VP8PredLuma4[int32(2)] = __ccgo_fp(VE4_C)
 	VP8PredLuma4[int32(4)] = __ccgo_fp(RD4_C)
 	VP8PredLuma4[int32(6)] = __ccgo_fp(LD4_C)
 	VP8PredLuma4[int32(3)] = __ccgo_fp(HE4_C)
 	VP8PredLuma4[int32(5)] = __ccgo_fp(VR4_C)
 	VP8PredLuma4[int32(7)] = __ccgo_fp(VL4_C)
 	VP8PredLuma4[int32(8)] = __ccgo_fp(HD4_C)
 	VP8PredLuma4[int32(9)] = __ccgo_fp(HU4_C)
 	VP8PredLuma16[0] = __ccgo_fp(DC16_C)
 	VP8PredLuma16[int32(1)] = __ccgo_fp(TM16_C)
 	VP8PredLuma16[int32(2)] = __ccgo_fp(VE16_C)
 	VP8PredLuma16[int32(3)] = __ccgo_fp(HE16_C)
 	VP8PredLuma16[int32(4)] = __ccgo_fp(DC16NoTop_C)
 	VP8PredLuma16[int32(5)] = __ccgo_fp(DC16NoLeft_C)
 	VP8PredLuma16[int32(6)] = __ccgo_fp(DC16NoTopLeft_C)
 	VP8PredChroma8[0] = __ccgo_fp(DC8uv_C)
 	VP8PredChroma8[int32(1)] = __ccgo_fp(TM8uv_C)
 	VP8PredChroma8[int32(2)] = __ccgo_fp(VE8uv_C)
 	VP8PredChroma8[int32(3)] = __ccgo_fp(HE8uv_C)
 	VP8PredChroma8[int32(4)] = __ccgo_fp(DC8uvNoTop_C)
 	VP8PredChroma8[int32(5)] = __ccgo_fp(DC8uvNoLeft_C)
 	VP8PredChroma8[int32(6)] = __ccgo_fp(DC8uvNoTopLeft_C)
 	VP8DitherCombine8x8 = __ccgo_fp(DitherCombine8x8_C)
 	// If defined, use CPUInfo() to overwrite some pointers with faster versions.
 	if VP8GetCPUInfo != libc.UintptrFromInt32(0) {
 	}
 }
 
 const USE_STATIC_TABLES = 1
 
 // define to 0 to have run-time table initialization
 
 var abs0 = [511]uint8_t{
 	0:   uint8(0xff),
 	1:   uint8(0xfe),
 	2:   uint8(0xfd),
 	3:   uint8(0xfc),
 	4:   uint8(0xfb),
 	5:   uint8(0xfa),
 	6:   uint8(0xf9),
 	7:   uint8(0xf8),
 	8:   uint8(0xf7),
 	9:   uint8(0xf6),
 	10:  uint8(0xf5),
 	11:  uint8(0xf4),
 	12:  uint8(0xf3),
 	13:  uint8(0xf2),
 	14:  uint8(0xf1),
 	15:  uint8(0xf0),
 	16:  uint8(0xef),
 	17:  uint8(0xee),
 	18:  uint8(0xed),
 	19:  uint8(0xec),
 	20:  uint8(0xeb),
 	21:  uint8(0xea),
 	22:  uint8(0xe9),
 	23:  uint8(0xe8),
 	24:  uint8(0xe7),
 	25:  uint8(0xe6),
 	26:  uint8(0xe5),
 	27:  uint8(0xe4),
 	28:  uint8(0xe3),
 	29:  uint8(0xe2),
 	30:  uint8(0xe1),
 	31:  uint8(0xe0),
 	32:  uint8(0xdf),
 	33:  uint8(0xde),
 	34:  uint8(0xdd),
 	35:  uint8(0xdc),
 	36:  uint8(0xdb),
 	37:  uint8(0xda),
 	38:  uint8(0xd9),
 	39:  uint8(0xd8),
 	40:  uint8(0xd7),
 	41:  uint8(0xd6),
 	42:  uint8(0xd5),
 	43:  uint8(0xd4),
 	44:  uint8(0xd3),
 	45:  uint8(0xd2),
 	46:  uint8(0xd1),
 	47:  uint8(0xd0),
 	48:  uint8(0xcf),
 	49:  uint8(0xce),
 	50:  uint8(0xcd),
 	51:  uint8(0xcc),
 	52:  uint8(0xcb),
 	53:  uint8(0xca),
 	54:  uint8(0xc9),
 	55:  uint8(0xc8),
 	56:  uint8(0xc7),
 	57:  uint8(0xc6),
 	58:  uint8(0xc5),
 	59:  uint8(0xc4),
 	60:  uint8(0xc3),
 	61:  uint8(0xc2),
 	62:  uint8(0xc1),
 	63:  uint8(0xc0),
 	64:  uint8(0xbf),
 	65:  uint8(0xbe),
 	66:  uint8(0xbd),
 	67:  uint8(0xbc),
 	68:  uint8(0xbb),
 	69:  uint8(0xba),
 	70:  uint8(0xb9),
 	71:  uint8(0xb8),
 	72:  uint8(0xb7),
 	73:  uint8(0xb6),
 	74:  uint8(0xb5),
 	75:  uint8(0xb4),
 	76:  uint8(0xb3),
 	77:  uint8(0xb2),
 	78:  uint8(0xb1),
 	79:  uint8(0xb0),
 	80:  uint8(0xaf),
 	81:  uint8(0xae),
 	82:  uint8(0xad),
 	83:  uint8(0xac),
 	84:  uint8(0xab),
 	85:  uint8(0xaa),
 	86:  uint8(0xa9),
 	87:  uint8(0xa8),
 	88:  uint8(0xa7),
 	89:  uint8(0xa6),
 	90:  uint8(0xa5),
 	91:  uint8(0xa4),
 	92:  uint8(0xa3),
 	93:  uint8(0xa2),
 	94:  uint8(0xa1),
 	95:  uint8(0xa0),
 	96:  uint8(0x9f),
 	97:  uint8(0x9e),
 	98:  uint8(0x9d),
 	99:  uint8(0x9c),
 	100: uint8(0x9b),
 	101: uint8(0x9a),
 	102: uint8(0x99),
 	103: uint8(0x98),
 	104: uint8(0x97),
 	105: uint8(0x96),
 	106: uint8(0x95),
 	107: uint8(0x94),
 	108: uint8(0x93),
 	109: uint8(0x92),
 	110: uint8(0x91),
 	111: uint8(0x90),
 	112: uint8(0x8f),
 	113: uint8(0x8e),
 	114: uint8(0x8d),
 	115: uint8(0x8c),
 	116: uint8(0x8b),
 	117: uint8(0x8a),
 	118: uint8(0x89),
 	119: uint8(0x88),
 	120: uint8(0x87),
 	121: uint8(0x86),
 	122: uint8(0x85),
 	123: uint8(0x84),
 	124: uint8(0x83),
 	125: uint8(0x82),
 	126: uint8(0x81),
 	127: uint8(0x80),
 	128: uint8(0x7f),
 	129: uint8(0x7e),
 	130: uint8(0x7d),
 	131: uint8(0x7c),
 	132: uint8(0x7b),
 	133: uint8(0x7a),
 	134: uint8(0x79),
 	135: uint8(0x78),
 	136: uint8(0x77),
 	137: uint8(0x76),
 	138: uint8(0x75),
 	139: uint8(0x74),
 	140: uint8(0x73),
 	141: uint8(0x72),
 	142: uint8(0x71),
 	143: uint8(0x70),
 	144: uint8(0x6f),
 	145: uint8(0x6e),
 	146: uint8(0x6d),
 	147: uint8(0x6c),
 	148: uint8(0x6b),
 	149: uint8(0x6a),
 	150: uint8(0x69),
 	151: uint8(0x68),
 	152: uint8(0x67),
 	153: uint8(0x66),
 	154: uint8(0x65),
 	155: uint8(0x64),
 	156: uint8(0x63),
 	157: uint8(0x62),
 	158: uint8(0x61),
 	159: uint8(0x60),
 	160: uint8(0x5f),
 	161: uint8(0x5e),
 	162: uint8(0x5d),
 	163: uint8(0x5c),
 	164: uint8(0x5b),
 	165: uint8(0x5a),
 	166: uint8(0x59),
 	167: uint8(0x58),
 	168: uint8(0x57),
 	169: uint8(0x56),
 	170: uint8(0x55),
 	171: uint8(0x54),
 	172: uint8(0x53),
 	173: uint8(0x52),
 	174: uint8(0x51),
 	175: uint8(0x50),
 	176: uint8(0x4f),
 	177: uint8(0x4e),
 	178: uint8(0x4d),
 	179: uint8(0x4c),
 	180: uint8(0x4b),
 	181: uint8(0x4a),
 	182: uint8(0x49),
 	183: uint8(0x48),
 	184: uint8(0x47),
 	185: uint8(0x46),
 	186: uint8(0x45),
 	187: uint8(0x44),
 	188: uint8(0x43),
 	189: uint8(0x42),
 	190: uint8(0x41),
 	191: uint8(0x40),
 	192: uint8(0x3f),
 	193: uint8(0x3e),
 	194: uint8(0x3d),
 	195: uint8(0x3c),
 	196: uint8(0x3b),
 	197: uint8(0x3a),
 	198: uint8(0x39),
 	199: uint8(0x38),
 	200: uint8(0x37),
 	201: uint8(0x36),
 	202: uint8(0x35),
 	203: uint8(0x34),
 	204: uint8(0x33),
 	205: uint8(0x32),
 	206: uint8(0x31),
 	207: uint8(0x30),
 	208: uint8(0x2f),
 	209: uint8(0x2e),
 	210: uint8(0x2d),
 	211: uint8(0x2c),
 	212: uint8(0x2b),
 	213: uint8(0x2a),
 	214: uint8(0x29),
 	215: uint8(0x28),
 	216: uint8(0x27),
 	217: uint8(0x26),
 	218: uint8(0x25),
 	219: uint8(0x24),
 	220: uint8(0x23),
 	221: uint8(0x22),
 	222: uint8(0x21),
 	223: uint8(0x20),
 	224: uint8(0x1f),
 	225: uint8(0x1e),
 	226: uint8(0x1d),
 	227: uint8(0x1c),
 	228: uint8(0x1b),
 	229: uint8(0x1a),
 	230: uint8(0x19),
 	231: uint8(0x18),
 	232: uint8(0x17),
 	233: uint8(0x16),
 	234: uint8(0x15),
 	235: uint8(0x14),
 	236: uint8(0x13),
 	237: uint8(0x12),
 	238: uint8(0x11),
 	239: uint8(0x10),
 	240: uint8(0x0f),
 	241: uint8(0x0e),
 	242: uint8(0x0d),
 	243: uint8(0x0c),
 	244: uint8(0x0b),
 	245: uint8(0x0a),
 	246: uint8(0x09),
 	247: uint8(0x08),
 	248: uint8(0x07),
 	249: uint8(0x06),
 	250: uint8(0x05),
 	251: uint8(0x04),
 	252: uint8(0x03),
 	253: uint8(0x02),
 	254: uint8(0x01),
 	256: uint8(0x01),
 	257: uint8(0x02),
 	258: uint8(0x03),
 	259: uint8(0x04),
 	260: uint8(0x05),
 	261: uint8(0x06),
 	262: uint8(0x07),
 	263: uint8(0x08),
 	264: uint8(0x09),
 	265: uint8(0x0a),
 	266: uint8(0x0b),
 	267: uint8(0x0c),
 	268: uint8(0x0d),
 	269: uint8(0x0e),
 	270: uint8(0x0f),
 	271: uint8(0x10),
 	272: uint8(0x11),
 	273: uint8(0x12),
 	274: uint8(0x13),
 	275: uint8(0x14),
 	276: uint8(0x15),
 	277: uint8(0x16),
 	278: uint8(0x17),
 	279: uint8(0x18),
 	280: uint8(0x19),
 	281: uint8(0x1a),
 	282: uint8(0x1b),
 	283: uint8(0x1c),
 	284: uint8(0x1d),
 	285: uint8(0x1e),
 	286: uint8(0x1f),
 	287: uint8(0x20),
 	288: uint8(0x21),
 	289: uint8(0x22),
 	290: uint8(0x23),
 	291: uint8(0x24),
 	292: uint8(0x25),
 	293: uint8(0x26),
 	294: uint8(0x27),
 	295: uint8(0x28),
 	296: uint8(0x29),
 	297: uint8(0x2a),
 	298: uint8(0x2b),
 	299: uint8(0x2c),
 	300: uint8(0x2d),
 	301: uint8(0x2e),
 	302: uint8(0x2f),
 	303: uint8(0x30),
 	304: uint8(0x31),
 	305: uint8(0x32),
 	306: uint8(0x33),
 	307: uint8(0x34),
 	308: uint8(0x35),
 	309: uint8(0x36),
 	310: uint8(0x37),
 	311: uint8(0x38),
 	312: uint8(0x39),
 	313: uint8(0x3a),
 	314: uint8(0x3b),
 	315: uint8(0x3c),
 	316: uint8(0x3d),
 	317: uint8(0x3e),
 	318: uint8(0x3f),
 	319: uint8(0x40),
 	320: uint8(0x41),
 	321: uint8(0x42),
 	322: uint8(0x43),
 	323: uint8(0x44),
 	324: uint8(0x45),
 	325: uint8(0x46),
 	326: uint8(0x47),
 	327: uint8(0x48),
 	328: uint8(0x49),
 	329: uint8(0x4a),
 	330: uint8(0x4b),
 	331: uint8(0x4c),
 	332: uint8(0x4d),
 	333: uint8(0x4e),
 	334: uint8(0x4f),
 	335: uint8(0x50),
 	336: uint8(0x51),
 	337: uint8(0x52),
 	338: uint8(0x53),
 	339: uint8(0x54),
 	340: uint8(0x55),
 	341: uint8(0x56),
 	342: uint8(0x57),
 	343: uint8(0x58),
 	344: uint8(0x59),
 	345: uint8(0x5a),
 	346: uint8(0x5b),
 	347: uint8(0x5c),
 	348: uint8(0x5d),
 	349: uint8(0x5e),
 	350: uint8(0x5f),
 	351: uint8(0x60),
 	352: uint8(0x61),
 	353: uint8(0x62),
 	354: uint8(0x63),
 	355: uint8(0x64),
 	356: uint8(0x65),
 	357: uint8(0x66),
 	358: uint8(0x67),
 	359: uint8(0x68),
 	360: uint8(0x69),
 	361: uint8(0x6a),
 	362: uint8(0x6b),
 	363: uint8(0x6c),
 	364: uint8(0x6d),
 	365: uint8(0x6e),
 	366: uint8(0x6f),
 	367: uint8(0x70),
 	368: uint8(0x71),
 	369: uint8(0x72),
 	370: uint8(0x73),
 	371: uint8(0x74),
 	372: uint8(0x75),
 	373: uint8(0x76),
 	374: uint8(0x77),
 	375: uint8(0x78),
 	376: uint8(0x79),
 	377: uint8(0x7a),
 	378: uint8(0x7b),
 	379: uint8(0x7c),
 	380: uint8(0x7d),
 	381: uint8(0x7e),
 	382: uint8(0x7f),
 	383: uint8(0x80),
 	384: uint8(0x81),
 	385: uint8(0x82),
 	386: uint8(0x83),
 	387: uint8(0x84),
 	388: uint8(0x85),
 	389: uint8(0x86),
 	390: uint8(0x87),
 	391: uint8(0x88),
 	392: uint8(0x89),
 	393: uint8(0x8a),
 	394: uint8(0x8b),
 	395: uint8(0x8c),
 	396: uint8(0x8d),
 	397: uint8(0x8e),
 	398: uint8(0x8f),
 	399: uint8(0x90),
 	400: uint8(0x91),
 	401: uint8(0x92),
 	402: uint8(0x93),
 	403: uint8(0x94),
 	404: uint8(0x95),
 	405: uint8(0x96),
 	406: uint8(0x97),
 	407: uint8(0x98),
 	408: uint8(0x99),
 	409: uint8(0x9a),
 	410: uint8(0x9b),
 	411: uint8(0x9c),
 	412: uint8(0x9d),
 	413: uint8(0x9e),
 	414: uint8(0x9f),
 	415: uint8(0xa0),
 	416: uint8(0xa1),
 	417: uint8(0xa2),
 	418: uint8(0xa3),
 	419: uint8(0xa4),
 	420: uint8(0xa5),
 	421: uint8(0xa6),
 	422: uint8(0xa7),
 	423: uint8(0xa8),
 	424: uint8(0xa9),
 	425: uint8(0xaa),
 	426: uint8(0xab),
 	427: uint8(0xac),
 	428: uint8(0xad),
 	429: uint8(0xae),
 	430: uint8(0xaf),
 	431: uint8(0xb0),
 	432: uint8(0xb1),
 	433: uint8(0xb2),
 	434: uint8(0xb3),
 	435: uint8(0xb4),
 	436: uint8(0xb5),
 	437: uint8(0xb6),
 	438: uint8(0xb7),
 	439: uint8(0xb8),
 	440: uint8(0xb9),
 	441: uint8(0xba),
 	442: uint8(0xbb),
 	443: uint8(0xbc),
 	444: uint8(0xbd),
 	445: uint8(0xbe),
 	446: uint8(0xbf),
 	447: uint8(0xc0),
 	448: uint8(0xc1),
 	449: uint8(0xc2),
 	450: uint8(0xc3),
 	451: uint8(0xc4),
 	452: uint8(0xc5),
 	453: uint8(0xc6),
 	454: uint8(0xc7),
 	455: uint8(0xc8),
 	456: uint8(0xc9),
 	457: uint8(0xca),
 	458: uint8(0xcb),
 	459: uint8(0xcc),
 	460: uint8(0xcd),
 	461: uint8(0xce),
 	462: uint8(0xcf),
 	463: uint8(0xd0),
 	464: uint8(0xd1),
 	465: uint8(0xd2),
 	466: uint8(0xd3),
 	467: uint8(0xd4),
 	468: uint8(0xd5),
 	469: uint8(0xd6),
 	470: uint8(0xd7),
 	471: uint8(0xd8),
 	472: uint8(0xd9),
 	473: uint8(0xda),
 	474: uint8(0xdb),
 	475: uint8(0xdc),
 	476: uint8(0xdd),
 	477: uint8(0xde),
 	478: uint8(0xdf),
 	479: uint8(0xe0),
 	480: uint8(0xe1),
 	481: uint8(0xe2),
 	482: uint8(0xe3),
 	483: uint8(0xe4),
 	484: uint8(0xe5),
 	485: uint8(0xe6),
 	486: uint8(0xe7),
 	487: uint8(0xe8),
 	488: uint8(0xe9),
 	489: uint8(0xea),
 	490: uint8(0xeb),
 	491: uint8(0xec),
 	492: uint8(0xed),
 	493: uint8(0xee),
 	494: uint8(0xef),
 	495: uint8(0xf0),
 	496: uint8(0xf1),
 	497: uint8(0xf2),
 	498: uint8(0xf3),
 	499: uint8(0xf4),
 	500: uint8(0xf5),
 	501: uint8(0xf6),
 	502: uint8(0xf7),
 	503: uint8(0xf8),
 	504: uint8(0xf9),
 	505: uint8(0xfa),
 	506: uint8(0xfb),
 	507: uint8(0xfc),
 	508: uint8(0xfd),
 	509: uint8(0xfe),
 	510: uint8(0xff),
 }
 
 var sclip1 = [2041]uint8_t{
 	0:    uint8(0x80),
 	1:    uint8(0x80),
 	2:    uint8(0x80),
 	3:    uint8(0x80),
 	4:    uint8(0x80),
 	5:    uint8(0x80),
 	6:    uint8(0x80),
 	7:    uint8(0x80),
 	8:    uint8(0x80),
 	9:    uint8(0x80),
 	10:   uint8(0x80),
 	11:   uint8(0x80),
 	12:   uint8(0x80),
 	13:   uint8(0x80),
 	14:   uint8(0x80),
 	15:   uint8(0x80),
 	16:   uint8(0x80),
 	17:   uint8(0x80),
 	18:   uint8(0x80),
 	19:   uint8(0x80),
 	20:   uint8(0x80),
 	21:   uint8(0x80),
 	22:   uint8(0x80),
 	23:   uint8(0x80),
 	24:   uint8(0x80),
 	25:   uint8(0x80),
 	26:   uint8(0x80),
 	27:   uint8(0x80),
 	28:   uint8(0x80),
 	29:   uint8(0x80),
 	30:   uint8(0x80),
 	31:   uint8(0x80),
 	32:   uint8(0x80),
 	33:   uint8(0x80),
 	34:   uint8(0x80),
 	35:   uint8(0x80),
 	36:   uint8(0x80),
 	37:   uint8(0x80),
 	38:   uint8(0x80),
 	39:   uint8(0x80),
 	40:   uint8(0x80),
 	41:   uint8(0x80),
 	42:   uint8(0x80),
 	43:   uint8(0x80),
 	44:   uint8(0x80),
 	45:   uint8(0x80),
 	46:   uint8(0x80),
 	47:   uint8(0x80),
 	48:   uint8(0x80),
 	49:   uint8(0x80),
 	50:   uint8(0x80),
 	51:   uint8(0x80),
 	52:   uint8(0x80),
 	53:   uint8(0x80),
 	54:   uint8(0x80),
 	55:   uint8(0x80),
 	56:   uint8(0x80),
 	57:   uint8(0x80),
 	58:   uint8(0x80),
 	59:   uint8(0x80),
 	60:   uint8(0x80),
 	61:   uint8(0x80),
 	62:   uint8(0x80),
 	63:   uint8(0x80),
 	64:   uint8(0x80),
 	65:   uint8(0x80),
 	66:   uint8(0x80),
 	67:   uint8(0x80),
 	68:   uint8(0x80),
 	69:   uint8(0x80),
 	70:   uint8(0x80),
 	71:   uint8(0x80),
 	72:   uint8(0x80),
 	73:   uint8(0x80),
 	74:   uint8(0x80),
 	75:   uint8(0x80),
 	76:   uint8(0x80),
 	77:   uint8(0x80),
 	78:   uint8(0x80),
 	79:   uint8(0x80),
 	80:   uint8(0x80),
 	81:   uint8(0x80),
 	82:   uint8(0x80),
 	83:   uint8(0x80),
 	84:   uint8(0x80),
 	85:   uint8(0x80),
 	86:   uint8(0x80),
 	87:   uint8(0x80),
 	88:   uint8(0x80),
 	89:   uint8(0x80),
 	90:   uint8(0x80),
 	91:   uint8(0x80),
 	92:   uint8(0x80),
 	93:   uint8(0x80),
 	94:   uint8(0x80),
 	95:   uint8(0x80),
 	96:   uint8(0x80),
 	97:   uint8(0x80),
 	98:   uint8(0x80),
 	99:   uint8(0x80),
 	100:  uint8(0x80),
 	101:  uint8(0x80),
 	102:  uint8(0x80),
 	103:  uint8(0x80),
 	104:  uint8(0x80),
 	105:  uint8(0x80),
 	106:  uint8(0x80),
 	107:  uint8(0x80),
 	108:  uint8(0x80),
 	109:  uint8(0x80),
 	110:  uint8(0x80),
 	111:  uint8(0x80),
 	112:  uint8(0x80),
 	113:  uint8(0x80),
 	114:  uint8(0x80),
 	115:  uint8(0x80),
 	116:  uint8(0x80),
 	117:  uint8(0x80),
 	118:  uint8(0x80),
 	119:  uint8(0x80),
 	120:  uint8(0x80),
 	121:  uint8(0x80),
 	122:  uint8(0x80),
 	123:  uint8(0x80),
 	124:  uint8(0x80),
 	125:  uint8(0x80),
 	126:  uint8(0x80),
 	127:  uint8(0x80),
 	128:  uint8(0x80),
 	129:  uint8(0x80),
 	130:  uint8(0x80),
 	131:  uint8(0x80),
 	132:  uint8(0x80),
 	133:  uint8(0x80),
 	134:  uint8(0x80),
 	135:  uint8(0x80),
 	136:  uint8(0x80),
 	137:  uint8(0x80),
 	138:  uint8(0x80),
 	139:  uint8(0x80),
 	140:  uint8(0x80),
 	141:  uint8(0x80),
 	142:  uint8(0x80),
 	143:  uint8(0x80),
 	144:  uint8(0x80),
 	145:  uint8(0x80),
 	146:  uint8(0x80),
 	147:  uint8(0x80),
 	148:  uint8(0x80),
 	149:  uint8(0x80),
 	150:  uint8(0x80),
 	151:  uint8(0x80),
 	152:  uint8(0x80),
 	153:  uint8(0x80),
 	154:  uint8(0x80),
 	155:  uint8(0x80),
 	156:  uint8(0x80),
 	157:  uint8(0x80),
 	158:  uint8(0x80),
 	159:  uint8(0x80),
 	160:  uint8(0x80),
 	161:  uint8(0x80),
 	162:  uint8(0x80),
 	163:  uint8(0x80),
 	164:  uint8(0x80),
 	165:  uint8(0x80),
 	166:  uint8(0x80),
 	167:  uint8(0x80),
 	168:  uint8(0x80),
 	169:  uint8(0x80),
 	170:  uint8(0x80),
 	171:  uint8(0x80),
 	172:  uint8(0x80),
 	173:  uint8(0x80),
 	174:  uint8(0x80),
 	175:  uint8(0x80),
 	176:  uint8(0x80),
 	177:  uint8(0x80),
 	178:  uint8(0x80),
 	179:  uint8(0x80),
 	180:  uint8(0x80),
 	181:  uint8(0x80),
 	182:  uint8(0x80),
 	183:  uint8(0x80),
 	184:  uint8(0x80),
 	185:  uint8(0x80),
 	186:  uint8(0x80),
 	187:  uint8(0x80),
 	188:  uint8(0x80),
 	189:  uint8(0x80),
 	190:  uint8(0x80),
 	191:  uint8(0x80),
 	192:  uint8(0x80),
 	193:  uint8(0x80),
 	194:  uint8(0x80),
 	195:  uint8(0x80),
 	196:  uint8(0x80),
 	197:  uint8(0x80),
 	198:  uint8(0x80),
 	199:  uint8(0x80),
 	200:  uint8(0x80),
 	201:  uint8(0x80),
 	202:  uint8(0x80),
 	203:  uint8(0x80),
 	204:  uint8(0x80),
 	205:  uint8(0x80),
 	206:  uint8(0x80),
 	207:  uint8(0x80),
 	208:  uint8(0x80),
 	209:  uint8(0x80),
 	210:  uint8(0x80),
 	211:  uint8(0x80),
 	212:  uint8(0x80),
 	213:  uint8(0x80),
 	214:  uint8(0x80),
 	215:  uint8(0x80),
 	216:  uint8(0x80),
 	217:  uint8(0x80),
 	218:  uint8(0x80),
 	219:  uint8(0x80),
 	220:  uint8(0x80),
 	221:  uint8(0x80),
 	222:  uint8(0x80),
 	223:  uint8(0x80),
 	224:  uint8(0x80),
 	225:  uint8(0x80),
 	226:  uint8(0x80),
 	227:  uint8(0x80),
 	228:  uint8(0x80),
 	229:  uint8(0x80),
 	230:  uint8(0x80),
 	231:  uint8(0x80),
 	232:  uint8(0x80),
 	233:  uint8(0x80),
 	234:  uint8(0x80),
 	235:  uint8(0x80),
 	236:  uint8(0x80),
 	237:  uint8(0x80),
 	238:  uint8(0x80),
 	239:  uint8(0x80),
 	240:  uint8(0x80),
 	241:  uint8(0x80),
 	242:  uint8(0x80),
 	243:  uint8(0x80),
 	244:  uint8(0x80),
 	245:  uint8(0x80),
 	246:  uint8(0x80),
 	247:  uint8(0x80),
 	248:  uint8(0x80),
 	249:  uint8(0x80),
 	250:  uint8(0x80),
 	251:  uint8(0x80),
 	252:  uint8(0x80),
 	253:  uint8(0x80),
 	254:  uint8(0x80),
 	255:  uint8(0x80),
 	256:  uint8(0x80),
 	257:  uint8(0x80),
 	258:  uint8(0x80),
 	259:  uint8(0x80),
 	260:  uint8(0x80),
 	261:  uint8(0x80),
 	262:  uint8(0x80),
 	263:  uint8(0x80),
 	264:  uint8(0x80),
 	265:  uint8(0x80),
 	266:  uint8(0x80),
 	267:  uint8(0x80),
 	268:  uint8(0x80),
 	269:  uint8(0x80),
 	270:  uint8(0x80),
 	271:  uint8(0x80),
 	272:  uint8(0x80),
 	273:  uint8(0x80),
 	274:  uint8(0x80),
 	275:  uint8(0x80),
 	276:  uint8(0x80),
 	277:  uint8(0x80),
 	278:  uint8(0x80),
 	279:  uint8(0x80),
 	280:  uint8(0x80),
 	281:  uint8(0x80),
 	282:  uint8(0x80),
 	283:  uint8(0x80),
 	284:  uint8(0x80),
 	285:  uint8(0x80),
 	286:  uint8(0x80),
 	287:  uint8(0x80),
 	288:  uint8(0x80),
 	289:  uint8(0x80),
 	290:  uint8(0x80),
 	291:  uint8(0x80),
 	292:  uint8(0x80),
 	293:  uint8(0x80),
 	294:  uint8(0x80),
 	295:  uint8(0x80),
 	296:  uint8(0x80),
 	297:  uint8(0x80),
 	298:  uint8(0x80),
 	299:  uint8(0x80),
 	300:  uint8(0x80),
 	301:  uint8(0x80),
 	302:  uint8(0x80),
 	303:  uint8(0x80),
 	304:  uint8(0x80),
 	305:  uint8(0x80),
 	306:  uint8(0x80),
 	307:  uint8(0x80),
 	308:  uint8(0x80),
 	309:  uint8(0x80),
 	310:  uint8(0x80),
 	311:  uint8(0x80),
 	312:  uint8(0x80),
 	313:  uint8(0x80),
 	314:  uint8(0x80),
 	315:  uint8(0x80),
 	316:  uint8(0x80),
 	317:  uint8(0x80),
 	318:  uint8(0x80),
 	319:  uint8(0x80),
 	320:  uint8(0x80),
 	321:  uint8(0x80),
 	322:  uint8(0x80),
 	323:  uint8(0x80),
 	324:  uint8(0x80),
 	325:  uint8(0x80),
 	326:  uint8(0x80),
 	327:  uint8(0x80),
 	328:  uint8(0x80),
 	329:  uint8(0x80),
 	330:  uint8(0x80),
 	331:  uint8(0x80),
 	332:  uint8(0x80),
 	333:  uint8(0x80),
 	334:  uint8(0x80),
 	335:  uint8(0x80),
 	336:  uint8(0x80),
 	337:  uint8(0x80),
 	338:  uint8(0x80),
 	339:  uint8(0x80),
 	340:  uint8(0x80),
 	341:  uint8(0x80),
 	342:  uint8(0x80),
 	343:  uint8(0x80),
 	344:  uint8(0x80),
 	345:  uint8(0x80),
 	346:  uint8(0x80),
 	347:  uint8(0x80),
 	348:  uint8(0x80),
 	349:  uint8(0x80),
 	350:  uint8(0x80),
 	351:  uint8(0x80),
 	352:  uint8(0x80),
 	353:  uint8(0x80),
 	354:  uint8(0x80),
 	355:  uint8(0x80),
 	356:  uint8(0x80),
 	357:  uint8(0x80),
 	358:  uint8(0x80),
 	359:  uint8(0x80),
 	360:  uint8(0x80),
 	361:  uint8(0x80),
 	362:  uint8(0x80),
 	363:  uint8(0x80),
 	364:  uint8(0x80),
 	365:  uint8(0x80),
 	366:  uint8(0x80),
 	367:  uint8(0x80),
 	368:  uint8(0x80),
 	369:  uint8(0x80),
 	370:  uint8(0x80),
 	371:  uint8(0x80),
 	372:  uint8(0x80),
 	373:  uint8(0x80),
 	374:  uint8(0x80),
 	375:  uint8(0x80),
 	376:  uint8(0x80),
 	377:  uint8(0x80),
 	378:  uint8(0x80),
 	379:  uint8(0x80),
 	380:  uint8(0x80),
 	381:  uint8(0x80),
 	382:  uint8(0x80),
 	383:  uint8(0x80),
 	384:  uint8(0x80),
 	385:  uint8(0x80),
 	386:  uint8(0x80),
 	387:  uint8(0x80),
 	388:  uint8(0x80),
 	389:  uint8(0x80),
 	390:  uint8(0x80),
 	391:  uint8(0x80),
 	392:  uint8(0x80),
 	393:  uint8(0x80),
 	394:  uint8(0x80),
 	395:  uint8(0x80),
 	396:  uint8(0x80),
 	397:  uint8(0x80),
 	398:  uint8(0x80),
 	399:  uint8(0x80),
 	400:  uint8(0x80),
 	401:  uint8(0x80),
 	402:  uint8(0x80),
 	403:  uint8(0x80),
 	404:  uint8(0x80),
 	405:  uint8(0x80),
 	406:  uint8(0x80),
 	407:  uint8(0x80),
 	408:  uint8(0x80),
 	409:  uint8(0x80),
 	410:  uint8(0x80),
 	411:  uint8(0x80),
 	412:  uint8(0x80),
 	413:  uint8(0x80),
 	414:  uint8(0x80),
 	415:  uint8(0x80),
 	416:  uint8(0x80),
 	417:  uint8(0x80),
 	418:  uint8(0x80),
 	419:  uint8(0x80),
 	420:  uint8(0x80),
 	421:  uint8(0x80),
 	422:  uint8(0x80),
 	423:  uint8(0x80),
 	424:  uint8(0x80),
 	425:  uint8(0x80),
 	426:  uint8(0x80),
 	427:  uint8(0x80),
 	428:  uint8(0x80),
 	429:  uint8(0x80),
 	430:  uint8(0x80),
 	431:  uint8(0x80),
 	432:  uint8(0x80),
 	433:  uint8(0x80),
 	434:  uint8(0x80),
 	435:  uint8(0x80),
 	436:  uint8(0x80),
 	437:  uint8(0x80),
 	438:  uint8(0x80),
 	439:  uint8(0x80),
 	440:  uint8(0x80),
 	441:  uint8(0x80),
 	442:  uint8(0x80),
 	443:  uint8(0x80),
 	444:  uint8(0x80),
 	445:  uint8(0x80),
 	446:  uint8(0x80),
 	447:  uint8(0x80),
 	448:  uint8(0x80),
 	449:  uint8(0x80),
 	450:  uint8(0x80),
 	451:  uint8(0x80),
 	452:  uint8(0x80),
 	453:  uint8(0x80),
 	454:  uint8(0x80),
 	455:  uint8(0x80),
 	456:  uint8(0x80),
 	457:  uint8(0x80),
 	458:  uint8(0x80),
 	459:  uint8(0x80),
 	460:  uint8(0x80),
 	461:  uint8(0x80),
 	462:  uint8(0x80),
 	463:  uint8(0x80),
 	464:  uint8(0x80),
 	465:  uint8(0x80),
 	466:  uint8(0x80),
 	467:  uint8(0x80),
 	468:  uint8(0x80),
 	469:  uint8(0x80),
 	470:  uint8(0x80),
 	471:  uint8(0x80),
 	472:  uint8(0x80),
 	473:  uint8(0x80),
 	474:  uint8(0x80),
 	475:  uint8(0x80),
 	476:  uint8(0x80),
 	477:  uint8(0x80),
 	478:  uint8(0x80),
 	479:  uint8(0x80),
 	480:  uint8(0x80),
 	481:  uint8(0x80),
 	482:  uint8(0x80),
 	483:  uint8(0x80),
 	484:  uint8(0x80),
 	485:  uint8(0x80),
 	486:  uint8(0x80),
 	487:  uint8(0x80),
 	488:  uint8(0x80),
 	489:  uint8(0x80),
 	490:  uint8(0x80),
 	491:  uint8(0x80),
 	492:  uint8(0x80),
 	493:  uint8(0x80),
 	494:  uint8(0x80),
 	495:  uint8(0x80),
 	496:  uint8(0x80),
 	497:  uint8(0x80),
 	498:  uint8(0x80),
 	499:  uint8(0x80),
 	500:  uint8(0x80),
 	501:  uint8(0x80),
 	502:  uint8(0x80),
 	503:  uint8(0x80),
 	504:  uint8(0x80),
 	505:  uint8(0x80),
 	506:  uint8(0x80),
 	507:  uint8(0x80),
 	508:  uint8(0x80),
 	509:  uint8(0x80),
 	510:  uint8(0x80),
 	511:  uint8(0x80),
 	512:  uint8(0x80),
 	513:  uint8(0x80),
 	514:  uint8(0x80),
 	515:  uint8(0x80),
 	516:  uint8(0x80),
 	517:  uint8(0x80),
 	518:  uint8(0x80),
 	519:  uint8(0x80),
 	520:  uint8(0x80),
 	521:  uint8(0x80),
 	522:  uint8(0x80),
 	523:  uint8(0x80),
 	524:  uint8(0x80),
 	525:  uint8(0x80),
 	526:  uint8(0x80),
 	527:  uint8(0x80),
 	528:  uint8(0x80),
 	529:  uint8(0x80),
 	530:  uint8(0x80),
 	531:  uint8(0x80),
 	532:  uint8(0x80),
 	533:  uint8(0x80),
 	534:  uint8(0x80),
 	535:  uint8(0x80),
 	536:  uint8(0x80),
 	537:  uint8(0x80),
 	538:  uint8(0x80),
 	539:  uint8(0x80),
 	540:  uint8(0x80),
 	541:  uint8(0x80),
 	542:  uint8(0x80),
 	543:  uint8(0x80),
 	544:  uint8(0x80),
 	545:  uint8(0x80),
 	546:  uint8(0x80),
 	547:  uint8(0x80),
 	548:  uint8(0x80),
 	549:  uint8(0x80),
 	550:  uint8(0x80),
 	551:  uint8(0x80),
 	552:  uint8(0x80),
 	553:  uint8(0x80),
 	554:  uint8(0x80),
 	555:  uint8(0x80),
 	556:  uint8(0x80),
 	557:  uint8(0x80),
 	558:  uint8(0x80),
 	559:  uint8(0x80),
 	560:  uint8(0x80),
 	561:  uint8(0x80),
 	562:  uint8(0x80),
 	563:  uint8(0x80),
 	564:  uint8(0x80),
 	565:  uint8(0x80),
 	566:  uint8(0x80),
 	567:  uint8(0x80),
 	568:  uint8(0x80),
 	569:  uint8(0x80),
 	570:  uint8(0x80),
 	571:  uint8(0x80),
 	572:  uint8(0x80),
 	573:  uint8(0x80),
 	574:  uint8(0x80),
 	575:  uint8(0x80),
 	576:  uint8(0x80),
 	577:  uint8(0x80),
 	578:  uint8(0x80),
 	579:  uint8(0x80),
 	580:  uint8(0x80),
 	581:  uint8(0x80),
 	582:  uint8(0x80),
 	583:  uint8(0x80),
 	584:  uint8(0x80),
 	585:  uint8(0x80),
 	586:  uint8(0x80),
 	587:  uint8(0x80),
 	588:  uint8(0x80),
 	589:  uint8(0x80),
 	590:  uint8(0x80),
 	591:  uint8(0x80),
 	592:  uint8(0x80),
 	593:  uint8(0x80),
 	594:  uint8(0x80),
 	595:  uint8(0x80),
 	596:  uint8(0x80),
 	597:  uint8(0x80),
 	598:  uint8(0x80),
 	599:  uint8(0x80),
 	600:  uint8(0x80),
 	601:  uint8(0x80),
 	602:  uint8(0x80),
 	603:  uint8(0x80),
 	604:  uint8(0x80),
 	605:  uint8(0x80),
 	606:  uint8(0x80),
 	607:  uint8(0x80),
 	608:  uint8(0x80),
 	609:  uint8(0x80),
 	610:  uint8(0x80),
 	611:  uint8(0x80),
 	612:  uint8(0x80),
 	613:  uint8(0x80),
 	614:  uint8(0x80),
 	615:  uint8(0x80),
 	616:  uint8(0x80),
 	617:  uint8(0x80),
 	618:  uint8(0x80),
 	619:  uint8(0x80),
 	620:  uint8(0x80),
 	621:  uint8(0x80),
 	622:  uint8(0x80),
 	623:  uint8(0x80),
 	624:  uint8(0x80),
 	625:  uint8(0x80),
 	626:  uint8(0x80),
 	627:  uint8(0x80),
 	628:  uint8(0x80),
 	629:  uint8(0x80),
 	630:  uint8(0x80),
 	631:  uint8(0x80),
 	632:  uint8(0x80),
 	633:  uint8(0x80),
 	634:  uint8(0x80),
 	635:  uint8(0x80),
 	636:  uint8(0x80),
 	637:  uint8(0x80),
 	638:  uint8(0x80),
 	639:  uint8(0x80),
 	640:  uint8(0x80),
 	641:  uint8(0x80),
 	642:  uint8(0x80),
 	643:  uint8(0x80),
 	644:  uint8(0x80),
 	645:  uint8(0x80),
 	646:  uint8(0x80),
 	647:  uint8(0x80),
 	648:  uint8(0x80),
 	649:  uint8(0x80),
 	650:  uint8(0x80),
 	651:  uint8(0x80),
 	652:  uint8(0x80),
 	653:  uint8(0x80),
 	654:  uint8(0x80),
 	655:  uint8(0x80),
 	656:  uint8(0x80),
 	657:  uint8(0x80),
 	658:  uint8(0x80),
 	659:  uint8(0x80),
 	660:  uint8(0x80),
 	661:  uint8(0x80),
 	662:  uint8(0x80),
 	663:  uint8(0x80),
 	664:  uint8(0x80),
 	665:  uint8(0x80),
 	666:  uint8(0x80),
 	667:  uint8(0x80),
 	668:  uint8(0x80),
 	669:  uint8(0x80),
 	670:  uint8(0x80),
 	671:  uint8(0x80),
 	672:  uint8(0x80),
 	673:  uint8(0x80),
 	674:  uint8(0x80),
 	675:  uint8(0x80),
 	676:  uint8(0x80),
 	677:  uint8(0x80),
 	678:  uint8(0x80),
 	679:  uint8(0x80),
 	680:  uint8(0x80),
 	681:  uint8(0x80),
 	682:  uint8(0x80),
 	683:  uint8(0x80),
 	684:  uint8(0x80),
 	685:  uint8(0x80),
 	686:  uint8(0x80),
 	687:  uint8(0x80),
 	688:  uint8(0x80),
 	689:  uint8(0x80),
 	690:  uint8(0x80),
 	691:  uint8(0x80),
 	692:  uint8(0x80),
 	693:  uint8(0x80),
 	694:  uint8(0x80),
 	695:  uint8(0x80),
 	696:  uint8(0x80),
 	697:  uint8(0x80),
 	698:  uint8(0x80),
 	699:  uint8(0x80),
 	700:  uint8(0x80),
 	701:  uint8(0x80),
 	702:  uint8(0x80),
 	703:  uint8(0x80),
 	704:  uint8(0x80),
 	705:  uint8(0x80),
 	706:  uint8(0x80),
 	707:  uint8(0x80),
 	708:  uint8(0x80),
 	709:  uint8(0x80),
 	710:  uint8(0x80),
 	711:  uint8(0x80),
 	712:  uint8(0x80),
 	713:  uint8(0x80),
 	714:  uint8(0x80),
 	715:  uint8(0x80),
 	716:  uint8(0x80),
 	717:  uint8(0x80),
 	718:  uint8(0x80),
 	719:  uint8(0x80),
 	720:  uint8(0x80),
 	721:  uint8(0x80),
 	722:  uint8(0x80),
 	723:  uint8(0x80),
 	724:  uint8(0x80),
 	725:  uint8(0x80),
 	726:  uint8(0x80),
 	727:  uint8(0x80),
 	728:  uint8(0x80),
 	729:  uint8(0x80),
 	730:  uint8(0x80),
 	731:  uint8(0x80),
 	732:  uint8(0x80),
 	733:  uint8(0x80),
 	734:  uint8(0x80),
 	735:  uint8(0x80),
 	736:  uint8(0x80),
 	737:  uint8(0x80),
 	738:  uint8(0x80),
 	739:  uint8(0x80),
 	740:  uint8(0x80),
 	741:  uint8(0x80),
 	742:  uint8(0x80),
 	743:  uint8(0x80),
 	744:  uint8(0x80),
 	745:  uint8(0x80),
 	746:  uint8(0x80),
 	747:  uint8(0x80),
 	748:  uint8(0x80),
 	749:  uint8(0x80),
 	750:  uint8(0x80),
 	751:  uint8(0x80),
 	752:  uint8(0x80),
 	753:  uint8(0x80),
 	754:  uint8(0x80),
 	755:  uint8(0x80),
 	756:  uint8(0x80),
 	757:  uint8(0x80),
 	758:  uint8(0x80),
 	759:  uint8(0x80),
 	760:  uint8(0x80),
 	761:  uint8(0x80),
 	762:  uint8(0x80),
 	763:  uint8(0x80),
 	764:  uint8(0x80),
 	765:  uint8(0x80),
 	766:  uint8(0x80),
 	767:  uint8(0x80),
 	768:  uint8(0x80),
 	769:  uint8(0x80),
 	770:  uint8(0x80),
 	771:  uint8(0x80),
 	772:  uint8(0x80),
 	773:  uint8(0x80),
 	774:  uint8(0x80),
 	775:  uint8(0x80),
 	776:  uint8(0x80),
 	777:  uint8(0x80),
 	778:  uint8(0x80),
 	779:  uint8(0x80),
 	780:  uint8(0x80),
 	781:  uint8(0x80),
 	782:  uint8(0x80),
 	783:  uint8(0x80),
 	784:  uint8(0x80),
 	785:  uint8(0x80),
 	786:  uint8(0x80),
 	787:  uint8(0x80),
 	788:  uint8(0x80),
 	789:  uint8(0x80),
 	790:  uint8(0x80),
 	791:  uint8(0x80),
 	792:  uint8(0x80),
 	793:  uint8(0x80),
 	794:  uint8(0x80),
 	795:  uint8(0x80),
 	796:  uint8(0x80),
 	797:  uint8(0x80),
 	798:  uint8(0x80),
 	799:  uint8(0x80),
 	800:  uint8(0x80),
 	801:  uint8(0x80),
 	802:  uint8(0x80),
 	803:  uint8(0x80),
 	804:  uint8(0x80),
 	805:  uint8(0x80),
 	806:  uint8(0x80),
 	807:  uint8(0x80),
 	808:  uint8(0x80),
 	809:  uint8(0x80),
 	810:  uint8(0x80),
 	811:  uint8(0x80),
 	812:  uint8(0x80),
 	813:  uint8(0x80),
 	814:  uint8(0x80),
 	815:  uint8(0x80),
 	816:  uint8(0x80),
 	817:  uint8(0x80),
 	818:  uint8(0x80),
 	819:  uint8(0x80),
 	820:  uint8(0x80),
 	821:  uint8(0x80),
 	822:  uint8(0x80),
 	823:  uint8(0x80),
 	824:  uint8(0x80),
 	825:  uint8(0x80),
 	826:  uint8(0x80),
 	827:  uint8(0x80),
 	828:  uint8(0x80),
 	829:  uint8(0x80),
 	830:  uint8(0x80),
 	831:  uint8(0x80),
 	832:  uint8(0x80),
 	833:  uint8(0x80),
 	834:  uint8(0x80),
 	835:  uint8(0x80),
 	836:  uint8(0x80),
 	837:  uint8(0x80),
 	838:  uint8(0x80),
 	839:  uint8(0x80),
 	840:  uint8(0x80),
 	841:  uint8(0x80),
 	842:  uint8(0x80),
 	843:  uint8(0x80),
 	844:  uint8(0x80),
 	845:  uint8(0x80),
 	846:  uint8(0x80),
 	847:  uint8(0x80),
 	848:  uint8(0x80),
 	849:  uint8(0x80),
 	850:  uint8(0x80),
 	851:  uint8(0x80),
 	852:  uint8(0x80),
 	853:  uint8(0x80),
 	854:  uint8(0x80),
 	855:  uint8(0x80),
 	856:  uint8(0x80),
 	857:  uint8(0x80),
 	858:  uint8(0x80),
 	859:  uint8(0x80),
 	860:  uint8(0x80),
 	861:  uint8(0x80),
 	862:  uint8(0x80),
 	863:  uint8(0x80),
 	864:  uint8(0x80),
 	865:  uint8(0x80),
 	866:  uint8(0x80),
 	867:  uint8(0x80),
 	868:  uint8(0x80),
 	869:  uint8(0x80),
 	870:  uint8(0x80),
 	871:  uint8(0x80),
 	872:  uint8(0x80),
 	873:  uint8(0x80),
 	874:  uint8(0x80),
 	875:  uint8(0x80),
 	876:  uint8(0x80),
 	877:  uint8(0x80),
 	878:  uint8(0x80),
 	879:  uint8(0x80),
 	880:  uint8(0x80),
 	881:  uint8(0x80),
 	882:  uint8(0x80),
 	883:  uint8(0x80),
 	884:  uint8(0x80),
 	885:  uint8(0x80),
 	886:  uint8(0x80),
 	887:  uint8(0x80),
 	888:  uint8(0x80),
 	889:  uint8(0x80),
 	890:  uint8(0x80),
 	891:  uint8(0x80),
 	892:  uint8(0x80),
 	893:  uint8(0x81),
 	894:  uint8(0x82),
 	895:  uint8(0x83),
 	896:  uint8(0x84),
 	897:  uint8(0x85),
 	898:  uint8(0x86),
 	899:  uint8(0x87),
 	900:  uint8(0x88),
 	901:  uint8(0x89),
 	902:  uint8(0x8a),
 	903:  uint8(0x8b),
 	904:  uint8(0x8c),
 	905:  uint8(0x8d),
 	906:  uint8(0x8e),
 	907:  uint8(0x8f),
 	908:  uint8(0x90),
 	909:  uint8(0x91),
 	910:  uint8(0x92),
 	911:  uint8(0x93),
 	912:  uint8(0x94),
 	913:  uint8(0x95),
 	914:  uint8(0x96),
 	915:  uint8(0x97),
 	916:  uint8(0x98),
 	917:  uint8(0x99),
 	918:  uint8(0x9a),
 	919:  uint8(0x9b),
 	920:  uint8(0x9c),
 	921:  uint8(0x9d),
 	922:  uint8(0x9e),
 	923:  uint8(0x9f),
 	924:  uint8(0xa0),
 	925:  uint8(0xa1),
 	926:  uint8(0xa2),
 	927:  uint8(0xa3),
 	928:  uint8(0xa4),
 	929:  uint8(0xa5),
 	930:  uint8(0xa6),
 	931:  uint8(0xa7),
 	932:  uint8(0xa8),
 	933:  uint8(0xa9),
 	934:  uint8(0xaa),
 	935:  uint8(0xab),
 	936:  uint8(0xac),
 	937:  uint8(0xad),
 	938:  uint8(0xae),
 	939:  uint8(0xaf),
 	940:  uint8(0xb0),
 	941:  uint8(0xb1),
 	942:  uint8(0xb2),
 	943:  uint8(0xb3),
 	944:  uint8(0xb4),
 	945:  uint8(0xb5),
 	946:  uint8(0xb6),
 	947:  uint8(0xb7),
 	948:  uint8(0xb8),
 	949:  uint8(0xb9),
 	950:  uint8(0xba),
 	951:  uint8(0xbb),
 	952:  uint8(0xbc),
 	953:  uint8(0xbd),
 	954:  uint8(0xbe),
 	955:  uint8(0xbf),
 	956:  uint8(0xc0),
 	957:  uint8(0xc1),
 	958:  uint8(0xc2),
 	959:  uint8(0xc3),
 	960:  uint8(0xc4),
 	961:  uint8(0xc5),
 	962:  uint8(0xc6),
 	963:  uint8(0xc7),
 	964:  uint8(0xc8),
 	965:  uint8(0xc9),
 	966:  uint8(0xca),
 	967:  uint8(0xcb),
 	968:  uint8(0xcc),
 	969:  uint8(0xcd),
 	970:  uint8(0xce),
 	971:  uint8(0xcf),
 	972:  uint8(0xd0),
 	973:  uint8(0xd1),
 	974:  uint8(0xd2),
 	975:  uint8(0xd3),
 	976:  uint8(0xd4),
 	977:  uint8(0xd5),
 	978:  uint8(0xd6),
 	979:  uint8(0xd7),
 	980:  uint8(0xd8),
 	981:  uint8(0xd9),
 	982:  uint8(0xda),
 	983:  uint8(0xdb),
 	984:  uint8(0xdc),
 	985:  uint8(0xdd),
 	986:  uint8(0xde),
 	987:  uint8(0xdf),
 	988:  uint8(0xe0),
 	989:  uint8(0xe1),
 	990:  uint8(0xe2),
 	991:  uint8(0xe3),
 	992:  uint8(0xe4),
 	993:  uint8(0xe5),
 	994:  uint8(0xe6),
 	995:  uint8(0xe7),
 	996:  uint8(0xe8),
 	997:  uint8(0xe9),
 	998:  uint8(0xea),
 	999:  uint8(0xeb),
 	1000: uint8(0xec),
 	1001: uint8(0xed),
 	1002: uint8(0xee),
 	1003: uint8(0xef),
 	1004: uint8(0xf0),
 	1005: uint8(0xf1),
 	1006: uint8(0xf2),
 	1007: uint8(0xf3),
 	1008: uint8(0xf4),
 	1009: uint8(0xf5),
 	1010: uint8(0xf6),
 	1011: uint8(0xf7),
 	1012: uint8(0xf8),
 	1013: uint8(0xf9),
 	1014: uint8(0xfa),
 	1015: uint8(0xfb),
 	1016: uint8(0xfc),
 	1017: uint8(0xfd),
 	1018: uint8(0xfe),
 	1019: uint8(0xff),
 	1021: uint8(0x01),
 	1022: uint8(0x02),
 	1023: uint8(0x03),
 	1024: uint8(0x04),
 	1025: uint8(0x05),
 	1026: uint8(0x06),
 	1027: uint8(0x07),
 	1028: uint8(0x08),
 	1029: uint8(0x09),
 	1030: uint8(0x0a),
 	1031: uint8(0x0b),
 	1032: uint8(0x0c),
 	1033: uint8(0x0d),
 	1034: uint8(0x0e),
 	1035: uint8(0x0f),
 	1036: uint8(0x10),
 	1037: uint8(0x11),
 	1038: uint8(0x12),
 	1039: uint8(0x13),
 	1040: uint8(0x14),
 	1041: uint8(0x15),
 	1042: uint8(0x16),
 	1043: uint8(0x17),
 	1044: uint8(0x18),
 	1045: uint8(0x19),
 	1046: uint8(0x1a),
 	1047: uint8(0x1b),
 	1048: uint8(0x1c),
 	1049: uint8(0x1d),
 	1050: uint8(0x1e),
 	1051: uint8(0x1f),
 	1052: uint8(0x20),
 	1053: uint8(0x21),
 	1054: uint8(0x22),
 	1055: uint8(0x23),
 	1056: uint8(0x24),
 	1057: uint8(0x25),
 	1058: uint8(0x26),
 	1059: uint8(0x27),
 	1060: uint8(0x28),
 	1061: uint8(0x29),
 	1062: uint8(0x2a),
 	1063: uint8(0x2b),
 	1064: uint8(0x2c),
 	1065: uint8(0x2d),
 	1066: uint8(0x2e),
 	1067: uint8(0x2f),
 	1068: uint8(0x30),
 	1069: uint8(0x31),
 	1070: uint8(0x32),
 	1071: uint8(0x33),
 	1072: uint8(0x34),
 	1073: uint8(0x35),
 	1074: uint8(0x36),
 	1075: uint8(0x37),
 	1076: uint8(0x38),
 	1077: uint8(0x39),
 	1078: uint8(0x3a),
 	1079: uint8(0x3b),
 	1080: uint8(0x3c),
 	1081: uint8(0x3d),
 	1082: uint8(0x3e),
 	1083: uint8(0x3f),
 	1084: uint8(0x40),
 	1085: uint8(0x41),
 	1086: uint8(0x42),
 	1087: uint8(0x43),
 	1088: uint8(0x44),
 	1089: uint8(0x45),
 	1090: uint8(0x46),
 	1091: uint8(0x47),
 	1092: uint8(0x48),
 	1093: uint8(0x49),
 	1094: uint8(0x4a),
 	1095: uint8(0x4b),
 	1096: uint8(0x4c),
 	1097: uint8(0x4d),
 	1098: uint8(0x4e),
 	1099: uint8(0x4f),
 	1100: uint8(0x50),
 	1101: uint8(0x51),
 	1102: uint8(0x52),
 	1103: uint8(0x53),
 	1104: uint8(0x54),
 	1105: uint8(0x55),
 	1106: uint8(0x56),
 	1107: uint8(0x57),
 	1108: uint8(0x58),
 	1109: uint8(0x59),
 	1110: uint8(0x5a),
 	1111: uint8(0x5b),
 	1112: uint8(0x5c),
 	1113: uint8(0x5d),
 	1114: uint8(0x5e),
 	1115: uint8(0x5f),
 	1116: uint8(0x60),
 	1117: uint8(0x61),
 	1118: uint8(0x62),
 	1119: uint8(0x63),
 	1120: uint8(0x64),
 	1121: uint8(0x65),
 	1122: uint8(0x66),
 	1123: uint8(0x67),
 	1124: uint8(0x68),
 	1125: uint8(0x69),
 	1126: uint8(0x6a),
 	1127: uint8(0x6b),
 	1128: uint8(0x6c),
 	1129: uint8(0x6d),
 	1130: uint8(0x6e),
 	1131: uint8(0x6f),
 	1132: uint8(0x70),
 	1133: uint8(0x71),
 	1134: uint8(0x72),
 	1135: uint8(0x73),
 	1136: uint8(0x74),
 	1137: uint8(0x75),
 	1138: uint8(0x76),
 	1139: uint8(0x77),
 	1140: uint8(0x78),
 	1141: uint8(0x79),
 	1142: uint8(0x7a),
 	1143: uint8(0x7b),
 	1144: uint8(0x7c),
 	1145: uint8(0x7d),
 	1146: uint8(0x7e),
 	1147: uint8(0x7f),
 	1148: uint8(0x7f),
 	1149: uint8(0x7f),
 	1150: uint8(0x7f),
 	1151: uint8(0x7f),
 	1152: uint8(0x7f),
 	1153: uint8(0x7f),
 	1154: uint8(0x7f),
 	1155: uint8(0x7f),
 	1156: uint8(0x7f),
 	1157: uint8(0x7f),
 	1158: uint8(0x7f),
 	1159: uint8(0x7f),
 	1160: uint8(0x7f),
 	1161: uint8(0x7f),
 	1162: uint8(0x7f),
 	1163: uint8(0x7f),
 	1164: uint8(0x7f),
 	1165: uint8(0x7f),
 	1166: uint8(0x7f),
 	1167: uint8(0x7f),
 	1168: uint8(0x7f),
 	1169: uint8(0x7f),
 	1170: uint8(0x7f),
 	1171: uint8(0x7f),
 	1172: uint8(0x7f),
 	1173: uint8(0x7f),
 	1174: uint8(0x7f),
 	1175: uint8(0x7f),
 	1176: uint8(0x7f),
 	1177: uint8(0x7f),
 	1178: uint8(0x7f),
 	1179: uint8(0x7f),
 	1180: uint8(0x7f),
 	1181: uint8(0x7f),
 	1182: uint8(0x7f),
 	1183: uint8(0x7f),
 	1184: uint8(0x7f),
 	1185: uint8(0x7f),
 	1186: uint8(0x7f),
 	1187: uint8(0x7f),
 	1188: uint8(0x7f),
 	1189: uint8(0x7f),
 	1190: uint8(0x7f),
 	1191: uint8(0x7f),
 	1192: uint8(0x7f),
 	1193: uint8(0x7f),
 	1194: uint8(0x7f),
 	1195: uint8(0x7f),
 	1196: uint8(0x7f),
 	1197: uint8(0x7f),
 	1198: uint8(0x7f),
 	1199: uint8(0x7f),
 	1200: uint8(0x7f),
 	1201: uint8(0x7f),
 	1202: uint8(0x7f),
 	1203: uint8(0x7f),
 	1204: uint8(0x7f),
 	1205: uint8(0x7f),
 	1206: uint8(0x7f),
 	1207: uint8(0x7f),
 	1208: uint8(0x7f),
 	1209: uint8(0x7f),
 	1210: uint8(0x7f),
 	1211: uint8(0x7f),
 	1212: uint8(0x7f),
 	1213: uint8(0x7f),
 	1214: uint8(0x7f),
 	1215: uint8(0x7f),
 	1216: uint8(0x7f),
 	1217: uint8(0x7f),
 	1218: uint8(0x7f),
 	1219: uint8(0x7f),
 	1220: uint8(0x7f),
 	1221: uint8(0x7f),
 	1222: uint8(0x7f),
 	1223: uint8(0x7f),
 	1224: uint8(0x7f),
 	1225: uint8(0x7f),
 	1226: uint8(0x7f),
 	1227: uint8(0x7f),
 	1228: uint8(0x7f),
 	1229: uint8(0x7f),
 	1230: uint8(0x7f),
 	1231: uint8(0x7f),
 	1232: uint8(0x7f),
 	1233: uint8(0x7f),
 	1234: uint8(0x7f),
 	1235: uint8(0x7f),
 	1236: uint8(0x7f),
 	1237: uint8(0x7f),
 	1238: uint8(0x7f),
 	1239: uint8(0x7f),
 	1240: uint8(0x7f),
 	1241: uint8(0x7f),
 	1242: uint8(0x7f),
 	1243: uint8(0x7f),
 	1244: uint8(0x7f),
 	1245: uint8(0x7f),
 	1246: uint8(0x7f),
 	1247: uint8(0x7f),
 	1248: uint8(0x7f),
 	1249: uint8(0x7f),
 	1250: uint8(0x7f),
 	1251: uint8(0x7f),
 	1252: uint8(0x7f),
 	1253: uint8(0x7f),
 	1254: uint8(0x7f),
 	1255: uint8(0x7f),
 	1256: uint8(0x7f),
 	1257: uint8(0x7f),
 	1258: uint8(0x7f),
 	1259: uint8(0x7f),
 	1260: uint8(0x7f),
 	1261: uint8(0x7f),
 	1262: uint8(0x7f),
 	1263: uint8(0x7f),
 	1264: uint8(0x7f),
 	1265: uint8(0x7f),
 	1266: uint8(0x7f),
 	1267: uint8(0x7f),
 	1268: uint8(0x7f),
 	1269: uint8(0x7f),
 	1270: uint8(0x7f),
 	1271: uint8(0x7f),
 	1272: uint8(0x7f),
 	1273: uint8(0x7f),
 	1274: uint8(0x7f),
 	1275: uint8(0x7f),
 	1276: uint8(0x7f),
 	1277: uint8(0x7f),
 	1278: uint8(0x7f),
 	1279: uint8(0x7f),
 	1280: uint8(0x7f),
 	1281: uint8(0x7f),
 	1282: uint8(0x7f),
 	1283: uint8(0x7f),
 	1284: uint8(0x7f),
 	1285: uint8(0x7f),
 	1286: uint8(0x7f),
 	1287: uint8(0x7f),
 	1288: uint8(0x7f),
 	1289: uint8(0x7f),
 	1290: uint8(0x7f),
 	1291: uint8(0x7f),
 	1292: uint8(0x7f),
 	1293: uint8(0x7f),
 	1294: uint8(0x7f),
 	1295: uint8(0x7f),
 	1296: uint8(0x7f),
 	1297: uint8(0x7f),
 	1298: uint8(0x7f),
 	1299: uint8(0x7f),
 	1300: uint8(0x7f),
 	1301: uint8(0x7f),
 	1302: uint8(0x7f),
 	1303: uint8(0x7f),
 	1304: uint8(0x7f),
 	1305: uint8(0x7f),
 	1306: uint8(0x7f),
 	1307: uint8(0x7f),
 	1308: uint8(0x7f),
 	1309: uint8(0x7f),
 	1310: uint8(0x7f),
 	1311: uint8(0x7f),
 	1312: uint8(0x7f),
 	1313: uint8(0x7f),
 	1314: uint8(0x7f),
 	1315: uint8(0x7f),
 	1316: uint8(0x7f),
 	1317: uint8(0x7f),
 	1318: uint8(0x7f),
 	1319: uint8(0x7f),
 	1320: uint8(0x7f),
 	1321: uint8(0x7f),
 	1322: uint8(0x7f),
 	1323: uint8(0x7f),
 	1324: uint8(0x7f),
 	1325: uint8(0x7f),
 	1326: uint8(0x7f),
 	1327: uint8(0x7f),
 	1328: uint8(0x7f),
 	1329: uint8(0x7f),
 	1330: uint8(0x7f),
 	1331: uint8(0x7f),
 	1332: uint8(0x7f),
 	1333: uint8(0x7f),
 	1334: uint8(0x7f),
 	1335: uint8(0x7f),
 	1336: uint8(0x7f),
 	1337: uint8(0x7f),
 	1338: uint8(0x7f),
 	1339: uint8(0x7f),
 	1340: uint8(0x7f),
 	1341: uint8(0x7f),
 	1342: uint8(0x7f),
 	1343: uint8(0x7f),
 	1344: uint8(0x7f),
 	1345: uint8(0x7f),
 	1346: uint8(0x7f),
 	1347: uint8(0x7f),
 	1348: uint8(0x7f),
 	1349: uint8(0x7f),
 	1350: uint8(0x7f),
 	1351: uint8(0x7f),
 	1352: uint8(0x7f),
 	1353: uint8(0x7f),
 	1354: uint8(0x7f),
 	1355: uint8(0x7f),
 	1356: uint8(0x7f),
 	1357: uint8(0x7f),
 	1358: uint8(0x7f),
 	1359: uint8(0x7f),
 	1360: uint8(0x7f),
 	1361: uint8(0x7f),
 	1362: uint8(0x7f),
 	1363: uint8(0x7f),
 	1364: uint8(0x7f),
 	1365: uint8(0x7f),
 	1366: uint8(0x7f),
 	1367: uint8(0x7f),
 	1368: uint8(0x7f),
 	1369: uint8(0x7f),
 	1370: uint8(0x7f),
 	1371: uint8(0x7f),
 	1372: uint8(0x7f),
 	1373: uint8(0x7f),
 	1374: uint8(0x7f),
 	1375: uint8(0x7f),
 	1376: uint8(0x7f),
 	1377: uint8(0x7f),
 	1378: uint8(0x7f),
 	1379: uint8(0x7f),
 	1380: uint8(0x7f),
 	1381: uint8(0x7f),
 	1382: uint8(0x7f),
 	1383: uint8(0x7f),
 	1384: uint8(0x7f),
 	1385: uint8(0x7f),
 	1386: uint8(0x7f),
 	1387: uint8(0x7f),
 	1388: uint8(0x7f),
 	1389: uint8(0x7f),
 	1390: uint8(0x7f),
 	1391: uint8(0x7f),
 	1392: uint8(0x7f),
 	1393: uint8(0x7f),
 	1394: uint8(0x7f),
 	1395: uint8(0x7f),
 	1396: uint8(0x7f),
 	1397: uint8(0x7f),
 	1398: uint8(0x7f),
 	1399: uint8(0x7f),
 	1400: uint8(0x7f),
 	1401: uint8(0x7f),
 	1402: uint8(0x7f),
 	1403: uint8(0x7f),
 	1404: uint8(0x7f),
 	1405: uint8(0x7f),
 	1406: uint8(0x7f),
 	1407: uint8(0x7f),
 	1408: uint8(0x7f),
 	1409: uint8(0x7f),
 	1410: uint8(0x7f),
 	1411: uint8(0x7f),
 	1412: uint8(0x7f),
 	1413: uint8(0x7f),
 	1414: uint8(0x7f),
 	1415: uint8(0x7f),
 	1416: uint8(0x7f),
 	1417: uint8(0x7f),
 	1418: uint8(0x7f),
 	1419: uint8(0x7f),
 	1420: uint8(0x7f),
 	1421: uint8(0x7f),
 	1422: uint8(0x7f),
 	1423: uint8(0x7f),
 	1424: uint8(0x7f),
 	1425: uint8(0x7f),
 	1426: uint8(0x7f),
 	1427: uint8(0x7f),
 	1428: uint8(0x7f),
 	1429: uint8(0x7f),
 	1430: uint8(0x7f),
 	1431: uint8(0x7f),
 	1432: uint8(0x7f),
 	1433: uint8(0x7f),
 	1434: uint8(0x7f),
 	1435: uint8(0x7f),
 	1436: uint8(0x7f),
 	1437: uint8(0x7f),
 	1438: uint8(0x7f),
 	1439: uint8(0x7f),
 	1440: uint8(0x7f),
 	1441: uint8(0x7f),
 	1442: uint8(0x7f),
 	1443: uint8(0x7f),
 	1444: uint8(0x7f),
 	1445: uint8(0x7f),
 	1446: uint8(0x7f),
 	1447: uint8(0x7f),
 	1448: uint8(0x7f),
 	1449: uint8(0x7f),
 	1450: uint8(0x7f),
 	1451: uint8(0x7f),
 	1452: uint8(0x7f),
 	1453: uint8(0x7f),
 	1454: uint8(0x7f),
 	1455: uint8(0x7f),
 	1456: uint8(0x7f),
 	1457: uint8(0x7f),
 	1458: uint8(0x7f),
 	1459: uint8(0x7f),
 	1460: uint8(0x7f),
 	1461: uint8(0x7f),
 	1462: uint8(0x7f),
 	1463: uint8(0x7f),
 	1464: uint8(0x7f),
 	1465: uint8(0x7f),
 	1466: uint8(0x7f),
 	1467: uint8(0x7f),
 	1468: uint8(0x7f),
 	1469: uint8(0x7f),
 	1470: uint8(0x7f),
 	1471: uint8(0x7f),
 	1472: uint8(0x7f),
 	1473: uint8(0x7f),
 	1474: uint8(0x7f),
 	1475: uint8(0x7f),
 	1476: uint8(0x7f),
 	1477: uint8(0x7f),
 	1478: uint8(0x7f),
 	1479: uint8(0x7f),
 	1480: uint8(0x7f),
 	1481: uint8(0x7f),
 	1482: uint8(0x7f),
 	1483: uint8(0x7f),
 	1484: uint8(0x7f),
 	1485: uint8(0x7f),
 	1486: uint8(0x7f),
 	1487: uint8(0x7f),
 	1488: uint8(0x7f),
 	1489: uint8(0x7f),
 	1490: uint8(0x7f),
 	1491: uint8(0x7f),
 	1492: uint8(0x7f),
 	1493: uint8(0x7f),
 	1494: uint8(0x7f),
 	1495: uint8(0x7f),
 	1496: uint8(0x7f),
 	1497: uint8(0x7f),
 	1498: uint8(0x7f),
 	1499: uint8(0x7f),
 	1500: uint8(0x7f),
 	1501: uint8(0x7f),
 	1502: uint8(0x7f),
 	1503: uint8(0x7f),
 	1504: uint8(0x7f),
 	1505: uint8(0x7f),
 	1506: uint8(0x7f),
 	1507: uint8(0x7f),
 	1508: uint8(0x7f),
 	1509: uint8(0x7f),
 	1510: uint8(0x7f),
 	1511: uint8(0x7f),
 	1512: uint8(0x7f),
 	1513: uint8(0x7f),
 	1514: uint8(0x7f),
 	1515: uint8(0x7f),
 	1516: uint8(0x7f),
 	1517: uint8(0x7f),
 	1518: uint8(0x7f),
 	1519: uint8(0x7f),
 	1520: uint8(0x7f),
 	1521: uint8(0x7f),
 	1522: uint8(0x7f),
 	1523: uint8(0x7f),
 	1524: uint8(0x7f),
 	1525: uint8(0x7f),
 	1526: uint8(0x7f),
 	1527: uint8(0x7f),
 	1528: uint8(0x7f),
 	1529: uint8(0x7f),
 	1530: uint8(0x7f),
 	1531: uint8(0x7f),
 	1532: uint8(0x7f),
 	1533: uint8(0x7f),
 	1534: uint8(0x7f),
 	1535: uint8(0x7f),
 	1536: uint8(0x7f),
 	1537: uint8(0x7f),
 	1538: uint8(0x7f),
 	1539: uint8(0x7f),
 	1540: uint8(0x7f),
 	1541: uint8(0x7f),
 	1542: uint8(0x7f),
 	1543: uint8(0x7f),
 	1544: uint8(0x7f),
 	1545: uint8(0x7f),
 	1546: uint8(0x7f),
 	1547: uint8(0x7f),
 	1548: uint8(0x7f),
 	1549: uint8(0x7f),
 	1550: uint8(0x7f),
 	1551: uint8(0x7f),
 	1552: uint8(0x7f),
 	1553: uint8(0x7f),
 	1554: uint8(0x7f),
 	1555: uint8(0x7f),
 	1556: uint8(0x7f),
 	1557: uint8(0x7f),
 	1558: uint8(0x7f),
 	1559: uint8(0x7f),
 	1560: uint8(0x7f),
 	1561: uint8(0x7f),
 	1562: uint8(0x7f),
 	1563: uint8(0x7f),
 	1564: uint8(0x7f),
 	1565: uint8(0x7f),
 	1566: uint8(0x7f),
 	1567: uint8(0x7f),
 	1568: uint8(0x7f),
 	1569: uint8(0x7f),
 	1570: uint8(0x7f),
 	1571: uint8(0x7f),
 	1572: uint8(0x7f),
 	1573: uint8(0x7f),
 	1574: uint8(0x7f),
 	1575: uint8(0x7f),
 	1576: uint8(0x7f),
 	1577: uint8(0x7f),
 	1578: uint8(0x7f),
 	1579: uint8(0x7f),
 	1580: uint8(0x7f),
 	1581: uint8(0x7f),
 	1582: uint8(0x7f),
 	1583: uint8(0x7f),
 	1584: uint8(0x7f),
 	1585: uint8(0x7f),
 	1586: uint8(0x7f),
 	1587: uint8(0x7f),
 	1588: uint8(0x7f),
 	1589: uint8(0x7f),
 	1590: uint8(0x7f),
 	1591: uint8(0x7f),
 	1592: uint8(0x7f),
 	1593: uint8(0x7f),
 	1594: uint8(0x7f),
 	1595: uint8(0x7f),
 	1596: uint8(0x7f),
 	1597: uint8(0x7f),
 	1598: uint8(0x7f),
 	1599: uint8(0x7f),
 	1600: uint8(0x7f),
 	1601: uint8(0x7f),
 	1602: uint8(0x7f),
 	1603: uint8(0x7f),
 	1604: uint8(0x7f),
 	1605: uint8(0x7f),
 	1606: uint8(0x7f),
 	1607: uint8(0x7f),
 	1608: uint8(0x7f),
 	1609: uint8(0x7f),
 	1610: uint8(0x7f),
 	1611: uint8(0x7f),
 	1612: uint8(0x7f),
 	1613: uint8(0x7f),
 	1614: uint8(0x7f),
 	1615: uint8(0x7f),
 	1616: uint8(0x7f),
 	1617: uint8(0x7f),
 	1618: uint8(0x7f),
 	1619: uint8(0x7f),
 	1620: uint8(0x7f),
 	1621: uint8(0x7f),
 	1622: uint8(0x7f),
 	1623: uint8(0x7f),
 	1624: uint8(0x7f),
 	1625: uint8(0x7f),
 	1626: uint8(0x7f),
 	1627: uint8(0x7f),
 	1628: uint8(0x7f),
 	1629: uint8(0x7f),
 	1630: uint8(0x7f),
 	1631: uint8(0x7f),
 	1632: uint8(0x7f),
 	1633: uint8(0x7f),
 	1634: uint8(0x7f),
 	1635: uint8(0x7f),
 	1636: uint8(0x7f),
 	1637: uint8(0x7f),
 	1638: uint8(0x7f),
 	1639: uint8(0x7f),
 	1640: uint8(0x7f),
 	1641: uint8(0x7f),
 	1642: uint8(0x7f),
 	1643: uint8(0x7f),
 	1644: uint8(0x7f),
 	1645: uint8(0x7f),
 	1646: uint8(0x7f),
 	1647: uint8(0x7f),
 	1648: uint8(0x7f),
 	1649: uint8(0x7f),
 	1650: uint8(0x7f),
 	1651: uint8(0x7f),
 	1652: uint8(0x7f),
 	1653: uint8(0x7f),
 	1654: uint8(0x7f),
 	1655: uint8(0x7f),
 	1656: uint8(0x7f),
 	1657: uint8(0x7f),
 	1658: uint8(0x7f),
 	1659: uint8(0x7f),
 	1660: uint8(0x7f),
 	1661: uint8(0x7f),
 	1662: uint8(0x7f),
 	1663: uint8(0x7f),
 	1664: uint8(0x7f),
 	1665: uint8(0x7f),
 	1666: uint8(0x7f),
 	1667: uint8(0x7f),
 	1668: uint8(0x7f),
 	1669: uint8(0x7f),
 	1670: uint8(0x7f),
 	1671: uint8(0x7f),
 	1672: uint8(0x7f),
 	1673: uint8(0x7f),
 	1674: uint8(0x7f),
 	1675: uint8(0x7f),
 	1676: uint8(0x7f),
 	1677: uint8(0x7f),
 	1678: uint8(0x7f),
 	1679: uint8(0x7f),
 	1680: uint8(0x7f),
 	1681: uint8(0x7f),
 	1682: uint8(0x7f),
 	1683: uint8(0x7f),
 	1684: uint8(0x7f),
 	1685: uint8(0x7f),
 	1686: uint8(0x7f),
 	1687: uint8(0x7f),
 	1688: uint8(0x7f),
 	1689: uint8(0x7f),
 	1690: uint8(0x7f),
 	1691: uint8(0x7f),
 	1692: uint8(0x7f),
 	1693: uint8(0x7f),
 	1694: uint8(0x7f),
 	1695: uint8(0x7f),
 	1696: uint8(0x7f),
 	1697: uint8(0x7f),
 	1698: uint8(0x7f),
 	1699: uint8(0x7f),
 	1700: uint8(0x7f),
 	1701: uint8(0x7f),
 	1702: uint8(0x7f),
 	1703: uint8(0x7f),
 	1704: uint8(0x7f),
 	1705: uint8(0x7f),
 	1706: uint8(0x7f),
 	1707: uint8(0x7f),
 	1708: uint8(0x7f),
 	1709: uint8(0x7f),
 	1710: uint8(0x7f),
 	1711: uint8(0x7f),
 	1712: uint8(0x7f),
 	1713: uint8(0x7f),
 	1714: uint8(0x7f),
 	1715: uint8(0x7f),
 	1716: uint8(0x7f),
 	1717: uint8(0x7f),
 	1718: uint8(0x7f),
 	1719: uint8(0x7f),
 	1720: uint8(0x7f),
 	1721: uint8(0x7f),
 	1722: uint8(0x7f),
 	1723: uint8(0x7f),
 	1724: uint8(0x7f),
 	1725: uint8(0x7f),
 	1726: uint8(0x7f),
 	1727: uint8(0x7f),
 	1728: uint8(0x7f),
 	1729: uint8(0x7f),
 	1730: uint8(0x7f),
 	1731: uint8(0x7f),
 	1732: uint8(0x7f),
 	1733: uint8(0x7f),
 	1734: uint8(0x7f),
 	1735: uint8(0x7f),
 	1736: uint8(0x7f),
 	1737: uint8(0x7f),
 	1738: uint8(0x7f),
 	1739: uint8(0x7f),
 	1740: uint8(0x7f),
 	1741: uint8(0x7f),
 	1742: uint8(0x7f),
 	1743: uint8(0x7f),
 	1744: uint8(0x7f),
 	1745: uint8(0x7f),
 	1746: uint8(0x7f),
 	1747: uint8(0x7f),
 	1748: uint8(0x7f),
 	1749: uint8(0x7f),
 	1750: uint8(0x7f),
 	1751: uint8(0x7f),
 	1752: uint8(0x7f),
 	1753: uint8(0x7f),
 	1754: uint8(0x7f),
 	1755: uint8(0x7f),
 	1756: uint8(0x7f),
 	1757: uint8(0x7f),
 	1758: uint8(0x7f),
 	1759: uint8(0x7f),
 	1760: uint8(0x7f),
 	1761: uint8(0x7f),
 	1762: uint8(0x7f),
 	1763: uint8(0x7f),
 	1764: uint8(0x7f),
 	1765: uint8(0x7f),
 	1766: uint8(0x7f),
 	1767: uint8(0x7f),
 	1768: uint8(0x7f),
 	1769: uint8(0x7f),
 	1770: uint8(0x7f),
 	1771: uint8(0x7f),
 	1772: uint8(0x7f),
 	1773: uint8(0x7f),
 	1774: uint8(0x7f),
 	1775: uint8(0x7f),
 	1776: uint8(0x7f),
 	1777: uint8(0x7f),
 	1778: uint8(0x7f),
 	1779: uint8(0x7f),
 	1780: uint8(0x7f),
 	1781: uint8(0x7f),
 	1782: uint8(0x7f),
 	1783: uint8(0x7f),
 	1784: uint8(0x7f),
 	1785: uint8(0x7f),
 	1786: uint8(0x7f),
 	1787: uint8(0x7f),
 	1788: uint8(0x7f),
 	1789: uint8(0x7f),
 	1790: uint8(0x7f),
 	1791: uint8(0x7f),
 	1792: uint8(0x7f),
 	1793: uint8(0x7f),
 	1794: uint8(0x7f),
 	1795: uint8(0x7f),
 	1796: uint8(0x7f),
 	1797: uint8(0x7f),
 	1798: uint8(0x7f),
 	1799: uint8(0x7f),
 	1800: uint8(0x7f),
 	1801: uint8(0x7f),
 	1802: uint8(0x7f),
 	1803: uint8(0x7f),
 	1804: uint8(0x7f),
 	1805: uint8(0x7f),
 	1806: uint8(0x7f),
 	1807: uint8(0x7f),
 	1808: uint8(0x7f),
 	1809: uint8(0x7f),
 	1810: uint8(0x7f),
 	1811: uint8(0x7f),
 	1812: uint8(0x7f),
 	1813: uint8(0x7f),
 	1814: uint8(0x7f),
 	1815: uint8(0x7f),
 	1816: uint8(0x7f),
 	1817: uint8(0x7f),
 	1818: uint8(0x7f),
 	1819: uint8(0x7f),
 	1820: uint8(0x7f),
 	1821: uint8(0x7f),
 	1822: uint8(0x7f),
 	1823: uint8(0x7f),
 	1824: uint8(0x7f),
 	1825: uint8(0x7f),
 	1826: uint8(0x7f),
 	1827: uint8(0x7f),
 	1828: uint8(0x7f),
 	1829: uint8(0x7f),
 	1830: uint8(0x7f),
 	1831: uint8(0x7f),
 	1832: uint8(0x7f),
 	1833: uint8(0x7f),
 	1834: uint8(0x7f),
 	1835: uint8(0x7f),
 	1836: uint8(0x7f),
 	1837: uint8(0x7f),
 	1838: uint8(0x7f),
 	1839: uint8(0x7f),
 	1840: uint8(0x7f),
 	1841: uint8(0x7f),
 	1842: uint8(0x7f),
 	1843: uint8(0x7f),
 	1844: uint8(0x7f),
 	1845: uint8(0x7f),
 	1846: uint8(0x7f),
 	1847: uint8(0x7f),
 	1848: uint8(0x7f),
 	1849: uint8(0x7f),
 	1850: uint8(0x7f),
 	1851: uint8(0x7f),
 	1852: uint8(0x7f),
 	1853: uint8(0x7f),
 	1854: uint8(0x7f),
 	1855: uint8(0x7f),
 	1856: uint8(0x7f),
 	1857: uint8(0x7f),
 	1858: uint8(0x7f),
 	1859: uint8(0x7f),
 	1860: uint8(0x7f),
 	1861: uint8(0x7f),
 	1862: uint8(0x7f),
 	1863: uint8(0x7f),
 	1864: uint8(0x7f),
 	1865: uint8(0x7f),
 	1866: uint8(0x7f),
 	1867: uint8(0x7f),
 	1868: uint8(0x7f),
 	1869: uint8(0x7f),
 	1870: uint8(0x7f),
 	1871: uint8(0x7f),
 	1872: uint8(0x7f),
 	1873: uint8(0x7f),
 	1874: uint8(0x7f),
 	1875: uint8(0x7f),
 	1876: uint8(0x7f),
 	1877: uint8(0x7f),
 	1878: uint8(0x7f),
 	1879: uint8(0x7f),
 	1880: uint8(0x7f),
 	1881: uint8(0x7f),
 	1882: uint8(0x7f),
 	1883: uint8(0x7f),
 	1884: uint8(0x7f),
 	1885: uint8(0x7f),
 	1886: uint8(0x7f),
 	1887: uint8(0x7f),
 	1888: uint8(0x7f),
 	1889: uint8(0x7f),
 	1890: uint8(0x7f),
 	1891: uint8(0x7f),
 	1892: uint8(0x7f),
 	1893: uint8(0x7f),
 	1894: uint8(0x7f),
 	1895: uint8(0x7f),
 	1896: uint8(0x7f),
 	1897: uint8(0x7f),
 	1898: uint8(0x7f),
 	1899: uint8(0x7f),
 	1900: uint8(0x7f),
 	1901: uint8(0x7f),
 	1902: uint8(0x7f),
 	1903: uint8(0x7f),
 	1904: uint8(0x7f),
 	1905: uint8(0x7f),
 	1906: uint8(0x7f),
 	1907: uint8(0x7f),
 	1908: uint8(0x7f),
 	1909: uint8(0x7f),
 	1910: uint8(0x7f),
 	1911: uint8(0x7f),
 	1912: uint8(0x7f),
 	1913: uint8(0x7f),
 	1914: uint8(0x7f),
 	1915: uint8(0x7f),
 	1916: uint8(0x7f),
 	1917: uint8(0x7f),
 	1918: uint8(0x7f),
 	1919: uint8(0x7f),
 	1920: uint8(0x7f),
 	1921: uint8(0x7f),
 	1922: uint8(0x7f),
 	1923: uint8(0x7f),
 	1924: uint8(0x7f),
 	1925: uint8(0x7f),
 	1926: uint8(0x7f),
 	1927: uint8(0x7f),
 	1928: uint8(0x7f),
 	1929: uint8(0x7f),
 	1930: uint8(0x7f),
 	1931: uint8(0x7f),
 	1932: uint8(0x7f),
 	1933: uint8(0x7f),
 	1934: uint8(0x7f),
 	1935: uint8(0x7f),
 	1936: uint8(0x7f),
 	1937: uint8(0x7f),
 	1938: uint8(0x7f),
 	1939: uint8(0x7f),
 	1940: uint8(0x7f),
 	1941: uint8(0x7f),
 	1942: uint8(0x7f),
 	1943: uint8(0x7f),
 	1944: uint8(0x7f),
 	1945: uint8(0x7f),
 	1946: uint8(0x7f),
 	1947: uint8(0x7f),
 	1948: uint8(0x7f),
 	1949: uint8(0x7f),
 	1950: uint8(0x7f),
 	1951: uint8(0x7f),
 	1952: uint8(0x7f),
 	1953: uint8(0x7f),
 	1954: uint8(0x7f),
 	1955: uint8(0x7f),
 	1956: uint8(0x7f),
 	1957: uint8(0x7f),
 	1958: uint8(0x7f),
 	1959: uint8(0x7f),
 	1960: uint8(0x7f),
 	1961: uint8(0x7f),
 	1962: uint8(0x7f),
 	1963: uint8(0x7f),
 	1964: uint8(0x7f),
 	1965: uint8(0x7f),
 	1966: uint8(0x7f),
 	1967: uint8(0x7f),
 	1968: uint8(0x7f),
 	1969: uint8(0x7f),
 	1970: uint8(0x7f),
 	1971: uint8(0x7f),
 	1972: uint8(0x7f),
 	1973: uint8(0x7f),
 	1974: uint8(0x7f),
 	1975: uint8(0x7f),
 	1976: uint8(0x7f),
 	1977: uint8(0x7f),
 	1978: uint8(0x7f),
 	1979: uint8(0x7f),
 	1980: uint8(0x7f),
 	1981: uint8(0x7f),
 	1982: uint8(0x7f),
 	1983: uint8(0x7f),
 	1984: uint8(0x7f),
 	1985: uint8(0x7f),
 	1986: uint8(0x7f),
 	1987: uint8(0x7f),
 	1988: uint8(0x7f),
 	1989: uint8(0x7f),
 	1990: uint8(0x7f),
 	1991: uint8(0x7f),
 	1992: uint8(0x7f),
 	1993: uint8(0x7f),
 	1994: uint8(0x7f),
 	1995: uint8(0x7f),
 	1996: uint8(0x7f),
 	1997: uint8(0x7f),
 	1998: uint8(0x7f),
 	1999: uint8(0x7f),
 	2000: uint8(0x7f),
 	2001: uint8(0x7f),
 	2002: uint8(0x7f),
 	2003: uint8(0x7f),
 	2004: uint8(0x7f),
 	2005: uint8(0x7f),
 	2006: uint8(0x7f),
 	2007: uint8(0x7f),
 	2008: uint8(0x7f),
 	2009: uint8(0x7f),
 	2010: uint8(0x7f),
 	2011: uint8(0x7f),
 	2012: uint8(0x7f),
 	2013: uint8(0x7f),
 	2014: uint8(0x7f),
 	2015: uint8(0x7f),
 	2016: uint8(0x7f),
 	2017: uint8(0x7f),
 	2018: uint8(0x7f),
 	2019: uint8(0x7f),
 	2020: uint8(0x7f),
 	2021: uint8(0x7f),
 	2022: uint8(0x7f),
 	2023: uint8(0x7f),
 	2024: uint8(0x7f),
 	2025: uint8(0x7f),
 	2026: uint8(0x7f),
 	2027: uint8(0x7f),
 	2028: uint8(0x7f),
 	2029: uint8(0x7f),
 	2030: uint8(0x7f),
 	2031: uint8(0x7f),
 	2032: uint8(0x7f),
 	2033: uint8(0x7f),
 	2034: uint8(0x7f),
 	2035: uint8(0x7f),
 	2036: uint8(0x7f),
 	2037: uint8(0x7f),
 	2038: uint8(0x7f),
 	2039: uint8(0x7f),
 }
 
 var sclip2 = [225]uint8_t{
 	0:   uint8(0xf0),
 	1:   uint8(0xf0),
 	2:   uint8(0xf0),
 	3:   uint8(0xf0),
 	4:   uint8(0xf0),
 	5:   uint8(0xf0),
 	6:   uint8(0xf0),
 	7:   uint8(0xf0),
 	8:   uint8(0xf0),
 	9:   uint8(0xf0),
 	10:  uint8(0xf0),
 	11:  uint8(0xf0),
 	12:  uint8(0xf0),
 	13:  uint8(0xf0),
 	14:  uint8(0xf0),
 	15:  uint8(0xf0),
 	16:  uint8(0xf0),
 	17:  uint8(0xf0),
 	18:  uint8(0xf0),
 	19:  uint8(0xf0),
 	20:  uint8(0xf0),
 	21:  uint8(0xf0),
 	22:  uint8(0xf0),
 	23:  uint8(0xf0),
 	24:  uint8(0xf0),
 	25:  uint8(0xf0),
 	26:  uint8(0xf0),
 	27:  uint8(0xf0),
 	28:  uint8(0xf0),
 	29:  uint8(0xf0),
 	30:  uint8(0xf0),
 	31:  uint8(0xf0),
 	32:  uint8(0xf0),
 	33:  uint8(0xf0),
 	34:  uint8(0xf0),
 	35:  uint8(0xf0),
 	36:  uint8(0xf0),
 	37:  uint8(0xf0),
 	38:  uint8(0xf0),
 	39:  uint8(0xf0),
 	40:  uint8(0xf0),
 	41:  uint8(0xf0),
 	42:  uint8(0xf0),
 	43:  uint8(0xf0),
 	44:  uint8(0xf0),
 	45:  uint8(0xf0),
 	46:  uint8(0xf0),
 	47:  uint8(0xf0),
 	48:  uint8(0xf0),
 	49:  uint8(0xf0),
 	50:  uint8(0xf0),
 	51:  uint8(0xf0),
 	52:  uint8(0xf0),
 	53:  uint8(0xf0),
 	54:  uint8(0xf0),
 	55:  uint8(0xf0),
 	56:  uint8(0xf0),
 	57:  uint8(0xf0),
 	58:  uint8(0xf0),
 	59:  uint8(0xf0),
 	60:  uint8(0xf0),
 	61:  uint8(0xf0),
 	62:  uint8(0xf0),
 	63:  uint8(0xf0),
 	64:  uint8(0xf0),
 	65:  uint8(0xf0),
 	66:  uint8(0xf0),
 	67:  uint8(0xf0),
 	68:  uint8(0xf0),
 	69:  uint8(0xf0),
 	70:  uint8(0xf0),
 	71:  uint8(0xf0),
 	72:  uint8(0xf0),
 	73:  uint8(0xf0),
 	74:  uint8(0xf0),
 	75:  uint8(0xf0),
 	76:  uint8(0xf0),
 	77:  uint8(0xf0),
 	78:  uint8(0xf0),
 	79:  uint8(0xf0),
 	80:  uint8(0xf0),
 	81:  uint8(0xf0),
 	82:  uint8(0xf0),
 	83:  uint8(0xf0),
 	84:  uint8(0xf0),
 	85:  uint8(0xf0),
 	86:  uint8(0xf0),
 	87:  uint8(0xf0),
 	88:  uint8(0xf0),
 	89:  uint8(0xf0),
 	90:  uint8(0xf0),
 	91:  uint8(0xf0),
 	92:  uint8(0xf0),
 	93:  uint8(0xf0),
 	94:  uint8(0xf0),
 	95:  uint8(0xf0),
 	96:  uint8(0xf0),
 	97:  uint8(0xf1),
 	98:  uint8(0xf2),
 	99:  uint8(0xf3),
 	100: uint8(0xf4),
 	101: uint8(0xf5),
 	102: uint8(0xf6),
 	103: uint8(0xf7),
 	104: uint8(0xf8),
 	105: uint8(0xf9),
 	106: uint8(0xfa),
 	107: uint8(0xfb),
 	108: uint8(0xfc),
 	109: uint8(0xfd),
 	110: uint8(0xfe),
 	111: uint8(0xff),
 	113: uint8(0x01),
 	114: uint8(0x02),
 	115: uint8(0x03),
 	116: uint8(0x04),
 	117: uint8(0x05),
 	118: uint8(0x06),
 	119: uint8(0x07),
 	120: uint8(0x08),
 	121: uint8(0x09),
 	122: uint8(0x0a),
 	123: uint8(0x0b),
 	124: uint8(0x0c),
 	125: uint8(0x0d),
 	126: uint8(0x0e),
 	127: uint8(0x0f),
 	128: uint8(0x0f),
 	129: uint8(0x0f),
 	130: uint8(0x0f),
 	131: uint8(0x0f),
 	132: uint8(0x0f),
 	133: uint8(0x0f),
 	134: uint8(0x0f),
 	135: uint8(0x0f),
 	136: uint8(0x0f),
 	137: uint8(0x0f),
 	138: uint8(0x0f),
 	139: uint8(0x0f),
 	140: uint8(0x0f),
 	141: uint8(0x0f),
 	142: uint8(0x0f),
 	143: uint8(0x0f),
 	144: uint8(0x0f),
 	145: uint8(0x0f),
 	146: uint8(0x0f),
 	147: uint8(0x0f),
 	148: uint8(0x0f),
 	149: uint8(0x0f),
 	150: uint8(0x0f),
 	151: uint8(0x0f),
 	152: uint8(0x0f),
 	153: uint8(0x0f),
 	154: uint8(0x0f),
 	155: uint8(0x0f),
 	156: uint8(0x0f),
 	157: uint8(0x0f),
 	158: uint8(0x0f),
 	159: uint8(0x0f),
 	160: uint8(0x0f),
 	161: uint8(0x0f),
 	162: uint8(0x0f),
 	163: uint8(0x0f),
 	164: uint8(0x0f),
 	165: uint8(0x0f),
 	166: uint8(0x0f),
 	167: uint8(0x0f),
 	168: uint8(0x0f),
 	169: uint8(0x0f),
 	170: uint8(0x0f),
 	171: uint8(0x0f),
 	172: uint8(0x0f),
 	173: uint8(0x0f),
 	174: uint8(0x0f),
 	175: uint8(0x0f),
 	176: uint8(0x0f),
 	177: uint8(0x0f),
 	178: uint8(0x0f),
 	179: uint8(0x0f),
 	180: uint8(0x0f),
 	181: uint8(0x0f),
 	182: uint8(0x0f),
 	183: uint8(0x0f),
 	184: uint8(0x0f),
 	185: uint8(0x0f),
 	186: uint8(0x0f),
 	187: uint8(0x0f),
 	188: uint8(0x0f),
 	189: uint8(0x0f),
 	190: uint8(0x0f),
 	191: uint8(0x0f),
 	192: uint8(0x0f),
 	193: uint8(0x0f),
 	194: uint8(0x0f),
 	195: uint8(0x0f),
 	196: uint8(0x0f),
 	197: uint8(0x0f),
 	198: uint8(0x0f),
 	199: uint8(0x0f),
 	200: uint8(0x0f),
 	201: uint8(0x0f),
 	202: uint8(0x0f),
 	203: uint8(0x0f),
 	204: uint8(0x0f),
 	205: uint8(0x0f),
 	206: uint8(0x0f),
 	207: uint8(0x0f),
 	208: uint8(0x0f),
 	209: uint8(0x0f),
 	210: uint8(0x0f),
 	211: uint8(0x0f),
 	212: uint8(0x0f),
 	213: uint8(0x0f),
 	214: uint8(0x0f),
 	215: uint8(0x0f),
 	216: uint8(0x0f),
 	217: uint8(0x0f),
 	218: uint8(0x0f),
 	219: uint8(0x0f),
 	220: uint8(0x0f),
 	221: uint8(0x0f),
 	222: uint8(0x0f),
 	223: uint8(0x0f),
 }
 
 var clip11 = [767]uint8_t{
 	256: uint8(0x01),
 	257: uint8(0x02),
 	258: uint8(0x03),
 	259: uint8(0x04),
 	260: uint8(0x05),
 	261: uint8(0x06),
 	262: uint8(0x07),
 	263: uint8(0x08),
 	264: uint8(0x09),
 	265: uint8(0x0a),
 	266: uint8(0x0b),
 	267: uint8(0x0c),
 	268: uint8(0x0d),
 	269: uint8(0x0e),
 	270: uint8(0x0f),
 	271: uint8(0x10),
 	272: uint8(0x11),
 	273: uint8(0x12),
 	274: uint8(0x13),
 	275: uint8(0x14),
 	276: uint8(0x15),
 	277: uint8(0x16),
 	278: uint8(0x17),
 	279: uint8(0x18),
 	280: uint8(0x19),
 	281: uint8(0x1a),
 	282: uint8(0x1b),
 	283: uint8(0x1c),
 	284: uint8(0x1d),
 	285: uint8(0x1e),
 	286: uint8(0x1f),
 	287: uint8(0x20),
 	288: uint8(0x21),
 	289: uint8(0x22),
 	290: uint8(0x23),
 	291: uint8(0x24),
 	292: uint8(0x25),
 	293: uint8(0x26),
 	294: uint8(0x27),
 	295: uint8(0x28),
 	296: uint8(0x29),
 	297: uint8(0x2a),
 	298: uint8(0x2b),
 	299: uint8(0x2c),
 	300: uint8(0x2d),
 	301: uint8(0x2e),
 	302: uint8(0x2f),
 	303: uint8(0x30),
 	304: uint8(0x31),
 	305: uint8(0x32),
 	306: uint8(0x33),
 	307: uint8(0x34),
 	308: uint8(0x35),
 	309: uint8(0x36),
 	310: uint8(0x37),
 	311: uint8(0x38),
 	312: uint8(0x39),
 	313: uint8(0x3a),
 	314: uint8(0x3b),
 	315: uint8(0x3c),
 	316: uint8(0x3d),
 	317: uint8(0x3e),
 	318: uint8(0x3f),
 	319: uint8(0x40),
 	320: uint8(0x41),
 	321: uint8(0x42),
 	322: uint8(0x43),
 	323: uint8(0x44),
 	324: uint8(0x45),
 	325: uint8(0x46),
 	326: uint8(0x47),
 	327: uint8(0x48),
 	328: uint8(0x49),
 	329: uint8(0x4a),
 	330: uint8(0x4b),
 	331: uint8(0x4c),
 	332: uint8(0x4d),
 	333: uint8(0x4e),
 	334: uint8(0x4f),
 	335: uint8(0x50),
 	336: uint8(0x51),
 	337: uint8(0x52),
 	338: uint8(0x53),
 	339: uint8(0x54),
 	340: uint8(0x55),
 	341: uint8(0x56),
 	342: uint8(0x57),
 	343: uint8(0x58),
 	344: uint8(0x59),
 	345: uint8(0x5a),
 	346: uint8(0x5b),
 	347: uint8(0x5c),
 	348: uint8(0x5d),
 	349: uint8(0x5e),
 	350: uint8(0x5f),
 	351: uint8(0x60),
 	352: uint8(0x61),
 	353: uint8(0x62),
 	354: uint8(0x63),
 	355: uint8(0x64),
 	356: uint8(0x65),
 	357: uint8(0x66),
 	358: uint8(0x67),
 	359: uint8(0x68),
 	360: uint8(0x69),
 	361: uint8(0x6a),
 	362: uint8(0x6b),
 	363: uint8(0x6c),
 	364: uint8(0x6d),
 	365: uint8(0x6e),
 	366: uint8(0x6f),
 	367: uint8(0x70),
 	368: uint8(0x71),
 	369: uint8(0x72),
 	370: uint8(0x73),
 	371: uint8(0x74),
 	372: uint8(0x75),
 	373: uint8(0x76),
 	374: uint8(0x77),
 	375: uint8(0x78),
 	376: uint8(0x79),
 	377: uint8(0x7a),
 	378: uint8(0x7b),
 	379: uint8(0x7c),
 	380: uint8(0x7d),
 	381: uint8(0x7e),
 	382: uint8(0x7f),
 	383: uint8(0x80),
 	384: uint8(0x81),
 	385: uint8(0x82),
 	386: uint8(0x83),
 	387: uint8(0x84),
 	388: uint8(0x85),
 	389: uint8(0x86),
 	390: uint8(0x87),
 	391: uint8(0x88),
 	392: uint8(0x89),
 	393: uint8(0x8a),
 	394: uint8(0x8b),
 	395: uint8(0x8c),
 	396: uint8(0x8d),
 	397: uint8(0x8e),
 	398: uint8(0x8f),
 	399: uint8(0x90),
 	400: uint8(0x91),
 	401: uint8(0x92),
 	402: uint8(0x93),
 	403: uint8(0x94),
 	404: uint8(0x95),
 	405: uint8(0x96),
 	406: uint8(0x97),
 	407: uint8(0x98),
 	408: uint8(0x99),
 	409: uint8(0x9a),
 	410: uint8(0x9b),
 	411: uint8(0x9c),
 	412: uint8(0x9d),
 	413: uint8(0x9e),
 	414: uint8(0x9f),
 	415: uint8(0xa0),
 	416: uint8(0xa1),
 	417: uint8(0xa2),
 	418: uint8(0xa3),
 	419: uint8(0xa4),
 	420: uint8(0xa5),
 	421: uint8(0xa6),
 	422: uint8(0xa7),
 	423: uint8(0xa8),
 	424: uint8(0xa9),
 	425: uint8(0xaa),
 	426: uint8(0xab),
 	427: uint8(0xac),
 	428: uint8(0xad),
 	429: uint8(0xae),
 	430: uint8(0xaf),
 	431: uint8(0xb0),
 	432: uint8(0xb1),
 	433: uint8(0xb2),
 	434: uint8(0xb3),
 	435: uint8(0xb4),
 	436: uint8(0xb5),
 	437: uint8(0xb6),
 	438: uint8(0xb7),
 	439: uint8(0xb8),
 	440: uint8(0xb9),
 	441: uint8(0xba),
 	442: uint8(0xbb),
 	443: uint8(0xbc),
 	444: uint8(0xbd),
 	445: uint8(0xbe),
 	446: uint8(0xbf),
 	447: uint8(0xc0),
 	448: uint8(0xc1),
 	449: uint8(0xc2),
 	450: uint8(0xc3),
 	451: uint8(0xc4),
 	452: uint8(0xc5),
 	453: uint8(0xc6),
 	454: uint8(0xc7),
 	455: uint8(0xc8),
 	456: uint8(0xc9),
 	457: uint8(0xca),
 	458: uint8(0xcb),
 	459: uint8(0xcc),
 	460: uint8(0xcd),
 	461: uint8(0xce),
 	462: uint8(0xcf),
 	463: uint8(0xd0),
 	464: uint8(0xd1),
 	465: uint8(0xd2),
 	466: uint8(0xd3),
 	467: uint8(0xd4),
 	468: uint8(0xd5),
 	469: uint8(0xd6),
 	470: uint8(0xd7),
 	471: uint8(0xd8),
 	472: uint8(0xd9),
 	473: uint8(0xda),
 	474: uint8(0xdb),
 	475: uint8(0xdc),
 	476: uint8(0xdd),
 	477: uint8(0xde),
 	478: uint8(0xdf),
 	479: uint8(0xe0),
 	480: uint8(0xe1),
 	481: uint8(0xe2),
 	482: uint8(0xe3),
 	483: uint8(0xe4),
 	484: uint8(0xe5),
 	485: uint8(0xe6),
 	486: uint8(0xe7),
 	487: uint8(0xe8),
 	488: uint8(0xe9),
 	489: uint8(0xea),
 	490: uint8(0xeb),
 	491: uint8(0xec),
 	492: uint8(0xed),
 	493: uint8(0xee),
 	494: uint8(0xef),
 	495: uint8(0xf0),
 	496: uint8(0xf1),
 	497: uint8(0xf2),
 	498: uint8(0xf3),
 	499: uint8(0xf4),
 	500: uint8(0xf5),
 	501: uint8(0xf6),
 	502: uint8(0xf7),
 	503: uint8(0xf8),
 	504: uint8(0xf9),
 	505: uint8(0xfa),
 	506: uint8(0xfb),
 	507: uint8(0xfc),
 	508: uint8(0xfd),
 	509: uint8(0xfe),
 	510: uint8(0xff),
 	511: uint8(0xff),
 	512: uint8(0xff),
 	513: uint8(0xff),
 	514: uint8(0xff),
 	515: uint8(0xff),
 	516: uint8(0xff),
 	517: uint8(0xff),
 	518: uint8(0xff),
 	519: uint8(0xff),
 	520: uint8(0xff),
 	521: uint8(0xff),
 	522: uint8(0xff),
 	523: uint8(0xff),
 	524: uint8(0xff),
 	525: uint8(0xff),
 	526: uint8(0xff),
 	527: uint8(0xff),
 	528: uint8(0xff),
 	529: uint8(0xff),
 	530: uint8(0xff),
 	531: uint8(0xff),
 	532: uint8(0xff),
 	533: uint8(0xff),
 	534: uint8(0xff),
 	535: uint8(0xff),
 	536: uint8(0xff),
 	537: uint8(0xff),
 	538: uint8(0xff),
 	539: uint8(0xff),
 	540: uint8(0xff),
 	541: uint8(0xff),
 	542: uint8(0xff),
 	543: uint8(0xff),
 	544: uint8(0xff),
 	545: uint8(0xff),
 	546: uint8(0xff),
 	547: uint8(0xff),
 	548: uint8(0xff),
 	549: uint8(0xff),
 	550: uint8(0xff),
 	551: uint8(0xff),
 	552: uint8(0xff),
 	553: uint8(0xff),
 	554: uint8(0xff),
 	555: uint8(0xff),
 	556: uint8(0xff),
 	557: uint8(0xff),
 	558: uint8(0xff),
 	559: uint8(0xff),
 	560: uint8(0xff),
 	561: uint8(0xff),
 	562: uint8(0xff),
 	563: uint8(0xff),
 	564: uint8(0xff),
 	565: uint8(0xff),
 	566: uint8(0xff),
 	567: uint8(0xff),
 	568: uint8(0xff),
 	569: uint8(0xff),
 	570: uint8(0xff),
 	571: uint8(0xff),
 	572: uint8(0xff),
 	573: uint8(0xff),
 	574: uint8(0xff),
 	575: uint8(0xff),
 	576: uint8(0xff),
 	577: uint8(0xff),
 	578: uint8(0xff),
 	579: uint8(0xff),
 	580: uint8(0xff),
 	581: uint8(0xff),
 	582: uint8(0xff),
 	583: uint8(0xff),
 	584: uint8(0xff),
 	585: uint8(0xff),
 	586: uint8(0xff),
 	587: uint8(0xff),
 	588: uint8(0xff),
 	589: uint8(0xff),
 	590: uint8(0xff),
 	591: uint8(0xff),
 	592: uint8(0xff),
 	593: uint8(0xff),
 	594: uint8(0xff),
 	595: uint8(0xff),
 	596: uint8(0xff),
 	597: uint8(0xff),
 	598: uint8(0xff),
 	599: uint8(0xff),
 	600: uint8(0xff),
 	601: uint8(0xff),
 	602: uint8(0xff),
 	603: uint8(0xff),
 	604: uint8(0xff),
 	605: uint8(0xff),
 	606: uint8(0xff),
 	607: uint8(0xff),
 	608: uint8(0xff),
 	609: uint8(0xff),
 	610: uint8(0xff),
 	611: uint8(0xff),
 	612: uint8(0xff),
 	613: uint8(0xff),
 	614: uint8(0xff),
 	615: uint8(0xff),
 	616: uint8(0xff),
 	617: uint8(0xff),
 	618: uint8(0xff),
 	619: uint8(0xff),
 	620: uint8(0xff),
 	621: uint8(0xff),
 	622: uint8(0xff),
 	623: uint8(0xff),
 	624: uint8(0xff),
 	625: uint8(0xff),
 	626: uint8(0xff),
 	627: uint8(0xff),
 	628: uint8(0xff),
 	629: uint8(0xff),
 	630: uint8(0xff),
 	631: uint8(0xff),
 	632: uint8(0xff),
 	633: uint8(0xff),
 	634: uint8(0xff),
 	635: uint8(0xff),
 	636: uint8(0xff),
 	637: uint8(0xff),
 	638: uint8(0xff),
 	639: uint8(0xff),
 	640: uint8(0xff),
 	641: uint8(0xff),
 	642: uint8(0xff),
 	643: uint8(0xff),
 	644: uint8(0xff),
 	645: uint8(0xff),
 	646: uint8(0xff),
 	647: uint8(0xff),
 	648: uint8(0xff),
 	649: uint8(0xff),
 	650: uint8(0xff),
 	651: uint8(0xff),
 	652: uint8(0xff),
 	653: uint8(0xff),
 	654: uint8(0xff),
 	655: uint8(0xff),
 	656: uint8(0xff),
 	657: uint8(0xff),
 	658: uint8(0xff),
 	659: uint8(0xff),
 	660: uint8(0xff),
 	661: uint8(0xff),
 	662: uint8(0xff),
 	663: uint8(0xff),
 	664: uint8(0xff),
 	665: uint8(0xff),
 	666: uint8(0xff),
 	667: uint8(0xff),
 	668: uint8(0xff),
 	669: uint8(0xff),
 	670: uint8(0xff),
 	671: uint8(0xff),
 	672: uint8(0xff),
 	673: uint8(0xff),
 	674: uint8(0xff),
 	675: uint8(0xff),
 	676: uint8(0xff),
 	677: uint8(0xff),
 	678: uint8(0xff),
 	679: uint8(0xff),
 	680: uint8(0xff),
 	681: uint8(0xff),
 	682: uint8(0xff),
 	683: uint8(0xff),
 	684: uint8(0xff),
 	685: uint8(0xff),
 	686: uint8(0xff),
 	687: uint8(0xff),
 	688: uint8(0xff),
 	689: uint8(0xff),
 	690: uint8(0xff),
 	691: uint8(0xff),
 	692: uint8(0xff),
 	693: uint8(0xff),
 	694: uint8(0xff),
 	695: uint8(0xff),
 	696: uint8(0xff),
 	697: uint8(0xff),
 	698: uint8(0xff),
 	699: uint8(0xff),
 	700: uint8(0xff),
 	701: uint8(0xff),
 	702: uint8(0xff),
 	703: uint8(0xff),
 	704: uint8(0xff),
 	705: uint8(0xff),
 	706: uint8(0xff),
 	707: uint8(0xff),
 	708: uint8(0xff),
 	709: uint8(0xff),
 	710: uint8(0xff),
 	711: uint8(0xff),
 	712: uint8(0xff),
 	713: uint8(0xff),
 	714: uint8(0xff),
 	715: uint8(0xff),
 	716: uint8(0xff),
 	717: uint8(0xff),
 	718: uint8(0xff),
 	719: uint8(0xff),
 	720: uint8(0xff),
 	721: uint8(0xff),
 	722: uint8(0xff),
 	723: uint8(0xff),
 	724: uint8(0xff),
 	725: uint8(0xff),
 	726: uint8(0xff),
 	727: uint8(0xff),
 	728: uint8(0xff),
 	729: uint8(0xff),
 	730: uint8(0xff),
 	731: uint8(0xff),
 	732: uint8(0xff),
 	733: uint8(0xff),
 	734: uint8(0xff),
 	735: uint8(0xff),
 	736: uint8(0xff),
 	737: uint8(0xff),
 	738: uint8(0xff),
 	739: uint8(0xff),
 	740: uint8(0xff),
 	741: uint8(0xff),
 	742: uint8(0xff),
 	743: uint8(0xff),
 	744: uint8(0xff),
 	745: uint8(0xff),
 	746: uint8(0xff),
 	747: uint8(0xff),
 	748: uint8(0xff),
 	749: uint8(0xff),
 	750: uint8(0xff),
 	751: uint8(0xff),
 	752: uint8(0xff),
 	753: uint8(0xff),
 	754: uint8(0xff),
 	755: uint8(0xff),
 	756: uint8(0xff),
 	757: uint8(0xff),
 	758: uint8(0xff),
 	759: uint8(0xff),
 	760: uint8(0xff),
 	761: uint8(0xff),
 	762: uint8(0xff),
 	763: uint8(0xff),
 	764: uint8(0xff),
 	765: uint8(0xff),
 }
 
 func VP8InitClipTables(tls *libc.TLS) {
 }
 
 func VP8DspInitMIPS32(tls *libc.TLS) {
 }
 
 func VP8DspInitMIPSdspR2(tls *libc.TLS) {
 }
 
 func VP8DspInitMSA(tls *libc.TLS) {
 }
 
 func VP8DspInitNEON(tls *libc.TLS) {
 }
 
 func VP8DspInitSSE2(tls *libc.TLS) {
 }
 
 func VP8DspInitSSE41(tls *libc.TLS) {
 }
 
 //------------------------------------------------------------------------------
 
 // Copyright 2012 Google Inc. All Rights Reserved.
 //
 // Use of this source code is governed by a BSD-style license
 // that can be found in the COPYING file in the root of the source
 // tree. An additional intellectual property rights grant can be found
 // in the file PATENTS. All contributing project authors may
 // be found in the AUTHORS file in the root of the source tree.
 // -----------------------------------------------------------------------------
 //
 // Misc. common utility functions
 //
 // Authors: Skal (pascal.massimino@gmail.com)
 //          Urvang (urvang@google.com)
 
 // Copyright 2010 Google Inc. All Rights Reserved.
 //
 // Use of this source code is governed by a BSD-style license
 // that can be found in the COPYING file in the root of the source
 // tree. An additional intellectual property rights grant can be found
 // in the file PATENTS. All contributing project authors may
 // be found in the AUTHORS file in the root of the source tree.
 // -----------------------------------------------------------------------------
 //
 //  Common types + memory wrappers
 //
 // Author: Skal (pascal.massimino@gmail.com)
 
 func clip_8b2(tls *libc.TLS, v int32) (r uint8_t) {
 	var v1, v2 int32
 	_, _ = v1, v2
 	if !(v & ^libc.Int32FromInt32(0xff) != 0) {
 		v1 = v
 	} else {
 		if v < 0 {
 			v2 = 0
 		} else {
 			v2 = int32(255)
 		}
 		v1 = v2
 	}
 	return libc.Uint8FromInt32(v1)
 }
 
 func clip_max(tls *libc.TLS, v int32, max int32) (r int32) {
 	var v1 int32
 	_ = v1
 	if v > max {
 		v1 = max
 	} else {
 		v1 = v
 	}
 	return v1
 }
 
 // C documentation
 //
 //	// general-purpose util function
 func VP8SetHistogramData(tls *libc.TLS, distribution uintptr, histo uintptr) {
 	var k, last_non_zero, max_value, value int32
 	_, _, _, _ = k, last_non_zero, max_value, value
 	max_value = 0
 	last_non_zero = int32(1)
 	k = 0
 	for {
 		if !(k <= int32(MAX_COEFF_THRESH)) {
 			break
 		}
 		value = **(**int32)(__ccgo_up(distribution + uintptr(k)*4))
 		if value > 0 {
 			if value > max_value {
 				max_value = value
 			}
 			last_non_zero = k
 		}
 		goto _1
 	_1:
 		;
 		k = k + 1
 	}
 	(*VP8Histogram)(unsafe.Pointer(histo)).Fmax_value = max_value
 	(*VP8Histogram)(unsafe.Pointer(histo)).Flast_non_zero = last_non_zero
 }
 
 func CollectHistogram_C(tls *libc.TLS, ref uintptr, pred uintptr, start_block int32, end_block int32, histo uintptr) {
 	bp := tls.Alloc(160)
 	defer tls.Free(160)
 	var clipped_value, j, k, v int32
 	var _ /* distribution at bp+0 */ [32]int32
 	var _ /* out at bp+128 */ [16]int16_t
 	_, _, _, _ = clipped_value, j, k, v
 	**(**[32]int32)(__ccgo_up(bp)) = [32]int32{}
 	j = start_block
 	for {
 		if !(j < end_block) {
 			break
 		}
 		(*(*func(*libc.TLS, uintptr, uintptr, uintptr))(unsafe.Pointer(&struct{ uintptr }{VP8FTransform})))(tls, ref+uintptr(VP8DspScan[j]), pred+uintptr(VP8DspScan[j]), bp+128)
 		// Convert coefficients to bin.
 		k = 0
 		for {
 			if !(k < int32(16)) {
 				break
 			}
 			v = libc.Xabs(tls, int32((**(**[16]int16_t)(__ccgo_up(bp + 128)))[k])) >> int32(3)
 			clipped_value = clip_max(tls, v, int32(MAX_COEFF_THRESH))
 			(**(**[32]int32)(__ccgo_up(bp)))[clipped_value] = (**(**[32]int32)(__ccgo_up(bp)))[clipped_value] + 1
 			goto _2
 		_2:
 			;
 			k = k + 1
 		}
 		goto _1
 	_1:
 		;
 		j = j + 1
 	}
 	VP8SetHistogramData(tls, bp, histo)
 }
 
 //------------------------------------------------------------------------------
 // run-time tables (~4k)
 
 var clip12 [766]uint8_t // clips [-255,510] to [0,255]
 
 // C documentation
 //
 //	// We declare this variable 'volatile' to prevent instruction reordering
 //	// and make sure it's set to true _last_ (so as to be thread-safe)
 var tables_ok = int32(0)
 
 func InitTables(tls *libc.TLS) {
 	var i int32
 	_ = i
 	if !(libc.AtomicLoadPInt32(uintptr(unsafe.Pointer(&tables_ok))) != 0) {
 		i = -int32(255)
 		for {
 			if !(i <= libc.Int32FromInt32(255)+libc.Int32FromInt32(255)) {
 				break
 			}
 			clip12[int32(255)+i] = clip_8b2(tls, i)
 			goto _1
 		_1:
 			;
 			i = i + 1
 		}
 		libc.AtomicStorePInt32(uintptr(unsafe.Pointer(&tables_ok)), int32(1))
 	}
 }
 
 //------------------------------------------------------------------------------
 // Transforms (Paragraph 14.4)
 
 func ITransformOne(tls *libc.TLS, ref uintptr, in uintptr, dst uintptr) {
 	bp := tls.Alloc(64)
 	defer tls.Free(64)
 	var a, a1, b, b1, c, c1, d, d1, dc, i int32
 	var tmp uintptr
 	var _ /* C at bp+0 */ [16]int32
 	_, _, _, _, _, _, _, _, _, _, _ = a, a1, b, b1, c, c1, d, d1, dc, i, tmp
 	tmp = bp
 	i = 0
 	for {
 		if !(i < int32(4)) {
 			break
 		} // vertical pass
 		a = int32(**(**int16_t)(__ccgo_up(in))) + int32(**(**int16_t)(__ccgo_up(in + 8*2)))
 		b = int32(**(**int16_t)(__ccgo_up(in))) - int32(**(**int16_t)(__ccgo_up(in + 8*2)))
 		c = int32(**(**int16_t)(__ccgo_up(in + 4*2)))*int32(WEBP_TRANSFORM_AC3_C2)>>int32(16) - (int32(**(**int16_t)(__ccgo_up(in + 12*2)))*int32(WEBP_TRANSFORM_AC3_C1)>>int32(16) + int32(**(**int16_t)(__ccgo_up(in + 12*2))))
 		d = int32(**(**int16_t)(__ccgo_up(in + 4*2)))*int32(WEBP_TRANSFORM_AC3_C1)>>int32(16) + int32(**(**int16_t)(__ccgo_up(in + 4*2))) + int32(**(**int16_t)(__ccgo_up(in + 12*2)))*int32(WEBP_TRANSFORM_AC3_C2)>>int32(16)
 		**(**int32)(__ccgo_up(tmp)) = a + d
 		**(**int32)(__ccgo_up(tmp + 1*4)) = b + c
 		**(**int32)(__ccgo_up(tmp + 2*4)) = b - c
 		**(**int32)(__ccgo_up(tmp + 3*4)) = a - d
 		tmp = tmp + uintptr(4)*4
 		in += 2
 		goto _1
 	_1:
 		;
 		i = i + 1
 	}
 	tmp = bp
 	i = 0
 	for {
 		if !(i < int32(4)) {
 			break
 		} // horizontal pass
 		dc = **(**int32)(__ccgo_up(tmp)) + int32(4)
 		a1 = dc + **(**int32)(__ccgo_up(tmp + 8*4))
 		b1 = dc - **(**int32)(__ccgo_up(tmp + 8*4))
 		c1 = **(**int32)(__ccgo_up(tmp + 4*4))*int32(WEBP_TRANSFORM_AC3_C2)>>int32(16) - (**(**int32)(__ccgo_up(tmp + 12*4))*int32(WEBP_TRANSFORM_AC3_C1)>>int32(16) + **(**int32)(__ccgo_up(tmp + 12*4)))
 		d1 = **(**int32)(__ccgo_up(tmp + 4*4))*int32(WEBP_TRANSFORM_AC3_C1)>>int32(16) + **(**int32)(__ccgo_up(tmp + 4*4)) + **(**int32)(__ccgo_up(tmp + 12*4))*int32(WEBP_TRANSFORM_AC3_C2)>>int32(16)
 		**(**uint8_t)(__ccgo_up(dst + uintptr(0+i*int32(BPS)))) = clip_8b2(tls, libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(ref + uintptr(0+i*int32(BPS)))))+(a1+d1)>>int32(3))
 		**(**uint8_t)(__ccgo_up(dst + uintptr(int32(1)+i*int32(BPS)))) = clip_8b2(tls, libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(ref + uintptr(int32(1)+i*int32(BPS)))))+(b1+c1)>>int32(3))
 		**(**uint8_t)(__ccgo_up(dst + uintptr(int32(2)+i*int32(BPS)))) = clip_8b2(tls, libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(ref + uintptr(int32(2)+i*int32(BPS)))))+(b1-c1)>>int32(3))
 		**(**uint8_t)(__ccgo_up(dst + uintptr(int32(3)+i*int32(BPS)))) = clip_8b2(tls, libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(ref + uintptr(int32(3)+i*int32(BPS)))))+(a1-d1)>>int32(3))
 		tmp += 4
 		goto _2
 	_2:
 		;
 		i = i + 1
 	}
 }
 
 func ITransform_C(tls *libc.TLS, ref uintptr, in uintptr, dst uintptr, do_two int32) {
 	ITransformOne(tls, ref, in, dst)
 	if do_two != 0 {
 		ITransformOne(tls, ref+uintptr(4), in+uintptr(16)*2, dst+uintptr(4))
 	}
 }
 
 func FTransform_C(tls *libc.TLS, src uintptr, ref uintptr, out uintptr) {
 	var a0, a01, a1, a11, a2, a21, a3, a31, d0, d1, d2, d3, i int32
 	var tmp [16]int32
 	_, _, _, _, _, _, _, _, _, _, _, _, _, _ = a0, a01, a1, a11, a2, a21, a3, a31, d0, d1, d2, d3, i, tmp
 	i = 0
 	for {
 		if !(i < int32(4)) {
 			break
 		}
 		d0 = libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(src))) - libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(ref))) // 9bit dynamic range ([-255,255])
 		d1 = libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(src + 1))) - libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(ref + 1)))
 		d2 = libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(src + 2))) - libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(ref + 2)))
 		d3 = libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(src + 3))) - libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(ref + 3)))
 		a0 = d0 + d3 // 10b                      [-510,510]
 		a1 = d1 + d2
 		a2 = d1 - d2
 		a3 = d0 - d3
 		tmp[0+i*int32(4)] = (a0 + a1) * int32(8)                                               // 14b                      [-8160,8160]
 		tmp[int32(1)+i*int32(4)] = (a2*int32(2217) + a3*int32(5352) + int32(1812)) >> int32(9) // [-7536,7542]
 		tmp[int32(2)+i*int32(4)] = (a0 - a1) * int32(8)
 		tmp[int32(3)+i*int32(4)] = (a3*int32(2217) - a2*int32(5352) + int32(937)) >> int32(9)
 		goto _1
 	_1:
 		;
 		i = i + 1
 		src = src + uintptr(BPS)
 		ref = ref + uintptr(BPS)
 	}
 	i = 0
 	for {
 		if !(i < int32(4)) {
 			break
 		}
 		a01 = tmp[0+i] + tmp[int32(12)+i] // 15b
 		a11 = tmp[int32(4)+i] + tmp[int32(8)+i]
 		a21 = tmp[int32(4)+i] - tmp[int32(8)+i]
 		a31 = tmp[0+i] - tmp[int32(12)+i]
 		**(**int16_t)(__ccgo_up(out + uintptr(0+i)*2)) = int16((a01 + a11 + int32(7)) >> int32(4)) // 12b
 		**(**int16_t)(__ccgo_up(out + uintptr(int32(4)+i)*2)) = int16((a21*int32(2217)+a31*int32(5352)+int32(12000))>>int32(16) + libc.BoolInt32(a31 != 0))
 		**(**int16_t)(__ccgo_up(out + uintptr(int32(8)+i)*2)) = int16((a01 - a11 + int32(7)) >> int32(4))
 		**(**int16_t)(__ccgo_up(out + uintptr(int32(12)+i)*2)) = int16((a31*libc.Int32FromInt32(2217) - a21*libc.Int32FromInt32(5352) + libc.Int32FromInt32(51000)) >> libc.Int32FromInt32(16))
 		goto _2
 	_2:
 		;
 		i = i + 1
 	}
 }
 
 func FTransform2_C(tls *libc.TLS, src uintptr, ref uintptr, out uintptr) {
 	(*(*func(*libc.TLS, uintptr, uintptr, uintptr))(unsafe.Pointer(&struct{ uintptr }{VP8FTransform})))(tls, src, ref, out)
 	(*(*func(*libc.TLS, uintptr, uintptr, uintptr))(unsafe.Pointer(&struct{ uintptr }{VP8FTransform})))(tls, src+uintptr(4), ref+uintptr(4), out+uintptr(16)*2)
 }
 
 func FTransformWHT_C(tls *libc.TLS, in uintptr, out uintptr) {
 	var a0, a01, a1, a11, a2, a21, a3, a31, b0, b1, b2, b3, i int32
 	var tmp [16]int32_t
 	_, _, _, _, _, _, _, _, _, _, _, _, _, _ = a0, a01, a1, a11, a2, a21, a3, a31, b0, b1, b2, b3, i, tmp
 	i = 0
 	for {
 		if !(i < int32(4)) {
 			break
 		}
 		a0 = int32(**(**int16_t)(__ccgo_up(in + uintptr(libc.Int32FromInt32(0)*libc.Int32FromInt32(16))*2))) + int32(**(**int16_t)(__ccgo_up(in + uintptr(libc.Int32FromInt32(2)*libc.Int32FromInt32(16))*2))) // 13b
 		a1 = int32(**(**int16_t)(__ccgo_up(in + uintptr(libc.Int32FromInt32(1)*libc.Int32FromInt32(16))*2))) + int32(**(**int16_t)(__ccgo_up(in + uintptr(libc.Int32FromInt32(3)*libc.Int32FromInt32(16))*2)))
 		a2 = int32(**(**int16_t)(__ccgo_up(in + uintptr(libc.Int32FromInt32(1)*libc.Int32FromInt32(16))*2))) - int32(**(**int16_t)(__ccgo_up(in + uintptr(libc.Int32FromInt32(3)*libc.Int32FromInt32(16))*2)))
 		a3 = int32(**(**int16_t)(__ccgo_up(in + uintptr(libc.Int32FromInt32(0)*libc.Int32FromInt32(16))*2))) - int32(**(**int16_t)(__ccgo_up(in + uintptr(libc.Int32FromInt32(2)*libc.Int32FromInt32(16))*2)))
 		tmp[0+i*int32(4)] = a0 + a1 // 14b
 		tmp[int32(1)+i*int32(4)] = a3 + a2
 		tmp[int32(2)+i*int32(4)] = a3 - a2
 		tmp[int32(3)+i*int32(4)] = a0 - a1
 		goto _1
 	_1:
 		;
 		i = i + 1
 		in = in + uintptr(64)*2
 	}
 	i = 0
 	for {
 		if !(i < int32(4)) {
 			break
 		}
 		a01 = tmp[0+i] + tmp[int32(8)+i] // 15b
 		a11 = tmp[int32(4)+i] + tmp[int32(12)+i]
 		a21 = tmp[int32(4)+i] - tmp[int32(12)+i]
 		a31 = tmp[0+i] - tmp[int32(8)+i]
 		b0 = a01 + a11 // 16b
 		b1 = a31 + a21
 		b2 = a31 - a21
 		b3 = a01 - a11
 		**(**int16_t)(__ccgo_up(out + uintptr(0+i)*2)) = int16(b0 >> int32(1)) // 15b
 		**(**int16_t)(__ccgo_up(out + uintptr(int32(4)+i)*2)) = int16(b1 >> int32(1))
 		**(**int16_t)(__ccgo_up(out + uintptr(int32(8)+i)*2)) = int16(b2 >> int32(1))
 		**(**int16_t)(__ccgo_up(out + uintptr(int32(12)+i)*2)) = int16(b3 >> int32(1))
 		goto _2
 	_2:
 		;
 		i = i + 1
 	}
 }
 
 //------------------------------------------------------------------------------
 // Intra predictions
 
 func Fill(tls *libc.TLS, dst uintptr, value int32, size int32) {
 	var j int32
 	_ = j
 	j = 0
 	for {
 		if !(j < size) {
 			break
 		}
 		libc.X__builtin___memset_chk(tls, dst+uintptr(j*int32(BPS)), value, libc.Uint64FromInt32(size), ^__predefined_size_t(0))
 		goto _1
 	_1:
 		;
 		j = j + 1
 	}
 }
 
 func VerticalPred(tls *libc.TLS, dst uintptr, top uintptr, size int32) {
 	var j int32
 	_ = j
 	if top != libc.UintptrFromInt32(0) {
 		j = 0
 		for {
 			if !(j < size) {
 				break
 			}
 			libc.X__builtin___memcpy_chk(tls, dst+uintptr(j*int32(BPS)), top, libc.Uint64FromInt32(size), ^__predefined_size_t(0))
 			goto _1
 		_1:
 			;
 			j = j + 1
 		}
 	} else {
 		Fill(tls, dst, int32(127), size)
 	}
 }
 
 func HorizontalPred(tls *libc.TLS, dst uintptr, left uintptr, size int32) {
 	var j int32
 	_ = j
 	if left != libc.UintptrFromInt32(0) {
 		j = 0
 		for {
 			if !(j < size) {
 				break
 			}
 			libc.X__builtin___memset_chk(tls, dst+uintptr(j*int32(BPS)), libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(left + uintptr(j)))), libc.Uint64FromInt32(size), ^__predefined_size_t(0))
 			goto _1
 		_1:
 			;
 			j = j + 1
 		}
 	} else {
 		Fill(tls, dst, int32(129), size)
 	}
 }
 
 func TrueMotion1(tls *libc.TLS, dst uintptr, left uintptr, top uintptr, size int32) {
 	var clip, clip_table uintptr
 	var x, y int32
 	_, _, _, _ = clip, clip_table, x, y
 	if left != libc.UintptrFromInt32(0) {
 		if top != libc.UintptrFromInt32(0) {
 			clip = uintptr(unsafe.Pointer(&clip12)) + uintptr(255) - uintptr(**(**uint8_t)(__ccgo_up(left + uintptr(-libc.Int32FromInt32(1)))))
 			y = 0
 			for {
 				if !(y < size) {
 					break
 				}
 				clip_table = clip + uintptr(**(**uint8_t)(__ccgo_up(left + uintptr(y))))
 				x = 0
 				for {
 					if !(x < size) {
 						break
 					}
 					**(**uint8_t)(__ccgo_up(dst + uintptr(x))) = **(**uint8_t)(__ccgo_up(clip_table + uintptr(**(**uint8_t)(__ccgo_up(top + uintptr(x))))))
 					goto _2
 				_2:
 					;
 					x = x + 1
 				}
 				dst = dst + uintptr(BPS)
 				goto _1
 			_1:
 				;
 				y = y + 1
 			}
 		} else {
 			HorizontalPred(tls, dst, left, size)
 		}
 	} else {
 		// true motion without left samples (hence: with default 129 value)
 		// is equivalent to VE prediction where you just copy the top samples.
 		// Note that if top samples are not available, the default value is
 		// then 129, and not 127 as in the VerticalPred case.
 		if top != libc.UintptrFromInt32(0) {
 			VerticalPred(tls, dst, top, size)
 		} else {
 			Fill(tls, dst, int32(129), size)
 		}
 	}
 }
 
 func DCMode(tls *libc.TLS, dst uintptr, left uintptr, top uintptr, size int32, round int32, shift int32) {
 	var DC, j int32
 	_, _ = DC, j
 	DC = 0
 	if top != libc.UintptrFromInt32(0) {
 		j = 0
 		for {
 			if !(j < size) {
 				break
 			}
 			DC = DC + libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(top + uintptr(j))))
 			goto _1
 		_1:
 			;
 			j = j + 1
 		}
 		if left != libc.UintptrFromInt32(0) { // top and left present
 			j = 0
 			for {
 				if !(j < size) {
 					break
 				}
 				DC = DC + libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(left + uintptr(j))))
 				goto _2
 			_2:
 				;
 				j = j + 1
 			}
 		} else { // top, but no left
 			DC = DC + DC
 		}
 		DC = (DC + round) >> shift
 	} else {
 		if left != libc.UintptrFromInt32(0) { // left but no top
 			j = 0
 			for {
 				if !(j < size) {
 					break
 				}
 				DC = DC + libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(left + uintptr(j))))
 				goto _3
 			_3:
 				;
 				j = j + 1
 			}
 			DC = DC + DC
 			DC = (DC + round) >> shift
 		} else { // no top, no left, nothing.
 			DC = int32(0x80)
 		}
 	}
 	Fill(tls, dst, DC, size)
 }
 
 //------------------------------------------------------------------------------
 // Chroma 8x8 prediction (paragraph 12.2)
 
 func IntraChromaPreds_C(tls *libc.TLS, dst uintptr, left uintptr, top uintptr) {
 	// U block
 	DCMode(tls, uintptr(libc.Int32FromInt32(2)*libc.Int32FromInt32(16)*libc.Int32FromInt32(BPS))+dst, left, top, int32(8), int32(8), int32(4))
 	VerticalPred(tls, uintptr(libc.Int32FromInt32(2)*libc.Int32FromInt32(16)*libc.Int32FromInt32(BPS)+libc.Int32FromInt32(8)*libc.Int32FromInt32(BPS))+dst, top, int32(8))
 	HorizontalPred(tls, uintptr(libc.Int32FromInt32(2)*libc.Int32FromInt32(16)*libc.Int32FromInt32(BPS)+libc.Int32FromInt32(8)*libc.Int32FromInt32(BPS)+libc.Int32FromInt32(1)*libc.Int32FromInt32(16))+dst, left, int32(8))
 	TrueMotion1(tls, uintptr(libc.Int32FromInt32(2)*libc.Int32FromInt32(16)*libc.Int32FromInt32(BPS)+libc.Int32FromInt32(1)*libc.Int32FromInt32(16))+dst, left, top, int32(8))
 	// V block
 	dst = dst + uintptr(8)
 	if top != libc.UintptrFromInt32(0) {
 		top = top + uintptr(8)
 	}
 	if left != libc.UintptrFromInt32(0) {
 		left = left + uintptr(16)
 	}
 	DCMode(tls, uintptr(libc.Int32FromInt32(2)*libc.Int32FromInt32(16)*libc.Int32FromInt32(BPS))+dst, left, top, int32(8), int32(8), int32(4))
 	VerticalPred(tls, uintptr(libc.Int32FromInt32(2)*libc.Int32FromInt32(16)*libc.Int32FromInt32(BPS)+libc.Int32FromInt32(8)*libc.Int32FromInt32(BPS))+dst, top, int32(8))
 	HorizontalPred(tls, uintptr(libc.Int32FromInt32(2)*libc.Int32FromInt32(16)*libc.Int32FromInt32(BPS)+libc.Int32FromInt32(8)*libc.Int32FromInt32(BPS)+libc.Int32FromInt32(1)*libc.Int32FromInt32(16))+dst, left, int32(8))
 	TrueMotion1(tls, uintptr(libc.Int32FromInt32(2)*libc.Int32FromInt32(16)*libc.Int32FromInt32(BPS)+libc.Int32FromInt32(1)*libc.Int32FromInt32(16))+dst, left, top, int32(8))
 }
 
 //------------------------------------------------------------------------------
 // luma 16x16 prediction (paragraph 12.3)
 
 func Intra16Preds_C(tls *libc.TLS, dst uintptr, left uintptr, top uintptr) {
 	DCMode(tls, uintptr(libc.Int32FromInt32(0)*libc.Int32FromInt32(16)*libc.Int32FromInt32(BPS))+dst, left, top, int32(16), int32(16), int32(5))
 	VerticalPred(tls, uintptr(libc.Int32FromInt32(1)*libc.Int32FromInt32(16)*libc.Int32FromInt32(BPS))+dst, top, int32(16))
 	HorizontalPred(tls, uintptr(libc.Int32FromInt32(1)*libc.Int32FromInt32(16)*libc.Int32FromInt32(BPS)+libc.Int32FromInt32(16))+dst, left, int32(16))
 	TrueMotion1(tls, uintptr(libc.Int32FromInt32(0)*libc.Int32FromInt32(16)*libc.Int32FromInt32(BPS)+libc.Int32FromInt32(16))+dst, left, top, int32(16))
 }
 
 //------------------------------------------------------------------------------
 // luma 4x4 prediction
 
 // C documentation
 //
 //	// vertical
 func VE4(tls *libc.TLS, dst uintptr, top uintptr) {
 	bp := tls.Alloc(16)
 	defer tls.Free(16)
 	var i int32
 	var _ /* vals at bp+0 */ [4]uint8_t
 	_ = i
 	**(**[4]uint8_t)(__ccgo_up(bp)) = [4]uint8_t{
 		0: libc.Uint8FromInt32((libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(top + uintptr(-libc.Int32FromInt32(1))))) + libc.Int32FromInt32(2)*libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(top))) + libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(top + 1))) + libc.Int32FromInt32(2)) >> libc.Int32FromInt32(2)),
 		1: libc.Uint8FromInt32((libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(top))) + libc.Int32FromInt32(2)*libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(top + 1))) + libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(top + 2))) + libc.Int32FromInt32(2)) >> libc.Int32FromInt32(2)),
 		2: libc.Uint8FromInt32((libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(top + 1))) + libc.Int32FromInt32(2)*libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(top + 2))) + libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(top + 3))) + libc.Int32FromInt32(2)) >> libc.Int32FromInt32(2)),
 		3: libc.Uint8FromInt32((libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(top + 2))) + libc.Int32FromInt32(2)*libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(top + 3))) + libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(top + 4))) + libc.Int32FromInt32(2)) >> libc.Int32FromInt32(2)),
 	}
 	i = 0
 	for {
 		if !(i < int32(4)) {
 			break
 		}
 		libc.X__builtin___memcpy_chk(tls, dst+uintptr(i*int32(BPS)), bp, uint64(4), ^__predefined_size_t(0))
 		goto _1
 	_1:
 		;
 		i = i + 1
 	}
 }
 
 // C documentation
 //
 //	// horizontal
 func HE4(tls *libc.TLS, dst uintptr, top uintptr) {
 	bp := tls.Alloc(16)
 	defer tls.Free(16)
 	var I, J, K, L, X int32
 	var v1 uintptr
 	var v2 uint32_t
 	_, _, _, _, _, _, _ = I, J, K, L, X, v1, v2
 	X = libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(top + uintptr(-libc.Int32FromInt32(1)))))
 	I = libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(top + uintptr(-libc.Int32FromInt32(2)))))
 	J = libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(top + uintptr(-libc.Int32FromInt32(3)))))
 	K = libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(top + uintptr(-libc.Int32FromInt32(4)))))
 	L = libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(top + uintptr(-libc.Int32FromInt32(5)))))
 	v1 = dst + uintptr(libc.Int32FromInt32(0)*libc.Int32FromInt32(BPS))
 	v2 = uint32(0x01010101) * uint32(libc.Uint8FromInt32((X+libc.Int32FromInt32(2)*I+J+libc.Int32FromInt32(2))>>libc.Int32FromInt32(2)))
 	*(*uint32_t)(unsafe.Pointer(bp)) = v2
 	libc.X__builtin___memcpy_chk(tls, v1, bp, uint64(4), ^__predefined_size_t(0))
 	v1 = dst + uintptr(libc.Int32FromInt32(1)*libc.Int32FromInt32(BPS))
 	v2 = uint32(0x01010101) * uint32(libc.Uint8FromInt32((I+libc.Int32FromInt32(2)*J+K+libc.Int32FromInt32(2))>>libc.Int32FromInt32(2)))
 	*(*uint32_t)(unsafe.Pointer(bp)) = v2
 	libc.X__builtin___memcpy_chk(tls, v1, bp, uint64(4), ^__predefined_size_t(0))
 	v1 = dst + uintptr(libc.Int32FromInt32(2)*libc.Int32FromInt32(BPS))
 	v2 = uint32(0x01010101) * uint32(libc.Uint8FromInt32((J+libc.Int32FromInt32(2)*K+L+libc.Int32FromInt32(2))>>libc.Int32FromInt32(2)))
 	*(*uint32_t)(unsafe.Pointer(bp)) = v2
 	libc.X__builtin___memcpy_chk(tls, v1, bp, uint64(4), ^__predefined_size_t(0))
 	v1 = dst + uintptr(libc.Int32FromInt32(3)*libc.Int32FromInt32(BPS))
 	v2 = uint32(0x01010101) * uint32(libc.Uint8FromInt32((K+libc.Int32FromInt32(2)*L+L+libc.Int32FromInt32(2))>>libc.Int32FromInt32(2)))
 	*(*uint32_t)(unsafe.Pointer(bp)) = v2
 	libc.X__builtin___memcpy_chk(tls, v1, bp, uint64(4), ^__predefined_size_t(0))
 }
 
 func DC4(tls *libc.TLS, dst uintptr, top uintptr) {
 	var dc uint32_t
 	var i int32
 	_, _ = dc, i
 	dc = uint32(4)
 	i = 0
 	for {
 		if !(i < int32(4)) {
 			break
 		}
 		dc = dc + libc.Uint32FromInt32(libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(top + uintptr(i))))+libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(top + uintptr(-int32(5)+i)))))
 		goto _1
 	_1:
 		;
 		i = i + 1
 	}
 	Fill(tls, dst, libc.Int32FromUint32(dc>>int32(3)), int32(4))
 }
 
 func RD4(tls *libc.TLS, dst uintptr, top uintptr) {
 	var A, B, C, D, I, J, K, L, X int32
 	var v1, v2, v3 uint8_t
 	_, _, _, _, _, _, _, _, _, _, _, _ = A, B, C, D, I, J, K, L, X, v1, v2, v3
 	X = libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(top + uintptr(-libc.Int32FromInt32(1)))))
 	I = libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(top + uintptr(-libc.Int32FromInt32(2)))))
 	J = libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(top + uintptr(-libc.Int32FromInt32(3)))))
 	K = libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(top + uintptr(-libc.Int32FromInt32(4)))))
 	L = libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(top + uintptr(-libc.Int32FromInt32(5)))))
 	A = libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(top)))
 	B = libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(top + 1)))
 	C = libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(top + 2)))
 	D = libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(top + 3)))
 	**(**uint8_t)(__ccgo_up(dst + uintptr(libc.Int32FromInt32(0)+libc.Int32FromInt32(3)*libc.Int32FromInt32(BPS)))) = libc.Uint8FromInt32((J + libc.Int32FromInt32(2)*K + L + libc.Int32FromInt32(2)) >> libc.Int32FromInt32(2))
 	v1 = libc.Uint8FromInt32((I + libc.Int32FromInt32(2)*J + K + libc.Int32FromInt32(2)) >> libc.Int32FromInt32(2))
 	**(**uint8_t)(__ccgo_up(dst + uintptr(libc.Int32FromInt32(1)+libc.Int32FromInt32(3)*libc.Int32FromInt32(BPS)))) = v1
 	**(**uint8_t)(__ccgo_up(dst + uintptr(libc.Int32FromInt32(0)+libc.Int32FromInt32(2)*libc.Int32FromInt32(BPS)))) = v1
 	v2 = libc.Uint8FromInt32((X + libc.Int32FromInt32(2)*I + J + libc.Int32FromInt32(2)) >> libc.Int32FromInt32(2))
 	**(**uint8_t)(__ccgo_up(dst + uintptr(libc.Int32FromInt32(2)+libc.Int32FromInt32(3)*libc.Int32FromInt32(BPS)))) = v2
 	v1 = v2
 	**(**uint8_t)(__ccgo_up(dst + uintptr(libc.Int32FromInt32(1)+libc.Int32FromInt32(2)*libc.Int32FromInt32(BPS)))) = v1
 	**(**uint8_t)(__ccgo_up(dst + uintptr(libc.Int32FromInt32(0)+libc.Int32FromInt32(1)*libc.Int32FromInt32(BPS)))) = v1
 	v3 = libc.Uint8FromInt32((A + libc.Int32FromInt32(2)*X + I + libc.Int32FromInt32(2)) >> libc.Int32FromInt32(2))
 	**(**uint8_t)(__ccgo_up(dst + uintptr(libc.Int32FromInt32(3)+libc.Int32FromInt32(3)*libc.Int32FromInt32(BPS)))) = v3
 	v2 = v3
 	**(**uint8_t)(__ccgo_up(dst + uintptr(libc.Int32FromInt32(2)+libc.Int32FromInt32(2)*libc.Int32FromInt32(BPS)))) = v2
 	v1 = v2
 	**(**uint8_t)(__ccgo_up(dst + uintptr(libc.Int32FromInt32(1)+libc.Int32FromInt32(1)*libc.Int32FromInt32(BPS)))) = v1
 	**(**uint8_t)(__ccgo_up(dst + uintptr(libc.Int32FromInt32(0)+libc.Int32FromInt32(0)*libc.Int32FromInt32(BPS)))) = v1
 	v2 = libc.Uint8FromInt32((B + libc.Int32FromInt32(2)*A + X + libc.Int32FromInt32(2)) >> libc.Int32FromInt32(2))
 	**(**uint8_t)(__ccgo_up(dst + uintptr(libc.Int32FromInt32(3)+libc.Int32FromInt32(2)*libc.Int32FromInt32(BPS)))) = v2
 	v1 = v2
 	**(**uint8_t)(__ccgo_up(dst + uintptr(libc.Int32FromInt32(2)+libc.Int32FromInt32(1)*libc.Int32FromInt32(BPS)))) = v1
 	**(**uint8_t)(__ccgo_up(dst + uintptr(libc.Int32FromInt32(1)+libc.Int32FromInt32(0)*libc.Int32FromInt32(BPS)))) = v1
 	v1 = libc.Uint8FromInt32((C + libc.Int32FromInt32(2)*B + A + libc.Int32FromInt32(2)) >> libc.Int32FromInt32(2))
 	**(**uint8_t)(__ccgo_up(dst + uintptr(libc.Int32FromInt32(3)+libc.Int32FromInt32(1)*libc.Int32FromInt32(BPS)))) = v1
 	**(**uint8_t)(__ccgo_up(dst + uintptr(libc.Int32FromInt32(2)+libc.Int32FromInt32(0)*libc.Int32FromInt32(BPS)))) = v1
 	**(**uint8_t)(__ccgo_up(dst + uintptr(libc.Int32FromInt32(3)+libc.Int32FromInt32(0)*libc.Int32FromInt32(BPS)))) = libc.Uint8FromInt32((D + libc.Int32FromInt32(2)*C + B + libc.Int32FromInt32(2)) >> libc.Int32FromInt32(2))
 }
 
 func LD4(tls *libc.TLS, dst uintptr, top uintptr) {
 	var A, B, C, D, E, F, G, H int32
 	var v1, v2, v3 uint8_t
 	_, _, _, _, _, _, _, _, _, _, _ = A, B, C, D, E, F, G, H, v1, v2, v3
 	A = libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(top)))
 	B = libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(top + 1)))
 	C = libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(top + 2)))
 	D = libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(top + 3)))
 	E = libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(top + 4)))
 	F = libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(top + 5)))
 	G = libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(top + 6)))
 	H = libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(top + 7)))
 	**(**uint8_t)(__ccgo_up(dst + uintptr(libc.Int32FromInt32(0)+libc.Int32FromInt32(0)*libc.Int32FromInt32(BPS)))) = libc.Uint8FromInt32((A + libc.Int32FromInt32(2)*B + C + libc.Int32FromInt32(2)) >> libc.Int32FromInt32(2))
 	v1 = libc.Uint8FromInt32((B + libc.Int32FromInt32(2)*C + D + libc.Int32FromInt32(2)) >> libc.Int32FromInt32(2))
 	**(**uint8_t)(__ccgo_up(dst + uintptr(libc.Int32FromInt32(0)+libc.Int32FromInt32(1)*libc.Int32FromInt32(BPS)))) = v1
 	**(**uint8_t)(__ccgo_up(dst + uintptr(libc.Int32FromInt32(1)+libc.Int32FromInt32(0)*libc.Int32FromInt32(BPS)))) = v1
 	v2 = libc.Uint8FromInt32((C + libc.Int32FromInt32(2)*D + E + libc.Int32FromInt32(2)) >> libc.Int32FromInt32(2))
 	**(**uint8_t)(__ccgo_up(dst + uintptr(libc.Int32FromInt32(0)+libc.Int32FromInt32(2)*libc.Int32FromInt32(BPS)))) = v2
 	v1 = v2
 	**(**uint8_t)(__ccgo_up(dst + uintptr(libc.Int32FromInt32(1)+libc.Int32FromInt32(1)*libc.Int32FromInt32(BPS)))) = v1
 	**(**uint8_t)(__ccgo_up(dst + uintptr(libc.Int32FromInt32(2)+libc.Int32FromInt32(0)*libc.Int32FromInt32(BPS)))) = v1
 	v3 = libc.Uint8FromInt32((D + libc.Int32FromInt32(2)*E + F + libc.Int32FromInt32(2)) >> libc.Int32FromInt32(2))
 	**(**uint8_t)(__ccgo_up(dst + uintptr(libc.Int32FromInt32(0)+libc.Int32FromInt32(3)*libc.Int32FromInt32(BPS)))) = v3
 	v2 = v3
 	**(**uint8_t)(__ccgo_up(dst + uintptr(libc.Int32FromInt32(1)+libc.Int32FromInt32(2)*libc.Int32FromInt32(BPS)))) = v2
 	v1 = v2
 	**(**uint8_t)(__ccgo_up(dst + uintptr(libc.Int32FromInt32(2)+libc.Int32FromInt32(1)*libc.Int32FromInt32(BPS)))) = v1
 	**(**uint8_t)(__ccgo_up(dst + uintptr(libc.Int32FromInt32(3)+libc.Int32FromInt32(0)*libc.Int32FromInt32(BPS)))) = v1
 	v2 = libc.Uint8FromInt32((E + libc.Int32FromInt32(2)*F + G + libc.Int32FromInt32(2)) >> libc.Int32FromInt32(2))
 	**(**uint8_t)(__ccgo_up(dst + uintptr(libc.Int32FromInt32(1)+libc.Int32FromInt32(3)*libc.Int32FromInt32(BPS)))) = v2
 	v1 = v2
 	**(**uint8_t)(__ccgo_up(dst + uintptr(libc.Int32FromInt32(2)+libc.Int32FromInt32(2)*libc.Int32FromInt32(BPS)))) = v1
 	**(**uint8_t)(__ccgo_up(dst + uintptr(libc.Int32FromInt32(3)+libc.Int32FromInt32(1)*libc.Int32FromInt32(BPS)))) = v1
 	v1 = libc.Uint8FromInt32((F + libc.Int32FromInt32(2)*G + H + libc.Int32FromInt32(2)) >> libc.Int32FromInt32(2))
 	**(**uint8_t)(__ccgo_up(dst + uintptr(libc.Int32FromInt32(2)+libc.Int32FromInt32(3)*libc.Int32FromInt32(BPS)))) = v1
 	**(**uint8_t)(__ccgo_up(dst + uintptr(libc.Int32FromInt32(3)+libc.Int32FromInt32(2)*libc.Int32FromInt32(BPS)))) = v1
 	**(**uint8_t)(__ccgo_up(dst + uintptr(libc.Int32FromInt32(3)+libc.Int32FromInt32(3)*libc.Int32FromInt32(BPS)))) = libc.Uint8FromInt32((G + libc.Int32FromInt32(2)*H + H + libc.Int32FromInt32(2)) >> libc.Int32FromInt32(2))
 }
 
 func VR4(tls *libc.TLS, dst uintptr, top uintptr) {
 	var A, B, C, D, I, J, K, X int32
 	var v1 uint8_t
 	_, _, _, _, _, _, _, _, _ = A, B, C, D, I, J, K, X, v1
 	X = libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(top + uintptr(-libc.Int32FromInt32(1)))))
 	I = libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(top + uintptr(-libc.Int32FromInt32(2)))))
 	J = libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(top + uintptr(-libc.Int32FromInt32(3)))))
 	K = libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(top + uintptr(-libc.Int32FromInt32(4)))))
 	A = libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(top)))
 	B = libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(top + 1)))
 	C = libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(top + 2)))
 	D = libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(top + 3)))
 	v1 = libc.Uint8FromInt32((X + A + libc.Int32FromInt32(1)) >> libc.Int32FromInt32(1))
 	**(**uint8_t)(__ccgo_up(dst + uintptr(libc.Int32FromInt32(1)+libc.Int32FromInt32(2)*libc.Int32FromInt32(BPS)))) = v1
 	**(**uint8_t)(__ccgo_up(dst + uintptr(libc.Int32FromInt32(0)+libc.Int32FromInt32(0)*libc.Int32FromInt32(BPS)))) = v1
 	v1 = libc.Uint8FromInt32((A + B + libc.Int32FromInt32(1)) >> libc.Int32FromInt32(1))
 	**(**uint8_t)(__ccgo_up(dst + uintptr(libc.Int32FromInt32(2)+libc.Int32FromInt32(2)*libc.Int32FromInt32(BPS)))) = v1
 	**(**uint8_t)(__ccgo_up(dst + uintptr(libc.Int32FromInt32(1)+libc.Int32FromInt32(0)*libc.Int32FromInt32(BPS)))) = v1
 	v1 = libc.Uint8FromInt32((B + C + libc.Int32FromInt32(1)) >> libc.Int32FromInt32(1))
 	**(**uint8_t)(__ccgo_up(dst + uintptr(libc.Int32FromInt32(3)+libc.Int32FromInt32(2)*libc.Int32FromInt32(BPS)))) = v1
 	**(**uint8_t)(__ccgo_up(dst + uintptr(libc.Int32FromInt32(2)+libc.Int32FromInt32(0)*libc.Int32FromInt32(BPS)))) = v1
 	**(**uint8_t)(__ccgo_up(dst + uintptr(libc.Int32FromInt32(3)+libc.Int32FromInt32(0)*libc.Int32FromInt32(BPS)))) = libc.Uint8FromInt32((C + D + libc.Int32FromInt32(1)) >> libc.Int32FromInt32(1))
 	**(**uint8_t)(__ccgo_up(dst + uintptr(libc.Int32FromInt32(0)+libc.Int32FromInt32(3)*libc.Int32FromInt32(BPS)))) = libc.Uint8FromInt32((K + libc.Int32FromInt32(2)*J + I + libc.Int32FromInt32(2)) >> libc.Int32FromInt32(2))
 	**(**uint8_t)(__ccgo_up(dst + uintptr(libc.Int32FromInt32(0)+libc.Int32FromInt32(2)*libc.Int32FromInt32(BPS)))) = libc.Uint8FromInt32((J + libc.Int32FromInt32(2)*I + X + libc.Int32FromInt32(2)) >> libc.Int32FromInt32(2))
 	v1 = libc.Uint8FromInt32((I + libc.Int32FromInt32(2)*X + A + libc.Int32FromInt32(2)) >> libc.Int32FromInt32(2))
 	**(**uint8_t)(__ccgo_up(dst + uintptr(libc.Int32FromInt32(1)+libc.Int32FromInt32(3)*libc.Int32FromInt32(BPS)))) = v1
 	**(**uint8_t)(__ccgo_up(dst + uintptr(libc.Int32FromInt32(0)+libc.Int32FromInt32(1)*libc.Int32FromInt32(BPS)))) = v1
 	v1 = libc.Uint8FromInt32((X + libc.Int32FromInt32(2)*A + B + libc.Int32FromInt32(2)) >> libc.Int32FromInt32(2))
 	**(**uint8_t)(__ccgo_up(dst + uintptr(libc.Int32FromInt32(2)+libc.Int32FromInt32(3)*libc.Int32FromInt32(BPS)))) = v1
 	**(**uint8_t)(__ccgo_up(dst + uintptr(libc.Int32FromInt32(1)+libc.Int32FromInt32(1)*libc.Int32FromInt32(BPS)))) = v1
 	v1 = libc.Uint8FromInt32((A + libc.Int32FromInt32(2)*B + C + libc.Int32FromInt32(2)) >> libc.Int32FromInt32(2))
 	**(**uint8_t)(__ccgo_up(dst + uintptr(libc.Int32FromInt32(3)+libc.Int32FromInt32(3)*libc.Int32FromInt32(BPS)))) = v1
 	**(**uint8_t)(__ccgo_up(dst + uintptr(libc.Int32FromInt32(2)+libc.Int32FromInt32(1)*libc.Int32FromInt32(BPS)))) = v1
 	**(**uint8_t)(__ccgo_up(dst + uintptr(libc.Int32FromInt32(3)+libc.Int32FromInt32(1)*libc.Int32FromInt32(BPS)))) = libc.Uint8FromInt32((B + libc.Int32FromInt32(2)*C + D + libc.Int32FromInt32(2)) >> libc.Int32FromInt32(2))
 }
 
 func VL4(tls *libc.TLS, dst uintptr, top uintptr) {
 	var A, B, C, D, E, F, G, H int32
 	var v1 uint8_t
 	_, _, _, _, _, _, _, _, _ = A, B, C, D, E, F, G, H, v1
 	A = libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(top)))
 	B = libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(top + 1)))
 	C = libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(top + 2)))
 	D = libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(top + 3)))
 	E = libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(top + 4)))
 	F = libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(top + 5)))
 	G = libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(top + 6)))
 	H = libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(top + 7)))
 	**(**uint8_t)(__ccgo_up(dst + uintptr(libc.Int32FromInt32(0)+libc.Int32FromInt32(0)*libc.Int32FromInt32(BPS)))) = libc.Uint8FromInt32((A + B + libc.Int32FromInt32(1)) >> libc.Int32FromInt32(1))
 	v1 = libc.Uint8FromInt32((B + C + libc.Int32FromInt32(1)) >> libc.Int32FromInt32(1))
 	**(**uint8_t)(__ccgo_up(dst + uintptr(libc.Int32FromInt32(0)+libc.Int32FromInt32(2)*libc.Int32FromInt32(BPS)))) = v1
 	**(**uint8_t)(__ccgo_up(dst + uintptr(libc.Int32FromInt32(1)+libc.Int32FromInt32(0)*libc.Int32FromInt32(BPS)))) = v1
 	v1 = libc.Uint8FromInt32((C + D + libc.Int32FromInt32(1)) >> libc.Int32FromInt32(1))
 	**(**uint8_t)(__ccgo_up(dst + uintptr(libc.Int32FromInt32(1)+libc.Int32FromInt32(2)*libc.Int32FromInt32(BPS)))) = v1
 	**(**uint8_t)(__ccgo_up(dst + uintptr(libc.Int32FromInt32(2)+libc.Int32FromInt32(0)*libc.Int32FromInt32(BPS)))) = v1
 	v1 = libc.Uint8FromInt32((D + E + libc.Int32FromInt32(1)) >> libc.Int32FromInt32(1))
 	**(**uint8_t)(__ccgo_up(dst + uintptr(libc.Int32FromInt32(2)+libc.Int32FromInt32(2)*libc.Int32FromInt32(BPS)))) = v1
 	**(**uint8_t)(__ccgo_up(dst + uintptr(libc.Int32FromInt32(3)+libc.Int32FromInt32(0)*libc.Int32FromInt32(BPS)))) = v1
 	**(**uint8_t)(__ccgo_up(dst + uintptr(libc.Int32FromInt32(0)+libc.Int32FromInt32(1)*libc.Int32FromInt32(BPS)))) = libc.Uint8FromInt32((A + libc.Int32FromInt32(2)*B + C + libc.Int32FromInt32(2)) >> libc.Int32FromInt32(2))
 	v1 = libc.Uint8FromInt32((B + libc.Int32FromInt32(2)*C + D + libc.Int32FromInt32(2)) >> libc.Int32FromInt32(2))
 	**(**uint8_t)(__ccgo_up(dst + uintptr(libc.Int32FromInt32(0)+libc.Int32FromInt32(3)*libc.Int32FromInt32(BPS)))) = v1
 	**(**uint8_t)(__ccgo_up(dst + uintptr(libc.Int32FromInt32(1)+libc.Int32FromInt32(1)*libc.Int32FromInt32(BPS)))) = v1
 	v1 = libc.Uint8FromInt32((C + libc.Int32FromInt32(2)*D + E + libc.Int32FromInt32(2)) >> libc.Int32FromInt32(2))
 	**(**uint8_t)(__ccgo_up(dst + uintptr(libc.Int32FromInt32(1)+libc.Int32FromInt32(3)*libc.Int32FromInt32(BPS)))) = v1
 	**(**uint8_t)(__ccgo_up(dst + uintptr(libc.Int32FromInt32(2)+libc.Int32FromInt32(1)*libc.Int32FromInt32(BPS)))) = v1
 	v1 = libc.Uint8FromInt32((D + libc.Int32FromInt32(2)*E + F + libc.Int32FromInt32(2)) >> libc.Int32FromInt32(2))
 	**(**uint8_t)(__ccgo_up(dst + uintptr(libc.Int32FromInt32(2)+libc.Int32FromInt32(3)*libc.Int32FromInt32(BPS)))) = v1
 	**(**uint8_t)(__ccgo_up(dst + uintptr(libc.Int32FromInt32(3)+libc.Int32FromInt32(1)*libc.Int32FromInt32(BPS)))) = v1
 	**(**uint8_t)(__ccgo_up(dst + uintptr(libc.Int32FromInt32(3)+libc.Int32FromInt32(2)*libc.Int32FromInt32(BPS)))) = libc.Uint8FromInt32((E + libc.Int32FromInt32(2)*F + G + libc.Int32FromInt32(2)) >> libc.Int32FromInt32(2))
 	**(**uint8_t)(__ccgo_up(dst + uintptr(libc.Int32FromInt32(3)+libc.Int32FromInt32(3)*libc.Int32FromInt32(BPS)))) = libc.Uint8FromInt32((F + libc.Int32FromInt32(2)*G + H + libc.Int32FromInt32(2)) >> libc.Int32FromInt32(2))
 }
 
 func HU4(tls *libc.TLS, dst uintptr, top uintptr) {
 	var I, J, K, L int32
 	var v1, v2, v3, v4, v5 uint8_t
 	_, _, _, _, _, _, _, _, _ = I, J, K, L, v1, v2, v3, v4, v5
 	I = libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(top + uintptr(-libc.Int32FromInt32(2)))))
 	J = libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(top + uintptr(-libc.Int32FromInt32(3)))))
 	K = libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(top + uintptr(-libc.Int32FromInt32(4)))))
 	L = libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(top + uintptr(-libc.Int32FromInt32(5)))))
 	**(**uint8_t)(__ccgo_up(dst + uintptr(libc.Int32FromInt32(0)+libc.Int32FromInt32(0)*libc.Int32FromInt32(BPS)))) = libc.Uint8FromInt32((I + J + libc.Int32FromInt32(1)) >> libc.Int32FromInt32(1))
 	v1 = libc.Uint8FromInt32((J + K + libc.Int32FromInt32(1)) >> libc.Int32FromInt32(1))
 	**(**uint8_t)(__ccgo_up(dst + uintptr(libc.Int32FromInt32(0)+libc.Int32FromInt32(1)*libc.Int32FromInt32(BPS)))) = v1
 	**(**uint8_t)(__ccgo_up(dst + uintptr(libc.Int32FromInt32(2)+libc.Int32FromInt32(0)*libc.Int32FromInt32(BPS)))) = v1
 	v1 = libc.Uint8FromInt32((K + L + libc.Int32FromInt32(1)) >> libc.Int32FromInt32(1))
 	**(**uint8_t)(__ccgo_up(dst + uintptr(libc.Int32FromInt32(0)+libc.Int32FromInt32(2)*libc.Int32FromInt32(BPS)))) = v1
 	**(**uint8_t)(__ccgo_up(dst + uintptr(libc.Int32FromInt32(2)+libc.Int32FromInt32(1)*libc.Int32FromInt32(BPS)))) = v1
 	**(**uint8_t)(__ccgo_up(dst + uintptr(libc.Int32FromInt32(1)+libc.Int32FromInt32(0)*libc.Int32FromInt32(BPS)))) = libc.Uint8FromInt32((I + libc.Int32FromInt32(2)*J + K + libc.Int32FromInt32(2)) >> libc.Int32FromInt32(2))
 	v1 = libc.Uint8FromInt32((J + libc.Int32FromInt32(2)*K + L + libc.Int32FromInt32(2)) >> libc.Int32FromInt32(2))
 	**(**uint8_t)(__ccgo_up(dst + uintptr(libc.Int32FromInt32(1)+libc.Int32FromInt32(1)*libc.Int32FromInt32(BPS)))) = v1
 	**(**uint8_t)(__ccgo_up(dst + uintptr(libc.Int32FromInt32(3)+libc.Int32FromInt32(0)*libc.Int32FromInt32(BPS)))) = v1
 	v1 = libc.Uint8FromInt32((K + libc.Int32FromInt32(2)*L + L + libc.Int32FromInt32(2)) >> libc.Int32FromInt32(2))
 	**(**uint8_t)(__ccgo_up(dst + uintptr(libc.Int32FromInt32(1)+libc.Int32FromInt32(2)*libc.Int32FromInt32(BPS)))) = v1
 	**(**uint8_t)(__ccgo_up(dst + uintptr(libc.Int32FromInt32(3)+libc.Int32FromInt32(1)*libc.Int32FromInt32(BPS)))) = v1
 	v5 = libc.Uint8FromInt32(L)
 	**(**uint8_t)(__ccgo_up(dst + uintptr(libc.Int32FromInt32(3)+libc.Int32FromInt32(3)*libc.Int32FromInt32(BPS)))) = v5
 	v4 = v5
 	**(**uint8_t)(__ccgo_up(dst + uintptr(libc.Int32FromInt32(2)+libc.Int32FromInt32(3)*libc.Int32FromInt32(BPS)))) = v4
 	v3 = v4
 	**(**uint8_t)(__ccgo_up(dst + uintptr(libc.Int32FromInt32(1)+libc.Int32FromInt32(3)*libc.Int32FromInt32(BPS)))) = v3
 	v2 = v3
 	**(**uint8_t)(__ccgo_up(dst + uintptr(libc.Int32FromInt32(0)+libc.Int32FromInt32(3)*libc.Int32FromInt32(BPS)))) = v2
 	v1 = v2
 	**(**uint8_t)(__ccgo_up(dst + uintptr(libc.Int32FromInt32(2)+libc.Int32FromInt32(2)*libc.Int32FromInt32(BPS)))) = v1
 	**(**uint8_t)(__ccgo_up(dst + uintptr(libc.Int32FromInt32(3)+libc.Int32FromInt32(2)*libc.Int32FromInt32(BPS)))) = v1
 }
 
 func HD4(tls *libc.TLS, dst uintptr, top uintptr) {
 	var A, B, C, I, J, K, L, X int32
 	var v1 uint8_t
 	_, _, _, _, _, _, _, _, _ = A, B, C, I, J, K, L, X, v1
 	X = libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(top + uintptr(-libc.Int32FromInt32(1)))))
 	I = libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(top + uintptr(-libc.Int32FromInt32(2)))))
 	J = libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(top + uintptr(-libc.Int32FromInt32(3)))))
 	K = libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(top + uintptr(-libc.Int32FromInt32(4)))))
 	L = libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(top + uintptr(-libc.Int32FromInt32(5)))))
 	A = libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(top)))
 	B = libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(top + 1)))
 	C = libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(top + 2)))
 	v1 = libc.Uint8FromInt32((I + X + libc.Int32FromInt32(1)) >> libc.Int32FromInt32(1))
 	**(**uint8_t)(__ccgo_up(dst + uintptr(libc.Int32FromInt32(2)+libc.Int32FromInt32(1)*libc.Int32FromInt32(BPS)))) = v1
 	**(**uint8_t)(__ccgo_up(dst + uintptr(libc.Int32FromInt32(0)+libc.Int32FromInt32(0)*libc.Int32FromInt32(BPS)))) = v1
 	v1 = libc.Uint8FromInt32((J + I + libc.Int32FromInt32(1)) >> libc.Int32FromInt32(1))
 	**(**uint8_t)(__ccgo_up(dst + uintptr(libc.Int32FromInt32(2)+libc.Int32FromInt32(2)*libc.Int32FromInt32(BPS)))) = v1
 	**(**uint8_t)(__ccgo_up(dst + uintptr(libc.Int32FromInt32(0)+libc.Int32FromInt32(1)*libc.Int32FromInt32(BPS)))) = v1
 	v1 = libc.Uint8FromInt32((K + J + libc.Int32FromInt32(1)) >> libc.Int32FromInt32(1))
 	**(**uint8_t)(__ccgo_up(dst + uintptr(libc.Int32FromInt32(2)+libc.Int32FromInt32(3)*libc.Int32FromInt32(BPS)))) = v1
 	**(**uint8_t)(__ccgo_up(dst + uintptr(libc.Int32FromInt32(0)+libc.Int32FromInt32(2)*libc.Int32FromInt32(BPS)))) = v1
 	**(**uint8_t)(__ccgo_up(dst + uintptr(libc.Int32FromInt32(0)+libc.Int32FromInt32(3)*libc.Int32FromInt32(BPS)))) = libc.Uint8FromInt32((L + K + libc.Int32FromInt32(1)) >> libc.Int32FromInt32(1))
 	**(**uint8_t)(__ccgo_up(dst + uintptr(libc.Int32FromInt32(3)+libc.Int32FromInt32(0)*libc.Int32FromInt32(BPS)))) = libc.Uint8FromInt32((A + libc.Int32FromInt32(2)*B + C + libc.Int32FromInt32(2)) >> libc.Int32FromInt32(2))
 	**(**uint8_t)(__ccgo_up(dst + uintptr(libc.Int32FromInt32(2)+libc.Int32FromInt32(0)*libc.Int32FromInt32(BPS)))) = libc.Uint8FromInt32((X + libc.Int32FromInt32(2)*A + B + libc.Int32FromInt32(2)) >> libc.Int32FromInt32(2))
 	v1 = libc.Uint8FromInt32((I + libc.Int32FromInt32(2)*X + A + libc.Int32FromInt32(2)) >> libc.Int32FromInt32(2))
 	**(**uint8_t)(__ccgo_up(dst + uintptr(libc.Int32FromInt32(3)+libc.Int32FromInt32(1)*libc.Int32FromInt32(BPS)))) = v1
 	**(**uint8_t)(__ccgo_up(dst + uintptr(libc.Int32FromInt32(1)+libc.Int32FromInt32(0)*libc.Int32FromInt32(BPS)))) = v1
 	v1 = libc.Uint8FromInt32((J + libc.Int32FromInt32(2)*I + X + libc.Int32FromInt32(2)) >> libc.Int32FromInt32(2))
 	**(**uint8_t)(__ccgo_up(dst + uintptr(libc.Int32FromInt32(3)+libc.Int32FromInt32(2)*libc.Int32FromInt32(BPS)))) = v1
 	**(**uint8_t)(__ccgo_up(dst + uintptr(libc.Int32FromInt32(1)+libc.Int32FromInt32(1)*libc.Int32FromInt32(BPS)))) = v1
 	v1 = libc.Uint8FromInt32((K + libc.Int32FromInt32(2)*J + I + libc.Int32FromInt32(2)) >> libc.Int32FromInt32(2))
 	**(**uint8_t)(__ccgo_up(dst + uintptr(libc.Int32FromInt32(3)+libc.Int32FromInt32(3)*libc.Int32FromInt32(BPS)))) = v1
 	**(**uint8_t)(__ccgo_up(dst + uintptr(libc.Int32FromInt32(1)+libc.Int32FromInt32(2)*libc.Int32FromInt32(BPS)))) = v1
 	**(**uint8_t)(__ccgo_up(dst + uintptr(libc.Int32FromInt32(1)+libc.Int32FromInt32(3)*libc.Int32FromInt32(BPS)))) = libc.Uint8FromInt32((L + libc.Int32FromInt32(2)*K + J + libc.Int32FromInt32(2)) >> libc.Int32FromInt32(2))
 }
 
 func TM4(tls *libc.TLS, dst uintptr, top uintptr) {
 	var clip, clip_table uintptr
 	var x, y int32
 	_, _, _, _ = clip, clip_table, x, y
 	clip = uintptr(unsafe.Pointer(&clip12)) + uintptr(255) - uintptr(**(**uint8_t)(__ccgo_up(top + uintptr(-libc.Int32FromInt32(1)))))
 	y = 0
 	for {
 		if !(y < int32(4)) {
 			break
 		}
 		clip_table = clip + uintptr(**(**uint8_t)(__ccgo_up(top + uintptr(-int32(2)-y))))
 		x = 0
 		for {
 			if !(x < int32(4)) {
 				break
 			}
 			**(**uint8_t)(__ccgo_up(dst + uintptr(x))) = **(**uint8_t)(__ccgo_up(clip_table + uintptr(**(**uint8_t)(__ccgo_up(top + uintptr(x))))))
 			goto _2
 		_2:
 			;
 			x = x + 1
 		}
 		dst = dst + uintptr(BPS)
 		goto _1
 	_1:
 		;
 		y = y + 1
 	}
 }
 
 // C documentation
 //
 //	// Left samples are top[-5 .. -2], top_left is top[-1], top are
 //	// located at top[0..3], and top right is top[4..7]
 func Intra4Preds_C(tls *libc.TLS, dst uintptr, top uintptr) {
 	DC4(tls, uintptr(libc.Int32FromInt32(3)*libc.Int32FromInt32(16)*libc.Int32FromInt32(BPS)+libc.Int32FromInt32(0))+dst, top)
 	TM4(tls, uintptr(libc.Int32FromInt32(3)*libc.Int32FromInt32(16)*libc.Int32FromInt32(BPS)+libc.Int32FromInt32(0)+libc.Int32FromInt32(4))+dst, top)
 	VE4(tls, uintptr(libc.Int32FromInt32(3)*libc.Int32FromInt32(16)*libc.Int32FromInt32(BPS)+libc.Int32FromInt32(0)+libc.Int32FromInt32(8))+dst, top)
 	HE4(tls, uintptr(libc.Int32FromInt32(3)*libc.Int32FromInt32(16)*libc.Int32FromInt32(BPS)+libc.Int32FromInt32(0)+libc.Int32FromInt32(12))+dst, top)
 	RD4(tls, uintptr(libc.Int32FromInt32(3)*libc.Int32FromInt32(16)*libc.Int32FromInt32(BPS)+libc.Int32FromInt32(0)+libc.Int32FromInt32(16))+dst, top)
 	VR4(tls, uintptr(libc.Int32FromInt32(3)*libc.Int32FromInt32(16)*libc.Int32FromInt32(BPS)+libc.Int32FromInt32(0)+libc.Int32FromInt32(20))+dst, top)
 	LD4(tls, uintptr(libc.Int32FromInt32(3)*libc.Int32FromInt32(16)*libc.Int32FromInt32(BPS)+libc.Int32FromInt32(0)+libc.Int32FromInt32(24))+dst, top)
 	VL4(tls, uintptr(libc.Int32FromInt32(3)*libc.Int32FromInt32(16)*libc.Int32FromInt32(BPS)+libc.Int32FromInt32(0)+libc.Int32FromInt32(28))+dst, top)
 	HD4(tls, uintptr(libc.Int32FromInt32(3)*libc.Int32FromInt32(16)*libc.Int32FromInt32(BPS)+libc.Int32FromInt32(4)*libc.Int32FromInt32(BPS))+dst, top)
 	HU4(tls, uintptr(libc.Int32FromInt32(3)*libc.Int32FromInt32(16)*libc.Int32FromInt32(BPS)+libc.Int32FromInt32(4)*libc.Int32FromInt32(BPS)+libc.Int32FromInt32(4))+dst, top)
 }
 
 //------------------------------------------------------------------------------
 // Metric
 
 func GetSSE(tls *libc.TLS, a uintptr, b uintptr, w int32, h int32) (r int32) {
 	var count, diff, x, y int32
 	_, _, _, _ = count, diff, x, y
 	count = 0
 	y = 0
 	for {
 		if !(y < h) {
 			break
 		}
 		x = 0
 		for {
 			if !(x < w) {
 				break
 			}
 			diff = libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(a + uintptr(x)))) - libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(b + uintptr(x))))
 			count = count + diff*diff
 			goto _2
 		_2:
 			;
 			x = x + 1
 		}
 		a = a + uintptr(BPS)
 		b = b + uintptr(BPS)
 		goto _1
 	_1:
 		;
 		y = y + 1
 	}
 	return count
 }
 
 func SSE16x16_C(tls *libc.TLS, a uintptr, b uintptr) (r int32) {
 	return GetSSE(tls, a, b, int32(16), int32(16))
 }
 
 func SSE16x8_C(tls *libc.TLS, a uintptr, b uintptr) (r int32) {
 	return GetSSE(tls, a, b, int32(16), int32(8))
 }
 
 func SSE8x8_C(tls *libc.TLS, a uintptr, b uintptr) (r int32) {
 	return GetSSE(tls, a, b, int32(8), int32(8))
 }
 
 func SSE4x4_C(tls *libc.TLS, a uintptr, b uintptr) (r int32) {
 	return GetSSE(tls, a, b, int32(4), int32(4))
 }
 
 func Mean16x4_C(tls *libc.TLS, ref uintptr, dc uintptr) {
 	var avg uint32_t
 	var k, x, y int32
 	_, _, _, _ = avg, k, x, y
 	k = 0
 	for {
 		if !(k < int32(4)) {
 			break
 		}
 		avg = uint32(0)
 		y = 0
 		for {
 			if !(y < int32(4)) {
 				break
 			}
 			x = 0
 			for {
 				if !(x < int32(4)) {
 					break
 				}
 				avg = avg + uint32(**(**uint8_t)(__ccgo_up(ref + uintptr(x+y*int32(BPS)))))
 				goto _3
 			_3:
 				;
 				x = x + 1
 			}
 			goto _2
 		_2:
 			;
 			y = y + 1
 		}
 		**(**uint32_t)(__ccgo_up(dc + uintptr(k)*4)) = avg
 		ref = ref + uintptr(4) // go to next 4x4 block.
 		goto _1
 	_1:
 		;
 		k = k + 1
 	}
 }
 
 //------------------------------------------------------------------------------
 // Texture distortion
 //
 // We try to match the spectral content (weighted) between source and
 // reconstructed samples.
 
 // C documentation
 //
 //	// Hadamard transform
 //	// Returns the weighted sum of the absolute value of transformed coefficients.
 //	// w[] contains a row-major 4 by 4 symmetric matrix.
 func TTransform(tls *libc.TLS, in uintptr, w uintptr) (r int32) {
 	var a0, a01, a1, a11, a2, a21, a3, a31, b0, b1, b2, b3, i, sum int32
 	var tmp [16]int32
 	_, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = a0, a01, a1, a11, a2, a21, a3, a31, b0, b1, b2, b3, i, sum, tmp
 	sum = 0
 	// horizontal pass
 	i = 0
 	for {
 		if !(i < int32(4)) {
 			break
 		}
 		a0 = libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(in))) + libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(in + 2)))
 		a1 = libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(in + 1))) + libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(in + 3)))
 		a2 = libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(in + 1))) - libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(in + 3)))
 		a3 = libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(in))) - libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(in + 2)))
 		tmp[0+i*int32(4)] = a0 + a1
 		tmp[int32(1)+i*int32(4)] = a3 + a2
 		tmp[int32(2)+i*int32(4)] = a3 - a2
 		tmp[int32(3)+i*int32(4)] = a0 - a1
 		goto _1
 	_1:
 		;
 		i = i + 1
 		in = in + uintptr(BPS)
 	}
 	// vertical pass
 	i = 0
 	for {
 		if !(i < int32(4)) {
 			break
 		}
 		a01 = tmp[0+i] + tmp[int32(8)+i]
 		a11 = tmp[int32(4)+i] + tmp[int32(12)+i]
 		a21 = tmp[int32(4)+i] - tmp[int32(12)+i]
 		a31 = tmp[0+i] - tmp[int32(8)+i]
 		b0 = a01 + a11
 		b1 = a31 + a21
 		b2 = a31 - a21
 		b3 = a01 - a11
 		sum = sum + libc.Int32FromUint16(**(**uint16_t)(__ccgo_up(w)))*libc.Xabs(tls, b0)
 		sum = sum + libc.Int32FromUint16(**(**uint16_t)(__ccgo_up(w + 4*2)))*libc.Xabs(tls, b1)
 		sum = sum + libc.Int32FromUint16(**(**uint16_t)(__ccgo_up(w + 8*2)))*libc.Xabs(tls, b2)
 		sum = sum + libc.Int32FromUint16(**(**uint16_t)(__ccgo_up(w + 12*2)))*libc.Xabs(tls, b3)
 		goto _2
 	_2:
 		;
 		i = i + 1
 		w += 2
 	}
 	return sum
 }
 
 func Disto4x4_C(tls *libc.TLS, a uintptr, b uintptr, w uintptr) (r int32) {
 	var sum1, sum2 int32
 	_, _ = sum1, sum2
 	sum1 = TTransform(tls, a, w)
 	sum2 = TTransform(tls, b, w)
 	return libc.Xabs(tls, sum2-sum1) >> int32(5)
 }
 
 func Disto16x16_C(tls *libc.TLS, a uintptr, b uintptr, w uintptr) (r int32) {
 	var D, x, y int32
 	_, _, _ = D, x, y
 	D = 0
 	y = 0
 	for {
 		if !(y < libc.Int32FromInt32(16)*libc.Int32FromInt32(BPS)) {
 			break
 		}
 		x = 0
 		for {
 			if !(x < int32(16)) {
 				break
 			}
 			D = D + Disto4x4_C(tls, a+uintptr(x)+uintptr(y), b+uintptr(x)+uintptr(y), w)
 			goto _2
 		_2:
 			;
 			x = x + int32(4)
 		}
 		goto _1
 	_1:
 		;
 		y = y + libc.Int32FromInt32(4)*libc.Int32FromInt32(BPS)
 	}
 	return D
 }
 
 //------------------------------------------------------------------------------
 // Quantization
 //
 
 var kZigzag2 = [16]uint8_t{
 	1:  uint8(1),
 	2:  uint8(4),
 	3:  uint8(8),
 	4:  uint8(5),
 	5:  uint8(2),
 	6:  uint8(3),
 	7:  uint8(6),
 	8:  uint8(9),
 	9:  uint8(12),
 	10: uint8(13),
 	11: uint8(10),
 	12: uint8(7),
 	13: uint8(11),
 	14: uint8(14),
 	15: uint8(15),
 }
 
 // C documentation
 //
 //	// Simple quantization
 func QuantizeBlock_C(tls *libc.TLS, in uintptr, out uintptr, mtx uintptr) (r int32) {
 	var B1, Q, coeff, iQ1 uint32_t
 	var j, last, level, n1, sign, v2, v3 int32
 	_, _, _, _, _, _, _, _, _, _, _ = B1, Q, coeff, iQ1, j, last, level, n1, sign, v2, v3
 	last = -int32(1)
 	n1 = 0
 	for {
 		if !(n1 < int32(16)) {
 			break
 		}
 		j = libc.Int32FromUint8(kZigzag2[n1])
 		sign = libc.BoolInt32(int32(**(**int16_t)(__ccgo_up(in + uintptr(j)*2))) < libc.Int32FromInt32(0))
 		if sign != 0 {
 			v2 = -int32(**(**int16_t)(__ccgo_up(in + uintptr(j)*2)))
 		} else {
 			v2 = int32(**(**int16_t)(__ccgo_up(in + uintptr(j)*2)))
 		}
 		coeff = libc.Uint32FromInt32(v2 + libc.Int32FromUint16(**(**uint16_t)(__ccgo_up(mtx + 192 + uintptr(j)*2))))
 		if coeff > **(**uint32_t)(__ccgo_up(mtx + 128 + uintptr(j)*4)) {
 			Q = uint32(**(**uint16_t)(__ccgo_up(mtx + uintptr(j)*2)))
 			iQ1 = uint32(**(**uint16_t)(__ccgo_up(mtx + 32 + uintptr(j)*2)))
 			B1 = **(**uint32_t)(__ccgo_up(mtx + 64 + uintptr(j)*4))
 			v3 = libc.Int32FromUint32((coeff*iQ1 + B1) >> libc.Int32FromInt32(QFIX))
 			goto _4
 		_4:
 			level = v3
 			if level > int32(MAX_LEVEL) {
 				level = int32(MAX_LEVEL)
 			}
 			if sign != 0 {
 				level = -level
 			}
 			**(**int16_t)(__ccgo_up(in + uintptr(j)*2)) = int16(level * libc.Int32FromUint32(Q))
 			**(**int16_t)(__ccgo_up(out + uintptr(n1)*2)) = int16(level)
 			if level != 0 {
 				last = n1
 			}
 		} else {
 			**(**int16_t)(__ccgo_up(out + uintptr(n1)*2)) = 0
 			**(**int16_t)(__ccgo_up(in + uintptr(j)*2)) = 0
 		}
 		goto _1
 	_1:
 		;
 		n1 = n1 + 1
 	}
 	return libc.BoolInt32(last >= 0)
 }
 
 func Quantize2Blocks_C(tls *libc.TLS, in uintptr, out uintptr, mtx uintptr) (r int32) {
 	var nz int32
 	_ = nz
 	nz = (*(*func(*libc.TLS, uintptr, uintptr, uintptr) int32)(unsafe.Pointer(&struct{ uintptr }{VP8EncQuantizeBlock})))(tls, in+uintptr(libc.Int32FromInt32(0)*libc.Int32FromInt32(16))*2, out+uintptr(libc.Int32FromInt32(0)*libc.Int32FromInt32(16))*2, mtx) << 0
 	nz = nz | (*(*func(*libc.TLS, uintptr, uintptr, uintptr) int32)(unsafe.Pointer(&struct{ uintptr }{VP8EncQuantizeBlock})))(tls, in+uintptr(libc.Int32FromInt32(1)*libc.Int32FromInt32(16))*2, out+uintptr(libc.Int32FromInt32(1)*libc.Int32FromInt32(16))*2, mtx)<<int32(1)
 	return nz
 }
 
 //------------------------------------------------------------------------------
 // Block copy
 
 func Copy(tls *libc.TLS, src uintptr, dst uintptr, w int32, h int32) {
 	var y int32
 	_ = y
 	y = 0
 	for {
 		if !(y < h) {
 			break
 		}
 		libc.X__builtin___memcpy_chk(tls, dst, src, libc.Uint64FromInt32(w), ^__predefined_size_t(0))
 		src = src + uintptr(BPS)
 		dst = dst + uintptr(BPS)
 		goto _1
 	_1:
 		;
 		y = y + 1
 	}
 }
 
 func Copy4x4_C(tls *libc.TLS, src uintptr, dst uintptr) {
 	Copy(tls, src, dst, int32(4), int32(4))
 }
 
 func Copy16x8_C(tls *libc.TLS, src uintptr, dst uintptr) {
 	Copy(tls, src, dst, int32(16), int32(8))
 }
 
 func VP8EncDspInit(tls *libc.TLS) {
 	if libc.AtomicLoadPUintptr(uintptr(unsafe.Pointer(&VP8EncDspInit_body_last_cpuinfo_used))) == VP8GetCPUInfo {
 		goto _1
 	}
 	VP8EncDspInit_body(tls)
 	libc.AtomicStorePUintptr(uintptr(unsafe.Pointer(&VP8EncDspInit_body_last_cpuinfo_used)), VP8GetCPUInfo)
 	goto _2
 _2:
 	;
 	goto _1
 _1: /**/ //
 }
 
 var VP8EncDspInit_body_last_cpuinfo_used = uintptr(0)
 
 func init() {
 	p := unsafe.Pointer(&VP8EncDspInit_body_last_cpuinfo_used)
 	*(*uintptr)(unsafe.Add(p, 0)) = uintptr(unsafe.Pointer(&VP8EncDspInit_body_last_cpuinfo_used))
 }
 
 func VP8EncDspInit_body(tls *libc.TLS) {
 	VP8DspInit(tls) // common inverse transforms
 	InitTables(tls)
 	// default C implementations
 	VP8ITransform = __ccgo_fp(ITransform_C)
 	VP8FTransform = __ccgo_fp(FTransform_C)
 	VP8FTransformWHT = __ccgo_fp(FTransformWHT_C)
 	VP8TDisto4x4 = __ccgo_fp(Disto4x4_C)
 	VP8TDisto16x16 = __ccgo_fp(Disto16x16_C)
 	VP8CollectHistogram = __ccgo_fp(CollectHistogram_C)
 	VP8SSE16x16 = __ccgo_fp(SSE16x16_C)
 	VP8SSE16x8 = __ccgo_fp(SSE16x8_C)
 	VP8SSE8x8 = __ccgo_fp(SSE8x8_C)
 	VP8SSE4x4 = __ccgo_fp(SSE4x4_C)
 	VP8EncQuantizeBlock = __ccgo_fp(QuantizeBlock_C)
 	VP8EncQuantize2Blocks = __ccgo_fp(Quantize2Blocks_C)
 	VP8EncQuantizeBlockWHT = __ccgo_fp(QuantizeBlock_C)
 	VP8EncPredLuma4 = __ccgo_fp(Intra4Preds_C)
 	VP8EncPredLuma16 = __ccgo_fp(Intra16Preds_C)
 	VP8FTransform2 = __ccgo_fp(FTransform2_C)
 	VP8EncPredChroma8 = __ccgo_fp(IntraChromaPreds_C)
 	VP8Mean16x4 = __ccgo_fp(Mean16x4_C)
 	VP8Copy4x4 = __ccgo_fp(Copy4x4_C)
 	VP8Copy16x8 = __ccgo_fp(Copy16x8_C)
 	// If defined, use CPUInfo() to overwrite some pointers with faster versions.
 	if VP8GetCPUInfo != libc.UintptrFromInt32(0) {
 	}
 }
 
 func VP8EncDspInitMIPS32(tls *libc.TLS) {
 }
 
 func VP8EncDspInitMIPSdspR2(tls *libc.TLS) {
 }
 
 func VP8EncDspInitMSA(tls *libc.TLS) {
 }
 
 func VP8EncDspInitNEON(tls *libc.TLS) {
 }
 
 func VP8EncDspInitSSE2(tls *libc.TLS) {
 }
 
 func VP8EncDspInitSSE41(tls *libc.TLS) {
 }
 
 // Copyright 2010 Google Inc. All Rights Reserved.
 //
 // Use of this source code is governed by a BSD-style license
 // that can be found in the COPYING file in the root of the source
 // tree. An additional intellectual property rights grant can be found
 // in the file PATENTS. All contributing project authors may
 // be found in the AUTHORS file in the root of the source tree.
 // -----------------------------------------------------------------------------
 //
 //  Common types + memory wrappers
 //
 // Author: Skal (pascal.massimino@gmail.com)
 
 //------------------------------------------------------------------------------
 // Helpful macro.
 
 func PredictLine_C(tls *libc.TLS, src uintptr, pred uintptr, dst uintptr, length int32) {
 	var i int32
 	_ = i
 	i = 0
 	for {
 		if !(i < length) {
 			break
 		}
 		**(**uint8_t)(__ccgo_up(dst + uintptr(i))) = libc.Uint8FromInt32(libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(src + uintptr(i)))) - libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(pred + uintptr(i)))))
 		goto _1
 	_1:
 		;
 		i = i + 1
 	}
 }
 
 //------------------------------------------------------------------------------
 // Horizontal filter.
 
 func DoHorizontalFilter_C(tls *libc.TLS, in uintptr, width int32, height int32, stride int32, out uintptr) {
 	var preds uintptr
 	var row int32
 	_, _ = preds, row
 	preds = in
 	// Leftmost pixel is the same as input for topmost scanline.
 	**(**uint8_t)(__ccgo_up(out)) = **(**uint8_t)(__ccgo_up(in))
 	PredictLine_C(tls, in+uintptr(1), preds, out+uintptr(1), width-int32(1))
 	preds = preds + uintptr(stride)
 	in = in + uintptr(stride)
 	out = out + uintptr(stride)
 	// Filter line-by-line.
 	row = int32(1)
 	for {
 		if !(row < height) {
 			break
 		}
 		// Leftmost pixel is predicted from above.
 		PredictLine_C(tls, in, preds-uintptr(stride), out, int32(1))
 		PredictLine_C(tls, in+uintptr(1), preds, out+uintptr(1), width-int32(1))
 		preds = preds + uintptr(stride)
 		in = in + uintptr(stride)
 		out = out + uintptr(stride)
 		goto _1
 	_1:
 		;
 		row = row + 1
 	}
 }
 
 //------------------------------------------------------------------------------
 // Vertical filter.
 
 func DoVerticalFilter_C(tls *libc.TLS, in uintptr, width int32, height int32, stride int32, out uintptr) {
 	var preds uintptr
 	var row int32
 	_, _ = preds, row
 	preds = in
 	// Very first top-left pixel is copied.
 	**(**uint8_t)(__ccgo_up(out)) = **(**uint8_t)(__ccgo_up(in))
 	// Rest of top scan-line is left-predicted.
 	PredictLine_C(tls, in+uintptr(1), preds, out+uintptr(1), width-int32(1))
 	in = in + uintptr(stride)
 	out = out + uintptr(stride)
 	// Filter line-by-line.
 	row = int32(1)
 	for {
 		if !(row < height) {
 			break
 		}
 		PredictLine_C(tls, in, preds, out, width)
 		preds = preds + uintptr(stride)
 		in = in + uintptr(stride)
 		out = out + uintptr(stride)
 		goto _1
 	_1:
 		;
 		row = row + 1
 	}
 }
 
 //------------------------------------------------------------------------------
 // Gradient filter.
 
 func GradientPredictor_C(tls *libc.TLS, a uint8_t, b uint8_t, c uint8_t) (r int32) {
 	var g, v1, v2 int32
 	_, _, _ = g, v1, v2
 	g = libc.Int32FromUint8(a) + libc.Int32FromUint8(b) - libc.Int32FromUint8(c)
 	if g & ^libc.Int32FromInt32(0xff) == 0 {
 		v1 = g
 	} else {
 		if g < 0 {
 			v2 = 0
 		} else {
 			v2 = int32(255)
 		}
 		v1 = v2
 	}
 	return v1 // clip to 8bit
 }
 
 func DoGradientFilter_C(tls *libc.TLS, in uintptr, width int32, height int32, stride int32, out uintptr) {
 	var pred, row, w int32
 	var preds uintptr
 	_, _, _, _ = pred, preds, row, w
 	preds = in
 	// left prediction for top scan-line
 	**(**uint8_t)(__ccgo_up(out)) = **(**uint8_t)(__ccgo_up(in))
 	PredictLine_C(tls, in+uintptr(1), preds, out+uintptr(1), width-int32(1))
 	preds = preds + uintptr(stride)
 	in = in + uintptr(stride)
 	out = out + uintptr(stride)
 	// Filter line-by-line.
 	row = int32(1)
 	for {
 		if !(row < height) {
 			break
 		}
 		// leftmost pixel: predict from above.
 		PredictLine_C(tls, in, preds-uintptr(stride), out, int32(1))
 		w = int32(1)
 		for {
 			if !(w < width) {
 				break
 			}
 			pred = GradientPredictor_C(tls, **(**uint8_t)(__ccgo_up(preds + uintptr(w-int32(1)))), **(**uint8_t)(__ccgo_up(preds + uintptr(w-stride))), **(**uint8_t)(__ccgo_up(preds + uintptr(w-stride-int32(1)))))
 			**(**uint8_t)(__ccgo_up(out + uintptr(w))) = libc.Uint8FromInt32(libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(in + uintptr(w)))) - pred)
 			goto _2
 		_2:
 			;
 			w = w + 1
 		}
 		preds = preds + uintptr(stride)
 		in = in + uintptr(stride)
 		out = out + uintptr(stride)
 		goto _1
 	_1:
 		;
 		row = row + 1
 	}
 }
 
 //------------------------------------------------------------------------------
 
 func HorizontalFilter_C(tls *libc.TLS, data uintptr, width int32, height int32, stride int32, filtered_data uintptr) {
 	DoHorizontalFilter_C(tls, data, width, height, stride, filtered_data)
 }
 
 func VerticalFilter_C(tls *libc.TLS, data uintptr, width int32, height int32, stride int32, filtered_data uintptr) {
 	DoVerticalFilter_C(tls, data, width, height, stride, filtered_data)
 }
 
 func GradientFilter_C(tls *libc.TLS, data uintptr, width int32, height int32, stride int32, filtered_data uintptr) {
 	DoGradientFilter_C(tls, data, width, height, stride, filtered_data)
 }
 
 //------------------------------------------------------------------------------
 
 func NoneUnfilter_C(tls *libc.TLS, prev uintptr, in uintptr, out uintptr, width int32) {
 	_ = prev
 	if out != in {
 		libc.X__builtin___memcpy_chk(tls, out, in, libc.Uint64FromInt32(width)*uint64(1), ^__predefined_size_t(0))
 	}
 }
 
 func HorizontalUnfilter_C(tls *libc.TLS, prev uintptr, in uintptr, out uintptr, width int32) {
 	var i, v1 int32
 	var pred uint8_t
 	_, _, _ = i, pred, v1
 	if prev == libc.UintptrFromInt32(0) {
 		v1 = 0
 	} else {
 		v1 = libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(prev)))
 	}
 	pred = libc.Uint8FromInt32(v1)
 	i = 0
 	for {
 		if !(i < width) {
 			break
 		}
 		**(**uint8_t)(__ccgo_up(out + uintptr(i))) = libc.Uint8FromInt32(libc.Int32FromUint8(pred) + libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(in + uintptr(i)))))
 		pred = **(**uint8_t)(__ccgo_up(out + uintptr(i)))
 		goto _2
 	_2:
 		;
 		i = i + 1
 	}
 }
 
 func VerticalUnfilter_C(tls *libc.TLS, prev uintptr, in uintptr, out uintptr, width int32) {
 	var i int32
 	_ = i
 	if prev == libc.UintptrFromInt32(0) {
 		HorizontalUnfilter_C(tls, libc.UintptrFromInt32(0), in, out, width)
 	} else {
 		i = 0
 		for {
 			if !(i < width) {
 				break
 			}
 			**(**uint8_t)(__ccgo_up(out + uintptr(i))) = libc.Uint8FromInt32(libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(prev + uintptr(i)))) + libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(in + uintptr(i)))))
 			goto _1
 		_1:
 			;
 			i = i + 1
 		}
 	}
 }
 
 func GradientUnfilter_C(tls *libc.TLS, prev uintptr, in uintptr, out uintptr, width int32) {
 	var i int32
 	var left, top, top_left uint8_t
 	_, _, _, _ = i, left, top, top_left
 	if prev == libc.UintptrFromInt32(0) {
 		HorizontalUnfilter_C(tls, libc.UintptrFromInt32(0), in, out, width)
 	} else {
 		top = **(**uint8_t)(__ccgo_up(prev))
 		top_left = top
 		left = top
 		i = 0
 		for {
 			if !(i < width) {
 				break
 			}
 			top = **(**uint8_t)(__ccgo_up(prev + uintptr(i))) // need to read this first, in case prev==out
 			left = libc.Uint8FromInt32(libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(in + uintptr(i)))) + GradientPredictor_C(tls, left, top, top_left))
 			top_left = top
 			**(**uint8_t)(__ccgo_up(out + uintptr(i))) = left
 			goto _1
 		_1:
 			;
 			i = i + 1
 		}
 	}
 }
 
 func VP8FiltersInit(tls *libc.TLS) {
 	if libc.AtomicLoadPUintptr(uintptr(unsafe.Pointer(&VP8FiltersInit_body_last_cpuinfo_used))) == VP8GetCPUInfo {
 		goto _1
 	}
 	VP8FiltersInit_body(tls)
 	libc.AtomicStorePUintptr(uintptr(unsafe.Pointer(&VP8FiltersInit_body_last_cpuinfo_used)), VP8GetCPUInfo)
 	goto _2
 _2:
 	;
 	goto _1
 _1: /**/ //
 }
 
 var VP8FiltersInit_body_last_cpuinfo_used = uintptr(0)
 
 func init() {
 	p := unsafe.Pointer(&VP8FiltersInit_body_last_cpuinfo_used)
 	*(*uintptr)(unsafe.Add(p, 0)) = uintptr(unsafe.Pointer(&VP8FiltersInit_body_last_cpuinfo_used))
 }
 
 func VP8FiltersInit_body(tls *libc.TLS) {
 	WebPUnfilters[int32(WEBP_FILTER_NONE)] = __ccgo_fp(NoneUnfilter_C)
 	WebPUnfilters[int32(WEBP_FILTER_HORIZONTAL)] = __ccgo_fp(HorizontalUnfilter_C)
 	WebPUnfilters[int32(WEBP_FILTER_VERTICAL)] = __ccgo_fp(VerticalUnfilter_C)
 	WebPUnfilters[int32(WEBP_FILTER_GRADIENT)] = __ccgo_fp(GradientUnfilter_C)
 	WebPFilters[int32(WEBP_FILTER_NONE)] = libc.UintptrFromInt32(0)
 	WebPFilters[int32(WEBP_FILTER_HORIZONTAL)] = __ccgo_fp(HorizontalFilter_C)
 	WebPFilters[int32(WEBP_FILTER_VERTICAL)] = __ccgo_fp(VerticalFilter_C)
 	WebPFilters[int32(WEBP_FILTER_GRADIENT)] = __ccgo_fp(GradientFilter_C)
 	if VP8GetCPUInfo != libc.UintptrFromInt32(0) {
 	}
 }
 
 func VP8FiltersInitMIPSdspR2(tls *libc.TLS) {
 }
 
 func VP8FiltersInitMSA(tls *libc.TLS) {
 }
 
 func VP8FiltersInitNEON(tls *libc.TLS) {
 }
 
 func VP8FiltersInitSSE2(tls *libc.TLS) {
 }
 
 func VP8LDspInitAVX2(tls *libc.TLS) {
 }
 
 const ARGB_BLACK3 = 4278190080
 
 var kHashMul15 = uint32(0x1e35a7bd)
 
 // Copyright 2012 Google Inc. All Rights Reserved.
 //
 // Use of this source code is governed by a BSD-style license
 // that can be found in the COPYING file in the root of the source
 // tree. An additional intellectual property rights grant can be found
 // in the file PATENTS. All contributing project authors may
 // be found in the AUTHORS file in the root of the source tree.
 // -----------------------------------------------------------------------------
 //
 // Misc. common utility functions
 //
 // Authors: Skal (pascal.massimino@gmail.com)
 //          Urvang (urvang@google.com)
 
 // Copyright 2010 Google Inc. All Rights Reserved.
 //
 // Use of this source code is governed by a BSD-style license
 // that can be found in the COPYING file in the root of the source
 // tree. An additional intellectual property rights grant can be found
 // in the file PATENTS. All contributing project authors may
 // be found in the AUTHORS file in the root of the source tree.
 // -----------------------------------------------------------------------------
 //
 //  Main decoding functions for WebP images.
 //
 // Author: Skal (pascal.massimino@gmail.com)
 
 // Copyright 2012 Google Inc. All Rights Reserved.
 //
 // Use of this source code is governed by a BSD-style license
 // that can be found in the COPYING file in the root of the source
 // tree. An additional intellectual property rights grant can be found
 // in the file PATENTS. All contributing project authors may
 // be found in the AUTHORS file in the root of the source tree.
 // -----------------------------------------------------------------------------
 //
 //  Internal header for constants related to WebP file format.
 //
 // Author: Urvang (urvang@google.com)
 
 // Copyright 2010 Google Inc. All Rights Reserved.
 //
 // Use of this source code is governed by a BSD-style license
 // that can be found in the COPYING file in the root of the source
 // tree. An additional intellectual property rights grant can be found
 // in the file PATENTS. All contributing project authors may
 // be found in the AUTHORS file in the root of the source tree.
 // -----------------------------------------------------------------------------
 //
 //  Common types + memory wrappers
 //
 // Author: Skal (pascal.massimino@gmail.com)
 
 //------------------------------------------------------------------------------
 // Image transforms.
 
 func Average2(tls *libc.TLS, a0 uint32_t, a1 uint32_t) (r uint32_t) {
 	return (a0^a1)&uint32(0xfefefefe)>>int32(1) + a0&a1
 }
 
 func Average3(tls *libc.TLS, a0 uint32_t, a1 uint32_t, a2 uint32_t) (r uint32_t) {
 	return Average2(tls, Average2(tls, a0, a2), a1)
 }
 
 func Average4(tls *libc.TLS, a0 uint32_t, a1 uint32_t, a2 uint32_t, a3 uint32_t) (r uint32_t) {
 	return Average2(tls, Average2(tls, a0, a1), Average2(tls, a2, a3))
 }
 
 func Clip255(tls *libc.TLS, a uint32_t) (r uint32_t) {
 	if a < uint32(256) {
 		return a
 	}
 	// return 0, when a is a negative integer.
 	// return 255, when a is positive.
 	return ^a >> int32(24)
 }
 
 func AddSubtractComponentFull(tls *libc.TLS, a int32, b int32, c int32) (r int32) {
 	return libc.Int32FromUint32(Clip255(tls, libc.Uint32FromInt32(a+b-c)))
 }
 
 func ClampedAddSubtractFull(tls *libc.TLS, c0 uint32_t, c1 uint32_t, c2 uint32_t) (r1 uint32_t) {
 	var a, b, g, r int32
 	_, _, _, _ = a, b, g, r
 	a = AddSubtractComponentFull(tls, libc.Int32FromUint32(c0>>int32(24)), libc.Int32FromUint32(c1>>int32(24)), libc.Int32FromUint32(c2>>int32(24)))
 	r = AddSubtractComponentFull(tls, libc.Int32FromUint32(c0>>libc.Int32FromInt32(16)&uint32(0xff)), libc.Int32FromUint32(c1>>libc.Int32FromInt32(16)&uint32(0xff)), libc.Int32FromUint32(c2>>libc.Int32FromInt32(16)&uint32(0xff)))
 	g = AddSubtractComponentFull(tls, libc.Int32FromUint32(c0>>libc.Int32FromInt32(8)&uint32(0xff)), libc.Int32FromUint32(c1>>libc.Int32FromInt32(8)&uint32(0xff)), libc.Int32FromUint32(c2>>libc.Int32FromInt32(8)&uint32(0xff)))
 	b = AddSubtractComponentFull(tls, libc.Int32FromUint32(c0&uint32(0xff)), libc.Int32FromUint32(c1&uint32(0xff)), libc.Int32FromUint32(c2&uint32(0xff)))
 	return libc.Uint32FromInt32(a)<<libc.Int32FromInt32(24) | libc.Uint32FromInt32(r<<libc.Int32FromInt32(16)) | libc.Uint32FromInt32(g<<libc.Int32FromInt32(8)) | libc.Uint32FromInt32(b)
 }
 
 func AddSubtractComponentHalf(tls *libc.TLS, a int32, b int32) (r int32) {
 	return libc.Int32FromUint32(Clip255(tls, libc.Uint32FromInt32(a+(a-b)/libc.Int32FromInt32(2))))
 }
 
 func ClampedAddSubtractHalf(tls *libc.TLS, c0 uint32_t, c1 uint32_t, c2 uint32_t) (r1 uint32_t) {
 	var a, b, g, r int32
 	var ave uint32_t
 	_, _, _, _, _ = a, ave, b, g, r
 	ave = Average2(tls, c0, c1)
 	a = AddSubtractComponentHalf(tls, libc.Int32FromUint32(ave>>int32(24)), libc.Int32FromUint32(c2>>int32(24)))
 	r = AddSubtractComponentHalf(tls, libc.Int32FromUint32(ave>>libc.Int32FromInt32(16)&uint32(0xff)), libc.Int32FromUint32(c2>>libc.Int32FromInt32(16)&uint32(0xff)))
 	g = AddSubtractComponentHalf(tls, libc.Int32FromUint32(ave>>libc.Int32FromInt32(8)&uint32(0xff)), libc.Int32FromUint32(c2>>libc.Int32FromInt32(8)&uint32(0xff)))
 	b = AddSubtractComponentHalf(tls, libc.Int32FromUint32(ave>>libc.Int32FromInt32(0)&uint32(0xff)), libc.Int32FromUint32(c2>>libc.Int32FromInt32(0)&uint32(0xff)))
 	return libc.Uint32FromInt32(a)<<libc.Int32FromInt32(24) | libc.Uint32FromInt32(r<<libc.Int32FromInt32(16)) | libc.Uint32FromInt32(g<<libc.Int32FromInt32(8)) | libc.Uint32FromInt32(b)
 }
 
 // gcc <= 4.9 on ARM generates incorrect code in Select() when Sub3() is
 // inlined.
 
 func Sub3(tls *libc.TLS, a int32, b int32, c int32) (r int32) {
 	var pa, pb int32
 	_, _ = pa, pb
 	pb = b - c
 	pa = a - c
 	return libc.Xabs(tls, pb) - libc.Xabs(tls, pa)
 }
 
 func Select(tls *libc.TLS, a uint32_t, b uint32_t, c uint32_t) (r uint32_t) {
 	var pa_minus_pb int32
 	var v1 uint32
 	_, _ = pa_minus_pb, v1
 	pa_minus_pb = Sub3(tls, libc.Int32FromUint32(a>>libc.Int32FromInt32(24)), libc.Int32FromUint32(b>>libc.Int32FromInt32(24)), libc.Int32FromUint32(c>>libc.Int32FromInt32(24))) + Sub3(tls, libc.Int32FromUint32(a>>libc.Int32FromInt32(16)&uint32(0xff)), libc.Int32FromUint32(b>>libc.Int32FromInt32(16)&uint32(0xff)), libc.Int32FromUint32(c>>libc.Int32FromInt32(16)&uint32(0xff))) + Sub3(tls, libc.Int32FromUint32(a>>libc.Int32FromInt32(8)&uint32(0xff)), libc.Int32FromUint32(b>>libc.Int32FromInt32(8)&uint32(0xff)), libc.Int32FromUint32(c>>libc.Int32FromInt32(8)&uint32(0xff))) + Sub3(tls, libc.Int32FromUint32(a&uint32(0xff)), libc.Int32FromUint32(b&uint32(0xff)), libc.Int32FromUint32(c&uint32(0xff)))
 	if pa_minus_pb <= 0 {
 		v1 = a
 	} else {
 		v1 = b
 	}
 	return v1
 }
 
 //------------------------------------------------------------------------------
 // Predictors
 
 func VP8LPredictor0_C(tls *libc.TLS, left uintptr, top uintptr) (r uint32_t) {
 	_ = top
 	_ = left
 	return uint32(ARGB_BLACK3)
 }
 
 func VP8LPredictor1_C(tls *libc.TLS, left uintptr, top uintptr) (r uint32_t) {
 	_ = top
 	return **(**uint32_t)(__ccgo_up(left))
 }
 
 func VP8LPredictor2_C(tls *libc.TLS, left uintptr, top uintptr) (r uint32_t) {
 	_ = left
 	return **(**uint32_t)(__ccgo_up(top))
 }
 
 func VP8LPredictor3_C(tls *libc.TLS, left uintptr, top uintptr) (r uint32_t) {
 	_ = left
 	return **(**uint32_t)(__ccgo_up(top + 1*4))
 }
 
 func VP8LPredictor4_C(tls *libc.TLS, left uintptr, top uintptr) (r uint32_t) {
 	_ = left
 	return **(**uint32_t)(__ccgo_up(top + uintptr(-libc.Int32FromInt32(1))*4))
 }
 
 func VP8LPredictor5_C(tls *libc.TLS, left uintptr, top uintptr) (r uint32_t) {
 	var pred uint32_t
 	_ = pred
 	pred = Average3(tls, **(**uint32_t)(__ccgo_up(left)), **(**uint32_t)(__ccgo_up(top)), **(**uint32_t)(__ccgo_up(top + 1*4)))
 	return pred
 }
 
 func VP8LPredictor6_C(tls *libc.TLS, left uintptr, top uintptr) (r uint32_t) {
 	var pred uint32_t
 	_ = pred
 	pred = Average2(tls, **(**uint32_t)(__ccgo_up(left)), **(**uint32_t)(__ccgo_up(top + uintptr(-libc.Int32FromInt32(1))*4)))
 	return pred
 }
 
 func VP8LPredictor7_C(tls *libc.TLS, left uintptr, top uintptr) (r uint32_t) {
 	var pred uint32_t
 	_ = pred
 	pred = Average2(tls, **(**uint32_t)(__ccgo_up(left)), **(**uint32_t)(__ccgo_up(top)))
 	return pred
 }
 
 func VP8LPredictor8_C(tls *libc.TLS, left uintptr, top uintptr) (r uint32_t) {
 	var pred uint32_t
 	_ = pred
 	pred = Average2(tls, **(**uint32_t)(__ccgo_up(top + uintptr(-libc.Int32FromInt32(1))*4)), **(**uint32_t)(__ccgo_up(top)))
 	_ = left
 	return pred
 }
 
 func VP8LPredictor9_C(tls *libc.TLS, left uintptr, top uintptr) (r uint32_t) {
 	var pred uint32_t
 	_ = pred
 	pred = Average2(tls, **(**uint32_t)(__ccgo_up(top)), **(**uint32_t)(__ccgo_up(top + 1*4)))
 	_ = left
 	return pred
 }
 
 func VP8LPredictor10_C(tls *libc.TLS, left uintptr, top uintptr) (r uint32_t) {
 	var pred uint32_t
 	_ = pred
 	pred = Average4(tls, **(**uint32_t)(__ccgo_up(left)), **(**uint32_t)(__ccgo_up(top + uintptr(-libc.Int32FromInt32(1))*4)), **(**uint32_t)(__ccgo_up(top)), **(**uint32_t)(__ccgo_up(top + 1*4)))
 	return pred
 }
 
 func VP8LPredictor11_C(tls *libc.TLS, left uintptr, top uintptr) (r uint32_t) {
 	var pred uint32_t
 	_ = pred
 	pred = Select(tls, **(**uint32_t)(__ccgo_up(top)), **(**uint32_t)(__ccgo_up(left)), **(**uint32_t)(__ccgo_up(top + uintptr(-libc.Int32FromInt32(1))*4)))
 	return pred
 }
 
 func VP8LPredictor12_C(tls *libc.TLS, left uintptr, top uintptr) (r uint32_t) {
 	var pred uint32_t
 	_ = pred
 	pred = ClampedAddSubtractFull(tls, **(**uint32_t)(__ccgo_up(left)), **(**uint32_t)(__ccgo_up(top)), **(**uint32_t)(__ccgo_up(top + uintptr(-libc.Int32FromInt32(1))*4)))
 	return pred
 }
 
 func VP8LPredictor13_C(tls *libc.TLS, left uintptr, top uintptr) (r uint32_t) {
 	var pred uint32_t
 	_ = pred
 	pred = ClampedAddSubtractHalf(tls, **(**uint32_t)(__ccgo_up(left)), **(**uint32_t)(__ccgo_up(top)), **(**uint32_t)(__ccgo_up(top + uintptr(-libc.Int32FromInt32(1))*4)))
 	return pred
 }
 
 func PredictorAdd0_C(tls *libc.TLS, in uintptr, upper uintptr, num_pixels int32, out uintptr) {
 	var alpha_and_green, red_and_blue, v2, v3, v4 uint32_t
 	var x int32
 	_, _, _, _, _, _ = alpha_and_green, red_and_blue, x, v2, v3, v4
 	_ = upper
 	x = 0
 	for {
 		if !(x < num_pixels) {
 			break
 		}
 		v2 = **(**uint32_t)(__ccgo_up(in + uintptr(x)*4))
 		v3 = uint32(ARGB_BLACK3)
 		alpha_and_green = v2&uint32(0xff00ff00) + v3&uint32(0xff00ff00)
 		red_and_blue = v2&uint32(0x00ff00ff) + v3&uint32(0x00ff00ff)
 		v4 = alpha_and_green&uint32(0xff00ff00) | red_and_blue&uint32(0x00ff00ff)
 		goto _5
 	_5:
 		**(**uint32_t)(__ccgo_up(out + uintptr(x)*4)) = v4
 		goto _1
 	_1:
 		;
 		x = x + 1
 	}
 }
 
 func PredictorAdd1_C(tls *libc.TLS, in uintptr, upper uintptr, num_pixels int32, out uintptr) {
 	var alpha_and_green, left, red_and_blue, v2, v3, v4, v5 uint32_t
 	var i int32
 	_, _, _, _, _, _, _, _ = alpha_and_green, i, left, red_and_blue, v2, v3, v4, v5
 	left = **(**uint32_t)(__ccgo_up(out + uintptr(-libc.Int32FromInt32(1))*4))
 	_ = upper
 	i = 0
 	for {
 		if !(i < num_pixels) {
 			break
 		}
 		v3 = **(**uint32_t)(__ccgo_up(in + uintptr(i)*4))
 		v4 = left
 		alpha_and_green = v3&uint32(0xff00ff00) + v4&uint32(0xff00ff00)
 		red_and_blue = v3&uint32(0x00ff00ff) + v4&uint32(0x00ff00ff)
 		v5 = alpha_and_green&uint32(0xff00ff00) | red_and_blue&uint32(0x00ff00ff)
 		goto _6
 	_6:
 		v2 = v5
 		left = v2
 		**(**uint32_t)(__ccgo_up(out + uintptr(i)*4)) = v2
 		goto _1
 	_1:
 		;
 		i = i + 1
 	}
 }
 
 func PredictorAdd2_C(tls *libc.TLS, in uintptr, upper uintptr, num_pixels int32, out uintptr) {
 	var alpha_and_green, pred, red_and_blue, v2, v3, v4 uint32_t
 	var x int32
 	_, _, _, _, _, _, _ = alpha_and_green, pred, red_and_blue, x, v2, v3, v4
 	x = 0
 	for {
 		if !(x < num_pixels) {
 			break
 		}
 		pred = VP8LPredictor2_C(tls, out+uintptr(x-int32(1))*4, upper+uintptr(x)*4)
 		v2 = **(**uint32_t)(__ccgo_up(in + uintptr(x)*4))
 		v3 = pred
 		alpha_and_green = v2&uint32(0xff00ff00) + v3&uint32(0xff00ff00)
 		red_and_blue = v2&uint32(0x00ff00ff) + v3&uint32(0x00ff00ff)
 		v4 = alpha_and_green&uint32(0xff00ff00) | red_and_blue&uint32(0x00ff00ff)
 		goto _5
 	_5:
 		**(**uint32_t)(__ccgo_up(out + uintptr(x)*4)) = v4
 		goto _1
 	_1:
 		;
 		x = x + 1
 	}
 }
 
 func PredictorAdd3_C(tls *libc.TLS, in uintptr, upper uintptr, num_pixels int32, out uintptr) {
 	var alpha_and_green, pred, red_and_blue, v2, v3, v4 uint32_t
 	var x int32
 	_, _, _, _, _, _, _ = alpha_and_green, pred, red_and_blue, x, v2, v3, v4
 	x = 0
 	for {
 		if !(x < num_pixels) {
 			break
 		}
 		pred = VP8LPredictor3_C(tls, out+uintptr(x-int32(1))*4, upper+uintptr(x)*4)
 		v2 = **(**uint32_t)(__ccgo_up(in + uintptr(x)*4))
 		v3 = pred
 		alpha_and_green = v2&uint32(0xff00ff00) + v3&uint32(0xff00ff00)
 		red_and_blue = v2&uint32(0x00ff00ff) + v3&uint32(0x00ff00ff)
 		v4 = alpha_and_green&uint32(0xff00ff00) | red_and_blue&uint32(0x00ff00ff)
 		goto _5
 	_5:
 		**(**uint32_t)(__ccgo_up(out + uintptr(x)*4)) = v4
 		goto _1
 	_1:
 		;
 		x = x + 1
 	}
 }
 
 func PredictorAdd4_C(tls *libc.TLS, in uintptr, upper uintptr, num_pixels int32, out uintptr) {
 	var alpha_and_green, pred, red_and_blue, v2, v3, v4 uint32_t
 	var x int32
 	_, _, _, _, _, _, _ = alpha_and_green, pred, red_and_blue, x, v2, v3, v4
 	x = 0
 	for {
 		if !(x < num_pixels) {
 			break
 		}
 		pred = VP8LPredictor4_C(tls, out+uintptr(x-int32(1))*4, upper+uintptr(x)*4)
 		v2 = **(**uint32_t)(__ccgo_up(in + uintptr(x)*4))
 		v3 = pred
 		alpha_and_green = v2&uint32(0xff00ff00) + v3&uint32(0xff00ff00)
 		red_and_blue = v2&uint32(0x00ff00ff) + v3&uint32(0x00ff00ff)
 		v4 = alpha_and_green&uint32(0xff00ff00) | red_and_blue&uint32(0x00ff00ff)
 		goto _5
 	_5:
 		**(**uint32_t)(__ccgo_up(out + uintptr(x)*4)) = v4
 		goto _1
 	_1:
 		;
 		x = x + 1
 	}
 }
 
 func PredictorAdd5_C(tls *libc.TLS, in uintptr, upper uintptr, num_pixels int32, out uintptr) {
 	var alpha_and_green, pred, red_and_blue, v2, v3, v4 uint32_t
 	var x int32
 	_, _, _, _, _, _, _ = alpha_and_green, pred, red_and_blue, x, v2, v3, v4
 	x = 0
 	for {
 		if !(x < num_pixels) {
 			break
 		}
 		pred = VP8LPredictor5_C(tls, out+uintptr(x-int32(1))*4, upper+uintptr(x)*4)
 		v2 = **(**uint32_t)(__ccgo_up(in + uintptr(x)*4))
 		v3 = pred
 		alpha_and_green = v2&uint32(0xff00ff00) + v3&uint32(0xff00ff00)
 		red_and_blue = v2&uint32(0x00ff00ff) + v3&uint32(0x00ff00ff)
 		v4 = alpha_and_green&uint32(0xff00ff00) | red_and_blue&uint32(0x00ff00ff)
 		goto _5
 	_5:
 		**(**uint32_t)(__ccgo_up(out + uintptr(x)*4)) = v4
 		goto _1
 	_1:
 		;
 		x = x + 1
 	}
 }
 
 func PredictorAdd6_C(tls *libc.TLS, in uintptr, upper uintptr, num_pixels int32, out uintptr) {
 	var alpha_and_green, pred, red_and_blue, v2, v3, v4 uint32_t
 	var x int32
 	_, _, _, _, _, _, _ = alpha_and_green, pred, red_and_blue, x, v2, v3, v4
 	x = 0
 	for {
 		if !(x < num_pixels) {
 			break
 		}
 		pred = VP8LPredictor6_C(tls, out+uintptr(x-int32(1))*4, upper+uintptr(x)*4)
 		v2 = **(**uint32_t)(__ccgo_up(in + uintptr(x)*4))
 		v3 = pred
 		alpha_and_green = v2&uint32(0xff00ff00) + v3&uint32(0xff00ff00)
 		red_and_blue = v2&uint32(0x00ff00ff) + v3&uint32(0x00ff00ff)
 		v4 = alpha_and_green&uint32(0xff00ff00) | red_and_blue&uint32(0x00ff00ff)
 		goto _5
 	_5:
 		**(**uint32_t)(__ccgo_up(out + uintptr(x)*4)) = v4
 		goto _1
 	_1:
 		;
 		x = x + 1
 	}
 }
 
 func PredictorAdd7_C(tls *libc.TLS, in uintptr, upper uintptr, num_pixels int32, out uintptr) {
 	var alpha_and_green, pred, red_and_blue, v2, v3, v4 uint32_t
 	var x int32
 	_, _, _, _, _, _, _ = alpha_and_green, pred, red_and_blue, x, v2, v3, v4
 	x = 0
 	for {
 		if !(x < num_pixels) {
 			break
 		}
 		pred = VP8LPredictor7_C(tls, out+uintptr(x-int32(1))*4, upper+uintptr(x)*4)
 		v2 = **(**uint32_t)(__ccgo_up(in + uintptr(x)*4))
 		v3 = pred
 		alpha_and_green = v2&uint32(0xff00ff00) + v3&uint32(0xff00ff00)
 		red_and_blue = v2&uint32(0x00ff00ff) + v3&uint32(0x00ff00ff)
 		v4 = alpha_and_green&uint32(0xff00ff00) | red_and_blue&uint32(0x00ff00ff)
 		goto _5
 	_5:
 		**(**uint32_t)(__ccgo_up(out + uintptr(x)*4)) = v4
 		goto _1
 	_1:
 		;
 		x = x + 1
 	}
 }
 
 func PredictorAdd8_C(tls *libc.TLS, in uintptr, upper uintptr, num_pixels int32, out uintptr) {
 	var alpha_and_green, pred, red_and_blue, v2, v3, v4 uint32_t
 	var x int32
 	_, _, _, _, _, _, _ = alpha_and_green, pred, red_and_blue, x, v2, v3, v4
 	x = 0
 	for {
 		if !(x < num_pixels) {
 			break
 		}
 		pred = VP8LPredictor8_C(tls, out+uintptr(x-int32(1))*4, upper+uintptr(x)*4)
 		v2 = **(**uint32_t)(__ccgo_up(in + uintptr(x)*4))
 		v3 = pred
 		alpha_and_green = v2&uint32(0xff00ff00) + v3&uint32(0xff00ff00)
 		red_and_blue = v2&uint32(0x00ff00ff) + v3&uint32(0x00ff00ff)
 		v4 = alpha_and_green&uint32(0xff00ff00) | red_and_blue&uint32(0x00ff00ff)
 		goto _5
 	_5:
 		**(**uint32_t)(__ccgo_up(out + uintptr(x)*4)) = v4
 		goto _1
 	_1:
 		;
 		x = x + 1
 	}
 }
 
 func PredictorAdd9_C(tls *libc.TLS, in uintptr, upper uintptr, num_pixels int32, out uintptr) {
 	var alpha_and_green, pred, red_and_blue, v2, v3, v4 uint32_t
 	var x int32
 	_, _, _, _, _, _, _ = alpha_and_green, pred, red_and_blue, x, v2, v3, v4
 	x = 0
 	for {
 		if !(x < num_pixels) {
 			break
 		}
 		pred = VP8LPredictor9_C(tls, out+uintptr(x-int32(1))*4, upper+uintptr(x)*4)
 		v2 = **(**uint32_t)(__ccgo_up(in + uintptr(x)*4))
 		v3 = pred
 		alpha_and_green = v2&uint32(0xff00ff00) + v3&uint32(0xff00ff00)
 		red_and_blue = v2&uint32(0x00ff00ff) + v3&uint32(0x00ff00ff)
 		v4 = alpha_and_green&uint32(0xff00ff00) | red_and_blue&uint32(0x00ff00ff)
 		goto _5
 	_5:
 		**(**uint32_t)(__ccgo_up(out + uintptr(x)*4)) = v4
 		goto _1
 	_1:
 		;
 		x = x + 1
 	}
 }
 
 func PredictorAdd10_C(tls *libc.TLS, in uintptr, upper uintptr, num_pixels int32, out uintptr) {
 	var alpha_and_green, pred, red_and_blue, v2, v3, v4 uint32_t
 	var x int32
 	_, _, _, _, _, _, _ = alpha_and_green, pred, red_and_blue, x, v2, v3, v4
 	x = 0
 	for {
 		if !(x < num_pixels) {
 			break
 		}
 		pred = VP8LPredictor10_C(tls, out+uintptr(x-int32(1))*4, upper+uintptr(x)*4)
 		v2 = **(**uint32_t)(__ccgo_up(in + uintptr(x)*4))
 		v3 = pred
 		alpha_and_green = v2&uint32(0xff00ff00) + v3&uint32(0xff00ff00)
 		red_and_blue = v2&uint32(0x00ff00ff) + v3&uint32(0x00ff00ff)
 		v4 = alpha_and_green&uint32(0xff00ff00) | red_and_blue&uint32(0x00ff00ff)
 		goto _5
 	_5:
 		**(**uint32_t)(__ccgo_up(out + uintptr(x)*4)) = v4
 		goto _1
 	_1:
 		;
 		x = x + 1
 	}
 }
 
 func PredictorAdd11_C(tls *libc.TLS, in uintptr, upper uintptr, num_pixels int32, out uintptr) {
 	var alpha_and_green, pred, red_and_blue, v2, v3, v4 uint32_t
 	var x int32
 	_, _, _, _, _, _, _ = alpha_and_green, pred, red_and_blue, x, v2, v3, v4
 	x = 0
 	for {
 		if !(x < num_pixels) {
 			break
 		}
 		pred = VP8LPredictor11_C(tls, out+uintptr(x-int32(1))*4, upper+uintptr(x)*4)
 		v2 = **(**uint32_t)(__ccgo_up(in + uintptr(x)*4))
 		v3 = pred
 		alpha_and_green = v2&uint32(0xff00ff00) + v3&uint32(0xff00ff00)
 		red_and_blue = v2&uint32(0x00ff00ff) + v3&uint32(0x00ff00ff)
 		v4 = alpha_and_green&uint32(0xff00ff00) | red_and_blue&uint32(0x00ff00ff)
 		goto _5
 	_5:
 		**(**uint32_t)(__ccgo_up(out + uintptr(x)*4)) = v4
 		goto _1
 	_1:
 		;
 		x = x + 1
 	}
 }
 
 func PredictorAdd12_C(tls *libc.TLS, in uintptr, upper uintptr, num_pixels int32, out uintptr) {
 	var alpha_and_green, pred, red_and_blue, v2, v3, v4 uint32_t
 	var x int32
 	_, _, _, _, _, _, _ = alpha_and_green, pred, red_and_blue, x, v2, v3, v4
 	x = 0
 	for {
 		if !(x < num_pixels) {
 			break
 		}
 		pred = VP8LPredictor12_C(tls, out+uintptr(x-int32(1))*4, upper+uintptr(x)*4)
 		v2 = **(**uint32_t)(__ccgo_up(in + uintptr(x)*4))
 		v3 = pred
 		alpha_and_green = v2&uint32(0xff00ff00) + v3&uint32(0xff00ff00)
 		red_and_blue = v2&uint32(0x00ff00ff) + v3&uint32(0x00ff00ff)
 		v4 = alpha_and_green&uint32(0xff00ff00) | red_and_blue&uint32(0x00ff00ff)
 		goto _5
 	_5:
 		**(**uint32_t)(__ccgo_up(out + uintptr(x)*4)) = v4
 		goto _1
 	_1:
 		;
 		x = x + 1
 	}
 }
 
 func PredictorAdd13_C(tls *libc.TLS, in uintptr, upper uintptr, num_pixels int32, out uintptr) {
 	var alpha_and_green, pred, red_and_blue, v2, v3, v4 uint32_t
 	var x int32
 	_, _, _, _, _, _, _ = alpha_and_green, pred, red_and_blue, x, v2, v3, v4
 	x = 0
 	for {
 		if !(x < num_pixels) {
 			break
 		}
 		pred = VP8LPredictor13_C(tls, out+uintptr(x-int32(1))*4, upper+uintptr(x)*4)
 		v2 = **(**uint32_t)(__ccgo_up(in + uintptr(x)*4))
 		v3 = pred
 		alpha_and_green = v2&uint32(0xff00ff00) + v3&uint32(0xff00ff00)
 		red_and_blue = v2&uint32(0x00ff00ff) + v3&uint32(0x00ff00ff)
 		v4 = alpha_and_green&uint32(0xff00ff00) | red_and_blue&uint32(0x00ff00ff)
 		goto _5
 	_5:
 		**(**uint32_t)(__ccgo_up(out + uintptr(x)*4)) = v4
 		goto _1
 	_1:
 		;
 		x = x + 1
 	}
 }
 
 //------------------------------------------------------------------------------
 
 // C documentation
 //
 //	// Inverse prediction.
 func PredictorInverseTransform_C(tls *libc.TLS, transform uintptr, y_start int32, y_end int32, in uintptr, out uintptr) {
 	var mask, tile_width, tiles_per_row, width, x, x_end, y int32
 	var pred_func VP8LPredictorAddSubFunc
 	var pred_mode_base, pred_mode_src, v4 uintptr
 	var v1, v2 uint32_t
 	_, _, _, _, _, _, _, _, _, _, _, _, _ = mask, pred_func, pred_mode_base, pred_mode_src, tile_width, tiles_per_row, width, x, x_end, y, v1, v2, v4
 	width = (*VP8LTransform)(unsafe.Pointer(transform)).Fxsize
 	if y_start == 0 { // First Row follows the L (mode=1) mode.
 		PredictorAdd0_C(tls, in, libc.UintptrFromInt32(0), int32(1), out)
 		PredictorAdd1_C(tls, in+uintptr(1)*4, libc.UintptrFromInt32(0), width-int32(1), out+uintptr(1)*4)
 		in = in + uintptr(width)*4
 		out = out + uintptr(width)*4
 		y_start = y_start + 1
 	}
 	y = y_start
 	tile_width = int32(1) << (*VP8LTransform)(unsafe.Pointer(transform)).Fbits
 	mask = tile_width - int32(1)
 	v1 = libc.Uint32FromInt32((*VP8LTransform)(unsafe.Pointer(transform)).Fbits)
 	v2 = (libc.Uint32FromInt32(width) + libc.Uint32FromInt32(libc.Int32FromInt32(1)<<v1) - uint32(1)) >> v1
 	goto _3
 _3:
 	tiles_per_row = libc.Int32FromUint32(v2)
 	pred_mode_base = (*VP8LTransform)(unsafe.Pointer(transform)).Fdata + uintptr(y>>(*VP8LTransform)(unsafe.Pointer(transform)).Fbits*tiles_per_row)*4
 	for y < y_end {
 		pred_mode_src = pred_mode_base
 		x = int32(1)
 		// First pixel follows the T (mode=2) mode.
 		PredictorAdd2_C(tls, in, out-uintptr(width)*4, int32(1), out)
 		// .. the rest:
 		for x < width {
 			v4 = pred_mode_src
 			pred_mode_src += 4
 			pred_func = VP8LPredictorsAdd[**(**uint32_t)(__ccgo_up(v4))>>libc.Int32FromInt32(8)&uint32(0xf)]
 			x_end = x & ^mask + tile_width
 			if x_end > width {
 				x_end = width
 			}
 			(*(*func(*libc.TLS, uintptr, uintptr, int32, uintptr))(unsafe.Pointer(&struct{ uintptr }{pred_func})))(tls, in+uintptr(x)*4, out+uintptr(x)*4-uintptr(width)*4, x_end-x, out+uintptr(x)*4)
 			x = x_end
 		}
 		in = in + uintptr(width)*4
 		out = out + uintptr(width)*4
 		y = y + 1
 		if y&mask == 0 { // Use the same mask, since tiles are squares.
 			pred_mode_base = pred_mode_base + uintptr(tiles_per_row)*4
 		}
 	}
 }
 
 // C documentation
 //
 //	// Add green to blue and red channels (i.e. perform the inverse transform of
 //	// 'subtract green').
 func VP8LAddGreenToBlueAndRed_C(tls *libc.TLS, src uintptr, num_pixels int32, dst uintptr) {
 	var argb, green, red_blue uint32_t
 	var i int32
 	_, _, _, _ = argb, green, i, red_blue
 	i = 0
 	for {
 		if !(i < num_pixels) {
 			break
 		}
 		argb = **(**uint32_t)(__ccgo_up(src + uintptr(i)*4))
 		green = argb >> libc.Int32FromInt32(8) & libc.Uint32FromInt32(0xff)
 		red_blue = argb & libc.Uint32FromUint32(0x00ff00ff)
 		red_blue = red_blue + (green<<libc.Int32FromInt32(16) | green)
 		red_blue = red_blue & uint32(0x00ff00ff)
 		**(**uint32_t)(__ccgo_up(dst + uintptr(i)*4)) = argb&uint32(0xff00ff00) | red_blue
 		goto _1
 	_1:
 		;
 		i = i + 1
 	}
 }
 
 func ColorTransformDelta(tls *libc.TLS, color_pred int8_t, color int8_t) (r int32) {
 	return int32(color_pred) * int32(color) >> int32(5)
 }
 
 func ColorCodeToMultipliers1(tls *libc.TLS, color_code uint32_t, m uintptr) {
 	(*VP8LMultipliers)(unsafe.Pointer(m)).Fgreen_to_red = uint8(color_code >> libc.Int32FromInt32(0) & uint32(0xff))
 	(*VP8LMultipliers)(unsafe.Pointer(m)).Fgreen_to_blue = uint8(color_code >> libc.Int32FromInt32(8) & uint32(0xff))
 	(*VP8LMultipliers)(unsafe.Pointer(m)).Fred_to_blue = uint8(color_code >> libc.Int32FromInt32(16) & uint32(0xff))
 }
 
 func VP8LTransformColorInverse_C(tls *libc.TLS, m uintptr, src uintptr, num_pixels int32, dst uintptr) {
 	var argb, red uint32_t
 	var green int8_t
 	var i, new_blue, new_red int32
 	_, _, _, _, _, _ = argb, green, i, new_blue, new_red, red
 	i = 0
 	for {
 		if !(i < num_pixels) {
 			break
 		}
 		argb = **(**uint32_t)(__ccgo_up(src + uintptr(i)*4))
 		green = libc.Int8FromUint32(argb >> libc.Int32FromInt32(8))
 		red = argb >> int32(16)
 		new_red = libc.Int32FromUint32(red & uint32(0xff))
 		new_blue = libc.Int32FromUint32(argb & uint32(0xff))
 		new_red = new_red + ColorTransformDelta(tls, libc.Int8FromUint8((*VP8LMultipliers)(unsafe.Pointer(m)).Fgreen_to_red), green)
 		new_red = new_red & int32(0xff)
 		new_blue = new_blue + ColorTransformDelta(tls, libc.Int8FromUint8((*VP8LMultipliers)(unsafe.Pointer(m)).Fgreen_to_blue), green)
 		new_blue = new_blue + ColorTransformDelta(tls, libc.Int8FromUint8((*VP8LMultipliers)(unsafe.Pointer(m)).Fred_to_blue), int8(new_red))
 		new_blue = new_blue & int32(0xff)
 		**(**uint32_t)(__ccgo_up(dst + uintptr(i)*4)) = argb&uint32(0xff00ff00) | libc.Uint32FromInt32(new_red<<libc.Int32FromInt32(16)) | libc.Uint32FromInt32(new_blue)
 		goto _1
 	_1:
 		;
 		i = i + 1
 	}
 }
 
 // C documentation
 //
 //	// Color space inverse transform.
 func ColorSpaceInverseTransform_C(tls *libc.TLS, transform uintptr, y_start int32, y_end int32, src uintptr, dst uintptr) {
 	bp := tls.Alloc(16)
 	defer tls.Free(16)
 	var mask, remaining_width, safe_width, tile_width, tiles_per_row, width, y int32
 	var pred, pred_row, src_end, src_safe_end, v4 uintptr
 	var v1, v2 uint32_t
 	var _ /* m at bp+0 */ VP8LMultipliers
 	_, _, _, _, _, _, _, _, _, _, _, _, _, _ = mask, pred, pred_row, remaining_width, safe_width, src_end, src_safe_end, tile_width, tiles_per_row, width, y, v1, v2, v4
 	width = (*VP8LTransform)(unsafe.Pointer(transform)).Fxsize
 	tile_width = int32(1) << (*VP8LTransform)(unsafe.Pointer(transform)).Fbits
 	mask = tile_width - int32(1)
 	safe_width = width & ^mask
 	remaining_width = width - safe_width
 	v1 = libc.Uint32FromInt32((*VP8LTransform)(unsafe.Pointer(transform)).Fbits)
 	v2 = (libc.Uint32FromInt32(width) + libc.Uint32FromInt32(libc.Int32FromInt32(1)<<v1) - uint32(1)) >> v1
 	goto _3
 _3:
 	tiles_per_row = libc.Int32FromUint32(v2)
 	y = y_start
 	pred_row = (*VP8LTransform)(unsafe.Pointer(transform)).Fdata + uintptr(y>>(*VP8LTransform)(unsafe.Pointer(transform)).Fbits*tiles_per_row)*4
 	for y < y_end {
 		pred = pred_row
 		**(**VP8LMultipliers)(__ccgo_up(bp)) = VP8LMultipliers{}
 		src_safe_end = src + uintptr(safe_width)*4
 		src_end = src + uintptr(width)*4
 		for src < src_safe_end {
 			v4 = pred
 			pred += 4
 			ColorCodeToMultipliers1(tls, **(**uint32_t)(__ccgo_up(v4)), bp)
 			(*(*func(*libc.TLS, uintptr, uintptr, int32, uintptr))(unsafe.Pointer(&struct{ uintptr }{VP8LTransformColorInverse})))(tls, bp, src, tile_width, dst)
 			src = src + uintptr(tile_width)*4
 			dst = dst + uintptr(tile_width)*4
 		}
 		if src < src_end { // Left-overs using C-version.
 			v4 = pred
 			pred += 4
 			ColorCodeToMultipliers1(tls, **(**uint32_t)(__ccgo_up(v4)), bp)
 			(*(*func(*libc.TLS, uintptr, uintptr, int32, uintptr))(unsafe.Pointer(&struct{ uintptr }{VP8LTransformColorInverse})))(tls, bp, src, remaining_width, dst)
 			src = src + uintptr(remaining_width)*4
 			dst = dst + uintptr(remaining_width)*4
 		}
 		y = y + 1
 		if y&mask == 0 {
 			pred_row = pred_row + uintptr(tiles_per_row)*4
 		}
 	}
 }
 
 // Separate out pixels packed together using pixel-bundling.
 // We define two methods for ARGB data (uint32_t) and alpha-only data (uint8_t).
 func MapARGB_C(tls *libc.TLS, src uintptr, color_map uintptr, dst uintptr, y_start int32, y_end int32, width int32) {
 	var x, y int32
 	var v3, v4 uintptr
 	var v5, v7 uint32_t
 	_, _, _, _, _, _ = x, y, v3, v4, v5, v7
 	y = y_start
 	for {
 		if !(y < y_end) {
 			break
 		}
 		x = 0
 		for {
 			if !(x < width) {
 				break
 			}
 			v3 = dst
 			dst += 4
 			v4 = src
 			src += 4
 			v5 = **(**uint32_t)(__ccgo_up(v4)) >> libc.Int32FromInt32(8) & uint32(0xff)
 			goto _6
 		_6:
 			v7 = **(**uint32_t)(__ccgo_up(color_map + uintptr(v5)*4))
 			goto _8
 		_8:
 			**(**uint32_t)(__ccgo_up(v3)) = v7
 			goto _2
 		_2:
 			;
 			x = x + 1
 		}
 		goto _1
 	_1:
 		;
 		y = y + 1
 	}
 }
 
 func ColorIndexInverseTransform_C(tls *libc.TLS, transform uintptr, y_start int32, y_end int32, src uintptr, dst uintptr) {
 	var bit_mask, packed_pixels, v4 uint32_t
 	var bits_per_pixel, count_mask, pixels_per_byte, width, x, y int32
 	var color_map, v3 uintptr
 	_, _, _, _, _, _, _, _, _, _, _ = bit_mask, bits_per_pixel, color_map, count_mask, packed_pixels, pixels_per_byte, width, x, y, v3, v4
 	bits_per_pixel = int32(8) >> (*VP8LTransform)(unsafe.Pointer(transform)).Fbits
 	width = (*VP8LTransform)(unsafe.Pointer(transform)).Fxsize
 	color_map = (*VP8LTransform)(unsafe.Pointer(transform)).Fdata
 	if bits_per_pixel < int32(8) {
 		pixels_per_byte = int32(1) << (*VP8LTransform)(unsafe.Pointer(transform)).Fbits
 		count_mask = pixels_per_byte - int32(1)
 		bit_mask = libc.Uint32FromInt32(int32(1)<<bits_per_pixel - int32(1))
 		y = y_start
 		for {
 			if !(y < y_end) {
 				break
 			}
 			packed_pixels = uint32(0)
 			x = 0
 			for {
 				if !(x < width) {
 					break
 				} /* We need to load fresh 'packed_pixels' once every                */ /* 'pixels_per_byte' increments of x. Fortunately, pixels_per_byte */ /* is a power of 2, so can just use a mask for that, instead of    */ /* decrementing a counter.                                         */
 				if x&count_mask == 0 {
 					v3 = src
 					src += 4
 					v4 = **(**uint32_t)(__ccgo_up(v3)) >> libc.Int32FromInt32(8) & uint32(0xff)
 					goto _5
 				_5:
 					packed_pixels = v4
 				}
 				v3 = dst
 				dst += 4
 				v4 = **(**uint32_t)(__ccgo_up(color_map + uintptr(packed_pixels&bit_mask)*4))
 				goto _8
 			_8:
 				**(**uint32_t)(__ccgo_up(v3)) = v4
 				packed_pixels = packed_pixels >> libc.Uint32FromInt32(bits_per_pixel)
 				goto _2
 			_2:
 				;
 				x = x + 1
 			}
 			goto _1
 		_1:
 			;
 			y = y + 1
 		}
 	} else {
 		(*(*func(*libc.TLS, uintptr, uintptr, uintptr, int32, int32, int32))(unsafe.Pointer(&struct{ uintptr }{VP8LMapColor32b})))(tls, src, color_map, dst, y_start, y_end, width)
 	}
 }
 
 func MapAlpha_C(tls *libc.TLS, src uintptr, color_map uintptr, dst uintptr, y_start int32, y_end int32, width int32) {
 	var x, y int32
 	var v3, v4 uintptr
 	var v5, v7 uint8_t
 	_, _, _, _, _, _ = x, y, v3, v4, v5, v7
 	y = y_start
 	for {
 		if !(y < y_end) {
 			break
 		}
 		x = 0
 		for {
 			if !(x < width) {
 				break
 			}
 			v3 = dst
 			dst = dst + 1
 			v4 = src
 			src = src + 1
 			v5 = **(**uint8_t)(__ccgo_up(v4))
 			goto _6
 		_6:
 			v7 = uint8(**(**uint32_t)(__ccgo_up(color_map + uintptr(v5)*4)) >> libc.Int32FromInt32(8) & uint32(0xff))
 			goto _8
 		_8:
 			**(**uint8_t)(__ccgo_up(v3)) = v7
 			goto _2
 		_2:
 			;
 			x = x + 1
 		}
 		goto _1
 	_1:
 		;
 		y = y + 1
 	}
 }
 
 func VP8LColorIndexInverseTransformAlpha(tls *libc.TLS, transform uintptr, y_start int32, y_end int32, src uintptr, dst uintptr) {
 	var bit_mask, packed_pixels uint32_t
 	var bits_per_pixel, count_mask, pixels_per_byte, width, x, y int32
 	var color_map, v3 uintptr
 	var v4 uint8_t
 	_, _, _, _, _, _, _, _, _, _, _ = bit_mask, bits_per_pixel, color_map, count_mask, packed_pixels, pixels_per_byte, width, x, y, v3, v4
 	bits_per_pixel = int32(8) >> (*VP8LTransform)(unsafe.Pointer(transform)).Fbits
 	width = (*VP8LTransform)(unsafe.Pointer(transform)).Fxsize
 	color_map = (*VP8LTransform)(unsafe.Pointer(transform)).Fdata
 	if bits_per_pixel < int32(8) {
 		pixels_per_byte = int32(1) << (*VP8LTransform)(unsafe.Pointer(transform)).Fbits
 		count_mask = pixels_per_byte - int32(1)
 		bit_mask = libc.Uint32FromInt32(int32(1)<<bits_per_pixel - int32(1))
 		y = y_start
 		for {
 			if !(y < y_end) {
 				break
 			}
 			packed_pixels = uint32(0)
 			x = 0
 			for {
 				if !(x < width) {
 					break
 				} /* We need to load fresh 'packed_pixels' once every                */ /* 'pixels_per_byte' increments of x. Fortunately, pixels_per_byte */ /* is a power of 2, so can just use a mask for that, instead of    */ /* decrementing a counter.                                         */
 				if x&count_mask == 0 {
 					v3 = src
 					src = src + 1
 					v4 = **(**uint8_t)(__ccgo_up(v3))
 					goto _5
 				_5:
 					packed_pixels = uint32(v4)
 				}
 				v3 = dst
 				dst = dst + 1
 				v4 = uint8(**(**uint32_t)(__ccgo_up(color_map + uintptr(packed_pixels&bit_mask)*4)) >> libc.Int32FromInt32(8) & uint32(0xff))
 				goto _8
 			_8:
 				**(**uint8_t)(__ccgo_up(v3)) = v4
 				packed_pixels = packed_pixels >> libc.Uint32FromInt32(bits_per_pixel)
 				goto _2
 			_2:
 				;
 				x = x + 1
 			}
 			goto _1
 		_1:
 			;
 			y = y + 1
 		}
 	} else {
 		(*(*func(*libc.TLS, uintptr, uintptr, uintptr, int32, int32, int32))(unsafe.Pointer(&struct{ uintptr }{VP8LMapColor8b})))(tls, src, color_map, dst, y_start, y_end, width)
 	}
 }
 
 func VP8LInverseTransform(tls *libc.TLS, transform uintptr, row_start int32, row_end int32, in uintptr, out uintptr) {
 	var in_stride, out_stride, width int32
 	var src uintptr
 	var v1, v2 uint32_t
 	_, _, _, _, _, _ = in_stride, out_stride, src, width, v1, v2
 	width = (*VP8LTransform)(unsafe.Pointer(transform)).Fxsize
 	switch (*VP8LTransform)(unsafe.Pointer(transform)).Ftype1 {
 	case int32(SUBTRACT_GREEN_TRANSFORM):
 		(*(*func(*libc.TLS, uintptr, int32, uintptr))(unsafe.Pointer(&struct{ uintptr }{VP8LAddGreenToBlueAndRed})))(tls, in, (row_end-row_start)*width, out)
 	case int32(PREDICTOR_TRANSFORM):
 		PredictorInverseTransform_C(tls, transform, row_start, row_end, in, out)
 		if row_end != (*VP8LTransform)(unsafe.Pointer(transform)).Fysize {
 			// The last predicted row in this iteration will be the top-pred row
 			// for the first row in next iteration.
 			libc.X__builtin___memcpy_chk(tls, out-uintptr(width)*4, out+uintptr((row_end-row_start-int32(1))*width)*4, libc.Uint64FromInt32(width)*uint64(4), ^__predefined_size_t(0))
 		}
 	case int32(CROSS_COLOR_TRANSFORM):
 		ColorSpaceInverseTransform_C(tls, transform, row_start, row_end, in, out)
 	case int32(COLOR_INDEXING_TRANSFORM):
 		if in == out && (*VP8LTransform)(unsafe.Pointer(transform)).Fbits > 0 {
 			// Move packed pixels to the end of unpacked region, so that unpacking
 			// can occur seamlessly.
 			// Also, note that this is the only transform that applies on
 			// the effective width of VP8LSubSampleSize(xsize, bits). All other
 			// transforms work on effective width of 'xsize'.
 			out_stride = (row_end - row_start) * width
 			v1 = libc.Uint32FromInt32((*VP8LTransform)(unsafe.Pointer(transform)).Fbits)
 			v2 = (libc.Uint32FromInt32((*VP8LTransform)(unsafe.Pointer(transform)).Fxsize) + libc.Uint32FromInt32(libc.Int32FromInt32(1)<<v1) - uint32(1)) >> v1
 			goto _3
 		_3:
 			in_stride = libc.Int32FromUint32(libc.Uint32FromInt32(row_end-row_start) * v2)
 			src = out + uintptr(out_stride)*4 - uintptr(in_stride)*4
 			libc.X__builtin___memmove_chk(tls, src, out, libc.Uint64FromInt32(in_stride)*uint64(4), ^__predefined_size_t(0))
 			ColorIndexInverseTransform_C(tls, transform, row_start, row_end, src, out)
 		} else {
 			ColorIndexInverseTransform_C(tls, transform, row_start, row_end, in, out)
 		}
 		break
 	}
 }
 
 //------------------------------------------------------------------------------
 // Color space conversion.
 
 func is_big_endian(tls *libc.TLS) (r int32) {
 	return libc.BoolInt32(libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(uintptr(unsafe.Pointer(&tmp))))) != int32(1))
 }
 
 var tmp = *(*struct {
 	Fb [0][2]uint8_t
 	Fw uint16_t
 })(unsafe.Pointer(&[1]uint16{0x1}))
 
 func VP8LConvertBGRAToRGB_C(tls *libc.TLS, src uintptr, num_pixels int32, dst uintptr) {
 	var argb uint32_t
 	var src_end, v1, v2 uintptr
 	_, _, _, _ = argb, src_end, v1, v2
 	src_end = src + uintptr(num_pixels)*4
 	for src < src_end {
 		v1 = src
 		src += 4
 		argb = **(**uint32_t)(__ccgo_up(v1))
 		v2 = dst
 		dst = dst + 1
 		**(**uint8_t)(__ccgo_up(v2)) = uint8(argb >> libc.Int32FromInt32(16) & uint32(0xff))
 		v1 = dst
 		dst = dst + 1
 		**(**uint8_t)(__ccgo_up(v1)) = uint8(argb >> libc.Int32FromInt32(8) & uint32(0xff))
 		v1 = dst
 		dst = dst + 1
 		**(**uint8_t)(__ccgo_up(v1)) = uint8(argb >> libc.Int32FromInt32(0) & uint32(0xff))
 	}
 }
 
 func VP8LConvertBGRAToRGBA_C(tls *libc.TLS, src uintptr, num_pixels int32, dst uintptr) {
 	var argb uint32_t
 	var src_end, v1, v2 uintptr
 	_, _, _, _ = argb, src_end, v1, v2
 	src_end = src + uintptr(num_pixels)*4
 	for src < src_end {
 		v1 = src
 		src += 4
 		argb = **(**uint32_t)(__ccgo_up(v1))
 		v2 = dst
 		dst = dst + 1
 		**(**uint8_t)(__ccgo_up(v2)) = uint8(argb >> libc.Int32FromInt32(16) & uint32(0xff))
 		v1 = dst
 		dst = dst + 1
 		**(**uint8_t)(__ccgo_up(v1)) = uint8(argb >> libc.Int32FromInt32(8) & uint32(0xff))
 		v1 = dst
 		dst = dst + 1
 		**(**uint8_t)(__ccgo_up(v1)) = uint8(argb >> libc.Int32FromInt32(0) & uint32(0xff))
 		v1 = dst
 		dst = dst + 1
 		**(**uint8_t)(__ccgo_up(v1)) = uint8(argb >> libc.Int32FromInt32(24) & uint32(0xff))
 	}
 }
 
 func VP8LConvertBGRAToRGBA4444_C(tls *libc.TLS, src uintptr, num_pixels int32, dst uintptr) {
 	var argb uint32_t
 	var ba, rg uint8_t
 	var src_end, v1, v2 uintptr
 	_, _, _, _, _, _ = argb, ba, rg, src_end, v1, v2
 	src_end = src + uintptr(num_pixels)*4
 	for src < src_end {
 		v1 = src
 		src += 4
 		argb = **(**uint32_t)(__ccgo_up(v1))
 		rg = uint8(argb>>libc.Int32FromInt32(16)&uint32(0xf0) | argb>>libc.Int32FromInt32(12)&uint32(0xf))
 		ba = uint8(argb>>libc.Int32FromInt32(0)&uint32(0xf0) | argb>>libc.Int32FromInt32(28)&uint32(0xf))
 		v2 = dst
 		dst = dst + 1
 		**(**uint8_t)(__ccgo_up(v2)) = rg
 		v1 = dst
 		dst = dst + 1
 		**(**uint8_t)(__ccgo_up(v1)) = ba
 	}
 }
 
 func VP8LConvertBGRAToRGB565_C(tls *libc.TLS, src uintptr, num_pixels int32, dst uintptr) {
 	var argb uint32_t
 	var gb, rg uint8_t
 	var src_end, v1, v2 uintptr
 	_, _, _, _, _, _ = argb, gb, rg, src_end, v1, v2
 	src_end = src + uintptr(num_pixels)*4
 	for src < src_end {
 		v1 = src
 		src += 4
 		argb = **(**uint32_t)(__ccgo_up(v1))
 		rg = uint8(argb>>libc.Int32FromInt32(16)&uint32(0xf8) | argb>>libc.Int32FromInt32(13)&uint32(0x7))
 		gb = uint8(argb>>libc.Int32FromInt32(5)&uint32(0xe0) | argb>>libc.Int32FromInt32(3)&uint32(0x1f))
 		v2 = dst
 		dst = dst + 1
 		**(**uint8_t)(__ccgo_up(v2)) = rg
 		v1 = dst
 		dst = dst + 1
 		**(**uint8_t)(__ccgo_up(v1)) = gb
 	}
 }
 
 func VP8LConvertBGRAToBGR_C(tls *libc.TLS, src uintptr, num_pixels int32, dst uintptr) {
 	var argb uint32_t
 	var src_end, v1, v2 uintptr
 	_, _, _, _ = argb, src_end, v1, v2
 	src_end = src + uintptr(num_pixels)*4
 	for src < src_end {
 		v1 = src
 		src += 4
 		argb = **(**uint32_t)(__ccgo_up(v1))
 		v2 = dst
 		dst = dst + 1
 		**(**uint8_t)(__ccgo_up(v2)) = uint8(argb >> libc.Int32FromInt32(0) & uint32(0xff))
 		v1 = dst
 		dst = dst + 1
 		**(**uint8_t)(__ccgo_up(v1)) = uint8(argb >> libc.Int32FromInt32(8) & uint32(0xff))
 		v1 = dst
 		dst = dst + 1
 		**(**uint8_t)(__ccgo_up(v1)) = uint8(argb >> libc.Int32FromInt32(16) & uint32(0xff))
 	}
 }
 
 func CopyOrSwap(tls *libc.TLS, src uintptr, num_pixels int32, dst uintptr, swap_on_big_endian int32) {
 	bp := tls.Alloc(16)
 	defer tls.Free(16)
 	var argb, v2, v5 uint32_t
 	var src_end, v1, v4 uintptr
 	_, _, _, _, _, _ = argb, src_end, v1, v2, v4, v5
 	if is_big_endian(tls) == swap_on_big_endian {
 		src_end = src + uintptr(num_pixels)*4
 		for src < src_end {
 			v1 = src
 			src += 4
 			argb = **(**uint32_t)(__ccgo_up(v1))
 			v2 = libc.X__builtin_bswap32(tls, argb)
 			goto _3
 		_3:
 			v4 = dst
 			v5 = v2
 			*(*uint32_t)(unsafe.Pointer(bp)) = v5
 			libc.X__builtin___memcpy_chk(tls, v4, bp, uint64(4), ^__predefined_size_t(0))
 			dst = dst + uintptr(4)
 		}
 	} else {
 		libc.X__builtin___memcpy_chk(tls, dst, src, libc.Uint64FromInt32(num_pixels)*uint64(4), ^__predefined_size_t(0))
 	}
 }
 
 func VP8LConvertFromBGRA(tls *libc.TLS, in_data uintptr, num_pixels int32, out_colorspace WEBP_CSP_MODE1, rgba uintptr) {
 	switch out_colorspace {
 	case int32(MODE_RGB):
 		(*(*func(*libc.TLS, uintptr, int32, uintptr))(unsafe.Pointer(&struct{ uintptr }{VP8LConvertBGRAToRGB})))(tls, in_data, num_pixels, rgba)
 	case int32(MODE_RGBA):
 		(*(*func(*libc.TLS, uintptr, int32, uintptr))(unsafe.Pointer(&struct{ uintptr }{VP8LConvertBGRAToRGBA})))(tls, in_data, num_pixels, rgba)
 	case int32(MODE_rgbA):
 		(*(*func(*libc.TLS, uintptr, int32, uintptr))(unsafe.Pointer(&struct{ uintptr }{VP8LConvertBGRAToRGBA})))(tls, in_data, num_pixels, rgba)
 		(*(*func(*libc.TLS, uintptr, int32, int32, int32, int32))(unsafe.Pointer(&struct{ uintptr }{WebPApplyAlphaMultiply})))(tls, rgba, 0, num_pixels, int32(1), 0)
 	case int32(MODE_BGR):
 		(*(*func(*libc.TLS, uintptr, int32, uintptr))(unsafe.Pointer(&struct{ uintptr }{VP8LConvertBGRAToBGR})))(tls, in_data, num_pixels, rgba)
 	case int32(MODE_BGRA):
 		CopyOrSwap(tls, in_data, num_pixels, rgba, int32(1))
 	case int32(MODE_bgrA):
 		CopyOrSwap(tls, in_data, num_pixels, rgba, int32(1))
 		(*(*func(*libc.TLS, uintptr, int32, int32, int32, int32))(unsafe.Pointer(&struct{ uintptr }{WebPApplyAlphaMultiply})))(tls, rgba, 0, num_pixels, int32(1), 0)
 	case int32(MODE_ARGB):
 		CopyOrSwap(tls, in_data, num_pixels, rgba, 0)
 	case int32(MODE_Argb):
 		CopyOrSwap(tls, in_data, num_pixels, rgba, 0)
 		(*(*func(*libc.TLS, uintptr, int32, int32, int32, int32))(unsafe.Pointer(&struct{ uintptr }{WebPApplyAlphaMultiply})))(tls, rgba, int32(1), num_pixels, int32(1), 0)
 	case int32(MODE_RGBA_4444):
 		(*(*func(*libc.TLS, uintptr, int32, uintptr))(unsafe.Pointer(&struct{ uintptr }{VP8LConvertBGRAToRGBA4444})))(tls, in_data, num_pixels, rgba)
 	case int32(MODE_rgbA_4444):
 		(*(*func(*libc.TLS, uintptr, int32, uintptr))(unsafe.Pointer(&struct{ uintptr }{VP8LConvertBGRAToRGBA4444})))(tls, in_data, num_pixels, rgba)
 		(*(*func(*libc.TLS, uintptr, int32, int32, int32))(unsafe.Pointer(&struct{ uintptr }{WebPApplyAlphaMultiply4444})))(tls, rgba, num_pixels, int32(1), 0)
 	case int32(MODE_RGB_565):
 		(*(*func(*libc.TLS, uintptr, int32, uintptr))(unsafe.Pointer(&struct{ uintptr }{VP8LConvertBGRAToRGB565})))(tls, in_data, num_pixels, rgba)
 	default:
 		// Code flow should not reach here.
 	}
 }
 
 func VP8LDspInit(tls *libc.TLS) {
 	if libc.AtomicLoadPUintptr(uintptr(unsafe.Pointer(&VP8LDspInit_body_last_cpuinfo_used))) == VP8GetCPUInfo {
 		goto _1
 	}
 	VP8LDspInit_body(tls)
 	libc.AtomicStorePUintptr(uintptr(unsafe.Pointer(&VP8LDspInit_body_last_cpuinfo_used)), VP8GetCPUInfo)
 	goto _2
 _2:
 	;
 	goto _1
 _1: /**/ //
 }
 
 var VP8LDspInit_body_last_cpuinfo_used = uintptr(0)
 
 func init() {
 	p := unsafe.Pointer(&VP8LDspInit_body_last_cpuinfo_used)
 	*(*uintptr)(unsafe.Add(p, 0)) = uintptr(unsafe.Pointer(&VP8LDspInit_body_last_cpuinfo_used))
 }
 
 func VP8LDspInit_body(tls *libc.TLS) {
 	VP8LPredictors[0] = __ccgo_fp(VP8LPredictor0_C)
 	VP8LPredictors[int32(1)] = __ccgo_fp(VP8LPredictor1_C)
 	VP8LPredictors[int32(2)] = __ccgo_fp(VP8LPredictor2_C)
 	VP8LPredictors[int32(3)] = __ccgo_fp(VP8LPredictor3_C)
 	VP8LPredictors[int32(4)] = __ccgo_fp(VP8LPredictor4_C)
 	VP8LPredictors[int32(5)] = __ccgo_fp(VP8LPredictor5_C)
 	VP8LPredictors[int32(6)] = __ccgo_fp(VP8LPredictor6_C)
 	VP8LPredictors[int32(7)] = __ccgo_fp(VP8LPredictor7_C)
 	VP8LPredictors[int32(8)] = __ccgo_fp(VP8LPredictor8_C)
 	VP8LPredictors[int32(9)] = __ccgo_fp(VP8LPredictor9_C)
 	VP8LPredictors[int32(10)] = __ccgo_fp(VP8LPredictor10_C)
 	VP8LPredictors[int32(11)] = __ccgo_fp(VP8LPredictor11_C)
 	VP8LPredictors[int32(12)] = __ccgo_fp(VP8LPredictor12_C)
 	VP8LPredictors[int32(13)] = __ccgo_fp(VP8LPredictor13_C)
 	VP8LPredictors[int32(14)] = __ccgo_fp(VP8LPredictor0_C) /* <- padding security sentinels*/
 	VP8LPredictors[int32(15)] = __ccgo_fp(VP8LPredictor0_C)
 	VP8LPredictorsAdd[0] = __ccgo_fp(PredictorAdd0_C)
 	VP8LPredictorsAdd[int32(1)] = __ccgo_fp(PredictorAdd1_C)
 	VP8LPredictorsAdd[int32(2)] = __ccgo_fp(PredictorAdd2_C)
 	VP8LPredictorsAdd[int32(3)] = __ccgo_fp(PredictorAdd3_C)
 	VP8LPredictorsAdd[int32(4)] = __ccgo_fp(PredictorAdd4_C)
 	VP8LPredictorsAdd[int32(5)] = __ccgo_fp(PredictorAdd5_C)
 	VP8LPredictorsAdd[int32(6)] = __ccgo_fp(PredictorAdd6_C)
 	VP8LPredictorsAdd[int32(7)] = __ccgo_fp(PredictorAdd7_C)
 	VP8LPredictorsAdd[int32(8)] = __ccgo_fp(PredictorAdd8_C)
 	VP8LPredictorsAdd[int32(9)] = __ccgo_fp(PredictorAdd9_C)
 	VP8LPredictorsAdd[int32(10)] = __ccgo_fp(PredictorAdd10_C)
 	VP8LPredictorsAdd[int32(11)] = __ccgo_fp(PredictorAdd11_C)
 	VP8LPredictorsAdd[int32(12)] = __ccgo_fp(PredictorAdd12_C)
 	VP8LPredictorsAdd[int32(13)] = __ccgo_fp(PredictorAdd13_C)
 	VP8LPredictorsAdd[int32(14)] = __ccgo_fp(PredictorAdd0_C) /* <- padding security sentinels*/
 	VP8LPredictorsAdd[int32(15)] = __ccgo_fp(PredictorAdd0_C)
 	VP8LPredictorsAdd_C[0] = __ccgo_fp(PredictorAdd0_C)
 	VP8LPredictorsAdd_C[int32(1)] = __ccgo_fp(PredictorAdd1_C)
 	VP8LPredictorsAdd_C[int32(2)] = __ccgo_fp(PredictorAdd2_C)
 	VP8LPredictorsAdd_C[int32(3)] = __ccgo_fp(PredictorAdd3_C)
 	VP8LPredictorsAdd_C[int32(4)] = __ccgo_fp(PredictorAdd4_C)
 	VP8LPredictorsAdd_C[int32(5)] = __ccgo_fp(PredictorAdd5_C)
 	VP8LPredictorsAdd_C[int32(6)] = __ccgo_fp(PredictorAdd6_C)
 	VP8LPredictorsAdd_C[int32(7)] = __ccgo_fp(PredictorAdd7_C)
 	VP8LPredictorsAdd_C[int32(8)] = __ccgo_fp(PredictorAdd8_C)
 	VP8LPredictorsAdd_C[int32(9)] = __ccgo_fp(PredictorAdd9_C)
 	VP8LPredictorsAdd_C[int32(10)] = __ccgo_fp(PredictorAdd10_C)
 	VP8LPredictorsAdd_C[int32(11)] = __ccgo_fp(PredictorAdd11_C)
 	VP8LPredictorsAdd_C[int32(12)] = __ccgo_fp(PredictorAdd12_C)
 	VP8LPredictorsAdd_C[int32(13)] = __ccgo_fp(PredictorAdd13_C)
 	VP8LPredictorsAdd_C[int32(14)] = __ccgo_fp(PredictorAdd0_C) /* <- padding security sentinels*/
 	VP8LPredictorsAdd_C[int32(15)] = __ccgo_fp(PredictorAdd0_C)
 	VP8LAddGreenToBlueAndRed = __ccgo_fp(VP8LAddGreenToBlueAndRed_C)
 	VP8LTransformColorInverse = __ccgo_fp(VP8LTransformColorInverse_C)
 	VP8LConvertBGRAToRGBA = __ccgo_fp(VP8LConvertBGRAToRGBA_C)
 	VP8LConvertBGRAToRGB = __ccgo_fp(VP8LConvertBGRAToRGB_C)
 	VP8LConvertBGRAToBGR = __ccgo_fp(VP8LConvertBGRAToBGR_C)
 	VP8LConvertBGRAToRGBA4444 = __ccgo_fp(VP8LConvertBGRAToRGBA4444_C)
 	VP8LConvertBGRAToRGB565 = __ccgo_fp(VP8LConvertBGRAToRGB565_C)
 	VP8LMapColor32b = __ccgo_fp(MapARGB_C)
 	VP8LMapColor8b = __ccgo_fp(MapAlpha_C)
 	// If defined, use CPUInfo() to overwrite some pointers with faster versions.
 	if VP8GetCPUInfo != libc.UintptrFromInt32(0) {
 	}
 }
 
 func VP8LEncDspInitAVX2(tls *libc.TLS) {
 }
 
 const LOG_2_RECIPROCAL_FIXED_DOUBLE1 = 1.2102203161561485e+07
 const __FLT_MIN__11 = 1.1754943508222875e-38
 
 func FastSLog2Slow_C(tls *libc.TLS, v uint32_t) (r uint64_t) {
 	var correction, log_cnt, orig_v uint64_t
 	var y uint32_t
 	var v1 int32
 	_, _, _, _, _ = correction, log_cnt, orig_v, y, v1
 	if v < uint32(APPROX_LOG_WITH_CORRECTION_MAX) {
 		orig_v = uint64(v)
 		v1 = int32(31) ^ libc.X__builtin_clz(tls, v)
 		goto _2
 	_2:
 		// use clz if available
 		log_cnt = libc.Uint64FromInt32(v1 - int32(7))
 		y = libc.Uint32FromInt32(int32(1) << log_cnt)
 		v = uint32(uint64(v) >> log_cnt)
 		// vf = (2^log_cnt) * Xf; where y = 2^log_cnt and Xf < 256
 		// Xf = floor(Xf) * (1 + (v % y) / v)
 		// log2(Xf) = log2(floor(Xf)) + log2(1 + (v % y) / v)
 		// The correction factor: log(1 + d) ~ d; for very small d values, so
 		// log2(1 + (v % y) / v) ~ LOG_2_RECIPROCAL * (v % y)/v
 		correction = libc.Uint64FromInt32(12102203) * (orig_v & uint64(y-libc.Uint32FromInt32(1)))
 		return orig_v*(uint64(kLog2Table[v])+log_cnt<<libc.Int32FromInt32(LOG_2_PRECISION_BITS)) + correction
 	} else {
 		return uint64(float64(float64(libc.Float64FromFloat64(1.2102203161561485e+07)*float64(v))*libc.Xlog(tls, float64(v))) + libc.Float64FromFloat64(0.5))
 	}
 	return r
 }
 
 func FastLog2Slow_C(tls *libc.TLS, v uint32_t) (r uint32_t) {
 	var correction uint64_t
 	var log_2, log_cnt, orig_v, y uint32_t
 	var v1 int32
 	var v3, v4, v5 int64_t
 	var v7 int64
 	_, _, _, _, _, _, _, _, _, _ = correction, log_2, log_cnt, orig_v, y, v1, v3, v4, v5, v7
 	if v < uint32(APPROX_LOG_WITH_CORRECTION_MAX) {
 		orig_v = v
 		v1 = int32(31) ^ libc.X__builtin_clz(tls, v)
 		goto _2
 	_2:
 		// use clz if available
 		log_cnt = libc.Uint32FromInt32(v1 - int32(7))
 		y = libc.Uint32FromInt32(int32(1) << log_cnt)
 		v = v >> log_cnt
 		log_2 = kLog2Table[v] + log_cnt<<libc.Int32FromInt32(LOG_2_PRECISION_BITS)
 		if orig_v >= uint32(APPROX_LOG_MAX) {
 			// Since the division is still expensive, add this correction factor only
 			// for large values of 'v'.
 			correction = libc.Uint64FromInt32(12102203) * uint64(orig_v&(y-libc.Uint32FromInt32(1)))
 			v3 = libc.Int64FromUint64(correction)
 			v4 = libc.Int64FromUint32(orig_v)
 			if libc.BoolInt32(v3 < 0) == libc.BoolInt32(v4 < 0) {
 				v7 = (v3 + v4/int64(2)) / v4
 			} else {
 				v7 = (v3 - v4/int64(2)) / v4
 			}
 			v5 = v7
 			goto _6
 		_6:
 			log_2 = log_2 + libc.Uint32FromInt64(v5)
 		}
 		return log_2
 	} else {
 		return uint32(float64(libc.Float64FromFloat64(1.2102203161561485e+07)*libc.Xlog(tls, float64(v))) + libc.Float64FromFloat64(0.5))
 	}
 	return r
 }
 
 //------------------------------------------------------------------------------
 // Methods to calculate Entropy (Shannon).
 
 // C documentation
 //
 //	// Compute the combined Shanon's entropy for distribution {X} and {X+Y}
 func CombinedShannonEntropy_C(tls *libc.TLS, X uintptr, Y uintptr) (r uint64_t) {
 	var i int32
 	var retval, v3, v7 uint64_t
 	var sumX, sumXY, x, xy, v2, v6 uint32_t
 	var v5, v9 uint64
 	_, _, _, _, _, _, _, _, _, _, _, _ = i, retval, sumX, sumXY, x, xy, v2, v3, v5, v6, v7, v9
 	retval = uint64(0)
 	sumX = uint32(0)
 	sumXY = uint32(0)
 	i = 0
 	for {
 		if !(i < int32(256)) {
 			break
 		}
 		x = **(**uint32_t)(__ccgo_up(X + uintptr(i)*4))
 		if x != uint32(0) {
 			xy = x + **(**uint32_t)(__ccgo_up(Y + uintptr(i)*4))
 			sumX = sumX + x
 			v2 = x
 			if v2 < uint32(LOG_LOOKUP_IDX_MAX) {
 				v5 = kSLog2Table[v2]
 			} else {
 				v5 = (*(*func(*libc.TLS, uint32_t) uint64_t)(unsafe.Pointer(&struct{ uintptr }{VP8LFastSLog2Slow})))(tls, v2)
 			}
 			v3 = v5
 			goto _4
 		_4:
 			retval = retval + v3
 			sumXY = sumXY + xy
 			v2 = xy
 			if v2 < uint32(LOG_LOOKUP_IDX_MAX) {
 				v5 = kSLog2Table[v2]
 			} else {
 				v5 = (*(*func(*libc.TLS, uint32_t) uint64_t)(unsafe.Pointer(&struct{ uintptr }{VP8LFastSLog2Slow})))(tls, v2)
 			}
 			v3 = v5
 			goto _8
 		_8:
 			retval = retval + v3
 		} else {
 			if **(**uint32_t)(__ccgo_up(Y + uintptr(i)*4)) != uint32(0) {
 				sumXY = sumXY + **(**uint32_t)(__ccgo_up(Y + uintptr(i)*4))
 				v2 = **(**uint32_t)(__ccgo_up(Y + uintptr(i)*4))
 				if v2 < uint32(LOG_LOOKUP_IDX_MAX) {
 					v5 = kSLog2Table[v2]
 				} else {
 					v5 = (*(*func(*libc.TLS, uint32_t) uint64_t)(unsafe.Pointer(&struct{ uintptr }{VP8LFastSLog2Slow})))(tls, v2)
 				}
 				v3 = v5
 				goto _12
 			_12:
 				retval = retval + v3
 			}
 		}
 		goto _1
 	_1:
 		;
 		i = i + 1
 	}
 	v2 = sumX
 	if v2 < uint32(LOG_LOOKUP_IDX_MAX) {
 		v5 = kSLog2Table[v2]
 	} else {
 		v5 = (*(*func(*libc.TLS, uint32_t) uint64_t)(unsafe.Pointer(&struct{ uintptr }{VP8LFastSLog2Slow})))(tls, v2)
 	}
 	v3 = v5
 	goto _16
 _16:
 	v6 = sumXY
 	if v6 < uint32(LOG_LOOKUP_IDX_MAX) {
 		v9 = kSLog2Table[v6]
 	} else {
 		v9 = (*(*func(*libc.TLS, uint32_t) uint64_t)(unsafe.Pointer(&struct{ uintptr }{VP8LFastSLog2Slow})))(tls, v6)
 	}
 	v7 = v9
 	goto _20
 _20:
 	retval = v3 + v7 - retval
 	return retval
 }
 
 func ShannonEntropy_C(tls *libc.TLS, X uintptr, n int32) (r uint64_t) {
 	var i, x int32
 	var retval, v3 uint64_t
 	var sumX, v2 uint32_t
 	var v5 uint64
 	_, _, _, _, _, _, _ = i, retval, sumX, x, v2, v3, v5
 	retval = uint64(0)
 	sumX = uint32(0)
 	i = 0
 	for {
 		if !(i < n) {
 			break
 		}
 		x = libc.Int32FromUint32(**(**uint32_t)(__ccgo_up(X + uintptr(i)*4)))
 		if x != 0 {
 			sumX = sumX + libc.Uint32FromInt32(x)
 			v2 = libc.Uint32FromInt32(x)
 			if v2 < uint32(LOG_LOOKUP_IDX_MAX) {
 				v5 = kSLog2Table[v2]
 			} else {
 				v5 = (*(*func(*libc.TLS, uint32_t) uint64_t)(unsafe.Pointer(&struct{ uintptr }{VP8LFastSLog2Slow})))(tls, v2)
 			}
 			v3 = v5
 			goto _4
 		_4:
 			retval = retval + v3
 		}
 		goto _1
 	_1:
 		;
 		i = i + 1
 	}
 	v2 = sumX
 	if v2 < uint32(LOG_LOOKUP_IDX_MAX) {
 		v5 = kSLog2Table[v2]
 	} else {
 		v5 = (*(*func(*libc.TLS, uint32_t) uint64_t)(unsafe.Pointer(&struct{ uintptr }{VP8LFastSLog2Slow})))(tls, v2)
 	}
 	v3 = v5
 	goto _8
 _8:
 	retval = v3 - retval
 	return retval
 }
 
 func VP8LBitEntropyInit(tls *libc.TLS, entropy uintptr) {
 	(*VP8LBitEntropy)(unsafe.Pointer(entropy)).Fentropy = uint64(0)
 	(*VP8LBitEntropy)(unsafe.Pointer(entropy)).Fsum = uint32(0)
 	(*VP8LBitEntropy)(unsafe.Pointer(entropy)).Fnonzeros = 0
 	(*VP8LBitEntropy)(unsafe.Pointer(entropy)).Fmax_val = uint32(0)
 	(*VP8LBitEntropy)(unsafe.Pointer(entropy)).Fnonzero_code = uint32(libc.Uint16FromInt32(libc.Int32FromInt32(0xffff)))
 }
 
 func VP8LBitsEntropyUnrefined(tls *libc.TLS, array uintptr, n int32, entropy uintptr) {
 	var i int32
 	var v2 uint32_t
 	var v3 uint64_t
 	var v5 uint64
 	_, _, _, _ = i, v2, v3, v5
 	VP8LBitEntropyInit(tls, entropy)
 	i = 0
 	for {
 		if !(i < n) {
 			break
 		}
 		if **(**uint32_t)(__ccgo_up(array + uintptr(i)*4)) != uint32(0) {
 			**(**uint32_t)(__ccgo_up(entropy + 8)) += **(**uint32_t)(__ccgo_up(array + uintptr(i)*4))
 			(*VP8LBitEntropy)(unsafe.Pointer(entropy)).Fnonzero_code = libc.Uint32FromInt32(i)
 			(*VP8LBitEntropy)(unsafe.Pointer(entropy)).Fnonzeros = (*VP8LBitEntropy)(unsafe.Pointer(entropy)).Fnonzeros + 1
 			v2 = **(**uint32_t)(__ccgo_up(array + uintptr(i)*4))
 			if v2 < uint32(LOG_LOOKUP_IDX_MAX) {
 				v5 = kSLog2Table[v2]
 			} else {
 				v5 = (*(*func(*libc.TLS, uint32_t) uint64_t)(unsafe.Pointer(&struct{ uintptr }{VP8LFastSLog2Slow})))(tls, v2)
 			}
 			v3 = v5
 			goto _4
 		_4:
 			**(**uint64_t)(__ccgo_up(entropy)) += v3
 			if (*VP8LBitEntropy)(unsafe.Pointer(entropy)).Fmax_val < **(**uint32_t)(__ccgo_up(array + uintptr(i)*4)) {
 				(*VP8LBitEntropy)(unsafe.Pointer(entropy)).Fmax_val = **(**uint32_t)(__ccgo_up(array + uintptr(i)*4))
 			}
 		}
 		goto _1
 	_1:
 		;
 		i = i + 1
 	}
 	v2 = (*VP8LBitEntropy)(unsafe.Pointer(entropy)).Fsum
 	if v2 < uint32(LOG_LOOKUP_IDX_MAX) {
 		v5 = kSLog2Table[v2]
 	} else {
 		v5 = (*(*func(*libc.TLS, uint32_t) uint64_t)(unsafe.Pointer(&struct{ uintptr }{VP8LFastSLog2Slow})))(tls, v2)
 	}
 	v3 = v5
 	goto _8
 _8:
 	(*VP8LBitEntropy)(unsafe.Pointer(entropy)).Fentropy = v3 - (*VP8LBitEntropy)(unsafe.Pointer(entropy)).Fentropy
 }
 
 func GetEntropyUnrefinedHelper(tls *libc.TLS, val uint32_t, i int32, val_prev uintptr, i_prev uintptr, bit_entropy uintptr, stats uintptr) {
 	var streak int32
 	var v1 uint32_t
 	var v2 uint64_t
 	var v4 uint64
 	_, _, _, _ = streak, v1, v2, v4
 	streak = i - **(**int32)(__ccgo_up(i_prev))
 	// Gather info for the bit entropy.
 	if **(**uint32_t)(__ccgo_up(val_prev)) != uint32(0) {
 		**(**uint32_t)(__ccgo_up(bit_entropy + 8)) += **(**uint32_t)(__ccgo_up(val_prev)) * libc.Uint32FromInt32(streak)
 		**(**int32)(__ccgo_up(bit_entropy + 12)) += streak
 		(*VP8LBitEntropy)(unsafe.Pointer(bit_entropy)).Fnonzero_code = libc.Uint32FromInt32(**(**int32)(__ccgo_up(i_prev)))
 		v1 = **(**uint32_t)(__ccgo_up(val_prev))
 		if v1 < uint32(LOG_LOOKUP_IDX_MAX) {
 			v4 = kSLog2Table[v1]
 		} else {
 			v4 = (*(*func(*libc.TLS, uint32_t) uint64_t)(unsafe.Pointer(&struct{ uintptr }{VP8LFastSLog2Slow})))(tls, v1)
 		}
 		v2 = v4
 		goto _3
 	_3:
 		**(**uint64_t)(__ccgo_up(bit_entropy)) += v2 * libc.Uint64FromInt32(streak)
 		if (*VP8LBitEntropy)(unsafe.Pointer(bit_entropy)).Fmax_val < **(**uint32_t)(__ccgo_up(val_prev)) {
 			(*VP8LBitEntropy)(unsafe.Pointer(bit_entropy)).Fmax_val = **(**uint32_t)(__ccgo_up(val_prev))
 		}
 	}
 	// Gather info for the Huffman cost.
 	**(**int32)(__ccgo_up(stats + libc.BoolUintptr(**(**uint32_t)(__ccgo_up(val_prev)) != uint32(0))*4)) += libc.BoolInt32(streak > int32(3))
 	**(**int32)(__ccgo_up(stats + 8 + libc.BoolUintptr(**(**uint32_t)(__ccgo_up(val_prev)) != uint32(0))*8 + libc.BoolUintptr(streak > libc.Int32FromInt32(3))*4)) += streak
 	**(**uint32_t)(__ccgo_up(val_prev)) = val
 	**(**int32)(__ccgo_up(i_prev)) = i
 }
 
 func GetEntropyUnrefined_C(tls *libc.TLS, X uintptr, length int32, bit_entropy uintptr, stats uintptr) {
 	bp := tls.Alloc(16)
 	defer tls.Free(16)
 	var i int32
 	var x, v2 uint32_t
 	var v3 uint64_t
 	var v5 uint64
 	var _ /* i_prev at bp+0 */ int32
 	var _ /* x_prev at bp+4 */ uint32_t
 	_, _, _, _, _ = i, x, v2, v3, v5
 	**(**int32)(__ccgo_up(bp)) = 0
 	**(**uint32_t)(__ccgo_up(bp + 4)) = **(**uint32_t)(__ccgo_up(X))
 	libc.X__builtin___memset_chk(tls, stats, 0, uint64(24), ^__predefined_size_t(0))
 	VP8LBitEntropyInit(tls, bit_entropy)
 	i = int32(1)
 	for {
 		if !(i < length) {
 			break
 		}
 		x = **(**uint32_t)(__ccgo_up(X + uintptr(i)*4))
 		if x != **(**uint32_t)(__ccgo_up(bp + 4)) {
 			GetEntropyUnrefinedHelper(tls, x, i, bp+4, bp, bit_entropy, stats)
 		}
 		goto _1
 	_1:
 		;
 		i = i + 1
 	}
 	GetEntropyUnrefinedHelper(tls, uint32(0), i, bp+4, bp, bit_entropy, stats)
 	v2 = (*VP8LBitEntropy)(unsafe.Pointer(bit_entropy)).Fsum
 	if v2 < uint32(LOG_LOOKUP_IDX_MAX) {
 		v5 = kSLog2Table[v2]
 	} else {
 		v5 = (*(*func(*libc.TLS, uint32_t) uint64_t)(unsafe.Pointer(&struct{ uintptr }{VP8LFastSLog2Slow})))(tls, v2)
 	}
 	v3 = v5
 	goto _4
 _4:
 	(*VP8LBitEntropy)(unsafe.Pointer(bit_entropy)).Fentropy = v3 - (*VP8LBitEntropy)(unsafe.Pointer(bit_entropy)).Fentropy
 }
 
 func GetCombinedEntropyUnrefined_C(tls *libc.TLS, X uintptr, Y uintptr, length int32, bit_entropy uintptr, stats uintptr) {
 	bp := tls.Alloc(16)
 	defer tls.Free(16)
 	var i int32
 	var xy, v2 uint32_t
 	var v3 uint64_t
 	var v5 uint64
 	var _ /* i_prev at bp+0 */ int32
 	var _ /* xy_prev at bp+4 */ uint32_t
 	_, _, _, _, _ = i, xy, v2, v3, v5
 	i = int32(1)
 	**(**int32)(__ccgo_up(bp)) = 0
 	**(**uint32_t)(__ccgo_up(bp + 4)) = **(**uint32_t)(__ccgo_up(X)) + **(**uint32_t)(__ccgo_up(Y))
 	libc.X__builtin___memset_chk(tls, stats, 0, uint64(24), ^__predefined_size_t(0))
 	VP8LBitEntropyInit(tls, bit_entropy)
 	i = int32(1)
 	for {
 		if !(i < length) {
 			break
 		}
 		xy = **(**uint32_t)(__ccgo_up(X + uintptr(i)*4)) + **(**uint32_t)(__ccgo_up(Y + uintptr(i)*4))
 		if xy != **(**uint32_t)(__ccgo_up(bp + 4)) {
 			GetEntropyUnrefinedHelper(tls, xy, i, bp+4, bp, bit_entropy, stats)
 		}
 		goto _1
 	_1:
 		;
 		i = i + 1
 	}
 	GetEntropyUnrefinedHelper(tls, uint32(0), i, bp+4, bp, bit_entropy, stats)
 	v2 = (*VP8LBitEntropy)(unsafe.Pointer(bit_entropy)).Fsum
 	if v2 < uint32(LOG_LOOKUP_IDX_MAX) {
 		v5 = kSLog2Table[v2]
 	} else {
 		v5 = (*(*func(*libc.TLS, uint32_t) uint64_t)(unsafe.Pointer(&struct{ uintptr }{VP8LFastSLog2Slow})))(tls, v2)
 	}
 	v3 = v5
 	goto _4
 _4:
 	(*VP8LBitEntropy)(unsafe.Pointer(bit_entropy)).Fentropy = v3 - (*VP8LBitEntropy)(unsafe.Pointer(bit_entropy)).Fentropy
 }
 
 //------------------------------------------------------------------------------
 
 func VP8LSubtractGreenFromBlueAndRed_C(tls *libc.TLS, argb_data uintptr, num_pixels int32) {
 	var argb, green, i int32
 	var new_b, new_r uint32_t
 	_, _, _, _, _ = argb, green, i, new_b, new_r
 	i = 0
 	for {
 		if !(i < num_pixels) {
 			break
 		}
 		argb = libc.Int32FromUint32(**(**uint32_t)(__ccgo_up(argb_data + uintptr(i)*4)))
 		green = argb >> libc.Int32FromInt32(8) & int32(0xff)
 		new_r = libc.Uint32FromInt32((argb>>libc.Int32FromInt32(16)&int32(0xff) - green) & int32(0xff))
 		new_b = libc.Uint32FromInt32((argb>>libc.Int32FromInt32(0)&int32(0xff) - green) & int32(0xff))
 		**(**uint32_t)(__ccgo_up(argb_data + uintptr(i)*4)) = libc.Uint32FromInt32(argb)&uint32(0xff00ff00) | new_r<<libc.Int32FromInt32(16) | new_b
 		goto _1
 	_1:
 		;
 		i = i + 1
 	}
 }
 
 func ColorTransformDelta1(tls *libc.TLS, color_pred int8_t, color int8_t) (r int32) {
 	return int32(color_pred) * int32(color) >> int32(5)
 }
 
 func U32ToS8(tls *libc.TLS, v uint32_t) (r int8_t) {
 	return libc.Int8FromUint32(v & libc.Uint32FromInt32(0xff))
 }
 
 func VP8LTransformColor_C(tls *libc.TLS, m uintptr, data uintptr, num_pixels int32) {
 	var argb uint32_t
 	var green, red int8_t
 	var i, new_blue, new_red int32
 	_, _, _, _, _, _ = argb, green, i, new_blue, new_red, red
 	i = 0
 	for {
 		if !(i < num_pixels) {
 			break
 		}
 		argb = **(**uint32_t)(__ccgo_up(data + uintptr(i)*4))
 		green = U32ToS8(tls, argb>>int32(8))
 		red = U32ToS8(tls, argb>>int32(16))
 		new_red = int32(red) & int32(0xff)
 		new_blue = libc.Int32FromUint32(argb & uint32(0xff))
 		new_red = new_red - ColorTransformDelta1(tls, libc.Int8FromUint8((*VP8LMultipliers)(unsafe.Pointer(m)).Fgreen_to_red), green)
 		new_red = new_red & int32(0xff)
 		new_blue = new_blue - ColorTransformDelta1(tls, libc.Int8FromUint8((*VP8LMultipliers)(unsafe.Pointer(m)).Fgreen_to_blue), green)
 		new_blue = new_blue - ColorTransformDelta1(tls, libc.Int8FromUint8((*VP8LMultipliers)(unsafe.Pointer(m)).Fred_to_blue), red)
 		new_blue = new_blue & int32(0xff)
 		**(**uint32_t)(__ccgo_up(data + uintptr(i)*4)) = argb&uint32(0xff00ff00) | libc.Uint32FromInt32(new_red<<libc.Int32FromInt32(16)) | libc.Uint32FromInt32(new_blue)
 		goto _1
 	_1:
 		;
 		i = i + 1
 	}
 }
 
 func TransformColorRed(tls *libc.TLS, green_to_red uint8_t, argb uint32_t) (r uint8_t) {
 	var green int8_t
 	var new_red int32
 	_, _ = green, new_red
 	green = U32ToS8(tls, argb>>int32(8))
 	new_red = libc.Int32FromUint32(argb >> int32(16))
 	new_red = new_red - ColorTransformDelta1(tls, libc.Int8FromUint8(green_to_red), green)
 	return libc.Uint8FromInt32(new_red & libc.Int32FromInt32(0xff))
 }
 
 func TransformColorBlue(tls *libc.TLS, green_to_blue uint8_t, red_to_blue uint8_t, argb uint32_t) (r uint8_t) {
 	var green, red int8_t
 	var new_blue int32
 	_, _, _ = green, new_blue, red
 	green = U32ToS8(tls, argb>>int32(8))
 	red = U32ToS8(tls, argb>>int32(16))
 	new_blue = libc.Int32FromUint32(argb & uint32(0xff))
 	new_blue = new_blue - ColorTransformDelta1(tls, libc.Int8FromUint8(green_to_blue), green)
 	new_blue = new_blue - ColorTransformDelta1(tls, libc.Int8FromUint8(red_to_blue), red)
 	return libc.Uint8FromInt32(new_blue & libc.Int32FromInt32(0xff))
 }
 
 func VP8LCollectColorRedTransforms_C(tls *libc.TLS, argb uintptr, stride int32, tile_width int32, tile_height int32, green_to_red int32, histo uintptr) {
 	var x, v1 int32
 	_, _ = x, v1
 	for {
 		v1 = tile_height
 		tile_height = tile_height - 1
 		if !(v1 > 0) {
 			break
 		}
 		x = 0
 		for {
 			if !(x < tile_width) {
 				break
 			}
 			**(**uint32_t)(__ccgo_up(histo + uintptr(TransformColorRed(tls, libc.Uint8FromInt32(green_to_red), **(**uint32_t)(__ccgo_up(argb + uintptr(x)*4))))*4)) = **(**uint32_t)(__ccgo_up(histo + uintptr(TransformColorRed(tls, libc.Uint8FromInt32(green_to_red), **(**uint32_t)(__ccgo_up(argb + uintptr(x)*4))))*4)) + 1
 			goto _2
 		_2:
 			;
 			x = x + 1
 		}
 		argb = argb + uintptr(stride)*4
 	}
 }
 
 func VP8LCollectColorBlueTransforms_C(tls *libc.TLS, argb uintptr, stride int32, tile_width int32, tile_height int32, green_to_blue int32, red_to_blue int32, histo uintptr) {
 	var x, v1 int32
 	_, _ = x, v1
 	for {
 		v1 = tile_height
 		tile_height = tile_height - 1
 		if !(v1 > 0) {
 			break
 		}
 		x = 0
 		for {
 			if !(x < tile_width) {
 				break
 			}
 			**(**uint32_t)(__ccgo_up(histo + uintptr(TransformColorBlue(tls, libc.Uint8FromInt32(green_to_blue), libc.Uint8FromInt32(red_to_blue), **(**uint32_t)(__ccgo_up(argb + uintptr(x)*4))))*4)) = **(**uint32_t)(__ccgo_up(histo + uintptr(TransformColorBlue(tls, libc.Uint8FromInt32(green_to_blue), libc.Uint8FromInt32(red_to_blue), **(**uint32_t)(__ccgo_up(argb + uintptr(x)*4))))*4)) + 1
 			goto _2
 		_2:
 			;
 			x = x + 1
 		}
 		argb = argb + uintptr(stride)*4
 	}
 }
 
 //------------------------------------------------------------------------------
 
 func VectorMismatch_C(tls *libc.TLS, array1 uintptr, array2 uintptr, length int32) (r int32) {
 	var match_len int32
 	_ = match_len
 	match_len = 0
 	for match_len < length && **(**uint32_t)(__ccgo_up(array1 + uintptr(match_len)*4)) == **(**uint32_t)(__ccgo_up(array2 + uintptr(match_len)*4)) {
 		match_len = match_len + 1
 	}
 	return match_len
 }
 
 // C documentation
 //
 //	// Bundles multiple (1, 2, 4 or 8) pixels into a single pixel.
 func VP8LBundleColorMap_C(tls *libc.TLS, row uintptr, width int32, xbits int32, dst uintptr) {
 	var bit_depth, mask, x, xsub int32
 	var code uint32_t
 	_, _, _, _, _ = bit_depth, code, mask, x, xsub
 	if xbits > 0 {
 		bit_depth = int32(1) << (int32(3) - xbits)
 		mask = int32(1)<<xbits - int32(1)
 		code = uint32(0xff000000)
 		x = 0
 		for {
 			if !(x < width) {
 				break
 			}
 			xsub = x & mask
 			if xsub == 0 {
 				code = uint32(0xff000000)
 			}
 			code = code | libc.Uint32FromInt32(libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(row + uintptr(x))))<<(int32(8)+bit_depth*xsub))
 			**(**uint32_t)(__ccgo_up(dst + uintptr(x>>xbits)*4)) = code
 			goto _1
 		_1:
 			;
 			x = x + 1
 		}
 	} else {
 		x = 0
 		for {
 			if !(x < width) {
 				break
 			}
 			**(**uint32_t)(__ccgo_up(dst + uintptr(x)*4)) = uint32(0xff000000) | libc.Uint32FromInt32(libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(row + uintptr(x))))<<libc.Int32FromInt32(8))
 			goto _2
 		_2:
 			;
 			x = x + 1
 		}
 	}
 }
 
 //------------------------------------------------------------------------------
 
 func ExtraCost_C(tls *libc.TLS, population uintptr, length int32) (r uint32_t) {
 	var cost uint32_t
 	var i int32
 	_, _ = cost, i
 	cost = **(**uint32_t)(__ccgo_up(population + 4*4)) + **(**uint32_t)(__ccgo_up(population + 5*4))
 	i = int32(2)
 	for {
 		if !(i < length/int32(2)-int32(1)) {
 			break
 		}
 		cost = cost + libc.Uint32FromInt32(i)*(**(**uint32_t)(__ccgo_up(population + uintptr(int32(2)*i+int32(2))*4))+**(**uint32_t)(__ccgo_up(population + uintptr(int32(2)*i+int32(3))*4)))
 		goto _1
 	_1:
 		;
 		i = i + 1
 	}
 	return cost
 }
 
 //------------------------------------------------------------------------------
 
 func AddVector_C(tls *libc.TLS, a uintptr, b uintptr, out uintptr, size int32) {
 	var i int32
 	_ = i
 	i = 0
 	for {
 		if !(i < size) {
 			break
 		}
 		**(**uint32_t)(__ccgo_up(out + uintptr(i)*4)) = **(**uint32_t)(__ccgo_up(a + uintptr(i)*4)) + **(**uint32_t)(__ccgo_up(b + uintptr(i)*4))
 		goto _1
 	_1:
 		;
 		i = i + 1
 	}
 }
 
 func AddVectorEq_C(tls *libc.TLS, a uintptr, out uintptr, size int32) {
 	var i int32
 	_ = i
 	i = 0
 	for {
 		if !(i < size) {
 			break
 		}
 		**(**uint32_t)(__ccgo_up(out + uintptr(i)*4)) += **(**uint32_t)(__ccgo_up(a + uintptr(i)*4))
 		goto _1
 	_1:
 		;
 		i = i + 1
 	}
 }
 
 //------------------------------------------------------------------------------
 // Image transforms.
 
 func PredictorSub0_C(tls *libc.TLS, in uintptr, upper uintptr, num_pixels int32, out uintptr) {
 	var alpha_and_green, red_and_blue, v2, v3, v4 uint32_t
 	var i int32
 	_, _, _, _, _, _ = alpha_and_green, i, red_and_blue, v2, v3, v4
 	i = 0
 	for {
 		if !(i < num_pixels) {
 			break
 		}
 		v2 = **(**uint32_t)(__ccgo_up(in + uintptr(i)*4))
 		v3 = uint32(ARGB_BLACK3)
 		alpha_and_green = uint32(0x00ff00ff) + v2&uint32(0xff00ff00) - v3&uint32(0xff00ff00)
 		red_and_blue = uint32(0xff00ff00) + v2&uint32(0x00ff00ff) - v3&uint32(0x00ff00ff)
 		v4 = alpha_and_green&uint32(0xff00ff00) | red_and_blue&uint32(0x00ff00ff)
 		goto _5
 	_5:
 		**(**uint32_t)(__ccgo_up(out + uintptr(i)*4)) = v4
 		goto _1
 	_1:
 		;
 		i = i + 1
 	}
 	_ = upper
 }
 
 func PredictorSub1_C(tls *libc.TLS, in uintptr, upper uintptr, num_pixels int32, out uintptr) {
 	var alpha_and_green, red_and_blue, v2, v3, v4 uint32_t
 	var i int32
 	_, _, _, _, _, _ = alpha_and_green, i, red_and_blue, v2, v3, v4
 	i = 0
 	for {
 		if !(i < num_pixels) {
 			break
 		}
 		v2 = **(**uint32_t)(__ccgo_up(in + uintptr(i)*4))
 		v3 = **(**uint32_t)(__ccgo_up(in + uintptr(i-int32(1))*4))
 		alpha_and_green = uint32(0x00ff00ff) + v2&uint32(0xff00ff00) - v3&uint32(0xff00ff00)
 		red_and_blue = uint32(0xff00ff00) + v2&uint32(0x00ff00ff) - v3&uint32(0x00ff00ff)
 		v4 = alpha_and_green&uint32(0xff00ff00) | red_and_blue&uint32(0x00ff00ff)
 		goto _5
 	_5:
 		**(**uint32_t)(__ccgo_up(out + uintptr(i)*4)) = v4
 		goto _1
 	_1:
 		;
 		i = i + 1
 	}
 	_ = upper
 }
 
 // It subtracts the prediction from the input pixel and stores the residual
 // in the output pixel.
 func PredictorSub2_C(tls *libc.TLS, in uintptr, upper uintptr, num_pixels int32, out uintptr) {
 	var alpha_and_green, pred, red_and_blue, v2, v3, v4 uint32_t
 	var x int32
 	_, _, _, _, _, _, _ = alpha_and_green, pred, red_and_blue, x, v2, v3, v4
 	x = 0
 	for {
 		if !(x < num_pixels) {
 			break
 		}
 		pred = VP8LPredictor2_C(tls, in+uintptr(x-int32(1))*4, upper+uintptr(x)*4)
 		v2 = **(**uint32_t)(__ccgo_up(in + uintptr(x)*4))
 		v3 = pred
 		alpha_and_green = uint32(0x00ff00ff) + v2&uint32(0xff00ff00) - v3&uint32(0xff00ff00)
 		red_and_blue = uint32(0xff00ff00) + v2&uint32(0x00ff00ff) - v3&uint32(0x00ff00ff)
 		v4 = alpha_and_green&uint32(0xff00ff00) | red_and_blue&uint32(0x00ff00ff)
 		goto _5
 	_5:
 		**(**uint32_t)(__ccgo_up(out + uintptr(x)*4)) = v4
 		goto _1
 	_1:
 		;
 		x = x + 1
 	}
 }
 
 func PredictorSub3_C(tls *libc.TLS, in uintptr, upper uintptr, num_pixels int32, out uintptr) {
 	var alpha_and_green, pred, red_and_blue, v2, v3, v4 uint32_t
 	var x int32
 	_, _, _, _, _, _, _ = alpha_and_green, pred, red_and_blue, x, v2, v3, v4
 	x = 0
 	for {
 		if !(x < num_pixels) {
 			break
 		}
 		pred = VP8LPredictor3_C(tls, in+uintptr(x-int32(1))*4, upper+uintptr(x)*4)
 		v2 = **(**uint32_t)(__ccgo_up(in + uintptr(x)*4))
 		v3 = pred
 		alpha_and_green = uint32(0x00ff00ff) + v2&uint32(0xff00ff00) - v3&uint32(0xff00ff00)
 		red_and_blue = uint32(0xff00ff00) + v2&uint32(0x00ff00ff) - v3&uint32(0x00ff00ff)
 		v4 = alpha_and_green&uint32(0xff00ff00) | red_and_blue&uint32(0x00ff00ff)
 		goto _5
 	_5:
 		**(**uint32_t)(__ccgo_up(out + uintptr(x)*4)) = v4
 		goto _1
 	_1:
 		;
 		x = x + 1
 	}
 }
 
 func PredictorSub4_C(tls *libc.TLS, in uintptr, upper uintptr, num_pixels int32, out uintptr) {
 	var alpha_and_green, pred, red_and_blue, v2, v3, v4 uint32_t
 	var x int32
 	_, _, _, _, _, _, _ = alpha_and_green, pred, red_and_blue, x, v2, v3, v4
 	x = 0
 	for {
 		if !(x < num_pixels) {
 			break
 		}
 		pred = VP8LPredictor4_C(tls, in+uintptr(x-int32(1))*4, upper+uintptr(x)*4)
 		v2 = **(**uint32_t)(__ccgo_up(in + uintptr(x)*4))
 		v3 = pred
 		alpha_and_green = uint32(0x00ff00ff) + v2&uint32(0xff00ff00) - v3&uint32(0xff00ff00)
 		red_and_blue = uint32(0xff00ff00) + v2&uint32(0x00ff00ff) - v3&uint32(0x00ff00ff)
 		v4 = alpha_and_green&uint32(0xff00ff00) | red_and_blue&uint32(0x00ff00ff)
 		goto _5
 	_5:
 		**(**uint32_t)(__ccgo_up(out + uintptr(x)*4)) = v4
 		goto _1
 	_1:
 		;
 		x = x + 1
 	}
 }
 
 func PredictorSub5_C(tls *libc.TLS, in uintptr, upper uintptr, num_pixels int32, out uintptr) {
 	var alpha_and_green, pred, red_and_blue, v2, v3, v4 uint32_t
 	var x int32
 	_, _, _, _, _, _, _ = alpha_and_green, pred, red_and_blue, x, v2, v3, v4
 	x = 0
 	for {
 		if !(x < num_pixels) {
 			break
 		}
 		pred = VP8LPredictor5_C(tls, in+uintptr(x-int32(1))*4, upper+uintptr(x)*4)
 		v2 = **(**uint32_t)(__ccgo_up(in + uintptr(x)*4))
 		v3 = pred
 		alpha_and_green = uint32(0x00ff00ff) + v2&uint32(0xff00ff00) - v3&uint32(0xff00ff00)
 		red_and_blue = uint32(0xff00ff00) + v2&uint32(0x00ff00ff) - v3&uint32(0x00ff00ff)
 		v4 = alpha_and_green&uint32(0xff00ff00) | red_and_blue&uint32(0x00ff00ff)
 		goto _5
 	_5:
 		**(**uint32_t)(__ccgo_up(out + uintptr(x)*4)) = v4
 		goto _1
 	_1:
 		;
 		x = x + 1
 	}
 }
 
 func PredictorSub6_C(tls *libc.TLS, in uintptr, upper uintptr, num_pixels int32, out uintptr) {
 	var alpha_and_green, pred, red_and_blue, v2, v3, v4 uint32_t
 	var x int32
 	_, _, _, _, _, _, _ = alpha_and_green, pred, red_and_blue, x, v2, v3, v4
 	x = 0
 	for {
 		if !(x < num_pixels) {
 			break
 		}
 		pred = VP8LPredictor6_C(tls, in+uintptr(x-int32(1))*4, upper+uintptr(x)*4)
 		v2 = **(**uint32_t)(__ccgo_up(in + uintptr(x)*4))
 		v3 = pred
 		alpha_and_green = uint32(0x00ff00ff) + v2&uint32(0xff00ff00) - v3&uint32(0xff00ff00)
 		red_and_blue = uint32(0xff00ff00) + v2&uint32(0x00ff00ff) - v3&uint32(0x00ff00ff)
 		v4 = alpha_and_green&uint32(0xff00ff00) | red_and_blue&uint32(0x00ff00ff)
 		goto _5
 	_5:
 		**(**uint32_t)(__ccgo_up(out + uintptr(x)*4)) = v4
 		goto _1
 	_1:
 		;
 		x = x + 1
 	}
 }
 
 func PredictorSub7_C(tls *libc.TLS, in uintptr, upper uintptr, num_pixels int32, out uintptr) {
 	var alpha_and_green, pred, red_and_blue, v2, v3, v4 uint32_t
 	var x int32
 	_, _, _, _, _, _, _ = alpha_and_green, pred, red_and_blue, x, v2, v3, v4
 	x = 0
 	for {
 		if !(x < num_pixels) {
 			break
 		}
 		pred = VP8LPredictor7_C(tls, in+uintptr(x-int32(1))*4, upper+uintptr(x)*4)
 		v2 = **(**uint32_t)(__ccgo_up(in + uintptr(x)*4))
 		v3 = pred
 		alpha_and_green = uint32(0x00ff00ff) + v2&uint32(0xff00ff00) - v3&uint32(0xff00ff00)
 		red_and_blue = uint32(0xff00ff00) + v2&uint32(0x00ff00ff) - v3&uint32(0x00ff00ff)
 		v4 = alpha_and_green&uint32(0xff00ff00) | red_and_blue&uint32(0x00ff00ff)
 		goto _5
 	_5:
 		**(**uint32_t)(__ccgo_up(out + uintptr(x)*4)) = v4
 		goto _1
 	_1:
 		;
 		x = x + 1
 	}
 }
 
 func PredictorSub8_C(tls *libc.TLS, in uintptr, upper uintptr, num_pixels int32, out uintptr) {
 	var alpha_and_green, pred, red_and_blue, v2, v3, v4 uint32_t
 	var x int32
 	_, _, _, _, _, _, _ = alpha_and_green, pred, red_and_blue, x, v2, v3, v4
 	x = 0
 	for {
 		if !(x < num_pixels) {
 			break
 		}
 		pred = VP8LPredictor8_C(tls, in+uintptr(x-int32(1))*4, upper+uintptr(x)*4)
 		v2 = **(**uint32_t)(__ccgo_up(in + uintptr(x)*4))
 		v3 = pred
 		alpha_and_green = uint32(0x00ff00ff) + v2&uint32(0xff00ff00) - v3&uint32(0xff00ff00)
 		red_and_blue = uint32(0xff00ff00) + v2&uint32(0x00ff00ff) - v3&uint32(0x00ff00ff)
 		v4 = alpha_and_green&uint32(0xff00ff00) | red_and_blue&uint32(0x00ff00ff)
 		goto _5
 	_5:
 		**(**uint32_t)(__ccgo_up(out + uintptr(x)*4)) = v4
 		goto _1
 	_1:
 		;
 		x = x + 1
 	}
 }
 
 func PredictorSub9_C(tls *libc.TLS, in uintptr, upper uintptr, num_pixels int32, out uintptr) {
 	var alpha_and_green, pred, red_and_blue, v2, v3, v4 uint32_t
 	var x int32
 	_, _, _, _, _, _, _ = alpha_and_green, pred, red_and_blue, x, v2, v3, v4
 	x = 0
 	for {
 		if !(x < num_pixels) {
 			break
 		}
 		pred = VP8LPredictor9_C(tls, in+uintptr(x-int32(1))*4, upper+uintptr(x)*4)
 		v2 = **(**uint32_t)(__ccgo_up(in + uintptr(x)*4))
 		v3 = pred
 		alpha_and_green = uint32(0x00ff00ff) + v2&uint32(0xff00ff00) - v3&uint32(0xff00ff00)
 		red_and_blue = uint32(0xff00ff00) + v2&uint32(0x00ff00ff) - v3&uint32(0x00ff00ff)
 		v4 = alpha_and_green&uint32(0xff00ff00) | red_and_blue&uint32(0x00ff00ff)
 		goto _5
 	_5:
 		**(**uint32_t)(__ccgo_up(out + uintptr(x)*4)) = v4
 		goto _1
 	_1:
 		;
 		x = x + 1
 	}
 }
 
 func PredictorSub10_C(tls *libc.TLS, in uintptr, upper uintptr, num_pixels int32, out uintptr) {
 	var alpha_and_green, pred, red_and_blue, v2, v3, v4 uint32_t
 	var x int32
 	_, _, _, _, _, _, _ = alpha_and_green, pred, red_and_blue, x, v2, v3, v4
 	x = 0
 	for {
 		if !(x < num_pixels) {
 			break
 		}
 		pred = VP8LPredictor10_C(tls, in+uintptr(x-int32(1))*4, upper+uintptr(x)*4)
 		v2 = **(**uint32_t)(__ccgo_up(in + uintptr(x)*4))
 		v3 = pred
 		alpha_and_green = uint32(0x00ff00ff) + v2&uint32(0xff00ff00) - v3&uint32(0xff00ff00)
 		red_and_blue = uint32(0xff00ff00) + v2&uint32(0x00ff00ff) - v3&uint32(0x00ff00ff)
 		v4 = alpha_and_green&uint32(0xff00ff00) | red_and_blue&uint32(0x00ff00ff)
 		goto _5
 	_5:
 		**(**uint32_t)(__ccgo_up(out + uintptr(x)*4)) = v4
 		goto _1
 	_1:
 		;
 		x = x + 1
 	}
 }
 
 func PredictorSub11_C(tls *libc.TLS, in uintptr, upper uintptr, num_pixels int32, out uintptr) {
 	var alpha_and_green, pred, red_and_blue, v2, v3, v4 uint32_t
 	var x int32
 	_, _, _, _, _, _, _ = alpha_and_green, pred, red_and_blue, x, v2, v3, v4
 	x = 0
 	for {
 		if !(x < num_pixels) {
 			break
 		}
 		pred = VP8LPredictor11_C(tls, in+uintptr(x-int32(1))*4, upper+uintptr(x)*4)
 		v2 = **(**uint32_t)(__ccgo_up(in + uintptr(x)*4))
 		v3 = pred
 		alpha_and_green = uint32(0x00ff00ff) + v2&uint32(0xff00ff00) - v3&uint32(0xff00ff00)
 		red_and_blue = uint32(0xff00ff00) + v2&uint32(0x00ff00ff) - v3&uint32(0x00ff00ff)
 		v4 = alpha_and_green&uint32(0xff00ff00) | red_and_blue&uint32(0x00ff00ff)
 		goto _5
 	_5:
 		**(**uint32_t)(__ccgo_up(out + uintptr(x)*4)) = v4
 		goto _1
 	_1:
 		;
 		x = x + 1
 	}
 }
 
 func PredictorSub12_C(tls *libc.TLS, in uintptr, upper uintptr, num_pixels int32, out uintptr) {
 	var alpha_and_green, pred, red_and_blue, v2, v3, v4 uint32_t
 	var x int32
 	_, _, _, _, _, _, _ = alpha_and_green, pred, red_and_blue, x, v2, v3, v4
 	x = 0
 	for {
 		if !(x < num_pixels) {
 			break
 		}
 		pred = VP8LPredictor12_C(tls, in+uintptr(x-int32(1))*4, upper+uintptr(x)*4)
 		v2 = **(**uint32_t)(__ccgo_up(in + uintptr(x)*4))
 		v3 = pred
 		alpha_and_green = uint32(0x00ff00ff) + v2&uint32(0xff00ff00) - v3&uint32(0xff00ff00)
 		red_and_blue = uint32(0xff00ff00) + v2&uint32(0x00ff00ff) - v3&uint32(0x00ff00ff)
 		v4 = alpha_and_green&uint32(0xff00ff00) | red_and_blue&uint32(0x00ff00ff)
 		goto _5
 	_5:
 		**(**uint32_t)(__ccgo_up(out + uintptr(x)*4)) = v4
 		goto _1
 	_1:
 		;
 		x = x + 1
 	}
 }
 
 func PredictorSub13_C(tls *libc.TLS, in uintptr, upper uintptr, num_pixels int32, out uintptr) {
 	var alpha_and_green, pred, red_and_blue, v2, v3, v4 uint32_t
 	var x int32
 	_, _, _, _, _, _, _ = alpha_and_green, pred, red_and_blue, x, v2, v3, v4
 	x = 0
 	for {
 		if !(x < num_pixels) {
 			break
 		}
 		pred = VP8LPredictor13_C(tls, in+uintptr(x-int32(1))*4, upper+uintptr(x)*4)
 		v2 = **(**uint32_t)(__ccgo_up(in + uintptr(x)*4))
 		v3 = pred
 		alpha_and_green = uint32(0x00ff00ff) + v2&uint32(0xff00ff00) - v3&uint32(0xff00ff00)
 		red_and_blue = uint32(0xff00ff00) + v2&uint32(0x00ff00ff) - v3&uint32(0x00ff00ff)
 		v4 = alpha_and_green&uint32(0xff00ff00) | red_and_blue&uint32(0x00ff00ff)
 		goto _5
 	_5:
 		**(**uint32_t)(__ccgo_up(out + uintptr(x)*4)) = v4
 		goto _1
 	_1:
 		;
 		x = x + 1
 	}
 }
 
 func VP8LEncDspInit(tls *libc.TLS) {
 	if libc.AtomicLoadPUintptr(uintptr(unsafe.Pointer(&VP8LEncDspInit_body_last_cpuinfo_used))) == VP8GetCPUInfo {
 		goto _1
 	}
 	VP8LEncDspInit_body(tls)
 	libc.AtomicStorePUintptr(uintptr(unsafe.Pointer(&VP8LEncDspInit_body_last_cpuinfo_used)), VP8GetCPUInfo)
 	goto _2
 _2:
 	;
 	goto _1
 _1: /**/ //
 }
 
 var VP8LEncDspInit_body_last_cpuinfo_used = uintptr(0)
 
 func init() {
 	p := unsafe.Pointer(&VP8LEncDspInit_body_last_cpuinfo_used)
 	*(*uintptr)(unsafe.Add(p, 0)) = uintptr(unsafe.Pointer(&VP8LEncDspInit_body_last_cpuinfo_used))
 }
 
 func VP8LEncDspInit_body(tls *libc.TLS) {
 	VP8LDspInit(tls)
 	VP8LSubtractGreenFromBlueAndRed = __ccgo_fp(VP8LSubtractGreenFromBlueAndRed_C)
 	VP8LTransformColor = __ccgo_fp(VP8LTransformColor_C)
 	VP8LCollectColorBlueTransforms = __ccgo_fp(VP8LCollectColorBlueTransforms_C)
 	VP8LCollectColorRedTransforms = __ccgo_fp(VP8LCollectColorRedTransforms_C)
 	VP8LFastLog2Slow = __ccgo_fp(FastLog2Slow_C)
 	VP8LFastSLog2Slow = __ccgo_fp(FastSLog2Slow_C)
 	VP8LExtraCost = __ccgo_fp(ExtraCost_C)
 	VP8LCombinedShannonEntropy = __ccgo_fp(CombinedShannonEntropy_C)
 	VP8LShannonEntropy = __ccgo_fp(ShannonEntropy_C)
 	VP8LGetEntropyUnrefined = __ccgo_fp(GetEntropyUnrefined_C)
 	VP8LGetCombinedEntropyUnrefined = __ccgo_fp(GetCombinedEntropyUnrefined_C)
 	VP8LAddVector = __ccgo_fp(AddVector_C)
 	VP8LAddVectorEq = __ccgo_fp(AddVectorEq_C)
 	VP8LVectorMismatch = __ccgo_fp(VectorMismatch_C)
 	VP8LBundleColorMap = __ccgo_fp(VP8LBundleColorMap_C)
 	VP8LPredictorsSub[0] = __ccgo_fp(PredictorSub0_C)
 	VP8LPredictorsSub[int32(1)] = __ccgo_fp(PredictorSub1_C)
 	VP8LPredictorsSub[int32(2)] = __ccgo_fp(PredictorSub2_C)
 	VP8LPredictorsSub[int32(3)] = __ccgo_fp(PredictorSub3_C)
 	VP8LPredictorsSub[int32(4)] = __ccgo_fp(PredictorSub4_C)
 	VP8LPredictorsSub[int32(5)] = __ccgo_fp(PredictorSub5_C)
 	VP8LPredictorsSub[int32(6)] = __ccgo_fp(PredictorSub6_C)
 	VP8LPredictorsSub[int32(7)] = __ccgo_fp(PredictorSub7_C)
 	VP8LPredictorsSub[int32(8)] = __ccgo_fp(PredictorSub8_C)
 	VP8LPredictorsSub[int32(9)] = __ccgo_fp(PredictorSub9_C)
 	VP8LPredictorsSub[int32(10)] = __ccgo_fp(PredictorSub10_C)
 	VP8LPredictorsSub[int32(11)] = __ccgo_fp(PredictorSub11_C)
 	VP8LPredictorsSub[int32(12)] = __ccgo_fp(PredictorSub12_C)
 	VP8LPredictorsSub[int32(13)] = __ccgo_fp(PredictorSub13_C)
 	VP8LPredictorsSub[int32(14)] = __ccgo_fp(PredictorSub0_C) // <- padding security sentinels
 	VP8LPredictorsSub[int32(15)] = __ccgo_fp(PredictorSub0_C)
 	VP8LPredictorsSub_C[0] = __ccgo_fp(PredictorSub0_C)
 	VP8LPredictorsSub_C[int32(1)] = __ccgo_fp(PredictorSub1_C)
 	VP8LPredictorsSub_C[int32(2)] = __ccgo_fp(PredictorSub2_C)
 	VP8LPredictorsSub_C[int32(3)] = __ccgo_fp(PredictorSub3_C)
 	VP8LPredictorsSub_C[int32(4)] = __ccgo_fp(PredictorSub4_C)
 	VP8LPredictorsSub_C[int32(5)] = __ccgo_fp(PredictorSub5_C)
 	VP8LPredictorsSub_C[int32(6)] = __ccgo_fp(PredictorSub6_C)
 	VP8LPredictorsSub_C[int32(7)] = __ccgo_fp(PredictorSub7_C)
 	VP8LPredictorsSub_C[int32(8)] = __ccgo_fp(PredictorSub8_C)
 	VP8LPredictorsSub_C[int32(9)] = __ccgo_fp(PredictorSub9_C)
 	VP8LPredictorsSub_C[int32(10)] = __ccgo_fp(PredictorSub10_C)
 	VP8LPredictorsSub_C[int32(11)] = __ccgo_fp(PredictorSub11_C)
 	VP8LPredictorsSub_C[int32(12)] = __ccgo_fp(PredictorSub12_C)
 	VP8LPredictorsSub_C[int32(13)] = __ccgo_fp(PredictorSub13_C)
 	VP8LPredictorsSub_C[int32(14)] = __ccgo_fp(PredictorSub0_C) // <- padding security sentinels
 	VP8LPredictorsSub_C[int32(15)] = __ccgo_fp(PredictorSub0_C)
 	// If defined, use CPUInfo() to overwrite some pointers with faster versions.
 	if VP8GetCPUInfo != libc.UintptrFromInt32(0) {
 	}
 }
 
 const LOG_2_RECIPROCAL_FIXED_DOUBLE2 = 12102203.161561485379934310913085937500
 const __FLT_MIN__12 = 1.17549435082228750796873653722224568e-38
 
 func VP8LEncDspInitMIPS32(tls *libc.TLS) {
 }
 
 func VP8LEncDspInitMIPSdspR2(tls *libc.TLS) {
 }
 
 func VP8LEncDspInitMSA(tls *libc.TLS) {
 }
 
 func VP8LEncDspInitNEON(tls *libc.TLS) {
 }
 
 func VP8LEncDspInitSSE2(tls *libc.TLS) {
 }
 
 func VP8LEncDspInitSSE41(tls *libc.TLS) {
 }
 
 func VP8LDspInitMIPSdspR2(tls *libc.TLS) {
 }
 
 func VP8LDspInitMSA(tls *libc.TLS) {
 }
 
 func VP8LDspInitNEON(tls *libc.TLS) {
 }
 
 func VP8LDspInitSSE2(tls *libc.TLS) {
 }
 
 func VP8LDspInitSSE41(tls *libc.TLS) {
 }
 
 //------------------------------------------------------------------------------
 
 //------------------------------------------------------------------------------
 // Implementations of critical functions ImportRow / ExportRow
 
 //------------------------------------------------------------------------------
 // Row import
 
 func WebPRescalerImportRowExpand_C(tls *libc.TLS, wrk uintptr, src uintptr) {
 	var accum, channel, x_in, x_out, x_out_max, x_stride int32
 	var left, right rescaler_t
 	var v2 uint32
 	_, _, _, _, _, _, _, _, _ = accum, channel, left, right, x_in, x_out, x_out_max, x_stride, v2
 	x_stride = (*WebPRescaler)(unsafe.Pointer(wrk)).Fnum_channels
 	x_out_max = (*WebPRescaler)(unsafe.Pointer(wrk)).Fdst_width * (*WebPRescaler)(unsafe.Pointer(wrk)).Fnum_channels
 	channel = 0
 	for {
 		if !(channel < x_stride) {
 			break
 		}
 		x_in = channel
 		x_out = channel
 		// simple bilinear interpolation
 		accum = (*WebPRescaler)(unsafe.Pointer(wrk)).Fx_add
 		left = uint32(**(**uint8_t)(__ccgo_up(src + uintptr(x_in))))
 		if (*WebPRescaler)(unsafe.Pointer(wrk)).Fsrc_width > int32(1) {
 			v2 = uint32(**(**uint8_t)(__ccgo_up(src + uintptr(x_in+x_stride))))
 		} else {
 			v2 = left
 		}
 		right = v2
 		x_in = x_in + x_stride
 		for int32(1) != 0 {
 			**(**rescaler_t)(__ccgo_up((*WebPRescaler)(unsafe.Pointer(wrk)).Ffrow + uintptr(x_out)*4)) = right*libc.Uint32FromInt32((*WebPRescaler)(unsafe.Pointer(wrk)).Fx_add) + (left-right)*libc.Uint32FromInt32(accum)
 			x_out = x_out + x_stride
 			if x_out >= x_out_max {
 				break
 			}
 			accum = accum - (*WebPRescaler)(unsafe.Pointer(wrk)).Fx_sub
 			if accum < 0 {
 				left = right
 				x_in = x_in + x_stride
 				right = uint32(**(**uint8_t)(__ccgo_up(src + uintptr(x_in))))
 				accum = accum + (*WebPRescaler)(unsafe.Pointer(wrk)).Fx_add
 			}
 		}
 		goto _1
 	_1:
 		;
 		channel = channel + 1
 	}
 }
 
 func WebPRescalerImportRowShrink_C(tls *libc.TLS, wrk uintptr, src uintptr) {
 	var accum, channel, x_in, x_out, x_out_max, x_stride int32
 	var base, sum uint32_t
 	var frac rescaler_t
 	_, _, _, _, _, _, _, _, _ = accum, base, channel, frac, sum, x_in, x_out, x_out_max, x_stride
 	x_stride = (*WebPRescaler)(unsafe.Pointer(wrk)).Fnum_channels
 	x_out_max = (*WebPRescaler)(unsafe.Pointer(wrk)).Fdst_width * (*WebPRescaler)(unsafe.Pointer(wrk)).Fnum_channels
 	channel = 0
 	for {
 		if !(channel < x_stride) {
 			break
 		}
 		x_in = channel
 		x_out = channel
 		sum = uint32(0)
 		accum = 0
 		for x_out < x_out_max {
 			base = uint32(0)
 			accum = accum + (*WebPRescaler)(unsafe.Pointer(wrk)).Fx_add
 			for accum > 0 {
 				accum = accum - (*WebPRescaler)(unsafe.Pointer(wrk)).Fx_sub
 				base = uint32(**(**uint8_t)(__ccgo_up(src + uintptr(x_in))))
 				sum = sum + base
 				x_in = x_in + x_stride
 			}
 			// Emit next horizontal pixel.
 			frac = base * libc.Uint32FromInt32(-accum)
 			**(**rescaler_t)(__ccgo_up((*WebPRescaler)(unsafe.Pointer(wrk)).Ffrow + uintptr(x_out)*4)) = sum*libc.Uint32FromInt32((*WebPRescaler)(unsafe.Pointer(wrk)).Fx_sub) - frac
 			// fresh fractional start for next pixel
 			sum = libc.Uint32FromInt32(libc.Int32FromUint64((uint64(frac)*uint64((*WebPRescaler)(unsafe.Pointer(wrk)).Ffx_scale) + libc.Uint64FromUint64(1)<<libc.Int32FromInt32(WEBP_RESCALER_RFIX)>>libc.Int32FromInt32(1)) >> libc.Int32FromInt32(WEBP_RESCALER_RFIX)))
 			x_out = x_out + x_stride
 		}
 		goto _1
 	_1:
 		;
 		channel = channel + 1
 	}
 }
 
 //------------------------------------------------------------------------------
 // Row export
 
 func WebPRescalerExportRowExpand_C(tls *libc.TLS, wrk uintptr) {
 	var A, B, J, J1 uint32_t
 	var I uint64_t
 	var dst, frow, irow uintptr
 	var v, v1, x_out, x_out_max int32
 	var v2 uint32
 	_, _, _, _, _, _, _, _, _, _, _, _, _ = A, B, I, J, J1, dst, frow, irow, v, v1, x_out, x_out_max, v2
 	dst = (*WebPRescaler)(unsafe.Pointer(wrk)).Fdst
 	irow = (*WebPRescaler)(unsafe.Pointer(wrk)).Firow
 	x_out_max = (*WebPRescaler)(unsafe.Pointer(wrk)).Fdst_width * (*WebPRescaler)(unsafe.Pointer(wrk)).Fnum_channels
 	frow = (*WebPRescaler)(unsafe.Pointer(wrk)).Ffrow
 	if (*WebPRescaler)(unsafe.Pointer(wrk)).Fy_accum == 0 {
 		x_out = 0
 		for {
 			if !(x_out < x_out_max) {
 				break
 			}
 			J = **(**rescaler_t)(__ccgo_up(frow + uintptr(x_out)*4))
 			v = libc.Int32FromUint64((uint64(J)*uint64((*WebPRescaler)(unsafe.Pointer(wrk)).Ffy_scale) + libc.Uint64FromUint64(1)<<libc.Int32FromInt32(WEBP_RESCALER_RFIX)>>libc.Int32FromInt32(1)) >> libc.Int32FromInt32(WEBP_RESCALER_RFIX))
 			if v > int32(255) {
 				v2 = uint32(255)
 			} else {
 				v2 = uint32(libc.Uint8FromInt32(v))
 			}
 			**(**uint8_t)(__ccgo_up(dst + uintptr(x_out))) = uint8(v2)
 			goto _1
 		_1:
 			;
 			x_out = x_out + 1
 		}
 	} else {
 		B = uint32(libc.Uint64FromInt32(-(*WebPRescaler)(unsafe.Pointer(wrk)).Fy_accum) << libc.Int32FromInt32(WEBP_RESCALER_RFIX) / libc.Uint64FromInt32((*WebPRescaler)(unsafe.Pointer(wrk)).Fy_sub))
 		A = uint32(libc.Uint64FromUint64(1)<<libc.Int32FromInt32(WEBP_RESCALER_RFIX) - uint64(B))
 		x_out = 0
 		for {
 			if !(x_out < x_out_max) {
 				break
 			}
 			I = uint64(A)*uint64(**(**rescaler_t)(__ccgo_up(frow + uintptr(x_out)*4))) + uint64(B)*uint64(**(**rescaler_t)(__ccgo_up(irow + uintptr(x_out)*4)))
 			J1 = uint32((I + libc.Uint64FromUint64(1)<<libc.Int32FromInt32(WEBP_RESCALER_RFIX)>>libc.Int32FromInt32(1)) >> libc.Int32FromInt32(WEBP_RESCALER_RFIX))
 			v1 = libc.Int32FromUint64((uint64(J1)*uint64((*WebPRescaler)(unsafe.Pointer(wrk)).Ffy_scale) + libc.Uint64FromUint64(1)<<libc.Int32FromInt32(WEBP_RESCALER_RFIX)>>libc.Int32FromInt32(1)) >> libc.Int32FromInt32(WEBP_RESCALER_RFIX))
 			if v1 > int32(255) {
 				v2 = uint32(255)
 			} else {
 				v2 = uint32(libc.Uint8FromInt32(v1))
 			}
 			**(**uint8_t)(__ccgo_up(dst + uintptr(x_out))) = uint8(v2)
 			goto _3
 		_3:
 			;
 			x_out = x_out + 1
 		}
 	}
 }
 
 func WebPRescalerExportRowShrink_C(tls *libc.TLS, wrk uintptr) {
 	var dst, frow, irow uintptr
 	var frac, yscale uint32_t
 	var v, v1, x_out, x_out_max int32
 	var v2 uint32
 	_, _, _, _, _, _, _, _, _, _ = dst, frac, frow, irow, v, v1, x_out, x_out_max, yscale, v2
 	dst = (*WebPRescaler)(unsafe.Pointer(wrk)).Fdst
 	irow = (*WebPRescaler)(unsafe.Pointer(wrk)).Firow
 	x_out_max = (*WebPRescaler)(unsafe.Pointer(wrk)).Fdst_width * (*WebPRescaler)(unsafe.Pointer(wrk)).Fnum_channels
 	frow = (*WebPRescaler)(unsafe.Pointer(wrk)).Ffrow
 	yscale = (*WebPRescaler)(unsafe.Pointer(wrk)).Ffy_scale * libc.Uint32FromInt32(-(*WebPRescaler)(unsafe.Pointer(wrk)).Fy_accum)
 	if yscale != 0 {
 		x_out = 0
 		for {
 			if !(x_out < x_out_max) {
 				break
 			}
 			frac = uint32(uint64(**(**rescaler_t)(__ccgo_up(frow + uintptr(x_out)*4))) * uint64(yscale) >> libc.Int32FromInt32(WEBP_RESCALER_RFIX))
 			v = libc.Int32FromUint64((uint64(**(**rescaler_t)(__ccgo_up(irow + uintptr(x_out)*4))-frac)*uint64((*WebPRescaler)(unsafe.Pointer(wrk)).Ffxy_scale) + libc.Uint64FromUint64(1)<<libc.Int32FromInt32(WEBP_RESCALER_RFIX)>>libc.Int32FromInt32(1)) >> libc.Int32FromInt32(WEBP_RESCALER_RFIX))
 			if v > int32(255) {
 				v2 = uint32(255)
 			} else {
 				v2 = uint32(libc.Uint8FromInt32(v))
 			}
 			**(**uint8_t)(__ccgo_up(dst + uintptr(x_out))) = uint8(v2)
 			**(**rescaler_t)(__ccgo_up(irow + uintptr(x_out)*4)) = frac // new fractional start
 			goto _1
 		_1:
 			;
 			x_out = x_out + 1
 		}
 	} else {
 		x_out = 0
 		for {
 			if !(x_out < x_out_max) {
 				break
 			}
 			v1 = libc.Int32FromUint64((uint64(**(**rescaler_t)(__ccgo_up(irow + uintptr(x_out)*4)))*uint64((*WebPRescaler)(unsafe.Pointer(wrk)).Ffxy_scale) + libc.Uint64FromUint64(1)<<libc.Int32FromInt32(WEBP_RESCALER_RFIX)>>libc.Int32FromInt32(1)) >> libc.Int32FromInt32(WEBP_RESCALER_RFIX))
 			if v1 > int32(255) {
 				v2 = uint32(255)
 			} else {
 				v2 = uint32(libc.Uint8FromInt32(v1))
 			}
 			**(**uint8_t)(__ccgo_up(dst + uintptr(x_out))) = uint8(v2)
 			**(**rescaler_t)(__ccgo_up(irow + uintptr(x_out)*4)) = uint32(0)
 			goto _3
 		_3:
 			;
 			x_out = x_out + 1
 		}
 	}
 }
 
 //------------------------------------------------------------------------------
 // Main entry calls
 
 func WebPRescalerImportRow(tls *libc.TLS, wrk uintptr, src uintptr) {
 	if !((*WebPRescaler)(unsafe.Pointer(wrk)).Fx_expand != 0) {
 		(*(*func(*libc.TLS, uintptr, uintptr))(unsafe.Pointer(&struct{ uintptr }{WebPRescalerImportRowShrink})))(tls, wrk, src)
 	} else {
 		(*(*func(*libc.TLS, uintptr, uintptr))(unsafe.Pointer(&struct{ uintptr }{WebPRescalerImportRowExpand})))(tls, wrk, src)
 	}
 }
 
 func WebPRescalerExportRow(tls *libc.TLS, wrk uintptr) {
 	var i int32
 	_ = i
 	if (*WebPRescaler)(unsafe.Pointer(wrk)).Fy_accum <= 0 {
 		if (*WebPRescaler)(unsafe.Pointer(wrk)).Fy_expand != 0 {
 			(*(*func(*libc.TLS, uintptr))(unsafe.Pointer(&struct{ uintptr }{WebPRescalerExportRowExpand})))(tls, wrk)
 		} else {
 			if (*WebPRescaler)(unsafe.Pointer(wrk)).Ffxy_scale != 0 {
 				(*(*func(*libc.TLS, uintptr))(unsafe.Pointer(&struct{ uintptr }{WebPRescalerExportRowShrink})))(tls, wrk)
 			} else {
 				i = 0
 				for {
 					if !(i < (*WebPRescaler)(unsafe.Pointer(wrk)).Fnum_channels*(*WebPRescaler)(unsafe.Pointer(wrk)).Fdst_width) {
 						break
 					}
 					**(**uint8_t)(__ccgo_up((*WebPRescaler)(unsafe.Pointer(wrk)).Fdst + uintptr(i))) = uint8(**(**rescaler_t)(__ccgo_up((*WebPRescaler)(unsafe.Pointer(wrk)).Firow + uintptr(i)*4)))
 					**(**rescaler_t)(__ccgo_up((*WebPRescaler)(unsafe.Pointer(wrk)).Firow + uintptr(i)*4)) = uint32(0)
 					goto _1
 				_1:
 					;
 					i = i + 1
 				}
 			}
 		}
 		**(**int32)(__ccgo_up(wrk + 24)) += (*WebPRescaler)(unsafe.Pointer(wrk)).Fy_add
 		**(**uintptr)(__ccgo_up(wrk + 72)) += uintptr((*WebPRescaler)(unsafe.Pointer(wrk)).Fdst_stride)
 		(*WebPRescaler)(unsafe.Pointer(wrk)).Fdst_y = (*WebPRescaler)(unsafe.Pointer(wrk)).Fdst_y + 1
 	}
 }
 
 func WebPRescalerDspInit(tls *libc.TLS) {
 	if libc.AtomicLoadPUintptr(uintptr(unsafe.Pointer(&WebPRescalerDspInit_body_last_cpuinfo_used))) == VP8GetCPUInfo {
 		goto _1
 	}
 	WebPRescalerDspInit_body(tls)
 	libc.AtomicStorePUintptr(uintptr(unsafe.Pointer(&WebPRescalerDspInit_body_last_cpuinfo_used)), VP8GetCPUInfo)
 	goto _2
 _2:
 	;
 	goto _1
 _1: /**/ //
 }
 
 var WebPRescalerDspInit_body_last_cpuinfo_used = uintptr(0)
 
 func init() {
 	p := unsafe.Pointer(&WebPRescalerDspInit_body_last_cpuinfo_used)
 	*(*uintptr)(unsafe.Add(p, 0)) = uintptr(unsafe.Pointer(&WebPRescalerDspInit_body_last_cpuinfo_used))
 }
 
 func WebPRescalerDspInit_body(tls *libc.TLS) {
 	WebPRescalerExportRowExpand = __ccgo_fp(WebPRescalerExportRowExpand_C)
 	WebPRescalerExportRowShrink = __ccgo_fp(WebPRescalerExportRowShrink_C)
 	WebPRescalerImportRowExpand = __ccgo_fp(WebPRescalerImportRowExpand_C)
 	WebPRescalerImportRowShrink = __ccgo_fp(WebPRescalerImportRowShrink_C)
 	if VP8GetCPUInfo != libc.UintptrFromInt32(0) {
 	}
 }
 
 func WebPRescalerDspInitMIPS32(tls *libc.TLS) {
 }
 
 func WebPRescalerDspInitMIPSdspR2(tls *libc.TLS) {
 }
 
 func WebPRescalerDspInitMSA(tls *libc.TLS) {
 }
 
 func WebPRescalerDspInitNEON(tls *libc.TLS) {
 }
 
 func WebPRescalerDspInitSSE2(tls *libc.TLS) {
 }
 
 // Copyright 2010 Google Inc. All Rights Reserved.
 //
 // Use of this source code is governed by a BSD-style license
 // that can be found in the COPYING file in the root of the source
 // tree. An additional intellectual property rights grant can be found
 // in the file PATENTS. All contributing project authors may
 // be found in the AUTHORS file in the root of the source tree.
 // -----------------------------------------------------------------------------
 //
 //  Common types + memory wrappers
 //
 // Author: Skal (pascal.massimino@gmail.com)
 
 //------------------------------------------------------------------------------
 // SSIM / PSNR
 
 // C documentation
 //
 //	// hat-shaped filter. Sum of coefficients is equal to 16.
 var kWeight = [7]uint32_t{
 	0: uint32(1),
 	1: uint32(2),
 	2: uint32(3),
 	3: uint32(4),
 	4: uint32(3),
 	5: uint32(2),
 	6: uint32(1),
 }
 var kWeightSum = libc.Uint32FromInt32(libc.Int32FromInt32(16) * libc.Int32FromInt32(16)) // sum{kWeight}^2
 
 func SSIMCalculation(tls *libc.TLS, stats uintptr, N uint32_t) (r1 float64) {
 	var C1, C2, C3, w2 uint32_t
 	var den_S, fden, fnum, num_S, sxx, syy, xmxm, ymym uint64_t
 	var r float64
 	var sxy, xmym int64_t
 	var v1 int64
 	_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = C1, C2, C3, den_S, fden, fnum, num_S, r, sxx, sxy, syy, w2, xmxm, xmym, ymym, v1
 	w2 = N * N
 	C1 = uint32(20) * w2
 	C2 = uint32(60) * w2
 	C3 = libc.Uint32FromInt32(libc.Int32FromInt32(8)*libc.Int32FromInt32(8)) * w2 // 'dark' limit ~= 6
 	xmxm = uint64((*VP8DistoStats)(unsafe.Pointer(stats)).Fxm) * uint64((*VP8DistoStats)(unsafe.Pointer(stats)).Fxm)
 	ymym = uint64((*VP8DistoStats)(unsafe.Pointer(stats)).Fym) * uint64((*VP8DistoStats)(unsafe.Pointer(stats)).Fym)
 	if xmxm+ymym >= uint64(C3) {
 		xmym = libc.Int64FromUint32((*VP8DistoStats)(unsafe.Pointer(stats)).Fxm) * libc.Int64FromUint32((*VP8DistoStats)(unsafe.Pointer(stats)).Fym)
 		sxy = libc.Int64FromUint32((*VP8DistoStats)(unsafe.Pointer(stats)).Fxym)*libc.Int64FromUint32(N) - xmym // can be negative
 		sxx = uint64((*VP8DistoStats)(unsafe.Pointer(stats)).Fxxm)*uint64(N) - xmxm
 		syy = uint64((*VP8DistoStats)(unsafe.Pointer(stats)).Fyym)*uint64(N) - ymym
 		if sxy < 0 {
 			v1 = 0
 		} else {
 			v1 = sxy
 		}
 		// we descale by 8 to prevent overflow during the fnum/fden multiply.
 		num_S = (uint64(2)*libc.Uint64FromInt64(v1) + uint64(C2)) >> int32(8)
 		den_S = (sxx + syy + uint64(C2)) >> int32(8)
 		fnum = libc.Uint64FromInt64(libc.Int64FromInt32(2)*xmym+libc.Int64FromUint32(C1)) * num_S
 		fden = (xmxm + ymym + uint64(C1)) * den_S
 		r = float64(fnum) / float64(fden)
 		return r
 	}
 	return float64(1) // area is too dark to contribute meaningfully
 }
 
 func VP8SSIMFromStats(tls *libc.TLS, stats uintptr) (r float64) {
 	return SSIMCalculation(tls, stats, kWeightSum)
 }
 
 func VP8SSIMFromStatsClipped(tls *libc.TLS, stats uintptr) (r float64) {
 	return SSIMCalculation(tls, stats, (*VP8DistoStats)(unsafe.Pointer(stats)).Fw)
 }
 
 func SSIMGetClipped_C(tls *libc.TLS, src1 uintptr, stride1 int32, src2 uintptr, stride2 int32, xo int32, yo int32, W int32, H int32) (r float64) {
 	bp := tls.Alloc(32)
 	defer tls.Free(32)
 	var s1, s2, w uint32_t
 	var x, xmax, xmin, y, ymax, ymin, v1, v2, v3, v4 int32
 	var _ /* stats at bp+0 */ VP8DistoStats
 	_, _, _, _, _, _, _, _, _, _, _, _, _ = s1, s2, w, x, xmax, xmin, y, ymax, ymin, v1, v2, v3, v4
 	**(**VP8DistoStats)(__ccgo_up(bp)) = VP8DistoStats{}
 	if yo-int32(VP8_SSIM_KERNEL) < 0 {
 		v1 = 0
 	} else {
 		v1 = yo - int32(VP8_SSIM_KERNEL)
 	}
 	ymin = v1
 	if yo+int32(VP8_SSIM_KERNEL) > H-int32(1) {
 		v2 = H - int32(1)
 	} else {
 		v2 = yo + int32(VP8_SSIM_KERNEL)
 	}
 	ymax = v2
 	if xo-int32(VP8_SSIM_KERNEL) < 0 {
 		v3 = 0
 	} else {
 		v3 = xo - int32(VP8_SSIM_KERNEL)
 	}
 	xmin = v3
 	if xo+int32(VP8_SSIM_KERNEL) > W-int32(1) {
 		v4 = W - int32(1)
 	} else {
 		v4 = xo + int32(VP8_SSIM_KERNEL)
 	}
 	xmax = v4
 	src1 = src1 + uintptr(ymin*stride1)
 	src2 = src2 + uintptr(ymin*stride2)
 	y = ymin
 	for {
 		if !(y <= ymax) {
 			break
 		}
 		x = xmin
 		for {
 			if !(x <= xmax) {
 				break
 			}
 			w = kWeight[int32(VP8_SSIM_KERNEL)+x-xo] * kWeight[int32(VP8_SSIM_KERNEL)+y-yo]
 			s1 = uint32(**(**uint8_t)(__ccgo_up(src1 + uintptr(x))))
 			s2 = uint32(**(**uint8_t)(__ccgo_up(src2 + uintptr(x))))
 			(**(**VP8DistoStats)(__ccgo_up(bp))).Fw += w
 			(**(**VP8DistoStats)(__ccgo_up(bp))).Fxm += w * s1
 			(**(**VP8DistoStats)(__ccgo_up(bp))).Fym += w * s2
 			(**(**VP8DistoStats)(__ccgo_up(bp))).Fxxm += w * s1 * s1
 			(**(**VP8DistoStats)(__ccgo_up(bp))).Fxym += w * s1 * s2
 			(**(**VP8DistoStats)(__ccgo_up(bp))).Fyym += w * s2 * s2
 			goto _6
 		_6:
 			;
 			x = x + 1
 		}
 		goto _5
 	_5:
 		;
 		y = y + 1
 		src1 = src1 + uintptr(stride1)
 		src2 = src2 + uintptr(stride2)
 	}
 	return VP8SSIMFromStatsClipped(tls, bp)
 }
 
 func SSIMGet_C(tls *libc.TLS, src1 uintptr, stride1 int32, src2 uintptr, stride2 int32) (r float64) {
 	bp := tls.Alloc(32)
 	defer tls.Free(32)
 	var s1, s2, w uint32_t
 	var x, y int32
 	var _ /* stats at bp+0 */ VP8DistoStats
 	_, _, _, _, _ = s1, s2, w, x, y
 	**(**VP8DistoStats)(__ccgo_up(bp)) = VP8DistoStats{}
 	y = 0
 	for {
 		if !(y <= libc.Int32FromInt32(2)*libc.Int32FromInt32(VP8_SSIM_KERNEL)) {
 			break
 		}
 		x = 0
 		for {
 			if !(x <= libc.Int32FromInt32(2)*libc.Int32FromInt32(VP8_SSIM_KERNEL)) {
 				break
 			}
 			w = kWeight[x] * kWeight[y]
 			s1 = uint32(**(**uint8_t)(__ccgo_up(src1 + uintptr(x))))
 			s2 = uint32(**(**uint8_t)(__ccgo_up(src2 + uintptr(x))))
 			(**(**VP8DistoStats)(__ccgo_up(bp))).Fxm += w * s1
 			(**(**VP8DistoStats)(__ccgo_up(bp))).Fym += w * s2
 			(**(**VP8DistoStats)(__ccgo_up(bp))).Fxxm += w * s1 * s1
 			(**(**VP8DistoStats)(__ccgo_up(bp))).Fxym += w * s1 * s2
 			(**(**VP8DistoStats)(__ccgo_up(bp))).Fyym += w * s2 * s2
 			goto _2
 		_2:
 			;
 			x = x + 1
 		}
 		goto _1
 	_1:
 		;
 		y = y + 1
 		src1 = src1 + uintptr(stride1)
 		src2 = src2 + uintptr(stride2)
 	}
 	return VP8SSIMFromStats(tls, bp)
 }
 
 //------------------------------------------------------------------------------
 
 func AccumulateSSE_C(tls *libc.TLS, src1 uintptr, src2 uintptr, len1 int32) (r uint32_t) {
 	var diff int32_t
 	var i int32
 	var sse2 uint32_t
 	_, _, _ = diff, i, sse2
 	sse2 = uint32(0)
 	// to ensure that accumulation fits within uint32_t
 	i = 0
 	for {
 		if !(i < len1) {
 			break
 		}
 		diff = libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(src1 + uintptr(i)))) - libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(src2 + uintptr(i))))
 		sse2 = sse2 + libc.Uint32FromInt32(diff*diff)
 		goto _1
 	_1:
 		;
 		i = i + 1
 	}
 	return sse2
 }
 
 func VP8SSIMDspInit(tls *libc.TLS) {
 	if libc.AtomicLoadPUintptr(uintptr(unsafe.Pointer(&VP8SSIMDspInit_body_last_cpuinfo_used))) == VP8GetCPUInfo {
 		goto _1
 	}
 	VP8SSIMDspInit_body(tls)
 	libc.AtomicStorePUintptr(uintptr(unsafe.Pointer(&VP8SSIMDspInit_body_last_cpuinfo_used)), VP8GetCPUInfo)
 	goto _2
 _2:
 	;
 	goto _1
 _1: /**/ //
 }
 
 var VP8SSIMDspInit_body_last_cpuinfo_used = uintptr(0)
 
 func init() {
 	p := unsafe.Pointer(&VP8SSIMDspInit_body_last_cpuinfo_used)
 	*(*uintptr)(unsafe.Add(p, 0)) = uintptr(unsafe.Pointer(&VP8SSIMDspInit_body_last_cpuinfo_used))
 }
 
 func VP8SSIMDspInit_body(tls *libc.TLS) {
 	VP8SSIMGetClipped = __ccgo_fp(SSIMGetClipped_C)
 	VP8SSIMGet = __ccgo_fp(SSIMGet_C)
 	VP8AccumulateSSE = __ccgo_fp(AccumulateSSE_C)
 	if VP8GetCPUInfo != libc.UintptrFromInt32(0) {
 	}
 }
 
 func VP8SSIMDspInitSSE2(tls *libc.TLS) {
 }
 
 // Given samples laid out in a square as:
 //  [a b]
 //  [c d]
 // we interpolate u/v as:
 //  ([9*a + 3*b + 3*c +   d    3*a + 9*b + 3*c +   d] + [8 8]) / 16
 //  ([3*a +   b + 9*c + 3*d      a + 3*b + 3*c + 9*d]   [8 8]) / 16
 
 // We process u and v together stashed into 32bit (16bit each).
 
 // C documentation
 //
 //	// All variants implemented.
 func UpsampleRgbaLinePair_C(tls *libc.TLS, top_y uintptr, bottom_y uintptr, top_u uintptr, top_v uintptr, cur_u uintptr, cur_v uintptr, top_dst uintptr, bottom_dst uintptr, len1 int32) {
 	var avg, diag_03, diag_12, l_uv, t_uv, tl_uv, uv, uv0, uv01, uv02, uv03, uv04, uv05, uv1, uv11 uint32_t
 	var last_pixel_pair, x, v10, v12, v13, v15, v16, v17, v19, v2, v21, v23, v25, v26, v28, v29, v3, v30, v32, v34, v36, v37, v39, v4, v40, v6, v8 int32
 	var v1, v5 uintptr
 	_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = avg, diag_03, diag_12, l_uv, last_pixel_pair, t_uv, tl_uv, uv, uv0, uv01, uv02, uv03, uv04, uv05, uv1, uv11, x, v1, v10, v12, v13, v15, v16, v17, v19, v2, v21, v23, v25, v26, v28, v29, v3, v30, v32, v34, v36, v37, v39, v4, v40, v5, v6, v8
 	last_pixel_pair = (len1 - int32(1)) >> int32(1)
 	tl_uv = libc.Uint32FromInt32(libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(top_u))) | libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(top_v)))<<libc.Int32FromInt32(16)) /* top-left sample */
 	l_uv = libc.Uint32FromInt32(libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(cur_u))) | libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(cur_v)))<<libc.Int32FromInt32(16))
 	uv0 = (uint32(3)*tl_uv + l_uv + uint32(0x00020002)) >> int32(2)
 	v1 = top_dst
 	v2 = libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(top_y)))
 	v3 = libc.Int32FromUint8(uint8(uv0 & uint32(0xff)))
 	v4 = libc.Int32FromUint8(uint8(uv0 >> libc.Int32FromInt32(16)))
 	v5 = v1
 	v8 = v2 * int32(19077) >> int32(8)
 	goto _9
 _9:
 	v10 = v4 * int32(26149) >> int32(8)
 	goto _11
 _11:
 	v12 = v8 + v10 - int32(14234)
 	if v12 & ^int32(YUV_MASK2) == 0 {
 		v15 = v12 >> int32(YUV_FIX2)
 	} else {
 		if v12 < 0 {
 			v16 = 0
 		} else {
 			v16 = int32(255)
 		}
 		v15 = v16
 	}
 	v13 = v15
 	goto _14
 _14:
 	v6 = v13
 	goto _7
 _7:
 	**(**uint8_t)(__ccgo_up(v5)) = libc.Uint8FromInt32(v6)
 	v19 = v2 * int32(19077) >> int32(8)
 	goto _20
 _20:
 	v21 = v3 * int32(6419) >> int32(8)
 	goto _22
 _22:
 	v23 = v4 * int32(13320) >> int32(8)
 	goto _24
 _24:
 	v25 = v19 - v21 - v23 + int32(8708)
 	if v25 & ^int32(YUV_MASK2) == 0 {
 		v28 = v25 >> int32(YUV_FIX2)
 	} else {
 		if v25 < 0 {
 			v29 = 0
 		} else {
 			v29 = int32(255)
 		}
 		v28 = v29
 	}
 	v26 = v28
 	goto _27
 _27:
 	v17 = v26
 	goto _18
 _18:
 	**(**uint8_t)(__ccgo_up(v5 + 1)) = libc.Uint8FromInt32(v17)
 	v32 = v2 * int32(19077) >> int32(8)
 	goto _33
 _33:
 	v34 = v3 * int32(33050) >> int32(8)
 	goto _35
 _35:
 	v36 = v32 + v34 - int32(17685)
 	if v36 & ^int32(YUV_MASK2) == 0 {
 		v39 = v36 >> int32(YUV_FIX2)
 	} else {
 		if v36 < 0 {
 			v40 = 0
 		} else {
 			v40 = int32(255)
 		}
 		v39 = v40
 	}
 	v37 = v39
 	goto _38
 _38:
 	v30 = v37
 	goto _31
 _31:
 	**(**uint8_t)(__ccgo_up(v5 + 2)) = libc.Uint8FromInt32(v30)
 	**(**uint8_t)(__ccgo_up(v1 + 3)) = uint8(0xff)
 	if bottom_y != libc.UintptrFromInt32(0) {
 		uv01 = (uint32(3)*l_uv + tl_uv + uint32(0x00020002)) >> int32(2)
 		v1 = bottom_dst
 		v2 = libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(bottom_y)))
 		v3 = libc.Int32FromUint8(uint8(uv01 & uint32(0xff)))
 		v4 = libc.Int32FromUint8(uint8(uv01 >> libc.Int32FromInt32(16)))
 		v5 = v1
 		v8 = v2 * int32(19077) >> int32(8)
 		goto _49
 	_49:
 		v10 = v4 * int32(26149) >> int32(8)
 		goto _51
 	_51:
 		v12 = v8 + v10 - int32(14234)
 		if v12 & ^int32(YUV_MASK2) == 0 {
 			v15 = v12 >> int32(YUV_FIX2)
 		} else {
 			if v12 < 0 {
 				v16 = 0
 			} else {
 				v16 = int32(255)
 			}
 			v15 = v16
 		}
 		v13 = v15
 		goto _54
 	_54:
 		v6 = v13
 		goto _47
 	_47:
 		**(**uint8_t)(__ccgo_up(v5)) = libc.Uint8FromInt32(v6)
 		v19 = v2 * int32(19077) >> int32(8)
 		goto _60
 	_60:
 		v21 = v3 * int32(6419) >> int32(8)
 		goto _62
 	_62:
 		v23 = v4 * int32(13320) >> int32(8)
 		goto _64
 	_64:
 		v25 = v19 - v21 - v23 + int32(8708)
 		if v25 & ^int32(YUV_MASK2) == 0 {
 			v28 = v25 >> int32(YUV_FIX2)
 		} else {
 			if v25 < 0 {
 				v29 = 0
 			} else {
 				v29 = int32(255)
 			}
 			v28 = v29
 		}
 		v26 = v28
 		goto _67
 	_67:
 		v17 = v26
 		goto _58
 	_58:
 		**(**uint8_t)(__ccgo_up(v5 + 1)) = libc.Uint8FromInt32(v17)
 		v32 = v2 * int32(19077) >> int32(8)
 		goto _73
 	_73:
 		v34 = v3 * int32(33050) >> int32(8)
 		goto _75
 	_75:
 		v36 = v32 + v34 - int32(17685)
 		if v36 & ^int32(YUV_MASK2) == 0 {
 			v39 = v36 >> int32(YUV_FIX2)
 		} else {
 			if v36 < 0 {
 				v40 = 0
 			} else {
 				v40 = int32(255)
 			}
 			v39 = v40
 		}
 		v37 = v39
 		goto _78
 	_78:
 		v30 = v37
 		goto _71
 	_71:
 		**(**uint8_t)(__ccgo_up(v5 + 2)) = libc.Uint8FromInt32(v30)
 		**(**uint8_t)(__ccgo_up(v1 + 3)) = uint8(0xff)
 	}
 	x = int32(1)
 	for {
 		if !(x <= last_pixel_pair) {
 			break
 		}
 		t_uv = libc.Uint32FromInt32(libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(top_u + uintptr(x)))) | libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(top_v + uintptr(x))))<<libc.Int32FromInt32(16)) /* top sample */
 		uv = libc.Uint32FromInt32(libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(cur_u + uintptr(x)))) | libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(cur_v + uintptr(x))))<<libc.Int32FromInt32(16))   /* sample */ /* precompute invariant values associated with first and second diagonals*/
 		avg = tl_uv + t_uv + l_uv + uv + uint32(0x00080008)
 		diag_12 = (avg + uint32(2)*(t_uv+l_uv)) >> int32(3)
 		diag_03 = (avg + uint32(2)*(tl_uv+uv)) >> int32(3)
 		uv02 = (diag_12 + tl_uv) >> int32(1)
 		uv1 = (diag_03 + t_uv) >> int32(1)
 		v1 = top_dst + uintptr((int32(2)*x-int32(1))*int32(4))
 		v2 = libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(top_y + uintptr(int32(2)*x-int32(1)))))
 		v3 = libc.Int32FromUint8(uint8(uv02 & uint32(0xff)))
 		v4 = libc.Int32FromUint8(uint8(uv02 >> libc.Int32FromInt32(16)))
 		v5 = v1
 		v8 = v2 * int32(19077) >> int32(8)
 		goto _90
 	_90:
 		v10 = v4 * int32(26149) >> int32(8)
 		goto _92
 	_92:
 		v12 = v8 + v10 - int32(14234)
 		if v12 & ^int32(YUV_MASK2) == 0 {
 			v15 = v12 >> int32(YUV_FIX2)
 		} else {
 			if v12 < 0 {
 				v16 = 0
 			} else {
 				v16 = int32(255)
 			}
 			v15 = v16
 		}
 		v13 = v15
 		goto _95
 	_95:
 		v6 = v13
 		goto _88
 	_88:
 		**(**uint8_t)(__ccgo_up(v5)) = libc.Uint8FromInt32(v6)
 		v19 = v2 * int32(19077) >> int32(8)
 		goto _101
 	_101:
 		v21 = v3 * int32(6419) >> int32(8)
 		goto _103
 	_103:
 		v23 = v4 * int32(13320) >> int32(8)
 		goto _105
 	_105:
 		v25 = v19 - v21 - v23 + int32(8708)
 		if v25 & ^int32(YUV_MASK2) == 0 {
 			v28 = v25 >> int32(YUV_FIX2)
 		} else {
 			if v25 < 0 {
 				v29 = 0
 			} else {
 				v29 = int32(255)
 			}
 			v28 = v29
 		}
 		v26 = v28
 		goto _108
 	_108:
 		v17 = v26
 		goto _99
 	_99:
 		**(**uint8_t)(__ccgo_up(v5 + 1)) = libc.Uint8FromInt32(v17)
 		v32 = v2 * int32(19077) >> int32(8)
 		goto _114
 	_114:
 		v34 = v3 * int32(33050) >> int32(8)
 		goto _116
 	_116:
 		v36 = v32 + v34 - int32(17685)
 		if v36 & ^int32(YUV_MASK2) == 0 {
 			v39 = v36 >> int32(YUV_FIX2)
 		} else {
 			if v36 < 0 {
 				v40 = 0
 			} else {
 				v40 = int32(255)
 			}
 			v39 = v40
 		}
 		v37 = v39
 		goto _119
 	_119:
 		v30 = v37
 		goto _112
 	_112:
 		**(**uint8_t)(__ccgo_up(v5 + 2)) = libc.Uint8FromInt32(v30)
 		**(**uint8_t)(__ccgo_up(v1 + 3)) = uint8(0xff)
 		v1 = top_dst + uintptr((int32(2)*x-0)*int32(4))
 		v2 = libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(top_y + uintptr(int32(2)*x-0))))
 		v3 = libc.Int32FromUint8(uint8(uv1 & uint32(0xff)))
 		v4 = libc.Int32FromUint8(uint8(uv1 >> libc.Int32FromInt32(16)))
 		v5 = v1
 		v8 = v2 * int32(19077) >> int32(8)
 		goto _130
 	_130:
 		v10 = v4 * int32(26149) >> int32(8)
 		goto _132
 	_132:
 		v12 = v8 + v10 - int32(14234)
 		if v12 & ^int32(YUV_MASK2) == 0 {
 			v15 = v12 >> int32(YUV_FIX2)
 		} else {
 			if v12 < 0 {
 				v16 = 0
 			} else {
 				v16 = int32(255)
 			}
 			v15 = v16
 		}
 		v13 = v15
 		goto _135
 	_135:
 		v6 = v13
 		goto _128
 	_128:
 		**(**uint8_t)(__ccgo_up(v5)) = libc.Uint8FromInt32(v6)
 		v19 = v2 * int32(19077) >> int32(8)
 		goto _141
 	_141:
 		v21 = v3 * int32(6419) >> int32(8)
 		goto _143
 	_143:
 		v23 = v4 * int32(13320) >> int32(8)
 		goto _145
 	_145:
 		v25 = v19 - v21 - v23 + int32(8708)
 		if v25 & ^int32(YUV_MASK2) == 0 {
 			v28 = v25 >> int32(YUV_FIX2)
 		} else {
 			if v25 < 0 {
 				v29 = 0
 			} else {
 				v29 = int32(255)
 			}
 			v28 = v29
 		}
 		v26 = v28
 		goto _148
 	_148:
 		v17 = v26
 		goto _139
 	_139:
 		**(**uint8_t)(__ccgo_up(v5 + 1)) = libc.Uint8FromInt32(v17)
 		v32 = v2 * int32(19077) >> int32(8)
 		goto _154
 	_154:
 		v34 = v3 * int32(33050) >> int32(8)
 		goto _156
 	_156:
 		v36 = v32 + v34 - int32(17685)
 		if v36 & ^int32(YUV_MASK2) == 0 {
 			v39 = v36 >> int32(YUV_FIX2)
 		} else {
 			if v36 < 0 {
 				v40 = 0
 			} else {
 				v40 = int32(255)
 			}
 			v39 = v40
 		}
 		v37 = v39
 		goto _159
 	_159:
 		v30 = v37
 		goto _152
 	_152:
 		**(**uint8_t)(__ccgo_up(v5 + 2)) = libc.Uint8FromInt32(v30)
 		**(**uint8_t)(__ccgo_up(v1 + 3)) = uint8(0xff)
 		if bottom_y != libc.UintptrFromInt32(0) {
 			uv03 = (diag_03 + l_uv) >> int32(1)
 			uv11 = (diag_12 + uv) >> int32(1)
 			v1 = bottom_dst + uintptr((int32(2)*x-int32(1))*int32(4))
 			v2 = libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(bottom_y + uintptr(int32(2)*x-int32(1)))))
 			v3 = libc.Int32FromUint8(uint8(uv03 & uint32(0xff)))
 			v4 = libc.Int32FromUint8(uint8(uv03 >> libc.Int32FromInt32(16)))
 			v5 = v1
 			v8 = v2 * int32(19077) >> int32(8)
 			goto _170
 		_170:
 			v10 = v4 * int32(26149) >> int32(8)
 			goto _172
 		_172:
 			v12 = v8 + v10 - int32(14234)
 			if v12 & ^int32(YUV_MASK2) == 0 {
 				v15 = v12 >> int32(YUV_FIX2)
 			} else {
 				if v12 < 0 {
 					v16 = 0
 				} else {
 					v16 = int32(255)
 				}
 				v15 = v16
 			}
 			v13 = v15
 			goto _175
 		_175:
 			v6 = v13
 			goto _168
 		_168:
 			**(**uint8_t)(__ccgo_up(v5)) = libc.Uint8FromInt32(v6)
 			v19 = v2 * int32(19077) >> int32(8)
 			goto _181
 		_181:
 			v21 = v3 * int32(6419) >> int32(8)
 			goto _183
 		_183:
 			v23 = v4 * int32(13320) >> int32(8)
 			goto _185
 		_185:
 			v25 = v19 - v21 - v23 + int32(8708)
 			if v25 & ^int32(YUV_MASK2) == 0 {
 				v28 = v25 >> int32(YUV_FIX2)
 			} else {
 				if v25 < 0 {
 					v29 = 0
 				} else {
 					v29 = int32(255)
 				}
 				v28 = v29
 			}
 			v26 = v28
 			goto _188
 		_188:
 			v17 = v26
 			goto _179
 		_179:
 			**(**uint8_t)(__ccgo_up(v5 + 1)) = libc.Uint8FromInt32(v17)
 			v32 = v2 * int32(19077) >> int32(8)
 			goto _194
 		_194:
 			v34 = v3 * int32(33050) >> int32(8)
 			goto _196
 		_196:
 			v36 = v32 + v34 - int32(17685)
 			if v36 & ^int32(YUV_MASK2) == 0 {
 				v39 = v36 >> int32(YUV_FIX2)
 			} else {
 				if v36 < 0 {
 					v40 = 0
 				} else {
 					v40 = int32(255)
 				}
 				v39 = v40
 			}
 			v37 = v39
 			goto _199
 		_199:
 			v30 = v37
 			goto _192
 		_192:
 			**(**uint8_t)(__ccgo_up(v5 + 2)) = libc.Uint8FromInt32(v30)
 			**(**uint8_t)(__ccgo_up(v1 + 3)) = uint8(0xff)
 			v1 = bottom_dst + uintptr((int32(2)*x+0)*int32(4))
 			v2 = libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(bottom_y + uintptr(int32(2)*x+0))))
 			v3 = libc.Int32FromUint8(uint8(uv11 & uint32(0xff)))
 			v4 = libc.Int32FromUint8(uint8(uv11 >> libc.Int32FromInt32(16)))
 			v5 = v1
 			v8 = v2 * int32(19077) >> int32(8)
 			goto _210
 		_210:
 			v10 = v4 * int32(26149) >> int32(8)
 			goto _212
 		_212:
 			v12 = v8 + v10 - int32(14234)
 			if v12 & ^int32(YUV_MASK2) == 0 {
 				v15 = v12 >> int32(YUV_FIX2)
 			} else {
 				if v12 < 0 {
 					v16 = 0
 				} else {
 					v16 = int32(255)
 				}
 				v15 = v16
 			}
 			v13 = v15
 			goto _215
 		_215:
 			v6 = v13
 			goto _208
 		_208:
 			**(**uint8_t)(__ccgo_up(v5)) = libc.Uint8FromInt32(v6)
 			v19 = v2 * int32(19077) >> int32(8)
 			goto _221
 		_221:
 			v21 = v3 * int32(6419) >> int32(8)
 			goto _223
 		_223:
 			v23 = v4 * int32(13320) >> int32(8)
 			goto _225
 		_225:
 			v25 = v19 - v21 - v23 + int32(8708)
 			if v25 & ^int32(YUV_MASK2) == 0 {
 				v28 = v25 >> int32(YUV_FIX2)
 			} else {
 				if v25 < 0 {
 					v29 = 0
 				} else {
 					v29 = int32(255)
 				}
 				v28 = v29
 			}
 			v26 = v28
 			goto _228
 		_228:
 			v17 = v26
 			goto _219
 		_219:
 			**(**uint8_t)(__ccgo_up(v5 + 1)) = libc.Uint8FromInt32(v17)
 			v32 = v2 * int32(19077) >> int32(8)
 			goto _234
 		_234:
 			v34 = v3 * int32(33050) >> int32(8)
 			goto _236
 		_236:
 			v36 = v32 + v34 - int32(17685)
 			if v36 & ^int32(YUV_MASK2) == 0 {
 				v39 = v36 >> int32(YUV_FIX2)
 			} else {
 				if v36 < 0 {
 					v40 = 0
 				} else {
 					v40 = int32(255)
 				}
 				v39 = v40
 			}
 			v37 = v39
 			goto _239
 		_239:
 			v30 = v37
 			goto _232
 		_232:
 			**(**uint8_t)(__ccgo_up(v5 + 2)) = libc.Uint8FromInt32(v30)
 			**(**uint8_t)(__ccgo_up(v1 + 3)) = uint8(0xff)
 		}
 		tl_uv = t_uv
 		l_uv = uv
 		goto _81
 	_81:
 		;
 		x = x + 1
 	}
 	if !(len1&libc.Int32FromInt32(1) != 0) {
 		uv04 = (uint32(3)*tl_uv + l_uv + uint32(0x00020002)) >> int32(2)
 		v1 = top_dst + uintptr((len1-int32(1))*int32(4))
 		v2 = libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(top_y + uintptr(len1-int32(1)))))
 		v3 = libc.Int32FromUint8(uint8(uv04 & uint32(0xff)))
 		v4 = libc.Int32FromUint8(uint8(uv04 >> libc.Int32FromInt32(16)))
 		v5 = v1
 		v8 = v2 * int32(19077) >> int32(8)
 		goto _250
 	_250:
 		v10 = v4 * int32(26149) >> int32(8)
 		goto _252
 	_252:
 		v12 = v8 + v10 - int32(14234)
 		if v12 & ^int32(YUV_MASK2) == 0 {
 			v15 = v12 >> int32(YUV_FIX2)
 		} else {
 			if v12 < 0 {
 				v16 = 0
 			} else {
 				v16 = int32(255)
 			}
 			v15 = v16
 		}
 		v13 = v15
 		goto _255
 	_255:
 		v6 = v13
 		goto _248
 	_248:
 		**(**uint8_t)(__ccgo_up(v5)) = libc.Uint8FromInt32(v6)
 		v19 = v2 * int32(19077) >> int32(8)
 		goto _261
 	_261:
 		v21 = v3 * int32(6419) >> int32(8)
 		goto _263
 	_263:
 		v23 = v4 * int32(13320) >> int32(8)
 		goto _265
 	_265:
 		v25 = v19 - v21 - v23 + int32(8708)
 		if v25 & ^int32(YUV_MASK2) == 0 {
 			v28 = v25 >> int32(YUV_FIX2)
 		} else {
 			if v25 < 0 {
 				v29 = 0
 			} else {
 				v29 = int32(255)
 			}
 			v28 = v29
 		}
 		v26 = v28
 		goto _268
 	_268:
 		v17 = v26
 		goto _259
 	_259:
 		**(**uint8_t)(__ccgo_up(v5 + 1)) = libc.Uint8FromInt32(v17)
 		v32 = v2 * int32(19077) >> int32(8)
 		goto _274
 	_274:
 		v34 = v3 * int32(33050) >> int32(8)
 		goto _276
 	_276:
 		v36 = v32 + v34 - int32(17685)
 		if v36 & ^int32(YUV_MASK2) == 0 {
 			v39 = v36 >> int32(YUV_FIX2)
 		} else {
 			if v36 < 0 {
 				v40 = 0
 			} else {
 				v40 = int32(255)
 			}
 			v39 = v40
 		}
 		v37 = v39
 		goto _279
 	_279:
 		v30 = v37
 		goto _272
 	_272:
 		**(**uint8_t)(__ccgo_up(v5 + 2)) = libc.Uint8FromInt32(v30)
 		**(**uint8_t)(__ccgo_up(v1 + 3)) = uint8(0xff)
 		if bottom_y != libc.UintptrFromInt32(0) {
 			uv05 = (uint32(3)*l_uv + tl_uv + uint32(0x00020002)) >> int32(2)
 			v1 = bottom_dst + uintptr((len1-int32(1))*int32(4))
 			v2 = libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(bottom_y + uintptr(len1-int32(1)))))
 			v3 = libc.Int32FromUint8(uint8(uv05 & uint32(0xff)))
 			v4 = libc.Int32FromUint8(uint8(uv05 >> libc.Int32FromInt32(16)))
 			v5 = v1
 			v8 = v2 * int32(19077) >> int32(8)
 			goto _290
 		_290:
 			v10 = v4 * int32(26149) >> int32(8)
 			goto _292
 		_292:
 			v12 = v8 + v10 - int32(14234)
 			if v12 & ^int32(YUV_MASK2) == 0 {
 				v15 = v12 >> int32(YUV_FIX2)
 			} else {
 				if v12 < 0 {
 					v16 = 0
 				} else {
 					v16 = int32(255)
 				}
 				v15 = v16
 			}
 			v13 = v15
 			goto _295
 		_295:
 			v6 = v13
 			goto _288
 		_288:
 			**(**uint8_t)(__ccgo_up(v5)) = libc.Uint8FromInt32(v6)
 			v19 = v2 * int32(19077) >> int32(8)
 			goto _301
 		_301:
 			v21 = v3 * int32(6419) >> int32(8)
 			goto _303
 		_303:
 			v23 = v4 * int32(13320) >> int32(8)
 			goto _305
 		_305:
 			v25 = v19 - v21 - v23 + int32(8708)
 			if v25 & ^int32(YUV_MASK2) == 0 {
 				v28 = v25 >> int32(YUV_FIX2)
 			} else {
 				if v25 < 0 {
 					v29 = 0
 				} else {
 					v29 = int32(255)
 				}
 				v28 = v29
 			}
 			v26 = v28
 			goto _308
 		_308:
 			v17 = v26
 			goto _299
 		_299:
 			**(**uint8_t)(__ccgo_up(v5 + 1)) = libc.Uint8FromInt32(v17)
 			v32 = v2 * int32(19077) >> int32(8)
 			goto _314
 		_314:
 			v34 = v3 * int32(33050) >> int32(8)
 			goto _316
 		_316:
 			v36 = v32 + v34 - int32(17685)
 			if v36 & ^int32(YUV_MASK2) == 0 {
 				v39 = v36 >> int32(YUV_FIX2)
 			} else {
 				if v36 < 0 {
 					v40 = 0
 				} else {
 					v40 = int32(255)
 				}
 				v39 = v40
 			}
 			v37 = v39
 			goto _319
 		_319:
 			v30 = v37
 			goto _312
 		_312:
 			**(**uint8_t)(__ccgo_up(v5 + 2)) = libc.Uint8FromInt32(v30)
 			**(**uint8_t)(__ccgo_up(v1 + 3)) = uint8(0xff)
 		}
 	}
 }
 
 func UpsampleBgraLinePair_C(tls *libc.TLS, top_y uintptr, bottom_y uintptr, top_u uintptr, top_v uintptr, cur_u uintptr, cur_v uintptr, top_dst uintptr, bottom_dst uintptr, len1 int32) {
 	var avg, diag_03, diag_12, l_uv, t_uv, tl_uv, uv, uv0, uv01, uv02, uv03, uv04, uv05, uv1, uv11 uint32_t
 	var last_pixel_pair, x, v10, v12, v13, v15, v16, v17, v19, v2, v21, v23, v25, v26, v28, v29, v3, v30, v32, v34, v36, v37, v39, v4, v40, v6, v8 int32
 	var v1, v5 uintptr
 	_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = avg, diag_03, diag_12, l_uv, last_pixel_pair, t_uv, tl_uv, uv, uv0, uv01, uv02, uv03, uv04, uv05, uv1, uv11, x, v1, v10, v12, v13, v15, v16, v17, v19, v2, v21, v23, v25, v26, v28, v29, v3, v30, v32, v34, v36, v37, v39, v4, v40, v5, v6, v8
 	last_pixel_pair = (len1 - int32(1)) >> int32(1)
 	tl_uv = libc.Uint32FromInt32(libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(top_u))) | libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(top_v)))<<libc.Int32FromInt32(16)) /* top-left sample */
 	l_uv = libc.Uint32FromInt32(libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(cur_u))) | libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(cur_v)))<<libc.Int32FromInt32(16))
 	uv0 = (uint32(3)*tl_uv + l_uv + uint32(0x00020002)) >> int32(2)
 	v1 = top_dst
 	v2 = libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(top_y)))
 	v3 = libc.Int32FromUint8(uint8(uv0 & uint32(0xff)))
 	v4 = libc.Int32FromUint8(uint8(uv0 >> libc.Int32FromInt32(16)))
 	v5 = v1
 	v8 = v2 * int32(19077) >> int32(8)
 	goto _9
 _9:
 	v10 = v3 * int32(33050) >> int32(8)
 	goto _11
 _11:
 	v12 = v8 + v10 - int32(17685)
 	if v12 & ^int32(YUV_MASK2) == 0 {
 		v15 = v12 >> int32(YUV_FIX2)
 	} else {
 		if v12 < 0 {
 			v16 = 0
 		} else {
 			v16 = int32(255)
 		}
 		v15 = v16
 	}
 	v13 = v15
 	goto _14
 _14:
 	v6 = v13
 	goto _7
 _7:
 	**(**uint8_t)(__ccgo_up(v5)) = libc.Uint8FromInt32(v6)
 	v19 = v2 * int32(19077) >> int32(8)
 	goto _20
 _20:
 	v21 = v3 * int32(6419) >> int32(8)
 	goto _22
 _22:
 	v23 = v4 * int32(13320) >> int32(8)
 	goto _24
 _24:
 	v25 = v19 - v21 - v23 + int32(8708)
 	if v25 & ^int32(YUV_MASK2) == 0 {
 		v28 = v25 >> int32(YUV_FIX2)
 	} else {
 		if v25 < 0 {
 			v29 = 0
 		} else {
 			v29 = int32(255)
 		}
 		v28 = v29
 	}
 	v26 = v28
 	goto _27
 _27:
 	v17 = v26
 	goto _18
 _18:
 	**(**uint8_t)(__ccgo_up(v5 + 1)) = libc.Uint8FromInt32(v17)
 	v32 = v2 * int32(19077) >> int32(8)
 	goto _33
 _33:
 	v34 = v4 * int32(26149) >> int32(8)
 	goto _35
 _35:
 	v36 = v32 + v34 - int32(14234)
 	if v36 & ^int32(YUV_MASK2) == 0 {
 		v39 = v36 >> int32(YUV_FIX2)
 	} else {
 		if v36 < 0 {
 			v40 = 0
 		} else {
 			v40 = int32(255)
 		}
 		v39 = v40
 	}
 	v37 = v39
 	goto _38
 _38:
 	v30 = v37
 	goto _31
 _31:
 	**(**uint8_t)(__ccgo_up(v5 + 2)) = libc.Uint8FromInt32(v30)
 	**(**uint8_t)(__ccgo_up(v1 + 3)) = uint8(0xff)
 	if bottom_y != libc.UintptrFromInt32(0) {
 		uv01 = (uint32(3)*l_uv + tl_uv + uint32(0x00020002)) >> int32(2)
 		v1 = bottom_dst
 		v2 = libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(bottom_y)))
 		v3 = libc.Int32FromUint8(uint8(uv01 & uint32(0xff)))
 		v4 = libc.Int32FromUint8(uint8(uv01 >> libc.Int32FromInt32(16)))
 		v5 = v1
 		v8 = v2 * int32(19077) >> int32(8)
 		goto _49
 	_49:
 		v10 = v3 * int32(33050) >> int32(8)
 		goto _51
 	_51:
 		v12 = v8 + v10 - int32(17685)
 		if v12 & ^int32(YUV_MASK2) == 0 {
 			v15 = v12 >> int32(YUV_FIX2)
 		} else {
 			if v12 < 0 {
 				v16 = 0
 			} else {
 				v16 = int32(255)
 			}
 			v15 = v16
 		}
 		v13 = v15
 		goto _54
 	_54:
 		v6 = v13
 		goto _47
 	_47:
 		**(**uint8_t)(__ccgo_up(v5)) = libc.Uint8FromInt32(v6)
 		v19 = v2 * int32(19077) >> int32(8)
 		goto _60
 	_60:
 		v21 = v3 * int32(6419) >> int32(8)
 		goto _62
 	_62:
 		v23 = v4 * int32(13320) >> int32(8)
 		goto _64
 	_64:
 		v25 = v19 - v21 - v23 + int32(8708)
 		if v25 & ^int32(YUV_MASK2) == 0 {
 			v28 = v25 >> int32(YUV_FIX2)
 		} else {
 			if v25 < 0 {
 				v29 = 0
 			} else {
 				v29 = int32(255)
 			}
 			v28 = v29
 		}
 		v26 = v28
 		goto _67
 	_67:
 		v17 = v26
 		goto _58
 	_58:
 		**(**uint8_t)(__ccgo_up(v5 + 1)) = libc.Uint8FromInt32(v17)
 		v32 = v2 * int32(19077) >> int32(8)
 		goto _73
 	_73:
 		v34 = v4 * int32(26149) >> int32(8)
 		goto _75
 	_75:
 		v36 = v32 + v34 - int32(14234)
 		if v36 & ^int32(YUV_MASK2) == 0 {
 			v39 = v36 >> int32(YUV_FIX2)
 		} else {
 			if v36 < 0 {
 				v40 = 0
 			} else {
 				v40 = int32(255)
 			}
 			v39 = v40
 		}
 		v37 = v39
 		goto _78
 	_78:
 		v30 = v37
 		goto _71
 	_71:
 		**(**uint8_t)(__ccgo_up(v5 + 2)) = libc.Uint8FromInt32(v30)
 		**(**uint8_t)(__ccgo_up(v1 + 3)) = uint8(0xff)
 	}
 	x = int32(1)
 	for {
 		if !(x <= last_pixel_pair) {
 			break
 		}
 		t_uv = libc.Uint32FromInt32(libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(top_u + uintptr(x)))) | libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(top_v + uintptr(x))))<<libc.Int32FromInt32(16)) /* top sample */
 		uv = libc.Uint32FromInt32(libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(cur_u + uintptr(x)))) | libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(cur_v + uintptr(x))))<<libc.Int32FromInt32(16))   /* sample */ /* precompute invariant values associated with first and second diagonals*/
 		avg = tl_uv + t_uv + l_uv + uv + uint32(0x00080008)
 		diag_12 = (avg + uint32(2)*(t_uv+l_uv)) >> int32(3)
 		diag_03 = (avg + uint32(2)*(tl_uv+uv)) >> int32(3)
 		uv02 = (diag_12 + tl_uv) >> int32(1)
 		uv1 = (diag_03 + t_uv) >> int32(1)
 		v1 = top_dst + uintptr((int32(2)*x-int32(1))*int32(4))
 		v2 = libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(top_y + uintptr(int32(2)*x-int32(1)))))
 		v3 = libc.Int32FromUint8(uint8(uv02 & uint32(0xff)))
 		v4 = libc.Int32FromUint8(uint8(uv02 >> libc.Int32FromInt32(16)))
 		v5 = v1
 		v8 = v2 * int32(19077) >> int32(8)
 		goto _90
 	_90:
 		v10 = v3 * int32(33050) >> int32(8)
 		goto _92
 	_92:
 		v12 = v8 + v10 - int32(17685)
 		if v12 & ^int32(YUV_MASK2) == 0 {
 			v15 = v12 >> int32(YUV_FIX2)
 		} else {
 			if v12 < 0 {
 				v16 = 0
 			} else {
 				v16 = int32(255)
 			}
 			v15 = v16
 		}
 		v13 = v15
 		goto _95
 	_95:
 		v6 = v13
 		goto _88
 	_88:
 		**(**uint8_t)(__ccgo_up(v5)) = libc.Uint8FromInt32(v6)
 		v19 = v2 * int32(19077) >> int32(8)
 		goto _101
 	_101:
 		v21 = v3 * int32(6419) >> int32(8)
 		goto _103
 	_103:
 		v23 = v4 * int32(13320) >> int32(8)
 		goto _105
 	_105:
 		v25 = v19 - v21 - v23 + int32(8708)
 		if v25 & ^int32(YUV_MASK2) == 0 {
 			v28 = v25 >> int32(YUV_FIX2)
 		} else {
 			if v25 < 0 {
 				v29 = 0
 			} else {
 				v29 = int32(255)
 			}
 			v28 = v29
 		}
 		v26 = v28
 		goto _108
 	_108:
 		v17 = v26
 		goto _99
 	_99:
 		**(**uint8_t)(__ccgo_up(v5 + 1)) = libc.Uint8FromInt32(v17)
 		v32 = v2 * int32(19077) >> int32(8)
 		goto _114
 	_114:
 		v34 = v4 * int32(26149) >> int32(8)
 		goto _116
 	_116:
 		v36 = v32 + v34 - int32(14234)
 		if v36 & ^int32(YUV_MASK2) == 0 {
 			v39 = v36 >> int32(YUV_FIX2)
 		} else {
 			if v36 < 0 {
 				v40 = 0
 			} else {
 				v40 = int32(255)
 			}
 			v39 = v40
 		}
 		v37 = v39
 		goto _119
 	_119:
 		v30 = v37
 		goto _112
 	_112:
 		**(**uint8_t)(__ccgo_up(v5 + 2)) = libc.Uint8FromInt32(v30)
 		**(**uint8_t)(__ccgo_up(v1 + 3)) = uint8(0xff)
 		v1 = top_dst + uintptr((int32(2)*x-0)*int32(4))
 		v2 = libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(top_y + uintptr(int32(2)*x-0))))
 		v3 = libc.Int32FromUint8(uint8(uv1 & uint32(0xff)))
 		v4 = libc.Int32FromUint8(uint8(uv1 >> libc.Int32FromInt32(16)))
 		v5 = v1
 		v8 = v2 * int32(19077) >> int32(8)
 		goto _130
 	_130:
 		v10 = v3 * int32(33050) >> int32(8)
 		goto _132
 	_132:
 		v12 = v8 + v10 - int32(17685)
 		if v12 & ^int32(YUV_MASK2) == 0 {
 			v15 = v12 >> int32(YUV_FIX2)
 		} else {
 			if v12 < 0 {
 				v16 = 0
 			} else {
 				v16 = int32(255)
 			}
 			v15 = v16
 		}
 		v13 = v15
 		goto _135
 	_135:
 		v6 = v13
 		goto _128
 	_128:
 		**(**uint8_t)(__ccgo_up(v5)) = libc.Uint8FromInt32(v6)
 		v19 = v2 * int32(19077) >> int32(8)
 		goto _141
 	_141:
 		v21 = v3 * int32(6419) >> int32(8)
 		goto _143
 	_143:
 		v23 = v4 * int32(13320) >> int32(8)
 		goto _145
 	_145:
 		v25 = v19 - v21 - v23 + int32(8708)
 		if v25 & ^int32(YUV_MASK2) == 0 {
 			v28 = v25 >> int32(YUV_FIX2)
 		} else {
 			if v25 < 0 {
 				v29 = 0
 			} else {
 				v29 = int32(255)
 			}
 			v28 = v29
 		}
 		v26 = v28
 		goto _148
 	_148:
 		v17 = v26
 		goto _139
 	_139:
 		**(**uint8_t)(__ccgo_up(v5 + 1)) = libc.Uint8FromInt32(v17)
 		v32 = v2 * int32(19077) >> int32(8)
 		goto _154
 	_154:
 		v34 = v4 * int32(26149) >> int32(8)
 		goto _156
 	_156:
 		v36 = v32 + v34 - int32(14234)
 		if v36 & ^int32(YUV_MASK2) == 0 {
 			v39 = v36 >> int32(YUV_FIX2)
 		} else {
 			if v36 < 0 {
 				v40 = 0
 			} else {
 				v40 = int32(255)
 			}
 			v39 = v40
 		}
 		v37 = v39
 		goto _159
 	_159:
 		v30 = v37
 		goto _152
 	_152:
 		**(**uint8_t)(__ccgo_up(v5 + 2)) = libc.Uint8FromInt32(v30)
 		**(**uint8_t)(__ccgo_up(v1 + 3)) = uint8(0xff)
 		if bottom_y != libc.UintptrFromInt32(0) {
 			uv03 = (diag_03 + l_uv) >> int32(1)
 			uv11 = (diag_12 + uv) >> int32(1)
 			v1 = bottom_dst + uintptr((int32(2)*x-int32(1))*int32(4))
 			v2 = libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(bottom_y + uintptr(int32(2)*x-int32(1)))))
 			v3 = libc.Int32FromUint8(uint8(uv03 & uint32(0xff)))
 			v4 = libc.Int32FromUint8(uint8(uv03 >> libc.Int32FromInt32(16)))
 			v5 = v1
 			v8 = v2 * int32(19077) >> int32(8)
 			goto _170
 		_170:
 			v10 = v3 * int32(33050) >> int32(8)
 			goto _172
 		_172:
 			v12 = v8 + v10 - int32(17685)
 			if v12 & ^int32(YUV_MASK2) == 0 {
 				v15 = v12 >> int32(YUV_FIX2)
 			} else {
 				if v12 < 0 {
 					v16 = 0
 				} else {
 					v16 = int32(255)
 				}
 				v15 = v16
 			}
 			v13 = v15
 			goto _175
 		_175:
 			v6 = v13
 			goto _168
 		_168:
 			**(**uint8_t)(__ccgo_up(v5)) = libc.Uint8FromInt32(v6)
 			v19 = v2 * int32(19077) >> int32(8)
 			goto _181
 		_181:
 			v21 = v3 * int32(6419) >> int32(8)
 			goto _183
 		_183:
 			v23 = v4 * int32(13320) >> int32(8)
 			goto _185
 		_185:
 			v25 = v19 - v21 - v23 + int32(8708)
 			if v25 & ^int32(YUV_MASK2) == 0 {
 				v28 = v25 >> int32(YUV_FIX2)
 			} else {
 				if v25 < 0 {
 					v29 = 0
 				} else {
 					v29 = int32(255)
 				}
 				v28 = v29
 			}
 			v26 = v28
 			goto _188
 		_188:
 			v17 = v26
 			goto _179
 		_179:
 			**(**uint8_t)(__ccgo_up(v5 + 1)) = libc.Uint8FromInt32(v17)
 			v32 = v2 * int32(19077) >> int32(8)
 			goto _194
 		_194:
 			v34 = v4 * int32(26149) >> int32(8)
 			goto _196
 		_196:
 			v36 = v32 + v34 - int32(14234)
 			if v36 & ^int32(YUV_MASK2) == 0 {
 				v39 = v36 >> int32(YUV_FIX2)
 			} else {
 				if v36 < 0 {
 					v40 = 0
 				} else {
 					v40 = int32(255)
 				}
 				v39 = v40
 			}
 			v37 = v39
 			goto _199
 		_199:
 			v30 = v37
 			goto _192
 		_192:
 			**(**uint8_t)(__ccgo_up(v5 + 2)) = libc.Uint8FromInt32(v30)
 			**(**uint8_t)(__ccgo_up(v1 + 3)) = uint8(0xff)
 			v1 = bottom_dst + uintptr((int32(2)*x+0)*int32(4))
 			v2 = libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(bottom_y + uintptr(int32(2)*x+0))))
 			v3 = libc.Int32FromUint8(uint8(uv11 & uint32(0xff)))
 			v4 = libc.Int32FromUint8(uint8(uv11 >> libc.Int32FromInt32(16)))
 			v5 = v1
 			v8 = v2 * int32(19077) >> int32(8)
 			goto _210
 		_210:
 			v10 = v3 * int32(33050) >> int32(8)
 			goto _212
 		_212:
 			v12 = v8 + v10 - int32(17685)
 			if v12 & ^int32(YUV_MASK2) == 0 {
 				v15 = v12 >> int32(YUV_FIX2)
 			} else {
 				if v12 < 0 {
 					v16 = 0
 				} else {
 					v16 = int32(255)
 				}
 				v15 = v16
 			}
 			v13 = v15
 			goto _215
 		_215:
 			v6 = v13
 			goto _208
 		_208:
 			**(**uint8_t)(__ccgo_up(v5)) = libc.Uint8FromInt32(v6)
 			v19 = v2 * int32(19077) >> int32(8)
 			goto _221
 		_221:
 			v21 = v3 * int32(6419) >> int32(8)
 			goto _223
 		_223:
 			v23 = v4 * int32(13320) >> int32(8)
 			goto _225
 		_225:
 			v25 = v19 - v21 - v23 + int32(8708)
 			if v25 & ^int32(YUV_MASK2) == 0 {
 				v28 = v25 >> int32(YUV_FIX2)
 			} else {
 				if v25 < 0 {
 					v29 = 0
 				} else {
 					v29 = int32(255)
 				}
 				v28 = v29
 			}
 			v26 = v28
 			goto _228
 		_228:
 			v17 = v26
 			goto _219
 		_219:
 			**(**uint8_t)(__ccgo_up(v5 + 1)) = libc.Uint8FromInt32(v17)
 			v32 = v2 * int32(19077) >> int32(8)
 			goto _234
 		_234:
 			v34 = v4 * int32(26149) >> int32(8)
 			goto _236
 		_236:
 			v36 = v32 + v34 - int32(14234)
 			if v36 & ^int32(YUV_MASK2) == 0 {
 				v39 = v36 >> int32(YUV_FIX2)
 			} else {
 				if v36 < 0 {
 					v40 = 0
 				} else {
 					v40 = int32(255)
 				}
 				v39 = v40
 			}
 			v37 = v39
 			goto _239
 		_239:
 			v30 = v37
 			goto _232
 		_232:
 			**(**uint8_t)(__ccgo_up(v5 + 2)) = libc.Uint8FromInt32(v30)
 			**(**uint8_t)(__ccgo_up(v1 + 3)) = uint8(0xff)
 		}
 		tl_uv = t_uv
 		l_uv = uv
 		goto _81
 	_81:
 		;
 		x = x + 1
 	}
 	if !(len1&libc.Int32FromInt32(1) != 0) {
 		uv04 = (uint32(3)*tl_uv + l_uv + uint32(0x00020002)) >> int32(2)
 		v1 = top_dst + uintptr((len1-int32(1))*int32(4))
 		v2 = libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(top_y + uintptr(len1-int32(1)))))
 		v3 = libc.Int32FromUint8(uint8(uv04 & uint32(0xff)))
 		v4 = libc.Int32FromUint8(uint8(uv04 >> libc.Int32FromInt32(16)))
 		v5 = v1
 		v8 = v2 * int32(19077) >> int32(8)
 		goto _250
 	_250:
 		v10 = v3 * int32(33050) >> int32(8)
 		goto _252
 	_252:
 		v12 = v8 + v10 - int32(17685)
 		if v12 & ^int32(YUV_MASK2) == 0 {
 			v15 = v12 >> int32(YUV_FIX2)
 		} else {
 			if v12 < 0 {
 				v16 = 0
 			} else {
 				v16 = int32(255)
 			}
 			v15 = v16
 		}
 		v13 = v15
 		goto _255
 	_255:
 		v6 = v13
 		goto _248
 	_248:
 		**(**uint8_t)(__ccgo_up(v5)) = libc.Uint8FromInt32(v6)
 		v19 = v2 * int32(19077) >> int32(8)
 		goto _261
 	_261:
 		v21 = v3 * int32(6419) >> int32(8)
 		goto _263
 	_263:
 		v23 = v4 * int32(13320) >> int32(8)
 		goto _265
 	_265:
 		v25 = v19 - v21 - v23 + int32(8708)
 		if v25 & ^int32(YUV_MASK2) == 0 {
 			v28 = v25 >> int32(YUV_FIX2)
 		} else {
 			if v25 < 0 {
 				v29 = 0
 			} else {
 				v29 = int32(255)
 			}
 			v28 = v29
 		}
 		v26 = v28
 		goto _268
 	_268:
 		v17 = v26
 		goto _259
 	_259:
 		**(**uint8_t)(__ccgo_up(v5 + 1)) = libc.Uint8FromInt32(v17)
 		v32 = v2 * int32(19077) >> int32(8)
 		goto _274
 	_274:
 		v34 = v4 * int32(26149) >> int32(8)
 		goto _276
 	_276:
 		v36 = v32 + v34 - int32(14234)
 		if v36 & ^int32(YUV_MASK2) == 0 {
 			v39 = v36 >> int32(YUV_FIX2)
 		} else {
 			if v36 < 0 {
 				v40 = 0
 			} else {
 				v40 = int32(255)
 			}
 			v39 = v40
 		}
 		v37 = v39
 		goto _279
 	_279:
 		v30 = v37
 		goto _272
 	_272:
 		**(**uint8_t)(__ccgo_up(v5 + 2)) = libc.Uint8FromInt32(v30)
 		**(**uint8_t)(__ccgo_up(v1 + 3)) = uint8(0xff)
 		if bottom_y != libc.UintptrFromInt32(0) {
 			uv05 = (uint32(3)*l_uv + tl_uv + uint32(0x00020002)) >> int32(2)
 			v1 = bottom_dst + uintptr((len1-int32(1))*int32(4))
 			v2 = libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(bottom_y + uintptr(len1-int32(1)))))
 			v3 = libc.Int32FromUint8(uint8(uv05 & uint32(0xff)))
 			v4 = libc.Int32FromUint8(uint8(uv05 >> libc.Int32FromInt32(16)))
 			v5 = v1
 			v8 = v2 * int32(19077) >> int32(8)
 			goto _290
 		_290:
 			v10 = v3 * int32(33050) >> int32(8)
 			goto _292
 		_292:
 			v12 = v8 + v10 - int32(17685)
 			if v12 & ^int32(YUV_MASK2) == 0 {
 				v15 = v12 >> int32(YUV_FIX2)
 			} else {
 				if v12 < 0 {
 					v16 = 0
 				} else {
 					v16 = int32(255)
 				}
 				v15 = v16
 			}
 			v13 = v15
 			goto _295
 		_295:
 			v6 = v13
 			goto _288
 		_288:
 			**(**uint8_t)(__ccgo_up(v5)) = libc.Uint8FromInt32(v6)
 			v19 = v2 * int32(19077) >> int32(8)
 			goto _301
 		_301:
 			v21 = v3 * int32(6419) >> int32(8)
 			goto _303
 		_303:
 			v23 = v4 * int32(13320) >> int32(8)
 			goto _305
 		_305:
 			v25 = v19 - v21 - v23 + int32(8708)
 			if v25 & ^int32(YUV_MASK2) == 0 {
 				v28 = v25 >> int32(YUV_FIX2)
 			} else {
 				if v25 < 0 {
 					v29 = 0
 				} else {
 					v29 = int32(255)
 				}
 				v28 = v29
 			}
 			v26 = v28
 			goto _308
 		_308:
 			v17 = v26
 			goto _299
 		_299:
 			**(**uint8_t)(__ccgo_up(v5 + 1)) = libc.Uint8FromInt32(v17)
 			v32 = v2 * int32(19077) >> int32(8)
 			goto _314
 		_314:
 			v34 = v4 * int32(26149) >> int32(8)
 			goto _316
 		_316:
 			v36 = v32 + v34 - int32(14234)
 			if v36 & ^int32(YUV_MASK2) == 0 {
 				v39 = v36 >> int32(YUV_FIX2)
 			} else {
 				if v36 < 0 {
 					v40 = 0
 				} else {
 					v40 = int32(255)
 				}
 				v39 = v40
 			}
 			v37 = v39
 			goto _319
 		_319:
 			v30 = v37
 			goto _312
 		_312:
 			**(**uint8_t)(__ccgo_up(v5 + 2)) = libc.Uint8FromInt32(v30)
 			**(**uint8_t)(__ccgo_up(v1 + 3)) = uint8(0xff)
 		}
 	}
 }
 
 func UpsampleArgbLinePair_C(tls *libc.TLS, top_y uintptr, bottom_y uintptr, top_u uintptr, top_v uintptr, cur_u uintptr, cur_v uintptr, top_dst uintptr, bottom_dst uintptr, len1 int32) {
 	var avg, diag_03, diag_12, l_uv, t_uv, tl_uv, uv, uv0, uv01, uv02, uv03, uv04, uv05, uv1, uv11 uint32_t
 	var last_pixel_pair, x, v10, v12, v13, v15, v16, v17, v19, v2, v21, v23, v25, v26, v28, v29, v3, v30, v32, v34, v36, v37, v39, v4, v40, v6, v8 int32
 	var v1, v5 uintptr
 	_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = avg, diag_03, diag_12, l_uv, last_pixel_pair, t_uv, tl_uv, uv, uv0, uv01, uv02, uv03, uv04, uv05, uv1, uv11, x, v1, v10, v12, v13, v15, v16, v17, v19, v2, v21, v23, v25, v26, v28, v29, v3, v30, v32, v34, v36, v37, v39, v4, v40, v5, v6, v8
 	last_pixel_pair = (len1 - int32(1)) >> int32(1)
 	tl_uv = libc.Uint32FromInt32(libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(top_u))) | libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(top_v)))<<libc.Int32FromInt32(16)) /* top-left sample */
 	l_uv = libc.Uint32FromInt32(libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(cur_u))) | libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(cur_v)))<<libc.Int32FromInt32(16))
 	uv0 = (uint32(3)*tl_uv + l_uv + uint32(0x00020002)) >> int32(2)
 	v1 = top_dst
 	**(**uint8_t)(__ccgo_up(v1)) = uint8(0xff)
 	v2 = libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(top_y)))
 	v3 = libc.Int32FromUint8(uint8(uv0 & uint32(0xff)))
 	v4 = libc.Int32FromUint8(uint8(uv0 >> libc.Int32FromInt32(16)))
 	v5 = v1 + uintptr(1)
 	v8 = v2 * int32(19077) >> int32(8)
 	goto _9
 _9:
 	v10 = v4 * int32(26149) >> int32(8)
 	goto _11
 _11:
 	v12 = v8 + v10 - int32(14234)
 	if v12 & ^int32(YUV_MASK2) == 0 {
 		v15 = v12 >> int32(YUV_FIX2)
 	} else {
 		if v12 < 0 {
 			v16 = 0
 		} else {
 			v16 = int32(255)
 		}
 		v15 = v16
 	}
 	v13 = v15
 	goto _14
 _14:
 	v6 = v13
 	goto _7
 _7:
 	**(**uint8_t)(__ccgo_up(v5)) = libc.Uint8FromInt32(v6)
 	v19 = v2 * int32(19077) >> int32(8)
 	goto _20
 _20:
 	v21 = v3 * int32(6419) >> int32(8)
 	goto _22
 _22:
 	v23 = v4 * int32(13320) >> int32(8)
 	goto _24
 _24:
 	v25 = v19 - v21 - v23 + int32(8708)
 	if v25 & ^int32(YUV_MASK2) == 0 {
 		v28 = v25 >> int32(YUV_FIX2)
 	} else {
 		if v25 < 0 {
 			v29 = 0
 		} else {
 			v29 = int32(255)
 		}
 		v28 = v29
 	}
 	v26 = v28
 	goto _27
 _27:
 	v17 = v26
 	goto _18
 _18:
 	**(**uint8_t)(__ccgo_up(v5 + 1)) = libc.Uint8FromInt32(v17)
 	v32 = v2 * int32(19077) >> int32(8)
 	goto _33
 _33:
 	v34 = v3 * int32(33050) >> int32(8)
 	goto _35
 _35:
 	v36 = v32 + v34 - int32(17685)
 	if v36 & ^int32(YUV_MASK2) == 0 {
 		v39 = v36 >> int32(YUV_FIX2)
 	} else {
 		if v36 < 0 {
 			v40 = 0
 		} else {
 			v40 = int32(255)
 		}
 		v39 = v40
 	}
 	v37 = v39
 	goto _38
 _38:
 	v30 = v37
 	goto _31
 _31:
 	**(**uint8_t)(__ccgo_up(v5 + 2)) = libc.Uint8FromInt32(v30)
 	if bottom_y != libc.UintptrFromInt32(0) {
 		uv01 = (uint32(3)*l_uv + tl_uv + uint32(0x00020002)) >> int32(2)
 		v1 = bottom_dst
 		**(**uint8_t)(__ccgo_up(v1)) = uint8(0xff)
 		v2 = libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(bottom_y)))
 		v3 = libc.Int32FromUint8(uint8(uv01 & uint32(0xff)))
 		v4 = libc.Int32FromUint8(uint8(uv01 >> libc.Int32FromInt32(16)))
 		v5 = v1 + uintptr(1)
 		v8 = v2 * int32(19077) >> int32(8)
 		goto _49
 	_49:
 		v10 = v4 * int32(26149) >> int32(8)
 		goto _51
 	_51:
 		v12 = v8 + v10 - int32(14234)
 		if v12 & ^int32(YUV_MASK2) == 0 {
 			v15 = v12 >> int32(YUV_FIX2)
 		} else {
 			if v12 < 0 {
 				v16 = 0
 			} else {
 				v16 = int32(255)
 			}
 			v15 = v16
 		}
 		v13 = v15
 		goto _54
 	_54:
 		v6 = v13
 		goto _47
 	_47:
 		**(**uint8_t)(__ccgo_up(v5)) = libc.Uint8FromInt32(v6)
 		v19 = v2 * int32(19077) >> int32(8)
 		goto _60
 	_60:
 		v21 = v3 * int32(6419) >> int32(8)
 		goto _62
 	_62:
 		v23 = v4 * int32(13320) >> int32(8)
 		goto _64
 	_64:
 		v25 = v19 - v21 - v23 + int32(8708)
 		if v25 & ^int32(YUV_MASK2) == 0 {
 			v28 = v25 >> int32(YUV_FIX2)
 		} else {
 			if v25 < 0 {
 				v29 = 0
 			} else {
 				v29 = int32(255)
 			}
 			v28 = v29
 		}
 		v26 = v28
 		goto _67
 	_67:
 		v17 = v26
 		goto _58
 	_58:
 		**(**uint8_t)(__ccgo_up(v5 + 1)) = libc.Uint8FromInt32(v17)
 		v32 = v2 * int32(19077) >> int32(8)
 		goto _73
 	_73:
 		v34 = v3 * int32(33050) >> int32(8)
 		goto _75
 	_75:
 		v36 = v32 + v34 - int32(17685)
 		if v36 & ^int32(YUV_MASK2) == 0 {
 			v39 = v36 >> int32(YUV_FIX2)
 		} else {
 			if v36 < 0 {
 				v40 = 0
 			} else {
 				v40 = int32(255)
 			}
 			v39 = v40
 		}
 		v37 = v39
 		goto _78
 	_78:
 		v30 = v37
 		goto _71
 	_71:
 		**(**uint8_t)(__ccgo_up(v5 + 2)) = libc.Uint8FromInt32(v30)
 	}
 	x = int32(1)
 	for {
 		if !(x <= last_pixel_pair) {
 			break
 		}
 		t_uv = libc.Uint32FromInt32(libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(top_u + uintptr(x)))) | libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(top_v + uintptr(x))))<<libc.Int32FromInt32(16)) /* top sample */
 		uv = libc.Uint32FromInt32(libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(cur_u + uintptr(x)))) | libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(cur_v + uintptr(x))))<<libc.Int32FromInt32(16))   /* sample */ /* precompute invariant values associated with first and second diagonals*/
 		avg = tl_uv + t_uv + l_uv + uv + uint32(0x00080008)
 		diag_12 = (avg + uint32(2)*(t_uv+l_uv)) >> int32(3)
 		diag_03 = (avg + uint32(2)*(tl_uv+uv)) >> int32(3)
 		uv02 = (diag_12 + tl_uv) >> int32(1)
 		uv1 = (diag_03 + t_uv) >> int32(1)
 		v1 = top_dst + uintptr((int32(2)*x-int32(1))*int32(4))
 		**(**uint8_t)(__ccgo_up(v1)) = uint8(0xff)
 		v2 = libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(top_y + uintptr(int32(2)*x-int32(1)))))
 		v3 = libc.Int32FromUint8(uint8(uv02 & uint32(0xff)))
 		v4 = libc.Int32FromUint8(uint8(uv02 >> libc.Int32FromInt32(16)))
 		v5 = v1 + uintptr(1)
 		v8 = v2 * int32(19077) >> int32(8)
 		goto _90
 	_90:
 		v10 = v4 * int32(26149) >> int32(8)
 		goto _92
 	_92:
 		v12 = v8 + v10 - int32(14234)
 		if v12 & ^int32(YUV_MASK2) == 0 {
 			v15 = v12 >> int32(YUV_FIX2)
 		} else {
 			if v12 < 0 {
 				v16 = 0
 			} else {
 				v16 = int32(255)
 			}
 			v15 = v16
 		}
 		v13 = v15
 		goto _95
 	_95:
 		v6 = v13
 		goto _88
 	_88:
 		**(**uint8_t)(__ccgo_up(v5)) = libc.Uint8FromInt32(v6)
 		v19 = v2 * int32(19077) >> int32(8)
 		goto _101
 	_101:
 		v21 = v3 * int32(6419) >> int32(8)
 		goto _103
 	_103:
 		v23 = v4 * int32(13320) >> int32(8)
 		goto _105
 	_105:
 		v25 = v19 - v21 - v23 + int32(8708)
 		if v25 & ^int32(YUV_MASK2) == 0 {
 			v28 = v25 >> int32(YUV_FIX2)
 		} else {
 			if v25 < 0 {
 				v29 = 0
 			} else {
 				v29 = int32(255)
 			}
 			v28 = v29
 		}
 		v26 = v28
 		goto _108
 	_108:
 		v17 = v26
 		goto _99
 	_99:
 		**(**uint8_t)(__ccgo_up(v5 + 1)) = libc.Uint8FromInt32(v17)
 		v32 = v2 * int32(19077) >> int32(8)
 		goto _114
 	_114:
 		v34 = v3 * int32(33050) >> int32(8)
 		goto _116
 	_116:
 		v36 = v32 + v34 - int32(17685)
 		if v36 & ^int32(YUV_MASK2) == 0 {
 			v39 = v36 >> int32(YUV_FIX2)
 		} else {
 			if v36 < 0 {
 				v40 = 0
 			} else {
 				v40 = int32(255)
 			}
 			v39 = v40
 		}
 		v37 = v39
 		goto _119
 	_119:
 		v30 = v37
 		goto _112
 	_112:
 		**(**uint8_t)(__ccgo_up(v5 + 2)) = libc.Uint8FromInt32(v30)
 		v1 = top_dst + uintptr((int32(2)*x-0)*int32(4))
 		**(**uint8_t)(__ccgo_up(v1)) = uint8(0xff)
 		v2 = libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(top_y + uintptr(int32(2)*x-0))))
 		v3 = libc.Int32FromUint8(uint8(uv1 & uint32(0xff)))
 		v4 = libc.Int32FromUint8(uint8(uv1 >> libc.Int32FromInt32(16)))
 		v5 = v1 + uintptr(1)
 		v8 = v2 * int32(19077) >> int32(8)
 		goto _130
 	_130:
 		v10 = v4 * int32(26149) >> int32(8)
 		goto _132
 	_132:
 		v12 = v8 + v10 - int32(14234)
 		if v12 & ^int32(YUV_MASK2) == 0 {
 			v15 = v12 >> int32(YUV_FIX2)
 		} else {
 			if v12 < 0 {
 				v16 = 0
 			} else {
 				v16 = int32(255)
 			}
 			v15 = v16
 		}
 		v13 = v15
 		goto _135
 	_135:
 		v6 = v13
 		goto _128
 	_128:
 		**(**uint8_t)(__ccgo_up(v5)) = libc.Uint8FromInt32(v6)
 		v19 = v2 * int32(19077) >> int32(8)
 		goto _141
 	_141:
 		v21 = v3 * int32(6419) >> int32(8)
 		goto _143
 	_143:
 		v23 = v4 * int32(13320) >> int32(8)
 		goto _145
 	_145:
 		v25 = v19 - v21 - v23 + int32(8708)
 		if v25 & ^int32(YUV_MASK2) == 0 {
 			v28 = v25 >> int32(YUV_FIX2)
 		} else {
 			if v25 < 0 {
 				v29 = 0
 			} else {
 				v29 = int32(255)
 			}
 			v28 = v29
 		}
 		v26 = v28
 		goto _148
 	_148:
 		v17 = v26
 		goto _139
 	_139:
 		**(**uint8_t)(__ccgo_up(v5 + 1)) = libc.Uint8FromInt32(v17)
 		v32 = v2 * int32(19077) >> int32(8)
 		goto _154
 	_154:
 		v34 = v3 * int32(33050) >> int32(8)
 		goto _156
 	_156:
 		v36 = v32 + v34 - int32(17685)
 		if v36 & ^int32(YUV_MASK2) == 0 {
 			v39 = v36 >> int32(YUV_FIX2)
 		} else {
 			if v36 < 0 {
 				v40 = 0
 			} else {
 				v40 = int32(255)
 			}
 			v39 = v40
 		}
 		v37 = v39
 		goto _159
 	_159:
 		v30 = v37
 		goto _152
 	_152:
 		**(**uint8_t)(__ccgo_up(v5 + 2)) = libc.Uint8FromInt32(v30)
 		if bottom_y != libc.UintptrFromInt32(0) {
 			uv03 = (diag_03 + l_uv) >> int32(1)
 			uv11 = (diag_12 + uv) >> int32(1)
 			v1 = bottom_dst + uintptr((int32(2)*x-int32(1))*int32(4))
 			**(**uint8_t)(__ccgo_up(v1)) = uint8(0xff)
 			v2 = libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(bottom_y + uintptr(int32(2)*x-int32(1)))))
 			v3 = libc.Int32FromUint8(uint8(uv03 & uint32(0xff)))
 			v4 = libc.Int32FromUint8(uint8(uv03 >> libc.Int32FromInt32(16)))
 			v5 = v1 + uintptr(1)
 			v8 = v2 * int32(19077) >> int32(8)
 			goto _170
 		_170:
 			v10 = v4 * int32(26149) >> int32(8)
 			goto _172
 		_172:
 			v12 = v8 + v10 - int32(14234)
 			if v12 & ^int32(YUV_MASK2) == 0 {
 				v15 = v12 >> int32(YUV_FIX2)
 			} else {
 				if v12 < 0 {
 					v16 = 0
 				} else {
 					v16 = int32(255)
 				}
 				v15 = v16
 			}
 			v13 = v15
 			goto _175
 		_175:
 			v6 = v13
 			goto _168
 		_168:
 			**(**uint8_t)(__ccgo_up(v5)) = libc.Uint8FromInt32(v6)
 			v19 = v2 * int32(19077) >> int32(8)
 			goto _181
 		_181:
 			v21 = v3 * int32(6419) >> int32(8)
 			goto _183
 		_183:
 			v23 = v4 * int32(13320) >> int32(8)
 			goto _185
 		_185:
 			v25 = v19 - v21 - v23 + int32(8708)
 			if v25 & ^int32(YUV_MASK2) == 0 {
 				v28 = v25 >> int32(YUV_FIX2)
 			} else {
 				if v25 < 0 {
 					v29 = 0
 				} else {
 					v29 = int32(255)
 				}
 				v28 = v29
 			}
 			v26 = v28
 			goto _188
 		_188:
 			v17 = v26
 			goto _179
 		_179:
 			**(**uint8_t)(__ccgo_up(v5 + 1)) = libc.Uint8FromInt32(v17)
 			v32 = v2 * int32(19077) >> int32(8)
 			goto _194
 		_194:
 			v34 = v3 * int32(33050) >> int32(8)
 			goto _196
 		_196:
 			v36 = v32 + v34 - int32(17685)
 			if v36 & ^int32(YUV_MASK2) == 0 {
 				v39 = v36 >> int32(YUV_FIX2)
 			} else {
 				if v36 < 0 {
 					v40 = 0
 				} else {
 					v40 = int32(255)
 				}
 				v39 = v40
 			}
 			v37 = v39
 			goto _199
 		_199:
 			v30 = v37
 			goto _192
 		_192:
 			**(**uint8_t)(__ccgo_up(v5 + 2)) = libc.Uint8FromInt32(v30)
 			v1 = bottom_dst + uintptr((int32(2)*x+0)*int32(4))
 			**(**uint8_t)(__ccgo_up(v1)) = uint8(0xff)
 			v2 = libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(bottom_y + uintptr(int32(2)*x+0))))
 			v3 = libc.Int32FromUint8(uint8(uv11 & uint32(0xff)))
 			v4 = libc.Int32FromUint8(uint8(uv11 >> libc.Int32FromInt32(16)))
 			v5 = v1 + uintptr(1)
 			v8 = v2 * int32(19077) >> int32(8)
 			goto _210
 		_210:
 			v10 = v4 * int32(26149) >> int32(8)
 			goto _212
 		_212:
 			v12 = v8 + v10 - int32(14234)
 			if v12 & ^int32(YUV_MASK2) == 0 {
 				v15 = v12 >> int32(YUV_FIX2)
 			} else {
 				if v12 < 0 {
 					v16 = 0
 				} else {
 					v16 = int32(255)
 				}
 				v15 = v16
 			}
 			v13 = v15
 			goto _215
 		_215:
 			v6 = v13
 			goto _208
 		_208:
 			**(**uint8_t)(__ccgo_up(v5)) = libc.Uint8FromInt32(v6)
 			v19 = v2 * int32(19077) >> int32(8)
 			goto _221
 		_221:
 			v21 = v3 * int32(6419) >> int32(8)
 			goto _223
 		_223:
 			v23 = v4 * int32(13320) >> int32(8)
 			goto _225
 		_225:
 			v25 = v19 - v21 - v23 + int32(8708)
 			if v25 & ^int32(YUV_MASK2) == 0 {
 				v28 = v25 >> int32(YUV_FIX2)
 			} else {
 				if v25 < 0 {
 					v29 = 0
 				} else {
 					v29 = int32(255)
 				}
 				v28 = v29
 			}
 			v26 = v28
 			goto _228
 		_228:
 			v17 = v26
 			goto _219
 		_219:
 			**(**uint8_t)(__ccgo_up(v5 + 1)) = libc.Uint8FromInt32(v17)
 			v32 = v2 * int32(19077) >> int32(8)
 			goto _234
 		_234:
 			v34 = v3 * int32(33050) >> int32(8)
 			goto _236
 		_236:
 			v36 = v32 + v34 - int32(17685)
 			if v36 & ^int32(YUV_MASK2) == 0 {
 				v39 = v36 >> int32(YUV_FIX2)
 			} else {
 				if v36 < 0 {
 					v40 = 0
 				} else {
 					v40 = int32(255)
 				}
 				v39 = v40
 			}
 			v37 = v39
 			goto _239
 		_239:
 			v30 = v37
 			goto _232
 		_232:
 			**(**uint8_t)(__ccgo_up(v5 + 2)) = libc.Uint8FromInt32(v30)
 		}
 		tl_uv = t_uv
 		l_uv = uv
 		goto _81
 	_81:
 		;
 		x = x + 1
 	}
 	if !(len1&libc.Int32FromInt32(1) != 0) {
 		uv04 = (uint32(3)*tl_uv + l_uv + uint32(0x00020002)) >> int32(2)
 		v1 = top_dst + uintptr((len1-int32(1))*int32(4))
 		**(**uint8_t)(__ccgo_up(v1)) = uint8(0xff)
 		v2 = libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(top_y + uintptr(len1-int32(1)))))
 		v3 = libc.Int32FromUint8(uint8(uv04 & uint32(0xff)))
 		v4 = libc.Int32FromUint8(uint8(uv04 >> libc.Int32FromInt32(16)))
 		v5 = v1 + uintptr(1)
 		v8 = v2 * int32(19077) >> int32(8)
 		goto _250
 	_250:
 		v10 = v4 * int32(26149) >> int32(8)
 		goto _252
 	_252:
 		v12 = v8 + v10 - int32(14234)
 		if v12 & ^int32(YUV_MASK2) == 0 {
 			v15 = v12 >> int32(YUV_FIX2)
 		} else {
 			if v12 < 0 {
 				v16 = 0
 			} else {
 				v16 = int32(255)
 			}
 			v15 = v16
 		}
 		v13 = v15
 		goto _255
 	_255:
 		v6 = v13
 		goto _248
 	_248:
 		**(**uint8_t)(__ccgo_up(v5)) = libc.Uint8FromInt32(v6)
 		v19 = v2 * int32(19077) >> int32(8)
 		goto _261
 	_261:
 		v21 = v3 * int32(6419) >> int32(8)
 		goto _263
 	_263:
 		v23 = v4 * int32(13320) >> int32(8)
 		goto _265
 	_265:
 		v25 = v19 - v21 - v23 + int32(8708)
 		if v25 & ^int32(YUV_MASK2) == 0 {
 			v28 = v25 >> int32(YUV_FIX2)
 		} else {
 			if v25 < 0 {
 				v29 = 0
 			} else {
 				v29 = int32(255)
 			}
 			v28 = v29
 		}
 		v26 = v28
 		goto _268
 	_268:
 		v17 = v26
 		goto _259
 	_259:
 		**(**uint8_t)(__ccgo_up(v5 + 1)) = libc.Uint8FromInt32(v17)
 		v32 = v2 * int32(19077) >> int32(8)
 		goto _274
 	_274:
 		v34 = v3 * int32(33050) >> int32(8)
 		goto _276
 	_276:
 		v36 = v32 + v34 - int32(17685)
 		if v36 & ^int32(YUV_MASK2) == 0 {
 			v39 = v36 >> int32(YUV_FIX2)
 		} else {
 			if v36 < 0 {
 				v40 = 0
 			} else {
 				v40 = int32(255)
 			}
 			v39 = v40
 		}
 		v37 = v39
 		goto _279
 	_279:
 		v30 = v37
 		goto _272
 	_272:
 		**(**uint8_t)(__ccgo_up(v5 + 2)) = libc.Uint8FromInt32(v30)
 		if bottom_y != libc.UintptrFromInt32(0) {
 			uv05 = (uint32(3)*l_uv + tl_uv + uint32(0x00020002)) >> int32(2)
 			v1 = bottom_dst + uintptr((len1-int32(1))*int32(4))
 			**(**uint8_t)(__ccgo_up(v1)) = uint8(0xff)
 			v2 = libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(bottom_y + uintptr(len1-int32(1)))))
 			v3 = libc.Int32FromUint8(uint8(uv05 & uint32(0xff)))
 			v4 = libc.Int32FromUint8(uint8(uv05 >> libc.Int32FromInt32(16)))
 			v5 = v1 + uintptr(1)
 			v8 = v2 * int32(19077) >> int32(8)
 			goto _290
 		_290:
 			v10 = v4 * int32(26149) >> int32(8)
 			goto _292
 		_292:
 			v12 = v8 + v10 - int32(14234)
 			if v12 & ^int32(YUV_MASK2) == 0 {
 				v15 = v12 >> int32(YUV_FIX2)
 			} else {
 				if v12 < 0 {
 					v16 = 0
 				} else {
 					v16 = int32(255)
 				}
 				v15 = v16
 			}
 			v13 = v15
 			goto _295
 		_295:
 			v6 = v13
 			goto _288
 		_288:
 			**(**uint8_t)(__ccgo_up(v5)) = libc.Uint8FromInt32(v6)
 			v19 = v2 * int32(19077) >> int32(8)
 			goto _301
 		_301:
 			v21 = v3 * int32(6419) >> int32(8)
 			goto _303
 		_303:
 			v23 = v4 * int32(13320) >> int32(8)
 			goto _305
 		_305:
 			v25 = v19 - v21 - v23 + int32(8708)
 			if v25 & ^int32(YUV_MASK2) == 0 {
 				v28 = v25 >> int32(YUV_FIX2)
 			} else {
 				if v25 < 0 {
 					v29 = 0
 				} else {
 					v29 = int32(255)
 				}
 				v28 = v29
 			}
 			v26 = v28
 			goto _308
 		_308:
 			v17 = v26
 			goto _299
 		_299:
 			**(**uint8_t)(__ccgo_up(v5 + 1)) = libc.Uint8FromInt32(v17)
 			v32 = v2 * int32(19077) >> int32(8)
 			goto _314
 		_314:
 			v34 = v3 * int32(33050) >> int32(8)
 			goto _316
 		_316:
 			v36 = v32 + v34 - int32(17685)
 			if v36 & ^int32(YUV_MASK2) == 0 {
 				v39 = v36 >> int32(YUV_FIX2)
 			} else {
 				if v36 < 0 {
 					v40 = 0
 				} else {
 					v40 = int32(255)
 				}
 				v39 = v40
 			}
 			v37 = v39
 			goto _319
 		_319:
 			v30 = v37
 			goto _312
 		_312:
 			**(**uint8_t)(__ccgo_up(v5 + 2)) = libc.Uint8FromInt32(v30)
 		}
 	}
 }
 
 func UpsampleRgbLinePair_C(tls *libc.TLS, top_y uintptr, bottom_y uintptr, top_u uintptr, top_v uintptr, cur_u uintptr, cur_v uintptr, top_dst uintptr, bottom_dst uintptr, len1 int32) {
 	var avg, diag_03, diag_12, l_uv, t_uv, tl_uv, uv, uv0, uv01, uv02, uv03, uv04, uv05, uv1, uv11 uint32_t
 	var last_pixel_pair, x, v1, v11, v12, v14, v15, v16, v18, v2, v20, v22, v24, v25, v27, v28, v29, v3, v31, v33, v35, v36, v38, v39, v5, v7, v9 int32
 	var v4 uintptr
 	_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = avg, diag_03, diag_12, l_uv, last_pixel_pair, t_uv, tl_uv, uv, uv0, uv01, uv02, uv03, uv04, uv05, uv1, uv11, x, v1, v11, v12, v14, v15, v16, v18, v2, v20, v22, v24, v25, v27, v28, v29, v3, v31, v33, v35, v36, v38, v39, v4, v5, v7, v9
 	last_pixel_pair = (len1 - int32(1)) >> int32(1)
 	tl_uv = libc.Uint32FromInt32(libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(top_u))) | libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(top_v)))<<libc.Int32FromInt32(16)) /* top-left sample */
 	l_uv = libc.Uint32FromInt32(libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(cur_u))) | libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(cur_v)))<<libc.Int32FromInt32(16))
 	uv0 = (uint32(3)*tl_uv + l_uv + uint32(0x00020002)) >> int32(2)
 	v1 = libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(top_y)))
 	v2 = libc.Int32FromUint32(uv0 & uint32(0xff))
 	v3 = libc.Int32FromUint32(uv0 >> libc.Int32FromInt32(16))
 	v4 = top_dst
 	v7 = v1 * int32(19077) >> int32(8)
 	goto _8
 _8:
 	v9 = v3 * int32(26149) >> int32(8)
 	goto _10
 _10:
 	v11 = v7 + v9 - int32(14234)
 	if v11 & ^int32(YUV_MASK2) == 0 {
 		v14 = v11 >> int32(YUV_FIX2)
 	} else {
 		if v11 < 0 {
 			v15 = 0
 		} else {
 			v15 = int32(255)
 		}
 		v14 = v15
 	}
 	v12 = v14
 	goto _13
 _13:
 	v5 = v12
 	goto _6
 _6:
 	**(**uint8_t)(__ccgo_up(v4)) = libc.Uint8FromInt32(v5)
 	v18 = v1 * int32(19077) >> int32(8)
 	goto _19
 _19:
 	v20 = v2 * int32(6419) >> int32(8)
 	goto _21
 _21:
 	v22 = v3 * int32(13320) >> int32(8)
 	goto _23
 _23:
 	v24 = v18 - v20 - v22 + int32(8708)
 	if v24 & ^int32(YUV_MASK2) == 0 {
 		v27 = v24 >> int32(YUV_FIX2)
 	} else {
 		if v24 < 0 {
 			v28 = 0
 		} else {
 			v28 = int32(255)
 		}
 		v27 = v28
 	}
 	v25 = v27
 	goto _26
 _26:
 	v16 = v25
 	goto _17
 _17:
 	**(**uint8_t)(__ccgo_up(v4 + 1)) = libc.Uint8FromInt32(v16)
 	v31 = v1 * int32(19077) >> int32(8)
 	goto _32
 _32:
 	v33 = v2 * int32(33050) >> int32(8)
 	goto _34
 _34:
 	v35 = v31 + v33 - int32(17685)
 	if v35 & ^int32(YUV_MASK2) == 0 {
 		v38 = v35 >> int32(YUV_FIX2)
 	} else {
 		if v35 < 0 {
 			v39 = 0
 		} else {
 			v39 = int32(255)
 		}
 		v38 = v39
 	}
 	v36 = v38
 	goto _37
 _37:
 	v29 = v36
 	goto _30
 _30:
 	**(**uint8_t)(__ccgo_up(v4 + 2)) = libc.Uint8FromInt32(v29)
 	if bottom_y != libc.UintptrFromInt32(0) {
 		uv01 = (uint32(3)*l_uv + tl_uv + uint32(0x00020002)) >> int32(2)
 		v1 = libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(bottom_y)))
 		v2 = libc.Int32FromUint32(uv01 & uint32(0xff))
 		v3 = libc.Int32FromUint32(uv01 >> libc.Int32FromInt32(16))
 		v4 = bottom_dst
 		v7 = v1 * int32(19077) >> int32(8)
 		goto _47
 	_47:
 		v9 = v3 * int32(26149) >> int32(8)
 		goto _49
 	_49:
 		v11 = v7 + v9 - int32(14234)
 		if v11 & ^int32(YUV_MASK2) == 0 {
 			v14 = v11 >> int32(YUV_FIX2)
 		} else {
 			if v11 < 0 {
 				v15 = 0
 			} else {
 				v15 = int32(255)
 			}
 			v14 = v15
 		}
 		v12 = v14
 		goto _52
 	_52:
 		v5 = v12
 		goto _45
 	_45:
 		**(**uint8_t)(__ccgo_up(v4)) = libc.Uint8FromInt32(v5)
 		v18 = v1 * int32(19077) >> int32(8)
 		goto _58
 	_58:
 		v20 = v2 * int32(6419) >> int32(8)
 		goto _60
 	_60:
 		v22 = v3 * int32(13320) >> int32(8)
 		goto _62
 	_62:
 		v24 = v18 - v20 - v22 + int32(8708)
 		if v24 & ^int32(YUV_MASK2) == 0 {
 			v27 = v24 >> int32(YUV_FIX2)
 		} else {
 			if v24 < 0 {
 				v28 = 0
 			} else {
 				v28 = int32(255)
 			}
 			v27 = v28
 		}
 		v25 = v27
 		goto _65
 	_65:
 		v16 = v25
 		goto _56
 	_56:
 		**(**uint8_t)(__ccgo_up(v4 + 1)) = libc.Uint8FromInt32(v16)
 		v31 = v1 * int32(19077) >> int32(8)
 		goto _71
 	_71:
 		v33 = v2 * int32(33050) >> int32(8)
 		goto _73
 	_73:
 		v35 = v31 + v33 - int32(17685)
 		if v35 & ^int32(YUV_MASK2) == 0 {
 			v38 = v35 >> int32(YUV_FIX2)
 		} else {
 			if v35 < 0 {
 				v39 = 0
 			} else {
 				v39 = int32(255)
 			}
 			v38 = v39
 		}
 		v36 = v38
 		goto _76
 	_76:
 		v29 = v36
 		goto _69
 	_69:
 		**(**uint8_t)(__ccgo_up(v4 + 2)) = libc.Uint8FromInt32(v29)
 	}
 	x = int32(1)
 	for {
 		if !(x <= last_pixel_pair) {
 			break
 		}
 		t_uv = libc.Uint32FromInt32(libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(top_u + uintptr(x)))) | libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(top_v + uintptr(x))))<<libc.Int32FromInt32(16)) /* top sample */
 		uv = libc.Uint32FromInt32(libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(cur_u + uintptr(x)))) | libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(cur_v + uintptr(x))))<<libc.Int32FromInt32(16))   /* sample */ /* precompute invariant values associated with first and second diagonals*/
 		avg = tl_uv + t_uv + l_uv + uv + uint32(0x00080008)
 		diag_12 = (avg + uint32(2)*(t_uv+l_uv)) >> int32(3)
 		diag_03 = (avg + uint32(2)*(tl_uv+uv)) >> int32(3)
 		uv02 = (diag_12 + tl_uv) >> int32(1)
 		uv1 = (diag_03 + t_uv) >> int32(1)
 		v1 = libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(top_y + uintptr(int32(2)*x-int32(1)))))
 		v2 = libc.Int32FromUint32(uv02 & uint32(0xff))
 		v3 = libc.Int32FromUint32(uv02 >> libc.Int32FromInt32(16))
 		v4 = top_dst + uintptr((int32(2)*x-int32(1))*int32(3))
 		v7 = v1 * int32(19077) >> int32(8)
 		goto _87
 	_87:
 		v9 = v3 * int32(26149) >> int32(8)
 		goto _89
 	_89:
 		v11 = v7 + v9 - int32(14234)
 		if v11 & ^int32(YUV_MASK2) == 0 {
 			v14 = v11 >> int32(YUV_FIX2)
 		} else {
 			if v11 < 0 {
 				v15 = 0
 			} else {
 				v15 = int32(255)
 			}
 			v14 = v15
 		}
 		v12 = v14
 		goto _92
 	_92:
 		v5 = v12
 		goto _85
 	_85:
 		**(**uint8_t)(__ccgo_up(v4)) = libc.Uint8FromInt32(v5)
 		v18 = v1 * int32(19077) >> int32(8)
 		goto _98
 	_98:
 		v20 = v2 * int32(6419) >> int32(8)
 		goto _100
 	_100:
 		v22 = v3 * int32(13320) >> int32(8)
 		goto _102
 	_102:
 		v24 = v18 - v20 - v22 + int32(8708)
 		if v24 & ^int32(YUV_MASK2) == 0 {
 			v27 = v24 >> int32(YUV_FIX2)
 		} else {
 			if v24 < 0 {
 				v28 = 0
 			} else {
 				v28 = int32(255)
 			}
 			v27 = v28
 		}
 		v25 = v27
 		goto _105
 	_105:
 		v16 = v25
 		goto _96
 	_96:
 		**(**uint8_t)(__ccgo_up(v4 + 1)) = libc.Uint8FromInt32(v16)
 		v31 = v1 * int32(19077) >> int32(8)
 		goto _111
 	_111:
 		v33 = v2 * int32(33050) >> int32(8)
 		goto _113
 	_113:
 		v35 = v31 + v33 - int32(17685)
 		if v35 & ^int32(YUV_MASK2) == 0 {
 			v38 = v35 >> int32(YUV_FIX2)
 		} else {
 			if v35 < 0 {
 				v39 = 0
 			} else {
 				v39 = int32(255)
 			}
 			v38 = v39
 		}
 		v36 = v38
 		goto _116
 	_116:
 		v29 = v36
 		goto _109
 	_109:
 		**(**uint8_t)(__ccgo_up(v4 + 2)) = libc.Uint8FromInt32(v29)
 		v1 = libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(top_y + uintptr(int32(2)*x-0))))
 		v2 = libc.Int32FromUint32(uv1 & uint32(0xff))
 		v3 = libc.Int32FromUint32(uv1 >> libc.Int32FromInt32(16))
 		v4 = top_dst + uintptr((int32(2)*x-0)*int32(3))
 		v7 = v1 * int32(19077) >> int32(8)
 		goto _126
 	_126:
 		v9 = v3 * int32(26149) >> int32(8)
 		goto _128
 	_128:
 		v11 = v7 + v9 - int32(14234)
 		if v11 & ^int32(YUV_MASK2) == 0 {
 			v14 = v11 >> int32(YUV_FIX2)
 		} else {
 			if v11 < 0 {
 				v15 = 0
 			} else {
 				v15 = int32(255)
 			}
 			v14 = v15
 		}
 		v12 = v14
 		goto _131
 	_131:
 		v5 = v12
 		goto _124
 	_124:
 		**(**uint8_t)(__ccgo_up(v4)) = libc.Uint8FromInt32(v5)
 		v18 = v1 * int32(19077) >> int32(8)
 		goto _137
 	_137:
 		v20 = v2 * int32(6419) >> int32(8)
 		goto _139
 	_139:
 		v22 = v3 * int32(13320) >> int32(8)
 		goto _141
 	_141:
 		v24 = v18 - v20 - v22 + int32(8708)
 		if v24 & ^int32(YUV_MASK2) == 0 {
 			v27 = v24 >> int32(YUV_FIX2)
 		} else {
 			if v24 < 0 {
 				v28 = 0
 			} else {
 				v28 = int32(255)
 			}
 			v27 = v28
 		}
 		v25 = v27
 		goto _144
 	_144:
 		v16 = v25
 		goto _135
 	_135:
 		**(**uint8_t)(__ccgo_up(v4 + 1)) = libc.Uint8FromInt32(v16)
 		v31 = v1 * int32(19077) >> int32(8)
 		goto _150
 	_150:
 		v33 = v2 * int32(33050) >> int32(8)
 		goto _152
 	_152:
 		v35 = v31 + v33 - int32(17685)
 		if v35 & ^int32(YUV_MASK2) == 0 {
 			v38 = v35 >> int32(YUV_FIX2)
 		} else {
 			if v35 < 0 {
 				v39 = 0
 			} else {
 				v39 = int32(255)
 			}
 			v38 = v39
 		}
 		v36 = v38
 		goto _155
 	_155:
 		v29 = v36
 		goto _148
 	_148:
 		**(**uint8_t)(__ccgo_up(v4 + 2)) = libc.Uint8FromInt32(v29)
 		if bottom_y != libc.UintptrFromInt32(0) {
 			uv03 = (diag_03 + l_uv) >> int32(1)
 			uv11 = (diag_12 + uv) >> int32(1)
 			v1 = libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(bottom_y + uintptr(int32(2)*x-int32(1)))))
 			v2 = libc.Int32FromUint32(uv03 & uint32(0xff))
 			v3 = libc.Int32FromUint32(uv03 >> libc.Int32FromInt32(16))
 			v4 = bottom_dst + uintptr((int32(2)*x-int32(1))*int32(3))
 			v7 = v1 * int32(19077) >> int32(8)
 			goto _165
 		_165:
 			v9 = v3 * int32(26149) >> int32(8)
 			goto _167
 		_167:
 			v11 = v7 + v9 - int32(14234)
 			if v11 & ^int32(YUV_MASK2) == 0 {
 				v14 = v11 >> int32(YUV_FIX2)
 			} else {
 				if v11 < 0 {
 					v15 = 0
 				} else {
 					v15 = int32(255)
 				}
 				v14 = v15
 			}
 			v12 = v14
 			goto _170
 		_170:
 			v5 = v12
 			goto _163
 		_163:
 			**(**uint8_t)(__ccgo_up(v4)) = libc.Uint8FromInt32(v5)
 			v18 = v1 * int32(19077) >> int32(8)
 			goto _176
 		_176:
 			v20 = v2 * int32(6419) >> int32(8)
 			goto _178
 		_178:
 			v22 = v3 * int32(13320) >> int32(8)
 			goto _180
 		_180:
 			v24 = v18 - v20 - v22 + int32(8708)
 			if v24 & ^int32(YUV_MASK2) == 0 {
 				v27 = v24 >> int32(YUV_FIX2)
 			} else {
 				if v24 < 0 {
 					v28 = 0
 				} else {
 					v28 = int32(255)
 				}
 				v27 = v28
 			}
 			v25 = v27
 			goto _183
 		_183:
 			v16 = v25
 			goto _174
 		_174:
 			**(**uint8_t)(__ccgo_up(v4 + 1)) = libc.Uint8FromInt32(v16)
 			v31 = v1 * int32(19077) >> int32(8)
 			goto _189
 		_189:
 			v33 = v2 * int32(33050) >> int32(8)
 			goto _191
 		_191:
 			v35 = v31 + v33 - int32(17685)
 			if v35 & ^int32(YUV_MASK2) == 0 {
 				v38 = v35 >> int32(YUV_FIX2)
 			} else {
 				if v35 < 0 {
 					v39 = 0
 				} else {
 					v39 = int32(255)
 				}
 				v38 = v39
 			}
 			v36 = v38
 			goto _194
 		_194:
 			v29 = v36
 			goto _187
 		_187:
 			**(**uint8_t)(__ccgo_up(v4 + 2)) = libc.Uint8FromInt32(v29)
 			v1 = libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(bottom_y + uintptr(int32(2)*x+0))))
 			v2 = libc.Int32FromUint32(uv11 & uint32(0xff))
 			v3 = libc.Int32FromUint32(uv11 >> libc.Int32FromInt32(16))
 			v4 = bottom_dst + uintptr((int32(2)*x+0)*int32(3))
 			v7 = v1 * int32(19077) >> int32(8)
 			goto _204
 		_204:
 			v9 = v3 * int32(26149) >> int32(8)
 			goto _206
 		_206:
 			v11 = v7 + v9 - int32(14234)
 			if v11 & ^int32(YUV_MASK2) == 0 {
 				v14 = v11 >> int32(YUV_FIX2)
 			} else {
 				if v11 < 0 {
 					v15 = 0
 				} else {
 					v15 = int32(255)
 				}
 				v14 = v15
 			}
 			v12 = v14
 			goto _209
 		_209:
 			v5 = v12
 			goto _202
 		_202:
 			**(**uint8_t)(__ccgo_up(v4)) = libc.Uint8FromInt32(v5)
 			v18 = v1 * int32(19077) >> int32(8)
 			goto _215
 		_215:
 			v20 = v2 * int32(6419) >> int32(8)
 			goto _217
 		_217:
 			v22 = v3 * int32(13320) >> int32(8)
 			goto _219
 		_219:
 			v24 = v18 - v20 - v22 + int32(8708)
 			if v24 & ^int32(YUV_MASK2) == 0 {
 				v27 = v24 >> int32(YUV_FIX2)
 			} else {
 				if v24 < 0 {
 					v28 = 0
 				} else {
 					v28 = int32(255)
 				}
 				v27 = v28
 			}
 			v25 = v27
 			goto _222
 		_222:
 			v16 = v25
 			goto _213
 		_213:
 			**(**uint8_t)(__ccgo_up(v4 + 1)) = libc.Uint8FromInt32(v16)
 			v31 = v1 * int32(19077) >> int32(8)
 			goto _228
 		_228:
 			v33 = v2 * int32(33050) >> int32(8)
 			goto _230
 		_230:
 			v35 = v31 + v33 - int32(17685)
 			if v35 & ^int32(YUV_MASK2) == 0 {
 				v38 = v35 >> int32(YUV_FIX2)
 			} else {
 				if v35 < 0 {
 					v39 = 0
 				} else {
 					v39 = int32(255)
 				}
 				v38 = v39
 			}
 			v36 = v38
 			goto _233
 		_233:
 			v29 = v36
 			goto _226
 		_226:
 			**(**uint8_t)(__ccgo_up(v4 + 2)) = libc.Uint8FromInt32(v29)
 		}
 		tl_uv = t_uv
 		l_uv = uv
 		goto _79
 	_79:
 		;
 		x = x + 1
 	}
 	if !(len1&libc.Int32FromInt32(1) != 0) {
 		uv04 = (uint32(3)*tl_uv + l_uv + uint32(0x00020002)) >> int32(2)
 		v1 = libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(top_y + uintptr(len1-int32(1)))))
 		v2 = libc.Int32FromUint32(uv04 & uint32(0xff))
 		v3 = libc.Int32FromUint32(uv04 >> libc.Int32FromInt32(16))
 		v4 = top_dst + uintptr((len1-int32(1))*int32(3))
 		v7 = v1 * int32(19077) >> int32(8)
 		goto _243
 	_243:
 		v9 = v3 * int32(26149) >> int32(8)
 		goto _245
 	_245:
 		v11 = v7 + v9 - int32(14234)
 		if v11 & ^int32(YUV_MASK2) == 0 {
 			v14 = v11 >> int32(YUV_FIX2)
 		} else {
 			if v11 < 0 {
 				v15 = 0
 			} else {
 				v15 = int32(255)
 			}
 			v14 = v15
 		}
 		v12 = v14
 		goto _248
 	_248:
 		v5 = v12
 		goto _241
 	_241:
 		**(**uint8_t)(__ccgo_up(v4)) = libc.Uint8FromInt32(v5)
 		v18 = v1 * int32(19077) >> int32(8)
 		goto _254
 	_254:
 		v20 = v2 * int32(6419) >> int32(8)
 		goto _256
 	_256:
 		v22 = v3 * int32(13320) >> int32(8)
 		goto _258
 	_258:
 		v24 = v18 - v20 - v22 + int32(8708)
 		if v24 & ^int32(YUV_MASK2) == 0 {
 			v27 = v24 >> int32(YUV_FIX2)
 		} else {
 			if v24 < 0 {
 				v28 = 0
 			} else {
 				v28 = int32(255)
 			}
 			v27 = v28
 		}
 		v25 = v27
 		goto _261
 	_261:
 		v16 = v25
 		goto _252
 	_252:
 		**(**uint8_t)(__ccgo_up(v4 + 1)) = libc.Uint8FromInt32(v16)
 		v31 = v1 * int32(19077) >> int32(8)
 		goto _267
 	_267:
 		v33 = v2 * int32(33050) >> int32(8)
 		goto _269
 	_269:
 		v35 = v31 + v33 - int32(17685)
 		if v35 & ^int32(YUV_MASK2) == 0 {
 			v38 = v35 >> int32(YUV_FIX2)
 		} else {
 			if v35 < 0 {
 				v39 = 0
 			} else {
 				v39 = int32(255)
 			}
 			v38 = v39
 		}
 		v36 = v38
 		goto _272
 	_272:
 		v29 = v36
 		goto _265
 	_265:
 		**(**uint8_t)(__ccgo_up(v4 + 2)) = libc.Uint8FromInt32(v29)
 		if bottom_y != libc.UintptrFromInt32(0) {
 			uv05 = (uint32(3)*l_uv + tl_uv + uint32(0x00020002)) >> int32(2)
 			v1 = libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(bottom_y + uintptr(len1-int32(1)))))
 			v2 = libc.Int32FromUint32(uv05 & uint32(0xff))
 			v3 = libc.Int32FromUint32(uv05 >> libc.Int32FromInt32(16))
 			v4 = bottom_dst + uintptr((len1-int32(1))*int32(3))
 			v7 = v1 * int32(19077) >> int32(8)
 			goto _282
 		_282:
 			v9 = v3 * int32(26149) >> int32(8)
 			goto _284
 		_284:
 			v11 = v7 + v9 - int32(14234)
 			if v11 & ^int32(YUV_MASK2) == 0 {
 				v14 = v11 >> int32(YUV_FIX2)
 			} else {
 				if v11 < 0 {
 					v15 = 0
 				} else {
 					v15 = int32(255)
 				}
 				v14 = v15
 			}
 			v12 = v14
 			goto _287
 		_287:
 			v5 = v12
 			goto _280
 		_280:
 			**(**uint8_t)(__ccgo_up(v4)) = libc.Uint8FromInt32(v5)
 			v18 = v1 * int32(19077) >> int32(8)
 			goto _293
 		_293:
 			v20 = v2 * int32(6419) >> int32(8)
 			goto _295
 		_295:
 			v22 = v3 * int32(13320) >> int32(8)
 			goto _297
 		_297:
 			v24 = v18 - v20 - v22 + int32(8708)
 			if v24 & ^int32(YUV_MASK2) == 0 {
 				v27 = v24 >> int32(YUV_FIX2)
 			} else {
 				if v24 < 0 {
 					v28 = 0
 				} else {
 					v28 = int32(255)
 				}
 				v27 = v28
 			}
 			v25 = v27
 			goto _300
 		_300:
 			v16 = v25
 			goto _291
 		_291:
 			**(**uint8_t)(__ccgo_up(v4 + 1)) = libc.Uint8FromInt32(v16)
 			v31 = v1 * int32(19077) >> int32(8)
 			goto _306
 		_306:
 			v33 = v2 * int32(33050) >> int32(8)
 			goto _308
 		_308:
 			v35 = v31 + v33 - int32(17685)
 			if v35 & ^int32(YUV_MASK2) == 0 {
 				v38 = v35 >> int32(YUV_FIX2)
 			} else {
 				if v35 < 0 {
 					v39 = 0
 				} else {
 					v39 = int32(255)
 				}
 				v38 = v39
 			}
 			v36 = v38
 			goto _311
 		_311:
 			v29 = v36
 			goto _304
 		_304:
 			**(**uint8_t)(__ccgo_up(v4 + 2)) = libc.Uint8FromInt32(v29)
 		}
 	}
 }
 
 func UpsampleBgrLinePair_C(tls *libc.TLS, top_y uintptr, bottom_y uintptr, top_u uintptr, top_v uintptr, cur_u uintptr, cur_v uintptr, top_dst uintptr, bottom_dst uintptr, len1 int32) {
 	var avg, diag_03, diag_12, l_uv, t_uv, tl_uv, uv, uv0, uv01, uv02, uv03, uv04, uv05, uv1, uv11 uint32_t
 	var last_pixel_pair, x, v1, v11, v12, v14, v15, v16, v18, v2, v20, v22, v24, v25, v27, v28, v29, v3, v31, v33, v35, v36, v38, v39, v5, v7, v9 int32
 	var v4 uintptr
 	_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = avg, diag_03, diag_12, l_uv, last_pixel_pair, t_uv, tl_uv, uv, uv0, uv01, uv02, uv03, uv04, uv05, uv1, uv11, x, v1, v11, v12, v14, v15, v16, v18, v2, v20, v22, v24, v25, v27, v28, v29, v3, v31, v33, v35, v36, v38, v39, v4, v5, v7, v9
 	last_pixel_pair = (len1 - int32(1)) >> int32(1)
 	tl_uv = libc.Uint32FromInt32(libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(top_u))) | libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(top_v)))<<libc.Int32FromInt32(16)) /* top-left sample */
 	l_uv = libc.Uint32FromInt32(libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(cur_u))) | libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(cur_v)))<<libc.Int32FromInt32(16))
 	uv0 = (uint32(3)*tl_uv + l_uv + uint32(0x00020002)) >> int32(2)
 	v1 = libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(top_y)))
 	v2 = libc.Int32FromUint32(uv0 & uint32(0xff))
 	v3 = libc.Int32FromUint32(uv0 >> libc.Int32FromInt32(16))
 	v4 = top_dst
 	v7 = v1 * int32(19077) >> int32(8)
 	goto _8
 _8:
 	v9 = v2 * int32(33050) >> int32(8)
 	goto _10
 _10:
 	v11 = v7 + v9 - int32(17685)
 	if v11 & ^int32(YUV_MASK2) == 0 {
 		v14 = v11 >> int32(YUV_FIX2)
 	} else {
 		if v11 < 0 {
 			v15 = 0
 		} else {
 			v15 = int32(255)
 		}
 		v14 = v15
 	}
 	v12 = v14
 	goto _13
 _13:
 	v5 = v12
 	goto _6
 _6:
 	**(**uint8_t)(__ccgo_up(v4)) = libc.Uint8FromInt32(v5)
 	v18 = v1 * int32(19077) >> int32(8)
 	goto _19
 _19:
 	v20 = v2 * int32(6419) >> int32(8)
 	goto _21
 _21:
 	v22 = v3 * int32(13320) >> int32(8)
 	goto _23
 _23:
 	v24 = v18 - v20 - v22 + int32(8708)
 	if v24 & ^int32(YUV_MASK2) == 0 {
 		v27 = v24 >> int32(YUV_FIX2)
 	} else {
 		if v24 < 0 {
 			v28 = 0
 		} else {
 			v28 = int32(255)
 		}
 		v27 = v28
 	}
 	v25 = v27
 	goto _26
 _26:
 	v16 = v25
 	goto _17
 _17:
 	**(**uint8_t)(__ccgo_up(v4 + 1)) = libc.Uint8FromInt32(v16)
 	v31 = v1 * int32(19077) >> int32(8)
 	goto _32
 _32:
 	v33 = v3 * int32(26149) >> int32(8)
 	goto _34
 _34:
 	v35 = v31 + v33 - int32(14234)
 	if v35 & ^int32(YUV_MASK2) == 0 {
 		v38 = v35 >> int32(YUV_FIX2)
 	} else {
 		if v35 < 0 {
 			v39 = 0
 		} else {
 			v39 = int32(255)
 		}
 		v38 = v39
 	}
 	v36 = v38
 	goto _37
 _37:
 	v29 = v36
 	goto _30
 _30:
 	**(**uint8_t)(__ccgo_up(v4 + 2)) = libc.Uint8FromInt32(v29)
 	if bottom_y != libc.UintptrFromInt32(0) {
 		uv01 = (uint32(3)*l_uv + tl_uv + uint32(0x00020002)) >> int32(2)
 		v1 = libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(bottom_y)))
 		v2 = libc.Int32FromUint32(uv01 & uint32(0xff))
 		v3 = libc.Int32FromUint32(uv01 >> libc.Int32FromInt32(16))
 		v4 = bottom_dst
 		v7 = v1 * int32(19077) >> int32(8)
 		goto _47
 	_47:
 		v9 = v2 * int32(33050) >> int32(8)
 		goto _49
 	_49:
 		v11 = v7 + v9 - int32(17685)
 		if v11 & ^int32(YUV_MASK2) == 0 {
 			v14 = v11 >> int32(YUV_FIX2)
 		} else {
 			if v11 < 0 {
 				v15 = 0
 			} else {
 				v15 = int32(255)
 			}
 			v14 = v15
 		}
 		v12 = v14
 		goto _52
 	_52:
 		v5 = v12
 		goto _45
 	_45:
 		**(**uint8_t)(__ccgo_up(v4)) = libc.Uint8FromInt32(v5)
 		v18 = v1 * int32(19077) >> int32(8)
 		goto _58
 	_58:
 		v20 = v2 * int32(6419) >> int32(8)
 		goto _60
 	_60:
 		v22 = v3 * int32(13320) >> int32(8)
 		goto _62
 	_62:
 		v24 = v18 - v20 - v22 + int32(8708)
 		if v24 & ^int32(YUV_MASK2) == 0 {
 			v27 = v24 >> int32(YUV_FIX2)
 		} else {
 			if v24 < 0 {
 				v28 = 0
 			} else {
 				v28 = int32(255)
 			}
 			v27 = v28
 		}
 		v25 = v27
 		goto _65
 	_65:
 		v16 = v25
 		goto _56
 	_56:
 		**(**uint8_t)(__ccgo_up(v4 + 1)) = libc.Uint8FromInt32(v16)
 		v31 = v1 * int32(19077) >> int32(8)
 		goto _71
 	_71:
 		v33 = v3 * int32(26149) >> int32(8)
 		goto _73
 	_73:
 		v35 = v31 + v33 - int32(14234)
 		if v35 & ^int32(YUV_MASK2) == 0 {
 			v38 = v35 >> int32(YUV_FIX2)
 		} else {
 			if v35 < 0 {
 				v39 = 0
 			} else {
 				v39 = int32(255)
 			}
 			v38 = v39
 		}
 		v36 = v38
 		goto _76
 	_76:
 		v29 = v36
 		goto _69
 	_69:
 		**(**uint8_t)(__ccgo_up(v4 + 2)) = libc.Uint8FromInt32(v29)
 	}
 	x = int32(1)
 	for {
 		if !(x <= last_pixel_pair) {
 			break
 		}
 		t_uv = libc.Uint32FromInt32(libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(top_u + uintptr(x)))) | libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(top_v + uintptr(x))))<<libc.Int32FromInt32(16)) /* top sample */
 		uv = libc.Uint32FromInt32(libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(cur_u + uintptr(x)))) | libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(cur_v + uintptr(x))))<<libc.Int32FromInt32(16))   /* sample */ /* precompute invariant values associated with first and second diagonals*/
 		avg = tl_uv + t_uv + l_uv + uv + uint32(0x00080008)
 		diag_12 = (avg + uint32(2)*(t_uv+l_uv)) >> int32(3)
 		diag_03 = (avg + uint32(2)*(tl_uv+uv)) >> int32(3)
 		uv02 = (diag_12 + tl_uv) >> int32(1)
 		uv1 = (diag_03 + t_uv) >> int32(1)
 		v1 = libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(top_y + uintptr(int32(2)*x-int32(1)))))
 		v2 = libc.Int32FromUint32(uv02 & uint32(0xff))
 		v3 = libc.Int32FromUint32(uv02 >> libc.Int32FromInt32(16))
 		v4 = top_dst + uintptr((int32(2)*x-int32(1))*int32(3))
 		v7 = v1 * int32(19077) >> int32(8)
 		goto _87
 	_87:
 		v9 = v2 * int32(33050) >> int32(8)
 		goto _89
 	_89:
 		v11 = v7 + v9 - int32(17685)
 		if v11 & ^int32(YUV_MASK2) == 0 {
 			v14 = v11 >> int32(YUV_FIX2)
 		} else {
 			if v11 < 0 {
 				v15 = 0
 			} else {
 				v15 = int32(255)
 			}
 			v14 = v15
 		}
 		v12 = v14
 		goto _92
 	_92:
 		v5 = v12
 		goto _85
 	_85:
 		**(**uint8_t)(__ccgo_up(v4)) = libc.Uint8FromInt32(v5)
 		v18 = v1 * int32(19077) >> int32(8)
 		goto _98
 	_98:
 		v20 = v2 * int32(6419) >> int32(8)
 		goto _100
 	_100:
 		v22 = v3 * int32(13320) >> int32(8)
 		goto _102
 	_102:
 		v24 = v18 - v20 - v22 + int32(8708)
 		if v24 & ^int32(YUV_MASK2) == 0 {
 			v27 = v24 >> int32(YUV_FIX2)
 		} else {
 			if v24 < 0 {
 				v28 = 0
 			} else {
 				v28 = int32(255)
 			}
 			v27 = v28
 		}
 		v25 = v27
 		goto _105
 	_105:
 		v16 = v25
 		goto _96
 	_96:
 		**(**uint8_t)(__ccgo_up(v4 + 1)) = libc.Uint8FromInt32(v16)
 		v31 = v1 * int32(19077) >> int32(8)
 		goto _111
 	_111:
 		v33 = v3 * int32(26149) >> int32(8)
 		goto _113
 	_113:
 		v35 = v31 + v33 - int32(14234)
 		if v35 & ^int32(YUV_MASK2) == 0 {
 			v38 = v35 >> int32(YUV_FIX2)
 		} else {
 			if v35 < 0 {
 				v39 = 0
 			} else {
 				v39 = int32(255)
 			}
 			v38 = v39
 		}
 		v36 = v38
 		goto _116
 	_116:
 		v29 = v36
 		goto _109
 	_109:
 		**(**uint8_t)(__ccgo_up(v4 + 2)) = libc.Uint8FromInt32(v29)
 		v1 = libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(top_y + uintptr(int32(2)*x-0))))
 		v2 = libc.Int32FromUint32(uv1 & uint32(0xff))
 		v3 = libc.Int32FromUint32(uv1 >> libc.Int32FromInt32(16))
 		v4 = top_dst + uintptr((int32(2)*x-0)*int32(3))
 		v7 = v1 * int32(19077) >> int32(8)
 		goto _126
 	_126:
 		v9 = v2 * int32(33050) >> int32(8)
 		goto _128
 	_128:
 		v11 = v7 + v9 - int32(17685)
 		if v11 & ^int32(YUV_MASK2) == 0 {
 			v14 = v11 >> int32(YUV_FIX2)
 		} else {
 			if v11 < 0 {
 				v15 = 0
 			} else {
 				v15 = int32(255)
 			}
 			v14 = v15
 		}
 		v12 = v14
 		goto _131
 	_131:
 		v5 = v12
 		goto _124
 	_124:
 		**(**uint8_t)(__ccgo_up(v4)) = libc.Uint8FromInt32(v5)
 		v18 = v1 * int32(19077) >> int32(8)
 		goto _137
 	_137:
 		v20 = v2 * int32(6419) >> int32(8)
 		goto _139
 	_139:
 		v22 = v3 * int32(13320) >> int32(8)
 		goto _141
 	_141:
 		v24 = v18 - v20 - v22 + int32(8708)
 		if v24 & ^int32(YUV_MASK2) == 0 {
 			v27 = v24 >> int32(YUV_FIX2)
 		} else {
 			if v24 < 0 {
 				v28 = 0
 			} else {
 				v28 = int32(255)
 			}
 			v27 = v28
 		}
 		v25 = v27
 		goto _144
 	_144:
 		v16 = v25
 		goto _135
 	_135:
 		**(**uint8_t)(__ccgo_up(v4 + 1)) = libc.Uint8FromInt32(v16)
 		v31 = v1 * int32(19077) >> int32(8)
 		goto _150
 	_150:
 		v33 = v3 * int32(26149) >> int32(8)
 		goto _152
 	_152:
 		v35 = v31 + v33 - int32(14234)
 		if v35 & ^int32(YUV_MASK2) == 0 {
 			v38 = v35 >> int32(YUV_FIX2)
 		} else {
 			if v35 < 0 {
 				v39 = 0
 			} else {
 				v39 = int32(255)
 			}
 			v38 = v39
 		}
 		v36 = v38
 		goto _155
 	_155:
 		v29 = v36
 		goto _148
 	_148:
 		**(**uint8_t)(__ccgo_up(v4 + 2)) = libc.Uint8FromInt32(v29)
 		if bottom_y != libc.UintptrFromInt32(0) {
 			uv03 = (diag_03 + l_uv) >> int32(1)
 			uv11 = (diag_12 + uv) >> int32(1)
 			v1 = libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(bottom_y + uintptr(int32(2)*x-int32(1)))))
 			v2 = libc.Int32FromUint32(uv03 & uint32(0xff))
 			v3 = libc.Int32FromUint32(uv03 >> libc.Int32FromInt32(16))
 			v4 = bottom_dst + uintptr((int32(2)*x-int32(1))*int32(3))
 			v7 = v1 * int32(19077) >> int32(8)
 			goto _165
 		_165:
 			v9 = v2 * int32(33050) >> int32(8)
 			goto _167
 		_167:
 			v11 = v7 + v9 - int32(17685)
 			if v11 & ^int32(YUV_MASK2) == 0 {
 				v14 = v11 >> int32(YUV_FIX2)
 			} else {
 				if v11 < 0 {
 					v15 = 0
 				} else {
 					v15 = int32(255)
 				}
 				v14 = v15
 			}
 			v12 = v14
 			goto _170
 		_170:
 			v5 = v12
 			goto _163
 		_163:
 			**(**uint8_t)(__ccgo_up(v4)) = libc.Uint8FromInt32(v5)
 			v18 = v1 * int32(19077) >> int32(8)
 			goto _176
 		_176:
 			v20 = v2 * int32(6419) >> int32(8)
 			goto _178
 		_178:
 			v22 = v3 * int32(13320) >> int32(8)
 			goto _180
 		_180:
 			v24 = v18 - v20 - v22 + int32(8708)
 			if v24 & ^int32(YUV_MASK2) == 0 {
 				v27 = v24 >> int32(YUV_FIX2)
 			} else {
 				if v24 < 0 {
 					v28 = 0
 				} else {
 					v28 = int32(255)
 				}
 				v27 = v28
 			}
 			v25 = v27
 			goto _183
 		_183:
 			v16 = v25
 			goto _174
 		_174:
 			**(**uint8_t)(__ccgo_up(v4 + 1)) = libc.Uint8FromInt32(v16)
 			v31 = v1 * int32(19077) >> int32(8)
 			goto _189
 		_189:
 			v33 = v3 * int32(26149) >> int32(8)
 			goto _191
 		_191:
 			v35 = v31 + v33 - int32(14234)
 			if v35 & ^int32(YUV_MASK2) == 0 {
 				v38 = v35 >> int32(YUV_FIX2)
 			} else {
 				if v35 < 0 {
 					v39 = 0
 				} else {
 					v39 = int32(255)
 				}
 				v38 = v39
 			}
 			v36 = v38
 			goto _194
 		_194:
 			v29 = v36
 			goto _187
 		_187:
 			**(**uint8_t)(__ccgo_up(v4 + 2)) = libc.Uint8FromInt32(v29)
 			v1 = libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(bottom_y + uintptr(int32(2)*x+0))))
 			v2 = libc.Int32FromUint32(uv11 & uint32(0xff))
 			v3 = libc.Int32FromUint32(uv11 >> libc.Int32FromInt32(16))
 			v4 = bottom_dst + uintptr((int32(2)*x+0)*int32(3))
 			v7 = v1 * int32(19077) >> int32(8)
 			goto _204
 		_204:
 			v9 = v2 * int32(33050) >> int32(8)
 			goto _206
 		_206:
 			v11 = v7 + v9 - int32(17685)
 			if v11 & ^int32(YUV_MASK2) == 0 {
 				v14 = v11 >> int32(YUV_FIX2)
 			} else {
 				if v11 < 0 {
 					v15 = 0
 				} else {
 					v15 = int32(255)
 				}
 				v14 = v15
 			}
 			v12 = v14
 			goto _209
 		_209:
 			v5 = v12
 			goto _202
 		_202:
 			**(**uint8_t)(__ccgo_up(v4)) = libc.Uint8FromInt32(v5)
 			v18 = v1 * int32(19077) >> int32(8)
 			goto _215
 		_215:
 			v20 = v2 * int32(6419) >> int32(8)
 			goto _217
 		_217:
 			v22 = v3 * int32(13320) >> int32(8)
 			goto _219
 		_219:
 			v24 = v18 - v20 - v22 + int32(8708)
 			if v24 & ^int32(YUV_MASK2) == 0 {
 				v27 = v24 >> int32(YUV_FIX2)
 			} else {
 				if v24 < 0 {
 					v28 = 0
 				} else {
 					v28 = int32(255)
 				}
 				v27 = v28
 			}
 			v25 = v27
 			goto _222
 		_222:
 			v16 = v25
 			goto _213
 		_213:
 			**(**uint8_t)(__ccgo_up(v4 + 1)) = libc.Uint8FromInt32(v16)
 			v31 = v1 * int32(19077) >> int32(8)
 			goto _228
 		_228:
 			v33 = v3 * int32(26149) >> int32(8)
 			goto _230
 		_230:
 			v35 = v31 + v33 - int32(14234)
 			if v35 & ^int32(YUV_MASK2) == 0 {
 				v38 = v35 >> int32(YUV_FIX2)
 			} else {
 				if v35 < 0 {
 					v39 = 0
 				} else {
 					v39 = int32(255)
 				}
 				v38 = v39
 			}
 			v36 = v38
 			goto _233
 		_233:
 			v29 = v36
 			goto _226
 		_226:
 			**(**uint8_t)(__ccgo_up(v4 + 2)) = libc.Uint8FromInt32(v29)
 		}
 		tl_uv = t_uv
 		l_uv = uv
 		goto _79
 	_79:
 		;
 		x = x + 1
 	}
 	if !(len1&libc.Int32FromInt32(1) != 0) {
 		uv04 = (uint32(3)*tl_uv + l_uv + uint32(0x00020002)) >> int32(2)
 		v1 = libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(top_y + uintptr(len1-int32(1)))))
 		v2 = libc.Int32FromUint32(uv04 & uint32(0xff))
 		v3 = libc.Int32FromUint32(uv04 >> libc.Int32FromInt32(16))
 		v4 = top_dst + uintptr((len1-int32(1))*int32(3))
 		v7 = v1 * int32(19077) >> int32(8)
 		goto _243
 	_243:
 		v9 = v2 * int32(33050) >> int32(8)
 		goto _245
 	_245:
 		v11 = v7 + v9 - int32(17685)
 		if v11 & ^int32(YUV_MASK2) == 0 {
 			v14 = v11 >> int32(YUV_FIX2)
 		} else {
 			if v11 < 0 {
 				v15 = 0
 			} else {
 				v15 = int32(255)
 			}
 			v14 = v15
 		}
 		v12 = v14
 		goto _248
 	_248:
 		v5 = v12
 		goto _241
 	_241:
 		**(**uint8_t)(__ccgo_up(v4)) = libc.Uint8FromInt32(v5)
 		v18 = v1 * int32(19077) >> int32(8)
 		goto _254
 	_254:
 		v20 = v2 * int32(6419) >> int32(8)
 		goto _256
 	_256:
 		v22 = v3 * int32(13320) >> int32(8)
 		goto _258
 	_258:
 		v24 = v18 - v20 - v22 + int32(8708)
 		if v24 & ^int32(YUV_MASK2) == 0 {
 			v27 = v24 >> int32(YUV_FIX2)
 		} else {
 			if v24 < 0 {
 				v28 = 0
 			} else {
 				v28 = int32(255)
 			}
 			v27 = v28
 		}
 		v25 = v27
 		goto _261
 	_261:
 		v16 = v25
 		goto _252
 	_252:
 		**(**uint8_t)(__ccgo_up(v4 + 1)) = libc.Uint8FromInt32(v16)
 		v31 = v1 * int32(19077) >> int32(8)
 		goto _267
 	_267:
 		v33 = v3 * int32(26149) >> int32(8)
 		goto _269
 	_269:
 		v35 = v31 + v33 - int32(14234)
 		if v35 & ^int32(YUV_MASK2) == 0 {
 			v38 = v35 >> int32(YUV_FIX2)
 		} else {
 			if v35 < 0 {
 				v39 = 0
 			} else {
 				v39 = int32(255)
 			}
 			v38 = v39
 		}
 		v36 = v38
 		goto _272
 	_272:
 		v29 = v36
 		goto _265
 	_265:
 		**(**uint8_t)(__ccgo_up(v4 + 2)) = libc.Uint8FromInt32(v29)
 		if bottom_y != libc.UintptrFromInt32(0) {
 			uv05 = (uint32(3)*l_uv + tl_uv + uint32(0x00020002)) >> int32(2)
 			v1 = libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(bottom_y + uintptr(len1-int32(1)))))
 			v2 = libc.Int32FromUint32(uv05 & uint32(0xff))
 			v3 = libc.Int32FromUint32(uv05 >> libc.Int32FromInt32(16))
 			v4 = bottom_dst + uintptr((len1-int32(1))*int32(3))
 			v7 = v1 * int32(19077) >> int32(8)
 			goto _282
 		_282:
 			v9 = v2 * int32(33050) >> int32(8)
 			goto _284
 		_284:
 			v11 = v7 + v9 - int32(17685)
 			if v11 & ^int32(YUV_MASK2) == 0 {
 				v14 = v11 >> int32(YUV_FIX2)
 			} else {
 				if v11 < 0 {
 					v15 = 0
 				} else {
 					v15 = int32(255)
 				}
 				v14 = v15
 			}
 			v12 = v14
 			goto _287
 		_287:
 			v5 = v12
 			goto _280
 		_280:
 			**(**uint8_t)(__ccgo_up(v4)) = libc.Uint8FromInt32(v5)
 			v18 = v1 * int32(19077) >> int32(8)
 			goto _293
 		_293:
 			v20 = v2 * int32(6419) >> int32(8)
 			goto _295
 		_295:
 			v22 = v3 * int32(13320) >> int32(8)
 			goto _297
 		_297:
 			v24 = v18 - v20 - v22 + int32(8708)
 			if v24 & ^int32(YUV_MASK2) == 0 {
 				v27 = v24 >> int32(YUV_FIX2)
 			} else {
 				if v24 < 0 {
 					v28 = 0
 				} else {
 					v28 = int32(255)
 				}
 				v27 = v28
 			}
 			v25 = v27
 			goto _300
 		_300:
 			v16 = v25
 			goto _291
 		_291:
 			**(**uint8_t)(__ccgo_up(v4 + 1)) = libc.Uint8FromInt32(v16)
 			v31 = v1 * int32(19077) >> int32(8)
 			goto _306
 		_306:
 			v33 = v3 * int32(26149) >> int32(8)
 			goto _308
 		_308:
 			v35 = v31 + v33 - int32(14234)
 			if v35 & ^int32(YUV_MASK2) == 0 {
 				v38 = v35 >> int32(YUV_FIX2)
 			} else {
 				if v35 < 0 {
 					v39 = 0
 				} else {
 					v39 = int32(255)
 				}
 				v38 = v39
 			}
 			v36 = v38
 			goto _311
 		_311:
 			v29 = v36
 			goto _304
 		_304:
 			**(**uint8_t)(__ccgo_up(v4 + 2)) = libc.Uint8FromInt32(v29)
 		}
 	}
 }
 
 func UpsampleRgba4444LinePair_C(tls *libc.TLS, top_y uintptr, bottom_y uintptr, top_u uintptr, top_v uintptr, cur_u uintptr, cur_v uintptr, top_dst uintptr, bottom_dst uintptr, len1 int32) {
 	var avg, diag_03, diag_12, l_uv, t_uv, tl_uv, uv, uv0, uv01, uv02, uv03, uv04, uv05, uv1, uv11 uint32_t
 	var b, ba, g, last_pixel_pair, r, rg, x, v1, v11, v12, v14, v15, v16, v18, v2, v20, v22, v24, v25, v27, v28, v29, v3, v31, v33, v35, v36, v38, v39, v5, v7, v9 int32
 	var v4 uintptr
 	_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = avg, b, ba, diag_03, diag_12, g, l_uv, last_pixel_pair, r, rg, t_uv, tl_uv, uv, uv0, uv01, uv02, uv03, uv04, uv05, uv1, uv11, x, v1, v11, v12, v14, v15, v16, v18, v2, v20, v22, v24, v25, v27, v28, v29, v3, v31, v33, v35, v36, v38, v39, v4, v5, v7, v9
 	last_pixel_pair = (len1 - int32(1)) >> int32(1)
 	tl_uv = libc.Uint32FromInt32(libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(top_u))) | libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(top_v)))<<libc.Int32FromInt32(16)) /* top-left sample */
 	l_uv = libc.Uint32FromInt32(libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(cur_u))) | libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(cur_v)))<<libc.Int32FromInt32(16))
 	uv0 = (uint32(3)*tl_uv + l_uv + uint32(0x00020002)) >> int32(2)
 	v1 = libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(top_y)))
 	v2 = libc.Int32FromUint32(uv0 & uint32(0xff))
 	v3 = libc.Int32FromUint32(uv0 >> libc.Int32FromInt32(16))
 	v4 = top_dst
 	v7 = v1 * int32(19077) >> int32(8)
 	goto _8
 _8:
 	v9 = v3 * int32(26149) >> int32(8)
 	goto _10
 _10:
 	v11 = v7 + v9 - int32(14234)
 	if v11 & ^int32(YUV_MASK2) == 0 {
 		v14 = v11 >> int32(YUV_FIX2)
 	} else {
 		if v11 < 0 {
 			v15 = 0
 		} else {
 			v15 = int32(255)
 		}
 		v14 = v15
 	}
 	v12 = v14
 	goto _13
 _13:
 	v5 = v12
 	goto _6
 _6:
 	r = v5
 	v18 = v1 * int32(19077) >> int32(8)
 	goto _19
 _19:
 	v20 = v2 * int32(6419) >> int32(8)
 	goto _21
 _21:
 	v22 = v3 * int32(13320) >> int32(8)
 	goto _23
 _23:
 	v24 = v18 - v20 - v22 + int32(8708)
 	if v24 & ^int32(YUV_MASK2) == 0 {
 		v27 = v24 >> int32(YUV_FIX2)
 	} else {
 		if v24 < 0 {
 			v28 = 0
 		} else {
 			v28 = int32(255)
 		}
 		v27 = v28
 	}
 	v25 = v27
 	goto _26
 _26:
 	v16 = v25
 	goto _17
 _17:
 	g = v16
 	v31 = v1 * int32(19077) >> int32(8)
 	goto _32
 _32:
 	v33 = v2 * int32(33050) >> int32(8)
 	goto _34
 _34:
 	v35 = v31 + v33 - int32(17685)
 	if v35 & ^int32(YUV_MASK2) == 0 {
 		v38 = v35 >> int32(YUV_FIX2)
 	} else {
 		if v35 < 0 {
 			v39 = 0
 		} else {
 			v39 = int32(255)
 		}
 		v38 = v39
 	}
 	v36 = v38
 	goto _37
 _37:
 	v29 = v36
 	goto _30
 _30:
 	b = v29
 	rg = r&int32(0xf0) | g>>libc.Int32FromInt32(4)
 	ba = b&int32(0xf0) | int32(0x0f)
 	**(**uint8_t)(__ccgo_up(v4)) = libc.Uint8FromInt32(rg)
 	**(**uint8_t)(__ccgo_up(v4 + 1)) = libc.Uint8FromInt32(ba)
 	if bottom_y != libc.UintptrFromInt32(0) {
 		uv01 = (uint32(3)*l_uv + tl_uv + uint32(0x00020002)) >> int32(2)
 		v1 = libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(bottom_y)))
 		v2 = libc.Int32FromUint32(uv01 & uint32(0xff))
 		v3 = libc.Int32FromUint32(uv01 >> libc.Int32FromInt32(16))
 		v4 = bottom_dst
 		v7 = v1 * int32(19077) >> int32(8)
 		goto _47
 	_47:
 		v9 = v3 * int32(26149) >> int32(8)
 		goto _49
 	_49:
 		v11 = v7 + v9 - int32(14234)
 		if v11 & ^int32(YUV_MASK2) == 0 {
 			v14 = v11 >> int32(YUV_FIX2)
 		} else {
 			if v11 < 0 {
 				v15 = 0
 			} else {
 				v15 = int32(255)
 			}
 			v14 = v15
 		}
 		v12 = v14
 		goto _52
 	_52:
 		v5 = v12
 		goto _45
 	_45:
 		r = v5
 		v18 = v1 * int32(19077) >> int32(8)
 		goto _58
 	_58:
 		v20 = v2 * int32(6419) >> int32(8)
 		goto _60
 	_60:
 		v22 = v3 * int32(13320) >> int32(8)
 		goto _62
 	_62:
 		v24 = v18 - v20 - v22 + int32(8708)
 		if v24 & ^int32(YUV_MASK2) == 0 {
 			v27 = v24 >> int32(YUV_FIX2)
 		} else {
 			if v24 < 0 {
 				v28 = 0
 			} else {
 				v28 = int32(255)
 			}
 			v27 = v28
 		}
 		v25 = v27
 		goto _65
 	_65:
 		v16 = v25
 		goto _56
 	_56:
 		g = v16
 		v31 = v1 * int32(19077) >> int32(8)
 		goto _71
 	_71:
 		v33 = v2 * int32(33050) >> int32(8)
 		goto _73
 	_73:
 		v35 = v31 + v33 - int32(17685)
 		if v35 & ^int32(YUV_MASK2) == 0 {
 			v38 = v35 >> int32(YUV_FIX2)
 		} else {
 			if v35 < 0 {
 				v39 = 0
 			} else {
 				v39 = int32(255)
 			}
 			v38 = v39
 		}
 		v36 = v38
 		goto _76
 	_76:
 		v29 = v36
 		goto _69
 	_69:
 		b = v29
 		rg = r&int32(0xf0) | g>>libc.Int32FromInt32(4)
 		ba = b&int32(0xf0) | int32(0x0f)
 		**(**uint8_t)(__ccgo_up(v4)) = libc.Uint8FromInt32(rg)
 		**(**uint8_t)(__ccgo_up(v4 + 1)) = libc.Uint8FromInt32(ba)
 	}
 	x = int32(1)
 	for {
 		if !(x <= last_pixel_pair) {
 			break
 		}
 		t_uv = libc.Uint32FromInt32(libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(top_u + uintptr(x)))) | libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(top_v + uintptr(x))))<<libc.Int32FromInt32(16)) /* top sample */
 		uv = libc.Uint32FromInt32(libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(cur_u + uintptr(x)))) | libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(cur_v + uintptr(x))))<<libc.Int32FromInt32(16))   /* sample */ /* precompute invariant values associated with first and second diagonals*/
 		avg = tl_uv + t_uv + l_uv + uv + uint32(0x00080008)
 		diag_12 = (avg + uint32(2)*(t_uv+l_uv)) >> int32(3)
 		diag_03 = (avg + uint32(2)*(tl_uv+uv)) >> int32(3)
 		uv02 = (diag_12 + tl_uv) >> int32(1)
 		uv1 = (diag_03 + t_uv) >> int32(1)
 		v1 = libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(top_y + uintptr(int32(2)*x-int32(1)))))
 		v2 = libc.Int32FromUint32(uv02 & uint32(0xff))
 		v3 = libc.Int32FromUint32(uv02 >> libc.Int32FromInt32(16))
 		v4 = top_dst + uintptr((int32(2)*x-int32(1))*int32(2))
 		v7 = v1 * int32(19077) >> int32(8)
 		goto _87
 	_87:
 		v9 = v3 * int32(26149) >> int32(8)
 		goto _89
 	_89:
 		v11 = v7 + v9 - int32(14234)
 		if v11 & ^int32(YUV_MASK2) == 0 {
 			v14 = v11 >> int32(YUV_FIX2)
 		} else {
 			if v11 < 0 {
 				v15 = 0
 			} else {
 				v15 = int32(255)
 			}
 			v14 = v15
 		}
 		v12 = v14
 		goto _92
 	_92:
 		v5 = v12
 		goto _85
 	_85:
 		r = v5
 		v18 = v1 * int32(19077) >> int32(8)
 		goto _98
 	_98:
 		v20 = v2 * int32(6419) >> int32(8)
 		goto _100
 	_100:
 		v22 = v3 * int32(13320) >> int32(8)
 		goto _102
 	_102:
 		v24 = v18 - v20 - v22 + int32(8708)
 		if v24 & ^int32(YUV_MASK2) == 0 {
 			v27 = v24 >> int32(YUV_FIX2)
 		} else {
 			if v24 < 0 {
 				v28 = 0
 			} else {
 				v28 = int32(255)
 			}
 			v27 = v28
 		}
 		v25 = v27
 		goto _105
 	_105:
 		v16 = v25
 		goto _96
 	_96:
 		g = v16
 		v31 = v1 * int32(19077) >> int32(8)
 		goto _111
 	_111:
 		v33 = v2 * int32(33050) >> int32(8)
 		goto _113
 	_113:
 		v35 = v31 + v33 - int32(17685)
 		if v35 & ^int32(YUV_MASK2) == 0 {
 			v38 = v35 >> int32(YUV_FIX2)
 		} else {
 			if v35 < 0 {
 				v39 = 0
 			} else {
 				v39 = int32(255)
 			}
 			v38 = v39
 		}
 		v36 = v38
 		goto _116
 	_116:
 		v29 = v36
 		goto _109
 	_109:
 		b = v29
 		rg = r&int32(0xf0) | g>>libc.Int32FromInt32(4)
 		ba = b&int32(0xf0) | int32(0x0f)
 		**(**uint8_t)(__ccgo_up(v4)) = libc.Uint8FromInt32(rg)
 		**(**uint8_t)(__ccgo_up(v4 + 1)) = libc.Uint8FromInt32(ba)
 		v1 = libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(top_y + uintptr(int32(2)*x-0))))
 		v2 = libc.Int32FromUint32(uv1 & uint32(0xff))
 		v3 = libc.Int32FromUint32(uv1 >> libc.Int32FromInt32(16))
 		v4 = top_dst + uintptr((int32(2)*x-0)*int32(2))
 		v7 = v1 * int32(19077) >> int32(8)
 		goto _126
 	_126:
 		v9 = v3 * int32(26149) >> int32(8)
 		goto _128
 	_128:
 		v11 = v7 + v9 - int32(14234)
 		if v11 & ^int32(YUV_MASK2) == 0 {
 			v14 = v11 >> int32(YUV_FIX2)
 		} else {
 			if v11 < 0 {
 				v15 = 0
 			} else {
 				v15 = int32(255)
 			}
 			v14 = v15
 		}
 		v12 = v14
 		goto _131
 	_131:
 		v5 = v12
 		goto _124
 	_124:
 		r = v5
 		v18 = v1 * int32(19077) >> int32(8)
 		goto _137
 	_137:
 		v20 = v2 * int32(6419) >> int32(8)
 		goto _139
 	_139:
 		v22 = v3 * int32(13320) >> int32(8)
 		goto _141
 	_141:
 		v24 = v18 - v20 - v22 + int32(8708)
 		if v24 & ^int32(YUV_MASK2) == 0 {
 			v27 = v24 >> int32(YUV_FIX2)
 		} else {
 			if v24 < 0 {
 				v28 = 0
 			} else {
 				v28 = int32(255)
 			}
 			v27 = v28
 		}
 		v25 = v27
 		goto _144
 	_144:
 		v16 = v25
 		goto _135
 	_135:
 		g = v16
 		v31 = v1 * int32(19077) >> int32(8)
 		goto _150
 	_150:
 		v33 = v2 * int32(33050) >> int32(8)
 		goto _152
 	_152:
 		v35 = v31 + v33 - int32(17685)
 		if v35 & ^int32(YUV_MASK2) == 0 {
 			v38 = v35 >> int32(YUV_FIX2)
 		} else {
 			if v35 < 0 {
 				v39 = 0
 			} else {
 				v39 = int32(255)
 			}
 			v38 = v39
 		}
 		v36 = v38
 		goto _155
 	_155:
 		v29 = v36
 		goto _148
 	_148:
 		b = v29
 		rg = r&int32(0xf0) | g>>libc.Int32FromInt32(4)
 		ba = b&int32(0xf0) | int32(0x0f)
 		**(**uint8_t)(__ccgo_up(v4)) = libc.Uint8FromInt32(rg)
 		**(**uint8_t)(__ccgo_up(v4 + 1)) = libc.Uint8FromInt32(ba)
 		if bottom_y != libc.UintptrFromInt32(0) {
 			uv03 = (diag_03 + l_uv) >> int32(1)
 			uv11 = (diag_12 + uv) >> int32(1)
 			v1 = libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(bottom_y + uintptr(int32(2)*x-int32(1)))))
 			v2 = libc.Int32FromUint32(uv03 & uint32(0xff))
 			v3 = libc.Int32FromUint32(uv03 >> libc.Int32FromInt32(16))
 			v4 = bottom_dst + uintptr((int32(2)*x-int32(1))*int32(2))
 			v7 = v1 * int32(19077) >> int32(8)
 			goto _165
 		_165:
 			v9 = v3 * int32(26149) >> int32(8)
 			goto _167
 		_167:
 			v11 = v7 + v9 - int32(14234)
 			if v11 & ^int32(YUV_MASK2) == 0 {
 				v14 = v11 >> int32(YUV_FIX2)
 			} else {
 				if v11 < 0 {
 					v15 = 0
 				} else {
 					v15 = int32(255)
 				}
 				v14 = v15
 			}
 			v12 = v14
 			goto _170
 		_170:
 			v5 = v12
 			goto _163
 		_163:
 			r = v5
 			v18 = v1 * int32(19077) >> int32(8)
 			goto _176
 		_176:
 			v20 = v2 * int32(6419) >> int32(8)
 			goto _178
 		_178:
 			v22 = v3 * int32(13320) >> int32(8)
 			goto _180
 		_180:
 			v24 = v18 - v20 - v22 + int32(8708)
 			if v24 & ^int32(YUV_MASK2) == 0 {
 				v27 = v24 >> int32(YUV_FIX2)
 			} else {
 				if v24 < 0 {
 					v28 = 0
 				} else {
 					v28 = int32(255)
 				}
 				v27 = v28
 			}
 			v25 = v27
 			goto _183
 		_183:
 			v16 = v25
 			goto _174
 		_174:
 			g = v16
 			v31 = v1 * int32(19077) >> int32(8)
 			goto _189
 		_189:
 			v33 = v2 * int32(33050) >> int32(8)
 			goto _191
 		_191:
 			v35 = v31 + v33 - int32(17685)
 			if v35 & ^int32(YUV_MASK2) == 0 {
 				v38 = v35 >> int32(YUV_FIX2)
 			} else {
 				if v35 < 0 {
 					v39 = 0
 				} else {
 					v39 = int32(255)
 				}
 				v38 = v39
 			}
 			v36 = v38
 			goto _194
 		_194:
 			v29 = v36
 			goto _187
 		_187:
 			b = v29
 			rg = r&int32(0xf0) | g>>libc.Int32FromInt32(4)
 			ba = b&int32(0xf0) | int32(0x0f)
 			**(**uint8_t)(__ccgo_up(v4)) = libc.Uint8FromInt32(rg)
 			**(**uint8_t)(__ccgo_up(v4 + 1)) = libc.Uint8FromInt32(ba)
 			v1 = libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(bottom_y + uintptr(int32(2)*x+0))))
 			v2 = libc.Int32FromUint32(uv11 & uint32(0xff))
 			v3 = libc.Int32FromUint32(uv11 >> libc.Int32FromInt32(16))
 			v4 = bottom_dst + uintptr((int32(2)*x+0)*int32(2))
 			v7 = v1 * int32(19077) >> int32(8)
 			goto _204
 		_204:
 			v9 = v3 * int32(26149) >> int32(8)
 			goto _206
 		_206:
 			v11 = v7 + v9 - int32(14234)
 			if v11 & ^int32(YUV_MASK2) == 0 {
 				v14 = v11 >> int32(YUV_FIX2)
 			} else {
 				if v11 < 0 {
 					v15 = 0
 				} else {
 					v15 = int32(255)
 				}
 				v14 = v15
 			}
 			v12 = v14
 			goto _209
 		_209:
 			v5 = v12
 			goto _202
 		_202:
 			r = v5
 			v18 = v1 * int32(19077) >> int32(8)
 			goto _215
 		_215:
 			v20 = v2 * int32(6419) >> int32(8)
 			goto _217
 		_217:
 			v22 = v3 * int32(13320) >> int32(8)
 			goto _219
 		_219:
 			v24 = v18 - v20 - v22 + int32(8708)
 			if v24 & ^int32(YUV_MASK2) == 0 {
 				v27 = v24 >> int32(YUV_FIX2)
 			} else {
 				if v24 < 0 {
 					v28 = 0
 				} else {
 					v28 = int32(255)
 				}
 				v27 = v28
 			}
 			v25 = v27
 			goto _222
 		_222:
 			v16 = v25
 			goto _213
 		_213:
 			g = v16
 			v31 = v1 * int32(19077) >> int32(8)
 			goto _228
 		_228:
 			v33 = v2 * int32(33050) >> int32(8)
 			goto _230
 		_230:
 			v35 = v31 + v33 - int32(17685)
 			if v35 & ^int32(YUV_MASK2) == 0 {
 				v38 = v35 >> int32(YUV_FIX2)
 			} else {
 				if v35 < 0 {
 					v39 = 0
 				} else {
 					v39 = int32(255)
 				}
 				v38 = v39
 			}
 			v36 = v38
 			goto _233
 		_233:
 			v29 = v36
 			goto _226
 		_226:
 			b = v29
 			rg = r&int32(0xf0) | g>>libc.Int32FromInt32(4)
 			ba = b&int32(0xf0) | int32(0x0f)
 			**(**uint8_t)(__ccgo_up(v4)) = libc.Uint8FromInt32(rg)
 			**(**uint8_t)(__ccgo_up(v4 + 1)) = libc.Uint8FromInt32(ba)
 		}
 		tl_uv = t_uv
 		l_uv = uv
 		goto _79
 	_79:
 		;
 		x = x + 1
 	}
 	if !(len1&libc.Int32FromInt32(1) != 0) {
 		uv04 = (uint32(3)*tl_uv + l_uv + uint32(0x00020002)) >> int32(2)
 		v1 = libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(top_y + uintptr(len1-int32(1)))))
 		v2 = libc.Int32FromUint32(uv04 & uint32(0xff))
 		v3 = libc.Int32FromUint32(uv04 >> libc.Int32FromInt32(16))
 		v4 = top_dst + uintptr((len1-int32(1))*int32(2))
 		v7 = v1 * int32(19077) >> int32(8)
 		goto _243
 	_243:
 		v9 = v3 * int32(26149) >> int32(8)
 		goto _245
 	_245:
 		v11 = v7 + v9 - int32(14234)
 		if v11 & ^int32(YUV_MASK2) == 0 {
 			v14 = v11 >> int32(YUV_FIX2)
 		} else {
 			if v11 < 0 {
 				v15 = 0
 			} else {
 				v15 = int32(255)
 			}
 			v14 = v15
 		}
 		v12 = v14
 		goto _248
 	_248:
 		v5 = v12
 		goto _241
 	_241:
 		r = v5
 		v18 = v1 * int32(19077) >> int32(8)
 		goto _254
 	_254:
 		v20 = v2 * int32(6419) >> int32(8)
 		goto _256
 	_256:
 		v22 = v3 * int32(13320) >> int32(8)
 		goto _258
 	_258:
 		v24 = v18 - v20 - v22 + int32(8708)
 		if v24 & ^int32(YUV_MASK2) == 0 {
 			v27 = v24 >> int32(YUV_FIX2)
 		} else {
 			if v24 < 0 {
 				v28 = 0
 			} else {
 				v28 = int32(255)
 			}
 			v27 = v28
 		}
 		v25 = v27
 		goto _261
 	_261:
 		v16 = v25
 		goto _252
 	_252:
 		g = v16
 		v31 = v1 * int32(19077) >> int32(8)
 		goto _267
 	_267:
 		v33 = v2 * int32(33050) >> int32(8)
 		goto _269
 	_269:
 		v35 = v31 + v33 - int32(17685)
 		if v35 & ^int32(YUV_MASK2) == 0 {
 			v38 = v35 >> int32(YUV_FIX2)
 		} else {
 			if v35 < 0 {
 				v39 = 0
 			} else {
 				v39 = int32(255)
 			}
 			v38 = v39
 		}
 		v36 = v38
 		goto _272
 	_272:
 		v29 = v36
 		goto _265
 	_265:
 		b = v29
 		rg = r&int32(0xf0) | g>>libc.Int32FromInt32(4)
 		ba = b&int32(0xf0) | int32(0x0f)
 		**(**uint8_t)(__ccgo_up(v4)) = libc.Uint8FromInt32(rg)
 		**(**uint8_t)(__ccgo_up(v4 + 1)) = libc.Uint8FromInt32(ba)
 		if bottom_y != libc.UintptrFromInt32(0) {
 			uv05 = (uint32(3)*l_uv + tl_uv + uint32(0x00020002)) >> int32(2)
 			v1 = libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(bottom_y + uintptr(len1-int32(1)))))
 			v2 = libc.Int32FromUint32(uv05 & uint32(0xff))
 			v3 = libc.Int32FromUint32(uv05 >> libc.Int32FromInt32(16))
 			v4 = bottom_dst + uintptr((len1-int32(1))*int32(2))
 			v7 = v1 * int32(19077) >> int32(8)
 			goto _282
 		_282:
 			v9 = v3 * int32(26149) >> int32(8)
 			goto _284
 		_284:
 			v11 = v7 + v9 - int32(14234)
 			if v11 & ^int32(YUV_MASK2) == 0 {
 				v14 = v11 >> int32(YUV_FIX2)
 			} else {
 				if v11 < 0 {
 					v15 = 0
 				} else {
 					v15 = int32(255)
 				}
 				v14 = v15
 			}
 			v12 = v14
 			goto _287
 		_287:
 			v5 = v12
 			goto _280
 		_280:
 			r = v5
 			v18 = v1 * int32(19077) >> int32(8)
 			goto _293
 		_293:
 			v20 = v2 * int32(6419) >> int32(8)
 			goto _295
 		_295:
 			v22 = v3 * int32(13320) >> int32(8)
 			goto _297
 		_297:
 			v24 = v18 - v20 - v22 + int32(8708)
 			if v24 & ^int32(YUV_MASK2) == 0 {
 				v27 = v24 >> int32(YUV_FIX2)
 			} else {
 				if v24 < 0 {
 					v28 = 0
 				} else {
 					v28 = int32(255)
 				}
 				v27 = v28
 			}
 			v25 = v27
 			goto _300
 		_300:
 			v16 = v25
 			goto _291
 		_291:
 			g = v16
 			v31 = v1 * int32(19077) >> int32(8)
 			goto _306
 		_306:
 			v33 = v2 * int32(33050) >> int32(8)
 			goto _308
 		_308:
 			v35 = v31 + v33 - int32(17685)
 			if v35 & ^int32(YUV_MASK2) == 0 {
 				v38 = v35 >> int32(YUV_FIX2)
 			} else {
 				if v35 < 0 {
 					v39 = 0
 				} else {
 					v39 = int32(255)
 				}
 				v38 = v39
 			}
 			v36 = v38
 			goto _311
 		_311:
 			v29 = v36
 			goto _304
 		_304:
 			b = v29
 			rg = r&int32(0xf0) | g>>libc.Int32FromInt32(4)
 			ba = b&int32(0xf0) | int32(0x0f)
 			**(**uint8_t)(__ccgo_up(v4)) = libc.Uint8FromInt32(rg)
 			**(**uint8_t)(__ccgo_up(v4 + 1)) = libc.Uint8FromInt32(ba)
 		}
 	}
 }
 
 func UpsampleRgb565LinePair_C(tls *libc.TLS, top_y uintptr, bottom_y uintptr, top_u uintptr, top_v uintptr, cur_u uintptr, cur_v uintptr, top_dst uintptr, bottom_dst uintptr, len1 int32) {
 	var avg, diag_03, diag_12, l_uv, t_uv, tl_uv, uv, uv0, uv01, uv02, uv03, uv04, uv05, uv1, uv11 uint32_t
 	var b, g, gb, last_pixel_pair, r, rg, x, v1, v11, v12, v14, v15, v16, v18, v2, v20, v22, v24, v25, v27, v28, v29, v3, v31, v33, v35, v36, v38, v39, v5, v7, v9 int32
 	var v4 uintptr
 	_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = avg, b, diag_03, diag_12, g, gb, l_uv, last_pixel_pair, r, rg, t_uv, tl_uv, uv, uv0, uv01, uv02, uv03, uv04, uv05, uv1, uv11, x, v1, v11, v12, v14, v15, v16, v18, v2, v20, v22, v24, v25, v27, v28, v29, v3, v31, v33, v35, v36, v38, v39, v4, v5, v7, v9
 	last_pixel_pair = (len1 - int32(1)) >> int32(1)
 	tl_uv = libc.Uint32FromInt32(libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(top_u))) | libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(top_v)))<<libc.Int32FromInt32(16)) /* top-left sample */
 	l_uv = libc.Uint32FromInt32(libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(cur_u))) | libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(cur_v)))<<libc.Int32FromInt32(16))
 	uv0 = (uint32(3)*tl_uv + l_uv + uint32(0x00020002)) >> int32(2)
 	v1 = libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(top_y)))
 	v2 = libc.Int32FromUint32(uv0 & uint32(0xff))
 	v3 = libc.Int32FromUint32(uv0 >> libc.Int32FromInt32(16))
 	v4 = top_dst
 	v7 = v1 * int32(19077) >> int32(8)
 	goto _8
 _8:
 	v9 = v3 * int32(26149) >> int32(8)
 	goto _10
 _10:
 	v11 = v7 + v9 - int32(14234)
 	if v11 & ^int32(YUV_MASK2) == 0 {
 		v14 = v11 >> int32(YUV_FIX2)
 	} else {
 		if v11 < 0 {
 			v15 = 0
 		} else {
 			v15 = int32(255)
 		}
 		v14 = v15
 	}
 	v12 = v14
 	goto _13
 _13:
 	v5 = v12
 	goto _6
 _6:
 	r = v5
 	v18 = v1 * int32(19077) >> int32(8)
 	goto _19
 _19:
 	v20 = v2 * int32(6419) >> int32(8)
 	goto _21
 _21:
 	v22 = v3 * int32(13320) >> int32(8)
 	goto _23
 _23:
 	v24 = v18 - v20 - v22 + int32(8708)
 	if v24 & ^int32(YUV_MASK2) == 0 {
 		v27 = v24 >> int32(YUV_FIX2)
 	} else {
 		if v24 < 0 {
 			v28 = 0
 		} else {
 			v28 = int32(255)
 		}
 		v27 = v28
 	}
 	v25 = v27
 	goto _26
 _26:
 	v16 = v25
 	goto _17
 _17:
 	g = v16
 	v31 = v1 * int32(19077) >> int32(8)
 	goto _32
 _32:
 	v33 = v2 * int32(33050) >> int32(8)
 	goto _34
 _34:
 	v35 = v31 + v33 - int32(17685)
 	if v35 & ^int32(YUV_MASK2) == 0 {
 		v38 = v35 >> int32(YUV_FIX2)
 	} else {
 		if v35 < 0 {
 			v39 = 0
 		} else {
 			v39 = int32(255)
 		}
 		v38 = v39
 	}
 	v36 = v38
 	goto _37
 _37:
 	v29 = v36
 	goto _30
 _30:
 	b = v29
 	rg = r&int32(0xf8) | g>>libc.Int32FromInt32(5)
 	gb = g<<libc.Int32FromInt32(3)&int32(0xe0) | b>>libc.Int32FromInt32(3)
 	**(**uint8_t)(__ccgo_up(v4)) = libc.Uint8FromInt32(rg)
 	**(**uint8_t)(__ccgo_up(v4 + 1)) = libc.Uint8FromInt32(gb)
 	if bottom_y != libc.UintptrFromInt32(0) {
 		uv01 = (uint32(3)*l_uv + tl_uv + uint32(0x00020002)) >> int32(2)
 		v1 = libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(bottom_y)))
 		v2 = libc.Int32FromUint32(uv01 & uint32(0xff))
 		v3 = libc.Int32FromUint32(uv01 >> libc.Int32FromInt32(16))
 		v4 = bottom_dst
 		v7 = v1 * int32(19077) >> int32(8)
 		goto _47
 	_47:
 		v9 = v3 * int32(26149) >> int32(8)
 		goto _49
 	_49:
 		v11 = v7 + v9 - int32(14234)
 		if v11 & ^int32(YUV_MASK2) == 0 {
 			v14 = v11 >> int32(YUV_FIX2)
 		} else {
 			if v11 < 0 {
 				v15 = 0
 			} else {
 				v15 = int32(255)
 			}
 			v14 = v15
 		}
 		v12 = v14
 		goto _52
 	_52:
 		v5 = v12
 		goto _45
 	_45:
 		r = v5
 		v18 = v1 * int32(19077) >> int32(8)
 		goto _58
 	_58:
 		v20 = v2 * int32(6419) >> int32(8)
 		goto _60
 	_60:
 		v22 = v3 * int32(13320) >> int32(8)
 		goto _62
 	_62:
 		v24 = v18 - v20 - v22 + int32(8708)
 		if v24 & ^int32(YUV_MASK2) == 0 {
 			v27 = v24 >> int32(YUV_FIX2)
 		} else {
 			if v24 < 0 {
 				v28 = 0
 			} else {
 				v28 = int32(255)
 			}
 			v27 = v28
 		}
 		v25 = v27
 		goto _65
 	_65:
 		v16 = v25
 		goto _56
 	_56:
 		g = v16
 		v31 = v1 * int32(19077) >> int32(8)
 		goto _71
 	_71:
 		v33 = v2 * int32(33050) >> int32(8)
 		goto _73
 	_73:
 		v35 = v31 + v33 - int32(17685)
 		if v35 & ^int32(YUV_MASK2) == 0 {
 			v38 = v35 >> int32(YUV_FIX2)
 		} else {
 			if v35 < 0 {
 				v39 = 0
 			} else {
 				v39 = int32(255)
 			}
 			v38 = v39
 		}
 		v36 = v38
 		goto _76
 	_76:
 		v29 = v36
 		goto _69
 	_69:
 		b = v29
 		rg = r&int32(0xf8) | g>>libc.Int32FromInt32(5)
 		gb = g<<libc.Int32FromInt32(3)&int32(0xe0) | b>>libc.Int32FromInt32(3)
 		**(**uint8_t)(__ccgo_up(v4)) = libc.Uint8FromInt32(rg)
 		**(**uint8_t)(__ccgo_up(v4 + 1)) = libc.Uint8FromInt32(gb)
 	}
 	x = int32(1)
 	for {
 		if !(x <= last_pixel_pair) {
 			break
 		}
 		t_uv = libc.Uint32FromInt32(libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(top_u + uintptr(x)))) | libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(top_v + uintptr(x))))<<libc.Int32FromInt32(16)) /* top sample */
 		uv = libc.Uint32FromInt32(libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(cur_u + uintptr(x)))) | libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(cur_v + uintptr(x))))<<libc.Int32FromInt32(16))   /* sample */ /* precompute invariant values associated with first and second diagonals*/
 		avg = tl_uv + t_uv + l_uv + uv + uint32(0x00080008)
 		diag_12 = (avg + uint32(2)*(t_uv+l_uv)) >> int32(3)
 		diag_03 = (avg + uint32(2)*(tl_uv+uv)) >> int32(3)
 		uv02 = (diag_12 + tl_uv) >> int32(1)
 		uv1 = (diag_03 + t_uv) >> int32(1)
 		v1 = libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(top_y + uintptr(int32(2)*x-int32(1)))))
 		v2 = libc.Int32FromUint32(uv02 & uint32(0xff))
 		v3 = libc.Int32FromUint32(uv02 >> libc.Int32FromInt32(16))
 		v4 = top_dst + uintptr((int32(2)*x-int32(1))*int32(2))
 		v7 = v1 * int32(19077) >> int32(8)
 		goto _87
 	_87:
 		v9 = v3 * int32(26149) >> int32(8)
 		goto _89
 	_89:
 		v11 = v7 + v9 - int32(14234)
 		if v11 & ^int32(YUV_MASK2) == 0 {
 			v14 = v11 >> int32(YUV_FIX2)
 		} else {
 			if v11 < 0 {
 				v15 = 0
 			} else {
 				v15 = int32(255)
 			}
 			v14 = v15
 		}
 		v12 = v14
 		goto _92
 	_92:
 		v5 = v12
 		goto _85
 	_85:
 		r = v5
 		v18 = v1 * int32(19077) >> int32(8)
 		goto _98
 	_98:
 		v20 = v2 * int32(6419) >> int32(8)
 		goto _100
 	_100:
 		v22 = v3 * int32(13320) >> int32(8)
 		goto _102
 	_102:
 		v24 = v18 - v20 - v22 + int32(8708)
 		if v24 & ^int32(YUV_MASK2) == 0 {
 			v27 = v24 >> int32(YUV_FIX2)
 		} else {
 			if v24 < 0 {
 				v28 = 0
 			} else {
 				v28 = int32(255)
 			}
 			v27 = v28
 		}
 		v25 = v27
 		goto _105
 	_105:
 		v16 = v25
 		goto _96
 	_96:
 		g = v16
 		v31 = v1 * int32(19077) >> int32(8)
 		goto _111
 	_111:
 		v33 = v2 * int32(33050) >> int32(8)
 		goto _113
 	_113:
 		v35 = v31 + v33 - int32(17685)
 		if v35 & ^int32(YUV_MASK2) == 0 {
 			v38 = v35 >> int32(YUV_FIX2)
 		} else {
 			if v35 < 0 {
 				v39 = 0
 			} else {
 				v39 = int32(255)
 			}
 			v38 = v39
 		}
 		v36 = v38
 		goto _116
 	_116:
 		v29 = v36
 		goto _109
 	_109:
 		b = v29
 		rg = r&int32(0xf8) | g>>libc.Int32FromInt32(5)
 		gb = g<<libc.Int32FromInt32(3)&int32(0xe0) | b>>libc.Int32FromInt32(3)
 		**(**uint8_t)(__ccgo_up(v4)) = libc.Uint8FromInt32(rg)
 		**(**uint8_t)(__ccgo_up(v4 + 1)) = libc.Uint8FromInt32(gb)
 		v1 = libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(top_y + uintptr(int32(2)*x-0))))
 		v2 = libc.Int32FromUint32(uv1 & uint32(0xff))
 		v3 = libc.Int32FromUint32(uv1 >> libc.Int32FromInt32(16))
 		v4 = top_dst + uintptr((int32(2)*x-0)*int32(2))
 		v7 = v1 * int32(19077) >> int32(8)
 		goto _126
 	_126:
 		v9 = v3 * int32(26149) >> int32(8)
 		goto _128
 	_128:
 		v11 = v7 + v9 - int32(14234)
 		if v11 & ^int32(YUV_MASK2) == 0 {
 			v14 = v11 >> int32(YUV_FIX2)
 		} else {
 			if v11 < 0 {
 				v15 = 0
 			} else {
 				v15 = int32(255)
 			}
 			v14 = v15
 		}
 		v12 = v14
 		goto _131
 	_131:
 		v5 = v12
 		goto _124
 	_124:
 		r = v5
 		v18 = v1 * int32(19077) >> int32(8)
 		goto _137
 	_137:
 		v20 = v2 * int32(6419) >> int32(8)
 		goto _139
 	_139:
 		v22 = v3 * int32(13320) >> int32(8)
 		goto _141
 	_141:
 		v24 = v18 - v20 - v22 + int32(8708)
 		if v24 & ^int32(YUV_MASK2) == 0 {
 			v27 = v24 >> int32(YUV_FIX2)
 		} else {
 			if v24 < 0 {
 				v28 = 0
 			} else {
 				v28 = int32(255)
 			}
 			v27 = v28
 		}
 		v25 = v27
 		goto _144
 	_144:
 		v16 = v25
 		goto _135
 	_135:
 		g = v16
 		v31 = v1 * int32(19077) >> int32(8)
 		goto _150
 	_150:
 		v33 = v2 * int32(33050) >> int32(8)
 		goto _152
 	_152:
 		v35 = v31 + v33 - int32(17685)
 		if v35 & ^int32(YUV_MASK2) == 0 {
 			v38 = v35 >> int32(YUV_FIX2)
 		} else {
 			if v35 < 0 {
 				v39 = 0
 			} else {
 				v39 = int32(255)
 			}
 			v38 = v39
 		}
 		v36 = v38
 		goto _155
 	_155:
 		v29 = v36
 		goto _148
 	_148:
 		b = v29
 		rg = r&int32(0xf8) | g>>libc.Int32FromInt32(5)
 		gb = g<<libc.Int32FromInt32(3)&int32(0xe0) | b>>libc.Int32FromInt32(3)
 		**(**uint8_t)(__ccgo_up(v4)) = libc.Uint8FromInt32(rg)
 		**(**uint8_t)(__ccgo_up(v4 + 1)) = libc.Uint8FromInt32(gb)
 		if bottom_y != libc.UintptrFromInt32(0) {
 			uv03 = (diag_03 + l_uv) >> int32(1)
 			uv11 = (diag_12 + uv) >> int32(1)
 			v1 = libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(bottom_y + uintptr(int32(2)*x-int32(1)))))
 			v2 = libc.Int32FromUint32(uv03 & uint32(0xff))
 			v3 = libc.Int32FromUint32(uv03 >> libc.Int32FromInt32(16))
 			v4 = bottom_dst + uintptr((int32(2)*x-int32(1))*int32(2))
 			v7 = v1 * int32(19077) >> int32(8)
 			goto _165
 		_165:
 			v9 = v3 * int32(26149) >> int32(8)
 			goto _167
 		_167:
 			v11 = v7 + v9 - int32(14234)
 			if v11 & ^int32(YUV_MASK2) == 0 {
 				v14 = v11 >> int32(YUV_FIX2)
 			} else {
 				if v11 < 0 {
 					v15 = 0
 				} else {
 					v15 = int32(255)
 				}
 				v14 = v15
 			}
 			v12 = v14
 			goto _170
 		_170:
 			v5 = v12
 			goto _163
 		_163:
 			r = v5
 			v18 = v1 * int32(19077) >> int32(8)
 			goto _176
 		_176:
 			v20 = v2 * int32(6419) >> int32(8)
 			goto _178
 		_178:
 			v22 = v3 * int32(13320) >> int32(8)
 			goto _180
 		_180:
 			v24 = v18 - v20 - v22 + int32(8708)
 			if v24 & ^int32(YUV_MASK2) == 0 {
 				v27 = v24 >> int32(YUV_FIX2)
 			} else {
 				if v24 < 0 {
 					v28 = 0
 				} else {
 					v28 = int32(255)
 				}
 				v27 = v28
 			}
 			v25 = v27
 			goto _183
 		_183:
 			v16 = v25
 			goto _174
 		_174:
 			g = v16
 			v31 = v1 * int32(19077) >> int32(8)
 			goto _189
 		_189:
 			v33 = v2 * int32(33050) >> int32(8)
 			goto _191
 		_191:
 			v35 = v31 + v33 - int32(17685)
 			if v35 & ^int32(YUV_MASK2) == 0 {
 				v38 = v35 >> int32(YUV_FIX2)
 			} else {
 				if v35 < 0 {
 					v39 = 0
 				} else {
 					v39 = int32(255)
 				}
 				v38 = v39
 			}
 			v36 = v38
 			goto _194
 		_194:
 			v29 = v36
 			goto _187
 		_187:
 			b = v29
 			rg = r&int32(0xf8) | g>>libc.Int32FromInt32(5)
 			gb = g<<libc.Int32FromInt32(3)&int32(0xe0) | b>>libc.Int32FromInt32(3)
 			**(**uint8_t)(__ccgo_up(v4)) = libc.Uint8FromInt32(rg)
 			**(**uint8_t)(__ccgo_up(v4 + 1)) = libc.Uint8FromInt32(gb)
 			v1 = libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(bottom_y + uintptr(int32(2)*x+0))))
 			v2 = libc.Int32FromUint32(uv11 & uint32(0xff))
 			v3 = libc.Int32FromUint32(uv11 >> libc.Int32FromInt32(16))
 			v4 = bottom_dst + uintptr((int32(2)*x+0)*int32(2))
 			v7 = v1 * int32(19077) >> int32(8)
 			goto _204
 		_204:
 			v9 = v3 * int32(26149) >> int32(8)
 			goto _206
 		_206:
 			v11 = v7 + v9 - int32(14234)
 			if v11 & ^int32(YUV_MASK2) == 0 {
 				v14 = v11 >> int32(YUV_FIX2)
 			} else {
 				if v11 < 0 {
 					v15 = 0
 				} else {
 					v15 = int32(255)
 				}
 				v14 = v15
 			}
 			v12 = v14
 			goto _209
 		_209:
 			v5 = v12
 			goto _202
 		_202:
 			r = v5
 			v18 = v1 * int32(19077) >> int32(8)
 			goto _215
 		_215:
 			v20 = v2 * int32(6419) >> int32(8)
 			goto _217
 		_217:
 			v22 = v3 * int32(13320) >> int32(8)
 			goto _219
 		_219:
 			v24 = v18 - v20 - v22 + int32(8708)
 			if v24 & ^int32(YUV_MASK2) == 0 {
 				v27 = v24 >> int32(YUV_FIX2)
 			} else {
 				if v24 < 0 {
 					v28 = 0
 				} else {
 					v28 = int32(255)
 				}
 				v27 = v28
 			}
 			v25 = v27
 			goto _222
 		_222:
 			v16 = v25
 			goto _213
 		_213:
 			g = v16
 			v31 = v1 * int32(19077) >> int32(8)
 			goto _228
 		_228:
 			v33 = v2 * int32(33050) >> int32(8)
 			goto _230
 		_230:
 			v35 = v31 + v33 - int32(17685)
 			if v35 & ^int32(YUV_MASK2) == 0 {
 				v38 = v35 >> int32(YUV_FIX2)
 			} else {
 				if v35 < 0 {
 					v39 = 0
 				} else {
 					v39 = int32(255)
 				}
 				v38 = v39
 			}
 			v36 = v38
 			goto _233
 		_233:
 			v29 = v36
 			goto _226
 		_226:
 			b = v29
 			rg = r&int32(0xf8) | g>>libc.Int32FromInt32(5)
 			gb = g<<libc.Int32FromInt32(3)&int32(0xe0) | b>>libc.Int32FromInt32(3)
 			**(**uint8_t)(__ccgo_up(v4)) = libc.Uint8FromInt32(rg)
 			**(**uint8_t)(__ccgo_up(v4 + 1)) = libc.Uint8FromInt32(gb)
 		}
 		tl_uv = t_uv
 		l_uv = uv
 		goto _79
 	_79:
 		;
 		x = x + 1
 	}
 	if !(len1&libc.Int32FromInt32(1) != 0) {
 		uv04 = (uint32(3)*tl_uv + l_uv + uint32(0x00020002)) >> int32(2)
 		v1 = libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(top_y + uintptr(len1-int32(1)))))
 		v2 = libc.Int32FromUint32(uv04 & uint32(0xff))
 		v3 = libc.Int32FromUint32(uv04 >> libc.Int32FromInt32(16))
 		v4 = top_dst + uintptr((len1-int32(1))*int32(2))
 		v7 = v1 * int32(19077) >> int32(8)
 		goto _243
 	_243:
 		v9 = v3 * int32(26149) >> int32(8)
 		goto _245
 	_245:
 		v11 = v7 + v9 - int32(14234)
 		if v11 & ^int32(YUV_MASK2) == 0 {
 			v14 = v11 >> int32(YUV_FIX2)
 		} else {
 			if v11 < 0 {
 				v15 = 0
 			} else {
 				v15 = int32(255)
 			}
 			v14 = v15
 		}
 		v12 = v14
 		goto _248
 	_248:
 		v5 = v12
 		goto _241
 	_241:
 		r = v5
 		v18 = v1 * int32(19077) >> int32(8)
 		goto _254
 	_254:
 		v20 = v2 * int32(6419) >> int32(8)
 		goto _256
 	_256:
 		v22 = v3 * int32(13320) >> int32(8)
 		goto _258
 	_258:
 		v24 = v18 - v20 - v22 + int32(8708)
 		if v24 & ^int32(YUV_MASK2) == 0 {
 			v27 = v24 >> int32(YUV_FIX2)
 		} else {
 			if v24 < 0 {
 				v28 = 0
 			} else {
 				v28 = int32(255)
 			}
 			v27 = v28
 		}
 		v25 = v27
 		goto _261
 	_261:
 		v16 = v25
 		goto _252
 	_252:
 		g = v16
 		v31 = v1 * int32(19077) >> int32(8)
 		goto _267
 	_267:
 		v33 = v2 * int32(33050) >> int32(8)
 		goto _269
 	_269:
 		v35 = v31 + v33 - int32(17685)
 		if v35 & ^int32(YUV_MASK2) == 0 {
 			v38 = v35 >> int32(YUV_FIX2)
 		} else {
 			if v35 < 0 {
 				v39 = 0
 			} else {
 				v39 = int32(255)
 			}
 			v38 = v39
 		}
 		v36 = v38
 		goto _272
 	_272:
 		v29 = v36
 		goto _265
 	_265:
 		b = v29
 		rg = r&int32(0xf8) | g>>libc.Int32FromInt32(5)
 		gb = g<<libc.Int32FromInt32(3)&int32(0xe0) | b>>libc.Int32FromInt32(3)
 		**(**uint8_t)(__ccgo_up(v4)) = libc.Uint8FromInt32(rg)
 		**(**uint8_t)(__ccgo_up(v4 + 1)) = libc.Uint8FromInt32(gb)
 		if bottom_y != libc.UintptrFromInt32(0) {
 			uv05 = (uint32(3)*l_uv + tl_uv + uint32(0x00020002)) >> int32(2)
 			v1 = libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(bottom_y + uintptr(len1-int32(1)))))
 			v2 = libc.Int32FromUint32(uv05 & uint32(0xff))
 			v3 = libc.Int32FromUint32(uv05 >> libc.Int32FromInt32(16))
 			v4 = bottom_dst + uintptr((len1-int32(1))*int32(2))
 			v7 = v1 * int32(19077) >> int32(8)
 			goto _282
 		_282:
 			v9 = v3 * int32(26149) >> int32(8)
 			goto _284
 		_284:
 			v11 = v7 + v9 - int32(14234)
 			if v11 & ^int32(YUV_MASK2) == 0 {
 				v14 = v11 >> int32(YUV_FIX2)
 			} else {
 				if v11 < 0 {
 					v15 = 0
 				} else {
 					v15 = int32(255)
 				}
 				v14 = v15
 			}
 			v12 = v14
 			goto _287
 		_287:
 			v5 = v12
 			goto _280
 		_280:
 			r = v5
 			v18 = v1 * int32(19077) >> int32(8)
 			goto _293
 		_293:
 			v20 = v2 * int32(6419) >> int32(8)
 			goto _295
 		_295:
 			v22 = v3 * int32(13320) >> int32(8)
 			goto _297
 		_297:
 			v24 = v18 - v20 - v22 + int32(8708)
 			if v24 & ^int32(YUV_MASK2) == 0 {
 				v27 = v24 >> int32(YUV_FIX2)
 			} else {
 				if v24 < 0 {
 					v28 = 0
 				} else {
 					v28 = int32(255)
 				}
 				v27 = v28
 			}
 			v25 = v27
 			goto _300
 		_300:
 			v16 = v25
 			goto _291
 		_291:
 			g = v16
 			v31 = v1 * int32(19077) >> int32(8)
 			goto _306
 		_306:
 			v33 = v2 * int32(33050) >> int32(8)
 			goto _308
 		_308:
 			v35 = v31 + v33 - int32(17685)
 			if v35 & ^int32(YUV_MASK2) == 0 {
 				v38 = v35 >> int32(YUV_FIX2)
 			} else {
 				if v35 < 0 {
 					v39 = 0
 				} else {
 					v39 = int32(255)
 				}
 				v38 = v39
 			}
 			v36 = v38
 			goto _311
 		_311:
 			v29 = v36
 			goto _304
 		_304:
 			b = v29
 			rg = r&int32(0xf8) | g>>libc.Int32FromInt32(5)
 			gb = g<<libc.Int32FromInt32(3)&int32(0xe0) | b>>libc.Int32FromInt32(3)
 			**(**uint8_t)(__ccgo_up(v4)) = libc.Uint8FromInt32(rg)
 			**(**uint8_t)(__ccgo_up(v4 + 1)) = libc.Uint8FromInt32(gb)
 		}
 	}
 }
 
 //------------------------------------------------------------------------------
 
 func WebPGetLinePairConverter(tls *libc.TLS, alpha_is_last int32) (r WebPUpsampleLinePairFunc) {
 	var v1 int32
 	_ = v1
 	WebPInitUpsamplers(tls)
 	if alpha_is_last != 0 {
 		v1 = int32(MODE_BGRA)
 	} else {
 		v1 = int32(MODE_ARGB)
 	}
 	return WebPUpsamplers[v1]
 }
 
 func WebPYuv444ToRgba_C(tls *libc.TLS, y5 uintptr, u4 uintptr, v6 uintptr, dst uintptr, len1 int32) {
 	var i, v11, v13, v14, v16, v17, v18, v20, v22, v24, v26, v27, v29, v3, v30, v31, v33, v35, v37, v38, v4, v40, v41, v5, v7, v9 int32
 	var v2, v61 uintptr
 	_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = i, v11, v13, v14, v16, v17, v18, v2, v20, v22, v24, v26, v27, v29, v3, v30, v31, v33, v35, v37, v38, v4, v40, v41, v5, v61, v7, v9
 	i = 0
 	for {
 		if !(i < len1) {
 			break
 		}
 		v2 = dst + uintptr(i*int32(4))
 		v3 = libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(y5 + uintptr(i))))
 		v4 = libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(u4 + uintptr(i))))
 		v5 = libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(v6 + uintptr(i))))
 		v61 = v2
 		v9 = v3 * int32(19077) >> int32(8)
 		goto _10
 	_10:
 		v11 = v5 * int32(26149) >> int32(8)
 		goto _12
 	_12:
 		v13 = v9 + v11 - int32(14234)
 		if v13 & ^int32(YUV_MASK2) == 0 {
 			v16 = v13 >> int32(YUV_FIX2)
 		} else {
 			if v13 < 0 {
 				v17 = 0
 			} else {
 				v17 = int32(255)
 			}
 			v16 = v17
 		}
 		v14 = v16
 		goto _15
 	_15:
 		v7 = v14
 		goto _8
 	_8:
 		**(**uint8_t)(__ccgo_up(v61)) = libc.Uint8FromInt32(v7)
 		v20 = v3 * int32(19077) >> int32(8)
 		goto _21
 	_21:
 		v22 = v4 * int32(6419) >> int32(8)
 		goto _23
 	_23:
 		v24 = v5 * int32(13320) >> int32(8)
 		goto _25
 	_25:
 		v26 = v20 - v22 - v24 + int32(8708)
 		if v26 & ^int32(YUV_MASK2) == 0 {
 			v29 = v26 >> int32(YUV_FIX2)
 		} else {
 			if v26 < 0 {
 				v30 = 0
 			} else {
 				v30 = int32(255)
 			}
 			v29 = v30
 		}
 		v27 = v29
 		goto _28
 	_28:
 		v18 = v27
 		goto _19
 	_19:
 		**(**uint8_t)(__ccgo_up(v61 + 1)) = libc.Uint8FromInt32(v18)
 		v33 = v3 * int32(19077) >> int32(8)
 		goto _34
 	_34:
 		v35 = v4 * int32(33050) >> int32(8)
 		goto _36
 	_36:
 		v37 = v33 + v35 - int32(17685)
 		if v37 & ^int32(YUV_MASK2) == 0 {
 			v40 = v37 >> int32(YUV_FIX2)
 		} else {
 			if v37 < 0 {
 				v41 = 0
 			} else {
 				v41 = int32(255)
 			}
 			v40 = v41
 		}
 		v38 = v40
 		goto _39
 	_39:
 		v31 = v38
 		goto _32
 	_32:
 		**(**uint8_t)(__ccgo_up(v61 + 2)) = libc.Uint8FromInt32(v31)
 		**(**uint8_t)(__ccgo_up(v2 + 3)) = uint8(0xff)
 		goto _1
 	_1:
 		;
 		i = i + 1
 	}
 }
 
 func WebPYuv444ToBgra_C(tls *libc.TLS, y5 uintptr, u4 uintptr, v6 uintptr, dst uintptr, len1 int32) {
 	var i, v11, v13, v14, v16, v17, v18, v20, v22, v24, v26, v27, v29, v3, v30, v31, v33, v35, v37, v38, v4, v40, v41, v5, v7, v9 int32
 	var v2, v61 uintptr
 	_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = i, v11, v13, v14, v16, v17, v18, v2, v20, v22, v24, v26, v27, v29, v3, v30, v31, v33, v35, v37, v38, v4, v40, v41, v5, v61, v7, v9
 	i = 0
 	for {
 		if !(i < len1) {
 			break
 		}
 		v2 = dst + uintptr(i*int32(4))
 		v3 = libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(y5 + uintptr(i))))
 		v4 = libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(u4 + uintptr(i))))
 		v5 = libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(v6 + uintptr(i))))
 		v61 = v2
 		v9 = v3 * int32(19077) >> int32(8)
 		goto _10
 	_10:
 		v11 = v4 * int32(33050) >> int32(8)
 		goto _12
 	_12:
 		v13 = v9 + v11 - int32(17685)
 		if v13 & ^int32(YUV_MASK2) == 0 {
 			v16 = v13 >> int32(YUV_FIX2)
 		} else {
 			if v13 < 0 {
 				v17 = 0
 			} else {
 				v17 = int32(255)
 			}
 			v16 = v17
 		}
 		v14 = v16
 		goto _15
 	_15:
 		v7 = v14
 		goto _8
 	_8:
 		**(**uint8_t)(__ccgo_up(v61)) = libc.Uint8FromInt32(v7)
 		v20 = v3 * int32(19077) >> int32(8)
 		goto _21
 	_21:
 		v22 = v4 * int32(6419) >> int32(8)
 		goto _23
 	_23:
 		v24 = v5 * int32(13320) >> int32(8)
 		goto _25
 	_25:
 		v26 = v20 - v22 - v24 + int32(8708)
 		if v26 & ^int32(YUV_MASK2) == 0 {
 			v29 = v26 >> int32(YUV_FIX2)
 		} else {
 			if v26 < 0 {
 				v30 = 0
 			} else {
 				v30 = int32(255)
 			}
 			v29 = v30
 		}
 		v27 = v29
 		goto _28
 	_28:
 		v18 = v27
 		goto _19
 	_19:
 		**(**uint8_t)(__ccgo_up(v61 + 1)) = libc.Uint8FromInt32(v18)
 		v33 = v3 * int32(19077) >> int32(8)
 		goto _34
 	_34:
 		v35 = v5 * int32(26149) >> int32(8)
 		goto _36
 	_36:
 		v37 = v33 + v35 - int32(14234)
 		if v37 & ^int32(YUV_MASK2) == 0 {
 			v40 = v37 >> int32(YUV_FIX2)
 		} else {
 			if v37 < 0 {
 				v41 = 0
 			} else {
 				v41 = int32(255)
 			}
 			v40 = v41
 		}
 		v38 = v40
 		goto _39
 	_39:
 		v31 = v38
 		goto _32
 	_32:
 		**(**uint8_t)(__ccgo_up(v61 + 2)) = libc.Uint8FromInt32(v31)
 		**(**uint8_t)(__ccgo_up(v2 + 3)) = uint8(0xff)
 		goto _1
 	_1:
 		;
 		i = i + 1
 	}
 }
 
 func WebPYuv444ToRgb_C(tls *libc.TLS, y4 uintptr, u3 uintptr, v5 uintptr, dst uintptr, len1 int32) {
 	var i, v10, v12, v13, v15, v16, v17, v19, v2, v21, v23, v25, v26, v28, v29, v3, v30, v32, v34, v36, v37, v39, v4, v40, v6, v8 int32
 	var v51 uintptr
 	_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = i, v10, v12, v13, v15, v16, v17, v19, v2, v21, v23, v25, v26, v28, v29, v3, v30, v32, v34, v36, v37, v39, v4, v40, v51, v6, v8
 	i = 0
 	for {
 		if !(i < len1) {
 			break
 		}
 		v2 = libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(y4 + uintptr(i))))
 		v3 = libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(u3 + uintptr(i))))
 		v4 = libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(v5 + uintptr(i))))
 		v51 = dst + uintptr(i*int32(3))
 		v8 = v2 * int32(19077) >> int32(8)
 		goto _9
 	_9:
 		v10 = v4 * int32(26149) >> int32(8)
 		goto _11
 	_11:
 		v12 = v8 + v10 - int32(14234)
 		if v12 & ^int32(YUV_MASK2) == 0 {
 			v15 = v12 >> int32(YUV_FIX2)
 		} else {
 			if v12 < 0 {
 				v16 = 0
 			} else {
 				v16 = int32(255)
 			}
 			v15 = v16
 		}
 		v13 = v15
 		goto _14
 	_14:
 		v6 = v13
 		goto _7
 	_7:
 		**(**uint8_t)(__ccgo_up(v51)) = libc.Uint8FromInt32(v6)
 		v19 = v2 * int32(19077) >> int32(8)
 		goto _20
 	_20:
 		v21 = v3 * int32(6419) >> int32(8)
 		goto _22
 	_22:
 		v23 = v4 * int32(13320) >> int32(8)
 		goto _24
 	_24:
 		v25 = v19 - v21 - v23 + int32(8708)
 		if v25 & ^int32(YUV_MASK2) == 0 {
 			v28 = v25 >> int32(YUV_FIX2)
 		} else {
 			if v25 < 0 {
 				v29 = 0
 			} else {
 				v29 = int32(255)
 			}
 			v28 = v29
 		}
 		v26 = v28
 		goto _27
 	_27:
 		v17 = v26
 		goto _18
 	_18:
 		**(**uint8_t)(__ccgo_up(v51 + 1)) = libc.Uint8FromInt32(v17)
 		v32 = v2 * int32(19077) >> int32(8)
 		goto _33
 	_33:
 		v34 = v3 * int32(33050) >> int32(8)
 		goto _35
 	_35:
 		v36 = v32 + v34 - int32(17685)
 		if v36 & ^int32(YUV_MASK2) == 0 {
 			v39 = v36 >> int32(YUV_FIX2)
 		} else {
 			if v36 < 0 {
 				v40 = 0
 			} else {
 				v40 = int32(255)
 			}
 			v39 = v40
 		}
 		v37 = v39
 		goto _38
 	_38:
 		v30 = v37
 		goto _31
 	_31:
 		**(**uint8_t)(__ccgo_up(v51 + 2)) = libc.Uint8FromInt32(v30)
 		goto _1
 	_1:
 		;
 		i = i + 1
 	}
 }
 
 func WebPYuv444ToBgr_C(tls *libc.TLS, y4 uintptr, u3 uintptr, v5 uintptr, dst uintptr, len1 int32) {
 	var i, v10, v12, v13, v15, v16, v17, v19, v2, v21, v23, v25, v26, v28, v29, v3, v30, v32, v34, v36, v37, v39, v4, v40, v6, v8 int32
 	var v51 uintptr
 	_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = i, v10, v12, v13, v15, v16, v17, v19, v2, v21, v23, v25, v26, v28, v29, v3, v30, v32, v34, v36, v37, v39, v4, v40, v51, v6, v8
 	i = 0
 	for {
 		if !(i < len1) {
 			break
 		}
 		v2 = libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(y4 + uintptr(i))))
 		v3 = libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(u3 + uintptr(i))))
 		v4 = libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(v5 + uintptr(i))))
 		v51 = dst + uintptr(i*int32(3))
 		v8 = v2 * int32(19077) >> int32(8)
 		goto _9
 	_9:
 		v10 = v3 * int32(33050) >> int32(8)
 		goto _11
 	_11:
 		v12 = v8 + v10 - int32(17685)
 		if v12 & ^int32(YUV_MASK2) == 0 {
 			v15 = v12 >> int32(YUV_FIX2)
 		} else {
 			if v12 < 0 {
 				v16 = 0
 			} else {
 				v16 = int32(255)
 			}
 			v15 = v16
 		}
 		v13 = v15
 		goto _14
 	_14:
 		v6 = v13
 		goto _7
 	_7:
 		**(**uint8_t)(__ccgo_up(v51)) = libc.Uint8FromInt32(v6)
 		v19 = v2 * int32(19077) >> int32(8)
 		goto _20
 	_20:
 		v21 = v3 * int32(6419) >> int32(8)
 		goto _22
 	_22:
 		v23 = v4 * int32(13320) >> int32(8)
 		goto _24
 	_24:
 		v25 = v19 - v21 - v23 + int32(8708)
 		if v25 & ^int32(YUV_MASK2) == 0 {
 			v28 = v25 >> int32(YUV_FIX2)
 		} else {
 			if v25 < 0 {
 				v29 = 0
 			} else {
 				v29 = int32(255)
 			}
 			v28 = v29
 		}
 		v26 = v28
 		goto _27
 	_27:
 		v17 = v26
 		goto _18
 	_18:
 		**(**uint8_t)(__ccgo_up(v51 + 1)) = libc.Uint8FromInt32(v17)
 		v32 = v2 * int32(19077) >> int32(8)
 		goto _33
 	_33:
 		v34 = v4 * int32(26149) >> int32(8)
 		goto _35
 	_35:
 		v36 = v32 + v34 - int32(14234)
 		if v36 & ^int32(YUV_MASK2) == 0 {
 			v39 = v36 >> int32(YUV_FIX2)
 		} else {
 			if v36 < 0 {
 				v40 = 0
 			} else {
 				v40 = int32(255)
 			}
 			v39 = v40
 		}
 		v37 = v39
 		goto _38
 	_38:
 		v30 = v37
 		goto _31
 	_31:
 		**(**uint8_t)(__ccgo_up(v51 + 2)) = libc.Uint8FromInt32(v30)
 		goto _1
 	_1:
 		;
 		i = i + 1
 	}
 }
 
 func WebPYuv444ToArgb_C(tls *libc.TLS, y5 uintptr, u4 uintptr, v6 uintptr, dst uintptr, len1 int32) {
 	var i, v11, v13, v14, v16, v17, v18, v20, v22, v24, v26, v27, v29, v3, v30, v31, v33, v35, v37, v38, v4, v40, v41, v5, v7, v9 int32
 	var v2, v61 uintptr
 	_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = i, v11, v13, v14, v16, v17, v18, v2, v20, v22, v24, v26, v27, v29, v3, v30, v31, v33, v35, v37, v38, v4, v40, v41, v5, v61, v7, v9
 	i = 0
 	for {
 		if !(i < len1) {
 			break
 		}
 		v2 = dst + uintptr(i*int32(4))
 		**(**uint8_t)(__ccgo_up(v2)) = uint8(0xff)
 		v3 = libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(y5 + uintptr(i))))
 		v4 = libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(u4 + uintptr(i))))
 		v5 = libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(v6 + uintptr(i))))
 		v61 = v2 + uintptr(1)
 		v9 = v3 * int32(19077) >> int32(8)
 		goto _10
 	_10:
 		v11 = v5 * int32(26149) >> int32(8)
 		goto _12
 	_12:
 		v13 = v9 + v11 - int32(14234)
 		if v13 & ^int32(YUV_MASK2) == 0 {
 			v16 = v13 >> int32(YUV_FIX2)
 		} else {
 			if v13 < 0 {
 				v17 = 0
 			} else {
 				v17 = int32(255)
 			}
 			v16 = v17
 		}
 		v14 = v16
 		goto _15
 	_15:
 		v7 = v14
 		goto _8
 	_8:
 		**(**uint8_t)(__ccgo_up(v61)) = libc.Uint8FromInt32(v7)
 		v20 = v3 * int32(19077) >> int32(8)
 		goto _21
 	_21:
 		v22 = v4 * int32(6419) >> int32(8)
 		goto _23
 	_23:
 		v24 = v5 * int32(13320) >> int32(8)
 		goto _25
 	_25:
 		v26 = v20 - v22 - v24 + int32(8708)
 		if v26 & ^int32(YUV_MASK2) == 0 {
 			v29 = v26 >> int32(YUV_FIX2)
 		} else {
 			if v26 < 0 {
 				v30 = 0
 			} else {
 				v30 = int32(255)
 			}
 			v29 = v30
 		}
 		v27 = v29
 		goto _28
 	_28:
 		v18 = v27
 		goto _19
 	_19:
 		**(**uint8_t)(__ccgo_up(v61 + 1)) = libc.Uint8FromInt32(v18)
 		v33 = v3 * int32(19077) >> int32(8)
 		goto _34
 	_34:
 		v35 = v4 * int32(33050) >> int32(8)
 		goto _36
 	_36:
 		v37 = v33 + v35 - int32(17685)
 		if v37 & ^int32(YUV_MASK2) == 0 {
 			v40 = v37 >> int32(YUV_FIX2)
 		} else {
 			if v37 < 0 {
 				v41 = 0
 			} else {
 				v41 = int32(255)
 			}
 			v40 = v41
 		}
 		v38 = v40
 		goto _39
 	_39:
 		v31 = v38
 		goto _32
 	_32:
 		**(**uint8_t)(__ccgo_up(v61 + 2)) = libc.Uint8FromInt32(v31)
 		goto _1
 	_1:
 		;
 		i = i + 1
 	}
 }
 
 func WebPYuv444ToRgba4444_C(tls *libc.TLS, y4 uintptr, u3 uintptr, v5 uintptr, dst uintptr, len1 int32) {
 	var b, ba, g, i, r, rg, v10, v12, v13, v15, v16, v17, v19, v2, v21, v23, v25, v26, v28, v29, v3, v30, v32, v34, v36, v37, v39, v4, v40, v6, v8 int32
 	var v51 uintptr
 	_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = b, ba, g, i, r, rg, v10, v12, v13, v15, v16, v17, v19, v2, v21, v23, v25, v26, v28, v29, v3, v30, v32, v34, v36, v37, v39, v4, v40, v51, v6, v8
 	i = 0
 	for {
 		if !(i < len1) {
 			break
 		}
 		v2 = libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(y4 + uintptr(i))))
 		v3 = libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(u3 + uintptr(i))))
 		v4 = libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(v5 + uintptr(i))))
 		v51 = dst + uintptr(i*int32(2))
 		v8 = v2 * int32(19077) >> int32(8)
 		goto _9
 	_9:
 		v10 = v4 * int32(26149) >> int32(8)
 		goto _11
 	_11:
 		v12 = v8 + v10 - int32(14234)
 		if v12 & ^int32(YUV_MASK2) == 0 {
 			v15 = v12 >> int32(YUV_FIX2)
 		} else {
 			if v12 < 0 {
 				v16 = 0
 			} else {
 				v16 = int32(255)
 			}
 			v15 = v16
 		}
 		v13 = v15
 		goto _14
 	_14:
 		v6 = v13
 		goto _7
 	_7:
 		r = v6
 		v19 = v2 * int32(19077) >> int32(8)
 		goto _20
 	_20:
 		v21 = v3 * int32(6419) >> int32(8)
 		goto _22
 	_22:
 		v23 = v4 * int32(13320) >> int32(8)
 		goto _24
 	_24:
 		v25 = v19 - v21 - v23 + int32(8708)
 		if v25 & ^int32(YUV_MASK2) == 0 {
 			v28 = v25 >> int32(YUV_FIX2)
 		} else {
 			if v25 < 0 {
 				v29 = 0
 			} else {
 				v29 = int32(255)
 			}
 			v28 = v29
 		}
 		v26 = v28
 		goto _27
 	_27:
 		v17 = v26
 		goto _18
 	_18:
 		g = v17
 		v32 = v2 * int32(19077) >> int32(8)
 		goto _33
 	_33:
 		v34 = v3 * int32(33050) >> int32(8)
 		goto _35
 	_35:
 		v36 = v32 + v34 - int32(17685)
 		if v36 & ^int32(YUV_MASK2) == 0 {
 			v39 = v36 >> int32(YUV_FIX2)
 		} else {
 			if v36 < 0 {
 				v40 = 0
 			} else {
 				v40 = int32(255)
 			}
 			v39 = v40
 		}
 		v37 = v39
 		goto _38
 	_38:
 		v30 = v37
 		goto _31
 	_31:
 		b = v30
 		rg = r&int32(0xf0) | g>>libc.Int32FromInt32(4)
 		ba = b&int32(0xf0) | int32(0x0f)
 		**(**uint8_t)(__ccgo_up(v51)) = libc.Uint8FromInt32(rg)
 		**(**uint8_t)(__ccgo_up(v51 + 1)) = libc.Uint8FromInt32(ba)
 		goto _1
 	_1:
 		;
 		i = i + 1
 	}
 }
 
 func WebPYuv444ToRgb565_C(tls *libc.TLS, y4 uintptr, u3 uintptr, v5 uintptr, dst uintptr, len1 int32) {
 	var b, g, gb, i, r, rg, v10, v12, v13, v15, v16, v17, v19, v2, v21, v23, v25, v26, v28, v29, v3, v30, v32, v34, v36, v37, v39, v4, v40, v6, v8 int32
 	var v51 uintptr
 	_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = b, g, gb, i, r, rg, v10, v12, v13, v15, v16, v17, v19, v2, v21, v23, v25, v26, v28, v29, v3, v30, v32, v34, v36, v37, v39, v4, v40, v51, v6, v8
 	i = 0
 	for {
 		if !(i < len1) {
 			break
 		}
 		v2 = libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(y4 + uintptr(i))))
 		v3 = libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(u3 + uintptr(i))))
 		v4 = libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(v5 + uintptr(i))))
 		v51 = dst + uintptr(i*int32(2))
 		v8 = v2 * int32(19077) >> int32(8)
 		goto _9
 	_9:
 		v10 = v4 * int32(26149) >> int32(8)
 		goto _11
 	_11:
 		v12 = v8 + v10 - int32(14234)
 		if v12 & ^int32(YUV_MASK2) == 0 {
 			v15 = v12 >> int32(YUV_FIX2)
 		} else {
 			if v12 < 0 {
 				v16 = 0
 			} else {
 				v16 = int32(255)
 			}
 			v15 = v16
 		}
 		v13 = v15
 		goto _14
 	_14:
 		v6 = v13
 		goto _7
 	_7:
 		r = v6
 		v19 = v2 * int32(19077) >> int32(8)
 		goto _20
 	_20:
 		v21 = v3 * int32(6419) >> int32(8)
 		goto _22
 	_22:
 		v23 = v4 * int32(13320) >> int32(8)
 		goto _24
 	_24:
 		v25 = v19 - v21 - v23 + int32(8708)
 		if v25 & ^int32(YUV_MASK2) == 0 {
 			v28 = v25 >> int32(YUV_FIX2)
 		} else {
 			if v25 < 0 {
 				v29 = 0
 			} else {
 				v29 = int32(255)
 			}
 			v28 = v29
 		}
 		v26 = v28
 		goto _27
 	_27:
 		v17 = v26
 		goto _18
 	_18:
 		g = v17
 		v32 = v2 * int32(19077) >> int32(8)
 		goto _33
 	_33:
 		v34 = v3 * int32(33050) >> int32(8)
 		goto _35
 	_35:
 		v36 = v32 + v34 - int32(17685)
 		if v36 & ^int32(YUV_MASK2) == 0 {
 			v39 = v36 >> int32(YUV_FIX2)
 		} else {
 			if v36 < 0 {
 				v40 = 0
 			} else {
 				v40 = int32(255)
 			}
 			v39 = v40
 		}
 		v37 = v39
 		goto _38
 	_38:
 		v30 = v37
 		goto _31
 	_31:
 		b = v30
 		rg = r&int32(0xf8) | g>>libc.Int32FromInt32(5)
 		gb = g<<libc.Int32FromInt32(3)&int32(0xe0) | b>>libc.Int32FromInt32(3)
 		**(**uint8_t)(__ccgo_up(v51)) = libc.Uint8FromInt32(rg)
 		**(**uint8_t)(__ccgo_up(v51 + 1)) = libc.Uint8FromInt32(gb)
 		goto _1
 	_1:
 		;
 		i = i + 1
 	}
 }
 
 func WebPInitYUV444Converters(tls *libc.TLS) {
 	if libc.AtomicLoadPUintptr(uintptr(unsafe.Pointer(&WebPInitYUV444Converters_body_last_cpuinfo_used))) == VP8GetCPUInfo {
 		goto _1
 	}
 	WebPInitYUV444Converters_body(tls)
 	libc.AtomicStorePUintptr(uintptr(unsafe.Pointer(&WebPInitYUV444Converters_body_last_cpuinfo_used)), VP8GetCPUInfo)
 	goto _2
 _2:
 	;
 	goto _1
 _1: /**/ //
 }
 
 var WebPInitYUV444Converters_body_last_cpuinfo_used = uintptr(0)
 
 func init() {
 	p := unsafe.Pointer(&WebPInitYUV444Converters_body_last_cpuinfo_used)
 	*(*uintptr)(unsafe.Add(p, 0)) = uintptr(unsafe.Pointer(&WebPInitYUV444Converters_body_last_cpuinfo_used))
 }
 
 func WebPInitYUV444Converters_body(tls *libc.TLS) {
 	WebPYUV444Converters[int32(MODE_RGBA)] = __ccgo_fp(WebPYuv444ToRgba_C)
 	WebPYUV444Converters[int32(MODE_BGRA)] = __ccgo_fp(WebPYuv444ToBgra_C)
 	WebPYUV444Converters[int32(MODE_RGB)] = __ccgo_fp(WebPYuv444ToRgb_C)
 	WebPYUV444Converters[int32(MODE_BGR)] = __ccgo_fp(WebPYuv444ToBgr_C)
 	WebPYUV444Converters[int32(MODE_ARGB)] = __ccgo_fp(WebPYuv444ToArgb_C)
 	WebPYUV444Converters[int32(MODE_RGBA_4444)] = __ccgo_fp(WebPYuv444ToRgba4444_C)
 	WebPYUV444Converters[int32(MODE_RGB_565)] = __ccgo_fp(WebPYuv444ToRgb565_C)
 	WebPYUV444Converters[int32(MODE_rgbA)] = __ccgo_fp(WebPYuv444ToRgba_C)
 	WebPYUV444Converters[int32(MODE_bgrA)] = __ccgo_fp(WebPYuv444ToBgra_C)
 	WebPYUV444Converters[int32(MODE_Argb)] = __ccgo_fp(WebPYuv444ToArgb_C)
 	WebPYUV444Converters[int32(MODE_rgbA_4444)] = __ccgo_fp(WebPYuv444ToRgba4444_C)
 	if VP8GetCPUInfo != libc.UintptrFromInt32(0) {
 	}
 }
 
 func WebPInitUpsamplers(tls *libc.TLS) {
 	if libc.AtomicLoadPUintptr(uintptr(unsafe.Pointer(&WebPInitUpsamplers_body_last_cpuinfo_used))) == VP8GetCPUInfo {
 		goto _1
 	}
 	WebPInitUpsamplers_body(tls)
 	libc.AtomicStorePUintptr(uintptr(unsafe.Pointer(&WebPInitUpsamplers_body_last_cpuinfo_used)), VP8GetCPUInfo)
 	goto _2
 _2:
 	;
 	goto _1
 _1: /**/ //
 }
 
 var WebPInitUpsamplers_body_last_cpuinfo_used = uintptr(0)
 
 func init() {
 	p := unsafe.Pointer(&WebPInitUpsamplers_body_last_cpuinfo_used)
 	*(*uintptr)(unsafe.Add(p, 0)) = uintptr(unsafe.Pointer(&WebPInitUpsamplers_body_last_cpuinfo_used))
 }
 
 func WebPInitUpsamplers_body(tls *libc.TLS) {
 	WebPUpsamplers[int32(MODE_RGBA)] = __ccgo_fp(UpsampleRgbaLinePair_C)
 	WebPUpsamplers[int32(MODE_BGRA)] = __ccgo_fp(UpsampleBgraLinePair_C)
 	WebPUpsamplers[int32(MODE_rgbA)] = __ccgo_fp(UpsampleRgbaLinePair_C)
 	WebPUpsamplers[int32(MODE_bgrA)] = __ccgo_fp(UpsampleBgraLinePair_C)
 	WebPUpsamplers[int32(MODE_RGB)] = __ccgo_fp(UpsampleRgbLinePair_C)
 	WebPUpsamplers[int32(MODE_BGR)] = __ccgo_fp(UpsampleBgrLinePair_C)
 	WebPUpsamplers[int32(MODE_ARGB)] = __ccgo_fp(UpsampleArgbLinePair_C)
 	WebPUpsamplers[int32(MODE_RGBA_4444)] = __ccgo_fp(UpsampleRgba4444LinePair_C)
 	WebPUpsamplers[int32(MODE_RGB_565)] = __ccgo_fp(UpsampleRgb565LinePair_C)
 	WebPUpsamplers[int32(MODE_Argb)] = __ccgo_fp(UpsampleArgbLinePair_C)
 	WebPUpsamplers[int32(MODE_rgbA_4444)] = __ccgo_fp(UpsampleRgba4444LinePair_C)
 	// If defined, use CPUInfo() to overwrite some pointers with faster versions.
 	if VP8GetCPUInfo != libc.UintptrFromInt32(0) {
 	}
 }
 
 func WebPInitYUV444ConvertersMIPSdspR2(tls *libc.TLS) {
 }
 
 func WebPInitUpsamplersMIPSdspR2(tls *libc.TLS) {
 }
 
 func WebPInitUpsamplersMSA(tls *libc.TLS) {
 }
 
 func WebPInitUpsamplersNEON(tls *libc.TLS) {
 }
 
 func WebPInitYUV444ConvertersSSE2(tls *libc.TLS) {
 }
 
 func WebPInitUpsamplersSSE2(tls *libc.TLS) {
 }
 
 func WebPInitYUV444ConvertersSSE41(tls *libc.TLS) {
 }
 
 func WebPInitUpsamplersSSE41(tls *libc.TLS) {
 }
 
 // Copyright 2010 Google Inc. All Rights Reserved.
 //
 // Use of this source code is governed by a BSD-style license
 // that can be found in the COPYING file in the root of the source
 // tree. An additional intellectual property rights grant can be found
 // in the file PATENTS. All contributing project authors may
 // be found in the AUTHORS file in the root of the source tree.
 // -----------------------------------------------------------------------------
 //
 //  Main decoding functions for WebP images.
 //
 // Author: Skal (pascal.massimino@gmail.com)
 
 //-----------------------------------------------------------------------------
 // Plain-C version
 
 // C documentation
 //
 //	// All variants implemented.
 func YuvToRgbRow(tls *libc.TLS, y4 uintptr, u3 uintptr, v5 uintptr, dst uintptr, len1 int32) {
 	var end, v4 uintptr
 	var v1, v11, v12, v14, v15, v16, v18, v2, v20, v22, v24, v25, v27, v28, v29, v3, v31, v33, v35, v36, v38, v39, v51, v7, v9 int32
 	_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = end, v1, v11, v12, v14, v15, v16, v18, v2, v20, v22, v24, v25, v27, v28, v29, v3, v31, v33, v35, v36, v38, v39, v4, v51, v7, v9
 	end = dst + uintptr(len1 & ^libc.Int32FromInt32(1) * int32(3))
 	for dst != end {
 		v1 = libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(y4)))
 		v2 = libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(u3)))
 		v3 = libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(v5)))
 		v4 = dst
 		v7 = v1 * int32(19077) >> int32(8)
 		goto _8
 	_8:
 		v9 = v3 * int32(26149) >> int32(8)
 		goto _10
 	_10:
 		v11 = v7 + v9 - int32(14234)
 		if v11 & ^int32(YUV_MASK2) == 0 {
 			v14 = v11 >> int32(YUV_FIX2)
 		} else {
 			if v11 < 0 {
 				v15 = 0
 			} else {
 				v15 = int32(255)
 			}
 			v14 = v15
 		}
 		v12 = v14
 		goto _13
 	_13:
 		v51 = v12
 		goto _6
 	_6:
 		**(**uint8_t)(__ccgo_up(v4)) = libc.Uint8FromInt32(v51)
 		v18 = v1 * int32(19077) >> int32(8)
 		goto _19
 	_19:
 		v20 = v2 * int32(6419) >> int32(8)
 		goto _21
 	_21:
 		v22 = v3 * int32(13320) >> int32(8)
 		goto _23
 	_23:
 		v24 = v18 - v20 - v22 + int32(8708)
 		if v24 & ^int32(YUV_MASK2) == 0 {
 			v27 = v24 >> int32(YUV_FIX2)
 		} else {
 			if v24 < 0 {
 				v28 = 0
 			} else {
 				v28 = int32(255)
 			}
 			v27 = v28
 		}
 		v25 = v27
 		goto _26
 	_26:
 		v16 = v25
 		goto _17
 	_17:
 		**(**uint8_t)(__ccgo_up(v4 + 1)) = libc.Uint8FromInt32(v16)
 		v31 = v1 * int32(19077) >> int32(8)
 		goto _32
 	_32:
 		v33 = v2 * int32(33050) >> int32(8)
 		goto _34
 	_34:
 		v35 = v31 + v33 - int32(17685)
 		if v35 & ^int32(YUV_MASK2) == 0 {
 			v38 = v35 >> int32(YUV_FIX2)
 		} else {
 			if v35 < 0 {
 				v39 = 0
 			} else {
 				v39 = int32(255)
 			}
 			v38 = v39
 		}
 		v36 = v38
 		goto _37
 	_37:
 		v29 = v36
 		goto _30
 	_30:
 		**(**uint8_t)(__ccgo_up(v4 + 2)) = libc.Uint8FromInt32(v29)
 		v1 = libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(y4 + 1)))
 		v2 = libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(u3)))
 		v3 = libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(v5)))
 		v4 = dst + uintptr(libc.Int32FromInt32(3))
 		v7 = v1 * int32(19077) >> int32(8)
 		goto _47
 	_47:
 		v9 = v3 * int32(26149) >> int32(8)
 		goto _49
 	_49:
 		v11 = v7 + v9 - int32(14234)
 		if v11 & ^int32(YUV_MASK2) == 0 {
 			v14 = v11 >> int32(YUV_FIX2)
 		} else {
 			if v11 < 0 {
 				v15 = 0
 			} else {
 				v15 = int32(255)
 			}
 			v14 = v15
 		}
 		v12 = v14
 		goto _52
 	_52:
 		v51 = v12
 		goto _45
 	_45:
 		**(**uint8_t)(__ccgo_up(v4)) = libc.Uint8FromInt32(v51)
 		v18 = v1 * int32(19077) >> int32(8)
 		goto _58
 	_58:
 		v20 = v2 * int32(6419) >> int32(8)
 		goto _60
 	_60:
 		v22 = v3 * int32(13320) >> int32(8)
 		goto _62
 	_62:
 		v24 = v18 - v20 - v22 + int32(8708)
 		if v24 & ^int32(YUV_MASK2) == 0 {
 			v27 = v24 >> int32(YUV_FIX2)
 		} else {
 			if v24 < 0 {
 				v28 = 0
 			} else {
 				v28 = int32(255)
 			}
 			v27 = v28
 		}
 		v25 = v27
 		goto _65
 	_65:
 		v16 = v25
 		goto _56
 	_56:
 		**(**uint8_t)(__ccgo_up(v4 + 1)) = libc.Uint8FromInt32(v16)
 		v31 = v1 * int32(19077) >> int32(8)
 		goto _71
 	_71:
 		v33 = v2 * int32(33050) >> int32(8)
 		goto _73
 	_73:
 		v35 = v31 + v33 - int32(17685)
 		if v35 & ^int32(YUV_MASK2) == 0 {
 			v38 = v35 >> int32(YUV_FIX2)
 		} else {
 			if v35 < 0 {
 				v39 = 0
 			} else {
 				v39 = int32(255)
 			}
 			v38 = v39
 		}
 		v36 = v38
 		goto _76
 	_76:
 		v29 = v36
 		goto _69
 	_69:
 		**(**uint8_t)(__ccgo_up(v4 + 2)) = libc.Uint8FromInt32(v29)
 		y4 = y4 + uintptr(2)
 		u3 = u3 + 1
 		v5 = v5 + 1
 		dst = dst + uintptr(libc.Int32FromInt32(2)*libc.Int32FromInt32(3))
 	}
 	if len1&int32(1) != 0 {
 		v1 = libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(y4)))
 		v2 = libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(u3)))
 		v3 = libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(v5)))
 		v4 = dst
 		v7 = v1 * int32(19077) >> int32(8)
 		goto _86
 	_86:
 		v9 = v3 * int32(26149) >> int32(8)
 		goto _88
 	_88:
 		v11 = v7 + v9 - int32(14234)
 		if v11 & ^int32(YUV_MASK2) == 0 {
 			v14 = v11 >> int32(YUV_FIX2)
 		} else {
 			if v11 < 0 {
 				v15 = 0
 			} else {
 				v15 = int32(255)
 			}
 			v14 = v15
 		}
 		v12 = v14
 		goto _91
 	_91:
 		v51 = v12
 		goto _84
 	_84:
 		**(**uint8_t)(__ccgo_up(v4)) = libc.Uint8FromInt32(v51)
 		v18 = v1 * int32(19077) >> int32(8)
 		goto _97
 	_97:
 		v20 = v2 * int32(6419) >> int32(8)
 		goto _99
 	_99:
 		v22 = v3 * int32(13320) >> int32(8)
 		goto _101
 	_101:
 		v24 = v18 - v20 - v22 + int32(8708)
 		if v24 & ^int32(YUV_MASK2) == 0 {
 			v27 = v24 >> int32(YUV_FIX2)
 		} else {
 			if v24 < 0 {
 				v28 = 0
 			} else {
 				v28 = int32(255)
 			}
 			v27 = v28
 		}
 		v25 = v27
 		goto _104
 	_104:
 		v16 = v25
 		goto _95
 	_95:
 		**(**uint8_t)(__ccgo_up(v4 + 1)) = libc.Uint8FromInt32(v16)
 		v31 = v1 * int32(19077) >> int32(8)
 		goto _110
 	_110:
 		v33 = v2 * int32(33050) >> int32(8)
 		goto _112
 	_112:
 		v35 = v31 + v33 - int32(17685)
 		if v35 & ^int32(YUV_MASK2) == 0 {
 			v38 = v35 >> int32(YUV_FIX2)
 		} else {
 			if v35 < 0 {
 				v39 = 0
 			} else {
 				v39 = int32(255)
 			}
 			v38 = v39
 		}
 		v36 = v38
 		goto _115
 	_115:
 		v29 = v36
 		goto _108
 	_108:
 		**(**uint8_t)(__ccgo_up(v4 + 2)) = libc.Uint8FromInt32(v29)
 	}
 }
 
 func YuvToBgrRow(tls *libc.TLS, y4 uintptr, u3 uintptr, v5 uintptr, dst uintptr, len1 int32) {
 	var end, v4 uintptr
 	var v1, v11, v12, v14, v15, v16, v18, v2, v20, v22, v24, v25, v27, v28, v29, v3, v31, v33, v35, v36, v38, v39, v51, v7, v9 int32
 	_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = end, v1, v11, v12, v14, v15, v16, v18, v2, v20, v22, v24, v25, v27, v28, v29, v3, v31, v33, v35, v36, v38, v39, v4, v51, v7, v9
 	end = dst + uintptr(len1 & ^libc.Int32FromInt32(1) * int32(3))
 	for dst != end {
 		v1 = libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(y4)))
 		v2 = libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(u3)))
 		v3 = libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(v5)))
 		v4 = dst
 		v7 = v1 * int32(19077) >> int32(8)
 		goto _8
 	_8:
 		v9 = v2 * int32(33050) >> int32(8)
 		goto _10
 	_10:
 		v11 = v7 + v9 - int32(17685)
 		if v11 & ^int32(YUV_MASK2) == 0 {
 			v14 = v11 >> int32(YUV_FIX2)
 		} else {
 			if v11 < 0 {
 				v15 = 0
 			} else {
 				v15 = int32(255)
 			}
 			v14 = v15
 		}
 		v12 = v14
 		goto _13
 	_13:
 		v51 = v12
 		goto _6
 	_6:
 		**(**uint8_t)(__ccgo_up(v4)) = libc.Uint8FromInt32(v51)
 		v18 = v1 * int32(19077) >> int32(8)
 		goto _19
 	_19:
 		v20 = v2 * int32(6419) >> int32(8)
 		goto _21
 	_21:
 		v22 = v3 * int32(13320) >> int32(8)
 		goto _23
 	_23:
 		v24 = v18 - v20 - v22 + int32(8708)
 		if v24 & ^int32(YUV_MASK2) == 0 {
 			v27 = v24 >> int32(YUV_FIX2)
 		} else {
 			if v24 < 0 {
 				v28 = 0
 			} else {
 				v28 = int32(255)
 			}
 			v27 = v28
 		}
 		v25 = v27
 		goto _26
 	_26:
 		v16 = v25
 		goto _17
 	_17:
 		**(**uint8_t)(__ccgo_up(v4 + 1)) = libc.Uint8FromInt32(v16)
 		v31 = v1 * int32(19077) >> int32(8)
 		goto _32
 	_32:
 		v33 = v3 * int32(26149) >> int32(8)
 		goto _34
 	_34:
 		v35 = v31 + v33 - int32(14234)
 		if v35 & ^int32(YUV_MASK2) == 0 {
 			v38 = v35 >> int32(YUV_FIX2)
 		} else {
 			if v35 < 0 {
 				v39 = 0
 			} else {
 				v39 = int32(255)
 			}
 			v38 = v39
 		}
 		v36 = v38
 		goto _37
 	_37:
 		v29 = v36
 		goto _30
 	_30:
 		**(**uint8_t)(__ccgo_up(v4 + 2)) = libc.Uint8FromInt32(v29)
 		v1 = libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(y4 + 1)))
 		v2 = libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(u3)))
 		v3 = libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(v5)))
 		v4 = dst + uintptr(libc.Int32FromInt32(3))
 		v7 = v1 * int32(19077) >> int32(8)
 		goto _47
 	_47:
 		v9 = v2 * int32(33050) >> int32(8)
 		goto _49
 	_49:
 		v11 = v7 + v9 - int32(17685)
 		if v11 & ^int32(YUV_MASK2) == 0 {
 			v14 = v11 >> int32(YUV_FIX2)
 		} else {
 			if v11 < 0 {
 				v15 = 0
 			} else {
 				v15 = int32(255)
 			}
 			v14 = v15
 		}
 		v12 = v14
 		goto _52
 	_52:
 		v51 = v12
 		goto _45
 	_45:
 		**(**uint8_t)(__ccgo_up(v4)) = libc.Uint8FromInt32(v51)
 		v18 = v1 * int32(19077) >> int32(8)
 		goto _58
 	_58:
 		v20 = v2 * int32(6419) >> int32(8)
 		goto _60
 	_60:
 		v22 = v3 * int32(13320) >> int32(8)
 		goto _62
 	_62:
 		v24 = v18 - v20 - v22 + int32(8708)
 		if v24 & ^int32(YUV_MASK2) == 0 {
 			v27 = v24 >> int32(YUV_FIX2)
 		} else {
 			if v24 < 0 {
 				v28 = 0
 			} else {
 				v28 = int32(255)
 			}
 			v27 = v28
 		}
 		v25 = v27
 		goto _65
 	_65:
 		v16 = v25
 		goto _56
 	_56:
 		**(**uint8_t)(__ccgo_up(v4 + 1)) = libc.Uint8FromInt32(v16)
 		v31 = v1 * int32(19077) >> int32(8)
 		goto _71
 	_71:
 		v33 = v3 * int32(26149) >> int32(8)
 		goto _73
 	_73:
 		v35 = v31 + v33 - int32(14234)
 		if v35 & ^int32(YUV_MASK2) == 0 {
 			v38 = v35 >> int32(YUV_FIX2)
 		} else {
 			if v35 < 0 {
 				v39 = 0
 			} else {
 				v39 = int32(255)
 			}
 			v38 = v39
 		}
 		v36 = v38
 		goto _76
 	_76:
 		v29 = v36
 		goto _69
 	_69:
 		**(**uint8_t)(__ccgo_up(v4 + 2)) = libc.Uint8FromInt32(v29)
 		y4 = y4 + uintptr(2)
 		u3 = u3 + 1
 		v5 = v5 + 1
 		dst = dst + uintptr(libc.Int32FromInt32(2)*libc.Int32FromInt32(3))
 	}
 	if len1&int32(1) != 0 {
 		v1 = libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(y4)))
 		v2 = libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(u3)))
 		v3 = libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(v5)))
 		v4 = dst
 		v7 = v1 * int32(19077) >> int32(8)
 		goto _86
 	_86:
 		v9 = v2 * int32(33050) >> int32(8)
 		goto _88
 	_88:
 		v11 = v7 + v9 - int32(17685)
 		if v11 & ^int32(YUV_MASK2) == 0 {
 			v14 = v11 >> int32(YUV_FIX2)
 		} else {
 			if v11 < 0 {
 				v15 = 0
 			} else {
 				v15 = int32(255)
 			}
 			v14 = v15
 		}
 		v12 = v14
 		goto _91
 	_91:
 		v51 = v12
 		goto _84
 	_84:
 		**(**uint8_t)(__ccgo_up(v4)) = libc.Uint8FromInt32(v51)
 		v18 = v1 * int32(19077) >> int32(8)
 		goto _97
 	_97:
 		v20 = v2 * int32(6419) >> int32(8)
 		goto _99
 	_99:
 		v22 = v3 * int32(13320) >> int32(8)
 		goto _101
 	_101:
 		v24 = v18 - v20 - v22 + int32(8708)
 		if v24 & ^int32(YUV_MASK2) == 0 {
 			v27 = v24 >> int32(YUV_FIX2)
 		} else {
 			if v24 < 0 {
 				v28 = 0
 			} else {
 				v28 = int32(255)
 			}
 			v27 = v28
 		}
 		v25 = v27
 		goto _104
 	_104:
 		v16 = v25
 		goto _95
 	_95:
 		**(**uint8_t)(__ccgo_up(v4 + 1)) = libc.Uint8FromInt32(v16)
 		v31 = v1 * int32(19077) >> int32(8)
 		goto _110
 	_110:
 		v33 = v3 * int32(26149) >> int32(8)
 		goto _112
 	_112:
 		v35 = v31 + v33 - int32(14234)
 		if v35 & ^int32(YUV_MASK2) == 0 {
 			v38 = v35 >> int32(YUV_FIX2)
 		} else {
 			if v35 < 0 {
 				v39 = 0
 			} else {
 				v39 = int32(255)
 			}
 			v38 = v39
 		}
 		v36 = v38
 		goto _115
 	_115:
 		v29 = v36
 		goto _108
 	_108:
 		**(**uint8_t)(__ccgo_up(v4 + 2)) = libc.Uint8FromInt32(v29)
 	}
 }
 
 func YuvToRgbaRow(tls *libc.TLS, y5 uintptr, u4 uintptr, v6 uintptr, dst uintptr, len1 int32) {
 	var end, v1, v5 uintptr
 	var v10, v12, v13, v15, v16, v17, v19, v2, v21, v23, v25, v26, v28, v29, v3, v30, v32, v34, v36, v37, v39, v4, v40, v61, v8 int32
 	_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = end, v1, v10, v12, v13, v15, v16, v17, v19, v2, v21, v23, v25, v26, v28, v29, v3, v30, v32, v34, v36, v37, v39, v4, v40, v5, v61, v8
 	end = dst + uintptr(len1 & ^libc.Int32FromInt32(1) * int32(4))
 	for dst != end {
 		v1 = dst
 		v2 = libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(y5)))
 		v3 = libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(u4)))
 		v4 = libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(v6)))
 		v5 = v1
 		v8 = v2 * int32(19077) >> int32(8)
 		goto _9
 	_9:
 		v10 = v4 * int32(26149) >> int32(8)
 		goto _11
 	_11:
 		v12 = v8 + v10 - int32(14234)
 		if v12 & ^int32(YUV_MASK2) == 0 {
 			v15 = v12 >> int32(YUV_FIX2)
 		} else {
 			if v12 < 0 {
 				v16 = 0
 			} else {
 				v16 = int32(255)
 			}
 			v15 = v16
 		}
 		v13 = v15
 		goto _14
 	_14:
 		v61 = v13
 		goto _7
 	_7:
 		**(**uint8_t)(__ccgo_up(v5)) = libc.Uint8FromInt32(v61)
 		v19 = v2 * int32(19077) >> int32(8)
 		goto _20
 	_20:
 		v21 = v3 * int32(6419) >> int32(8)
 		goto _22
 	_22:
 		v23 = v4 * int32(13320) >> int32(8)
 		goto _24
 	_24:
 		v25 = v19 - v21 - v23 + int32(8708)
 		if v25 & ^int32(YUV_MASK2) == 0 {
 			v28 = v25 >> int32(YUV_FIX2)
 		} else {
 			if v25 < 0 {
 				v29 = 0
 			} else {
 				v29 = int32(255)
 			}
 			v28 = v29
 		}
 		v26 = v28
 		goto _27
 	_27:
 		v17 = v26
 		goto _18
 	_18:
 		**(**uint8_t)(__ccgo_up(v5 + 1)) = libc.Uint8FromInt32(v17)
 		v32 = v2 * int32(19077) >> int32(8)
 		goto _33
 	_33:
 		v34 = v3 * int32(33050) >> int32(8)
 		goto _35
 	_35:
 		v36 = v32 + v34 - int32(17685)
 		if v36 & ^int32(YUV_MASK2) == 0 {
 			v39 = v36 >> int32(YUV_FIX2)
 		} else {
 			if v36 < 0 {
 				v40 = 0
 			} else {
 				v40 = int32(255)
 			}
 			v39 = v40
 		}
 		v37 = v39
 		goto _38
 	_38:
 		v30 = v37
 		goto _31
 	_31:
 		**(**uint8_t)(__ccgo_up(v5 + 2)) = libc.Uint8FromInt32(v30)
 		**(**uint8_t)(__ccgo_up(v1 + 3)) = uint8(0xff)
 		v1 = dst + uintptr(libc.Int32FromInt32(4))
 		v2 = libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(y5 + 1)))
 		v3 = libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(u4)))
 		v4 = libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(v6)))
 		v5 = v1
 		v8 = v2 * int32(19077) >> int32(8)
 		goto _49
 	_49:
 		v10 = v4 * int32(26149) >> int32(8)
 		goto _51
 	_51:
 		v12 = v8 + v10 - int32(14234)
 		if v12 & ^int32(YUV_MASK2) == 0 {
 			v15 = v12 >> int32(YUV_FIX2)
 		} else {
 			if v12 < 0 {
 				v16 = 0
 			} else {
 				v16 = int32(255)
 			}
 			v15 = v16
 		}
 		v13 = v15
 		goto _54
 	_54:
 		v61 = v13
 		goto _47
 	_47:
 		**(**uint8_t)(__ccgo_up(v5)) = libc.Uint8FromInt32(v61)
 		v19 = v2 * int32(19077) >> int32(8)
 		goto _60
 	_60:
 		v21 = v3 * int32(6419) >> int32(8)
 		goto _62
 	_62:
 		v23 = v4 * int32(13320) >> int32(8)
 		goto _64
 	_64:
 		v25 = v19 - v21 - v23 + int32(8708)
 		if v25 & ^int32(YUV_MASK2) == 0 {
 			v28 = v25 >> int32(YUV_FIX2)
 		} else {
 			if v25 < 0 {
 				v29 = 0
 			} else {
 				v29 = int32(255)
 			}
 			v28 = v29
 		}
 		v26 = v28
 		goto _67
 	_67:
 		v17 = v26
 		goto _58
 	_58:
 		**(**uint8_t)(__ccgo_up(v5 + 1)) = libc.Uint8FromInt32(v17)
 		v32 = v2 * int32(19077) >> int32(8)
 		goto _73
 	_73:
 		v34 = v3 * int32(33050) >> int32(8)
 		goto _75
 	_75:
 		v36 = v32 + v34 - int32(17685)
 		if v36 & ^int32(YUV_MASK2) == 0 {
 			v39 = v36 >> int32(YUV_FIX2)
 		} else {
 			if v36 < 0 {
 				v40 = 0
 			} else {
 				v40 = int32(255)
 			}
 			v39 = v40
 		}
 		v37 = v39
 		goto _78
 	_78:
 		v30 = v37
 		goto _71
 	_71:
 		**(**uint8_t)(__ccgo_up(v5 + 2)) = libc.Uint8FromInt32(v30)
 		**(**uint8_t)(__ccgo_up(v1 + 3)) = uint8(0xff)
 		y5 = y5 + uintptr(2)
 		u4 = u4 + 1
 		v6 = v6 + 1
 		dst = dst + uintptr(libc.Int32FromInt32(2)*libc.Int32FromInt32(4))
 	}
 	if len1&int32(1) != 0 {
 		v1 = dst
 		v2 = libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(y5)))
 		v3 = libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(u4)))
 		v4 = libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(v6)))
 		v5 = v1
 		v8 = v2 * int32(19077) >> int32(8)
 		goto _89
 	_89:
 		v10 = v4 * int32(26149) >> int32(8)
 		goto _91
 	_91:
 		v12 = v8 + v10 - int32(14234)
 		if v12 & ^int32(YUV_MASK2) == 0 {
 			v15 = v12 >> int32(YUV_FIX2)
 		} else {
 			if v12 < 0 {
 				v16 = 0
 			} else {
 				v16 = int32(255)
 			}
 			v15 = v16
 		}
 		v13 = v15
 		goto _94
 	_94:
 		v61 = v13
 		goto _87
 	_87:
 		**(**uint8_t)(__ccgo_up(v5)) = libc.Uint8FromInt32(v61)
 		v19 = v2 * int32(19077) >> int32(8)
 		goto _100
 	_100:
 		v21 = v3 * int32(6419) >> int32(8)
 		goto _102
 	_102:
 		v23 = v4 * int32(13320) >> int32(8)
 		goto _104
 	_104:
 		v25 = v19 - v21 - v23 + int32(8708)
 		if v25 & ^int32(YUV_MASK2) == 0 {
 			v28 = v25 >> int32(YUV_FIX2)
 		} else {
 			if v25 < 0 {
 				v29 = 0
 			} else {
 				v29 = int32(255)
 			}
 			v28 = v29
 		}
 		v26 = v28
 		goto _107
 	_107:
 		v17 = v26
 		goto _98
 	_98:
 		**(**uint8_t)(__ccgo_up(v5 + 1)) = libc.Uint8FromInt32(v17)
 		v32 = v2 * int32(19077) >> int32(8)
 		goto _113
 	_113:
 		v34 = v3 * int32(33050) >> int32(8)
 		goto _115
 	_115:
 		v36 = v32 + v34 - int32(17685)
 		if v36 & ^int32(YUV_MASK2) == 0 {
 			v39 = v36 >> int32(YUV_FIX2)
 		} else {
 			if v36 < 0 {
 				v40 = 0
 			} else {
 				v40 = int32(255)
 			}
 			v39 = v40
 		}
 		v37 = v39
 		goto _118
 	_118:
 		v30 = v37
 		goto _111
 	_111:
 		**(**uint8_t)(__ccgo_up(v5 + 2)) = libc.Uint8FromInt32(v30)
 		**(**uint8_t)(__ccgo_up(v1 + 3)) = uint8(0xff)
 	}
 }
 
 func YuvToBgraRow(tls *libc.TLS, y5 uintptr, u4 uintptr, v6 uintptr, dst uintptr, len1 int32) {
 	var end, v1, v5 uintptr
 	var v10, v12, v13, v15, v16, v17, v19, v2, v21, v23, v25, v26, v28, v29, v3, v30, v32, v34, v36, v37, v39, v4, v40, v61, v8 int32
 	_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = end, v1, v10, v12, v13, v15, v16, v17, v19, v2, v21, v23, v25, v26, v28, v29, v3, v30, v32, v34, v36, v37, v39, v4, v40, v5, v61, v8
 	end = dst + uintptr(len1 & ^libc.Int32FromInt32(1) * int32(4))
 	for dst != end {
 		v1 = dst
 		v2 = libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(y5)))
 		v3 = libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(u4)))
 		v4 = libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(v6)))
 		v5 = v1
 		v8 = v2 * int32(19077) >> int32(8)
 		goto _9
 	_9:
 		v10 = v3 * int32(33050) >> int32(8)
 		goto _11
 	_11:
 		v12 = v8 + v10 - int32(17685)
 		if v12 & ^int32(YUV_MASK2) == 0 {
 			v15 = v12 >> int32(YUV_FIX2)
 		} else {
 			if v12 < 0 {
 				v16 = 0
 			} else {
 				v16 = int32(255)
 			}
 			v15 = v16
 		}
 		v13 = v15
 		goto _14
 	_14:
 		v61 = v13
 		goto _7
 	_7:
 		**(**uint8_t)(__ccgo_up(v5)) = libc.Uint8FromInt32(v61)
 		v19 = v2 * int32(19077) >> int32(8)
 		goto _20
 	_20:
 		v21 = v3 * int32(6419) >> int32(8)
 		goto _22
 	_22:
 		v23 = v4 * int32(13320) >> int32(8)
 		goto _24
 	_24:
 		v25 = v19 - v21 - v23 + int32(8708)
 		if v25 & ^int32(YUV_MASK2) == 0 {
 			v28 = v25 >> int32(YUV_FIX2)
 		} else {
 			if v25 < 0 {
 				v29 = 0
 			} else {
 				v29 = int32(255)
 			}
 			v28 = v29
 		}
 		v26 = v28
 		goto _27
 	_27:
 		v17 = v26
 		goto _18
 	_18:
 		**(**uint8_t)(__ccgo_up(v5 + 1)) = libc.Uint8FromInt32(v17)
 		v32 = v2 * int32(19077) >> int32(8)
 		goto _33
 	_33:
 		v34 = v4 * int32(26149) >> int32(8)
 		goto _35
 	_35:
 		v36 = v32 + v34 - int32(14234)
 		if v36 & ^int32(YUV_MASK2) == 0 {
 			v39 = v36 >> int32(YUV_FIX2)
 		} else {
 			if v36 < 0 {
 				v40 = 0
 			} else {
 				v40 = int32(255)
 			}
 			v39 = v40
 		}
 		v37 = v39
 		goto _38
 	_38:
 		v30 = v37
 		goto _31
 	_31:
 		**(**uint8_t)(__ccgo_up(v5 + 2)) = libc.Uint8FromInt32(v30)
 		**(**uint8_t)(__ccgo_up(v1 + 3)) = uint8(0xff)
 		v1 = dst + uintptr(libc.Int32FromInt32(4))
 		v2 = libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(y5 + 1)))
 		v3 = libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(u4)))
 		v4 = libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(v6)))
 		v5 = v1
 		v8 = v2 * int32(19077) >> int32(8)
 		goto _49
 	_49:
 		v10 = v3 * int32(33050) >> int32(8)
 		goto _51
 	_51:
 		v12 = v8 + v10 - int32(17685)
 		if v12 & ^int32(YUV_MASK2) == 0 {
 			v15 = v12 >> int32(YUV_FIX2)
 		} else {
 			if v12 < 0 {
 				v16 = 0
 			} else {
 				v16 = int32(255)
 			}
 			v15 = v16
 		}
 		v13 = v15
 		goto _54
 	_54:
 		v61 = v13
 		goto _47
 	_47:
 		**(**uint8_t)(__ccgo_up(v5)) = libc.Uint8FromInt32(v61)
 		v19 = v2 * int32(19077) >> int32(8)
 		goto _60
 	_60:
 		v21 = v3 * int32(6419) >> int32(8)
 		goto _62
 	_62:
 		v23 = v4 * int32(13320) >> int32(8)
 		goto _64
 	_64:
 		v25 = v19 - v21 - v23 + int32(8708)
 		if v25 & ^int32(YUV_MASK2) == 0 {
 			v28 = v25 >> int32(YUV_FIX2)
 		} else {
 			if v25 < 0 {
 				v29 = 0
 			} else {
 				v29 = int32(255)
 			}
 			v28 = v29
 		}
 		v26 = v28
 		goto _67
 	_67:
 		v17 = v26
 		goto _58
 	_58:
 		**(**uint8_t)(__ccgo_up(v5 + 1)) = libc.Uint8FromInt32(v17)
 		v32 = v2 * int32(19077) >> int32(8)
 		goto _73
 	_73:
 		v34 = v4 * int32(26149) >> int32(8)
 		goto _75
 	_75:
 		v36 = v32 + v34 - int32(14234)
 		if v36 & ^int32(YUV_MASK2) == 0 {
 			v39 = v36 >> int32(YUV_FIX2)
 		} else {
 			if v36 < 0 {
 				v40 = 0
 			} else {
 				v40 = int32(255)
 			}
 			v39 = v40
 		}
 		v37 = v39
 		goto _78
 	_78:
 		v30 = v37
 		goto _71
 	_71:
 		**(**uint8_t)(__ccgo_up(v5 + 2)) = libc.Uint8FromInt32(v30)
 		**(**uint8_t)(__ccgo_up(v1 + 3)) = uint8(0xff)
 		y5 = y5 + uintptr(2)
 		u4 = u4 + 1
 		v6 = v6 + 1
 		dst = dst + uintptr(libc.Int32FromInt32(2)*libc.Int32FromInt32(4))
 	}
 	if len1&int32(1) != 0 {
 		v1 = dst
 		v2 = libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(y5)))
 		v3 = libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(u4)))
 		v4 = libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(v6)))
 		v5 = v1
 		v8 = v2 * int32(19077) >> int32(8)
 		goto _89
 	_89:
 		v10 = v3 * int32(33050) >> int32(8)
 		goto _91
 	_91:
 		v12 = v8 + v10 - int32(17685)
 		if v12 & ^int32(YUV_MASK2) == 0 {
 			v15 = v12 >> int32(YUV_FIX2)
 		} else {
 			if v12 < 0 {
 				v16 = 0
 			} else {
 				v16 = int32(255)
 			}
 			v15 = v16
 		}
 		v13 = v15
 		goto _94
 	_94:
 		v61 = v13
 		goto _87
 	_87:
 		**(**uint8_t)(__ccgo_up(v5)) = libc.Uint8FromInt32(v61)
 		v19 = v2 * int32(19077) >> int32(8)
 		goto _100
 	_100:
 		v21 = v3 * int32(6419) >> int32(8)
 		goto _102
 	_102:
 		v23 = v4 * int32(13320) >> int32(8)
 		goto _104
 	_104:
 		v25 = v19 - v21 - v23 + int32(8708)
 		if v25 & ^int32(YUV_MASK2) == 0 {
 			v28 = v25 >> int32(YUV_FIX2)
 		} else {
 			if v25 < 0 {
 				v29 = 0
 			} else {
 				v29 = int32(255)
 			}
 			v28 = v29
 		}
 		v26 = v28
 		goto _107
 	_107:
 		v17 = v26
 		goto _98
 	_98:
 		**(**uint8_t)(__ccgo_up(v5 + 1)) = libc.Uint8FromInt32(v17)
 		v32 = v2 * int32(19077) >> int32(8)
 		goto _113
 	_113:
 		v34 = v4 * int32(26149) >> int32(8)
 		goto _115
 	_115:
 		v36 = v32 + v34 - int32(14234)
 		if v36 & ^int32(YUV_MASK2) == 0 {
 			v39 = v36 >> int32(YUV_FIX2)
 		} else {
 			if v36 < 0 {
 				v40 = 0
 			} else {
 				v40 = int32(255)
 			}
 			v39 = v40
 		}
 		v37 = v39
 		goto _118
 	_118:
 		v30 = v37
 		goto _111
 	_111:
 		**(**uint8_t)(__ccgo_up(v5 + 2)) = libc.Uint8FromInt32(v30)
 		**(**uint8_t)(__ccgo_up(v1 + 3)) = uint8(0xff)
 	}
 }
 
 func YuvToArgbRow(tls *libc.TLS, y5 uintptr, u4 uintptr, v6 uintptr, dst uintptr, len1 int32) {
 	var end, v1, v5 uintptr
 	var v10, v12, v13, v15, v16, v17, v19, v2, v21, v23, v25, v26, v28, v29, v3, v30, v32, v34, v36, v37, v39, v4, v40, v61, v8 int32
 	_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = end, v1, v10, v12, v13, v15, v16, v17, v19, v2, v21, v23, v25, v26, v28, v29, v3, v30, v32, v34, v36, v37, v39, v4, v40, v5, v61, v8
 	end = dst + uintptr(len1 & ^libc.Int32FromInt32(1) * int32(4))
 	for dst != end {
 		v1 = dst
 		**(**uint8_t)(__ccgo_up(v1)) = uint8(0xff)
 		v2 = libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(y5)))
 		v3 = libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(u4)))
 		v4 = libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(v6)))
 		v5 = v1 + uintptr(1)
 		v8 = v2 * int32(19077) >> int32(8)
 		goto _9
 	_9:
 		v10 = v4 * int32(26149) >> int32(8)
 		goto _11
 	_11:
 		v12 = v8 + v10 - int32(14234)
 		if v12 & ^int32(YUV_MASK2) == 0 {
 			v15 = v12 >> int32(YUV_FIX2)
 		} else {
 			if v12 < 0 {
 				v16 = 0
 			} else {
 				v16 = int32(255)
 			}
 			v15 = v16
 		}
 		v13 = v15
 		goto _14
 	_14:
 		v61 = v13
 		goto _7
 	_7:
 		**(**uint8_t)(__ccgo_up(v5)) = libc.Uint8FromInt32(v61)
 		v19 = v2 * int32(19077) >> int32(8)
 		goto _20
 	_20:
 		v21 = v3 * int32(6419) >> int32(8)
 		goto _22
 	_22:
 		v23 = v4 * int32(13320) >> int32(8)
 		goto _24
 	_24:
 		v25 = v19 - v21 - v23 + int32(8708)
 		if v25 & ^int32(YUV_MASK2) == 0 {
 			v28 = v25 >> int32(YUV_FIX2)
 		} else {
 			if v25 < 0 {
 				v29 = 0
 			} else {
 				v29 = int32(255)
 			}
 			v28 = v29
 		}
 		v26 = v28
 		goto _27
 	_27:
 		v17 = v26
 		goto _18
 	_18:
 		**(**uint8_t)(__ccgo_up(v5 + 1)) = libc.Uint8FromInt32(v17)
 		v32 = v2 * int32(19077) >> int32(8)
 		goto _33
 	_33:
 		v34 = v3 * int32(33050) >> int32(8)
 		goto _35
 	_35:
 		v36 = v32 + v34 - int32(17685)
 		if v36 & ^int32(YUV_MASK2) == 0 {
 			v39 = v36 >> int32(YUV_FIX2)
 		} else {
 			if v36 < 0 {
 				v40 = 0
 			} else {
 				v40 = int32(255)
 			}
 			v39 = v40
 		}
 		v37 = v39
 		goto _38
 	_38:
 		v30 = v37
 		goto _31
 	_31:
 		**(**uint8_t)(__ccgo_up(v5 + 2)) = libc.Uint8FromInt32(v30)
 		v1 = dst + uintptr(libc.Int32FromInt32(4))
 		**(**uint8_t)(__ccgo_up(v1)) = uint8(0xff)
 		v2 = libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(y5 + 1)))
 		v3 = libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(u4)))
 		v4 = libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(v6)))
 		v5 = v1 + uintptr(1)
 		v8 = v2 * int32(19077) >> int32(8)
 		goto _49
 	_49:
 		v10 = v4 * int32(26149) >> int32(8)
 		goto _51
 	_51:
 		v12 = v8 + v10 - int32(14234)
 		if v12 & ^int32(YUV_MASK2) == 0 {
 			v15 = v12 >> int32(YUV_FIX2)
 		} else {
 			if v12 < 0 {
 				v16 = 0
 			} else {
 				v16 = int32(255)
 			}
 			v15 = v16
 		}
 		v13 = v15
 		goto _54
 	_54:
 		v61 = v13
 		goto _47
 	_47:
 		**(**uint8_t)(__ccgo_up(v5)) = libc.Uint8FromInt32(v61)
 		v19 = v2 * int32(19077) >> int32(8)
 		goto _60
 	_60:
 		v21 = v3 * int32(6419) >> int32(8)
 		goto _62
 	_62:
 		v23 = v4 * int32(13320) >> int32(8)
 		goto _64
 	_64:
 		v25 = v19 - v21 - v23 + int32(8708)
 		if v25 & ^int32(YUV_MASK2) == 0 {
 			v28 = v25 >> int32(YUV_FIX2)
 		} else {
 			if v25 < 0 {
 				v29 = 0
 			} else {
 				v29 = int32(255)
 			}
 			v28 = v29
 		}
 		v26 = v28
 		goto _67
 	_67:
 		v17 = v26
 		goto _58
 	_58:
 		**(**uint8_t)(__ccgo_up(v5 + 1)) = libc.Uint8FromInt32(v17)
 		v32 = v2 * int32(19077) >> int32(8)
 		goto _73
 	_73:
 		v34 = v3 * int32(33050) >> int32(8)
 		goto _75
 	_75:
 		v36 = v32 + v34 - int32(17685)
 		if v36 & ^int32(YUV_MASK2) == 0 {
 			v39 = v36 >> int32(YUV_FIX2)
 		} else {
 			if v36 < 0 {
 				v40 = 0
 			} else {
 				v40 = int32(255)
 			}
 			v39 = v40
 		}
 		v37 = v39
 		goto _78
 	_78:
 		v30 = v37
 		goto _71
 	_71:
 		**(**uint8_t)(__ccgo_up(v5 + 2)) = libc.Uint8FromInt32(v30)
 		y5 = y5 + uintptr(2)
 		u4 = u4 + 1
 		v6 = v6 + 1
 		dst = dst + uintptr(libc.Int32FromInt32(2)*libc.Int32FromInt32(4))
 	}
 	if len1&int32(1) != 0 {
 		v1 = dst
 		**(**uint8_t)(__ccgo_up(v1)) = uint8(0xff)
 		v2 = libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(y5)))
 		v3 = libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(u4)))
 		v4 = libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(v6)))
 		v5 = v1 + uintptr(1)
 		v8 = v2 * int32(19077) >> int32(8)
 		goto _89
 	_89:
 		v10 = v4 * int32(26149) >> int32(8)
 		goto _91
 	_91:
 		v12 = v8 + v10 - int32(14234)
 		if v12 & ^int32(YUV_MASK2) == 0 {
 			v15 = v12 >> int32(YUV_FIX2)
 		} else {
 			if v12 < 0 {
 				v16 = 0
 			} else {
 				v16 = int32(255)
 			}
 			v15 = v16
 		}
 		v13 = v15
 		goto _94
 	_94:
 		v61 = v13
 		goto _87
 	_87:
 		**(**uint8_t)(__ccgo_up(v5)) = libc.Uint8FromInt32(v61)
 		v19 = v2 * int32(19077) >> int32(8)
 		goto _100
 	_100:
 		v21 = v3 * int32(6419) >> int32(8)
 		goto _102
 	_102:
 		v23 = v4 * int32(13320) >> int32(8)
 		goto _104
 	_104:
 		v25 = v19 - v21 - v23 + int32(8708)
 		if v25 & ^int32(YUV_MASK2) == 0 {
 			v28 = v25 >> int32(YUV_FIX2)
 		} else {
 			if v25 < 0 {
 				v29 = 0
 			} else {
 				v29 = int32(255)
 			}
 			v28 = v29
 		}
 		v26 = v28
 		goto _107
 	_107:
 		v17 = v26
 		goto _98
 	_98:
 		**(**uint8_t)(__ccgo_up(v5 + 1)) = libc.Uint8FromInt32(v17)
 		v32 = v2 * int32(19077) >> int32(8)
 		goto _113
 	_113:
 		v34 = v3 * int32(33050) >> int32(8)
 		goto _115
 	_115:
 		v36 = v32 + v34 - int32(17685)
 		if v36 & ^int32(YUV_MASK2) == 0 {
 			v39 = v36 >> int32(YUV_FIX2)
 		} else {
 			if v36 < 0 {
 				v40 = 0
 			} else {
 				v40 = int32(255)
 			}
 			v39 = v40
 		}
 		v37 = v39
 		goto _118
 	_118:
 		v30 = v37
 		goto _111
 	_111:
 		**(**uint8_t)(__ccgo_up(v5 + 2)) = libc.Uint8FromInt32(v30)
 	}
 }
 
 func YuvToRgba4444Row(tls *libc.TLS, y4 uintptr, u3 uintptr, v5 uintptr, dst uintptr, len1 int32) {
 	var b, ba, g, r, rg, v1, v11, v12, v14, v15, v16, v18, v2, v20, v22, v24, v25, v27, v28, v29, v3, v31, v33, v35, v36, v38, v39, v51, v7, v9 int32
 	var end, v4 uintptr
 	_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = b, ba, end, g, r, rg, v1, v11, v12, v14, v15, v16, v18, v2, v20, v22, v24, v25, v27, v28, v29, v3, v31, v33, v35, v36, v38, v39, v4, v51, v7, v9
 	end = dst + uintptr(len1 & ^libc.Int32FromInt32(1) * int32(2))
 	for dst != end {
 		v1 = libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(y4)))
 		v2 = libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(u3)))
 		v3 = libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(v5)))
 		v4 = dst
 		v7 = v1 * int32(19077) >> int32(8)
 		goto _8
 	_8:
 		v9 = v3 * int32(26149) >> int32(8)
 		goto _10
 	_10:
 		v11 = v7 + v9 - int32(14234)
 		if v11 & ^int32(YUV_MASK2) == 0 {
 			v14 = v11 >> int32(YUV_FIX2)
 		} else {
 			if v11 < 0 {
 				v15 = 0
 			} else {
 				v15 = int32(255)
 			}
 			v14 = v15
 		}
 		v12 = v14
 		goto _13
 	_13:
 		v51 = v12
 		goto _6
 	_6:
 		r = v51
 		v18 = v1 * int32(19077) >> int32(8)
 		goto _19
 	_19:
 		v20 = v2 * int32(6419) >> int32(8)
 		goto _21
 	_21:
 		v22 = v3 * int32(13320) >> int32(8)
 		goto _23
 	_23:
 		v24 = v18 - v20 - v22 + int32(8708)
 		if v24 & ^int32(YUV_MASK2) == 0 {
 			v27 = v24 >> int32(YUV_FIX2)
 		} else {
 			if v24 < 0 {
 				v28 = 0
 			} else {
 				v28 = int32(255)
 			}
 			v27 = v28
 		}
 		v25 = v27
 		goto _26
 	_26:
 		v16 = v25
 		goto _17
 	_17:
 		g = v16
 		v31 = v1 * int32(19077) >> int32(8)
 		goto _32
 	_32:
 		v33 = v2 * int32(33050) >> int32(8)
 		goto _34
 	_34:
 		v35 = v31 + v33 - int32(17685)
 		if v35 & ^int32(YUV_MASK2) == 0 {
 			v38 = v35 >> int32(YUV_FIX2)
 		} else {
 			if v35 < 0 {
 				v39 = 0
 			} else {
 				v39 = int32(255)
 			}
 			v38 = v39
 		}
 		v36 = v38
 		goto _37
 	_37:
 		v29 = v36
 		goto _30
 	_30:
 		b = v29
 		rg = r&int32(0xf0) | g>>libc.Int32FromInt32(4)
 		ba = b&int32(0xf0) | int32(0x0f)
 		**(**uint8_t)(__ccgo_up(v4)) = libc.Uint8FromInt32(rg)
 		**(**uint8_t)(__ccgo_up(v4 + 1)) = libc.Uint8FromInt32(ba)
 		v1 = libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(y4 + 1)))
 		v2 = libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(u3)))
 		v3 = libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(v5)))
 		v4 = dst + uintptr(libc.Int32FromInt32(2))
 		v7 = v1 * int32(19077) >> int32(8)
 		goto _47
 	_47:
 		v9 = v3 * int32(26149) >> int32(8)
 		goto _49
 	_49:
 		v11 = v7 + v9 - int32(14234)
 		if v11 & ^int32(YUV_MASK2) == 0 {
 			v14 = v11 >> int32(YUV_FIX2)
 		} else {
 			if v11 < 0 {
 				v15 = 0
 			} else {
 				v15 = int32(255)
 			}
 			v14 = v15
 		}
 		v12 = v14
 		goto _52
 	_52:
 		v51 = v12
 		goto _45
 	_45:
 		r = v51
 		v18 = v1 * int32(19077) >> int32(8)
 		goto _58
 	_58:
 		v20 = v2 * int32(6419) >> int32(8)
 		goto _60
 	_60:
 		v22 = v3 * int32(13320) >> int32(8)
 		goto _62
 	_62:
 		v24 = v18 - v20 - v22 + int32(8708)
 		if v24 & ^int32(YUV_MASK2) == 0 {
 			v27 = v24 >> int32(YUV_FIX2)
 		} else {
 			if v24 < 0 {
 				v28 = 0
 			} else {
 				v28 = int32(255)
 			}
 			v27 = v28
 		}
 		v25 = v27
 		goto _65
 	_65:
 		v16 = v25
 		goto _56
 	_56:
 		g = v16
 		v31 = v1 * int32(19077) >> int32(8)
 		goto _71
 	_71:
 		v33 = v2 * int32(33050) >> int32(8)
 		goto _73
 	_73:
 		v35 = v31 + v33 - int32(17685)
 		if v35 & ^int32(YUV_MASK2) == 0 {
 			v38 = v35 >> int32(YUV_FIX2)
 		} else {
 			if v35 < 0 {
 				v39 = 0
 			} else {
 				v39 = int32(255)
 			}
 			v38 = v39
 		}
 		v36 = v38
 		goto _76
 	_76:
 		v29 = v36
 		goto _69
 	_69:
 		b = v29
 		rg = r&int32(0xf0) | g>>libc.Int32FromInt32(4)
 		ba = b&int32(0xf0) | int32(0x0f)
 		**(**uint8_t)(__ccgo_up(v4)) = libc.Uint8FromInt32(rg)
 		**(**uint8_t)(__ccgo_up(v4 + 1)) = libc.Uint8FromInt32(ba)
 		y4 = y4 + uintptr(2)
 		u3 = u3 + 1
 		v5 = v5 + 1
 		dst = dst + uintptr(libc.Int32FromInt32(2)*libc.Int32FromInt32(2))
 	}
 	if len1&int32(1) != 0 {
 		v1 = libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(y4)))
 		v2 = libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(u3)))
 		v3 = libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(v5)))
 		v4 = dst
 		v7 = v1 * int32(19077) >> int32(8)
 		goto _86
 	_86:
 		v9 = v3 * int32(26149) >> int32(8)
 		goto _88
 	_88:
 		v11 = v7 + v9 - int32(14234)
 		if v11 & ^int32(YUV_MASK2) == 0 {
 			v14 = v11 >> int32(YUV_FIX2)
 		} else {
 			if v11 < 0 {
 				v15 = 0
 			} else {
 				v15 = int32(255)
 			}
 			v14 = v15
 		}
 		v12 = v14
 		goto _91
 	_91:
 		v51 = v12
 		goto _84
 	_84:
 		r = v51
 		v18 = v1 * int32(19077) >> int32(8)
 		goto _97
 	_97:
 		v20 = v2 * int32(6419) >> int32(8)
 		goto _99
 	_99:
 		v22 = v3 * int32(13320) >> int32(8)
 		goto _101
 	_101:
 		v24 = v18 - v20 - v22 + int32(8708)
 		if v24 & ^int32(YUV_MASK2) == 0 {
 			v27 = v24 >> int32(YUV_FIX2)
 		} else {
 			if v24 < 0 {
 				v28 = 0
 			} else {
 				v28 = int32(255)
 			}
 			v27 = v28
 		}
 		v25 = v27
 		goto _104
 	_104:
 		v16 = v25
 		goto _95
 	_95:
 		g = v16
 		v31 = v1 * int32(19077) >> int32(8)
 		goto _110
 	_110:
 		v33 = v2 * int32(33050) >> int32(8)
 		goto _112
 	_112:
 		v35 = v31 + v33 - int32(17685)
 		if v35 & ^int32(YUV_MASK2) == 0 {
 			v38 = v35 >> int32(YUV_FIX2)
 		} else {
 			if v35 < 0 {
 				v39 = 0
 			} else {
 				v39 = int32(255)
 			}
 			v38 = v39
 		}
 		v36 = v38
 		goto _115
 	_115:
 		v29 = v36
 		goto _108
 	_108:
 		b = v29
 		rg = r&int32(0xf0) | g>>libc.Int32FromInt32(4)
 		ba = b&int32(0xf0) | int32(0x0f)
 		**(**uint8_t)(__ccgo_up(v4)) = libc.Uint8FromInt32(rg)
 		**(**uint8_t)(__ccgo_up(v4 + 1)) = libc.Uint8FromInt32(ba)
 	}
 }
 
 func YuvToRgb565Row(tls *libc.TLS, y4 uintptr, u3 uintptr, v5 uintptr, dst uintptr, len1 int32) {
 	var b, g, gb, r, rg, v1, v11, v12, v14, v15, v16, v18, v2, v20, v22, v24, v25, v27, v28, v29, v3, v31, v33, v35, v36, v38, v39, v51, v7, v9 int32
 	var end, v4 uintptr
 	_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = b, end, g, gb, r, rg, v1, v11, v12, v14, v15, v16, v18, v2, v20, v22, v24, v25, v27, v28, v29, v3, v31, v33, v35, v36, v38, v39, v4, v51, v7, v9
 	end = dst + uintptr(len1 & ^libc.Int32FromInt32(1) * int32(2))
 	for dst != end {
 		v1 = libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(y4)))
 		v2 = libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(u3)))
 		v3 = libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(v5)))
 		v4 = dst
 		v7 = v1 * int32(19077) >> int32(8)
 		goto _8
 	_8:
 		v9 = v3 * int32(26149) >> int32(8)
 		goto _10
 	_10:
 		v11 = v7 + v9 - int32(14234)
 		if v11 & ^int32(YUV_MASK2) == 0 {
 			v14 = v11 >> int32(YUV_FIX2)
 		} else {
 			if v11 < 0 {
 				v15 = 0
 			} else {
 				v15 = int32(255)
 			}
 			v14 = v15
 		}
 		v12 = v14
 		goto _13
 	_13:
 		v51 = v12
 		goto _6
 	_6:
 		r = v51
 		v18 = v1 * int32(19077) >> int32(8)
 		goto _19
 	_19:
 		v20 = v2 * int32(6419) >> int32(8)
 		goto _21
 	_21:
 		v22 = v3 * int32(13320) >> int32(8)
 		goto _23
 	_23:
 		v24 = v18 - v20 - v22 + int32(8708)
 		if v24 & ^int32(YUV_MASK2) == 0 {
 			v27 = v24 >> int32(YUV_FIX2)
 		} else {
 			if v24 < 0 {
 				v28 = 0
 			} else {
 				v28 = int32(255)
 			}
 			v27 = v28
 		}
 		v25 = v27
 		goto _26
 	_26:
 		v16 = v25
 		goto _17
 	_17:
 		g = v16
 		v31 = v1 * int32(19077) >> int32(8)
 		goto _32
 	_32:
 		v33 = v2 * int32(33050) >> int32(8)
 		goto _34
 	_34:
 		v35 = v31 + v33 - int32(17685)
 		if v35 & ^int32(YUV_MASK2) == 0 {
 			v38 = v35 >> int32(YUV_FIX2)
 		} else {
 			if v35 < 0 {
 				v39 = 0
 			} else {
 				v39 = int32(255)
 			}
 			v38 = v39
 		}
 		v36 = v38
 		goto _37
 	_37:
 		v29 = v36
 		goto _30
 	_30:
 		b = v29
 		rg = r&int32(0xf8) | g>>libc.Int32FromInt32(5)
 		gb = g<<libc.Int32FromInt32(3)&int32(0xe0) | b>>libc.Int32FromInt32(3)
 		**(**uint8_t)(__ccgo_up(v4)) = libc.Uint8FromInt32(rg)
 		**(**uint8_t)(__ccgo_up(v4 + 1)) = libc.Uint8FromInt32(gb)
 		v1 = libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(y4 + 1)))
 		v2 = libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(u3)))
 		v3 = libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(v5)))
 		v4 = dst + uintptr(libc.Int32FromInt32(2))
 		v7 = v1 * int32(19077) >> int32(8)
 		goto _47
 	_47:
 		v9 = v3 * int32(26149) >> int32(8)
 		goto _49
 	_49:
 		v11 = v7 + v9 - int32(14234)
 		if v11 & ^int32(YUV_MASK2) == 0 {
 			v14 = v11 >> int32(YUV_FIX2)
 		} else {
 			if v11 < 0 {
 				v15 = 0
 			} else {
 				v15 = int32(255)
 			}
 			v14 = v15
 		}
 		v12 = v14
 		goto _52
 	_52:
 		v51 = v12
 		goto _45
 	_45:
 		r = v51
 		v18 = v1 * int32(19077) >> int32(8)
 		goto _58
 	_58:
 		v20 = v2 * int32(6419) >> int32(8)
 		goto _60
 	_60:
 		v22 = v3 * int32(13320) >> int32(8)
 		goto _62
 	_62:
 		v24 = v18 - v20 - v22 + int32(8708)
 		if v24 & ^int32(YUV_MASK2) == 0 {
 			v27 = v24 >> int32(YUV_FIX2)
 		} else {
 			if v24 < 0 {
 				v28 = 0
 			} else {
 				v28 = int32(255)
 			}
 			v27 = v28
 		}
 		v25 = v27
 		goto _65
 	_65:
 		v16 = v25
 		goto _56
 	_56:
 		g = v16
 		v31 = v1 * int32(19077) >> int32(8)
 		goto _71
 	_71:
 		v33 = v2 * int32(33050) >> int32(8)
 		goto _73
 	_73:
 		v35 = v31 + v33 - int32(17685)
 		if v35 & ^int32(YUV_MASK2) == 0 {
 			v38 = v35 >> int32(YUV_FIX2)
 		} else {
 			if v35 < 0 {
 				v39 = 0
 			} else {
 				v39 = int32(255)
 			}
 			v38 = v39
 		}
 		v36 = v38
 		goto _76
 	_76:
 		v29 = v36
 		goto _69
 	_69:
 		b = v29
 		rg = r&int32(0xf8) | g>>libc.Int32FromInt32(5)
 		gb = g<<libc.Int32FromInt32(3)&int32(0xe0) | b>>libc.Int32FromInt32(3)
 		**(**uint8_t)(__ccgo_up(v4)) = libc.Uint8FromInt32(rg)
 		**(**uint8_t)(__ccgo_up(v4 + 1)) = libc.Uint8FromInt32(gb)
 		y4 = y4 + uintptr(2)
 		u3 = u3 + 1
 		v5 = v5 + 1
 		dst = dst + uintptr(libc.Int32FromInt32(2)*libc.Int32FromInt32(2))
 	}
 	if len1&int32(1) != 0 {
 		v1 = libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(y4)))
 		v2 = libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(u3)))
 		v3 = libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(v5)))
 		v4 = dst
 		v7 = v1 * int32(19077) >> int32(8)
 		goto _86
 	_86:
 		v9 = v3 * int32(26149) >> int32(8)
 		goto _88
 	_88:
 		v11 = v7 + v9 - int32(14234)
 		if v11 & ^int32(YUV_MASK2) == 0 {
 			v14 = v11 >> int32(YUV_FIX2)
 		} else {
 			if v11 < 0 {
 				v15 = 0
 			} else {
 				v15 = int32(255)
 			}
 			v14 = v15
 		}
 		v12 = v14
 		goto _91
 	_91:
 		v51 = v12
 		goto _84
 	_84:
 		r = v51
 		v18 = v1 * int32(19077) >> int32(8)
 		goto _97
 	_97:
 		v20 = v2 * int32(6419) >> int32(8)
 		goto _99
 	_99:
 		v22 = v3 * int32(13320) >> int32(8)
 		goto _101
 	_101:
 		v24 = v18 - v20 - v22 + int32(8708)
 		if v24 & ^int32(YUV_MASK2) == 0 {
 			v27 = v24 >> int32(YUV_FIX2)
 		} else {
 			if v24 < 0 {
 				v28 = 0
 			} else {
 				v28 = int32(255)
 			}
 			v27 = v28
 		}
 		v25 = v27
 		goto _104
 	_104:
 		v16 = v25
 		goto _95
 	_95:
 		g = v16
 		v31 = v1 * int32(19077) >> int32(8)
 		goto _110
 	_110:
 		v33 = v2 * int32(33050) >> int32(8)
 		goto _112
 	_112:
 		v35 = v31 + v33 - int32(17685)
 		if v35 & ^int32(YUV_MASK2) == 0 {
 			v38 = v35 >> int32(YUV_FIX2)
 		} else {
 			if v35 < 0 {
 				v39 = 0
 			} else {
 				v39 = int32(255)
 			}
 			v38 = v39
 		}
 		v36 = v38
 		goto _115
 	_115:
 		v29 = v36
 		goto _108
 	_108:
 		b = v29
 		rg = r&int32(0xf8) | g>>libc.Int32FromInt32(5)
 		gb = g<<libc.Int32FromInt32(3)&int32(0xe0) | b>>libc.Int32FromInt32(3)
 		**(**uint8_t)(__ccgo_up(v4)) = libc.Uint8FromInt32(rg)
 		**(**uint8_t)(__ccgo_up(v4 + 1)) = libc.Uint8FromInt32(gb)
 	}
 }
 
 type __ccgo_fp__XWebPSamplerProcessPlane_9 = func(*libc.TLS, uintptr, uintptr, uintptr, uintptr, int32)
 
 // C documentation
 //
 //	// Main call for processing a plane with a WebPSamplerRowFunc function:
 func WebPSamplerProcessPlane(tls *libc.TLS, y uintptr, y_stride int32, u uintptr, v uintptr, uv_stride int32, dst uintptr, dst_stride int32, width int32, height int32, __ccgo_fp_func WebPSamplerRowFunc) {
 	var j int32
 	_ = j
 	j = 0
 	for {
 		if !(j < height) {
 			break
 		}
 		(*(*func(*libc.TLS, uintptr, uintptr, uintptr, uintptr, int32))(unsafe.Pointer(&struct{ uintptr }{__ccgo_fp_func})))(tls, y, u, v, dst, width)
 		y = y + uintptr(y_stride)
 		if j&int32(1) != 0 {
 			u = u + uintptr(uv_stride)
 			v = v + uintptr(uv_stride)
 		}
 		dst = dst + uintptr(dst_stride)
 		goto _1
 	_1:
 		;
 		j = j + 1
 	}
 }
 
 func WebPInitSamplers(tls *libc.TLS) {
 	if libc.AtomicLoadPUintptr(uintptr(unsafe.Pointer(&WebPInitSamplers_body_last_cpuinfo_used))) == VP8GetCPUInfo {
 		goto _1
 	}
 	WebPInitSamplers_body(tls)
 	libc.AtomicStorePUintptr(uintptr(unsafe.Pointer(&WebPInitSamplers_body_last_cpuinfo_used)), VP8GetCPUInfo)
 	goto _2
 _2:
 	;
 	goto _1
 _1: /**/ //
 }
 
 var WebPInitSamplers_body_last_cpuinfo_used = uintptr(0)
 
 func init() {
 	p := unsafe.Pointer(&WebPInitSamplers_body_last_cpuinfo_used)
 	*(*uintptr)(unsafe.Add(p, 0)) = uintptr(unsafe.Pointer(&WebPInitSamplers_body_last_cpuinfo_used))
 }
 
 func WebPInitSamplers_body(tls *libc.TLS) {
 	WebPSamplers[int32(MODE_RGB)] = __ccgo_fp(YuvToRgbRow)
 	WebPSamplers[int32(MODE_RGBA)] = __ccgo_fp(YuvToRgbaRow)
 	WebPSamplers[int32(MODE_BGR)] = __ccgo_fp(YuvToBgrRow)
 	WebPSamplers[int32(MODE_BGRA)] = __ccgo_fp(YuvToBgraRow)
 	WebPSamplers[int32(MODE_ARGB)] = __ccgo_fp(YuvToArgbRow)
 	WebPSamplers[int32(MODE_RGBA_4444)] = __ccgo_fp(YuvToRgba4444Row)
 	WebPSamplers[int32(MODE_RGB_565)] = __ccgo_fp(YuvToRgb565Row)
 	WebPSamplers[int32(MODE_rgbA)] = __ccgo_fp(YuvToRgbaRow)
 	WebPSamplers[int32(MODE_bgrA)] = __ccgo_fp(YuvToBgraRow)
 	WebPSamplers[int32(MODE_Argb)] = __ccgo_fp(YuvToArgbRow)
 	WebPSamplers[int32(MODE_rgbA_4444)] = __ccgo_fp(YuvToRgba4444Row)
 	// If defined, use CPUInfo() to overwrite some pointers with faster versions.
 	if VP8GetCPUInfo != libc.UintptrFromInt32(0) {
 	}
 }
 
 //-----------------------------------------------------------------------------
 // ARGB -> YUV converters
 
 func ConvertARGBToY_C(tls *libc.TLS, argb uintptr, y uintptr, width int32) {
 	var i, luma, v2 int32
 	var p uint32_t
 	_, _, _, _ = i, luma, p, v2
 	i = 0
 	for {
 		if !(i < width) {
 			break
 		}
 		p = **(**uint32_t)(__ccgo_up(argb + uintptr(i)*4))
 		luma = int32(16839)*libc.Int32FromUint32(p>>libc.Int32FromInt32(16)&uint32(0xff)) + int32(33059)*libc.Int32FromUint32(p>>libc.Int32FromInt32(8)&uint32(0xff)) + int32(6420)*libc.Int32FromUint32(p>>libc.Int32FromInt32(0)&uint32(0xff))
 		v2 = (luma + int32(YUV_HALF) + libc.Int32FromInt32(16)<<int32(YUV_FIX)) >> int32(YUV_FIX)
 		goto _3
 	_3:
 		**(**uint8_t)(__ccgo_up(y + uintptr(i))) = libc.Uint8FromInt32(v2)
 		goto _1
 	_1:
 		;
 		i = i + 1
 	}
 }
 
 func WebPConvertARGBToUV_C(tls *libc.TLS, argb uintptr, u1 uintptr, v1 uintptr, src_width int32, do_store int32) {
 	var b2, b3, g2, g3, i, r2, r3, tmp_u, tmp_u1, tmp_v, tmp_v1, u, uv_width, v, v111, v12, v14, v15, v2, v4, v5, v7, v8, v9 int32
 	var v0, v01, v11 uint32_t
 	_, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _, _ = b2, b3, g2, g3, i, r2, r3, tmp_u, tmp_u1, tmp_v, tmp_v1, u, uv_width, v, v0, v01, v11, v111, v12, v14, v15, v2, v4, v5, v7, v8, v9
 	// No rounding. Last pixel is dealt with separately.
 	uv_width = src_width >> int32(1)
 	i = 0
 	for {
 		if !(i < uv_width) {
 			break
 		}
 		v0 = **(**uint32_t)(__ccgo_up(argb + uintptr(int32(2)*i+0)*4))
 		v11 = **(**uint32_t)(__ccgo_up(argb + uintptr(int32(2)*i+int32(1))*4))
 		// VP8RGBToU/V expects four accumulated pixels. Hence we need to
 		// scale r/g/b value by a factor 2. We just shift v0/v1 one bit less.
 		r2 = libc.Int32FromUint32(v0>>libc.Int32FromInt32(15)&uint32(0x1fe) + v11>>libc.Int32FromInt32(15)&uint32(0x1fe))
 		g2 = libc.Int32FromUint32(v0>>libc.Int32FromInt32(7)&uint32(0x1fe) + v11>>libc.Int32FromInt32(7)&uint32(0x1fe))
 		b2 = libc.Int32FromUint32(v0<<libc.Int32FromInt32(1)&uint32(0x1fe) + v11<<libc.Int32FromInt32(1)&uint32(0x1fe))
 		u = -int32(9719)*r2 - int32(19081)*g2 + int32(28800)*b2
 		v4 = u
 		v4 = (v4 + int32(YUV_HALF)<<libc.Int32FromInt32(2) + libc.Int32FromInt32(128)<<(int32(YUV_FIX)+libc.Int32FromInt32(2))) >> (int32(YUV_FIX) + libc.Int32FromInt32(2))
 		if v4 & ^libc.Int32FromInt32(0xff) == 0 {
 			v7 = v4
 		} else {
 			if v4 < 0 {
 				v8 = 0
 			} else {
 				v8 = int32(255)
 			}
 			v7 = v8
 		}
 		v5 = v7
 		goto _6
 	_6:
 		v2 = v5
 		goto _3
 	_3:
 		tmp_u = v2
 		v = +libc.Int32FromInt32(28800)*r2 - int32(24116)*g2 - int32(4684)*b2
 		v111 = v
 		v111 = (v111 + int32(YUV_HALF)<<libc.Int32FromInt32(2) + libc.Int32FromInt32(128)<<(int32(YUV_FIX)+libc.Int32FromInt32(2))) >> (int32(YUV_FIX) + libc.Int32FromInt32(2))
 		if v111 & ^libc.Int32FromInt32(0xff) == 0 {
 			v14 = v111
 		} else {
 			if v111 < 0 {
 				v15 = 0
 			} else {
 				v15 = int32(255)
 			}
 			v14 = v15
 		}
 		v12 = v14
 		goto _13
 	_13:
 		v9 = v12
 		goto _10
 	_10:
 		tmp_v = v9
 		if do_store != 0 {
 			**(**uint8_t)(__ccgo_up(u1 + uintptr(i))) = libc.Uint8FromInt32(tmp_u)
 			**(**uint8_t)(__ccgo_up(v1 + uintptr(i))) = libc.Uint8FromInt32(tmp_v)
 		} else {
 			// Approximated average-of-four. But it's an acceptable diff.
 			**(**uint8_t)(__ccgo_up(u1 + uintptr(i))) = libc.Uint8FromInt32((libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(u1 + uintptr(i)))) + tmp_u + int32(1)) >> int32(1))
 			**(**uint8_t)(__ccgo_up(v1 + uintptr(i))) = libc.Uint8FromInt32((libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(v1 + uintptr(i)))) + tmp_v + int32(1)) >> int32(1))
 		}
 		goto _1
 	_1:
 		;
 		i = i + 1
 	}
 	if src_width&int32(1) != 0 { // last pixel
 		v01 = **(**uint32_t)(__ccgo_up(argb + uintptr(int32(2)*i+0)*4))
 		r3 = libc.Int32FromUint32(v01 >> libc.Int32FromInt32(14) & uint32(0x3fc))
 		g3 = libc.Int32FromUint32(v01 >> libc.Int32FromInt32(6) & uint32(0x3fc))
 		b3 = libc.Int32FromUint32(v01 << libc.Int32FromInt32(2) & uint32(0x3fc))
 		u = -int32(9719)*r3 - int32(19081)*g3 + int32(28800)*b3
 		v4 = u
 		v4 = (v4 + int32(YUV_HALF)<<libc.Int32FromInt32(2) + libc.Int32FromInt32(128)<<(int32(YUV_FIX)+libc.Int32FromInt32(2))) >> (int32(YUV_FIX) + libc.Int32FromInt32(2))
 		if v4 & ^libc.Int32FromInt32(0xff) == 0 {
 			v7 = v4
 		} else {
 			if v4 < 0 {
 				v8 = 0
 			} else {
 				v8 = int32(255)
 			}
 			v7 = v8
 		}
 		v5 = v7
 		goto _20
 	_20:
 		v2 = v5
 		goto _17
 	_17:
 		tmp_u1 = v2
 		v = +libc.Int32FromInt32(28800)*r3 - int32(24116)*g3 - int32(4684)*b3
 		v111 = v
 		v111 = (v111 + int32(YUV_HALF)<<libc.Int32FromInt32(2) + libc.Int32FromInt32(128)<<(int32(YUV_FIX)+libc.Int32FromInt32(2))) >> (int32(YUV_FIX) + libc.Int32FromInt32(2))
 		if v111 & ^libc.Int32FromInt32(0xff) == 0 {
 			v14 = v111
 		} else {
 			if v111 < 0 {
 				v15 = 0
 			} else {
 				v15 = int32(255)
 			}
 			v14 = v15
 		}
 		v12 = v14
 		goto _27
 	_27:
 		v9 = v12
 		goto _24
 	_24:
 		tmp_v1 = v9
 		if do_store != 0 {
 			**(**uint8_t)(__ccgo_up(u1 + uintptr(i))) = libc.Uint8FromInt32(tmp_u1)
 			**(**uint8_t)(__ccgo_up(v1 + uintptr(i))) = libc.Uint8FromInt32(tmp_v1)
 		} else {
 			**(**uint8_t)(__ccgo_up(u1 + uintptr(i))) = libc.Uint8FromInt32((libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(u1 + uintptr(i)))) + tmp_u1 + int32(1)) >> int32(1))
 			**(**uint8_t)(__ccgo_up(v1 + uintptr(i))) = libc.Uint8FromInt32((libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(v1 + uintptr(i)))) + tmp_v1 + int32(1)) >> int32(1))
 		}
 	}
 }
 
 //-----------------------------------------------------------------------------
 
 func ConvertRGB24ToY_C(tls *libc.TLS, rgb uintptr, y uintptr, width int32) {
 	var i, luma, v2 int32
 	_, _, _ = i, luma, v2
 	i = 0
 	for {
 		if !(i < width) {
 			break
 		}
 		luma = int32(16839)*libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(rgb))) + int32(33059)*libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(rgb + 1))) + int32(6420)*libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(rgb + 2)))
 		v2 = (luma + int32(YUV_HALF) + libc.Int32FromInt32(16)<<int32(YUV_FIX)) >> int32(YUV_FIX)
 		goto _3
 	_3:
 		**(**uint8_t)(__ccgo_up(y + uintptr(i))) = libc.Uint8FromInt32(v2)
 		goto _1
 	_1:
 		;
 		i = i + 1
 		rgb = rgb + uintptr(3)
 	}
 }
 
 func ConvertBGR24ToY_C(tls *libc.TLS, bgr uintptr, y uintptr, width int32) {
 	var i, luma, v2 int32
 	_, _, _ = i, luma, v2
 	i = 0
 	for {
 		if !(i < width) {
 			break
 		}
 		luma = int32(16839)*libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(bgr + 2))) + int32(33059)*libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(bgr + 1))) + int32(6420)*libc.Int32FromUint8(**(**uint8_t)(__ccgo_up(bgr)))
 		v2 = (luma + int32(YUV_HALF) + libc.Int32FromInt32(16)<<int32(YUV_FIX)) >> int32(YUV_FIX)
 		goto _3
 	_3:
 		**(**uint8_t)(__ccgo_up(y + uintptr(i))) = libc.Uint8FromInt32(v2)
 		goto _1
 	_1:
 		;
 		i = i + 1
 		bgr = bgr + uintptr(3)
 	}
 }
 
 func WebPConvertRGBA32ToUV_C(tls *libc.TLS, rgb uintptr, u1 uintptr, v1 uintptr, width int32) {
 	var b2, g2, i, r2, u, v, v2, v4, v5, v7, v8 int32
 	_, _, _, _, _, _, _, _, _, _, _ = b2, g2, i, r2, u, v, v2, v4, v5, v7, v8
 	i = 0
 	for {
 		if !(i < width) {
 			break
 		}
 		r2 = libc.Int32FromUint16(**(**uint16_t)(__ccgo_up(rgb)))
 		g2 = libc.Int32FromUint16(**(**uint16_t)(__ccgo_up(rgb + 1*2)))
 		b2 = libc.Int32FromUint16(**(**uint16_t)(__ccgo_up(rgb + 2*2)))
 		u = -int32(9719)*r2 - int32(19081)*g2 + int32(28800)*b2
 		v4 = u
 		v4 = (v4 + int32(YUV_HALF)<<libc.Int32FromInt32(2) + libc.Int32FromInt32(128)<<(int32(YUV_FIX)+libc.Int32FromInt32(2))) >> (int32(YUV_FIX) + libc.Int32FromInt32(2))
 		if v4 & ^libc.Int32FromInt32(0xff) == 0 {
 			v7 = v4
 		} else {
 			if v4 < 0 {
 				v8 = 0
 			} else {
 				v8 = int32(255)
 			}
 			v7 = v8
 		}
 		v5 = v7
 		goto _6
 	_6:
 		v2 = v5
 		goto _3
 	_3:
 		**(**uint8_t)(__ccgo_up(u1 + uintptr(i))) = libc.Uint8FromInt32(v2)
 		v = +libc.Int32FromInt32(28800)*r2 - int32(24116)*g2 - int32(4684)*b2
 		v4 = v
 		v4 = (v4 + int32(YUV_HALF)<<libc.Int32FromInt32(2) + libc.Int32FromInt32(128)<<(int32(YUV_FIX)+libc.Int32FromInt32(2))) >> (int32(YUV_FIX) + libc.Int32FromInt32(2))
 		if v4 & ^libc.Int32FromInt32(0xff) == 0 {
 			v7 = v4
 		} else {
 			if v4 < 0 {
 				v8 = 0
 			} else {
 				v8 = int32(255)
 			}
 			v7 = v8
 		}
 		v5 = v7
 		goto _13
 	_13:
 		v2 = v5
 		goto _10
 	_10:
 		**(**uint8_t)(__ccgo_up(v1 + uintptr(i))) = libc.Uint8FromInt32(v2)
 		goto _1
 	_1:
 		;
 		i = i + int32(1)
 		rgb = rgb + uintptr(4)*2
 	}
 }
 
 func WebPInitConvertARGBToYUV(tls *libc.TLS) {
 	if libc.AtomicLoadPUintptr(uintptr(unsafe.Pointer(&WebPInitConvertARGBToYUV_body_last_cpuinfo_used))) == VP8GetCPUInfo {
 		goto _1
 	}
 	WebPInitConvertARGBToYUV_body(tls)
 	libc.AtomicStorePUintptr(uintptr(unsafe.Pointer(&WebPInitConvertARGBToYUV_body_last_cpuinfo_used)), VP8GetCPUInfo)
 	goto _2
 _2:
 	;
 	goto _1
 _1: /**/ //
 }
 
 var WebPInitConvertARGBToYUV_body_last_cpuinfo_used = uintptr(0)
 
 func init() {
 	p := unsafe.Pointer(&WebPInitConvertARGBToYUV_body_last_cpuinfo_used)
 	*(*uintptr)(unsafe.Add(p, 0)) = uintptr(unsafe.Pointer(&WebPInitConvertARGBToYUV_body_last_cpuinfo_used))
 }
 
 func WebPInitConvertARGBToYUV_body(tls *libc.TLS) {
 	WebPConvertARGBToY = __ccgo_fp(ConvertARGBToY_C)
 	WebPConvertARGBToUV = __ccgo_fp(WebPConvertARGBToUV_C)
 	WebPConvertRGB24ToY = __ccgo_fp(ConvertRGB24ToY_C)
 	WebPConvertBGR24ToY = __ccgo_fp(ConvertBGR24ToY_C)
 	WebPConvertRGBA32ToUV = __ccgo_fp(WebPConvertRGBA32ToUV_C)
 	if VP8GetCPUInfo != libc.UintptrFromInt32(0) {
 	}
 }
 
 func WebPInitSamplersMIPS32(tls *libc.TLS) {
 }
 
 func WebPInitSamplersMIPSdspR2(tls *libc.TLS) {
 }
 
 func WebPInitConvertARGBToYUVNEON(tls *libc.TLS) {
 }
 
 func WebPInitSamplersSSE2(tls *libc.TLS) {
 }
 
 func WebPInitConvertARGBToYUVSSE2(tls *libc.TLS) {
 }
 
 func WebPInitSamplersSSE41(tls *libc.TLS) {
 }
 
 func WebPInitConvertARGBToYUVSSE41(tls *libc.TLS) {
 }
 
 type __ccgo_fp__XSharpYuvInit_0 = func(*libc.TLS, int32) int32
 
 func SharpYuvInit(tls *libc.TLS, __ccgo_fp_cpu_info_func VP8CPUInfo) {
 	_ = __ccgo_fp_cpu_info_func
 }
 
 func SharpYuvGetConversionMatrix(tls *libc.TLS, matrix_type SharpYuvMatrixType) (r uintptr) {
 	_ = matrix_type
 	return libc.UintptrFromInt32(0)
 }
 
 func SharpYuvConvert(tls *libc.TLS, r_ptr uintptr, g_ptr uintptr, b_ptr uintptr, rgb_step int32, rgb_stride int32, rgb_bit_depth int32, y_ptr uintptr, y_stride int32, u_ptr uintptr, u_stride int32, v_ptr uintptr, v_stride int32, yuv_bit_depth int32, width int32, height int32, yuv_matrix uintptr) (r int32) {
 	_ = r_ptr
 	_ = g_ptr
 	_ = b_ptr
 	_ = rgb_step
 	_ = rgb_stride
 	_ = rgb_bit_depth
 	_ = y_ptr
 	_ = y_stride
 	_ = u_ptr
 	_ = u_stride
 	_ = v_ptr
 	_ = v_stride
 	_ = yuv_bit_depth
 	_ = width
 	_ = height
 	_ = yuv_matrix
 	return 0
 }
 
 func __ccgo_fp(f interface{}) uintptr {
 	type iface [2]uintptr
 	return (*iface)(unsafe.Pointer(&f))[1]
 }
 
 func __ccgo_up(n uintptr) unsafe.Pointer {
 	return unsafe.Pointer(&n)
 }
 
 var VP8AccumulateSSE VP8AccumulateSSEFunc
 
 //------------------------------------------------------------------------------
 // Tables for level coding
 
 var VP8Cat3 = [3]uint8_t{
 	0: uint8(173),
 	1: uint8(148),
 	2: uint8(140),
 }
 
 var VP8Cat4 = [4]uint8_t{
 	0: uint8(176),
 	1: uint8(155),
 	2: uint8(140),
 	3: uint8(135),
 }
 
 var VP8Cat5 = [5]uint8_t{
 	0: uint8(180),
 	1: uint8(157),
 	2: uint8(141),
 	3: uint8(134),
 	4: uint8(130),
 }
 
 var VP8Cat6 = [11]uint8_t{
 	0:  uint8(254),
 	1:  uint8(254),
 	2:  uint8(243),
 	3:  uint8(230),
 	4:  uint8(196),
 	5:  uint8(177),
 	6:  uint8(153),
 	7:  uint8(140),
 	8:  uint8(133),
 	9:  uint8(130),
 	10: uint8(129),
 }
 
 //------------------------------------------------------------------------------
 
 // Copyright 2011 Google Inc. All Rights Reserved.
 //
 // Use of this source code is governed by a BSD-style license
 // that can be found in the COPYING file in the root of the source
 // tree. An additional intellectual property rights grant can be found
 // in the file PATENTS. All contributing project authors may
 // be found in the AUTHORS file in the root of the source tree.
 // -----------------------------------------------------------------------------
 //
 // Bit writing and boolean coder
 //
 // Author: Skal (pascal.massimino@gmail.com)
 
 //------------------------------------------------------------------------------
 // Default probabilities
 
 // C documentation
 //
 //	// Paragraph 13.5
 
 var VP8CoeffsProba0 = [4][8][3][11]uint8_t{
 	0: {
 		0: {
 			0: {
 				0:  uint8(128),
 				1:  uint8(128),
 				2:  uint8(128),
 				3:  uint8(128),
 				4:  uint8(128),
 				5:  uint8(128),
 				6:  uint8(128),
 				7:  uint8(128),
 				8:  uint8(128),
 				9:  uint8(128),
 				10: uint8(128),
 			},
 			1: {
 				0:  uint8(128),
 				1:  uint8(128),
 				2:  uint8(128),
 				3:  uint8(128),
 				4:  uint8(128),
 				5:  uint8(128),
 				6:  uint8(128),
 				7:  uint8(128),
 				8:  uint8(128),
 				9:  uint8(128),
 				10: uint8(128),
 			},
 			2: {
 				0:  uint8(128),
 				1:  uint8(128),
 				2:  uint8(128),
 				3:  uint8(128),
 				4:  uint8(128),
 				5:  uint8(128),
 				6:  uint8(128),
 				7:  uint8(128),
 				8:  uint8(128),
 				9:  uint8(128),
 				10: uint8(128),
 			},
 		},
 		1: {
 			0: {
 				0:  uint8(253),
 				1:  uint8(136),
 				2:  uint8(254),
 				3:  uint8(255),
 				4:  uint8(228),
 				5:  uint8(219),
 				6:  uint8(128),
 				7:  uint8(128),
 				8:  uint8(128),
 				9:  uint8(128),
 				10: uint8(128),
 			},
 			1: {
 				0:  uint8(189),
 				1:  uint8(129),
 				2:  uint8(242),
 				3:  uint8(255),
 				4:  uint8(227),
 				5:  uint8(213),
 				6:  uint8(255),
 				7:  uint8(219),
 				8:  uint8(128),
 				9:  uint8(128),
 				10: uint8(128),
 			},
 			2: {
 				0:  uint8(106),
 				1:  uint8(126),
 				2:  uint8(227),
 				3:  uint8(252),
 				4:  uint8(214),
 				5:  uint8(209),
 				6:  uint8(255),
 				7:  uint8(255),
 				8:  uint8(128),
 				9:  uint8(128),
 				10: uint8(128),
 			},
 		},
 		2: {
 			0: {
 				0:  uint8(1),
 				1:  uint8(98),
 				2:  uint8(248),
 				3:  uint8(255),
 				4:  uint8(236),
 				5:  uint8(226),
 				6:  uint8(255),
 				7:  uint8(255),
 				8:  uint8(128),
 				9:  uint8(128),
 				10: uint8(128),
 			},
 			1: {
 				0:  uint8(181),
 				1:  uint8(133),
 				2:  uint8(238),
 				3:  uint8(254),
 				4:  uint8(221),
 				5:  uint8(234),
 				6:  uint8(255),
 				7:  uint8(154),
 				8:  uint8(128),
 				9:  uint8(128),
 				10: uint8(128),
 			},
 			2: {
 				0:  uint8(78),
 				1:  uint8(134),
 				2:  uint8(202),
 				3:  uint8(247),
 				4:  uint8(198),
 				5:  uint8(180),
 				6:  uint8(255),
 				7:  uint8(219),
 				8:  uint8(128),
 				9:  uint8(128),
 				10: uint8(128),
 			},
 		},
 		3: {
 			0: {
 				0:  uint8(1),
 				1:  uint8(185),
 				2:  uint8(249),
 				3:  uint8(255),
 				4:  uint8(243),
 				5:  uint8(255),
 				6:  uint8(128),
 				7:  uint8(128),
 				8:  uint8(128),
 				9:  uint8(128),
 				10: uint8(128),
 			},
 			1: {
 				0:  uint8(184),
 				1:  uint8(150),
 				2:  uint8(247),
 				3:  uint8(255),
 				4:  uint8(236),
 				5:  uint8(224),
 				6:  uint8(128),
 				7:  uint8(128),
 				8:  uint8(128),
 				9:  uint8(128),
 				10: uint8(128),
 			},
 			2: {
 				0:  uint8(77),
 				1:  uint8(110),
 				2:  uint8(216),
 				3:  uint8(255),
 				4:  uint8(236),
 				5:  uint8(230),
 				6:  uint8(128),
 				7:  uint8(128),
 				8:  uint8(128),
 				9:  uint8(128),
 				10: uint8(128),
 			},
 		},
 		4: {
 			0: {
 				0:  uint8(1),
 				1:  uint8(101),
 				2:  uint8(251),
 				3:  uint8(255),
 				4:  uint8(241),
 				5:  uint8(255),
 				6:  uint8(128),
 				7:  uint8(128),
 				8:  uint8(128),
 				9:  uint8(128),
 				10: uint8(128),
 			},
 			1: {
 				0:  uint8(170),
 				1:  uint8(139),
 				2:  uint8(241),
 				3:  uint8(252),
 				4:  uint8(236),
 				5:  uint8(209),
 				6:  uint8(255),
 				7:  uint8(255),
 				8:  uint8(128),
 				9:  uint8(128),
 				10: uint8(128),
 			},
 			2: {
 				0:  uint8(37),
 				1:  uint8(116),
 				2:  uint8(196),
 				3:  uint8(243),
 				4:  uint8(228),
 				5:  uint8(255),
 				6:  uint8(255),
 				7:  uint8(255),
 				8:  uint8(128),
 				9:  uint8(128),
 				10: uint8(128),
 			},
 		},
 		5: {
 			0: {
 				0:  uint8(1),
 				1:  uint8(204),
 				2:  uint8(254),
 				3:  uint8(255),
 				4:  uint8(245),
 				5:  uint8(255),
 				6:  uint8(128),
 				7:  uint8(128),
 				8:  uint8(128),
 				9:  uint8(128),
 				10: uint8(128),
 			},
 			1: {
 				0:  uint8(207),
 				1:  uint8(160),
 				2:  uint8(250),
 				3:  uint8(255),
 				4:  uint8(238),
 				5:  uint8(128),
 				6:  uint8(128),
 				7:  uint8(128),
 				8:  uint8(128),
 				9:  uint8(128),
 				10: uint8(128),
 			},
 			2: {
 				0:  uint8(102),
 				1:  uint8(103),
 				2:  uint8(231),
 				3:  uint8(255),
 				4:  uint8(211),
 				5:  uint8(171),
 				6:  uint8(128),
 				7:  uint8(128),
 				8:  uint8(128),
 				9:  uint8(128),
 				10: uint8(128),
 			},
 		},
 		6: {
 			0: {
 				0:  uint8(1),
 				1:  uint8(152),
 				2:  uint8(252),
 				3:  uint8(255),
 				4:  uint8(240),
 				5:  uint8(255),
 				6:  uint8(128),
 				7:  uint8(128),
 				8:  uint8(128),
 				9:  uint8(128),
 				10: uint8(128),
 			},
 			1: {
 				0:  uint8(177),
 				1:  uint8(135),
 				2:  uint8(243),
 				3:  uint8(255),
 				4:  uint8(234),
 				5:  uint8(225),
 				6:  uint8(128),
 				7:  uint8(128),
 				8:  uint8(128),
 				9:  uint8(128),
 				10: uint8(128),
 			},
 			2: {
 				0:  uint8(80),
 				1:  uint8(129),
 				2:  uint8(211),
 				3:  uint8(255),
 				4:  uint8(194),
 				5:  uint8(224),
 				6:  uint8(128),
 				7:  uint8(128),
 				8:  uint8(128),
 				9:  uint8(128),
 				10: uint8(128),
 			},
 		},
 		7: {
 			0: {
 				0:  uint8(1),
 				1:  uint8(1),
 				2:  uint8(255),
 				3:  uint8(128),
 				4:  uint8(128),
 				5:  uint8(128),
 				6:  uint8(128),
 				7:  uint8(128),
 				8:  uint8(128),
 				9:  uint8(128),
 				10: uint8(128),
 			},
 			1: {
 				0:  uint8(246),
 				1:  uint8(1),
 				2:  uint8(255),
 				3:  uint8(128),
 				4:  uint8(128),
 				5:  uint8(128),
 				6:  uint8(128),
 				7:  uint8(128),
 				8:  uint8(128),
 				9:  uint8(128),
 				10: uint8(128),
 			},
 			2: {
 				0:  uint8(255),
 				1:  uint8(128),
 				2:  uint8(128),
 				3:  uint8(128),
 				4:  uint8(128),
 				5:  uint8(128),
 				6:  uint8(128),
 				7:  uint8(128),
 				8:  uint8(128),
 				9:  uint8(128),
 				10: uint8(128),
 			},
 		},
 	},
 	1: {
 		0: {
 			0: {
 				0:  uint8(198),
 				1:  uint8(35),
 				2:  uint8(237),
 				3:  uint8(223),
 				4:  uint8(193),
 				5:  uint8(187),
 				6:  uint8(162),
 				7:  uint8(160),
 				8:  uint8(145),
 				9:  uint8(155),
 				10: uint8(62),
 			},
 			1: {
 				0:  uint8(131),
 				1:  uint8(45),
 				2:  uint8(198),
 				3:  uint8(221),
 				4:  uint8(172),
 				5:  uint8(176),
 				6:  uint8(220),
 				7:  uint8(157),
 				8:  uint8(252),
 				9:  uint8(221),
 				10: uint8(1),
 			},
 			2: {
 				0:  uint8(68),
 				1:  uint8(47),
 				2:  uint8(146),
 				3:  uint8(208),
 				4:  uint8(149),
 				5:  uint8(167),
 				6:  uint8(221),
 				7:  uint8(162),
 				8:  uint8(255),
 				9:  uint8(223),
 				10: uint8(128),
 			},
 		},
 		1: {
 			0: {
 				0:  uint8(1),
 				1:  uint8(149),
 				2:  uint8(241),
 				3:  uint8(255),
 				4:  uint8(221),
 				5:  uint8(224),
 				6:  uint8(255),
 				7:  uint8(255),
 				8:  uint8(128),
 				9:  uint8(128),
 				10: uint8(128),
 			},
 			1: {
 				0:  uint8(184),
 				1:  uint8(141),
 				2:  uint8(234),
 				3:  uint8(253),
 				4:  uint8(222),
 				5:  uint8(220),
 				6:  uint8(255),
 				7:  uint8(199),
 				8:  uint8(128),
 				9:  uint8(128),
 				10: uint8(128),
 			},
 			2: {
 				0:  uint8(81),
 				1:  uint8(99),
 				2:  uint8(181),
 				3:  uint8(242),
 				4:  uint8(176),
 				5:  uint8(190),
 				6:  uint8(249),
 				7:  uint8(202),
 				8:  uint8(255),
 				9:  uint8(255),
 				10: uint8(128),
 			},
 		},
 		2: {
 			0: {
 				0:  uint8(1),
 				1:  uint8(129),
 				2:  uint8(232),
 				3:  uint8(253),
 				4:  uint8(214),
 				5:  uint8(197),
 				6:  uint8(242),
 				7:  uint8(196),
 				8:  uint8(255),
 				9:  uint8(255),
 				10: uint8(128),
 			},
 			1: {
 				0:  uint8(99),
 				1:  uint8(121),
 				2:  uint8(210),
 				3:  uint8(250),
 				4:  uint8(201),
 				5:  uint8(198),
 				6:  uint8(255),
 				7:  uint8(202),
 				8:  uint8(128),
 				9:  uint8(128),
 				10: uint8(128),
 			},
 			2: {
 				0:  uint8(23),
 				1:  uint8(91),
 				2:  uint8(163),
 				3:  uint8(242),
 				4:  uint8(170),
 				5:  uint8(187),
 				6:  uint8(247),
 				7:  uint8(210),
 				8:  uint8(255),
 				9:  uint8(255),
 				10: uint8(128),
 			},
 		},
 		3: {
 			0: {
 				0:  uint8(1),
 				1:  uint8(200),
 				2:  uint8(246),
 				3:  uint8(255),
 				4:  uint8(234),
 				5:  uint8(255),
 				6:  uint8(128),
 				7:  uint8(128),
 				8:  uint8(128),
 				9:  uint8(128),
 				10: uint8(128),
 			},
 			1: {
 				0:  uint8(109),
 				1:  uint8(178),
 				2:  uint8(241),
 				3:  uint8(255),
 				4:  uint8(231),
 				5:  uint8(245),
 				6:  uint8(255),
 				7:  uint8(255),
 				8:  uint8(128),
 				9:  uint8(128),
 				10: uint8(128),
 			},
 			2: {
 				0:  uint8(44),
 				1:  uint8(130),
 				2:  uint8(201),
 				3:  uint8(253),
 				4:  uint8(205),
 				5:  uint8(192),
 				6:  uint8(255),
 				7:  uint8(255),
 				8:  uint8(128),
 				9:  uint8(128),
 				10: uint8(128),
 			},
 		},
 		4: {
 			0: {
 				0:  uint8(1),
 				1:  uint8(132),
 				2:  uint8(239),
 				3:  uint8(251),
 				4:  uint8(219),
 				5:  uint8(209),
 				6:  uint8(255),
 				7:  uint8(165),
 				8:  uint8(128),
 				9:  uint8(128),
 				10: uint8(128),
 			},
 			1: {
 				0:  uint8(94),
 				1:  uint8(136),
 				2:  uint8(225),
 				3:  uint8(251),
 				4:  uint8(218),
 				5:  uint8(190),
 				6:  uint8(255),
 				7:  uint8(255),
 				8:  uint8(128),
 				9:  uint8(128),
 				10: uint8(128),
 			},
 			2: {
 				0:  uint8(22),
 				1:  uint8(100),
 				2:  uint8(174),
 				3:  uint8(245),
 				4:  uint8(186),
 				5:  uint8(161),
 				6:  uint8(255),
 				7:  uint8(199),
 				8:  uint8(128),
 				9:  uint8(128),
 				10: uint8(128),
 			},
 		},
 		5: {
 			0: {
 				0:  uint8(1),
 				1:  uint8(182),
 				2:  uint8(249),
 				3:  uint8(255),
 				4:  uint8(232),
 				5:  uint8(235),
 				6:  uint8(128),
 				7:  uint8(128),
 				8:  uint8(128),
 				9:  uint8(128),
 				10: uint8(128),
 			},
 			1: {
 				0:  uint8(124),
 				1:  uint8(143),
 				2:  uint8(241),
 				3:  uint8(255),
 				4:  uint8(227),
 				5:  uint8(234),
 				6:  uint8(128),
 				7:  uint8(128),
 				8:  uint8(128),
 				9:  uint8(128),
 				10: uint8(128),
 			},
 			2: {
 				0:  uint8(35),
 				1:  uint8(77),
 				2:  uint8(181),
 				3:  uint8(251),
 				4:  uint8(193),
 				5:  uint8(211),
 				6:  uint8(255),
 				7:  uint8(205),
 				8:  uint8(128),
 				9:  uint8(128),
 				10: uint8(128),
 			},
 		},
 		6: {
 			0: {
 				0:  uint8(1),
 				1:  uint8(157),
 				2:  uint8(247),
 				3:  uint8(255),
 				4:  uint8(236),
 				5:  uint8(231),
 				6:  uint8(255),
 				7:  uint8(255),
 				8:  uint8(128),
 				9:  uint8(128),
 				10: uint8(128),
 			},
 			1: {
 				0:  uint8(121),
 				1:  uint8(141),
 				2:  uint8(235),
 				3:  uint8(255),
 				4:  uint8(225),
 				5:  uint8(227),
 				6:  uint8(255),
 				7:  uint8(255),
 				8:  uint8(128),
 				9:  uint8(128),
 				10: uint8(128),
 			},
 			2: {
 				0:  uint8(45),
 				1:  uint8(99),
 				2:  uint8(188),
 				3:  uint8(251),
 				4:  uint8(195),
 				5:  uint8(217),
 				6:  uint8(255),
 				7:  uint8(224),
 				8:  uint8(128),
 				9:  uint8(128),
 				10: uint8(128),
 			},
 		},
 		7: {
 			0: {
 				0:  uint8(1),
 				1:  uint8(1),
 				2:  uint8(251),
 				3:  uint8(255),
 				4:  uint8(213),
 				5:  uint8(255),
 				6:  uint8(128),
 				7:  uint8(128),
 				8:  uint8(128),
 				9:  uint8(128),
 				10: uint8(128),
 			},
 			1: {
 				0:  uint8(203),
 				1:  uint8(1),
 				2:  uint8(248),
 				3:  uint8(255),
 				4:  uint8(255),
 				5:  uint8(128),
 				6:  uint8(128),
 				7:  uint8(128),
 				8:  uint8(128),
 				9:  uint8(128),
 				10: uint8(128),
 			},
 			2: {
 				0:  uint8(137),
 				1:  uint8(1),
 				2:  uint8(177),
 				3:  uint8(255),
 				4:  uint8(224),
 				5:  uint8(255),
 				6:  uint8(128),
 				7:  uint8(128),
 				8:  uint8(128),
 				9:  uint8(128),
 				10: uint8(128),
 			},
 		},
 	},
 	2: {
 		0: {
 			0: {
 				0:  uint8(253),
 				1:  uint8(9),
 				2:  uint8(248),
 				3:  uint8(251),
 				4:  uint8(207),
 				5:  uint8(208),
 				6:  uint8(255),
 				7:  uint8(192),
 				8:  uint8(128),
 				9:  uint8(128),
 				10: uint8(128),
 			},
 			1: {
 				0:  uint8(175),
 				1:  uint8(13),
 				2:  uint8(224),
 				3:  uint8(243),
 				4:  uint8(193),
 				5:  uint8(185),
 				6:  uint8(249),
 				7:  uint8(198),
 				8:  uint8(255),
 				9:  uint8(255),
 				10: uint8(128),
 			},
 			2: {
 				0:  uint8(73),
 				1:  uint8(17),
 				2:  uint8(171),
 				3:  uint8(221),
 				4:  uint8(161),
 				5:  uint8(179),
 				6:  uint8(236),
 				7:  uint8(167),
 				8:  uint8(255),
 				9:  uint8(234),
 				10: uint8(128),
 			},
 		},
 		1: {
 			0: {
 				0:  uint8(1),
 				1:  uint8(95),
 				2:  uint8(247),
 				3:  uint8(253),
 				4:  uint8(212),
 				5:  uint8(183),
 				6:  uint8(255),
 				7:  uint8(255),
 				8:  uint8(128),
 				9:  uint8(128),
 				10: uint8(128),
 			},
 			1: {
 				0:  uint8(239),
 				1:  uint8(90),
 				2:  uint8(244),
 				3:  uint8(250),
 				4:  uint8(211),
 				5:  uint8(209),
 				6:  uint8(255),
 				7:  uint8(255),
 				8:  uint8(128),
 				9:  uint8(128),
 				10: uint8(128),
 			},
 			2: {
 				0:  uint8(155),
 				1:  uint8(77),
 				2:  uint8(195),
 				3:  uint8(248),
 				4:  uint8(188),
 				5:  uint8(195),
 				6:  uint8(255),
 				7:  uint8(255),
 				8:  uint8(128),
 				9:  uint8(128),
 				10: uint8(128),
 			},
 		},
 		2: {
 			0: {
 				0:  uint8(1),
 				1:  uint8(24),
 				2:  uint8(239),
 				3:  uint8(251),
 				4:  uint8(218),
 				5:  uint8(219),
 				6:  uint8(255),
 				7:  uint8(205),
 				8:  uint8(128),
 				9:  uint8(128),
 				10: uint8(128),
 			},
 			1: {
 				0:  uint8(201),
 				1:  uint8(51),
 				2:  uint8(219),
 				3:  uint8(255),
 				4:  uint8(196),
 				5:  uint8(186),
 				6:  uint8(128),
 				7:  uint8(128),
 				8:  uint8(128),
 				9:  uint8(128),
 				10: uint8(128),
 			},
 			2: {
 				0:  uint8(69),
 				1:  uint8(46),
 				2:  uint8(190),
 				3:  uint8(239),
 				4:  uint8(201),
 				5:  uint8(218),
 				6:  uint8(255),
 				7:  uint8(228),
 				8:  uint8(128),
 				9:  uint8(128),
 				10: uint8(128),
 			},
 		},
 		3: {
 			0: {
 				0:  uint8(1),
 				1:  uint8(191),
 				2:  uint8(251),
 				3:  uint8(255),
 				4:  uint8(255),
 				5:  uint8(128),
 				6:  uint8(128),
 				7:  uint8(128),
 				8:  uint8(128),
 				9:  uint8(128),
 				10: uint8(128),
 			},
 			1: {
 				0:  uint8(223),
 				1:  uint8(165),
 				2:  uint8(249),
 				3:  uint8(255),
 				4:  uint8(213),
 				5:  uint8(255),
 				6:  uint8(128),
 				7:  uint8(128),
 				8:  uint8(128),
 				9:  uint8(128),
 				10: uint8(128),
 			},
 			2: {
 				0:  uint8(141),
 				1:  uint8(124),
 				2:  uint8(248),
 				3:  uint8(255),
 				4:  uint8(255),
 				5:  uint8(128),
 				6:  uint8(128),
 				7:  uint8(128),
 				8:  uint8(128),
 				9:  uint8(128),
 				10: uint8(128),
 			},
 		},
 		4: {
 			0: {
 				0:  uint8(1),
 				1:  uint8(16),
 				2:  uint8(248),
 				3:  uint8(255),
 				4:  uint8(255),
 				5:  uint8(128),
 				6:  uint8(128),
 				7:  uint8(128),
 				8:  uint8(128),
 				9:  uint8(128),
 				10: uint8(128),
 			},
 			1: {
 				0:  uint8(190),
 				1:  uint8(36),
 				2:  uint8(230),
 				3:  uint8(255),
 				4:  uint8(236),
 				5:  uint8(255),
 				6:  uint8(128),
 				7:  uint8(128),
 				8:  uint8(128),
 				9:  uint8(128),
 				10: uint8(128),
 			},
 			2: {
 				0:  uint8(149),
 				1:  uint8(1),
 				2:  uint8(255),
 				3:  uint8(128),
 				4:  uint8(128),
 				5:  uint8(128),
 				6:  uint8(128),
 				7:  uint8(128),
 				8:  uint8(128),
 				9:  uint8(128),
 				10: uint8(128),
 			},
 		},
 		5: {
 			0: {
 				0:  uint8(1),
 				1:  uint8(226),
 				2:  uint8(255),
 				3:  uint8(128),
 				4:  uint8(128),
 				5:  uint8(128),
 				6:  uint8(128),
 				7:  uint8(128),
 				8:  uint8(128),
 				9:  uint8(128),
 				10: uint8(128),
 			},
 			1: {
 				0:  uint8(247),
 				1:  uint8(192),
 				2:  uint8(255),
 				3:  uint8(128),
 				4:  uint8(128),
 				5:  uint8(128),
 				6:  uint8(128),
 				7:  uint8(128),
 				8:  uint8(128),
 				9:  uint8(128),
 				10: uint8(128),
 			},
 			2: {
 				0:  uint8(240),
 				1:  uint8(128),
 				2:  uint8(255),
 				3:  uint8(128),
 				4:  uint8(128),
 				5:  uint8(128),
 				6:  uint8(128),
 				7:  uint8(128),
 				8:  uint8(128),
 				9:  uint8(128),
 				10: uint8(128),
 			},
 		},
 		6: {
 			0: {
 				0:  uint8(1),
 				1:  uint8(134),
 				2:  uint8(252),
 				3:  uint8(255),
 				4:  uint8(255),
 				5:  uint8(128),
 				6:  uint8(128),
 				7:  uint8(128),
 				8:  uint8(128),
 				9:  uint8(128),
 				10: uint8(128),
 			},
 			1: {
 				0:  uint8(213),
 				1:  uint8(62),
 				2:  uint8(250),
 				3:  uint8(255),
 				4:  uint8(255),
 				5:  uint8(128),
 				6:  uint8(128),
 				7:  uint8(128),
 				8:  uint8(128),
 				9:  uint8(128),
 				10: uint8(128),
 			},
 			2: {
 				0:  uint8(55),
 				1:  uint8(93),
 				2:  uint8(255),
 				3:  uint8(128),
 				4:  uint8(128),
 				5:  uint8(128),
 				6:  uint8(128),
 				7:  uint8(128),
 				8:  uint8(128),
 				9:  uint8(128),
 				10: uint8(128),
 			},
 		},
 		7: {
 			0: {
 				0:  uint8(128),
 				1:  uint8(128),
 				2:  uint8(128),
 				3:  uint8(128),
 				4:  uint8(128),
 				5:  uint8(128),
 				6:  uint8(128),
 				7:  uint8(128),
 				8:  uint8(128),
 				9:  uint8(128),
 				10: uint8(128),
 			},
 			1: {
 				0:  uint8(128),
 				1:  uint8(128),
 				2:  uint8(128),
 				3:  uint8(128),
 				4:  uint8(128),
 				5:  uint8(128),
 				6:  uint8(128),
 				7:  uint8(128),
 				8:  uint8(128),
 				9:  uint8(128),
 				10: uint8(128),
 			},
 			2: {
 				0:  uint8(128),
 				1:  uint8(128),
 				2:  uint8(128),
 				3:  uint8(128),
 				4:  uint8(128),
 				5:  uint8(128),
 				6:  uint8(128),
 				7:  uint8(128),
 				8:  uint8(128),
 				9:  uint8(128),
 				10: uint8(128),
 			},
 		},
 	},
 	3: {
 		0: {
 			0: {
 				0:  uint8(202),
 				1:  uint8(24),
 				2:  uint8(213),
 				3:  uint8(235),
 				4:  uint8(186),
 				5:  uint8(191),
 				6:  uint8(220),
 				7:  uint8(160),
 				8:  uint8(240),
 				9:  uint8(175),
 				10: uint8(255),
 			},
 			1: {
 				0:  uint8(126),
 				1:  uint8(38),
 				2:  uint8(182),
 				3:  uint8(232),
 				4:  uint8(169),
 				5:  uint8(184),
 				6:  uint8(228),
 				7:  uint8(174),
 				8:  uint8(255),
 				9:  uint8(187),
 				10: uint8(128),
 			},
 			2: {
 				0:  uint8(61),
 				1:  uint8(46),
 				2:  uint8(138),
 				3:  uint8(219),
 				4:  uint8(151),
 				5:  uint8(178),
 				6:  uint8(240),
 				7:  uint8(170),
 				8:  uint8(255),
 				9:  uint8(216),
 				10: uint8(128),
 			},
 		},
 		1: {
 			0: {
 				0:  uint8(1),
 				1:  uint8(112),
 				2:  uint8(230),
 				3:  uint8(250),
 				4:  uint8(199),
 				5:  uint8(191),
 				6:  uint8(247),
 				7:  uint8(159),
 				8:  uint8(255),
 				9:  uint8(255),
 				10: uint8(128),
 			},
 			1: {
 				0:  uint8(166),
 				1:  uint8(109),
 				2:  uint8(228),
 				3:  uint8(252),
 				4:  uint8(211),
 				5:  uint8(215),
 				6:  uint8(255),
 				7:  uint8(174),
 				8:  uint8(128),
 				9:  uint8(128),
 				10: uint8(128),
 			},
 			2: {
 				0:  uint8(39),
 				1:  uint8(77),
 				2:  uint8(162),
 				3:  uint8(232),
 				4:  uint8(172),
 				5:  uint8(180),
 				6:  uint8(245),
 				7:  uint8(178),
 				8:  uint8(255),
 				9:  uint8(255),
 				10: uint8(128),
 			},
 		},
 		2: {
 			0: {
 				0:  uint8(1),
 				1:  uint8(52),
 				2:  uint8(220),
 				3:  uint8(246),
 				4:  uint8(198),
 				5:  uint8(199),
 				6:  uint8(249),
 				7:  uint8(220),
 				8:  uint8(255),
 				9:  uint8(255),
 				10: uint8(128),
 			},
 			1: {
 				0:  uint8(124),
 				1:  uint8(74),
 				2:  uint8(191),
 				3:  uint8(243),
 				4:  uint8(183),
 				5:  uint8(193),
 				6:  uint8(250),
 				7:  uint8(221),
 				8:  uint8(255),
 				9:  uint8(255),
 				10: uint8(128),
 			},
 			2: {
 				0:  uint8(24),
 				1:  uint8(71),
 				2:  uint8(130),
 				3:  uint8(219),
 				4:  uint8(154),
 				5:  uint8(170),
 				6:  uint8(243),
 				7:  uint8(182),
 				8:  uint8(255),
 				9:  uint8(255),
 				10: uint8(128),
 			},
 		},
 		3: {
 			0: {
 				0:  uint8(1),
 				1:  uint8(182),
 				2:  uint8(225),
 				3:  uint8(249),
 				4:  uint8(219),
 				5:  uint8(240),
 				6:  uint8(255),
 				7:  uint8(224),
 				8:  uint8(128),
 				9:  uint8(128),
 				10: uint8(128),
 			},
 			1: {
 				0:  uint8(149),
 				1:  uint8(150),
 				2:  uint8(226),
 				3:  uint8(252),
 				4:  uint8(216),
 				5:  uint8(205),
 				6:  uint8(255),
 				7:  uint8(171),
 				8:  uint8(128),
 				9:  uint8(128),
 				10: uint8(128),
 			},
 			2: {
 				0:  uint8(28),
 				1:  uint8(108),
 				2:  uint8(170),
 				3:  uint8(242),
 				4:  uint8(183),
 				5:  uint8(194),
 				6:  uint8(254),
 				7:  uint8(223),
 				8:  uint8(255),
 				9:  uint8(255),
 				10: uint8(128),
 			},
 		},
 		4: {
 			0: {
 				0:  uint8(1),
 				1:  uint8(81),
 				2:  uint8(230),
 				3:  uint8(252),
 				4:  uint8(204),
 				5:  uint8(203),
 				6:  uint8(255),
 				7:  uint8(192),
 				8:  uint8(128),
 				9:  uint8(128),
 				10: uint8(128),
 			},
 			1: {
 				0:  uint8(123),
 				1:  uint8(102),
 				2:  uint8(209),
 				3:  uint8(247),
 				4:  uint8(188),
 				5:  uint8(196),
 				6:  uint8(255),
 				7:  uint8(233),
 				8:  uint8(128),
 				9:  uint8(128),
 				10: uint8(128),
 			},
 			2: {
 				0:  uint8(20),
 				1:  uint8(95),
 				2:  uint8(153),
 				3:  uint8(243),
 				4:  uint8(164),
 				5:  uint8(173),
 				6:  uint8(255),
 				7:  uint8(203),
 				8:  uint8(128),
 				9:  uint8(128),
 				10: uint8(128),
 			},
 		},
 		5: {
 			0: {
 				0:  uint8(1),
 				1:  uint8(222),
 				2:  uint8(248),
 				3:  uint8(255),
 				4:  uint8(216),
 				5:  uint8(213),
 				6:  uint8(128),
 				7:  uint8(128),
 				8:  uint8(128),
 				9:  uint8(128),
 				10: uint8(128),
 			},
 			1: {
 				0:  uint8(168),
 				1:  uint8(175),
 				2:  uint8(246),
 				3:  uint8(252),
 				4:  uint8(235),
 				5:  uint8(205),
 				6:  uint8(255),
 				7:  uint8(255),
 				8:  uint8(128),
 				9:  uint8(128),
 				10: uint8(128),
 			},
 			2: {
 				0:  uint8(47),
 				1:  uint8(116),
 				2:  uint8(215),
 				3:  uint8(255),
 				4:  uint8(211),
 				5:  uint8(212),
 				6:  uint8(255),
 				7:  uint8(255),
 				8:  uint8(128),
 				9:  uint8(128),
 				10: uint8(128),
 			},
 		},
 		6: {
 			0: {
 				0:  uint8(1),
 				1:  uint8(121),
 				2:  uint8(236),
 				3:  uint8(253),
 				4:  uint8(212),
 				5:  uint8(214),
 				6:  uint8(255),
 				7:  uint8(255),
 				8:  uint8(128),
 				9:  uint8(128),
 				10: uint8(128),
 			},
 			1: {
 				0:  uint8(141),
 				1:  uint8(84),
 				2:  uint8(213),
 				3:  uint8(252),
 				4:  uint8(201),
 				5:  uint8(202),
 				6:  uint8(255),
 				7:  uint8(219),
 				8:  uint8(128),
 				9:  uint8(128),
 				10: uint8(128),
 			},
 			2: {
 				0:  uint8(42),
 				1:  uint8(80),
 				2:  uint8(160),
 				3:  uint8(240),
 				4:  uint8(162),
 				5:  uint8(185),
 				6:  uint8(255),
 				7:  uint8(205),
 				8:  uint8(128),
 				9:  uint8(128),
 				10: uint8(128),
 			},
 		},
 		7: {
 			0: {
 				0:  uint8(1),
 				1:  uint8(1),
 				2:  uint8(255),
 				3:  uint8(128),
 				4:  uint8(128),
 				5:  uint8(128),
 				6:  uint8(128),
 				7:  uint8(128),
 				8:  uint8(128),
 				9:  uint8(128),
 				10: uint8(128),
 			},
 			1: {
 				0:  uint8(244),
 				1:  uint8(1),
 				2:  uint8(255),
 				3:  uint8(128),
 				4:  uint8(128),
 				5:  uint8(128),
 				6:  uint8(128),
 				7:  uint8(128),
 				8:  uint8(128),
 				9:  uint8(128),
 				10: uint8(128),
 			},
 			2: {
 				0:  uint8(238),
 				1:  uint8(1),
 				2:  uint8(255),
 				3:  uint8(128),
 				4:  uint8(128),
 				5:  uint8(128),
 				6:  uint8(128),
 				7:  uint8(128),
 				8:  uint8(128),
 				9:  uint8(128),
 				10: uint8(128),
 			},
 		},
 	},
 }
 
 //------------------------------------------------------------------------------
 // Paragraph 13
 
 var VP8CoeffsUpdateProba = [4][8][3][11]uint8_t{
 	0: {
 		0: {
 			0: {
 				0:  uint8(255),
 				1:  uint8(255),
 				2:  uint8(255),
 				3:  uint8(255),
 				4:  uint8(255),
 				5:  uint8(255),
 				6:  uint8(255),
 				7:  uint8(255),
 				8:  uint8(255),
 				9:  uint8(255),
 				10: uint8(255),
 			},
 			1: {
 				0:  uint8(255),
 				1:  uint8(255),
 				2:  uint8(255),
 				3:  uint8(255),
 				4:  uint8(255),
 				5:  uint8(255),
 				6:  uint8(255),
 				7:  uint8(255),
 				8:  uint8(255),
 				9:  uint8(255),
 				10: uint8(255),
 			},
 			2: {
 				0:  uint8(255),
 				1:  uint8(255),
 				2:  uint8(255),
 				3:  uint8(255),
 				4:  uint8(255),
 				5:  uint8(255),
 				6:  uint8(255),
 				7:  uint8(255),
 				8:  uint8(255),
 				9:  uint8(255),
 				10: uint8(255),
 			},
 		},
 		1: {
 			0: {
 				0:  uint8(176),
 				1:  uint8(246),
 				2:  uint8(255),
 				3:  uint8(255),
 				4:  uint8(255),
 				5:  uint8(255),
 				6:  uint8(255),
 				7:  uint8(255),
 				8:  uint8(255),
 				9:  uint8(255),
 				10: uint8(255),
 			},
 			1: {
 				0:  uint8(223),
 				1:  uint8(241),
 				2:  uint8(252),
 				3:  uint8(255),
 				4:  uint8(255),
 				5:  uint8(255),
 				6:  uint8(255),
 				7:  uint8(255),
 				8:  uint8(255),
 				9:  uint8(255),
 				10: uint8(255),
 			},
 			2: {
 				0:  uint8(249),
 				1:  uint8(253),
 				2:  uint8(253),
 				3:  uint8(255),
 				4:  uint8(255),
 				5:  uint8(255),
 				6:  uint8(255),
 				7:  uint8(255),
 				8:  uint8(255),
 				9:  uint8(255),
 				10: uint8(255),
 			},
 		},
 		2: {
 			0: {
 				0:  uint8(255),
 				1:  uint8(244),
 				2:  uint8(252),
 				3:  uint8(255),
 				4:  uint8(255),
 				5:  uint8(255),
 				6:  uint8(255),
 				7:  uint8(255),
 				8:  uint8(255),
 				9:  uint8(255),
 				10: uint8(255),
 			},
 			1: {
 				0:  uint8(234),
 				1:  uint8(254),
 				2:  uint8(254),
 				3:  uint8(255),
 				4:  uint8(255),
 				5:  uint8(255),
 				6:  uint8(255),
 				7:  uint8(255),
 				8:  uint8(255),
 				9:  uint8(255),
 				10: uint8(255),
 			},
 			2: {
 				0:  uint8(253),
 				1:  uint8(255),
 				2:  uint8(255),
 				3:  uint8(255),
 				4:  uint8(255),
 				5:  uint8(255),
 				6:  uint8(255),
 				7:  uint8(255),
 				8:  uint8(255),
 				9:  uint8(255),
 				10: uint8(255),
 			},
 		},
 		3: {
 			0: {
 				0:  uint8(255),
 				1:  uint8(246),
 				2:  uint8(254),
 				3:  uint8(255),
 				4:  uint8(255),
 				5:  uint8(255),
 				6:  uint8(255),
 				7:  uint8(255),
 				8:  uint8(255),
 				9:  uint8(255),
 				10: uint8(255),
 			},
 			1: {
 				0:  uint8(239),
 				1:  uint8(253),
 				2:  uint8(254),
 				3:  uint8(255),
 				4:  uint8(255),
 				5:  uint8(255),
 				6:  uint8(255),
 				7:  uint8(255),
 				8:  uint8(255),
 				9:  uint8(255),
 				10: uint8(255),
 			},
 			2: {
 				0:  uint8(254),
 				1:  uint8(255),
 				2:  uint8(254),
 				3:  uint8(255),
 				4:  uint8(255),
 				5:  uint8(255),
 				6:  uint8(255),
 				7:  uint8(255),
 				8:  uint8(255),
 				9:  uint8(255),
 				10: uint8(255),
 			},
 		},
 		4: {
 			0: {
 				0:  uint8(255),
 				1:  uint8(248),
 				2:  uint8(254),
 				3:  uint8(255),
 				4:  uint8(255),
 				5:  uint8(255),
 				6:  uint8(255),
 				7:  uint8(255),
 				8:  uint8(255),
 				9:  uint8(255),
 				10: uint8(255),
 			},
 			1: {
 				0:  uint8(251),
 				1:  uint8(255),
 				2:  uint8(254),
 				3:  uint8(255),
 				4:  uint8(255),
 				5:  uint8(255),
 				6:  uint8(255),
 				7:  uint8(255),
 				8:  uint8(255),
 				9:  uint8(255),
 				10: uint8(255),
 			},
 			2: {
 				0:  uint8(255),
 				1:  uint8(255),
 				2:  uint8(255),
 				3:  uint8(255),
 				4:  uint8(255),
 				5:  uint8(255),
 				6:  uint8(255),
 				7:  uint8(255),
 				8:  uint8(255),
 				9:  uint8(255),
 				10: uint8(255),
 			},
 		},
 		5: {
 			0: {
 				0:  uint8(255),
 				1:  uint8(253),
 				2:  uint8(254),
 				3:  uint8(255),
 				4:  uint8(255),
 				5:  uint8(255),
 				6:  uint8(255),
 				7:  uint8(255),
 				8:  uint8(255),
 				9:  uint8(255),
 				10: uint8(255),
 			},
 			1: {
 				0:  uint8(251),
 				1:  uint8(254),
 				2:  uint8(254),
 				3:  uint8(255),
 				4:  uint8(255),
 				5:  uint8(255),
 				6:  uint8(255),
 				7:  uint8(255),
 				8:  uint8(255),
 				9:  uint8(255),
 				10: uint8(255),
 			},
 			2: {
 				0:  uint8(254),
 				1:  uint8(255),
 				2:  uint8(254),
 				3:  uint8(255),
 				4:  uint8(255),
 				5:  uint8(255),
 				6:  uint8(255),
 				7:  uint8(255),
 				8:  uint8(255),
 				9:  uint8(255),
 				10: uint8(255),
 			},
 		},
 		6: {
 			0: {
 				0:  uint8(255),
 				1:  uint8(254),
 				2:  uint8(253),
 				3:  uint8(255),
 				4:  uint8(254),
 				5:  uint8(255),
 				6:  uint8(255),
 				7:  uint8(255),
 				8:  uint8(255),
 				9:  uint8(255),
 				10: uint8(255),
 			},
 			1: {
 				0:  uint8(250),
 				1:  uint8(255),
 				2:  uint8(254),
 				3:  uint8(255),
 				4:  uint8(254),
 				5:  uint8(255),
 				6:  uint8(255),
 				7:  uint8(255),
 				8:  uint8(255),
 				9:  uint8(255),
 				10: uint8(255),
 			},
 			2: {
 				0:  uint8(254),
 				1:  uint8(255),
 				2:  uint8(255),
 				3:  uint8(255),
 				4:  uint8(255),
 				5:  uint8(255),
 				6:  uint8(255),
 				7:  uint8(255),
 				8:  uint8(255),
 				9:  uint8(255),
 				10: uint8(255),
 			},
 		},
 		7: {
 			0: {
 				0:  uint8(255),
 				1:  uint8(255),
 				2:  uint8(255),
 				3:  uint8(255),
 				4:  uint8(255),
 				5:  uint8(255),
 				6:  uint8(255),
 				7:  uint8(255),
 				8:  uint8(255),
 				9:  uint8(255),
 				10: uint8(255),
 			},
 			1: {
 				0:  uint8(255),
 				1:  uint8(255),
 				2:  uint8(255),
 				3:  uint8(255),
 				4:  uint8(255),
 				5:  uint8(255),
 				6:  uint8(255),
 				7:  uint8(255),
 				8:  uint8(255),
 				9:  uint8(255),
 				10: uint8(255),
 			},
 			2: {
 				0:  uint8(255),
 				1:  uint8(255),
 				2:  uint8(255),
 				3:  uint8(255),
 				4:  uint8(255),
 				5:  uint8(255),
 				6:  uint8(255),
 				7:  uint8(255),
 				8:  uint8(255),
 				9:  uint8(255),
 				10: uint8(255),
 			},
 		},
 	},
 	1: {
 		0: {
 			0: {
 				0:  uint8(217),
 				1:  uint8(255),
 				2:  uint8(255),
 				3:  uint8(255),
 				4:  uint8(255),
 				5:  uint8(255),
 				6:  uint8(255),
 				7:  uint8(255),
 				8:  uint8(255),
 				9:  uint8(255),
 				10: uint8(255),
 			},
 			1: {
 				0:  uint8(225),
 				1:  uint8(252),
 				2:  uint8(241),
 				3:  uint8(253),
 				4:  uint8(255),
 				5:  uint8(255),
 				6:  uint8(254),
 				7:  uint8(255),
 				8:  uint8(255),
 				9:  uint8(255),
 				10: uint8(255),
 			},
 			2: {
 				0:  uint8(234),
 				1:  uint8(250),
 				2:  uint8(241),
 				3:  uint8(250),
 				4:  uint8(253),
 				5:  uint8(255),
 				6:  uint8(253),
 				7:  uint8(254),
 				8:  uint8(255),
 				9:  uint8(255),
 				10: uint8(255),
 			},
 		},
 		1: {
 			0: {
 				0:  uint8(255),
 				1:  uint8(254),
 				2:  uint8(255),
 				3:  uint8(255),
 				4:  uint8(255),
 				5:  uint8(255),
 				6:  uint8(255),
 				7:  uint8(255),
 				8:  uint8(255),
 				9:  uint8(255),
 				10: uint8(255),
 			},
 			1: {
 				0:  uint8(223),
 				1:  uint8(254),
 				2:  uint8(254),
 				3:  uint8(255),
 				4:  uint8(255),
 				5:  uint8(255),
 				6:  uint8(255),
 				7:  uint8(255),
 				8:  uint8(255),
 				9:  uint8(255),
 				10: uint8(255),
 			},
 			2: {
 				0:  uint8(238),
 				1:  uint8(253),
 				2:  uint8(254),
 				3:  uint8(254),
 				4:  uint8(255),
 				5:  uint8(255),
 				6:  uint8(255),
 				7:  uint8(255),
 				8:  uint8(255),
 				9:  uint8(255),
 				10: uint8(255),
 			},
 		},
 		2: {
 			0: {
 				0:  uint8(255),
 				1:  uint8(248),
 				2:  uint8(254),
 				3:  uint8(255),
 				4:  uint8(255),
 				5:  uint8(255),
 				6:  uint8(255),
 				7:  uint8(255),
 				8:  uint8(255),
 				9:  uint8(255),
 				10: uint8(255),
 			},
 			1: {
 				0:  uint8(249),
 				1:  uint8(254),
 				2:  uint8(255),
 				3:  uint8(255),
 				4:  uint8(255),
 				5:  uint8(255),
 				6:  uint8(255),
 				7:  uint8(255),
 				8:  uint8(255),
 				9:  uint8(255),
 				10: uint8(255),
 			},
 			2: {
 				0:  uint8(255),
 				1:  uint8(255),
 				2:  uint8(255),
 				3:  uint8(255),
 				4:  uint8(255),
 				5:  uint8(255),
 				6:  uint8(255),
 				7:  uint8(255),
 				8:  uint8(255),
 				9:  uint8(255),
 				10: uint8(255),
 			},
 		},
 		3: {
 			0: {
 				0:  uint8(255),
 				1:  uint8(253),
 				2:  uint8(255),
 				3:  uint8(255),
 				4:  uint8(255),
 				5:  uint8(255),
 				6:  uint8(255),
 				7:  uint8(255),
 				8:  uint8(255),
 				9:  uint8(255),
 				10: uint8(255),
 			},
 			1: {
 				0:  uint8(247),
 				1:  uint8(254),
 				2:  uint8(255),
 				3:  uint8(255),
 				4:  uint8(255),
 				5:  uint8(255),
 				6:  uint8(255),
 				7:  uint8(255),
 				8:  uint8(255),
 				9:  uint8(255),
 				10: uint8(255),
 			},
 			2: {
 				0:  uint8(255),
 				1:  uint8(255),
 				2:  uint8(255),
 				3:  uint8(255),
 				4:  uint8(255),
 				5:  uint8(255),
 				6:  uint8(255),
 				7:  uint8(255),
 				8:  uint8(255),
 				9:  uint8(255),
 				10: uint8(255),
 			},
 		},
 		4: {
 			0: {
 				0:  uint8(255),
 				1:  uint8(253),
 				2:  uint8(254),
 				3:  uint8(255),
 				4:  uint8(255),
 				5:  uint8(255),
 				6:  uint8(255),
 				7:  uint8(255),
 				8:  uint8(255),
 				9:  uint8(255),
 				10: uint8(255),
 			},
 			1: {
 				0:  uint8(252),
 				1:  uint8(255),
 				2:  uint8(255),
 				3:  uint8(255),
 				4:  uint8(255),
 				5:  uint8(255),
 				6:  uint8(255),
 				7:  uint8(255),
 				8:  uint8(255),
 				9:  uint8(255),
 				10: uint8(255),
 			},
 			2: {
 				0:  uint8(255),
 				1:  uint8(255),
 				2:  uint8(255),
 				3:  uint8(255),
 				4:  uint8(255),
 				5:  uint8(255),
 				6:  uint8(255),
 				7:  uint8(255),
 				8:  uint8(255),
 				9:  uint8(255),
 				10: uint8(255),
 			},
 		},
 		5: {
 			0: {
 				0:  uint8(255),
 				1:  uint8(254),
 				2:  uint8(254),
 				3:  uint8(255),
 				4:  uint8(255),
 				5:  uint8(255),
 				6:  uint8(255),
 				7:  uint8(255),
 				8:  uint8(255),
 				9:  uint8(255),
 				10: uint8(255),
 			},
 			1: {
 				0:  uint8(253),
 				1:  uint8(255),
 				2:  uint8(255),
 				3:  uint8(255),
 				4:  uint8(255),
 				5:  uint8(255),
 				6:  uint8(255),
 				7:  uint8(255),
 				8:  uint8(255),
 				9:  uint8(255),
 				10: uint8(255),
 			},
 			2: {
 				0:  uint8(255),
 				1:  uint8(255),
 				2:  uint8(255),
 				3:  uint8(255),
 				4:  uint8(255),
 				5:  uint8(255),
 				6:  uint8(255),
 				7:  uint8(255),
 				8:  uint8(255),
 				9:  uint8(255),
 				10: uint8(255),
 			},
 		},
 		6: {
 			0: {
 				0:  uint8(255),
 				1:  uint8(254),
 				2:  uint8(253),
 				3:  uint8(255),
 				4:  uint8(255),
 				5:  uint8(255),
 				6:  uint8(255),
 				7:  uint8(255),
 				8:  uint8(255),
 				9:  uint8(255),
 				10: uint8(255),
 			},
 			1: {
 				0:  uint8(250),
 				1:  uint8(255),
 				2:  uint8(255),
 				3:  uint8(255),
 				4:  uint8(255),
 				5:  uint8(255),
 				6:  uint8(255),
 				7:  uint8(255),
 				8:  uint8(255),
 				9:  uint8(255),
 				10: uint8(255),
 			},
 			2: {
 				0:  uint8(254),
 				1:  uint8(255),
 				2:  uint8(255),
 				3:  uint8(255),
 				4:  uint8(255),
 				5:  uint8(255),
 				6:  uint8(255),
 				7:  uint8(255),
 				8:  uint8(255),
 				9:  uint8(255),
 				10: uint8(255),
 			},
 		},
 		7: {
 			0: {
 				0:  uint8(255),
 				1:  uint8(255),
 				2:  uint8(255),
 				3:  uint8(255),
 				4:  uint8(255),
 				5:  uint8(255),
 				6:  uint8(255),
 				7:  uint8(255),
 				8:  uint8(255),
 				9:  uint8(255),
 				10: uint8(255),
 			},
 			1: {
 				0:  uint8(255),
 				1:  uint8(255),
 				2:  uint8(255),
 				3:  uint8(255),
 				4:  uint8(255),
 				5:  uint8(255),
 				6:  uint8(255),
 				7:  uint8(255),
 				8:  uint8(255),
 				9:  uint8(255),
 				10: uint8(255),
 			},
 			2: {
 				0:  uint8(255),
 				1:  uint8(255),
 				2:  uint8(255),
 				3:  uint8(255),
 				4:  uint8(255),
 				5:  uint8(255),
 				6:  uint8(255),
 				7:  uint8(255),
 				8:  uint8(255),
 				9:  uint8(255),
 				10: uint8(255),
 			},
 		},
 	},
 	2: {
 		0: {
 			0: {
 				0:  uint8(186),
 				1:  uint8(251),
 				2:  uint8(250),
 				3:  uint8(255),
 				4:  uint8(255),
 				5:  uint8(255),
 				6:  uint8(255),
 				7:  uint8(255),
 				8:  uint8(255),
 				9:  uint8(255),
 				10: uint8(255),
 			},
 			1: {
 				0:  uint8(234),
 				1:  uint8(251),
 				2:  uint8(244),
 				3:  uint8(254),
 				4:  uint8(255),
 				5:  uint8(255),
 				6:  uint8(255),
 				7:  uint8(255),
 				8:  uint8(255),
 				9:  uint8(255),
 				10: uint8(255),
 			},
 			2: {
 				0:  uint8(251),
 				1:  uint8(251),
 				2:  uint8(243),
 				3:  uint8(253),
 				4:  uint8(254),
 				5:  uint8(255),
 				6:  uint8(254),
 				7:  uint8(255),
 				8:  uint8(255),
 				9:  uint8(255),
 				10: uint8(255),
 			},
 		},
 		1: {
 			0: {
 				0:  uint8(255),
 				1:  uint8(253),
 				2:  uint8(254),
 				3:  uint8(255),
 				4:  uint8(255),
 				5:  uint8(255),
 				6:  uint8(255),
 				7:  uint8(255),
 				8:  uint8(255),
 				9:  uint8(255),
 				10: uint8(255),
 			},
 			1: {
 				0:  uint8(236),
 				1:  uint8(253),
 				2:  uint8(254),
 				3:  uint8(255),
 				4:  uint8(255),
 				5:  uint8(255),
 				6:  uint8(255),
 				7:  uint8(255),
 				8:  uint8(255),
 				9:  uint8(255),
 				10: uint8(255),
 			},
 			2: {
 				0:  uint8(251),
 				1:  uint8(253),
 				2:  uint8(253),
 				3:  uint8(254),
 				4:  uint8(254),
 				5:  uint8(255),
 				6:  uint8(255),
 				7:  uint8(255),
 				8:  uint8(255),
 				9:  uint8(255),
 				10: uint8(255),
 			},
 		},
 		2: {
 			0: {
 				0:  uint8(255),
 				1:  uint8(254),
 				2:  uint8(254),
 				3:  uint8(255),
 				4:  uint8(255),
 				5:  uint8(255),
 				6:  uint8(255),
 				7:  uint8(255),
 				8:  uint8(255),
 				9:  uint8(255),
 				10: uint8(255),
 			},
 			1: {
 				0:  uint8(254),
 				1:  uint8(254),
 				2:  uint8(254),
 				3:  uint8(255),
 				4:  uint8(255),
 				5:  uint8(255),
 				6:  uint8(255),
 				7:  uint8(255),
 				8:  uint8(255),
 				9:  uint8(255),
 				10: uint8(255),
 			},
 			2: {
 				0:  uint8(255),
 				1:  uint8(255),
 				2:  uint8(255),
 				3:  uint8(255),
 				4:  uint8(255),
 				5:  uint8(255),
 				6:  uint8(255),
 				7:  uint8(255),
 				8:  uint8(255),
 				9:  uint8(255),
 				10: uint8(255),
 			},
 		},
 		3: {
 			0: {
 				0:  uint8(255),
 				1:  uint8(254),
 				2:  uint8(255),
 				3:  uint8(255),
 				4:  uint8(255),
 				5:  uint8(255),
 				6:  uint8(255),
 				7:  uint8(255),
 				8:  uint8(255),
 				9:  uint8(255),
 				10: uint8(255),
 			},
 			1: {
 				0:  uint8(254),
 				1:  uint8(254),
 				2:  uint8(255),
 				3:  uint8(255),
 				4:  uint8(255),
 				5:  uint8(255),
 				6:  uint8(255),
 				7:  uint8(255),
 				8:  uint8(255),
 				9:  uint8(255),
 				10: uint8(255),
 			},
 			2: {
 				0:  uint8(254),
 				1:  uint8(255),
 				2:  uint8(255),
 				3:  uint8(255),
 				4:  uint8(255),
 				5:  uint8(255),
 				6:  uint8(255),
 				7:  uint8(255),
 				8:  uint8(255),
 				9:  uint8(255),
 				10: uint8(255),
 			},
 		},
 		4: {
 			0: {
 				0:  uint8(255),
 				1:  uint8(255),
 				2:  uint8(255),
 				3:  uint8(255),
 				4:  uint8(255),
 				5:  uint8(255),
 				6:  uint8(255),
 				7:  uint8(255),
 				8:  uint8(255),
 				9:  uint8(255),
 				10: uint8(255),
 			},
 			1: {
 				0:  uint8(254),
 				1:  uint8(255),
 				2:  uint8(255),
 				3:  uint8(255),
 				4:  uint8(255),
 				5:  uint8(255),
 				6:  uint8(255),
 				7:  uint8(255),
 				8:  uint8(255),
 				9:  uint8(255),
 				10: uint8(255),
 			},
 			2: {
 				0:  uint8(255),
 				1:  uint8(255),
 				2:  uint8(255),
 				3:  uint8(255),
 				4:  uint8(255),
 				5:  uint8(255),
 				6:  uint8(255),
 				7:  uint8(255),
 				8:  uint8(255),
 				9:  uint8(255),
 				10: uint8(255),
 			},
 		},
 		5: {
 			0: {
 				0:  uint8(255),
 				1:  uint8(255),
 				2:  uint8(255),
 				3:  uint8(255),
 				4:  uint8(255),
 				5:  uint8(255),
 				6:  uint8(255),
 				7:  uint8(255),
 				8:  uint8(255),
 				9:  uint8(255),
 				10: uint8(255),
 			},
 			1: {
 				0:  uint8(255),
 				1:  uint8(255),
 				2:  uint8(255),
 				3:  uint8(255),
 				4:  uint8(255),
 				5:  uint8(255),
 				6:  uint8(255),
 				7:  uint8(255),
 				8:  uint8(255),
 				9:  uint8(255),
 				10: uint8(255),
 			},
 			2: {
 				0:  uint8(255),
 				1:  uint8(255),
 				2:  uint8(255),
 				3:  uint8(255),
 				4:  uint8(255),
 				5:  uint8(255),
 				6:  uint8(255),
 				7:  uint8(255),
 				8:  uint8(255),
 				9:  uint8(255),
 				10: uint8(255),
 			},
 		},
 		6: {
 			0: {
 				0:  uint8(255),
 				1:  uint8(255),
 				2:  uint8(255),
 				3:  uint8(255),
 				4:  uint8(255),
 				5:  uint8(255),
 				6:  uint8(255),
 				7:  uint8(255),
 				8:  uint8(255),
 				9:  uint8(255),
 				10: uint8(255),
 			},
 			1: {
 				0:  uint8(255),
 				1:  uint8(255),
 				2:  uint8(255),
 				3:  uint8(255),
 				4:  uint8(255),
 				5:  uint8(255),
 				6:  uint8(255),
 				7:  uint8(255),
 				8:  uint8(255),
 				9:  uint8(255),
 				10: uint8(255),
 			},
 			2: {
 				0:  uint8(255),
 				1:  uint8(255),
 				2:  uint8(255),
 				3:  uint8(255),
 				4:  uint8(255),
 				5:  uint8(255),
 				6:  uint8(255),
 				7:  uint8(255),
 				8:  uint8(255),
 				9:  uint8(255),
 				10: uint8(255),
 			},
 		},
 		7: {
 			0: {
 				0:  uint8(255),
 				1:  uint8(255),
 				2:  uint8(255),
 				3:  uint8(255),
 				4:  uint8(255),
 				5:  uint8(255),
 				6:  uint8(255),
 				7:  uint8(255),
 				8:  uint8(255),
 				9:  uint8(255),
 				10: uint8(255),
 			},
 			1: {
 				0:  uint8(255),
 				1:  uint8(255),
 				2:  uint8(255),
 				3:  uint8(255),
 				4:  uint8(255),
 				5:  uint8(255),
 				6:  uint8(255),
 				7:  uint8(255),
 				8:  uint8(255),
 				9:  uint8(255),
 				10: uint8(255),
 			},
 			2: {
 				0:  uint8(255),
 				1:  uint8(255),
 				2:  uint8(255),
 				3:  uint8(255),
 				4:  uint8(255),
 				5:  uint8(255),
 				6:  uint8(255),
 				7:  uint8(255),
 				8:  uint8(255),
 				9:  uint8(255),
 				10: uint8(255),
 			},
 		},
 	},
 	3: {
 		0: {
 			0: {
 				0:  uint8(248),
 				1:  uint8(255),
 				2:  uint8(255),
 				3:  uint8(255),
 				4:  uint8(255),
 				5:  uint8(255),
 				6:  uint8(255),
 				7:  uint8(255),
 				8:  uint8(255),
 				9:  uint8(255),
 				10: uint8(255),
 			},
 			1: {
 				0:  uint8(250),
 				1:  uint8(254),
 				2:  uint8(252),
 				3:  uint8(254),
 				4:  uint8(255),
 				5:  uint8(255),
 				6:  uint8(255),
 				7:  uint8(255),
 				8:  uint8(255),
 				9:  uint8(255),
 				10: uint8(255),
 			},
 			2: {
 				0:  uint8(248),
 				1:  uint8(254),
 				2:  uint8(249),
 				3:  uint8(253),
 				4:  uint8(255),
 				5:  uint8(255),
 				6:  uint8(255),
 				7:  uint8(255),
 				8:  uint8(255),
 				9:  uint8(255),
 				10: uint8(255),
 			},
 		},
 		1: {
 			0: {
 				0:  uint8(255),
 				1:  uint8(253),
 				2:  uint8(253),
 				3:  uint8(255),
 				4:  uint8(255),
 				5:  uint8(255),
 				6:  uint8(255),
 				7:  uint8(255),
 				8:  uint8(255),
 				9:  uint8(255),
 				10: uint8(255),
 			},
 			1: {
 				0:  uint8(246),
 				1:  uint8(253),
 				2:  uint8(253),
 				3:  uint8(255),
 				4:  uint8(255),
 				5:  uint8(255),
 				6:  uint8(255),
 				7:  uint8(255),
 				8:  uint8(255),
 				9:  uint8(255),
 				10: uint8(255),
 			},
 			2: {
 				0:  uint8(252),
 				1:  uint8(254),
 				2:  uint8(251),
 				3:  uint8(254),
 				4:  uint8(254),
 				5:  uint8(255),
 				6:  uint8(255),
 				7:  uint8(255),
 				8:  uint8(255),
 				9:  uint8(255),
 				10: uint8(255),
 			},
 		},
 		2: {
 			0: {
 				0:  uint8(255),
 				1:  uint8(254),
 				2:  uint8(252),
 				3:  uint8(255),
 				4:  uint8(255),
 				5:  uint8(255),
 				6:  uint8(255),
 				7:  uint8(255),
 				8:  uint8(255),
 				9:  uint8(255),
 				10: uint8(255),
 			},
 			1: {
 				0:  uint8(248),
 				1:  uint8(254),
 				2:  uint8(253),
 				3:  uint8(255),
 				4:  uint8(255),
 				5:  uint8(255),
 				6:  uint8(255),
 				7:  uint8(255),
 				8:  uint8(255),
 				9:  uint8(255),
 				10: uint8(255),
 			},
 			2: {
 				0:  uint8(253),
 				1:  uint8(255),
 				2:  uint8(254),
 				3:  uint8(254),
 				4:  uint8(255),
 				5:  uint8(255),
 				6:  uint8(255),
 				7:  uint8(255),
 				8:  uint8(255),
 				9:  uint8(255),
 				10: uint8(255),
 			},
 		},
 		3: {
 			0: {
 				0:  uint8(255),
 				1:  uint8(251),
 				2:  uint8(254),
 				3:  uint8(255),
 				4:  uint8(255),
 				5:  uint8(255),
 				6:  uint8(255),
 				7:  uint8(255),
 				8:  uint8(255),
 				9:  uint8(255),
 				10: uint8(255),
 			},
 			1: {
 				0:  uint8(245),
 				1:  uint8(251),
 				2:  uint8(254),
 				3:  uint8(255),
 				4:  uint8(255),
 				5:  uint8(255),
 				6:  uint8(255),
 				7:  uint8(255),
 				8:  uint8(255),
 				9:  uint8(255),
 				10: uint8(255),
 			},
 			2: {
 				0:  uint8(253),
 				1:  uint8(253),
 				2:  uint8(254),
 				3:  uint8(255),
 				4:  uint8(255),
 				5:  uint8(255),
 				6:  uint8(255),
 				7:  uint8(255),
 				8:  uint8(255),
 				9:  uint8(255),
 				10: uint8(255),
 			},
 		},
 		4: {
 			0: {
 				0:  uint8(255),
 				1:  uint8(251),
 				2:  uint8(253),
 				3:  uint8(255),
 				4:  uint8(255),
 				5:  uint8(255),
 				6:  uint8(255),
 				7:  uint8(255),
 				8:  uint8(255),
 				9:  uint8(255),
 				10: uint8(255),
 			},
 			1: {
 				0:  uint8(252),
 				1:  uint8(253),
 				2:  uint8(254),
 				3:  uint8(255),
 				4:  uint8(255),
 				5:  uint8(255),
 				6:  uint8(255),
 				7:  uint8(255),
 				8:  uint8(255),
 				9:  uint8(255),
 				10: uint8(255),
 			},
 			2: {
 				0:  uint8(255),
 				1:  uint8(254),
 				2:  uint8(255),
 				3:  uint8(255),
 				4:  uint8(255),
 				5:  uint8(255),
 				6:  uint8(255),
 				7:  uint8(255),
 				8:  uint8(255),
 				9:  uint8(255),
 				10: uint8(255),
 			},
 		},
 		5: {
 			0: {
 				0:  uint8(255),
 				1:  uint8(252),
 				2:  uint8(255),
 				3:  uint8(255),
 				4:  uint8(255),
 				5:  uint8(255),
 				6:  uint8(255),
 				7:  uint8(255),
 				8:  uint8(255),
 				9:  uint8(255),
 				10: uint8(255),
 			},
 			1: {
 				0:  uint8(249),
 				1:  uint8(255),
 				2:  uint8(254),
 				3:  uint8(255),
 				4:  uint8(255),
 				5:  uint8(255),
 				6:  uint8(255),
 				7:  uint8(255),
 				8:  uint8(255),
 				9:  uint8(255),
 				10: uint8(255),
 			},
 			2: {
 				0:  uint8(255),
 				1:  uint8(255),
 				2:  uint8(254),
 				3:  uint8(255),
 				4:  uint8(255),
 				5:  uint8(255),
 				6:  uint8(255),
 				7:  uint8(255),
 				8:  uint8(255),
 				9:  uint8(255),
 				10: uint8(255),
 			},
 		},
 		6: {
 			0: {
 				0:  uint8(255),
 				1:  uint8(255),
 				2:  uint8(253),
 				3:  uint8(255),
 				4:  uint8(255),
 				5:  uint8(255),
 				6:  uint8(255),
 				7:  uint8(255),
 				8:  uint8(255),
 				9:  uint8(255),
 				10: uint8(255),
 			},
 			1: {
 				0:  uint8(250),
 				1:  uint8(255),
 				2:  uint8(255),
 				3:  uint8(255),
 				4:  uint8(255),
 				5:  uint8(255),
 				6:  uint8(255),
 				7:  uint8(255),
 				8:  uint8(255),
 				9:  uint8(255),
 				10: uint8(255),
 			},
 			2: {
 				0:  uint8(255),
 				1:  uint8(255),
 				2:  uint8(255),
 				3:  uint8(255),
 				4:  uint8(255),
 				5:  uint8(255),
 				6:  uint8(255),
 				7:  uint8(255),
 				8:  uint8(255),
 				9:  uint8(255),
 				10: uint8(255),
 			},
 		},
 		7: {
 			0: {
 				0:  uint8(255),
 				1:  uint8(255),
 				2:  uint8(255),
 				3:  uint8(255),
 				4:  uint8(255),
 				5:  uint8(255),
 				6:  uint8(255),
 				7:  uint8(255),
 				8:  uint8(255),
 				9:  uint8(255),
 				10: uint8(255),
 			},
 			1: {
 				0:  uint8(254),
 				1:  uint8(255),
 				2:  uint8(255),
 				3:  uint8(255),
 				4:  uint8(255),
 				5:  uint8(255),
 				6:  uint8(255),
 				7:  uint8(255),
 				8:  uint8(255),
 				9:  uint8(255),
 				10: uint8(255),
 			},
 			2: {
 				0:  uint8(255),
 				1:  uint8(255),
 				2:  uint8(255),
 				3:  uint8(255),
 				4:  uint8(255),
 				5:  uint8(255),
 				6:  uint8(255),
 				7:  uint8(255),
 				8:  uint8(255),
 				9:  uint8(255),
 				10: uint8(255),
 			},
 		},
 	},
 }
 
 //------------------------------------------------------------------------------
 // Initialization
 
 // C documentation
 //
 //	// Speed-critical function pointers. We have to initialize them to the default
 //	// implementations within VP8EncDspInit().
 var VP8CollectHistogram VP8CHisto
 
 var VP8Copy16x8 VP8BlockCopy
 
 var VP8Copy4x4 VP8BlockCopy
 
 var VP8DitherCombine8x8 uintptr
 
 //------------------------------------------------------------------------------
 // Compute susceptibility based on DCT-coeff histograms:
 // the higher, the "easier" the macroblock is to compress.
 
 var VP8DspScan = [24]int32{
 	1:  libc.Int32FromInt32(4) + libc.Int32FromInt32(0)*libc.Int32FromInt32(BPS),
 	2:  libc.Int32FromInt32(8) + libc.Int32FromInt32(0)*libc.Int32FromInt32(BPS),
 	3:  libc.Int32FromInt32(12) + libc.Int32FromInt32(0)*libc.Int32FromInt32(BPS),
 	4:  libc.Int32FromInt32(0) + libc.Int32FromInt32(4)*libc.Int32FromInt32(BPS),
 	5:  libc.Int32FromInt32(4) + libc.Int32FromInt32(4)*libc.Int32FromInt32(BPS),
 	6:  libc.Int32FromInt32(8) + libc.Int32FromInt32(4)*libc.Int32FromInt32(BPS),
 	7:  libc.Int32FromInt32(12) + libc.Int32FromInt32(4)*libc.Int32FromInt32(BPS),
 	8:  libc.Int32FromInt32(0) + libc.Int32FromInt32(8)*libc.Int32FromInt32(BPS),
 	9:  libc.Int32FromInt32(4) + libc.Int32FromInt32(8)*libc.Int32FromInt32(BPS),
 	10: libc.Int32FromInt32(8) + libc.Int32FromInt32(8)*libc.Int32FromInt32(BPS),
 	11: libc.Int32FromInt32(12) + libc.Int32FromInt32(8)*libc.Int32FromInt32(BPS),
 	12: libc.Int32FromInt32(0) + libc.Int32FromInt32(12)*libc.Int32FromInt32(BPS),
 	13: libc.Int32FromInt32(4) + libc.Int32FromInt32(12)*libc.Int32FromInt32(BPS),
 	14: libc.Int32FromInt32(8) + libc.Int32FromInt32(12)*libc.Int32FromInt32(BPS),
 	15: libc.Int32FromInt32(12) + libc.Int32FromInt32(12)*libc.Int32FromInt32(BPS),
 	17: libc.Int32FromInt32(4) + libc.Int32FromInt32(0)*libc.Int32FromInt32(BPS),
 	18: libc.Int32FromInt32(0) + libc.Int32FromInt32(4)*libc.Int32FromInt32(BPS),
 	19: libc.Int32FromInt32(4) + libc.Int32FromInt32(4)*libc.Int32FromInt32(BPS),
 	20: libc.Int32FromInt32(8) + libc.Int32FromInt32(0)*libc.Int32FromInt32(BPS),
 	21: libc.Int32FromInt32(12) + libc.Int32FromInt32(0)*libc.Int32FromInt32(BPS),
 	22: libc.Int32FromInt32(8) + libc.Int32FromInt32(4)*libc.Int32FromInt32(BPS),
 	23: libc.Int32FromInt32(12) + libc.Int32FromInt32(4)*libc.Int32FromInt32(BPS),
 }
 
 //------------------------------------------------------------------------------
 // Tables for level coding
 
 var VP8EncBands = [17]uint8_t{
 	1:  uint8(1),
 	2:  uint8(2),
 	3:  uint8(3),
 	4:  uint8(6),
 	5:  uint8(4),
 	6:  uint8(5),
 	7:  uint8(6),
 	8:  uint8(6),
 	9:  uint8(6),
 	10: uint8(6),
 	11: uint8(6),
 	12: uint8(6),
 	13: uint8(6),
 	14: uint8(6),
 	15: uint8(7),
 }
 
 var VP8EncPredChroma8 VP8IntraPreds
 
 var VP8EncPredLuma16 VP8IntraPreds
 
 var VP8EncPredLuma4 VP8Intra4Preds
 
 var VP8EncQuantize2Blocks VP8Quantize2Blocks
 
 var VP8EncQuantizeBlock VP8QuantizeBlock
 
 var VP8EncQuantizeBlockWHT VP8QuantizeBlockWHT
 
 //------------------------------------------------------------------------------
 
 // Copyright 2011 Google Inc. All Rights Reserved.
 //
 // Use of this source code is governed by a BSD-style license
 // that can be found in the COPYING file in the root of the source
 // tree. An additional intellectual property rights grant can be found
 // in the file PATENTS. All contributing project authors may
 // be found in the AUTHORS file in the root of the source tree.
 // -----------------------------------------------------------------------------
 //
 //   WebP encoder: internal header.
 //
 // Author: Skal (pascal.massimino@gmail.com)
 
 //------------------------------------------------------------------------------
 // Boolean-cost cost table
 
 var VP8EntropyCost = [256]uint16_t{
 	0:   uint16(1792),
 	1:   uint16(1792),
 	2:   uint16(1792),
 	3:   uint16(1536),
 	4:   uint16(1536),
 	5:   uint16(1408),
 	6:   uint16(1366),
 	7:   uint16(1280),
 	8:   uint16(1280),
 	9:   uint16(1216),
 	10:  uint16(1178),
 	11:  uint16(1152),
 	12:  uint16(1110),
 	13:  uint16(1076),
 	14:  uint16(1061),
 	15:  uint16(1024),
 	16:  uint16(1024),
 	17:  uint16(992),
 	18:  uint16(968),
 	19:  uint16(951),
 	20:  uint16(939),
 	21:  uint16(911),
 	22:  uint16(896),
 	23:  uint16(878),
 	24:  uint16(871),
 	25:  uint16(854),
 	26:  uint16(838),
 	27:  uint16(820),
 	28:  uint16(811),
 	29:  uint16(794),
 	30:  uint16(786),
 	31:  uint16(768),
 	32:  uint16(768),
 	33:  uint16(752),
 	34:  uint16(740),
 	35:  uint16(732),
 	36:  uint16(720),
 	37:  uint16(709),
 	38:  uint16(704),
 	39:  uint16(690),
 	40:  uint16(683),
 	41:  uint16(672),
 	42:  uint16(666),
 	43:  uint16(655),
 	44:  uint16(647),
 	45:  uint16(640),
 	46:  uint16(631),
 	47:  uint16(622),
 	48:  uint16(615),
 	49:  uint16(607),
 	50:  uint16(598),
 	51:  uint16(592),
 	52:  uint16(586),
 	53:  uint16(576),
 	54:  uint16(572),
 	55:  uint16(564),
 	56:  uint16(559),
 	57:  uint16(555),
 	58:  uint16(547),
 	59:  uint16(541),
 	60:  uint16(534),
 	61:  uint16(528),
 	62:  uint16(522),
 	63:  uint16(512),
 	64:  uint16(512),
 	65:  uint16(504),
 	66:  uint16(500),
 	67:  uint16(494),
 	68:  uint16(488),
 	69:  uint16(483),
 	70:  uint16(477),
 	71:  uint16(473),
 	72:  uint16(467),
 	73:  uint16(461),
 	74:  uint16(458),
 	75:  uint16(452),
 	76:  uint16(448),
 	77:  uint16(443),
 	78:  uint16(438),
 	79:  uint16(434),
 	80:  uint16(427),
 	81:  uint16(424),
 	82:  uint16(419),
 	83:  uint16(415),
 	84:  uint16(410),
 	85:  uint16(406),
 	86:  uint16(403),
 	87:  uint16(399),
 	88:  uint16(394),
 	89:  uint16(390),
 	90:  uint16(384),
 	91:  uint16(384),
 	92:  uint16(377),
 	93:  uint16(374),
 	94:  uint16(370),
 	95:  uint16(366),
 	96:  uint16(362),
 	97:  uint16(359),
 	98:  uint16(355),
 	99:  uint16(351),
 	100: uint16(347),
 	101: uint16(342),
 	102: uint16(342),
 	103: uint16(336),
 	104: uint16(333),
 	105: uint16(330),
 	106: uint16(326),
 	107: uint16(323),
 	108: uint16(320),
 	109: uint16(316),
 	110: uint16(312),
 	111: uint16(308),
 	112: uint16(305),
 	113: uint16(302),
 	114: uint16(299),
 	115: uint16(296),
 	116: uint16(293),
 	117: uint16(288),
 	118: uint16(287),
 	119: uint16(283),
 	120: uint16(280),
 	121: uint16(277),
 	122: uint16(274),
 	123: uint16(272),
 	124: uint16(268),
 	125: uint16(266),
 	126: uint16(262),
 	127: uint16(256),
 	128: uint16(256),
 	129: uint16(256),
 	130: uint16(251),
 	131: uint16(248),
 	132: uint16(245),
 	133: uint16(242),
 	134: uint16(240),
 	135: uint16(237),
 	136: uint16(234),
 	137: uint16(232),
 	138: uint16(228),
 	139: uint16(226),
 	140: uint16(223),
 	141: uint16(221),
 	142: uint16(218),
 	143: uint16(216),
 	144: uint16(214),
 	145: uint16(211),
 	146: uint16(208),
 	147: uint16(205),
 	148: uint16(203),
 	149: uint16(201),
 	150: uint16(198),
 	151: uint16(196),
 	152: uint16(192),
 	153: uint16(191),
 	154: uint16(188),
 	155: uint16(187),
 	156: uint16(183),
 	157: uint16(181),
 	158: uint16(179),
 	159: uint16(176),
 	160: uint16(175),
 	161: uint16(171),
 	162: uint16(171),
 	163: uint16(168),
 	164: uint16(165),
 	165: uint16(163),
 	166: uint16(160),
 	167: uint16(159),
 	168: uint16(156),
 	169: uint16(154),
 	170: uint16(152),
 	171: uint16(150),
 	172: uint16(148),
 	173: uint16(146),
 	174: uint16(144),
 	175: uint16(142),
 	176: uint16(139),
 	177: uint16(138),
 	178: uint16(135),
 	179: uint16(133),
 	180: uint16(131),
 	181: uint16(128),
 	182: uint16(128),
 	183: uint16(125),
 	184: uint16(123),
 	185: uint16(121),
 	186: uint16(119),
 	187: uint16(117),
 	188: uint16(115),
 	189: uint16(113),
 	190: uint16(111),
 	191: uint16(110),
 	192: uint16(107),
 	193: uint16(105),
 	194: uint16(103),
 	195: uint16(102),
 	196: uint16(100),
 	197: uint16(98),
 	198: uint16(96),
 	199: uint16(94),
 	200: uint16(92),
 	201: uint16(91),
 	202: uint16(89),
 	203: uint16(86),
 	204: uint16(86),
 	205: uint16(83),
 	206: uint16(82),
 	207: uint16(80),
 	208: uint16(77),
 	209: uint16(76),
 	210: uint16(74),
 	211: uint16(73),
 	212: uint16(71),
 	213: uint16(69),
 	214: uint16(67),
 	215: uint16(66),
 	216: uint16(64),
 	217: uint16(63),
 	218: uint16(61),
 	219: uint16(59),
 	220: uint16(57),
 	221: uint16(55),
 	222: uint16(54),
 	223: uint16(52),
 	224: uint16(51),
 	225: uint16(49),
 	226: uint16(47),
 	227: uint16(46),
 	228: uint16(44),
 	229: uint16(43),
 	230: uint16(41),
 	231: uint16(40),
 	232: uint16(38),
 	233: uint16(36),
 	234: uint16(35),
 	235: uint16(33),
 	236: uint16(32),
 	237: uint16(30),
 	238: uint16(29),
 	239: uint16(27),
 	240: uint16(25),
 	241: uint16(24),
 	242: uint16(22),
 	243: uint16(21),
 	244: uint16(19),
 	245: uint16(18),
 	246: uint16(16),
 	247: uint16(15),
 	248: uint16(13),
 	249: uint16(12),
 	250: uint16(10),
 	251: uint16(9),
 	252: uint16(7),
 	253: uint16(6),
 	254: uint16(4),
 	255: uint16(3),
 }
 
 var VP8FTransform VP8Fdct
 
 var VP8FTransform2 VP8Fdct
 
 var VP8FTransformWHT VP8WHT
 
 // C documentation
 //
 //	// note: these values include the fixed VP8BitCost(1, 145) mode selection cost.
 var VP8FixedCostsI16 = [4]uint16_t{
 	0: uint16(663),
 	1: uint16(919),
 	2: uint16(872),
 	3: uint16(919),
 }
 
 var VP8FixedCostsI4 = [10][10][10]uint16_t{
 	0: {
 		0: {
 			0: uint16(40),
 			1: uint16(1151),
 			2: uint16(1723),
 			3: uint16(1874),
 			4: uint16(2103),
 			5: uint16(2019),
 			6: uint16(1628),
 			7: uint16(1777),
 			8: uint16(2226),
 			9: uint16(2137),
 		},
 		1: {
 			0: uint16(192),
 			1: uint16(469),
 			2: uint16(1296),
 			3: uint16(1308),
 			4: uint16(1849),
 			5: uint16(1794),
 			6: uint16(1781),
 			7: uint16(1703),
 			8: uint16(1713),
 			9: uint16(1522),
 		},
 		2: {
 			0: uint16(142),
 			1: uint16(910),
 			2: uint16(762),
 			3: uint16(1684),
 			4: uint16(1849),
 			5: uint16(1576),
 			6: uint16(1460),
 			7: uint16(1305),
 			8: uint16(1801),
 			9: uint16(1657),
 		},
 		3: {
 			0: uint16(559),
 			1: uint16(641),
 			2: uint16(1370),
 			3: uint16(421),
 			4: uint16(1182),
 			5: uint16(1569),
 			6: uint16(1612),
 			7: uint16(1725),
 			8: uint16(863),
 			9: uint16(1007),
 		},
 		4: {
 			0: uint16(299),
 			1: uint16(1059),
 			2: uint16(1256),
 			3: uint16(1108),
 			4: uint16(636),
 			5: uint16(1068),
 			6: uint16(1581),
 			7: uint16(1883),
 			8: uint16(869),
 			9: uint16(1142),
 		},
 		5: {
 			0: uint16(277),
 			1: uint16(1111),
 			2: uint16(707),
 			3: uint16(1362),
 			4: uint16(1089),
 			5: uint16(672),
 			6: uint16(1603),
 			7: uint16(1541),
 			8: uint16(1545),
 			9: uint16(1291),
 		},
 		6: {
 			0: uint16(214),
 			1: uint16(781),
 			2: uint16(1609),
 			3: uint16(1303),
 			4: uint16(1632),
 			5: uint16(2229),
 			6: uint16(726),
 			7: uint16(1560),
 			8: uint16(1713),
 			9: uint16(918),
 		},
 		7: {
 			0: uint16(152),
 			1: uint16(1037),
 			2: uint16(1046),
 			3: uint16(1759),
 			4: uint16(1983),
 			5: uint16(2174),
 			6: uint16(1358),
 			7: uint16(742),
 			8: uint16(1740),
 			9: uint16(1390),
 		},
 		8: {
 			0: uint16(512),
 			1: uint16(1046),
 			2: uint16(1420),
 			3: uint16(753),
 			4: uint16(752),
 			5: uint16(1297),
 			6: uint16(1486),
 			7: uint16(1613),
 			8: uint16(460),
 			9: uint16(1207),
 		},
 		9: {
 			0: uint16(424),
 			1: uint16(827),
 			2: uint16(1362),
 			3: uint16(719),
 			4: uint16(1462),
 			5: uint16(1202),
 			6: uint16(1199),
 			7: uint16(1476),
 			8: uint16(1199),
 			9: uint16(538),
 		},
 	},
 	1: {
 		0: {
 			0: uint16(240),
 			1: uint16(402),
 			2: uint16(1134),
 			3: uint16(1491),
 			4: uint16(1659),
 			5: uint16(1505),
 			6: uint16(1517),
 			7: uint16(1555),
 			8: uint16(1979),
 			9: uint16(2099),
 		},
 		1: {
 			0: uint16(467),
 			1: uint16(242),
 			2: uint16(960),
 			3: uint16(1232),
 			4: uint16(1714),
 			5: uint16(1620),
 			6: uint16(1834),
 			7: uint16(1570),
 			8: uint16(1676),
 			9: uint16(1391),
 		},
 		2: {
 			0: uint16(500),
 			1: uint16(455),
 			2: uint16(463),
 			3: uint16(1507),
 			4: uint16(1699),
 			5: uint16(1282),
 			6: uint16(1564),
 			7: uint16(982),
 			8: uint16(2114),
 			9: uint16(2114),
 		},
 		3: {
 			0: uint16(672),
 			1: uint16(643),
 			2: uint16(1372),
 			3: uint16(331),
 			4: uint16(1589),
 			5: uint16(1667),
 			6: uint16(1453),
 			7: uint16(1938),
 			8: uint16(996),
 			9: uint16(876),
 		},
 		4: {
 			0: uint16(458),
 			1: uint16(783),
 			2: uint16(1037),
 			3: uint16(911),
 			4: uint16(738),
 			5: uint16(968),
 			6: uint16(1165),
 			7: uint16(1518),
 			8: uint16(859),
 			9: uint16(1033),
 		},
 		5: {
 			0: uint16(504),
 			1: uint16(815),
 			2: uint16(504),
 			3: uint16(1139),
 			4: uint16(1219),
 			5: uint16(719),
 			6: uint16(1506),
 			7: uint16(1085),
 			8: uint16(1268),
 			9: uint16(1268),
 		},
 		6: {
 			0: uint16(333),
 			1: uint16(630),
 			2: uint16(1445),
 			3: uint16(1239),
 			4: uint16(1883),
 			5: uint16(3672),
 			6: uint16(799),
 			7: uint16(1548),
 			8: uint16(1865),
 			9: uint16(598),
 		},
 		7: {
 			0: uint16(399),
 			1: uint16(644),
 			2: uint16(746),
 			3: uint16(1342),
 			4: uint16(1856),
 			5: uint16(1350),
 			6: uint16(1493),
 			7: uint16(613),
 			8: uint16(1855),
 			9: uint16(1015),
 		},
 		8: {
 			0: uint16(622),
 			1: uint16(749),
 			2: uint16(1205),
 			3: uint16(608),
 			4: uint16(1066),
 			5: uint16(1408),
 			6: uint16(1290),
 			7: uint16(1406),
 			8: uint16(546),
 			9: uint16(971),
 		},
 		9: {
 			0: uint16(500),
 			1: uint16(753),
 			2: uint16(1041),
 			3: uint16(668),
 			4: uint16(1230),
 			5: uint16(1617),
 			6: uint16(1297),
 			7: uint16(1425),
 			8: uint16(1383),
 			9: uint16(523),
 		},
 	},
 	2: {
 		0: {
 			0: uint16(394),
 			1: uint16(553),
 			2: uint16(523),
 			3: uint16(1502),
 			4: uint16(1536),
 			5: uint16(981),
 			6: uint16(1608),
 			7: uint16(1142),
 			8: uint16(1666),
 			9: uint16(2181),
 		},
 		1: {
 			0: uint16(655),
 			1: uint16(430),
 			2: uint16(375),
 			3: uint16(1411),
 			4: uint16(1861),
 			5: uint16(1220),
 			6: uint16(1677),
 			7: uint16(1135),
 			8: uint16(1978),
 			9: uint16(1553),
 		},
 		2: {
 			0: uint16(690),
 			1: uint16(640),
 			2: uint16(245),
 			3: uint16(1954),
 			4: uint16(2070),
 			5: uint16(1194),
 			6: uint16(1528),
 			7: uint16(982),
 			8: uint16(1972),
 			9: uint16(2232),
 		},
 		3: {
 			0: uint16(559),
 			1: uint16(834),
 			2: uint16(741),
 			3: uint16(867),
 			4: uint16(1131),
 			5: uint16(980),
 			6: uint16(1225),
 			7: uint16(852),
 			8: uint16(1092),
 			9: uint16(784),
 		},
 		4: {
 			0: uint16(690),
 			1: uint16(875),
 			2: uint16(516),
 			3: uint16(959),
 			4: uint16(673),
 			5: uint16(894),
 			6: uint16(1056),
 			7: uint16(1190),
 			8: uint16(1528),
 			9: uint16(1126),
 		},
 		5: {
 			0: uint16(740),
 			1: uint16(951),
 			2: uint16(384),
 			3: uint16(1277),
 			4: uint16(1177),
 			5: uint16(492),
 			6: uint16(1579),
 			7: uint16(1155),
 			8: uint16(1846),
 			9: uint16(1513),
 		},
 		6: {
 			0: uint16(323),
 			1: uint16(775),
 			2: uint16(1062),
 			3: uint16(1776),
 			4: uint16(3062),
 			5: uint16(1274),
 			6: uint16(813),
 			7: uint16(1188),
 			8: uint16(1372),
 			9: uint16(655),
 		},
 		7: {
 			0: uint16(488),
 			1: uint16(971),
 			2: uint16(484),
 			3: uint16(1767),
 			4: uint16(1515),
 			5: uint16(1775),
 			6: uint16(1115),
 			7: uint16(503),
 			8: uint16(1539),
 			9: uint16(1461),
 		},
 		8: {
 			0: uint16(740),
 			1: uint16(1006),
 			2: uint16(998),
 			3: uint16(709),
 			4: uint16(851),
 			5: uint16(1230),
 			6: uint16(1337),
 			7: uint16(788),
 			8: uint16(741),
 			9: uint16(721),
 		},
 		9: {
 			0: uint16(522),
 			1: uint16(1073),
 			2: uint16(573),
 			3: uint16(1045),
 			4: uint16(1346),
 			5: uint16(887),
 			6: uint16(1046),
 			7: uint16(1146),
 			8: uint16(1203),
 			9: uint16(697),
 		},
 	},
 	3: {
 		0: {
 			0: uint16(105),
 			1: uint16(864),
 			2: uint16(1442),
 			3: uint16(1009),
 			4: uint16(1934),
 			5: uint16(1840),
 			6: uint16(1519),
 			7: uint16(1920),
 			8: uint16(1673),
 			9: uint16(1579),
 		},
 		1: {
 			0: uint16(534),
 			1: uint16(305),
 			2: uint16(1193),
 			3: uint16(683),
 			4: uint16(1388),
 			5: uint16(2164),
 			6: uint16(1802),
 			7: uint16(1894),
 			8: uint16(1264),
 			9: uint16(1170),
 		},
 		2: {
 			0: uint16(305),
 			1: uint16(518),
 			2: uint16(877),
 			3: uint16(1108),
 			4: uint16(1426),
 			5: uint16(3215),
 			6: uint16(1425),
 			7: uint16(1064),
 			8: uint16(1320),
 			9: uint16(1242),
 		},
 		3: {
 			0: uint16(683),
 			1: uint16(732),
 			2: uint16(1927),
 			3: uint16(257),
 			4: uint16(1493),
 			5: uint16(2048),
 			6: uint16(1858),
 			7: uint16(1552),
 			8: uint16(1055),
 			9: uint16(947),
 		},
 		4: {
 			0: uint16(394),
 			1: uint16(814),
 			2: uint16(1024),
 			3: uint16(660),
 			4: uint16(959),
 			5: uint16(1556),
 			6: uint16(1282),
 			7: uint16(1289),
 			8: uint16(893),
 			9: uint16(1047),
 		},
 		5: {
 			0: uint16(528),
 			1: uint16(615),
 			2: uint16(996),
 			3: uint16(940),
 			4: uint16(1201),
 			5: uint16(635),
 			6: uint16(1094),
 			7: uint16(2515),
 			8: uint16(803),
 			9: uint16(1358),
 		},
 		6: {
 			0: uint16(347),
 			1: uint16(614),
 			2: uint16(1609),
 			3: uint16(1187),
 			4: uint16(3133),
 			5: uint16(1345),
 			6: uint16(1007),
 			7: uint16(1339),
 			8: uint16(1017),
 			9: uint16(667),
 		},
 		7: {
 			0: uint16(218),
 			1: uint16(740),
 			2: uint16(878),
 			3: uint16(1605),
 			4: uint16(3650),
 			5: uint16(3650),
 			6: uint16(1345),
 			7: uint16(758),
 			8: uint16(1357),
 			9: uint16(1617),
 		},
 		8: {
 			0: uint16(672),
 			1: uint16(750),
 			2: uint16(1541),
 			3: uint16(558),
 			4: uint16(1257),
 			5: uint16(1599),
 			6: uint16(1870),
 			7: uint16(2135),
 			8: uint16(402),
 			9: uint16(1087),
 		},
 		9: {
 			0: uint16(592),
 			1: uint16(684),
 			2: uint16(1161),
 			3: uint16(430),
 			4: uint16(1092),
 			5: uint16(1497),
 			6: uint16(1475),
 			7: uint16(1489),
 			8: uint16(1095),
 			9: uint16(822),
 		},
 	},
 	4: {
 		0: {
 			0: uint16(228),
 			1: uint16(1056),
 			2: uint16(1059),
 			3: uint16(1368),
 			4: uint16(752),
 			5: uint16(982),
 			6: uint16(1512),
 			7: uint16(1518),
 			8: uint16(987),
 			9: uint16(1782),
 		},
 		1: {
 			0: uint16(494),
 			1: uint16(514),
 			2: uint16(818),
 			3: uint16(942),
 			4: uint16(965),
 			5: uint16(892),
 			6: uint16(1610),
 			7: uint16(1356),
 			8: uint16(1048),
 			9: uint16(1363),
 		},
 		2: {
 			0: uint16(512),
 			1: uint16(648),
 			2: uint16(591),
 			3: uint16(1042),
 			4: uint16(761),
 			5: uint16(991),
 			6: uint16(1196),
 			7: uint16(1454),
 			8: uint16(1309),
 			9: uint16(1463),
 		},
 		3: {
 			0: uint16(683),
 			1: uint16(749),
 			2: uint16(1043),
 			3: uint16(676),
 			4: uint16(841),
 			5: uint16(1396),
 			6: uint16(1133),
 			7: uint16(1138),
 			8: uint16(654),
 			9: uint16(939),
 		},
 		4: {
 			0: uint16(622),
 			1: uint16(1101),
 			2: uint16(1126),
 			3: uint16(994),
 			4: uint16(361),
 			5: uint16(1077),
 			6: uint16(1203),
 			7: uint16(1318),
 			8: uint16(877),
 			9: uint16(1219),
 		},
 		5: {
 			0: uint16(631),
 			1: uint16(1068),
 			2: uint16(857),
 			3: uint16(1650),
 			4: uint16(651),
 			5: uint16(477),
 			6: uint16(1650),
 			7: uint16(1419),
 			8: uint16(828),
 			9: uint16(1170),
 		},
 		6: {
 			0: uint16(555),
 			1: uint16(727),
 			2: uint16(1068),
 			3: uint16(1335),
 			4: uint16(3127),
 			5: uint16(1339),
 			6: uint16(820),
 			7: uint16(1331),
 			8: uint16(1077),
 			9: uint16(429),
 		},
 		7: {
 			0: uint16(504),
 			1: uint16(879),
 			2: uint16(624),
 			3: uint16(1398),
 			4: uint16(889),
 			5: uint16(889),
 			6: uint16(1392),
 			7: uint16(808),
 			8: uint16(891),
 			9: uint16(1406),
 		},
 		8: {
 			0: uint16(683),
 			1: uint16(1602),
 			2: uint16(1289),
 			3: uint16(977),
 			4: uint16(578),
 			5: uint16(983),
 			6: uint16(1280),
 			7: uint16(1708),
 			8: uint16(406),
 			9: uint16(1122),
 		},
 		9: {
 			0: uint16(399),
 			1: uint16(865),
 			2: uint16(1433),
 			3: uint16(1070),
 			4: uint16(1072),
 			5: uint16(764),
 			6: uint16(968),
 			7: uint16(1477),
 			8: uint16(1223),
 			9: uint16(678),
 		},
 	},
 	5: {
 		0: {
 			0: uint16(333),
 			1: uint16(760),
 			2: uint16(935),
 			3: uint16(1638),
 			4: uint16(1010),
 			5: uint16(529),
 			6: uint16(1646),
 			7: uint16(1410),
 			8: uint16(1472),
 			9: uint16(2219),
 		},
 		1: {
 			0: uint16(512),
 			1: uint16(494),
 			2: uint16(750),
 			3: uint16(1160),
 			4: uint16(1215),
 			5: uint16(610),
 			6: uint16(1870),
 			7: uint16(1868),
 			8: uint16(1628),
 			9: uint16(1169),
 		},
 		2: {
 			0: uint16(572),
 			1: uint16(646),
 			2: uint16(492),
 			3: uint16(1934),
 			4: uint16(1208),
 			5: uint16(603),
 			6: uint16(1580),
 			7: uint16(1099),
 			8: uint16(1398),
 			9: uint16(1995),
 		},
 		3: {
 			0: uint16(786),
 			1: uint16(789),
 			2: uint16(942),
 			3: uint16(581),
 			4: uint16(1018),
 			5: uint16(951),
 			6: uint16(1599),
 			7: uint16(1207),
 			8: uint16(731),
 			9: uint16(768),
 		},
 		4: {
 			0: uint16(690),
 			1: uint16(1015),
 			2: uint16(672),
 			3: uint16(1078),
 			4: uint16(582),
 			5: uint16(504),
 			6: uint16(1693),
 			7: uint16(1438),
 			8: uint16(1108),
 			9: uint16(2897),
 		},
 		5: {
 			0: uint16(768),
 			1: uint16(1267),
 			2: uint16(571),
 			3: uint16(2005),
 			4: uint16(1243),
 			5: uint16(244),
 			6: uint16(2881),
 			7: uint16(1380),
 			8: uint16(1786),
 			9: uint16(1453),
 		},
 		6: {
 			0: uint16(452),
 			1: uint16(899),
 			2: uint16(1293),
 			3: uint16(903),
 			4: uint16(1311),
 			5: uint16(3100),
 			6: uint16(465),
 			7: uint16(1311),
 			8: uint16(1319),
 			9: uint16(813),
 		},
 		7: {
 			0: uint16(394),
 			1: uint16(927),
 			2: uint16(942),
 			3: uint16(1103),
 			4: uint16(1358),
 			5: uint16(1104),
 			6: uint16(946),
 			7: uint16(593),
 			8: uint16(1363),
 			9: uint16(1109),
 		},
 		8: {
 			0: uint16(559),
 			1: uint16(1005),
 			2: uint16(1007),
 			3: uint16(1016),
 			4: uint16(658),
 			5: uint16(1173),
 			6: uint16(1021),
 			7: uint16(1164),
 			8: uint16(623),
 			9: uint16(1028),
 		},
 		9: {
 			0: uint16(564),
 			1: uint16(796),
 			2: uint16(632),
 			3: uint16(1005),
 			4: uint16(1014),
 			5: uint16(863),
 			6: uint16(2316),
 			7: uint16(1268),
 			8: uint16(938),
 			9: uint16(764),
 		},
 	},
 	6: {
 		0: {
 			0: uint16(266),
 			1: uint16(606),
 			2: uint16(1098),
 			3: uint16(1228),
 			4: uint16(1497),
 			5: uint16(1243),
 			6: uint16(948),
 			7: uint16(1030),
 			8: uint16(1734),
 			9: uint16(1461),
 		},
 		1: {
 			0: uint16(366),
 			1: uint16(585),
 			2: uint16(901),
 			3: uint16(1060),
 			4: uint16(1407),
 			5: uint16(1247),
 			6: uint16(876),
 			7: uint16(1134),
 			8: uint16(1620),
 			9: uint16(1054),
 		},
 		2: {
 			0: uint16(452),
 			1: uint16(565),
 			2: uint16(542),
 			3: uint16(1729),
 			4: uint16(1479),
 			5: uint16(1479),
 			6: uint16(1016),
 			7: uint16(886),
 			8: uint16(2938),
 			9: uint16(1150),
 		},
 		3: {
 			0: uint16(555),
 			1: uint16(1088),
 			2: uint16(1533),
 			3: uint16(950),
 			4: uint16(1354),
 			5: uint16(895),
 			6: uint16(834),
 			7: uint16(1019),
 			8: uint16(1021),
 			9: uint16(496),
 		},
 		4: {
 			0: uint16(704),
 			1: uint16(815),
 			2: uint16(1193),
 			3: uint16(971),
 			4: uint16(973),
 			5: uint16(640),
 			6: uint16(1217),
 			7: uint16(2214),
 			8: uint16(832),
 			9: uint16(578),
 		},
 		5: {
 			0: uint16(672),
 			1: uint16(1245),
 			2: uint16(579),
 			3: uint16(871),
 			4: uint16(875),
 			5: uint16(774),
 			6: uint16(872),
 			7: uint16(1273),
 			8: uint16(1027),
 			9: uint16(949),
 		},
 		6: {
 			0: uint16(296),
 			1: uint16(1134),
 			2: uint16(2050),
 			3: uint16(1784),
 			4: uint16(1636),
 			5: uint16(3425),
 			6: uint16(442),
 			7: uint16(1550),
 			8: uint16(2076),
 			9: uint16(722),
 		},
 		7: {
 			0: uint16(342),
 			1: uint16(982),
 			2: uint16(1259),
 			3: uint16(1846),
 			4: uint16(1848),
 			5: uint16(1848),
 			6: uint16(622),
 			7: uint16(568),
 			8: uint16(1847),
 			9: uint16(1052),
 		},
 		8: {
 			0: uint16(555),
 			1: uint16(1064),
 			2: uint16(1304),
 			3: uint16(828),
 			4: uint16(746),
 			5: uint16(1343),
 			6: uint16(1075),
 			7: uint16(1329),
 			8: uint16(1078),
 			9: uint16(494),
 		},
 		9: {
 			0: uint16(288),
 			1: uint16(1167),
 			2: uint16(1285),
 			3: uint16(1174),
 			4: uint16(1639),
 			5: uint16(1639),
 			6: uint16(833),
 			7: uint16(2254),
 			8: uint16(1304),
 			9: uint16(509),
 		},
 	},
 	7: {
 		0: {
 			0: uint16(342),
 			1: uint16(719),
 			2: uint16(767),
 			3: uint16(1866),
 			4: uint16(1757),
 			5: uint16(1270),
 			6: uint16(1246),
 			7: uint16(550),
 			8: uint16(1746),
 			9: uint16(2151),
 		},
 		1: {
 			0: uint16(483),
 			1: uint16(653),
 			2: uint16(694),
 			3: uint16(1509),
 			4: uint16(1459),
 			5: uint16(1410),
 			6: uint16(1218),
 			7: uint16(507),
 			8: uint16(1914),
 			9: uint16(1266),
 		},
 		2: {
 			0: uint16(488),
 			1: uint16(757),
 			2: uint16(447),
 			3: uint16(2979),
 			4: uint16(1813),
 			5: uint16(1268),
 			6: uint16(1654),
 			7: uint16(539),
 			8: uint16(1849),
 			9: uint16(2109),
 		},
 		3: {
 			0: uint16(522),
 			1: uint16(1097),
 			2: uint16(1085),
 			3: uint16(851),
 			4: uint16(1365),
 			5: uint16(1111),
 			6: uint16(851),
 			7: uint16(901),
 			8: uint16(961),
 			9: uint16(605),
 		},
 		4: {
 			0: uint16(709),
 			1: uint16(716),
 			2: uint16(841),
 			3: uint16(728),
 			4: uint16(736),
 			5: uint16(945),
 			6: uint16(941),
 			7: uint16(862),
 			8: uint16(2845),
 			9: uint16(1057),
 		},
 		5: {
 			0: uint16(512),
 			1: uint16(1323),
 			2: uint16(500),
 			3: uint16(1336),
 			4: uint16(1083),
 			5: uint16(681),
 			6: uint16(1342),
 			7: uint16(717),
 			8: uint16(1604),
 			9: uint16(1350),
 		},
 		6: {
 			0: uint16(452),
 			1: uint16(1155),
 			2: uint16(1372),
 			3: uint16(1900),
 			4: uint16(1501),
 			5: uint16(3290),
 			6: uint16(311),
 			7: uint16(944),
 			8: uint16(1919),
 			9: uint16(922),
 		},
 		7: {
 			0: uint16(403),
 			1: uint16(1520),
 			2: uint16(977),
 			3: uint16(2132),
 			4: uint16(1733),
 			5: uint16(3522),
 			6: uint16(1076),
 			7: uint16(276),
 			8: uint16(3335),
 			9: uint16(1547),
 		},
 		8: {
 			0: uint16(559),
 			1: uint16(1374),
 			2: uint16(1101),
 			3: uint16(615),
 			4: uint16(673),
 			5: uint16(2462),
 			6: uint16(974),
 			7: uint16(795),
 			8: uint16(984),
 			9: uint16(984),
 		},
 		9: {
 			0: uint16(547),
 			1: uint16(1122),
 			2: uint16(1062),
 			3: uint16(812),
 			4: uint16(1410),
 			5: uint16(951),
 			6: uint16(1140),
 			7: uint16(622),
 			8: uint16(1268),
 			9: uint16(651),
 		},
 	},
 	8: {
 		0: {
 			0: uint16(165),
 			1: uint16(982),
 			2: uint16(1235),
 			3: uint16(938),
 			4: uint16(1334),
 			5: uint16(1366),
 			6: uint16(1659),
 			7: uint16(1578),
 			8: uint16(964),
 			9: uint16(1612),
 		},
 		1: {
 			0: uint16(592),
 			1: uint16(422),
 			2: uint16(925),
 			3: uint16(847),
 			4: uint16(1139),
 			5: uint16(1112),
 			6: uint16(1387),
 			7: uint16(2036),
 			8: uint16(861),
 			9: uint16(1041),
 		},
 		2: {
 			0: uint16(403),
 			1: uint16(837),
 			2: uint16(732),
 			3: uint16(770),
 			4: uint16(941),
 			5: uint16(1658),
 			6: uint16(1250),
 			7: uint16(809),
 			8: uint16(1407),
 			9: uint16(1407),
 		},
 		3: {
 			0: uint16(896),
 			1: uint16(874),
 			2: uint16(1071),
 			3: uint16(381),
 			4: uint16(1568),
 			5: uint16(1722),
 			6: uint16(1437),
 			7: uint16(2192),
 			8: uint16(480),
 			9: uint16(1035),
 		},
 		4: {
 			0: uint16(640),
 			1: uint16(1098),
 			2: uint16(1012),
 			3: uint16(1032),
 			4: uint16(684),
 			5: uint16(1382),
 			6: uint16(1581),
 			7: uint16(2106),
 			8: uint16(416),
 			9: uint16(865),
 		},
 		5: {
 			0: uint16(559),
 			1: uint16(1005),
 			2: uint16(819),
 			3: uint16(914),
 			4: uint16(710),
 			5: uint16(770),
 			6: uint16(1418),
 			7: uint16(920),
 			8: uint16(838),
 			9: uint16(1435),
 		},
 		6: {
 			0: uint16(415),
 			1: uint16(1258),
 			2: uint16(1245),
 			3: uint16(870),
 			4: uint16(1278),
 			5: uint16(3067),
 			6: uint16(770),
 			7: uint16(1021),
 			8: uint16(1287),
 			9: uint16(522),
 		},
 		7: {
 			0: uint16(406),
 			1: uint16(990),
 			2: uint16(601),
 			3: uint16(1009),
 			4: uint16(1265),
 			5: uint16(1265),
 			6: uint16(1267),
 			7: uint16(759),
 			8: uint16(1017),
 			9: uint16(1277),
 		},
 		8: {
 			0: uint16(968),
 			1: uint16(1182),
 			2: uint16(1329),
 			3: uint16(788),
 			4: uint16(1032),
 			5: uint16(1292),
 			6: uint16(1705),
 			7: uint16(1714),
 			8: uint16(203),
 			9: uint16(1403),
 		},
 		9: {
 			0: uint16(732),
 			1: uint16(877),
 			2: uint16(1279),
 			3: uint16(471),
 			4: uint16(901),
 			5: uint16(1161),
 			6: uint16(1545),
 			7: uint16(1294),
 			8: uint16(755),
 			9: uint16(755),
 		},
 	},
 	9: {
 		0: {
 			0: uint16(111),
 			1: uint16(931),
 			2: uint16(1378),
 			3: uint16(1185),
 			4: uint16(1933),
 			5: uint16(1648),
 			6: uint16(1148),
 			7: uint16(1714),
 			8: uint16(1873),
 			9: uint16(1307),
 		},
 		1: {
 			0: uint16(406),
 			1: uint16(414),
 			2: uint16(1030),
 			3: uint16(1023),
 			4: uint16(1910),
 			5: uint16(1404),
 			6: uint16(1313),
 			7: uint16(1647),
 			8: uint16(1509),
 			9: uint16(793),
 		},
 		2: {
 			0: uint16(342),
 			1: uint16(640),
 			2: uint16(575),
 			3: uint16(1088),
 			4: uint16(1241),
 			5: uint16(1349),
 			6: uint16(1161),
 			7: uint16(1350),
 			8: uint16(1756),
 			9: uint16(1502),
 		},
 		3: {
 			0: uint16(559),
 			1: uint16(766),
 			2: uint16(1185),
 			3: uint16(357),
 			4: uint16(1682),
 			5: uint16(1428),
 			6: uint16(1329),
 			7: uint16(1897),
 			8: uint16(1219),
 			9: uint16(802),
 		},
 		4: {
 			0: uint16(473),
 			1: uint16(909),
 			2: uint16(1164),
 			3: uint16(771),
 			4: uint16(719),
 			5: uint16(2508),
 			6: uint16(1427),
 			7: uint16(1432),
 			8: uint16(722),
 			9: uint16(782),
 		},
 		5: {
 			0: uint16(342),
 			1: uint16(892),
 			2: uint16(785),
 			3: uint16(1145),
 			4: uint16(1150),
 			5: uint16(794),
 			6: uint16(1296),
 			7: uint16(1550),
 			8: uint16(973),
 			9: uint16(1057),
 		},
 		6: {
 			0: uint16(208),
 			1: uint16(1036),
 			2: uint16(1326),
 			3: uint16(1343),
 			4: uint16(1606),
 			5: uint16(3395),
 			6: uint16(815),
 			7: uint16(1455),
 			8: uint16(1618),
 			9: uint16(712),
 		},
 		7: {
 			0: uint16(228),
 			1: uint16(928),
 			2: uint16(890),
 			3: uint16(1046),
 			4: uint16(3499),
 			5: uint16(1711),
 			6: uint16(994),
 			7: uint16(829),
 			8: uint16(1720),
 			9: uint16(1318),
 		},
 		8: {
 			0: uint16(768),
 			1: uint16(724),
 			2: uint16(1058),
 			3: uint16(636),
 			4: uint16(991),
 			5: uint16(1075),
 			6: uint16(1319),
 			7: uint16(1324),
 			8: uint16(616),
 			9: uint16(825),
 		},
 		9: {
 			0: uint16(305),
 			1: uint16(1167),
 			2: uint16(1358),
 			3: uint16(899),
 			4: uint16(1587),
 			5: uint16(1587),
 			6: uint16(987),
 			7: uint16(1988),
 			8: uint16(1332),
 			9: uint16(501),
 		},
 	},
 }
 
 //------------------------------------------------------------------------------
 // Mode cost tables.
 
 // C documentation
 //
 //	// These are the fixed probabilities (in the coding trees) turned into bit-cost
 //	// by calling VP8BitCost().
 var VP8FixedCostsUV = [4]uint16_t{
 	0: uint16(302),
 	1: uint16(984),
 	2: uint16(439),
 	3: uint16(642),
 }
 
 var VP8GetCPUInfo = uintptr(0)
 
 //------------------------------------------------------------------------------
 // init function
 
 var VP8GetResidualCost VP8GetResidualCostFunc
 
 var VP8HFilter16 VP8LumaFilterFunc
 
 var VP8HFilter16i VP8LumaFilterFunc
 
 var VP8HFilter8 VP8ChromaFilterFunc
 
 var VP8HFilter8i VP8ChromaFilterFunc
 
 //------------------------------------------------------------------------------
 // Form the predictions in cache
 
 // C documentation
 //
 //	// Must be ordered using {DC_PRED, TM_PRED, V_PRED, H_PRED} as index
 var VP8I16ModeOffsets = [4]uint16_t{
 	1: libc.Uint16FromInt32(libc.Int32FromInt32(0)*libc.Int32FromInt32(16)*libc.Int32FromInt32(BPS) + libc.Int32FromInt32(16)),
 	2: libc.Uint16FromInt32(libc.Int32FromInt32(1) * libc.Int32FromInt32(16) * libc.Int32FromInt32(BPS)),
 	3: libc.Uint16FromInt32(libc.Int32FromInt32(1)*libc.Int32FromInt32(16)*libc.Int32FromInt32(BPS) + libc.Int32FromInt32(16)),
 }
 
 var VP8ITransform VP8Idct
 
 //------------------------------------------------------------------------------
 
 var VP8LAddGreenToBlueAndRed VP8LProcessDecBlueAndRedFunc
 
 var VP8LAddGreenToBlueAndRed_SSE VP8LProcessDecBlueAndRedFunc
 
 var VP8LAddVector VP8LAddVectorFunc
 
 var VP8LAddVectorEq VP8LAddVectorEqFunc
 
 var VP8LBundleColorMap VP8LBundleColorMapFunc
 
 var VP8LBundleColorMap_SSE VP8LBundleColorMapFunc
 
 var VP8LCollectColorBlueTransforms VP8LCollectColorBlueTransformsFunc
 
 var VP8LCollectColorBlueTransforms_SSE VP8LCollectColorBlueTransformsFunc
 
 var VP8LCollectColorRedTransforms VP8LCollectColorRedTransformsFunc
 
 var VP8LCollectColorRedTransforms_SSE VP8LCollectColorRedTransformsFunc
 
 var VP8LCombinedShannonEntropy VP8LCombinedShannonEntropyFunc
 
 var VP8LConvertBGRAToBGR VP8LConvertFunc
 
 var VP8LConvertBGRAToRGB VP8LConvertFunc
 
 var VP8LConvertBGRAToRGB565 VP8LConvertFunc
 
 var VP8LConvertBGRAToRGBA VP8LConvertFunc
 
 var VP8LConvertBGRAToRGBA4444 VP8LConvertFunc
 
 var VP8LConvertBGRAToRGBA_SSE VP8LConvertFunc
 
 var VP8LConvertBGRAToRGB_SSE VP8LConvertFunc
 
 var VP8LExtraCost VP8LCostFunc
 
 var VP8LFastLog2Slow VP8LFastLog2SlowFunc
 
 var VP8LFastSLog2Slow VP8LFastSLog2SlowFunc
 
 var VP8LGetCombinedEntropyUnrefined VP8LGetCombinedEntropyUnrefinedFunc
 
 var VP8LGetEntropyUnrefined VP8LGetEntropyUnrefinedFunc
 
 var VP8LMapColor32b VP8LMapARGBFunc
 
 var VP8LMapColor8b VP8LMapAlphaFunc
 
 var VP8LPredictors [16]VP8LPredictorFunc
 
 var VP8LPredictorsAdd [16]VP8LPredictorAddSubFunc
 
 // C documentation
 //
 //	// exposed plain-C implementations
 var VP8LPredictorsAdd_C [16]VP8LPredictorAddSubFunc
 
 var VP8LPredictorsAdd_SSE [16]VP8LPredictorAddSubFunc
 
 var VP8LPredictorsSub [16]VP8LPredictorAddSubFunc
 
 var VP8LPredictorsSub_C [16]VP8LPredictorAddSubFunc
 
 var VP8LPredictorsSub_SSE [16]VP8LPredictorAddSubFunc
 
 var VP8LShannonEntropy VP8LShannonEntropyFunc
 
 //------------------------------------------------------------------------------
 
 var VP8LSubtractGreenFromBlueAndRed VP8LProcessEncBlueAndRedFunc
 
 var VP8LSubtractGreenFromBlueAndRed_SSE VP8LProcessEncBlueAndRedFunc
 
 var VP8LTransformColor VP8LTransformColorFunc
 
 var VP8LTransformColorInverse VP8LTransformColorInverseFunc
 
 var VP8LTransformColorInverse_SSE VP8LTransformColorInverseFunc
 
 var VP8LTransformColor_SSE VP8LTransformColorFunc
 
 var VP8LVectorMismatch VP8LVectorMismatchFunc
 
 //------------------------------------------------------------------------------
 // Level cost tables
 
 // C documentation
 //
 //	// fixed costs for coding levels, deduce from the coding tree.
 //	// This is only the part that doesn't depend on the probability state.
 var VP8LevelFixedCosts = [2048]uint16_t{
 	1:    uint16(256),
 	2:    uint16(256),
 	3:    uint16(256),
 	4:    uint16(256),
 	5:    uint16(432),
 	6:    uint16(618),
 	7:    uint16(630),
 	8:    uint16(731),
 	9:    uint16(640),
 	10:   uint16(640),
 	11:   uint16(828),
 	12:   uint16(901),
 	13:   uint16(948),
 	14:   uint16(1021),
 	15:   uint16(1101),
 	16:   uint16(1174),
 	17:   uint16(1221),
 	18:   uint16(1294),
 	19:   uint16(1042),
 	20:   uint16(1085),
 	21:   uint16(1115),
 	22:   uint16(1158),
 	23:   uint16(1202),
 	24:   uint16(1245),
 	25:   uint16(1275),
 	26:   uint16(1318),
 	27:   uint16(1337),
 	28:   uint16(1380),
 	29:   uint16(1410),
 	30:   uint16(1453),
 	31:   uint16(1497),
 	32:   uint16(1540),
 	33:   uint16(1570),
 	34:   uint16(1613),
 	35:   uint16(1280),
 	36:   uint16(1295),
 	37:   uint16(1317),
 	38:   uint16(1332),
 	39:   uint16(1358),
 	40:   uint16(1373),
 	41:   uint16(1395),
 	42:   uint16(1410),
 	43:   uint16(1454),
 	44:   uint16(1469),
 	45:   uint16(1491),
 	46:   uint16(1506),
 	47:   uint16(1532),
 	48:   uint16(1547),
 	49:   uint16(1569),
 	50:   uint16(1584),
 	51:   uint16(1601),
 	52:   uint16(1616),
 	53:   uint16(1638),
 	54:   uint16(1653),
 	55:   uint16(1679),
 	56:   uint16(1694),
 	57:   uint16(1716),
 	58:   uint16(1731),
 	59:   uint16(1775),
 	60:   uint16(1790),
 	61:   uint16(1812),
 	62:   uint16(1827),
 	63:   uint16(1853),
 	64:   uint16(1868),
 	65:   uint16(1890),
 	66:   uint16(1905),
 	67:   uint16(1727),
 	68:   uint16(1733),
 	69:   uint16(1742),
 	70:   uint16(1748),
 	71:   uint16(1759),
 	72:   uint16(1765),
 	73:   uint16(1774),
 	74:   uint16(1780),
 	75:   uint16(1800),
 	76:   uint16(1806),
 	77:   uint16(1815),
 	78:   uint16(1821),
 	79:   uint16(1832),
 	80:   uint16(1838),
 	81:   uint16(1847),
 	82:   uint16(1853),
 	83:   uint16(1878),
 	84:   uint16(1884),
 	85:   uint16(1893),
 	86:   uint16(1899),
 	87:   uint16(1910),
 	88:   uint16(1916),
 	89:   uint16(1925),
 	90:   uint16(1931),
 	91:   uint16(1951),
 	92:   uint16(1957),
 	93:   uint16(1966),
 	94:   uint16(1972),
 	95:   uint16(1983),
 	96:   uint16(1989),
 	97:   uint16(1998),
 	98:   uint16(2004),
 	99:   uint16(2027),
 	100:  uint16(2033),
 	101:  uint16(2042),
 	102:  uint16(2048),
 	103:  uint16(2059),
 	104:  uint16(2065),
 	105:  uint16(2074),
 	106:  uint16(2080),
 	107:  uint16(2100),
 	108:  uint16(2106),
 	109:  uint16(2115),
 	110:  uint16(2121),
 	111:  uint16(2132),
 	112:  uint16(2138),
 	113:  uint16(2147),
 	114:  uint16(2153),
 	115:  uint16(2178),
 	116:  uint16(2184),
 	117:  uint16(2193),
 	118:  uint16(2199),
 	119:  uint16(2210),
 	120:  uint16(2216),
 	121:  uint16(2225),
 	122:  uint16(2231),
 	123:  uint16(2251),
 	124:  uint16(2257),
 	125:  uint16(2266),
 	126:  uint16(2272),
 	127:  uint16(2283),
 	128:  uint16(2289),
 	129:  uint16(2298),
 	130:  uint16(2304),
 	131:  uint16(2168),
 	132:  uint16(2174),
 	133:  uint16(2183),
 	134:  uint16(2189),
 	135:  uint16(2200),
 	136:  uint16(2206),
 	137:  uint16(2215),
 	138:  uint16(2221),
 	139:  uint16(2241),
 	140:  uint16(2247),
 	141:  uint16(2256),
 	142:  uint16(2262),
 	143:  uint16(2273),
 	144:  uint16(2279),
 	145:  uint16(2288),
 	146:  uint16(2294),
 	147:  uint16(2319),
 	148:  uint16(2325),
 	149:  uint16(2334),
 	150:  uint16(2340),
 	151:  uint16(2351),
 	152:  uint16(2357),
 	153:  uint16(2366),
 	154:  uint16(2372),
 	155:  uint16(2392),
 	156:  uint16(2398),
 	157:  uint16(2407),
 	158:  uint16(2413),
 	159:  uint16(2424),
 	160:  uint16(2430),
 	161:  uint16(2439),
 	162:  uint16(2445),
 	163:  uint16(2468),
 	164:  uint16(2474),
 	165:  uint16(2483),
 	166:  uint16(2489),
 	167:  uint16(2500),
 	168:  uint16(2506),
 	169:  uint16(2515),
 	170:  uint16(2521),
 	171:  uint16(2541),
 	172:  uint16(2547),
 	173:  uint16(2556),
 	174:  uint16(2562),
 	175:  uint16(2573),
 	176:  uint16(2579),
 	177:  uint16(2588),
 	178:  uint16(2594),
 	179:  uint16(2619),
 	180:  uint16(2625),
 	181:  uint16(2634),
 	182:  uint16(2640),
 	183:  uint16(2651),
 	184:  uint16(2657),
 	185:  uint16(2666),
 	186:  uint16(2672),
 	187:  uint16(2692),
 	188:  uint16(2698),
 	189:  uint16(2707),
 	190:  uint16(2713),
 	191:  uint16(2724),
 	192:  uint16(2730),
 	193:  uint16(2739),
 	194:  uint16(2745),
 	195:  uint16(2540),
 	196:  uint16(2546),
 	197:  uint16(2555),
 	198:  uint16(2561),
 	199:  uint16(2572),
 	200:  uint16(2578),
 	201:  uint16(2587),
 	202:  uint16(2593),
 	203:  uint16(2613),
 	204:  uint16(2619),
 	205:  uint16(2628),
 	206:  uint16(2634),
 	207:  uint16(2645),
 	208:  uint16(2651),
 	209:  uint16(2660),
 	210:  uint16(2666),
 	211:  uint16(2691),
 	212:  uint16(2697),
 	213:  uint16(2706),
 	214:  uint16(2712),
 	215:  uint16(2723),
 	216:  uint16(2729),
 	217:  uint16(2738),
 	218:  uint16(2744),
 	219:  uint16(2764),
 	220:  uint16(2770),
 	221:  uint16(2779),
 	222:  uint16(2785),
 	223:  uint16(2796),
 	224:  uint16(2802),
 	225:  uint16(2811),
 	226:  uint16(2817),
 	227:  uint16(2840),
 	228:  uint16(2846),
 	229:  uint16(2855),
 	230:  uint16(2861),
 	231:  uint16(2872),
 	232:  uint16(2878),
 	233:  uint16(2887),
 	234:  uint16(2893),
 	235:  uint16(2913),
 	236:  uint16(2919),
 	237:  uint16(2928),
 	238:  uint16(2934),
 	239:  uint16(2945),
 	240:  uint16(2951),
 	241:  uint16(2960),
 	242:  uint16(2966),
 	243:  uint16(2991),
 	244:  uint16(2997),
 	245:  uint16(3006),
 	246:  uint16(3012),
 	247:  uint16(3023),
 	248:  uint16(3029),
 	249:  uint16(3038),
 	250:  uint16(3044),
 	251:  uint16(3064),
 	252:  uint16(3070),
 	253:  uint16(3079),
 	254:  uint16(3085),
 	255:  uint16(3096),
 	256:  uint16(3102),
 	257:  uint16(3111),
 	258:  uint16(3117),
 	259:  uint16(2981),
 	260:  uint16(2987),
 	261:  uint16(2996),
 	262:  uint16(3002),
 	263:  uint16(3013),
 	264:  uint16(3019),
 	265:  uint16(3028),
 	266:  uint16(3034),
 	267:  uint16(3054),
 	268:  uint16(3060),
 	269:  uint16(3069),
 	270:  uint16(3075),
 	271:  uint16(3086),
 	272:  uint16(3092),
 	273:  uint16(3101),
 	274:  uint16(3107),
 	275:  uint16(3132),
 	276:  uint16(3138),
 	277:  uint16(3147),
 	278:  uint16(3153),
 	279:  uint16(3164),
 	280:  uint16(3170),
 	281:  uint16(3179),
 	282:  uint16(3185),
 	283:  uint16(3205),
 	284:  uint16(3211),
 	285:  uint16(3220),
 	286:  uint16(3226),
 	287:  uint16(3237),
 	288:  uint16(3243),
 	289:  uint16(3252),
 	290:  uint16(3258),
 	291:  uint16(3281),
 	292:  uint16(3287),
 	293:  uint16(3296),
 	294:  uint16(3302),
 	295:  uint16(3313),
 	296:  uint16(3319),
 	297:  uint16(3328),
 	298:  uint16(3334),
 	299:  uint16(3354),
 	300:  uint16(3360),
 	301:  uint16(3369),
 	302:  uint16(3375),
 	303:  uint16(3386),
 	304:  uint16(3392),
 	305:  uint16(3401),
 	306:  uint16(3407),
 	307:  uint16(3432),
 	308:  uint16(3438),
 	309:  uint16(3447),
 	310:  uint16(3453),
 	311:  uint16(3464),
 	312:  uint16(3470),
 	313:  uint16(3479),
 	314:  uint16(3485),
 	315:  uint16(3505),
 	316:  uint16(3511),
 	317:  uint16(3520),
 	318:  uint16(3526),
 	319:  uint16(3537),
 	320:  uint16(3543),
 	321:  uint16(3552),
 	322:  uint16(3558),
 	323:  uint16(2816),
 	324:  uint16(2822),
 	325:  uint16(2831),
 	326:  uint16(2837),
 	327:  uint16(2848),
 	328:  uint16(2854),
 	329:  uint16(2863),
 	330:  uint16(2869),
 	331:  uint16(2889),
 	332:  uint16(2895),
 	333:  uint16(2904),
 	334:  uint16(2910),
 	335:  uint16(2921),
 	336:  uint16(2927),
 	337:  uint16(2936),
 	338:  uint16(2942),
 	339:  uint16(2967),
 	340:  uint16(2973),
 	341:  uint16(2982),
 	342:  uint16(2988),
 	343:  uint16(2999),
 	344:  uint16(3005),
 	345:  uint16(3014),
 	346:  uint16(3020),
 	347:  uint16(3040),
 	348:  uint16(3046),
 	349:  uint16(3055),
 	350:  uint16(3061),
 	351:  uint16(3072),
 	352:  uint16(3078),
 	353:  uint16(3087),
 	354:  uint16(3093),
 	355:  uint16(3116),
 	356:  uint16(3122),
 	357:  uint16(3131),
 	358:  uint16(3137),
 	359:  uint16(3148),
 	360:  uint16(3154),
 	361:  uint16(3163),
 	362:  uint16(3169),
 	363:  uint16(3189),
 	364:  uint16(3195),
 	365:  uint16(3204),
 	366:  uint16(3210),
 	367:  uint16(3221),
 	368:  uint16(3227),
 	369:  uint16(3236),
 	370:  uint16(3242),
 	371:  uint16(3267),
 	372:  uint16(3273),
 	373:  uint16(3282),
 	374:  uint16(3288),
 	375:  uint16(3299),
 	376:  uint16(3305),
 	377:  uint16(3314),
 	378:  uint16(3320),
 	379:  uint16(3340),
 	380:  uint16(3346),
 	381:  uint16(3355),
 	382:  uint16(3361),
 	383:  uint16(3372),
 	384:  uint16(3378),
 	385:  uint16(3387),
 	386:  uint16(3393),
 	387:  uint16(3257),
 	388:  uint16(3263),
 	389:  uint16(3272),
 	390:  uint16(3278),
 	391:  uint16(3289),
 	392:  uint16(3295),
 	393:  uint16(3304),
 	394:  uint16(3310),
 	395:  uint16(3330),
 	396:  uint16(3336),
 	397:  uint16(3345),
 	398:  uint16(3351),
 	399:  uint16(3362),
 	400:  uint16(3368),
 	401:  uint16(3377),
 	402:  uint16(3383),
 	403:  uint16(3408),
 	404:  uint16(3414),
 	405:  uint16(3423),
 	406:  uint16(3429),
 	407:  uint16(3440),
 	408:  uint16(3446),
 	409:  uint16(3455),
 	410:  uint16(3461),
 	411:  uint16(3481),
 	412:  uint16(3487),
 	413:  uint16(3496),
 	414:  uint16(3502),
 	415:  uint16(3513),
 	416:  uint16(3519),
 	417:  uint16(3528),
 	418:  uint16(3534),
 	419:  uint16(3557),
 	420:  uint16(3563),
 	421:  uint16(3572),
 	422:  uint16(3578),
 	423:  uint16(3589),
 	424:  uint16(3595),
 	425:  uint16(3604),
 	426:  uint16(3610),
 	427:  uint16(3630),
 	428:  uint16(3636),
 	429:  uint16(3645),
 	430:  uint16(3651),
 	431:  uint16(3662),
 	432:  uint16(3668),
 	433:  uint16(3677),
 	434:  uint16(3683),
 	435:  uint16(3708),
 	436:  uint16(3714),
 	437:  uint16(3723),
 	438:  uint16(3729),
 	439:  uint16(3740),
 	440:  uint16(3746),
 	441:  uint16(3755),
 	442:  uint16(3761),
 	443:  uint16(3781),
 	444:  uint16(3787),
 	445:  uint16(3796),
 	446:  uint16(3802),
 	447:  uint16(3813),
 	448:  uint16(3819),
 	449:  uint16(3828),
 	450:  uint16(3834),
 	451:  uint16(3629),
 	452:  uint16(3635),
 	453:  uint16(3644),
 	454:  uint16(3650),
 	455:  uint16(3661),
 	456:  uint16(3667),
 	457:  uint16(3676),
 	458:  uint16(3682),
 	459:  uint16(3702),
 	460:  uint16(3708),
 	461:  uint16(3717),
 	462:  uint16(3723),
 	463:  uint16(3734),
 	464:  uint16(3740),
 	465:  uint16(3749),
 	466:  uint16(3755),
 	467:  uint16(3780),
 	468:  uint16(3786),
 	469:  uint16(3795),
 	470:  uint16(3801),
 	471:  uint16(3812),
 	472:  uint16(3818),
 	473:  uint16(3827),
 	474:  uint16(3833),
 	475:  uint16(3853),
 	476:  uint16(3859),
 	477:  uint16(3868),
 	478:  uint16(3874),
 	479:  uint16(3885),
 	480:  uint16(3891),
 	481:  uint16(3900),
 	482:  uint16(3906),
 	483:  uint16(3929),
 	484:  uint16(3935),
 	485:  uint16(3944),
 	486:  uint16(3950),
 	487:  uint16(3961),
 	488:  uint16(3967),
 	489:  uint16(3976),
 	490:  uint16(3982),
 	491:  uint16(4002),
 	492:  uint16(4008),
 	493:  uint16(4017),
 	494:  uint16(4023),
 	495:  uint16(4034),
 	496:  uint16(4040),
 	497:  uint16(4049),
 	498:  uint16(4055),
 	499:  uint16(4080),
 	500:  uint16(4086),
 	501:  uint16(4095),
 	502:  uint16(4101),
 	503:  uint16(4112),
 	504:  uint16(4118),
 	505:  uint16(4127),
 	506:  uint16(4133),
 	507:  uint16(4153),
 	508:  uint16(4159),
 	509:  uint16(4168),
 	510:  uint16(4174),
 	511:  uint16(4185),
 	512:  uint16(4191),
 	513:  uint16(4200),
 	514:  uint16(4206),
 	515:  uint16(4070),
 	516:  uint16(4076),
 	517:  uint16(4085),
 	518:  uint16(4091),
 	519:  uint16(4102),
 	520:  uint16(4108),
 	521:  uint16(4117),
 	522:  uint16(4123),
 	523:  uint16(4143),
 	524:  uint16(4149),
 	525:  uint16(4158),
 	526:  uint16(4164),
 	527:  uint16(4175),
 	528:  uint16(4181),
 	529:  uint16(4190),
 	530:  uint16(4196),
 	531:  uint16(4221),
 	532:  uint16(4227),
 	533:  uint16(4236),
 	534:  uint16(4242),
 	535:  uint16(4253),
 	536:  uint16(4259),
 	537:  uint16(4268),
 	538:  uint16(4274),
 	539:  uint16(4294),
 	540:  uint16(4300),
 	541:  uint16(4309),
 	542:  uint16(4315),
 	543:  uint16(4326),
 	544:  uint16(4332),
 	545:  uint16(4341),
 	546:  uint16(4347),
 	547:  uint16(4370),
 	548:  uint16(4376),
 	549:  uint16(4385),
 	550:  uint16(4391),
 	551:  uint16(4402),
 	552:  uint16(4408),
 	553:  uint16(4417),
 	554:  uint16(4423),
 	555:  uint16(4443),
 	556:  uint16(4449),
 	557:  uint16(4458),
 	558:  uint16(4464),
 	559:  uint16(4475),
 	560:  uint16(4481),
 	561:  uint16(4490),
 	562:  uint16(4496),
 	563:  uint16(4521),
 	564:  uint16(4527),
 	565:  uint16(4536),
 	566:  uint16(4542),
 	567:  uint16(4553),
 	568:  uint16(4559),
 	569:  uint16(4568),
 	570:  uint16(4574),
 	571:  uint16(4594),
 	572:  uint16(4600),
 	573:  uint16(4609),
 	574:  uint16(4615),
 	575:  uint16(4626),
 	576:  uint16(4632),
 	577:  uint16(4641),
 	578:  uint16(4647),
 	579:  uint16(3515),
 	580:  uint16(3521),
 	581:  uint16(3530),
 	582:  uint16(3536),
 	583:  uint16(3547),
 	584:  uint16(3553),
 	585:  uint16(3562),
 	586:  uint16(3568),
 	587:  uint16(3588),
 	588:  uint16(3594),
 	589:  uint16(3603),
 	590:  uint16(3609),
 	591:  uint16(3620),
 	592:  uint16(3626),
 	593:  uint16(3635),
 	594:  uint16(3641),
 	595:  uint16(3666),
 	596:  uint16(3672),
 	597:  uint16(3681),
 	598:  uint16(3687),
 	599:  uint16(3698),
 	600:  uint16(3704),
 	601:  uint16(3713),
 	602:  uint16(3719),
 	603:  uint16(3739),
 	604:  uint16(3745),
 	605:  uint16(3754),
 	606:  uint16(3760),
 	607:  uint16(3771),
 	608:  uint16(3777),
 	609:  uint16(3786),
 	610:  uint16(3792),
 	611:  uint16(3815),
 	612:  uint16(3821),
 	613:  uint16(3830),
 	614:  uint16(3836),
 	615:  uint16(3847),
 	616:  uint16(3853),
 	617:  uint16(3862),
 	618:  uint16(3868),
 	619:  uint16(3888),
 	620:  uint16(3894),
 	621:  uint16(3903),
 	622:  uint16(3909),
 	623:  uint16(3920),
 	624:  uint16(3926),
 	625:  uint16(3935),
 	626:  uint16(3941),
 	627:  uint16(3966),
 	628:  uint16(3972),
 	629:  uint16(3981),
 	630:  uint16(3987),
 	631:  uint16(3998),
 	632:  uint16(4004),
 	633:  uint16(4013),
 	634:  uint16(4019),
 	635:  uint16(4039),
 	636:  uint16(4045),
 	637:  uint16(4054),
 	638:  uint16(4060),
 	639:  uint16(4071),
 	640:  uint16(4077),
 	641:  uint16(4086),
 	642:  uint16(4092),
 	643:  uint16(3956),
 	644:  uint16(3962),
 	645:  uint16(3971),
 	646:  uint16(3977),
 	647:  uint16(3988),
 	648:  uint16(3994),
 	649:  uint16(4003),
 	650:  uint16(4009),
 	651:  uint16(4029),
 	652:  uint16(4035),
 	653:  uint16(4044),
 	654:  uint16(4050),
 	655:  uint16(4061),
 	656:  uint16(4067),
 	657:  uint16(4076),
 	658:  uint16(4082),
 	659:  uint16(4107),
 	660:  uint16(4113),
 	661:  uint16(4122),
 	662:  uint16(4128),
 	663:  uint16(4139),
 	664:  uint16(4145),
 	665:  uint16(4154),
 	666:  uint16(4160),
 	667:  uint16(4180),
 	668:  uint16(4186),
 	669:  uint16(4195),
 	670:  uint16(4201),
 	671:  uint16(4212),
 	672:  uint16(4218),
 	673:  uint16(4227),
 	674:  uint16(4233),
 	675:  uint16(4256),
 	676:  uint16(4262),
 	677:  uint16(4271),
 	678:  uint16(4277),
 	679:  uint16(4288),
 	680:  uint16(4294),
 	681:  uint16(4303),
 	682:  uint16(4309),
 	683:  uint16(4329),
 	684:  uint16(4335),
 	685:  uint16(4344),
 	686:  uint16(4350),
 	687:  uint16(4361),
 	688:  uint16(4367),
 	689:  uint16(4376),
 	690:  uint16(4382),
 	691:  uint16(4407),
 	692:  uint16(4413),
 	693:  uint16(4422),
 	694:  uint16(4428),
 	695:  uint16(4439),
 	696:  uint16(4445),
 	697:  uint16(4454),
 	698:  uint16(4460),
 	699:  uint16(4480),
 	700:  uint16(4486),
 	701:  uint16(4495),
 	702:  uint16(4501),
 	703:  uint16(4512),
 	704:  uint16(4518),
 	705:  uint16(4527),
 	706:  uint16(4533),
 	707:  uint16(4328),
 	708:  uint16(4334),
 	709:  uint16(4343),
 	710:  uint16(4349),
 	711:  uint16(4360),
 	712:  uint16(4366),
 	713:  uint16(4375),
 	714:  uint16(4381),
 	715:  uint16(4401),
 	716:  uint16(4407),
 	717:  uint16(4416),
 	718:  uint16(4422),
 	719:  uint16(4433),
 	720:  uint16(4439),
 	721:  uint16(4448),
 	722:  uint16(4454),
 	723:  uint16(4479),
 	724:  uint16(4485),
 	725:  uint16(4494),
 	726:  uint16(4500),
 	727:  uint16(4511),
 	728:  uint16(4517),
 	729:  uint16(4526),
 	730:  uint16(4532),
 	731:  uint16(4552),
 	732:  uint16(4558),
 	733:  uint16(4567),
 	734:  uint16(4573),
 	735:  uint16(4584),
 	736:  uint16(4590),
 	737:  uint16(4599),
 	738:  uint16(4605),
 	739:  uint16(4628),
 	740:  uint16(4634),
 	741:  uint16(4643),
 	742:  uint16(4649),
 	743:  uint16(4660),
 	744:  uint16(4666),
 	745:  uint16(4675),
 	746:  uint16(4681),
 	747:  uint16(4701),
 	748:  uint16(4707),
 	749:  uint16(4716),
 	750:  uint16(4722),
 	751:  uint16(4733),
 	752:  uint16(4739),
 	753:  uint16(4748),
 	754:  uint16(4754),
 	755:  uint16(4779),
 	756:  uint16(4785),
 	757:  uint16(4794),
 	758:  uint16(4800),
 	759:  uint16(4811),
 	760:  uint16(4817),
 	761:  uint16(4826),
 	762:  uint16(4832),
 	763:  uint16(4852),
 	764:  uint16(4858),
 	765:  uint16(4867),
 	766:  uint16(4873),
 	767:  uint16(4884),
 	768:  uint16(4890),
 	769:  uint16(4899),
 	770:  uint16(4905),
 	771:  uint16(4769),
 	772:  uint16(4775),
 	773:  uint16(4784),
 	774:  uint16(4790),
 	775:  uint16(4801),
 	776:  uint16(4807),
 	777:  uint16(4816),
 	778:  uint16(4822),
 	779:  uint16(4842),
 	780:  uint16(4848),
 	781:  uint16(4857),
 	782:  uint16(4863),
 	783:  uint16(4874),
 	784:  uint16(4880),
 	785:  uint16(4889),
 	786:  uint16(4895),
 	787:  uint16(4920),
 	788:  uint16(4926),
 	789:  uint16(4935),
 	790:  uint16(4941),
 	791:  uint16(4952),
 	792:  uint16(4958),
 	793:  uint16(4967),
 	794:  uint16(4973),
 	795:  uint16(4993),
 	796:  uint16(4999),
 	797:  uint16(5008),
 	798:  uint16(5014),
 	799:  uint16(5025),
 	800:  uint16(5031),
 	801:  uint16(5040),
 	802:  uint16(5046),
 	803:  uint16(5069),
 	804:  uint16(5075),
 	805:  uint16(5084),
 	806:  uint16(5090),
 	807:  uint16(5101),
 	808:  uint16(5107),
 	809:  uint16(5116),
 	810:  uint16(5122),
 	811:  uint16(5142),
 	812:  uint16(5148),
 	813:  uint16(5157),
 	814:  uint16(5163),
 	815:  uint16(5174),
 	816:  uint16(5180),
 	817:  uint16(5189),
 	818:  uint16(5195),
 	819:  uint16(5220),
 	820:  uint16(5226),
 	821:  uint16(5235),
 	822:  uint16(5241),
 	823:  uint16(5252),
 	824:  uint16(5258),
 	825:  uint16(5267),
 	826:  uint16(5273),
 	827:  uint16(5293),
 	828:  uint16(5299),
 	829:  uint16(5308),
 	830:  uint16(5314),
 	831:  uint16(5325),
 	832:  uint16(5331),
 	833:  uint16(5340),
 	834:  uint16(5346),
 	835:  uint16(4604),
 	836:  uint16(4610),
 	837:  uint16(4619),
 	838:  uint16(4625),
 	839:  uint16(4636),
 	840:  uint16(4642),
 	841:  uint16(4651),
 	842:  uint16(4657),
 	843:  uint16(4677),
 	844:  uint16(4683),
 	845:  uint16(4692),
 	846:  uint16(4698),
 	847:  uint16(4709),
 	848:  uint16(4715),
 	849:  uint16(4724),
 	850:  uint16(4730),
 	851:  uint16(4755),
 	852:  uint16(4761),
 	853:  uint16(4770),
 	854:  uint16(4776),
 	855:  uint16(4787),
 	856:  uint16(4793),
 	857:  uint16(4802),
 	858:  uint16(4808),
 	859:  uint16(4828),
 	860:  uint16(4834),
 	861:  uint16(4843),
 	862:  uint16(4849),
 	863:  uint16(4860),
 	864:  uint16(4866),
 	865:  uint16(4875),
 	866:  uint16(4881),
 	867:  uint16(4904),
 	868:  uint16(4910),
 	869:  uint16(4919),
 	870:  uint16(4925),
 	871:  uint16(4936),
 	872:  uint16(4942),
 	873:  uint16(4951),
 	874:  uint16(4957),
 	875:  uint16(4977),
 	876:  uint16(4983),
 	877:  uint16(4992),
 	878:  uint16(4998),
 	879:  uint16(5009),
 	880:  uint16(5015),
 	881:  uint16(5024),
 	882:  uint16(5030),
 	883:  uint16(5055),
 	884:  uint16(5061),
 	885:  uint16(5070),
 	886:  uint16(5076),
 	887:  uint16(5087),
 	888:  uint16(5093),
 	889:  uint16(5102),
 	890:  uint16(5108),
 	891:  uint16(5128),
 	892:  uint16(5134),
 	893:  uint16(5143),
 	894:  uint16(5149),
 	895:  uint16(5160),
 	896:  uint16(5166),
 	897:  uint16(5175),
 	898:  uint16(5181),
 	899:  uint16(5045),
 	900:  uint16(5051),
 	901:  uint16(5060),
 	902:  uint16(5066),
 	903:  uint16(5077),
 	904:  uint16(5083),
 	905:  uint16(5092),
 	906:  uint16(5098),
 	907:  uint16(5118),
 	908:  uint16(5124),
 	909:  uint16(5133),
 	910:  uint16(5139),
 	911:  uint16(5150),
 	912:  uint16(5156),
 	913:  uint16(5165),
 	914:  uint16(5171),
 	915:  uint16(5196),
 	916:  uint16(5202),
 	917:  uint16(5211),
 	918:  uint16(5217),
 	919:  uint16(5228),
 	920:  uint16(5234),
 	921:  uint16(5243),
 	922:  uint16(5249),
 	923:  uint16(5269),
 	924:  uint16(5275),
 	925:  uint16(5284),
 	926:  uint16(5290),
 	927:  uint16(5301),
 	928:  uint16(5307),
 	929:  uint16(5316),
 	930:  uint16(5322),
 	931:  uint16(5345),
 	932:  uint16(5351),
 	933:  uint16(5360),
 	934:  uint16(5366),
 	935:  uint16(5377),
 	936:  uint16(5383),
 	937:  uint16(5392),
 	938:  uint16(5398),
 	939:  uint16(5418),
 	940:  uint16(5424),
 	941:  uint16(5433),
 	942:  uint16(5439),
 	943:  uint16(5450),
 	944:  uint16(5456),
 	945:  uint16(5465),
 	946:  uint16(5471),
 	947:  uint16(5496),
 	948:  uint16(5502),
 	949:  uint16(5511),
 	950:  uint16(5517),
 	951:  uint16(5528),
 	952:  uint16(5534),
 	953:  uint16(5543),
 	954:  uint16(5549),
 	955:  uint16(5569),
 	956:  uint16(5575),
 	957:  uint16(5584),
 	958:  uint16(5590),
 	959:  uint16(5601),
 	960:  uint16(5607),
 	961:  uint16(5616),
 	962:  uint16(5622),
 	963:  uint16(5417),
 	964:  uint16(5423),
 	965:  uint16(5432),
 	966:  uint16(5438),
 	967:  uint16(5449),
 	968:  uint16(5455),
 	969:  uint16(5464),
 	970:  uint16(5470),
 	971:  uint16(5490),
 	972:  uint16(5496),
 	973:  uint16(5505),
 	974:  uint16(5511),
 	975:  uint16(5522),
 	976:  uint16(5528),
 	977:  uint16(5537),
 	978:  uint16(5543),
 	979:  uint16(5568),
 	980:  uint16(5574),
 	981:  uint16(5583),
 	982:  uint16(5589),
 	983:  uint16(5600),
 	984:  uint16(5606),
 	985:  uint16(5615),
 	986:  uint16(5621),
 	987:  uint16(5641),
 	988:  uint16(5647),
 	989:  uint16(5656),
 	990:  uint16(5662),
 	991:  uint16(5673),
 	992:  uint16(5679),
 	993:  uint16(5688),
 	994:  uint16(5694),
 	995:  uint16(5717),
 	996:  uint16(5723),
 	997:  uint16(5732),
 	998:  uint16(5738),
 	999:  uint16(5749),
 	1000: uint16(5755),
 	1001: uint16(5764),
 	1002: uint16(5770),
 	1003: uint16(5790),
 	1004: uint16(5796),
 	1005: uint16(5805),
 	1006: uint16(5811),
 	1007: uint16(5822),
 	1008: uint16(5828),
 	1009: uint16(5837),
 	1010: uint16(5843),
 	1011: uint16(5868),
 	1012: uint16(5874),
 	1013: uint16(5883),
 	1014: uint16(5889),
 	1015: uint16(5900),
 	1016: uint16(5906),
 	1017: uint16(5915),
 	1018: uint16(5921),
 	1019: uint16(5941),
 	1020: uint16(5947),
 	1021: uint16(5956),
 	1022: uint16(5962),
 	1023: uint16(5973),
 	1024: uint16(5979),
 	1025: uint16(5988),
 	1026: uint16(5994),
 	1027: uint16(5858),
 	1028: uint16(5864),
 	1029: uint16(5873),
 	1030: uint16(5879),
 	1031: uint16(5890),
 	1032: uint16(5896),
 	1033: uint16(5905),
 	1034: uint16(5911),
 	1035: uint16(5931),
 	1036: uint16(5937),
 	1037: uint16(5946),
 	1038: uint16(5952),
 	1039: uint16(5963),
 	1040: uint16(5969),
 	1041: uint16(5978),
 	1042: uint16(5984),
 	1043: uint16(6009),
 	1044: uint16(6015),
 	1045: uint16(6024),
 	1046: uint16(6030),
 	1047: uint16(6041),
 	1048: uint16(6047),
 	1049: uint16(6056),
 	1050: uint16(6062),
 	1051: uint16(6082),
 	1052: uint16(6088),
 	1053: uint16(6097),
 	1054: uint16(6103),
 	1055: uint16(6114),
 	1056: uint16(6120),
 	1057: uint16(6129),
 	1058: uint16(6135),
 	1059: uint16(6158),
 	1060: uint16(6164),
 	1061: uint16(6173),
 	1062: uint16(6179),
 	1063: uint16(6190),
 	1064: uint16(6196),
 	1065: uint16(6205),
 	1066: uint16(6211),
 	1067: uint16(6231),
 	1068: uint16(6237),
 	1069: uint16(6246),
 	1070: uint16(6252),
 	1071: uint16(6263),
 	1072: uint16(6269),
 	1073: uint16(6278),
 	1074: uint16(6284),
 	1075: uint16(6309),
 	1076: uint16(6315),
 	1077: uint16(6324),
 	1078: uint16(6330),
 	1079: uint16(6341),
 	1080: uint16(6347),
 	1081: uint16(6356),
 	1082: uint16(6362),
 	1083: uint16(6382),
 	1084: uint16(6388),
 	1085: uint16(6397),
 	1086: uint16(6403),
 	1087: uint16(6414),
 	1088: uint16(6420),
 	1089: uint16(6429),
 	1090: uint16(6435),
 	1091: uint16(3515),
 	1092: uint16(3521),
 	1093: uint16(3530),
 	1094: uint16(3536),
 	1095: uint16(3547),
 	1096: uint16(3553),
 	1097: uint16(3562),
 	1098: uint16(3568),
 	1099: uint16(3588),
 	1100: uint16(3594),
 	1101: uint16(3603),
 	1102: uint16(3609),
 	1103: uint16(3620),
 	1104: uint16(3626),
 	1105: uint16(3635),
 	1106: uint16(3641),
 	1107: uint16(3666),
 	1108: uint16(3672),
 	1109: uint16(3681),
 	1110: uint16(3687),
 	1111: uint16(3698),
 	1112: uint16(3704),
 	1113: uint16(3713),
 	1114: uint16(3719),
 	1115: uint16(3739),
 	1116: uint16(3745),
 	1117: uint16(3754),
 	1118: uint16(3760),
 	1119: uint16(3771),
 	1120: uint16(3777),
 	1121: uint16(3786),
 	1122: uint16(3792),
 	1123: uint16(3815),
 	1124: uint16(3821),
 	1125: uint16(3830),
 	1126: uint16(3836),
 	1127: uint16(3847),
 	1128: uint16(3853),
 	1129: uint16(3862),
 	1130: uint16(3868),
 	1131: uint16(3888),
 	1132: uint16(3894),
 	1133: uint16(3903),
 	1134: uint16(3909),
 	1135: uint16(3920),
 	1136: uint16(3926),
 	1137: uint16(3935),
 	1138: uint16(3941),
 	1139: uint16(3966),
 	1140: uint16(3972),
 	1141: uint16(3981),
 	1142: uint16(3987),
 	1143: uint16(3998),
 	1144: uint16(4004),
 	1145: uint16(4013),
 	1146: uint16(4019),
 	1147: uint16(4039),
 	1148: uint16(4045),
 	1149: uint16(4054),
 	1150: uint16(4060),
 	1151: uint16(4071),
 	1152: uint16(4077),
 	1153: uint16(4086),
 	1154: uint16(4092),
 	1155: uint16(3956),
 	1156: uint16(3962),
 	1157: uint16(3971),
 	1158: uint16(3977),
 	1159: uint16(3988),
 	1160: uint16(3994),
 	1161: uint16(4003),
 	1162: uint16(4009),
 	1163: uint16(4029),
 	1164: uint16(4035),
 	1165: uint16(4044),
 	1166: uint16(4050),
 	1167: uint16(4061),
 	1168: uint16(4067),
 	1169: uint16(4076),
 	1170: uint16(4082),
 	1171: uint16(4107),
 	1172: uint16(4113),
 	1173: uint16(4122),
 	1174: uint16(4128),
 	1175: uint16(4139),
 	1176: uint16(4145),
 	1177: uint16(4154),
 	1178: uint16(4160),
 	1179: uint16(4180),
 	1180: uint16(4186),
 	1181: uint16(4195),
 	1182: uint16(4201),
 	1183: uint16(4212),
 	1184: uint16(4218),
 	1185: uint16(4227),
 	1186: uint16(4233),
 	1187: uint16(4256),
 	1188: uint16(4262),
 	1189: uint16(4271),
 	1190: uint16(4277),
 	1191: uint16(4288),
 	1192: uint16(4294),
 	1193: uint16(4303),
 	1194: uint16(4309),
 	1195: uint16(4329),
 	1196: uint16(4335),
 	1197: uint16(4344),
 	1198: uint16(4350),
 	1199: uint16(4361),
 	1200: uint16(4367),
 	1201: uint16(4376),
 	1202: uint16(4382),
 	1203: uint16(4407),
 	1204: uint16(4413),
 	1205: uint16(4422),
 	1206: uint16(4428),
 	1207: uint16(4439),
 	1208: uint16(4445),
 	1209: uint16(4454),
 	1210: uint16(4460),
 	1211: uint16(4480),
 	1212: uint16(4486),
 	1213: uint16(4495),
 	1214: uint16(4501),
 	1215: uint16(4512),
 	1216: uint16(4518),
 	1217: uint16(4527),
 	1218: uint16(4533),
 	1219: uint16(4328),
 	1220: uint16(4334),
 	1221: uint16(4343),
 	1222: uint16(4349),
 	1223: uint16(4360),
 	1224: uint16(4366),
 	1225: uint16(4375),
 	1226: uint16(4381),
 	1227: uint16(4401),
 	1228: uint16(4407),
 	1229: uint16(4416),
 	1230: uint16(4422),
 	1231: uint16(4433),
 	1232: uint16(4439),
 	1233: uint16(4448),
 	1234: uint16(4454),
 	1235: uint16(4479),
 	1236: uint16(4485),
 	1237: uint16(4494),
 	1238: uint16(4500),
 	1239: uint16(4511),
 	1240: uint16(4517),
 	1241: uint16(4526),
 	1242: uint16(4532),
 	1243: uint16(4552),
 	1244: uint16(4558),
 	1245: uint16(4567),
 	1246: uint16(4573),
 	1247: uint16(4584),
 	1248: uint16(4590),
 	1249: uint16(4599),
 	1250: uint16(4605),
 	1251: uint16(4628),
 	1252: uint16(4634),
 	1253: uint16(4643),
 	1254: uint16(4649),
 	1255: uint16(4660),
 	1256: uint16(4666),
 	1257: uint16(4675),
 	1258: uint16(4681),
 	1259: uint16(4701),
 	1260: uint16(4707),
 	1261: uint16(4716),
 	1262: uint16(4722),
 	1263: uint16(4733),
 	1264: uint16(4739),
 	1265: uint16(4748),
 	1266: uint16(4754),
 	1267: uint16(4779),
 	1268: uint16(4785),
 	1269: uint16(4794),
 	1270: uint16(4800),
 	1271: uint16(4811),
 	1272: uint16(4817),
 	1273: uint16(4826),
 	1274: uint16(4832),
 	1275: uint16(4852),
 	1276: uint16(4858),
 	1277: uint16(4867),
 	1278: uint16(4873),
 	1279: uint16(4884),
 	1280: uint16(4890),
 	1281: uint16(4899),
 	1282: uint16(4905),
 	1283: uint16(4769),
 	1284: uint16(4775),
 	1285: uint16(4784),
 	1286: uint16(4790),
 	1287: uint16(4801),
 	1288: uint16(4807),
 	1289: uint16(4816),
 	1290: uint16(4822),
 	1291: uint16(4842),
 	1292: uint16(4848),
 	1293: uint16(4857),
 	1294: uint16(4863),
 	1295: uint16(4874),
 	1296: uint16(4880),
 	1297: uint16(4889),
 	1298: uint16(4895),
 	1299: uint16(4920),
 	1300: uint16(4926),
 	1301: uint16(4935),
 	1302: uint16(4941),
 	1303: uint16(4952),
 	1304: uint16(4958),
 	1305: uint16(4967),
 	1306: uint16(4973),
 	1307: uint16(4993),
 	1308: uint16(4999),
 	1309: uint16(5008),
 	1310: uint16(5014),
 	1311: uint16(5025),
 	1312: uint16(5031),
 	1313: uint16(5040),
 	1314: uint16(5046),
 	1315: uint16(5069),
 	1316: uint16(5075),
 	1317: uint16(5084),
 	1318: uint16(5090),
 	1319: uint16(5101),
 	1320: uint16(5107),
 	1321: uint16(5116),
 	1322: uint16(5122),
 	1323: uint16(5142),
 	1324: uint16(5148),
 	1325: uint16(5157),
 	1326: uint16(5163),
 	1327: uint16(5174),
 	1328: uint16(5180),
 	1329: uint16(5189),
 	1330: uint16(5195),
 	1331: uint16(5220),
 	1332: uint16(5226),
 	1333: uint16(5235),
 	1334: uint16(5241),
 	1335: uint16(5252),
 	1336: uint16(5258),
 	1337: uint16(5267),
 	1338: uint16(5273),
 	1339: uint16(5293),
 	1340: uint16(5299),
 	1341: uint16(5308),
 	1342: uint16(5314),
 	1343: uint16(5325),
 	1344: uint16(5331),
 	1345: uint16(5340),
 	1346: uint16(5346),
 	1347: uint16(4604),
 	1348: uint16(4610),
 	1349: uint16(4619),
 	1350: uint16(4625),
 	1351: uint16(4636),
 	1352: uint16(4642),
 	1353: uint16(4651),
 	1354: uint16(4657),
 	1355: uint16(4677),
 	1356: uint16(4683),
 	1357: uint16(4692),
 	1358: uint16(4698),
 	1359: uint16(4709),
 	1360: uint16(4715),
 	1361: uint16(4724),
 	1362: uint16(4730),
 	1363: uint16(4755),
 	1364: uint16(4761),
 	1365: uint16(4770),
 	1366: uint16(4776),
 	1367: uint16(4787),
 	1368: uint16(4793),
 	1369: uint16(4802),
 	1370: uint16(4808),
 	1371: uint16(4828),
 	1372: uint16(4834),
 	1373: uint16(4843),
 	1374: uint16(4849),
 	1375: uint16(4860),
 	1376: uint16(4866),
 	1377: uint16(4875),
 	1378: uint16(4881),
 	1379: uint16(4904),
 	1380: uint16(4910),
 	1381: uint16(4919),
 	1382: uint16(4925),
 	1383: uint16(4936),
 	1384: uint16(4942),
 	1385: uint16(4951),
 	1386: uint16(4957),
 	1387: uint16(4977),
 	1388: uint16(4983),
 	1389: uint16(4992),
 	1390: uint16(4998),
 	1391: uint16(5009),
 	1392: uint16(5015),
 	1393: uint16(5024),
 	1394: uint16(5030),
 	1395: uint16(5055),
 	1396: uint16(5061),
 	1397: uint16(5070),
 	1398: uint16(5076),
 	1399: uint16(5087),
 	1400: uint16(5093),
 	1401: uint16(5102),
 	1402: uint16(5108),
 	1403: uint16(5128),
 	1404: uint16(5134),
 	1405: uint16(5143),
 	1406: uint16(5149),
 	1407: uint16(5160),
 	1408: uint16(5166),
 	1409: uint16(5175),
 	1410: uint16(5181),
 	1411: uint16(5045),
 	1412: uint16(5051),
 	1413: uint16(5060),
 	1414: uint16(5066),
 	1415: uint16(5077),
 	1416: uint16(5083),
 	1417: uint16(5092),
 	1418: uint16(5098),
 	1419: uint16(5118),
 	1420: uint16(5124),
 	1421: uint16(5133),
 	1422: uint16(5139),
 	1423: uint16(5150),
 	1424: uint16(5156),
 	1425: uint16(5165),
 	1426: uint16(5171),
 	1427: uint16(5196),
 	1428: uint16(5202),
 	1429: uint16(5211),
 	1430: uint16(5217),
 	1431: uint16(5228),
 	1432: uint16(5234),
 	1433: uint16(5243),
 	1434: uint16(5249),
 	1435: uint16(5269),
 	1436: uint16(5275),
 	1437: uint16(5284),
 	1438: uint16(5290),
 	1439: uint16(5301),
 	1440: uint16(5307),
 	1441: uint16(5316),
 	1442: uint16(5322),
 	1443: uint16(5345),
 	1444: uint16(5351),
 	1445: uint16(5360),
 	1446: uint16(5366),
 	1447: uint16(5377),
 	1448: uint16(5383),
 	1449: uint16(5392),
 	1450: uint16(5398),
 	1451: uint16(5418),
 	1452: uint16(5424),
 	1453: uint16(5433),
 	1454: uint16(5439),
 	1455: uint16(5450),
 	1456: uint16(5456),
 	1457: uint16(5465),
 	1458: uint16(5471),
 	1459: uint16(5496),
 	1460: uint16(5502),
 	1461: uint16(5511),
 	1462: uint16(5517),
 	1463: uint16(5528),
 	1464: uint16(5534),
 	1465: uint16(5543),
 	1466: uint16(5549),
 	1467: uint16(5569),
 	1468: uint16(5575),
 	1469: uint16(5584),
 	1470: uint16(5590),
 	1471: uint16(5601),
 	1472: uint16(5607),
 	1473: uint16(5616),
 	1474: uint16(5622),
 	1475: uint16(5417),
 	1476: uint16(5423),
 	1477: uint16(5432),
 	1478: uint16(5438),
 	1479: uint16(5449),
 	1480: uint16(5455),
 	1481: uint16(5464),
 	1482: uint16(5470),
 	1483: uint16(5490),
 	1484: uint16(5496),
 	1485: uint16(5505),
 	1486: uint16(5511),
 	1487: uint16(5522),
 	1488: uint16(5528),
 	1489: uint16(5537),
 	1490: uint16(5543),
 	1491: uint16(5568),
 	1492: uint16(5574),
 	1493: uint16(5583),
 	1494: uint16(5589),
 	1495: uint16(5600),
 	1496: uint16(5606),
 	1497: uint16(5615),
 	1498: uint16(5621),
 	1499: uint16(5641),
 	1500: uint16(5647),
 	1501: uint16(5656),
 	1502: uint16(5662),
 	1503: uint16(5673),
 	1504: uint16(5679),
 	1505: uint16(5688),
 	1506: uint16(5694),
 	1507: uint16(5717),
 	1508: uint16(5723),
 	1509: uint16(5732),
 	1510: uint16(5738),
 	1511: uint16(5749),
 	1512: uint16(5755),
 	1513: uint16(5764),
 	1514: uint16(5770),
 	1515: uint16(5790),
 	1516: uint16(5796),
 	1517: uint16(5805),
 	1518: uint16(5811),
 	1519: uint16(5822),
 	1520: uint16(5828),
 	1521: uint16(5837),
 	1522: uint16(5843),
 	1523: uint16(5868),
 	1524: uint16(5874),
 	1525: uint16(5883),
 	1526: uint16(5889),
 	1527: uint16(5900),
 	1528: uint16(5906),
 	1529: uint16(5915),
 	1530: uint16(5921),
 	1531: uint16(5941),
 	1532: uint16(5947),
 	1533: uint16(5956),
 	1534: uint16(5962),
 	1535: uint16(5973),
 	1536: uint16(5979),
 	1537: uint16(5988),
 	1538: uint16(5994),
 	1539: uint16(5858),
 	1540: uint16(5864),
 	1541: uint16(5873),
 	1542: uint16(5879),
 	1543: uint16(5890),
 	1544: uint16(5896),
 	1545: uint16(5905),
 	1546: uint16(5911),
 	1547: uint16(5931),
 	1548: uint16(5937),
 	1549: uint16(5946),
 	1550: uint16(5952),
 	1551: uint16(5963),
 	1552: uint16(5969),
 	1553: uint16(5978),
 	1554: uint16(5984),
 	1555: uint16(6009),
 	1556: uint16(6015),
 	1557: uint16(6024),
 	1558: uint16(6030),
 	1559: uint16(6041),
 	1560: uint16(6047),
 	1561: uint16(6056),
 	1562: uint16(6062),
 	1563: uint16(6082),
 	1564: uint16(6088),
 	1565: uint16(6097),
 	1566: uint16(6103),
 	1567: uint16(6114),
 	1568: uint16(6120),
 	1569: uint16(6129),
 	1570: uint16(6135),
 	1571: uint16(6158),
 	1572: uint16(6164),
 	1573: uint16(6173),
 	1574: uint16(6179),
 	1575: uint16(6190),
 	1576: uint16(6196),
 	1577: uint16(6205),
 	1578: uint16(6211),
 	1579: uint16(6231),
 	1580: uint16(6237),
 	1581: uint16(6246),
 	1582: uint16(6252),
 	1583: uint16(6263),
 	1584: uint16(6269),
 	1585: uint16(6278),
 	1586: uint16(6284),
 	1587: uint16(6309),
 	1588: uint16(6315),
 	1589: uint16(6324),
 	1590: uint16(6330),
 	1591: uint16(6341),
 	1592: uint16(6347),
 	1593: uint16(6356),
 	1594: uint16(6362),
 	1595: uint16(6382),
 	1596: uint16(6388),
 	1597: uint16(6397),
 	1598: uint16(6403),
 	1599: uint16(6414),
 	1600: uint16(6420),
 	1601: uint16(6429),
 	1602: uint16(6435),
 	1603: uint16(5303),
 	1604: uint16(5309),
 	1605: uint16(5318),
 	1606: uint16(5324),
 	1607: uint16(5335),
 	1608: uint16(5341),
 	1609: uint16(5350),
 	1610: uint16(5356),
 	1611: uint16(5376),
 	1612: uint16(5382),
 	1613: uint16(5391),
 	1614: uint16(5397),
 	1615: uint16(5408),
 	1616: uint16(5414),
 	1617: uint16(5423),
 	1618: uint16(5429),
 	1619: uint16(5454),
 	1620: uint16(5460),
 	1621: uint16(5469),
 	1622: uint16(5475),
 	1623: uint16(5486),
 	1624: uint16(5492),
 	1625: uint16(5501),
 	1626: uint16(5507),
 	1627: uint16(5527),
 	1628: uint16(5533),
 	1629: uint16(5542),
 	1630: uint16(5548),
 	1631: uint16(5559),
 	1632: uint16(5565),
 	1633: uint16(5574),
 	1634: uint16(5580),
 	1635: uint16(5603),
 	1636: uint16(5609),
 	1637: uint16(5618),
 	1638: uint16(5624),
 	1639: uint16(5635),
 	1640: uint16(5641),
 	1641: uint16(5650),
 	1642: uint16(5656),
 	1643: uint16(5676),
 	1644: uint16(5682),
 	1645: uint16(5691),
 	1646: uint16(5697),
 	1647: uint16(5708),
 	1648: uint16(5714),
 	1649: uint16(5723),
 	1650: uint16(5729),
 	1651: uint16(5754),
 	1652: uint16(5760),
 	1653: uint16(5769),
 	1654: uint16(5775),
 	1655: uint16(5786),
 	1656: uint16(5792),
 	1657: uint16(5801),
 	1658: uint16(5807),
 	1659: uint16(5827),
 	1660: uint16(5833),
 	1661: uint16(5842),
 	1662: uint16(5848),
 	1663: uint16(5859),
 	1664: uint16(5865),
 	1665: uint16(5874),
 	1666: uint16(5880),
 	1667: uint16(5744),
 	1668: uint16(5750),
 	1669: uint16(5759),
 	1670: uint16(5765),
 	1671: uint16(5776),
 	1672: uint16(5782),
 	1673: uint16(5791),
 	1674: uint16(5797),
 	1675: uint16(5817),
 	1676: uint16(5823),
 	1677: uint16(5832),
 	1678: uint16(5838),
 	1679: uint16(5849),
 	1680: uint16(5855),
 	1681: uint16(5864),
 	1682: uint16(5870),
 	1683: uint16(5895),
 	1684: uint16(5901),
 	1685: uint16(5910),
 	1686: uint16(5916),
 	1687: uint16(5927),
 	1688: uint16(5933),
 	1689: uint16(5942),
 	1690: uint16(5948),
 	1691: uint16(5968),
 	1692: uint16(5974),
 	1693: uint16(5983),
 	1694: uint16(5989),
 	1695: uint16(6000),
 	1696: uint16(6006),
 	1697: uint16(6015),
 	1698: uint16(6021),
 	1699: uint16(6044),
 	1700: uint16(6050),
 	1701: uint16(6059),
 	1702: uint16(6065),
 	1703: uint16(6076),
 	1704: uint16(6082),
 	1705: uint16(6091),
 	1706: uint16(6097),
 	1707: uint16(6117),
 	1708: uint16(6123),
 	1709: uint16(6132),
 	1710: uint16(6138),
 	1711: uint16(6149),
 	1712: uint16(6155),
 	1713: uint16(6164),
 	1714: uint16(6170),
 	1715: uint16(6195),
 	1716: uint16(6201),
 	1717: uint16(6210),
 	1718: uint16(6216),
 	1719: uint16(6227),
 	1720: uint16(6233),
 	1721: uint16(6242),
 	1722: uint16(6248),
 	1723: uint16(6268),
 	1724: uint16(6274),
 	1725: uint16(6283),
 	1726: uint16(6289),
 	1727: uint16(6300),
 	1728: uint16(6306),
 	1729: uint16(6315),
 	1730: uint16(6321),
 	1731: uint16(6116),
 	1732: uint16(6122),
 	1733: uint16(6131),
 	1734: uint16(6137),
 	1735: uint16(6148),
 	1736: uint16(6154),
 	1737: uint16(6163),
 	1738: uint16(6169),
 	1739: uint16(6189),
 	1740: uint16(6195),
 	1741: uint16(6204),
 	1742: uint16(6210),
 	1743: uint16(6221),
 	1744: uint16(6227),
 	1745: uint16(6236),
 	1746: uint16(6242),
 	1747: uint16(6267),
 	1748: uint16(6273),
 	1749: uint16(6282),
 	1750: uint16(6288),
 	1751: uint16(6299),
 	1752: uint16(6305),
 	1753: uint16(6314),
 	1754: uint16(6320),
 	1755: uint16(6340),
 	1756: uint16(6346),
 	1757: uint16(6355),
 	1758: uint16(6361),
 	1759: uint16(6372),
 	1760: uint16(6378),
 	1761: uint16(6387),
 	1762: uint16(6393),
 	1763: uint16(6416),
 	1764: uint16(6422),
 	1765: uint16(6431),
 	1766: uint16(6437),
 	1767: uint16(6448),
 	1768: uint16(6454),
 	1769: uint16(6463),
 	1770: uint16(6469),
 	1771: uint16(6489),
 	1772: uint16(6495),
 	1773: uint16(6504),
 	1774: uint16(6510),
 	1775: uint16(6521),
 	1776: uint16(6527),
 	1777: uint16(6536),
 	1778: uint16(6542),
 	1779: uint16(6567),
 	1780: uint16(6573),
 	1781: uint16(6582),
 	1782: uint16(6588),
 	1783: uint16(6599),
 	1784: uint16(6605),
 	1785: uint16(6614),
 	1786: uint16(6620),
 	1787: uint16(6640),
 	1788: uint16(6646),
 	1789: uint16(6655),
 	1790: uint16(6661),
 	1791: uint16(6672),
 	1792: uint16(6678),
 	1793: uint16(6687),
 	1794: uint16(6693),
 	1795: uint16(6557),
 	1796: uint16(6563),
 	1797: uint16(6572),
 	1798: uint16(6578),
 	1799: uint16(6589),
 	1800: uint16(6595),
 	1801: uint16(6604),
 	1802: uint16(6610),
 	1803: uint16(6630),
 	1804: uint16(6636),
 	1805: uint16(6645),
 	1806: uint16(6651),
 	1807: uint16(6662),
 	1808: uint16(6668),
 	1809: uint16(6677),
 	1810: uint16(6683),
 	1811: uint16(6708),
 	1812: uint16(6714),
 	1813: uint16(6723),
 	1814: uint16(6729),
 	1815: uint16(6740),
 	1816: uint16(6746),
 	1817: uint16(6755),
 	1818: uint16(6761),
 	1819: uint16(6781),
 	1820: uint16(6787),
 	1821: uint16(6796),
 	1822: uint16(6802),
 	1823: uint16(6813),
 	1824: uint16(6819),
 	1825: uint16(6828),
 	1826: uint16(6834),
 	1827: uint16(6857),
 	1828: uint16(6863),
 	1829: uint16(6872),
 	1830: uint16(6878),
 	1831: uint16(6889),
 	1832: uint16(6895),
 	1833: uint16(6904),
 	1834: uint16(6910),
 	1835: uint16(6930),
 	1836: uint16(6936),
 	1837: uint16(6945),
 	1838: uint16(6951),
 	1839: uint16(6962),
 	1840: uint16(6968),
 	1841: uint16(6977),
 	1842: uint16(6983),
 	1843: uint16(7008),
 	1844: uint16(7014),
 	1845: uint16(7023),
 	1846: uint16(7029),
 	1847: uint16(7040),
 	1848: uint16(7046),
 	1849: uint16(7055),
 	1850: uint16(7061),
 	1851: uint16(7081),
 	1852: uint16(7087),
 	1853: uint16(7096),
 	1854: uint16(7102),
 	1855: uint16(7113),
 	1856: uint16(7119),
 	1857: uint16(7128),
 	1858: uint16(7134),
 	1859: uint16(6392),
 	1860: uint16(6398),
 	1861: uint16(6407),
 	1862: uint16(6413),
 	1863: uint16(6424),
 	1864: uint16(6430),
 	1865: uint16(6439),
 	1866: uint16(6445),
 	1867: uint16(6465),
 	1868: uint16(6471),
 	1869: uint16(6480),
 	1870: uint16(6486),
 	1871: uint16(6497),
 	1872: uint16(6503),
 	1873: uint16(6512),
 	1874: uint16(6518),
 	1875: uint16(6543),
 	1876: uint16(6549),
 	1877: uint16(6558),
 	1878: uint16(6564),
 	1879: uint16(6575),
 	1880: uint16(6581),
 	1881: uint16(6590),
 	1882: uint16(6596),
 	1883: uint16(6616),
 	1884: uint16(6622),
 	1885: uint16(6631),
 	1886: uint16(6637),
 	1887: uint16(6648),
 	1888: uint16(6654),
 	1889: uint16(6663),
 	1890: uint16(6669),
 	1891: uint16(6692),
 	1892: uint16(6698),
 	1893: uint16(6707),
 	1894: uint16(6713),
 	1895: uint16(6724),
 	1896: uint16(6730),
 	1897: uint16(6739),
 	1898: uint16(6745),
 	1899: uint16(6765),
 	1900: uint16(6771),
 	1901: uint16(6780),
 	1902: uint16(6786),
 	1903: uint16(6797),
 	1904: uint16(6803),
 	1905: uint16(6812),
 	1906: uint16(6818),
 	1907: uint16(6843),
 	1908: uint16(6849),
 	1909: uint16(6858),
 	1910: uint16(6864),
 	1911: uint16(6875),
 	1912: uint16(6881),
 	1913: uint16(6890),
 	1914: uint16(6896),
 	1915: uint16(6916),
 	1916: uint16(6922),
 	1917: uint16(6931),
 	1918: uint16(6937),
 	1919: uint16(6948),
 	1920: uint16(6954),
 	1921: uint16(6963),
 	1922: uint16(6969),
 	1923: uint16(6833),
 	1924: uint16(6839),
 	1925: uint16(6848),
 	1926: uint16(6854),
 	1927: uint16(6865),
 	1928: uint16(6871),
 	1929: uint16(6880),
 	1930: uint16(6886),
 	1931: uint16(6906),
 	1932: uint16(6912),
 	1933: uint16(6921),
 	1934: uint16(6927),
 	1935: uint16(6938),
 	1936: uint16(6944),
 	1937: uint16(6953),
 	1938: uint16(6959),
 	1939: uint16(6984),
 	1940: uint16(6990),
 	1941: uint16(6999),
 	1942: uint16(7005),
 	1943: uint16(7016),
 	1944: uint16(7022),
 	1945: uint16(7031),
 	1946: uint16(7037),
 	1947: uint16(7057),
 	1948: uint16(7063),
 	1949: uint16(7072),
 	1950: uint16(7078),
 	1951: uint16(7089),
 	1952: uint16(7095),
 	1953: uint16(7104),
 	1954: uint16(7110),
 	1955: uint16(7133),
 	1956: uint16(7139),
 	1957: uint16(7148),
 	1958: uint16(7154),
 	1959: uint16(7165),
 	1960: uint16(7171),
 	1961: uint16(7180),
 	1962: uint16(7186),
 	1963: uint16(7206),
 	1964: uint16(7212),
 	1965: uint16(7221),
 	1966: uint16(7227),
 	1967: uint16(7238),
 	1968: uint16(7244),
 	1969: uint16(7253),
 	1970: uint16(7259),
 	1971: uint16(7284),
 	1972: uint16(7290),
 	1973: uint16(7299),
 	1974: uint16(7305),
 	1975: uint16(7316),
 	1976: uint16(7322),
 	1977: uint16(7331),
 	1978: uint16(7337),
 	1979: uint16(7357),
 	1980: uint16(7363),
 	1981: uint16(7372),
 	1982: uint16(7378),
 	1983: uint16(7389),
 	1984: uint16(7395),
 	1985: uint16(7404),
 	1986: uint16(7410),
 	1987: uint16(7205),
 	1988: uint16(7211),
 	1989: uint16(7220),
 	1990: uint16(7226),
 	1991: uint16(7237),
 	1992: uint16(7243),
 	1993: uint16(7252),
 	1994: uint16(7258),
 	1995: uint16(7278),
 	1996: uint16(7284),
 	1997: uint16(7293),
 	1998: uint16(7299),
 	1999: uint16(7310),
 	2000: uint16(7316),
 	2001: uint16(7325),
 	2002: uint16(7331),
 	2003: uint16(7356),
 	2004: uint16(7362),
 	2005: uint16(7371),
 	2006: uint16(7377),
 	2007: uint16(7388),
 	2008: uint16(7394),
 	2009: uint16(7403),
 	2010: uint16(7409),
 	2011: uint16(7429),
 	2012: uint16(7435),
 	2013: uint16(7444),
 	2014: uint16(7450),
 	2015: uint16(7461),
 	2016: uint16(7467),
 	2017: uint16(7476),
 	2018: uint16(7482),
 	2019: uint16(7505),
 	2020: uint16(7511),
 	2021: uint16(7520),
 	2022: uint16(7526),
 	2023: uint16(7537),
 	2024: uint16(7543),
 	2025: uint16(7552),
 	2026: uint16(7558),
 	2027: uint16(7578),
 	2028: uint16(7584),
 	2029: uint16(7593),
 	2030: uint16(7599),
 	2031: uint16(7610),
 	2032: uint16(7616),
 	2033: uint16(7625),
 	2034: uint16(7631),
 	2035: uint16(7656),
 	2036: uint16(7662),
 	2037: uint16(7671),
 	2038: uint16(7677),
 	2039: uint16(7688),
 	2040: uint16(7694),
 	2041: uint16(7703),
 	2042: uint16(7709),
 	2043: uint16(7729),
 	2044: uint16(7735),
 	2045: uint16(7744),
 	2046: uint16(7750),
 	2047: uint16(7761),
 }
 
 var VP8Mean16x4 VP8MeanMetric
 
 var VP8PredChroma8 [7]VP8PredFunc
 
 var VP8PredLuma16 [7]VP8PredFunc
 
 var VP8PredLuma4 [10]VP8PredFunc
 
 var VP8SSE16x16 VP8Metric
 
 var VP8SSE16x8 VP8Metric
 
 var VP8SSE4x4 VP8Metric
 
 var VP8SSE8x8 VP8Metric
 
 //------------------------------------------------------------------------------
 
 var VP8SSIMGet VP8SSIMGetFunc
 
 var VP8SSIMGetClipped VP8SSIMGetClippedFunc
 
 //------------------------------------------------------------------------------
 // Quantize
 
 // Layout:
 // +----+----+
 // |YYYY|UUVV| 0
 // |YYYY|UUVV| 4
 // |YYYY|....| 8
 // |YYYY|....| 12
 // +----+----+
 
 var VP8Scan = [16]uint16_t{
 	1:  libc.Uint16FromInt32(libc.Int32FromInt32(4) + libc.Int32FromInt32(0)*libc.Int32FromInt32(BPS)),
 	2:  libc.Uint16FromInt32(libc.Int32FromInt32(8) + libc.Int32FromInt32(0)*libc.Int32FromInt32(BPS)),
 	3:  libc.Uint16FromInt32(libc.Int32FromInt32(12) + libc.Int32FromInt32(0)*libc.Int32FromInt32(BPS)),
 	4:  libc.Uint16FromInt32(libc.Int32FromInt32(0) + libc.Int32FromInt32(4)*libc.Int32FromInt32(BPS)),
 	5:  libc.Uint16FromInt32(libc.Int32FromInt32(4) + libc.Int32FromInt32(4)*libc.Int32FromInt32(BPS)),
 	6:  libc.Uint16FromInt32(libc.Int32FromInt32(8) + libc.Int32FromInt32(4)*libc.Int32FromInt32(BPS)),
 	7:  libc.Uint16FromInt32(libc.Int32FromInt32(12) + libc.Int32FromInt32(4)*libc.Int32FromInt32(BPS)),
 	8:  libc.Uint16FromInt32(libc.Int32FromInt32(0) + libc.Int32FromInt32(8)*libc.Int32FromInt32(BPS)),
 	9:  libc.Uint16FromInt32(libc.Int32FromInt32(4) + libc.Int32FromInt32(8)*libc.Int32FromInt32(BPS)),
 	10: libc.Uint16FromInt32(libc.Int32FromInt32(8) + libc.Int32FromInt32(8)*libc.Int32FromInt32(BPS)),
 	11: libc.Uint16FromInt32(libc.Int32FromInt32(12) + libc.Int32FromInt32(8)*libc.Int32FromInt32(BPS)),
 	12: libc.Uint16FromInt32(libc.Int32FromInt32(0) + libc.Int32FromInt32(12)*libc.Int32FromInt32(BPS)),
 	13: libc.Uint16FromInt32(libc.Int32FromInt32(4) + libc.Int32FromInt32(12)*libc.Int32FromInt32(BPS)),
 	14: libc.Uint16FromInt32(libc.Int32FromInt32(8) + libc.Int32FromInt32(12)*libc.Int32FromInt32(BPS)),
 	15: libc.Uint16FromInt32(libc.Int32FromInt32(12) + libc.Int32FromInt32(12)*libc.Int32FromInt32(BPS)),
 }
 
 var VP8SetResidualCoeffs VP8SetResidualCoeffsFunc
 
 var VP8SimpleHFilter16 VP8SimpleFilterFunc
 
 var VP8SimpleHFilter16i VP8SimpleFilterFunc
 
 var VP8SimpleVFilter16 VP8SimpleFilterFunc
 
 var VP8SimpleVFilter16i VP8SimpleFilterFunc
 
 var VP8TDisto16x16 VP8WMetric
 
 var VP8TDisto4x4 VP8WMetric
 
 //------------------------------------------------------------------------------
 
 var VP8Transform VP8DecIdct2
 
 var VP8TransformAC3 VP8DecIdct
 
 var VP8TransformDC VP8DecIdct
 
 var VP8TransformDCUV VP8DecIdct
 
 var VP8TransformUV VP8DecIdct
 
 var VP8TransformWHT VP8WHT
 
 var VP8UVModeOffsets = [4]uint16_t{
 	0: libc.Uint16FromInt32(libc.Int32FromInt32(2) * libc.Int32FromInt32(16) * libc.Int32FromInt32(BPS)),
 	1: libc.Uint16FromInt32(libc.Int32FromInt32(2)*libc.Int32FromInt32(16)*libc.Int32FromInt32(BPS) + libc.Int32FromInt32(1)*libc.Int32FromInt32(16)),
 	2: libc.Uint16FromInt32(libc.Int32FromInt32(2)*libc.Int32FromInt32(16)*libc.Int32FromInt32(BPS) + libc.Int32FromInt32(8)*libc.Int32FromInt32(BPS)),
 	3: libc.Uint16FromInt32(libc.Int32FromInt32(2)*libc.Int32FromInt32(16)*libc.Int32FromInt32(BPS) + libc.Int32FromInt32(8)*libc.Int32FromInt32(BPS) + libc.Int32FromInt32(1)*libc.Int32FromInt32(16)),
 }
 
 var VP8VFilter16 VP8LumaFilterFunc
 
 var VP8VFilter16i VP8LumaFilterFunc
 
 var VP8VFilter8 VP8ChromaFilterFunc
 
 var VP8VFilter8i VP8ChromaFilterFunc
 
 var VP8kabs0 = uintptr(unsafe.Pointer(&abs0)) + 255
 
 var VP8kclip1 = uintptr(unsafe.Pointer(&clip11)) + 255
 
 var VP8ksclip1 = uintptr(unsafe.Pointer(&sclip1)) + 1020
 
 var VP8ksclip2 = uintptr(unsafe.Pointer(&sclip2)) + 112
 
 var WebPAlphaReplace uintptr
 
 var WebPApplyAlphaMultiply uintptr
 
 var WebPApplyAlphaMultiply4444 uintptr
 
 var WebPConvertARGBToUV uintptr
 
 var WebPConvertARGBToY uintptr
 
 var WebPConvertBGR24ToY uintptr
 
 //-----------------------------------------------------------------------------
 
 var WebPConvertRGB24ToY uintptr
 
 var WebPConvertRGBA32ToUV uintptr
 
 var WebPDispatchAlpha uintptr
 
 var WebPDispatchAlphaToGreen uintptr
 
 var WebPExtractAlpha uintptr
 
 var WebPExtractGreen uintptr
 
 //------------------------------------------------------------------------------
 // Init function
 
 var WebPFilters [4]WebPFilterFunc
 
 var WebPHasAlpha32b uintptr
 
 var WebPHasAlpha8b uintptr
 
 var WebPMultARGBRow uintptr
 
 var WebPMultRow uintptr
 
 var WebPPackRGB uintptr
 
 var WebPRescalerExportRowExpand WebPRescalerExportRowFunc
 
 var WebPRescalerExportRowShrink WebPRescalerExportRowFunc
 
 //------------------------------------------------------------------------------
 
 var WebPRescalerImportRowExpand WebPRescalerImportRowFunc
 
 var WebPRescalerImportRowShrink WebPRescalerImportRowFunc
 
 //-----------------------------------------------------------------------------
 // Main call
 
 var WebPSamplers [13]WebPSamplerRowFunc
 
 var WebPUnfilters [4]WebPUnfilterFunc
 
 // Copyright 2010 Google Inc. All Rights Reserved.
 //
 // Use of this source code is governed by a BSD-style license
 // that can be found in the COPYING file in the root of the source
 // tree. An additional intellectual property rights grant can be found
 // in the file PATENTS. All contributing project authors may
 // be found in the AUTHORS file in the root of the source tree.
 // -----------------------------------------------------------------------------
 //
 //  Main decoding functions for WebP images.
 //
 // Author: Skal (pascal.massimino@gmail.com)
 
 //------------------------------------------------------------------------------
 // Fancy upsampler
 
 // C documentation
 //
 //	// Fancy upsampling functions to convert YUV to RGB
 var WebPUpsamplers [13]WebPUpsampleLinePairFunc
 
 var WebPYUV444Converters [13]WebPYUV444Converter
 
 // Copyright 2012 Google Inc. All Rights Reserved.
 //
 // Use of this source code is governed by a BSD-style license
 // that can be found in the COPYING file in the root of the source
 // tree. An additional intellectual property rights grant can be found
 // in the file PATENTS. All contributing project authors may
 // be found in the AUTHORS file in the root of the source tree.
 // -----------------------------------------------------------------------------
 //
 // Misc. common utility functions
 //
 // Authors: Skal (pascal.massimino@gmail.com)
 //          Urvang (urvang@google.com)
 
 // Copyright 2012 Google Inc. All Rights Reserved.
 //
 // Use of this source code is governed by a BSD-style license
 // that can be found in the COPYING file in the root of the source
 // tree. An additional intellectual property rights grant can be found
 // in the file PATENTS. All contributing project authors may
 // be found in the AUTHORS file in the root of the source tree.
 // -----------------------------------------------------------------------------
 //
 //  Internal header for constants related to WebP file format.
 //
 // Author: Urvang (urvang@google.com)
 
 // Copyright 2010 Google Inc. All Rights Reserved.
 //
 // Use of this source code is governed by a BSD-style license
 // that can be found in the COPYING file in the root of the source
 // tree. An additional intellectual property rights grant can be found
 // in the file PATENTS. All contributing project authors may
 // be found in the AUTHORS file in the root of the source tree.
 // -----------------------------------------------------------------------------
 //
 //  Common types + memory wrappers
 //
 // Author: Skal (pascal.massimino@gmail.com)
 
 // C documentation
 //
 //	// lookup table for small values of log2(int) * (1 << LOG_2_PRECISION_BITS).
 //	// Obtained in Python with:
 //	// a = [ str(round((1<<23)*math.log2(i))) if i else "0" for i in range(256)]
 //	// print(',\n'.join(['  '+','.join(v)
 //	//       for v in batched([i.rjust(9) for i in a],7)]))
 var kLog2Table = [256]uint32_t{
 	2:   uint32(8388608),
 	3:   uint32(13295629),
 	4:   uint32(16777216),
 	5:   uint32(19477745),
 	6:   uint32(21684237),
 	7:   uint32(23549800),
 	8:   uint32(25165824),
 	9:   uint32(26591258),
 	10:  uint32(27866353),
 	11:  uint32(29019816),
 	12:  uint32(30072845),
 	13:  uint32(31041538),
 	14:  uint32(31938408),
 	15:  uint32(32773374),
 	16:  uint32(33554432),
 	17:  uint32(34288123),
 	18:  uint32(34979866),
 	19:  uint32(35634199),
 	20:  uint32(36254961),
 	21:  uint32(36845429),
 	22:  uint32(37408424),
 	23:  uint32(37946388),
 	24:  uint32(38461453),
 	25:  uint32(38955489),
 	26:  uint32(39430146),
 	27:  uint32(39886887),
 	28:  uint32(40327016),
 	29:  uint32(40751698),
 	30:  uint32(41161982),
 	31:  uint32(41558811),
 	32:  uint32(41943040),
 	33:  uint32(42315445),
 	34:  uint32(42676731),
 	35:  uint32(43027545),
 	36:  uint32(43368474),
 	37:  uint32(43700062),
 	38:  uint32(44022807),
 	39:  uint32(44337167),
 	40:  uint32(44643569),
 	41:  uint32(44942404),
 	42:  uint32(45234037),
 	43:  uint32(45518808),
 	44:  uint32(45797032),
 	45:  uint32(46069003),
 	46:  uint32(46334996),
 	47:  uint32(46595268),
 	48:  uint32(46850061),
 	49:  uint32(47099600),
 	50:  uint32(47344097),
 	51:  uint32(47583753),
 	52:  uint32(47818754),
 	53:  uint32(48049279),
 	54:  uint32(48275495),
 	55:  uint32(48497560),
 	56:  uint32(48715624),
 	57:  uint32(48929828),
 	58:  uint32(49140306),
 	59:  uint32(49347187),
 	60:  uint32(49550590),
 	61:  uint32(49750631),
 	62:  uint32(49947419),
 	63:  uint32(50141058),
 	64:  uint32(50331648),
 	65:  uint32(50519283),
 	66:  uint32(50704053),
 	67:  uint32(50886044),
 	68:  uint32(51065339),
 	69:  uint32(51242017),
 	70:  uint32(51416153),
 	71:  uint32(51587818),
 	72:  uint32(51757082),
 	73:  uint32(51924012),
 	74:  uint32(52088670),
 	75:  uint32(52251118),
 	76:  uint32(52411415),
 	77:  uint32(52569616),
 	78:  uint32(52725775),
 	79:  uint32(52879946),
 	80:  uint32(53032177),
 	81:  uint32(53182516),
 	82:  uint32(53331012),
 	83:  uint32(53477707),
 	84:  uint32(53622645),
 	85:  uint32(53765868),
 	86:  uint32(53907416),
 	87:  uint32(54047327),
 	88:  uint32(54185640),
 	89:  uint32(54322389),
 	90:  uint32(54457611),
 	91:  uint32(54591338),
 	92:  uint32(54723604),
 	93:  uint32(54854440),
 	94:  uint32(54983876),
 	95:  uint32(55111943),
 	96:  uint32(55238669),
 	97:  uint32(55364082),
 	98:  uint32(55488208),
 	99:  uint32(55611074),
 	100: uint32(55732705),
 	101: uint32(55853126),
 	102: uint32(55972361),
 	103: uint32(56090432),
 	104: uint32(56207362),
 	105: uint32(56323174),
 	106: uint32(56437887),
 	107: uint32(56551524),
 	108: uint32(56664103),
 	109: uint32(56775645),
 	110: uint32(56886168),
 	111: uint32(56995691),
 	112: uint32(57104232),
 	113: uint32(57211808),
 	114: uint32(57318436),
 	115: uint32(57424133),
 	116: uint32(57528914),
 	117: uint32(57632796),
 	118: uint32(57735795),
 	119: uint32(57837923),
 	120: uint32(57939198),
 	121: uint32(58039632),
 	122: uint32(58139239),
 	123: uint32(58238033),
 	124: uint32(58336027),
 	125: uint32(58433234),
 	126: uint32(58529666),
 	127: uint32(58625336),
 	128: uint32(58720256),
 	129: uint32(58814437),
 	130: uint32(58907891),
 	131: uint32(59000628),
 	132: uint32(59092661),
 	133: uint32(59183999),
 	134: uint32(59274652),
 	135: uint32(59364632),
 	136: uint32(59453947),
 	137: uint32(59542609),
 	138: uint32(59630625),
 	139: uint32(59718006),
 	140: uint32(59804761),
 	141: uint32(59890898),
 	142: uint32(59976426),
 	143: uint32(60061354),
 	144: uint32(60145690),
 	145: uint32(60229443),
 	146: uint32(60312620),
 	147: uint32(60395229),
 	148: uint32(60477278),
 	149: uint32(60558775),
 	150: uint32(60639726),
 	151: uint32(60720140),
 	152: uint32(60800023),
 	153: uint32(60879382),
 	154: uint32(60958224),
 	155: uint32(61036555),
 	156: uint32(61114383),
 	157: uint32(61191714),
 	158: uint32(61268554),
 	159: uint32(61344908),
 	160: uint32(61420785),
 	161: uint32(61496188),
 	162: uint32(61571124),
 	163: uint32(61645600),
 	164: uint32(61719620),
 	165: uint32(61793189),
 	166: uint32(61866315),
 	167: uint32(61939001),
 	168: uint32(62011253),
 	169: uint32(62083076),
 	170: uint32(62154476),
 	171: uint32(62225457),
 	172: uint32(62296024),
 	173: uint32(62366182),
 	174: uint32(62435935),
 	175: uint32(62505289),
 	176: uint32(62574248),
 	177: uint32(62642816),
 	178: uint32(62710997),
 	179: uint32(62778797),
 	180: uint32(62846219),
 	181: uint32(62913267),
 	182: uint32(62979946),
 	183: uint32(63046260),
 	184: uint32(63112212),
 	185: uint32(63177807),
 	186: uint32(63243048),
 	187: uint32(63307939),
 	188: uint32(63372484),
 	189: uint32(63436687),
 	190: uint32(63500551),
 	191: uint32(63564080),
 	192: uint32(63627277),
 	193: uint32(63690146),
 	194: uint32(63752690),
 	195: uint32(63814912),
 	196: uint32(63876816),
 	197: uint32(63938405),
 	198: uint32(63999682),
 	199: uint32(64060650),
 	200: uint32(64121313),
 	201: uint32(64181673),
 	202: uint32(64241734),
 	203: uint32(64301498),
 	204: uint32(64360969),
 	205: uint32(64420148),
 	206: uint32(64479040),
 	207: uint32(64537646),
 	208: uint32(64595970),
 	209: uint32(64654014),
 	210: uint32(64711782),
 	211: uint32(64769274),
 	212: uint32(64826495),
 	213: uint32(64883447),
 	214: uint32(64940132),
 	215: uint32(64996553),
 	216: uint32(65052711),
 	217: uint32(65108611),
 	218: uint32(65164253),
 	219: uint32(65219641),
 	220: uint32(65274776),
 	221: uint32(65329662),
 	222: uint32(65384299),
 	223: uint32(65438691),
 	224: uint32(65492840),
 	225: uint32(65546747),
 	226: uint32(65600416),
 	227: uint32(65653847),
 	228: uint32(65707044),
 	229: uint32(65760008),
 	230: uint32(65812741),
 	231: uint32(65865245),
 	232: uint32(65917522),
 	233: uint32(65969575),
 	234: uint32(66021404),
 	235: uint32(66073013),
 	236: uint32(66124403),
 	237: uint32(66175575),
 	238: uint32(66226531),
 	239: uint32(66277275),
 	240: uint32(66327806),
 	241: uint32(66378127),
 	242: uint32(66428240),
 	243: uint32(66478146),
 	244: uint32(66527847),
 	245: uint32(66577345),
 	246: uint32(66626641),
 	247: uint32(66675737),
 	248: uint32(66724635),
 	249: uint32(66773336),
 	250: uint32(66821842),
 	251: uint32(66870154),
 	252: uint32(66918274),
 	253: uint32(66966204),
 	254: uint32(67013944),
 	255: uint32(67061497),
 }
 
 var kPrefixEncodeCode = [512]VP8LPrefixCode{
 	0: {},
 	1: {},
 	2: {
 		Fcode: int8(1),
 	},
 	3: {
 		Fcode: int8(2),
 	},
 	4: {
 		Fcode: int8(3),
 	},
 	5: {
 		Fcode:       int8(4),
 		Fextra_bits: int8(1),
 	},
 	6: {
 		Fcode:       int8(4),
 		Fextra_bits: int8(1),
 	},
 	7: {
 		Fcode:       int8(5),
 		Fextra_bits: int8(1),
 	},
 	8: {
 		Fcode:       int8(5),
 		Fextra_bits: int8(1),
 	},
 	9: {
 		Fcode:       int8(6),
 		Fextra_bits: int8(2),
 	},
 	10: {
 		Fcode:       int8(6),
 		Fextra_bits: int8(2),
 	},
 	11: {
 		Fcode:       int8(6),
 		Fextra_bits: int8(2),
 	},
 	12: {
 		Fcode:       int8(6),
 		Fextra_bits: int8(2),
 	},
 	13: {
 		Fcode:       int8(7),
 		Fextra_bits: int8(2),
 	},
 	14: {
 		Fcode:       int8(7),
 		Fextra_bits: int8(2),
 	},
 	15: {
 		Fcode:       int8(7),
 		Fextra_bits: int8(2),
 	},
 	16: {
 		Fcode:       int8(7),
 		Fextra_bits: int8(2),
 	},
 	17: {
 		Fcode:       int8(8),
 		Fextra_bits: int8(3),
 	},
 	18: {
 		Fcode:       int8(8),
 		Fextra_bits: int8(3),
 	},
 	19: {
 		Fcode:       int8(8),
 		Fextra_bits: int8(3),
 	},
 	20: {
 		Fcode:       int8(8),
 		Fextra_bits: int8(3),
 	},
 	21: {
 		Fcode:       int8(8),
 		Fextra_bits: int8(3),
 	},
 	22: {
 		Fcode:       int8(8),
 		Fextra_bits: int8(3),
 	},
 	23: {
 		Fcode:       int8(8),
 		Fextra_bits: int8(3),
 	},
 	24: {
 		Fcode:       int8(8),
 		Fextra_bits: int8(3),
 	},
 	25: {
 		Fcode:       int8(9),
 		Fextra_bits: int8(3),
 	},
 	26: {
 		Fcode:       int8(9),
 		Fextra_bits: int8(3),
 	},
 	27: {
 		Fcode:       int8(9),
 		Fextra_bits: int8(3),
 	},
 	28: {
 		Fcode:       int8(9),
 		Fextra_bits: int8(3),
 	},
 	29: {
 		Fcode:       int8(9),
 		Fextra_bits: int8(3),
 	},
 	30: {
 		Fcode:       int8(9),
 		Fextra_bits: int8(3),
 	},
 	31: {
 		Fcode:       int8(9),
 		Fextra_bits: int8(3),
 	},
 	32: {
 		Fcode:       int8(9),
 		Fextra_bits: int8(3),
 	},
 	33: {
 		Fcode:       int8(10),
 		Fextra_bits: int8(4),
 	},
 	34: {
 		Fcode:       int8(10),
 		Fextra_bits: int8(4),
 	},
 	35: {
 		Fcode:       int8(10),
 		Fextra_bits: int8(4),
 	},
 	36: {
 		Fcode:       int8(10),
 		Fextra_bits: int8(4),
 	},
 	37: {
 		Fcode:       int8(10),
 		Fextra_bits: int8(4),
 	},
 	38: {
 		Fcode:       int8(10),
 		Fextra_bits: int8(4),
 	},
 	39: {
 		Fcode:       int8(10),
 		Fextra_bits: int8(4),
 	},
 	40: {
 		Fcode:       int8(10),
 		Fextra_bits: int8(4),
 	},
 	41: {
 		Fcode:       int8(10),
 		Fextra_bits: int8(4),
 	},
 	42: {
 		Fcode:       int8(10),
 		Fextra_bits: int8(4),
 	},
 	43: {
 		Fcode:       int8(10),
 		Fextra_bits: int8(4),
 	},
 	44: {
 		Fcode:       int8(10),
 		Fextra_bits: int8(4),
 	},
 	45: {
 		Fcode:       int8(10),
 		Fextra_bits: int8(4),
 	},
 	46: {
 		Fcode:       int8(10),
 		Fextra_bits: int8(4),
 	},
 	47: {
 		Fcode:       int8(10),
 		Fextra_bits: int8(4),
 	},
 	48: {
 		Fcode:       int8(10),
 		Fextra_bits: int8(4),
 	},
 	49: {
 		Fcode:       int8(11),
 		Fextra_bits: int8(4),
 	},
 	50: {
 		Fcode:       int8(11),
 		Fextra_bits: int8(4),
 	},
 	51: {
 		Fcode:       int8(11),
 		Fextra_bits: int8(4),
 	},
 	52: {
 		Fcode:       int8(11),
 		Fextra_bits: int8(4),
 	},
 	53: {
 		Fcode:       int8(11),
 		Fextra_bits: int8(4),
 	},
 	54: {
 		Fcode:       int8(11),
 		Fextra_bits: int8(4),
 	},
 	55: {
 		Fcode:       int8(11),
 		Fextra_bits: int8(4),
 	},
 	56: {
 		Fcode:       int8(11),
 		Fextra_bits: int8(4),
 	},
 	57: {
 		Fcode:       int8(11),
 		Fextra_bits: int8(4),
 	},
 	58: {
 		Fcode:       int8(11),
 		Fextra_bits: int8(4),
 	},
 	59: {
 		Fcode:       int8(11),
 		Fextra_bits: int8(4),
 	},
 	60: {
 		Fcode:       int8(11),
 		Fextra_bits: int8(4),
 	},
 	61: {
 		Fcode:       int8(11),
 		Fextra_bits: int8(4),
 	},
 	62: {
 		Fcode:       int8(11),
 		Fextra_bits: int8(4),
 	},
 	63: {
 		Fcode:       int8(11),
 		Fextra_bits: int8(4),
 	},
 	64: {
 		Fcode:       int8(11),
 		Fextra_bits: int8(4),
 	},
 	65: {
 		Fcode:       int8(12),
 		Fextra_bits: int8(5),
 	},
 	66: {
 		Fcode:       int8(12),
 		Fextra_bits: int8(5),
 	},
 	67: {
 		Fcode:       int8(12),
 		Fextra_bits: int8(5),
 	},
 	68: {
 		Fcode:       int8(12),
 		Fextra_bits: int8(5),
 	},
 	69: {
 		Fcode:       int8(12),
 		Fextra_bits: int8(5),
 	},
 	70: {
 		Fcode:       int8(12),
 		Fextra_bits: int8(5),
 	},
 	71: {
 		Fcode:       int8(12),
 		Fextra_bits: int8(5),
 	},
 	72: {
 		Fcode:       int8(12),
 		Fextra_bits: int8(5),
 	},
 	73: {
 		Fcode:       int8(12),
 		Fextra_bits: int8(5),
 	},
 	74: {
 		Fcode:       int8(12),
 		Fextra_bits: int8(5),
 	},
 	75: {
 		Fcode:       int8(12),
 		Fextra_bits: int8(5),
 	},
 	76: {
 		Fcode:       int8(12),
 		Fextra_bits: int8(5),
 	},
 	77: {
 		Fcode:       int8(12),
 		Fextra_bits: int8(5),
 	},
 	78: {
 		Fcode:       int8(12),
 		Fextra_bits: int8(5),
 	},
 	79: {
 		Fcode:       int8(12),
 		Fextra_bits: int8(5),
 	},
 	80: {
 		Fcode:       int8(12),
 		Fextra_bits: int8(5),
 	},
 	81: {
 		Fcode:       int8(12),
 		Fextra_bits: int8(5),
 	},
 	82: {
 		Fcode:       int8(12),
 		Fextra_bits: int8(5),
 	},
 	83: {
 		Fcode:       int8(12),
 		Fextra_bits: int8(5),
 	},
 	84: {
 		Fcode:       int8(12),
 		Fextra_bits: int8(5),
 	},
 	85: {
 		Fcode:       int8(12),
 		Fextra_bits: int8(5),
 	},
 	86: {
 		Fcode:       int8(12),
 		Fextra_bits: int8(5),
 	},
 	87: {
 		Fcode:       int8(12),
 		Fextra_bits: int8(5),
 	},
 	88: {
 		Fcode:       int8(12),
 		Fextra_bits: int8(5),
 	},
 	89: {
 		Fcode:       int8(12),
 		Fextra_bits: int8(5),
 	},
 	90: {
 		Fcode:       int8(12),
 		Fextra_bits: int8(5),
 	},
 	91: {
 		Fcode:       int8(12),
 		Fextra_bits: int8(5),
 	},
 	92: {
 		Fcode:       int8(12),
 		Fextra_bits: int8(5),
 	},
 	93: {
 		Fcode:       int8(12),
 		Fextra_bits: int8(5),
 	},
 	94: {
 		Fcode:       int8(12),
 		Fextra_bits: int8(5),
 	},
 	95: {
 		Fcode:       int8(12),
 		Fextra_bits: int8(5),
 	},
 	96: {
 		Fcode:       int8(12),
 		Fextra_bits: int8(5),
 	},
 	97: {
 		Fcode:       int8(13),
 		Fextra_bits: int8(5),
 	},
 	98: {
 		Fcode:       int8(13),
 		Fextra_bits: int8(5),
 	},
 	99: {
 		Fcode:       int8(13),
 		Fextra_bits: int8(5),
 	},
 	100: {
 		Fcode:       int8(13),
 		Fextra_bits: int8(5),
 	},
 	101: {
 		Fcode:       int8(13),
 		Fextra_bits: int8(5),
 	},
 	102: {
 		Fcode:       int8(13),
 		Fextra_bits: int8(5),
 	},
 	103: {
 		Fcode:       int8(13),
 		Fextra_bits: int8(5),
 	},
 	104: {
 		Fcode:       int8(13),
 		Fextra_bits: int8(5),
 	},
 	105: {
 		Fcode:       int8(13),
 		Fextra_bits: int8(5),
 	},
 	106: {
 		Fcode:       int8(13),
 		Fextra_bits: int8(5),
 	},
 	107: {
 		Fcode:       int8(13),
 		Fextra_bits: int8(5),
 	},
 	108: {
 		Fcode:       int8(13),
 		Fextra_bits: int8(5),
 	},
 	109: {
 		Fcode:       int8(13),
 		Fextra_bits: int8(5),
 	},
 	110: {
 		Fcode:       int8(13),
 		Fextra_bits: int8(5),
 	},
 	111: {
 		Fcode:       int8(13),
 		Fextra_bits: int8(5),
 	},
 	112: {
 		Fcode:       int8(13),
 		Fextra_bits: int8(5),
 	},
 	113: {
 		Fcode:       int8(13),
 		Fextra_bits: int8(5),
 	},
 	114: {
 		Fcode:       int8(13),
 		Fextra_bits: int8(5),
 	},
 	115: {
 		Fcode:       int8(13),
 		Fextra_bits: int8(5),
 	},
 	116: {
 		Fcode:       int8(13),
 		Fextra_bits: int8(5),
 	},
 	117: {
 		Fcode:       int8(13),
 		Fextra_bits: int8(5),
 	},
 	118: {
 		Fcode:       int8(13),
 		Fextra_bits: int8(5),
 	},
 	119: {
 		Fcode:       int8(13),
 		Fextra_bits: int8(5),
 	},
 	120: {
 		Fcode:       int8(13),
 		Fextra_bits: int8(5),
 	},
 	121: {
 		Fcode:       int8(13),
 		Fextra_bits: int8(5),
 	},
 	122: {
 		Fcode:       int8(13),
 		Fextra_bits: int8(5),
 	},
 	123: {
 		Fcode:       int8(13),
 		Fextra_bits: int8(5),
 	},
 	124: {
 		Fcode:       int8(13),
 		Fextra_bits: int8(5),
 	},
 	125: {
 		Fcode:       int8(13),
 		Fextra_bits: int8(5),
 	},
 	126: {
 		Fcode:       int8(13),
 		Fextra_bits: int8(5),
 	},
 	127: {
 		Fcode:       int8(13),
 		Fextra_bits: int8(5),
 	},
 	128: {
 		Fcode:       int8(13),
 		Fextra_bits: int8(5),
 	},
 	129: {
 		Fcode:       int8(14),
 		Fextra_bits: int8(6),
 	},
 	130: {
 		Fcode:       int8(14),
 		Fextra_bits: int8(6),
 	},
 	131: {
 		Fcode:       int8(14),
 		Fextra_bits: int8(6),
 	},
 	132: {
 		Fcode:       int8(14),
 		Fextra_bits: int8(6),
 	},
 	133: {
 		Fcode:       int8(14),
 		Fextra_bits: int8(6),
 	},
 	134: {
 		Fcode:       int8(14),
 		Fextra_bits: int8(6),
 	},
 	135: {
 		Fcode:       int8(14),
 		Fextra_bits: int8(6),
 	},
 	136: {
 		Fcode:       int8(14),
 		Fextra_bits: int8(6),
 	},
 	137: {
 		Fcode:       int8(14),
 		Fextra_bits: int8(6),
 	},
 	138: {
 		Fcode:       int8(14),
 		Fextra_bits: int8(6),
 	},
 	139: {
 		Fcode:       int8(14),
 		Fextra_bits: int8(6),
 	},
 	140: {
 		Fcode:       int8(14),
 		Fextra_bits: int8(6),
 	},
 	141: {
 		Fcode:       int8(14),
 		Fextra_bits: int8(6),
 	},
 	142: {
 		Fcode:       int8(14),
 		Fextra_bits: int8(6),
 	},
 	143: {
 		Fcode:       int8(14),
 		Fextra_bits: int8(6),
 	},
 	144: {
 		Fcode:       int8(14),
 		Fextra_bits: int8(6),
 	},
 	145: {
 		Fcode:       int8(14),
 		Fextra_bits: int8(6),
 	},
 	146: {
 		Fcode:       int8(14),
 		Fextra_bits: int8(6),
 	},
 	147: {
 		Fcode:       int8(14),
 		Fextra_bits: int8(6),
 	},
 	148: {
 		Fcode:       int8(14),
 		Fextra_bits: int8(6),
 	},
 	149: {
 		Fcode:       int8(14),
 		Fextra_bits: int8(6),
 	},
 	150: {
 		Fcode:       int8(14),
 		Fextra_bits: int8(6),
 	},
 	151: {
 		Fcode:       int8(14),
 		Fextra_bits: int8(6),
 	},
 	152: {
 		Fcode:       int8(14),
 		Fextra_bits: int8(6),
 	},
 	153: {
 		Fcode:       int8(14),
 		Fextra_bits: int8(6),
 	},
 	154: {
 		Fcode:       int8(14),
 		Fextra_bits: int8(6),
 	},
 	155: {
 		Fcode:       int8(14),
 		Fextra_bits: int8(6),
 	},
 	156: {
 		Fcode:       int8(14),
 		Fextra_bits: int8(6),
 	},
 	157: {
 		Fcode:       int8(14),
 		Fextra_bits: int8(6),
 	},
 	158: {
 		Fcode:       int8(14),
 		Fextra_bits: int8(6),
 	},
 	159: {
 		Fcode:       int8(14),
 		Fextra_bits: int8(6),
 	},
 	160: {
 		Fcode:       int8(14),
 		Fextra_bits: int8(6),
 	},
 	161: {
 		Fcode:       int8(14),
 		Fextra_bits: int8(6),
 	},
 	162: {
 		Fcode:       int8(14),
 		Fextra_bits: int8(6),
 	},
 	163: {
 		Fcode:       int8(14),
 		Fextra_bits: int8(6),
 	},
 	164: {
 		Fcode:       int8(14),
 		Fextra_bits: int8(6),
 	},
 	165: {
 		Fcode:       int8(14),
 		Fextra_bits: int8(6),
 	},
 	166: {
 		Fcode:       int8(14),
 		Fextra_bits: int8(6),
 	},
 	167: {
 		Fcode:       int8(14),
 		Fextra_bits: int8(6),
 	},
 	168: {
 		Fcode:       int8(14),
 		Fextra_bits: int8(6),
 	},
 	169: {
 		Fcode:       int8(14),
 		Fextra_bits: int8(6),
 	},
 	170: {
 		Fcode:       int8(14),
 		Fextra_bits: int8(6),
 	},
 	171: {
 		Fcode:       int8(14),
 		Fextra_bits: int8(6),
 	},
 	172: {
 		Fcode:       int8(14),
 		Fextra_bits: int8(6),
 	},
 	173: {
 		Fcode:       int8(14),
 		Fextra_bits: int8(6),
 	},
 	174: {
 		Fcode:       int8(14),
 		Fextra_bits: int8(6),
 	},
 	175: {
 		Fcode:       int8(14),
 		Fextra_bits: int8(6),
 	},
 	176: {
 		Fcode:       int8(14),
 		Fextra_bits: int8(6),
 	},
 	177: {
 		Fcode:       int8(14),
 		Fextra_bits: int8(6),
 	},
 	178: {
 		Fcode:       int8(14),
 		Fextra_bits: int8(6),
 	},
 	179: {
 		Fcode:       int8(14),
 		Fextra_bits: int8(6),
 	},
 	180: {
 		Fcode:       int8(14),
 		Fextra_bits: int8(6),
 	},
 	181: {
 		Fcode:       int8(14),
 		Fextra_bits: int8(6),
 	},
 	182: {
 		Fcode:       int8(14),
 		Fextra_bits: int8(6),
 	},
 	183: {
 		Fcode:       int8(14),
 		Fextra_bits: int8(6),
 	},
 	184: {
 		Fcode:       int8(14),
 		Fextra_bits: int8(6),
 	},
 	185: {
 		Fcode:       int8(14),
 		Fextra_bits: int8(6),
 	},
 	186: {
 		Fcode:       int8(14),
 		Fextra_bits: int8(6),
 	},
 	187: {
 		Fcode:       int8(14),
 		Fextra_bits: int8(6),
 	},
 	188: {
 		Fcode:       int8(14),
 		Fextra_bits: int8(6),
 	},
 	189: {
 		Fcode:       int8(14),
 		Fextra_bits: int8(6),
 	},
 	190: {
 		Fcode:       int8(14),
 		Fextra_bits: int8(6),
 	},
 	191: {
 		Fcode:       int8(14),
 		Fextra_bits: int8(6),
 	},
 	192: {
 		Fcode:       int8(14),
 		Fextra_bits: int8(6),
 	},
 	193: {
 		Fcode:       int8(15),
 		Fextra_bits: int8(6),
 	},
 	194: {
 		Fcode:       int8(15),
 		Fextra_bits: int8(6),
 	},
 	195: {
 		Fcode:       int8(15),
 		Fextra_bits: int8(6),
 	},
 	196: {
 		Fcode:       int8(15),
 		Fextra_bits: int8(6),
 	},
 	197: {
 		Fcode:       int8(15),
 		Fextra_bits: int8(6),
 	},
 	198: {
 		Fcode:       int8(15),
 		Fextra_bits: int8(6),
 	},
 	199: {
 		Fcode:       int8(15),
 		Fextra_bits: int8(6),
 	},
 	200: {
 		Fcode:       int8(15),
 		Fextra_bits: int8(6),
 	},
 	201: {
 		Fcode:       int8(15),
 		Fextra_bits: int8(6),
 	},
 	202: {
 		Fcode:       int8(15),
 		Fextra_bits: int8(6),
 	},
 	203: {
 		Fcode:       int8(15),
 		Fextra_bits: int8(6),
 	},
 	204: {
 		Fcode:       int8(15),
 		Fextra_bits: int8(6),
 	},
 	205: {
 		Fcode:       int8(15),
 		Fextra_bits: int8(6),
 	},
 	206: {
 		Fcode:       int8(15),
 		Fextra_bits: int8(6),
 	},
 	207: {
 		Fcode:       int8(15),
 		Fextra_bits: int8(6),
 	},
 	208: {
 		Fcode:       int8(15),
 		Fextra_bits: int8(6),
 	},
 	209: {
 		Fcode:       int8(15),
 		Fextra_bits: int8(6),
 	},
 	210: {
 		Fcode:       int8(15),
 		Fextra_bits: int8(6),
 	},
 	211: {
 		Fcode:       int8(15),
 		Fextra_bits: int8(6),
 	},
 	212: {
 		Fcode:       int8(15),
 		Fextra_bits: int8(6),
 	},
 	213: {
 		Fcode:       int8(15),
 		Fextra_bits: int8(6),
 	},
 	214: {
 		Fcode:       int8(15),
 		Fextra_bits: int8(6),
 	},
 	215: {
 		Fcode:       int8(15),
 		Fextra_bits: int8(6),
 	},
 	216: {
 		Fcode:       int8(15),
 		Fextra_bits: int8(6),
 	},
 	217: {
 		Fcode:       int8(15),
 		Fextra_bits: int8(6),
 	},
 	218: {
 		Fcode:       int8(15),
 		Fextra_bits: int8(6),
 	},
 	219: {
 		Fcode:       int8(15),
 		Fextra_bits: int8(6),
 	},
 	220: {
 		Fcode:       int8(15),
 		Fextra_bits: int8(6),
 	},
 	221: {
 		Fcode:       int8(15),
 		Fextra_bits: int8(6),
 	},
 	222: {
 		Fcode:       int8(15),
 		Fextra_bits: int8(6),
 	},
 	223: {
 		Fcode:       int8(15),
 		Fextra_bits: int8(6),
 	},
 	224: {
 		Fcode:       int8(15),
 		Fextra_bits: int8(6),
 	},
 	225: {
 		Fcode:       int8(15),
 		Fextra_bits: int8(6),
 	},
 	226: {
 		Fcode:       int8(15),
 		Fextra_bits: int8(6),
 	},
 	227: {
 		Fcode:       int8(15),
 		Fextra_bits: int8(6),
 	},
 	228: {
 		Fcode:       int8(15),
 		Fextra_bits: int8(6),
 	},
 	229: {
 		Fcode:       int8(15),
 		Fextra_bits: int8(6),
 	},
 	230: {
 		Fcode:       int8(15),
 		Fextra_bits: int8(6),
 	},
 	231: {
 		Fcode:       int8(15),
 		Fextra_bits: int8(6),
 	},
 	232: {
 		Fcode:       int8(15),
 		Fextra_bits: int8(6),
 	},
 	233: {
 		Fcode:       int8(15),
 		Fextra_bits: int8(6),
 	},
 	234: {
 		Fcode:       int8(15),
 		Fextra_bits: int8(6),
 	},
 	235: {
 		Fcode:       int8(15),
 		Fextra_bits: int8(6),
 	},
 	236: {
 		Fcode:       int8(15),
 		Fextra_bits: int8(6),
 	},
 	237: {
 		Fcode:       int8(15),
 		Fextra_bits: int8(6),
 	},
 	238: {
 		Fcode:       int8(15),
 		Fextra_bits: int8(6),
 	},
 	239: {
 		Fcode:       int8(15),
 		Fextra_bits: int8(6),
 	},
 	240: {
 		Fcode:       int8(15),
 		Fextra_bits: int8(6),
 	},
 	241: {
 		Fcode:       int8(15),
 		Fextra_bits: int8(6),
 	},
 	242: {
 		Fcode:       int8(15),
 		Fextra_bits: int8(6),
 	},
 	243: {
 		Fcode:       int8(15),
 		Fextra_bits: int8(6),
 	},
 	244: {
 		Fcode:       int8(15),
 		Fextra_bits: int8(6),
 	},
 	245: {
 		Fcode:       int8(15),
 		Fextra_bits: int8(6),
 	},
 	246: {
 		Fcode:       int8(15),
 		Fextra_bits: int8(6),
 	},
 	247: {
 		Fcode:       int8(15),
 		Fextra_bits: int8(6),
 	},
 	248: {
 		Fcode:       int8(15),
 		Fextra_bits: int8(6),
 	},
 	249: {
 		Fcode:       int8(15),
 		Fextra_bits: int8(6),
 	},
 	250: {
 		Fcode:       int8(15),
 		Fextra_bits: int8(6),
 	},
 	251: {
 		Fcode:       int8(15),
 		Fextra_bits: int8(6),
 	},
 	252: {
 		Fcode:       int8(15),
 		Fextra_bits: int8(6),
 	},
 	253: {
 		Fcode:       int8(15),
 		Fextra_bits: int8(6),
 	},
 	254: {
 		Fcode:       int8(15),
 		Fextra_bits: int8(6),
 	},
 	255: {
 		Fcode:       int8(15),
 		Fextra_bits: int8(6),
 	},
 	256: {
 		Fcode:       int8(15),
 		Fextra_bits: int8(6),
 	},
 	257: {
 		Fcode:       int8(16),
 		Fextra_bits: int8(7),
 	},
 	258: {
 		Fcode:       int8(16),
 		Fextra_bits: int8(7),
 	},
 	259: {
 		Fcode:       int8(16),
 		Fextra_bits: int8(7),
 	},
 	260: {
 		Fcode:       int8(16),
 		Fextra_bits: int8(7),
 	},
 	261: {
 		Fcode:       int8(16),
 		Fextra_bits: int8(7),
 	},
 	262: {
 		Fcode:       int8(16),
 		Fextra_bits: int8(7),
 	},
 	263: {
 		Fcode:       int8(16),
 		Fextra_bits: int8(7),
 	},
 	264: {
 		Fcode:       int8(16),
 		Fextra_bits: int8(7),
 	},
 	265: {
 		Fcode:       int8(16),
 		Fextra_bits: int8(7),
 	},
 	266: {
 		Fcode:       int8(16),
 		Fextra_bits: int8(7),
 	},
 	267: {
 		Fcode:       int8(16),
 		Fextra_bits: int8(7),
 	},
 	268: {
 		Fcode:       int8(16),
 		Fextra_bits: int8(7),
 	},
 	269: {
 		Fcode:       int8(16),
 		Fextra_bits: int8(7),
 	},
 	270: {
 		Fcode:       int8(16),
 		Fextra_bits: int8(7),
 	},
 	271: {
 		Fcode:       int8(16),
 		Fextra_bits: int8(7),
 	},
 	272: {
 		Fcode:       int8(16),
 		Fextra_bits: int8(7),
 	},
 	273: {
 		Fcode:       int8(16),
 		Fextra_bits: int8(7),
 	},
 	274: {
 		Fcode:       int8(16),
 		Fextra_bits: int8(7),
 	},
 	275: {
 		Fcode:       int8(16),
 		Fextra_bits: int8(7),
 	},
 	276: {
 		Fcode:       int8(16),
 		Fextra_bits: int8(7),
 	},
 	277: {
 		Fcode:       int8(16),
 		Fextra_bits: int8(7),
 	},
 	278: {
 		Fcode:       int8(16),
 		Fextra_bits: int8(7),
 	},
 	279: {
 		Fcode:       int8(16),
 		Fextra_bits: int8(7),
 	},
 	280: {
 		Fcode:       int8(16),
 		Fextra_bits: int8(7),
 	},
 	281: {
 		Fcode:       int8(16),
 		Fextra_bits: int8(7),
 	},
 	282: {
 		Fcode:       int8(16),
 		Fextra_bits: int8(7),
 	},
 	283: {
 		Fcode:       int8(16),
 		Fextra_bits: int8(7),
 	},
 	284: {
 		Fcode:       int8(16),
 		Fextra_bits: int8(7),
 	},
 	285: {
 		Fcode:       int8(16),
 		Fextra_bits: int8(7),
 	},
 	286: {
 		Fcode:       int8(16),
 		Fextra_bits: int8(7),
 	},
 	287: {
 		Fcode:       int8(16),
 		Fextra_bits: int8(7),
 	},
 	288: {
 		Fcode:       int8(16),
 		Fextra_bits: int8(7),
 	},
 	289: {
 		Fcode:       int8(16),
 		Fextra_bits: int8(7),
 	},
 	290: {
 		Fcode:       int8(16),
 		Fextra_bits: int8(7),
 	},
 	291: {
 		Fcode:       int8(16),
 		Fextra_bits: int8(7),
 	},
 	292: {
 		Fcode:       int8(16),
 		Fextra_bits: int8(7),
 	},
 	293: {
 		Fcode:       int8(16),
 		Fextra_bits: int8(7),
 	},
 	294: {
 		Fcode:       int8(16),
 		Fextra_bits: int8(7),
 	},
 	295: {
 		Fcode:       int8(16),
 		Fextra_bits: int8(7),
 	},
 	296: {
 		Fcode:       int8(16),
 		Fextra_bits: int8(7),
 	},
 	297: {
 		Fcode:       int8(16),
 		Fextra_bits: int8(7),
 	},
 	298: {
 		Fcode:       int8(16),
 		Fextra_bits: int8(7),
 	},
 	299: {
 		Fcode:       int8(16),
 		Fextra_bits: int8(7),
 	},
 	300: {
 		Fcode:       int8(16),
 		Fextra_bits: int8(7),
 	},
 	301: {
 		Fcode:       int8(16),
 		Fextra_bits: int8(7),
 	},
 	302: {
 		Fcode:       int8(16),
 		Fextra_bits: int8(7),
 	},
 	303: {
 		Fcode:       int8(16),
 		Fextra_bits: int8(7),
 	},
 	304: {
 		Fcode:       int8(16),
 		Fextra_bits: int8(7),
 	},
 	305: {
 		Fcode:       int8(16),
 		Fextra_bits: int8(7),
 	},
 	306: {
 		Fcode:       int8(16),
 		Fextra_bits: int8(7),
 	},
 	307: {
 		Fcode:       int8(16),
 		Fextra_bits: int8(7),
 	},
 	308: {
 		Fcode:       int8(16),
 		Fextra_bits: int8(7),
 	},
 	309: {
 		Fcode:       int8(16),
 		Fextra_bits: int8(7),
 	},
 	310: {
 		Fcode:       int8(16),
 		Fextra_bits: int8(7),
 	},
 	311: {
 		Fcode:       int8(16),
 		Fextra_bits: int8(7),
 	},
 	312: {
 		Fcode:       int8(16),
 		Fextra_bits: int8(7),
 	},
 	313: {
 		Fcode:       int8(16),
 		Fextra_bits: int8(7),
 	},
 	314: {
 		Fcode:       int8(16),
 		Fextra_bits: int8(7),
 	},
 	315: {
 		Fcode:       int8(16),
 		Fextra_bits: int8(7),
 	},
 	316: {
 		Fcode:       int8(16),
 		Fextra_bits: int8(7),
 	},
 	317: {
 		Fcode:       int8(16),
 		Fextra_bits: int8(7),
 	},
 	318: {
 		Fcode:       int8(16),
 		Fextra_bits: int8(7),
 	},
 	319: {
 		Fcode:       int8(16),
 		Fextra_bits: int8(7),
 	},
 	320: {
 		Fcode:       int8(16),
 		Fextra_bits: int8(7),
 	},
 	321: {
 		Fcode:       int8(16),
 		Fextra_bits: int8(7),
 	},
 	322: {
 		Fcode:       int8(16),
 		Fextra_bits: int8(7),
 	},
 	323: {
 		Fcode:       int8(16),
 		Fextra_bits: int8(7),
 	},
 	324: {
 		Fcode:       int8(16),
 		Fextra_bits: int8(7),
 	},
 	325: {
 		Fcode:       int8(16),
 		Fextra_bits: int8(7),
 	},
 	326: {
 		Fcode:       int8(16),
 		Fextra_bits: int8(7),
 	},
 	327: {
 		Fcode:       int8(16),
 		Fextra_bits: int8(7),
 	},
 	328: {
 		Fcode:       int8(16),
 		Fextra_bits: int8(7),
 	},
 	329: {
 		Fcode:       int8(16),
 		Fextra_bits: int8(7),
 	},
 	330: {
 		Fcode:       int8(16),
 		Fextra_bits: int8(7),
 	},
 	331: {
 		Fcode:       int8(16),
 		Fextra_bits: int8(7),
 	},
 	332: {
 		Fcode:       int8(16),
 		Fextra_bits: int8(7),
 	},
 	333: {
 		Fcode:       int8(16),
 		Fextra_bits: int8(7),
 	},
 	334: {
 		Fcode:       int8(16),
 		Fextra_bits: int8(7),
 	},
 	335: {
 		Fcode:       int8(16),
 		Fextra_bits: int8(7),
 	},
 	336: {
 		Fcode:       int8(16),
 		Fextra_bits: int8(7),
 	},
 	337: {
 		Fcode:       int8(16),
 		Fextra_bits: int8(7),
 	},
 	338: {
 		Fcode:       int8(16),
 		Fextra_bits: int8(7),
 	},
 	339: {
 		Fcode:       int8(16),
 		Fextra_bits: int8(7),
 	},
 	340: {
 		Fcode:       int8(16),
 		Fextra_bits: int8(7),
 	},
 	341: {
 		Fcode:       int8(16),
 		Fextra_bits: int8(7),
 	},
 	342: {
 		Fcode:       int8(16),
 		Fextra_bits: int8(7),
 	},
 	343: {
 		Fcode:       int8(16),
 		Fextra_bits: int8(7),
 	},
 	344: {
 		Fcode:       int8(16),
 		Fextra_bits: int8(7),
 	},
 	345: {
 		Fcode:       int8(16),
 		Fextra_bits: int8(7),
 	},
 	346: {
 		Fcode:       int8(16),
 		Fextra_bits: int8(7),
 	},
 	347: {
 		Fcode:       int8(16),
 		Fextra_bits: int8(7),
 	},
 	348: {
 		Fcode:       int8(16),
 		Fextra_bits: int8(7),
 	},
 	349: {
 		Fcode:       int8(16),
 		Fextra_bits: int8(7),
 	},
 	350: {
 		Fcode:       int8(16),
 		Fextra_bits: int8(7),
 	},
 	351: {
 		Fcode:       int8(16),
 		Fextra_bits: int8(7),
 	},
 	352: {
 		Fcode:       int8(16),
 		Fextra_bits: int8(7),
 	},
 	353: {
 		Fcode:       int8(16),
 		Fextra_bits: int8(7),
 	},
 	354: {
 		Fcode:       int8(16),
 		Fextra_bits: int8(7),
 	},
 	355: {
 		Fcode:       int8(16),
 		Fextra_bits: int8(7),
 	},
 	356: {
 		Fcode:       int8(16),
 		Fextra_bits: int8(7),
 	},
 	357: {
 		Fcode:       int8(16),
 		Fextra_bits: int8(7),
 	},
 	358: {
 		Fcode:       int8(16),
 		Fextra_bits: int8(7),
 	},
 	359: {
 		Fcode:       int8(16),
 		Fextra_bits: int8(7),
 	},
 	360: {
 		Fcode:       int8(16),
 		Fextra_bits: int8(7),
 	},
 	361: {
 		Fcode:       int8(16),
 		Fextra_bits: int8(7),
 	},
 	362: {
 		Fcode:       int8(16),
 		Fextra_bits: int8(7),
 	},
 	363: {
 		Fcode:       int8(16),
 		Fextra_bits: int8(7),
 	},
 	364: {
 		Fcode:       int8(16),
 		Fextra_bits: int8(7),
 	},
 	365: {
 		Fcode:       int8(16),
 		Fextra_bits: int8(7),
 	},
 	366: {
 		Fcode:       int8(16),
 		Fextra_bits: int8(7),
 	},
 	367: {
 		Fcode:       int8(16),
 		Fextra_bits: int8(7),
 	},
 	368: {
 		Fcode:       int8(16),
 		Fextra_bits: int8(7),
 	},
 	369: {
 		Fcode:       int8(16),
 		Fextra_bits: int8(7),
 	},
 	370: {
 		Fcode:       int8(16),
 		Fextra_bits: int8(7),
 	},
 	371: {
 		Fcode:       int8(16),
 		Fextra_bits: int8(7),
 	},
 	372: {
 		Fcode:       int8(16),
 		Fextra_bits: int8(7),
 	},
 	373: {
 		Fcode:       int8(16),
 		Fextra_bits: int8(7),
 	},
 	374: {
 		Fcode:       int8(16),
 		Fextra_bits: int8(7),
 	},
 	375: {
 		Fcode:       int8(16),
 		Fextra_bits: int8(7),
 	},
 	376: {
 		Fcode:       int8(16),
 		Fextra_bits: int8(7),
 	},
 	377: {
 		Fcode:       int8(16),
 		Fextra_bits: int8(7),
 	},
 	378: {
 		Fcode:       int8(16),
 		Fextra_bits: int8(7),
 	},
 	379: {
 		Fcode:       int8(16),
 		Fextra_bits: int8(7),
 	},
 	380: {
 		Fcode:       int8(16),
 		Fextra_bits: int8(7),
 	},
 	381: {
 		Fcode:       int8(16),
 		Fextra_bits: int8(7),
 	},
 	382: {
 		Fcode:       int8(16),
 		Fextra_bits: int8(7),
 	},
 	383: {
 		Fcode:       int8(16),
 		Fextra_bits: int8(7),
 	},
 	384: {
 		Fcode:       int8(16),
 		Fextra_bits: int8(7),
 	},
 	385: {
 		Fcode:       int8(17),
 		Fextra_bits: int8(7),
 	},
 	386: {
 		Fcode:       int8(17),
 		Fextra_bits: int8(7),
 	},
 	387: {
 		Fcode:       int8(17),
 		Fextra_bits: int8(7),
 	},
 	388: {
 		Fcode:       int8(17),
 		Fextra_bits: int8(7),
 	},
 	389: {
 		Fcode:       int8(17),
 		Fextra_bits: int8(7),
 	},
 	390: {
 		Fcode:       int8(17),
 		Fextra_bits: int8(7),
 	},
 	391: {
 		Fcode:       int8(17),
 		Fextra_bits: int8(7),
 	},
 	392: {
 		Fcode:       int8(17),
 		Fextra_bits: int8(7),
 	},
 	393: {
 		Fcode:       int8(17),
 		Fextra_bits: int8(7),
 	},
 	394: {
 		Fcode:       int8(17),
 		Fextra_bits: int8(7),
 	},
 	395: {
 		Fcode:       int8(17),
 		Fextra_bits: int8(7),
 	},
 	396: {
 		Fcode:       int8(17),
 		Fextra_bits: int8(7),
 	},
 	397: {
 		Fcode:       int8(17),
 		Fextra_bits: int8(7),
 	},
 	398: {
 		Fcode:       int8(17),
 		Fextra_bits: int8(7),
 	},
 	399: {
 		Fcode:       int8(17),
 		Fextra_bits: int8(7),
 	},
 	400: {
 		Fcode:       int8(17),
 		Fextra_bits: int8(7),
 	},
 	401: {
 		Fcode:       int8(17),
 		Fextra_bits: int8(7),
 	},
 	402: {
 		Fcode:       int8(17),
 		Fextra_bits: int8(7),
 	},
 	403: {
 		Fcode:       int8(17),
 		Fextra_bits: int8(7),
 	},
 	404: {
 		Fcode:       int8(17),
 		Fextra_bits: int8(7),
 	},
 	405: {
 		Fcode:       int8(17),
 		Fextra_bits: int8(7),
 	},
 	406: {
 		Fcode:       int8(17),
 		Fextra_bits: int8(7),
 	},
 	407: {
 		Fcode:       int8(17),
 		Fextra_bits: int8(7),
 	},
 	408: {
 		Fcode:       int8(17),
 		Fextra_bits: int8(7),
 	},
 	409: {
 		Fcode:       int8(17),
 		Fextra_bits: int8(7),
 	},
 	410: {
 		Fcode:       int8(17),
 		Fextra_bits: int8(7),
 	},
 	411: {
 		Fcode:       int8(17),
 		Fextra_bits: int8(7),
 	},
 	412: {
 		Fcode:       int8(17),
 		Fextra_bits: int8(7),
 	},
 	413: {
 		Fcode:       int8(17),
 		Fextra_bits: int8(7),
 	},
 	414: {
 		Fcode:       int8(17),
 		Fextra_bits: int8(7),
 	},
 	415: {
 		Fcode:       int8(17),
 		Fextra_bits: int8(7),
 	},
 	416: {
 		Fcode:       int8(17),
 		Fextra_bits: int8(7),
 	},
 	417: {
 		Fcode:       int8(17),
 		Fextra_bits: int8(7),
 	},
 	418: {
 		Fcode:       int8(17),
 		Fextra_bits: int8(7),
 	},
 	419: {
 		Fcode:       int8(17),
 		Fextra_bits: int8(7),
 	},
 	420: {
 		Fcode:       int8(17),
 		Fextra_bits: int8(7),
 	},
 	421: {
 		Fcode:       int8(17),
 		Fextra_bits: int8(7),
 	},
 	422: {
 		Fcode:       int8(17),
 		Fextra_bits: int8(7),
 	},
 	423: {
 		Fcode:       int8(17),
 		Fextra_bits: int8(7),
 	},
 	424: {
 		Fcode:       int8(17),
 		Fextra_bits: int8(7),
 	},
 	425: {
 		Fcode:       int8(17),
 		Fextra_bits: int8(7),
 	},
 	426: {
 		Fcode:       int8(17),
 		Fextra_bits: int8(7),
 	},
 	427: {
 		Fcode:       int8(17),
 		Fextra_bits: int8(7),
 	},
 	428: {
 		Fcode:       int8(17),
 		Fextra_bits: int8(7),
 	},
 	429: {
 		Fcode:       int8(17),
 		Fextra_bits: int8(7),
 	},
 	430: {
 		Fcode:       int8(17),
 		Fextra_bits: int8(7),
 	},
 	431: {
 		Fcode:       int8(17),
 		Fextra_bits: int8(7),
 	},
 	432: {
 		Fcode:       int8(17),
 		Fextra_bits: int8(7),
 	},
 	433: {
 		Fcode:       int8(17),
 		Fextra_bits: int8(7),
 	},
 	434: {
 		Fcode:       int8(17),
 		Fextra_bits: int8(7),
 	},
 	435: {
 		Fcode:       int8(17),
 		Fextra_bits: int8(7),
 	},
 	436: {
 		Fcode:       int8(17),
 		Fextra_bits: int8(7),
 	},
 	437: {
 		Fcode:       int8(17),
 		Fextra_bits: int8(7),
 	},
 	438: {
 		Fcode:       int8(17),
 		Fextra_bits: int8(7),
 	},
 	439: {
 		Fcode:       int8(17),
 		Fextra_bits: int8(7),
 	},
 	440: {
 		Fcode:       int8(17),
 		Fextra_bits: int8(7),
 	},
 	441: {
 		Fcode:       int8(17),
 		Fextra_bits: int8(7),
 	},
 	442: {
 		Fcode:       int8(17),
 		Fextra_bits: int8(7),
 	},
 	443: {
 		Fcode:       int8(17),
 		Fextra_bits: int8(7),
 	},
 	444: {
 		Fcode:       int8(17),
 		Fextra_bits: int8(7),
 	},
 	445: {
 		Fcode:       int8(17),
 		Fextra_bits: int8(7),
 	},
 	446: {
 		Fcode:       int8(17),
 		Fextra_bits: int8(7),
 	},
 	447: {
 		Fcode:       int8(17),
 		Fextra_bits: int8(7),
 	},
 	448: {
 		Fcode:       int8(17),
 		Fextra_bits: int8(7),
 	},
 	449: {
 		Fcode:       int8(17),
 		Fextra_bits: int8(7),
 	},
 	450: {
 		Fcode:       int8(17),
 		Fextra_bits: int8(7),
 	},
 	451: {
 		Fcode:       int8(17),
 		Fextra_bits: int8(7),
 	},
 	452: {
 		Fcode:       int8(17),
 		Fextra_bits: int8(7),
 	},
 	453: {
 		Fcode:       int8(17),
 		Fextra_bits: int8(7),
 	},
 	454: {
 		Fcode:       int8(17),
 		Fextra_bits: int8(7),
 	},
 	455: {
 		Fcode:       int8(17),
 		Fextra_bits: int8(7),
 	},
 	456: {
 		Fcode:       int8(17),
 		Fextra_bits: int8(7),
 	},
 	457: {
 		Fcode:       int8(17),
 		Fextra_bits: int8(7),
 	},
 	458: {
 		Fcode:       int8(17),
 		Fextra_bits: int8(7),
 	},
 	459: {
 		Fcode:       int8(17),
 		Fextra_bits: int8(7),
 	},
 	460: {
 		Fcode:       int8(17),
 		Fextra_bits: int8(7),
 	},
 	461: {
 		Fcode:       int8(17),
 		Fextra_bits: int8(7),
 	},
 	462: {
 		Fcode:       int8(17),
 		Fextra_bits: int8(7),
 	},
 	463: {
 		Fcode:       int8(17),
 		Fextra_bits: int8(7),
 	},
 	464: {
 		Fcode:       int8(17),
 		Fextra_bits: int8(7),
 	},
 	465: {
 		Fcode:       int8(17),
 		Fextra_bits: int8(7),
 	},
 	466: {
 		Fcode:       int8(17),
 		Fextra_bits: int8(7),
 	},
 	467: {
 		Fcode:       int8(17),
 		Fextra_bits: int8(7),
 	},
 	468: {
 		Fcode:       int8(17),
 		Fextra_bits: int8(7),
 	},
 	469: {
 		Fcode:       int8(17),
 		Fextra_bits: int8(7),
 	},
 	470: {
 		Fcode:       int8(17),
 		Fextra_bits: int8(7),
 	},
 	471: {
 		Fcode:       int8(17),
 		Fextra_bits: int8(7),
 	},
 	472: {
 		Fcode:       int8(17),
 		Fextra_bits: int8(7),
 	},
 	473: {
 		Fcode:       int8(17),
 		Fextra_bits: int8(7),
 	},
 	474: {
 		Fcode:       int8(17),
 		Fextra_bits: int8(7),
 	},
 	475: {
 		Fcode:       int8(17),
 		Fextra_bits: int8(7),
 	},
 	476: {
 		Fcode:       int8(17),
 		Fextra_bits: int8(7),
 	},
 	477: {
 		Fcode:       int8(17),
 		Fextra_bits: int8(7),
 	},
 	478: {
 		Fcode:       int8(17),
 		Fextra_bits: int8(7),
 	},
 	479: {
 		Fcode:       int8(17),
 		Fextra_bits: int8(7),
 	},
 	480: {
 		Fcode:       int8(17),
 		Fextra_bits: int8(7),
 	},
 	481: {
 		Fcode:       int8(17),
 		Fextra_bits: int8(7),
 	},
 	482: {
 		Fcode:       int8(17),
 		Fextra_bits: int8(7),
 	},
 	483: {
 		Fcode:       int8(17),
 		Fextra_bits: int8(7),
 	},
 	484: {
 		Fcode:       int8(17),
 		Fextra_bits: int8(7),
 	},
 	485: {
 		Fcode:       int8(17),
 		Fextra_bits: int8(7),
 	},
 	486: {
 		Fcode:       int8(17),
 		Fextra_bits: int8(7),
 	},
 	487: {
 		Fcode:       int8(17),
 		Fextra_bits: int8(7),
 	},
 	488: {
 		Fcode:       int8(17),
 		Fextra_bits: int8(7),
 	},
 	489: {
 		Fcode:       int8(17),
 		Fextra_bits: int8(7),
 	},
 	490: {
 		Fcode:       int8(17),
 		Fextra_bits: int8(7),
 	},
 	491: {
 		Fcode:       int8(17),
 		Fextra_bits: int8(7),
 	},
 	492: {
 		Fcode:       int8(17),
 		Fextra_bits: int8(7),
 	},
 	493: {
 		Fcode:       int8(17),
 		Fextra_bits: int8(7),
 	},
 	494: {
 		Fcode:       int8(17),
 		Fextra_bits: int8(7),
 	},
 	495: {
 		Fcode:       int8(17),
 		Fextra_bits: int8(7),
 	},
 	496: {
 		Fcode:       int8(17),
 		Fextra_bits: int8(7),
 	},
 	497: {
 		Fcode:       int8(17),
 		Fextra_bits: int8(7),
 	},
 	498: {
 		Fcode:       int8(17),
 		Fextra_bits: int8(7),
 	},
 	499: {
 		Fcode:       int8(17),
 		Fextra_bits: int8(7),
 	},
 	500: {
 		Fcode:       int8(17),
 		Fextra_bits: int8(7),
 	},
 	501: {
 		Fcode:       int8(17),
 		Fextra_bits: int8(7),
 	},
 	502: {
 		Fcode:       int8(17),
 		Fextra_bits: int8(7),
 	},
 	503: {
 		Fcode:       int8(17),
 		Fextra_bits: int8(7),
 	},
 	504: {
 		Fcode:       int8(17),
 		Fextra_bits: int8(7),
 	},
 	505: {
 		Fcode:       int8(17),
 		Fextra_bits: int8(7),
 	},
 	506: {
 		Fcode:       int8(17),
 		Fextra_bits: int8(7),
 	},
 	507: {
 		Fcode:       int8(17),
 		Fextra_bits: int8(7),
 	},
 	508: {
 		Fcode:       int8(17),
 		Fextra_bits: int8(7),
 	},
 	509: {
 		Fcode:       int8(17),
 		Fextra_bits: int8(7),
 	},
 	510: {
 		Fcode:       int8(17),
 		Fextra_bits: int8(7),
 	},
 	511: {
 		Fcode:       int8(17),
 		Fextra_bits: int8(7),
 	},
 }
 
 var kPrefixEncodeExtraBitsValue = [512]uint8_t{
 	6:   uint8(1),
 	8:   uint8(1),
 	10:  uint8(1),
 	11:  uint8(2),
 	12:  uint8(3),
 	14:  uint8(1),
 	15:  uint8(2),
 	16:  uint8(3),
 	18:  uint8(1),
 	19:  uint8(2),
 	20:  uint8(3),
 	21:  uint8(4),
 	22:  uint8(5),
 	23:  uint8(6),
 	24:  uint8(7),
 	26:  uint8(1),
 	27:  uint8(2),
 	28:  uint8(3),
 	29:  uint8(4),
 	30:  uint8(5),
 	31:  uint8(6),
 	32:  uint8(7),
 	34:  uint8(1),
 	35:  uint8(2),
 	36:  uint8(3),
 	37:  uint8(4),
 	38:  uint8(5),
 	39:  uint8(6),
 	40:  uint8(7),
 	41:  uint8(8),
 	42:  uint8(9),
 	43:  uint8(10),
 	44:  uint8(11),
 	45:  uint8(12),
 	46:  uint8(13),
 	47:  uint8(14),
 	48:  uint8(15),
 	50:  uint8(1),
 	51:  uint8(2),
 	52:  uint8(3),
 	53:  uint8(4),
 	54:  uint8(5),
 	55:  uint8(6),
 	56:  uint8(7),
 	57:  uint8(8),
 	58:  uint8(9),
 	59:  uint8(10),
 	60:  uint8(11),
 	61:  uint8(12),
 	62:  uint8(13),
 	63:  uint8(14),
 	64:  uint8(15),
 	66:  uint8(1),
 	67:  uint8(2),
 	68:  uint8(3),
 	69:  uint8(4),
 	70:  uint8(5),
 	71:  uint8(6),
 	72:  uint8(7),
 	73:  uint8(8),
 	74:  uint8(9),
 	75:  uint8(10),
 	76:  uint8(11),
 	77:  uint8(12),
 	78:  uint8(13),
 	79:  uint8(14),
 	80:  uint8(15),
 	81:  uint8(16),
 	82:  uint8(17),
 	83:  uint8(18),
 	84:  uint8(19),
 	85:  uint8(20),
 	86:  uint8(21),
 	87:  uint8(22),
 	88:  uint8(23),
 	89:  uint8(24),
 	90:  uint8(25),
 	91:  uint8(26),
 	92:  uint8(27),
 	93:  uint8(28),
 	94:  uint8(29),
 	95:  uint8(30),
 	96:  uint8(31),
 	98:  uint8(1),
 	99:  uint8(2),
 	100: uint8(3),
 	101: uint8(4),
 	102: uint8(5),
 	103: uint8(6),
 	104: uint8(7),
 	105: uint8(8),
 	106: uint8(9),
 	107: uint8(10),
 	108: uint8(11),
 	109: uint8(12),
 	110: uint8(13),
 	111: uint8(14),
 	112: uint8(15),
 	113: uint8(16),
 	114: uint8(17),
 	115: uint8(18),
 	116: uint8(19),
 	117: uint8(20),
 	118: uint8(21),
 	119: uint8(22),
 	120: uint8(23),
 	121: uint8(24),
 	122: uint8(25),
 	123: uint8(26),
 	124: uint8(27),
 	125: uint8(28),
 	126: uint8(29),
 	127: uint8(30),
 	128: uint8(31),
 	130: uint8(1),
 	131: uint8(2),
 	132: uint8(3),
 	133: uint8(4),
 	134: uint8(5),
 	135: uint8(6),
 	136: uint8(7),
 	137: uint8(8),
 	138: uint8(9),
 	139: uint8(10),
 	140: uint8(11),
 	141: uint8(12),
 	142: uint8(13),
 	143: uint8(14),
 	144: uint8(15),
 	145: uint8(16),
 	146: uint8(17),
 	147: uint8(18),
 	148: uint8(19),
 	149: uint8(20),
 	150: uint8(21),
 	151: uint8(22),
 	152: uint8(23),
 	153: uint8(24),
 	154: uint8(25),
 	155: uint8(26),
 	156: uint8(27),
 	157: uint8(28),
 	158: uint8(29),
 	159: uint8(30),
 	160: uint8(31),
 	161: uint8(32),
 	162: uint8(33),
 	163: uint8(34),
 	164: uint8(35),
 	165: uint8(36),
 	166: uint8(37),
 	167: uint8(38),
 	168: uint8(39),
 	169: uint8(40),
 	170: uint8(41),
 	171: uint8(42),
 	172: uint8(43),
 	173: uint8(44),
 	174: uint8(45),
 	175: uint8(46),
 	176: uint8(47),
 	177: uint8(48),
 	178: uint8(49),
 	179: uint8(50),
 	180: uint8(51),
 	181: uint8(52),
 	182: uint8(53),
 	183: uint8(54),
 	184: uint8(55),
 	185: uint8(56),
 	186: uint8(57),
 	187: uint8(58),
 	188: uint8(59),
 	189: uint8(60),
 	190: uint8(61),
 	191: uint8(62),
 	192: uint8(63),
 	194: uint8(1),
 	195: uint8(2),
 	196: uint8(3),
 	197: uint8(4),
 	198: uint8(5),
 	199: uint8(6),
 	200: uint8(7),
 	201: uint8(8),
 	202: uint8(9),
 	203: uint8(10),
 	204: uint8(11),
 	205: uint8(12),
 	206: uint8(13),
 	207: uint8(14),
 	208: uint8(15),
 	209: uint8(16),
 	210: uint8(17),
 	211: uint8(18),
 	212: uint8(19),
 	213: uint8(20),
 	214: uint8(21),
 	215: uint8(22),
 	216: uint8(23),
 	217: uint8(24),
 	218: uint8(25),
 	219: uint8(26),
 	220: uint8(27),
 	221: uint8(28),
 	222: uint8(29),
 	223: uint8(30),
 	224: uint8(31),
 	225: uint8(32),
 	226: uint8(33),
 	227: uint8(34),
 	228: uint8(35),
 	229: uint8(36),
 	230: uint8(37),
 	231: uint8(38),
 	232: uint8(39),
 	233: uint8(40),
 	234: uint8(41),
 	235: uint8(42),
 	236: uint8(43),
 	237: uint8(44),
 	238: uint8(45),
 	239: uint8(46),
 	240: uint8(47),
 	241: uint8(48),
 	242: uint8(49),
 	243: uint8(50),
 	244: uint8(51),
 	245: uint8(52),
 	246: uint8(53),
 	247: uint8(54),
 	248: uint8(55),
 	249: uint8(56),
 	250: uint8(57),
 	251: uint8(58),
 	252: uint8(59),
 	253: uint8(60),
 	254: uint8(61),
 	255: uint8(62),
 	256: uint8(63),
 	258: uint8(1),
 	259: uint8(2),
 	260: uint8(3),
 	261: uint8(4),
 	262: uint8(5),
 	263: uint8(6),
 	264: uint8(7),
 	265: uint8(8),
 	266: uint8(9),
 	267: uint8(10),
 	268: uint8(11),
 	269: uint8(12),
 	270: uint8(13),
 	271: uint8(14),
 	272: uint8(15),
 	273: uint8(16),
 	274: uint8(17),
 	275: uint8(18),
 	276: uint8(19),
 	277: uint8(20),
 	278: uint8(21),
 	279: uint8(22),
 	280: uint8(23),
 	281: uint8(24),
 	282: uint8(25),
 	283: uint8(26),
 	284: uint8(27),
 	285: uint8(28),
 	286: uint8(29),
 	287: uint8(30),
 	288: uint8(31),
 	289: uint8(32),
 	290: uint8(33),
 	291: uint8(34),
 	292: uint8(35),
 	293: uint8(36),
 	294: uint8(37),
 	295: uint8(38),
 	296: uint8(39),
 	297: uint8(40),
 	298: uint8(41),
 	299: uint8(42),
 	300: uint8(43),
 	301: uint8(44),
 	302: uint8(45),
 	303: uint8(46),
 	304: uint8(47),
 	305: uint8(48),
 	306: uint8(49),
 	307: uint8(50),
 	308: uint8(51),
 	309: uint8(52),
 	310: uint8(53),
 	311: uint8(54),
 	312: uint8(55),
 	313: uint8(56),
 	314: uint8(57),
 	315: uint8(58),
 	316: uint8(59),
 	317: uint8(60),
 	318: uint8(61),
 	319: uint8(62),
 	320: uint8(63),
 	321: uint8(64),
 	322: uint8(65),
 	323: uint8(66),
 	324: uint8(67),
 	325: uint8(68),
 	326: uint8(69),
 	327: uint8(70),
 	328: uint8(71),
 	329: uint8(72),
 	330: uint8(73),
 	331: uint8(74),
 	332: uint8(75),
 	333: uint8(76),
 	334: uint8(77),
 	335: uint8(78),
 	336: uint8(79),
 	337: uint8(80),
 	338: uint8(81),
 	339: uint8(82),
 	340: uint8(83),
 	341: uint8(84),
 	342: uint8(85),
 	343: uint8(86),
 	344: uint8(87),
 	345: uint8(88),
 	346: uint8(89),
 	347: uint8(90),
 	348: uint8(91),
 	349: uint8(92),
 	350: uint8(93),
 	351: uint8(94),
 	352: uint8(95),
 	353: uint8(96),
 	354: uint8(97),
 	355: uint8(98),
 	356: uint8(99),
 	357: uint8(100),
 	358: uint8(101),
 	359: uint8(102),
 	360: uint8(103),
 	361: uint8(104),
 	362: uint8(105),
 	363: uint8(106),
 	364: uint8(107),
 	365: uint8(108),
 	366: uint8(109),
 	367: uint8(110),
 	368: uint8(111),
 	369: uint8(112),
 	370: uint8(113),
 	371: uint8(114),
 	372: uint8(115),
 	373: uint8(116),
 	374: uint8(117),
 	375: uint8(118),
 	376: uint8(119),
 	377: uint8(120),
 	378: uint8(121),
 	379: uint8(122),
 	380: uint8(123),
 	381: uint8(124),
 	382: uint8(125),
 	383: uint8(126),
 	384: uint8(127),
 	386: uint8(1),
 	387: uint8(2),
 	388: uint8(3),
 	389: uint8(4),
 	390: uint8(5),
 	391: uint8(6),
 	392: uint8(7),
 	393: uint8(8),
 	394: uint8(9),
 	395: uint8(10),
 	396: uint8(11),
 	397: uint8(12),
 	398: uint8(13),
 	399: uint8(14),
 	400: uint8(15),
 	401: uint8(16),
 	402: uint8(17),
 	403: uint8(18),
 	404: uint8(19),
 	405: uint8(20),
 	406: uint8(21),
 	407: uint8(22),
 	408: uint8(23),
 	409: uint8(24),
 	410: uint8(25),
 	411: uint8(26),
 	412: uint8(27),
 	413: uint8(28),
 	414: uint8(29),
 	415: uint8(30),
 	416: uint8(31),
 	417: uint8(32),
 	418: uint8(33),
 	419: uint8(34),
 	420: uint8(35),
 	421: uint8(36),
 	422: uint8(37),
 	423: uint8(38),
 	424: uint8(39),
 	425: uint8(40),
 	426: uint8(41),
 	427: uint8(42),
 	428: uint8(43),
 	429: uint8(44),
 	430: uint8(45),
 	431: uint8(46),
 	432: uint8(47),
 	433: uint8(48),
 	434: uint8(49),
 	435: uint8(50),
 	436: uint8(51),
 	437: uint8(52),
 	438: uint8(53),
 	439: uint8(54),
 	440: uint8(55),
 	441: uint8(56),
 	442: uint8(57),
 	443: uint8(58),
 	444: uint8(59),
 	445: uint8(60),
 	446: uint8(61),
 	447: uint8(62),
 	448: uint8(63),
 	449: uint8(64),
 	450: uint8(65),
 	451: uint8(66),
 	452: uint8(67),
 	453: uint8(68),
 	454: uint8(69),
 	455: uint8(70),
 	456: uint8(71),
 	457: uint8(72),
 	458: uint8(73),
 	459: uint8(74),
 	460: uint8(75),
 	461: uint8(76),
 	462: uint8(77),
 	463: uint8(78),
 	464: uint8(79),
 	465: uint8(80),
 	466: uint8(81),
 	467: uint8(82),
 	468: uint8(83),
 	469: uint8(84),
 	470: uint8(85),
 	471: uint8(86),
 	472: uint8(87),
 	473: uint8(88),
 	474: uint8(89),
 	475: uint8(90),
 	476: uint8(91),
 	477: uint8(92),
 	478: uint8(93),
 	479: uint8(94),
 	480: uint8(95),
 	481: uint8(96),
 	482: uint8(97),
 	483: uint8(98),
 	484: uint8(99),
 	485: uint8(100),
 	486: uint8(101),
 	487: uint8(102),
 	488: uint8(103),
 	489: uint8(104),
 	490: uint8(105),
 	491: uint8(106),
 	492: uint8(107),
 	493: uint8(108),
 	494: uint8(109),
 	495: uint8(110),
 	496: uint8(111),
 	497: uint8(112),
 	498: uint8(113),
 	499: uint8(114),
 	500: uint8(115),
 	501: uint8(116),
 	502: uint8(117),
 	503: uint8(118),
 	504: uint8(119),
 	505: uint8(120),
 	506: uint8(121),
 	507: uint8(122),
 	508: uint8(123),
 	509: uint8(124),
 	510: uint8(125),
 	511: uint8(126),
 }
 
 // C documentation
 //
 //	// lookup table for small values of int*log2(int) * (1 << LOG_2_PRECISION_BITS).
 //	// Obtained in Python with:
 //	// a=[ "%d"%i if i<(1<<32) else "%dull"%i
 //	//     for i in [ round((1<<LOG_2_PRECISION_BITS)*math.log2(i)*i) if i
 //	//     else 0 for i in range(256)]]
 //	// print(',\n '.join([','.join(v) for v in batched([i.rjust(15)
 //	//                      for i in a],4)]))
 var kSLog2Table = [256]uint64_t{
 	2:   uint64(16777216),
 	3:   uint64(39886887),
 	4:   uint64(67108864),
 	5:   uint64(97388723),
 	6:   uint64(130105423),
 	7:   uint64(164848600),
 	8:   uint64(201326592),
 	9:   uint64(239321324),
 	10:  uint64(278663526),
 	11:  uint64(319217973),
 	12:  uint64(360874141),
 	13:  uint64(403539997),
 	14:  uint64(447137711),
 	15:  uint64(491600606),
 	16:  uint64(536870912),
 	17:  uint64(582898099),
 	18:  uint64(629637592),
 	19:  uint64(677049776),
 	20:  uint64(725099212),
 	21:  uint64(773754010),
 	22:  uint64(822985323),
 	23:  uint64(872766924),
 	24:  uint64(923074875),
 	25:  uint64(973887230),
 	26:  uint64(1025183802),
 	27:  uint64(1076945958),
 	28:  uint64(1129156447),
 	29:  uint64(1181799249),
 	30:  uint64(1234859451),
 	31:  uint64(1288323135),
 	32:  uint64(1342177280),
 	33:  uint64(1396409681),
 	34:  uint64(1451008871),
 	35:  uint64(1505964059),
 	36:  uint64(1561265072),
 	37:  uint64(1616902301),
 	38:  uint64(1672866655),
 	39:  uint64(1729149526),
 	40:  uint64(1785742744),
 	41:  uint64(1842638548),
 	42:  uint64(1899829557),
 	43:  uint64(1957308741),
 	44:  uint64(2015069397),
 	45:  uint64(2073105127),
 	46:  uint64(2131409817),
 	47:  uint64(2189977618),
 	48:  uint64(2248802933),
 	49:  uint64(2307880396),
 	50:  uint64(2367204859),
 	51:  uint64(2426771383),
 	52:  uint64(2486575220),
 	53:  uint64(2546611805),
 	54:  uint64(2606876748),
 	55:  uint64(2667365819),
 	56:  uint64(2728074942),
 	57:  uint64(2789000187),
 	58:  uint64(2850137762),
 	59:  uint64(2911484006),
 	60:  uint64(2973035382),
 	61:  uint64(3034788471),
 	62:  uint64(3096739966),
 	63:  uint64(3158886666),
 	64:  uint64(3221225472),
 	65:  uint64(3283753383),
 	66:  uint64(3346467489),
 	67:  uint64(3409364969),
 	68:  uint64(3472443085),
 	69:  uint64(3535699182),
 	70:  uint64(3599130679),
 	71:  uint64(3662735070),
 	72:  uint64(3726509920),
 	73:  uint64(3790452862),
 	74:  uint64(3854561593),
 	75:  uint64(3918833872),
 	76:  uint64(3983267519),
 	77:  uint64(4047860410),
 	78:  uint64(4112610476),
 	79:  uint64(4177515704),
 	80:  uint64(4242574127),
 	81:  uint64(4307783833),
 	82:  uint64(4373142952),
 	83:  uint64(4438649662),
 	84:  uint64(4504302186),
 	85:  uint64(4570098787),
 	86:  uint64(4636037770),
 	87:  uint64(4702117480),
 	88:  uint64(4768336298),
 	89:  uint64(4834692645),
 	90:  uint64(4901184974),
 	91:  uint64(4967811774),
 	92:  uint64(5034571569),
 	93:  uint64(5101462912),
 	94:  uint64(5168484389),
 	95:  uint64(5235634615),
 	96:  uint64(5302912235),
 	97:  uint64(5370315922),
 	98:  uint64(5437844376),
 	99:  uint64(5505496324),
 	100: uint64(5573270518),
 	101: uint64(5641165737),
 	102: uint64(5709180782),
 	103: uint64(5777314477),
 	104: uint64(5845565671),
 	105: uint64(5913933235),
 	106: uint64(5982416059),
 	107: uint64(6051013057),
 	108: uint64(6119723161),
 	109: uint64(6188545324),
 	110: uint64(6257478518),
 	111: uint64(6326521733),
 	112: uint64(6395673979),
 	113: uint64(6464934282),
 	114: uint64(6534301685),
 	115: uint64(6603775250),
 	116: uint64(6673354052),
 	117: uint64(6743037185),
 	118: uint64(6812823756),
 	119: uint64(6882712890),
 	120: uint64(6952703725),
 	121: uint64(7022795412),
 	122: uint64(7092987118),
 	123: uint64(7163278025),
 	124: uint64(7233667324),
 	125: uint64(7304154222),
 	126: uint64(7374737939),
 	127: uint64(7445417707),
 	128: uint64(7516192768),
 	129: uint64(7587062379),
 	130: uint64(7658025806),
 	131: uint64(7729082328),
 	132: uint64(7800231234),
 	133: uint64(7871471825),
 	134: uint64(7942803410),
 	135: uint64(8014225311),
 	136: uint64(8085736859),
 	137: uint64(8157337394),
 	138: uint64(8229026267),
 	139: uint64(8300802839),
 	140: uint64(8372666477),
 	141: uint64(8444616560),
 	142: uint64(8516652476),
 	143: uint64(8588773618),
 	144: uint64(8660979393),
 	145: uint64(8733269211),
 	146: uint64(8805642493),
 	147: uint64(8878098667),
 	148: uint64(8950637170),
 	149: uint64(9023257446),
 	150: uint64(9095958945),
 	151: uint64(9168741125),
 	152: uint64(9241603454),
 	153: uint64(9314545403),
 	154: uint64(9387566451),
 	155: uint64(9460666086),
 	156: uint64(9533843800),
 	157: uint64(9607099093),
 	158: uint64(9680431471),
 	159: uint64(9753840445),
 	160: uint64(9827325535),
 	161: uint64(9900886263),
 	162: uint64(9974522161),
 	163: uint64(10048232765),
 	164: uint64(10122017615),
 	165: uint64(10195876260),
 	166: uint64(10269808253),
 	167: uint64(10343813150),
 	168: uint64(10417890516),
 	169: uint64(10492039919),
 	170: uint64(10566260934),
 	171: uint64(10640553138),
 	172: uint64(10714916116),
 	173: uint64(10789349456),
 	174: uint64(10863852751),
 	175: uint64(10938425600),
 	176: uint64(11013067604),
 	177: uint64(11087778372),
 	178: uint64(11162557513),
 	179: uint64(11237404645),
 	180: uint64(11312319387),
 	181: uint64(11387301364),
 	182: uint64(11462350205),
 	183: uint64(11537465541),
 	184: uint64(11612647010),
 	185: uint64(11687894253),
 	186: uint64(11763206912),
 	187: uint64(11838584638),
 	188: uint64(11914027082),
 	189: uint64(11989533899),
 	190: uint64(12065104750),
 	191: uint64(12140739296),
 	192: uint64(12216437206),
 	193: uint64(12292198148),
 	194: uint64(12368021795),
 	195: uint64(12443907826),
 	196: uint64(12519855920),
 	197: uint64(12595865759),
 	198: uint64(12671937032),
 	199: uint64(12748069427),
 	200: uint64(12824262637),
 	201: uint64(12900516358),
 	202: uint64(12976830290),
 	203: uint64(13053204134),
 	204: uint64(13129637595),
 	205: uint64(13206130381),
 	206: uint64(13282682202),
 	207: uint64(13359292772),
 	208: uint64(13435961806),
 	209: uint64(13512689025),
 	210: uint64(13589474149),
 	211: uint64(13666316903),
 	212: uint64(13743217014),
 	213: uint64(13820174211),
 	214: uint64(13897188225),
 	215: uint64(13974258793),
 	216: uint64(14051385649),
 	217: uint64(14128568535),
 	218: uint64(14205807192),
 	219: uint64(14283101363),
 	220: uint64(14360450796),
 	221: uint64(14437855239),
 	222: uint64(14515314443),
 	223: uint64(14592828162),
 	224: uint64(14670396151),
 	225: uint64(14748018167),
 	226: uint64(14825693972),
 	227: uint64(14903423326),
 	228: uint64(14981205995),
 	229: uint64(15059041743),
 	230: uint64(15136930339),
 	231: uint64(15214871554),
 	232: uint64(15292865160),
 	233: uint64(15370910930),
 	234: uint64(15449008641),
 	235: uint64(15527158071),
 	236: uint64(15605359001),
 	237: uint64(15683611210),
 	238: uint64(15761914485),
 	239: uint64(15840268608),
 	240: uint64(15918673369),
 	241: uint64(15997128556),
 	242: uint64(16075633960),
 	243: uint64(16154189373),
 	244: uint64(16232794589),
 	245: uint64(16311449405),
 	246: uint64(16390153617),
 	247: uint64(16468907026),
 	248: uint64(16547709431),
 	249: uint64(16626560636),
 	250: uint64(16705460444),
 	251: uint64(16784408661),
 	252: uint64(16863405094),
 	253: uint64(16942449552),
 	254: uint64(17021541845),
 	255: uint64(17100681785),
 }
 
 var kVP8Log2Range = [128]uint8_t{
 	0:   uint8(7),
 	1:   uint8(6),
 	2:   uint8(6),
 	3:   uint8(5),
 	4:   uint8(5),
 	5:   uint8(5),
 	6:   uint8(5),
 	7:   uint8(4),
 	8:   uint8(4),
 	9:   uint8(4),
 	10:  uint8(4),
 	11:  uint8(4),
 	12:  uint8(4),
 	13:  uint8(4),
 	14:  uint8(4),
 	15:  uint8(3),
 	16:  uint8(3),
 	17:  uint8(3),
 	18:  uint8(3),
 	19:  uint8(3),
 	20:  uint8(3),
 	21:  uint8(3),
 	22:  uint8(3),
 	23:  uint8(3),
 	24:  uint8(3),
 	25:  uint8(3),
 	26:  uint8(3),
 	27:  uint8(3),
 	28:  uint8(3),
 	29:  uint8(3),
 	30:  uint8(3),
 	31:  uint8(2),
 	32:  uint8(2),
 	33:  uint8(2),
 	34:  uint8(2),
 	35:  uint8(2),
 	36:  uint8(2),
 	37:  uint8(2),
 	38:  uint8(2),
 	39:  uint8(2),
 	40:  uint8(2),
 	41:  uint8(2),
 	42:  uint8(2),
 	43:  uint8(2),
 	44:  uint8(2),
 	45:  uint8(2),
 	46:  uint8(2),
 	47:  uint8(2),
 	48:  uint8(2),
 	49:  uint8(2),
 	50:  uint8(2),
 	51:  uint8(2),
 	52:  uint8(2),
 	53:  uint8(2),
 	54:  uint8(2),
 	55:  uint8(2),
 	56:  uint8(2),
 	57:  uint8(2),
 	58:  uint8(2),
 	59:  uint8(2),
 	60:  uint8(2),
 	61:  uint8(2),
 	62:  uint8(2),
 	63:  uint8(1),
 	64:  uint8(1),
 	65:  uint8(1),
 	66:  uint8(1),
 	67:  uint8(1),
 	68:  uint8(1),
 	69:  uint8(1),
 	70:  uint8(1),
 	71:  uint8(1),
 	72:  uint8(1),
 	73:  uint8(1),
 	74:  uint8(1),
 	75:  uint8(1),
 	76:  uint8(1),
 	77:  uint8(1),
 	78:  uint8(1),
 	79:  uint8(1),
 	80:  uint8(1),
 	81:  uint8(1),
 	82:  uint8(1),
 	83:  uint8(1),
 	84:  uint8(1),
 	85:  uint8(1),
 	86:  uint8(1),
 	87:  uint8(1),
 	88:  uint8(1),
 	89:  uint8(1),
 	90:  uint8(1),
 	91:  uint8(1),
 	92:  uint8(1),
 	93:  uint8(1),
 	94:  uint8(1),
 	95:  uint8(1),
 	96:  uint8(1),
 	97:  uint8(1),
 	98:  uint8(1),
 	99:  uint8(1),
 	100: uint8(1),
 	101: uint8(1),
 	102: uint8(1),
 	103: uint8(1),
 	104: uint8(1),
 	105: uint8(1),
 	106: uint8(1),
 	107: uint8(1),
 	108: uint8(1),
 	109: uint8(1),
 	110: uint8(1),
 	111: uint8(1),
 	112: uint8(1),
 	113: uint8(1),
 	114: uint8(1),
 	115: uint8(1),
 	116: uint8(1),
 	117: uint8(1),
 	118: uint8(1),
 	119: uint8(1),
 	120: uint8(1),
 	121: uint8(1),
 	122: uint8(1),
 	123: uint8(1),
 	124: uint8(1),
 	125: uint8(1),
 	126: uint8(1),
 }
 
 // C documentation
 //
 //	// range = ((range - 1) << kVP8Log2Range[range]) + 1
 var kVP8NewRange = [128]uint8_t{
 	0:   uint8(127),
 	1:   uint8(127),
 	2:   uint8(191),
 	3:   uint8(127),
 	4:   uint8(159),
 	5:   uint8(191),
 	6:   uint8(223),
 	7:   uint8(127),
 	8:   uint8(143),
 	9:   uint8(159),
 	10:  uint8(175),
 	11:  uint8(191),
 	12:  uint8(207),
 	13:  uint8(223),
 	14:  uint8(239),
 	15:  uint8(127),
 	16:  uint8(135),
 	17:  uint8(143),
 	18:  uint8(151),
 	19:  uint8(159),
 	20:  uint8(167),
 	21:  uint8(175),
 	22:  uint8(183),
 	23:  uint8(191),
 	24:  uint8(199),
 	25:  uint8(207),
 	26:  uint8(215),
 	27:  uint8(223),
 	28:  uint8(231),
 	29:  uint8(239),
 	30:  uint8(247),
 	31:  uint8(127),
 	32:  uint8(131),
 	33:  uint8(135),
 	34:  uint8(139),
 	35:  uint8(143),
 	36:  uint8(147),
 	37:  uint8(151),
 	38:  uint8(155),
 	39:  uint8(159),
 	40:  uint8(163),
 	41:  uint8(167),
 	42:  uint8(171),
 	43:  uint8(175),
 	44:  uint8(179),
 	45:  uint8(183),
 	46:  uint8(187),
 	47:  uint8(191),
 	48:  uint8(195),
 	49:  uint8(199),
 	50:  uint8(203),
 	51:  uint8(207),
 	52:  uint8(211),
 	53:  uint8(215),
 	54:  uint8(219),
 	55:  uint8(223),
 	56:  uint8(227),
 	57:  uint8(231),
 	58:  uint8(235),
 	59:  uint8(239),
 	60:  uint8(243),
 	61:  uint8(247),
 	62:  uint8(251),
 	63:  uint8(127),
 	64:  uint8(129),
 	65:  uint8(131),
 	66:  uint8(133),
 	67:  uint8(135),
 	68:  uint8(137),
 	69:  uint8(139),
 	70:  uint8(141),
 	71:  uint8(143),
 	72:  uint8(145),
 	73:  uint8(147),
 	74:  uint8(149),
 	75:  uint8(151),
 	76:  uint8(153),
 	77:  uint8(155),
 	78:  uint8(157),
 	79:  uint8(159),
 	80:  uint8(161),
 	81:  uint8(163),
 	82:  uint8(165),
 	83:  uint8(167),
 	84:  uint8(169),
 	85:  uint8(171),
 	86:  uint8(173),
 	87:  uint8(175),
 	88:  uint8(177),
 	89:  uint8(179),
 	90:  uint8(181),
 	91:  uint8(183),
 	92:  uint8(185),
 	93:  uint8(187),
 	94:  uint8(189),
 	95:  uint8(191),
 	96:  uint8(193),
 	97:  uint8(195),
 	98:  uint8(197),
 	99:  uint8(199),
 	100: uint8(201),
 	101: uint8(203),
 	102: uint8(205),
 	103: uint8(207),
 	104: uint8(209),
 	105: uint8(211),
 	106: uint8(213),
 	107: uint8(215),
 	108: uint8(217),
 	109: uint8(219),
 	110: uint8(221),
 	111: uint8(223),
 	112: uint8(225),
 	113: uint8(227),
 	114: uint8(229),
 	115: uint8(231),
 	116: uint8(233),
 	117: uint8(235),
 	118: uint8(237),
 	119: uint8(239),
 	120: uint8(241),
 	121: uint8(243),
 	122: uint8(245),
 	123: uint8(247),
 	124: uint8(249),
 	125: uint8(251),
 	126: uint8(253),
 	127: uint8(127),
 }
 
 var __ccgo_ts = (*reflect.StringHeader)(unsafe.Pointer(&__ccgo_ts1)).Data
 
 var __ccgo_ts1 = "Alpha decoder initialization failed.\x00Could not decode alpha data.\x00Frame setup failed\x00thread initialization failed.\x00no memory during frame initialization.\x00OK\x00no object\x00null VP8Io passed to VP8GetHeaders()\x00Truncated header.\x00Incorrect keyframe parameters.\x00Frame not displayable.\x00cannot parse picture header\x00Bad code word\x00bad partition length\x00cannot parse segment header\x00cannot parse filter header\x00cannot parse partitions\x00Not a key frame.\x00Premature end-of-partition0 encountered.\x00Premature end-of-file encountered.\x00Output aborted.\x00NULL VP8Io parameter in VP8Decode().\x00RIFF\x00WEBP\x00VP8X\x00VP8 \x00VP8L\x00ALPH\x00assembler statements not supported\x00cpu.c\x00GetCPUInfo\x00xgetbv\x00"