ActionScript-Code of am_sim.fla version 0.9 date 2003-10-31

##### fLoad #####

/* ARCADEmini simulator in Flash
 * version 0.9 date 2003-10-31
 * part of the ARCADEmini project - http[s]://arcademini.schuermans.info/
 * Copyright (C) 2003 sphaera <sphaera@geekness.de>
 *                and 1stein <1stein@schuermans.info>
 * Copyleft: GNU public license - http://www.gnu.org/copyleft/gpl.html
 */

//nothing loaded yet
amloaded = 0;

//check if filename of data file is specified
if( amflash + "" == "" )
{
  //filename of data file is specified
  //try to read data file
  loadVariables( amflash, "" );
}
else
{
  //no filename of data file found
  //use default data (AM-Pixie)
  amdata = ""
  amdata = amdata + "EBFCEDEBEEEFGNGJGOGJCADCDGHIDCDACPDBDGCAGBGNGCGJGOCADBCODACACACAPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPPP"
  amdata = amdata + "KMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEAIAAAAAAAAAOFCJIACFDCPAAJEMKAADJEKHAAIAAAAACAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMAMJADOIKMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAAAAAAAAAAAACOAAAAAKEAAAACJAAAAAKEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMAMJABPEKMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAAAIEAAAADJMGAAAIELMAACFCIAAAGEJMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMAMJABPEKMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAAAAAAIAAAAADIMJAAAJEJIAACFCGAAAODCEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMAMJADOIKMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMAMJADOIKMAACAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMAMJAAGEKMAAAAAAAAAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMAMJAAGEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA"
  amdata = amdata + "KMAAAAAAAAAAAAAAACAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMAMJAAGEKMAAAAAAAAAAAAAAAAAAAAAAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAHIAAAABOAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMAMJAAGEKMAAAAAAAAAAAAAAAAAAAAAAAAAAAACAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADPAAAAAIEAAAADPAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMAMJAAGEKMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADPPAAAAIAEAAACABAAAAPPMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMAMJAAGEKMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADDPAAAAMAEAAACABAAAAPPMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMAMJAAMIKMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIAAAAAAAAAAAAAAAAAAAAAAAADDPAAAAMAEAAACABAAAAPPMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMAMJAAGEKMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAAAAAAAAAAAAAAAAAADDPAAAAMAEAAACABAAAAPPMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMAMJAAGEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA"
  amdata = amdata + "KMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIAAAAAAAAAAADDPAAAAMAEAAACABAAAAPPMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMAMJAAGEKMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEAAAAAAAAAAABIPOAAAGAAIAABIACAAAEAAIAABPPOAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMAMJAAMIKMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAAAAAAAAAAAAMHPMAADAABAAAMAAEAACAABAAAIAAEAADPPPAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMAMJAAMIKMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIAAAAAMHPMAADAABAAAMAAEAACAABAAAIAAEAADPPPAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMAMJAAGEKMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAOHPMAADAABAAAMAAEAACAABAAAIAAEAADPPPAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMAMJAAGEKMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGJPPIABIAACAAGAAAIABIAACAAEAAAIABAAACAAHPPPIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMAMJAAMIKMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADGHPPAAMAAAEADAAABAAMAAAEACAAABAAIAAAEACAAABAAPPPPMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMAMJAAMIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA"
  amdata = amdata + "KMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADGHPPAANIAAEADAAABAAMAAAEACAAABAAIAAAEACAAABAAPPPPMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMAMJAAGEKMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADAHPPAANIAAEADGAABAAMAAAEACAAABAAIAAAEACAAABAAPPPPMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMAMJAAGEKMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGADPPIBIAAACAGAAAAIBJMAACAGHAAAIBAAAACAEAAAAIBAAAACAEAAAAIBPPPPOAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMAMJAAMIKMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGADPPIBIAAACAGAAAAIBIAAACAGHAAAIBBMAACAEAAAAIBAAAACAEAAAAIBPPPPOAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMAMJAAGEKMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGADPPIBIAAACAGAAAAIBIAAACAGAAAAIBBMAACAEHAAAIBAAAACAEAAAAIBPPPPOAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMAMJAAGEKMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGADPPIBIAAACAGAAAAIBIAAACAGAAAAIBAAAACAEHAAAIBBMAACAEAAAAIBPPPPOAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMAMJAAGEKMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEADPPIBIAAACAFAAAAIBCAAACAEEAAAIBAAAACAEAAAAIBBMAACAEHAAAIBPPPPOAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMAMJAAMIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA"
  amdata = amdata + "KMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGADPPIBMAAACAEMAAAIBAMAACAEAAAAIBAAAACAEHAAAIBBMAACAEAAAAIBPPPPOAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMAMJAAMIKMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGADPPIBHAAACAEDMAAIBAAAACAEAAAAIBAAAACAEAAAAIBBMAACAEHAAAIBPPPPOAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMAMJAAMIKMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAHPPPPIBAAAACAEAAAAIBAAAACAEAAAAIBAAAACAEAAAAIBBMAACAEHAAAIBPPPPOAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMAMJADOIKMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAHPPPPIBAAAACAEAAAAIBAAAACAEAAAAIBAAAACAEAAAAIBBMAACAEFAAAIBPPPPOAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMAMJABPEKMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAHPPPPIBAAAACAEAAAAIBAAAACAEAAAAIBAAAACAECAAAIBBMAACAEFAAAIBPPPPOAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMAMJABPEKMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAHPPPPIBAAAACAEAAAAIBAAAACAEAAAAIBAIAACAEHAAAIBAAAACAEFAAAIBPPPPOAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMAMJABPEKMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAHPPPPIBAAAACAEAAAAIBAAAACAECAAAIBAAAACAEHAAAIBAAAACAEFAAAIBPPPPOAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMAMJADOIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA"
  amdata = amdata + "KMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAHPPPPIBAAAACAEAAAAIBAAAACAEDAAAIBAAAACAEGAAAIBAAAACAEFAAAIBPPPPOAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMAMJAAMIKMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAHPPPPIBAAAACAEAAAAIBAIAACAECAAAIBAAAACAEGAAAIBAAAACAEFAAAIBPPPPOAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMAMJAADCKMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAHPPPPIBAAAACAEAAAAIBAAAACAEDAAAIBAAAACAEGAAAIBAAAACAEFAAAIBPPPPOAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMAMJAADCKMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAHPPPPIBAAAACAEAAAAIBAIAACAECAAAIBAAAACAEGAAAIBAAAACAEFAAAIBPPPPOAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMAMJAADCKMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAHPPPPIBAAAACAEAAAAIBAAAACAEDAAAIBAAAACAEGAAAIBAAAACAEFAAAIBPPPPOAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMAMJAADCKMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAHPPPPIBAAAACAEAAAAIBAAAACAECAAAIBAAAACAEHAAAIBAAAACAEFAAAIBPPPPOAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMAMJABPEKMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAHPPPPIBAAAACAEAAAAIBAAAACAECAAAIBBEAACAECAAAIBAAAACAEFAAAIBPPPPOAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMAMJAAMIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA"
  amdata = amdata + "KMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAHPPPPIBAAAACAEAAAAIBAAAACAEKIAAIBAAAACAECAAAIBAAAACAEFAAAIBPPPPOAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMAMJAAMIKMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAHPPPPIBAAAACAEAAAAIBBEAACAECAAAIBAAAACAECAAAIBAAAACAEFAAAIBPPPPOAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMAMJABPEKMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAHPPPPIBAAAACAEAAAAIBBAAACAECIAAIBAAAACAECAAAIBCAAACAEBAAAIBPPPPOAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMAMJAAMIKMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAHPPPPIBAAAACAEAAAAIBAEAACAEAEAAIBAAIACAEJAAAIBAAAACAEBAAAIBPPPPOAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMAMJAAMIKMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAHPPPPIBAAAACAEAAAAIBAAIACAEAAAAIBAAEACAEEIEAIBAAAACAEBAAAIBPPPPOAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMAMJAAMIKMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAHPPPPIBAAAACAEAAAAIBAAAACAEABAAIBAIAACAEAEIAIBAABACAEBAAAIBPPPPOAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMAMJAAMIKMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAHPPPPIBAAAACAEAAAAIBAAAACAEBAEAIBAAAACAEACEAIBAEAACAEAAEAIBPPPPOAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMAMJAAMIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA"
  amdata = amdata + "KMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAHPPPPIBAAAACAEAAAAIBAAAACAEAEBAIBAAAACAEAJCAIBAAAACAEAAEAIBPPPPOAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMAMJAAMIKMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAHPPPPIBAAAACAEAAAAIBAAAACAEABAAIBAAABCAEAEIAIBAAAECAEAAEAIBPPPPOAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMAMJAAMIKMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAHPPPPIBAAAACAEAAAAIBAAAACAEAAEAIBAAIACAEAAEAIBAAAFCAEAAEAIBPPPPOAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMAMJAAMIKMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAHPPPPIBAAAACAEAAAAIBAAAACAEAABAIBAACACAEAABAIBAAAECAEAAEIIBPPPPOAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMAMJAAMIKMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAHPPPPIBAAAACAEAAAAIBAAACCAEAAEAIBAAAECAEAAAAIBAAAECAEAAEIIBPPPPOAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMAMJAAMIKMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAHPPPPIBAAAACAEAAAAIBAAAECAEAAACIBAAACCAEAAAAIBAAAECAEAAEIIBPPPPOAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMAMJAAMIKMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAHPPPPIBAAAACAEAAAAIBAAABCAEAAAAIBAAACGAEAAAAIBAACECAEAAAIIBPPPPOAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMAMJAAMIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA"
  amdata = amdata + "KMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAHPPPPIBAAAACAEAAAAIBAAAAGAEAAAAIBAACCGAEAACAIBAAAACAEAAAIIBPPPPOAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMAMJAAMIKMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAHPPPPIBAAAACAEAAAAIBAACAGAEAAAIIBAABAGAEAAAAIBAAAICAEAAAAIBPPPPOAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMAMJAAMIKMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAHPPPPIBAAAACAEAACAIBAACAGAEAAAIIBAABAGAEAAAAIBAAAACAEAAAAIBPPPPOAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMAMJAAMIKMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAHPPPPIBAACACAEABAAIBAAAEGAEAAIAIBAAABCAEAAAAIBAAAACAEAAAAIBPPPPOAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMAMJAAMIKMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAHPPPPIBAACACAEACAAIBAABBCAEACAAIBAAAICAEAAAAIBAAAACAEAAAAIBPPPPOAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMAMJAAMIKMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAHPPPPIBAACACAEAAAAIBAAIACAEAIIIIBAAAACAEAAEAIBAAAACAEAAAAIBPPPPOAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMAMJAAMIKMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAHPPPPIBAACACAEBAAAIBAAIACAEAAIAIBAAAICAEABAAIBAAAACAEAAAAIBPPPPOAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMAMJAAMIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA"
  amdata = amdata + "KMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAHPPPPIBACCACAEACAAIBAAAACAEABAAIBAAAACAEAEEAIBAAAACAEAAAAIBPPPPOAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMAMJAAMIKMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAHPPPPIBACCACAEACAAIBAAAACAEACAAIBACCACAEAAAAIBAAAACAEAAAAIBPPPPOAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMAMJAAMIKMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAHPPPPIBACCACAEAAAAIBAAIACAEAAAAIBAAIACAEAAAAIBABEACAEAAAAIBPPPPOAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMAMJABPEKMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAHPPPPIBACCACAEACAAIBAAAACAEACAAIBAAAACAEAFAAIBAAAACAEAAAAIBPPPPOAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMAMJAAMIKMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAHPPPPIBACCACAEAAAAIBAAIACAEAAAAIBAAIACAEAAAAIBABEACAEAAAAIBPPPPOAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMAMJAAMIKMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAHOHPPIBAGAACAEAIIAIBAAAACAEACAAIBAAAACAEACAAIBAAAACAEAFAAIBPPPPOAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMAMJAAMIKMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAHAHPPIBHAAACAEDIAAIBACCACAEAAAAIBAAIACAEAAAAIBAAIACAEAFAAIBPPPPOAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMAMJAAMIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA"
  amdata = amdata + "KMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGAHPPIBGAAACAEGAAAIBAGAACAEAIIAIBAAIACAEAAAAIBAAIACAEAFAAIBPPPPOAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMAMJAAMIKMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGAHPPIBEAAACAEIAAAIBBIAACAEBAAAIBACKACAEAAAAIBAAIACAEAFAAIBPPPPOAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMAMJAAMIKMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAHAHPPIBEAAACAEIAAAIBCAAACAEEAAAIBBAIACAEAIIAIBAAIACAEAFAAIBPPPPOAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMAMJAAMIKMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGAHPPIBEAAACAFAAAAIBEAAACAEICAAIBCAAACAEAKIAIBAAAACAEAFAAIBPPPPOAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMAMJAAMIKMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGAHPPIBAAAACAFAAAAIBEAAACAFACAAIBECCACAFACAAIBAAAACAEAFAAIBPPPPOAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMAMJAAMIKMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGAHPPIBAAAACAEAAAAIBBCKACAEIAAAIBCAIACAFAAAAIBEBEACAEAAAAIBPPPPOAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMAMJAAMIKMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGAHPPIBAAAACAEAAAAIBACKACAEACAAIBAJEACAEEAAAIBCAAACAFAAAAIBPPPPOAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMAMJAAMIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA"
  amdata = amdata + "KMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGAHPPIBAAAACAEAAAAIBACCACAEAHAAIBAAAACAEBIAAIBBIAACAFIAAAIBPPPPOAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMAMJAAMIKMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGAHPPIBAAAACAEAAAAIBADOACAEACAAIBAAAACAEAAAAIBAOAACAFMAAAIBPPPPOAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMAMJAAMIKMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGAHPPIBAAAACAEAAAAIBAAAACAEAPIAIBAAAACAEAAAAIBAAAACAFPIAAIBPPPPOAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMAMJAAMIKMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGAHPPIBAAAACAEAAAAIBAAIACAEAKIAIBABEACAEAAAAIBAAAACAFPIAAIBPPPPOAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMAMJAAMIKMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGAHPPIBAAAACAEAAAAIBAAAACAEACAAIBACKACAEAFAAIBAAAACAFPIAAIBPPPPOAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMAMJAAMIKMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGAHPPIBAAAACAEAAAAIBAAAACAEACAAIBACCACAEACAAIBABEACAFPIAAIBPPPPOAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMAMJAAMIKMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGAHPPIBAAAACAEAAAAIBAAAACAEAAAAIBAAAACAEACAAIBACKACAFPNAAIBPPPPOAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMAMJAAMIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA"
  amdata = amdata + "KMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGAHPPIBAAAACAEAAAAIBAAAACAEAAAAIBAAIACAEAKIAIBAAAACAFPNAAIBPPPPOAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMAMJAAMIKMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGAHPPIBAAAACAEAAAAIBAAAACAEACAAIBACCACAEACAAIBAAAACAFPNAAIBPPPPOAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMAMJADOIKMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGAHPPIBAAAACAEAAAAIBAAAACAEAAAAIBAAIACAEAIIAIBAAIACAFPNAAIBPPPPOAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMAMJAAMIKMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGAHPPIBAAAACAEAAAAIBAAAACAEAFAAIBAEAACAEACAAIBAAAACAFPNAAIBPPPPOAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMAMJAAMIKMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGAHPPIBAAAACAEAAAAIBACIACAEAIAAIBAEIACAEABAAIBABAACAFPIAAIBPPPPOAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMAMJAAMIKMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGAHPPIBAAAACAEAAAAIBACAACAEBAAAIBAFEACAEAEAAIBAAAACAFPIAAIBPPPPOAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMAMJAAMIKMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGAHPPIBAAAACAEAAAAIBAIEACAEBEAAIBABAACAEAAAAIBAAAACAFPIAAIBPPPPOAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMAMJAAMIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA"
  amdata = amdata + "KMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGAHPPIBAAAACAEBAAAIBACAACAEGEAAIBAEAACAEAAAAIBAAAACAFPIAAIBPPPPOAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMAMJAAMIKMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGAHPPIBAAAACAEIIAAIBAIAACAEEAAAIBCEAACAEAAAAIBAAAACAFPIAAIBPPPPOAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMAMJAAMIKMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGAHPPIBAAAACAECAAAIBFAAACAECIAAIBCAAACAEAAAAIBAAAACAFPIAAIBPPPPOAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMAMJAAMIKMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGAHPPIBAAAACAEIAAAIBBEAACAFCAAAIBBAAACAEAAAAIBAAAACAFPIAAIBPPPPOAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMAMJAAMIKMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGAHPPIBAAAACAEAAAAIBEEAACAEGAAAIBCIAACAEAAAAIBAAAACAFPIAAIBPPPPOAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMAMJAAMIKMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGAHPPIBAAAACAEAAAAIBBAAACAEKAAAIBKEAACAEAAAAIBAAAACAFPIAAIBPPPPOAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMAMJAAMIKMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGAHPPIBAAAACAEAAAAIBIAAACAEKAAAIBEAAACAGIAAAIBAAAACAFPIAAIBPPPPOAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMAMJADOIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA"
  amdata = amdata + "KMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGAHPPIBAAAACAEAAAAIBKIAACAFAAAAIBAAAACAGIAAAIBAAAACAFPIAAIBPPPPOAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMAMJAAMIKMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGAHPPIBAAAACAEAAAAIBIAAACAEKAAAIBEAAACAGIAAAIBAAAACAFPIAAIBPPPPOAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMAMJAAMIKMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGAHPPIBAAAACAEAAAAIBJEAACAEIAAAIBAAAACAGIAAAIBAAAACAFPIAAIBPPPPOAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMAMJAAMIKMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGAHPPIBAAAACAEFAAAIBKAAACAEAAAAIBBAAACAGAAAAIBAAAACAFPIAAIBPPPPOAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMAMJAAMIKMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGAHPPIBAKAACAFEAAAIBAAAACAEEAAAIBEAAACAEAAAAIBAAAACAFPIAAIBPPPPOAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMAMJAAMIKMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGCPPPIBCIAACAEAAAAIBAIAACAEIAAAIBAAAACAEAAAAIBAAAACAFPIAAIBPPPPOAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMAMJAAMIKMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGCPPPIBCIAACAEAAAAIBAAAACAEFAAAIBAAAACAEAAAAIBAAAACAFPIAAIBPPPPOAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMAMJABPEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA"
  amdata = amdata + "KMAAAAAAAAAAAAAAAAAAAAAAAAAAAAEAAAAGFPPPIBAAAACAEEAAAIBAEAACAEAAAAIBAAAACAEAAAAIBAAAACAFPIAAIBPPPPOAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMAMJABCMKMAAAAAAAAAAAAAAAAAAAAAAAAAAAAKAAAAGBPPPIBAIAACAEAAAAIBAIAACAEAAAAIBAAAACAEAAAAIBAAAACAFPIAAIBPPPPOAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMAMJABCMKMAAAAAAAAAAAAAAAAAAAAABAAAAACCAAAAGCPPPIBBAAACAEAAAAIBAAAACAEAAAAIBAAAACAEAAAAIBAAAACAFPIAAIBPPPPOAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMAMJAAMIKMAAAAAAAAAAAAAAACAAAAAIAAAAAAKAAAAGEPPPIBAAAACAEAAAAIBAAAACAEAAAAIBAAAACAEAAAAIBAAAACAFPIAAIBPPPPOAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMAMJAAMIKMAAAAAAAAAAAAAABAAAAAACCAAAABCAAAAGAPPPIBAAAACAEAAAAIBAAAACAEAAAAIBAAAACAEAAAAIBAAAACAFPIAAIBPPPPOAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMAMJAAMIKMAAAAAAAACAAAAAAEAAAAAEFAAAAAAAAAAGAPPPIBAAAACAEAAAAIBAAAACAEAAAAIBAAAACAEAAAAIBAAAACAFPIAAIBPPPPOAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMAMJAAMIKMAACAAAAAEAAAAAACAAAAAAFAAAAAEAAAAGAHPPIBAAAACAEAAAAIBAAAACAEAAAAIBAAAACAEAAAAIBAAAACAFPIAAIBPPPPOAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMAMJAAMIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA"
  amdata = amdata + "KMAAEIAAAAAEAAAAAAAAAAABKAAAAAAAAAAGAHPPIBAAAACAEAAAAIBAAAACAEAAAAIBAAAACAEAAAAIBAAAACAFPIAAIBPPPPOAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMAMJAAMIKMAABAAAAAACIAAAAEAAAAAAKAAAAAAAAAAGAHPPIBAAAACAEAAAAIBAAAACAEAAAAIBAAAACAEAAAAIBAAAACAFPIAAIBPPPPOAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMAMJAAMIKMAAAAAAAABCAAAAAIFAAAABAAAAAAAAAAAGAHPPIBAAAACAEAAAAIBAAAACAEAAAAIBAAAACAEAAAAIBAAAACAFPIAAIBPPPPOAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMAMJAAMIKMAABAAAAABAEAAAAEEAAAAABAAAAAAAAAAGAHPPIBAAAACAEAAAAIBAAAACAEAAAAIBAAAACAEAAAAIBAAAACAFPIAAIBPPPPOAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMAMJAAMIKMAAAAAAAAAFAAAAACAAAAAABEAAAABAAAAGAHPPIBAAAACAEAAAAIBAAAACAEAAAAIBAAAACAEAAAAIBAAAACAFPIAAIBPPPPOAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMAMJAAMIKMAAAAAAAAACAAAAACCAAAAACAAAAABEAAAGAHPPIBAAAACAEAAAAIBAAAACAEAAAAIBAAAACAEAAAAIBAAAACAFPIAAIBPPPPOAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMAMJAAMIKMAAAAAAAAAAAAAAAAIAAAAAIIAAAABMAAAGAHPPIBAAAACAEAAAAIBAAAACAEAAAAIBAAAACAEAAAAIBAAAACAFPIAAIBPPPPOAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMAMJAAMIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA"
  amdata = amdata + "KMAAAAAAAAACAAAAACCAAAAACAAAAABEAAAGAHPPIBAAAACAEAAAAIBAAAACAEAAAAIBAAAACAEAAAAIBAAAACAFPIAAIBPPPPOAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMAMJAAMIKMAAAIAAAAAIIAAAAAIAAAAAAAAAAABEAAAGAHPPIBAAAACAEAAAAIBAAAACAEAAAAIBAAAACAEAAAAIBAAAACAFPIAAIBPPPPOAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMAMJABPEKMAAAIAAAABBAAAAAAIAAAAAAAAAAABEAAAGAHPPIBAAAACAEAAAAIBAAAACAEAAAAIBAAAACAEAAAAIBAAAACAFPIAAIBPPPPOAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMAMJAAMIKMAABAAAAACIAAAAAAIAAAAAAAAAAABEAAAGAHPPIBAAAACAEAAAAIBAAAACAEAAAAIBAAAACAEAAAAIBAAAACAFPIAAIBPPPPOAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMAMJAAMIKMAACAAAAAFAAAAAAAIAAAAAAAAAAABEAAAGAHPPIBAAAACAEAAAAIBAAAACAEAAAAIBAAAACAEAAAAIBAAAACAFPIAAIBPPPPOAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMAMJABPEKMAACAAAAAFAAAAABAIAAAAEAAAAAABEAAAGAHPPIBAAAACAEAAAAIBAAAACAEAAAAIBAAAACAEAAAAIBAAAACAFPIAAIBPPPPOAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMAMJAAMIKMAACAAAAAFAAAAABAIAAAAEAAAAABBEAAAGEHPPIBAAAACAEAAAAIBAAAACAEAAAAIBAAAACAEAAAAIBAAAACAFPIAAIBPPPPOAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMAMJAAMIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA"
  amdata = amdata + "KMAACAAAAAFAAAAABAIAAAAEAAAAABBEAAAGEHPPIBBAAACAEEAAAIBAAAACAEAAAAIBAAAACAEAAAAIBAAAACAFPIAAIBPPPPOAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMAMJAAMIKMAACAAAAAFAAAAABAIAAAAEAAAAABBEAAAGEHPPIBBAAACAEEAAAIBBAAACAEEAAAIBAAAACAEAAAAIBAAAACAFPIAAIBPPPPOAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMAMJAAMIKMAACAAAAAFAAAAABAIAAAAEAAAAABBEAAAGEHPPIBBAAACAEEAAAIBBAAACAEEAAAIBBAAACAEEAAAIBAAAACAFPIAAIBPPPPOAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMAMJAAMIKMAACAAAAAFAAAAABAIAAAAEAAAAABBEAAAGEHPPIBBAAACAEEAAAIBBAAACAEEAAAIBBAAACAEEAAAIBBAAACAFPIAAIBPPPPOAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMAMJABPEKMAACAAAAAFAAAAABAIAAAAEAAAAABBEAAAGEHPPIBBAAACAEEAAAIBBAAACAEEAAAIBBAAACAFPIAAIBAAAACAEAAAAIBPPPPOAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMAMJAAGEKMAACAAAAAFAAAAABAIAAAAEAAAAABBEAAAGEHPPIBBAAACAEEAAAIBBAAACAFPIAAIBAAAACAEAAAAIBAAAACAEAAAAIBPPPPOAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMAMJAAGEKMAACAAAAAFAAAAABAIAAAAEAAAAABBEAAAGEHPPIBBAAACAFPIAAIBAAAACAEAAAAIBAAAACAEAAAAIBAAAACAEAAAAIBPPPPOAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMAMJAAGEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA"
  amdata = amdata + "KMAACAAAAAFAAAAABAIAAAAEAAAAABBEAAAHPPPPIBAAAACAEAAAAIBAAAACAEAAAAIBAAAACAEAAAAIBAAAACAEAAAAIBPPPPOAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMAMJABPEKMAABAAAAACIAAAAAAIAAAAEAAAAABBEAAAHPPPPIBAAAACAEAAAAIBAAAACAEAAAAIBAAAACAEAAAAIBAAAACAEAAAAIBPPPPOAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMAMJAAGEKMAAAIAAAAAIIAAAAAIAAAAAAAAAAABEAAAHPPPPIBAAAACAEAAAAIBAAAACAEAAAAIBAAAACAEAAAAIBAAAACAEAAAAIBPPPPOAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMAMJADOIKMAAAAAAAAACAAAAACCAAAAACAAAAABEAAAHPPPPIBAAAACAEAAAAIBAAAACAEAAAAIBAAAACAEAAAAIBAAAACAEAAAAIBPPPPOAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMAMJAAMIKMAAAIAAAAAIIAAAAAIAAAAAAAAAAABEAAAHPPPPIBAAAACAEAAAAIBAAAACAEAAAAIBAAAACAEAAAAIBAAAACAEAAAAIBPPPPOAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMAMJAAMIKMAAAIAAAAAKIAAAAAAAAAAAFAAAAAAAAAAHPPPPIBAAAACAEAAAAIBAAAACAEAAAAIBAAAACAEAAAAIBAAAACAEAAAAIBPPPPOAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMAMJAAMIKMAAAIAAAAAIIAAAAAIAAAAAAAAAAABEAAAHPPPPIBAAAACAEAAAAIBAAAACAEAAAAIBAAAACAEAAAAIBAAAACAEAAAAIBPPPPOAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMAMJAAMIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA"
  amdata = amdata + "KMAAAAAAAAAAAAAAAAIAAAAAIIAAAAAIAAAAAFAAAAPPPPMACAAABAAIAAAEACAAABAAIAAAEACAAABAAIAAAEACAAABAAPPPPMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMAMJAAMIKMAAAAAAAAACAAAAACKAAAAAAAAAAABEAAAAAAAAAAPPPPMACAAABAAIAAAEACAAABAAIAAAEACAAABAAIAAAEACAAABAAPPPPMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMAMJAAMIKMAAAAAAAAACAAAAACCAAAAACAAAAAAAAAAAAFAAAAPPPPMACAAABAAIAAAEACAAABAAIAAAEACAAABAAIAAAEACAAABAAPPPPMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMAMJAAMIKMAAAAAAAAAAAAAAAAAAAAAACAAAAACCAAAAACAAAAABEAAABPPPOAAEAAAIABAAACAAEAAAIABAAACAAEAAAIABAAACAAHPPPIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMAMJAAMIKMAAAAAAAAAAAAAAAAIAAAAAKIAAAAAAAAAAAFAAAAAAAAAABPPPOAAEAAAIABAAACAAEAAAIABAAACAAEAAAIABAAACAAHPPPIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMAMJAAMIKMAAAAAAAAAAAAAAAAIAAAAAIIAAAAAIAAAAAAAAAAABEAAABPPPOAAEAAAIABAAACAAEAAAIABAAACAAEAAAIABAAACAAHPPPIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMAMJAAMIKMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIAAAAAIIAAAAAIAAAAAFAAAADPPPAAAIAAEAACAABAAAIAAEAACAABAAAIAAEAADPPPAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMAMJAAMIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA"
  amdata = amdata + "KMAAAAAAAAAAAAAAAAAAAAAACAAAAACKAAAAAAAAAAABEAAAAAAAAAADPPPAAAIAAEAACAABAAAIAAEAACAABAAAIAAEAADPPPAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMAMJAAMIKMAAAAAAAAAAAAAAAAAAAAAACAAAAACCAAAAACAAAAAAAAAAAAFAAAADPPPAAAIAAEAACAABAAAIAAEAACAABAAAIAAEAADPPPAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMAMJAAMIKMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAAAAACCAAAAACAAAAABEAAAAHPPIAABAACAAAEAAIAABAACAAAEAAIAABPPOAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMAMJAAMIKMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIAAAAAKIAAAAAAAAAAAFAAAAAAAAAAAHPPIAABAACAAAEAAIAABAACAAAEAAIAABPPOAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMAMJAAMIKMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIAAAAAIIAAAAAIAAAAAAAAAAABEAAAAHPPIAABAACAAAEAAIAABAACAAAEAAIAABPPOAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMAMJAAMIKMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIAAAAAIIAAAAAIAAAAAFAAAAAPPMAAACABAAAAIAEAAACABAAAAPPMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMAMJAAMIKMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAAAAACKAAAAAAAAAAABEAAAAAAAAAAAPPMAAACABAAAAIAEAAACABAAAAPPMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMAMJAAMIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA"
  amdata = amdata + "KMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAAAAACCAAAAACAAAAAAAAAAAAFAAAAAPPMAAACABAAAAIAEAAACABAAAAPPMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMAMJAAMIKMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAAAAACCAAAAACAAAAABEAAAABPOAAAAEAIAAABACAAAAHPIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMAMJAAMIKMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIAAAAAKIAAAAAAAAAAAFAAAAAAAAAAABPOAAAAEAIAAABACAAAAHPIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMAMJAAMIKMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIAAAAAIIAAAAAIAAAAAAAAAAABEAAAABPOAAAAEAIAAABACAAAAHPIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMAMJAAMIKMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIAAAAAIIAAAAAIAAAAAFAAAAADPAAAAAIEAAAADPAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMAMJAAMIKMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAAAAACKAAAAAAAAAAABEAAAAAAAAAAADPAAAAAIEAAAADPAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMAMJAAMIKMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAAAAACCAAAAACAAAAAAAAAAAAFAAAAADPAAAAAIEAAAADPAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMAMJAAMIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA"
  amdata = amdata + "KMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAAAAACCAAAAACAAAAABEAAAAAHIAAAABOAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMAMJAAMIKMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIAAAAAKIAAAAAAAAAAAFAAAAAAAAAAAAHIAAAABOAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMAMJAAMIKMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIAAAAAIIAAAAAIAAAAAAAAAAABEAAAAAHIAAAABOAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMAMJAAMIKMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIAAAAAIIAAAAAIAAAAAFAAAAAAMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMAMJAAMIKMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAAABBAAAAABAAAAAAAAAAAACIAAAAAAAAAAAAMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMAMJAAMIKMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIAAAAAIIAAAAAIAAAAAFAAAAAAAAAAAAAMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMAMJAAMIKMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEAAAAAEEAAAAAEAAAAAAAAAAAAKMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMAMJAAMIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA"
  amdata = amdata + "KMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAAABBAAAAABAAAAAAKMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMAMJAAMIKMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEAAAAAAAAAAABFAAAAAAAAAAAAKMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMAMJADOIKMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAAAAAAAAAAAANAAAAAAAAAAAAGMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMAMJAAMIKMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIAAAAAAAAAAADEAAAAAADAAAABEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMAMJAAMIKMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEAAAAAEEAAAAAEAGAAAAAAAAAAKAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMAMJAAMIKMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABFAAAAAAAABAAAEAAAAAAAAAAAAKAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMAMJAAMIKMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEEAAAAAEAAAAAAAAAAAAEAAAAAAAAAAAAKAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMAMJABPEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA"
  amdata = amdata + "KMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABFAAAAAAAAAAAAEAAAAAAAAAAAAKAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMAMJAAMIKMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEEAAAAAEAAAAAAAAAAAAEAAAAAAAAAAAAKAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMAMJADOIKMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABEAAAAAAEAAAAAEAAAAAAAAAAAAKAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMAMJABPEKMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACEAAAAAAEAAAAAEAAAAAAAAAAAAKAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMAMJAAGEKMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABEAAAAAAEAAAAAEAAAAAAAAAAAAKAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMAMJAAGEKMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACEAAAAAAEAAAAAEAAAAAAAAAAAAKAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMAMJAAGEKMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABEAAAAAAEAAAAAEAAAAAAAAAAAAKAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMAMJAAGEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA"
  amdata = amdata + "KMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACEAAAAAAEAAAAAEAAAAAAAAAAAAKAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMAMJAAGEKMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABEAAAAAAEAAAAAEAAAAAAAAAAAAKAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMAMJAAMIKMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEAAAAAEEAAAAAEAAAAAAAAAAAAKAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMAMJAAGEKMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEAAAAAAAAAAAAOAAAAAAAAAAAAKAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMAMJAAGEKMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAAAAAAAAAADIAAAAAKAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMAMJAAGEKMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEAAAAADIAAAAAKAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMAMJAAGEKMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADIAAAAAKAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMAMJAAGEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA"
  amdata = amdata + "KMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADIAAAAAOAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMAMJAAGEKMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMAMJAAMIKMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMAMJAAGEKMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMAMJAAMIKMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMAMJAAGEKMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMAMJAAGEKMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMAMJAAGEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA"
  amdata = amdata + "KMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMAMJAAGEKMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMAMJAAGEKMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMAMJAAGEKMAAAAAAAABACAAAAAAAAADJEKGAAJEMLMACFDCIAAOFCJMACAAAAAAIAAAAAABPPAAAAHPMAAABKPAAAAHOMAAABOPAAAAHPMAAABNHAAAAHPMAAABPPAAAAAAAAAAAAAAAMAMJABPEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA"
  amdata = amdata + "ABPPPPPPODAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA"
  amloaded = 1;
}



