Ticket #8: IntEnum_code.c

char lhc_c_compile[] = "gcc '-std=gnu99' -D_GNU_SOURCE '-falign-functions=4' -ffast-math -Wshadow -Wextra -Wall -Wno-unused-parameter -o IntEnum IntEnum_code.c -fomit-frame-pointer -O3";
char lhc_command[] = "lhc --keep-tmp-files -dgrin -dcore-mangled -oIntEnum IntEnum.hs";
char lhc_version[] = "lhc 0.6.20081216 (zhu) compiled by ghc-6.8 on a i386 running linux";

/* HsFFI.h for lhc */

#ifndef _LHC_HSFFI_H
#define _LHC_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

// lhc_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 <assert.h>
#include <float.h>
#include <sys/times.h>
#include <setjmp.h>


// #define our options

#define _LHC_GC_NONE  0
#define _LHC_GC_BOEHM 1


#ifndef _LHC_GC
#define _LHC_GC _LHC_GC_NONE
#endif

#ifndef _LHC_PROFILE
#define _LHC_PROFILE 0
#endif

#ifndef _LHC_DEBUG
#ifdef NDEBUG
#define _LHC_DEBUG 0
#else
#define _LHC_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)))




// some default definitions

#define lhc_malloc_whnf lhc_malloc
#define lhc_malloc_suspension lhc_malloc
#define lhc_malloc_atomic lhc_malloc
#define lhc_malloc_atomic_whnf lhc_malloc_atomic
#define lhc_malloc_sanity(p,t) (1)

extern void _start,_end;

#if _LHC_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 /* _LHC_PROFILE */

#if _LHC_GC == _LHC_GC_BOEHM

#include <gc/gc.h>

#define lhc_malloc GC_malloc
#undef  lhc_malloc_atomic
#define lhc_malloc_atomic GC_malloc_atomic
#define lhc_free GC_free

static inline void lhc_malloc_init(void) { GC_INIT(); }
static inline void lhc_alloc_print_stats(void) { GC_dump(); }

#elif _LHC_GC == _LHC_GC_NONE

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

static char initial_chunk[LHC_MEM_CHUNK_SIZE];

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


static inline void
lhc_malloc_init(void) { return; }

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

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

static inline void * A_MALLOC
lhc_malloc_basic(size_t n) {
        n = ALIGN(sizeof(void *),n);
        if (n > (LHC_MEM_CHUNK_SIZE - mem_offset))
                lhc_malloc_grow();
        void *ret = lhc_current_chunk + mem_offset;
        mem_offset += n;
        return ret;
}


#if _LHC_DEBUG

#define lhc_malloc(n) lhc_malloc_debug(n,__LINE__,0)
#undef lhc_malloc_atomic
#define lhc_malloc_atomic(n) lhc_malloc_debug(n,__LINE__,1)

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

#else

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

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


#endif /* _LHC_DEBUG */

#endif /* _LHC_GC == _LHC_GC_BOEHM */





static void _amain(void);
static void lhc_arch_assert(void);
static int lhc_argc;
static char **lhc_argv;
static char *lhc_progname;
static jmp_buf lhc_uncaught;

static HsInt lhc_stdrnd[2] A_UNUSED = { 1 , 1 };

#if _LHC_PROFILE

static uintmax_t lhc_prof_function_calls;
static uintmax_t lhc_prof_case_statements;
static uintmax_t lhc_prof_updates;

#define lhc_update_inc()   lhc_prof_updates++
#define lhc_function_inc() lhc_prof_function_calls++
#define lhc_case_inc()     lhc_prof_case_statements++

#else

#define lhc_update_inc()    do { } while(0)
#define lhc_function_inc()  do { } while(0)
#define lhc_case_inc()      do { } while(0)

#endif

static void A_COLD
lhc_print_profile(void) {
        struct tms tm;
        times(&tm);
        if(!(_LHC_PROFILE || getenv("LHC_RTS_PROFILE"))) return;

        fprintf(stderr, "\n-----------------\n");
        fprintf(stderr, "Profiling: %s\n", lhc_progname);
        fprintf(stderr, "Command: %s\n", lhc_command);
        fprintf(stderr, "Complie: %s\n", lhc_c_compile);
        fprintf(stderr, "Version: %s\n\n", lhc_version);
        lhc_alloc_print_stats();
        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);

#if _LHC_PROFILE
        fprintf(stderr, "\nFunction Calls:   %llu\n", (unsigned long long)lhc_prof_function_calls);
        fprintf(stderr, "Case Statements:  %llu\n", (unsigned long long)lhc_prof_case_statements);
        fprintf(stderr, "Updates:          %llu\n", (unsigned long long)lhc_prof_updates);
#endif
        fprintf(stderr, "-----------------\n");
}


static void A_NORETURN A_UNUSED A_COLD
lhc_exit(int n) {
        lhc_print_profile();
        exit(n);
}

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

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

#define lhc_setjmp(jb) sigsetjmp(*(jmp_buf *)jb,0)
#define lhc_longjmp(jb) siglongjmp(*(jmp_buf *)jb,1)

