christoph/failnix
1
Fork 0
Code Releases Activity

Add wasm tacle-bench targets

Browse Source
This commit is contained in:
Christoph Urlacher
2026-06-12 20:06:22 +02:00
parent 30daa8a00c
commit 08c2e9c13d
1122 changed files with 520422 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

BIN
targets/wasm-tacle/sequential/epic/generated/default/epic.wasm Executable file
View File

Binary file not shown.

4079
targets/wasm-tacle/sequential/epic/generated/default/epic.wat Normal file
View File

File diff suppressed because one or more lines are too long

940
targets/wasm-tacle/sequential/epic/generated/modified_sources/default/epic.c Normal file
View File

@ -0,0 +1,940 @@
/*
This program is part of the TACLeBench benchmark suite.
Version V 2.0
Name: epic
Author: Designed by Eero P. Simoncelli and Edward H. Adelson
Written by Eero P. Simoncelli
Developed at the Vision Science Group, The Media Laboratory
Copyright 1989, Massachusetts Institute of Technology
All rights reserved.
Function: Efficient Pyramid Image Coder
Source: MediaBench
Original name: epic
Changes: no major functional changes
License:
Permission to use, copy, or modify this software and its documentation
for educational and research purposes only and without fee is hereby
granted, provided that this copyright notice appear on all copies and
supporting documentation. For any other uses of this software, in
original or modified form, including but not limited to distribution
in whole or in part, specific prior permission must be obtained from
M.I.T. and the authors. These programs shall not be used, rewritten,
or adapted as the basis of a commercial software or hardware product
without first obtaining appropriate licenses from M.I.T. M.I.T. makes
no representations about the suitability of this software for any
purpose. It is provided "as is" without express or implied warranty.
*/
#include "epic.h"
// Wasm loop bounds
__attribute__((import_module("__pragma"), import_name("loopbound"))) extern void
__pragma_loopbound(unsigned int min_bound, unsigned int max_bound);
#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);
__attribute__((noinline)) __attribute__((export_name("entrypoint"))) void
epic_main(void);
__attribute__((noinline)) __attribute__((export_name("main"))) 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(4096, 4096);
for (i = 0; i < X_SIZE * Y_SIZE; ++i)
epic_image[i] *= SCALE_FACTOR;
}
/*
Algorithm core functions
*/
/*
======================================================================
epic_build_pyr() -- builds a separable QMF-style pyramid. The pyramid
is written over the original image. NOTE: the image size must be
divisible by 2^num_levels, but we do not check this here.
======================================================================
*/
void
epic_build_pyr(float *image, int x_size, int y_size, int num_levels,
float *lo_filter, float *hi_filter, int filter_size) {
int x_level, y_level, level;
x_level = x_size;
y_level = y_size;
__pragma_loopbound(4, 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(14, 2399);
for (current_pos = 1; current_pos < modulus; ++current_pos) {
/* Compute swap position */
swap_pos = current_pos;
__pragma_loopbound(1, 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(1, 4);
for (y_pos = ygrid_start - y_fmid - 1; y_pos < 0; y_pos += ygrid_step) {
__pragma_loopbound(1, 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(1, 15);
for (y_filt_lin = x_fdim; y_filt_lin <= filt_size;
y_filt_lin += x_fdim) {
im_pos = y_im_lin;
__pragma_loopbound(1, 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(41, 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(1, 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(1, 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(1, 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(1, 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(1, 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(41, 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(1, 15);
for (y_filt_lin = x_fdim; y_filt_lin <= filt_size;
y_filt_lin += x_fdim) {
im_pos = y_im_lin;
__pragma_loopbound(1, 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(41, 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(41, 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(1, 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(1, 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(1, 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(41, 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(1, 15);
for (y_filt_lin = x_fdim; y_filt_lin <= filt_size;
y_filt_lin += x_fdim) {
__pragma_loopbound(1, 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(1, 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(1, 15);
for (y_filt_lin = x_fdim; y_filt_lin <= filt_size;
y_filt_lin += x_fdim) {
__pragma_loopbound(1, 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(41, 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(1, 15);
for (y_filt_lin = x_fdim; y_filt_lin <= filt_size;
y_filt_lin += x_fdim) {
__pragma_loopbound(1, 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(1, 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(1, 15);
for (y_filt_lin = x_fdim; y_filt_lin <= filt_size;
y_filt_lin += x_fdim) {
__pragma_loopbound(1, 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(15, 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(1, 15);
for (y_filt = y_start; y_filt < y_stop; y_filt += x_dim) {
x_edge = x_edge_dist;
__pragma_loopbound(1, 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(0, 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(0, 0);
for (x_filt = y_base; x_filt < y_base + x_dim; ++x_filt)
result[x_filt] += result[x_filt];
}
}
/*
Main functions
*/
__attribute__((noinline)) __attribute__((export_name("entrypoint"))) void
epic_main(void) {
epic_build_pyr(epic_image, X_SIZE, Y_SIZE, NUM_LEVELS, epic_lo_filter,
epic_hi_filter, FILTER_SIZE);
}
int
epic_return() {
int i;
int checksum = 0;
__pragma_loopbound(64, 64);
for (i = 0; i < X_SIZE * Y_SIZE; i += Y_SIZE + 1)
checksum += epic_image[i];
return (checksum == 43968 ? 0 : 1);
}
__attribute__((noinline)) __attribute__((export_name("main"))) int
main(void) {
epic_init();
epic_main();
return epic_return();
}

71
targets/wasm-tacle/sequential/epic/generated/modified_sources/default/epic.h Normal file
View File

@ -0,0 +1,71 @@
#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_

953
targets/wasm-tacle/sequential/epic/generated/modified_sources/inline/epic.c Normal file
View File

@ -0,0 +1,953 @@
/*
This program is part of the TACLeBench benchmark suite.
Version V 2.0
Name: epic
Author: Designed by Eero P. Simoncelli and Edward H. Adelson
Written by Eero P. Simoncelli
Developed at the Vision Science Group, The Media Laboratory
Copyright 1989, Massachusetts Institute of Technology
All rights reserved.
Function: Efficient Pyramid Image Coder
Source: MediaBench
Original name: epic
Changes: no major functional changes
License:
Permission to use, copy, or modify this software and its documentation
for educational and research purposes only and without fee is hereby
granted, provided that this copyright notice appear on all copies and
supporting documentation. For any other uses of this software, in
original or modified form, including but not limited to distribution
in whole or in part, specific prior permission must be obtained from
M.I.T. and the authors. These programs shall not be used, rewritten,
or adapted as the basis of a commercial software or hardware product
without first obtaining appropriate licenses from M.I.T. M.I.T. makes
no representations about the suitability of this software for any
purpose. It is provided "as is" without express or implied warranty.
*/
#include "epic.h"
// Wasm loop bounds
__attribute__((import_module("__pragma"), import_name("loopbound"))) extern void
__pragma_loopbound(unsigned int min_bound, unsigned int max_bound);
#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
*/
__attribute__((always_inline)) static inline void epic_init(void);
__attribute__((always_inline)) static inline void
epic_build_pyr(float *image, int x_size, int y_size, int num_levels,
float *lo_filter, float *hi_filter, int filter_size);
__attribute__((always_inline)) static inline 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);
__attribute__((always_inline)) static inline void
epic_internal_transpose(float *mat, int rows, int cols);
__attribute__((always_inline)) static inline 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);
__attribute__((always_inline)) static inline void
epic_reflect1(float *filt, int x_dim, int y_dim, int x_pos, int y_pos,
float *result, int f_or_e);
__attribute__((noinline)) __attribute__((export_name("entrypoint")))
__attribute__((noinline)) __attribute__((export_name("entrypoint"))) void
epic_main(void);
__attribute__((noinline)) __attribute__((export_name("main")))
__attribute__((noinline)) __attribute__((export_name("main"))) 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
*/
__attribute__((always_inline)) static inline void
epic_init(void) {
int i;
__pragma_loopbound(4096, 4096);
for (i = 0; i < X_SIZE * Y_SIZE; ++i)
epic_image[i] *= SCALE_FACTOR;
}
/*
Algorithm core functions
*/
/*
======================================================================
epic_build_pyr() -- builds a separable QMF-style pyramid. The pyramid
is written over the original image. NOTE: the image size must be
divisible by 2^num_levels, but we do not check this here.
======================================================================
*/
__attribute__((always_inline)) static inline 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(4, 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.
======================================================================
*/
__attribute__((always_inline)) static inline 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??
======================================================================
*/
__attribute__((always_inline)) static inline 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(14, 2399);
for (current_pos = 1; current_pos < modulus; ++current_pos) {
/* Compute swap position */
swap_pos = current_pos;
__pragma_loopbound(1, 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.
------------------------------------------------------------------------ */
__attribute__((always_inline)) static inline 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(1, 4);
for (y_pos = ygrid_start - y_fmid - 1; y_pos < 0; y_pos += ygrid_step) {
__pragma_loopbound(1, 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(1, 15);
for (y_filt_lin = x_fdim; y_filt_lin <= filt_size;
y_filt_lin += x_fdim) {
im_pos = y_im_lin;
__pragma_loopbound(1, 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(41, 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(1, 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(1, 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(1, 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(1, 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(1, 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(41, 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(1, 15);
for (y_filt_lin = x_fdim; y_filt_lin <= filt_size;
y_filt_lin += x_fdim) {
im_pos = y_im_lin;
__pragma_loopbound(1, 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(41, 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(41, 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(1, 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(1, 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(1, 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(41, 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(1, 15);
for (y_filt_lin = x_fdim; y_filt_lin <= filt_size;
y_filt_lin += x_fdim) {
__pragma_loopbound(1, 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(1, 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(1, 15);
for (y_filt_lin = x_fdim; y_filt_lin <= filt_size;
y_filt_lin += x_fdim) {
__pragma_loopbound(1, 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(41, 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(1, 15);
for (y_filt_lin = x_fdim; y_filt_lin <= filt_size;
y_filt_lin += x_fdim) {
__pragma_loopbound(1, 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(1, 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(1, 15);
for (y_filt_lin = x_fdim; y_filt_lin <= filt_size;
y_filt_lin += x_fdim) {
__pragma_loopbound(1, 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). */
__attribute__((always_inline)) static inline 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(15, 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(1, 15);
for (y_filt = y_start; y_filt < y_stop; y_filt += x_dim) {
x_edge = x_edge_dist;
__pragma_loopbound(1, 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(0, 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(0, 0);
for (x_filt = y_base; x_filt < y_base + x_dim; ++x_filt)
result[x_filt] += result[x_filt];
}
}
/*
Main functions
*/
__attribute__((noinline)) __attribute__((export_name("entrypoint")))
__attribute__((noinline)) __attribute__((export_name("entrypoint"))) void
epic_main(void) {
epic_build_pyr(epic_image, X_SIZE, Y_SIZE, NUM_LEVELS, epic_lo_filter,
epic_hi_filter, FILTER_SIZE);
}
__attribute__((always_inline)) static inline int
epic_return() {
int i;
int checksum = 0;
__pragma_loopbound(64, 64);
for (i = 0; i < X_SIZE * Y_SIZE; i += Y_SIZE + 1)
checksum += epic_image[i];
return (checksum == 43968 ? 0 : 1);
}
__attribute__((noinline)) __attribute__((export_name("main")))
__attribute__((noinline)) __attribute__((export_name("main"))) int
main(void) {
epic_init();
epic_main();
return epic_return();
}

77
targets/wasm-tacle/sequential/epic/generated/modified_sources/inline/epic.h Normal file
View File

@ -0,0 +1,77 @@
#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. */
__attribute__((always_inline)) static inline void
epic_build_pyr(float *image, int x_size, int y_size, int num_levels,
float *lo_filter, float *hi_filter, int filter_size);
__attribute__((always_inline)) static inline 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);
__attribute__((always_inline)) static inline void
epic_internal_transpose(register float *mat, int rows, register int cols);
__attribute__((always_inline)) static inline 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);
__attribute__((always_inline)) static inline 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);
__attribute__((always_inline)) static inline 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_