path: root/all_pairs/source/epic/epic.c

/*

  This program is part of the TACLeBench benchmark suite.
  Version V 2.0

  Name: epic

  Author: Designed by Eero P. Simoncelli and Edward H. Adelson
          Written by Eero P. Simoncelli
          Developed at the Vision Science Group, The Media Laboratory
          Copyright 1989, Massachusetts Institute of Technology
          All rights reserved.

  Function: Efficient Pyramid Image Coder

  Source: MediaBench


  Original name: epic

  Changes: no major functional changes

  License:
    Permission to use, copy, or modify this software and its documentation
    for educational and research purposes only and without fee is hereby
    granted, provided that this copyright notice appear on all copies and
    supporting documentation.  For any other uses of this software, in
    original or modified form, including but not limited to distribution
    in whole or in part, specific prior permission must be obtained from
    M.I.T. and the authors.  These programs shall not be used, rewritten,
    or adapted as the basis of a commercial software or hardware product
    without first obtaining appropriate licenses from M.I.T.  M.I.T. makes
    no representations about the suitability of this software for any
    purpose.  It is provided "as is" without express or implied warranty.
*/


#include "extra.h"
#include "epic.h"

#define X_SIZE  64
#define Y_SIZE  64

float epic_image[]  = {
  0x89, 0x88, 0x87, 0x86, 0x89, 0x87, 0x84, 0x86,
  0x83, 0x89, 0x82, 0x83, 0x84, 0x81, 0x80, 0x80,
  0x81, 0x83, 0x88, 0x8A, 0x8E, 0x90, 0x96, 0x98,
  0x95, 0x92, 0x93, 0x88, 0x78, 0x7B, 0x60, 0x52,
  0x41, 0x3F, 0x3A, 0x46, 0x46, 0x48, 0x49, 0x48,
  0x4F, 0x4A, 0x49, 0x50, 0x4C, 0x4B, 0x4D, 0x4C,
  0x4E, 0x4E, 0x4A, 0x49, 0x4D, 0x54, 0x50, 0x59,
  0x51, 0x5A, 0x5E, 0x5A, 0x5D, 0x61, 0x59, 0x65,
  0x63, 0x65, 0x60, 0x62, 0x68, 0x67, 0x64, 0x61,
  0x64, 0x5E, 0x66, 0x63, 0x63, 0x61, 0x67, 0x68,
  0x62, 0x64, 0x66, 0x67, 0x64, 0x63, 0x66, 0x64,
  0x67, 0x66, 0x65, 0x64, 0x64, 0x6A, 0x66, 0x65,
  0x68, 0x66, 0x69, 0x67, 0x6A, 0x66, 0x68, 0x66,
  0x6C, 0x65, 0x69, 0x64, 0x65, 0x64, 0x66, 0x62,
  0x63, 0x68, 0x68, 0x65, 0x64, 0x64, 0x62, 0x63,
  0x68, 0x65, 0x66, 0x69, 0x66, 0x65, 0x61, 0x66,
  0x6E, 0x69, 0x64, 0x61, 0x63, 0x63, 0x66, 0x63,
  0x62, 0x64, 0x60, 0x68, 0x63, 0x61, 0x62, 0x65,
  0x60, 0x63, 0x60, 0x62, 0x60, 0x5E, 0x61, 0x62,
  0x5D, 0x5C, 0x57, 0x5B, 0x58, 0x53, 0x54, 0x47,
  0x49, 0x54, 0x5C, 0x6B, 0x6F, 0x77, 0x7F, 0x80,
  0x88, 0x8A, 0x8C, 0x85, 0x7A, 0x7D, 0x7F, 0x7D,
  0x80, 0x80, 0x81, 0x80, 0x85, 0x82, 0x81, 0x7E,
  0x80, 0x7F, 0x7F, 0x7E, 0x7D, 0x7E, 0x83, 0x7F,
  0x81, 0x83, 0x87, 0x82, 0x83, 0x88, 0x84, 0x82,
  0x82, 0x8A, 0xB3, 0xC5, 0xCD, 0xCF, 0xD4, 0xD3,
  0xD6, 0xCC, 0xB5, 0x80, 0x4E, 0x48, 0x4D, 0x4D,
  0x57, 0x5A, 0x59, 0x5C, 0x62, 0x58, 0x5C, 0x5B,
  0x5B, 0x62, 0x5D, 0x5C, 0x59, 0x5C, 0x5A, 0x59,
  0x5D, 0x5F, 0x5B, 0x5F, 0x60, 0x5E, 0x5E, 0x57,
  0x5F, 0x5F, 0x60, 0x61, 0x5C, 0x61, 0x60, 0x5B,
  0x56, 0x56, 0x57, 0x58, 0x6E, 0x91, 0x96, 0x7E,
  0x89, 0x88, 0x87, 0x86, 0x8A, 0x87, 0x84, 0x87,
  0x83, 0x89, 0x82, 0x83, 0x84, 0x81, 0x80, 0x80,
  0x81, 0x83, 0x88, 0x8A, 0x8E, 0x90, 0x96, 0x98,
  0x94, 0x93, 0x93, 0x88, 0x78, 0x7B, 0x60, 0x52,
  0x41, 0x3F, 0x39, 0x46, 0x46, 0x48, 0x49, 0x47,
  0x50, 0x4A, 0x49, 0x50, 0x4D, 0x4B, 0x4D, 0x4C,
  0x4E, 0x4E, 0x4A, 0x49, 0x4E, 0x54, 0x4F, 0x59,
  0x51, 0x5A, 0x5E, 0x5A, 0x5D, 0x61, 0x59, 0x65,
  0x63, 0x65, 0x5F, 0x62, 0x68, 0x67, 0x64, 0x61,
  0x64, 0x5E, 0x66, 0x63, 0x63, 0x61, 0x67, 0x69,
  0x61, 0x63, 0x66, 0x67, 0x65, 0x63, 0x66, 0x64,
  0x67, 0x67, 0x65, 0x64, 0x64, 0x6A, 0x66, 0x65,
  0x68, 0x66, 0x69, 0x67, 0x6A, 0x67, 0x69, 0x66,
  0x6C, 0x65, 0x69, 0x64, 0x65, 0x64, 0x66, 0x62,
  0x63, 0x68, 0x68, 0x66, 0x64, 0x64, 0x62, 0x63,
  0x68, 0x65, 0x66, 0x6A, 0x67, 0x65, 0x60, 0x66,
  0x6F, 0x6A, 0x64, 0x61, 0x64, 0x63, 0x66, 0x63,
  0x62, 0x64, 0x60, 0x69, 0x64, 0x61, 0x62, 0x65,
  0x60, 0x63, 0x60, 0x62, 0x60, 0x5E, 0x61, 0x62,
  0x5D, 0x5C, 0x57, 0x5B, 0x59, 0x53, 0x54, 0x47,
  0x49, 0x54, 0x5C, 0x6B, 0x6F, 0x77, 0x7F, 0x80,
  0x88, 0x8A, 0x8C, 0x85, 0x7A, 0x7D, 0x7F, 0x7C,
  0x80, 0x80, 0x81, 0x80, 0x85, 0x82, 0x81, 0x7E,
  0x80, 0x7F, 0x7F, 0x7E, 0x7D, 0x7E, 0x83, 0x7F,
  0x81, 0x83, 0x87, 0x81, 0x83, 0x88, 0x84, 0x82,
  0x82, 0x8A, 0xB5, 0xC5, 0xCD, 0xCF, 0xD4, 0xD3,
  0xD6, 0xCC, 0xB4, 0x7E, 0x4D, 0x48, 0x4E, 0x4D,
  0x57, 0x5A, 0x59, 0x5C, 0x62, 0x58, 0x5C, 0x5B,
  0x5B, 0x62, 0x5D, 0x5C, 0x59, 0x5C, 0x5A, 0x59,
  0x5D, 0x5F, 0x5B, 0x5F, 0x60, 0x5E, 0x5E, 0x57,
  0x5F, 0x5F, 0x60, 0x61, 0x5C, 0x61, 0x60, 0x5B,
  0x56, 0x56, 0x57, 0x58, 0x6F, 0x94, 0x9A, 0x82,
  0x88, 0x89, 0x87, 0x86, 0x88, 0x86, 0x84, 0x85,
  0x82, 0x87, 0x82, 0x81, 0x83, 0x81, 0x7F, 0x80,
  0x82, 0x82, 0x87, 0x8A, 0x8F, 0x90, 0x95, 0x98,
  0x95, 0x92, 0x92, 0x88, 0x79, 0x77, 0x5F, 0x51,
  0x41, 0x3E, 0x3B, 0x44, 0x44, 0x46, 0x49, 0x4A,
  0x4C, 0x49, 0x49, 0x4E, 0x4A, 0x4A, 0x4E, 0x4A,
  0x4D, 0x4D, 0x48, 0x4A, 0x4C, 0x52, 0x52, 0x58,
  0x52, 0x59, 0x5E, 0x5A, 0x5D, 0x5F, 0x59, 0x64,
  0x64, 0x64, 0x62, 0x61, 0x66, 0x66, 0x64, 0x60,
  0x62, 0x5F, 0x65, 0x63, 0x62, 0x62, 0x65, 0x66,
  0x62, 0x65, 0x67, 0x66, 0x64, 0x64, 0x65, 0x65,
  0x66, 0x65, 0x65, 0x63, 0x63, 0x67, 0x65, 0x64,
  0x67, 0x67, 0x68, 0x66, 0x6A, 0x66, 0x67, 0x66,
  0x6C, 0x65, 0x6A, 0x64, 0x64, 0x63, 0x66, 0x62,
  0x63, 0x67, 0x69, 0x65, 0x64, 0x63, 0x62, 0x63,
  0x68, 0x65, 0x66, 0x69, 0x66, 0x65, 0x61, 0x65,
  0x6C, 0x69, 0x64, 0x61, 0x62, 0x62, 0x64, 0x63,
  0x61, 0x63, 0x60, 0x66, 0x63, 0x61, 0x62, 0x65,
  0x60, 0x62, 0x60, 0x62, 0x60, 0x5E, 0x60, 0x61,
  0x5C, 0x5C, 0x59, 0x5B, 0x57, 0x53, 0x52, 0x47,
  0x48, 0x54, 0x5C, 0x69, 0x6E, 0x77, 0x7D, 0x80,
  0x88, 0x89, 0x8C, 0x84, 0x7B, 0x7D, 0x7E, 0x7D,
  0x7F, 0x80, 0x81, 0x7F, 0x85, 0x82, 0x80, 0x7E,
  0x7F, 0x7E, 0x7F, 0x7F, 0x7E, 0x7F, 0x82, 0x7F,
  0x81, 0x83, 0x86, 0x82, 0x83, 0x87, 0x84, 0x82,
  0x81, 0x88, 0xB0, 0xC5, 0xCD, 0xCF, 0xD4, 0xD4,
  0xD6, 0xCD, 0xB8, 0x86, 0x51, 0x47, 0x4B, 0x4D,
  0x56, 0x59, 0x59, 0x5B, 0x5F, 0x59, 0x5C, 0x5D,
  0x5B, 0x62, 0x5D, 0x5B, 0x5B, 0x5C, 0x5B, 0x5A,
  0x5E, 0x5F, 0x5D, 0x5F, 0x60, 0x5D, 0x5F, 0x58,
  0x5E, 0x5F, 0x5F, 0x5F, 0x5B, 0x60, 0x60, 0x5C,
  0x57, 0x56, 0x59, 0x5B, 0x6E, 0x8A, 0x87, 0x6C,
  0x84, 0x88, 0x86, 0x84, 0x87, 0x85, 0x84, 0x82,
  0x80, 0x84, 0x82, 0x7E, 0x82, 0x7F, 0x7C, 0x80,
  0x84, 0x80, 0x84, 0x8B, 0x90, 0x92, 0x93, 0x95,
  0x97, 0x91, 0x8E, 0x86, 0x79, 0x6F, 0x5B, 0x4F,
  0x41, 0x3A, 0x3D, 0x3F, 0x40, 0x42, 0x48, 0x4B,
  0x46, 0x48, 0x47, 0x4A, 0x46, 0x49, 0x4D, 0x48,
  0x48, 0x4D, 0x46, 0x4C, 0x4B, 0x4F, 0x55, 0x55,
  0x54, 0x58, 0x5D, 0x5B, 0x5D, 0x5C, 0x5A, 0x61,
  0x62, 0x60, 0x65, 0x61, 0x63, 0x65, 0x64, 0x5F,
  0x60, 0x61, 0x63, 0x63, 0x61, 0x63, 0x61, 0x63,
  0x64, 0x66, 0x67, 0x66, 0x64, 0x65, 0x65, 0x67,
  0x64, 0x64, 0x66, 0x63, 0x62, 0x64, 0x63, 0x62,
  0x65, 0x67, 0x66, 0x65, 0x68, 0x65, 0x64, 0x64,
  0x69, 0x63, 0x69, 0x65, 0x63, 0x61, 0x63, 0x61,
  0x63, 0x68, 0x6B, 0x65, 0x63, 0x61, 0x62, 0x64,
  0x66, 0x64, 0x65, 0x66, 0x63, 0x63, 0x63, 0x65,
  0x65, 0x67, 0x65, 0x60, 0x60, 0x5E, 0x60, 0x64,
  0x5E, 0x63, 0x60, 0x61, 0x5F, 0x60, 0x61, 0x63,
  0x62, 0x62, 0x5E, 0x60, 0x61, 0x60, 0x5E, 0x5D,
  0x5C, 0x5D, 0x5C, 0x5A, 0x54, 0x51, 0x4E, 0x4A,
  0x46, 0x50, 0x59, 0x62, 0x6A, 0x75, 0x79, 0x80,
  0x86, 0x86, 0x8B, 0x83, 0x7F, 0x7E, 0x7E, 0x7E,
  0x7E, 0x81, 0x81, 0x7E, 0x83, 0x82, 0x80, 0x80,
  0x7F, 0x7F, 0x7F, 0x81, 0x81, 0x81, 0x7F, 0x7E,
  0x80, 0x82, 0x84, 0x83, 0x81, 0x84, 0x83, 0x82,
  0x7F, 0x82, 0x9D, 0xBD, 0xC9, 0xCE, 0xD2, 0xD4,
  0xD6, 0xD2, 0xC4, 0xA1, 0x68, 0x49, 0x48, 0x4D,
  0x54, 0x56, 0x59, 0x5A, 0x5A, 0x5B, 0x5B, 0x60,
  0x5B, 0x60, 0x5B, 0x5B, 0x5C, 0x5C, 0x5D, 0x5D,
  0x60, 0x5C, 0x5E, 0x5E, 0x5E, 0x5B, 0x5E, 0x5C,
  0x5D, 0x5E, 0x5F, 0x5C, 0x5C, 0x60, 0x61, 0x5E,
  0x5A, 0x58, 0x5F, 0x62, 0x5F, 0x5D, 0x48, 0x32,
  0x81, 0x85, 0x85, 0x81, 0x86, 0x83, 0x84, 0x80,
  0x7F, 0x84, 0x83, 0x7E, 0x80, 0x7E, 0x7D, 0x80,
  0x82, 0x7F, 0x85, 0x8D, 0x91, 0x93, 0x92, 0x95,
  0x95, 0x8F, 0x8C, 0x84, 0x76, 0x6B, 0x5D, 0x50,
  0x41, 0x38, 0x39, 0x3B, 0x41, 0x41, 0x46, 0x47,
  0x45, 0x47, 0x44, 0x47, 0x45, 0x4A, 0x49, 0x48,
  0x45, 0x4C, 0x48, 0x4C, 0x4E, 0x4E, 0x51, 0x56,
  0x56, 0x59, 0x5A, 0x5C, 0x5C, 0x5E, 0x5A, 0x60,
  0x5D, 0x60, 0x62, 0x61, 0x63, 0x64, 0x62, 0x5F,
  0x61, 0x62, 0x64, 0x62, 0x61, 0x64, 0x61, 0x64,
  0x63, 0x65, 0x65, 0x67, 0x63, 0x66, 0x65, 0x64,
  0x63, 0x65, 0x66, 0x61, 0x60, 0x67, 0x64, 0x62,
  0x63, 0x65, 0x64, 0x65, 0x65, 0x63, 0x62, 0x63,
  0x63, 0x61, 0x67, 0x66, 0x63, 0x5F, 0x5E, 0x60,
  0x63, 0x66, 0x6A, 0x64, 0x62, 0x60, 0x64, 0x63,
  0x65, 0x62, 0x62, 0x62, 0x60, 0x62, 0x63, 0x63,
  0x61, 0x64, 0x65, 0x60, 0x60, 0x5D, 0x61, 0x62,
  0x5D, 0x61, 0x5E, 0x60, 0x5C, 0x60, 0x5F, 0x60,
  0x61, 0x61, 0x5F, 0x60, 0x61, 0x61, 0x5E, 0x5D,
  0x5D, 0x5B, 0x5A, 0x58, 0x52, 0x51, 0x4E, 0x4D,
  0x47, 0x4A, 0x51, 0x5B, 0x66, 0x70, 0x76, 0x7C,
  0x81, 0x84, 0x8A, 0x85, 0x81, 0x80, 0x7F, 0x7C,
  0x7F, 0x82, 0x82, 0x81, 0x82, 0x82, 0x81, 0x84,
  0x80, 0x82, 0x81, 0x80, 0x81, 0x81, 0x80, 0x80,
  0x81, 0x82, 0x81, 0x82, 0x7F, 0x81, 0x80, 0x81,
  0x7F, 0x7D, 0x86, 0xAB, 0xC1, 0xCB, 0xCF, 0xD2,
  0xD3, 0xD5, 0xCF, 0xBA, 0x8A, 0x57, 0x48, 0x4D,
  0x51, 0x52, 0x55, 0x5A, 0x5A, 0x5B, 0x59, 0x5F,
  0x59, 0x5C, 0x59, 0x5C, 0x5A, 0x5A, 0x5B, 0x5C,
  0x5F, 0x5C, 0x5D, 0x5B, 0x5D, 0x5C, 0x5C, 0x5E,
  0x5C, 0x5D, 0x61, 0x5E, 0x5D, 0x5F, 0x62, 0x61,
  0x61, 0x5F, 0x60, 0x5A, 0x3D, 0x28, 0x19, 0x13,
  0x82, 0x84, 0x83, 0x7F, 0x84, 0x83, 0x83, 0x81,
  0x80, 0x83, 0x84, 0x82, 0x7F, 0x7F, 0x80, 0x7F,
  0x81, 0x83, 0x87, 0x8E, 0x92, 0x91, 0x93, 0x94,
  0x91, 0x8F, 0x8E, 0x83, 0x72, 0x6A, 0x60, 0x4F,
  0x3F, 0x36, 0x37, 0x3D, 0x42, 0x3F, 0x43, 0x47,
  0x45, 0x45, 0x46, 0x46, 0x47, 0x4B, 0x44, 0x46,
  0x44, 0x47, 0x48, 0x4B, 0x51, 0x4D, 0x4F, 0x56,
  0x56, 0x5A, 0x5A, 0x5B, 0x5B, 0x5D, 0x5B, 0x5F,
  0x5C, 0x62, 0x5D, 0x61, 0x62, 0x63, 0x60, 0x63,
  0x62, 0x63, 0x64, 0x60, 0x61, 0x64, 0x60, 0x66,
  0x5F, 0x63, 0x65, 0x67, 0x63, 0x63, 0x63, 0x63,
  0x63, 0x65, 0x63, 0x61, 0x62, 0x66, 0x63, 0x63,
  0x62, 0x63, 0x61, 0x62, 0x64, 0x61, 0x64, 0x63,
  0x61, 0x64, 0x66, 0x63, 0x63, 0x5E, 0x5D, 0x5E,
  0x63, 0x61, 0x64, 0x63, 0x63, 0x60, 0x63, 0x62,
  0x64, 0x62, 0x63, 0x61, 0x62, 0x61, 0x63, 0x60,
  0x61, 0x61, 0x63, 0x63, 0x61, 0x62, 0x62, 0x60,
  0x5E, 0x5F, 0x5F, 0x61, 0x5D, 0x61, 0x5F, 0x5F,
  0x5F, 0x5E, 0x61, 0x60, 0x5F, 0x5F, 0x62, 0x61,
  0x5D, 0x5A, 0x56, 0x58, 0x54, 0x52, 0x51, 0x4F,
  0x4C, 0x47, 0x4B, 0x57, 0x61, 0x6C, 0x72, 0x79,
  0x7E, 0x82, 0x89, 0x87, 0x82, 0x82, 0x7F, 0x7E,
  0x80, 0x82, 0x86, 0x84, 0x85, 0x84, 0x83, 0x85,
  0x82, 0x82, 0x82, 0x80, 0x81, 0x83, 0x82, 0x80,
  0x80, 0x83, 0x80, 0x81, 0x7F, 0x81, 0x7F, 0x81,
  0x83, 0x7A, 0x7D, 0x95, 0xB7, 0xC6, 0xCD, 0xD0,
  0xD3, 0xD5, 0xD4, 0xC9, 0xA9, 0x73, 0x4B, 0x48,
  0x4D, 0x50, 0x53, 0x57, 0x59, 0x5A, 0x57, 0x5C,
  0x5B, 0x5A, 0x59, 0x5B, 0x59, 0x58, 0x58, 0x5A,
  0x5F, 0x5D, 0x5B, 0x58, 0x5D, 0x5A, 0x5C, 0x5D,
  0x5D, 0x5E, 0x5E, 0x5F, 0x5C, 0x5D, 0x62, 0x65,
  0x66, 0x65, 0x55, 0x3D, 0x20, 0x13, 0x12, 0x17,
  0x83, 0x83, 0x80, 0x81, 0x84, 0x82, 0x81, 0x81,
  0x81, 0x83, 0x81, 0x83, 0x7F, 0x80, 0x80, 0x7E,
  0x83, 0x8A, 0x8A, 0x90, 0x93, 0x91, 0x92, 0x92,
  0x8F, 0x90, 0x8D, 0x83, 0x71, 0x69, 0x5D, 0x4D,
  0x41, 0x37, 0x37, 0x3F, 0x3C, 0x3F, 0x42, 0x48,
  0x44, 0x46, 0x49, 0x4B, 0x4A, 0x4A, 0x41, 0x45,
  0x45, 0x44, 0x44, 0x48, 0x50, 0x4C, 0x51, 0x53,
  0x57, 0x57, 0x5A, 0x5A, 0x5D, 0x5B, 0x5D, 0x5D,
  0x5C, 0x5E, 0x5E, 0x62, 0x5E, 0x62, 0x60, 0x65,
  0x63, 0x63, 0x61, 0x5F, 0x61, 0x63, 0x5E, 0x65,
  0x5E, 0x61, 0x66, 0x63, 0x63, 0x61, 0x63, 0x65,
  0x61, 0x62, 0x62, 0x64, 0x64, 0x63, 0x62, 0x62,
  0x60, 0x63, 0x62, 0x61, 0x64, 0x61, 0x64, 0x63,
  0x62, 0x66, 0x66, 0x63, 0x64, 0x5E, 0x60, 0x5F,
  0x63, 0x62, 0x60, 0x63, 0x62, 0x60, 0x62, 0x62,
  0x64, 0x66, 0x66, 0x63, 0x65, 0x61, 0x65, 0x61,
  0x60, 0x61, 0x61, 0x64, 0x61, 0x63, 0x63, 0x61,
  0x61, 0x5F, 0x61, 0x61, 0x5F, 0x62, 0x5E, 0x60,
  0x5F, 0x5B, 0x5F, 0x61, 0x5E, 0x5F, 0x65, 0x60,
  0x5A, 0x5B, 0x58, 0x59, 0x56, 0x53, 0x52, 0x50,
  0x4E, 0x4B, 0x47, 0x51, 0x5A, 0x67, 0x6E, 0x77,
  0x7B, 0x7F, 0x87, 0x87, 0x86, 0x84, 0x82, 0x83,
  0x83, 0x83, 0x86, 0x87, 0x89, 0x88, 0x87, 0x84,
  0x84, 0x83, 0x80, 0x80, 0x81, 0x84, 0x81, 0x81,
  0x80, 0x81, 0x7F, 0x7F, 0x7F, 0x82, 0x80, 0x81,
  0x84, 0x7C, 0x7E, 0x82, 0xA5, 0xC0, 0xCA, 0xCF,
  0xD3, 0xD5, 0xD5, 0xD2, 0xBF, 0x96, 0x5C, 0x47,
  0x4B, 0x4E, 0x50, 0x55, 0x55, 0x58, 0x57, 0x5A,
  0x5D, 0x5A, 0x5C, 0x59, 0x5C, 0x55, 0x57, 0x5B,
  0x60, 0x5B, 0x5B, 0x59, 0x5B, 0x5B, 0x5F, 0x5B,
  0x5D, 0x5E, 0x5B, 0x5D, 0x5D, 0x5D, 0x65, 0x68,
  0x63, 0x5A, 0x3A, 0x23, 0x19, 0x12, 0x17, 0x19,
  0x83, 0x83, 0x81, 0x84, 0x82, 0x80, 0x82, 0x81,
  0x81, 0x81, 0x80, 0x81, 0x80, 0x7F, 0x7E, 0x82,
  0x86, 0x8C, 0x90, 0x91, 0x91, 0x92, 0x91, 0x92,
  0x90, 0x8F, 0x87, 0x82, 0x72, 0x69, 0x5D, 0x4E,
  0x42, 0x39, 0x37, 0x3E, 0x3A, 0x42, 0x44, 0x43,
  0x46, 0x4B, 0x49, 0x4E, 0x4A, 0x49, 0x42, 0x48,
  0x48, 0x44, 0x42, 0x45, 0x4C, 0x4D, 0x51, 0x51,
  0x55, 0x56, 0x5A, 0x5C, 0x5E, 0x5C, 0x5C, 0x5F,
  0x5D, 0x5C, 0x60, 0x60, 0x5C, 0x62, 0x62, 0x64,
  0x63, 0x61, 0x61, 0x60, 0x61, 0x61, 0x60, 0x63,
  0x61, 0x61, 0x65, 0x62, 0x62, 0x65, 0x65, 0x65,
  0x61, 0x62, 0x64, 0x65, 0x66, 0x63, 0x64, 0x5F,
  0x5F, 0x62, 0x65, 0x64, 0x64, 0x63, 0x62, 0x65,
  0x63, 0x64, 0x65, 0x62, 0x65, 0x60, 0x63, 0x60,
  0x61, 0x66, 0x61, 0x64, 0x5F, 0x60, 0x63, 0x62,
  0x64, 0x67, 0x66, 0x67, 0x66, 0x61, 0x65, 0x64,
  0x60, 0x65, 0x61, 0x62, 0x61, 0x60, 0x64, 0x5F,
  0x63, 0x61, 0x60, 0x5F, 0x5F, 0x5E, 0x5D, 0x60,
  0x61, 0x5D, 0x60, 0x61, 0x60, 0x60, 0x62, 0x5F,
  0x59, 0x5D, 0x5B, 0x5A, 0x57, 0x54, 0x51, 0x56,
  0x4E, 0x4E, 0x48, 0x4C, 0x55, 0x60, 0x6E, 0x75,
  0x79, 0x7D, 0x84, 0x87, 0x89, 0x89, 0x87, 0x85,
  0x84, 0x86, 0x87, 0x8A, 0x89, 0x8A, 0x8A, 0x85,
  0x82, 0x84, 0x82, 0x81, 0x83, 0x83, 0x7D, 0x80,
  0x80, 0x7E, 0x7F, 0x7C, 0x7E, 0x7F, 0x80, 0x80,
  0x7F, 0x80, 0x7F, 0x7B, 0x8D, 0xB5, 0xC5, 0xCC,
  0xD2, 0xD4, 0xD5, 0xD6, 0xCC, 0xB4, 0x7F, 0x4E,
  0x4C, 0x4B, 0x4F, 0x51, 0x56, 0x55, 0x54, 0x59,
  0x5C, 0x59, 0x5D, 0x59, 0x5B, 0x57, 0x57, 0x5D,
  0x5D, 0x58, 0x5D, 0x5D, 0x5A, 0x5F, 0x61, 0x5D,
  0x5F, 0x5E, 0x5D, 0x60, 0x60, 0x63, 0x69, 0x62,
  0x50, 0x38, 0x1D, 0x1A, 0x1C, 0x17, 0x19, 0x18,
  0x81, 0x82, 0x83, 0x82, 0x81, 0x7E, 0x83, 0x83,
  0x80, 0x82, 0x82, 0x80, 0x80, 0x7D, 0x80, 0x88,
  0x8A, 0x8D, 0x93, 0x8F, 0x91, 0x91, 0x90, 0x8F,
  0x90, 0x8C, 0x84, 0x81, 0x71, 0x69, 0x5E, 0x4B,
  0x40, 0x3A, 0x38, 0x3B, 0x3B, 0x45, 0x44, 0x3E,
  0x46, 0x4B, 0x4A, 0x4B, 0x45, 0x47, 0x45, 0x49,
  0x44, 0x45, 0x42, 0x47, 0x4A, 0x4F, 0x52, 0x51,
  0x53, 0x57, 0x59, 0x5D, 0x5B, 0x5E, 0x5A, 0x60,
  0x5F, 0x5F, 0x5F, 0x61, 0x5C, 0x61, 0x64, 0x63,
  0x62, 0x60, 0x62, 0x62, 0x63, 0x60, 0x61, 0x60,
  0x64, 0x64, 0x66, 0x63, 0x61, 0x68, 0x65, 0x65,
  0x63, 0x66, 0x65, 0x63, 0x65, 0x63, 0x64, 0x61,
  0x60, 0x60, 0x62, 0x66, 0x64, 0x61, 0x63, 0x65,
  0x64, 0x62, 0x66, 0x60, 0x67, 0x63, 0x61, 0x5E,
  0x5D, 0x66, 0x65, 0x63, 0x60, 0x60, 0x61, 0x62,
  0x66, 0x68, 0x66, 0x6B, 0x65, 0x62, 0x65, 0x63,
  0x63, 0x64, 0x63, 0x62, 0x60, 0x61, 0x62, 0x5D,
  0x62, 0x62, 0x61, 0x5E, 0x5F, 0x5A, 0x5E, 0x5E,
  0x61, 0x60, 0x62, 0x60, 0x62, 0x5E, 0x5F, 0x60,
  0x5E, 0x5F, 0x59, 0x5B, 0x56, 0x54, 0x51, 0x59,
  0x4E, 0x4E, 0x49, 0x47, 0x52, 0x5B, 0x6B, 0x72,
  0x76, 0x7C, 0x82, 0x86, 0x87, 0x8E, 0x89, 0x85,
  0x85, 0x87, 0x88, 0x8D, 0x89, 0x89, 0x8A, 0x89,
  0x82, 0x84, 0x85, 0x86, 0x86, 0x80, 0x7E, 0x7E,
  0x7E, 0x7F, 0x81, 0x7D, 0x7F, 0x7C, 0x7E, 0x7D,
  0x7E, 0x80, 0x7D, 0x7C, 0x7B, 0x9F, 0xBD, 0xC9,
  0xD0, 0xD3, 0xD5, 0xD6, 0xD3, 0xC6, 0xA3, 0x64,
  0x4C, 0x47, 0x50, 0x4D, 0x58, 0x53, 0x52, 0x58,
  0x59, 0x5A, 0x5C, 0x59, 0x5B, 0x5E, 0x58, 0x5E,
  0x5B, 0x5D, 0x5F, 0x5C, 0x5B, 0x60, 0x63, 0x5F,
  0x62, 0x62, 0x60, 0x64, 0x65, 0x68, 0x63, 0x4F,
  0x30, 0x17, 0x14, 0x13, 0x17, 0x1A, 0x15, 0x17,
  0x82, 0x83, 0x83, 0x80, 0x82, 0x7F, 0x83, 0x86,
  0x83, 0x86, 0x81, 0x81, 0x80, 0x7F, 0x85, 0x88,
  0x8C, 0x8F, 0x92, 0x8E, 0x93, 0x8F, 0x8E, 0x8B,
  0x8E, 0x8A, 0x85, 0x7E, 0x71, 0x68, 0x5E, 0x4F,
  0x42, 0x3E, 0x38, 0x39, 0x3D, 0x45, 0x42, 0x42,
  0x44, 0x47, 0x4B, 0x49, 0x45, 0x46, 0x47, 0x46,
  0x42, 0x45, 0x44, 0x48, 0x4A, 0x50, 0x52, 0x51,
  0x55, 0x54, 0x57, 0x5A, 0x5A, 0x5D, 0x57, 0x5F,
  0x5E, 0x60, 0x5D, 0x61, 0x5E, 0x61, 0x64, 0x62,
  0x60, 0x62, 0x62, 0x63, 0x63, 0x62, 0x62, 0x61,
  0x63, 0x62, 0x65, 0x63, 0x60, 0x65, 0x64, 0x63,
  0x64, 0x66, 0x64, 0x61, 0x62, 0x64, 0x63, 0x63,
  0x63, 0x5F, 0x61, 0x67, 0x62, 0x61, 0x64, 0x63,
  0x63, 0x62, 0x65, 0x61, 0x68, 0x61, 0x63, 0x61,
  0x5D, 0x65, 0x68, 0x62, 0x60, 0x5E, 0x5E, 0x63,
  0x67, 0x69, 0x68, 0x69, 0x69, 0x64, 0x65, 0x64,
  0x65, 0x61, 0x64, 0x64, 0x64, 0x62, 0x62, 0x5C,
  0x60, 0x62, 0x63, 0x61, 0x61, 0x5B, 0x5C, 0x5C,
  0x60, 0x60, 0x61, 0x5F, 0x63, 0x5B, 0x5D, 0x60,
  0x61, 0x5F, 0x5B, 0x5C, 0x5A, 0x53, 0x52, 0x56,
  0x4E, 0x4C, 0x48, 0x44, 0x4E, 0x5A, 0x65, 0x6F,
  0x74, 0x7C, 0x81, 0x85, 0x85, 0x8E, 0x88, 0x87,
  0x88, 0x87, 0x88, 0x8E, 0x89, 0x8A, 0x8A, 0x8B,
  0x86, 0x83, 0x84, 0x87, 0x86, 0x83, 0x80, 0x7F,
  0x7F, 0x81, 0x80, 0x7F, 0x7F, 0x7E, 0x7E, 0x7F,
  0x80, 0x7D, 0x7C, 0x7C, 0x78, 0x84, 0xAD, 0xC3,
  0xCC, 0xD2, 0xD4, 0xD6, 0xD6, 0xCF, 0xB9, 0x87,
  0x54, 0x47, 0x51, 0x4D, 0x56, 0x53, 0x54, 0x59,
  0x57, 0x5B, 0x5E, 0x5B, 0x5E, 0x61, 0x5A, 0x5E,
  0x5A, 0x63, 0x5D, 0x5D, 0x5F, 0x5E, 0x62, 0x5F,
  0x62, 0x65, 0x63, 0x68, 0x6A, 0x63, 0x4D, 0x33,
  0x17, 0x12, 0x1B, 0x11, 0x16, 0x18, 0x14, 0x16,
  0x84, 0x83, 0x82, 0x7F, 0x83, 0x81, 0x82, 0x86,
  0x86, 0x85, 0x80, 0x83, 0x7E, 0x80, 0x85, 0x86,
  0x8C, 0x90, 0x8F, 0x8E, 0x93, 0x8C, 0x8C, 0x8B,
  0x88, 0x88, 0x84, 0x7C, 0x74, 0x68, 0x62, 0x5B,
  0x45, 0x3F, 0x38, 0x3A, 0x3F, 0x42, 0x41, 0x45,
  0x4D, 0x46, 0x49, 0x48, 0x44, 0x47, 0x45, 0x43,
  0x47, 0x46, 0x45, 0x45, 0x4B, 0x51, 0x50, 0x52,
  0x57, 0x54, 0x55, 0x57, 0x59, 0x5B, 0x57, 0x5E,
  0x5B, 0x5E, 0x5E, 0x60, 0x61, 0x60, 0x63, 0x61,
  0x5E, 0x63, 0x61, 0x63, 0x62, 0x63, 0x63, 0x62,
  0x61, 0x61, 0x63, 0x64, 0x60, 0x60, 0x64, 0x61,
  0x63, 0x61, 0x63, 0x61, 0x61, 0x61, 0x63, 0x62,
  0x64, 0x60, 0x61, 0x64, 0x60, 0x61, 0x61, 0x62,
  0x63, 0x60, 0x61, 0x62, 0x65, 0x5F, 0x66, 0x63,
  0x61, 0x63, 0x65, 0x62, 0x5E, 0x5E, 0x5F, 0x62,
  0x65, 0x66, 0x67, 0x67, 0x6D, 0x64, 0x62, 0x63,
  0x65, 0x61, 0x62, 0x62, 0x69, 0x61, 0x64, 0x5C,
  0x5F, 0x61, 0x61, 0x60, 0x61, 0x5C, 0x5B, 0x5E,
  0x60, 0x5F, 0x60, 0x60, 0x60, 0x5B, 0x5E, 0x5E,
  0x60, 0x5C, 0x5D, 0x5C, 0x60, 0x57, 0x53, 0x53,
  0x4E, 0x4D, 0x49, 0x44, 0x4C, 0x55, 0x61, 0x6C,
  0x74, 0x7B, 0x80, 0x84, 0x86, 0x8B, 0x89, 0x89,
  0x89, 0x87, 0x87, 0x8D, 0x89, 0x8C, 0x89, 0x8A,
  0x89, 0x83, 0x83, 0x83, 0x85, 0x86, 0x7F, 0x81,
  0x80, 0x82, 0x7E, 0x7F, 0x7D, 0x80, 0x7F, 0x81,
  0x7F, 0x7C, 0x7D, 0x7B, 0x7B, 0x76, 0x95, 0xBA,
  0xC7, 0xD0, 0xD2, 0xD5, 0xD7, 0xD4, 0xC8, 0xAA,
  0x70, 0x48, 0x4F, 0x4D, 0x54, 0x52, 0x55, 0x58,
  0x56, 0x59, 0x5A, 0x5C, 0x5F, 0x5E, 0x59, 0x5D,
  0x5A, 0x5D, 0x5D, 0x62, 0x63, 0x61, 0x61, 0x62,
  0x63, 0x66, 0x68, 0x6D, 0x65, 0x4A, 0x31, 0x1C,
  0x12, 0x1B, 0x22, 0x16, 0x1B, 0x16, 0x16, 0x18,
  0x84, 0x83, 0x7E, 0x82, 0x83, 0x81, 0x82, 0x85,
  0x87, 0x84, 0x83, 0x84, 0x7D, 0x80, 0x83, 0x88,
  0x8E, 0x90, 0x90, 0x8C, 0x8F, 0x8D, 0x8C, 0x88,
  0x85, 0x86, 0x83, 0x7C, 0x78, 0x6A, 0x63, 0x5A,
  0x43, 0x3A, 0x39, 0x3D, 0x3F, 0x3E, 0x42, 0x43,
  0x57, 0x45, 0x48, 0x44, 0x43, 0x4B, 0x43, 0x44,
  0x48, 0x46, 0x46, 0x46, 0x4C, 0x52, 0x4D, 0x52,
  0x56, 0x59, 0x55, 0x58, 0x57, 0x5A, 0x5B, 0x5B,
  0x5D, 0x5C, 0x5D, 0x60, 0x63, 0x62, 0x60, 0x61,
  0x60, 0x5F, 0x62, 0x63, 0x5F, 0x60, 0x62, 0x62,
  0x61, 0x61, 0x63, 0x64, 0x61, 0x60, 0x64, 0x63,
  0x62, 0x60, 0x64, 0x63, 0x60, 0x5F, 0x63, 0x62,
  0x61, 0x64, 0x5E, 0x61, 0x60, 0x60, 0x5E, 0x62,
  0x60, 0x5F, 0x60, 0x60, 0x61, 0x5F, 0x61, 0x61,
  0x61, 0x61, 0x61, 0x61, 0x5D, 0x60, 0x5E, 0x5F,
  0x63, 0x62, 0x66, 0x66, 0x69, 0x64, 0x61, 0x62,
  0x64, 0x62, 0x63, 0x61, 0x65, 0x61, 0x60, 0x5F,
  0x5E, 0x63, 0x5E, 0x5D, 0x5D, 0x5D, 0x5B, 0x60,
  0x5F, 0x5F, 0x5D, 0x5F, 0x5B, 0x5B, 0x5F, 0x5E,
  0x5D, 0x5A, 0x5C, 0x5B, 0x5C, 0x58, 0x52, 0x51,
  0x4E, 0x51, 0x4A, 0x47, 0x4D, 0x51, 0x5E, 0x69,
  0x74, 0x7B, 0x7E, 0x82, 0x86, 0x89, 0x8B, 0x89,
  0x88, 0x8A, 0x86, 0x88, 0x88, 0x8C, 0x88, 0x89,
  0x89, 0x88, 0x85, 0x7F, 0x83, 0x84, 0x80, 0x80,
  0x80, 0x81, 0x7C, 0x7E, 0x7E, 0x7E, 0x7E, 0x7E,
  0x7E, 0x7B, 0x7D, 0x7C, 0x78, 0x74, 0x7F, 0xA8,
  0xC1, 0xCB, 0xD1, 0xD4, 0xD6, 0xD6, 0xD2, 0xC1,
  0x94, 0x57, 0x49, 0x4C, 0x52, 0x53, 0x57, 0x5A,
  0x57, 0x59, 0x53, 0x5A, 0x5E, 0x5C, 0x5A, 0x5A,
  0x5A, 0x57, 0x60, 0x63, 0x65, 0x64, 0x63, 0x64,
  0x66, 0x69, 0x6A, 0x67, 0x4E, 0x30, 0x1C, 0x12,
  0x15, 0x19, 0x1F, 0x1A, 0x1A, 0x16, 0x1A, 0x1B,
  0x81, 0x81, 0x7D, 0x83, 0x85, 0x81, 0x84, 0x84,
  0x86, 0x83, 0x84, 0x83, 0x7E, 0x84, 0x86, 0x8B,
  0x8F, 0x8F, 0x94, 0x8D, 0x8D, 0x8B, 0x8C, 0x85,
  0x85, 0x85, 0x84, 0x7D, 0x79, 0x6B, 0x5C, 0x4F,
  0x3F, 0x36, 0x36, 0x3A, 0x3E, 0x3B, 0x43, 0x44,
  0x4E, 0x45, 0x47, 0x42, 0x45, 0x4B, 0x44, 0x44,
  0x48, 0x44, 0x46, 0x4A, 0x4B, 0x4F, 0x4D, 0x50,
  0x56, 0x5A, 0x57, 0x59, 0x56, 0x58, 0x5E, 0x5C,
  0x5F, 0x5F, 0x5C, 0x5F, 0x5D, 0x65, 0x5D, 0x62,
  0x5F, 0x5C, 0x61, 0x60, 0x5F, 0x5E, 0x61, 0x62,
  0x61, 0x61, 0x63, 0x60, 0x5F, 0x61, 0x63, 0x63,
  0x61, 0x61, 0x64, 0x62, 0x60, 0x61, 0x66, 0x63,
  0x62, 0x64, 0x5E, 0x61, 0x60, 0x5F, 0x5C, 0x5F,
  0x5C, 0x60, 0x5E, 0x5D, 0x5E, 0x5E, 0x5B, 0x5F,
  0x60, 0x5D, 0x5E, 0x60, 0x5E, 0x60, 0x5B, 0x5E,
  0x61, 0x60, 0x63, 0x64, 0x64, 0x65, 0x63, 0x61,
  0x63, 0x61, 0x64, 0x64, 0x60, 0x62, 0x5C, 0x5F,
  0x5D, 0x63, 0x5E, 0x5C, 0x5D, 0x5D, 0x5B, 0x5F,
  0x5E, 0x60, 0x5D, 0x5D, 0x5B, 0x5D, 0x5E, 0x5E,
  0x5C, 0x5B, 0x5D, 0x59, 0x5A, 0x58, 0x52, 0x4D,
  0x4F, 0x4F, 0x4A, 0x4B, 0x50, 0x54, 0x5C, 0x66,
  0x71, 0x79, 0x7C, 0x83, 0x85, 0x89, 0x8B, 0x8A,
  0x87, 0x8D, 0x86, 0x84, 0x87, 0x89, 0x88, 0x88,
  0x87, 0x89, 0x86, 0x81, 0x83, 0x84, 0x82, 0x80,
  0x82, 0x80, 0x7C, 0x7D, 0x7F, 0x7D, 0x7D, 0x7C,
  0x7F, 0x7C, 0x7C, 0x7D, 0x78, 0x75, 0x75, 0x91,
  0xB7, 0xC7, 0xCF, 0xD4, 0xD5, 0xD6, 0xD7, 0xCE,
  0xB2, 0x7C, 0x4A, 0x4A, 0x4F, 0x53, 0x58, 0x5B,
  0x5B, 0x5C, 0x57, 0x59, 0x5E, 0x5C, 0x5A, 0x58,
  0x59, 0x5B, 0x5E, 0x60, 0x61, 0x62, 0x63, 0x64,
  0x69, 0x6B, 0x63, 0x50, 0x2B, 0x27, 0x19, 0x11,
  0x13, 0x15, 0x15, 0x17, 0x14, 0x18, 0x1E, 0x1A,
  0x7F, 0x7F, 0x81, 0x82, 0x84, 0x82, 0x85, 0x83,
  0x83, 0x83, 0x85, 0x82, 0x81, 0x89, 0x8A, 0x8D,
  0x8F, 0x90, 0x92, 0x8E, 0x8A, 0x87, 0x89, 0x85,
  0x87, 0x87, 0x85, 0x7D, 0x78, 0x6C, 0x58, 0x4B,
  0x3B, 0x33, 0x30, 0x36, 0x3E, 0x3D, 0x43, 0x46,
  0x43, 0x46, 0x46, 0x45, 0x48, 0x47, 0x46, 0x44,
  0x49, 0x42, 0x46, 0x4A, 0x4B, 0x4B, 0x4F, 0x4F,
  0x56, 0x5B, 0x57, 0x58, 0x57, 0x5A, 0x5B, 0x5E,
  0x5F, 0x61, 0x5C, 0x5E, 0x5D, 0x61, 0x5E, 0x62,
  0x5D, 0x5E, 0x5F, 0x5E, 0x61, 0x61, 0x60, 0x62,
  0x61, 0x61, 0x60, 0x5F, 0x5D, 0x60, 0x5F, 0x61,
  0x61, 0x60, 0x62, 0x5E, 0x60, 0x64, 0x65, 0x63,
  0x66, 0x65, 0x65, 0x60, 0x5F, 0x5C, 0x59, 0x5B,
  0x5B, 0x5D, 0x59, 0x5C, 0x5B, 0x5D, 0x5E, 0x5F,
  0x5F, 0x5A, 0x5C, 0x5E, 0x5E, 0x5F, 0x5A, 0x60,
  0x5D, 0x5F, 0x5F, 0x63, 0x62, 0x64, 0x63, 0x61,
  0x61, 0x63, 0x64, 0x66, 0x60, 0x61, 0x5E, 0x5D,
  0x5D, 0x5F, 0x5E, 0x5D, 0x60, 0x5C, 0x5D, 0x5F,
  0x5D, 0x5E, 0x5E, 0x5D, 0x5C, 0x60, 0x5E, 0x5D,
  0x5D, 0x5B, 0x5C, 0x59, 0x5C, 0x5B, 0x53, 0x4E,
  0x50, 0x4A, 0x48, 0x4B, 0x50, 0x56, 0x5C, 0x63,
  0x6E, 0x74, 0x7E, 0x83, 0x84, 0x88, 0x8B, 0x89,
  0x89, 0x8B, 0x85, 0x85, 0x87, 0x86, 0x88, 0x85,
  0x86, 0x87, 0x86, 0x85, 0x82, 0x84, 0x82, 0x81,
  0x83, 0x80, 0x7F, 0x7E, 0x7D, 0x7F, 0x7F, 0x7C,
  0x7F, 0x7C, 0x7E, 0x7D, 0x7A, 0x78, 0x75, 0x7C,
  0xA4, 0xC2, 0xCC, 0xD3, 0xD4, 0xD7, 0xD9, 0xD5,
  0xC7, 0xA2, 0x60, 0x46, 0x4E, 0x50, 0x54, 0x57,
  0x5C, 0x5E, 0x5D, 0x5A, 0x5D, 0x5A, 0x5A, 0x59,
  0x59, 0x5E, 0x5E, 0x5D, 0x5E, 0x61, 0x63, 0x67,
  0x69, 0x64, 0x4C, 0x2D, 0x12, 0x1C, 0x1B, 0x10,
  0x0E, 0x14, 0x11, 0x13, 0x12, 0x1B, 0x1D, 0x1A,
  0x82, 0x81, 0x85, 0x82, 0x83, 0x82, 0x85, 0x85,
  0x84, 0x84, 0x87, 0x85, 0x84, 0x8C, 0x8C, 0x90,
  0x91, 0x91, 0x8E, 0x8E, 0x87, 0x84, 0x85, 0x85,
  0x86, 0x89, 0x86, 0x7F, 0x76, 0x69, 0x59, 0x4D,
  0x3A, 0x35, 0x31, 0x36, 0x3F, 0x40, 0x42, 0x45,
  0x45, 0x46, 0x49, 0x44, 0x49, 0x47, 0x48, 0x44,
  0x47, 0x43, 0x46, 0x49, 0x4B, 0x4B, 0x50, 0x52,
  0x54, 0x5A, 0x58, 0x58, 0x59, 0x5E, 0x5B, 0x5C,
  0x5F, 0x5E, 0x5B, 0x5D, 0x62, 0x5F, 0x5F, 0x5F,
  0x5D, 0x5E, 0x60, 0x5F, 0x63, 0x63, 0x5E, 0x62,
  0x61, 0x60, 0x5E, 0x61, 0x60, 0x60, 0x5E, 0x62,
  0x62, 0x5F, 0x5F, 0x5C, 0x60, 0x61, 0x60, 0x65,
  0x67, 0x68, 0x68, 0x61, 0x5F, 0x5A, 0x58, 0x5A,
  0x5A, 0x58, 0x57, 0x59, 0x5A, 0x5D, 0x5F, 0x60,
  0x5D, 0x5C, 0x5C, 0x5C, 0x5B, 0x5D, 0x5C, 0x5F,
  0x5E, 0x5F, 0x60, 0x60, 0x61, 0x62, 0x63, 0x65,
  0x62, 0x64, 0x64, 0x64, 0x61, 0x60, 0x60, 0x5C,
  0x5E, 0x5F, 0x5E, 0x60, 0x5E, 0x5D, 0x5C, 0x5E,
  0x5D, 0x5B, 0x5D, 0x5D, 0x5B, 0x61, 0x5F, 0x5C,
  0x5F, 0x5C, 0x5B, 0x5B, 0x57, 0x59, 0x56, 0x52,
  0x50, 0x4C, 0x49, 0x4B, 0x4E, 0x55, 0x5E, 0x65,
  0x6D, 0x73, 0x7F, 0x81, 0x85, 0x85, 0x8A, 0x89,
  0x8A, 0x88, 0x86, 0x86, 0x88, 0x84, 0x89, 0x83,
  0x88, 0x84, 0x84, 0x84, 0x82, 0x82, 0x82, 0x81,
  0x83, 0x80, 0x80, 0x7F, 0x7F, 0x85, 0x80, 0x7E,
  0x7D, 0x7D, 0x7E, 0x7D, 0x79, 0x79, 0x77, 0x73,
  0x8B, 0xB6, 0xC7, 0xD0, 0xD3, 0xD5, 0xD8, 0xD8,
  0xD2, 0xBC, 0x86, 0x4A, 0x48, 0x50, 0x52, 0x56,
  0x58, 0x5A, 0x58, 0x5C, 0x5C, 0x59, 0x5B, 0x5B,
  0x5A, 0x5E, 0x5E, 0x5E, 0x5F, 0x64, 0x66, 0x69,
  0x62, 0x49, 0x27, 0x13, 0x0D, 0x14, 0x18, 0x10,
  0x12, 0x12, 0x12, 0x14, 0x14, 0x1C, 0x19, 0x21,
  0x82, 0x83, 0x86, 0x83, 0x83, 0x84, 0x84, 0x86,
  0x86, 0x85, 0x85, 0x89, 0x8A, 0x8F, 0x8F, 0x91,
  0x92, 0x8F, 0x8E, 0x8D, 0x86, 0x85, 0x84, 0x84,
  0x85, 0x8A, 0x88, 0x83, 0x76, 0x69, 0x5E, 0x4E,
  0x3D, 0x39, 0x34, 0x38, 0x3F, 0x40, 0x42, 0x45,
  0x48, 0x47, 0x4C, 0x45, 0x4B, 0x49, 0x46, 0x44,
  0x46, 0x43, 0x45, 0x48, 0x4A, 0x4A, 0x4F, 0x51,
  0x53, 0x55, 0x59, 0x59, 0x5A, 0x5D, 0x5B, 0x59,
  0x5F, 0x5C, 0x5D, 0x5C, 0x61, 0x61, 0x5F, 0x5D,
  0x5D, 0x5B, 0x5F, 0x60, 0x61, 0x62, 0x5E, 0x60,
  0x60, 0x60, 0x5F, 0x61, 0x61, 0x61, 0x60, 0x61,
  0x61, 0x5F, 0x60, 0x5E, 0x61, 0x5C, 0x60, 0x65,
  0x65, 0x64, 0x65, 0x62, 0x60, 0x5F, 0x5B, 0x58,
  0x59, 0x55, 0x59, 0x57, 0x5B, 0x5A, 0x5C, 0x5F,
  0x5E, 0x5C, 0x5C, 0x5D, 0x5D, 0x5A, 0x5C, 0x5D,
  0x5E, 0x5F, 0x64, 0x5E, 0x60, 0x62, 0x61, 0x65,
  0x67, 0x62, 0x64, 0x60, 0x60, 0x5D, 0x5F, 0x5E,
  0x60, 0x61, 0x60, 0x60, 0x61, 0x5E, 0x58, 0x5E,
  0x5C, 0x5A, 0x5D, 0x5B, 0x5B, 0x60, 0x5E, 0x5F,
  0x5F, 0x61, 0x5A, 0x59, 0x55, 0x55, 0x57, 0x54,
  0x4F, 0x4D, 0x4B, 0x4A, 0x4A, 0x55, 0x5F, 0x66,
  0x6A, 0x74, 0x7B, 0x7D, 0x84, 0x84, 0x86, 0x89,
  0x88, 0x87, 0x86, 0x84, 0x88, 0x82, 0x88, 0x84,
  0x88, 0x84, 0x83, 0x83, 0x83, 0x82, 0x81, 0x81,
  0x84, 0x81, 0x7F, 0x7F, 0x82, 0x88, 0x81, 0x83,
  0x7D, 0x7F, 0x7D, 0x7D, 0x7A, 0x7A, 0x77, 0x72,
  0x79, 0x9D, 0xBB, 0xCA, 0xD0, 0xD4, 0xD7, 0xD8,
  0xD8, 0xCD, 0xAE, 0x6D, 0x49, 0x50, 0x50, 0x57,
  0x55, 0x58, 0x54, 0x5B, 0x59, 0x5B, 0x5C, 0x5C,
  0x5E, 0x5D, 0x5C, 0x61, 0x62, 0x66, 0x67, 0x65,
  0x51, 0x27, 0x10, 0x0D, 0x15, 0x14, 0x15, 0x10,
  0x16, 0x13, 0x15, 0x17, 0x17, 0x18, 0x19, 0x23
};



