/*
 * Copyright (c) 2003, 2007-11 Matteo Frigo
 * Copyright (c) 2003, 2007-11 Massachusetts Institute of Technology
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
 *
 */

/* This file was automatically generated --- DO NOT EDIT */
/* Generated on Sun Nov 25 07:36:01 EST 2012 */

/*
 * Copyright (c) 2003, 2007-11 Matteo Frigo
 * Copyright (c) 2003, 2007-11 Massachusetts Institute of Technology
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
 *
 */


/*
 * This header file must include every file or define every
 * type or macro which is required to compile a codelet.
 */


/*
 * Copyright (c) 2003, 2007-11 Matteo Frigo
 * Copyright (c) 2003, 2007-11 Massachusetts Institute of Technology
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
 *
 */


/* FFTW internal header file */

/* config.h.  Generated from config.h.in by configure.  */
/* config.h.in.  Generated from configure.ac by autoheader.  */

/* Define to compile in long-double precision. */

/* Define to compile in quad precision. */

/* Define to compile in single precision. */

/* Define to one of `_getb67', `GETB67', `getb67' for Cray-2 and Cray-YMP
   systems. This function is required for `alloca.c' support on those systems.
   */

/* Define to 1 if using `alloca.c'. */

/* Define to disable Fortran wrappers. */
/* #undef DISABLE_FORTRAN */

/* Define to dummy `main' function (if any) required to link to the Fortran
   libraries. */

/* Define to a macro mangling the given C identifier (in lower and upper
   case), which must not contain underscores, for linking with Fortran. */

/* As F77_FUNC, but for C identifiers containing underscores. */

/* Define if F77_FUNC and F77_FUNC_ are equivalent. */

/* Define if F77 and FC dummy `main' functions are identical. */

/* C compiler name and flags */

/* Define to enable extra FFTW debugging code. */

/* Define to enable alignment debugging hacks. */

/* Define to enable debugging malloc. */

/* Define to enable the use of alloca(). */

/* Define to compile in long-double precision. */

/* Define to compile in quad precision. */

/* Define to enable pseudorandom estimate planning for debugging. */

/* Define to compile in single precision. */

/* Define to 1 if you have the `abort' function. */

/* Define to 1 if you have `alloca', as a function or macro. */

/* Define to 1 if you have <alloca.h> and it should be used (not on Ultrix).
   */

/* Define to enable Altivec optimizations. */

/* Define to 1 if you have the <altivec.h> header file. */

/* Define to enable AVX optimizations. */

/* Define to 1 if you have the `BSDgettimeofday' function. */

/* Define to 1 if you have the `clock_gettime' function. */

/* Define to 1 if you have the `cosl' function. */

/* Define to 1 if you have the <c_asm.h> header file. */

/* Define to 1 if you have the declaration of `cosl', and to 0 if you don't.
   */

/* Define to 1 if you have the declaration of `cosq', and to 0 if you don't.
   */

/* Define to 1 if you have the declaration of `drand48', and to 0 if you
   don't. */

/* Define to 1 if you have the declaration of `memalign', and to 0 if you
   don't. */

/* Define to 1 if you have the declaration of `posix_memalign', and to 0 if
   you don't. */

/* Define to 1 if you have the declaration of `sinl', and to 0 if you don't.
   */

/* Define to 1 if you have the declaration of `sinq', and to 0 if you don't.
   */

/* Define to 1 if you have the declaration of `srand48', and to 0 if you
   don't. */

/* Define to 1 if you have the <dlfcn.h> header file. */

/* Define to 1 if you don't have `vprintf' but do have `_doprnt.' */

/* Define to 1 if you have the `drand48' function. */

/* Define if you have a machine with fused multiply-add */

/* Define to 1 if you have the `gethrtime' function. */

/* Define to 1 if you have the `gettimeofday' function. */

/* Define to 1 if hrtime_t is defined in <sys/time.h> */

/* Define to 1 if you have the <intrinsics.h> header file. */

/* Define to 1 if you have the <inttypes.h> header file. */

/* Define if the isnan() function/macro is available. */

/* Define to 1 if you have the <libintl.h> header file. */

/* Define to 1 if you have the `m' library (-lm). */

/* Define to 1 if you have the `quadmath' library (-lquadmath). */

/* Define to 1 if you have the <limits.h> header file. */

/* Define to 1 if the compiler supports `long double' */

/* Define to 1 if you have the `mach_absolute_time' function. */

/* Define to 1 if you have the <mach/mach_time.h> header file. */

/* Define to 1 if you have the <malloc.h> header file. */

/* Define to 1 if you have the `memalign' function. */

/* Define to 1 if you have the <memory.h> header file. */

/* Define to 1 if you have the `memset' function. */

/* Define to enable use of MIPS ZBus cycle-counter. */

/* Define if you have the MPI library. */

/* Define to enable ARM NEON optimizations. */

/* Define if OpenMP is enabled */

/* Define to 1 if you have the `posix_memalign' function. */

/* Define if you have POSIX threads libraries and header files. */

/* Define to 1 if you have the `read_real_time' function. */

/* Define to 1 if you have the `sinl' function. */

/* Define to 1 if you have the `snprintf' function. */

/* Define to 1 if you have the `sqrt' function. */

/* Define to enable SSE/SSE2 optimizations. */

/* Define to 1 if you have the <stddef.h> header file. */

/* Define to 1 if you have the <stdint.h> header file. */

/* Define to 1 if you have the <stdlib.h> header file. */

/* Define to 1 if you have the <strings.h> header file. */

/* Define to 1 if you have the <string.h> header file. */

/* Define to 1 if you have the `sysctl' function. */

/* Define to 1 if you have the <sys/stat.h> header file. */

/* Define to 1 if you have the <sys/sysctl.h> header file. */

/* Define to 1 if you have the <sys/time.h> header file. */

/* Define to 1 if you have the <sys/types.h> header file. */

/* Define to 1 if you have the `tanl' function. */

/* Define if we have a threads library. */

/* Define to 1 if you have the `time_base_to_time' function. */

/* Define to 1 if the system has the type `uintptr_t'. */

/* Define to 1 if you have the <unistd.h> header file. */

/* Define to 1 if you have the `vprintf' function. */

/* Define to 1 if you have the `_mm_free' function. */

/* Define to 1 if you have the `_mm_malloc' function. */

/* Define if you have the UNICOS _rtc() intrinsic. */

/* Define to the sub-directory in which libtool stores uninstalled libraries.
   */

/* Define to 1 if your C compiler doesn't accept -c and -o together. */
/* #undef NO_MINUS_C_MINUS_O */

/* Name of package */

/* Define to the address where bug reports for this package should be sent. */

/* Define to the full name of this package. */

/* Define to the full name and version of this package. */

/* Define to the one symbol short name of this package. */

/* Define to the home page for this package. */

/* Define to the version of this package. */

/* Define to necessary symbol if this constant uses a non-standard name on
   your system. */
/* #undef PTHREAD_CREATE_JOINABLE */

/* The size of `double', as computed by sizeof. */

/* The size of `fftw_r2r_kind', as computed by sizeof. */

/* The size of `float', as computed by sizeof. */

/* The size of `int', as computed by sizeof. */

/* The size of `long', as computed by sizeof. */

/* The size of `long long', as computed by sizeof. */

/* The size of `MPI_Fint', as computed by sizeof. */
/* #undef SIZEOF_MPI_FINT */

/* The size of `ptrdiff_t', as computed by sizeof. */

/* The size of `size_t', as computed by sizeof. */

/* The size of `unsigned int', as computed by sizeof. */

/* The size of `unsigned long', as computed by sizeof. */

/* The size of `unsigned long long', as computed by sizeof. */

/* The size of `void *', as computed by sizeof. */
/* #undef SIZEOF_VOID_P */

/* If using the C implementation of alloca, define if you know the
   direction of stack growth for your system; otherwise it will be
   automatically deduced at runtime.
	STACK_DIRECTION > 0 => grows toward higher addresses
	STACK_DIRECTION < 0 => grows toward lower addresses
	STACK_DIRECTION = 0 => direction of growth unknown */
/* #undef STACK_DIRECTION */

/* Define to 1 if you have the ANSI C header files. */

/* Define to 1 if you can safely include both <sys/time.h> and <time.h>. */

/* Define if we have and are using POSIX threads. */

/* Version number of package */

/* Use common Windows Fortran mangling styles for the Fortran interfaces. */

/* Include g77-compatible wrappers in addition to any other Fortran wrappers.
   */

/* Use our own aligned malloc routine; mainly helpful for Windows systems
   lacking aligned allocation system-library routines. */
/* #undef WITH_OUR_MALLOC */

/* Use low-precision timers, making planner very slow */

/* Define to empty if `const' does not conform to ANSI C. */
/* #undef const */

/* Define to `__inline__' or `__inline' if that's what the C compiler
   calls it, or to nothing if 'inline' is not supported under any name.  */

/* Define to `unsigned int' if <sys/types.h> does not define. */
/* #undef size_t */

/*****************************************************************************/
/* stdlib.h   v8.1.4                                                         */
/*                                                                           */
/* Copyright (c) 1993-2017 Texas Instruments Incorporated                    */
/* http://www.ti.com/                                                        */
/*                                                                           */
/*  Redistribution and  use in source  and binary forms, with  or without    */
/*  modification,  are permitted provided  that the  following conditions    */
/*  are met:                                                                 */
/*                                                                           */
/*     Redistributions  of source  code must  retain the  above copyright    */
/*     notice, this list of conditions and the following disclaimer.         */
/*                                                                           */
/*     Redistributions in binary form  must reproduce the above copyright    */
/*     notice, this  list of conditions  and the following  disclaimer in    */
/*     the  documentation  and/or   other  materials  provided  with  the    */
/*     distribution.                                                         */
/*                                                                           */
/*     Neither the  name of Texas Instruments Incorporated  nor the names    */
/*     of its  contributors may  be used to  endorse or  promote products    */
/*     derived  from   this  software  without   specific  prior  written    */
/*     permission.                                                           */
/*                                                                           */
/*  THIS SOFTWARE  IS PROVIDED BY THE COPYRIGHT  HOLDERS AND CONTRIBUTORS    */
/*  "AS IS"  AND ANY  EXPRESS OR IMPLIED  WARRANTIES, INCLUDING,  BUT NOT    */
/*  LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR    */
/*  A PARTICULAR PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT    */
/*  OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,    */
/*  SPECIAL,  EXEMPLARY,  OR CONSEQUENTIAL  DAMAGES  (INCLUDING, BUT  NOT    */
/*  LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,    */
/*  DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY    */
/*  THEORY OF  LIABILITY, WHETHER IN CONTRACT, STRICT  LIABILITY, OR TORT    */
/*  (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE    */
/*  OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.     */
/*                                                                           */
/*****************************************************************************/



#pragma diag_push
#pragma CHECK_MISRA("-6.3") /* standard types required for standard headers */
#pragma CHECK_MISRA("-8.5") /* need to define inline function */
#pragma CHECK_MISRA("-19.1") /* #includes required for implementation */
#pragma CHECK_MISRA("-19.7") /* need function-like macros */
#pragma CHECK_MISRA("-20.1") /* standard headers must define standard names */
#pragma CHECK_MISRA("-20.2") /* standard headers must define standard names */

/*---------------------------------------------------------------------------*/
/* Attributes are only available in relaxed ANSI mode.                       */
/*---------------------------------------------------------------------------*/


/*---------------------------------------------------------------------------*/
/* <cstdlib> IS RECOMMENDED OVER <stdlib.h>.  <stdlib.h> IS PROVIDED FOR     */
/* COMPATIBILITY WITH C AND THIS USAGE IS DEPRECATED IN C++                  */
/*---------------------------------------------------------------------------*/
extern "C" namespace std {

#pragma diag_push
#pragma CHECK_MISRA("-5.7") /* keep names intact */

typedef struct { int quot, rem; } div_t;

typedef struct { long quot, rem; } ldiv_t;

typedef struct { long long quot, rem; } lldiv_t;

#pragma diag_pop



typedef unsigned size_t;




/*****************************************************************************/
/* linkage.h   v8.1.4                                                        */
/*                                                                           */
/* Copyright (c) 1998-2017 Texas Instruments Incorporated                    */
/* http://www.ti.com/                                                        */
/*                                                                           */
/*  Redistribution and  use in source  and binary forms, with  or without    */
/*  modification,  are permitted provided  that the  following conditions    */
/*  are met:                                                                 */
/*                                                                           */
/*     Redistributions  of source  code must  retain the  above copyright    */
/*     notice, this list of conditions and the following disclaimer.         */
/*                                                                           */
/*     Redistributions in binary form  must reproduce the above copyright    */
/*     notice, this  list of conditions  and the following  disclaimer in    */
/*     the  documentation  and/or   other  materials  provided  with  the    */
/*     distribution.                                                         */
/*                                                                           */
/*     Neither the  name of Texas Instruments Incorporated  nor the names    */
/*     of its  contributors may  be used to  endorse or  promote products    */
/*     derived  from   this  software  without   specific  prior  written    */
/*     permission.                                                           */
/*                                                                           */
/*  THIS SOFTWARE  IS PROVIDED BY THE COPYRIGHT  HOLDERS AND CONTRIBUTORS    */
/*  "AS IS"  AND ANY  EXPRESS OR IMPLIED  WARRANTIES, INCLUDING,  BUT NOT    */
/*  LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR    */
/*  A PARTICULAR PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT    */
/*  OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,    */
/*  SPECIAL,  EXEMPLARY,  OR CONSEQUENTIAL  DAMAGES  (INCLUDING, BUT  NOT    */
/*  LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,    */
/*  DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY    */
/*  THEORY OF  LIABILITY, WHETHER IN CONTRACT, STRICT  LIABILITY, OR TORT    */
/*  (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE    */
/*  OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.     */
/*                                                                           */
/*****************************************************************************/


#pragma diag_push
#pragma CHECK_MISRA("-19.4") /* macros required for implementation */

/*--------------------------------------------------------------------------*/
/* Define _CODE_ACCESS ==> how to call RTS functions                        */
/*--------------------------------------------------------------------------*/

/*--------------------------------------------------------------------------*/
/* Define _DATA_ACCESS ==> how to access RTS global or static data          */
/*--------------------------------------------------------------------------*/
/*--------------------------------------------------------------------------*/
/* Define _DATA_ACCESS_NEAR ==> some C6000 RTS data must always be near     */
/*--------------------------------------------------------------------------*/

/*--------------------------------------------------------------------------*/
/* Define _IDECL ==> how inline functions are declared                      */
/*--------------------------------------------------------------------------*/

/*--------------------------------------------------------------------------*/
/* If compiling with non-TI compiler (e.g. GCC), nullify any TI-specific    */
/* language extensions.                                                     */
/*--------------------------------------------------------------------------*/

#pragma diag_pop


/*---------------------------------------------------------------*/
/* NOTE - Normally, abs, labs, and fabs are expanded inline, so  */
/*        no formal definition is really required. However, ANSI */
/*        requires that they exist as separate functions, so     */
/*        they are supplied in the library.  The prototype is    */
/*        here mainly for documentation.                         */
/*---------------------------------------------------------------*/
#pragma diag_push
#pragma CHECK_MISRA("-16.4") /* false positives due to builtin declarations */
      int       abs(int _val); 
      long      labs(long _val);
      long long llabs(long long _val);
#pragma diag_pop

     int       atoi(const char *_st);
     long      atol(const char *_st);
     long long atoll(const char *_st);
     int       ltoa(long val, char *buffer);
          static __inline double    atof(const char *_st);

     long      strtol(const char *_st, char **_endptr, int _base);
     unsigned long strtoul(const char *_st, char **_endptr,
    					  int _base);
     long long strtoll(const char *_st, char **_endptr, int _base);
     unsigned long long strtoull(const char *_st, char **_endptr,
					     int _base);
     float     strtof(const char * _st, 
                                  char ** _endptr);
     double    strtod(const char * _st, 
                                  char ** _endptr);
     long double strtold(const char * _st, 
                                     char ** _endptr);
    
     int    rand(void);
     void   srand(unsigned _seed);
    
     void  *calloc(size_t _num, size_t _size)
               __attribute__((malloc));
     void  *malloc(size_t _size)
               __attribute__((malloc));
     void  *realloc(void *_ptr, size_t _size)
               __attribute__((malloc));
     void   free(void *_ptr);
     void  *memalign(size_t _aln, size_t _size)
               __attribute__((malloc));
    
     void   abort(void); 

    typedef void (*__TI_atexit_fn)(void);
     int    atexit(__TI_atexit_fn _func);

    typedef int (*__TI_compar_fn)(const void *_a,const void *_b);
     void  *bsearch(const void *_key, const void *_base,
                                size_t _nmemb, size_t _size, 
                                __TI_compar_fn compar);
     void   qsort(void *_base, size_t _nmemb, size_t _size, 
                              __TI_compar_fn compar);

     void   exit(int _status);
    
     div_t  div(int _numer, int _denom);
     ldiv_t ldiv(long _numer, long _denom);
     lldiv_t lldiv(long long _numer, long long _denom);

     char  *getenv(const char *_string);
     int    system(const char *_name);

     int    mblen(const char *_s, size_t _n);
     size_t mbstowcs(wchar_t *_dest, const char *_src, size_t _n);
     int    mbtowc(wchar_t *_dest, const char *_src, size_t _n);

     size_t wcstombs(char *_dest, const wchar_t *_src, size_t _n);
     int    wctomb(char *_s, wchar_t _wc);

} /* extern "C" namespace std */



namespace std {

static __inline double atof(const char *_st) 
{
  return strtod(_st, (char **)0); 
}

} /* namespace std */



#pragma diag_pop


#pragma diag_push

/* using declarations must occur outside header guard to support including both
   C and C++-wrapped version of header; see _CPP_STYLE_HEADER check */
/* this code is for C++ mode only and thus also not relevant for MISRA */
#pragma CHECK_MISRA("-19.15")

using std::div_t;
using std::ldiv_t;
using std::lldiv_t;
using std::size_t;
using std::abs;
using std::labs;
using std::atoi;
using std::atol;
using std::llabs;
using std::atoll;
using std::atof;
using std::strtol;
using std::strtoul;
using std::strtoll;
using std::strtoull;
using std::strtof;
using std::strtod;
using std::strtold;
using std::rand;
using std::srand;
using std::calloc;
using std::malloc;
using std::realloc;
using std::free;
using std::memalign;
using std::abort;
using std::atexit;
using std::bsearch;
using std::qsort;
using std::exit;
using std::div;
using std::ldiv;
using std::lldiv;
using std::getenv;
using std::system;
using std::mblen;
using std::mbtowc;
using std::wctomb;
using std::mbstowcs;
using std::wcstombs;

#pragma diag_pop

#pragma diag_push

/* C2000-specific additions to header implemented with #include */
#pragma CHECK_MISRA("-19.1")
#pragma CHECK_MISRA("-19.15")


#pragma diag_pop
/*****************************************************************************/
/* stdarg.h   v8.1.4                                                         */
/*                                                                           */
/* Copyright (c) 1993-2017 Texas Instruments Incorporated                    */
/* http://www.ti.com/                                                        */
/*                                                                           */
/*  Redistribution and  use in source  and binary forms, with  or without    */
/*  modification,  are permitted provided  that the  following conditions    */
/*  are met:                                                                 */
/*                                                                           */
/*     Redistributions  of source  code must  retain the  above copyright    */
/*     notice, this list of conditions and the following disclaimer.         */
/*                                                                           */
/*     Redistributions in binary form  must reproduce the above copyright    */
/*     notice, this  list of conditions  and the following  disclaimer in    */
/*     the  documentation  and/or   other  materials  provided  with  the    */
/*     distribution.                                                         */
/*                                                                           */
/*     Neither the  name of Texas Instruments Incorporated  nor the names    */
/*     of its  contributors may  be used to  endorse or  promote products    */
/*     derived  from   this  software  without   specific  prior  written    */
/*     permission.                                                           */
/*                                                                           */
/*  THIS SOFTWARE  IS PROVIDED BY THE COPYRIGHT  HOLDERS AND CONTRIBUTORS    */
/*  "AS IS"  AND ANY  EXPRESS OR IMPLIED  WARRANTIES, INCLUDING,  BUT NOT    */
/*  LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR    */
/*  A PARTICULAR PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT    */
/*  OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,    */
/*  SPECIAL,  EXEMPLARY,  OR CONSEQUENTIAL  DAMAGES  (INCLUDING, BUT  NOT    */
/*  LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,    */
/*  DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY    */
/*  THEORY OF  LIABILITY, WHETHER IN CONTRACT, STRICT  LIABILITY, OR TORT    */
/*  (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE    */
/*  OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.     */
/*                                                                           */
/*****************************************************************************/


#pragma diag_push
#pragma CHECK_MISRA("-20.1") /* standard headers must define standard names */
#pragma CHECK_MISRA("-20.2") /* standard headers must define standard names */
#pragma CHECK_MISRA("-19.7") /* macros required for implementation */
#pragma CHECK_MISRA("-19.10") /* need types as macro arguments */

namespace std
{

    typedef char *va_list;

}

/*****************************************************************************/
/* LLVM VARARGS HANDLING - Use builtin operations.                           */
/*****************************************************************************/

/*****************************************************************************/
/* VA_END - Reclaim resources used by varargs handling.                      */
/*                                                                           */
/* No action needed                                                          */
/*****************************************************************************/

/*****************************************************************************/
/* VA_START - Set up the va_list pointer.                                    */
/*****************************************************************************/


/*---------------------------------------------------------------------------*/
/* ELF ABI convention:                                                       */
/* - va_list pointer points one byte beyond the last argument.               */
/*---------------------------------------------------------------------------*/



/*****************************************************************************/
/* VA_ARG - Return the next argument, adjust va_list pointer                 */
/*                                                                           */
/* Some arguments passed by value are turned into pass-by-reference by       */
/* making a temporary object and passing a pointer to this temporary.  For   */
/* such an argument (indicated by __va_argref(_type)) the actual argument    */
/* passed is a pointer, so it must be dealt with specially.                  */
/*                                                                           */
/* When an argument is larger than the maximum alignment (8 bytes for double */
/* or long long), we only align to 8 bytes.                                  */
/*****************************************************************************/

/*---------------------------------------------------------------------------*/
/* What happens on every va_arg(_ap, _type) call is:                         */
/* 1) Align the value of _ap (the va_list pointer) appropriately for _type   */
/*    (the requested type).                                                  */
/* 2) Increment _ap appropriately for _type.                                 */
/* 3) Return the value desired by dereferencing _ap.                         */
/*---------------------------------------------------------------------------*/


/*---------------------------------------------------------------------------*/
/* 1) Align _ap to satisfy alignment of _type.                               */
/* 2) Increment _ap by sizeof(_type)                                         */
/* 3) return *(ap-sizeof(_type))                                             */
/*---------------------------------------------------------------------------*/







/*---------------------------------------------------------------------------*/
/* The big- and little-endian variants are different only because we are     */
/* trying to support the case of the user asking for "char" or "short",      */
/* which is actually undefined behavior (See ISO/IEC 9899:1999 7.15.1.1),    */
/* but we are trying to be friendly.                                         */
/*---------------------------------------------------------------------------*/






#pragma diag_pop


#pragma diag_push

/* using declarations must occur outside header guard to support including both
   C and C++-wrapped version of header; see _CPP_STYLE_HEADER check */
