Import 2.3.16

[davej-history.git] / arch / ppc / kernel / prom.c

/*
 * $Id: prom.c,v 1.70 1999/08/25 21:26:08 cort Exp $
 *
 * Procedures for interfacing to the Open Firmware PROM on
 * Power Macintosh computers.
 *
 * In particular, we are interested in the device tree
 * and in using some of its services (exit, write to stdout).
 *
 * Paul Mackerras       August 1996.
 * Copyright (C) 1996 Paul Mackerras.
 */
#include <stdarg.h>
#include <linux/config.h>
#include <linux/kernel.h>
#include <linux/string.h>
#include <linux/init.h>
#include <linux/version.h>

#include <asm/init.h>
#include <asm/spinlock.h>
#include <asm/prom.h>
#include <asm/page.h>
#include <asm/processor.h>
#include <asm/irq.h>
#include <asm/io.h>
#include <asm/smp.h>
#include <asm/bootx.h>
#include <asm/system.h>

/*
 * Properties whose value is longer than this get excluded from our
 * copy of the device tree.  This way we don't waste space storing
 * things like "driver,AAPL,MacOS,PowerPC" properties.
 */
#define MAX_PROPERTY_LENGTH     1024

struct prom_args {
        const char *service;
        int nargs;
        int nret;
        void *args[10];
};

struct pci_address {
        unsigned a_hi;
        unsigned a_mid;
        unsigned a_lo;
};

struct pci_reg_property {
        struct pci_address addr;
        unsigned size_hi;
        unsigned size_lo;
};

struct pci_range {
        struct pci_address addr;
        unsigned phys;
        unsigned size_hi;
        unsigned size_lo;
};

struct isa_reg_property {
        unsigned space;
        unsigned address;
        unsigned size;
};

struct pci_intr_map {
        struct pci_address addr;
        unsigned dunno;
        phandle int_ctrler;
        unsigned intr;
};

typedef unsigned long interpret_func(struct device_node *, unsigned long);
static interpret_func interpret_pci_props;
static interpret_func interpret_dbdma_props;
static interpret_func interpret_isa_props;
static interpret_func interpret_macio_props;
static interpret_func interpret_root_props;

#ifndef FB_MAX                  /* avoid pulling in all of the fb stuff */
#define FB_MAX  8
#endif
char *prom_display_paths[FB_MAX] __initdata = { 0, };
unsigned int prom_num_displays = 0;
char *of_stdout_device = 0;

prom_entry prom = 0;
ihandle prom_chosen = 0, prom_stdout = 0;

extern char *klimit;
char *bootpath = 0;
char *bootdevice = 0;

unsigned int rtas_data = 0;   /* virtual pointer */
unsigned int rtas_entry = 0;  /* physical pointer */
unsigned int rtas_size = 0;
unsigned int old_rtas = 0;

static struct device_node *allnodes = 0;

static void clearscreen(void);
static void flushscreen(void);

#ifdef CONFIG_BOOTX_TEXT

static void drawchar(char c);
static void drawhex(unsigned long v);
static void drawstring(const char *c);
static void scrollscreen(void);

static void draw_byte(unsigned char c, long locX, long locY);
static void draw_byte_32(unsigned char *bits, unsigned long *base);
static void draw_byte_16(unsigned char *bits, unsigned long *base);
static void draw_byte_8(unsigned char *bits, unsigned long *base);

static long                             g_loc_X;
static long                             g_loc_Y;
static long                             g_max_loc_X;
static long                             g_max_loc_Y;

#define cmapsz  (16*256)

static unsigned char vga_font[cmapsz];

#endif


static void *call_prom(const char *service, int nargs, int nret, ...);
static void prom_exit(void);
static unsigned long copy_device_tree(unsigned long, unsigned long);
static unsigned long inspect_node(phandle, struct device_node *, unsigned long,
                                  unsigned long, struct device_node ***);
static unsigned long finish_node(struct device_node *, unsigned long,
                                 interpret_func *);
static void relocate_nodes(void);
static unsigned long check_display(unsigned long);
static int prom_next_node(phandle *);
static void *early_get_property(unsigned long, unsigned long, char *);

extern void enter_rtas(void *);
extern unsigned long reloc_offset(void);

extern char cmd_line[512];      /* XXX */
boot_infos_t *boot_infos = 0;   /* init it so it's in data segment not bss */

/*
 * prom_init() is called very early on, before the kernel text
 * and data have been mapped to KERNELBASE.  At this point the code
 * is running at whatever address it has been loaded at, so
 * references to extern and static variables must be relocated
 * explicitly.  The procedure reloc_offset() returns the address
 * we're currently running at minus the address we were linked at.
 * (Note that strings count as static variables.)
 *
 * Because OF may have mapped I/O devices into the area starting at
 * KERNELBASE, particularly on CHRP machines, we can't safely call
 * OF once the kernel has been mapped to KERNELBASE.  Therefore all
 * OF calls should be done within prom_init(), and prom_init()
 * and all routines called within it must be careful to relocate
 * references as necessary.
 *
 * Note that the bss is cleared *after* prom_init runs, so we have
 * to make sure that any static or extern variables it accesses
 * are put in the data segment.
 */
#define PTRRELOC(x)     ((typeof(x))((unsigned long)(x) + offset))
#define PTRUNRELOC(x)   ((typeof(x))((unsigned long)(x) - offset))
#define RELOC(x)        (*PTRRELOC(&(x)))

#define ALIGN(x) (((x) + sizeof(unsigned long)-1) & -sizeof(unsigned long))

/* Is boot-info compatible ? */
#define BOOT_INFO_IS_COMPATIBLE(bi)             ((bi)->compatible_version <= BOOT_INFO_VERSION)
#define BOOT_INFO_IS_V2_COMPATIBLE(bi)  ((bi)->version >= 2)
#define BOOT_INFO_IS_V4_COMPATIBLE(bi)  ((bi)->version >= 4)

__init
static void
prom_exit()
{
        struct prom_args args;
        unsigned long offset = reloc_offset();

        args.service = "exit";
        args.nargs = 0;
        args.nret = 0;
        RELOC(prom)(&args);
        for (;;)                        /* should never get here */
                ;
}

__init
void
prom_enter(void)
{
        struct prom_args args;
        unsigned long offset = reloc_offset();

        args.service = RELOC("enter");
        args.nargs = 0;
        args.nret = 0;
        RELOC(prom)(&args);
}

__init
static void *
call_prom(const char *service, int nargs, int nret, ...)
{
        va_list list;
        int i;
        unsigned long offset = reloc_offset();
        struct prom_args prom_args;

        prom_args.service = service;
        prom_args.nargs = nargs;
        prom_args.nret = nret;
        va_start(list, nret);
        for (i = 0; i < nargs; ++i)
                prom_args.args[i] = va_arg(list, void *);
        va_end(list);
        for (i = 0; i < nret; ++i)
                prom_args.args[i + nargs] = 0;
        RELOC(prom)(&prom_args);
        return prom_args.args[nargs];
}

__init
void
prom_print(const char *msg)
{
        const char *p, *q;
        unsigned long offset = reloc_offset();

        if (RELOC(prom_stdout) == 0)
        {
#ifdef CONFIG_BOOTX_TEXT
                if (RELOC(boot_infos) != 0)
                        drawstring(msg);
#endif
                return;
        }               
                

        for (p = msg; *p != 0; p = q) {
                for (q = p; *q != 0 && *q != '\n'; ++q)
                        ;
                if (q > p)
                        call_prom(RELOC("write"), 3, 1, RELOC(prom_stdout),
                                  p, q - p);
                if (*q != 0) {
                        ++q;
                        call_prom(RELOC("write"), 3, 1, RELOC(prom_stdout),
                                  RELOC("\r\n"), 2);
                }
        }
}

unsigned long smp_ibm_chrp_hack __initdata = 0;
unsigned long smp_chrp_cpu_nr __initdata = 1;

/*
 * We enter here early on, when the Open Firmware prom is still
 * handling exceptions and the MMU hash table for us.
 */
