[jhc] compilation error of my example raytracer program

John Meacham john at repetae.net
Thu Mar 26 19:55:02 EDT 2009


Hi, I have patched jhc so your example will run, if you don't want to
recompile jhc, I have attached the generated C file. simply compile it
with

gcc -m32 '-std=gnu99' -D_GNU_SOURCE '-falign-functions=4' -ffast-math -DNDEBUG -O3 -fomit-frame-pointer -o hruska_ray hruska_ray_code.c

or you can use the recomp.prl script that comes with jhc in the utils
directory to recompile C code generated by jhc with different options.

        John


-- 
John Meacham - ⑆repetae.net⑆john⑈
-------------- next part --------------
char jhc_c_compile[] = "gcc '-std=gnu99' -D_GNU_SOURCE '-falign-functions=4' -ffast-math -Wshadow -Wextra -Wall -Wno-unused-parameter -o hruska_ray hruska_ray_code.c -DNDEBUG -O3 -fomit-frame-pointer";
char jhc_command[] = "jhc --ho-dir /home/john/prog/hs/jhc/jhc/regress/results/ho -v --noauto -v hruska_ray.hs -o hruska_ray -fno-monomorphism-restriction -dgrin-final --stale Main";
char jhc_version[] = "jhc 0.6.0 (0.6.0-3)";

/* HsFFI.h for jhc */

#ifndef _JHC_HSFFI_H
#define _JHC_HSFFI_H

#include <inttypes.h>


typedef int32_t HsInt;
typedef int8_t  HsInt8;
typedef int16_t HsInt16;
typedef int32_t HsInt32;
typedef int64_t HsInt64;

typedef uint32_t HsWord;
typedef uint8_t  HsWord8;
typedef uint16_t HsWord16;
typedef uint32_t HsWord32;
typedef uint64_t HsWord64;

typedef uint32_t HsChar;
typedef int HsBool;

typedef double HsDouble;
typedef float HsFloat;

typedef void *HsPtr;
typedef void (*HsFunPtr)(void);
typedef void *HsStablePtr;

#define HS_BOOL_FALSE 0
#define HS_BOOL_TRUE 1

void hs_init (int *argc, char **argv[]);
void hs_exit (void);
void hs_set_argv(int argc, char *argv[]);
void hs_perform_gc(void);
void hs_free_stable_ptr(HsStablePtr sp);
void hs_free_fun_ptr(HsFunPtr fp);

#endif

// jhc_rts_header.h

#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <unistd.h>
#include <wchar.h>
#include <limits.h>
#include <locale.h>
#include <math.h>
#include <sys/select.h>
#include <assert.h>
#include <float.h>
#ifndef __WIN32__
#include <sys/times.h>
#include <endian.h>
#include <sys/utsname.h>
#endif
#include <setjmp.h>


// #define our options

#define _JHC_GC_NONE  0
#define _JHC_JGC      1
#define _JHC_GC_BOEHM 2


#ifndef _JHC_GC
#define _JHC_GC _JHC_GC_NONE
#endif

#ifndef _JHC_PROFILE
#define _JHC_PROFILE 0
#endif

#ifndef _JHC_DEBUG
#ifdef NDEBUG
#define _JHC_DEBUG 0
#else
#define _JHC_DEBUG 1
#endif
#endif


// GNU attributes

#ifdef __GNUC__
#define A_ALIGNED  __attribute__ ((aligned))
#define A_CONST    __attribute__ ((const))
#define A_MALLOC   __attribute__ ((malloc))
#define A_MAYALIAS __attribute__ ((__may_alias__))
#define A_NORETURN __attribute__ ((noreturn))
#define A_PURE     __attribute__ ((pure))
#define A_UNUSED   __attribute__ ((unused))
#ifdef __i386__
#define A_REGPARM __attribute__ ((fastcall))
#else
#define A_REGPARM
#endif
#define A_STD    A_REGPARM

#else
#define A_ALIGNED
#define A_CONST
#define A_MALLOC
#define A_MAYALIAS
#define A_NORETURN
#define A_PURE
#define A_UNUSED
#define A_STD
#endif

// these should be enabled with newer versions of gcc
#define A_HOT
#define A_COLD
#define A_FALIGNED

#define STR(s) #s
#define XSTR(s) STR(s)
#define ALIGN(a,n) ((n) - 1 + ((a) - ((n) - 1) % (a)))


#ifdef __WIN32__
#define JHC_isWindows   1
#define JHC_isBigEndian 0
#else
#define JHC_isWindows 0
#define JHC_isBigEndian (__BYTE_ORDER == __BIG_ENDIAN)
#endif

#define JHC_isPosix (!JHC_isWindows)


// some default definitions

#define jhc_malloc_whnf jhc_malloc
#define jhc_malloc_suspension jhc_malloc
#define jhc_malloc_atomic jhc_malloc
#define jhc_malloc_atomic_whnf jhc_malloc_atomic
#define jhc_malloc_sanity(p,t) (1)

extern void _start,_end;

#if _JHC_PROFILE

#define BUCKETS 7

static unsigned alloced[BUCKETS];
static unsigned alloced_atomic[BUCKETS];

static void
alloc_count(int n,int atomic)
{
        n = n ? ((n - 1)/sizeof(void *)) + 1 : 0;
        n = n > BUCKETS - 1 ? BUCKETS - 1 : n;
        (atomic ? alloced_atomic : alloced)[n]++;
}


static void
print_alloc_size_stats(void) {
        char fmt[] = "%10s %10s %10s %10s %10s\n";
        char fmt2[] = "%10u %10u %10u %10u %10u\n";
        fprintf(stderr,fmt,"Size","Normal","Atomic","Total","Accum");
        fprintf(stderr,fmt,"----","------","------","-----","-----");
        unsigned accum = 0;
        for(int i = 0; i < BUCKETS; i++) {
                accum += alloced[i] + alloced_atomic[i];
                fprintf(stderr,fmt2,i,alloced[i],alloced_atomic[i],alloced_atomic[i] + alloced[i], accum);
        }
}


#else

#define alloc_count(x,y)
#define print_alloc_size_stats()

#endif

#if _JHC_GC == _JHC_GC_BOEHM

#include <gc/gc.h>

#define jhc_malloc GC_malloc
#undef  jhc_malloc_atomic
#define jhc_malloc_atomic GC_malloc_atomic
#define jhc_free GC_free

static inline void jhc_malloc_init(void) { GC_INIT(); }
static inline void jhc_alloc_print_stats(void) { GC_dump(); }

#elif _JHC_GC == _JHC_GC_NONE

// memory allocated in 1MB chunks.
#define JHC_MEM_CHUNK_SIZE (1 << 20)

static char initial_chunk[JHC_MEM_CHUNK_SIZE];

static void *jhc_current_chunk = initial_chunk;
static unsigned mem_chunks,mem_offset;


static inline void
jhc_malloc_init(void) { return; }

static void
jhc_alloc_print_stats(void) {
        fprintf(stderr, "Memory Allocated: %u bytes\n", (JHC_MEM_CHUNK_SIZE*(mem_chunks)) + mem_offset);
        print_alloc_size_stats();
}

static void
jhc_malloc_grow(void) {
        void *c = malloc(JHC_MEM_CHUNK_SIZE);
        if(!c) {
                fputs("Out of memory!\n",stderr);
                abort();
        }
        mem_chunks++;
        jhc_current_chunk = c;
        mem_offset = 0;
}

static inline void * A_MALLOC
jhc_malloc_basic(size_t n) {
        n = ALIGN(sizeof(void *),n);
        if (n > (JHC_MEM_CHUNK_SIZE - mem_offset))
                jhc_malloc_grow();
        void *ret = jhc_current_chunk + mem_offset;
        mem_offset += n;
        return ret;
}


#if _JHC_DEBUG

#define jhc_malloc(n) jhc_malloc_debug(n,__LINE__,0)
#undef jhc_malloc_atomic
#define jhc_malloc_atomic(n) jhc_malloc_debug(n,__LINE__,1)

static void * A_MALLOC
jhc_malloc_debug(size_t n,int line,int atomic) {
        alloc_count(n,atomic);
        void *ret = jhc_malloc_basic(n + sizeof(uintptr_t));
        *((uintptr_t *)ret) = line;
        return ret + sizeof(uintptr_t);
}

#else

static inline void * A_MALLOC
jhc_malloc(size_t n) {
        alloc_count(n,0);
        return jhc_malloc_basic(n);
}

#undef jhc_malloc_atomic
static inline void * A_MALLOC
jhc_malloc_atomic(size_t n) {
        alloc_count(n,1);
        return jhc_malloc_basic(n);
}


#endif

#elif _JHC_GC == _JHC_GC_JGC

#error "jgc not supported yet."

#endif





static void _amain(void);
static void jhc_arch_assert(void);
static int jhc_argc;
static char **jhc_argv;
static char *jhc_progname;
static jmp_buf jhc_uncaught;

static HsInt jhc_stdrnd[2] A_UNUSED = { 1 , 1 };
static HsInt jhc_data_unique A_UNUSED;
#ifdef __WIN32__
static char *jhc_options_os =  "mingw32";
static char *jhc_options_arch = "i386";
#else
struct utsname jhc_utsname;
static char *jhc_options_os = "(unknown os)";
static char *jhc_options_arch = "(unknown arch)";
#endif


#if _JHC_PROFILE

static uintmax_t jhc_prof_function_calls;
static uintmax_t jhc_prof_case_statements;
static uintmax_t jhc_prof_updates;

#define jhc_update_inc()   jhc_prof_updates++
#define jhc_function_inc() jhc_prof_function_calls++
#define jhc_case_inc()     jhc_prof_case_statements++

#else

#define jhc_update_inc()    do { } while(0)
#define jhc_function_inc()  do { } while(0)
#define jhc_case_inc()      do { } while(0)

#endif

static void A_COLD
jhc_print_profile(void) {
#ifndef __WIN32__
        struct tms tm;
        times(&tm);
#endif
        if(!(_JHC_PROFILE || getenv("JHC_RTS_PROFILE"))) return;

        fprintf(stderr, "\n-----------------\n");
        fprintf(stderr, "Profiling: %s\n", jhc_progname);
        fprintf(stderr, "Command: %s\n", jhc_command);
        fprintf(stderr, "Complie: %s\n", jhc_c_compile);
        fprintf(stderr, "Version: %s\n\n", jhc_version);
        jhc_alloc_print_stats();
#ifndef __WIN32__
        float cpt = (float)sysconf(_SC_CLK_TCK);
        fprintf(stderr, "User Time:   %.2fs\n", (float)tm.tms_utime/cpt);
        fprintf(stderr, "System Time: %.2fs\n", (float)tm.tms_stime/cpt);
        fprintf(stderr, "Total Time:  %.2fs\n", (float)(tm.tms_stime + tm.tms_utime)/cpt);
#endif

#if _JHC_PROFILE
        fprintf(stderr, "\nFunction Calls:   %llu\n", (unsigned long long)jhc_prof_function_calls);
        fprintf(stderr, "Case Statements:  %llu\n", (unsigned long long)jhc_prof_case_statements);
        fprintf(stderr, "Updates:          %llu\n", (unsigned long long)jhc_prof_updates);
#endif
        fprintf(stderr, "-----------------\n");
}


static void A_NORETURN A_UNUSED A_COLD
jhc_exit(int n) {
        jhc_print_profile();
        exit(n);
}

static void  A_NORETURN A_UNUSED  A_COLD
jhc_error(char *s) {
        fputs(s,stderr);
        fputs("\n",stderr);
        jhc_print_profile();
        exit(255);
}

static void  A_NORETURN A_UNUSED  A_COLD
jhc_case_fell_off(int n) {
        fflush(stdout);
        fprintf(stderr, "\n%s:%i: case fell off\n", __FILE__, n);
        abort();
}

static HsBool A_UNUSED
jhc_wait_for_input(FILE *f,HsInt timeout) {
        fd_set fds;
        FD_ZERO(&fds);
        FD_SET(fileno(f),&fds);
        struct timeval to = {  0, timeout * 1000 };
        int retval = select(1,&fds,NULL,&fds,&to);
        if(retval)
                return HS_BOOL_TRUE;
        else
                return HS_BOOL_FALSE;

}

#ifdef __WIN32__
#define jhc_setjmp(jb) setjmp(*(jmp_buf *)jb)
#define jhc_longjmp(jb) longjmp(*(jmp_buf *)jb,1)
#define getchar_unlocked() getchar()
#define putchar_unlocked(x) putchar(x)
#define getc_unlocked(x) getc(x)
#define putc_unlocked(x,y) putc(x,y)
#else
#define jhc_setjmp(jb) sigsetjmp(*(jmp_buf *)jb,0)
#define jhc_longjmp(jb) siglongjmp(*(jmp_buf *)jb,1)
#endif

struct jhc_continuation {
    void *argument;
    jmp_buf jump_buf;
};

#define prim_umaxbound(t) ((t)~((t)0))
#define prim_maxbound(t) ((t)(~((t)1 << (sizeof(t)*8 - 1))))
#define prim_minbound(t) ((t)(((t)1 << (sizeof(t)*8 - 1))))


inline static int A_UNUSED
jhc_utf8_getchar(void)
{
    return getchar_unlocked();
}

inline static int A_UNUSED
jhc_utf8_getc(FILE *f)
{
    return getc_unlocked(f);
}

inline static int A_UNUSED
jhc_utf8_putchar(int ch)
{
    return putchar_unlocked(ch);
}

inline static int A_UNUSED
jhc_utf8_putc(int ch, FILE *f)
{
    return putc_unlocked(ch,f);
}


int  A_COLD
main(int argc, char *argv[])
{
        /* A few random assertions about the architecture that the compiler
         * assumes. should be true of any but the oddest of beasts.
         */

        assert(sizeof(HsPtr) == sizeof(HsFunPtr));
        assert(sizeof(HsPtr) == sizeof(intptr_t));
        assert(sizeof(HsPtr) == sizeof(uintptr_t));
        assert(CHAR_BIT == 8);
        assert(EOF == -1);

        jhc_arch_assert();
        jhc_malloc_init();
        jhc_argc = argc - 1;
        jhc_argv = argv + 1;
        jhc_progname = argv[0];
#if JHC_isPosix
        if(!uname(&jhc_utsname)) {
                jhc_options_arch = jhc_utsname.machine;
                jhc_options_os   = jhc_utsname.sysname;
        }
#endif
        setlocale(LC_ALL,"");
        if (jhc_setjmp(jhc_uncaught))
                jhc_error("Uncaught Exception");
        else
                _amain();
        jhc_print_profile();
        return 0;
}





#define ISLAZY(x)    (((uintptr_t)(x)) & 0x1)
#define DETAG(x)     ((uintptr_t)(x) & ~0x3)
#define GETTAG(x)    ((uintptr_t)(x) & 0x3)

#define GETHEAD(x)   (NODEP(x)->head)
#define NODEP(x)     ((node_t *)(x))
#define DNODEP(x)    ((dnode_t *)(x))
#define EVALTAG(fn)  (assert(((uintptr_t)(fn) & 0x3) == 0),(sptr_t)((uintptr_t)(fn) | P_LAZY))
#define EVALTAGC(fn) ((sptr_t)((void *)(fn) + P_LAZY))
#define EVALFUNC(fn) ((fptr_t)((uintptr_t)(fn) | P_FUNC))
#define VALUE(n)     ((wptr_t)(((intptr_t)(n) << 2) | P_VALUE))
#define GETVALUE(n)  ((intptr_t)(n) >> 2)
#define ISVALUE(n)   (assert(!ISLAZY(n)), ((uintptr_t)(n) & 0x2))
#define PROMOTE(n)   ((wptr_t)(n))
#define DEMOTE(n)    ((sptr_t)(n))
#define GETWHAT(x)   (GETTAG(x) == P_VALUE ? ((uintptr_t)(x) >> 16) : DNODEP(x)->what)

#define SETWHAT(x,v)   (DNODEP(x)->what = (v))
#define RAWWHAT(w)     (wptr_t)(((uintptr_t)w << 16) | P_VALUE)


#define P_WHNF  0x0
#define P_LAZY  0x1
#define P_VALUE 0x2
#define P_FUNC  0x3

#define BLACK_HOLE ((fptr_t)0xDEADBEEF)


/*@Internals

# The Run Time System

Jhc is very minimalist in that it does not have a precompiled run time system,
but rather generates what is needed as part of the compilation process.
However, we call whatever conventions and binary layouts used in the generated
executable the run time system. Since jhc generates the code anew each time, it
can build a different 'run time' based on compiler options, trading things like
the garbage collector as needed or changing the closure layout when we know we
have done full program optimization. This describes the 'native' layout upon
which other conventions are layered.

A basic value in jhc is represented by a 'smart pointer' of c type sptr_t. a
smart pointer is the size of a native pointer, but can take on different roles
depending on a pair of tag bits.

smart pointers take on a general form as follows:

    -------------------------
    |    payload        | GL|
    -------------------------

      G - if set, then the garbage collector should not treat value as a pointer to be followed
      L - lazy, this bit being set means the value is not in WHNF

A raw sptr_t on its own in the wild can only take on one of the following values:

    -------------------------
    |    raw value      | 10|
    -------------------------

    -------------------------
    |    whnf location  | 00|
    -------------------------

    -------------------------
    |   lazy location   | 01|
    -------------------------

A raw value can be anything and not necessarily a pointer in general, a WHNF
location is a pointer to some value in WHNF. The system places no restrictions
on what is actually pointed to by a WHNF pointer, however the garbage collector
in use may. In general, the back end is free to choose what to place in the raw
value field or in what a WHNF points to with complete freedom. If an
implementation sees the L bit is clear, it can pass on the smart pointer
without examining it knowing the value is in WHNF.

A lazy location points to a potential closure or an indirection to a WHNF
value. The lazy location is an allocated chunk of memory that is at least
one pointer long. the very first location in a closure must be one of the
following.

    -------------------------
    | raw value or whnf  |X0|
    -------------------------

An evaluated value, interpreted exactly as above. one can always replace any occurance of a
lazy location with an evaluated indirecton.

    -------------------------
    |    code pointer   | 11|
    -------------------------
    |     data ...          |

This is something to evaluate, code pointer is a pointer to a function that takes
the memory location as its only argument, the called function is in charge
of updating the location if needed.

note that it is invalid to have a lazy location point to another lazy
location. there is only ever one level of indirection allowed, and only from
lazy locations

note that a partial application is just like any other value in WHNF as far
as the above is concered. It happens to possibly contain a code pointer.

*/


/*
 * type names
 *
 * sptr_t - a tagged smart pointer, may be a value, may be a pointer to a whnf or lazy location
 * wptr_t - a value guarenteed to be in whnf
 * fptr_t - a pointer to a whnf or a function pointer to something to evaluate, first value in a lazy location.
 * what_t  - the discriminator of a discriminated union
 *
 */

typedef struct node *  sptr_t;
typedef struct dnode * wptr_t;
typedef void *         fptr_t;
typedef uintptr_t      what_t;


typedef struct node {
        fptr_t head;
        sptr_t rest[];
} A_MAYALIAS node_t;

typedef struct dnode {
        what_t what;
        sptr_t rest[];
} A_MAYALIAS dnode_t;

#if _JHC_DEBUG

// these ensure the type synonyms are available to the debugger
uintptr_t _dummy1;
node_t *_dummy2;
dnode_t *_dummy3;
sptr_t *_dummy4;
fptr_t *_dummy5;
wptr_t *_dummy6;


