├── LICENSE.md
├── Makefile
├── README.md
├── envremap.c
├── envtoirr.c
├── etc
    ├── ball.tif
    ├── box2.png
    ├── box3.png
    ├── box4.png
    ├── cent.png
    ├── cube.tif
    ├── dome.tif
    ├── earth.tif
    ├── hemi.tif
    ├── moon.tif
    ├── rect.tif
    ├── rgss.png
    ├── sampling.ai
    ├── thumbnail-ball.png
    ├── thumbnail-cube.png
    ├── thumbnail-dome.png
    ├── thumbnail-hemi.png
    └── thumbnail-rect.png
├── gray.h
└── sRGB.h


/LICENSE.md:
--------------------------------------------------------------------------------
 1 | envtools is made available under the terms of the MIT License.
 2 | 
 3 | Copyright (c) 2010-2013 Robert Kooima
 4 | 
 5 | Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
 6 | 
 7 | The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
 8 | 
 9 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
10 | 


--------------------------------------------------------------------------------
/Makefile:
--------------------------------------------------------------------------------
 1 | #CC= $(firstword $(wildcard /usr/local/bin/gcc /usr/bin/gcc))
 2 | CC=gcc
 3 | CFLAGS= -std=c99 -pedantic -Wall -g -m64 -fstrict-aliasing
 4 | #CFLAGS= -std=c99 -pedantic -Wall -O3 -m64 -fstrict-aliasing -fopenmp -march=athlon64
 5 | 
 6 | LIBS= -L/usr/local/lib -ltiff -ljpeg -lpng -lz -lm
 7 | INCS= -I/usr/local/include
 8 | 
 9 | #-------------------------------------------------------------------------------