__init
void
prom_init(int r3, int r4, prom_entry pp)
{
#ifdef CONFIG_SMP       
        int i;
        phandle node;
        char type[16], *path;
#endif  
        unsigned long mem;
        ihandle prom_rtas;
        unsigned long offset = reloc_offset();
        int l;
        char *p, *d;

        /* check if we're apus, return if we are */
        if ( r3 == 0x61707573 )
                return;

        /* If we came here from BootX, clear the screen,
         * set up some pointers and return. */
        if (r3 == 0x426f6f58 && pp == NULL) {
                boot_infos_t *bi = (boot_infos_t *) r4;
                unsigned long space;
                unsigned long ptr, x;
                char *model;
#ifdef CONFIG_BOOTX_TEXT
                unsigned long flags;
#endif          

                RELOC(boot_infos) = PTRUNRELOC(bi);

                clearscreen();

#ifdef CONFIG_BOOTX_TEXT
                RELOC(g_loc_X) = 0;
                RELOC(g_loc_Y) = 0;
                RELOC(g_max_loc_X) = (bi->dispDeviceRect[2] - bi->dispDeviceRect[0]) / 8;
                RELOC(g_max_loc_Y) = (bi->dispDeviceRect[3] - bi->dispDeviceRect[1]) / 16;
                
                /* Test if boot-info is compatible. Done only in config CONFIG_BOOTX_TEXT since
                   there is nothing much we can do with an incompatible version, except display
                   a message and eventually hang the processor...
                   
                   I'll try to keep enough of boot-info compatible in the future to always allow
                   display of this message;
                */
                if (!BOOT_INFO_IS_COMPATIBLE(bi))
                        prom_print(RELOC(" !!! WARNING - Incompatible version of BootX !!!\n\n\n"));
                
                prom_print(RELOC("Welcome to Linux, kernel " UTS_RELEASE "\n"));
                prom_print(RELOC("\nstarted at       : 0x"));
                drawhex(reloc_offset() + KERNELBASE);
                prom_print(RELOC("\nlinked at        : 0x"));
                drawhex(KERNELBASE);
                prom_print(RELOC("\nframe buffer at  : 0x"));
                drawhex((unsigned long)bi->dispDeviceBase);
                prom_print(RELOC(" (phys), 0x"));
                drawhex((unsigned long)bi->logicalDisplayBase);
                prom_print(RELOC(" (log)"));
                prom_print(RELOC("\nMSR              : 0x"));
                __asm__ __volatile__ ("mfmsr %0" : "=r" ((flags)) : : "memory");
                drawhex(flags);
                prom_print(RELOC("\n\n"));
#endif
                /* Out of the #if/#endif since it flushes the clearscreen too */
                flushscreen();
                
                /* New BootX enters kernel with MMU off, i/os are not allowed
                   here. This hack will have been done by the boostrap anyway.
                 */
                if (bi->version < 4) {
                        /*
                         * XXX If this is an iMac, turn off the USB controller.
                         */
                        model = (char *) early_get_property
                                (r4 + bi->deviceTreeOffset, 4, RELOC("model"));
                        if (model
                            && (strcmp(model, RELOC("iMac,1")) == 0
                                || strcmp(model, RELOC("PowerMac1,1")) == 0)) {
                                out_le32((unsigned *)0x80880008, 1);    /* XXX */
                        }
                }
                
                space = bi->deviceTreeOffset + bi->deviceTreeSize;
                if (bi->ramDisk)
                        space = bi->ramDisk + bi->ramDiskSize;
                RELOC(klimit) = PTRUNRELOC((char *) bi + space);

                /* New BootX will have flushed all TLBs and enters kernel with
                   MMU switched OFF, so this should not be useful anymore.
                 */
                if (bi->version < 4) {
                        /*
                         * Touch each page to make sure the PTEs for them
                         * are in the hash table - the aim is to try to avoid
                         * getting DSI exceptions while copying the kernel image.
                         */
                        for (ptr = (KERNELBASE + offset) & PAGE_MASK;
                             ptr < (unsigned long)bi + space; ptr += PAGE_SIZE)
                                x = *(volatile unsigned long *)ptr;
                }
                
#ifdef CONFIG_BOOTX_TEXT
                prom_print(RELOC("booting...\n"));
                flushscreen();
#endif
                return;
        }

        /* check if we're prep, return if we are */
        if ( *(unsigned long *)(0) == 0xdeadc0de )
                return;

        /* First get a handle for the stdout device */
        RELOC(prom) = pp;
        RELOC(prom_chosen) = call_prom(RELOC("finddevice"), 1, 1,
                                       RELOC("/chosen"));
        if (RELOC(prom_chosen) == (void *)-1)
                prom_exit();
        if ((int) call_prom(RELOC("getprop"), 4, 1, RELOC(prom_chosen),
                            RELOC("stdout"), &RELOC(prom_stdout),
                            sizeof(prom_stdout)) <= 0)
                prom_exit();

        /* Get the full OF pathname of the stdout device */
        mem = (unsigned long) RELOC(klimit) + offset;
        p = (char *) mem;
        memset(p, 0, 256);
        call_prom(RELOC("instance-to-path"), 3, 1, RELOC(prom_stdout), p, 255);
        RELOC(of_stdout_device) = PTRUNRELOC(p);
        mem += strlen(p) + 1;

        /* Get the boot device and translate it to a full OF pathname. */
        p = (char *) mem;
        l = (int) call_prom(RELOC("getprop"), 4, 1, RELOC(prom_chosen),
                            RELOC("bootpath"), p, 1<<20);
        if (l > 0) {
                p[l] = 0;       /* should already be null-terminated */
                RELOC(bootpath) = PTRUNRELOC(p);
                mem += l + 1;
                d = (char *) mem;
                *d = 0;
                call_prom(RELOC("canon"), 3, 1, p, d, 1<<20);
                RELOC(bootdevice) = PTRUNRELOC(d);
                mem = ALIGN(mem + strlen(d) + 1);
        }

        mem = check_display(mem);

        prom_print(RELOC("copying OF device tree..."));
        mem = copy_device_tree(mem, mem + (1<<20));
        prom_print(RELOC("done\n"));


        RELOC(klimit) = (char *) (mem - offset);
        
        prom_rtas = call_prom(RELOC("finddevice"), 1, 1, RELOC("/rtas"));
        if (prom_rtas != (void *) -1) {
                RELOC(rtas_size) = 0;
                call_prom(RELOC("getprop"), 4, 1, prom_rtas,
                          RELOC("rtas-size"), &RELOC(rtas_size), sizeof(rtas_size));
                prom_print(RELOC("instantiating rtas..."));
                if (RELOC(rtas_size) == 0) {
                        RELOC(rtas_data) = 0;
                } else {
                        /*
                         * We do _not_ want the rtas_data inside the klimit
                         * boundry since it'll be squashed when we do the
                         * relocate of the kernel on chrp right after prom_init()
                         * in head.S.  So, we just pick a spot in memory.
                         * -- Cort
                         */
#if 0
                        mem = (mem + 4095) & -4096;
                        RELOC(rtas_data) = mem + KERNELBASE;
                        mem += RELOC(rtas_size);
#endif
                        RELOC(rtas_data) = (6<<20) + KERNELBASE;
                }
                prom_rtas = call_prom(RELOC("open"), 1, 1, RELOC("/rtas"));
                {
                        int i, nargs;
                        struct prom_args prom_args;
                        nargs = 3;
                        prom_args.service = RELOC("call-method");
                        prom_args.nargs = nargs;
                        prom_args.nret = 2;
                        prom_args.args[0] = RELOC("instantiate-rtas");
                        prom_args.args[1] = prom_rtas;
                        prom_args.args[2] = ((void *)(RELOC(rtas_data)-KERNELBASE));
                        RELOC(prom)(&prom_args);
                        if (prom_args.args[nargs] != 0)
                                i = 0;
                        else
                                i = (int)prom_args.args[nargs+1];
                        RELOC(rtas_entry) = i;
                }
                if ((RELOC(rtas_entry) == -1) || (RELOC(rtas_entry) == 0))
                        prom_print(RELOC(" failed\n"));
                else
                        prom_print(RELOC(" done\n"));
        }

#ifdef CONFIG_SMP
        /*
         * With CHRP SMP we need to use the OF to start the other
         * processors so we can't wait until smp_boot_cpus (the OF is
         * trashed by then) so we have to put the processors into
         * a holding pattern controlled by the kernel (not OF) before
         * we destroy the OF.
         *
         * This uses a chunk of high memory, puts some holding pattern
         * code there and sends the other processors off to there until
         * smp_boot_cpus tells them to do something.  We do that by using
         * physical address 0x0.  The holding pattern checks that address
         * until its cpu # is there, when it is that cpu jumps to
         * __secondary_start().  smp_boot_cpus() takes care of setting those
         * values.
         *
         * We also use physical address 0x4 here to tell when a cpu
         * is in its holding pattern code.
         *
         * -- Cort
         */
        {
                extern void __secondary_hold(void);
                unsigned long i;
                char type[16];
                

                /*
                 * XXX: hack to make sure we're chrp, assume that if we're
                 *      chrp we have a device_type property -- Cort
                 */
                node = call_prom(RELOC("finddevice"), 1, 1, RELOC("/"));
                if ( (int)call_prom(RELOC("getprop"), 4, 1, node,
                            RELOC("device_type"),type, sizeof(type)) <= 0)
                        return;
                
                /* copy the holding pattern code to someplace safe (8M) */
                memcpy( (void *)(8<<20), RELOC(__secondary_hold), 0x100 );
                for (i = 8<<20; i < ((8<<20)+0x100); i += 32)
                {
                        asm volatile("dcbf 0,%0" : : "r" (i) : "memory");
                        asm volatile("icbi 0,%0" : : "r" (i) : "memory");
                }
        }

        /* look for cpus */
        for (node = 0; prom_next_node(&node);)
        {
                type[0] = 0;
                call_prom(RELOC("getprop"), 4, 1, node, RELOC("device_type"),
                          type, sizeof(type));
                if (strcmp(type, RELOC("cpu")) != 0)
                        continue;
                path = (char *) mem;
                memset(path, 0, 256);
                if ((int) call_prom(RELOC("package-to-path"), 3, 1,
                                    node, path, 255) < 0)
                        continue;
                /* XXX: hack - don't start cpu 0, this cpu -- Cort */
                if ( smp_chrp_cpu_nr++ == 0 )
                        continue;
                RELOC(smp_ibm_chrp_hack) = 1;
                prom_print(RELOC("starting cpu "));
                prom_print(path);
                *(unsigned long *)(0x4) = 0;
                asm volatile("dcbf 0,%0": : "r" (0x4) : "memory");
                call_prom(RELOC("start-cpu"), 3, 0, node, 8<<20, smp_chrp_cpu_nr-1);
                for ( i = 0 ; (i < 10000) &&
                              (*(ulong *)(0x4) == (ulong)0); i++ )
                        ;
                if (*(ulong *)(0x4) == (ulong)smp_chrp_cpu_nr-1 )
                        prom_print(RELOC("...ok\n"));
                else
                        prom_print(RELOC("...failed\n"));
        }
#endif  
}

/*
 * If we have a display that we don't know how to drive,
 * we will want to try to execute OF's open method for it
 * later.  However, OF will probably fall over if we do that
 * we've taken over the MMU.
 * So we check whether we will need to open the display,
 * and if so, open it now.
 */
__init
static unsigned long
check_display(unsigned long mem)
{
        phandle node;
        ihandle ih;
        int i;
        unsigned long offset = reloc_offset();
        char type[16], *path;

        for (node = 0; prom_next_node(&node); ) {
                type[0] = 0;
                call_prom(RELOC("getprop"), 4, 1, node, RELOC("device_type"),
                          type, sizeof(type));
                if (strcmp(type, RELOC("display")) != 0)
                        continue;
                /* It seems OF doesn't null-terminate the path :-( */
                path = (char *) mem;
                memset(path, 0, 256);
                if ((int) call_prom(RELOC("package-to-path"), 3, 1,
                                    node, path, 255) < 0)
                        continue;
                prom_print(RELOC("opening display "));
                prom_print(path);
                ih = call_prom(RELOC("open"), 1, 1, path);
                if (ih == 0 || ih == (ihandle) -1) {
                        prom_print(RELOC("... failed\n"));
                        continue;
                }
                prom_print(RELOC("... ok\n"));

                /*
                 * If this display is the device that OF is using for stdout,
                 * move it to the front of the list.
                 */
                mem += strlen(path) + 1;
                i = RELOC(prom_num_displays)++;
                if (RELOC(of_stdout_device) != 0 && i > 0
                    && strcmp(PTRRELOC(RELOC(of_stdout_device)), path) == 0) {
                        for (; i > 0; --i)
                                RELOC(prom_display_paths[i])
                                        = RELOC(prom_display_paths[i-1]);
                }
                RELOC(prom_display_paths[i]) = PTRUNRELOC(path);
                if (RELOC(prom_num_displays) >= FB_MAX)
                        break;
        }
        return ALIGN(mem);
}

__init
static int
prom_next_node(phandle *nodep)
{
        phandle node;
        unsigned long offset = reloc_offset();

        if ((node = *nodep) != 0
            && (*nodep = call_prom(RELOC("child"), 1, 1, node)) != 0)
                return 1;
        if ((*nodep = call_prom(RELOC("peer"), 1, 1, node)) != 0)
                return 1;
        for (;;) {
                if ((node = call_prom(RELOC("parent"), 1, 1, node)) == 0)
                        return 0;
                if ((*nodep = call_prom(RELOC("peer"), 1, 1, node)) != 0)
                        return 1;
        }
}

/*
 * Make a copy of the device tree from the PROM.
 */