struct lhc_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
lhc_utf8_getchar(void)
{
    return getchar_unlocked();
}

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

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

inline static int A_UNUSED
lhc_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);

        lhc_arch_assert();
        lhc_malloc_init();
        lhc_argc = argc - 1;
        lhc_argv = argv + 1;
        lhc_progname = argv[0];
        setlocale(LC_ALL,"");
        if (sigsetjmp(lhc_uncaught,0))
                lhc_error("Uncaught Exception");
        else
                _amain();
        lhc_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

Lhc 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 lhc 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 lhc 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 _LHC_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
lhc_valid_whnf(wptr_t s)
{
        return ((GETTAG(s) == P_VALUE) || ((GETTAG(s) == P_WHNF) && lhc_malloc_sanity(s,P_WHNF)));
}

static int A_UNUSED
lhc_valid_lazy(sptr_t s)
{
        if(lhc_valid_whnf((wptr_t)s))
                return 1;
        assert(GETTAG(s) == P_LAZY);
        node_t *ds = (sptr_t)DETAG(s);
        assert(lhc_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 lhc_valid_whnf((wptr_t)ds->head);
}


#else

#define lhc_valid_whnf(x) 1
#define lhc_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(lhc_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(lhc_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(lhc_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(lhc_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 _LHC_DEBUG
                        GETHEAD(ds) = BLACK_HOLE;
#endif
                        wptr_t r = (*fn)(NODEP(ds));
#if _LHC_DEBUG
                        assert(GETHEAD(ds) != BLACK_HOLE);
#endif
                        return r;
                }
                return (wptr_t)h;
        }
        assert(lhc_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)
{
        lhc_update_inc();
        assert(GETHEAD(thunk) == BLACK_HOLE);
        assert(!ISLAZY(new));
        GETHEAD(thunk) = (fptr_t)new;
}




static void
lhc_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>

enum {
    CLhc__Basics___L_R = 0,
    CLhc__Prim__Char = 0,
    CLhc__Prim___x3a = 0,
    CLhc__Prim___x5b_x5d = 1,
    P1_uLhc__Show__showsPrec_d4 = 0,
    P1_uLhc__Show__showsPrec_d5 = 1,
    TLhc__Prim__Int = 2,
    TLhc__Prim___x5b_x5d = 3
};
struct sBap_u1_uLhc__Show__showsPrec_u100016 A_ALIGNED;
struct sBap_u1_uLhc__Show__showsPrec_u100028 A_ALIGNED;
struct sCLhc__Prim___x3a A_ALIGNED;
struct sFLhc__Show__shows A_ALIGNED;
struct sFLhc__Show__showsPrec_d2 A_ALIGNED;
struct sFLhc__Show__showsPrec_d3 A_ALIGNED;
struct sFW_a__fLhc__Inst__Show__showWord A_ALIGNED;
struct sFtheMain_d2 A_ALIGNED;
struct sFtheMain_d3 A_ALIGNED;
struct sFtheMain_d4 A_ALIGNED;
struct sFtheMain_d5 A_ALIGNED;
struct sP1_uLhc__Show__showsPrec_d4 A_ALIGNED;
struct sP1_uLhc__Show__showsPrec_d5 A_ALIGNED;
struct sTLhc__Prim___x5b_x5d A_ALIGNED;

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

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

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

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

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

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

struct sFW_a__fLhc__Inst__Show__showWord {
    
    fptr_t head;
    sptr_t a2;
    uint32_t a1;
};

struct sFtheMain_d2 {
    
    fptr_t head;
    sptr_t a2;
    uint32_t a1;
};

struct sFtheMain_d3 {
    
    fptr_t head;
    uint32_t a1;
};

struct sFtheMain_d4 {
    
    fptr_t head;
};

struct sFtheMain_d5 {
    
    fptr_t head;
};

struct sP1_uLhc__Show__showsPrec_d4 {
    what_t what;
    uint32_t a1;
};

struct sP1_uLhc__Show__showsPrec_d5 {
    what_t what;
    uint32_t a1;
};

struct sTLhc__Prim___x5b_x5d {
    what_t what;
    wptr_t a1;
};

/* CAFS */
/* v-957878805 = (@hole)*/
static node_t _g957878805;
#define g957878805 (EVALTAGC(&_g957878805))

/* v-966922773 = (@hole)*/
static node_t _g966922773;
#define g966922773 (EVALTAGC(&_g966922773))