##### fLoadWait #####



##### fLoadCheck #####

//wait some more time if file is not yet loaded
if( amloaded == 0 )
{
  gotoAndPlay( "fLoadWait" );
  return;
}

//get number of sectros
sec_cnt = int( amdata.length / (512 * 2) );
if( sec_cnt < 2 )
{
  tfLoadStatus = "ERROR: less than 2 sectos loaded";
  gotoAndStop( "fLoadCheck" );
  return;
}

//check signature in sector 0
signature = "ARCADEmini 26x20/16 ambin 1.0   ";
amsector = amdata.substr( 0, 512 * 2);
for( i = 0, j = 0; i < signature.length; i++, j += 2 )
{
  sig_chr = signature.charCodeAt(i);
  sec_chr = (amsector.charCodeAt( j ) - 65) << 4 | (amsector.charCodeAt( j + 1 ) - 65);
  if( sig_chr != sec_chr )
  {
    tfLoadStatus = "ERROR: signature does not match at position " + i + ": " + sig_chr + " != " + sec_chr;
    gotoAndStop( "fLoadCheck" );
    return;
  }
}

//start converting sectors
sector_no = 0;
sectors = new Array( );



##### fPreload #####

//show current sector number
tfLoadStatus = "loading sector " + (sec_no + 1) + " / " + sec_cnt;