__init
static unsigned long
copy_device_tree(unsigned long mem_start, unsigned long mem_end)
{
        phandle root;
        unsigned long new_start;
        struct device_node **allnextp;
        unsigned long offset = reloc_offset();

        root = call_prom(RELOC("peer"), 1, 1, (phandle)0);
        if (root == (phandle)0) {
                prom_print(RELOC("couldn't get device tree root\n"));
                prom_exit();
        }
        allnextp = &RELOC(allnodes);
        mem_start = ALIGN(mem_start);
        new_start = inspect_node(root, 0, mem_start, mem_end, &allnextp);
        *allnextp = 0;
        return new_start;
}

__init
static unsigned long
inspect_node(phandle node, struct device_node *dad,
             unsigned long mem_start, unsigned long mem_end,
             struct device_node ***allnextpp)
{
        int l;
        phandle child;
        struct device_node *np;
        struct property *pp, **prev_propp;
        char *prev_name, *namep;
        unsigned char *valp;
        unsigned long offset = reloc_offset();

        np = (struct device_node *) mem_start;
        mem_start += sizeof(struct device_node);
        memset(np, 0, sizeof(*np));
        np->node = node;
        **allnextpp = PTRUNRELOC(np);
        *allnextpp = &np->allnext;
        if (dad != 0) {
                np->parent = PTRUNRELOC(dad);
                /* we temporarily use the `next' field as `last_child'. */
                if (dad->next == 0)
                        dad->child = PTRUNRELOC(np);
                else
                        dad->next->sibling = PTRUNRELOC(np);
                dad->next = np;
        }

        /* get and store all properties */
        prev_propp = &np->properties;
        prev_name = RELOC("");
        for (;;) {
                pp = (struct property *) mem_start;
                namep = (char *) (pp + 1);
                pp->name = PTRUNRELOC(namep);
                if ((int) call_prom(RELOC("nextprop"), 3, 1, node, prev_name,
                                    namep) <= 0)
                        break;
                mem_start = ALIGN((unsigned long)namep + strlen(namep) + 1);
                prev_name = namep;
                valp = (unsigned char *) mem_start;
                pp->value = PTRUNRELOC(valp);
                pp->length = (int)
                        call_prom(RELOC("getprop"), 4, 1, node, namep,
                                  valp, mem_end - mem_start);
                if (pp->length < 0)
                        continue;
#ifdef MAX_PROPERTY_LENGTH
                if (pp->length > MAX_PROPERTY_LENGTH)
                        continue; /* ignore this property */
#endif
                mem_start = ALIGN(mem_start + pp->length);
                *prev_propp = PTRUNRELOC(pp);
                prev_propp = &pp->next;
        }
        *prev_propp = 0;

        /* get the node's full name */
        l = (int) call_prom(RELOC("package-to-path"), 3, 1, node,
                            (char *) mem_start, mem_end - mem_start);
        if (l >= 0) {
                np->full_name = PTRUNRELOC((char *) mem_start);
                *(char *)(mem_start + l) = 0;
                mem_start = ALIGN(mem_start + l + 1);
        }

        /* do all our children */
        child = call_prom(RELOC("child"), 1, 1, node);
        while (child != (void *)0) {
                mem_start = inspect_node(child, np, mem_start, mem_end,
                                         allnextpp);
                child = call_prom(RELOC("peer"), 1, 1, child);
        }

        return mem_start;
}

/*
 * finish_device_tree is called once things are running normally
 * (i.e. with text and data mapped to the address they were linked at).
 * It traverses the device tree and fills in the name, type,
 * {n_}addrs and {n_}intrs fields of each node.
 */
__init
void
finish_device_tree(void)
{
        unsigned long mem = (unsigned long) klimit;

        if (boot_infos)
                relocate_nodes();
        mem = finish_node(allnodes, mem, NULL);
        printk(KERN_INFO "device tree used %lu bytes\n",
               mem - (unsigned long) allnodes);
        klimit = (char *) mem;
}

/*
 * early_get_property is used to access the device tree image prepared
 * by BootX very early on, before the pointers in it have been relocated.
 */
__init void *
early_get_property(unsigned long base, unsigned long node, char *prop)
{
        struct device_node *np = (struct device_node *)(base + node);
        struct property *pp;

        for (pp = np->properties; pp != 0; pp = pp->next) {
                pp = (struct property *) (base + (unsigned long)pp);
                if (strcmp((char *)((unsigned long)pp->name + base),
                           prop) == 0) {
                        return (void *)((unsigned long)pp->value + base);
                }
        }
        return 0;
}

__init
static unsigned long
finish_node(struct device_node *np, unsigned long mem_start,
            interpret_func *ifunc)
{
        struct device_node *child;

        np->name = get_property(np, "name", 0);
        np->type = get_property(np, "device_type", 0);

        /* get the device addresses and interrupts */
        if (ifunc != NULL) {
                mem_start = ifunc(np, mem_start);
        }

        /* the f50 sets the name to 'display' and 'compatible' to what we
         * expect for the name -- Cort
         */
        if (!strcmp(np->name, "display"))
                np->name = get_property(np, "compatible", 0);

        if (!strcmp(np->name, "device-tree"))
                ifunc = interpret_root_props;
        else if (np->type == 0)
                ifunc = NULL;
        else if (!strcmp(np->type, "pci") || !strcmp(np->type, "vci"))
                ifunc = interpret_pci_props;
        else if (!strcmp(np->type, "dbdma"))
                ifunc = interpret_dbdma_props;
        else if (!strcmp(np->type, "mac-io")
                 || ifunc == interpret_macio_props)
                ifunc = interpret_macio_props;
        else if (!strcmp(np->type, "isa"))
                ifunc = interpret_isa_props;
        else if (!((ifunc == interpret_dbdma_props
                    || ifunc == interpret_macio_props)
                   && (!strcmp(np->type, "escc")
                       || !strcmp(np->type, "media-bay"))))
                ifunc = NULL;

        /* if we were booted from BootX, convert the full name */
        if (boot_infos
            && strncmp(np->full_name, "Devices:device-tree", 19) == 0) {
                if (np->full_name[19] == 0) {
                        strcpy(np->full_name, "/");
                } else if (np->full_name[19] == ':') {
                        char *p = np->full_name + 19;
                        np->full_name = p;
                        for (; *p; ++p)
                                if (*p == ':')
                                        *p = '/';
                }
        }

        for (child = np->child; child != NULL; child = child->sibling)
                mem_start = finish_node(child, mem_start, ifunc);

        return mem_start;
}

/*
 * When BootX makes a copy of the device tree from the MacOS
 * Name Registry, it is in the format we use but all of the pointers
 * are offsets from the start of the tree.
 * This procedure updates the pointers.
 */
__init
static void relocate_nodes(void)
{
        unsigned long base;
        struct device_node *np;
        struct property *pp;

#define ADDBASE(x)      (x = (x)? ((typeof (x))((unsigned long)(x) + base)): 0)

        base = (unsigned long) boot_infos + boot_infos->deviceTreeOffset;
        allnodes = (struct device_node *)(base + 4);
        for (np = allnodes; np != 0; np = np->allnext) {
                ADDBASE(np->full_name);
                ADDBASE(np->properties);
                ADDBASE(np->parent);
                ADDBASE(np->child);
                ADDBASE(np->sibling);
                ADDBASE(np->allnext);
                for (pp = np->properties; pp != 0; pp = pp->next) {
                        ADDBASE(pp->name);
                        ADDBASE(pp->value);
                        ADDBASE(pp->next);
                }
        }
}

__init
static unsigned long
interpret_pci_props(struct device_node *np, unsigned long mem_start)
{
        struct address_range *adr;
        struct pci_reg_property *pci_addrs;
        int i, l, *ip, ml;
        struct pci_intr_map *imp;

        pci_addrs = (struct pci_reg_property *)
                get_property(np, "assigned-addresses", &l);
        if (pci_addrs != 0 && l >= sizeof(struct pci_reg_property)) {
                i = 0;
                adr = (struct address_range *) mem_start;
                while ((l -= sizeof(struct pci_reg_property)) >= 0) {
                        /* XXX assumes PCI addresses mapped 1-1 to physical */
                        adr[i].space = pci_addrs[i].addr.a_hi;
                        adr[i].address = pci_addrs[i].addr.a_lo;
                        adr[i].size = pci_addrs[i].size_lo;
                        ++i;
                }
                np->addrs = adr;
                np->n_addrs = i;
                mem_start += i * sizeof(struct address_range);
        }

        /*
         * If the pci host bridge has an interrupt-map property,
         * look for our node in it.
         */
        if (np->parent != 0 && pci_addrs != 0
            && (imp = (struct pci_intr_map *)
                get_property(np->parent, "interrupt-map", &ml)) != 0
            && (ip = (int *) get_property(np, "interrupts", &l)) != 0) {
                unsigned int devfn = pci_addrs[0].addr.a_hi & 0xff00;
                np->n_intrs = 0;
                np->intrs = (struct interrupt_info *) mem_start;
                for (i = 0; (ml -= sizeof(struct pci_intr_map)) >= 0; ++i) {
                        if (imp[i].addr.a_hi == devfn) {
                                np->intrs[np->n_intrs].line = imp[i].intr;
                                np->intrs[np->n_intrs].sense = 0;
                                ++np->n_intrs;
                        }
                }
                if (np->n_intrs == 0)
                        np->intrs = 0;
                mem_start += np->n_intrs * sizeof(struct interrupt_info);
                return mem_start;
        }

        ip = (int *) get_property(np, "AAPL,interrupts", &l);
        if (ip == 0)
                ip = (int *) get_property(np, "interrupts", &l);
        if (ip != 0) {
                np->intrs = (struct interrupt_info *) mem_start;
                np->n_intrs = l / sizeof(int);
                mem_start += np->n_intrs * sizeof(struct interrupt_info);
                for (i = 0; i < np->n_intrs; ++i) {
                        np->intrs[i].line = *ip++;
                        np->intrs[i].sense = 0;
                }
        }

        return mem_start;
}

__init
static unsigned long
interpret_dbdma_props(struct device_node *np, unsigned long mem_start)
{
        struct reg_property *rp;
        struct address_range *adr;
        unsigned long base_address;
        int i, l, *ip;
        struct device_node *db;

        base_address = 0;
        for (db = np->parent; db != NULL; db = db->parent) {
                if (!strcmp(db->type, "dbdma") && db->n_addrs != 0) {
                        base_address = db->addrs[0].address;
                        break;
                }
        }

        rp = (struct reg_property *) get_property(np, "reg", &l);
        if (rp != 0 && l >= sizeof(struct reg_property)) {
                i = 0;
                adr = (struct address_range *) mem_start;
                while ((l -= sizeof(struct reg_property)) >= 0) {
                        adr[i].space = 0;
                        adr[i].address = rp[i].address + base_address;
                        adr[i].size = rp[i].size;
                        ++i;
                }
                np->addrs = adr;
                np->n_addrs = i;
                mem_start += i * sizeof(struct address_range);
        }

        ip = (int *) get_property(np, "AAPL,interrupts", &l);
        if (ip == 0)
                ip = (int *) get_property(np, "interrupts", &l);
        if (ip != 0) {
                np->intrs = (struct interrupt_info *) mem_start;
                np->n_intrs = l / sizeof(int);
                mem_start += np->n_intrs * sizeof(struct interrupt_info);
                for (i = 0; i < np->n_intrs; ++i) {
                        np->intrs[i].line = *ip++;
                        np->intrs[i].sense = 0;
                }
        }

        return mem_start;
}