static int A_UNUSED
jhc_valid_whnf(wptr_t s)
{
        return ((GETTAG(s) == P_VALUE) || ((GETTAG(s) == P_WHNF) && jhc_malloc_sanity(s,P_WHNF)));
}

static int A_UNUSED
jhc_valid_lazy(sptr_t s)
{
        if(jhc_valid_whnf((wptr_t)s))
                return 1;
        assert(GETTAG(s) == P_LAZY);
        node_t *ds = (sptr_t)DETAG(s);
        assert(jhc_malloc_sanity(ds,P_LAZY));
        if(ISLAZY(ds->head)) {
                if(ds->head == BLACK_HOLE) return 1;
                assert(GETTAG(ds->head) == P_FUNC);
                fptr_t dhead = (fptr_t)DETAG(ds->head);
                assert(dhead >= &_start && dhead < &_end);
                return 1;
        } else
                return jhc_valid_whnf((wptr_t)ds->head);
}


#else

#define jhc_valid_whnf(x) 1
#define jhc_valid_lazy(x) 1

#endif


typedef wptr_t (*eval_fn)(node_t *node) A_STD;

// both promote and demote evaluate to nothing when debugging is not enabled
// otherwise, they check that their arguments are in the correct form.

static inline wptr_t A_STD A_UNUSED  A_HOT
promote(sptr_t s)
{
        assert(!ISLAZY(s));
        assert(jhc_valid_whnf((wptr_t)s));
        return (wptr_t)s;
}

static inline sptr_t A_STD A_UNUSED A_HOT
demote(wptr_t s)
{
        assert(!ISLAZY(s));
        assert(jhc_valid_whnf(s));
        return (sptr_t)s;
}

// like eval but you know the target is in WHNF or is a already evaluated indirection
static inline wptr_t A_STD A_UNUSED  A_HOT
follow(sptr_t s)
{
        assert(jhc_valid_lazy(s));
        if(ISLAZY(s)) {
                sptr_t h = (sptr_t)(GETHEAD(DETAG(s)));
                assert(!ISLAZY(h));
                return (wptr_t)h;
        }
        return (wptr_t)s;
}

static inline wptr_t A_STD A_UNUSED  A_HOT
eval(sptr_t s)
{
        assert(jhc_valid_lazy(s));
        if(ISLAZY(s)) {
                assert(GETTAG(s) == P_LAZY);
                void *ds = (void *)DETAG(s);
                sptr_t h = (sptr_t)(GETHEAD(ds));
                assert(h != BLACK_HOLE);
                if(ISLAZY(h)) {
                        eval_fn fn = (eval_fn)DETAG(h);
#if _JHC_DEBUG
                        GETHEAD(ds) = BLACK_HOLE;
#endif
                        wptr_t r = (*fn)(NODEP(ds));
#if _JHC_DEBUG
                        assert(GETHEAD(ds) != BLACK_HOLE);
#endif
                        return r;
                }
                return (wptr_t)h;
        }
        assert(jhc_valid_whnf((wptr_t)s));
        return (wptr_t)s;
}


static inline void A_STD A_UNUSED A_HOT
update(sptr_t thunk, wptr_t new)
{
        jhc_update_inc();
        assert(GETHEAD(thunk) == BLACK_HOLE);
        assert(!ISLAZY(new));
        GETHEAD(thunk) = (fptr_t)new;
}




static void
jhc_arch_assert(void)
{
      assert(sizeof(uint32_t) == 4);
      assert(sizeof(HsChar) == 4);
      assert(sizeof(int) == 4);
      assert(sizeof(intmax_t) == 8);
      assert(sizeof(int8_t) == 1);
      assert(sizeof(int16_t) == 2);
      assert(sizeof(int32_t) == 4);
      assert(sizeof(int64_t) == 8);
      assert(sizeof(intmax_t) == 8);
      assert(sizeof(intptr_t) == 4);
      assert(sizeof(unsigned int) == 4);
      assert(sizeof(uint8_t) == 1);
      assert(sizeof(uint16_t) == 2);
      assert(sizeof(uint32_t) == 4);
      assert(sizeof(uint64_t) == 8);
      assert(sizeof(uintmax_t) == 8);
      assert(sizeof(uintptr_t) == 4);
      assert(sizeof(float) == 4);
      assert(sizeof(double) == 8);
      assert(sizeof(HsPtr) == 4);
      assert(sizeof(HsFunPtr) == 4);
      assert(sizeof(char) == 1);
      assert(sizeof(short) == 2);
      assert(sizeof(int) == 4);
      assert(sizeof(unsigned int) == 4);
      assert(sizeof(size_t) == 4);
      assert(sizeof(wchar_t) == 4);
      assert(sizeof(wint_t) == 4);
}
#include <stdio.h>
#include <stdlib.h>

enum {
    CInteger_h = 0,
    CJhc__Addr__Addr = 0,
    CJhc__Basics___L_R = 0,
    CJhc__Basics___L_c_R = 0,
    CJhc__Float__Float = 0,
    CJhc__Maybe__Just = 1,
    CJhc__Maybe__Nothing = 0,
    CJhc__Prim__Char = 0,
    CJhc__Prim___x3a = 0,
    CJhc__Prim___x5b_x5d = 1,
    CMain__AmbientLight = 1,
    CMain__Obj = 0,
    CMain__Plane = 1,
    CMain__PointLight = 0,
    CMain__Sphere = 0,
    CMain__V3 = 0,
    P1_utheMain_d14 = 0,
    P1_utheMain_d16 = 1,
    P1_utheMain_d18 = 2,
    P1_utheMain_d19 = 3,
    P1_utheMain_d6 = 4,
    P1_utheMain_d7 = 5,
    P1_utheMain_d8 = 6
};
struct sBap_u1_uData__Maybe__mapMaybe_d2_u100120 A_ALIGNED;
struct sCInteger_h A_ALIGNED;
struct sCJhc__Addr__Addr A_ALIGNED;
struct sCJhc__Basics___L_c_R A_ALIGNED;
struct sCJhc__Float__Float A_ALIGNED;
struct sCJhc__Maybe__Just A_ALIGNED;
struct sCJhc__Prim___x3a A_ALIGNED;
struct sCMain__AmbientLight A_ALIGNED;
struct sCMain__Obj A_ALIGNED;
struct sCMain__Plane A_ALIGNED;
struct sCMain__PointLight A_ALIGNED;
struct sCMain__Sphere A_ALIGNED;
struct sCMain__V3 A_ALIGNED;
struct sFData__Maybe__mapMaybe_d2 A_ALIGNED;
struct sFJhc__Basics__161_ug A_ALIGNED;
struct sFMain__147_ui A_ALIGNED;
struct sFPrelude___x5e_d2 A_ALIGNED;
struct sFPrelude___x5e_d3 A_ALIGNED;
struct sFR_a__fJhc__Basics___p_p A_ALIGNED;
struct sFR_a__fJhc__Basics__foldl A_ALIGNED;
struct sFW_a__fInstance_a__iJhc__Enum__enumFromTo__Jhc__Prim__Int_d2 A_ALIGNED;
struct sFtheMain_d10 A_ALIGNED;
struct sFtheMain_d11 A_ALIGNED;
struct sFtheMain_d12 A_ALIGNED;
struct sFtheMain_d13 A_ALIGNED;
struct sFtheMain_d2 A_ALIGNED;
struct sFtheMain_d20 A_ALIGNED;
struct sFtheMain_d21 A_ALIGNED;
struct sFtheMain_d27 A_ALIGNED;
struct sFtheMain_d28 A_ALIGNED;
struct sFtheMain_d29 A_ALIGNED;
struct sFtheMain_d3 A_ALIGNED;
struct sFtheMain_d33 A_ALIGNED;
struct sFtheMain_d34 A_ALIGNED;
struct sFtheMain_d35 A_ALIGNED;
struct sFtheMain_d36 A_ALIGNED;
struct sFtheMain_d37 A_ALIGNED;
struct sFtheMain_d38 A_ALIGNED;
struct sFtheMain_d4 A_ALIGNED;
struct sFtheMain_d40 A_ALIGNED;
struct sFtheMain_d42 A_ALIGNED;
struct sFtheMain_d43 A_ALIGNED;
struct sFtheMain_d44 A_ALIGNED;
struct sFtheMain_d45 A_ALIGNED;
struct sFtheMain_d46 A_ALIGNED;
struct sFtheMain_d47 A_ALIGNED;
struct sFtheMain_d5 A_ALIGNED;
struct sFtheMain_d9 A_ALIGNED;
struct sP1_utheMain_d8 A_ALIGNED;

struct sBap_u1_uData__Maybe__mapMaybe_d2_u100120 {
    fptr_t head;
    sptr_t a1;
    sptr_t a2;
};

struct sCInteger_h {
    uintmax_t a1;
};

struct sCJhc__Addr__Addr {
    uintptr_t a1;
};

struct sCJhc__Basics___L_c_R {
    sptr_t a1;
    sptr_t a2;
};

struct sCJhc__Float__Float {
    float a1;
};

struct sCJhc__Maybe__Just {
    what_t what;
    sptr_t a1;
};

struct sCJhc__Prim___x3a {
    what_t what;
    sptr_t a1;
    sptr_t a2;
};

struct sCMain__AmbientLight {
    what_t what;
    sptr_t a1;
};

struct sCMain__Obj {
    sptr_t a1;
    sptr_t a2;
    sptr_t a3;
};

struct sCMain__Plane {
    what_t what;
    sptr_t a1;
    sptr_t a2;
};

struct sCMain__PointLight {
    what_t what;
    sptr_t a1;
    sptr_t a2;
};

struct sCMain__Sphere {
    what_t what;
    sptr_t a1;
    sptr_t a2;
};

struct sCMain__V3 {
    float a1;
    float a2;
    float a3;
};

struct sFData__Maybe__mapMaybe_d2 {
    fptr_t head;
    sptr_t a1;
    sptr_t a2;
};

struct sFJhc__Basics__161_ug {
    fptr_t head;
    sptr_t a1;
};

struct sFMain__147_ui {
    fptr_t head;
};

struct sFPrelude___x5e_d2 {
    fptr_t head;
    sptr_t a1;
};

struct sFPrelude___x5e_d3 {
    fptr_t head;
    sptr_t a1;
    sptr_t a2;
};

struct sFR_a__fJhc__Basics___p_p {
    fptr_t head;
    sptr_t a1;
    sptr_t a2;
};

struct sFR_a__fJhc__Basics__foldl {
    fptr_t head;
    sptr_t a1;
    sptr_t a2;
};

struct sFW_a__fInstance_a__iJhc__Enum__enumFromTo__Jhc__Prim__Int_d2 {
    fptr_t head;
    uint32_t a1;
    uint32_t a2;
};

struct sFtheMain_d10 {
    fptr_t head;
    sptr_t a1;
    float a2;
    float a3;
};

struct sFtheMain_d11 {
    fptr_t head;
    sptr_t a1;
    sptr_t a2;
};

struct sFtheMain_d12 {
    fptr_t head;
    sptr_t a1;
    sptr_t a2;
    sptr_t a3;
};

struct sFtheMain_d13 {
    fptr_t head;
    sptr_t a1;
};

struct sFtheMain_d2 {
    fptr_t head;
};

struct sFtheMain_d20 {
    fptr_t head;
};

struct sFtheMain_d21 {
    fptr_t head;
};

struct sFtheMain_d27 {
    fptr_t head;
    sptr_t a1;
    sptr_t a2;
};

struct sFtheMain_d28 {
    fptr_t head;
    sptr_t a1;
    sptr_t a2;
};

struct sFtheMain_d29 {
    fptr_t head;
};

struct sFtheMain_d3 {
    fptr_t head;
    sptr_t a1;
    sptr_t a2;
};

struct sFtheMain_d33 {
    fptr_t head;
    sptr_t a1;
    sptr_t a2;
    sptr_t a3;
};

struct sFtheMain_d34 {
    fptr_t head;
    sptr_t a1;
    sptr_t a2;
    sptr_t a3;
};

struct sFtheMain_d35 {
    fptr_t head;
    sptr_t a1;
    sptr_t a2;
};

struct sFtheMain_d36 {
    fptr_t head;
    sptr_t a1;
    sptr_t a2;
};

struct sFtheMain_d37 {
    fptr_t head;
    sptr_t a1;
    sptr_t a2;
    sptr_t a3;
    sptr_t a4;
};

struct sFtheMain_d38 {
    fptr_t head;
};

struct sFtheMain_d4 {
    fptr_t head;
    sptr_t a1;
};

struct sFtheMain_d40 {
    fptr_t head;
    sptr_t a1;
    sptr_t a2;
};

struct sFtheMain_d42 {
    fptr_t head;
    sptr_t a1;
    sptr_t a2;
};

struct sFtheMain_d43 {
    fptr_t head;
    sptr_t a1;
};

struct sFtheMain_d44 {
    fptr_t head;
    sptr_t a1;
};

struct sFtheMain_d45 {
    fptr_t head;
    sptr_t a1;
};

struct sFtheMain_d46 {
    fptr_t head;
    sptr_t a1;
};

struct sFtheMain_d47 {
    fptr_t head;
    sptr_t a1;
};

struct sFtheMain_d5 {
    fptr_t head;
};

struct sFtheMain_d9 {
    fptr_t head;
    sptr_t a1;
    sptr_t a8;
    float a2;
    float a3;
    float a4;
    float a5;
    float a6;
    float a7;
};

struct sP1_utheMain_d8 {
    what_t what;
    sptr_t a1;
    sptr_t a2;
};
struct tup1 {
    float t0;
    float t1;
    float t2;
};
/* CAFS */
/* v-1850483221 = (@hole)*/
static node_t _g1850483221;
#define g1850483221 (EVALTAGC(&_g1850483221))

/* v-1818239509 = (@hole)*/
static node_t _g1818239509;
#define g1818239509 (EVALTAGC(&_g1818239509))

/* v-1798185495 = (@hole)*/
static node_t _g1798185495;
#define g1798185495 (EVALTAGC(&_g1798185495))

/* v-1801069079 = (@hole)*/
static node_t _g1801069079;
#define g1801069079 (EVALTAGC(&_g1801069079))

/* v-1776951831 = (@hole)*/
static node_t _g1776951831;
#define g1776951831 (EVALTAGC(&_g1776951831))

/* v-1768694295 = (@hole)*/
static node_t _g1768694295;
#define g1768694295 (EVALTAGC(&_g1768694295))

/* v-1853235735 = (@hole)*/
static node_t _g1853235735;
#define g1853235735 (EVALTAGC(&_g1853235735))

