v86 0.3.7 → 0.5.10

package/bios/seabios/src/e820map.c

@@ -1,152 +0,0 @@
-// Support for building memory maps suitable for int 15 e820 calls.
-//
-// Copyright (C) 2008,2009  Kevin O'Connor <kevin@koconnor.net>
-//
-// This file may be distributed under the terms of the GNU LGPLv3 license.
-
-#include "config.h" // BUILD_MAX_E820
-#include "e820map.h" // struct e820entry
-#include "output.h" // dprintf
-#include "string.h" // memmove
-
-
-/****************************************************************
- * e820 memory map
- ****************************************************************/
-
-// Info on e820 map location and size.
-struct e820entry e820_list[BUILD_MAX_E820] VARFSEG;
-int e820_count VARFSEG;
-
-// Remove an entry from the e820_list.
-static void
-remove_e820(int i)
-{
-    e820_count--;
-    memmove(&e820_list[i], &e820_list[i+1]
-            , sizeof(e820_list[0]) * (e820_count - i));
-}
-
-// Insert an entry in the e820_list at the given position.
-static void
-insert_e820(int i, u64 start, u64 size, u32 type)
-{
-    if (e820_count >= BUILD_MAX_E820) {
-        warn_noalloc();
-        return;
-    }
-
-    memmove(&e820_list[i+1], &e820_list[i]
-            , sizeof(e820_list[0]) * (e820_count - i));
-    e820_count++;
-    struct e820entry *e = &e820_list[i];
-    e->start = start;
-    e->size = size;
-    e->type = type;
-}
-
-static const char *
-e820_type_name(u32 type)
-{
-    switch (type) {
-    case E820_RAM:      return "RAM";
-    case E820_RESERVED: return "RESERVED";
-    case E820_ACPI:     return "ACPI";
-    case E820_NVS:      return "NVS";
-    case E820_UNUSABLE: return "UNUSABLE";
-    default:            return "UNKNOWN";
-    }
-}
-
-// Show the current e820_list.
-static void
-dump_map(void)
-{
-    dprintf(1, "e820 map has %d items:\n", e820_count);
-    int i;
-    for (i=0; i<e820_count; i++) {
-        struct e820entry *e = &e820_list[i];
-        u64 e_end = e->start + e->size;
-        dprintf(1, "  %d: %016llx - %016llx = %d %s\n", i
-                , e->start, e_end, e->type, e820_type_name(e->type));
-    }
-}
-
-#define E820_HOLE         ((u32)-1) // Used internally to remove entries
-
-// Add a new entry to the list.  This scans for overlaps and keeps the
-// list sorted.
-void
-e820_add(u64 start, u64 size, u32 type)
-{
-    dprintf(8, "Add to e820 map: %08llx %08llx %d\n", start, size, type);
-
-    if (! size)
-        // Huh?  Nothing to do.
-        return;
-
-    // Find position of new item (splitting existing item if needed).
-    u64 end = start + size;
-    int i;
-    for (i=0; i<e820_count; i++) {
-        struct e820entry *e = &e820_list[i];
-        u64 e_end = e->start + e->size;
-        if (start > e_end)
-            continue;
-        // Found position - check if an existing item needs to be split.
-        if (start > e->start) {
-            if (type == e->type) {
-                // Same type - merge them.
-                size += start - e->start;
-                start = e->start;
-            } else {
-                // Split existing item.
-                e->size = start - e->start;
-                i++;
-                if (e_end > end)
-                    insert_e820(i, end, e_end - end, e->type);
-            }
-        }
-        break;
-    }
-    // Remove/adjust existing items that are overlapping.
-    while (i<e820_count) {
-        struct e820entry *e = &e820_list[i];
-        if (end < e->start)
-            // No overlap - done.
-            break;
-        u64 e_end = e->start + e->size;
-        if (end >= e_end) {
-            // Existing item completely overlapped - remove it.
-            remove_e820(i);
-            continue;
-        }
-        // Not completely overlapped - adjust its start.
-        e->start = end;
-        e->size = e_end - end;
-        if (type == e->type) {
-            // Same type - merge them.
-            size += e->size;
-            remove_e820(i);
-        }
-        break;
-    }
-    // Insert new item.
-    if (type != E820_HOLE)
-        insert_e820(i, start, size, type);
-    //dump_map();
-}
-
-// Remove any definitions in a memory range (make a memory hole).
-void
-e820_remove(u64 start, u64 size)
-{
-    e820_add(start, size, E820_HOLE);
-}
-
-// Report on final memory locations.
-void
-e820_prepboot(void)
-{
-    dump_map();
-}

package/bios/seabios/src/e820map.h