__init
static unsigned long
interpret_macio_props(struct device_node *np, unsigned long mem_start)
{
        struct reg_property *rp;
        struct address_range *adr;
        unsigned long base_address;
        int i, l, *ip;
        struct device_node *db;

        base_address = 0;
        for (db = np->parent; db != NULL; db = db->parent) {
                if (!strcmp(db->type, "mac-io") && db->n_addrs != 0) {
                        base_address = db->addrs[0].address;
                        break;
                }
        }

        rp = (struct reg_property *) get_property(np, "reg", &l);
        if (rp != 0 && l >= sizeof(struct reg_property)) {
                i = 0;
                adr = (struct address_range *) mem_start;
                while ((l -= sizeof(struct reg_property)) >= 0) {
                        adr[i].space = 0;
                        adr[i].address = rp[i].address + base_address;
                        adr[i].size = rp[i].size;
                        ++i;
                }
                np->addrs = adr;
                np->n_addrs = i;
                mem_start += i * sizeof(struct address_range);
        }

        ip = (int *) get_property(np, "interrupts", &l);
        if (ip == 0)
                ip = (int *) get_property(np, "AAPL,interrupts", &l);
        if (ip != 0) {
                np->intrs = (struct interrupt_info *) mem_start;
                if (_machine == _MACH_Pmac) {
                        /* for the iMac */
                        np->n_intrs = l / sizeof(int);
                        for (i = 0; i < np->n_intrs; ++i) {
                                np->intrs[i].line = *ip++;
                                np->intrs[i].sense = 0;
                        }
                } else {
                        /* CHRP machines */
                        np->n_intrs = l / (2 * sizeof(int));
                        for (i = 0; i < np->n_intrs; ++i) {
                                np->intrs[i].line = openpic_to_irq(*ip++);
                                np->intrs[i].sense = *ip++;
                        }
                }
                mem_start += np->n_intrs * sizeof(struct interrupt_info);
        }

        return mem_start;
}

__init
static unsigned long
interpret_isa_props(struct device_node *np, unsigned long mem_start)
{
        struct isa_reg_property *rp;
        struct address_range *adr;
        int i, l, *ip;

        rp = (struct isa_reg_property *) get_property(np, "reg", &l);
        if (rp != 0 && l >= sizeof(struct isa_reg_property)) {
                i = 0;
                adr = (struct address_range *) mem_start;
                while ((l -= sizeof(struct reg_property)) >= 0) {
                        adr[i].space = rp[i].space;
                        adr[i].address = rp[i].address
                                + (adr[i].space? 0: _ISA_MEM_BASE);
                        adr[i].size = rp[i].size;
                        ++i;
                }
                np->addrs = adr;
                np->n_addrs = i;
                mem_start += i * sizeof(struct address_range);
        }

        ip = (int *) get_property(np, "interrupts", &l);
        if (ip != 0) {
                np->intrs = (struct interrupt_info *) mem_start;
                np->n_intrs = l / (2 * sizeof(int));
                mem_start += np->n_intrs * sizeof(struct interrupt_info);
                for (i = 0; i < np->n_intrs; ++i) {
                        np->intrs[i].line = *ip++;
                        np->intrs[i].sense = *ip++;
                }
        }

        return mem_start;
}

__init
static unsigned long
interpret_root_props(struct device_node *np, unsigned long mem_start)
{
        struct reg_property *rp;
        struct address_range *adr;
        int i, l, *ip;

        rp = (struct reg_property *) get_property(np, "reg", &l);
        if (rp != 0 && l >= sizeof(struct reg_property)) {
                i = 0;
                adr = (struct address_range *) mem_start;
                while ((l -= sizeof(struct reg_property)) >= 0) {
                        adr[i].space = 0;
                        adr[i].address = rp[i].address;
                        adr[i].size = rp[i].size;
                        ++i;
                }
                np->addrs = adr;
                np->n_addrs = i;
                mem_start += i * sizeof(struct address_range);
        }

        ip = (int *) get_property(np, "AAPL,interrupts", &l);
        if (ip == 0)
                ip = (int *) get_property(np, "interrupts", &l);
        if (ip != 0) {
                np->intrs = (struct interrupt_info *) mem_start;
                np->n_intrs = l / sizeof(int);
                mem_start += np->n_intrs * sizeof(struct interrupt_info);
                for (i = 0; i < np->n_intrs; ++i) {
                        np->intrs[i].line = *ip++;
                        np->intrs[i].sense = 0;
                }
        }

        return mem_start;
}

/*
 * Construct and return a list of the device_nodes with a given name.
 */
__openfirmware
struct device_node *
find_devices(const char *name)
{
        struct device_node *head, **prevp, *np;

        prevp = &head;
        for (np = allnodes; np != 0; np = np->allnext) {
                if (np->name != 0 && strcasecmp(np->name, name) == 0) {
                        *prevp = np;
                        prevp = &np->next;
                }
        }
        *prevp = 0;
        return head;
}

/*
 * Construct and return a list of the device_nodes with a given type.
 */
__openfirmware
struct device_node *
find_type_devices(const char *type)
{
        struct device_node *head, **prevp, *np;

        prevp = &head;
        for (np = allnodes; np != 0; np = np->allnext) {
                if (np->type != 0 && strcasecmp(np->type, type) == 0) {
                        *prevp = np;
                        prevp = &np->next;
                }
        }
        *prevp = 0;
        return head;
}

/* Checks if the given "compat" string matches one of the strings in
 * the device's "compatible" property
 */
__openfirmware
int
device_is_compatible(struct device_node *device, const char *compat)
{
        const char* cp;
        int cplen, l;

        cp = (char *) get_property(device, "compatible", &cplen);
        if (cp == NULL)
                return 0;
        while (cplen > 0) {
                if (strncasecmp(cp, compat, strlen(compat)) == 0)
                        return 1;
                l = strlen(cp) + 1;
                cp += l;
                cplen -= l;
        }

        return 0;
}

/*
 * Construct and return a list of the device_nodes with a given type
 * and compatible property.
 */
__openfirmware
struct device_node *
find_compatible_devices(const char *type, const char *compat)
{
        struct device_node *head, **prevp, *np;

        prevp = &head;
        for (np = allnodes; np != 0; np = np->allnext) {
                if (type != NULL
                    && !(np->type != 0 && strcasecmp(np->type, type) == 0))
                        continue;
                if (device_is_compatible(np, compat)) {
                        *prevp = np;
                        prevp = &np->next;
                }
        }
        *prevp = 0;
        return head;
}

/*
 * Find the device_node with a given full_name.
 */
__openfirmware
struct device_node *
find_path_device(const char *path)
{
        struct device_node *np;

        for (np = allnodes; np != 0; np = np->allnext)
                if (np->full_name != 0 && strcasecmp(np->full_name, path) == 0)
                        return np;
        return NULL;
}

/*
 * Find the device_node with a given phandle.
 */
__openfirmware
struct device_node *
find_phandle(phandle ph)
{
        struct device_node *np;

        for (np = allnodes; np != 0; np = np->allnext)
                if (np->node == ph)
                        return np;
        return NULL;
}

/*
 * Find a property with a given name for a given node
 * and return the value.
 */
__openfirmware
unsigned char *
get_property(struct device_node *np, const char *name, int *lenp)
{
        struct property *pp;

        for (pp = np->properties; pp != 0; pp = pp->next)
                if (strcmp(pp->name, name) == 0) {
                        if (lenp != 0)
                                *lenp = pp->length;
                        return pp->value;
                }
        return 0;
}

#if 0
__openfirmware
void
print_properties(struct device_node *np)
{
        struct property *pp;
        char *cp;
        int i, n;

        for (pp = np->properties; pp != 0; pp = pp->next) {
                printk(KERN_INFO "%s", pp->name);
                for (i = strlen(pp->name); i < 16; ++i)
                        printk(" ");
                cp = (char *) pp->value;
                for (i = pp->length; i > 0; --i, ++cp)
                        if ((i > 1 && (*cp < 0x20 || *cp > 0x7e))
                            || (i == 1 && *cp != 0))
                                break;
                if (i == 0 && pp->length > 1) {
                        /* looks like a string */
                        printk(" %s\n", (char *) pp->value);
                } else {
                        /* dump it in hex */
                        n = pp->length;
                        if (n > 64)
                                n = 64;
                        if (pp->length % 4 == 0) {
                                unsigned int *p = (unsigned int *) pp->value;

                                n /= 4;
                                for (i = 0; i < n; ++i) {
                                        if (i != 0 && (i % 4) == 0)
                                                printk("\n                ");
                                        printk(" %08x", *p++);
                                }
                        } else {
                                unsigned char *bp = pp->value;

                                for (i = 0; i < n; ++i) {
                                        if (i != 0 && (i % 16) == 0)
                                                printk("\n                ");
                                        printk(" %02x", *bp++);
                                }
                        }
                        printk("\n");
                        if (pp->length > 64)
                                printk("                 ... (length = %d)\n",
                                       pp->length);
                }
        }
}
#endif

/* this can be called after setup -- Cort */
__openfirmware
int
call_rtas(const char *service, int nargs, int nret,
          unsigned long *outputs, ...)
{
        va_list list;
        int i, s;
        struct device_node *rtas;
        int *tokp;
        union {
                unsigned long words[16];
                double align;
        } u;

        rtas = find_devices("rtas");
        if (rtas == NULL)
                return -1;
        tokp = (int *) get_property(rtas, service, NULL);
        if (tokp == NULL) {
                printk(KERN_ERR "No RTAS service called %s\n", service);
                return -1;
        }
        u.words[0] = *tokp;
        u.words[1] = nargs;
        u.words[2] = nret;
        va_start(list, outputs);
        for (i = 0; i < nargs; ++i)
                u.words[i+3] = va_arg(list, unsigned long);
        va_end(list);

        save_flags(s);
        cli();
        
        enter_rtas((void *)__pa(&u));
        restore_flags(s);
        if (nret > 1 && outputs != NULL)
                for (i = 0; i < nret-1; ++i)
                        outputs[i] = u.words[i+nargs+4];
        return u.words[nargs+3];
}

__init
void
abort()
{
#ifdef CONFIG_XMON
        xmon(NULL);
#endif
        prom_exit();
}

/* Calc the base address of a given point (x,y) */
#define CALC_BASE(x,y)  ((BOOT_INFO_IS_V2_COMPATIBLE(bi) ? bi->logicalDisplayBase :     \
                        bi->dispDeviceBase) + (bi->dispDeviceRect[0] + (x)) *           \
                        (bi->dispDeviceDepth >> 3) + bi->dispDeviceRowBytes *           \
                        ((y) + bi->dispDeviceRect[1]))