/* this code is for C++ mode only and thus also not relevant for MISRA */
#pragma CHECK_MISRA("-19.15")

using std::va_list;

#pragma diag_pop
/*****************************************************************************/
/* stddef.h   v8.1.4                                                         */
/*                                                                           */
/* Copyright (c) 1993-2017 Texas Instruments Incorporated                    */
/* http://www.ti.com/                                                        */
/*                                                                           */
/*  Redistribution and  use in source  and binary forms, with  or without    */
/*  modification,  are permitted provided  that the  following conditions    */
/*  are met:                                                                 */
/*                                                                           */
/*     Redistributions  of source  code must  retain the  above copyright    */
/*     notice, this list of conditions and the following disclaimer.         */
/*                                                                           */
/*     Redistributions in binary form  must reproduce the above copyright    */
/*     notice, this  list of conditions  and the following  disclaimer in    */
/*     the  documentation  and/or   other  materials  provided  with  the    */
/*     distribution.                                                         */
/*                                                                           */
/*     Neither the  name of Texas Instruments Incorporated  nor the names    */
/*     of its  contributors may  be used to  endorse or  promote products    */
/*     derived  from   this  software  without   specific  prior  written    */
/*     permission.                                                           */
/*                                                                           */
/*  THIS SOFTWARE  IS PROVIDED BY THE COPYRIGHT  HOLDERS AND CONTRIBUTORS    */
/*  "AS IS"  AND ANY  EXPRESS OR IMPLIED  WARRANTIES, INCLUDING,  BUT NOT    */
/*  LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR    */
/*  A PARTICULAR PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT    */
/*  OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,    */
/*  SPECIAL,  EXEMPLARY,  OR CONSEQUENTIAL  DAMAGES  (INCLUDING, BUT  NOT    */
/*  LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,    */
/*  DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY    */
/*  THEORY OF  LIABILITY, WHETHER IN CONTRACT, STRICT  LIABILITY, OR TORT    */
/*  (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE    */
/*  OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.     */
/*                                                                           */
/*****************************************************************************/


#pragma diag_push
#pragma CHECK_MISRA("-19.7") /* macros required for implementation */
#pragma CHECK_MISRA("-20.1") /* standard headers must define standard names */
#pragma CHECK_MISRA("-20.2") /* standard headers must define standard names */

extern "C" namespace std {


typedef int ptrdiff_t;



#pragma diag_push
#pragma CHECK_MISRA("-19.10") /* need types as macro arguments */


} /* extern "C" namespace std */

#pragma diag_pop


using std::ptrdiff_t;
using std::size_t;
/*using std::wchar_t;*/

#pragma diag_push
#pragma CHECK_MISRA("-19.15") /* code outside guard; see below comment */

/*-----------------------------------------------------------------------*/
/* Define _win_t, for compiling GCC libraries with the TI compiler.      */
/* GCC's library (newlib) expects wint_t to be defined here, in stddef.h,*/
/* which is arguably incorrect, but we go along for compatibility.       */
/* This is outside the _STDDEF guard in case this file has already       */
/* been included without __need_wint_t.                                  */
/*-----------------------------------------------------------------------*/

#pragma diag_pop



/*****************************************************************************/
/* STDINT.H v8.1.4                                                           */
/*                                                                           */
/* Copyright (c) 2002-2017 Texas Instruments Incorporated                    */
/* http://www.ti.com/                                                        */
/*                                                                           */
/*  Redistribution and  use in source  and binary forms, with  or without    */
/*  modification,  are permitted provided  that the  following conditions    */
/*  are met:                                                                 */
/*                                                                           */
/*     Redistributions  of source  code must  retain the  above copyright    */
/*     notice, this list of conditions and the following disclaimer.         */
/*                                                                           */
/*     Redistributions in binary form  must reproduce the above copyright    */
/*     notice, this  list of conditions  and the following  disclaimer in    */
/*     the  documentation  and/or   other  materials  provided  with  the    */
/*     distribution.                                                         */
/*                                                                           */
/*     Neither the  name of Texas Instruments Incorporated  nor the names    */
/*     of its  contributors may  be used to  endorse or  promote products    */
/*     derived  from   this  software  without   specific  prior  written    */
/*     permission.                                                           */
/*                                                                           */
/*  THIS SOFTWARE  IS PROVIDED BY THE COPYRIGHT  HOLDERS AND CONTRIBUTORS    */
/*  "AS IS"  AND ANY  EXPRESS OR IMPLIED  WARRANTIES, INCLUDING,  BUT NOT    */
/*  LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR    */
/*  A PARTICULAR PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT    */
/*  OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,    */
/*  SPECIAL,  EXEMPLARY,  OR CONSEQUENTIAL  DAMAGES  (INCLUDING, BUT  NOT    */
/*  LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,    */
/*  DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY    */
/*  THEORY OF  LIABILITY, WHETHER IN CONTRACT, STRICT  LIABILITY, OR TORT    */
/*  (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE    */
/*  OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.     */
/*                                                                           */
/*****************************************************************************/

/* 7.18.1.1 Exact-width integer types */

    typedef   signed char   int8_t;
    typedef unsigned char  uint8_t;
    typedef          short  int16_t;
    typedef unsigned short uint16_t;
    typedef          int    int32_t;
    typedef unsigned int   uint32_t;

    typedef          __int40_t  int40_t;
    typedef unsigned __int40_t uint40_t;

    typedef          long long  int64_t;
    typedef unsigned long long uint64_t;

/* 7.18.1.2 Minimum-width integer types */

    typedef  int8_t   int_least8_t;
    typedef uint8_t  uint_least8_t;

    typedef  int16_t  int_least16_t;
    typedef uint16_t uint_least16_t;
    typedef  int32_t  int_least32_t;
    typedef uint32_t uint_least32_t;

    typedef  int40_t  int_least40_t;
    typedef uint40_t uint_least40_t;

    typedef  int64_t  int_least64_t;
    typedef uint64_t uint_least64_t;

/* 7.18.1.3 Fastest minimum-width integer types */

    typedef  int32_t  int_fast8_t;
    typedef uint32_t uint_fast8_t;
    typedef  int32_t  int_fast16_t;
    typedef uint32_t uint_fast16_t;

    typedef  int32_t  int_fast32_t;
    typedef uint32_t uint_fast32_t;

    typedef  int40_t  int_fast40_t;
    typedef uint40_t uint_fast40_t;

    typedef  int64_t  int_fast64_t;
    typedef uint64_t uint_fast64_t;

/* 7.18.1.4 Integer types capable of holding object pointers */
    typedef          int intptr_t;
    typedef unsigned int uintptr_t;

/* 7.18.1.5 Greatest-width integer types */
    typedef          long long intmax_t;
    typedef unsigned long long uintmax_t;

/* 
   According to footnotes in the 1999 C standard, "C++ implementations
   should define these macros only when __STDC_LIMIT_MACROS is defined
   before <stdint.h> is included." 
*/


/*****************************************************************************/
/* INTTYPES.H v8.1.4                                                         */
/*                                                                           */
/* Copyright (c) 2002-2017 Texas Instruments Incorporated                    */
/* http://www.ti.com/                                                        */
/*                                                                           */
/*  Redistribution and  use in source  and binary forms, with  or without    */
/*  modification,  are permitted provided  that the  following conditions    */
/*  are met:                                                                 */
/*                                                                           */
/*     Redistributions  of source  code must  retain the  above copyright    */
/*     notice, this list of conditions and the following disclaimer.         */
/*                                                                           */
/*     Redistributions in binary form  must reproduce the above copyright    */
/*     notice, this  list of conditions  and the following  disclaimer in    */
/*     the  documentation  and/or   other  materials  provided  with  the    */
/*     distribution.                                                         */
/*                                                                           */
/*     Neither the  name of Texas Instruments Incorporated  nor the names    */
/*     of its  contributors may  be used to  endorse or  promote products    */
/*     derived  from   this  software  without   specific  prior  written    */
/*     permission.                                                           */
/*                                                                           */
/*  THIS SOFTWARE  IS PROVIDED BY THE COPYRIGHT  HOLDERS AND CONTRIBUTORS    */
/*  "AS IS"  AND ANY  EXPRESS OR IMPLIED  WARRANTIES, INCLUDING,  BUT NOT    */
/*  LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR    */
/*  A PARTICULAR PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT    */
/*  OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,    */
/*  SPECIAL,  EXEMPLARY,  OR CONSEQUENTIAL  DAMAGES  (INCLUDING, BUT  NOT    */
/*  LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,    */
/*  DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY    */
/*  THEORY OF  LIABILITY, WHETHER IN CONTRACT, STRICT  LIABILITY, OR TORT    */
/*  (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE    */
/*  OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.     */
/*                                                                           */
/*****************************************************************************/



/* 7.8 Format conversion of integer types */

typedef struct { intmax_t quot, rem; } imaxdiv_t;

/* 
   According to footnotes in the 1999 C standard, "C++ implementations
   should define these macros only when __STDC_FORMAT_MACROS is defined
   before <inttypes.h> is included." 
*/

/* 7.8.2 Functions for greatest-width integer types */

extern "C" namespace std {

 intmax_t  imaxabs(intmax_t j);
 imaxdiv_t imaxdiv(intmax_t numer, intmax_t denom);
 intmax_t  strtoimax(const char * __restrict nptr, 
		    char ** __restrict endptr, int base);
 uintmax_t strtoumax(const char * __restrict nptr, 
		    char ** __restrict endptr, int base);

}

using std::imaxabs;
using std::imaxdiv;
using std::strtoimax;
using std::strtoumax;