10 | 
11 | TOOLS = envremap envtoirr
12 | 
13 | all : $(TOOLS)
14 | 
15 | envremap : envremap.o
16 | envtoirr : envtoirr.o
17 | 
18 | #-------------------------------------------------------------------------------
19 | # Define implicit rules building all tools.
20 | 
21 | %   : %.c
22 | %.o : %.c
23 | 	$(CC) $(CFLAGS) $(INCS) -o $@ -c $<
24 | 
25 | %   : %.o
26 | 	$(CC) $(CFLAGS) $(LIBS) -o $@ $^
27 | 
28 | clean :
29 | 	rm -f $(TOOLS) $(UTILS) *.o
30 | 
31 | #-------------------------------------------------------------------------------
32 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
 1 | # Environment Mapping Tools
 2 | 
 3 | Copyright &copy; 2012&ndash;2013 &mdash; [Robert Kooima](http://kooima.net)
 4 | 
 5 | The environment mapping tools are a set of command line utilities that operate upon spherical images in TIFF form. These operations including remapping between common spherical projections and generating diffuse irradiance maps from specular environment maps.
 6 | 
 7 | - [envremap.c](envremap.c)
 8 | - [envtoirr.c](envtoirr.c)
 9 | 
10 | The following header files provide the ICC profiles needed for well-formed floating-point TIFFs.
11 | 
12 | - [gray.h](gray.h)
13 | - [sRGB.h](sRGB.h)
14 | 
15 | ## Spherical Remapping
16 | 
17 | This code supports reprojection and resampling between any two of the following spherical image projections. A high-resolution example image of each type is included.
18 | 
19 | <table>
20 | <tr><td><img src="etc/thumbnail-rect.png"></td><td>The <b>rect</b> type corresponds to the equirectangular projection, much like the common map of the world. It represents the full sphere, though with significant distortion near the poles. (<a href="etc/rect.tif">Example</a>.)</td></tr>
21 | <tr><td><img src="etc/thumbnail-ball.png"></td><td>The <b>ball</b> type corresponds to a photograph of a mirrored sphere, or "light probe". It represents the full sphere, but with significant distortion toward the back. (<a href="etc/ball.tif">Example</a>.)</td></tr>
22 | <tr><td><img src="etc/thumbnail-dome.png"></td><td>The <b>dome</b> type gives a "dome master". This is an image suitable for projection onto a fulldome planetarium. The view looks up and the radius varies linearly with latitude. It represents only half of the sphere. (<a href="etc/dome.tif">Example</a>.)</td></tr>
23 | <tr><td><img src="etc/thumbnail-hemi.png"></td><td>The <b>hemi</b> type is mathematically identical to the dome type, though the view faces forward instead of up. This corresponds to a photograph taken with an 8mm "fisheye" lens. This too represents only half of the sphere. (<a href="etc/hemi.tif">Example</a>.)</td></tr>
24 | <tr><td><img src="etc/thumbnail-cube.png"></td><td>The <b>cube</b> type corresponds to an OpenGL cube map texture, and is the best choice for use in real-time 3D rendering. The TIFF contains each of the six cube faces in a separate page. The cube faithfully represents the full sphere with minimal distortion. (<a href="etc/cube.tif">Example</a>.)</td></tr>
25 | </table>
26 | 
27 | The output is sampled using one of several sampling patterns, which give a quality-speed tradeoff.
28 | 
29 | <table>
30 | <tr><td><img src="etc/cent.png"></td><td><b>cent</b> &hellip; One sample at the centroid of the output pixel</td></tr>
31 | <tr><td><img src="etc/rgss.png"></td><td><b>rgss</b> &hellip; Rotated-grid super sampling</td></tr>
32 | <tr><td><img src="etc/box2.png"></td><td><b>box2</b> &hellip; 2 &times; 2 super sampling</td></tr>
33 | <tr><td><img src="etc/box3.png"></td><td><b>box3</b> &hellip; 3 &times; 3 super sampling</td></tr>
34 | <tr><td><img src="etc/box4.png"></td><td><b>box4</b> &hellip; 4 &times; 4 super sampling</td></tr>
35 | </table>
36 | 
37 | This tool remaps the input image `src.tif` to the output `dst.tif`. The sample depth and format of the input TIFF is preserved in the output.
38 | 
39 | `envremap [-i input] [-o output] [-p pattern] [-f filter] [-n n] src.tif dst.tif`
40 | 
41 | - `-i input`
42 | 
43 |     Input projection type. May be `ball`, `cube`, `dome`, `hemi`, or `rect`. The default is `rect`.
44 | 
45 | - `-o output`
46 | 
47 |     Output projection type. May be `ball`, `cube`, `dome`, `hemi`, or `rect`. The default is `rect`.
48 | 
49 | - `-p pattern`
50 | 
51 |     Output sampling pattern. May be `cent`, `rgss`, `box2`, `box3`, or `box4`. The default is `rgss`.
52 | 
53 | - `-f filter`
54 | 
55 |     Input filter type. Maybe `nearest` or `linear`. The default is `linear`.
56 | 
57 | - `-n n`
58 | 
59 |     Output size. Image will have size `n` &times; `n`, except `rect` which will have size 2`n` &times; `n`.
60 | 
61 | ## Irradiance Generation
62 | 
63 | This tool generates an irradiance environment map from a given environment map using the method of Ramamoorthi and Hanrahan's [An Efficient Representation for Irradiance Environment Maps](http://graphics.stanford.edu/papers/envmap/). The input _must_ be a 32-bit floating point TIFF image in cube map format with six pages.
64 | 
65 | `envtoirr [-n n] [-f src.tif] [-ges] dst.tif`
66 | 
67 | - `-n n`
68 | 
69 |     Output size. The output will be a 32-bit floating point TIFF with six pages, each `n` &times; `n` in size.
70 | 
71 | - `-f src.tif`
72 | 
73 |     Input TIFF file.
74 | 
75 | - `-g`  
76 |   `-e`  
77 |   `-s`
78 | 
79 |     Forego loading an input file and instead generate an irradiance map using one of the parameter sets from Ramamoorth and Hanrahan. Options are `-g` Grace Cathedral, `-e` Eucalyptus Grove, or `s` St. Peter's Basilica.
80 | 


--------------------------------------------------------------------------------
/envremap.c:
--------------------------------------------------------------------------------
   1 | /* Copyright (c) 2010-2013 Robert Kooima                                      */
   2 | /*                                                                            */
   3 | /* Permission is hereby granted, free of charge, to any person obtaining a    */
   4 | /* copy of this software and associated documentation files (the "Software"), */
   5 | /* to deal in the Software without restriction, including without limitation  */
   6 | /* the rights to use, copy, modify, merge, publish, distribute, sublicense,   */
   7 | /* and/or sell copies of the Software, and to permit persons to whom the      */
   8 | /* Software is furnished to do so, subject to the following conditions:       */
   9 | /*                                                                            */
  10 | /* The above copyright notice and this permission notice shall be included in */
  11 | /* all copies or substantial portions of the Software.                        */
  12 | /*                                                                            */
  13 | /* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR */
  14 | /* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,   */
  15 | /* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL    */
  16 | /* THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER */
  17 | /* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING    */
  18 | /* FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER        */
  19 | /* DEALINGS IN THE SOFTWARE.                                                  */
  20 | 
  21 | #include <tiffio.h>
  22 | #include <assert.h>
  23 | #include <stdlib.h>
  24 | #include <string.h>
  25 | #include <getopt.h>
  26 | #include <stdio.h>
  27 | #include <math.h>
  28 | 
  29 | #include "gray.h"
  30 | #include "sRGB.h"
  31 | 
  32 | /*----------------------------------------------------------------------------*/
  33 | 
  34 | /* In image structure represents an input or output raster.                   */
  35 | 
  36 | struct image
  37 | {
  38 |     float *p;  // data
  39 |     int    h;  // height
  40 |     int    w;  // width
  41 |     int    c;  // sample count
  42 |     int    b;  // sample depth
  43 |     int    s;  // sample format
  44 | };
  45 | 
  46 | typedef struct image image;
  47 | 
  48 | /* A pattern structure represents a supersampling pattern.                    */
  49 | 
  50 | struct point
  51 | {
  52 |     float i;
  53 |     float j;
  54 | };
  55 | 
  56 | typedef struct point point;
  57 | 
  58 | struct pattern
  59 | {
  60 |     int    n;
  61 |     point *p;
  62 | };
  63 | 
  64 | typedef struct pattern pattern;
  65 | 
  66 | /*----------------------------------------------------------------------------*/
  67 | 
  68 | typedef void (*filter)(const image *, float, float, float *);
  69 | 
  70 | typedef int (*to_img)(int *, float *, float *, int, int, const float *);
  71 | typedef int (*to_env)(int,   float,   float,   int, int,       float *);
  72 | 
  73 | /*----------------------------------------------------------------------------*/
  74 | /* A small set of single precision mathematical utilities.                    */
  75 | 
  76 | #define PI2 1.5707963f
  77 | #define PI  3.1415927f
  78 | #define TAU 6.2831853f
  79 | 
  80 | static inline float lerp(float a, float b, float k)
  81 | {
  82 |     return a * (1.f - k) + b * k;
  83 | }
  84 | 
  85 | static inline float clamp(float f, float a, float z)
  86 | {
  87 |     if      (f < a) return a;
  88 |     else if (f > z) return z;
  89 |     else            return f;
  90 | }
  91 | 
  92 | static inline float length(float i, float j)
  93 | {
  94 |     return sqrtf(i * i + j * j);
  95 | }
  96 | 
  97 | static inline void normalize(float *v)
  98 | {
  99 |     const float k = 1.f / sqrtf(v[0] * v[0] + v[1] * v[1] + v[2] * v[2]);
 100 |     v[0] *= k;
 101 |     v[1] *= k;
 102 |     v[2] *= k;
 103 | }
 104 | 
 105 | static inline void add(float *a, const float *b, const float *c)
 106 | {
 107 |     a[0] = b[0] + c[0];
 108 |     a[1] = b[1] + c[1];
 109 |     a[2] = b[2] + c[2];
 110 | }
 111 | 
 112 | /*----------------------------------------------------------------------------*/
 113 | /* Pixel block and line copying procedures used for cube map bordering.       */
 114 | 
 115 | static void blit(void *dst, int dw, int dx, int dy,
 116 |                  void *src, int sw, int sx, int sy,
 117 |                         int w, int h, int c, int b)
 118 | {
 119 |     int i;
 120 |     for (i = 0; i < h; i++)
 121 |         memcpy((char *) dst + ((i + dy) * dw + dx) * c * b,
 122 |                (char *) src + ((i + sy) * sw + sx) * c * b,
 123 |                                                  w * c * b);
 124 | }
 125 | 
 126 | #if 0
 127 | static void line(void *dst, int dw, int dx, int dy, int ddx, int ddy,
 128 |                  void *src, int sw, int sx, int sy, int sdx, int sdy,
 129 |                                                  int n, int c, int b)
 130 | {
 131 |     int i;
 132 |     for (i = 0; i < n; i++)
 133 |         memcpy((char *) dst + ((dy + ddy * i) * dw + dx + ddx * i) * c * b,
 134 |                (char *) src + ((sy + sdy * i) * sw + sx + sdx * i) * c * b,
 135 |                                                                      c * b);
 136 | }
 137 | #endif
 138 | /*----------------------------------------------------------------------------*/
 139 | 
 140 | /* Read one scanline from the given TIFF file, converting it from the format */
 141 | /* of the TIFF to float. The file must have contiguous planar configuration.  */
 142 | /* This is a drop-in replacement for TIFFReadScanline.                        */
 143 | 
 144 | int TIFFReadFloatScanline(TIFF *T, float *dst, uint32 r)
 145 | {
 146 |     static tdata_t *src = NULL;
 147 |     static tsize_t  len = 0;
 148 | 
 149 |     uint32 w = 0;
 150 |     uint16 c = 0;
 151 |     uint16 b = 0;
 152 |     uint16 s = 0;
 153 |     uint16 p = 0;
 154 | 
 155 |     TIFFGetField(T, TIFFTAG_IMAGEWIDTH,      &w);
 156 |     TIFFGetField(T, TIFFTAG_SAMPLESPERPIXEL, &c);
 157 |     TIFFGetField(T, TIFFTAG_BITSPERSAMPLE,   &b);
 158 |     TIFFGetField(T, TIFFTAG_SAMPLEFORMAT,    &s);
 159 |     TIFFGetField(T, TIFFTAG_PLANARCONFIG,    &p);
 160 | 
 161 |     if (p == PLANARCONFIG_CONTIG)
 162 |     {
 163 |         if (len != TIFFScanlineSize(T))
 164 |         {
 165 |             len  = TIFFScanlineSize(T);
 166 |             src  = realloc(src, len);
 167 |         }
 168 | 
 169 |         if (src && TIFFReadScanline(T, src, r, 0) > 0)
 170 |         {
 171 |             if      ((b ==  8) && (s == SAMPLEFORMAT_UINT || s == 0))
 172 |                 for (uint32 i = 0; i < w * c; i++)
 173 |                     dst[i] = ((uint8  *) src)[i] / 255.0f;
 174 | 
 175 |             else if ((b ==  8) && (s == SAMPLEFORMAT_INT))
 176 |                 for (uint32 i = 0; i < w * c; i++)
 177 |                     dst[i] = ((int8   *) src)[i] / 127.0f;
 178 | 
 179 |             else if ((b == 16) && (s == SAMPLEFORMAT_UINT || s == 0))
 180 |                 for (uint32 i = 0; i < w * c; i++)
 181 |                     dst[i] = ((uint16 *) src)[i] / 65535.0f;
 182 | 
 183 |             else if ((b == 16) && (s == SAMPLEFORMAT_INT))
 184 |                 for (uint32 i = 0; i < w * c; i++)
 185 |                     dst[i] = ((int16  *) src)[i] / 32767.0f;
 186 | 
 187 |             else if ((b == 32) && (s == SAMPLEFORMAT_IEEEFP))
 188 |                 for (uint32 i = 0; i < w * c; i++)
 189 |                     dst[i] = ((float  *) src)[i];
 190 | 
 191 |             else return -1;
 192 |         }
 193 |     }
 194 |     return +1;
 195 | }
 196 | 
 197 | /* Write one scanline to the given TIFF file, converting it from float to the */
 198 | /* format of the TIFF. The file must have contiguous planar configuration.    */
 199 | /* This is a drop-in replacement for TIFFWriteScanline.                       */
 200 | 
 201 | int TIFFWriteFloatScanline(TIFF *T, float *src, uint32 r)
 202 | {
 203 |     static tdata_t *dst = NULL;
 204 |     static tsize_t  len = 0;
 205 | 
 206 |     uint32 w = 0;
 207 |     uint16 c = 0;
 208 |     uint16 b = 0;
 209 |     uint16 s = 0;
 210 |     uint16 p = 0;
 211 | 
 212 |     TIFFGetField(T, TIFFTAG_IMAGEWIDTH,      &w);
 213 |     TIFFGetField(T, TIFFTAG_SAMPLESPERPIXEL, &c);
 214 |     TIFFGetField(T, TIFFTAG_BITSPERSAMPLE,   &b);
 215 |     TIFFGetField(T, TIFFTAG_SAMPLEFORMAT,    &s);
 216 |     TIFFGetField(T, TIFFTAG_PLANARCONFIG,    &p);
 217 | 
 218 |     if (p == PLANARCONFIG_CONTIG)
 219 |     {
 220 |         if (len != TIFFScanlineSize(T))
 221 |         {
 222 |             len  = TIFFScanlineSize(T);
 223 |             dst  = realloc(dst, len);
 224 |         }
 225 | 
 226 |         if (dst)
 227 |         {
 228 |             if      ((b ==  8) && (s == SAMPLEFORMAT_UINT || s == 0))
 229 |                 for (uint32 i = 0; i < w * c; i++)
 230 |                     ((uint8  *) dst)[i] = clamp(src[i], 0.0f, 1.0f) * 255.0f;
 231 | 
 232 |             else if ((b ==  8) && (s == SAMPLEFORMAT_INT))
 233 |                 for (uint32 i = 0; i < w * c; i++)
 234 |                     ((int8   *) dst)[i] = clamp(src[i], 0.0f, 1.0f) * 127.0f;
 235 | 
 236 |             else if ((b == 16) && (s == SAMPLEFORMAT_UINT || s == 0))
 237 |                 for (uint32 i = 0; i < w * c; i++)
 238 |                     ((uint16 *) dst)[i] = clamp(src[i], 0.0f, 1.0f) * 65535.0f;
 239 | 
 240 |             else if ((b == 16) && (s == SAMPLEFORMAT_INT))
 241 |                 for (uint32 i = 0; i < w * c; i++)
 242 |                     ((int16  *) dst)[i] = clamp(src[i], 0.0f, 1.0f) * 32767.0f;
 243 | 
 244 |             else if ((b == 32) && (s == SAMPLEFORMAT_IEEEFP))
 245 |                 for (uint32 i = 0; i < w * c; i++)
 246 |                     ((float  *) dst)[i] = src[i];
 247 | 
 248 |             else return -1;
 249 | 
 250 |             if (TIFFWriteScanline(T, dst, r, 0) == -1)
 251 |                 return -1;
 252 |         }
 253 |     }
 254 |     return +1;
 255 | }
 256 | 
 257 | /*----------------------------------------------------------------------------*/
 258 | 
 259 | /* Allocate and initialize n image structures, each with a floating point     */
 260 | /* pixel buffer with width w, height h, and channel count c.                  */
 261 | 
 262 | static image *image_alloc(int n, int h, int w, int c, int b, int s)
 263 | {
 264 |     image *img;
 265 |     int f;
 266 | 
 267 |     if (s == 0)
 268 |     {
 269 |         if (b == 32)
 270 |             s = SAMPLEFORMAT_IEEEFP;
 271 |         else
 272 |             s = SAMPLEFORMAT_UINT;
 273 |     }
 274 | 
 275 |     if ((img = (image *) calloc(n, sizeof (image))))
 276 |         for (f = 0; f < n; f++)
 277 |         {
 278 |             img[f].p = (float *) calloc(w * h * c, sizeof (float));
 279 |             img[f].w = w;
 280 |             img[f].h = h;
 281 |             img[f].c = c;
 282 |             img[f].b = b;
 283 |             img[f].s = s;
 284 |         }
 285 | 
 286 |     return img;
 287 | }
 288 | 
 289 | /* Release the storage for n image buffers.                                   */
 290 | #if 0
 291 | static void image_free(image *img, int n)
 292 | {
 293 |     int f;
 294 | 
 295 |     for (f = 0; f < n; f++)
 296 |         free(img[f].p);
 297 | 
 298 |     free(img);
 299 | }
 300 | #endif
 301 | 
 302 | /* Read and return n pages from the named TIFF image file.                    */
 303 | 
 304 | static image *image_reader(const char *name, int n)
 305 | {
 306 |     image *in = 0;
 307 |     TIFF  *T  = 0;
 308 |     int    f;
 309 | 
 310 |     if ((T = TIFFOpen(name, "r")))
 311 |     {
 312 |         if ((in = (image *) calloc(n, sizeof (image))))
 313 |         {
 314 |             for (f = 0; f < n; f++)
 315 |             {
 316 |                 uint16 b, c, s = 0;
 317 |                 uint32 w, h, r;
 318 |                 float *p;
 319 | 
 320 |                 TIFFSetDirectory(T, f);
 321 | 
 322 |                 TIFFGetField(T, TIFFTAG_IMAGEWIDTH,      &w);
 323 |                 TIFFGetField(T, TIFFTAG_IMAGELENGTH,     &h);
 324 |                 TIFFGetField(T, TIFFTAG_SAMPLESPERPIXEL, &c);
 325 |                 TIFFGetField(T, TIFFTAG_BITSPERSAMPLE,   &b);
 326 |                 TIFFGetField(T, TIFFTAG_SAMPLEFORMAT,    &s);
 327 | 
 328 |                 if ((p = (float *) malloc(h * w * c * sizeof (float))))
 329 |                 {
 330 |                     for (r = 0; r < h; ++r)
 331 |                         TIFFReadFloatScanline(T, p + w * c * r, r);
 332 | 
 333 |                     in[f].p = (float *) p;
 334 |                     in[f].w = (int)     w;
 335 |                     in[f].h = (int)     h;
 336 |                     in[f].c = (int)     c;
 337 |                     in[f].b = (int)     b;
 338 |                     in[f].s = (int)     s;
 339 |                 }
 340 |             }
 341 |         }
 342 |         TIFFClose(T);
 343 |     }
 344 |     return in;
 345 | }
 346 | 
 347 | /* Write n pages to the named TIFF image file.                                */
 348 | 
 349 | static void image_writer(const char *name, image *out, int n)
 350 | {
 351 |     TIFF  *T = 0;
 352 |     uint32 f, r;
 353 | 
 354 |     if ((T = TIFFOpen(name, "w")))
 355 |     {
 356 |         for (f = 0; f < n; ++f)
 357 |         {
 358 |             TIFFSetField(T, TIFFTAG_IMAGEWIDTH,      out[f].w);
 359 |             TIFFSetField(T, TIFFTAG_IMAGELENGTH,     out[f].h);
 360 |             TIFFSetField(T, TIFFTAG_SAMPLESPERPIXEL, out[f].c);
 361 |             TIFFSetField(T, TIFFTAG_BITSPERSAMPLE,   out[f].b);
 362 |             TIFFSetField(T, TIFFTAG_SAMPLEFORMAT,    out[f].s);
 363 |             TIFFSetField(T, TIFFTAG_ORIENTATION,     ORIENTATION_TOPLEFT);
 364 |             TIFFSetField(T, TIFFTAG_PLANARCONFIG,    PLANARCONFIG_CONTIG);
 365 | 
 366 |             if (out[f].c == 1)
 367 |             {
 368 |                 TIFFSetField(T, TIFFTAG_PHOTOMETRIC,  PHOTOMETRIC_MINISBLACK);
 369 |                 TIFFSetField(T, TIFFTAG_ICCPROFILE, sizeof (grayicc), grayicc);
 370 |             }
 371 |             else
 372 |             {
 373 |                 TIFFSetField(T, TIFFTAG_PHOTOMETRIC,  PHOTOMETRIC_RGB);
 374 |                 TIFFSetField(T, TIFFTAG_ICCPROFILE, sizeof (sRGBicc), sRGBicc);
 375 |             }
 376 | 
 377 |             for (r = 0; r < out[f].h; ++r)
 378 |                 TIFFWriteFloatScanline(T, out[f].p + out[f].w * out[f].c * r, r);
 379 | 
 380 |             TIFFWriteDirectory(T);
 381 |         }
 382 |         TIFFClose(T);
 383 |     }
 384 | }
 385 | 
 386 | /*----------------------------------------------------------------------------*/
 387 | 
 388 | #define SAMP(img, i, j, k) img.p[img.c * (img.w * i + j) + k]
 389 | 
 390 | static float *rotN(image *img, int i, int j)
 391 | {
 392 |     const int ii = i;
 393 |     const int jj = j;
 394 |     return img->p + img->c * (img->w * ii + jj);
 395 | }
 396 | 
 397 | static float *rotL(image *img, int i, int j)
 398 | {
 399 |     const int ii = j;
 400 |     const int jj = img->h - i - 1;
 401 |     return img->p + img->c * (img->w * ii + jj);
 402 | }
 403 | 
 404 | static float *rotR(image *img, int i, int j)
 405 | {
 406 |     const int ii = img->w - j - 1;
 407 |     const int jj = i;
 408 |     return img->p + img->c * (img->w * ii + jj);
 409 | }
 410 | 
 411 | typedef float *(*rot)(image *, int, int);
 412 | 
 413 | static void border(image *a, rot rota, image *b, rot rotb, int d)
 414 | {
 415 |     const size_t s = b->c * sizeof (float);
 416 |     const int    n = b->h;
 417 | 
 418 |     for     (int i = d; i < n - d; i++)
 419 |         for (int j = 0; j <     d; j++)
 420 |         {
 421 |             memcpy(rota(a, i, n - d + j), rotb(b, i,         d + j), s);
 422 |             memcpy(rotb(b, i,         j), rota(a, i, n - d - d + j), s);
 423 |         }
 424 | }
 425 | 
 426 | /* Add borders to a cubemap image. Assume the given image pointer is an array */
 427 | /* of six images. Copy each to a new sef of six images, each two pixels wider */
 428 | /* and higher. Also copy the borders. This is necessary for correct cubemap   */
 429 | /* sampling.                                                                  */
 430 | 
 431 | static image *image_border(image *src)
 432 | {
 433 |     image *dst = 0;
 434 | 
 435 |     const int d = 1;
 436 | 
 437 |     if ((src) && (dst = image_alloc(6, src[0].w + 2 * d,
 438 |                                        src[0].w + 2 * d,
 439 |                                        src[0].c,
 440 |                                        src[0].b,
 441 |                                        src[0].s)))
 442 |     {
 443 |         const int n = src[0].w;
 444 |         const int c = src[0].c;
 445 |         const int b = 4;
 446 | 
 447 |         const int N = n + 2 * d;
 448 | 
 449 |         /* Copy all page data. */
 450 | 
 451 |         blit(dst[0].p, N, d, d, src[0].p, n, 0, 0, n, n, c, b);
 452 |         blit(dst[1].p, N, d, d, src[1].p, n, 0, 0, n, n, c, b);
 453 |         blit(dst[2].p, N, d, d, src[2].p, n, 0, 0, n, n, c, b);
 454 |         blit(dst[3].p, N, d, d, src[3].p, n, 0, 0, n, n, c, b);
 455 |         blit(dst[4].p, N, d, d, src[4].p, n, 0, 0, n, n, c, b);
 456 |         blit(dst[5].p, N, d, d, src[5].p, n, 0, 0, n, n, c, b);
 457 | 
 458 |         border(dst + 0, rotN, dst + 5, rotN, d);
 459 |         border(dst + 5, rotN, dst + 1, rotN, d);
 460 |         border(dst + 1, rotN, dst + 4, rotN, d);
 461 |         border(dst + 4, rotN, dst + 0, rotN, d);
 462 | 
 463 |         border(dst + 1, rotR, dst + 2, rotN, d);
 464 |         border(dst + 1, rotL, dst + 3, rotN, d);
 465 | 
 466 |         border(dst + 2, rotN, dst + 0, rotL, d);
 467 |         border(dst + 3, rotN, dst + 0, rotR, d);
 468 | 
 469 |         border(dst + 2, rotL, dst + 4, rotL, d);
 470 |         border(dst + 2, rotR, dst + 5, rotL, d);
 471 |         border(dst + 3, rotL, dst + 5, rotR, d);
 472 |         border(dst + 3, rotR, dst + 4, rotR, d);
 473 | 
 474 | #if 0
 475 |         /* Corner patch hack. */
 476 | 
 477 |         for     (f = 0; f < 6; f++)
 478 |             for (k = 0; k < c; k++)
 479 |             {
 480 |                 SAMP(dst[f], 0, 0, k) = (SAMP(dst[f], 1, 0, k) +
 481 |                                          SAMP(dst[f], 0, 1, k) +
 482 |                                          SAMP(dst[f], 1, 1, k)) / 3.0f;
 483 |                 SAMP(dst[f], 0, M, k) = (SAMP(dst[f], 1, M, k) +
 484 |                                          SAMP(dst[f], 0, L, k) +
 485 |                                          SAMP(dst[f], 1, L, k)) / 3.0f;
 486 |                 SAMP(dst[f], M, 0, k) = (SAMP(dst[f], L, 0, k) +
 487 |                                          SAMP(dst[f], M, 1, k) +
 488 |                                          SAMP(dst[f], L, 1, k)) / 3.0f;
 489 |                 SAMP(dst[f], M, M, k) = (SAMP(dst[f], L, M, k) +
 490 |                                          SAMP(dst[f], M, L, k) +
 491 |                                          SAMP(dst[f], L, L, k)) / 3.0f;
 492 |             }
 493 | #endif
 494 |     }
 495 |     return dst;
 496 | }
 497 | 
 498 | /*----------------------------------------------------------------------------*/
 499 | 
 500 | /* Sample an image at row i column j using linear interpolation.              */
 501 | 
 502 | static void filter_linear(const image *img, float i, float j, float *p)
 503 | {
 504 |     const float ii = clamp(i - 0.5f, 0.0f, img->h - 1.0f);
 505 |     const float jj = clamp(j - 0.5f, 0.0f, img->w - 1.0f);
 506 | 
 507 |     const long  i0 = lrintf(floorf(ii)), i1 = lrintf(ceilf(ii));
 508 |     const long  j0 = lrintf(floorf(jj)), j1 = lrintf(ceilf(jj));
 509 | 
 510 |     const float di = ii - i0;
 511 |     const float dj = jj - j0;
 512 | 
 513 |     int k;
 514 | 
 515 |     for (k = 0; k < img->c; k++)
 516 |         p[k] += lerp(lerp(img->p[(img->w * i0 + j0) * img->c + k],
 517 |                           img->p[(img->w * i0 + j1) * img->c + k], dj),
 518 |                      lerp(img->p[(img->w * i1 + j0) * img->c + k],
 519 |                           img->p[(img->w * i1 + j1) * img->c + k], dj), di);
 520 | }
 521 | 
 522 | /* Sample an image at row i column j using nearest neighbor.                  */
 523 | 
 524 | static void filter_nearest(const image *img, float i, float j, float *p)
 525 | {
 526 |     const float ii = clamp(i - 0.5f, 0.0f, img->h - 1.0f);
 527 |     const float jj = clamp(j - 0.5f, 0.0f, img->w - 1.0f);
 528 | 
 529 |     const long  i0 = lrintf(ii);
 530 |     const long  j0 = lrintf(jj);
 531 | 
 532 |     int k;
 533 | 
 534 |     for (k = 0; k < img->c; k++)
 535 |         p[k] += img->p[(img->w * i0 + j0) * img->c + k];
 536 | }
 537 | 
 538 | /*----------------------------------------------------------------------------*/
 539 | 
 540 | static int cube_to_img(int *f, float *i, float *j, int h, int w, const float *v)
 541 | {
 542 |     const float X = fabsf(v[0]);
 543 |     const float Y = fabsf(v[1]);
 544 |     const float Z = fabsf(v[2]);
 545 | 
 546 |     float x;
 547 |     float y;
 548 | 
 549 |     if      (v[0] > 0 && X >= Y && X >= Z) { *f = 0; x = -v[2] / X; y = -v[1] / X; }
 550 |     else if (v[0] < 0 && X >= Y && X >= Z) { *f = 1; x =  v[2] / X; y = -v[1] / X; }
 551 |     else if (v[1] > 0 && Y >= X && Y >= Z) { *f = 2; x =  v[0] / Y; y =  v[2] / Y; }
 552 |     else if (v[1] < 0 && Y >= X && Y >= Z) { *f = 3; x =  v[0] / Y; y = -v[2] / Y; }
 553 |     else if (v[2] > 0 && Z >= X && Z >= Y) { *f = 4; x =  v[0] / Z; y = -v[1] / Z; }
 554 |     else if (v[2] < 0 && Z >= X && Z >= Y) { *f = 5; x = -v[0] / Z; y = -v[1] / Z; }
 555 |     else return 0;
 556 | 
 557 |     *i = 1.0f + (h - 2) * (y + 1.0f) / 2.0f;
 558 |     *j = 1.0f + (w - 2) * (x + 1.0f) / 2.0f;
 559 | 
 560 |     return 1;
 561 | }
 562 | 
 563 | static int dome_to_img(int *f, float *i, float *j, int h, int w, const float *v)
 564 | {
 565 |     if (v[1] >= 0)
 566 |     {
 567 |         const float d = sqrtf(v[0] * v[0] + v[2] * v[2]);
 568 |         const float r = acosf(v[1]) / PI2;
 569 | 
 570 |         *f = 0;
 571 |         *i = h * (1.0f - r * v[2] / d) / 2.0f;
 572 |         *j = w * (1.0f + r * v[0] / d) / 2.0f;
 573 | 
 574 |         return 1;
 575 |     }
 576 |     return 0;
 577 | }
 578 | 
 579 | static int hemi_to_img(int *f, float *i, float *j, int h, int w, const float *v)
 580 | {
 581 |     if (v[2] <= 0)
 582 |     {
 583 |         const float d = sqrtf(v[0] * v[0] + v[1] * v[1]);
 584 |         const float r = acosf(-v[2]) / PI2;
 585 | 
 586 |         *f = 0;
 587 |         *i = h * (1.0f - r * v[1] / d) / 2.0f;
 588 |         *j = w * (1.0f + r * v[0] / d) / 2.0f;
 589 | 
 590 |         return 1;
 591 |     }
 592 |     return 0;
 593 | }
 594 | 
 595 | static int ball_to_img(int *f, float *i, float *j, int h, int w, const float *v)
 596 | {
 597 |     const float d = sqrtf(v[0] * v[0] + v[1] * v[1]);
 598 |     const float r = sinf(acosf(v[2]) * 0.5f);
 599 | 
 600 |     *f = 0;
 601 |     *i = h * (1.0f - r * v[1] / d) / 2.0f;
 602 |     *j = w * (1.0f + r * v[0] / d) / 2.0f;
 603 | 
 604 |     return 1;
 605 | }
 606 | 
 607 | static int rect_to_img(int *f, float *i, float *j, int h, int w, const float *v)
 608 | {
 609 |     *f = 0;
 610 |     *i = h * (       acosf (v[1])        / PI);
 611 |     *j = w * (0.5f + atan2f(v[0], -v[2]) / TAU);
 612 | 
 613 |     return 1;
 614 | }
 615 | 
 616 | /*----------------------------------------------------------------------------*/
 617 | 
 618 | static int cube_to_env(int f, float i, float j, int h, int w, float *v)
 619 | {
 620 |     const int p[6][3][3] = {
 621 |         {{  0,  0, -1 }, {  0, -1,  0 }, {  1,  0,  0 }},
 622 |         {{  0,  0,  1 }, {  0, -1,  0 }, { -1,  0,  0 }},
 623 |         {{  1,  0,  0 }, {  0,  0,  1 }, {  0,  1,  0 }},
 624 |         {{  1,  0,  0 }, {  0,  0, -1 }, {  0, -1,  0 }},
 625 |         {{  1,  0,  0 }, {  0, -1,  0 }, {  0,  0,  1 }},
 626 |         {{ -1,  0,  0 }, {  0, -1,  0 }, {  0,  0, -1 }},
 627 |     };
 628 | 
 629 |     const float y = 2.0f * i / h - 1.0f;
 630 |     const float x = 2.0f * j / w - 1.0f;
 631 | 
 632 |     v[0] = p[f][0][0] * x + p[f][1][0] * y + p[f][2][0];
 633 |     v[1] = p[f][0][1] * x + p[f][1][1] * y + p[f][2][1];
 634 |     v[2] = p[f][0][2] * x + p[f][1][2] * y + p[f][2][2];
 635 | 
 636 |     normalize(v);
 637 |     return 1;
 638 | }
 639 | 
 640 | static int dome_to_env(int f, float i, float j, int h, int w, float *v)
 641 | {
 642 |     const float y = 2.0f * i / h - 1.0f;
 643 |     const float x = 2.0f * j / w - 1.0f;
 644 | 
 645 |     if (length(x, y) <= 1.0f)
 646 |     {
 647 |         const float lat = PI2 - PI2 * length(x, y);
 648 |         const float lon =             atan2f(x, y);
 649 | 
 650 |         v[0] =  sinf(lon) * cosf(lat);
 651 |         v[1] =              sinf(lat);
 652 |         v[2] = -cosf(lon) * cosf(lat);
 653 | 
 654 |         return 1;
 655 |     }
 656 |     return 0;
 657 | }
 658 | 
 659 | static int hemi_to_env(int f, float i, float j, int h, int w, float *v)
 660 | {
 661 |     const float y = 2.0f * i / h  - 1.0f;
 662 |     const float x = 2.0f * j / w  - 1.0f;
 663 | 
 664 |     if (length(x, y) <= 1.0f)
 665 |     {
 666 |         const float lat = PI2 - PI2 * length(x, y);
 667 |         const float lon =             atan2f(x, y);
 668 | 
 669 |         v[0] =  sinf(lon) * cosf(lat);
 670 |         v[1] = -cosf(lon) * cosf(lat);
 671 |         v[2] =             -sinf(lat);
 672 | 
 673 |         return 1;
 674 |     }
 675 |     return 0;
 676 | }
 677 | 
 678 | static int ball_to_env(int f, float i, float j, int h, int w, float *v)
 679 | {
 680 |     const float y = 2.0f * i / h  - 1.0f;
 681 |     const float x = 2.0f * j / w  - 1.0f;
 682 | 
 683 |     if (length(x, y) <= 1.0f)
 684 |     {
 685 |         const float lat = 2.0f * asin(length(x, y));
 686 |         const float lon =             atan2f(x, y);
 687 | 
 688 |         v[0] =  sinf(lon) * sinf(lat);
 689 |         v[1] = -cosf(lon) * sinf(lat);
 690 |         v[2] =              cosf(lat);
 691 | 
 692 |         return 1;
 693 |     }
 694 |     return 0;
 695 | }
 696 | 
 697 | static int rect_to_env(int f, float i, float j, int h, int w, float *v)
 698 | {
 699 |     const float lat = PI2 - PI * i / h;
 700 |     const float lon = TAU * j / w - PI;
 701 | 
 702 |     v[0] =  sinf(lon) * cosf(lat);
 703 |     v[1] =              sinf(lat);
 704 |     v[2] = -cosf(lon) * cosf(lat);
 705 | 
 706 |     return 1;
 707 | }
 708 | 
 709 | /*----------------------------------------------------------------------------*/
 710 | 
 711 | static int xfm(const float *rot, float *v)
 712 | {
 713 |     if (rot[0])
 714 |     {
 715 |         float s = sinf(rot[0] * PI / 180.0f);
 716 |         float c = cosf(rot[0] * PI / 180.0f);
 717 |         float y = v[1] * c - v[2] * s;
 718 |         float z = v[1] * s + v[2] * c;
 719 | 
 720 |         v[1] = y; v[2] = z;
 721 |     }
 722 |     if (rot[1])
 723 |     {
 724 |         float s = sinf(rot[1] * PI / 180.0f);
 725 |         float c = cosf(rot[1] * PI / 180.0f);
 726 |         float z = v[2] * c - v[0] * s;
 727 |         float x = v[2] * s + v[0] * c;
 728 | 
 729 |         v[0] = x; v[2] = z;
 730 |     }
 731 |     if (rot[2])
 732 |     {
 733 |         float s = sinf(rot[2] * PI / 180.0f);
 734 |         float c = cosf(rot[2] * PI / 180.0f);
 735 |         float x = v[0] * c - v[1] * s;
 736 |         float y = v[0] * s + v[1] * c;
 737 | 
 738 |         v[0] = x; v[1] = y;
 739 |     }
 740 |     return 1;
 741 | }
 742 | 
 743 | void supersample(const image   *src,
 744 |                  const image   *dst,
 745 |                  const pattern *pat,
 746 |                  const float   *rot,
 747 |                  filter fil, to_img img, to_env env, int f, int i, int j)
 748 | {
 749 |     int    F;
 750 |     float  I;
 751 |     float  J;
 752 |     int    k;
 753 |     int    c = 0;
 754 |     float *p = dst[f].p + dst[f].c * (dst[f].w * i + j);
 755 | 
 756 |     /* For each sample of the supersampling pattern... */
 757 | 
 758 |     for (k = 0; k < pat->n; k++)
 759 |     {
 760 |         const float ii = pat->p[k].i + i;
 761 |         const float jj = pat->p[k].j + j;
 762 | 
 763 |         /* Project and unproject giving the source location. Sample there. */
 764 | 
 765 |         float v[3];
 766 | 
 767 |         if (env( f, ii, jj, dst->h, dst->w, v) && xfm(rot, v) &&
 768 |             img(&F, &I, &J, src->h, src->w, v))
 769 |         {
 770 | #if 1
 771 |             fil(src + F, I, J, p);
 772 | #else
 773 |             p[0] = (v[0] + 1.0f) / 2.0f;
 774 |             p[1] = (v[1] + 1.0f) / 2.0f;
 775 |             p[2] = (v[2] + 1.0f) / 2.0f;
 776 | #endif
 777 |             c++;
 778 |         }
 779 |     }
 780 | 
 781 |     /* Normalize the sample. */
 782 | 
 783 |     for (k = 0; k < dst->c; k++)
 784 |         p[k] /= c;
 785 | }
 786 | 
 787 | void process(const image   *src,
 788 |              const image   *dst,
 789 |              const pattern *pat,
 790 |              const float   *rot,
 791 |              filter fil, to_img img, to_env env, int n)
 792 | {
 793 |     int i;
 794 |     int j;
 795 |     int f;
 796 | 
 797 |     /* Sample all destination rows, columns, and pages. */
 798 | 
 799 |     #pragma omp parallel for private(j, f)
 800 |     for         (i = 0; i < dst->h; i++)
 801 |         for     (j = 0; j < dst->w; j++)
 802 |             for (f = 0; f <      n; f++)
 803 |                 supersample(src, dst, pat, rot, fil, img, env, f, i, j);
 804 | }
 805 | 
 806 | /*----------------------------------------------------------------------------*/
 807 | 
 808 | static point cent_points[] = {
 809 |     { 0.5f, 0.5f },
 810 | };
 811 | 
 812 | static point rgss_points[] = {
 813 |     { 0.125f, 0.625f },
 814 |     { 0.375f, 0.125f },
 815 |     { 0.625f, 0.875f },
 816 |     { 0.875f, 0.375f },
 817 | };
 818 | 
 819 | static point box2_points[] = {
 820 |     { 0.25f, 0.25f },
 821 |     { 0.25f, 0.75f },
 822 |     { 0.75f, 0.25f },
 823 |     { 0.75f, 0.75f },
 824 | };
 825 | 
 826 | static point box3_points[] = {
 827 |     { 0.1666667f, 0.1666667f },
 828 |     { 0.1666667f, 0.5000000f },
 829 |     { 0.1666667f, 0.8333333f },
 830 |     { 0.5000000f, 0.1666667f },
 831 |     { 0.5000000f, 0.5000000f },
 832 |     { 0.5000000f, 0.8333333f },
 833 |     { 0.8333333f, 0.1666667f },
 834 |     { 0.8333333f, 0.5000000f },
 835 |     { 0.8333333f, 0.8333333f },
 836 | };
 837 | 
 838 | static point box4_points[] = {
 839 |     { 0.125f, 0.125f },
 840 |     { 0.125f, 0.375f },
 841 |     { 0.125f, 0.625f },
 842 |     { 0.125f, 0.875f },
 843 |     { 0.375f, 0.125f },
 844 |     { 0.375f, 0.375f },
 845 |     { 0.375f, 0.625f },
 846 |     { 0.375f, 0.875f },
 847 |     { 0.625f, 0.125f },
 848 |     { 0.625f, 0.375f },
 849 |     { 0.625f, 0.625f },
 850 |     { 0.625f, 0.875f },
 851 |     { 0.875f, 0.125f },
 852 |     { 0.875f, 0.375f },
 853 |     { 0.875f, 0.625f },
 854 |     { 0.875f, 0.875f },
 855 | };
 856 | 
 857 | static const pattern cent_pattern = {  1, cent_points };
 858 | static const pattern rgss_pattern = {  4, rgss_points };
 859 | static const pattern box2_pattern = {  4, box2_points };
 860 | static const pattern box3_pattern = {  9, box3_points };
 861 | static const pattern box4_pattern = { 16, box4_points };
 862 | 
 863 | /*----------------------------------------------------------------------------*/
 864 | 
 865 | static int usage(const char *exe)
 866 | {
 867 |     fprintf(stderr,
 868 |             "%s [-i input] [-o output] [-p pattern] [-f filter] [-n n] src dst\n"
 869 |             "\t-i ... Input  file type: cube, dome, hemi, ball, rect  [rect]\n"
 870 |             "\t-o ... Output file type: cube, dome, hemi, ball, rect  [rect]\n"
 871 |             "\t-p ... Sample pattern: cent, rgss, box2, box3, box4    [rgss]\n"
 872 |             "\t-f ... Filter type: nearest, linear                  [linear]\n"
 873 |             "\t-n ... Output size                                     [1024]\n",
 874 |             exe);
 875 |     return 0;
 876 | }
 877 | 
 878 | int main(int argc, char **argv)
 879 | {
 880 |     /* Set some default behaviors. */
 881 | 
 882 |     const char *i = "rect";
 883 |     const char *o = "rect";
 884 |     const char *p = "rgss";
 885 |     const char *f = "linear";
 886 | 
 887 |     float rot[3] = { 0.f, 0.f, 0.f };
 888 | 
 889 |     int n = 1024;
 890 |     int c;
 891 | 
 892 |     /* Parse the command line options. */
 893 | 
 894 |     while ((c = getopt(argc, argv, "i:o:p:n:f:x:y:z:")) != -1)
 895 |         switch (c)
 896 |         {
 897 |             case 'i': i      = optarg;               break;
 898 |             case 'o': o      = optarg;               break;
 899 |             case 'p': p      = optarg;               break;
 900 |             case 'f': f      = optarg;               break;
 901 |             case 'x': rot[0] = strtod(optarg, 0);    break;
 902 |             case 'y': rot[1] = strtod(optarg, 0);    break;
 903 |             case 'z': rot[2] = strtod(optarg, 0);    break;
 904 |             case 'n': n      = strtol(optarg, 0, 0); break;
 905 | 
 906 |             default: return usage(argv[0]);
 907 |         }
 908 | 
 909 |     int      num = 1;
 910 |     image   *src = 0;
 911 |     image   *dst = 0;
 912 |     image   *tmp = 0;
 913 |     to_img   img;
 914 |     to_env   env;
 915 |     filter   fil;
 916 | 
 917 |     /* Select the sampler. */
 918 | 
 919 |     if      (!strcmp(f, "linear"))  fil = filter_linear;
 920 |     else if (!strcmp(f, "nearest")) fil = filter_nearest;
 921 |     else return usage(argv[0]);
 922 | 
 923 |     /* Read the input image. */
 924 | 
 925 |     if (optind + 2 <= argc)
 926 |     {
 927 |         if      (!strcmp(i, "cube"))
 928 |         {
 929 |             tmp = image_reader(argv[optind], 6);
 930 |             src = image_border(tmp);
 931 |             img = cube_to_img;
 932 |         }
 933 |         else if (!strcmp(i, "dome"))
 934 |         {
 935 |             src = image_reader(argv[optind], 1);
 936 |             img = dome_to_img;
 937 |         }
 938 |         else if (!strcmp(i, "hemi"))
 939 |         {
 940 |             src = image_reader(argv[optind], 1);
 941 |             img = hemi_to_img;
 942 |         }
 943 |         else if (!strcmp(i, "ball"))
 944 |         {
 945 |             src = image_reader(argv[optind], 1);
 946 |             img = ball_to_img;
 947 |         }
 948 |         else if (!strcmp(i, "rect"))
 949 |         {
 950 |             src = image_reader(argv[optind], 1);
 951 |             img = rect_to_img;
 952 |         }
 953 |         else return usage(argv[0]);
 954 |     }
 955 |     else return usage(argv[0]);
 956 | 
 957 |     /* Prepare the output image. */
 958 | 
 959 |     if (src)
 960 |     {
 961 |         if      (!strcmp(o, "cube"))
 962 |         {
 963 |             dst = image_alloc((num = 6), n, n, src->c, src->b, src->s);
 964 |             env = cube_to_env;
 965 |         }
 966 |         else if (!strcmp(o, "dome"))
 967 |         {
 968 |             dst = image_alloc((num = 1), n, n, src->c, src->b, src->s);
 969 |             env = dome_to_env;
 970 |         }
 971 |         else if (!strcmp(o, "hemi"))
 972 |         {
 973 |             dst = image_alloc((num = 1), n, n, src->c, src->b, src->s);
 974 |             env = hemi_to_env;
 975 |         }
 976 |         else if (!strcmp(o, "ball"))
 977 |         {
 978 |             dst = image_alloc((num = 1), n, n, src->c, src->b, src->s);
 979 |             env = ball_to_env;
 980 |         }
 981 |         else if (!strcmp(o, "rect"))
 982 |         {
 983 |             dst = image_alloc((num = 1), n, 2 * n, src->c, src->b, src->s);
 984 |             env = rect_to_env;
 985 |         }
 986 |         else return usage(argv[0]);
 987 |     }
 988 | 
 989 |     /* Perform the remapping using the selected pattern. */
 990 | 
 991 |     if (src && dst)
 992 |     {
 993 |         if      (!strcmp(p, "cent"))
 994 |             process(src, dst, &cent_pattern, rot, fil, img, env, num);
 995 | 
 996 |         else if (!strcmp(p, "rgss"))
 997 |             process(src, dst, &rgss_pattern, rot, fil, img, env, num);
 998 | 
 999 |         else if (!strcmp(p, "box2"))
1000 |             process(src, dst, &box2_pattern, rot, fil, img, env, num);
1001 | 
1002 |         else if (!strcmp(p, "box3"))
1003 |             process(src, dst, &box3_pattern, rot, fil, img, env, num);
1004 | 
1005 |         else if (!strcmp(p, "box4"))
1006 |             process(src, dst, &box4_pattern, rot, fil, img, env, num);
1007 | 
1008 |         else return usage(argv[0]);
1009 | 
1010 |         /* Write the output. */
1011 | 
1012 |         image_writer(argv[optind + 1], dst, num);
1013 |     }
1014 | 
1015 |     return 0;
1016 | }
1017 | 


--------------------------------------------------------------------------------
/envtoirr.c:
--------------------------------------------------------------------------------
  1 | /* Copyright (c) 2010-2013 Robert Kooima                                      */
  2 | /*                                                                            */
  3 | /* Permission is hereby granted, free of charge, to any person obtaining a    */
  4 | /* copy of this software and associated documentation files (the "Software"), */
  5 | /* to deal in the Software without restriction, including without limitation  */
  6 | /* the rights to use, copy, modify, merge, publish, distribute, sublicense,   */
  7 | /* and/or sell copies of the Software, and to permit persons to whom the      */
  8 | /* Software is furnished to do so, subject to the following conditions:       */
  9 | /*                                                                            */
 10 | /* The above copyright notice and this permission notice shall be included in */
 11 | /* all copies or substantial portions of the Software.                        */
 12 | /*                                                                            */
 13 | /* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR */
 14 | /* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,   */
 15 | /* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL    */
 16 | /* THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER */
 17 | /* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING    */
 18 | /* FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER        */
 19 | /* DEALINGS IN THE SOFTWARE.                                                  */
 20 | 
 21 | #include <tiffio.h>
 22 | #include <stdlib.h>
 23 | #include <string.h>
 24 | #include <getopt.h>
 25 | #include <stdio.h>
 26 | #include <math.h>
 27 | 
 28 | #include "gray.h"
 29 | #include "sRGB.h"
 30 | 
 31 | #define PI  3.1415927f
 32 | 
 33 | /* See "An Efficient Representation for Irradiance Environment Maps" by       */
 34 | /* Ramamorrthi & Handrahan, SIGGRAPH 2001                                     */
 35 | 
 36 | /*----------------------------------------------------------------------------*/
 37 | 
 38 | /* This array defines the X, Y, and Z axes of each of the six cube map faces, */
 39 | /* which determine the orientation of each face and the mapping between 2D    */
 40 | /* image space and 3D cube map space.                                         */
 41 | 
 42 | static const double nx[3] = { -1.0,  0.0,  0.0 };
 43 | static const double px[3] = {  1.0,  0.0,  0.0 };
 44 | static const double ny[3] = {  0.0, -1.0,  0.0 };
 45 | static const double py[3] = {  0.0,  1.0,  0.0 };
 46 | static const double nz[3] = {  0.0,  0.0, -1.0 };
 47 | static const double pz[3] = {  0.0,  0.0,  1.0 };
 48 | 
 49 | const double *cubemap_axis[6][3] = {
 50 |     { pz, py, nx },
 51 |     { nz, py, px },
 52 |     { nx, nz, ny },
 53 |     { nx, pz, py },
 54 |     { nx, py, nz },
 55 |     { px, py, pz },
 56 | };
 57 | 
 58 | static void normalize(double *a, const double *b)
 59 | {
 60 |     const double k = 1.0 / sqrt(b[0] * b[0] + b[1] * b[1] + b[2] * b[2]);
 61 | 
 62 |     a[0] = b[0] * k;
 63 |     a[1] = b[1] * k;
 64 |     a[2] = b[2] * k;
 65 | }
 66 | 
 67 | void transform(double *a, const double *M, const double *b)
 68 | {
 69 |     a[0] = M[ 0] * b[0] + M[ 4] * b[1] + M[ 8] * b[2] + M[12] * b[3];
 70 |     a[1] = M[ 1] * b[0] + M[ 5] * b[1] + M[ 9] * b[2] + M[13] * b[3];
 71 |     a[2] = M[ 2] * b[0] + M[ 6] * b[1] + M[10] * b[2] + M[14] * b[3];
 72 |     a[3] = M[ 3] * b[0] + M[ 7] * b[1] + M[11] * b[2] + M[15] * b[3];
 73 | }
 74 | 
 75 | static void vector(double *v, int f, double x, double y, double z)
 76 | {
 77 |     const double *X = cubemap_axis[f][0];
 78 |     const double *Y = cubemap_axis[f][1];
 79 |     const double *Z = cubemap_axis[f][2];
 80 | 
 81 |     double w[3];
 82 | 
 83 |     w[0] = X[0] * x + Y[0] * y + Z[0] * z;
 84 |     w[1] = X[1] * x + Y[1] * y + Z[1] * z;
 85 |     w[2] = X[2] * x + Y[2] * y + Z[2] * z;
 86 | 
 87 |     normalize(v, w);
 88 |     v[3] = 1.0;
 89 | }
 90 | 
 91 | double solid_angle(const double *a,
 92 |                    const double *b,
 93 |                    const double *c)
 94 | {
 95 |     double n = fabs(a[0] * (b[1] * c[2] - b[2] * c[1]) +
 96 |                     a[1] * (b[2] * c[0] - b[0] * c[2]) +
 97 |                     a[2] * (b[0] * c[1] - b[1] * c[0]));
 98 | 
 99 |     double d = 1.0 + a[0] * b[0] + a[1] * b[1] + a[2] * b[2]
100 |                    + a[0] * c[0] + a[1] * c[1] + a[2] * c[2]
101 |                    + b[0] * c[0] + b[1] * c[1] + b[2] * c[2];
102 | 
103 |     return 2.0 * atan2(n, d);
104 | }
105 | 
106 | /*----------------------------------------------------------------------------*/
107 | 
108 | double *sph_grace_cathedral(uint16 *C)
109 | {
110 |     double *L = 0;
111 | 
112 |     if ((L = (double *) malloc(9 * 3 * sizeof (double))))
113 |     {
114 |         L[ 0] =  0.79; L[ 1] =  0.44; L[ 2] =  0.54;
115 |         L[ 3] =  0.39; L[ 4] =  0.35; L[ 5] =  0.60;
116 |         L[ 6] = -0.34; L[ 7] = -0.18; L[ 8] = -0.27;
117 |         L[ 9] = -0.29; L[10] = -0.06; L[11] =  0.01;
118 |         L[12] = -0.11; L[13] = -0.05; L[14] = -0.12;
119 |         L[15] = -0.26; L[16] = -0.22; L[17] = -0.47;
120 |         L[18] = -0.16; L[19] = -0.09; L[20] = -0.15;
121 |         L[21] =  0.56; L[22] =  0.21; L[23] =  0.14;
122 |         L[24] =  0.21; L[25] = -0.05; L[26] = -0.30;
123 | 
124 |         *C = 3;
125 |     }
126 |     return L;
127 | }
128 | 
129 | double *sph_eucalyptus_grove(uint16 *C)
130 | {
131 |     double *L = 0;
132 | 
133 |     if ((L = (double *) malloc(9 * 3 * sizeof (double))))
134 |     {
135 |         L[ 0] =  0.38; L[ 1] =  0.43; L[ 2] =  0.45;
136 |         L[ 3] =  0.29; L[ 4] =  0.36; L[ 5] =  0.41;
137 |         L[ 6] =  0.04; L[ 7] =  0.03; L[ 8] =  0.01;
138 |         L[ 9] = -0.10; L[10] = -0.10; L[11] = -0.09;
139 |         L[12] = -0.06; L[13] = -0.06; L[14] = -0.04;
140 |         L[15] =  0.01; L[16] = -0.01; L[17] = -0.05;
141 |         L[18] = -0.09; L[19] = -0.13; L[20] = -0.15;
142 |         L[21] = -0.06; L[22] = -0.05; L[23] = -0.04;
143 |         L[24] =  0.02; L[25] = -0.00; L[26] = -0.05;
144 | 
145 |         *C = 3;
146 |     }
147 |     return L;
148 | }
149 | 
150 | double *sph_st_peters_basilica(uint16 *C)
151 | {
152 |     double *L = 0;
153 | 
154 |     if ((L = (double *) malloc(9 * 3 * sizeof (double))))
155 |     {
156 |         L[ 0] =  0.36; L[ 1] =  0.26; L[ 2] =  0.23;
157 |         L[ 3] =  0.18; L[ 4] =  0.14; L[ 5] =  0.13;
158 |         L[ 6] = -0.02; L[ 7] = -0.01; L[ 8] = -0.00;
159 |         L[ 9] =  0.03; L[10] =  0.02; L[11] =  0.01;
160 |         L[12] =  0.02; L[13] =  0.01; L[14] =  0.00;
161 |         L[15] = -0.05; L[16] = -0.03; L[17] = -0.01;
162 |         L[18] = -0.09; L[19] = -0.08; L[20] = -0.07;
163 |         L[21] =  0.01; L[22] =  0.00; L[23] =  0.00;
164 |         L[24] = -0.08; L[25] = -0.06; L[26] =  0.00;
165 | 
166 |         *C = 3;
167 |     }
168 |     return L;
169 | }
170 | 
171 | /*----------------------------------------------------------------------------*/
172 | 
173 | double calc_domega(const double *v00,
174 |                    const double *v01,
175 |                    const double *v10,
176 |                    const double *v11)
177 | {
178 |     return (solid_angle(v00, v11, v01) +
179 |             solid_angle(v11, v00, v10)) / (4 * PI);
180 | }
181 | 
182 | void calc_Y(double *Y, double x, double y, double z)
183 | {
184 |     Y[0] = 0.282095;
185 |     Y[1] = 0.488603 *  y;
186 |     Y[2] = 0.488603 *  z;
187 |     Y[3] = 0.488603 *  x;
188 |     Y[4] = 1.092548 *  x * y;
189 |     Y[5] = 1.092548 *  y * z;
190 |     Y[6] = 0.315392 * (3 * z * z - 1);
191 |     Y[7] = 1.092548 *  x * z;
192 |     Y[8] = 0.546274 * (x * x - y * y);
193 | }
194 | 
195 | void env_to_sph_face(double *L, TIFF *I, int F, uint32 N, uint16 C, uint16 B)
196 | {
197 |     /* Confirm the parameters of the current face. */
198 | 
199 |     if (TIFFSetDirectory(I, F))
200 |     {
201 |         uint32 w, h;
202 |         uint16 b, c;
203 |         float *s;
204 | 
205 |         TIFFGetField(I, TIFFTAG_IMAGEWIDTH,      &w);
206 |         TIFFGetField(I, TIFFTAG_IMAGELENGTH,     &h);
207 |         TIFFGetField(I, TIFFTAG_SAMPLESPERPIXEL, &c);
208 |         TIFFGetField(I, TIFFTAG_BITSPERSAMPLE,   &b);
209 | 
210 |         if (w == N && h == N && b == B && c == C)
211 |         {
212 |             /* Allocate a scanline buffer. */
213 | 
214 |             if ((s = (float *) malloc(TIFFScanlineSize(I))))
215 |             {
216 |                 uint32 i;
217 |                 uint32 j;
218 |                 uint16 k;
219 | 
220 |                 /* Iterate over all pixels of the current cube face. */
221 | 
222 |                 for (i = 0; i < N; ++i)
223 |                 {
224 |                     if (TIFFReadScanline(I, s, i, 0) == 1)
225 |                     {
226 |                         for (j = 0; j < N; ++j)
227 |                         {
228 |                             float *p = s + j * c;
229 | 
230 |                             /* Compute the direction vector to this pixel. */
231 | 
232 |                             double y0  = (2.0 * (i      ) - N) / N;
233 |                             double y   = (2.0 * (i + 0.5) - N) / N;
234 |                             double y1  = (2.0 * (i + 1.0) - N) / N;
235 |                             double x0  = (2.0 * (j      ) - N) / N;
236 |                             double x   = (2.0 * (j + 0.5) - N) / N;
237 |                             double x1  = (2.0 * (j + 1.0) - N) / N;
238 | 
239 |                             double v00[4];
240 |                             double v01[4];
241 |                             double v10[4];
242 |                             double v11[4];
243 | 
244 |                             double v[4];
245 |                             double Y[9];
246 |                             double dd;
247 | 
248 |                             vector(v00, F, x0, y0, 1.f);
249 |                             vector(v01, F, x0, y1, 1.f);
250 |                             vector(v10, F, x1, y0, 1.f);
251 |                             vector(v11, F, x1, y1, 1.f);
252 |                             vector(v,   F, x,  y,  1.f);
253 | 
254 |                             dd = calc_domega(v00, v01, v10, v11);
255 | 
256 |                             calc_Y(Y, v[0], v[1], v[2]);
257 | 
258 |                             for (k = 0; k < c; ++k)
259 |                             {
260 |                                 L[0 * c + k] += Y[0] * (double) p[k] * dd;
261 |                                 L[1 * c + k] += Y[1] * (double) p[k] * dd;
262 |                                 L[2 * c + k] += Y[2] * (double) p[k] * dd;
263 |                                 L[3 * c + k] += Y[3] * (double) p[k] * dd;
264 |                                 L[4 * c + k] += Y[4] * (double) p[k] * dd;
265 |                                 L[5 * c + k] += Y[5] * (double) p[k] * dd;
266 |                                 L[6 * c + k] += Y[6] * (double) p[k] * dd;
267 |                                 L[7 * c + k] += Y[7] * (double) p[k] * dd;
268 |                                 L[8 * c + k] += Y[8] * (double) p[k] * dd;
269 |                             }
270 |                         }
271 |                     }
272 |                 }
273 |                 free(s);
274 |             }
275 |         }
276 |     }
277 | }
278 | 
279 | double *env_to_sph(TIFF *I, uint32 N, uint16 C, uint16 B)
280 | {
281 |     double *L = 0;
282 |     int     F;
283 | 
284 |     /* Allocate storage for spherical harmonic coefficients. */
285 | 
286 |     if ((L = (double *) calloc(9 * C, sizeof (double))))
287 |     {
288 |         /* Iterate over all faces, accumulating coefficients for all. */
289 | 
290 |         for (F = 0; F < 6; ++F)
291 |             env_to_sph_face(L, I, F, N, C, B);
292 |     }
293 |     return L;
294 | }
295 | 
296 | /*----------------------------------------------------------------------------*/
297 | 
298 | void irrmatrix(double *M, double Lzz, double Lpn, double Lpz,
299 |                           double Lpp, double Lqm, double Lqn,
300 |                           double Lqz, double Lqp, double Lqq)
301 | {
302 |     const double c1 = 0.429043;
303 |     const double c2 = 0.511664;
304 |     const double c3 = 0.743125;
305 |     const double c4 = 0.886227;
306 |     const double c5 = 0.247708;
307 | 
308 |     M[ 0] =  c1 * Lqq;
309 |     M[ 1] =  c1 * Lqm;
310 |     M[ 2] =  c1 * Lqp;
311 |     M[ 3] =  c2 * Lpp;
312 | 
313 |     M[ 4] =  c1 * Lqm;
314 |     M[ 5] = -c1 * Lqq;
315 |     M[ 6] =  c1 * Lqn;
316 |     M[ 7] =  c2 * Lpn;
317 | 
318 |     M[ 8] =  c1 * Lqp;
319 |     M[ 9] =  c1 * Lqn;
320 |     M[10] =  c3 * Lqz;
321 |     M[11] =  c2 * Lpz;
322 | 
323 |     M[12] =  c2 * Lpp;
324 |     M[13] =  c2 * Lpn;
325 |     M[14] =  c2 * Lpz;
326 |     M[15] =  c4 * Lzz - c5 * Lqz;
327 | }
328 | 
329 | void sph_to_irr_face(float *d, const double *M, int F, uint32 N, uint16 C, uint16 k)
330 | {
331 |     uint32 i;
332 |     uint32 j;
333 | 
334 |     /* Iterate over all pixels of the current cube face. */
335 | 
336 |     for     (i = 0; i < N; ++i)
337 |         for (j = 0; j < N; ++j)
338 |         {
339 |             /* Compute the direction vector of the current pixel. */
340 | 
341 |             double y = (double) (2.0 * (i + 0.5) - N) / N;
342 |             double x = (double) (2.0 * (j + 0.5) - N) / N;
343 | 
344 |             double v[4];
345 |             double w[4];
346 | 
347 |             vector(v, F, x, y, 1.0);
348 | 
349 |             /* Compute the irradiance. */
350 | 
351 |             transform(w, M, v);
352 | 
353 |             (d + i * N * C + j * C)[k] = (float) (v[0] * w[0] +
354 |                                                   v[1] * w[1] +
355 |                                                   v[2] * w[2] +
356 |                                                   v[3] * w[3]);
357 |         }
358 | }
359 | 
360 | void sph_to_irr(double *L, TIFF *O, uint32 N, uint16 C)
361 | {
362 |     double M[16];
363 |     float *d;
364 |     uint16 k;
365 |     uint32 i;
366 |     size_t S;
367 |     int    F;
368 | 
369 |     /* Allocate a scratch buffer for one cube face. */
370 | 
371 |     if ((d = (float *) malloc(N * N * C * sizeof (float))))
372 |     {
373 |         /* Iterate over all cube faces. */
374 | 
375 |         for (F = 0; F < 6; ++F)
376 |         {
377 |             TIFFSetField(O, TIFFTAG_IMAGEWIDTH,      N);
378 |             TIFFSetField(O, TIFFTAG_IMAGELENGTH,     N);
379 |             TIFFSetField(O, TIFFTAG_SAMPLESPERPIXEL, C);
380 |             TIFFSetField(O, TIFFTAG_BITSPERSAMPLE,   32);
381 |             TIFFSetField(O, TIFFTAG_ORIENTATION,     ORIENTATION_TOPLEFT);
382 |             TIFFSetField(O, TIFFTAG_PLANARCONFIG,    PLANARCONFIG_CONTIG);
383 |             TIFFSetField(O, TIFFTAG_SAMPLEFORMAT,    SAMPLEFORMAT_IEEEFP);
384 | 
385 |             if (C == 1)
386 |             {
387 |                 TIFFSetField(O, TIFFTAG_PHOTOMETRIC,  PHOTOMETRIC_MINISBLACK);
388 |                 TIFFSetField(O, TIFFTAG_ICCPROFILE, sizeof (grayicc), grayicc);
389 |             }
390 |             else
391 |             {
392 |                 TIFFSetField(O, TIFFTAG_PHOTOMETRIC,  PHOTOMETRIC_RGB);
393 |                 TIFFSetField(O, TIFFTAG_ICCPROFILE, sizeof (sRGBicc), sRGBicc);
394 |             }
395 | 
396 |             S = (size_t) TIFFScanlineSize(O);
397 | 
398 |             /* Iterate over all channels. */
399 | 
400 |             for (k = 0; k < C; ++k)
401 |             {
402 |                 /* Generate the irradiance matrix for the current channel. */
403 | 
404 |                 irrmatrix(M, L[0 * C + k],
405 |                              L[1 * C + k],
406 |                              L[2 * C + k],
407 |                              L[3 * C + k],
408 |                              L[4 * C + k],
409 |                              L[5 * C + k],
410 |                              L[6 * C + k],
411 |                              L[7 * C + k],
412 |                              L[8 * C + k]);
413 | 
414 |                 /* Render the current cube face using the current irradiance. */
415 | 
416 |                 sph_to_irr_face(d, M, F, N, C, k);
417 |             }
418 | 
419 |             /* Write the result to an image file. */
420 | 
421 |             for (i = 0; i < N; ++i)
422 |                 TIFFWriteScanline(O, (uint8 *) d + S * i, i, 0);
423 | 
424 |             TIFFWriteDirectory(O);
425 |         }
426 |         free(d);
427 |     }
428 | }
429 | 
430 | /*----------------------------------------------------------------------------*/
431 | 
432 | static void sph_dump(const double *L, int c)
433 | {
434 |     int i;
435 |     int k;
436 | 
437 |     printf("Spherical harmonic coefficients:\n");
438 | 
439 |     for (i = 0; i < 9; ++i)
440 |     {
441 |         for (k = 0; k < c; ++k)
442 |             printf("% 12.5f ", L[i * c + k]);
443 | 
444 |         printf("\n");
445 |     }
446 | }
447 | 
448 | static double *sph_file(const char *name, uint16 *C)
449 | {
450 |     double *L = 0;
451 |     TIFF   *T;
452 | 
453 |     if ((T = TIFFOpen(name, "r")))
454 |     {
455 |         uint32 W, H;
456 |         uint16 B;
457 | 
458 |         TIFFGetField(T, TIFFTAG_IMAGEWIDTH,     &W);
459 |         TIFFGetField(T, TIFFTAG_IMAGELENGTH,    &H);
460 |         TIFFGetField(T, TIFFTAG_SAMPLESPERPIXEL, C);
461 |         TIFFGetField(T, TIFFTAG_BITSPERSAMPLE,  &B);
462 | 
463 |         if (W == H)
464 |             L = env_to_sph(T, W, *C, B);
465 | 
466 |         TIFFClose(T);
467 |     }
468 |     return L;
469 | }
470 | 
471 | /*----------------------------------------------------------------------------*/
472 | 
473 | static int usage(const char *exe)
474 | {
475 |     fprintf(stderr, "Usage: %s [-n n] [-f in.tif] [-ges] out.tif n\n", exe);
476 |     return 1;
477 | }
478 | 
479 | int main(int argc, char *argv[])
480 | {
481 |     double *L = 0;
482 |     TIFF   *T;
483 |     uint16  C;
484 |     int     n = 256;
485 |     int     c;
486 | 
487 |     while ((c = getopt(argc, argv, "n:f:ges")) != -1)
488 |         switch (c)
489 |         {
490 |             case 'n': n = strtol(optarg, 0, 0);       break;
491 |             case 'f': L = sph_file(optarg, &C);       break;
492 |             case 'g': L = sph_grace_cathedral   (&C); break;
493 |             case 'e': L = sph_eucalyptus_grove  (&C); break;
494 |             case 's': L = sph_st_peters_basilica(&C); break;
495 | 
496 |             default: return usage(argv[0]);
497 |         }
498 | 
499 |     if (L && optind < argc)
500 |     {
501 |         if ((T = TIFFOpen(argv[optind], "w")))
502 |         {
503 |             sph_dump(L, C);
504 |             sph_to_irr(L, T, n, C);
505 |             TIFFClose(T);
506 |         }
507 |         free(L);
508 |     }
509 |     else return usage(argv[0]);
510 | 
511 |     return 0;
512 | }
513 | 


--------------------------------------------------------------------------------
/etc/ball.tif:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/rlk/envtools/2a30e6b316f28314d7f663f3820da7a95b06241f/etc/ball.tif


--------------------------------------------------------------------------------
/etc/box2.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/rlk/envtools/2a30e6b316f28314d7f663f3820da7a95b06241f/etc/box2.png


--------------------------------------------------------------------------------
/etc/box3.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/rlk/envtools/2a30e6b316f28314d7f663f3820da7a95b06241f/etc/box3.png


--------------------------------------------------------------------------------
/etc/box4.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/rlk/envtools/2a30e6b316f28314d7f663f3820da7a95b06241f/etc/box4.png


--------------------------------------------------------------------------------
/etc/cent.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/rlk/envtools/2a30e6b316f28314d7f663f3820da7a95b06241f/etc/cent.png


--------------------------------------------------------------------------------
/etc/cube.tif:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/rlk/envtools/2a30e6b316f28314d7f663f3820da7a95b06241f/etc/cube.tif


--------------------------------------------------------------------------------
/etc/dome.tif:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/rlk/envtools/2a30e6b316f28314d7f663f3820da7a95b06241f/etc/dome.tif


--------------------------------------------------------------------------------
/etc/earth.tif:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/rlk/envtools/2a30e6b316f28314d7f663f3820da7a95b06241f/etc/earth.tif


--------------------------------------------------------------------------------
/etc/hemi.tif:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/rlk/envtools/2a30e6b316f28314d7f663f3820da7a95b06241f/etc/hemi.tif


--------------------------------------------------------------------------------
/etc/moon.tif:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/rlk/envtools/2a30e6b316f28314d7f663f3820da7a95b06241f/etc/moon.tif


--------------------------------------------------------------------------------
/etc/rect.tif:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/rlk/envtools/2a30e6b316f28314d7f663f3820da7a95b06241f/etc/rect.tif


--------------------------------------------------------------------------------
/etc/rgss.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/rlk/envtools/2a30e6b316f28314d7f663f3820da7a95b06241f/etc/rgss.png


--------------------------------------------------------------------------------
/etc/sampling.ai:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/rlk/envtools/2a30e6b316f28314d7f663f3820da7a95b06241f/etc/sampling.ai


--------------------------------------------------------------------------------
/etc/thumbnail-ball.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/rlk/envtools/2a30e6b316f28314d7f663f3820da7a95b06241f/etc/thumbnail-ball.png


--------------------------------------------------------------------------------
/etc/thumbnail-cube.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/rlk/envtools/2a30e6b316f28314d7f663f3820da7a95b06241f/etc/thumbnail-cube.png


--------------------------------------------------------------------------------
/etc/thumbnail-dome.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/rlk/envtools/2a30e6b316f28314d7f663f3820da7a95b06241f/etc/thumbnail-dome.png


--------------------------------------------------------------------------------
/etc/thumbnail-hemi.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/rlk/envtools/2a30e6b316f28314d7f663f3820da7a95b06241f/etc/thumbnail-hemi.png


--------------------------------------------------------------------------------
/etc/thumbnail-rect.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/rlk/envtools/2a30e6b316f28314d7f663f3820da7a95b06241f/etc/thumbnail-rect.png


--------------------------------------------------------------------------------
/gray.h:
--------------------------------------------------------------------------------
  1 | // Generic Gray Gamma 2.2 Profile
  2 | // Copyright (C) 2008 Apple Inc.
  3 | 
  4 | unsigned char grayicc[] = {
  5 |   0x00, 0x00, 0x11, 0x90, 0x61, 0x70, 0x70, 0x6c, 0x02, 0x00, 0x00, 0x00,
  6 |   0x6d, 0x6e, 0x74, 0x72, 0x47, 0x52, 0x41, 0x59, 0x58, 0x59, 0x5a, 0x20,
  7 |   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
  8 |   0x61, 0x63, 0x73, 0x70, 0x41, 0x50, 0x50, 0x4c, 0x00, 0x00, 0x00, 0x00,
  9 |   0x6e, 0x6f, 0x6e, 0x65, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 10 |   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xf6, 0xd6,
 11 |   0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0xd3, 0x2d, 0x61, 0x70, 0x70, 0x6c,
 12 |   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 13 |   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 14 |   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 15 |   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x05,
 16 |   0x64, 0x65, 0x73, 0x63, 0x00, 0x00, 0x00, 0xc0, 0x00, 0x00, 0x00, 0x79,
 17 |   0x64, 0x73, 0x63, 0x6d, 0x00, 0x00, 0x01, 0x3c, 0x00, 0x00, 0x08, 0x10,
 18 |   0x63, 0x70, 0x72, 0x74, 0x00, 0x00, 0x09, 0x4c, 0x00, 0x00, 0x00, 0x23,
 19 |   0x77, 0x74, 0x70, 0x74, 0x00, 0x00, 0x09, 0x70, 0x00, 0x00, 0x00, 0x14,
 20 |   0x6b, 0x54, 0x52, 0x43, 0x00, 0x00, 0x09, 0x84, 0x00, 0x00, 0x08, 0x0c,
 21 |   0x64, 0x65, 0x73, 0x63, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x1f,
 22 |   0x47, 0x65, 0x6e, 0x65, 0x72, 0x69, 0x63, 0x20, 0x47, 0x72, 0x61, 0x79,
 23 |   0x20, 0x47, 0x61, 0x6d, 0x6d, 0x61, 0x20, 0x32, 0x2e, 0x32, 0x20, 0x50,
 24 |   0x72, 0x6f, 0x66, 0x69, 0x6c, 0x65, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 25 |   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 26 |   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 27 |   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 28 |   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 29 |   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 30 |   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 31 |   0x00, 0x00, 0x00, 0x00, 0x6d, 0x6c, 0x75, 0x63, 0x00, 0x00, 0x00, 0x00,
 32 |   0x00, 0x00, 0x00, 0x1e, 0x00, 0x00, 0x00, 0x0c, 0x73, 0x6b, 0x53, 0x4b,
 33 |   0x00, 0x00, 0x00, 0x2e, 0x00, 0x00, 0x01, 0x78, 0x68, 0x72, 0x48, 0x52,
 34 |   0x00, 0x00, 0x00, 0x3e, 0x00, 0x00, 0x01, 0xa6, 0x63, 0x61, 0x45, 0x53,
 35 |   0x00, 0x00, 0x00, 0xac, 0x00, 0x00, 0x01, 0xe4, 0x70, 0x74, 0x42, 0x52,
 36 |   0x00, 0x00, 0x00, 0x4a, 0x00, 0x00, 0x02, 0x90, 0x75, 0x6b, 0x55, 0x41,
 37 |   0x00, 0x00, 0x00, 0x2c, 0x00, 0x00, 0x02, 0xda, 0x66, 0x72, 0x46, 0x55,
 38 |   0x00, 0x00, 0x00, 0x3e, 0x00, 0x00, 0x03, 0x06, 0x7a, 0x68, 0x54, 0x57,
 39 |   0x00, 0x00, 0x00, 0x1e, 0x00, 0x00, 0x03, 0x44, 0x69, 0x74, 0x49, 0x54,
 40 |   0x00, 0x00, 0x00, 0x4e, 0x00, 0x00, 0x03, 0x62, 0x6e, 0x62, 0x4e, 0x4f,
 41 |   0x00, 0x00, 0x00, 0x3a, 0x00, 0x00, 0x03, 0xb0, 0x6b, 0x6f, 0x4b, 0x52,
 42 |   0x00, 0x00, 0x00, 0x22, 0x00, 0x00, 0x03, 0xea, 0x63, 0x73, 0x43, 0x5a,
 43 |   0x00, 0x00, 0x00, 0x28, 0x00, 0x00, 0x04, 0x0c, 0x68, 0x65, 0x49, 0x4c,
 44 |   0x00, 0x00, 0x00, 0x24, 0x00, 0x00, 0x04, 0x34, 0x64, 0x65, 0x44, 0x45,
 45 |   0x00, 0x00, 0x00, 0x4e, 0x00, 0x00, 0x04, 0x58, 0x68, 0x75, 0x48, 0x55,
 46 |   0x00, 0x00, 0x00, 0x34, 0x00, 0x00, 0x04, 0xa6, 0x73, 0x76, 0x53, 0x45,
 47 |   0x00, 0x00, 0x00, 0x38, 0x00, 0x00, 0x04, 0xda, 0x7a, 0x68, 0x43, 0x4e,
 48 |   0x00, 0x00, 0x00, 0x1e, 0x00, 0x00, 0x05, 0x12, 0x6a, 0x61, 0x4a, 0x50,
 49 |   0x00, 0x00, 0x00, 0x26, 0x00, 0x00, 0x05, 0x30, 0x72, 0x6f, 0x52, 0x4f,
 50 |   0x00, 0x00, 0x00, 0x2a, 0x00, 0x00, 0x05, 0x56, 0x65, 0x6c, 0x47, 0x52,
 51 |   0x00, 0x00, 0x00, 0x2a, 0x00, 0x00, 0x05, 0x80, 0x70, 0x74, 0x50, 0x4f,
 52 |   0x00, 0x00, 0x00, 0x52, 0x00, 0x00, 0x05, 0xaa, 0x6e, 0x6c, 0x4e, 0x4c,
 53 |   0x00, 0x00, 0x00, 0x40, 0x00, 0x00, 0x05, 0xfc, 0x65, 0x73, 0x45, 0x53,
 54 |   0x00, 0x00, 0x00, 0x4c, 0x00, 0x00, 0x06, 0x3c, 0x74, 0x68, 0x54, 0x48,
 55 |   0x00, 0x00, 0x00, 0x32, 0x00, 0x00, 0x06, 0x88, 0x74, 0x72, 0x54, 0x52,
 56 |   0x00, 0x00, 0x00, 0x24, 0x00, 0x00, 0x06, 0xba, 0x66, 0x69, 0x46, 0x49,
 57 |   0x00, 0x00, 0x00, 0x46, 0x00, 0x00, 0x06, 0xde, 0x70, 0x6c, 0x50, 0x4c,
 58 |   0x00, 0x00, 0x00, 0x4a, 0x00, 0x00, 0x07, 0x24, 0x72, 0x75, 0x52, 0x55,
 59 |   0x00, 0x00, 0x00, 0x3a, 0x00, 0x00, 0x07, 0x6e, 0x61, 0x72, 0x45, 0x47,
 60 |   0x00, 0x00, 0x00, 0x2c, 0x00, 0x00, 0x07, 0xa8, 0x65, 0x6e, 0x55, 0x53,
 61 |   0x00, 0x00, 0x00, 0x3c, 0x00, 0x00, 0x07, 0xd4, 0x64, 0x61, 0x44, 0x4b,
 62 |   0x00, 0x00, 0x00, 0x38, 0x00, 0x00, 0x04, 0xda, 0x00, 0x56, 0x01, 0x61,
 63 |   0x00, 0x65, 0x00, 0x6f, 0x00, 0x62, 0x00, 0x65, 0x00, 0x63, 0x00, 0x6e,
 64 |   0x00, 0xe1, 0x00, 0x20, 0x00, 0x73, 0x00, 0x69, 0x00, 0x76, 0x00, 0xe1,
 65 |   0x00, 0x20, 0x00, 0x67, 0x00, 0x61, 0x00, 0x6d, 0x00, 0x61, 0x00, 0x20,
 66 |   0x00, 0x32, 0x00, 0x2c, 0x00, 0x32, 0x00, 0x47, 0x00, 0x65, 0x00, 0x6e,
 67 |   0x00, 0x65, 0x00, 0x72, 0x00, 0x69, 0x01, 0x0d, 0x00, 0x6b, 0x00, 0x69,
 68 |   0x00, 0x20, 0x00, 0x47, 0x00, 0x72, 0x00, 0x61, 0x00, 0x79, 0x00, 0x20,
 69 |   0x00, 0x47, 0x00, 0x61, 0x00, 0x6d, 0x00, 0x6d, 0x00, 0x61, 0x00, 0x20,
 70 |   0x00, 0x32, 0x00, 0x2e, 0x00, 0x32, 0x00, 0x20, 0x00, 0x70, 0x00, 0x72,
 71 |   0x00, 0x6f, 0x00, 0x66, 0x00, 0x69, 0x00, 0x6c, 0x00, 0x47, 0x00, 0x61,
 72 |   0x00, 0x6d, 0x00, 0x6d, 0x00, 0x61, 0x00, 0x20, 0x00, 0x64, 0x00, 0x65,
 73 |   0x00, 0x20, 0x00, 0x67, 0x00, 0x72, 0x00, 0x69, 0x00, 0x73, 0x00, 0x6f,
 74 |   0x00, 0x73, 0x00, 0x20, 0x00, 0x67, 0x00, 0x65, 0x00, 0x6e, 0x00, 0xe8,
 75 |   0x00, 0x72, 0x00, 0x69, 0x00, 0x63, 0x00, 0x61, 0x00, 0x20, 0x00, 0x32,
 76 |   0x00, 0x2e, 0x00, 0x32, 0x00, 0x0a, 0x00, 0x47, 0x00, 0x61, 0x00, 0x6d,
 77 |   0x00, 0x6d, 0x00, 0x61, 0x00, 0x20, 0x00, 0x64, 0x00, 0x65, 0x00, 0x20,
 78 |   0x00, 0x67, 0x00, 0x72, 0x00, 0x69, 0x00, 0x73, 0x00, 0x6f, 0x00, 0x73,
 79 |   0x00, 0x20, 0x00, 0x67, 0x00, 0x65, 0x00, 0x6e, 0x00, 0xe8, 0x00, 0x72,
 80 |   0x00, 0x69, 0x00, 0x63, 0x00, 0x61, 0x00, 0x20, 0x00, 0x32, 0x00, 0x2e,
 81 |   0x00, 0x32, 0x00, 0x0a, 0x00, 0x47, 0x00, 0x61, 0x00, 0x6d, 0x00, 0x6d,
 82 |   0x00, 0x61, 0x00, 0x20, 0x00, 0x64, 0x00, 0x65, 0x00, 0x20, 0x00, 0x67,
 83 |   0x00, 0x72, 0x00, 0x69, 0x00, 0x73, 0x00, 0x6f, 0x00, 0x73, 0x00, 0x20,
 84 |   0x00, 0x67, 0x00, 0x65, 0x00, 0x6e, 0x00, 0xe8, 0x00, 0x72, 0x00, 0x69,
 85 |   0x00, 0x63, 0x00, 0x61, 0x00, 0x20, 0x00, 0x32, 0x00, 0x2e, 0x00, 0x32,
 86 |   0x00, 0x50, 0x00, 0x65, 0x00, 0x72, 0x00, 0x66, 0x00, 0x69, 0x00, 0x6c,
 87 |   0x00, 0x20, 0x00, 0x47, 0x00, 0x65, 0x00, 0x6e, 0x00, 0xe9, 0x00, 0x72,
 88 |   0x00, 0x69, 0x00, 0x63, 0x00, 0x6f, 0x00, 0x20, 0x00, 0x64, 0x00, 0x61,
 89 |   0x00, 0x20, 0x00, 0x47, 0x00, 0x61, 0x00, 0x6d, 0x00, 0x61, 0x00, 0x20,
 90 |   0x00, 0x64, 0x00, 0x65, 0x00, 0x20, 0x00, 0x43, 0x00, 0x69, 0x00, 0x6e,
 91 |   0x00, 0x7a, 0x00, 0x61, 0x00, 0x73, 0x00, 0x20, 0x00, 0x32, 0x00, 0x2c,
 92 |   0x00, 0x32, 0x04, 0x17, 0x04, 0x30, 0x04, 0x33, 0x04, 0x30, 0x04, 0x3b,
 93 |   0x04, 0x4c, 0x04, 0x3d, 0x04, 0x30, 0x00, 0x20, 0x00, 0x47, 0x00, 0x72,
 94 |   0x00, 0x61, 0x00, 0x79, 0x00, 0x2d, 0x04, 0x33, 0x04, 0x30, 0x04, 0x3c,
 95 |   0x04, 0x30, 0x00, 0x20, 0x00, 0x32, 0x00, 0x2e, 0x00, 0x32, 0x00, 0x50,
 96 |   0x00, 0x72, 0x00, 0x6f, 0x00, 0x66, 0x00, 0x69, 0x00, 0x6c, 0x00, 0x20,
 97 |   0x00, 0x67, 0x00, 0xe9, 0x00, 0x6e, 0x00, 0xe9, 0x00, 0x72, 0x00, 0x69,
 98 |   0x00, 0x71, 0x00, 0x75, 0x00, 0x65, 0x00, 0x20, 0x00, 0x67, 0x00, 0x72,
 99 |   0x00, 0x69, 0x00, 0x73, 0x00, 0x20, 0x00, 0x67, 0x00, 0x61, 0x00, 0x6d,
100 |   0x00, 0x6d, 0x00, 0x61, 0x00, 0x20, 0x00, 0x32, 0x00, 0x2c, 0x00, 0x32,
101 |   0x90, 0x1a, 0x75, 0x28, 0x70, 0x70, 0x96, 0x8e, 0x51, 0x49, 0x5e, 0xa6,
102 |   0x00, 0x20, 0x00, 0x32, 0x00, 0x2e, 0x00, 0x32, 0x00, 0x20, 0x82, 0x72,
103 |   0x5f, 0x69, 0x63, 0xcf, 0x8f, 0xf0, 0x00, 0x50, 0x00, 0x72, 0x00, 0x6f,
104 |   0x00, 0x66, 0x00, 0x69, 0x00, 0x6c, 0x00, 0x6f, 0x00, 0x20, 0x00, 0x67,
105 |   0x00, 0x72, 0x00, 0x69, 0x00, 0x67, 0x00, 0x69, 0x00, 0x6f, 0x00, 0x20,
106 |   0x00, 0x67, 0x00, 0x65, 0x00, 0x6e, 0x00, 0x65, 0x00, 0x72, 0x00, 0x69,
107 |   0x00, 0x63, 0x00, 0x6f, 0x00, 0x20, 0x00, 0x64, 0x00, 0x65, 0x00, 0x6c,
108 |   0x00, 0x6c, 0x00, 0x61, 0x00, 0x20, 0x00, 0x67, 0x00, 0x61, 0x00, 0x6d,
109 |   0x00, 0x6d, 0x00, 0x61, 0x00, 0x20, 0x00, 0x32, 0x00, 0x2c, 0x00, 0x32,
110 |   0x00, 0x47, 0x00, 0x65, 0x00, 0x6e, 0x00, 0x65, 0x00, 0x72, 0x00, 0x69,
111 |   0x00, 0x73, 0x00, 0x6b, 0x00, 0x20, 0x00, 0x67, 0x00, 0x72, 0x00, 0xe5,
112 |   0x00, 0x20, 0x00, 0x67, 0x00, 0x61, 0x00, 0x6d, 0x00, 0x6d, 0x00, 0x61,
113 |   0x00, 0x20, 0x00, 0x32, 0x00, 0x2c, 0x00, 0x32, 0x00, 0x2d, 0x00, 0x70,
114 |   0x00, 0x72, 0x00, 0x6f, 0x00, 0x66, 0x00, 0x69, 0x00, 0x6c, 0xc7, 0x7c,
115 |   0xbc, 0x18, 0x00, 0x20, 0xd6, 0x8c, 0xc0, 0xc9, 0x00, 0x20, 0xac, 0x10,
116 |   0xb9, 0xc8, 0x00, 0x20, 0x00, 0x32, 0x00, 0x2e, 0x00, 0x32, 0x00, 0x20,
117 |   0xd5, 0x04, 0xb8, 0x5c, 0xd3, 0x0c, 0xc7, 0x7c, 0x00, 0x4f, 0x00, 0x62,
118 |   0x00, 0x65, 0x00, 0x63, 0x00, 0x6e, 0x00, 0xe1, 0x00, 0x20, 0x01, 0x61,
119 |   0x00, 0x65, 0x00, 0x64, 0x00, 0xe1, 0x00, 0x20, 0x00, 0x67, 0x00, 0x61,
120 |   0x00, 0x6d, 0x00, 0x61, 0x00, 0x20, 0x00, 0x32, 0x00, 0x2e, 0x00, 0x32,
121 |   0x05, 0xd2, 0x05, 0xd0, 0x05, 0xde, 0x05, 0xd4, 0x00, 0x20, 0x05, 0xd0,
122 |   0x05, 0xe4, 0x05, 0xd5, 0x05, 0xe8, 0x00, 0x20, 0x05, 0xdb, 0x05, 0xdc,
123 |   0x05, 0xdc, 0x05, 0xd9, 0x00, 0x20, 0x00, 0x32, 0x00, 0x2e, 0x00, 0x32,
124 |   0x00, 0x41, 0x00, 0x6c, 0x00, 0x6c, 0x00, 0x67, 0x00, 0x65, 0x00, 0x6d,
125 |   0x00, 0x65, 0x00, 0x69, 0x00, 0x6e, 0x00, 0x65, 0x00, 0x73, 0x00, 0x20,
126 |   0x00, 0x47, 0x00, 0x72, 0x00, 0x61, 0x00, 0x75, 0x00, 0x73, 0x00, 0x74,
127 |   0x00, 0x75, 0x00, 0x66, 0x00, 0x65, 0x00, 0x6e, 0x00, 0x2d, 0x00, 0x50,
128 |   0x00, 0x72, 0x00, 0x6f, 0x00, 0x66, 0x00, 0x69, 0x00, 0x6c, 0x00, 0x20,
129 |   0x00, 0x47, 0x00, 0x61, 0x00, 0x6d, 0x00, 0x6d, 0x00, 0x61, 0x00, 0x20,
130 |   0x00, 0x32, 0x00, 0x2c, 0x00, 0x32, 0x00, 0xc1, 0x00, 0x6c, 0x00, 0x74,
131 |   0x00, 0x61, 0x00, 0x6c, 0x00, 0xe1, 0x00, 0x6e, 0x00, 0x6f, 0x00, 0x73,
132 |   0x00, 0x20, 0x00, 0x73, 0x00, 0x7a, 0x00, 0xfc, 0x00, 0x72, 0x00, 0x6b,
133 |   0x00, 0x65, 0x00, 0x20, 0x00, 0x67, 0x00, 0x61, 0x00, 0x6d, 0x00, 0x6d,
134 |   0x00, 0x61, 0x00, 0x20, 0x00, 0x32, 0x00, 0x2e, 0x00, 0x32, 0x00, 0x47,
135 |   0x00, 0x65, 0x00, 0x6e, 0x00, 0x65, 0x00, 0x72, 0x00, 0x69, 0x00, 0x73,
136 |   0x00, 0x6b, 0x00, 0x20, 0x00, 0x67, 0x00, 0x72, 0x00, 0xe5, 0x00, 0x20,
137 |   0x00, 0x32, 0x00, 0x2c, 0x00, 0x32, 0x00, 0x20, 0x00, 0x67, 0x00, 0x61,
138 |   0x00, 0x6d, 0x00, 0x6d, 0x00, 0x61, 0x00, 0x70, 0x00, 0x72, 0x00, 0x6f,
139 |   0x00, 0x66, 0x00, 0x69, 0x00, 0x6c, 0x90, 0x1a, 0x75, 0x28, 0x70, 0x70,
140 |   0x5e, 0xa6, 0x7c, 0xfb, 0x65, 0x70, 0x00, 0x20, 0x00, 0x32, 0x00, 0x2e,
141 |   0x00, 0x32, 0x00, 0x20, 0x63, 0xcf, 0x8f, 0xf0, 0x65, 0x87, 0x4e, 0xf6,
142 |   0x4e, 0x00, 0x82, 0x2c, 0x30, 0xb0, 0x30, 0xec, 0x30, 0xa4, 0x30, 0xac,
143 |   0x30, 0xf3, 0x30, 0xde, 0x00, 0x20, 0x00, 0x32, 0x00, 0x2e, 0x00, 0x32,
144 |   0x00, 0x20, 0x30, 0xd7, 0x30, 0xed, 0x30, 0xd5, 0x30, 0xa1, 0x30, 0xa4,
145 |   0x30, 0xeb, 0x00, 0x47, 0x00, 0x61, 0x00, 0x6d, 0x00, 0x61, 0x00, 0x20,
146 |   0x00, 0x67, 0x00, 0x72, 0x00, 0x69, 0x00, 0x20, 0x00, 0x67, 0x00, 0x65,
147 |   0x00, 0x6e, 0x00, 0x65, 0x00, 0x72, 0x00, 0x69, 0x00, 0x63, 0x01, 0x03,
148 |   0x00, 0x20, 0x00, 0x32, 0x00, 0x2c, 0x00, 0x32, 0x03, 0x93, 0x03, 0xb5,
149 |   0x03, 0xbd, 0x03, 0xb9, 0x03, 0xba, 0x03, 0xcc, 0x00, 0x20, 0x03, 0x93,
150 |   0x03, 0xba, 0x03, 0xc1, 0x03, 0xb9, 0x00, 0x20, 0x03, 0x93, 0x03, 0xac,
151 |   0x03, 0xbc, 0x03, 0xbc, 0x03, 0xb1, 0x00, 0x20, 0x00, 0x32, 0x00, 0x2e,
152 |   0x00, 0x32, 0x00, 0x50, 0x00, 0x65, 0x00, 0x72, 0x00, 0x66, 0x00, 0x69,
153 |   0x00, 0x6c, 0x00, 0x20, 0x00, 0x67, 0x00, 0x65, 0x00, 0x6e, 0x00, 0xe9,
154 |   0x00, 0x72, 0x00, 0x69, 0x00, 0x63, 0x00, 0x6f, 0x00, 0x20, 0x00, 0x64,
155 |   0x00, 0x65, 0x00, 0x20, 0x00, 0x63, 0x00, 0x69, 0x00, 0x6e, 0x00, 0x7a,
156 |   0x00, 0x65, 0x00, 0x6e, 0x00, 0x74, 0x00, 0x6f, 0x00, 0x73, 0x00, 0x20,
157 |   0x00, 0x64, 0x00, 0x61, 0x00, 0x20, 0x00, 0x47, 0x00, 0x61, 0x00, 0x6d,
158 |   0x00, 0x6d, 0x00, 0x61, 0x00, 0x20, 0x00, 0x32, 0x00, 0x2c, 0x00, 0x32,
159 |   0x00, 0x41, 0x00, 0x6c, 0x00, 0x67, 0x00, 0x65, 0x00, 0x6d, 0x00, 0x65,
160 |   0x00, 0x65, 0x00, 0x6e, 0x00, 0x20, 0x00, 0x67, 0x00, 0x72, 0x00, 0x69,
161 |   0x00, 0x6a, 0x00, 0x73, 0x00, 0x20, 0x00, 0x67, 0x00, 0x61, 0x00, 0x6d,
162 |   0x00, 0x6d, 0x00, 0x61, 0x00, 0x20, 0x00, 0x32, 0x00, 0x2c, 0x00, 0x32,
163 |   0x00, 0x2d, 0x00, 0x70, 0x00, 0x72, 0x00, 0x6f, 0x00, 0x66, 0x00, 0x69,
164 |   0x00, 0x65, 0x00, 0x6c, 0x00, 0x50, 0x00, 0x65, 0x00, 0x72, 0x00, 0x66,
165 |   0x00, 0x69, 0x00, 0x6c, 0x00, 0x20, 0x00, 0x67, 0x00, 0x65, 0x00, 0x6e,
166 |   0x00, 0xe9, 0x00, 0x72, 0x00, 0x69, 0x00, 0x63, 0x00, 0x6f, 0x00, 0x20,
167 |   0x00, 0x64, 0x00, 0x65, 0x00, 0x20, 0x00, 0x67, 0x00, 0x61, 0x00, 0x6d,
168 |   0x00, 0x6d, 0x00, 0x61, 0x00, 0x20, 0x00, 0x64, 0x00, 0x65, 0x00, 0x20,
169 |   0x00, 0x67, 0x00, 0x72, 0x00, 0x69, 0x00, 0x73, 0x00, 0x65, 0x00, 0x73,
170 |   0x00, 0x20, 0x00, 0x32, 0x00, 0x2c, 0x00, 0x32, 0x0e, 0x23, 0x0e, 0x31,
171 |   0x0e, 0x07, 0x0e, 0x2a, 0x0e, 0x35, 0x0e, 0x41, 0x0e, 0x01, 0x0e, 0x21,
172 |   0x0e, 0x21, 0x0e, 0x32, 0x0e, 0x40, 0x0e, 0x01, 0x0e, 0x23, 0x0e, 0x22,
173 |   0x0e, 0x4c, 0x0e, 0x17, 0x0e, 0x31, 0x0e, 0x48, 0x0e, 0x27, 0x0e, 0x44,
174 |   0x0e, 0x1b, 0x00, 0x20, 0x00, 0x32, 0x00, 0x2e, 0x00, 0x32, 0x00, 0x47,
175 |   0x00, 0x65, 0x00, 0x6e, 0x00, 0x65, 0x00, 0x6c, 0x00, 0x20, 0x00, 0x47,
176 |   0x00, 0x72, 0x00, 0x69, 0x00, 0x20, 0x00, 0x47, 0x00, 0x61, 0x00, 0x6d,
177 |   0x00, 0x61, 0x00, 0x20, 0x00, 0x32, 0x00, 0x2c, 0x00, 0x32, 0x00, 0x59,
178 |   0x00, 0x6c, 0x00, 0x65, 0x00, 0x69, 0x00, 0x6e, 0x00, 0x65, 0x00, 0x6e,
179 |   0x00, 0x20, 0x00, 0x68, 0x00, 0x61, 0x00, 0x72, 0x00, 0x6d, 0x00, 0x61,
180 |   0x00, 0x61, 0x00, 0x6e, 0x00, 0x20, 0x00, 0x67, 0x00, 0x61, 0x00, 0x6d,
181 |   0x00, 0x6d, 0x00, 0x61, 0x00, 0x20, 0x00, 0x32, 0x00, 0x2c, 0x00, 0x32,
182 |   0x00, 0x20, 0x00, 0x2d, 0x00, 0x70, 0x00, 0x72, 0x00, 0x6f, 0x00, 0x66,
183 |   0x00, 0x69, 0x00, 0x69, 0x00, 0x6c, 0x00, 0x69, 0x00, 0x55, 0x00, 0x6e,
184 |   0x00, 0x69, 0x00, 0x77, 0x00, 0x65, 0x00, 0x72, 0x00, 0x73, 0x00, 0x61,
185 |   0x00, 0x6c, 0x00, 0x6e, 0x00, 0x79, 0x00, 0x20, 0x00, 0x70, 0x00, 0x72,
186 |   0x00, 0x6f, 0x00, 0x66, 0x00, 0x69, 0x00, 0x6c, 0x00, 0x20, 0x00, 0x73,
187 |   0x00, 0x7a, 0x00, 0x61, 0x00, 0x72, 0x00, 0x6f, 0x01, 0x5b, 0x00, 0x63,
188 |   0x00, 0x69, 0x00, 0x20, 0x00, 0x67, 0x00, 0x61, 0x00, 0x6d, 0x00, 0x6d,
189 |   0x00, 0x61, 0x00, 0x20, 0x00, 0x32, 0x00, 0x2c, 0x00, 0x32, 0x04, 0x1e,
190 |   0x04, 0x31, 0x04, 0x49, 0x04, 0x30, 0x04, 0x4f, 0x00, 0x20, 0x04, 0x41,
191 |   0x04, 0x35, 0x04, 0x40, 0x04, 0x30, 0x04, 0x4f, 0x00, 0x20, 0x04, 0x33,
192 |   0x04, 0x30, 0x04, 0x3c, 0x04, 0x3c, 0x04, 0x30, 0x00, 0x20, 0x00, 0x32,
193 |   0x00, 0x2c, 0x00, 0x32, 0x00, 0x2d, 0x04, 0x3f, 0x04, 0x40, 0x04, 0x3e,
194 |   0x04, 0x44, 0x04, 0x38, 0x04, 0x3b, 0x04, 0x4c, 0x06, 0x3a, 0x06, 0x27,
195 |   0x06, 0x45, 0x06, 0x27, 0x00, 0x20, 0x00, 0x32, 0x00, 0x2e, 0x00, 0x32,
196 |   0x00, 0x20, 0x06, 0x44, 0x06, 0x48, 0x06, 0x46, 0x00, 0x20, 0x06, 0x31,
197 |   0x06, 0x45, 0x06, 0x27, 0x06, 0x2f, 0x06, 0x4a, 0x00, 0x20, 0x06, 0x39,
198 |   0x06, 0x27, 0x06, 0x45, 0x00, 0x47, 0x00, 0x65, 0x00, 0x6e, 0x00, 0x65,
199 |   0x00, 0x72, 0x00, 0x69, 0x00, 0x63, 0x00, 0x20, 0x00, 0x47, 0x00, 0x72,
200 |   0x00, 0x61, 0x00, 0x79, 0x00, 0x20, 0x00, 0x47, 0x00, 0x61, 0x00, 0x6d,
201 |   0x00, 0x6d, 0x00, 0x61, 0x00, 0x20, 0x00, 0x32, 0x00, 0x2e, 0x00, 0x32,
202 |   0x00, 0x20, 0x00, 0x50, 0x00, 0x72, 0x00, 0x6f, 0x00, 0x66, 0x00, 0x69,
203 |   0x00, 0x6c, 0x00, 0x65, 0x74, 0x65, 0x78, 0x74, 0x00, 0x00, 0x00, 0x00,
204 |   0x43, 0x6f, 0x70, 0x79, 0x72, 0x69, 0x67, 0x68, 0x74, 0x20, 0x41, 0x70,
205 |   0x70, 0x6c, 0x65, 0x20, 0x49, 0x6e, 0x63, 0x2e, 0x2c, 0x20, 0x32, 0x30,
206 |   0x30, 0x38, 0x00, 0x00, 0x58, 0x59, 0x5a, 0x20, 0x00, 0x00, 0x00, 0x00,
207 |   0x00, 0x00, 0xf3, 0x51, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x16, 0xcc,
208 |   0x63, 0x75, 0x72, 0x76, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x04, 0x00,
209 |   0x00, 0x00, 0x00, 0x05, 0x00, 0x0a, 0x00, 0x0f, 0x00, 0x14, 0x00, 0x19,
210 |   0x00, 0x1e, 0x00, 0x23, 0x00, 0x28, 0x00, 0x2d, 0x00, 0x32, 0x00, 0x37,
211 |   0x00, 0x3b, 0x00, 0x40, 0x00, 0x45, 0x00, 0x4a, 0x00, 0x4f, 0x00, 0x54,
212 |   0x00, 0x59, 0x00, 0x5e, 0x00, 0x63, 0x00, 0x68, 0x00, 0x6d, 0x00, 0x72,
213 |   0x00, 0x77, 0x00, 0x7c, 0x00, 0x81, 0x00, 0x86, 0x00, 0x8b, 0x00, 0x90,
214 |   0x00, 0x95, 0x00, 0x9a, 0x00, 0x9f, 0x00, 0xa4, 0x00, 0xa9, 0x00, 0xae,
215 |   0x00, 0xb2, 0x00, 0xb7, 0x00, 0xbc, 0x00, 0xc1, 0x00, 0xc6, 0x00, 0xcb,
216 |   0x00, 0xd0, 0x00, 0xd5, 0x00, 0xdb, 0x00, 0xe0, 0x00, 0xe5, 0x00, 0xeb,
217 |   0x00, 0xf0, 0x00, 0xf6, 0x00, 0xfb, 0x01, 0x01, 0x01, 0x07, 0x01, 0x0d,
218 |   0x01, 0x13, 0x01, 0x19, 0x01, 0x1f, 0x01, 0x25, 0x01, 0x2b, 0x01, 0x32,
219 |   0x01, 0x38, 0x01, 0x3e, 0x01, 0x45, 0x01, 0x4c, 0x01, 0x52, 0x01, 0x59,
220 |   0x01, 0x60, 0x01, 0x67, 0x01, 0x6e, 0x01, 0x75, 0x01, 0x7c, 0x01, 0x83,
221 |   0x01, 0x8b, 0x01, 0x92, 0x01, 0x9a, 0x01, 0xa1, 0x01, 0xa9, 0x01, 0xb1,
222 |   0x01, 0xb9, 0x01, 0xc1, 0x01, 0xc9, 0x01, 0xd1, 0x01, 0xd9, 0x01, 0xe1,
223 |   0x01, 0xe9, 0x01, 0xf2, 0x01, 0xfa, 0x02, 0x03, 0x02, 0x0c, 0x02, 0x14,
224 |   0x02, 0x1d, 0x02, 0x26, 0x02, 0x2f, 0x02, 0x38, 0x02, 0x41, 0x02, 0x4b,
225 |   0x02, 0x54, 0x02, 0x5d, 0x02, 0x67, 0x02, 0x71, 0x02, 0x7a, 0x02, 0x84,
226 |   0x02, 0x8e, 0x02, 0x98, 0x02, 0xa2, 0x02, 0xac, 0x02, 0xb6, 0x02, 0xc1,
227 |   0x02, 0xcb, 0x02, 0xd5, 0x02, 0xe0, 0x02, 0xeb, 0x02, 0xf5, 0x03, 0x00,
228 |   0x03, 0x0b, 0x03, 0x16, 0x03, 0x21, 0x03, 0x2d, 0x03, 0x38, 0x03, 0x43,
229 |   0x03, 0x4f, 0x03, 0x5a, 0x03, 0x66, 0x03, 0x72, 0x03, 0x7e, 0x03, 0x8a,
230 |   0x03, 0x96, 0x03, 0xa2, 0x03, 0xae, 0x03, 0xba, 0x03, 0xc7, 0x03, 0xd3,
231 |   0x03, 0xe0, 0x03, 0xec, 0x03, 0xf9, 0x04, 0x06, 0x04, 0x13, 0x04, 0x20,
232 |   0x04, 0x2d, 0x04, 0x3b, 0x04, 0x48, 0x04, 0x55, 0x04, 0x63, 0x04, 0x71,
233 |   0x04, 0x7e, 0x04, 0x8c, 0x04, 0x9a, 0x04, 0xa8, 0x04, 0xb6, 0x04, 0xc4,
234 |   0x04, 0xd3, 0x04, 0xe1, 0x04, 0xf0, 0x04, 0xfe, 0x05, 0x0d, 0x05, 0x1c,
235 |   0x05, 0x2b, 0x05, 0x3a, 0x05, 0x49, 0x05, 0x58, 0x05, 0x67, 0x05, 0x77,
236 |   0x05, 0x86, 0x05, 0x96, 0x05, 0xa6, 0x05, 0xb5, 0x05, 0xc5, 0x05, 0xd5,
237 |   0x05, 0xe5, 0x05, 0xf6, 0x06, 0x06, 0x06, 0x16, 0x06, 0x27, 0x06, 0x37,
238 |   0x06, 0x48, 0x06, 0x59, 0x06, 0x6a, 0x06, 0x7b, 0x06, 0x8c, 0x06, 0x9d,
239 |   0x06, 0xaf, 0x06, 0xc0, 0x06, 0xd1, 0x06, 0xe3, 0x06, 0xf5, 0x07, 0x07,
240 |   0x07, 0x19, 0x07, 0x2b, 0x07, 0x3d, 0x07, 0x4f, 0x07, 0x61, 0x07, 0x74,
241 |   0x07, 0x86, 0x07, 0x99, 0x07, 0xac, 0x07, 0xbf, 0x07, 0xd2, 0x07, 0xe5,
242 |   0x07, 0xf8, 0x08, 0x0b, 0x08, 0x1f, 0x08, 0x32, 0x08, 0x46, 0x08, 0x5a,
243 |   0x08, 0x6e, 0x08, 0x82, 0x08, 0x96, 0x08, 0xaa, 0x08, 0xbe, 0x08, 0xd2,
244 |   0x08, 0xe7, 0x08, 0xfb, 0x09, 0x10, 0x09, 0x25, 0x09, 0x3a, 0x09, 0x4f,
245 |   0x09, 0x64, 0x09, 0x79, 0x09, 0x8f, 0x09, 0xa4, 0x09, 0xba, 0x09, 0xcf,
246 |   0x09, 0xe5, 0x09, 0xfb, 0x0a, 0x11, 0x0a, 0x27, 0x0a, 0x3d, 0x0a, 0x54,
247 |   0x0a, 0x6a, 0x0a, 0x81, 0x0a, 0x98, 0x0a, 0xae, 0x0a, 0xc5, 0x0a, 0xdc,
248 |   0x0a, 0xf3, 0x0b, 0x0b, 0x0b, 0x22, 0x0b, 0x39, 0x0b, 0x51, 0x0b, 0x69,
249 |   0x0b, 0x80, 0x0b, 0x98, 0x0b, 0xb0, 0x0b, 0xc8, 0x0b, 0xe1, 0x0b, 0xf9,
250 |   0x0c, 0x12, 0x0c, 0x2a, 0x0c, 0x43, 0x0c, 0x5c, 0x0c, 0x75, 0x0c, 0x8e,
251 |   0x0c, 0xa7, 0x0c, 0xc0, 0x0c, 0xd9, 0x0c, 0xf3, 0x0d, 0x0d, 0x0d, 0x26,
252 |   0x0d, 0x40, 0x0d, 0x5a, 0x0d, 0x74, 0x0d, 0x8e, 0x0d, 0xa9, 0x0d, 0xc3,
253 |   0x0d, 0xde, 0x0d, 0xf8, 0x0e, 0x13, 0x0e, 0x2e, 0x0e, 0x49, 0x0e, 0x64,
254 |   0x0e, 0x7f, 0x0e, 0x9b, 0x0e, 0xb6, 0x0e, 0xd2, 0x0e, 0xee, 0x0f, 0x09,
255 |   0x0f, 0x25, 0x0f, 0x41, 0x0f, 0x5e, 0x0f, 0x7a, 0x0f, 0x96, 0x0f, 0xb3,
256 |   0x0f, 0xcf, 0x0f, 0xec, 0x10, 0x09, 0x10, 0x26, 0x10, 0x43, 0x10, 0x61,
257 |   0x10, 0x7e, 0x10, 0x9b, 0x10, 0xb9, 0x10, 0xd7, 0x10, 0xf5, 0x11, 0x13,
258 |   0x11, 0x31, 0x11, 0x4f, 0x11, 0x6d, 0x11, 0x8c, 0x11, 0xaa, 0x11, 0xc9,
259 |   0x11, 0xe8, 0x12, 0x07, 0x12, 0x26, 0x12, 0x45, 0x12, 0x64, 0x12, 0x84,
260 |   0x12, 0xa3, 0x12, 0xc3, 0x12, 0xe3, 0x13, 0x03, 0x13, 0x23, 0x13, 0x43,
261 |   0x13, 0x63, 0x13, 0x83, 0x13, 0xa4, 0x13, 0xc5, 0x13, 0xe5, 0x14, 0x06,
262 |   0x14, 0x27, 0x14, 0x49, 0x14, 0x6a, 0x14, 0x8b, 0x14, 0xad, 0x14, 0xce,
263 |   0x14, 0xf0, 0x15, 0x12, 0x15, 0x34, 0x15, 0x56, 0x15, 0x78, 0x15, 0x9b,
264 |   0x15, 0xbd, 0x15, 0xe0, 0x16, 0x03, 0x16, 0x26, 0x16, 0x49, 0x16, 0x6c,
265 |   0x16, 0x8f, 0x16, 0xb2, 0x16, 0xd6, 0x16, 0xfa, 0x17, 0x1d, 0x17, 0x41,
266 |   0x17, 0x65, 0x17, 0x89, 0x17, 0xae, 0x17, 0xd2, 0x17, 0xf7, 0x18, 0x1b,
267 |   0x18, 0x40, 0x18, 0x65, 0x18, 0x8a, 0x18, 0xaf, 0x18, 0xd5, 0x18, 0xfa,
268 |   0x19, 0x20, 0x19, 0x45, 0x19, 0x6b, 0x19, 0x91, 0x19, 0xb7, 0x19, 0xdd,
269 |   0x1a, 0x04, 0x1a, 0x2a, 0x1a, 0x51, 0x1a, 0x77, 0x1a, 0x9e, 0x1a, 0xc5,
270 |   0x1a, 0xec, 0x1b, 0x14, 0x1b, 0x3b, 0x1b, 0x63, 0x1b, 0x8a, 0x1b, 0xb2,
271 |   0x1b, 0xda, 0x1c, 0x02, 0x1c, 0x2a, 0x1c, 0x52, 0x1c, 0x7b, 0x1c, 0xa3,
272 |   0x1c, 0xcc, 0x1c, 0xf5, 0x1d, 0x1e, 0x1d, 0x47, 0x1d, 0x70, 0x1d, 0x99,
273 |   0x1d, 0xc3, 0x1d, 0xec, 0x1e, 0x16, 0x1e, 0x40, 0x1e, 0x6a, 0x1e, 0x94,
274 |   0x1e, 0xbe, 0x1e, 0xe9, 0x1f, 0x13, 0x1f, 0x3e, 0x1f, 0x69, 0x1f, 0x94,
275 |   0x1f, 0xbf, 0x1f, 0xea, 0x20, 0x15, 0x20, 0x41, 0x20, 0x6c, 0x20, 0x98,
276 |   0x20, 0xc4, 0x20, 0xf0, 0x21, 0x1c, 0x21, 0x48, 0x21, 0x75, 0x21, 0xa1,
277 |   0x21, 0xce, 0x21, 0xfb, 0x22, 0x27, 0x22, 0x55, 0x22, 0x82, 0x22, 0xaf,
278 |   0x22, 0xdd, 0x23, 0x0a, 0x23, 0x38, 0x23, 0x66, 0x23, 0x94, 0x23, 0xc2,
279 |   0x23, 0xf0, 0x24, 0x1f, 0x24, 0x4d, 0x24, 0x7c, 0x24, 0xab, 0x24, 0xda,
280 |   0x25, 0x09, 0x25, 0x38, 0x25, 0x68, 0x25, 0x97, 0x25, 0xc7, 0x25, 0xf7,
281 |   0x26, 0x27, 0x26, 0x57, 0x26, 0x87, 0x26, 0xb7, 0x26, 0xe8, 0x27, 0x18,
282 |   0x27, 0x49, 0x27, 0x7a, 0x27, 0xab, 0x27, 0xdc, 0x28, 0x0d, 0x28, 0x3f,
283 |   0x28, 0x71, 0x28, 0xa2, 0x28, 0xd4, 0x29, 0x06, 0x29, 0x38, 0x29, 0x6b,
284 |   0x29, 0x9d, 0x29, 0xd0, 0x2a, 0x02, 0x2a, 0x35, 0x2a, 0x68, 0x2a, 0x9b,
285 |   0x2a, 0xcf, 0x2b, 0x02, 0x2b, 0x36, 0x2b, 0x69, 0x2b, 0x9d, 0x2b, 0xd1,
286 |   0x2c, 0x05, 0x2c, 0x39, 0x2c, 0x6e, 0x2c, 0xa2, 0x2c, 0xd7, 0x2d, 0x0c,
287 |   0x2d, 0x41, 0x2d, 0x76, 0x2d, 0xab, 0x2d, 0xe1, 0x2e, 0x16, 0x2e, 0x4c,
288 |   0x2e, 0x82, 0x2e, 0xb7, 0x2e, 0xee, 0x2f, 0x24, 0x2f, 0x5a, 0x2f, 0x91,
289 |   0x2f, 0xc7, 0x2f, 0xfe, 0x30, 0x35, 0x30, 0x6c, 0x30, 0xa4, 0x30, 0xdb,
290 |   0x31, 0x12, 0x31, 0x4a, 0x31, 0x82, 0x31, 0xba, 0x31, 0xf2, 0x32, 0x2a,
291 |   0x32, 0x63, 0x32, 0x9b, 0x32, 0xd4, 0x33, 0x0d, 0x33, 0x46, 0x33, 0x7f,
292 |   0x33, 0xb8, 0x33, 0xf1, 0x34, 0x2b, 0x34, 0x65, 0x34, 0x9e, 0x34, 0xd8,
293 |   0x35, 0x13, 0x35, 0x4d, 0x35, 0x87, 0x35, 0xc2, 0x35, 0xfd, 0x36, 0x37,
294 |   0x36, 0x72, 0x36, 0xae, 0x36, 0xe9, 0x37, 0x24, 0x37, 0x60, 0x37, 0x9c,
295 |   0x37, 0xd7, 0x38, 0x14, 0x38, 0x50, 0x38, 0x8c, 0x38, 0xc8, 0x39, 0x05,
296 |   0x39, 0x42, 0x39, 0x7f, 0x39, 0xbc, 0x39, 0xf9, 0x3a, 0x36, 0x3a, 0x74,
297 |   0x3a, 0xb2, 0x3a, 0xef, 0x3b, 0x2d, 0x3b, 0x6b, 0x3b, 0xaa, 0x3b, 0xe8,
298 |   0x3c, 0x27, 0x3c, 0x65, 0x3c, 0xa4, 0x3c, 0xe3, 0x3d, 0x22, 0x3d, 0x61,
299 |   0x3d, 0xa1, 0x3d, 0xe0, 0x3e, 0x20, 0x3e, 0x60, 0x3e, 0xa0, 0x3e, 0xe0,
300 |   0x3f, 0x21, 0x3f, 0x61, 0x3f, 0xa2, 0x3f, 0xe2, 0x40, 0x23, 0x40, 0x64,
301 |   0x40, 0xa6, 0x40, 0xe7, 0x41, 0x29, 0x41, 0x6a, 0x41, 0xac, 0x41, 0xee,
302 |   0x42, 0x30, 0x42, 0x72, 0x42, 0xb5, 0x42, 0xf7, 0x43, 0x3a, 0x43, 0x7d,
303 |   0x43, 0xc0, 0x44, 0x03, 0x44, 0x47, 0x44, 0x8a, 0x44, 0xce, 0x45, 0x12,
304 |   0x45, 0x55, 0x45, 0x9a, 0x45, 0xde, 0x46, 0x22, 0x46, 0x67, 0x46, 0xab,
305 |   0x46, 0xf0, 0x47, 0x35, 0x47, 0x7b, 0x47, 0xc0, 0x48, 0x05, 0x48, 0x4b,
306 |   0x48, 0x91, 0x48, 0xd7, 0x49, 0x1d, 0x49, 0x63, 0x49, 0xa9, 0x49, 0xf0,
307 |   0x4a, 0x37, 0x4a, 0x7d, 0x4a, 0xc4, 0x4b, 0x0c, 0x4b, 0x53, 0x4b, 0x9a,
308 |   0x4b, 0xe2, 0x4c, 0x2a, 0x4c, 0x72, 0x4c, 0xba, 0x4d, 0x02, 0x4d, 0x4a,
309 |   0x4d, 0x93, 0x4d, 0xdc, 0x4e, 0x25, 0x4e, 0x6e, 0x4e, 0xb7, 0x4f, 0x00,
310 |   0x4f, 0x49, 0x4f, 0x93, 0x4f, 0xdd, 0x50, 0x27, 0x50, 0x71, 0x50, 0xbb,
311 |   0x51, 0x06, 0x51, 0x50, 0x51, 0x9b, 0x51, 0xe6, 0x52, 0x31, 0x52, 0x7c,
312 |   0x52, 0xc7, 0x53, 0x13, 0x53, 0x5f, 0x53, 0xaa, 0x53, 0xf6, 0x54, 0x42,
313 |   0x54, 0x8f, 0x54, 0xdb, 0x55, 0x28, 0x55, 0x75, 0x55, 0xc2, 0x56, 0x0f,
314 |   0x56, 0x5c, 0x56, 0xa9, 0x56, 0xf7, 0x57, 0x44, 0x57, 0x92, 0x57, 0xe0,
315 |   0x58, 0x2f, 0x58, 0x7d, 0x58, 0xcb, 0x59, 0x1a, 0x59, 0x69, 0x59, 0xb8,
316 |   0x5a, 0x07, 0x5a, 0x56, 0x5a, 0xa6, 0x5a, 0xf5, 0x5b, 0x45, 0x5b, 0x95,
317 |   0x5b, 0xe5, 0x5c, 0x35, 0x5c, 0x86, 0x5c, 0xd6, 0x5d, 0x27, 0x5d, 0x78,
318 |   0x5d, 0xc9, 0x5e, 0x1a, 0x5e, 0x6c, 0x5e, 0xbd, 0x5f, 0x0f, 0x5f, 0x61,
319 |   0x5f, 0xb3, 0x60, 0x05, 0x60, 0x57, 0x60, 0xaa, 0x60, 0xfc, 0x61, 0x4f,
320 |   0x61, 0xa2, 0x61, 0xf5, 0x62, 0x49, 0x62, 0x9c, 0x62, 0xf0, 0x63, 0x43,
321 |   0x63, 0x97, 0x63, 0xeb, 0x64, 0x40, 0x64, 0x94, 0x64, 0xe9, 0x65, 0x3d,
322 |   0x65, 0x92, 0x65, 0xe7, 0x66, 0x3d, 0x66, 0x92, 0x66, 0xe8, 0x67, 0x3d,
323 |   0x67, 0x93, 0x67, 0xe9, 0x68, 0x3f, 0x68, 0x96, 0x68, 0xec, 0x69, 0x43,
324 |   0x69, 0x9a, 0x69, 0xf1, 0x6a, 0x48, 0x6a, 0x9f, 0x6a, 0xf7, 0x6b, 0x4f,
325 |   0x6b, 0xa7, 0x6b, 0xff, 0x6c, 0x57, 0x6c, 0xaf, 0x6d, 0x08, 0x6d, 0x60,
326 |   0x6d, 0xb9, 0x6e, 0x12, 0x6e, 0x6b, 0x6e, 0xc4, 0x6f, 0x1e, 0x6f, 0x78,
327 |   0x6f, 0xd1, 0x70, 0x2b, 0x70, 0x86, 0x70, 0xe0, 0x71, 0x3a, 0x71, 0x95,
328 |   0x71, 0xf0, 0x72, 0x4b, 0x72, 0xa6, 0x73, 0x01, 0x73, 0x5d, 0x73, 0xb8,
329 |   0x74, 0x14, 0x74, 0x70, 0x74, 0xcc, 0x75, 0x28, 0x75, 0x85, 0x75, 0xe1,
330 |   0x76, 0x3e, 0x76, 0x9b, 0x76, 0xf8, 0x77, 0x56, 0x77, 0xb3, 0x78, 0x11,
331 |   0x78, 0x6e, 0x78, 0xcc, 0x79, 0x2a, 0x79, 0x89, 0x79, 0xe7, 0x7a, 0x46,
332 |   0x7a, 0xa5, 0x7b, 0x04, 0x7b, 0x63, 0x7b, 0xc2, 0x7c, 0x21, 0x7c, 0x81,
333 |   0x7c, 0xe1, 0x7d, 0x41, 0x7d, 0xa1, 0x7e, 0x01, 0x7e, 0x62, 0x7e, 0xc2,
334 |   0x7f, 0x23, 0x7f, 0x84, 0x7f, 0xe5, 0x80, 0x47, 0x80, 0xa8, 0x81, 0x0a,
335 |   0x81, 0x6b, 0x81, 0xcd, 0x82, 0x30, 0x82, 0x92, 0x82, 0xf4, 0x83, 0x57,
336 |   0x83, 0xba, 0x84, 0x1d, 0x84, 0x80, 0x84, 0xe3, 0x85, 0x47, 0x85, 0xab,
337 |   0x86, 0x0e, 0x86, 0x72, 0x86, 0xd7, 0x87, 0x3b, 0x87, 0x9f, 0x88, 0x04,
338 |   0x88, 0x69, 0x88, 0xce, 0x89, 0x33, 0x89, 0x99, 0x89, 0xfe, 0x8a, 0x64,
339 |   0x8a, 0xca, 0x8b, 0x30, 0x8b, 0x96, 0x8b, 0xfc, 0x8c, 0x63, 0x8c, 0xca,
340 |   0x8d, 0x31, 0x8d, 0x98, 0x8d, 0xff, 0x8e, 0x66, 0x8e, 0xce, 0x8f, 0x36,
341 |   0x8f, 0x9e, 0x90, 0x06, 0x90, 0x6e, 0x90, 0xd6, 0x91, 0x3f, 0x91, 0xa8,
342 |   0x92, 0x11, 0x92, 0x7a, 0x92, 0xe3, 0x93, 0x4d, 0x93, 0xb6, 0x94, 0x20,
343 |   0x94, 0x8a, 0x94, 0xf4, 0x95, 0x5f, 0x95, 0xc9, 0x96, 0x34, 0x96, 0x9f,
344 |   0x97, 0x0a, 0x97, 0x75, 0x97, 0xe0, 0x98, 0x4c, 0x98, 0xb8, 0x99, 0x24,
345 |   0x99, 0x90, 0x99, 0xfc, 0x9a, 0x68, 0x9a, 0xd5, 0x9b, 0x42, 0x9b, 0xaf,
346 |   0x9c, 0x1c, 0x9c, 0x89, 0x9c, 0xf7, 0x9d, 0x64, 0x9d, 0xd2, 0x9e, 0x40,
347 |   0x9e, 0xae, 0x9f, 0x1d, 0x9f, 0x8b, 0x9f, 0xfa, 0xa0, 0x69, 0xa0, 0xd8,
348 |   0xa1, 0x47, 0xa1, 0xb6, 0xa2, 0x26, 0xa2, 0x96, 0xa3, 0x06, 0xa3, 0x76,
349 |   0xa3, 0xe6, 0xa4, 0x56, 0xa4, 0xc7, 0xa5, 0x38, 0xa5, 0xa9, 0xa6, 0x1a,
350 |   0xa6, 0x8b, 0xa6, 0xfd, 0xa7, 0x6e, 0xa7, 0xe0, 0xa8, 0x52, 0xa8, 0xc4,
351 |   0xa9, 0x37, 0xa9, 0xa9, 0xaa, 0x1c, 0xaa, 0x8f, 0xab, 0x02, 0xab, 0x75,
352 |   0xab, 0xe9, 0xac, 0x5c, 0xac, 0xd0, 0xad, 0x44, 0xad, 0xb8, 0xae, 0x2d,
353 |   0xae, 0xa1, 0xaf, 0x16, 0xaf, 0x8b, 0xb0, 0x00, 0xb0, 0x75, 0xb0, 0xea,
354 |   0xb1, 0x60, 0xb1, 0xd6, 0xb2, 0x4b, 0xb2, 0xc2, 0xb3, 0x38, 0xb3, 0xae,
355 |   0xb4, 0x25, 0xb4, 0x9c, 0xb5, 0x13, 0xb5, 0x8a, 0xb6, 0x01, 0xb6, 0x79,
356 |   0xb6, 0xf0, 0xb7, 0x68, 0xb7, 0xe0, 0xb8, 0x59, 0xb8, 0xd1, 0xb9, 0x4a,
357 |   0xb9, 0xc2, 0xba, 0x3b, 0xba, 0xb5, 0xbb, 0x2e, 0xbb, 0xa7, 0xbc, 0x21,
358 |   0xbc, 0x9b, 0xbd, 0x15, 0xbd, 0x8f, 0xbe, 0x0a, 0xbe, 0x84, 0xbe, 0xff,
359 |   0xbf, 0x7a, 0xbf, 0xf5, 0xc0, 0x70, 0xc0, 0xec, 0xc1, 0x67, 0xc1, 0xe3,
360 |   0xc2, 0x5f, 0xc2, 0xdb, 0xc3, 0x58, 0xc3, 0xd4, 0xc4, 0x51, 0xc4, 0xce,
361 |   0xc5, 0x4b, 0xc5, 0xc8, 0xc6, 0x46, 0xc6, 0xc3, 0xc7, 0x41, 0xc7, 0xbf,
362 |   0xc8, 0x3d, 0xc8, 0xbc, 0xc9, 0x3a, 0xc9, 0xb9, 0xca, 0x38, 0xca, 0xb7,
363 |   0xcb, 0x36, 0xcb, 0xb6, 0xcc, 0x35, 0xcc, 0xb5, 0xcd, 0x35, 0xcd, 0xb5,
364 |   0xce, 0x36, 0xce, 0xb6, 0xcf, 0x37, 0xcf, 0xb8, 0xd0, 0x39, 0xd0, 0xba,
365 |   0xd1, 0x3c, 0xd1, 0xbe, 0xd2, 0x3f, 0xd2, 0xc1, 0xd3, 0x44, 0xd3, 0xc6,
366 |   0xd4, 0x49, 0xd4, 0xcb, 0xd5, 0x4e, 0xd5, 0xd1, 0xd6, 0x55, 0xd6, 0xd8,
367 |   0xd7, 0x5c, 0xd7, 0xe0, 0xd8, 0x64, 0xd8, 0xe8, 0xd9, 0x6c, 0xd9, 0xf1,
368 |   0xda, 0x76, 0xda, 0xfb, 0xdb, 0x80, 0xdc, 0x05, 0xdc, 0x8a, 0xdd, 0x10,
369 |   0xdd, 0x96, 0xde, 0x1c, 0xde, 0xa2, 0xdf, 0x29, 0xdf, 0xaf, 0xe0, 0x36,
370 |   0xe0, 0xbd, 0xe1, 0x44, 0xe1, 0xcc, 0xe2, 0x53, 0xe2, 0xdb, 0xe3, 0x63,
371 |   0xe3, 0xeb, 0xe4, 0x73, 0xe4, 0xfc, 0xe5, 0x84, 0xe6, 0x0d, 0xe6, 0x96,
372 |   0xe7, 0x1f, 0xe7, 0xa9, 0xe8, 0x32, 0xe8, 0xbc, 0xe9, 0x46, 0xe9, 0xd0,
373 |   0xea, 0x5b, 0xea, 0xe5, 0xeb, 0x70, 0xeb, 0xfb, 0xec, 0x86, 0xed, 0x11,
374 |   0xed, 0x9c, 0xee, 0x28, 0xee, 0xb4, 0xef, 0x40, 0xef, 0xcc, 0xf0, 0x58,
375 |   0xf0, 0xe5, 0xf1, 0x72, 0xf1, 0xff, 0xf2, 0x8c, 0xf3, 0x19, 0xf3, 0xa7,
376 |   0xf4, 0x34, 0xf4, 0xc2, 0xf5, 0x50, 0xf5, 0xde, 0xf6, 0x6d, 0xf6, 0xfb,
377 |   0xf7, 0x8a, 0xf8, 0x19, 0xf8, 0xa8, 0xf9, 0x38, 0xf9, 0xc7, 0xfa, 0x57,
378 |   0xfa, 0xe7, 0xfb, 0x77, 0xfc, 0x07, 0xfc, 0x98, 0xfd, 0x29, 0xfd, 0xba,
379 |   0xfe, 0x4b, 0xfe, 0xdc, 0xff, 0x6d, 0xff, 0xff
380 | };
381 | 


--------------------------------------------------------------------------------
/sRGB.h:
--------------------------------------------------------------------------------
  1 | // IEC 61966-2.1 Default RGB colour space - sRGB
  2 | // Copyright (c) 1998 Hewlett-Packard Company
  3 | 
  4 | unsigned char sRGBicc[] = {
  5 |   0x00, 0x00, 0x0c, 0x48, 0x4c, 0x69, 0x6e, 0x6f, 0x02, 0x10, 0x00, 0x00,
  6 |   0x6d, 0x6e, 0x74, 0x72, 0x52, 0x47, 0x42, 0x20, 0x58, 0x59, 0x5a, 0x20,
  7 |   0x07, 0xce, 0x00, 0x02, 0x00, 0x09, 0x00, 0x06, 0x00, 0x31, 0x00, 0x00,
  8 |   0x61, 0x63, 0x73, 0x70, 0x4d, 0x53, 0x46, 0x54, 0x00, 0x00, 0x00, 0x00,
  9 |   0x49, 0x45, 0x43, 0x20, 0x73, 0x52, 0x47, 0x42, 0x00, 0x00, 0x00, 0x00,
 10 |   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xf6, 0xd6,
 11 |   0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0xd3, 0x2d, 0x48, 0x50, 0x20, 0x20,
 12 |   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 13 |   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 14 |   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 15 |   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x11,
 16 |   0x63, 0x70, 0x72, 0x74, 0x00, 0x00, 0x01, 0x50, 0x00, 0x00, 0x00, 0x33,
 17 |   0x64, 0x65, 0x73, 0x63, 0x00, 0x00, 0x01, 0x84, 0x00, 0x00, 0x00, 0x6c,
 18 |   0x77, 0x74, 0x70, 0x74, 0x00, 0x00, 0x01, 0xf0, 0x00, 0x00, 0x00, 0x14,
 19 |   0x62, 0x6b, 0x70, 0x74, 0x00, 0x00, 0x02, 0x04, 0x00, 0x00, 0x00, 0x14,
 20 |   0x72, 0x58, 0x59, 0x5a, 0x00, 0x00, 0x02, 0x18, 0x00, 0x00, 0x00, 0x14,
 21 |   0x67, 0x58, 0x59, 0x5a, 0x00, 0x00, 0x02, 0x2c, 0x00, 0x00, 0x00, 0x14,
 22 |   0x62, 0x58, 0x59, 0x5a, 0x00, 0x00, 0x02, 0x40, 0x00, 0x00, 0x00, 0x14,
 23 |   0x64, 0x6d, 0x6e, 0x64, 0x00, 0x00, 0x02, 0x54, 0x00, 0x00, 0x00, 0x70,
 24 |   0x64, 0x6d, 0x64, 0x64, 0x00, 0x00, 0x02, 0xc4, 0x00, 0x00, 0x00, 0x88,
 25 |   0x76, 0x75, 0x65, 0x64, 0x00, 0x00, 0x03, 0x4c, 0x00, 0x00, 0x00, 0x86,
 26 |   0x76, 0x69, 0x65, 0x77, 0x00, 0x00, 0x03, 0xd4, 0x00, 0x00, 0x00, 0x24,
 27 |   0x6c, 0x75, 0x6d, 0x69, 0x00, 0x00, 0x03, 0xf8, 0x00, 0x00, 0x00, 0x14,
 28 |   0x6d, 0x65, 0x61, 0x73, 0x00, 0x00, 0x04, 0x0c, 0x00, 0x00, 0x00, 0x24,
 29 |   0x74, 0x65, 0x63, 0x68, 0x00, 0x00, 0x04, 0x30, 0x00, 0x00, 0x00, 0x0c,
 30 |   0x72, 0x54, 0x52, 0x43, 0x00, 0x00, 0x04, 0x3c, 0x00, 0x00, 0x08, 0x0c,
 31 |   0x67, 0x54, 0x52, 0x43, 0x00, 0x00, 0x04, 0x3c, 0x00, 0x00, 0x08, 0x0c,
 32 |   0x62, 0x54, 0x52, 0x43, 0x00, 0x00, 0x04, 0x3c, 0x00, 0x00, 0x08, 0x0c,
 33 |   0x74, 0x65, 0x78, 0x74, 0x00, 0x00, 0x00, 0x00, 0x43, 0x6f, 0x70, 0x79,
 34 |   0x72, 0x69, 0x67, 0x68, 0x74, 0x20, 0x28, 0x63, 0x29, 0x20, 0x31, 0x39,
 35 |   0x39, 0x38, 0x20, 0x48, 0x65, 0x77, 0x6c, 0x65, 0x74, 0x74, 0x2d, 0x50,
 36 |   0x61, 0x63, 0x6b, 0x61, 0x72, 0x64, 0x20, 0x43, 0x6f, 0x6d, 0x70, 0x61,
 37 |   0x6e, 0x79, 0x00, 0x00, 0x64, 0x65, 0x73, 0x63, 0x00, 0x00, 0x00, 0x00,
 38 |   0x00, 0x00, 0x00, 0x12, 0x73, 0x52, 0x47, 0x42, 0x20, 0x49, 0x45, 0x43,
 39 |   0x36, 0x31, 0x39, 0x36, 0x36, 0x2d, 0x32, 0x2e, 0x31, 0x00, 0x00, 0x00,
 40 |   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x12, 0x73, 0x52, 0x47,
 41 |   0x42, 0x20, 0x49, 0x45, 0x43, 0x36, 0x31, 0x39, 0x36, 0x36, 0x2d, 0x32,
 42 |   0x2e, 0x31, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 43 |   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 44 |   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 45 |   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 46 |   0x00, 0x00, 0x00, 0x00, 0x58, 0x59, 0x5a, 0x20, 0x00, 0x00, 0x00, 0x00,
 47 |   0x00, 0x00, 0xf3, 0x51, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x16, 0xcc,
 48 |   0x58, 0x59, 0x5a, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 49 |   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x58, 0x59, 0x5a, 0x20,
 50 |   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x6f, 0xa2, 0x00, 0x00, 0x38, 0xf5,
 51 |   0x00, 0x00, 0x03, 0x90, 0x58, 0x59, 0x5a, 0x20, 0x00, 0x00, 0x00, 0x00,
 52 |   0x00, 0x00, 0x62, 0x99, 0x00, 0x00, 0xb7, 0x85, 0x00, 0x00, 0x18, 0xda,
 53 |   0x58, 0x59, 0x5a, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x24, 0xa0,
 54 |   0x00, 0x00, 0x0f, 0x84, 0x00, 0x00, 0xb6, 0xcf, 0x64, 0x65, 0x73, 0x63,
 55 |   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x16, 0x49, 0x45, 0x43, 0x20,
 56 |   0x68, 0x74, 0x74, 0x70, 0x3a, 0x2f, 0x2f, 0x77, 0x77, 0x77, 0x2e, 0x69,
 57 |   0x65, 0x63, 0x2e, 0x63, 0x68, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 58 |   0x00, 0x00, 0x00, 0x00, 0x16, 0x49, 0x45, 0x43, 0x20, 0x68, 0x74, 0x74,
 59 |   0x70, 0x3a, 0x2f, 0x2f, 0x77, 0x77, 0x77, 0x2e, 0x69, 0x65, 0x63, 0x2e,
 60 |   0x63, 0x68, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 61 |   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 62 |   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 63 |   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 64 |   0x64, 0x65, 0x73, 0x63, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x2e,
 65 |   0x49, 0x45, 0x43, 0x20, 0x36, 0x31, 0x39, 0x36, 0x36, 0x2d, 0x32, 0x2e,
 66 |   0x31, 0x20, 0x44, 0x65, 0x66, 0x61, 0x75, 0x6c, 0x74, 0x20, 0x52, 0x47,
 67 |   0x42, 0x20, 0x63, 0x6f, 0x6c, 0x6f, 0x75, 0x72, 0x20, 0x73, 0x70, 0x61,
 68 |   0x63, 0x65, 0x20, 0x2d, 0x20, 0x73, 0x52, 0x47, 0x42, 0x00, 0x00, 0x00,
 69 |   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x2e, 0x49, 0x45, 0x43,
 70 |   0x20, 0x36, 0x31, 0x39, 0x36, 0x36, 0x2d, 0x32, 0x2e, 0x31, 0x20, 0x44,
 71 |   0x65, 0x66, 0x61, 0x75, 0x6c, 0x74, 0x20, 0x52, 0x47, 0x42, 0x20, 0x63,
 72 |   0x6f, 0x6c, 0x6f, 0x75, 0x72, 0x20, 0x73, 0x70, 0x61, 0x63, 0x65, 0x20,
 73 |   0x2d, 0x20, 0x73, 0x52, 0x47, 0x42, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 74 |   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 75 |   0x00, 0x00, 0x00, 0x00, 0x64, 0x65, 0x73, 0x63, 0x00, 0x00, 0x00, 0x00,
 76 |   0x00, 0x00, 0x00, 0x2c, 0x52, 0x65, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63,
 77 |   0x65, 0x20, 0x56, 0x69, 0x65, 0x77, 0x69, 0x6e, 0x67, 0x20, 0x43, 0x6f,
 78 |   0x6e, 0x64, 0x69, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x69, 0x6e, 0x20, 0x49,
 79 |   0x45, 0x43, 0x36, 0x31, 0x39, 0x36, 0x36, 0x2d, 0x32, 0x2e, 0x31, 0x00,
 80 |   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x2c, 0x52,
 81 |   0x65, 0x66, 0x65, 0x72, 0x65, 0x6e, 0x63, 0x65, 0x20, 0x56, 0x69, 0x65,
 82 |   0x77, 0x69, 0x6e, 0x67, 0x20, 0x43, 0x6f, 0x6e, 0x64, 0x69, 0x74, 0x69,
 83 |   0x6f, 0x6e, 0x20, 0x69, 0x6e, 0x20, 0x49, 0x45, 0x43, 0x36, 0x31, 0x39,
 84 |   0x36, 0x36, 0x2d, 0x32, 0x2e, 0x31, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 85 |   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 86 |   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x76, 0x69, 0x65, 0x77,
 87 |   0x00, 0x00, 0x00, 0x00, 0x00, 0x13, 0xa4, 0xfe, 0x00, 0x14, 0x5f, 0x2e,
 88 |   0x00, 0x10, 0xcf, 0x14, 0x00, 0x03, 0xed, 0xcc, 0x00, 0x04, 0x13, 0x0b,
 89 |   0x00, 0x03, 0x5c, 0x9e, 0x00, 0x00, 0x00, 0x01, 0x58, 0x59, 0x5a, 0x20,
 90 |   0x00, 0x00, 0x00, 0x00, 0x00, 0x4c, 0x09, 0x56, 0x00, 0x50, 0x00, 0x00,
 91 |   0x00, 0x57, 0x1f, 0xe7, 0x6d, 0x65, 0x61, 0x73, 0x00, 0x00, 0x00, 0x00,
 92 |   0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 93 |   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0x8f,
 94 |   0x00, 0x00, 0x00, 0x02, 0x73, 0x69, 0x67, 0x20, 0x00, 0x00, 0x00, 0x00,
 95 |   0x43, 0x52, 0x54, 0x20, 0x63, 0x75, 0x72, 0x76, 0x00, 0x00, 0x00, 0x00,
 96 |   0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x00, 0x05, 0x00, 0x0a, 0x00, 0x0f,
 97 |   0x00, 0x14, 0x00, 0x19, 0x00, 0x1e, 0x00, 0x23, 0x00, 0x28, 0x00, 0x2d,
 98 |   0x00, 0x32, 0x00, 0x37, 0x00, 0x3b, 0x00, 0x40, 0x00, 0x45, 0x00, 0x4a,
 99 |   0x00, 0x4f, 0x00, 0x54, 0x00, 0x59, 0x00, 0x5e, 0x00, 0x63, 0x00, 0x68,
100 |   0x00, 0x6d, 0x00, 0x72, 0x00, 0x77, 0x00, 0x7c, 0x00, 0x81, 0x00, 0x86,
101 |   0x00, 0x8b, 0x00, 0x90, 0x00, 0x95, 0x00, 0x9a, 0x00, 0x9f, 0x00, 0xa4,
102 |   0x00, 0xa9, 0x00, 0xae, 0x00, 0xb2, 0x00, 0xb7, 0x00, 0xbc, 0x00, 0xc1,
103 |   0x00, 0xc6, 0x00, 0xcb, 0x00, 0xd0, 0x00, 0xd5, 0x00, 0xdb, 0x00, 0xe0,
104 |   0x00, 0xe5, 0x00, 0xeb, 0x00, 0xf0, 0x00, 0xf6, 0x00, 0xfb, 0x01, 0x01,
105 |   0x01, 0x07, 0x01, 0x0d, 0x01, 0x13, 0x01, 0x19, 0x01, 0x1f, 0x01, 0x25,
106 |   0x01, 0x2b, 0x01, 0x32, 0x01, 0x38, 0x01, 0x3e, 0x01, 0x45, 0x01, 0x4c,
107 |   0x01, 0x52, 0x01, 0x59, 0x01, 0x60, 0x01, 0x67, 0x01, 0x6e, 0x01, 0x75,
108 |   0x01, 0x7c, 0x01, 0x83, 0x01, 0x8b, 0x01, 0x92, 0x01, 0x9a, 0x01, 0xa1,
109 |   0x01, 0xa9, 0x01, 0xb1, 0x01, 0xb9, 0x01, 0xc1, 0x01, 0xc9, 0x01, 0xd1,
110 |   0x01, 0xd9, 0x01, 0xe1, 0x01, 0xe9, 0x01, 0xf2, 0x01, 0xfa, 0x02, 0x03,
111 |   0x02, 0x0c, 0x02, 0x14, 0x02, 0x1d, 0x02, 0x26, 0x02, 0x2f, 0x02, 0x38,
112 |   0x02, 0x41, 0x02, 0x4b, 0x02, 0x54, 0x02, 0x5d, 0x02, 0x67, 0x02, 0x71,
113 |   0x02, 0x7a, 0x02, 0x84, 0x02, 0x8e, 0x02, 0x98, 0x02, 0xa2, 0x02, 0xac,
114 |   0x02, 0xb6, 0x02, 0xc1, 0x02, 0xcb, 0x02, 0xd5, 0x02, 0xe0, 0x02, 0xeb,
115 |   0x02, 0xf5, 0x03, 0x00, 0x03, 0x0b, 0x03, 0x16, 0x03, 0x21, 0x03, 0x2d,
116 |   0x03, 0x38, 0x03, 0x43, 0x03, 0x4f, 0x03, 0x5a, 0x03, 0x66, 0x03, 0x72,
117 |   0x03, 0x7e, 0x03, 0x8a, 0x03, 0x96, 0x03, 0xa2, 0x03, 0xae, 0x03, 0xba,
118 |   0x03, 0xc7, 0x03, 0xd3, 0x03, 0xe0, 0x03, 0xec, 0x03, 0xf9, 0x04, 0x06,
119 |   0x04, 0x13, 0x04, 0x20, 0x04, 0x2d, 0x04, 0x3b, 0x04, 0x48, 0x04, 0x55,
120 |   0x04, 0x63, 0x04, 0x71, 0x04, 0x7e, 0x04, 0x8c, 0x04, 0x9a, 0x04, 0xa8,
121 |   0x04, 0xb6, 0x04, 0xc4, 0x04, 0xd3, 0x04, 0xe1, 0x04, 0xf0, 0x04, 0xfe,
122 |   0x05, 0x0d, 0x05, 0x1c, 0x05, 0x2b, 0x05, 0x3a, 0x05, 0x49, 0x05, 0x58,
123 |   0x05, 0x67, 0x05, 0x77, 0x05, 0x86, 0x05, 0x96, 0x05, 0xa6, 0x05, 0xb5,
124 |   0x05, 0xc5, 0x05, 0xd5, 0x05, 0xe5, 0x05, 0xf6, 0x06, 0x06, 0x06, 0x16,
125 |   0x06, 0x27, 0x06, 0x37, 0x06, 0x48, 0x06, 0x59, 0x06, 0x6a, 0x06, 0x7b,
126 |   0x06, 0x8c, 0x06, 0x9d, 0x06, 0xaf, 0x06, 0xc0, 0x06, 0xd1, 0x06, 0xe3,
127 |   0x06, 0xf5, 0x07, 0x07, 0x07, 0x19, 0x07, 0x2b, 0x07, 0x3d, 0x07, 0x4f,
128 |   0x07, 0x61, 0x07, 0x74, 0x07, 0x86, 0x07, 0x99, 0x07, 0xac, 0x07, 0xbf,
129 |   0x07, 0xd2, 0x07, 0xe5, 0x07, 0xf8, 0x08, 0x0b, 0x08, 0x1f, 0x08, 0x32,
130 |   0x08, 0x46, 0x08, 0x5a, 0x08, 0x6e, 0x08, 0x82, 0x08, 0x96, 0x08, 0xaa,
131 |   0x08, 0xbe, 0x08, 0xd2, 0x08, 0xe7, 0x08, 0xfb, 0x09, 0x10, 0x09, 0x25,
132 |   0x09, 0x3a, 0x09, 0x4f, 0x09, 0x64, 0x09, 0x79, 0x09, 0x8f, 0x09, 0xa4,
133 |   0x09, 0xba, 0x09, 0xcf, 0x09, 0xe5, 0x09, 0xfb, 0x0a, 0x11, 0x0a, 0x27,
134 |   0x0a, 0x3d, 0x0a, 0x54, 0x0a, 0x6a, 0x0a, 0x81, 0x0a, 0x98, 0x0a, 0xae,
135 |   0x0a, 0xc5, 0x0a, 0xdc, 0x0a, 0xf3, 0x0b, 0x0b, 0x0b, 0x22, 0x0b, 0x39,
136 |   0x0b, 0x51, 0x0b, 0x69, 0x0b, 0x80, 0x0b, 0x98, 0x0b, 0xb0, 0x0b, 0xc8,
137 |   0x0b, 0xe1, 0x0b, 0xf9, 0x0c, 0x12, 0x0c, 0x2a, 0x0c, 0x43, 0x0c, 0x5c,
138 |   0x0c, 0x75, 0x0c, 0x8e, 0x0c, 0xa7, 0x0c, 0xc0, 0x0c, 0xd9, 0x0c, 0xf3,
139 |   0x0d, 0x0d, 0x0d, 0x26, 0x0d, 0x40, 0x0d, 0x5a, 0x0d, 0x74, 0x0d, 0x8e,
140 |   0x0d, 0xa9, 0x0d, 0xc3, 0x0d, 0xde, 0x0d, 0xf8, 0x0e, 0x13, 0x0e, 0x2e,
141 |   0x0e, 0x49, 0x0e, 0x64, 0x0e, 0x7f, 0x0e, 0x9b, 0x0e, 0xb6, 0x0e, 0xd2,
142 |   0x0e, 0xee, 0x0f, 0x09, 0x0f, 0x25, 0x0f, 0x41, 0x0f, 0x5e, 0x0f, 0x7a,
143 |   0x0f, 0x96, 0x0f, 0xb3, 0x0f, 0xcf, 0x0f, 0xec, 0x10, 0x09, 0x10, 0x26,
144 |   0x10, 0x43, 0x10, 0x61, 0x10, 0x7e, 0x10, 0x9b, 0x10, 0xb9, 0x10, 0xd7,
145 |   0x10, 0xf5, 0x11, 0x13, 0x11, 0x31, 0x11, 0x4f, 0x11, 0x6d, 0x11, 0x8c,
146 |   0x11, 0xaa, 0x11, 0xc9, 0x11, 0xe8, 0x12, 0x07, 0x12, 0x26, 0x12, 0x45,
147 |   0x12, 0x64, 0x12, 0x84, 0x12, 0xa3, 0x12, 0xc3, 0x12, 0xe3, 0x13, 0x03,
148 |   0x13, 0x23, 0x13, 0x43, 0x13, 0x63, 0x13, 0x83, 0x13, 0xa4, 0x13, 0xc5,
149 |   0x13, 0xe5, 0x14, 0x06, 0x14, 0x27, 0x14, 0x49, 0x14, 0x6a, 0x14, 0x8b,
150 |   0x14, 0xad, 0x14, 0xce, 0x14, 0xf0, 0x15, 0x12, 0x15, 0x34, 0x15, 0x56,
151 |   0x15, 0x78, 0x15, 0x9b, 0x15, 0xbd, 0x15, 0xe0, 0x16, 0x03, 0x16, 0x26,
152 |   0x16, 0x49, 0x16, 0x6c, 0x16, 0x8f, 0x16, 0xb2, 0x16, 0xd6, 0x16, 0xfa,
153 |   0x17, 0x1d, 0x17, 0x41, 0x17, 0x65, 0x17, 0x89, 0x17, 0xae, 0x17, 0xd2,
154 |   0x17, 0xf7, 0x18, 0x1b, 0x18, 0x40, 0x18, 0x65, 0x18, 0x8a, 0x18, 0xaf,
155 |   0x18, 0xd5, 0x18, 0xfa, 0x19, 0x20, 0x19, 0x45, 0x19, 0x6b, 0x19, 0x91,
156 |   0x19, 0xb7, 0x19, 0xdd, 0x1a, 0x04, 0x1a, 0x2a, 0x1a, 0x51, 0x1a, 0x77,
157 |   0x1a, 0x9e, 0x1a, 0xc5, 0x1a, 0xec, 0x1b, 0x14, 0x1b, 0x3b, 0x1b, 0x63,
158 |   0x1b, 0x8a, 0x1b, 0xb2, 0x1b, 0xda, 0x1c, 0x02, 0x1c, 0x2a, 0x1c, 0x52,
159 |   0x1c, 0x7b, 0x1c, 0xa3, 0x1c, 0xcc, 0x1c, 0xf5, 0x1d, 0x1e, 0x1d, 0x47,
160 |   0x1d, 0x70, 0x1d, 0x99, 0x1d, 0xc3, 0x1d, 0xec, 0x1e, 0x16, 0x1e, 0x40,
161 |   0x1e, 0x6a, 0x1e, 0x94, 0x1e, 0xbe, 0x1e, 0xe9, 0x1f, 0x13, 0x1f, 0x3e,
162 |   0x1f, 0x69, 0x1f, 0x94, 0x1f, 0xbf, 0x1f, 0xea, 0x20, 0x15, 0x20, 0x41,
163 |   0x20, 0x6c, 0x20, 0x98, 0x20, 0xc4, 0x20, 0xf0, 0x21, 0x1c, 0x21, 0x48,
164 |   0x21, 0x75, 0x21, 0xa1, 0x21, 0xce, 0x21, 0xfb, 0x22, 0x27, 0x22, 0x55,
165 |   0x22, 0x82, 0x22, 0xaf, 0x22, 0xdd, 0x23, 0x0a, 0x23, 0x38, 0x23, 0x66,
166 |   0x23, 0x94, 0x23, 0xc2, 0x23, 0xf0, 0x24, 0x1f, 0x24, 0x4d, 0x24, 0x7c,
167 |   0x24, 0xab, 0x24, 0xda, 0x25, 0x09, 0x25, 0x38, 0x25, 0x68, 0x25, 0x97,
168 |   0x25, 0xc7, 0x25, 0xf7, 0x26, 0x27, 0x26, 0x57, 0x26, 0x87, 0x26, 0xb7,
169 |   0x26, 0xe8, 0x27, 0x18, 0x27, 0x49, 0x27, 0x7a, 0x27, 0xab, 0x27, 0xdc,
170 |   0x28, 0x0d, 0x28, 0x3f, 0x28, 0x71, 0x28, 0xa2, 0x28, 0xd4, 0x29, 0x06,
171 |   0x29, 0x38, 0x29, 0x6b, 0x29, 0x9d, 0x29, 0xd0, 0x2a, 0x02, 0x2a, 0x35,
172 |   0x2a, 0x68, 0x2a, 0x9b, 0x2a, 0xcf, 0x2b, 0x02, 0x2b, 0x36, 0x2b, 0x69,
173 |   0x2b, 0x9d, 0x2b, 0xd1, 0x2c, 0x05, 0x2c, 0x39, 0x2c, 0x6e, 0x2c, 0xa2,
174 |   0x2c, 0xd7, 0x2d, 0x0c, 0x2d, 0x41, 0x2d, 0x76, 0x2d, 0xab, 0x2d, 0xe1,
175 |   0x2e, 0x16, 0x2e, 0x4c, 0x2e, 0x82, 0x2e, 0xb7, 0x2e, 0xee, 0x2f, 0x24,
176 |   0x2f, 0x5a, 0x2f, 0x91, 0x2f, 0xc7, 0x2f, 0xfe, 0x30, 0x35, 0x30, 0x6c,
177 |   0x30, 0xa4, 0x30, 0xdb, 0x31, 0x12, 0x31, 0x4a, 0x31, 0x82, 0x31, 0xba,
178 |   0x31, 0xf2, 0x32, 0x2a, 0x32, 0x63, 0x32, 0x9b, 0x32, 0xd4, 0x33, 0x0d,
179 |   0x33, 0x46, 0x33, 0x7f, 0x33, 0xb8, 0x33, 0xf1, 0x34, 0x2b, 0x34, 0x65,
180 |   0x34, 0x9e, 0x34, 0xd8, 0x35, 0x13, 0x35, 0x4d, 0x35, 0x87, 0x35, 0xc2,
181 |   0x35, 0xfd, 0x36, 0x37, 0x36, 0x72, 0x36, 0xae, 0x36, 0xe9, 0x37, 0x24,
182 |   0x37, 0x60, 0x37, 0x9c, 0x37, 0xd7, 0x38, 0x14, 0x38, 0x50, 0x38, 0x8c,
183 |   0x38, 0xc8, 0x39, 0x05, 0x39, 0x42, 0x39, 0x7f, 0x39, 0xbc, 0x39, 0xf9,
184 |   0x3a, 0x36, 0x3a, 0x74, 0x3a, 0xb2, 0x3a, 0xef, 0x3b, 0x2d, 0x3b, 0x6b,
185 |   0x3b, 0xaa, 0x3b, 0xe8, 0x3c, 0x27, 0x3c, 0x65, 0x3c, 0xa4, 0x3c, 0xe3,
186 |   0x3d, 0x22, 0x3d, 0x61, 0x3d, 0xa1, 0x3d, 0xe0, 0x3e, 0x20, 0x3e, 0x60,
187 |   0x3e, 0xa0, 0x3e, 0xe0, 0x3f, 0x21, 0x3f, 0x61, 0x3f, 0xa2, 0x3f, 0xe2,
188 |   0x40, 0x23, 0x40, 0x64, 0x40, 0xa6, 0x40, 0xe7, 0x41, 0x29, 0x41, 0x6a,
189 |   0x41, 0xac, 0x41, 0xee, 0x42, 0x30, 0x42, 0x72, 0x42, 0xb5, 0x42, 0xf7,
190 |   0x43, 0x3a, 0x43, 0x7d, 0x43, 0xc0, 0x44, 0x03, 0x44, 0x47, 0x44, 0x8a,
191 |   0x44, 0xce, 0x45, 0x12, 0x45, 0x55, 0x45, 0x9a, 0x45, 0xde, 0x46, 0x22,
192 |   0x46, 0x67, 0x46, 0xab, 0x46, 0xf0, 0x47, 0x35, 0x47, 0x7b, 0x47, 0xc0,
193 |   0x48, 0x05, 0x48, 0x4b, 0x48, 0x91, 0x48, 0xd7, 0x49, 0x1d, 0x49, 0x63,
194 |   0x49, 0xa9, 0x49, 0xf0, 0x4a, 0x37, 0x4a, 0x7d, 0x4a, 0xc4, 0x4b, 0x0c,
195 |   0x4b, 0x53, 0x4b, 0x9a, 0x4b, 0xe2, 0x4c, 0x2a, 0x4c, 0x72, 0x4c, 0xba,
196 |   0x4d, 0x02, 0x4d, 0x4a, 0x4d, 0x93, 0x4d, 0xdc, 0x4e, 0x25, 0x4e, 0x6e,
197 |   0x4e, 0xb7, 0x4f, 0x00, 0x4f, 0x49, 0x4f, 0x93, 0x4f, 0xdd, 0x50, 0x27,
198 |   0x50, 0x71, 0x50, 0xbb, 0x51, 0x06, 0x51, 0x50, 0x51, 0x9b, 0x51, 0xe6,
199 |   0x52, 0x31, 0x52, 0x7c, 0x52, 0xc7, 0x53, 0x13, 0x53, 0x5f, 0x53, 0xaa,
200 |   0x53, 0xf6, 0x54, 0x42, 0x54, 0x8f, 0x54, 0xdb, 0x55, 0x28, 0x55, 0x75,
201 |   0x55, 0xc2, 0x56, 0x0f, 0x56, 0x5c, 0x56, 0xa9, 0x56, 0xf7, 0x57, 0x44,
202 |   0x57, 0x92, 0x57, 0xe0, 0x58, 0x2f, 0x58, 0x7d, 0x58, 0xcb, 0x59, 0x1a,
203 |   0x59, 0x69, 0x59, 0xb8, 0x5a, 0x07, 0x5a, 0x56, 0x5a, 0xa6, 0x5a, 0xf5,
204 |   0x5b, 0x45, 0x5b, 0x95, 0x5b, 0xe5, 0x5c, 0x35, 0x5c, 0x86, 0x5c, 0xd6,
205 |   0x5d, 0x27, 0x5d, 0x78, 0x5d, 0xc9, 0x5e, 0x1a, 0x5e, 0x6c, 0x5e, 0xbd,
206 |   0x5f, 0x0f, 0x5f, 0x61, 0x5f, 0xb3, 0x60, 0x05, 0x60, 0x57, 0x60, 0xaa,
207 |   0x60, 0xfc, 0x61, 0x4f, 0x61, 0xa2, 0x61, 0xf5, 0x62, 0x49, 0x62, 0x9c,
208 |   0x62, 0xf0, 0x63, 0x43, 0x63, 0x97, 0x63, 0xeb, 0x64, 0x40, 0x64, 0x94,
209 |   0x64, 0xe9, 0x65, 0x3d, 0x65, 0x92, 0x65, 0xe7, 0x66, 0x3d, 0x66, 0x92,
210 |   0x66, 0xe8, 0x67, 0x3d, 0x67, 0x93, 0x67, 0xe9, 0x68, 0x3f, 0x68, 0x96,
211 |   0x68, 0xec, 0x69, 0x43, 0x69, 0x9a, 0x69, 0xf1, 0x6a, 0x48, 0x6a, 0x9f,
212 |   0x6a, 0xf7, 0x6b, 0x4f, 0x6b, 0xa7, 0x6b, 0xff, 0x6c, 0x57, 0x6c, 0xaf,
213 |   0x6d, 0x08, 0x6d, 0x60, 0x6d, 0xb9, 0x6e, 0x12, 0x6e, 0x6b, 0x6e, 0xc4,
214 |   0x6f, 0x1e, 0x6f, 0x78, 0x6f, 0xd1, 0x70, 0x2b, 0x70, 0x86, 0x70, 0xe0,
215 |   0x71, 0x3a, 0x71, 0x95, 0x71, 0xf0, 0x72, 0x4b, 0x72, 0xa6, 0x73, 0x01,
216 |   0x73, 0x5d, 0x73, 0xb8, 0x74, 0x14, 0x74, 0x70, 0x74, 0xcc, 0x75, 0x28,
217 |   0x75, 0x85, 0x75, 0xe1, 0x76, 0x3e, 0x76, 0x9b, 0x76, 0xf8, 0x77, 0x56,
218 |   0x77, 0xb3, 0x78, 0x11, 0x78, 0x6e, 0x78, 0xcc, 0x79, 0x2a, 0x79, 0x89,
219 |   0x79, 0xe7, 0x7a, 0x46, 0x7a, 0xa5, 0x7b, 0x04, 0x7b, 0x63, 0x7b, 0xc2,
220 |   0x7c, 0x21, 0x7c, 0x81, 0x7c, 0xe1, 0x7d, 0x41, 0x7d, 0xa1, 0x7e, 0x01,
221 |   0x7e, 0x62, 0x7e, 0xc2, 0x7f, 0x23, 0x7f, 0x84, 0x7f, 0xe5, 0x80, 0x47,
222 |   0x80, 0xa8, 0x81, 0x0a, 0x81, 0x6b, 0x81, 0xcd, 0x82, 0x30, 0x82, 0x92,
223 |   0x82, 0xf4, 0x83, 0x57, 0x83, 0xba, 0x84, 0x1d, 0x84, 0x80, 0x84, 0xe3,
224 |   0x85, 0x47, 0x85, 0xab, 0x86, 0x0e, 0x86, 0x72, 0x86, 0xd7, 0x87, 0x3b,
225 |   0x87, 0x9f, 0x88, 0x04, 0x88, 0x69, 0x88, 0xce, 0x89, 0x33, 0x89, 0x99,
226 |   0x89, 0xfe, 0x8a, 0x64, 0x8a, 0xca, 0x8b, 0x30, 0x8b, 0x96, 0x8b, 0xfc,
227 |   0x8c, 0x63, 0x8c, 0xca, 0x8d, 0x31, 0x8d, 0x98, 0x8d, 0xff, 0x8e, 0x66,
228 |   0x8e, 0xce, 0x8f, 0x36, 0x8f, 0x9e, 0x90, 0x06, 0x90, 0x6e, 0x90, 0xd6,
229 |   0x91, 0x3f, 0x91, 0xa8, 0x92, 0x11, 0x92, 0x7a, 0x92, 0xe3, 0x93, 0x4d,
230 |   0x93, 0xb6, 0x94, 0x20, 0x94, 0x8a, 0x94, 0xf4, 0x95, 0x5f, 0x95, 0xc9,
231 |   0x96, 0x34, 0x96, 0x9f, 0x97, 0x0a, 0x97, 0x75, 0x97, 0xe0, 0x98, 0x4c,
232 |   0x98, 0xb8, 0x99, 0x24, 0x99, 0x90, 0x99, 0xfc, 0x9a, 0x68, 0x9a, 0xd5,
233 |   0x9b, 0x42, 0x9b, 0xaf, 0x9c, 0x1c, 0x9c, 0x89, 0x9c, 0xf7, 0x9d, 0x64,
234 |   0x9d, 0xd2, 0x9e, 0x40, 0x9e, 0xae, 0x9f, 0x1d, 0x9f, 0x8b, 0x9f, 0xfa,
235 |   0xa0, 0x69, 0xa0, 0xd8, 0xa1, 0x47, 0xa1, 0xb6, 0xa2, 0x26, 0xa2, 0x96,
236 |   0xa3, 0x06, 0xa3, 0x76, 0xa3, 0xe6, 0xa4, 0x56, 0xa4, 0xc7, 0xa5, 0x38,
237 |   0xa5, 0xa9, 0xa6, 0x1a, 0xa6, 0x8b, 0xa6, 0xfd, 0xa7, 0x6e, 0xa7, 0xe0,
238 |   0xa8, 0x52, 0xa8, 0xc4, 0xa9, 0x37, 0xa9, 0xa9, 0xaa, 0x1c, 0xaa, 0x8f,
239 |   0xab, 0x02, 0xab, 0x75, 0xab, 0xe9, 0xac, 0x5c, 0xac, 0xd0, 0xad, 0x44,
240 |   0xad, 0xb8, 0xae, 0x2d, 0xae, 0xa1, 0xaf, 0x16, 0xaf, 0x8b, 0xb0, 0x00,
241 |   0xb0, 0x75, 0xb0, 0xea, 0xb1, 0x60, 0xb1, 0xd6, 0xb2, 0x4b, 0xb2, 0xc2,
242 |   0xb3, 0x38, 0xb3, 0xae, 0xb4, 0x25, 0xb4, 0x9c, 0xb5, 0x13, 0xb5, 0x8a,
243 |   0xb6, 0x01, 0xb6, 0x79, 0xb6, 0xf0, 0xb7, 0x68, 0xb7, 0xe0, 0xb8, 0x59,
244 |   0xb8, 0xd1, 0xb9, 0x4a, 0xb9, 0xc2, 0xba, 0x3b, 0xba, 0xb5, 0xbb, 0x2e,
245 |   0xbb, 0xa7, 0xbc, 0x21, 0xbc, 0x9b, 0xbd, 0x15, 0xbd, 0x8f, 0xbe, 0x0a,
246 |   0xbe, 0x84, 0xbe, 0xff, 0xbf, 0x7a, 0xbf, 0xf5, 0xc0, 0x70, 0xc0, 0xec,
247 |   0xc1, 0x67, 0xc1, 0xe3, 0xc2, 0x5f, 0xc2, 0xdb, 0xc3, 0x58, 0xc3, 0xd4,
248 |   0xc4, 0x51, 0xc4, 0xce, 0xc5, 0x4b, 0xc5, 0xc8, 0xc6, 0x46, 0xc6, 0xc3,
249 |   0xc7, 0x41, 0xc7, 0xbf, 0xc8, 0x3d, 0xc8, 0xbc, 0xc9, 0x3a, 0xc9, 0xb9,
250 |   0xca, 0x38, 0xca, 0xb7, 0xcb, 0x36, 0xcb, 0xb6, 0xcc, 0x35, 0xcc, 0xb5,
251 |   0xcd, 0x35, 0xcd, 0xb5, 0xce, 0x36, 0xce, 0xb6, 0xcf, 0x37, 0xcf, 0xb8,
252 |   0xd0, 0x39, 0xd0, 0xba, 0xd1, 0x3c, 0xd1, 0xbe, 0xd2, 0x3f, 0xd2, 0xc1,
253 |   0xd3, 0x44, 0xd3, 0xc6, 0xd4, 0x49, 0xd4, 0xcb, 0xd5, 0x4e, 0xd5, 0xd1,
254 |   0xd6, 0x55, 0xd6, 0xd8, 0xd7, 0x5c, 0xd7, 0xe0, 0xd8, 0x64, 0xd8, 0xe8,
255 |   0xd9, 0x6c, 0xd9, 0xf1, 0xda, 0x76, 0xda, 0xfb, 0xdb, 0x80, 0xdc, 0x05,
256 |   0xdc, 0x8a, 0xdd, 0x10, 0xdd, 0x96, 0xde, 0x1c, 0xde, 0xa2, 0xdf, 0x29,
257 |   0xdf, 0xaf, 0xe0, 0x36, 0xe0, 0xbd, 0xe1, 0x44, 0xe1, 0xcc, 0xe2, 0x53,
258 |   0xe2, 0xdb, 0xe3, 0x63, 0xe3, 0xeb, 0xe4, 0x73, 0xe4, 0xfc, 0xe5, 0x84,
259 |   0xe6, 0x0d, 0xe6, 0x96, 0xe7, 0x1f, 0xe7, 0xa9, 0xe8, 0x32, 0xe8, 0xbc,
260 |   0xe9, 0x46, 0xe9, 0xd0, 0xea, 0x5b, 0xea, 0xe5, 0xeb, 0x70, 0xeb, 0xfb,
261 |   0xec, 0x86, 0xed, 0x11, 0xed, 0x9c, 0xee, 0x28, 0xee, 0xb4, 0xef, 0x40,
262 |   0xef, 0xcc, 0xf0, 0x58, 0xf0, 0xe5, 0xf1, 0x72, 0xf1, 0xff, 0xf2, 0x8c,
263 |   0xf3, 0x19, 0xf3, 0xa7, 0xf4, 0x34, 0xf4, 0xc2, 0xf5, 0x50, 0xf5, 0xde,
264 |   0xf6, 0x6d, 0xf6, 0xfb, 0xf7, 0x8a, 0xf8, 0x19, 0xf8, 0xa8, 0xf9, 0x38,
265 |   0xf9, 0xc7, 0xfa, 0x57, 0xfa, 0xe7, 0xfb, 0x77, 0xfc, 0x07, 0xfc, 0x98,
266 |   0xfd, 0x29, 0xfd, 0xba, 0xfe, 0x4b, 0xfe, 0xdc, 0xff, 0x6d, 0xff, 0xff
267 | };
268 | 


--------------------------------------------------------------------------------