@@ -1,26 +0,0 @@
-#ifndef __E820MAP_H
-#define __E820MAP_H
-
-#include "types.h" // u64
-
-#define E820_RAM          1
-#define E820_RESERVED     2
-#define E820_ACPI         3
-#define E820_NVS          4
-#define E820_UNUSABLE     5
-
-struct e820entry {
-    u64 start;
-    u64 size;
-    u32 type;
-};
-
-void e820_add(u64 start, u64 size, u32 type);
-void e820_remove(u64 start, u64 size);
-void e820_prepboot(void);
-
-// e820 map storage
-extern struct e820entry e820_list[];
-extern int e820_count;
-
-#endif // e820map.h

package/bios/seabios/src/entryfuncs.S

@@ -1,165 +0,0 @@
-// Macros for entering C code
-//
-// Copyright (C) 2008-2014  Kevin O'Connor <kevin@koconnor.net>
-//
-// This file may be distributed under the terms of the GNU LGPLv3 license.
-
-
-/****************************************************************
- * Macros for save and restore of 'struct bregs' registers
- ****************************************************************/
-
-#define PUSHBREGS_size 32
-
-        // Save registers (matches struct bregs) to stack
-        .macro PUSHBREGS
-        pushl %eax
-        pushl %ecx
-        pushl %edx
-        pushl %ebx
-        pushl %ebp
-        pushl %esi
-        pushl %edi
-        pushw %es
-        pushw %ds
-        .endm
-
-        // Restore registers (from struct bregs) from stack
-        .macro POPBREGS
-        popw %ds
-        popw %es
-        popl %edi
-        popl %esi
-        popl %ebp
-        popl %ebx
-        popl %edx
-        popl %ecx
-        popl %eax
-        .endm
-
-        // Save registers to struct bregs at %ds:%eax.  The caller
-        // should "pushw %ds ; pushl %eax" prior to calling - this macro
-        // will pop them off.
-        .macro SAVEBREGS_POP_DSEAX
-        popl BREGS_eax(%eax)
-        popw BREGS_ds(%eax)
-        movl %edi, BREGS_edi(%eax)
-        movl %esi, BREGS_esi(%eax)
-        movl %ebp, BREGS_ebp(%eax)
-        movl %ebx, BREGS_ebx(%eax)
-        movl %edx, BREGS_edx(%eax)
-        movl %ecx, BREGS_ecx(%eax)
-        movw %es, BREGS_es(%eax)
-        .endm
-
-        // Restore registers from struct bregs at %ds:%eax
-        .macro RESTOREBREGS_DSEAX
-        movl BREGS_edi(%eax), %edi
-        movl BREGS_esi(%eax), %esi
-        movl BREGS_ebp(%eax), %ebp
-        movl BREGS_ebx(%eax), %ebx
-        movl BREGS_edx(%eax), %edx
-        movl BREGS_ecx(%eax), %ecx
-        movw BREGS_es(%eax), %es
-        pushl BREGS_eax(%eax)
-        movw BREGS_ds(%eax), %ds
-        popl %eax
-        .endm
-
-
-/****************************************************************
- * Entry macros
- ****************************************************************/
-
-        // Call a C function - this does the minimal work necessary to
-        // call into C.  It sets up %ds, backs up %es, and backs up
-        // those registers that are call clobbered by the C compiler.
-        .macro ENTRY cfunc
-        cli         // In case something far-calls instead of using "int"
-        cld
-        pushl %eax              // Save registers clobbered by C code
-        pushl %ecx
-        pushl %edx
-        pushw %es
-        pushw %ds
-        movw %ss, %ax           // Move %ss to %ds
-        movw %ax, %ds
-        pushl %esp              // Backup %esp, then clear high bits
-        movzwl %sp, %esp
-        calll \cfunc
-        popl %esp               // Restore %esp (including high bits)
-        popw %ds                // Restore registers saved above
-        popw %es
-        popl %edx
-        popl %ecx
-        popl %eax
-        .endm
-
-        // Call a C function with current register list as an
-        // argument.  This backs up the registers and sets %eax
-        // to point to the backup.  On return, the registers are
-        // restored from the structure.
-        .macro ENTRY_ARG cfunc
-        cli
-        cld
-        PUSHBREGS
-        movw %ss, %ax           // Move %ss to %ds
-        movw %ax, %ds
-        movl %esp, %ebx         // Backup %esp, then zero high bits
-        movzwl %sp, %esp
-        movl %esp, %eax         // First arg is pointer to struct bregs
-        calll \cfunc
-        movl %ebx, %esp         // Restore %esp (including high bits)
-        POPBREGS
-        .endm
-
-        // As above, but get calling function from stack.
-        .macro ENTRY_ARG_ST
-        cli
-        cld
-        pushl %ecx
-        pushl %edx
-        pushl %ebx
-        pushl %ebp
-        pushl %esi
-        pushl %edi
-        pushw %es
-        pushw %ds
-        movw %ss, %cx           // Move %ss to %ds
-        movw %cx, %ds
-        movl %esp, %ebx         // Backup %esp, then zero high bits
-        movzwl %sp, %esp
-        movl 28(%esp), %ecx     // Get calling function
-        movl %eax, 28(%esp)     // Save %eax
-        movl %esp, %eax         // First arg is pointer to struct bregs
-        calll *%ecx
-        movl %ebx, %esp         // Restore %esp (including high bits)
-        POPBREGS
-        .endm
-
-        // Same as ENTRY_ARG, but don't mangle %esp
-        .macro ENTRY_ARG_ESP cfunc
-        cli
-        cld
-        PUSHBREGS
-        movw %ss, %ax           // Move %ss to %ds
-        movw %ax, %ds
-        movl %esp, %eax         // First arg is pointer to struct bregs
-        calll \cfunc
-        POPBREGS
-        .endm
-
-        // Reset stack, transition to 32bit mode, and call a C function.
-        .macro ENTRY_INTO32 cfunc
-        xorw %dx, %dx
-        movw %dx, %ss
-        movl $ BUILD_STACK_ADDR , %esp
-        movl $ \cfunc , %edx
-        jmp transition32
-        .endm
-
-        // Declare a function
-        .macro DECLFUNC func
-        .section .text.asm.\func
-        .global \func
-        .endm