/*
  Macro definitions
*/

#define abs(x)    (x>=0 ? x : -(x))
#define FILTER 0
#define EXPAND 1
#define IS    ==
#define ISNT  !=
#define AND &&
#define OR ||

#define NUM_LEVELS  4


/*
  Forward declaration of functions
*/

void epic_init( void );
void epic_build_pyr( float *image, int x_size, int y_size, int num_levels,
                     float *lo_filter, float *hi_filter, int filter_size );
void epic_build_level( float *image, int level_x_size, int level_y_size,
                       float *lo_filter, float *hi_filter,
                       int filter_size, float *result_block );
void epic_internal_transpose( float *mat, int rows, int cols );
void epic_internal_filter( float *image, int x_dim, int y_dim, float *filt,
                           float *temp, int x_fdim, int y_fdim,
                           int xgrid_start, int xgrid_step, int ygrid_start,
                           int ygrid_step, float *result );
void epic_reflect1( float *filt, int x_dim, int y_dim, int x_pos, int y_pos,
                    float *result, int f_or_e );
void epic_main( void );
//int main( void );


/*
  Declaration of global variables
*/

float epic_filtertemp[FILTER_SIZE*2]; // *2 to work around memory corruption issue
float epic_hi_imagetemp[X_SIZE * Y_SIZE / 2];
float epic_lo_imagetemp[X_SIZE * Y_SIZE / 2];