/* (HcNode CMain.Sphere [Left ni-1798185495,Left ni-1801069079],1) */
static const struct sCMain__Sphere _c1 = {.what = CMain__Sphere, .a1 = g1798185495, .a2 = g1801069079};
#define c1 ((sptr_t)&_c1)
/* (HcNode CMain.Obj [Right 1,Left &("P1_theMain$6"),Left &("P1_theMain$18")],2) */
static const struct sCMain__Obj _c2 = {.a1 = c1, .a2 = (sptr_t)RAWWHAT(P1_utheMain_d6), .a3 = (sptr_t)RAWWHAT(P1_utheMain_d18)};
#define c2 ((sptr_t)&_c2)
/* (HcNode CMain.V3 [Left 50,Left 50,Left 100],3) */
static const struct sCMain__V3 _c3 = {.a1 = 50.0, .a2 = 50.0, .a3 = 100.0};
#define c3 ((sptr_t)&_c3)
/* (HcNode CJhc.Float.Float [Left 100],4) */
static const struct sCJhc__Float__Float _c4 = {.a1 = 100.0};
#define c4 ((sptr_t)&_c4)
/* (HcNode CMain.Sphere [Right 3,Right 4],5) */
static const struct sCMain__Sphere _c5 = {.what = CMain__Sphere, .a1 = c3, .a2 = c4};
#define c5 ((sptr_t)&_c5)
/* (HcNode CMain.Obj [Right 5,Left &("P1_theMain$7"),Left &("P1_theMain$14")],6) */
static const struct sCMain__Obj _c6 = {.a1 = c5, .a2 = (sptr_t)RAWWHAT(P1_utheMain_d7), .a3 = (sptr_t)RAWWHAT(P1_utheMain_d14)};
#define c6 ((sptr_t)&_c6)
/* (HcNode CMain.V3 [Left -100,Left 100,Left 0],7) */
static const struct sCMain__V3 _c7 = {.a1 = -100.0, .a2 = 100.0, .a3 = 0.0};
#define c7 ((sptr_t)&_c7)
/* (HcNode CMain.Plane [Right 7,Left ni-1818239509],8) */
static const struct sCMain__Plane _c8 = {.what = CMain__Plane, .a1 = c7, .a2 = g1818239509};
#define c8 ((sptr_t)&_c8)
/* (HcNode CMain.Obj [Right 8,Left &("P1_theMain$19"),Left &("P1_theMain$16")],9) */
static const struct sCMain__Obj _c9 = {.a1 = c8, .a2 = (sptr_t)RAWWHAT(P1_utheMain_d19), .a3 = (sptr_t)RAWWHAT(P1_utheMain_d16)};
#define c9 ((sptr_t)&_c9)
/* (HcNode CJhc.Prim.: [Right 9,Left &("CJhc.Prim.[]")],10) */
static const struct sCJhc__Prim___x3a _c10 = {.what = CJhc__Prim___x3a, .a1 = c9, .a2 = (sptr_t)RAWWHAT(CJhc__Prim___x5b_x5d)};
#define c10 ((sptr_t)&_c10)
/* (HcNode CJhc.Prim.: [Right 6,Right 10],11) */
static const struct sCJhc__Prim___x3a _c11 = {.what = CJhc__Prim___x3a, .a1 = c6, .a2 = c10};
#define c11 ((sptr_t)&_c11)
/* (HcNode CJhc.Prim.: [Right 2,Right 11],12) */
static const struct sCJhc__Prim___x3a _c12 = {.what = CJhc__Prim___x3a, .a1 = c2, .a2 = c11};
#define c12 ((sptr_t)&_c12)
/* (HcNode CMain.V3 [Left Op {primCOp = BinOp FDiv fbits32 fbits32, primRetTy = fbits32}(40000,1),Left 20000,Left 20000],13) */
static const struct sCMain__V3 _c13 = {.a1 = 40000.0 / 1.0, .a2 = 20000.0, .a3 = 20000.0};
#define c13 ((sptr_t)&_c13)
/* (HcNode CMain.PointLight [Left ni-1768694295,Right 13],14) */
static const struct sCMain__PointLight _c14 = {.what = CMain__PointLight, .a1 = g1768694295, .a2 = c13};
#define c14 ((sptr_t)&_c14)
/* (HcNode CMain.V3 [Left Op {primCOp = BinOp FDiv fbits32 fbits32, primRetTy = fbits32}(0,1),Left Op {primCOp = BinOp FDiv fbits32 fbits32, primRetTy = fbits32}(1,20),Left Op {primCOp = BinOp FDiv fbits32 fbits32, primRetTy = fbits32}(1,10)],15) */
static const struct sCMain__V3 _c15 = {.a1 = 0.0 / 1.0, .a2 = 1.0 / 20.0, .a3 = 1.0 / 10.0};
#define c15 ((sptr_t)&_c15)
/* (HcNode CMain.AmbientLight [Right 15],16) */
static const struct sCMain__AmbientLight _c16 = {.what = CMain__AmbientLight, .a1 = c15};
#define c16 ((sptr_t)&_c16)
/* (HcNode CMain.V3 [Left Op {primCOp = BinOp FDiv fbits32 fbits32, primRetTy = fbits32}(10000,1),Left 20000,Left 50000],17) */
static const struct sCMain__V3 _c17 = {.a1 = 10000.0 / 1.0, .a2 = 20000.0, .a3 = 50000.0};
#define c17 ((sptr_t)&_c17)
/* (HcNode CMain.PointLight [Left ni-1776951831,Right 17],18) */
static const struct sCMain__PointLight _c18 = {.what = CMain__PointLight, .a1 = g1776951831, .a2 = c17};
#define c18 ((sptr_t)&_c18)
/* (HcNode CJhc.Prim.: [Right 18,Left &("CJhc.Prim.[]")],19) */
static const struct sCJhc__Prim___x3a _c19 = {.what = CJhc__Prim___x3a, .a1 = c18, .a2 = (sptr_t)RAWWHAT(CJhc__Prim___x5b_x5d)};
#define c19 ((sptr_t)&_c19)
/* (HcNode CJhc.Prim.: [Right 16,Right 19],20) */
static const struct sCJhc__Prim___x3a _c20 = {.what = CJhc__Prim___x3a, .a1 = c16, .a2 = c19};
#define c20 ((sptr_t)&_c20)
/* (HcNode CJhc.Prim.: [Right 14,Right 20],21) */
static const struct sCJhc__Prim___x3a _c21 = {.what = CJhc__Prim___x3a, .a1 = c14, .a2 = c20};
#define c21 ((sptr_t)&_c21)
/* (HcNode CMain.V3 [Left 0,Left 0,Left 0],22) */
static const struct sCMain__V3 _c22 = {.a1 = 0.0, .a2 = 0.0, .a3 = 0.0};
#define c22 ((sptr_t)&_c22)
/* (HcNode CJhc.Prim.: [Left &("CJhc.Prim.Char" 99),Left &("CJhc.Prim.[]")],23) */
static const struct sCJhc__Prim___x3a _c23 = {.what = CJhc__Prim___x3a, .a1 = (sptr_t)VALUE('c'), .a2 = (sptr_t)RAWWHAT(CJhc__Prim___x5b_x5d)};
#define c23 ((sptr_t)&_c23)
/* (HcNode CJhc.Prim.: [Left &("CJhc.Prim.Char" 111),Right 23],24) */
static const struct sCJhc__Prim___x3a _c24 = {.what = CJhc__Prim___x3a, .a1 = (sptr_t)VALUE('o'), .a2 = c23};
#define c24 ((sptr_t)&_c24)
/* (HcNode CJhc.Prim.: [Left &("CJhc.Prim.Char" 108),Right 24],25) */
static const struct sCJhc__Prim___x3a _c25 = {.what = CJhc__Prim___x3a, .a1 = (sptr_t)VALUE('l'), .a2 = c24};
#define c25 ((sptr_t)&_c25)
/* (HcNode CJhc.Prim.: [Left &("CJhc.Prim.Char" 108),Right 25],26) */
static const struct sCJhc__Prim___x3a _c26 = {.what = CJhc__Prim___x3a, .a1 = (sptr_t)VALUE('l'), .a2 = c25};
#define c26 ((sptr_t)&_c26)
/* (HcNode CJhc.Prim.: [Left &("CJhc.Prim.Char" 97),Right 26],27) */
static const struct sCJhc__Prim___x3a _c27 = {.what = CJhc__Prim___x3a, .a1 = (sptr_t)VALUE('a'), .a2 = c26};
#define c27 ((sptr_t)&_c27)
/* (HcNode CJhc.Prim.: [Left &("CJhc.Prim.Char" 109),Right 27],28) */
static const struct sCJhc__Prim___x3a _c28 = {.what = CJhc__Prim___x3a, .a1 = (sptr_t)VALUE('m'), .a2 = c27};
#define c28 ((sptr_t)&_c28)
/* (HcNode CJhc.Prim.: [Left &("CJhc.Prim.Char" 121),Left &("CJhc.Prim.[]")],29) */
static const struct sCJhc__Prim___x3a _c29 = {.what = CJhc__Prim___x3a, .a1 = (sptr_t)VALUE('y'), .a2 = (sptr_t)RAWWHAT(CJhc__Prim___x5b_x5d)};
#define c29 ((sptr_t)&_c29)
/* (HcNode CJhc.Prim.: [Left &("CJhc.Prim.Char" 114),Right 29],30) */
static const struct sCJhc__Prim___x3a _c30 = {.what = CJhc__Prim___x3a, .a1 = (sptr_t)VALUE('r'), .a2 = c29};
#define c30 ((sptr_t)&_c30)
/* (HcNode CJhc.Prim.: [Left &("CJhc.Prim.Char" 111),Right 30],31) */
static const struct sCJhc__Prim___x3a _c31 = {.what = CJhc__Prim___x3a, .a1 = (sptr_t)VALUE('o'), .a2 = c30};
#define c31 ((sptr_t)&_c31)
/* (HcNode CJhc.Prim.: [Left &("CJhc.Prim.Char" 109),Right 31],32) */
static const struct sCJhc__Prim___x3a _c32 = {.what = CJhc__Prim___x3a, .a1 = (sptr_t)VALUE('m'), .a2 = c31};
#define c32 ((sptr_t)&_c32)
/* (HcNode CJhc.Prim.: [Left &("CJhc.Prim.Char" 101),Right 32],33) */
static const struct sCJhc__Prim___x3a _c33 = {.what = CJhc__Prim___x3a, .a1 = (sptr_t)VALUE('e'), .a2 = c32};
#define c33 ((sptr_t)&_c33)
/* (HcNode CJhc.Prim.: [Left &("CJhc.Prim.Char" 109),Right 33],34) */
static const struct sCJhc__Prim___x3a _c34 = {.what = CJhc__Prim___x3a, .a1 = (sptr_t)VALUE('m'), .a2 = c33};
#define c34 ((sptr_t)&_c34)
/* (HcNode CJhc.Prim.: [Left &("CJhc.Prim.Char" 32),Right 34],35) */
static const struct sCJhc__Prim___x3a _c35 = {.what = CJhc__Prim___x3a, .a1 = (sptr_t)VALUE(' '), .a2 = c34};
#define c35 ((sptr_t)&_c35)
/* (HcNode CJhc.Prim.: [Left &("CJhc.Prim.Char" 102),Right 35],36) */
static const struct sCJhc__Prim___x3a _c36 = {.what = CJhc__Prim___x3a, .a1 = (sptr_t)VALUE('f'), .a2 = c35};
#define c36 ((sptr_t)&_c36)
/* (HcNode CJhc.Prim.: [Left &("CJhc.Prim.Char" 111),Right 36],37) */
static const struct sCJhc__Prim___x3a _c37 = {.what = CJhc__Prim___x3a, .a1 = (sptr_t)VALUE('o'), .a2 = c36};
#define c37 ((sptr_t)&_c37)
/* (HcNode CJhc.Prim.: [Left &("CJhc.Prim.Char" 32),Right 37],38) */
static const struct sCJhc__Prim___x3a _c38 = {.what = CJhc__Prim___x3a, .a1 = (sptr_t)VALUE(' '), .a2 = c37};
#define c38 ((sptr_t)&_c38)
/* (HcNode CJhc.Prim.: [Left &("CJhc.Prim.Char" 116),Right 38],39) */
static const struct sCJhc__Prim___x3a _c39 = {.what = CJhc__Prim___x3a, .a1 = (sptr_t)VALUE('t'), .a2 = c38};
#define c39 ((sptr_t)&_c39)
/* (HcNode CJhc.Prim.: [Left &("CJhc.Prim.Char" 117),Right 39],40) */
static const struct sCJhc__Prim___x3a _c40 = {.what = CJhc__Prim___x3a, .a1 = (sptr_t)VALUE('u'), .a2 = c39};
#define c40 ((sptr_t)&_c40)
/* (HcNode CJhc.Prim.: [Left &("CJhc.Prim.Char" 111),Right 40],41) */
static const struct sCJhc__Prim___x3a _c41 = {.what = CJhc__Prim___x3a, .a1 = (sptr_t)VALUE('o'), .a2 = c40};
#define c41 ((sptr_t)&_c41)
/* (HcNode CJhc.Prim.: [Left &("CJhc.Prim.Char" 32),Right 41],42) */
static const struct sCJhc__Prim___x3a _c42 = {.what = CJhc__Prim___x3a, .a1 = (sptr_t)VALUE(' '), .a2 = c41};
#define c42 ((sptr_t)&_c42)
/* (HcNode CJhc.Prim.: [Left &("CJhc.Prim.Char" 58),Right 42],43) */
static const struct sCJhc__Prim___x3a _c43 = {.what = CJhc__Prim___x3a, .a1 = (sptr_t)VALUE(':'), .a2 = c42};
#define c43 ((sptr_t)&_c43)
/* (HcNode CJhc.Prim.: [Left &("CJhc.Prim.Char" 33),Left &("CJhc.Prim.[]")],44) */
static const struct sCJhc__Prim___x3a _c44 = {.what = CJhc__Prim___x3a, .a1 = (sptr_t)VALUE('!'), .a2 = (sptr_t)RAWWHAT(CJhc__Prim___x5b_x5d)};
#define c44 ((sptr_t)&_c44)
/* (HcNode CJhc.Prim.: [Left &("CJhc.Prim.Char" 111),Right 44],45) */
static const struct sCJhc__Prim___x3a _c45 = {.what = CJhc__Prim___x3a, .a1 = (sptr_t)VALUE('o'), .a2 = c44};
#define c45 ((sptr_t)&_c45)
/* (HcNode CJhc.Prim.: [Left &("CJhc.Prim.Char" 108),Right 45],46) */
static const struct sCJhc__Prim___x3a _c46 = {.what = CJhc__Prim___x3a, .a1 = (sptr_t)VALUE('l'), .a2 = c45};
#define c46 ((sptr_t)&_c46)
/* (HcNode CJhc.Prim.: [Left &("CJhc.Prim.Char" 108),Right 46],47) */
static const struct sCJhc__Prim___x3a _c47 = {.what = CJhc__Prim___x3a, .a1 = (sptr_t)VALUE('l'), .a2 = c46};
#define c47 ((sptr_t)&_c47)
/* (HcNode CJhc.Prim.: [Left &("CJhc.Prim.Char" 101),Right 47],48) */
static const struct sCJhc__Prim___x3a _c48 = {.what = CJhc__Prim___x3a, .a1 = (sptr_t)VALUE('e'), .a2 = c47};
#define c48 ((sptr_t)&_c48)
/* (HcNode CJhc.Prim.: [Left &("CJhc.Prim.Char" 72),Right 48],49) */
static const struct sCJhc__Prim___x3a _c49 = {.what = CJhc__Prim___x3a, .a1 = (sptr_t)VALUE('H'), .a2 = c48};
#define c49 ((sptr_t)&_c49)
/* (HcNode CMain.V3 [Left 0,Left 0,Left -500],50) */
static const struct sCMain__V3 _c50 = {.a1 = 0.0, .a2 = 0.0, .a3 = -500.0};
#define c50 ((sptr_t)&_c50)
/* (HcNode CInteger# [Left 2],51) */
static const struct sCInteger_h _c51 = {.a1 = 2};
#define c51 ((sptr_t)&_c51)
void _amain(void) ;
static void b_umain(void) A_STD;
static wptr_t bap_u1_uData__Maybe__mapMaybe_d2_u100120(sptr_t v613,sptr_t v615) A_STD A_MALLOC;
static wptr_t bapply_u16507(wptr_t v1,sptr_t v2) A_STD A_MALLOC;
static wptr_t fData__Maybe__mapMaybe(sptr_t v1172967969,sptr_t v144230444) A_STD A_MALLOC;
static wptr_t fData__Maybe__mapMaybe_d2(sptr_t v123193690,sptr_t v54) A_STD A_MALLOC;
static sptr_t fForeign__Marshal__Array__pokeArray(sptr_t v1699877435,sptr_t v1703678525) A_STD A_MALLOC;
static wptr_t fJhc__Basics__161_ug(sptr_t v210133554) A_STD A_MALLOC;
static wptr_t fJhc__Basics___p_p(sptr_t v431,sptr_t v12) A_STD A_MALLOC;
static wptr_t fMain__147_ui(void) A_STD A_MALLOC;
static wptr_t fMain__findNearest(sptr_t v1168245787,sptr_t v237771584,sptr_t v142176834) A_STD A_MALLOC;
static wptr_t fPrelude___x5e(sptr_t v29751956,sptr_t v202592748) A_STD A_MALLOC;
static wptr_t fPrelude___x5e_d2(sptr_t v211197114) A_STD A_MALLOC;
static wptr_t fPrelude___x5e_d3(sptr_t v6963186,sptr_t v66802802) A_STD A_MALLOC;
static wptr_t fR_a__fJhc__Basics___p_p(sptr_t v148914806,sptr_t v107940062) A_STD A_MALLOC;
static wptr_t fR_a__fJhc__Basics__foldl(sptr_t v192554778,sptr_t v154806006) A_STD A_MALLOC;
static wptr_t fW_a__fInstance_a__iJhc__Enum__enumFromTo__Jhc__Prim__Int(uint32_t v411439145,uint32_t v445912105) A_STD A_MALLOC;
static wptr_t fW_a__fInstance_a__iJhc__Enum__enumFromTo__Jhc__Prim__Int_d2(uint32_t v228603538,uint32_t v12325748) A_STD A_MALLOC;
static struct tup1 fW_a__fR_a__fMain__trace(sptr_t v16520982,sptr_t v177931968,uint32_t v93759628) A_STD;
static void ftheMain(void) A_STD;
static wptr_t ftheMain_d10(sptr_t v178,float v63948308,float v64169428) A_STD A_MALLOC;
static wptr_t ftheMain_d11(sptr_t v34,sptr_t v250400670) A_STD A_MALLOC;
static wptr_t ftheMain_d12(sptr_t v1169949723,sptr_t v1171653657,sptr_t v56837338) A_STD A_MALLOC;
static wptr_t ftheMain_d13(sptr_t v1196164133) A_STD A_MALLOC;
static wptr_t ftheMain_d14(sptr_t u1) A_STD A_MALLOC;
static wptr_t ftheMain_d16(sptr_t u1) A_STD A_MALLOC;
static wptr_t ftheMain_d18(sptr_t u1) A_STD A_MALLOC;
static wptr_t ftheMain_d19(sptr_t u1) A_STD A_MALLOC;
static wptr_t ftheMain_d2(void) A_STD A_MALLOC;
static wptr_t ftheMain_d20(void) A_STD A_MALLOC;
static wptr_t ftheMain_d21(void) A_STD A_MALLOC;
static wptr_t ftheMain_d27(sptr_t v163888928,sptr_t v402) A_STD A_MALLOC;
static wptr_t ftheMain_d28(sptr_t v189354292,sptr_t v1330512919) A_STD A_MALLOC;
static wptr_t ftheMain_d29(void) A_STD A_MALLOC;
static wptr_t ftheMain_d3(sptr_t v20129050,sptr_t v75189798) A_STD A_MALLOC;
static wptr_t ftheMain_d33(sptr_t v169612168,sptr_t v74017418,sptr_t v253662592) A_STD A_MALLOC;
static wptr_t ftheMain_d34(sptr_t v86070426,sptr_t v62465782,sptr_t v176290140) A_STD A_MALLOC;
static wptr_t ftheMain_d35(sptr_t v139590720,sptr_t v43995970) A_STD A_MALLOC;
static wptr_t ftheMain_d36(sptr_t v106,sptr_t v74828324) A_STD A_MALLOC;
static wptr_t ftheMain_d37(sptr_t v247669114,sptr_t v1253966873,sptr_t v1255539739,sptr_t v229959050) A_STD A_MALLOC;
static wptr_t ftheMain_d38(void) A_STD A_MALLOC;
static wptr_t ftheMain_d4(sptr_t v211325860) A_STD A_MALLOC;
static wptr_t ftheMain_d40(sptr_t v179870866,sptr_t v198219490) A_STD A_MALLOC;
static wptr_t ftheMain_d41(sptr_t v243793588,sptr_t v102624740) A_STD A_MALLOC;
static wptr_t ftheMain_d42(sptr_t v91735138,sptr_t v264575842) A_STD A_MALLOC;
static wptr_t ftheMain_d43(sptr_t v17109994) A_STD A_MALLOC;
static wptr_t ftheMain_d44(sptr_t v59311016) A_STD A_MALLOC;
static wptr_t ftheMain_d45(sptr_t v229935430) A_STD A_MALLOC;
static wptr_t ftheMain_d46(sptr_t v1367606309) A_STD A_MALLOC;
static wptr_t ftheMain_d47(sptr_t v109993702) A_STD A_MALLOC;
static wptr_t ftheMain_d5(void) A_STD A_MALLOC;
static wptr_t ftheMain_d6(sptr_t u1) A_STD A_MALLOC;
static wptr_t ftheMain_d7(sptr_t u1) A_STD A_MALLOC;
static wptr_t ftheMain_d8(sptr_t v78765330,sptr_t v251606036,sptr_t v102610400) A_STD A_MALLOC;
static wptr_t ftheMain_d9(sptr_t v172,float v65785274,float v84141378,float v143031316,float v179736044,float v238626066,float v256974690,sptr_t v207463906) A_STD A_MALLOC;
static wptr_t jhc_ueval_ubap_u1_uData__Maybe__mapMaybe_d2_u100120(struct sBap_u1_uData__Maybe__mapMaybe_d2_u100120* arg) A_STD A_FALIGNED;
static wptr_t jhc_ueval_ufData__Maybe__mapMaybe_d2(struct sFData__Maybe__mapMaybe_d2* arg) A_STD A_FALIGNED;
static wptr_t jhc_ueval_ufJhc__Basics__161_ug(struct sFJhc__Basics__161_ug* arg) A_STD A_FALIGNED;
static wptr_t jhc_ueval_ufMain__147_ui(struct sFMain__147_ui* arg) A_STD A_FALIGNED;
static wptr_t jhc_ueval_ufPrelude___x5e_d2(struct sFPrelude___x5e_d2* arg) A_STD A_FALIGNED;
static wptr_t jhc_ueval_ufPrelude___x5e_d3(struct sFPrelude___x5e_d3* arg) A_STD A_FALIGNED;
static wptr_t jhc_ueval_ufR_a__fJhc__Basics___p_p(struct sFR_a__fJhc__Basics___p_p* arg) A_STD A_FALIGNED;
static wptr_t jhc_ueval_ufR_a__fJhc__Basics__foldl(struct sFR_a__fJhc__Basics__foldl* arg) A_STD A_FALIGNED;
static wptr_t jhc_ueval_ufW_a__fInstance_a__iJhc__Enum__enumFromTo__Jhc__Prim__Int_d2(struct sFW_a__fInstance_a__iJhc__Enum__enumFromTo__Jhc__Prim__Int_d2* arg) A_STD A_FALIGNED;
static wptr_t jhc_ueval_uftheMain_d10(struct sFtheMain_d10* arg) A_STD A_FALIGNED;
static wptr_t jhc_ueval_uftheMain_d11(struct sFtheMain_d11* arg) A_STD A_FALIGNED;
static wptr_t jhc_ueval_uftheMain_d12(struct sFtheMain_d12* arg) A_STD A_FALIGNED;
static wptr_t jhc_ueval_uftheMain_d13(struct sFtheMain_d13* arg) A_STD A_FALIGNED;
static wptr_t jhc_ueval_uftheMain_d2(struct sFtheMain_d2* arg) A_STD A_FALIGNED;
static wptr_t jhc_ueval_uftheMain_d20(struct sFtheMain_d20* arg) A_STD A_FALIGNED;
static wptr_t jhc_ueval_uftheMain_d21(struct sFtheMain_d21* arg) A_STD A_FALIGNED;
static wptr_t jhc_ueval_uftheMain_d27(struct sFtheMain_d27* arg) A_STD A_FALIGNED;
static wptr_t jhc_ueval_uftheMain_d28(struct sFtheMain_d28* arg) A_STD A_FALIGNED;
static wptr_t jhc_ueval_uftheMain_d29(struct sFtheMain_d29* arg) A_STD A_FALIGNED;
static wptr_t jhc_ueval_uftheMain_d3(struct sFtheMain_d3* arg) A_STD A_FALIGNED;
static wptr_t jhc_ueval_uftheMain_d33(struct sFtheMain_d33* arg) A_STD A_FALIGNED;
static wptr_t jhc_ueval_uftheMain_d34(struct sFtheMain_d34* arg) A_STD A_FALIGNED;
static wptr_t jhc_ueval_uftheMain_d35(struct sFtheMain_d35* arg) A_STD A_FALIGNED;
static wptr_t jhc_ueval_uftheMain_d36(struct sFtheMain_d36* arg) A_STD A_FALIGNED;
static wptr_t jhc_ueval_uftheMain_d37(struct sFtheMain_d37* arg) A_STD A_FALIGNED;
static wptr_t jhc_ueval_uftheMain_d38(struct sFtheMain_d38* arg) A_STD A_FALIGNED;
static wptr_t jhc_ueval_uftheMain_d4(struct sFtheMain_d4* arg) A_STD A_FALIGNED;
static wptr_t jhc_ueval_uftheMain_d40(struct sFtheMain_d40* arg) A_STD A_FALIGNED;
static wptr_t jhc_ueval_uftheMain_d42(struct sFtheMain_d42* arg) A_STD A_FALIGNED;
static wptr_t jhc_ueval_uftheMain_d43(struct sFtheMain_d43* arg) A_STD A_FALIGNED;
static wptr_t jhc_ueval_uftheMain_d44(struct sFtheMain_d44* arg) A_STD A_FALIGNED;
static wptr_t jhc_ueval_uftheMain_d45(struct sFtheMain_d45* arg) A_STD A_FALIGNED;
static wptr_t jhc_ueval_uftheMain_d46(struct sFtheMain_d46* arg) A_STD A_FALIGNED;
static wptr_t jhc_ueval_uftheMain_d47(struct sFtheMain_d47* arg) A_STD A_FALIGNED;
static wptr_t jhc_ueval_uftheMain_d5(struct sFtheMain_d5* arg) A_STD A_FALIGNED;
static wptr_t jhc_ueval_uftheMain_d9(struct sFtheMain_d9* arg) A_STD A_FALIGNED;