//convert one sector
amsector = amdata.substr( sec_no * 512 * 2, 512 * 2);
sectors[sec_no] = new Array( );
for( i = 0, j = 0; i < 512; i++, j += 2 )
{
  sectors[sec_no][i] = (amsector.charCodeAt( j ) - 65) << 4 | (amsector.charCodeAt( j + 1 ) - 65);
  if( sectors[sec_no][i] < 0 || sectors[sec_no][i] > 255 )
    sectors[sec_no][i] = 0;
}

//next sector
sec_no++;



#####   fpredoad2 #####

//last sector not yet converted
if( sec_no < sec_cnt )
{
  gotoAndPlay( "fPreload" );
  return;
}


##### fInit #####

//load sector sec_no
function load_sector( )
{
  //check number of sector and restart in sector 1 if invalid
  if( sec_no < 1 || sec_no >= sec_cnt )
    sec_no = 1;
  //copy current sector
  sector = sectors[sec_no];
}

//initialize sector buffer
sector = new Array();
for( i = 0; i < 512 + 68; i++ )
  sector[i] = 0;
//start at beginning of sector 1
sec_no = 1;
iptr = 0;
load_sector( );
//ARCADEmini variables
variables = new Array();
for( i = 0; i < 256; i++ )
  variables[i] = 0;
//create overlay pixel buffer
overlay = new Array();
for( y = 0; y < 20; y++ )
{
  overlay[y] = new Array();
  for( x = 0; x < 26; x++ )
    overlay[y][x] = 0;
}
//create visible picture
picture = new Array();
for( y = 0; y < 20; y++ )
{
  picture[y] = new Array();
  for( x = 0; x < 26; x++ )
    picture[y][x] = 0;
}
//create leds
for( y = 0, pos_y = 18, i = 0; y < 20; y++, pos_y += 18 )
{
  for( x = 0, pos_x = 12; x < 26; x++, pos_x += 12, i++ )
  {
    led_id = "led" + i;
    duplicateMovieClip( "led", led_id, 100 + i );
    _root[led_id]._x = pos_x;
    _root[led_id]._y = pos_y;
    _root[led_id]._alpha = 40; //_alpha = <pixel_value> * 4 + 40;
  }
}

//no delay active
delay_end = 0;
delay_active = 0;
delay_wait = 0;

//use current system time
time_offset = 0;

//no keys pressed
keys_state = 0;
keys_pressed = 0;
keys_released = 0;
snes0_state = 0;
snes0_pressed = 0;
snes0_released = 0;
snes1_state = 0;
snes1_pressed = 0;
snes1_released = 0;



##### fRun #####



##### fCommand #####

//-------------------------------------------------------------------------------------------
// JMP_NEXT_SEC
// load the next sector
//-------------------------------------------------------------------------------------------
function JMP_NEXT_SEC( )
{
  sec_no++;
  iptr = 0;
  load_sector( );
}

//-------------------------------------------------------------------------------------------
// JMP_SEC <sectors (4)>
// jump <sectors> sectors further
// - <sectors (4)> is stored in big endian format
//-------------------------------------------------------------------------------------------
function JMP_SEC( )
{
  sec_no += ((sector[iptr+1] * 256 + sector[iptr+2]) * 256 + sector[iptr+3]) * 256 + sector[iptr+4];
  sec_no &= 4294967295;
  iptr = 0;
  load_sector( );
}

//-------------------------------------------------------------------------------------------
// JMP_OFS (bit0 is bit8 of offset) <offset>
// jump to offset
//-------------------------------------------------------------------------------------------
function JMP_OFS( )
{
  iptr = (sector[iptr] & 1) << 8 | sector[iptr+1];
}

//-------------------------------------------------------------------------------------------
// JMP_OFS_SEC (bit0 is bit8 of offset) <offset> <sectors (4)>
// jump to offset and <sectors> sectors further
// - <sectors (4)> is stored in big endian format
//-------------------------------------------------------------------------------------------
function JMP_OFS_SEC( )
{
  sec_no += ((sector[iptr+2] * 256 + sector[iptr+3]) * 256 + sector[iptr+4]) * 256 + sector[iptr+5];
  sec_no &= 4294967295;
  iptr = (sector[iptr] & 1) << 8 | sector[iptr+1];
  load_sector( );
}

//-------------------------------------------------------------------------------------------
// JMP_IND <offset_h> <offset_l> <sectors_hh> <sectors_hl> <sectors_lh> <sectors_ll>
// jump indirect to offset and <sectors> sectors further
//-------------------------------------------------------------------------------------------
function JMP_IND( )
{
  sec_no += ((variables[sector[iptr+3]] * 256 + variables[sector[iptr+4]]) * 256
         + variables[sector[iptr+5]]) * 256 + variables[sector[iptr+6]];
  sec_no &= 4294967295;
  iptr = (variables[sector[iptr+1]] << 8 | variables[sector[iptr+2]]) & 511;
  load_sector( );
}

//-------------------------------------------------------------------------------------------
// JMP_EQ (bit0 is bit8 of offset) <offset> <param1> <param2>
// jump if equal
// jump to offset if <param1> == <param2>
//-------------------------------------------------------------------------------------------
function JMP_EQ( )
{
  if( variables[sector[iptr+2]] == variables[sector[iptr+3]] )
    iptr = (sector[iptr] & 1) << 8 | sector[iptr+1];
  else
    iptr += 4;
}

//-------------------------------------------------------------------------------------------
// JMP_EQ_C (bit0 is bit8 of offset) <offset> <param> <constant>
// jump if equal to constant
// jump to offset if <param> == <constant>
//-------------------------------------------------------------------------------------------
function JMP_EQ_C( )
{
  if( variables[sector[iptr+2]] == sector[iptr+3] )
    iptr = (sector[iptr] & 1) << 8 | sector[iptr+1];
  else
    iptr += 4;
}

//-------------------------------------------------------------------------------------------
// JMP_NEQ (bit0 is bit8 of offset) <offset> <param1> <param2>
// jump if not equal
// jump to offset if <param1> != <param2>
//-------------------------------------------------------------------------------------------
function JMP_NEQ( )
{
  if( variables[sector[iptr+2]] != variables[sector[iptr+3]] )
    iptr = (sector[iptr] & 1) << 8 | sector[iptr+1];
  else
    iptr += 4;
}

//-------------------------------------------------------------------------------------------
// JMP_NEQ_C (bit0 is bit8 of offset) <offset> <param> <constant>
// jump if not equal to constant
// jump to offset if <param> != <constant>
//-------------------------------------------------------------------------------------------
function JMP_NEQ_C( )
{
  if( variables[sector[iptr+2]] != sector[iptr+3] )
    iptr = (sector[iptr] & 1) << 8 | sector[iptr+1];
  else
    iptr += 4;
}

//-------------------------------------------------------------------------------------------
// JMP_GT (bit0 is bit8 of offset) <offset> <param1> <param2>
// jump if greater than
// jump to offset if <param1> > <param2>
//-------------------------------------------------------------------------------------------
function JMP_GT( )
{
  if( variables[sector[iptr+2]] > variables[sector[iptr+3]] )
    iptr = (sector[iptr] & 1) << 8 | sector[iptr+1];
  else
    iptr += 4;
}

//-------------------------------------------------------------------------------------------
// JMP_GT_C (bit0 is bit8 of offset) <offset> <param> <constant>
// jump if greater than
// jump to offset if <param> > <constant>
//-------------------------------------------------------------------------------------------
function JMP_GT_C( )
{
  if( variables[sector[iptr+2]] > sector[iptr+3] )
    iptr = (sector[iptr] & 1) << 8 | sector[iptr+1];
  else
    iptr += 4;
}

//-------------------------------------------------------------------------------------------
// JMP_NGT (bit0 is bit8 of offset) <offset> <param1> <param2>
// jump if not greater than
// jump to offset if <param1> <= <param2>
//-------------------------------------------------------------------------------------------
function JMP_NGT( )
{
  if( variables[sector[iptr+2]] <= variables[sector[iptr+3]] )
    iptr = (sector[iptr] & 1) << 8 | sector[iptr+1];
  else
    iptr += 4;
}

//-------------------------------------------------------------------------------------------
// JMP_NGT_C (bit0 is bit8 of offset) <offset> <param> <constant>
// jump if not greater than
// jump to offset if <param> <= <constant>
//-------------------------------------------------------------------------------------------
function JMP_NGT_C( )
{
  if( variables[sector[iptr+2]] <= sector[iptr+3] )
    iptr = (sector[iptr] & 1) << 8 | sector[iptr+1];
  else
    iptr += 4;
}

//-------------------------------------------------------------------------------------------
// JMP_LT (bit0 is bit8 of offset) <offset> <param1> <param2>
// jump if less than
// jump to offset if <param1> < <param2>
//-------------------------------------------------------------------------------------------
function JMP_LT( )
{
  if( variables[sector[iptr+2]] < variables[sector[iptr+3]] )
    iptr = (sector[iptr] & 1) << 8 | sector[iptr+1];
  else
    iptr += 4;
}

//-------------------------------------------------------------------------------------------
// JMP_LT_C (bit0 is bit8 of offset) <offset> <param> <constant>
// jump if less than
// jump to offset if <param> < <constant>
//-------------------------------------------------------------------------------------------
function JMP_LT_C( )
{
  if( variables[sector[iptr+2]] < sector[iptr+3] )
    iptr = (sector[iptr] & 1) << 8 | sector[iptr+1];
  else
    iptr += 4;
}

//-------------------------------------------------------------------------------------------
// JMP_NLT (bit0 is bit8 of offset) <offset> <param1> <param2>
// jump if not less than
// jump to offset if <param1> >= <param2>
//-------------------------------------------------------------------------------------------
function JMP_NLT( )
{
  if( variables[sector[iptr+2]] >= variables[sector[iptr+3]] )
    iptr = (sector[iptr] & 1) << 8 | sector[iptr+1];
  else
    iptr += 4;
}

//-------------------------------------------------------------------------------------------
// JMP_NLT_C (bit0 is bit8 of offset) <offset> <param> <constant>
// jump if not less than
// jump to offset if <param> >= <constant>
//-------------------------------------------------------------------------------------------
function JMP_NLT_C( )
{
  if( variables[sector[iptr+2]] >= sector[iptr+3] )
    iptr = (sector[iptr] & 1) << 8 | sector[iptr+1];
  else
    iptr += 4;
}

//-------------------------------------------------------------------------------------------
// JMP_GTS (bit0 is bit8 of offset) <offset> <param1> <param2>
// jump if greater (signed) than
// jump to offset if <param1> > <param2>
//-------------------------------------------------------------------------------------------
function JMP_GTS( )
{
  val1 = variables[sector[iptr+2]];
  val2 = variables[sector[iptr+3]];
  if( val1 >= 128 ) val1 -= 256;
  if( val2 >= 128 ) val2 -= 256;
  if( val1 > val2 )
    iptr = (sector[iptr] & 1) << 8 | sector[iptr+1];
  else
    iptr += 4;
}

//-------------------------------------------------------------------------------------------
// JMP_GTS_C (bit0 is bit8 of offset) <offset> <param> <constant>
// jump if greater (signed) than
// jump to offset if <param> > <constant>
//-------------------------------------------------------------------------------------------
function JMP_GTS_C( )
{
  val1 = variables[sector[iptr+2]];
  val2 = sector[iptr+3];
  if( val1 >= 128 ) val1 -= 256;
  if( val2 >= 128 ) val2 -= 256;
  if( val1 > val2 )
    iptr = (sector[iptr] & 1) << 8 | sector[iptr+1];
  else
    iptr += 4;
}

//-------------------------------------------------------------------------------------------
// JMP_NGTS (bit0 is bit8 of offset) <offset> <param1> <param2>
// jump if not greater (signed) than
// jump to offset if <param1> <= <param2>
//-------------------------------------------------------------------------------------------
function JMP_NGTS( )
{
  val1 = variables[sector[iptr+2]];
  val2 = variables[sector[iptr+3]];
  if( val1 >= 128 ) val1 -= 256;
  if( val2 >= 128 ) val2 -= 256;
  if( val1 <= val2 )
    iptr = (sector[iptr] & 1) << 8 | sector[iptr+1];
  else
    iptr += 4;
}

//-------------------------------------------------------------------------------------------
// JMP_NGTS_C (bit0 is bit8 of offset) <offset> <param> <constant>
// jump if not greater than
// jump to offset if <param> <= <constant>
//-------------------------------------------------------------------------------------------
function JMP_NGTS_C( )
{
  val1 = variables[sector[iptr+2]];
  val2 = sector[iptr+3];
  if( val1 >= 128 ) val1 -= 256;
  if( val2 >= 128 ) val2 -= 256;
  if( val1 <= val2 )
    iptr = (sector[iptr] & 1) << 8 | sector[iptr+1];
  else
    iptr += 4;
}

//-------------------------------------------------------------------------------------------
// JMP_LTS (bit0 is bit8 of offset) <offset> <param1> <param2>
// jump if less (signed) than
// jump to offset if <param1> < <param2>
//-------------------------------------------------------------------------------------------
function JMP_LTS( )
{
  val1 = variables[sector[iptr+2]];
  val2 = variables[sector[iptr+3]];
  if( val1 >= 128 ) val1 -= 256;
  if( val2 >= 128 ) val2 -= 256;
  if( val1 < val2 )
    iptr = (sector[iptr] & 1) << 8 | sector[iptr+1];
  else
    iptr += 4;
}

//-------------------------------------------------------------------------------------------
// JMP_LTS_C (bit0 is bit8 of offset) <offset> <param> <constant>
// jump if less (signed) than
// jump to offset if <param> < <constant>
//-------------------------------------------------------------------------------------------
function JMP_LTS_C( )
{
  val1 = variables[sector[iptr+2]];
  val2 = sector[iptr+3];
  if( val1 >= 128 ) val1 -= 256;
  if( val2 >= 128 ) val2 -= 256;
  if( val1 < val2 )
    iptr = (sector[iptr] & 1) << 8 | sector[iptr+1];
  else
    iptr += 4;
}

//-------------------------------------------------------------------------------------------
// JMP_NLTS (bit0 is bit8 of offset) <offset> <param1> <param2>
// jump if not less (signed) than
// jump to offset if <param1> >= <param2>
//-------------------------------------------------------------------------------------------
function JMP_NLTS( )
{
  val1 = variables[sector[iptr+2]];
  val2 = variables[sector[iptr+3]];
  if( val1 >= 128 ) val1 -= 256;
  if( val2 >= 128 ) val2 -= 256;
  if( val1 >= val2 )
    iptr = (sector[iptr] & 1) << 8 | sector[iptr+1];
  else
    iptr += 4;
}