__init
static void
clearscreen(void)
{
        unsigned long offset    = reloc_offset();
        boot_infos_t* bi        = PTRRELOC(RELOC(boot_infos));
        unsigned long *base     = (unsigned long *)CALC_BASE(0,0);
        unsigned long width     = ((bi->dispDeviceRect[2] - bi->dispDeviceRect[0]) *
                                        (bi->dispDeviceDepth >> 3)) >> 2;
        int i,j;
        
        for (i=0; i<(bi->dispDeviceRect[3] - bi->dispDeviceRect[1]); i++)
        {
                unsigned long *ptr = base;
                for(j=width; j; --j)
                        *(ptr++) = 0;
                base += (bi->dispDeviceRowBytes >> 2);
        }
}

__inline__ void dcbst(const void* addr)
{
        __asm__ __volatile__ ("dcbst 0,%0" :: "r" (addr));
}

__init
static void
flushscreen(void)
{
        unsigned long offset    = reloc_offset();
        boot_infos_t* bi        = PTRRELOC(RELOC(boot_infos));
        unsigned long *base     = (unsigned long *)CALC_BASE(0,0);
        unsigned long width     = ((bi->dispDeviceRect[2] - bi->dispDeviceRect[0]) *
                                        (bi->dispDeviceDepth >> 3)) >> 2;
        int i,j;
        
        for (i=0; i<(bi->dispDeviceRect[3] - bi->dispDeviceRect[1]); i++)
        {
                unsigned long *ptr = base;
                for(j=width; j>0; j-=8) {
                        dcbst(ptr);
                        ptr += 8;
                }
                base += (bi->dispDeviceRowBytes >> 2);
        }
}

#ifdef CONFIG_BOOTX_TEXT

__init
static void
scrollscreen(void)
{
        unsigned long offset            = reloc_offset();
        boot_infos_t* bi                = PTRRELOC(RELOC(boot_infos));
        unsigned long *src              = (unsigned long *)CALC_BASE(0,16);
        unsigned long *dst              = (unsigned long *)CALC_BASE(0,0);
        unsigned long width             = ((bi->dispDeviceRect[2] - bi->dispDeviceRect[0]) *
                                                (bi->dispDeviceDepth >> 3)) >> 2;
        int i,j;
        
        for (i=0; i<(bi->dispDeviceRect[3] - bi->dispDeviceRect[1] - 16); i++)
        {
                unsigned long *src_ptr = src;
                unsigned long *dst_ptr = dst;
                for(j=width; j; --j)
                        *(dst_ptr++) = *(src_ptr++);
                src += (bi->dispDeviceRowBytes >> 2);
                dst += (bi->dispDeviceRowBytes >> 2);
        }
        for (i=0; i<16; i++)
        {
                unsigned long *dst_ptr = dst;
                for(j=width; j; --j)
                        *(dst_ptr++) = 0;
                dst += (bi->dispDeviceRowBytes >> 2);
        }
}

__init
static void
drawchar(char c)
{
        unsigned long offset = reloc_offset();

        switch(c) {
                case '\r': RELOC(g_loc_X) = 0;                  break;
                case '\n': RELOC(g_loc_X) = 0; RELOC(g_loc_Y)++;        break;
                default:
                        draw_byte(c, RELOC(g_loc_X)++, RELOC(g_loc_Y));
                        if (RELOC(g_loc_X) >= RELOC(g_max_loc_X)) {
                                RELOC(g_loc_X) = 0;
                                RELOC(g_loc_Y)++;
                        }
        }
        while (RELOC(g_loc_Y) >= RELOC(g_max_loc_Y)) {
                scrollscreen();
                RELOC(g_loc_Y)--;
        }
}

__init
static void
drawstring(const char *c)
{
        while(*c)
                drawchar(*(c++));
}

__init
static void
drawhex(unsigned long v)
{
        static char hex_table[] = "0123456789abcdef";
        unsigned long offset    = reloc_offset();
        
        drawchar(RELOC(hex_table)[(v >> 28) & 0x0000000FUL]);
        drawchar(RELOC(hex_table)[(v >> 24) & 0x0000000FUL]);
        drawchar(RELOC(hex_table)[(v >> 20) & 0x0000000FUL]);
        drawchar(RELOC(hex_table)[(v >> 16) & 0x0000000FUL]);
        drawchar(RELOC(hex_table)[(v >> 12) & 0x0000000FUL]);
        drawchar(RELOC(hex_table)[(v >>  8) & 0x0000000FUL]);
        drawchar(RELOC(hex_table)[(v >>  4) & 0x0000000FUL]);
        drawchar(RELOC(hex_table)[(v >>  0) & 0x0000000FUL]);
}


__init
static void
draw_byte(unsigned char c, long locX, long locY)
{
        unsigned long offset    = reloc_offset();
        boot_infos_t* bi        = PTRRELOC(RELOC(boot_infos));
        unsigned char *base     = CALC_BASE(locX << 3, locY << 4);
        unsigned char *font     = &RELOC(vga_font)[((unsigned long)c) * 16];
        
        switch(bi->dispDeviceDepth) {
                case 32:
                        draw_byte_32(font, (unsigned long *)base);
                        break;
                case 16:
                        draw_byte_16(font, (unsigned long *)base);
                        break;
                case 8:
                        draw_byte_8(font, (unsigned long *)base);
                        break;
                default:
                        break;
        }
}

__init
static unsigned long expand_bits_8[16] = {
        0x00000000,
        0x000000ff,
        0x0000ff00,
        0x0000ffff,
        0x00ff0000,
        0x00ff00ff,
        0x00ffff00,
        0x00ffffff,
        0xff000000,
        0xff0000ff,
        0xff00ff00,
        0xff00ffff,
        0xffff0000,
        0xffff00ff,
        0xffffff00,
        0xffffffff
};

__init
static unsigned long expand_bits_16[4] = {
        0x00000000,
        0x0000ffff,
        0xffff0000,
        0xffffffff
};


__init
static void
draw_byte_32(unsigned char *font, unsigned long *base)
{
        unsigned long offset = reloc_offset();
        boot_infos_t* bi                = PTRRELOC(RELOC(boot_infos));
        int l, bits;    
        int fg = 0xFFFFFFFFUL;
        int bg = 0x00000000UL;
        

        for (l = 0; l < 16; ++l)
        {
                bits = *font++;
                base[0] = (-(bits >> 7) & fg) ^ bg;
                base[1] = (-((bits >> 6) & 1) & fg) ^ bg;
                base[2] = (-((bits >> 5) & 1) & fg) ^ bg;
                base[3] = (-((bits >> 4) & 1) & fg) ^ bg;
                base[4] = (-((bits >> 3) & 1) & fg) ^ bg;
                base[5] = (-((bits >> 2) & 1) & fg) ^ bg;
                base[6] = (-((bits >> 1) & 1) & fg) ^ bg;
                base[7] = (-(bits & 1) & fg) ^ bg;
                base = (unsigned long *) ((char *)base + bi->dispDeviceRowBytes);
        }
}

__init
static void
draw_byte_16(unsigned char *font, unsigned long *base)
{
        unsigned long offset = reloc_offset();
        boot_infos_t* bi                = PTRRELOC(RELOC(boot_infos));
        int l, bits;    
        int fg = 0xFFFFFFFFUL;
        int bg = 0x00000000UL;
        unsigned long *eb = RELOC(expand_bits_16);

        for (l = 0; l < 16; ++l)
        {
                bits = *font++;
                base[0] = (eb[bits >> 6] & fg) ^ bg;
                base[1] = (eb[(bits >> 4) & 3] & fg) ^ bg;
                base[2] = (eb[(bits >> 2) & 3] & fg) ^ bg;
                base[3] = (eb[bits & 3] & fg) ^ bg;
                base = (unsigned long *) ((char *)base + bi->dispDeviceRowBytes);
        }
}

__init
static void
draw_byte_8(unsigned char *font, unsigned long *base)
{
        unsigned long offset = reloc_offset();
        boot_infos_t* bi                = PTRRELOC(RELOC(boot_infos));
        int l, bits;    
        int fg = 0x0F0F0F0FUL;
        int bg = 0x00000000UL;
        unsigned long *eb = RELOC(expand_bits_8);

        for (l = 0; l < 16; ++l)
        {
                bits = *font++;
                base[0] = (eb[bits >> 4] & fg) ^ bg;
                base[1] = (eb[bits & 0xf] & fg) ^ bg;
                base = (unsigned long *) ((char *)base + bi->dispDeviceRowBytes);
        }
}