/* (HcNode TLhc.Prim.[] [Left ("TLhc.Prim.Int")],1) */
static const struct sTLhc__Prim___x5b_x5d _c1 = {.what = TLhc__Prim___x5b_x5d, .a1 = RAWWHAT(TLhc__Prim__Int)};
#define c1 ((sptr_t)&_c1)
/* (HcNode CLhc.Prim.: [Left &("CLhc.Prim.Char" 93),Left &("CLhc.Prim.[]")],2) */
static const struct sCLhc__Prim___x3a _c2 = {.what = CLhc__Prim___x3a, .a1 = (sptr_t)VALUE(']'), .a2 = (sptr_t)RAWWHAT(CLhc__Prim___x5b_x5d)};
#define c2 ((sptr_t)&_c2)
/* (HcNode CLhc.Prim.: [Left &("CLhc.Prim.Char" 91),Right 2],3) */
static const struct sCLhc__Prim___x3a _c3 = {.what = CLhc__Prim___x3a, .a1 = (sptr_t)VALUE('['), .a2 = c2};
#define c3 ((sptr_t)&_c3)
 void _amain(void) ;
static void b_umain(void) A_STD;
static wptr_t bap_u1_uLhc__Show__showsPrec_u100016(sptr_t v86,sptr_t v88) A_STD A_MALLOC;
static wptr_t bap_u1_uLhc__Show__showsPrec_u100028(sptr_t v87,sptr_t v89) A_STD A_MALLOC;
static wptr_t bapply_u12329(wptr_t v1,sptr_t v2) A_STD A_MALLOC;
static wptr_t fLhc__Show__shows(sptr_t v1559062240,sptr_t v1902233550) A_STD A_MALLOC;
static wptr_t fLhc__Show__showsPrec(wptr_t v1876430363,sptr_t v114079652,sptr_t v1989490482,sptr_t v1378948956) A_STD A_MALLOC;
static wptr_t fLhc__Show__showsPrec_d2(sptr_t v508,sptr_t v510) A_STD A_MALLOC;
static wptr_t fLhc__Show__showsPrec_d3(sptr_t v528,sptr_t v530) A_STD A_MALLOC;
static wptr_t fLhc__Show__showsPrec_d4(uint32_t v622,sptr_t v554) A_STD A_MALLOC;
static wptr_t fLhc__Show__showsPrec_d5(uint32_t v641,sptr_t v590) A_STD A_MALLOC;
static wptr_t fW_a__fLhc__Inst__Show__showWord(uint32_t v1368789043,sptr_t v1372065837) A_STD A_MALLOC;
static wptr_t fW_a__fR_a__fLhc__Inst__Show__showWord(uint32_t v1499950522,sptr_t v280340684) A_STD A_MALLOC;
static void ftheMain(void) A_STD;
static wptr_t ftheMain_d2(uint32_t v674,sptr_t v676) A_STD A_MALLOC;
static wptr_t ftheMain_d3(uint32_t v420) A_STD A_MALLOC;
static wptr_t ftheMain_d4(void) A_STD A_MALLOC;
static wptr_t ftheMain_d5(void) A_STD A_MALLOC;
static sptr_t ftheMain_d6(sptr_t v710) A_STD A_MALLOC;
static wptr_t lhc_ueval_ubap_u1_uLhc__Show__showsPrec_u100016(struct sBap_u1_uLhc__Show__showsPrec_u100016* arg) A_STD A_FALIGNED;
static wptr_t lhc_ueval_ubap_u1_uLhc__Show__showsPrec_u100028(struct sBap_u1_uLhc__Show__showsPrec_u100028* arg) A_STD A_FALIGNED;
static wptr_t lhc_ueval_ufLhc__Show__shows(struct sFLhc__Show__shows* arg) A_STD A_FALIGNED;
static wptr_t lhc_ueval_ufLhc__Show__showsPrec_d2(struct sFLhc__Show__showsPrec_d2* arg) A_STD A_FALIGNED;
static wptr_t lhc_ueval_ufLhc__Show__showsPrec_d3(struct sFLhc__Show__showsPrec_d3* arg) A_STD A_FALIGNED;
static wptr_t lhc_ueval_ufW_a__fLhc__Inst__Show__showWord(struct sFW_a__fLhc__Inst__Show__showWord* arg) A_STD A_FALIGNED;
static wptr_t lhc_ueval_uftheMain_d2(struct sFtheMain_d2* arg) A_STD A_FALIGNED;
static wptr_t lhc_ueval_uftheMain_d3(struct sFtheMain_d3* arg) A_STD A_FALIGNED;
static wptr_t lhc_ueval_uftheMain_d4(struct sFtheMain_d4* arg) A_STD A_FALIGNED;
static wptr_t lhc_ueval_uftheMain_d5(struct sFtheMain_d5* arg) A_STD A_FALIGNED;

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

static void A_STD
b_umain(void)
{
        
        lhc_function_inc();
        lhc_update_inc();
        ((struct sFtheMain_d4*)DETAG(g957878805))->head = EVALFUNC(&lhc_ueval_uftheMain_d4);
        lhc_update_inc();
        ((struct sFtheMain_d5*)DETAG(g966922773))->head = EVALFUNC(&lhc_ueval_uftheMain_d5);
        return ftheMain();
}

static wptr_t A_STD A_MALLOC
bap_u1_uLhc__Show__showsPrec_u100016(sptr_t v86,sptr_t v88)
{
        
        lhc_function_inc();
        wptr_t v100018 = promote(v86);
        return bapply_u12329(v100018,v88);
}