static float epic_lo_filter[FILTER_SIZE] = {
  -0.0012475221, -0.0024950907, 0.0087309530, 0.0199579580,
  -0.0505290000, -0.1205509700, 0.2930455800,
  0.7061761600,
  0.2930455800, -0.1205509700, -0.0505290000,
  0.0199579580, 0.0087309530, -0.0024950907, -0.0012475221
};

static float epic_hi_filter[FILTER_SIZE] = {
  0.0012475221, -0.0024950907, -0.0087309530, 0.0199579580,
  0.0505290000, -0.1205509700, -0.2930455800,
  0.7061761600,
  -0.2930455800, -0.1205509700, 0.0505290000,
  0.0199579580, -0.0087309530, -0.0024950907, 0.0012475221
};


/*
  Initialization function
*/

void epic_init( void )
{
  int i;

  _Pragma( "loopbound min 4096 max 9801" )
  for ( i = 0; i < X_SIZE * Y_SIZE; ++i )
    epic_image[i] *= SCALE_FACTOR;
}


/*
  Algorithm core functions
*/

/*
  ======================================================================
  epic_build_pyr() -- builds a separable QMF-style pyramid.  The pyramid
  is written over the original image.  NOTE: the image size must be
  divisible by 2^num_levels, but we do not check this here.
  ======================================================================
*/
void epic_build_pyr( float *image, int x_size, int y_size, int num_levels,
                     float *lo_filter, float *hi_filter, int filter_size )
{
  int x_level, y_level, level;

  x_level = x_size;
  y_level = y_size;

  _Pragma( "loopbound min 4 max 4" )
  for ( level = 0;  level < num_levels; ++level ){
    epic_build_level( image, x_level, y_level, lo_filter, hi_filter,
                      filter_size, image );
    x_level /= 2;
    y_level /= 2;
  }
}