void 
_amain(void)
{
        return (void)b_umain();
}

static void A_STD
b_umain(void)
{
        jhc_function_inc();
        jhc_update_inc();
        ((struct sFtheMain_d2*)DETAG(g1850483221))->head = EVALFUNC(&jhc_ueval_uftheMain_d2);
        jhc_update_inc();
        ((struct sFtheMain_d5*)DETAG(g1818239509))->head = EVALFUNC(&jhc_ueval_uftheMain_d5);
        jhc_update_inc();
        ((struct sFtheMain_d20*)DETAG(g1798185495))->head = EVALFUNC(&jhc_ueval_uftheMain_d20);
        jhc_update_inc();
        ((struct sFtheMain_d21*)DETAG(g1801069079))->head = EVALFUNC(&jhc_ueval_uftheMain_d21);
        jhc_update_inc();
        ((struct sFtheMain_d29*)DETAG(g1776951831))->head = EVALFUNC(&jhc_ueval_uftheMain_d29);
        jhc_update_inc();
        ((struct sFtheMain_d38*)DETAG(g1768694295))->head = EVALFUNC(&jhc_ueval_uftheMain_d38);
        jhc_update_inc();
        ((struct sFMain__147_ui*)DETAG(g1853235735))->head = EVALFUNC(&jhc_ueval_ufMain__147_ui);
        return ftheMain();
}

static wptr_t A_STD A_MALLOC
bap_u1_uData__Maybe__mapMaybe_d2_u100120(sptr_t v613,sptr_t v615)
{
        jhc_function_inc();
        wptr_t v100122 = promote(v613);
        return bapply_u16507(v100122,v615);
}

static wptr_t A_STD A_MALLOC
bapply_u16507(wptr_t v1,sptr_t v2)
{
        jhc_function_inc();
        jhc_case_inc();
        switch (GETWHAT(v1)) {
        case P1_utheMain_d8:
            {   sptr_t v3;
                sptr_t v4;
                v3 = ((struct sP1_utheMain_d8*)v1)->a1;
                v4 = ((struct sP1_utheMain_d8*)v1)->a2;
                return ftheMain_d8(v3,v4,v2);
            }
            break;
        case P1_utheMain_d14:
            {   return ftheMain_d14(v2);
            }
            break;
        case P1_utheMain_d7:
            {   return ftheMain_d7(v2);
            }
            break;
        case P1_utheMain_d16:
            {   return ftheMain_d16(v2);
            }
            break;
        case P1_utheMain_d19:
            {   return ftheMain_d19(v2);
            }
            break;
        case P1_utheMain_d18:
            {   return ftheMain_d18(v2);
            }
            break;
        case P1_utheMain_d6:
            {   return ftheMain_d6(v2);
            }
            break;
        default: jhc_case_fell_off(__LINE__);
        }
}

static wptr_t A_STD A_MALLOC
fData__Maybe__mapMaybe(sptr_t v1172967969,sptr_t v144230444)
{
        wptr_t v100198;
        jhc_function_inc();
        v100198 = fData__Maybe__mapMaybe_d2(v1172967969,v144230444);
        sptr_t v211142512 = demote(v100198);
        return fJhc__Basics__161_ug(v211142512);
}

static wptr_t A_STD A_MALLOC
fData__Maybe__mapMaybe_d2(sptr_t v123193690,sptr_t v54)
{
        wptr_t v100118;
        jhc_function_inc();
        v100118 = eval(v54);
        jhc_case_inc();
        if (RAWWHAT(CJhc__Prim___x5b_x5d) == v100118) {
            return v100118;
        } else {
            sptr_t v56;
            sptr_t v58;
            /* ("CJhc.Prim.:" ni56 ni58) */
            assert(CJhc__Prim___x3a == GETWHAT(v100118));
            v56 = ((struct sCJhc__Prim___x3a*)v100118)->a1;
            v58 = ((struct sCJhc__Prim___x3a*)v100118)->a2;
            sptr_t x66 = jhc_malloc(sizeof(struct sBap_u1_uData__Maybe__mapMaybe_d2_u100120));
            ((struct sBap_u1_uData__Maybe__mapMaybe_d2_u100120*)x66)->head = EVALFUNC(&jhc_ueval_ubap_u1_uData__Maybe__mapMaybe_d2_u100120);
            ((struct sBap_u1_uData__Maybe__mapMaybe_d2_u100120*)x66)->a1 = v123193690;
            ((struct sBap_u1_uData__Maybe__mapMaybe_d2_u100120*)x66)->a2 = v56;
            sptr_t v179578850 = EVALTAG(x66);
            sptr_t x67 = jhc_malloc(sizeof(struct sFData__Maybe__mapMaybe_d2));
            ((struct sFData__Maybe__mapMaybe_d2*)x67)->head = EVALFUNC(&jhc_ueval_ufData__Maybe__mapMaybe_d2);
            ((struct sFData__Maybe__mapMaybe_d2*)x67)->a1 = v123193690;
            ((struct sFData__Maybe__mapMaybe_d2*)x67)->a2 = v58;
            sptr_t v88762968 = EVALTAG(x67);
            wptr_t x68 = jhc_malloc(sizeof(struct sCJhc__Prim___x3a));
            SETWHAT((struct sCJhc__Prim___x3a*)x68,CJhc__Prim___x3a);
            ((struct sCJhc__Prim___x3a*)x68)->a1 = v179578850;
            ((struct sCJhc__Prim___x3a*)x68)->a2 = v88762968;
            return x68;
        }
}

static sptr_t A_STD A_MALLOC
fForeign__Marshal__Array__pokeArray(sptr_t v1699877435,sptr_t v1703678525)
{
        sptr_t v54749794;
        uint32_t v150344458;
        jhc_function_inc();
        v150344458 = 0;
        v54749794 = v1703678525;
        fW_a__fForeign__Marshal__Array__61_uf_u89:;
        {   wptr_t v100056;
            sptr_t v131995836 = ((sptr_t)VALUE(v150344458));
            v100056 = eval(v54749794);
            jhc_case_inc();
            if (RAWWHAT(CJhc__Prim___x5b_x5d) == v100056) {
                v131995836;
            } else {
                wptr_t v100058;
                wptr_t v100060;
                sptr_t v168;
                sptr_t v170;
                uintptr_t v115580380;
                float v180865002;
                /* ("CJhc.Prim.:" ni168 ni170) */
                assert(CJhc__Prim___x3a == GETWHAT(v100056));
                v168 = ((struct sCJhc__Prim___x3a*)v100056)->a1;
                v170 = ((struct sCJhc__Prim___x3a*)v100056)->a2;
                v100058 = eval(v1699877435);
                v115580380 = ((struct sCJhc__Addr__Addr*)v100058)->a1;
                uint32_t v172787532 = (v150344458 * sizeof(float));
                (intptr_t)((int32_t)v172787532);
                uint32_t v45211620 = (v150344458 * sizeof(float));
                uintptr_t v218045016 = ((intptr_t)((int32_t)v45211620));
                uintptr_t v90582628 = (v115580380 + v218045016);
                v100060 = eval(v168);
                v180865002 = ((struct sCJhc__Float__Float*)v100060)->a1;
                *((float *)(v90582628)) = v180865002;
                uint32_t v90260176 = (1 + v150344458);
                v150344458 = v90260176;
                v54749794 = v170;
                goto fW_a__fForeign__Marshal__Array__61_uf_u89;
            }
        }
        return (sptr_t)RAWWHAT(CJhc__Basics___L_R);
}

static wptr_t A_STD A_MALLOC
fJhc__Basics__161_ug(sptr_t v210133554)
{
        wptr_t v100064;
        jhc_function_inc();
        v100064 = eval(v210133554);
        jhc_case_inc();
        if (RAWWHAT(CJhc__Prim___x5b_x5d) == v100064) {
            return v100064;
        } else {
            wptr_t v100066;
            sptr_t v204751208;
            sptr_t v31917812;
            /* ("CJhc.Prim.:" ni31917812 ni204751208) */
            assert(CJhc__Prim___x3a == GETWHAT(v100064));
            v31917812 = ((struct sCJhc__Prim___x3a*)v100064)->a1;
            v204751208 = ((struct sCJhc__Prim___x3a*)v100064)->a2;
            v100066 = eval(v31917812);
            jhc_case_inc();
            if (RAWWHAT(CJhc__Maybe__Nothing) == v100066) {
                sptr_t x40 = jhc_malloc(sizeof(struct sFJhc__Basics__161_ug));
                ((struct sFJhc__Basics__161_ug*)x40)->head = EVALFUNC(&jhc_ueval_ufJhc__Basics__161_ug);
                ((struct sFJhc__Basics__161_ug*)x40)->a1 = v204751208;
                sptr_t v341016 = EVALTAG(x40);
                return fJhc__Basics___p_p((sptr_t)RAWWHAT(CJhc__Prim___x5b_x5d),v341016);
            } else {
                sptr_t v150293938;
                /* ("CJhc.Maybe.Just" ni150293938) */
                assert(CJhc__Maybe__Just == GETWHAT(v100066));
                v150293938 = ((struct sCJhc__Maybe__Just*)v100066)->a1;
                sptr_t x41 = jhc_malloc(sizeof(struct sCJhc__Prim___x3a));
                SETWHAT((struct sCJhc__Prim___x3a*)x41,CJhc__Prim___x3a);
                ((struct sCJhc__Prim___x3a*)x41)->a1 = v150293938;
                ((struct sCJhc__Prim___x3a*)x41)->a2 = ((sptr_t)RAWWHAT(CJhc__Prim___x5b_x5d));
                sptr_t v230720128 = x41;
                sptr_t x42 = jhc_malloc(sizeof(struct sFJhc__Basics__161_ug));
                ((struct sFJhc__Basics__161_ug*)x42)->head = EVALFUNC(&jhc_ueval_ufJhc__Basics__161_ug);
                ((struct sFJhc__Basics__161_ug*)x42)->a1 = v204751208;
                sptr_t v27153122 = EVALTAG(x42);
                return fJhc__Basics___p_p(v230720128,v27153122);
            }
        }
}

static wptr_t A_STD A_MALLOC
fJhc__Basics___p_p(sptr_t v431,sptr_t v12)
{
        jhc_function_inc();
        return fR_a__fJhc__Basics___p_p(v431,v12);
}

static wptr_t A_STD A_MALLOC
fMain__147_ui(void)
{
        wptr_t v100194;
        jhc_function_inc();
        v100194 = fW_a__fInstance_a__iJhc__Enum__enumFromTo__Jhc__Prim__Int(0,229);
        sptr_t v140097148 = demote(v100194);
        return ftheMain_d4(v140097148);
}

static wptr_t A_STD A_MALLOC
fMain__findNearest(sptr_t v1168245787,sptr_t v237771584,sptr_t v142176834)
{
        wptr_t v100054;
        jhc_function_inc();
        sptr_t x20 = jhc_malloc(sizeof(struct sP1_utheMain_d8));
        SETWHAT((struct sP1_utheMain_d8*)x20,P1_utheMain_d8);
        ((struct sP1_utheMain_d8*)x20)->a1 = v237771584;
        ((struct sP1_utheMain_d8*)x20)->a2 = v142176834;
        sptr_t v1173226531 = x20;
        v100054 = fData__Maybe__mapMaybe(v1173226531,v1168245787);
        jhc_case_inc();
        if (RAWWHAT(CJhc__Prim___x5b_x5d) == v100054) {
            return RAWWHAT(CJhc__Maybe__Nothing);
        } else {
            sptr_t v247794026;
            sptr_t v74960714;
            /* ("CJhc.Prim.:" ni74960714 ni247794026) */
            assert(CJhc__Prim___x3a == GETWHAT(v100054));
            v74960714 = ((struct sCJhc__Prim___x3a*)v100054)->a1;
            v247794026 = ((struct sCJhc__Prim___x3a*)v100054)->a2;
            sptr_t x21 = jhc_malloc(sizeof(struct sFR_a__fJhc__Basics__foldl));
            ((struct sFR_a__fJhc__Basics__foldl*)x21)->head = EVALFUNC(&jhc_ueval_ufR_a__fJhc__Basics__foldl);
            ((struct sFR_a__fJhc__Basics__foldl*)x21)->a1 = v74960714;
            ((struct sFR_a__fJhc__Basics__foldl*)x21)->a2 = v247794026;
            sptr_t v67147168 = EVALTAG(x21);
            sptr_t x22 = jhc_malloc(sizeof(struct sFtheMain_d12));
            ((struct sFtheMain_d12*)x22)->head = EVALFUNC(&jhc_ueval_uftheMain_d12);
            ((struct sFtheMain_d12*)x22)->a1 = v237771584;
            ((struct sFtheMain_d12*)x22)->a2 = v142176834;
            ((struct sFtheMain_d12*)x22)->a3 = v67147168;
            sptr_t v246851826 = EVALTAG(x22);
            sptr_t x23 = jhc_malloc(sizeof(struct sFtheMain_d13));
            ((struct sFtheMain_d13*)x23)->head = EVALFUNC(&jhc_ueval_uftheMain_d13);
            ((struct sFtheMain_d13*)x23)->a1 = v67147168;
            sptr_t v1198523419 = EVALTAG(x23);
            sptr_t x24 = jhc_malloc(sizeof(struct sCJhc__Basics___L_c_R));
            ((struct sCJhc__Basics___L_c_R*)x24)->a1 = v1198523419;
            ((struct sCJhc__Basics___L_c_R*)x24)->a2 = v246851826;
            sptr_t v99369370 = x24;
            wptr_t x25 = jhc_malloc(sizeof(struct sCJhc__Maybe__Just));
            SETWHAT((struct sCJhc__Maybe__Just*)x25,CJhc__Maybe__Just);
            ((struct sCJhc__Maybe__Just*)x25)->a1 = v99369370;
            return x25;
        }
}

static wptr_t A_STD A_MALLOC
fPrelude___x5e(sptr_t v29751956,sptr_t v202592748)
{
        uintmax_t v11395938;
        jhc_function_inc();
        wptr_t v100102 = promote(v202592748);
        v11395938 = ((struct sCInteger_h*)v100102)->a1;
        jhc_case_inc();
        if (0 == v11395938) {
            wptr_t x76 = jhc_malloc_atomic(sizeof(struct sCJhc__Float__Float));
            ((struct sCJhc__Float__Float*)x76)->a1 = 1.0;
            return x76;
        } else {
            uint16_t v100104 = (((intmax_t)0) < ((intmax_t)v11395938));
            jhc_case_inc();
            if (0 == v100104) {
                jhc_error("Prelude.error: Prelude.^: negative exponent");
                return NULL;
            } else {
                sptr_t v159523458;
                sptr_t v257999526;
                uintmax_t v162404862;
                /* 1 */
                assert(1 == v100104);
                uintmax_t v42447366 = (v11395938 - 1);
                v257999526 = v29751956;
                v162404862 = v42447366;
                v159523458 = v29751956;
                fW_a__fR_a__fPrelude__28_uf_u77:;
                {   jhc_case_inc();
                    if (0 == v162404862) {
                        return eval(v159523458);
                    } else {
                        sptr_t v154141112;
                        uintmax_t v179803892;
                        v154141112 = v257999526;
                        v179803892 = v162404862;
                        fW_a__fPrelude__33_ug_u78:;
                        {   uintmax_t v100106 = (((intmax_t)v179803892) % ((intmax_t)2));
                            jhc_case_inc();
                            if (0 == v100106) {
                                sptr_t x79 = jhc_malloc(sizeof(struct sFPrelude___x5e_d2));
                                ((struct sFPrelude___x5e_d2*)x79)->head = EVALFUNC(&jhc_ueval_ufPrelude___x5e_d2);
                                ((struct sFPrelude___x5e_d2*)x79)->a1 = v154141112;
                                sptr_t v258031724 = EVALTAG(x79);
                                uintmax_t v70990018 = (((intmax_t)v179803892) / ((intmax_t)2));
                                v154141112 = v258031724;
                                v179803892 = v70990018;
                                goto fW_a__fPrelude__33_ug_u78;
                            } else {
                                sptr_t x80 = jhc_malloc(sizeof(struct sFPrelude___x5e_d3));
                                ((struct sFPrelude___x5e_d3*)x80)->head = EVALFUNC(&jhc_ueval_ufPrelude___x5e_d3);
                                ((struct sFPrelude___x5e_d3*)x80)->a1 = v154141112;
                                ((struct sFPrelude___x5e_d3*)x80)->a2 = v159523458;
                                sptr_t v232084378 = EVALTAG(x80);
                                uintmax_t v216015914 = (v179803892 - 1);
                                v257999526 = v154141112;
                                v162404862 = v216015914;
                                v159523458 = v232084378;
                                goto fW_a__fR_a__fPrelude__28_uf_u77;
                            }
                        }
                    }
                }
            }
        }
}