static wptr_t A_STD A_MALLOC
bap_u1_uLhc__Show__showsPrec_u100028(sptr_t v87,sptr_t v89)
{
        
        lhc_function_inc();
        wptr_t v100030 = promote(v87);
        return bapply_u12329(v100030,v89);
}

static wptr_t A_STD A_MALLOC
bapply_u12329(wptr_t v1,sptr_t v2)
{
        
        lhc_function_inc();
        lhc_case_inc();
        if (P1_uLhc__Show__showsPrec_d5 == GETWHAT(v1)) {
            uint32_t v3;
            v3 = ((struct sP1_uLhc__Show__showsPrec_d5*)v1)->a1;
            return fLhc__Show__showsPrec_d5(v3,v2);
        } else {
            uint32_t v7;
            /* ("P1_Lhc.Show.showsPrec$4" w7) */
            assert(P1_uLhc__Show__showsPrec_d4 == GETWHAT(v1));
            v7 = ((struct sP1_uLhc__Show__showsPrec_d4*)v1)->a1;
            return fLhc__Show__showsPrec_d4(v7,v2);
        }
}

static wptr_t A_STD A_MALLOC
fLhc__Show__shows(sptr_t v1559062240,sptr_t v1902233550)
{
        
        lhc_function_inc();
        return fLhc__Show__showsPrec(RAWWHAT(TLhc__Prim__Int),(sptr_t)VALUE(0),v1559062240,v1902233550);
}

