/* This program is part of the TACLeBench benchmark suite. Version V 2.0 Name: epic Author: Designed by Eero P. Simoncelli and Edward H. Adelson Written by Eero P. Simoncelli Developed at the Vision Science Group, The Media Laboratory Copyright 1989, Massachusetts Institute of Technology All rights reserved. Function: Efficient Pyramid Image Coder Source: MediaBench Original name: epic Changes: no major functional changes License: Permission to use, copy, or modify this software and its documentation for educational and research purposes only and without fee is hereby granted, provided that this copyright notice appear on all copies and supporting documentation. For any other uses of this software, in original or modified form, including but not limited to distribution in whole or in part, specific prior permission must be obtained from M.I.T. and the authors. These programs shall not be used, rewritten, or adapted as the basis of a commercial software or hardware product without first obtaining appropriate licenses from M.I.T. M.I.T. makes no representations about the suitability of this software for any purpose. It is provided "as is" without express or implied warranty. */ #include "extra.h" #include "epic.h" #define X_SIZE 64 #define Y_SIZE 64 float epic_image[] = { 0x89, 0x88, 0x87, 0x86, 0x89, 0x87, 0x84, 0x86, 0x83, 0x89, 0x82, 0x83, 0x84, 0x81, 0x80, 0x80, 0x81, 0x83, 0x88, 0x8A, 0x8E, 0x90, 0x96, 0x98, 0x95, 0x92, 0x93, 0x88, 0x78, 0x7B, 0x60, 0x52, 0x41, 0x3F, 0x3A, 0x46, 0x46, 0x48, 0x49, 0x48, 0x4F, 0x4A, 0x49, 0x50, 0x4C, 0x4B, 0x4D, 0x4C, 0x4E, 0x4E, 0x4A, 0x49, 0x4D, 0x54, 0x50, 0x59, 0x51, 0x5A, 0x5E, 0x5A, 0x5D, 0x61, 0x59, 0x65, 0x63, 0x65, 0x60, 0x62, 0x68, 0x67, 0x64, 0x61, 0x64, 0x5E, 0x66, 0x63, 0x63, 0x61, 0x67, 0x68, 0x62, 0x64, 0x66, 0x67, 0x64, 0x63, 0x66, 0x64, 0x67, 0x66, 0x65, 0x64, 0x64, 0x6A, 0x66, 0x65, 0x68, 0x66, 0x69, 0x67, 0x6A, 0x66, 0x68, 0x66, 0x6C, 0x65, 0x69, 0x64, 0x65, 0x64, 0x66, 0x62, 0x63, 0x68, 0x68, 0x65, 0x64, 0x64, 0x62, 0x63, 0x68, 0x65, 0x66, 0x69, 0x66, 0x65, 0x61, 0x66, 0x6E, 0x69, 0x64, 0x61, 0x63, 0x63, 0x66, 0x63, 0x62, 0x64, 0x60, 0x68, 0x63, 0x61, 0x62, 0x65, 0x60, 0x63, 0x60, 0x62, 0x60, 0x5E, 0x61, 0x62, 0x5D, 0x5C, 0x57, 0x5B, 0x58, 0x53, 0x54, 0x47, 0x49, 0x54, 0x5C, 0x6B, 0x6F, 0x77, 0x7F, 0x80, 0x88, 0x8A, 0x8C, 0x85, 0x7A, 0x7D, 0x7F, 0x7D, 0x80, 0x80, 0x81, 0x80, 0x85, 0x82, 0x81, 0x7E, 0x80, 0x7F, 0x7F, 0x7E, 0x7D, 0x7E, 0x83, 0x7F, 0x81, 0x83, 0x87, 0x82, 0x83, 0x88, 0x84, 0x82, 0x82, 0x8A, 0xB3, 0xC5, 0xCD, 0xCF, 0xD4, 0xD3, 0xD6, 0xCC, 0xB5, 0x80, 0x4E, 0x48, 0x4D, 0x4D, 0x57, 0x5A, 0x59, 0x5C, 0x62, 0x58, 0x5C, 0x5B, 0x5B, 0x62, 0x5D, 0x5C, 0x59, 0x5C, 0x5A, 0x59, 0x5D, 0x5F, 0x5B, 0x5F, 0x60, 0x5E, 0x5E, 0x57, 0x5F, 0x5F, 0x60, 0x61, 0x5C, 0x61, 0x60, 0x5B, 0x56, 0x56, 0x57, 0x58, 0x6E, 0x91, 0x96, 0x7E, 0x89, 0x88, 0x87, 0x86, 0x8A, 0x87, 0x84, 0x87, 0x83, 0x89, 0x82, 0x83, 0x84, 0x81, 0x80, 0x80, 0x81, 0x83, 0x88, 0x8A, 0x8E, 0x90, 0x96, 0x98, 0x94, 0x93, 0x93, 0x88, 0x78, 0x7B, 0x60, 0x52, 0x41, 0x3F, 0x39, 0x46, 0x46, 0x48, 0x49, 0x47, 0x50, 0x4A, 0x49, 0x50, 0x4D, 0x4B, 0x4D, 0x4C, 0x4E, 0x4E, 0x4A, 0x49, 0x4E, 0x54, 0x4F, 0x59, 0x51, 0x5A, 0x5E, 0x5A, 0x5D, 0x61, 0x59, 0x65, 0x63, 0x65, 0x5F, 0x62, 0x68, 0x67, 0x64, 0x61, 0x64, 0x5E, 0x66, 0x63, 0x63, 0x61, 0x67, 0x69, 0x61, 0x63, 0x66, 0x67, 0x65, 0x63, 0x66, 0x64, 0x67, 0x67, 0x65, 0x64, 0x64, 0x6A, 0x66, 0x65, 0x68, 0x66, 0x69, 0x67, 0x6A, 0x67, 0x69, 0x66, 0x6C, 0x65, 0x69, 0x64, 0x65, 0x64, 0x66, 0x62, 0x63, 0x68, 0x68, 0x66, 0x64, 0x64, 0x62, 0x63, 0x68, 0x65, 0x66, 0x6A, 0x67, 0x65, 0x60, 0x66, 0x6F, 0x6A, 0x64, 0x61, 0x64, 0x63, 0x66, 0x63, 0x62, 0x64, 0x60, 0x69, 0x64, 0x61, 0x62, 0x65, 0x60, 0x63, 0x60, 0x62, 0x60, 0x5E, 0x61, 0x62, 0x5D, 0x5C, 0x57, 0x5B, 0x59, 0x53, 0x54, 0x47, 0x49, 0x54, 0x5C, 0x6B, 0x6F, 0x77, 0x7F, 0x80, 0x88, 0x8A, 0x8C, 0x85, 0x7A, 0x7D, 0x7F, 0x7C, 0x80, 0x80, 0x81, 0x80, 0x85, 0x82, 0x81, 0x7E, 0x80, 0x7F, 0x7F, 0x7E, 0x7D, 0x7E, 0x83, 0x7F, 0x81, 0x83, 0x87, 0x81, 0x83, 0x88, 0x84, 0x82, 0x82, 0x8A, 0xB5, 0xC5, 0xCD, 0xCF, 0xD4, 0xD3, 0xD6, 0xCC, 0xB4, 0x7E, 0x4D, 0x48, 0x4E, 0x4D, 0x57, 0x5A, 0x59, 0x5C, 0x62, 0x58, 0x5C, 0x5B, 0x5B, 0x62, 0x5D, 0x5C, 0x59, 0x5C, 0x5A, 0x59, 0x5D, 0x5F, 0x5B, 0x5F, 0x60, 0x5E, 0x5E, 0x57, 0x5F, 0x5F, 0x60, 0x61, 0x5C, 0x61, 0x60, 0x5B, 0x56, 0x56, 0x57, 0x58, 0x6F, 0x94, 0x9A, 0x82, 0x88, 0x89, 0x87, 0x86, 0x88, 0x86, 0x84, 0x85, 0x82, 0x87, 0x82, 0x81, 0x83, 0x81, 0x7F, 0x80, 0x82, 0x82, 0x87, 0x8A, 0x8F, 0x90, 0x95, 0x98, 0x95, 0x92, 0x92, 0x88, 0x79, 0x77, 0x5F, 0x51, 0x41, 0x3E, 0x3B, 0x44, 0x44, 0x46, 0x49, 0x4A, 0x4C, 0x49, 0x49, 0x4E, 0x4A, 0x4A, 0x4E, 0x4A, 0x4D, 0x4D, 0x48, 0x4A, 0x4C, 0x52, 0x52, 0x58, 0x52, 0x59, 0x5E, 0x5A, 0x5D, 0x5F, 0x59, 0x64, 0x64, 0x64, 0x62, 0x61, 0x66, 0x66, 0x64, 0x60, 0x62, 0x5F, 0x65, 0x63, 0x62, 0x62, 0x65, 0x66, 0x62, 0x65, 0x67, 0x66, 0x64, 0x64, 0x65, 0x65, 0x66, 0x65, 0x65, 0x63, 0x63, 0x67, 0x65, 0x64, 0x67, 0x67, 0x68, 0x66, 0x6A, 0x66, 0x67, 0x66, 0x6C, 0x65, 0x6A, 0x64, 0x64, 0x63, 0x66, 0x62, 0x63, 0x67, 0x69, 0x65, 0x64, 0x63, 0x62, 0x63, 0x68, 0x65, 0x66, 0x69, 0x66, 0x65, 0x61, 0x65, 0x6C, 0x69, 0x64, 0x61, 0x62, 0x62, 0x64, 0x63, 0x61, 0x63, 0x60, 0x66, 0x63, 0x61, 0x62, 0x65, 0x60, 0x62, 0x60, 0x62, 0x60, 0x5E, 0x60, 0x61, 0x5C, 0x5C, 0x59, 0x5B, 0x57, 0x53, 0x52, 0x47, 0x48, 0x54, 0x5C, 0x69, 0x6E, 0x77, 0x7D, 0x80, 0x88, 0x89, 0x8C, 0x84, 0x7B, 0x7D, 0x7E, 0x7D, 0x7F, 0x80, 0x81, 0x7F, 0x85, 0x82, 0x80, 0x7E, 0x7F, 0x7E, 0x7F, 0x7F, 0x7E, 0x7F, 0x82, 0x7F, 0x81, 0x83, 0x86, 0x82, 0x83, 0x87, 0x84, 0x82, 0x81, 0x88, 0xB0, 0xC5, 0xCD, 0xCF, 0xD4, 0xD4, 0xD6, 0xCD, 0xB8, 0x86, 0x51, 0x47, 0x4B, 0x4D, 0x56, 0x59, 0x59, 0x5B, 0x5F, 0x59, 0x5C, 0x5D, 0x5B, 0x62, 0x5D, 0x5B, 0x5B, 0x5C, 0x5B, 0x5A, 0x5E, 0x5F, 0x5D, 0x5F, 0x60, 0x5D, 0x5F, 0x58, 0x5E, 0x5F, 0x5F, 0x5F, 0x5B, 0x60, 0x60, 0x5C, 0x57, 0x56, 0x59, 0x5B, 0x6E, 0x8A, 0x87, 0x6C, 0x84, 0x88, 0x86, 0x84, 0x87, 0x85, 0x84, 0x82, 0x80, 0x84, 0x82, 0x7E, 0x82, 0x7F, 0x7C, 0x80, 0x84, 0x80, 0x84, 0x8B, 0x90, 0x92, 0x93, 0x95, 0x97, 0x91, 0x8E, 0x86, 0x79, 0x6F, 0x5B, 0x4F, 0x41, 0x3A, 0x3D, 0x3F, 0x40, 0x42, 0x48, 0x4B, 0x46, 0x48, 0x47, 0x4A, 0x46, 0x49, 0x4D, 0x48, 0x48, 0x4D, 0x46, 0x4C, 0x4B, 0x4F, 0x55, 0x55, 0x54, 0x58, 0x5D, 0x5B, 0x5D, 0x5C, 0x5A, 0x61, 0x62, 0x60, 0x65, 0x61, 0x63, 0x65, 0x64, 0x5F, 0x60, 0x61, 0x63, 0x63, 0x61, 0x63, 0x61, 0x63, 0x64, 0x66, 0x67, 0x66, 0x64, 0x65, 0x65, 0x67, 0x64, 0x64, 0x66, 0x63, 0x62, 0x64, 0x63, 0x62, 0x65, 0x67, 0x66, 0x65, 0x68, 0x65, 0x64, 0x64, 0x69, 0x63, 0x69, 0x65, 0x63, 0x61, 0x63, 0x61, 0x63, 0x68, 0x6B, 0x65, 0x63, 0x61, 0x62, 0x64, 0x66, 0x64, 0x65, 0x66, 0x63, 0x63, 0x63, 0x65, 0x65, 0x67, 0x65, 0x60, 0x60, 0x5E, 0x60, 0x64, 0x5E, 0x63, 0x60, 0x61, 0x5F, 0x60, 0x61, 0x63, 0x62, 0x62, 0x5E, 0x60, 0x61, 0x60, 0x5E, 0x5D, 0x5C, 0x5D, 0x5C, 0x5A, 0x54, 0x51, 0x4E, 0x4A, 0x46, 0x50, 0x59, 0x62, 0x6A, 0x75, 0x79, 0x80, 0x86, 0x86, 0x8B, 0x83, 0x7F, 0x7E, 0x7E, 0x7E, 0x7E, 0x81, 0x81, 0x7E, 0x83, 0x82, 0x80, 0x80, 0x7F, 0x7F, 0x7F, 0x81, 0x81, 0x81, 0x7F, 0x7E, 0x80, 0x82, 0x84, 0x83, 0x81, 0x84, 0x83, 0x82, 0x7F, 0x82, 0x9D, 0xBD, 0xC9, 0xCE, 0xD2, 0xD4, 0xD6, 0xD2, 0xC4, 0xA1, 0x68, 0x49, 0x48, 0x4D, 0x54, 0x56, 0x59, 0x5A, 0x5A, 0x5B, 0x5B, 0x60, 0x5B, 0x60, 0x5B, 0x5B, 0x5C, 0x5C, 0x5D, 0x5D, 0x60, 0x5C, 0x5E, 0x5E, 0x5E, 0x5B, 0x5E, 0x5C, 0x5D, 0x5E, 0x5F, 0x5C, 0x5C, 0x60, 0x61, 0x5E, 0x5A, 0x58, 0x5F, 0x62, 0x5F, 0x5D, 0x48, 0x32, 0x81, 0x85, 0x85, 0x81, 0x86, 0x83, 0x84, 0x80, 0x7F, 0x84, 0x83, 0x7E, 0x80, 0x7E, 0x7D, 0x80, 0x82, 0x7F, 0x85, 0x8D, 0x91, 0x93, 0x92, 0x95, 0x95, 0x8F, 0x8C, 0x84, 0x76, 0x6B, 0x5D, 0x50, 0x41, 0x38, 0x39, 0x3B, 0x41, 0x41, 0x46, 0x47, 0x45, 0x47, 0x44, 0x47, 0x45, 0x4A, 0x49, 0x48, 0x45, 0x4C, 0x48, 0x4C, 0x4E, 0x4E, 0x51, 0x56, 0x56, 0x59, 0x5A, 0x5C, 0x5C, 0x5E, 0x5A, 0x60, 0x5D, 0x60, 0x62, 0x61, 0x63, 0x64, 0x62, 0x5F, 0x61, 0x62, 0x64, 0x62, 0x61, 0x64, 0x61, 0x64, 0x63, 0x65, 0x65, 0x67, 0x63, 0x66, 0x65, 0x64, 0x63, 0x65, 0x66, 0x61, 0x60, 0x67, 0x64, 0x62, 0x63, 0x65, 0x64, 0x65, 0x65, 0x63, 0x62, 0x63, 0x63, 0x61, 0x67, 0x66, 0x63, 0x5F, 0x5E, 0x60, 0x63, 0x66, 0x6A, 0x64, 0x62, 0x60, 0x64, 0x63, 0x65, 0x62, 0x62, 0x62, 0x60, 0x62, 0x63, 0x63, 0x61, 0x64, 0x65, 0x60, 0x60, 0x5D, 0x61, 0x62, 0x5D, 0x61, 0x5E, 0x60, 0x5C, 0x60, 0x5F, 0x60, 0x61, 0x61, 0x5F, 0x60, 0x61, 0x61, 0x5E, 0x5D, 0x5D, 0x5B, 0x5A, 0x58, 0x52, 0x51, 0x4E, 0x4D, 0x47, 0x4A, 0x51, 0x5B, 0x66, 0x70, 0x76, 0x7C, 0x81, 0x84, 0x8A, 0x85, 0x81, 0x80, 0x7F, 0x7C, 0x7F, 0x82, 0x82, 0x81, 0x82, 0x82, 0x81, 0x84, 0x80, 0x82, 0x81, 0x80, 0x81, 0x81, 0x80, 0x80, 0x81, 0x82, 0x81, 0x82, 0x7F, 0x81, 0x80, 0x81, 0x7F, 0x7D, 0x86, 0xAB, 0xC1, 0xCB, 0xCF, 0xD2, 0xD3, 0xD5, 0xCF, 0xBA, 0x8A, 0x57, 0x48, 0x4D, 0x51, 0x52, 0x55, 0x5A, 0x5A, 0x5B, 0x59, 0x5F, 0x59, 0x5C, 0x59, 0x5C, 0x5A, 0x5A, 0x5B, 0x5C, 0x5F, 0x5C, 0x5D, 0x5B, 0x5D, 0x5C, 0x5C, 0x5E, 0x5C, 0x5D, 0x61, 0x5E, 0x5D, 0x5F, 0x62, 0x61, 0x61, 0x5F, 0x60, 0x5A, 0x3D, 0x28, 0x19, 0x13, 0x82, 0x84, 0x83, 0x7F, 0x84, 0x83, 0x83, 0x81, 0x80, 0x83, 0x84, 0x82, 0x7F, 0x7F, 0x80, 0x7F, 0x81, 0x83, 0x87, 0x8E, 0x92, 0x91, 0x93, 0x94, 0x91, 0x8F, 0x8E, 0x83, 0x72, 0x6A, 0x60, 0x4F, 0x3F, 0x36, 0x37, 0x3D, 0x42, 0x3F, 0x43, 0x47, 0x45, 0x45, 0x46, 0x46, 0x47, 0x4B, 0x44, 0x46, 0x44, 0x47, 0x48, 0x4B, 0x51, 0x4D, 0x4F, 0x56, 0x56, 0x5A, 0x5A, 0x5B, 0x5B, 0x5D, 0x5B, 0x5F, 0x5C, 0x62, 0x5D, 0x61, 0x62, 0x63, 0x60, 0x63, 0x62, 0x63, 0x64, 0x60, 0x61, 0x64, 0x60, 0x66, 0x5F, 0x63, 0x65, 0x67, 0x63, 0x63, 0x63, 0x63, 0x63, 0x65, 0x63, 0x61, 0x62, 0x66, 0x63, 0x63, 0x62, 0x63, 0x61, 0x62, 0x64, 0x61, 0x64, 0x63, 0x61, 0x64, 0x66, 0x63, 0x63, 0x5E, 0x5D, 0x5E, 0x63, 0x61, 0x64, 0x63, 0x63, 0x60, 0x63, 0x62, 0x64, 0x62, 0x63, 0x61, 0x62, 0x61, 0x63, 0x60, 0x61, 0x61, 0x63, 0x63, 0x61, 0x62, 0x62, 0x60, 0x5E, 0x5F, 0x5F, 0x61, 0x5D, 0x61, 0x5F, 0x5F, 0x5F, 0x5E, 0x61, 0x60, 0x5F, 0x5F, 0x62, 0x61, 0x5D, 0x5A, 0x56, 0x58, 0x54, 0x52, 0x51, 0x4F, 0x4C, 0x47, 0x4B, 0x57, 0x61, 0x6C, 0x72, 0x79, 0x7E, 0x82, 0x89, 0x87, 0x82, 0x82, 0x7F, 0x7E, 0x80, 0x82, 0x86, 0x84, 0x85, 0x84, 0x83, 0x85, 0x82, 0x82, 0x82, 0x80, 0x81, 0x83, 0x82, 0x80, 0x80, 0x83, 0x80, 0x81, 0x7F, 0x81, 0x7F, 0x81, 0x83, 0x7A, 0x7D, 0x95, 0xB7, 0xC6, 0xCD, 0xD0, 0xD3, 0xD5, 0xD4, 0xC9, 0xA9, 0x73, 0x4B, 0x48, 0x4D, 0x50, 0x53, 0x57, 0x59, 0x5A, 0x57, 0x5C, 0x5B, 0x5A, 0x59, 0x5B, 0x59, 0x58, 0x58, 0x5A, 0x5F, 0x5D, 0x5B, 0x58, 0x5D, 0x5A, 0x5C, 0x5D, 0x5D, 0x5E, 0x5E, 0x5F, 0x5C, 0x5D, 0x62, 0x65, 0x66, 0x65, 0x55, 0x3D, 0x20, 0x13, 0x12, 0x17, 0x83, 0x83, 0x80, 0x81, 0x84, 0x82, 0x81, 0x81, 0x81, 0x83, 0x81, 0x83, 0x7F, 0x80, 0x80, 0x7E, 0x83, 0x8A, 0x8A, 0x90, 0x93, 0x91, 0x92, 0x92, 0x8F, 0x90, 0x8D, 0x83, 0x71, 0x69, 0x5D, 0x4D, 0x41, 0x37, 0x37, 0x3F, 0x3C, 0x3F, 0x42, 0x48, 0x44, 0x46, 0x49, 0x4B, 0x4A, 0x4A, 0x41, 0x45, 0x45, 0x44, 0x44, 0x48, 0x50, 0x4C, 0x51, 0x53, 0x57, 0x57, 0x5A, 0x5A, 0x5D, 0x5B, 0x5D, 0x5D, 0x5C, 0x5E, 0x5E, 0x62, 0x5E, 0x62, 0x60, 0x65, 0x63, 0x63, 0x61, 0x5F, 0x61, 0x63, 0x5E, 0x65, 0x5E, 0x61, 0x66, 0x63, 0x63, 0x61, 0x63, 0x65, 0x61, 0x62, 0x62, 0x64, 0x64, 0x63, 0x62, 0x62, 0x60, 0x63, 0x62, 0x61, 0x64, 0x61, 0x64, 0x63, 0x62, 0x66, 0x66, 0x63, 0x64, 0x5E, 0x60, 0x5F, 0x63, 0x62, 0x60, 0x63, 0x62, 0x60, 0x62, 0x62, 0x64, 0x66, 0x66, 0x63, 0x65, 0x61, 0x65, 0x61, 0x60, 0x61, 0x61, 0x64, 0x61, 0x63, 0x63, 0x61, 0x61, 0x5F, 0x61, 0x61, 0x5F, 0x62, 0x5E, 0x60, 0x5F, 0x5B, 0x5F, 0x61, 0x5E, 0x5F, 0x65, 0x60, 0x5A, 0x5B, 0x58, 0x59, 0x56, 0x53, 0x52, 0x50, 0x4E, 0x4B, 0x47, 0x51, 0x5A, 0x67, 0x6E, 0x77, 0x7B, 0x7F, 0x87, 0x87, 0x86, 0x84, 0x82, 0x83, 0x83, 0x83, 0x86, 0x87, 0x89, 0x88, 0x87, 0x84, 0x84, 0x83, 0x80, 0x80, 0x81, 0x84, 0x81, 0x81, 0x80, 0x81, 0x7F, 0x7F, 0x7F, 0x82, 0x80, 0x81, 0x84, 0x7C, 0x7E, 0x82, 0xA5, 0xC0, 0xCA, 0xCF, 0xD3, 0xD5, 0xD5, 0xD2, 0xBF, 0x96, 0x5C, 0x47, 0x4B, 0x4E, 0x50, 0x55, 0x55, 0x58, 0x57, 0x5A, 0x5D, 0x5A, 0x5C, 0x59, 0x5C, 0x55, 0x57, 0x5B, 0x60, 0x5B, 0x5B, 0x59, 0x5B, 0x5B, 0x5F, 0x5B, 0x5D, 0x5E, 0x5B, 0x5D, 0x5D, 0x5D, 0x65, 0x68, 0x63, 0x5A, 0x3A, 0x23, 0x19, 0x12, 0x17, 0x19, 0x83, 0x83, 0x81, 0x84, 0x82, 0x80, 0x82, 0x81, 0x81, 0x81, 0x80, 0x81, 0x80, 0x7F, 0x7E, 0x82, 0x86, 0x8C, 0x90, 0x91, 0x91, 0x92, 0x91, 0x92, 0x90, 0x8F, 0x87, 0x82, 0x72, 0x69, 0x5D, 0x4E, 0x42, 0x39, 0x37, 0x3E, 0x3A, 0x42, 0x44, 0x43, 0x46, 0x4B, 0x49, 0x4E, 0x4A, 0x49, 0x42, 0x48, 0x48, 0x44, 0x42, 0x45, 0x4C, 0x4D, 0x51, 0x51, 0x55, 0x56, 0x5A, 0x5C, 0x5E, 0x5C, 0x5C, 0x5F, 0x5D, 0x5C, 0x60, 0x60, 0x5C, 0x62, 0x62, 0x64, 0x63, 0x61, 0x61, 0x60, 0x61, 0x61, 0x60, 0x63, 0x61, 0x61, 0x65, 0x62, 0x62, 0x65, 0x65, 0x65, 0x61, 0x62, 0x64, 0x65, 0x66, 0x63, 0x64, 0x5F, 0x5F, 0x62, 0x65, 0x64, 0x64, 0x63, 0x62, 0x65, 0x63, 0x64, 0x65, 0x62, 0x65, 0x60, 0x63, 0x60, 0x61, 0x66, 0x61, 0x64, 0x5F, 0x60, 0x63, 0x62, 0x64, 0x67, 0x66, 0x67, 0x66, 0x61, 0x65, 0x64, 0x60, 0x65, 0x61, 0x62, 0x61, 0x60, 0x64, 0x5F, 0x63, 0x61, 0x60, 0x5F, 0x5F, 0x5E, 0x5D, 0x60, 0x61, 0x5D, 0x60, 0x61, 0x60, 0x60, 0x62, 0x5F, 0x59, 0x5D, 0x5B, 0x5A, 0x57, 0x54, 0x51, 0x56, 0x4E, 0x4E, 0x48, 0x4C, 0x55, 0x60, 0x6E, 0x75, 0x79, 0x7D, 0x84, 0x87, 0x89, 0x89, 0x87, 0x85, 0x84, 0x86, 0x87, 0x8A, 0x89, 0x8A, 0x8A, 0x85, 0x82, 0x84, 0x82, 0x81, 0x83, 0x83, 0x7D, 0x80, 0x80, 0x7E, 0x7F, 0x7C, 0x7E, 0x7F, 0x80, 0x80, 0x7F, 0x80, 0x7F, 0x7B, 0x8D, 0xB5, 0xC5, 0xCC, 0xD2, 0xD4, 0xD5, 0xD6, 0xCC, 0xB4, 0x7F, 0x4E, 0x4C, 0x4B, 0x4F, 0x51, 0x56, 0x55, 0x54, 0x59, 0x5C, 0x59, 0x5D, 0x59, 0x5B, 0x57, 0x57, 0x5D, 0x5D, 0x58, 0x5D, 0x5D, 0x5A, 0x5F, 0x61, 0x5D, 0x5F, 0x5E, 0x5D, 0x60, 0x60, 0x63, 0x69, 0x62, 0x50, 0x38, 0x1D, 0x1A, 0x1C, 0x17, 0x19, 0x18, 0x81, 0x82, 0x83, 0x82, 0x81, 0x7E, 0x83, 0x83, 0x80, 0x82, 0x82, 0x80, 0x80, 0x7D, 0x80, 0x88, 0x8A, 0x8D, 0x93, 0x8F, 0x91, 0x91, 0x90, 0x8F, 0x90, 0x8C, 0x84, 0x81, 0x71, 0x69, 0x5E, 0x4B, 0x40, 0x3A, 0x38, 0x3B, 0x3B, 0x45, 0x44, 0x3E, 0x46, 0x4B, 0x4A, 0x4B, 0x45, 0x47, 0x45, 0x49, 0x44, 0x45, 0x42, 0x47, 0x4A, 0x4F, 0x52, 0x51, 0x53, 0x57, 0x59, 0x5D, 0x5B, 0x5E, 0x5A, 0x60, 0x5F, 0x5F, 0x5F, 0x61, 0x5C, 0x61, 0x64, 0x63, 0x62, 0x60, 0x62, 0x62, 0x63, 0x60, 0x61, 0x60, 0x64, 0x64, 0x66, 0x63, 0x61, 0x68, 0x65, 0x65, 0x63, 0x66, 0x65, 0x63, 0x65, 0x63, 0x64, 0x61, 0x60, 0x60, 0x62, 0x66, 0x64, 0x61, 0x63, 0x65, 0x64, 0x62, 0x66, 0x60, 0x67, 0x63, 0x61, 0x5E, 0x5D, 0x66, 0x65, 0x63, 0x60, 0x60, 0x61, 0x62, 0x66, 0x68, 0x66, 0x6B, 0x65, 0x62, 0x65, 0x63, 0x63, 0x64, 0x63, 0x62, 0x60, 0x61, 0x62, 0x5D, 0x62, 0x62, 0x61, 0x5E, 0x5F, 0x5A, 0x5E, 0x5E, 0x61, 0x60, 0x62, 0x60, 0x62, 0x5E, 0x5F, 0x60, 0x5E, 0x5F, 0x59, 0x5B, 0x56, 0x54, 0x51, 0x59, 0x4E, 0x4E, 0x49, 0x47, 0x52, 0x5B, 0x6B, 0x72, 0x76, 0x7C, 0x82, 0x86, 0x87, 0x8E, 0x89, 0x85, 0x85, 0x87, 0x88, 0x8D, 0x89, 0x89, 0x8A, 0x89, 0x82, 0x84, 0x85, 0x86, 0x86, 0x80, 0x7E, 0x7E, 0x7E, 0x7F, 0x81, 0x7D, 0x7F, 0x7C, 0x7E, 0x7D, 0x7E, 0x80, 0x7D, 0x7C, 0x7B, 0x9F, 0xBD, 0xC9, 0xD0, 0xD3, 0xD5, 0xD6, 0xD3, 0xC6, 0xA3, 0x64, 0x4C, 0x47, 0x50, 0x4D, 0x58, 0x53, 0x52, 0x58, 0x59, 0x5A, 0x5C, 0x59, 0x5B, 0x5E, 0x58, 0x5E, 0x5B, 0x5D, 0x5F, 0x5C, 0x5B, 0x60, 0x63, 0x5F, 0x62, 0x62, 0x60, 0x64, 0x65, 0x68, 0x63, 0x4F, 0x30, 0x17, 0x14, 0x13, 0x17, 0x1A, 0x15, 0x17, 0x82, 0x83, 0x83, 0x80, 0x82, 0x7F, 0x83, 0x86, 0x83, 0x86, 0x81, 0x81, 0x80, 0x7F, 0x85, 0x88, 0x8C, 0x8F, 0x92, 0x8E, 0x93, 0x8F, 0x8E, 0x8B, 0x8E, 0x8A, 0x85, 0x7E, 0x71, 0x68, 0x5E, 0x4F, 0x42, 0x3E, 0x38, 0x39, 0x3D, 0x45, 0x42, 0x42, 0x44, 0x47, 0x4B, 0x49, 0x45, 0x46, 0x47, 0x46, 0x42, 0x45, 0x44, 0x48, 0x4A, 0x50, 0x52, 0x51, 0x55, 0x54, 0x57, 0x5A, 0x5A, 0x5D, 0x57, 0x5F, 0x5E, 0x60, 0x5D, 0x61, 0x5E, 0x61, 0x64, 0x62, 0x60, 0x62, 0x62, 0x63, 0x63, 0x62, 0x62, 0x61, 0x63, 0x62, 0x65, 0x63, 0x60, 0x65, 0x64, 0x63, 0x64, 0x66, 0x64, 0x61, 0x62, 0x64, 0x63, 0x63, 0x63, 0x5F, 0x61, 0x67, 0x62, 0x61, 0x64, 0x63, 0x63, 0x62, 0x65, 0x61, 0x68, 0x61, 0x63, 0x61, 0x5D, 0x65, 0x68, 0x62, 0x60, 0x5E, 0x5E, 0x63, 0x67, 0x69, 0x68, 0x69, 0x69, 0x64, 0x65, 0x64, 0x65, 0x61, 0x64, 0x64, 0x64, 0x62, 0x62, 0x5C, 0x60, 0x62, 0x63, 0x61, 0x61, 0x5B, 0x5C, 0x5C, 0x60, 0x60, 0x61, 0x5F, 0x63, 0x5B, 0x5D, 0x60, 0x61, 0x5F, 0x5B, 0x5C, 0x5A, 0x53, 0x52, 0x56, 0x4E, 0x4C, 0x48, 0x44, 0x4E, 0x5A, 0x65, 0x6F, 0x74, 0x7C, 0x81, 0x85, 0x85, 0x8E, 0x88, 0x87, 0x88, 0x87, 0x88, 0x8E, 0x89, 0x8A, 0x8A, 0x8B, 0x86, 0x83, 0x84, 0x87, 0x86, 0x83, 0x80, 0x7F, 0x7F, 0x81, 0x80, 0x7F, 0x7F, 0x7E, 0x7E, 0x7F, 0x80, 0x7D, 0x7C, 0x7C, 0x78, 0x84, 0xAD, 0xC3, 0xCC, 0xD2, 0xD4, 0xD6, 0xD6, 0xCF, 0xB9, 0x87, 0x54, 0x47, 0x51, 0x4D, 0x56, 0x53, 0x54, 0x59, 0x57, 0x5B, 0x5E, 0x5B, 0x5E, 0x61, 0x5A, 0x5E, 0x5A, 0x63, 0x5D, 0x5D, 0x5F, 0x5E, 0x62, 0x5F, 0x62, 0x65, 0x63, 0x68, 0x6A, 0x63, 0x4D, 0x33, 0x17, 0x12, 0x1B, 0x11, 0x16, 0x18, 0x14, 0x16, 0x84, 0x83, 0x82, 0x7F, 0x83, 0x81, 0x82, 0x86, 0x86, 0x85, 0x80, 0x83, 0x7E, 0x80, 0x85, 0x86, 0x8C, 0x90, 0x8F, 0x8E, 0x93, 0x8C, 0x8C, 0x8B, 0x88, 0x88, 0x84, 0x7C, 0x74, 0x68, 0x62, 0x5B, 0x45, 0x3F, 0x38, 0x3A, 0x3F, 0x42, 0x41, 0x45, 0x4D, 0x46, 0x49, 0x48, 0x44, 0x47, 0x45, 0x43, 0x47, 0x46, 0x45, 0x45, 0x4B, 0x51, 0x50, 0x52, 0x57, 0x54, 0x55, 0x57, 0x59, 0x5B, 0x57, 0x5E, 0x5B, 0x5E, 0x5E, 0x60, 0x61, 0x60, 0x63, 0x61, 0x5E, 0x63, 0x61, 0x63, 0x62, 0x63, 0x63, 0x62, 0x61, 0x61, 0x63, 0x64, 0x60, 0x60, 0x64, 0x61, 0x63, 0x61, 0x63, 0x61, 0x61, 0x61, 0x63, 0x62, 0x64, 0x60, 0x61, 0x64, 0x60, 0x61, 0x61, 0x62, 0x63, 0x60, 0x61, 0x62, 0x65, 0x5F, 0x66, 0x63, 0x61, 0x63, 0x65, 0x62, 0x5E, 0x5E, 0x5F, 0x62, 0x65, 0x66, 0x67, 0x67, 0x6D, 0x64, 0x62, 0x63, 0x65, 0x61, 0x62, 0x62, 0x69, 0x61, 0x64, 0x5C, 0x5F, 0x61, 0x61, 0x60, 0x61, 0x5C, 0x5B, 0x5E, 0x60, 0x5F, 0x60, 0x60, 0x60, 0x5B, 0x5E, 0x5E, 0x60, 0x5C, 0x5D, 0x5C, 0x60, 0x57, 0x53, 0x53, 0x4E, 0x4D, 0x49, 0x44, 0x4C, 0x55, 0x61, 0x6C, 0x74, 0x7B, 0x80, 0x84, 0x86, 0x8B, 0x89, 0x89, 0x89, 0x87, 0x87, 0x8D, 0x89, 0x8C, 0x89, 0x8A, 0x89, 0x83, 0x83, 0x83, 0x85, 0x86, 0x7F, 0x81, 0x80, 0x82, 0x7E, 0x7F, 0x7D, 0x80, 0x7F, 0x81, 0x7F, 0x7C, 0x7D, 0x7B, 0x7B, 0x76, 0x95, 0xBA, 0xC7, 0xD0, 0xD2, 0xD5, 0xD7, 0xD4, 0xC8, 0xAA, 0x70, 0x48, 0x4F, 0x4D, 0x54, 0x52, 0x55, 0x58, 0x56, 0x59, 0x5A, 0x5C, 0x5F, 0x5E, 0x59, 0x5D, 0x5A, 0x5D, 0x5D, 0x62, 0x63, 0x61, 0x61, 0x62, 0x63, 0x66, 0x68, 0x6D, 0x65, 0x4A, 0x31, 0x1C, 0x12, 0x1B, 0x22, 0x16, 0x1B, 0x16, 0x16, 0x18, 0x84, 0x83, 0x7E, 0x82, 0x83, 0x81, 0x82, 0x85, 0x87, 0x84, 0x83, 0x84, 0x7D, 0x80, 0x83, 0x88, 0x8E, 0x90, 0x90, 0x8C, 0x8F, 0x8D, 0x8C, 0x88, 0x85, 0x86, 0x83, 0x7C, 0x78, 0x6A, 0x63, 0x5A, 0x43, 0x3A, 0x39, 0x3D, 0x3F, 0x3E, 0x42, 0x43, 0x57, 0x45, 0x48, 0x44, 0x43, 0x4B, 0x43, 0x44, 0x48, 0x46, 0x46, 0x46, 0x4C, 0x52, 0x4D, 0x52, 0x56, 0x59, 0x55, 0x58, 0x57, 0x5A, 0x5B, 0x5B, 0x5D, 0x5C, 0x5D, 0x60, 0x63, 0x62, 0x60, 0x61, 0x60, 0x5F, 0x62, 0x63, 0x5F, 0x60, 0x62, 0x62, 0x61, 0x61, 0x63, 0x64, 0x61, 0x60, 0x64, 0x63, 0x62, 0x60, 0x64, 0x63, 0x60, 0x5F, 0x63, 0x62, 0x61, 0x64, 0x5E, 0x61, 0x60, 0x60, 0x5E, 0x62, 0x60, 0x5F, 0x60, 0x60, 0x61, 0x5F, 0x61, 0x61, 0x61, 0x61, 0x61, 0x61, 0x5D, 0x60, 0x5E, 0x5F, 0x63, 0x62, 0x66, 0x66, 0x69, 0x64, 0x61, 0x62, 0x64, 0x62, 0x63, 0x61, 0x65, 0x61, 0x60, 0x5F, 0x5E, 0x63, 0x5E, 0x5D, 0x5D, 0x5D, 0x5B, 0x60, 0x5F, 0x5F, 0x5D, 0x5F, 0x5B, 0x5B, 0x5F, 0x5E, 0x5D, 0x5A, 0x5C, 0x5B, 0x5C, 0x58, 0x52, 0x51, 0x4E, 0x51, 0x4A, 0x47, 0x4D, 0x51, 0x5E, 0x69, 0x74, 0x7B, 0x7E, 0x82, 0x86, 0x89, 0x8B, 0x89, 0x88, 0x8A, 0x86, 0x88, 0x88, 0x8C, 0x88, 0x89, 0x89, 0x88, 0x85, 0x7F, 0x83, 0x84, 0x80, 0x80, 0x80, 0x81, 0x7C, 0x7E, 0x7E, 0x7E, 0x7E, 0x7E, 0x7E, 0x7B, 0x7D, 0x7C, 0x78, 0x74, 0x7F, 0xA8, 0xC1, 0xCB, 0xD1, 0xD4, 0xD6, 0xD6, 0xD2, 0xC1, 0x94, 0x57, 0x49, 0x4C, 0x52, 0x53, 0x57, 0x5A, 0x57, 0x59, 0x53, 0x5A, 0x5E, 0x5C, 0x5A, 0x5A, 0x5A, 0x57, 0x60, 0x63, 0x65, 0x64, 0x63, 0x64, 0x66, 0x69, 0x6A, 0x67, 0x4E, 0x30, 0x1C, 0x12, 0x15, 0x19, 0x1F, 0x1A, 0x1A, 0x16, 0x1A, 0x1B, 0x81, 0x81, 0x7D, 0x83, 0x85, 0x81, 0x84, 0x84, 0x86, 0x83, 0x84, 0x83, 0x7E, 0x84, 0x86, 0x8B, 0x8F, 0x8F, 0x94, 0x8D, 0x8D, 0x8B, 0x8C, 0x85, 0x85, 0x85, 0x84, 0x7D, 0x79, 0x6B, 0x5C, 0x4F, 0x3F, 0x36, 0x36, 0x3A, 0x3E, 0x3B, 0x43, 0x44, 0x4E, 0x45, 0x47, 0x42, 0x45, 0x4B, 0x44, 0x44, 0x48, 0x44, 0x46, 0x4A, 0x4B, 0x4F, 0x4D, 0x50, 0x56, 0x5A, 0x57, 0x59, 0x56, 0x58, 0x5E, 0x5C, 0x5F, 0x5F, 0x5C, 0x5F, 0x5D, 0x65, 0x5D, 0x62, 0x5F, 0x5C, 0x61, 0x60, 0x5F, 0x5E, 0x61, 0x62, 0x61, 0x61, 0x63, 0x60, 0x5F, 0x61, 0x63, 0x63, 0x61, 0x61, 0x64, 0x62, 0x60, 0x61, 0x66, 0x63, 0x62, 0x64, 0x5E, 0x61, 0x60, 0x5F, 0x5C, 0x5F, 0x5C, 0x60, 0x5E, 0x5D, 0x5E, 0x5E, 0x5B, 0x5F, 0x60, 0x5D, 0x5E, 0x60, 0x5E, 0x60, 0x5B, 0x5E, 0x61, 0x60, 0x63, 0x64, 0x64, 0x65, 0x63, 0x61, 0x63, 0x61, 0x64, 0x64, 0x60, 0x62, 0x5C, 0x5F, 0x5D, 0x63, 0x5E, 0x5C, 0x5D, 0x5D, 0x5B, 0x5F, 0x5E, 0x60, 0x5D, 0x5D, 0x5B, 0x5D, 0x5E, 0x5E, 0x5C, 0x5B, 0x5D, 0x59, 0x5A, 0x58, 0x52, 0x4D, 0x4F, 0x4F, 0x4A, 0x4B, 0x50, 0x54, 0x5C, 0x66, 0x71, 0x79, 0x7C, 0x83, 0x85, 0x89, 0x8B, 0x8A, 0x87, 0x8D, 0x86, 0x84, 0x87, 0x89, 0x88, 0x88, 0x87, 0x89, 0x86, 0x81, 0x83, 0x84, 0x82, 0x80, 0x82, 0x80, 0x7C, 0x7D, 0x7F, 0x7D, 0x7D, 0x7C, 0x7F, 0x7C, 0x7C, 0x7D, 0x78, 0x75, 0x75, 0x91, 0xB7, 0xC7, 0xCF, 0xD4, 0xD5, 0xD6, 0xD7, 0xCE, 0xB2, 0x7C, 0x4A, 0x4A, 0x4F, 0x53, 0x58, 0x5B, 0x5B, 0x5C, 0x57, 0x59, 0x5E, 0x5C, 0x5A, 0x58, 0x59, 0x5B, 0x5E, 0x60, 0x61, 0x62, 0x63, 0x64, 0x69, 0x6B, 0x63, 0x50, 0x2B, 0x27, 0x19, 0x11, 0x13, 0x15, 0x15, 0x17, 0x14, 0x18, 0x1E, 0x1A, 0x7F, 0x7F, 0x81, 0x82, 0x84, 0x82, 0x85, 0x83, 0x83, 0x83, 0x85, 0x82, 0x81, 0x89, 0x8A, 0x8D, 0x8F, 0x90, 0x92, 0x8E, 0x8A, 0x87, 0x89, 0x85, 0x87, 0x87, 0x85, 0x7D, 0x78, 0x6C, 0x58, 0x4B, 0x3B, 0x33, 0x30, 0x36, 0x3E, 0x3D, 0x43, 0x46, 0x43, 0x46, 0x46, 0x45, 0x48, 0x47, 0x46, 0x44, 0x49, 0x42, 0x46, 0x4A, 0x4B, 0x4B, 0x4F, 0x4F, 0x56, 0x5B, 0x57, 0x58, 0x57, 0x5A, 0x5B, 0x5E, 0x5F, 0x61, 0x5C, 0x5E, 0x5D, 0x61, 0x5E, 0x62, 0x5D, 0x5E, 0x5F, 0x5E, 0x61, 0x61, 0x60, 0x62, 0x61, 0x61, 0x60, 0x5F, 0x5D, 0x60, 0x5F, 0x61, 0x61, 0x60, 0x62, 0x5E, 0x60, 0x64, 0x65, 0x63, 0x66, 0x65, 0x65, 0x60, 0x5F, 0x5C, 0x59, 0x5B, 0x5B, 0x5D, 0x59, 0x5C, 0x5B, 0x5D, 0x5E, 0x5F, 0x5F, 0x5A, 0x5C, 0x5E, 0x5E, 0x5F, 0x5A, 0x60, 0x5D, 0x5F, 0x5F, 0x63, 0x62, 0x64, 0x63, 0x61, 0x61, 0x63, 0x64, 0x66, 0x60, 0x61, 0x5E, 0x5D, 0x5D, 0x5F, 0x5E, 0x5D, 0x60, 0x5C, 0x5D, 0x5F, 0x5D, 0x5E, 0x5E, 0x5D, 0x5C, 0x60, 0x5E, 0x5D, 0x5D, 0x5B, 0x5C, 0x59, 0x5C, 0x5B, 0x53, 0x4E, 0x50, 0x4A, 0x48, 0x4B, 0x50, 0x56, 0x5C, 0x63, 0x6E, 0x74, 0x7E, 0x83, 0x84, 0x88, 0x8B, 0x89, 0x89, 0x8B, 0x85, 0x85, 0x87, 0x86, 0x88, 0x85, 0x86, 0x87, 0x86, 0x85, 0x82, 0x84, 0x82, 0x81, 0x83, 0x80, 0x7F, 0x7E, 0x7D, 0x7F, 0x7F, 0x7C, 0x7F, 0x7C, 0x7E, 0x7D, 0x7A, 0x78, 0x75, 0x7C, 0xA4, 0xC2, 0xCC, 0xD3, 0xD4, 0xD7, 0xD9, 0xD5, 0xC7, 0xA2, 0x60, 0x46, 0x4E, 0x50, 0x54, 0x57, 0x5C, 0x5E, 0x5D, 0x5A, 0x5D, 0x5A, 0x5A, 0x59, 0x59, 0x5E, 0x5E, 0x5D, 0x5E, 0x61, 0x63, 0x67, 0x69, 0x64, 0x4C, 0x2D, 0x12, 0x1C, 0x1B, 0x10, 0x0E, 0x14, 0x11, 0x13, 0x12, 0x1B, 0x1D, 0x1A, 0x82, 0x81, 0x85, 0x82, 0x83, 0x82, 0x85, 0x85, 0x84, 0x84, 0x87, 0x85, 0x84, 0x8C, 0x8C, 0x90, 0x91, 0x91, 0x8E, 0x8E, 0x87, 0x84, 0x85, 0x85, 0x86, 0x89, 0x86, 0x7F, 0x76, 0x69, 0x59, 0x4D, 0x3A, 0x35, 0x31, 0x36, 0x3F, 0x40, 0x42, 0x45, 0x45, 0x46, 0x49, 0x44, 0x49, 0x47, 0x48, 0x44, 0x47, 0x43, 0x46, 0x49, 0x4B, 0x4B, 0x50, 0x52, 0x54, 0x5A, 0x58, 0x58, 0x59, 0x5E, 0x5B, 0x5C, 0x5F, 0x5E, 0x5B, 0x5D, 0x62, 0x5F, 0x5F, 0x5F, 0x5D, 0x5E, 0x60, 0x5F, 0x63, 0x63, 0x5E, 0x62, 0x61, 0x60, 0x5E, 0x61, 0x60, 0x60, 0x5E, 0x62, 0x62, 0x5F, 0x5F, 0x5C, 0x60, 0x61, 0x60, 0x65, 0x67, 0x68, 0x68, 0x61, 0x5F, 0x5A, 0x58, 0x5A, 0x5A, 0x58, 0x57, 0x59, 0x5A, 0x5D, 0x5F, 0x60, 0x5D, 0x5C, 0x5C, 0x5C, 0x5B, 0x5D, 0x5C, 0x5F, 0x5E, 0x5F, 0x60, 0x60, 0x61, 0x62, 0x63, 0x65, 0x62, 0x64, 0x64, 0x64, 0x61, 0x60, 0x60, 0x5C, 0x5E, 0x5F, 0x5E, 0x60, 0x5E, 0x5D, 0x5C, 0x5E, 0x5D, 0x5B, 0x5D, 0x5D, 0x5B, 0x61, 0x5F, 0x5C, 0x5F, 0x5C, 0x5B, 0x5B, 0x57, 0x59, 0x56, 0x52, 0x50, 0x4C, 0x49, 0x4B, 0x4E, 0x55, 0x5E, 0x65, 0x6D, 0x73, 0x7F, 0x81, 0x85, 0x85, 0x8A, 0x89, 0x8A, 0x88, 0x86, 0x86, 0x88, 0x84, 0x89, 0x83, 0x88, 0x84, 0x84, 0x84, 0x82, 0x82, 0x82, 0x81, 0x83, 0x80, 0x80, 0x7F, 0x7F, 0x85, 0x80, 0x7E, 0x7D, 0x7D, 0x7E, 0x7D, 0x79, 0x79, 0x77, 0x73, 0x8B, 0xB6, 0xC7, 0xD0, 0xD3, 0xD5, 0xD8, 0xD8, 0xD2, 0xBC, 0x86, 0x4A, 0x48, 0x50, 0x52, 0x56, 0x58, 0x5A, 0x58, 0x5C, 0x5C, 0x59, 0x5B, 0x5B, 0x5A, 0x5E, 0x5E, 0x5E, 0x5F, 0x64, 0x66, 0x69, 0x62, 0x49, 0x27, 0x13, 0x0D, 0x14, 0x18, 0x10, 0x12, 0x12, 0x12, 0x14, 0x14, 0x1C, 0x19, 0x21, 0x82, 0x83, 0x86, 0x83, 0x83, 0x84, 0x84, 0x86, 0x86, 0x85, 0x85, 0x89, 0x8A, 0x8F, 0x8F, 0x91, 0x92, 0x8F, 0x8E, 0x8D, 0x86, 0x85, 0x84, 0x84, 0x85, 0x8A, 0x88, 0x83, 0x76, 0x69, 0x5E, 0x4E, 0x3D, 0x39, 0x34, 0x38, 0x3F, 0x40, 0x42, 0x45, 0x48, 0x47, 0x4C, 0x45, 0x4B, 0x49, 0x46, 0x44, 0x46, 0x43, 0x45, 0x48, 0x4A, 0x4A, 0x4F, 0x51, 0x53, 0x55, 0x59, 0x59, 0x5A, 0x5D, 0x5B, 0x59, 0x5F, 0x5C, 0x5D, 0x5C, 0x61, 0x61, 0x5F, 0x5D, 0x5D, 0x5B, 0x5F, 0x60, 0x61, 0x62, 0x5E, 0x60, 0x60, 0x60, 0x5F, 0x61, 0x61, 0x61, 0x60, 0x61, 0x61, 0x5F, 0x60, 0x5E, 0x61, 0x5C, 0x60, 0x65, 0x65, 0x64, 0x65, 0x62, 0x60, 0x5F, 0x5B, 0x58, 0x59, 0x55, 0x59, 0x57, 0x5B, 0x5A, 0x5C, 0x5F, 0x5E, 0x5C, 0x5C, 0x5D, 0x5D, 0x5A, 0x5C, 0x5D, 0x5E, 0x5F, 0x64, 0x5E, 0x60, 0x62, 0x61, 0x65, 0x67, 0x62, 0x64, 0x60, 0x60, 0x5D, 0x5F, 0x5E, 0x60, 0x61, 0x60, 0x60, 0x61, 0x5E, 0x58, 0x5E, 0x5C, 0x5A, 0x5D, 0x5B, 0x5B, 0x60, 0x5E, 0x5F, 0x5F, 0x61, 0x5A, 0x59, 0x55, 0x55, 0x57, 0x54, 0x4F, 0x4D, 0x4B, 0x4A, 0x4A, 0x55, 0x5F, 0x66, 0x6A, 0x74, 0x7B, 0x7D, 0x84, 0x84, 0x86, 0x89, 0x88, 0x87, 0x86, 0x84, 0x88, 0x82, 0x88, 0x84, 0x88, 0x84, 0x83, 0x83, 0x83, 0x82, 0x81, 0x81, 0x84, 0x81, 0x7F, 0x7F, 0x82, 0x88, 0x81, 0x83, 0x7D, 0x7F, 0x7D, 0x7D, 0x7A, 0x7A, 0x77, 0x72, 0x79, 0x9D, 0xBB, 0xCA, 0xD0, 0xD4, 0xD7, 0xD8, 0xD8, 0xCD, 0xAE, 0x6D, 0x49, 0x50, 0x50, 0x57, 0x55, 0x58, 0x54, 0x5B, 0x59, 0x5B, 0x5C, 0x5C, 0x5E, 0x5D, 0x5C, 0x61, 0x62, 0x66, 0x67, 0x65, 0x51, 0x27, 0x10, 0x0D, 0x15, 0x14, 0x15, 0x10, 0x16, 0x13, 0x15, 0x17, 0x17, 0x18, 0x19, 0x23 }; /* Macro definitions */ #define abs(x) (x>=0 ? x : -(x)) #define FILTER 0 #define EXPAND 1 #define IS == #define ISNT != #define AND && #define OR || #define NUM_LEVELS 4 /* Forward declaration of functions */ void epic_init( void ); void epic_build_pyr( float *image, int x_size, int y_size, int num_levels, float *lo_filter, float *hi_filter, int filter_size ); void epic_build_level( float *image, int level_x_size, int level_y_size, float *lo_filter, float *hi_filter, int filter_size, float *result_block ); void epic_internal_transpose( float *mat, int rows, int cols ); void epic_internal_filter( float *image, int x_dim, int y_dim, float *filt, float *temp, int x_fdim, int y_fdim, int xgrid_start, int xgrid_step, int ygrid_start, int ygrid_step, float *result ); void epic_reflect1( float *filt, int x_dim, int y_dim, int x_pos, int y_pos, float *result, int f_or_e ); void epic_main( void ); //int main( void ); /* Declaration of global variables */ float epic_filtertemp[FILTER_SIZE]; float epic_hi_imagetemp[X_SIZE * Y_SIZE / 2]; float epic_lo_imagetemp[X_SIZE * Y_SIZE / 2]; static float epic_lo_filter[FILTER_SIZE] = { -0.0012475221, -0.0024950907, 0.0087309530, 0.0199579580, -0.0505290000, -0.1205509700, 0.2930455800, 0.7061761600, 0.2930455800, -0.1205509700, -0.0505290000, 0.0199579580, 0.0087309530, -0.0024950907, -0.0012475221 }; static float epic_hi_filter[FILTER_SIZE] = { 0.0012475221, -0.0024950907, -0.0087309530, 0.0199579580, 0.0505290000, -0.1205509700, -0.2930455800, 0.7061761600, -0.2930455800, -0.1205509700, 0.0505290000, 0.0199579580, -0.0087309530, -0.0024950907, 0.0012475221 }; /* Initialization function */ void epic_init( void ) { int i; _Pragma( "loopbound min 4096 max 9801" ) for ( i = 0; i < X_SIZE * Y_SIZE; ++i ) epic_image[i] *= SCALE_FACTOR; } /* Algorithm core functions */ /* ====================================================================== epic_build_pyr() -- builds a separable QMF-style pyramid. The pyramid is written over the original image. NOTE: the image size must be divisible by 2^num_levels, but we do not check this here. ====================================================================== */ void epic_build_pyr( float *image, int x_size, int y_size, int num_levels, float *lo_filter, float *hi_filter, int filter_size ) { int x_level, y_level, level; x_level = x_size; y_level = y_size; _Pragma( "loopbound min 4 max 4" ) for ( level = 0; level < num_levels; ++level ){ epic_build_level( image, x_level, y_level, lo_filter, hi_filter, filter_size, image ); x_level /= 2; y_level /= 2; } } /* ====================================================================== epic_build_level() -- builds a level of the pyramid by computing 4 filtered and subsampled images. Since the convolution is separable, image and result-block can point to the same place! Image order is lowpass, horizontal, vertical (transposed), and diagonal. ====================================================================== */ void epic_build_level( float *image, int level_x_size, int level_y_size, float *lo_filter, float *hi_filter, int filter_size, float *result_block ) { int total_size = level_x_size * level_y_size; /* filter and subsample in the X direction */ epic_internal_filter ( image, level_x_size, level_y_size, lo_filter, epic_filtertemp, filter_size, 1, 0, 2, 0, 1, epic_lo_imagetemp ); epic_internal_filter ( image, level_x_size, level_y_size, hi_filter, epic_filtertemp, filter_size, 1, 1, 2, 0, 1, epic_hi_imagetemp ); level_x_size /= 2; /* now filter and subsample in the Y direction */ epic_internal_filter ( epic_lo_imagetemp, level_x_size, level_y_size, /* lowpass */ lo_filter, epic_filtertemp, 1, filter_size, 0, 1, 0, 2, result_block ); epic_internal_filter ( epic_lo_imagetemp, level_x_size, level_y_size, /* horizontal */ hi_filter, epic_filtertemp, 1, filter_size, 0, 1, 1, 2, ( result_block += ( total_size / 4 ) ) ); epic_internal_filter ( epic_hi_imagetemp, level_x_size, level_y_size, /* vertical */ lo_filter, epic_filtertemp, 1, filter_size, 0, 1, 0, 2, ( result_block += ( total_size / 4 ) ) ); /* transpose the vertical band for more efficient scanning */ epic_internal_transpose( result_block, level_y_size / 2, level_x_size ); epic_internal_filter ( epic_hi_imagetemp, level_x_size, level_y_size, /* diagonal */ hi_filter, epic_filtertemp, 1, filter_size, 0, 1, 1, 2, ( result_block += ( total_size / 4 ) ) ); } /* ====================================================================== In-place matrix tranpose algorithm. Handles non-square matrices, too! Is there a faster algorithm?? ====================================================================== */ void epic_internal_transpose( float *mat, int rows, int cols ) { register int swap_pos; register int modulus = rows * cols - 1; register int current_pos; register float swap_val; /* loop, ignoring first and last elements */ _Pragma( "loopbound min 1022 max 2399" ) for ( current_pos = 1; current_pos < modulus; ++current_pos ) { /* Compute swap position */ swap_pos = current_pos; _Pragma( "loopbound min 1 max 2" ) do { swap_pos = ( swap_pos * cols ) % modulus; } while ( swap_pos < current_pos ); if ( current_pos != swap_pos ) { swap_val = mat[swap_pos]; mat[swap_pos] = mat[current_pos]; mat[current_pos] = swap_val; } } } /* -------------------------------------------------------------------- Correlate FILT with IMAGE, subsampling according to GRID parameters, with values placed into result array. TEMP is a temporary array the size of the filter. EDGES is a string -- see convolve.h. The convolution is done in 9 sections, where the border sections use specially computed edge-handling filters (see edges.c). The origin of the filter is assumed to be (floor(x_fdim/2), floor(y_fdim/2)). 10/6/89 - approximately optimized the choice of register vars on SPARCS. ------------------------------------------------------------------------ */ void epic_internal_filter( float *image, int x_dim, int y_dim, float *filt, float *temp, int x_fdim, int y_fdim, int xgrid_start, int xgrid_step, int ygrid_start, int ygrid_step, float *result ) { //register double sum; register float sum; register int x_filt, im_pos, y_filt_lin; register int y_im_lin, x_pos, filt_size = x_fdim * y_fdim; register int y_pos, res_pos; register int last_ctr_col = x_dim - x_fdim; int last_ctr_row = ( y_dim - y_fdim ) * x_dim; int first_row, first_col ; int x_fmid = x_fdim / 2; int y_fmid = y_fdim / 2; int x_stop = x_fdim - x_fmid + 1; int y_stop = y_fdim - y_fmid + 1; int ygrid_step_full = ygrid_step * x_dim; int prev_res_pos, x_res_dim = ( x_dim - xgrid_start + xgrid_step - 1 ) / xgrid_step; int rt_edge_res_pos = x_res_dim; res_pos = 0; first_col = xgrid_start - x_fmid + xgrid_step; _Pragma( "loopbound min 1 max 4" ) for ( y_pos = ygrid_start - y_fmid - 1; y_pos < 0; y_pos += ygrid_step ) { _Pragma( "loopbound min 1 max 4" ) for ( x_pos = xgrid_start - x_fmid; /* top-left corner */ x_pos < 0; x_pos += xgrid_step ) { epic_reflect1( filt, x_fdim, y_fdim, x_pos, y_pos, temp, FILTER ); sum = 0.0f; x_filt = y_im_lin = 0; _Pragma( "loopbound min 1 max 15" ) for ( y_filt_lin = x_fdim; y_filt_lin <= filt_size; y_filt_lin += x_fdim ) { im_pos = y_im_lin; _Pragma( "loopbound min 1 max 15" ) for ( ; x_filt < y_filt_lin; ++x_filt ) { sum += image[im_pos] * temp[x_filt]; ++im_pos; } y_im_lin += x_dim; } result[res_pos] = sum; ++res_pos; } first_col = x_pos + 1; epic_reflect1( filt, x_fdim, y_fdim, 0, y_pos, temp, FILTER ); _Pragma( "loopbound min 41 max 46" ) for ( x_pos = first_col; /* top edge */ x_pos < last_ctr_col; x_pos += xgrid_step ) { sum = 0.0f; x_filt = y_im_lin = 0; _Pragma( "loopbound min 1 max 15" ) for ( y_filt_lin = x_fdim; y_filt_lin <= filt_size; y_filt_lin += x_fdim ) { im_pos = x_pos + y_im_lin; _Pragma( "loopbound min 1 max 15" ) for ( ; x_filt < y_filt_lin; ++x_filt ) { sum += image[im_pos] * temp[x_filt]; ++im_pos; } y_im_lin += x_dim; } result[res_pos] = sum; ++res_pos; } rt_edge_res_pos = res_pos + x_res_dim; /* save this for later ... */ _Pragma( "loopbound min 1 max 4" ) for ( x_pos += ( 1 - last_ctr_col ); /* top-right corner */ x_pos < x_stop; x_pos += xgrid_step ) { epic_reflect1( filt, x_fdim, y_fdim, x_pos, y_pos, temp, FILTER ); sum = 0.0f; x_filt = y_im_lin = 0; _Pragma( "loopbound min 1 max 15" ) for ( y_filt_lin = x_fdim; y_filt_lin <= filt_size; y_filt_lin += x_fdim ) { im_pos = y_im_lin + last_ctr_col; _Pragma( "loopbound min 1 max 15" ) for ( ; x_filt < y_filt_lin; ++x_filt ) { sum += image[im_pos] * temp[x_filt]; ++im_pos; } y_im_lin += x_dim; } result[res_pos] = sum; ++res_pos; } } /* end top */ first_row = x_dim * ( y_pos + 1 ); /* need this to go down the sides */ prev_res_pos = res_pos; _Pragma( "loopbound min 1 max 4" ) for ( x_pos = xgrid_start - x_fmid; /* left edge */ x_pos < 1; x_pos += xgrid_step ) { res_pos = prev_res_pos; epic_reflect1( filt, x_fdim, y_fdim, x_pos, 0, temp, FILTER ); _Pragma( "loopbound min 41 max 97" ) for ( y_pos = first_row; y_pos < last_ctr_row; y_pos += ygrid_step_full ) { sum = 0.0f; x_filt = 0, y_im_lin = y_pos; _Pragma( "loopbound min 1 max 15" ) for ( y_filt_lin = x_fdim; y_filt_lin <= filt_size; y_filt_lin += x_fdim ) { im_pos = y_im_lin; _Pragma( "loopbound min 1 max 15" ) for ( ; x_filt < y_filt_lin; x_filt++ ) { sum += image[im_pos] * temp[x_filt]; ++im_pos; } y_im_lin += x_dim; } result[res_pos] = sum; res_pos += x_res_dim; } prev_res_pos++; } epic_reflect1( filt, x_fdim, y_fdim, 0, 0, temp, FILTER ); _Pragma( "loopbound min 41 max 97" ) for ( y_pos = first_row; /* center region of image */ y_pos < last_ctr_row; y_pos += ygrid_step_full ) { res_pos = prev_res_pos; _Pragma( "loopbound min 41 max 46" ) for ( x_pos = first_col; x_pos < last_ctr_col; x_pos += xgrid_step ) { sum = 0.0f; x_filt = 0, y_im_lin = y_pos; _Pragma( "loopbound min 1 max 15" ) for ( y_filt_lin = x_fdim; y_filt_lin <= filt_size; y_filt_lin += x_fdim ) { im_pos = x_pos + y_im_lin; _Pragma( "loopbound min 1 max 15" ) for ( ; x_filt < y_filt_lin; ++x_filt ) { sum += image[im_pos] * temp[x_filt]; ++im_pos; } y_im_lin += x_dim; } result[res_pos] = sum; ++res_pos; } prev_res_pos += x_res_dim; } prev_res_pos = rt_edge_res_pos; _Pragma( "loopbound min 1 max 4" ) for ( x_pos += ( 1 - last_ctr_col ); /* right edge */ x_pos < x_stop; x_pos += xgrid_step ) { res_pos = prev_res_pos; epic_reflect1( filt, x_fdim, y_fdim, x_pos, 0, temp, FILTER ); _Pragma( "loopbound min 41 max 97" ) for ( y_pos = first_row; y_pos < last_ctr_row; y_pos += ygrid_step_full ) { sum = 0.0f; x_filt = 0, y_im_lin = y_pos; _Pragma( "loopbound min 1 max 15" ) for ( y_filt_lin = x_fdim; y_filt_lin <= filt_size; y_filt_lin += x_fdim ) { _Pragma( "loopbound min 1 max 15" ) for ( im_pos = y_im_lin + last_ctr_col; x_filt < y_filt_lin; ++x_filt ) { sum += image[im_pos] * temp[x_filt]; ++im_pos; } y_im_lin += x_dim; } result[res_pos] = sum; res_pos += x_res_dim; } prev_res_pos++; } /* end mid */ res_pos -= ( x_res_dim - 1 ); /* go to lower left corner */ _Pragma( "loopbound min 1 max 4" ) for ( y_pos = ( ( y_pos - last_ctr_row ) / x_dim ) + 1; /* bottom */ y_pos < y_stop; y_pos += ygrid_step ) { _Pragma( "loopbound min 1 max 4" ) for ( x_pos = xgrid_start - x_fmid; /* bottom-left corner */ x_pos < 1; x_pos += xgrid_step ) { epic_reflect1( filt, x_fdim, y_fdim, x_pos, y_pos, temp, FILTER ); sum = 0.0f; x_filt = 0, y_im_lin = last_ctr_row; _Pragma( "loopbound min 1 max 15" ) for ( y_filt_lin = x_fdim; y_filt_lin <= filt_size; y_filt_lin += x_fdim ) { _Pragma( "loopbound min 1 max 15" ) for ( im_pos = y_im_lin; x_filt < y_filt_lin; ++x_filt ) { sum += image[im_pos] * temp[x_filt]; ++im_pos; } y_im_lin += x_dim; } result[res_pos] = sum; ++res_pos; } epic_reflect1( filt, x_fdim, y_fdim, 0, y_pos, temp, FILTER ); _Pragma( "loopbound min 41 max 46" ) for ( x_pos = first_col; /* bottom edge */ x_pos < last_ctr_col; x_pos += xgrid_step ) { sum = 0.0f; x_filt = 0, y_im_lin = last_ctr_row; _Pragma( "loopbound min 1 max 15" ) for ( y_filt_lin = x_fdim; y_filt_lin <= filt_size; y_filt_lin += x_fdim ) { _Pragma( "loopbound min 1 max 15" ) for ( im_pos = x_pos + y_im_lin; x_filt < y_filt_lin; ++x_filt ) { sum += image[im_pos] * temp[x_filt]; ++im_pos; } y_im_lin += x_dim; } result[res_pos] = sum; ++res_pos; } _Pragma( "loopbound min 1 max 4" ) for ( x_pos += 1 - last_ctr_col; /* bottom-right corner */ x_pos < x_stop; x_pos += xgrid_step ) { epic_reflect1( filt, x_fdim, y_fdim, x_pos, y_pos, temp, FILTER ); sum = 0.0f; x_filt = 0, y_im_lin = last_ctr_row; _Pragma( "loopbound min 1 max 15" ) for ( y_filt_lin = x_fdim; y_filt_lin <= filt_size; y_filt_lin += x_fdim ) { _Pragma( "loopbound min 1 max 15" ) for ( im_pos = y_im_lin + last_ctr_col; x_filt < y_filt_lin; ++x_filt ) { sum += image[im_pos] * temp[x_filt]; ++im_pos; } y_im_lin += x_dim; } result[res_pos] = sum; ++res_pos; } } /* end bottom */ } /* end of epic_internal_filter */ /* The following function determine how edges are to be handled when performing convolutions of images with linear filters. Any edge handling function which is local and linear may be defined, except (unfortunately) constants cannot be added. So to treat the edges as if the image is surrounded by a gray field, you must paste it into a gray image, convolve, and crop it out... The main convolution function is called epic_internal_filter. The idea is that the convolution function calls the edge handling function which computes a new filter based on the old filter and the distance to the edge of the image. For example, reflection is done by reflecting the filter through the appropriate axis and summing. */ /* ---------------- EDGE HANDLER ARGUMENTS ------------------------ filt - floating point array of filter taps. x_dim, y_dim - x and y dimensions of filt. x_pos - position of filter relative to the horizontal image edges. Negative values indicate left edge, positive indicate right edge. Zero indicates that the filter is not touching either edge. An absolute value of 1 indicates that the edge tap of the filter is over the edge pixel of the image. y_pos - analogous to x_pos. result - floating point array where the resulting filter will go. The edge of this filter will be aligned with the image for application... f_or_e - equal to one of the two constants EXPAND or FILTER. -------------------------------------------------------------------- */ /* -------------------------------------------------------------------- epic_reflect1() - Reflection through the edge pixels. This is the right thing to do if you are subsampling by 2, since it maintains parity (even pixels positions remain even, odd ones remain odd). (note: procedure differs depending on f_or_e parameter). */ void epic_reflect1( float *filt, int x_dim, int y_dim, int x_pos, int y_pos, float *result, int f_or_e ) { int filt_sz = x_dim * y_dim; register int x_start = 0, y_start = 0, x_stop = x_dim, y_stop = filt_sz; register int y_filt, x_filt, y_edge, x_edge; register int x_base = ( x_pos > 0 ) ? ( x_dim - 1 ) : 0; register int y_base = ( y_pos > 0 ) ? ( x_dim * ( y_dim - 1 ) ) : 0; int x_edge_dist = ( x_pos > 0 ) ? ( x_pos - x_dim ) : ( ( x_pos < -1 ) ? ( x_pos + 1 ) : 0 ); int y_edge_dist = x_dim * ( ( y_pos > 0 ) ? ( y_pos - y_dim ) : ( ( y_pos < -1 ) ? ( y_pos + 1 ) : 0 ) ); int i; int mx_pos = ( x_dim / 2 ) + 1; int my_pos = ( y_dim / 2 ) + 1; _Pragma( "loopbound min 15 max 15" ) for ( i = 0; i < filt_sz; ++i ) result[i] = 0.0f; /* if EXPAND and filter is centered on image edge, do not reflect */ if ( f_or_e IS EXPAND ) { if ( x_pos IS mx_pos ) x_stop = ( x_dim + 1 ) / 2; else if ( x_pos IS - mx_pos ) { x_start = x_dim / 2; x_edge_dist = 0; } if ( y_pos IS my_pos ) y_stop = x_dim * ( ( y_dim + 1 ) / 2 ); else if ( y_pos IS - my_pos ) { y_start = x_dim * ( y_dim / 2 ); y_edge_dist = 0; } } y_edge = y_edge_dist; /* reflect at boundary of image */ _Pragma( "loopbound min 1 max 15" ) for ( y_filt = y_start; y_filt < y_stop; y_filt += x_dim ) { x_edge = x_edge_dist; _Pragma( "loopbound min 1 max 15" ) for ( x_filt = y_filt + x_start; x_filt < y_filt + x_stop; ++x_filt ) { result[abs( y_base - abs( y_edge ) ) + abs( x_base - abs( x_edge ) )] += filt[x_filt]; ++x_edge; } y_edge += x_dim; } /* if EXPAND and filter is not centered on image edge, mult edge by 2 */ if ( f_or_e IS EXPAND ) { if ( ( abs( x_pos ) ISNT mx_pos ) AND ( x_pos ISNT 0 ) ) _Pragma( "loopbound min 0 max 0" ) for ( y_filt = x_base; y_filt < filt_sz; y_filt += x_dim ) result[y_filt] += result[y_filt]; if ( ( abs( y_pos ) ISNT my_pos ) AND ( y_pos ISNT 0 ) ) _Pragma( "loopbound min 0 max 0" ) for ( x_filt = y_base; x_filt < y_base + x_dim; ++x_filt ) result[x_filt] += result[x_filt]; } } /* Main functions */ void _Pragma( "entrypoint" ) epic_main( void ) { epic_build_pyr( epic_image, X_SIZE, Y_SIZE, NUM_LEVELS, epic_lo_filter, epic_hi_filter, FILTER_SIZE ); } int epic_return(){ int i; int checksum = 0; for ( i=0 ; i