static wptr_t A_STD A_MALLOC
fPrelude___x5e_d2(sptr_t v211197114)
{
        wptr_t v100124;
        float v56826134;
        jhc_function_inc();
        v100124 = eval(v211197114);
        v56826134 = ((struct sCJhc__Float__Float*)v100124)->a1;
        float v38477510 = (v56826134 * v56826134);
        wptr_t x69 = jhc_malloc_atomic(sizeof(struct sCJhc__Float__Float));
        ((struct sCJhc__Float__Float*)x69)->a1 = v38477510;
        return x69;
}

static wptr_t A_STD A_MALLOC
fPrelude___x5e_d3(sptr_t v6963186,sptr_t v66802802)
{
        wptr_t v100126;
        wptr_t v100128;
        float v175474602;
        float v252720642;
        jhc_function_inc();
        v100126 = eval(v6963186);
        v100128 = eval(v66802802);
        v175474602 = ((struct sCJhc__Float__Float*)v100126)->a1;
        v252720642 = ((struct sCJhc__Float__Float*)v100128)->a1;
        float v157118584 = (v175474602 * v252720642);
        wptr_t x62 = jhc_malloc_atomic(sizeof(struct sCJhc__Float__Float));
        ((struct sCJhc__Float__Float*)x62)->a1 = v157118584;
        return x62;
}

static wptr_t A_STD A_MALLOC
fR_a__fJhc__Basics___p_p(sptr_t v148914806,sptr_t v107940062)
{
        wptr_t v100192;
        jhc_function_inc();
        v100192 = eval(v148914806);
        jhc_case_inc();
        if (RAWWHAT(CJhc__Prim___x5b_x5d) == v100192) {
            return eval(v107940062);
        } else {
            sptr_t v264590738;
            sptr_t v91757428;
            /* ("CJhc.Prim.:" ni91757428 ni264590738) */
            assert(CJhc__Prim___x3a == GETWHAT(v100192));
            v91757428 = ((struct sCJhc__Prim___x3a*)v100192)->a1;
            v264590738 = ((struct sCJhc__Prim___x3a*)v100192)->a2;
            sptr_t x44 = jhc_malloc(sizeof(struct sFR_a__fJhc__Basics___p_p));
            ((struct sFR_a__fJhc__Basics___p_p*)x44)->head = EVALFUNC(&jhc_ueval_ufR_a__fJhc__Basics___p_p);
            ((struct sFR_a__fJhc__Basics___p_p*)x44)->a1 = v264590738;
            ((struct sFR_a__fJhc__Basics___p_p*)x44)->a2 = v107940062;
            sptr_t v216966670 = EVALTAG(x44);
            wptr_t x45 = jhc_malloc(sizeof(struct sCJhc__Prim___x3a));
            SETWHAT((struct sCJhc__Prim___x3a*)x45,CJhc__Prim___x3a);
            ((struct sCJhc__Prim___x3a*)x45)->a1 = v91757428;
            ((struct sCJhc__Prim___x3a*)x45)->a2 = v216966670;
            return x45;
        }
}

static wptr_t A_STD A_MALLOC
fR_a__fJhc__Basics__foldl(sptr_t v192554778,sptr_t v154806006)
{
        wptr_t v100062;
        jhc_function_inc();
        v100062 = eval(v154806006);
        jhc_case_inc();
        if (RAWWHAT(CJhc__Prim___x5b_x5d) == v100062) {
            return eval(v192554778);
        } else {
            sptr_t v187172432;
            sptr_t v43021226;
            /* ("CJhc.Prim.:" ni187172432 ni43021226) */
            assert(CJhc__Prim___x3a == GETWHAT(v100062));
            v187172432 = ((struct sCJhc__Prim___x3a*)v100062)->a1;
            v43021226 = ((struct sCJhc__Prim___x3a*)v100062)->a2;
            sptr_t x88 = jhc_malloc(sizeof(struct sFtheMain_d11));
            ((struct sFtheMain_d11*)x88)->head = EVALFUNC(&jhc_ueval_uftheMain_d11);
            ((struct sFtheMain_d11*)x88)->a1 = v187172432;
            ((struct sFtheMain_d11*)x88)->a2 = v192554778;
            sptr_t v116252194 = EVALTAG(x88);
            return fR_a__fJhc__Basics__foldl(v116252194,v43021226);
        }
}

static wptr_t A_STD A_MALLOC
fW_a__fInstance_a__iJhc__Enum__enumFromTo__Jhc__Prim__Int(uint32_t v411439145,uint32_t v445912105)
{
        jhc_function_inc();
        return fW_a__fInstance_a__iJhc__Enum__enumFromTo__Jhc__Prim__Int_d2(v445912105,v411439145);
}

static wptr_t A_STD A_MALLOC
fW_a__fInstance_a__iJhc__Enum__enumFromTo__Jhc__Prim__Int_d2(uint32_t v228603538,uint32_t v12325748)
{
        jhc_function_inc();
        sptr_t v185159144 = ((sptr_t)VALUE(v12325748));
        uint16_t v100116 = (((int32_t)v12325748) > ((int32_t)v228603538));
        jhc_case_inc();
        if (0 == v100116) {
            uint32_t v78459564 = (1 + v12325748);
            sptr_t x71 = jhc_malloc(sizeof(struct sFW_a__fInstance_a__iJhc__Enum__enumFromTo__Jhc__Prim__Int_d2));
            ((struct sFW_a__fInstance_a__iJhc__Enum__enumFromTo__Jhc__Prim__Int_d2*)x71)->head = EVALFUNC(&jhc_ueval_ufW_a__fInstance_a__iJhc__Enum__enumFromTo__Jhc__Prim__Int_d2);
            ((struct sFW_a__fInstance_a__iJhc__Enum__enumFromTo__Jhc__Prim__Int_d2*)x71)->a1 = v228603538;
            ((struct sFW_a__fInstance_a__iJhc__Enum__enumFromTo__Jhc__Prim__Int_d2*)x71)->a2 = v78459564;
            sptr_t v106714296 = EVALTAG(x71);
            wptr_t x72 = jhc_malloc(sizeof(struct sCJhc__Prim___x3a));
            SETWHAT((struct sCJhc__Prim___x3a*)x72,CJhc__Prim___x3a);
            ((struct sCJhc__Prim___x3a*)x72)->a1 = v185159144;
            ((struct sCJhc__Prim___x3a*)x72)->a2 = v106714296;
            return x72;
        } else {
            /* 1 */
            assert(1 == v100116);
            return RAWWHAT(CJhc__Prim___x5b_x5d);
        }
}

static struct tup1 A_STD
fW_a__fR_a__fMain__trace(sptr_t v16520982,sptr_t v177931968,uint32_t v93759628)
{
        jhc_function_inc();
        jhc_case_inc();
        if (0 == v93759628) {
            struct tup1 _t2;
            return (_t2.t0 = 0.0,_t2.t1 = 0.0,_t2.t2 = 0.0,_t2);
        } else {
            wptr_t v100034;
            v100034 = fMain__findNearest(c12,v16520982,v177931968);
            jhc_case_inc();
            if (RAWWHAT(CJhc__Maybe__Nothing) == v100034) {
                struct tup1 _t3;
                return (_t3.t0 = 0.0,_t3.t1 = 0.0,_t3.t2 = 0.0,_t3);
            } else {
                wptr_t v100036;
                wptr_t v100038;
                wptr_t v100040;
                wptr_t v100042;
                wptr_t v100044;
                wptr_t v100046;
                wptr_t v100048;
                wptr_t v100052;
                sptr_t v102;
                sptr_t v104;
                sptr_t v180148344;
                sptr_t v257394384;
                sptr_t v404;
                sptr_t v406;
                struct tup1 _t4;
                float v100205570;
                float v188879608;
                float v194736638;
                float v195800234;
                float v21895932;
                float v22959528;
                float v263772434;
                float v266118254;
                float v49328736;
                float v93277462;
                struct tup1 x4;
                /* ("CJhc.Maybe.Just" ni102) */
                assert(CJhc__Maybe__Just == GETWHAT(v100034));
                v102 = ((struct sCJhc__Maybe__Just*)v100034)->a1;
                v100036 = eval(v102);
                v104 = ((struct sCJhc__Basics___L_c_R*)v100036)->a1;
                v180148344 = ((struct sCJhc__Basics___L_c_R*)v100036)->a2;
                v100038 = eval(v104);
                v257394384 = ((struct sCMain__Obj*)v100038)->a1;
                v404 = ((struct sCMain__Obj*)v100038)->a2;
                v406 = ((struct sCMain__Obj*)v100038)->a3;
                v100042 = eval(v404);
                v100040 = bapply_u16507(v100042,v180148344);
                v22959528 = ((struct sCMain__V3*)v100040)->a1;
                v195800234 = ((struct sCMain__V3*)v100040)->a2;
                v100205570 = ((struct sCMain__V3*)v100040)->a3;
                uint32_t v105944728 = (v93759628 - 1);
                sptr_t x2 = jhc_malloc(sizeof(struct sFtheMain_d27));
                ((struct sFtheMain_d27*)x2)->head = EVALFUNC(&jhc_ueval_uftheMain_d27);
                ((struct sFtheMain_d27*)x2)->a1 = v180148344;
                ((struct sFtheMain_d27*)x2)->a2 = v257394384;
                sptr_t v202937114 = EVALTAG(x2);
                sptr_t x3 = jhc_malloc(sizeof(struct sFtheMain_d28));
                ((struct sFtheMain_d28*)x3)->head = EVALFUNC(&jhc_ueval_uftheMain_d28);
                ((struct sFtheMain_d28*)x3)->a1 = v177931968;
                ((struct sFtheMain_d28*)x3)->a2 = v202937114;
                sptr_t v1331954717 = EVALTAG(x3);
                x4 = fW_a__fR_a__fMain__trace(v180148344,v1331954717,v105944728);
                v21895932 = x4.t0;
                v194736638 = x4.t1;
                v49328736 = x4.t2;
                v100046 = eval(v406);
                v100044 = bapply_u16507(v100046,v180148344);
                v263772434 = ((struct sCJhc__Float__Float*)v100044)->a1;
                float v148338210 = (v21895932 * v263772434);
                float v52743544 = (v194736638 * v263772434);
                float v225584250 = (v49328736 * v263772434);
                v100048 = ftheMain_d33(v180148344,v202937114,c21);
                sptr_t v1324745759 = demote(v100048);
                v100052 = ftheMain_d41(c22,v1324745759);
                v188879608 = ((struct sCMain__V3*)v100052)->a1;
                v93277462 = ((struct sCMain__V3*)v100052)->a2;
                v266118254 = ((struct sCMain__V3*)v100052)->a3;
                float v212296776 = (1.0 - v263772434);
                float v77145214 = (v188879608 * v212296776);
                float v249985920 = (v93277462 * v212296776);
                float v154383860 = (v266118254 * v212296776);
                float v213273884 = (v148338210 + v77145214);
                float v117679132 = (v52743544 + v249985920);
                float v22084468 = (v225584250 + v154383860);
                float v80974404 = (v22959528 * v213273884);
                float v253815196 = (v195800234 * v117679132);
                float v158220532 = (v100205570 * v22084468);
                return (_t4.t0 = v80974404,_t4.t1 = v253815196,_t4.t2 = v158220532,_t4);
            }
        }
}

static void A_STD
ftheMain(void)
{
        sptr_t v168510314;
        sptr_t v22795006;
        sptr_t v59394522;
        sptr_t v97020030;
        uintptr_t v140;
        jhc_function_inc();
        uintptr_t v84 = ((uintptr_t)malloc((size_t)((size_t)(158700 * sizeof(float)))));
        sptr_t x27 = jhc_malloc_atomic(sizeof(struct sCJhc__Addr__Addr));
        ((struct sCJhc__Addr__Addr*)x27)->a1 = v84;
        sptr_t v206617486 = x27;
        jhc_case_inc();
        if (0 == v84) {
            wptr_t v100000;
            sptr_t v174862238;
            v100000 = fJhc__Basics___p_p(c28,c43);
            sptr_t v217418110 = demote(v100000);
            v174862238 = v217418110;
            fR_a__fJhc__IO__putErrLn_u28:;
            {   wptr_t v100004;
                v100004 = eval(v174862238);
                jhc_case_inc();
                if (RAWWHAT(CJhc__Prim___x5b_x5d) == v100004) {
                    (void)jhc_utf8_putchar((int)10);
                } else {
                    wptr_t v100006;
                    sptr_t v38;
                    sptr_t v40;
                    uint32_t v163193222;
                    /* ("CJhc.Prim.:" ni38 ni40) */
                    assert(CJhc__Prim___x3a == GETWHAT(v100004));
                    v38 = ((struct sCJhc__Prim___x3a*)v100004)->a1;
                    v40 = ((struct sCJhc__Prim___x3a*)v100004)->a2;
                    v100006 = eval(v38);
                    v163193222 = ((uint32_t)GETVALUE(v100006));
                    (void)jhc_utf8_putchar((int)v163193222);
                    v174862238 = v40;
                    goto fR_a__fJhc__IO__putErrLn_u28;
                }
            }
            jhc_exit(255);
        } else {
            v168510314 = v206617486;
        }
        v22795006 = c49;
        fJhc__Monad__63_ugo_u29:;
        {   wptr_t v100014;
            v100014 = eval(v22795006);
            jhc_case_inc();
            if (RAWWHAT(CJhc__Prim___x5b_x5d) == v100014) {
            } else {
                wptr_t v100016;
                sptr_t v42;
                sptr_t v44;
                uint32_t v170987214;
                /* ("CJhc.Prim.:" ni42 ni44) */
                assert(CJhc__Prim___x3a == GETWHAT(v100014));
                v42 = ((struct sCJhc__Prim___x3a*)v100014)->a1;
                v44 = ((struct sCJhc__Prim___x3a*)v100014)->a2;
                v100016 = eval(v42);
                v170987214 = ((uint32_t)GETVALUE(v100016));
                (void)jhc_utf8_putchar((int)v170987214);
                v22795006 = v44;
                goto fJhc__Monad__63_ugo_u29;
            }
        }
        (void)jhc_utf8_putchar((int)10);
        v59394522 = v168510314;
        v97020030 = g1853235735;
        fR_a__fControl__Monad__foldM_u30:;
        {   wptr_t v100010;
            v100010 = eval(v97020030);
            jhc_case_inc();
            if (RAWWHAT(CJhc__Prim___x5b_x5d) == v100010) {
                v59394522;
            } else {
                wptr_t v100012;
                sptr_t v151830696;
                sptr_t v22;
                sptr_t v246580894;
                sptr_t v247425362;
                /* ("CJhc.Prim.:" ni246580894 ni22) */
                assert(CJhc__Prim___x3a == GETWHAT(v100010));
                v246580894 = ((struct sCJhc__Prim___x3a*)v100010)->a1;
                v22 = ((struct sCJhc__Prim___x3a*)v100010)->a2;
                v100012 = eval(v246580894);
                v247425362 = ((struct sCJhc__Basics___L_c_R*)v100012)->a1;
                v151830696 = ((struct sCJhc__Basics___L_c_R*)v100012)->a2;
                sptr_t x31 = jhc_malloc(sizeof(struct sFtheMain_d42));
                ((struct sFtheMain_d42*)x31)->head = EVALFUNC(&jhc_ueval_uftheMain_d42);
                ((struct sFtheMain_d42*)x31)->a1 = v247425362;
                ((struct sFtheMain_d42*)x31)->a2 = v151830696;
                sptr_t v56228552 = EVALTAG(x31);
                sptr_t x32 = jhc_malloc(sizeof(struct sFtheMain_d43));
                ((struct sFtheMain_d43*)x32)->head = EVALFUNC(&jhc_ueval_uftheMain_d43);
                ((struct sFtheMain_d43*)x32)->a1 = v56228552;
                sptr_t v229069342 = EVALTAG(x32);
                sptr_t x33 = jhc_malloc(sizeof(struct sFtheMain_d44));
                ((struct sFtheMain_d44*)x33)->head = EVALFUNC(&jhc_ueval_uftheMain_d44);
                ((struct sFtheMain_d44*)x33)->a1 = v229069342;
                sptr_t v1364722711 = EVALTAG(x33);
                sptr_t x34 = jhc_malloc(sizeof(struct sFtheMain_d45));
                ((struct sFtheMain_d45*)x34)->head = EVALFUNC(&jhc_ueval_uftheMain_d45);
                ((struct sFtheMain_d45*)x34)->a1 = v229069342;
                sptr_t v1366164503 = EVALTAG(x34);
                sptr_t x35 = jhc_malloc(sizeof(struct sCJhc__Prim___x3a));
                SETWHAT((struct sCJhc__Prim___x3a*)x35,CJhc__Prim___x3a);
                ((struct sCJhc__Prim___x3a*)x35)->a1 = v1366164503;
                ((struct sCJhc__Prim___x3a*)x35)->a2 = ((sptr_t)RAWWHAT(CJhc__Prim___x5b_x5d));
                sptr_t v176439796 = x35;
                sptr_t x36 = jhc_malloc(sizeof(struct sCJhc__Prim___x3a));
                SETWHAT((struct sCJhc__Prim___x3a*)x36,CJhc__Prim___x3a);
                ((struct sCJhc__Prim___x3a*)x36)->a1 = v1364722711;
                ((struct sCJhc__Prim___x3a*)x36)->a2 = v176439796;
                sptr_t v161249662 = x36;
                sptr_t x37 = jhc_malloc(sizeof(struct sFtheMain_d46));
                ((struct sFtheMain_d46*)x37)->head = EVALFUNC(&jhc_ueval_uftheMain_d46);
                ((struct sFtheMain_d46*)x37)->a1 = v229069342;
                sptr_t v1369965591 = EVALTAG(x37);
                sptr_t x38 = jhc_malloc(sizeof(struct sCJhc__Prim___x3a));
                SETWHAT((struct sCJhc__Prim___x3a*)x38,CJhc__Prim___x3a);
                ((struct sCJhc__Prim___x3a*)x38)->a1 = v1369965591;
                ((struct sCJhc__Prim___x3a*)x38)->a2 = v161249662;
                sptr_t v120713716 = x38;
                fForeign__Marshal__Array__pokeArray(v59394522,v120713716);
                sptr_t x39 = jhc_malloc(sizeof(struct sFtheMain_d47));
                ((struct sFtheMain_d47*)x39)->head = EVALFUNC(&jhc_ueval_uftheMain_d47);
                ((struct sFtheMain_d47*)x39)->a1 = v59394522;
                sptr_t v164471608 = EVALTAG(x39);
                v59394522 = v164471608;
                v97020030 = v22;
                goto fR_a__fControl__Monad__foldM_u30;
            }
        }
        wptr_t v100008 = promote(v168510314);
        v140 = ((struct sCJhc__Addr__Addr*)v100008)->a1;
        return (void)free((HsPtr)v140);
}