/*
  ======================================================================
  epic_build_level() -- builds a level of the pyramid by computing 4
  filtered and subsampled images.  Since the convolution is separable,
  image and result-block can point to the same place!  Image order is
  lowpass, horizontal, vertical (transposed), and diagonal.
  ======================================================================
*/
void epic_build_level( float *image, int level_x_size, int level_y_size,
                       float *lo_filter, float *hi_filter,
                       int filter_size, float *result_block )
{
  int total_size = level_x_size * level_y_size;

  /* filter and subsample in the X direction */
  epic_internal_filter ( image, level_x_size, level_y_size,
                         lo_filter, epic_filtertemp, filter_size, 1,
                         0, 2, 0, 1, epic_lo_imagetemp );
  epic_internal_filter ( image, level_x_size, level_y_size,
                         hi_filter, epic_filtertemp, filter_size, 1,
                         1, 2, 0, 1, epic_hi_imagetemp );

  level_x_size /= 2;
  /* now filter and subsample in the Y direction */
  epic_internal_filter ( epic_lo_imagetemp, level_x_size,
                         level_y_size, /* lowpass */
                         lo_filter, epic_filtertemp, 1, filter_size,
                         0, 1, 0, 2, result_block );
  epic_internal_filter ( epic_lo_imagetemp, level_x_size,
                         level_y_size, /* horizontal */
                         hi_filter, epic_filtertemp, 1, filter_size,
                         0, 1, 1, 2, ( result_block += ( total_size / 4 ) ) );
  epic_internal_filter ( epic_hi_imagetemp, level_x_size,
                         level_y_size, /* vertical */
                         lo_filter, epic_filtertemp, 1, filter_size,
                         0, 1, 0, 2, ( result_block += ( total_size / 4 ) ) );
  /* transpose the vertical band for more efficient scanning */
  epic_internal_transpose( result_block, level_y_size / 2, level_x_size );
  epic_internal_filter ( epic_hi_imagetemp, level_x_size,
                         level_y_size, /* diagonal */
                         hi_filter, epic_filtertemp, 1, filter_size,
                         0, 1, 1, 2, ( result_block += ( total_size / 4 ) ) );
}