static wptr_t A_STD A_MALLOC
fLhc__Show__showsPrec(wptr_t v1876430363,sptr_t v114079652,sptr_t v1989490482,sptr_t v1378948956)
{
        
        lhc_function_inc();
        lhc_case_inc();
        if (RAWWHAT(TLhc__Prim__Int) == v1876430363) {
            wptr_t v100008;
            uint32_t v671;
            
            v100008 = eval(v1989490482);
            v671 = ((uint32_t)GETVALUE(v100008));
            uint16_t v100010 = (v671 == prim_minbound(uint32_t));
            lhc_case_inc();
            if (0 == v100010) {
                
                uint16_t v100022 = (((int32_t)0) > ((int32_t)v671));
                lhc_case_inc();
                if (0 == v100022) {
                    
                    return fW_a__fLhc__Inst__Show__showWord(v671,v1378948956);
                } else {
                    uint32_t v586;
                    /* 1 */
                    assert(1 == v100022);
                    wptr_t v100024 = promote(v114079652);
                    v586 = ((uint32_t)GETVALUE(v100024));
                    sptr_t x6 = lhc_malloc_atomic(sizeof(struct sP1_uLhc__Show__showsPrec_d5));
                    SETWHAT((struct sP1_uLhc__Show__showsPrec_d5*)x6,P1_uLhc__Show__showsPrec_d5);
                    ((struct sP1_uLhc__Show__showsPrec_d5*)x6)->a1 = v671;
                    sptr_t v588 = x6;
                    uint16_t v100026 = (((int32_t)6) < ((int32_t)v586));
                    lhc_case_inc();
                    if (0 == v100026) {
                        
                        return fLhc__Show__showsPrec_d5(v671,v1378948956);
                    } else {
                        
                        /* 1 */
                        assert(1 == v100026);
                        sptr_t x7 = lhc_malloc(sizeof(struct sCLhc__Prim___x3a));
                        SETWHAT((struct sCLhc__Prim___x3a*)x7,CLhc__Prim___x3a);
                        ((struct sCLhc__Prim___x3a*)x7)->a1 = ((sptr_t)VALUE(')'));
                        ((struct sCLhc__Prim___x3a*)x7)->a2 = v1378948956;
                        sptr_t v598 = x7;
                        sptr_t x8 = lhc_malloc(sizeof(struct sBap_u1_uLhc__Show__showsPrec_u100028));
                        ((struct sBap_u1_uLhc__Show__showsPrec_u100028*)x8)->head = EVALFUNC(&lhc_ueval_ubap_u1_uLhc__Show__showsPrec_u100028);
                        ((struct sBap_u1_uLhc__Show__showsPrec_u100028*)x8)->a1 = v588;
                        ((struct sBap_u1_uLhc__Show__showsPrec_u100028*)x8)->a2 = v598;
                        sptr_t v600 = EVALTAG(x8);
                        wptr_t x9 = lhc_malloc(sizeof(struct sCLhc__Prim___x3a));
                        SETWHAT((struct sCLhc__Prim___x3a*)x9,CLhc__Prim___x3a);
                        ((struct sCLhc__Prim___x3a*)x9)->a1 = ((sptr_t)VALUE('('));
                        ((struct sCLhc__Prim___x3a*)x9)->a2 = v600;
                        return x9;
                    }
                }
            } else {
                uint32_t v550;
                /* 1 */
                assert(1 == v100010);
                wptr_t v100012 = promote(v114079652);
                v550 = ((uint32_t)GETVALUE(v100012));
                sptr_t x10 = lhc_malloc_atomic(sizeof(struct sP1_uLhc__Show__showsPrec_d4));
                SETWHAT((struct sP1_uLhc__Show__showsPrec_d4*)x10,P1_uLhc__Show__showsPrec_d4);
                ((struct sP1_uLhc__Show__showsPrec_d4*)x10)->a1 = v671;
                sptr_t v552 = x10;
                uint16_t v100014 = (((int32_t)6) < ((int32_t)v550));
                lhc_case_inc();
                if (0 == v100014) {
                    
                    return fLhc__Show__showsPrec_d4(v671,v1378948956);
                } else {
                    
                    /* 1 */
                    assert(1 == v100014);
                    sptr_t x11 = lhc_malloc(sizeof(struct sCLhc__Prim___x3a));
                    SETWHAT((struct sCLhc__Prim___x3a*)x11,CLhc__Prim___x3a);
                    ((struct sCLhc__Prim___x3a*)x11)->a1 = ((sptr_t)VALUE(')'));
                    ((struct sCLhc__Prim___x3a*)x11)->a2 = v1378948956;
                    sptr_t v578 = x11;
                    sptr_t x12 = lhc_malloc(sizeof(struct sBap_u1_uLhc__Show__showsPrec_u100016));
                    ((struct sBap_u1_uLhc__Show__showsPrec_u100016*)x12)->head = EVALFUNC(&lhc_ueval_ubap_u1_uLhc__Show__showsPrec_u100016);
                    ((struct sBap_u1_uLhc__Show__showsPrec_u100016*)x12)->a1 = v552;
                    ((struct sBap_u1_uLhc__Show__showsPrec_u100016*)x12)->a2 = v578;
                    sptr_t v580 = EVALTAG(x12);
                    wptr_t x13 = lhc_malloc(sizeof(struct sCLhc__Prim___x3a));
                    SETWHAT((struct sCLhc__Prim___x3a*)x13,CLhc__Prim___x3a);
                    ((struct sCLhc__Prim___x3a*)x13)->a1 = ((sptr_t)VALUE('('));
                    ((struct sCLhc__Prim___x3a*)x13)->a2 = v580;
                    return x13;
                }
            }
        } else {
            wptr_t v100006;
            /* ("TLhc.Prim.[]" nd0) */
            assert(TLhc__Prim___x5b_x5d == GETWHAT(v1876430363));
            
            v100006 = eval(v1989490482);
            lhc_case_inc();
            if (RAWWHAT(CLhc__Prim___x5b_x5d) == v100006) {
                
                return fLhc__Show__showsPrec_d3(c3,v1378948956);
            } else {
                sptr_t v498;
                sptr_t v500;
                /* ("CLhc.Prim.:" ni498 ni500) */
                assert(CLhc__Prim___x3a == GETWHAT(v100006));
                v498 = ((struct sCLhc__Prim___x3a*)v100006)->a1;
                v500 = ((struct sCLhc__Prim___x3a*)v100006)->a2;
                sptr_t x14 = lhc_malloc(sizeof(struct sFLhc__Show__showsPrec_d2));
                ((struct sFLhc__Show__showsPrec_d2*)x14)->head = EVALFUNC(&lhc_ueval_ufLhc__Show__showsPrec_d2);
                ((struct sFLhc__Show__showsPrec_d2*)x14)->a1 = v500;
                ((struct sFLhc__Show__showsPrec_d2*)x14)->a2 = v1378948956;
                sptr_t v502 = EVALTAG(x14);
                sptr_t x15 = lhc_malloc(sizeof(struct sFLhc__Show__shows));
                ((struct sFLhc__Show__shows*)x15)->head = EVALFUNC(&lhc_ueval_ufLhc__Show__shows);
                ((struct sFLhc__Show__shows*)x15)->a1 = v498;
                ((struct sFLhc__Show__shows*)x15)->a2 = v502;
                sptr_t v504 = EVALTAG(x15);
                wptr_t x16 = lhc_malloc(sizeof(struct sCLhc__Prim___x3a));
                SETWHAT((struct sCLhc__Prim___x3a*)x16,CLhc__Prim___x3a);
                ((struct sCLhc__Prim___x3a*)x16)->a1 = ((sptr_t)VALUE('['));
                ((struct sCLhc__Prim___x3a*)x16)->a2 = v504;
                return x16;
            }
        }
}