static wptr_t A_STD A_MALLOC
ftheMain_d10(sptr_t v178,float v63948308,float v64169428)
{
        wptr_t v100098;
        wptr_t v100100;
        float v115346514;
        float v38100472;
        jhc_function_inc();
        v100098 = fPrelude___x5e(v178,c51);
        sptr_t x73 = jhc_malloc_atomic(sizeof(struct sCJhc__Float__Float));
        ((struct sCJhc__Float__Float*)x73)->a1 = v63948308;
        sptr_t v1129186331 = x73;
        v100100 = fPrelude___x5e(v1129186331,c51);
        float v237010220 = sqrtf(v64169428);
        v38100472 = ((struct sCJhc__Float__Float*)v100098)->a1;
        v115346514 = ((struct sCJhc__Float__Float*)v100100)->a1;
        float v19744454 = (v38100472 - v115346514);
        float v1395744 = sqrtf(v19744454);
        float v60285766 = (v237010220 - v1395744);
        wptr_t x74 = jhc_malloc_atomic(sizeof(struct sCJhc__Float__Float));
        ((struct sCJhc__Float__Float*)x74)->a1 = v60285766;
        return x74;
}

static wptr_t A_STD A_MALLOC
ftheMain_d11(sptr_t v34,sptr_t v250400670)
{
        wptr_t v100136;
        wptr_t v100138;
        wptr_t v100140;
        wptr_t v100142;
        sptr_t v177984860;
        sptr_t v216141390;
        sptr_t v43300598;
        sptr_t v82390194;
        float v223724986;
        float v32535570;
        jhc_function_inc();
        v100136 = eval(v250400670);
        v177984860 = ((struct sCJhc__Basics___L_c_R*)v100136)->a1;
        v82390194 = ((struct sCJhc__Basics___L_c_R*)v100136)->a2;
        v100138 = eval(v82390194);
        v100140 = eval(v34);
        v43300598 = ((struct sCJhc__Basics___L_c_R*)v100140)->a1;
        v216141390 = ((struct sCJhc__Basics___L_c_R*)v100140)->a2;
        v100142 = eval(v216141390);
        v223724986 = ((struct sCJhc__Float__Float*)v100138)->a1;
        v32535570 = ((struct sCJhc__Float__Float*)v100142)->a1;
        uint16_t v100558 = (v223724986 == v32535570);
        jhc_case_inc();
        if (0 == v100558) {
            uint16_t v100146 = (v223724986 <= v32535570);
            jhc_case_inc();
            if (0 == v100146) {
                wptr_t x59 = jhc_malloc(sizeof(struct sCJhc__Basics___L_c_R));
                ((struct sCJhc__Basics___L_c_R*)x59)->a1 = v43300598;
                ((struct sCJhc__Basics___L_c_R*)x59)->a2 = v216141390;
                return x59;
            } else {
                /* 1 */
                assert(1 == v100146);
                wptr_t x60 = jhc_malloc(sizeof(struct sCJhc__Basics___L_c_R));
                ((struct sCJhc__Basics___L_c_R*)x60)->a1 = v177984860;
                ((struct sCJhc__Basics___L_c_R*)x60)->a2 = v82390194;
                return x60;
            }
        } else {
            /* 1 */
            assert(1 == v100558);
            wptr_t x61 = jhc_malloc(sizeof(struct sCJhc__Basics___L_c_R));
            ((struct sCJhc__Basics___L_c_R*)x61)->a1 = v177984860;
            ((struct sCJhc__Basics___L_c_R*)x61)->a2 = v82390194;
            return x61;
        }
}

static wptr_t A_STD A_MALLOC
ftheMain_d12(sptr_t v1169949723,sptr_t v1171653657,sptr_t v56837338)
{
        wptr_t v100148;
        wptr_t v100150;
        wptr_t v100152;
        wptr_t v100154;
        sptr_t v142;
        float v122939372;
        float v133151108;
        float v141295476;
        float v200185498;
        float v236890140;
        float v27344706;
        float v45693330;
        jhc_function_inc();
        v100148 = eval(v1169949723);
        v100150 = eval(v1171653657);
        v100152 = eval(v56837338);
        v142 = ((struct sCJhc__Basics___L_c_R*)v100152)->a2;
        v100154 = eval(v142);
        v236890140 = ((struct sCMain__V3*)v100148)->a1;
        v141295476 = ((struct sCMain__V3*)v100148)->a2;
        v45693330 = ((struct sCMain__V3*)v100148)->a3;
        v122939372 = ((struct sCMain__V3*)v100150)->a1;
        v27344706 = ((struct sCMain__V3*)v100150)->a2;
        v200185498 = ((struct sCMain__V3*)v100150)->a3;
        v133151108 = ((struct sCJhc__Float__Float*)v100154)->a1;
        float v114398450 = (v122939372 * v133151108);
        float v18803786 = (v27344706 * v133151108);
        float v191644492 = (v200185498 * v133151108);
        float v250534514 = (v236890140 + v114398450);
        float v154932454 = (v141295476 + v18803786);
        float v59337704 = (v45693330 + v191644492);
        wptr_t x57 = jhc_malloc_atomic(sizeof(struct sCMain__V3));
        ((struct sCMain__V3*)x57)->a1 = v250534514;
        ((struct sCMain__V3*)x57)->a2 = v154932454;
        ((struct sCMain__V3*)x57)->a3 = v59337704;
        return x57;
}

static wptr_t A_STD A_MALLOC
ftheMain_d13(sptr_t v1196164133)
{
        wptr_t v100156;
        sptr_t v146;
        jhc_function_inc();
        v100156 = eval(v1196164133);
        v146 = ((struct sCJhc__Basics___L_c_R*)v100156)->a1;
        return eval(v146);
}

static wptr_t A_STD A_MALLOC
ftheMain_d14(sptr_t u1)
{
        jhc_function_inc();
        wptr_t x15 = jhc_malloc_atomic(sizeof(struct sCJhc__Float__Float));
        ((struct sCJhc__Float__Float*)x15)->a1 = 0.5;
        return x15;
}

static wptr_t A_STD A_MALLOC
ftheMain_d16(sptr_t u1)
{
        jhc_function_inc();
        wptr_t x13 = jhc_malloc_atomic(sizeof(struct sCJhc__Float__Float));
        ((struct sCJhc__Float__Float*)x13)->a1 = 0.0;
        return x13;
}

static wptr_t A_STD A_MALLOC
ftheMain_d18(sptr_t u1)
{
        jhc_function_inc();
        wptr_t x10 = jhc_malloc_atomic(sizeof(struct sCJhc__Float__Float));
        ((struct sCJhc__Float__Float*)x10)->a1 = 0.6;
        return x10;
}

static wptr_t A_STD A_MALLOC
ftheMain_d19(sptr_t u1)
{
        jhc_function_inc();
        wptr_t x12 = jhc_malloc_atomic(sizeof(struct sCMain__V3));
        ((struct sCMain__V3*)x12)->a1 = (1.0 / 1.0);
        ((struct sCMain__V3*)x12)->a2 = (1.0 / 1.0);
        ((struct sCMain__V3*)x12)->a3 = (1.0 / 1.0);
        return x12;
}

static wptr_t A_STD A_MALLOC
ftheMain_d2(void)
{
        jhc_function_inc();
        return fW_a__fInstance_a__iJhc__Enum__enumFromTo__Jhc__Prim__Int(0,229);
}

static wptr_t A_STD A_MALLOC
ftheMain_d20(void)
{
        jhc_function_inc();
        float v96558538 = sinf(456.0 + (0.0 / 1.0));
        float v155448474 = (100.0 * v96558538);
        float v214338496 = (-50.0 + v155448474);
        wptr_t x7 = jhc_malloc_atomic(sizeof(struct sCMain__V3));
        ((struct sCMain__V3*)x7)->a1 = -50.0;
        ((struct sCMain__V3*)x7)->a2 = v214338496;
        ((struct sCMain__V3*)x7)->a3 = 100.0;
        return x7;
}

static wptr_t A_STD A_MALLOC
ftheMain_d21(void)
{
        jhc_function_inc();
        float v6904006 = sinf(0.0 / 1.0);
        float v207352616 = (30.0 * v6904006);
        float v266250034 = (100.0 - v207352616);
        wptr_t x8 = jhc_malloc_atomic(sizeof(struct sCJhc__Float__Float));
        ((struct sCJhc__Float__Float*)x8)->a1 = v266250034;
        return x8;
}

static wptr_t A_STD A_MALLOC
ftheMain_d27(sptr_t v163888928,sptr_t v402)
{
        wptr_t v100158;
        jhc_function_inc();
        v100158 = eval(v402);
        jhc_case_inc();
        if (CMain__Plane == GETWHAT(v100158)) {
            sptr_t v228;
            v228 = ((struct sCMain__Plane*)v100158)->a2;
            return eval(v228);
        } else {
            wptr_t v100160;
            wptr_t v100162;
            sptr_t v230;
            float v145691904;
            float v164047922;
            float v222937944;
            float v259642672;
            float v50097240;
            float v68453258;
            /* ("CMain.Sphere" ni230 ni0) */
            assert(CMain__Sphere == GETWHAT(v100158));
            v230 = ((struct sCMain__Sphere*)v100158)->a1;
            v100160 = eval(v163888928);
            v259642672 = ((struct sCMain__V3*)v100160)->a1;
            v164047922 = ((struct sCMain__V3*)v100160)->a2;
            v68453258 = ((struct sCMain__V3*)v100160)->a3;
            v100162 = eval(v230);
            v145691904 = ((struct sCMain__V3*)v100162)->a1;
            v50097240 = ((struct sCMain__V3*)v100162)->a2;
            v222937944 = ((struct sCMain__V3*)v100162)->a3;
            float v127343280 = (v259642672 - v145691904);
            float v31748530 = (v164047922 - v50097240);
            float v204581926 = (v68453258 - v222937944);
            float v45938464 = (v127343280 * v127343280);
            float v218771860 = (v31748530 * v31748530);
            float v123177110 = (v204581926 * v204581926);
            float v27582444 = (v45938464 + v218771860);
            float v200423150 = (v27582444 + v123177110);
            float v104828486 = sqrtf(v200423150);
            float v221591712 = (v127343280 / v104828486);
            float v125997048 = (v31748530 / v104828486);
            float v30394902 = (v204581926 / v104828486);
            wptr_t x55 = jhc_malloc_atomic(sizeof(struct sCMain__V3));
            ((struct sCMain__V3*)x55)->a1 = v221591712;
            ((struct sCMain__V3*)x55)->a2 = v125997048;
            ((struct sCMain__V3*)x55)->a3 = v30394902;
            return x55;
        }
}

static wptr_t A_STD A_MALLOC
ftheMain_d28(sptr_t v189354292,sptr_t v1330512919)
{
        wptr_t v100164;
        wptr_t v100166;
        float v14659292;
        float v169143980;
        float v187499998;
        float v246390020;
        float v73549316;
        float v91905334;
        jhc_function_inc();
        v100164 = eval(v189354292);
        v100166 = eval(v1330512919);
        v14659292 = ((struct sCMain__V3*)v100164)->a1;
        v187499998 = ((struct sCMain__V3*)v100164)->a2;
        v91905334 = ((struct sCMain__V3*)v100164)->a3;
        v169143980 = ((struct sCMain__V3*)v100166)->a1;
        v73549316 = ((struct sCMain__V3*)v100166)->a2;
        v246390020 = ((struct sCMain__V3*)v100166)->a3;
        float v24070358 = (v169143980 * v14659292);
        float v196911148 = (v73549316 * v187499998);
        float v101316398 = (v246390020 * v91905334);
        float v160206420 = (v24070358 + v196911148);
        float v64611756 = (v160206420 + v101316398);
        float v50213366 = (2.0 * v64611756);
        float v57409586 = (v169143980 * v50213366);
        float v230250378 = (v73549316 * v50213366);
        float v134655628 = (v246390020 * v50213366);
        float v193545650 = (v14659292 - v57409586);
        float v97950986 = (v187499998 - v230250378);
        float v2356234 = (v91905334 - v134655628);
        wptr_t x56 = jhc_malloc_atomic(sizeof(struct sCMain__V3));
        ((struct sCMain__V3*)x56)->a1 = v193545650;
        ((struct sCMain__V3*)x56)->a2 = v97950986;
        ((struct sCMain__V3*)x56)->a3 = v2356234;
        return x56;
}

static wptr_t A_STD A_MALLOC
ftheMain_d29(void)
{
        jhc_function_inc();
        float v25252714 = sinf(0.0 / 1.0);
        float v125354664 = (-100.0 * v25252714);
        float v137901450 = (v125354664 - 110.0);
        float v86080134 = sinf(0.0 / 1.0);
        float v144970156 = (6.0 * v86080134);
        float v51591782 = (17.0 + v144970156);
        wptr_t x6 = jhc_malloc_atomic(sizeof(struct sCMain__V3));
        ((struct sCMain__V3*)x6)->a1 = 75.0;
        ((struct sCMain__V3*)x6)->a2 = v137901450;
        ((struct sCMain__V3*)x6)->a3 = v51591782;
        return x6;
}

static wptr_t A_STD A_MALLOC
ftheMain_d3(sptr_t v20129050,sptr_t v75189798)
{
        wptr_t v100130;
        jhc_function_inc();
        v100130 = eval(v75189798);
        jhc_case_inc();
        if (RAWWHAT(CJhc__Prim___x5b_x5d) == v100130) {
            return v100130;
        } else {
            sptr_t v152428444;
            sptr_t v56833778;
            /* ("CJhc.Prim.:" ni152428444 ni56833778) */
            assert(CJhc__Prim___x3a == GETWHAT(v100130));
            v152428444 = ((struct sCJhc__Prim___x3a*)v100130)->a1;
            v56833778 = ((struct sCJhc__Prim___x3a*)v100130)->a2;
            sptr_t x63 = jhc_malloc(sizeof(struct sCJhc__Basics___L_c_R));
            ((struct sCJhc__Basics___L_c_R*)x63)->a1 = v152428444;
            ((struct sCJhc__Basics___L_c_R*)x63)->a2 = v20129050;
            sptr_t v229674570 = x63;
            sptr_t x64 = jhc_malloc(sizeof(struct sFtheMain_d3));
            ((struct sFtheMain_d3*)x64)->head = EVALFUNC(&jhc_ueval_uftheMain_d3);
            ((struct sFtheMain_d3*)x64)->a1 = v20129050;
            ((struct sFtheMain_d3*)x64)->a2 = v56833778;
            sptr_t v134079820 = EVALTAG(x64);
            wptr_t x65 = jhc_malloc(sizeof(struct sCJhc__Prim___x3a));
            SETWHAT((struct sCJhc__Prim___x3a*)x65,CJhc__Prim___x3a);
            ((struct sCJhc__Prim___x3a*)x65)->a1 = v229674570;
            ((struct sCJhc__Prim___x3a*)x65)->a2 = v134079820;
            return x65;
        }
}

static wptr_t A_STD A_MALLOC
ftheMain_d33(sptr_t v169612168,sptr_t v74017418,sptr_t v253662592)
{
        wptr_t v100018;
        jhc_function_inc();
        v100018 = eval(v253662592);
        jhc_case_inc();
        if (RAWWHAT(CJhc__Prim___x5b_x5d) == v100018) {
            return v100018;
        } else {
            sptr_t v235306574;
            sptr_t v241475864;
            /* ("CJhc.Prim.:" ni241475864 ni235306574) */
            assert(CJhc__Prim___x3a == GETWHAT(v100018));
            v241475864 = ((struct sCJhc__Prim___x3a*)v100018)->a1;
            v235306574 = ((struct sCJhc__Prim___x3a*)v100018)->a2;
            sptr_t x90 = jhc_malloc(sizeof(struct sFtheMain_d34));
            ((struct sFtheMain_d34*)x90)->head = EVALFUNC(&jhc_ueval_uftheMain_d34);
            ((struct sFtheMain_d34*)x90)->a1 = v169612168;
            ((struct sFtheMain_d34*)x90)->a2 = v241475864;
            ((struct sFtheMain_d34*)x90)->a3 = v74017418;
            sptr_t v139711910 = EVALTAG(x90);
            sptr_t x91 = jhc_malloc(sizeof(struct sFtheMain_d33));
            ((struct sFtheMain_d33*)x91)->head = EVALFUNC(&jhc_ueval_uftheMain_d33);
            ((struct sFtheMain_d33*)x91)->a1 = v169612168;
            ((struct sFtheMain_d33*)x91)->a2 = v74017418;
            ((struct sFtheMain_d33*)x91)->a3 = v235306574;
            sptr_t v44117158 = EVALTAG(x91);
            wptr_t x92 = jhc_malloc(sizeof(struct sCJhc__Prim___x3a));
            SETWHAT((struct sCJhc__Prim___x3a*)x92,CJhc__Prim___x3a);
            ((struct sCJhc__Prim___x3a*)x92)->a1 = v139711910;
            ((struct sCJhc__Prim___x3a*)x92)->a2 = v44117158;
            return x92;
        }
}

static wptr_t A_STD A_MALLOC
ftheMain_d34(sptr_t v86070426,sptr_t v62465782,sptr_t v176290140)
{
        wptr_t v100020;
        jhc_function_inc();
        v100020 = eval(v62465782);
        jhc_case_inc();
        if (CMain__AmbientLight == GETWHAT(v100020)) {
            sptr_t v132;
            v132 = ((struct sCMain__AmbientLight*)v100020)->a1;
            return eval(v132);
        } else {
            wptr_t v100022;
            sptr_t v170907794;
            sptr_t v75313128;
            /* ("CMain.PointLight" ni170907794 ni75313128) */
            assert(CMain__PointLight == GETWHAT(v100020));
            v170907794 = ((struct sCMain__PointLight*)v100020)->a1;
            v75313128 = ((struct sCMain__PointLight*)v100020)->a2;
            sptr_t x16 = jhc_malloc(sizeof(struct sFtheMain_d35));
            ((struct sFtheMain_d35*)x16)->head = EVALFUNC(&jhc_ueval_uftheMain_d35);
            ((struct sFtheMain_d35*)x16)->a1 = v86070426;
            ((struct sFtheMain_d35*)x16)->a2 = v170907794;
            sptr_t v248153834 = EVALTAG(x16);
            sptr_t x17 = jhc_malloc(sizeof(struct sFtheMain_d36));
            ((struct sFtheMain_d36*)x17)->head = EVALFUNC(&jhc_ueval_uftheMain_d36);
            ((struct sFtheMain_d36*)x17)->a1 = v86070426;
            ((struct sFtheMain_d36*)x17)->a2 = v170907794;
            sptr_t v152559170 = EVALTAG(x17);
            sptr_t x18 = jhc_malloc(sizeof(struct sFtheMain_d37));
            ((struct sFtheMain_d37*)x18)->head = EVALFUNC(&jhc_ueval_uftheMain_d37);
            ((struct sFtheMain_d37*)x18)->a1 = v75313128;
            ((struct sFtheMain_d37*)x18)->a2 = v152559170;
            ((struct sFtheMain_d37*)x18)->a3 = v248153834;
            ((struct sFtheMain_d37*)x18)->a4 = v176290140;
            sptr_t v1252131869 = EVALTAG(x18);
            v100022 = fMain__findNearest(c12,v86070426,v152559170);
            jhc_case_inc();
            if (RAWWHAT(CJhc__Maybe__Nothing) == v100022) {
                return eval(v1252131869);
            } else {
                wptr_t v100024;
                wptr_t v100026;
                wptr_t v100028;
                wptr_t v100030;
                sptr_t v126;
                sptr_t v130;
                float v176184828;
                float v194533452;
                float v21692746;
                float v252167474;
                float v253423474;
                float v80582770;
                float v98938788;
                /* ("CJhc.Maybe.Just" ni126) */
                assert(CJhc__Maybe__Just == GETWHAT(v100022));
                v126 = ((struct sCJhc__Maybe__Just*)v100022)->a1;
                v100024 = eval(v126);
                v130 = ((struct sCJhc__Basics___L_c_R*)v100024)->a2;
                v100026 = eval(v130);
                v21692746 = ((struct sCMain__V3*)v100026)->a1;
                v194533452 = ((struct sCMain__V3*)v100026)->a2;
                v98938788 = ((struct sCMain__V3*)v100026)->a3;
                v100028 = eval(v86070426);
                v176184828 = ((struct sCMain__V3*)v100028)->a1;
                v80582770 = ((struct sCMain__V3*)v100028)->a2;
                v253423474 = ((struct sCMain__V3*)v100028)->a3;
                float v157828810 = (v21692746 - v176184828);
                float v62234060 = (v194533452 - v80582770);
                float v235074852 = (v98938788 - v253423474);
                float v45077686 = (v157828810 * v157828810);
                float v217918390 = (v62234060 * v62234060);
                float v122323726 = (v235074852 * v235074852);
                float v26728976 = (v45077686 + v217918390);
                float v199562372 = (v26728976 + v122323726);
                float v103967622 = sqrtf(v199562372);
                v100030 = eval(v248153834);
                v252167474 = ((struct sCJhc__Float__Float*)v100030)->a1;
                uint16_t v100032 = (v103967622 < v252167474);
                jhc_case_inc();
                if (0 == v100032) {
                    return eval(v1252131869);
                } else {
                    /* 1 */
                    assert(1 == v100032);
                    wptr_t x19 = jhc_malloc_atomic(sizeof(struct sCMain__V3));
                    ((struct sCMain__V3*)x19)->a1 = 0.0;
                    ((struct sCMain__V3*)x19)->a2 = 0.0;
                    ((struct sCMain__V3*)x19)->a3 = 0.0;
                    return x19;
                }
            }
        }
}