//-------------------------------------------------------------------------------------------
// JMP_NLTS_C (bit0 is bit8 of offset) <offset> <param> <constant>
// jump if not less (signed) than
// jump to offset if <param> >= <constant>
//-------------------------------------------------------------------------------------------
function JMP_NLTS_C( )
{
  val1 = variables[sector[iptr+2]];
  val2 = sector[iptr+3];
  if( val1 >= 128 ) val1 -= 256;
  if( val2 >= 128 ) val2 -= 256;
  if( val1 >= val2 )
    iptr = (sector[iptr] & 1) << 8 | sector[iptr+1];
  else
    iptr += 4;
}

//-------------------------------------------------------------------------------------------
// JMP_AND_Z (bit0 is bit8 of offset) <offset> <param1> <param2>
// jump if bitwise and is zero
// jump to offset if <param1> AND <param2> == 0
//-------------------------------------------------------------------------------------------
function JMP_AND_Z( )
{
  if( (variables[sector[iptr+2]] & variables[sector[iptr+3]]) == 0 )
    iptr = (sector[iptr] & 1) << 8 | sector[iptr+1];
  else
    iptr += 4;
}

//-------------------------------------------------------------------------------------------
// JMP_AND_Z_C (bit0 is bit8 of offset) <offset> <param> <constant>
// jump if bitwise and is zero
// jump to offset if <param> AND <constant> == 0
//-------------------------------------------------------------------------------------------
function JMP_AND_Z_C( )
{
  if( (variables[sector[iptr+2]] & sector[iptr+3]) == 0 )
    iptr = (sector[iptr] & 1) << 8 | sector[iptr+1];
  else
    iptr += 4;
}

//-------------------------------------------------------------------------------------------
// JMP_AND_NZ (bit0 is bit8 of offset) <offset> <param1> <param2>
// jump if bitwise and is not zero
// jump to offset if <param1> AND <param2> != 0
//-------------------------------------------------------------------------------------------
function JMP_AND_NZ( )
{
  if( (variables[sector[iptr+2]] & variables[sector[iptr+3]]) != 0 )
    iptr = (sector[iptr] & 1) << 8 | sector[iptr+1];
  else
    iptr += 4;
}

//-------------------------------------------------------------------------------------------
// JMP_AND_NZ_C (bit0 is bit8 of offset) <offset> <param> <constant>
// jump if bitwise and is not zero
// jump to offset if <param> AND <constant> != 0
//-------------------------------------------------------------------------------------------
function JMP_AND_NZ_C( )
{
  if( (variables[sector[iptr+2]] & sector[iptr+3]) != 0 )
    iptr = (sector[iptr] & 1) << 8 | sector[iptr+1];
  else
    iptr += 4;
}

//-------------------------------------------------------------------------------------------
// JMP_OR_M (bit0 is bit8 of offset) <offset> <param1> <param2>
// jump if bitwise or is maximum
// jump to offset if <param1> OR <param2> == 0xFF
//-------------------------------------------------------------------------------------------
function JMP_OR_M( )
{
  if( (variables[sector[iptr+2]] | variables[sector[iptr+3]]) == 255 )
    iptr = (sector[iptr] & 1) << 8 | sector[iptr+1];
  else
    iptr += 4;
}

//-------------------------------------------------------------------------------------------
// JMP_OR_M_C (bit0 is bit8 of offset) <offset> <param> <constant>
// jump if bitwise or is maximum
// jump to offset if <param> OR <constant> == 0xFF
//-------------------------------------------------------------------------------------------
function JMP_OR_M_C( )
{
  if( (variables[sector[iptr+2]] | sector[iptr+3]) == 255 )
    iptr = (sector[iptr] & 1) << 8 | sector[iptr+1];
  else
    iptr += 4;
}

//-------------------------------------------------------------------------------------------
// JMP_OR_NM (bit0 is bit8 of offset) <offset> <param1> <param2>
// jump if bitwise or is not maximum
// jump to offset if <param1> OR <param2> != 0xFF
//-------------------------------------------------------------------------------------------
function JMP_OR_NM( )
{
  if( (variables[sector[iptr+2]] | variables[sector[iptr+3]]) != 255 )
    iptr = (sector[iptr] & 1) << 8 | sector[iptr+1];
  else
    iptr += 4;
}

//-------------------------------------------------------------------------------------------
// JMP_OR_NM_C (bit0 is bit8 of offset) <offset> <param> <constant>
// jump if bitwise or is not maximum
// jump to offset if <param> OR <constant> != 0xFF
//-------------------------------------------------------------------------------------------
function JMP_OR_NM_C( )
{
  if( (variables[sector[iptr+2]] | sector[iptr+3]) != 255 )
    iptr = (sector[iptr] & 1) << 8 | sector[iptr+1];
  else
    iptr += 4;
}

//-------------------------------------------------------------------------------------------
// MOV <source> <dest>
// move
// write contents of source into dest
//-------------------------------------------------------------------------------------------
function MOV( )
{
  variables[sector[iptr+2]] = variables[sector[iptr+1]];
  iptr += 3;
}

//-------------------------------------------------------------------------------------------
// MOV_C <constant> <dest>
// move constant
// write constant into dest
//-------------------------------------------------------------------------------------------
function MOV_C( )
{
  variables[sector[iptr+2]] = sector[iptr+1];
  iptr += 3;
}

//-------------------------------------------------------------------------------------------
// MOV2 <source1> <dest1> <source2> <dest2>
// move 2
// write contents of source<x> into dest<x>
//-------------------------------------------------------------------------------------------
function MOV2( )
{
  variables[sector[iptr+2]] = variables[sector[iptr+1]];
  variables[sector[iptr+4]] = variables[sector[iptr+3]];
  iptr += 5;
}

//-------------------------------------------------------------------------------------------
// MOV2_C <constant1> <dest1> <constant2> <dest2>
// move 2 constants
// write constant<x> into dest<x>
//-------------------------------------------------------------------------------------------
function MOV2_C( )
{
  variables[sector[iptr+2]] = sector[iptr+1];
  variables[sector[iptr+4]] = sector[iptr+3];
  iptr += 5;
}

//-------------------------------------------------------------------------------------------
// MOV4 <source1> <dest1> ... <source4> <dest4>
// move 4
// write contents of source<x> into dest<x>
//-------------------------------------------------------------------------------------------
function MOV4( )
{
  variables[sector[iptr+2]] = variables[sector[iptr+1]];
  variables[sector[iptr+4]] = variables[sector[iptr+3]];
  variables[sector[iptr+6]] = variables[sector[iptr+5]];
  variables[sector[iptr+8]] = variables[sector[iptr+7]];
  iptr += 9;
}

//-------------------------------------------------------------------------------------------
// MOV4_C <constant1> <dest1> ... <constant4> <dest4>
// move 4 constants
// write constant<x> into dest<x>
//-------------------------------------------------------------------------------------------
function MOV4_C( )
{
  variables[sector[iptr+2]] = sector[iptr+1];
  variables[sector[iptr+4]] = sector[iptr+3];
  variables[sector[iptr+6]] = sector[iptr+5];
  variables[sector[iptr+8]] = sector[iptr+7];
  iptr += 9;
}

//-------------------------------------------------------------------------------------------
// RD_I <addr> <dest>
// read indirect
// write contents of variable pointed to by addr into dest
//-------------------------------------------------------------------------------------------
function RD_I( )
{
  variables[sector[iptr+2]] = variables[variables[sector[iptr+1]]];
  iptr += 3;
}

//-------------------------------------------------------------------------------------------
// WR_I <source> <addr>
// write indirect
// write contents of source into variable pointed to by addr
//-------------------------------------------------------------------------------------------
function WR_I( )
{
  variables[variables[sector[iptr+2]]] = variables[sector[iptr+1]];
  iptr += 3;
}

//-------------------------------------------------------------------------------------------
// RD_S <offset_h> <offset_l> <dest>
// read from current sector
// write byte at offset of current sector into dest
//-------------------------------------------------------------------------------------------
function RD_S( )
{
  addr = (variables[sector[iptr+1]] << 8 | variables[sector[iptr+2]]) & 511;
  variables[variables[sector[iptr+3]]] = sector[addr];
  iptr += 4;
}

//-------------------------------------------------------------------------------------------
// ADD <source1> <source2> <dest>
// add
// write sum of contents of source1 and contents of source2 into dest
//-------------------------------------------------------------------------------------------
function ADD( )
{
  variables[sector[iptr+3]] = (variables[sector[iptr+1]] + variables[sector[iptr+2]]) & 255;
  iptr += 4;
}

//-------------------------------------------------------------------------------------------
// ADD_C <constant> <source> <dest>
// add constant
// write sum of constant and contents of source into dest
//-------------------------------------------------------------------------------------------
function ADD_C( )
{
  variables[sector[iptr+3]] = (sector[iptr+1] + variables[sector[iptr+2]]) & 255;
  iptr += 4;
}

//-------------------------------------------------------------------------------------------
// ADDC <source1> <source2> <carry_in> <dest> <carry_out>
// add (with carry)
// write sum of contents of source1 and contents of source2 into dest
// bit 0 of carry_in is also included in the sum
// carry_out is 0x01 if the result is >= 0x100, 0x00 otherwise
//-------------------------------------------------------------------------------------------
function ADDC( )
{
  val = variables[sector[iptr+1]] + variables[sector[iptr+2]] + (variables[sector[iptr+3]] & 1);
  variables[sector[iptr+4]] = val & 255;
  variables[sector[iptr+5]] = (val >= 256) ? 1 : 0;
  iptr += 6;
}

//-------------------------------------------------------------------------------------------
// ADDC_C <constant> <source> <carry_in> <dest> <carry_out>
// add constant (with carry)
// write sum of constant and contents of source into dest
// bit 0 of carry_in is also included in the sum
// carry_out is 0x01 if the result is >= 0x100, 0x00 otherwise
//-------------------------------------------------------------------------------------------
function ADDC_C( )
{
  val = sector[iptr+1] + variables[sector[iptr+2]] + (variables[sector[iptr+3]] & 1);
  variables[sector[iptr+4]] = val & 255;
  variables[sector[iptr+5]] = (val >= 256) ? 1 : 0;
  iptr += 6;
}

//-------------------------------------------------------------------------------------------
// SUB <source1> <source2> <dest>
// subtract
// write difference of contents of source1 minus contents of source2 into dest
//-------------------------------------------------------------------------------------------
function SUB( )
{
  variables[sector[iptr+3]] = (variables[sector[iptr+1]] + 256 - variables[sector[iptr+2]]) & 255;
  iptr += 4;
}

//-------------------------------------------------------------------------------------------
// SUB_C <constant> <source> <dest>
// subtract from constant
// write difference of constant minus contents of source into dest
//-------------------------------------------------------------------------------------------
function SUB_C( )
{
  variables[sector[iptr+3]] = (sector[iptr+1] + 256 - variables[sector[iptr+2]]) & 255;
  iptr += 4;
}

//-------------------------------------------------------------------------------------------
// SUBB <source1> <source2> <borrow_in> <dest> <borrow_out>
// subtract (with borrow)
// write difference of contents of source1 minus contents of source2 into dest
// bit 0 of borrow_in is also subtracted
// borrow_out is 0x01 if the result is < 0x00, 0x00 otherwise
//-------------------------------------------------------------------------------------------
function SUBB( )
{
  val = variables[sector[iptr+1]] - variables[sector[iptr+2]] - (variables[sector[iptr+3]] & 1)
  variables[sector[iptr+4]] = (256 + val) & 255;
  variables[sector[iptr+5]] = (val < 0) ? 1 : 0;
  iptr += 6;
}

//-------------------------------------------------------------------------------------------
// SUBB_C <constant> <source> <borrow_in> <dest> <borrow_out>
// subtract from constant (with borrow)
// write difference of constant minus contents of source into dest
//-------------------------------------------------------------------------------------------
function SUBB_C( )
{
  val = sector[iptr+1] - variables[sector[iptr+2]] - (variables[sector[iptr+3]] & 1)
  variables[sector[iptr+4]] = (256 + val) & 255;
  variables[sector[iptr+5]] = (val < 0) ? 1 : 0;
  iptr += 6;
}

//-------------------------------------------------------------------------------------------
// MUL <source1> <source2> <dest_h> <dest_l>
// multiply
// write product of contents of source1 and contents of source2 into dest_h and dest_l
//-------------------------------------------------------------------------------------------
function MUL( )
{
  val = variables[sector[iptr+1]] * variables[sector[iptr+2]];
  variables[sector[iptr+3]] = (val >> 8) & 255;
  variables[sector[iptr+4]] = val & 255;
  iptr += 5;
}

//-------------------------------------------------------------------------------------------
// MUL_C <constant> <source> <dest_h> <dest_l>
// multiply with constant
// write product of constant and contents of source into dest_h and dest_l
//-------------------------------------------------------------------------------------------
function MUL_C( )
{
  val = sector[iptr+1] * variables[sector[iptr+2]];
  variables[sector[iptr+3]] = (val >> 8) & 255;
  variables[sector[iptr+4]] = val & 255;
  iptr += 5;
}

//-------------------------------------------------------------------------------------------
// MULS <source1> <source2> <dest_h> <dest_l>
// multiply (signed)
// write product of contents of source1 and contents of source2 into dest_h and dest_l
//-------------------------------------------------------------------------------------------
function MULS( )
{
  val1 = variables[sector[iptr+1]];
  val2 = variables[sector[iptr+2]];
  if( val1 >= 128 ) val1 -= 256;
  if( val2 >= 128 ) val2 -= 256;
  val = val1 * val2;
  if( val < 0 ) val += 65536;
  variables[sector[iptr+3]] = (val >> 8) & 255;
  variables[sector[iptr+4]] = val & 255;
  iptr += 5;
}

//-------------------------------------------------------------------------------------------
// MULS_C <constant> <source> <dest_h> <dest_l>
// multiply with constant (signed)
// write product of constant and contents of source into dest_h and dest_l
//-------------------------------------------------------------------------------------------
function MULS_C( )
{
  val1 = sector[iptr+1];
  val2 = variables[sector[iptr+2]];
  if( val1 >= 128 ) val1 -= 256;
  if( val2 >= 128 ) val2 -= 256;
  val = val1 * val2;
  if( val < 0 ) val += 65536;
  variables[sector[iptr+3]] = (val >> 8) & 255;
  variables[sector[iptr+4]] = val & 255;
  iptr += 5;
}

//-------------------------------------------------------------------------------------------
// DIV <source_h> <source_l> <divisor> <quotient> <remainder>
// divide
// calculate quotient and remainder of division of source by divisor
//-------------------------------------------------------------------------------------------
function DIV( )
{
  source = variables[sector[iptr+1]] << 8 | variables[sector[iptr+2]];
  divisor = variables[sector[iptr+3]];
  quotient = (source / divisor) & 255;
  remainder = (source % divisor) & 255;
  variables[sector[iptr+4]] = quotient;
  variables[sector[iptr+5]] = remainder;
  iptr += 6;
}

//-------------------------------------------------------------------------------------------
// DIVS <source_h> <source_l> <divisor> <quotient> <remainder>
// divide (signed)
// calculate quotient and remainder of division of source by divisor
//-------------------------------------------------------------------------------------------
function DIVS( )
{
  source = variables[sector[iptr+1]] << 8 | variables[sector[iptr+2]];
  divisor = variables[sector[iptr+3]];
  if( source >= 32768 ) source -= 65536;
  if( divisor >= 128 ) divisor -= 256;
  quotient = (source / divisor);
  remainder = (source % divisor);
  quotient = quotient % 256;
  if( quotient < 0 ) quotient += 256;
  if( remainder < 0) remainder += 256;
  variables[sector[iptr+4]] = quotient;
  variables[sector[iptr+5]] = remainder;
  iptr += 6;
}

//-------------------------------------------------------------------------------------------
// AND <source1> <source2> <dest>
// bitwise and
// write bitwise and of contents of source1 and contents of source2 into dest
//-------------------------------------------------------------------------------------------
function AND( )
{
  variables[sector[iptr+3]] = (variables[sector[iptr+1]] & variables[sector[iptr+2]]) & 255;
  iptr += 4;
}

//-------------------------------------------------------------------------------------------
// AND_C <constant> <source> <dest>
// and bitwise with constant
// write bitwise and of constant and contents of source into dest
//-------------------------------------------------------------------------------------------
function AND_C( )
{
  variables[sector[iptr+3]] = (sector[iptr+1] & variables[sector[iptr+2]]) & 255;
  iptr += 4;
}

//-------------------------------------------------------------------------------------------
// OR <source1> <source2> <dest>
// bitwise or
// write bitwise or of contents of source1 and contents of source2 into dest
//-------------------------------------------------------------------------------------------
function OR( )
{
  variables[sector[iptr+3]] = (variables[sector[iptr+1]] | variables[sector[iptr+2]]) & 255;
  iptr += 4;
}

//-------------------------------------------------------------------------------------------
// OR_C <constant> <source> <dest>
// or bitwise with constant
// write bitwise or of constant and contents of source into dest
//-------------------------------------------------------------------------------------------
function OR_C( )
{
  variables[sector[iptr+3]] = (sector[iptr+1] | variables[sector[iptr+2]]) & 255;
  iptr += 4;
}