static wptr_t A_STD A_MALLOC
fLhc__Show__showsPrec_d2(sptr_t v508,sptr_t v510)
{
        wptr_t v100034;
        lhc_function_inc();
        
        v100034 = eval(v508);
        lhc_case_inc();
        if (RAWWHAT(CLhc__Prim___x5b_x5d) == v100034) {
            
            wptr_t x23 = lhc_malloc(sizeof(struct sCLhc__Prim___x3a));
            SETWHAT((struct sCLhc__Prim___x3a*)x23,CLhc__Prim___x3a);
            ((struct sCLhc__Prim___x3a*)x23)->a1 = ((sptr_t)VALUE(']'));
            ((struct sCLhc__Prim___x3a*)x23)->a2 = v510;
            return x23;
        } else {
            sptr_t v514;
            sptr_t v516;
            /* ("CLhc.Prim.:" ni514 ni516) */
            assert(CLhc__Prim___x3a == GETWHAT(v100034));
            v514 = ((struct sCLhc__Prim___x3a*)v100034)->a1;
            v516 = ((struct sCLhc__Prim___x3a*)v100034)->a2;
            sptr_t x24 = lhc_malloc(sizeof(struct sFLhc__Show__showsPrec_d2));
            ((struct sFLhc__Show__showsPrec_d2*)x24)->head = EVALFUNC(&lhc_ueval_ufLhc__Show__showsPrec_d2);
            ((struct sFLhc__Show__showsPrec_d2*)x24)->a1 = v516;
            ((struct sFLhc__Show__showsPrec_d2*)x24)->a2 = v510;
            sptr_t v518 = EVALTAG(x24);
            sptr_t x25 = lhc_malloc(sizeof(struct sFLhc__Show__shows));
            ((struct sFLhc__Show__shows*)x25)->head = EVALFUNC(&lhc_ueval_ufLhc__Show__shows);
            ((struct sFLhc__Show__shows*)x25)->a1 = v514;
            ((struct sFLhc__Show__shows*)x25)->a2 = v518;
            sptr_t v520 = EVALTAG(x25);
            wptr_t x26 = lhc_malloc(sizeof(struct sCLhc__Prim___x3a));
            SETWHAT((struct sCLhc__Prim___x3a*)x26,CLhc__Prim___x3a);
            ((struct sCLhc__Prim___x3a*)x26)->a1 = ((sptr_t)VALUE(','));
            ((struct sCLhc__Prim___x3a*)x26)->a2 = v520;
            return x26;
        }
}

static wptr_t A_STD A_MALLOC
fLhc__Show__showsPrec_d3(sptr_t v528,sptr_t v530)
{
        wptr_t v100036;
        lhc_function_inc();
        
        v100036 = eval(v528);
        lhc_case_inc();
        if (RAWWHAT(CLhc__Prim___x5b_x5d) == v100036) {
            
            return eval(v530);
        } else {
            sptr_t v534;
            sptr_t v536;
            /* ("CLhc.Prim.:" ni534 ni536) */
            assert(CLhc__Prim___x3a == GETWHAT(v100036));
            v534 = ((struct sCLhc__Prim___x3a*)v100036)->a1;
            v536 = ((struct sCLhc__Prim___x3a*)v100036)->a2;
            sptr_t x19 = lhc_malloc(sizeof(struct sFLhc__Show__showsPrec_d3));
            ((struct sFLhc__Show__showsPrec_d3*)x19)->head = EVALFUNC(&lhc_ueval_ufLhc__Show__showsPrec_d3);
            ((struct sFLhc__Show__showsPrec_d3*)x19)->a1 = v536;
            ((struct sFLhc__Show__showsPrec_d3*)x19)->a2 = v530;
            sptr_t v538 = EVALTAG(x19);
            wptr_t x20 = lhc_malloc(sizeof(struct sCLhc__Prim___x3a));
            SETWHAT((struct sCLhc__Prim___x3a*)x20,CLhc__Prim___x3a);
            ((struct sCLhc__Prim___x3a*)x20)->a1 = v534;
            ((struct sCLhc__Prim___x3a*)x20)->a2 = v538;
            return x20;
        }
}

static wptr_t A_STD A_MALLOC
fLhc__Show__showsPrec_d4(uint32_t v622,sptr_t v554)
{
        
        lhc_function_inc();
        sptr_t x21 = lhc_malloc(sizeof(struct sFW_a__fLhc__Inst__Show__showWord));
        ((struct sFW_a__fLhc__Inst__Show__showWord*)x21)->head = EVALFUNC(&lhc_ueval_ufW_a__fLhc__Inst__Show__showWord);
        ((struct sFW_a__fLhc__Inst__Show__showWord*)x21)->a1 = v622;
        ((struct sFW_a__fLhc__Inst__Show__showWord*)x21)->a2 = v554;
        sptr_t v556 = EVALTAG(x21);
        wptr_t x22 = lhc_malloc(sizeof(struct sCLhc__Prim___x3a));
        SETWHAT((struct sCLhc__Prim___x3a*)x22,CLhc__Prim___x3a);
        ((struct sCLhc__Prim___x3a*)x22)->a1 = ((sptr_t)VALUE('-'));
        ((struct sCLhc__Prim___x3a*)x22)->a2 = v556;
        return x22;
}

