From 386b7d3366f1359a265da207a9cafa3edf553b64 Mon Sep 17 00:00:00 2001 From: Joshua Bakita Date: Mon, 7 Oct 2019 19:13:39 -0400 Subject: Reorganize and commit all the modified TACLeBench code and run scripts --- all_pairs/source/epic/epic.c | 1141 ++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 1141 insertions(+) create mode 100644 all_pairs/source/epic/epic.c (limited to 'all_pairs/source/epic/epic.c') diff --git a/all_pairs/source/epic/epic.c b/all_pairs/source/epic/epic.c new file mode 100644 index 0000000..13ba442 --- /dev/null +++ b/all_pairs/source/epic/epic.c @@ -0,0 +1,1141 @@ +/* + + 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]; +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