//-------------------------------------------------------------------------------------------
// XOR <source1> <source2> <dest>
// bitwise xor
// write bitwise xor of contents of source1 and contents of source2 into dest
//-------------------------------------------------------------------------------------------
function XOR( )
{
  variables[sector[iptr+3]] = (variables[sector[iptr+1]] ^ variables[sector[iptr+2]]) & 255;
  iptr += 4;
}

//-------------------------------------------------------------------------------------------
// XOR_C <constant> <source> <dest>
// xor bitwise with constant
// write bitwise xor of constant and contents of source into dest
//-------------------------------------------------------------------------------------------
function XOR_C( )
{
  variables[sector[iptr+3]] = (sector[iptr+1] ^ variables[sector[iptr+2]]) & 255;
  iptr += 4;
}

//-------------------------------------------------------------------------------------------
// SHL <bits> <source> <dest>
// shift left
// shift left contents of source <bits> bits and write result into dest
//-------------------------------------------------------------------------------------------
function SHL( )
{
  variables[sector[iptr+3]] = (variables[sector[iptr+2]] << variables[sector[iptr+1]]) & 255;
  iptr += 4;
}

//-------------------------------------------------------------------------------------------
// SHL_C <constant> <source> <dest>
// shift left constant number of bits
// shift left contents of source <constant> bits and write result into dest
//-------------------------------------------------------------------------------------------
function SHL_C( )
{
  variables[sector[iptr+3]] = (variables[sector[iptr+2]] << sector[iptr+1]) & 255;
  iptr += 4;
}

//-------------------------------------------------------------------------------------------
// SHR <bits> <source> <dest>
// shift right
// shift right contents of source <bits> bits and write result into dest
//-------------------------------------------------------------------------------------------
function SHR( )
{
  variables[sector[iptr+3]] = (variables[sector[iptr+2]] >> variables[sector[iptr+1]]) & 255;
  iptr += 4;
}

//-------------------------------------------------------------------------------------------
// SHR_C <constant> <source> <dest>
// shift right constant number of bits
// shift right contents of source <constant> bits and write result into dest
//-------------------------------------------------------------------------------------------
function SHR_C( )
{
  variables[sector[iptr+3]] = (variables[sector[iptr+2]] >> sector[iptr+1]) & 255;
  iptr += 4;
}

//-------------------------------------------------------------------------------------------
// ROL <bits> <source> <dest>
// rotate left
// rotate left contents of source <bits> bits and write result into dest
//-------------------------------------------------------------------------------------------
function ROL( )
{
  bits = variables[sector[iptr+1]] & 7;
  val = variables[sector[iptr+2]] & 255;
  variables[sector[iptr+3]] = (val << bits) | (val >> (8 - bits));
  iptr += 4;
}

//-------------------------------------------------------------------------------------------
// ROL_C <constant> <source> <dest>
// rotate left constant number of bits
// rotate left contents of source <constant> bits and write result into dest
//-------------------------------------------------------------------------------------------
function ROL_C( )
{
  bits = sector[iptr+1] & 7;
  val = variables[sector[iptr+2]] & 255;
  variables[sector[iptr+3]] = (val << bits) | (val >> (8 - bits));
  iptr += 4;
}

//-------------------------------------------------------------------------------------------
// ROR <bits> <source> <dest>
// rotate right
// rotate right contents of source <bits> bits and write result into dest
//-------------------------------------------------------------------------------------------
function ROR( )
{
  bits = variables[sector[iptr+1]] & 7;
  val = variables[sector[iptr+2]] & 255;
  variables[sector[iptr+3]] = (val >> bits) | (val << (8 - bits));
  iptr += 4;
}

//-------------------------------------------------------------------------------------------
// ROR_C <constant> <source> <dest>
// rotate right constant number of bits
// rotate right contents of source <constant> bits and write result into dest
//-------------------------------------------------------------------------------------------
function ROR_C( )
{
  bits = sector[iptr+1] & 7;
  val = variables[sector[iptr+2]] & 255;
  variables[sector[iptr+3]] = (val >> bits) | (val << (8 - bits));
  iptr += 4;
}

//-------------------------------------------------------------------------------------------
// RD_PIX <var_x> <var_y> <dest>
// read pixel
// write the value of the pixel at position var_x, var_y into dest
//-------------------------------------------------------------------------------------------
function RD_PIX( )
{
  x = variables[sector[iptr+1]];
  y = variables[sector[iptr+2]];
  if( x < 26 && y < 20 )
    variables[sector[iptr+3]] = picture[y][x];
  else
    variables[sector[iptr+3]] = 0;
  iptr += 4;
}

//-------------------------------------------------------------------------------------------
// RD_PIX_C <con_x> <con_y> <dest>
// read constant pixel
// write the value of the pixel at position con_x, con_y into dest
//-------------------------------------------------------------------------------------------
function RD_PIX_C( )
{
  x = sector[iptr+1];
  y = sector[iptr+2];
  if( x < 26 && y < 20 )
    variables[sector[iptr+3]] = picture[y][x];
  else
    variables[sector[iptr+3]] = 0;
  iptr += 4;
}

//-------------------------------------------------------------------------------------------
// RD_OVP <var_x> <var_y> <dest>
// read overlay pixel
// write the value of the overlay pixel at position var_x, var_y into dest
//-------------------------------------------------------------------------------------------
function RD_OVP( )
{
  x = variables[sector[iptr+1]];
  y = variables[sector[iptr+2]];
  if( x < 26 && y < 20 )
    variables[sector[iptr+3]] = overlay[y][x];
  else
    variables[sector[iptr+3]] = 0;
  iptr += 4;
}

//-------------------------------------------------------------------------------------------
// RD_OVP_C <con_x> <con_y> <dest>
// read constant overlay pixel
// write the value of the overlay pixel at position con_x, con_y into dest
//-------------------------------------------------------------------------------------------
function RD_OVP_C( )
{
  x = sector[iptr+1];
  y = sector[iptr+2];
  if( x < 26 && y < 20 )
    variables[sector[iptr+3]] = overlay[y][x];
  else
    variables[sector[iptr+3]] = 0;
  iptr += 4;
}

//-------------------------------------------------------------------------------------------
// WR_PIX <var_x> <var_y> <source>
// write pixel
// write the value of source into the pixel at position var_x, var_y
//-------------------------------------------------------------------------------------------
function WR_PIX( )
{
  x = variables[sector[iptr+1]];
  y = variables[sector[iptr+2]];
  if( x < 26 && y < 20 )
    picture[y][x] = variables[sector[iptr+3]] & 15;
  iptr += 4;
}

//-------------------------------------------------------------------------------------------
// WR_PIX_C <con_x> <con_y> <source>
// write constant pixel
// write the value of source into the pixel at position con_x, con_y
//-------------------------------------------------------------------------------------------
function WR_PIX_C( )
{
  x = sector[iptr+1];
  y = sector[iptr+2];
  if( x < 26 && y < 20 )
    picture[y][x] = variables[sector[iptr+3]] & 15;
  iptr += 4;
}

//-------------------------------------------------------------------------------------------
// WR_OVP <var_x> <var_y> <source>
// write overlay pixel
// write the value of source into the overlay pixel at position var_x, var_y
//-------------------------------------------------------------------------------------------
function WR_OVP( )
{
  x = variables[sector[iptr+1]];
  y = variables[sector[iptr+2]];
  if( x < 26 && y < 20 )
    overlay[y][x] = variables[sector[iptr+3]] & 15;
  iptr += 4;
}

//-------------------------------------------------------------------------------------------
// WR_OVP_C <con_x> <con_y> <source>
// write constant overlay pixel
// write the value of source into the overlay pixel at position con_x, con_y
//-------------------------------------------------------------------------------------------
function WR_OVP_C( )
{
  x = sector[iptr+1];
  y = sector[iptr+2];
  if( x < 26 && y < 20 )
    overlay[y][x] = variables[sector[iptr+3]] & 15;
  iptr += 4;
}

//-------------------------------------------------------------------------------------------
// WR_PIX_CO <var_x> <var_y> <constant>
// set pixel to color
// write const_source into the pixel at position var_x, var_y
//-------------------------------------------------------------------------------------------
function WR_PIX_CO( )
{
  x = variables[sector[iptr+1]];
  y = variables[sector[iptr+2]];
  if( x < 26 && y < 20 )
    picture[y][x] = sector[iptr+3] & 15;
  iptr += 4;
}

//-------------------------------------------------------------------------------------------
// WR_PIX_CO_C <con_x> <con_y> <constant>
// set constant pixel to color
// write constant into the pixel at position con_x, con_y
//-------------------------------------------------------------------------------------------
function WR_PIX_CO_C( )
{
  x = sector[iptr+1];
  y = sector[iptr+2];
  if( x < 26 && y < 20 )
    picture[y][x] = sector[iptr+3] & 15;
  iptr += 4;
}

//-------------------------------------------------------------------------------------------
// WR_OVP_CO <var_x> <var_y> <constant>
// set overlay pixel to color
// write constant into the overlay pixel at position var_x, var_y
//-------------------------------------------------------------------------------------------
function WR_OVP_CO( )
{
  x = variables[sector[iptr+1]];
  y = variables[sector[iptr+2]];
  if( x < 26 && y < 20 )
    overlay[y][x] = sector[iptr+3] & 15;
  iptr += 4;
}

//-------------------------------------------------------------------------------------------
// WR_OVP_CO_C <con_x> <con_y> <constant>
// set constant overlay pixel to color
// write constant into the overlay pixel at position con_x, con_y
//-------------------------------------------------------------------------------------------
function WR_OVP_CO_C( )
{
  x = sector[iptr+1];
  y = sector[iptr+2];
  if( x < 26 && y < 20 )
    overlay[y][x] = sector[iptr+3] & 15;
  iptr += 4;
}

//-------------------------------------------------------------------------------------------
// WR_PIX_LINE <var_y> <pixel_0_1> <pixel_2_3> ... <pixel_24_25>
// write pixel line
// two pixels are packed in one byte - e.g. pixel_0_1=0xF0 turns on pixel 0 and off pixel 1
//-------------------------------------------------------------------------------------------
function WR_PIX_LINE( )
{
  y = variables[sector[iptr+1]];
  if( y < 20 )
    for( x = 0; x < 26; x++ )
      picture[y][x] = (sector[iptr + 2 + (x >> 1)] >> ((x & 1) ? 0 : 4)) & 15;
  iptr += 15;
}

//-------------------------------------------------------------------------------------------
// WR_PIX_LINE_C <con_y> <pixel_0_1> <pixel_2_3> ... <pixel_24_25>
// write constant pixel line
// two pixels are packed in one byte - e.g. pixel_0_1=0xF0 turns on pixel 0 and off pixel 1
//-------------------------------------------------------------------------------------------
function WR_PIX_LINE_C( )
{
  y = sector[iptr+1];
  if( y < 20 )
    for( x = 0; x < 26; x++ )
      picture[y][x] = (sector[iptr + 2 + (x >> 1)] >> ((x & 1) ? 0 : 4)) & 15;
  iptr += 15;
}

//-------------------------------------------------------------------------------------------
// WR_OVP_LINE <var_y> <ov-pixel_0_1> <ov-pixel_2_3> ... <ov-pixel_24_25>
// write overlay pixel line
// two overlay pixels are packed in one byte - e.g. overlay pixel_0_1=0xF0 turns on overlay pixel 0 and off overlay pixel 1
//-------------------------------------------------------------------------------------------
function WR_OVP_LINE( )
{
  y = variables[sector[iptr+1]];
  if( y < 20 )
    for( x = 0; x < 26; x++ )
      overlay[y][x] = (sector[iptr + 2 + (x >> 1)] >> ((x & 1) ? 0 : 4)) & 15;
  iptr += 15;
}

//-------------------------------------------------------------------------------------------
// WR_OVP_LINE_C <con_y> <ov-pixel_0_1> <ov-pixel_2_3> ... <ov-pixel_24_25>
// write constant overlay pixel line
// two overlay pixels are packed in one byte - e.g. overlay pixel_0_1=0xF0 turns on overlay pixel 0 and off overlay pixel 1
//-------------------------------------------------------------------------------------------
function WR_OVP_LINE_C( )
{
  y = sector[iptr+1];
  if( y < 20 )
    for( x = 0; x < 26; x++ )
      overlay[y][x] = (sector[iptr + 2 + (x >> 1)] >> ((x & 1) ? 0 : 4)) & 15;
  iptr += 15;
}

//-------------------------------------------------------------------------------------------
// WR_PIX_QUART <var_quart> <pixel_l0_0_1> <pixel_l0_2_3> ... <pixel_l4_24_25>
// write pixel quarter
// two pixels are packed in one byte
// - e.g. pixel_l0_0_1=0xF0 turns on line 0, pixel 0 and off pixel 1 (lines rel. to quarter)
//-------------------------------------------------------------------------------------------
function WR_PIX_QUART( )
{
  yy = variables[sector[iptr+1]];
  if( yy < 4 )
  {
    yy = yy * 5;
    for( y = yy, i = 0; y < yy + 5; y++ )
      for( x = 0; x < 26; x++, i++ )
        picture[y][x] = (sector[iptr + 2 + (i >> 1)] >> ((i & 1) ? 0 : 4)) & 15;
  }
  iptr += 67;
}

//-------------------------------------------------------------------------------------------
// WR_PIX_QUART_C <con_quart> <pixel_l0_0_1> <pixel_l0_2_3> ... <pixel_l4_24_25>
// write constant pixel quarter
// two pixels are packed in one byte
// - e.g. pixel_l0_0_1=0xF0 turns on line 0, pixel 0 and off pixel 1 (lines rel. to quarter)
//-------------------------------------------------------------------------------------------
function WR_PIX_QUART_C( )
{
  yy = sector[iptr+1];
  if( yy < 4 )
  {
    yy = yy * 5;
    for( y = yy, i = 0; y < yy + 5; y++ )
      for( x = 0; x < 26; x++, i++ )
        picture[y][x] = (sector[iptr + 2 + (i >> 1)] >> ((i & 1) ? 0 : 4)) & 15;
  }
  iptr += 67;
}

//-------------------------------------------------------------------------------------------
// WR_OVP_QUART <var_quart> <ov-pixel_l0_0_1> <ov-pixel_l0_2_3> ... <ov-pixel_l4_24_25>
// write overlay pixel quarter
// two overlay pixels are packed in one byte
// - e.g. overlay pixel_l0_0_1=0xF0 turns on line 0, overlay pixel 0 and off overlay pixel 1 (lines rel. to quarter)
//-------------------------------------------------------------------------------------------
function WR_OVP_QUART( )
{
  yy = variables[sector[iptr+1]];
  if( yy < 4 )
  {
    yy = yy * 5;
    for( y = yy, i = 0; y < yy + 5; y++ )
      for( x = 0; x < 26; x++, i++ )
        overlay[y][x] = (sector[iptr + 2 + (i >> 1)] >> ((i & 1) ? 0 : 4)) & 15;
  }
  iptr += 67;
}

//-------------------------------------------------------------------------------------------
// WR_OVP_QUART_C <con_quart> <ov-pixel_l0_0_1> <ov-pixel_l0_2_3> ... <ov-pixel_l4_24_25>
// write constant overlay pixel quarter
// two overlay pixels are packed in one byte
// - e.g. overlay pixel_l0_0_1=0xF0 turns on line 0, overlay pixel 0 and off overlay pixel 1
//-------------------------------------------------------------------------------------------
function WR_OVP_QUART_C( )
{
  yy = sector[iptr+1];
  if( yy < 4 )
  {
    yy = yy * 5;
    for( y = yy, i = 0; y < yy + 5; y++ )
      for( x = 0; x < 26; x++, i++ )
        overlay[y][x] = (sector[iptr + 2 + (i >> 1)] >> ((i & 1) ? 0 : 4)) & 15;
  }
  iptr += 67;
}

//-------------------------------------------------------------------------------------------
// WR_PIX_CLR
// clear pixels
//-------------------------------------------------------------------------------------------
function WR_PIX_CLR( )
{
  for( y = 0; y < 20; y++ )
    for( x = 0; x < 26; x++ )
      picture[y][x] = 0;
  iptr++;
}

//-------------------------------------------------------------------------------------------
// WR_OVP_CLR
// clear overlay pixels
//-------------------------------------------------------------------------------------------
function WR_OVP_CLR( )
{
  for( y = 0; y < 20; y++ )
    for( x = 0; x < 26; x++ )
      overlay[y][x] = 0;
  iptr++;
}

//-------------------------------------------------------------------------------------------
// WR_PIX_SET
// set pixels
//-------------------------------------------------------------------------------------------
function WR_PIX_SET( )
{
  for( y = 0; y < 20; y++ )
    for( x = 0; x < 26; x++ )
      picture[y][x] = 15;
  iptr++;
}

//-------------------------------------------------------------------------------------------
// WR_OVP_SET
// set overlay pixels
//-------------------------------------------------------------------------------------------
function WR_OVP_SET( )
{
  for( y = 0; y < 20; y++ )
    for( x = 0; x < 26; x++ )
      overlay[y][x] = 15;
  iptr++;
}