static wptr_t A_STD A_MALLOC
fLhc__Show__showsPrec_d5(uint32_t v641,sptr_t v590)
{
        
        lhc_function_inc();
        uint32_t v592 = (-((int32_t)v641));
        sptr_t x17 = lhc_malloc(sizeof(struct sFW_a__fLhc__Inst__Show__showWord));
        ((struct sFW_a__fLhc__Inst__Show__showWord*)x17)->head = EVALFUNC(&lhc_ueval_ufW_a__fLhc__Inst__Show__showWord);
        ((struct sFW_a__fLhc__Inst__Show__showWord*)x17)->a1 = v592;
        ((struct sFW_a__fLhc__Inst__Show__showWord*)x17)->a2 = v590;
        sptr_t v594 = EVALTAG(x17);
        wptr_t x18 = lhc_malloc(sizeof(struct sCLhc__Prim___x3a));
        SETWHAT((struct sCLhc__Prim___x3a*)x18,CLhc__Prim___x3a);
        ((struct sCLhc__Prim___x3a*)x18)->a1 = ((sptr_t)VALUE('-'));
        ((struct sCLhc__Prim___x3a*)x18)->a2 = v594;
        return x18;
}

static wptr_t A_STD A_MALLOC
fW_a__fLhc__Inst__Show__showWord(uint32_t v1368789043,sptr_t v1372065837)
{
        
        lhc_function_inc();
        return fW_a__fR_a__fLhc__Inst__Show__showWord(v1368789043,v1372065837);
}

static wptr_t A_STD A_MALLOC
fW_a__fR_a__fLhc__Inst__Show__showWord(uint32_t v1499950522,sptr_t v280340684)
{
        
        lhc_function_inc();
        uint32_t v752 = (v1499950522 / 10);
        uint32_t v762 = (v1499950522 % 10);
        uint32_t v1241062752 = (48 + v762);
        sptr_t v2192046 = ((sptr_t)VALUE(v1241062752));
        lhc_case_inc();
        if (0 == v752) {
            
            wptr_t x27 = lhc_malloc(sizeof(struct sCLhc__Prim___x3a));
            SETWHAT((struct sCLhc__Prim___x3a*)x27,CLhc__Prim___x3a);
            ((struct sCLhc__Prim___x3a*)x27)->a1 = v2192046;
            ((struct sCLhc__Prim___x3a*)x27)->a2 = v280340684;
            return x27;
        } else {
            
            sptr_t x28 = lhc_malloc(sizeof(struct sCLhc__Prim___x3a));
            SETWHAT((struct sCLhc__Prim___x3a*)x28,CLhc__Prim___x3a);
            ((struct sCLhc__Prim___x3a*)x28)->a1 = v2192046;
            ((struct sCLhc__Prim___x3a*)x28)->a2 = v280340684;
            sptr_t v1379012655 = x28;
            return fW_a__fR_a__fLhc__Inst__Show__showWord(v752,v1379012655);
        }
}

static void A_STD
ftheMain(void)
{
        wptr_t v100038;
        lhc_function_inc();
        
        v100038 = fLhc__Show__showsPrec(PROMOTE(c1),(sptr_t)VALUE(0),g966922773,(sptr_t)RAWWHAT(CLhc__Prim___x5b_x5d));
        sptr_t v442 = demote(v100038);
        ftheMain_d6(v442);
        return (void)lhc_utf8_putchar((int)10);
}

static wptr_t A_STD A_MALLOC
ftheMain_d2(uint32_t v674,sptr_t v676)
{
        
        lhc_function_inc();
        uint16_t v100042 = (((int32_t)0) >= ((int32_t)v674));
        lhc_case_inc();
        if (0 == v100042) {
            wptr_t v100044;
            
            v100044 = eval(v676);
            lhc_case_inc();
            if (RAWWHAT(CLhc__Prim___x5b_x5d) == v100044) {
                
                return v100044;
            } else {
                sptr_t v682;
                sptr_t v684;
                /* ("CLhc.Prim.:" ni682 ni684) */
                assert(CLhc__Prim___x3a == GETWHAT(v100044));
                v682 = ((struct sCLhc__Prim___x3a*)v100044)->a1;
                v684 = ((struct sCLhc__Prim___x3a*)v100044)->a2;
                uint32_t v686 = (v674 - 1);
                sptr_t x2 = lhc_malloc(sizeof(struct sFtheMain_d2));
                ((struct sFtheMain_d2*)x2)->head = EVALFUNC(&lhc_ueval_uftheMain_d2);
                ((struct sFtheMain_d2*)x2)->a1 = v686;
                ((struct sFtheMain_d2*)x2)->a2 = v684;
                sptr_t v688 = EVALTAG(x2);
                wptr_t x3 = lhc_malloc(sizeof(struct sCLhc__Prim___x3a));
                SETWHAT((struct sCLhc__Prim___x3a*)x3,CLhc__Prim___x3a);
                ((struct sCLhc__Prim___x3a*)x3)->a1 = v682;
                ((struct sCLhc__Prim___x3a*)x3)->a2 = v688;
                return x3;
            }
        } else {
            
            /* 1 */
            assert(1 == v100042);
            return RAWWHAT(CLhc__Prim___x5b_x5d);
        }
}

