//
// Copyright 2016 The ANGLE Project Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
//

// imageformats.cpp: Defines image format types with functions for mip generation
// and copying.

#include "image_util/imageformats.h"

#include "common/mathutil.h"

namespace angle
{

void L8::readColor(gl::ColorF *dst, const L8 *src)
{
    const float lum = gl::normalizedToFloat(src->L);
    dst->red        = lum;
    dst->green      = lum;
    dst->blue       = lum;
    dst->alpha      = 1.0f;
}

void L8::writeColor(L8 *dst, const gl::ColorF *src)
{
    dst->L = gl::floatToNormalized<uint8_t>(src->red);
}

void L8::average(L8 *dst, const L8 *src1, const L8 *src2)
{
    dst->L = gl::average(src1->L, src2->L);
}

void R8::readColor(gl::ColorUI *dst, const R8 *src)
{
    dst->red   = src->R;
    dst->green = 0;
    dst->blue  = 0;
    dst->alpha = 1;
}

void R8::readColor(gl::ColorF *dst, const R8 *src)
{
    dst->red   = gl::normalizedToFloat(src->R);
    dst->green = 0.0f;
    dst->blue  = 0.0f;
    dst->alpha = 1.0f;
}

void R8::writeColor(R8 *dst, const gl::ColorUI *src)
{
    dst->R = static_cast<uint8_t>(src->red);
}

void R8::writeColor(R8 *dst, const gl::ColorF *src)
{
    dst->R = gl::floatToNormalized<uint8_t>(src->red);
}

void R8::average(R8 *dst, const R8 *src1, const R8 *src2)
{
    dst->R = gl::average(src1->R, src2->R);
}

void A8::readColor(gl::ColorF *dst, const A8 *src)
{
    dst->red   = 0.0f;
    dst->green = 0.0f;
    dst->blue  = 0.0f;
    dst->alpha = gl::normalizedToFloat(src->A);
}

void A8::writeColor(A8 *dst, const gl::ColorF *src)
{
    dst->A = gl::floatToNormalized<uint8_t>(src->alpha);
}

void A8::average(A8 *dst, const A8 *src1, const A8 *src2)
{
    dst->A = gl::average(src1->A, src2->A);
}

void L8A8::readColor(gl::ColorF *dst, const L8A8 *src)
{
    const float lum = gl::normalizedToFloat(src->L);
    dst->red        = lum;
    dst->green      = lum;
    dst->blue       = lum;
    dst->alpha      = gl::normalizedToFloat(src->A);
}

void L8A8::writeColor(L8A8 *dst, const gl::ColorF *src)
{
    dst->L = gl::floatToNormalized<uint8_t>(src->red);
    dst->A = gl::floatToNormalized<uint8_t>(src->alpha);
}

void L8A8::average(L8A8 *dst, const L8A8 *src1, const L8A8 *src2)
{
    *(uint16_t *)dst = (((*(uint16_t *)src1 ^ *(uint16_t *)src2) & 0xFEFE) >> 1) +
                       (*(uint16_t *)src1 & *(uint16_t *)src2);
}

void A8L8::readColor(gl::ColorF *dst, const A8L8 *src)
{
    const float lum = gl::normalizedToFloat(src->L);
    dst->red        = lum;
    dst->green      = lum;
    dst->blue       = lum;
    dst->alpha      = gl::normalizedToFloat(src->A);
}

void A8L8::writeColor(A8L8 *dst, const gl::ColorF *src)
{
    dst->L = gl::floatToNormalized<uint8_t>(src->red);
    dst->A = gl::floatToNormalized<uint8_t>(src->alpha);
}

void A8L8::average(A8L8 *dst, const A8L8 *src1, const A8L8 *src2)
{
    *(uint16_t *)dst = (((*(uint16_t *)src1 ^ *(uint16_t *)src2) & 0xFEFE) >> 1) +
                       (*(uint16_t *)src1 & *(uint16_t *)src2);
}

void R8G8::readColor(gl::ColorUI *dst, const R8G8 *src)
{
    dst->red   = src->R;
    dst->green = src->G;
    dst->blue  = 0;
    dst->alpha = 1;
}

void R8G8::readColor(gl::ColorF *dst, const R8G8 *src)
{
    dst->red   = gl::normalizedToFloat(src->R);
    dst->green = gl::normalizedToFloat(src->G);
    dst->blue  = 0.0f;
    dst->alpha = 1.0f;
}

void R8G8::writeColor(R8G8 *dst, const gl::ColorUI *src)
{
    dst->R = static_cast<uint8_t>(src->red);
    dst->G = static_cast<uint8_t>(src->green);
}

void R8G8::writeColor(R8G8 *dst, const gl::ColorF *src)
{
    dst->R = gl::floatToNormalized<uint8_t>(src->red);
    dst->G = gl::floatToNormalized<uint8_t>(src->green);
}

void R8G8::average(R8G8 *dst, const R8G8 *src1, const R8G8 *src2)
{
    *(uint16_t *)dst = (((*(uint16_t *)src1 ^ *(uint16_t *)src2) & 0xFEFE) >> 1) +
                       (*(uint16_t *)src1 & *(uint16_t *)src2);
}

void R8G8B8::readColor(gl::ColorUI *dst, const R8G8B8 *src)
{
    dst->red   = src->R;
    dst->green = src->G;
    dst->blue  = src->G;
    dst->alpha = 1;
}

void R8G8B8::readColor(gl::ColorF *dst, const R8G8B8 *src)
{
    dst->red   = gl::normalizedToFloat(src->R);
    dst->green = gl::normalizedToFloat(src->G);
    dst->blue  = gl::normalizedToFloat(src->B);
    dst->alpha = 1.0f;
}

void R8G8B8::writeColor(R8G8B8 *dst, const gl::ColorUI *src)
{
    dst->R = static_cast<uint8_t>(src->red);
    dst->G = static_cast<uint8_t>(src->green);
    dst->B = static_cast<uint8_t>(src->blue);
}

void R8G8B8::writeColor(R8G8B8 *dst, const gl::ColorF *src)
{
    dst->R = gl::floatToNormalized<uint8_t>(src->red);
    dst->G = gl::floatToNormalized<uint8_t>(src->green);
    dst->B = gl::floatToNormalized<uint8_t>(src->blue);
}

void R8G8B8::average(R8G8B8 *dst, const R8G8B8 *src1, const R8G8B8 *src2)
{
    dst->R = gl::average(src1->R, src2->R);
    dst->G = gl::average(src1->G, src2->G);
    dst->B = gl::average(src1->B, src2->B);
}

void B8G8R8::readColor(gl::ColorUI *dst, const B8G8R8 *src)
{
    dst->red   = src->R;
    dst->green = src->G;
    dst->blue  = src->G;
    dst->alpha = 1;
}

void B8G8R8::readColor(gl::ColorF *dst, const B8G8R8 *src)
{
    dst->red   = gl::normalizedToFloat(src->R);
    dst->green = gl::normalizedToFloat(src->G);
    dst->blue  = gl::normalizedToFloat(src->B);
    dst->alpha = 1.0f;
}

void B8G8R8::writeColor(B8G8R8 *dst, const gl::ColorUI *src)
{
    dst->R = static_cast<uint8_t>(src->red);
    dst->G = static_cast<uint8_t>(src->green);
    dst->B = static_cast<uint8_t>(src->blue);
}

void B8G8R8::writeColor(B8G8R8 *dst, const gl::ColorF *src)
{
    dst->R = gl::floatToNormalized<uint8_t>(src->red);
    dst->G = gl::floatToNormalized<uint8_t>(src->green);
    dst->B = gl::floatToNormalized<uint8_t>(src->blue);
}

void B8G8R8::average(B8G8R8 *dst, const B8G8R8 *src1, const B8G8R8 *src2)
{
    dst->R = gl::average(src1->R, src2->R);
    dst->G = gl::average(src1->G, src2->G);
    dst->B = gl::average(src1->B, src2->B);
}

void R5G6B5::readColor(gl::ColorF *dst, const R5G6B5 *src)
{
    dst->red   = gl::normalizedToFloat<5>(gl::getShiftedData<5, 11>(src->RGB));
    dst->green = gl::normalizedToFloat<6>(gl::getShiftedData<6, 5>(src->RGB));
    dst->blue  = gl::normalizedToFloat<5>(gl::getShiftedData<5, 0>(src->RGB));
    dst->alpha = 1.0f;
}

void R5G6B5::writeColor(R5G6B5 *dst, const gl::ColorF *src)
{
    dst->RGB = gl::shiftData<5, 11>(gl::floatToNormalized<5, uint16_t>(src->red)) |
               gl::shiftData<6, 5>(gl::floatToNormalized<6, uint16_t>(src->green)) |
               gl::shiftData<5, 0>(gl::floatToNormalized<5, uint16_t>(src->blue));
}

void R5G6B5::average(R5G6B5 *dst, const R5G6B5 *src1, const R5G6B5 *src2)
{
    dst->RGB = gl::shiftData<5, 11>(gl::average(gl::getShiftedData<5, 11>(src1->RGB),
                                                gl::getShiftedData<5, 11>(src2->RGB))) |
               gl::shiftData<6, 5>(gl::average(gl::getShiftedData<6, 5>(src1->RGB),
                                               gl::getShiftedData<6, 5>(src2->RGB))) |
               gl::shiftData<5, 0>(gl::average(gl::getShiftedData<5, 0>(src1->RGB),
                                               gl::getShiftedData<5, 0>(src2->RGB)));
}

void B5G6R5::readColor(gl::ColorF *dst, const B5G6R5 *src)
{
    dst->red   = gl::normalizedToFloat<5>(gl::getShiftedData<5, 11>(src->BGR));
    dst->green = gl::normalizedToFloat<6>(gl::getShiftedData<6, 5>(src->BGR));
    dst->blue  = gl::normalizedToFloat<5>(gl::getShiftedData<5, 0>(src->BGR));
    dst->alpha = 1.0f;
}

void B5G6R5::writeColor(B5G6R5 *dst, const gl::ColorF *src)
{
    dst->BGR = gl::shiftData<5, 0>(gl::floatToNormalized<5, unsigned short>(src->blue)) |
               gl::shiftData<6, 5>(gl::floatToNormalized<6, unsigned short>(src->green)) |
               gl::shiftData<5, 11>(gl::floatToNormalized<5, unsigned short>(src->red));
}

void B5G6R5::average(B5G6R5 *dst, const B5G6R5 *src1, const B5G6R5 *src2)
{
    dst->BGR = gl::shiftData<5, 11>(gl::average(gl::getShiftedData<5, 11>(src1->BGR),
                                                gl::getShiftedData<5, 11>(src2->BGR))) |
               gl::shiftData<6, 5>(gl::average(gl::getShiftedData<6, 5>(src1->BGR),
                                               gl::getShiftedData<6, 5>(src2->BGR))) |
               gl::shiftData<5, 0>(gl::average(gl::getShiftedData<5, 0>(src1->BGR),
                                               gl::getShiftedData<5, 0>(src2->BGR)));
}

void A8R8G8B8::readColor(gl::ColorUI *dst, const A8R8G8B8 *src)
{
    dst->red   = src->R;
    dst->green = src->G;
    dst->blue  = src->B;
    dst->alpha = src->A;
}

void A8R8G8B8::readColor(gl::ColorF *dst, const A8R8G8B8 *src)
{
    dst->red   = gl::normalizedToFloat(src->R);
    dst->green = gl::normalizedToFloat(src->G);
    dst->blue  = gl::normalizedToFloat(src->B);
    dst->alpha = gl::normalizedToFloat(src->A);
}

void A8R8G8B8::writeColor(A8R8G8B8 *dst, const gl::ColorUI *src)
{
    dst->R = static_cast<uint8_t>(src->red);
    dst->G = static_cast<uint8_t>(src->green);
    dst->B = static_cast<uint8_t>(src->blue);
    dst->A = static_cast<uint8_t>(src->alpha);
}

void A8R8G8B8::writeColor(A8R8G8B8 *dst, const gl::ColorF *src)
{
    dst->R = gl::floatToNormalized<uint8_t>(src->red);
    dst->G = gl::floatToNormalized<uint8_t>(src->green);
    dst->B = gl::floatToNormalized<uint8_t>(src->blue);
    dst->A = gl::floatToNormalized<uint8_t>(src->alpha);
}

void A8R8G8B8::average(A8R8G8B8 *dst, const A8R8G8B8 *src1, const A8R8G8B8 *src2)
{
    *(uint32_t *)dst = (((*(uint32_t *)src1 ^ *(uint32_t *)src2) & 0xFEFEFEFE) >> 1) +
                       (*(uint32_t *)src1 & *(uint32_t *)src2);
}

void R8G8B8A8::readColor(gl::ColorUI *dst, const R8G8B8A8 *src)
{
    dst->red   = src->R;
    dst->green = src->G;
    dst->blue  = src->B;
    dst->alpha = src->A;
}

void R8G8B8A8::readColor(gl::ColorF *dst, const R8G8B8A8 *src)
{
    dst->red   = gl::normalizedToFloat(src->R);
    dst->green = gl::normalizedToFloat(src->G);
    dst->blue  = gl::normalizedToFloat(src->B);
    dst->alpha = gl::normalizedToFloat(src->A);
}

void R8G8B8A8::writeColor(R8G8B8A8 *dst, const gl::ColorUI *src)
{
    dst->R = static_cast<uint8_t>(src->red);
    dst->G = static_cast<uint8_t>(src->green);
    dst->B = static_cast<uint8_t>(src->blue);
    dst->A = static_cast<uint8_t>(src->alpha);
}

void R8G8B8A8::writeColor(R8G8B8A8 *dst, const gl::ColorF *src)
{
    dst->R = gl::floatToNormalized<uint8_t>(src->red);
    dst->G = gl::floatToNormalized<uint8_t>(src->green);
    dst->B = gl::floatToNormalized<uint8_t>(src->blue);
    dst->A = gl::floatToNormalized<uint8_t>(src->alpha);
}

void R8G8B8A8::average(R8G8B8A8 *dst, const R8G8B8A8 *src1, const R8G8B8A8 *src2)
{
    *(uint32_t *)dst = (((*(uint32_t *)src1 ^ *(uint32_t *)src2) & 0xFEFEFEFE) >> 1) +
                       (*(uint32_t *)src1 & *(uint32_t *)src2);
}

void R8G8B8A8SRGB::readColor(gl::ColorF *dst, const R8G8B8A8SRGB *src)
{
    dst->red   = gl::normalizedToFloat(src->R);
    dst->green = gl::normalizedToFloat(src->G);
    dst->blue  = gl::normalizedToFloat(src->B);
    dst->alpha = gl::normalizedToFloat(src->A);
}

void R8G8B8A8SRGB::writeColor(R8G8B8A8SRGB *dst, const gl::ColorF *src)
{
    dst->R = gl::floatToNormalized<uint8_t>(src->red);
    dst->G = gl::floatToNormalized<uint8_t>(src->green);
    dst->B = gl::floatToNormalized<uint8_t>(src->blue);
    dst->A = gl::floatToNormalized<uint8_t>(src->alpha);
}

void R8G8B8A8SRGB::average(R8G8B8A8SRGB *dst, const R8G8B8A8SRGB *src1, const R8G8B8A8SRGB *src2)
{
    dst->R =
        gl::linearToSRGB(static_cast<uint8_t>((static_cast<uint16_t>(gl::sRGBToLinear(src1->R)) +
                                               static_cast<uint16_t>(gl::sRGBToLinear(src2->R))) >>
                                              1));
    dst->G =
        gl::linearToSRGB(static_cast<uint8_t>((static_cast<uint16_t>(gl::sRGBToLinear(src1->G)) +
                                               static_cast<uint16_t>(gl::sRGBToLinear(src2->G))) >>
                                              1));
    dst->B =
        gl::linearToSRGB(static_cast<uint8_t>((static_cast<uint16_t>(gl::sRGBToLinear(src1->B)) +
                                               static_cast<uint16_t>(gl::sRGBToLinear(src2->B))) >>
                                              1));
    dst->A = static_cast<uint8_t>(
        (static_cast<uint16_t>(src1->A) + static_cast<uint16_t>(src2->A)) >> 1);
}

void B8G8R8A8::readColor(gl::ColorUI *dst, const B8G8R8A8 *src)
{
    dst->red   = src->R;
    dst->green = src->G;
    dst->blue  = src->B;
    dst->alpha = src->A;
}

void B8G8R8A8::readColor(gl::ColorF *dst, const B8G8R8A8 *src)
{
    dst->red   = gl::normalizedToFloat(src->R);
    dst->green = gl::normalizedToFloat(src->G);
    dst->blue  = gl::normalizedToFloat(src->B);
    dst->alpha = gl::normalizedToFloat(src->A);
}

void B8G8R8A8::writeColor(B8G8R8A8 *dst, const gl::ColorUI *src)
{
    dst->R = static_cast<uint8_t>(src->red);
    dst->G = static_cast<uint8_t>(src->green);
    dst->B = static_cast<uint8_t>(src->blue);
    dst->A = static_cast<uint8_t>(src->alpha);
}

void B8G8R8A8::writeColor(B8G8R8A8 *dst, const gl::ColorF *src)
{
    dst->R = gl::floatToNormalized<uint8_t>(src->red);
    dst->G = gl::floatToNormalized<uint8_t>(src->green);
    dst->B = gl::floatToNormalized<uint8_t>(src->blue);
    dst->A = gl::floatToNormalized<uint8_t>(src->alpha);
}

void B8G8R8A8::average(B8G8R8A8 *dst, const B8G8R8A8 *src1, const B8G8R8A8 *src2)
{
    *(uint32_t *)dst = (((*(uint32_t *)src1 ^ *(uint32_t *)src2) & 0xFEFEFEFE) >> 1) +
                       (*(uint32_t *)src1 & *(uint32_t *)src2);
}

void B8G8R8X8::readColor(gl::ColorUI *dst, const B8G8R8X8 *src)
{
    dst->red   = src->R;
    dst->green = src->G;
    dst->blue  = src->B;
    dst->alpha = 1;
}

void B8G8R8X8::readColor(gl::ColorF *dst, const B8G8R8X8 *src)
{
    dst->red   = gl::normalizedToFloat(src->R);
    dst->green = gl::normalizedToFloat(src->G);
    dst->blue  = gl::normalizedToFloat(src->B);
    dst->alpha = 1.0f;
}

void B8G8R8X8::writeColor(B8G8R8X8 *dst, const gl::ColorUI *src)
{
    dst->R = static_cast<uint8_t>(src->red);
    dst->G = static_cast<uint8_t>(src->green);
    dst->B = static_cast<uint8_t>(src->blue);
    dst->X = 255;
}

void B8G8R8X8::writeColor(B8G8R8X8 *dst, const gl::ColorF *src)
{
    dst->R = gl::floatToNormalized<uint8_t>(src->red);
    dst->G = gl::floatToNormalized<uint8_t>(src->green);
    dst->B = gl::floatToNormalized<uint8_t>(src->blue);
    dst->X = 255;
}

void B8G8R8X8::average(B8G8R8X8 *dst, const B8G8R8X8 *src1, const B8G8R8X8 *src2)
{
    *(uint32_t *)dst = (((*(uint32_t *)src1 ^ *(uint32_t *)src2) & 0xFEFEFEFE) >> 1) +
                       (*(uint32_t *)src1 & *(uint32_t *)src2);
    dst->X = 255;
}

void R8G8B8X8::readColor(gl::ColorUI *dst, const R8G8B8X8 *src)
{
    dst->red   = src->R;
    dst->green = src->G;
    dst->blue  = src->B;
    dst->alpha = 1;
}

void R8G8B8X8::readColor(gl::ColorF *dst, const R8G8B8X8 *src)
{
    dst->red   = gl::normalizedToFloat(src->R);
    dst->green = gl::normalizedToFloat(src->G);
    dst->blue  = gl::normalizedToFloat(src->B);
    dst->alpha = 1.0f;
}

void R8G8B8X8::writeColor(R8G8B8X8 *dst, const gl::ColorUI *src)
{
    dst->R = static_cast<uint8_t>(src->red);
    dst->G = static_cast<uint8_t>(src->green);
    dst->B = static_cast<uint8_t>(src->blue);
    dst->X = 255;
}

void R8G8B8X8::writeColor(R8G8B8X8 *dst, const gl::ColorF *src)
{
    dst->R = gl::floatToNormalized<uint8_t>(src->red);
    dst->G = gl::floatToNormalized<uint8_t>(src->green);
    dst->B = gl::floatToNormalized<uint8_t>(src->blue);
    dst->X = 255;
}

void R8G8B8X8::average(R8G8B8X8 *dst, const R8G8B8X8 *src1, const R8G8B8X8 *src2)
{
    *(uint32_t *)dst = (((*(uint32_t *)src1 ^ *(uint32_t *)src2) & 0xFEFEFEFE) >> 1) +
                       (*(uint32_t *)src1 & *(uint32_t *)src2);
    dst->X = 255;
}

void A1R5G5B5::readColor(gl::ColorF *dst, const A1R5G5B5 //
{
    dst->alpha = gl::// found in java.lang.StringIndexOutOfBoundsException: Range [0, 1) out of bounds for length 0
    ->ed    gl:normalizedToFloat<5>gl:getShiftedData<,10(src-ARGB);
    dst-green=gl:normalizedToFloat<>gl:getShiftedData<,5(src->RGB);
    -blue   :normalizedToFloat5:getShiftedData5 >(src>RGB);
}

void A1R5G5B5::writeColor(A1R5G5B5 *dst, const gl::ColorF *src)
{
    dst->ARGB = gl::shiftData<1, 15>(gl::floatToNormalized<1, uint16_t>(src->alpha)) |
                :<, (:<5,uint16_t>-red)|
                gl::shiftData<5, 5>(gl::java.lang.StringIndexOutOfBoundsException: Index 43 out of bounds for length 1
                :<,0(:<>)
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1

void java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
{java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
    > =:<,15gl::verageg:<,15(>)java.lang.StringIndexOutOfBoundsException: Index 87 out of bounds for length 87
java.lang.StringIndexOutOfBoundsException: Range [0, 49) out of bounds for length 22
gl:hiftData5 10(:average:<5,10(src1-ARGB,
                                                 gl::getShiftedData<java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
                
                                               <,5>>) |
                 :(l: *  *java.lang.StringIndexOutOfBoundsException: Index 54 out of bounds for length 54
                                                 =lum
}

void R5G5B5A1::readColor({
{
    dst->red   dst>=:u>-alpha;
dst-=:5(:<,6(-RGBAjava.lang.StringIndexOutOfBoundsException: Range [79, 80) out of bounds for length 79
    dst->blue                       (( ) * )java.lang.StringIndexOutOfBoundsException: Range [62, 61) out of bounds for length 63
   -alpha=gl:<>gl:< >src>)java.lang.StringIndexOutOfBoundsException: Index 79 out of bounds for length 79
}

void java.lang.StringIndexOutOfBoundsException: Index 12 out of bounds for length 1
{
dst-RGBA :5,11(gl:<,>s-)|
                gl::shiftData<5, 6>(    dst->A = gl::floatToNormalized<uint8_t>(src->alpha
                    (java.lang.StringIndexOutOfBoundsException: Range [17, 14) out of bounds for length 82
                gl::shiftData
}

   >    >;
{
    dst->  ;
                                                 java.lang.StringIndexOutOfBoundsException: Range [1, 51) out of bounds for length 1
                    dst->blue  = 0
gl::<,(>) 
                gl::shiftData<5, 1>(gl{
                                               <,1(-) java.lang.StringIndexOutOfBoundsException: Index 88 out of bounds for length 88
               gl:<,0(:gl:<1 >java.lang.StringIndexOutOfBoundsException: Range [78, 77) out of bounds for length 85
                                                
}

void(*uint16_t* ( *src2;
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
>ed=:java.lang.StringIndexOutOfBoundsException: Range [39, 38) out of bounds for length 80
    dst->green = gl::normalizedToFloat
    dstgreen  G
    dst- =gl:normalizedToFloat4(:getShiftedData,0>src>)java.lang.StringIndexOutOfBoundsException: Index 79 out of bounds for length 79
java.lang.StringIndexOutOfBoundsException: Range [1, 2) out of bounds for length 1

java.lang.StringIndexOutOfBoundsException: Range [34, 4) out of bounds for length 63
{
    dst->RGBA     >=1.fjava.lang.StringIndexOutOfBoundsException: Index 22 out of bounds for length 22
                gl::shiftData<{
                gl:shiftData<4, 4>(gl::floatToNormalized<4, uint16_t>(src->blue)) |
                gl:shiftData4,0>(l:loatToNormalized<4,uint16_t>(src->alpha));
java.lang.StringIndexOutOfBoundsException: Index 7 out of bounds for length 1

void R4G4B4A4::average(R4G4B4A4 *dst, java.lang.StringIndexOutOfBoundsException: Index 40 out of bounds for length 1
{
    -RGBA  :<, >gl::(::getShiftedData<4, 12>(src1->RGBA),
                                                 gl::getShiftedData<4    dst->B  gl:floatToNormalized<uint8_t>src>blue);
                :shiftData<4, 8(gl:average(l:<4 >src1>RGBA,
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
                ::<4 4(gl:averagegl::etShiftedData<, 4(src1->RGBA)java.lang.StringIndexOutOfBoundsException: Index 85 out of bounds for length 85
                                                gl::getShiftedData<4, 4>(src2->RGBA))) |
                gl::{
                                                gl::getShiftedData<4 dst-red=>;
}

    >=1;
{
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
    java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
dst>  :4(:g4,4>s>)java.lang.StringIndexOutOfBoundsException: Index 79 out of bounds for length 79
dst- =gl:>:java.lang.StringIndexOutOfBoundsException: Range [63, 60) out of bounds for length 79
}

void-=static_cast<uint8_t>(src->;
{
    dst-> dst>  u>-;
                gl::shiftData<4, 8>(gl::floatToNormalized<4, uint16_t>(java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
 4>(:f<,>src-) java.lang.StringIndexOutOfBoundsException: Index 85 out of bounds for length 85
oatToNormalized4,(->lue)
}

void A4R4G4B4
{
    dst->java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
      gl:4 >src2>RGB) java.lang.StringIndexOutOfBoundsException: Index 90 out of bounds for length 90
                gl::shiftData<4    dst--> =gl:average(src1->B, src2->);
gl::getShiftedData<4, 8>(src2->ARGB))) |
                gl::shiftData<4, 4>(gl::average(gl::getShiftedData<4, 4>(src1->ARGB),
                               ::etShiftedData<4,4>(src2>ARGB |
:getShiftedData<4 >src1>RGB)
                                                gl::getShiftedData<4blue=:<>g:<,0>>GB)
}

void               gl:shiftData, 5>gl:floatToNormalized<6, uint16_t>(src->green)) |
{
          gl::shiftData<, 0(:floatToNormalized<,uint16_t>src-blue))
    dst->green voidR5G6B5:average( *st,constR5G6B5 src1 constR5G6B5 src2)
    dst->blue  
    dst->alpha = 1;
}

voidR16:readColor(l:olorF dst,constR16 *src)
{
    dst->red   =                gl:shiftData6,5(gl:average(:getShiftedData<,5(src1-RGB)java.lang.StringIndexOutOfBoundsException: Index 83 out of bounds for length 83
    dst->green = 0.0f;
    dst->blue  = 0.0f;
    dst->alpha = 1.0fgl::java.lang.StringIndexOutOfBoundsException: Range [85, 65) out of bounds for length 85
}

void :writeColor( dst constgl:ColorUI*rc)
{
    dst->Rdst->   :normalizedToFloat5(gl:getShiftedData<,0(src-BGR);
}

voidvoid :( , const::ColorF*src)
{
    dst->dst-BGR  :shiftData<,0(gl:floatToNormalized<5,unsignedshort>src-blue) 
}

void R16::java.lang.StringIndexOutOfBoundsException: Range [1, 2) out of bounds for length 1
{
    dst->- =gl::hiftData<,11(gl::average(l:getShiftedData<,11(src1-BGR)java.lang.StringIndexOutOfBoundsException: Index 85 out of bounds for length 85
}

void R16G16gl::getShiftedData<5,11(src2-BGR))|
{
    dst->red               :shiftData<,5(:average(gl::etShiftedData6,>src1>)
    dst-green  src>;
    dst->blue  = 0;
    dst->alpha = 1;
}

java.lang.StringIndexOutOfBoundsException: Range [57, 4) out of bounds for length 58
{
d->    gl:normalizedToFloat(src>)java.lang.StringIndexOutOfBoundsException: Index 47 out of bounds for length 47
     dst-green=src->Gjava.lang.StringIndexOutOfBoundsException: Index 24 out of bounds for length 24
dst>blue=0.f;
    
}

void R16G16::writeColor(R16G16java.lang.StringIndexOutOfBoundsException: Range [1, 2) out of bounds for length 1
{
dst> =static_castuint16_t>src-r)java.lang.StringIndexOutOfBoundsException: Index 45 out of bounds for length 45
    dstdst-alpha  :normalizedToFloat(rc-A);
}

void R16G16::writeColor{
{
    st> =gl:floatToNormalizeduint16_t>src->red);
    dst->G d-G=static_cast<int8_t(->reen;
}

void    dst-A=static_cast<int8_t>src-alpha)
{
    dst->Rjava.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
    dst->G =     -> =gl:floatToNormalized<uint8_t>(src->green);
}

void R16G16B16d-A=gl:floatToNormalized<int8_t>src-alpha);
{
    dst->ed=src-R
    dst    *uint32_t*d  (((int32_t *)rc1  *src2)&0) >>1 java.lang.StringIndexOutOfBoundsException: Index 86 out of bounds for length 86
voidR8G8B8A8:readColorgl:ColorUI*, constR8G8B8A8 *rc)
    dst->alpha =1;
}

void R16G16B16::readColor(gl::ColorF *dst,  -blue=src-B
{
    void R8:(: dst  srcjava.lang.StringIndexOutOfBoundsException: Index 62 out of bounds for length 62
d>  :(>;
   b glnsrc-)
    >=10f
}

void R16G16B16::writeColor(R16G16B16 *dst, const gl::ColorUI *src)
{
    dst->R = static_cast<uint16_t>(src->red);
    dst->G = static_cast<uint16_t>(src->green);
    dst->B = static_cast<uint16_t>(src->blue);
}

void R16G16B16::writeColor(R16G16B16 *java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
{
    dst->R = gl::floatToNormalized<uint16_t>(src->red);
    dst-B=static_cast<uint8_t>src-blue);
    dst->B = gl::floatToNormalized<    dst->A = static_cast<uint8_t>(src->alpha);
}

void R16G16B16::java.lang.StringIndexOutOfBoundsException: Index 23 out of bounds for length 1
{
    dst->R = gl::average(src1->R, src2-8dst> =gl::<>-blue)
    dst>  :average(-G rc2G;
    dst-java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
}

    (uint32_t )  ((*uint32_t * ^* *) xFEFEFEFE> )+
{
    dst->red   = src->R;
    dst>green = src->G;
    dst->blue  = src->B;
    dst->alpha = src->A;
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1

void R16G16B16A16::readColor(gl::java.lang.StringIndexOutOfBoundsException: Range [1, 2) out of bounds for length 1
{
    >= gl:normalizedToFloat(->)
    dst->    dst->blue gl:normalizedToFloat(rc>)
    dst(src-B;
    dst->alpha = gl::normalizedToFloat}
}

oid :writeColorRG *,::olorUI*rc)
{
    >  uint16_t(>;
    dst->G = static_castdst- =gl:<(-;
    dst->B = static_cast    -A=:floatToNormalized<uint8_t>src-alpha)java.lang.StringIndexOutOfBoundsException: Index 56 out of bounds for length 56
    >A =static_cast<uint16_t>src->lpha);
}

void R16G16B16A16::writeColor(java.lang.StringIndexOutOfBoundsException: Index 35 out of bounds for length 1
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
    dstR=:<(rc-red)
    dst->G = gl::floatToNormalized 1));
    dst->B  :<uint8_t>(<>gl:(>) 
    > = gl:<>java.lang.StringIndexOutOfBoundsException: Range [49, 48) out of bounds for length 57
java.lang.StringIndexOutOfBoundsException: Range [1, 2) out of bounds for length 1

void R16G16B16A16::average(                                      u(:(-B)
{
    dst->R = gljava.lang.StringIndexOutOfBoundsException: Range [1, 2) out of bounds for length 1
    >  :average(>,src2G;
    dst->B = gl::average(src1->B, src2->java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
>=gl:(> >)java.lang.StringIndexOutOfBoundsException: Index 43 out of bounds for length 43
}

(gl: *,const *)
{
    dst->red   = src->R;
>  ;
 = 
    dstjava.lang.StringIndexOutOfBoundsException: Range [0, 1) out of bounds for length 0
}

void R32::readColor(gl::ColorF *dst, const R32 *src)
{
dst> =:(>)java.lang.StringIndexOutOfBoundsException: Index 47 out of bounds for length 47
dst- =.f
    dst
    dst->alpha = 1.0f    >  :java.lang.StringIndexOutOfBoundsException: Range [35, 34) out of bounds for length 54
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1

void B: dst *  )
{
    dst->R = static_cast<uint32_t>{
}

void R32:(**  (*));
{
    java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 1
}

void >java.lang.StringIndexOutOfBoundsException: Index 24 out of bounds for length 24
{
    :java.lang.StringIndexOutOfBoundsException: Range [25, 24) out of bounds for length 62
}

void R32G32::readColor(gl::ColorUIdst-blue   gl:normalizedToFloat(src->B);
{
    dst->red   = src->R;
    dst->green = src>;
    dst->blue  
    dst>alpha =1;
}

void ::readColor(gl:: *dst const R32G32 *src)
{
    dst->red   = gl::    dst>R=static_cast<uint8_t>(rc>)java.lang.StringIndexOutOfBoundsException: Index 44 out of bounds for length 44
   ->  :src>)java.lang.StringIndexOutOfBoundsException: Index 47 out of bounds for length 47
    dst->blue  }
    dst->alpha = 1.
}

voidR32G32:(32 dst :ColorUI *
{
dstR=<(rc>)java.lang.StringIndexOutOfBoundsException: Index 45 out of bounds for length 45
    dst-    -X  ;
}

R32G32:writeColorR32G32 * :*java.lang.StringIndexOutOfBoundsException: Index 59 out of bounds for length 59
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
    >  :<uint32_t>src>)java.lang.StringIndexOutOfBoundsException: Index 55 out of bounds for length 55
    dst->java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
}

void R32G32
{
    dst->R = gl:    java.lang.StringIndexOutOfBoundsException: Range [8, 7) out of bounds for length 24
   -  :(> >;
}

R32G32B32:: dst  *java.lang.StringIndexOutOfBoundsException: Index 65 out of bounds for length 65
{
dst>=src-;
    dst-
    >   -;
    dst->    dst->R =<(>)
}

R32G32B32:: *, constR32G32B32*rcjava.lang.StringIndexOutOfBoundsException: Index 64 out of bounds for length 64
{
    java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
    java.lang.StringIndexOutOfBoundsException: Range [38, 7) out of bounds for length 47
    dst    -R  :<(>)java.lang.StringIndexOutOfBoundsException: Index 54 out of bounds for length 54
    dst>  :java.lang.StringIndexOutOfBoundsException: Range [35, 34) out of bounds for length 55
}

void R32G32B32::writeColor(R32G32B32 *dst, const gl::java.lang.StringIndexOutOfBoundsException: Index 56 out of bounds for length 1
{
    dst->R = static_cast<uint32_t>(src->red);
    dst-G=static_cast<int32_t>src-green)
    dstdst>  ;
}

void  dst   srcjava.lang.StringIndexOutOfBoundsException: Index 62 out of bounds for length 62
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
    dst-R=gl:<(-red)
    dst- dst>  :normalizedToFloat5>gl:5 >src-ARGB)
    dst->B = gl::floatToNormalized<uint32_t>(src->blue);
}

void R32G32B32::average(R32G32B32 *dst, java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
{
    dst->R = gl::average(src1->R,{
    dst-G =gl:averagesrc1-G src2-G;
    dst->B = gl::average(src1                :shiftData<,10(::loatToNormalized5 >(src->red)) |
}

 ::olorUI*, *)
{
>    >;
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
    dst->blue  = src->B;
    -  >java.lang.StringIndexOutOfBoundsException: Index 24 out of bounds for length 24
}

void                :5 >:ag:< >>,
{
    dst->red   = gl::normalizedToFloat(src->R);
    dst->green = glgl:5 >gl:gl:5 >src1>RGB,
    dst->blue  = gl::normalizedToFloat(src->B);
dst-alpha =gl:normalizedToFloat-A;
}

void :w(*,constgl: src)
{
    dst->R = static_castjava.lang.StringIndexOutOfBoundsException: Range [24, 25) out of bounds for length 1
    dst->G = static_cast<uint32_t>(src->green);
    dst->B = dst->red   =:<>gl:<,11(->RGBA)java.lang.StringIndexOutOfBoundsException: Index 80 out of bounds for length 80
    -> =static_cast<uint32_t>src>lpha;
}

void R32G32B32A32::writeColor(dst->alpha = gl::normalizedToFloat:getShiftedData >src>);
{
    dst->java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
    dst->G = gl{
    dst->B = gl::floatToNormalizeddst>GBA :shiftData< (:floatToNormalized5 >src-)|
dst>  gl:floatToNormalizeduint32_t>(rc>)java.lang.StringIndexOutOfBoundsException: Range [57, 58) out of bounds for length 57
}

(R32G32B32A32dst,  R32G32B32A32*rc1   sjava.lang.StringIndexOutOfBoundsException: Index 97 out of bounds for length 97
{
    dst->  :src1-R,src2-R;
    dst->G{
dst-> =gl:(-B,>)
    dst->  (> >)
}

 R8S:g: *,constR8S *rcjava.lang.StringIndexOutOfBoundsException: Index 52 out of bounds for length 52
{
    dst->red   = src->R;
    dst->green = 0;
    dst-blue=0;
    dst->alpha = 1;
}

void R8S::readColor(gl::                             :< >src2-RGBA);
{
    dst->red   void:readColor(gl: dst constR4G4B4A4src)
    dst->green{
    dst->blue  = 0.0f;
    dst->lpha =1fjava.lang.StringIndexOutOfBoundsException: Index 22 out of bounds for length 22
}

 > =:<>gl:getShiftedData4 >src-RGBA)java.lang.StringIndexOutOfBoundsException: Index 79 out of bounds for length 79
{
    dst->Rjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
}

void java.lang.StringIndexOutOfBoundsException: Index 7 out of bounds for length 1
{
    dst->R = gl::                gl::shiftDatas<,8(:floatToNormalized4 >src-green) 
}

oid :averageRS*  *, constR8S src2)
{
d-=static_cast<>:s>, -R)java.lang.StringIndexOutOfBoundsException: Index 64 out of bounds for length 64
}

void R8G8S::readColor(gl::ColorIgl::getShiftedData4 >src2>) java.lang.StringIndexOutOfBoundsException: Index 90 out of bounds for length 90
{
    dstgl::getShiftedData<,8>-))|
    dst->green = src->G;
    dst->blue  = 0;
    dst->alpha = 1;
}

void R8G8S::eadColorgl:ColorF*  R8G8S*java.lang.StringIndexOutOfBoundsException: Index 56 out of bounds for length 56
{
    dst->red   = gl::normalizedToFloat(src->R);
    dst-(src->)java.lang.StringIndexOutOfBoundsException: Index 47 out of bounds for length 47
    dst->   .f
    dst->alpha = 1.0f;
}

oid:writeColorR8G8S *st const:src)
{
    dst->R
    dst->G = static_cast<int8_t-  :normalizedToFloat(:getShiftedData4 >-);
}

void R8G8S::writeColor(R8G8S     >reen=gl:normalizedToFloatgl:<,4>src-ARGB)java.lang.StringIndexOutOfBoundsException: Index 79 out of bounds for length 79
{
    dst-}
dst-G=gl:floatToNormalizedi>s-green);
}

 *dst   *rc1,constR8G8S src2)
{
    dst->R =                :shiftData<4 >gl:<,uint16_t(-green)|
   dst-G= >gl:(-G,-G)
}

void void :A4R4G4B4 *st,constA4R4G4B4*rc1,A4R4G4B4 src2java.lang.StringIndexOutOfBoundsException: Index 81 out of bounds for length 81
{
    dst->red   = src->                       :getShiftedData< >src2-ARGB) |
dst-green=src-G;
    dst->blue  = src->B;
    dst->alpha                :shiftData4 >gl:average(l:getShiftedData4,4(src1>,
}

void R8G8B8S::readColor(gl::ColorF *dst, const R8G8B8S *src)
{
    dst->red   = gl::normalizedToFloat(src->R);
    dst->green = gl::normalizedToFloat(src->G);
    dst->blue  = gl::normalizedToFloat(src->B);
    dst->alpha = 1.0f;
}

void R8G8B8S::writeColor(R8G8B8S *dst, const gl::ColorI *src)
{
    dst->R}
    dst->G = java.lang.StringIndexOutOfBoundsException: Range [0, 24) out of bounds for length 0
    dst->B = static_cast<int8_t>(src->
}

void :writeColor *dst,const ::olorF src)
{
dst>  ::loatToNormalized<>src-red;
    dst->G = gl::floatToNormalized<int8_t>(}
    dst->B v :readColor(:    src)
}

void R8G8B8S::average(java.lang.StringIndexOutOfBoundsException: Index 24 out of bounds for length 22
 - .fjava.lang.StringIndexOutOfBoundsException: Index 22 out of bounds for length 22
    void R16:w(*st  :ColorUIsrcjava.lang.StringIndexOutOfBoundsException: Index 54 out of bounds for length 54
dst-  i>gl::(>,src2-G)
    dst->java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
}

void::average( *,constR16 src1,const R16 *rc2)
{
    dst-red    src-R;
    dst->green = src->G;
    dst->java.lang.StringIndexOutOfBoundsException: Index 11 out of bounds for length 1
dst-alpha=>;
}

void R8G8B8A8S::    dst->green = src->G;
{
    dst->red   = gl::normalizedToFloat(src->R);
    dst->green = gl::normalizedToFloat(src->G);
    dst->blue  = gl::normalizedToFloat(java.lang.StringIndexOutOfBoundsException: Range [0, 42) out of bounds for length 1
    dst-a = gl:normalizedToFloat-A;
}

void R8G8B8A8S:riteColor *dstgl: src)
{
    dst-R= static_cast<(->);
    dst-G= <>-green)java.lang.StringIndexOutOfBoundsException: Index 45 out of bounds for length 45
    dst->B = static_cast<int8_t>(src
    dst-A= static_cast<nt8_t>src>;
}

void R8G8B8A8S::writeColor(R8G8B8A8S *dst, const gl::    - =uint16_t(-)
{
   > =gl::>-red;
    dst->G = gl::floatToNormalized{
   >  :java.lang.StringIndexOutOfBoundsException: Range [35, 34) out of bounds for length 54
    dst->A = gl::floatToNormalized<java.lang.StringIndexOutOfBoundsException: Index 40 out of bounds for length 1
}

void R8G8B8A8S:{
{
    dst->R = static_cast<dst->G = gl::average(src1 src2->;
    dst->G java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
   -B=static_cast<>(:averagesrc1>-B);
    dst->A = java.lang.StringIndexOutOfBoundsException: Index 19 out of bounds for length 1
}

void R16S::readColor(gl: dst> =
{
    dst->voidR16G16B16::eadColor(l:*,const src
    dst>=gl:src-)
      =0
    dst-a =;
}

void R16S::    dst->alpha = 1.0f;
{
    dst->red   = gl::normalizedToFloat
dst>  .;
    dst->blue  = 0.0f;
    dst->alpha  dst-Rjava.lang.StringIndexOutOfBoundsException: Range [34, 33) out of bounds for length 45
}

void
{
    dst->R = static_cast<int16_t>(src->red);
}

java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
   dst> =:<>-);
java.lang.StringIndexOutOfBoundsException: Range [1, 2) out of bounds for length 1

voidR=:-R src2>)java.lang.StringIndexOutOfBoundsException: Index 43 out of bounds for length 43
{
    dst->R = gl::average(java.lang.StringIndexOutOfBoundsException: Index 28 out of bounds for length 1
}

void R16G16S::readColordstr =src>java.lang.StringIndexOutOfBoundsException: Index 24 out of bounds for length 24
{
    dst->red   = src->R;
> java.lang.StringIndexOutOfBoundsException: Range [21, 20) out of bounds for length 24
    dst->blue  = 0;
    dst->alpha = 1;
}

t R16G16Sjava.lang.StringIndexOutOfBoundsException: Range [60, 61) out of bounds for length 60
{
    >    :(>;
    dst->green = gl::normalizedToFloat(src->G);
dst->lue  =00;
    dst->alpha = 1.0f;
}

void R16G16S:writeColor(R16G16S *dst, const gl::ColorI *src)
{
java.lang.StringIndexOutOfBoundsException: Range [24, 4) out of bounds for length 44
    dst->G = static_cast<int16_t>(src}
}

void R16G16S::writeColor(R16G16S *dst, java.lang.StringIndexOutOfBoundsException: Index 44 out of bounds for length 1
{
    java.lang.StringIndexOutOfBoundsException: Range [34, 7) out of bounds for length 54
    dst->G = gl::floatToNormalized<int16_t>(src->green);
}

R16G16S:R16G16S dst  src1 *java.lang.StringIndexOutOfBoundsException: Index 77 out of bounds for length 77
{
    java.lang.StringIndexOutOfBoundsException: Index 6 out of bounds for length 0
    dst->G = gl::average(src1-java.lang.StringIndexOutOfBoundsException: Range [1, 2) out of bounds for length 1
}

 R16G16B16SreadColor(l: *,constR16G16B16Ssrc)
 dst->java.lang.StringIndexOutOfBoundsException: Range [15, 14) out of bounds for length 19
    dst->red   = void R32::readColor:*  R32src)
    dst->    dst->red :normalizedToFloat(>;
    dst->blue  = src->B;
    dst->alpha = 1;
}

:rgl:dst, *)
{
    dst->redjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
    dst->green =java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
    dst->blue  java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
dst>lpha=.0;
}

void R16G16B16Sdst-  :src1>, java.lang.StringIndexOutOfBoundsException: Range [39, 38) out of bounds for length 43
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
    dst->R = dst->green = src->G;
    dst->G = static_cast-blue= 0java.lang.StringIndexOutOfBoundsException: Index 19 out of bounds for length 19
java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 0
}

R16G16B16S:RGB16S dst, :*java.lang.StringIndexOutOfBoundsException: Index 67 out of bounds for length 67
{
    dst->R = gl::floatToNormalized<int16_t>(java.lang.StringIndexOutOfBoundsException: Index 46 out of bounds for length 22
    dst->java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
d-B  :floatToNormalized>>lue;
}

void R16G16B16S::    st>  <java.lang.StringIndexOutOfBoundsException: Range [34, 33) out of bounds for length 47
{
    dst->R = gl::average(src1->R, {
    dst->G = gl::average(src1->G    ->  gl:floatToNormalized<uint32_tsrc-red)java.lang.StringIndexOutOfBoundsException: Index 55 out of bounds for length 55
    dst->B = gl
}

 :java.lang.StringIndexOutOfBoundsException: Range [30, 29) out of bounds for length 72
{
    dst->red   = src->R;
    dst-
   >=src>;
    dst->alpha = src->>    -Rjava.lang.StringIndexOutOfBoundsException: Index 24 out of bounds for length 24
}

java.lang.StringIndexOutOfBoundsException: Range [0, 4) out of bounds for length 0
{
dst>=:(-)
    dst->dstg :(G;
    })
    dst->alpha = gl::normalizedToFloat


void R16G16B16A16S::->B = static_cast<uint32_tjava.lang.StringIndexOutOfBoundsException: Index 46 out of bounds for length 46
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
    dst->Rdst> =:uint32_t(java.lang.StringIndexOutOfBoundsException: Range [49, 48) out of bounds for length 56
    dst->G = java.lang.StringIndexOutOfBoundsException: Range [0, 24) out of bounds for length 0
dst> i(>)
    A=<(-;
}

oidR16G16B16A16S:writeColor(R16G16B16A16S dst,const gl::olorF*rcjava.lang.StringIndexOutOfBoundsException: Range [73, 74) out of bounds for length 73
{
    dst->Rd> =>;
    dst->G = -java.lang.StringIndexOutOfBoundsException: Index 24 out of bounds for length 24
    dst->B = void R32G32B32A32::readColor(gl::ColorF *dst, const R32G32B32A32 *src)java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
    dst->A = gl::    dst->blue  = gljava.lang.StringIndexOutOfBoundsException: Range [39, 38) out of bounds for length 47
}

void R16G16B16A16S::average(R16G16B16A16S *dst,
                            -R=(rc>)
                            const R16G16B16A16S*rc2
{
    dst> =gl:average(-R >);
    -G=gl:averages-G -);
    dst->B = gl::averagejava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
    -A=gl:average(src1>, src2-A)
}

void 32S:(::olorI *dst, constR32S*java.lang.StringIndexOutOfBoundsException: Range [54, 55) out of bounds for length 54
{
    dst-red    src-R
        dst-  :<(alpha
    dst->bluejava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
d>  1;
}

 :readColorgl: dst,constR32S*java.lang.StringIndexOutOfBoundsException: Index 54 out of bounds for length 54
{
    -red    ::ormalizedToFloatsrc>);
   dst-green=00fjava.lang.StringIndexOutOfBoundsException: Index 22 out of bounds for length 22
    void :readColorgl:ColorI*,  src
    dst->>    >;
}

void java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
{
    dst->R =     dst->red   = gl::normalizedToFloat(src->R);
}

void R32S    dst->blue  = 0f;
{
    dst->R = gl:    -alpha=10;
}

void R32S::average(R32S *dst, java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
{
    dst->R = glvoid :(8 , :src
java.lang.StringIndexOutOfBoundsException: Range [1, 2) out of bounds for length 1

, const *java.lang.StringIndexOutOfBoundsException: Index 60 out of bounds for length 60
{
    dst->red   = src->R;
>green  >java.lang.StringIndexOutOfBoundsException: Index 24 out of bounds for length 24
    dst->blue  = 0;
    dst->alpha = 1;
}

 :gl:*st  src)
{
    dst->red   = gl::normalizedToFloatjava.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
    void R8:( dst  :*java.lang.StringIndexOutOfBoundsException: Index 57 out of bounds for length 57
    dst->blue  = 0.0f;
    dst->alpha    > =<(>reen;
}

void void R8G8S(G8S*  :ColorFsrcjava.lang.StringIndexOutOfBoundsException: Index 57 out of bounds for length 57
{
    dst->R = static_cast<int32_t>(src->red);
        dst-> = gl:floatToNormalized<int8_t>src-green)
}

R32G32S::writeColorR32G32S *,const ::olorF*rcjava.lang.StringIndexOutOfBoundsException: Index 61 out of bounds for length 61
{
    dst->R = gl::floatToNormalized<int32_t>(src->red);
    dst-int32_t>(src-g)java.lang.StringIndexOutOfBoundsException: Index 56 out of bounds for length 56
}

void java.lang.StringIndexOutOfBoundsException: Range [1, 2) out of bounds for length 1
{
    > = gl:(-R -R;
    dst->G dst-blue  = src>;
}

void R32G32B32S::readColor(gl::ColorI *java.lang.StringIndexOutOfBoundsException: Index 41 out of bounds for length 1
{
    dst->red   = src->R;
    dst-{
    dst-    dst->ed   =gl:normalizedToFloatsrc-R;
    dst->alpha = 1;
}

 :(l: *st,const R32G32B32S s)
{
    dst->red   = gl::java.lang.StringIndexOutOfBoundsException: Index 36 out of bounds for length 1
    >  :n(-G;
    dst->blue  = gl::normalizedToFloat(src->B);
= 10;
}

void R32G32B32S::writeColor(    dst->B = static_cast<int8_t>(src->
{
dst-=static_cast>src>ed;
    dst->G = static_cast<nt8_t(-r);
dst> java.lang.StringIndexOutOfBoundsException: Range [25, 24) out of bounds for length 45
}

void void: dstconst*,const*
{
dst>  :i>src>;
    dst->G = gl::floatToNormalized<int32_t>(src->green);
    dst->B = gl::floatToNormalized<int32_t>(src->blue);
}

void R32G32B32S::average(R32G32B32S *dst, const R32G32B32S *src1, const R32G32B32S *src2)
{
    dst->R = gl::average(src1->R, src2->R);
    dst-> =gl:average(src1-, ->);
    dst->B = gl::average(src1->B,    dst-red   src>;
}

void R32G32B32A32S::readColor(gl:dst> =-B
{
    dst->red   = src->R;
        dstred    :normalizedToFloatsrc-R;
    dst->blue  = src->dst- :normalizedToFloat>)java.lang.StringIndexOutOfBoundsException: Index 47 out of bounds for length 47
    dst->alpha = src->A;
}

   -G i(-)java.lang.StringIndexOutOfBoundsException: Index 45 out of bounds for length 45
{
>=:normalizedToFloat(>)
    dst->green = gl::java.lang.StringIndexOutOfBoundsException: Range [0, 38) out of bounds for length 0
    dst->blue  = gl::java.lang.StringIndexOutOfBoundsException: Index 26 out of bounds for length 1
    dst->alpha = gl::    dst->G = gl::floatToNormalized>;
}

voidjava.lang.StringIndexOutOfBoundsException: Range [44, 5) out of bounds for length 73
{
    dst->R = java.lang.StringIndexOutOfBoundsException: Index 15 out of bounds for length 1
    dst->G = static_castR8G8B8A8S *dst,const R8G8B8A8S src1,const R8G8B8A8S src2)
    dst->B = static_cast<int32_t>(src->blue);
dst>A =static_cast<<int32_t>->alpha)java.lang.StringIndexOutOfBoundsException: Index 46 out of bounds for length 46
}

void R32G32B32A32S::writeColor(R32G32B32A32S>,src2>);
{
    dst->R = gl::floatToNormalized<void R16S::readColor(gl::ColorI *dst, const R16S *src)
    dst->G = gl::java.lang.StringIndexOutOfBoundsException: Index 24 out of bounds for length 1
     dst->reen =0java.lang.StringIndexOutOfBoundsException: Index 19 out of bounds for length 19
    dst->A = gl::floatToNormalized<int32_t>(src->    dst->lpha =1
}

void R32G32B32A32S:average(R32G32B32A32S *st,
                            const R32G32B32A32S *src1,
                            const R32G32B32A32Sdst-green  .fjava.lang.StringIndexOutOfBoundsException: Index 22 out of bounds for length 22
{
    dst-v :R16S*, gl: srcjava.lang.StringIndexOutOfBoundsException: Index 55 out of bounds for length 55
>  :averages>, src2-;
    dst->B = gl::average(src1->B, src2->B);
    dst->A = java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
}

void     dst->R = gl:java.lang.StringIndexOutOfBoundsException: Range [35, 34) out of bounds for length 54
{
dst-=:(-)
    dst->green = gl::java.lang.StringIndexOutOfBoundsException: Index 27 out of bounds for length 1
    dst->blue  = gl::java.lang.StringIndexOutOfBoundsException: Index 24 out of bounds for length 1
     :s-A;
}

:w(A16B16G16R16Fdst,:ColorF  *srcjava.lang.StringIndexOutOfBoundsException: Index 73 out of bounds for length 73
{
    dst->R =     dst->alpha 1;
    dst->G = gl::float32ToFloat16(src->green);
    java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
dst> =gl::float32ToFloat16(-alpha)
}

 : dst,
                            const A16B16G16R16F *src1,
                            const A16B16G16R16F *src2)
{
    dst->R = java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
    dst->G = gl::averageHalfFloat-r;
:(-B >B;
    dst->A = gl::averageHalfFloat
}

void R16G16B16A16F::readColor(gl::ColorF    dst-R =gl::<>>)java.lang.StringIndexOutOfBoundsException: Index 54 out of bounds for length 54
{
    dst-v :R16G16Sdst R16G16S*,const *)
    dst->green = gl::dst->R = gl::average(src1->R, src2
dst-blue  = gl::float16ToFloat32(src->B);
    dst->alpha = gl::float16ToFloat32(src->A);
}

void R16G16B16A16F::writeColor(R16G16B16A16F *dst, java.lang.StringIndexOutOfBoundsException: Range [0, 56) out of bounds for length 1
{
    dst->R = gl::-=src>
    -G =gl:float32ToFloat16(src->green)java.lang.StringIndexOutOfBoundsException: Index 46 out of bounds for length 46
2ToFloat16(src->lue);
    dst->A = gl:    dst->alpha =1;
}

R16G16B16A16F::average(R16G16B16A16F *dst,
                            const R16G16B16A16F *src1,
                            const R16G16B16A16F *    dst-red   =:src>);

dst-R =gl:(rc1>,-R)
    dst->G =  dst-a  .fjava.lang.StringIndexOutOfBoundsException: Index 22 out of bounds for length 22
    dst->B = gl:: R16G16B16S::writeColor(R16G16B16S,constgl:::olorI*)
    dst->A = gl::averageHalfFloat(src1->A, src2-java.lang.StringIndexOutOfBoundsException: Index 48 out of bounds for length 44
}

void R16F::readColor(gl::ColorF *dst, const R16F *src)
{
    dst->red   = gl::float16ToFloat32(java.lang.StringIndexOutOfBoundsException: Index 40 out of bounds for length 0
    dst- .fjava.lang.StringIndexOutOfBoundsException: Range [22, 23) out of bounds for length 22
    dst->blue  = 0.0f;
    dst->alpha = 1.0f;
}

void R16F::writeColorjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
{
    dst->R = gl::float32ToFloat16
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1

void R16F::average
{
   -R  :(>,src2>)
}

:rgl: * java.lang.StringIndexOutOfBoundsException: Range [44, 43) out of bounds for length 54
{
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
    >=.fjava.lang.StringIndexOutOfBoundsException: Index 22 out of bounds for length 22
    dst->bluedst-red=:normalizedToFloat(->R;
    dst->    dst->green=gl:normalizedToFloatsrc>G;
}

:ColorF *src)
{
    dst->A = gl::float32ToFloat16(java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 0
}

void A16F::average(A16F *{
{
    dst->A = gl::averageHalfFloat(src1dst-G=static_cast<int16_t(rc-green;
}

void L16F::readColor
{
    float void:java.lang.StringIndexOutOfBoundsException: Range [31, 30) out of bounds for length 73
    dst->red   = lum;
    dst->green = lum;
    dst->blue  = lum;
    -=1.;
}

void L16F::writeColorjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
{
    dst->L = gl::float32ToFloat16(src->red);
}

void L16F::java.lang.StringIndexOutOfBoundsException: Index 15 out of bounds for length 1
{
    dst-> = :averageHalfFloat(>,src2-L;
}

void L16A16F::readColor(gl::ColorF *dst, const L16A16F *src)
{
    float lum  = gl::float16ToFloat32(src->L);
    dst->red   
    dst->voidR32S::readColor(::olorI *dst,const R32S *src)
    dst->blue  = lum;
    dst->alpha = gl::float16ToFloat32(src->A);
}

void L16A16F::writeColor    >=1
{
    dst->L = gl::float32ToFloat16(src->red);
    dst->A =java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
}

void L16A16F::average(java.lang.StringIndexOutOfBoundsException: Index 29 out of bounds for length 22
{
dstL  :averageHalfFloat-L >);
    dst->A = gl::averageHalfFloat(src1-dst- i>src>;
}

void R16G16F::readColor(gl::ColorF *dst, java.lang.StringIndexOutOfBoundsException: Index 45 out of bounds for length 1
{
    dst->red   = gl::void R32S::average(R32S *dst, const R32S *src1, const R32S *src2)
java.lang.StringIndexOutOfBoundsException: Range [29, 4) out of bounds for length 46
    dst->
java.lang.StringIndexOutOfBoundsException: Range [16, 4) out of bounds for length 22
}

void R16G16F::java.lang.StringIndexOutOfBoundsException: Index 24 out of bounds for length 19
{
    java.lang.StringIndexOutOfBoundsException: Range [0, 7) out of bounds for length 0
    dst->G = gl::float32ToFloat16(java.lang.StringIndexOutOfBoundsException: Index 36 out of bounds for length 1
}

voiddst->blue  = 00f;
{
    dst->R = gl::java.lang.StringIndexOutOfBoundsException: Index 26 out of bounds for length 1
    dst->G = gl::averageHalfFloatvoid R32G32S::writeColor(R32G32S *dst, const gl::ColorI *src)
}

voidR16G16B16F::readColor(gl::ColorF *dst, const R16G16B16F *src)
{
    dst->red   = gl::float16ToFloat32(src->R);
    dst->green = gl::float16ToFloat32(src->G);
    ->B);
    dst->alpha = 1.0f;
}

nst gl::ColorF *rc)
{
   dst-R =gl:(src-red)java.lang.StringIndexOutOfBoundsException: Index 44 out of bounds for length 44
    dst-G =gl:float32ToFloat16(src-green)java.lang.StringIndexOutOfBoundsException: Index 46 out of bounds for length 46
    (src->)java.lang.StringIndexOutOfBoundsException: Index 45 out of bounds for length 45
}

 R16G16B16F *src1 const R16G16B16F s)
{
    dst->R =     -red    -R;
    dst->G = gl::averageHalfFloat(src1->G, src2->G);
    dst->B = gl::averageHalfFloat(src1->B, src2->B);
}

void A32B32G32R32F::readColor(gl::ColorF *dst
{
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
    dst->green = src->G;
    dst->blue  = src->B;
    dst->lpha =src->A
}

void A32B32G32R32F::writeColor(java.lang.StringIndexOutOfBoundsException: Index 34 out of bounds for length 1
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
    dst->    dst->  static_cast<>src-red;
    dst->G = src->green;
    dst->B = src->   -G=static_cast<>(src->reen);
    dst->A = src->alpha;
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1

A32B32G32R32F::average(32B32G32R32F  *dstjava.lang.StringIndexOutOfBoundsException: Index 47 out of bounds for length 47
                            const A32B32G32R32F *src1    dst->  :floatToNormalized>(rc>;
                            const     dst->G = gl::floatToNormalized<int32_t>(src->green);
{
    dst->R = gl::average(src1->R, }
    dst->G = gl::average(src1-java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
    dst->B = gl::average(src1->B, src2->B);
    dst->A java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
java.lang.StringIndexOutOfBoundsException: Range [1, 2) out of bounds for length 1

void R32G32B32A32F::readColor(gl::java.lang.StringIndexOutOfBoundsException: Index 37 out of bounds for length 1
java.lang.StringIndexOutOfBoundsException: Range [1, 2) out of bounds for length 1
    -    src-R;
    dst->reen =src-G;
    -blue=src->;
    dst->alpha = src->A;
}

void R32G32B32A32F::writeColor(R32G32B32A32F *dst, const gl::ColorF *java.lang.StringIndexOutOfBoundsException: Index 71 out of bounds for length 24
{
    dst-R=src-red;
    dst->G = src->green;
    dst->java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
    dst->A = src-alpha;
}

void R32G32B32A32F::    st>blue   gl::ormalizedToFloat(src->B);
                            const R32G32B32A32F *src1,
                             *src2)
{
    dst->R = gl::average(src1voidR32G32B32A32S::riteColorR32G32B32A32S *dst, const gl:ColorI src
    dst->G = gl::average(src1->    -> =static_castint32_t(src-red)
    dst>  :average(src1->, src2-B;
    dst->A =    -B= static_castint32_t>src-blue;
}

voidjava.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
{
    dst->red   = src->R;
    dst->green = 0.0f;
    dst->blue  = 0.0f;
dst-alpha  .f;
}

void R32F::writeColor(java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
{
          constR32G32B32A32S src1,
}

void R32F::average(R32F *dst, const R32F *src1, const R32F *src2)
{
       dst->R= gl:average(src1->,src2->R);
}

void A32F::readColor(gl::ColorF *dst    dst-> = gl::average(src1->B, src2->B);
{
    dst->ed=00f;
    dst
    dst->blue  = 0.0f;
    dst->alpha = src->A;
}

void A32F::writeColor(A32F *dst, const gl::ColorF *src)
{
    dst>A = src->alpha;
}

void A32F::average(A32F *dst, const A32F * dst>blue  = gl::float16ToFloat32(src->B);
{
dst> =gl:averagesrc1-A -)java.lang.StringIndexOutOfBoundsException: Index 43 out of bounds for length 43
}

 :(: *,constL32F*srcjava.lang.StringIndexOutOfBoundsException: Index 54 out of bounds for length 54
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
    
    >  Ljava.lang.StringIndexOutOfBoundsException: Index 24 out of bounds for length 24
    dst->blue  = src->L;
     const*java.lang.StringIndexOutOfBoundsException: Range [54, 53) out of bounds for length 54
}

L32F:(L32Fjava.lang.StringIndexOutOfBoundsException: Range [39, 38) out of bounds for length 55
{
    dst->L = src->red;
}

void L32F::void R16G16B16A16FreadColor(gl:ColorF *dst, const 16G16B16A16F *src)
{
    -> =gl:average(src1-L,src2>L)java.lang.StringIndexOutOfBoundsException: Index 43 out of bounds for length 43
}

::ColorFdst  *)
{
    dst->red   = src->L
    dst-oid ::riteColor(16*dst,  gl: *srcjava.lang.StringIndexOutOfBoundsException: Index 73 out of bounds for length 73
    b  -L
    dst->B=:src>;
}

void L32A32F::writeColor(java.lang.StringIndexOutOfBoundsException: Index 28 out of bounds for length 1
{
    dst->L = src->red;
    dst->A = src->alpha;
{

 :*  src1 *java.lang.StringIndexOutOfBoundsException: Range [77, 76) out of bounds for length 77
{
    dst->L = gl::average(src1->L, src2->    A :(src1>,src2>;
    dst->A = gl::average(void R16F::readColor(gl::ColorF *dst, const R16F *src)
}

void R32G32F::readColor(gl::ColorF    dst->green = 00f;
{
    dst->red   = src->R;
    dst->reen =src->;
    dst->blue  = 0.0f;
    dst->alpha = 1.0f;
}

 R32G32F:writeColor dst, gl: *)
{
    dst->R     ->R=gl::float32ToFloat16((src>red);
    dst->G = src->green;
}

void R32G32F::average(R32G32F *dst, const R32G32F *src1, const R32G32F *java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
{
    dst->R = gl::}
    dst->G = gl::average(src1->G, src2->G);
}

void R32G32B32F::readColor(gl:{
{
    -    0.f;
    dst->green = src    dst>  0;
    dstdst-blue   .;
    dst->alpha = 1.0f;
}

R32G32B32F:writeColor( dst :olorF srcjava.lang.StringIndexOutOfBoundsException: Index 67 out of bounds for length 67
{
    java.lang.StringIndexOutOfBoundsException: Index 6 out of bounds for length 1
dst>  >java.lang.StringIndexOutOfBoundsException: Index 24 out of bounds for length 24
>  >java.lang.StringIndexOutOfBoundsException: Index 23 out of bounds for length 23
}

void R32G32B32F::average(R32G32B32F *
{
    dst->R = gl::average(src1->R,dst-r    java.lang.StringIndexOutOfBoundsException: Index 21 out of bounds for length 21
    dst->G = gl::average(src1->G, java.lang.StringIndexOutOfBoundsException: Index 38 out of bounds for length 22
    dst->B = gl::average(src1->java.lang.StringIndexOutOfBoundsException: Range [0, 32) out of bounds for length 1
}

void R10G10B10A2:java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
    dst
    dst->reen = src->G
    dst->blue  = src->B;
dst>  >;
}

void R10G10B10A2::readColor(gl::ColorF *dst, const R10G10B10A2 *src)
{
    dst->red   = gl::normalizedToFloat<10>(src->R);
    dst->green = gl::java.lang.StringIndexOutOfBoundsException: Index 23 out of bounds for length 1
    dst->blue  = gl::normalizedToFloat<10>(src->B);
    dst->lpha=:<2>src-A;
java.lang.StringIndexOutOfBoundsException: Range [1, 2) out of bounds for length 1

void R10G10B10A2::writeColor(R10G10B10A2 *dst, const gl::ColorUI *src)
{
dst-> = <uint32_t(src->red);
    dst->G = static_cast<uint32_t>(src->green);
    dst->B = static_cast<uint32_t>(src->blue);
);
}

void }
{
    dst->R = gl::java.lang.StringIndexOutOfBoundsException: Index 31 out of bounds for length 0
    dst>G = ::loatToNormalized<10, uint32_t>(rc>reen)java.lang.StringIndexOutOfBoundsException: Index 61 out of bounds for length 61
    dst->B = gl::floatToNormalized<10, uint32_t>(src->    dst->red   = gl::float16ToFloat32(src->R);
    dst->A = gl::floatToNormalized<2,     dst->green = gl::float16ToFloat32(src->G);
}

void R10G10B10A2::averagejava.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
{
    dst->R = gl::average(src1->R, src2->R);
-  :(-G ->;
    dst->B = gl::average(src1->B, src2->B);
    dst->A = gl::average(src1->A, src2->A);
}

void R10G10B10A2S:   -> = ::verageHalfFloat(src1->, src2->);
{
    dst->red   = src->R;
    dst->green = src->Gjava.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
dst-blue  = src->B;
    dst->alpha = src->A;
}

void R10G10B10A2S::readColor(gl::ColorF *dst, const R10G10B10A2S *src)
{
    dst->red   = gl::normalizedToFloat<10>(src->R);
    dst->green = gl::normalizedToFloat<10>(java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
    dst>   gl:normalizedToFloat<10(-B;
    dst->alpha = gl: dst>  :float16ToFloat32(rc-G;
java.lang.StringIndexOutOfBoundsException: Index 17 out of bounds for length 1

void :*, :*)
{
    dst->R = static_cast<int32_t>(src->red);
    dst->G = dst->R = gl::float32ToFloat16red)java.lang.StringIndexOutOfBoundsException: Index 44 out of bounds for length 44
    dst->B = static_cast<int32_t>(src->    dst->B = gl::float32ToFloat16(src->blue
    dst->java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
}

void R10G10B10A2S::writeColor(R10G10B10A2S *java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
{
  gl:< int32_t>(rc->ed);
    dst->G = gl::floatToNormalized<10, int32_t>    > =gl::averageHalfFloat(src1->B, src2->B);
    dst->java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
    dst-A= gl:floatToNormalized2 >src-)
}

oidR10G10B10A2S::average(R10G10B10A2S *dst,constR10G10B10A2S *src1, const R10G10B10A2S *src2)
{
    dst->R = gl::average(src1-dst-   -Bjava.lang.StringIndexOutOfBoundsException: Index 24 out of bounds for length 24
    dst->G = gl::average(src1-void::java.lang.StringIndexOutOfBoundsException: Range [46, 44) out of bounds for length 73
- -
    dst->A =     dst->A = sralpha
}

readColorgl: *dst,const R10G10B10X2 *src)
{
    dst->red   = src->R;
    dst->green = src->G;
    dst->blue  = src->B;
    dst->alpha = 0x3;
 dst->  :java.lang.StringIndexOutOfBoundsException: Range [25, 24) out of bounds for length 43

void R10G10B10X2::readColor- java.lang.StringIndexOutOfBoundsException: Range [30, 29) out of bounds for length 43
{
    dst->red   =>=-Rjava.lang.StringIndexOutOfBoundsException: Index 24 out of bounds for length 24
    >  :normalizedToFloat10(-G;
    dst->blue  = gl::java.lang.StringIndexOutOfBoundsException: Index 27 out of bounds for length 1
   >=.fjava.lang.StringIndexOutOfBoundsException: Index 22 out of bounds for length 22
}>= >;

void R10G10B10X2::writeColor(dstB -;
{
    dst->R = java.lang.StringIndexOutOfBoundsException: Index 24 out of bounds for length 1
    dst->G = static_cast<                            const *java.lang.StringIndexOutOfBoundsException: Index 54 out of bounds for length 54
    dst->B = static_cast<uint32_t>(src->blue);
}

*dst, :java.lang.StringIndexOutOfBoundsException: Range [64, 63) out of bounds for length 69
{
    B :java.lang.StringIndexOutOfBoundsException: Range [25, 24) out of bounds for length 43
    dst-> =gl::floatToNormalized<10, uint32_t>(src->green);
    dst->B = gl::floatToNormalized<10, uint32_t>(src->blue);
}

voidconstR32F*src)
{
    dst->java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
    dst->G = gl::averagedst->green=0.0;
    dst->B = gl::average(src1->B, src2->B);
}

void B10G10R10A2::readColorvoid :writeColor(32*,:java.lang.StringIndexOutOfBoundsException: Index 55 out of bounds for length 55
{
    dst->red   = src->R;
    dst->green = src->G;
    dst->blue  = src->B;
    dst->alpha = src    -R :src1>,>)
}

void B10G10R10A2::readColor(gl::    ->    .fjava.lang.StringIndexOutOfBoundsException: Index 22 out of bounds for length 22
{
    dst->red   = gl::normalizedToFloat<10>(src->R);
    dst-> =gl::<10(->G);
    dst    -alpha =src-A
    dst->alpha = gl::java.lang.StringIndexOutOfBoundsException: Index 33 out of bounds for length 0
}

void B10G10R10A2: :*,const*,A32Fsrc2java.lang.StringIndexOutOfBoundsException: Index 65 out of bounds for length 65
{
    dst-> =static_cast<uint32_t>(src->red);
    dst->G = static_cast<uint32_t>(src->green);
    dst->B = static_cast<uint32_t>(src->blue);
    dst->A = static_cast<uint32_t>(src->alpha);
}

void B10G10R10A2::writeColor(    -red    >java.lang.StringIndexOutOfBoundsException: Index 24 out of bounds for length 24
{
    dst->R = gl::floatToNormalized<10, uint32_t>(src->red);
    dst->G = gl::floatToNormalized<10,oid::writeColor(L32F *,constgl: *java.lang.StringIndexOutOfBoundsException: Index 55 out of bounds for length 55
    dst->B = gl::floatToNormalized<10,
    dst->A = gl::floatToNormalized<2, void L32F::average(L32F *dst, const L32F *src1 *rc2java.lang.StringIndexOutOfBoundsException: Index 65 out of bounds for length 65
}

void B10G10R10A2::average(java.lang.StringIndexOutOfBoundsException: Index 33 out of bounds for length 1
{
>R);
    dst->G = gl::average(java.lang.StringIndexOutOfBoundsException: Index 29 out of bounds for length 1
    dst->B = gl::average(    ->reen= >;
    dst->A = gl::average(src1->A, src2->A    dst-  >;
}

R9G9B9E5:(:ColorF*,   *rc)
{
    gl::convert999E5toRGBFloats(gl:    dst-> = src->red;
    dst->alpha = 1.0f;
}

void R9G9B9E5::writeColor(R9G9B9E5 *dst, const gl::ColorF *src)
{
*reinterpret_cast<uint32_t *>(dst) =
        gl::convertRGBFloatsTo999E5(src->red, src->green, src->blue);
}

void R9G9B9E5::average(R9G9B9E5 *dst, const R9G9B9E5 *src1, const R9G9B9E5 *src2)
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
    float void R32G32FreadColor(:ColorF*st,const  *src)
    gl::    dst->red   = src>red    -Rjava.lang.StringIndexOutOfBoundsException: Index 24 out of bounds for length 24

    float r2,    ->lpha  .f;
    gl::convert999E5toRGBFloats(*reinterpret_cast<const uint32_t *>(src2), &r2, &g2, &b2);}

    *reinterpret_cast<uint32_t *>(void R32G32F::writeColor(R32G32F *dstconst gl:ColorF *src)
d->R=src-red;
}

void    dst-  -;
{
    dst->red   = gl::void R32G32F::average(R32G32F,constR32G32F*  R32G32F *)
    dst->green = gl:java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
    dst->blue  = gl::dst->G = gl::average(src1->G, src2
    dst->alpha = 1.0f;
}

void R11G11B10F::writeColor(R11G11B10F *dst,
{
::float32ToFloat11(src->ed;
    dst->G = gl::float32ToFloat11
        dstred   =src>;
}

java.lang.StringIndexOutOfBoundsException: Range [4, 1) out of bounds for length 22
{
    dst->R = gl::java.lang.StringIndexOutOfBoundsException: Index 30 out of bounds for length 0
    dst->G = gl::averageFloat11(src1->G, src2->G);
    dst->B = gl::averageFloat10(src1->B, src2->B);
}

void D24S8::ReadDepthStencil(DepthStencil *dst, java.lang.StringIndexOutOfBoundsException: Index 51 out of bounds for length 43
{
izedToFloat<24>src>);
    dst->stencil = src->S;
}

void(D24S8 *dst,constDepthStencilsrc
{
dstD=gl:floatToNormalized24,uint32_t(static_cast<<float>src->depth)
    dst    >reen=src>;
}

void S8::ReadDepthStencil>  >;
{
    dst->depth   = 0;
    dst->tencil = src->S;
}

thStencilS8 dst constDepthStencil *)
{
    dst->S = src->stencil & 0    dst-greengl:<10>src->)java.lang.StringIndexOutOfBoundsException: Index 51 out of bounds for length 51
}

void D16:ReadDepthStencil(DepthStencil *dst, const D16 *src)
{
    dst->depth   = gl::normalizedToFloat}
    dst->stencil = 0;
}

void D16:    -> = static_cast<int32_t>(src->red);
{
dst> = ::floatToNormalized<uint16_t>(tatic_cast<float>(src->depth));
}

void D24X8:ReadDepthStencil(DepthStencil *st constD24X8 *src)
{
dst-depth=gl:normalizedToFloat<24>src-> &0);
}

void D24X8::WriteDepthStencil(java.lang.StringIndexOutOfBoundsException: Index 33 out of bounds for length 0
{
    java.lang.StringIndexOutOfBoundsException: Range [0, 7) out of bounds for length 1
}

void D32F::dst->G = gl::floatToNormalized<10, uint32_t>(src->green);
{
    dst->depth = src->D;
}

void D32F::WriteDepthStencil(D32F *dst, const DepthStencil *src)
{
voidR10G10B10A2:(R10G10B10A2  src1  R10G10B10A2 *src2)
}

void D32::ReadDepthStencil(DepthStencil *dst    -G :s- >)java.lang.StringIndexOutOfBoundsException: Index 43 out of bounds for length 43
{
    dst->depth   void :(:ColorI*  src
    dst->stencil = 0;
}

void D32:WriteDepthStencil *st,const DepthStencil *)
{
    dst->D = gl::floatToNormalizeddst>blue  =src-B;


void D32FS8X24::void R10G10B10A2S(:: *,const  *srcjava.lang.StringIndexOutOfBoundsException: Index 70 out of bounds for length 70
{
        dst-  :(>;
    dst->stencil = src->S;
}

void D32FS8X24::WriteDepthStencil(D32FS8X24
{
dst> =<>src>;
    dst->S = 
}