extern "C"
{

/* Windows annoyances -- since tests/hook.c uses some internal
   FFTW functions, we need to given them the dllexport attribute
   under Windows when compiling as a DLL (see api/fftw3.h). */

/* determine precision and name-mangling scheme */
//#define FFTW_SINGLE
  typedef int R;

/*
  integral type large enough to contain a stride (what ``int'' should
  have been in the first place.
*/
typedef ptrdiff_t INT;

/* dummy use of unused parameters to silence compiler warnings */


extern void fftwi_extract_reim(int sign, R *c, R **r, R **i);



/* define HAVE_SIMD if any simd extensions are supported */

extern int fftwi_have_simd_sse2(void);
extern int fftwi_have_simd_avx(void);
extern int fftwi_have_simd_altivec(void);
extern int fftwi_have_simd_neon(void);

/* forward declarations */
typedef struct problem_s problem;
typedef struct plan_s plan;
typedef struct solver_s solver;
typedef struct planner_s planner;
typedef struct printer_s printer;
typedef struct scanner_s scanner;

/*-----------------------------------------------------------------------*/
/* alloca: */

   /* use malloc instead of alloca */

/* allocation of buffers.  If these grow too large use malloc(), else
   use STACK_MALLOC (hopefully reducing to alloca()). */

/* 64KiB ought to be enough for anybody */



/*-----------------------------------------------------------------------*/
/* define uintptr_t if it is not already defined */


/*-----------------------------------------------------------------------*/
/* We can do an optimization for copying pairs of (aligned) floats
   when in single precision if 2*float = double. */



/*-----------------------------------------------------------------------*/
/* assert.c: */
extern void fftwi_assertion_failed(const char *s, 
				      int line, const char *file);

/* always check */


extern void fftwi_debug(const char *format, ...);

/*-----------------------------------------------------------------------*/
/* kalloc.c: */
extern void *fftwi_kernel_malloc(size_t n);
extern void fftwi_kernel_free(void *p);

/*-----------------------------------------------------------------------*/
/* alloc.c: */

/* objects allocated by malloc, for statistical purposes */
enum malloc_tag {
     EVERYTHING,
     PLANS,
     SOLVERS,
     PROBLEMS,
     BUFFERS,
     HASHT,
     TENSORS,
     PLANNERS,
     SLVDESCS,
     TWIDDLES,
     STRIDES,
     OTHER,
     MALLOC_WHAT_LAST		/* must be last */
};

extern void fftwi_ifree(void *ptr);
extern void fftwi_ifree0(void *ptr);


extern void *fftwi_malloc_plain(size_t sz);



/*-----------------------------------------------------------------------*/
/* low-resolution clock */

/*****************************************************************************/
/* time.h     v8.1.4                                                         */
/*                                                                           */
/* Copyright (c) 1990-2017 Texas Instruments Incorporated                    */
/* http://www.ti.com/                                                        */
/*                                                                           */
/*  Redistribution and  use in source  and binary forms, with  or without    */
/*  modification,  are permitted provided  that the  following conditions    */
/*  are met:                                                                 */
/*                                                                           */
/*     Redistributions  of source  code must  retain the  above copyright    */
/*     notice, this list of conditions and the following disclaimer.         */
/*                                                                           */
/*     Redistributions in binary form  must reproduce the above copyright    */
/*     notice, this  list of conditions  and the following  disclaimer in    */
/*     the  documentation  and/or   other  materials  provided  with  the    */
/*     distribution.                                                         */
/*                                                                           */
/*     Neither the  name of Texas Instruments Incorporated  nor the names    */
/*     of its  contributors may  be used to  endorse or  promote products    */
/*     derived  from   this  software  without   specific  prior  written    */
/*     permission.                                                           */
/*                                                                           */
/*  THIS SOFTWARE  IS PROVIDED BY THE COPYRIGHT  HOLDERS AND CONTRIBUTORS    */
/*  "AS IS"  AND ANY  EXPRESS OR IMPLIED  WARRANTIES, INCLUDING,  BUT NOT    */
/*  LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR    */
/*  A PARTICULAR PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT    */
/*  OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,    */
/*  SPECIAL,  EXEMPLARY,  OR CONSEQUENTIAL  DAMAGES  (INCLUDING, BUT  NOT    */
/*  LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,    */
/*  DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY    */
/*  THEORY OF  LIABILITY, WHETHER IN CONTRACT, STRICT  LIABILITY, OR TORT    */
/*  (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE    */
/*  OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.     */
/*                                                                           */
/*****************************************************************************/







extern "C" namespace std {

typedef unsigned int clock_t;
typedef unsigned int __time32_t;

typedef long long __time64_t;


typedef __time32_t time_t;


struct tm 
{
    int tm_sec;      /* seconds after the minute   - [0,59]  */
    int tm_min;      /* minutes after the hour     - [0,59]  */
    int tm_hour;     /* hours after the midnight   - [0,23]  */
    int tm_mday;     /* day of the month           - [1,31]  */
    int tm_mon;      /* months since January       - [0,11]  */
    int tm_year;     /* years since 1900                     */
    int tm_wday;     /* days since Sunday          - [0,6]   */
    int tm_yday;     /* days since Jan 1st         - [0,365] */
    int tm_isdst;    /* Daylight Savings Time flag           */

};

/*************************************************************************/
/* TIME ZONE STRUCTURE DEFINITION                                        */
/*************************************************************************/
typedef struct 
{
    short daylight;
    long  timezone;
    char  tzname[4];
    char  dstname[4];
} TZ;

extern __far TZ _tz;

/****************************************************************************/
/* FUNCTION DECLARATIONS.  (NOTE : clock AND time ARE SYSTEM SPECIFIC)      */
/****************************************************************************/
 clock_t    clock(void);             

 __time32_t __time32(__time32_t *_timer);   
 __time32_t __mktime32(struct tm *_tptr);
 double     __difftime32(__time32_t _time1, __time32_t _time0);
      static __inline char      *__ctime32(const __time32_t *_timer);
 struct tm *__gmtime32(const __time32_t *_timer);
 struct tm *__localtime32(const __time32_t *_timer);

 __time64_t __time64(__time64_t *_timer);   
 __time64_t __mktime64(struct tm *_tptr);
 double     __difftime64(__time64_t _time1, __time64_t _time0);
      static __inline char      *__ctime64(const __time64_t *_timer);
 struct tm *__gmtime64(const __time64_t *_timer);
 struct tm *__localtime64(const __time64_t *_timer);

 char      *asctime(const struct tm *_timeptr);
 size_t     strftime(char *_out, size_t _maxsize, 
				 const char *_format,
				 const struct tm *_timeptr);

static __inline char *__ctime32(const __time32_t *timer)
{
   return asctime(__localtime32(timer));
}

static __inline char *__ctime64(const __time64_t *timer)
{
   return asctime(__localtime64(timer));
}

/*-----------------------------------------------------------------------*/
/* The user may define __TI_TIME_USES_64=1 to redirects all time        */
/* functions to time64 functions.                                        */
/*-----------------------------------------------------------------------*/
 time_t     time(time_t *_timer);   
 time_t     mktime(struct tm *_tptr);
 double     difftime(time_t _time1, time_t _time0);
      static __inline char      *ctime(const time_t *_timer);
 struct tm *gmtime(const time_t *_timer);
 struct tm *localtime(const time_t *_timer);
  static __inline char *ctime(const time_t *timer)
  {
     return asctime(localtime(timer));
  }

} /* extern "C" */


using std::size_t;
using std::clock_t;
using std::clock;

using std::tm;
using std::TZ;
using std::_tz;
using std::__time32_t;
using std::__time64_t;
using std::__time32;
using std::__time64;
using std::__ctime32;
using std::__ctime64;
using std::__difftime32;
using std::__difftime64;
using std::__gmtime32;
using std::__gmtime64;
using std::__localtime32;
using std::__localtime64;
using std::__mktime32;
using std::__mktime64;
using std::time_t;
using std::time;
using std::ctime;
using std::difftime;
using std::gmtime;
using std::localtime;
using std::mktime;

using std::asctime;
using std::strftime;


   typedef clock_t crude_time;

crude_time fftwi_get_crude_time(void);
double fftwi_elapsed_since(const planner *plnr, const problem *p,
			crude_time t0); /* time in seconds since t0 */

/*-----------------------------------------------------------------------*/
/* ops.c: */
/*
 * ops counter.  The total number of additions is add + fma
 * and the total number of multiplications is mul + fma.
 * Total flops = add + mul + 2 * fma
 */
typedef struct {
     double add;
     double mul;
     double fma;
     double other;
} opcnt;

void fftwi_ops_zero(opcnt *dst);
void fftwi_ops_other(INT o, opcnt *dst);
void fftwi_ops_cpy(const opcnt *src, opcnt *dst);

void fftwi_ops_add(const opcnt *a, const opcnt *b, opcnt *dst);
void fftwi_ops_add2(const opcnt *a, opcnt *dst);

/* dst = m * a + b */
void fftwi_ops_madd(INT m, const opcnt *a, const opcnt *b, opcnt *dst);

/* dst += m * a */
void fftwi_ops_madd2(INT m, const opcnt *a, opcnt *dst);


/*-----------------------------------------------------------------------*/
/* minmax.c: */
INT fftwi_imax(INT a, INT b);
INT fftwi_imin(INT a, INT b);

/*-----------------------------------------------------------------------*/
/* iabs.c: */
INT fftwi_iabs(INT a);

/* inline version */

/*-----------------------------------------------------------------------*/
/* md5.c */

typedef unsigned int md5uint;

typedef md5uint md5sig[4];

typedef struct {
     md5sig s; /* state and signature */

     /* fields not meant to be used outside md5.c: */
     unsigned char c[64]; /* stuff not yet processed */
     unsigned l;  /* total length.  Should be 64 bits long, but this is
		     good enough for us */
} md5;

void fftwi_md5begin(md5 *p);
void fftwi_md5putb(md5 *p, const void *d_, size_t len);
void fftwi_md5puts(md5 *p, const char *s);
void fftwi_md5putc(md5 *p, unsigned char c);
void fftwi_md5int(md5 *p, int i);
void fftwi_md5INT(md5 *p, INT i);
void fftwi_md5unsigned(md5 *p, unsigned i);
void fftwi_md5end(md5 *p);

/*-----------------------------------------------------------------------*/
/* tensor.c: */

typedef struct {
     INT n;
     INT is;			/* input stride */
     INT os;			/* output stride */
} iodim;

typedef struct {
     int rnk;
     iodim dims[1];
} tensor;

/*
  Definition of rank -infinity.
  This definition has the property that if you want rank 0 or 1,
  you can simply test for rank <= 1.  This is a common case.
 
  A tensor of rank -infinity has size 0.
*/

typedef enum { INPLACE_IS, INPLACE_OS } inplace_kind;

tensor *fftwi_mktensor(int rnk);
tensor *fftwi_mktensor_0d(void);
tensor *fftwi_mktensor_1d(INT n, INT is, INT os);
tensor *fftwi_mktensor_2d(INT n0, INT is0, INT os0,
		       INT n1, INT is1, INT os1);
tensor *fftwi_mktensor_3d(INT n0, INT is0, INT os0,
		       INT n1, INT is1, INT os1,
		       INT n2, INT is2, INT os2);
tensor *fftwi_mktensor_4d(INT n0, INT is0, INT os0,
		       INT n1, INT is1, INT os1,
		       INT n2, INT is2, INT os2,
		       INT n3, INT is3, INT os3);
tensor *fftwi_mktensor_5d(INT n0, INT is0, INT os0,
		       INT n1, INT is1, INT os1,
		       INT n2, INT is2, INT os2,
		       INT n3, INT is3, INT os3,
		       INT n4, INT is4, INT os4);
INT fftwi_tensor_sz(const tensor *sz);
void fftwi_tensor_md5(md5 *p, const tensor *t);
INT fftwi_tensor_max_index(const tensor *sz);
INT fftwi_tensor_min_istride(const tensor *sz);
INT fftwi_tensor_min_ostride(const tensor *sz);
INT fftwi_tensor_min_stride(const tensor *sz);
int fftwi_tensor_inplace_strides(const tensor *sz);
int fftwi_tensor_inplace_strides2(const tensor *a, const tensor *b);
int fftwi_tensor_strides_decrease(const tensor *sz, const tensor *vecsz,
                               inplace_kind k);
tensor *fftwi_tensor_copy(const tensor *sz);
int fftwi_tensor_kosherp(const tensor *x);

tensor *fftwi_tensor_copy_inplace(const tensor *sz, inplace_kind k);
tensor *fftwi_tensor_copy_except(const tensor *sz, int except_dim);
tensor *fftwi_tensor_copy_sub(const tensor *sz, int start_dim, int rnk);
tensor *fftwi_tensor_compress(const tensor *sz);
tensor *fftwi_tensor_compress_contiguous(const tensor *sz);
tensor *fftwi_tensor_append(const tensor *a, const tensor *b);
void fftwi_tensor_split(const tensor *sz, tensor **a, int a_rnk, tensor **b);
int fftwi_tensor_tornk1(const tensor *t, INT *n, INT *is, INT *os);
void fftwi_tensor_destroy(tensor *sz);
void fftwi_tensor_destroy2(tensor *a, tensor *b);
void fftwi_tensor_destroy4(tensor *a, tensor *b, tensor *c, tensor *d);
void fftwi_tensor_print(const tensor *sz, printer *p);
int fftwi_dimcmp(const iodim *a, const iodim *b);
int fftwi_tensor_equal(const tensor *a, const tensor *b);
int fftwi_tensor_inplace_locations(const tensor *sz, const tensor *vecsz);

/*-----------------------------------------------------------------------*/
/* problem.c: */
enum { 
     /* a problem that cannot be solved */
     PROBLEM_UNSOLVABLE,

     PROBLEM_DFT, 
     PROBLEM_RDFT,
     PROBLEM_RDFT2,

     /* for mpi/ subdirectory */
     PROBLEM_MPI_DFT,
     PROBLEM_MPI_RDFT,
     PROBLEM_MPI_RDFT2,
     PROBLEM_MPI_TRANSPOSE,

     PROBLEM_LAST 
};

typedef struct {
     int problem_kind;
     void (*hash) (const problem *ego, md5 *p);
     void (*zero) (const problem *ego);
     void (*print) (const problem *ego, printer *p);
     void (*destroy) (problem *ego);
} problem_adt;

struct problem_s {
     const problem_adt *adt;
};

problem *fftwi_mkproblem(size_t sz, const problem_adt *adt);
void fftwi_problem_destroy(problem *ego);
problem *fftwi_mkproblem_unsolvable(void);

/*-----------------------------------------------------------------------*/
/* print.c */
struct printer_s {
     void (*print)(printer *p, const char *format, ...);
     void (*vprint)(printer *p, const char *format, va_list ap);
     void (*putchr)(printer *p, char c);
     void (*cleanup)(printer *p);
     int indent;
     int indent_incr;
};

printer *fftwi_mkprinter(size_t size, 
		      void (*putchr)(printer *p, char c),
		      void (*cleanup)(printer *p));
extern void fftwi_printer_destroy(printer *p);

/*-----------------------------------------------------------------------*/
/* scan.c */
struct scanner_s {
     int (*scan)(scanner *sc, const char *format, ...);
     int (*vscan)(scanner *sc, const char *format, va_list ap);
     int (*getchr)(scanner *sc);
     int ungotc;
};

scanner *fftwi_mkscanner(size_t size, int (*getchr)(scanner *sc));
void fftwi_scanner_destroy(scanner *sc);

/*-----------------------------------------------------------------------*/
/* plan.c: */

enum wakefulness {
     SLEEPY,
     AWAKE_ZERO,
     AWAKE_SQRTN_TABLE,
     AWAKE_SINCOS
};

typedef struct {
     void (*solve)(const plan *ego, const problem *p);
     void (*awake)(plan *ego, enum wakefulness wakefulness);
     void (*print)(const plan *ego, printer *p);
     void (*destroy)(plan *ego);
} plan_adt;

struct plan_s {
     const plan_adt *adt;
     opcnt ops;
     double pcost;
     enum wakefulness wakefulness; /* used for debugging only */
     int could_prune_now_p;
};

plan *fftwi_mkplan(size_t size, const plan_adt *adt);
void fftwi_plan_destroy_internal(plan *ego);
extern void fftwi_plan_awake(plan *ego, enum wakefulness wakefulness);
void fftwi_plan_null_destroy(plan *ego);

/*-----------------------------------------------------------------------*/
/* solver.c: */
typedef struct {
     int problem_kind;
     plan *(*mkplan)(const solver *ego, const problem *p, planner *plnr);
     void (*destroy)(solver *ego);
} solver_adt;

struct solver_s {
     const solver_adt *adt;
     int refcnt;
};

solver *fftwi_mksolver(size_t size, const solver_adt *adt);
void fftwi_solver_use(solver *ego);
void fftwi_solver_destroy(solver *ego);
void fftwi_solver_register(planner *plnr, solver *s);

/* shorthand */

/*-----------------------------------------------------------------------*/
/* planner.c */

typedef struct slvdesc_s {
     solver *slv;
     const char *reg_nam;
     unsigned nam_hash;
     int reg_id;
     int next_for_same_problem_kind;
} slvdesc;

typedef struct solution_s solution; /* opaque */

/* interpretation of L and U: 

   - if it returns a plan, the planner guarantees that all applicable
     plans at least as impatient as U have been tried, and that each
     plan in the solution is at least as impatient as L.
   
   - if it returns 0, the planner guarantees to have tried all solvers
     at least as impatient as L, and that none of them was applicable.

   The structure is packed to fit into 64 bits.
*/

typedef struct {
     unsigned l:20;
     unsigned hash_info:3;
     unsigned timelimit_impatience:9;
     unsigned u:20;
     
     /* abstraction break: we store the solver here to pad the
	structure to 64 bits.  Otherwise, the struct is padded to 64
	bits anyway, and another word is allocated for slvndx. */
     unsigned slvndx:12;
} flags_t;

/* impatience flags  */
enum {
     BELIEVE_PCOST = 0x0001,
     ESTIMATE = 0x0002,
     NO_DFT_R2HC = 0x0004,
     NO_SLOW = 0x0008,
     NO_VRECURSE = 0x0010,
     NO_INDIRECT_OP = 0x0020,
     NO_LARGE_GENERIC = 0x0040,
     NO_RANK_SPLITS = 0x0080,
     NO_VRANK_SPLITS = 0x0100,
     NO_NONTHREADED = 0x0200,
     NO_BUFFERING = 0x0400,
     NO_FIXED_RADIX_LARGE_N = 0x0800,
     NO_DESTROY_INPUT = 0x1000,
     NO_SIMD = 0x2000,
     CONSERVE_MEMORY = 0x4000,
     NO_DHT_R2HC = 0x8000,
     NO_UGLY = 0x10000,
     ALLOW_PRUNING = 0x20000
};

/* hashtable information */
enum {
     BLESSING = 0x1,   /* save this entry */
     H_VALID = 0x2,    /* valid hastable entry */
     H_LIVE = 0x4      /* entry is nonempty, implies H_VALID */
};





typedef enum { FORGET_ACCURSED, FORGET_EVERYTHING } amnesia;

typedef enum { 
     /* WISDOM_NORMAL: planner may or may not use wisdom */
     WISDOM_NORMAL, 

     /* WISDOM_ONLY: planner must use wisdom and must avoid searching */
     WISDOM_ONLY, 

     /* WISDOM_IS_BOGUS: planner must return 0 as quickly as possible */
     WISDOM_IS_BOGUS,

     /* WISDOM_IGNORE_INFEASIBLE: planner ignores infeasible wisdom */
     WISDOM_IGNORE_INFEASIBLE,

     /* WISDOM_IGNORE_ALL: planner ignores all */
     WISDOM_IGNORE_ALL
} wisdom_state_t;

typedef struct {
     void (*register_solver)(planner *ego, solver *s);
     plan *(*mkplan)(planner *ego, const problem *p);
     void (*forget)(planner *ego, amnesia a);
     void (*exprt)(planner *ego, printer *p); /* ``export'' is a reserved
						 word in C++. */
     int (*imprt)(planner *ego, scanner *sc);
} planner_adt;

/* hash table of solutions */
typedef struct {
     solution *solutions;
     unsigned hashsiz, nelem;

     /* statistics */
     int lookup, succ_lookup, lookup_iter;
     int insert, insert_iter, insert_unknown;
     int nrehash;
} hashtab;

typedef enum { COST_SUM, COST_MAX } cost_kind;

struct planner_s {
     const planner_adt *adt;
     void (*hook)(struct planner_s *plnr, plan *pln, 
		  const problem *p, int optimalp);
     double (*cost_hook)(const problem *p, double t, cost_kind k);
     int (*wisdom_ok_hook)(const problem *p, flags_t flags);
     void (*nowisdom_hook)(const problem *p);
     wisdom_state_t (*bogosity_hook)(wisdom_state_t state, const problem *p);

     /* solver descriptors */
     slvdesc *slvdescs;
     unsigned nslvdesc, slvdescsiz;
     const char *cur_reg_nam;
     int cur_reg_id;
     int slvdescs_for_problem_kind[PROBLEM_LAST];

     wisdom_state_t wisdom_state;

     hashtab htab_blessed;
     hashtab htab_unblessed;

     int nthr;
     flags_t flags;

     crude_time start_time;
     double timelimit; /* elapsed_since(start_time) at which to bail out */
     int timed_out; /* whether most recent search timed out */
     int need_timeout_check;

     /* various statistics */
     int nplan;    /* number of plans evaluated */
     double pcost, epcost; /* total pcost of measured/estimated plans */
     int nprob;    /* number of problems evaluated */
};

planner *fftwi_mkplanner(void);
void fftwi_planner_destroy(planner *ego);

/*
  Iterate over all solvers.   Read:
 
  @article{ baker93iterators,
  author = "Henry G. Baker, Jr.",
  title = "Iterators: Signs of Weakness in Object-Oriented Languages",
  journal = "{ACM} {OOPS} Messenger",
  volume = "4",
  number = "3",
  pages = "18--25"
  }
*/



/* make plan, destroy problem */
plan *fftwi_mkplan_d(planner *ego, problem *p);
plan *fftwi_mkplan_f_d(planner *ego, problem *p, 
		    unsigned l_set, unsigned u_set, unsigned u_reset);

/*-----------------------------------------------------------------------*/
/* stride.c: */

/* If PRECOMPUTE_ARRAY_INDICES is defined, precompute all strides. */

extern const INT fftwi_an_INT_guaranteed_to_be_zero;


typedef INT stride;

/* hackery to prevent the compiler from ``optimizing'' induction
   variables in codelet loops.  The problem is that for each K and for
   each expression of the form P[I + STRIDE * K] in a loop, most
   compilers will try to lift an induction variable PK := &P[I + STRIDE * K].
   For large values of K this behavior overflows the
   register set, which is likely worse than doing the index computation
   in the first place.

   If we guess that there are more than
   ESTIMATED_AVAILABLE_INDEX_REGISTERS such pointers, we deliberately confuse
   the compiler by setting STRIDE ^= ZERO, where ZERO is a value guaranteed to
   be 0, but the compiler does not know this. 

   16 registers ought to be enough for anybody, or so the amd64 and ARM ISA's
   seem to imply.
*/

/*-----------------------------------------------------------------------*/
/* solvtab.c */

struct solvtab_s { void (*reg)(planner *); const char *reg_nam; };
typedef struct solvtab_s solvtab[];
void fftwi_solvtab_exec(const solvtab tbl, planner *p);

/*-----------------------------------------------------------------------*/
/* pickdim.c */
int fftwi_pickdim(int which_dim, const int *buddies, int nbuddies,
	       const tensor *sz, int oop, int *dp);

/*-----------------------------------------------------------------------*/
/* twiddle.c */
/* little language to express twiddle factors computation */
enum { TW_COS = 0, TW_SIN = 1, TW_CEXP = 2, TW_NEXT = 3, 
       TW_FULL = 4, TW_HALF = 5 };

typedef struct {
     unsigned char op;
     signed char v;
     short i;
} tw_instr;

typedef struct twid_s {
     R *W;                     /* array of twiddle factors */
     INT n, r, m;                /* transform order, radix, # twiddle rows */
     int refcnt;
     const tw_instr *instr;
     struct twid_s *cdr;
     enum wakefulness wakefulness;
} twid;

INT fftwi_twiddle_length(INT r, const tw_instr *p);
void fftwi_twiddle_awake(enum wakefulness wakefulness,
		      twid **pp, const tw_instr *instr, INT n, INT r, INT m);

/*-----------------------------------------------------------------------*/
/* trig.c */
   typedef double trigreal;

typedef struct triggen_s triggen;

struct triggen_s {
     void (*cexp)(triggen *t, INT m, R *result);
     void (*cexpl)(triggen *t, INT m, trigreal *result);
     void (*rotate)(triggen *p, INT m, R xr, R xi, R *res);

     INT twshft;
     INT twradix;
     INT twmsk;
     trigreal *W0, *W1;
     INT n;
};

triggen *fftwi_mktriggen(enum wakefulness wakefulness, INT n);
void fftwi_triggen_destroy(triggen *p);

/*-----------------------------------------------------------------------*/
/* primes.c: */


INT fftwi_safe_mulmod(INT x, INT y, INT p);
INT fftwi_power_mod(INT n, INT m, INT p);
INT fftwi_find_generator(INT p);
INT fftwi_first_divisor(INT n);
int fftwi_is_prime(INT n);
INT fftwi_next_prime(INT n);
int fftwi_factors_into(INT n, const INT *primes);
int fftwi_factors_into_small_primes(INT n);
INT fftwi_choose_radix(INT r, INT n);
INT fftwi_isqrt(INT n);
INT fftwi_modulo(INT a, INT n);


/* thresholds below which certain solvers are considered SLOW.  These are guesses
   believed to be conservative */

/*-----------------------------------------------------------------------*/
/* rader.c: */
typedef struct rader_tls rader_tl;

void fftwi_rader_tl_insert(INT k1, INT k2, INT k3, R *W, rader_tl **tl);
R *fftwi_rader_tl_find(INT k1, INT k2, INT k3, rader_tl *t);
void fftwi_rader_tl_delete(R *W, rader_tl **tl);

/*-----------------------------------------------------------------------*/
/* copy/transposition routines */

/* lower bound to the cache size, for tiled routines */

INT fftwi_compute_tilesz(INT vl, int how_many_tiles_in_cache);

void fftwi_tile2d(INT n0l, INT n0u, INT n1l, INT n1u, INT tilesz,
	       void (*f)(INT n0l, INT n0u, INT n1l, INT n1u, void *args),
	       void *args);
void fftwi_cpy1d(R *I, R *O, INT n0, INT is0, INT os0, INT vl);
void fftwi_cpy2d(R *I, R *O,
	      INT n0, INT is0, INT os0,
	      INT n1, INT is1, INT os1,
	      INT vl);
void fftwi_cpy2d_ci(R *I, R *O,
		 INT n0, INT is0, INT os0,
		 INT n1, INT is1, INT os1,
		 INT vl);
void fftwi_cpy2d_co(R *I, R *O,
		 INT n0, INT is0, INT os0,
		 INT n1, INT is1, INT os1,
		 INT vl);
void fftwi_cpy2d_tiled(R *I, R *O,
		    INT n0, INT is0, INT os0,
		    INT n1, INT is1, INT os1, 
		    INT vl);
void fftwi_cpy2d_tiledbuf(R *I, R *O,
		       INT n0, INT is0, INT os0,
		       INT n1, INT is1, INT os1, 
		       INT vl);
void fftwi_cpy2d_pair(R *I0, R *I1, R *O0, R *O1,
		   INT n0, INT is0, INT os0,
		   INT n1, INT is1, INT os1);
void fftwi_cpy2d_pair_ci(R *I0, R *I1, R *O0, R *O1,
		      INT n0, INT is0, INT os0,
		      INT n1, INT is1, INT os1);
void fftwi_cpy2d_pair_co(R *I0, R *I1, R *O0, R *O1,
		      INT n0, INT is0, INT os0,
		      INT n1, INT is1, INT os1);

void fftwi_transpose(R *I, INT n, INT s0, INT s1, INT vl);
void fftwi_transpose_tiled(R *I, INT n, INT s0, INT s1, INT vl);
void fftwi_transpose_tiledbuf(R *I, INT n, INT s0, INT s1, INT vl);

typedef void (*transpose_func)(R *I, INT n, INT s0, INT s1, INT vl);
typedef void (*cpy2d_func)(R *I, R *O,
			   INT n0, INT is0, INT os0,
			   INT n1, INT is1, INT os1,
			   INT vl);

/*-----------------------------------------------------------------------*/
/* misc stuff */
void fftwi_null_awake(plan *ego, enum wakefulness wakefulness);
double fftwi_iestimate_cost(const planner *, const plan *, const problem *);


double fftwi_measure_execution_time(const planner *plnr, 
				 plan *pln, const problem *p);
int fftwi_alignment_of(R *p);
unsigned fftwi_hash(const char *s);
INT fftwi_nbuf(INT n, INT vl, INT maxnbuf);
int fftwi_nbuf_redundant(INT n, INT vl, int which, 
		      const INT *maxnbuf, int nmaxnbuf);
INT fftwi_bufdist(INT n, INT vl);
int fftwi_toobig(INT n);
int fftwi_ct_uglyp(INT min_n, INT v, INT n, INT r);





/*-----------------------------------------------------------------------*/
/* macros used in codelets to reduce source code size */

typedef R E;  /* internal precision of codelets. */


//#define DK(name, value) const E name = K((float)value* (float)NORM_COEFF)
/* FMA macros */


		typedef long long __int64;


}  /* extern "C" */


/**************************************************************
 * types of codelets
 **************************************************************/

/* DFT codelets */
typedef struct kdft_desc_s kdft_desc;

typedef struct {
     int (*okp)(
	  const kdft_desc *desc,
	  const R *ri, const R *ii, const R *ro, const R *io,
	  INT is, INT os, INT vl, INT ivs, INT ovs,
	  const planner *plnr);
     INT vl;
} kdft_genus;

struct kdft_desc_s {
     INT sz;    /* size of transform computed */
     const char *nam;
     opcnt ops;
     const kdft_genus *genus;
     INT is;
     INT os;
     INT ivs;
     INT ovs;
};

typedef void (*kdft) (const R *ri, const R *ii, R *ro, R *io,
                      stride is, stride os, INT vl, INT ivs, INT ovs);
void fftwi_kdft_register(planner *p, kdft codelet, const kdft_desc *desc);


typedef struct ct_desc_s ct_desc;

typedef struct {
     int (*okp)(
	  const struct ct_desc_s *desc,
	  const R *rio, const R *iio, 
	  INT rs, INT vs, INT m, INT mb, INT me, INT ms,
	  const planner *plnr);
     INT vl;
} ct_genus;

struct ct_desc_s {
     INT radix;
     const char *nam;
     const tw_instr *tw;
     const ct_genus *genus;
     opcnt ops;
     INT rs;
     INT vs;
     INT ms;
};

typedef void (*kdftw) (R *rioarray, R *iioarray, const R *W,
		       stride ios, INT mb, INT me, INT ms);
void fftwi_kdft_dit_register(planner *p, kdftw codelet, const ct_desc *desc);
void fftwi_kdft_dif_register(planner *p, kdftw codelet, const ct_desc *desc);


typedef void (*kdftwsq) (R *rioarray, R *iioarray,
			 const R *W, stride is, stride vs,
			 INT mb, INT me, INT ms);
void fftwi_kdft_difsq_register(planner *p, kdftwsq codelet, const ct_desc *desc);


extern const solvtab fftwi_solvtab_dft_standard;
extern const solvtab fftwi_solvtab_dft_sse2;
extern const solvtab fftwi_solvtab_dft_avx;
extern const solvtab fftwi_solvtab_dft_altivec;
extern const solvtab fftwi_solvtab_dft_neon;



/* Generated by: ../../../genfft/gen_twiddle.native -compact -variables 4 -pipeline-latency 4 -twiddle-log3 -precompute-twiddles -n 64 -name t2_64 -include t.h */

/*
 * This function contains 1154 FP additions, 660 FP multiplications,
 * (or, 880 additions, 386 multiplications, 274 fused multiply/add),
 * 302 stack variables, 15 constants, and 256 memory accesses
 */
/*
 * Copyright (c) 2003, 2007-11 Matteo Frigo
 * Copyright (c) 2003, 2007-11 Massachusetts Institute of Technology
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
 *
 */