package/bios/seabios/src/farptr.h

@@ -1,208 +0,0 @@
-// Code to access multiple segments within gcc.
-//
-// Copyright (C) 2008,2009  Kevin O'Connor <kevin@koconnor.net>
-//
-// This file may be distributed under the terms of the GNU LGPLv3 license.
-#ifndef __FARPTR_H
-#define __FARPTR_H
-
-#include "x86.h" // insb
-
-// Dummy definitions used to make sure gcc understands dependencies
-// between SET_SEG and GET/READ/WRITE_SEG macros.
-extern u16 __segment_ES, __segment_CS, __segment_DS, __segment_SS;
-extern u16 __segment_FS, __segment_GS;
-
-// Low level macros for reading/writing memory via a segment selector.
-#define READ8_SEG(prefix, SEG, value, var)                      \
-    __asm__(prefix "movb %%" #SEG ":%1, %b0" : "=Qi"(value)     \
-            : "m"(var), "m"(__segment_ ## SEG))
-#define READ16_SEG(prefix, SEG, value, var)                     \
-    __asm__(prefix "movw %%" #SEG ":%1, %w0" : "=ri"(value)     \
-            : "m"(var), "m"(__segment_ ## SEG))
-#define READ32_SEG(prefix, SEG, value, var)                     \
-    __asm__(prefix "movl %%" #SEG ":%1, %0" : "=ri"(value)      \
-            : "m"(var), "m"(__segment_ ## SEG))
-#define READ64_SEG(prefix, SEG, value, var) do {                \
-        union u64_u32_u __value;                                \
-        union u64_u32_u *__r64_ptr = (union u64_u32_u *)&(var); \
-        READ32_SEG(prefix, SEG, __value.lo, __r64_ptr->lo);     \
-        READ32_SEG(prefix, SEG, __value.hi, __r64_ptr->hi);     \
-        *(u64*)&(value) = __value.val;                          \
-    } while (0)
-#define WRITE8_SEG(prefix, SEG, var, value)                     \
-    __asm__(prefix "movb %b1, %%" #SEG ":%0" : "=m"(var)        \
-            : "Q"(value), "m"(__segment_ ## SEG))
-#define WRITE16_SEG(prefix, SEG, var, value)                    \
-    __asm__(prefix "movw %w1, %%" #SEG ":%0" : "=m"(var)        \
-            : "r"(value), "m"(__segment_ ## SEG))
-#define WRITE32_SEG(prefix, SEG, var, value)                    \
-    __asm__(prefix "movl %1, %%" #SEG ":%0" : "=m"(var)         \
-            : "r"(value), "m"(__segment_ ## SEG))
-#define WRITE64_SEG(prefix, SEG, var, value) do {               \
-        union u64_u32_u __value;                                \
-        union u64_u32_u *__w64_ptr = (union u64_u32_u *)&(var); \
-        typeof(var) __value_tmp = (value);                      \
-        __value.val = *(u64*)&__value_tmp;                      \
-        WRITE32_SEG(prefix, SEG, __w64_ptr->lo, __value.lo);    \
-        WRITE32_SEG(prefix, SEG, __w64_ptr->hi, __value.hi);    \
-    } while (0)
-
-// Macros for automatically choosing the appropriate memory size
-// access method.
-extern void __force_link_error__unknown_type(void);
-
-#define __GET_VAR(prefix, seg, var) ({          \
-    typeof(var) __val;                          \
-    if (sizeof(__val) == 1)                     \
-        READ8_SEG(prefix, seg, __val, var);     \
-    else if (sizeof(__val) == 2)                \
-        READ16_SEG(prefix, seg, __val, var);    \
-    else if (sizeof(__val) == 4)                \
-        READ32_SEG(prefix, seg, __val, var);    \
-    else if (sizeof(__val) == 8)                \
-        READ64_SEG(prefix, seg, __val, var);    \
-    else                                        \
-        __force_link_error__unknown_type();     \
-    __val; })
-
-#define __SET_VAR(prefix, seg, var, val) do {           \
-        if (sizeof(var) == 1)                           \
-            WRITE8_SEG(prefix, seg, var, (val));        \
-        else if (sizeof(var) == 2)                      \
-            WRITE16_SEG(prefix, seg, var, (val));       \
-        else if (sizeof(var) == 4)                      \
-            WRITE32_SEG(prefix, seg, var, (val));       \
-        else if (sizeof(var) == 8)                      \
-            WRITE64_SEG(prefix, seg, var, (val));       \
-        else                                            \
-            __force_link_error__unknown_type();         \
-    } while (0)
-
-#define DECL_SEGFUNCS(SEG)                              \
-static inline void __set_seg_##SEG(u16 seg) {           \
-    __asm__("movw %w1, %%" #SEG : "=m"(__segment_##SEG) \
-            : "rm"(seg));                               \
-}                                                       \
-static inline u16 __get_seg_##SEG(void) {               \
-    u16 res;                                            \
-    __asm__("movw %%" #SEG ", %w0" : "=rm"(res)         \
-            : "m"(__segment_##SEG));                    \
-    return res;                                         \
-}
-DECL_SEGFUNCS(CS)
-DECL_SEGFUNCS(DS)
-DECL_SEGFUNCS(ES)
-DECL_SEGFUNCS(FS)
-DECL_SEGFUNCS(GS)
-DECL_SEGFUNCS(SS)
-
-// Low level macros for getting/setting a segment register.
-#define __SET_SEG(SEG, value)                   \
-    __set_seg_##SEG(value)
-#define __GET_SEG(SEG)                          \
-    __get_seg_##SEG()
-
-// Macros for accessing a variable in another segment.  (They
-// automatically update the %es segment and then make the appropriate
-// access.)
-#define __GET_FARVAR(seg, var) ({               \
-    SET_SEG(ES, (seg));                         \
-    GET_VAR(ES, (var)); })
-#define __SET_FARVAR(seg, var, val) do {        \
-        typeof(var) __sfv_val = (val);          \
-        SET_SEG(ES, (seg));                     \
-        SET_VAR(ES, (var), __sfv_val);          \
-    } while (0)
-
-// Macros for accesssing a 32bit flat mode pointer from 16bit real
-// mode.  (They automatically update the %es segment, break the
-// pointer into segment/offset, and then make the access.)
-#define __GET_FLATPTR(ptr) ({                                   \
-    typeof(&(ptr)) __ptr = &(ptr);                              \
-    GET_FARVAR(FLATPTR_TO_SEG(__ptr)                            \
-               , *(typeof(__ptr))FLATPTR_TO_OFFSET(__ptr)); })
-#define __SET_FLATPTR(ptr, val) do {                            \
-        typeof (&(ptr)) __ptr = &(ptr);                         \
-        SET_FARVAR(FLATPTR_TO_SEG(__ptr)                        \
-                   , *(typeof(__ptr))FLATPTR_TO_OFFSET(__ptr)   \
-                   , (val));                                    \
-    } while (0)
-
-// Macros for converting to/from 32bit flat mode pointers to their
-// equivalent 16bit segment/offset values.
-#define FLATPTR_TO_SEG(p) (((u32)(p)) >> 4)
-#define FLATPTR_TO_OFFSET(p) (((u32)(p)) & 0xf)
-#define MAKE_FLATPTR(seg,off) ((void*)(((u32)(seg)<<4)+(u32)(off)))
-
-
-#if MODESEGMENT == 1
-
-// Definitions when using segmented mode.
-#define GET_FARVAR(seg, var) __GET_FARVAR((seg), (var))
-#define SET_FARVAR(seg, var, val) __SET_FARVAR((seg), (var), (val))
-#define GET_VAR(seg, var) __GET_VAR("", seg, (var))
-#define SET_VAR(seg, var, val) __SET_VAR("", seg, (var), (val))
-#define SET_SEG(SEG, value) __SET_SEG(SEG, (value))
-#define GET_SEG(SEG) __GET_SEG(SEG)
-#define GET_FLATPTR(ptr) __GET_FLATPTR(ptr)
-#define SET_FLATPTR(ptr, val) __SET_FLATPTR((ptr), (val))
-
-static inline void insb_fl(u16 port, void *ptr_fl, u16 count) {
-    SET_SEG(ES, FLATPTR_TO_SEG(ptr_fl));
-    insb(port, (u8*)FLATPTR_TO_OFFSET(ptr_fl), count);
-}
-static inline void insw_fl(u16 port, void *ptr_fl, u16 count) {
-    SET_SEG(ES, FLATPTR_TO_SEG(ptr_fl));
-    insw(port, (u16*)FLATPTR_TO_OFFSET(ptr_fl), count);
-}
-static inline void insl_fl(u16 port, void *ptr_fl, u16 count) {
-    SET_SEG(ES, FLATPTR_TO_SEG(ptr_fl));
-    insl(port, (u32*)FLATPTR_TO_OFFSET(ptr_fl), count);
-}
-static inline void outsb_fl(u16 port, void *ptr_fl, u16 count) {
-    SET_SEG(ES, FLATPTR_TO_SEG(ptr_fl));
-    outsb(port, (u8*)FLATPTR_TO_OFFSET(ptr_fl), count);
-}
-static inline void outsw_fl(u16 port, void *ptr_fl, u16 count) {
-    SET_SEG(ES, FLATPTR_TO_SEG(ptr_fl));
-    outsw(port, (u16*)FLATPTR_TO_OFFSET(ptr_fl), count);
-}
-static inline void outsl_fl(u16 port, void *ptr_fl, u16 count) {
-    SET_SEG(ES, FLATPTR_TO_SEG(ptr_fl));
-    outsl(port, (u32*)FLATPTR_TO_OFFSET(ptr_fl), count);
-}
-
-#else
-
-// In 32-bit flat mode there is no need to mess with the segments.
-#define GET_FARVAR(seg, var) \
-    (*((typeof(&(var)))MAKE_FLATPTR((seg), &(var))))
-#define SET_FARVAR(seg, var, val) \
-    do { GET_FARVAR((seg), (var)) = (val); } while (0)
-#define GET_VAR(seg, var) (var)
-#define SET_VAR(seg, var, val) do { (var) = (val); } while (0)
-#define SET_SEG(SEG, value) ((void)(value))
-#define GET_SEG(SEG) 0
-#define GET_FLATPTR(ptr) (ptr)
-#define SET_FLATPTR(ptr, val) do { (ptr) = (val); } while (0)
-
-#define insb_fl(port, ptr_fl, count) insb(port, ptr_fl, count)
-#define insw_fl(port, ptr_fl, count) insw(port, ptr_fl, count)
-#define insl_fl(port, ptr_fl, count) insl(port, ptr_fl, count)
-#define outsb_fl(port, ptr_fl, count) outsb(port, ptr_fl, count)
-#define outsw_fl(port, ptr_fl, count) outsw(port, ptr_fl, count)
-#define outsl_fl(port, ptr_fl, count) outsl(port, ptr_fl, count)
-
-#endif
-
-#define SEGOFF(s,o) ({struct segoff_s __so; __so.offset=(o); __so.seg=(s); __so;})
-
-static inline struct segoff_s FLATPTR_TO_SEGOFF(void *p) {
-    return SEGOFF(FLATPTR_TO_SEG(p), FLATPTR_TO_OFFSET(p));
-}
-static inline void *SEGOFF_TO_FLATPTR(struct segoff_s so) {
-    return MAKE_FLATPTR(so.seg, so.offset);
-}
-
-#endif // farptr.h

package/bios/seabios/src/font.c

@@ -1,139 +0,0 @@
-#include "types.h" // u8
-
-// Character Font for 320x200 & 640x200 Graphics (lower 128 characters)
-
-/*
- * This font comes from the fntcol16.zip package (c) by  Joseph Gil
- * found at ftp://ftp.simtel.net/pub/simtelnet/msdos/screen/fntcol16.zip
- * This font is public domain
- */
-u8 vgafont8[128*8] VARFSEGFIXED(0xfa6e) = {
-    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-    0x7e, 0x81, 0xa5, 0x81, 0xbd, 0x99, 0x81, 0x7e,
-    0x7e, 0xff, 0xdb, 0xff, 0xc3, 0xe7, 0xff, 0x7e,
-    0x6c, 0xfe, 0xfe, 0xfe, 0x7c, 0x38, 0x10, 0x00,
-    0x10, 0x38, 0x7c, 0xfe, 0x7c, 0x38, 0x10, 0x00,
-    0x38, 0x7c, 0x38, 0xfe, 0xfe, 0x7c, 0x38, 0x7c,
-    0x10, 0x10, 0x38, 0x7c, 0xfe, 0x7c, 0x38, 0x7c,
-    0x00, 0x00, 0x18, 0x3c, 0x3c, 0x18, 0x00, 0x00,
-    0xff, 0xff, 0xe7, 0xc3, 0xc3, 0xe7, 0xff, 0xff,
-    0x00, 0x3c, 0x66, 0x42, 0x42, 0x66, 0x3c, 0x00,
-    0xff, 0xc3, 0x99, 0xbd, 0xbd, 0x99, 0xc3, 0xff,
-    0x0f, 0x07, 0x0f, 0x7d, 0xcc, 0xcc, 0xcc, 0x78,
-    0x3c, 0x66, 0x66, 0x66, 0x3c, 0x18, 0x7e, 0x18,
-    0x3f, 0x33, 0x3f, 0x30, 0x30, 0x70, 0xf0, 0xe0,
-    0x7f, 0x63, 0x7f, 0x63, 0x63, 0x67, 0xe6, 0xc0,
-    0x99, 0x5a, 0x3c, 0xe7, 0xe7, 0x3c, 0x5a, 0x99,
-    0x80, 0xe0, 0xf8, 0xfe, 0xf8, 0xe0, 0x80, 0x00,
-    0x02, 0x0e, 0x3e, 0xfe, 0x3e, 0x0e, 0x02, 0x00,
-    0x18, 0x3c, 0x7e, 0x18, 0x18, 0x7e, 0x3c, 0x18,
-    0x66, 0x66, 0x66, 0x66, 0x66, 0x00, 0x66, 0x00,
-    0x7f, 0xdb, 0xdb, 0x7b, 0x1b, 0x1b, 0x1b, 0x00,
-    0x3e, 0x63, 0x38, 0x6c, 0x6c, 0x38, 0xcc, 0x78,
-    0x00, 0x00, 0x00, 0x00, 0x7e, 0x7e, 0x7e, 0x00,
-    0x18, 0x3c, 0x7e, 0x18, 0x7e, 0x3c, 0x18, 0xff,
-    0x18, 0x3c, 0x7e, 0x18, 0x18, 0x18, 0x18, 0x00,
-    0x18, 0x18, 0x18, 0x18, 0x7e, 0x3c, 0x18, 0x00,
-    0x00, 0x18, 0x0c, 0xfe, 0x0c, 0x18, 0x00, 0x00,
-    0x00, 0x30, 0x60, 0xfe, 0x60, 0x30, 0x00, 0x00,
-    0x00, 0x00, 0xc0, 0xc0, 0xc0, 0xfe, 0x00, 0x00,
-    0x00, 0x24, 0x66, 0xff, 0x66, 0x24, 0x00, 0x00,
-    0x00, 0x18, 0x3c, 0x7e, 0xff, 0xff, 0x00, 0x00,
-    0x00, 0xff, 0xff, 0x7e, 0x3c, 0x18, 0x00, 0x00,
-    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-    0x30, 0x78, 0x78, 0x30, 0x30, 0x00, 0x30, 0x00,
-    0x6c, 0x6c, 0x6c, 0x00, 0x00, 0x00, 0x00, 0x00,
-    0x6c, 0x6c, 0xfe, 0x6c, 0xfe, 0x6c, 0x6c, 0x00,
-    0x30, 0x7c, 0xc0, 0x78, 0x0c, 0xf8, 0x30, 0x00,
-    0x00, 0xc6, 0xcc, 0x18, 0x30, 0x66, 0xc6, 0x00,
-    0x38, 0x6c, 0x38, 0x76, 0xdc, 0xcc, 0x76, 0x00,
-    0x60, 0x60, 0xc0, 0x00, 0x00, 0x00, 0x00, 0x00,
-    0x18, 0x30, 0x60, 0x60, 0x60, 0x30, 0x18, 0x00,
-    0x60, 0x30, 0x18, 0x18, 0x18, 0x30, 0x60, 0x00,
-    0x00, 0x66, 0x3c, 0xff, 0x3c, 0x66, 0x00, 0x00,
-    0x00, 0x30, 0x30, 0xfc, 0x30, 0x30, 0x00, 0x00,
-    0x00, 0x00, 0x00, 0x00, 0x00, 0x30, 0x30, 0x60,
-    0x00, 0x00, 0x00, 0xfc, 0x00, 0x00, 0x00, 0x00,
-    0x00, 0x00, 0x00, 0x00, 0x00, 0x30, 0x30, 0x00,
-    0x06, 0x0c, 0x18, 0x30, 0x60, 0xc0, 0x80, 0x00,
-    0x7c, 0xc6, 0xce, 0xde, 0xf6, 0xe6, 0x7c, 0x00,
-    0x30, 0x70, 0x30, 0x30, 0x30, 0x30, 0xfc, 0x00,
-    0x78, 0xcc, 0x0c, 0x38, 0x60, 0xcc, 0xfc, 0x00,
-    0x78, 0xcc, 0x0c, 0x38, 0x0c, 0xcc, 0x78, 0x00,
-    0x1c, 0x3c, 0x6c, 0xcc, 0xfe, 0x0c, 0x1e, 0x00,
-    0xfc, 0xc0, 0xf8, 0x0c, 0x0c, 0xcc, 0x78, 0x00,
-    0x38, 0x60, 0xc0, 0xf8, 0xcc, 0xcc, 0x78, 0x00,
-    0xfc, 0xcc, 0x0c, 0x18, 0x30, 0x30, 0x30, 0x00,
-    0x78, 0xcc, 0xcc, 0x78, 0xcc, 0xcc, 0x78, 0x00,
-    0x78, 0xcc, 0xcc, 0x7c, 0x0c, 0x18, 0x70, 0x00,
-    0x00, 0x30, 0x30, 0x00, 0x00, 0x30, 0x30, 0x00,
-    0x00, 0x30, 0x30, 0x00, 0x00, 0x30, 0x30, 0x60,
-    0x18, 0x30, 0x60, 0xc0, 0x60, 0x30, 0x18, 0x00,
-    0x00, 0x00, 0xfc, 0x00, 0x00, 0xfc, 0x00, 0x00,
-    0x60, 0x30, 0x18, 0x0c, 0x18, 0x30, 0x60, 0x00,
-    0x78, 0xcc, 0x0c, 0x18, 0x30, 0x00, 0x30, 0x00,
-    0x7c, 0xc6, 0xde, 0xde, 0xde, 0xc0, 0x78, 0x00,
-    0x30, 0x78, 0xcc, 0xcc, 0xfc, 0xcc, 0xcc, 0x00,
-    0xfc, 0x66, 0x66, 0x7c, 0x66, 0x66, 0xfc, 0x00,
-    0x3c, 0x66, 0xc0, 0xc0, 0xc0, 0x66, 0x3c, 0x00,
-    0xf8, 0x6c, 0x66, 0x66, 0x66, 0x6c, 0xf8, 0x00,
-    0xfe, 0x62, 0x68, 0x78, 0x68, 0x62, 0xfe, 0x00,
-    0xfe, 0x62, 0x68, 0x78, 0x68, 0x60, 0xf0, 0x00,
-    0x3c, 0x66, 0xc0, 0xc0, 0xce, 0x66, 0x3e, 0x00,
-    0xcc, 0xcc, 0xcc, 0xfc, 0xcc, 0xcc, 0xcc, 0x00,
-    0x78, 0x30, 0x30, 0x30, 0x30, 0x30, 0x78, 0x00,
-    0x1e, 0x0c, 0x0c, 0x0c, 0xcc, 0xcc, 0x78, 0x00,
-    0xe6, 0x66, 0x6c, 0x78, 0x6c, 0x66, 0xe6, 0x00,
-    0xf0, 0x60, 0x60, 0x60, 0x62, 0x66, 0xfe, 0x00,
-    0xc6, 0xee, 0xfe, 0xfe, 0xd6, 0xc6, 0xc6, 0x00,
-    0xc6, 0xe6, 0xf6, 0xde, 0xce, 0xc6, 0xc6, 0x00,
-    0x38, 0x6c, 0xc6, 0xc6, 0xc6, 0x6c, 0x38, 0x00,
-    0xfc, 0x66, 0x66, 0x7c, 0x60, 0x60, 0xf0, 0x00,
-    0x78, 0xcc, 0xcc, 0xcc, 0xdc, 0x78, 0x1c, 0x00,
-    0xfc, 0x66, 0x66, 0x7c, 0x6c, 0x66, 0xe6, 0x00,
-    0x78, 0xcc, 0xe0, 0x70, 0x1c, 0xcc, 0x78, 0x00,
-    0xfc, 0xb4, 0x30, 0x30, 0x30, 0x30, 0x78, 0x00,
-    0xcc, 0xcc, 0xcc, 0xcc, 0xcc, 0xcc, 0xfc, 0x00,
-    0xcc, 0xcc, 0xcc, 0xcc, 0xcc, 0x78, 0x30, 0x00,
-    0xc6, 0xc6, 0xc6, 0xd6, 0xfe, 0xee, 0xc6, 0x00,
-    0xc6, 0xc6, 0x6c, 0x38, 0x38, 0x6c, 0xc6, 0x00,
-    0xcc, 0xcc, 0xcc, 0x78, 0x30, 0x30, 0x78, 0x00,
-    0xfe, 0xc6, 0x8c, 0x18, 0x32, 0x66, 0xfe, 0x00,
-    0x78, 0x60, 0x60, 0x60, 0x60, 0x60, 0x78, 0x00,
-    0xc0, 0x60, 0x30, 0x18, 0x0c, 0x06, 0x02, 0x00,
-    0x78, 0x18, 0x18, 0x18, 0x18, 0x18, 0x78, 0x00,
-    0x10, 0x38, 0x6c, 0xc6, 0x00, 0x00, 0x00, 0x00,
-    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff,
-    0x30, 0x30, 0x18, 0x00, 0x00, 0x00, 0x00, 0x00,
-    0x00, 0x00, 0x78, 0x0c, 0x7c, 0xcc, 0x76, 0x00,
-    0xe0, 0x60, 0x60, 0x7c, 0x66, 0x66, 0xdc, 0x00,
-    0x00, 0x00, 0x78, 0xcc, 0xc0, 0xcc, 0x78, 0x00,
-    0x1c, 0x0c, 0x0c, 0x7c, 0xcc, 0xcc, 0x76, 0x00,
-    0x00, 0x00, 0x78, 0xcc, 0xfc, 0xc0, 0x78, 0x00,
-    0x38, 0x6c, 0x60, 0xf0, 0x60, 0x60, 0xf0, 0x00,
-    0x00, 0x00, 0x76, 0xcc, 0xcc, 0x7c, 0x0c, 0xf8,
-    0xe0, 0x60, 0x6c, 0x76, 0x66, 0x66, 0xe6, 0x00,
-    0x30, 0x00, 0x70, 0x30, 0x30, 0x30, 0x78, 0x00,
-    0x0c, 0x00, 0x0c, 0x0c, 0x0c, 0xcc, 0xcc, 0x78,
-    0xe0, 0x60, 0x66, 0x6c, 0x78, 0x6c, 0xe6, 0x00,
-    0x70, 0x30, 0x30, 0x30, 0x30, 0x30, 0x78, 0x00,
-    0x00, 0x00, 0xcc, 0xfe, 0xfe, 0xd6, 0xc6, 0x00,
-    0x00, 0x00, 0xf8, 0xcc, 0xcc, 0xcc, 0xcc, 0x00,
-    0x00, 0x00, 0x78, 0xcc, 0xcc, 0xcc, 0x78, 0x00,
-    0x00, 0x00, 0xdc, 0x66, 0x66, 0x7c, 0x60, 0xf0,
-    0x00, 0x00, 0x76, 0xcc, 0xcc, 0x7c, 0x0c, 0x1e,
-    0x00, 0x00, 0xdc, 0x76, 0x66, 0x60, 0xf0, 0x00,
-    0x00, 0x00, 0x7c, 0xc0, 0x78, 0x0c, 0xf8, 0x00,
-    0x10, 0x30, 0x7c, 0x30, 0x30, 0x34, 0x18, 0x00,
-    0x00, 0x00, 0xcc, 0xcc, 0xcc, 0xcc, 0x76, 0x00,
-    0x00, 0x00, 0xcc, 0xcc, 0xcc, 0x78, 0x30, 0x00,
-    0x00, 0x00, 0xc6, 0xd6, 0xfe, 0xfe, 0x6c, 0x00,
-    0x00, 0x00, 0xc6, 0x6c, 0x38, 0x6c, 0xc6, 0x00,
-    0x00, 0x00, 0xcc, 0xcc, 0xcc, 0x7c, 0x0c, 0xf8,
-    0x00, 0x00, 0xfc, 0x98, 0x30, 0x64, 0xfc, 0x00,
-    0x1c, 0x30, 0x30, 0xe0, 0x30, 0x30, 0x1c, 0x00,
-    0x18, 0x18, 0x18, 0x00, 0x18, 0x18, 0x18, 0x00,
-    0xe0, 0x30, 0x30, 0x1c, 0x30, 0x30, 0xe0, 0x00,
-    0x76, 0xdc, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-    0x00, 0x10, 0x38, 0x6c, 0xc6, 0xc6, 0xfe, 0x00,
-};