//-------------------------------------------------------------------------------------------
// WR_PIX_BW <bw0> ... <bw64>
// write frame of black/white pixels
// bw0,7 = pixel 0,0 / bw0,6 = pixel 1,0 / ... / bw64,0 = pixel 25,19
//-------------------------------------------------------------------------------------------
function WR_PIX_BW( )
{
  for( y = 0, i = 0; y < 20; y++ )
    for( x = 0; x < 26; x++, i++ )
      picture[y][x] = (sector[iptr + 1 + (i >> 3)] & (1 << (7 - (i & 7)))) ? 15 : 0;
  iptr += 66;
}

//-------------------------------------------------------------------------------------------
// WR_OVP_BW <bw0> ... <bw64>
// write frame of black/white overlay pixels
// bw0,7 = pixel 0,0 / bw0,6 = pixel 1,0 / ... / bw64,0 = pixel 25,19
//-------------------------------------------------------------------------------------------
function WR_OVP_BW( )
{
  for( y = 0, i = 0; y < 20; y++ )
    for( x = 0; x < 26; x++, i++ )
      overlay[y][x] = (sector[iptr + 1 + (i >> 3)] & (1 << (7 - (i & 7)))) ? 15 : 0;
  iptr += 66;
}

//-------------------------------------------------------------------------------------------
// WR_PIX_SEL <source> <sel0> ... <sel64>
// set selected pixels of frame to source
// - sel selects pixels
// - pixels with sel=1 are set to source
// sel0,7 = pixel 0,0 / sel0,6 = pixel 1,0 / ... / sel64,0 = pixel 25,19
//-------------------------------------------------------------------------------------------
function WR_PIX_SEL( )
{
  val = variables[sector[iptr+1]] & 15;
  for( y = 0, i = 0; y < 20; y++ )
    for( x = 0; x < 26; x++, i++ )
      if( sector[iptr + 2 + (i >> 3)] & (1 << (7 - (i & 7))) )
      picture[y][x] = val;
  iptr += 67;
}

//-------------------------------------------------------------------------------------------
// WR_PIX_SEL_C <constant> <sel0> ... <sel64>
// set selected pixels of frame to constant
// - sel selects pixels
// - pixels with sel=1 are set to constant
// sel0,7 = pixel 0,0 / sel0,6 = pixel 1,0 / ... / sel64,0 = pixel 25,19
//-------------------------------------------------------------------------------------------
function WR_PIX_SEL_C( )
{
  val = sector[iptr+1] & 15;
  for( y = 0, i = 0; y < 20; y++ )
    for( x = 0; x < 26; x++, i++ )
      if( sector[iptr + 2 + (i >> 3)] & (1 << (7 - (i & 7))) )
      picture[y][x] = val;
  iptr += 67;
}

//-------------------------------------------------------------------------------------------
// WR_OVP_SEL <source> <sel0> ... <sel64>
// set selected overlay pixels of frame to source
// - sel selects pixels
// - pixels with sel=1 are set to source
// sel0,7 = pixel 0,0 / sel0,6 = pixel 1,0 / ... / sel64,0 = pixel 25,19
//-------------------------------------------------------------------------------------------
function WR_OVP_SEL( )
{
  val = variables[sector[iptr+1]] & 15;
  for( y = 0, i = 0; y < 20; y++ )
    for( x = 0; x < 26; x++, i++ )
      if( sector[iptr + 2 + (i >> 3)] & (1 << (7 - (i & 7))) )
      overlay[y][x] = val;
  iptr += 67;
}

//-------------------------------------------------------------------------------------------
// WR_OVP_SEL_C <constant> <sel0> ... <sel64>
// set selected overlay pixels of frame to constant
// - sel selects pixels
// - pixels with sel=1 are set to constant
// sel0,7 = pixel 0,0 / sel0,6 = pixel 1,0 / ... / sel64,0 = pixel 25,19
//-------------------------------------------------------------------------------------------
function WR_OVP_SEL_C( )
{
  val = sector[iptr+1] & 15;
  for( y = 0, i = 0; y < 20; y++ )
    for( x = 0; x < 26; x++, i++ )
      if( sector[iptr + 2 + (i >> 3)] & (1 << (7 - (i & 7))) )
      overlay[y][x] = val;
  iptr += 67;
}

//-------------------------------------------------------------------------------------------
// CP_BLK <flags> <src_x> <src_y> <dest_x> <dest_y> <size_x> <size_y>
// copy a block of pixels
// flags,7: 0=copy from pixel buffer, 1=copy from overlay buffer
// flags,6: 0=copy to pixel buffer, 1=copy to overlay buffer
// flags,5: 0=src_x is a variable, 1=src_x is a constant
// flags,4: 0=src_y is a variable, 1=src_y is a constant
// flags,3: 0=dest_x is a variable, 1=dest_x is a constant
// flags,2: 0=dest_y is a variable, 1=dest_y is a constant
// flags,1: 0=size_x is a variable, 1=size_x is a constant
// flags,0: 0=size_y is a variable, 1=size_y is a constant
// if the two sections overlap, the result is undefined
//-------------------------------------------------------------------------------------------
function CP_BLK( )
{
  flags = sector[iptr+1];
  if( flags & 32 ) srcx = sector[iptr+2]; else srcx = variables[sector[iptr+2]];
  if( flags & 16 ) srcy = sector[iptr+3]; else srcy = variables[sector[iptr+3]];
  if( flags & 8 ) destx = sector[iptr+4]; else destx = variables[sector[iptr+4]];
  if( flags & 4 ) desty = sector[iptr+5]; else desty = variables[sector[iptr+5]];
  if( flags & 2 ) sizex = sector[iptr+6]; else sizex = variables[sector[iptr+6]];
  if( flags & 1 ) sizey = sector[iptr+7]; else sizey = variables[sector[iptr+7]];
  if( srcx < 26 && srcy < 20 && destx < 26 && desty < 20
    && srcx + sizex <= 26 && srcy + sizey <= 20
    && destx + sizex <= 26 && desty + sizey <= 20 )
  {
    if( flags & 128 )
      if( flags & 64 )
        for( y = 0; y < sizey; y++ )
          for( x = 0; x < sizex; x++ )
            overlay[desty+y][destx+x] = overlay[srcy+y][srcx+x];
      else
        for( y = 0; y < sizey; y++ )
          for( x = 0; x < sizex; x++ )
            picture[desty+y][destx+x] = overlay[srcy+y][srcx+x];
    else
      if( flags & 64 )
        for( y = 0; y < sizey; y++ )
          for( x = 0; x < sizex; x++ )
            overlay[desty+y][destx+x] = picture[srcy+y][srcx+x];
      else
        for( y = 0; y < sizey; y++ )
          for( x = 0; x < sizex; x++ )
            picture[desty+y][destx+x] = picture[srcy+y][srcx+x];
  }
  iptr += 8;
}

//-------------------------------------------------------------------------------------------
// CP_BLK_TR <flags> <transp> <src_x> <src_y> <dest_x> <dest_y> <size_x> <size_y>
// copy a block of pixels with a transparent color
//  - if the variable transp is not in the range 0x00..0x0F no color is transparent
// flags,7: 0=copy from pixel buffer, 1=copy from overlay buffer
// flags,6: 0=copy to pixel buffer, 1=copy to overlay buffer
// flags,5: 0=src_x is a variable, 1=src_x is a constant
// flags,4: 0=src_y is a variable, 1=src_y is a constant
// flags,3: 0=dest_x is a variable, 1=dest_x is a constant
// flags,2: 0=dest_y is a variable, 1=dest_y is a constant
// flags,1: 0=size_x is a variable, 1=size_x is a constant
// flags,0: 0=size_y is a variable, 1=size_y is a constant
// if the two sections overlap, the result is undefined
//-------------------------------------------------------------------------------------------
function CP_BLK_TR( )
{
  flags = sector[iptr+1];
  val = variables[sector[iptr+2]] & 15;
  if( flags & 32 ) srcx = sector[iptr+3]; else srcx = variables[sector[iptr+3]];
  if( flags & 16 ) srcy = sector[iptr+4]; else srcy = variables[sector[iptr+4]];
  if( flags & 8 ) destx = sector[iptr+5]; else destx = variables[sector[iptr+5]];
  if( flags & 4 ) desty = sector[iptr+6]; else desty = variables[sector[iptr+6]];
  if( flags & 2 ) sizex = sector[iptr+7]; else sizex = variables[sector[iptr+7]];
  if( flags & 1 ) sizey = sector[iptr+8]; else sizey = variables[sector[iptr+8]];
  if( srcx < 26 && srcy < 20 && destx < 26 && desty < 20
    && srcx + sizex <= 26 && srcy + sizey <= 20
    && destx + sizex <= 26 && desty + sizey <= 20 )
  {
    if( flags & 128 )
      if( flags & 64 )
        for( y = 0; y < sizey; y++ )
          for( x = 0; x < sizex; x++ )
            if( overlay[srcy+y][srcx+x] != val )
              overlay[desty+y][destx+x] = overlay[srcy+y][srcx+x];
      else
        for( y = 0; y < sizey; y++ )
          for( x = 0; x < sizex; x++ )
            if( overlay[srcy+y][srcx+x] != val )
              picture[desty+y][destx+x] = overlay[srcy+y][srcx+x];
    else
      if( flags & 64 )
        for( y = 0; y < sizey; y++ )
          for( x = 0; x < sizex; x++ )
            if( picture[srcy+y][srcx+x] != val )
              overlay[desty+y][destx+x] = picture[srcy+y][srcx+x];
      else
        for( y = 0; y < sizey; y++ )
          for( x = 0; x < sizex; x++ )
            if( picture[srcy+y][srcx+x] != val )
              picture[desty+y][destx+x] = picture[srcy+y][srcx+x];
  }
  iptr += 9;
}

//-------------------------------------------------------------------------------------------
// CP_BLK_TR_C <flags> <transp> <src_x> <src_y> <dest_x> <dest_y> <size_x> <size_y>
// copy a block of pixels with a constant transparent color
//  - if the constant transp is not in the range 0x00..0x0F no color is transparent
// flags,7: 0=copy from pixel buffer, 1=copy from overlay buffer
// flags,6: 0=copy to pixel buffer, 1=copy to overlay buffer
// flags,5: 0=src_x is a variable, 1=src_x is a constant
// flags,4: 0=src_y is a variable, 1=src_y is a constant
// flags,3: 0=dest_x is a variable, 1=dest_x is a constant
// flags,2: 0=dest_y is a variable, 1=dest_y is a constant
// flags,1: 0=size_x is a variable, 1=size_x is a constant
// flags,0: 0=size_y is a variable, 1=size_y is a constant
// if the two sections overlap, the result is undefined
//-------------------------------------------------------------------------------------------
function CP_BLK_TR( )
{
  flags = sector[iptr+1];
  val = sector[iptr+2] & 15;
  if( flags & 32 ) srcx = sector[iptr+3]; else srcx = variables[sector[iptr+3]];
  if( flags & 16 ) srcy = sector[iptr+4]; else srcy = variables[sector[iptr+4]];
  if( flags & 8 ) destx = sector[iptr+5]; else destx = variables[sector[iptr+5]];
  if( flags & 4 ) desty = sector[iptr+6]; else desty = variables[sector[iptr+6]];
  if( flags & 2 ) sizex = sector[iptr+7]; else sizex = variables[sector[iptr+7]];
  if( flags & 1 ) sizey = sector[iptr+8]; else sizey = variables[sector[iptr+8]];
  if( srcx < 26 && srcy < 20 && destx < 26 && desty < 20
    && srcx + sizex <= 26 && srcy + sizey <= 20
    && destx + sizex <= 26 && desty + sizey <= 20 )
  {
    if( flags & 128 )
      if( flags & 64 )
        for( y = 0; y < sizey; y++ )
          for( x = 0; x < sizex; x++ )
            if( overlay[srcy+y][srcx+x] != val )
              overlay[desty+y][destx+x] = overlay[srcy+y][srcx+x];
      else
        for( y = 0; y < sizey; y++ )
          for( x = 0; x < sizex; x++ )
            if( overlay[srcy+y][srcx+x] != val )
              picture[desty+y][destx+x] = overlay[srcy+y][srcx+x];
    else
      if( flags & 64 )
        for( y = 0; y < sizey; y++ )
          for( x = 0; x < sizex; x++ )
            if( picture[srcy+y][srcx+x] != val )
              overlay[desty+y][destx+x] = picture[srcy+y][srcx+x];
      else
        for( y = 0; y < sizey; y++ )
          for( x = 0; x < sizex; x++ )
            if( picture[srcy+y][srcx+x] != val )
              picture[desty+y][destx+x] = picture[srcy+y][srcx+x];
  }
  iptr += 9;
}

//-------------------------------------------------------------------------------------------
// DISPLAY
// display frame
//-------------------------------------------------------------------------------------------
function DISPLAY( )
{
  for( y = 0, i = 0; y < 20; y++ )
    for( x = 0; x < 26; x++, i++ )
      _root["led" + i]._alpha = picture[y][x] * 4 + 40;
  iptr++;
}

//-------------------------------------------------------------------------------------------
// DISPLAY_CP
// display frame and copy it into new drawing buffer
//-------------------------------------------------------------------------------------------
function DISPLAY_CP( )
{
  for( y = 0, i = 0; y < 20; y++ )
    for( x = 0; x < 26; x++, i++ )
      _root["led" + i]._alpha = picture[y][x] * 4 + 40;
  iptr++;
}

//-------------------------------------------------------------------------------------------
// DELAY_DO <delay_h> <delay_l>
// wait <delay> milliseconds
//-------------------------------------------------------------------------------------------
function DELAY_DO( )
{
  duration = variables[sector[iptr+1]] << 8 | variables[sector[iptr+2]];
  now = new Date( );
  now_ms = (now.getMinutes( ) * 60 + now.getSeconds( )) * 1000 + now.getMilliseconds( );
  delay_end = (now_ms + duration) % (60*60*1000);
  delay_active = 1;
  delay_wait = 1;
  iptr += 3;
}

//-------------------------------------------------------------------------------------------
// DELAY_DO_C <cons_delay (2)>
// wait <delay> milliseconds
//-------------------------------------------------------------------------------------------
function DELAY_DO_C( )
{
  duration = sector[iptr+1] << 8 | sector[iptr+2];
  now = new Date( );
  now_ms = (now.getMinutes( ) * 60 + now.getSeconds( )) * 1000 + now.getMilliseconds( );
  delay_end = (now_ms + duration) % (60*60*1000);
  delay_active = 1;
  delay_wait = 1;
  iptr += 3;
}

//-------------------------------------------------------------------------------------------
// DELAY_START <delay_h> <delay_l>
// start background delay of <delay> milliseconds
// - background delay can be checked with DELAY_CHECK
// - background delay can be waited for with DELAY_WAIT
//-------------------------------------------------------------------------------------------
function DELAY_START( )
{
  duration = variables[sector[iptr+1]] << 8 | variables[sector[iptr+2]];
  now = new Date( );
  now_ms = (now.getMinutes( ) * 60 + now.getSeconds( )) * 1000 + now.getMilliseconds( );
  delay_end = (now_ms + duration) % (60*60*1000);
  delay_active = 1;
  delay_wait = 0;
  iptr += 3;
}

//-------------------------------------------------------------------------------------------
// DELAY_START_C <cons_delay (2)>
// start background delay of <delay> milliseconds
// - background delay can be checked with DELAY_CHECK
// - background delay can be waited for with DELAY_WAIT
//-------------------------------------------------------------------------------------------
function DELAY_START_C( )
{
  duration = sector[iptr+1] << 8 | sector[iptr+2];
  now = new Date( );
  now_ms = (now.getMinutes( ) * 60 + now.getSeconds( )) * 1000 + now.getMilliseconds( );
  delay_end = (now_ms + duration) % (60*60*1000);
  delay_active = 1;
  delay_wait = 0;
  iptr += 3;
}

//-------------------------------------------------------------------------------------------
// DELAY_CHECK <check result>
// check if background delay elapsed (returns 0xFF if delay is active, 0x00 if not)
// - background delay can be started with DELAY_START
// - background delay can be waited for with DELAY_WAIT
//-------------------------------------------------------------------------------------------
function DELAY_CHECK( )
{
  variables[sector[iptr+1]] = delay_active ? 255 : 0;
  iptr += 2;
}

//-------------------------------------------------------------------------------------------
// DELAY_WAIT
// wait for background delay to elapse
// - background delay can be started with DELAY_START
// - background delay can be checked with DELAY_CHECK
//-------------------------------------------------------------------------------------------
function DELAY_WAIT( )
{
  if( delay_active )
    delay_wait = 1;
  iptr++;
}

//-------------------------------------------------------------------------------------------
// GET_KEYS <current> <pressed> <released>
// get keys
// - current: current (debounced) key state
// - pressed: keys that were pressed since last GET_KEYS
// - released: keys that were released since last GET_KEYS
//-------------------------------------------------------------------------------------------
function GET_KEYS( )
{
  variables[sector[iptr+1]] = keys_state;
  variables[sector[iptr+2]] = keys_pressed;
  variables[sector[iptr+3]] = keys_released;
  keys_pressed = 0;
  keys_released = 0;
  iptr += 4;
}