/*
  ======================================================================
  In-place matrix tranpose algorithm.  Handles non-square matrices,
  too!  Is there a faster algorithm??
  ======================================================================
*/
void epic_internal_transpose( float *mat, int rows, int cols )
{
  register int swap_pos;
  register int modulus = rows * cols - 1;
  register int current_pos;
  register float swap_val;

  /* loop, ignoring first and last elements */
  _Pragma( "loopbound min 1022 max 2399" )
  for ( current_pos = 1; current_pos < modulus; ++current_pos ) {
    /* Compute swap position */
    swap_pos = current_pos;

    _Pragma( "loopbound min 1 max 2" )
    do {
      swap_pos = ( swap_pos * cols ) % modulus;
    } while ( swap_pos < current_pos );

    if ( current_pos != swap_pos ) {
      swap_val = mat[swap_pos];
      mat[swap_pos] = mat[current_pos];
      mat[current_pos] = swap_val;
    }
  }
}


/* --------------------------------------------------------------------
  Correlate FILT with IMAGE, subsampling according to GRID parameters,
  with values placed into result array.  TEMP is a temporary
  array the size of the filter.  EDGES is a string -- see convolve.h.
  The convolution is done in 9 sections, where the border sections use
  specially computed edge-handling filters (see edges.c). The origin
  of the filter is assumed to be (floor(x_fdim/2), floor(y_fdim/2)).
  10/6/89 - approximately optimized the choice of register vars on SPARCS.
  ------------------------------------------------------------------------ */