static wptr_t A_STD A_MALLOC
ftheMain_d3(uint32_t v420)
{
        
        lhc_function_inc();
        sptr_t v422 = ((sptr_t)VALUE(v420));
        uint16_t v100046 = (((int32_t)v420) <= ((int32_t)prim_maxbound(uint32_t)));
        lhc_case_inc();
        if (0 == v100046) {
            
            return RAWWHAT(CLhc__Prim___x5b_x5d);
        } else {
            
            /* 1 */
            assert(1 == v100046);
            uint32_t v428 = (v420 + (33554431 - 16777215));
            sptr_t x4 = lhc_malloc(sizeof(struct sFtheMain_d3));
            ((struct sFtheMain_d3*)x4)->head = EVALFUNC(&lhc_ueval_uftheMain_d3);
            ((struct sFtheMain_d3*)x4)->a1 = v428;
            sptr_t v430 = EVALTAG(x4);
            wptr_t x5 = lhc_malloc(sizeof(struct sCLhc__Prim___x3a));
            SETWHAT((struct sCLhc__Prim___x3a*)x5,CLhc__Prim___x3a);
            ((struct sCLhc__Prim___x3a*)x5)->a1 = v422;
            ((struct sCLhc__Prim___x3a*)x5)->a2 = v430;
            return x5;
        }
}

static wptr_t A_STD A_MALLOC
ftheMain_d4(void)
{
        
        lhc_function_inc();
        return ftheMain_d3(16777215);
}

static wptr_t A_STD A_MALLOC
ftheMain_d5(void)
{
        
        lhc_function_inc();
        return ftheMain_d2(257,g957878805);
}

static sptr_t A_STD A_MALLOC
ftheMain_d6(sptr_t v710)
{
        wptr_t v100048;
        lhc_function_inc();
        
        v100048 = eval(v710);
        lhc_case_inc();
        if (RAWWHAT(CLhc__Prim___x5b_x5d) == v100048) {
            
            return (sptr_t)RAWWHAT(CLhc__Basics___L_R);
        } else {
            wptr_t v100050;
            sptr_t v714;
            sptr_t v716;
            uint32_t v304;
            /* ("CLhc.Prim.:" ni714 ni716) */
            assert(CLhc__Prim___x3a == GETWHAT(v100048));
            v714 = ((struct sCLhc__Prim___x3a*)v100048)->a1;
            v716 = ((struct sCLhc__Prim___x3a*)v100048)->a2;
            
            v100050 = eval(v714);
            v304 = ((uint32_t)GETVALUE(v100050));
            (void)lhc_utf8_putchar((int)v304);
            return ftheMain_d6(v716);
        }
}

static wptr_t A_STD A_FALIGNED
lhc_ueval_ubap_u1_uLhc__Show__showsPrec_u100016(struct sBap_u1_uLhc__Show__showsPrec_u100016* arg)
{
        wptr_t r;
        r = bap_u1_uLhc__Show__showsPrec_u100016(arg->a1,arg->a2);
        update((sptr_t)arg,r);
        return r;
}

static wptr_t A_STD A_FALIGNED
lhc_ueval_ubap_u1_uLhc__Show__showsPrec_u100028(struct sBap_u1_uLhc__Show__showsPrec_u100028* arg)
{
        wptr_t r;
        r = bap_u1_uLhc__Show__showsPrec_u100028(arg->a1,arg->a2);
        update((sptr_t)arg,r);
        return r;
}

static wptr_t A_STD A_FALIGNED
lhc_ueval_ufLhc__Show__shows(struct sFLhc__Show__shows* arg)
{
        wptr_t r;
        r = fLhc__Show__shows(arg->a1,arg->a2);
        update((sptr_t)arg,r);
        return r;
}

static wptr_t A_STD A_FALIGNED
lhc_ueval_ufLhc__Show__showsPrec_d2(struct sFLhc__Show__showsPrec_d2* arg)
{
        wptr_t r;
        r = fLhc__Show__showsPrec_d2(arg->a1,arg->a2);
        update((sptr_t)arg,r);
        return r;
}

static wptr_t A_STD A_FALIGNED
lhc_ueval_ufLhc__Show__showsPrec_d3(struct sFLhc__Show__showsPrec_d3* arg)
{
        wptr_t r;
        r = fLhc__Show__showsPrec_d3(arg->a1,arg->a2);
        update((sptr_t)arg,r);
        return r;
}

static wptr_t A_STD A_FALIGNED
lhc_ueval_ufW_a__fLhc__Inst__Show__showWord(struct sFW_a__fLhc__Inst__Show__showWord* arg)
{
        wptr_t r;
        r = fW_a__fLhc__Inst__Show__showWord(arg->a1,arg->a2);
        update((sptr_t)arg,r);
        return r;
}

static wptr_t A_STD A_FALIGNED
lhc_ueval_uftheMain_d2(struct sFtheMain_d2* arg)
{
        wptr_t r;
        r = ftheMain_d2(arg->a1,arg->a2);
        update((sptr_t)arg,r);
        return r;
}

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

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

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