static wptr_t A_STD A_MALLOC
ftheMain_d35(sptr_t v139590720,sptr_t v43995970)
{
        wptr_t v100168;
        wptr_t v100170;
        float v130547458;
        float v148896082;
        float v207786104;
        float v244490832;
        float v34945400;
        float v53301418;
        jhc_function_inc();
        v100168 = eval(v43995970);
        v100170 = eval(v139590720);
        v244490832 = ((struct sCMain__V3*)v100168)->a1;
        v148896082 = ((struct sCMain__V3*)v100168)->a2;
        v53301418 = ((struct sCMain__V3*)v100168)->a3;
        v130547458 = ((struct sCMain__V3*)v100170)->a1;
        v34945400 = ((struct sCMain__V3*)v100170)->a2;
        v207786104 = ((struct sCMain__V3*)v100170)->a3;
        float v112191440 = (v244490832 - v130547458);
        float v16596690 = (v148896082 - v34945400);
        float v189437480 = (v53301418 - v207786104);
        float v196778758 = (v112191440 * v112191440);
        float v12005140 = (v16596690 * v16596690);
        float v241574664 = (v189437480 * v189437480);
        float v202708818 = (v196778758 + v12005140);
        float v163842886 = (v202708818 + v241574664);
        float v124969556 = sqrtf(v163842886);
        wptr_t x53 = jhc_malloc_atomic(sizeof(struct sCJhc__Float__Float));
        ((struct sCJhc__Float__Float*)x53)->a1 = v124969556;
        return x53;
}

static wptr_t A_STD A_MALLOC
ftheMain_d36(sptr_t v106,sptr_t v74828324)
{
        wptr_t v100172;
        wptr_t v100174;
        float v152732752;
        float v171081376;
        float v229971398;
        float v266676126;
        float v57130694;
        float v75486712;
        jhc_function_inc();
        v100172 = eval(v74828324);
        v100174 = eval(v106);
        v266676126 = ((struct sCMain__V3*)v100172)->a1;
        v171081376 = ((struct sCMain__V3*)v100172)->a2;
        v75486712 = ((struct sCMain__V3*)v100172)->a3;
        v152732752 = ((struct sCMain__V3*)v100174)->a1;
        v57130694 = ((struct sCMain__V3*)v100174)->a2;
        v229971398 = ((struct sCMain__V3*)v100174)->a3;
        float v134376734 = (v266676126 - v152732752);
        float v38781984 = (v171081376 - v57130694);
        float v211622774 = (v75486712 - v229971398);
        float v58779830 = (v134376734 * v134376734);
        float v231620536 = (v38781984 * v38781984);
        float v136025872 = (v211622774 * v211622774);
        float v40423812 = (v58779830 + v231620536);
        float v213264518 = (v40423812 + v136025872);
        float v117669854 = sqrtf(v213264518);
        float v178430134 = (v134376734 / v117669854);
        float v82827988 = (v38781984 / v117669854);
        float v255668780 = (v211622774 / v117669854);
        wptr_t x54 = jhc_malloc_atomic(sizeof(struct sCMain__V3));
        ((struct sCMain__V3*)x54)->a1 = v178430134;
        ((struct sCMain__V3*)x54)->a2 = v82827988;
        ((struct sCMain__V3*)x54)->a3 = v255668780;
        return x54;
}

static wptr_t A_STD A_MALLOC
ftheMain_d37(sptr_t v247669114,sptr_t v1253966873,sptr_t v1255539739,sptr_t v229959050)
{
        wptr_t v100068;
        wptr_t v100070;
        wptr_t v100072;
        wptr_t v100074;
        float v138559436;
        float v175264164;
        float v193266670;
        float v20425964;
        float v214195964;
        float v234154100;
        float v252510204;
        float v61313394;
        float v79669414;
        float v97672006;
        jhc_function_inc();
        v100068 = eval(v247669114);
        v100070 = eval(v229959050);
        v100072 = eval(v1253966873);
        v100074 = fPrelude___x5e(v1255539739,c51);
        v20425964 = ((struct sCMain__V3*)v100068)->a1;
        v193266670 = ((struct sCMain__V3*)v100068)->a2;
        v97672006 = ((struct sCMain__V3*)v100068)->a3;
        v175264164 = ((struct sCMain__V3*)v100070)->a1;
        v79669414 = ((struct sCMain__V3*)v100070)->a2;
        v252510204 = ((struct sCMain__V3*)v100070)->a3;
        v61313394 = ((struct sCMain__V3*)v100072)->a1;
        v234154100 = ((struct sCMain__V3*)v100072)->a2;
        v138559436 = ((struct sCMain__V3*)v100072)->a3;
        float v42964686 = (v175264164 * v61313394);
        float v215798082 = (v79669414 * v234154100);
        float v120203418 = (v252510204 * v138559436);
        float v179093354 = (v42964686 + v215798082);
        float v83498688 = (v179093354 + v120203418);
        v214195964 = ((struct sCJhc__Float__Float*)v100074)->a1;
        float v118593904 = (v83498688 / v214195964);
        float v11885044 = (v20425964 * v118593904);
        float v184725750 = (v193266670 * v118593904);
        float v89131086 = (v97672006 * v118593904);
        wptr_t x75 = jhc_malloc_atomic(sizeof(struct sCMain__V3));
        ((struct sCMain__V3*)x75)->a1 = v11885044;
        ((struct sCMain__V3*)x75)->a2 = v184725750;
        ((struct sCMain__V3*)x75)->a3 = v89131086;
        return x75;
}

static wptr_t A_STD A_MALLOC
ftheMain_d38(void)
{
        jhc_function_inc();
        float v253433146 = sinf(0.0 / 1.0);
        float v17787372 = (-200.0 * v253433146);
        float v74178162 = (v17787372 - 200.0);
        wptr_t x5 = jhc_malloc_atomic(sizeof(struct sCMain__V3));
        ((struct sCMain__V3*)x5)->a1 = 175.0;
        ((struct sCMain__V3*)x5)->a2 = v74178162;
        ((struct sCMain__V3*)x5)->a3 = 10.0;
        return x5;
}

static wptr_t A_STD A_MALLOC
ftheMain_d4(sptr_t v211325860)
{
        wptr_t v100108;
        jhc_function_inc();
        v100108 = eval(v211325860);
        jhc_case_inc();
        if (RAWWHAT(CJhc__Prim___x5b_x5d) == v100108) {
            return v100108;
        } else {
            wptr_t v100110;
            sptr_t v192969842;
            sptr_t v211764266;
            /* ("CJhc.Prim.:" ni211764266 ni192969842) */
            assert(CJhc__Prim___x3a == GETWHAT(v100108));
            v211764266 = ((struct sCJhc__Prim___x3a*)v100108)->a1;
            v192969842 = ((struct sCJhc__Prim___x3a*)v100108)->a2;
            v100110 = ftheMain_d3(v211764266,g1850483221);
            sptr_t v97375092 = demote(v100110);
            sptr_t x43 = jhc_malloc(sizeof(struct sFtheMain_d4));
            ((struct sFtheMain_d4*)x43)->head = EVALFUNC(&jhc_ueval_uftheMain_d4);
            ((struct sFtheMain_d4*)x43)->a1 = v192969842;
            sptr_t v1780426 = EVALTAG(x43);
            return fJhc__Basics___p_p(v97375092,v1780426);
        }
}

static wptr_t A_STD A_MALLOC
ftheMain_d40(sptr_t v179870866,sptr_t v198219490)
{
        wptr_t v100176;
        wptr_t v100178;
        float v146958686;
        float v165314704;
        float v224204726;
        float v260909454;
        float v51364022;
        float v69720040;
        jhc_function_inc();
        v100176 = eval(v198219490);
        v100178 = eval(v179870866);
        v260909454 = ((struct sCMain__V3*)v100176)->a1;
        v165314704 = ((struct sCMain__V3*)v100176)->a2;
        v69720040 = ((struct sCMain__V3*)v100176)->a3;
        v146958686 = ((struct sCMain__V3*)v100178)->a1;
        v51364022 = ((struct sCMain__V3*)v100178)->a2;
        v224204726 = ((struct sCMain__V3*)v100178)->a3;
        float v128610062 = (v260909454 + v146958686);
        float v33015312 = (v165314704 + v51364022);
        float v205848708 = (v69720040 + v224204726);
        wptr_t x51 = jhc_malloc_atomic(sizeof(struct sCMain__V3));
        ((struct sCMain__V3*)x51)->a1 = v128610062;
        ((struct sCMain__V3*)x51)->a2 = v33015312;
        ((struct sCMain__V3*)x51)->a3 = v205848708;
        return x51;
}

static wptr_t A_STD A_MALLOC
ftheMain_d41(sptr_t v243793588,sptr_t v102624740)
{
        wptr_t v100114;
        jhc_function_inc();
        v100114 = eval(v102624740);
        jhc_case_inc();
        if (RAWWHAT(CJhc__Prim___x5b_x5d) == v100114) {
            return eval(v243793588);
        } else {
            sptr_t v133018802;
            sptr_t v238411242;
            /* ("CJhc.Prim.:" ni238411242 ni133018802) */
            assert(CJhc__Prim___x3a == GETWHAT(v100114));
            v238411242 = ((struct sCJhc__Prim___x3a*)v100114)->a1;
            v133018802 = ((struct sCJhc__Prim___x3a*)v100114)->a2;
            sptr_t x70 = jhc_malloc(sizeof(struct sFtheMain_d40));
            ((struct sFtheMain_d40*)x70)->head = EVALFUNC(&jhc_ueval_uftheMain_d40);
            ((struct sFtheMain_d40*)x70)->a1 = v238411242;
            ((struct sFtheMain_d40*)x70)->a2 = v243793588;
            sptr_t v1647728 = EVALTAG(x70);
            return ftheMain_d41(v1647728,v133018802);
        }
}

static wptr_t A_STD A_MALLOC
ftheMain_d42(sptr_t v91735138,sptr_t v264575842)
{
        wptr_t v100180;
        wptr_t v100182;
        uint32_t v115700494;
        uint32_t v54219136;
        jhc_function_inc();
        v100180 = eval(v91735138);
        v115700494 = ((uint32_t)GETVALUE(v100180));
        float v91167898 = ((float)((int32_t)v115700494));
        v100182 = eval(v264575842);
        v54219136 = ((uint32_t)GETVALUE(v100182));
        float v227059928 = ((float)((int32_t)v54219136));
        float v244289772 = (v91167898 - 115.0);
        float v34744338 = (v244289772 / 230.0);
        float v93634362 = (600.0 * v34744338);
        float v25253824 = (v227059928 - 115.0);
        float v84143760 = (v25253824 / 230.0);
        float v143033782 = (600.0 * v84143760);
        float v264305826 = (v93634362 * v93634362);
        float v168711160 = (v143033782 * v143033782);
        float v245949806 = (v264305826 + v168711160);
        float v150355142 = (250000.0 + v245949806);
        float v54760392 = sqrtf(v150355142);
        float v93078020 = (v93634362 / v54760392);
        float v265918724 = (v143033782 / v54760392);
        float v170324060 = (500.0 / v54760392);
        wptr_t x52 = jhc_malloc_atomic(sizeof(struct sCMain__V3));
        ((struct sCMain__V3*)x52)->a1 = v93078020;
        ((struct sCMain__V3*)x52)->a2 = v265918724;
        ((struct sCMain__V3*)x52)->a3 = v170324060;
        return x52;
}

static wptr_t A_STD A_MALLOC
ftheMain_d43(sptr_t v17109994)
{
        float v147774408;
        float v225020448;
        float v52179656;
        struct tup1 x48;
        jhc_function_inc();
        x48 = fW_a__fR_a__fMain__trace(c50,v17109994,7);
        v147774408 = x48.t0;
        v52179656 = x48.t1;
        v225020448 = x48.t2;
        wptr_t x49 = jhc_malloc_atomic(sizeof(struct sCMain__V3));
        ((struct sCMain__V3*)x49)->a1 = v147774408;
        ((struct sCMain__V3*)x49)->a2 = v52179656;
        ((struct sCMain__V3*)x49)->a3 = v225020448;
        return x49;
}

static wptr_t A_STD A_MALLOC
ftheMain_d44(sptr_t v59311016)
{
        wptr_t v100184;
        float v72;
        jhc_function_inc();
        v100184 = eval(v59311016);
        v72 = ((struct sCMain__V3*)v100184)->a2;
        wptr_t x50 = jhc_malloc_atomic(sizeof(struct sCJhc__Float__Float));
        ((struct sCJhc__Float__Float*)x50)->a1 = v72;
        return x50;
}

static wptr_t A_STD A_MALLOC
ftheMain_d45(sptr_t v229935430)
{
        wptr_t v100186;
        float v60;
        jhc_function_inc();
        v100186 = eval(v229935430);
        v60 = ((struct sCMain__V3*)v100186)->a3;
        wptr_t x46 = jhc_malloc_atomic(sizeof(struct sCJhc__Float__Float));
        ((struct sCJhc__Float__Float*)x46)->a1 = v60;
        return x46;
}

static wptr_t A_STD A_MALLOC
ftheMain_d46(sptr_t v1367606309)
{
        wptr_t v100188;
        float v154394606;
        jhc_function_inc();
        v100188 = eval(v1367606309);
        v154394606 = ((struct sCMain__V3*)v100188)->a1;
        wptr_t x47 = jhc_malloc_atomic(sizeof(struct sCJhc__Float__Float));
        ((struct sCJhc__Float__Float*)x47)->a1 = v154394606;
        return x47;
}

static wptr_t A_STD A_MALLOC
ftheMain_d47(sptr_t v109993702)
{
        wptr_t v100190;
        uintptr_t v37209198;
        jhc_function_inc();
        v100190 = eval(v109993702);
        v37209198 = ((struct sCJhc__Addr__Addr*)v100190)->a1;
        uintptr_t v18853094 = (v37209198 + ((intptr_t)((int32_t)(3 * sizeof(float)))));
        wptr_t x26 = jhc_malloc_atomic(sizeof(struct sCJhc__Addr__Addr));
        ((struct sCJhc__Addr__Addr*)x26)->a1 = v18853094;
        return x26;
}

static wptr_t A_STD A_MALLOC
ftheMain_d5(void)
{
        jhc_function_inc();
        float v20744856 = sqrtf((1.0 + ((-(1.0 / 5.0)) * (-(1.0 / 5.0)))) + ((-(1.0 / 5.0)) * (-(1.0 / 5.0))));
        float v111094646 = (1.0 / v20744856);
        float v87356196 = ((-(1.0 / 5.0)) / v20744856);
        float v63625226 = ((-(1.0 / 5.0)) / v20744856);
        wptr_t x11 = jhc_malloc_atomic(sizeof(struct sCMain__V3));
        ((struct sCMain__V3*)x11)->a1 = v111094646;
        ((struct sCMain__V3*)x11)->a2 = v87356196;
        ((struct sCMain__V3*)x11)->a3 = v63625226;
        return x11;
}

static wptr_t A_STD A_MALLOC
ftheMain_d6(sptr_t u1)
{
        jhc_function_inc();
        wptr_t x9 = jhc_malloc_atomic(sizeof(struct sCMain__V3));
        ((struct sCMain__V3*)x9)->a1 = (1.0 / 1.0);
        ((struct sCMain__V3*)x9)->a2 = (3.0 / 10.0);
        ((struct sCMain__V3*)x9)->a3 = (1.0 / 1.0);
        return x9;
}

static wptr_t A_STD A_MALLOC
ftheMain_d7(sptr_t u1)
{
        jhc_function_inc();
        wptr_t x14 = jhc_malloc_atomic(sizeof(struct sCMain__V3));
        ((struct sCMain__V3*)x14)->a1 = (1.0 / 5.0);
        ((struct sCMain__V3*)x14)->a2 = (1.0 / 1.0);
        ((struct sCMain__V3*)x14)->a3 = (1.0 / 5.0);
        return x14;
}