void epic_internal_filter( float *image, int x_dim, int y_dim, float *filt,
                           float *temp, int x_fdim, int y_fdim,
                           int xgrid_start, int xgrid_step, int ygrid_start,
                           int ygrid_step, float *result )
{
  //register double sum;
  register float sum;
  register int x_filt, im_pos, y_filt_lin;
  register int y_im_lin, x_pos, filt_size = x_fdim * y_fdim;
  register int y_pos, res_pos;
  register int last_ctr_col = x_dim - x_fdim;
  int last_ctr_row = ( y_dim - y_fdim ) * x_dim;
  int first_row, first_col ;
  int x_fmid = x_fdim / 2;
  int y_fmid = y_fdim / 2;
  int x_stop = x_fdim - x_fmid + 1;
  int y_stop = y_fdim - y_fmid + 1;
  int ygrid_step_full = ygrid_step * x_dim;
  int prev_res_pos, x_res_dim = ( x_dim - xgrid_start + xgrid_step - 1 ) /
                                xgrid_step;
  int rt_edge_res_pos = x_res_dim;

  res_pos = 0;
  first_col = xgrid_start - x_fmid + xgrid_step;

  _Pragma( "loopbound min 1 max 4" )
  for ( y_pos = ygrid_start - y_fmid - 1; y_pos < 0; y_pos += ygrid_step ) {
    _Pragma( "loopbound min 1 max 4" )
    for ( x_pos = xgrid_start - x_fmid;   /* top-left corner */
          x_pos < 0;
          x_pos += xgrid_step ) {
      epic_reflect1( filt, x_fdim, y_fdim, x_pos, y_pos, temp, FILTER );
      sum = 0.0f;
      x_filt = y_im_lin = 0;
      _Pragma( "loopbound min 1 max 15" )
      for ( y_filt_lin = x_fdim; y_filt_lin <= filt_size;
            y_filt_lin += x_fdim ) {
        im_pos = y_im_lin;

        _Pragma( "loopbound min 1 max 15" )
        for ( ; x_filt < y_filt_lin; ++x_filt ) {
          sum += image[im_pos] * temp[x_filt];
          ++im_pos;
        }
        y_im_lin += x_dim;
      }
      result[res_pos] = sum;
      ++res_pos;
    }
    first_col = x_pos + 1;
    epic_reflect1( filt, x_fdim, y_fdim, 0, y_pos, temp, FILTER );
    _Pragma( "loopbound min 41 max 46" )
    for ( x_pos = first_col;          /* top edge */
          x_pos < last_ctr_col;
          x_pos += xgrid_step ) {
      sum = 0.0f;
      x_filt = y_im_lin = 0;
      _Pragma( "loopbound min 1 max 15" )
      for ( y_filt_lin = x_fdim; y_filt_lin <= filt_size;
            y_filt_lin += x_fdim ) {
        im_pos = x_pos + y_im_lin;
        _Pragma( "loopbound min 1 max 15" )
        for ( ; x_filt < y_filt_lin; ++x_filt ) {
          sum += image[im_pos] * temp[x_filt];
          ++im_pos;
        }
        y_im_lin += x_dim;
      }
      result[res_pos] = sum;
      ++res_pos;
    }
    rt_edge_res_pos = res_pos + x_res_dim;   /* save this for later ... */
    _Pragma( "loopbound min 1 max 4" )
    for ( x_pos += ( 1 - last_ctr_col );  /* top-right corner */
          x_pos < x_stop;
          x_pos += xgrid_step ) {
      epic_reflect1( filt, x_fdim, y_fdim, x_pos, y_pos, temp, FILTER );
      sum = 0.0f;
      x_filt = y_im_lin = 0;
      _Pragma( "loopbound min 1 max 15" )
      for ( y_filt_lin = x_fdim; y_filt_lin <= filt_size;
            y_filt_lin += x_fdim ) {
        im_pos = y_im_lin + last_ctr_col;

        _Pragma( "loopbound min 1 max 15" )
        for ( ; x_filt < y_filt_lin; ++x_filt ) {
          sum += image[im_pos] * temp[x_filt];
          ++im_pos;
        }
        y_im_lin += x_dim;
      }
      result[res_pos] = sum;
      ++res_pos;
    }
  }                        /* end top */

  first_row = x_dim * ( y_pos + 1 ); /* need this to go down the sides */
  prev_res_pos = res_pos;
  _Pragma( "loopbound min 1 max 4" )
  for ( x_pos = xgrid_start - x_fmid;      /* left edge */
        x_pos < 1;
        x_pos += xgrid_step ) {
    res_pos = prev_res_pos;
    epic_reflect1( filt, x_fdim, y_fdim, x_pos, 0, temp, FILTER );
    _Pragma( "loopbound min 41 max 97" )
    for ( y_pos = first_row; y_pos < last_ctr_row;
          y_pos += ygrid_step_full ) {
      sum = 0.0f;
      x_filt = 0, y_im_lin = y_pos;
      _Pragma( "loopbound min 1 max 15" )
      for ( y_filt_lin = x_fdim; y_filt_lin <= filt_size;
            y_filt_lin += x_fdim ) {
        im_pos = y_im_lin;
        _Pragma( "loopbound min 1 max 15" )
        for ( ; x_filt < y_filt_lin; x_filt++ ) {
          sum += image[im_pos] * temp[x_filt];
          ++im_pos;
        }
        y_im_lin += x_dim;
      }
      result[res_pos] = sum;
      res_pos += x_res_dim;
    }
    prev_res_pos++;
  }
  epic_reflect1( filt, x_fdim, y_fdim, 0, 0, temp, FILTER );
  _Pragma( "loopbound min 41 max 97" )
  for ( y_pos = first_row; /* center region of image */
        y_pos < last_ctr_row;
        y_pos += ygrid_step_full ) {
    res_pos = prev_res_pos;
    _Pragma( "loopbound min 41 max 46" )
    for ( x_pos = first_col;
          x_pos < last_ctr_col;
          x_pos += xgrid_step ) {
      sum = 0.0f;
      x_filt = 0, y_im_lin = y_pos;
      _Pragma( "loopbound min 1 max 15" )
      for ( y_filt_lin = x_fdim; y_filt_lin <= filt_size;
            y_filt_lin += x_fdim ) {
        im_pos = x_pos + y_im_lin;
        _Pragma( "loopbound min 1 max 15" )
        for ( ; x_filt < y_filt_lin; ++x_filt ) {
          sum += image[im_pos] * temp[x_filt];
          ++im_pos;
        }
        y_im_lin += x_dim;
      }
      result[res_pos] = sum;
      ++res_pos;
    }
    prev_res_pos += x_res_dim;
  }
  prev_res_pos = rt_edge_res_pos;
  _Pragma( "loopbound min 1 max 4" )
  for ( x_pos += ( 1 - last_ctr_col );           /* right edge */
        x_pos < x_stop;
        x_pos += xgrid_step ) {
    res_pos = prev_res_pos;
    epic_reflect1( filt, x_fdim, y_fdim, x_pos, 0, temp, FILTER );
    _Pragma( "loopbound min 41 max 97" )
    for ( y_pos = first_row; y_pos < last_ctr_row;
          y_pos += ygrid_step_full ) {
      sum = 0.0f;
      x_filt = 0, y_im_lin = y_pos;
      _Pragma( "loopbound min 1 max 15" )
      for ( y_filt_lin = x_fdim;
            y_filt_lin <= filt_size;
            y_filt_lin += x_fdim ) {
        _Pragma( "loopbound min 1 max 15" )
        for ( im_pos = y_im_lin + last_ctr_col;
              x_filt < y_filt_lin;
              ++x_filt ) {
          sum += image[im_pos] * temp[x_filt];
          ++im_pos;
        }
        y_im_lin += x_dim;
      }
      result[res_pos] = sum;
      res_pos += x_res_dim;
    }
    prev_res_pos++;
  }       /* end mid */

  res_pos -= ( x_res_dim - 1 );          /* go to lower left corner */
  _Pragma( "loopbound min 1 max 4" )
  for ( y_pos = ( ( y_pos - last_ctr_row ) / x_dim ) + 1; /* bottom */
        y_pos < y_stop;
        y_pos += ygrid_step ) {
    _Pragma( "loopbound min 1 max 4" )
    for ( x_pos = xgrid_start - x_fmid;    /* bottom-left corner */
          x_pos < 1;
          x_pos += xgrid_step ) {
      epic_reflect1( filt, x_fdim, y_fdim, x_pos, y_pos, temp, FILTER );
      sum = 0.0f;
      x_filt = 0, y_im_lin = last_ctr_row;
      _Pragma( "loopbound min 1 max 15" )
      for ( y_filt_lin = x_fdim; y_filt_lin <= filt_size;
            y_filt_lin += x_fdim ) {
        _Pragma( "loopbound min 1 max 15" )
        for ( im_pos = y_im_lin;
              x_filt < y_filt_lin;
              ++x_filt ) {
          sum += image[im_pos] * temp[x_filt];
          ++im_pos;
        }
        y_im_lin += x_dim;
      }
      result[res_pos] = sum;
      ++res_pos;
    }
    epic_reflect1( filt, x_fdim, y_fdim, 0, y_pos, temp, FILTER );
    _Pragma( "loopbound min 41 max 46" )
    for ( x_pos = first_col;        /* bottom edge */
          x_pos < last_ctr_col;
          x_pos += xgrid_step ) {
      sum = 0.0f;
      x_filt = 0, y_im_lin = last_ctr_row;
      _Pragma( "loopbound min 1 max 15" )
      for ( y_filt_lin = x_fdim; y_filt_lin <= filt_size;
            y_filt_lin += x_fdim ) {
        _Pragma( "loopbound min 1 max 15" )
        for ( im_pos = x_pos + y_im_lin;
              x_filt < y_filt_lin;
              ++x_filt ) {
          sum += image[im_pos] * temp[x_filt];
          ++im_pos;
        }
        y_im_lin += x_dim;
      }
      result[res_pos] = sum;
      ++res_pos;
    }
    _Pragma( "loopbound min 1 max 4" )
    for ( x_pos += 1 - last_ctr_col; /* bottom-right corner */
          x_pos < x_stop;
          x_pos += xgrid_step ) {
      epic_reflect1( filt, x_fdim, y_fdim, x_pos, y_pos, temp, FILTER );
      sum = 0.0f;
      x_filt = 0, y_im_lin = last_ctr_row;
      _Pragma( "loopbound min 1 max 15" )
      for ( y_filt_lin = x_fdim; y_filt_lin <= filt_size;
            y_filt_lin += x_fdim ) {
        _Pragma( "loopbound min 1 max 15" )
        for ( im_pos = y_im_lin + last_ctr_col;
              x_filt < y_filt_lin;
              ++x_filt ) {
          sum += image[im_pos] * temp[x_filt];
          ++im_pos;
        }
        y_im_lin += x_dim;
      }
      result[res_pos] = sum;
      ++res_pos;
    }
  }       /* end bottom */

}     /* end of epic_internal_filter */


