christoph/failnix
1
Fork 0
Code Releases Activity
Files
b9ff08db1667c87a5f672bd7f595a06b2a241981
failnix/targets/wasm-tacle/sequential/epic/epic.c

1137 lines
46 KiB
C
Executable File
Raw Blame History

/*
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 "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 ];
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 4096" )
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 14 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;
_Pragma( "loopbound min 64 max 64" )
for ( i = 0 ; i < X_SIZE * Y_SIZE ; i += Y_SIZE + 1 )
checksum += epic_image[ i ];
return ( checksum == 43968 ? 0 : 1 );
}
int main( void )
{
epic_init();
epic_main();
return epic_return();
}
View Git Blame Copy Permalink