//-------------------------------------------------------------------------------------------
// GET_SNES0 <current_h> <current_l> <pressed_h> <pressed_l> <released_h> <released_l>
// get keys of 1st SNES pad
// - current: current (debounced) key state
// - pressed: keys that were pressed since last GET_SNES0
// - released: keys that were released since last GET_SNES0
//-------------------------------------------------------------------------------------------
function GET_SNES0( )
{
  variables[sector[iptr+1]] = (snes0_state >> 8) & 0xFF;
  variables[sector[iptr+2]] = snes0_state & 0xFF;
  variables[sector[iptr+3]] = (snes0_pressed >> 8) & 0xFF;
  variables[sector[iptr+4]] = snes0_pressed & 0xFF;
  variables[sector[iptr+5]] = (snes0_released >> 8) & 0xFF;
  variables[sector[iptr+6]] = snes0_released & 0xFF;
  snes0_pressed = 0;
  snes0_released = 0;
  iptr += 7;
}

//-------------------------------------------------------------------------------------------
// GET_SNES1 <current_h> <current_l> <pressed_h> <pressed_l> <released_h> <released_l>
// get keys of 2nd SNES pad
// - current: current (debounced) key state
// - pressed: keys that were pressed since last GET_SNES1
// - released: keys that were released since last GET_SNES1
//-------------------------------------------------------------------------------------------
function GET_SNES1( )
{
  variables[sector[iptr+1]] = (snes1_state >> 8) & 0xFF;
  variables[sector[iptr+2]] = snes1_state & 0xFF;
  variables[sector[iptr+3]] = (snes1_pressed >> 8) & 0xFF;
  variables[sector[iptr+4]] = snes1_pressed & 0xFF;
  variables[sector[iptr+5]] = (snes1_released >> 8) & 0xFF;
  variables[sector[iptr+6]] = snes1_released & 0xFF;
  snes1_pressed = 0;
  snes1_released = 0;
  iptr += 7;
}

//-------------------------------------------------------------------------------------------
// GET_TIME <sec> <min> <hour>
// get time: seconds, minutes, hours
//-------------------------------------------------------------------------------------------
function GET_TIME( )
{
  now = new Date( );
  now_s = (now.getHours( ) * 60 + now.getMinutes( )) * 60 + now.getSeconds( );
  val = now_s + time_offset;
  variables[sector[iptr+1]] = val % 60;
  variables[sector[iptr+2]] = int(val / 60) % 60;
  variables[sector[iptr+3]] = int(val / 3600) % 24;
  iptr += 4;
}

//-------------------------------------------------------------------------------------------
// SET_TIME <sec> <min> <hour>
// set time: seconds (0..59), minutes (0..59), hours (0..23)
//-------------------------------------------------------------------------------------------
function SET_TIME( )
{
  sec = variables[sector[iptr+1]];
  min = variables[sector[iptr+2]];
  hour = variables[sector[iptr+3]];
  if( sec < 60 && min < 60 && hour < 24 )
  {
    val = (hour * 60 + min) * 60 + sec;
    now = new Date( );
    now_s = (now.getHours( ) * 60 + now.getMinutes( )) * 60 + now.getSeconds( );
    time_offset = (val + 86400 - now_s) % 86400;
  }
  iptr += 4;
}

//-------------------------------------------------------------------------------------------
// CMD_RND <dest>
// fill dest with pseudorandom value
//-------------------------------------------------------------------------------------------
function RND( )
{
  variables[sector[iptr+1]] = random( 256 );
  iptr += 2;
}

//-------------------------------------------------------------------------------------------
// NOP
// no operation
//-------------------------------------------------------------------------------------------
function NOP( )
{
  iptr++;
}

//get keys
keys_old = keys_state;
keys_state = 0;
if( Key.isDown( 49 ) ) keys_state |= 1; //'1'
if( Key.isDown( 50 ) ) keys_state |= 2; //'2'
if( Key.isDown( 51 ) ) keys_state |= 4; //'3'
if( Key.isDown( 52 ) ) keys_state |= 8; //'4'
if( Key.isDown( 53 ) ) keys_state |= 16; //'5'
if( Key.isDown( 54 ) ) keys_state |= 32; //'6'
if( Key.isDown( 55 ) ) keys_state |= 64; //'7'
if( Key.isDown( 56 ) ) keys_state |= 128; //'8'
keys_pressed |= ~keys_old & keys_state;
keys_released |= keys_old & ~keys_state;

//delay active
if( delay_wait )
{
  //get time in milliseconds
  now = new Date( );
  now_ms = (now.getMinutes( ) * 60 + now.getSeconds( )) * 1000 + now.getMilliseconds( );
  //delay ended
  if( now_ms > delay_end || (now_ms < 5*60*1000 && delay_end > 55*60*1000) )
  {
    delay_active = 0;
    delay_wait = 0;
  }
}