/*
  The following function determine how edges are to be handled
  when performing convolutions of images with linear filters.
  Any edge handling function which is local and linear may be defined,
  except (unfortunately) constants cannot be added.  So to treat the
  edges as if the image is surrounded by a gray field, you must paste it
  into a gray image, convolve, and crop it out...
  The main convolution function is called epic_internal_filter.  The idea
  is that the convolution function calls the edge handling function which
  computes a new filter based on the old filter and the distance to the
  edge of the image.  For example, reflection is done by reflecting the
  filter through the appropriate axis and summing.
*/

/*
  ---------------- EDGE HANDLER ARGUMENTS ------------------------
  filt - floating point array of filter taps.
  x_dim, y_dim - x and y dimensions of filt.
  x_pos - position of filter relative to the horizontal image edges. Negative
       values indicate left edge, positive indicate right edge.  Zero
       indicates that the filter is not touching either edge.  An absolute
       value of 1 indicates that the edge tap of the filter is over the
       edge pixel of the image.
  y_pos - analogous to x_pos.
  result - floating point array where the resulting filter will go.  The edge
       of this filter will be aligned with the image for application...
  f_or_e - equal to one of the two constants EXPAND or FILTER.
  --------------------------------------------------------------------
*/

/* --------------------------------------------------------------------
  epic_reflect1() - Reflection through the edge pixels.  This is the right
  thing to do if you are subsampling by 2, since it maintains parity (even
  pixels positions remain even, odd ones remain odd). (note: procedure differs
  depending on f_or_e parameter).  */