static wptr_t A_STD A_MALLOC
ftheMain_d8(sptr_t v78765330,sptr_t v251606036,sptr_t v102610400)
{
        wptr_t v100076;
        wptr_t v100078;
        sptr_t v179856526;
        sptr_t v257102568;
        sptr_t v84261776;
        jhc_function_inc();
        v100076 = eval(v102610400);
        v179856526 = ((struct sCMain__Obj*)v100076)->a1;
        v84261776 = ((struct sCMain__Obj*)v100076)->a2;
        v257102568 = ((struct sCMain__Obj*)v100076)->a3;
        v100078 = eval(v179856526);
        sptr_t x81 = jhc_malloc(sizeof(struct sCMain__Obj));
        ((struct sCMain__Obj*)x81)->a1 = v179856526;
        ((struct sCMain__Obj*)x81)->a2 = v84261776;
        ((struct sCMain__Obj*)x81)->a3 = v257102568;
        sptr_t v1177420825 = x81;
        jhc_case_inc();
        if (CMain__Plane == GETWHAT(v100078)) {
            wptr_t v100080;
            wptr_t v100082;
            sptr_t v168981484;
            sptr_t v88573032;
            float v142088104;
            float v160436728;
            float v237682768;
            float v256038788;
            float v46493354;
            float v83198082;
            v88573032 = ((struct sCMain__Plane*)v100078)->a1;
            v168981484 = ((struct sCMain__Plane*)v100078)->a2;
            v100080 = eval(v251606036);
            v83198082 = ((struct sCMain__V3*)v100080)->a1;
            v256038788 = ((struct sCMain__V3*)v100080)->a2;
            v160436728 = ((struct sCMain__V3*)v100080)->a3;
            v100082 = eval(v168981484);
            v237682768 = ((struct sCMain__V3*)v100082)->a1;
            v142088104 = ((struct sCMain__V3*)v100082)->a2;
            v46493354 = ((struct sCMain__V3*)v100082)->a3;
            float v47436650 = (v83198082 * v237682768);
            float v220270048 = (v256038788 * v142088104);
            float v124675296 = (v160436728 * v46493354);
            float v164832722 = (v47436650 + v220270048);
            float v223722744 = (v164832722 + v124675296);
            uint16_t v100084 = (0.0 <= v223722744);
            jhc_case_inc();
            if (0 == v100084) {
                sptr_t x82 = jhc_malloc(sizeof(struct sFtheMain_d9));
                ((struct sFtheMain_d9*)x82)->head = EVALFUNC(&jhc_ueval_uftheMain_d9);
                ((struct sFtheMain_d9*)x82)->a1 = v88573032;
                ((struct sFtheMain_d9*)x82)->a2 = v237682768;
                ((struct sFtheMain_d9*)x82)->a3 = v256038788;
                ((struct sFtheMain_d9*)x82)->a4 = v46493354;
                ((struct sFtheMain_d9*)x82)->a5 = v83198082;
                ((struct sFtheMain_d9*)x82)->a6 = v142088104;
                ((struct sFtheMain_d9*)x82)->a7 = v160436728;
                ((struct sFtheMain_d9*)x82)->a8 = v78765330;
                sptr_t v258847772 = EVALTAG(x82);
                sptr_t x83 = jhc_malloc(sizeof(struct sCJhc__Basics___L_c_R));
                ((struct sCJhc__Basics___L_c_R*)x83)->a1 = v1177420825;
                ((struct sCJhc__Basics___L_c_R*)x83)->a2 = v258847772;
                sptr_t v81213742 = x83;
                wptr_t x84 = jhc_malloc(sizeof(struct sCJhc__Maybe__Just));
                SETWHAT((struct sCJhc__Maybe__Just*)x84,CJhc__Maybe__Just);
                ((struct sCJhc__Maybe__Just*)x84)->a1 = v81213742;
                return x84;
            } else {
                /* 1 */
                assert(1 == v100084);
                return RAWWHAT(CJhc__Maybe__Nothing);
            }
        } else {
            wptr_t v100088;
            wptr_t v100090;
            wptr_t v100092;
            wptr_t v100119;
            sptr_t v141981084;
            sptr_t v95222160;
            float v108410658;
            float v148281356;
            float v204005408;
            float v240400696;
            float v243876020;
            float v31164616;
            float v340;
            float v342;
            float v344;
            float v71035314;
            /* ("CMain.Sphere" ni141981084 ni95222160) */
            assert(CMain__Sphere == GETWHAT(v100078));
            v141981084 = ((struct sCMain__Sphere*)v100078)->a1;
            v95222160 = ((struct sCMain__Sphere*)v100078)->a2;
            v100119 = eval(v78765330);
            v340 = ((struct sCMain__V3*)v100119)->a1;
            v342 = ((struct sCMain__V3*)v100119)->a2;
            v344 = ((struct sCMain__V3*)v100119)->a3;
            v100088 = eval(v251606036);
            v31164616 = ((struct sCMain__V3*)v100088)->a1;
            v204005408 = ((struct sCMain__V3*)v100088)->a2;
            v108410658 = ((struct sCMain__V3*)v100088)->a3;
            v100090 = eval(v141981084);
            v71035314 = ((struct sCMain__V3*)v100090)->a1;
            v243876020 = ((struct sCMain__V3*)v100090)->a2;
            v148281356 = ((struct sCMain__V3*)v100090)->a3;
            float v207171378 = (v71035314 - v340);
            float v111576628 = (v243876020 - v342);
            float v15974568 = (v148281356 - v344);
            float v82304412 = (v207171378 * v31164616);
            float v255137722 = (v111576628 * v204005408);
            float v159543058 = (v15974568 * v108410658);
            float v218433080 = (v82304412 + v255137722);
            float v122838330 = (v218433080 + v159543058);
            float v2058610 = (v31164616 * v122838330);
            float v174892006 = (v204005408 * v122838330);
            float v79297342 = (v108410658 * v122838330);
            float v96452186 = (v340 + v2058610);
            float v175907208 = (v342 + v174892006);
            float v255369624 = (v344 + v79297342);
            float v251188454 = (v96452186 - v71035314);
            float v155593790 = (v175907208 - v243876020);
            float v59999038 = (v255369624 - v148281356);
            float v5058372 = (v251188454 * v251188454);
            float v177899076 = (v155593790 * v155593790);
            float v139900314 = (v59999038 * v59999038);
            float v101034466 = (v5058372 + v177899076);
            float v62161140 = (v101034466 + v139900314);
            float v104330320 = sqrtf(v62161140);
            v100092 = eval(v95222160);
            v240400696 = ((struct sCJhc__Float__Float*)v100092)->a1;
            uint16_t v100094 = (v104330320 >= v240400696);
            jhc_case_inc();
            if (0 == v100094) {
                float v247080284 = (v96452186 - v340);
                float v151485534 = (v175907208 - v342);
                float v55883474 = (v255369624 - v344);
                float v126321488 = (v247080284 * v31164616);
                float v30726824 = (v151485534 * v204005408);
                float v203567528 = (v55883474 * v108410658);
                float v107972864 = (v126321488 + v30726824);
                float v12370718 = (v107972864 + v203567528);
                uint16_t v100096 = (0.0 >= v12370718);
                jhc_case_inc();
                if (0 == v100096) {
                    float v124588594 = (v96452186 - v340);
                    float v28993844 = (v175907208 - v342);
                    float v201827240 = (v255369624 - v344);
                    float v178120198 = (v124588594 * v124588594);
                    float v82518138 = (v28993844 * v28993844);
                    float v255358844 = (v201827240 * v201827240);
                    float v159764178 = (v178120198 + v82518138);
                    float v201795328 = (v159764178 + v255358844);
                    sptr_t x85 = jhc_malloc(sizeof(struct sFtheMain_d10));
                    ((struct sFtheMain_d10*)x85)->head = EVALFUNC(&jhc_ueval_uftheMain_d10);
                    ((struct sFtheMain_d10*)x85)->a1 = v95222160;
                    ((struct sFtheMain_d10*)x85)->a2 = v104330320;
                    ((struct sFtheMain_d10*)x85)->a3 = v201795328;
                    sptr_t v137524412 = EVALTAG(x85);
                    sptr_t x86 = jhc_malloc(sizeof(struct sCJhc__Basics___L_c_R));
                    ((struct sCJhc__Basics___L_c_R*)x86)->a1 = v1177420825;
                    ((struct sCJhc__Basics___L_c_R*)x86)->a2 = v137524412;
                    sptr_t v41929748 = x86;
                    wptr_t x87 = jhc_malloc(sizeof(struct sCJhc__Maybe__Just));
                    SETWHAT((struct sCJhc__Maybe__Just*)x87,CJhc__Maybe__Just);
                    ((struct sCJhc__Maybe__Just*)x87)->a1 = v41929748;
                    return x87;
                } else {
                    /* 1 */
                    assert(1 == v100096);
                    return RAWWHAT(CJhc__Maybe__Nothing);
                }
            } else {
                /* 1 */
                assert(1 == v100094);
                return RAWWHAT(CJhc__Maybe__Nothing);
            }
        }
}

static wptr_t A_STD A_MALLOC
ftheMain_d9(sptr_t v172,float v65785274,float v84141378,float v143031316,float v179736044,float v238626066,float v256974690,sptr_t v207463906)
{
        wptr_t v100132;
        wptr_t v100134;
        float v362;
        float v364;
        float v366;
        float v368;
        float v370;
        float v372;
        jhc_function_inc();
        v100132 = eval(v172);
        v100134 = eval(v207463906);
        v368 = ((struct sCMain__V3*)v100132)->a1;
        v370 = ((struct sCMain__V3*)v100132)->a2;
        v372 = ((struct sCMain__V3*)v100132)->a3;
        v362 = ((struct sCMain__V3*)v100134)->a1;
        v364 = ((struct sCMain__V3*)v100134)->a2;
        v366 = ((struct sCMain__V3*)v100134)->a3;
        float v133885386 = (v368 - v362);
        float v213340408 = (v370 - v364);
        float v24367370 = (v372 - v366);
        float v235368334 = (v133885386 * v65785274);
        float v139773670 = (v213340408 * v238626066);
        float v44178918 = (v24367370 * v143031316);
        float v217019710 = (v235368334 + v139773670);
        float v121424960 = (v217019710 + v44178918);
        float v172466210 = (v179736044 * v65785274);
        float v76871546 = (v84141378 * v238626066);
        float v249712250 = (v256974690 * v143031316);
        float v154117586 = (v172466210 + v76871546);
        float v58515440 = (v154117586 + v249712250);
        float v65697042 = (v121424960 / v58515440);
        wptr_t x58 = jhc_malloc_atomic(sizeof(struct sCJhc__Float__Float));
        ((struct sCJhc__Float__Float*)x58)->a1 = v65697042;
        return x58;
}

static wptr_t A_STD A_FALIGNED
jhc_ueval_ubap_u1_uData__Maybe__mapMaybe_d2_u100120(struct sBap_u1_uData__Maybe__mapMaybe_d2_u100120* arg)
{
        wptr_t r;
        r = bap_u1_uData__Maybe__mapMaybe_d2_u100120(arg->a1,arg->a2);
        update((sptr_t)arg,r);
        return r;
}

static wptr_t A_STD A_FALIGNED
jhc_ueval_ufData__Maybe__mapMaybe_d2(struct sFData__Maybe__mapMaybe_d2* arg)
{
        wptr_t r;
        r = fData__Maybe__mapMaybe_d2(arg->a1,arg->a2);
        update((sptr_t)arg,r);
        return r;
}

static wptr_t A_STD A_FALIGNED
jhc_ueval_ufJhc__Basics__161_ug(struct sFJhc__Basics__161_ug* arg)
{
        wptr_t r;
        r = fJhc__Basics__161_ug(arg->a1);
        update((sptr_t)arg,r);
        return r;
}

static wptr_t A_STD A_FALIGNED
jhc_ueval_ufMain__147_ui(struct sFMain__147_ui* arg)
{
        wptr_t r;
        r = fMain__147_ui();
        update((sptr_t)arg,r);
        return r;
}

static wptr_t A_STD A_FALIGNED
jhc_ueval_ufPrelude___x5e_d2(struct sFPrelude___x5e_d2* arg)
{
        wptr_t r;
        r = fPrelude___x5e_d2(arg->a1);
        update((sptr_t)arg,r);
        return r;
}

static wptr_t A_STD A_FALIGNED
jhc_ueval_ufPrelude___x5e_d3(struct sFPrelude___x5e_d3* arg)
{
        wptr_t r;
        r = fPrelude___x5e_d3(arg->a1,arg->a2);
        update((sptr_t)arg,r);
        return r;
}

static wptr_t A_STD A_FALIGNED
jhc_ueval_ufR_a__fJhc__Basics___p_p(struct sFR_a__fJhc__Basics___p_p* arg)
{
        wptr_t r;
        r = fR_a__fJhc__Basics___p_p(arg->a1,arg->a2);
        update((sptr_t)arg,r);
        return r;
}

static wptr_t A_STD A_FALIGNED
jhc_ueval_ufR_a__fJhc__Basics__foldl(struct sFR_a__fJhc__Basics__foldl* arg)
{
        wptr_t r;
        r = fR_a__fJhc__Basics__foldl(arg->a1,arg->a2);
        update((sptr_t)arg,r);
        return r;
}

static wptr_t A_STD A_FALIGNED
jhc_ueval_ufW_a__fInstance_a__iJhc__Enum__enumFromTo__Jhc__Prim__Int_d2(struct sFW_a__fInstance_a__iJhc__Enum__enumFromTo__Jhc__Prim__Int_d2* arg)
{
        wptr_t r;
        r = fW_a__fInstance_a__iJhc__Enum__enumFromTo__Jhc__Prim__Int_d2(arg->a1,arg->a2);
        update((sptr_t)arg,r);
        return r;
}

static wptr_t A_STD A_FALIGNED
jhc_ueval_uftheMain_d10(struct sFtheMain_d10* arg)
{
        wptr_t r;
        r = ftheMain_d10(arg->a1,arg->a2,arg->a3);
        update((sptr_t)arg,r);
        return r;
}

static wptr_t A_STD A_FALIGNED
jhc_ueval_uftheMain_d11(struct sFtheMain_d11* arg)
{
        wptr_t r;
        r = ftheMain_d11(arg->a1,arg->a2);
        update((sptr_t)arg,r);
        return r;
}

static wptr_t A_STD A_FALIGNED
jhc_ueval_uftheMain_d12(struct sFtheMain_d12* arg)
{
        wptr_t r;
        r = ftheMain_d12(arg->a1,arg->a2,arg->a3);
        update((sptr_t)arg,r);
        return r;
}

static wptr_t A_STD A_FALIGNED
jhc_ueval_uftheMain_d13(struct sFtheMain_d13* arg)
{
        wptr_t r;
        r = ftheMain_d13(arg->a1);
        update((sptr_t)arg,r);
        return r;
}

static wptr_t A_STD A_FALIGNED
jhc_ueval_uftheMain_d2(struct sFtheMain_d2* arg)
{
        wptr_t r;
        r = ftheMain_d2();
        update((sptr_t)arg,r);
        return r;
}

static wptr_t A_STD A_FALIGNED
jhc_ueval_uftheMain_d20(struct sFtheMain_d20* arg)
{
        wptr_t r;
        r = ftheMain_d20();
        update((sptr_t)arg,r);
        return r;
}

static wptr_t A_STD A_FALIGNED
jhc_ueval_uftheMain_d21(struct sFtheMain_d21* arg)
{
        wptr_t r;
        r = ftheMain_d21();
        update((sptr_t)arg,r);
        return r;
}

static wptr_t A_STD A_FALIGNED
jhc_ueval_uftheMain_d27(struct sFtheMain_d27* arg)
{
        wptr_t r;
        r = ftheMain_d27(arg->a1,arg->a2);
        update((sptr_t)arg,r);
        return r;
}

static wptr_t A_STD A_FALIGNED
jhc_ueval_uftheMain_d28(struct sFtheMain_d28* arg)
{
        wptr_t r;
        r = ftheMain_d28(arg->a1,arg->a2);
        update((sptr_t)arg,r);
        return r;
}

static wptr_t A_STD A_FALIGNED
jhc_ueval_uftheMain_d29(struct sFtheMain_d29* arg)
{
        wptr_t r;
        r = ftheMain_d29();
        update((sptr_t)arg,r);
        return r;
}

static wptr_t A_STD A_FALIGNED
jhc_ueval_uftheMain_d3(struct sFtheMain_d3* arg)
{
        wptr_t r;
        r = ftheMain_d3(arg->a1,arg->a2);
        update((sptr_t)arg,r);
        return r;
}

static wptr_t A_STD A_FALIGNED
jhc_ueval_uftheMain_d33(struct sFtheMain_d33* arg)
{
        wptr_t r;
        r = ftheMain_d33(arg->a1,arg->a2,arg->a3);
        update((sptr_t)arg,r);
        return r;
}

static wptr_t A_STD A_FALIGNED
jhc_ueval_uftheMain_d34(struct sFtheMain_d34* arg)
{
        wptr_t r;
        r = ftheMain_d34(arg->a1,arg->a2,arg->a3);
        update((sptr_t)arg,r);
        return r;
}

static wptr_t A_STD A_FALIGNED
jhc_ueval_uftheMain_d35(struct sFtheMain_d35* arg)
{
        wptr_t r;
        r = ftheMain_d35(arg->a1,arg->a2);
        update((sptr_t)arg,r);
        return r;
}

static wptr_t A_STD A_FALIGNED
jhc_ueval_uftheMain_d36(struct sFtheMain_d36* arg)
{
        wptr_t r;
        r = ftheMain_d36(arg->a1,arg->a2);
        update((sptr_t)arg,r);
        return r;
}

static wptr_t A_STD A_FALIGNED
jhc_ueval_uftheMain_d37(struct sFtheMain_d37* arg)
{
        wptr_t r;
        r = ftheMain_d37(arg->a1,arg->a2,arg->a3,arg->a4);
        update((sptr_t)arg,r);
        return r;
}

static wptr_t A_STD A_FALIGNED
jhc_ueval_uftheMain_d38(struct sFtheMain_d38* arg)
{
        wptr_t r;
        r = ftheMain_d38();
        update((sptr_t)arg,r);
        return r;
}

static wptr_t A_STD A_FALIGNED
jhc_ueval_uftheMain_d4(struct sFtheMain_d4* arg)
{
        wptr_t r;
        r = ftheMain_d4(arg->a1);
        update((sptr_t)arg,r);
        return r;
}

static wptr_t A_STD A_FALIGNED
jhc_ueval_uftheMain_d40(struct sFtheMain_d40* arg)
{
        wptr_t r;
        r = ftheMain_d40(arg->a1,arg->a2);
        update((sptr_t)arg,r);
        return r;
}

static wptr_t A_STD A_FALIGNED
jhc_ueval_uftheMain_d42(struct sFtheMain_d42* arg)
{
        wptr_t r;
        r = ftheMain_d42(arg->a1,arg->a2);
        update((sptr_t)arg,r);
        return r;
}

static wptr_t A_STD A_FALIGNED
jhc_ueval_uftheMain_d43(struct sFtheMain_d43* arg)
{
        wptr_t r;
        r = ftheMain_d43(arg->a1);
        update((sptr_t)arg,r);
        return r;
}

static wptr_t A_STD A_FALIGNED
jhc_ueval_uftheMain_d44(struct sFtheMain_d44* arg)
{
        wptr_t r;
        r = ftheMain_d44(arg->a1);
        update((sptr_t)arg,r);
        return r;
}

static wptr_t A_STD A_FALIGNED
jhc_ueval_uftheMain_d45(struct sFtheMain_d45* arg)
{
        wptr_t r;
        r = ftheMain_d45(arg->a1);
        update((sptr_t)arg,r);
        return r;
}

static wptr_t A_STD A_FALIGNED
jhc_ueval_uftheMain_d46(struct sFtheMain_d46* arg)
{
        wptr_t r;
        r = ftheMain_d46(arg->a1);
        update((sptr_t)arg,r);
        return r;
}

static wptr_t A_STD A_FALIGNED
jhc_ueval_uftheMain_d47(struct sFtheMain_d47* arg)
{
        wptr_t r;
        r = ftheMain_d47(arg->a1);
        update((sptr_t)arg,r);
        return r;
}

static wptr_t A_STD A_FALIGNED
jhc_ueval_uftheMain_d5(struct sFtheMain_d5* arg)
{
        wptr_t r;
        r = ftheMain_d5();
        update((sptr_t)arg,r);
        return r;
}

static wptr_t A_STD A_FALIGNED
jhc_ueval_uftheMain_d9(struct sFtheMain_d9* arg)
{
        wptr_t r;
        r = ftheMain_d9(arg->a1,arg->a2,arg->a3,arg->a4,arg->a5,arg->a6,arg->a7,arg->a8);
        update((sptr_t)arg,r);
        return r;
}



More information about the jhc mailing list