提交: 951d53848130aa0807175aecde0048c7e8ab33a6 - kmbasic2 (git)

BASIC compiler/interpreter for PIC32MX/MZ-80K

Commit MetaInfo

• 修訂: 951d53848130aa0807175aecde0048c7e8ab33a6 (tree)
• 時間: 2019-04-10 06:15:53
• 作者: Katsumi <kmorimatsu@sour...>
• Commiter: Katsumi

Log Message

Start Protozoa Git repository

Change Summary

• modified: mips/classes/STRING/help.txt
• add: mips/protozoa/App_32MX170F256B.ld
• add: mips/protozoa/api.h
• add: mips/protozoa/args.c
• add: mips/protozoa/class.c
• add: mips/protozoa/cmpdata.c
• add: mips/protozoa/compiler.c
• add: mips/protozoa/compiler.h
• add: mips/protozoa/debug.c
• add: mips/protozoa/debug.h
• add: mips/protozoa/editor.c
• add: mips/protozoa/editor.h
• add: mips/protozoa/envspecific.c
• add: mips/protozoa/envspecific.h
• add: mips/protozoa/error.c
• add: mips/protozoa/exception.c
• add: mips/protozoa/file.c
• add: mips/protozoa/float.c
• add: mips/protozoa/function.c
• add: mips/protozoa/globalvars.c
• add: mips/protozoa/interface/LCDdriver.c
• add: mips/protozoa/interface/LCDdriver.h
• add: mips/protozoa/interface/SDFSIO.h
• add: mips/protozoa/interface/graphlib.c
• add: mips/protozoa/interface/keyinput.c
• add: mips/protozoa/interface/keyinput.h
• add: mips/protozoa/interface/libsdfsio.a
• add: mips/protozoa/interface/ps2keyboard.h
• add: mips/protozoa/interface/videoout.h
• add: mips/protozoa/library.c
• add: mips/protozoa/linker.c
• add: mips/protozoa/main.c
• add: mips/protozoa/main.h
• add: mips/protozoa/memory.c
• add: mips/protozoa/music.c
• add: mips/protozoa/operator.c
• add: mips/protozoa/protozoa.mcp
• add: mips/protozoa/run.c
• add: mips/protozoa/statement.c
• add: mips/protozoa/string.c
• add: mips/protozoa/timer.c
• add: mips/protozoa/value.c
• add: mips/protozoa/varname.c

差異

--- a/mips/classes/STRING/help.txt
+++ b/mips/classes/STRING/help.txt
@@ -12,7 +12,7 @@ BAS
 JavaのStringクラス様の文字列を扱うクラス。
 
 ＜コンストラクター＞
-第一引数は、文字列もしくはCSTRオブジェクト。
+第一引数は、文字列。
 
 ＜パブリックフィールド＞
 STR$

--- /dev/null
+++ b/mips/protozoa/App_32MX170F256B.ld
@@ -0,0 +1,794 @@
+/* linker script for application of PIC32MX170F256B SD card bootloader */
+
+/*--------------------------------------------------------------------------
+ * MPLAB XC Compiler -  PIC32MX170F256B linker script
+ * 
+ * This software is developed by Microchip Technology Inc. and its
+ * subsidiaries ("Microchip").
+ * 
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are 
+ * met:
+ * 
+ * 1.      Redistributions of source code must retain the above copyright
+ *         notice, this list of conditions and the following disclaimer.
+ * 2.      Redistributions in binary form must reproduce the above 
+ *         copyright notice, this list of conditions and the following 
+ *         disclaimer in the documentation and/or other materials provided 
+ *         with the distribution.
+ * 3.      Microchip's name may not be used to endorse or promote products
+ *         derived from this software without specific prior written 
+ *         permission.
+ * 
+ * THIS SOFTWARE IS PROVIDED BY MICROCHIP "AS IS" AND ANY EXPRESS OR IMPLIED
+ * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+ * MERCHANTABILITY AND FITNESS FOR PURPOSE ARE DISCLAIMED. IN NO EVENT 
+ * SHALL MICROCHIP BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING BUT NOT LIMITED TO
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA OR PROFITS;
+ * OR BUSINESS INTERRUPTION) HOWSOEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+ * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR 
+ * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
+ * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ * 
+ *-------------------------------------------------------------------------*/
+
+/* Default linker script, for normal executables */
+
+/*  IMPORTANT: PIC32MX MCUs use two files for the default linker script: 
+ *    1) pic32mx/lib/ldscripts/elf32pic32.x (main linker script)
+ *    2) pic32mx/lib/proc/32MX170F256B/procdefs.ld (variant-specific fragment)
+ *
+ *  This file is provided only as a convenience when adding a custom linker script
+ *  to your application.
+ */
+
+OUTPUT_FORMAT("elf32-tradlittlemips")
+OUTPUT_ARCH(pic32mx)
+ENTRY(_reset)
+/*
+ * Provide for a minimum stack and heap size
+ * - _min_stack_size - represents the minimum space that must be made
+ *                     available for the stack.  Can be overridden from
+ *                     the command line using the linker's --defsym option.
+ * - _min_heap_size  - represents the minimum space that must be made
+ *                     available for the heap.  Must be specified on
+ *                     the command line using the linker's --defsym option.
+ */
+EXTERN (_min_stack_size _min_heap_size)
+PROVIDE(_min_stack_size = 0x400) ;
+
+/*************************************************************************
+ * Processor-specific object file.  Contains SFR definitions.
+ *************************************************************************/
+INPUT("processor.o")
+
+/*************************************************************************
+ * Processor-specific peripheral libraries are optional
+ *************************************************************************/
+OPTIONAL("libmchp_peripheral.a")
+OPTIONAL("libmchp_peripheral_32MX150F128B.a")
+
+/*************************************************************************
+ * For interrupt vector handling
+ *************************************************************************/
+PROVIDE(_vector_spacing = 0x00000001);
+_ebase_address =  0x9D006000;
+
+/*************************************************************************
+ * Memory Address Equates
+ * _RESET_ADDR                    -- Reset Vector
+ * _BEV_EXCPT_ADDR                -- Boot exception Vector
+ * _DBG_EXCPT_ADDR                -- In-circuit Debugging Exception Vector
+ * _DBG_CODE_ADDR                 -- In-circuit Debug Executive address
+ * _DBG_CODE_SIZE                 -- In-circuit Debug Executive size
+ * _GEN_EXCPT_ADDR                -- General Exception Vector
+ *************************************************************************/
+_RESET_ADDR              =  (0x9D006000 + 0x1000);
+_BEV_EXCPT_ADDR          = ((0x9D006000 + 0x1000) + 0x380);
+_DBG_EXCPT_ADDR          = ((0x9D006000 + 0x1000) + 0x480);
+_DBG_CODE_ADDR           = 0x9FC00490;
+_DBG_CODE_SIZE           = 0x760     ;
+_GEN_EXCPT_ADDR          = _ebase_address + 0x180;
+
+/*************************************************************************
+ * Memory Regions
+ *
+ * Memory regions without attributes cannot be used for orphaned sections.
+ * Only sections specifically assigned to these regions can be allocated
+ * into these regions.
+ *
+ * The Debug exception vector is located at 0x9FC00480.
+ * The config_<address> sections are used to locate the config words at
+ * their absolute addresses.
+ *************************************************************************/
+MEMORY
+{
+  kseg0_program_mem    (rx)  : ORIGIN = (0x9D006000 + 0x1000 + 0x490), LENGTH = 0x40000 - (0x6000 + 0x1000 + 0x490) /* All C Files will be located here */
+  exception_mem              : ORIGIN = 0x9D006000, LENGTH = 0x1000 /* Interrupt vector table */
+  debug_exec_mem             : ORIGIN = 0x9FC00490, LENGTH = 0x760
+  kseg0_boot_mem             : ORIGIN = 0x9D006000, LENGTH = 0x0 /* This memory region is dummy */
+  kseg1_boot_mem             : ORIGIN = (0x9D006000 + 0x1000), LENGTH = 0x490 /* C Startup code */
+  config3                    : ORIGIN = 0xBFC00BF0, LENGTH = 0x4
+  config2                    : ORIGIN = 0xBFC00BF4, LENGTH = 0x4
+  config1                    : ORIGIN = 0xBFC00BF8, LENGTH = 0x4
+  config0                    : ORIGIN = 0xBFC00BFC, LENGTH = 0x4
+  kseg1_data_mem       (w!x) : ORIGIN = 0xA0000000, LENGTH = 0x10000
+  sfrs                       : ORIGIN = 0xBF800000, LENGTH = 0x100000
+  configsfrs                 : ORIGIN = 0xBFC00BF0, LENGTH = 0x10
+}
+
+/*************************************************************************
+ * Configuration-word sections. Map the config-pragma input sections to
+ * absolute-address output sections.
+ *************************************************************************/
+SECTIONS
+{
+  .config_BFC00BF0 : {
+    KEEP(*(.config_BFC00BF0))
+  } > config3
+  .config_BFC00BF4 : {
+    KEEP(*(.config_BFC00BF4))
+  } > config2
+  .config_BFC00BF8 : {
+    KEEP(*(.config_BFC00BF8))
+  } > config1
+  .config_BFC00BFC : {
+    KEEP(*(.config_BFC00BFC))
+  } > config0
+}
+SECTIONS
+{
+  /* Boot Sections */
+  .reset _RESET_ADDR :
+  {
+    KEEP(*(.reset))
+    KEEP(*(.reset.startup))
+  } > kseg1_boot_mem
+  .bev_excpt _BEV_EXCPT_ADDR :
+  {
+    KEEP(*(.bev_handler))
+  } > kseg1_boot_mem
+  /* Debug exception vector */
+  .dbg_excpt _DBG_EXCPT_ADDR (NOLOAD) :
+  {
+    . += (DEFINED (_DEBUGGER) ? 0x8 : 0x0);
+  } > kseg1_boot_mem
+  /* Space reserved for the debug executive */
+  .dbg_code _DBG_CODE_ADDR (NOLOAD) :
+  {
+    . += (DEFINED (_DEBUGGER) ? _DBG_CODE_SIZE : 0x0);
+  } > debug_exec_mem
+
+  .app_excpt _GEN_EXCPT_ADDR :
+  {
+    KEEP(*(.gen_handler))
+  } > exception_mem
+
+  .vector_0 _ebase_address + 0x200 + ((_vector_spacing << 5) * 0) :
+  {
+     KEEP(*(.vector_0))
+  } > exception_mem
+  ASSERT (_vector_spacing == 0 || SIZEOF(.vector_0) <= (_vector_spacing << 5), "function at exception vector 0 too large")
+  .vector_1 _ebase_address + 0x200 + ((_vector_spacing << 5) * 1) :
+  {
+     KEEP(*(.vector_1))
+  } > exception_mem
+  ASSERT (_vector_spacing == 0 || SIZEOF(.vector_1) <= (_vector_spacing << 5), "function at exception vector 1 too large")
+  .vector_2 _ebase_address + 0x200 + ((_vector_spacing << 5) * 2) :
+  {
+     KEEP(*(.vector_2))
+  } > exception_mem
+  ASSERT (_vector_spacing == 0 || SIZEOF(.vector_2) <= (_vector_spacing << 5), "function at exception vector 2 too large")
+  .vector_3 _ebase_address + 0x200 + ((_vector_spacing << 5) * 3) :
+  {
+     KEEP(*(.vector_3))
+  } > exception_mem
+  ASSERT (_vector_spacing == 0 || SIZEOF(.vector_3) <= (_vector_spacing << 5), "function at exception vector 3 too large")
+  .vector_4 _ebase_address + 0x200 + ((_vector_spacing << 5) * 4) :
+  {
+     KEEP(*(.vector_4))
+  } > exception_mem
+  ASSERT (_vector_spacing == 0 || SIZEOF(.vector_4) <= (_vector_spacing << 5), "function at exception vector 4 too large")
+  .vector_5 _ebase_address + 0x200 + ((_vector_spacing << 5) * 5) :
+  {
+     KEEP(*(.vector_5))
+  } > exception_mem
+  ASSERT (_vector_spacing == 0 || SIZEOF(.vector_5) <= (_vector_spacing << 5), "function at exception vector 5 too large")
+  .vector_6 _ebase_address + 0x200 + ((_vector_spacing << 5) * 6) :
+  {
+     KEEP(*(.vector_6))
+  } > exception_mem
+  ASSERT (_vector_spacing == 0 || SIZEOF(.vector_6) <= (_vector_spacing << 5), "function at exception vector 6 too large")
+  .vector_7 _ebase_address + 0x200 + ((_vector_spacing << 5) * 7) :
+  {
+     KEEP(*(.vector_7))
+  } > exception_mem
+  ASSERT (_vector_spacing == 0 || SIZEOF(.vector_7) <= (_vector_spacing << 5), "function at exception vector 7 too large")
+  .vector_8 _ebase_address + 0x200 + ((_vector_spacing << 5) * 8) :
+  {
+     KEEP(*(.vector_8))
+  } > exception_mem
+  ASSERT (_vector_spacing == 0 || SIZEOF(.vector_8) <= (_vector_spacing << 5), "function at exception vector 8 too large")
+  .vector_9 _ebase_address + 0x200 + ((_vector_spacing << 5) * 9) :
+  {
+     KEEP(*(.vector_9))
+  } > exception_mem
+  ASSERT (_vector_spacing == 0 || SIZEOF(.vector_9) <= (_vector_spacing << 5), "function at exception vector 9 too large")
+  .vector_10 _ebase_address + 0x200 + ((_vector_spacing << 5) * 10) :
+  {
+     KEEP(*(.vector_10))
+  } > exception_mem
+  ASSERT (_vector_spacing == 0 || SIZEOF(.vector_10) <= (_vector_spacing << 5), "function at exception vector 10 too large")
+  .vector_11 _ebase_address + 0x200 + ((_vector_spacing << 5) * 11) :
+  {
+     KEEP(*(.vector_11))
+  } > exception_mem
+  ASSERT (_vector_spacing == 0 || SIZEOF(.vector_11) <= (_vector_spacing << 5), "function at exception vector 11 too large")
+  .vector_12 _ebase_address + 0x200 + ((_vector_spacing << 5) * 12) :
+  {
+     KEEP(*(.vector_12))
+  } > exception_mem
+  ASSERT (_vector_spacing == 0 || SIZEOF(.vector_12) <= (_vector_spacing << 5), "function at exception vector 12 too large")
+  .vector_13 _ebase_address + 0x200 + ((_vector_spacing << 5) * 13) :
+  {
+     KEEP(*(.vector_13))
+  } > exception_mem
+  ASSERT (_vector_spacing == 0 || SIZEOF(.vector_13) <= (_vector_spacing << 5), "function at exception vector 13 too large")
+  .vector_14 _ebase_address + 0x200 + ((_vector_spacing << 5) * 14) :
+  {
+     KEEP(*(.vector_14))
+  } > exception_mem
+  ASSERT (_vector_spacing == 0 || SIZEOF(.vector_14) <= (_vector_spacing << 5), "function at exception vector 14 too large")
+  .vector_15 _ebase_address + 0x200 + ((_vector_spacing << 5) * 15) :
+  {
+     KEEP(*(.vector_15))
+  } > exception_mem
+  ASSERT (_vector_spacing == 0 || SIZEOF(.vector_15) <= (_vector_spacing << 5), "function at exception vector 15 too large")
+  .vector_16 _ebase_address + 0x200 + ((_vector_spacing << 5) * 16) :
+  {
+     KEEP(*(.vector_16))
+  } > exception_mem
+  ASSERT (_vector_spacing == 0 || SIZEOF(.vector_16) <= (_vector_spacing << 5), "function at exception vector 16 too large")
+  .vector_17 _ebase_address + 0x200 + ((_vector_spacing << 5) * 17) :
+  {
+     KEEP(*(.vector_17))
+  } > exception_mem
+  ASSERT (_vector_spacing == 0 || SIZEOF(.vector_17) <= (_vector_spacing << 5), "function at exception vector 17 too large")
+  .vector_18 _ebase_address + 0x200 + ((_vector_spacing << 5) * 18) :
+  {
+     KEEP(*(.vector_18))
+  } > exception_mem
+  ASSERT (_vector_spacing == 0 || SIZEOF(.vector_18) <= (_vector_spacing << 5), "function at exception vector 18 too large")
+  .vector_19 _ebase_address + 0x200 + ((_vector_spacing << 5) * 19) :
+  {
+     KEEP(*(.vector_19))
+  } > exception_mem
+  ASSERT (_vector_spacing == 0 || SIZEOF(.vector_19) <= (_vector_spacing << 5), "function at exception vector 19 too large")
+  .vector_20 _ebase_address + 0x200 + ((_vector_spacing << 5) * 20) :
+  {
+     KEEP(*(.vector_20))
+  } > exception_mem
+  ASSERT (_vector_spacing == 0 || SIZEOF(.vector_20) <= (_vector_spacing << 5), "function at exception vector 20 too large")
+  .vector_21 _ebase_address + 0x200 + ((_vector_spacing << 5) * 21) :
+  {
+     KEEP(*(.vector_21))
+  } > exception_mem
+  ASSERT (_vector_spacing == 0 || SIZEOF(.vector_21) <= (_vector_spacing << 5), "function at exception vector 21 too large")
+  .vector_22 _ebase_address + 0x200 + ((_vector_spacing << 5) * 22) :
+  {
+     KEEP(*(.vector_22))
+  } > exception_mem
+  ASSERT (_vector_spacing == 0 || SIZEOF(.vector_22) <= (_vector_spacing << 5), "function at exception vector 22 too large")
+  .vector_23 _ebase_address + 0x200 + ((_vector_spacing << 5) * 23) :
+  {
+     KEEP(*(.vector_23))
+  } > exception_mem
+  ASSERT (_vector_spacing == 0 || SIZEOF(.vector_23) <= (_vector_spacing << 5), "function at exception vector 23 too large")
+  .vector_24 _ebase_address + 0x200 + ((_vector_spacing << 5) * 24) :
+  {
+     KEEP(*(.vector_24))
+  } > exception_mem
+  ASSERT (_vector_spacing == 0 || SIZEOF(.vector_24) <= (_vector_spacing << 5), "function at exception vector 24 too large")
+  .vector_25 _ebase_address + 0x200 + ((_vector_spacing << 5) * 25) :
+  {
+     KEEP(*(.vector_25))
+  } > exception_mem
+  ASSERT (_vector_spacing == 0 || SIZEOF(.vector_25) <= (_vector_spacing << 5), "function at exception vector 25 too large")
+  .vector_26 _ebase_address + 0x200 + ((_vector_spacing << 5) * 26) :
+  {
+     KEEP(*(.vector_26))
+  } > exception_mem
+  ASSERT (_vector_spacing == 0 || SIZEOF(.vector_26) <= (_vector_spacing << 5), "function at exception vector 26 too large")
+  .vector_27 _ebase_address + 0x200 + ((_vector_spacing << 5) * 27) :
+  {
+     KEEP(*(.vector_27))
+  } > exception_mem
+  ASSERT (_vector_spacing == 0 || SIZEOF(.vector_27) <= (_vector_spacing << 5), "function at exception vector 27 too large")
+  .vector_28 _ebase_address + 0x200 + ((_vector_spacing << 5) * 28) :
+  {
+     KEEP(*(.vector_28))
+  } > exception_mem
+  ASSERT (_vector_spacing == 0 || SIZEOF(.vector_28) <= (_vector_spacing << 5), "function at exception vector 28 too large")
+  .vector_29 _ebase_address + 0x200 + ((_vector_spacing << 5) * 29) :
+  {
+     KEEP(*(.vector_29))
+  } > exception_mem
+  ASSERT (_vector_spacing == 0 || SIZEOF(.vector_29) <= (_vector_spacing << 5), "function at exception vector 29 too large")
+  .vector_30 _ebase_address + 0x200 + ((_vector_spacing << 5) * 30) :
+  {
+     KEEP(*(.vector_30))
+  } > exception_mem
+  ASSERT (_vector_spacing == 0 || SIZEOF(.vector_30) <= (_vector_spacing << 5), "function at exception vector 30 too large")
+  .vector_31 _ebase_address + 0x200 + ((_vector_spacing << 5) * 31) :
+  {
+     KEEP(*(.vector_31))
+  } > exception_mem
+  ASSERT (_vector_spacing == 0 || SIZEOF(.vector_31) <= (_vector_spacing << 5), "function at exception vector 31 too large")
+  .vector_32 _ebase_address + 0x200 + ((_vector_spacing << 5) * 32) :
+  {
+     KEEP(*(.vector_32))
+  } > exception_mem
+  ASSERT (_vector_spacing == 0 || SIZEOF(.vector_32) <= (_vector_spacing << 5), "function at exception vector 32 too large")
+  .vector_33 _ebase_address + 0x200 + ((_vector_spacing << 5) * 33) :
+  {
+     KEEP(*(.vector_33))
+  } > exception_mem
+  ASSERT (_vector_spacing == 0 || SIZEOF(.vector_33) <= (_vector_spacing << 5), "function at exception vector 33 too large")
+  .vector_34 _ebase_address + 0x200 + ((_vector_spacing << 5) * 34) :
+  {
+     KEEP(*(.vector_34))
+  } > exception_mem
+  ASSERT (_vector_spacing == 0 || SIZEOF(.vector_34) <= (_vector_spacing << 5), "function at exception vector 34 too large")
+  .vector_35 _ebase_address + 0x200 + ((_vector_spacing << 5) * 35) :
+  {
+     KEEP(*(.vector_35))
+  } > exception_mem
+  ASSERT (_vector_spacing == 0 || SIZEOF(.vector_35) <= (_vector_spacing << 5), "function at exception vector 35 too large")
+  .vector_36 _ebase_address + 0x200 + ((_vector_spacing << 5) * 36) :
+  {
+     KEEP(*(.vector_36))
+  } > exception_mem
+  ASSERT (_vector_spacing == 0 || SIZEOF(.vector_36) <= (_vector_spacing << 5), "function at exception vector 36 too large")
+  .vector_37 _ebase_address + 0x200 + ((_vector_spacing << 5) * 37) :
+  {
+     KEEP(*(.vector_37))
+  } > exception_mem
+  ASSERT (_vector_spacing == 0 || SIZEOF(.vector_37) <= (_vector_spacing << 5), "function at exception vector 37 too large")
+  .vector_38 _ebase_address + 0x200 + ((_vector_spacing << 5) * 38) :
+  {
+     KEEP(*(.vector_38))
+  } > exception_mem
+  ASSERT (_vector_spacing == 0 || SIZEOF(.vector_38) <= (_vector_spacing << 5), "function at exception vector 38 too large")
+  .vector_39 _ebase_address + 0x200 + ((_vector_spacing << 5) * 39) :
+  {
+     KEEP(*(.vector_39))
+  } > exception_mem
+  ASSERT (_vector_spacing == 0 || SIZEOF(.vector_39) <= (_vector_spacing << 5), "function at exception vector 39 too large")
+  .vector_40 _ebase_address + 0x200 + ((_vector_spacing << 5) * 40) :
+  {
+     KEEP(*(.vector_40))
+  } > exception_mem
+  ASSERT (_vector_spacing == 0 || SIZEOF(.vector_40) <= (_vector_spacing << 5), "function at exception vector 40 too large")
+  .vector_41 _ebase_address + 0x200 + ((_vector_spacing << 5) * 41) :
+  {
+     KEEP(*(.vector_41))
+  } > exception_mem
+  ASSERT (_vector_spacing == 0 || SIZEOF(.vector_41) <= (_vector_spacing << 5), "function at exception vector 41 too large")
+  .vector_42 _ebase_address + 0x200 + ((_vector_spacing << 5) * 42) :
+  {
+     KEEP(*(.vector_42))
+  } > exception_mem
+  ASSERT (_vector_spacing == 0 || SIZEOF(.vector_42) <= (_vector_spacing << 5), "function at exception vector 42 too large")
+  .vector_43 _ebase_address + 0x200 + ((_vector_spacing << 5) * 43) :
+  {
+     KEEP(*(.vector_43))
+  } > exception_mem
+  ASSERT (_vector_spacing == 0 || SIZEOF(.vector_43) <= (_vector_spacing << 5), "function at exception vector 43 too large")
+  .vector_44 _ebase_address + 0x200 + ((_vector_spacing << 5) * 44) :
+  {
+     KEEP(*(.vector_44))
+  } > exception_mem
+  ASSERT (_vector_spacing == 0 || SIZEOF(.vector_44) <= (_vector_spacing << 5), "function at exception vector 44 too large")
+  .vector_45 _ebase_address + 0x200 + ((_vector_spacing << 5) * 45) :
+  {
+     KEEP(*(.vector_45))
+  } > exception_mem
+  ASSERT (_vector_spacing == 0 || SIZEOF(.vector_45) <= (_vector_spacing << 5), "function at exception vector 45 too large")
+  .vector_46 _ebase_address + 0x200 + ((_vector_spacing << 5) * 46) :
+  {
+     KEEP(*(.vector_46))
+  } > exception_mem
+  ASSERT (_vector_spacing == 0 || SIZEOF(.vector_46) <= (_vector_spacing << 5), "function at exception vector 46 too large")
+  .vector_47 _ebase_address + 0x200 + ((_vector_spacing << 5) * 47) :
+  {
+     KEEP(*(.vector_47))
+  } > exception_mem
+  ASSERT (_vector_spacing == 0 || SIZEOF(.vector_47) <= (_vector_spacing << 5), "function at exception vector 47 too large")
+  .vector_48 _ebase_address + 0x200 + ((_vector_spacing << 5) * 48) :
+  {
+     KEEP(*(.vector_48))
+  } > exception_mem
+  ASSERT (_vector_spacing == 0 || SIZEOF(.vector_48) <= (_vector_spacing << 5), "function at exception vector 48 too large")
+  .vector_49 _ebase_address + 0x200 + ((_vector_spacing << 5) * 49) :
+  {
+     KEEP(*(.vector_49))
+  } > exception_mem
+  ASSERT (_vector_spacing == 0 || SIZEOF(.vector_49) <= (_vector_spacing << 5), "function at exception vector 49 too large")
+  .vector_50 _ebase_address + 0x200 + ((_vector_spacing << 5) * 50) :
+  {
+     KEEP(*(.vector_50))
+  } > exception_mem
+  ASSERT (_vector_spacing == 0 || SIZEOF(.vector_50) <= (_vector_spacing << 5), "function at exception vector 50 too large")
+  .vector_51 _ebase_address + 0x200 + ((_vector_spacing << 5) * 51) :
+  {
+     KEEP(*(.vector_51))
+  } > exception_mem
+  ASSERT (_vector_spacing == 0 || SIZEOF(.vector_51) <= (_vector_spacing << 5), "function at exception vector 51 too large")
+  .vector_52 _ebase_address + 0x200 + ((_vector_spacing << 5) * 52) :
+  {
+     KEEP(*(.vector_52))
+  } > exception_mem
+  ASSERT (_vector_spacing == 0 || SIZEOF(.vector_52) <= (_vector_spacing << 5), "function at exception vector 52 too large")
+  .vector_53 _ebase_address + 0x200 + ((_vector_spacing << 5) * 53) :
+  {
+     KEEP(*(.vector_53))
+  } > exception_mem
+  ASSERT (_vector_spacing == 0 || SIZEOF(.vector_53) <= (_vector_spacing << 5), "function at exception vector 53 too large")
+  .vector_54 _ebase_address + 0x200 + ((_vector_spacing << 5) * 54) :
+  {
+     KEEP(*(.vector_54))
+  } > exception_mem
+  ASSERT (_vector_spacing == 0 || SIZEOF(.vector_54) <= (_vector_spacing << 5), "function at exception vector 54 too large")
+  .vector_55 _ebase_address + 0x200 + ((_vector_spacing << 5) * 55) :
+  {
+     KEEP(*(.vector_55))
+  } > exception_mem
+  ASSERT (_vector_spacing == 0 || SIZEOF(.vector_55) <= (_vector_spacing << 5), "function at exception vector 55 too large")
+  .vector_56 _ebase_address + 0x200 + ((_vector_spacing << 5) * 56) :
+  {
+     KEEP(*(.vector_56))
+  } > exception_mem
+  ASSERT (_vector_spacing == 0 || SIZEOF(.vector_56) <= (_vector_spacing << 5), "function at exception vector 56 too large")
+  .vector_57 _ebase_address + 0x200 + ((_vector_spacing << 5) * 57) :
+  {
+     KEEP(*(.vector_57))
+  } > exception_mem
+  ASSERT (_vector_spacing == 0 || SIZEOF(.vector_57) <= (_vector_spacing << 5), "function at exception vector 57 too large")
+  .vector_58 _ebase_address + 0x200 + ((_vector_spacing << 5) * 58) :
+  {
+     KEEP(*(.vector_58))
+  } > exception_mem
+  ASSERT (_vector_spacing == 0 || SIZEOF(.vector_58) <= (_vector_spacing << 5), "function at exception vector 58 too large")
+  .vector_59 _ebase_address + 0x200 + ((_vector_spacing << 5) * 59) :
+  {
+     KEEP(*(.vector_59))
+  } > exception_mem
+  ASSERT (_vector_spacing == 0 || SIZEOF(.vector_59) <= (_vector_spacing << 5), "function at exception vector 59 too large")
+  .vector_60 _ebase_address + 0x200 + ((_vector_spacing << 5) * 60) :
+  {
+     KEEP(*(.vector_60))
+  } > exception_mem
+  ASSERT (_vector_spacing == 0 || SIZEOF(.vector_60) <= (_vector_spacing << 5), "function at exception vector 60 too large")
+  .vector_61 _ebase_address + 0x200 + ((_vector_spacing << 5) * 61) :
+  {
+     KEEP(*(.vector_61))
+  } > exception_mem
+  ASSERT (_vector_spacing == 0 || SIZEOF(.vector_61) <= (_vector_spacing << 5), "function at exception vector 61 too large")
+  .vector_62 _ebase_address + 0x200 + ((_vector_spacing << 5) * 62) :
+  {
+     KEEP(*(.vector_62))
+  } > exception_mem
+  ASSERT (_vector_spacing == 0 || SIZEOF(.vector_62) <= (_vector_spacing << 5), "function at exception vector 62 too large")
+  .vector_63 _ebase_address + 0x200 + ((_vector_spacing << 5) * 63) :
+  {
+     KEEP(*(.vector_63))
+  } > exception_mem
+  ASSERT (_vector_spacing == 0 || SIZEOF(.vector_63) <= (_vector_spacing << 5), "function at exception vector 63 too large")
+
+  /*  The startup code is in the .reset.startup section.
+   *  Keep this here for backwards compatibility with older
+   *  C32 v1.xx releases.
+   */
+  .startup ORIGIN(kseg0_boot_mem) :
+  {
+    KEEP(*(.startup))
+  } > kseg0_boot_mem
+  /* Code Sections - Note that input sections *(.text) and *(.text.*)
+  ** are not mapped here. The best-fit allocator locates them,
+  ** so that .text may flow around absolute sections as needed.
+  */
+  .text :
+  {
+    *(.stub .gnu.linkonce.t.*)
+    KEEP (*(.text.*personality*))
+    *(.mips16.fn.*)
+    *(.mips16.call.*)
+    *(.gnu.warning)
+    . = ALIGN(4) ;
+  } >kseg0_program_mem
+  /* Global-namespace object initialization */
+  .init   :
+  {
+    KEEP (*crti.o(.init))
+    KEEP (*crtbegin.o(.init))
+    KEEP (*(EXCLUDE_FILE (*crtend.o *crtend?.o *crtn.o ).init))
+    KEEP (*crtend.o(.init))
+    KEEP (*crtn.o(.init))
+    . = ALIGN(4) ;
+  } >kseg0_program_mem
+  .fini   :
+  {
+    KEEP (*(.fini))
+    . = ALIGN(4) ;
+  } >kseg0_program_mem
+  .preinit_array   :
+  {
+    PROVIDE_HIDDEN (__preinit_array_start = .);
+    KEEP (*(.preinit_array))
+    PROVIDE_HIDDEN (__preinit_array_end = .);
+    . = ALIGN(4) ;
+  } >kseg0_program_mem
+  .init_array   :
+  {
+    PROVIDE_HIDDEN (__init_array_start = .);
+    KEEP (*(SORT(.init_array.*)))
+    KEEP (*(.init_array))
+    PROVIDE_HIDDEN (__init_array_end = .);
+    . = ALIGN(4) ;
+  } >kseg0_program_mem
+  .fini_array   :
+  {
+    PROVIDE_HIDDEN (__fini_array_start = .);
+    KEEP (*(SORT(.fini_array.*)))
+    KEEP (*(.fini_array))
+    PROVIDE_HIDDEN (__fini_array_end = .);
+    . = ALIGN(4) ;
+  } >kseg0_program_mem
+  .ctors   :
+  {
+    /* XC32 uses crtbegin.o to find the start of
+       the constructors, so we make sure it is
+       first.  Because this is a wildcard, it
+       doesn't matter if the user does not
+       actually link against crtbegin.o; the
+       linker won't look for a file to match a
+       wildcard.  The wildcard also means that it
+       doesn't matter which directory crtbegin.o
+       is in.  */
+    KEEP (*crtbegin.o(.ctors))
+    KEEP (*crtbegin?.o(.ctors))
+    /* We don't want to include the .ctor section from
+       the crtend.o file until after the sorted ctors.
+       The .ctor section from the crtend file contains the
+       end of ctors marker and it must be last */
+    KEEP (*(EXCLUDE_FILE (*crtend.o *crtend?.o ) .ctors))
+    KEEP (*(SORT(.ctors.*)))
+    KEEP (*(.ctors))
+    . = ALIGN(4) ;
+  } >kseg0_program_mem
+  .dtors   :
+  {
+    KEEP (*crtbegin.o(.dtors))
+    KEEP (*crtbegin?.o(.dtors))
+    KEEP (*(EXCLUDE_FILE (*crtend.o *crtend?.o ) .dtors))
+    KEEP (*(SORT(.dtors.*)))
+    KEEP (*(.dtors))
+    . = ALIGN(4) ;
+  } >kseg0_program_mem
+  /* Read-only sections */
+  .rodata   :
+  {
+    *( .gnu.linkonce.r.*)
+    *(.rodata1)
+    . = ALIGN(4) ;
+  } >kseg0_program_mem
+  /*
+   * Small initialized constant global and static data can be placed in the
+   * .sdata2 section.  This is different from .sdata, which contains small
+   * initialized non-constant global and static data.
+   */
+  .sdata2 ALIGN(4) :
+  {
+    *(.sdata2 .sdata2.* .gnu.linkonce.s2.*)
+    . = ALIGN(4) ;
+  } >kseg0_program_mem
+  /*
+   * Uninitialized constant global and static data (i.e., variables which will
+   * always be zero).  Again, this is different from .sbss, which contains
+   * small non-initialized, non-constant global and static data.
+   */
+  .sbss2 ALIGN(4) :
+  {
+    *(.sbss2 .sbss2.* .gnu.linkonce.sb2.*)
+    . = ALIGN(4) ;
+  } >kseg0_program_mem
+  .eh_frame_hdr   :
+  {
+    *(.eh_frame_hdr)
+  } >kseg0_program_mem
+    . = ALIGN(4) ;
+  .eh_frame   : ONLY_IF_RO
+  {
+    KEEP (*(.eh_frame))
+  } >kseg0_program_mem
+    . = ALIGN(4) ;
+  .gcc_except_table   : ONLY_IF_RO
+  {
+    *(.gcc_except_table .gcc_except_table.*)
+  } >kseg0_program_mem
+    . = ALIGN(4) ;
+  .dbg_data (NOLOAD) :
+  {
+    . += (DEFINED (_DEBUGGER) ? 0x200 : 0x0);
+  } >kseg1_data_mem
+  .jcr   :
+  {
+    KEEP (*(.jcr))
+    . = ALIGN(4) ;
+  } >kseg1_data_mem
+  .eh_frame    : ONLY_IF_RW
+  {
+    KEEP (*(.eh_frame))
+  } >kseg1_data_mem
+    . = ALIGN(4) ;
+  .gcc_except_table    : ONLY_IF_RW
+  {
+    *(.gcc_except_table .gcc_except_table.*)
+  } >kseg1_data_mem
+    . = ALIGN(4) ;
+  /* Persistent data - Use the new C 'persistent' attribute instead. */
+  .persist   :
+  {
+    _persist_begin = .;
+    *(.persist .persist.*)
+    *(.pbss .pbss.*)
+    . = ALIGN(4) ;
+    _persist_end = .;
+  } >kseg1_data_mem
+  /*
+   *  Note that input sections named .data* are not mapped here.
+   *  The best-fit allocator locates them, so that they may flow
+   *  around absolute sections as needed.
+   */
+  .data   :
+  {
+    *( .gnu.linkonce.d.*)
+    SORT(CONSTRUCTORS)
+    *(.data1)
+    . = ALIGN(4) ;
+  } >kseg1_data_mem
+  . = .;
+  _gp = ALIGN(16) + 0x7ff0;
+  .got ALIGN(4) :
+  {
+    *(.got.plt) *(.got)
+    . = ALIGN(4) ;
+  } >kseg1_data_mem /* AT>kseg0_program_mem */
+  /*
+   * Note that 'small' data sections are still mapped in the linker
+   * script. This ensures that they are grouped together for
+   * gp-relative addressing. Absolute sections are allocated after
+   * the 'small' data sections so small data cannot flow around them.
+   */
+  /*
+   * We want the small data sections together, so single-instruction offsets
+   * can access them all, and initialized data all before uninitialized, so
+   * we can shorten the on-disk segment size.
+   */
+  .sdata ALIGN(4) :
+  {
+    _sdata_begin = . ;
+    *(.sdata .sdata.* .gnu.linkonce.s.*)
+    . = ALIGN(4) ;
+    _sdata_end = . ;
+  } >kseg1_data_mem
+  .lit8           :
+  {
+    *(.lit8)
+  } >kseg1_data_mem
+  .lit4           :
+  {
+    *(.lit4)
+  } >kseg1_data_mem
+  . = ALIGN (4) ;
+  _data_end = . ;
+  _bss_begin = . ;
+  .sbss ALIGN(4) :
+  {
+    _sbss_begin = . ;
+    *(.dynsbss)
+    *(.sbss .sbss.* .gnu.linkonce.sb.*)
+    *(.scommon)
+    _sbss_end = . ;
+    . = ALIGN(4) ;
+  } >kseg1_data_mem
+  /*
+   *  Align here to ensure that the .bss section occupies space up to
+   *  _end.  Align after .bss to ensure correct alignment even if the
+   *  .bss section disappears because there are no input sections.
+   *
+   *  Note that input sections named .bss* are no longer mapped here.
+   *  The best-fit allocator locates them, so that they may flow
+   *  around absolute sections as needed.
+   *
+   */
+  .bss     :
+  {
+    *(.dynbss)
+    *(COMMON)
+   /* Align here to ensure that the .bss section occupies space up to
+      _end.  Align after .bss to ensure correct alignment even if the
+      .bss section disappears because there are no input sections. */
+   . = ALIGN(. != 0 ? 4 : 1);
+  } >kseg1_data_mem
+  . = ALIGN(4) ;
+  _end = . ;
+  _bss_end = . ;
+  /*
+   *  The heap and stack are best-fit allocated by the linker after other
+   *  data and bss sections have been allocated.
+   */
+  /*
+   * RAM functions go at the end of our stack and heap allocation.
+   * Alignment of 2K required by the boundary register (BMXDKPBA).
+   *
+   * RAM functions are now allocated by the linker. The linker generates
+   * _ramfunc_begin and _bmxdkpba_address symbols depending on the
+   * location of RAM functions.
+   */
+  _bmxdudba_address = LENGTH(kseg1_data_mem) ;
+  _bmxdupba_address = LENGTH(kseg1_data_mem) ;
+    /* The .pdr section belongs in the absolute section */
+    /DISCARD/ : { *(.pdr) }
+  .gptab.sdata : { *(.gptab.data) *(.gptab.sdata) }
+  .gptab.sbss : { *(.gptab.bss) *(.gptab.sbss) }
+  .mdebug.abi32 : { KEEP(*(.mdebug.abi32)) }
+  .mdebug.abiN32 : { KEEP(*(.mdebug.abiN32)) }
+  .mdebug.abi64 : { KEEP(*(.mdebug.abi64)) }
+  .mdebug.abiO64 : { KEEP(*(.mdebug.abiO64)) }
+  .mdebug.eabi32 : { KEEP(*(.mdebug.eabi32)) }
+  .mdebug.eabi64 : { KEEP(*(.mdebug.eabi64)) }
+  .gcc_compiled_long32 : { KEEP(*(.gcc_compiled_long32)) }
+  .gcc_compiled_long64 : { KEEP(*(.gcc_compiled_long64)) }
+  /* Stabs debugging sections.  */
+  .stab          0 : { *(.stab) }
+  .stabstr       0 : { *(.stabstr) }
+  .stab.excl     0 : { *(.stab.excl) }
+  .stab.exclstr  0 : { *(.stab.exclstr) }
+  .stab.index    0 : { *(.stab.index) }
+  .stab.indexstr 0 : { *(.stab.indexstr) }
+  .comment       0 : { *(.comment) }
+  /* DWARF debug sections used by MPLAB X for source-level debugging. 
+     Symbols in the DWARF debugging sections are relative to the beginning
+     of the section so we begin them at 0.  */
+  /* DWARF 1 */
+  .debug          0 : { *(.debug) }
+  .line           0 : { *(.line) }
+  /* GNU DWARF 1 extensions */
+  .debug_srcinfo  0 : { *(.debug_srcinfo) }
+  .debug_sfnames  0 : { *(.debug_sfnames) }
+  /* DWARF 1.1 and DWARF 2 */
+  .debug_aranges  0 : { *(.debug_aranges) }
+  .debug_pubnames 0 : { *(.debug_pubnames) }
+  /* DWARF 2 */
+  .debug_info     0 : { *(.debug_info .gnu.linkonce.wi.*) }
+  .debug_abbrev   0 : { *(.debug_abbrev) }
+  .debug_line     0 : { *(.debug_line) }
+  .debug_frame    0 : { *(.debug_frame) }
+  .debug_str      0 : { *(.debug_str) }
+  .debug_loc      0 : { *(.debug_loc) }
+  .debug_macinfo  0 : { *(.debug_macinfo) }
+  /* SGI/MIPS DWARF 2 extensions */
+  .debug_weaknames 0 : { *(.debug_weaknames) }
+  .debug_funcnames 0 : { *(.debug_funcnames) }
+  .debug_typenames 0 : { *(.debug_typenames) }
+  .debug_varnames  0 : { *(.debug_varnames) }
+  .debug_pubtypes 0 : { *(.debug_pubtypes) }
+  .debug_ranges   0 : { *(.debug_ranges) }
+  /DISCARD/ : { *(.rel.dyn) }
+  .gnu.attributes 0 : { KEEP (*(.gnu.attributes)) }
+  /DISCARD/ : { *(.note.GNU-stack) }
+  /DISCARD/ : { *(.note.GNU-stack) *(.gnu_debuglink) *(.gnu.lto_*) *(.discard) }
+}
+

--- /dev/null
+++ b/mips/protozoa/api.h
@@ -0,0 +1,39 @@
+/*
+   This file is provided under the LGPL license ver 2.1.
+   Written by Katsumi.
+   http://hp.vector.co.jp/authors/VA016157/
+   [e-mail]
+*/
+
+#ifndef BOOL
+	typedef enum _BOOL { FALSE = 0, TRUE } BOOL; 
+#endif
+
+#ifndef BYTE
+	#define BYTE unsigned char
+#endif
+
+#ifndef WORD
+	#define WORD unsigned short
+#endif
+
+#ifndef DWORD
+	#define DWORD unsigned long
+#endif
+
+#ifndef UINT16
+	#define UINT16 unsigned short
+#endif
+
+#ifndef size_t
+	#define size_t unsigned int
+#endif
+
+// Used for asm("wait")
+#define WAIT "wait"
+
+#include "interface/videoout.h"
+#include "interface/SDFSIO.h"
+#include "interface/ps2keyboard.h"
+#include "interface/keyinput.h"
+#include "debug.h"

--- /dev/null
+++ b/mips/protozoa/args.c
@@ -0,0 +1,106 @@
+/*
+   This file is provided under the LGPL license ver 2.1.
+   Written by Katsumi.
+   http://hp.vector.co.jp/authors/VA016157/
+   [e-mail]
+*/
+
+/*
+	This file is shared by Megalopa and Zoea
+*/
+
+#include "compiler.h"
+
+const unsigned int g_initial_s5_stack[3]={
+	0,                                     // -8($s5): no object
+	(unsigned int) &g_initial_s5_stack[2], // -4($s5): previous $s5 (recursive)
+	0                                      //  0($s5): no parameter
+};
+
+static int g_args_stack;
+/*
+	See ARGS_SP_XXXX and ARGS_S5_XXXX in compiler.h
+	At least 4 stacks are needed even without argument
+		 4($sp) = -12($s5): $sp
+		 8($sp) =  -8($s5): $v0 - pointer to object or previous -8($s5)
+		12($sp) =  -4($s5): previous $s5
+		16($sp) =   0($s5): number of arguments
+		20($sp) =   4($s5): first argument
+	$v0 must be the pointer to an object before comming to this code.
+	After this code, -12($s5) must be set to $sp: 0xAEBDFFF4   sw          sp,-12(s5)
+*/
+char* prepare_args_stack(char start_char){
+	// start_char is either ',' or '('
+	// When ',' mode, there must be a ',' if argument(s) exist(s).
+	// When '(' mode, there shouldn't be a '(', because this character has passed.
+	char* err;
+	int opos,stack;
+	stack=0;
+	opos=g_objpos;
+	check_obj_space(2);
+	g_object[g_objpos++]=0x27BD0000;             // addiu       sp,sp,-xx
+	// 8(sp) is for $v0, which is pointer to an object
+	g_object[g_objpos++]=0xAFA20008;             // sw          v0,8(sp)
+	next_position();
+	do {
+		if (!stack) {
+			// First parameter if exists
+			stack=16;
+			if (start_char==','){
+				if (g_source[g_srcpos]!=',') break;
+			} else if (start_char=='('){
+				next_position();
+				if (g_source[g_srcpos]==')') break;
+				g_srcpos--;
+			} else {
+				return ERR_UNKNOWN;
+			}
+		}
+		g_srcpos++;
+		stack+=4;
+		err=get_stringFloatOrValue();
+		if (err) return err;
+		check_obj_space(1);
+		g_object[g_objpos++]=0xAFA20000|stack; // sw          v0,xx(sp)
+		next_position();
+	} while (g_source[g_srcpos]==',');
+	// 12(sp) is for $s5, 16(sp) is for # of parameters
+	check_obj_space(5);
+	g_object[g_objpos++]=0xAFB5000C;             // sw          s5,12(sp)
+	g_object[g_objpos++]=0x34020000|(stack/4-4); // ori         v0,zero,xx
+	g_object[g_objpos++]=0xAFA20010;             // sw          v0,16(sp)
+	g_object[g_objpos++]=0x27B50010;             // addiu       s5,sp,16
+	g_object[opos]|=((0-stack)&0xFFFF);          // addiu       sp,sp,-xx (See above)
+	// All done. Register # of stacks to global var.
+	g_args_stack=stack;
+	return 0;
+}
+
+char* remove_args_stack(void){
+	// Remove stack
+	check_obj_space(2);
+	g_object[g_objpos++]=0x8FB5000C;              // lw          s5,12(sp)
+	g_object[g_objpos++]=0x27BD0000|g_args_stack; // addiu       sp,sp,xx
+	return 0;
+}
+
+char* args_function_main(void){
+	char* err;
+	int i;
+	err=get_value();
+	if (err) return err;
+	i=g_object[g_objpos-1];
+	if ((i>>16)==0x3402) {
+		// Previous object is "ori v0,zero,xxxx".
+		i&=0xffff;
+		i=i<<2;
+		g_object[g_objpos-1]=0x8EA20000|i; //   lw          v0,xx(s5)
+	} else {
+		check_obj_space(3);
+		g_object[g_objpos++]=0x00021080;   //   sll         v0,v0,0x2
+		g_object[g_objpos++]=0x02A21021;   //   addu        v0,s5,v0
+		g_object[g_objpos++]=0x8C420000;   //   lw          v0,0(v0)
+	}
+	return 0;	
+}
+

--- /dev/null
+++ b/mips/protozoa/class.c
@@ -0,0 +1,931 @@
+/*
+   This file is provided under the LGPL license ver 2.1.
+   Written by K.Tanaka & Katsumi
+   http://www.ze.em-net.ne.jp/~kenken/index.html
+   http://hp.vector.co.jp/authors/VA016157/
+*/
+
+/*
+	This file is shared by Megalopa and Zoea
+*/
+
+#include "compiler.h"
+
+static int* g_class_structure;
+
+/*
+	CMPDATA_CLASS structure
+		type:      CMPDATA_CLASS (2)
+		len:       3
+		data16:    n/a (0)
+		record[1]: class name as integer
+		record[2]: pointer to class structure
+*/
+
+/*
+	CMPDATA_FIELD structure
+		type:      CMPDATA_FIELD (3)
+		len:       2 or 3 (2: field; 3: method)
+		data16:    field or method
+		             CMPTYPE_PUBLIC_FIELD:  0
+		             CMPTYPE_PRIVATE_FIELD: 1
+		             CMPTYPE_PUBLIC_METHOD: 2
+		record[1]: field/method name as integer
+		record[2]: pointer to method
+*/
+
+/*
+	CMPDATA_STATIC structure
+		type:      CMPDATA_STATIC (4)
+		len:       3
+		data16:    variable number; add ALLOC_LNV_BLOCK when using
+		record[1]: class name as integer
+		record[2]: variable name as integer
+*/
+
+/*
+	CMPDATA_UNSOLVED structure
+		type:      CMPDATA_UNSOLVED (5)
+		len:       4
+		data16:    CMPTYPE_NEW_FUNCTION (0)
+		record[1]: class name as integer
+		record[2]: address of code for pointer to class structure
+		record[3]: address of code for size definition
+
+		type:      CMPDATA_UNSOLVED (5)
+		len:       4
+		data16:    CMPTYPE_STATIC_METHOD (1)
+		record[1]: class name as integer
+		record[2]: method name as integer
+		record[3]: address of code for pointer to method
+
+*/
+
+/*
+	Local prototyping
+*/
+char* obj_method(int method);
+
+/*
+	Return code used for calling null method
+*/
+static const unsigned int g_return_code[]={
+	0x8FA30004, // lw          v1,4(sp)
+	0x00600008, // jr          v1
+	0x27BD0004, // addiu       sp,sp,4
+};
+
+
+
+char* begin_compiling_class(int class){
+	// Initialize parameters
+	g_compiling_class=class;
+	g_class_structure=0;
+	// Register the class to cmpdata without class structure
+	return update_class_info(class);
+}
+
+char* end_compiling_class(int class){
+	char* err;
+	g_compiling_class=0;
+	// Construct class structure
+	err=construct_class_structure(class);
+	if (err) return err;
+	// Uppdate class information.
+	err=update_class_info(class);
+	if (err) return err;
+	// Resolve CMPDATA_UNSOLVED.
+	err=resolve_unresolved(class);
+	if (err) return err;
+	// Delete some cmpdata.
+	delete_cmpdata_for_class(class);
+	return 0;
+}
+
+void* search_method(int* classdata,int method){
+	int pos,i;
+	int nums=classdata[1];
+
+	classdata+=2;                  // exclude first 2 words
+	classdata+=2*(nums&0xff);      // exclude public field
+	classdata+=2*((nums>>8)&0xff); // exclude private field
+	nums=(nums>>16)&0xff;          // number of methods
+	for(i=0;i<nums;i++){
+		if (classdata[0]==method) return (void*)classdata[1];
+		classdata+=2;
+	}
+	return 0; // not found
+}
+
+char* resolve_unresolved(int class){
+	int* classdata;
+	int* record;
+	int* code;
+	int i;
+	// Get class structure
+	cmpdata_reset();
+	while(record=cmpdata_find(CMPDATA_CLASS)){
+		if (record[1]==class) break;
+	}
+	if (!record) return ERR_UNKNOWN;
+	classdata=(int*)record[2];
+	// Explore CMPDATA_UNSOLVED
+	cmpdata_reset();
+	while(record=cmpdata_find(CMPDATA_UNSOLVED)){
+		// Note: don't use cmpdata_find() again in the loop.
+		// If used, the solved CMPDATA_UNSOLVED must be removed before.
+		if (record[1]!=class) continue;
+		switch (record[0]&0xffff) {
+			case CMPTYPE_NEW_FUNCTION:
+				// Resolve address of code for pointer to class structure
+				code=(int*)(record[2]);
+				code[0]=(code[0]&0xFFFF0000) | (((unsigned int)classdata)>>16);
+				code[1]=(code[1]&0xFFFF0000) | (((unsigned int)classdata) & 0x0000FFFF);
+				// Resolve size of object
+				code=(int*)(record[3]);
+				code[0]=(code[0]&0xFFFF0000) | (object_size(classdata) & 0x0000FFFF);
+				// All done
+				break;
+			case CMPTYPE_STATIC_METHOD:
+				// Resolve address of code for pointer to method
+				// Find method
+				i=(int)search_method(classdata,record[2]);
+				if (!i) return ERR_NOT_FIELD;
+				code=(int*)(record[3]);
+				code[0]=(code[0]&0xFC000000)|((i&0x0FFFFFFF)>>2);
+				// All done
+				break;
+			default:
+				return ERR_UNKNOWN;
+		}
+	}
+	return 0;	
+}
+
+char* update_class_info(int class){
+	int* record;
+	int data[2];
+	// Update record if exist.
+	cmpdata_reset();
+	while(record=cmpdata_find(CMPDATA_CLASS)){
+		if (record[1]==class) {
+			record[2]=(int)g_class_structure;
+			return 0;
+		}
+	}
+	// No record of this class yet. Insert a record.
+	data[0]=class;
+	data[1]=(int)g_class_structure;
+	return cmpdata_insert(CMPDATA_CLASS,0,&data[0],2);
+}
+
+/*
+	Class structure:
+		cstruct[0]:   class name as integer
+		cstruct[1]:   number of fields and methods:
+		                bit 0-7:   # of public fields
+		                bit 8-15:  # of private fields
+		                bit 16-23: # of public methods
+		                bit 24-31: reserved
+		cstruct[x]:   public field name
+		cstruct[x+1]: public field var number
+		cstruct[y]:   private field name
+		cstruct[y+1]: private field var number
+		cstruct[z]:   public method name
+		cstruct[z+1]: public method pointer
+*/
+
+/*
+	Object structure:
+		object[0]:   pointer to class structure
+		object[1]:   field value
+		...
+		object[n]:   field value
+		(according to class structure; public field(s) first, then private field(s))
+*/
+
+char* construct_class_structure(int class){
+	int* record;
+	int i;
+	int num=0;
+	// Register current address to global var
+	g_class_structure=&g_object[g_objpos];
+	// Construct a class structure in object area in following lines
+	// Class name
+	check_obj_space(2);
+	g_object[g_objpos++]=class; // Class name
+	g_objpos++;                 // Number of fields/methods
+	// Public fields
+	cmpdata_reset();
+	while(record=cmpdata_find(CMPDATA_FIELD)){
+		if ((record[0]&0xffff)==CMPTYPE_PUBLIC_FIELD) {
+			num+=1<<0;
+			check_obj_space(2);
+			g_object[g_objpos++]=record[1]; // Field name
+			g_objpos++;                     // Var number (see below)
+		}
+	}
+	// Private fields
+	cmpdata_reset();
+	while(record=cmpdata_find(CMPDATA_FIELD)){
+		if ((record[0]&0xffff)==CMPTYPE_PRIVATE_FIELD) {
+			num+=1<<8;
+			check_obj_space(2);
+			g_object[g_objpos++]=record[1]; // Field name
+			g_objpos++;                     // Var number (see below)
+		}
+	}
+	// Public methods
+	cmpdata_reset();
+	while(record=cmpdata_find(CMPDATA_FIELD)){
+		if ((record[0]&0xffff)==CMPTYPE_PUBLIC_METHOD) {
+			num+=1<<16;
+			check_obj_space(2);
+			g_object[g_objpos++]=record[1]; // Method name
+			g_object[g_objpos++]=record[2]; // pointer
+		}
+	}
+	// Update number info
+	g_class_structure[1]=num;
+	// Update var numbers of fields
+	num=((num>>8)&0xff)+(num&0xff);
+	for(i=1;i<=num;i++){
+		if ((
+			g_class_structure[i*2+1]=search_var_name(0x7FFFFFFF & g_class_structure[i*2])+ALLOC_LNV_BLOCK
+			)<ALLOC_LNV_BLOCK) return ERR_UNKNOWN;
+	}
+	return 0;
+}
+
+void delete_cmpdata_for_class(int class){
+	int* record;
+	// Delete field/method data
+	cmpdata_reset();
+	while(record=cmpdata_find(CMPDATA_FIELD)){
+		cmpdata_delete(record);
+		cmpdata_reset();
+	}	
+	// Delete longvar data
+	cmpdata_reset();
+	while(record=cmpdata_find(CMPDATA_USEVAR)){
+		cmpdata_delete(record);
+		cmpdata_reset();
+	}
+	// Delete solved class codes
+	cmpdata_reset();
+	while(record=cmpdata_find(CMPDATA_UNSOLVED)){
+		if (record[1]!=class) continue;
+		cmpdata_delete(record);
+		cmpdata_reset();
+	}
+}
+
+int object_size(int* classdata){
+	int nums=classdata[1];
+	int size=nums&0xff;   // public field
+	size+=(nums>>8)&0xff; // private
+	// Add 1 for pointer to class data.
+	return size+1;	
+}
+
+char* new_function(){
+	char* err;
+	int class,size;
+	int i,stack, opos;
+	int* data;
+	int* classdata;
+	int record[3];
+	void* init_method;
+	// Resolve class name
+	err=get_label();
+	if (err) return err;
+	if (!g_label) return ERR_SYNTAX;
+	class=g_label;
+	record[0]=class;
+	next_position();
+	// Get class data from cmpdata
+	// Note that the address of class structure can be resolved
+	// by using cmpdata when compiling NEW function but not running. 
+	// Therefore, class table is not requred when running.
+	cmpdata_reset();
+	while(data=cmpdata_find(CMPDATA_CLASS)){
+		if (data[1]==class) break;
+	}
+	if (!data) return ERR_NO_CLASS;
+	classdata=(int*)data[2];
+	if (classdata) {
+		size=object_size(classdata);
+	} else {
+		// Class structure is unsolved.
+		size=0;
+	}
+	// Create object
+	record[2]=(int)&g_object[g_objpos+3];
+	call_quicklib_code(lib_calloc_memory,ASM_ORI_A0_ZERO_|size);
+	// First word of object is pointer to classdata
+	check_obj_space(3);
+	record[1]=(int)&g_object[g_objpos];
+	g_object[g_objpos++]=0x3C080000|(((unsigned int)classdata)>>16);        // lui         t0,xxxx
+	g_object[g_objpos++]=0x35080000|(((unsigned int)classdata)&0x0000FFFF); // ori         t0,t0,xxxx
+	g_object[g_objpos++]=0xAC480000; // sw          t0,0(v0)
+	// Check if INIT method exists
+	if (classdata) {
+		init_method=search_method(classdata,LABEL_INIT);
+	} else {
+		// Class structure is unknown. Use null method.
+		init_method=(int*)&g_return_code[0];
+		// Register CMPDATA
+		cmpdata_insert(CMPDATA_UNSOLVED,CMPTYPE_NEW_FUNCTION,(int*)&record[0],3);
+		g_allow_shift_obj=0;
+	}		
+	if (!init_method) {
+		// All done
+		// Note that $v0 is address of object here.
+		// There should not be parameter(s).
+		if (g_source[g_srcpos]==',') return ERR_NO_INIT;
+		return 0;
+	}
+	// INIT method exists. Note that $v0 is address of object here.
+	if (g_source[g_srcpos]==',') g_srcpos++;
+	else if (g_source[g_srcpos]!=')') return ERR_SYNTAX;
+	check_obj_space(2);
+	g_object[g_objpos++]=0x27BDFFFC; // addiu       sp,sp,-4
+	g_object[g_objpos++]=0xAFA20004; // sw          v0,4(sp)
+	err=obj_method(LABEL_INIT);
+	if (err) return err;
+	g_srcpos--; // Leave ')' character for detecting end of "new" function
+	check_obj_space(2);
+	g_object[g_objpos++]=0x8FA20004; //lw          v0,4(sp)
+	g_object[g_objpos++]=0x27BD0004; //addiu       sp,sp,4
+	// All done
+	// Note that $v0 is address of object here.
+	return 0;
+}
+
+char* field_statement(){
+	char* err;
+	int i;
+	int data[1];
+	int is_private=0;
+	// This statement is valid only in class file.
+	if (!g_compiling_class) return ERR_INVALID_NON_CLASS;
+	// Check which private or public
+	next_position();
+	if (nextCodeIs("PRIVATE ")) {
+		is_private=1;
+	} else if (nextCodeIs("PUBLIC ")) {
+		is_private=0;
+	}
+	do {
+		next_position();
+		i=check_var_name();
+		if (i<65536) return ERR_SYNTAX;
+		// Register varname
+		err=register_var_name(i);
+		if (err) return err;
+		if (g_source[g_srcpos]=='#') {
+			g_srcpos++;
+		} else if (g_source[g_srcpos]=='$') {
+			// String field. Raise 31st bit.
+			g_srcpos++;
+			i|=0x80000000;
+		} else if (g_source[g_srcpos]=='(' && g_source[g_srcpos+1]==')' && is_private) {
+			// Dimension field (private only). Raise 31st bit.
+			g_srcpos++;
+			g_srcpos++;
+			i|=0x80000000;
+		}
+		// Register field
+		data[0]=i;
+		if (is_private) {
+			err=cmpdata_insert(CMPDATA_FIELD,CMPTYPE_PRIVATE_FIELD,(int*)&data[0],1);
+		} else {
+			err=cmpdata_insert(CMPDATA_FIELD,CMPTYPE_PUBLIC_FIELD,(int*)&data[0],1);
+		}
+		next_position();
+		if (g_source[g_srcpos]==',') {
+			g_srcpos++;
+		} else {
+			break;
+		}
+	} while(1);
+	return 0;
+}
+
+/*
+	char* obj_method(int method);
+	Implementation of access to method of object.
+*/
+char* obj_method(int method){
+	// $v0 contains the address of object.
+	// Note that '(' has been passed.
+	char* err;
+	int stack,opos;
+	// When method of an object is called from object, 
+	// current variables must be saved to object fields
+	if (g_compiling_class) {
+		check_obj_space(1);
+		g_object[g_objpos++]=0x00402821; // addu        a1,v0,zero
+		call_quicklib_code(lib_save_vars_to_fields,ASM_LW_A0_XXXX_S5|ARGS_S5_V0_OBJ);
+	}
+	// Parameters preparation (to $s5) here.
+	next_position();
+	opos=g_objpos;
+	// Begin parameter(s) construction routine
+	err=prepare_args_stack('(');
+	if (err) return err;
+	if (g_source[g_srcpos]!=')') return ERR_SYNTAX;
+	g_srcpos++;
+	// Determine address of method and store fields to local variables.
+	check_obj_space(3);
+	g_object[g_objpos++]=0x8FA20000|ARGS_SP_V0_OBJ;            // lw          v0,8(sp)
+	g_object[g_objpos++]=0x3C050000|((method>>16)&0x0000FFFF); // lui   a1,xxxx
+	g_object[g_objpos++]=0x34A50000|(method&0x0000FFFF);       // ori a1,a1,xxxx
+	call_quicklib_code(lib_pre_method,ASM_ADDU_A0_V0_ZERO);
+	// Call method address here. Same routine for GOSUB statement with integer value is used.
+	check_obj_space(6);
+	g_object[g_objpos++]=0x27BDFFFC;                           // addiu       sp,sp,-4
+	g_object[g_objpos++]=0x04130003;                           // bgezall     zero,label1
+	g_object[g_objpos++]=0xAEBD0000|ARGS_S5_SP;                // sw          sp,-12(s5)
+	g_object[g_objpos++]=0x10000003;                           // beq         zero,zero,label2
+	g_object[g_objpos++]=0x00000000;                           // nop         
+	                                                           // label1:
+	g_object[g_objpos++]=0x00400008;                           // jr          v0
+	g_object[g_objpos++]=0xAFBF0004;                           // sw          ra,4(sp)	                                                           // label2:
+	// Restore fields from local variables.
+	check_obj_space(3);
+	g_object[g_objpos++]=0x8FA40008;                           // lw          a0,8(sp)
+	call_quicklib_code(lib_post_method,ASM_ADDU_A1_V0_ZERO);
+	// Remove stack
+	err=remove_args_stack();
+	if (err) return err;
+	// When method of an object is called from object, 
+	// current variables must be saved to object fields
+	if (g_compiling_class) {
+		check_obj_space(1);
+		g_object[g_objpos++]=0x00402821; // addu        a1,v0,zero
+		call_quicklib_code(lib_load_vars_from_fields,ASM_LW_A0_XXXX_S5|ARGS_S5_V0_OBJ);
+	}
+	return 0;
+}
+
+/*
+	char* integer_obj_field();
+	char* string_obj_field();
+	char* float_obj_field();
+	Implementation of access to field of object.
+	This feature is recursive. When an object is applied to the field of another object, 
+	following expression is possible (for example):
+		obj1.field1.field2
+	
+*/
+
+#define OBJ_FIELD_INTEGER 0
+#define OBJ_FIELD_STRING  '$'
+#define OBJ_FIELD_FLOAT   '#'
+
+char* _obj_field(char mode){
+	// $v0 contains the address of object.
+	int i;
+	char* err;
+	do {
+		i=check_var_name();
+		if (i<65536) return ERR_SYNTAX;
+		if (g_source[g_srcpos]=='(' && mode==OBJ_FIELD_INTEGER) {
+			// This is a method
+			g_srcpos++;
+			return obj_method(i);
+		} else if (g_source[g_srcpos+1]=='(') {
+			if (g_source[g_srcpos]==mode) {
+				// This is a string/float method
+				g_srcpos++;
+				g_srcpos++;
+				return obj_method(i);
+			}
+		} else if (g_source[g_srcpos]==mode && mode==OBJ_FIELD_STRING) {
+			// This is a string field. Raise 31st bit.
+			i|=0x80000000;
+		}
+		check_obj_space(2);
+		g_object[g_objpos++]=0x3C050000|((i>>16)&0x0000FFFF); // lui   a1,xxxx
+		g_object[g_objpos++]=0x34A50000|(i&0x0000FFFF);       // ori a1,a1,xxxx
+		// First and second arguments are address of object and field name, respectively.
+		call_quicklib_code(lib_obj_field,ASM_ADDU_A0_V0_ZERO);
+		// Check if "." follows
+		if (g_source[g_srcpos]=='.') {
+			// "." found. $v0 is adress of an object. See the field.
+			g_srcpos++;
+			continue;
+		}
+	} while(0);
+	// All done. Check variable type
+	if (mode==OBJ_FIELD_INTEGER) return 0;
+	else if (g_source[g_srcpos]==mode) {
+		g_srcpos++;
+		return 0;
+	} else return ERR_SYNTAX;
+}
+
+char* integer_obj_field(){
+	return _obj_field(OBJ_FIELD_INTEGER);
+}
+
+char* string_obj_field(){
+	return _obj_field(OBJ_FIELD_STRING);
+}
+
+char* float_obj_field(){
+	return _obj_field(OBJ_FIELD_FLOAT);
+}
+
+int lib_obj_field(int* object, int fieldname){
+	int* class;
+	int i,numfield;
+	// Check if this is an object (if within the RAM).
+	if (!withinRAM(object)) err_not_obj();
+	class=(int*)object[0];
+	if (!withinRAM(class)) err_not_obj();
+	// Obtain # of public field
+	numfield=class[1]&0xff;
+	for(i=0;i<numfield;i++){
+		if (class[2+i*2]==fieldname) break;
+	}
+	if (i==numfield) err_not_field(fieldname,class[0]);
+	// Got address of field. Return value as $v0 and address as $v1.
+	g_temp=(int)(&object[1+i]);
+	asm volatile("la $v1,%0"::"i"(&g_temp));
+	asm volatile("lw $v1,0($v1)");
+	return object[1+i];
+}
+
+/*
+	Library for letting string field 
+*/
+
+void lib_let_str_field(char* prev_str, char* new_str){
+	int var_num=get_permanent_var_num();
+	free_perm_str(prev_str);
+	lib_let_str(new_str,var_num);
+	return;
+}
+
+/*
+	Library for calling method statement
+*/
+
+int lib_load_vars_from_fields(int* object, int v0){
+	// Do nothing if no object
+	if (object) lib_pre_method(object,LABEL_INIT);
+	return v0;
+}
+
+int lib_pre_method(int* object, int methodname){
+	int i,num,nums;
+	int* class;
+	// Check if this is an object (if within the RAM).
+	if (!withinRAM(object)) err_not_obj();
+	class=(int*)object[0];
+	if (!withinRAM(class)) err_not_obj();
+	// Save object field values in local variables in class
+	nums=class[1];
+	num=nums&0xff;
+	for(i=0;i<num;i++){
+		// Public fields
+		class+=2;
+		g_var_mem[class[1]]=object[i+1];
+		// When string, move from permanent block
+		if (0x80000000&class[0]) move_from_perm_block_if_exists(class[1]);
+	}
+	num+=(nums>>8)&0xff;
+	for(i=i;i<num;i++){
+		// Private fields
+		class+=2;
+		g_var_mem[class[1]]=object[i+1];
+		// When string/dimension, move from permanent block
+		if (0x80000000&class[0]) move_from_perm_block_if_exists(class[1]);
+	}
+	// Seek method
+	num+=(nums>>16)&0xff;
+	for(i=i;i<num;i++){
+		class+=2;
+		if (class[0]==methodname) break;
+	}
+	if (i==num) {
+		// Method not found
+		if (methodname==LABEL_INIT) {
+			// INIT method not found
+			// Call null function
+			return (int)(&g_return_code[0]);
+		} else {
+			class=(int*)object[0];
+			err_not_field(methodname,class[0]);
+		}
+	}
+	// Method found. return it.
+	return class[1];
+}
+
+int lib_save_vars_to_fields(int* object,int v0){
+	int* class;
+	// Do nothing if no object
+	if (!object) return;
+	// Check if this is an object (if within the RAM).
+	if (!withinRAM(object)) err_not_obj();
+	class=(int*)object[0];
+	if (!withinRAM(class)) err_not_obj();
+	// save vars
+	lib_post_method(object,0);
+	return v0;
+}
+
+int lib_post_method(int* object, int v0){
+	// Note that v0 (a1) contains the return value from a method.
+	int i,num,nums;
+	int* class;
+	// Restore local variables to object field values
+	class=(int*)object[0];
+	nums=class[1];
+	num=nums&0xff;
+	for(i=0;i<num;i++){
+		// Public fields
+		class+=2;
+		object[i+1]=g_var_mem[class[1]];
+		// When string, move to permanent block
+		if (0x80000000&class[0]) {
+			if (g_var_size[class[1]]) move_to_perm_block(class[1]);
+		}
+	}
+	num+=(nums>>8)&0xff;
+	for(i=i;i<num;i++){
+		// Private fields
+		class+=2;
+		object[i+1]=g_var_mem[class[1]];
+		// When string/dimension, move to permanent block
+		if (0x80000000&class[0]) {
+			if (g_var_size[class[1]]) move_to_perm_block(class[1]);
+		}
+	}
+	// all done
+	return v0;
+}
+
+/*
+	Method statement
+*/
+
+char* method_statement(){
+	char* err;
+	int data[2];
+	int opos=g_objpos;
+	// This statement is valid only in class file.
+	if (!g_compiling_class) return ERR_INVALID_NON_CLASS;
+	// Insert label for setting $s6
+	err=label_statement();
+	if (err) return err;
+	// Register cmpdata
+	data[0]=g_label;
+	data[1]=(int)(&g_object[opos]);
+	return cmpdata_insert(CMPDATA_FIELD,CMPTYPE_PUBLIC_METHOD,(int*)&data[0],2);
+}
+
+/*
+	Delete statement
+*/
+
+char* delete_statement(){
+	char* err;
+	next_position();
+	g_srcpos--;
+	do{
+		g_srcpos++;
+		err=get_value();
+		if (err) return err;
+		call_quicklib_code(lib_delete,ASM_ADDU_A0_V0_ZERO);
+		next_position();
+	} while (g_source[g_srcpos]==',');
+	return 0;
+}
+
+/*
+	Call statement
+*/
+
+char* call_statement(){
+	// Just get an integer value. That is it.
+	return get_value();
+}
+
+/*
+	Static statement
+*/
+
+char* static_statement(){
+	char* err;
+	int* record;
+	int data[2];
+	int i;
+	int is_private=0;
+	// This statement is valid only in class file.
+	if (!g_compiling_class) return ERR_INVALID_NON_CLASS;
+	// Check which private or public
+	next_position();
+	if (nextCodeIs("PRIVATE ")) {
+		is_private=1;
+	} else if (nextCodeIs("PUBLIC ")) {
+		is_private=0;
+	}
+	do {
+		next_position();
+		i=check_var_name();
+		if (i<65536) return ERR_SYNTAX;
+		if (g_source[g_srcpos]=='#' || g_source[g_srcpos]=='$') {
+			g_srcpos++;
+		}
+		// Register public static field
+		if (is_private) {
+			// This is the same as USEVAR
+			// Register varname
+			err=register_var_name(i);
+			if (err) return err;
+		} else {
+			// Check if there is already a CMPDATA record
+			cmpdata_reset();
+			while(record=cmpdata_find(CMPDATA_STATIC)){
+				if (record[1]!=g_compiling_class) continue;
+				if (record[2]!=i) continue;
+				break;
+			}
+			if (record) {
+				// There is already a record.
+				// Do not allocate new number but use the registered number;
+				i=record[0]&0xffff;
+				err=cmpdata_insert(CMPDATA_USEVAR,i,&record[2],1);
+				if (err) return err;
+			} else {
+				// Register varname
+				err=register_var_name(i);
+				if (err) return err;
+				// Insert a CMDATA_STATIC record
+				data[0]=g_compiling_class; // class name as integer
+				data[1]=i;                 // static var name as integer
+				i=search_var_name(i);      // var number of this static field
+				if (i<0) return ERR_UNKNOWN;
+				err=cmpdata_insert(CMPDATA_STATIC,i,(int*)&data[0],2);
+				if (err) return err;
+			}
+		}
+		next_position();
+		if (g_source[g_srcpos]==',') {
+			g_srcpos++;
+		} else {
+			break;
+		}
+	} while(1);
+	return 0;
+	
+}
+
+/*
+	Static method
+		Type is either 0, '$', or '#', 
+		for integer, string, or float
+*/
+
+char* static_method(char type){
+	char* err;
+	int* data;
+	int record[3];
+	int i,opos,method,stack;
+	next_position();
+	// Check class name
+	i=check_var_name();
+	if (i<65536) return ERR_SYNTAX;
+	record[0]=i;
+	// Check if the class exists
+	cmpdata_reset();
+	while(data=cmpdata_find(CMPDATA_CLASS)){
+		if (data[1]==i) {
+			// The class was already defined.
+			i=0;
+			break;
+		}
+	}
+	// Check '::'
+	if (g_source[g_srcpos]!=':') return ERR_SYNTAX;
+	g_srcpos++;
+	if (g_source[g_srcpos]!=':') return ERR_SYNTAX;
+	g_srcpos++;
+	if (i) return ERR_NO_CLASS;
+	data=(int*)data[2];
+	// Check method
+	i=check_var_name();
+	if (i<65536) return ERR_SYNTAX;
+	if (data) {
+		method=(int)search_method(data,i);
+		if (!method) return ERR_NOT_FIELD;
+	} else {
+		method=(int)&g_return_code[0];
+		record[1]=i;
+	}
+	// Check type and '('
+	if (type) {// Either 0, '$', or '#'
+		if (g_source[g_srcpos]!=type) return ERR_SYNTAX;
+		g_srcpos++;
+
+	}
+	if (g_source[g_srcpos]!='(') return ERR_SYNTAX;
+	g_srcpos++;
+	// Begin parameter(s) construction routine
+	check_obj_space(1);
+	g_object[g_objpos++]=0x34020000; // ori v0,zero,0
+	err=prepare_args_stack('(');
+	if (err) return err;
+	// Calling subroutine, which is static method of class
+	record[2]=(int)&g_object[g_objpos+5];
+	check_obj_space(7);
+	g_object[g_objpos++]=0x27BDFFFC;                            // addiu       sp,sp,-4
+	g_object[g_objpos++]=0x04130003;                            // bgezall     zero,label1
+	g_object[g_objpos++]=0xAEBD0000|ARGS_S5_SP;                 // sw          sp,-12(s5)
+	g_object[g_objpos++]=0x10000003;                            // beq         zero,zero,label2
+	g_object[g_objpos++]=0x00000000;                            // nop         
+	                                                            // label1:
+	g_object[g_objpos++]=0x08000000|((method&0x0FFFFFFF)>>2);   // j           xxxx
+	g_object[g_objpos++]=0xAFBF0004;                            // sw          ra,4(sp)
+		                                                        // label2:	
+	// Register CMPDATA if required.
+	if (!data) {
+		cmpdata_insert(CMPDATA_UNSOLVED,CMPTYPE_STATIC_METHOD,(int*)&record[0],3);
+		g_allow_shift_obj=0;
+	}
+	// Remove stack
+	err=remove_args_stack();
+	if (err) return err;
+	return 0;
+}
+
+/*
+	Let object.field statement
+*/
+
+char* let_object_field(){
+	char* err;
+	char b3;
+	int spos,opos;
+	// $v0 contains the pointer to object
+	spos=g_srcpos;
+	opos=g_objpos;
+	// Try string field, first
+	err=string_obj_field();
+	if (err) {
+		// Integer or float field
+		g_srcpos=spos;
+		g_objpos=opos;
+		err=integer_obj_field();
+		if (err) return err;
+		b3=g_source[g_srcpos];
+		if (b3=='#') g_srcpos++;
+	} else {
+		// String field
+		b3='$';
+	}
+	if (g_source[g_srcpos-1]==')') {
+		// This is a CALL statement
+		return 0;
+	}
+	// $v1 is address to store value. Save it in stack.
+	check_obj_space(1);
+	g_object[g_objpos++]=0x27BDFFFC;              // addiu sp,sp,-4
+	g_object[g_objpos++]=0xAFA30004;              // sw    v1,4(sp)
+	if (b3=='$') {
+		// String field
+		// Get value
+		next_position();
+		if (g_source[g_srcpos]!='=') return ERR_SYNTAX;
+		g_srcpos++;
+		err=get_string();
+	} else if (b3=='#') {
+		// Float field
+		// Get value
+		next_position();
+		if (g_source[g_srcpos]!='=') return ERR_SYNTAX;
+		g_srcpos++;
+		err=get_float();
+	} else {
+			// Integer field
+			// Get value
+			next_position();
+			if (g_source[g_srcpos]!='=') return ERR_SYNTAX;
+			g_srcpos++;
+			err=get_value();
+	}
+	if (err) return err;
+	// Store in field of object
+	check_obj_space(4);
+	g_object[g_objpos++]=0x8FA30004;              // lw    v1,4(sp)
+	g_object[g_objpos++]=0x27BD0004;              // addiu sp,sp,4
+	g_object[g_objpos++]=0x8C640000;              // lw    a0,0(v1)
+	g_object[g_objpos++]=0xAC620000;              // sw    v0,0(v1)
+	// Handle permanent block for string field
+	if (b3=='$') call_quicklib_code(lib_let_str_field,ASM_ADDU_A1_V0_ZERO);
+	return 0;
+}
\ No newline at end of file

--- /dev/null
+++ b/mips/protozoa/cmpdata.c
@@ -0,0 +1,130 @@
+/*
+   This file is provided under the LGPL license ver 2.1.
+   Written by Katsumi.
+   http://hp.vector.co.jp/authors/VA016157/
+   [e-mail]
+*/
+
+/*
+	This file is shared by Megalopa and Zoea
+*/
+
+#include "compiler.h"
+
+/*
+	This file provide functions for handling data used when compiling.
+	The data is inserted between g_objmax and file cache.
+	Data format (32 bit):
+		MSB                LSB
+		 +----+----+--------+
+		 |type|len | data16 |
+		 +----+----+--------+
+		where,
+			type:   data type number (unsigned char)
+			len:    length of data area in number of words (unsigned char)
+			data16: general 16 bit data (short)
+*/
+
+/*
+	CMPDATA_TEMP structure
+		type:      CMPDATA_TEMP (6)
+		len:       n+1
+		data16:    id
+		record[1]: any data
+		record[2]: any data
+		...
+		record[n]: any data
+*/
+
+#define g_cmpdata g_objmax
+
+static int* g_cmpdata_end;
+static int* g_cmpdata_point;
+static unsigned short g_cmpdata_id;
+
+/*
+	Initialize routine must be called when starting compiler.
+*/
+void cmpdata_init(){
+	g_cmpdata_end=g_objmax;
+	g_cmpdata_point=g_objmax;
+	g_cmpdata_id=1;
+}
+
+/*
+	Returns ID as 16 bit indivisual number
+*/
+unsigned short cmpdata_get_id(){
+	if ((++g_cmpdata_id)==0) printstr("CMPDATA: no more ID!\n");
+	return g_cmpdata_id;
+}
+
+/*
+	Function to insert a data. The data must be defined by a pointer to int array.
+		unsigned char type: Data type number (0-255)
+		short data16:       16 bit data. If not required, set 0.
+		int* data:          Pointer to data array. If not requird, set 0.
+		unsigned char num:  Length of above data array. If not required, set 0.
+*/
+char* cmpdata_insert(unsigned char type, short data16, int* data, unsigned char num){
+	unsigned char i;
+	g_cmpdata-=num+1;
+	if (g_cmpdata<g_object+g_objpos) return ERR_NE_BINARY;
+	g_cmpdata[0]=(type<<24)|(num+1)<<16|data16;
+	for(i=0;i<num;i++){
+		g_cmpdata[i+1]=data[i];
+	}
+	return 0;
+}
+
+/*
+	Reset data point. Next search will be from the beginning.
+*/
+
+void cmpdata_reset(){
+	g_cmpdata_point=g_cmpdata;
+}
+
+/*
+	Find the next record with defined type. Return the pointer to the record.
+*/
+int* cmpdata_find(unsigned char type){
+	int* ret;
+	while(g_cmpdata_point<g_cmpdata_end){
+		// Remember return value
+		ret=g_cmpdata_point;
+		// Move the point to next
+		g_cmpdata_point+=(ret[0]&0x00ff0000)>>16;
+		// Check if type is the same. If the same, return.
+		if ((ret[0]>>24)==type) return ret;
+	}
+	return 0;
+}
+
+/*
+	Find the record from beginning.
+*/
+
+int* cmpdata_findfirst(unsigned char type){
+	cmpdata_reset();
+	return cmpdata_find(type);
+}
+
+/*
+	Delete a record.
+*/
+void cmpdata_delete(int* record){
+	int delnum;
+	int* data;
+	// Ignore if invalid record.
+	if (record<g_cmpdata || g_cmpdata_end<record) return;
+	// Get number of word to delete.
+	delnum=(record[0]&0x00ff0000)>>16;
+	// Delete record by shifting data.
+	for(data=record-1;g_cmpdata<=data;data--){
+	     data[delnum]=data[0];
+	}
+	g_cmpdata+=delnum;
+	// Reset
+	cmpdata_reset();
+}

--- /dev/null
+++ b/mips/protozoa/compiler.c
@@ -0,0 +1,183 @@
+/*
+   This file is provided under the LGPL license ver 2.1.
+   Written by Katsumi.
+   http://hp.vector.co.jp/authors/VA016157/
+   [e-mail]
+*/
+
+/*
+	This file is shared by Megalopa and Zoea
+*/
+
+/*
+	Usage of MIPS32 registors
+	$zero:   always zero
+	$at:     not used
+	$v0:     return value or result of last calculation
+	$v1:     for calculation (like $v0=$v1*$v0)
+	$a0-$a2: parameters for calling library ($a2=$v0)
+	$a3:     function # for library
+	$t0-$t7: used as temporary registors
+	$s0-$s4: not used
+	$s5:     pointer to parameters list
+	$s6:     line or label number
+	$s7:     address of call_library()
+	$t8-$t9: used as temporary registors
+	$k0-$k1: not used
+	$gp:     for accessing global variables by C
+	$sp:     stack pointer
+	$fp($s8) for accessing variables by BASIC
+	$ra:     contains return address
+*/
+
+#include "compiler.h"
+
+void start_program(void* addr, void* memory){
+	// Note that if usage of $s0-$s7, and $fp is changed, 
+	// revice BasicInt() in timer.c, too.
+	static unsigned int stored_sp;
+	// Store s0-s7, fp, and ra in stacks
+	asm volatile("#":::"s0");
+	asm volatile("#":::"s1");
+	asm volatile("#":::"s2");
+	asm volatile("#":::"s3");
+	asm volatile("#":::"s4");
+	asm volatile("#":::"s5");
+	asm volatile("#":::"s6");
+	asm volatile("#":::"s7");
+	asm volatile("#":::"fp");
+	asm volatile("#":::"ra");
+	// Store sp in stored_sp
+	asm volatile("la $v0,%0"::"i"(&stored_sp));
+	asm volatile("sw $sp,0($v0)");
+	// Shift sp for safety
+	asm volatile("addiu $sp,$sp,-8");
+	// Register vector for unexpected NEXT/RETURN
+	asm volatile("la $v0,%0"::"i"(&err_unexp_next));
+	asm volatile("sw $v0,4($sp)");
+	// Store end address in g_end_addr
+	asm volatile("la $v0,%0"::"i"(&g_end_addr));
+	asm volatile("la $v1,label");
+	asm volatile("sw $v1,0($v0)");
+	// Set s5 for initial_s5_stack
+	asm volatile("la $s5,%0"::"i"(&g_initial_s5_stack[2]));
+	// Set s7 for easy calling call_library()
+	asm volatile("la $s7,%0"::"i"(&call_library));
+	// Set fp and execute program
+	asm volatile("addu $fp,$zero,$a1");
+	asm volatile("jr $a0");
+	// Restore sp from stored_sp
+	asm volatile("label:");
+	asm volatile("la $v0,%0"::"i"(&stored_sp));
+	asm volatile("lw $sp,0($v0)");
+	// Restore registers from stack and return
+	return;
+}
+
+int get_gp(void){
+	asm volatile("addu $v0,$gp,$zero");
+}
+
+int get_fp(void){
+	asm volatile("addu $v0,$fp,$zero");
+}
+
+
+void shift_obj(int* src, int* dst, int len){
+	int i;
+	if (dst<src) {
+		for(i=0;i<len;i++){
+			dst[i]=src[i];
+		}
+	} else if (src<dst) {
+		for(i=len-1;0<=i;i--){
+			dst[i]=src[i];
+		}
+	}
+}
+
+int strncmp(char* str1, char* str2, int len){
+	int i;
+	for (i=0;i<len;i++) {
+		if (str1[i]>str2[i]) return 1;
+		if (str1[i]<str2[i]) return -1;
+	}
+	return 0;
+}
+
+int nextCodeIs(char* str){
+	int len;
+	next_position();
+	for(len=0;str[len];len++);
+	if (!strncmp(g_source+g_srcpos,str,len)) {
+		if ('A'<=str[len-1] && str[len-1]<='Z') {
+			// When the last character of str is alphabet, 
+			// the next character in source must be space, enter, ',', or ':'.
+			if (0x20<g_source[g_srcpos+len] && 
+				g_source[g_srcpos+len]!=':' && g_source[g_srcpos+len]!=',') return 0;
+		}
+		// String matches in the current position in source.
+		g_srcpos+=len;
+		return len;
+	} else {
+		// String didn't match.
+		return 0;
+	}
+}
+
+int endOfStatement(){
+	unsigned char b;
+	next_position();
+	b=g_source[g_srcpos];
+	return (b<0x20 || b==':') ? 1:0;
+}
+
+char* compile_line(void){
+	char b1;
+	char* err;
+	g_line++;
+	g_fileline++;
+	// Check if line number exists
+	next_position();
+	b1=g_source[g_srcpos];
+	if (b1<0x20) {
+		// The end of line.
+		// Don't add $s6-setting command.
+		if (g_source[g_srcpos]==0x0D && g_source[g_srcpos+1]==0x0A) g_srcpos++;
+		g_srcpos++;
+		return 0;
+	} else if ('0'<=b1 && b1<='9') {
+		// Line number exists
+		err=get_label();
+		if (err) return err;
+		g_line=g_label;
+	}
+	// Store line number in $s6
+	if (!(g_line&0xFFFF0000)) {
+		// Line number must be less than 65536.
+		// If not, it is invalid number.
+		// Check existing line with the same number here.
+		if (search_label(g_line)) {
+			// Error: duplicate lines
+			printstr("Line ");
+			printstr(resolve_label(g_line));
+			return ERR_MULTIPLE_LABEL;
+		}
+		if (!g_nolinenum) {
+			check_obj_space(1);
+			g_object[g_objpos++]=0x34160000|g_line; //ori         s6,zero,xxxx;
+		}
+	}
+	while(g_source[g_srcpos]!=0x0D && g_source[g_srcpos]!=0x0A){
+		err=statement();
+		if (err) return err;
+		next_position();
+		if (g_source[g_srcpos]==':') {
+			g_srcpos++;
+			next_position();
+		}
+	}
+	if (g_source[g_srcpos]==0x0D && g_source[g_srcpos+1]==0x0A) g_srcpos++;
+	g_srcpos++;
+	return 0;
+}
\ No newline at end of file

--- /dev/null
+++ b/mips/protozoa/compiler.h
@@ -0,0 +1,523 @@
+/*
+   This file is provided under the LGPL license ver 2.1.
+   Written by Katsumi.
+   http://hp.vector.co.jp/authors/VA016157/
+   [e-mail]
+*/
+
+/*
+	This file is shared by Megalopa and Zoea
+*/
+
+// Include envilonment specific configurations
+#include "envspecific.h"
+
+/* Definitions */
+// Number of variables (including temporary ones)
+#define ALLOC_VAR_NUM 36
+// Block # dedicated for PCG
+#define ALLOC_PCG_BLOCK 36
+// Block # dedicated for GRAPHIC
+#define ALLOC_GRAPHIC_BLOCK 37
+// Block # dedicated for PLAYWAVE
+#define ALLOC_WAVE_BLOCK 38
+// Start # for long name variables
+#define ALLOC_LNV_BLOCK 39
+// Number of long name variables
+#define ALLOC_LNV_NUM 190
+// Start # of permanent blocks
+#define ALLOC_PERM_BLOCK 229
+// Number of blocks that can be assigned for memory allocation (including all above)
+#define ALLOC_BLOCK_NUM 329
+
+// Persistent RAM bytes used for object, heap and exception data
+#ifndef PERSISTENT_RAM_SIZE
+	// This must be defined in envspecific.h
+	#define PERSISTENT_RAM_SIZE (1024*53)
+#endif
+// Exception data area bytes
+#define EXCEPTION_DATA_SIZE (64)
+// RAM size used for object and heap
+#define RAMSIZE (PERSISTENT_RAM_SIZE-EXCEPTION_DATA_SIZE)
+
+/* Enums */
+enum variable{
+	VAR_INTEGER,
+	VAR_FLOAT,
+	VAR_STRING
+};
+
+#define OP_MASK 0x001F
+enum operator{
+	OP_VOID=0,
+	OP_OR  =1,
+	OP_AND =2,
+	OP_XOR =3,
+	OP_EQ  =4,
+	OP_NEQ =5,
+	OP_LT  =6,
+	OP_LTE =7,
+	OP_MT  =8,
+	OP_MTE =9,
+	OP_SHL =10,
+	OP_SHR =11,
+	OP_ADD =12,
+	OP_SUB =13,
+	OP_MUL =14,
+	OP_DIV =15,
+	OP_REM =16
+};
+
+#define LIB_MASK 0xFE00
+#define LIB_STEP 0x0200
+enum libs{
+	LIB_SOUND          =LIB_STEP*0,
+	LIB_MUSICFUNC      =LIB_STEP*1,
+	LIB_MUSIC          =LIB_STEP*2,
+	LIB_SETDRAWCOUNT   =LIB_STEP*3,
+	LIB_DRAWCOUNT      =LIB_STEP*4,
+	LIB_PALETTE        =LIB_STEP*5,
+	LIB_GPALETTE       =LIB_STEP*6,
+	LIB_BGCOLOR        =LIB_STEP*7,
+	LIB_CURSOR         =LIB_STEP*8,
+	LIB_CLS            =LIB_STEP*9,
+	LIB_GCLS           =LIB_STEP*10,
+	LIB_COLOR          =LIB_STEP*11,
+	LIB_GCOLOR         =LIB_STEP*12,
+	LIB_KEYS           =LIB_STEP*13,
+	LIB_RESTORE        =LIB_STEP*14,
+	LIB_RESTORE2       =LIB_STEP*15,
+	LIB_READ           =LIB_STEP*16,
+	LIB_MIDSTR         =LIB_STEP*17,
+	LIB_CLEAR          =LIB_STEP*18,
+	LIB_DIV0           =LIB_STEP*19,
+	LIB_LETSTR         =LIB_STEP*20,
+	LIB_STRNCMP        =LIB_STEP*21,
+	LIB_RND            =LIB_STEP*22,
+	LIB_DEC            =LIB_STEP*23,
+	LIB_HEX            =LIB_STEP*24,
+	LIB_CHR            =LIB_STEP*25,
+	LIB_CONNECT_STRING =LIB_STEP*26,
+	LIB_STRING         =LIB_STEP*27,
+	LIB_PRINTSTR       =LIB_STEP*28,
+	LIB_LABEL          =LIB_STEP*29,
+	LIB_DIM            =LIB_STEP*30,
+	LIB_VAL            =LIB_STEP*31,
+	LIB_INPUT          =LIB_STEP*32,
+	LIB_INKEY          =LIB_STEP*33,
+	LIB_USEPCG         =LIB_STEP*34,
+	LIB_PCG            =LIB_STEP*35,
+	LIB_SCROLL         =LIB_STEP*36,
+	LIB_WAIT           =LIB_STEP*37,
+	LIB_VAR_PUSH       =LIB_STEP*38,
+	LIB_VAR_POP        =LIB_STEP*39,
+	LIB_SYSTEM         =LIB_STEP*40,
+	LIB_SPRINTF        =LIB_STEP*41,
+	LIB_FLOAT          =LIB_STEP*42,
+	LIB_FLOATFUNCS     =LIB_STEP*43,
+	LIB_CREAD          =LIB_STEP*44,
+	LIB_USEGRAPHIC     =LIB_STEP*45,
+	LIB_GRAPHIC        =LIB_STEP*46,
+	LIB_WIDTH          =LIB_STEP*47,
+	LIB_FILE           =LIB_STEP*48,
+	LIB_PLAYWAVE       =LIB_STEP*49,
+	LIB_PLAYWAVEFUNC   =LIB_STEP*50,
+	LIB_SETDIR         =LIB_STEP*51,
+	LIB_SETDIRFUNC     =LIB_STEP*52,
+	LIB_GETDIR         =LIB_STEP*53,
+	LIB_DEBUG          =LIB_STEP*127,
+};
+
+// Note: OP_XXXX and FUNC_XXXX cannot be used simultaneously
+#define FUNC_MASK 0x003F
+#define FUNC_STEP 0x0001
+enum functions{
+	FUNC_FLOAT       =FUNC_STEP*0,
+	FUNC_INT         =FUNC_STEP*1,
+	FUNC_VALSHARP    =FUNC_STEP*2,
+	FUNC_SIN         =FUNC_STEP*3,
+	FUNC_COS         =FUNC_STEP*4,
+	FUNC_TAN         =FUNC_STEP*5,
+	FUNC_ASIN        =FUNC_STEP*6,
+	FUNC_ACOS        =FUNC_STEP*7,
+	FUNC_ATAN        =FUNC_STEP*8,
+	FUNC_ATAN2       =FUNC_STEP*9,
+	FUNC_SINH        =FUNC_STEP*10,
+	FUNC_COSH        =FUNC_STEP*11,
+	FUNC_TANH        =FUNC_STEP*12,
+	FUNC_EXP         =FUNC_STEP*13,
+	FUNC_LOG         =FUNC_STEP*14,
+	FUNC_LOG10       =FUNC_STEP*15,
+	FUNC_POW         =FUNC_STEP*16,
+	FUNC_SQRT        =FUNC_STEP*17,
+	FUNC_CEIL        =FUNC_STEP*18,
+	FUNC_FLOOR       =FUNC_STEP*19,
+	FUNC_FABS        =FUNC_STEP*20,
+	FUNC_MODF        =FUNC_STEP*21,
+	FUNC_FMOD        =FUNC_STEP*22,
+	FUNC_PSET        =FUNC_STEP*23,
+	FUNC_LINE        =FUNC_STEP*24,
+	FUNC_BOXFILL     =FUNC_STEP*25,
+	FUNC_CIRCLE      =FUNC_STEP*26,
+	FUNC_CIRCLEFILL  =FUNC_STEP*27,
+	FUNC_GPRINT      =FUNC_STEP*28,
+	FUNC_PUTBMP      =FUNC_STEP*29,
+	FUNC_PUTBMP2     =FUNC_STEP*30,
+	FUNC_GCOLOR      =FUNC_STEP*31,
+	FUNC_POINT       =FUNC_STEP*32,
+	FUNC_FOPEN       =FUNC_STEP*33,
+	FUNC_FOPENST     =FUNC_STEP*34,
+	FUNC_FILE        =FUNC_STEP*35,
+	FUNC_FCLOSE      =FUNC_STEP*36,
+	FUNC_FINPUT      =FUNC_STEP*37,
+	FUNC_FPRINTSTR   =FUNC_STEP*38,
+	FUNC_FGET        =FUNC_STEP*39,
+	FUNC_FPUT        =FUNC_STEP*40,
+	FUNC_FSEEK       =FUNC_STEP*41,
+	FUNC_FTELL       =FUNC_STEP*42,
+	FUNC_FLEN        =FUNC_STEP*43,
+	FUNC_FSTRING     =FUNC_STEP*44,
+	FUNC_FGETC       =FUNC_STEP*45,
+	FUNC_FPUTC       =FUNC_STEP*46,
+	FUNC_FREMOVE     =FUNC_STEP*47,
+	FUNC_FEOF        =FUNC_STEP*48,
+	FUNC_FINIT       =FUNC_STEP*49,
+	// MAX 63
+};
+
+/* Global vars (see globalvers.c) */
+extern int g_intconst;
+extern char g_valueisconst;
+extern unsigned int g_rnd_seed;
+extern unsigned int g_label;
+extern int g_sdepth;
+extern int g_maxsdepth;
+extern char g_allow_shift_obj;
+extern enum variable g_lastvar;
+extern char* g_source;
+extern int g_srcpos;
+extern int g_line;
+extern int g_fileline;
+extern int* g_object;
+extern int g_objpos;
+extern int* g_objmax;
+extern const char* g_err_str[];
+extern const unsigned char g_priority[];
+extern enum operator g_last_op;
+extern int g_end_addr;
+extern int g_gp;
+extern int g_s6;
+extern char RAM[RAMSIZE];
+extern unsigned int g_ex_data[EXCEPTION_DATA_SIZE/4];
+extern int g_var_mem[ALLOC_BLOCK_NUM];
+extern unsigned short g_var_pointer[ALLOC_BLOCK_NUM];
+extern unsigned short g_var_size[ALLOC_BLOCK_NUM];
+extern char g_temp_area_used;
+extern char g_nolinenum;
+extern int* g_heap_mem;
+extern int g_max_mem;
+extern char g_disable_break;
+extern unsigned char* g_pcg_font;
+extern char g_use_graphic;
+extern unsigned short* g_graphic_area;
+extern int* g_libparams;
+extern int g_long_name_var_num;
+extern char g_music_active;
+extern int g_class;
+extern int g_compiling_class;
+extern int g_temp;
+
+/* Prototypes */
+int get_gp(void);
+int get_fp(void);
+void start_program(void* addr, void* memory);
+void shift_obj(int* src, int* dst, int len);
+char* compile_line(void);
+int nextCodeIs(char* str);
+int endOfStatement();
+
+char* init_file(char* buff,char* appname);
+void close_file();
+void read_file(int blocklen);
+char* compile_file();
+int compile_and_link_file(char* buff,char* appname);
+int compile_and_link_main_file(char* buff,char* appname);
+int compile_and_link_class(char* buff,int class);
+
+void err_break(void);
+void err_music(char* str);
+void err_data_not_found(void);
+void err_str_complex(void);
+void err_label_not_found(void);
+void err_no_mem(void);
+void err_div_zero(void);
+void err_unkonwn(void);
+void err_unexp_next(void);
+void err_no_block(void);
+void err_invalid_param(void);
+void err_file(void);
+void err_wave(void);
+void err_not_obj(void);
+void err_not_field(int fieldname, int classname);
+void err_str(char* str);
+char* resolve_label(int s6);
+
+void musicint();
+void set_sound(unsigned long* data, int flagsLR);
+int musicRemaining(int flagsLR);
+int waveRemaining(int mode);
+void set_music(char* str, int flagsLR);
+void stop_music(void);
+void init_music(void);
+void play_wave(char* filename, int start);
+
+char* statement(void);
+char* gosub_statement();
+char* graphic_statement(enum functions func);
+char* fopen_statement_main(enum functions func);
+char* fget_statement();
+char* fput_statement();
+char* fputc_statement();
+char* fremove_statement();
+char* label_statement();
+
+char* function(void);
+char* str_function(void);
+char* float_function(void);
+
+void call_library(void);
+void reset_dataread();
+
+void free_temp_str(char* str);
+void free_non_temp_str(char* str);
+void free_perm_str(char* str);
+void* alloc_memory(int size, int var_num);
+void* calloc_memory(int size, int var_num);
+void move_to_perm_block(int var_num);
+void move_from_perm_block(int var_num);
+int move_from_perm_block_if_exists(int var_num);
+int get_permanent_var_num(void);
+int get_varnum_from_address(void* address);
+void* lib_calloc_memory(int size);
+void lib_delete(int* object);
+
+char* link(void);
+char* get_label(void);
+void* search_label(unsigned int label);
+
+char* get_string();
+char* simple_string(void);
+
+char* get_operator(void);
+char* get_floatOperator(void);
+char* calculation(enum operator op);
+char* calculation_float(enum operator op);
+int lib_float(int ia0,int iv0, enum operator a1);
+
+int lib_file(enum functions func, int a0, int a1, int v0);
+
+char* get_dim_value(int i);
+char* get_simple_value(void);
+char* get_value();
+char* get_floatOrValue();
+char* get_stringFloatOrValue();
+
+void blue_screen(void);
+
+char* get_float();
+
+void cmpdata_init();
+unsigned short cmpdata_get_id();
+char* cmpdata_insert(unsigned char type, short data16, int* data, unsigned char num);
+void cmpdata_reset();
+int* cmpdata_find(unsigned char type);
+int* cmpdata_findfirst(unsigned char type);
+void cmpdata_delete(int* record);
+
+int check_var_name();
+int get_var_number();
+int search_var_name(int nameint);
+char* register_var_name(int nameint);
+
+char* update_class_info(int class);
+char* construct_class_structure(int class);
+void delete_cmpdata_for_class(int class);
+
+extern const unsigned int g_initial_s5_stack[3];
+char* prepare_args_stack(char start_char);
+char* remove_args_stack(void);
+char* args_function_main(void);
+
+char* begin_compiling_class(int class);
+char* end_compiling_class(int class);
+char* new_function();
+char* field_statement();
+char* integer_obj_field();
+char* string_obj_field();
+char* float_obj_field();
+int lib_obj_field(int* object, int fieldname);
+int lib_pre_method(int* object, int methodname);
+int lib_post_method(int* object, int v0);
+int lib_save_vars_to_fields(int* object,int v0);
+int lib_load_vars_from_fields(int* object, int v0);
+
+char* method_statement();
+char* delete_statement();
+char* call_statement();
+void lib_let_str_field(char* str, char* prev_str);
+char* let_object_field();
+char* static_statement();
+char* static_method(char type);
+char* resolve_unresolved(int class);
+
+void init_timer();
+void stop_timer();
+char* usetimer_statement();
+char* timer_statement();
+char* timer_function();
+char* interrupt_statement();
+
+/* Error messages */
+#define ERR_SYNTAX (char*)(g_err_str[0])
+#define ERR_NE_BINARY (char*)(g_err_str[1])
+#define ERR_NE_MEMORY (char*)(g_err_str[2])
+#define ERR_DIV_0 (char*)(g_err_str[3])
+#define ERR_NY_I (char*)(g_err_str[4])
+#define ERR_LABEL_NF (char*)(g_err_str[5])
+#define ERR_LABEL_LONG (char*)(g_err_str[6])
+#define ERR_STR_COMPLEX (char*)(g_err_str[7])
+#define ERR_DATA_NF (char*)(g_err_str[8])
+#define ERR_UNKNOWN (char*)(g_err_str[9])
+#define ERR_MUSIC (char*)(g_err_str[10])
+#define ERR_MULTIPLE_LABEL (char*)(g_err_str[11])
+#define ERR_BREAK (char*)(g_err_str[12])
+#define ERR_UNEXP_NEXT (char*)(g_err_str[13])
+#define ERR_NO_BLOCK (char*)(g_err_str[14])
+#define ERR_GOSUB_ASH (char*)(g_err_str[15])
+#define ERR_INVALID_BREAK (char*)(g_err_str[16])
+#define ERR_INVALID_ELSEIF (char*)(g_err_str[17])
+#define ERR_INVALID_PARAM (char*)(g_err_str[18])
+#define ERR_FILE (char*)(g_err_str[19])
+#define ERR_INVALID_VAR_NAME (char*)(g_err_str[20])
+#define ERR_WAVE (char*)(g_err_str[21])
+#define ERR_COMPILE_CLASS (char*)(g_err_str[22])
+#define ERR_NO_CLASS (char*)(g_err_str[23])
+#define ERR_NOT_OBJ (char*)(g_err_str[24])
+#define ERR_NOT_FIELD (char*)(g_err_str[25])
+#define ERR_INVALID_NON_CLASS (char*)(g_err_str[26])
+#define ERR_INVALID_CLASS (char*)(g_err_str[27])
+#define ERR_NO_INIT (char*)(g_err_str[28])
+
+/* compile data type numbers */
+#define CMPDATA_RESERVED 0
+#define CMPDATA_USEVAR   1
+#define CMPDATA_CLASS    2
+#define CMPDATA_FIELD    3
+#define CMPDATA_STATIC   4
+#define CMPDATA_UNSOLVED 5
+#define CMPDATA_TEMP     6
+// Sub types follow
+#define CMPTYPE_PUBLIC_FIELD 0
+#define CMPTYPE_PRIVATE_FIELD 1
+#define CMPTYPE_PUBLIC_METHOD 2
+#define CMPTYPE_NEW_FUNCTION 0
+#define CMPTYPE_STATIC_METHOD 1
+
+
+/* Stack position for values in args.c */
+#define ARGS_SP_SP       4
+#define ARGS_SP_V0_OBJ   8
+#define ARGS_SP_PREV_S5  12
+#define ARGS_SP_NUM_ARGS 16
+#define ARGS_S5_SP       (-12 & 0xFFFF)
+#define ARGS_S5_V0_OBJ   (-8  & 0xFFFF)
+#define ARGS_S5_PREV_S5  (-4  & 0xFFFF)
+#define ARGS_S5_NUM_ARGS (0   & 0xFFFF)
+
+/*
+	Hidden varname 31 bit values
+	Note that max number of 31 bit value is 0x61504BFF (for ZZZZZZ)
+*/
+#define HIDDEN_VAR_THIS_OBJECT 0x7FFF0000
+
+/* Macros */
+
+// Lables as 31 bit integer
+#define LABEL_INIT 0x0007df55
+
+// Skip blanc(s) in source code
+#define next_position() while(g_source[g_srcpos]==' ') {g_srcpos++;}
+
+// Check if object area is not full.
+#define check_obj_space(x) if (g_objmax<g_object+g_objpos+(x)) return ERR_NE_BINARY
+
+// Returns priority of operator
+#define priority(x) (int)g_priority[(int)(x)]
+
+// Insert code for calling library
+//02E0F809   jalr        ra,s7
+//24070000   addiu       a3,zero,0000
+#define call_lib_code(x) \
+	check_obj_space(2);\
+	g_object[g_objpos++]=0x02E0F809;\
+	g_object[g_objpos++]=0x24070000|((x)&0x0000FFFF)
+
+// Insert code for calling quick library
+//3C081234   lui         t0,0x1234
+//35085678   ori         t0,t0,0x5678
+//0100F809   jalr        ra,t0
+//00000000   nop         
+#define call_quicklib_code(x,y) do {\
+		check_obj_space(4);\
+		g_object[g_objpos++]=0x3C080000|(((unsigned int)(x))>>16);\
+		g_object[g_objpos++]=0x35080000|(((unsigned int)(x))&0x0000FFFF);\
+		g_object[g_objpos++]=0x0100F809;\
+		g_object[g_objpos++]=(y);\
+	} while (0)	
+
+#define ASM_NOP 0x00000000
+#define ASM_ADDU_A0_V0_ZERO 0x00402021
+#define ASM_ADDU_A1_V0_ZERO 0x00402821
+#define ASM_ADDU_A2_V0_ZERO 0x00403021
+#define ASM_ADDU_A3_V0_ZERO 0x00403821
+#define ASM_ORI_A0_ZERO_ 0x34040000
+#define ASM_LW_A0_XXXX_S8 0x8FC40000
+#define ASM_LW_A0_XXXX_S5 0x8EA40000
+
+// Interrupt macros
+// 32 different type interruptions are possible
+// See also envspecific.h for additional interruptions
+#define INTERRUPT_TIMER     0
+#define INTERRUPT_DRAWCOUNT 1
+#define INTERRUPT_KEYS      2
+#define INTERRUPT_INKEY     3
+#define INTERRUPT_MUSIC     4
+#define INTERRUPT_WAVE      5
+
+extern int g_interrupt_flags;
+extern int g_int_vector[];
+#define raise_interrupt_flag(x) do {\
+	if (g_int_vector[x]) {\
+		IFS0bits.CS1IF=1;\
+		g_interrupt_flags|=(1<<(x));\
+	}\
+} while(0)
+
+// Division macro for unsigned long
+// Valid for 31 bits for all cases and 32 bits for some cases
+#define div32(x,y,z) ((((unsigned long long)((unsigned long)(x)))*((unsigned long long)((unsigned long)(y))))>>(z))
+
+// Divide by 9 (valid for 32 bits)
+#define div9_32(x) div32(x,0xe38e38e4,35)
+#define rem9_32(x) ((x)-9*div9_32(x))
+
+// Divide by 10 (valid for 32 bits)
+#define div10_32(x) div32(x,0xcccccccd,35)
+#define rem10_32(x) ((x)-10*div10_32(x))
+
+// Divide by 36 (valid for 32 bits)
+#define div36_32(x) div32(x,0xe38e38e4,37)
+#define rem36_32(x) (x-36*div36_32(x))
+
+// Check if within RAM
+#define withinRAM(x) ((&RAM[0])<=((char*)(x)) && ((char*)(x))<(&RAM[RAMSIZE]))

--- /dev/null
+++ b/mips/protozoa/debug.c
@@ -0,0 +1,302 @@
+/*
+   This file is provided under the LGPL license ver 2.1.
+   Written by K.Tanaka & Katsumi
+   http://www.ze.em-net.ne.jp/~kenken/index.html
+   http://hp.vector.co.jp/authors/VA016157/
+*/
+
+#ifdef __DEBUG
+
+#include <xc.h>
+#include "api.h"
+#include "main.h"
+#include "compiler.h"
+
+/*
+	Enable following line when debugging binary object.
+*/
+//#include "debugdump.h"
+
+
+// Pseudo reading config setting for debug mode
+unsigned int g_DEVCFG1=0xFF7F4DDB;
+
+// Construct jump assembly in boot area.
+const unsigned int _debug_boot[] __attribute__((address(0xBFC00000))) ={
+	0x0B401C00,//   j           0x9d007000
+	0x00000000,//   nop         
+};
+
+// Use DEBUG.HEX as file name of this program.
+const unsigned char _debug_filename[] __attribute__((address(FILENAME_FLASH_ADDRESS))) ="DEBUG.HEX";
+
+static const char initext[];
+static const char bastext[];
+static const char class1text[];
+static const char class2text[];
+
+static char* readtext;
+static int filepos;
+
+/*
+	Debug dump
+	In debugdump.h:
+		__DEBUGDUMP is defined.
+		__DEBUGDUMP_FREEAREA is defined as start address of free area (1st argument of set_free_area() function)
+		const unsigned char dump[] is initialized.
+*/
+#ifdef __DEBUGDUMP
+int debugDump(){
+	int i;
+	for(i=0;i<sizeof dump;i++){
+		RAM[i]=dump[i];
+	}
+
+	g_objpos=(__DEBUGDUMP_FREEAREA-(unsigned int)g_object)/4;
+
+	// Initialize parameters
+	g_pcg_font=0;
+	g_use_graphic=0;
+	g_graphic_area=0;
+	clearscreen();
+	setcursor(0,0,7);	
+
+	printstr("BASIC "BASVER"\n");
+	wait60thsec(15);
+
+	printstr("Compiling...");
+
+	// Initialize the other parameters
+	// Random seed
+	g_rnd_seed=0x92D68CA2; //2463534242
+	// Clear variables
+	for(i=0;i<ALLOC_BLOCK_NUM;i++){
+		g_var_mem[i]=0;
+		g_var_size[i]=0;
+	}
+	// Clear key input buffer
+	for(i=0;i<256;i++){
+		ps2keystatus[i]=0;
+	}
+	// Reset data/read.
+	reset_dataread();
+
+	// Assign memory
+	set_free_area((void*)(g_object+g_objpos),(void*)(&RAM[RAMSIZE]));
+	// Execute program
+	// Start program from the beginning of RAM.
+	// Work area (used for A-Z values) is next to the object code area.
+	start_program((void*)(&(RAM[0])),(void*)(&g_var_mem[0]));
+	printstr("\nOK\n");
+	g_use_graphic=0;
+
+	return 1;
+}
+#else
+int debugDump(){
+	return 0;
+}
+#endif
+
+/*
+    Override libsdfsio functions.
+    Here, don't use SD card, but the vertual files 
+    (initext[] and bastext[]) are used. 
+*/
+
+FSFILE fsfile;
+
+size_t FSfread(void *ptr, size_t size, size_t n, FSFILE *stream){
+	char b;
+	size_t ret=0;
+	if (!readtext) return 0;
+	while(b=readtext[filepos]){
+		filepos++;
+		((char*)ptr)[ret]=b;
+		ret++;
+		if (n<=ret) break;
+	}
+	return ret;
+}
+FSFILE* FSfopen(const char * fileName, const char *mode){
+	int i;
+	for(i=0;i<13;i++){
+		if (fileName[i]=='.') break;
+	}
+	if (i==13) {
+		// Unknown file name
+		// Force BAS file
+		readtext=(char*)&bastext[0];
+	} else if (fileName[i+1]=='I' && fileName[i+2]=='N' && fileName[i+3]=='I') {
+		// INI file
+		readtext=(char*)&initext[0];
+	} else if (fileName[i+1]=='B' && fileName[i+2]=='A' && fileName[i+3]=='S') {
+		// Select BAS file
+		if (fileName[i-6]=='C' && fileName[i-5]=='L' && fileName[i-4]=='A' &&
+			fileName[i-3]=='S' && fileName[i-2]=='S') {
+			if (fileName[i-1]=='1') readtext=(char*)&class1text[0];
+			else if (fileName[i-1]=='2') readtext=(char*)&class2text[0];
+			else readtext=(char*)&bastext[0];
+		} else {
+			readtext=(char*)&bastext[0];
+		}
+		// Try debugDump.
+		if (debugDump()) return 0;
+	} else {
+		readtext=0;
+		return 0;
+	}
+	filepos=0;
+	return &fsfile;
+}
+int FSfeof( FSFILE * stream ){
+	return readtext[filepos]?1:0;
+}
+int FSfclose(FSFILE *fo){
+	return 0;
+}
+int FSInit(void){
+	return 1;
+}
+int FSremove (const char * fileName){
+	return 0;
+}
+size_t FSfwrite(const void *ptr, size_t size, size_t n, FSFILE *stream){
+	return 0;
+}
+
+int FindFirst (const char * fileName, unsigned int attr, SearchRec * rec){
+	return 0;
+}
+int FindNext (SearchRec * rec){
+	return 0;
+}
+int FSmkdir (char * path){
+	return 0;
+}
+char * FSgetcwd (char * path, int numchars){
+	return 0;
+}
+int FSchdir (char * path){
+	return 0;
+}
+long FSftell (FSFILE * fo){
+	return 0;
+}
+int FSfseek(FSFILE *stream, long offset, int whence){
+	return 0;
+}
+/*
+    ps2init() is not called.
+    Instead, not_ps2init_but_init_Timer1() is called.
+    Timer1 is used to update drawcount and drawing gloval variables.
+*/
+
+int not_ps2init_but_init_Timer1(){
+	PR1=0x0FFF;
+	TMR1=0;
+	IFS0bits.T1IF=0;
+	T1CON=0x8000;
+	// Timer1 interrupt: priority 4
+	IPC1bits.T1IP=4;
+	IPC1bits.T1IS=0;
+	IEC0bits.T1IE=1;
+
+	return 0;
+}
+
+#pragma interrupt timer1Int IPL4SOFT vector 4
+
+void timer1Int(){
+	IFS0bits.T1IF=0;
+	if (drawing) {
+		drawing=0;
+		drawcount++;
+	} else {
+		drawing=1;
+	}
+}
+
+/*
+    initext[] and bastext[] are vertual files 
+    as "MACHIKAN.INI" and "DEBUG.BAS".
+*/
+
+
+static const char initext[]=
+"#PRINT\n"
+"#PRINT\n";
+
+static const char bastext[]=
+"I=1:WHILE I<=10\n"
+"I=I+1:WEND\n"
+"\n"
+"I=1:DO\n"
+"I=I+1:LOOP UNTIL I=11\n"
+"\n"
+"FOR I=1 TO 10\n"
+"NEXT\n"
+"\n"
+"\n"
+"\n";
+
+static const char class1text[]=
+"STATIC T1\n"
+"useclass CLASS2\n"
+"method T3\n"
+" return CLASS2::T2\n"
+"method T5\n"
+" return T1\n"
+"\n"
+"\n";
+
+static const char class2text[]=
+"STATIC T2\n"
+"useclass CLASS1\n"
+"method T4\n"
+" return CLASS1::T1\n"
+"method T6\n"
+" return T2\n"
+"\n"
+"\n"
+"\n"
+"\n";
+
+/*
+    Test function for constructing assemblies from C codes.
+*/
+
+static const void* debugjumptable[]={
+	FSfread,
+	FSfopen,
+};
+
+#define for2(x,y,z) for(x=y;x<=z;x++)
+
+int _debug_test(int a0, int a1, int a2, int a3, int param4, int param5){
+	asm volatile(".set noreorder");
+	asm volatile("addiu $v0,$zero,4772");
+	asm volatile("loop:");
+	asm volatile("bne $v0,$zero,loop");
+	asm volatile("addi $v0,$v0,-1");
+	asm volatile("wait");
+	asm volatile("nop");
+	asm volatile("nop");
+	asm volatile("nop");
+	asm volatile("nop");
+	asm volatile("nop");
+	asm volatile("nop");
+	asm volatile("nop");
+	asm volatile("nop");
+	a2&=0xFFFFFFFC;
+	return a2+a3;
+}
+
+/*
+	Break point used for debugging object code.
+
+g_object[g_objpos++]=0x0000000d;// break 0x0
+
+*/
+
+#endif // __DEBUG

--- /dev/null
+++ b/mips/protozoa/debug.h
@@ -0,0 +1,34 @@
+/*
+   This file is provided under the LGPL license ver 2.1.
+   Written by K.Tanaka & Katsumi
+   http://www.ze.em-net.ne.jp/~kenken/index.html
+   http://hp.vector.co.jp/authors/VA016157/
+*/
+
+/*
+	This file is shared by Megalopa and Zoea
+*/
+
+#ifdef __DEBUG
+
+// Pseudo reading config setting for debug mode
+extern unsigned int g_DEVCFG1;
+#define DEVCFG1 g_DEVCFG1
+
+// Do not use PS/2 keyboard
+#define ps2init() not_ps2init_but_init_Timer1()
+int not_ps2init_but_init_Timer1();
+
+// Do not use asm("wait") but use asm("nop")
+#undef WAIT
+#define WAIT "nop"
+
+#endif // __DEBUG
+
+// key waiting macro
+
+#define debug_wait() lineinput((char*)&g_temp,3)
+#define debug_wait_char(x) do {\
+		printchar(x); \
+		lineinput((char*)&g_temp,3);\
+	} while(0)	

--- /dev/null
+++ b/mips/protozoa/editor.c
@@ -0,0 +1,20 @@
+/*
+   This file is provided under the LGPL license ver 2.1.
+   Written by K.Tanaka & Katsumi
+   http://www.ze.em-net.ne.jp/~kenken/index.html
+   http://hp.vector.co.jp/authors/VA016157/
+*/
+
+#include <xc.h>
+#include "api.h"
+#include "editor.h"
+#include "compiler.h"
+#include "main.h"
+
+unsigned char currentfile[13],tempfile[13]; //編集中のファイル名、一時ファイル名
+
+void wait60thsec(unsigned short n){
+	// 60分のn秒ウェイト（ビデオ画面の最下行信号出力終了まで待つ）
+	n+=drawcount;
+	while(drawcount!=n) asm(WAIT);
+}

--- /dev/null
+++ b/mips/protozoa/editor.h
@@ -0,0 +1,41 @@
+/*
+   This file is provided under the LGPL license ver 2.1.
+   Written by K.Tanaka
+   http://www.ze.em-net.ne.jp/~kenken/index.html
+*/
+
+#define TBUFMAXLINE 201 //テキストバッファ数
+
+#define TBUFSIZE 200 //テキストバッファ1つのサイズ
+#define TBUFMAXSIZE (TBUFSIZE*(TBUFMAXLINE-1)) //最大バッファ容量（バッファ1行分空ける）
+//#define EDITWIDTHX 30 //エディタ画面横幅
+#define EDITWIDTHY 29 //エディタ画面縦幅
+//#define EDITWIDTHY 39 //エディタ画面縦幅
+#define COLOR_NORMALTEXT 7 //通常テキスト色
+#define COLOR_ERRORTEXT 4 //エラーメッセージテキスト色
+#define COLOR_AREASELECTTEXT 4 //範囲選択テキスト色
+#define COLOR_BOTTOMLINE 5 //画面最下行の色
+#define COLOR_DIR 6 //ディレクトリ名表示の色
+#define FILEBUFSIZE 256 //ファイルアクセス用バッファサイズ
+#define MAXFILENUM 200 //利用可能ファイル最大数
+#define PATHNAMEMAX 128 //ワーキングディレクトリパス名の最大値
+#define UNDOBUFSIZE 2048 //アンドゥ用バッファサイズ
+
+#define ERR_FILETOOBIG -1
+#define ERR_CANTFILEOPEN -2
+#define ERR_CANTWRITEFILE -3
+
+#define TEMPFILENAME "~TEMP.BAS" //実行時ソース保存ファイル名
+#define WORKDIRFILE "~WORKDIR.TMP" //実行時パス保存ファイル名
+
+#define UNDO_INSERT 1
+#define UNDO_OVERWRITE 2
+#define UNDO_DELETE 3
+#define UNDO_BACKSPACE 4
+#define UNDO_CONTINS 5
+#define UNDO_CONTDEL 6
+
+void texteditor(void); //テキストエディタ本体
+int runbasic(char *s,int test); //コンパイルして実行
+extern unsigned char tempfile[13];
+void wait60thsec(unsigned short n);

--- /dev/null
+++ b/mips/protozoa/envspecific.c
@@ -0,0 +1,268 @@
+/*
+   This file is provided under the LGPL license ver 2.1.
+   Written by Katsumi.
+   http://hp.vector.co.jp/authors/VA016157/
+   [e-mail]
+*/
+
+#include <xc.h>
+#include "main.h"
+#include "compiler.h"
+#include "api.h"
+
+/* 
+	dymmy imprementations:
+	ps2keystatus
+	ps2init
+*/
+volatile unsigned char ps2keystatus[256];
+void g_set_palette(unsigned char n,unsigned char b,unsigned char r,unsigned char g){
+	set_palette(n,b,r,g);
+}
+void ps2init(void){}
+
+
+void pre_run(){
+	// Currently, do nothing.
+}
+
+void post_run(){
+	// Cool down
+}
+
+
+int readbuttons(){
+	int keys;
+	LCD_CS_HI;
+	asm("nop");
+	KEY_EN;
+	asm("nop");
+	TRISBSET=KEYMASK;
+	asm("nop");
+	keys=KEYPORT;
+#if LCD_ALIGNMENT == VERTICAL
+	keys=
+		((keys&KEYUP)?    0:1)|
+		((keys&KEYDOWN)?  0:2)|
+		((keys&KEYLEFT)?  0:4)|
+		((keys&KEYRIGHT)? 0:8)|
+		((keys&KEYSTART)? 0:16)|
+		((keys&KEYFIRE)?  0:32);
+#else
+	keys=
+		((keys&KEYRIGHT)? 0:1)|
+		((keys&KEYLEFT)?  0:2)|
+		((keys&KEYUP)?    0:4)|
+		((keys&KEYDOWN)?  0:8)|
+		((keys&KEYSTART)? 0:16)|
+		((keys&KEYFIRE)?  0:32);
+#endif
+	KEY_DS;
+	asm("nop");
+	TRISBCLR=KEYMASK;
+	asm("nop");
+	LCD_CS_LO;
+	return keys;	
+}
+
+void scroll30(int x,int y){
+	int i,j;
+	int vector=y*WIDTH_X1+x;
+	if (vector<0) {
+		// Copy data from upper address to lower address
+		for(i=0-vector;i<WIDTH_X1*WIDTH_Y;i++){
+			TVRAM[i+vector]=TVRAM[i];
+			TVRAM[WIDTH_X1*WIDTH_Y+i+vector]=TVRAM[WIDTH_X1*WIDTH_Y+i];
+		}
+	} else if (0<vector) {
+		// Copy data from lower address to upper address
+		for(i=WIDTH_X1*WIDTH_Y-vector-1;0<=i;i--){
+			TVRAM[i+vector]=TVRAM[i];
+			TVRAM[WIDTH_X1*WIDTH_Y+i+vector]=TVRAM[WIDTH_X1*WIDTH_Y+i];
+		}
+	} else {
+		return;
+	}
+	if (x<0) {
+		// Fill blanc at right
+		for(i=x;i<0;i++){
+			for(j=WIDTH_X1+i;j<WIDTH_X1*WIDTH_Y;j+=WIDTH_X1){
+				TVRAM[j]=0x00;
+				TVRAM[WIDTH_X1*WIDTH_Y+j]=cursorcolor;
+			}
+		}
+	} else if (0<x) {
+		// Fill blanc at left
+		for(i=0;i<x;i++){
+			for(j=i;j<WIDTH_X1*WIDTH_Y;j+=WIDTH_X1){
+				TVRAM[j]=0x00;
+				TVRAM[WIDTH_X1*WIDTH_Y+j]=cursorcolor;
+			}
+		}
+	}
+	if (y<0) {
+		// Fill blanc at bottom
+		for(i=WIDTH_X1*(WIDTH_Y+y);i<WIDTH_X1*WIDTH_Y;i++){
+				TVRAM[i]=0x00;
+				TVRAM[WIDTH_X1*WIDTH_Y+i]=cursorcolor;
+		}
+	} else if (0<y) {
+		// Fill blanc at top
+		for(i=0;i<WIDTH_X1*y;i++){
+				TVRAM[i]=0x00;
+				TVRAM[WIDTH_X1*WIDTH_Y+i]=cursorcolor;
+		}
+	}
+}
+
+void scroll40(int x,int y){
+	int i,j;
+	int vector=y*WIDTH_X2+x;
+	if (vector<0) {
+		// Copy data from upper address to lower address
+		for(i=0-vector;i<WIDTH_X2*WIDTH_Y;i++){
+			TVRAM[i+vector]=TVRAM[i];
+			TVRAM[WIDTH_X2*WIDTH_Y+i+vector]=TVRAM[WIDTH_X2*WIDTH_Y+i];
+		}
+	} else if (0<vector) {
+		// Copy data from lower address to upper address
+		for(i=WIDTH_X2*WIDTH_Y-vector-1;0<=i;i--){
+			TVRAM[i+vector]=TVRAM[i];
+			TVRAM[WIDTH_X2*WIDTH_Y+i+vector]=TVRAM[WIDTH_X2*WIDTH_Y+i];
+		}
+	} else {
+		return;
+	}
+	if (x<0) {
+		// Fill blanc at right
+		for(i=x;i<0;i++){
+			for(j=WIDTH_X2+i;j<WIDTH_X2*WIDTH_Y;j+=WIDTH_X2){
+				TVRAM[j]=0x00;
+				TVRAM[WIDTH_X2*WIDTH_Y+j]=cursorcolor;
+			}
+		}
+	} else if (0<x) {
+		// Fill blanc at left
+		for(i=0;i<x;i++){
+			for(j=i;j<WIDTH_X2*WIDTH_Y;j+=WIDTH_X2){
+				TVRAM[j]=0x00;
+				TVRAM[WIDTH_X2*WIDTH_Y+j]=cursorcolor;
+			}
+		}
+	}
+	if (y<0) {
+		// Fill blanc at bottom
+		for(i=WIDTH_X2*(WIDTH_Y+y);i<WIDTH_X2*WIDTH_Y;i++){
+				TVRAM[i]=0x00;
+				TVRAM[WIDTH_X2*WIDTH_Y+i]=cursorcolor;
+		}
+	} else if (0<y) {
+		// Fill blanc at top
+		for(i=0;i<WIDTH_X2*y;i++){
+				TVRAM[i]=0x00;
+				TVRAM[WIDTH_X2*WIDTH_Y+i]=cursorcolor;
+		}
+	}
+}
+
+void scroll(int x, int y){
+	if (twidth==40) scroll40(x,y);
+	else scroll30(x,y);
+}
+
+void allocate_graphic_area(){
+	if (!g_graphic_area) {
+		// Use this pointer like unsigned short GVRAM[G_H_WORD*G_Y_RES] __attribute__ ((aligned (4)));
+//		g_graphic_area=(unsigned short*)alloc_memory(G_H_WORD*G_Y_RES/2,ALLOC_GRAPHIC_BLOCK);
+		g_graphic_area=(void *)1;
+		// Start graphic and clear screen
+//		init_graphic(g_graphic_area);
+		init_graphic();
+		// Move current point to (0,0)
+//		g_prev_x=g_prev_y=0;
+	}
+}
+
+void usegraphic(int mode){
+	// Modes; 0: stop GRAPHIC, 1: use GRAPHIC, 2: reset GRAPHIC and use it
+	switch(mode){
+		case 0:
+			if (g_use_graphic){
+				// Stop GRAPHIC if used
+				set_graphmode(0);
+				g_use_graphic=0;
+				// Set timer4 for tempo
+//				PR4=59473;       // 3632*262/16-1
+			} else {
+				// Prepare GRAPHIC area if not used and not allcated.
+				allocate_graphic_area();
+			}
+			break;
+		case 2:
+			// Reset GRAPHIC and use it
+			g_graphic_area=0;
+			// Continue to case 1:
+		case 1:
+		case 3:
+		default:
+			// Use GRAPHIC
+			allocate_graphic_area();
+			// Start showing GRAPHIC with mode 1, but not with mode 3
+			if (mode !=3 && !g_use_graphic){
+				set_graphmode(1);
+				g_use_graphic=1;
+				// Set timer4 for tempo
+//				PR4=55756;       // ~=3405*262/16-1(55755.875)
+			}
+			break;
+	}
+}
+
+void videowidth(int width){
+	// Do nothing
+}
+
+int lib_system(int a0, int a1 ,int v0, int a3, int g_gcolor, int g_prev_x, int g_prev_y){
+	switch(a0){
+		// Version info
+		case 0: return (int)SYSVER1;
+		case 1: return (int)SYSVER2;
+		case 2: return (int)BASVER;
+		case 3: return (int)FILENAME_FLASH_ADDRESS;
+		// Display info
+		case 20: return twidth;
+		case 21: return WIDTH_Y;
+		case 22: return G_X_RES;
+		case 23: return G_Y_RES;
+		case 24: return cursorcolor;
+		case 25: return g_gcolor;
+		case 26: return ((int)(cursor-TVRAM))%twidth;
+		case 27: return ((int)(cursor-TVRAM))/twidth;
+		case 28: return g_prev_x;
+		case 29: return g_prev_y;
+		// Keyboard info
+		case 40: return 0;//(int)inPS2MODE();
+		case 41: return 0;//(int)vkey;
+		case 42: return 0;//(int)lockkey;
+		case 43: return 0;//(int)keytype;
+		// Pointers to gloval variables
+		case 100: return (int)&g_var_mem[0];
+		case 101: return (int)&g_rnd_seed;
+		case 102: return (int)&TVRAM[0];
+		case 103: return (int)&FontData[0];
+		case 104: return (int)g_var_mem[ALLOC_PCG_BLOCK];
+		case 105: return (int)g_var_mem[ALLOC_GRAPHIC_BLOCK];
+		// Change system settings
+		case 200:
+			// ON/OFF monitor
+			if (v0) {
+//				start_composite();
+			} else {
+//				stop_composite();
+			}
+			break;
+		default:
+			break;
+	}
+	return 0;
+}

--- /dev/null
+++ b/mips/protozoa/envspecific.h
@@ -0,0 +1,37 @@
+/*
+   This file is provided under the LGPL license ver 2.1.
+   Written by Katsumi.
+   http://hp.vector.co.jp/authors/VA016157/
+   [e-mail]
+*/
+
+#define CPU_CLOCK_HZ 48000000
+#define PERSISTENT_RAM_SIZE (1024*53)
+
+int readbuttons();
+void scroll(int x, int y);
+void usegraphic(int mode);
+void videowidth(int width);
+int lib_system(int a0, int a1 ,int v0, int a3, int g_gcolor, int g_prev_x, int g_prev_y);
+
+// 30 or 40 characters per line for Zoea
+#define printcomma() printstr("          "+rem10_32((unsigned int)(cursor-TVRAM)))
+
+// Check break key or buttons when executing BASIC code.
+// In PS/2 mode, detect ctrl-break.
+// In button mode, detect pushing four buttons are pushed simultaneously.
+#define check_break() \
+	if (g_disable_break==0) {\
+		if (inPS2MODE()) {\
+			if (ps2keystatus[0x03]) err_break();\
+		} else {\
+			if ((PORTB&0x4c80)==0) err_break();\
+		}\
+	}
+
+// Protozoa specific lists of statements and functions (none defined for Zoea)
+#define ADDITIONAL_STATEMENTS
+#define ADDITIONAL_INT_FUNCTIONS
+#define ADDITIONAL_STR_FUNCTIONS
+#define ADDITIONAL_RESERVED_VAR_NAMES
+#define ADDITIONAL_INTERRUPT_FUNCTIONS

--- /dev/null
+++ b/mips/protozoa/error.c
@@ -0,0 +1,198 @@
+/*
+   This file is provided under the LGPL license ver 2.1.
+   Written by Katsumi.
+   http://hp.vector.co.jp/authors/VA016157/
+   [e-mail]
+*/
+
+/*
+	This file is shared by Megalopa and Zoea
+*/
+
+#include "compiler.h"
+
+const char* g_err_str[]={
+	"Syntax error",
+	"Not enough binary space",
+	"Not enough memory",
+	"Divided by zero",
+	"Not yet implemented",
+	"Label or line number not found: ",
+	"Label too long or too short",
+	"String too complexed",
+	"Data not found",
+	"Unknown error:",
+	"Music syntax error:'",
+	" found more than twice",
+	"Break",
+	"Unexpected NEXT or RETURN statement",
+	"Cannot assign temporary block",
+	"GOSUB fuction cannot be used after string-handling",
+	"Invalid BREAK statement in line ",
+	"Invalid ELSE/IF statement in line ",
+	"Invalid parameter(s)",
+	"File error",
+	"Invalid variable name",
+	"WAVE format error",
+	"ERR_COMPILE_CLASS",
+	"Class not found",
+	"Not an object",
+	" is not public field/method",
+	"Valid only in class file",
+	"Invalid in class file",
+	"INIT method does not exist",
+};
+
+char* resolve_label(int s6){
+	static char str[7];
+	int i,j;
+	if (s6<65536) {
+		// Line number
+		for(i=0;i<5;i++){
+			str[5-i]='0'+rem10_32(s6);
+			s6=div10_32(s6);
+		}
+		str[6]=0x00;
+		for(j=1;j<5;j++){
+			if (str[j]!='0') break;
+		}
+		return (char*)(str+j);
+	} else {
+		// Label
+		s6-=65536;
+		str[6]=0x00;
+		for(i=5;0<=i;i--){
+			if (s6<36) {
+				// First character must be A-Z, corresponding to 1-26 but not 10-35.
+				// See get_label() for the detail.
+				str[i]=s6-1+'A';
+				break;
+			} else {
+				// From second, 0-9 corresponds to 0-9 and A-Z corresponds to 10-35.
+				str[i]="0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ"[rem36_32(s6)];
+				s6=div36_32(s6);
+			}
+		}
+		return (char*)(str+i);
+	}
+}
+
+void pre_end_addr(int s6){
+	int i,j;
+	char str[7];
+	// Cool down the system
+	stop_music();
+	// Resolve line and show it
+	if (s6<0) s6=s6&0x7fffffff;
+	g_label=s6;
+	if (s6<65536) {
+		// Line number
+		printstr("\nIn line ");
+	} else {
+		// Label
+		printstr("\nAfter label ");
+	}
+	printstr(resolve_label(s6));
+	asm volatile("la $v0,%0"::"i"(&g_end_addr));
+	asm volatile("lw $v0,0($v0)");
+	asm volatile("nop");
+	asm volatile("jr $v0");
+}
+
+#define end_exec() \
+	asm volatile("addu $a0,$s6,$zero");\
+	asm volatile("j pre_end_addr")
+
+void err_break(void){
+	stop_music();
+	printstr(ERR_BREAK);
+	end_exec();
+}
+
+void err_data_not_found(void){
+	printstr(ERR_DATA_NF);
+	end_exec();
+}
+
+void err_label_not_found(void){
+	printstr(ERR_LABEL_NF);
+	printstr(resolve_label(g_label));
+	printstr("\n");
+	end_exec();
+}
+
+void err_div_zero(void){
+	printstr(ERR_DIV_0);
+	end_exec();
+}
+
+void err_no_mem(void){
+	printstr(ERR_NE_MEMORY);
+	end_exec();
+}
+
+void err_str_complex(void){
+	printstr(ERR_STR_COMPLEX);
+	end_exec();
+}
+
+void err_unknown(void){
+	asm volatile("la $v0,%0"::"i"(&g_temp));
+	asm volatile("sw $ra,0($v0)");
+	printstr(ERR_UNKNOWN);
+	printhex32(g_temp);
+	end_exec();
+}
+
+void err_music(char* str){
+	printstr(ERR_MUSIC);
+	printstr(str);
+	printstr("'\n");
+	// Restore s6 from g_s6
+	asm volatile("la $s6,%0"::"i"(&g_s6));
+	asm volatile("lw $s6,0($s6)");
+	end_exec();
+}
+
+void err_unexp_next(void){
+	printstr(ERR_UNEXP_NEXT);
+	end_exec();	
+}
+
+void err_no_block(void){
+	printstr(ERR_NO_BLOCK);
+	end_exec();	
+}
+
+void err_invalid_param(void){
+	printstr(ERR_INVALID_PARAM);
+	end_exec();	
+}
+
+void err_file(void){
+	printstr(ERR_FILE);
+	end_exec();	
+}
+
+void err_wave(void){
+	printstr(ERR_WAVE);
+	end_exec();	
+}
+
+void err_not_obj(void){
+	printstr(ERR_NOT_OBJ);
+	end_exec();	
+}
+
+void err_not_field(int fieldname, int classname){
+	printstr(resolve_label(classname));
+	printchar('.');
+	printstr(resolve_label(fieldname & 0x7FFFFFFF));
+	printstr(ERR_NOT_FIELD);
+	end_exec();	
+}
+
+void err_str(char* str){
+	printstr(str);
+	end_exec();	
+}
\ No newline at end of file

--- /dev/null
+++ b/mips/protozoa/exception.c
@@ -0,0 +1,170 @@
+/*
+   This file is provided under the LGPL license ver 2.1.
+   Written by K.Tanaka & Katsumi
+   http://www.ze.em-net.ne.jp/~kenken/index.html
+   http://hp.vector.co.jp/authors/VA016157/
+*/
+
+/*
+	This file is shared by Megalopa and Zoea
+*/
+
+#include <xc.h>
+#include "api.h"
+#include "main.h"
+#include "compiler.h"
+
+/*
+	Enable following line if memory dump is needed when exception occurs.
+*/
+
+//#define DUMPFILE "~~MEMORY.DMP"
+
+#ifdef DUMPFILE
+void dumpMemory(){
+	unsigned int i;
+	FSFILE *fp;
+	printstr("\n"DUMPFILE" ");
+	if(FSInit()==FALSE){
+		printstr("cannot be created.\n");
+		return;
+	}
+	fp=FSfopen(DUMPFILE,"w");
+	if(fp==NULL) {
+		printstr("not saved.\n");
+		return;
+	}
+	for(i=0;i<PERSISTENT_RAM_SIZE;i+=512){
+		if (FSfwrite(&RAM[i],1,512,fp)<512) break;
+	}
+	FSfclose(fp);	
+	printstr("saved.\n");
+}
+#else
+void dumpMemory(){}
+#endif //ifdef DUMPFILE
+
+void _general_exception_handler_main (void);
+void _general_exception_handler (void){
+	asm volatile("la $sp,%0"::"i"(&RAM[RAMSIZE-4]));
+	asm volatile("j _general_exception_handler_main");
+}
+void _general_exception_handler_main (void){
+	int i;
+	// $v1 is g_ex_data
+	asm volatile("la $v1,%0"::"i"(&g_ex_data[0]));
+	// Prepare proper stack area before SoftReset
+	asm volatile("addiu $sp,$v1,0xfff0");
+	// g_ex_data[2]=$s6
+	asm volatile("sw $s6,8($v1)");
+	// g_ex_data[3]=Cause
+	asm volatile("mfc0 $v0,$13");
+	asm volatile("sw $v0,12($v1)");
+	// g_ex_data[4]=EPC 
+	asm volatile("mfc0 $v0,$14");
+	asm volatile("sw $v0,16($v1)");
+	// Exception occured
+	g_ex_data[0]=1;
+	// g_s6
+	g_ex_data[1]=g_s6;
+	// Clear 2 MLB bits of EPC
+	g_ex_data[4]&=0xfffffffc;
+	// If EPC is within RAM, store data in exception area.
+	if ((int)(&RAM[0])<=g_ex_data[4] && g_ex_data[4] <(int)(&RAM[RAMSIZE])) {
+		// g_ex_data[5] - g_ex_data[12]: assembly
+		for(i=-3;i<=3;i++){
+			g_ex_data[i+8]=((int*)g_ex_data[4])[i];
+		}
+	}
+	// Wait until all buttons are released and reset MachiKania.
+	#ifdef __DEBUG
+		asm volatile("j 0xBFC00000");
+	#else
+		for(i=0;i<100000;i++){
+			if((readbuttons()&(KEYUP|KEYDOWN|KEYLEFT|KEYRIGHT|KEYSTART|KEYFIRE))
+				!=(KEYUP|KEYDOWN|KEYLEFT|KEYRIGHT|KEYSTART|KEYFIRE)) i=0;
+		}
+		RCONbits.POR=0;
+		RCONbits.EXTR=0;
+		asm volatile("j 0x9FC00000");
+	#endif
+}
+
+void blue_screen(void){
+	int i,j,s6,s6g;
+	unsigned int* opos;
+	if (RCONbits.POR || RCONbits.EXTR) {
+		// After power on or reset. Reset flags and return.
+		RCONbits.POR=0;
+		RCONbits.EXTR=0;
+		for(i=0;i<RAMSIZE;i++){
+			// Reset all RAM area including g_ex_data[]
+			RAM[i]=0;
+		}
+		return;
+	} else if (g_ex_data[0]==0) {
+		// No exception found.
+		return;
+	}
+	// Exception occured before SoftReset().
+	// Prepare data
+	s6=g_ex_data[2];
+	s6g=g_ex_data[1];
+	s6=s6&0x7fffffff;
+	s6g=s6g&0x7fffffff;
+	opos=(int*)g_ex_data[4];
+	//set_bgcolor(255,0,0);
+	printstr("STOP");
+	printstr("\nException at ");
+	printhex32(g_ex_data[4]);
+	printstr("\n      Cause: ");
+	printhex32(g_ex_data[3]);
+	printstr("\n ");
+	switch((g_ex_data[3]>>2)&0x1f){
+		case 0:  printstr("(Interrupt)"); break;
+		case 1:  printstr("(TLB modification)"); break;
+		case 2:  printstr("(TLB load/fetch)"); break;
+		case 3:  printstr("(TLB store)"); break;
+		case 4:  printstr("(Address load/fetch error )"); break;
+		case 5:  printstr("(Address store error)"); break;
+		case 6:  printstr("(Bus fetch error)"); break;
+		case 7:  printstr("(Bus load/store error)"); break;
+		case 8:  printstr("(Syscall)"); break;
+		case 9:  printstr("(Breakpoint)"); break;
+		case 10: printstr("(Reserved instruction)"); break;
+		case 11: printstr("(Coprocessor Unusable)"); break;
+		case 12: printstr("(Integer Overflow)"); break;
+		case 13: printstr("(Trap)"); break;
+		case 23: printstr("(Reference to Watch address)"); break;
+		case 24: printstr("(Machine check)"); break;
+		default: printstr("(Unknown)"); break;
+	}
+	printstr("\n         s6: ");
+	printstr(resolve_label(s6));
+	printstr("\n       g_s6: ");
+	printstr(resolve_label(s6g));
+	printstr("\n");
+	printstr("Reset MachiKania to contine.\n\n");
+	// Show code where the exception happened.
+	for(i=-3;i<=3;i++){
+		printstr("\n ");
+		printhex32((unsigned int)&opos[i]);
+		printstr("  ");
+		if ((unsigned int)&RAM[0]<=(unsigned int)&opos[i] && (unsigned int)&opos[i]<(unsigned int)&RAM[RAMSIZE]) {
+			// Exception in RAM[RAMSIZE] area
+			printhex32(g_ex_data[i+8]);		
+		} else if (   0xA0000000<=(unsigned int)&opos[i] && (unsigned int)&opos[i]<0xA0000000+PIC32MX_RAMSIZE
+			|| 0x9D000000<=(unsigned int)&opos[i] && (unsigned int)&opos[i]<=0x9D000000+PIC32MX_FLASHSIZE) {
+			// Exception in outside RAM[RAMSIZE] or flash area
+			printhex32(opos[i]);
+		} else {
+			printstr("********");
+		}
+	}
+	printstr("\n");
+
+#ifndef __DEBUG
+	dumpMemory();
+#endif
+	while(1) asm("wait");
+}

--- /dev/null
+++ b/mips/protozoa/file.c
@@ -0,0 +1,275 @@
+/*
+   This file is provided under the LGPL license ver 2.1.
+   Written by K.Tanaka & Katsumi
+   http://www.ze.em-net.ne.jp/~kenken/index.html
+   http://hp.vector.co.jp/authors/VA016157/
+*/
+
+/*
+	This file is shared by Megalopa and Zoea
+*/
+
+#include <xc.h>
+#include "api.h"
+#include "compiler.h"
+
+static FSFILE* g_fhandle;
+static char* g_fbuff;
+static int g_size;
+
+char* init_file(char* buff,char* appname){
+	// Open file
+	g_fhandle=FSfopen(appname,"r");
+	if (!g_fhandle) {
+		return ERR_UNKNOWN;
+	}
+	// Initialize parameters
+	g_fbuff=buff;
+	g_line=0;
+	g_fileline=0;
+	g_source=buff;
+	g_srcpos=0;
+	return 0;
+}
+
+void close_file(){
+	FSfclose(g_fhandle);
+}
+
+void read_file(int blocklen){
+	int i;
+	static char in_string, escape;
+	// blocklen is either 512 or 256.
+	if (blocklen==512) {
+		// This is first read. Initialize parameter(s).
+		in_string=0;
+		escape=0;
+	} else if (g_size<512) {
+		// Already reached the end of file.
+		return;
+	} else {
+		// Shift buffer and source position 256 bytes.
+		for(i=0;i<256;i++) g_fbuff[i]=g_fbuff[i+256];
+		g_srcpos-=256;
+	}
+	// Read 512 or 256 bytes from SD card.
+	g_size=512-blocklen+FSfread((void*)&g_fbuff[512-blocklen],1,blocklen,g_fhandle);
+	// Some modifications of text for easy compiling.
+	for(i=512-blocklen;i<512;i++){
+		if (in_string) {
+			if (g_fbuff[i]=='\\' && !escape) {
+				escape=1;
+			} else {
+				escape=0;
+				if (g_fbuff[i]=='"') in_string=0;
+			}
+		} else {
+			// If not in string, all upper cases.
+			if (g_fbuff[i]=='"') in_string=1;
+			else if ('a'<=g_fbuff[i] && g_fbuff[i]<='z') g_fbuff[i]+='A'-'a';
+			// If not in string, tabs will be spaces.
+			else if ('\t'==g_fbuff[i]) g_fbuff[i]=' ';
+		}
+		if (g_fbuff[i]==0x0a || g_fbuff[i]==0x0d) in_string=escape=0;
+	}
+	return;
+}
+
+char* compile_file(){
+	int i;
+	char* err;
+	// Read first 512 bytes
+	read_file(512);
+	// Compile line by line
+	while (g_size==512) {
+		err=compile_line();
+		if (err) return err;
+		// Maintain at least 256 characters in cache.
+		if (256<=g_srcpos) read_file(256);
+	}
+	// Return code at the end
+	g_source[g_size]=0x0d;
+	// Compile last few lines.
+	while(g_srcpos<g_size-1){
+		err=compile_line();
+		if (err) return err;
+	}
+	// Add "DATA 0" and "END" statements.
+	if (g_compiling_class) {
+		g_source="END\n";
+	} else {
+		g_source="DATA 0:END\n";
+	}
+	g_srcpos=0;
+	err=compile_line();
+	if (err) return err;
+	g_srcpos=-1;
+	// No error occured
+	return 0;
+}
+
+int compile_and_link_file(char* buff,char* appname){
+	int i,j;
+	char* err;
+
+	while(1){
+		// Initialize SD card file system
+		err=init_file(buff,appname);
+		if (err) {
+			//setcursorcolor(COLOR_ERRORTEXT);
+			printstr("Can't Open ");
+			printstr(appname);
+			printchar('\n');
+			return -1;
+		}
+
+		// Option initialization(s)
+		g_nolinenum=0;
+
+		// Compile the file
+		err=compile_file();
+		close_file();
+
+		// If compiling a class file is required, do it.
+		if (err==ERR_COMPILE_CLASS) {
+			j=g_compiling_class;
+			i=compile_and_link_class(buff, g_class);
+			g_compiling_class=j;
+			if (i) return i;
+			// Continue compiling current file from the beginning.
+			continue;
+		}
+		break;
+	}
+
+	if (err) {
+		// Compile error
+		printstr(err);
+		printstr("\nAround: '");
+		for(i=0;i<5;i++){
+			printchar(g_source[g_srcpos-2+i]);
+		}
+		printstr("' in line ");
+		printdec(g_line);
+		printstr("\n");
+		for(i=g_srcpos;0x20<=g_source[i];i++);
+		g_source[i]=0x00;
+		for(i=g_srcpos;0x20<=g_source[i];i--);
+		printstr(g_source+i);
+		return g_fileline;
+	}
+
+	// Link
+	err=link();
+	if (err) {
+		// Link error
+		printstr(err);
+		printstr(resolve_label(g_label));
+		return -2;
+	}
+	
+	// All done
+	return 0;
+}
+
+int compile_and_link_class(char* buff,int class){
+	int i,j;
+	char* err;
+	char* classname;
+	char classfile[13];
+	char classdir[11];
+	int data[2];
+	unsigned short cwd_id;
+	int* record;
+	while(1){
+		// Begin compiling class
+		err=begin_compiling_class(class);
+		if (err) break;
+		// Determine class file name
+		classname=resolve_label(class);
+		for(i=0;classfile[i]=classname[i];i++);
+		classfile[i++]='.';
+		classfile[i++]='B';
+		classfile[i++]='A';
+		classfile[i++]='S';
+		classfile[i]=0;
+		// Check if file exists in current directory
+		err=init_file(buff,&classfile[0]);
+		if (!err) {
+			// Class file found in current directory
+			close_file();
+			// Compile it
+			i=compile_and_link_file(buff,&classfile[0]);
+			if (i) break;
+		} else {
+			// Class file not found in current directory.
+			// Try library directory, for example, \LIB\CLASS1\CLASS1.BAS
+			// Store current directory, first
+			if (!FSgetcwd(buff,256)) break;
+			for(i=0;buff[i];i++);
+			cwd_id=cmpdata_get_id();
+			if (!cwd_id) break;
+			err=cmpdata_insert(CMPDATA_TEMP,cwd_id,(int*)(&buff[0]),(i+1+3)>>2);
+			if (err) break;
+			// Change current directory to class library directory
+			for(i=0;classdir[i]="\\LIB\\"[i];i++);
+			for(j=0;classdir[i++]=classname[j];j++);
+			classdir[i]=0;
+			FSchdir(classdir);
+			// Compile class file
+			i=compile_and_link_file(buff,&classfile[0]);
+			// Restore current dirctory
+			cmpdata_reset();
+			while(record=cmpdata_find(CMPDATA_TEMP)){
+				if (cwd_id=(record[0]&0xffff)) break;
+			}
+			if (!record) break;
+			FSchdir((char*)(&record[1]));
+			cmpdata_delete(record);
+			if (i) break;
+		}
+		// End compiling class
+		err=end_compiling_class(class);
+		if (err) break;
+		// Initial assembly is a jump statement to jump to the end of class file
+		// Note that there is at least a code (set line # to $s6) before reaching here
+		g_object[0]=0x08000000 | ((((int)(&g_object[g_objpos]))&0x0FFFFFFF)>>2); // j xxxxxxxx
+		// In the next link, current region of object is ignored.
+		g_object+=g_objpos;
+		g_objpos=0;
+		// All done
+		return 0;
+	}
+	// Error occured
+	printstr("/nError in class: ");
+	printstr((char*)&classfile[0]);
+	printchar('\n');
+	if (err) printstr(err);
+	return -2;
+}
+
+int compile_and_link_main_file(char* buff,char* appname){
+	int i;
+	g_compiling_class=0;
+	i=compile_and_link_file(buff,appname);
+	if (i) return i;
+	return 0;
+	/*
+		After compiling class code, g_object is set to the beginning of next code.
+		Therefore, after the all, g_object is set toe the beginnig of main code,
+		and class code(s) is/are excluded. This will affect following features when running:
+			READ/DATA/RESTORE function/statements
+		The linker also works withing the g_object dimension. Therefore, the label only works withing the file,
+		but not in the other file. This feature allows using the same label name in different files without
+		causing error/misjumping
+
+		After compiling class code, following cmpdata are destroyed (see delete_cmpdata_for_class() function):
+			CMPDATA_FIELD  : object field and method information
+			CMPDATA_USEVAR : long var name information
+		but following cmpdata remains:
+			CMPDATA_CLASS  : class name and address of class structure
+		This feature allows compiler to use class information (name and structure) for "NEW" function,
+		to use the same long var name in different files (note that g_long_name_var_num is not reseted after
+		compiling each class code).
+	*/
+}
\ No newline at end of file

--- /dev/null
+++ b/mips/protozoa/float.c
@@ -0,0 +1,171 @@
+/*
+   This file is provided under the LGPL license ver 2.1.
+   Written by Katsumi.
+   http://hp.vector.co.jp/authors/VA016157/
+   [e-mail]
+*/
+
+/*
+	This file is shared by Megalopa and Zoea
+*/
+
+#include "./compiler.h"
+#include "stdlib.h"
+
+char* get_float_sub(int pr);
+
+char* get_simple_float(void){
+	int i;
+	float f;
+	char* err;
+	char b1,b2,b3;
+	next_position();
+	b1=g_source[g_srcpos];
+	if (b1=='(') {
+		// (...)
+		// Parenthesis
+		g_srcpos++;
+		next_position();
+		err=get_float_sub(priority(OP_VOID));
+		if (err) return err;
+		next_position();
+		if (g_source[g_srcpos]!=')') return ERR_SYNTAX;
+		g_srcpos++;
+	} else if (b1=='-') {
+		// Unary '-' operator
+		// Note that unary operators ( + and - ) have higher priority than the other operators
+		g_srcpos++;
+		err=get_simple_float();
+		if (err) return err;
+		check_obj_space(1);
+		g_object[g_objpos++]=0x34040000;                     // ori a0,zero,0
+		call_lib_code(LIB_FLOAT | OP_SUB);
+	} else {
+		// Main routine of getting float value here
+		if (b1=='+') g_srcpos++; // Ignore unary '+' operator
+		next_position();
+		b1=g_source[g_srcpos];
+		b2=g_source[g_srcpos+1];
+		b3=g_source[g_srcpos+2];
+		if ('0'<=b1 && b1<='9') {
+			f=strtof((const char*)&g_source[g_srcpos],&err);
+			if (&g_source[g_srcpos]==err) return ERR_SYNTAX;
+			g_srcpos=err-g_source;
+			i=((int*)(&f))[0];
+			if (i&0xFFFF0000) {
+				// 32 bit
+				check_obj_space(2);
+				g_object[g_objpos++]=0x3C020000|((i>>16)&0x0000FFFF); // lui   v0,xxxx
+				g_object[g_objpos++]=0x34420000|(i&0x0000FFFF);       // ori v0,v0,xxxx
+			} else {
+				// 16 bit
+				check_obj_space(1);
+				g_object[g_objpos++]=0x34020000|(i&0x0000FFFF); // ori v0,zero,xxxx
+			}
+		} else {
+			i=get_var_number();
+			if (i<0) {
+				// Must be a function.
+				return float_function();
+			}
+			if (g_source[g_srcpos]=='.') {
+				// This is an object field or method to return string
+				check_obj_space(1);
+				g_object[g_objpos++]=0x8FC20000|(i*4); // lw v0,xx(s8)
+				g_srcpos++;
+				return float_obj_field();
+			} else if (g_source[g_srcpos]=='(') {
+				// An array element contains pointer to an object.
+				g_srcpos++;
+				err=get_dim_value(i);
+				if (err) return err;
+				if (g_source[g_srcpos]!='.') return ERR_SYNTAX;
+				g_srcpos++;
+				return float_obj_field();
+			}
+			if (g_source[g_srcpos]!='#') return ERR_SYNTAX;
+			g_srcpos++;
+			if (g_source[g_srcpos]=='(') {
+				// Dimension
+				g_srcpos++;
+				return get_dim_value(i);
+			}
+			// Simple value
+			check_obj_space(1);
+			g_object[g_objpos++]=0x8FC20000|(i*4); // lw v0,xx(s8)
+		}
+	}
+	// No error 
+	return 0;
+}
+
+char* get_float_sub(int pr){
+	char* err;
+	enum operator op;
+	char b1,b2,b3;
+	int prevpos;
+	// Get a value in $v0.
+	err=get_simple_float();
+	if (err) return err;
+	while(1){
+		// Get the operator in op. If not valid operator, simply return without error.
+		prevpos=g_srcpos;
+		err=get_floatOperator();
+		if (err) return 0;
+		op=g_last_op;
+		// Compair current and previous operators.
+		// If the previous operator has higher priolity, return.
+		if (pr>=priority(op)) {
+			g_srcpos=prevpos;
+			return 0;
+		}
+		// Store $v0 in stack
+		g_sdepth+=4;
+		if (g_maxsdepth<g_sdepth) g_maxsdepth=g_sdepth;
+		check_obj_space(1);
+		g_object[g_objpos++]=0xAFA20000|g_sdepth; // sw v0,xx(sp)
+		// Get next value.
+		err=get_float_sub(priority(op));
+		if (err) return err;
+		// Get value from stack to $a0.
+		check_obj_space(1);
+		g_object[g_objpos++]=0x8FA40000|g_sdepth; // lw a0,xx(sp)
+		g_sdepth-=4;
+		// Calculation. Result will be in $v0.
+		err=calculation_float(op);
+		if (err) return err;
+	}
+}
+
+char* get_float(){
+	// Note that this can be called recursively.
+	// Value may contain function with a parameter of another value.
+	char* err;
+	int prevpos;
+	if (g_sdepth==0) {
+		// Initialize stack handler
+		g_maxsdepth=0;
+		prevpos=g_objpos;
+		// Stack decrement command will be filled later
+		check_obj_space(1);
+		g_object[g_objpos++]=0x00000000; // nop (will be replaced by "addiu sp,sp,-xx")
+	}
+	err=get_float_sub(priority(OP_VOID));
+	if (err) return err;
+	if (g_sdepth==0) {
+		if (g_maxsdepth==0) {
+			// Stack was not used.
+			if (g_allow_shift_obj) {
+				shift_obj(&g_object[prevpos+1],&g_object[prevpos],g_objpos-prevpos-1);
+				g_objpos--;
+			}
+		} else {
+			// Stack was used.
+			check_obj_space(1);
+			g_object[prevpos]=0x27BD0000 | (0-g_maxsdepth) & 0x0000FFFF; // addiu sp,sp,-xx
+			g_object[g_objpos++]=0x27BD0000 | g_maxsdepth & 0x0000FFFF;  // addiu sp,sp,xx
+		}
+	}
+	g_lastvar=VAR_FLOAT;
+	return 0;
+}
\ No newline at end of file

--- /dev/null
+++ b/mips/protozoa/function.c
@@ -0,0 +1,625 @@
+/*
+   This file is provided under the LGPL license ver 2.1.
+   Written by Katsumi.
+   http://hp.vector.co.jp/authors/VA016157/
+   [e-mail]
+*/
+
+/*
+	This file is shared by Megalopa and Zoea
+*/
+
+#include "compiler.h"
+#include "api.h"
+
+char* music_function(){
+	char* err;
+	next_position();
+	if (g_source[g_srcpos]==')') {
+		check_obj_space(1);
+		g_object[g_objpos++]=0x34020003; //ori         v0,zero,0x03
+	} else {
+		err=get_value();
+		if (err) return err;
+	}
+	call_lib_code(LIB_MUSICFUNC);
+	return 0;
+}
+
+char* read_function(){
+	// This function is not valid in class file.
+	if (g_compiling_class) return ERR_INVALID_CLASS;
+	call_lib_code(LIB_READ);
+	return 0;
+}
+
+char* cread_function(){
+	call_lib_code(LIB_CREAD);
+	return 0;
+}
+
+char* gosub_function(){
+	// Check if garbage collection has been done.
+	// This check is required because the used temporary area would be changed 
+	// in sub routine. 
+	if (g_temp_area_used) return ERR_GOSUB_ASH;
+	return gosub_statement();
+}
+char* strncmp_function(){
+	char* err;
+	err=get_string();
+	if (err) return err;
+	check_obj_space(2);
+	g_object[g_objpos++]=0x27BDFFF8; // addiu       sp,sp,-8
+	g_object[g_objpos++]=0xAFA20004; // sw          v0,4(sp)
+	if (g_source[g_srcpos]!=',') return ERR_SYNTAX;
+	g_srcpos++;
+	err=get_string();
+	if (err) return err;
+	check_obj_space(1);
+	g_object[g_objpos++]=0xAFA20008; // sw          v0,8(sp)
+	if (g_source[g_srcpos]!=',') return ERR_SYNTAX;
+	g_srcpos++;
+	err=get_value();
+	if (err) return err;
+	call_lib_code(LIB_STRNCMP);
+	check_obj_space(1);
+	g_object[g_objpos++]=0x27BD0008; // addiu       sp,sp,8
+	return 0;
+}
+char* len_function(){
+	char* err;
+	err=get_string();
+	if (err) return err;
+	check_obj_space(5);
+	g_object[g_objpos++]=0x2443FFFF; // addiu       v1,v0,-1
+	                                 // loop:
+	g_object[g_objpos++]=0x80640001; // lb          a0,1(v1)
+	g_object[g_objpos++]=0x1480FFFE; // bne         a0,zero,loop
+	g_object[g_objpos++]=0x24630001; // addiu       v1,v1,1
+	g_object[g_objpos++]=0x00621023; // subu        v0,v1,v0
+	return 0;
+}
+
+char* asc_function(){
+	char* err;
+	err=get_string();
+	if (err) return err;
+	check_obj_space(1);
+	g_object[g_objpos++]=0x90420000; // lbu         v0,0(v0)
+	return 0;
+}
+
+char* val_function(){
+	char* err;
+	err=get_string();
+	if (err) return err;
+	call_lib_code(LIB_VAL);
+	return 0;	
+}
+
+char* peek_function_sub(int bits){
+	char* err;
+	err=get_value();
+	if (err) return err;
+	check_obj_space(1);
+	switch(bits){
+		case 32:
+			g_object[g_objpos++]=0x8C420000; // lw          v0,0(v0)
+			break;
+		case 16:
+			g_object[g_objpos++]=0x94420000; // lhu         v0,0(v0)
+			break;
+		case 8:
+		default:
+			g_object[g_objpos++]=0x90420000; // lbu         v0,0(v0)
+			break;
+	}
+	return 0;
+}
+
+char* sgn_function(){
+	char* err;
+	err=get_value();
+	if (err) return err;
+	check_obj_space(5);
+	g_object[g_objpos++]=0x10400004; // beq         v0,zero,end
+	g_object[g_objpos++]=0x24030001; // addiu       v1,zero,1
+	g_object[g_objpos++]=0x1C400002; // bgtz        v0,end
+	g_object[g_objpos++]=0x00601021; // addu        v0,v1,zero
+	g_object[g_objpos++]=0x00031023; // subu        v0,zero,v1
+	                                 // end:
+	return 0;
+}
+
+char* abs_function(){
+	char* err;
+	err=get_value();
+	if (err) return err;
+	check_obj_space(3);
+	g_object[g_objpos++]=0x00021FC3; //sra         v1,v0,0x1f
+	g_object[g_objpos++]=0x00621026; //xor         v0,v1,v0
+	g_object[g_objpos++]=0x00431023; //subu        v0,v0,v1
+	return 0;
+}
+
+char* not_function(){
+	char* err;
+	err=get_value();
+	if (err) return err;
+	check_obj_space(1);
+	g_object[g_objpos++]=0x2C420001; //sltiu       v0,v0,1
+	return 0;
+}
+
+char* rnd_function(){
+	call_lib_code(LIB_RND);
+	return 0;
+}
+
+char* chr_function(void){
+	char* err;
+	err=get_value();
+	if (err) return err;
+	call_lib_code(LIB_CHR);
+	return 0;
+}
+char* hex_function(void){
+	char* err;
+	err=get_value();
+	if (err) return err;
+	if (g_source[g_srcpos]==',') {
+		// Second argument found.
+		// Get is as $a0.
+		g_srcpos++;
+		check_obj_space(2);
+		g_object[g_objpos++]=0x27BDFFFC; //addiu       sp,sp,-4
+		g_object[g_objpos++]=0xAFA20004; //sw          v0,4(sp)
+		err=get_value();
+		if (err) return err;
+		check_obj_space(3);
+		g_object[g_objpos++]=0x00022021; //a0,zero,v0
+		g_object[g_objpos++]=0x8FA20004; //lw          v0,4(sp)
+		g_object[g_objpos++]=0x27BD0004; //addiu       sp,sp,4
+	} else {
+		// Second argument not found.
+		// Set $a0 to 0.
+		check_obj_space(1);
+		g_object[g_objpos++]=0x24040000; //addiu       a0,zero,0
+	}
+	call_lib_code(LIB_HEX);
+	return 0;
+}
+
+char* dec_function(void){
+	char* err;
+	err=get_value();
+	if (err) return err;
+	call_lib_code(LIB_DEC);
+	return 0;
+}
+
+char* keys_function(void){
+	char* err;
+	next_position();
+	if (g_source[g_srcpos]==')') {
+		check_obj_space(1);
+		g_object[g_objpos++]=0x3402003F; //ori         v0,zero,0x3f
+	} else {
+		err=get_value();
+		if (err) return err;
+	}	
+	call_lib_code(LIB_KEYS);
+	return 0;
+}
+
+char* tvram_function(void){
+	char* err;
+	int i;
+	next_position();
+	if (g_source[g_srcpos]==')') {
+		i=(int)(&TVRAM[0]);
+		i-=g_gp;
+		check_obj_space(1);
+		g_object[g_objpos++]=0x27820000|(i&0x0000FFFF);       // addiu       v0,gp,xxxx
+	} else {
+		err=get_value();
+		if (err) return err;
+		i=(int)(&TVRAM[0]);
+		i-=g_gp;
+		check_obj_space(3);
+		g_object[g_objpos++]=0x27830000|(i&0x0000FFFF);       // addiu       v1,gp,xxxx
+		g_object[g_objpos++]=0x00621821;                      // addu        v1,v1,v0
+		g_object[g_objpos++]=0x90620000;                      // lbu         v0,0(v1)
+	}	
+	return 0;
+}
+
+char* drawcount_function(void){
+	call_lib_code(LIB_DRAWCOUNT);
+	return 0;
+}
+
+char* input_function(void){
+	call_lib_code(LIB_INPUT);
+	return 0;
+}
+
+char* inkey_function(void){
+	char* err;
+	next_position();
+	if (g_source[g_srcpos]==')') {
+		check_obj_space(1);
+		g_object[g_objpos++]=0x34020000; //ori         v0,zero,0x00
+	} else {
+		err=get_value();
+		if (err) return err;
+	}	
+	call_lib_code(LIB_INKEY);
+	return 0;
+}
+
+char* args_function(void){
+	return args_function_main();
+}
+
+char* system_function(void){
+	char* err;
+	err=get_value();
+	if (err) return err;
+	g_object[g_objpos++]=0x00402021; //   addu        a0,v0,zero
+	call_lib_code(LIB_SYSTEM);
+	return 0;
+}
+
+char* sprintf_function(void){
+	char* err;
+	err=get_string();
+	if (err) return err;
+	next_position();
+	if (g_source[g_srcpos]!=',') return ERR_SYNTAX;
+	g_srcpos++;
+	check_obj_space(2);
+	g_object[g_objpos++]=0x27BDFFFC; //addiu       sp,sp,-4
+	g_object[g_objpos++]=0xAFA20004; //sw          v0,4(sp)
+	err=get_float();
+	if (err) return err;
+	check_obj_space(3);
+	g_object[g_objpos++]=0x00022021; //addu        a0,zero,v0
+	g_object[g_objpos++]=0x8FA20004; //lw          v0,4(sp)
+	g_object[g_objpos++]=0x27BD0004; //addiu       sp,sp,4
+	call_lib_code(LIB_SPRINTF);
+	return 0;
+}
+
+char* floatstr_function(void){
+	char* err;
+	err=get_float();
+	if (err) return err;
+	check_obj_space(2);
+	g_object[g_objpos++]=0x00022021; //addu        a0,zero,v0
+	g_object[g_objpos++]=0x34020000; //ori         v0,zero,0x0000
+	call_lib_code(LIB_SPRINTF);
+	return 0;
+}
+
+char* floatsharp_function(void){
+	char* err;
+	err=get_value();
+	if (err) return err;
+	call_lib_code(LIB_FLOATFUNCS | FUNC_FLOAT);
+	return 0;
+}
+
+char* valsharp_function(void){
+	char* err;
+	err=get_string();
+	if (err) return err;
+	call_lib_code(LIB_FLOATFUNCS | FUNC_VALSHARP);
+	return 0;
+}
+
+char* int_function(void){
+	char* err;
+	err=get_float();
+	if (err) return err;
+	call_lib_code(LIB_FLOATFUNCS | FUNC_INT);
+	return 0;
+}
+
+char* fseek_function(){
+	call_lib_code(LIB_FILE | FUNC_FTELL);
+	return 0;
+}
+
+char* flen_function(){
+	call_lib_code(LIB_FILE | FUNC_FLEN);
+	return 0;
+}
+
+char* fgetc_function(){
+	call_lib_code(LIB_FILE | FUNC_FGETC);
+	return 0;
+}
+
+char* finput_function(){
+	char* err;
+	next_position();
+	if (g_source[g_srcpos]!=')') {
+		err=get_value();
+		if (err) return err;
+	} else {
+		// Parameter will be zero if not defined
+		check_obj_space(1);
+		g_object[g_objpos++]=0x34020000; // ori v0,zero,0
+	}
+	call_lib_code(LIB_FILE | FUNC_FINPUT);
+	return 0;
+}
+
+char* feof_function(){
+	call_lib_code(LIB_FILE | FUNC_FEOF);
+	return 0;
+}
+
+char* playwave_function(){
+	char* err;
+	next_position();
+	if (g_source[g_srcpos]!=')') {
+		// Get param
+		err=get_value();
+		if (err) return err;
+	} else {
+		// If parameter is omitted, use 0.
+		check_obj_space(1);
+		g_object[g_objpos++]=0x24020000;      // addiu       v0,zero,0
+	}
+	call_lib_code(LIB_PLAYWAVEFUNC);
+	return 0;
+}
+
+char* setdir_function(){
+	char* err;
+	err=get_string();
+	if (err) return err;
+	call_lib_code(LIB_SETDIRFUNC);
+	return 0;
+}
+
+char* getdir_function(){
+	call_lib_code(LIB_GETDIR);
+	return 0;
+}
+
+char* float_constant(float val){
+	volatile int i;
+	((float*)(&i))[0]=val;
+	if (i&0xFFFF0000) {
+		// 32 bit
+		check_obj_space(2);
+		g_object[g_objpos++]=0x3C020000|((i>>16)&0x0000FFFF); // lui   v0,xxxx
+		g_object[g_objpos++]=0x34420000|(i&0x0000FFFF);       // ori v0,v0,xxxx
+	} else {
+		// 16 bit
+		check_obj_space(1);
+		g_object[g_objpos++]=0x34020000|(i&0x0000FFFF); // ori v0,zero,xxxx
+	}
+	return 0;	
+}
+
+char* float_1param_function(enum functions func){
+	char* err;
+	err=get_float();
+	if (err) return err;
+	call_lib_code(LIB_FLOATFUNCS | func);
+	return 0;
+}
+
+char* float_2param_function(enum functions func){
+	char* err;
+	err=get_float();
+	if (err) return err;
+	next_position();
+	if (g_source[g_srcpos]!=',') return ERR_SYNTAX;
+	g_srcpos++;
+	check_obj_space(2);
+	g_object[g_objpos++]=0x27BDFFFC; //addiu       sp,sp,-4
+	g_object[g_objpos++]=0xAFA20004; //sw          v0,4(sp)
+	err=get_float();
+	if (err) return err;
+	check_obj_space(3);
+	g_object[g_objpos++]=0x00022021; //addu        a0,zero,v0
+	g_object[g_objpos++]=0x8FA20004; //lw          v0,4(sp)
+	g_object[g_objpos++]=0x27BD0004; //addiu       sp,sp,4
+	call_lib_code(LIB_FLOATFUNCS | func);
+	return 0;
+}
+
+char* float_function(void){
+	char* err;
+	if (nextCodeIs("FLOAT#(")) {
+		err=floatsharp_function();
+	} else if (nextCodeIs("VAL#(")) {
+		err=valsharp_function();
+	} else if (nextCodeIs("SIN#(")) {
+		err=float_1param_function(FUNC_SIN);
+	} else if (nextCodeIs("COS#(")) {
+		err=float_1param_function(FUNC_COS);
+	} else if (nextCodeIs("TAN#(")) {
+		err=float_1param_function(FUNC_TAN);
+	} else if (nextCodeIs("ASIN#(")) {
+		err=float_1param_function(FUNC_ASIN);
+	} else if (nextCodeIs("ACOS#(")) {
+		err=float_1param_function(FUNC_ACOS);
+	} else if (nextCodeIs("ATAN#(")) {
+		err=float_1param_function(FUNC_ATAN);
+	} else if (nextCodeIs("ATAN2#(")) {
+		err=float_2param_function(FUNC_ATAN2);
+	} else if (nextCodeIs("SINH#(")) {
+		err=float_1param_function(FUNC_SINH);
+	} else if (nextCodeIs("COSH#(")) {
+		err=float_1param_function(FUNC_COSH);
+	} else if (nextCodeIs("TANH#(")) {
+		err=float_1param_function(FUNC_TANH);
+	} else if (nextCodeIs("EXP#(")) {
+		err=float_1param_function(FUNC_EXP);
+	} else if (nextCodeIs("LOG#(")) {
+		err=float_1param_function(FUNC_LOG);
+	} else if (nextCodeIs("LOG10#(")) {
+		err=float_1param_function(FUNC_LOG10);
+	} else if (nextCodeIs("POW#(")) {
+		err=float_2param_function(FUNC_POW);
+	} else if (nextCodeIs("SQRT#(")) {
+		err=float_1param_function(FUNC_SQRT);
+	} else if (nextCodeIs("CEIL#(")) {
+		err=float_1param_function(FUNC_CEIL);
+	} else if (nextCodeIs("FLOOR#(")) {
+		err=float_1param_function(FUNC_FLOOR);
+	} else if (nextCodeIs("FABS#(")) {
+		err=float_1param_function(FUNC_FABS);
+	} else if (nextCodeIs("MODF#(")) {
+		err=float_1param_function(FUNC_MODF);
+	} else if (nextCodeIs("FMOD#(")) {
+		err=float_2param_function(FUNC_FMOD);
+	} else if (nextCodeIs("GOSUB#(")) {
+		err=gosub_function();
+	} else if (nextCodeIs("ARGS#(")) {
+		err=args_function();
+	} else if (nextCodeIs("PI#")) {
+		return float_constant(3.141593);
+	} else {
+		// Check if static method of a class
+		err=static_method('#');
+		//return ERR_SYNTAX;
+	}
+	if (err) return err;
+	if (g_source[g_srcpos]!=')') return ERR_SYNTAX;
+	g_srcpos++;
+	return 0;
+}
+
+static const void* str_func_list[]={
+	"CHR$(",chr_function,
+	"HEX$(",hex_function,
+	"DEC$(",dec_function,
+	"INPUT$(",input_function,
+	"GOSUB$(",gosub_function,
+	"ARGS$(",args_function,
+	"READ$(",read_function,
+	"SPRINTF$(",sprintf_function,
+	"FLOAT$(",floatstr_function,
+	"SYSTEM$(",system_function,
+	"FINPUT$(",finput_function,
+	"GETDIR$(",getdir_function,
+	// Additional functions follow
+	ADDITIONAL_STR_FUNCTIONS
+};
+
+char* str_function(void){
+	char* err;
+	int i;
+	char* (*f)();
+	// Seek the function
+	for (i=0;i<sizeof(str_func_list)/sizeof(str_func_list[0]);i+=2){
+		if (nextCodeIs((char*)str_func_list[i])) break;
+	}
+	if (i<sizeof(str_func_list)/sizeof(str_func_list[0])) {
+		// Function found. Call it.
+		f=str_func_list[i+1];
+		err=f();
+	} else {
+		// Check if static method of a class
+		err=static_method('$');
+		//return ERR_SYNTAX;
+	}
+	if (err) return err;
+	if (g_source[g_srcpos]!=')') return ERR_SYNTAX;
+	g_srcpos++;
+	return 0;
+}
+
+// Aliases follow
+
+char* peek_function(){
+	return peek_function_sub(8);
+}
+
+char* peek16_function(){
+	return peek_function_sub(16);
+}
+
+char* peek32_function(){
+	return peek_function_sub(32);
+}
+
+char* gcolor_function(){
+	return graphic_statement(FUNC_GCOLOR);
+}
+
+char* fopen_function(){
+	return fopen_statement_main(FUNC_FOPEN);
+}
+
+static const void* int_func_list[]={
+	"NOT(",not_function,
+	"DRAWCOUNT(",drawcount_function,
+	"MUSIC(",music_function,
+	"TVRAM(",tvram_function,
+	"KEYS(",keys_function,
+	"READ(",read_function,
+	"CREAD(",cread_function,
+	"GOSUB(",gosub_function,
+	"STRNCMP(",strncmp_function,
+	"PEEK(",peek_function,
+	"PEEK16(",peek16_function,
+	"PEEK32(",peek32_function,
+	"LEN(",len_function,
+	"ASC(",asc_function,
+	"SGN(",sgn_function,
+	"ABS(",abs_function,
+	"RND(",rnd_function,
+	"VAL(",val_function,
+	"INKEY(",inkey_function,
+	"ARGS(",args_function,
+	"SYSTEM(",system_function,
+	"INT(",int_function,
+	"GCOLOR(",gcolor_function,
+	"FOPEN(",fopen_function,
+	"FSEEK(",fseek_function,
+	"FLEN(",flen_function,
+	"FGET(",fget_statement,
+	"FPUT(",fput_statement,
+	"FGETC(",fgetc_function,
+	"FPUTC(",fputc_statement,
+	"FREMOVE(",fremove_statement,
+	"FEOF(",feof_function,
+	"PLAYWAVE(",playwave_function,
+	"NEW(",new_function,
+	"SETDIR(",setdir_function,
+	"TIMER(",timer_function,
+	// Additional functions follow
+	ADDITIONAL_INT_FUNCTIONS
+};
+
+char* function(void){
+	char* err;
+	int i;
+	char* (*f)();
+	// Seek the function
+	for (i=0;i<sizeof(int_func_list)/sizeof(int_func_list[0]);i+=2){
+		if (nextCodeIs((char*)int_func_list[i])) break;
+	}
+	if (i<sizeof(int_func_list)/sizeof(int_func_list[0])) {
+		// Function found. Call it.
+		f=int_func_list[i+1];
+		err=f();
+	} else {
+		// Check if static method of a class
+		err=static_method(0);
+		//return ERR_SYNTAX;
+	}
+	if (err) return err;
+	if (g_source[g_srcpos]!=')') return ERR_SYNTAX;
+	g_srcpos++;
+	return 0;
+}

--- /dev/null
+++ b/mips/protozoa/globalvars.c
@@ -0,0 +1,95 @@
+/*
+   This file is provided under the LGPL license ver 2.1.
+   Written by K.Tanaka & Katsumi
+   http://www.ze.em-net.ne.jp/~kenken/index.html
+   http://hp.vector.co.jp/authors/VA016157/
+*/
+
+/*
+	This file is shared by Megalopa and Zoea
+*/
+
+#include "compiler.h"
+#include "main.h"
+
+// Contain the valus of $gp and $s6 (GPR of MIPS32)
+int g_gp;
+int g_s6;
+
+// Line data when compiling
+int g_line;
+int g_fileline;
+
+// Contain the address to which return in "END" statement.
+int g_end_addr;
+
+// Following vars are used in value.c and string.c.
+// These define the depth of stack pointer used for
+// handling values and strings.
+int g_sdepth;
+int g_maxsdepth;
+char g_allow_shift_obj;
+
+// Following var shows what type of variable was defined
+// in compiling the last code.
+enum variable g_lastvar;
+
+// Vars used for handling constant integer
+int g_intconst;
+char g_valueisconst;
+
+// Global vars associated to RAM
+char* g_source;
+int g_srcpos;
+int* g_object;
+int g_objpos;
+int* g_objmax;
+char RAM[RAMSIZE] __attribute__((persistent,address(0xA0000000+PIC32MX_RAMSIZE-PERSISTENT_RAM_SIZE)));
+unsigned int g_ex_data[EXCEPTION_DATA_SIZE/4] __attribute__((persistent,address(0xA0000000+PIC32MX_RAMSIZE-EXCEPTION_DATA_SIZE)));
+
+// Global area for vars A-Z and three temporary string pointers
+int g_var_mem[ALLOC_BLOCK_NUM];
+unsigned short g_var_pointer[ALLOC_BLOCK_NUM];
+unsigned short g_var_size[ALLOC_BLOCK_NUM];
+
+// Flag to use temporary area when compiling
+char g_temp_area_used;
+
+// Flag to use option nolinenum
+char g_nolinenum;
+
+// Heap area
+int* g_heap_mem;
+int g_max_mem;
+
+// Random seed
+unsigned int g_rnd_seed;
+
+// Enable/disable Break keys
+char g_disable_break;
+
+// Font data used for PCG
+unsigned char* g_pcg_font;
+
+// Use or do not use graphic
+char g_use_graphic;
+
+// Pointer to graphic RAM
+unsigned short* g_graphic_area;
+
+// Parameter-containing block used for library
+int* g_libparams;
+
+// Number of long name variables
+int g_long_name_var_num;
+
+// Flag for active music/sound/wave function
+char g_music_active;
+
+// Class name being compiled
+int g_class;
+// Flag to compile class file
+int g_compiling_class;
+
+// General purpose integer used for asigning value with pointer
+int g_temp;

--- /dev/null
+++ b/mips/protozoa/interface/LCDdriver.c
@@ -0,0 +1,176 @@
+/*
+ * 液晶モジュールドライバ for PIC32MX1xx/2xx
+ * システムクロック48MHz、周辺クロック48MHz
+ *
+ * 液晶モジュールの初期化はブートローダ側で行うため不要
+ *
+ * 8bit mode接続
+ * D8  RB0
+ * D9  RB1
+ * D10 RB2
+ * D11 RB3
+ * D12 RB4
+ * D13 RB5
+ * D14 RB7
+ * D15 RB8
+ * RS  RB9
+ * WR  RB10
+ * CS  RB11
+ * RD  RB13
+ * RESET RB14
+ */
+
+#include <plib.h>
+#include "LCDdriver.h"
+
+void inline LCD_set_dat(unsigned char c){
+	LCD_DATCLR=LCD_DAT_MASK;
+	LCD_DATSET=((c<<1)&0x180)+(c&0x3f);
+}
+unsigned char LCD_get_dat(void){
+	unsigned short d;
+	d=PORTB & LCD_DAT_MASK;
+	return ((d&0x180)>>1)+(d&0x3f);
+}
+void LCD_WriteIndex(unsigned char index){
+// Write Index
+	LCD_RS_LO;
+	LCD_set_dat(0);
+	LCD_WR_LO;
+	asm("nop");
+	LCD_WR_HI;
+	LCD_set_dat(index);
+	LCD_WR_LO;
+	asm("nop");
+	LCD_WR_HI;
+}
+
+void LCD_WriteData(unsigned short data)
+{
+// Write Data
+	LCD_RS_HI;
+	LCD_set_dat(data>>8);
+	LCD_WR_LO;
+	asm("nop");
+	LCD_WR_HI;
+	LCD_set_dat((unsigned char)data);
+	LCD_WR_LO;
+	asm("nop");
+	LCD_WR_HI;
+}
+unsigned short LCD_ReadData(void)
+{
+// Read Data
+	unsigned short d;
+	TRISBSET=LCD_DAT_MASK;
+	LCD_RS_HI;
+	LCD_RD_LO;
+	asm("nop");asm("nop");asm("nop");asm("nop");asm("nop");
+	asm("nop");asm("nop");asm("nop");asm("nop");asm("nop");
+	asm("nop");asm("nop");asm("nop");asm("nop");asm("nop");
+	d=LCD_get_dat();
+	LCD_RD_HI;
+	asm("nop");asm("nop");asm("nop");asm("nop");asm("nop");
+	asm("nop");asm("nop");asm("nop");asm("nop");asm("nop");
+	LCD_RD_LO;
+	asm("nop");asm("nop");asm("nop");asm("nop");asm("nop");
+	asm("nop");asm("nop");asm("nop");asm("nop");asm("nop");
+	asm("nop");asm("nop");asm("nop");asm("nop");asm("nop");
+	d=(d<<8)+LCD_get_dat();
+	LCD_RD_HI;
+	asm("nop");asm("nop");asm("nop");asm("nop");asm("nop");
+	TRISBCLR=LCD_DAT_MASK;
+	return d;
+}
+void LCD_WriteReg(unsigned char index, unsigned short data)
+{
+// Write Index
+	LCD_WriteIndex(index);
+
+// Write Data
+	LCD_WriteData(data);
+}
+unsigned short LCD_ReadReg(unsigned char index)
+{
+// Write Index
+	LCD_WriteIndex(index);
+
+// Read Data
+	return LCD_ReadData();
+}
+
+void LCD_SetCursor(unsigned short x, unsigned short y)
+{
+#if LCD_ALIGNMENT == VERTICAL
+	LCD_WriteReg(0x20, x);
+	LCD_WriteReg(0x21, y);
+#elif LCD_ALIGNMENT == HORIZONTAL
+	LCD_WriteReg(0x20, y);
+	LCD_WriteReg(0x21, x);
+#endif
+}
+
+void LCD_continuous_output(unsigned short x,unsigned short y,unsigned short color,int n)
+{
+	//High speed continuous output
+	int i;
+	unsigned char d1,d2;
+	LCD_SetCursor(x,y);
+	LCD_WriteIndex(0x22);
+	LCD_RS_HI;
+	d1=color>>8;
+	d2=(unsigned char)color;
+	for (i=0; i < n ; i++){
+		LCD_set_dat(d1);
+		LCD_WR_LO;
+		asm("nop");
+		LCD_WR_HI;
+		LCD_set_dat(d2);
+		LCD_WR_LO;
+		asm("nop");
+		LCD_WR_HI;
+	}
+}
+void LCD_Clear(unsigned short color)
+{
+	LCD_continuous_output(0,0,color,X_RES*Y_RES);
+}
+
+void drawPixel(unsigned short x, unsigned short y, unsigned short color)
+{
+	LCD_SetCursor(x,y);
+	LCD_WriteIndex(0x22);
+	LCD_WriteData(color);
+}
+
+unsigned short getColor(unsigned short x, unsigned short y)
+{
+	unsigned short d;
+	LCD_SetCursor(x,y);
+	LCD_WriteIndex(0x22);
+	LCD_ReadData(); //dummy read
+	d=LCD_ReadData();
+	return (d>>11)+(d&0x7e0)+((d&0x1f)<<11); //swap R and B
+}
+
+void LCD_set_Vertical(void){
+	if(LCD_ReadReg(0)==0x0129){
+		LCD_WriteReg(0x01, 0x0127);
+		LCD_WriteReg(0x03, 0x1030);
+	}
+	else{
+		LCD_WriteReg(0x01, 0x0100);
+		LCD_WriteReg(0x03, 0x1030);
+	}
+}
+
+void LCD_set_Horizontal(void){
+	if(LCD_ReadReg(0)==0x0129){
+		LCD_WriteReg(0x01, 0x0027);
+		LCD_WriteReg(0x03, 0x1028);
+	}
+	else{
+		LCD_WriteReg(0x01, 0x0000);
+		LCD_WriteReg(0x03, 0x1028);
+	}
+}

--- /dev/null
+++ b/mips/protozoa/interface/LCDdriver.h
@@ -0,0 +1,36 @@
+#define VERTICAL 0
+#define HORIZONTAL 1
+//#define LCD_ALIGNMENT VERTICAL
+#define LCD_ALIGNMENT HORIZONTAL
+
+#if LCD_ALIGNMENT == VERTICAL
+	#define X_RES 240 // 横方向解像度
+	#define Y_RES 320 // 縦方向解像度
+#else
+	#define X_RES 320 // 横方向解像度
+	#define Y_RES 240 // 縦方向解像度
+#endif
+
+#define LCD_DAT_MASK 0x01bf
+#define LCD_DATCLR LATBCLR
+#define LCD_DATSET LATBSET
+#define LCD_RS_LO LATBCLR=0x200
+#define LCD_RS_HI LATBSET=0x200
+#define LCD_CS_LO LATBCLR=0x800
+#define LCD_CS_HI LATBSET=0x800
+#define LCD_WR_LO LATBCLR=0x400
+#define LCD_WR_HI LATBSET=0x400
+#define LCD_RD_LO LATBCLR=0x2000
+#define LCD_RD_HI LATBSET=0x2000
+#define LCD_RESET_LO LATBCLR=0x4000
+#define LCD_RESET_HI LATBSET=0x4000
+
+void LCD_WriteIndex(unsigned char index);
+void LCD_WriteData(unsigned short data);
+unsigned short LCD_ReadData(void);
+void LCD_Init(void);
+void LCD_SetCursor(unsigned short x, unsigned short y);
+void LCD_Clear(unsigned short color);
+void drawPixel(unsigned short x, unsigned short y, unsigned short color);
+void LCD_set_Vertical(void);
+void LCD_set_Horizontal(void);

--- /dev/null
+++ b/mips/protozoa/interface/SDFSIO.h
@@ -0,0 +1,2344 @@
+/******************************************************************************
+ *
+ *                Microchip Memory Disk Drive File System
+ *
+ ******************************************************************************
+ * FileName:        FSIO.h
+ * Dependencies:    GenericTypeDefs.h
+ *                  FSconfig.h
+ *                  FSDefs.h
+ *                  stddef.h
+ * Processor:       PIC18/PIC24/dsPIC30/dsPIC33/PIC32
+ * Compiler:        C18/C30/C32
+ * Company:         Microchip Technology, Inc.
+ * Version:         1.3.0
+ *
+ * Software License Agreement
+ *
+ * The software supplied herewith by Microchip Technology Incorporated
+ * (the 鼎ompany・ for its PICmicroｮ Microcontroller is intended and
+ * supplied to you, the Company痴 customer, for use solely and
+ * exclusively on Microchip PICmicro Microcontroller products. The
+ * software is owned by the Company and/or its supplier, and is
+ * protected under applicable copyright laws. All rights are reserved.
+ * Any use in violation of the foregoing restrictions may subject the
+ * user to criminal sanctions under applicable laws, as well as to
+ * civil liability for the breach of the terms and conditions of this
+ * license.
+ *
+ * THIS SOFTWARE IS PROVIDED IN AN 鄭S IS・CONDITION. NO WARRANTIES,
+ * WHETHER EXPRESS, IMPLIED OR STATUTORY, INCLUDING, BUT NOT LIMITED
+ * TO, IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
+ * PARTICULAR PURPOSE APPLY TO THIS SOFTWARE. THE COMPANY SHALL NOT,
+ * IN ANY CIRCUMSTANCES, BE LIABLE FOR SPECIAL, INCIDENTAL OR
+ * CONSEQUENTIAL DAMAGES, FOR ANY REASON WHATSOEVER.
+ *
+*****************************************************************************/
+
+#ifndef  FS_DOT_H
+#define  FS_DOT_H
+
+#define ALLOW_FILESEARCH
+#define ALLOW_WRITES
+#define ALLOW_DIRS
+#define SUPPORT_FAT32
+
+#define MDD_MediaInitialize     MDD_SDSPI_MediaInitialize
+#define MDD_MediaDetect         MDD_SDSPI_MediaDetect
+#define MDD_SectorRead          MDD_SDSPI_SectorRead
+#define MDD_SectorWrite         MDD_SDSPI_SectorWrite
+#define MDD_InitIO              MDD_SDSPI_InitIO
+#define MDD_ShutdownMedia       MDD_SDSPI_ShutdownMedia
+#define MDD_WriteProtectState   MDD_SDSPI_WriteProtectState
+
+// Summary: An enumeration used for various error codes.
+// Description: The CETYPE enumeration is used to indicate different error conditions during device operation.
+typedef enum _CETYPE
+{
+    CE_GOOD = 0,                    // No error
+    CE_ERASE_FAIL,                  // An erase failed
+    CE_NOT_PRESENT,                 // No device was present
+    CE_NOT_FORMATTED,               // The disk is of an unsupported format
+    CE_BAD_PARTITION,               // The boot record is bad
+    CE_UNSUPPORTED_FS,              // The file system type is unsupported
+    CE_INIT_ERROR,                  // An initialization error has occured
+    CE_NOT_INIT,                    // An operation was performed on an uninitialized device
+    CE_BAD_SECTOR_READ,             // A bad read of a sector occured
+    CE_WRITE_ERROR,                 // Could not write to a sector
+    CE_INVALID_CLUSTER,             // Invalid cluster value > maxcls
+    CE_FILE_NOT_FOUND,              // Could not find the file on the device
+    CE_DIR_NOT_FOUND,               // Could not find the directory
+    CE_BAD_FILE,                    // File is corrupted
+    CE_DONE,                        // No more files in this directory
+    CE_COULD_NOT_GET_CLUSTER,       // Could not load/allocate next cluster in file
+    CE_FILENAME_2_LONG,             // A specified file name is too long to use
+    CE_FILENAME_EXISTS,             // A specified filename already exists on the device
+    CE_INVALID_FILENAME,            // Invalid file name
+    CE_DELETE_DIR,                  // The user tried to delete a directory with FSremove
+    CE_DIR_FULL,                    // All root dir entry are taken
+    CE_DISK_FULL,                   // All clusters in partition are taken
+    CE_DIR_NOT_EMPTY,               // This directory is not empty yet, remove files before deleting
+    CE_NONSUPPORTED_SIZE,           // The disk is too big to format as FAT16
+    CE_WRITE_PROTECTED,             // Card is write protected
+    CE_FILENOTOPENED,               // File not opened for the write
+    CE_SEEK_ERROR,                  // File location could not be changed successfully
+    CE_BADCACHEREAD,                // Bad cache read
+    CE_CARDFAT32,                   // FAT 32 - card not supported
+    CE_READONLY,                    // The file is read-only
+    CE_WRITEONLY,                   // The file is write-only
+    CE_INVALID_ARGUMENT,            // Invalid argument
+    CE_TOO_MANY_FILES_OPEN,         // Too many files are already open
+    CE_UNSUPPORTED_SECTOR_SIZE      // Unsupported sector size
+} CETYPE;
+
+
+// Summary: A macro indicating a dir entry was found
+// Description: The FOUND macro indicates that a directory entry was found in the specified position
+#define FOUND       0
+
+// Summary: A macro indicating no dir entry was found
+// Description: The NOT_FOUND macro indicates that the specified directory entry to load was deleted
+#define NOT_FOUND   1
+
+// Summary: A macro indicating that no more files were found
+// Description: The NO_MORE macro indicates that there are no more directory entries to search for
+#define NO_MORE     2
+
+
+
+// Summary: A macro indicating the device is formatted with FAT12
+// Description: The FAT12 macro is used to indicate that the file system on the device being accessed is a FAT12 file system.
+#define FAT12       1
+
+// Summary: A macro indicating the device is formatted with FAT16
+// Description: The FAT16 macro is used to indicate that the file system on the device being accessed is a FAT16 file system.
+#define FAT16       2
+
+// Summary: A macro indicating the device is formatted with FAT32
+// Description: The FAT32 macro is used to indicate that the file system on the device being accessed is a FAT32 file system.
+#define FAT32       3
+
+
+
+// Summary: A read-only attribute macro
+// Description: A macro for the read-only attribute.  A file with this attribute should not be written to.  Note that this
+//              attribute will not actually prevent a write to the file; that functionality is operating-system dependant.  The
+//              user should take care not to write to a read-only file.
+#define ATTR_READ_ONLY      0x01
+
+// Summary: A hidden attribute macro
+// Description: A macro for the hidden attribute.  A file with this attribute may be hidden from the user, depending on the
+//              implementation of the operating system.
+#define ATTR_HIDDEN         0x02
+
+// Summary: A system attribute macro
+// Description: A macro for the system attribute.  A file with this attribute is used by the operating system, and should not be
+//              modified.  Note that this attribute will not actually prevent a write to the file.
+#define ATTR_SYSTEM         0x04
+
+// Summary: A volume attribute macro
+// Description: A macro for the volume attribute.  If the first directory entry in the root directory has the volume attribute set,
+//              the device will use the name in that directory entry as the volume name.
+#define ATTR_VOLUME         0x08
+
+// Summary: A macro for the attributes for a long-file name entry
+// Description: A macro for the long-name attributes.  If a directory entry is used in a long-file name implementation, it will have
+//              all four lower bits set.  This indicates that any software that does not support long file names should ignore that
+//              entry.
+#define ATTR_LONG_NAME      0x0f
+
+// Summary: A directory attribute macro
+// Description: A macro for the directory attribute.  If a directory entry has this attribute set, the file it points to is a directory-
+//              type file, and will contain directory entries that point to additional directories or files.
+#define ATTR_DIRECTORY      0x10
+
+// Summary: An archive attribute macro
+// Description: A macro for the archive attribute.  This attribute will indicate to some archiving programs that the file with this
+//              attribute needs to be backed up.  Most operating systems create files with the archive attribute set.
+#define ATTR_ARCHIVE        0x20
+
+// Summary: A macro for all attributes
+// Description: A macro for all attributes.  The search functions in this library require an argument that determines which attributes
+//              a file is allowed to have in order to be found.  If ATTR_MASK is specified as this argument, any file may be found, regardless
+//              of its attributes.
+#define ATTR_MASK           0x3f
+
+
+
+// Summary: A macro to indicate an empty FAT entry
+// Description: The CLUSTER_EMPTY value is used to indicate that a FAT entry and it's corresponding cluster are available.
+#define CLUSTER_EMPTY               0x0000 
+
+// Summary: A macro to indicate the last cluster value for FAT12
+// Description: The LAST_CLUSTER_FAT12 macro is used when reading the FAT to indicate that the next FAT12 entry for a file contains
+//              the end-of-file value.
+#define LAST_CLUSTER_FAT12          0xff8
+
+// Summary: A macro to indicate the last cluster value for FAT16
+// Description: The LAST_CLUSTER_FAT16 macro is used when reading the FAT to indicate that the next FAT16 entry for a file contains
+//              the end-of-file value.
+#define LAST_CLUSTER_FAT16          0xfff8
+
+// Summary: A macro to indicate the last allocatable cluster for FAT12
+// Description: The END_CLUSTER_FAT12 value is used as a comparison in FAT12 to determine that the firmware has reached the end of
+//              the range of allowed allocatable clusters.
+#define END_CLUSTER_FAT12           0xFF7
+
+// Summary: A macro to indicate the last allocatable cluster for FAT16
+// Description: The END_CLUSTER_FAT16 value is used as a comparison in FAT16 to determine that the firmware has reached the end of
+//              the range of allowed allocatable clusters.
+#define END_CLUSTER_FAT16           0xFFF7
+
+// Summary: A macro to indicate the failure of the ReadFAT function
+// Description: The CLUSTER_FAIL_FAT16 macro is used by the ReadFAT function to indicate that an error occured reading a FAT12 or FAT16
+//              file allocation table.  Note that since '0xFFF8' is used for the last cluster return value in the FAT16 implementation
+//              the end-of-file value '0xFFFF' can be used to indicate an error condition.
+#define CLUSTER_FAIL_FAT16          0xFFFF
+
+
+
+#ifdef SUPPORT_FAT32
+    // Summary: A macro to indicate the last cluster value for FAT32
+    // Description: The LAST_CLUSTER_FAT32 macro is used when reading the FAT to indicate that the next FAT32 entry for a file contains
+    //              the end-of-file value.
+    #define LAST_CLUSTER_FAT32      0x0FFFFFF8
+
+    // Summary: A macro to indicate the last allocatable cluster for FAT32
+    // Description: The END_CLUSTER_FAT32 value is used as a comparison in FAT32 to determine that the firmware has reached the end of
+    //              the range of allowed allocatable clusters.
+    #define END_CLUSTER_FAT32       0x0FFFFFF7
+
+    // Summary: A macro to indicate the failure of the ReadFAT function
+    // Description: The CLUSTER_FAIL_FAT32 macro is used by the ReadFAT function to indicate that an error occured reading a FAT32
+    //              file allocation able.
+    #define CLUSTER_FAIL_FAT32      0x0FFFFFFF
+
+#endif
+
+// Summary: A macro indicating the number of bytes in a directory entry.
+// Description: The NUMBER_OF_BYTES_IN_DIR_ENTRY macro represents the number of bytes in one directory entry.  It is used to calculate
+//              the number of sectors in the root directory based on information in the boot sector.
+#define NUMBER_OF_BYTES_IN_DIR_ENTRY    32
+
+
+
+// Summary: A macro for a deleted dir entry marker.
+// Description: The DIR_DEL macro is used to mark a directory entry as deleted.  When a file is deleted, this value will replace the
+//              first character in the file name, and will indicate that the file the entry points to was deleted.
+#define DIR_DEL             0xE5
+
+// Summary: A macro for the last dir entry marker.
+// Description: The DIR_EMPTY macro is used to indicate the last entry in a directory.  Since entries in use cannot start with a 0 and
+//              deleted entries start with the DIR_DEL character, a 0 will mark the end of the in-use or previously used group of
+//              entries in a directory
+#define DIR_EMPTY           0
+
+
+
+// Summary: A macro used to indicate the length of an 8.3 file name
+// Description: The DIR_NAMESIZE macro is used when validing the name portion of 8.3 filenames
+#define DIR_NAMESIZE        8
+
+// Summary: A macro used to indicate the length of an 8.3 file extension
+// Description: The DIR_EXTENSION macro is used when validating the extension portion of 8.3 filenames
+#define DIR_EXTENSION       3
+
+// Summary: A macro used to indicate the length of an 8.3 file name and extension
+// Description: The DIR_NAMECOMP macro is used when validating 8.3 filenames
+#define DIR_NAMECOMP        (DIR_NAMESIZE+DIR_EXTENSION)
+
+
+
+// Summary: A macro to write a byte to RAM
+// Description: The RAMwrite macro is used to write a byte of data to a RAM array
+#define RAMwrite( a, f, d) *(a+f) = d
+
+// Summary: A macro to read a byte from RAM
+// Description: The RAMread macro is used to read a byte of data from a RAM array
+#define RAMread( a, f)  *(a+f)
+
+// Summary: A macro to read a 16-bit word from RAM
+// Description: The RAMreadW macro is used to read two bytes of data from a RAM array
+#define RAMreadW( a, f) *(WORD *)(a+f)
+
+// Summary: A macro to read a 32-bit word from RAM
+// Description: The RAMreadD macro is used to read four bytes of data from a RAM array
+#define RAMreadD( a, f) *(DWORD *)(a+f)
+
+
+
+#ifndef EOF
+    // Summary: Indicates error conditions or end-of-file conditions
+    // Description: The EOF macro is used to indicate error conditions in some function calls.  It is also used to indicate
+    //              that the end-of-file has been reached.
+    #define EOF             ((int)-1)
+#endif
+
+
+
+// Summary: A structure containing information about the device.
+// Description: The DISK structure contains information about the device being accessed.
+typedef struct
+{ 
+    BYTE    *   buffer;         // Address of the global data buffer used to read and write file information
+    DWORD       firsts;         // Logical block address of the first sector of the FAT partition on the device
+    DWORD       fat;            // Logical block address of the FAT
+    DWORD       root;           // Logical block address of the root directory
+    DWORD       data;           // Logical block address of the data section of the device.
+    WORD        maxroot;        // The maximum number of entries in the root directory.
+    DWORD       maxcls;         // The maximum number of clusters in the partition.
+    DWORD       sectorSize;     // The size of a sector in bytes
+    DWORD       fatsize;        // The number of sectors in the FAT
+    BYTE        fatcopy;        // The number of copies of the FAT in the partition
+    BYTE        SecPerClus;     // The number of sectors per cluster in the data region
+    BYTE        type;           // The file system type of the partition (FAT12, FAT16 or FAT32)
+    BYTE        mount;          // Device mount flag (TRUE if disk was mounted successfully, FALSE otherwise)
+#if defined __PIC32MX__ || defined __C30__
+} __attribute__ ((packed)) DISK;
+#else
+} DISK;
+#endif
+
+
+#ifdef __18CXX
+    // Summary: A 24-bit data type
+    // Description: The SWORD macro is used to defined a 24-bit data type.  For 16+ bit architectures, this must be represented as
+    //              an array of three bytes.
+    typedef unsigned short long SWORD;
+#else
+    // Summary: A 24-bit data type
+    // Description: The SWORD macro is used to defined a 24-bit data type.  For 16+ bit architectures, this must be represented as
+    //              an array of three bytes.
+    typedef struct
+    {
+        unsigned char array[3];
+#if defined __PIC32MX__ || defined __C30__
+    } __attribute__ ((packed)) SWORD;
+#else
+    } SWORD;
+#endif
+#endif
+
+
+
+// Summary: A structure containing the bios parameter block for a FAT12 file system (in the boot sector)
+// Description: The _BPB_FAT12 structure provides a layout of the "bios parameter block" in the boot sector of a FAT12 partition.
+typedef struct {
+    SWORD BootSec_JumpCmd;          // Jump Command
+    BYTE  BootSec_OEMName[8];       // OEM name
+    WORD BootSec_BPS;               // Number of bytes per sector
+    BYTE  BootSec_SPC;              // Number of sectors per cluster
+    WORD BootSec_ResrvSec;          // Number of reserved sectors at the beginning of the partition
+    BYTE  BootSec_FATCount;         // Number of FATs on the partition
+    WORD BootSec_RootDirEnts;       // Number of root directory entries
+    WORD BootSec_TotSec16;          // Total number of sectors
+    BYTE  BootSec_MDesc;            // Media descriptor
+    WORD BootSec_SPF;               // Number of sectors per FAT
+    WORD BootSec_SPT;               // Number of sectors per track
+    WORD BootSec_HeadCnt;           // Number of heads
+    DWORD BootSec_HiddenSecCnt;     // Number of hidden sectors
+    DWORD  BootSec_Reserved;        // Reserved space
+    BYTE  BootSec_DriveNum;         // Drive number
+    BYTE  BootSec_Reserved2;        // Reserved space
+    BYTE  BootSec_BootSig;          // Boot signature - equal to 0x29
+    BYTE  BootSec_VolID[4];         // Volume ID
+    BYTE  BootSec_VolLabel[11];     // Volume Label
+    BYTE  BootSec_FSType[8];        // File system type in ASCII. Not used for determination   
+#if defined __PIC32MX__ || defined __C30__
+    } __attribute__ ((packed)) _BPB_FAT12;
+#else
+    } _BPB_FAT12;
+#endif
+
+// Summary: A structure containing the bios parameter block for a FAT16 file system (in the boot sector)
+// Description: The _BPB_FAT16 structure provides a layout of the "bios parameter block" in the boot sector of a FAT16 partition.
+typedef struct {
+    SWORD BootSec_JumpCmd;          // Jump Command
+    BYTE  BootSec_OEMName[8];       // OEM name
+    WORD  BootSec_BPS;              // Number of bytes per sector
+    BYTE  BootSec_SPC;              // Number of sectors per cluster
+    WORD  BootSec_ResrvSec;         // Number of reserved sectors at the beginning of the partition
+    BYTE  BootSec_FATCount;         // Number of FATs on the partition
+    WORD  BootSec_RootDirEnts;      // Number of root directory entries
+    WORD  BootSec_TotSec16;         // Total number of sectors
+    BYTE  BootSec_MDesc;            // Media descriptor
+    WORD  BootSec_SPF;              // Number of sectors per FAT
+    WORD  BootSec_SPT;              // Number of sectors per track
+    WORD  BootSec_HeadCnt;          // Number of heads
+    DWORD BootSec_HiddenSecCnt;     // Number of hidden sectors
+    DWORD BootSec_TotSec32;         // Total sector count (32 bits)
+    BYTE  BootSec_DriveNum;         // Drive number
+    BYTE  BootSec_Reserved;         // Reserved space
+    BYTE  BootSec_BootSig;          // Boot signature - equal to 0x29
+    BYTE  BootSec_VolID[4];         // Volume ID
+    BYTE  BootSec_VolLabel[11];     // Volume Label
+    BYTE  BootSec_FSType[8];        // File system type in ASCII. Not used for determination     
+#if defined __PIC32MX__ || defined __C30__
+    } __attribute__ ((packed)) _BPB_FAT16;
+#else
+    } _BPB_FAT16;
+#endif
+
+// Summary: A structure containing the bios parameter block for a FAT32 file system (in the boot sector)
+// Description: The _BPB_FAT32 structure provides a layout of the "bios parameter block" in the boot sector of a FAT32 partition.
+typedef struct {
+    SWORD BootSec_jmpBoot;          // Jump Command
+    BYTE  BootSec_OEMName[8];       // OEM name
+    WORD BootSec_BytsPerSec;        // Number of bytes per sector
+    BYTE  BootSec_SecPerClus;       // Number of sectors per cluster
+    WORD BootSec_RsvdSecCnt;        // Number of reserved sectors at the beginning of the partition
+    BYTE  BootSec_NumFATs;          // Number of FATs on the partition
+    WORD BootSec_RootEntCnt;        // Number of root directory entries
+    WORD BootSec_TotSec16;          // Total number of sectors
+    BYTE  BootSec_Media;            // Media descriptor
+    WORD BootSec_FATSz16;           // Number of sectors per FAT
+    WORD BootSec_SecPerTrk;         // Number of sectors per track
+    WORD BootSec_NumHeads;          // Number of heads
+    DWORD BootSec_HiddSec;          // Number of hidden sectors
+    DWORD BootSec_TotSec32;         // Total sector count (32 bits)
+    DWORD BootSec_FATSz32;          // Sectors per FAT (32 bits)
+    WORD BootSec_ExtFlags;          // Presently active FAT. Defined by bits 0-3 if bit 7 is 1.
+    WORD BootSec_FSVers;            // FAT32 filesystem version.  Should be 0:0
+    DWORD BootSec_RootClus;         // Start cluster of the root directory (should be 2)
+    WORD BootSec_FSInfo;            // File system information
+    WORD BootSec_BkBootSec;         // Backup boot sector address.
+    BYTE  BootSec_Reserved[12];     // Reserved space
+    BYTE  BootSec_DrvNum;           // Drive number
+    BYTE  BootSec_Reserved1;        // Reserved space
+    BYTE  BootSec_BootSig;          // Boot signature - 0x29
+    BYTE  BootSec_VolID[4];         // Volume ID
+    BYTE  BootSec_VolLab[11];       // Volume Label
+    BYTE  BootSec_FilSysType[8];    // File system type in ASCII.  Not used for determination  
+#if defined __PIC32MX__ || defined __C30__
+    } __attribute__ ((packed)) _BPB_FAT32;
+#else
+    } _BPB_FAT32;
+#endif
+
+
+// Description: A macro for the boot sector bytes per sector value offset
+#define BSI_BPS            11
+
+// Description: A macro for the boot sector sector per cluster value offset
+#define BSI_SPC            13
+
+// Description: A macro for the boot sector reserved sector count value offset
+#define BSI_RESRVSEC       14
+
+// Description: A macro for the boot sector FAT count value offset
+#define BSI_FATCOUNT       16
+
+// Description: A macro for the boot sector root directory entry count value offset
+#define BSI_ROOTDIRENTS    17
+
+// Description: A macro for the boot sector 16-bit total sector count value offset
+#define BSI_TOTSEC16       19
+
+// Description: A macro for the boot sector sectors per FAT value offset
+#define BSI_SPF            22
+
+// Description: A macro for the boot sector 32-bit total sector count value offset
+#define BSI_TOTSEC32       32
+
+// Description: A macro for the boot sector boot signature offset
+#define BSI_BOOTSIG        38
+
+// Description: A macro for the boot sector file system type string offset
+#define BSI_FSTYPE         54
+
+// Description: A macro for the boot sector 32-bit sector per FAT value offset
+#define  BSI_FATSZ32       36
+
+// Description: A macro for the boot sector start cluster of root directory value offset
+#define  BSI_ROOTCLUS      44
+
+// Description: A macro for the FAT32 boot sector boot signature offset
+#define  BSI_FAT32_BOOTSIG 66
+
+// Description: A macro for the FAT32 boot sector file system type string offset
+#define  BSI_FAT32_FSTYPE  82
+
+
+
+// Summary: A partition table entry structure.
+// Description: The PTE_MBR structure contains values found in a partition table entry in the MBR of a device.
+typedef struct
+{
+    BYTE      PTE_BootDes;            // The boot descriptor (should be 0x00 in a non-bootable device)
+    SWORD     PTE_FrstPartSect;       // The cylinder-head-sector address of the first sector of the partition
+    BYTE      PTE_FSDesc;             // The file system descriptor
+    SWORD     PTE_LstPartSect;        // The cylinder-head-sector address of the last sector of the partition
+    DWORD     PTE_FrstSect;           // The logical block address of the first sector of the partition
+    DWORD     PTE_NumSect;            // The number of sectors in a partition
+#if defined __PIC32MX__ || defined __C30__
+    } __attribute__ ((packed)) PTE_MBR;
+#else
+    } PTE_MBR;
+#endif
+
+
+// Summary: A structure of the organization of a master boot record.
+// Description: The _PT_MBR structure has the same form as a master boot record.  When the MBR is loaded from the device, it will
+//              be cast as a _PT_MBR structure so the MBR elements can be accessed.
+typedef struct
+{
+    BYTE        ConsChkRtn[446];        // Boot code
+    PTE_MBR     Partition0;             // The first partition table entry
+    PTE_MBR     Partition1;             // The second partition table entry
+    PTE_MBR     Partition2;             // The third partition table entry
+    PTE_MBR     Partition3;             // The fourth partition table entry
+    BYTE        Signature0;             // MBR signature code - equal to 0x55
+    BYTE        Signature1;             // MBR signature code - equal to 0xAA
+#if defined __PIC32MX__ || defined __C30__
+}__attribute__((packed)) _PT_MBR;
+#else
+}_PT_MBR;
+#endif
+
+// Summary: A pointer to a _PT_MBR structure
+// Description: The PT_MBR pointer points to a _PT_MBR structure.
+typedef _PT_MBR *  PT_MBR;
+
+
+
+// Summary: A structure of the organization of a boot sector.
+// Description: The _BootSec structure has the same form as a boot sector.  When the boot sector is loaded from the device, it will
+//              be cast as a _BootSec structure so the boot sector elements can be accessed.
+typedef struct
+{
+    // A union of different bios parameter blocks
+    union
+    {
+        _BPB_FAT32  FAT_32;
+        _BPB_FAT16  FAT_16;
+        _BPB_FAT12  FAT_12;
+    }FAT;
+    BYTE    Reserved[512-sizeof(_BPB_FAT32)-2]; // Reserved space
+    BYTE    Signature0;         // Boot sector signature code - equal to 0x55
+    BYTE    Signature1;         // Boot sector signature code - equal to 0xAA
+#if defined __PIC32MX__ || defined __C30__
+    } __attribute__ ((packed)) _BootSec;
+#else
+    } _BootSec;
+#endif
+
+// Summary: A pointer to a _BootSec structure
+// Description: The BootSec pointer points to a _BootSec structure.
+typedef _BootSec * BootSec;
+
+
+
+// Summary: A macro indicating the offset for the master boot record
+// Description: FO_MBR is a macro that indicates the addresss of the master boot record on the device.  When the device is initialized
+//              this sector will be read
+#define FO_MBR          0L
+
+
+
+// Summary: A macro for the first boot sector/MBR signature byte
+// Description: The FAT_GOOD_SIGN_0 macro is used to determine that the first byte of the MBR or boot sector signature code is correct
+#define FAT_GOOD_SIGN_0     0x55
+
+// Summary: A macro for the second boot sector/MBR signature byte
+// Description: The FAT_GOOD_SIGN_1 macro is used to determine that the second byte of the MBR or boot sector signature code is correct
+#define FAT_GOOD_SIGN_1     0xAA
+
+
+typedef struct 
+{
+    BYTE    errorCode;
+    union 
+    {
+        BYTE    value;
+        struct 
+        {
+            BYTE    sectorSize  : 1;
+            BYTE    maxLUN      : 1;
+        }   bits;
+    } validityFlags;
+    
+    WORD    sectorSize;
+    BYTE    maxLUN;
+} MEDIA_INFORMATION;
+
+typedef enum
+{
+    MEDIA_NO_ERROR,                     // No errors
+    MEDIA_DEVICE_NOT_PRESENT,           // The requested device is not present
+    MEDIA_CANNOT_INITIALIZE             // Cannot initialize media
+} MEDIA_ERRORS;                
+
+
+/*******************************************************************/
+/*                     Strunctures and defines                     */
+/*******************************************************************/
+
+#ifndef FALSE
+    // Summary: False value
+    // Description:  This macro will indicate that a condition is false.
+    #define FALSE   0
+#endif
+#ifndef TRUE
+    // Summary: True value
+    // Description: This macro will indicate that a condition is true.
+    #define TRUE    !FALSE  // True value
+#endif
+
+
+
+
+#ifndef SEEK_SET
+    // Summary: Macro for the FSfseek SEEK_SET base location.
+    // Description: Functions as an input for FSfseek that specifies that the position in the file will be changed 
+    //              relative to the beginning of the file.
+    #define SEEK_SET 0
+
+#endif
+#ifndef SEEK_CUR
+
+    // Summary: Macro for the FSfseek SEEK_CUR base location.
+    // Description: Functions as an input for FSfseek that specifies that the position in the file will be changed
+    //              relative to the current location of the file
+    #define SEEK_CUR 1
+
+#endif
+#ifndef SEEK_END
+
+    // Summary: Macro for the FSfseek SEEK_END base location
+    // Description: Functions as an input for FSfseek that specifies that the position in the file will be changed
+    //              relative to the end of the file.  For this macro, the offset value will be subtracted from
+    //              the end location of the file by default.
+    #define SEEK_END 2
+
+#endif
+
+
+
+
+// Summary: Macro for the FSfopen FS_APPEND mode
+// Description: If this macro is specified as the mode argument in a call of FSfopen, the file being opened will
+//              be created if it doesn't exist.  If it does exist, it's file information will be loaded and the
+//              current location in the file will be set to the end.  The user will then be able to write to the file.
+#define FS_APPEND   "a"
+#define APPEND  "a"     //deprecated
+
+// Summary: Macro for the FSfopen FS_WRITE mode
+// Description: If this macro is specified as the mode argument in a call of FSfopen, the file being opened will
+//              be created if it doesn't exist.  If it does exist, it will be erased and replaced by an empty file
+//              of the same name.  The user will then be able to write to the file.
+#define FS_WRITE    "w"
+#define WRITE   "w"     //deprecated
+
+// Summary: Macro for the FSfopen FS_READ mode
+// Description: If this macro is specified as the mode argument in a call of FSfopen, the file information for the 
+//              specified file will be loaded.  If the file does not exist, the FSfopen function will fail.  The user 
+//              will then be able to read from the file.
+#define FS_READ "r"
+#if defined(__32MX795F512L__)
+//    #warning FSfopen must use "r" and not READ as input on this device
+#else
+    #define READ    "r"     //deprecated
+#endif
+
+// Summary: Macro for the FSfopen FS_APPEND+ mode
+// Description: If this macro is specified as the mode argument in a call of FSfopen, the file being opened will
+//              be created if it doesn't exist.  If it does exist, it's file information will be loaded and the
+//              current location in the file will be set to the end.  The user will then be able to write to the file
+//              or read from the file.
+#define FS_APPENDPLUS   "a+"
+#define APPENDPLUS "a+"     //deprecated
+
+// Summary: Macro for the FSfopen FS_WRITE+ mode
+// Description: If this macro is specified as the mode argument in a call of FSfopen, the file being opened will
+//              be created if it doesn't exist.  If it does exist, it will be erased and replaced by an empty file
+//              of the same name.  The user will then be able to write to the file or read from the file.
+#define FS_WRITEPLUS    "w+"
+#define WRITEPLUS  "w+"     //deprecated
+
+// Summary: Macro for the FSfopen FS_READ+ mode
+// Description: If this macro is specified as the mode argument in a call of FSfopen, the file information for the 
+//              specified file will be loaded.  If the file does not exist, the FSfopen function will fail.  The user 
+//              will then be able to read from the file or write to the file.
+#define FS_READPLUS     "r+"
+#define READPLUS   "r+"     //deprecated
+
+
+
+#ifndef intmax_t
+    #ifdef __PIC24F__
+        // Summary: A data type indicating the maximum integer size in an architecture
+        // Description: The intmax_t data type refers to the maximum-sized data type on any given architecture.  This
+        //              data type can be specified as a format specifier size specification for the FSfprintf function.
+        #define intmax_t long long
+    #elif defined __PIC24H__
+        #define intmax_t long long
+    #elif defined __dsPIC30F__
+        #define intmax_t long long
+    #elif defined __dsPIC33F__
+        #define intmax_t long long
+    #endif
+#endif
+
+
+
+// Summary:  Indicates flag conditions for a file object
+// Description: The FILEFLAGS structure is used to indicate conditions in a file.  It contains three flags: 'write' indicates
+//              that the file was opened in a mode that allows writes, 'read' indicates that the file was opened in a mode
+//              that allows reads, and 'FileWriteEOF' indicates that additional data that is written to the file will increase
+//              the file size.
+typedef struct
+{
+    unsigned    write :1;           // Indicates a file was opened in a mode that allows writes
+    unsigned    read :1;            // Indicates a file was opened in a mode that allows reads
+    unsigned    FileWriteEOF :1;    // Indicates the current position in a file is at the end of the file
+}FILEFLAGS;
+
+
+
+// Summary: Indicates how to search for file entries in the FILEfind function
+// Description: The values in the SEARCH_TYPE enumeration are used internally by the library to indicate how the FILEfind function
+//              how to perform a search.  The 'LOOK_FOR_EMPTY_ENTRY' value indicates that FILEfind should search for an empty file entry.
+//              The 'LOOK_FOR_MATCHING_ENTRY' value indicates that FILEfind should search for an entry that matches the FSFILE object
+//              that was passed into the FILEfind function.
+typedef enum{
+    LOOK_FOR_EMPTY_ENTRY = 0,
+    LOOK_FOR_MATCHING_ENTRY
+} SEARCH_TYPE;
+
+
+
+// Summary: Macro indicating the length of a 8.3 file name
+// Description: The TOTAL_FILE_SIZE_8P3 macro indicates the maximum number of characters in an 8.3 file name.  This value includes
+//              8 characters for the name, three for the extentsion, and 1 for the radix ('.')
+#define TOTAL_FILE_SIZE_8P3             (8+3+1)
+#define TOTAL_FILE_SIZE                 TOTAL_FILE_SIZE_8P3
+
+// Summary: Macro indicating the max length of a LFN file name
+// Description: The MAX_FILE_NAME_LENGTH_LFN macro indicates the maximum number of characters in an LFN file name.
+#define MAX_FILE_NAME_LENGTH_LFN             256
+
+// Summary: A mask that indicates the limit of directory entries in a sector
+// Description: The MASK_MAX_FILE_ENTRY_LIMIT_BITS is used to indicate to the Cache_File_Entry function that a new sector needs to
+//              be loaded.
+#define MASK_MAX_FILE_ENTRY_LIMIT_BITS          0x0f
+
+// Summary: Value used for shift operations to calculate the sector offset in a directory
+// Description: The VALUE_BASED_ON_ENTRIES_PER_CLUSTER macro is used to calculate sector offsets for directories.  The position of the
+//              entry is shifted by 4 bits (divided by 16, since there are 16 entries in a sector) to calculate how many sectors a
+//              specified entry is offset from the beginning of the directory.
+#define VALUE_BASED_ON_ENTRIES_PER_CLUSTER      4
+
+// Summary: A value that will indicate that a dotdot directory entry points to the root.
+// Description: The VALUE_DOTDOT_CLUSTER_VALUE_FOR_ROOT macro is used as an absolute address when writing information to a dotdot entry
+//              in a newly created directory.  If a dotdot entry points to the root directory, it's cluster value must be set to 0,
+//              regardless of the actual cluster number of the root directory.
+#define VALUE_DOTDOT_CLUSTER_VALUE_FOR_ROOT     0
+
+// Summary: MAcro indicating the length of an 8.3 file name in a directory entry
+// Description: The FILE_NAME_SIZE_8P3 macro indicates the number of characters that an 8.3 file name will take up when packed in
+//              a directory entry.  This value includes 8 characters for the name and 3 for the extension.  Note that the radix is not
+//              stored in the directory entry.
+#define FILE_NAME_SIZE_8P3           11
+#define FILE_NAME_SIZE               FILE_NAME_SIZE_8P3
+
+
+// Summary: Contains file information and is used to indicate which file to access.
+// Description: The FSFILE structure is used to hold file information for an open file as it's being modified or accessed.  A pointer to 
+//              an open file's FSFILE structure will be passeed to any library function that will modify that file.
+typedef struct
+{
+    DISK    *       dsk;            // Pointer to a DISK structure
+    DWORD           cluster;        // The first cluster of the file
+    DWORD           ccls;           // The current cluster of the file
+    WORD            sec;            // The current sector in the current cluster of the file
+    WORD            pos;            // The position in the current sector
+    DWORD           seek;           // The absolute position in the file
+    DWORD           size;           // The size of the file
+    FILEFLAGS       flags;          // A structure containing file flags
+    WORD            time;           // The file's last update time
+    WORD            date;           // The file's last update date
+    char            name[FILE_NAME_SIZE_8P3];       // The short name of the file
+	#ifdef SUPPORT_LFN
+    	BOOL			AsciiEncodingType;          // Ascii file name or Non-Ascii file name indicator
+		unsigned short int *utf16LFNptr;	        // Pointer to long file name in UTF16 format
+		unsigned short int utf16LFNlength;          // LFN length in terms of words including the NULL word at the last.
+	#endif
+    WORD            entry;          // The position of the file's directory entry in it's directory
+    WORD            chk;            // File structure checksum
+    WORD            attributes;     // The file attributes
+    DWORD           dirclus;        // The base cluster of the file's directory
+    DWORD           dirccls;        // The current cluster of the file's directory
+} FSFILE;
+
+/* Summary: Possible results of the FSGetDiskProperties() function.
+** Description: See the FSGetDiskProperties() function for more information.
+*/
+typedef enum
+{
+    FS_GET_PROPERTIES_NO_ERRORS = 0,
+    FS_GET_PROPERTIES_DISK_NOT_MOUNTED,
+    FS_GET_PROPERTIES_CLUSTER_FAILURE,
+    FS_GET_PROPERTIES_STILL_WORKING = 0xFF
+} FS_DISK_ERRORS;
+
+
+/* Summary: Contains the disk search information, intermediate values, and results
+** Description: This structure is used in conjunction with the FSGetDiskProperties()
+**              function.  See that function for more information about the usage.
+*/
+typedef struct
+{
+    DISK *  disk;           /* pointer to the disk we are searching */
+    BOOL    new_request;    /* is this a new request or a continued request */
+    FS_DISK_ERRORS properties_status;  /* status of the last call of the function */
+
+    struct
+    {
+        BYTE disk_format;           /* disk format: FAT12, FAT16, FAT32 */
+        WORD sector_size;           /* sector size of the drive */
+        BYTE sectors_per_cluster;   /* number of sectors per cluster */
+        DWORD total_clusters;       /* the number of total clusters on the drive */
+        DWORD free_clusters;        /* the number of free (unused) clusters on drive */
+    } results;                      /* the results of the current search */
+
+    struct
+    {
+        DWORD   c;     
+        DWORD   curcls;
+        DWORD   EndClusterLimit;
+        DWORD   ClusterFailValue;
+    } private;      /* intermediate values used to continue searches.  This
+                         member should be used only by the FSGetDiskProperties()
+                         function */
+
+} FS_DISK_PROPERTIES;
+
+// Summary: A structure used for searching for files on a device.
+// Description: The SearchRec structure is used when searching for file on a device.  It contains parameters that will be loaded with
+//              file information when a file is found.  It also contains the parameters that the user searched for, allowing further
+//              searches to be perfomed in the same directory for additional files that meet the specified criteria.
+typedef struct
+{
+    char            filename[FILE_NAME_SIZE_8P3 + 2];   // The name of the file that has been found
+    unsigned char   attributes;                     // The attributes of the file that has been found
+    unsigned long   filesize;                       // The size of the file that has been found
+    unsigned long   timestamp;                      // The last modified time of the file that has been found (create time for directories)
+	#ifdef SUPPORT_LFN
+		BOOL			AsciiEncodingType;          // Ascii file name or Non-Ascii file name indicator
+		unsigned short int *utf16LFNfound;		    // Pointer to long file name found in UTF16 format
+		unsigned short int utf16LFNfoundLength;     // LFN Found length in terms of words including the NULL word at the last.
+	#endif
+    unsigned int    entry;                          // The directory entry of the last file found that matches the specified attributes. (Internal use only)
+    char            searchname[FILE_NAME_SIZE_8P3 + 2]; // The 8.3 format name specified when the user began the search. (Internal use only)
+    unsigned char   searchattr;                     // The attributes specified when the user began the search. (Internal use only)
+    unsigned long   cwdclus;                        // The directory that this search was performed in. (Internal use only)
+    unsigned char   initialized;                    // Check to determine if the structure was initialized by FindFirst (Internal use only)
+} SearchRec;
+
+
+/***************************************************************************
+* Prototypes                                                               *
+***************************************************************************/
+
+
+
+
+/*************************************************************************
+  Function:
+    int FSInit(void)
+  Summary:
+    Function to initialize the device.
+  Conditions:
+    The physical device should be connected to the microcontroller.
+  Input:
+    None
+  Return Values:
+    TRUE -  Initialization successful
+    FALSE - Initialization unsuccessful
+  Side Effects:
+    The FSerrno variable will be changed.
+  Description:
+    Initializes the static or dynamic memory slots for holding file
+    structures.  Initializes the device with the DISKmount function. Loads 
+    MBR and boot sector information.  Initializes the current working
+    directory to the root directory for the device if directory support
+    is enabled.
+  Remarks:
+    None
+  *************************************************************************/
+
+int FSInit(void);
+
+
+/*********************************************************************
+  Function:
+    FSFILE * FSfopen (const char * fileName, const char *mode)
+  Summary:
+    Open a Ascii file
+  Conditions:
+    For read modes, file exists; FSInit performed
+  Input:
+    fileName -  The name of the file to open
+    mode -
+         - WRITE -      Create a new file or replace an existing file
+         - READ -       Read data from an existing file
+         - APPEND -     Append data to an existing file
+         - WRITEPLUS -  Create a new file or replace an existing file (reads also enabled)
+         - READPLUS -   Read data from an existing file (writes also enabled)
+         - APPENDPLUS - Append data to an existing file (reads also enabled)
+  Return Values:
+    FSFILE * - The pointer to the file object
+    NULL -     The file could not be opened
+  Side Effects:
+    The FSerrno variable will be changed.
+  Description:
+    This function will open a file or directory.  First, RAM in the
+    dynamic heap or static array will be allocated to a new FSFILE object.
+    Then, the specified file name will be formatted to ensure that it's
+    in 8.3 format or LFN format. Next, the FILEfind function will be used
+    to search for the specified file name. If the name is found, one of three
+    things will happen: if the file was opened in read mode, its file
+    info will be loaded using the FILEopen function; if it was opened in
+    write mode, it will be erased, and a new file will be constructed in
+    its place; if it was opened in append mode, its file info will be
+    loaded with FILEopen and the current location will be moved to the
+    end of the file using the FSfseek function.  If the file was not
+    found by FILEfind, a new file will be created if the mode was specified as
+    a write or append mode.  In these cases, a pointer to the heap or
+    static FSFILE object array will be returned. If the file was not
+    found and the mode was specified as a read mode, the memory
+    allocated to the file will be freed and the NULL pointer value
+    will be returned.
+  Remarks:
+    None.
+  *********************************************************************/
+
+FSFILE * FSfopen(const char * fileName, const char *mode);
+
+#ifdef SUPPORT_LFN
+/*********************************************************************
+  Function:
+    FSFILE * wFSfopen (const unsigned short int * fileName, const char *mode)
+  Summary:
+    Open a UTF16 file.
+  Conditions:
+    For read modes, file exists; FSInit performed
+  Input:
+    fileName -  The name of the file to open
+    mode -
+         - WRITE -      Create a new file or replace an existing file
+         - READ -       Read data from an existing file
+         - APPEND -     Append data to an existing file
+         - WRITEPLUS -  Create a new file or replace an existing file (reads also enabled)
+         - READPLUS -   Read data from an existing file (writes also enabled)
+         - APPENDPLUS - Append data to an existing file (reads also enabled)
+  Return Values:
+    FSFILE * - The pointer to the file object
+    NULL -     The file could not be opened
+  Side Effects:
+    The FSerrno variable will be changed.
+  Description:
+    This function will open a file or directory.  First, RAM in the
+    dynamic heap or static array will be allocated to a new FSFILE object.
+    Then, the specified file name will be formatted to ensure that it's
+    in 8.3 format or LFN format. Next, the FILEfind function will be used
+    to search for the specified file name. If the name is found, one of three
+    things will happen: if the file was opened in read mode, its file
+    info will be loaded using the FILEopen function; if it was opened in
+    write mode, it will be erased, and a new file will be constructed in
+    its place; if it was opened in append mode, its file info will be
+    loaded with FILEopen and the current location will be moved to the
+    end of the file using the FSfseek function.  If the file was not
+    found by FILEfind, a new file will be created if the mode was specified as
+    a write or append mode.  In these cases, a pointer to the heap or
+    static FSFILE object array will be returned. If the file was not
+    found and the mode was specified as a read mode, the memory
+    allocated to the file will be freed and the NULL pointer value
+    will be returned.
+  Remarks:
+    None.
+  *********************************************************************/
+
+FSFILE * wFSfopen(const unsigned short int * fileName, const char *mode);
+#endif
+
+#ifdef ALLOW_PGMFUNCTIONS
+
+/******************************************************************************
+  Function:
+    FSFILE * FSfopenpgm(const rom char * fileName, const rom char *mode)
+  Summary:
+    Open a Ascii file named with a ROM string on PIC18
+  Conditions:
+    For read modes, file exists; FSInit performed
+  Input:
+    fileName -  The name of the file to be opened (ROM)
+    mode -      The mode the file will be opened in (ROM)
+  Return Values:
+    FSFILE * - A pointer to the file object
+    NULL -     File could not be opened
+  Side Effects:
+    The FSerrno variable will be changed.
+  Description:
+    The FSfopenpgm function will copy a PIC18 ROM fileName and mode argument
+    into RAM arrays, and then pass those arrays to the FSfopen function.
+  Remarks:
+    This function is for use with PIC18 when passing arguments in ROM.
+  ******************************************************************************/
+
+    FSFILE * FSfopenpgm(const rom char * fileName, const rom char *mode);
+
+
+/**************************************************************************************
+  Function:
+    int FindFirstpgm (const char * fileName, unsigned int attr, SearchRec * rec)
+  Summary:
+    Find a file named with a ROM string on PIC18
+  Conditions:
+    None
+  Input:
+    fileName -  The name of the file to be found (ROM)
+    attr -      The attributes of the file to be found
+    rec -       Pointer to a search record to store the file info in
+  Return Values:
+    0 -  File was found
+    -1 - No file matching the given parameters was found
+  Side Effects:
+    Search criteria from previous FindFirstpgm call on passed SearchRec object
+    will be lost.The FSerrno variable will be changed.
+  Description:
+    The FindFirstpgm function will copy a PIC18 ROM fileName argument
+    into a RAM array, and then pass that array to the FindFirst function.
+  Remarks:
+    Call FindFirstpgm or FindFirst before calling FindNext.
+    This function is for use with PIC18 when passing arguments in ROM.
+  **************************************************************************************/
+
+    int FindFirstpgm (const rom char * fileName, unsigned int attr, SearchRec * rec);
+
+
+/**************************************************************************
+  Function:
+    int FSchdirpgm (const rom char * path)
+  Summary:
+    Changed the CWD with a path in ROM on PIC18
+  Conditions:
+    None
+  Input:
+    path - The path of the directory to change to (ROM)
+  Return Values:
+    0 -   The current working directory was changed successfully
+    EOF - The current working directory could not be changed
+  Side Effects:
+    The current working directory may be changed. The FSerrno variable will
+    be changed.
+  Description:
+    The FSchdirpgm function passes a PIC18 ROM path pointer to the
+    chdirhelper function.
+  Remarks:
+    This function is for use with PIC18 when passing arguments in ROM
+  **************************************************************************/
+
+    int FSchdirpgm (const rom char * path);
+
+    #ifdef ALLOW_WRITES
+
+
+/*************************************************************
+  Function:
+    int FSremovepgm (const rom char * fileName)
+  Summary:
+    Delete a file named with a ROM string on PIC18
+  Conditions:
+    File not opened; file exists
+  Input:
+    fileName -  The name of the file to be deleted (ROM)
+  Return Values:
+    0 -  File was removed successfully
+    -1 - File could not be removed
+  Side Effects:
+    The FSerrno variable will be changed.
+  Description:
+    The FSremovepgm function will copy a PIC18 ROM fileName argument
+    into a RAM array, and then pass that array to the FSremove function.
+  Remarks:
+    This function is for use with PIC18 when passing arguments in ROM.
+  *************************************************************/
+
+        int FSremovepgm (const rom char * fileName);
+
+
+/**************************************************************************
+  Function:
+    int FSmkdirpgm (const rom char * path)
+  Summary:
+    Create a directory with a path in ROM on PIC18
+  Conditions:
+    None
+  Input:
+    path - The path of directories to create (ROM)
+  Return Values:
+    0 -   The specified directory was created successfully
+    EOF - The specified directory could not be created
+  Side Effects:
+    Will create all non-existent directories in the path. The FSerrno 
+    variable will be changed.
+  Description:
+    The FSmkdirpgm function passes a PIC18 ROM path pointer to the
+    mkdirhelper function.
+  Remarks:
+    This function is for use with PIC18 when passing arugments in ROM
+  **************************************************************************/
+
+        int FSmkdirpgm (const rom char * path);
+
+
+/**************************************************************************
+  Function:
+    int FSrmdirpgm (const rom char * path)
+  Summary:
+    Delete a directory with a path in ROM on PIC18
+  Conditions:
+    None.
+  Input:
+    path -      The path of the directory to remove (ROM)
+    rmsubdirs - 
+              - TRUE -  All sub-dirs and files in the target dir will be removed
+              - FALSE - FSrmdir will not remove non-empty directories
+  Return Values:
+    0 -   The specified directory was deleted successfully
+    EOF - The specified directory could not be deleted
+  Side Effects:
+    The FSerrno variable will be changed.
+  Description:
+    The FSrmdirpgm function passes a PIC18 ROM path pointer to the
+    rmdirhelper function.
+  Remarks:
+    This function is for use with PIC18 when passing arguments in ROM.
+  **************************************************************************/
+
+        int FSrmdirpgm (const rom char * path, unsigned char rmsubdirs);
+
+
+/*****************************************************************
+  Function:
+    int FSrenamepgm(const rom char * fileName, FSFILE * fo)
+  Summary:
+    Rename a file named with a ROM string on PIC18
+  Conditions:
+    File opened.
+  Input:
+    fileName -  The new name of the file (in ROM)
+    fo -        The file to rename
+  Return Values:
+    0 -  File renamed successfully
+    -1 - File could not be renamed
+  Side Effects:
+    The FSerrno variable will be changed.
+  Description:
+    The Fsrenamepgm function will copy the rom fileName specified
+    by the user into a RAM array and pass that array into the
+    FSrename function.
+  Remarks:
+    This function is for use with PIC18 when passing arguments in ROM.                       
+  *****************************************************************/
+
+        int FSrenamepgm (const rom char * fileName, FSFILE * fo);
+    #endif
+#endif
+
+
+/************************************************************
+  Function:
+    int FSfclose(FSFILE *fo)
+  Summary:
+    Update file information and free FSFILE objects
+  Conditions:
+    File opened
+  Input:
+    fo -  Pointer to the file to close
+  Return Values:
+    0 -   File closed successfully 
+    EOF - Error closing the file
+  Side Effects:
+    The FSerrno variable will be changed.
+  Description:
+    This function will update the directory entry for the 
+    file pointed to by 'fo' with the information contained
+    in 'fo,' including the new file size and attributes.
+    Timestamp information will also be loaded based on the
+    method selected by the user and written to the entry
+    as the last modified time and date.  The file entry will
+    then be written to the device.  Finally, the memory
+    used for the specified file object will be freed from
+    the dynamic heap or the array of FSFILE objects.
+  Remarks:
+    A function to flush data to the device without closing the
+    file can be created by removing the portion of this
+    function that frees the memory and the line that clears
+    the write flag.
+  ************************************************************/
+
+int FSfclose(FSFILE *fo);
+
+
+/*********************************************************
+  Function:
+    void FSrewind (FSFILE * fo)
+  Summary:
+    Set the current position in a file to the beginning
+  Conditions:
+    File opened.
+  Input:
+    fo -  Pointer to file structure
+  Return Values:
+    None
+  Side Effects:
+    None.
+  Description:
+    The FSrewind funciton will reset the position of the
+    specified file to the beginning of the file.  This
+    functionality is faster than using FSfseek to reset
+    the position in the file.
+  Remarks:
+    None.
+  *********************************************************/
+
+void FSrewind (FSFILE *fo);
+
+
+/**************************************************************************
+  Function:
+    size_t FSfread(void *ptr, size_t size, size_t n, FSFILE *stream)
+  Summary:
+    Read data from a file
+  Conditions:
+    File is opened in a read mode
+  Input:
+    ptr -     Destination buffer for read bytes
+    size -    Size of units in bytes
+    n -       Number of units to be read
+    stream -  File to be read from
+  Return:
+    size_t - number of units read
+  Side Effects:
+    The FSerrno variable will be changed.
+  Description:
+    The FSfread function will read data from the specified file.  First,
+    the appropriate sector of the file is loaded.  Then, data is read into
+    the specified buffer until the specified number of bytes have been read.
+    When a cluster boundary is reached, a new cluster will be loaded.  The
+    parameters 'size' and 'n' indicate how much data to read.  'Size'
+    refers to the size of one object to read (in bytes), and 'n' will refer 
+    to the number of these objects to read.  The value returned will be equal 
+    to 'n' unless an error occured or the user tried to read beyond the end
+    of the file.
+  Remarks:
+    None.
+  **************************************************************************/
+
+size_t FSfread(void *ptr, size_t size, size_t n, FSFILE *stream);
+
+
+/**********************************************************************
+  Function:
+    int FSfseek(FSFILE *stream, long offset, int whence)
+  Summary:
+    Change the current position in a file
+  Conditions:
+    File opened
+  Input:
+    stream -    Pointer to file structure
+    offset -    Offset from base location
+    whence -    
+           - SEEK_SET -  Seek from start of file
+           - SEEK_CUR -  Seek from current location
+           - SEEK_END -  Seek from end of file (subtract offset)
+  Return Values:
+    0 -  Operation successful 
+    -1 - Operation unsuccesful
+  Side Effects:
+    The FSerrno variable will be changed.
+  Description:
+    The FSfseek function will change the current position in the file to
+    one specified by the user.  First, an absolute offset is calculated
+    using the offset and base location passed in by the user.  Then, the
+    position variables are updated, and the sector number that corresponds
+    to the new location.  That sector is then loaded.  If the offset
+    falls exactly on a cluster boundary, a new cluster will be allocated
+    to the file and the position will be set to the first byte of that
+    cluster.
+  Remarks:
+    None                                                               
+  **********************************************************************/
+
+int FSfseek(FSFILE *stream, long offset, int whence);
+
+
+/*******************************************************************
+  Function:
+    long FSftell (FSFILE * fo)
+  Summary:
+    Determine the current location in a file
+  Conditions:
+    File opened
+  Input:
+    fo -  Pointer to file structure
+  Return: Current location in the file
+  Side Effects:
+    The FSerrno variable will be changed
+  Description:
+    The FSftell function will return the current position in the
+    file pointed to by 'fo' by returning the 'seek' variable in the
+    FSFILE object, which is used to keep track of the absolute
+    location of the current position in the file.
+  Remarks:
+    None                                                            
+  *******************************************************************/
+
+long FSftell(FSFILE *fo);
+
+
+/****************************************************
+  Function:
+    int FSfeof( FSFILE * stream )
+  Summary:
+    Indicate whether the current file position is at the end
+  Conditions:
+    File is open in a read mode
+  Input:
+    stream -  Pointer to the target file
+  Return Values:
+    Non-Zero - EOF reached 
+    0 - Not at end of File
+  Side Effects:
+    The FSerrno variable will be changed.
+  Description:
+    The FSfeof function will indicate that the end-of-
+    file has been reached for the specified file by
+    comparing the absolute location in the file to the
+    size of the file.
+  Remarks:
+    None.
+  ****************************************************/
+
+int FSfeof( FSFILE * stream );
+
+
+#ifdef ALLOW_FORMATS
+/*******************************************************************
+  Function:
+    int FSformat (char mode, long int serialNumber, char * volumeID)
+  Summary:
+    Formats a device
+  Conditions:
+    The device must possess a valid master boot record.
+  Input:
+    mode -          - 0 - Just erase the FAT and root
+                    - 1 - Create a new boot sector
+    serialNumber -  Serial number to write to the card
+    volumeID -      Name of the card
+  Return Values:
+    0 -    Format was successful
+    EOF -  Format was unsuccessful
+  Side Effects:
+    The FSerrno variable will be changed.
+  Description:
+    The FSformat function can be used to create a new boot sector
+    on a device, based on the information in the master boot record.
+    This function will first initialize the I/O pins and the device,
+    and then attempts to read the master boot record.  If the MBR
+    cannot be loaded successfully, the function will fail.  Next, if
+    the 'mode' argument is specified as '0' the existing boot sector
+    information will be loaded.  If the 'mode' argument is '1' an
+    entirely new boot sector will be constructed using the disk
+    values from the master boot record.  Once the boot sector has
+    been successfully loaded/created, the locations of the FAT and
+    root will be loaded from it, and they will be completely
+    erased.  If the user has specified a volumeID parameter, a 
+    VOLUME attribute entry will be created in the root directory
+    to name the device.
+
+    FAT12, FAT16 and FAT32 formatting are supported.
+
+    Based on the number of sectors, the format function automatically
+    compute the smallest possible value for the cluster size in order to
+    accommodate the physical size of the media. In this case, if a media 
+    with a big capacity is formatted, the format function may take a very
+    long time to write all the FAT tables. 
+
+    Therefore, the FORMAT_SECTORS_PER_CLUSTER macro may be used to 
+    specify the exact cluster size (in multiples of sector size). This 
+    macro can be defined in FSconfig.h
+
+  Remarks:
+    Only devices with a sector size of 512 bytes are supported by the 
+    format function                      
+  *******************************************************************/
+
+int FSformat (char mode, long int serialNumber, char * volumeID);
+#endif
+
+
+#ifdef ALLOW_WRITES
+/***************************************************************************
+  Function:
+    int FSattrib (FSFILE * file, unsigned char attributes)
+  Summary:
+    Change the attributes of a file
+  Conditions:
+    File opened
+  Input:
+    file -        Pointer to file structure
+    attributes -  The attributes to set for the file
+               -  Attribute -      Value - Indications 
+               -  ATTR_READ_ONLY - 0x01  - The read-only attribute
+               -  ATTR_HIDDEN -    0x02  - The hidden attribute 
+               -  ATTR_SYSTEM -    0x04  - The system attribute 
+               -  ATTR_ARCHIVE -   0x20  - The archive attribute
+  Return Values:
+    0 -  Attribute change was successful 
+    -1 - Attribute change was unsuccessful
+  Side Effects:
+    The FSerrno variable will be changed.
+  Description:
+    The FSattrib funciton will set the attributes of the specified file
+    to the attributes passed in by the user.  This function will load the
+    file entry, replace the attributes with the ones specified, and write
+    the attributes back.  If the specified file is a directory, the
+    directory attribute will be preserved.
+  Remarks:
+    None                                                                
+  ***************************************************************************/
+
+int FSattrib (FSFILE * file, unsigned char attributes);
+
+
+/***************************************************************
+  Function:
+    int FSrename (const rom char * fileName, FSFILE * fo)
+  Summary:
+    Change the Ascii name of a file or directory
+  Conditions:
+    File opened.
+  Input:
+    fileName -  The new name of the file
+    fo -        The file to rename
+  Return Values:
+    0 -   File was renamed successfully
+    EOF - File was not renamed
+  Side Effects:
+    The FSerrno variable will be changed.
+  Description:
+    The FSrename function will rename a file.  First, it will
+    search through the current working directory to ensure the
+    specified new filename is not already in use.  If it isn't,
+    the new filename will be written to the file entry of the
+    file pointed to by 'fo.'
+  Remarks:
+    None                                                        
+  ***************************************************************/
+
+int FSrename (const char * fileName, FSFILE * fo);
+
+#ifdef SUPPORT_LFN
+/***************************************************************
+  Function:
+    int wFSrename (const rom unsigned short int * fileName, FSFILE * fo)
+  Summary:
+    Change the name of a file or directory to the UTF16 input fileName
+  Conditions:
+    File opened.
+  Input:
+    fileName -  The new name of the file
+    fo -        The file to rename
+  Return Values:
+    0 -   File was renamed successfully
+    EOF - File was not renamed
+  Side Effects:
+    The FSerrno variable will be changed.
+  Description:
+    The wFSrename function will rename a file.  First, it will
+    search through the current working directory to ensure the
+    specified new UTF16 filename is not already in use.  If it isn't,
+    the new filename will be written to the file entry of the
+    file pointed to by 'fo.'
+  Remarks:
+    None
+  ***************************************************************/
+
+int wFSrename (const unsigned short int * fileName, FSFILE * fo);
+#endif
+
+/*********************************************************************
+  Function:
+    int FSremove (const char * fileName)
+  Summary:
+    Delete a Ascii file
+  Conditions:
+    File not opened, file exists
+  Input:
+    fileName -  Name of the file to erase
+  Return Values:
+    0 -   File removed 
+    EOF - File was not removed
+  Side Effects:
+    The FSerrno variable will be changed.
+  Description:
+    The FSremove function will attempt to find the specified file with
+    the FILEfind function.  If the file is found, it will be erased
+    using the FILEerase function.The user can also provide ascii alias name
+    of the ascii long file name as the input to this function to get it erased
+    from the memory.
+  Remarks:
+    None                                       
+  **********************************************************************/
+
+int FSremove (const char * fileName);
+
+#ifdef SUPPORT_LFN
+/*********************************************************************
+  Function:
+    int wFSremove (const unsigned short int * fileName)
+  Summary:
+    Delete a UTF16 file
+  Conditions:
+    File not opened, file exists
+  Input:
+    fileName -  Name of the file to erase
+  Return Values:
+    0 -   File removed
+    EOF - File was not removed
+  Side Effects:
+    The FSerrno variable will be changed.
+  Description:
+    The wFSremove function will attempt to find the specified UTF16 file
+    name with the FILEfind function. If the file is found, it will be erased
+    using the FILEerase function.
+  Remarks:
+    None
+  **********************************************************************/
+
+int wFSremove (const unsigned short int * fileName);
+#endif
+
+/*********************************************************************************
+  Function:
+    size_t FSfwrite(const void *ptr, size_t size, size_t n, FSFILE *stream)
+  Summary:
+    Write data to a file
+  Conditions:
+    File opened in WRITE, APPEND, WRITE+, APPEND+, READ+ mode
+  Input:
+    ptr -     Pointer to source buffer
+    size -    Size of units in bytes
+    n -       Number of units to transfer
+    stream -  Pointer to file structure
+  Return:
+    size_t - number of units written
+  Side Effects:
+    The FSerrno variable will be changed.
+  Description:
+    The FSfwrite function will write data to a file.  First, the sector that
+    corresponds to the current position in the file will be loaded (if it hasn't
+    already been cached in the global data buffer).  Data will then be written to
+    the device from the specified buffer until the specified amount has been written.
+    If the end of a cluster is reached, the next cluster will be loaded, unless
+    the end-of-file flag for the specified file has been set.  If it has, a new
+    cluster will be allocated to the file.  Finally, the new position and filesize
+    will be stored in the FSFILE object.  The parameters 'size' and 'n' indicate how 
+    much data to write.  'Size' refers to the size of one object to write (in bytes), 
+    and 'n' will refer to the number of these objects to write.  The value returned 
+    will be equal  to 'n' unless an error occured.
+  Remarks:
+    None.
+  *********************************************************************************/
+
+size_t FSfwrite(const void *ptr, size_t size, size_t n, FSFILE *stream);
+
+#endif
+
+#ifdef ALLOW_DIRS
+
+
+/**************************************************************************
+  Function:
+    int FSchdir (char * path)
+  Summary:
+    Change the current working directory as per the path specified in Ascii format
+  Conditions:
+    None
+  Input:
+    path - The path of the directory to change to.
+  Return Values:
+    0 -   The current working directory was changed successfully
+    EOF - The current working directory could not be changed
+  Side Effects:
+    The current working directory may be changed. The FSerrno variable will
+    be changed.
+  Description:
+    The FSchdir function passes a RAM pointer to the path to the
+    chdirhelper function.
+  Remarks:
+    None                                            
+  **************************************************************************/
+
+int FSchdir (char * path);
+
+#ifdef SUPPORT_LFN
+/**************************************************************************
+  Function:
+    int wFSchdir (unsigned short int * path)
+  Summary:
+    Change the current working directory as per the path specified in UTF16 format
+  Conditions:
+    None
+  Input:
+    path - The path of the directory to change to.
+  Return Values:
+    0 -   The current working directory was changed successfully
+    EOF - The current working directory could not be changed
+  Side Effects:
+    The current working directory may be changed. The FSerrno variable will
+    be changed.
+  Description:
+    The FSchdir function passes a RAM pointer to the path to the
+    chdirhelper function.
+  Remarks:
+    None                                            
+  **************************************************************************/
+
+int wFSchdir (unsigned short int * path);
+#endif
+
+/**************************************************************
+  Function:
+    char * FSgetcwd (char * path, int numchars)
+  Summary:
+    Get the current working directory path in Ascii format
+  Conditions:
+    None
+  Input:
+    path -      Pointer to the array to return the cwd name in
+    numchars -  Number of chars in the path
+  Return Values:
+    char * - The cwd name string pointer (path or defaultArray)
+    NULL -   The current working directory name could not be loaded.
+  Side Effects:
+    The FSerrno variable will be changed
+  Description:
+    The FSgetcwd function will get the name of the current
+    working directory and return it to the user.  The name
+    will be copied into the buffer pointed to by 'path,'
+    starting at the root directory and copying as many chars
+    as possible before the end of the buffer.  The buffer
+    size is indicated by the 'numchars' argument.  The first
+    thing this function will do is load the name of the current
+    working directory, if it isn't already present.  This could
+    occur if the user switched to the dotdot entry of a
+    subdirectory immediately before calling this function.  The
+    function will then copy the current working directory name 
+    into the buffer backwards, and insert a backslash character.  
+    Next, the function will continuously switch to the previous 
+    directories and copy their names backwards into the buffer
+    until it reaches the root.  If the buffer overflows, it
+    will be treated as a circular buffer, and data will be
+    copied over existing characters, starting at the beginning.
+    Once the root directory is reached, the text in the buffer
+    will be swapped, so that the buffer contains as much of the
+    current working directory name as possible, starting at the 
+    root.
+  Remarks:
+    None                                                       
+  **************************************************************/
+
+char * FSgetcwd (char * path, int numbchars);
+
+#ifdef SUPPORT_LFN
+/**************************************************************
+  Function:
+    char * wFSgetcwd (unsigned short int * path, int numchars)
+  Summary:
+    Get the current working directory path in UTF16 format
+  Conditions:
+    None
+  Input:
+    path -      Pointer to the array to return the cwd name in
+    numchars -  Number of chars in the path
+  Return Values:
+    char * - The cwd name string pointer (path or defaultArray)
+    NULL -   The current working directory name could not be loaded.
+  Side Effects:
+    The FSerrno variable will be changed
+  Description:
+    The FSgetcwd function will get the name of the current
+    working directory and return it to the user.  The name
+    will be copied into the buffer pointed to by 'path,'
+    starting at the root directory and copying as many chars
+    as possible before the end of the buffer.  The buffer
+    size is indicated by the 'numchars' argument.  The first
+    thing this function will do is load the name of the current
+    working directory, if it isn't already present.  This could
+    occur if the user switched to the dotdot entry of a
+    subdirectory immediately before calling this function.  The
+    function will then copy the current working directory name 
+    into the buffer backwards, and insert a backslash character.  
+    Next, the function will continuously switch to the previous 
+    directories and copy their names backwards into the buffer
+    until it reaches the root.  If the buffer overflows, it
+    will be treated as a circular buffer, and data will be
+    copied over existing characters, starting at the beginning.
+    Once the root directory is reached, the text in the buffer
+    will be swapped, so that the buffer contains as much of the
+    current working directory name as possible, starting at the 
+    root.
+  Remarks:
+    None                                                       
+  **************************************************************/
+
+char * wFSgetcwd (unsigned short int * path, int numbchars);
+#endif
+
+#ifdef ALLOW_WRITES
+
+/**************************************************************************
+  Function:
+    int FSmkdir (char * path)
+  Summary:
+    Create a directory as per the Ascii input path
+  Conditions:
+    None
+  Input:
+    path - The path of directories to create.
+  Return Values:
+    0 -   The specified directory was created successfully
+    EOF - The specified directory could not be created
+  Side Effects:
+    Will create all non-existent directories in the path. The FSerrno 
+    variable will be changed.
+  Description:
+    The FSmkdir function passes a RAM pointer to the path to the
+    mkdirhelper function.
+  Remarks:
+    None                                            
+  **************************************************************************/
+
+int FSmkdir (char * path);
+
+#ifdef SUPPORT_LFN
+/**************************************************************************
+  Function:
+    int wFSmkdir (unsigned short int * path)
+  Summary:
+    Create a directory as per the UTF16 input path
+  Conditions:
+    None
+  Input:
+    path - The path of directories to create.
+  Return Values:
+    0 -   The specified directory was created successfully
+    EOF - The specified directory could not be created
+  Side Effects:
+    Will create all non-existent directories in the path. The FSerrno 
+    variable will be changed.
+  Description:
+    The wFSmkdir function passes a RAM pointer to the path to the
+    mkdirhelper function.
+  Remarks:
+    None                                            
+  **************************************************************************/
+
+int wFSmkdir (unsigned short int * path);
+#endif
+
+/**************************************************************************
+  Function:
+    int FSrmdir (char * path)
+  Summary:
+    Delete a directory as per the Ascii input path
+  Conditions:
+    None
+  Input:
+    path -      The path of the directory to remove
+    rmsubdirs - 
+              - TRUE -  All sub-dirs and files in the target dir will be removed
+              - FALSE - FSrmdir will not remove non-empty directories
+  Return Values:
+    0 -   The specified directory was deleted successfully
+    EOF - The specified directory could not be deleted
+  Side Effects:
+    The FSerrno variable will be changed.
+  Description:
+    The FSrmdir function passes a RAM pointer to the path to the
+    rmdirhelper function.
+  Remarks:
+    None.
+  **************************************************************************/
+
+int FSrmdir (char * path, unsigned char rmsubdirs);
+
+#ifdef SUPPORT_LFN
+/**************************************************************************
+  Function:
+    int wFSrmdir (unsigned short int * path, unsigned char rmsubdirs)
+  Summary:
+    Delete a directory as per the UTF16 input path
+  Conditions:
+    None
+  Input:
+    path -      The path of the directory to remove
+    rmsubdirs - 
+              - TRUE -  All sub-dirs and files in the target dir will be removed
+              - FALSE - FSrmdir will not remove non-empty directories
+  Return Values:
+    0 -   The specified directory was deleted successfully
+    EOF - The specified directory could not be deleted
+  Side Effects:
+    The FSerrno variable will be changed.
+  Description:
+    The wFSrmdir function passes a RAM pointer to the path to the
+    rmdirhelper function.
+  Remarks:
+    None.
+  **************************************************************************/
+
+int wFSrmdir (unsigned short int * path, unsigned char rmsubdirs);
+#endif
+
+#endif
+
+#endif
+
+#ifdef USERDEFINEDCLOCK
+
+
+/***********************************************************************************************************
+  Function:
+    int SetClockVars (unsigned int year, unsigned char month, unsigned char day, unsigned char hour, unsigned char minute, unsigned char second)
+  Summary:
+    Manually set timestamp variables
+  Conditions:
+    USERDEFINEDCLOCK macro defined in FSconfig.h.
+  Input:
+    year -     The year (1980\-2107)
+    month -   The month (1\-12)
+    day -     The day of the month (1\-31)
+    hour -    The hour (0\-23)
+    minute -  The minute (0\-59)
+    second -  The second (0\-59)
+  Return Values:
+    None
+  Side Effects:
+    Modifies global timing variables
+  Description:
+    Lets the user manually set the timing variables.  The values passed in will be converted to the format
+    used by the FAT timestamps.
+  Remarks:
+    Call this before creating a file or directory (set create time) and
+    before closing a file (set last access time, last modified time)                                        
+  ***********************************************************************************************************/
+
+int SetClockVars (unsigned int year, unsigned char month, unsigned char day, unsigned char hour, unsigned char minute, unsigned char second);
+#endif
+
+
+#ifdef ALLOW_FILESEARCH
+
+/***********************************************************************************
+  Function:
+    int FindFirst (const char * fileName, unsigned int attr, SearchRec * rec)
+  Summary:
+    Initial search function for the input Ascii fileName
+  Conditions:
+    None
+  Input:
+    fileName - The name to search for
+             - Parital string search characters
+             - * - Indicates the rest of the filename or extension can vary (e.g. FILE.*)
+             - ? - Indicates that one character in a filename can vary (e.g. F?LE.T?T)
+    attr -            The attributes that a found file may have
+         - ATTR_READ_ONLY -  File may be read only
+         - ATTR_HIDDEN -     File may be a hidden file
+         - ATTR_SYSTEM -     File may be a system file
+         - ATTR_VOLUME -     Entry may be a volume label
+         - ATTR_DIRECTORY -  File may be a directory
+         - ATTR_ARCHIVE -    File may have archive attribute
+         - ATTR_MASK -       All attributes
+    rec -             pointer to a structure to put the file information in
+  Return Values:
+    0 -  File was found
+    -1 - No file matching the specified criteria was found
+  Side Effects:
+    Search criteria from previous FindFirst call on passed SearchRec object
+    will be lost. "utf16LFNfound" is overwritten after subsequent FindFirst/FindNext
+    operations.It is the responsibility of the application to read the "utf16LFNfound"
+    before it is lost.The FSerrno variable will be changed.
+  Description:
+    The FindFirst function will search for a file based on parameters passed in
+    by the user.  This function will use the FILEfind function to parse through
+    the current working directory searching for entries that match the specified
+    parameters.  If a file is found, its parameters are copied into the SearchRec
+    structure, as are the initial parameters passed in by the user and the position
+    of the file entry in the current working directory.If the return value of the 
+    function is 0 then "utf16LFNfoundLength" indicates whether the file found was 
+    long file name or short file name(8P3 format). The "utf16LFNfoundLength" is non-zero
+    for long file name and is zero for 8P3 format."utf16LFNfound" points to the
+    address of long file name if found during the operation.
+  Remarks:
+    Call FindFirst or FindFirstpgm before calling FindNext
+  ***********************************************************************************/
+
+int FindFirst (const char * fileName, unsigned int attr, SearchRec * rec);
+
+#ifdef SUPPORT_LFN
+/***********************************************************************************
+  Function:
+    int wFindFirst (const unsigned short int * fileName, unsigned int attr, SearchRec * rec)
+  Summary:
+    Initial search function for the input UTF16 fileName
+  Conditions:
+    None
+  Input:
+    fileName - The name to search for
+             - Parital string search characters
+             - * - Indicates the rest of the filename or extension can vary (e.g. FILE.*)
+             - ? - Indicates that one character in a filename can vary (e.g. F?LE.T?T)
+    attr -            The attributes that a found file may have
+         - ATTR_READ_ONLY -  File may be read only
+         - ATTR_HIDDEN -     File may be a hidden file
+         - ATTR_SYSTEM -     File may be a system file
+         - ATTR_VOLUME -     Entry may be a volume label
+         - ATTR_DIRECTORY -  File may be a directory
+         - ATTR_ARCHIVE -    File may have archive attribute
+         - ATTR_MASK -       All attributes
+    rec -             pointer to a structure to put the file information in
+  Return Values:
+    0 -  File was found
+    -1 - No file matching the specified criteria was found
+  Side Effects:
+    Search criteria from previous wFindFirst call on passed SearchRec object
+    will be lost. "utf16LFNfound" is overwritten after subsequent wFindFirst/FindNext
+    operations.It is the responsibility of the application to read the "utf16LFNfound"
+    before it is lost.The FSerrno variable will be changed.
+  Description:
+    The wFindFirst function will search for a file based on parameters passed in
+    by the user.  This function will use the FILEfind function to parse through
+    the current working directory searching for entries that match the specified
+    parameters.  If a file is found, its parameters are copied into the SearchRec
+    structure, as are the initial parameters passed in by the user and the position
+    of the file entry in the current working directory.If the return value of the 
+    function is 0 then "utf16LFNfoundLength" indicates whether the file found was 
+    long file name or short file name(8P3 format). The "utf16LFNfoundLength" is non-zero
+    for long file name and is zero for 8P3 format."utf16LFNfound" points to the
+    address of long file name if found during the operation.
+  Remarks:
+    Call FindFirst or FindFirstpgm before calling FindNext
+  ***********************************************************************************/
+
+int wFindFirst (const unsigned short int * fileName, unsigned int attr, SearchRec * rec);
+#endif
+
+/**********************************************************************
+  Function:
+    int FindNext (SearchRec * rec)
+  Summary:
+    Sequential search function
+  Conditions:
+    None
+  Input:
+    rec -  The structure to store the file information in
+  Return Values:
+    0 -  File was found
+    -1 - No additional files matching the specified criteria were found
+  Side Effects:
+    Search criteria from previous FindNext call on passed SearchRec object
+    will be lost. "utf16LFNfound" is overwritten after subsequent FindFirst/FindNext
+    operations.It is the responsibility of the application to read the "utf16LFNfound"
+    before it is lost.The FSerrno variable will be changed.
+  Description:
+    The FindNext function performs the same function as the FindFirst
+    funciton, except it does not copy any search parameters into the
+    SearchRec structure (only info about found files) and it begins
+    searching at the last directory entry offset at which a file was
+    found, rather than at the beginning of the current working
+    directory.If the return value of the function is 0 then "utf16LFNfoundLength"
+    indicates whether the file found was long file name or short file
+    name(8P3 format). The "utf16LFNfoundLength" is non-zero for long file name
+    and is zero for 8P3 format."utf16LFNfound" points to the address of long 
+    file name if found during the operation.
+  Remarks:
+    Call FindFirst or FindFirstpgm before calling this function
+  **********************************************************************/
+
+int FindNext (SearchRec * rec); 
+#endif
+
+
+/**********************************************************************
+  Function:
+    // PIC24/30/33/32
+    int FSfprintf (FSFILE * fptr, const char * fmt, ...)
+    // PIC18
+    int FSfpritnf (FSFILE * fptr, const rom char * fmt, ...)
+  Summary:
+    Function to write formatted strings to a file
+  Conditions:
+    For PIC18, integer promotion must be enabled in the project build
+    options menu.  File opened in a write mode.
+  Input:
+    fptr - A pointer to the file to write to.
+    fmt -  A string of characters and format specifiers to write to
+           the file
+    ... -  Additional arguments inserted in the string by format
+           specifiers
+  Returns:
+    The number of characters written to the file
+  Side Effects:
+    The FSerrno variable will be changed.
+  Description:
+    Writes a specially formatted string to a file.
+  Remarks:
+    Consult AN1045 for a full description of how to use format
+    specifiers.        
+  **********************************************************************/
+
+#ifdef ALLOW_FSFPRINTF
+    #ifdef __18CXX
+        int FSfprintf (FSFILE *fptr, const rom char *fmt, ...);
+    #else
+        int FSfprintf (FSFILE *fptr, const char * fmt, ...);
+    #endif
+#endif
+
+
+/**************************************************************************
+  Function:
+    int FSerror (void)
+  Summary:
+    Return an error code for the last function call
+  Conditions:
+    The return value depends on the last function called.
+  Input:
+    None
+  Side Effects:
+    None.
+  Return Values:
+    FSInit       - 
+                 - CE_GOOD ・                 No Error 
+                 - CE_INIT_ERROR ・           The physical media could not be initialized
+                 - CE_BAD_SECTOR_READ ・      The MBR or the boot sector could not be
+                                              read correctly
+                 - CE_BAD_PARITION ・         The MBR signature code was incorrect.
+                 - CE_NOT_FORMATTED ・        The boot sector signature code was incorrect or
+                                              indicates an invalid number of bytes per sector. 
+                 - CE_CARDFAT32 ・            The physical media is FAT32 type (only an error 
+                                              when FAT32 support is disabled). 
+                 - CE_UNSUPPORTED_FS ・       The device is formatted with an unsupported file 
+                                              system (not FAT12 or 16).
+    FSfopen      -
+                 - CE_GOOD ・                 No Error 
+                 - CE_NOT_INIT ・             The device has not been initialized. 
+                 - CE_TOO_MANY_FILES_OPEN ・  The function could not allocate any 
+                                              additional file information to the array 
+                                              of FSFILE structures or the heap. 
+                 - CE_INVALID_FILENAME ・     The file name argument was invalid.
+                 - CE_INVALID_ARGUMENT ・     The user attempted to open a directory in a 
+                                              write mode or specified an invalid mode argument. 
+                 - CE_FILE_NOT_FOUND ・       The specified file (which was to be opened in read 
+                                              mode) does not exist on the device. 
+                 - CE_BADCACHEREAD ・         A read from the device failed.
+                 - CE_ERASE_FAIL ・           The existing file could not be erased (when opening 
+                                              a file in WRITE mode). 
+                 - CE_DIR_FULL ・             The directory is full. 
+                 - CE_DISK_FULL・             The data memory section is full. 
+                 - CE_WRITE_ERROR ・          A write to the device failed. 
+                 - CE_SEEK_ERROR ・           The current position in the file could not be set to 
+                                              the end (when the file was opened in APPEND mode).
+    FSfclose     - 
+                 - CE_GOOD ・                 No Error 
+                 - CE_WRITE_ERROR ・          The existing data in the data buffer or the new file
+                                              entry information could not be written to the device.
+                 - CE_BADCACHEREAD ・         The file entry information could not be cached
+    FSfread      - 
+                 - CE_GOOD ・                 No Error 
+                 - CE_WRITEONLY ・            The file was opened in a write-only mode.
+                 - CE_WRITE_ERROR ・          The existing data in the data buffer could not be 
+                                              written to the device. 
+                 - CE_BAD_SECTOR_READ ・      The data sector could not be read. 
+                 - CE_EOF ・                  The end of the file was reached.
+                 - CE_COULD_NOT_GET_CLUSTER ・Additional clusters in the file could not be loaded.
+    FSfwrite     - 
+                 - CE_GOOD ・                 No Error 
+                 - CE_READONLY ・             The file was opened in a read-only mode. 
+                 - CE_WRITE_PROTECTED ・      The device write-protect check function indicated 
+                                              that the device has been write-protected.
+                 - CE_WRITE_ERROR ・          There was an error writing data to the device.
+                 - CE_BADCACHEREAD ・         The data sector to be modified could not be read from
+                                              the device. 
+                 - CE_DISK_FULL ・            All data clusters on the device are in use.
+    FSfseek      -
+                 - CE_GOOD ・                 No Error 
+                 - CE_WRITE_ERROR ・          The existing data in the data buffer could not be
+                                              written to the device. 
+                 - CE_INVALID_ARGUMENT ・     The specified offset exceeds the size of the file. 
+                 - CE_BADCACHEREAD ・         The sector that contains the new current position 
+                                              could not be loaded.
+                 - CE_COULD_NOT_GET_CLUSTER ・Additional clusters in the file could not be 
+                                              loaded/allocated.
+    FSftell      - 
+                 - CE_GOOD ・                 No Error
+    FSattrib     -
+                 - CE_GOOD ・                 No Error 
+                 - CE_INVALID_ARGUMENT ・     The attribute argument was invalid. 
+                 - CE_BADCACHEREAD ・         The existing file entry information could not be 
+                                              loaded. 
+                 - CE_WRITE_ERROR ・          The file entry information could not be written to 
+                                              the device.
+    FSrename     -
+                 - CE_GOOD ・                 No Error 
+                 - CE_FILENOTOPENED ・        A null file pointer was passed into the function. 
+                 - CE_INVALID_FILENAME ・     The file name passed into the function was invalid. 
+                 - CE_BADCACHEREAD ・         A read from the device failed. 
+                 - CE_FILENAME_EXISTS ・      A file with the specified name already exists. 
+                 - CE_WRITE_ERROR ・          The new file entry data could not be written to the 
+                                              device.
+    FSfeof       -
+                 - CE_GOOD ・                 No Error
+    FSformat     -
+                 - CE_GOOD ・                 No Error 
+                 - CE_INIT_ERROR ・           The device could not be initialized. 
+                 - CE_BADCACHEREAD ・         The master boot record or boot sector could not be 
+                                              loaded successfully. 
+                 - CE_INVALID_ARGUMENT ・     The user selected to create their own boot sector on 
+                                              a device that has no master boot record, or the mode 
+                                              argument was invalid. 
+                 - CE_WRITE_ERROR ・          The updated MBR/Boot sector could not be written to 
+                                              the device.
+                 - CE_BAD_PARTITION ・        The calculated number of sectors per clusters was 
+                                              invalid. 
+                 - CE_NONSUPPORTED_SIZE ・    The card has too many sectors to be formatted as 
+                                              FAT12 or FAT16.
+    FSremove     - 
+                 - CE_GOOD ・                 No Error 
+                 - CE_WRITE_PROTECTED ・      The device write-protect check function indicated 
+                                              that the device has been write-protected. 
+                 - CE_INVALID_FILENAME ・     The specified filename was invalid. 
+                 - CE_FILE_NOT_FOUND ・       The specified file could not be found.
+                 - CE_ERASE_FAIL ・           The file could not be erased.
+    FSchdir      -
+                 - CE_GOOD ・                 No Error 
+                 - CE_INVALID_ARGUMENT ・     The path string was mis-formed or the user tried to 
+                                              change to a non-directory file.
+                 - CE_BADCACHEREAD ・         A directory entry could not be cached.
+                 - CE_DIR_NOT_FOUND ・        Could not find a directory in the path.
+    FSgetcwd     -
+                 - CE_GOOD ・                 No Error 
+                 - CE_INVALID_ARGUMENT ・     The user passed a 0-length buffer into the function.
+                 - CE_BADCACHEREAD ・         A directory entry could not be cached. 
+                 - CE_BAD_SECTOR_READ ・      The function could not determine a previous directory 
+                                              of the current working directory.
+    FSmkdir      -
+                 - CE_GOOD ・                 No Error 
+                 - CE_WRITE_PROTECTED ・      The device write-protect check function indicated 
+                                              that the device has been write-protected. 
+                 - CE_INVALID_ARGUMENT ・     The path string was mis-formed.
+                 - CE_BADCACHEREAD ・         Could not successfully change to a recently created 
+                                              directory to store its dir entry information, or 
+                                              could not cache directory entry information. 
+                 - CE_INVALID_FILENAME ・     One or more of the directory names has an invalid 
+                                              format. 
+                 - CE_WRITE_ERROR ・          The existing data in the data buffer could not be 
+                                              written to the device or the dot/dotdot entries could 
+                                              not be written to a newly created directory.
+                 - CE_DIR_FULL ・             There are no available dir entries in the CWD.
+                 - CE_DISK_FULL ・            There are no available clusters in the data region of 
+                                              the device.    
+    FSrmdir      - 
+                 - CE_GOOD ・                 No Error 
+                 - CE_DIR_NOT_FOUND ・        The directory specified could not be found or the 
+                                              function could not change to a subdirectory within 
+                                              the directory to be deleted (when recursive delete is 
+                                              enabled).
+                 - CE_INVALID_ARGUMENT ・     The user tried to remove the CWD or root directory. 
+                 - CE_BADCACHEREAD ・         A directory entry could not be cached.
+                 - CE_DIR_NOT_EMPTY ・        The directory to be deleted was not empty and 
+                                              recursive subdirectory removal was disabled. 
+                 - CE_ERASE_FAIL ・           The directory or one of the directories or files 
+                                              within it could not be deleted. 
+                 - CE_BAD_SECTOR_READ ・      The function could not determine a previous directory 
+                                              of the CWD.
+    SetClockVars -
+                 - CE_GOOD ・                 No Error 
+                 - CE_INVALID_ARGUMENT ・     The time values passed into the function were 
+                                              invalid.    
+    FindFirst    - 
+                 - CE_GOOD ・                 No Error 
+                 - CE_INVALID_FILENAME ・     The specified filename was invalid. 
+                 - CE_FILE_NOT_FOUND ・       No file matching the specified criteria was found. 
+                 - CE_BADCACHEREAD ・         The file information for the file that was found 
+                                              could not be cached.
+    FindNext     - 
+                 - CE_GOOD ・                 No Error 
+                 - CE_NOT_INIT ・             The SearchRec object was not initialized by a call to 
+                                              FindFirst. 
+                 - CE_INVALID_ARGUMENT ・     The SearchRec object was initialized in a different 
+                                              directory from the CWD.
+                 - CE_INVALID_FILENAME ・     The filename is invalid. 
+                 - CE_FILE_NOT_FOUND ・       No file matching the specified criteria was found.
+    FSfprintf    - 
+                 - CE_GOOD ・                 No Error 
+                 - CE_WRITE_ERROR ・          Characters could not be written to the file.                                                   
+  Description:
+    The FSerror function will return the FSerrno variable.  This global
+    variable will have been set to an error value during the last call of a
+    library function.
+  Remarks:
+    None
+  **************************************************************************/
+
+int FSerror (void);
+
+
+/*********************************************************************************
+  Function:
+    int FSCreateMBR (unsigned long firstSector, unsigned long numSectors)
+  Summary:
+    Creates a master boot record
+  Conditions:
+    The I/O pins for the device have been initialized by the InitIO function.
+  Input:
+    firstSector -  The first sector of the partition on the device (cannot
+                   be 0; that's the MBR)
+    numSectors -   The number of sectors available in memory (including the
+                   MBR)
+  Return Values:
+    0 -   MBR was created successfully
+    EOF - MBR could not be created
+  Side Effects:
+    None
+  Description:  
+    This function can be used to create a master boot record for a device.  Note
+    that this function should not be used on a device that is already formatted
+    with a master boot record (i.e. most SD cards, CF cards, USB keys).  This
+    function will fill the global data buffer with appropriate partition information
+    for a FAT partition with a type determined by the number of sectors available
+    to the partition.  It will then write the MBR information to the first sector
+    on the device.  This function should be followed by a call to FSformat, which
+    will create a boot sector, root dir, and FAT appropriate the the information
+    contained in the new master boot record.  Note that FSformat only supports
+    FAT12 and FAT16 formatting at this time, and so cannot be used to format a
+    device with more than 0x3FFD5F sectors.
+  Remarks:
+    This function can damage the device being used, and should not be called
+    unless the user is sure about the size of the device and the first sector value.
+  *********************************************************************************/
+
+int FSCreateMBR (unsigned long firstSector, unsigned long numSectors);
+
+
+#ifdef ALLOW_GET_DISK_PROPERTIES
+/*********************************************************************************
+  Function:
+    void FSGetDiskProperties(FS_DISK_PROPERTIES* properties)
+  Summary:
+    Allows user to get the disk properties (size of disk, free space, etc)
+  Conditions:
+    1) ALLOW_GET_DISK_PROPERTIES must be defined in FSconfig.h
+    2) a FS_DISK_PROPERTIES object must be created before the function is called
+    3) the new_request member of the FS_DISK_PROPERTIES object must be set before
+        calling the function for the first time.  This will start a new search.
+    4) this function should not be called while there is a file open.  Close all
+        files before calling this function.
+  Input:
+    properties - a pointer to a FS_DISK_PROPERTIES object where the results should
+      be stored.
+  Return Values:
+    This function returns void.  The properties_status of the previous call of 
+      this function is located in the properties.status field.  This field has 
+      the following possible values:
+
+    FS_GET_PROPERTIES_NO_ERRORS - operation completed without error.  Results
+      are in the properties object passed into the function.
+    FS_GET_PROPERTIES_DISK_NOT_MOUNTED - there is no mounted disk.  Results in
+      properties object is not valid
+    FS_GET_PROPERTIES_CLUSTER_FAILURE - there was a failure trying to read a 
+      cluster from the drive.  The results in the properties object is a partial
+      result up until the point of the failure.
+    FS_GET_PROPERTIES_STILL_WORKING - the search for free sectors is still in
+      process.  Continue calling this function with the same properties pointer 
+      until either the function completes or until the partial results meets the
+      application needs.  The properties object contains the partial results of
+      the search and can be used by the application.  
+  Side Effects:
+    Can cause errors if called when files are open.  Close all files before
+    calling this function.
+
+    Calling this function without setting the new_request member on the first
+    call can result in undefined behavior and results.
+
+    Calling this function after a result is returned other than
+    FS_GET_PROPERTIES_STILL_WORKING can result in undefined behavior and results.
+  Description:  
+    This function returns the information about the mounted drive.  The results 
+    member of the properties object passed into the function is populated with 
+    the information about the drive.    
+
+    Before starting a new request, the new_request member of the properties
+    input parameter should be set to TRUE.  This will initiate a new search
+    request.
+
+    This function will return before the search is complete with partial results.
+    All of the results except the free_clusters will be correct after the first
+    call.  The free_clusters will contain the number of free clusters found up
+    until that point, thus the free_clusters result will continue to grow until
+    the entire drive is searched.  If an application only needs to know that a 
+    certain number of bytes is available and doesn't need to know the total free 
+    size, then this function can be called until the required free size is
+    verified.  To continue a search, pass a pointer to the same FS_DISK_PROPERTIES
+    object that was passed in to create the search.
+
+    A new search request sould be made once this function has returned a value 
+    other than FS_GET_PROPERTIES_STILL_WORKING.  Continuing a completed search
+    can result in undefined behavior or results.
+
+    Typical Usage:
+    <code>
+    FS_DISK_PROPERTIES disk_properties;
+
+    disk_properties.new_request = TRUE;
+
+    do
+    {
+        FSGetDiskProperties(&disk_properties);
+    } while (disk_properties.properties_status == FS_GET_PROPERTIES_STILL_WORKING);
+    </code>
+
+    results.disk_format - contains the format of the drive.  Valid results are 
+      FAT12(1), FAT16(2), or FAT32(3).
+
+    results.sector_size - the sector size of the mounted drive.  Valid values are
+      512, 1024, 2048, and 4096.
+
+    results.sectors_per_cluster - the number sectors per cluster.
+
+    results.total_clusters - the number of total clusters on the drive.  This 
+      can be used to calculate the total disk size (total_clusters * 
+      sectors_per_cluster * sector_size = total size of drive in bytes)
+
+    results.free_clusters - the number of free (unallocated) clusters on the drive.
+      This can be used to calculate the total free disk size (free_clusters * 
+      sectors_per_cluster * sector_size = total size of drive in bytes)
+
+  Remarks:
+    PIC24F size estimates:
+      Flash - 400 bytes (-Os setting)
+
+    PIC24F speed estimates:
+      Search takes approximately 7 seconds per Gigabyte of drive space.  Speed
+        will vary based on the number of sectors per cluster and the sector size.
+  *********************************************************************************/
+void FSGetDiskProperties(FS_DISK_PROPERTIES* properties);
+#endif
+
+
+#endif

--- /dev/null
+++ b/mips/protozoa/interface/graphlib.c
@@ -0,0 +1,894 @@
+//カラーグラフィックライブラリ
+
+#include <plib.h>
+#include "videoout.h"
+#include "LCDdriver.h"
+
+//unsigned char TVRAM[WIDTH_X*WIDTH_Y*2+1] __attribute__ ((aligned (4)));
+unsigned char TVRAM[WIDTH_X2*WIDTH_Y*2+1] __attribute__ ((aligned (4)));
+unsigned char *fontp; //フォント格納アドレス、初期化時はFontData、RAM指定することでPCGを実現
+unsigned int bgcolor; // バックグランドカラー
+unsigned char twidth; //テキスト1行文字数（30 or 40）
+unsigned char graphmode; //テキストモード時 0、グラフィックモード時 0以外
+
+unsigned short palette[256];
+const unsigned char __attribute__((weak)) FontData[256*8]={
+//フォントデータ、キャラクタコード順に8バイトずつ、上位ビットが左
+	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,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,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,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,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,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,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,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,
+	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,0x08,0x0C,0xFE,0xFE,0x0C,0x08,0x00,
+	0x00,0x20,0x60,0xFE,0xFE,0x60,0x20,0x00,
+	0x18,0x3C,0x7E,0x18,0x18,0x18,0x18,0x00,
+	0x00,0x18,0x18,0x18,0x18,0x7E,0x3C,0x18,
+	0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+	0x30,0x30,0x30,0x30,0x00,0x00,0x30,0x00,
+	0x6C,0x6C,0x6C,0x00,0x00,0x00,0x00,0x00,
+	0x6C,0x6C,0xFE,0x6C,0xFE,0x6C,0x6C,0x00,
+	0x18,0x7E,0xD8,0x7E,0x1A,0xFE,0x18,0x00,
+	0xE0,0xE6,0x0C,0x18,0x30,0x6E,0xCE,0x00,
+	0x78,0xCC,0xD8,0x70,0xDE,0xCC,0x76,0x00,
+	0x0C,0x18,0x30,0x00,0x00,0x00,0x00,0x00,
+	0x0C,0x18,0x30,0x30,0x30,0x18,0x0C,0x00,
+	0x30,0x18,0x0C,0x0C,0x0C,0x18,0x30,0x00,
+	0xD6,0x7C,0x38,0xFE,0x38,0x7C,0xD6,0x00,
+	0x00,0x30,0x30,0xFC,0x30,0x30,0x00,0x00,
+	0x00,0x00,0x00,0x00,0x00,0x30,0x30,0x60,
+	0x00,0x00,0x00,0xFE,0x00,0x00,0x00,0x00,
+	0x00,0x00,0x00,0x00,0x00,0x38,0x38,0x00,
+	0x00,0x06,0x0C,0x18,0x30,0x60,0xC0,0x00,
+	0x7C,0xC6,0xC6,0xC6,0xC6,0xC6,0x7C,0x00,
+	0x18,0x38,0x78,0x18,0x18,0x18,0x7E,0x00,
+	0x7C,0xC6,0x06,0x1C,0x70,0xC0,0xFE,0x00,
+	0x7C,0xC6,0x06,0x3C,0x06,0xC6,0x7C,0x00,
+	0x0C,0x1C,0x3C,0x6C,0xFE,0x0C,0x0C,0x00,
+	0xFE,0xC0,0xF8,0x0C,0x06,0xCC,0x78,0x00,
+	0x3C,0x60,0xC0,0xFC,0xC6,0xC6,0x7C,0x00,
+	0xFE,0xC6,0x0C,0x18,0x30,0x30,0x30,0x00,
+	0x7C,0xC6,0xC6,0x7C,0xC6,0xC6,0x7C,0x00,
+	0x7C,0xC6,0xC6,0x7E,0x06,0x0C,0x78,0x00,
+	0x00,0x30,0x00,0x00,0x00,0x30,0x00,0x00,
+	0x00,0x30,0x00,0x00,0x00,0x30,0x30,0x60,
+	0x0C,0x18,0x30,0x60,0x30,0x18,0x0C,0x00,
+	0x00,0x00,0xFE,0x00,0xFE,0x00,0x00,0x00,
+	0x60,0x30,0x18,0x0C,0x18,0x30,0x60,0x00,
+	0x7C,0xC6,0x06,0x1C,0x30,0x00,0x30,0x00,
+	0x3C,0x66,0xDE,0xF6,0xDC,0x60,0x3E,0x00,
+	0x38,0x6C,0xC6,0xFE,0xC6,0xC6,0xC6,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,0xC0,0xC0,0xF8,0xC0,0xC0,0xFE,0x00,
+	0xFE,0xC0,0xC0,0xF8,0xC0,0xC0,0xC0,0x00,
+	0x3C,0x66,0xC0,0xCE,0xC6,0x66,0x3C,0x00,
+	0xC6,0xC6,0xC6,0xFE,0xC6,0xC6,0xC6,0x00,
+	0x3C,0x18,0x18,0x18,0x18,0x18,0x3C,0x00,
+	0x1E,0x0C,0x0C,0x0C,0x0C,0xCC,0x78,0x00,
+	0xC6,0xCC,0xD8,0xF0,0xD8,0xCC,0xC6,0x00,
+	0xC0,0xC0,0xC0,0xC0,0xC0,0xC0,0xFE,0x00,
+	0xC6,0xEE,0xFE,0xD6,0xC6,0xC6,0xC6,0x00,
+	0xC6,0xE6,0xF6,0xDE,0xCE,0xC6,0xC6,0x00,
+	0x38,0x6C,0xC6,0xC6,0xC6,0x6C,0x38,0x00,
+	0xFC,0xC6,0xC6,0xFC,0xC0,0xC0,0xC0,0x00,
+	0x38,0x6C,0xC6,0xC6,0xDE,0x6C,0x3E,0x00,
+	0xFC,0xC6,0xC6,0xFC,0xD8,0xCC,0xC6,0x00,
+	0x7C,0xC6,0xC0,0x7C,0x06,0xC6,0x7C,0x00,
+	0x7E,0x18,0x18,0x18,0x18,0x18,0x18,0x00,
+	0xC6,0xC6,0xC6,0xC6,0xC6,0xC6,0x7C,0x00,
+	0xC6,0xC6,0xC6,0x6C,0x6C,0x38,0x38,0x00,
+	0xC6,0xC6,0xC6,0xD6,0xFE,0xEE,0xC6,0x00,
+	0xC6,0xC6,0x6C,0x38,0x6C,0xC6,0xC6,0x00,
+	0xCC,0xCC,0xCC,0x78,0x30,0x30,0x30,0x00,
+	0xFE,0x06,0x0C,0x38,0x60,0xC0,0xFE,0x00,
+	0x3C,0x30,0x30,0x30,0x30,0x30,0x3C,0x00,
+	0xCC,0xCC,0x78,0xFC,0x30,0xFC,0x30,0x00,
+	0x3C,0x0C,0x0C,0x0C,0x0C,0x0C,0x3C,0x00,
+	0x30,0x78,0xCC,0x00,0x00,0x00,0x00,0x00,
+	0x00,0x00,0x00,0x00,0x00,0x00,0xFE,0x00,
+	0x30,0x18,0x0C,0x00,0x00,0x00,0x00,0x00,
+	0x00,0x00,0x7C,0x0C,0x7C,0xCC,0x7E,0x00,
+	0xC0,0xC0,0xFC,0xE6,0xC6,0xE6,0xFC,0x00,
+	0x00,0x00,0x7C,0xC6,0xC0,0xC6,0x7C,0x00,
+	0x06,0x06,0x7E,0xCE,0xC6,0xCE,0x7E,0x00,
+	0x00,0x00,0x7C,0xC6,0xFE,0xC0,0x7C,0x00,
+	0x1C,0x36,0x30,0xFC,0x30,0x30,0x30,0x00,
+	0x00,0x00,0x7E,0xCE,0xCE,0x7E,0x06,0x7C,
+	0xC0,0xC0,0xFC,0xE6,0xC6,0xC6,0xC6,0x00,
+	0x18,0x00,0x38,0x18,0x18,0x18,0x3C,0x00,
+	0x0C,0x00,0x1C,0x0C,0x0C,0x0C,0xCC,0x78,
+	0xC0,0xC0,0xCC,0xD8,0xF0,0xF8,0xCC,0x00,
+	0x38,0x18,0x18,0x18,0x18,0x18,0x3C,0x00,
+	0x00,0x00,0xFC,0xB6,0xB6,0xB6,0xB6,0x00,
+	0x00,0x00,0xFC,0xE6,0xC6,0xC6,0xC6,0x00,
+	0x00,0x00,0x7C,0xC6,0xC6,0xC6,0x7C,0x00,
+	0x00,0x00,0xFC,0xE6,0xE6,0xFC,0xC0,0xC0,
+	0x00,0x00,0x7E,0xCE,0xCE,0x7E,0x06,0x06,
+	0x00,0x00,0xDC,0xE6,0xC0,0xC0,0xC0,0x00,
+	0x00,0x00,0x7E,0xC0,0x7C,0x06,0xFC,0x00,
+	0x30,0x30,0xFC,0x30,0x30,0x36,0x1C,0x00,
+	0x00,0x00,0xC6,0xC6,0xC6,0xCE,0x76,0x00,
+	0x00,0x00,0xC6,0xC6,0xC6,0x6C,0x38,0x00,
+	0x00,0x00,0x86,0xB6,0xB6,0xB6,0xFC,0x00,
+	0x00,0x00,0xC6,0x6C,0x38,0x6C,0xC6,0x00,
+	0x00,0x00,0xC6,0xC6,0xCE,0x7E,0x06,0x7C,
+	0x00,0x00,0xFE,0x0C,0x38,0x60,0xFE,0x00,
+	0x3C,0x60,0x60,0xC0,0x60,0x60,0x3C,0x00,
+	0x30,0x30,0x30,0x30,0x30,0x30,0x30,0x00,
+	0xF0,0x18,0x18,0x0C,0x18,0x18,0xF0,0x00,
+	0x60,0xB6,0x1C,0x00,0x00,0x00,0x00,0x00,
+	0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+	0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xFF,
+	0x00,0x00,0x00,0x00,0x00,0x00,0xFF,0xFF,
+	0x00,0x00,0x00,0x00,0x00,0xFF,0xFF,0xFF,
+	0x00,0x00,0x00,0x00,0xFF,0xFF,0xFF,0xFF,
+	0x00,0x00,0x00,0xFF,0xFF,0xFF,0xFF,0xFF,
+	0x00,0x00,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,
+	0x00,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,
+	0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,
+	0x80,0x80,0x80,0x80,0x80,0x80,0x80,0x80,
+	0xC0,0xC0,0xC0,0xC0,0xC0,0xC0,0xC0,0xC0,
+	0xE0,0xE0,0xE0,0xE0,0xE0,0xE0,0xE0,0xE0,
+	0xF0,0xF0,0xF0,0xF0,0xF0,0xF0,0xF0,0xF0,
+	0xF8,0xF8,0xF8,0xF8,0xF8,0xF8,0xF8,0xF8,
+	0xFC,0xFC,0xFC,0xFC,0xFC,0xFC,0xFC,0xFC,
+	0xFE,0xFE,0xFE,0xFE,0xFE,0xFE,0xFE,0xFE,
+	0x18,0x18,0x18,0x18,0xFF,0x18,0x18,0x18,
+	0x18,0x18,0x18,0x18,0xFF,0x00,0x00,0x00,
+	0x00,0x00,0x00,0x00,0xFF,0x18,0x18,0x18,
+	0x18,0x18,0x18,0x18,0xF8,0x18,0x18,0x18,
+	0x18,0x18,0x18,0x18,0x1F,0x18,0x18,0x18,
+	0xFF,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+	0x00,0x00,0x00,0x00,0xFF,0x00,0x00,0x00,
+	0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,
+	0x03,0x03,0x03,0x03,0x03,0x03,0x03,0x03,
+	0x00,0x00,0x00,0x00,0x1F,0x18,0x18,0x18,
+	0x00,0x00,0x00,0x00,0xF8,0x18,0x18,0x18,
+	0x18,0x18,0x18,0x18,0x1F,0x00,0x00,0x00,
+	0x18,0x18,0x18,0x18,0xF8,0x00,0x00,0x00,
+	0x00,0x00,0x00,0x00,0x07,0x0C,0x18,0x18,
+	0x00,0x00,0x00,0x00,0xE0,0x30,0x18,0x18,
+	0x18,0x18,0x18,0x0C,0x07,0x00,0x00,0x00,
+	0x18,0x18,0x18,0x30,0xE0,0x00,0x00,0x00,
+	0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
+	0x00,0x00,0x00,0x00,0x78,0x68,0x78,0x00,
+	0x78,0x60,0x60,0x60,0x00,0x00,0x00,0x00,
+	0x00,0x00,0x00,0x18,0x18,0x18,0x78,0x00,
+	0x00,0x00,0x00,0x00,0x60,0x30,0x18,0x00,
+	0x00,0x00,0x00,0x30,0x00,0x00,0x00,0x00,
+	0xFE,0x06,0x06,0xFE,0x06,0x0C,0x78,0x00,
+	0x00,0x00,0xFC,0x0C,0x38,0x30,0x60,0x00,
+	0x00,0x00,0x0C,0x18,0x38,0x78,0x18,0x00,
+	0x00,0x00,0x30,0xFC,0xCC,0x0C,0x38,0x00,
+	0x00,0x00,0x00,0xFC,0x30,0x30,0xFC,0x00,
+	0x00,0x00,0x18,0xFC,0x38,0x78,0xD8,0x00,
+	0x00,0x00,0x60,0xFC,0x6C,0x68,0x60,0x00,
+	0x00,0x00,0x00,0x78,0x18,0x18,0xFC,0x00,
+	0x00,0x00,0x7C,0x0C,0x7C,0x0C,0x7C,0x00,
+	0x00,0x00,0x00,0xAC,0xAC,0x0C,0x38,0x00,
+	0x00,0x00,0x00,0xFE,0x00,0x00,0x00,0x00,
+	0xFE,0x06,0x06,0x34,0x38,0x30,0x60,0x00,
+	0x06,0x0C,0x18,0x38,0x78,0xD8,0x18,0x00,
+	0x18,0xFE,0xC6,0xC6,0x06,0x0C,0x38,0x00,
+	0x00,0x7E,0x18,0x18,0x18,0x18,0x7E,0x00,
+	0x18,0xFE,0x18,0x38,0x78,0xD8,0x18,0x00,
+	0x30,0xFE,0x36,0x36,0x36,0x36,0x6C,0x00,
+	0x18,0x7E,0x18,0x7E,0x18,0x18,0x18,0x00,
+	0x3E,0x66,0xC6,0x0C,0x18,0x30,0xE0,0x00,
+	0x60,0x7E,0xD8,0x18,0x18,0x18,0x30,0x00,
+	0x00,0xFE,0x06,0x06,0x06,0x06,0xFE,0x00,
+	0x6C,0xFE,0x6C,0x0C,0x0C,0x18,0x30,0x00,
+	0x00,0xF0,0x00,0xF6,0x06,0x0C,0xF8,0x00,
+	0xFE,0x06,0x0C,0x18,0x38,0x6C,0xC6,0x00,
+	0x60,0xFE,0x66,0x6C,0x60,0x60,0x3E,0x00,
+	0xC6,0xC6,0x66,0x06,0x0C,0x18,0xF0,0x00,
+	0x3E,0x66,0xE6,0x3C,0x18,0x30,0xE0,0x00,
+	0x0C,0x78,0x18,0xFE,0x18,0x18,0xF0,0x00,
+	0x00,0xD6,0xD6,0xD6,0x0C,0x18,0xF0,0x00,
+	0x7C,0x00,0xFE,0x18,0x18,0x30,0x60,0x00,
+	0x30,0x30,0x38,0x3C,0x36,0x30,0x30,0x00,
+	0x18,0x18,0xFE,0x18,0x18,0x30,0x60,0x00,
+	0x00,0x7C,0x00,0x00,0x00,0x00,0xFE,0x00,
+	0x00,0x7E,0x06,0x6C,0x18,0x36,0x60,0x00,
+	0x18,0x7E,0x0C,0x18,0x3C,0x7E,0x18,0x00,
+	0x06,0x06,0x06,0x0C,0x18,0x30,0x60,0x00,
+	0x30,0x18,0x0C,0xC6,0xC6,0xC6,0xC6,0x00,
+	0xC0,0xC0,0xFE,0xC0,0xC0,0xC0,0x7E,0x00,
+	0x00,0xFE,0x06,0x06,0x0C,0x18,0x70,0x00,
+	0x00,0x30,0x78,0xCC,0x06,0x06,0x00,0x00,
+	0x18,0x18,0xFE,0x18,0xDB,0xDB,0x18,0x00,
+	0xFE,0x06,0x06,0x6C,0x38,0x30,0x18,0x00,
+	0x00,0x3C,0x00,0x3C,0x00,0x7C,0x06,0x00,
+	0x0C,0x18,0x30,0x60,0xCC,0xFC,0x06,0x00,
+	0x02,0x36,0x3C,0x18,0x3C,0x6C,0xC0,0x00,
+	0x00,0xFE,0x30,0xFE,0x30,0x30,0x3E,0x00,
+	0x30,0x30,0xFE,0x36,0x3C,0x30,0x30,0x00,
+	0x00,0x78,0x18,0x18,0x18,0x18,0xFE,0x00,
+	0xFE,0x06,0x06,0xFE,0x06,0x06,0xFE,0x00,
+	0x7C,0x00,0xFE,0x06,0x0C,0x18,0x30,0x00,
+	0xC6,0xC6,0xC6,0x06,0x06,0x0C,0x38,0x00,
+	0x6C,0x6C,0x6C,0x6E,0x6E,0x6C,0xC8,0x00,
+	0x60,0x60,0x60,0x66,0x6C,0x78,0x70,0x00,
+	0x00,0xFE,0xC6,0xC6,0xC6,0xC6,0xFE,0x00,
+	0x00,0xFE,0xC6,0xC6,0x06,0x0C,0x38,0x00,
+	0x00,0xF0,0x06,0x06,0x0C,0x18,0xF0,0x00,
+	0x18,0xCC,0x60,0x00,0x00,0x00,0x00,0x00,
+	0x70,0xD8,0x70,0x00,0x00,0x00,0x00,0x00,
+	0x00,0x00,0xFF,0x00,0x00,0xFF,0x00,0x00,
+	0x18,0x18,0x1F,0x18,0x18,0x1F,0x18,0x18,
+	0x18,0x18,0xFF,0x18,0x18,0xFF,0x18,0x18,
+	0x18,0x18,0xF8,0x18,0x18,0xF8,0x18,0x18,
+	0x01,0x03,0x07,0x0F,0x1F,0x3F,0x7F,0xFF,
+	0x80,0xC0,0xE0,0xF0,0xF8,0xFC,0xFE,0xFF,
+	0xFF,0x7F,0x3F,0x1F,0x0F,0x07,0x03,0x01,
+	0xFF,0xFE,0xFC,0xF8,0xF0,0xE0,0xC0,0x80,
+	0x10,0x38,0x7C,0xFE,0xFE,0x38,0x7C,0x00,
+	0x6C,0xFE,0xFE,0xFE,0x7C,0x38,0x10,0x00,
+	0x10,0x38,0x7C,0xFE,0x7C,0x38,0x10,0x00,
+	0x38,0x38,0xFE,0xFE,0xD6,0x10,0x7C,0x00,
+	0x00,0x3C,0x7E,0x7E,0x7E,0x7E,0x3C,0x00,
+	0x00,0x7C,0xC6,0xC6,0xC6,0xC6,0x7C,0x00,
+	0x03,0x06,0x0C,0x18,0x30,0x60,0xC0,0x80,
+	0x80,0xC0,0x60,0x30,0x18,0x0C,0x06,0x03,
+	0x83,0xC6,0x6C,0x38,0x38,0x6C,0xC6,0x83,
+	0xFE,0xB6,0xB6,0xFE,0x86,0x86,0x86,0x00,
+	0xC0,0xFE,0xD8,0x7E,0x58,0xFE,0x18,0x00,
+	0x7E,0x66,0x7E,0x66,0x7E,0x66,0xC6,0x00,
+	0xFE,0xC6,0xC6,0xFE,0xC6,0xC6,0xFE,0x00,
+	0x06,0xEF,0xA6,0xFF,0xA2,0xFF,0x0A,0x06,
+	0x00,0x38,0x6C,0xC6,0x7C,0x34,0x6C,0x00,
+	0xFC,0x6C,0xFE,0x6E,0xF6,0xEC,0x6C,0x78,
+	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,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,0x00,0x00,0x00,0x00,0x00,0x00,
+	0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00
+};
+
+void set_palette(unsigned char n,unsigned char b,unsigned char r,unsigned char g){
+//テキスト、グラフィック共用カラーパレット設定
+	palette[n]=((r>>3)<<11)+((g>>2)<<5)+(b>>3);
+}
+
+void g_pset(int x,int y,unsigned int c)
+// (x,y)の位置にカラーパレット番号cで点を描画
+{
+	if(x>=0 && x<X_RES && y>=0 && y<Y_RES)
+		drawPixel(x,y,palette[c]);
+}
+
+void g_putbmpmn(int x,int y,char m,char n,const unsigned char bmp[])
+// 横m*縦nドットのキャラクターを座標x,yに表示
+// unsigned char bmp[m*n]配列に、単純にカラー番号を並べる
+// カラー番号が0の部分は透明色として扱う
+{
+	int i,j;
+	int skip;
+	const unsigned char *p;
+	if(x<=-m || x>X_RES || y<=-n || y>=Y_RES) return; //画面外
+	if(y<0){ //画面上部に切れる場合
+		i=0;
+		p=bmp-y*m;
+	}
+	else{
+		i=y;
+		p=bmp;
+	}
+	for(;i<y+n;i++){
+		if(i>=Y_RES) return; //画面下部に切れる場合
+		if(x<0){ //画面左に切れる場合は残る部分のみ描画
+			j=0;
+			p+=-x;
+		}
+		else{
+			j=x;
+		}
+		skip=1;
+		for(;j<x+m;j++){
+			if(j>=X_RES){ //画面右に切れる場合
+				p+=x+m-j;
+				break;
+			}
+			if(*p!=0){ //カラー番号が0の場合、透明として処理
+				if(skip){
+					LCD_SetCursor(j,i);
+					LCD_WriteIndex(0x22);
+					skip=0;
+				}
+				LCD_WriteData(palette[*p]);
+			}
+			else skip=1;
+			p++;
+		}
+	}
+}
+
+
+// 縦m*横nドットのキャラクター消去
+// カラー0で塗りつぶし
+void g_clrbmpmn(int x,int y,char m,char n)
+{
+	int i,j,k;
+	if(x<=-m || x>X_RES || y<=-n || y>=Y_RES) return; //画面外
+	if(y<0) i=0; //画面上部に切れる場合
+	else i=y;
+	if(x<0) j=0; //画面左に切れる場合は残る部分のみ描画
+	else j=x;
+	if(x+m>=X_RES) k=X_RES-j; //画面右に切れる場合
+	else k=x+m-j;
+	for(;i<y+n;i++){
+		if(i>=Y_RES) return; //画面下部に切れる場合
+		LCD_continuous_output(j,i,0,k);
+	}
+}
+
+void g_gline(int x1,int y1,int x2,int y2,unsigned int c)
+// (x1,y1)-(x2,y2)にカラーパレット番号cで線分を描画
+{
+	int sx,sy,dx,dy,i;
+	int e;
+
+	if(x2>x1){
+		dx=x2-x1;
+		sx=1;
+	}
+	else{
+		dx=x1-x2;
+		sx=-1;
+	}
+	if(y2>y1){
+		dy=y2-y1;
+		sy=1;
+	}
+	else{
+		dy=y1-y2;
+		sy=-1;
+	}
+	if(dx>=dy){
+		e=-dx;
+		for(i=0;i<=dx;i++){
+			g_pset(x1,y1,c);
+			x1+=sx;
+			e+=dy*2;
+			if(e>=0){
+				y1+=sy;
+				e-=dx*2;
+			}
+		}
+	}
+	else{
+		e=-dy;
+		for(i=0;i<=dy;i++){
+			g_pset(x1,y1,c);
+			y1+=sy;
+			e+=dx*2;
+			if(e>=0){
+				x1+=sx;
+				e-=dy*2;
+			}
+		}
+	}
+}
+void g_hline(int x1,int x2,int y,unsigned int c)
+// (x1,y)-(x2,y)への水平ラインを高速描画
+{
+	int temp;
+	unsigned short d,*ad;
+
+	if(y<0 || y>=Y_RES) return;
+	if(x1>x2){
+		temp=x1;
+		x1=x2;
+		x2=temp;
+	}
+	if(x2<0 || x1>=X_RES) return;
+	if(x1<0) x1=0;
+	if(x2>=X_RES) x2=X_RES-1;
+	LCD_continuous_output(x1,y,palette[c],x2-x1+1);
+}
+
+void g_circle(int x0,int y0,unsigned int r,unsigned int c)
+// (x0,y0)を中心に、半径r、カラーパレット番号cの円を描画
+{
+	int x,y,f;
+	x=r;
+	y=0;
+	f=-2*r+3;
+	while(x>=y){
+		g_pset(x0-x,y0-y,c);
+		g_pset(x0-x,y0+y,c);
+		g_pset(x0+x,y0-y,c);
+		g_pset(x0+x,y0+y,c);
+		g_pset(x0-y,y0-x,c);
+		g_pset(x0-y,y0+x,c);
+		g_pset(x0+y,y0-x,c);
+		g_pset(x0+y,y0+x,c);
+		if(f>=0){
+			x--;
+			f-=x*4;
+		}
+		y++;
+		f+=y*4+2;
+	}
+}
+void g_boxfill(int x1,int y1,int x2,int y2,unsigned int c)
+// (x1,y1),(x2,y2)を対角線とするカラーパレット番号cで塗られた長方形を描画
+{
+	int temp;
+	if(x1>x2){
+		temp=x1;
+		x1=x2;
+		x2=temp;
+	}
+	if(x2<0 || x1>=X_RES) return;
+	if(y1>y2){
+		temp=y1;
+		y1=y2;
+		y2=temp;
+	}
+	if(y2<0 || y1>=Y_RES) return;
+	if(y1<0) y1=0;
+	if(y2>=Y_RES) y2=Y_RES-1;
+	while(y1<=y2){
+		g_hline(x1,x2,y1++,c);
+	}
+}
+void g_circlefill(int x0,int y0,unsigned int r,unsigned int c)
+// (x0,y0)を中心に、半径r、カラーパレット番号cで塗られた円を描画
+{
+	int x,y,f;
+	x=r;
+	y=0;
+	f=-2*r+3;
+	while(x>=y){
+		g_hline(x0-x,x0+x,y0-y,c);
+		g_hline(x0-x,x0+x,y0+y,c);
+		g_hline(x0-y,x0+y,y0-x,c);
+		g_hline(x0-y,x0+y,y0+x,c);
+		if(f>=0){
+			x--;
+			f-=x*4;
+		}
+		y++;
+		f+=y*4+2;
+	}
+}
+
+void g_putfont(int x,int y,unsigned int c,int bc,unsigned char n)
+//8*8ドットのアルファベットフォント表示
+//座標(x,y)、カラーパレット番号c
+//bc:バックグランドカラー、負数の場合無視
+//n:文字番号
+{
+	int i,j;
+	unsigned char d;
+	int skip;
+	unsigned short c1;
+	const unsigned char *p;
+	if(x<=-8 || x>=X_RES || y<=-8 || y>=Y_RES) return; //画面外
+	if(y<0){ //画面上部に切れる場合
+		i=0;
+		p=fontp+n*8-y;
+	}
+	else{
+		i=y;
+		p=fontp+n*8;
+	}
+	c1=palette[c];
+	if(bc>=0) bc=palette[bc];
+	for(;i<y+8;i++){
+		if(i>=Y_RES) return; //画面下部に切れる場合
+		d=*p++;
+		if(x<0){ //画面左に切れる場合は残る部分のみ描画
+			j=0;
+			d<<=-x;
+		}
+		else{
+			j=x;
+		}
+		if(bc<0){
+			skip=1;
+			for(;j<x+8;j++){
+				if(j>=X_RES){ //画面右に切れる場合
+					break;
+				}
+				if(d&0x80){
+					if(skip){
+						LCD_SetCursor(j,i);
+						LCD_WriteIndex(0x22);
+						skip=0;
+					}
+					LCD_WriteData(c1);
+				}
+				else skip=1;
+				d<<=1;
+			}
+		}
+		else{
+			LCD_SetCursor(j,i);
+			LCD_WriteIndex(0x22);
+			for(;j<x+8;j++){
+				if(j>=X_RES){ //画面右に切れる場合
+					break;
+				}
+				if(d&0x80){
+					LCD_WriteData(c1);
+				}
+				else{
+					LCD_WriteData(bc);
+				}
+				d<<=1;
+			}
+		}
+	}
+}
+
+void g_printstr(int x,int y,unsigned int c,unsigned int bc,unsigned char *s){
+	//座標(x,y)からカラーパレット番号cで文字列sを表示、bc:バックグランドカラー
+	//bcが負の場合は無視
+	while(*s){
+		g_putfont(x,y,c,bc,*s++);
+		x+=8;
+	}
+}
+void g_printnum(int x,int y,unsigned int c,unsigned int bc,unsigned int n){
+	//座標(x,y)にカラー番号cで数値nを表示、bc:バックグランドカラー
+	unsigned int d,e;
+	d=10;
+	e=0;
+	while(n>=d){
+		e++;
+		if(e==9) break;
+		d*=10;
+	}
+	x+=e*8;
+	do{
+		g_putfont(x,y,c,bc,'0'+n%10);
+		n/=10;
+		x-=8;
+	}while(n!=0);
+}
+void g_printnum2(int x,int y,unsigned int c,unsigned int bc,unsigned int n,unsigned char e){
+	//座標(x,y)にカラー番号cで数値nを表示、bc:バックグランドカラー、e桁で表示
+	if(e==0) return;
+	x+=(e-1)*8;
+	do{
+		g_putfont(x,y,c,bc,'0'+n%10);
+		e--;
+		n/=10;
+		x-=8;
+	}while(e!=0 && n!=0);
+	while(e!=0){
+		g_putfont(x,y,c,bc,' ');
+		x-=8;
+		e--;
+	}
+}
+unsigned int g_color(int x,int y){
+//座標(x,y)の色情報を返す、画面外は0を返す
+//パレット番号ではないことに注意
+	if(x<0 || x>=X_RES || y<0 || y>=Y_RES) return 0;
+	return getColor(x,y);
+}
+
+// テキスト画面クリア
+void clearscreen(void)
+{
+	unsigned int *vp;
+	int i;
+	vp=(unsigned int *)TVRAM;
+	for(i=0;i<WIDTH_X2*WIDTH_Y*2/4;i++) *vp++=0;
+	cursor=TVRAM;
+	LCD_Clear(bgcolor);
+}
+
+// グラフィック画面クリア
+void g_clearscreen(void)
+{
+	LCD_Clear(0);
+}
+unsigned char *cursor;
+unsigned char cursorcolor;
+
+void textredraw(void){
+// テキスト画面再描画
+// テキストVRAMの内容にしたがって液晶に出力
+	unsigned char *p;
+	int i,j;
+
+	p=TVRAM;
+	for(i=0;i<WIDTH_Y;i++){
+		if(twidth==WIDTH_X1){
+			for(j=0;j<WIDTH_X1;j++){
+				g_putfont(j*8,i*8,*(p+ATTROFFSET1),bgcolor,*p);
+				p++;
+			}
+		}
+		else{
+			for(j=0;j<WIDTH_X2;j++){
+				g_putfont(j*6,i*8,*(p+ATTROFFSET2),bgcolor,*p);
+				p++;
+			}
+		}
+	}
+}
+void vramscroll(void){
+	unsigned short *p1,*p2;
+
+	p1=(unsigned short *)TVRAM;
+	if(twidth==WIDTH_X1){
+		p2=(unsigned short *)(TVRAM+WIDTH_X1);
+		while(p2<(unsigned short *)(TVRAM+ATTROFFSET1)){
+			*(p1+ATTROFFSET1/2)=*(p2+ATTROFFSET1/2);
+			*p1++=*p2++;
+		}
+		while(p1<(unsigned short *)(TVRAM+ATTROFFSET1)){
+			*(p1+ATTROFFSET1/2)=0;
+			*p1++=0;
+		}
+	}
+	else{
+		p2=(unsigned short *)(TVRAM+WIDTH_X2);
+		while(p2<(unsigned short *)(TVRAM+ATTROFFSET2)){
+			*(p1+ATTROFFSET2/2)=*(p2+ATTROFFSET2/2);
+			*p1++=*p2++;
+		}
+		while(p1<(unsigned short *)(TVRAM+ATTROFFSET2)){
+			*(p1+ATTROFFSET2/2)=0;
+			*p1++=0;
+		}
+	}
+	textredraw();
+}
+void vramscrolldown(void){
+	unsigned short *p1,*p2;
+
+	if(twidth==WIDTH_X1){
+		p1=(unsigned short *)(TVRAM+ATTROFFSET1)-1;
+		p2=(unsigned short *)(TVRAM+ATTROFFSET1-WIDTH_X1)-1;
+		while(p2>=(unsigned short *)(TVRAM)){
+			*(p1+ATTROFFSET1/2)=*(p2+ATTROFFSET1/2);
+			*p1++=*p2++;
+		}
+		while(p1>=(unsigned short *)(TVRAM)){
+			*(p1+ATTROFFSET1/2)=0;
+			*p1++=0;
+		}
+	}
+	else{
+		p1=(unsigned short *)(TVRAM+ATTROFFSET2)-1;
+		p2=(unsigned short *)(TVRAM+ATTROFFSET2-WIDTH_X2)-1;
+		while(p2>=(unsigned short *)(TVRAM)){
+			*(p1+ATTROFFSET2/2)=*(p2+ATTROFFSET2/2);
+			*p1++=*p2++;
+		}
+		while(p1>=(unsigned short *)(TVRAM)){
+			*(p1+ATTROFFSET2/2)=0;
+			*p1++=0;
+		}
+	}
+	textredraw();
+}
+void setcursor(unsigned char x,unsigned char y,unsigned char c){
+	//カーソルを座標(x,y)にカラー番号cに設定
+	if(x>=twidth || y>=WIDTH_Y) return;
+	cursor=TVRAM+y*twidth+x;
+	cursorcolor=c;
+}
+void setcursorcolor(unsigned char c){
+	//カーソル位置そのままでカラー番号をcに設定
+	cursorcolor=c;
+}
+void printchar(unsigned char n){
+	//カーソル位置にテキストコードnを1文字表示し、カーソルを1文字進める
+	//画面最終文字表示してもスクロールせず、次の文字表示時にスクロールする
+	if(cursor<TVRAM || cursor>TVRAM+twidth*WIDTH_Y) return;
+	if(cursor==TVRAM+twidth*WIDTH_Y){
+		vramscroll();
+		cursor-=twidth;
+	}
+	if(n=='\n'){
+		//改行
+		cursor+=twidth-((cursor-TVRAM)%twidth);
+	} else{
+		*cursor=n;
+		if(twidth==WIDTH_X1){
+			*(cursor+ATTROFFSET1)=cursorcolor;
+			g_putfont(((cursor-TVRAM)%WIDTH_X1)*8,((cursor-TVRAM)/WIDTH_X1)*8,cursorcolor,bgcolor,n);
+		}
+		else{
+			*(cursor+ATTROFFSET2)=cursorcolor;
+			g_putfont(((cursor-TVRAM)%WIDTH_X2)*6,((cursor-TVRAM)/WIDTH_X2)*8,cursorcolor,bgcolor,n);
+		}
+		cursor++;
+	}
+}
+void printstr(unsigned char *s){
+	//カーソル位置に文字列sを表示
+	while(*s){
+		printchar(*s++);
+	}
+}
+void printnum(unsigned int n){
+	//カーソル位置に符号なし整数nを10進数表示
+	unsigned int d,n1;
+	n1=n/10;
+	d=1;
+	while(n1>=d){
+		d*=10;
+	}
+	while(d!=0){
+		printchar('0'+n/d);
+		n%=d;
+		d/=10;
+	}
+}
+void printnum2(unsigned int n,unsigned char e){
+	//カーソル位置に符号なし整数nをe桁の10進数表示（前の空き桁部分はスペースで埋める）
+	unsigned int d,n1;
+	if(e==0) return;
+	n1=n/10;
+	d=1;
+	e--;
+	while(e>0 && n1>=d){
+		d*=10;
+		e--;
+	}
+	if(e==0 && n1>d) n%=d*10;
+	for(;e>0;e--) printchar(' ');
+	while(d!=0){
+		printchar('0'+n/d);
+		n%=d;
+		d/=10;
+	}
+}
+void cls(void){
+	//画面消去しカーソルを先頭に移動
+	clearscreen();
+}
+void startPCG(unsigned char *p,int a){
+// RAMフォント（PCG）の利用開始
+// p：RAMフォントの格納アドレス（8*256＝2048バイト）
+// a： システムフォントからのコピー指定。0の場合コピーなし、0以外でコピー
+	int i;
+	if(a){
+		if(twidth==WIDTH_X1)
+			for(i=0;i<8*256;i++) *p++=FontData[i];
+//		else
+//			for(i=0;i<8*256;i++) *p++=FontData2[i];
+		fontp=p-8*256;
+	}
+	else fontp=p;
+}
+void stopPCG(void){
+// RAMフォント（PCG）の利用停止
+	if(twidth==WIDTH_X1) fontp=(unsigned char *)FontData;
+//	else fontp=(unsigned char *)FontData2;
+}
+void set_bgcolor(unsigned char b,unsigned char r,unsigned char g)
+{
+	bgcolor=((r>>3)<<11)+((g>>2)<<5)+(b>>3);
+
+}
+void init_textgraph(void){
+	//テキストモードでのグラフィックLCDライブラリの使用開始
+	//パレット設定
+	//LCD縦横設定
+
+	int i;
+	graphmode=0;//テキストモード
+	fontp=(unsigned char *)FontData;
+	twidth=WIDTH_X1;//30文字モード
+	set_bgcolor(0,0,0); //バックグランドカラーは黒
+	clearscreen();
+	//カラーパレット初期化
+	for(i=0;i<8;i++){
+		set_palette(i,255*(i&1),255*((i>>1)&1),255*(i>>2));
+	}
+	for(i=0;i<8;i++){
+		set_palette(i+8,128*(i&1),128*((i>>1)&1),128*(i>>2));
+	}
+	for(i=16;i<256;i++){
+		set_palette(i,255,255,255);
+	}
+	setcursorcolor(7);
+
+//	LCD_Init(); //ブートローダで初期化するため、アプリ側では初期化しない
+
+#if LCD_ALIGNMENT == HORIZONTAL
+	LCD_set_Horizontal();
+#endif
+}
+
+void init_graphic(void){
+	//グラフィックLCDライブラリの使用開始
+	//パレット設定
+	//LCD縦横設定
+
+	int i;
+	//カラーパレット初期化
+	for(i=0;i<8;i++){
+		set_palette(i,255*(i&1),255*((i>>1)&1),255*(i>>2));
+	}
+	for(i=0;i<8;i++){
+		set_palette(i+8,128*(i&1),128*((i>>1)&1),128*(i>>2));
+	}
+	for(i=16;i<256;i++){
+		set_palette(i,255,255,255);
+	}
+
+//	LCD_Init(); //ブートローダで初期化するため、アプリ側では初期化しない
+
+#if LCD_ALIGNMENT == HORIZONTAL
+	LCD_set_Horizontal();
+#endif
+	LCD_Clear(0);
+}
+volatile unsigned short drawcount;
+/**********************
+*  Timer2 割り込み処理関数
+***********************/
+void __ISR(8, ipl4) T2Handler(void)
+{
+	drawcount++;
+	IFS0bits.T2IF = 0;			// T2割り込みフラグクリア
+	IFS0bits.CS0IF= 1;			// CS0割り込み
+}
+
+//30文字モード(8ドットフォント)と40文字モード(6ドットフォント)の切り替え
+void set_width(unsigned char m){
+// m:0　30文字モード、1　40文字モード
+// グラフモード時は無効
+// PCG使用中はフォント変更しない
+	if(graphmode) return;
+	clearscreen();
+	if(m){
+//		if(fontp<(unsigned char *)0xa0000000) fontp=(unsigned char *)FontData2;
+		twidth=WIDTH_X2;
+	}
+	else{
+		if(fontp<(unsigned char *)0xa0000000) fontp=(unsigned char *)FontData;
+		twidth=WIDTH_X1;
+	}
+	return;
+}
+
+//テキストモードとグラフィックモードの切り替え
+void set_graphmode(unsigned char m){
+// m:0　テキストモード、0以外 グラフィックモード
+	if(m){
+		//グラフィックモード開始
+		graphmode=1;
+	}
+	else{
+		//テキストーモード開始
+		graphmode=0;
+	}
+}

--- /dev/null
+++ b/mips/protozoa/interface/keyinput.c
@@ -0,0 +1,41 @@
+/*
+   This file is provided under the LGPL license ver 2.1.
+   Written by K.Tanaka & Katsumi
+   http://www.ze.em-net.ne.jp/~kenken/index.html
+   http://hp.vector.co.jp/authors/VA016157/
+*/
+// キー入力、カーソル表示関連機能 by K.Tanaka
+// PS/2キーボード入力システム、カラーテキスト出力システム利用
+
+#include "videoout.h"
+#include "ps2keyboard.h"
+#include "keyinput.h"
+#include "plib.h"
+
+volatile unsigned short vkey; //仮想キーコード
+unsigned short keystatus,keystatus2,oldkey; //最新のボタン状態と前回のボタン状態
+
+int lineinput(char *s,int n){
+	return 0;
+}
+
+unsigned short readButton(void){
+	unsigned short k;
+	LCD_CS_HI;
+	asm("nop");
+	KEY_EN;
+	asm("nop");
+	TRISBSET=KEYMASK;
+	asm("nop");
+	k=~KEYPORT & KEYMASK;
+	KEY_DS;
+	asm("nop");
+	TRISBCLR=KEYMASK;
+	asm("nop");
+	LCD_CS_LO;
+	return k;
+}
+
+unsigned char ps2readkey(){
+	return 0;
+}
\ No newline at end of file

--- /dev/null
+++ b/mips/protozoa/interface/keyinput.h
@@ -0,0 +1,48 @@
+/*
+   This file is provided under the LGPL license ver 2.1.
+   Written by K.Tanaka
+   http://www.ze.em-net.ne.jp/~kenken/index.html
+*/
+
+#define BLINKTIME 15
+#define CURSORCHAR 0x87
+#define CURSORCHAR2 0x80
+#define CURSORCOLOR 7
+
+void getcursorchar();
+// カーソル点滅用に元の文字コードを退避
+
+void resetcursorchar();
+// カーソルを元の文字に戻す
+
+void blinkcursorchar();
+// 定期的に呼び出すことでカーソルを点滅表示させる
+// BLINKTIMEで点滅間隔を設定
+// 事前にgetcursorchar()を呼び出しておく
+
+int lineinput(char *s,int n);
+// キー入力して文字列配列sに格納
+// sに初期文字列を入れておくと最初に表示して文字列の最後にカーソル移動する
+// 初期文字列を使用しない場合は*s=0としておく
+// カーソル位置はsetcursor関数で指定しておく
+// 最大文字数n、最後に0を格納するのでn+1バイトの領域必要、ただしnの最大値は255
+// 戻り値　Enterで終了した場合0、ESCで終了時は-1（sは壊さない）
+
+unsigned char inputchar(void);
+// キーボードから1キー入力待ち
+// 戻り値 通常文字の場合ASCIIコード、その他は0、グローバル変数vkeyに仮想キーコード
+
+unsigned char printinputchar(void);
+// カーソル表示しながらキーボードから通常文字キー入力待ちし、入力された文字を表示
+// 戻り値 入力された文字のASCIIコード、グローバル変数vkeyに最後に押されたキーの仮想キーコード
+
+unsigned char cursorinputchar(void);
+// カーソル表示しながらキーボードから1キー入力待ち
+// 戻り値 通常文字の場合ASCIIコード、その他は0、グローバル変数vkeyに仮想キーコード
+
+unsigned short readButton(void);
+
+extern unsigned char blinkchar,blinkcolor;
+extern int blinktimer;
+extern int insertmode; //挿入モード：1、上書きモード：0
+extern unsigned short keystatus,keystatus2,oldkey; //最新のボタン状態と前回のボタン状態

Binary files /dev/null and b/mips/protozoa/interface/libsdfsio.a differ

--- /dev/null
+++ b/mips/protozoa/interface/ps2keyboard.h
@@ -0,0 +1,178 @@
+#define CHK_SHIFT 0x01
+#define CHK_CTRL 0x02
+#define CHK_ALT 0x04
+#define CHK_WIN 0x08
+#define CHK_SCRLK 0x10
+#define CHK_NUMLK 0x20
+#define CHK_CAPSLK 0x40
+#define CHK_SHIFT_L 0x01
+#define CHK_SHIFT_R 0x02
+#define CHK_CTRL_L 0x04
+#define CHK_CTRL_R 0x08
+#define CHK_ALT_L 0x10
+#define CHK_ALT_R 0x20
+#define CHK_WIN_L 0x40
+#define CHK_WIN_R 0x80
+#define CHK_SCRLK_A 0x100
+#define CHK_NUMLK_A 0x200
+#define CHK_CAPSLK_A 0x400
+
+#define VK_LBUTTON 0x01
+#define VK_RBUTTON 0x02
+#define VK_CANCEL 0x03
+#define VK_MBUTTON 0x04
+#define VK_XBUTTON1 0x05
+#define VK_XBUTTON2 0x06
+#define VK_BACK 0x08
+#define VK_TAB 0x09
+#define VK_CLEAR 0x0C
+#define VK_RETURN 0x0D
+#define VK_SHIFT 0x10
+#define VK_CONTROL 0x11
+#define VK_MENU 0x12
+#define VK_PAUSE 0x13
+#define VK_CAPITAL 0x14
+#define VK_KANA 0x15
+#define VK_HANGUEL 0x15
+#define VK_HANGUL 0x15
+#define VK_JUNJA 0x17
+#define VK_FINAL 0x18
+#define VK_HANJA 0x19
+#define VK_KANJI 0x19
+#define VK_ESCAPE 0x1B
+#define VK_CONVERT 0x1C
+#define VK_NONCONVERT 0x1D
+#define VK_ACCEPT 0x1E
+#define VK_MODECHANGE 0x1F
+#define VK_SPACE 0x20
+#define VK_PRIOR 0x21
+#define VK_NEXT 0x22
+#define VK_END 0x23
+#define VK_HOME 0x24
+#define VK_LEFT 0x25
+#define VK_UP 0x26
+#define VK_RIGHT 0x27
+#define VK_DOWN 0x28
+#define VK_SELECT 0x29
+#define VK_PRINT 0x2A
+#define VK_EXECUTE 0x2B
+#define VK_SNAPSHOT 0x2C
+#define VK_INSERT 0x2D
+#define VK_DELETE 0x2E
+#define VK_HELP 0x2F
+#define VK_LWIN 0x5B
+#define VK_RWIN 0x5C
+#define VK_APPS 0x5D
+#define VK_SLEEP 0x5F
+#define VK_NUMPAD0 0x60
+#define VK_NUMPAD1 0x61
+#define VK_NUMPAD2 0x62
+#define VK_NUMPAD3 0x63
+#define VK_NUMPAD4 0x64
+#define VK_NUMPAD5 0x65
+#define VK_NUMPAD6 0x66
+#define VK_NUMPAD7 0x67
+#define VK_NUMPAD8 0x68
+#define VK_NUMPAD9 0x69
+#define VK_MULTIPLY 0x6A
+#define VK_ADD 0x6B
+#define VK_SEPARATOR 0x6C
+#define VK_SUBTRACT 0x6D
+#define VK_DECIMAL 0x6E
+#define VK_DIVIDE 0x6F
+#define VK_F1 0x70
+#define VK_F2 0x71
+#define VK_F3 0x72
+#define VK_F4 0x73
+#define VK_F5 0x74
+#define VK_F6 0x75
+#define VK_F7 0x76
+#define VK_F8 0x77
+#define VK_F9 0x78
+#define VK_F10 0x79
+#define VK_F11 0x7A
+#define VK_F12 0x7B
+#define VK_F13 0x7C
+#define VK_F14 0x7D
+#define VK_F15 0x7E
+#define VK_F16 0x7F
+#define VK_F17 0x80
+#define VK_F18 0x81
+#define VK_F19 0x82
+#define VK_F20 0x83
+#define VK_F21 0x84
+#define VK_F22 0x85
+#define VK_F23 0x86
+#define VK_F24 0x87
+#define VK_NUMLOCK 0x90
+#define VK_SCROLL 0x91
+#define VK_LSHIFT 0xA0
+#define VK_RSHIFT 0xA1
+#define VK_LCONTROL 0xA2
+#define VK_RCONTROL 0xA3
+#define VK_LMENU 0xA4
+#define VK_RMENU 0xA5
+#define VK_BROWSER_BACK 0xA6
+#define VK_BROWSER_FORWARD 0xA7
+#define VK_BROWSER_REFRESH 0xA8
+#define VK_BROWSER_STOP 0xA9
+#define VK_BROWSER_SEARCH 0xAA
+#define VK_BROWSER_FAVORITES 0xAB
+#define VK_BROWSER_HOME 0xAC
+#define VK_VOLUME_MUTE 0xAD
+#define VK_VOLUME_DOWN 0xAE
+#define VK_VOLUME_UP 0xAF
+#define VK_MEDIA_NEXT_TRACK 0xB0
+#define VK_MEDIA_PREV_TRACK 0xB1
+#define VK_MEDIA_STOP 0xB2
+#define VK_MEDIA_PLAY_PAUSE 0xB3
+#define VK_LAUNCH_MAIL 0xB4
+#define VK_LAUNCH_MEDIA_SELECT 0xB5
+#define VK_LAUNCH_APP1 0xB6
+#define VK_LAUNCH_APP2 0xB7
+#define VK_OEM_1 0xBA
+#define VK_OEM_PLUS 0xBB
+#define VK_OEM_COMMA 0xBC
+#define VK_OEM_MINUS 0xBD
+#define VK_OEM_PERIOD 0xBE
+#define VK_OEM_2 0xBF
+#define VK_OEM_3 0xC0
+#define VK_OEM_4 0xDB
+#define VK_OEM_5 0xDC
+#define VK_OEM_6 0xDD
+#define VK_OEM_7 0xDE
+#define VK_OEM_8 0xDF
+#define VK_OEM_102 0xE2
+#define VK_PROCESSKEY 0xE5
+#define VK_PACKE 0xE7
+#define VK_ATTN 0xF6
+#define VK_CRSEL 0xF7
+#define VK_EXSEL 0xF8
+#define VK_EREOF 0xF9
+#define VK_PLAY 0xFA
+#define VK_ZOOM 0xFB
+#define VK_NONAME 0xFC
+#define VK_PA1 0xFD
+#define VK_OEM_CLEAR 0xFE
+
+extern volatile unsigned char ps2keystatus[256]; // 仮想コードに相当するキーの状態（Onの時1）
+extern volatile unsigned short vkey; //仮想キーコード
+extern unsigned char lockkey; // 初期化時にLockキーの状態指定。下位3ビットが<CAPSLK><NUMLK><SCRLK>
+extern unsigned char keytype; // キーボードの種類。0：日本語109キー、1：英語104キー
+
+//int ps2init(); // PS/2ライブラリ関連初期化。正常終了0、エラーで-1を返す
+//unsigned char shiftkeys(); // SHIFT関連キーの押下状態を返す
+#define shiftkeys() 0 // SHIFT関連キーの押下状態を返す
+unsigned char ps2readkey();
+// 入力された1つのキーのキーコードをグローバル変数vkeyに格納（押されていなければ0を返す）
+// 下位8ビット：キーコード
+// 上位8ビット：シフト状態（押下：1）、上位から<0><CAPSLK><NUMLK><SCRLK><Win><ALT><CTRL><SHIFT>
+// 英数・記号文字の場合、戻り値としてASCIIコード（それ以外は0を返す）
+
+// PIC32MX1xx/2xx版のキーボードとボタンの排他利用システムで使用する関数、マクロ
+//void ps2mode(); // PS/2を有効にする
+#define ps2mode() (0)
+//void buttonmode(); // ボタンを有効にする
+#define buttonmode() (0)
+//#define inPS2MODE() ((LATA&2)>>1) // モード確認用マクロ。PS/2モードの場合1、ボタンモードの場合0を返す
+#define inPS2MODE() (0)

--- /dev/null
+++ b/mips/protozoa/interface/videoout.h
@@ -0,0 +1,130 @@
+#include "LCDdriver.h"
+
+#if LCD_ALIGNMENT == VERTICAL
+#define WIDTH_X1 30 // 横方向文字数1
+#define WIDTH_X2 40 // 横方向文字数2(6ドットフォント利用時)
+#define WIDTH_Y 40 // 縦方向文字数
+#define ATTROFFSET1 (WIDTH_X1*WIDTH_Y) // VRAM上のカラーパレット格納位置1
+#define ATTROFFSET2 (WIDTH_X2*WIDTH_Y) // VRAM上のカラーパレット格納位置2
+#define G_X_RES 240 // 横方向解像度
+#define G_Y_RES 320 // 縦方向解像度
+#else
+#define WIDTH_X1 40 // 横方向文字数1
+#define WIDTH_X2 52 // 横方向文字数2(6ドットフォント利用時)
+#define WIDTH_Y 30 // 縦方向文字数
+#define ATTROFFSET1 (WIDTH_X1*WIDTH_Y) // VRAM上のカラーパレット格納位置1
+#define ATTROFFSET2 (WIDTH_X2*WIDTH_Y) // VRAM上のカラーパレット格納位置2
+#define G_X_RES 320 // 横方向解像度
+#define G_Y_RES 240 // 縦方向解像度
+#endif
+
+// 入力ボタンのポート、ビット定義
+#define KEYPORT PORTB
+#define KEYDOWN  0x0004
+#define KEYLEFT  0x0008
+#define KEYRIGHT 0x0010
+#define KEYUP    0x0020
+#define KEYSTART 0x0080
+#define KEYFIRE  0x0100
+#define KEYMASK (KEYSTART | KEYFIRE | KEYUP | KEYDOWN | KEYLEFT | KEYRIGHT)
+#define KEY_DS LATASET=0x0008
+#define KEY_EN LATACLR=0x0008
+
+//extern volatile char drawing;		//　表示期間中は-1
+extern volatile unsigned short drawcount;		//　1画面表示終了ごとに1足す。アプリ側で0にする。
+							// 最低1回は画面表示したことのチェックと、アプリの処理が何画面期間必要かの確認に利用。
+extern unsigned char TVRAM[]; //テキストビデオメモリ
+//extern unsigned short *gVRAM; //グラフィックVRAM開始位置のポインタ
+
+extern const unsigned char FontData[]; //フォントパターン定義
+//extern const unsigned char FontData[],FontData2[]; //フォントパターン定義
+extern unsigned char *cursor;
+extern unsigned char cursorcolor;
+extern unsigned char *fontp;
+extern unsigned char twidth; //テキスト1行文字数（30 or 40）
+extern unsigned int bgcolor; // バックグランドカラー
+
+//void start_composite(void); //カラーコンポジット出力開始
+//void stop_composite(void); //カラーコンポジット出力停止
+//void init_composite(void); //カラーコンポジット出力初期化
+void clearscreen(void); //テキスト画面クリア
+void set_palette(unsigned char n,unsigned char b,unsigned char r,unsigned char g); //テキストパレット設定
+void set_bgcolor(unsigned char b,unsigned char r,unsigned char g); //バックグランドカラー設定
+void set_graphmode(unsigned char m); //グラフィックモード変更
+void init_textgraph(void); //テキスト機能利用準備
+void init_graphic(void); //グラフィック機能利用準備
+void set_width(unsigned char m); //30文字モード(8ドットフォント)と40文字モード(6ドットフォント)の切り替え
+void textredraw(void);
+	// テキスト画面再描画、テキストVRAMの内容にしたがって液晶に出力
+void vramscroll(void);
+	//1行スクロール
+void vramscrolldown(void);
+	//1行逆スクロール
+void setcursor(unsigned char x,unsigned char y,unsigned char c);
+	//カーソル位置とカラーを設定
+void setcursorcolor(unsigned char c);
+	//カーソル位置そのままでカラー番号をcに設定
+void printchar(unsigned char n);
+	//カーソル位置にテキストコードnを1文字表示し、カーソルを1文字進める
+void printstr(unsigned char *s);
+	//カーソル位置に文字列sを表示
+void printnum(unsigned int n);
+	//カーソル位置に符号なし整数nを10進数表示
+void printnum2(unsigned int n,unsigned char e);
+	//カーソル位置に符号なし整数nをe桁の10進数表示（前の空き桁部分はスペースで埋める）
+void cls(void);
+	//テキスト画面消去し、カーソルを先頭に移動
+void startPCG(unsigned char *p,int a);
+	// RAMフォント（PCG）の利用開始、pがフォント格納場所、aが0以外でシステムフォントをコピー
+void stopPCG(void);
+	// RAMフォント（PCG）の利用停止
+
+void g_clearscreen(void);
+//グラフィック画面クリア
+void g_set_palette(unsigned char n,unsigned char b,unsigned char r,unsigned char g);
+//グラフィック用カラーパレット設定
+
+void g_pset(int x,int y,unsigned int c);
+// (x,y)の位置にカラーcで点を描画
+
+void g_putbmpmn(int x,int y,char m,char n,const unsigned char bmp[]);
+// 横m*縦nドットのキャラクターを座標x,yに表示
+// unsigned char bmp[m*n]配列に、単純にカラー番号を並べる
+// カラー番号が0の部分は透明色として扱う
+
+void g_clrbmpmn(int x,int y,char m,char n);
+// 縦m*横nドットのキャラクター消去
+// カラー0で塗りつぶし
+
+void g_gline(int x1,int y1,int x2,int y2,unsigned int c);
+// (x1,y1)-(x2,y2)にカラーcで線分を描画
+
+void g_hline(int x1,int x2,int y,unsigned int c);
+// (x1,y)-(x2,y)への水平ラインを高速描画
+
+void g_circle(int x0,int y0,unsigned int r,unsigned int c);
+// (x0,y0)を中心に、半径r、カラーcの円を描画
+
+void g_boxfill(int x1,int y1,int x2,int y2,unsigned int c);
+// (x1,y1),(x2,y2)を対角線とするカラーcで塗られた長方形を描画
+
+void g_circlefill(int x0,int y0,unsigned int r,unsigned int c);
+// (x0,y0)を中心に、半径r、カラーcで塗られた円を描画
+
+void g_putfont(int x,int y,unsigned int c,int bc,unsigned char n);
+//8*8ドットのアルファベットフォント表示
+//座標（x,y)、カラー番号c
+//bc:バックグランドカラー、負数の場合無視
+//n:文字番号
+
+void g_printstr(int x,int y,unsigned int c,unsigned int bc,unsigned char *s);
+//座標(x,y)からカラー番号cで文字列sを表示、bc:バックグランドカラー
+
+void g_printnum(int x,int y,unsigned int c,unsigned int bc,unsigned int n);
+//座標(x,y)にカラー番号cで数値nを表示、bc:バックグランドカラー
+
+void g_printnum2(int x,int y,unsigned int c,unsigned int bc,unsigned int n,unsigned char e);
+//座標(x,y)にカラー番号cで数値nを表示、bc:バックグランドカラー、e桁で表示
+
+unsigned int g_color(int x,int y);
+//座標(x,y)のVRAM上の現在のパレット番号を返す、画面外は0を返す

--- /dev/null
+++ b/mips/protozoa/library.c
@@ -0,0 +1,1108 @@
+/*
+   This file is provided under the LGPL license ver 2.1.
+   Written by Katsumi.
+   http://hp.vector.co.jp/authors/VA016157/
+   [e-mail]
+*/
+
+/*
+	This file is shared by Megalopa and Zoea
+*/
+
+#include <xc.h>
+#include "main.h"
+#include "compiler.h"
+#include "api.h"
+#include "interface/keyinput.h"
+#include "stdlib.h"
+#include "math.h"
+
+/*
+   Local global variables used for graphic
+ */
+
+static int g_gcolor=7;
+static int g_prev_x=0;
+static int g_prev_y=0;
+
+int lib_setdir(int mode,char* path){
+	int ret;
+	ret=FSchdir(path);
+	if (mode==LIB_SETDIR && ret) err_file();
+	return ret;
+}
+
+int lib_getdir(){
+	char* path;
+	path=calloc_memory(32,-1);
+	FSgetcwd (path,128);
+	return (int)path;
+}
+
+int lib_read(int mode, unsigned int label){
+	unsigned int i,code,code2;
+	static unsigned int pos=0;
+	static unsigned int in_data=0;
+	static unsigned char skip=0;
+	if (label) {
+		// RESTORE function
+		switch(mode){
+			case 0:
+				// label is label data
+				i=(int)search_label(label);
+				if (!i) {
+					err_data_not_found();
+					return 0;
+				}
+				break;
+			case 1:
+				// label is pointer
+				i=label;
+				break;
+			case 2:
+			default:
+				// Reset data/read
+				pos=0;
+				in_data=0;
+				skip=0;
+				return 0;
+		}
+		i-=(int)(&g_object[0]);
+		pos=i/4;
+		in_data=0;
+	}
+	// Get data
+	if (in_data==0) {
+		for(i=pos;i<g_objpos;i++){
+			code=g_object[i];
+			code2=g_object[i+1];
+			if ((code&0xFFFF0000)!=0x04110000) continue;
+			// "bgezal zero," assembly found.
+			// Check if 0x00000020,0x00000021,0x00000022, or 0x00000023 follows
+			if ((code2&0xfffffffc)!=0x00000020) {// add/addu/sub/subu        zero,zero,zero
+				// If not, skip following block (it's strig).
+				i+=code&0x0000FFFF;
+				continue;
+			}
+			// DATA region found.
+			in_data=(code&0x0000FFFF)-1;
+			pos=i+2;
+			skip=code2&0x03;
+			break;
+		}
+		if (g_objpos<=i) {
+			err_data_not_found();
+			return 0;
+		}
+	}
+	if (label) {
+		// RESTORE function. Return pointer.
+		return ((int)&g_object[pos])+skip;
+	} else {
+		switch(mode){
+			case 0:
+				// READ() function
+				in_data--;
+				return g_object[pos++];
+			case 1:
+			default:
+				// CREAD() function
+				i=g_object[pos];
+				i>>=skip*8;
+				i&=0xff;
+				if ((++skip)==4) {
+					skip=0;
+					in_data--;
+					pos++;
+				}
+				return i;
+		}
+	}
+}
+
+void reset_dataread(){
+	lib_read(2,1);
+}
+
+char* lib_midstr(int var_num, int pos, int len){
+	int i;
+	char* str;
+	char* ret;
+	if (0<=pos) {
+		// String after "pos" position.
+		str=(char*)(g_var_mem[var_num]+pos);
+	} else {
+		// String right "pos" characters.
+		// Determine length
+		str=(char*)g_var_mem[var_num];
+		for(i=0;str[i];i++);
+		if (0<=(i+pos)) {
+			str=(char*)(g_var_mem[var_num]+i+pos);
+		}
+	}
+	if (len<0) {
+		// Length is not specified.
+		// Return the string to the end.
+		return str;
+	}
+	// Length is specified.
+	// Construct temporary string containing specified number of characters.
+	ret=alloc_memory((len+1+3)/4,-1);
+	// Copy string.
+	for(i=0;(ret[i]=str[i])&&(i<len);i++);
+	ret[len]=0x00;
+	return ret;
+}
+
+void lib_clear(void){
+	int i;
+	// All variables (including temporary and permanent ones) will be integer 0
+	for(i=0;i<ALLOC_BLOCK_NUM;i++){
+		g_var_mem[i]=0;
+	}
+	// Clear memory allocation area
+	for(i=0;i<ALLOC_BLOCK_NUM;i++){
+		g_var_size[i]=0;
+	}
+	// Cancel PCG
+	stopPCG();
+	g_pcg_font=0;
+	// Stop using graphic
+	g_use_graphic=1; // Force set_graphmode(0) (see usegraphic() function)
+	usegraphic(0);
+}
+
+void lib_let_str(char* str, int var_num){
+	int begin,end,size;
+	// Save pointer
+	g_var_mem[var_num]=(int)str;
+	// Determine size
+	for(size=0;str[size];size++);
+	// Check if str is in heap area.
+	begin=(int)str;
+	end=(int)(&str[size]);
+	if (begin<(int)(&g_heap_mem[0]) || (int)(&g_heap_mem[g_max_mem])<=end) {
+		// String is not within allcated block
+		return;
+	}
+	// Str is in heap area. Calculate values stored in heap data dimension
+	begin-=(int)(&g_heap_mem[0]);
+	begin>>=2;
+	end-=(int)(&g_heap_mem[0]);
+	end>>=2;
+	size=end-begin+1;
+	g_var_pointer[var_num]=begin;
+	g_var_size[var_num]=size;
+}
+
+int lib_rnd(){
+	int y;
+	y=g_rnd_seed;
+	y = y ^ (y << 13);
+	y = y ^ (y >> 17);
+	y = y ^ (y << 5);
+	g_rnd_seed=y;
+	return y&0x7fff;
+}
+
+char* lib_chr(int num){
+	char* str;
+	str=alloc_memory(1,-1);
+	str[0]=num&0x000000FF;
+	str[1]=0x00;
+	return str;
+}
+
+char* lib_dec(int num){
+	char* str;
+	int i,j,minus;
+	char b[12];
+	b[11]=0x00;
+	if (num<0) {
+		minus=1;
+		num=0-num;
+	} else {
+		minus=0;
+	}
+	for (i=10;0<i;i--) {
+		if (num==0 && i<10) break; 
+		b[i]='0'+rem10_32(num);
+		num=div10_32(num);
+	}
+	if (minus) {
+		b[i]='-';
+	} else {
+		i++;
+	}
+	str=alloc_memory(3,-1);
+	for(j=0;str[j]=b[i++];j++);
+	return str;
+}
+
+char* lib_hex(int num, int width){
+	char* str;
+	int i,j,minus;
+	char b[8];
+	str=alloc_memory(3,-1);
+	for(i=0;i<8;i++){
+		b[i]="0123456789ABCDEF"[(num>>(i<<2))&0x0F];
+	}
+	// Width must be between 0 and 8;
+	if (width<0||8<width) width=8;
+	if (width==0) {
+		// Width not asigned. Use minimum width.
+		for(i=7;0<i;i--){
+			if ('0'<b[i]) break;
+		}
+	} else {
+		// Constant width
+		i=width-1;
+	}
+	// Copy string to allocated block.
+	for(j=0;0<=i;i--){
+		str[j++]=b[i];
+	}
+	str[j]=0x00;
+	return str;
+}
+
+char* lib_connect_string(char* str1, char* str2){
+	int i,j;
+	char b;
+	char* result;
+	// Determine total length
+	for(i=0;str1[i];i++);
+	for(j=0;str2[j];j++);
+	// Allocate a block for new string
+	result=alloc_memory((i+j+1+3)/4,-1);
+	// Create connected strings 
+	for(i=0;b=str1[i];i++) result[i]=b;
+	for(j=0;b=str2[j];j++) result[i+j]=b;
+	result[i+j]=0x00;
+	free_temp_str(str1);
+	free_temp_str(str2);
+	return result;
+}
+
+void lib_string(int mode){
+	int i;
+	switch(mode){
+		case 0:
+			// CR
+			printchar('\n');
+			return;
+		case 1:
+			// ,
+			printcomma();
+			return;
+		default:
+			return;
+	}
+}
+
+void* lib_label(unsigned int label){
+	// This routine is used to jump to address dynamically determined
+	// in the code; for example: "GOTO 100+I"
+	unsigned int i,code,search;
+	void* ret;  
+	if (label&0xFFFF0000) {
+		// Label is not supported.
+		// Line number must bs less than 65536.
+		err_label_not_found();
+	} else {
+		// Line number
+		ret=search_label(label);
+		if (ret) return ret;
+		// Line number not found.
+		err_label_not_found();
+	}
+}
+
+int lib_keys(int mask){
+	int keys;
+	keys=readbuttons();
+	keys=
+		((keys&KEYUP)?    0:1)|
+		((keys&KEYDOWN)?  0:2)|
+		((keys&KEYLEFT)?  0:4)|
+		((keys&KEYRIGHT)? 0:8)|
+		((keys&KEYSTART)? 0:16)|
+		((keys&KEYFIRE)?  0:32);
+	return mask&keys;
+}
+
+int lib_val(char* str){
+	int i;
+	int val=0;
+	int sign=1;
+	char b;
+	// Skip blanc
+	for(i=0;0<=str[i] && str[i]<0x21;i++);
+	// Skip '+'
+	if (str[i]=='+') i++;
+	// Check '-'
+	if (str[i]=='-') {
+		sign=-1;
+		i++;
+	}
+	// Check '0x' or '$'
+	if (str[i]=='$' || str[i]=='0' && (str[i+1]=='x' || str[i+1]=='X')) {
+		// Hexadecimal
+		if (str[i++]=='0') i++;
+		while(1) {
+			b=str[i++];
+			if ('0'<=b && b<='9') {
+				val<<=4;
+				val+=b-'0';
+			} else if ('a'<=b && b<='f') {
+				val<<=4;
+				val+=b-'a'+10;
+			} else if ('A'<=b && b<='F') {
+				val<<=4;
+				val+=b-'A'+10;
+			} else {
+				break;
+			}
+		}
+	} else {
+		// Decimal
+		while(1) {
+			b=str[i++];
+			if ('0'<=b && b<='9') {
+				val*=10;
+				val+=b-'0';
+			} else {
+				break;
+			}
+		}
+	}
+	return val*sign;
+}
+
+char* lib_input(){
+	// Allocate memory for strings with 63 characters
+	char *str=calloc_memory((63+1)/4,-1);
+	// Enable PS/2 keyboard
+	if (!inPS2MODE()) {
+		ps2mode();
+		ps2init();
+	}
+	// Clear key buffer
+	do ps2readkey();
+	while(vkey!=0);
+	// Get string as a line
+	lineinput(str,63);
+	check_break();
+	return str;
+}
+
+unsigned char lib_inkey(int key){
+	int i;
+	// Enable PS/2 keyboard
+	if (!inPS2MODE()) {
+		ps2mode();
+		ps2init();
+	}
+	if (key) {
+		return ps2keystatus[key&0xff];
+	} else {
+		for(i=0;i<256;i++){
+			if (ps2keystatus[i]) return i;
+		}
+		return 0;
+	}
+}
+
+void lib_usepcg(int mode){
+	// Modes; 0: stop PCG, 1: use PCG, 2: reset PCG and use it
+	switch(mode){
+		case 0:
+			// Stop PCG
+			stopPCG();
+			break;
+		case 2:
+			// Reset PCG and use it
+			if (g_pcg_font) {
+				free_non_temp_str(g_pcg_font);
+				g_pcg_font=0;
+			}
+			// Continue to case 1:
+		case 1:
+		default:
+			// Use PCG
+			if (g_pcg_font) {
+				startPCG(g_pcg_font,0);
+			} else {
+				g_pcg_font=alloc_memory(256*8/4,ALLOC_PCG_BLOCK);
+				startPCG(g_pcg_font,1);
+			}
+			break;
+	}
+}
+
+void lib_pcg(unsigned int ascii,unsigned int fontdata1,unsigned int fontdata2){
+	unsigned int* pcg;
+	// If USEPCG has not yet executed, do now.
+	if (!g_pcg_font) lib_usepcg(1);
+	pcg=(unsigned int*)g_pcg_font;
+	// 0 <= ascii <= 0xff
+	ascii&=0xff;
+	// Update font data
+	ascii<<=1;
+	pcg[ascii]=(fontdata1>>24)|((fontdata1&0xff0000)>>8)|((fontdata1&0xff00)<<8)|(fontdata1<<24);
+	pcg[ascii+1]=(fontdata2>>24)|((fontdata2&0xff0000)>>8)|((fontdata2&0xff00)<<8)|(fontdata2<<24);
+}
+
+void lib_usegraphic(int mode){
+	usegraphic(mode);
+	// Move current point to (0,0)
+	g_prev_x=g_prev_y=0;
+}
+void lib_wait(int period){
+	int i;
+	unsigned short dcount;
+	for(i=0;i<period;i++){
+		dcount=drawcount;
+		while(dcount==drawcount){
+			asm (WAIT);
+			check_break();
+		}
+	}
+}
+
+int lib_graphic(int v0,enum functions func){
+	unsigned char b;
+	int x1=g_libparams[1];
+	int y1=g_libparams[2];
+	int x2=g_libparams[3];
+	int y2=g_libparams[4];
+	// Disable if graphic area is not defined.
+	if (!g_graphic_area) return;
+	// If C is omitted in parameters, use current color.
+	if (v0==-1) {
+		v0=g_gcolor;
+	}
+	// If X1 or Y1 is 0x80000000, use the previous values.
+	if (x1==0x80000000) x1=g_prev_x;
+	if (y1==0x80000000) y1=g_prev_y;
+	switch(func){
+		case FUNC_POINT:// X1,Y1
+			g_prev_x=x1;
+			g_prev_y=y1;
+			break;
+		case FUNC_PSET:// X1,Y1[,C]
+			g_pset(x1,y1,v0);
+			g_prev_x=x1;
+			g_prev_y=y1;
+			break;
+		case FUNC_LINE:// X1,Y1,X2,Y2[,C]
+			if (y1==y2) g_hline(x1,x2,y1,v0);
+			else g_gline(x1,y1,x2,y2,v0);
+			g_prev_x=x2;
+			g_prev_y=y2;
+			break;
+		case FUNC_BOXFILL:// X1,Y1,X2,Y2[,C]
+			g_boxfill(x1,y1,x2,y2,v0);
+			g_prev_x=x2;
+			g_prev_y=y2;
+			break;
+		case FUNC_CIRCLE:// X1,Y1,R[,C]
+			g_circle(x1,y1,x2,v0);
+			g_prev_x=x1;
+			g_prev_y=y1;
+			break;
+		case FUNC_CIRCLEFILL:// X1,Y1,R[,C]
+			g_circlefill(x1,y1,x2,v0);
+			g_prev_x=x1;
+			g_prev_y=y1;
+			break;
+		case FUNC_GPRINT:// X1,Y1,C,BC,S$
+			g_printstr(x1,y1,x2,y2,(unsigned char*)v0);
+			// Move current X,Y according to the string
+			while(b=((unsigned char*)v0)[0]){
+				v0++;
+				if (b==0x0d) {
+					x1=0;
+					y1+=8;
+				} else {
+					x1+=8;
+				}
+			}
+			g_prev_x=x1;
+			g_prev_y=y1;
+			break;
+		case FUNC_PUTBMP2:// X1,Y1,M,N,BMP(label)
+			// Search CDATA
+			// It starts from either 0x00000020,0x00000021,0x00000022, or 0x00000023.
+			while((((unsigned int*)v0)[0]&0xfffffffc)!=0x00000020) v0+=4;
+			// CDATA starts from next word.
+			// MLB 3 bytes show skip byte(s).
+			v0+=4+(((unsigned int*)v0)[0]&0x03);
+			// Contunue to FUNC_PUTBMP.
+		case FUNC_PUTBMP:// X1,Y1,M,N,BMP(pointer)
+			g_putbmpmn(x1,y1,x2,y2,(const unsigned char*)v0);
+			g_prev_x=x1;
+			g_prev_y=y1;
+			break;
+		case FUNC_GCOLOR:// (X1,Y1)
+			v0=g_color(x1,y1);
+			break;
+		default:
+			break;
+	}
+	return v0;
+}
+
+void lib_var_push(int a0, int a1, int* sp){
+	// Note that sp[1] is used for string return address
+	// sp[2] can be used to store flags
+	// sp[3] etc can be used to store variable values
+	int i,params;
+	unsigned char varnum;
+	unsigned int strflags=0;
+	int stack=3;
+	for(i=0;i<8;i++){
+		// Prepare parameter
+		switch(i){
+			case 0:
+				params=a0;
+				break;
+			case 4:
+				params=a1;
+				break;
+			default:
+				break;
+		}
+		// Get variable number
+		varnum=params&0xff;
+		params>>=8;
+		if (varnum==0) break; // No more variable. End the loop.
+		varnum--;
+		sp[stack++]=g_var_mem[varnum];
+		if (g_var_size[varnum] && g_var_mem[varnum]==(int)(&g_var_pointer[varnum])) {
+			// strflags change using varnum
+			strflags|=1<<i;
+			// Copy to VAR_BLOCK
+			move_to_perm_block(varnum);
+		}
+		// Clear variable
+		g_var_mem[varnum]=0;
+	}
+	// Store string flags
+	sp[2]=strflags;
+}
+
+void lib_var_pop(int a0, int a1, int* sp){
+	// Note that sp is 4 bytes larger than that in lib_var_push
+	// sp[1] was used to store flags
+	// sp[2] etc can be used to store variable values
+	int i,params;
+	unsigned char varnum;
+	int stack=2;
+	unsigned int strflags=sp[1];
+	for(i=0;i<8;i++){
+		// Prepare parameter
+		switch(i){
+			case 0:
+				params=a0;
+				break;
+			case 4:
+				params=a1;
+				break;
+			default:
+				break;
+		}
+		// Get variable number
+		varnum=params&0xff;
+		params>>=8;
+		if (varnum==0) break; // No more variable. End the loop.
+		varnum--;
+		g_var_mem[varnum]=sp[stack++];
+		if (strflags&(1<<i)) {
+			// Restore from VAR_BLOCK
+			move_from_perm_block(varnum);
+		}
+	}
+}
+
+
+char* lib_sprintf(char* format, int data){
+	char* str;
+	int i;
+	char temp[4];
+	if (!format) format="%g";
+	i=snprintf((char*)(&temp[0]),4,format,data)+1;
+	str=alloc_memory((i+3)/4,-1);
+	snprintf(str,i,format,data);
+	return str;
+}
+
+int lib_floatfuncs(int ia0,int iv0,enum functions a1){
+	volatile float a0,v0;
+	((int*)(&a0))[0]=ia0;
+	((int*)(&v0))[0]=iv0;
+	switch(a1){
+		case FUNC_FLOAT:
+			v0=(float)iv0;
+			break;
+		case FUNC_INT:
+			return (int)v0;
+		case FUNC_VALSHARP:
+			v0=strtof((const char*)iv0,0);
+			break;
+		case FUNC_SIN:
+			v0=sinf(v0);
+			break;
+		case FUNC_COS:
+			v0=cosf(v0);
+			break;
+		case FUNC_TAN:
+			v0=tanf(v0);
+			break;
+		case FUNC_ASIN:
+			v0=asinf(v0);
+			break;
+		case FUNC_ACOS:
+			v0=acosf(v0);
+			break;
+		case FUNC_ATAN:
+			v0=atanf(v0);
+			break;
+		case FUNC_ATAN2:
+			v0=atan2f(v0,a0);
+			break;
+		case FUNC_SINH:
+			v0=sinhf(v0);
+			break;
+		case FUNC_COSH:
+			v0=coshf(v0);
+			break;
+		case FUNC_TANH:
+			v0=tanhf(v0);
+			break;
+		case FUNC_EXP:
+			v0=expf(v0);
+			break;
+		case FUNC_LOG:
+			v0=logf(v0);
+			break;
+		case FUNC_LOG10:
+			v0=log10f(v0);
+			break;
+		case FUNC_POW:
+			v0=powf(v0,a0);
+			break;
+		case FUNC_SQRT:
+			v0=sqrtf(v0);
+			break;
+		case FUNC_CEIL:
+			v0=ceilf(v0);
+			break;
+		case FUNC_FLOOR:
+			v0=floorf(v0);
+			break;
+		case FUNC_FABS:
+			v0=fabsf(v0);
+			break;
+		case FUNC_MODF:
+			v0=modff(v0,(void*)&a0);
+			break;
+		case FUNC_FMOD:
+			v0=fmodf(v0,a0);
+			break;
+		default:
+			err_unknown();
+			break;
+	}
+	return ((int*)(&v0))[0];
+};
+
+int* lib_dim(int varnum, int argsnum, int* sp){
+	int i,j;
+	static int* heap;
+	// Calculate total length.
+	int len=0;  // Total length
+	int size=1; // Size of current block
+	for(i=1;i<=argsnum;i++){
+		size*=sp[i]+1;
+		len+=size;
+	}
+	// Allocate memory
+	heap=calloc_memory(len,varnum);
+	// Construct pointers
+	len=0;
+	size=1;
+	for(i=1;i<argsnum;i++){
+		size*=sp[i]+1;
+		for(j=0;j<size;j++){
+			heap[len+j]=(int)&heap[len+size+(sp[i+1]+1)*j];
+		}
+		len+=size;
+	}
+	return heap;
+};
+
+int lib_file_textlen(FSFILE* fhandle){
+	char buff[128];
+	int i,textlen,len,seek;
+	seek=FSftell(fhandle);
+	len=FSfread(&buff[0],1,128,fhandle);
+	textlen=0;
+	for(i=0;i<len-1;i++){ // Read 127 bytes for supporting CRLF
+		if (buff[i]==0x0d) {
+			if (i<len && buff[i+1]==0x0a) i++;
+			break;
+		} else if (buff[i]==0x0a) {
+			break;
+		}
+		if (i==len-2) {
+			// reached the end of buffer. Read next 127 bytes
+			textlen+=127;
+			buff[0]=buff[127];
+			len=FSfread(&buff[1],1,127,fhandle);
+			// Continue with i=0
+			i=-1;
+		}
+	}
+	// The last return code must be included to caluclate total length.
+	textlen+=i+1;
+	// Return to original position
+	FSfseek(fhandle,seek,SEEK_SET);
+	return textlen;
+}
+
+int lib_file(enum functions func, int a0, int a1, int v0){
+	static FSFILE* s_fhandle[2]={0,0};
+	static char activefhandle=0;
+	static int numinline=0;
+	FSFILE* fhandle=0;
+	int i;
+	int buff[1];
+	char* str;
+	if (activefhandle) fhandle=s_fhandle[activefhandle-1];
+	switch(func){
+		case FUNC_FINIT:
+			// This function is not BASIC statement/function but used from
+			// running routine. 
+			for(i=0;i<2;i++){
+				if (s_fhandle[i]) FSfclose(s_fhandle[i]);
+				s_fhandle[i]=0; 
+			}
+			activefhandle=0;
+			numinline=0;
+			break;
+		case FUNC_FOPEN:   // Return 0 when called as a function.
+		case FUNC_FOPENST: // Stop with error when called as a statement.
+			activefhandle=0;
+			// Check if file handle is free to use, first.
+			switch(v0){
+				case 0:
+					// File handle was not designated
+					// Force handle=1 and continue to following cases.
+					v0=1;
+				case 1:
+				case 2:
+					// File handle was designated
+					// Check if not used yet.
+					if (s_fhandle[v0-1]) {
+						// This file handle has been occupied.
+						err_file();
+						return 0;
+					}
+					// OK. This file handle can be asigned for new file opened.
+					break;
+				default:
+					err_invalid_param();
+					return 0;
+			}
+			// Open a file
+			fhandle=FSfopen ((const char*) a0, (const char*) a1);
+			if (!fhandle) {
+				if (func==FUNC_FOPENST) err_file();
+				return 0;
+			}
+			// The file is succesfully opened. Asign file handle.
+			s_fhandle[v0-1]=fhandle;
+			activefhandle=v0;
+			return v0;
+		case FUNC_FILE:
+			switch(v0){
+				case 1:
+				case 2:
+					if (s_fhandle[v0]) {
+						activefhandle=v0;
+						break;
+					}
+				default:
+					err_invalid_param();
+			}
+			break;
+		case FUNC_FCLOSE:
+			switch(v0){
+				case 0:
+					break;
+				case 1:
+				case 2:
+					if (s_fhandle[v0-1]) activefhandle=v0;
+					if (activefhandle) fhandle=s_fhandle[activefhandle-1];
+					break;
+				default:
+					err_invalid_param();
+			}
+			if (fhandle) {
+				FSfclose(fhandle);
+				s_fhandle[activefhandle-1]=0;
+			}
+			activefhandle=0;
+			break;	
+		case FUNC_FINPUT:
+			if (fhandle) {
+				// Determine text length if called without parameter
+				if (v0==0) v0=lib_file_textlen(fhandle);
+				// Allocate temporary area for string
+				str=alloc_memory((v0+1+3)/4,-1);
+				// Read from SD card
+				v0=FSfread(str,1,v0,fhandle);
+				// Null string at the end.
+				str[v0]=0;
+				return (int)str;
+			} else {
+				err_file();
+				return (int)"";
+			}
+		case FUNC_FPRINTSTR:
+			// Like lib_printstr()
+			for(i=0;((char*)v0)[i];i++);
+			if (fhandle) {
+				if (!FSfwrite((char*)v0,1,i,fhandle)) err_file();
+			} else err_file();
+			numinline+=i;
+			break;
+		case FUNC_FSTRING:
+			// Like lib_string()
+			switch(v0){
+				case 0:
+					// CR
+					lib_file(FUNC_FPRINTSTR,a0,a1,(int)"\r\n");
+					numinline=0;
+					break;
+				case 1:
+					// ,
+					i=rem10_32(numinline);
+					lib_file(FUNC_FPRINTSTR,a0,a1,(int)("          "+i));
+					break;
+				default:
+					break;
+			}
+			break;
+		case FUNC_FGET:
+			if (fhandle) return FSfread((void*)a0,1,v0,fhandle);
+			err_file();
+			break;
+		case FUNC_FPUT:
+			if (fhandle) return FSfwrite((void*)a0,1,v0,fhandle);
+			err_file();
+			break;
+		case FUNC_FGETC:
+			if (fhandle) {
+				// Note: Little endian.
+				if (FSfread((void*)&buff[0],1,1,fhandle)) return buff[0]&0xff;
+				else return -1;
+			}
+			err_file();
+			break;
+		case FUNC_FPUTC:
+			if (fhandle) {
+				// Note: Little endian.
+				buff[0]=v0;
+				return FSfwrite((void*)&buff[0],1,1,fhandle);
+			}
+			err_file();
+			break;
+		case FUNC_FSEEK:
+			if (fhandle) return FSfseek(fhandle,v0,SEEK_SET);
+			err_file();
+			break;
+		case FUNC_FTELL:
+			if (fhandle) return FSftell(fhandle);
+			err_file();
+			break;
+		case FUNC_FLEN:
+			if (fhandle) return fhandle->size;
+			err_file();
+			break;
+		case FUNC_FEOF:
+			if (fhandle) return (fhandle->size<=FSftell(fhandle)) ? 1:0;
+			err_file();
+			break;
+		case FUNC_FREMOVE:
+			return FSremove((const char *)v0);
+		default:
+			err_unknown();
+	}
+	return v0;
+}
+
+int _call_library(int a0,int a1,int a2,enum libs a3);
+
+void call_library(void){
+	// Store s6 in g_s6
+	asm volatile("la $a2,%0"::"i"(&g_s6));
+	asm volatile("sw $s6,0($a2)");
+	// Copy $v0 to $a2 as 3rd argument of function
+	asm volatile("addu $a2,$v0,$zero");
+	// Store sp in g_libparams
+	asm volatile("la $v0,%0"::"i"(&g_libparams));
+	asm volatile("sw $sp,0($v0)");
+	// Jump to main routine
+	asm volatile("j _call_library");
+}
+
+int _call_library(int a0,int a1,int v0,enum libs a3){
+	// usage: call_lib_code(LIB_XXXX);
+	// Above code takes 2 words.
+	check_break();
+	switch(a3 & LIB_MASK){
+		case LIB_FLOAT:
+			return lib_float(a0,v0,(enum operator)(a3 & OP_MASK)); // see operator.c
+		case LIB_FLOATFUNCS:
+			return lib_floatfuncs(a0,v0,(enum functions)(a3 & FUNC_MASK));
+		case LIB_STRNCMP:
+			return strncmp((char*)g_libparams[1],(char*)g_libparams[2],v0);
+		case LIB_MIDSTR:
+			return (int)lib_midstr(a1,v0,a0);
+		case LIB_RND:
+			return (int)lib_rnd();
+		case LIB_DEC:
+			return (int)lib_dec(v0);
+		case LIB_HEX:
+			return (int)lib_hex(v0,a0);
+		case LIB_CHR:
+			return (int)lib_chr(v0);
+		case LIB_VAL:
+			return lib_val((char*)v0);
+		case LIB_LETSTR:
+			lib_let_str((char*)v0,a0);
+			return;
+		case LIB_CONNECT_STRING:
+			return (int)lib_connect_string((char*)a0, (char*)v0);
+		case LIB_STRING:
+			lib_string(v0);
+			return v0;
+		case LIB_PRINTSTR:
+			printstr((char*)v0);
+			return v0;
+		case LIB_GRAPHIC:
+			return lib_graphic(v0, (enum functions)(a3 & FUNC_MASK));
+		case LIB_SPRINTF:
+			return (int)lib_sprintf((char*)v0,a0);
+		case LIB_VAR_PUSH:
+			lib_var_push(a0,a1,g_libparams);
+			return v0;
+		case LIB_VAR_POP:
+			lib_var_pop(a0,a1,g_libparams);
+			return v0;
+		case LIB_SCROLL:
+			scroll(g_libparams[1],v0);
+			return v0;
+		case LIB_FILE:
+			return lib_file((enum functions)(a3 & FUNC_MASK),g_libparams[1],g_libparams[2],v0);
+		case LIB_KEYS:
+			return lib_keys(v0);
+		case LIB_INKEY:
+			return (int)lib_inkey(v0);
+		case LIB_CURSOR:
+			setcursor(g_libparams[1],v0,cursorcolor);
+			return v0;
+		case LIB_SOUND:
+			set_sound((unsigned long*)v0,a0);
+			return v0;
+		case LIB_MUSICFUNC:
+			return musicRemaining(a0);
+		case LIB_MUSIC:
+			set_music((char*)v0,a0);
+			return v0;
+		case LIB_PLAYWAVE:
+			play_wave((char*)g_libparams[1],v0);
+			return v0;
+		case LIB_PLAYWAVEFUNC:
+			return waveRemaining(v0);
+		case LIB_SETDRAWCOUNT:
+			drawcount=(v0&0x0000FFFF);
+			return v0;
+		case LIB_GETDIR:
+			return lib_getdir();
+		case LIB_SETDIRFUNC:
+		case LIB_SETDIR:
+			return lib_setdir(a3,(char*)v0);
+		case LIB_DRAWCOUNT:
+			return drawcount;
+		case LIB_SYSTEM:
+			return lib_system(a0, a1 ,v0, a3, g_gcolor, g_prev_x, g_prev_y);
+		case LIB_RESTORE:
+			return lib_read(0,v0);
+		case LIB_RESTORE2:
+			return lib_read(1,v0);
+		case LIB_READ:
+			return lib_read(0,0);
+		case LIB_CREAD:
+			return lib_read(1,0);
+		case LIB_LABEL:
+			return (int)lib_label(v0);
+		case LIB_INPUT:
+			return (int)lib_input();
+		case LIB_USEGRAPHIC:
+			lib_usegraphic(v0);
+			return v0;
+		case LIB_USEPCG:
+			lib_usepcg(v0);
+			return v0;
+		case LIB_PCG:
+			lib_pcg(g_libparams[1],g_libparams[2],v0);
+			return v0;
+		case LIB_BGCOLOR: // BGCOLOR R,G,B
+			set_bgcolor(v0,g_libparams[1],g_libparams[2]); //set_bgcolor(b,r,g);
+			return v0;
+		case LIB_PALETTE: // PALETTE N,R,G,B
+			set_palette(g_libparams[1],v0,g_libparams[2],g_libparams[3]); // set_palette(n,b,r,g);
+			return v0;
+		case LIB_GPALETTE:// GPALETTE N,R,G,B
+			if (g_graphic_area) g_set_palette(g_libparams[1],v0,g_libparams[2],g_libparams[3]); // g_set_palette(n,b,r,g);
+			return v0;
+		case LIB_CLS:
+			clearscreen();
+			return v0;
+		case LIB_GCLS:
+			if (g_graphic_area) g_clearscreen();
+			g_prev_x=g_prev_y=0;
+			return v0;
+		case LIB_WIDTH:
+			videowidth(v0);
+			return v0;
+		case LIB_COLOR:
+			setcursorcolor(v0);
+			return v0;
+		case LIB_GCOLOR:
+			g_gcolor=v0;
+			return v0;
+		case LIB_WAIT:
+			lib_wait(v0);
+			return v0;
+		case LIB_CLEAR:
+			lib_clear();
+			return v0;
+		case LIB_DIM:
+			return (int)lib_dim(a0,a1,(int*)v0);
+#ifdef __DEBUG
+		case LIB_DEBUG:
+			asm volatile("nop");
+			return v0;
+#endif
+		case LIB_DIV0:
+			err_div_zero();
+			return v0;
+		default:
+			err_unknown();
+			return v0;
+	}
+}
\ No newline at end of file

--- /dev/null
+++ b/mips/protozoa/linker.c
@@ -0,0 +1,394 @@
+/*
+   This file is provided under the LGPL license ver 2.1.
+   Written by Katsumi.
+   http://hp.vector.co.jp/authors/VA016157/
+   [e-mail]
+*/
+
+/*
+	This file is shared by Megalopa and Zoea
+*/
+
+#include "compiler.h"
+
+unsigned int g_label;
+
+char* get_label(void){
+	unsigned int i;
+	char b1;
+	int prevpos;
+	next_position();
+	prevpos=g_srcpos;
+	i=0;
+	b1=g_source[g_srcpos];
+	if ('0'<= b1 && b1<='9') {
+		// May be line number
+		do {
+			i*=10;
+			i+=b1-'0';
+			g_srcpos++;
+			b1=g_source[g_srcpos];
+		} while ('0'<= b1 && b1<='9');
+		// Check if end of the statement.
+		if (i==0 || 65535<i) {
+			// Line number 0 or more than 65535 is not available
+			g_srcpos=prevpos;
+			return ERR_SYNTAX;
+		} else if (get_operator()) {
+			// Oparator not found.
+			g_label=i;
+			return 0;
+		} else {
+			// This is not constant line number.
+			g_srcpos=prevpos;
+			g_label=0;
+			return 0;
+		}
+	} else if ('A'<=b1 && b1<='Z') {
+		// May be label
+		do {
+			// First character must be A-Z
+			// From second, A-Z and 0-9 can be used.
+			i*=36;
+			if ('0'<=b1 && b1<='9') {
+				i+=b1-'0';
+			} else if (g_srcpos==prevpos) {
+				// First character must be A-Z.
+				// Subtract 9, resulting 1-26 but not 10-35.
+				// This subtraction is required to maintain
+				// final number being <0x80000000.
+				i+=b1-'A'+1;
+			} else {
+				i+=b1-'A'+10;
+			}
+			g_srcpos++;
+			b1=g_source[g_srcpos];
+		} while ('0'<= b1 && b1<='9' || 'A'<=b1 && b1<='Z');
+		// Length of the label must be between 2 and 6.
+		if (g_srcpos-prevpos<2 || 6<g_srcpos-prevpos) {
+			g_srcpos=prevpos;
+			return ERR_LABEL_LONG;
+		}
+		// Must not be a function
+		next_position();
+		if (g_source[g_srcpos]=='(') {
+			g_srcpos=prevpos;
+			g_label=0;
+			return 0;
+		}
+		g_label=i+65536;
+		return 0;
+	} else {
+		g_label=0;
+		return 0;
+	}
+}
+
+void* search_label(unsigned int label){
+	unsigned int i,code,search1,search2;
+	if (label&0xFFFF0000) {
+		// Label
+		search1=0x3C160000|((label>>16)&0x0000FFFF); //lui s6,yyyy;
+		search2=0x36D60000|(label&0x0000FFFF);       //ori s6,s6,zzzz;
+		for(i=0;i<g_objpos;i++){
+			code=g_object[i];
+			if (code==search1) {
+				if (g_object[i+1]==search2) {
+					// Label number found
+					return &(g_object[i]);
+				}
+			}
+			if (code&0xFFFF0000==0x04110000) {
+				// "bgezal zero," assembly found. Skip following block (strig).
+				i+=code&0x0000FFFF;
+			}
+		}
+		// Line number not found.
+		return 0;
+	} else {
+		// Line number
+		search1=0x34160000|label; //ori         s6,zero,xxxx;
+		for(i=0;i<g_objpos;i++){
+			code=g_object[i];
+			if (code==search1) {
+				// Line number found
+				return &(g_object[i]);
+			}
+			if (code&0xFFFF0000==0x04110000) {
+				// "bgezal zero," assembly found. Skip following block (strig).
+				i+=code&0x0000FFFF;
+			}
+		}
+		// Line number not found.
+		return 0;
+	}
+}
+
+void* search_breakout(unsigned int start, int* prevcode){
+	unsigned int pos,code1,depth;
+	// Start search from start point where BREAK statement is used.
+	depth=0;
+	for(pos=start;pos<g_objpos;pos++){
+		code1=g_object[pos];
+		switch(code1>>16){
+			case 0x0411:
+				// "bgezal zero," assembly found. Skip following block (strig).
+				pos+=code1&0x0000FFFF;
+				break;
+			case 0x0820: // FOR
+			case 0x0821: // WHILE
+			case 0x0822: // DO
+				depth++;
+				break;
+			case 0x0830: // NEXT
+			case 0x0831: // WEND
+			case 0x0832: // LOOP
+				if (0<depth) {
+					depth--;
+					break;
+				}
+				// Destination found.
+				// Previous code will be also set if required for CONTINUE statement.
+				if (prevcode) prevcode[0]=g_object[pos-1];
+				return (void*)&g_object[pos];
+			default:
+				break;
+		}
+	}
+	return 0;
+}
+
+void* search_ifout(unsigned int start){
+	unsigned int pos,code1,depth;
+	// Start search from start point where BREAK statement is used.
+	depth=0;
+	for(pos=start;pos<g_objpos;pos++){
+		code1=g_object[pos];
+		switch(code1>>16){
+			case 0x0411:
+				// "bgezal zero," assembly found. Skip following block (strig).
+				pos+=code1&0x0000FFFF;
+				break;
+			case 0x3000: // Block marker
+				if (code1==0x30008000) {
+					// end block
+					if (0<depth) {
+						depth--;
+						break;
+					}
+					// Destination found.
+					return (void*)&g_object[pos];
+				} else if (code1==0x30000000) {
+					// begin block
+					depth++;
+					break;
+				} else {
+					break;
+				}
+			default:
+				break;
+		}
+	}
+	return 0;
+}
+
+/*
+	Following codes are dedicated to specific use:
+	0x0411xxxx: String/data block
+		Use 0x0413xxxx (bzegall zero,xxxx) for other cases to get PC to $ra
+	0x0810xxxx, 0x0811xxxx: GOTO statement
+	0x0812xxxx, 0x0813xxxx: GOSUB statement
+	0x0814xxxx, 0x0815xxxx: SOUND etc, for setting v0 as pointer to DATA array.
+	0x0816xxxx: BREAK statemant and relatives
+		0x08160000: BREAK
+		0x08160008: CONTINUE
+		0x08160100: Jump to next ELSE, ELSEIF or ENDIF
+	0x082xyyyy: Begin block (FOR/DO/WHILE)
+	0x083xyyyy: End block (NEXT/LOOP/WEND)
+	0x00000020, 0x00000021,
+	0x00000022, 0x00000023: Marker for begining the DATA region.
+	                        MLB 2 bits show skip byte length in DATA.
+	0x30000000: Begin block (IF-THEN-ELSEIF-ELSE-ENDIF)
+	0x30008000: End block (IF-THEN-ELSEIF-ELSE-ENDIF)
+	0x3000Fxxx: General purpose NOP with value 0x0000-0x0FFF.
+
+	IF-THEN-ELSEIF-ELSE-ENDIF is written as follows:
+		IF-THEN: 0x30000000 0x10400000 0x30000000
+		ELSEIF-THEN: 0x08160100 0x30008000 (conditional expression) 0x10400000 0x30000000
+		ELSE: 0x08160100 0x30008000 0x30000000
+		ENDIF: 0x30008000 0x30008000 
+	, where "0x10400000 0x30000000" and "0x08160100 0x30008000" will be replaced by
+	codes jumping to next 0x30008000. The 0x30000000 - 0x30008000 blocks will be skipped.
+*/
+
+char* link(void){
+	int pos;
+	unsigned int code1,code2,label;
+	g_fileline=0;
+	for(pos=0;pos<g_objpos;pos++){
+		code1=g_object[pos];
+		switch(code1>>16){
+			case 0x0411:
+				// "bgezal zero," assembly found. Skip following block (strig).
+				pos+=code1&0x0000FFFF;
+				break;
+			case 0x3416:
+				// "ori s6,zero,xxxx" found this is the first word in a line.
+				g_fileline++;
+				g_line=code1&0x0000FFFF;
+				break;
+			case 0x0810:
+				// GOTO
+				code2=g_object[pos+1];
+				if ((code2&0xFFFF0000)!=0x08110000) continue;
+				code1&=0x0000FFFF;
+				code2&=0x0000FFFF;
+				label=(code1<<16)|code2;
+				code1=(int)search_label(label);
+				g_label=label;
+				if (!code1) return ERR_LABEL_NF;
+				code1&=0x0FFFFFFF;
+				code1>>=2;
+				code1|=0x08000000; // j xxxx
+				g_object[pos++]=code1;
+				g_object[pos]=0x00000000; // nop
+				break;
+			case 0x0812:
+				// GOSUB
+				code2=g_object[pos+1];
+				if ((code2&0xFFFF0000)!=0x08130000) continue;
+				code1&=0x0000FFFF;
+				code2&=0x0000FFFF;
+				label=(code1<<16)|code2;
+				code2=(int)search_label(label);
+				g_label=label;
+				if (!code2) return ERR_LABEL_NF;
+				code2&=0x0FFFFFFF;
+				code2>>=2;
+				code2|=0x08000000; // j xxxx
+				g_object[pos++]=0x00000000; // nop
+				g_object[pos]=code2;
+				break;
+			case 0x0814:
+				// SOUND etc, for setting v0 as pointer to label/line
+				code2=g_object[pos+1];
+				if ((code2&0xFFFF0000)!=0x08150000) continue;
+				code1&=0x0000FFFF;
+				code2&=0x0000FFFF;
+				label=(code1<<16)|code2;
+				code1=(int)search_label(label);
+				g_label=label;
+				if (!code1) return ERR_LABEL_NF;
+				g_object[pos++]=0x3C020000|((code1>>16)&0x0000FFFF); // lui   v0,xxxx
+				g_object[pos]  =0x34420000|(code1&0x0000FFFF);       // ori v0,v0,xxxx
+				break;
+			case 0x0816:
+				switch(code1&0xFFFF) {
+					case 0x0000:
+						// BREAK statement
+						// Find next the NEXT or WHILE statement and insert jump code after this.
+						g_label=g_line;
+						code1=(int)search_breakout(pos,0);
+						if (!code1) return ERR_INVALID_BREAK;
+						code1&=0x0FFFFFFF;
+						code1>>=2;
+						code1|=0x08000000; // j xxxx
+						g_object[pos]=code1;
+						break;
+					case 0x0008:
+						// CONTINUE statement
+						// Find next the NEXT or WHILE statement and insert jump code after this.
+						g_label=g_line;
+						code1=(int)search_breakout(pos,&g_temp);
+						if (!code1) return ERR_INVALID_BREAK;
+						if (0x3000F000 == (g_temp&0xFFFFF000)) {
+							// WEND or LOOP statement found
+							code1-=(g_temp&0x0FFF)<<2;
+						} else {
+							// NEXT statement found
+							code1-=3<<2;
+						}
+						code1&=0x0FFFFFFF;
+						code1>>=2;
+						code1|=0x08000000; // j xxxx
+						g_object[pos]=code1;
+						break;
+					case 0x0100:
+						// Jump to next ENDIF
+						g_label=g_line;
+						// "pos+2" is for skipping next code (must be 0x30008000)
+						code1=(int)search_ifout(pos+2);
+						if (!code1) return ERR_INVALID_ELSEIF;
+						code1&=0x0FFFFFFF;
+						code1>>=2;
+						code1|=0x08000000; // j xxxx
+						g_object[pos]=code1;
+						break;
+					default:
+						break;
+				}
+				break;
+			case 0x3000:
+				// Block marker
+				switch(code1&0xFFFF) {
+					case 0x0000:
+						// Begin if block
+						if (g_object[pos-1]==0x10400000) { // beq v0,zero,xxxx
+							// IF-THEN or ELSEIF-THEN
+							// Jump to next ELSE, ELSEIF or ENDIF
+							g_label=g_line;
+							// "pos+1" is for skipping current code (0x30000000)
+							code1=(int)search_ifout(pos+1);
+							if (!code1) return ERR_INVALID_ELSEIF;
+							code1-=(int)(&g_object[pos]);
+							code1>>=2;
+							code1&=0x0000FFFF;
+							code1|=0x10400000; // beq v0,zero,xxxx
+							g_object[pos-1]=code1;
+							break;
+						}
+						break;
+					default:
+						break;
+				}
+				break;
+			case 0x0820: // FOR
+			case 0x0830: // NEXT
+			case 0x0821: // WHILE
+			case 0x0831: // WEND
+			case 0x0822: // DO
+			case 0x0832: // WHILE
+				// These are used for detecing the depth of structures.
+				// Change them to stack increase/decrease commands.
+				g_object[pos]=0x27BD0000|(code1&0x0000FFFF); //// addiu       sp,sp,xx
+				break;
+			case 0x2407:                                // addiu       a3,zero,xxxx
+				if (g_object[pos-1]!=0x02E0F809) break; // jalr        ra,s7
+				// call_lib_code(x)
+				switch(code1&0x0000FFFF){
+					case LIB_RESTORE:
+						// Convert label data to pointer if not dynamic
+						code1=g_object[pos-3];
+						code2=g_object[pos-2];
+						if ((code1>>16)!=0x3C02) break; // lui         v0,xxxx
+						if ((code2>>16)!=0x3442) break; // ori         v0,v0,xxxx
+						label=(code1<<16)|(code2&0x0000FFFF);
+						code1=(int)search_label(label);
+						g_label=label;
+						if (!code1) return ERR_LABEL_NF;
+						code2=code1&0x0000FFFF;
+						code1=code1>>16;
+						g_object[pos-3]=0x3C020000|code1;      // lui         v0,xxxx
+						g_object[pos-2]=0x34420000|code2;      // ori         v0,v0,xxxx
+						g_object[pos]=0x24070000|LIB_RESTORE2; // addiu       a3,zero,xxxx
+						break;
+					default:
+						break;
+				}
+				break;
+			default:
+				break;
+		}
+	}
+	return 0;
+}
\ No newline at end of file

--- /dev/null
+++ b/mips/protozoa/main.c
@@ -0,0 +1,272 @@
+/*
+   This file is provided under the LGPL license ver 2.1.
+   Written by K.Tanaka & Katsumi
+   http://www.ze.em-net.ne.jp/~kenken/index.html
+   http://hp.vector.co.jp/authors/VA016157/
+*/
+
+// main.c
+// MachiKania BASIC System Ver Zoea
+// KM-BASIC 統合開発実行環境 for PIC32MX170F256B / PIC32MX270F256B by K.Tanaka
+// LCD出力バージョン（テスト） by K.Tanaka
+
+// 利用システム
+// libsdfsio.a ： SDカードアクセス用ライブラリ
+
+// System clock :48MHz  FRC with PLL (8/2*24/2)
+// Peripheral clock :48MHz
+
+/*
+	PIC32MX ペリフェラル使用状況
+	
+	割り込み
+		NTSC,   Timer2, vector  8, priority 5
+		MUSIC,  CS0,    vector  1, priority 2
+		TIMER,  Timer1, vector  4, priority 3
+		INT,    CS1,    vector  2, priority 1
+	
+	タイマー
+		Timer1 BASIC用タイマー
+		Timer2 NTSC
+		Timer3 MUSIC/PWM
+		Timer4 MUSIC
+		Timer5 未使用
+	
+	DMA
+		DMA0 未使用
+		DMA1 未使用
+		DMA2 MUSIC
+		DMA3 未使用
+	
+	Output compair
+		OC1 未使用
+		OC2 未使用
+		OC3 未使用
+		OC4 MUSIC/PWM
+		OC5 未使用
+		
+	SPI
+		SPI1 未使用
+		SPI2 マルチメディアカード
+	
+	I2C
+		I2C1 未使用
+		I2C2 未使用
+	
+	ポート使用
+		A0  MMC
+		A1  MMC
+		A2  Audio
+		A3  LCD/button切換え
+		A4  MMC
+		B0  LCD
+		B1  LCD
+		B2  LCD/button
+		B3  LCD/button
+		B4  LCD/button
+		B5  LCD/button
+		B6  未使用
+		B7  LCD/button
+		B8  LCD/button
+		B9  PS2/button
+		B10 LCD
+		B11 LCD
+		B12 未使用
+		B13 LCD
+		B14 LCD
+		B15 MMC
+*/
+
+#include <xc.h>
+#include "api.h"
+#include "compiler.h"
+#include "editor.h"
+#include "main.h"
+
+#define mBMXSetRAMKernProgOffset(offset)	(BMXDKPBA = (offset))
+#define mBMXSetRAMUserDataOffset(offset)	(BMXDUDBA = (offset))
+#define mBMXSetRAMUserProgOffset(offset)	(BMXDUPBA = (offset))
+
+// INIファイル指定キーワード（8文字以内）
+const char InitKeywords[][9]={
+	"106KEY","101KEY","NUMLOCK","CAPSLOCK","SCRLLOCK"
+};
+
+void freadline(char *s,FSFILE *fp){
+// ファイルから1行読み込み、配列sに返す
+// 最大8文字まで。9文字以上の場合無効
+// #または0x20以下のコードを見つけた場合、以降は無視
+// s:9バイト以上の配列
+// fp:ファイルポインタ
+	int n;
+	char c,*p;
+	n=0;
+	p=s;
+	*p=0;
+	while(n<=8){
+		if(FSfread(p,1,1,fp)==0 || *p=='\n'){
+			*p=0;
+			return;
+		}
+		if(*p=='#'){
+			*p=0;
+			break;
+		}
+		if(*p<=' '){
+			if(n>0){
+				*p=0;
+				break;
+			}
+			continue;
+		}
+		p++;
+		n++;
+	}
+	if(n>8) *s=0; //9文字以上の文字列の場合は無効
+	//以降の文字は無視
+	while(FSfread(&c,1,1,fp) && c!='\n') ;
+}
+int searchinittext(char *s){
+// InitKeywords配列の中から文字列sを探し、位置した場合何番目かを返す
+// 見つからなかった場合-1を返す
+	int i;
+	char *p1;
+	const char *p2;
+	for(i=0;i<sizeof(InitKeywords)/sizeof(InitKeywords[0]);i++){
+		p1=s;
+		p2=InitKeywords[i];
+		while(*p1==*p2){
+			if(*p1==0) return i;
+			p1++;
+			p2++;
+		}
+	}
+	return -1;
+}
+void readinifile(void){
+	FSFILE *fp;
+	char inittext[9];
+
+	fp=FSfopen(INIFILE,"r");
+	if(fp==NULL) return;
+	printstr("Initialization File Found\n");
+//	lockkey=0; //INIファイルが存在する場合、Lock関連キーはINIファイルに従う
+	while(1){
+		if(FSfeof(fp)) break;
+		freadline(inittext,fp);
+		switch(searchinittext(inittext)){
+			case 0:
+//				keytype=0;//日本語キーボード
+				break;
+			case 1:
+//				keytype=1;//英語キーボード
+				break;
+			case 2:
+//				lockkey|=2;//Num Lock
+				break;
+			case 3:
+//				lockkey|=4;//CAPS Lock
+				break;
+			case 4:
+//				lockkey|=1;//Scroll Lock
+				break;
+		}
+	}
+	FSfclose(fp);
+}
+
+void printhex8(unsigned char d){
+	printchar("0123456789ABCDEF"[d>>4]);
+	printchar("0123456789ABCDEF"[d&0x0f]);	
+}
+
+void printhex16(unsigned short d){
+	printhex8(d>>8);
+	printhex8(d&0x00ff);
+}
+
+void printhex32(unsigned int d){
+	printhex16(d>>16);
+	printhex16(d&0x0000ffff);
+}
+
+int main(void){
+	char *appname,*s;
+
+	if(DEVCFG1 & 0x8000){
+		// Set Clock switching enabled and reset
+		NVMWriteWord(&DEVCFG1,DEVCFG1 & 0xffff7fff);
+		SoftReset();
+	}
+
+	/* ポートの初期設定 */
+	TRISA = 0x0000; // PORTA全て出力
+	ANSELA = 0x0000; // 全てデジタル
+	TRISB = 0x0000; // PORTB全て出力（ボタン読み込み時のみ入力に切り替える）
+	ANSELB = 0x0000; // 全てデジタル
+	KEY_DS;
+	LCD_CS_LO;
+
+	// 周辺機能ピン割り当て
+	SDI2R=2; //RPA4:SDI2
+	RPA1R=4; //RPA1:SDO2
+
+	// Make RAM executable. See also "char RAM[RAMSIZE]" in globalvars.c
+	mBMXSetRAMKernProgOffset(PIC32MX_RAMSIZE-RAMSIZE);
+	mBMXSetRAMUserDataOffset(PIC32MX_RAMSIZE);
+	mBMXSetRAMUserProgOffset(PIC32MX_RAMSIZE);
+
+	INTEnableSystemMultiVectoredInt();
+	IPC2bits.T2IP = 4;			// 割り込みレベル4
+	IFS0bits.T2IF = 0;
+	IEC0bits.T2IE = 1;			// タイマ2割り込み有効化
+	PR2=3125;				// 60分の1秒
+	T2CON = 0x8070;				// プリスケーラ1:256、タイマ2開始
+
+	init_textgraph();// パレット設定、LCDクリア
+	setcursor(0,0,COLOR_NORMALTEXT);
+	keystatus=0;
+
+	// Show blue screen if exception before soft reset.
+	blue_screen();
+
+	printstr("MachiKania BASIC System\n");
+	printstr(" Ver "SYSVER1" "SYSVER2" by KENKEN\n");
+	printstr("BASIC Compiler "BASVER"\n");
+	printstr(" by Katsumi\n\n");
+	//SDカードファイルシステム初期化
+	setcursorcolor(COLOR_NORMALTEXT);
+	printstr("Init File System...");
+	// Initialize the File System
+	if(FSInit()==FALSE){ //ファイルシステム初期化
+		//エラーの場合停止
+		setcursorcolor(COLOR_ERRORTEXT);
+		printstr("\nFile System Error\n");
+		printstr("Insert Correct Card\n");
+		printstr("And Reset\n");
+		while(1) asm("wait");
+	}
+	printstr("OK\n");
+	readinifile(); //INIファイル読み込み
+
+	wait60thsec(60); //1秒待ち
+
+/*
+	// 実行中HEXファイル名がHEXFILEと一致した場合はエディタ起動
+	appname=(char*)FILENAME_FLASH_ADDRESS;
+	s=HEXFILE;
+	while(*s++==*appname++) if(*s==0) texteditor(); //テキストエディター呼び出し
+*/
+
+	// 実行中HEXファイル名の「.HEX」を「.BAS」に置き換えてBASファイルを実行
+	appname=(char*)FILENAME_FLASH_ADDRESS;
+	s=tempfile;
+	while(*appname!='.') *s++=*appname++;
+	appname=".BAS";
+	while(*appname!=0) *s++=*appname++;
+	*s=0;
+	// buttonmode(); //ボタン有効化
+	g_disable_break=1; // Breakキー無効化
+	runbasic(tempfile,0);
+	while(1) asm(WAIT);
+}

--- /dev/null
+++ b/mips/protozoa/main.h
@@ -0,0 +1,21 @@
+/*
+   This file is provided under the LGPL license ver 2.1.
+   Written by K.Tanaka & Katsumi
+   http://www.ze.em-net.ne.jp/~kenken/index.html
+   http://hp.vector.co.jp/authors/VA016157/
+*/
+
+#define SYSVER1 "Protozoa"
+#define SYSVER2 "1.3"
+#define BASVER "KM-1208"
+
+#define INIFILE "MACHILCD.INI" // 初期設定ファイル
+#define HEXFILE "MACHILCD.HEX" // 実行中HEXファイル名がこれと一致した場合はエディタ起動
+
+#define FILENAME_FLASH_ADDRESS 0x9D005800
+#define PIC32MX_RAMSIZE 0x10000
+#define PIC32MX_FLASHSIZE 0x40000
+
+void printhex8(unsigned char d);
+void printhex16(unsigned short d);
+void printhex32(unsigned int d);

--- /dev/null
+++ b/mips/protozoa/memory.c
@@ -0,0 +1,327 @@
+/*
+   This file is provided under the LGPL license ver 2.1.
+   Written by Katsumi.
+   http://hp.vector.co.jp/authors/VA016157/
+   [e-mail]
+*/
+
+/*
+	This file is shared by Megalopa and Zoea
+*/
+
+#include "compiler.h"
+
+/*
+	ALLOC_VAR_NUM:    # of variables used for allocation of memory (string/dimension).
+	                  0 is for A, 1 is for B, ... , and 25 is for Z.
+	                  This number also includes temporary area used for string construction etc.
+	                  Temporary area is cleared every line of BASIC code in alloc_memory().
+	ALLOC_BLOCK_NUM:  # of blocks that can be used for memory allocation.
+	                  This # includes the ones for ALLOC_VAR_NUM, ALLOC_PCG_BLOCK etc, ALLOC_LNV_BLOCK,
+	                  ALLOC_PERM_BLOCK.
+	                  After ALLOC_VAR_NUM area, dedicated memory area and permanent area follows.
+	ALLOC_PERM_BLOCK: Start # of permanent blocks.
+                      The blocks after this number is permanently stored.
+                      Therefore, it must be released when it's not used any more.
+*/
+
+static int g_temp_var_num_candidate=ALLOC_PERM_BLOCK;
+
+#define DELETE_LIST_SIZE 10
+static int g_deleted_num;
+static int g_deleted_pointer[DELETE_LIST_SIZE];
+static int g_deleted_size[DELETE_LIST_SIZE];
+
+void register_deleted_block(int pointer, int size){
+	// There is maximum
+	if (DELETE_LIST_SIZE<=g_deleted_num) return;
+	if (g_deleted_num) {
+		// Avoid duplication
+		if (g_deleted_pointer[g_deleted_num-1]==pointer) return;
+	}
+	g_deleted_pointer[g_deleted_num]=pointer;
+	g_deleted_size[g_deleted_num]=size;
+	g_deleted_num++;
+} 
+
+void set_free_area(void* begin, void* end){
+	// Initialize heap area
+	int i;
+	for(i=0;i<ALLOC_BLOCK_NUM;i++){
+		g_var_size[i]=0;
+	}
+	g_heap_mem=(int*)begin;
+	g_max_mem=(int)((end-begin)/4);
+	g_deleted_num=0;
+}
+
+void* calloc_memory(int size, int var_num){
+	int i;
+	void* ret;
+	// Allocate memory
+	ret=alloc_memory(size,var_num);
+	// Fill zero in allocated memory
+	for(i=0;i<size;i++){
+		((int*)ret)[i]=0;
+	}
+	// return pointer to allocated memory
+	return ret;
+}
+void* alloc_memory(int size, int var_num){
+	// Remove temporary blocks once a line.
+	asm volatile("nop");
+	asm volatile("bltz $s6,_alloc_memory_main"); // Skip if $s6<0
+	// Following code will be activated after setting $s6 register
+	// every line and after label statement.
+	asm volatile("lui $v0,0x8000");
+	asm volatile("or $s6,$v0,$s6");              // $s6=0x80000000|$s6;
+	// Remove all temporary blocks
+	// Note that g_var_size is short integer.
+	// Note that ALLOC_VAR_NUM is used here (but not ALLOC_BLOC_NUM)
+	//	for(i=26;i<ALLOC_VAR_NUM;i++)g_var_size[i]=0;
+	asm volatile("addiu $v0,$zero,%0"::"n"((ALLOC_VAR_NUM-26)/2)); // $v0=(ALLOC_VAR_NUM-26)/2
+	asm volatile("la $v1,%0"::"i"(&g_var_size[0]));                // $v1=g_var_size
+	asm volatile("loop:");
+	asm volatile("sw $zero,(26*2)($v1)");                          // $v1[26]=0, $v1[27]=0
+	asm volatile("addiu $v0,$v0,-1");                              // $v0--
+	asm volatile("addiu $v1,$v1,4");                               // $v1+=2
+	asm volatile("bne $v0,$zero,loop");                            // loop if 0<$v0
+	asm volatile("b _alloc_memory_main");
+}
+void* _alloc_memory_main(int size, int var_num){
+	int i,j,candidate;
+	// Assign temp var number
+	if (var_num<0) {
+		// Use ALLOC_VAR_NUM here but not ALLOC_BLOCK_NUM
+		for(i=26;i<ALLOC_VAR_NUM;i++){
+			if (g_var_size[i]==0) {
+				var_num=i;
+				break;
+			}
+		}
+		if (var_num<0) {
+			err_str_complex();
+			return 0;
+		}
+	}
+	// Clear var to be assigned.
+	g_var_size[var_num]=0;
+	g_var_pointer[var_num]=0;
+	while(1){
+		// Try the block previously deleted, not for temporary block.
+		// This is for fast allocation of memory for class object.
+		if (var_num<26 || ALLOC_VAR_NUM<=var_num) {
+			candidate=0;
+			while(g_deleted_num){
+				// Check if the last deleted block fits
+				// If not, these cannot be used anymore
+				g_deleted_num--;
+				if (size<=g_deleted_size[g_deleted_num]) {
+					candidate=g_deleted_pointer[g_deleted_num];
+					break;
+				}
+			}
+			if (candidate || g_deleted_num) {
+				// Candidate found
+				break;
+			}
+		}
+		// Try the block after last block
+		candidate=0;
+		for(i=0;i<ALLOC_BLOCK_NUM;i++){
+			if (g_var_size[i]==0) continue;
+			if (candidate<=g_var_pointer[i]) {
+				candidate=g_var_pointer[i]+g_var_size[i];
+			}
+		}
+		if (candidate+size<=g_max_mem) {
+			// Check after deleted block
+			j=candidate;
+			for(i=0;i<g_deleted_num;i++){
+				if (j<g_deleted_pointer[i]+g_deleted_size[i]) {
+					j=g_deleted_pointer[i]+g_deleted_size[i];
+				}
+			}
+			if (j+size<=g_max_mem) {
+				// Candidate block found after previously deleted blokcs
+				candidate=j;
+				break;
+			} else {
+				// Candidate is before previously deleted blocks,
+				// and there is no candidate block after previously deleted blocks.
+				// Therefore, use the current candidate, which may invade previously
+				// deleted blocks. Therefore, erase the previously deleted blocks list.
+				g_deleted_num=0;
+				break;
+			}
+		}
+		// Peviously deleted blocks cannot be used any more
+		g_deleted_num=0;
+		// Check between blocks
+		// Note that there is at least one block with zero pointer and zero size (see above).
+		for(i=0;i<ALLOC_BLOCK_NUM;i++){
+			// Candidate is after this block.
+			candidate=g_var_pointer[i]+g_var_size[i];
+			// Check if there is an overlap.
+			for(j=0;j<ALLOC_BLOCK_NUM;j++){
+				if (g_var_size[j]==0) continue;
+				if (candidate+size<=g_var_pointer[j]) continue;
+				if (g_var_pointer[j]+g_var_size[j]<=candidate) continue;
+				// This block overlaps with the candidate
+				candidate=-1;
+				break;
+			}
+			if (0<=candidate && candidate+size<=g_max_mem) {
+				// Available block found
+				break;
+			} else {
+				candidate=-1;
+			}
+		}
+		if (0<=candidate) break;
+		// New memory block cannot be allocated.
+		err_no_mem();
+		return 0;
+	}
+	// Available block found.
+	g_var_pointer[var_num]=candidate;
+	g_var_size[var_num]=size;
+	g_var_mem[var_num]=(int)(&(g_heap_mem[candidate]));
+	return (void*)g_var_mem[var_num];
+}
+
+void free_temp_str(char* str){
+	int i,pointer;
+	if (!str) return;
+	pointer=(int)str-(int)g_heap_mem;
+	pointer>>=2;
+	for(i=26;i<ALLOC_VAR_NUM;i++){
+		if (g_var_pointer[i]==pointer) {
+			if (g_var_size[i] && g_var_mem[i]==(int)str) {
+				register_deleted_block(pointer,g_var_size[i]);
+				g_var_size[i]=0;
+			}
+		}
+	}
+}
+
+void free_non_temp_str(char* str){
+	int i,pointer;
+	if (!str) return;
+	pointer=(int)str-(int)g_heap_mem;
+	pointer>>=2;
+	for(i=0;i<26;i++){
+		if (g_var_pointer[i]==pointer) {
+			if (g_var_size[i] && g_var_mem[i]==(int)str) {
+				register_deleted_block(pointer,g_var_size[i]);
+				g_var_size[i]=0;
+				g_var_mem[i]=0;
+			}
+		}
+	}
+	for(i=ALLOC_VAR_NUM;i<ALLOC_BLOCK_NUM;i++){
+		if (g_var_pointer[i]==pointer) {
+			if (g_var_size[i] && g_var_mem[i]==(int)str) {
+				register_deleted_block(pointer,g_var_size[i]);
+				g_var_size[i]=0;
+				g_var_mem[i]=0;
+				if (ALLOC_PERM_BLOCK<=i) g_temp_var_num_candidate=i;
+			}
+		}
+	}
+}
+
+void free_perm_str(char* str){
+	int i,pointer;
+	if (!str) return;
+	pointer=(int)str-(int)g_heap_mem;
+	pointer>>=2;
+	// Search permanent block and delete a block if found.
+	for(i=ALLOC_PERM_BLOCK;i<ALLOC_BLOCK_NUM;i++){
+		if (g_var_pointer[i]==pointer) {
+			if (g_var_size[i] && g_var_mem[i]==(int)str) {
+				register_deleted_block(pointer,g_var_size[i]);
+				g_var_size[i]=0;
+				g_temp_var_num_candidate=i;
+				break;
+			}
+		}
+	}
+}
+
+void move_to_perm_block(int var_num){
+	int i;
+	// Find available permanent block
+	i=get_permanent_var_num();
+	// Available block found.
+	// Copy value from variable.
+	g_var_size[i]=g_var_size[var_num];
+	g_var_pointer[i]=g_var_pointer[var_num];
+	g_var_mem[i]=g_var_mem[var_num];
+	// Clear variable
+	g_var_size[var_num]=0;
+	g_var_mem[var_num]=0;
+}
+
+int move_from_perm_block_if_exists(int var_num){
+	int i,pointer;
+	pointer=(int)g_var_mem[var_num]-(int)g_heap_mem;
+	pointer>>=2;
+	// Find stored block
+	for (i=ALLOC_PERM_BLOCK;i<ALLOC_BLOCK_NUM;i++){
+		if (0<g_var_size[i] && g_var_pointer[i]==pointer) break;
+	}
+	if (ALLOC_BLOCK_NUM<=i) return 0; // Not found
+	// Stored block found.
+	// Replace pointer
+	g_var_size[var_num]=g_var_size[i];
+	g_var_pointer[var_num]=g_var_pointer[i];
+	// Clear block
+	g_var_size[i]=0;
+	g_temp_var_num_candidate=i;
+	return 1;
+}
+
+void move_from_perm_block(int var_num){
+	if (move_from_perm_block_if_exists(var_num)) return; // Found
+	err_unknown(); // Not found
+}
+
+int get_permanent_var_num(){
+	int i;
+	// Try candidate first
+	if (!g_var_size[g_temp_var_num_candidate]) {
+		if (ALLOC_PERM_BLOCK<g_temp_var_num_candidate && 
+				g_temp_var_num_candidate<ALLOC_BLOCK_NUM) {
+			return g_temp_var_num_candidate++;
+		}
+	}
+	// Candidate is not available. Seek all.
+	for (i=ALLOC_PERM_BLOCK;i<ALLOC_BLOCK_NUM;i++) {
+		if (g_var_size[i]==0) {
+			g_temp_var_num_candidate=i+1;
+			return i;
+		}
+	}
+	err_no_block();
+	return 0;
+}
+
+int get_varnum_from_address(void* address){
+	int i;
+	for (i=0;i<ALLOC_BLOCK_NUM;i++){
+		if (g_var_mem[i]==(int)address) return i;
+	}
+	// not found
+	return -1;
+}
+
+void* lib_calloc_memory(int size){
+	// Allocate memory and return address
+	return calloc_memory(size,get_permanent_var_num());
+}
+
+void lib_delete(int* object){
+	// Remove region that fit to object
+	free_non_temp_str((char*)object);
+}

--- /dev/null
+++ b/mips/protozoa/music.c
@@ -0,0 +1,644 @@
+/*
+   This file is provided under the LGPL license ver 2.1.
+   Written by Katsumi.
+   http://hp.vector.co.jp/authors/VA016157/
+   [e-mail]
+*/
+
+#include <xc.h>
+#include "compiler.h"
+#include "api.h"
+
+/*
+	Timer3: 1/32 prescaler, toggle mode :750000 Hz
+	PR3=1704 <-> 440 Hz
+	Shift tone for 2048 <--> ~440 Hz.
+		x 1705 / 2048 = 213 / 256 + 1 / 2048
+
+*/
+
+/*
+	c:  1434
+	B:  1519
+	A#: 1609
+	A:  1705
+	G#: 1806
+	G:  1914
+	F#: 2028
+	F:  2148
+	E:  2276
+	D#: 2411
+	D:  2555
+	C#: 2707
+	C:  2867
+	Cb:	3038
+*/
+
+const static int g_keys[]={
+	1609,1434,2707,2411,2148,2028,1806,//  0 7# C# A#m
+	1609,1519,2707,2411,2148,2028,1806,//  7 6# F# D#m
+	1609,1519,2707,2411,2276,2028,1806,// 14 5# B  G#m
+	1705,1519,2707,2411,2276,2028,1806,// 21 4# E  C#m
+	1705,1519,2707,2555,2276,2028,1806,// 28 3# A  F#m
+	1705,1519,2707,2555,2276,2028,1914,// 35 2# D  Bm
+	1705,1519,2867,2555,2276,2028,1914,// 42 1# G  Em
+	1705,1519,2867,2555,2276,2148,1914,// 49 0  C  Am
+	1705,1609,2867,2555,2276,2148,1914,// 56 1b F  Dm
+	1705,1609,2867,2555,2411,2148,1914,// 63 2b Bb Gm
+	1806,1609,2867,2555,2411,2148,1914,// 70 3b Eb Cm
+	1806,1609,2867,2707,2411,2148,1914,// 77 4b Ab Fm
+	1806,1609,2867,2707,2411,2148,2028,// 84 5b Db Bbm
+	1806,1609,3038,2707,2411,2148,2028,// 91 6b Gb Ebm
+	1806,1609,3038,2707,2411,2276,2028 // 98 7b Cb Abm
+};
+
+/*
+	2^(1/12)    ~= 69433/(2^16)
+	1/(2^(1/12) ~= 1933/(2^11)
+*/
+
+#define toneFlat(x) ((((unsigned long)(x))*69433)>>16)
+#define toneSharp(x) ((((unsigned long)(x))*1933)>>11)
+
+/* local global vars */
+static int* g_tones;
+static int g_qvalue;
+static int g_lvalue;
+static int g_mpoint;
+static char* g_mstr;
+static int g_mspos;
+static unsigned short g_music[32];
+static unsigned short g_sound[32];
+static unsigned short g_musiclen[32];
+static unsigned char g_soundlen[32];
+static int g_musicstart;
+static int g_musicend;
+static int g_musicwait;
+static int g_soundstart;
+static int g_soundend;
+static int g_soundwait;
+static int g_soundrepeat;
+
+static char g_sound_mode=0;
+static FSFILE* g_fhandle=0;
+static char* g_wavtable=0;
+
+#define SOUND_MODE_MUSIC 1
+#define SOUND_MODE_WAVE 2
+
+#define start_dma() T4CONSET=0x8000; DCH2CONSET=0x00000080; g_sound_mode=SOUND_MODE_WAVE
+#define stop_dma()  T4CONCLR=0x8000; DCH2CONCLR=0x00000080; g_sound_mode=SOUND_MODE_MUSIC
+
+int waveRemaining(int mode){
+	if (!g_fhandle) return 0;
+	switch(mode){
+		case 1: // current position (header excluded)
+			return g_fhandle->seek-0x2c;
+			break;
+		case 2: // file size (header excluded)
+			return g_fhandle->size-0x2c;
+			break;
+		case 0: // remaining
+		default:
+			return g_fhandle->size-g_fhandle->seek;
+			break;
+	}
+}
+int musicRemaining(int flagsLR){
+	// flagsLR is ignored
+	return (g_musicend-g_musicstart)&31;
+}
+
+void musicint(){
+	unsigned int i;
+	static unsigned short wavtable_pos;
+	// This function is called every 1/60 sec.
+	switch(g_sound_mode){
+		case SOUND_MODE_MUSIC:
+			if (g_soundstart!=g_soundend){
+				// Start timer & OC4
+				i=g_sound[g_soundstart];
+				if (i<0xffff) {
+					T3CONSET=0x8000;
+					PR3=i;
+					if (i<TMR3) TMR3=0;
+				} else {
+					T3CONCLR=0x8000;
+				}
+				if ((--g_soundwait)<=0) {
+					g_soundstart++;
+					if (g_soundstart==g_soundend || 31<g_soundstart) {
+						g_soundstart=0;
+						g_soundrepeat--;
+						if (0<g_soundrepeat) {
+							g_soundwait=g_soundlen[g_soundstart];
+						} else {
+							g_soundend=g_soundrepeat=g_soundwait=0;
+						}
+					} else {
+						g_soundwait=g_soundlen[g_soundstart];
+					}
+				}
+				// Shift music data even though without output.
+				if (g_musicstart!=g_musicend) {
+					if ((--g_musicwait)<=0) {
+						g_musicstart++;
+						g_musicstart&=31;
+						g_musicwait=g_musiclen[g_musicstart];
+					}
+				}
+			} else if (g_musicstart!=g_musicend) {
+				// Start timer & OC4
+				i=g_music[g_musicstart];
+				if (i<0xffff) {
+					T3CONSET=0x8000;
+					PR3=i;
+					if (i<TMR3) TMR3=0;
+				} else {
+					T3CONCLR=0x8000;
+				}
+				if ((--g_musicwait)<=0) {
+					g_musicstart++;
+					g_musicstart&=31;
+					g_musicwait=g_musiclen[g_musicstart];
+					if (((g_musicstart+1)&31)==g_musicend) {
+						// Raise MUSIC interrupt flag
+						raise_interrupt_flag(INTERRUPT_MUSIC);
+					}
+				}
+			} else {
+				// Stop timer
+				T3CONCLR=0x8000;
+			}
+			break;
+		case SOUND_MODE_WAVE:
+			// Initialize parameters
+			if (!T4CONbits.ON){
+				start_dma();
+				wavtable_pos=0;
+			}
+			wavtable_pos=262-wavtable_pos;
+			// Read from file
+			if (0 == FSfread((void*)&g_wavtable[wavtable_pos],1,262,g_fhandle)) {
+				// End of file.
+				stop_dma();
+				FSfclose(g_fhandle);
+				g_fhandle=0;
+				g_sound_mode=SOUND_MODE_MUSIC;
+				stop_music();
+				// Raise WAVE interrupt flag
+				raise_interrupt_flag(INTERRUPT_WAVE);
+				break;
+			}
+			break;
+		default:
+			break;
+	}
+}
+
+int musicGetNum(){
+	int i, ret;
+	char b;
+	// Skip non number character
+	for(i=0;(b=g_mstr[g_mspos+i])<'0' && '9'<g_mstr[g_mspos+i];i++);
+	// Determine the number
+	ret=0;
+	while('0'<=b && b<='9'){
+		ret*=10;
+		ret+=b-'0';
+		i++;
+		b=g_mstr[g_mspos+i];
+	}
+	g_mspos+=i;
+	return ret;
+}
+
+void stop_music(){
+	// Initialize normal music mode.
+
+	// Use Timer3 and OC4 for sound.
+	RPA2R=5;         //Use RPA2 for OC4
+	OC4R=0;
+	OC4CON=0x000b;   // Timer3, toggle mode
+	OC4CONSET=0x8000;// Start OC4
+	T3CON=0x0050;    // Prescaller: 1:32 (1.5 MHz), not yet started
+
+	// Initializations for music/sound.
+	g_musicstart=g_musicend=g_musicwait=g_soundstart=g_soundend=g_soundwait=g_soundrepeat=0;
+	g_sound_mode=SOUND_MODE_MUSIC;
+
+	// Initialize DMA (see also init_dma_music())
+
+	// Stop Timer4
+	T4CON=0x0000; // Not start yet
+
+	// Enable DMA, stop DMA2
+	DMACONSET=0x8000;
+	DCH2CONCLR=0x0080;
+
+	// Close handle if open.
+	if (g_fhandle) FSfclose(g_fhandle);
+	g_fhandle=0;
+
+	// Inactive music first
+	g_music_active=0;
+}
+
+void init_music(){
+	// Initilize music system
+	stop_music();
+	
+	// Initializations for music/sound.
+	g_qvalue=160; // Q: 1/4=90
+	g_lvalue=20;   // L: 1/8
+	g_tones=(int*)&(g_keys[49]); // C major
+}
+
+void musicSetL(){
+	// Set length of a character.
+	// Syntax: L:n/m, where n and m are numbers.
+	int n,m;
+	n=musicGetNum();
+	g_mspos++;
+	m=musicGetNum();
+	g_lvalue=g_qvalue*n/m;
+}
+
+void musicSetQ(){
+	int i;
+	// Syntax: Q:1/4=n, where n is number.
+	// Skip "1/4="
+	for(i=0;g_mstr[g_mspos+i]!='=';i++);
+	g_mspos+=i+1;
+	i=musicGetNum();
+	if      (i<48)  { g_qvalue=320; /* 1/4=45  */ }
+	else if (i<53)  { g_qvalue=288; /* 1/4=50  */ }
+	else if (i<60)  { g_qvalue=256; /* 1/4=56  */ }
+	else if (i<70)  { g_qvalue=224; /* 1/4=64  */ }
+	else if (i<83)  { g_qvalue=192; /* 1/4=75  */ }
+	else if (i<102) { g_qvalue=160; /* 1/4=90  */ }
+	else if (i<132) { g_qvalue=128; /* 1/4=113 */ }
+	else if (i<188) { g_qvalue=96;  /* 1/4=150 */ }
+	else            { g_qvalue=64;  /* 1/4=225 */ }
+	g_lvalue=g_qvalue>>3;
+}
+
+void musicSetK(){
+	// Syntax: K:xxx
+	if (!strncmp((char*)&(g_mstr[g_mspos]),"A#m",3)) {
+			g_mspos+=3;
+			g_tones=(int*)&(g_keys[0]);
+			return;
+	} else if (!strncmp((char*)&(g_mstr[g_mspos]),"D#m",3)) {
+			g_mspos+=3;
+			g_tones=(int*)&(g_keys[7]);
+			return;
+	} else if (!strncmp((char*)&(g_mstr[g_mspos]),"G#m",3)) {
+			g_mspos+=3;
+			g_tones=(int*)&(g_keys[14]);
+			return;
+	} else if (!strncmp((char*)&(g_mstr[g_mspos]),"C#m",3)) {
+			g_mspos+=3;
+			g_tones=(int*)&(g_keys[21]);
+			return;
+	} else if (!strncmp((char*)&(g_mstr[g_mspos]),"F#m",3)) {
+			g_mspos+=3;
+			g_tones=(int*)&(g_keys[28]);
+			return;
+	} else if (!strncmp((char*)&(g_mstr[g_mspos]),"Bbm",3)) {
+			g_mspos+=3;
+			g_tones=(int*)&(g_keys[84]);
+			return;
+	} else if (!strncmp((char*)&(g_mstr[g_mspos]),"Ebm",3)) {
+			g_mspos+=3;
+			g_tones=(int*)&(g_keys[91]);
+			return;
+	} else if (!strncmp((char*)&(g_mstr[g_mspos]),"Abm",3)) {
+			g_mspos+=3;
+			g_tones=(int*)&(g_keys[98]);
+			return;
+	}
+	if (!strncmp((char*)&(g_mstr[g_mspos]),"C#",2)) {
+			g_mspos+=2;
+			g_tones=(int*)&(g_keys[0]);
+			return;
+	} else if (!strncmp((char*)&(g_mstr[g_mspos]),"F#",2)) {
+			g_mspos+=2;
+			g_tones=(int*)&(g_keys[7]);
+			return;
+	} else if (!strncmp((char*)&(g_mstr[g_mspos]),"Bm",2)) {
+			g_mspos+=2;
+			g_tones=(int*)&(g_keys[35]);
+			return;
+	} else if (!strncmp((char*)&(g_mstr[g_mspos]),"Em",2)) {
+			g_mspos+=2;
+			g_tones=(int*)&(g_keys[42]);
+			return;
+	} else if (!strncmp((char*)&(g_mstr[g_mspos]),"Am",2)) {
+			g_mspos+=2;
+			g_tones=(int*)&(g_keys[49]);
+			return;
+	} else if (!strncmp((char*)&(g_mstr[g_mspos]),"Dm",2)) {
+			g_mspos+=2;
+			g_tones=(int*)&(g_keys[56]);
+			return;
+	} else if (!strncmp((char*)&(g_mstr[g_mspos]),"Gm",2) || !strncmp((char*)&(g_mstr[g_mspos]),"Bb",2)) {
+			g_mspos+=2;
+			g_tones=(int*)&(g_keys[63]);
+			return;
+	} else if (!strncmp((char*)&(g_mstr[g_mspos]),"Cm",2) || !strncmp((char*)&(g_mstr[g_mspos]),"Eb",2)) {
+			g_mspos+=2;
+			g_tones=(int*)&(g_keys[70]);
+			return;
+	} else if (!strncmp((char*)&(g_mstr[g_mspos]),"Fm",2) || !strncmp((char*)&(g_mstr[g_mspos]),"Ab",2)) {
+			g_mspos+=2;
+			g_tones=(int*)&(g_keys[77]);
+			return;
+	} else if (!strncmp((char*)&(g_mstr[g_mspos]),"Db",2)) {
+			g_mspos+=2;
+			g_tones=(int*)&(g_keys[84]);
+			return;
+	} else if (!strncmp((char*)&(g_mstr[g_mspos]),"Gb",2)) {
+			g_mspos+=2;
+			g_tones=(int*)&(g_keys[91]);
+			return;
+	} else if (!strncmp((char*)&(g_mstr[g_mspos]),"Cb",2)) {
+			g_mspos+=2;
+			g_tones=(int*)&(g_keys[98]);
+			return;
+	}
+	switch(g_mstr[g_mspos]){
+		case 'B':
+			g_mspos++;
+			g_tones=(int*)&(g_keys[14]);
+			return;
+		case 'E':
+			g_mspos++;
+			g_tones=(int*)&(g_keys[21]);
+			return;
+		case 'A':
+			g_mspos++;
+			g_tones=(int*)&(g_keys[28]);
+			return;
+		case 'D':
+			g_mspos++;
+			g_tones=(int*)&(g_keys[35]);
+			return;
+		case 'G':
+			g_mspos++;
+			g_tones=(int*)&(g_keys[42]);
+			return;
+		case 'C':
+			g_mspos++;
+			g_tones=(int*)&(g_keys[49]);
+			return;
+		case 'F':
+			g_mspos++;
+			g_tones=(int*)&(g_keys[56]);
+			return;
+		default:
+			err_music(g_mstr);
+			break;
+	}
+}
+void musicSetM(){
+	// Currently do nothing
+	musicGetNum();
+	musicGetNum();
+}
+
+void set_sound(unsigned long* data, int flagsLR){
+	// flagsLR is ignored
+	int sound;
+	int len;
+	int pos;
+	int datalen;
+	IEC0bits.T4IE=0; // Stop interruption, first.
+	// Initialize
+	g_soundrepeat=g_soundstart=g_soundend=0;
+	pos=0;
+	do {
+		while(data[1]!=0x00000020) data++; // Seek DATA statement
+		datalen=(data[0]&0x00007FFF)-1;    // Use bgezal statement containing data length.
+		data+=2;
+		while(0<datalen){
+			datalen--;
+			len=data[0]>>16;
+			sound=data[0]&0x0000FFFF;
+			data++;
+			if (len) {
+				// Shift tone for 2048 <--> ~440 Hz.
+				// 2048 must be changed to 1705
+				//    x 1705 / 2048 = 213 / 256 + 1 / 2048
+				sound=213*(sound>>8)+(sound>>11);
+				g_sound[pos]=sound-1;
+				g_soundlen[pos]=len;
+				pos++;
+				if (32<pos) {
+					err_music("Sound data too long.");
+					return;
+				}
+			} else {
+				g_soundrepeat=sound;
+				break;
+			}
+		}
+	} while(len);
+	g_soundend=pos;
+	g_soundwait=g_soundlen[0];
+	IEC0bits.T4IE=1; // Restart interrupt.
+	g_music_active=1;// Activate music system
+}
+
+void set_music(char* str, int flagsLR){
+	// flagsLR is ignored
+	char b;
+	unsigned long tone,tonenatural;
+	int len;
+	g_mstr=str;
+	g_mspos=0;
+	while(0<(b=g_mstr[g_mspos])){
+		if (g_mstr[g_mspos+1]==':') {
+			// Set property
+			g_mspos+=2;
+			switch(b){
+				case 'L':
+					musicSetL();
+					break;
+				case 'Q':
+					musicSetQ();
+					break;
+				case 'K':
+					musicSetK();
+					break;
+				case 'M':
+					musicSetM();
+					break;
+				default:
+					err_music(str);
+					break;
+			}	
+		} else if ('A'<=b && b<='G' || 'a'<=b && b<='g' || b=='z') {
+			g_mspos++;
+			if (b=='z') {
+				tone=0;
+			} else if (b<='G') {
+				tone=g_tones[b-'A'];
+				tonenatural=g_keys[b-'A'+49];
+			} else {
+				tone=g_tones[b-'a']>>1;
+				tonenatural=g_keys[b-'a'+49]>>1;
+			}
+			// Check "'"s
+			while(g_mstr[g_mspos]=='\''){
+				g_mspos++;
+				tone>>=1;
+			}
+			// Check ","s
+			while(g_mstr[g_mspos]==','){
+				g_mspos++;
+				tone<<=1;
+				tonenatural<<=1;
+			}
+			// Check "^","=","_"
+			switch(g_mstr[g_mspos]){
+				case '^':
+					g_mspos++;
+					tone=toneSharp(tone);
+					break;
+				case '_':
+					g_mspos++;
+					tone=toneFlat(tone);
+					break;
+				case '=':
+					g_mspos++;
+					tone=tonenatural;
+					break;
+				default:
+					break;
+			}
+			// Check number for length
+			b=g_mstr[g_mspos];
+			if ('0'<=b && b<='9') {
+				len=g_lvalue*musicGetNum();
+			} else {
+				len=g_lvalue;
+			}
+			if (g_mstr[g_mspos]=='/') {
+				g_mspos++;
+				len=len/musicGetNum();
+			}
+			// Shift tone if graphic is used
+			if (g_use_graphic) {
+				// MUL_15 instead of MUL_16 for CPU clock.
+				// tone=tone*15/16
+				tone-=(tone+7)>>4;
+			}
+			// Update music value array
+			IEC0bits.T4IE=0; // Stop interruption, first.
+			if (g_musicstart==g_musicend) {
+				g_musicwait=len;
+			}
+			g_music[g_musicend]=(tone-1)&0x0000FFFF;
+			g_musiclen[g_musicend]=len;
+			g_musicend++;
+			g_musicend&=31;
+			IEC0bits.T4IE=1; // Restart interruption.
+		} else {
+			err_music(str);
+		}
+		// Go to next character
+		while(0<g_mstr[g_mspos] && g_mstr[g_mspos]<=0x20 || g_mstr[g_mspos]=='|') g_mspos++;
+	}
+	g_music_active=1;// Activate music system
+}
+
+/*
+	PLAYWAVE routines follow
+*/
+
+int checkChars(char* str1, char* str2, int num){
+	int i;
+	for(i=0;i<num;i++){
+		if (str1[i]!=str2[i]) return 1;
+	}
+	return 0;
+}
+
+void init_dma_music(){
+	// Timer4 for 15700 Hz
+	T4CON=0x0000; // Not start yet
+	if (g_use_graphic) {
+		PR4=3405-1;
+	} else {
+		PR4=3632-1;
+	}
+	TMR4=PR4-1;
+
+	// Timer3 for PWM
+	TMR3=0;
+	PR3=0x100;
+	T3CON=0x8000;
+
+	// OC4 setting
+	RPA2R=5;         //Use RPA2 for OC4
+	OC4RS=0x80;
+	OC4CON=0x000e;
+	OC4CONSET=0x8000;
+
+	//DMA2 settings for OC4
+	DMACONSET=0x8000;
+	DCH2CON=0x00000012;  // CHBUSY=0, CHCHNS=0, CHEN=0, CHAED=0, CHCHN=0, CHAEN=1, CHEDET=0, CHPRI=b10
+	DCH2ECON=0x1310;     // CHAIRQ=0, CHSIRQ=19, CFORCE=0, CABRT=0, PATEN=0, SIRQEN=1, AIRQEN=0
+	                     // CHSIRQ=19: Timer4 interrupt
+	DCH2SSA=((unsigned int)&(g_wavtable[0]))&0x1fffffff;
+	DCH2DSA=0x1F803620; // OC4RS
+	DCH2SSIZ=524;
+	DCH2DSIZ=1;
+	DCH2CSIZ=1;
+	DCH2INTCLR=0x00FF00FF;
+	DCH2CONSET=0x00000080;
+}
+
+void play_wave(char* filename, int start){
+	int i;
+	// Stop the previous play
+	stop_music();
+	// Exit function if null filename
+	if (filename[0]==0x00) {
+		return;
+	}
+	// Alocate 524 byte buffer if not assigned
+	if (g_var_size[ALLOC_WAVE_BLOCK]==0) {
+		g_wavtable=(char*)alloc_memory(524/4,ALLOC_WAVE_BLOCK);
+	}
+	// Open file
+	if (g_fhandle) FSfclose(g_fhandle);
+	g_fhandle=FSfopen(filename,"r");
+	if (!g_fhandle) err_file();
+	// Read header and check if monaural 8 bit 16000 Hz.
+	if (0x2c != FSfread((void*)&g_wavtable[0],1,0x2c,g_fhandle)) err_file();
+	i=0;
+	i+=checkChars((char*)&g_wavtable[0],"RIFF",4);                      // Check RIFF
+	i+=checkChars((char*)&g_wavtable[8],"WAVEfmt ",8);                  // Check WAVE and fmt
+	i+=checkChars((char*)&g_wavtable[16],"\x10\x00\x00\x00\x01\x00",6); // Check if liear PCM
+	if (!checkChars((char*)&g_wavtable[22],"\x01\x00\x80\x3e\x00\x00\x80\x3e\x00\x00\x01\x00",12)) {
+		// Monaural 16000 Hz
+	} else if (!checkChars((char*)&g_wavtable[22],"\x01\x00\x54\x3d\x00\x00\x54\x3d\x00\x00\x01\x00",12)) {
+		// Monaural 15700 Hz
+	} else {
+		i=1;
+	}
+	i+=checkChars((char*)&g_wavtable[34],"\x08\x00\x64\x61\x74\x61",6); // Check bit # and data
+	if (i) err_wave();
+	// Support defined start position here to skip file pointer here.
+	FSfseek(g_fhandle, start, SEEK_CUR);
+	// Read first 262 bytes.
+	if (262 != FSfread((void*)&g_wavtable[0],1,262,g_fhandle)) err_file();
+
+	// Initialize DMA
+	init_dma_music();	
+	g_sound_mode=SOUND_MODE_WAVE;
+
+	g_music_active=1;// Activate music system
+}

--- /dev/null
+++ b/mips/protozoa/operator.c
@@ -0,0 +1,277 @@
+/*
+   This file is provided under the LGPL license ver 2.1.
+   Written by Katsumi.
+   http://hp.vector.co.jp/authors/VA016157/
+   [e-mail]
+*/
+
+/*
+	This file is shared by Megalopa and Zoea
+*/
+
+#include "compiler.h"
+
+/*
+Operators: (upper ones have higher priority
+()
+* / %
++ -
+<< >>
+< <= > >=
+= !=
+XOR
+AND
+OR
+*/
+
+
+const unsigned char g_priority[]={
+	0, // OP_VOID
+	1, // OP_OR
+	2, // OP_AND
+	3, // OP_XOR
+	4,4, // OP_EQ, OP_NEQ
+	5,5,5,5, // OP_LT, OP_LTE, OP_MT, OP_MTE
+	6,6, // OP_SHL, OP_SHR
+	7,7, // OP_ADD, OP_SUB
+	8,8,8 // OP_MUL, OP_DIV, OP_REM
+};
+
+enum operator g_last_op;
+
+char* get_operator(void){
+	char b1,b2,b3;
+	next_position();
+	b1=g_source[g_srcpos];
+	b2=g_source[g_srcpos+1];
+	b3=g_source[g_srcpos+2];
+	switch(b1){
+		case '%': g_last_op=OP_REM; break;
+		case '/': g_last_op=OP_DIV; break;
+		case '*': g_last_op=OP_MUL; break;
+		case '-': g_last_op=OP_SUB; break;
+		case '+': g_last_op=OP_ADD; break;
+		case '>':
+			if (b2=='>') {
+				g_srcpos++;
+				g_last_op=OP_SHR;
+			} else if (b2=='=') {
+				g_srcpos++;
+				g_last_op=OP_MTE;
+			} else {
+				g_last_op=OP_MT;
+			}
+			break;
+		case '<':
+			if (b2=='<') {
+				g_srcpos++;
+				g_last_op=OP_SHL;
+			} else if (b2=='=') {
+				g_srcpos++;
+				g_last_op=OP_LTE;
+			} else {
+				g_last_op=OP_LT;
+			}
+			break;
+		case '!':
+			if (b2!='=') return ERR_SYNTAX;
+			g_srcpos++;
+			g_last_op=OP_NEQ;
+			break;
+		case '=':
+			if (b2=='=') g_srcpos++;
+			g_last_op=OP_EQ;
+			break;
+		case 'X':
+			if (b2!='O') return ERR_SYNTAX;
+			if (b3!='R') return ERR_SYNTAX;
+			g_srcpos++;
+			g_srcpos++;
+			g_last_op=OP_XOR;
+			break;
+		case 'O':
+			if (b2!='R') return ERR_SYNTAX;
+			g_srcpos++;
+			g_last_op=OP_OR;
+			break;
+		case 'A':
+			if (b2!='N') return ERR_SYNTAX;
+			if (b3!='D') return ERR_SYNTAX;
+			g_srcpos++;
+			g_srcpos++;
+			g_last_op=OP_AND;
+			break;
+		default:
+			return ERR_SYNTAX;
+	}
+	g_srcpos++;
+	return 0;
+}
+
+char* get_floatOperator(void){
+	char* err;
+	int spos;
+	next_position();
+	spos=g_srcpos;
+	err=get_operator();
+	if (err) return err;
+	switch(g_last_op){
+		// Following operators cannot be used for float values.
+		case OP_XOR:
+		case OP_REM:
+		case OP_SHR:
+		case OP_SHL:
+			g_srcpos=spos;
+			return ERR_SYNTAX;
+		default:
+			return 0;
+	}
+}
+
+char* calculation(enum operator op){
+	// $v0 = $v1 <op> $v0;
+	switch(op){
+		case OP_OR:
+			check_obj_space(1);
+			g_object[g_objpos++]=0x00621025; // or          v0,v1,v0
+			break;
+		case OP_AND:
+			check_obj_space(1);
+			g_object[g_objpos++]=0x00621024; // and         v0,v1,v0
+			break;
+		case OP_XOR:
+			check_obj_space(1);
+			g_object[g_objpos++]=0x00621026; // xor         v0,v1,v0
+			break;
+		case OP_EQ:
+			check_obj_space(2);
+			g_object[g_objpos++]=0x00621026; // xor         v0,v1,v0
+			g_object[g_objpos++]=0x2C420001; // sltiu       v0,v0,1
+			break;
+		case OP_NEQ:
+			check_obj_space(2);
+			g_object[g_objpos++]=0x00621026; // xor         v0,v1,v0
+			g_object[g_objpos++]=0x0002102B; // sltu        v0,zero,v0
+			break;
+		case OP_LT:
+			check_obj_space(1);
+			g_object[g_objpos++]=0x0062102A; // slt         v0,v1,v0
+			break;
+		case OP_LTE:
+			check_obj_space(2);
+			g_object[g_objpos++]=0x0043102A; // slt         v0,v0,v1
+			g_object[g_objpos++]=0x38420001; // xori        v0,v0,0x1
+			break;
+		case OP_MT:
+			check_obj_space(1);
+			g_object[g_objpos++]=0x0043102A; // slt         v0,v0,v1
+			break;
+		case OP_MTE:
+			check_obj_space(2);
+			g_object[g_objpos++]=0x0062102A; // slt         v0,v1,v0
+			g_object[g_objpos++]=0x38420001; // xori        v0,v0,0x1
+			break;
+		case OP_SHR:
+			check_obj_space(1);
+			g_object[g_objpos++]=0x00431006; // srlv        v0,v1,v0
+			break;
+		case OP_SHL:
+			check_obj_space(1);
+			g_object[g_objpos++]=0x00431004; // sllv        v0,v1,v0
+			break;
+		case OP_ADD:
+			check_obj_space(1);
+			g_object[g_objpos++]=0x00621021; // addu        v0,v1,v0
+			break;
+		case OP_SUB:
+			check_obj_space(1);
+			g_object[g_objpos++]=0x00621023; // subu        v0,v1,v0
+			break;
+		case OP_MUL:
+			check_obj_space(1);
+			g_object[g_objpos++]=0x70621002; // mul         v0,v1,v0
+			break;
+		case OP_DIV:
+			// Note that intterupt functions do not use mflo and mfhi.
+			// Probably using div does not cause delay of interrupt.
+			check_obj_space(5);
+			g_object[g_objpos++]=0x14400003;                                        // bne         v0,zero,label
+			g_object[g_objpos++]=0x0062001A;                                        // div         v1,v0
+			call_lib_code(LIB_DIV0); // 2 words
+ 			                                                                        // label:
+			g_object[g_objpos++]=0x00001012;                                        // mflo        v0
+			break;
+		case OP_REM:
+			check_obj_space(5);
+			g_object[g_objpos++]=0x14400003;                                        // bne         v0,zero,label
+			g_object[g_objpos++]=0x0062001A;                                        // div         v1,v0
+			call_lib_code(LIB_DIV0); // 2 words
+ 			                                                                        // label:
+			g_object[g_objpos++]=0x00001010;                                        // mfhi        v0
+			break;
+		default:
+			return ERR_SYNTAX;
+	}
+	return 0;
+}
+
+char* calculation_float(enum operator op){
+	// $v0 = $a0 <op> $v0;
+	// All the calculations will be done in library code, lib_float function (see below).
+	call_lib_code(LIB_FLOAT | op);
+	return 0;
+}
+
+int lib_float(int ia0,int iv0, enum operator a1){
+	// This function was called from _call_library().
+	// Variable types must be all int.
+	// Casting cannot be used.
+	// Instead, by using pointer, put as int value, get as float value, 
+	// calculate, put as float value, then get as int value for returning.
+	volatile float a0,v0;
+	((int*)(&a0))[0]=ia0;
+	((int*)(&v0))[0]=iv0;
+	switch(a1){
+		case OP_EQ:
+			v0= a0==v0?1:0;
+			break;
+		case OP_NEQ:
+			v0= a0!=v0?1:0;
+			break;
+		case OP_LT:
+			v0= a0<v0?1:0;
+			break;
+		case OP_LTE:
+			v0= a0<=v0?1:0;
+			break;
+		case OP_MT:
+			v0= a0>v0?1:0;
+			break;
+		case OP_MTE:
+			v0= a0>=v0?1:0;
+			break;
+		case OP_ADD:
+			v0= a0+v0;
+			break;
+		case OP_SUB:
+			v0= a0-v0;
+			break;
+		case OP_MUL:
+			v0= a0*v0;
+			break;
+		case OP_DIV:
+			if (v0==0) err_div_zero();
+			v0= a0/v0;
+			break;
+		case OP_OR:
+			v0= a0||v0?1:0;
+			break;
+		case OP_AND:
+			v0= a0&&v0?1:0;
+			break;
+		default:
+			err_unknown();
+			return 0;
+	}
+	return ((int*)(&v0))[0];
+}; 
\ No newline at end of file

--- /dev/null
+++ b/mips/protozoa/protozoa.mcp
@@ -0,0 +1,210 @@
+[HEADER]
+magic_cookie={66E99B07-E706-4689-9E80-9B2582898A13}
+file_version=1.0
+device=PIC32MX150F128B
+[PATH_INFO]
+BuildDirPolicy=BuildDirIsProjectDir
+dir_src=
+dir_bin=
+dir_tmp=
+dir_sin=
+dir_inc=
+dir_lib=C:\Program Files\Microchip\xc32\v1.42\pic32mx\lib
+dir_lkr=
+[CAT_FILTERS]
+filter_src=*.s;*.c
+filter_inc=*.h;*.inc
+filter_obj=*.o
+filter_lib=*.a
+filter_lkr=*.ld
+[CAT_SUBFOLDERS]
+subfolder_src=
+subfolder_inc=
+subfolder_obj=
+subfolder_lib=
+subfolder_lkr=
+[FILE_SUBFOLDERS]
+file_000=.
+file_001=.
+file_002=.
+file_003=.
+file_004=.
+file_005=.
+file_006=.
+file_007=.
+file_008=.
+file_009=.
+file_010=.
+file_011=.
+file_012=.
+file_013=.
+file_014=.
+file_015=.
+file_016=.
+file_017=.
+file_018=.
+file_019=.
+file_020=.
+file_021=.
+file_022=.
+file_023=.
+file_024=.
+file_025=.
+file_026=.
+file_027=.
+file_028=.
+file_029=.
+file_030=.
+file_031=.
+file_032=.
+file_033=.
+file_034=.
+file_035=.
+file_036=.
+file_037=.
+file_038=.
+file_039=.
+file_040=.
+[GENERATED_FILES]
+file_000=no
+file_001=no
+file_002=no
+file_003=no
+file_004=no
+file_005=no
+file_006=no
+file_007=no
+file_008=no
+file_009=no
+file_010=no
+file_011=no
+file_012=no
+file_013=no
+file_014=no
+file_015=no
+file_016=no
+file_017=no
+file_018=no
+file_019=no
+file_020=no
+file_021=no
+file_022=no
+file_023=no
+file_024=no
+file_025=no
+file_026=no
+file_027=no
+file_028=no
+file_029=no
+file_030=no
+file_031=no
+file_032=no
+file_033=no
+file_034=no
+file_035=no
+file_036=no
+file_037=no
+file_038=no
+file_039=no
+file_040=no
+[OTHER_FILES]
+file_000=no
+file_001=no
+file_002=no
+file_003=no
+file_004=no
+file_005=no
+file_006=no
+file_007=no
+file_008=no
+file_009=no
+file_010=no
+file_011=no
+file_012=no
+file_013=no
+file_014=no
+file_015=no
+file_016=no
+file_017=no
+file_018=no
+file_019=no
+file_020=no
+file_021=no
+file_022=no
+file_023=no
+file_024=no
+file_025=no
+file_026=no
+file_027=no
+file_028=no
+file_029=no
+file_030=no
+file_031=no
+file_032=no
+file_033=no
+file_034=no
+file_035=no
+file_036=no
+file_037=no
+file_038=no
+file_039=no
+file_040=no
+[FILE_INFO]
+file_000=args.c
+file_001=class.c
+file_002=cmpdata.c
+file_003=compiler.c
+file_004=debug.c
+file_005=editor.c
+file_006=envspecific.c
+file_007=error.c
+file_008=exception.c
+file_009=file.c
+file_010=float.c
+file_011=function.c
+file_012=globalvars.c
+file_013=library.c
+file_014=linker.c
+file_015=main.c
+file_016=memory.c
+file_017=music.c
+file_018=operator.c
+file_019=run.c
+file_020=statement.c
+file_021=string.c
+file_022=timer.c
+file_023=value.c
+file_024=varname.c
+file_025=interface\graphlib.c
+file_026=interface\keyinput.c
+file_027=interface\LCDdriver.c
+file_028=api.h
+file_029=compiler.h
+file_030=debug.h
+file_031=editor.h
+file_032=envspecific.h
+file_033=main.h
+file_034=interface\keyinput.h
+file_035=interface\LCDdriver.h
+file_036=interface\ps2keyboard.h
+file_037=interface\SDFSIO.h
+file_038=interface\videoout.h
+file_039=interface\libsdfsio.a
+file_040=App_32MX170F256B.ld
+[SUITE_INFO]
+suite_guid={62D235D8-2DB2-49CD-AF24-5489A6015337}
+suite_state=
+[TOOL_SETTINGS]
+TS{6F324298-6323-4781-8C43-43FA5E6F3646}=-gdwarf-2
+TS{1F324EFA-C0BA-4A8F-A85A-B21644939CAD}=-g -D_SUPPRESS_PLIB_WARNING -O1
+TS{29D3B6CC-DCAB-4659-8011-FFF75BB7F8D7}=-o"$(BINDIR_)$(TARGETBASE).$(TARGETSUFFIX)" -Map="$(BINDIR_)$(TARGETBASE).map"
+TS{AD4C3FBD-B6BB-4F50-AB4E-35BF132D4D60}=
+[INSTRUMENTED_TRACE]
+enable=0
+transport=0
+format=0
+[CUSTOM_BUILD]
+Pre-Build=
+Pre-BuildEnabled=1
+Post-Build=
+Post-BuildEnabled=1

--- /dev/null
+++ b/mips/protozoa/run.c
@@ -0,0 +1,133 @@
+/*
+   This file is provided under the LGPL license ver 2.1.
+   Written by K.Tanaka & Katsumi
+   http://www.ze.em-net.ne.jp/~kenken/index.html
+   http://hp.vector.co.jp/authors/VA016157/
+*/
+
+/*
+	This file is shared by Megalopa and Zoea
+*/
+
+#include <xc.h>
+#include "api.h"
+#include "compiler.h"
+#include "editor.h"
+#include "main.h"
+
+char* printdec(int num){
+	char str[11];
+	int i;
+	if (num<0) {
+		printchar('-');
+		num=0-num;
+	}
+	for(i=10;0<i;i--){
+		if (num==0 && i<10) break;
+		str[i]='0'+rem10_32(num);
+		num=div10_32(num);
+	}
+	for(i++;i<11;i++) {
+		printchar(str[i]);
+	}
+}
+
+int runbasic(char *appname,int test){
+// BASICソースのコンパイルと実行
+// appname 実行するBASICソースファイル
+// test 0:コンパイルと実行、0以外:コンパイルのみで終了
+//
+// 戻り値
+//　　0:正常終了
+//　　-1:ファイルエラー
+//　　-2:リンクエラー
+//　　1以上:コンパイルエラーの発生行（行番号ではなくファイル上の何行目か）
+	int i;
+	char* buff;
+	char* err;
+
+	// Set grobal pointer
+	g_gp=get_gp();
+	// Set buffer positions
+	buff=(char*)&(RAM[RAMSIZE-512]);
+	// Set object positions
+	g_object=(int*)(&RAM[0]);
+	g_objpos=0;
+	g_objmax=g_object+(RAMSIZE-512)/4; // Buffer area excluded.
+	// Clear object area
+	for(i=0;i<RAMSIZE/4;i++) g_object[i]=0x00000000;
+
+	// Check file error
+	err=init_file(buff,appname);
+	if (err) {
+		setcursorcolor(COLOR_ERRORTEXT);
+		printstr("Can't Open ");
+		printstr(appname);
+		printchar('\n');
+		return -1;
+	}
+	close_file();	
+
+	// Initialize parameters
+	g_pcg_font=0;
+	g_use_graphic=0;
+	g_graphic_area=0;
+	clearscreen();
+	setcursor(0,0,7);
+	g_long_name_var_num=0;
+	cmpdata_init();
+
+	// Initialize music system
+	init_music();
+
+	printstr("BASIC "BASVER"\n");
+	wait60thsec(15);
+
+	printstr("Compiling...");
+
+	// Compile the file
+	i=compile_and_link_main_file(buff,appname);
+	if (i) return i;
+
+	// All done
+	printstr("done\n");
+	if(test) return 0; //コンパイルのみの場合
+	wait60thsec(15);
+
+	// Initialize the other parameters
+	// Random seed
+	g_rnd_seed=0x92D68CA2; //2463534242
+	// Clear variables
+	for(i=0;i<ALLOC_BLOCK_NUM;i++){
+		g_var_mem[i]=0;
+		g_var_size[i]=0;
+	}
+	// Clear key input buffer
+	for(i=0;i<256;i++){
+		ps2keystatus[i]=0;
+	}
+	// Reset data/read.
+	reset_dataread();
+	// Initialize file system
+	lib_file(FUNC_FINIT,0,0,0);
+
+	// Assign memory
+	set_free_area((void*)(g_object+g_objpos),(void*)(&RAM[RAMSIZE]));
+
+	// Warm up environment
+	pre_run();
+	init_timer();
+
+	// Execute program
+	// Start program from the beginning of RAM.
+	// Work area (used for A-Z values) is next to the object code area.
+	start_program((void*)(&(RAM[0])),(void*)(&g_var_mem[0]));
+	printstr("\nOK\n");
+
+	// Cool down environment
+	post_run();
+	lib_file(FUNC_FINIT,0,0,0);
+	stop_timer();
+
+	return 0;
+}

--- /dev/null
+++ b/mips/protozoa/statement.c
@@ -0,0 +1,1771 @@
+/*
+   This file is provided under the LGPL license ver 2.1.
+   Written by Katsumi.
+   http://hp.vector.co.jp/authors/VA016157/
+   [e-mail]
+*/
+
+/*
+	This file is shared by Megalopa and Zoea
+*/
+
+#include "api.h"
+#include "compiler.h"
+
+char* rem_statement(){
+	if (g_source[g_srcpos-4]<0x20) {
+		// This line contains only "REM" statement
+		// Delete $s6-setting command if exists.
+		if ((g_object[g_objpos-1]&0xffff0000)==0x34160000) g_objpos--;
+	}
+	while(0xE0 & g_source[g_srcpos]){
+		g_srcpos++;
+	}
+	return 0;
+}
+
+char* sound_statement(){
+	char *err;
+	err=get_label();
+	if (err) return err;
+	if (g_label) {
+		// Label/number is constant.
+		// Linker will change following codes later.
+		// Note that 0x0814xxxx and 0x0815xxxx are specific codes for these.
+		check_obj_space(2);
+		g_object[g_objpos++]=0x08140000|((g_label>>16)&0x0000FFFF); // lui   v0,xxxx
+		g_object[g_objpos++]=0x08150000|(g_label&0x0000FFFF);       // ori v0,v0,xxxx
+	} else {
+		// Label/number will be dynamically set when executing code.
+		err=get_value();
+		if (err) return err;
+		call_lib_code(LIB_LABEL);
+	}
+	// 2nd param is optional
+	next_position();
+	if (g_source[g_srcpos]==',') {
+		g_srcpos++;
+		check_obj_space(2);
+		g_object[g_objpos++]=0x27BDFFFC; // addiu       sp,sp,-4
+		g_object[g_objpos++]=0xAFA20004; // sw          v0,4(sp)
+		err=get_value();
+		if (err) return err;
+		check_obj_space(3);
+		g_object[g_objpos++]=0x00402021; // addu        a0,v0,zero
+		g_object[g_objpos++]=0x8FA20004; // lw          v0,4(sp)
+		g_object[g_objpos++]=0x27BD0004; // addiu       sp,sp,4
+	} else {
+		// Set 3 if omitted
+		check_obj_space(1);
+		g_object[g_objpos++]=0x24040003; // addiu       a0,zero,xx
+	}
+	call_lib_code(LIB_SOUND);
+	return 0;
+}
+char* music_statement(){
+	char *err;
+	err=get_string();
+	if (err) return err;
+	// 2nd param is optional
+	next_position();
+	if (g_source[g_srcpos]==',') {
+		g_srcpos++;
+		check_obj_space(2);
+		g_object[g_objpos++]=0x27BDFFFC; // addiu       sp,sp,-4
+		g_object[g_objpos++]=0xAFA20004; // sw          v0,4(sp)
+		err=get_value();
+		if (err) return err;
+		check_obj_space(3);
+		g_object[g_objpos++]=0x00402021; // addu        a0,v0,zero
+		g_object[g_objpos++]=0x8FA20004; // lw          v0,4(sp)
+		g_object[g_objpos++]=0x27BD0004; // addiu       sp,sp,4
+	} else {
+		// Set 3 if omitted
+		check_obj_space(1);
+		g_object[g_objpos++]=0x24040003; // addiu       a0,zero,xx
+	}
+	call_lib_code(LIB_MUSIC);
+	return 0;
+}
+
+char* exec_statement(){
+	char *err;
+	char b1;
+	int i,prevpos;
+	b1=g_source[g_srcpos];
+	while('0'<=b1 && b1<='9' || b1=='-' || b1=='$'){
+		prevpos=g_objpos;
+		g_valueisconst=1;
+		err=get_simple_value();
+		if (!g_valueisconst) err=ERR_SYNTAX;
+		if (err) return err;
+		check_obj_space(1);
+		g_objpos=prevpos;
+		g_object[g_objpos++]=g_intconst;
+		next_position();
+		b1=g_source[g_srcpos];
+		if (b1!=',') break;
+		g_srcpos++;
+		next_position();
+		b1=g_source[g_srcpos];
+		if (b1==0x0d || b1==0x0a) {
+			// Multiline DATA/EXEC statement
+			g_line++;
+			g_fileline++;
+			if (b1==0x0D && g_source[g_srcpos+1]==0x0A) g_srcpos++;
+			g_srcpos++;
+			// Maintain at least 256 characters in cache.
+			if (256<=g_srcpos) read_file(256);
+			next_position();
+			b1=g_source[g_srcpos];
+		}			
+	}
+	return 0;
+}
+
+char* cdata_statement(){
+	// 0x00000020, 0x00000021, 0x00000022, and 0x00000023 (add/addu/sub/subu zero,zero,zero) 
+	// are the sign of data region
+	int beginpos,prevpos;
+	char* err;
+	char b1;
+	char* cpy;
+	int shift=0;
+	int i=0;
+	// This statement is not valid in class file.
+	if (g_compiling_class) return ERR_INVALID_CLASS;
+	beginpos=g_objpos;
+	check_obj_space(2);
+	g_object[g_objpos++]=0x04110000; // bgezal      zero,xxxx
+	g_object[g_objpos++]=0x00000020; // add         zero,zero,zero
+	next_position();
+	b1=g_source[g_srcpos];
+	while('0'<=b1 && b1<='9' || b1=='-' || b1=='$'){
+		prevpos=g_objpos;
+		g_valueisconst=1;
+		err=get_simple_value();
+		if (!g_valueisconst) err=ERR_SYNTAX;
+		if (g_intconst<0x00 || 0xff<g_intconst) err=ERR_SYNTAX;
+		if (err) return err;
+		g_objpos=prevpos;
+		i|=g_intconst<<shift;
+		shift+=8;
+		if (32<=shift) {
+			check_obj_space(1);
+			g_object[g_objpos++]=i;
+			shift=0;
+			i=0;
+		}
+		next_position();
+		b1=g_source[g_srcpos];
+		if (b1!=',') break;
+		g_srcpos++;
+		next_position();
+		b1=g_source[g_srcpos];
+		if (b1==0x0d || b1==0x0a) {
+			// Multiline CDATA statement
+			g_line++;
+			g_fileline++;
+			if (b1==0x0D && g_source[g_srcpos+1]==0x0A) g_srcpos++;
+			g_srcpos++;
+			// Maintain at least 256 characters in cache.
+			if (256<=g_srcpos) read_file(256);
+			next_position();
+			b1=g_source[g_srcpos];
+		}			
+	}
+	// Write the last 1-3 bytes and shift data if total # is not multipes of 4.
+	if (0<shift) {
+		// Convert shift value from bit-shift to data byte-shift.
+		shift=4-shift/8;
+		check_obj_space(1);
+		g_object[g_objpos++]=i;
+		for(cpy=(char*)&g_object[g_objpos]-1;(char*)&g_object[beginpos+2]<cpy;cpy--){
+			cpy[0]=cpy[0-shift];
+		}
+	}
+	// Determine the size of data
+	i=g_objpos-beginpos-1;
+	g_object[beginpos]  =0x04110000|i;     // bgezal zero,xxxx
+	g_object[beginpos+1]=0x00000020|shift; // add         zero,zero,zero
+	return 0;
+}
+
+char* data_statement(){
+	// 0x00000020, 0x00000021, 0x00000022, and 0x00000023 (add/addu/sub/subu zero,zero,zero) 
+	// are the sign of data region
+	int i,prevpos;
+	char* err;
+	// This statement is not valid in class file.
+	if (g_compiling_class) return ERR_INVALID_CLASS;
+	while(1){
+		prevpos=g_objpos;
+		check_obj_space(2);
+		g_object[g_objpos++]=0x04110000; // bgezal      zero,xxxx
+		g_object[g_objpos++]=0x00000020; // add         zero,zero,zero
+		next_position();
+		if (g_source[g_srcpos]=='"') {
+			// Constant string
+			// Store pointer to string. This is 3 words bellow of current position
+			g_object[g_objpos]=(int)(&g_object[g_objpos+3]);
+			g_objpos++;
+			g_object[prevpos]=0x04110002; // bgezal zero,xxxx
+			err=simple_string();
+			if (err) return err;
+			next_position();
+			if (g_source[g_srcpos]==',') {
+				g_srcpos++;
+				continue;
+			}
+			return 0;
+		}
+		err=exec_statement();
+		if (err) return err;
+		// Determine the size of data
+		i=g_objpos-prevpos-1;
+		g_object[prevpos]=0x04110000|i; // bgezal zero,xxxx
+		if (g_source[g_srcpos]=='"') {
+			// Constant string
+			continue;
+		}
+		return 0;
+	}
+}
+
+char* clear_statement(){
+	call_lib_code(LIB_CLEAR);
+	return 0;
+}
+
+char* poke_statement_sub(int bits){
+	char* err;
+	err=get_value();
+	if (err) return err;
+	if (g_source[g_srcpos]!=',') return ERR_SYNTAX;
+	g_srcpos++;
+	check_obj_space(2);
+	g_object[g_objpos++]=0x27BDFFFC; // addiu       sp,sp,-4
+	g_object[g_objpos++]=0xAFA20004; // sw          v0,4(sp)
+	err=get_value();
+	if (err) return err;
+	check_obj_space(3);
+	g_object[g_objpos++]=0x8FA30004; // lw          v1,4(sp)
+	g_object[g_objpos++]=0x27BD0004; // addiu       sp,sp,4
+	switch(bits){
+		case 32:
+			g_object[g_objpos++]=0xAC620000; // sw          v0,0(v1)
+			break;
+		case 16:
+			g_object[g_objpos++]=0xA4620000; // sh          v0,0(v1)
+			break;
+		case 8:
+		default:
+			g_object[g_objpos++]=0xA0620000; // sb          v0,0(v1)
+			break;
+	}
+	return 0;
+}
+
+char* dim_statement(){
+	char* err;
+	char b1;
+	int i;
+	int spos;
+	int stack;
+	while(1){
+		stack=0;
+		next_position();
+		i=get_var_number();
+		if (i<0) return ERR_SYNTAX;
+		if (g_source[g_srcpos]=='#') g_srcpos++;
+		next_position();
+		if (g_source[g_srcpos]!='(') return ERR_SYNTAX;
+		check_obj_space(1);
+		spos=g_objpos++;           // addiu       sp,sp,xxxx
+		do {
+			g_srcpos++;
+			err=get_value();
+			if (err) return err;
+			stack+=4;
+			check_obj_space(1);
+			g_object[g_objpos++]=0xAFA20000|stack; // sw          v0,8(sp)
+		} while (g_source[g_srcpos]==',');
+		if (g_source[g_srcpos]!=')') return ERR_SYNTAX;
+		g_srcpos++;
+		check_obj_space(3);
+		g_object[g_objpos++]=0x24040000|(i);       // addiu       a0,zero,xx
+		g_object[g_objpos++]=0x24050000|(stack/4); // addiu       a1,zero,xxxx
+		g_object[g_objpos++]=0x03A01025;           // or          v0,sp,zero
+		call_lib_code(LIB_DIM);
+		// Stack -/+
+		check_obj_space(1);
+		g_object[g_objpos++]=0x27BD0000|stack;     // addiu       sp,sp,xxxx
+		stack=(0-stack)&0x0000FFFF;
+		g_object[spos]=0x27BD0000|stack;           // addiu       sp,sp,xxxx
+		next_position();
+		if (g_source[g_srcpos]!=',') break;
+		g_srcpos++;
+	}
+	return 0;
+}
+
+char* label_statement(){
+	char* err;
+	char b1;
+	b1=g_source[g_srcpos];
+	if (b1<'A' || 'Z'<b1) return ERR_SYNTAX; // Number is not allowed here.
+	err=get_label();
+	if (err) return err;
+	// Check existing label with the same name here.
+	if (search_label(g_label)) {
+		// Error: duplicate labels
+		printstr("Label ");
+		printstr(resolve_label(g_label));
+		return ERR_MULTIPLE_LABEL;
+	}
+	check_obj_space(2);
+	g_object[g_objpos++]=0x3C160000|((g_label>>16)&0x0000FFFF); //lui s6,yyyy;
+	g_object[g_objpos++]=0x36D60000|(g_label&0x0000FFFF);       //ori s6,s6,zzzz;
+	return 0;
+}
+
+char* restore_statement(){
+	char* err;
+	// This statement is not valid in class file.
+	if (g_compiling_class) return ERR_INVALID_CLASS;
+	err=get_label();
+	if (err) return err;
+	if (g_label) {
+		// Constant label/number
+		// Use 32 bit mode also for values<65536
+		// This code will be replaced to code for v0 for pointer in linker.
+		check_obj_space(2);
+		g_object[g_objpos++]=0x3C020000|(g_label>>16);        // lui         v0,xxxx
+		g_object[g_objpos++]=0x34420000|(g_label&0x0000FFFF); // ori         v0,v0,xxxx
+	} else {
+		// Dynamic number
+		err=get_value();
+		if (err) return err;
+	}
+	call_lib_code(LIB_RESTORE);
+	return 0;
+}
+
+char* gosub_statement_sub(){
+	char* err;
+	err=get_label();
+	if (err) return err;
+	if (g_label) {
+		// Label/number is constant.
+		// Linker will change following codes later.
+		// Note that 0x0812xxxx and 0x0813xxxx are specific codes for these.
+		check_obj_space(7);
+		g_object[g_objpos++]=0x27BDFFFC;                            // addiu       sp,sp,-4
+		g_object[g_objpos++]=0x04130003;                            // bgezall     zero,label1
+		g_object[g_objpos++]=0xAEBD0000|ARGS_S5_SP;                 // sw          sp,-12(s5)
+		g_object[g_objpos++]=0x10000003;                            // beq         zero,zero,label2
+		g_object[g_objpos++]=0x08120000|((g_label>>16)&0x0000FFFF); // nop         
+		                                                            // label1:
+		g_object[g_objpos++]=0x08130000|(g_label&0x0000FFFF);       // j           xxxx
+		g_object[g_objpos++]=0xAFBF0004;                            // sw          ra,4(sp)
+		                                                            // label2:
+	} else {
+		// Label/number will be dynamically set when executing code.
+		err=get_value();
+		if (err) return err;
+		call_lib_code(LIB_LABEL);
+		check_obj_space(7);
+		g_object[g_objpos++]=0x27BDFFFC;            // addiu       sp,sp,-4
+		g_object[g_objpos++]=0x04130003;            // bgezall     zero,label1
+		g_object[g_objpos++]=0xAEBD0000|ARGS_S5_SP; // sw          sp,-12(s5)
+		g_object[g_objpos++]=0x10000003;            // beq         zero,zero,label2
+		g_object[g_objpos++]=0x00000000;            // nop         
+		                                            // label1:
+		g_object[g_objpos++]=0x00400008;            // jr          v0
+		g_object[g_objpos++]=0xAFBF0004;            // sw          ra,4(sp)
+		                                            // label2:
+	}
+	return 0;
+}
+
+char* gosub_statement(){
+	char* err;
+	int opos,spos,stack;
+	// Skip label first (see below)
+	opos=g_objpos;
+	spos=g_srcpos;
+	err=gosub_statement_sub();
+	if (err) return err;
+	next_position();
+	// Rewind object and construct argument-creating routine.
+	g_objpos=opos;
+	// Begin parameter(s) construction routine
+	g_object[g_objpos++]=0x8EA20000|ARGS_S5_V0_OBJ;           // lw          v0,-8(s5)
+	err=prepare_args_stack(',');
+	if (err) return err;
+	// Rewind source and construct GOSUB routine again.
+	opos=spos;
+	spos=g_srcpos;
+	g_srcpos=opos;
+	err=gosub_statement_sub();
+	if (err) return err;
+	// Remove stack
+	err=remove_args_stack();
+	if (err) return err;
+	// All done, go back to right source position
+	g_srcpos=spos;
+	return 0;
+}
+
+char* return_statement(){
+	char* err;
+	char b1;
+	next_position();
+	b1=g_source[g_srcpos];
+	if (0x20<b1 && b1!=':') {
+		// There is a return value.
+		err=get_stringFloatOrValue();
+		if (err) return err;
+	}
+	check_obj_space(4);
+	g_object[g_objpos++]=0x8EBD0000|ARGS_S5_SP; // lw          sp,-12(s5)
+	g_object[g_objpos++]=0x8FA30004;            // lw          v1,4(sp)
+	g_object[g_objpos++]=0x00600008;            // jr          v1
+	g_object[g_objpos++]=0x27BD0004;            // addiu       sp,sp,4
+	return 0;
+}
+
+char* goto_statement(){
+	char* err;
+	err=get_label();
+	if (err) return err;
+	if (g_label) {
+		// Label/number is constant.
+		// Linker will change following codes later.
+		// Note that 0x0810xxxx and 0x0811xxxx are specific codes for these.
+		check_obj_space(2);
+		g_object[g_objpos++]=0x08100000|((g_label>>16)&0x0000FFFF); // j xxxx
+		g_object[g_objpos++]=0x08110000|(g_label&0x0000FFFF);       // nop
+	} else {
+		// Label/number will be dynamically set when executing code.
+		err=get_value();
+		if (err) return err;
+		call_lib_code(LIB_LABEL);
+		check_obj_space(2);
+		g_object[g_objpos++]=0x00400008; // jr          v0
+		g_object[g_objpos++]=0x00000000; // nop
+	}
+	return 0;
+}
+
+char* if_statement(){
+	char* err;
+	int prevpos,bpos;
+	// Get value.
+	err=get_floatOrValue();
+	if (err) return err;
+	// Check "THEN"
+	if (!nextCodeIs("THEN")) return ERR_SYNTAX;
+	// Check if statement follows after THEN statement
+	next_position();
+	if (nextCodeIs("REM")) {
+		// If REM statement follows, skip comment words.
+		rem_statement();
+	}
+	if (g_source[g_srcpos]<0x20) {
+		// End of line.
+		// Use IF-THEN-ENDIF mode (multiple line mode)
+		check_obj_space(3);
+		g_object[g_objpos++]=0x30000000; // nop (see linker)
+		g_object[g_objpos++]=0x10400000; // beq         v0,zero,xxxx
+		g_object[g_objpos++]=0x30000000; // nop (see linker)
+		return 0;
+	}
+	// One line mode
+	// If $v0=0 then skip.
+	bpos=g_objpos;
+	check_obj_space(2);
+	g_object[g_objpos++]=0x10400000; // beq         v0,zero,xxxx
+	g_object[g_objpos++]=0x00000000; // nop
+	prevpos=g_srcpos;
+	if (statement()) {
+		// May be label
+		g_srcpos=prevpos;
+		err=goto_statement();
+		if (err) return err;
+	} else {
+		// Must be statement(s)
+		while(1) {
+			if (g_source[g_srcpos]!=':') break;
+			g_srcpos++;
+			err=statement();
+			if (err) return err;
+		}
+	}
+	// Check if "ELSE" exists.
+	if (!nextCodeIs("ELSE ")) {
+		// "ELSE" not found. This is the end of "IF" statement.
+		// Previous branch command must jump to this position.
+		g_object[bpos]=0x10400000|(g_objpos-bpos-1); // beq         v0,zero,xxxx	
+		return 0;
+	}
+	// Skip after ELSE if required.
+	check_obj_space(2);
+	g_object[g_objpos++]=0x10000000; // beq         zero,zero,xxxx
+	g_object[g_objpos++]=0x00000000; // nop
+	// Previous branch command must jump to this position.
+	g_object[bpos]=0x10400000|(g_objpos-bpos-1); // beq         v0,zero,xxxx	
+	bpos=g_objpos-2;
+	// Next statement is either label or general statement
+	prevpos=g_srcpos;
+	if (statement()) {
+		// May be label
+		g_srcpos=prevpos;
+		err=goto_statement();
+		if (err) return err;
+	} else {
+		// Must be statement(s)
+		while(1) {
+			if (g_source[g_srcpos]!=':') break;
+			g_srcpos++;
+			err=statement();
+			if (err) return err;
+		}
+	}
+	// Previous branch command must jump to this position.
+	g_object[bpos]=0x10000000|(g_objpos-bpos-1); // beq         zero,zero,xxxx	
+	return 0;
+}
+
+char* elseif_statement(void){
+	// Multiple line mode
+	char* err;
+	g_object[g_objpos++]=0x08160100; // breakif (see linker)
+	g_object[g_objpos++]=0x30008000; // nop (see linker)
+	// Get value.
+	err=get_floatOrValue();
+	if (err) return err;
+	// Check "THEN"
+	if (!nextCodeIs("THEN")) return ERR_SYNTAX;
+	// Check if statement follows after THEN statement
+	if (nextCodeIs("REM")) {
+		// If REM statement follows, skip comment words.
+		rem_statement();
+	}
+	if (0x20<=g_source[g_srcpos]) return ERR_SYNTAX;
+	// Statement didn't follow after THEM statement (that is correct).
+	g_object[g_objpos++]=0x10400000; // beq         v0,zero,xxxx
+	g_object[g_objpos++]=0x30000000; // nop (see linker)
+	return 0;
+	
+}
+
+char* else_statement(void){
+	// Multiple line mode
+	g_object[g_objpos++]=0x08160100; // breakif (see linker)
+	g_object[g_objpos++]=0x30008000; // nop (see linker)
+	g_object[g_objpos++]=0x30000000; // nop (see linker)
+	// Check if statement follows after THEN statement
+	if (nextCodeIs("REM")) {
+		// If REM statement follows, skip comment words.
+		rem_statement();
+	}
+	if (0x20<=g_source[g_srcpos]) return ERR_SYNTAX;
+	// Statement didn't follow after THEM statement (that is correct).
+	return 0;
+}
+
+char* endif_statement(void){
+	// Multiple line mode
+	g_object[g_objpos++]=0x30008000; // nop (see linker)
+	g_object[g_objpos++]=0x30008000; // nop (see linker)
+	// Check if statement follows after THEN statement
+	if (nextCodeIs("REM")) {
+		// If REM statement follows, skip comment words.
+		rem_statement();
+	}
+	if (0x20<=g_source[g_srcpos]) return ERR_SYNTAX;
+	// Statement didn't follow after THEM statement (that is correct).
+	return 0;
+}
+
+char* end_statement(void){
+	int i;
+	i=(int)&g_end_addr;
+	i-=g_gp;
+	check_obj_space(3);
+	g_object[g_objpos++]=0x8F820000|(i&0x0000FFFF);       // lw v0,xxxx(gp)
+	g_object[g_objpos++]=0x00400008;                      // jr v0
+	g_object[g_objpos++]=0x00000000;                      // nop
+	return 0;
+}
+
+char* let_dim_sub(int i){
+	char* err;
+	g_srcpos++;
+	err=get_value();
+	if (err) return err;
+	check_obj_space(4);
+	g_object[g_objpos++]=0x00021080;              // sll v0,v0,0x2
+	g_object[g_objpos++]=0x8FC30000|(i*4);        // lw    v1,xx(s8)
+	g_object[g_objpos++]=0x00621821;              // addu  v1,v1,v0
+	g_object[g_objpos++]=0xAFA30004;              // sw    v1,4(sp)
+	while(g_source[g_srcpos]==','){
+		g_srcpos++;
+		err=get_value();
+		if (err) return err;
+		check_obj_space(4);
+		g_object[g_objpos++]=0x00021080;          // sll v0,v0,0x2
+		g_object[g_objpos++]=0x8FA30004;          // lw    v1,4(sp)
+		g_object[g_objpos++]=0x8C630000;          // lw    v1,0(v1)
+		g_object[g_objpos++]=0x00621821;          // addu  v1,v1,v0
+		g_object[g_objpos++]=0xAFA30004;          // sw    v1,4(sp)
+	}
+	if (g_source[g_srcpos]!=')') return ERR_SYNTAX;
+	g_srcpos++;
+	return 0;
+};
+
+char* let_statement(){
+	char* err;
+	char b2,b3;
+	int i,spos,opos;
+	next_position();
+	i=get_var_number();
+	if (i<0) return ERR_SYNTAX;
+	b2=g_source[g_srcpos];
+	b3=g_source[g_srcpos+1];
+	if (b2=='#' && b3=='(') {
+		// Float dimension
+		g_srcpos++;
+		check_obj_space(1);
+		g_object[g_objpos++]=0x27BDFFFC;              // addiu sp,sp,-4
+		let_dim_sub(i);
+		next_position();
+		if (g_source[g_srcpos]!='=') return ERR_SYNTAX;
+		g_srcpos++;
+		err=get_float();
+		if (err) return err;
+		check_obj_space(3);
+		g_object[g_objpos++]=0x8FA30004;              // lw    v1,4(sp)
+		g_object[g_objpos++]=0x27BD0004;              // addiu sp,sp,4
+		g_object[g_objpos++]=0xAC620000;              // sw    v0,0(v1)
+		return 0;
+	} else if (b2=='#') {
+		// Float A-Z
+		g_srcpos++;
+		next_position();
+		if (g_source[g_srcpos]!='=') return ERR_SYNTAX;
+		g_srcpos++;
+		err=get_float();
+		if (err) return err;
+		check_obj_space(1);
+		g_object[g_objpos++]=0xAFC20000|(i*4);        // sw v0,xxx(s8)
+		return 0;
+	} else 	if (b2=='$') {
+		// String
+		g_srcpos++;
+		next_position();
+		if (g_source[g_srcpos]!='=') return ERR_SYNTAX;
+		g_srcpos++;
+		err=get_string();
+		if (err) return err;
+		check_obj_space(1);
+		g_object[g_objpos++]=0x24040000|(i);          //addiu       a0,zero,xx
+		call_lib_code(LIB_LETSTR);
+		return 0;
+	} else if (b2=='(') {
+		// Dimension
+		check_obj_space(1);
+		g_object[g_objpos++]=0x27BDFFFC;              // addiu sp,sp,-4
+		let_dim_sub(i);
+		if (g_source[g_srcpos]=='.') {
+			// This is an object. Determine the filed of this object.
+			// 4(sp) contains the address of dimension value
+			// The dimension value is the pointer to object
+			g_srcpos++;
+			check_obj_space(3);
+			g_object[g_objpos++]=0x8FA20004;          // lw    v0,4(sp)
+			g_object[g_objpos++]=0x8C420000;          // lw    v0,0(v0)
			g_object[g_objpos++]=0x27BD0004;          // addiu sp,sp,4
+			return let_object_field();
+		}
+		next_position();
+		if (g_source[g_srcpos]!='=') return ERR_SYNTAX;
+		g_srcpos++;
+		err=get_value();
+		if (err) return err;
+		check_obj_space(3);
+		g_object[g_objpos++]=0x8FA30004;              // lw    v1,4(sp)
+		g_object[g_objpos++]=0x27BD0004;              // addiu sp,sp,4
+		g_object[g_objpos++]=0xAC620000;              // sw    v0,0(v1)
+		return 0;
+	} else if (b2=='.') {
+		// Field of object
+		g_srcpos++;
+		check_obj_space(1);
+		g_object[g_objpos++]=0x8FC20000|(i*4);        // lw    v0,xx(s8)
+		return let_object_field();
+	} else {
+		// Integer A-Z
+		next_position();
+		if (g_source[g_srcpos]!='=') return ERR_SYNTAX;
+		g_srcpos++;
+		err=get_value();
+		if (err) return err;
+		check_obj_space(1);
+		g_object[g_objpos++]=0xAFC20000|(i*4);        // sw v0,xxx(s8)
+	}
+	return 0;
+}
+
+char* print_statement_main(enum libs lib_printstr, enum libs lib_string){
+	char* err;
+	char b1;
+	int i;
+	int status=0;// 1:',' 2:';' 0:none
+	while(1){
+		next_position();
+		if (endOfStatement()) break;
+		if (!strncmp(g_source+g_srcpos,"ELSE "  ,5)) break;	
+		err=get_stringFloatOrValue();
+		if (err) return err;
+		switch(g_lastvar){
+			case VAR_INTEGER:
+				// Use DEC$() function.
+				call_lib_code(LIB_DEC);
+				break;
+			case VAR_FLOAT:
+				// Use FLOAT$() function.
+				check_obj_space(2);
+				g_object[g_objpos++]=0x00022021; //addu        a0,zero,v0
+				g_object[g_objpos++]=0x34020000; //ori         v0,zero,0x0000
+				call_lib_code(LIB_SPRINTF);
+				break;
+			case VAR_STRING:
+			default:
+				break;
+		}
+		// Call printstr() function
+		// First argument is the pointer to string
+		call_lib_code(lib_printstr);
+		next_position();
+		b1=g_source[g_srcpos];
+		if (b1==',') {
+			status=1;
+			g_srcpos++;
+			// Call lib_string() function for comma (,)
+			check_obj_space(1);
+			g_object[g_objpos++]=0x34020001;                      // ori   v0,zero,1
+			call_lib_code(lib_string);
+		} else if (b1==';') {
+			status=2;
+			g_srcpos++;
+		} else {
+			status=0;
+		}
+	}
+	if (status==0) {
+		// Call lib_string() function for CR (\n)
+		check_obj_space(1);
+		g_object[g_objpos++]=0x34020000;                      // ori   v0,zero,0
+		call_lib_code(lib_string);
+	}
+	return 0;
+}
+
+char* break_statement(){
+	check_obj_space(2);
+	g_object[g_objpos++]=0x08160000; // j           xxxx     (See link() function)
+	g_object[g_objpos++]=0x00000000; // nop
+	return 0;
+}
+
+char* continue_statement(){
+	check_obj_space(2);
+	g_object[g_objpos++]=0x08160008; // j           xxxx     (See link() function)
+	g_object[g_objpos++]=0x00000000; // nop
+	return 0;
+}
+
+char* for_statement(){
+	char* err;
+//	char b1;
+	int i;
+	int prepos=g_srcpos;
+	// Initialization of variable
+//	next_position();
+//	b1=g_source[g_srcpos];
+	i=get_var_number();
+//	if (b1<'A' || 'Z'<b1) return ERR_SYNTAX;
+	if (i<0) return ERR_SYNTAX;
+	g_srcpos=prepos;
+	err=let_statement();
+	if (err) return err;
+	// Check if "TO" exists
+	if (!nextCodeIs("TO ")) return ERR_SYNTAX;
+	err=get_value();
+	if (err) return err;
+	// Usage of stack:
+	//   12(sp): "TO" value
+	//    8(sp): "STEP" value
+	//    4(sp): Address to return to in "NEXT" statement.
+	// Store "TO" value in stack
+	check_obj_space(2);
+	g_object[g_objpos++]=0x0820FFF4; // addiu sp,sp,-12 (see linker)
+	g_object[g_objpos++]=0xAFA2000C; // sw v0,12(sp)
+	// Check if "STEP" exists
+	g_valueisconst=1;
+	if (nextCodeIs("STEP ")) {
+		// "STEP" exists. Get value
+		err=get_value();
+		if (err) return err;
+	} else {
+		// "STEP" not exist. Use "1".	
+		check_obj_space(1);
+		g_object[g_objpos++]=0x24020001; // addiu v0,zero,1
+		g_intconst=1;
+	}
+	check_obj_space(14);
+	g_object[g_objpos++]=0xAFA20008;              // sw          v0,8(sp)       (STEP value)
+	g_object[g_objpos++]=0x04130004;              // bgezall     zero,check
+//	g_object[g_objpos++]=0x8FC40000|((b1-'A')*4); // lw          a0,xx(s8)      (current var value)
+	g_object[g_objpos++]=0x8FC40000|(i*4);        // lw          a0,xx(s8)      (current var value)
+	// After executing "NEXT" statement, process reaches following line.
+	// Update variable value by adding STEP value
+	// Note that STEP value is loaded onto $v0 in NEXT statement
+//	g_object[g_objpos++]=0x8FC40000|((b1-'A')*4); // lw          a0,xx(s8)      (current var value)
+	g_object[g_objpos++]=0x8FC40000|(i*4);        // lw          a0,xx(s8)      (current var value)
+	g_object[g_objpos++]=0x00822021;              // addu        a0,a0,v0
+//	g_object[g_objpos++]=0xAFC40000|((b1-'A')*4); // sw          a0,xx(s8)      (new var value)
+	g_object[g_objpos++]=0xAFC40000|(i*4);        // sw          a0,xx(s8)      (new var value)
+	// Value-checking routine and storing ra in stack
+	                                              // check:
+	g_object[g_objpos++]=0x8FA3000C;              // lw          v1,12(sp)      (TO value)
+	g_object[g_objpos++]=0x00641823;              // subu        v1,v1,a0
+	g_object[g_objpos++]=0x04420001;              // bltzl       v0,negative
+	g_object[g_objpos++]=0x00031823;              // subu        v1,zero,v1
+	                                              // negative:
+	g_object[g_objpos++]=0x04610003;              // bgez        v1,continue
+	g_object[g_objpos++]=0xAFBF0004;              // sw          ra,4(sp)
+	break_statement();                            // (2 words)
+	                                              // continue:
+	return 0;
+}
+
+char* next_statement(){
+	// Return to address stored in 4($sp)
+	// while set $v0 to 8($sp) (see for_statement)
+	// Following assembly must be 4 words.
+	// If the number of words will be changed, link.c must be reviced for CONTINUE statement.
+	check_obj_space(4);
+	g_object[g_objpos++]=0x8FBF0004; // lw          ra,4(sp)
+	g_object[g_objpos++]=0x03E00008; // jr          ra
+	g_object[g_objpos++]=0x8FA20008; // lw          v0,8(sp)       (STEP value)
+	g_object[g_objpos++]=0x0830000C; // addiu       sp,sp,12 (see linker)
+	return 0;
+}
+
+char* do_statement(){
+	char* err;
+	// Usage of stack:
+	//    4(sp): Address to return to in "DO" statement.
+	check_obj_space(3);
+	g_object[g_objpos++]=0x04130001;//   bgezall     zero,label1:
+	g_object[g_objpos++]=0x0822FFFC;//   addiu       sp,sp,-4 (see linker)
+	                                //   label1:
+	g_object[g_objpos++]=0xAFBF0004;//   sw          ra,4(sp)
+	if (nextCodeIs("WHILE ")) {
+		// DO WHILE
+		err=get_floatOrValue();
+		if (err) return err;
+		check_obj_space(2);
+		g_object[g_objpos++]=0x14400003; // bne         v0,zero,labe2
+		g_object[g_objpos++]=0x00000000; // nop
+		return break_statement();        // (2 words)
+			                             // label2:
+
+	} else if (nextCodeIs("UNTIL ")) {
+		// DO UNTIL
+		err=get_floatOrValue();
+		if (err) return err;
+		check_obj_space(2);
+		g_object[g_objpos++]=0x10400003; // beq         v0,zero,label2
+		g_object[g_objpos++]=0x00000000; // nop
+		return break_statement();        // (2 words)
+			                             // label2:
+	} else {
+		// DO statement without WHILE/UNTIL
+		return 0;
+	}
+}
+
+char* loop_statement(){
+	char* err;
+	int opos;
+	opos=g_objpos;
+	if (nextCodeIs("WHILE ")) {
+		// LOOP WHILE
+		err=get_floatOrValue();
+		if (err) return err;
+		check_obj_space(1);
+		g_object[g_objpos++]=0x10400003; // beq         v0,zero,label1
+	} else if (nextCodeIs("UNTIL ")) {
+		// LOOP UNTIL
+		err=get_floatOrValue();
+		if (err) return err;
+		check_obj_space(1);
+		g_object[g_objpos++]=0x14400003; // bne         v0,zero,label
+	} else {
+		// LOOP statement without WHILE/UNTIL
+	}
+	check_obj_space(4);
+	g_object[g_objpos++]=0x8FBF0004;      // lw          ra,4(sp)
+	g_object[g_objpos++]=0x03E00008;      // jr          ra
+	opos=g_objpos+1-opos;
+	g_object[g_objpos++]=0x3000F000|opos; // nop                 (See linker, used for CONTINUE statement)
+	                                      // label1:
+	g_object[g_objpos++]=0x08320004;      // addiu       sp,sp,4       (See link() function)
+	return 0;
+}
+
+char* while_statement(){
+	char* err;
+	check_obj_space(3);
+	g_object[g_objpos++]=0x04130001; // bgezall     zero,label1:
+	g_object[g_objpos++]=0x0821FFFC; // addiu       sp,sp,-4 (see linker)
+	                                 // label1:
+	g_object[g_objpos++]=0xAFBF0004; // sw          ra,4(sp)
+	err=get_floatOrValue();
+	if (err) return err;
+	check_obj_space(2);
+	g_object[g_objpos++]=0x14400003; // bne         v0,zero,label2
+	g_object[g_objpos++]=0x00000000; // nop
+	return break_statement();        // (2 words)
+		                             // label2:
+}
+
+char* wend_statement(){
+	check_obj_space(4);
+	g_object[g_objpos++]=0x8FBF0004; // lw          ra,4(sp)
+	g_object[g_objpos++]=0x03E00008; // jr          ra
+	g_object[g_objpos++]=0x3000F003; // nop                 (See linker, used for CONTINUE statement)
+	                                 // label1:
+	g_object[g_objpos++]=0x08310004; // addiu       sp,sp,4 (See link() function)
+	return 0;
+}
+
+char* param4_statement(enum libs lib){
+	// lib is either LIB_PALETTE or LIB_GPALETTE
+	// PALETTE N,R,G,B
+	char* err;
+	// Get N
+	err=get_value();
+	if (err) return err;
+	if (g_source[g_srcpos]!=',') return ERR_SYNTAX;
+	g_srcpos++;
+	check_obj_space(2);
+	g_object[g_objpos++]=0x27BDFFF4; // addiu       sp,sp,-12
+	g_object[g_objpos++]=0xAFA20004; // sw          v0,4(sp)
+	// Get R
+	err=get_value();
+	if (err) return err;
+	if (g_source[g_srcpos]!=',') return ERR_SYNTAX;
+	g_srcpos++;
+	check_obj_space(1);
+	g_object[g_objpos++]=0xAFA20008; // sw          v0,8(sp)
+	// Get G
+	err=get_value();
+	if (err) return err;
+	if (g_source[g_srcpos]!=',') return ERR_SYNTAX;
+	g_srcpos++;
+	check_obj_space(1);
+	g_object[g_objpos++]=0xAFA2000C; // sw          v0,12(sp)
+	// Get B
+	err=get_value();
+	if (err) return err;
+	call_lib_code(lib);
+	check_obj_space(1);
+	g_object[g_objpos++]=0x27BD000C; // addiu       sp,sp,12
+	return 0;
+}
+
+char* param3_statement(enum libs lib){
+	char* err;
+	// Get 1st parameter
+	err=get_value();
+	if (err) return err;
+	if (g_source[g_srcpos]!=',') return ERR_SYNTAX;
+	g_srcpos++;
+	check_obj_space(2);
+	g_object[g_objpos++]=0x27BDFFF8; // addiu       sp,sp,-8
+	g_object[g_objpos++]=0xAFA20004; // sw          v0,4(sp)
+	// Get 2nd parameter
+	err=get_value();
+	if (err) return err;
+	if (g_source[g_srcpos]!=',') return ERR_SYNTAX;
+	g_srcpos++;
+	check_obj_space(1);
+	g_object[g_objpos++]=0xAFA20008; // sw          v0,8(sp)
+	// Get 3rd parameter
+	err=get_value();
+	if (err) return err;
+	call_lib_code(lib);
+	check_obj_space(1);
+	g_object[g_objpos++]=0x27BD0008; // addiu       sp,sp,8
+	return 0;
+}
+
+char* bgcolor_statement(){
+	// BGCOLOR R,G,B
+	return param3_statement(LIB_BGCOLOR);
+}
+
+char* pcg_statement(){
+	// PCG ASCII,D1,D2
+	return param3_statement(LIB_PCG);
+}
+
+char* usepcg_statement(){
+	int objpos=g_objpos;
+	if (get_value()) {
+		// Getting integer failed.
+		// It supporsed to be not parameter
+		// and same as parameter=1.
+		g_objpos=objpos;
+		check_obj_space(1);
+		g_object[g_objpos++]=0x34020001; //ori         v0,zero,0x01
+	}
+	call_lib_code(LIB_USEPCG);
+	return 0;
+}
+
+char* usegraphic_statement(){
+	int objpos=g_objpos;
+	if (get_value()) {
+		// Getting integer failed.
+		// It supporsed to be not parameter
+		// and same as parameter=1.
+		g_objpos=objpos;
+		check_obj_space(1);
+		g_object[g_objpos++]=0x34020001; //ori         v0,zero,0x01
+	}
+	call_lib_code(LIB_USEGRAPHIC);
+	return 0;
+}
+
+char* cls_statement(){
+	call_lib_code(LIB_CLS);
+	return 0;
+}
+
+char* gcls_statement(){
+	call_lib_code(LIB_GCLS);
+	return 0;
+}
+
+char* color_statement(){
+	char* err;
+	err=get_value();
+	if (err) return err;
+	call_lib_code(LIB_COLOR);
+	return 0;
+}
+
+char* gcolor_statement(){
+	char* err;
+	err=get_value();
+	if (err) return err;
+	call_lib_code(LIB_GCOLOR);
+	return 0;
+}
+
+char* param2_statement(enum libs lib){
+	char* err;
+	// Get 1st
+	err=get_value();
+	if (err) return err;
+	if (g_source[g_srcpos]!=',') return ERR_SYNTAX;
+	g_srcpos++;
+	check_obj_space(2);
+	g_object[g_objpos++]=0x27BDFFFC; // addiu       sp,sp,-4
+	g_object[g_objpos++]=0xAFA20004; // sw          v0,4(sp)
+	// Get 2nd
+	err=get_value();
+	if (err) return err;
+	call_lib_code(lib);
+	check_obj_space(1);
+	g_object[g_objpos++]=0x27BD0004; // addiu       sp,sp,4
+	return 0;
+}
+
+char* system_statement(){
+	// SYSTEM X,Y
+	char* err;
+	// Get 1st
+	err=get_value();
+	if (err) return err;
+	if (g_source[g_srcpos]!=',') return ERR_SYNTAX;
+	g_srcpos++;
+	check_obj_space(2);
+	g_object[g_objpos++]=0x27BDFFFC; // addiu       sp,sp,-4
+	g_object[g_objpos++]=0xAFA20004; // sw          v0,4(sp)
+	// Get 2nd
+	err=get_value();
+	if (err) return err;
+	check_obj_space(2);
+	g_object[g_objpos++]=0x8FA40004; // lw          a0,4(sp)
+	g_object[g_objpos++]=0x27BD0004; // addiu       sp,sp,4
+	call_lib_code(LIB_SYSTEM);
+	return 0;
+}
+
+char* cursor_statement(){
+	// CURSOR X,Y
+	return param2_statement(LIB_CURSOR);
+}
+
+char* scroll_statement(){
+	// SCROLL X,Y
+	return param2_statement(LIB_SCROLL);
+}
+
+char* drawcount_statement(){
+	char* err;
+	err=get_value();
+	if (err) return err;
+	call_lib_code(LIB_SETDRAWCOUNT);
+	return 0;
+}
+
+char* wait_statement(){
+	char* err;
+	err=get_value();
+	if (err) return err;
+	call_lib_code(LIB_WAIT);
+	return 0;
+}
+
+char* width_statement(){
+	char* err;
+	err=get_value();
+	if (err) return err;
+	call_lib_code(LIB_WIDTH);
+	return 0;
+}
+
+char* var_statement_sub(int a0, int a1){
+	// Construct parameter-setting scripts
+	if (a0&0xffff0000) {
+		check_obj_space(1);
+		g_object[g_objpos++]=0x3C040000|(a0>>16);        // lui         a0,XXXX
+		if (a0&0x0000ffff) {
+			check_obj_space(1);
+			g_object[g_objpos++]=0x34840000|(a0&0xffff); // ori         a0,a0,XXXX
+		}
+	} else if (a0&0x0000ffff) {
+		check_obj_space(1);
+		g_object[g_objpos++]=0x34040000|(a0&0xffff);     // ori         a0,zero,xxxx
+	}
+	if (a1&0xffff0000) {
+		check_obj_space(1);
+		g_object[g_objpos++]=0x3C050000|(a1>>16);        // lui         a1,XXXX
+		if (a1&0x0000ffff) {
+			check_obj_space(1);
+			g_object[g_objpos++]=0x34A50000|(a1&0xffff); // ori         a1,a1,XXXX
+		}
+	} else if (a1&0x0000ffff) {
+		check_obj_space(1);
+		g_object[g_objpos++]=0x34050000|(a1&0xffff);     // ori         a1,zero,xxxx
+	} else if (a0&0xff000000) {
+		// # of variables is 4. Reset $a1 to let lib_var() know that there is no more variables to store.
+		check_obj_space(1);
+		g_object[g_objpos++]=0x34050000;                 // ori         a1,zero,0
+	}
+	return 0;
+}
+
+char* var_statement(){
+	char* err;
+	int i,j,a0,a1;
+	static int prevpos;
+	short stack;
+	do {
+		// For stack, 4 bytes are used for return address,
+		// 4 bytes are used in lib_var(),
+		// and additinal bytes are used for storing variable values.
+		stack=8;
+		a0=a1=0;
+		for (i=0;i<8;i++){
+			// Determine the variable number from source code
+			j=get_var_number();
+			if (j<0) return ERR_SYNTAX;
+			stack+=4;
+			// Create parameters in $a0, or $a1
+			if (i<4) {
+				a0=(a0<<8)|(j+1);
+			} else {
+				a1=(a1<<8)|(j+1);
+			}
+			// Check remaining variable(s) 
+			if (g_source[g_srcpos]=='#' || g_source[g_srcpos]=='$') g_srcpos++;
+			next_position();
+			if (g_source[g_srcpos]!=',') break;
+			g_srcpos++;
+		}
+		// Jump to push routine, first
+		check_obj_space(2);
+		prevpos=g_objpos;
+		g_object[g_objpos++]=0x04130000;                    // bgezall     zero,label1
+		g_object[g_objpos++]=0x27BD0000|((0-stack)&0xffff); // addiu       sp,sp,-xx
+		// Process will be here after RETURN statement
+		// Pop routine
+		err=var_statement_sub(a0,a1);                       // Prepare a0, and a1
+		if (err) return err;
+		call_lib_code(LIB_VAR_POP);
+		// Restore stack and return
+		check_obj_space(3);
+		g_object[g_objpos++]=0x8FA30000|stack;              // lw          v1,xx(sp)
+		g_object[g_objpos++]=0x00600008;                    // jr          v1
+		g_object[g_objpos++]=0x27BD0000|stack;              // addiu       sp,sp,xx
+		// Push rotine
+		g_object[prevpos]|=g_objpos-prevpos-1;              // label1:
+		check_obj_space(1);
+		g_object[g_objpos++]=0xAFBF0004;                    // sw          ra,4(sp)
+		err=var_statement_sub(a0,a1);                       // Prepare a0, and a1
+		if (err) return err;
+		call_lib_code(LIB_VAR_PUSH);
+
+	} while (g_source[g_srcpos-1]==',');
+	// Renew sp stored in s5 stack.
+	check_obj_space(1);
+	g_object[g_objpos++]=0xAEBD0000|ARGS_S5_SP; // sw          sp,-12(s5)
+	return 0;
+}
+
+
+char* graphic_statement(enum functions func){
+	/*
+		PSET X1,Y1[,C]
+		LINE X1,Y1,X2,Y2[,C]
+		BOXFILL X1,Y1,X2,Y2[,C]
+		CIRCLE X1,Y1,R[,C]
+		CIRCLEFILL X1,Y1,R[,C]
+		GPRINT X1,Y1,C,BC,S$
+		PUTBMP X1,Y1,M,N,BMP
+		4(sp): X1
+		8(sp): Y1
+		12(sp): X2/R/M
+		16(sp): Y2/N
+		v0: C/S$/BMP
+	*/
+	char* err;
+	int spos;
+	int paramnum;
+	switch(func){
+		case FUNC_PSET:// X1,Y1[,C]
+		case FUNC_GCOLOR:// X1,Y1
+		case FUNC_POINT:// X1,Y1
+			paramnum=2;
+			break;
+		case FUNC_CIRCLE:// X1,Y1,R[,C]
+		case FUNC_CIRCLEFILL:// X1,Y1,R[,C]
+			paramnum=3;
+			break;
+		case FUNC_LINE:// X1,Y1,X2,Y2[,C]
+		case FUNC_BOXFILL:// X1,Y1,X2,Y2[,C]
+			paramnum=4;
+			break;
+		case FUNC_GPRINT:// X1,Y1,C,BC,S$
+		case FUNC_PUTBMP:// X1,Y1,M,N,BMP
+			paramnum=5;
+			break;
+		default:
+			return ERR_UNKNOWN;
+	}
+
+	next_position();
+	if (g_source[g_srcpos]==',') {
+		// X1 and Y1 is omitted. Set 0x80000000 for both.
+		check_obj_space(4);
+		g_object[g_objpos++]=0x27BDFFF0;              // addiu       sp,sp,-16
+		g_object[g_objpos++]=0x3C028000;              // lui         v0,0x0080
+		g_object[g_objpos++]=0xAFA20004;              // sw          v0,4(sp)
+		g_object[g_objpos++]=0xAFA20008;              // sw          v0,8(sp)
+	} else {
+		// X1
+		err=get_value();
+		if (err) return err;
+		check_obj_space(2);
+		g_object[g_objpos++]=0x27BDFFF0;              // addiu       sp,sp,-16
+		g_object[g_objpos++]=0xAFA20004;              // sw          v0,4(sp)
+		// Y1
+		if (g_source[g_srcpos]!=',') return ERR_SYNTAX;
+		g_srcpos++;
+		err=get_value();
+		if (err) return err;
+		check_obj_space(1);
+		g_object[g_objpos++]=0xAFA20008;              // sw          v0,8(sp)
+	}
+	if (2<paramnum) {
+		// X2, R, or M
+		if (g_source[g_srcpos]!=',') return ERR_SYNTAX;
+		g_srcpos++;
+		err=get_value();
+		if (err) return err;
+		check_obj_space(1);
+		g_object[g_objpos++]=0xAFA2000C;          // sw          v0,12(sp)
+		if (3<paramnum) {
+			// Y2, BC, or N
+			if (g_source[g_srcpos]!=',') return ERR_SYNTAX;
+			g_srcpos++;
+			err=get_value();
+			if (err) return err;
+			check_obj_space(1);
+			g_object[g_objpos++]=0xAFA20010;      // sw          v0,16(sp)
+		}
+	}
+	if (func==FUNC_GPRINT) {
+		// S$
+		if (g_source[g_srcpos]!=',') return ERR_SYNTAX;
+		g_srcpos++;
+		err=get_string();
+		if (err) return err;
+	} else if (func==FUNC_PUTBMP) {
+		// BMP
+		if (g_source[g_srcpos]!=',') return ERR_SYNTAX;
+		g_srcpos++;
+		spos=g_srcpos;
+		err=get_label();
+		if (g_label && !err) {
+			if (search_var_name(g_label)!=-1) {
+				// This is a long var name.
+				g_label=0;
+				g_srcpos=spos;
+			}
+		}
+		if (g_label && !err) {
+			// Label/number is constant.
+			// Linker will change following codes later.
+			// Note that 0x0814xxxx and 0x0815xxxx are specific codes for these.
+			check_obj_space(2);
+			g_object[g_objpos++]=0x08140000|((g_label>>16)&0x0000FFFF); // lui   v0,xxxx
+			g_object[g_objpos++]=0x08150000|(g_label&0x0000FFFF);       // ori v0,v0,xxxx
+			// Change func to FUNC_PUTBMP2 (label mode).
+			func=FUNC_PUTBMP2;
+		} else {
+			err=get_value();
+			if (err) return err;
+		}
+	} else {
+		// [,C]
+		if (g_source[g_srcpos]==',') {
+			g_srcpos++;
+			err=get_value();
+			if (err) return err;
+		} else {
+			// If C is omitted, use -1.
+			check_obj_space(1);
+			g_object[g_objpos++]=0x2402FFFF;      // addiu       v0,zero,-1
+		}
+	}
+	// Call library
+	call_lib_code(LIB_GRAPHIC | func);
+	// Restore stack pointer
+	check_obj_space(1);
+	g_object[g_objpos++]=0x27BD0010;              // addiu       sp,sp,16
+	return 0;
+}
+
+char* fopen_statement_main(enum functions func){
+	// func is either FUNC_FOPENST or FUNC_FOPEN
+	char* err;
+	// Get 1st
+	err=get_string();
+	if (err) return err;
+	if (g_source[g_srcpos]!=',') return ERR_SYNTAX;
+	g_srcpos++;
+	check_obj_space(2);
+	g_object[g_objpos++]=0x27BDFFF8; // addiu       sp,sp,-8
+	g_object[g_objpos++]=0xAFA20004; // sw          v0,4(sp)
+	// Get 2nd
+	err=get_string();
+	if (err) return err;
+	check_obj_space(1);
+	g_object[g_objpos++]=0xAFA20008; // sw          v0,8(sp)
+	// Get 3rd
+	if (g_source[g_srcpos]==',') {
+		g_srcpos++;
+		err=get_value();
+		if (err) return err;
+	} else {
+		// If 3rd parameter is omitted, use 0.
+		check_obj_space(1);
+		g_object[g_objpos++]=0x24020000;      // addiu       v0,zero,0
+	}
+	call_lib_code(LIB_FILE | func);
+	check_obj_space(1);
+	g_object[g_objpos++]=0x27BD0008; // addiu       sp,sp,8
+	return 0;
+}
+
+char* file_statement(){
+	char* err;
+	err=get_value();
+	if (err) return err;
+	call_lib_code(LIB_FILE | FUNC_FILE);
+	return 0;
+}
+
+char* fclose_statement(){
+	char* err;
+	int orgpos=g_srcpos;
+	if (endOfStatement()) {
+		// If no argument, use 0
+		check_obj_space(1);
+		g_object[g_objpos++]=0x24020000;      // addiu       v0,zero,0
+	} else {
+		err=get_value();
+		if (err) return err;
+	}
+	call_lib_code(LIB_FILE | FUNC_FCLOSE);
+	return 0;
+}
+
+char* fget_statement(){
+	return param2_statement(LIB_FILE | FUNC_FGET);
+}
+
+char* fput_statement(){
+	return param2_statement(LIB_FILE | FUNC_FPUT);
+}
+
+char* fseek_statement(){
+	char* err;
+	err=get_value();
+	if (err) return err;
+	call_lib_code(LIB_FILE | FUNC_FSEEK);
+	return 0;
+}
+
+char* fputc_statement(){
+	char* err;
+	err=get_value();
+	if (err) return err;
+	call_lib_code(LIB_FILE | FUNC_FPUTC);
+	return 0;
+}
+
+char* fremove_statement(){
+	char* err;
+	err=get_string();
+	if (err) return err;
+	call_lib_code(LIB_FILE | FUNC_FREMOVE);
+	return 0;
+}
+
+char* usevar_statement(){
+	char* err;
+	int i;
+	do {
+		next_position();
+		i=check_var_name();
+		if (i<65536) return ERR_SYNTAX;
+		err=register_var_name(i);
+		if (err) return err;
+		if (g_source[g_srcpos]=='#' || g_source[g_srcpos]=='$') g_srcpos++;
+		next_position();
+		if (g_source[g_srcpos]==',') {
+			g_srcpos++;
+		} else {
+			break;
+		}
+	} while(1);
+	return 0;
+}
+
+char* playwave_statement(){
+	char* err;
+	err=get_string();
+	if (err) return err;
+	check_obj_space(2);
+	g_object[g_objpos++]=0x27BDFFFC; // addiu       sp,sp,-4
+	g_object[g_objpos++]=0xAFA20004; // sw          v0,4(sp)
+	if (g_source[g_srcpos]==',') {
+		g_srcpos++;
+		// Get 2nd
+		err=get_value();
+		if (err) return err;
+	} else {
+		// If 2rd parameter is omitted, use 0.
+		check_obj_space(1);
+		g_object[g_objpos++]=0x24020000;      // addiu       v0,zero,0
+	}
+	call_lib_code(LIB_PLAYWAVE);
+	check_obj_space(1);
+	g_object[g_objpos++]=0x27BD0004; // addiu       sp,sp,4
+	return 0;
+}
+
+char* useclass_statement(){
+	char* err;
+	int i;
+	int* cmpdata;
+	do {
+		next_position();
+		i=check_var_name();
+		if (i<65536) return ERR_SYNTAX;
+		// Check if the class already exists
+		cmpdata_reset();
+		while(cmpdata=cmpdata_find(CMPDATA_CLASS)){
+			if (cmpdata[1]==i) {
+				// The class was already defined.
+				i=0;
+				break;
+			}
+		}
+		if (i) {
+			// Remove a objects before USECLASS statement
+			g_objpos=0;
+			// Insert a NOP assembly. This will be replaced by jump statement.
+			check_obj_space(1);
+			g_object[g_objpos++]=0x00000000; // nop
+			// Load new file to define class statement.
+			g_class=i;
+			return ERR_COMPILE_CLASS;
+		}
+		if (g_source[g_srcpos]==',') {
+			g_srcpos++;
+		} else {
+			break;
+		}
+	} while(1);
+	return 0;
+}
+
+char* setdir_statement(){
+	char* err;
+	err=get_string();
+	if (err) return err;
+	call_lib_code(LIB_SETDIR);
+	return 0;
+}
+
+char* option_statement(){
+	while(1){
+		next_position();
+		if (nextCodeIs("NOLINENUM")) {
+			g_nolinenum=1;
+		} else {
+			return ERR_SYNTAX;
+		}
+		next_position();
+		if (g_source[g_srcpos]==',') {
+			g_srcpos++;
+		} else {
+			break;
+		}
+	}
+	return 0;
+}
+
+char* idle_statement(){
+	check_obj_space(2);
+	g_object[g_objpos++]=0x42000020; // wait
+	return 0;	
+}
+
+#ifdef __DEBUG
+	char* debug_statement(){
+		call_lib_code(LIB_DEBUG);
+		return 0;
+	}
+#endif
+
+// Aliases follow
+
+char* poke_statement(){
+	return poke_statement_sub(8);
+}
+
+char* poke16_statement(){
+	return poke_statement_sub(16);
+}
+
+char* poke32_statement(){
+	return poke_statement_sub(32);
+}
+
+char* palette_statement(){
+	return param4_statement(LIB_PALETTE);
+}
+
+char* gpalette_statement(){
+	return param4_statement(LIB_GPALETTE);
+}
+
+char* print_statement(){
+	return print_statement_main(LIB_PRINTSTR,LIB_STRING);
+}
+
+char* pset_statement(){
+	return graphic_statement(FUNC_PSET);
+}
+
+char* line_statement(){
+	return graphic_statement(FUNC_LINE);
+}
+
+char* boxfill_statement(){
+	return graphic_statement(FUNC_BOXFILL);
+}
+
+char* circle_statement(){
+	return graphic_statement(FUNC_CIRCLE);
+}
+
+char* circlefill_statement(){
+	return graphic_statement(FUNC_CIRCLEFILL);
+}
+
+char* gprint_statement(){
+	return graphic_statement(FUNC_GPRINT);
+}
+
+char* putbmp_statement(){
+	return graphic_statement(FUNC_PUTBMP);
+}
+
+char* point_statement(){
+	return graphic_statement(FUNC_POINT);
+}
+
+char* fopen_statement(){
+	return fopen_statement_main(FUNC_FOPENST);
+}
+
+char* fprint_statement(){
+	return print_statement_main(LIB_FILE | FUNC_FPRINTSTR,LIB_FILE | FUNC_FSTRING);
+}
+
+static const void* statement_list[]={
+	"REM",rem_statement,
+	"SOUND ",sound_statement,
+	"MUSIC ",music_statement,
+	"DRAWCOUNT ",drawcount_statement,
+	"CURSOR ",cursor_statement,
+	"PALETTE ",palette_statement,
+	"GPALETTE ",gpalette_statement,
+	"BGCOLOR ",bgcolor_statement,
+	"CLS",cls_statement,
+	"GCLS",gcls_statement,
+	"COLOR ",color_statement,
+	"GCOLOR ",gcolor_statement,
+	"RESTORE ",restore_statement,
+	"DATA ",data_statement,
+	"CDATA ",cdata_statement,
+	"LABEL ",label_statement,
+	"DIM ",dim_statement,
+	"CLEAR",clear_statement,
+	"PRINT",print_statement,
+	"IF ",if_statement,
+	"ELSEIF ",elseif_statement,
+	"ELSE",else_statement,
+	"ENDIF",endif_statement,
+	"END",end_statement,
+	"EXEC ",exec_statement,
+	"GOTO ",goto_statement,
+	"GOSUB ",gosub_statement,
+	"RETURN",return_statement,
+	"POKE ",poke_statement,
+	"POKE16 ",poke16_statement,
+	"POKE32 ",poke32_statement,
+	"FOR ",for_statement,
+	"NEXT",next_statement,
+	"LET ",let_statement,
+	"PCG ",pcg_statement,
+	"USEPCG",usepcg_statement,
+	"SCROLL ",scroll_statement,
+	"WAIT ",wait_statement,
+	"USEGRAPHIC",usegraphic_statement,
+	"PSET ",pset_statement,
+	"LINE ",line_statement,
+	"BOXFILL ",boxfill_statement,
+	"CIRCLE ",circle_statement,
+	"CIRCLEFILL ",circlefill_statement,
+	"GPRINT ",gprint_statement,
+	"PUTBMP ",putbmp_statement,
+	"POINT ",point_statement,
+	"VAR ",var_statement,
+	"DO",do_statement,
+	"LOOP",loop_statement,
+	"WHILE ",while_statement,
+	"WEND",wend_statement,
+	"BREAK",break_statement,
+	"CONTINUE",continue_statement,
+	"SYSTEM",system_statement,
+	"WIDTH ",width_statement,
+	"FOPEN ",fopen_statement,
+	"FILE ",file_statement,
+	"FCLOSE",fclose_statement,
+	"FPRINT ",fprint_statement,
+	"FGET ",fget_statement,
+	"FPUT ",fput_statement,
+	"FPUTC ",fputc_statement,
+	"FSEEK ",fseek_statement,
+	"FREMOVE ",fremove_statement,
+	"USEVAR ",usevar_statement,
+	"PLAYWAVE ",playwave_statement,
+	"USECLASS ",useclass_statement,
+	"FIELD ",field_statement,
+	"METHOD ",method_statement,
+	"DELETE ",delete_statement,
+	"CALL ",call_statement,
+	"STATIC ",static_statement,
+	"SETDIR ",setdir_statement,
+	"OPTION ",option_statement,
+	"USETIMER ",usetimer_statement,
+	"TIMER ",timer_statement,
+	"INTERRUPT ",interrupt_statement,
+	"IDLE",idle_statement,
+	// List of additional statements follows
+	ADDITIONAL_STATEMENTS
+};
+
+char* statement(void){
+	char* err;
+	int prevpos;
+	int i;
+	char* (*f)();
+	// Clear flag for temp area usage.
+	g_temp_area_used=0;
+	// Initialize stack handler used for value
+	g_sdepth=g_maxsdepth=0;
+	// Allow shifting code object when stack is used.
+	// This will be disalloed when CMPDATA_UNSOLVED etc is used.
+	g_allow_shift_obj=1;
+	// Seek the statement
+	for (i=0;i<sizeof(statement_list)/sizeof(statement_list[0]);i+=2){
+		if (nextCodeIs((char*)statement_list[i])) break;
+	}
+	if (i<sizeof(statement_list)/sizeof(statement_list[0])) {
+		// Statement found. Call it.
+		f=statement_list[i+1];
+		err=f();
+#ifdef __DEBUG
+	} else if (nextCodeIs("DEBUG")) {
+		err=debug_statement();
+#endif
+	} else {
+		err=let_statement();
+	}
+	if (err) return err;
+	// Stack handler must be zero here.
+	if (g_sdepth!=0) return ERR_UNKNOWN;
+	// Check if temp area is used
+	if (g_temp_area_used) {
+		// Temp area is used. Insert a garbage collection flag setting routine.
+		check_obj_space(1);
+		g_object[g_objpos++]=0x7ED6F000;//   ext         s6,s6,0,31
+	}
+	return 0;
+}

--- /dev/null
+++ b/mips/protozoa/string.c
@@ -0,0 +1,237 @@
+/*
+   This file is provided under the LGPL license ver 2.1.
+   Written by Katsumi.
+   http://hp.vector.co.jp/authors/VA016157/
+   [e-mail]
+*/
+
+/*
+	This file is shared by Megalopa and Zoea
+*/
+
+/*
+  Public functions:
+    char* get_string(void);
+	char* simple_string(void);
+*/
+
+#include "api.h"
+#include "compiler.h"
+
+char* simple_string(void){
+	char* err;
+	unsigned char b1,b2;
+	int i,j;
+	next_position();
+	b1=g_source[g_srcpos];
+	b2=g_source[g_srcpos+1];
+	if (b1=='"') {
+		// Constant string
+		// Count character number (+1 for \0)
+		// This may be more than actual character number due to escape sequence.
+		i=0;
+		while(1){
+			i++;
+			b1=g_source[g_srcpos+i];
+			if (b1=='"') {
+				break;
+			} else if (b1=='\\') {
+				i++;
+			} else if (b1<0x20) {
+				// This is an error, that will be detected later again.
+				break;
+			}
+		};
+		g_srcpos++;
+		// Determine required word number
+		i=(i+3)/4;
+		// Determine address containing the string
+		j=(int)(&(g_object[g_objpos+3]));
+		// Note that using "bgezal zero," must be used to skip some region.
+		// This is to find embed string in the code.
+		check_obj_space(2+i);
+		g_object[g_objpos++]=0x04110000|((i+1)&0x0000FFFF);   // bgezal zero,xxxx
+		g_object[g_objpos++]=0x03E01021;                      // addu   v0,ra,zero
+		for(j=0;(b1=g_source[g_srcpos++])!='"';j++) {
+			if (b1=='\\') {
+				b1=g_source[g_srcpos++];
+				if (b1=='x' || b1=='X') {
+					// Hexadecimal
+					b1=g_source[g_srcpos++];
+					if ('0'<=b1 && b1<='9') b1=b1-'0';
+					else if ('A'<=b1 && b1<='F') b1=b1-'A'+10;
+					else if ('a'<=b1 && b1<='f') b1=b1-'a'+10;
+					else return ERR_SYNTAX;
+					b2=g_source[g_srcpos++];
+					if ('0'<=b2 && b2<='9') b2=b2-'0';
+					else if ('A'<=b2 && b2<='F') b2=b2-'A'+10;
+					else if ('a'<=b2 && b2<='f') b2=b2-'a'+10;
+					else return ERR_SYNTAX;
+					b1=(b1<<4)|b2;
+				} else if (b1<0x20) {
+					return ERR_SYNTAX;
+				} else {
+					// \\ or \"
+				}
+			} else if (b1<0x20) {
+				return ERR_SYNTAX;
+			}
+			((char*)(&g_object[g_objpos]))[j]=b1;
+		}
+		((char*)(&g_object[g_objpos]))[j]=0x00;
+		g_objpos+=i;
+	} else if ('A'<=b1 && b1<='Z') {
+		i=get_var_number();
+		if (i<0) {
+			// Function
+			// String would be pointed by $v0
+			// Otherwise, it will be assinged in xxx_function() function.
+			err=str_function();
+			if (err) return err;
+			// Temp area would be used when executing.
+			g_temp_area_used=1;
+			return 0;
+		}
+		if (g_source[g_srcpos]=='.') {
+			// This is an object field or method to return string
+			check_obj_space(1);
+			g_object[g_objpos++]=0x8FC20000|(i*4); // lw v0,xx(s8)
+			g_srcpos++;
+			return string_obj_field();
+		} else if (g_source[g_srcpos]=='(') {
+			// An array element contains pointer to an object.
+			g_srcpos++;
+			err=get_dim_value(i);
+			if (err) return err;
+			if (g_source[g_srcpos]!='.') return ERR_SYNTAX;
+			g_srcpos++;
+			return string_obj_field();
+		}
+		if (g_source[g_srcpos]!='$') return ERR_SYNTAX;
+		g_srcpos++;
+		// String variable
+		next_position();
+		if (g_source[g_srcpos]=='(') {
+			// A part of string
+			g_srcpos++;
+			err=get_value();
+			if (err) return err;
+			if (g_source[g_srcpos]==')') {
+				g_srcpos++;
+				// Put -1 to $a0
+				check_obj_space(1);
+				g_object[g_objpos++]=0x2404FFFF;          // addiu a0,zero,-1
+			} else if (g_source[g_srcpos]==',') {
+				g_srcpos++;
+				// Store $v0 in stack
+				g_sdepth+=4;
+				if (g_maxsdepth<g_sdepth) g_maxsdepth=g_sdepth;
+				check_obj_space(1);
+				g_object[g_objpos++]=0xAFA20000|g_sdepth; // sw v0,xx(sp)
+				// Get next value
+				err=get_value();
+				if (err) return err;
+				// Copy $v0 to $a0 and get value from stack to $a0.
+				check_obj_space(2);
+				g_object[g_objpos++]=0x00402021;          // addu a0,v0,zero
+				g_object[g_objpos++]=0x8FA20000|g_sdepth; // lw v0,xx(sp)
+				g_sdepth-=4;
+				if (g_source[g_srcpos]!=')') return ERR_SYNTAX;
+				g_srcpos++;
+				// Temp area will be used when executing.
+				g_temp_area_used=1;
+			} else {
+				return ERR_SYNTAX;
+			}
+			// $a1 is var number, $v0 is position, $a0 is length
+			check_obj_space(1);
+			g_object[g_objpos++]=0x24050000|(i);          // addiu a1,zero,xx
+			call_lib_code(LIB_MIDSTR);
+		} else {
+			// Simple string
+			check_obj_space(1);
+			g_object[g_objpos++]=0x8FC20000|(i*4);        // lw v0,xx(s8)
+			// String is pointed by $v0
+		}
+	} else {
+		return ERR_SYNTAX;
+	}
+	return 0;
+}
+
+char* get_string_sub(){
+	char* err;
+	char b1;
+	// Obtain initial string
+	err=simple_string();
+	if (err) return err;
+	// Check if connection operator exists
+	next_position();
+	b1=g_source[g_srcpos];
+	if (b1!='+' && b1!='&') return 0; // Exit if connection operator does not exist.
+	g_srcpos++;
+	// Connection required.
+	// Prepare one level of stack for handling
+	g_sdepth+=4;
+	if (g_maxsdepth<g_sdepth) g_maxsdepth=g_sdepth;
+	while(1) {
+		// Store current pointer in stack
+		check_obj_space(1);
+		g_object[g_objpos++]=0xAFA20000|g_sdepth; // sw v0,xx(sp)
+		// Obtain next string (pointer will be in $v0)
+		err=simple_string();
+		if (err) return err;
+		// Restore previous pointer from stack in $a0 and copy $v0 to $a1
+		// Call library
+		check_obj_space(2);
+		g_object[g_objpos++]=0x8FA40000|g_sdepth;             // lw    a0,xx(sp)
+		call_lib_code(LIB_CONNECT_STRING);
+		// Temp area will be used when executing.
+		g_temp_area_used=1;
+		// Check if further connection operator exists
+		next_position();
+		b1=g_source[g_srcpos];
+		if (b1!='+' && b1!='&') break;
+		g_srcpos++;
+	}
+	g_sdepth-=4;
+	return 0;
+}
+
+char* get_string(){
+	// This is only the public function.
+	// Note that this can be called recursively.
+	// String may contain a function with a parameter of value
+	// that is a function with a parameter of string.
+	// Result will be in $v0 as a pointer.
+	char* err;
+	char b1;
+	int i,prevpos;
+	if (g_sdepth==0) {
+		// Initialize stack handler
+		g_maxsdepth=0;
+		prevpos=g_objpos;
+		// Stack decrement command will be filled later
+		check_obj_space(1);
+		g_object[g_objpos++]=0x00000000; // nop (will be replaced by "addiu sp,sp,-xx")
+	}
+	err=get_string_sub();
+	if (err) return err;
+	if (g_sdepth==0) {
+		if (g_maxsdepth==0) {
+			// Stack was not used.
+			if (g_allow_shift_obj) {
+				shift_obj(&g_object[prevpos+1],&g_object[prevpos],g_objpos-prevpos-1);
+				g_objpos--;
+			}
+		} else {
+			// Stack was used.
+			check_obj_space(1);
+			g_object[prevpos]=0x27BD0000 | (0-g_maxsdepth) & 0x0000FFFF; // addiu sp,sp,-xx
+			g_object[g_objpos++]=0x27BD0000 | g_maxsdepth & 0x0000FFFF;  // addiu sp,sp,xx
+		}
+	}
+	g_lastvar=VAR_STRING;
+	return 0;
+}
+

--- /dev/null
+++ b/mips/protozoa/timer.c
@@ -0,0 +1,325 @@
+/*
+   This file is provided under the LGPL license ver 2.1.
+   Written by Katsumi.
+   http://hp.vector.co.jp/authors/VA016157/
+   [e-mail]
+*/
+
+/*
+	This file is shared by Megalopa and Zoea
+*/
+
+#include <xc.h>
+#include "compiler.h"
+#include "api.h"
+
+/*
+	32 different type interruptions are possible.
+	See definition in compiler.h like:
+		#define INTERRUPT_TIMER 0
+		extern int g_interrupt_flags;
+		extern int g_int_vector[];
+		#define raise_interrupt_flag(x) do {\
+*/
+
+// Timer value that increments every timer event
+static int g_timer;
+
+// Interrupt types
+static const void* interrupt_list[]={
+	"TIMER",    (void*)INTERRUPT_TIMER,
+	"DRAWCOUNT",(void*)INTERRUPT_DRAWCOUNT,
+	"KEYS",     (void*)INTERRUPT_KEYS,
+	"INKEY",    (void*)INTERRUPT_INKEY,
+	"MUSIC",    (void*)INTERRUPT_MUSIC,
+	"WAVE",     (void*)INTERRUPT_WAVE,
+	ADDITIONAL_INTERRUPT_FUNCTIONS
+};
+#define NUM_INTERRUPT_TYPES ((sizeof(interrupt_list)/sizeof(interrupt_list[0]))/2)
+// Flags for interrupt
+int g_interrupt_flags;
+// Jump address when interrupt
+int g_int_vector[NUM_INTERRUPT_TYPES];
+
+/*
+	Initialize and termination
+*/
+
+void init_timer(){
+	int i;
+	// Stop timer, first
+	T1CON=0x0000;
+	IEC0bits.T1IE=0;
+	TMR1=0;
+	PR1=0xffff;
+	g_timer=0;
+	// Disable interrupt
+	IEC0bits.CS1IE=0;
+	for(i=0;i<NUM_INTERRUPT_TYPES;i++) g_int_vector[i]=0;
+	// CS0 interrupt every 1/60 sec (triggered by Timer2)
+	IPC0bits.CS0IP=3;
+	IPC0bits.CS0IS=0;
+	IFS0bits.CS0IF=0;
+	IEC0bits.CS0IE=1;	
+}
+
+void stop_timer(){
+	// Stop timer
+	T1CON=0x0000;
+	IEC0bits.T1IE=0;
+	// Disable interrupt
+	IEC0bits.CS1IE=0;
+}
+
+/*
+	Timer interprtation
+*/
+
+// Interrupt handler
+#ifndef __DEBUG
+	// Timer1 is also used for debug mode
+	#pragma interrupt T1Handler IPL2SOFT vector 4
+#endif
+void T1Handler(void){
+	g_timer++;
+	// Clear Timer1 interrupt flag
+	IFS0bits.T1IF=0;
+	// Raise TIMER interrupt flag
+	raise_interrupt_flag(INTERRUPT_TIMER);
+}
+
+void lib_usetimer(int usec){
+	int temppr1;
+	// Stop timer, first
+	T1CON=0x0000;
+	IEC0bits.T1IE=0;
+	TMR1=0;
+	PR1=0xffff;
+	// PR1 setting
+	// ((CPU_CLOCK_HZ/10000)*usec)< 2147483648, 
+	// therefore, the calculation can be done as 32 bit signed integer
+	temppr1=((CPU_CLOCK_HZ/10000)*usec)/100;
+	if (temppr1<=65536) {
+		// no prescaler
+		T1CON=0x0000;
+		PR1=temppr1-1;
+	} else if ((temppr1>>3)<=65536) {
+		// 1/8 prescaler
+		T1CON=0x0010;
+		PR1=(temppr1>>3)-1;
+	} else if ((temppr1>>6)<=65536) {
+		// 1/64 prescaler
+		T1CON=0x0020;
+		PR1=(temppr1>>6)-1;
+	} else if ((temppr1>>8)<=65536) {
+		// 1/256 prescaler
+		T1CON=0x0030;
+		PR1=(temppr1>>8)-1;
+	} else {
+		err_invalid_param();
+	}
+	// Timer1 interrupt: priority 2
+	IPC1bits.T1IP=2;
+	IPC1bits.T1IS=0;
+	IEC0bits.T1IE=1;
+	// Start timer
+	T1CONbits.ON=1;
+}
+
+char* usetimer_statement(){
+	char* err;
+	err=get_value();
+	if (err) return err;
+	call_quicklib_code(lib_usetimer,ASM_ADDU_A0_V0_ZERO);
+	return 0;
+}
+
+char* timer_statement(){
+	int i;
+	char* err;
+	err=get_value();
+	if (err) return err;
+	i=(int)(&g_timer)+0x8000;
+	check_obj_space(4);
+	g_object[g_objpos++]=0x3C030000|((i>>16)&0x0000FFFF); // lui v1,xxxx
+	g_object[g_objpos++]=0xAC620000|((i-0x8000)&0xFFFF);  // sw  v0,xxxx(v1)
+	i=(int)(&TMR1)+0x8000;//0xBF800610
+	g_object[g_objpos++]=0x3C030000|((i>>16)&0x0000FFFF); // lui v1,0xbf80
+	g_object[g_objpos++]=0xAC600000|((i-0x8000)&0xFFFF);  // sw  zero,0x0610(v1)
+	return 0;
+}
+
+char* timer_function(){
+	int i;
+	i=(int)(&g_timer)+0x8000;
+	check_obj_space(2);
+	g_object[g_objpos++]=0x3C020000|((i>>16)&0x0000FFFF); // lui v0,xxxx
+	g_object[g_objpos++]=0x8C420000|((i-0x8000)&0xFFFF);  // lw  v0,xxxx(v0)
+	return 0;
+}
+
+/*
+	Interrupt interprtation
+	To cause interruption, use raise_interrupt_flag() macro
+	For example,
+		raise_interrupt_flag(INTERRUPT_TIMER);
+
+*/
+
+void BasicInt(int addr,void* memory){
+	// Note that $s0-$s7 and $fp values must be set again here.
+	// Set s5 for initial_s5_stack
+	asm volatile("la $s5,%0"::"i"(&g_initial_s5_stack[2]));
+	// Set s7 for easy calling call_library()
+	asm volatile("la $s7,%0"::"i"(&call_library));
+	// Set fp and execute BASIC code at $a0
+	asm volatile("addu $fp,$zero,$a1");
+	asm volatile("jr $a0");
+}
+#pragma interrupt CS1Handler IPL1SOFT vector 2
+void CS1Handler(void){
+	int i;
+	// Store s0-s7, fp, and ra in stacks
+	asm volatile("#":::"s0");
+	asm volatile("#":::"s1");
+	asm volatile("#":::"s2");
+	asm volatile("#":::"s3");
+	asm volatile("#":::"s4");
+	asm volatile("#":::"s5");
+	asm volatile("#":::"s6");
+	asm volatile("#":::"s7");
+	asm volatile("#":::"fp");
+	asm volatile("#":::"ra");
+	while(g_interrupt_flags){
+		for(i=0;i<NUM_INTERRUPT_TYPES;i++){
+			if (g_interrupt_flags & (1<<i)) {
+				if (g_int_vector[i]) BasicInt(g_int_vector[i],(void*)(&g_var_mem[0]));
+				g_interrupt_flags &= (1<<i)^0xffff;
+			}
+		}
+	}
+	IFS0bits.CS1IF=0;
+}
+
+void lib_interrupt_main(int itype, int address){
+	// Set address
+	g_int_vector[itype]=address;
+	// CS1 interrupt: priority 1
+	IPC0bits.CS1IP=1;
+	IPC0bits.CS1IS=0;
+	IEC0bits.CS1IE=1;
+}
+
+void lib_interrupt(int itype){
+	// $ra contains the address for interrupt
+	// $ra is 2 word before the interrupt address
+	asm volatile("addiu $a1,$ra,8");
+	asm volatile("j lib_interrupt_main");
+}
+
+char* interrupt_statement(){
+	int itype;
+	int i,opos;
+	char* err;
+	int stop=0;
+	// Check if STOP
+	stop=nextCodeIs("STOP ");
+	// Seek the interrupt
+	for (i=0;i<NUM_INTERRUPT_TYPES;i++){
+		if (nextCodeIs((char*)interrupt_list[i*2])) break;
+	}
+	if (i<NUM_INTERRUPT_TYPES) {
+		// Interrupt found
+		itype=(int)interrupt_list[i*2+1];
+	} else {
+		// Interrupt not found
+		return ERR_SYNTAX;
+	}
+	// Compile INTERRUPT STOP
+	if (stop) {
+		// g_int_vector[itype]=0;
+		i=(int)(&g_int_vector[itype]);
+		i-=g_gp;
+		check_obj_space(1);
+		g_object[g_objpos++]=0xAF800000|(i&0x0000FFFF); // sw          zero,xxxx(gp)
+		return 0;
+	}
+	// Detect ','
+	next_position();
+	if (g_source[g_srcpos]!=',') return ERR_SYNTAX;
+	g_srcpos++;
+	// Store address to call
+	call_quicklib_code(lib_interrupt,ASM_ORI_A0_ZERO_|itype);
+	check_obj_space(4);
+	// Skip the region used for interrupt-calling
+	opos=g_objpos;
+	g_object[g_objpos++]=0x10000000; // b   xxxxx
+	g_object[g_objpos++]=0x00000000; // nop
+	// Begin interrupt-calling region
+	// Store $ra
+	g_object[g_objpos++]=0x27BDFFFC; // addiu       sp,sp,-4
+	g_object[g_objpos++]=0xAFBF0004; // sw          ra,4(sp)
+	// Compile as GOSUB statement
+	err=gosub_statement();
+	if (err) return err;
+	// Retore $ra and return
+	check_obj_space(3);
+	g_object[g_objpos++]=0x8FBF0004; // lw          ra,4(sp)
+	g_object[g_objpos++]=0x03E00008; // jr          ra
+	g_object[g_objpos++]=0x08320004; // addiu       sp,sp,4
+	// End interrupt-calling region
+	// Complete B assembly
+	g_object[opos]|=g_objpos-opos-1;
+	return 0;
+}
+
+/*
+	CS0 interrupt
+	IPL3SOFT vector 1
+
+	This interrupt is always active. Therefore, Do things as few as possible.
+	1) Call music function if needed.
+		MUSIC interrupt is taken by music.c
+	2) Check buttons for KEYS interrupt
+	3) Check PS/2 for INKEY interrupt
+	4) DRAWCOUNT interrupt
+*/
+
+const int* g_keystatus=(int*)&ps2keystatus[0];
+
+#pragma interrupt CS0Handler IPL3SOFT vector 1
+void CS0Handler(void){
+	static int s_keys=-1;
+	static char s_inkey=0;
+	int i;
+	IFS0bits.CS0IF=0;
+	// Call music function
+	if (g_music_active) musicint();
+	// The interrupts are valid only when CS1 is active
+	if (IEC0bits.CS1IE) {
+		// Raise DRAWCOUNT interrupt flag
+		raise_interrupt_flag(INTERRUPT_DRAWCOUNT);
+		// Check buttons
+		if (0<=s_keys && s_keys!=(KEYPORT&(KEYUP|KEYDOWN|KEYLEFT|KEYRIGHT|KEYSTART|KEYFIRE))) {
+			// Raise KEYS interrupt flag
+			raise_interrupt_flag(INTERRUPT_KEYS);
+		}
+		s_keys=KEYPORT&(KEYUP|KEYDOWN|KEYLEFT|KEYRIGHT|KEYSTART|KEYFIRE);
+		// Check PS/2 keyboard down
+		if (g_int_vector[INTERRUPT_INKEY]) {
+			for(i=0;i<64;i++){
+				if (g_keystatus[i]) {
+					// Raise INKEY interrupt flag
+					if (!s_inkey) raise_interrupt_flag(INTERRUPT_INKEY);
+					break;
+				}
+			}
+			s_inkey=(i==64) ? 0:1;
+		}
+	}
+}
+/*
+		for(i=0;i<256;i++){
+			if (ps2keystatus[i]) return i;
+		}
+*/

--- /dev/null
+++ b/mips/protozoa/value.c
@@ -0,0 +1,295 @@
+/*
+   This file is provided under the LGPL license ver 2.1.
+   Written by Katsumi.
+   http://hp.vector.co.jp/authors/VA016157/
+   [e-mail]
+*/
+
+/*
+	This file is shared by Megalopa and Zoea
+*/
+
+/*
+  Public function is only get_value().
+*/
+
+#include "compiler.h"
+
+char* get_value();
+char* get_value_sub(int pr);
+
+char* get_dim_value(int i){
+	char* err;
+	err=get_value_sub(priority(OP_VOID));
+	if (err) return err;
+	check_obj_space(4);
+	g_object[g_objpos++]=0x00021080;              // sll v0,v0,0x2
+	g_object[g_objpos++]=0x8FC30000|(i*4);        // lw v1,xx(s8)
+	g_object[g_objpos++]=0x00621821;              // addu v1,v1,v0
+	g_object[g_objpos++]=0x8C620000;              // lw v0,0(v1)
+	next_position();
+	if (g_source[g_srcpos]==','){
+		// 2D, 3D or more
+		// Use a stack
+		g_sdepth+=4;
+		if (g_maxsdepth<g_sdepth) g_maxsdepth=g_sdepth;
+		check_obj_space(1);
+		do {
+			g_srcpos++;
+			g_object[g_objpos++]=0xAFA20000|g_sdepth;      // sw v0,xx(sp)
+			err=get_value_sub(priority(OP_VOID));
+			if (err) return err;
+			check_obj_space(5);
+			g_object[g_objpos++]=0x00021080;               // sll v0,v0,0x2
+			g_object[g_objpos++]=0x8FA30000|g_sdepth;      // lw v1,xx(sp)
+			g_object[g_objpos++]=0x00621821;               // addu v1,v1,v0
+			g_object[g_objpos++]=0x8C620000;               // lw v0,0(v1)
+		} while (g_source[g_srcpos]==',');
+		g_sdepth-=4;
+	}
+	if (g_source[g_srcpos]!=')') return ERR_SYNTAX;
+	g_srcpos++;
+	return 0;
+}
+
+char* get_simple_value(void){
+	int i;
+	char* err;
+	char b1,b2;
+	next_position();
+	b1=g_source[g_srcpos];
+	if (b1=='(') {
+		// (...)
+		// Parenthesis
+		g_srcpos++;
+		next_position();
+		err=get_value_sub(priority(OP_VOID));
+		if (err) return err;
+		next_position();
+		if (g_source[g_srcpos]!=')') return ERR_SYNTAX;
+		g_srcpos++;
+	} else if (b1=='-') {
+		// Unary '-' operator
+		// Note that unary operators ( + and - ) have higher priority than the other operators
+		g_srcpos++;
+		err=get_simple_value();
+		if (err) return err;
+		check_obj_space(1);
+		g_object[g_objpos++]=0x00021023; // subu v0,zero,v0
+		g_intconst=-g_intconst;
+	} else if (b1=='&') {
+		// '&' operator
+		g_srcpos++;
+		i=get_var_number();
+		if (i<0) return ERR_SYNTAX;
+		check_obj_space(1);
+		g_object[g_objpos++]=0x27C20000|(i*4); // addiu       v0,s8,xxxx
+	} else {
+		// Main routine of getting value here
+		if (b1=='+') g_srcpos++; // Ignore unary '+' operator
+		next_position();
+		b1=g_source[g_srcpos];
+		b2=g_source[g_srcpos+1];
+		if (b1=='0' && b2=='X' || b1=='$') {
+			// Starts with '0x' or '$'
+			// Hex number
+			g_srcpos++;
+			if (b1=='0') g_srcpos++;
+			i=0;
+			while(b1=g_source[g_srcpos]) {
+				if ('0'<=b1 && b1<='9') {
+					i*=16;
+					i+=b1-'0';
+				} else if ('A'<=b1 && b1<='F') {
+					i*=16;
+					i+=b1-'A'+0x0A;
+				} else if (b1==' ') { // Skip ' '
+					// Avoid "ELSE" statement etc
+					if ('F'<g_source[g_srcpos+2]) break;
+				} else {
+					break;
+				}
+				g_srcpos++;
+			}
+			g_intconst=i;
+			if (i&0xFFFF0000) {
+				// 32 bit
+				check_obj_space(2);
+				g_object[g_objpos++]=0x3C020000|((i>>16)&0x0000FFFF); // lui   v0,xxxx
+				g_object[g_objpos++]=0x34420000|(i&0x0000FFFF);       // ori v0,v0,xxxx
+			} else {
+				// 16 bit
+				check_obj_space(1);
+				g_object[g_objpos++]=0x34020000|(i&0x0000FFFF); // ori v0,zero,xxxx
+			}
+		} else if ('0'<=b1 && b1<='9') {
+			// Starts with 0-9
+			// Decimal number
+			i=0;
+			while(b1=g_source[g_srcpos]) {
+				if ('0'<=b1 && b1<='9') {
+					i*=10;
+					i+=b1-'0';
+				} else if (b1!=' ') { // Skip ' '
+					break;
+				}
+				g_srcpos++;
+			}
+			// The next character should not be '.' or 'E'.
+			// Or, it must be recognized as a float value.
+			if (b1=='.') return ERR_SYNTAX;
+			if (b1=='E') {
+				b2=g_source[g_srcpos+1];
+				if (b2==' ' || '0'<=b2 && b2<='9') return ERR_SYNTAX;
+			}
+			g_intconst=i;
+			if (i&0xFFFF0000) {
+				// 32 bit
+				check_obj_space(2);
+				g_object[g_objpos++]=0x3C020000|((i>>16)&0x0000FFFF); // lui   v0,xxxx
+				g_object[g_objpos++]=0x34420000|(i&0x0000FFFF);       // ori v0,v0,xxxx
+			} else {
+				// 16 bit
+				check_obj_space(1);
+				g_object[g_objpos++]=0x34020000|(i&0x0000FFFF); // ori v0,zero,xxxx
+			}
+		} else {
+			g_valueisconst=0;
+			i=get_var_number();
+			if (i<0) {
+				// Must be a function.
+				return function();
+			}
+			if (g_source[g_srcpos]=='(') {
+				// Dimension
+				g_srcpos++;
+				err=get_dim_value(i);
+				if (err) return err;
+			} else {
+				// Simple value
+				check_obj_space(1);
+				g_object[g_objpos++]=0x8FC20000|(i*4); // lw v0,xx(s8)
+			}
+			// Check if this is an object
+			if (g_source[g_srcpos]=='.') {
+				// This is an object. See the filed of it.
+				g_srcpos++;
+				return integer_obj_field();
+			}
+		}
+	}
+	// No error 
+	return 0;
+}
+
+char* get_value_sub(int pr){
+	char* err;
+	enum operator op;
+	char b1,b2,b3;
+	int prevpos;
+	// Get a value in $v0.
+	err=get_simple_value();
+	if (err) return err;
+	while(1){
+		// Get the operator in op. If not valid operator, simply return without error.
+		prevpos=g_srcpos;
+		err=get_operator();
+		if (err) return 0;
+		op=g_last_op;
+		// Compair current and previous operators.
+		// If the previous operator has higher priolity, return.
+		if (pr>=priority(op)) {
+			g_srcpos=prevpos;
+			return 0;
+		}
+		// Store $v0 in stack
+		g_sdepth+=4;
+		if (g_maxsdepth<g_sdepth) g_maxsdepth=g_sdepth;
+		check_obj_space(1);
+		g_object[g_objpos++]=0xAFA20000|g_sdepth; // sw v0,xx(sp)
+		// Get next value.
+		err=get_value_sub(priority(op));
+		if (err) return err;
+		// Get value from stack to $v1.
+		check_obj_space(1);
+		g_object[g_objpos++]=0x8FA30000|g_sdepth; // lw v1,xx(sp)
+		g_sdepth-=4;
+		// Calculation. Result will be in $v0.
+		err=calculation(op);
+		if (err) return err;
+	}
+}
+
+char* get_value(){
+	// This is only the public function.
+	// Note that this can be called recursively.
+	// Value may contain function with a parameter of another value.
+	char* err;
+	int prevpos;
+	if (g_sdepth==0) {
+		// Initialize stack handler
+		g_maxsdepth=0;
+		prevpos=g_objpos;
+		// Stack decrement command will be filled later
+		check_obj_space(1);
+		g_object[g_objpos++]=0x00000000; // nop (will be replaced by "addiu sp,sp,-xx")
+	}
+	err=get_value_sub(priority(OP_VOID));
+	if (err) return err;
+	if (g_sdepth==0) {
+		if (g_maxsdepth==0) {
+			// Stack was not used.
+			if (g_allow_shift_obj) {
+				shift_obj(&g_object[prevpos+1],&g_object[prevpos],g_objpos-prevpos-1);
+				g_objpos--;
+			}
+		} else {
+			// Stack was used.
+			check_obj_space(1);
+			g_object[prevpos]=0x27BD0000 | (0-g_maxsdepth) & 0x0000FFFF; // addiu sp,sp,-xx
+			g_object[g_objpos++]=0x27BD0000 | g_maxsdepth & 0x0000FFFF;  // addiu sp,sp,xx
+		}
+	}
+	g_lastvar=VAR_INTEGER;
+	return 0;
+}
+
+char* get_floatOrValue(){
+	char* err;
+	char b;
+	int opos,spos,sdpt;
+	sdpt=g_sdepth;
+	opos=g_objpos;
+	spos=g_srcpos;
+	// First try integer.
+	// Integer value has the higher priolity than float value.
+	err=get_value();
+	b=g_source[g_srcpos];
+	if (err || b=='#') {
+		// Value is not integer. Let's try float.
+		g_sdepth=sdpt;
+		g_objpos=opos;
+		g_srcpos=spos;
+		return get_float();
+	} else {
+		// Value was recognized as an integer.
+		return 0;
+	}
+}
+
+char* get_stringFloatOrValue(){
+	char* err;
+	int opos,spos;
+	opos=g_objpos;
+	spos=g_srcpos;
+	// First try string, float, then integer.
+	err=get_string();
+	if (err) {
+		g_objpos=opos;
+		g_srcpos=spos;
+		return get_floatOrValue();
+	} else {
+		return 0;
+	}
+}
+

--- /dev/null
+++ b/mips/protozoa/varname.c
@@ -0,0 +1,271 @@
+/*
+   This file is provided under the LGPL license ver 2.1.
+   Written by Katsumi.
+   http://hp.vector.co.jp/authors/VA016157/
+   [e-mail]
+*/
+
+/*
+	This file is shared by Megalopa and Zoea
+*/
+
+#include "compiler.h"
+
+/*
+	static const int reserved_var_names[];
+	This dimension contains var name integers of reserved var names.
+	To make following structure, execute "reservednames.js" in Windows.
+*/
+
+static const int reserved_var_names[]={
+	0x000106b8, /*ABS*/
+	0x0001f67c, /*ACOS*/
+	0x0002414c, /*ARGS*/
+	0x0001090c, /*ASC*/
+	0x0002469f, /*ASIN*/
+	0x00024a8f, /*ATAN*/
+	0x002f7c1e, /*ATAN2*/
+	0x0047c31c, /*BREAK*/
+	0x00035869, /*CALL*/
+	0x00575afe, /*CDATA*/
+	0x00036c3d, /*CEIL*/
+	0x000111af, /*CHR*/
+	0x0cb1b682, /*CIRCLE*/
+	0x005d1ea3, /*CLEAR*/
+	0x00011240, /*CLS*/
+	0x005f66cb, /*COLOR*/
+	0x000112ac, /*COS*/
+	0x0003a041, /*COSH*/
+	0x00616415, /*CREAD*/
+	0x0de593fb, /*CURSOR*/
+	0x00040fbe, /*DATA*/
+	0x00011644, /*DEC*/
+	0x0fe19c42, /*DELETE*/
+	0x000116de, /*DIM*/
+	0x000100a8, /*DO*/
+	0x0004fd8e, /*ELSE*/
+	0x1434a177, /*ELSEIF*/
+	0x00011c99, /*END*/
+	0x0091c927, /*ENDIF*/
+	0x00053854, /*EXEC*/
+	0x00011e0d, /*EXP*/
+	0x000579c8, /*FABS*/
+	0x16e3d4be, /*FCLOSE*/
+	0x00058fcf, /*FEOF*/
+	0x00059895, /*FGET*/
+	0x00a67500, /*FGETC*/
+	0x00a7e061, /*FIELD*/
+	0x0005a3a2, /*FILE*/
+	0x177f0ca5, /*FINPUT*/
+	0x0005b1df, /*FLEN*/
+	0x00aa3445, /*FLOAT*/
+	0x00aa363b, /*FLOOR*/
+	0x0005b84d, /*FMOD*/
+	0x00ac5c9f, /*FOPEN*/
+	0x000121db, /*FOR*/
+	0x18352839, /*FPRINT*/
+	0x0005c865, /*FPUT*/
+	0x00ad2e40, /*FPUTC*/
+	0x00aefdec, /*FSEEK*/
+	0x00063b90, /*GCLS*/
+	0x1a808bcb, /*GCOLOR*/
+	0x1ab733b3, /*GETDIR*/
+	0x00c60f03, /*GOSUB*/
+	0x0006796c, /*GOTO*/
+	0x1bcfcc39, /*GPRINT*/
+	0x00012a99, /*HEX*/
+	0x0007ad12, /*IDLE*/
+	0x00010153, /*IF*/
+	0x00f8701a, /*INKEY*/
+	0x00f88ba5, /*INPUT*/
+	0x000130e9, /*INT*/
+	0x00092084, /*KEYS*/
+	0x013be43d, /*LABEL*/
+	0x00013ecf, /*LEN*/
+	0x00013ed5, /*LET*/
+	0x0009e96a, /*LINE*/
+	0x00014030, /*LOG*/
+	0x0145f324, /*LOG10*/
+	0x000a07f9, /*LOOP*/
+	0x000abca3, /*MODF*/
+	0x016418d4, /*MUSIC*/
+	0x000b4321, /*NEXT*/
+	0x000148f8, /*NEW*/
+	0x00014a5d, /*NOT*/
+	0x38a658d7, /*OPTION*/
+	0x000152c0, /*PCG*/
+	0x000cacec, /*PEEK*/
+	0x3b1c6aea, /*PEEK16*/
+	0x3b1c6b2e, /*PEEK32*/
+	0x00010252, /*PI*/
+	0x01ac8479, /*POINT*/
+	0x000ce05e, /*POKE*/
+	0x3c20dc0a, /*POKE16*/
+	0x3c20dc4e, /*POKE32*/
+	0x00015480, /*POW*/
+	0x01aea739, /*PRINT*/
+	0x000cf3d5, /*PSET*/
+	0x3cb45fa4, /*PUBLIC*/
+	0x3cc0fe21, /*PUTBMP*/
+	0x000e18d5, /*READ*/
+	0x00015d2e, /*REM*/
+	0x425c9703, /*RETURN*/
+	0x00015e69, /*RND*/
+	0x45c26d49, /*SCROLL*/
+	0x45f6e3b3, /*SETDIR*/
+	0x00016287, /*SGN*/
+	0x000162cf, /*SIN*/
+	0x000ee52d, /*SINH*/
+	0x01f9a429, /*SOUND*/
+	0x000f0e49, /*SQRT*/
+	0x47f711de, /*SYSTEM*/
+	0x000166bf, /*TAN*/
+	0x000f72ed, /*TANH*/
+	0x020ed5f3, /*TIMER*/
+	0x02182fee, /*TVRAM*/
+	0x022c2a2d, /*UNTIL*/
+	0x4e8887d0, /*USEPCG*/
+	0x4e88a5f3, /*USEVAR*/
+	0x000170dd, /*VAL*/
+	0x000170e3, /*VAR*/
+	0x00119505, /*WAIT*/
+	0x0011a9e9, /*WEND*/
+	0x025aef62, /*WHILE*/
+	0x025b8d75, /*WIDTH*/
+	// Additional names follow
+	ADDITIONAL_RESERVED_VAR_NAMES
+};
+
+/*
+	check_var_name();
+	This function reads the current position of source code and check if
+	it contains valid var name, the function returns 0 or plus value.
+	If not, it returns -1;
+*/
+
+int check_var_name(){
+	char b1;
+	int j;
+	int i=0;
+	int prevpos=g_srcpos;
+	next_position();
+	b1=g_source[g_srcpos];
+	if (b1<'A' || 'Z'<b1) return -1;
+	do {
+		// First character must be A-Z
+		// From second, A-Z and 0-9 can be used.
+		i*=36;
+		if ('0'<=b1 && b1<='9') {
+			i+=b1-'0';
+		} else if (g_srcpos==prevpos) {
+			// First character must be A-Z.
+			// Subtract 9, resulting 1-26 but not 10-35.
+			// This subtraction is required to maintain
+			// final number being <0x80000000.
+			i+=b1-'A'+1;
+		} else {
+			i+=b1-'A'+10;
+		}
+		g_srcpos++;
+		b1=g_source[g_srcpos];
+	} while ('0'<= b1 && b1<='9' || 'A'<=b1 && b1<='Z');
+	// Length of the label must be between 2 and 6.
+	if (g_srcpos-prevpos<2) {
+		// One letter var name, A-Z
+		return i-1;
+	}
+	if (6<g_srcpos-prevpos) {
+		// Too long. This is not var name.
+		g_srcpos=prevpos;
+		return -1;
+	}
+	i+=65536;
+	// Check if this is reserved var name.
+	for(j=0;j<sizeof reserved_var_names/sizeof reserved_var_names[0];j++){
+		if (reserved_var_names[j]==i) {
+			// This var name is reserved as used for function or statement.
+			g_srcpos=prevpos;
+			return -1;
+		}
+	}
+	// Reserved var names table was checked. This must be a long var name.
+	return i;
+}
+
+/*
+	int get_var_number();
+	This function returns variable number that can be used as the index of $s8
+*/
+
+int get_var_number(){
+	int i,j,spos;
+	int* record;
+	// This must be a short or long var name.
+	spos=g_srcpos;
+	i=check_var_name();
+	if (i<0) return -1;
+	// If it is a short name, immediately return.
+	if (i<26) return i;
+	// Check if CLASS::STATIC
+	if (g_source[g_srcpos]==':' && g_source[g_srcpos+1]==':') {
+		// This is CLASS::STATIC
+		g_srcpos++;
+		g_srcpos++;
+		j=check_var_name();
+		if (j<26) return -1;
+		cmpdata_reset();
+		while(record=cmpdata_find(CMPDATA_STATIC)){
+			if (record[1]!=i) continue;
+			if (record[2]!=j) continue;
+			// Found CLASS::STATIC
+			i=record[0]&0x0000FFFF;
+			j=0;
+			break;
+		}	
+		if (j) {
+			// Not found. Maybe a static method
+			g_srcpos=spos;
+			return -1;
+		}
+	} else {
+		// Search long var names registered by USEVAR statement.
+		// If found, returns the value that can be used as the index of $s8
+		i=search_var_name(i);
+		if (i<0) return -1;
+	}
+	// This var name is defined by USEVAR statement.
+	return i+ALLOC_LNV_BLOCK;
+	
+}
+
+/*
+	int search_var_name(int nameint);
+	This function searchs registered long var name in compile data table.
+	If not found, this function returns -1.
+	If found, it retunrs var number, beginning 0.
+*/
+
+int search_var_name(int nameint){
+	int* cmpdata;
+	cmpdata_reset();
+	while(cmpdata=cmpdata_find(CMPDATA_USEVAR)){
+		if (cmpdata[1]==nameint) return cmpdata[0]&0x0000ffff;
+	}
+	return -1;
+}
+
+/*
+	char* register_var_name(int nameint);
+	This function is called when compiler detects "USEVAR" statement.
+	It registers the long file name in compile data table.
+*/
+
+char* register_var_name(int nameint){
+	// Check if registered before. If did, cause error.
+	if (search_var_name(nameint)!=-1) return ERR_INVALID_VAR_NAME;
+	// Number of long var name is restricted
+	if (ALLOC_LNV_NUM<=g_long_name_var_num) return ERR_INVALID_VAR_NAME;
+	// Register var name as a compile data
+	g_temp=nameint;
+	return cmpdata_insert(CMPDATA_USEVAR,g_long_name_var_num++,&g_temp,1);
+}