void epic_reflect1( float *filt, int x_dim, int y_dim, int x_pos, int y_pos,
                    float *result, int f_or_e )
{
  int filt_sz = x_dim * y_dim;
  register int x_start = 0, y_start = 0, x_stop = x_dim, y_stop = filt_sz;
  register int y_filt, x_filt, y_edge, x_edge;
  register int x_base = ( x_pos > 0 ) ? ( x_dim - 1 ) : 0;
  register int y_base = ( y_pos > 0 ) ? ( x_dim * ( y_dim - 1 ) ) : 0;
  int x_edge_dist = ( x_pos > 0 ) ? ( x_pos - x_dim ) : ( ( x_pos < -1 ) ?
                    ( x_pos + 1 ) : 0 );
  int y_edge_dist = x_dim * ( ( y_pos > 0 ) ? ( y_pos - y_dim ) : ( (
                                y_pos < -1 ) ? ( y_pos + 1 ) : 0 ) );
  int i;
  int mx_pos = ( x_dim / 2 ) + 1;
  int my_pos = ( y_dim / 2 ) + 1;

  _Pragma( "loopbound min 15 max 15" )
  for ( i = 0; i < filt_sz; ++i ) result[i] = 0.0f;

  /* if EXPAND and filter is centered on image edge, do not reflect */
  if ( f_or_e IS EXPAND ) {
    if ( x_pos IS mx_pos ) x_stop = ( x_dim + 1 ) / 2;
    else
      if ( x_pos IS - mx_pos ) {
        x_start = x_dim / 2;
        x_edge_dist = 0;
      }

    if ( y_pos IS my_pos ) y_stop = x_dim * ( ( y_dim + 1 ) / 2 );
    else
      if ( y_pos IS - my_pos ) {
        y_start = x_dim * ( y_dim / 2 );
        y_edge_dist = 0;
      }
  }

  y_edge = y_edge_dist;
  /* reflect at boundary of image */
  _Pragma( "loopbound min 1 max 15" )
  for ( y_filt = y_start; y_filt < y_stop; y_filt += x_dim ) {
    x_edge = x_edge_dist;
    _Pragma( "loopbound min 1 max 15" )
    for ( x_filt = y_filt + x_start; x_filt < y_filt + x_stop; ++x_filt ) {
      result[abs( y_base - abs( y_edge ) ) + abs( x_base - abs( x_edge ) )]
      += filt[x_filt];
      ++x_edge;
    }
    y_edge += x_dim;
  }

  /* if EXPAND and filter is not centered on image edge, mult edge by 2 */
  if ( f_or_e IS EXPAND ) {
    if ( ( abs( x_pos ) ISNT mx_pos ) AND ( x_pos ISNT 0 ) )
      _Pragma( "loopbound min 0 max 0" )
      for ( y_filt = x_base; y_filt < filt_sz; y_filt += x_dim )
        result[y_filt] += result[y_filt];
    if ( ( abs( y_pos ) ISNT my_pos ) AND ( y_pos ISNT 0 ) )
      _Pragma( "loopbound min 0 max 0" )
      for ( x_filt = y_base; x_filt < y_base + x_dim; ++x_filt )
        result[x_filt] += result[x_filt];
  }
}


/*
  Main functions
*/

void _Pragma( "entrypoint" ) epic_main( void )
{
  epic_build_pyr( epic_image, X_SIZE, Y_SIZE, NUM_LEVELS, epic_lo_filter,
                  epic_hi_filter, FILTER_SIZE );
}

int epic_return(){
  int i;
  int checksum = 0;
  for ( i=0 ; i<X_SIZE*Y_SIZE ; i+=Y_SIZE+1 ){
    checksum += epic_image[i];
  }
  return ( checksum == 43968 ? 0 : 1);
}

int main( int argc, char **argv )
{
  int exit_code = -1;
  SET_UP
  for (jobsComplete=0; jobsComplete<maxJobs; jobsComplete++){
    START_LOOP
    epic_init();
    epic_main();
    // This checks the checksum is as expected.
    // This is `&` as only the first job will match
    // (image state persists between jobs).
    exit_code &= epic_return();
    STOP_LOOP
  }
  WRITE_TO_FILE
  return exit_code;
}