Reorganize and commit all the modified TACLeBench code and run scripts

3 files changed, 1269 insertions, 0 deletions

diff --git a/baseline/source/epic/ChangeLog.txt b/baseline/source/epic/ChangeLog.txt
new file mode 100644
index 0000000..5aad4f5
--- /dev/null
+++ b/baseline/source/epic/ChangeLog.txt
@@ -0,0 +1,56 @@
+Files: epic.c epic_data.h epic_data.c
+Original provenience: MediaBench benchmark suite,
+                      http://euler.slu.edu/~fritts/mediabench/mb1/index.html
+
+2016-02-03:
+- Added TACLeBench header, also kept original copyright notice
+- Removed commented-out code
+- Removed seemingly unnecessary empty lines
+- Removed unused function, variable, macro and type declarations except where
+  they may help understanding the program.
+- Slightly changed wording of original comments to keep them in line with the
+  modified/removed code parts.
+- Separated epic.c to epic.c and epic.h
+- Added proper '#ifndef __EPIC_DATA_H_' and friends to epic_data.h
+- Moved around all the following so that they are in the given order just after
+the header
+  - macro definitions
+  - forward declaration of functions
+  - declaration of global variables
+- Added a new main function that first calls init function then the old main
+  function sans init
+- Annotated epic_main() as the entry point of the analysis
+- Applied code formatting according to the following rules
+  - Lines shall not be wider than 80 characters; whenever possible, appropriate
+    line breaks shall be inserted to keep lines below 80 characters
+  - Indentation is done using whitespaces only, no tabs. Code is indented by
+    two whitespaces
+  - Two empty lines are put between any two functions
+  - In non-empty lists or index expressions, opening '(' and '[' are followed by
+    one whitespace, closing ')' and ']' are preceded by one whitespace
+  - In comma- or colon-separated argument lists, one whitespace is put after
+    each comma/colon
+  - Names of functions and global variables all start with a benchmark-specific
+  prefix (here: epic_) followed by lowercase letter
+  - For pointer types, one whitespace is put before the '*'
+  - Operators within expressions shall be preceded and followed by one
+    whitespace
+  - Code of then- and else-parts of if-then-else statements shall be put in
+    separate lines, not in the same lines as the if-condition or the keyword
+    "else"
+  - Opening braces '{' denoting the beginning of code for some if-else or loop
+    body shall be put at the end of the same line where the keywords "if",
+    "else", "for", "while" etc. occur
+
+2016-10-10:
+- removed unused parameter 'char *edges' in epic_internal_filter()
+- included input data definition in epic.c, and removed epic_data.c and epic_data.h
+
+2016-10-12:
+- added initial value to variable 'rt_edge_res_pos' (in case the first for loop
+at line 775) is not executed)
+- added initial value to variable 'first_col' (in case the first for loop
+at line 775) is not executed)
+
+2016-10_14:
+- added epic_return() function
diff --git a/baseline/source/epic/epic.c b/baseline/source/epic/epic.c
new file mode 100644
index 0000000..13ba442
--- /dev/null
+++ b/baseline/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<X_SIZE*Y_SIZE ; i+=Y_SIZE+1 ){
+    checksum += epic_image[i];
+  }
+  return ( checksum == 43968 ? 0 : 1);
+}
+
+int main( int argc, char **argv )
+{
+        SET_UP
+        for (jobsComplete=-1; jobsComplete<maxJobs; jobsComplete++){
+                START_LOOP
+                epic_init();
+                epic_main();
+                STOP_LOOP
+        }
+        WRITE_TO_FILE
+  return epic_return();
+}
diff --git a/baseline/source/epic/epic.h b/baseline/source/epic/epic.h
new file mode 100644
index 0000000..5e5675f
--- /dev/null
+++ b/baseline/source/epic/epic.h
@@ -0,0 +1,72 @@
+#ifndef __EPIC_H_
+#define __EPIC_H_
+
+#define EPIC_VERSION 1.1
+
+/* ============= FUNDAMENTAL LIMITATIONS ============= */
+
+/* Maximum x- or y-size of image */
+#define MAX_IMAGE_DIM 16384
+
+/* Maximum number of pyramid levels (value 3*levs+1 stored in 5 bits).
+   This doesn't need to be larger than log2(MAX_IMAGE_DIM/FILTER_SIZE). */
+#define MAX_LEVELS 10
+
+/* Maximum number of quantization bins.  This essentially determines
+   the maximum depth image to be represented. */
+#define MAX_BINS 511
+
+/* ============= SECONDARY (derived) LIMITATIONS ============= */
+
+/* This number determines the precision of the stored binsizes:
+   stored coefficients are accurate to +/- (1/SCALE_FACTOR).
+   On the other hand, this number also will limit the maximum amount
+   of compression.
+   It should not be more than [2^(8*sizeof(BinValueType))]/256. */
+#define SCALE_FACTOR 128
+
+/* This number must be consistent with the filters that are
+   hardwired into epic.c */
+#define FILTER_SIZE 15
+
+/* Log (base 2) of MAX_IMAGE_DIM^2: (bits required to store the dimensions) */
+#define LOG_MAX_IMAGE_SIZE 32
+
+/* The type of the quantized images. Must be SIGNED, and capable of holding
+   values  in the range [-MAX_BINS, MAX_BINS] */
+typedef short BinIndexType;
+
+/* The type used to represent the binsizes. Should be UNSIGNED. If this is
+   changed, be sure to change the places in epic.c and unepic.c where
+   binsizes are written or read from files.  */
+typedef unsigned short BinValueType;
+
+/* Number of possible values for a symbol.  This must be at least
+   (MAX_BINS * 4)  (one sign bit, one tag bit)... */
+#define NUM_SYMBOL_VALUES 65536
+
+/* Function prototypes. */
+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( register float *mat, int rows,
+                              register int cols );
+
+void epic_reflect1( register float *filt, register int x_dim, int y_dim,
+                    int x_pos, int y_pos, register float *result, int f_or_e );
+
+void epic_internal_filter( register float *image, register int x_dim,
+                           register int y_dim, float *filt,
+                           register float *temp, register int x_fdim,
+                           register int y_fdim, int xgrid_start,
+                           int xgrid_step, int ygrid_start, int ygrid_step,
+                           register 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 );
+
+#endif // __EPIC_H_