__init
static unsigned char vga_font[cmapsz] = {
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x7e, 0x81, 0xa5, 0x81, 0x81, 0xbd, 
0x99, 0x81, 0x81, 0x7e, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x7e, 0xff, 
0xdb, 0xff, 0xff, 0xc3, 0xe7, 0xff, 0xff, 0x7e, 0x00, 0x00, 0x00, 0x00, 
0x00, 0x00, 0x00, 0x00, 0x6c, 0xfe, 0xfe, 0xfe, 0xfe, 0x7c, 0x38, 0x10, 
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x10, 0x38, 0x7c, 0xfe, 
0x7c, 0x38, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x18, 
0x3c, 0x3c, 0xe7, 0xe7, 0xe7, 0x18, 0x18, 0x3c, 0x00, 0x00, 0x00, 0x00, 
0x00, 0x00, 0x00, 0x18, 0x3c, 0x7e, 0xff, 0xff, 0x7e, 0x18, 0x18, 0x3c, 
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x18, 0x3c, 
0x3c, 0x18, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 
0xff, 0xff, 0xe7, 0xc3, 0xc3, 0xe7, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 
0x00, 0x00, 0x00, 0x00, 0x00, 0x3c, 0x66, 0x42, 0x42, 0x66, 0x3c, 0x00, 
0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xc3, 0x99, 0xbd, 
0xbd, 0x99, 0xc3, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x1e, 0x0e, 
0x1a, 0x32, 0x78, 0xcc, 0xcc, 0xcc, 0xcc, 0x78, 0x00, 0x00, 0x00, 0x00, 
0x00, 0x00, 0x3c, 0x66, 0x66, 0x66, 0x66, 0x3c, 0x18, 0x7e, 0x18, 0x18, 
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x3f, 0x33, 0x3f, 0x30, 0x30, 0x30, 
0x30, 0x70, 0xf0, 0xe0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x7f, 0x63, 
0x7f, 0x63, 0x63, 0x63, 0x63, 0x67, 0xe7, 0xe6, 0xc0, 0x00, 0x00, 0x00, 
0x00, 0x00, 0x00, 0x18, 0x18, 0xdb, 0x3c, 0xe7, 0x3c, 0xdb, 0x18, 0x18, 
0x00, 0x00, 0x00, 0x00, 0x00, 0x80, 0xc0, 0xe0, 0xf0, 0xf8, 0xfe, 0xf8, 
0xf0, 0xe0, 0xc0, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0x06, 0x0e, 
0x1e, 0x3e, 0xfe, 0x3e, 0x1e, 0x0e, 0x06, 0x02, 0x00, 0x00, 0x00, 0x00, 
0x00, 0x00, 0x18, 0x3c, 0x7e, 0x18, 0x18, 0x18, 0x7e, 0x3c, 0x18, 0x00, 
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 
0x66, 0x00, 0x66, 0x66, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x7f, 0xdb, 
0xdb, 0xdb, 0x7b, 0x1b, 0x1b, 0x1b, 0x1b, 0x1b, 0x00, 0x00, 0x00, 0x00, 
0x00, 0x7c, 0xc6, 0x60, 0x38, 0x6c, 0xc6, 0xc6, 0x6c, 0x38, 0x0c, 0xc6, 
0x7c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
0xfe, 0xfe, 0xfe, 0xfe, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x18, 0x3c, 
0x7e, 0x18, 0x18, 0x18, 0x7e, 0x3c, 0x18, 0x7e, 0x00, 0x00, 0x00, 0x00, 
0x00, 0x00, 0x18, 0x3c, 0x7e, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 
0x18, 0x7e, 0x3c, 0x18, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
0x00, 0x18, 0x0c, 0xfe, 0x0c, 0x18, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
0x00, 0x00, 0x00, 0x00, 0x00, 0x30, 0x60, 0xfe, 0x60, 0x30, 0x00, 0x00, 
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xc0, 0xc0, 
0xc0, 0xfe, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
0x00, 0x24, 0x66, 0xff, 0x66, 0x24, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
0x00, 0x00, 0x00, 0x00, 0x10, 0x38, 0x38, 0x7c, 0x7c, 0xfe, 0xfe, 0x00, 
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xfe, 0xfe, 0x7c, 0x7c, 
0x38, 0x38, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
0x00, 0x00, 0x18, 0x3c, 0x3c, 0x3c, 0x18, 0x18, 0x18, 0x00, 0x18, 0x18, 
0x00, 0x00, 0x00, 0x00, 0x00, 0x66, 0x66, 0x66, 0x24, 0x00, 0x00, 0x00, 
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x6c, 
0x6c, 0xfe, 0x6c, 0x6c, 0x6c, 0xfe, 0x6c, 0x6c, 0x00, 0x00, 0x00, 0x00, 
0x18, 0x18, 0x7c, 0xc6, 0xc2, 0xc0, 0x7c, 0x06, 0x06, 0x86, 0xc6, 0x7c, 
0x18, 0x18, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xc2, 0xc6, 0x0c, 0x18, 
0x30, 0x60, 0xc6, 0x86, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x38, 0x6c, 
0x6c, 0x38, 0x76, 0xdc, 0xcc, 0xcc, 0xcc, 0x76, 0x00, 0x00, 0x00, 0x00, 
0x00, 0x30, 0x30, 0x30, 0x60, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0c, 0x18, 0x30, 0x30, 0x30, 0x30, 
0x30, 0x30, 0x18, 0x0c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x30, 0x18, 
0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x18, 0x30, 0x00, 0x00, 0x00, 0x00, 
0x00, 0x00, 0x00, 0x00, 0x00, 0x66, 0x3c, 0xff, 0x3c, 0x66, 0x00, 0x00, 
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x18, 0x18, 0x7e, 
0x18, 0x18, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
0x00, 0x00, 0x00, 0x00, 0x00, 0x18, 0x18, 0x18, 0x30, 0x00, 0x00, 0x00, 
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x7e, 0x00, 0x00, 0x00, 0x00, 
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
0x00, 0x00, 0x18, 0x18, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
0x02, 0x06, 0x0c, 0x18, 0x30, 0x60, 0xc0, 0x80, 0x00, 0x00, 0x00, 0x00, 
0x00, 0x00, 0x7c, 0xc6, 0xc6, 0xce, 0xde, 0xf6, 0xe6, 0xc6, 0xc6, 0x7c, 
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x18, 0x38, 0x78, 0x18, 0x18, 0x18, 
0x18, 0x18, 0x18, 0x7e, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x7c, 0xc6, 
0x06, 0x0c, 0x18, 0x30, 0x60, 0xc0, 0xc6, 0xfe, 0x00, 0x00, 0x00, 0x00, 
0x00, 0x00, 0x7c, 0xc6, 0x06, 0x06, 0x3c, 0x06, 0x06, 0x06, 0xc6, 0x7c, 
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0c, 0x1c, 0x3c, 0x6c, 0xcc, 0xfe, 
0x0c, 0x0c, 0x0c, 0x1e, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xfe, 0xc0, 
0xc0, 0xc0, 0xfc, 0x06, 0x06, 0x06, 0xc6, 0x7c, 0x00, 0x00, 0x00, 0x00, 
0x00, 0x00, 0x38, 0x60, 0xc0, 0xc0, 0xfc, 0xc6, 0xc6, 0xc6, 0xc6, 0x7c, 
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xfe, 0xc6, 0x06, 0x06, 0x0c, 0x18, 
0x30, 0x30, 0x30, 0x30, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x7c, 0xc6, 
0xc6, 0xc6, 0x7c, 0xc6, 0xc6, 0xc6, 0xc6, 0x7c, 0x00, 0x00, 0x00, 0x00, 
0x00, 0x00, 0x7c, 0xc6, 0xc6, 0xc6, 0x7e, 0x06, 0x06, 0x06, 0x0c, 0x78, 
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x18, 0x18, 0x00, 0x00, 
0x00, 0x18, 0x18, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
0x18, 0x18, 0x00, 0x00, 0x00, 0x18, 0x18, 0x30, 0x00, 0x00, 0x00, 0x00, 
0x00, 0x00, 0x00, 0x06, 0x0c, 0x18, 0x30, 0x60, 0x30, 0x18, 0x0c, 0x06, 
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x7e, 0x00, 0x00, 
0x7e, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x60, 
0x30, 0x18, 0x0c, 0x06, 0x0c, 0x18, 0x30, 0x60, 0x00, 0x00, 0x00, 0x00, 
0x00, 0x00, 0x7c, 0xc6, 0xc6, 0x0c, 0x18, 0x18, 0x18, 0x00, 0x18, 0x18, 
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x7c, 0xc6, 0xc6, 0xc6, 0xde, 0xde, 
0xde, 0xdc, 0xc0, 0x7c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x10, 0x38, 
0x6c, 0xc6, 0xc6, 0xfe, 0xc6, 0xc6, 0xc6, 0xc6, 0x00, 0x00, 0x00, 0x00, 
0x00, 0x00, 0xfc, 0x66, 0x66, 0x66, 0x7c, 0x66, 0x66, 0x66, 0x66, 0xfc, 
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x3c, 0x66, 0xc2, 0xc0, 0xc0, 0xc0, 
0xc0, 0xc2, 0x66, 0x3c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xf8, 0x6c, 
0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x6c, 0xf8, 0x00, 0x00, 0x00, 0x00, 
0x00, 0x00, 0xfe, 0x66, 0x62, 0x68, 0x78, 0x68, 0x60, 0x62, 0x66, 0xfe, 
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xfe, 0x66, 0x62, 0x68, 0x78, 0x68, 
0x60, 0x60, 0x60, 0xf0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x3c, 0x66, 
0xc2, 0xc0, 0xc0, 0xde, 0xc6, 0xc6, 0x66, 0x3a, 0x00, 0x00, 0x00, 0x00, 
0x00, 0x00, 0xc6, 0xc6, 0xc6, 0xc6, 0xfe, 0xc6, 0xc6, 0xc6, 0xc6, 0xc6, 
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x3c, 0x18, 0x18, 0x18, 0x18, 0x18, 
0x18, 0x18, 0x18, 0x3c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x1e, 0x0c, 
0x0c, 0x0c, 0x0c, 0x0c, 0xcc, 0xcc, 0xcc, 0x78, 0x00, 0x00, 0x00, 0x00, 
0x00, 0x00, 0xe6, 0x66, 0x66, 0x6c, 0x78, 0x78, 0x6c, 0x66, 0x66, 0xe6, 
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xf0, 0x60, 0x60, 0x60, 0x60, 0x60, 
0x60, 0x62, 0x66, 0xfe, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xc3, 0xe7, 
0xff, 0xff, 0xdb, 0xc3, 0xc3, 0xc3, 0xc3, 0xc3, 0x00, 0x00, 0x00, 0x00, 
0x00, 0x00, 0xc6, 0xe6, 0xf6, 0xfe, 0xde, 0xce, 0xc6, 0xc6, 0xc6, 0xc6, 
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x7c, 0xc6, 0xc6, 0xc6, 0xc6, 0xc6, 
0xc6, 0xc6, 0xc6, 0x7c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xfc, 0x66, 
0x66, 0x66, 0x7c, 0x60, 0x60, 0x60, 0x60, 0xf0, 0x00, 0x00, 0x00, 0x00, 
0x00, 0x00, 0x7c, 0xc6, 0xc6, 0xc6, 0xc6, 0xc6, 0xc6, 0xd6, 0xde, 0x7c, 
0x0c, 0x0e, 0x00, 0x00, 0x00, 0x00, 0xfc, 0x66, 0x66, 0x66, 0x7c, 0x6c, 
0x66, 0x66, 0x66, 0xe6, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x7c, 0xc6, 
0xc6, 0x60, 0x38, 0x0c, 0x06, 0xc6, 0xc6, 0x7c, 0x00, 0x00, 0x00, 0x00, 
0x00, 0x00, 0xff, 0xdb, 0x99, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x3c, 
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xc6, 0xc6, 0xc6, 0xc6, 0xc6, 0xc6, 
0xc6, 0xc6, 0xc6, 0x7c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xc3, 0xc3, 
0xc3, 0xc3, 0xc3, 0xc3, 0xc3, 0x66, 0x3c, 0x18, 0x00, 0x00, 0x00, 0x00, 
0x00, 0x00, 0xc3, 0xc3, 0xc3, 0xc3, 0xc3, 0xdb, 0xdb, 0xff, 0x66, 0x66, 
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xc3, 0xc3, 0x66, 0x3c, 0x18, 0x18, 
0x3c, 0x66, 0xc3, 0xc3, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xc3, 0xc3, 
0xc3, 0x66, 0x3c, 0x18, 0x18, 0x18, 0x18, 0x3c, 0x00, 0x00, 0x00, 0x00, 
0x00, 0x00, 0xff, 0xc3, 0x86, 0x0c, 0x18, 0x30, 0x60, 0xc1, 0xc3, 0xff, 
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x3c, 0x30, 0x30, 0x30, 0x30, 0x30, 
0x30, 0x30, 0x30, 0x3c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80, 
0xc0, 0xe0, 0x70, 0x38, 0x1c, 0x0e, 0x06, 0x02, 0x00, 0x00, 0x00, 0x00, 
0x00, 0x00, 0x3c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x3c, 
0x00, 0x00, 0x00, 0x00, 0x10, 0x38, 0x6c, 0xc6, 0x00, 0x00, 0x00, 0x00, 
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 
0x30, 0x30, 0x18, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x78, 0x0c, 0x7c, 
0xcc, 0xcc, 0xcc, 0x76, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xe0, 0x60, 
0x60, 0x78, 0x6c, 0x66, 0x66, 0x66, 0x66, 0x7c, 0x00, 0x00, 0x00, 0x00, 
0x00, 0x00, 0x00, 0x00, 0x00, 0x7c, 0xc6, 0xc0, 0xc0, 0xc0, 0xc6, 0x7c, 
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x1c, 0x0c, 0x0c, 0x3c, 0x6c, 0xcc, 
0xcc, 0xcc, 0xcc, 0x76, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
0x00, 0x7c, 0xc6, 0xfe, 0xc0, 0xc0, 0xc6, 0x7c, 0x00, 0x00, 0x00, 0x00, 
0x00, 0x00, 0x38, 0x6c, 0x64, 0x60, 0xf0, 0x60, 0x60, 0x60, 0x60, 0xf0, 
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x76, 0xcc, 0xcc, 
0xcc, 0xcc, 0xcc, 0x7c, 0x0c, 0xcc, 0x78, 0x00, 0x00, 0x00, 0xe0, 0x60, 
0x60, 0x6c, 0x76, 0x66, 0x66, 0x66, 0x66, 0xe6, 0x00, 0x00, 0x00, 0x00, 
0x00, 0x00, 0x18, 0x18, 0x00, 0x38, 0x18, 0x18, 0x18, 0x18, 0x18, 0x3c, 
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x06, 0x06, 0x00, 0x0e, 0x06, 0x06, 
0x06, 0x06, 0x06, 0x06, 0x66, 0x66, 0x3c, 0x00, 0x00, 0x00, 0xe0, 0x60, 
0x60, 0x66, 0x6c, 0x78, 0x78, 0x6c, 0x66, 0xe6, 0x00, 0x00, 0x00, 0x00, 
0x00, 0x00, 0x38, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x3c, 
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xe6, 0xff, 0xdb, 
0xdb, 0xdb, 0xdb, 0xdb, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
0x00, 0xdc, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x00, 0x00, 0x00, 0x00, 
0x00, 0x00, 0x00, 0x00, 0x00, 0x7c, 0xc6, 0xc6, 0xc6, 0xc6, 0xc6, 0x7c, 
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xdc, 0x66, 0x66, 
0x66, 0x66, 0x66, 0x7c, 0x60, 0x60, 0xf0, 0x00, 0x00, 0x00, 0x00, 0x00, 
0x00, 0x76, 0xcc, 0xcc, 0xcc, 0xcc, 0xcc, 0x7c, 0x0c, 0x0c, 0x1e, 0x00, 
0x00, 0x00, 0x00, 0x00, 0x00, 0xdc, 0x76, 0x66, 0x60, 0x60, 0x60, 0xf0, 
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x7c, 0xc6, 0x60, 
0x38, 0x0c, 0xc6, 0x7c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x10, 0x30, 
0x30, 0xfc, 0x30, 0x30, 0x30, 0x30, 0x36, 0x1c, 0x00, 0x00, 0x00, 0x00, 
0x00, 0x00, 0x00, 0x00, 0x00, 0xcc, 0xcc, 0xcc, 0xcc, 0xcc, 0xcc, 0x76, 
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xc3, 0xc3, 0xc3, 
0xc3, 0x66, 0x3c, 0x18, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
0x00, 0xc3, 0xc3, 0xc3, 0xdb, 0xdb, 0xff, 0x66, 0x00, 0x00, 0x00, 0x00, 
0x00, 0x00, 0x00, 0x00, 0x00, 0xc3, 0x66, 0x3c, 0x18, 0x3c, 0x66, 0xc3, 
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xc6, 0xc6, 0xc6, 
0xc6, 0xc6, 0xc6, 0x7e, 0x06, 0x0c, 0xf8, 0x00, 0x00, 0x00, 0x00, 0x00, 
0x00, 0xfe, 0xcc, 0x18, 0x30, 0x60, 0xc6, 0xfe, 0x00, 0x00, 0x00, 0x00, 
0x00, 0x00, 0x0e, 0x18, 0x18, 0x18, 0x70, 0x18, 0x18, 0x18, 0x18, 0x0e, 
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x18, 0x18, 0x18, 0x18, 0x00, 0x18, 
0x18, 0x18, 0x18, 0x18, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x70, 0x18, 
0x18, 0x18, 0x0e, 0x18, 0x18, 0x18, 0x18, 0x70, 0x00, 0x00, 0x00, 0x00, 
0x00, 0x00, 0x76, 0xdc, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x10, 0x38, 0x6c, 0xc6, 
0xc6, 0xc6, 0xfe, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x3c, 0x66, 
0xc2, 0xc0, 0xc0, 0xc0, 0xc2, 0x66, 0x3c, 0x0c, 0x06, 0x7c, 0x00, 0x00, 
0x00, 0x00, 0xcc, 0x00, 0x00, 0xcc, 0xcc, 0xcc, 0xcc, 0xcc, 0xcc, 0x76, 
0x00, 0x00, 0x00, 0x00, 0x00, 0x0c, 0x18, 0x30, 0x00, 0x7c, 0xc6, 0xfe, 
0xc0, 0xc0, 0xc6, 0x7c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x10, 0x38, 0x6c, 
0x00, 0x78, 0x0c, 0x7c, 0xcc, 0xcc, 0xcc, 0x76, 0x00, 0x00, 0x00, 0x00, 
0x00, 0x00, 0xcc, 0x00, 0x00, 0x78, 0x0c, 0x7c, 0xcc, 0xcc, 0xcc, 0x76, 
0x00, 0x00, 0x00, 0x00, 0x00, 0x60, 0x30, 0x18, 0x00, 0x78, 0x0c, 0x7c, 
0xcc, 0xcc, 0xcc, 0x76, 0x00, 0x00, 0x00, 0x00, 0x00, 0x38, 0x6c, 0x38, 
0x00, 0x78, 0x0c, 0x7c, 0xcc, 0xcc, 0xcc, 0x76, 0x00, 0x00, 0x00, 0x00, 
0x00, 0x00, 0x00, 0x00, 0x3c, 0x66, 0x60, 0x60, 0x66, 0x3c, 0x0c, 0x06, 
0x3c, 0x00, 0x00, 0x00, 0x00, 0x10, 0x38, 0x6c, 0x00, 0x7c, 0xc6, 0xfe, 
0xc0, 0xc0, 0xc6, 0x7c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xc6, 0x00, 
0x00, 0x7c, 0xc6, 0xfe, 0xc0, 0xc0, 0xc6, 0x7c, 0x00, 0x00, 0x00, 0x00, 
0x00, 0x60, 0x30, 0x18, 0x00, 0x7c, 0xc6, 0xfe, 0xc0, 0xc0, 0xc6, 0x7c, 
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x66, 0x00, 0x00, 0x38, 0x18, 0x18, 
0x18, 0x18, 0x18, 0x3c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x18, 0x3c, 0x66, 
0x00, 0x38, 0x18, 0x18, 0x18, 0x18, 0x18, 0x3c, 0x00, 0x00, 0x00, 0x00, 
0x00, 0x60, 0x30, 0x18, 0x00, 0x38, 0x18, 0x18, 0x18, 0x18, 0x18, 0x3c, 
0x00, 0x00, 0x00, 0x00, 0x00, 0xc6, 0x00, 0x10, 0x38, 0x6c, 0xc6, 0xc6, 
0xfe, 0xc6, 0xc6, 0xc6, 0x00, 0x00, 0x00, 0x00, 0x38, 0x6c, 0x38, 0x00, 
0x38, 0x6c, 0xc6, 0xc6, 0xfe, 0xc6, 0xc6, 0xc6, 0x00, 0x00, 0x00, 0x00, 
0x18, 0x30, 0x60, 0x00, 0xfe, 0x66, 0x60, 0x7c, 0x60, 0x60, 0x66, 0xfe, 
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x6e, 0x3b, 0x1b, 
0x7e, 0xd8, 0xdc, 0x77, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x3e, 0x6c, 
0xcc, 0xcc, 0xfe, 0xcc, 0xcc, 0xcc, 0xcc, 0xce, 0x00, 0x00, 0x00, 0x00, 
0x00, 0x10, 0x38, 0x6c, 0x00, 0x7c, 0xc6, 0xc6, 0xc6, 0xc6, 0xc6, 0x7c, 
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xc6, 0x00, 0x00, 0x7c, 0xc6, 0xc6, 
0xc6, 0xc6, 0xc6, 0x7c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x60, 0x30, 0x18, 
0x00, 0x7c, 0xc6, 0xc6, 0xc6, 0xc6, 0xc6, 0x7c, 0x00, 0x00, 0x00, 0x00, 
0x00, 0x30, 0x78, 0xcc, 0x00, 0xcc, 0xcc, 0xcc, 0xcc, 0xcc, 0xcc, 0x76, 
0x00, 0x00, 0x00, 0x00, 0x00, 0x60, 0x30, 0x18, 0x00, 0xcc, 0xcc, 0xcc, 
0xcc, 0xcc, 0xcc, 0x76, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xc6, 0x00, 
0x00, 0xc6, 0xc6, 0xc6, 0xc6, 0xc6, 0xc6, 0x7e, 0x06, 0x0c, 0x78, 0x00, 
0x00, 0xc6, 0x00, 0x7c, 0xc6, 0xc6, 0xc6, 0xc6, 0xc6, 0xc6, 0xc6, 0x7c, 
0x00, 0x00, 0x00, 0x00, 0x00, 0xc6, 0x00, 0xc6, 0xc6, 0xc6, 0xc6, 0xc6, 
0xc6, 0xc6, 0xc6, 0x7c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x18, 0x18, 0x7e, 
0xc3, 0xc0, 0xc0, 0xc0, 0xc3, 0x7e, 0x18, 0x18, 0x00, 0x00, 0x00, 0x00, 
0x00, 0x38, 0x6c, 0x64, 0x60, 0xf0, 0x60, 0x60, 0x60, 0x60, 0xe6, 0xfc, 
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xc3, 0x66, 0x3c, 0x18, 0xff, 0x18, 
0xff, 0x18, 0x18, 0x18, 0x00, 0x00, 0x00, 0x00, 0x00, 0xfc, 0x66, 0x66, 
0x7c, 0x62, 0x66, 0x6f, 0x66, 0x66, 0x66, 0xf3, 0x00, 0x00, 0x00, 0x00, 
0x00, 0x0e, 0x1b, 0x18, 0x18, 0x18, 0x7e, 0x18, 0x18, 0x18, 0x18, 0x18, 
0xd8, 0x70, 0x00, 0x00, 0x00, 0x18, 0x30, 0x60, 0x00, 0x78, 0x0c, 0x7c, 
0xcc, 0xcc, 0xcc, 0x76, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0c, 0x18, 0x30, 
0x00, 0x38, 0x18, 0x18, 0x18, 0x18, 0x18, 0x3c, 0x00, 0x00, 0x00, 0x00, 
0x00, 0x18, 0x30, 0x60, 0x00, 0x7c, 0xc6, 0xc6, 0xc6, 0xc6, 0xc6, 0x7c, 
0x00, 0x00, 0x00, 0x00, 0x00, 0x18, 0x30, 0x60, 0x00, 0xcc, 0xcc, 0xcc, 
0xcc, 0xcc, 0xcc, 0x76, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x76, 0xdc, 
0x00, 0xdc, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x00, 0x00, 0x00, 0x00, 
0x76, 0xdc, 0x00, 0xc6, 0xe6, 0xf6, 0xfe, 0xde, 0xce, 0xc6, 0xc6, 0xc6, 
0x00, 0x00, 0x00, 0x00, 0x00, 0x3c, 0x6c, 0x6c, 0x3e, 0x00, 0x7e, 0x00, 
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x38, 0x6c, 0x6c, 
0x38, 0x00, 0x7c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
0x00, 0x00, 0x30, 0x30, 0x00, 0x30, 0x30, 0x60, 0xc0, 0xc6, 0xc6, 0x7c, 
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xfe, 0xc0, 
0xc0, 0xc0, 0xc0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
0x00, 0x00, 0xfe, 0x06, 0x06, 0x06, 0x06, 0x00, 0x00, 0x00, 0x00, 0x00, 
0x00, 0xc0, 0xc0, 0xc2, 0xc6, 0xcc, 0x18, 0x30, 0x60, 0xce, 0x9b, 0x06, 
0x0c, 0x1f, 0x00, 0x00, 0x00, 0xc0, 0xc0, 0xc2, 0xc6, 0xcc, 0x18, 0x30, 
0x66, 0xce, 0x96, 0x3e, 0x06, 0x06, 0x00, 0x00, 0x00, 0x00, 0x18, 0x18, 
0x00, 0x18, 0x18, 0x18, 0x3c, 0x3c, 0x3c, 0x18, 0x00, 0x00, 0x00, 0x00, 
0x00, 0x00, 0x00, 0x00, 0x00, 0x36, 0x6c, 0xd8, 0x6c, 0x36, 0x00, 0x00, 
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xd8, 0x6c, 0x36, 
0x6c, 0xd8, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x11, 0x44, 0x11, 0x44, 
0x11, 0x44, 0x11, 0x44, 0x11, 0x44, 0x11, 0x44, 0x11, 0x44, 0x11, 0x44, 
0x55, 0xaa, 0x55, 0xaa, 0x55, 0xaa, 0x55, 0xaa, 0x55, 0xaa, 0x55, 0xaa, 
0x55, 0xaa, 0x55, 0xaa, 0xdd, 0x77, 0xdd, 0x77, 0xdd, 0x77, 0xdd, 0x77, 
0xdd, 0x77, 0xdd, 0x77, 0xdd, 0x77, 0xdd, 0x77, 0x18, 0x18, 0x18, 0x18, 
0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 
0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0xf8, 0x18, 0x18, 0x18, 0x18, 
0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0xf8, 0x18, 0xf8, 
0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x36, 0x36, 0x36, 0x36, 
0x36, 0x36, 0x36, 0xf6, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xfe, 0x36, 0x36, 0x36, 0x36, 
0x36, 0x36, 0x36, 0x36, 0x00, 0x00, 0x00, 0x00, 0x00, 0xf8, 0x18, 0xf8, 
0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x36, 0x36, 0x36, 0x36, 
0x36, 0xf6, 0x06, 0xf6, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 
0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 
0x36, 0x36, 0x36, 0x36, 0x00, 0x00, 0x00, 0x00, 0x00, 0xfe, 0x06, 0xf6, 
0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 
0x36, 0xf6, 0x06, 0xfe, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0xfe, 0x00, 0x00, 0x00, 0x00, 
0x00, 0x00, 0x00, 0x00, 0x18, 0x18, 0x18, 0x18, 0x18, 0xf8, 0x18, 0xf8, 
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
0x00, 0x00, 0x00, 0xf8, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 
0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x1f, 0x00, 0x00, 0x00, 0x00, 
0x00, 0x00, 0x00, 0x00, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0xff, 
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
0x00, 0x00, 0x00, 0xff, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 
0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x1f, 0x18, 0x18, 0x18, 0x18, 
0x18, 0x18, 0x18, 0x18, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x18, 0x18, 0x18, 0x18, 
0x18, 0x18, 0x18, 0xff, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 
0x18, 0x18, 0x18, 0x18, 0x18, 0x1f, 0x18, 0x1f, 0x18, 0x18, 0x18, 0x18, 
0x18, 0x18, 0x18, 0x18, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x37, 
0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 
0x36, 0x37, 0x30, 0x3f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
0x00, 0x00, 0x00, 0x00, 0x00, 0x3f, 0x30, 0x37, 0x36, 0x36, 0x36, 0x36, 
0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0xf7, 0x00, 0xff, 
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
0x00, 0xff, 0x00, 0xf7, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 
0x36, 0x36, 0x36, 0x36, 0x36, 0x37, 0x30, 0x37, 0x36, 0x36, 0x36, 0x36, 
0x36, 0x36, 0x36, 0x36, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0x00, 0xff, 
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x36, 0x36, 0x36, 0x36, 
0x36, 0xf7, 0x00, 0xf7, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 
0x18, 0x18, 0x18, 0x18, 0x18, 0xff, 0x00, 0xff, 0x00, 0x00, 0x00, 0x00, 
0x00, 0x00, 0x00, 0x00, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0xff, 
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
0x00, 0xff, 0x00, 0xff, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0x36, 0x36, 0x36, 0x36, 
0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x3f, 
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x18, 0x18, 0x18, 0x18, 
0x18, 0x1f, 0x18, 0x1f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
0x00, 0x00, 0x00, 0x00, 0x00, 0x1f, 0x18, 0x1f, 0x18, 0x18, 0x18, 0x18, 
0x18, 0x18, 0x18, 0x18, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x3f, 
0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 
0x36, 0x36, 0x36, 0xff, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 0x36, 
0x18, 0x18, 0x18, 0x18, 0x18, 0xff, 0x18, 0xff, 0x18, 0x18, 0x18, 0x18, 
0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0xf8, 
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
0x00, 0x00, 0x00, 0x1f, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 
0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xf0, 0xf0, 0xf0, 0xf0, 
0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 
0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 
0x0f, 0x0f, 0x0f, 0x0f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
0x00, 0x76, 0xdc, 0xd8, 0xd8, 0xd8, 0xdc, 0x76, 0x00, 0x00, 0x00, 0x00, 
0x00, 0x00, 0x78, 0xcc, 0xcc, 0xcc, 0xd8, 0xcc, 0xc6, 0xc6, 0xc6, 0xcc, 
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xfe, 0xc6, 0xc6, 0xc0, 0xc0, 0xc0, 
0xc0, 0xc0, 0xc0, 0xc0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
0xfe, 0x6c, 0x6c, 0x6c, 0x6c, 0x6c, 0x6c, 0x6c, 0x00, 0x00, 0x00, 0x00, 
0x00, 0x00, 0x00, 0xfe, 0xc6, 0x60, 0x30, 0x18, 0x30, 0x60, 0xc6, 0xfe, 
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x7e, 0xd8, 0xd8, 
0xd8, 0xd8, 0xd8, 0x70, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
0x66, 0x66, 0x66, 0x66, 0x66, 0x7c, 0x60, 0x60, 0xc0, 0x00, 0x00, 0x00, 
0x00, 0x00, 0x00, 0x00, 0x76, 0xdc, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x7e, 0x18, 0x3c, 0x66, 0x66, 
0x66, 0x3c, 0x18, 0x7e, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x38, 
0x6c, 0xc6, 0xc6, 0xfe, 0xc6, 0xc6, 0x6c, 0x38, 0x00, 0x00, 0x00, 0x00, 
0x00, 0x00, 0x38, 0x6c, 0xc6, 0xc6, 0xc6, 0x6c, 0x6c, 0x6c, 0x6c, 0xee, 
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x1e, 0x30, 0x18, 0x0c, 0x3e, 0x66, 
0x66, 0x66, 0x66, 0x3c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
0x00, 0x7e, 0xdb, 0xdb, 0xdb, 0x7e, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
0x00, 0x00, 0x00, 0x03, 0x06, 0x7e, 0xdb, 0xdb, 0xf3, 0x7e, 0x60, 0xc0, 
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x1c, 0x30, 0x60, 0x60, 0x7c, 0x60, 
0x60, 0x60, 0x30, 0x1c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x7c, 
0xc6, 0xc6, 0xc6, 0xc6, 0xc6, 0xc6, 0xc6, 0xc6, 0x00, 0x00, 0x00, 0x00, 
0x00, 0x00, 0x00, 0x00, 0xfe, 0x00, 0x00, 0xfe, 0x00, 0x00, 0xfe, 0x00, 
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x18, 0x18, 0x7e, 0x18, 
0x18, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x30, 
0x18, 0x0c, 0x06, 0x0c, 0x18, 0x30, 0x00, 0x7e, 0x00, 0x00, 0x00, 0x00, 
0x00, 0x00, 0x00, 0x0c, 0x18, 0x30, 0x60, 0x30, 0x18, 0x0c, 0x00, 0x7e, 
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0e, 0x1b, 0x1b, 0x1b, 0x18, 0x18, 
0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 
0x18, 0x18, 0x18, 0x18, 0xd8, 0xd8, 0xd8, 0x70, 0x00, 0x00, 0x00, 0x00, 
0x00, 0x00, 0x00, 0x00, 0x18, 0x18, 0x00, 0x7e, 0x00, 0x18, 0x18, 0x00, 
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x76, 0xdc, 0x00, 
0x76, 0xdc, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x38, 0x6c, 0x6c, 
0x38, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x18, 0x18, 0x00, 0x00, 0x00, 
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
0x18, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0f, 0x0c, 0x0c, 
0x0c, 0x0c, 0x0c, 0xec, 0x6c, 0x6c, 0x3c, 0x1c, 0x00, 0x00, 0x00, 0x00, 
0x00, 0xd8, 0x6c, 0x6c, 0x6c, 0x6c, 0x6c, 0x00, 0x00, 0x00, 0x00, 0x00, 
0x00, 0x00, 0x00, 0x00, 0x00, 0x70, 0xd8, 0x30, 0x60, 0xc8, 0xf8, 0x00, 
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
0x7c, 0x7c, 0x7c, 0x7c, 0x7c, 0x7c, 0x7c, 0x00, 0x00, 0x00, 0x00, 0x00, 
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
0x00, 0x00, 0x00, 0x00, 
};

#endif /* CONFIG_BOOTX_TEXT */