//execute some commands
for( cmd_no = 0; cmd_no < 30 && !delay_wait; cmd_no++ )
{
  //execute command at instruction pointer
  cmd = sector[iptr];
  if( cmd < 128 )
  {
    if( cmd < 64 )
    {
      if( cmd < 32 )
      {
        if( cmd < 16 )
        {
          if( cmd < 8 )
          {
            if( cmd < 4 )
            {
              if( cmd < 2 )
              {
                if( cmd < 1 )
                {
                  //### COMMAND 0 ###
                  JMP_NEXT_SEC( );
                }
                else
                {
                  //### COMMAND 1 ###
                  JMP_SEC( );
                }
              }
              else
              {
                //### COMMAND 2, 3 ###
                JMP_OFS( );
              }
            }
            else
            {
              if( cmd < 6 )
              {
                //### COMMAND 4, 5 ###
                JMP_OFS_SEC( );
              }
              else
              {
                if( cmd < 7 )
                {
                  //### COMMAND 6 ###
                  JMP_IND( );
                }
                else
                {
                  //### COMMAND 7 ###
                  NOP( );
                }
              }
            }
          }
          else
          {
            if( cmd < 12 )
            {
              if( cmd < 10 )
              {
                //### COMMAND 8, 9 ###
                JMP_EQ( );
              }
              else
              {
                //### COMMAND 10, 11 ###
                JMP_EQ_C( );
              }
            }
            else
            {
              if( cmd < 14 )
              {
                //### COMMAND 12, 13 ###
                JMP_NEQ( );
              }
              else
              {
                //### COMMAND 14, 15 ###
                JMP_NEQ_C( );
              }
            }
          }
        }
        else
        {
          if( cmd < 24 )
          {
            if( cmd < 20 )
            {
              if( cmd < 18 )
              {
                //### COMMAND 16, 17 ###
                JMP_GT( );
              }
              else
              {
                //### COMMAND 18, 19 ###
                JMP_GT_C( );
              }
            }
            else
            {
              if( cmd < 22 )
              {
                //### COMMAND 20, 21 ###
                JMP_NGT( );
              }
              else
              {
                //### COMMAND 22, 23 ###
                JMP_NGT_C( );
              }
            }
          }
          else
          {
            if( cmd < 28 )
            {
              if( cmd < 26 )
              {
                //### COMMAND 24, 25 ###
                JMP_LT( );
              }
              else
              {
                //### COMMAND 26, 27 ###
                JMP_LT_C( );
              }
            }
            else
            {
              if( cmd < 30 )
              {
                //### COMMAND 28, 29 ###
                JMP_NLT( );
              }
              else
              {
                //### COMMAND 30, 31 ###
                JMP_NLT_C( );
              }
            }
          }
        }
      }
      else
      {
        if( cmd < 48 )
        {
          if( cmd < 40 )
          {
            if( cmd < 36 )
            {
              if( cmd < 34 )
              {
                //### COMMAND 32, 33 ###
                JMP_GTS( );
              }
              else
              {
                //### COMMAND 34, 35 ###
                JMP_GTS_C( );
              }
            }
            else
            {
              if( cmd < 38 )
              {
                //### COMMAND 36, 37 ###
                JMP_NGTS( );
              }
              else
              {
                //### COMMAND 38, 39 ###
                JMP_NGTS_C( );
              }
            }
          }
          else
          {
            if( cmd < 44 )
            {
              if( cmd < 42 )
              {
                //### COMMAND 40, 41 ###
                JMP_LTS( );
              }
              else
              {
                //### COMMAND 42, 43 ###
                JMP_LTS_C( );
              }
            }
            else
            {
              if( cmd < 46 )
              {
                //### COMMAND 44, 45 ###
                JMP_NLTS( );
              }
              else
              {
                //### COMMAND 46, 47 ###
                JMP_NLTS_C( );
              }
            }
          }
        }
        else
        {
          if( cmd < 56 )
          {
            if( cmd < 52 )
            {
              if( cmd < 50 )
              {
                //### COMMAND 48, 49 ###
                JMP_AND_Z( );
              }
              else
              {
                //### COMMAND 50, 51 ###
                JMP_AND_Z_C( );
              }
            }
            else
            {
              if( cmd < 54 )
              {
                //### COMMAND 52, 53 ###
                JMP_AND_NZ( );
              }
              else
              {
                //### COMMAND 54, 55 ###
                JMP_AND_NZ_C( );
              }
            }
          }
          else
          {
            if( cmd < 60 )
            {
              if( cmd < 58 )
              {
                //### COMMAND 56, 57 ###
                JMP_OR_M( );
              }
              else
              {
                //### COMMAND 58, 59 ###
                JMP_OR_M_C( );
              }
            }
            else
            {
              if( cmd < 62 )
              {
                //### COMMAND 60, 61 ###
                JMP_OR_NM( );
              }
              else
              {
                //### COMMAND 62, 63 ###
                JMP_OR_NM_C( );
              }
            }
          }
        }
      }
    }
    else
    {
      if( cmd < 96 )
      {
        if( cmd < 80 )
        {
          if( cmd < 72 )
          {
            if( cmd < 68 )
            {
              if( cmd < 66 )
              {
                if( cmd < 65 )
                {
                  //### COMMAND 64 ###
                  NOP( );
                }
                else
                {
                  //### COMMAND 65 ###
                  NOP( );
                }
              }
              else
              {
                if( cmd < 67 )
                {
                  //### COMMAND 66 ###
                  NOP( );
                }
                else
                {
                  //### COMMAND 67 ###
                  NOP( );
                }
              }
            }
            else
            {
              if( cmd < 70 )
              {
                if( cmd < 69 )
                {
                  //### COMMAND 68 ###
                  NOP( );
                }
                else
                {
                  //### COMMAND 69 ###
                  NOP( );
                }
              }
              else
              {
                if( cmd < 71 )
                {
                  //### COMMAND 70 ###
                  NOP( );
                }
                else
                {
                  //### COMMAND 71 ###
                  NOP( );
                }
              }
            }
          }
          else
          {
            if( cmd < 76 )
            {
              if( cmd < 74 )
              {
                if( cmd < 73 )
                {
                  //### COMMAND 72 ###
                  NOP( );
                }
                else
                {
                  //### COMMAND 73 ###
                  NOP( );
                }
              }
              else
              {
                if( cmd < 75 )
                {
                  //### COMMAND 74 ###
                  NOP( );
                }
                else
                {
                  //### COMMAND 75 ###
                  NOP( );
                }
              }
            }
            else
            {
              if( cmd < 78 )
              {
                if( cmd < 77 )
                {
                  //### COMMAND 76 ###
                  NOP( );
                }
                else
                {
                  //### COMMAND 77 ###
                  NOP( );
                }
              }
              else
              {
                if( cmd < 79 )
                {
                  //### COMMAND 78 ###
                  NOP( );
                }
                else
                {
                  //### COMMAND 79 ###
                  NOP( );
                }
              }
            }
          }
        }
        else
        {
          if( cmd < 88 )
          {
            if( cmd < 84 )
            {
              if( cmd < 82 )
              {
                if( cmd < 81 )
                {
                  //### COMMAND 80 ###
                  MOV( );
                }
                else
                {
                  //### COMMAND 81 ###
                  MOV_C( );
                }
              }
              else
              {
                if( cmd < 83 )
                {
                  //### COMMAND 82 ###
                  MOV2( );
                }
                else
                {
                  //### COMMAND 83 ###
                  MOV2_C( );
                }
              }
            }
            else
            {
              if( cmd < 86 )
              {
                if( cmd < 85 )
                {
                  //### COMMAND 84 ###
                  MOV4( );
                }
                else
                {
                  //### COMMAND 85 ###
                  MOV4_C( );
                }
              }
              else
              {
                if( cmd < 87 )
                {
                  //### COMMAND 86 ###
                  NOP( );
                }
                else
                {
                  //### COMMAND 87 ###
                  NOP( );
                }
              }
            }
          }
          else
          {
            if( cmd < 92 )
            {
              if( cmd < 90 )
              {
                if( cmd < 89 )
                {
                  //### COMMAND 88 ###
                  RD_I( );
                }
                else
                {
                  //### COMMAND 89 ###
                  WR_I( );
                }
              }
              else
              {
                if( cmd < 91 )
                {
                  //### COMMAND 90 ###
                  NOP( );
                }
                else
                {
                  //### COMMAND 91 ###
                  NOP( );
                }
              }
            }
            else
            {
              if( cmd < 94 )
              {
                if( cmd < 93 )
                {
                  //### COMMAND 92 ###
                  RD_S( );
                }
                else
                {
                  //### COMMAND 93 ###
                  NOP( );
                }
              }
              else
              {
                if( cmd < 95 )
                {
                  //### COMMAND 94 ###
                  NOP( );
                }
                else
                {
                  //### COMMAND 95 ###
                  NOP( );
                }
              }
            }
          }
        }
      }
      else
      {
        if( cmd < 112 )
        {
          if( cmd < 104 )
          {
            if( cmd < 100 )
            {
              if( cmd < 98 )
              {
                if( cmd < 97 )
                {
                  //### COMMAND 96 ###
                  ADD( );
                }
                else
                {
                  //### COMMAND 97 ###
                  ADD_C( );
                }
              }
              else
              {
                if( cmd < 99 )
                {
                  //### COMMAND 98 ###
                  ADDC( );
                }
                else
                {
                  //### COMMAND 99 ###
                  ADDC_C( );
                }
              }
            }
            else
            {
              if( cmd < 102 )
              {
                if( cmd < 101 )
                {
                  //### COMMAND 100 ###
                  SUB( );
                }
                else
                {
                  //### COMMAND 101 ###
                  SUB_C( );
                }
              }
              else
              {
                if( cmd < 103 )
                {
                  //### COMMAND 102 ###
                  SUBB( );
                }
                else
                {
                  //### COMMAND 103 ###
                  SUBB_C( );
                }
              }
            }
          }
          else
          {
            if( cmd < 108 )
            {
              if( cmd < 106 )
              {
                if( cmd < 105 )
                {
                  //### COMMAND 104 ###
                  MUL( );
                }
                else
                {
                  //### COMMAND 105 ###
                  MUL_C( );
                }
              }
              else
              {
                if( cmd < 107 )
                {
                  //### COMMAND 106 ###
                  MULS( );
                }
                else
                {
                  //### COMMAND 107 ###
                  MULS_C( );
                }
              }
            }
            else
            {
              if( cmd < 110 )
              {
                if( cmd < 109 )
                {
                  //### COMMAND 108 ###
                  DIV( );
                }
                else
                {
                  //### COMMAND 109 ###
                  DIVS( );
                }
              }
              else
              {
                if( cmd < 111 )
                {
                  //### COMMAND 110 ###
                  NOP( );
                }
                else
                {
                  //### COMMAND 111 ###
                  NOP( );
                }
              }
            }
          }
        }
        else
        {
          if( cmd < 120 )
          {
            if( cmd < 116 )
            {
              if( cmd < 114 )
              {
                if( cmd < 113 )
                {
                  //### COMMAND 112 ###
                  AND( );
                }
                else
                {
                  //### COMMAND 113 ###
                  AND_C( );
                }
              }
              else
              {
                if( cmd < 115 )
                {
                  //### COMMAND 114 ###
                  OR( );
                }
                else
                {
                  //### COMMAND 115 ###
                  OR_C( );
                }
              }
            }
            else
            {
              if( cmd < 118 )
              {
                if( cmd < 117 )
                {
                  //### COMMAND 116 ###
                  XOR( );
                }
                else
                {
                  //### COMMAND 117 ###
                  XOR_C( );
                }
              }
              else
              {
                if( cmd < 119 )
                {
                  //### COMMAND 118 ###
                  NOP( );
                }
                else
                {
                  //### COMMAND 119 ###
                  NOP( );
                }
              }
            }
          }
          else
          {
            if( cmd < 124 )
            {
              if( cmd < 122 )
              {
                if( cmd < 121 )
                {
                  //### COMMAND 120 ###
                  SHL( );
                }
                else
                {
                  //### COMMAND 121 ###
                  SHL_C( );
                }
              }
              else
              {
                if( cmd < 123 )
                {
                  //### COMMAND 122 ###
                  SHR( );
                }
                else
                {
                  //### COMMAND 123 ###
                  SHR_C( );
                }
              }
            }
            else
            {
              if( cmd < 126 )
              {
                if( cmd < 125 )
                {
                  //### COMMAND 124 ###
                  ROL( );
                }
                else
                {
                  //### COMMAND 125 ###
                  ROL_C( );
                }
              }
              else
              {
                if( cmd < 127 )
                {
                  //### COMMAND 126 ###
                  ROR( );
                }
                else
                {
                  //### COMMAND 127 ###
                  ROR_C( );
                }
              }
            }
          }
        }
      }
    }
  }
  else
  {
    if( cmd < 192 )
    {
      if( cmd < 160 )
      {
        if( cmd < 144 )
        {
          if( cmd < 136 )
          {
            if( cmd < 132 )
            {
              if( cmd < 130 )
              {
                if( cmd < 129 )
                {
                  //### COMMAND 128 ###
                  NOP( );
                }
                else
                {
                  //### COMMAND 129 ###
                  NOP( );
                }
              }
              else
              {
                if( cmd < 131 )
                {
                  //### COMMAND 130 ###
                  NOP( );
                }
                else
                {
                  //### COMMAND 131 ###
                  NOP( );
                }
              }
            }
            else
            {
              if( cmd < 134 )
              {
                if( cmd < 133 )
                {
                  //### COMMAND 132 ###
                  NOP( );
                }
                else
                {
                  //### COMMAND 133 ###
                  NOP( );
                }
              }
              else
              {
                if( cmd < 135 )
                {
                  //### COMMAND 134 ###
                  NOP( );
                }
                else
                {
                  //### COMMAND 135 ###
                  NOP( );
                }
              }
            }
          }
          else
          {
            if( cmd < 140 )
            {
              if( cmd < 138 )
              {
                if( cmd < 137 )
                {
                  //### COMMAND 136 ###
                  NOP( );
                }
                else
                {
                  //### COMMAND 137 ###
                  NOP( );
                }
              }
              else
              {
                if( cmd < 139 )
                {
                  //### COMMAND 138 ###
                  NOP( );
                }
                else
                {
                  //### COMMAND 139 ###
                  NOP( );
                }
              }
            }
            else
            {
              if( cmd < 142 )
              {
                if( cmd < 141 )
                {
                  //### COMMAND 140 ###
                  NOP( );
                }
                else
                {
                  //### COMMAND 141 ###
                  NOP( );
                }
              }
              else
              {
                if( cmd < 143 )
                {
                  //### COMMAND 142 ###
                  NOP( );
                }
                else
                {
                  //### COMMAND 143 ###
                  NOP( );
                }
              }
            }
          }
        }
        else
        {
          if( cmd < 152 )
          {
            if( cmd < 148 )
            {
              if( cmd < 146 )
              {
                if( cmd < 145 )
                {
                  //### COMMAND 144 ###
                  RD_PIX( );
                }
                else
                {
                  //### COMMAND 145 ###
                  RD_PIX_C( );
                }
              }
              else
              {
                if( cmd < 147 )
                {
                  //### COMMAND 146 ###
                  RD_OVP( );
                }
                else
                {
                  //### COMMAND 147 ###
                  RD_OVP_C( );
                }
              }
            }
            else
            {
              if( cmd < 150 )
              {
                if( cmd < 149 )
                {
                  //### COMMAND 148 ###
                  WR_PIX( );
                }
                else
                {
                  //### COMMAND 149 ###
                  WR_PIX_C( );
                }
              }
              else
              {
                if( cmd < 151 )
                {
                  //### COMMAND 150 ###
                  WR_OVP( );
                }
                else
                {
                  //### COMMAND 151 ###
                  WR_OVP_C( );
                }
              }
            }
          }
          else
          {
            if( cmd < 156 )
            {
              if( cmd < 154 )
              {
                if( cmd < 153 )
                {
                  //### COMMAND 152 ###
                  WR_PIX_CO( );
                }
                else
                {
                  //### COMMAND 153 ###
                  WR_PIX_CO_C( );
                }
              }
              else
              {
                if( cmd < 155 )
                {
                  //### COMMAND 154 ###
                  WR_OVP_CO( );
                }
                else
                {
                  //### COMMAND 155 ###
                  WR_OVP_CO_C( );
                }
              }
            }
            else
            {
              if( cmd < 158 )
              {
                if( cmd < 157 )
                {
                  //### COMMAND 156 ###
                  NOP( );
                }
                else
                {
                  //### COMMAND 157 ###
                  NOP( );
                }
              }
              else
              {
                if( cmd < 159 )
                {
                  //### COMMAND 158 ###
                  NOP( );
                }
                else
                {
                  //### COMMAND 159 ###
                  NOP( );
                }
              }
            }
          }
        }
      }
      else
      {
        if( cmd < 176 )
        {
          if( cmd < 168 )
          {
            if( cmd < 164 )
            {
              if( cmd < 162 )
              {
                if( cmd < 161 )
                {
                  //### COMMAND 160 ###
                  WR_PIX_LINE( );
                }
                else
                {
                  //### COMMAND 161 ###
                  WR_PIX_LINE_C( );
                }
              }
              else
              {
                if( cmd < 163 )
                {
                  //### COMMAND 162 ###
                  WR_OVP_LINE( );
                }
                else
                {
                  //### COMMAND 163 ###
                  WR_OVP_LINE_C( );
                }
              }
            }
            else
            {
              if( cmd < 166 )
              {
                if( cmd < 165 )
                {
                  //### COMMAND 164 ###
                  WR_PIX_QUART( );
                }
                else
                {
                  //### COMMAND 165 ###
                  WR_PIX_QUART_C( );
                }
              }
              else
              {
                if( cmd < 167 )
                {
                  //### COMMAND 166 ###
                  WR_OVP_QUART( );
                }
                else
                {
                  //### COMMAND 167 ###
                  WR_OVP_QUART_C( );
                }
              }
            }
          }
          else
          {
            if( cmd < 172 )
            {
              if( cmd < 170 )
              {
                if( cmd < 169 )
                {
                  //### COMMAND 168 ###
                  WR_PIX_CLR( );
                }
                else
                {
                  //### COMMAND 169 ###
                  WR_OVP_CLR( );
                }
              }
              else
              {
                if( cmd < 171 )
                {
                  //### COMMAND 170 ###
                  WR_PIX_SET( );
                }
                else
                {
                  //### COMMAND 171 ###
                  WR_OVP_SET( );
                }
              }
            }
            else
            {
              if( cmd < 174 )
              {
                if( cmd < 173 )
                {
                  //### COMMAND 172 ###
                  WR_PIX_BW( );
                }
                else
                {
                  //### COMMAND 173 ###
                  WR_OVP_BW( );
                }
              }
              else
              {
                if( cmd < 175 )
                {
                  //### COMMAND 174 ###
                  WR_PIX_SEL( );
                }
                else
                {
                  //### COMMAND 175 ###
                  WR_PIX_SEL_C( );
                }
              }
            }
          }
        }
        else
        {
          if( cmd < 184 )
          {
            if( cmd < 180 )
            {
              if( cmd < 178 )
              {
                if( cmd < 177 )
                {
                  //### COMMAND 176 ###
                  WR_OVP_SEL( );
                }
                else
                {
                  //### COMMAND 177 ###
                  WR_OVP_SEL_C( );
                }
              }
              else
              {
                if( cmd < 179 )
                {
                  //### COMMAND 178 ###
                  NOP( );
                }
                else
                {
                  //### COMMAND 179 ###
                  NOP( );
                }
              }
            }
            else
            {
              if( cmd < 182 )
              {
                if( cmd < 181 )
                {
                  //### COMMAND 180 ###
                  CP_BLK( );
                }
                else
                {
                  //### COMMAND 181 ###
                  NOP( );
                }
              }
              else
              {
                if( cmd < 183 )
                {
                  //### COMMAND 182 ###
                  CP_BLK_TR( );
                }
                else
                {
                  //### COMMAND 183 ###
                  CP_BLK_TR_C( );
                }
              }
            }
          }
          else
          {
            if( cmd < 188 )
            {
              if( cmd < 186 )
              {
                if( cmd < 185 )
                {
                  //### COMMAND 184 ###
                  NOP( );
                }
                else
                {
                  //### COMMAND 185 ###
                  NOP( );
                }
              }
              else
              {
                if( cmd < 187 )
                {
                  //### COMMAND 186 ###
                  NOP( );
                }
                else
                {
                  //### COMMAND 187 ###
                  NOP( );
                }
              }
            }
            else
            {
              if( cmd < 190 )
              {
                if( cmd < 189 )
                {
                  //### COMMAND 188 ###
                  NOP( );
                }
                else
                {
                  //### COMMAND 189 ###
                  NOP( );
                }
              }
              else
              {
                if( cmd < 191 )
                {
                  //### COMMAND 190 ###
                  NOP( );
                }
                else
                {
                  //### COMMAND 191 ###
                  NOP( );
                }
              }
            }
          }
        }
      }
    }
    else
    {
      if( cmd < 224 )
      {
        if( cmd < 208 )
        {
          if( cmd < 200 )
          {
            if( cmd < 196 )
            {
              if( cmd < 194 )
              {
                if( cmd < 193 )
                {
                  //### COMMAND 192 ###
                  DISPLAY( );
                }
                else
                {
                  //### COMMAND 193 ###
                  DISPLAY_CP( );
                }
              }
              else
              {
                if( cmd < 195 )
                {
                  //### COMMAND 194 ###
                  NOP( );
                }
                else
                {
                  //### COMMAND 195 ###
                  NOP( );
                }
              }
            }
            else
            {
              if( cmd < 198 )
              {
                if( cmd < 197 )
                {
                  //### COMMAND 196 ###
                  NOP( );
                }
                else
                {
                  //### COMMAND 197 ###
                  NOP( );
                }
              }
              else
              {
                if( cmd < 199 )
                {
                  //### COMMAND 198 ###
                  NOP( );
                }
                else
                {
                  //### COMMAND 199 ###
                  NOP( );
                }
              }
            }
          }
          else
          {
            if( cmd < 204 )
            {
              if( cmd < 202 )
              {
                if( cmd < 201 )
                {
                  //### COMMAND 200 ###
                  DELAY_DO( );
                }
                else
                {
                  //### COMMAND 201 ###
                  DELAY_DO_C( );
                }
              }
              else
              {
                if( cmd < 203 )
                {
                  //### COMMAND 202 ###
                  DELAY_START( );
                }
                else
                {
                  //### COMMAND 203 ###
                  DELAY_START_C( );
                }
              }
            }
            else
            {
              if( cmd < 206 )
              {
                if( cmd < 205 )
                {
                  //### COMMAND 204 ###
                  DELAY_CHECK( );
                }
                else
                {
                  //### COMMAND 205 ###
                  DELAY_WAIT( );
                }
              }
              else
              {
                if( cmd < 207 )
                {
                  //### COMMAND 206 ###
                  NOP( );
                }
                else
                {
                  //### COMMAND 207 ###
                  NOP( );
                }
              }
            }
          }
        }
        else
        {
          if( cmd < 216 )
          {
            if( cmd < 212 )
            {
              if( cmd < 210 )
              {
                if( cmd < 209 )
                {
                  //### COMMAND 208 ###
                  GET_KEYS( );
                }
                else
                {
                  //### COMMAND 209 ###
                  NOP( );
                }
              }
              else
              {
                if( cmd < 211 )
                {
                  //### COMMAND 210 ###
                  GET_SNES0( );
                }
                else
                {
                  //### COMMAND 211 ###
                  GET_SNES1( );
                }
              }
            }
            else
            {
              if( cmd < 214 )
              {
                if( cmd < 213 )
                {
                  //### COMMAND 212 ###
                  GET_TIME( );
                }
                else
                {
                  //### COMMAND 213 ###
                  SET_TIME( );
                }
              }
              else
              {
                if( cmd < 215 )
                {
                  //### COMMAND 214 ###
                  NOP( );
                }
                else
                {
                  //### COMMAND 215 ###
                  NOP( );
                }
              }
            }
          }
          else
          {
            if( cmd < 220 )
            {
              if( cmd < 218 )
              {
                if( cmd < 217 )
                {
                  //### COMMAND 216 ###
                  RND( );
                }
                else
                {
                  //### COMMAND 217 ###
                  NOP( );
                }
              }
              else
              {
                if( cmd < 219 )
                {
                  //### COMMAND 218 ###
                  NOP( );
                }
                else
                {
                  //### COMMAND 219 ###
                  NOP( );
                }
              }
            }
            else
            {
              if( cmd < 222 )
              {
                if( cmd < 221 )
                {
                  //### COMMAND 220 ###
                  NOP( );
                }
                else
                {
                  //### COMMAND 221 ###
                  NOP( );
                }
              }
              else
              {
                if( cmd < 223 )
                {
                  //### COMMAND 222 ###
                  NOP( );
                }
                else
                {
                  //### COMMAND 223 ###
                  NOP( );
                }
              }
            }
          }
        }
      }
      else
      {
        if( cmd < 240 )
        {
          if( cmd < 232 )
          {
            if( cmd < 228 )
            {
              if( cmd < 226 )
              {
                if( cmd < 225 )
                {
                  //### COMMAND 224 ###
                  NOP( );
                }
                else
                {
                  //### COMMAND 225 ###
                  NOP( );
                }
              }
              else
              {
                if( cmd < 227 )
                {
                  //### COMMAND 226 ###
                  NOP( );
                }
                else
                {
                  //### COMMAND 227 ###
                  NOP( );
                }
              }
            }
            else
            {
              if( cmd < 230 )
              {
                if( cmd < 229 )
                {
                  //### COMMAND 228 ###
                  NOP( );
                }
                else
                {
                  //### COMMAND 229 ###
                  NOP( );
                }
              }
              else
              {
                if( cmd < 231 )
                {
                  //### COMMAND 230 ###
                  NOP( );
                }
                else
                {
                  //### COMMAND 231 ###
                  NOP( );
                }
              }
            }
          }
          else
          {
            if( cmd < 236 )
            {
              if( cmd < 234 )
              {
                if( cmd < 233 )
                {
                  //### COMMAND 232 ###
                  NOP( );
                }
                else
                {
                  //### COMMAND 233 ###
                  NOP( );
                }
              }
              else
              {
                if( cmd < 235 )
                {
                  //### COMMAND 234 ###
                  NOP( );
                }
                else
                {
                  //### COMMAND 235 ###
                  NOP( );
                }
              }
            }
            else
            {
              if( cmd < 238 )
              {
                if( cmd < 237 )
                {
                  //### COMMAND 236 ###
                  NOP( );
                }
                else
                {
                  //### COMMAND 237 ###
                  NOP( );
                }
              }
              else
              {
                if( cmd < 239 )
                {
                  //### COMMAND 238 ###
                  NOP( );
                }
                else
                {
                  //### COMMAND 239 ###
                  NOP( );
                }
              }
            }
          }
        }
        else
        {
          if( cmd < 248 )
          {
            if( cmd < 244 )
            {
              if( cmd < 242 )
              {
                if( cmd < 241 )
                {
                  //### COMMAND 240 ###
                  NOP( );
                }
                else
                {
                  //### COMMAND 241 ###
                  NOP( );
                }
              }
              else
              {
                if( cmd < 243 )
                {
                  //### COMMAND 242 ###
                  NOP( );
                }
                else
                {
                  //### COMMAND 243 ###
                  NOP( );
                }
              }
            }
            else
            {
              if( cmd < 246 )
              {
                if( cmd < 245 )
                {
                  //### COMMAND 244 ###
                  NOP( );
                }
                else
                {
                  //### COMMAND 245 ###
                  NOP( );
                }
              }
              else
              {
                if( cmd < 247 )
                {
                  //### COMMAND 246 ###
                  NOP( );
                }
                else
                {
                  //### COMMAND 247 ###
                  NOP( );
                }
              }
            }
          }
          else
          {
            if( cmd < 252 )
            {
              if( cmd < 250 )
              {
                if( cmd < 249 )
                {
                  //### COMMAND 248 ###
                  NOP( );
                }
                else
                {
                  //### COMMAND 249 ###
                  NOP( );
                }
              }
              else
              {
                if( cmd < 251 )
                {
                  //### COMMAND 250 ###
                  NOP( );
                }
                else
                {
                  //### COMMAND 251 ###
                  NOP( );
                }
              }
            }
            else
            {
              if( cmd < 254 )
              {
                if( cmd < 253 )
                {
                  //### COMMAND 252 ###
                  NOP( );
                }
                else
                {
                  //### COMMAND 253 ###
                  NOP( );
                }
              }
              else
              {
                if( cmd < 255 )
                {
                  //### COMMAND 254 ###
                  NOP( );
                }
                else
                {
                  //### COMMAND 255 ###
                  NOP( );
                }
              }
            }
          }
        }
      }
    }
  }
} //for( cmd_no = 0; cmd_no < 10 && !delay_wait; cmd_no++ )

//go back to last frame
gotoAndPlay( "fRun" );
return;