extern const ct_genus fftwi_dft_t_genus;
static void t2_64(R *ri, R *ii, const R *W, stride rs, INT mb, INT me, INT ms)
{
     const E KP471396736 = (float)+0.471396736825997648556387625905254377657460319* (float)((1<<(25))-1);
     const E KP881921264 = (float)+0.881921264348355029712756863660388349508442621* (float)((1<<(25))-1);
     const E KP290284677 = (float)+0.290284677254462367636192375817395274691476278* (float)((1<<(25))-1);
     const E KP956940335 = (float)+0.956940335732208864935797886980269969482849206* (float)((1<<(25))-1);
     const E KP634393284 = (float)+0.634393284163645498215171613225493370675687095* (float)((1<<(25))-1);
     const E KP773010453 = (float)+0.773010453362736960810906609758469800971041293* (float)((1<<(25))-1);
     const E KP098017140 = (float)+0.098017140329560601994195563888641845861136673* (float)((1<<(25))-1);
     const E KP995184726 = (float)+0.995184726672196886244836953109479921575474869* (float)((1<<(25))-1);
     const E KP555570233 = (float)+0.555570233019602224742830813948532874374937191* (float)((1<<(25))-1);
     const E KP831469612 = (float)+0.831469612302545237078788377617905756738560812* (float)((1<<(25))-1);
     const E KP980785280 = (float)+0.980785280403230449126182236134239036973933731* (float)((1<<(25))-1);
     const E KP195090322 = (float)+0.195090322016128267848284868477022240927691618* (float)((1<<(25))-1);
     const E KP923879532 = (float)+0.923879532511286756128183189396788286822416626* (float)((1<<(25))-1);
     const E KP382683432 = (float)+0.382683432365089771728459984030398866761344562* (float)((1<<(25))-1);
     const E KP707106781 = (float)+0.707106781186547524400844362104849039284835938* (float)((1<<(25))-1);
     {
	  INT m;
	  for (m = mb, W = W + (mb * 10); m < me; m = m + 1, ri = ri + ms, ii = ii + ms, W = W + 10, (128 <= 16 ? 0 : ((rs) = (rs) ^ fftwi_an_INT_guaranteed_to_be_zero))) {
	       E T2, T5, T3, T6, Te, T9, TP, T3e, T1e, T39, T3c, TT, T1a, T37, T8;
	       E Tw, Td, Ty, Tm, Th, T1C, T3K, T1V, T3x, T3I, T1G, T1R, T3v, T2m, T2q;
	       E T5Y, T6u, T53, T5B, T62, T6w, T57, T5D, T2V, T2X, Tg, TE, T3Y, T3V, T3j;
	       E Tl, TA, T3g, T1j, T1t, TV, T2C, T2z, T1u, TZ, T1h, To, T1p, T6j, T6H;
	       E Ts, T1l, T6l, T6F, T2P, T4b, T4x, T5i, T2R, T49, T4z, T5g, TG, T4k, T4m;
	       E TK, T21, T3O, T3Q, T25, TW, T10, T11, T79, T6X, T5M, T6b, T1v, T30, T69;
	       E T77, T13, T2F, T2D, T6p, T6O, T1x, T2a, T2f, T6V, T28, T6r, T2h, T6Q, T32;
	       E T5K, T5w, T4G, T4Q, T3m, T4h, T4I, T5y, T3k, T4f, T41, T4S, T4Y, T3q, T3D;
	       E T3F, T5r, T3s, T4W, T3Z, T5p;
	       {
		    E Ta, Tj, Tx, TC, Tf, Tk, Tz, TD, T1B, T1E, T2o, T2l, T1T, T1Q, T1A;
		    E T1F, T2p, T2k, T1U, T1P;
		    {
			 E T4, T1d, T19, Tb, T1c, T7, Tc, T18, TR, TO, TS, TN;
			 T2 = W[0];
			 T5 = W[1];
			 T3 = W[2];
			 T6 = W[3];
			 Te = W[5];
			 T9 = W[4];
			 T4 = ( (((__int64)T2) * ((__int64)T3))>>(25) );
			 T1d = ( (((__int64)T5) * ((__int64)T9))>>(25) );
			 T19 = ( (((__int64)T5) * ((__int64)Te))>>(25) );
			 Tb = ( (((__int64)T2) * ((__int64)T6))>>(25) );
			 T1c = ( (((__int64)T2) * ((__int64)Te))>>(25) );
			 T7 = ( (((__int64)T5) * ((__int64)T6))>>(25) );
			 Tc = ( (((__int64)T5) * ((__int64)T3))>>(25) );
			 T18 = ( (((__int64)T2) * ((__int64)T9))>>(25) );
			 TR = ( (((__int64)T3) * ((__int64)Te))>>(25) );
			 TO = ( (((__int64)T6) * ((__int64)Te))>>(25) );
			 TS = ( (((__int64)T6) * ((__int64)T9))>>(25) );
			 TN = ( (((__int64)T3) * ((__int64)T9))>>(25) );
			 TP = TN - TO;
			 T3e = TR - TS;
			 T1e = T1c - T1d;
			 T39 = T1c + T1d;
			 T3c = TN + TO;
			 TT = TR + TS;
			 T1a = T18 + T19;
			 T37 = T18 - T19;
			 T8 = T4 - T7;
			 Ta = ( (((__int64)T8) * ((__int64)T9))>>(25) );
			 Tj = ( (((__int64)T8) * ((__int64)Te))>>(25) );
			 Tw = T4 + T7;
			 Tx = ( (((__int64)Tw) * ((__int64)T9))>>(25) );
			 TC = ( (((__int64)Tw) * ((__int64)Te))>>(25) );
			 Td = Tb + Tc;
			 Tf = ( (((__int64)Td) * ((__int64)Te))>>(25) );
			 Tk = ( (((__int64)Td) * ((__int64)T9))>>(25) );
			 Ty = Tb - Tc;
			 Tz = ( (((__int64)Ty) * ((__int64)Te))>>(25) );
			 TD = ( (((__int64)Ty) * ((__int64)T9))>>(25) );
			 Tm = W[7];
			 T1B = ( (((__int64)T6) * ((__int64)Tm))>>(25) );
			 T1E = ( (((__int64)T3) * ((__int64)Tm))>>(25) );
			 T2o = ( (((__int64)T2) * ((__int64)Tm))>>(25) );
			 T2l = ( (((__int64)T5) * ((__int64)Tm))>>(25) );
			 T1T = ( (((__int64)T9) * ((__int64)Tm))>>(25) );
			 T1Q = ( (((__int64)Te) * ((__int64)Tm))>>(25) );
			 Th = W[6];
			 T1A = ( (((__int64)T3) * ((__int64)Th))>>(25) );
			 T1F = ( (((__int64)T6) * ((__int64)Th))>>(25) );
			 T2p = ( (((__int64)T5) * ((__int64)Th))>>(25) );
			 T2k = ( (((__int64)T2) * ((__int64)Th))>>(25) );
			 T1U = ( (((__int64)Te) * ((__int64)Th))>>(25) );
			 T1P = ( (((__int64)T9) * ((__int64)Th))>>(25) );
		    }
		    T1C = T1A + T1B;
		    T3K = T1E + T1F;
		    T1V = T1T + T1U;
		    T3x = T2o - T2p;
		    T3I = T1A - T1B;
		    T1G = T1E - T1F;
		    T1R = T1P - T1Q;
		    {
			 E T5W, T5X, T55, T56;
			 T3v = T2k + T2l;
			 T2m = T2k - T2l;
			 T2q = T2o + T2p;
			 T5W = ( (((__int64)T8) * ((__int64)Th))>>(25) );
			 T5X = ( (((__int64)Td) * ((__int64)Tm))>>(25) );
			 T5Y = T5W - T5X;
			 T6u = T5W + T5X;
			 {
			      E T51, T52, T60, T61;
			      T51 = ( (((__int64)Tw) * ((__int64)Th))>>(25) );
			      T52 = ( (((__int64)Ty) * ((__int64)Tm))>>(25) );
			      T53 = T51 + T52;
			      T5B = T51 - T52;
			      T60 = ( (((__int64)T8) * ((__int64)Tm))>>(25) );
			      T61 = ( (((__int64)Td) * ((__int64)Th))>>(25) );
			      T62 = T60 + T61;
			      T6w = T60 - T61;
			 }
			 T55 = ( (((__int64)Tw) * ((__int64)Tm))>>(25) );
			 T56 = ( (((__int64)Ty) * ((__int64)Th))>>(25) );
			 T57 = T55 - T56;
			 T5D = T55 + T56;
			 {
			      E Ti, Tq, TF, TJ, T3W, T3X, T3T, T3U, T3h, T3i, Tn, Tr, TB, TI, T3d;
			      E T3f, T1k, T1o, T1Z, T23, TQ, TU, T2A, T2B, T2x, T2y, T20, T24, TX, TY;
			      E T1i, T1n;
			      T2V = T1P + T1Q;
			      T2X = T1T - T1U;
			      Tg = Ta + Tf;
			      Ti = ( (((__int64)Tg) * ((__int64)Th))>>(25) );
			      Tq = ( (((__int64)Tg) * ((__int64)Tm))>>(25) );
			      TE = TC + TD;
			      TF = ( (((__int64)TE) * ((__int64)Tm))>>(25) );
			      TJ = ( (((__int64)TE) * ((__int64)Th))>>(25) );
			      T3W = ( (((__int64)T37) * ((__int64)Tm))>>(25) );
			      T3X = ( (((__int64)T39) * ((__int64)Th))>>(25) );
			      T3Y = T3W - T3X;
			      T3T = ( (((__int64)T37) * ((__int64)Th))>>(25) );
			      T3U = ( (((__int64)T39) * ((__int64)Tm))>>(25) );
			      T3V = T3T + T3U;
			      T3h = ( (((__int64)T3c) * ((__int64)Tm))>>(25) );
			      T3i = ( (((__int64)T3e) * ((__int64)Th))>>(25) );
			      T3j = T3h - T3i;
			      Tl = Tj - Tk;
			      Tn = ( (((__int64)Tl) * ((__int64)Tm))>>(25) );
			      Tr = ( (((__int64)Tl) * ((__int64)Th))>>(25) );
			      TA = Tx - Tz;
			      TB = ( (((__int64)TA) * ((__int64)Th))>>(25) );
			      TI = ( (((__int64)TA) * ((__int64)Tm))>>(25) );
			      T3d = ( (((__int64)T3c) * ((__int64)Th))>>(25) );
			      T3f = ( (((__int64)T3e) * ((__int64)Tm))>>(25) );
			      T3g = T3d + T3f;
			      T1j = Tj + Tk;
			      T1k = ( (((__int64)T1j) * ((__int64)Tm))>>(25) );
			      T1o = ( (((__int64)T1j) * ((__int64)Th))>>(25) );
			      T1t = Tx + Tz;
			      T1Z = ( (((__int64)T1t) * ((__int64)Th))>>(25) );
			      T23 = ( (((__int64)T1t) * ((__int64)Tm))>>(25) );
			      TQ = ( (((__int64)TP) * ((__int64)Th))>>(25) );
			      TU = ( (((__int64)TT) * ((__int64)Tm))>>(25) );
			      TV = TQ + TU;
			      T2A = ( (((__int64)T1a) * ((__int64)Tm))>>(25) );
			      T2B = ( (((__int64)T1e) * ((__int64)Th))>>(25) );
			      T2C = T2A - T2B;
			      T2x = ( (((__int64)T1a) * ((__int64)Th))>>(25) );
			      T2y = ( (((__int64)T1e) * ((__int64)Tm))>>(25) );
			      T2z = T2x + T2y;
			      T1u = TC - TD;
			      T20 = ( (((__int64)T1u) * ((__int64)Tm))>>(25) );
			      T24 = ( (((__int64)T1u) * ((__int64)Th))>>(25) );
			      TX = ( (((__int64)TP) * ((__int64)Tm))>>(25) );
			      TY = ( (((__int64)TT) * ((__int64)Th))>>(25) );
			      TZ = TX - TY;
			      T1h = Ta - Tf;
			      T1i = ( (((__int64)T1h) * ((__int64)Th))>>(25) );
			      T1n = ( (((__int64)T1h) * ((__int64)Tm))>>(25) );
			      To = Ti - Tn;
			      T1p = T1n + T1o;
			      T6j = TQ - TU;
			      T6H = T2A + T2B;
			      Ts = Tq + Tr;
			      T1l = T1i - T1k;
			      T6l = TX + TY;
			      T6F = T2x - T2y;
			      T2P = T1Z - T20;
			      T4b = TI + TJ;
			      T4x = T3d - T3f;
			      T5i = T3W + T3X;
			      T2R = T23 + T24;
			      T49 = TB - TF;
			      T4z = T3h + T3i;
			      T5g = T3T - T3U;
			      TG = TB + TF;
			      T4k = Ti + Tn;
			      T4m = Tq - Tr;
			      TK = TI - TJ;
			      T21 = T1Z + T20;
			      T3O = T1i + T1k;
			      T3Q = T1n - T1o;
			      T25 = T23 - T24;
			      TW = W[8];
			      T10 = W[9];
			      T11 = ( ( (((__int64)TV) * ((__int64)TW))>>(25) ) + (( (((__int64)TZ) * ((__int64)T10))>>(25) )));
			      T79 = ((( (((__int64)T21) * ((__int64)T10))>>(25) )) - ( (((__int64)T25) * ((__int64)TW))>>(25) ));
			      T6X = ((( (((__int64)T8) * ((__int64)T10))>>(25) )) - ( (((__int64)Td) * ((__int64)TW))>>(25) ));
			      T5M = ((( (((__int64)T2V) * ((__int64)T10))>>(25) )) - ( (((__int64)T2X) * ((__int64)TW))>>(25) ));
			      T6b = ((( (((__int64)TG) * ((__int64)T10))>>(25) )) - ( (((__int64)TK) * ((__int64)TW))>>(25) ));
			      T1v = ( ( (((__int64)T1t) * ((__int64)TW))>>(25) ) + (( (((__int64)T1u) * ((__int64)T10))>>(25) )));
			      T30 = ( ( (((__int64)T1h) * ((__int64)TW))>>(25) ) + (( (((__int64)T1j) * ((__int64)T10))>>(25) )));
			      T69 = ( ( (((__int64)TG) * ((__int64)TW))>>(25) ) + (( (((__int64)TK) * ((__int64)T10))>>(25) )));
			      T77 = ( ( (((__int64)T21) * ((__int64)TW))>>(25) ) + (( (((__int64)T25) * ((__int64)T10))>>(25) )));
			      T13 = ((( (((__int64)TV) * ((__int64)T10))>>(25) )) - ( (((__int64)TZ) * ((__int64)TW))>>(25) ));
			      T2F = ((( (((__int64)T2z) * ((__int64)T10))>>(25) )) - ( (((__int64)T2C) * ((__int64)TW))>>(25) ));
			      T2D = ( ( (((__int64)T2z) * ((__int64)TW))>>(25) ) + (( (((__int64)T2C) * ((__int64)T10))>>(25) )));
			      T6p = ( ( (((__int64)T1a) * ((__int64)TW))>>(25) ) + (( (((__int64)T1e) * ((__int64)T10))>>(25) )));
			      T6O = ( ( (((__int64)TP) * ((__int64)TW))>>(25) ) + (( (((__int64)TT) * ((__int64)T10))>>(25) )));
			      T1x = ((( (((__int64)T1t) * ((__int64)T10))>>(25) )) - ( (((__int64)T1u) * ((__int64)TW))>>(25) ));
			      T2a = ((( (((__int64)TA) * ((__int64)T10))>>(25) )) - ( (((__int64)TE) * ((__int64)TW))>>(25) ));
			      T2f = ( ( (((__int64)T3) * ((__int64)TW))>>(25) ) + (( (((__int64)T6) * ((__int64)T10))>>(25) )));
			      T6V = ( ( (((__int64)T8) * ((__int64)TW))>>(25) ) + (( (((__int64)Td) * ((__int64)T10))>>(25) )));
			      T28 = ( ( (((__int64)TA) * ((__int64)TW))>>(25) ) + (( (((__int64)TE) * ((__int64)T10))>>(25) )));
			      T6r = ((( (((__int64)T1a) * ((__int64)T10))>>(25) )) - ( (((__int64)T1e) * ((__int64)TW))>>(25) ));
			      T2h = ((( (((__int64)T3) * ((__int64)T10))>>(25) )) - ( (((__int64)T6) * ((__int64)TW))>>(25) ));
			      T6Q = ((( (((__int64)TP) * ((__int64)T10))>>(25) )) - ( (((__int64)TT) * ((__int64)TW))>>(25) ));
			      T32 = ((( (((__int64)T1h) * ((__int64)T10))>>(25) )) - ( (((__int64)T1j) * ((__int64)TW))>>(25) ));
			      T5K = ( ( (((__int64)T2V) * ((__int64)TW))>>(25) ) + (( (((__int64)T2X) * ((__int64)T10))>>(25) )));
			      T5w = ( ( (((__int64)Tw) * ((__int64)TW))>>(25) ) + (( (((__int64)Ty) * ((__int64)T10))>>(25) )));
			      T4G = ( ( (((__int64)T3O) * ((__int64)TW))>>(25) ) + (( (((__int64)T3Q) * ((__int64)T10))>>(25) )));
			      T4Q = ( ( (((__int64)T4k) * ((__int64)TW))>>(25) ) + (( (((__int64)T4m) * ((__int64)T10))>>(25) )));
			      T3m = ((( (((__int64)T3g) * ((__int64)T10))>>(25) )) - ( (((__int64)T3j) * ((__int64)TW))>>(25) ));
			      T4h = ((( (((__int64)T9) * ((__int64)T10))>>(25) )) - ( (((__int64)Te) * ((__int64)TW))>>(25) ));
			      T4I = ((( (((__int64)T3O) * ((__int64)T10))>>(25) )) - ( (((__int64)T3Q) * ((__int64)TW))>>(25) ));
			      T5y = ((( (((__int64)Tw) * ((__int64)T10))>>(25) )) - ( (((__int64)Ty) * ((__int64)TW))>>(25) ));
			      T3k = ( ( (((__int64)T3g) * ((__int64)TW))>>(25) ) + (( (((__int64)T3j) * ((__int64)T10))>>(25) )));
			      T4f = ( ( (((__int64)T9) * ((__int64)TW))>>(25) ) + (( (((__int64)Te) * ((__int64)T10))>>(25) )));
			      T41 = ((( (((__int64)T3V) * ((__int64)T10))>>(25) )) - ( (((__int64)T3Y) * ((__int64)TW))>>(25) ));
			      T4S = ((( (((__int64)T4k) * ((__int64)T10))>>(25) )) - ( (((__int64)T4m) * ((__int64)TW))>>(25) ));
			      T4Y = ((( (((__int64)T3c) * ((__int64)T10))>>(25) )) - ( (((__int64)T3e) * ((__int64)TW))>>(25) ));
			      T3q = ( ( (((__int64)Tg) * ((__int64)TW))>>(25) ) + (( (((__int64)Tl) * ((__int64)T10))>>(25) )));
			      T3D = ( ( (((__int64)T2) * ((__int64)TW))>>(25) ) + (( (((__int64)T5) * ((__int64)T10))>>(25) )));
			      T3F = ((( (((__int64)T2) * ((__int64)T10))>>(25) )) - ( (((__int64)T5) * ((__int64)TW))>>(25) ));
			      T5r = ((( (((__int64)T37) * ((__int64)T10))>>(25) )) - ( (((__int64)T39) * ((__int64)TW))>>(25) ));
			      T3s = ((( (((__int64)Tg) * ((__int64)T10))>>(25) )) - ( (((__int64)Tl) * ((__int64)TW))>>(25) ));
			      T4W = ( ( (((__int64)T3c) * ((__int64)TW))>>(25) ) + (( (((__int64)T3e) * ((__int64)T10))>>(25) )));
			      T3Z = ( ( (((__int64)T3V) * ((__int64)TW))>>(25) ) + (( (((__int64)T3Y) * ((__int64)T10))>>(25) )));
			      T5p = ( ( (((__int64)T37) * ((__int64)TW))>>(25) ) + (( (((__int64)T39) * ((__int64)T10))>>(25) )));
			 }
		    }
	       }
	       {
		    E T17, TdV, Tj3, Tjx, T7l, TbJ, Ti3, Tix, T1K, Tiw, TdY, ThY, T7w, Tj0, TbM;
		    E Tjw, T2e, TgA, T7I, TaY, TbQ, Tda, Te4, TfO, T2J, TgB, T7T, TaZ, TbT, Tdb;
		    E Te9, TfP, T36, T3B, TgH, TgE, TgF, TgG, T80, TbW, Tel, TfT, T8b, Tc0, T8k;
		    E TbX, Teg, TfS, T8h, TbZ, T45, T4q, TgJ, TgK, TgL, TgM, T8r, Tc6, Tew, TfW;
		    E T8C, Tc4, T8L, Tc7, Ter, TfV, T8I, Tc3, T6B, Th1, Tfm, Tga, Th8, ThI, T9N;
		    E Tcv, T9Y, TcH, Tav, Tcw, Tf5, Tg7, Tas, TcG, T5c, TgV, TeV, Tg0, TgS, ThD;
		    E T8U, Tcc, T95, Tco, T9C, Tcd, TeE, Tg3, T9z, Tcn, T5R, TgT, TeO, TeW, TgY;
		    E ThE, T9h, T9F, T9s, T9E, Tck, Tcq, TeJ, TeX, Tch, Tcr, T7e, Th9, Tff, Tfn;
		    E Th4, ThJ, Taa, Tay, Tal, Tax, TcD, TcJ, Tfa, Tfo, TcA, TcK;
		    {
			 E T1, Ti1, Tu, Ti0, TM, T7i, T15, T7j, Tp, Tt;
			 T1 = ri[0];
			 Ti1 = ii[0];
			 Tp = ri[(rs * 32)];
			 Tt = ii[(rs * 32)];
			 Tu = ( ( (((__int64)To) * ((__int64)Tp))>>(25) ) + (( (((__int64)Ts) * ((__int64)Tt))>>(25) )));
			 Ti0 = ((( (((__int64)To) * ((__int64)Tt))>>(25) )) - ( (((__int64)Ts) * ((__int64)Tp))>>(25) ));
			 {
			      E TH, TL, T12, T14;
			      TH = ri[(rs * 16)];
			      TL = ii[(rs * 16)];
			      TM = ( ( (((__int64)TG) * ((__int64)TH))>>(25) ) + (( (((__int64)TK) * ((__int64)TL))>>(25) )));
			      T7i = ((( (((__int64)TG) * ((__int64)TL))>>(25) )) - ( (((__int64)TK) * ((__int64)TH))>>(25) ));
			      T12 = ri[(rs * 48)];
			      T14 = ii[(rs * 48)];
			      T15 = ( ( (((__int64)T11) * ((__int64)T12))>>(25) ) + (( (((__int64)T13) * ((__int64)T14))>>(25) )));
			      T7j = ((( (((__int64)T11) * ((__int64)T14))>>(25) )) - ( (((__int64)T13) * ((__int64)T12))>>(25) ));
			 }
			 {
			      E Tv, T16, Tj1, Tj2;
			      Tv = T1 + Tu;
			      T16 = TM + T15;
			      T17 = Tv + T16;
			      TdV = Tv - T16;
			      Tj1 = Ti1 - Ti0;
			      Tj2 = TM - T15;
			      Tj3 = Tj1 - Tj2;
			      Tjx = Tj2 + Tj1;
			 }
			 {
			      E T7h, T7k, ThZ, Ti2;
			      T7h = T1 - Tu;
			      T7k = T7i - T7j;
			      T7l = T7h - T7k;
			      TbJ = T7h + T7k;
			      ThZ = T7i + T7j;
			      Ti2 = Ti0 + Ti1;
			      Ti3 = ThZ + Ti2;
			      Tix = Ti2 - ThZ;
			 }
		    }
		    {
			 E T1g, T7m, T1r, T7n, T7o, T7p, T1z, T7s, T1I, T7t, T7r, T7u;
			 {
			      E T1b, T1f, T1m, T1q;
			      T1b = ri[(rs * 8)];
			      T1f = ii[(rs * 8)];
			      T1g = ( ( (((__int64)T1a) * ((__int64)T1b))>>(25) ) + (( (((__int64)T1e) * ((__int64)T1f))>>(25) )));
			      T7m = ((( (((__int64)T1a) * ((__int64)T1f))>>(25) )) - ( (((__int64)T1e) * ((__int64)T1b))>>(25) ));
			      T1m = ri[(rs * 40)];
			      T1q = ii[(rs * 40)];
			      T1r = ( ( (((__int64)T1l) * ((__int64)T1m))>>(25) ) + (( (((__int64)T1p) * ((__int64)T1q))>>(25) )));
			      T7n = ((( (((__int64)T1l) * ((__int64)T1q))>>(25) )) - ( (((__int64)T1p) * ((__int64)T1m))>>(25) ));
			 }
			 T7o = T7m - T7n;
			 T7p = T1g - T1r;
			 {
			      E T1w, T1y, T1D, T1H;
			      T1w = ri[(rs * 56)];
			      T1y = ii[(rs * 56)];
			      T1z = ( ( (((__int64)T1v) * ((__int64)T1w))>>(25) ) + (( (((__int64)T1x) * ((__int64)T1y))>>(25) )));
			      T7s = ((( (((__int64)T1v) * ((__int64)T1y))>>(25) )) - ( (((__int64)T1x) * ((__int64)T1w))>>(25) ));
			      T1D = ri[(rs * 24)];
			      T1H = ii[(rs * 24)];
			      T1I = ( ( (((__int64)T1C) * ((__int64)T1D))>>(25) ) + (( (((__int64)T1G) * ((__int64)T1H))>>(25) )));
			      T7t = ((( (((__int64)T1C) * ((__int64)T1H))>>(25) )) - ( (((__int64)T1G) * ((__int64)T1D))>>(25) ));
			 }
			 T7r = T1z - T1I;
			 T7u = T7s - T7t;
			 {
			      E T1s, T1J, TdW, TdX;
			      T1s = T1g + T1r;
			      T1J = T1z + T1I;
			      T1K = T1s + T1J;
			      Tiw = T1J - T1s;
			      TdW = T7m + T7n;
			      TdX = T7s + T7t;
			      TdY = TdW - TdX;
			      ThY = TdW + TdX;
			 }
			 {
			      E T7q, T7v, TbK, TbL;
			      T7q = T7o - T7p;
			      T7v = T7r + T7u;
			      T7w = ( (((__int64)KP707106781) * ((__int64)(T7q - T7v)))>>(25) );
			      Tj0 = ( (((__int64)KP707106781) * ((__int64)(T7q + T7v)))>>(25) );
			      TbK = T7p + T7o;
			      TbL = T7r - T7u;
			      TbM = ( (((__int64)KP707106781) * ((__int64)(TbK + TbL)))>>(25) );
			      Tjw = ( (((__int64)KP707106781) * ((__int64)(TbL - TbK)))>>(25) );
			 }
		    }
		    {
			 E T1Y, Te0, T7A, T7D, T2d, Te1, T7B, T7G, T7C, T7H;
			 {
			      E T1O, T7y, T1X, T7z;
			      {
				   E T1M, T1N, T1S, T1W;
				   T1M = ri[(rs * 4)];
				   T1N = ii[(rs * 4)];
				   T1O = ( ( (((__int64)T8) * ((__int64)T1M))>>(25) ) + (( (((__int64)Td) * ((__int64)T1N))>>(25) )));
				   T7y = ((( (((__int64)T8) * ((__int64)T1N))>>(25) )) - ( (((__int64)Td) * ((__int64)T1M))>>(25) ));
				   T1S = ri[(rs * 36)];
				   T1W = ii[(rs * 36)];
				   T1X = ( ( (((__int64)T1R) * ((__int64)T1S))>>(25) ) + (( (((__int64)T1V) * ((__int64)T1W))>>(25) )));
				   T7z = ((( (((__int64)T1R) * ((__int64)T1W))>>(25) )) - ( (((__int64)T1V) * ((__int64)T1S))>>(25) ));
			      }
			      T1Y = T1O + T1X;
			      Te0 = T7y + T7z;
			      T7A = T7y - T7z;
			      T7D = T1O - T1X;
			 }
			 {
			      E T27, T7E, T2c, T7F;
			      {
				   E T22, T26, T29, T2b;
				   T22 = ri[(rs * 20)];
				   T26 = ii[(rs * 20)];
				   T27 = ( ( (((__int64)T21) * ((__int64)T22))>>(25) ) + (( (((__int64)T25) * ((__int64)T26))>>(25) )));
				   T7E = ((( (((__int64)T21) * ((__int64)T26))>>(25) )) - ( (((__int64)T25) * ((__int64)T22))>>(25) ));
				   T29 = ri[(rs * 52)];
				   T2b = ii[(rs * 52)];
				   T2c = ( ( (((__int64)T28) * ((__int64)T29))>>(25) ) + (( (((__int64)T2a) * ((__int64)T2b))>>(25) )));
				   T7F = ((( (((__int64)T28) * ((__int64)T2b))>>(25) )) - ( (((__int64)T2a) * ((__int64)T29))>>(25) ));
			      }
			      T2d = T27 + T2c;
			      Te1 = T7E + T7F;
			      T7B = T27 - T2c;
			      T7G = T7E - T7F;
			 }
			 T2e = T1Y + T2d;
			 TgA = Te0 + Te1;
			 T7C = T7A + T7B;
			 T7H = T7D - T7G;
			 T7I = ((( (((__int64)KP382683432) * ((__int64)T7C))>>(25) )) - ( (((__int64)KP923879532) * ((__int64)T7H))>>(25) ));
			 TaY = ( ( (((__int64)KP923879532) * ((__int64)T7C))>>(25) ) + (( (((__int64)KP382683432) * ((__int64)T7H))>>(25) )));
			 {
			      E TbO, TbP, Te2, Te3;
			      TbO = T7A - T7B;
			      TbP = T7D + T7G;
			      TbQ = ((( (((__int64)KP923879532) * ((__int64)TbO))>>(25) )) - ( (((__int64)KP382683432) * ((__int64)TbP))>>(25) ));
			      Tda = ( ( (((__int64)KP382683432) * ((__int64)TbO))>>(25) ) + (( (((__int64)KP923879532) * ((__int64)TbP))>>(25) )));
			      Te2 = Te0 - Te1;
			      Te3 = T1Y - T2d;
			      Te4 = Te2 - Te3;
			      TfO = Te3 + Te2;
			 }
		    }
		    {
			 E T2t, Te6, T7L, T7O, T2I, Te7, T7M, T7R, T7N, T7S;
			 {
			      E T2j, T7J, T2s, T7K;
			      {
				   E T2g, T2i, T2n, T2r;
				   T2g = ri[(rs * 60)];
				   T2i = ii[(rs * 60)];
				   T2j = ( ( (((__int64)T2f) * ((__int64)T2g))>>(25) ) + (( (((__int64)T2h) * ((__int64)T2i))>>(25) )));
				   T7J = ((( (((__int64)T2f) * ((__int64)T2i))>>(25) )) - ( (((__int64)T2h) * ((__int64)T2g))>>(25) ));
				   T2n = ri[(rs * 28)];
				   T2r = ii[(rs * 28)];
				   T2s = ( ( (((__int64)T2m) * ((__int64)T2n))>>(25) ) + (( (((__int64)T2q) * ((__int64)T2r))>>(25) )));
				   T7K = ((( (((__int64)T2m) * ((__int64)T2r))>>(25) )) - ( (((__int64)T2q) * ((__int64)T2n))>>(25) ));
			      }
			      T2t = T2j + T2s;
			      Te6 = T7J + T7K;
			      T7L = T7J - T7K;
			      T7O = T2j - T2s;
			 }
			 {
			      E T2w, T7P, T2H, T7Q;
			      {
				   E T2u, T2v, T2E, T2G;
				   T2u = ri[(rs * 12)];
				   T2v = ii[(rs * 12)];
				   T2w = ( ( (((__int64)TP) * ((__int64)T2u))>>(25) ) + (( (((__int64)TT) * ((__int64)T2v))>>(25) )));
				   T7P = ((( (((__int64)TP) * ((__int64)T2v))>>(25) )) - ( (((__int64)TT) * ((__int64)T2u))>>(25) ));
				   T2E = ri[(rs * 44)];
				   T2G = ii[(rs * 44)];
				   T2H = ( ( (((__int64)T2D) * ((__int64)T2E))>>(25) ) + (( (((__int64)T2F) * ((__int64)T2G))>>(25) )));
				   T7Q = ((( (((__int64)T2D) * ((__int64)T2G))>>(25) )) - ( (((__int64)T2F) * ((__int64)T2E))>>(25) ));
			      }
			      T2I = T2w + T2H;
			      Te7 = T7P + T7Q;
			      T7M = T2w - T2H;
			      T7R = T7P - T7Q;
			 }
			 T2J = T2t + T2I;
			 TgB = Te6 + Te7;
			 T7N = T7L + T7M;
			 T7S = T7O - T7R;
			 T7T = ( ( (((__int64)KP382683432) * ((__int64)T7N))>>(25) ) + (( (((__int64)KP923879532) * ((__int64)T7S))>>(25) )));
			 TaZ = ((( (((__int64)KP382683432) * ((__int64)T7S))>>(25) )) - ( (((__int64)KP923879532) * ((__int64)T7N))>>(25) ));
			 {
			      E TbR, TbS, Te5, Te8;
			      TbR = T7L - T7M;
			      TbS = T7O + T7R;
			      TbT = ( ( (((__int64)KP923879532) * ((__int64)TbR))>>(25) ) + (( (((__int64)KP382683432) * ((__int64)TbS))>>(25) )));
			      Tdb = ((( (((__int64)KP923879532) * ((__int64)TbS))>>(25) )) - ( (((__int64)KP382683432) * ((__int64)TbR))>>(25) ));
			      Te5 = T2t - T2I;
			      Te8 = Te6 - Te7;
			      Te9 = Te5 + Te8;
			      TfP = Te5 - Te8;
			 }
		    }
		    {
			 E T2O, T7W, T2T, T7X, T2U, Tec, T2Z, T8e, T34, T8f, T35, Ted, T3p, Tei, T86;
			 E T89, T3A, Tej, T81, T84;
			 {
			      E T2M, T2N, T2Q, T2S;
			      T2M = ri[(rs * 2)];
			      T2N = ii[(rs * 2)];
			      T2O = ( ( (((__int64)Tw) * ((__int64)T2M))>>(25) ) + (( (((__int64)Ty) * ((__int64)T2N))>>(25) )));
			      T7W = ((( (((__int64)Tw) * ((__int64)T2N))>>(25) )) - ( (((__int64)Ty) * ((__int64)T2M))>>(25) ));
			      T2Q = ri[(rs * 34)];
			      T2S = ii[(rs * 34)];
			      T2T = ( ( (((__int64)T2P) * ((__int64)T2Q))>>(25) ) + (( (((__int64)T2R) * ((__int64)T2S))>>(25) )));
			      T7X = ((( (((__int64)T2P) * ((__int64)T2S))>>(25) )) - ( (((__int64)T2R) * ((__int64)T2Q))>>(25) ));
			 }
			 T2U = T2O + T2T;
			 Tec = T7W + T7X;
			 {
			      E T2W, T2Y, T31, T33;
			      T2W = ri[(rs * 18)];
			      T2Y = ii[(rs * 18)];
			      T2Z = ( ( (((__int64)T2V) * ((__int64)T2W))>>(25) ) + (( (((__int64)T2X) * ((__int64)T2Y))>>(25) )));
			      T8e = ((( (((__int64)T2V) * ((__int64)T2Y))>>(25) )) - ( (((__int64)T2X) * ((__int64)T2W))>>(25) ));
			      T31 = ri[(rs * 50)];
			      T33 = ii[(rs * 50)];
			      T34 = ( ( (((__int64)T30) * ((__int64)T31))>>(25) ) + (( (((__int64)T32) * ((__int64)T33))>>(25) )));
			      T8f = ((( (((__int64)T30) * ((__int64)T33))>>(25) )) - ( (((__int64)T32) * ((__int64)T31))>>(25) ));
			 }
			 T35 = T2Z + T34;
			 Ted = T8e + T8f;
			 {
			      E T3b, T87, T3o, T88;
			      {
				   E T38, T3a, T3l, T3n;
				   T38 = ri[(rs * 10)];
				   T3a = ii[(rs * 10)];
				   T3b = ( ( (((__int64)T37) * ((__int64)T38))>>(25) ) + (( (((__int64)T39) * ((__int64)T3a))>>(25) )));
				   T87 = ((( (((__int64)T37) * ((__int64)T3a))>>(25) )) - ( (((__int64)T39) * ((__int64)T38))>>(25) ));
				   T3l = ri[(rs * 42)];
				   T3n = ii[(rs * 42)];
				   T3o = ( ( (((__int64)T3k) * ((__int64)T3l))>>(25) ) + (( (((__int64)T3m) * ((__int64)T3n))>>(25) )));
				   T88 = ((( (((__int64)T3k) * ((__int64)T3n))>>(25) )) - ( (((__int64)T3m) * ((__int64)T3l))>>(25) ));
			      }
			      T3p = T3b + T3o;
			      Tei = T87 + T88;
			      T86 = T3b - T3o;
			      T89 = T87 - T88;
			 }
			 {
			      E T3u, T82, T3z, T83;
			      {
				   E T3r, T3t, T3w, T3y;
				   T3r = ri[(rs * 58)];
				   T3t = ii[(rs * 58)];
				   T3u = ( ( (((__int64)T3q) * ((__int64)T3r))>>(25) ) + (( (((__int64)T3s) * ((__int64)T3t))>>(25) )));
				   T82 = ((( (((__int64)T3q) * ((__int64)T3t))>>(25) )) - ( (((__int64)T3s) * ((__int64)T3r))>>(25) ));
				   T3w = ri[(rs * 26)];
				   T3y = ii[(rs * 26)];
				   T3z = ( ( (((__int64)T3v) * ((__int64)T3w))>>(25) ) + (( (((__int64)T3x) * ((__int64)T3y))>>(25) )));
				   T83 = ((( (((__int64)T3v) * ((__int64)T3y))>>(25) )) - ( (((__int64)T3x) * ((__int64)T3w))>>(25) ));
			      }
			      T3A = T3u + T3z;
			      Tej = T82 + T83;
			      T81 = T3u - T3z;
			      T84 = T82 - T83;
			 }
			 T36 = T2U + T35;
			 T3B = T3p + T3A;
			 TgH = T36 - T3B;
			 TgE = Tec + Ted;
			 TgF = Tei + Tej;
			 TgG = TgE - TgF;
			 {
			      E T7Y, T7Z, Teh, Tek;
			      T7Y = T7W - T7X;
			      T7Z = T2Z - T34;
			      T80 = T7Y + T7Z;
			      TbW = T7Y - T7Z;
			      Teh = T2U - T35;
			      Tek = Tei - Tej;
			      Tel = Teh - Tek;
			      TfT = Teh + Tek;
			 }
			 {
			      E T85, T8a, T8i, T8j;
			      T85 = T81 - T84;
			      T8a = T86 + T89;
			      T8b = ( (((__int64)KP707106781) * ((__int64)(T85 - T8a)))>>(25) );
			      Tc0 = ( (((__int64)KP707106781) * ((__int64)(T8a + T85)))>>(25) );
			      T8i = T89 - T86;
			      T8j = T81 + T84;
			      T8k = ( (((__int64)KP707106781) * ((__int64)(T8i - T8j)))>>(25) );
			      TbX = ( (((__int64)KP707106781) * ((__int64)(T8i + T8j)))>>(25) );
			 }
			 {
			      E Tee, Tef, T8d, T8g;
			      Tee = Tec - Ted;
			      Tef = T3A - T3p;
			      Teg = Tee - Tef;
			      TfS = Tee + Tef;
			      T8d = T2O - T2T;
			      T8g = T8e - T8f;
			      T8h = T8d - T8g;
			      TbZ = T8d + T8g;
			 }
		    }
		    {
			 E T3H, T8n, T3M, T8o, T3N, Ten, T3S, T8F, T43, T8G, T44, Teo, T4e, Tet, T8x;
			 E T8A, T4p, Teu, T8s, T8v;
			 {
			      E T3E, T3G, T3J, T3L;
			      T3E = ri[(rs * 62)];
			      T3G = ii[(rs * 62)];
			      T3H = ( ( (((__int64)T3D) * ((__int64)T3E))>>(25) ) + (( (((__int64)T3F) * ((__int64)T3G))>>(25) )));
			      T8n = ((( (((__int64)T3D) * ((__int64)T3G))>>(25) )) - ( (((__int64)T3F) * ((__int64)T3E))>>(25) ));
			      T3J = ri[(rs * 30)];
			      T3L = ii[(rs * 30)];
			      T3M = ( ( (((__int64)T3I) * ((__int64)T3J))>>(25) ) + (( (((__int64)T3K) * ((__int64)T3L))>>(25) )));
			      T8o = ((( (((__int64)T3I) * ((__int64)T3L))>>(25) )) - ( (((__int64)T3K) * ((__int64)T3J))>>(25) ));
			 }
			 T3N = T3H + T3M;
			 Ten = T8n + T8o;
			 {
			      E T3P, T3R, T40, T42;
			      T3P = ri[(rs * 14)];
			      T3R = ii[(rs * 14)];
			      T3S = ( ( (((__int64)T3O) * ((__int64)T3P))>>(25) ) + (( (((__int64)T3Q) * ((__int64)T3R))>>(25) )));
			      T8F = ((( (((__int64)T3O) * ((__int64)T3R))>>(25) )) - ( (((__int64)T3Q) * ((__int64)T3P))>>(25) ));
			      T40 = ri[(rs * 46)];
			      T42 = ii[(rs * 46)];
			      T43 = ( ( (((__int64)T3Z) * ((__int64)T40))>>(25) ) + (( (((__int64)T41) * ((__int64)T42))>>(25) )));
			      T8G = ((( (((__int64)T3Z) * ((__int64)T42))>>(25) )) - ( (((__int64)T41) * ((__int64)T40))>>(25) ));
			 }
			 T44 = T3S + T43;
			 Teo = T8F + T8G;
			 {
			      E T48, T8y, T4d, T8z;
			      {
				   E T46, T47, T4a, T4c;
				   T46 = ri[(rs * 6)];
				   T47 = ii[(rs * 6)];
				   T48 = ( ( (((__int64)T3c) * ((__int64)T46))>>(25) ) + (( (((__int64)T3e) * ((__int64)T47))>>(25) )));
				   T8y = ((( (((__int64)T3c) * ((__int64)T47))>>(25) )) - ( (((__int64)T3e) * ((__int64)T46))>>(25) ));
				   T4a = ri[(rs * 38)];
				   T4c = ii[(rs * 38)];
				   T4d = ( ( (((__int64)T49) * ((__int64)T4a))>>(25) ) + (( (((__int64)T4b) * ((__int64)T4c))>>(25) )));
				   T8z = ((( (((__int64)T49) * ((__int64)T4c))>>(25) )) - ( (((__int64)T4b) * ((__int64)T4a))>>(25) ));
			      }
			      T4e = T48 + T4d;
			      Tet = T8y + T8z;
			      T8x = T48 - T4d;
			      T8A = T8y - T8z;
			 }
			 {
			      E T4j, T8t, T4o, T8u;
			      {
				   E T4g, T4i, T4l, T4n;
				   T4g = ri[(rs * 54)];
				   T4i = ii[(rs * 54)];
				   T4j = ( ( (((__int64)T4f) * ((__int64)T4g))>>(25) ) + (( (((__int64)T4h) * ((__int64)T4i))>>(25) )));
				   T8t = ((( (((__int64)T4f) * ((__int64)T4i))>>(25) )) - ( (((__int64)T4h) * ((__int64)T4g))>>(25) ));
				   T4l = ri[(rs * 22)];
				   T4n = ii[(rs * 22)];
				   T4o = ( ( (((__int64)T4k) * ((__int64)T4l))>>(25) ) + (( (((__int64)T4m) * ((__int64)T4n))>>(25) )));
				   T8u = ((( (((__int64)T4k) * ((__int64)T4n))>>(25) )) - ( (((__int64)T4m) * ((__int64)T4l))>>(25) ));
			      }
			      T4p = T4j + T4o;
			      Teu = T8t + T8u;
			      T8s = T4j - T4o;
			      T8v = T8t - T8u;
			 }
			 T45 = T3N + T44;
			 T4q = T4e + T4p;
			 TgJ = T45 - T4q;
			 TgK = Ten + Teo;
			 TgL = Tet + Teu;
			 TgM = TgK - TgL;
			 {
			      E T8p, T8q, Tes, Tev;
			      T8p = T8n - T8o;
			      T8q = T3S - T43;
			      T8r = T8p + T8q;
			      Tc6 = T8p - T8q;
			      Tes = T3N - T44;
			      Tev = Tet - Teu;
			      Tew = Tes - Tev;
			      TfW = Tes + Tev;
			 }
			 {
			      E T8w, T8B, T8J, T8K;
			      T8w = T8s - T8v;
			      T8B = T8x + T8A;
			      T8C = ( (((__int64)KP707106781) * ((__int64)(T8w - T8B)))>>(25) );
			      Tc4 = ( (((__int64)KP707106781) * ((__int64)(T8B + T8w)))>>(25) );
			      T8J = T8A - T8x;
			      T8K = T8s + T8v;
			      T8L = ( (((__int64)KP707106781) * ((__int64)(T8J - T8K)))>>(25) );
			      Tc7 = ( (((__int64)KP707106781) * ((__int64)(T8J + T8K)))>>(25) );
			 }
			 {
			      E Tep, Teq, T8E, T8H;
			      Tep = Ten - Teo;
			      Teq = T4p - T4e;
			      Ter = Tep - Teq;
			      TfV = Tep + Teq;
			      T8E = T3H - T3M;
			      T8H = T8F - T8G;
			      T8I = T8E - T8H;
			      Tc3 = T8E + T8H;
			 }
		    }
		    {
			 E T5V, Tao, T64, Tap, T65, Tfi, T68, T9K, T6d, T9L, T6e, Tfj, T6o, Tf2, T9Q;
			 E T9R, T6z, Tf3, T9T, T9W;
			 {
			      E T5T, T5U, T5Z, T63;
			      T5T = ri[(rs * 63)];
			      T5U = ii[(rs * 63)];
			      T5V = ( ( (((__int64)TW) * ((__int64)T5T))>>(25) ) + (( (((__int64)T10) * ((__int64)T5U))>>(25) )));
			      Tao = ((( (((__int64)TW) * ((__int64)T5U))>>(25) )) - ( (((__int64)T10) * ((__int64)T5T))>>(25) ));
			      T5Z = ri[(rs * 31)];
			      T63 = ii[(rs * 31)];
			      T64 = ( ( (((__int64)T5Y) * ((__int64)T5Z))>>(25) ) + (( (((__int64)T62) * ((__int64)T63))>>(25) )));
			      Tap = ((( (((__int64)T5Y) * ((__int64)T63))>>(25) )) - ( (((__int64)T62) * ((__int64)T5Z))>>(25) ));
			 }
			 T65 = T5V + T64;
			 Tfi = Tao + Tap;
			 {
			      E T66, T67, T6a, T6c;
			      T66 = ri[(rs * 15)];
			      T67 = ii[(rs * 15)];
			      T68 = ( ( (((__int64)TV) * ((__int64)T66))>>(25) ) + (( (((__int64)TZ) * ((__int64)T67))>>(25) )));
			      T9K = ((( (((__int64)TV) * ((__int64)T67))>>(25) )) - ( (((__int64)TZ) * ((__int64)T66))>>(25) ));
			      T6a = ri[(rs * 47)];
			      T6c = ii[(rs * 47)];
			      T6d = ( ( (((__int64)T69) * ((__int64)T6a))>>(25) ) + (( (((__int64)T6b) * ((__int64)T6c))>>(25) )));
			      T9L = ((( (((__int64)T69) * ((__int64)T6c))>>(25) )) - ( (((__int64)T6b) * ((__int64)T6a))>>(25) ));
			 }
			 T6e = T68 + T6d;
			 Tfj = T9K + T9L;
			 {
			      E T6i, T9O, T6n, T9P;
			      {
				   E T6g, T6h, T6k, T6m;
				   T6g = ri[(rs * 7)];
				   T6h = ii[(rs * 7)];
				   T6i = ( ( (((__int64)T1t) * ((__int64)T6g))>>(25) ) + (( (((__int64)T1u) * ((__int64)T6h))>>(25) )));
				   T9O = ((( (((__int64)T1t) * ((__int64)T6h))>>(25) )) - ( (((__int64)T1u) * ((__int64)T6g))>>(25) ));
				   T6k = ri[(rs * 39)];
				   T6m = ii[(rs * 39)];
				   T6n = ( ( (((__int64)T6j) * ((__int64)T6k))>>(25) ) + (( (((__int64)T6l) * ((__int64)T6m))>>(25) )));
				   T9P = ((( (((__int64)T6j) * ((__int64)T6m))>>(25) )) - ( (((__int64)T6l) * ((__int64)T6k))>>(25) ));
			      }
			      T6o = T6i + T6n;
			      Tf2 = T9O + T9P;
			      T9Q = T9O - T9P;
			      T9R = T6i - T6n;
			 }
			 {
			      E T6t, T9U, T6y, T9V;
			      {
				   E T6q, T6s, T6v, T6x;
				   T6q = ri[(rs * 55)];
				   T6s = ii[(rs * 55)];
				   T6t = ( ( (((__int64)T6p) * ((__int64)T6q))>>(25) ) + (( (((__int64)T6r) * ((__int64)T6s))>>(25) )));
				   T9U = ((( (((__int64)T6p) * ((__int64)T6s))>>(25) )) - ( (((__int64)T6r) * ((__int64)T6q))>>(25) ));
				   T6v = ri[(rs * 23)];
				   T6x = ii[(rs * 23)];
				   T6y = ( ( (((__int64)T6u) * ((__int64)T6v))>>(25) ) + (( (((__int64)T6w) * ((__int64)T6x))>>(25) )));
				   T9V = ((( (((__int64)T6u) * ((__int64)T6x))>>(25) )) - ( (((__int64)T6w) * ((__int64)T6v))>>(25) ));
			      }
			      T6z = T6t + T6y;
			      Tf3 = T9U + T9V;
			      T9T = T6t - T6y;
			      T9W = T9U - T9V;
			 }
			 {
			      E T6f, T6A, Tfk, Tfl;
			      T6f = T65 + T6e;
			      T6A = T6o + T6z;
			      T6B = T6f + T6A;
			      Th1 = T6f - T6A;
			      Tfk = Tfi - Tfj;
			      Tfl = T6z - T6o;
			      Tfm = Tfk - Tfl;
			      Tga = Tfk + Tfl;
			 }
			 {
			      E Th6, Th7, T9J, T9M;
			      Th6 = Tfi + Tfj;
			      Th7 = Tf2 + Tf3;
			      Th8 = Th6 - Th7;
			      ThI = Th6 + Th7;
			      T9J = T5V - T64;
			      T9M = T9K - T9L;
			      T9N = T9J - T9M;
			      Tcv = T9J + T9M;
			 }
			 {
			      E T9S, T9X, Tat, Tau;
			      T9S = T9Q - T9R;
			      T9X = T9T + T9W;
			      T9Y = ( (((__int64)KP707106781) * ((__int64)(T9S - T9X)))>>(25) );
			      TcH = ( (((__int64)KP707106781) * ((__int64)(T9S + T9X)))>>(25) );
			      Tat = T9T - T9W;
			      Tau = T9R + T9Q;
			      Tav = ( (((__int64)KP707106781) * ((__int64)(Tat - Tau)))>>(25) );
			      Tcw = ( (((__int64)KP707106781) * ((__int64)(Tau + Tat)))>>(25) );
			 }
			 {
			      E Tf1, Tf4, Taq, Tar;
			      Tf1 = T65 - T6e;
			      Tf4 = Tf2 - Tf3;
			      Tf5 = Tf1 - Tf4;
			      Tg7 = Tf1 + Tf4;
			      Taq = Tao - Tap;
			      Tar = T68 - T6d;
			      Tas = Taq + Tar;
			      TcG = Taq - Tar;
			 }
		    }
		    {
			 E T4w, T8Q, T4B, T8R, T4C, TeA, T4F, T9w, T4K, T9x, T4L, TeB, T4V, TeS, T90;
			 E T93, T5a, TeT, T8V, T8Y;
			 {
			      E T4u, T4v, T4y, T4A;
			      T4u = ri[(rs * 1)];
			      T4v = ii[(rs * 1)];
			      T4w = ( ( (((__int64)T2) * ((__int64)T4u))>>(25) ) + (( (((__int64)T5) * ((__int64)T4v))>>(25) )));
			      T8Q = ((( (((__int64)T2) * ((__int64)T4v))>>(25) )) - ( (((__int64)T5) * ((__int64)T4u))>>(25) ));
			      T4y = ri[(rs * 33)];
			      T4A = ii[(rs * 33)];
			      T4B = ( ( (((__int64)T4x) * ((__int64)T4y))>>(25) ) + (( (((__int64)T4z) * ((__int64)T4A))>>(25) )));
			      T8R = ((( (((__int64)T4x) * ((__int64)T4A))>>(25) )) - ( (((__int64)T4z) * ((__int64)T4y))>>(25) ));
			 }
			 T4C = T4w + T4B;
			 TeA = T8Q + T8R;
			 {
			      E T4D, T4E, T4H, T4J;
			      T4D = ri[(rs * 17)];
			      T4E = ii[(rs * 17)];
			      T4F = ( ( (((__int64)T3V) * ((__int64)T4D))>>(25) ) + (( (((__int64)T3Y) * ((__int64)T4E))>>(25) )));
			      T9w = ((( (((__int64)T3V) * ((__int64)T4E))>>(25) )) - ( (((__int64)T3Y) * ((__int64)T4D))>>(25) ));
			      T4H = ri[(rs * 49)];
			      T4J = ii[(rs * 49)];
			      T4K = ( ( (((__int64)T4G) * ((__int64)T4H))>>(25) ) + (( (((__int64)T4I) * ((__int64)T4J))>>(25) )));
			      T9x = ((( (((__int64)T4G) * ((__int64)T4J))>>(25) )) - ( (((__int64)T4I) * ((__int64)T4H))>>(25) ));
			 }
			 T4L = T4F + T4K;
			 TeB = T9w + T9x;
			 {
			      E T4P, T91, T4U, T92;
			      {
				   E T4N, T4O, T4R, T4T;
				   T4N = ri[(rs * 9)];
				   T4O = ii[(rs * 9)];
				   T4P = ( ( (((__int64)T9) * ((__int64)T4N))>>(25) ) + (( (((__int64)Te) * ((__int64)T4O))>>(25) )));
				   T91 = ((( (((__int64)T9) * ((__int64)T4O))>>(25) )) - ( (((__int64)Te) * ((__int64)T4N))>>(25) ));
				   T4R = ri[(rs * 41)];
				   T4T = ii[(rs * 41)];
				   T4U = ( ( (((__int64)T4Q) * ((__int64)T4R))>>(25) ) + (( (((__int64)T4S) * ((__int64)T4T))>>(25) )));
				   T92 = ((( (((__int64)T4Q) * ((__int64)T4T))>>(25) )) - ( (((__int64)T4S) * ((__int64)T4R))>>(25) ));
			      }
			      T4V = T4P + T4U;
			      TeS = T91 + T92;
			      T90 = T4P - T4U;
			      T93 = T91 - T92;
			 }
			 {
			      E T50, T8W, T59, T8X;
			      {
				   E T4X, T4Z, T54, T58;
				   T4X = ri[(rs * 57)];
				   T4Z = ii[(rs * 57)];
				   T50 = ( ( (((__int64)T4W) * ((__int64)T4X))>>(25) ) + (( (((__int64)T4Y) * ((__int64)T4Z))>>(25) )));
				   T8W = ((( (((__int64)T4W) * ((__int64)T4Z))>>(25) )) - ( (((__int64)T4Y) * ((__int64)T4X))>>(25) ));
				   T54 = ri[(rs * 25)];
				   T58 = ii[(rs * 25)];
				   T59 = ( ( (((__int64)T53) * ((__int64)T54))>>(25) ) + (( (((__int64)T57) * ((__int64)T58))>>(25) )));
				   T8X = ((( (((__int64)T53) * ((__int64)T58))>>(25) )) - ( (((__int64)T57) * ((__int64)T54))>>(25) ));
			      }
			      T5a = T50 + T59;
			      TeT = T8W + T8X;
			      T8V = T50 - T59;
			      T8Y = T8W - T8X;
			 }
			 {
			      E T4M, T5b, TeR, TeU;
			      T4M = T4C + T4L;
			      T5b = T4V + T5a;
			      T5c = T4M + T5b;
			      TgV = T4M - T5b;
			      TeR = T4C - T4L;
			      TeU = TeS - TeT;
			      TeV = TeR - TeU;
			      Tg0 = TeR + TeU;
			 }
			 {
			      E TgQ, TgR, T8S, T8T;
			      TgQ = TeA + TeB;
			      TgR = TeS + TeT;
			      TgS = TgQ - TgR;
			      ThD = TgQ + TgR;
			      T8S = T8Q - T8R;
			      T8T = T4F - T4K;
			      T8U = T8S + T8T;
			      Tcc = T8S - T8T;
			 }
			 {
			      E T8Z, T94, T9A, T9B;
			      T8Z = T8V - T8Y;
			      T94 = T90 + T93;
			      T95 = ( (((__int64)KP707106781) * ((__int64)(T8Z - T94)))>>(25) );
			      Tco = ( (((__int64)KP707106781) * ((__int64)(T94 + T8Z)))>>(25) );
			      T9A = T93 - T90;
			      T9B = T8V + T8Y;
			      T9C = ( (((__int64)KP707106781) * ((__int64)(T9A - T9B)))>>(25) );
			      Tcd = ( (((__int64)KP707106781) * ((__int64)(T9A + T9B)))>>(25) );
			 }
			 {
			      E TeC, TeD, T9v, T9y;
			      TeC = TeA - TeB;
			      TeD = T5a - T4V;
			      TeE = TeC - TeD;
			      Tg3 = TeC + TeD;
			      T9v = T4w - T4B;
			      T9y = T9w - T9x;
			      T9z = T9v - T9y;
			      Tcn = T9v + T9y;
			 }
		    }
		    {
			 E T5l, TeL, T9k, T9n, T5P, TeH, T9a, T9f, T5u, TeM, T9l, T9q, T5G, TeG, T97;
			 E T9e;
			 {
			      E T5f, T9i, T5k, T9j;
			      {
				   E T5d, T5e, T5h, T5j;
				   T5d = ri[(rs * 5)];
				   T5e = ii[(rs * 5)];
				   T5f = ( ( (((__int64)Tg) * ((__int64)T5d))>>(25) ) + (( (((__int64)Tl) * ((__int64)T5e))>>(25) )));
				   T9i = ((( (((__int64)Tg) * ((__int64)T5e))>>(25) )) - ( (((__int64)Tl) * ((__int64)T5d))>>(25) ));
				   T5h = ri[(rs * 37)];
				   T5j = ii[(rs * 37)];
				   T5k = ( ( (((__int64)T5g) * ((__int64)T5h))>>(25) ) + (( (((__int64)T5i) * ((__int64)T5j))>>(25) )));
				   T9j = ((( (((__int64)T5g) * ((__int64)T5j))>>(25) )) - ( (((__int64)T5i) * ((__int64)T5h))>>(25) ));
			      }
			      T5l = T5f + T5k;
			      TeL = T9i + T9j;
			      T9k = T9i - T9j;
			      T9n = T5f - T5k;
			 }
			 {
			      E T5J, T98, T5O, T99;
			      {
				   E T5H, T5I, T5L, T5N;
				   T5H = ri[(rs * 13)];
				   T5I = ii[(rs * 13)];
				   T5J = ( ( (((__int64)T1h) * ((__int64)T5H))>>(25) ) + (( (((__int64)T1j) * ((__int64)T5I))>>(25) )));
				   T98 = ((( (((__int64)T1h) * ((__int64)T5I))>>(25) )) - ( (((__int64)T1j) * ((__int64)T5H))>>(25) ));
				   T5L = ri[(rs * 45)];
				   T5N = ii[(rs * 45)];
				   T5O = ( ( (((__int64)T5K) * ((__int64)T5L))>>(25) ) + (( (((__int64)T5M) * ((__int64)T5N))>>(25) )));
				   T99 = ((( (((__int64)T5K) * ((__int64)T5N))>>(25) )) - ( (((__int64)T5M) * ((__int64)T5L))>>(25) ));
			      }
			      T5P = T5J + T5O;
			      TeH = T98 + T99;
			      T9a = T98 - T99;
			      T9f = T5J - T5O;
			 }
			 {
			      E T5o, T9o, T5t, T9p;
			      {
				   E T5m, T5n, T5q, T5s;
				   T5m = ri[(rs * 21)];
				   T5n = ii[(rs * 21)];
				   T5o = ( ( (((__int64)T3g) * ((__int64)T5m))>>(25) ) + (( (((__int64)T3j) * ((__int64)T5n))>>(25) )));
				   T9o = ((( (((__int64)T3g) * ((__int64)T5n))>>(25) )) - ( (((__int64)T3j) * ((__int64)T5m))>>(25) ));
				   T5q = ri[(rs * 53)];
				   T5s = ii[(rs * 53)];
				   T5t = ( ( (((__int64)T5p) * ((__int64)T5q))>>(25) ) + (( (((__int64)T5r) * ((__int64)T5s))>>(25) )));
				   T9p = ((( (((__int64)T5p) * ((__int64)T5s))>>(25) )) - ( (((__int64)T5r) * ((__int64)T5q))>>(25) ));
			      }
			      T5u = T5o + T5t;
			      TeM = T9o + T9p;
			      T9l = T5o - T5t;
			      T9q = T9o - T9p;
			 }
			 {
			      E T5A, T9c, T5F, T9d;
			      {
				   E T5x, T5z, T5C, T5E;
				   T5x = ri[(rs * 61)];
				   T5z = ii[(rs * 61)];
				   T5A = ( ( (((__int64)T5w) * ((__int64)T5x))>>(25) ) + (( (((__int64)T5y) * ((__int64)T5z))>>(25) )));
				   T9c = ((( (((__int64)T5w) * ((__int64)T5z))>>(25) )) - ( (((__int64)T5y) * ((__int64)T5x))>>(25) ));
				   T5C = ri[(rs * 29)];
				   T5E = ii[(rs * 29)];
				   T5F = ( ( (((__int64)T5B) * ((__int64)T5C))>>(25) ) + (( (((__int64)T5D) * ((__int64)T5E))>>(25) )));
				   T9d = ((( (((__int64)T5B) * ((__int64)T5E))>>(25) )) - ( (((__int64)T5D) * ((__int64)T5C))>>(25) ));
			      }
			      T5G = T5A + T5F;
			      TeG = T9c + T9d;
			      T97 = T5A - T5F;
			      T9e = T9c - T9d;
			 }
			 {
			      E T5v, T5Q, TeK, TeN;
			      T5v = T5l + T5u;
			      T5Q = T5G + T5P;
			      T5R = T5v + T5Q;
			      TgT = T5Q - T5v;
			      TeK = T5l - T5u;
			      TeN = TeL - TeM;
			      TeO = TeK + TeN;
			      TeW = TeN - TeK;
			 }
			 {
			      E TgW, TgX, T9b, T9g;
			      TgW = TeL + TeM;
			      TgX = TeG + TeH;
			      TgY = TgW - TgX;
			      ThE = TgW + TgX;
			      T9b = T97 - T9a;
			      T9g = T9e + T9f;
			      T9h = ((( (((__int64)KP382683432) * ((__int64)T9b))>>(25) )) - ( (((__int64)KP923879532) * ((__int64)T9g))>>(25) ));
			      T9F = ( ( (((__int64)KP382683432) * ((__int64)T9g))>>(25) ) + (( (((__int64)KP923879532) * ((__int64)T9b))>>(25) )));
			 }
			 {
			      E T9m, T9r, Tci, Tcj;
			      T9m = T9k + T9l;
			      T9r = T9n - T9q;
			      T9s = ( ( (((__int64)KP923879532) * ((__int64)T9m))>>(25) ) + (( (((__int64)KP382683432) * ((__int64)T9r))>>(25) )));
			      T9E = ((( (((__int64)KP382683432) * ((__int64)T9m))>>(25) )) - ( (((__int64)KP923879532) * ((__int64)T9r))>>(25) ));
			      Tci = T9k - T9l;
			      Tcj = T9n + T9q;
			      Tck = ( ( (((__int64)KP382683432) * ((__int64)Tci))>>(25) ) + (( (((__int64)KP923879532) * ((__int64)Tcj))>>(25) )));
			      Tcq = ((( (((__int64)KP923879532) * ((__int64)Tci))>>(25) )) - ( (((__int64)KP382683432) * ((__int64)Tcj))>>(25) ));
			 }
			 {
			      E TeF, TeI, Tcf, Tcg;
			      TeF = T5G - T5P;
			      TeI = TeG - TeH;
			      TeJ = TeF - TeI;
			      TeX = TeF + TeI;
			      Tcf = T97 + T9a;
			      Tcg = T9e - T9f;
			      Tch = ((( (((__int64)KP923879532) * ((__int64)Tcf))>>(25) )) - ( (((__int64)KP382683432) * ((__int64)Tcg))>>(25) ));
			      Tcr = ( ( (((__int64)KP923879532) * ((__int64)Tcg))>>(25) ) + (( (((__int64)KP382683432) * ((__int64)Tcf))>>(25) )));
			 }
		    }
		    {
			 E T6K, Tf6, Ta2, Ta5, T7c, Tfd, Tae, Taj, T6T, Tf7, Ta3, Ta8, T73, Tfc, Tad;
			 E Tag;
			 {
			      E T6E, Ta0, T6J, Ta1;
			      {
				   E T6C, T6D, T6G, T6I;
				   T6C = ri[(rs * 3)];
				   T6D = ii[(rs * 3)];
				   T6E = ( ( (((__int64)T3) * ((__int64)T6C))>>(25) ) + (( (((__int64)T6) * ((__int64)T6D))>>(25) )));
				   Ta0 = ((( (((__int64)T3) * ((__int64)T6D))>>(25) )) - ( (((__int64)T6) * ((__int64)T6C))>>(25) ));
				   T6G = ri[(rs * 35)];
				   T6I = ii[(rs * 35)];
				   T6J = ( ( (((__int64)T6F) * ((__int64)T6G))>>(25) ) + (( (((__int64)T6H) * ((__int64)T6I))>>(25) )));
				   Ta1 = ((( (((__int64)T6F) * ((__int64)T6I))>>(25) )) - ( (((__int64)T6H) * ((__int64)T6G))>>(25) ));
			      }
			      T6K = T6E + T6J;
			      Tf6 = Ta0 + Ta1;
			      Ta2 = Ta0 - Ta1;
			      Ta5 = T6E - T6J;
			 }
			 {
			      E T76, Tah, T7b, Tai;
			      {
				   E T74, T75, T78, T7a;
				   T74 = ri[(rs * 11)];
				   T75 = ii[(rs * 11)];
				   T76 = ( ( (((__int64)TA) * ((__int64)T74))>>(25) ) + (( (((__int64)TE) * ((__int64)T75))>>(25) )));
				   Tah = ((( (((__int64)TA) * ((__int64)T75))>>(25) )) - ( (((__int64)TE) * ((__int64)T74))>>(25) ));
				   T78 = ri[(rs * 43)];
				   T7a = ii[(rs * 43)];
				   T7b = ( ( (((__int64)T77) * ((__int64)T78))>>(25) ) + (( (((__int64)T79) * ((__int64)T7a))>>(25) )));
				   Tai = ((( (((__int64)T77) * ((__int64)T7a))>>(25) )) - ( (((__int64)T79) * ((__int64)T78))>>(25) ));
			      }
			      T7c = T76 + T7b;
			      Tfd = Tah + Tai;
			      Tae = T76 - T7b;
			      Taj = Tah - Tai;
			 }
			 {
			      E T6N, Ta6, T6S, Ta7;
			      {
				   E T6L, T6M, T6P, T6R;
				   T6L = ri[(rs * 19)];
				   T6M = ii[(rs * 19)];
				   T6N = ( ( (((__int64)T2z) * ((__int64)T6L))>>(25) ) + (( (((__int64)T2C) * ((__int64)T6M))>>(25) )));
				   Ta6 = ((( (((__int64)T2z) * ((__int64)T6M))>>(25) )) - ( (((__int64)T2C) * ((__int64)T6L))>>(25) ));
				   T6P = ri[(rs * 51)];
				   T6R = ii[(rs * 51)];
				   T6S = ( ( (((__int64)T6O) * ((__int64)T6P))>>(25) ) + (( (((__int64)T6Q) * ((__int64)T6R))>>(25) )));
				   Ta7 = ((( (((__int64)T6O) * ((__int64)T6R))>>(25) )) - ( (((__int64)T6Q) * ((__int64)T6P))>>(25) ));
			      }
			      T6T = T6N + T6S;
			      Tf7 = Ta6 + Ta7;
			      Ta3 = T6N - T6S;
			      Ta8 = Ta6 - Ta7;
			 }
			 {
			      E T6Z, Tab, T72, Tac;
			      {
				   E T6W, T6Y, T70, T71;
				   T6W = ri[(rs * 59)];
				   T6Y = ii[(rs * 59)];
				   T6Z = ( ( (((__int64)T6V) * ((__int64)T6W))>>(25) ) + (( (((__int64)T6X) * ((__int64)T6Y))>>(25) )));
				   Tab = ((( (((__int64)T6V) * ((__int64)T6Y))>>(25) )) - ( (((__int64)T6X) * ((__int64)T6W))>>(25) ));
				   T70 = ri[(rs * 27)];
				   T71 = ii[(rs * 27)];
				   T72 = ( ( (((__int64)Th) * ((__int64)T70))>>(25) ) + (( (((__int64)Tm) * ((__int64)T71))>>(25) )));
				   Tac = ((( (((__int64)Th) * ((__int64)T71))>>(25) )) - ( (((__int64)Tm) * ((__int64)T70))>>(25) ));
			      }
			      T73 = T6Z + T72;
			      Tfc = Tab + Tac;
			      Tad = Tab - Tac;
			      Tag = T6Z - T72;
			 }
			 {
			      E T6U, T7d, Tfb, Tfe;
			      T6U = T6K + T6T;
			      T7d = T73 + T7c;
			      T7e = T6U + T7d;
			      Th9 = T7d - T6U;
			      Tfb = T73 - T7c;
			      Tfe = Tfc - Tfd;
			      Tff = Tfb + Tfe;
			      Tfn = Tfb - Tfe;
			 }
			 {
			      E Th2, Th3, Ta4, Ta9;
			      Th2 = Tf6 + Tf7;
			      Th3 = Tfc + Tfd;
			      Th4 = Th2 - Th3;
			      ThJ = Th2 + Th3;
			      Ta4 = Ta2 + Ta3;
			      Ta9 = Ta5 - Ta8;
			      Taa = ((( (((__int64)KP382683432) * ((__int64)Ta4))>>(25) )) - ( (((__int64)KP923879532) * ((__int64)Ta9))>>(25) ));
			      Tay = ( ( (((__int64)KP923879532) * ((__int64)Ta4))>>(25) ) + (( (((__int64)KP382683432) * ((__int64)Ta9))>>(25) )));
			 }
			 {
			      E Taf, Tak, TcB, TcC;
			      Taf = Tad + Tae;
			      Tak = Tag - Taj;
			      Tal = ( ( (((__int64)KP382683432) * ((__int64)Taf))>>(25) ) + (( (((__int64)KP923879532) * ((__int64)Tak))>>(25) )));
			      Tax = ((( (((__int64)KP382683432) * ((__int64)Tak))>>(25) )) - ( (((__int64)KP923879532) * ((__int64)Taf))>>(25) ));
			      TcB = Tad - Tae;
			      TcC = Tag + Taj;
			      TcD = ( ( (((__int64)KP923879532) * ((__int64)TcB))>>(25) ) + (( (((__int64)KP382683432) * ((__int64)TcC))>>(25) )));
			      TcJ = ((( (((__int64)KP923879532) * ((__int64)TcC))>>(25) )) - ( (((__int64)KP382683432) * ((__int64)TcB))>>(25) ));
			 }
			 {
			      E Tf8, Tf9, Tcy, Tcz;
			      Tf8 = Tf6 - Tf7;
			      Tf9 = T6K - T6T;
			      Tfa = Tf8 - Tf9;
			      Tfo = Tf9 + Tf8;
			      Tcy = Ta2 - Ta3;
			      Tcz = Ta5 + Ta8;
			      TcA = ((( (((__int64)KP923879532) * ((__int64)Tcy))>>(25) )) - ( (((__int64)KP382683432) * ((__int64)Tcz))>>(25) ));
			      TcK = ( ( (((__int64)KP382683432) * ((__int64)Tcy))>>(25) ) + (( (((__int64)KP923879532) * ((__int64)Tcz))>>(25) )));
			 }
		    }
		    {
			 E T2L, Thx, ThU, ThV, Ti5, Tib, T4s, Tia, T7g, Ti7, ThG, ThO, ThL, ThP, ThA;
			 E ThW;
			 {
			      E T1L, T2K, ThS, ThT;
			      T1L = T17 + T1K;
			      T2K = T2e + T2J;
			      T2L = T1L + T2K;
			      Thx = T1L - T2K;
			      ThS = ThD + ThE;
			      ThT = ThI + ThJ;
			      ThU = ThS - ThT;
			      ThV = ThS + ThT;
			 }
			 {
			      E ThX, Ti4, T3C, T4r;
			      ThX = TgA + TgB;
			      Ti4 = ThY + Ti3;
			      Ti5 = ThX + Ti4;
			      Tib = Ti4 - ThX;
			      T3C = T36 + T3B;
			      T4r = T45 + T4q;
			      T4s = T3C + T4r;
			      Tia = T4r - T3C;
			 }
			 {
			      E T5S, T7f, ThC, ThF;
			      T5S = T5c + T5R;
			      T7f = T6B + T7e;
			      T7g = T5S + T7f;
			      Ti7 = T7f - T5S;
			      ThC = T5c - T5R;
			      ThF = ThD - ThE;
			      ThG = ThC + ThF;
			      ThO = ThF - ThC;
			 }
			 {
			      E ThH, ThK, Thy, Thz;
			      ThH = T6B - T7e;
			      ThK = ThI - ThJ;
			      ThL = ThH - ThK;
			      ThP = ThH + ThK;
			      Thy = TgE + TgF;
			      Thz = TgK + TgL;
			      ThA = Thy - Thz;
			      ThW = Thy + Thz;
			 }
			 {
			      E T4t, Ti6, ThR, Ti8;
			      T4t = T2L + T4s;
			      ri[(rs * 32)] = ( T4t - T7g >> (6) );
			      ri[0] = 			( T4t + T7g >> (6) );
			      Ti6 = ThW + Ti5;
			      ii[0] = 			( ThV + Ti6 >> (6) );
			      ii[(rs * 32)] = ( Ti6 - ThV >> (6) );
			      ThR = T2L - T4s;
			      ri[(rs * 48)] = ( ThR - ThU >> (6) );
			      ri[(rs * 16)] = ( ThR + ThU >> (6) );
			      Ti8 = Ti5 - ThW;
			      ii[(rs * 16)] = ( Ti7 + Ti8 >> (6) );
			      ii[(rs * 48)] = ( Ti8 - Ti7 >> (6) );
			 }
			 {
			      E ThB, ThM, Ti9, Tic;
			      ThB = Thx + ThA;
			      ThM = ( (((__int64)KP707106781) * ((__int64)(ThG + ThL)))>>(25) );
			      ri[(rs * 40)] = ( ThB - ThM >> (6) );
			      ri[(rs * 8)] = ( ThB + ThM >> (6) );
			      Ti9 = ( (((__int64)KP707106781) * ((__int64)(ThO + ThP)))>>(25) );
			      Tic = Tia + Tib;
			      ii[(rs * 8)] = ( Ti9 + Tic >> (6) );
			      ii[(rs * 40)] = ( Tic - Ti9 >> (6) );
			 }
			 {
			      E ThN, ThQ, Tid, Tie;
			      ThN = Thx - ThA;
			      ThQ = ( (((__int64)KP707106781) * ((__int64)(ThO - ThP)))>>(25) );
			      ri[(rs * 56)] = ( ThN - ThQ >> (6) );
			      ri[(rs * 24)] = ( ThN + ThQ >> (6) );
			      Tid = ( (((__int64)KP707106781) * ((__int64)(ThL - ThG)))>>(25) );
			      Tie = Tib - Tia;
			      ii[(rs * 24)] = ( Tid + Tie >> (6) );
			      ii[(rs * 56)] = ( Tie - Tid >> (6) );
			 }
		    }
		    {
			 E TgD, Thh, Thr, Thv, Tij, Tip, TgO, Tig, Th0, The, Thk, Tio, Tho, Thu, Thb;
			 E Thf;
			 {
			      E Tgz, TgC, Thp, Thq;
			      Tgz = T17 - T1K;
			      TgC = TgA - TgB;
			      TgD = Tgz - TgC;
			      Thh = Tgz + TgC;
			      Thp = Th1 + Th4;
			      Thq = Th8 + Th9;
			      Thr = ((( (((__int64)KP923879532) * ((__int64)Thp))>>(25) )) - ( (((__int64)KP382683432) * ((__int64)Thq))>>(25) ));
			      Thv = ( ( (((__int64)KP923879532) * ((__int64)Thq))>>(25) ) + (( (((__int64)KP382683432) * ((__int64)Thp))>>(25) )));
			 }
			 {
			      E Tih, Tii, TgI, TgN;
			      Tih = T2J - T2e;
			      Tii = Ti3 - ThY;
			      Tij = Tih + Tii;
			      Tip = Tii - Tih;
			      TgI = TgG - TgH;
			      TgN = TgJ + TgM;
			      TgO = ( (((__int64)KP707106781) * ((__int64)(TgI - TgN)))>>(25) );
			      Tig = ( (((__int64)KP707106781) * ((__int64)(TgI + TgN)))>>(25) );
			 }
			 {
			      E TgU, TgZ, Thi, Thj;
			      TgU = TgS - TgT;
			      TgZ = TgV - TgY;
			      Th0 = ( ( (((__int64)KP923879532) * ((__int64)TgU))>>(25) ) + (( (((__int64)KP382683432) * ((__int64)TgZ))>>(25) )));
			      The = ((( (((__int64)KP382683432) * ((__int64)TgU))>>(25) )) - ( (((__int64)KP923879532) * ((__int64)TgZ))>>(25) ));
			      Thi = TgH + TgG;
			      Thj = TgJ - TgM;
			      Thk = ( (((__int64)KP707106781) * ((__int64)(Thi + Thj)))>>(25) );
			      Tio = ( (((__int64)KP707106781) * ((__int64)(Thj - Thi)))>>(25) );
			 }
			 {
			      E Thm, Thn, Th5, Tha;
			      Thm = TgS + TgT;
			      Thn = TgV + TgY;
			      Tho = ( ( (((__int64)KP382683432) * ((__int64)Thm))>>(25) ) + (( (((__int64)KP923879532) * ((__int64)Thn))>>(25) )));
			      Thu = ((( (((__int64)KP923879532) * ((__int64)Thm))>>(25) )) - ( (((__int64)KP382683432) * ((__int64)Thn))>>(25) ));
			      Th5 = Th1 - Th4;
			      Tha = Th8 - Th9;
			      Thb = ((( (((__int64)KP382683432) * ((__int64)Th5))>>(25) )) - ( (((__int64)KP923879532) * ((__int64)Tha))>>(25) ));
			      Thf = ( ( (((__int64)KP382683432) * ((__int64)Tha))>>(25) ) + (( (((__int64)KP923879532) * ((__int64)Th5))>>(25) )));
			 }
			 {
			      E TgP, Thc, Tin, Tiq;
			      TgP = TgD + TgO;
			      Thc = Th0 + Thb;
			      ri[(rs * 44)] = ( TgP - Thc >> (6) );
			      ri[(rs * 12)] = ( TgP + Thc >> (6) );
			      Tin = The + Thf;
			      Tiq = Tio + Tip;
			      ii[(rs * 12)] = ( Tin + Tiq >> (6) );
			      ii[(rs * 44)] = ( Tiq - Tin >> (6) );
			 }
			 {
			      E Thd, Thg, Tir, Tis;
			      Thd = TgD - TgO;
			      Thg = The - Thf;
			      ri[(rs * 60)] = ( Thd - Thg >> (6) );
			      ri[(rs * 28)] = ( Thd + Thg >> (6) );
			      Tir = Thb - Th0;
			      Tis = Tip - Tio;
			      ii[(rs * 28)] = ( Tir + Tis >> (6) );
			      ii[(rs * 60)] = ( Tis - Tir >> (6) );
			 }
			 {
			      E Thl, Ths, Tif, Tik;
			      Thl = Thh + Thk;
			      Ths = Tho + Thr;
			      ri[(rs * 36)] = ( Thl - Ths >> (6) );
			      ri[(rs * 4)] = ( Thl + Ths >> (6) );
			      Tif = Thu + Thv;
			      Tik = Tig + Tij;
			      ii[(rs * 4)] = ( Tif + Tik >> (6) );
			      ii[(rs * 36)] = ( Tik - Tif >> (6) );
			 }
			 {
			      E Tht, Thw, Til, Tim;
			      Tht = Thh - Thk;
			      Thw = Thu - Thv;
			      ri[(rs * 52)] = ( Tht - Thw >> (6) );
			      ri[(rs * 20)] = ( Tht + Thw >> (6) );
			      Til = Thr - Tho;
			      Tim = Tij - Tig;
			      ii[(rs * 20)] = ( Til + Tim >> (6) );
			      ii[(rs * 52)] = ( Tim - Til >> (6) );
			 }
		    }
		    {
			 E Teb, Tfx, Tey, TiK, TiN, TiT, TfA, TiS, Tfr, TfL, Tfv, TfH, Tf0, TfK, Tfu;
			 E TfE;
			 {
			      E TdZ, Tea, Tfy, Tfz;
			      TdZ = TdV - TdY;
			      Tea = ( (((__int64)KP707106781) * ((__int64)(Te4 - Te9)))>>(25) );
			      Teb = TdZ - Tea;
			      Tfx = TdZ + Tea;
			      {
				   E Tem, Tex, TiL, TiM;
				   Tem = ((( (((__int64)KP382683432) * ((__int64)Teg))>>(25) )) - ( (((__int64)KP923879532) * ((__int64)Tel))>>(25) ));
				   Tex = ( ( (((__int64)KP382683432) * ((__int64)Ter))>>(25) ) + (( (((__int64)KP923879532) * ((__int64)Tew))>>(25) )));
				   Tey = Tem - Tex;
				   TiK = Tem + Tex;
				   TiL = ( (((__int64)KP707106781) * ((__int64)(TfP - TfO)))>>(25) );
				   TiM = Tix - Tiw;
				   TiN = TiL + TiM;
				   TiT = TiM - TiL;
			      }
			      Tfy = ( ( (((__int64)KP923879532) * ((__int64)Teg))>>(25) ) + (( (((__int64)KP382683432) * ((__int64)Tel))>>(25) )));
			      Tfz = ((( (((__int64)KP382683432) * ((__int64)Tew))>>(25) )) - ( (((__int64)KP923879532) * ((__int64)Ter))>>(25) ));
			      TfA = Tfy + Tfz;
			      TiS = Tfz - Tfy;
			      {
				   E Tfh, TfF, Tfq, TfG, Tfg, Tfp;
				   Tfg = ( (((__int64)KP707106781) * ((__int64)(Tfa - Tff)))>>(25) );
				   Tfh = Tf5 - Tfg;
				   TfF = Tf5 + Tfg;
				   Tfp = ( (((__int64)KP707106781) * ((__int64)(Tfn - Tfo)))>>(25) );
				   Tfq = Tfm - Tfp;
				   TfG = Tfm + Tfp;
				   Tfr = ((( (((__int64)KP195090322) * ((__int64)Tfh))>>(25) )) - ( (((__int64)KP980785280) * ((__int64)Tfq))>>(25) ));
				   TfL = ( ( (((__int64)KP831469612) * ((__int64)TfG))>>(25) ) + (( (((__int64)KP555570233) * ((__int64)TfF))>>(25) )));
				   Tfv = ( ( (((__int64)KP195090322) * ((__int64)Tfq))>>(25) ) + (( (((__int64)KP980785280) * ((__int64)Tfh))>>(25) )));
				   TfH = ((( (((__int64)KP831469612) * ((__int64)TfF))>>(25) )) - ( (((__int64)KP555570233) * ((__int64)TfG))>>(25) ));
			      }
			      {
				   E TeQ, TfC, TeZ, TfD, TeP, TeY;
				   TeP = ( (((__int64)KP707106781) * ((__int64)(TeJ - TeO)))>>(25) );
				   TeQ = TeE - TeP;
				   TfC = TeE + TeP;
				   TeY = ( (((__int64)KP707106781) * ((__int64)(TeW - TeX)))>>(25) );
				   TeZ = TeV - TeY;
				   TfD = TeV + TeY;
				   Tf0 = ( ( (((__int64)KP980785280) * ((__int64)TeQ))>>(25) ) + (( (((__int64)KP195090322) * ((__int64)TeZ))>>(25) )));
				   TfK = ((( (((__int64)KP831469612) * ((__int64)TfC))>>(25) )) - ( (((__int64)KP555570233) * ((__int64)TfD))>>(25) ));
				   Tfu = ((( (((__int64)KP195090322) * ((__int64)TeQ))>>(25) )) - ( (((__int64)KP980785280) * ((__int64)TeZ))>>(25) ));
				   TfE = ( ( (((__int64)KP555570233) * ((__int64)TfC))>>(25) ) + (( (((__int64)KP831469612) * ((__int64)TfD))>>(25) )));
			      }
			 }
			 {
			      E Tez, Tfs, TiR, TiU;
			      Tez = Teb + Tey;
			      Tfs = Tf0 + Tfr;
			      ri[(rs * 46)] = ( Tez - Tfs >> (6) );
			      ri[(rs * 14)] = ( Tez + Tfs >> (6) );
			      TiR = Tfu + Tfv;
			      TiU = TiS + TiT;
			      ii[(rs * 14)] = ( TiR + TiU >> (6) );
			      ii[(rs * 46)] = ( TiU - TiR >> (6) );
			 }
			 {
			      E Tft, Tfw, TiV, TiW;
			      Tft = Teb - Tey;
			      Tfw = Tfu - Tfv;
			      ri[(rs * 62)] = ( Tft - Tfw >> (6) );
			      ri[(rs * 30)] = ( Tft + Tfw >> (6) );
			      TiV = Tfr - Tf0;
			      TiW = TiT - TiS;
			      ii[(rs * 30)] = ( TiV + TiW >> (6) );
			      ii[(rs * 62)] = ( TiW - TiV >> (6) );
			 }
			 {
			      E TfB, TfI, TiJ, TiO;
			      TfB = Tfx + TfA;
			      TfI = TfE + TfH;
			      ri[(rs * 38)] = ( TfB - TfI >> (6) );
			      ri[(rs * 6)] = ( TfB + TfI >> (6) );
			      TiJ = TfK + TfL;
			      TiO = TiK + TiN;
			      ii[(rs * 6)] = ( TiJ + TiO >> (6) );
			      ii[(rs * 38)] = ( TiO - TiJ >> (6) );
			 }
			 {
			      E TfJ, TfM, TiP, TiQ;
			      TfJ = Tfx - TfA;
			      TfM = TfK - TfL;
			      ri[(rs * 54)] = ( TfJ - TfM >> (6) );
			      ri[(rs * 22)] = ( TfJ + TfM >> (6) );
			      TiP = TfH - TfE;
			      TiQ = TiN - TiK;
			      ii[(rs * 22)] = ( TiP + TiQ >> (6) );
			      ii[(rs * 54)] = ( TiQ - TiP >> (6) );
			 }
		    }
		    {
			 E TfR, Tgj, TfY, Tiu, Tiz, TiF, Tgm, TiE, Tgd, Tgx, Tgh, Tgt, Tg6, Tgw, Tgg;
			 E Tgq;
			 {
			      E TfN, TfQ, Tgk, Tgl;
			      TfN = TdV + TdY;
			      TfQ = ( (((__int64)KP707106781) * ((__int64)(TfO + TfP)))>>(25) );
			      TfR = TfN - TfQ;
			      Tgj = TfN + TfQ;
			      {
				   E TfU, TfX, Tiv, Tiy;
				   TfU = ((( (((__int64)KP923879532) * ((__int64)TfS))>>(25) )) - ( (((__int64)KP382683432) * ((__int64)TfT))>>(25) ));
				   TfX = ( ( (((__int64)KP923879532) * ((__int64)TfV))>>(25) ) + (( (((__int64)KP382683432) * ((__int64)TfW))>>(25) )));
				   TfY = TfU - TfX;
				   Tiu = TfU + TfX;
				   Tiv = ( (((__int64)KP707106781) * ((__int64)(Te4 + Te9)))>>(25) );
				   Tiy = Tiw + Tix;
				   Tiz = Tiv + Tiy;
				   TiF = Tiy - Tiv;
			      }
			      Tgk = ( ( (((__int64)KP382683432) * ((__int64)TfS))>>(25) ) + (( (((__int64)KP923879532) * ((__int64)TfT))>>(25) )));
			      Tgl = ((( (((__int64)KP923879532) * ((__int64)TfW))>>(25) )) - ( (((__int64)KP382683432) * ((__int64)TfV))>>(25) ));
			      Tgm = Tgk + Tgl;
			      TiE = Tgl - Tgk;
			      {
				   E Tg9, Tgr, Tgc, Tgs, Tg8, Tgb;
				   Tg8 = ( (((__int64)KP707106781) * ((__int64)(Tfo + Tfn)))>>(25) );
				   Tg9 = Tg7 - Tg8;
				   Tgr = Tg7 + Tg8;
				   Tgb = ( (((__int64)KP707106781) * ((__int64)(Tfa + Tff)))>>(25) );
				   Tgc = Tga - Tgb;
				   Tgs = Tga + Tgb;
				   Tgd = ((( (((__int64)KP555570233) * ((__int64)Tg9))>>(25) )) - ( (((__int64)KP831469612) * ((__int64)Tgc))>>(25) ));
				   Tgx = ( ( (((__int64)KP195090322) * ((__int64)Tgr))>>(25) ) + (( (((__int64)KP980785280) * ((__int64)Tgs))>>(25) )));
				   Tgh = ( ( (((__int64)KP831469612) * ((__int64)Tg9))>>(25) ) + (( (((__int64)KP555570233) * ((__int64)Tgc))>>(25) )));
				   Tgt = ((( (((__int64)KP980785280) * ((__int64)Tgr))>>(25) )) - ( (((__int64)KP195090322) * ((__int64)Tgs))>>(25) ));
			      }
			      {
				   E Tg2, Tgo, Tg5, Tgp, Tg1, Tg4;
				   Tg1 = ( (((__int64)KP707106781) * ((__int64)(TeO + TeJ)))>>(25) );
				   Tg2 = Tg0 - Tg1;
				   Tgo = Tg0 + Tg1;
				   Tg4 = ( (((__int64)KP707106781) * ((__int64)(TeW + TeX)))>>(25) );
				   Tg5 = Tg3 - Tg4;
				   Tgp = Tg3 + Tg4;
				   Tg6 = ( ( (((__int64)KP555570233) * ((__int64)Tg2))>>(25) ) + (( (((__int64)KP831469612) * ((__int64)Tg5))>>(25) )));
				   Tgw = ((( (((__int64)KP980785280) * ((__int64)Tgp))>>(25) )) - ( (((__int64)KP195090322) * ((__int64)Tgo))>>(25) ));
				   Tgg = ((( (((__int64)KP555570233) * ((__int64)Tg5))>>(25) )) - ( (((__int64)KP831469612) * ((__int64)Tg2))>>(25) ));
				   Tgq = ( ( (((__int64)KP980785280) * ((__int64)Tgo))>>(25) ) + (( (((__int64)KP195090322) * ((__int64)Tgp))>>(25) )));
			      }
			 }
			 {
			      E TfZ, Tge, TiD, TiG;
			      TfZ = TfR + TfY;
			      Tge = Tg6 + Tgd;
			      ri[(rs * 42)] = ( TfZ - Tge >> (6) );
			      ri[(rs * 10)] = ( TfZ + Tge >> (6) );
			      TiD = Tgg + Tgh;
			      TiG = TiE + TiF;
			      ii[(rs * 10)] = ( TiD + TiG >> (6) );
			      ii[(rs * 42)] = ( TiG - TiD >> (6) );
			 }
			 {
			      E Tgf, Tgi, TiH, TiI;
			      Tgf = TfR - TfY;
			      Tgi = Tgg - Tgh;
			      ri[(rs * 58)] = ( Tgf - Tgi >> (6) );
			      ri[(rs * 26)] = ( Tgf + Tgi >> (6) );
			      TiH = Tgd - Tg6;
			      TiI = TiF - TiE;
			      ii[(rs * 26)] = ( TiH + TiI >> (6) );
			      ii[(rs * 58)] = ( TiI - TiH >> (6) );
			 }
			 {
			      E Tgn, Tgu, Tit, TiA;
			      Tgn = Tgj + Tgm;
			      Tgu = Tgq + Tgt;
			      ri[(rs * 34)] = ( Tgn - Tgu >> (6) );
			      ri[(rs * 2)] = ( Tgn + Tgu >> (6) );
			      Tit = Tgw + Tgx;
			      TiA = Tiu + Tiz;
			      ii[(rs * 2)] = ( Tit + TiA >> (6) );
			      ii[(rs * 34)] = ( TiA - Tit >> (6) );
			 }
			 {
			      E Tgv, Tgy, TiB, TiC;
			      Tgv = Tgj - Tgm;
			      Tgy = Tgw - Tgx;
			      ri[(rs * 50)] = ( Tgv - Tgy >> (6) );
			      ri[(rs * 18)] = ( Tgv + Tgy >> (6) );
			      TiB = Tgt - Tgq;
			      TiC = Tiz - Tiu;
			      ii[(rs * 18)] = ( TiB + TiC >> (6) );
			      ii[(rs * 50)] = ( TiC - TiB >> (6) );
			 }
		    }
		    {
			 E T7V, TaH, TjN, TjT, T8O, TjS, TaK, TjK, T9I, TaU, TaE, TaO, TaB, TaV, TaF;
			 E TaR;
			 {
			      E T7x, T7U, TjL, TjM;
			      T7x = T7l - T7w;
			      T7U = T7I - T7T;
			      T7V = T7x - T7U;
			      TaH = T7x + T7U;
			      TjL = TaZ - TaY;
			      TjM = Tjx - Tjw;
			      TjN = TjL + TjM;
			      TjT = TjM - TjL;
			 }
			 {
			      E T8m, TaI, T8N, TaJ;
			      {
				   E T8c, T8l, T8D, T8M;
				   T8c = T80 - T8b;
				   T8l = T8h - T8k;
				   T8m = ((( (((__int64)KP195090322) * ((__int64)T8c))>>(25) )) - ( (((__int64)KP980785280) * ((__int64)T8l))>>(25) ));
				   TaI = ( ( (((__int64)KP980785280) * ((__int64)T8c))>>(25) ) + (( (((__int64)KP195090322) * ((__int64)T8l))>>(25) )));
				   T8D = T8r - T8C;
				   T8M = T8I - T8L;
				   T8N = ( ( (((__int64)KP195090322) * ((__int64)T8D))>>(25) ) + (( (((__int64)KP980785280) * ((__int64)T8M))>>(25) )));
				   TaJ = ((( (((__int64)KP195090322) * ((__int64)T8M))>>(25) )) - ( (((__int64)KP980785280) * ((__int64)T8D))>>(25) ));
			      }
			      T8O = T8m - T8N;
			      TjS = TaJ - TaI;
			      TaK = TaI + TaJ;
			      TjK = T8m + T8N;
			 }
			 {
			      E T9u, TaM, T9H, TaN;
			      {
				   E T96, T9t, T9D, T9G;
				   T96 = T8U - T95;
				   T9t = T9h - T9s;
				   T9u = T96 - T9t;
				   TaM = T96 + T9t;
				   T9D = T9z - T9C;
				   T9G = T9E - T9F;
				   T9H = T9D - T9G;
				   TaN = T9D + T9G;
			      }
			      T9I = ( ( (((__int64)KP995184726) * ((__int64)T9u))>>(25) ) + (( (((__int64)KP098017140) * ((__int64)T9H))>>(25) )));
			      TaU = ((( (((__int64)KP773010453) * ((__int64)TaM))>>(25) )) - ( (((__int64)KP634393284) * ((__int64)TaN))>>(25) ));
			      TaE = ((( (((__int64)KP098017140) * ((__int64)T9u))>>(25) )) - ( (((__int64)KP995184726) * ((__int64)T9H))>>(25) ));
			      TaO = ( ( (((__int64)KP634393284) * ((__int64)TaM))>>(25) ) + (( (((__int64)KP773010453) * ((__int64)TaN))>>(25) )));
			 }
			 {
			      E Tan, TaP, TaA, TaQ;
			      {
				   E T9Z, Tam, Taw, Taz;
				   T9Z = T9N - T9Y;
				   Tam = Taa - Tal;
				   Tan = T9Z - Tam;
				   TaP = T9Z + Tam;
				   Taw = Tas - Tav;
				   Taz = Tax - Tay;
				   TaA = Taw - Taz;
				   TaQ = Taw + Taz;
			      }
			      TaB = ((( (((__int64)KP098017140) * ((__int64)Tan))>>(25) )) - ( (((__int64)KP995184726) * ((__int64)TaA))>>(25) ));
			      TaV = ( ( (((__int64)KP773010453) * ((__int64)TaQ))>>(25) ) + (( (((__int64)KP634393284) * ((__int64)TaP))>>(25) )));
			      TaF = ( ( (((__int64)KP098017140) * ((__int64)TaA))>>(25) ) + (( (((__int64)KP995184726) * ((__int64)Tan))>>(25) )));
			      TaR = ((( (((__int64)KP773010453) * ((__int64)TaP))>>(25) )) - ( (((__int64)KP634393284) * ((__int64)TaQ))>>(25) ));
			 }
			 {
			      E T8P, TaC, TjR, TjU;
			      T8P = T7V + T8O;
			      TaC = T9I + TaB;
			      ri[(rs * 47)] = ( T8P - TaC >> (6) );
			      ri[(rs * 15)] = ( T8P + TaC >> (6) );
			      TjR = TaE + TaF;
			      TjU = TjS + TjT;
			      ii[(rs * 15)] = ( TjR + TjU >> (6) );
			      ii[(rs * 47)] = ( TjU - TjR >> (6) );
			 }
			 {
			      E TaD, TaG, TjV, TjW;
			      TaD = T7V - T8O;
			      TaG = TaE - TaF;
			      ri[(rs * 63)] = ( TaD - TaG >> (6) );
			      ri[(rs * 31)] = ( TaD + TaG >> (6) );
			      TjV = TaB - T9I;
			      TjW = TjT - TjS;
			      ii[(rs * 31)] = ( TjV + TjW >> (6) );
			      ii[(rs * 63)] = ( TjW - TjV >> (6) );
			 }
			 {
			      E TaL, TaS, TjJ, TjO;
			      TaL = TaH + TaK;
			      TaS = TaO + TaR;
			      ri[(rs * 39)] = ( TaL - TaS >> (6) );
			      ri[(rs * 7)] = ( TaL + TaS >> (6) );
			      TjJ = TaU + TaV;
			      TjO = TjK + TjN;
			      ii[(rs * 7)] = ( TjJ + TjO >> (6) );
			      ii[(rs * 39)] = ( TjO - TjJ >> (6) );
			 }
			 {
			      E TaT, TaW, TjP, TjQ;
			      TaT = TaH - TaK;
			      TaW = TaU - TaV;
			      ri[(rs * 55)] = ( TaT - TaW >> (6) );
			      ri[(rs * 23)] = ( TaT + TaW >> (6) );
			      TjP = TaR - TaO;
			      TjQ = TjN - TjK;
			      ii[(rs * 23)] = ( TjP + TjQ >> (6) );
			      ii[(rs * 55)] = ( TjQ - TjP >> (6) );
			 }
		    }
		    {
			 E TbV, TcT, Tjj, Tjp, Tca, Tjo, TcW, Tjg, Tcu, Td6, TcQ, Td0, TcN, Td7, TcR;
			 E Td3;
			 {
			      E TbN, TbU, Tjh, Tji;
			      TbN = TbJ - TbM;
			      TbU = TbQ - TbT;
			      TbV = TbN - TbU;
			      TcT = TbN + TbU;
			      Tjh = Tdb - Tda;
			      Tji = Tj3 - Tj0;
			      Tjj = Tjh + Tji;
			      Tjp = Tji - Tjh;
			 }
			 {
			      E Tc2, TcU, Tc9, TcV;
			      {
				   E TbY, Tc1, Tc5, Tc8;
				   TbY = TbW - TbX;
				   Tc1 = TbZ - Tc0;
				   Tc2 = ((( (((__int64)KP555570233) * ((__int64)TbY))>>(25) )) - ( (((__int64)KP831469612) * ((__int64)Tc1))>>(25) ));
				   TcU = ( ( (((__int64)KP555570233) * ((__int64)Tc1))>>(25) ) + (( (((__int64)KP831469612) * ((__int64)TbY))>>(25) )));
				   Tc5 = Tc3 - Tc4;
				   Tc8 = Tc6 - Tc7;
				   Tc9 = ( ( (((__int64)KP831469612) * ((__int64)Tc5))>>(25) ) + (( (((__int64)KP555570233) * ((__int64)Tc8))>>(25) )));
				   TcV = ((( (((__int64)KP555570233) * ((__int64)Tc5))>>(25) )) - ( (((__int64)KP831469612) * ((__int64)Tc8))>>(25) ));
			      }
			      Tca = Tc2 - Tc9;
			      Tjo = TcV - TcU;
			      TcW = TcU + TcV;
			      Tjg = Tc2 + Tc9;
			 }
			 {
			      E Tcm, TcY, Tct, TcZ;
			      {
				   E Tce, Tcl, Tcp, Tcs;
				   Tce = Tcc - Tcd;
				   Tcl = Tch - Tck;
				   Tcm = Tce - Tcl;
				   TcY = Tce + Tcl;
				   Tcp = Tcn - Tco;
				   Tcs = Tcq - Tcr;
				   Tct = Tcp - Tcs;
				   TcZ = Tcp + Tcs;
			      }
			      Tcu = ( ( (((__int64)KP956940335) * ((__int64)Tcm))>>(25) ) + (( (((__int64)KP290284677) * ((__int64)Tct))>>(25) )));
			      Td6 = ((( (((__int64)KP881921264) * ((__int64)TcY))>>(25) )) - ( (((__int64)KP471396736) * ((__int64)TcZ))>>(25) ));
			      TcQ = ((( (((__int64)KP290284677) * ((__int64)Tcm))>>(25) )) - ( (((__int64)KP956940335) * ((__int64)Tct))>>(25) ));
			      Td0 = ( ( (((__int64)KP471396736) * ((__int64)TcY))>>(25) ) + (( (((__int64)KP881921264) * ((__int64)TcZ))>>(25) )));
			 }
			 {
			      E TcF, Td1, TcM, Td2;
			      {
				   E Tcx, TcE, TcI, TcL;
				   Tcx = Tcv - Tcw;
				   TcE = TcA - TcD;
				   TcF = Tcx - TcE;
				   Td1 = Tcx + TcE;
				   TcI = TcG - TcH;
				   TcL = TcJ - TcK;
				   TcM = TcI - TcL;
				   Td2 = TcI + TcL;
			      }
			      TcN = ((( (((__int64)KP290284677) * ((__int64)TcF))>>(25) )) - ( (((__int64)KP956940335) * ((__int64)TcM))>>(25) ));
			      Td7 = ( ( (((__int64)KP881921264) * ((__int64)Td2))>>(25) ) + (( (((__int64)KP471396736) * ((__int64)Td1))>>(25) )));
			      TcR = ( ( (((__int64)KP290284677) * ((__int64)TcM))>>(25) ) + (( (((__int64)KP956940335) * ((__int64)TcF))>>(25) )));
			      Td3 = ((( (((__int64)KP881921264) * ((__int64)Td1))>>(25) )) - ( (((__int64)KP471396736) * ((__int64)Td2))>>(25) ));
			 }
			 {
			      E Tcb, TcO, Tjn, Tjq;
			      Tcb = TbV + Tca;
			      TcO = Tcu + TcN;
			      ri[(rs * 45)] = ( Tcb - TcO >> (6) );
			      ri[(rs * 13)] = ( Tcb + TcO >> (6) );
			      Tjn = TcQ + TcR;
			      Tjq = Tjo + Tjp;
			      ii[(rs * 13)] = ( Tjn + Tjq >> (6) );
			      ii[(rs * 45)] = ( Tjq - Tjn >> (6) );
			 }
			 {
			      E TcP, TcS, Tjr, Tjs;
			      TcP = TbV - Tca;
			      TcS = TcQ - TcR;
			      ri[(rs * 61)] = ( TcP - TcS >> (6) );
			      ri[(rs * 29)] = ( TcP + TcS >> (6) );
			      Tjr = TcN - Tcu;
			      Tjs = Tjp - Tjo;
			      ii[(rs * 29)] = ( Tjr + Tjs >> (6) );
			      ii[(rs * 61)] = ( Tjs - Tjr >> (6) );
			 }
			 {
			      E TcX, Td4, Tjf, Tjk;
			      TcX = TcT + TcW;
			      Td4 = Td0 + Td3;
			      ri[(rs * 37)] = ( TcX - Td4 >> (6) );
			      ri[(rs * 5)] = ( TcX + Td4 >> (6) );
			      Tjf = Td6 + Td7;
			      Tjk = Tjg + Tjj;
			      ii[(rs * 5)] = ( Tjf + Tjk >> (6) );
			      ii[(rs * 37)] = ( Tjk - Tjf >> (6) );
			 }
			 {
			      E Td5, Td8, Tjl, Tjm;
			      Td5 = TcT - TcW;
			      Td8 = Td6 - Td7;
			      ri[(rs * 53)] = ( Td5 - Td8 >> (6) );
			      ri[(rs * 21)] = ( Td5 + Td8 >> (6) );
			      Tjl = Td3 - Td0;
			      Tjm = Tjj - Tjg;
			      ii[(rs * 21)] = ( Tjl + Tjm >> (6) );
			      ii[(rs * 53)] = ( Tjm - Tjl >> (6) );
			 }
		    }
		    {
			 E Tdd, TdF, Tj5, Tjb, Tdk, Tja, TdI, TiY, Tds, TdS, TdC, TdM, Tdz, TdT, TdD;
			 E TdP;
			 {
			      E Td9, Tdc, TiZ, Tj4;
			      Td9 = TbJ + TbM;
			      Tdc = Tda + Tdb;
			      Tdd = Td9 - Tdc;
			      TdF = Td9 + Tdc;
			      TiZ = TbQ + TbT;
			      Tj4 = Tj0 + Tj3;
			      Tj5 = TiZ + Tj4;
			      Tjb = Tj4 - TiZ;
			 }
			 {
			      E Tdg, TdG, Tdj, TdH;
			      {
				   E Tde, Tdf, Tdh, Tdi;
				   Tde = TbW + TbX;
				   Tdf = TbZ + Tc0;
				   Tdg = ((( (((__int64)KP980785280) * ((__int64)Tde))>>(25) )) - ( (((__int64)KP195090322) * ((__int64)Tdf))>>(25) ));
				   TdG = ( ( (((__int64)KP980785280) * ((__int64)Tdf))>>(25) ) + (( (((__int64)KP195090322) * ((__int64)Tde))>>(25) )));
				   Tdh = Tc3 + Tc4;
				   Tdi = Tc6 + Tc7;
				   Tdj = ( ( (((__int64)KP195090322) * ((__int64)Tdh))>>(25) ) + (( (((__int64)KP980785280) * ((__int64)Tdi))>>(25) )));
				   TdH = ((( (((__int64)KP980785280) * ((__int64)Tdh))>>(25) )) - ( (((__int64)KP195090322) * ((__int64)Tdi))>>(25) ));
			      }
			      Tdk = Tdg - Tdj;
			      Tja = TdH - TdG;
			      TdI = TdG + TdH;
			      TiY = Tdg + Tdj;
			 }
			 {
			      E Tdo, TdK, Tdr, TdL;
			      {
				   E Tdm, Tdn, Tdp, Tdq;
				   Tdm = Tcn + Tco;
				   Tdn = Tck + Tch;
				   Tdo = Tdm - Tdn;
				   TdK = Tdm + Tdn;
				   Tdp = Tcc + Tcd;
				   Tdq = Tcq + Tcr;
				   Tdr = Tdp - Tdq;
				   TdL = Tdp + Tdq;
			      }
			      Tds = ( ( (((__int64)KP634393284) * ((__int64)Tdo))>>(25) ) + (( (((__int64)KP773010453) * ((__int64)Tdr))>>(25) )));
			      TdS = ((( (((__int64)KP995184726) * ((__int64)TdL))>>(25) )) - ( (((__int64)KP098017140) * ((__int64)TdK))>>(25) ));
			      TdC = ((( (((__int64)KP634393284) * ((__int64)Tdr))>>(25) )) - ( (((__int64)KP773010453) * ((__int64)Tdo))>>(25) ));
			      TdM = ( ( (((__int64)KP995184726) * ((__int64)TdK))>>(25) ) + (( (((__int64)KP098017140) * ((__int64)TdL))>>(25) )));
			 }
			 {
			      E Tdv, TdN, Tdy, TdO;
			      {
				   E Tdt, Tdu, Tdw, Tdx;
				   Tdt = Tcv + Tcw;
				   Tdu = TcK + TcJ;
				   Tdv = Tdt - Tdu;
				   TdN = Tdt + Tdu;
				   Tdw = TcG + TcH;
				   Tdx = TcA + TcD;
				   Tdy = Tdw - Tdx;
				   TdO = Tdw + Tdx;
			      }
			      Tdz = ((( (((__int64)KP634393284) * ((__int64)Tdv))>>(25) )) - ( (((__int64)KP773010453) * ((__int64)Tdy))>>(25) ));
			      TdT = ( ( (((__int64)KP098017140) * ((__int64)TdN))>>(25) ) + (( (((__int64)KP995184726) * ((__int64)TdO))>>(25) )));
			      TdD = ( ( (((__int64)KP773010453) * ((__int64)Tdv))>>(25) ) + (( (((__int64)KP634393284) * ((__int64)Tdy))>>(25) )));
			      TdP = ((( (((__int64)KP995184726) * ((__int64)TdN))>>(25) )) - ( (((__int64)KP098017140) * ((__int64)TdO))>>(25) ));
			 }
			 {
			      E Tdl, TdA, Tj9, Tjc;
			      Tdl = Tdd + Tdk;
			      TdA = Tds + Tdz;
			      ri[(rs * 41)] = ( Tdl - TdA >> (6) );
			      ri[(rs * 9)] = ( Tdl + TdA >> (6) );
			      Tj9 = TdC + TdD;
			      Tjc = Tja + Tjb;
			      ii[(rs * 9)] = ( Tj9 + Tjc >> (6) );
			      ii[(rs * 41)] = ( Tjc - Tj9 >> (6) );
			 }
			 {
			      E TdB, TdE, Tjd, Tje;
			      TdB = Tdd - Tdk;
			      TdE = TdC - TdD;
			      ri[(rs * 57)] = ( TdB - TdE >> (6) );
			      ri[(rs * 25)] = ( TdB + TdE >> (6) );
			      Tjd = Tdz - Tds;
			      Tje = Tjb - Tja;
			      ii[(rs * 25)] = ( Tjd + Tje >> (6) );
			      ii[(rs * 57)] = ( Tje - Tjd >> (6) );
			 }
			 {
			      E TdJ, TdQ, TiX, Tj6;
			      TdJ = TdF + TdI;
			      TdQ = TdM + TdP;
			      ri[(rs * 33)] = ( TdJ - TdQ >> (6) );
			      ri[(rs * 1)] = ( TdJ + TdQ >> (6) );
			      TiX = TdS + TdT;
			      Tj6 = TiY + Tj5;
			      ii[(rs * 1)] = ( TiX + Tj6 >> (6) );
			      ii[(rs * 33)] = ( Tj6 - TiX >> (6) );
			 }
			 {
			      E TdR, TdU, Tj7, Tj8;
			      TdR = TdF - TdI;
			      TdU = TdS - TdT;
			      ri[(rs * 49)] = ( TdR - TdU >> (6) );
			      ri[(rs * 17)] = ( TdR + TdU >> (6) );
			      Tj7 = TdP - TdM;
			      Tj8 = Tj5 - TiY;
			      ii[(rs * 17)] = ( Tj7 + Tj8 >> (6) );
			      ii[(rs * 49)] = ( Tj8 - Tj7 >> (6) );
			 }
		    }
		    {
			 E Tb1, Tbt, Tjz, TjF, Tb8, TjE, Tbw, Tju, Tbg, TbG, Tbq, TbA, Tbn, TbH, Tbr;
			 E TbD;
			 {
			      E TaX, Tb0, Tjv, Tjy;
			      TaX = T7l + T7w;
			      Tb0 = TaY + TaZ;
			      Tb1 = TaX - Tb0;
			      Tbt = TaX + Tb0;
			      Tjv = T7I + T7T;
			      Tjy = Tjw + Tjx;
			      Tjz = Tjv + Tjy;
			      TjF = Tjy - Tjv;
			 }
			 {
			      E Tb4, Tbu, Tb7, Tbv;
			      {
				   E Tb2, Tb3, Tb5, Tb6;
				   Tb2 = T80 + T8b;
				   Tb3 = T8h + T8k;
				   Tb4 = ((( (((__int64)KP831469612) * ((__int64)Tb2))>>(25) )) - ( (((__int64)KP555570233) * ((__int64)Tb3))>>(25) ));
				   Tbu = ( ( (((__int64)KP555570233) * ((__int64)Tb2))>>(25) ) + (( (((__int64)KP831469612) * ((__int64)Tb3))>>(25) )));
				   Tb5 = T8r + T8C;
				   Tb6 = T8I + T8L;
				   Tb7 = ( ( (((__int64)KP831469612) * ((__int64)Tb5))>>(25) ) + (( (((__int64)KP555570233) * ((__int64)Tb6))>>(25) )));
				   Tbv = ((( (((__int64)KP831469612) * ((__int64)Tb6))>>(25) )) - ( (((__int64)KP555570233) * ((__int64)Tb5))>>(25) ));
			      }
			      Tb8 = Tb4 - Tb7;
			      TjE = Tbv - Tbu;
			      Tbw = Tbu + Tbv;
			      Tju = Tb4 + Tb7;
			 }
			 {
			      E Tbc, Tby, Tbf, Tbz;
			      {
				   E Tba, Tbb, Tbd, Tbe;
				   Tba = T9z + T9C;
				   Tbb = T9s + T9h;
				   Tbc = Tba - Tbb;
				   Tby = Tba + Tbb;
				   Tbd = T8U + T95;
				   Tbe = T9E + T9F;
				   Tbf = Tbd - Tbe;
				   Tbz = Tbd + Tbe;
			      }
			      Tbg = ( ( (((__int64)KP471396736) * ((__int64)Tbc))>>(25) ) + (( (((__int64)KP881921264) * ((__int64)Tbf))>>(25) )));
			      TbG = ((( (((__int64)KP956940335) * ((__int64)Tbz))>>(25) )) - ( (((__int64)KP290284677) * ((__int64)Tby))>>(25) ));
			      Tbq = ((( (((__int64)KP471396736) * ((__int64)Tbf))>>(25) )) - ( (((__int64)KP881921264) * ((__int64)Tbc))>>(25) ));
			      TbA = ( ( (((__int64)KP956940335) * ((__int64)Tby))>>(25) ) + (( (((__int64)KP290284677) * ((__int64)Tbz))>>(25) )));
			 }
			 {
			      E Tbj, TbB, Tbm, TbC;
			      {
				   E Tbh, Tbi, Tbk, Tbl;
				   Tbh = T9N + T9Y;
				   Tbi = Tay + Tax;
				   Tbj = Tbh - Tbi;
				   TbB = Tbh + Tbi;
				   Tbk = Tas + Tav;
				   Tbl = Taa + Tal;
				   Tbm = Tbk - Tbl;
				   TbC = Tbk + Tbl;
			      }
			      Tbn = ((( (((__int64)KP471396736) * ((__int64)Tbj))>>(25) )) - ( (((__int64)KP881921264) * ((__int64)Tbm))>>(25) ));
			      TbH = ( ( (((__int64)KP290284677) * ((__int64)TbB))>>(25) ) + (( (((__int64)KP956940335) * ((__int64)TbC))>>(25) )));
			      Tbr = ( ( (((__int64)KP881921264) * ((__int64)Tbj))>>(25) ) + (( (((__int64)KP471396736) * ((__int64)Tbm))>>(25) )));
			      TbD = ((( (((__int64)KP956940335) * ((__int64)TbB))>>(25) )) - ( (((__int64)KP290284677) * ((__int64)TbC))>>(25) ));
			 }
			 {
			      E Tb9, Tbo, TjD, TjG;
			      Tb9 = Tb1 + Tb8;
			      Tbo = Tbg + Tbn;
			      ri[(rs * 43)] = ( Tb9 - Tbo >> (6) );
			      ri[(rs * 11)] = ( Tb9 + Tbo >> (6) );
			      TjD = Tbq + Tbr;
			      TjG = TjE + TjF;
			      ii[(rs * 11)] = ( TjD + TjG >> (6) );
			      ii[(rs * 43)] = ( TjG - TjD >> (6) );
			 }
			 {
			      E Tbp, Tbs, TjH, TjI;
			      Tbp = Tb1 - Tb8;
			      Tbs = Tbq - Tbr;
			      ri[(rs * 59)] = ( Tbp - Tbs >> (6) );
			      ri[(rs * 27)] = ( Tbp + Tbs >> (6) );
			      TjH = Tbn - Tbg;
			      TjI = TjF - TjE;
			      ii[(rs * 27)] = ( TjH + TjI >> (6) );
			      ii[(rs * 59)] = ( TjI - TjH >> (6) );
			 }
			 {
			      E Tbx, TbE, Tjt, TjA;
			      Tbx = Tbt + Tbw;
			      TbE = TbA + TbD;
			      ri[(rs * 35)] = ( Tbx - TbE >> (6) );
			      ri[(rs * 3)] = ( Tbx + TbE >> (6) );
			      Tjt = TbG + TbH;
			      TjA = Tju + Tjz;
			      ii[(rs * 3)] = ( Tjt + TjA >> (6) );
			      ii[(rs * 35)] = ( TjA - Tjt >> (6) );
			 }
			 {
			      E TbF, TbI, TjB, TjC;
			      TbF = Tbt - Tbw;
			      TbI = TbG - TbH;
			      ri[(rs * 51)] = ( TbF - TbI >> (6) );
			      ri[(rs * 19)] = ( TbF + TbI >> (6) );
			      TjB = TbD - TbA;
			      TjC = Tjz - Tju;
			      ii[(rs * 19)] = ( TjB + TjC >> (6) );
			      ii[(rs * 51)] = ( TjC - TjB >> (6) );
			 }
		    }
	       }
	  }
     }
}

static const tw_instr twinstr[] = {
     {TW_CEXP, 0, 1},
     {TW_CEXP, 0, 3},
     {TW_CEXP, 0, 9},
     {TW_CEXP, 0, 27},
     {TW_CEXP, 0, 63},
     {TW_NEXT, 1, 0}
};

static const ct_desc desc = { 64, "t2_64", twinstr, &fftwi_dft_t_genus, {880, 386, 274, 0}, 0, 0, 0 };

void fftwi_codelet_t2_64 (planner *p) {
     fftwi_kdft_dit_register (p, t2_64, &desc);
}
