BeerWanter source code (version 6.1)

Technical facts

Application type(s)

Operating system(s) or programming environment(s)

NDS
Ubuntu 10.10 (maverick)
Windows XP

IDE(s):

Qt Creator 2.0.0

Project type:

GUI application

Compiler(s):

G++ 4.4.5

Libraries used:

Boost: version 1.42
libnds: version 1.4.7
Qt: version 4.7.0 (32 bit)
STL: GNU ISO C++ Library, version 4.4.5
Wt: version 3.1.2

Qt project file: GameBeerWanterNds.pro


#-------------------------------------------------

#

# Project created by QtCreator 2010-07-22T22:43:13

#

#-------------------------------------------------

SOURCES += mainNds.cpp

HEADERS  += \

    picbeer.h

CONFIG+=ARM9

INCLUDEPATH += /opt/devkitpro/libnds-1.4.7/include

INCLUDEPATH += /opt/devkitpro/libnds-src-1.4.7/include/nds

INCLUDEPATH += /opt/devkitpro/devkitARM/arm-eabi/include

LIBS += -L/opt/devkitpro/libnds-1.4.7/lib -lnds9

LIBS += -L/opt/devkitpro/devkitARM/arm-eabi/lib -lstdc++

DEFINES += ARM9

TARGET = BeerWanterNds

CONFIG   += console

CONFIG   -= qt

CONFIG   -= app_bundle

TEMPLATE = app

QMAKE_CC = /opt/devkitpro/devkitARM/bin/arm-eabi-g++

QMAKE_CXX = /opt/devkitpro/devkitARM/bin/arm-eabi-g++

QMAKE_LINK = /opt/devkitpro/devkitARM/bin/arm-eabi-g++

QMAKE_LFLAGS = -T/opt/devkitpro/devkitARM/arm-eabi/lib/ds_arm9.ld

Qt project file: GameBeerWanterUbuntu.pro


#-------------------------------------------------

#

# Project created by QtCreator 2010-07-22T22:43:13

#

#-------------------------------------------------

SOURCES += mainDesktop.cpp \

  beerwanterdialog.cpp \

    beerwanter.cpp \

    beerwanterqtwidget.cpp

HEADERS += \

  beerwanterdialog.h \

    beerwanter.h \

    beerwanterqtwidget.h

QT += core gui

TARGET = BeerWanterUbuntu

TEMPLATE = app

RESOURCES += \

    resources.qrc

FORMS += \

    beerwanterdialog.ui

Qt project file: GameBeerWanterWin.pro


#-------------------------------------------------

#

# Project created by QtCreator 2010-07-22T22:43:13

#

#-------------------------------------------------

SOURCES += mainDesktop.cpp \

  beerwanterdialog.cpp \

    beerwanterqtwidget.cpp \

    beerwanter.cpp

HEADERS  += \

  beerwanterdialog.h \

  picbeer.h \

    beerwanterqtwidget.h \

    beerwanter.h

QT       += core gui

TARGET = BeerWanterWin

TEMPLATE = app

RESOURCES += resources.qrc

FORMS += beerwanterdialog.ui

Qt project file: GameBeerWanterWt.pro


#-------------------------------------------------

#

# Project created by QtCreator 2010-07-22T22:43:13

#

#-------------------------------------------------

QT += core

QT -= gui

SOURCES += \

    beerwanter.cpp \

    mainWt.cpp \

    beerwanterwtwidget.cpp

HEADERS  += \

    beerwanter.h \

    beerwanterwtwidget.h \

    myassert.h

LIBS += -lwt -lwthttp

#Note: the flag below is a workaround for the following error:

#  http://richelbilderbeek.nl/CppCompileErrorCc1plusInternalCompilerErrorSegmentationFault.htm

#Drawback: all asserts will removed as well

QMAKE_CXXFLAGS += -DNDEBUG

TARGET = BeerWanterWt

CONFIG   += console

CONFIG   += qt

CONFIG   -= app_bundle

TEMPLATE = app

beerwanter.cpp


//---------------------------------------------------------------------------

/*

BeerWanter. A simple game.

Copyright (C) 2005-2010 Richel Bilderbeek



This program is free software: you can redistribute it and/or modify

it under the terms of the GNU General Public License as published by

the Free Software Foundation, either version 3 of the License, or

(at your option) any later version.



This program is distributed in the hope that it will be useful,

but WITHOUT ANY WARRANTY; without even the implied warranty of

MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.See the

GNU General Public License for more details.



You should have received a copy of the GNU General Public License

along with this program.If not, see <http://www.gnu.org/licenses/>.

*/

//---------------------------------------------------------------------------

//From hhtp://www.richelbilderbeek.nl/GameBeerWanter.htm

//---------------------------------------------------------------------------

#include <cstdlib>

#include <iostream>

#include <sstream>

#include <stdexcept>

//---------------------------------------------------------------------------

#include "beerwanter.h"

//---------------------------------------------------------------------------

BeerWanter::BeerWanter(

  int screen_width,

  int screen_height,

  int sprite_width,

  int sprite_height,

  int window_width,

  int window_height)

  : m_level(1),

   m_screen_height(screen_height),

   m_screen_width(screen_width),

   m_sprite_height(sprite_height),

   m_sprite_width(sprite_width),

   m_window_height(window_height),

   m_window_width(window_width)

{

  m_cursor_x = m_window_width  / 2;

  m_cursor_y = m_window_height / 2;

  m_sprite_x = (m_window_width  / 2) - (m_sprite_width  / 2);

  m_sprite_y = (m_window_height / 2) - (m_sprite_height / 2);

  m_window_x = (m_screen_width  / 2) - (m_window_width  / 2);

  m_window_y = (m_screen_height / 2) - (m_window_height / 2);

}

//---------------------------------------------------------------------------

bool BeerWanter::ClickWilBeSuccess() const

{

  return (

       (m_cursor_x >= m_sprite_x)

    && (m_cursor_x <= m_sprite_x + m_sprite_width)

    && (m_cursor_y >= m_sprite_y)

    && (m_cursor_y <= m_sprite_y + m_sprite_height));

}

//---------------------------------------------------------------------------

///Click is called when the user presses a key. The bool returned

///indicates whether the user successfully clicked on a beer

bool BeerWanter::Click()

{

  if (ClickWilBeSuccess())

  {

    //Clicked the sprite

    //Move the sprite to a new random position

    m_sprite_x = std::rand() % (m_window_width  - m_sprite_width );

    m_sprite_y = std::rand() % (m_window_height - m_sprite_height);



    ++m_level;



    return true;

  }

  return false;

}

//---------------------------------------------------------------------------

const std::vector<std::string> BeerWanter::GetLicence()

{

  std::vector<std::string> v;

  v.push_back("BeerWanter. A simple game.");

  v.push_back("Copyright (C) 2005-2010 Richel Bilderbeek");

  v.push_back("");

  v.push_back("This program is free software: you can redistribute it and/or modify");

  v.push_back("it under the terms of the GNU General Public License as published by");

  v.push_back("the Free Software Foundation, either version 3 of the License, or");

  v.push_back("(at your option) any later version.");

  v.push_back("");

  v.push_back("This program is distributed in the hope that it will be useful,");

  v.push_back("but WITHOUT ANY WARRANTY; without even the implied warranty of");

  v.push_back("MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.See the");

  v.push_back("GNU General Public License for more details.");

  v.push_back("");

  v.push_back("You should have received a copy of the GNU General Public License");

  v.push_back("along with this program.If not, see <http://www.gnu.org/licenses/>.");

  v.push_back("");  return v;

}

//---------------------------------------------------------------------------

int BeerWanter::GetRandomCursorShake() const

{

  return (std::rand() % (2*((m_level-1)/2)+1))

    - ((m_level-1)/2);

}

//---------------------------------------------------------------------------

int BeerWanter::GetRandomWindowShake() const

{

  return (std::rand() % (2*((m_level-1)/4)+1))

    - ((m_level-1)/4);

}

//---------------------------------------------------------------------------

const std::string BeerWanter::GetVersion()

{

  return "6.1";

}

//---------------------------------------------------------------------------

const std::vector<std::string> BeerWanter::GetVersionHistory()

{

  std::vector<std::string> v;

  v.push_back("YYYY-MM-DD: version X.Y: [description]");

  v.push_back("2005-11-16: version 1.0: (at that time called) 'Beerwanter 1' was programmed in C++ using the C++ Builder IDE during a 'Spass programmieren' session, which made BeerWanter a game for Windows users only.");

  v.push_back("2005-11-18: version 2.0: (at that time called) 'Beerwanter 2' was programmed after the success of BeerWanter 1.0. The game was made tougher.");

  v.push_back("2005-11-22: version 3.0: (at that time called) 'Beerwanter 3' was programmed after the success of BeerWanter 2.0. The game was made even tougher.");

  v.push_back("2010-06-23: version 4.0: port code to Qt Creator, BeerWanter is now cross-platform. The game its name is changed back to 'BeerWanter'.");

  v.push_back("2010-06-24: version 5.0: improved the GUI, changed the beer sprite to an adaptation of my favorite beer.");

  v.push_back("2010-10-10: version 5.1: (temporary NDS-only fork) start of port to NDS.");

  v.push_back("2010-10-11: version 5.2: BeerWanter is one project again and build for NDS, Ubuntu and Windows.");

  v.push_back("2010-12-19: version 6.0: seperated project files for NDS, Ubuntu and Windows development. Preparation for seperating game logic from GUI.");

  v.push_back("2010-12-23: version 6.1: added ClickWilBeSuccess method, fixed bug in BeerWanter::ShakeWindow");

  return v;

}

//---------------------------------------------------------------------------

const std::string BeerWanter::GetWindowTitle() const

{

  return std::string("BeerWanter (C) 2005 Richel Bilderbeek. Beer already got: ")

    + IntToStr(m_level - 1);

}

//---------------------------------------------------------------------------

void BeerWanter::SetCursorPos(const int x, const int y)

{

  m_cursor_x = x;

  m_cursor_y = y;

}

//---------------------------------------------------------------------------

///ShakeCursor shakes the cursor

void BeerWanter::ShakeCursor()

{

  //std::clog

  //  << "ShakeCursor: ("

  //  << m_cursor_x

  //  << ","

  //  << m_cursor_y

  //  << ") -> (";



  //Note that cursor is allowed to leave the window :-)

  m_cursor_x += GetRandomCursorShake();

  m_cursor_y += GetRandomCursorShake();



  //std::clog

  //  << m_cursor_x

  //  << ","

  //  << m_cursor_y

  //  << ")\n";

}

//---------------------------------------------------------------------------

///ShakeWindow shakes the window (on desktop computer only)

void BeerWanter::ShakeWindow()

{

  m_window_x += GetRandomWindowShake();

  m_window_y += GetRandomWindowShake();

}

//---------------------------------------------------------------------------

///From http://www.richelbilderbeek.nl/CppIntToStr.htm

const std::string IntToStr(const int x)

{

  std::ostringstream s;

  if (!(s << x)) throw std::logic_error("IntToStr failed");

  return s.str();

}

//---------------------------------------------------------------------------

beerwanter.h


//---------------------------------------------------------------------------

/*

BeerWanter. A simple game.

Copyright (C) 2005-2010 Richel Bilderbeek



This program is free software: you can redistribute it and/or modify

it under the terms of the GNU General Public License as published by

the Free Software Foundation, either version 3 of the License, or

(at your option) any later version.



This program is distributed in the hope that it will be useful,

but WITHOUT ANY WARRANTY; without even the implied warranty of

MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.See the

GNU General Public License for more details.



You should have received a copy of the GNU General Public License

along with this program.If not, see <http://www.gnu.org/licenses/>.

*/

//---------------------------------------------------------------------------

//From hhtp://www.richelbilderbeek.nl/GameBeerWanter.htm

//---------------------------------------------------------------------------

#ifndef BEERWANTER_H

#define BEERWANTER_H

//---------------------------------------------------------------------------

#include <string>

#include <vector>

//---------------------------------------------------------------------------

///BeerWanter contains the logic behind the game BeerWanter

struct BeerWanter

{

  BeerWanter(

    int screen_width,

    int screen_height,

    int sprite_width,

    int sprite_height,

    int window_width,

    int window_height);

  bool Click();

  bool ClickWilBeSuccess() const;

  int GetCursorX() const { return m_cursor_x; }

  int GetCursorY() const { return m_cursor_y; }

  int GetLevel() const { return m_level; }

  int GetSpriteX() const { return m_sprite_x; }

  int GetSpriteY() const { return m_sprite_y; }

  int GetSpriteHeight() const { return m_sprite_height; }

  int GetSpriteWidth()  const { return m_sprite_width ; }

  int GetWindowHeight() const { return m_window_height; }

  const std::string GetWindowTitle() const;

  int GetWindowWidth()  const { return m_window_width ; }

  int GetWindowX() const { return m_window_x; }

  int GetWindowY() const { return m_window_y; }



  static const std::vector<std::string> GetLicence();

  static const std::string GetVersion();

  static const std::vector<std::string> GetVersionHistory();

  void SetArenaSize(const int width, const int height);

  void SetCursorPos(const int x, const int y);

  void SetSpriteSize(const int width, const int height);

  void ShakeCursor();

  void ShakeWindow();

  void Tick();



  private:

  int m_cursor_x;

  int m_cursor_y;

  int m_level;

  const int m_screen_height;

  const int m_screen_width;

  int m_sprite_x;

  int m_sprite_y;

  const int m_sprite_height;

  const int m_sprite_width;

  const int m_window_height;

  const int m_window_width;

  int m_window_x;

  int m_window_y;



  int GetRandomCursorShake() const;

  int GetRandomWindowShake() const;

};

//---------------------------------------------------------------------------

///From http://www.richelbilderbeek.nl/CppIntToStr.htm

const std::string IntToStr(const int x);

//---------------------------------------------------------------------------

#endif // BEERWANTER_H

beerwanterdialog.cpp


//---------------------------------------------------------------------------

/*

BeerWanter. A simple game.

Copyright (C) 2005-2010 Richel Bilderbeek



This program is free software: you can redistribute it and/or modify

it under the terms of the GNU General Public License as published by

the Free Software Foundation, either version 3 of the License, or

(at your option) any later version.



This program is distributed in the hope that it will be useful,

but WITHOUT ANY WARRANTY; without even the implied warranty of

MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.See the

GNU General Public License for more details.



You should have received a copy of the GNU General Public License

along with this program.If not, see <http://www.gnu.org/licenses/>.

*/

//---------------------------------------------------------------------------

//From hhtp://www.richelbilderbeek.nl/GameBeerWanter.htm

//---------------------------------------------------------------------------

#include <iostream>

//---------------------------------------------------------------------------

#include "beerwanter.h"

#include "beerwanterdialog.h"

#include "beerwanterqtwidget.h"

#include "ui_beerwanterdialog.h"

//---------------------------------------------------------------------------

BeerWanterDialog::BeerWanterDialog(QWidget *parent) :

    QDialog(parent),

    ui(new Ui::BeerWanterDialog),

    m_widget(new BeerWanterQtWidget)

{

  ui->setupUi(this);

  ui->beerwanter_layout->addWidget(m_widget.get());

  this->setGeometry(

    m_widget->GetBeerWanter()->GetWindowX(),

    m_widget->GetBeerWanter()->GetWindowY(),

    m_widget->GetBeerWanter()->GetWindowWidth(),

    m_widget->GetBeerWanter()->GetWindowHeight());



  QObject::connect(m_widget.get(),SIGNAL(LevelUp(const std::string&)),

    this,SLOT(ChangeTitle(const std::string&)));

  QObject::connect(m_widget.get(),SIGNAL(DoShake(const int,const int)),

    this,SLOT(OnShake(const int,const int)));

}

//---------------------------------------------------------------------------

BeerWanterDialog::~BeerWanterDialog()

{

  delete ui;

}

//---------------------------------------------------------------------------

void BeerWanterDialog::ChangeTitle(const std::string& title)

{

  this->setWindowTitle(title.c_str());

}

//---------------------------------------------------------------------------

void BeerWanterDialog::OnShake(const int x, const int y)

{

  this->setGeometry(x,y,this->width(),this->height());

  this->repaint();

}

//---------------------------------------------------------------------------

beerwanterdialog.h


//---------------------------------------------------------------------------

/*

BeerWanter. A simple game.

Copyright (C) 2005-2010 Richel Bilderbeek



This program is free software: you can redistribute it and/or modify

it under the terms of the GNU General Public License as published by

the Free Software Foundation, either version 3 of the License, or

(at your option) any later version.



This program is distributed in the hope that it will be useful,

but WITHOUT ANY WARRANTY; without even the implied warranty of

MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.See the

GNU General Public License for more details.



You should have received a copy of the GNU General Public License

along with this program.If not, see <http://www.gnu.org/licenses/>.

*/

//---------------------------------------------------------------------------

//From hhtp://www.richelbilderbeek.nl/GameBeerWanter.htm

//---------------------------------------------------------------------------

#ifndef BEERWANTERDIALOG_H

#define BEERWANTERDIALOG_H

//---------------------------------------------------------------------------

#include <boost/shared_ptr.hpp>

#include <QDialog>

//---------------------------------------------------------------------------

struct BeerWanterQtWidget;

//---------------------------------------------------------------------------

namespace Ui {

  class BeerWanterDialog;

}

//---------------------------------------------------------------------------

class BeerWanterDialog : public QDialog

{

  Q_OBJECT



public:

  explicit BeerWanterDialog(QWidget *parent = 0);

  ~BeerWanterDialog();

private:

  Ui::BeerWanterDialog *ui;

  boost::shared_ptr<BeerWanterQtWidget> m_widget;



private slots:

  void ChangeTitle(const std::string& title);

  void OnShake(const int x, const int y);

};

//---------------------------------------------------------------------------

#endif // BEERWANTERDIALOG_H

beerwanterqtwidget.cpp


//---------------------------------------------------------------------------

/*

BeerWanter. A simple game.

Copyright (C) 2005-2010 Richel Bilderbeek



This program is free software: you can redistribute it and/or modify

it under the terms of the GNU General Public License as published by

the Free Software Foundation, either version 3 of the License, or

(at your option) any later version.



This program is distributed in the hope that it will be useful,

but WITHOUT ANY WARRANTY; without even the implied warranty of

MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.See the

GNU General Public License for more details.



You should have received a copy of the GNU General Public License

along with this program.If not, see <http://www.gnu.org/licenses/>.

*/

//---------------------------------------------------------------------------

//From hhtp://www.richelbilderbeek.nl/GameBeerWanter.htm

//---------------------------------------------------------------------------

#include <iostream>

//---------------------------------------------------------------------------

#include <boost/lexical_cast.hpp>

//---------------------------------------------------------------------------

#include <QApplication>

#include <QDesktopWidget>

#include <QGraphicsPixmapItem>

#include <QGraphicsScene>

#include <QGraphicsView>

#include <QImage>

#include <QMouseEvent>

#include <QTimer>

#include <QVBoxLayout>

//---------------------------------------------------------------------------

#include "beerwanter.h"

#include "beerwanterqtwidget.h"

//---------------------------------------------------------------------------

BeerWanterQtWidget::BeerWanterQtWidget(QWidget *parent)

  : QWidget(parent),

    m_timer(new QTimer),

    m_sprite(new QPixmap(":/Beer.png"))

{

  assert(!m_sprite.get()->isNull());



  this->setMouseTracking(true);



  m_beerwanter.reset(

    new BeerWanter(

      QApplication::desktop()->width(),

      QApplication::desktop()->height(),

      m_sprite->width(),

      m_sprite->height(),

      520,

      520));



  //Ensure the window does not get resized

  this->setFixedHeight(m_beerwanter->GetWindowHeight());

  this->setFixedWidth(m_beerwanter->GetWindowWidth());



  m_timer->connect(m_timer.get(),SIGNAL(timeout()),this,SLOT(onTimer()));

  m_timer->start(20); //Framerate about (1000/20=) 50 fps

}

//---------------------------------------------------------------------------

const BeerWanter * BeerWanterQtWidget::GetBeerWanter() const

{

  return m_beerwanter.get();

}

//---------------------------------------------------------------------------

void BeerWanterQtWidget::mouseMoveEvent(QMouseEvent * event)

{

  const int mouse_x = event->x();

  const int mouse_y = event->y();

  //#define DEBUG_SHOW_MOUSE_POSITION

  #ifdef DEBUG_SHOW_MOUSE_POSITION

  m_debug_text

    = "MOVE: ("

    + boost::lexical_cast<std::string>(mouse_x)

    + ","

    + boost::lexical_cast<std::string>(mouse_y)

    + ")";

  if (m_beerwanter->ClickWilBeSuccess())

  {

    m_debug_text += "-> CLICK WILL BE SUCCESS";

  }

  const int sprite_x = m_beerwanter->GetSpriteX();

  const int sprite_y = m_beerwanter->GetSpriteX();

  const int sprite_maxx = m_beerwanter->GetSpriteX() + m_beerwanter->GetSpriteWidth();

  const int sprite_maxy = m_beerwanter->GetSpriteY() + m_beerwanter->GetSpriteHeight();

  m_debug_text += ", Sprite: ("

    + boost::lexical_cast<std::string>(sprite_x)

    + ","

    + boost::lexical_cast<std::string>(sprite_y)

    + ")-("

    + boost::lexical_cast<std::string>(sprite_maxx)

    + ","

    + boost::lexical_cast<std::string>(sprite_maxy)

    + ")";

  #endif

  assert(event->type() == ::QMouseEvent::MouseMove);

  assert(event);

  m_beerwanter->SetCursorPos(mouse_x,mouse_y);

  this->repaint();

}

//---------------------------------------------------------------------------

void BeerWanterQtWidget::mousePressEvent(QMouseEvent * event)

{

  //#define DEBUG_SHOW_MOUSE_CLICK_POSITION

  #ifdef DEBUG_SHOW_MOUSE_CLICK_POSITION

  const int mouse_x = event->x();

  const int mouse_y = event->y();

  m_debug_text

    = "CLICK: ("

    + boost::lexical_cast<std::string>(mouse_x)

    + ","

    + boost::lexical_cast<std::string>(mouse_y)

    + ")";

  #endif

  if (m_beerwanter->Click())

  {

    //Inform user of level-up

    emit LevelUp(m_beerwanter->GetWindowTitle());

  }

  this->repaint();

}

//---------------------------------------------------------------------------

void BeerWanterQtWidget::onTimer()

{

  m_beerwanter->ShakeCursor();



  const int mouse_x = m_beerwanter->GetCursorX();

  const int mouse_y = m_beerwanter->GetCursorY();

  //#define DEBUG_SHOW_MOUSE_TIMER_POSITION

  #ifdef DEBUG_SHOW_MOUSE_TIMER_POSITION

  m_debug_text

    = "ONTIMER: ("

    + boost::lexical_cast<std::string>(mouse_x)

    + ","

    + boost::lexical_cast<std::string>(mouse_y)

    + ")";

  #endif



  const QPoint base_pos = this->mapToGlobal(QPoint(0,0));

  #ifdef DEBUG_SHOW_MOUSE_TIMER_POSITION

  m_debug_text

    += "-> ("

    + boost::lexical_cast<std::string>(base_pos.x())

    + ","

    + boost::lexical_cast<std::string>(base_pos.y())

    + ")";

  #endif



  this->cursor().setPos(

    base_pos.x() + mouse_x,base_pos.y() + mouse_y);



  //Move window

  m_beerwanter->ShakeWindow();

  //BeerWanterQtWidget cannot shake itself

  emit DoShake(m_beerwanter->GetWindowX(),m_beerwanter->GetWindowY());

  this->repaint();

}

//---------------------------------------------------------------------------

void BeerWanterQtWidget::paintEvent(QPaintEvent *)

{

  QPainter painter(this);



  QPixmap p(this->width(),this->height());

  Paint(

    p,

    //std::rand() % 256, std::rand() % 256, std::rand() % 256);

    255,255,255);

  painter.drawPixmap(0,0,p);



  //#define DEBUG_SHOW_BEERWANTER_INFO

  #ifdef DEBUG_SHOW_BEERWANTER_INFO

  painter.drawText(QRectF(0.0,0.0,this->width(),this->height()),m_debug_text.c_str());

  #endif



  assert(m_sprite);

  painter.drawPixmap(

    m_beerwanter->GetSpriteX(),

    m_beerwanter->GetSpriteY(),

    *m_sprite.get());

}

//---------------------------------------------------------------------------

//From http://www.richelbilderbeek.nl/CppPaint.htm

void Paint(

  QPixmap& pixmap,

  const unsigned char r,

  const unsigned char g,

  const unsigned char b,

  const unsigned char a) //Opaque

{

  const int width = pixmap.width();

  const int height = pixmap.height();



  QImage image = pixmap.toImage();



  assert(image.bytesPerLine() / width == 4

    && "Assume there are 4 bytes per pixel");



  for (int y=0; y!=height; ++y)

  {

    unsigned char * const line

      = static_cast<unsigned char *>(image.scanLine(y));

    for (int x=0; x!=width; ++x)

    {

      line[x*4+3] = a; //Alpha value

      line[x*4+2] = r; //Red

      line[x*4+1] = g; //Green

      line[x*4+0] = b; //Blue

    }

  }

  pixmap = pixmap.fromImage(image);

}

//---------------------------------------------------------------------------

beerwanterqtwidget.h


//---------------------------------------------------------------------------

/*

BeerWanter. A simple game.

Copyright (C) 2005-2010 Richel Bilderbeek



This program is free software: you can redistribute it and/or modify

it under the terms of the GNU General Public License as published by

the Free Software Foundation, either version 3 of the License, or

(at your option) any later version.



This program is distributed in the hope that it will be useful,

but WITHOUT ANY WARRANTY; without even the implied warranty of

MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.See the

GNU General Public License for more details.



You should have received a copy of the GNU General Public License

along with this program.If not, see <http://www.gnu.org/licenses/>.

*/

//---------------------------------------------------------------------------

//From hhtp://www.richelbilderbeek.nl/GameBeerWanter.htm

//---------------------------------------------------------------------------

#ifndef BEERWANTERWIDGET_H

#define BEERWANTERWIDGET_H

//---------------------------------------------------------------------------

#include <boost/scoped_ptr.hpp>

#include <boost/shared_ptr.hpp>

#include <QWidget>

#include "beerwanter.h"

//---------------------------------------------------------------------------

struct BeerWanter;

//struct QGraphicsPixmapItem;

//struct QGraphicsScene;

//struct QGraphicsView;

struct QMouseEvent;

struct QPixmap;

//struct QVBoxLayout;

struct QTimer;

//---------------------------------------------------------------------------

class BeerWanterQtWidget : public QWidget

{

  Q_OBJECT



public:

  explicit BeerWanterQtWidget(QWidget *parent = 0);

  const BeerWanter * GetBeerWanter() const;



private:

  boost::shared_ptr<QTimer> m_timer;

  boost::shared_ptr<QPixmap> m_sprite;

  void mousePressEvent(QMouseEvent * event);

  virtual void mouseMoveEvent(QMouseEvent * event);

  boost::scoped_ptr<BeerWanter> m_beerwanter;

  void paintEvent(QPaintEvent *);

  std::string m_debug_text;



private slots:

  void onTimer();



signals:

  void DoShake(const int x,const int y);

  void LevelUp(const std::string&);

};

//---------------------------------------------------------------------------

//From http://www.richelbilderbeek.nl/CppPaint.htm

void Paint(

  QPixmap& pixmap,

  const unsigned char r,

  const unsigned char g,

  const unsigned char b,

  const unsigned char a = 255); //Opaque

//---------------------------------------------------------------------------

#endif // BEERWANTERWIDGET_H

//---------------------------------------------------------------------------

beerwanterwtwidget.cpp


//---------------------------------------------------------------------------

#include <Wt/WBreak>

#include <Wt/WContainerWidget>

#include <Wt/WFileResource>

#include <Wt/WImage>

#include <Wt/WLineEdit>

#include <Wt/WPainter>

#include <Wt/WPushButton>

#include <Wt/WResource>

#include <Wt/WText>

#include <Wt/WTextArea>

//---------------------------------------------------------------------------

#include "beerwanter.h"

#include "beerwanterwtwidget.h"

//Cannot use assert due to the following error:

//  http://richelbilderbeek.nl/CppCompileErrorCc1plusInternalCompilerErrorSegmentationFault.htm

//#define MY_NDEBUG to disable this Assert

#include "myassert.h"

//---------------------------------------------------------------------------

BeerWanterWtWidget::BeerWanterWtWidget(

  Wt::WContainerWidget *parent)

  : Wt::WPaintedWidget(parent),

    m_image(new Wt::WPainter::Image("Beer.png",39,102)),

    m_beerwanter(new BeerWanter(600,500,39,102,600,500))

{

  Assert(m_image);

  this->resize(

    m_beerwanter->GetWindowWidth(),

    m_beerwanter->GetWindowHeight());

  this->mouseMoved().connect(this, &BeerWanterWtWidget::OnMouseMove);

  this->mouseWentDown().connect(this, &BeerWanterWtWidget::OnClick);

  this->update();

}

//---------------------------------------------------------------------------

void BeerWanterWtWidget::OnClick(const Wt::WMouseEvent& e)

{

  #ifdef DEBUG_SHOW_MOUSE_CLICK_POSITION

  const int mouse_x = e.widget().x;

  const int mouse_y = e.widget().y;

  m_debug_text

    = "CLICK: ("

    + boost::lexical_cast<std::string>(mouse_x)

    + ","

    + boost::lexical_cast<std::string>(mouse_y)

    + ")";

  #endif

  m_beerwanter->Click();

  this->update();

}

//---------------------------------------------------------------------------

void BeerWanterWtWidget::OnMouseMove(const Wt::WMouseEvent& e)

{

  const int mouse_x = e.widget().x;

  const int mouse_y = e.widget().y;

  #ifdef DEBUG_SHOW_MOUSE_POSITION

  m_debug_text

    = "MOVE: ("

    + boost::lexical_cast<std::string>(mouse_x)

    + ","

    + boost::lexical_cast<std::string>(mouse_y)

    + ")";

  if (m_beerwanter->ClickWilBeSuccess())

  {

    m_debug_text += "-> CLICK WILL BE SUCCESS";

  }

  const int sprite_x = m_beerwanter->GetSpriteX();

  const int sprite_y = m_beerwanter->GetSpriteX();

  const int sprite_maxx = m_beerwanter->GetSpriteX() + m_beerwanter->GetSpriteWidth();

  const int sprite_maxy = m_beerwanter->GetSpriteY() + m_beerwanter->GetSpriteHeight();

  m_debug_text += ", Sprite: ("

    + boost::lexical_cast<std::string>(sprite_x)

    + ","

    + boost::lexical_cast<std::string>(sprite_y)

    + ")-("

    + boost::lexical_cast<std::string>(sprite_maxx)

    + ","

    + boost::lexical_cast<std::string>(sprite_maxy)

    + ")";

  #endif



  m_beerwanter->SetCursorPos(

    mouse_x,

    mouse_y);

  this->update();

}

//---------------------------------------------------------------------------

void BeerWanterWtWidget::paintEvent(Wt::WPaintDevice *paintDevice)

{

  Wt::WPainter painter(paintDevice);

  //Display the current level

  painter.drawText(

    0,0,

    m_beerwanter->GetWindowWidth(),

    m_beerwanter->GetWindowHeight(),

    Wt::AlignCenter | Wt::AlignMiddle,

    boost::lexical_cast<std::string>(m_beerwanter->GetLevel()));

  //Display the sprite

  painter.drawImage(

    m_beerwanter->GetSpriteX(),

    m_beerwanter->GetSpriteY(),

    *m_image);

  //#define DEBUG_SHOW_GRID

  #ifdef DEBUG_SHOW_GRID

  for (int x = 0; x!= 600; x+=100)

    painter.drawLine(x,0,x,600);

  for (int y = 0; y!= 600; y+=100)

    painter.drawLine(0,y,600,y);

  #endif

}

//---------------------------------------------------------------------------

beerwanterwtwidget.h


#ifndef BEERWANTERWT_H

#define BEERWANTERWT_H

//---------------------------------------------------------------------------

#include <boost/shared_ptr.hpp>

//---------------------------------------------------------------------------

#include <Wt/WContainerWidget>

#include <Wt/WPaintedWidget>

#include <Wt/WPainter>

//---------------------------------------------------------------------------

namespace Wt

{

  struct WPaintDevice;

  struct WPaintedWidget;

  struct WPainter;

};

//---------------------------------------------------------------------------

struct BeerWanter;

//---------------------------------------------------------------------------

struct BeerWanterWtWidget : public Wt::WPaintedWidget

{

public:

  BeerWanterWtWidget(

    Wt::WContainerWidget *parent = 0);

  ~BeerWanterWtWidget() {}



protected:

   void paintEvent(Wt::WPaintDevice *paintDevice);



private:

  Wt::WPainter::Image * m_image;

  boost::shared_ptr<BeerWanter> m_beerwanter;



  std::string m_debug_text;



  void OnClick(const Wt::WMouseEvent& e);

  void OnMouseMove(const Wt::WMouseEvent& e);

};

//---------------------------------------------------------------------------

#endif // BEERWANTERWT_H

mainDesktop.cpp


//---------------------------------------------------------------------------

/*

BeerWanter. A simple game.

Copyright (C) 2005-2010 Richel Bilderbeek



This program is free software: you can redistribute it and/or modify

it under the terms of the GNU General Public License as published by

the Free Software Foundation, either version 3 of the License, or

(at your option) any later version.



This program is distributed in the hope that it will be useful,

but WITHOUT ANY WARRANTY; without even the implied warranty of

MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.See the

GNU General Public License for more details.



You should have received a copy of the GNU General Public License

along with this program.If not, see <http://www.gnu.org/licenses/>.

*/

//---------------------------------------------------------------------------

//From hhtp://www.richelbilderbeek.nl/GameBeerWanter.htm

//---------------------------------------------------------------------------

#include <QtGui/QApplication>

#include "beerwanterdialog.h"

//---------------------------------------------------------------------------

int main(int argc, char *argv[])

{

  QApplication a(argc, argv);

  BeerWanterDialog w;

  w.show();

  return a.exec();

}

//---------------------------------------------------------------------------

mainNds.cpp


//---------------------------------------------------------------------------

/*

  BeerWanter. A simple game.

  Copyright (C) 2005-2010 Richel Bilderbeek



  This program is free software: you can redistribute it and/or modify

  it under the terms of the GNU General Public License as published by

  the Free Software Foundation, either version 3 of the License, or

  (at your option) any later version.



  This program is distributed in the hope that it will be useful,

  but WITHOUT ANY WARRANTY; without even the implied warranty of

  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.See the

  GNU General Public License for more details.



  You should have received a copy of the GNU General Public License

  along with this program.If not, see <http://www.gnu.org/licenses/>.

*/

//---------------------------------------------------------------------------

//From hhtp://www.richelbilderbeek.nl/GameBeerWanter.htm

//---------------------------------------------------------------------------

#include <cstdlib>

#include <iostream>

#include <nds.h>

#include "picbeer.h"



int main()

{

  //Initialization, thanks to http://dev-scene.com/NDS/Tutorials_Day_3

  //point our video buffer to the start of bitmap background video

  u16 * const video_buffer_main = BG_BMP_RAM(0);

  u16 * const video_buffer_sub  = BG_BMP_RAM_SUB(0);

  //set video mode to mode 5 with background 3 enabled

  videoSetMode(   MODE_5_2D | DISPLAY_BG3_ACTIVE);

  videoSetModeSub(MODE_5_2D | DISPLAY_BG3_ACTIVE);



  //map vram a to start of main background graphics memory

  vramSetBankA(VRAM_A_MAIN_BG_0x06000000);

  vramSetBankC(VRAM_C_SUB_BG_0x06200000);



  //initialize the background

  BACKGROUND.control[3] = BG_BMP16_256x256 | BG_BMP_BASE(0);

  BACKGROUND.bg3_rotation.hdy = 0;

  BACKGROUND.bg3_rotation.hdx = 1 << 8;

  BACKGROUND.bg3_rotation.vdx = 0;

  BACKGROUND.bg3_rotation.vdy = 1 << 8;



  //initialize the sub background

  BACKGROUND_SUB.control[3] = BG_BMP16_256x256 | BG_BMP_BASE(0);

  BACKGROUND_SUB.bg3_rotation.hdy = 0;

  BACKGROUND_SUB.bg3_rotation.hdx = 1 << 8;

  BACKGROUND_SUB.bg3_rotation.vdx = 0;

  BACKGROUND_SUB.bg3_rotation.vdy = 1 << 8;



  const int maxx = SCREEN_WIDTH;

  const int maxy = SCREEN_HEIGHT;

  const PicBeer pic = PicBeer();

  int x = (maxx / 2) - (pic.GetWidth()  / 2);

  int y = (maxy / 2) - (pic.GetHeight() / 2);



  while(1)

  {

    //swiWaitForVBlank();

    pic.Draw(video_buffer_main,x,y);

    pic.Draw(video_buffer_sub,x,y);

    //Respond to keys

    scanKeys();

    const int held = keysHeld();

    if (held & KEY_RIGHT) { if (x + 1 + pic.GetWidth() < maxx) ++x; }

    if (held & KEY_LEFT) { --x; if (x<0) x=0; }

    if (held & KEY_DOWN) { if (y + 1 + pic.GetHeight() < maxy) ++y; }

    if (held & KEY_UP) { --y; if (y<0) y=0; }

    if (held & KEY_A) break;

    if (held & KEY_B) break;

    if (held & KEY_L) break;

    if (held & KEY_R) break;

  }

  systemShutDown();

}

mainWt.cpp


//---------------------------------------------------------------------------

/*

BeerWanter. A simple game.

Copyright (C) 2005-2010 Richel Bilderbeek



This program is free software: you can redistribute it and/or modify

it under the terms of the GNU General Public License as published by

the Free Software Foundation, either version 3 of the License, or

(at your option) any later version.



This program is distributed in the hope that it will be useful,

but WITHOUT ANY WARRANTY; without even the implied warranty of

MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.See the

GNU General Public License for more details.



You should have received a copy of the GNU General Public License

along with this program.If not, see <http://www.gnu.org/licenses/>.

*/

//---------------------------------------------------------------------------

//From hhtp://www.richelbilderbeek.nl/GameBeerWanter.htm

//---------------------------------------------------------------------------

#include <Wt/WApplication>

//---------------------------------------------------------------------------

#include "beerwanterwtwidget.h"

//---------------------------------------------------------------------------

#include <Wt/WApplication>

#include <Wt/WContainerWidget>

//---------------------------------------------------------------------------

struct BeerWanterWtApplication : public Wt::WApplication

{

  BeerWanterWtApplication(const Wt::WEnvironment& env)

  : Wt::WApplication(env),

    m_widget(new BeerWanterWtWidget)

  {

    this->setTitle("BeerWanter");

    root()->addWidget(m_widget);

  }

  private:

  BeerWanterWtWidget * const m_widget;

  void OnLevelUp();

};

//---------------------------------------------------------------------------

Wt::WApplication * createApplication(const Wt::WEnvironment& env)

{

  return new BeerWanterWtApplication(env);

}

//---------------------------------------------------------------------------

int main(int argc, char **argv)

{

  return WRun(argc, argv, &createApplication);

}

//---------------------------------------------------------------------------

myassert.h


#ifndef MYASSERT_H

#define MYASSERT_H



//From http://www.richelbilderbeek.nl/CppQtAssert.htm

#ifdef MY_NDEBUG

  #define Assert(x) ((void)0)

#else

  #include <iostream>

  #include <stdexcept>



  #define Assert(x)                      \

  if (!(x))                             \

  {                                      \

    std::cout                            \

      << "ERROR!! Assertion "            \

      <<  std::string (#x)               \

      <<  " failed\n on line "           \

      <<  (__LINE__)                     \

      <<  "\n in file "                  \

      <<  __FILE__                       \

      << std::endl;                      \

      throw std::logic_error(            \

        "Assertion failed");             \

  }



#endif



#endif // MYASSERT_H

picbeer.h


#ifndef PICBEER_H

#define PICBEER_H



#ifdef ARM9



#include <nds.h>

#include <iostream>



//Code generated by PicToCode

//From http://www.richelbilderbeek.nl/ToolPicToCode.htm

struct PicBeer

{

  void Draw(u16 * const buffer,const int x,const int y) const

  {

    const int maxx = 256;

    //const int maxy = 192;

    buffer[((y+0)*maxx)+(x+0)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+0)*maxx)+(x+1)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+0)*maxx)+(x+2)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+0)*maxx)+(x+3)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+0)*maxx)+(x+4)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+0)*maxx)+(x+5)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+0)*maxx)+(x+6)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+0)*maxx)+(x+7)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+0)*maxx)+(x+8)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+0)*maxx)+(x+9)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+0)*maxx)+(x+10)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+0)*maxx)+(x+11)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+0)*maxx)+(x+12)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+0)*maxx)+(x+13)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+0)*maxx)+(x+14)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+0)*maxx)+(x+15)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+0)*maxx)+(x+16)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+0)*maxx)+(x+17)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+0)*maxx)+(x+18)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+0)*maxx)+(x+19)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+0)*maxx)+(x+20)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+0)*maxx)+(x+21)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+0)*maxx)+(x+22)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+0)*maxx)+(x+23)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+0)*maxx)+(x+24)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+0)*maxx)+(x+25)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+0)*maxx)+(x+26)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+0)*maxx)+(x+27)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+0)*maxx)+(x+28)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+0)*maxx)+(x+29)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+0)*maxx)+(x+30)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+0)*maxx)+(x+31)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+0)*maxx)+(x+32)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+0)*maxx)+(x+33)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+0)*maxx)+(x+34)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+0)*maxx)+(x+35)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+0)*maxx)+(x+36)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+0)*maxx)+(x+37)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+0)*maxx)+(x+38)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+0)*maxx)+(x+39)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+0)*maxx)+(x+40)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+1)*maxx)+(x+0)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+1)*maxx)+(x+1)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+1)*maxx)+(x+2)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+1)*maxx)+(x+3)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+1)*maxx)+(x+4)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+1)*maxx)+(x+5)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+1)*maxx)+(x+6)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+1)*maxx)+(x+7)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+1)*maxx)+(x+8)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+1)*maxx)+(x+9)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+1)*maxx)+(x+10)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+1)*maxx)+(x+11)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+1)*maxx)+(x+12)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+1)*maxx)+(x+13)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+1)*maxx)+(x+14)] = RGB15(16,16,16) | BIT(15);

    buffer[((y+1)*maxx)+(x+15)] = RGB15(16,16,16) | BIT(15);

    buffer[((y+1)*maxx)+(x+16)] = RGB15(16,16,16) | BIT(15);

    buffer[((y+1)*maxx)+(x+17)] = RGB15(16,16,16) | BIT(15);

    buffer[((y+1)*maxx)+(x+18)] = RGB15(16,16,16) | BIT(15);

    buffer[((y+1)*maxx)+(x+19)] = RGB15(16,16,16) | BIT(15);

    buffer[((y+1)*maxx)+(x+20)] = RGB15(16,16,16) | BIT(15);

    buffer[((y+1)*maxx)+(x+21)] = RGB15(16,16,16) | BIT(15);

    buffer[((y+1)*maxx)+(x+22)] = RGB15(16,16,16) | BIT(15);

    buffer[((y+1)*maxx)+(x+23)] = RGB15(16,16,16) | BIT(15);

    buffer[((y+1)*maxx)+(x+24)] = RGB15(16,16,16) | BIT(15);

    buffer[((y+1)*maxx)+(x+25)] = RGB15(16,16,16) | BIT(15);

    buffer[((y+1)*maxx)+(x+26)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+1)*maxx)+(x+27)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+1)*maxx)+(x+28)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+1)*maxx)+(x+29)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+1)*maxx)+(x+30)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+1)*maxx)+(x+31)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+1)*maxx)+(x+32)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+1)*maxx)+(x+33)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+1)*maxx)+(x+34)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+1)*maxx)+(x+35)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+1)*maxx)+(x+36)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+1)*maxx)+(x+37)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+1)*maxx)+(x+38)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+1)*maxx)+(x+39)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+1)*maxx)+(x+40)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+2)*maxx)+(x+0)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+2)*maxx)+(x+1)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+2)*maxx)+(x+2)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+2)*maxx)+(x+3)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+2)*maxx)+(x+4)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+2)*maxx)+(x+5)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+2)*maxx)+(x+6)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+2)*maxx)+(x+7)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+2)*maxx)+(x+8)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+2)*maxx)+(x+9)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+2)*maxx)+(x+10)] = RGB15(16,16,16) | BIT(15);

    buffer[((y+2)*maxx)+(x+11)] = RGB15(16,16,16) | BIT(15);

    buffer[((y+2)*maxx)+(x+12)] = RGB15(16,16,16) | BIT(15);

    buffer[((y+2)*maxx)+(x+13)] = RGB15(16,16,16) | BIT(15);

    buffer[((y+2)*maxx)+(x+14)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+2)*maxx)+(x+15)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+2)*maxx)+(x+16)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+2)*maxx)+(x+17)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+2)*maxx)+(x+18)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+2)*maxx)+(x+19)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+2)*maxx)+(x+20)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+2)*maxx)+(x+21)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+2)*maxx)+(x+22)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+2)*maxx)+(x+23)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+2)*maxx)+(x+24)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+2)*maxx)+(x+25)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+2)*maxx)+(x+26)] = RGB15(16,16,16) | BIT(15);

    buffer[((y+2)*maxx)+(x+27)] = RGB15(16,16,16) | BIT(15);

    buffer[((y+2)*maxx)+(x+28)] = RGB15(16,16,16) | BIT(15);

    buffer[((y+2)*maxx)+(x+29)] = RGB15(16,16,16) | BIT(15);

    buffer[((y+2)*maxx)+(x+30)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+2)*maxx)+(x+31)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+2)*maxx)+(x+32)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+2)*maxx)+(x+33)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+2)*maxx)+(x+34)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+2)*maxx)+(x+35)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+2)*maxx)+(x+36)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+2)*maxx)+(x+37)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+2)*maxx)+(x+38)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+2)*maxx)+(x+39)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+2)*maxx)+(x+40)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+3)*maxx)+(x+0)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+3)*maxx)+(x+1)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+3)*maxx)+(x+2)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+3)*maxx)+(x+3)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+3)*maxx)+(x+4)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+3)*maxx)+(x+5)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+3)*maxx)+(x+6)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+3)*maxx)+(x+7)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+3)*maxx)+(x+8)] = RGB15(16,16,16) | BIT(15);

    buffer[((y+3)*maxx)+(x+9)] = RGB15(16,16,16) | BIT(15);

    buffer[((y+3)*maxx)+(x+10)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+3)*maxx)+(x+11)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+3)*maxx)+(x+12)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+3)*maxx)+(x+13)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+3)*maxx)+(x+14)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+3)*maxx)+(x+15)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+3)*maxx)+(x+16)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+3)*maxx)+(x+17)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+3)*maxx)+(x+18)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+3)*maxx)+(x+19)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+3)*maxx)+(x+20)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+3)*maxx)+(x+21)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+3)*maxx)+(x+22)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+3)*maxx)+(x+23)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+3)*maxx)+(x+24)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+3)*maxx)+(x+25)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+3)*maxx)+(x+26)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+3)*maxx)+(x+27)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+3)*maxx)+(x+28)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+3)*maxx)+(x+29)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+3)*maxx)+(x+30)] = RGB15(16,16,16) | BIT(15);

    buffer[((y+3)*maxx)+(x+31)] = RGB15(16,16,16) | BIT(15);

    buffer[((y+3)*maxx)+(x+32)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+3)*maxx)+(x+33)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+3)*maxx)+(x+34)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+3)*maxx)+(x+35)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+3)*maxx)+(x+36)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+3)*maxx)+(x+37)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+3)*maxx)+(x+38)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+3)*maxx)+(x+39)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+3)*maxx)+(x+40)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+4)*maxx)+(x+0)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+4)*maxx)+(x+1)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+4)*maxx)+(x+2)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+4)*maxx)+(x+3)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+4)*maxx)+(x+4)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+4)*maxx)+(x+5)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+4)*maxx)+(x+6)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+4)*maxx)+(x+7)] = RGB15(16,16,16) | BIT(15);

    buffer[((y+4)*maxx)+(x+8)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+4)*maxx)+(x+9)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+4)*maxx)+(x+10)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+4)*maxx)+(x+11)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+4)*maxx)+(x+12)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+4)*maxx)+(x+13)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+4)*maxx)+(x+14)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+4)*maxx)+(x+15)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+4)*maxx)+(x+16)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+4)*maxx)+(x+17)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+4)*maxx)+(x+18)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+4)*maxx)+(x+19)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+4)*maxx)+(x+20)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+4)*maxx)+(x+21)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+4)*maxx)+(x+22)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+4)*maxx)+(x+23)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+4)*maxx)+(x+24)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+4)*maxx)+(x+25)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+4)*maxx)+(x+26)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+4)*maxx)+(x+27)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+4)*maxx)+(x+28)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+4)*maxx)+(x+29)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+4)*maxx)+(x+30)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+4)*maxx)+(x+31)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+4)*maxx)+(x+32)] = RGB15(16,16,16) | BIT(15);

    buffer[((y+4)*maxx)+(x+33)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+4)*maxx)+(x+34)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+4)*maxx)+(x+35)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+4)*maxx)+(x+36)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+4)*maxx)+(x+37)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+4)*maxx)+(x+38)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+4)*maxx)+(x+39)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+4)*maxx)+(x+40)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+5)*maxx)+(x+0)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+5)*maxx)+(x+1)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+5)*maxx)+(x+2)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+5)*maxx)+(x+3)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+5)*maxx)+(x+4)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+5)*maxx)+(x+5)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+5)*maxx)+(x+6)] = RGB15(16,16,16) | BIT(15);

    buffer[((y+5)*maxx)+(x+7)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+5)*maxx)+(x+8)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+5)*maxx)+(x+9)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+5)*maxx)+(x+10)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+5)*maxx)+(x+11)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+5)*maxx)+(x+12)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+5)*maxx)+(x+13)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+5)*maxx)+(x+14)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+5)*maxx)+(x+15)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+5)*maxx)+(x+16)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+5)*maxx)+(x+17)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+5)*maxx)+(x+18)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+5)*maxx)+(x+19)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+5)*maxx)+(x+20)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+5)*maxx)+(x+21)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+5)*maxx)+(x+22)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+5)*maxx)+(x+23)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+5)*maxx)+(x+24)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+5)*maxx)+(x+25)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+5)*maxx)+(x+26)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+5)*maxx)+(x+27)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+5)*maxx)+(x+28)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+5)*maxx)+(x+29)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+5)*maxx)+(x+30)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+5)*maxx)+(x+31)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+5)*maxx)+(x+32)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+5)*maxx)+(x+33)] = RGB15(16,16,16) | BIT(15);

    buffer[((y+5)*maxx)+(x+34)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+5)*maxx)+(x+35)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+5)*maxx)+(x+36)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+5)*maxx)+(x+37)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+5)*maxx)+(x+38)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+5)*maxx)+(x+39)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+5)*maxx)+(x+40)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+6)*maxx)+(x+0)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+6)*maxx)+(x+1)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+6)*maxx)+(x+2)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+6)*maxx)+(x+3)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+6)*maxx)+(x+4)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+6)*maxx)+(x+5)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+6)*maxx)+(x+6)] = RGB15(16,16,16) | BIT(15);

    buffer[((y+6)*maxx)+(x+7)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+6)*maxx)+(x+8)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+6)*maxx)+(x+9)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+6)*maxx)+(x+10)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+6)*maxx)+(x+11)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+6)*maxx)+(x+12)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+6)*maxx)+(x+13)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+6)*maxx)+(x+14)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+6)*maxx)+(x+15)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+6)*maxx)+(x+16)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+6)*maxx)+(x+17)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+6)*maxx)+(x+18)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+6)*maxx)+(x+19)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+6)*maxx)+(x+20)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+6)*maxx)+(x+21)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+6)*maxx)+(x+22)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+6)*maxx)+(x+23)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+6)*maxx)+(x+24)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+6)*maxx)+(x+25)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+6)*maxx)+(x+26)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+6)*maxx)+(x+27)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+6)*maxx)+(x+28)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+6)*maxx)+(x+29)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+6)*maxx)+(x+30)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+6)*maxx)+(x+31)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+6)*maxx)+(x+32)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+6)*maxx)+(x+33)] = RGB15(16,16,16) | BIT(15);

    buffer[((y+6)*maxx)+(x+34)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+6)*maxx)+(x+35)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+6)*maxx)+(x+36)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+6)*maxx)+(x+37)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+6)*maxx)+(x+38)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+6)*maxx)+(x+39)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+6)*maxx)+(x+40)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+7)*maxx)+(x+0)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+7)*maxx)+(x+1)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+7)*maxx)+(x+2)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+7)*maxx)+(x+3)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+7)*maxx)+(x+4)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+7)*maxx)+(x+5)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+7)*maxx)+(x+6)] = RGB15(16,16,16) | BIT(15);

    buffer[((y+7)*maxx)+(x+7)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+7)*maxx)+(x+8)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+7)*maxx)+(x+9)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+7)*maxx)+(x+10)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+7)*maxx)+(x+11)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+7)*maxx)+(x+12)] = RGB15(16,16,16) | BIT(15);

    buffer[((y+7)*maxx)+(x+13)] = RGB15(16,16,16) | BIT(15);

    buffer[((y+7)*maxx)+(x+14)] = RGB15(16,16,16) | BIT(15);

    buffer[((y+7)*maxx)+(x+15)] = RGB15(16,16,16) | BIT(15);

    buffer[((y+7)*maxx)+(x+16)] = RGB15(16,16,16) | BIT(15);

    buffer[((y+7)*maxx)+(x+17)] = RGB15(16,16,16) | BIT(15);

    buffer[((y+7)*maxx)+(x+18)] = RGB15(16,16,16) | BIT(15);

    buffer[((y+7)*maxx)+(x+19)] = RGB15(16,16,16) | BIT(15);

    buffer[((y+7)*maxx)+(x+20)] = RGB15(16,16,16) | BIT(15);

    buffer[((y+7)*maxx)+(x+21)] = RGB15(16,16,16) | BIT(15);

    buffer[((y+7)*maxx)+(x+22)] = RGB15(16,16,16) | BIT(15);

    buffer[((y+7)*maxx)+(x+23)] = RGB15(16,16,16) | BIT(15);

    buffer[((y+7)*maxx)+(x+24)] = RGB15(16,16,16) | BIT(15);

    buffer[((y+7)*maxx)+(x+25)] = RGB15(16,16,16) | BIT(15);

    buffer[((y+7)*maxx)+(x+26)] = RGB15(16,16,16) | BIT(15);

    buffer[((y+7)*maxx)+(x+27)] = RGB15(16,16,16) | BIT(15);

    buffer[((y+7)*maxx)+(x+28)] = RGB15(16,16,16) | BIT(15);

    buffer[((y+7)*maxx)+(x+29)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+7)*maxx)+(x+30)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+7)*maxx)+(x+31)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+7)*maxx)+(x+32)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+7)*maxx)+(x+33)] = RGB15(16,16,16) | BIT(15);

    buffer[((y+7)*maxx)+(x+34)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+7)*maxx)+(x+35)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+7)*maxx)+(x+36)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+7)*maxx)+(x+37)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+7)*maxx)+(x+38)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+7)*maxx)+(x+39)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+7)*maxx)+(x+40)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+8)*maxx)+(x+0)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+8)*maxx)+(x+1)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+8)*maxx)+(x+2)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+8)*maxx)+(x+3)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+8)*maxx)+(x+4)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+8)*maxx)+(x+5)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+8)*maxx)+(x+6)] = RGB15(16,16,16) | BIT(15);

    buffer[((y+8)*maxx)+(x+7)] = RGB15(16,16,16) | BIT(15);

    buffer[((y+8)*maxx)+(x+8)] = RGB15(16,16,16) | BIT(15);

    buffer[((y+8)*maxx)+(x+9)] = RGB15(16,16,16) | BIT(15);

    buffer[((y+8)*maxx)+(x+10)] = RGB15(16,16,16) | BIT(15);

    buffer[((y+8)*maxx)+(x+11)] = RGB15(16,16,16) | BIT(15);

    buffer[((y+8)*maxx)+(x+12)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+8)*maxx)+(x+13)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+8)*maxx)+(x+14)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+8)*maxx)+(x+15)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+8)*maxx)+(x+16)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+8)*maxx)+(x+17)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+8)*maxx)+(x+18)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+8)*maxx)+(x+19)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+8)*maxx)+(x+20)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+8)*maxx)+(x+21)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+8)*maxx)+(x+22)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+8)*maxx)+(x+23)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+8)*maxx)+(x+24)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+8)*maxx)+(x+25)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+8)*maxx)+(x+26)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+8)*maxx)+(x+27)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+8)*maxx)+(x+28)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+8)*maxx)+(x+29)] = RGB15(16,16,16) | BIT(15);

    buffer[((y+8)*maxx)+(x+30)] = RGB15(16,16,16) | BIT(15);

    buffer[((y+8)*maxx)+(x+31)] = RGB15(16,16,16) | BIT(15);

    buffer[((y+8)*maxx)+(x+32)] = RGB15(16,16,16) | BIT(15);

    buffer[((y+8)*maxx)+(x+33)] = RGB15(16,16,16) | BIT(15);

    buffer[((y+8)*maxx)+(x+34)] = RGB15(16,16,16) | BIT(15);

    buffer[((y+8)*maxx)+(x+35)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+8)*maxx)+(x+36)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+8)*maxx)+(x+37)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+8)*maxx)+(x+38)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+8)*maxx)+(x+39)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+8)*maxx)+(x+40)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+9)*maxx)+(x+0)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+9)*maxx)+(x+1)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+9)*maxx)+(x+2)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+9)*maxx)+(x+3)] = RGB15(16,16,16) | BIT(15);

    buffer[((y+9)*maxx)+(x+4)] = RGB15(16,16,16) | BIT(15);

    buffer[((y+9)*maxx)+(x+5)] = RGB15(16,16,16) | BIT(15);

    buffer[((y+9)*maxx)+(x+6)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+9)*maxx)+(x+7)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+9)*maxx)+(x+8)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+9)*maxx)+(x+9)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+9)*maxx)+(x+10)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+9)*maxx)+(x+11)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+9)*maxx)+(x+12)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+9)*maxx)+(x+13)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+9)*maxx)+(x+14)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+9)*maxx)+(x+15)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+9)*maxx)+(x+16)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+9)*maxx)+(x+17)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+9)*maxx)+(x+18)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+9)*maxx)+(x+19)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+9)*maxx)+(x+20)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+9)*maxx)+(x+21)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+9)*maxx)+(x+22)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+9)*maxx)+(x+23)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+9)*maxx)+(x+24)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+9)*maxx)+(x+25)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+9)*maxx)+(x+26)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+9)*maxx)+(x+27)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+9)*maxx)+(x+28)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+9)*maxx)+(x+29)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+9)*maxx)+(x+30)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+9)*maxx)+(x+31)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+9)*maxx)+(x+32)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+9)*maxx)+(x+33)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+9)*maxx)+(x+34)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+9)*maxx)+(x+35)] = RGB15(16,16,16) | BIT(15);

    buffer[((y+9)*maxx)+(x+36)] = RGB15(16,16,16) | BIT(15);

    buffer[((y+9)*maxx)+(x+37)] = RGB15(16,16,16) | BIT(15);

    buffer[((y+9)*maxx)+(x+38)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+9)*maxx)+(x+39)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+9)*maxx)+(x+40)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+10)*maxx)+(x+0)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+10)*maxx)+(x+1)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+10)*maxx)+(x+2)] = RGB15(16,16,16) | BIT(15);

    buffer[((y+10)*maxx)+(x+3)] = RGB15(16,16,16) | BIT(15);

    buffer[((y+10)*maxx)+(x+4)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+10)*maxx)+(x+5)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+10)*maxx)+(x+6)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+10)*maxx)+(x+7)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+10)*maxx)+(x+8)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+10)*maxx)+(x+9)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+10)*maxx)+(x+10)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+10)*maxx)+(x+11)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+10)*maxx)+(x+12)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+10)*maxx)+(x+13)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+10)*maxx)+(x+14)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+10)*maxx)+(x+15)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+10)*maxx)+(x+16)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+10)*maxx)+(x+17)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+10)*maxx)+(x+18)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+10)*maxx)+(x+19)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+10)*maxx)+(x+20)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+10)*maxx)+(x+21)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+10)*maxx)+(x+22)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+10)*maxx)+(x+23)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+10)*maxx)+(x+24)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+10)*maxx)+(x+25)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+10)*maxx)+(x+26)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+10)*maxx)+(x+27)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+10)*maxx)+(x+28)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+10)*maxx)+(x+29)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+10)*maxx)+(x+30)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+10)*maxx)+(x+31)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+10)*maxx)+(x+32)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+10)*maxx)+(x+33)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+10)*maxx)+(x+34)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+10)*maxx)+(x+35)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+10)*maxx)+(x+36)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+10)*maxx)+(x+37)] = RGB15(16,16,16) | BIT(15);

    buffer[((y+10)*maxx)+(x+38)] = RGB15(16,16,16) | BIT(15);

    buffer[((y+10)*maxx)+(x+39)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+10)*maxx)+(x+40)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+11)*maxx)+(x+0)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+11)*maxx)+(x+1)] = RGB15(16,16,16) | BIT(15);

    buffer[((y+11)*maxx)+(x+2)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+11)*maxx)+(x+3)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+11)*maxx)+(x+4)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+11)*maxx)+(x+5)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+11)*maxx)+(x+6)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+11)*maxx)+(x+7)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+11)*maxx)+(x+8)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+11)*maxx)+(x+9)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+11)*maxx)+(x+10)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+11)*maxx)+(x+11)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+11)*maxx)+(x+12)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+11)*maxx)+(x+13)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+11)*maxx)+(x+14)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+11)*maxx)+(x+15)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+11)*maxx)+(x+16)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+11)*maxx)+(x+17)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+11)*maxx)+(x+18)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+11)*maxx)+(x+19)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+11)*maxx)+(x+20)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+11)*maxx)+(x+21)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+11)*maxx)+(x+22)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+11)*maxx)+(x+23)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+11)*maxx)+(x+24)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+11)*maxx)+(x+25)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+11)*maxx)+(x+26)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+11)*maxx)+(x+27)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+11)*maxx)+(x+28)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+11)*maxx)+(x+29)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+11)*maxx)+(x+30)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+11)*maxx)+(x+31)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+11)*maxx)+(x+32)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+11)*maxx)+(x+33)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+11)*maxx)+(x+34)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+11)*maxx)+(x+35)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+11)*maxx)+(x+36)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+11)*maxx)+(x+37)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+11)*maxx)+(x+38)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+11)*maxx)+(x+39)] = RGB15(16,16,16) | BIT(15);

    buffer[((y+11)*maxx)+(x+40)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+12)*maxx)+(x+0)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+12)*maxx)+(x+1)] = RGB15(16,16,16) | BIT(15);

    buffer[((y+12)*maxx)+(x+2)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+12)*maxx)+(x+3)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+12)*maxx)+(x+4)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+12)*maxx)+(x+5)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+12)*maxx)+(x+6)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+12)*maxx)+(x+7)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+12)*maxx)+(x+8)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+12)*maxx)+(x+9)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+12)*maxx)+(x+10)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+12)*maxx)+(x+11)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+12)*maxx)+(x+12)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+12)*maxx)+(x+13)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+12)*maxx)+(x+14)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+12)*maxx)+(x+15)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+12)*maxx)+(x+16)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+12)*maxx)+(x+17)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+12)*maxx)+(x+18)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+12)*maxx)+(x+19)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+12)*maxx)+(x+20)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+12)*maxx)+(x+21)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+12)*maxx)+(x+22)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+12)*maxx)+(x+23)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+12)*maxx)+(x+24)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+12)*maxx)+(x+25)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+12)*maxx)+(x+26)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+12)*maxx)+(x+27)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+12)*maxx)+(x+28)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+12)*maxx)+(x+29)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+12)*maxx)+(x+30)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+12)*maxx)+(x+31)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+12)*maxx)+(x+32)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+12)*maxx)+(x+33)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+12)*maxx)+(x+34)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+12)*maxx)+(x+35)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+12)*maxx)+(x+36)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+12)*maxx)+(x+37)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+12)*maxx)+(x+38)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+12)*maxx)+(x+39)] = RGB15(16,16,16) | BIT(15);

    buffer[((y+12)*maxx)+(x+40)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+13)*maxx)+(x+0)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+13)*maxx)+(x+1)] = RGB15(16,16,16) | BIT(15);

    buffer[((y+13)*maxx)+(x+2)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+13)*maxx)+(x+3)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+13)*maxx)+(x+4)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+13)*maxx)+(x+5)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+13)*maxx)+(x+6)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+13)*maxx)+(x+7)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+13)*maxx)+(x+8)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+13)*maxx)+(x+9)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+13)*maxx)+(x+10)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+13)*maxx)+(x+11)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+13)*maxx)+(x+12)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+13)*maxx)+(x+13)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+13)*maxx)+(x+14)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+13)*maxx)+(x+15)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+13)*maxx)+(x+16)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+13)*maxx)+(x+17)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+13)*maxx)+(x+18)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+13)*maxx)+(x+19)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+13)*maxx)+(x+20)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+13)*maxx)+(x+21)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+13)*maxx)+(x+22)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+13)*maxx)+(x+23)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+13)*maxx)+(x+24)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+13)*maxx)+(x+25)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+13)*maxx)+(x+26)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+13)*maxx)+(x+27)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+13)*maxx)+(x+28)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+13)*maxx)+(x+29)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+13)*maxx)+(x+30)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+13)*maxx)+(x+31)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+13)*maxx)+(x+32)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+13)*maxx)+(x+33)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+13)*maxx)+(x+34)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+13)*maxx)+(x+35)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+13)*maxx)+(x+36)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+13)*maxx)+(x+37)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+13)*maxx)+(x+38)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+13)*maxx)+(x+39)] = RGB15(16,16,16) | BIT(15);

    buffer[((y+13)*maxx)+(x+40)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+14)*maxx)+(x+0)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+14)*maxx)+(x+1)] = RGB15(16,16,16) | BIT(15);

    buffer[((y+14)*maxx)+(x+2)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+14)*maxx)+(x+3)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+14)*maxx)+(x+4)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+14)*maxx)+(x+5)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+14)*maxx)+(x+6)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+14)*maxx)+(x+7)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+14)*maxx)+(x+8)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+14)*maxx)+(x+9)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+14)*maxx)+(x+10)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+14)*maxx)+(x+11)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+14)*maxx)+(x+12)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+14)*maxx)+(x+13)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+14)*maxx)+(x+14)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+14)*maxx)+(x+15)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+14)*maxx)+(x+16)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+14)*maxx)+(x+17)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+14)*maxx)+(x+18)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+14)*maxx)+(x+19)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+14)*maxx)+(x+20)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+14)*maxx)+(x+21)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+14)*maxx)+(x+22)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+14)*maxx)+(x+23)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+14)*maxx)+(x+24)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+14)*maxx)+(x+25)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+14)*maxx)+(x+26)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+14)*maxx)+(x+27)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+14)*maxx)+(x+28)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+14)*maxx)+(x+29)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+14)*maxx)+(x+30)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+14)*maxx)+(x+31)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+14)*maxx)+(x+32)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+14)*maxx)+(x+33)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+14)*maxx)+(x+34)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+14)*maxx)+(x+35)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+14)*maxx)+(x+36)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+14)*maxx)+(x+37)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+14)*maxx)+(x+38)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+14)*maxx)+(x+39)] = RGB15(16,16,16) | BIT(15);

    buffer[((y+14)*maxx)+(x+40)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+15)*maxx)+(x+0)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+15)*maxx)+(x+1)] = RGB15(16,16,16) | BIT(15);

    buffer[((y+15)*maxx)+(x+2)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+15)*maxx)+(x+3)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+15)*maxx)+(x+4)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+15)*maxx)+(x+5)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+15)*maxx)+(x+6)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+15)*maxx)+(x+7)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+15)*maxx)+(x+8)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+15)*maxx)+(x+9)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+15)*maxx)+(x+10)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+15)*maxx)+(x+11)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+15)*maxx)+(x+12)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+15)*maxx)+(x+13)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+15)*maxx)+(x+14)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+15)*maxx)+(x+15)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+15)*maxx)+(x+16)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+15)*maxx)+(x+17)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+15)*maxx)+(x+18)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+15)*maxx)+(x+19)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+15)*maxx)+(x+20)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+15)*maxx)+(x+21)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+15)*maxx)+(x+22)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+15)*maxx)+(x+23)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+15)*maxx)+(x+24)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+15)*maxx)+(x+25)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+15)*maxx)+(x+26)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+15)*maxx)+(x+27)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+15)*maxx)+(x+28)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+15)*maxx)+(x+29)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+15)*maxx)+(x+30)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+15)*maxx)+(x+31)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+15)*maxx)+(x+32)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+15)*maxx)+(x+33)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+15)*maxx)+(x+34)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+15)*maxx)+(x+35)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+15)*maxx)+(x+36)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+15)*maxx)+(x+37)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+15)*maxx)+(x+38)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+15)*maxx)+(x+39)] = RGB15(16,16,16) | BIT(15);

    buffer[((y+15)*maxx)+(x+40)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+16)*maxx)+(x+0)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+16)*maxx)+(x+1)] = RGB15(16,16,16) | BIT(15);

    buffer[((y+16)*maxx)+(x+2)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+16)*maxx)+(x+3)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+16)*maxx)+(x+4)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+16)*maxx)+(x+5)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+16)*maxx)+(x+6)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+16)*maxx)+(x+7)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+16)*maxx)+(x+8)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+16)*maxx)+(x+9)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+16)*maxx)+(x+10)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+16)*maxx)+(x+11)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+16)*maxx)+(x+12)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+16)*maxx)+(x+13)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+16)*maxx)+(x+14)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+16)*maxx)+(x+15)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+16)*maxx)+(x+16)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+16)*maxx)+(x+17)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+16)*maxx)+(x+18)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+16)*maxx)+(x+19)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+16)*maxx)+(x+20)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+16)*maxx)+(x+21)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+16)*maxx)+(x+22)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+16)*maxx)+(x+23)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+16)*maxx)+(x+24)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+16)*maxx)+(x+25)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+16)*maxx)+(x+26)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+16)*maxx)+(x+27)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+16)*maxx)+(x+28)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+16)*maxx)+(x+29)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+16)*maxx)+(x+30)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+16)*maxx)+(x+31)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+16)*maxx)+(x+32)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+16)*maxx)+(x+33)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+16)*maxx)+(x+34)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+16)*maxx)+(x+35)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+16)*maxx)+(x+36)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+16)*maxx)+(x+37)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+16)*maxx)+(x+38)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+16)*maxx)+(x+39)] = RGB15(16,16,16) | BIT(15);

    buffer[((y+16)*maxx)+(x+40)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+17)*maxx)+(x+0)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+17)*maxx)+(x+1)] = RGB15(16,16,16) | BIT(15);

    buffer[((y+17)*maxx)+(x+2)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+17)*maxx)+(x+3)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+17)*maxx)+(x+4)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+17)*maxx)+(x+5)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+17)*maxx)+(x+6)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+17)*maxx)+(x+7)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+17)*maxx)+(x+8)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+17)*maxx)+(x+9)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+17)*maxx)+(x+10)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+17)*maxx)+(x+11)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+17)*maxx)+(x+12)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+17)*maxx)+(x+13)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+17)*maxx)+(x+14)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+17)*maxx)+(x+15)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+17)*maxx)+(x+16)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+17)*maxx)+(x+17)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+17)*maxx)+(x+18)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+17)*maxx)+(x+19)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+17)*maxx)+(x+20)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+17)*maxx)+(x+21)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+17)*maxx)+(x+22)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+17)*maxx)+(x+23)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+17)*maxx)+(x+24)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+17)*maxx)+(x+25)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+17)*maxx)+(x+26)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+17)*maxx)+(x+27)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+17)*maxx)+(x+28)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+17)*maxx)+(x+29)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+17)*maxx)+(x+30)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+17)*maxx)+(x+31)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+17)*maxx)+(x+32)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+17)*maxx)+(x+33)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+17)*maxx)+(x+34)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+17)*maxx)+(x+35)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+17)*maxx)+(x+36)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+17)*maxx)+(x+37)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+17)*maxx)+(x+38)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+17)*maxx)+(x+39)] = RGB15(16,16,16) | BIT(15);

    buffer[((y+17)*maxx)+(x+40)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+18)*maxx)+(x+0)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+18)*maxx)+(x+1)] = RGB15(16,16,16) | BIT(15);

    buffer[((y+18)*maxx)+(x+2)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+18)*maxx)+(x+3)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+18)*maxx)+(x+4)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+18)*maxx)+(x+5)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+18)*maxx)+(x+6)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+18)*maxx)+(x+7)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+18)*maxx)+(x+8)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+18)*maxx)+(x+9)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+18)*maxx)+(x+10)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+18)*maxx)+(x+11)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+18)*maxx)+(x+12)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+18)*maxx)+(x+13)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+18)*maxx)+(x+14)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+18)*maxx)+(x+15)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+18)*maxx)+(x+16)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+18)*maxx)+(x+17)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+18)*maxx)+(x+18)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+18)*maxx)+(x+19)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+18)*maxx)+(x+20)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+18)*maxx)+(x+21)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+18)*maxx)+(x+22)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+18)*maxx)+(x+23)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+18)*maxx)+(x+24)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+18)*maxx)+(x+25)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+18)*maxx)+(x+26)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+18)*maxx)+(x+27)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+18)*maxx)+(x+28)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+18)*maxx)+(x+29)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+18)*maxx)+(x+30)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+18)*maxx)+(x+31)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+18)*maxx)+(x+32)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+18)*maxx)+(x+33)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+18)*maxx)+(x+34)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+18)*maxx)+(x+35)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+18)*maxx)+(x+36)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+18)*maxx)+(x+37)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+18)*maxx)+(x+38)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+18)*maxx)+(x+39)] = RGB15(16,16,16) | BIT(15);

    buffer[((y+18)*maxx)+(x+40)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+19)*maxx)+(x+0)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+19)*maxx)+(x+1)] = RGB15(16,16,16) | BIT(15);

    buffer[((y+19)*maxx)+(x+2)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+19)*maxx)+(x+3)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+19)*maxx)+(x+4)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+19)*maxx)+(x+5)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+19)*maxx)+(x+6)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+19)*maxx)+(x+7)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+19)*maxx)+(x+8)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+19)*maxx)+(x+9)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+19)*maxx)+(x+10)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+19)*maxx)+(x+11)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+19)*maxx)+(x+12)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+19)*maxx)+(x+13)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+19)*maxx)+(x+14)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+19)*maxx)+(x+15)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+19)*maxx)+(x+16)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+19)*maxx)+(x+17)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+19)*maxx)+(x+18)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+19)*maxx)+(x+19)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+19)*maxx)+(x+20)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+19)*maxx)+(x+21)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+19)*maxx)+(x+22)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+19)*maxx)+(x+23)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+19)*maxx)+(x+24)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+19)*maxx)+(x+25)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+19)*maxx)+(x+26)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+19)*maxx)+(x+27)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+19)*maxx)+(x+28)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+19)*maxx)+(x+29)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+19)*maxx)+(x+30)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+19)*maxx)+(x+31)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+19)*maxx)+(x+32)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+19)*maxx)+(x+33)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+19)*maxx)+(x+34)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+19)*maxx)+(x+35)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+19)*maxx)+(x+36)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+19)*maxx)+(x+37)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+19)*maxx)+(x+38)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+19)*maxx)+(x+39)] = RGB15(16,16,16) | BIT(15);

    buffer[((y+19)*maxx)+(x+40)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+20)*maxx)+(x+0)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+20)*maxx)+(x+1)] = RGB15(16,16,16) | BIT(15);

    buffer[((y+20)*maxx)+(x+2)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+20)*maxx)+(x+3)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+20)*maxx)+(x+4)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+20)*maxx)+(x+5)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+20)*maxx)+(x+6)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+20)*maxx)+(x+7)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+20)*maxx)+(x+8)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+20)*maxx)+(x+9)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+20)*maxx)+(x+10)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+20)*maxx)+(x+11)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+20)*maxx)+(x+12)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+20)*maxx)+(x+13)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+20)*maxx)+(x+14)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+20)*maxx)+(x+15)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+20)*maxx)+(x+16)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+20)*maxx)+(x+17)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+20)*maxx)+(x+18)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+20)*maxx)+(x+19)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+20)*maxx)+(x+20)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+20)*maxx)+(x+21)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+20)*maxx)+(x+22)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+20)*maxx)+(x+23)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+20)*maxx)+(x+24)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+20)*maxx)+(x+25)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+20)*maxx)+(x+26)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+20)*maxx)+(x+27)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+20)*maxx)+(x+28)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+20)*maxx)+(x+29)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+20)*maxx)+(x+30)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+20)*maxx)+(x+31)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+20)*maxx)+(x+32)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+20)*maxx)+(x+33)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+20)*maxx)+(x+34)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+20)*maxx)+(x+35)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+20)*maxx)+(x+36)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+20)*maxx)+(x+37)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+20)*maxx)+(x+38)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+20)*maxx)+(x+39)] = RGB15(16,16,16) | BIT(15);

    buffer[((y+20)*maxx)+(x+40)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+21)*maxx)+(x+0)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+21)*maxx)+(x+1)] = RGB15(16,16,16) | BIT(15);

    buffer[((y+21)*maxx)+(x+2)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+21)*maxx)+(x+3)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+21)*maxx)+(x+4)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+21)*maxx)+(x+5)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+21)*maxx)+(x+6)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+21)*maxx)+(x+7)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+21)*maxx)+(x+8)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+21)*maxx)+(x+9)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+21)*maxx)+(x+10)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+21)*maxx)+(x+11)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+21)*maxx)+(x+12)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+21)*maxx)+(x+13)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+21)*maxx)+(x+14)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+21)*maxx)+(x+15)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+21)*maxx)+(x+16)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+21)*maxx)+(x+17)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+21)*maxx)+(x+18)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+21)*maxx)+(x+19)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+21)*maxx)+(x+20)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+21)*maxx)+(x+21)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+21)*maxx)+(x+22)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+21)*maxx)+(x+23)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+21)*maxx)+(x+24)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+21)*maxx)+(x+25)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+21)*maxx)+(x+26)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+21)*maxx)+(x+27)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+21)*maxx)+(x+28)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+21)*maxx)+(x+29)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+21)*maxx)+(x+30)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+21)*maxx)+(x+31)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+21)*maxx)+(x+32)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+21)*maxx)+(x+33)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+21)*maxx)+(x+34)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+21)*maxx)+(x+35)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+21)*maxx)+(x+36)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+21)*maxx)+(x+37)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+21)*maxx)+(x+38)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+21)*maxx)+(x+39)] = RGB15(16,16,16) | BIT(15);

    buffer[((y+21)*maxx)+(x+40)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+22)*maxx)+(x+0)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+22)*maxx)+(x+1)] = RGB15(16,16,16) | BIT(15);

    buffer[((y+22)*maxx)+(x+2)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+22)*maxx)+(x+3)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+22)*maxx)+(x+4)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+22)*maxx)+(x+5)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+22)*maxx)+(x+6)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+22)*maxx)+(x+7)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+22)*maxx)+(x+8)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+22)*maxx)+(x+9)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+22)*maxx)+(x+10)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+22)*maxx)+(x+11)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+22)*maxx)+(x+12)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+22)*maxx)+(x+13)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+22)*maxx)+(x+14)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+22)*maxx)+(x+15)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+22)*maxx)+(x+16)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+22)*maxx)+(x+17)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+22)*maxx)+(x+18)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+22)*maxx)+(x+19)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+22)*maxx)+(x+20)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+22)*maxx)+(x+21)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+22)*maxx)+(x+22)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+22)*maxx)+(x+23)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+22)*maxx)+(x+24)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+22)*maxx)+(x+25)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+22)*maxx)+(x+26)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+22)*maxx)+(x+27)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+22)*maxx)+(x+28)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+22)*maxx)+(x+29)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+22)*maxx)+(x+30)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+22)*maxx)+(x+31)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+22)*maxx)+(x+32)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+22)*maxx)+(x+33)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+22)*maxx)+(x+34)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+22)*maxx)+(x+35)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+22)*maxx)+(x+36)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+22)*maxx)+(x+37)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+22)*maxx)+(x+38)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+22)*maxx)+(x+39)] = RGB15(16,16,16) | BIT(15);

    buffer[((y+22)*maxx)+(x+40)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+23)*maxx)+(x+0)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+23)*maxx)+(x+1)] = RGB15(16,16,16) | BIT(15);

    buffer[((y+23)*maxx)+(x+2)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+23)*maxx)+(x+3)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+23)*maxx)+(x+4)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+23)*maxx)+(x+5)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+23)*maxx)+(x+6)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+23)*maxx)+(x+7)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+23)*maxx)+(x+8)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+23)*maxx)+(x+9)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+23)*maxx)+(x+10)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+23)*maxx)+(x+11)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+23)*maxx)+(x+12)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+23)*maxx)+(x+13)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+23)*maxx)+(x+14)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+23)*maxx)+(x+15)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+23)*maxx)+(x+16)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+23)*maxx)+(x+17)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+23)*maxx)+(x+18)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+23)*maxx)+(x+19)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+23)*maxx)+(x+20)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+23)*maxx)+(x+21)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+23)*maxx)+(x+22)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+23)*maxx)+(x+23)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+23)*maxx)+(x+24)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+23)*maxx)+(x+25)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+23)*maxx)+(x+26)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+23)*maxx)+(x+27)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+23)*maxx)+(x+28)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+23)*maxx)+(x+29)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+23)*maxx)+(x+30)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+23)*maxx)+(x+31)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+23)*maxx)+(x+32)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+23)*maxx)+(x+33)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+23)*maxx)+(x+34)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+23)*maxx)+(x+35)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+23)*maxx)+(x+36)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+23)*maxx)+(x+37)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+23)*maxx)+(x+38)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+23)*maxx)+(x+39)] = RGB15(16,16,16) | BIT(15);

    buffer[((y+23)*maxx)+(x+40)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+24)*maxx)+(x+0)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+24)*maxx)+(x+1)] = RGB15(16,16,16) | BIT(15);

    buffer[((y+24)*maxx)+(x+2)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+24)*maxx)+(x+3)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+24)*maxx)+(x+4)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+24)*maxx)+(x+5)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+24)*maxx)+(x+6)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+24)*maxx)+(x+7)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+24)*maxx)+(x+8)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+24)*maxx)+(x+9)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+24)*maxx)+(x+10)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+24)*maxx)+(x+11)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+24)*maxx)+(x+12)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+24)*maxx)+(x+13)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+24)*maxx)+(x+14)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+24)*maxx)+(x+15)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+24)*maxx)+(x+16)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+24)*maxx)+(x+17)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+24)*maxx)+(x+18)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+24)*maxx)+(x+19)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+24)*maxx)+(x+20)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+24)*maxx)+(x+21)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+24)*maxx)+(x+22)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+24)*maxx)+(x+23)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+24)*maxx)+(x+24)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+24)*maxx)+(x+25)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+24)*maxx)+(x+26)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+24)*maxx)+(x+27)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+24)*maxx)+(x+28)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+24)*maxx)+(x+29)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+24)*maxx)+(x+30)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+24)*maxx)+(x+31)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+24)*maxx)+(x+32)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+24)*maxx)+(x+33)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+24)*maxx)+(x+34)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+24)*maxx)+(x+35)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+24)*maxx)+(x+36)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+24)*maxx)+(x+37)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+24)*maxx)+(x+38)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+24)*maxx)+(x+39)] = RGB15(16,16,16) | BIT(15);

    buffer[((y+24)*maxx)+(x+40)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+25)*maxx)+(x+0)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+25)*maxx)+(x+1)] = RGB15(16,16,16) | BIT(15);

    buffer[((y+25)*maxx)+(x+2)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+25)*maxx)+(x+3)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+25)*maxx)+(x+4)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+25)*maxx)+(x+5)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+25)*maxx)+(x+6)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+25)*maxx)+(x+7)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+25)*maxx)+(x+8)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+25)*maxx)+(x+9)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+25)*maxx)+(x+10)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+25)*maxx)+(x+11)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+25)*maxx)+(x+12)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+25)*maxx)+(x+13)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+25)*maxx)+(x+14)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+25)*maxx)+(x+15)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+25)*maxx)+(x+16)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+25)*maxx)+(x+17)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+25)*maxx)+(x+18)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+25)*maxx)+(x+19)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+25)*maxx)+(x+20)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+25)*maxx)+(x+21)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+25)*maxx)+(x+22)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+25)*maxx)+(x+23)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+25)*maxx)+(x+24)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+25)*maxx)+(x+25)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+25)*maxx)+(x+26)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+25)*maxx)+(x+27)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+25)*maxx)+(x+28)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+25)*maxx)+(x+29)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+25)*maxx)+(x+30)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+25)*maxx)+(x+31)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+25)*maxx)+(x+32)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+25)*maxx)+(x+33)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+25)*maxx)+(x+34)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+25)*maxx)+(x+35)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+25)*maxx)+(x+36)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+25)*maxx)+(x+37)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+25)*maxx)+(x+38)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+25)*maxx)+(x+39)] = RGB15(16,16,16) | BIT(15);

    buffer[((y+25)*maxx)+(x+40)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+26)*maxx)+(x+0)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+26)*maxx)+(x+1)] = RGB15(16,16,16) | BIT(15);

    buffer[((y+26)*maxx)+(x+2)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+26)*maxx)+(x+3)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+26)*maxx)+(x+4)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+26)*maxx)+(x+5)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+26)*maxx)+(x+6)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+26)*maxx)+(x+7)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+26)*maxx)+(x+8)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+26)*maxx)+(x+9)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+26)*maxx)+(x+10)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+26)*maxx)+(x+11)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+26)*maxx)+(x+12)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+26)*maxx)+(x+13)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+26)*maxx)+(x+14)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+26)*maxx)+(x+15)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+26)*maxx)+(x+16)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+26)*maxx)+(x+17)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+26)*maxx)+(x+18)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+26)*maxx)+(x+19)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+26)*maxx)+(x+20)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+26)*maxx)+(x+21)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+26)*maxx)+(x+22)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+26)*maxx)+(x+23)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+26)*maxx)+(x+24)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+26)*maxx)+(x+25)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+26)*maxx)+(x+26)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+26)*maxx)+(x+27)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+26)*maxx)+(x+28)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+26)*maxx)+(x+29)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+26)*maxx)+(x+30)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+26)*maxx)+(x+31)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+26)*maxx)+(x+32)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+26)*maxx)+(x+33)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+26)*maxx)+(x+34)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+26)*maxx)+(x+35)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+26)*maxx)+(x+36)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+26)*maxx)+(x+37)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+26)*maxx)+(x+38)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+26)*maxx)+(x+39)] = RGB15(16,16,16) | BIT(15);

    buffer[((y+26)*maxx)+(x+40)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+27)*maxx)+(x+0)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+27)*maxx)+(x+1)] = RGB15(16,16,16) | BIT(15);

    buffer[((y+27)*maxx)+(x+2)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+27)*maxx)+(x+3)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+27)*maxx)+(x+4)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+27)*maxx)+(x+5)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+27)*maxx)+(x+6)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+27)*maxx)+(x+7)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+27)*maxx)+(x+8)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+27)*maxx)+(x+9)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+27)*maxx)+(x+10)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+27)*maxx)+(x+11)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+27)*maxx)+(x+12)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+27)*maxx)+(x+13)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+27)*maxx)+(x+14)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+27)*maxx)+(x+15)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+27)*maxx)+(x+16)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+27)*maxx)+(x+17)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+27)*maxx)+(x+18)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+27)*maxx)+(x+19)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+27)*maxx)+(x+20)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+27)*maxx)+(x+21)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+27)*maxx)+(x+22)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+27)*maxx)+(x+23)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+27)*maxx)+(x+24)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+27)*maxx)+(x+25)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+27)*maxx)+(x+26)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+27)*maxx)+(x+27)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+27)*maxx)+(x+28)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+27)*maxx)+(x+29)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+27)*maxx)+(x+30)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+27)*maxx)+(x+31)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+27)*maxx)+(x+32)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+27)*maxx)+(x+33)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+27)*maxx)+(x+34)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+27)*maxx)+(x+35)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+27)*maxx)+(x+36)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+27)*maxx)+(x+37)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+27)*maxx)+(x+38)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+27)*maxx)+(x+39)] = RGB15(16,16,16) | BIT(15);

    buffer[((y+27)*maxx)+(x+40)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+28)*maxx)+(x+0)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+28)*maxx)+(x+1)] = RGB15(16,16,16) | BIT(15);

    buffer[((y+28)*maxx)+(x+2)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+28)*maxx)+(x+3)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+28)*maxx)+(x+4)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+28)*maxx)+(x+5)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+28)*maxx)+(x+6)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+28)*maxx)+(x+7)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+28)*maxx)+(x+8)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+28)*maxx)+(x+9)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+28)*maxx)+(x+10)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+28)*maxx)+(x+11)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+28)*maxx)+(x+12)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+28)*maxx)+(x+13)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+28)*maxx)+(x+14)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+28)*maxx)+(x+15)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+28)*maxx)+(x+16)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+28)*maxx)+(x+17)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+28)*maxx)+(x+18)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+28)*maxx)+(x+19)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+28)*maxx)+(x+20)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+28)*maxx)+(x+21)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+28)*maxx)+(x+22)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+28)*maxx)+(x+23)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+28)*maxx)+(x+24)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+28)*maxx)+(x+25)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+28)*maxx)+(x+26)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+28)*maxx)+(x+27)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+28)*maxx)+(x+28)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+28)*maxx)+(x+29)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+28)*maxx)+(x+30)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+28)*maxx)+(x+31)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+28)*maxx)+(x+32)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+28)*maxx)+(x+33)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+28)*maxx)+(x+34)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+28)*maxx)+(x+35)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+28)*maxx)+(x+36)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+28)*maxx)+(x+37)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+28)*maxx)+(x+38)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+28)*maxx)+(x+39)] = RGB15(16,16,16) | BIT(15);

    buffer[((y+28)*maxx)+(x+40)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+29)*maxx)+(x+0)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+29)*maxx)+(x+1)] = RGB15(16,16,16) | BIT(15);

    buffer[((y+29)*maxx)+(x+2)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+29)*maxx)+(x+3)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+29)*maxx)+(x+4)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+29)*maxx)+(x+5)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+29)*maxx)+(x+6)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+29)*maxx)+(x+7)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+29)*maxx)+(x+8)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+29)*maxx)+(x+9)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+29)*maxx)+(x+10)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+29)*maxx)+(x+11)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+29)*maxx)+(x+12)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+29)*maxx)+(x+13)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+29)*maxx)+(x+14)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+29)*maxx)+(x+15)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+29)*maxx)+(x+16)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+29)*maxx)+(x+17)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+29)*maxx)+(x+18)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+29)*maxx)+(x+19)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+29)*maxx)+(x+20)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+29)*maxx)+(x+21)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+29)*maxx)+(x+22)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+29)*maxx)+(x+23)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+29)*maxx)+(x+24)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+29)*maxx)+(x+25)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+29)*maxx)+(x+26)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+29)*maxx)+(x+27)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+29)*maxx)+(x+28)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+29)*maxx)+(x+29)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+29)*maxx)+(x+30)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+29)*maxx)+(x+31)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+29)*maxx)+(x+32)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+29)*maxx)+(x+33)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+29)*maxx)+(x+34)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+29)*maxx)+(x+35)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+29)*maxx)+(x+36)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+29)*maxx)+(x+37)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+29)*maxx)+(x+38)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+29)*maxx)+(x+39)] = RGB15(16,16,16) | BIT(15);

    buffer[((y+29)*maxx)+(x+40)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+30)*maxx)+(x+0)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+30)*maxx)+(x+1)] = RGB15(16,16,16) | BIT(15);

    buffer[((y+30)*maxx)+(x+2)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+30)*maxx)+(x+3)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+30)*maxx)+(x+4)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+30)*maxx)+(x+5)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+30)*maxx)+(x+6)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+30)*maxx)+(x+7)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+30)*maxx)+(x+8)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+30)*maxx)+(x+9)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+30)*maxx)+(x+10)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+30)*maxx)+(x+11)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+30)*maxx)+(x+12)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+30)*maxx)+(x+13)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+30)*maxx)+(x+14)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+30)*maxx)+(x+15)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+30)*maxx)+(x+16)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+30)*maxx)+(x+17)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+30)*maxx)+(x+18)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+30)*maxx)+(x+19)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+30)*maxx)+(x+20)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+30)*maxx)+(x+21)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+30)*maxx)+(x+22)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+30)*maxx)+(x+23)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+30)*maxx)+(x+24)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+30)*maxx)+(x+25)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+30)*maxx)+(x+26)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+30)*maxx)+(x+27)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+30)*maxx)+(x+28)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+30)*maxx)+(x+29)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+30)*maxx)+(x+30)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+30)*maxx)+(x+31)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+30)*maxx)+(x+32)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+30)*maxx)+(x+33)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+30)*maxx)+(x+34)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+30)*maxx)+(x+35)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+30)*maxx)+(x+36)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+30)*maxx)+(x+37)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+30)*maxx)+(x+38)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+30)*maxx)+(x+39)] = RGB15(16,16,16) | BIT(15);

    buffer[((y+30)*maxx)+(x+40)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+31)*maxx)+(x+0)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+31)*maxx)+(x+1)] = RGB15(16,16,16) | BIT(15);

    buffer[((y+31)*maxx)+(x+2)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+31)*maxx)+(x+3)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+31)*maxx)+(x+4)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+31)*maxx)+(x+5)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+31)*maxx)+(x+6)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+31)*maxx)+(x+7)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+31)*maxx)+(x+8)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+31)*maxx)+(x+9)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+31)*maxx)+(x+10)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+31)*maxx)+(x+11)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+31)*maxx)+(x+12)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+31)*maxx)+(x+13)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+31)*maxx)+(x+14)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+31)*maxx)+(x+15)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+31)*maxx)+(x+16)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+31)*maxx)+(x+17)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+31)*maxx)+(x+18)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+31)*maxx)+(x+19)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+31)*maxx)+(x+20)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+31)*maxx)+(x+21)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+31)*maxx)+(x+22)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+31)*maxx)+(x+23)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+31)*maxx)+(x+24)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+31)*maxx)+(x+25)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+31)*maxx)+(x+26)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+31)*maxx)+(x+27)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+31)*maxx)+(x+28)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+31)*maxx)+(x+29)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+31)*maxx)+(x+30)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+31)*maxx)+(x+31)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+31)*maxx)+(x+32)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+31)*maxx)+(x+33)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+31)*maxx)+(x+34)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+31)*maxx)+(x+35)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+31)*maxx)+(x+36)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+31)*maxx)+(x+37)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+31)*maxx)+(x+38)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+31)*maxx)+(x+39)] = RGB15(16,16,16) | BIT(15);

    buffer[((y+31)*maxx)+(x+40)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+32)*maxx)+(x+0)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+32)*maxx)+(x+1)] = RGB15(16,16,16) | BIT(15);

    buffer[((y+32)*maxx)+(x+2)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+32)*maxx)+(x+3)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+32)*maxx)+(x+4)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+32)*maxx)+(x+5)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+32)*maxx)+(x+6)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+32)*maxx)+(x+7)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+32)*maxx)+(x+8)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+32)*maxx)+(x+9)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+32)*maxx)+(x+10)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+32)*maxx)+(x+11)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+32)*maxx)+(x+12)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+32)*maxx)+(x+13)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+32)*maxx)+(x+14)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+32)*maxx)+(x+15)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+32)*maxx)+(x+16)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+32)*maxx)+(x+17)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+32)*maxx)+(x+18)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+32)*maxx)+(x+19)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+32)*maxx)+(x+20)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+32)*maxx)+(x+21)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+32)*maxx)+(x+22)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+32)*maxx)+(x+23)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+32)*maxx)+(x+24)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+32)*maxx)+(x+25)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+32)*maxx)+(x+26)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+32)*maxx)+(x+27)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+32)*maxx)+(x+28)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+32)*maxx)+(x+29)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+32)*maxx)+(x+30)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+32)*maxx)+(x+31)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+32)*maxx)+(x+32)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+32)*maxx)+(x+33)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+32)*maxx)+(x+34)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+32)*maxx)+(x+35)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+32)*maxx)+(x+36)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+32)*maxx)+(x+37)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+32)*maxx)+(x+38)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+32)*maxx)+(x+39)] = RGB15(16,16,16) | BIT(15);

    buffer[((y+32)*maxx)+(x+40)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+33)*maxx)+(x+0)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+33)*maxx)+(x+1)] = RGB15(16,16,16) | BIT(15);

    buffer[((y+33)*maxx)+(x+2)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+33)*maxx)+(x+3)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+33)*maxx)+(x+4)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+33)*maxx)+(x+5)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+33)*maxx)+(x+6)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+33)*maxx)+(x+7)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+33)*maxx)+(x+8)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+33)*maxx)+(x+9)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+33)*maxx)+(x+10)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+33)*maxx)+(x+11)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+33)*maxx)+(x+12)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+33)*maxx)+(x+13)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+33)*maxx)+(x+14)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+33)*maxx)+(x+15)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+33)*maxx)+(x+16)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+33)*maxx)+(x+17)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+33)*maxx)+(x+18)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+33)*maxx)+(x+19)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+33)*maxx)+(x+20)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+33)*maxx)+(x+21)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+33)*maxx)+(x+22)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+33)*maxx)+(x+23)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+33)*maxx)+(x+24)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+33)*maxx)+(x+25)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+33)*maxx)+(x+26)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+33)*maxx)+(x+27)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+33)*maxx)+(x+28)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+33)*maxx)+(x+29)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+33)*maxx)+(x+30)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+33)*maxx)+(x+31)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+33)*maxx)+(x+32)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+33)*maxx)+(x+33)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+33)*maxx)+(x+34)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+33)*maxx)+(x+35)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+33)*maxx)+(x+36)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+33)*maxx)+(x+37)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+33)*maxx)+(x+38)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+33)*maxx)+(x+39)] = RGB15(16,16,16) | BIT(15);

    buffer[((y+33)*maxx)+(x+40)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+34)*maxx)+(x+0)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+34)*maxx)+(x+1)] = RGB15(16,16,16) | BIT(15);

    buffer[((y+34)*maxx)+(x+2)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+34)*maxx)+(x+3)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+34)*maxx)+(x+4)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+34)*maxx)+(x+5)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+34)*maxx)+(x+6)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+34)*maxx)+(x+7)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+34)*maxx)+(x+8)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+34)*maxx)+(x+9)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+34)*maxx)+(x+10)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+34)*maxx)+(x+11)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+34)*maxx)+(x+12)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+34)*maxx)+(x+13)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+34)*maxx)+(x+14)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+34)*maxx)+(x+15)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+34)*maxx)+(x+16)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+34)*maxx)+(x+17)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+34)*maxx)+(x+18)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+34)*maxx)+(x+19)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+34)*maxx)+(x+20)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+34)*maxx)+(x+21)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+34)*maxx)+(x+22)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+34)*maxx)+(x+23)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+34)*maxx)+(x+24)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+34)*maxx)+(x+25)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+34)*maxx)+(x+26)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+34)*maxx)+(x+27)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+34)*maxx)+(x+28)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+34)*maxx)+(x+29)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+34)*maxx)+(x+30)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+34)*maxx)+(x+31)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+34)*maxx)+(x+32)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+34)*maxx)+(x+33)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+34)*maxx)+(x+34)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+34)*maxx)+(x+35)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+34)*maxx)+(x+36)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+34)*maxx)+(x+37)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+34)*maxx)+(x+38)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+34)*maxx)+(x+39)] = RGB15(16,16,16) | BIT(15);

    buffer[((y+34)*maxx)+(x+40)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+35)*maxx)+(x+0)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+35)*maxx)+(x+1)] = RGB15(16,16,16) | BIT(15);

    buffer[((y+35)*maxx)+(x+2)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+35)*maxx)+(x+3)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+35)*maxx)+(x+4)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+35)*maxx)+(x+5)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+35)*maxx)+(x+6)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+35)*maxx)+(x+7)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+35)*maxx)+(x+8)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+35)*maxx)+(x+9)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+35)*maxx)+(x+10)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+35)*maxx)+(x+11)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+35)*maxx)+(x+12)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+35)*maxx)+(x+13)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+35)*maxx)+(x+14)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+35)*maxx)+(x+15)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+35)*maxx)+(x+16)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+35)*maxx)+(x+17)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+35)*maxx)+(x+18)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+35)*maxx)+(x+19)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+35)*maxx)+(x+20)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+35)*maxx)+(x+21)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+35)*maxx)+(x+22)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+35)*maxx)+(x+23)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+35)*maxx)+(x+24)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+35)*maxx)+(x+25)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+35)*maxx)+(x+26)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+35)*maxx)+(x+27)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+35)*maxx)+(x+28)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+35)*maxx)+(x+29)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+35)*maxx)+(x+30)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+35)*maxx)+(x+31)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+35)*maxx)+(x+32)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+35)*maxx)+(x+33)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+35)*maxx)+(x+34)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+35)*maxx)+(x+35)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+35)*maxx)+(x+36)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+35)*maxx)+(x+37)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+35)*maxx)+(x+38)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+35)*maxx)+(x+39)] = RGB15(16,16,16) | BIT(15);

    buffer[((y+35)*maxx)+(x+40)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+36)*maxx)+(x+0)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+36)*maxx)+(x+1)] = RGB15(16,16,16) | BIT(15);

    buffer[((y+36)*maxx)+(x+2)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+36)*maxx)+(x+3)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+36)*maxx)+(x+4)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+36)*maxx)+(x+5)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+36)*maxx)+(x+6)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+36)*maxx)+(x+7)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+36)*maxx)+(x+8)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+36)*maxx)+(x+9)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+36)*maxx)+(x+10)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+36)*maxx)+(x+11)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+36)*maxx)+(x+12)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+36)*maxx)+(x+13)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+36)*maxx)+(x+14)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+36)*maxx)+(x+15)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+36)*maxx)+(x+16)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+36)*maxx)+(x+17)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+36)*maxx)+(x+18)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+36)*maxx)+(x+19)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+36)*maxx)+(x+20)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+36)*maxx)+(x+21)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+36)*maxx)+(x+22)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+36)*maxx)+(x+23)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+36)*maxx)+(x+24)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+36)*maxx)+(x+25)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+36)*maxx)+(x+26)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+36)*maxx)+(x+27)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+36)*maxx)+(x+28)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+36)*maxx)+(x+29)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+36)*maxx)+(x+30)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+36)*maxx)+(x+31)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+36)*maxx)+(x+32)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+36)*maxx)+(x+33)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+36)*maxx)+(x+34)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+36)*maxx)+(x+35)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+36)*maxx)+(x+36)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+36)*maxx)+(x+37)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+36)*maxx)+(x+38)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+36)*maxx)+(x+39)] = RGB15(16,16,16) | BIT(15);

    buffer[((y+36)*maxx)+(x+40)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+37)*maxx)+(x+0)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+37)*maxx)+(x+1)] = RGB15(16,16,16) | BIT(15);

    buffer[((y+37)*maxx)+(x+2)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+37)*maxx)+(x+3)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+37)*maxx)+(x+4)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+37)*maxx)+(x+5)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+37)*maxx)+(x+6)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+37)*maxx)+(x+7)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+37)*maxx)+(x+8)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+37)*maxx)+(x+9)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+37)*maxx)+(x+10)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+37)*maxx)+(x+11)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+37)*maxx)+(x+12)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+37)*maxx)+(x+13)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+37)*maxx)+(x+14)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+37)*maxx)+(x+15)] = RGB15(28,25,17) | BIT(15);

    buffer[((y+37)*maxx)+(x+16)] = RGB15(25,22,15) | BIT(15);

    buffer[((y+37)*maxx)+(x+17)] = RGB15(23,20,13) | BIT(15);

    buffer[((y+37)*maxx)+(x+18)] = RGB15(22,18,13) | BIT(15);

    buffer[((y+37)*maxx)+(x+19)] = RGB15(22,18,13) | BIT(15);

    buffer[((y+37)*maxx)+(x+20)] = RGB15(22,18,13) | BIT(15);

    buffer[((y+37)*maxx)+(x+21)] = RGB15(23,19,13) | BIT(15);

    buffer[((y+37)*maxx)+(x+22)] = RGB15(22,19,13) | BIT(15);

    buffer[((y+37)*maxx)+(x+23)] = RGB15(23,20,14) | BIT(15);

    buffer[((y+37)*maxx)+(x+24)] = RGB15(26,23,16) | BIT(15);

    buffer[((y+37)*maxx)+(x+25)] = RGB15(30,27,20) | BIT(15);

    buffer[((y+37)*maxx)+(x+26)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+37)*maxx)+(x+27)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+37)*maxx)+(x+28)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+37)*maxx)+(x+29)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+37)*maxx)+(x+30)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+37)*maxx)+(x+31)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+37)*maxx)+(x+32)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+37)*maxx)+(x+33)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+37)*maxx)+(x+34)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+37)*maxx)+(x+35)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+37)*maxx)+(x+36)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+37)*maxx)+(x+37)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+37)*maxx)+(x+38)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+37)*maxx)+(x+39)] = RGB15(16,16,16) | BIT(15);

    buffer[((y+37)*maxx)+(x+40)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+38)*maxx)+(x+0)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+38)*maxx)+(x+1)] = RGB15(16,16,16) | BIT(15);

    buffer[((y+38)*maxx)+(x+2)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+38)*maxx)+(x+3)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+38)*maxx)+(x+4)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+38)*maxx)+(x+5)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+38)*maxx)+(x+6)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+38)*maxx)+(x+7)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+38)*maxx)+(x+8)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+38)*maxx)+(x+9)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+38)*maxx)+(x+10)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+38)*maxx)+(x+11)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+38)*maxx)+(x+12)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+38)*maxx)+(x+13)] = RGB15(26,23,16) | BIT(15);

    buffer[((y+38)*maxx)+(x+14)] = RGB15(23,19,13) | BIT(15);

    buffer[((y+38)*maxx)+(x+15)] = RGB15(22,18,12) | BIT(15);

    buffer[((y+38)*maxx)+(x+16)] = RGB15(22,19,14) | BIT(15);

    buffer[((y+38)*maxx)+(x+17)] = RGB15(24,21,17) | BIT(15);

    buffer[((y+38)*maxx)+(x+18)] = RGB15(22,21,17) | BIT(15);

    buffer[((y+38)*maxx)+(x+19)] = RGB15(21,20,17) | BIT(15);

    buffer[((y+38)*maxx)+(x+20)] = RGB15(21,20,17) | BIT(15);

    buffer[((y+38)*maxx)+(x+21)] = RGB15(22,21,18) | BIT(15);

    buffer[((y+38)*maxx)+(x+22)] = RGB15(24,21,17) | BIT(15);

    buffer[((y+38)*maxx)+(x+23)] = RGB15(23,20,15) | BIT(15);

    buffer[((y+38)*maxx)+(x+24)] = RGB15(22,19,13) | BIT(15);

    buffer[((y+38)*maxx)+(x+25)] = RGB15(22,18,12) | BIT(15);

    buffer[((y+38)*maxx)+(x+26)] = RGB15(24,21,14) | BIT(15);

    buffer[((y+38)*maxx)+(x+27)] = RGB15(29,26,19) | BIT(15);

    buffer[((y+38)*maxx)+(x+28)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+38)*maxx)+(x+29)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+38)*maxx)+(x+30)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+38)*maxx)+(x+31)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+38)*maxx)+(x+32)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+38)*maxx)+(x+33)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+38)*maxx)+(x+34)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+38)*maxx)+(x+35)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+38)*maxx)+(x+36)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+38)*maxx)+(x+37)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+38)*maxx)+(x+38)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+38)*maxx)+(x+39)] = RGB15(16,16,16) | BIT(15);

    buffer[((y+38)*maxx)+(x+40)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+39)*maxx)+(x+0)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+39)*maxx)+(x+1)] = RGB15(16,16,16) | BIT(15);

    buffer[((y+39)*maxx)+(x+2)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+39)*maxx)+(x+3)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+39)*maxx)+(x+4)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+39)*maxx)+(x+5)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+39)*maxx)+(x+6)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+39)*maxx)+(x+7)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+39)*maxx)+(x+8)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+39)*maxx)+(x+9)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+39)*maxx)+(x+10)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+39)*maxx)+(x+11)] = RGB15(26,24,16) | BIT(15);

    buffer[((y+39)*maxx)+(x+12)] = RGB15(21,18,12) | BIT(15);

    buffer[((y+39)*maxx)+(x+13)] = RGB15(21,17,12) | BIT(15);

    buffer[((y+39)*maxx)+(x+14)] = RGB15(22,20,17) | BIT(15);

    buffer[((y+39)*maxx)+(x+15)] = RGB15(18,17,14) | BIT(15);

    buffer[((y+39)*maxx)+(x+16)] = RGB15(14,14,12) | BIT(15);

    buffer[((y+39)*maxx)+(x+17)] = RGB15(13,13,12) | BIT(15);

    buffer[((y+39)*maxx)+(x+18)] = RGB15(11,11,10) | BIT(15);

    buffer[((y+39)*maxx)+(x+19)] = RGB15(11,12,10) | BIT(15);

    buffer[((y+39)*maxx)+(x+20)] = RGB15(17,17,16) | BIT(15);

    buffer[((y+39)*maxx)+(x+21)] = RGB15(10,11,9) | BIT(15);

    buffer[((y+39)*maxx)+(x+22)] = RGB15(13,14,12) | BIT(15);

    buffer[((y+39)*maxx)+(x+23)] = RGB15(14,14,12) | BIT(15);

    buffer[((y+39)*maxx)+(x+24)] = RGB15(17,17,14) | BIT(15);

    buffer[((y+39)*maxx)+(x+25)] = RGB15(22,21,18) | BIT(15);

    buffer[((y+39)*maxx)+(x+26)] = RGB15(22,19,14) | BIT(15);

    buffer[((y+39)*maxx)+(x+27)] = RGB15(21,18,12) | BIT(15);

    buffer[((y+39)*maxx)+(x+28)] = RGB15(24,21,14) | BIT(15);

    buffer[((y+39)*maxx)+(x+29)] = RGB15(30,28,20) | BIT(15);

    buffer[((y+39)*maxx)+(x+30)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+39)*maxx)+(x+31)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+39)*maxx)+(x+32)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+39)*maxx)+(x+33)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+39)*maxx)+(x+34)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+39)*maxx)+(x+35)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+39)*maxx)+(x+36)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+39)*maxx)+(x+37)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+39)*maxx)+(x+38)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+39)*maxx)+(x+39)] = RGB15(16,16,16) | BIT(15);

    buffer[((y+39)*maxx)+(x+40)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+40)*maxx)+(x+0)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+40)*maxx)+(x+1)] = RGB15(16,16,16) | BIT(15);

    buffer[((y+40)*maxx)+(x+2)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+40)*maxx)+(x+3)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+40)*maxx)+(x+4)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+40)*maxx)+(x+5)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+40)*maxx)+(x+6)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+40)*maxx)+(x+7)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+40)*maxx)+(x+8)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+40)*maxx)+(x+9)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+40)*maxx)+(x+10)] = RGB15(23,20,14) | BIT(15);

    buffer[((y+40)*maxx)+(x+11)] = RGB15(21,18,12) | BIT(15);

    buffer[((y+40)*maxx)+(x+12)] = RGB15(22,20,16) | BIT(15);

    buffer[((y+40)*maxx)+(x+13)] = RGB15(16,16,14) | BIT(15);

    buffer[((y+40)*maxx)+(x+14)] = RGB15(12,12,11) | BIT(15);

    buffer[((y+40)*maxx)+(x+15)] = RGB15(10,11,9) | BIT(15);

    buffer[((y+40)*maxx)+(x+16)] = RGB15(8,10,8) | BIT(15);

    buffer[((y+40)*maxx)+(x+17)] = RGB15(21,22,21) | BIT(15);

    buffer[((y+40)*maxx)+(x+18)] = RGB15(13,13,13) | BIT(15);

    buffer[((y+40)*maxx)+(x+19)] = RGB15(15,15,15) | BIT(15);

    buffer[((y+40)*maxx)+(x+20)] = RGB15(19,19,18) | BIT(15);

    buffer[((y+40)*maxx)+(x+21)] = RGB15(12,12,11) | BIT(15);

    buffer[((y+40)*maxx)+(x+22)] = RGB15(13,13,12) | BIT(15);

    buffer[((y+40)*maxx)+(x+23)] = RGB15(21,21,20) | BIT(15);

    buffer[((y+40)*maxx)+(x+24)] = RGB15(13,14,12) | BIT(15);

    buffer[((y+40)*maxx)+(x+25)] = RGB15(12,12,11) | BIT(15);

    buffer[((y+40)*maxx)+(x+26)] = RGB15(14,14,12) | BIT(15);

    buffer[((y+40)*maxx)+(x+27)] = RGB15(21,19,16) | BIT(15);

    buffer[((y+40)*maxx)+(x+28)] = RGB15(22,18,13) | BIT(15);

    buffer[((y+40)*maxx)+(x+29)] = RGB15(22,19,13) | BIT(15);

    buffer[((y+40)*maxx)+(x+30)] = RGB15(29,26,19) | BIT(15);

    buffer[((y+40)*maxx)+(x+31)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+40)*maxx)+(x+32)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+40)*maxx)+(x+33)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+40)*maxx)+(x+34)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+40)*maxx)+(x+35)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+40)*maxx)+(x+36)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+40)*maxx)+(x+37)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+40)*maxx)+(x+38)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+40)*maxx)+(x+39)] = RGB15(16,16,16) | BIT(15);

    buffer[((y+40)*maxx)+(x+40)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+41)*maxx)+(x+0)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+41)*maxx)+(x+1)] = RGB15(16,16,16) | BIT(15);

    buffer[((y+41)*maxx)+(x+2)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+41)*maxx)+(x+3)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+41)*maxx)+(x+4)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+41)*maxx)+(x+5)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+41)*maxx)+(x+6)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+41)*maxx)+(x+7)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+41)*maxx)+(x+8)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+41)*maxx)+(x+9)] = RGB15(23,19,13) | BIT(15);

    buffer[((y+41)*maxx)+(x+10)] = RGB15(21,18,14) | BIT(15);

    buffer[((y+41)*maxx)+(x+11)] = RGB15(21,20,16) | BIT(15);

    buffer[((y+41)*maxx)+(x+12)] = RGB15(10,11,8) | BIT(15);

    buffer[((y+41)*maxx)+(x+13)] = RGB15(17,18,16) | BIT(15);

    buffer[((y+41)*maxx)+(x+14)] = RGB15(13,14,13) | BIT(15);

    buffer[((y+41)*maxx)+(x+15)] = RGB15(16,17,15) | BIT(15);

    buffer[((y+41)*maxx)+(x+16)] = RGB15(8,8,6) | BIT(15);

    buffer[((y+41)*maxx)+(x+17)] = RGB15(14,13,13) | BIT(15);

    buffer[((y+41)*maxx)+(x+18)] = RGB15(15,14,13) | BIT(15);

    buffer[((y+41)*maxx)+(x+19)] = RGB15(16,15,14) | BIT(15);

    buffer[((y+41)*maxx)+(x+20)] = RGB15(15,15,14) | BIT(15);

    buffer[((y+41)*maxx)+(x+21)] = RGB15(16,16,14) | BIT(15);

    buffer[((y+41)*maxx)+(x+22)] = RGB15(14,14,12) | BIT(15);

    buffer[((y+41)*maxx)+(x+23)] = RGB15(13,13,12) | BIT(15);

    buffer[((y+41)*maxx)+(x+24)] = RGB15(18,18,17) | BIT(15);

    buffer[((y+41)*maxx)+(x+25)] = RGB15(11,12,9) | BIT(15);

    buffer[((y+41)*maxx)+(x+26)] = RGB15(14,14,12) | BIT(15);

    buffer[((y+41)*maxx)+(x+27)] = RGB15(15,15,13) | BIT(15);

    buffer[((y+41)*maxx)+(x+28)] = RGB15(18,17,15) | BIT(15);

    buffer[((y+41)*maxx)+(x+29)] = RGB15(22,20,15) | BIT(15);

    buffer[((y+41)*maxx)+(x+30)] = RGB15(21,18,12) | BIT(15);

    buffer[((y+41)*maxx)+(x+31)] = RGB15(28,25,18) | BIT(15);

    buffer[((y+41)*maxx)+(x+32)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+41)*maxx)+(x+33)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+41)*maxx)+(x+34)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+41)*maxx)+(x+35)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+41)*maxx)+(x+36)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+41)*maxx)+(x+37)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+41)*maxx)+(x+38)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+41)*maxx)+(x+39)] = RGB15(16,16,16) | BIT(15);

    buffer[((y+41)*maxx)+(x+40)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+42)*maxx)+(x+0)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+42)*maxx)+(x+1)] = RGB15(16,16,16) | BIT(15);

    buffer[((y+42)*maxx)+(x+2)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+42)*maxx)+(x+3)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+42)*maxx)+(x+4)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+42)*maxx)+(x+5)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+42)*maxx)+(x+6)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+42)*maxx)+(x+7)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+42)*maxx)+(x+8)] = RGB15(23,19,13) | BIT(15);

    buffer[((y+42)*maxx)+(x+9)] = RGB15(22,19,14) | BIT(15);

    buffer[((y+42)*maxx)+(x+10)] = RGB15(20,18,16) | BIT(15);

    buffer[((y+42)*maxx)+(x+11)] = RGB15(16,16,15) | BIT(15);

    buffer[((y+42)*maxx)+(x+12)] = RGB15(10,11,9) | BIT(15);

    buffer[((y+42)*maxx)+(x+13)] = RGB15(11,11,10) | BIT(15);

    buffer[((y+42)*maxx)+(x+14)] = RGB15(14,14,13) | BIT(15);

    buffer[((y+42)*maxx)+(x+15)] = RGB15(17,16,14) | BIT(15);

    buffer[((y+42)*maxx)+(x+16)] = RGB15(22,21,16) | BIT(15);

    buffer[((y+42)*maxx)+(x+17)] = RGB15(24,23,17) | BIT(15);

    buffer[((y+42)*maxx)+(x+18)] = RGB15(25,23,17) | BIT(15);

    buffer[((y+42)*maxx)+(x+19)] = RGB15(18,17,12) | BIT(15);

    buffer[((y+42)*maxx)+(x+20)] = RGB15(12,11,8) | BIT(15);

    buffer[((y+42)*maxx)+(x+21)] = RGB15(12,11,7) | BIT(15);

    buffer[((y+42)*maxx)+(x+22)] = RGB15(20,18,14) | BIT(15);

    buffer[((y+42)*maxx)+(x+23)] = RGB15(24,22,18) | BIT(15);

    buffer[((y+42)*maxx)+(x+24)] = RGB15(18,17,15) | BIT(15);

    buffer[((y+42)*maxx)+(x+25)] = RGB15(9,11,9) | BIT(15);

    buffer[((y+42)*maxx)+(x+26)] = RGB15(20,20,18) | BIT(15);

    buffer[((y+42)*maxx)+(x+27)] = RGB15(14,14,14) | BIT(15);

    buffer[((y+42)*maxx)+(x+28)] = RGB15(18,19,18) | BIT(15);

    buffer[((y+42)*maxx)+(x+29)] = RGB15(16,15,13) | BIT(15);

    buffer[((y+42)*maxx)+(x+30)] = RGB15(22,20,16) | BIT(15);

    buffer[((y+42)*maxx)+(x+31)] = RGB15(21,18,12) | BIT(15);

    buffer[((y+42)*maxx)+(x+32)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+42)*maxx)+(x+33)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+42)*maxx)+(x+34)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+42)*maxx)+(x+35)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+42)*maxx)+(x+36)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+42)*maxx)+(x+37)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+42)*maxx)+(x+38)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+42)*maxx)+(x+39)] = RGB15(16,16,16) | BIT(15);

    buffer[((y+42)*maxx)+(x+40)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+43)*maxx)+(x+0)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+43)*maxx)+(x+1)] = RGB15(16,16,16) | BIT(15);

    buffer[((y+43)*maxx)+(x+2)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+43)*maxx)+(x+3)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+43)*maxx)+(x+4)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+43)*maxx)+(x+5)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+43)*maxx)+(x+6)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+43)*maxx)+(x+7)] = RGB15(25,21,14) | BIT(15);

    buffer[((y+43)*maxx)+(x+8)] = RGB15(21,18,13) | BIT(15);

    buffer[((y+43)*maxx)+(x+9)] = RGB15(20,19,15) | BIT(15);

    buffer[((y+43)*maxx)+(x+10)] = RGB15(15,16,14) | BIT(15);

    buffer[((y+43)*maxx)+(x+11)] = RGB15(15,15,14) | BIT(15);

    buffer[((y+43)*maxx)+(x+12)] = RGB15(17,17,16) | BIT(15);

    buffer[((y+43)*maxx)+(x+13)] = RGB15(13,13,11) | BIT(15);

    buffer[((y+43)*maxx)+(x+14)] = RGB15(22,21,16) | BIT(15);

    buffer[((y+43)*maxx)+(x+15)] = RGB15(26,24,17) | BIT(15);

    buffer[((y+43)*maxx)+(x+16)] = RGB15(29,27,20) | BIT(15);

    buffer[((y+43)*maxx)+(x+17)] = RGB15(29,28,20) | BIT(15);

    buffer[((y+43)*maxx)+(x+18)] = RGB15(28,28,20) | BIT(15);

    buffer[((y+43)*maxx)+(x+19)] = RGB15(11,12,6) | BIT(15);

    buffer[((y+43)*maxx)+(x+20)] = RGB15(9,10,7) | BIT(15);

    buffer[((y+43)*maxx)+(x+21)] = RGB15(6,7,5) | BIT(15);

    buffer[((y+43)*maxx)+(x+22)] = RGB15(8,8,5) | BIT(15);

    buffer[((y+43)*maxx)+(x+23)] = RGB15(25,23,17) | BIT(15);

    buffer[((y+43)*maxx)+(x+24)] = RGB15(27,24,17) | BIT(15);

    buffer[((y+43)*maxx)+(x+25)] = RGB15(24,21,17) | BIT(15);

    buffer[((y+43)*maxx)+(x+26)] = RGB15(15,15,14) | BIT(15);

    buffer[((y+43)*maxx)+(x+27)] = RGB15(14,14,13) | BIT(15);

    buffer[((y+43)*maxx)+(x+28)] = RGB15(15,15,14) | BIT(15);

    buffer[((y+43)*maxx)+(x+29)] = RGB15(17,17,17) | BIT(15);

    buffer[((y+43)*maxx)+(x+30)] = RGB15(15,15,13) | BIT(15);

    buffer[((y+43)*maxx)+(x+31)] = RGB15(21,19,15) | BIT(15);

    buffer[((y+43)*maxx)+(x+32)] = RGB15(22,19,13) | BIT(15);

    buffer[((y+43)*maxx)+(x+33)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+43)*maxx)+(x+34)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+43)*maxx)+(x+35)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+43)*maxx)+(x+36)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+43)*maxx)+(x+37)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+43)*maxx)+(x+38)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+43)*maxx)+(x+39)] = RGB15(16,16,16) | BIT(15);

    buffer[((y+43)*maxx)+(x+40)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+44)*maxx)+(x+0)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+44)*maxx)+(x+1)] = RGB15(16,16,16) | BIT(15);

    buffer[((y+44)*maxx)+(x+2)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+44)*maxx)+(x+3)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+44)*maxx)+(x+4)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+44)*maxx)+(x+5)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+44)*maxx)+(x+6)] = RGB15(28,26,18) | BIT(15);

    buffer[((y+44)*maxx)+(x+7)] = RGB15(22,19,12) | BIT(15);

    buffer[((y+44)*maxx)+(x+8)] = RGB15(22,20,17) | BIT(15);

    buffer[((y+44)*maxx)+(x+9)] = RGB15(14,14,12) | BIT(15);

    buffer[((y+44)*maxx)+(x+10)] = RGB15(13,14,12) | BIT(15);

    buffer[((y+44)*maxx)+(x+11)] = RGB15(17,17,16) | BIT(15);

    buffer[((y+44)*maxx)+(x+12)] = RGB15(17,16,14) | BIT(15);

    buffer[((y+44)*maxx)+(x+13)] = RGB15(24,23,17) | BIT(15);

    buffer[((y+44)*maxx)+(x+14)] = RGB15(29,27,19) | BIT(15);

    buffer[((y+44)*maxx)+(x+15)] = RGB15(30,28,20) | BIT(15);

    buffer[((y+44)*maxx)+(x+16)] = RGB15(29,27,19) | BIT(15);

    buffer[((y+44)*maxx)+(x+17)] = RGB15(29,27,20) | BIT(15);

    buffer[((y+44)*maxx)+(x+18)] = RGB15(17,17,12) | BIT(15);

    buffer[((y+44)*maxx)+(x+19)] = RGB15(7,8,5) | BIT(15);

    buffer[((y+44)*maxx)+(x+20)] = RGB15(8,9,6) | BIT(15);

    buffer[((y+44)*maxx)+(x+21)] = RGB15(6,7,5) | BIT(15);

    buffer[((y+44)*maxx)+(x+22)] = RGB15(8,9,5) | BIT(15);

    buffer[((y+44)*maxx)+(x+23)] = RGB15(26,25,19) | BIT(15);

    buffer[((y+44)*maxx)+(x+24)] = RGB15(28,26,18) | BIT(15);

    buffer[((y+44)*maxx)+(x+25)] = RGB15(18,16,11) | BIT(15);

    buffer[((y+44)*maxx)+(x+26)] = RGB15(24,22,17) | BIT(15);

    buffer[((y+44)*maxx)+(x+27)] = RGB15(19,18,15) | BIT(15);

    buffer[((y+44)*maxx)+(x+28)] = RGB15(15,15,14) | BIT(15);

    buffer[((y+44)*maxx)+(x+29)] = RGB15(14,14,13) | BIT(15);

    buffer[((y+44)*maxx)+(x+30)] = RGB15(13,14,12) | BIT(15);

    buffer[((y+44)*maxx)+(x+31)] = RGB15(19,18,15) | BIT(15);

    buffer[((y+44)*maxx)+(x+32)] = RGB15(23,20,14) | BIT(15);

    buffer[((y+44)*maxx)+(x+33)] = RGB15(27,24,17) | BIT(15);

    buffer[((y+44)*maxx)+(x+34)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+44)*maxx)+(x+35)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+44)*maxx)+(x+36)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+44)*maxx)+(x+37)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+44)*maxx)+(x+38)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+44)*maxx)+(x+39)] = RGB15(16,16,16) | BIT(15);

    buffer[((y+44)*maxx)+(x+40)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+45)*maxx)+(x+0)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+45)*maxx)+(x+1)] = RGB15(16,16,16) | BIT(15);

    buffer[((y+45)*maxx)+(x+2)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+45)*maxx)+(x+3)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+45)*maxx)+(x+4)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+45)*maxx)+(x+5)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+45)*maxx)+(x+6)] = RGB15(22,20,13) | BIT(15);

    buffer[((y+45)*maxx)+(x+7)] = RGB15(22,20,14) | BIT(15);

    buffer[((y+45)*maxx)+(x+8)] = RGB15(13,12,11) | BIT(15);

    buffer[((y+45)*maxx)+(x+9)] = RGB15(14,15,14) | BIT(15);

    buffer[((y+45)*maxx)+(x+10)] = RGB15(17,18,17) | BIT(15);

    buffer[((y+45)*maxx)+(x+11)] = RGB15(15,15,12) | BIT(15);

    buffer[((y+45)*maxx)+(x+12)] = RGB15(25,23,17) | BIT(15);

    buffer[((y+45)*maxx)+(x+13)] = RGB15(30,28,20) | BIT(15);

    buffer[((y+45)*maxx)+(x+14)] = RGB15(30,28,20) | BIT(15);

    buffer[((y+45)*maxx)+(x+15)] = RGB15(30,28,20) | BIT(15);

    buffer[((y+45)*maxx)+(x+16)] = RGB15(30,28,20) | BIT(15);

    buffer[((y+45)*maxx)+(x+17)] = RGB15(27,25,18) | BIT(15);

    buffer[((y+45)*maxx)+(x+18)] = RGB15(10,10,6) | BIT(15);

    buffer[((y+45)*maxx)+(x+19)] = RGB15(7,7,6) | BIT(15);

    buffer[((y+45)*maxx)+(x+20)] = RGB15(11,12,10) | BIT(15);

    buffer[((y+45)*maxx)+(x+21)] = RGB15(7,7,5) | BIT(15);

    buffer[((y+45)*maxx)+(x+22)] = RGB15(8,7,6) | BIT(15);

    buffer[((y+45)*maxx)+(x+23)] = RGB15(26,25,19) | BIT(15);

    buffer[((y+45)*maxx)+(x+24)] = RGB15(28,26,18) | BIT(15);

    buffer[((y+45)*maxx)+(x+25)] = RGB15(15,13,9) | BIT(15);

    buffer[((y+45)*maxx)+(x+26)] = RGB15(29,27,19) | BIT(15);

    buffer[((y+45)*maxx)+(x+27)] = RGB15(26,24,18) | BIT(15);

    buffer[((y+45)*maxx)+(x+28)] = RGB15(19,18,15) | BIT(15);

    buffer[((y+45)*maxx)+(x+29)] = RGB15(16,17,16) | BIT(15);

    buffer[((y+45)*maxx)+(x+30)] = RGB15(14,15,14) | BIT(15);

    buffer[((y+45)*maxx)+(x+31)] = RGB15(12,12,10) | BIT(15);

    buffer[((y+45)*maxx)+(x+32)] = RGB15(23,21,17) | BIT(15);

    buffer[((y+45)*maxx)+(x+33)] = RGB15(21,17,12) | BIT(15);

    buffer[((y+45)*maxx)+(x+34)] = RGB15(28,26,19) | BIT(15);

    buffer[((y+45)*maxx)+(x+35)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+45)*maxx)+(x+36)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+45)*maxx)+(x+37)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+45)*maxx)+(x+38)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+45)*maxx)+(x+39)] = RGB15(16,16,16) | BIT(15);

    buffer[((y+45)*maxx)+(x+40)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+46)*maxx)+(x+0)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+46)*maxx)+(x+1)] = RGB15(16,16,16) | BIT(15);

    buffer[((y+46)*maxx)+(x+2)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+46)*maxx)+(x+3)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+46)*maxx)+(x+4)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+46)*maxx)+(x+5)] = RGB15(27,24,17) | BIT(15);

    buffer[((y+46)*maxx)+(x+6)] = RGB15(20,17,11) | BIT(15);

    buffer[((y+46)*maxx)+(x+7)] = RGB15(19,18,15) | BIT(15);

    buffer[((y+46)*maxx)+(x+8)] = RGB15(17,18,15) | BIT(15);

    buffer[((y+46)*maxx)+(x+9)] = RGB15(17,17,16) | BIT(15);

    buffer[((y+46)*maxx)+(x+10)] = RGB15(13,12,11) | BIT(15);

    buffer[((y+46)*maxx)+(x+11)] = RGB15(24,22,17) | BIT(15);

    buffer[((y+46)*maxx)+(x+12)] = RGB15(30,28,20) | BIT(15);

    buffer[((y+46)*maxx)+(x+13)] = RGB15(30,28,19) | BIT(15);

    buffer[((y+46)*maxx)+(x+14)] = RGB15(30,28,20) | BIT(15);

    buffer[((y+46)*maxx)+(x+15)] = RGB15(30,28,20) | BIT(15);

    buffer[((y+46)*maxx)+(x+16)] = RGB15(30,28,20) | BIT(15);

    buffer[((y+46)*maxx)+(x+17)] = RGB15(30,28,20) | BIT(15);

    buffer[((y+46)*maxx)+(x+18)] = RGB15(25,25,20) | BIT(15);

    buffer[((y+46)*maxx)+(x+19)] = RGB15(22,22,21) | BIT(15);

    buffer[((y+46)*maxx)+(x+20)] = RGB15(28,28,27) | BIT(15);

    buffer[((y+46)*maxx)+(x+21)] = RGB15(20,21,20) | BIT(15);

    buffer[((y+46)*maxx)+(x+22)] = RGB15(15,15,14) | BIT(15);

    buffer[((y+46)*maxx)+(x+23)] = RGB15(9,9,5) | BIT(15);

    buffer[((y+46)*maxx)+(x+24)] = RGB15(22,21,16) | BIT(15);

    buffer[((y+46)*maxx)+(x+25)] = RGB15(12,10,7) | BIT(15);

    buffer[((y+46)*maxx)+(x+26)] = RGB15(28,26,18) | BIT(15);

    buffer[((y+46)*maxx)+(x+27)] = RGB15(30,28,20) | BIT(15);

    buffer[((y+46)*maxx)+(x+28)] = RGB15(25,23,17) | BIT(15);

    buffer[((y+46)*maxx)+(x+29)] = RGB15(15,14,13) | BIT(15);

    buffer[((y+46)*maxx)+(x+30)] = RGB15(17,16,16) | BIT(15);

    buffer[((y+46)*maxx)+(x+31)] = RGB15(20,20,20) | BIT(15);

    buffer[((y+46)*maxx)+(x+32)] = RGB15(16,16,14) | BIT(15);

    buffer[((y+46)*maxx)+(x+33)] = RGB15(21,18,14) | BIT(15);

    buffer[((y+46)*maxx)+(x+34)] = RGB15(24,21,14) | BIT(15);

    buffer[((y+46)*maxx)+(x+35)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+46)*maxx)+(x+36)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+46)*maxx)+(x+37)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+46)*maxx)+(x+38)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+46)*maxx)+(x+39)] = RGB15(16,16,16) | BIT(15);

    buffer[((y+46)*maxx)+(x+40)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+47)*maxx)+(x+0)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+47)*maxx)+(x+1)] = RGB15(16,16,16) | BIT(15);

    buffer[((y+47)*maxx)+(x+2)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+47)*maxx)+(x+3)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+47)*maxx)+(x+4)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+47)*maxx)+(x+5)] = RGB15(24,21,14) | BIT(15);

    buffer[((y+47)*maxx)+(x+6)] = RGB15(22,19,15) | BIT(15);

    buffer[((y+47)*maxx)+(x+7)] = RGB15(13,13,11) | BIT(15);

    buffer[((y+47)*maxx)+(x+8)] = RGB15(8,10,6) | BIT(15);

    buffer[((y+47)*maxx)+(x+9)] = RGB15(12,13,10) | BIT(15);

    buffer[((y+47)*maxx)+(x+10)] = RGB15(21,19,17) | BIT(15);

    buffer[((y+47)*maxx)+(x+11)] = RGB15(28,26,19) | BIT(15);

    buffer[((y+47)*maxx)+(x+12)] = RGB15(31,28,19) | BIT(15);

    buffer[((y+47)*maxx)+(x+13)] = RGB15(30,28,21) | BIT(15);

    buffer[((y+47)*maxx)+(x+14)] = RGB15(30,28,20) | BIT(15);

    buffer[((y+47)*maxx)+(x+15)] = RGB15(30,28,20) | BIT(15);

    buffer[((y+47)*maxx)+(x+16)] = RGB15(30,28,20) | BIT(15);

    buffer[((y+47)*maxx)+(x+17)] = RGB15(30,28,20) | BIT(15);

    buffer[((y+47)*maxx)+(x+18)] = RGB15(28,27,20) | BIT(15);

    buffer[((y+47)*maxx)+(x+19)] = RGB15(23,22,20) | BIT(15);

    buffer[((y+47)*maxx)+(x+20)] = RGB15(24,25,24) | BIT(15);

    buffer[((y+47)*maxx)+(x+21)] = RGB15(22,24,22) | BIT(15);

    buffer[((y+47)*maxx)+(x+22)] = RGB15(8,9,6) | BIT(15);

    buffer[((y+47)*maxx)+(x+23)] = RGB15(7,8,5) | BIT(15);

    buffer[((y+47)*maxx)+(x+24)] = RGB15(7,7,5) | BIT(15);

    buffer[((y+47)*maxx)+(x+25)] = RGB15(9,8,6) | BIT(15);

    buffer[((y+47)*maxx)+(x+26)] = RGB15(26,25,19) | BIT(15);

    buffer[((y+47)*maxx)+(x+27)] = RGB15(31,28,20) | BIT(15);

    buffer[((y+47)*maxx)+(x+28)] = RGB15(30,28,20) | BIT(15);

    buffer[((y+47)*maxx)+(x+29)] = RGB15(23,22,18) | BIT(15);

    buffer[((y+47)*maxx)+(x+30)] = RGB15(13,12,11) | BIT(15);

    buffer[((y+47)*maxx)+(x+31)] = RGB15(14,15,14) | BIT(15);

    buffer[((y+47)*maxx)+(x+32)] = RGB15(13,13,12) | BIT(15);

    buffer[((y+47)*maxx)+(x+33)] = RGB15(22,20,16) | BIT(15);

    buffer[((y+47)*maxx)+(x+34)] = RGB15(22,19,13) | BIT(15);

    buffer[((y+47)*maxx)+(x+35)] = RGB15(30,28,20) | BIT(15);

    buffer[((y+47)*maxx)+(x+36)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+47)*maxx)+(x+37)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+47)*maxx)+(x+38)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+47)*maxx)+(x+39)] = RGB15(16,16,16) | BIT(15);

    buffer[((y+47)*maxx)+(x+40)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+48)*maxx)+(x+0)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+48)*maxx)+(x+1)] = RGB15(16,16,16) | BIT(15);

    buffer[((y+48)*maxx)+(x+2)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+48)*maxx)+(x+3)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+48)*maxx)+(x+4)] = RGB15(31,28,20) | BIT(15);

    buffer[((y+48)*maxx)+(x+5)] = RGB15(25,21,15) | BIT(15);

    buffer[((y+48)*maxx)+(x+6)] = RGB15(25,23,19) | BIT(15);

    buffer[((y+48)*maxx)+(x+7)] = RGB15(16,17,16) | BIT(15);

    buffer[((y+48)*maxx)+(x+8)] = RGB15(20,20,18) | BIT(15);

    buffer[((y+48)*maxx)+(x+9)] = RGB15(13,13,12) | BIT(15);

    buffer[((y+48)*maxx)+(x+10)] = RGB15(25,23,18) | BIT(15);

    buffer[((y+48)*maxx)+(x+11)] = RGB15(31,28,21) | BIT(15);

    buffer[((y+48)*maxx)+(x+12)] = RGB15(30,28,19) | BIT(15);

    buffer[((y+48)*maxx)+(x+13)] = RGB15(29,27,20) | BIT(15);

    buffer[((y+48)*maxx)+(x+14)] = RGB15(24,23,16) | BIT(15);

    buffer[((y+48)*maxx)+(x+15)] = RGB15(27,26,18) | BIT(15);

    buffer[((y+48)*maxx)+(x+16)] = RGB15(30,28,20) | BIT(15);

    buffer[((y+48)*maxx)+(x+17)] = RGB15(29,28,20) | BIT(15);

    buffer[((y+48)*maxx)+(x+18)] = RGB15(30,28,20) | BIT(15);

    buffer[((y+48)*maxx)+(x+19)] = RGB15(20,19,15) | BIT(15);

    buffer[((y+48)*maxx)+(x+20)] = RGB15(6,7,4) | BIT(15);

    buffer[((y+48)*maxx)+(x+21)] = RGB15(7,8,6) | BIT(15);

    buffer[((y+48)*maxx)+(x+22)] = RGB15(7,9,5) | BIT(15);

    buffer[((y+48)*maxx)+(x+23)] = RGB15(8,10,6) | BIT(15);

    buffer[((y+48)*maxx)+(x+24)] = RGB15(8,9,6) | BIT(15);

    buffer[((y+48)*maxx)+(x+25)] = RGB15(7,8,5) | BIT(15);

    buffer[((y+48)*maxx)+(x+26)] = RGB15(24,22,17) | BIT(15);

    buffer[((y+48)*maxx)+(x+27)] = RGB15(30,28,19) | BIT(15);

    buffer[((y+48)*maxx)+(x+28)] = RGB15(30,28,20) | BIT(15);

    buffer[((y+48)*maxx)+(x+29)] = RGB15(26,24,17) | BIT(15);

    buffer[((y+48)*maxx)+(x+30)] = RGB15(17,16,14) | BIT(15);

    buffer[((y+48)*maxx)+(x+31)] = RGB15(14,15,14) | BIT(15);

    buffer[((y+48)*maxx)+(x+32)] = RGB15(10,11,10) | BIT(15);

    buffer[((y+48)*maxx)+(x+33)] = RGB15(20,18,16) | BIT(15);

    buffer[((y+48)*maxx)+(x+34)] = RGB15(23,20,14) | BIT(15);

    buffer[((y+48)*maxx)+(x+35)] = RGB15(28,25,18) | BIT(15);

    buffer[((y+48)*maxx)+(x+36)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+48)*maxx)+(x+37)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+48)*maxx)+(x+38)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+48)*maxx)+(x+39)] = RGB15(16,16,16) | BIT(15);

    buffer[((y+48)*maxx)+(x+40)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+49)*maxx)+(x+0)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+49)*maxx)+(x+1)] = RGB15(16,16,16) | BIT(15);

    buffer[((y+49)*maxx)+(x+2)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+49)*maxx)+(x+3)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+49)*maxx)+(x+4)] = RGB15(29,27,19) | BIT(15);

    buffer[((y+49)*maxx)+(x+5)] = RGB15(24,20,14) | BIT(15);

    buffer[((y+49)*maxx)+(x+6)] = RGB15(20,18,16) | BIT(15);

    buffer[((y+49)*maxx)+(x+7)] = RGB15(12,12,11) | BIT(15);

    buffer[((y+49)*maxx)+(x+8)] = RGB15(13,13,12) | BIT(15);

    buffer[((y+49)*maxx)+(x+9)] = RGB15(18,17,15) | BIT(15);

    buffer[((y+49)*maxx)+(x+10)] = RGB15(27,25,18) | BIT(15);

    buffer[((y+49)*maxx)+(x+11)] = RGB15(27,26,20) | BIT(15);

    buffer[((y+49)*maxx)+(x+12)] = RGB15(25,24,18) | BIT(15);

    buffer[((y+49)*maxx)+(x+13)] = RGB15(16,16,12) | BIT(15);

    buffer[((y+49)*maxx)+(x+14)] = RGB15(16,15,14) | BIT(15);

    buffer[((y+49)*maxx)+(x+15)] = RGB15(11,10,8) | BIT(15);

    buffer[((y+49)*maxx)+(x+16)] = RGB15(24,23,18) | BIT(15);

    buffer[((y+49)*maxx)+(x+17)] = RGB15(30,28,20) | BIT(15);

    buffer[((y+49)*maxx)+(x+18)] = RGB15(29,27,19) | BIT(15);

    buffer[((y+49)*maxx)+(x+19)] = RGB15(18,17,13) | BIT(15);

    buffer[((y+49)*maxx)+(x+20)] = RGB15(7,9,6) | BIT(15);

    buffer[((y+49)*maxx)+(x+21)] = RGB15(7,9,6) | BIT(15);

    buffer[((y+49)*maxx)+(x+22)] = RGB15(9,10,7) | BIT(15);

    buffer[((y+49)*maxx)+(x+23)] = RGB15(9,10,6) | BIT(15);

    buffer[((y+49)*maxx)+(x+24)] = RGB15(9,10,7) | BIT(15);

    buffer[((y+49)*maxx)+(x+25)] = RGB15(7,8,5) | BIT(15);

    buffer[((y+49)*maxx)+(x+26)] = RGB15(17,16,11) | BIT(15);

    buffer[((y+49)*maxx)+(x+27)] = RGB15(28,26,18) | BIT(15);

    buffer[((y+49)*maxx)+(x+28)] = RGB15(29,26,19) | BIT(15);

    buffer[((y+49)*maxx)+(x+29)] = RGB15(28,26,19) | BIT(15);

    buffer[((y+49)*maxx)+(x+30)] = RGB15(21,20,16) | BIT(15);

    buffer[((y+49)*maxx)+(x+31)] = RGB15(14,14,13) | BIT(15);

    buffer[((y+49)*maxx)+(x+32)] = RGB15(21,22,21) | BIT(15);

    buffer[((y+49)*maxx)+(x+33)] = RGB15(17,16,14) | BIT(15);

    buffer[((y+49)*maxx)+(x+34)] = RGB15(22,18,14) | BIT(15);

    buffer[((y+49)*maxx)+(x+35)] = RGB15(26,23,16) | BIT(15);

    buffer[((y+49)*maxx)+(x+36)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+49)*maxx)+(x+37)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+49)*maxx)+(x+38)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+49)*maxx)+(x+39)] = RGB15(16,16,16) | BIT(15);

    buffer[((y+49)*maxx)+(x+40)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+50)*maxx)+(x+0)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+50)*maxx)+(x+1)] = RGB15(16,16,16) | BIT(15);

    buffer[((y+50)*maxx)+(x+2)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+50)*maxx)+(x+3)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+50)*maxx)+(x+4)] = RGB15(27,25,18) | BIT(15);

    buffer[((y+50)*maxx)+(x+5)] = RGB15(22,19,13) | BIT(15);

    buffer[((y+50)*maxx)+(x+6)] = RGB15(17,16,15) | BIT(15);

    buffer[((y+50)*maxx)+(x+7)] = RGB15(15,15,14) | BIT(15);

    buffer[((y+50)*maxx)+(x+8)] = RGB15(15,15,14) | BIT(15);

    buffer[((y+50)*maxx)+(x+9)] = RGB15(20,19,16) | BIT(15);

    buffer[((y+50)*maxx)+(x+10)] = RGB15(26,25,19) | BIT(15);

    buffer[((y+50)*maxx)+(x+11)] = RGB15(14,13,11) | BIT(15);

    buffer[((y+50)*maxx)+(x+12)] = RGB15(17,17,16) | BIT(15);

    buffer[((y+50)*maxx)+(x+13)] = RGB15(9,9,9) | BIT(15);

    buffer[((y+50)*maxx)+(x+14)] = RGB15(8,8,8) | BIT(15);

    buffer[((y+50)*maxx)+(x+15)] = RGB15(16,16,16) | BIT(15);

    buffer[((y+50)*maxx)+(x+16)] = RGB15(17,17,14) | BIT(15);

    buffer[((y+50)*maxx)+(x+17)] = RGB15(27,25,19) | BIT(15);

    buffer[((y+50)*maxx)+(x+18)] = RGB15(28,25,18) | BIT(15);

    buffer[((y+50)*maxx)+(x+19)] = RGB15(14,14,9) | BIT(15);

    buffer[((y+50)*maxx)+(x+20)] = RGB15(6,8,5) | BIT(15);

    buffer[((y+50)*maxx)+(x+21)] = RGB15(6,7,5) | BIT(15);

    buffer[((y+50)*maxx)+(x+22)] = RGB15(7,8,5) | BIT(15);

    buffer[((y+50)*maxx)+(x+23)] = RGB15(8,9,6) | BIT(15);

    buffer[((y+50)*maxx)+(x+24)] = RGB15(9,10,7) | BIT(15);

    buffer[((y+50)*maxx)+(x+25)] = RGB15(9,10,7) | BIT(15);

    buffer[((y+50)*maxx)+(x+26)] = RGB15(16,16,12) | BIT(15);

    buffer[((y+50)*maxx)+(x+27)] = RGB15(27,25,18) | BIT(15);

    buffer[((y+50)*maxx)+(x+28)] = RGB15(27,24,17) | BIT(15);

    buffer[((y+50)*maxx)+(x+29)] = RGB15(30,28,20) | BIT(15);

    buffer[((y+50)*maxx)+(x+30)] = RGB15(24,23,18) | BIT(15);

    buffer[((y+50)*maxx)+(x+31)] = RGB15(12,11,10) | BIT(15);

    buffer[((y+50)*maxx)+(x+32)] = RGB15(14,15,13) | BIT(15);

    buffer[((y+50)*maxx)+(x+33)] = RGB15(13,13,12) | BIT(15);

    buffer[((y+50)*maxx)+(x+34)] = RGB15(22,19,14) | BIT(15);

    buffer[((y+50)*maxx)+(x+35)] = RGB15(23,20,13) | BIT(15);

    buffer[((y+50)*maxx)+(x+36)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+50)*maxx)+(x+37)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+50)*maxx)+(x+38)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+50)*maxx)+(x+39)] = RGB15(16,16,16) | BIT(15);

    buffer[((y+50)*maxx)+(x+40)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+51)*maxx)+(x+0)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+51)*maxx)+(x+1)] = RGB15(16,16,16) | BIT(15);

    buffer[((y+51)*maxx)+(x+2)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+51)*maxx)+(x+3)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+51)*maxx)+(x+4)] = RGB15(26,23,16) | BIT(15);

    buffer[((y+51)*maxx)+(x+5)] = RGB15(21,17,12) | BIT(15);

    buffer[((y+51)*maxx)+(x+6)] = RGB15(15,15,15) | BIT(15);

    buffer[((y+51)*maxx)+(x+7)] = RGB15(22,21,20) | BIT(15);

    buffer[((y+51)*maxx)+(x+8)] = RGB15(13,14,13) | BIT(15);

    buffer[((y+51)*maxx)+(x+9)] = RGB15(23,21,18) | BIT(15);

    buffer[((y+51)*maxx)+(x+10)] = RGB15(28,27,20) | BIT(15);

    buffer[((y+51)*maxx)+(x+11)] = RGB15(17,17,15) | BIT(15);

    buffer[((y+51)*maxx)+(x+12)] = RGB15(12,12,11) | BIT(15);

    buffer[((y+51)*maxx)+(x+13)] = RGB15(8,6,6) | BIT(15);

    buffer[((y+51)*maxx)+(x+14)] = RGB15(10,9,8) | BIT(15);

    buffer[((y+51)*maxx)+(x+15)] = RGB15(18,18,17) | BIT(15);

    buffer[((y+51)*maxx)+(x+16)] = RGB15(16,15,13) | BIT(15);

    buffer[((y+51)*maxx)+(x+17)] = RGB15(26,24,18) | BIT(15);

    buffer[((y+51)*maxx)+(x+18)] = RGB15(25,23,16) | BIT(15);

    buffer[((y+51)*maxx)+(x+19)] = RGB15(18,18,13) | BIT(15);

    buffer[((y+51)*maxx)+(x+20)] = RGB15(5,7,4) | BIT(15);

    buffer[((y+51)*maxx)+(x+21)] = RGB15(4,6,3) | BIT(15);

    buffer[((y+51)*maxx)+(x+22)] = RGB15(7,8,5) | BIT(15);

    buffer[((y+51)*maxx)+(x+23)] = RGB15(6,7,4) | BIT(15);

    buffer[((y+51)*maxx)+(x+24)] = RGB15(7,8,6) | BIT(15);

    buffer[((y+51)*maxx)+(x+25)] = RGB15(7,8,5) | BIT(15);

    buffer[((y+51)*maxx)+(x+26)] = RGB15(8,8,4) | BIT(15);

    buffer[((y+51)*maxx)+(x+27)] = RGB15(24,22,16) | BIT(15);

    buffer[((y+51)*maxx)+(x+28)] = RGB15(26,23,17) | BIT(15);

    buffer[((y+51)*maxx)+(x+29)] = RGB15(29,27,20) | BIT(15);

    buffer[((y+51)*maxx)+(x+30)] = RGB15(25,23,18) | BIT(15);

    buffer[((y+51)*maxx)+(x+31)] = RGB15(15,14,14) | BIT(15);

    buffer[((y+51)*maxx)+(x+32)] = RGB15(14,15,12) | BIT(15);

    buffer[((y+51)*maxx)+(x+33)] = RGB15(11,12,10) | BIT(15);

    buffer[((y+51)*maxx)+(x+34)] = RGB15(25,22,18) | BIT(15);

    buffer[((y+51)*maxx)+(x+35)] = RGB15(24,21,15) | BIT(15);

    buffer[((y+51)*maxx)+(x+36)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+51)*maxx)+(x+37)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+51)*maxx)+(x+38)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+51)*maxx)+(x+39)] = RGB15(16,16,16) | BIT(15);

    buffer[((y+51)*maxx)+(x+40)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+52)*maxx)+(x+0)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+52)*maxx)+(x+1)] = RGB15(16,16,16) | BIT(15);

    buffer[((y+52)*maxx)+(x+2)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+52)*maxx)+(x+3)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+52)*maxx)+(x+4)] = RGB15(25,22,16) | BIT(15);

    buffer[((y+52)*maxx)+(x+5)] = RGB15(20,16,12) | BIT(15);

    buffer[((y+52)*maxx)+(x+6)] = RGB15(14,14,13) | BIT(15);

    buffer[((y+52)*maxx)+(x+7)] = RGB15(14,15,14) | BIT(15);

    buffer[((y+52)*maxx)+(x+8)] = RGB15(10,11,9) | BIT(15);

    buffer[((y+52)*maxx)+(x+9)] = RGB15(23,21,18) | BIT(15);

    buffer[((y+52)*maxx)+(x+10)] = RGB15(29,28,20) | BIT(15);

    buffer[((y+52)*maxx)+(x+11)] = RGB15(26,25,19) | BIT(15);

    buffer[((y+52)*maxx)+(x+12)] = RGB15(23,22,16) | BIT(15);

    buffer[((y+52)*maxx)+(x+13)] = RGB15(18,16,13) | BIT(15);

    buffer[((y+52)*maxx)+(x+14)] = RGB15(12,12,11) | BIT(15);

    buffer[((y+52)*maxx)+(x+15)] = RGB15(18,18,18) | BIT(15);

    buffer[((y+52)*maxx)+(x+16)] = RGB15(26,26,25) | BIT(15);

    buffer[((y+52)*maxx)+(x+17)] = RGB15(21,20,17) | BIT(15);

    buffer[((y+52)*maxx)+(x+18)] = RGB15(17,16,12) | BIT(15);

    buffer[((y+52)*maxx)+(x+19)] = RGB15(10,10,7) | BIT(15);

    buffer[((y+52)*maxx)+(x+20)] = RGB15(9,9,7) | BIT(15);

    buffer[((y+52)*maxx)+(x+21)] = RGB15(8,9,6) | BIT(15);

    buffer[((y+52)*maxx)+(x+22)] = RGB15(7,8,5) | BIT(15);

    buffer[((y+52)*maxx)+(x+23)] = RGB15(7,9,6) | BIT(15);

    buffer[((y+52)*maxx)+(x+24)] = RGB15(7,8,5) | BIT(15);

    buffer[((y+52)*maxx)+(x+25)] = RGB15(7,9,5) | BIT(15);

    buffer[((y+52)*maxx)+(x+26)] = RGB15(9,9,6) | BIT(15);

    buffer[((y+52)*maxx)+(x+27)] = RGB15(20,19,14) | BIT(15);

    buffer[((y+52)*maxx)+(x+28)] = RGB15(25,23,16) | BIT(15);

    buffer[((y+52)*maxx)+(x+29)] = RGB15(28,26,18) | BIT(15);

    buffer[((y+52)*maxx)+(x+30)] = RGB15(25,23,17) | BIT(15);

    buffer[((y+52)*maxx)+(x+31)] = RGB15(14,14,12) | BIT(15);

    buffer[((y+52)*maxx)+(x+32)] = RGB15(9,10,8) | BIT(15);

    buffer[((y+52)*maxx)+(x+33)] = RGB15(9,10,8) | BIT(15);

    buffer[((y+52)*maxx)+(x+34)] = RGB15(26,24,19) | BIT(15);

    buffer[((y+52)*maxx)+(x+35)] = RGB15(25,22,15) | BIT(15);

    buffer[((y+52)*maxx)+(x+36)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+52)*maxx)+(x+37)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+52)*maxx)+(x+38)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+52)*maxx)+(x+39)] = RGB15(16,16,16) | BIT(15);

    buffer[((y+52)*maxx)+(x+40)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+53)*maxx)+(x+0)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+53)*maxx)+(x+1)] = RGB15(16,16,16) | BIT(15);

    buffer[((y+53)*maxx)+(x+2)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+53)*maxx)+(x+3)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+53)*maxx)+(x+4)] = RGB15(25,23,16) | BIT(15);

    buffer[((y+53)*maxx)+(x+5)] = RGB15(21,17,12) | BIT(15);

    buffer[((y+53)*maxx)+(x+6)] = RGB15(15,15,14) | BIT(15);

    buffer[((y+53)*maxx)+(x+7)] = RGB15(18,18,17) | BIT(15);

    buffer[((y+53)*maxx)+(x+8)] = RGB15(14,15,13) | BIT(15);

    buffer[((y+53)*maxx)+(x+9)] = RGB15(22,21,18) | BIT(15);

    buffer[((y+53)*maxx)+(x+10)] = RGB15(26,24,17) | BIT(15);

    buffer[((y+53)*maxx)+(x+11)] = RGB15(26,23,16) | BIT(15);

    buffer[((y+53)*maxx)+(x+12)] = RGB15(27,26,18) | BIT(15);

    buffer[((y+53)*maxx)+(x+13)] = RGB15(24,23,17) | BIT(15);

    buffer[((y+53)*maxx)+(x+14)] = RGB15(25,25,24) | BIT(15);

    buffer[((y+53)*maxx)+(x+15)] = RGB15(22,22,22) | BIT(15);

    buffer[((y+53)*maxx)+(x+16)] = RGB15(23,23,23) | BIT(15);

    buffer[((y+53)*maxx)+(x+17)] = RGB15(8,8,7) | BIT(15);

    buffer[((y+53)*maxx)+(x+18)] = RGB15(11,11,10) | BIT(15);

    buffer[((y+53)*maxx)+(x+19)] = RGB15(6,6,5) | BIT(15);

    buffer[((y+53)*maxx)+(x+20)] = RGB15(8,9,8) | BIT(15);

    buffer[((y+53)*maxx)+(x+21)] = RGB15(6,7,5) | BIT(15);

    buffer[((y+53)*maxx)+(x+22)] = RGB15(6,8,5) | BIT(15);

    buffer[((y+53)*maxx)+(x+23)] = RGB15(7,9,6) | BIT(15);

    buffer[((y+53)*maxx)+(x+24)] = RGB15(5,7,4) | BIT(15);

    buffer[((y+53)*maxx)+(x+25)] = RGB15(7,9,6) | BIT(15);

    buffer[((y+53)*maxx)+(x+26)] = RGB15(10,11,8) | BIT(15);

    buffer[((y+53)*maxx)+(x+27)] = RGB15(16,16,11) | BIT(15);

    buffer[((y+53)*maxx)+(x+28)] = RGB15(27,25,18) | BIT(15);

    buffer[((y+53)*maxx)+(x+29)] = RGB15(27,25,17) | BIT(15);

    buffer[((y+53)*maxx)+(x+30)] = RGB15(25,23,17) | BIT(15);

    buffer[((y+53)*maxx)+(x+31)] = RGB15(12,12,10) | BIT(15);

    buffer[((y+53)*maxx)+(x+32)] = RGB15(10,11,9) | BIT(15);

    buffer[((y+53)*maxx)+(x+33)] = RGB15(10,10,8) | BIT(15);

    buffer[((y+53)*maxx)+(x+34)] = RGB15(24,22,17) | BIT(15);

    buffer[((y+53)*maxx)+(x+35)] = RGB15(24,21,14) | BIT(15);

    buffer[((y+53)*maxx)+(x+36)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+53)*maxx)+(x+37)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+53)*maxx)+(x+38)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+53)*maxx)+(x+39)] = RGB15(16,16,16) | BIT(15);

    buffer[((y+53)*maxx)+(x+40)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+54)*maxx)+(x+0)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+54)*maxx)+(x+1)] = RGB15(16,16,16) | BIT(15);

    buffer[((y+54)*maxx)+(x+2)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+54)*maxx)+(x+3)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+54)*maxx)+(x+4)] = RGB15(25,23,16) | BIT(15);

    buffer[((y+54)*maxx)+(x+5)] = RGB15(21,18,13) | BIT(15);

    buffer[((y+54)*maxx)+(x+6)] = RGB15(17,17,15) | BIT(15);

    buffer[((y+54)*maxx)+(x+7)] = RGB15(17,17,16) | BIT(15);

    buffer[((y+54)*maxx)+(x+8)] = RGB15(13,14,12) | BIT(15);

    buffer[((y+54)*maxx)+(x+9)] = RGB15(23,21,18) | BIT(15);

    buffer[((y+54)*maxx)+(x+10)] = RGB15(26,24,18) | BIT(15);

    buffer[((y+54)*maxx)+(x+11)] = RGB15(27,24,18) | BIT(15);

    buffer[((y+54)*maxx)+(x+12)] = RGB15(26,24,18) | BIT(15);

    buffer[((y+54)*maxx)+(x+13)] = RGB15(21,20,17) | BIT(15);

    buffer[((y+54)*maxx)+(x+14)] = RGB15(21,21,20) | BIT(15);

    buffer[((y+54)*maxx)+(x+15)] = RGB15(23,23,23) | BIT(15);

    buffer[((y+54)*maxx)+(x+16)] = RGB15(22,22,22) | BIT(15);

    buffer[((y+54)*maxx)+(x+17)] = RGB15(5,5,4) | BIT(15);

    buffer[((y+54)*maxx)+(x+18)] = RGB15(6,7,5) | BIT(15);

    buffer[((y+54)*maxx)+(x+19)] = RGB15(7,7,5) | BIT(15);

    buffer[((y+54)*maxx)+(x+20)] = RGB15(6,7,4) | BIT(15);

    buffer[((y+54)*maxx)+(x+21)] = RGB15(4,6,3) | BIT(15);

    buffer[((y+54)*maxx)+(x+22)] = RGB15(6,8,5) | BIT(15);

    buffer[((y+54)*maxx)+(x+23)] = RGB15(7,8,4) | BIT(15);

    buffer[((y+54)*maxx)+(x+24)] = RGB15(6,6,3) | BIT(15);

    buffer[((y+54)*maxx)+(x+25)] = RGB15(7,7,5) | BIT(15);

    buffer[((y+54)*maxx)+(x+26)] = RGB15(9,8,5) | BIT(15);

    buffer[((y+54)*maxx)+(x+27)] = RGB15(18,17,12) | BIT(15);

    buffer[((y+54)*maxx)+(x+28)] = RGB15(25,23,17) | BIT(15);

    buffer[((y+54)*maxx)+(x+29)] = RGB15(27,25,17) | BIT(15);

    buffer[((y+54)*maxx)+(x+30)] = RGB15(25,23,18) | BIT(15);

    buffer[((y+54)*maxx)+(x+31)] = RGB15(15,15,13) | BIT(15);

    buffer[((y+54)*maxx)+(x+32)] = RGB15(21,21,20) | BIT(15);

    buffer[((y+54)*maxx)+(x+33)] = RGB15(15,15,14) | BIT(15);

    buffer[((y+54)*maxx)+(x+34)] = RGB15(24,22,18) | BIT(15);

    buffer[((y+54)*maxx)+(x+35)] = RGB15(23,20,14) | BIT(15);

    buffer[((y+54)*maxx)+(x+36)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+54)*maxx)+(x+37)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+54)*maxx)+(x+38)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+54)*maxx)+(x+39)] = RGB15(16,16,16) | BIT(15);

    buffer[((y+54)*maxx)+(x+40)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+55)*maxx)+(x+0)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+55)*maxx)+(x+1)] = RGB15(16,16,16) | BIT(15);

    buffer[((y+55)*maxx)+(x+2)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+55)*maxx)+(x+3)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+55)*maxx)+(x+4)] = RGB15(26,24,17) | BIT(15);

    buffer[((y+55)*maxx)+(x+5)] = RGB15(23,20,14) | BIT(15);

    buffer[((y+55)*maxx)+(x+6)] = RGB15(16,16,14) | BIT(15);

    buffer[((y+55)*maxx)+(x+7)] = RGB15(17,17,16) | BIT(15);

    buffer[((y+55)*maxx)+(x+8)] = RGB15(12,12,11) | BIT(15);

    buffer[((y+55)*maxx)+(x+9)] = RGB15(23,22,19) | BIT(15);

    buffer[((y+55)*maxx)+(x+10)] = RGB15(28,27,19) | BIT(15);

    buffer[((y+55)*maxx)+(x+11)] = RGB15(27,25,18) | BIT(15);

    buffer[((y+55)*maxx)+(x+12)] = RGB15(26,25,18) | BIT(15);

    buffer[((y+55)*maxx)+(x+13)] = RGB15(22,22,20) | BIT(15);

    buffer[((y+55)*maxx)+(x+14)] = RGB15(26,26,25) | BIT(15);

    buffer[((y+55)*maxx)+(x+15)] = RGB15(26,27,25) | BIT(15);

    buffer[((y+55)*maxx)+(x+16)] = RGB15(8,9,7) | BIT(15);

    buffer[((y+55)*maxx)+(x+17)] = RGB15(7,8,6) | BIT(15);

    buffer[((y+55)*maxx)+(x+18)] = RGB15(7,8,6) | BIT(15);

    buffer[((y+55)*maxx)+(x+19)] = RGB15(5,7,4) | BIT(15);

    buffer[((y+55)*maxx)+(x+20)] = RGB15(7,9,6) | BIT(15);

    buffer[((y+55)*maxx)+(x+21)] = RGB15(8,9,7) | BIT(15);

    buffer[((y+55)*maxx)+(x+22)] = RGB15(8,10,6) | BIT(15);

    buffer[((y+55)*maxx)+(x+23)] = RGB15(10,10,7) | BIT(15);

    buffer[((y+55)*maxx)+(x+24)] = RGB15(16,13,10) | BIT(15);

    buffer[((y+55)*maxx)+(x+25)] = RGB15(15,12,9) | BIT(15);

    buffer[((y+55)*maxx)+(x+26)] = RGB15(19,16,11) | BIT(15);

    buffer[((y+55)*maxx)+(x+27)] = RGB15(20,18,13) | BIT(15);

    buffer[((y+55)*maxx)+(x+28)] = RGB15(20,18,12) | BIT(15);

    buffer[((y+55)*maxx)+(x+29)] = RGB15(28,26,20) | BIT(15);

    buffer[((y+55)*maxx)+(x+30)] = RGB15(25,23,19) | BIT(15);

    buffer[((y+55)*maxx)+(x+31)] = RGB15(13,13,12) | BIT(15);

    buffer[((y+55)*maxx)+(x+32)] = RGB15(17,17,17) | BIT(15);

    buffer[((y+55)*maxx)+(x+33)] = RGB15(14,14,13) | BIT(15);

    buffer[((y+55)*maxx)+(x+34)] = RGB15(23,21,17) | BIT(15);

    buffer[((y+55)*maxx)+(x+35)] = RGB15(21,18,13) | BIT(15);

    buffer[((y+55)*maxx)+(x+36)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+55)*maxx)+(x+37)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+55)*maxx)+(x+38)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+55)*maxx)+(x+39)] = RGB15(16,16,16) | BIT(15);

    buffer[((y+55)*maxx)+(x+40)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+56)*maxx)+(x+0)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+56)*maxx)+(x+1)] = RGB15(16,16,16) | BIT(15);

    buffer[((y+56)*maxx)+(x+2)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+56)*maxx)+(x+3)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+56)*maxx)+(x+4)] = RGB15(29,27,19) | BIT(15);

    buffer[((y+56)*maxx)+(x+5)] = RGB15(26,22,16) | BIT(15);

    buffer[((y+56)*maxx)+(x+6)] = RGB15(17,17,15) | BIT(15);

    buffer[((y+56)*maxx)+(x+7)] = RGB15(17,17,17) | BIT(15);

    buffer[((y+56)*maxx)+(x+8)] = RGB15(12,12,10) | BIT(15);

    buffer[((y+56)*maxx)+(x+9)] = RGB15(24,22,19) | BIT(15);

    buffer[((y+56)*maxx)+(x+10)] = RGB15(30,29,21) | BIT(15);

    buffer[((y+56)*maxx)+(x+11)] = RGB15(31,28,21) | BIT(15);

    buffer[((y+56)*maxx)+(x+12)] = RGB15(29,28,21) | BIT(15);

    buffer[((y+56)*maxx)+(x+13)] = RGB15(22,22,20) | BIT(15);

    buffer[((y+56)*maxx)+(x+14)] = RGB15(22,23,22) | BIT(15);

    buffer[((y+56)*maxx)+(x+15)] = RGB15(21,21,20) | BIT(15);

    buffer[((y+56)*maxx)+(x+16)] = RGB15(9,11,8) | BIT(15);

    buffer[((y+56)*maxx)+(x+17)] = RGB15(5,6,4) | BIT(15);

    buffer[((y+56)*maxx)+(x+18)] = RGB15(5,6,4) | BIT(15);

    buffer[((y+56)*maxx)+(x+19)] = RGB15(6,8,5) | BIT(15);

    buffer[((y+56)*maxx)+(x+20)] = RGB15(7,9,6) | BIT(15);

    buffer[((y+56)*maxx)+(x+21)] = RGB15(5,6,4) | BIT(15);

    buffer[((y+56)*maxx)+(x+22)] = RGB15(4,5,3) | BIT(15);

    buffer[((y+56)*maxx)+(x+23)] = RGB15(10,9,6) | BIT(15);

    buffer[((y+56)*maxx)+(x+24)] = RGB15(12,11,8) | BIT(15);

    buffer[((y+56)*maxx)+(x+25)] = RGB15(16,14,10) | BIT(15);

    buffer[((y+56)*maxx)+(x+26)] = RGB15(21,18,13) | BIT(15);

    buffer[((y+56)*maxx)+(x+27)] = RGB15(20,17,12) | BIT(15);

    buffer[((y+56)*maxx)+(x+28)] = RGB15(20,18,12) | BIT(15);

    buffer[((y+56)*maxx)+(x+29)] = RGB15(27,25,18) | BIT(15);

    buffer[((y+56)*maxx)+(x+30)] = RGB15(25,23,18) | BIT(15);

    buffer[((y+56)*maxx)+(x+31)] = RGB15(14,14,12) | BIT(15);

    buffer[((y+56)*maxx)+(x+32)] = RGB15(17,17,16) | BIT(15);

    buffer[((y+56)*maxx)+(x+33)] = RGB15(13,13,12) | BIT(15);

    buffer[((y+56)*maxx)+(x+34)] = RGB15(24,22,18) | BIT(15);

    buffer[((y+56)*maxx)+(x+35)] = RGB15(22,19,13) | BIT(15);

    buffer[((y+56)*maxx)+(x+36)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+56)*maxx)+(x+37)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+56)*maxx)+(x+38)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+56)*maxx)+(x+39)] = RGB15(16,16,16) | BIT(15);

    buffer[((y+56)*maxx)+(x+40)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+57)*maxx)+(x+0)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+57)*maxx)+(x+1)] = RGB15(16,16,16) | BIT(15);

    buffer[((y+57)*maxx)+(x+2)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+57)*maxx)+(x+3)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+57)*maxx)+(x+4)] = RGB15(27,24,17) | BIT(15);

    buffer[((y+57)*maxx)+(x+5)] = RGB15(25,21,15) | BIT(15);

    buffer[((y+57)*maxx)+(x+6)] = RGB15(17,17,15) | BIT(15);

    buffer[((y+57)*maxx)+(x+7)] = RGB15(22,22,21) | BIT(15);

    buffer[((y+57)*maxx)+(x+8)] = RGB15(15,16,14) | BIT(15);

    buffer[((y+57)*maxx)+(x+9)] = RGB15(24,22,18) | BIT(15);

    buffer[((y+57)*maxx)+(x+10)] = RGB15(30,29,21) | BIT(15);

    buffer[((y+57)*maxx)+(x+11)] = RGB15(31,28,21) | BIT(15);

    buffer[((y+57)*maxx)+(x+12)] = RGB15(29,28,21) | BIT(15);

    buffer[((y+57)*maxx)+(x+13)] = RGB15(21,20,18) | BIT(15);

    buffer[((y+57)*maxx)+(x+14)] = RGB15(22,22,22) | BIT(15);

    buffer[((y+57)*maxx)+(x+15)] = RGB15(23,23,22) | BIT(15);

    buffer[((y+57)*maxx)+(x+16)] = RGB15(11,13,11) | BIT(15);

    buffer[((y+57)*maxx)+(x+17)] = RGB15(6,7,5) | BIT(15);

    buffer[((y+57)*maxx)+(x+18)] = RGB15(6,7,4) | BIT(15);

    buffer[((y+57)*maxx)+(x+19)] = RGB15(6,8,5) | BIT(15);

    buffer[((y+57)*maxx)+(x+20)] = RGB15(6,8,4) | BIT(15);

    buffer[((y+57)*maxx)+(x+21)] = RGB15(7,8,5) | BIT(15);

    buffer[((y+57)*maxx)+(x+22)] = RGB15(7,8,5) | BIT(15);

    buffer[((y+57)*maxx)+(x+23)] = RGB15(14,12,8) | BIT(15);

    buffer[((y+57)*maxx)+(x+24)] = RGB15(17,15,11) | BIT(15);

    buffer[((y+57)*maxx)+(x+25)] = RGB15(16,14,9) | BIT(15);

    buffer[((y+57)*maxx)+(x+26)] = RGB15(16,13,10) | BIT(15);

    buffer[((y+57)*maxx)+(x+27)] = RGB15(18,16,13) | BIT(15);

    buffer[((y+57)*maxx)+(x+28)] = RGB15(18,16,11) | BIT(15);

    buffer[((y+57)*maxx)+(x+29)] = RGB15(29,27,19) | BIT(15);

    buffer[((y+57)*maxx)+(x+30)] = RGB15(25,23,18) | BIT(15);

    buffer[((y+57)*maxx)+(x+31)] = RGB15(14,14,12) | BIT(15);

    buffer[((y+57)*maxx)+(x+32)] = RGB15(13,13,12) | BIT(15);

    buffer[((y+57)*maxx)+(x+33)] = RGB15(12,12,11) | BIT(15);

    buffer[((y+57)*maxx)+(x+34)] = RGB15(24,22,18) | BIT(15);

    buffer[((y+57)*maxx)+(x+35)] = RGB15(24,21,15) | BIT(15);

    buffer[((y+57)*maxx)+(x+36)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+57)*maxx)+(x+37)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+57)*maxx)+(x+38)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+57)*maxx)+(x+39)] = RGB15(16,16,16) | BIT(15);

    buffer[((y+57)*maxx)+(x+40)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+58)*maxx)+(x+0)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+58)*maxx)+(x+1)] = RGB15(16,16,16) | BIT(15);

    buffer[((y+58)*maxx)+(x+2)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+58)*maxx)+(x+3)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+58)*maxx)+(x+4)] = RGB15(25,23,16) | BIT(15);

    buffer[((y+58)*maxx)+(x+5)] = RGB15(23,20,14) | BIT(15);

    buffer[((y+58)*maxx)+(x+6)] = RGB15(17,17,15) | BIT(15);

    buffer[((y+58)*maxx)+(x+7)] = RGB15(16,16,16) | BIT(15);

    buffer[((y+58)*maxx)+(x+8)] = RGB15(13,13,12) | BIT(15);

    buffer[((y+58)*maxx)+(x+9)] = RGB15(24,22,19) | BIT(15);

    buffer[((y+58)*maxx)+(x+10)] = RGB15(30,28,21) | BIT(15);

    buffer[((y+58)*maxx)+(x+11)] = RGB15(28,26,18) | BIT(15);

    buffer[((y+58)*maxx)+(x+12)] = RGB15(28,26,19) | BIT(15);

    buffer[((y+58)*maxx)+(x+13)] = RGB15(24,24,20) | BIT(15);

    buffer[((y+58)*maxx)+(x+14)] = RGB15(20,20,19) | BIT(15);

    buffer[((y+58)*maxx)+(x+15)] = RGB15(22,21,19) | BIT(15);

    buffer[((y+58)*maxx)+(x+16)] = RGB15(25,25,25) | BIT(15);

    buffer[((y+58)*maxx)+(x+17)] = RGB15(9,9,7) | BIT(15);

    buffer[((y+58)*maxx)+(x+18)] = RGB15(9,10,6) | BIT(15);

    buffer[((y+58)*maxx)+(x+19)] = RGB15(9,10,6) | BIT(15);

    buffer[((y+58)*maxx)+(x+20)] = RGB15(7,8,4) | BIT(15);

    buffer[((y+58)*maxx)+(x+21)] = RGB15(7,8,5) | BIT(15);

    buffer[((y+58)*maxx)+(x+22)] = RGB15(8,8,5) | BIT(15);

    buffer[((y+58)*maxx)+(x+23)] = RGB15(18,16,11) | BIT(15);

    buffer[((y+58)*maxx)+(x+24)] = RGB15(15,12,8) | BIT(15);

    buffer[((y+58)*maxx)+(x+25)] = RGB15(19,17,12) | BIT(15);

    buffer[((y+58)*maxx)+(x+26)] = RGB15(19,17,11) | BIT(15);

    buffer[((y+58)*maxx)+(x+27)] = RGB15(18,16,12) | BIT(15);

    buffer[((y+58)*maxx)+(x+28)] = RGB15(16,14,10) | BIT(15);

    buffer[((y+58)*maxx)+(x+29)] = RGB15(29,27,21) | BIT(15);

    buffer[((y+58)*maxx)+(x+30)] = RGB15(25,23,17) | BIT(15);

    buffer[((y+58)*maxx)+(x+31)] = RGB15(15,15,13) | BIT(15);

    buffer[((y+58)*maxx)+(x+32)] = RGB15(19,19,18) | BIT(15);

    buffer[((y+58)*maxx)+(x+33)] = RGB15(15,15,14) | BIT(15);

    buffer[((y+58)*maxx)+(x+34)] = RGB15(26,23,18) | BIT(15);

    buffer[((y+58)*maxx)+(x+35)] = RGB15(26,23,17) | BIT(15);

    buffer[((y+58)*maxx)+(x+36)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+58)*maxx)+(x+37)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+58)*maxx)+(x+38)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+58)*maxx)+(x+39)] = RGB15(16,16,16) | BIT(15);

    buffer[((y+58)*maxx)+(x+40)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+59)*maxx)+(x+0)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+59)*maxx)+(x+1)] = RGB15(16,16,16) | BIT(15);

    buffer[((y+59)*maxx)+(x+2)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+59)*maxx)+(x+3)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+59)*maxx)+(x+4)] = RGB15(25,23,16) | BIT(15);

    buffer[((y+59)*maxx)+(x+5)] = RGB15(22,18,13) | BIT(15);

    buffer[((y+59)*maxx)+(x+6)] = RGB15(15,15,14) | BIT(15);

    buffer[((y+59)*maxx)+(x+7)] = RGB15(14,14,14) | BIT(15);

    buffer[((y+59)*maxx)+(x+8)] = RGB15(13,13,12) | BIT(15);

    buffer[((y+59)*maxx)+(x+9)] = RGB15(25,23,20) | BIT(15);

    buffer[((y+59)*maxx)+(x+10)] = RGB15(29,28,20) | BIT(15);

    buffer[((y+59)*maxx)+(x+11)] = RGB15(28,26,19) | BIT(15);

    buffer[((y+59)*maxx)+(x+12)] = RGB15(28,26,19) | BIT(15);

    buffer[((y+59)*maxx)+(x+13)] = RGB15(25,23,20) | BIT(15);

    buffer[((y+59)*maxx)+(x+14)] = RGB15(25,24,22) | BIT(15);

    buffer[((y+59)*maxx)+(x+15)] = RGB15(23,22,18) | BIT(15);

    buffer[((y+59)*maxx)+(x+16)] = RGB15(23,23,22) | BIT(15);

    buffer[((y+59)*maxx)+(x+17)] = RGB15(13,13,10) | BIT(15);

    buffer[((y+59)*maxx)+(x+18)] = RGB15(11,12,7) | BIT(15);

    buffer[((y+59)*maxx)+(x+19)] = RGB15(16,15,11) | BIT(15);

    buffer[((y+59)*maxx)+(x+20)] = RGB15(13,12,9) | BIT(15);

    buffer[((y+59)*maxx)+(x+21)] = RGB15(7,7,5) | BIT(15);

    buffer[((y+59)*maxx)+(x+22)] = RGB15(7,8,5) | BIT(15);

    buffer[((y+59)*maxx)+(x+23)] = RGB15(16,14,9) | BIT(15);

    buffer[((y+59)*maxx)+(x+24)] = RGB15(18,15,11) | BIT(15);

    buffer[((y+59)*maxx)+(x+25)] = RGB15(13,11,7) | BIT(15);

    buffer[((y+59)*maxx)+(x+26)] = RGB15(15,12,8) | BIT(15);

    buffer[((y+59)*maxx)+(x+27)] = RGB15(13,11,8) | BIT(15);

    buffer[((y+59)*maxx)+(x+28)] = RGB15(12,10,7) | BIT(15);

    buffer[((y+59)*maxx)+(x+29)] = RGB15(30,28,21) | BIT(15);

    buffer[((y+59)*maxx)+(x+30)] = RGB15(24,22,17) | BIT(15);

    buffer[((y+59)*maxx)+(x+31)] = RGB15(13,14,12) | BIT(15);

    buffer[((y+59)*maxx)+(x+32)] = RGB15(18,19,18) | BIT(15);

    buffer[((y+59)*maxx)+(x+33)] = RGB15(12,12,11) | BIT(15);

    buffer[((y+59)*maxx)+(x+34)] = RGB15(24,21,17) | BIT(15);

    buffer[((y+59)*maxx)+(x+35)] = RGB15(23,20,14) | BIT(15);

    buffer[((y+59)*maxx)+(x+36)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+59)*maxx)+(x+37)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+59)*maxx)+(x+38)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+59)*maxx)+(x+39)] = RGB15(16,16,16) | BIT(15);

    buffer[((y+59)*maxx)+(x+40)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+60)*maxx)+(x+0)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+60)*maxx)+(x+1)] = RGB15(16,16,16) | BIT(15);

    buffer[((y+60)*maxx)+(x+2)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+60)*maxx)+(x+3)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+60)*maxx)+(x+4)] = RGB15(25,23,16) | BIT(15);

    buffer[((y+60)*maxx)+(x+5)] = RGB15(22,18,13) | BIT(15);

    buffer[((y+60)*maxx)+(x+6)] = RGB15(14,15,13) | BIT(15);

    buffer[((y+60)*maxx)+(x+7)] = RGB15(13,14,11) | BIT(15);

    buffer[((y+60)*maxx)+(x+8)] = RGB15(12,12,9) | BIT(15);

    buffer[((y+60)*maxx)+(x+9)] = RGB15(24,23,19) | BIT(15);

    buffer[((y+60)*maxx)+(x+10)] = RGB15(29,26,20) | BIT(15);

    buffer[((y+60)*maxx)+(x+11)] = RGB15(27,24,17) | BIT(15);

    buffer[((y+60)*maxx)+(x+12)] = RGB15(27,24,18) | BIT(15);

    buffer[((y+60)*maxx)+(x+13)] = RGB15(24,22,18) | BIT(15);

    buffer[((y+60)*maxx)+(x+14)] = RGB15(25,23,19) | BIT(15);

    buffer[((y+60)*maxx)+(x+15)] = RGB15(24,21,15) | BIT(15);

    buffer[((y+60)*maxx)+(x+16)] = RGB15(22,21,18) | BIT(15);

    buffer[((y+60)*maxx)+(x+17)] = RGB15(17,16,11) | BIT(15);

    buffer[((y+60)*maxx)+(x+18)] = RGB15(17,15,10) | BIT(15);

    buffer[((y+60)*maxx)+(x+19)] = RGB15(19,17,12) | BIT(15);

    buffer[((y+60)*maxx)+(x+20)] = RGB15(18,16,11) | BIT(15);

    buffer[((y+60)*maxx)+(x+21)] = RGB15(14,12,8) | BIT(15);

    buffer[((y+60)*maxx)+(x+22)] = RGB15(14,12,9) | BIT(15);

    buffer[((y+60)*maxx)+(x+23)] = RGB15(18,14,11) | BIT(15);

    buffer[((y+60)*maxx)+(x+24)] = RGB15(21,17,13) | BIT(15);

    buffer[((y+60)*maxx)+(x+25)] = RGB15(20,16,12) | BIT(15);

    buffer[((y+60)*maxx)+(x+26)] = RGB15(19,16,12) | BIT(15);

    buffer[((y+60)*maxx)+(x+27)] = RGB15(17,16,11) | BIT(15);

    buffer[((y+60)*maxx)+(x+28)] = RGB15(19,17,12) | BIT(15);

    buffer[((y+60)*maxx)+(x+29)] = RGB15(29,27,21) | BIT(15);

    buffer[((y+60)*maxx)+(x+30)] = RGB15(24,22,17) | BIT(15);

    buffer[((y+60)*maxx)+(x+31)] = RGB15(12,12,8) | BIT(15);

    buffer[((y+60)*maxx)+(x+32)] = RGB15(9,10,7) | BIT(15);

    buffer[((y+60)*maxx)+(x+33)] = RGB15(8,9,6) | BIT(15);

    buffer[((y+60)*maxx)+(x+34)] = RGB15(23,21,17) | BIT(15);

    buffer[((y+60)*maxx)+(x+35)] = RGB15(23,20,14) | BIT(15);

    buffer[((y+60)*maxx)+(x+36)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+60)*maxx)+(x+37)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+60)*maxx)+(x+38)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+60)*maxx)+(x+39)] = RGB15(16,16,16) | BIT(15);

    buffer[((y+60)*maxx)+(x+40)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+61)*maxx)+(x+0)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+61)*maxx)+(x+1)] = RGB15(16,16,16) | BIT(15);

    buffer[((y+61)*maxx)+(x+2)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+61)*maxx)+(x+3)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+61)*maxx)+(x+4)] = RGB15(27,24,17) | BIT(15);

    buffer[((y+61)*maxx)+(x+5)] = RGB15(24,21,15) | BIT(15);

    buffer[((y+61)*maxx)+(x+6)] = RGB15(21,19,15) | BIT(15);

    buffer[((y+61)*maxx)+(x+7)] = RGB15(20,18,13) | BIT(15);

    buffer[((y+61)*maxx)+(x+8)] = RGB15(21,20,16) | BIT(15);

    buffer[((y+61)*maxx)+(x+9)] = RGB15(25,21,17) | BIT(15);

    buffer[((y+61)*maxx)+(x+10)] = RGB15(24,21,18) | BIT(15);

    buffer[((y+61)*maxx)+(x+11)] = RGB15(24,20,17) | BIT(15);

    buffer[((y+61)*maxx)+(x+12)] = RGB15(23,20,17) | BIT(15);

    buffer[((y+61)*maxx)+(x+13)] = RGB15(22,19,17) | BIT(15);

    buffer[((y+61)*maxx)+(x+14)] = RGB15(21,18,17) | BIT(15);

    buffer[((y+61)*maxx)+(x+15)] = RGB15(22,18,15) | BIT(15);

    buffer[((y+61)*maxx)+(x+16)] = RGB15(22,17,17) | BIT(15);

    buffer[((y+61)*maxx)+(x+17)] = RGB15(22,17,16) | BIT(15);

    buffer[((y+61)*maxx)+(x+18)] = RGB15(22,17,16) | BIT(15);

    buffer[((y+61)*maxx)+(x+19)] = RGB15(22,17,16) | BIT(15);

    buffer[((y+61)*maxx)+(x+20)] = RGB15(21,17,16) | BIT(15);

    buffer[((y+61)*maxx)+(x+21)] = RGB15(21,16,16) | BIT(15);

    buffer[((y+61)*maxx)+(x+22)] = RGB15(20,17,15) | BIT(15);

    buffer[((y+61)*maxx)+(x+23)] = RGB15(22,17,15) | BIT(15);

    buffer[((y+61)*maxx)+(x+24)] = RGB15(21,18,16) | BIT(15);

    buffer[((y+61)*maxx)+(x+25)] = RGB15(21,18,16) | BIT(15);

    buffer[((y+61)*maxx)+(x+26)] = RGB15(21,18,16) | BIT(15);

    buffer[((y+61)*maxx)+(x+27)] = RGB15(22,18,16) | BIT(15);

    buffer[((y+61)*maxx)+(x+28)] = RGB15(22,19,16) | BIT(15);

    buffer[((y+61)*maxx)+(x+29)] = RGB15(22,19,16) | BIT(15);

    buffer[((y+61)*maxx)+(x+30)] = RGB15(24,20,16) | BIT(15);

    buffer[((y+61)*maxx)+(x+31)] = RGB15(21,20,16) | BIT(15);

    buffer[((y+61)*maxx)+(x+32)] = RGB15(18,17,13) | BIT(15);

    buffer[((y+61)*maxx)+(x+33)] = RGB15(16,14,11) | BIT(15);

    buffer[((y+61)*maxx)+(x+34)] = RGB15(20,17,14) | BIT(15);

    buffer[((y+61)*maxx)+(x+35)] = RGB15(19,17,11) | BIT(15);

    buffer[((y+61)*maxx)+(x+36)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+61)*maxx)+(x+37)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+61)*maxx)+(x+38)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+61)*maxx)+(x+39)] = RGB15(16,16,16) | BIT(15);

    buffer[((y+61)*maxx)+(x+40)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+62)*maxx)+(x+0)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+62)*maxx)+(x+1)] = RGB15(16,16,16) | BIT(15);

    buffer[((y+62)*maxx)+(x+2)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+62)*maxx)+(x+3)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+62)*maxx)+(x+4)] = RGB15(25,22,17) | BIT(15);

    buffer[((y+62)*maxx)+(x+5)] = RGB15(22,18,16) | BIT(15);

    buffer[((y+62)*maxx)+(x+6)] = RGB15(21,16,15) | BIT(15);

    buffer[((y+62)*maxx)+(x+7)] = RGB15(21,15,13) | BIT(15);

    buffer[((y+62)*maxx)+(x+8)] = RGB15(20,18,17) | BIT(15);

    buffer[((y+62)*maxx)+(x+9)] = RGB15(17,10,11) | BIT(15);

    buffer[((y+62)*maxx)+(x+10)] = RGB15(19,8,9) | BIT(15);

    buffer[((y+62)*maxx)+(x+11)] = RGB15(18,7,9) | BIT(15);

    buffer[((y+62)*maxx)+(x+12)] = RGB15(17,8,10) | BIT(15);

    buffer[((y+62)*maxx)+(x+13)] = RGB15(20,5,9) | BIT(15);

    buffer[((y+62)*maxx)+(x+14)] = RGB15(20,6,9) | BIT(15);

    buffer[((y+62)*maxx)+(x+15)] = RGB15(21,13,14) | BIT(15);

    buffer[((y+62)*maxx)+(x+16)] = RGB15(21,15,16) | BIT(15);

    buffer[((y+62)*maxx)+(x+17)] = RGB15(21,15,16) | BIT(15);

    buffer[((y+62)*maxx)+(x+18)] = RGB15(18,7,9) | BIT(15);

    buffer[((y+62)*maxx)+(x+19)] = RGB15(19,8,10) | BIT(15);

    buffer[((y+62)*maxx)+(x+20)] = RGB15(22,15,17) | BIT(15);

    buffer[((y+62)*maxx)+(x+21)] = RGB15(21,17,17) | BIT(15);

    buffer[((y+62)*maxx)+(x+22)] = RGB15(19,11,12) | BIT(15);

    buffer[((y+62)*maxx)+(x+23)] = RGB15(18,6,9) | BIT(15);

    buffer[((y+62)*maxx)+(x+24)] = RGB15(20,13,14) | BIT(15);

    buffer[((y+62)*maxx)+(x+25)] = RGB15(19,12,14) | BIT(15);

    buffer[((y+62)*maxx)+(x+26)] = RGB15(19,11,12) | BIT(15);

    buffer[((y+62)*maxx)+(x+27)] = RGB15(18,6,8) | BIT(15);

    buffer[((y+62)*maxx)+(x+28)] = RGB15(18,8,10) | BIT(15);

    buffer[((y+62)*maxx)+(x+29)] = RGB15(17,9,10) | BIT(15);

    buffer[((y+62)*maxx)+(x+30)] = RGB15(18,9,10) | BIT(15);

    buffer[((y+62)*maxx)+(x+31)] = RGB15(20,11,11) | BIT(15);

    buffer[((y+62)*maxx)+(x+32)] = RGB15(22,13,14) | BIT(15);

    buffer[((y+62)*maxx)+(x+33)] = RGB15(21,15,15) | BIT(15);

    buffer[((y+62)*maxx)+(x+34)] = RGB15(21,17,16) | BIT(15);

    buffer[((y+62)*maxx)+(x+35)] = RGB15(21,19,15) | BIT(15);

    buffer[((y+62)*maxx)+(x+36)] = RGB15(27,26,19) | BIT(15);

    buffer[((y+62)*maxx)+(x+37)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+62)*maxx)+(x+38)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+62)*maxx)+(x+39)] = RGB15(16,16,16) | BIT(15);

    buffer[((y+62)*maxx)+(x+40)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+63)*maxx)+(x+0)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+63)*maxx)+(x+1)] = RGB15(16,16,16) | BIT(15);

    buffer[((y+63)*maxx)+(x+2)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+63)*maxx)+(x+3)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+63)*maxx)+(x+4)] = RGB15(20,13,10) | BIT(15);

    buffer[((y+63)*maxx)+(x+5)] = RGB15(20,6,9) | BIT(15);

    buffer[((y+63)*maxx)+(x+6)] = RGB15(21,7,10) | BIT(15);

    buffer[((y+63)*maxx)+(x+7)] = RGB15(20,7,9) | BIT(15);

    buffer[((y+63)*maxx)+(x+8)] = RGB15(26,23,23) | BIT(15);

    buffer[((y+63)*maxx)+(x+9)] = RGB15(18,13,13) | BIT(15);

    buffer[((y+63)*maxx)+(x+10)] = RGB15(20,7,9) | BIT(15);

    buffer[((y+63)*maxx)+(x+11)] = RGB15(20,12,13) | BIT(15);

    buffer[((y+63)*maxx)+(x+12)] = RGB15(26,26,25) | BIT(15);

    buffer[((y+63)*maxx)+(x+13)] = RGB15(16,7,8) | BIT(15);

    buffer[((y+63)*maxx)+(x+14)] = RGB15(19,7,8) | BIT(15);

    buffer[((y+63)*maxx)+(x+15)] = RGB15(27,25,25) | BIT(15);

    buffer[((y+63)*maxx)+(x+16)] = RGB15(17,16,14) | BIT(15);

    buffer[((y+63)*maxx)+(x+17)] = RGB15(14,9,9) | BIT(15);

    buffer[((y+63)*maxx)+(x+18)] = RGB15(16,6,8) | BIT(15);

    buffer[((y+63)*maxx)+(x+19)] = RGB15(26,23,22) | BIT(15);

    buffer[((y+63)*maxx)+(x+20)] = RGB15(17,16,15) | BIT(15);

    buffer[((y+63)*maxx)+(x+21)] = RGB15(14,7,8) | BIT(15);

    buffer[((y+63)*maxx)+(x+22)] = RGB15(17,11,11) | BIT(15);

    buffer[((y+63)*maxx)+(x+23)] = RGB15(16,8,9) | BIT(15);

    buffer[((y+63)*maxx)+(x+24)] = RGB15(29,28,27) | BIT(15);

    buffer[((y+63)*maxx)+(x+25)] = RGB15(15,14,14) | BIT(15);

    buffer[((y+63)*maxx)+(x+26)] = RGB15(16,12,12) | BIT(15);

    buffer[((y+63)*maxx)+(x+27)] = RGB15(15,7,8) | BIT(15);

    buffer[((y+63)*maxx)+(x+28)] = RGB15(27,24,24) | BIT(15);

    buffer[((y+63)*maxx)+(x+29)] = RGB15(20,19,18) | BIT(15);

    buffer[((y+63)*maxx)+(x+30)] = RGB15(25,22,23) | BIT(15);

    buffer[((y+63)*maxx)+(x+31)] = RGB15(20,13,13) | BIT(15);

    buffer[((y+63)*maxx)+(x+32)] = RGB15(21,7,9) | BIT(15);

    buffer[((y+63)*maxx)+(x+33)] = RGB15(20,8,9) | BIT(15);

    buffer[((y+63)*maxx)+(x+34)] = RGB15(21,8,10) | BIT(15);

    buffer[((y+63)*maxx)+(x+35)] = RGB15(20,11,10) | BIT(15);

    buffer[((y+63)*maxx)+(x+36)] = RGB15(30,27,21) | BIT(15);

    buffer[((y+63)*maxx)+(x+37)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+63)*maxx)+(x+38)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+63)*maxx)+(x+39)] = RGB15(16,16,16) | BIT(15);

    buffer[((y+63)*maxx)+(x+40)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+64)*maxx)+(x+0)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+64)*maxx)+(x+1)] = RGB15(16,16,16) | BIT(15);

    buffer[((y+64)*maxx)+(x+2)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+64)*maxx)+(x+3)] = RGB15(27,24,18) | BIT(15);

    buffer[((y+64)*maxx)+(x+4)] = RGB15(23,17,13) | BIT(15);

    buffer[((y+64)*maxx)+(x+5)] = RGB15(20,7,9) | BIT(15);

    buffer[((y+64)*maxx)+(x+6)] = RGB15(21,7,10) | BIT(15);

    buffer[((y+64)*maxx)+(x+7)] = RGB15(20,8,9) | BIT(15);

    buffer[((y+64)*maxx)+(x+8)] = RGB15(24,20,20) | BIT(15);

    buffer[((y+64)*maxx)+(x+9)] = RGB15(19,16,16) | BIT(15);

    buffer[((y+64)*maxx)+(x+10)] = RGB15(20,8,9) | BIT(15);

    buffer[((y+64)*maxx)+(x+11)] = RGB15(23,18,18) | BIT(15);

    buffer[((y+64)*maxx)+(x+12)] = RGB15(25,26,25) | BIT(15);

    buffer[((y+64)*maxx)+(x+13)] = RGB15(19,13,14) | BIT(15);

    buffer[((y+64)*maxx)+(x+14)] = RGB15(20,6,9) | BIT(15);

    buffer[((y+64)*maxx)+(x+15)] = RGB15(26,25,24) | BIT(15);

    buffer[((y+64)*maxx)+(x+16)] = RGB15(22,21,21) | BIT(15);

    buffer[((y+64)*maxx)+(x+17)] = RGB15(19,16,16) | BIT(15);

    buffer[((y+64)*maxx)+(x+18)] = RGB15(14,7,8) | BIT(15);

    buffer[((y+64)*maxx)+(x+19)] = RGB15(28,28,28) | BIT(15);

    buffer[((y+64)*maxx)+(x+20)] = RGB15(15,9,10) | BIT(15);

    buffer[((y+64)*maxx)+(x+21)] = RGB15(19,8,10) | BIT(15);

    buffer[((y+64)*maxx)+(x+22)] = RGB15(19,10,12) | BIT(15);

    buffer[((y+64)*maxx)+(x+23)] = RGB15(19,9,10) | BIT(15);

    buffer[((y+64)*maxx)+(x+24)] = RGB15(30,29,28) | BIT(15);

    buffer[((y+64)*maxx)+(x+25)] = RGB15(20,19,18) | BIT(15);

    buffer[((y+64)*maxx)+(x+26)] = RGB15(19,15,15) | BIT(15);

    buffer[((y+64)*maxx)+(x+27)] = RGB15(17,7,9) | BIT(15);

    buffer[((y+64)*maxx)+(x+28)] = RGB15(28,26,26) | BIT(15);

    buffer[((y+64)*maxx)+(x+29)] = RGB15(16,14,14) | BIT(15);

    buffer[((y+64)*maxx)+(x+30)] = RGB15(26,24,24) | BIT(15);

    buffer[((y+64)*maxx)+(x+31)] = RGB15(18,15,15) | BIT(15);

    buffer[((y+64)*maxx)+(x+32)] = RGB15(19,6,8) | BIT(15);

    buffer[((y+64)*maxx)+(x+33)] = RGB15(21,7,9) | BIT(15);

    buffer[((y+64)*maxx)+(x+34)] = RGB15(21,8,10) | BIT(15);

    buffer[((y+64)*maxx)+(x+35)] = RGB15(22,14,11) | BIT(15);

    buffer[((y+64)*maxx)+(x+36)] = RGB15(26,24,19) | BIT(15);

    buffer[((y+64)*maxx)+(x+37)] = RGB15(29,26,20) | BIT(15);

    buffer[((y+64)*maxx)+(x+38)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+64)*maxx)+(x+39)] = RGB15(16,16,16) | BIT(15);

    buffer[((y+64)*maxx)+(x+40)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+65)*maxx)+(x+0)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+65)*maxx)+(x+1)] = RGB15(16,16,16) | BIT(15);

    buffer[((y+65)*maxx)+(x+2)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+65)*maxx)+(x+3)] = RGB15(26,21,17) | BIT(15);

    buffer[((y+65)*maxx)+(x+4)] = RGB15(26,20,16) | BIT(15);

    buffer[((y+65)*maxx)+(x+5)] = RGB15(21,9,10) | BIT(15);

    buffer[((y+65)*maxx)+(x+6)] = RGB15(21,7,9) | BIT(15);

    buffer[((y+65)*maxx)+(x+7)] = RGB15(21,7,9) | BIT(15);

    buffer[((y+65)*maxx)+(x+8)] = RGB15(23,17,17) | BIT(15);

    buffer[((y+65)*maxx)+(x+9)] = RGB15(21,20,20) | BIT(15);

    buffer[((y+65)*maxx)+(x+10)] = RGB15(18,7,9) | BIT(15);

    buffer[((y+65)*maxx)+(x+11)] = RGB15(23,22,22) | BIT(15);

    buffer[((y+65)*maxx)+(x+12)] = RGB15(21,19,20) | BIT(15);

    buffer[((y+65)*maxx)+(x+13)] = RGB15(25,24,24) | BIT(15);

    buffer[((y+65)*maxx)+(x+14)] = RGB15(17,7,8) | BIT(15);

    buffer[((y+65)*maxx)+(x+15)] = RGB15(25,24,23) | BIT(15);

    buffer[((y+65)*maxx)+(x+16)] = RGB15(18,15,15) | BIT(15);

    buffer[((y+65)*maxx)+(x+17)] = RGB15(15,6,8) | BIT(15);

    buffer[((y+65)*maxx)+(x+18)] = RGB15(17,7,9) | BIT(15);

    buffer[((y+65)*maxx)+(x+19)] = RGB15(27,26,26) | BIT(15);

    buffer[((y+65)*maxx)+(x+20)] = RGB15(18,12,13) | BIT(15);

    buffer[((y+65)*maxx)+(x+21)] = RGB15(21,12,14) | BIT(15);

    buffer[((y+65)*maxx)+(x+22)] = RGB15(25,24,24) | BIT(15);

    buffer[((y+65)*maxx)+(x+23)] = RGB15(15,8,9) | BIT(15);

    buffer[((y+65)*maxx)+(x+24)] = RGB15(28,28,28) | BIT(15);

    buffer[((y+65)*maxx)+(x+25)] = RGB15(13,8,9) | BIT(15);

    buffer[((y+65)*maxx)+(x+26)] = RGB15(16,6,8) | BIT(15);

    buffer[((y+65)*maxx)+(x+27)] = RGB15(18,8,9) | BIT(15);

    buffer[((y+65)*maxx)+(x+28)] = RGB15(28,28,28) | BIT(15);

    buffer[((y+65)*maxx)+(x+29)] = RGB15(24,24,24) | BIT(15);

    buffer[((y+65)*maxx)+(x+30)] = RGB15(21,20,20) | BIT(15);

    buffer[((y+65)*maxx)+(x+31)] = RGB15(14,5,7) | BIT(15);

    buffer[((y+65)*maxx)+(x+32)] = RGB15(19,6,8) | BIT(15);

    buffer[((y+65)*maxx)+(x+33)] = RGB15(20,6,9) | BIT(15);

    buffer[((y+65)*maxx)+(x+34)] = RGB15(20,7,9) | BIT(15);

    buffer[((y+65)*maxx)+(x+35)] = RGB15(22,14,12) | BIT(15);

    buffer[((y+65)*maxx)+(x+36)] = RGB15(22,18,14) | BIT(15);

    buffer[((y+65)*maxx)+(x+37)] = RGB15(28,25,20) | BIT(15);

    buffer[((y+65)*maxx)+(x+38)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+65)*maxx)+(x+39)] = RGB15(16,16,16) | BIT(15);

    buffer[((y+65)*maxx)+(x+40)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+66)*maxx)+(x+0)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+66)*maxx)+(x+1)] = RGB15(16,16,16) | BIT(15);

    buffer[((y+66)*maxx)+(x+2)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+66)*maxx)+(x+3)] = RGB15(24,18,15) | BIT(15);

    buffer[((y+66)*maxx)+(x+4)] = RGB15(23,15,12) | BIT(15);

    buffer[((y+66)*maxx)+(x+5)] = RGB15(22,12,11) | BIT(15);

    buffer[((y+66)*maxx)+(x+6)] = RGB15(20,7,9) | BIT(15);

    buffer[((y+66)*maxx)+(x+7)] = RGB15(21,7,9) | BIT(15);

    buffer[((y+66)*maxx)+(x+8)] = RGB15(20,14,14) | BIT(15);

    buffer[((y+66)*maxx)+(x+9)] = RGB15(21,21,21) | BIT(15);

    buffer[((y+66)*maxx)+(x+10)] = RGB15(17,8,10) | BIT(15);

    buffer[((y+66)*maxx)+(x+11)] = RGB15(19,19,18) | BIT(15);

    buffer[((y+66)*maxx)+(x+12)] = RGB15(13,6,8) | BIT(15);

    buffer[((y+66)*maxx)+(x+13)] = RGB15(26,24,23) | BIT(15);

    buffer[((y+66)*maxx)+(x+14)] = RGB15(17,10,11) | BIT(15);

    buffer[((y+66)*maxx)+(x+15)] = RGB15(20,18,18) | BIT(15);

    buffer[((y+66)*maxx)+(x+16)] = RGB15(20,19,19) | BIT(15);

    buffer[((y+66)*maxx)+(x+17)] = RGB15(20,17,17) | BIT(15);

    buffer[((y+66)*maxx)+(x+18)] = RGB15(13,7,8) | BIT(15);

    buffer[((y+66)*maxx)+(x+19)] = RGB15(20,10,12) | BIT(15);

    buffer[((y+66)*maxx)+(x+20)] = RGB15(21,19,18) | BIT(15);

    buffer[((y+66)*maxx)+(x+21)] = RGB15(21,18,18) | BIT(15);

    buffer[((y+66)*maxx)+(x+22)] = RGB15(19,16,16) | BIT(15);

    buffer[((y+66)*maxx)+(x+23)] = RGB15(16,9,10) | BIT(15);

    buffer[((y+66)*maxx)+(x+24)] = RGB15(24,23,23) | BIT(15);

    buffer[((y+66)*maxx)+(x+25)] = RGB15(18,18,18) | BIT(15);

    buffer[((y+66)*maxx)+(x+26)] = RGB15(18,14,14) | BIT(15);

    buffer[((y+66)*maxx)+(x+27)] = RGB15(18,8,9) | BIT(15);

    buffer[((y+66)*maxx)+(x+28)] = RGB15(29,28,27) | BIT(15);

    buffer[((y+66)*maxx)+(x+29)] = RGB15(13,11,11) | BIT(15);

    buffer[((y+66)*maxx)+(x+30)] = RGB15(29,27,27) | BIT(15);

    buffer[((y+66)*maxx)+(x+31)] = RGB15(18,10,11) | BIT(15);

    buffer[((y+66)*maxx)+(x+32)] = RGB15(20,6,8) | BIT(15);

    buffer[((y+66)*maxx)+(x+33)] = RGB15(20,5,8) | BIT(15);

    buffer[((y+66)*maxx)+(x+34)] = RGB15(19,7,8) | BIT(15);

    buffer[((y+66)*maxx)+(x+35)] = RGB15(20,13,11) | BIT(15);

    buffer[((y+66)*maxx)+(x+36)] = RGB15(20,13,11) | BIT(15);

    buffer[((y+66)*maxx)+(x+37)] = RGB15(28,25,19) | BIT(15);

    buffer[((y+66)*maxx)+(x+38)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+66)*maxx)+(x+39)] = RGB15(16,16,16) | BIT(15);

    buffer[((y+66)*maxx)+(x+40)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+67)*maxx)+(x+0)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+67)*maxx)+(x+1)] = RGB15(16,16,16) | BIT(15);

    buffer[((y+67)*maxx)+(x+2)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+67)*maxx)+(x+3)] = RGB15(24,19,14) | BIT(15);

    buffer[((y+67)*maxx)+(x+4)] = RGB15(20,13,9) | BIT(15);

    buffer[((y+67)*maxx)+(x+5)] = RGB15(21,13,12) | BIT(15);

    buffer[((y+67)*maxx)+(x+6)] = RGB15(21,7,9) | BIT(15);

    buffer[((y+67)*maxx)+(x+7)] = RGB15(19,7,9) | BIT(15);

    buffer[((y+67)*maxx)+(x+8)] = RGB15(21,16,16) | BIT(15);

    buffer[((y+67)*maxx)+(x+9)] = RGB15(12,9,9) | BIT(15);

    buffer[((y+67)*maxx)+(x+10)] = RGB15(17,7,9) | BIT(15);

    buffer[((y+67)*maxx)+(x+11)] = RGB15(14,6,7) | BIT(15);

    buffer[((y+67)*maxx)+(x+12)] = RGB15(19,6,9) | BIT(15);

    buffer[((y+67)*maxx)+(x+13)] = RGB15(15,5,7) | BIT(15);

    buffer[((y+67)*maxx)+(x+14)] = RGB15(14,5,7) | BIT(15);

    buffer[((y+67)*maxx)+(x+15)] = RGB15(15,6,7) | BIT(15);

    buffer[((y+67)*maxx)+(x+16)] = RGB15(15,6,8) | BIT(15);

    buffer[((y+67)*maxx)+(x+17)] = RGB15(16,7,9) | BIT(15);

    buffer[((y+67)*maxx)+(x+18)] = RGB15(18,7,9) | BIT(15);

    buffer[((y+67)*maxx)+(x+19)] = RGB15(19,8,9) | BIT(15);

    buffer[((y+67)*maxx)+(x+20)] = RGB15(18,8,10) | BIT(15);

    buffer[((y+67)*maxx)+(x+21)] = RGB15(16,7,9) | BIT(15);

    buffer[((y+67)*maxx)+(x+22)] = RGB15(18,7,9) | BIT(15);

    buffer[((y+67)*maxx)+(x+23)] = RGB15(17,7,8) | BIT(15);

    buffer[((y+67)*maxx)+(x+24)] = RGB15(15,4,7) | BIT(15);

    buffer[((y+67)*maxx)+(x+25)] = RGB15(14,5,7) | BIT(15);

    buffer[((y+67)*maxx)+(x+26)] = RGB15(15,5,7) | BIT(15);

    buffer[((y+67)*maxx)+(x+27)] = RGB15(17,6,8) | BIT(15);

    buffer[((y+67)*maxx)+(x+28)] = RGB15(15,7,8) | BIT(15);

    buffer[((y+67)*maxx)+(x+29)] = RGB15(16,7,8) | BIT(15);

    buffer[((y+67)*maxx)+(x+30)] = RGB15(18,10,11) | BIT(15);

    buffer[((y+67)*maxx)+(x+31)] = RGB15(15,8,9) | BIT(15);

    buffer[((y+67)*maxx)+(x+32)] = RGB15(19,6,8) | BIT(15);

    buffer[((y+67)*maxx)+(x+33)] = RGB15(20,6,9) | BIT(15);

    buffer[((y+67)*maxx)+(x+34)] = RGB15(20,10,9) | BIT(15);

    buffer[((y+67)*maxx)+(x+35)] = RGB15(18,12,8) | BIT(15);

    buffer[((y+67)*maxx)+(x+36)] = RGB15(19,13,9) | BIT(15);

    buffer[((y+67)*maxx)+(x+37)] = RGB15(29,27,20) | BIT(15);

    buffer[((y+67)*maxx)+(x+38)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+67)*maxx)+(x+39)] = RGB15(16,16,16) | BIT(15);

    buffer[((y+67)*maxx)+(x+40)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+68)*maxx)+(x+0)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+68)*maxx)+(x+1)] = RGB15(16,16,16) | BIT(15);

    buffer[((y+68)*maxx)+(x+2)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+68)*maxx)+(x+3)] = RGB15(28,24,18) | BIT(15);

    buffer[((y+68)*maxx)+(x+4)] = RGB15(20,14,9) | BIT(15);

    buffer[((y+68)*maxx)+(x+5)] = RGB15(21,14,11) | BIT(15);

    buffer[((y+68)*maxx)+(x+6)] = RGB15(19,8,9) | BIT(15);

    buffer[((y+68)*maxx)+(x+7)] = RGB15(19,9,11) | BIT(15);

    buffer[((y+68)*maxx)+(x+8)] = RGB15(18,12,12) | BIT(15);

    buffer[((y+68)*maxx)+(x+9)] = RGB15(19,15,14) | BIT(15);

    buffer[((y+68)*maxx)+(x+10)] = RGB15(21,16,15) | BIT(15);

    buffer[((y+68)*maxx)+(x+11)] = RGB15(21,17,16) | BIT(15);

    buffer[((y+68)*maxx)+(x+12)] = RGB15(21,18,16) | BIT(15);

    buffer[((y+68)*maxx)+(x+13)] = RGB15(22,19,17) | BIT(15);

    buffer[((y+68)*maxx)+(x+14)] = RGB15(23,20,18) | BIT(15);

    buffer[((y+68)*maxx)+(x+15)] = RGB15(24,21,18) | BIT(15);

    buffer[((y+68)*maxx)+(x+16)] = RGB15(24,22,18) | BIT(15);

    buffer[((y+68)*maxx)+(x+17)] = RGB15(24,22,18) | BIT(15);

    buffer[((y+68)*maxx)+(x+18)] = RGB15(24,22,17) | BIT(15);

    buffer[((y+68)*maxx)+(x+19)] = RGB15(25,23,18) | BIT(15);

    buffer[((y+68)*maxx)+(x+20)] = RGB15(25,23,18) | BIT(15);

    buffer[((y+68)*maxx)+(x+21)] = RGB15(26,24,19) | BIT(15);

    buffer[((y+68)*maxx)+(x+22)] = RGB15(26,24,20) | BIT(15);

    buffer[((y+68)*maxx)+(x+23)] = RGB15(25,23,19) | BIT(15);

    buffer[((y+68)*maxx)+(x+24)] = RGB15(25,23,19) | BIT(15);

    buffer[((y+68)*maxx)+(x+25)] = RGB15(23,21,18) | BIT(15);

    buffer[((y+68)*maxx)+(x+26)] = RGB15(23,20,17) | BIT(15);

    buffer[((y+68)*maxx)+(x+27)] = RGB15(22,19,17) | BIT(15);

    buffer[((y+68)*maxx)+(x+28)] = RGB15(22,18,17) | BIT(15);

    buffer[((y+68)*maxx)+(x+29)] = RGB15(22,17,16) | BIT(15);

    buffer[((y+68)*maxx)+(x+30)] = RGB15(21,16,15) | BIT(15);

    buffer[((y+68)*maxx)+(x+31)] = RGB15(21,14,14) | BIT(15);

    buffer[((y+68)*maxx)+(x+32)] = RGB15(20,11,12) | BIT(15);

    buffer[((y+68)*maxx)+(x+33)] = RGB15(19,7,8) | BIT(15);

    buffer[((y+68)*maxx)+(x+34)] = RGB15(22,14,11) | BIT(15);

    buffer[((y+68)*maxx)+(x+35)] = RGB15(20,14,10) | BIT(15);

    buffer[((y+68)*maxx)+(x+36)] = RGB15(25,20,15) | BIT(15);

    buffer[((y+68)*maxx)+(x+37)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+68)*maxx)+(x+38)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+68)*maxx)+(x+39)] = RGB15(16,16,16) | BIT(15);

    buffer[((y+68)*maxx)+(x+40)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+69)*maxx)+(x+0)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+69)*maxx)+(x+1)] = RGB15(16,16,16) | BIT(15);

    buffer[((y+69)*maxx)+(x+2)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+69)*maxx)+(x+3)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+69)*maxx)+(x+4)] = RGB15(21,17,12) | BIT(15);

    buffer[((y+69)*maxx)+(x+5)] = RGB15(20,12,10) | BIT(15);

    buffer[((y+69)*maxx)+(x+6)] = RGB15(21,17,14) | BIT(15);

    buffer[((y+69)*maxx)+(x+7)] = RGB15(22,19,16) | BIT(15);

    buffer[((y+69)*maxx)+(x+8)] = RGB15(20,16,13) | BIT(15);

    buffer[((y+69)*maxx)+(x+9)] = RGB15(22,17,14) | BIT(15);

    buffer[((y+69)*maxx)+(x+10)] = RGB15(16,13,10) | BIT(15);

    buffer[((y+69)*maxx)+(x+11)] = RGB15(21,19,15) | BIT(15);

    buffer[((y+69)*maxx)+(x+12)] = RGB15(27,24,18) | BIT(15);

    buffer[((y+69)*maxx)+(x+13)] = RGB15(27,24,16) | BIT(15);

    buffer[((y+69)*maxx)+(x+14)] = RGB15(28,25,18) | BIT(15);

    buffer[((y+69)*maxx)+(x+15)] = RGB15(30,27,20) | BIT(15);

    buffer[((y+69)*maxx)+(x+16)] = RGB15(29,27,19) | BIT(15);

    buffer[((y+69)*maxx)+(x+17)] = RGB15(28,26,18) | BIT(15);

    buffer[((y+69)*maxx)+(x+18)] = RGB15(27,25,17) | BIT(15);

    buffer[((y+69)*maxx)+(x+19)] = RGB15(28,26,18) | BIT(15);

    buffer[((y+69)*maxx)+(x+20)] = RGB15(30,27,20) | BIT(15);

    buffer[((y+69)*maxx)+(x+21)] = RGB15(29,26,19) | BIT(15);

    buffer[((y+69)*maxx)+(x+22)] = RGB15(27,25,18) | BIT(15);

    buffer[((y+69)*maxx)+(x+23)] = RGB15(28,26,19) | BIT(15);

    buffer[((y+69)*maxx)+(x+24)] = RGB15(29,27,20) | BIT(15);

    buffer[((y+69)*maxx)+(x+25)] = RGB15(28,26,19) | BIT(15);

    buffer[((y+69)*maxx)+(x+26)] = RGB15(28,25,18) | BIT(15);

    buffer[((y+69)*maxx)+(x+27)] = RGB15(29,26,19) | BIT(15);

    buffer[((y+69)*maxx)+(x+28)] = RGB15(24,22,16) | BIT(15);

    buffer[((y+69)*maxx)+(x+29)] = RGB15(17,16,13) | BIT(15);

    buffer[((y+69)*maxx)+(x+30)] = RGB15(18,16,12) | BIT(15);

    buffer[((y+69)*maxx)+(x+31)] = RGB15(20,16,13) | BIT(15);

    buffer[((y+69)*maxx)+(x+32)] = RGB15(21,17,14) | BIT(15);

    buffer[((y+69)*maxx)+(x+33)] = RGB15(23,19,16) | BIT(15);

    buffer[((y+69)*maxx)+(x+34)] = RGB15(21,15,12) | BIT(15);

    buffer[((y+69)*maxx)+(x+35)] = RGB15(21,16,11) | BIT(15);

    buffer[((y+69)*maxx)+(x+36)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+69)*maxx)+(x+37)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+69)*maxx)+(x+38)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+69)*maxx)+(x+39)] = RGB15(16,16,16) | BIT(15);

    buffer[((y+69)*maxx)+(x+40)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+70)*maxx)+(x+0)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+70)*maxx)+(x+1)] = RGB15(16,16,16) | BIT(15);

    buffer[((y+70)*maxx)+(x+2)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+70)*maxx)+(x+3)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+70)*maxx)+(x+4)] = RGB15(28,25,18) | BIT(15);

    buffer[((y+70)*maxx)+(x+5)] = RGB15(22,16,12) | BIT(15);

    buffer[((y+70)*maxx)+(x+6)] = RGB15(23,19,15) | BIT(15);

    buffer[((y+70)*maxx)+(x+7)] = RGB15(23,19,15) | BIT(15);

    buffer[((y+70)*maxx)+(x+8)] = RGB15(23,21,16) | BIT(15);

    buffer[((y+70)*maxx)+(x+9)] = RGB15(20,18,15) | BIT(15);

    buffer[((y+70)*maxx)+(x+10)] = RGB15(8,10,6) | BIT(15);

    buffer[((y+70)*maxx)+(x+11)] = RGB15(14,15,12) | BIT(15);

    buffer[((y+70)*maxx)+(x+12)] = RGB15(23,22,17) | BIT(15);

    buffer[((y+70)*maxx)+(x+13)] = RGB15(28,26,19) | BIT(15);

    buffer[((y+70)*maxx)+(x+14)] = RGB15(27,24,17) | BIT(15);

    buffer[((y+70)*maxx)+(x+15)] = RGB15(28,25,18) | BIT(15);

    buffer[((y+70)*maxx)+(x+16)] = RGB15(27,24,18) | BIT(15);

    buffer[((y+70)*maxx)+(x+17)] = RGB15(27,24,17) | BIT(15);

    buffer[((y+70)*maxx)+(x+18)] = RGB15(24,22,16) | BIT(15);

    buffer[((y+70)*maxx)+(x+19)] = RGB15(23,21,14) | BIT(15);

    buffer[((y+70)*maxx)+(x+20)] = RGB15(24,23,16) | BIT(15);

    buffer[((y+70)*maxx)+(x+21)] = RGB15(25,23,17) | BIT(15);

    buffer[((y+70)*maxx)+(x+22)] = RGB15(23,21,15) | BIT(15);

    buffer[((y+70)*maxx)+(x+23)] = RGB15(28,25,19) | BIT(15);

    buffer[((y+70)*maxx)+(x+24)] = RGB15(28,25,18) | BIT(15);

    buffer[((y+70)*maxx)+(x+25)] = RGB15(27,25,18) | BIT(15);

    buffer[((y+70)*maxx)+(x+26)] = RGB15(28,26,19) | BIT(15);

    buffer[((y+70)*maxx)+(x+27)] = RGB15(27,24,19) | BIT(15);

    buffer[((y+70)*maxx)+(x+28)] = RGB15(20,19,15) | BIT(15);

    buffer[((y+70)*maxx)+(x+29)] = RGB15(8,9,6) | BIT(15);

    buffer[((y+70)*maxx)+(x+30)] = RGB15(12,13,8) | BIT(15);

    buffer[((y+70)*maxx)+(x+31)] = RGB15(23,20,16) | BIT(15);

    buffer[((y+70)*maxx)+(x+32)] = RGB15(23,20,15) | BIT(15);

    buffer[((y+70)*maxx)+(x+33)] = RGB15(23,20,15) | BIT(15);

    buffer[((y+70)*maxx)+(x+34)] = RGB15(23,18,14) | BIT(15);

    buffer[((y+70)*maxx)+(x+35)] = RGB15(24,21,15) | BIT(15);

    buffer[((y+70)*maxx)+(x+36)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+70)*maxx)+(x+37)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+70)*maxx)+(x+38)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+70)*maxx)+(x+39)] = RGB15(16,16,16) | BIT(15);

    buffer[((y+70)*maxx)+(x+40)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+71)*maxx)+(x+0)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+71)*maxx)+(x+1)] = RGB15(16,16,16) | BIT(15);

    buffer[((y+71)*maxx)+(x+2)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+71)*maxx)+(x+3)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+71)*maxx)+(x+4)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+71)*maxx)+(x+5)] = RGB15(25,22,16) | BIT(15);

    buffer[((y+71)*maxx)+(x+6)] = RGB15(20,14,10) | BIT(15);

    buffer[((y+71)*maxx)+(x+7)] = RGB15(22,17,13) | BIT(15);

    buffer[((y+71)*maxx)+(x+8)] = RGB15(22,20,16) | BIT(15);

    buffer[((y+71)*maxx)+(x+9)] = RGB15(10,10,7) | BIT(15);

    buffer[((y+71)*maxx)+(x+10)] = RGB15(8,10,6) | BIT(15);

    buffer[((y+71)*maxx)+(x+11)] = RGB15(7,9,6) | BIT(15);

    buffer[((y+71)*maxx)+(x+12)] = RGB15(16,15,12) | BIT(15);

    buffer[((y+71)*maxx)+(x+13)] = RGB15(24,22,17) | BIT(15);

    buffer[((y+71)*maxx)+(x+14)] = RGB15(27,24,17) | BIT(15);

    buffer[((y+71)*maxx)+(x+15)] = RGB15(28,25,18) | BIT(15);

    buffer[((y+71)*maxx)+(x+16)] = RGB15(26,24,17) | BIT(15);

    buffer[((y+71)*maxx)+(x+17)] = RGB15(28,26,19) | BIT(15);

    buffer[((y+71)*maxx)+(x+18)] = RGB15(24,21,15) | BIT(15);

    buffer[((y+71)*maxx)+(x+19)] = RGB15(22,20,13) | BIT(15);

    buffer[((y+71)*maxx)+(x+20)] = RGB15(23,21,14) | BIT(15);

    buffer[((y+71)*maxx)+(x+21)] = RGB15(24,21,15) | BIT(15);

    buffer[((y+71)*maxx)+(x+22)] = RGB15(20,18,12) | BIT(15);

    buffer[((y+71)*maxx)+(x+23)] = RGB15(25,24,17) | BIT(15);

    buffer[((y+71)*maxx)+(x+24)] = RGB15(27,25,17) | BIT(15);

    buffer[((y+71)*maxx)+(x+25)] = RGB15(27,25,17) | BIT(15);

    buffer[((y+71)*maxx)+(x+26)] = RGB15(25,23,16) | BIT(15);

    buffer[((y+71)*maxx)+(x+27)] = RGB15(20,20,16) | BIT(15);

    buffer[((y+71)*maxx)+(x+28)] = RGB15(8,9,7) | BIT(15);

    buffer[((y+71)*maxx)+(x+29)] = RGB15(8,9,6) | BIT(15);

    buffer[((y+71)*maxx)+(x+30)] = RGB15(8,9,6) | BIT(15);

    buffer[((y+71)*maxx)+(x+31)] = RGB15(19,18,14) | BIT(15);

    buffer[((y+71)*maxx)+(x+32)] = RGB15(22,18,13) | BIT(15);

    buffer[((y+71)*maxx)+(x+33)] = RGB15(19,14,10) | BIT(15);

    buffer[((y+71)*maxx)+(x+34)] = RGB15(21,17,12) | BIT(15);

    buffer[((y+71)*maxx)+(x+35)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+71)*maxx)+(x+36)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+71)*maxx)+(x+37)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+71)*maxx)+(x+38)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+71)*maxx)+(x+39)] = RGB15(16,16,16) | BIT(15);

    buffer[((y+71)*maxx)+(x+40)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+72)*maxx)+(x+0)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+72)*maxx)+(x+1)] = RGB15(16,16,16) | BIT(15);

    buffer[((y+72)*maxx)+(x+2)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+72)*maxx)+(x+3)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+72)*maxx)+(x+4)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+72)*maxx)+(x+5)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+72)*maxx)+(x+6)] = RGB15(25,19,15) | BIT(15);

    buffer[((y+72)*maxx)+(x+7)] = RGB15(23,19,13) | BIT(15);

    buffer[((y+72)*maxx)+(x+8)] = RGB15(22,19,14) | BIT(15);

    buffer[((y+72)*maxx)+(x+9)] = RGB15(19,18,15) | BIT(15);

    buffer[((y+72)*maxx)+(x+10)] = RGB15(8,9,5) | BIT(15);

    buffer[((y+72)*maxx)+(x+11)] = RGB15(7,9,6) | BIT(15);

    buffer[((y+72)*maxx)+(x+12)] = RGB15(9,10,7) | BIT(15);

    buffer[((y+72)*maxx)+(x+13)] = RGB15(13,13,11) | BIT(15);

    buffer[((y+72)*maxx)+(x+14)] = RGB15(23,21,17) | BIT(15);

    buffer[((y+72)*maxx)+(x+15)] = RGB15(25,22,16) | BIT(15);

    buffer[((y+72)*maxx)+(x+16)] = RGB15(26,23,16) | BIT(15);

    buffer[((y+72)*maxx)+(x+17)] = RGB15(26,23,16) | BIT(15);

    buffer[((y+72)*maxx)+(x+18)] = RGB15(27,25,18) | BIT(15);

    buffer[((y+72)*maxx)+(x+19)] = RGB15(27,25,17) | BIT(15);

    buffer[((y+72)*maxx)+(x+20)] = RGB15(27,25,17) | BIT(15);

    buffer[((y+72)*maxx)+(x+21)] = RGB15(28,25,19) | BIT(15);

    buffer[((y+72)*maxx)+(x+22)] = RGB15(27,25,18) | BIT(15);

    buffer[((y+72)*maxx)+(x+23)] = RGB15(27,25,18) | BIT(15);

    buffer[((y+72)*maxx)+(x+24)] = RGB15(26,23,17) | BIT(15);

    buffer[((y+72)*maxx)+(x+25)] = RGB15(24,22,17) | BIT(15);

    buffer[((y+72)*maxx)+(x+26)] = RGB15(17,17,14) | BIT(15);

    buffer[((y+72)*maxx)+(x+27)] = RGB15(10,10,9) | BIT(15);

    buffer[((y+72)*maxx)+(x+28)] = RGB15(7,9,6) | BIT(15);

    buffer[((y+72)*maxx)+(x+29)] = RGB15(8,9,5) | BIT(15);

    buffer[((y+72)*maxx)+(x+30)] = RGB15(15,15,12) | BIT(15);

    buffer[((y+72)*maxx)+(x+31)] = RGB15(21,19,15) | BIT(15);

    buffer[((y+72)*maxx)+(x+32)] = RGB15(22,18,12) | BIT(15);

    buffer[((y+72)*maxx)+(x+33)] = RGB15(24,19,14) | BIT(15);

    buffer[((y+72)*maxx)+(x+34)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+72)*maxx)+(x+35)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+72)*maxx)+(x+36)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+72)*maxx)+(x+37)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+72)*maxx)+(x+38)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+72)*maxx)+(x+39)] = RGB15(16,16,16) | BIT(15);

    buffer[((y+72)*maxx)+(x+40)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+73)*maxx)+(x+0)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+73)*maxx)+(x+1)] = RGB15(16,16,16) | BIT(15);

    buffer[((y+73)*maxx)+(x+2)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+73)*maxx)+(x+3)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+73)*maxx)+(x+4)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+73)*maxx)+(x+5)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+73)*maxx)+(x+6)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+73)*maxx)+(x+7)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+73)*maxx)+(x+8)] = RGB15(22,19,12) | BIT(15);

    buffer[((y+73)*maxx)+(x+9)] = RGB15(20,17,13) | BIT(15);

    buffer[((y+73)*maxx)+(x+10)] = RGB15(17,17,14) | BIT(15);

    buffer[((y+73)*maxx)+(x+11)] = RGB15(8,8,6) | BIT(15);

    buffer[((y+73)*maxx)+(x+12)] = RGB15(20,21,19) | BIT(15);

    buffer[((y+73)*maxx)+(x+13)] = RGB15(17,17,15) | BIT(15);

    buffer[((y+73)*maxx)+(x+14)] = RGB15(9,9,7) | BIT(15);

    buffer[((y+73)*maxx)+(x+15)] = RGB15(17,16,13) | BIT(15);

    buffer[((y+73)*maxx)+(x+16)] = RGB15(22,21,16) | BIT(15);

    buffer[((y+73)*maxx)+(x+17)] = RGB15(23,21,16) | BIT(15);

    buffer[((y+73)*maxx)+(x+18)] = RGB15(24,21,15) | BIT(15);

    buffer[((y+73)*maxx)+(x+19)] = RGB15(25,22,16) | BIT(15);

    buffer[((y+73)*maxx)+(x+20)] = RGB15(25,22,16) | BIT(15);

    buffer[((y+73)*maxx)+(x+21)] = RGB15(24,22,16) | BIT(15);

    buffer[((y+73)*maxx)+(x+22)] = RGB15(24,21,16) | BIT(15);

    buffer[((y+73)*maxx)+(x+23)] = RGB15(23,22,17) | BIT(15);

    buffer[((y+73)*maxx)+(x+24)] = RGB15(18,18,15) | BIT(15);

    buffer[((y+73)*maxx)+(x+25)] = RGB15(10,11,9) | BIT(15);

    buffer[((y+73)*maxx)+(x+26)] = RGB15(10,12,9) | BIT(15);

    buffer[((y+73)*maxx)+(x+27)] = RGB15(24,25,24) | BIT(15);

    buffer[((y+73)*maxx)+(x+28)] = RGB15(7,8,6) | BIT(15);

    buffer[((y+73)*maxx)+(x+29)] = RGB15(14,14,11) | BIT(15);

    buffer[((y+73)*maxx)+(x+30)] = RGB15(21,19,15) | BIT(15);

    buffer[((y+73)*maxx)+(x+31)] = RGB15(21,18,12) | BIT(15);

    buffer[((y+73)*maxx)+(x+32)] = RGB15(28,26,19) | BIT(15);

    buffer[((y+73)*maxx)+(x+33)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+73)*maxx)+(x+34)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+73)*maxx)+(x+35)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+73)*maxx)+(x+36)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+73)*maxx)+(x+37)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+73)*maxx)+(x+38)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+73)*maxx)+(x+39)] = RGB15(16,16,16) | BIT(15);

    buffer[((y+73)*maxx)+(x+40)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+74)*maxx)+(x+0)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+74)*maxx)+(x+1)] = RGB15(16,16,16) | BIT(15);

    buffer[((y+74)*maxx)+(x+2)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+74)*maxx)+(x+3)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+74)*maxx)+(x+4)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+74)*maxx)+(x+5)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+74)*maxx)+(x+6)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+74)*maxx)+(x+7)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+74)*maxx)+(x+8)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+74)*maxx)+(x+9)] = RGB15(22,20,13) | BIT(15);

    buffer[((y+74)*maxx)+(x+10)] = RGB15(21,19,14) | BIT(15);

    buffer[((y+74)*maxx)+(x+11)] = RGB15(20,19,15) | BIT(15);

    buffer[((y+74)*maxx)+(x+12)] = RGB15(10,10,8) | BIT(15);

    buffer[((y+74)*maxx)+(x+13)] = RGB15(9,10,8) | BIT(15);

    buffer[((y+74)*maxx)+(x+14)] = RGB15(8,11,7) | BIT(15);

    buffer[((y+74)*maxx)+(x+15)] = RGB15(7,10,6) | BIT(15);

    buffer[((y+74)*maxx)+(x+16)] = RGB15(9,10,8) | BIT(15);

    buffer[((y+74)*maxx)+(x+17)] = RGB15(16,16,16) | BIT(15);

    buffer[((y+74)*maxx)+(x+18)] = RGB15(15,15,13) | BIT(15);

    buffer[((y+74)*maxx)+(x+19)] = RGB15(16,16,13) | BIT(15);

    buffer[((y+74)*maxx)+(x+20)] = RGB15(16,16,14) | BIT(15);

    buffer[((y+74)*maxx)+(x+21)] = RGB15(15,15,13) | BIT(15);

    buffer[((y+74)*maxx)+(x+22)] = RGB15(17,16,16) | BIT(15);

    buffer[((y+74)*maxx)+(x+23)] = RGB15(9,11,8) | BIT(15);

    buffer[((y+74)*maxx)+(x+24)] = RGB15(7,9,5) | BIT(15);

    buffer[((y+74)*maxx)+(x+25)] = RGB15(7,10,5) | BIT(15);

    buffer[((y+74)*maxx)+(x+26)] = RGB15(7,9,6) | BIT(15);

    buffer[((y+74)*maxx)+(x+27)] = RGB15(8,9,7) | BIT(15);

    buffer[((y+74)*maxx)+(x+28)] = RGB15(17,16,12) | BIT(15);

    buffer[((y+74)*maxx)+(x+29)] = RGB15(21,19,14) | BIT(15);

    buffer[((y+74)*maxx)+(x+30)] = RGB15(21,18,12) | BIT(15);

    buffer[((y+74)*maxx)+(x+31)] = RGB15(28,26,19) | BIT(15);

    buffer[((y+74)*maxx)+(x+32)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+74)*maxx)+(x+33)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+74)*maxx)+(x+34)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+74)*maxx)+(x+35)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+74)*maxx)+(x+36)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+74)*maxx)+(x+37)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+74)*maxx)+(x+38)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+74)*maxx)+(x+39)] = RGB15(16,16,16) | BIT(15);

    buffer[((y+74)*maxx)+(x+40)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+75)*maxx)+(x+0)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+75)*maxx)+(x+1)] = RGB15(16,16,16) | BIT(15);

    buffer[((y+75)*maxx)+(x+2)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+75)*maxx)+(x+3)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+75)*maxx)+(x+4)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+75)*maxx)+(x+5)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+75)*maxx)+(x+6)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+75)*maxx)+(x+7)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+75)*maxx)+(x+8)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+75)*maxx)+(x+9)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+75)*maxx)+(x+10)] = RGB15(24,20,14) | BIT(15);

    buffer[((y+75)*maxx)+(x+11)] = RGB15(21,19,13) | BIT(15);

    buffer[((y+75)*maxx)+(x+12)] = RGB15(22,20,16) | BIT(15);

    buffer[((y+75)*maxx)+(x+13)] = RGB15(16,16,13) | BIT(15);

    buffer[((y+75)*maxx)+(x+14)] = RGB15(9,10,7) | BIT(15);

    buffer[((y+75)*maxx)+(x+15)] = RGB15(10,11,8) | BIT(15);

    buffer[((y+75)*maxx)+(x+16)] = RGB15(16,17,15) | BIT(15);

    buffer[((y+75)*maxx)+(x+17)] = RGB15(20,21,20) | BIT(15);

    buffer[((y+75)*maxx)+(x+18)] = RGB15(13,14,12) | BIT(15);

    buffer[((y+75)*maxx)+(x+19)] = RGB15(11,12,10) | BIT(15);

    buffer[((y+75)*maxx)+(x+20)] = RGB15(20,21,20) | BIT(15);

    buffer[((y+75)*maxx)+(x+21)] = RGB15(9,10,8) | BIT(15);

    buffer[((y+75)*maxx)+(x+22)] = RGB15(20,20,20) | BIT(15);

    buffer[((y+75)*maxx)+(x+23)] = RGB15(16,17,16) | BIT(15);

    buffer[((y+75)*maxx)+(x+24)] = RGB15(8,9,6) | BIT(15);

    buffer[((y+75)*maxx)+(x+25)] = RGB15(8,9,5) | BIT(15);

    buffer[((y+75)*maxx)+(x+26)] = RGB15(15,15,11) | BIT(15);

    buffer[((y+75)*maxx)+(x+27)] = RGB15(24,22,20) | BIT(15);

    buffer[((y+75)*maxx)+(x+28)] = RGB15(26,23,17) | BIT(15);

    buffer[((y+75)*maxx)+(x+29)] = RGB15(26,22,16) | BIT(15);

    buffer[((y+75)*maxx)+(x+30)] = RGB15(29,27,20) | BIT(15);

    buffer[((y+75)*maxx)+(x+31)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+75)*maxx)+(x+32)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+75)*maxx)+(x+33)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+75)*maxx)+(x+34)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+75)*maxx)+(x+35)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+75)*maxx)+(x+36)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+75)*maxx)+(x+37)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+75)*maxx)+(x+38)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+75)*maxx)+(x+39)] = RGB15(16,16,16) | BIT(15);

    buffer[((y+75)*maxx)+(x+40)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+76)*maxx)+(x+0)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+76)*maxx)+(x+1)] = RGB15(16,16,16) | BIT(15);

    buffer[((y+76)*maxx)+(x+2)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+76)*maxx)+(x+3)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+76)*maxx)+(x+4)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+76)*maxx)+(x+5)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+76)*maxx)+(x+6)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+76)*maxx)+(x+7)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+76)*maxx)+(x+8)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+76)*maxx)+(x+9)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+76)*maxx)+(x+10)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+76)*maxx)+(x+11)] = RGB15(26,23,16) | BIT(15);

    buffer[((y+76)*maxx)+(x+12)] = RGB15(21,18,12) | BIT(15);

    buffer[((y+76)*maxx)+(x+13)] = RGB15(22,19,13) | BIT(15);

    buffer[((y+76)*maxx)+(x+14)] = RGB15(22,21,17) | BIT(15);

    buffer[((y+76)*maxx)+(x+15)] = RGB15(18,17,14) | BIT(15);

    buffer[((y+76)*maxx)+(x+16)] = RGB15(15,15,13) | BIT(15);

    buffer[((y+76)*maxx)+(x+17)] = RGB15(13,13,12) | BIT(15);

    buffer[((y+76)*maxx)+(x+18)] = RGB15(11,12,10) | BIT(15);

    buffer[((y+76)*maxx)+(x+19)] = RGB15(9,10,8) | BIT(15);

    buffer[((y+76)*maxx)+(x+20)] = RGB15(15,16,14) | BIT(15);

    buffer[((y+76)*maxx)+(x+21)] = RGB15(8,9,7) | BIT(15);

    buffer[((y+76)*maxx)+(x+22)] = RGB15(12,12,11) | BIT(15);

    buffer[((y+76)*maxx)+(x+23)] = RGB15(13,13,11) | BIT(15);

    buffer[((y+76)*maxx)+(x+24)] = RGB15(16,16,13) | BIT(15);

    buffer[((y+76)*maxx)+(x+25)] = RGB15(22,20,17) | BIT(15);

    buffer[((y+76)*maxx)+(x+26)] = RGB15(24,21,16) | BIT(15);

    buffer[((y+76)*maxx)+(x+27)] = RGB15(25,21,15) | BIT(15);

    buffer[((y+76)*maxx)+(x+28)] = RGB15(27,24,17) | BIT(15);

    buffer[((y+76)*maxx)+(x+29)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+76)*maxx)+(x+30)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+76)*maxx)+(x+31)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+76)*maxx)+(x+32)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+76)*maxx)+(x+33)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+76)*maxx)+(x+34)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+76)*maxx)+(x+35)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+76)*maxx)+(x+36)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+76)*maxx)+(x+37)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+76)*maxx)+(x+38)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+76)*maxx)+(x+39)] = RGB15(16,16,16) | BIT(15);

    buffer[((y+76)*maxx)+(x+40)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+77)*maxx)+(x+0)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+77)*maxx)+(x+1)] = RGB15(16,16,16) | BIT(15);

    buffer[((y+77)*maxx)+(x+2)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+77)*maxx)+(x+3)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+77)*maxx)+(x+4)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+77)*maxx)+(x+5)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+77)*maxx)+(x+6)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+77)*maxx)+(x+7)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+77)*maxx)+(x+8)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+77)*maxx)+(x+9)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+77)*maxx)+(x+10)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+77)*maxx)+(x+11)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+77)*maxx)+(x+12)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+77)*maxx)+(x+13)] = RGB15(26,23,16) | BIT(15);

    buffer[((y+77)*maxx)+(x+14)] = RGB15(23,20,13) | BIT(15);

    buffer[((y+77)*maxx)+(x+15)] = RGB15(22,19,13) | BIT(15);

    buffer[((y+77)*maxx)+(x+16)] = RGB15(22,19,15) | BIT(15);

    buffer[((y+77)*maxx)+(x+17)] = RGB15(22,20,17) | BIT(15);

    buffer[((y+77)*maxx)+(x+18)] = RGB15(21,19,16) | BIT(15);

    buffer[((y+77)*maxx)+(x+19)] = RGB15(19,17,15) | BIT(15);

    buffer[((y+77)*maxx)+(x+20)] = RGB15(19,17,14) | BIT(15);

    buffer[((y+77)*maxx)+(x+21)] = RGB15(20,19,15) | BIT(15);

    buffer[((y+77)*maxx)+(x+22)] = RGB15(22,20,16) | BIT(15);

    buffer[((y+77)*maxx)+(x+23)] = RGB15(22,20,15) | BIT(15);

    buffer[((y+77)*maxx)+(x+24)] = RGB15(22,19,13) | BIT(15);

    buffer[((y+77)*maxx)+(x+25)] = RGB15(23,19,13) | BIT(15);

    buffer[((y+77)*maxx)+(x+26)] = RGB15(25,22,15) | BIT(15);

    buffer[((y+77)*maxx)+(x+27)] = RGB15(29,27,19) | BIT(15);

    buffer[((y+77)*maxx)+(x+28)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+77)*maxx)+(x+29)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+77)*maxx)+(x+30)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+77)*maxx)+(x+31)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+77)*maxx)+(x+32)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+77)*maxx)+(x+33)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+77)*maxx)+(x+34)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+77)*maxx)+(x+35)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+77)*maxx)+(x+36)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+77)*maxx)+(x+37)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+77)*maxx)+(x+38)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+77)*maxx)+(x+39)] = RGB15(16,16,16) | BIT(15);

    buffer[((y+77)*maxx)+(x+40)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+78)*maxx)+(x+0)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+78)*maxx)+(x+1)] = RGB15(16,16,16) | BIT(15);

    buffer[((y+78)*maxx)+(x+2)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+78)*maxx)+(x+3)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+78)*maxx)+(x+4)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+78)*maxx)+(x+5)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+78)*maxx)+(x+6)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+78)*maxx)+(x+7)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+78)*maxx)+(x+8)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+78)*maxx)+(x+9)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+78)*maxx)+(x+10)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+78)*maxx)+(x+11)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+78)*maxx)+(x+12)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+78)*maxx)+(x+13)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+78)*maxx)+(x+14)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+78)*maxx)+(x+15)] = RGB15(28,25,17) | BIT(15);

    buffer[((y+78)*maxx)+(x+16)] = RGB15(25,22,15) | BIT(15);

    buffer[((y+78)*maxx)+(x+17)] = RGB15(23,19,13) | BIT(15);

    buffer[((y+78)*maxx)+(x+18)] = RGB15(21,18,11) | BIT(15);

    buffer[((y+78)*maxx)+(x+19)] = RGB15(20,17,11) | BIT(15);

    buffer[((y+78)*maxx)+(x+20)] = RGB15(20,17,11) | BIT(15);

    buffer[((y+78)*maxx)+(x+21)] = RGB15(21,17,10) | BIT(15);

    buffer[((y+78)*maxx)+(x+22)] = RGB15(23,19,13) | BIT(15);

    buffer[((y+78)*maxx)+(x+23)] = RGB15(25,21,15) | BIT(15);

    buffer[((y+78)*maxx)+(x+24)] = RGB15(27,24,17) | BIT(15);

    buffer[((y+78)*maxx)+(x+25)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+78)*maxx)+(x+26)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+78)*maxx)+(x+27)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+78)*maxx)+(x+28)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+78)*maxx)+(x+29)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+78)*maxx)+(x+30)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+78)*maxx)+(x+31)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+78)*maxx)+(x+32)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+78)*maxx)+(x+33)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+78)*maxx)+(x+34)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+78)*maxx)+(x+35)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+78)*maxx)+(x+36)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+78)*maxx)+(x+37)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+78)*maxx)+(x+38)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+78)*maxx)+(x+39)] = RGB15(16,16,16) | BIT(15);

    buffer[((y+78)*maxx)+(x+40)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+79)*maxx)+(x+0)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+79)*maxx)+(x+1)] = RGB15(16,16,16) | BIT(15);

    buffer[((y+79)*maxx)+(x+2)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+79)*maxx)+(x+3)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+79)*maxx)+(x+4)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+79)*maxx)+(x+5)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+79)*maxx)+(x+6)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+79)*maxx)+(x+7)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+79)*maxx)+(x+8)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+79)*maxx)+(x+9)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+79)*maxx)+(x+10)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+79)*maxx)+(x+11)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+79)*maxx)+(x+12)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+79)*maxx)+(x+13)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+79)*maxx)+(x+14)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+79)*maxx)+(x+15)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+79)*maxx)+(x+16)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+79)*maxx)+(x+17)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+79)*maxx)+(x+18)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+79)*maxx)+(x+19)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+79)*maxx)+(x+20)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+79)*maxx)+(x+21)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+79)*maxx)+(x+22)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+79)*maxx)+(x+23)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+79)*maxx)+(x+24)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+79)*maxx)+(x+25)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+79)*maxx)+(x+26)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+79)*maxx)+(x+27)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+79)*maxx)+(x+28)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+79)*maxx)+(x+29)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+79)*maxx)+(x+30)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+79)*maxx)+(x+31)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+79)*maxx)+(x+32)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+79)*maxx)+(x+33)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+79)*maxx)+(x+34)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+79)*maxx)+(x+35)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+79)*maxx)+(x+36)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+79)*maxx)+(x+37)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+79)*maxx)+(x+38)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+79)*maxx)+(x+39)] = RGB15(16,16,16) | BIT(15);

    buffer[((y+79)*maxx)+(x+40)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+80)*maxx)+(x+0)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+80)*maxx)+(x+1)] = RGB15(16,16,16) | BIT(15);

    buffer[((y+80)*maxx)+(x+2)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+80)*maxx)+(x+3)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+80)*maxx)+(x+4)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+80)*maxx)+(x+5)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+80)*maxx)+(x+6)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+80)*maxx)+(x+7)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+80)*maxx)+(x+8)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+80)*maxx)+(x+9)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+80)*maxx)+(x+10)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+80)*maxx)+(x+11)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+80)*maxx)+(x+12)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+80)*maxx)+(x+13)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+80)*maxx)+(x+14)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+80)*maxx)+(x+15)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+80)*maxx)+(x+16)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+80)*maxx)+(x+17)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+80)*maxx)+(x+18)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+80)*maxx)+(x+19)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+80)*maxx)+(x+20)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+80)*maxx)+(x+21)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+80)*maxx)+(x+22)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+80)*maxx)+(x+23)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+80)*maxx)+(x+24)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+80)*maxx)+(x+25)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+80)*maxx)+(x+26)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+80)*maxx)+(x+27)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+80)*maxx)+(x+28)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+80)*maxx)+(x+29)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+80)*maxx)+(x+30)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+80)*maxx)+(x+31)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+80)*maxx)+(x+32)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+80)*maxx)+(x+33)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+80)*maxx)+(x+34)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+80)*maxx)+(x+35)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+80)*maxx)+(x+36)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+80)*maxx)+(x+37)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+80)*maxx)+(x+38)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+80)*maxx)+(x+39)] = RGB15(16,16,16) | BIT(15);

    buffer[((y+80)*maxx)+(x+40)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+81)*maxx)+(x+0)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+81)*maxx)+(x+1)] = RGB15(16,16,16) | BIT(15);

    buffer[((y+81)*maxx)+(x+2)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+81)*maxx)+(x+3)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+81)*maxx)+(x+4)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+81)*maxx)+(x+5)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+81)*maxx)+(x+6)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+81)*maxx)+(x+7)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+81)*maxx)+(x+8)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+81)*maxx)+(x+9)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+81)*maxx)+(x+10)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+81)*maxx)+(x+11)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+81)*maxx)+(x+12)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+81)*maxx)+(x+13)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+81)*maxx)+(x+14)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+81)*maxx)+(x+15)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+81)*maxx)+(x+16)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+81)*maxx)+(x+17)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+81)*maxx)+(x+18)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+81)*maxx)+(x+19)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+81)*maxx)+(x+20)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+81)*maxx)+(x+21)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+81)*maxx)+(x+22)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+81)*maxx)+(x+23)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+81)*maxx)+(x+24)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+81)*maxx)+(x+25)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+81)*maxx)+(x+26)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+81)*maxx)+(x+27)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+81)*maxx)+(x+28)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+81)*maxx)+(x+29)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+81)*maxx)+(x+30)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+81)*maxx)+(x+31)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+81)*maxx)+(x+32)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+81)*maxx)+(x+33)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+81)*maxx)+(x+34)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+81)*maxx)+(x+35)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+81)*maxx)+(x+36)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+81)*maxx)+(x+37)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+81)*maxx)+(x+38)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+81)*maxx)+(x+39)] = RGB15(16,16,16) | BIT(15);

    buffer[((y+81)*maxx)+(x+40)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+82)*maxx)+(x+0)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+82)*maxx)+(x+1)] = RGB15(16,16,16) | BIT(15);

    buffer[((y+82)*maxx)+(x+2)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+82)*maxx)+(x+3)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+82)*maxx)+(x+4)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+82)*maxx)+(x+5)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+82)*maxx)+(x+6)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+82)*maxx)+(x+7)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+82)*maxx)+(x+8)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+82)*maxx)+(x+9)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+82)*maxx)+(x+10)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+82)*maxx)+(x+11)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+82)*maxx)+(x+12)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+82)*maxx)+(x+13)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+82)*maxx)+(x+14)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+82)*maxx)+(x+15)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+82)*maxx)+(x+16)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+82)*maxx)+(x+17)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+82)*maxx)+(x+18)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+82)*maxx)+(x+19)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+82)*maxx)+(x+20)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+82)*maxx)+(x+21)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+82)*maxx)+(x+22)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+82)*maxx)+(x+23)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+82)*maxx)+(x+24)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+82)*maxx)+(x+25)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+82)*maxx)+(x+26)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+82)*maxx)+(x+27)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+82)*maxx)+(x+28)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+82)*maxx)+(x+29)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+82)*maxx)+(x+30)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+82)*maxx)+(x+31)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+82)*maxx)+(x+32)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+82)*maxx)+(x+33)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+82)*maxx)+(x+34)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+82)*maxx)+(x+35)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+82)*maxx)+(x+36)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+82)*maxx)+(x+37)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+82)*maxx)+(x+38)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+82)*maxx)+(x+39)] = RGB15(16,16,16) | BIT(15);

    buffer[((y+82)*maxx)+(x+40)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+83)*maxx)+(x+0)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+83)*maxx)+(x+1)] = RGB15(16,16,16) | BIT(15);

    buffer[((y+83)*maxx)+(x+2)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+83)*maxx)+(x+3)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+83)*maxx)+(x+4)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+83)*maxx)+(x+5)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+83)*maxx)+(x+6)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+83)*maxx)+(x+7)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+83)*maxx)+(x+8)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+83)*maxx)+(x+9)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+83)*maxx)+(x+10)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+83)*maxx)+(x+11)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+83)*maxx)+(x+12)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+83)*maxx)+(x+13)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+83)*maxx)+(x+14)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+83)*maxx)+(x+15)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+83)*maxx)+(x+16)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+83)*maxx)+(x+17)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+83)*maxx)+(x+18)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+83)*maxx)+(x+19)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+83)*maxx)+(x+20)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+83)*maxx)+(x+21)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+83)*maxx)+(x+22)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+83)*maxx)+(x+23)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+83)*maxx)+(x+24)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+83)*maxx)+(x+25)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+83)*maxx)+(x+26)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+83)*maxx)+(x+27)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+83)*maxx)+(x+28)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+83)*maxx)+(x+29)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+83)*maxx)+(x+30)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+83)*maxx)+(x+31)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+83)*maxx)+(x+32)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+83)*maxx)+(x+33)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+83)*maxx)+(x+34)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+83)*maxx)+(x+35)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+83)*maxx)+(x+36)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+83)*maxx)+(x+37)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+83)*maxx)+(x+38)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+83)*maxx)+(x+39)] = RGB15(16,16,16) | BIT(15);

    buffer[((y+83)*maxx)+(x+40)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+84)*maxx)+(x+0)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+84)*maxx)+(x+1)] = RGB15(16,16,16) | BIT(15);

    buffer[((y+84)*maxx)+(x+2)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+84)*maxx)+(x+3)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+84)*maxx)+(x+4)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+84)*maxx)+(x+5)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+84)*maxx)+(x+6)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+84)*maxx)+(x+7)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+84)*maxx)+(x+8)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+84)*maxx)+(x+9)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+84)*maxx)+(x+10)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+84)*maxx)+(x+11)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+84)*maxx)+(x+12)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+84)*maxx)+(x+13)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+84)*maxx)+(x+14)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+84)*maxx)+(x+15)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+84)*maxx)+(x+16)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+84)*maxx)+(x+17)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+84)*maxx)+(x+18)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+84)*maxx)+(x+19)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+84)*maxx)+(x+20)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+84)*maxx)+(x+21)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+84)*maxx)+(x+22)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+84)*maxx)+(x+23)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+84)*maxx)+(x+24)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+84)*maxx)+(x+25)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+84)*maxx)+(x+26)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+84)*maxx)+(x+27)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+84)*maxx)+(x+28)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+84)*maxx)+(x+29)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+84)*maxx)+(x+30)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+84)*maxx)+(x+31)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+84)*maxx)+(x+32)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+84)*maxx)+(x+33)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+84)*maxx)+(x+34)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+84)*maxx)+(x+35)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+84)*maxx)+(x+36)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+84)*maxx)+(x+37)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+84)*maxx)+(x+38)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+84)*maxx)+(x+39)] = RGB15(16,16,16) | BIT(15);

    buffer[((y+84)*maxx)+(x+40)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+85)*maxx)+(x+0)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+85)*maxx)+(x+1)] = RGB15(16,16,16) | BIT(15);

    buffer[((y+85)*maxx)+(x+2)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+85)*maxx)+(x+3)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+85)*maxx)+(x+4)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+85)*maxx)+(x+5)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+85)*maxx)+(x+6)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+85)*maxx)+(x+7)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+85)*maxx)+(x+8)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+85)*maxx)+(x+9)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+85)*maxx)+(x+10)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+85)*maxx)+(x+11)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+85)*maxx)+(x+12)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+85)*maxx)+(x+13)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+85)*maxx)+(x+14)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+85)*maxx)+(x+15)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+85)*maxx)+(x+16)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+85)*maxx)+(x+17)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+85)*maxx)+(x+18)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+85)*maxx)+(x+19)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+85)*maxx)+(x+20)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+85)*maxx)+(x+21)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+85)*maxx)+(x+22)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+85)*maxx)+(x+23)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+85)*maxx)+(x+24)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+85)*maxx)+(x+25)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+85)*maxx)+(x+26)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+85)*maxx)+(x+27)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+85)*maxx)+(x+28)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+85)*maxx)+(x+29)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+85)*maxx)+(x+30)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+85)*maxx)+(x+31)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+85)*maxx)+(x+32)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+85)*maxx)+(x+33)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+85)*maxx)+(x+34)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+85)*maxx)+(x+35)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+85)*maxx)+(x+36)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+85)*maxx)+(x+37)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+85)*maxx)+(x+38)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+85)*maxx)+(x+39)] = RGB15(16,16,16) | BIT(15);

    buffer[((y+85)*maxx)+(x+40)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+86)*maxx)+(x+0)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+86)*maxx)+(x+1)] = RGB15(16,16,16) | BIT(15);

    buffer[((y+86)*maxx)+(x+2)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+86)*maxx)+(x+3)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+86)*maxx)+(x+4)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+86)*maxx)+(x+5)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+86)*maxx)+(x+6)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+86)*maxx)+(x+7)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+86)*maxx)+(x+8)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+86)*maxx)+(x+9)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+86)*maxx)+(x+10)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+86)*maxx)+(x+11)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+86)*maxx)+(x+12)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+86)*maxx)+(x+13)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+86)*maxx)+(x+14)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+86)*maxx)+(x+15)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+86)*maxx)+(x+16)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+86)*maxx)+(x+17)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+86)*maxx)+(x+18)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+86)*maxx)+(x+19)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+86)*maxx)+(x+20)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+86)*maxx)+(x+21)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+86)*maxx)+(x+22)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+86)*maxx)+(x+23)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+86)*maxx)+(x+24)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+86)*maxx)+(x+25)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+86)*maxx)+(x+26)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+86)*maxx)+(x+27)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+86)*maxx)+(x+28)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+86)*maxx)+(x+29)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+86)*maxx)+(x+30)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+86)*maxx)+(x+31)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+86)*maxx)+(x+32)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+86)*maxx)+(x+33)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+86)*maxx)+(x+34)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+86)*maxx)+(x+35)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+86)*maxx)+(x+36)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+86)*maxx)+(x+37)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+86)*maxx)+(x+38)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+86)*maxx)+(x+39)] = RGB15(16,16,16) | BIT(15);

    buffer[((y+86)*maxx)+(x+40)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+87)*maxx)+(x+0)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+87)*maxx)+(x+1)] = RGB15(16,16,16) | BIT(15);

    buffer[((y+87)*maxx)+(x+2)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+87)*maxx)+(x+3)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+87)*maxx)+(x+4)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+87)*maxx)+(x+5)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+87)*maxx)+(x+6)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+87)*maxx)+(x+7)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+87)*maxx)+(x+8)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+87)*maxx)+(x+9)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+87)*maxx)+(x+10)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+87)*maxx)+(x+11)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+87)*maxx)+(x+12)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+87)*maxx)+(x+13)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+87)*maxx)+(x+14)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+87)*maxx)+(x+15)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+87)*maxx)+(x+16)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+87)*maxx)+(x+17)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+87)*maxx)+(x+18)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+87)*maxx)+(x+19)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+87)*maxx)+(x+20)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+87)*maxx)+(x+21)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+87)*maxx)+(x+22)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+87)*maxx)+(x+23)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+87)*maxx)+(x+24)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+87)*maxx)+(x+25)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+87)*maxx)+(x+26)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+87)*maxx)+(x+27)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+87)*maxx)+(x+28)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+87)*maxx)+(x+29)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+87)*maxx)+(x+30)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+87)*maxx)+(x+31)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+87)*maxx)+(x+32)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+87)*maxx)+(x+33)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+87)*maxx)+(x+34)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+87)*maxx)+(x+35)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+87)*maxx)+(x+36)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+87)*maxx)+(x+37)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+87)*maxx)+(x+38)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+87)*maxx)+(x+39)] = RGB15(16,16,16) | BIT(15);

    buffer[((y+87)*maxx)+(x+40)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+88)*maxx)+(x+0)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+88)*maxx)+(x+1)] = RGB15(16,16,16) | BIT(15);

    buffer[((y+88)*maxx)+(x+2)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+88)*maxx)+(x+3)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+88)*maxx)+(x+4)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+88)*maxx)+(x+5)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+88)*maxx)+(x+6)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+88)*maxx)+(x+7)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+88)*maxx)+(x+8)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+88)*maxx)+(x+9)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+88)*maxx)+(x+10)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+88)*maxx)+(x+11)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+88)*maxx)+(x+12)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+88)*maxx)+(x+13)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+88)*maxx)+(x+14)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+88)*maxx)+(x+15)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+88)*maxx)+(x+16)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+88)*maxx)+(x+17)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+88)*maxx)+(x+18)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+88)*maxx)+(x+19)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+88)*maxx)+(x+20)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+88)*maxx)+(x+21)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+88)*maxx)+(x+22)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+88)*maxx)+(x+23)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+88)*maxx)+(x+24)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+88)*maxx)+(x+25)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+88)*maxx)+(x+26)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+88)*maxx)+(x+27)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+88)*maxx)+(x+28)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+88)*maxx)+(x+29)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+88)*maxx)+(x+30)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+88)*maxx)+(x+31)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+88)*maxx)+(x+32)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+88)*maxx)+(x+33)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+88)*maxx)+(x+34)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+88)*maxx)+(x+35)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+88)*maxx)+(x+36)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+88)*maxx)+(x+37)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+88)*maxx)+(x+38)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+88)*maxx)+(x+39)] = RGB15(16,16,16) | BIT(15);

    buffer[((y+88)*maxx)+(x+40)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+89)*maxx)+(x+0)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+89)*maxx)+(x+1)] = RGB15(16,16,16) | BIT(15);

    buffer[((y+89)*maxx)+(x+2)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+89)*maxx)+(x+3)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+89)*maxx)+(x+4)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+89)*maxx)+(x+5)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+89)*maxx)+(x+6)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+89)*maxx)+(x+7)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+89)*maxx)+(x+8)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+89)*maxx)+(x+9)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+89)*maxx)+(x+10)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+89)*maxx)+(x+11)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+89)*maxx)+(x+12)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+89)*maxx)+(x+13)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+89)*maxx)+(x+14)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+89)*maxx)+(x+15)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+89)*maxx)+(x+16)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+89)*maxx)+(x+17)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+89)*maxx)+(x+18)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+89)*maxx)+(x+19)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+89)*maxx)+(x+20)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+89)*maxx)+(x+21)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+89)*maxx)+(x+22)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+89)*maxx)+(x+23)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+89)*maxx)+(x+24)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+89)*maxx)+(x+25)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+89)*maxx)+(x+26)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+89)*maxx)+(x+27)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+89)*maxx)+(x+28)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+89)*maxx)+(x+29)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+89)*maxx)+(x+30)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+89)*maxx)+(x+31)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+89)*maxx)+(x+32)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+89)*maxx)+(x+33)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+89)*maxx)+(x+34)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+89)*maxx)+(x+35)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+89)*maxx)+(x+36)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+89)*maxx)+(x+37)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+89)*maxx)+(x+38)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+89)*maxx)+(x+39)] = RGB15(16,16,16) | BIT(15);

    buffer[((y+89)*maxx)+(x+40)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+90)*maxx)+(x+0)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+90)*maxx)+(x+1)] = RGB15(16,16,16) | BIT(15);

    buffer[((y+90)*maxx)+(x+2)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+90)*maxx)+(x+3)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+90)*maxx)+(x+4)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+90)*maxx)+(x+5)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+90)*maxx)+(x+6)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+90)*maxx)+(x+7)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+90)*maxx)+(x+8)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+90)*maxx)+(x+9)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+90)*maxx)+(x+10)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+90)*maxx)+(x+11)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+90)*maxx)+(x+12)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+90)*maxx)+(x+13)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+90)*maxx)+(x+14)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+90)*maxx)+(x+15)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+90)*maxx)+(x+16)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+90)*maxx)+(x+17)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+90)*maxx)+(x+18)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+90)*maxx)+(x+19)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+90)*maxx)+(x+20)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+90)*maxx)+(x+21)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+90)*maxx)+(x+22)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+90)*maxx)+(x+23)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+90)*maxx)+(x+24)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+90)*maxx)+(x+25)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+90)*maxx)+(x+26)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+90)*maxx)+(x+27)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+90)*maxx)+(x+28)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+90)*maxx)+(x+29)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+90)*maxx)+(x+30)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+90)*maxx)+(x+31)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+90)*maxx)+(x+32)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+90)*maxx)+(x+33)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+90)*maxx)+(x+34)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+90)*maxx)+(x+35)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+90)*maxx)+(x+36)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+90)*maxx)+(x+37)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+90)*maxx)+(x+38)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+90)*maxx)+(x+39)] = RGB15(16,16,16) | BIT(15);

    buffer[((y+90)*maxx)+(x+40)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+91)*maxx)+(x+0)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+91)*maxx)+(x+1)] = RGB15(16,16,16) | BIT(15);

    buffer[((y+91)*maxx)+(x+2)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+91)*maxx)+(x+3)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+91)*maxx)+(x+4)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+91)*maxx)+(x+5)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+91)*maxx)+(x+6)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+91)*maxx)+(x+7)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+91)*maxx)+(x+8)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+91)*maxx)+(x+9)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+91)*maxx)+(x+10)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+91)*maxx)+(x+11)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+91)*maxx)+(x+12)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+91)*maxx)+(x+13)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+91)*maxx)+(x+14)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+91)*maxx)+(x+15)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+91)*maxx)+(x+16)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+91)*maxx)+(x+17)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+91)*maxx)+(x+18)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+91)*maxx)+(x+19)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+91)*maxx)+(x+20)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+91)*maxx)+(x+21)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+91)*maxx)+(x+22)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+91)*maxx)+(x+23)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+91)*maxx)+(x+24)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+91)*maxx)+(x+25)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+91)*maxx)+(x+26)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+91)*maxx)+(x+27)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+91)*maxx)+(x+28)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+91)*maxx)+(x+29)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+91)*maxx)+(x+30)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+91)*maxx)+(x+31)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+91)*maxx)+(x+32)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+91)*maxx)+(x+33)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+91)*maxx)+(x+34)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+91)*maxx)+(x+35)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+91)*maxx)+(x+36)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+91)*maxx)+(x+37)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+91)*maxx)+(x+38)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+91)*maxx)+(x+39)] = RGB15(16,16,16) | BIT(15);

    buffer[((y+91)*maxx)+(x+40)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+92)*maxx)+(x+0)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+92)*maxx)+(x+1)] = RGB15(16,16,16) | BIT(15);

    buffer[((y+92)*maxx)+(x+2)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+92)*maxx)+(x+3)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+92)*maxx)+(x+4)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+92)*maxx)+(x+5)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+92)*maxx)+(x+6)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+92)*maxx)+(x+7)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+92)*maxx)+(x+8)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+92)*maxx)+(x+9)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+92)*maxx)+(x+10)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+92)*maxx)+(x+11)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+92)*maxx)+(x+12)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+92)*maxx)+(x+13)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+92)*maxx)+(x+14)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+92)*maxx)+(x+15)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+92)*maxx)+(x+16)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+92)*maxx)+(x+17)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+92)*maxx)+(x+18)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+92)*maxx)+(x+19)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+92)*maxx)+(x+20)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+92)*maxx)+(x+21)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+92)*maxx)+(x+22)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+92)*maxx)+(x+23)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+92)*maxx)+(x+24)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+92)*maxx)+(x+25)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+92)*maxx)+(x+26)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+92)*maxx)+(x+27)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+92)*maxx)+(x+28)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+92)*maxx)+(x+29)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+92)*maxx)+(x+30)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+92)*maxx)+(x+31)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+92)*maxx)+(x+32)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+92)*maxx)+(x+33)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+92)*maxx)+(x+34)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+92)*maxx)+(x+35)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+92)*maxx)+(x+36)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+92)*maxx)+(x+37)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+92)*maxx)+(x+38)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+92)*maxx)+(x+39)] = RGB15(16,16,16) | BIT(15);

    buffer[((y+92)*maxx)+(x+40)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+93)*maxx)+(x+0)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+93)*maxx)+(x+1)] = RGB15(16,16,16) | BIT(15);

    buffer[((y+93)*maxx)+(x+2)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+93)*maxx)+(x+3)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+93)*maxx)+(x+4)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+93)*maxx)+(x+5)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+93)*maxx)+(x+6)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+93)*maxx)+(x+7)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+93)*maxx)+(x+8)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+93)*maxx)+(x+9)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+93)*maxx)+(x+10)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+93)*maxx)+(x+11)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+93)*maxx)+(x+12)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+93)*maxx)+(x+13)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+93)*maxx)+(x+14)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+93)*maxx)+(x+15)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+93)*maxx)+(x+16)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+93)*maxx)+(x+17)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+93)*maxx)+(x+18)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+93)*maxx)+(x+19)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+93)*maxx)+(x+20)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+93)*maxx)+(x+21)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+93)*maxx)+(x+22)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+93)*maxx)+(x+23)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+93)*maxx)+(x+24)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+93)*maxx)+(x+25)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+93)*maxx)+(x+26)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+93)*maxx)+(x+27)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+93)*maxx)+(x+28)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+93)*maxx)+(x+29)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+93)*maxx)+(x+30)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+93)*maxx)+(x+31)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+93)*maxx)+(x+32)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+93)*maxx)+(x+33)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+93)*maxx)+(x+34)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+93)*maxx)+(x+35)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+93)*maxx)+(x+36)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+93)*maxx)+(x+37)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+93)*maxx)+(x+38)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+93)*maxx)+(x+39)] = RGB15(16,16,16) | BIT(15);

    buffer[((y+93)*maxx)+(x+40)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+94)*maxx)+(x+0)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+94)*maxx)+(x+1)] = RGB15(16,16,16) | BIT(15);

    buffer[((y+94)*maxx)+(x+2)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+94)*maxx)+(x+3)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+94)*maxx)+(x+4)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+94)*maxx)+(x+5)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+94)*maxx)+(x+6)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+94)*maxx)+(x+7)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+94)*maxx)+(x+8)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+94)*maxx)+(x+9)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+94)*maxx)+(x+10)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+94)*maxx)+(x+11)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+94)*maxx)+(x+12)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+94)*maxx)+(x+13)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+94)*maxx)+(x+14)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+94)*maxx)+(x+15)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+94)*maxx)+(x+16)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+94)*maxx)+(x+17)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+94)*maxx)+(x+18)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+94)*maxx)+(x+19)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+94)*maxx)+(x+20)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+94)*maxx)+(x+21)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+94)*maxx)+(x+22)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+94)*maxx)+(x+23)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+94)*maxx)+(x+24)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+94)*maxx)+(x+25)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+94)*maxx)+(x+26)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+94)*maxx)+(x+27)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+94)*maxx)+(x+28)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+94)*maxx)+(x+29)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+94)*maxx)+(x+30)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+94)*maxx)+(x+31)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+94)*maxx)+(x+32)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+94)*maxx)+(x+33)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+94)*maxx)+(x+34)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+94)*maxx)+(x+35)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+94)*maxx)+(x+36)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+94)*maxx)+(x+37)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+94)*maxx)+(x+38)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+94)*maxx)+(x+39)] = RGB15(16,16,16) | BIT(15);

    buffer[((y+94)*maxx)+(x+40)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+95)*maxx)+(x+0)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+95)*maxx)+(x+1)] = RGB15(16,16,16) | BIT(15);

    buffer[((y+95)*maxx)+(x+2)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+95)*maxx)+(x+3)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+95)*maxx)+(x+4)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+95)*maxx)+(x+5)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+95)*maxx)+(x+6)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+95)*maxx)+(x+7)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+95)*maxx)+(x+8)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+95)*maxx)+(x+9)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+95)*maxx)+(x+10)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+95)*maxx)+(x+11)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+95)*maxx)+(x+12)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+95)*maxx)+(x+13)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+95)*maxx)+(x+14)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+95)*maxx)+(x+15)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+95)*maxx)+(x+16)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+95)*maxx)+(x+17)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+95)*maxx)+(x+18)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+95)*maxx)+(x+19)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+95)*maxx)+(x+20)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+95)*maxx)+(x+21)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+95)*maxx)+(x+22)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+95)*maxx)+(x+23)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+95)*maxx)+(x+24)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+95)*maxx)+(x+25)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+95)*maxx)+(x+26)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+95)*maxx)+(x+27)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+95)*maxx)+(x+28)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+95)*maxx)+(x+29)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+95)*maxx)+(x+30)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+95)*maxx)+(x+31)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+95)*maxx)+(x+32)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+95)*maxx)+(x+33)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+95)*maxx)+(x+34)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+95)*maxx)+(x+35)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+95)*maxx)+(x+36)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+95)*maxx)+(x+37)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+95)*maxx)+(x+38)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+95)*maxx)+(x+39)] = RGB15(16,16,16) | BIT(15);

    buffer[((y+95)*maxx)+(x+40)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+96)*maxx)+(x+0)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+96)*maxx)+(x+1)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+96)*maxx)+(x+2)] = RGB15(16,16,16) | BIT(15);

    buffer[((y+96)*maxx)+(x+3)] = RGB15(16,16,16) | BIT(15);

    buffer[((y+96)*maxx)+(x+4)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+96)*maxx)+(x+5)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+96)*maxx)+(x+6)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+96)*maxx)+(x+7)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+96)*maxx)+(x+8)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+96)*maxx)+(x+9)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+96)*maxx)+(x+10)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+96)*maxx)+(x+11)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+96)*maxx)+(x+12)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+96)*maxx)+(x+13)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+96)*maxx)+(x+14)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+96)*maxx)+(x+15)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+96)*maxx)+(x+16)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+96)*maxx)+(x+17)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+96)*maxx)+(x+18)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+96)*maxx)+(x+19)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+96)*maxx)+(x+20)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+96)*maxx)+(x+21)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+96)*maxx)+(x+22)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+96)*maxx)+(x+23)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+96)*maxx)+(x+24)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+96)*maxx)+(x+25)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+96)*maxx)+(x+26)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+96)*maxx)+(x+27)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+96)*maxx)+(x+28)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+96)*maxx)+(x+29)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+96)*maxx)+(x+30)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+96)*maxx)+(x+31)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+96)*maxx)+(x+32)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+96)*maxx)+(x+33)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+96)*maxx)+(x+34)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+96)*maxx)+(x+35)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+96)*maxx)+(x+36)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+96)*maxx)+(x+37)] = RGB15(16,16,16) | BIT(15);

    buffer[((y+96)*maxx)+(x+38)] = RGB15(16,16,16) | BIT(15);

    buffer[((y+96)*maxx)+(x+39)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+96)*maxx)+(x+40)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+97)*maxx)+(x+0)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+97)*maxx)+(x+1)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+97)*maxx)+(x+2)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+97)*maxx)+(x+3)] = RGB15(16,16,16) | BIT(15);

    buffer[((y+97)*maxx)+(x+4)] = RGB15(16,16,16) | BIT(15);

    buffer[((y+97)*maxx)+(x+5)] = RGB15(16,16,16) | BIT(15);

    buffer[((y+97)*maxx)+(x+6)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+97)*maxx)+(x+7)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+97)*maxx)+(x+8)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+97)*maxx)+(x+9)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+97)*maxx)+(x+10)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+97)*maxx)+(x+11)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+97)*maxx)+(x+12)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+97)*maxx)+(x+13)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+97)*maxx)+(x+14)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+97)*maxx)+(x+15)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+97)*maxx)+(x+16)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+97)*maxx)+(x+17)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+97)*maxx)+(x+18)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+97)*maxx)+(x+19)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+97)*maxx)+(x+20)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+97)*maxx)+(x+21)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+97)*maxx)+(x+22)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+97)*maxx)+(x+23)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+97)*maxx)+(x+24)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+97)*maxx)+(x+25)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+97)*maxx)+(x+26)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+97)*maxx)+(x+27)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+97)*maxx)+(x+28)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+97)*maxx)+(x+29)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+97)*maxx)+(x+30)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+97)*maxx)+(x+31)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+97)*maxx)+(x+32)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+97)*maxx)+(x+33)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+97)*maxx)+(x+34)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+97)*maxx)+(x+35)] = RGB15(16,16,16) | BIT(15);

    buffer[((y+97)*maxx)+(x+36)] = RGB15(16,16,16) | BIT(15);

    buffer[((y+97)*maxx)+(x+37)] = RGB15(16,16,16) | BIT(15);

    buffer[((y+97)*maxx)+(x+38)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+97)*maxx)+(x+39)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+97)*maxx)+(x+40)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+98)*maxx)+(x+0)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+98)*maxx)+(x+1)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+98)*maxx)+(x+2)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+98)*maxx)+(x+3)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+98)*maxx)+(x+4)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+98)*maxx)+(x+5)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+98)*maxx)+(x+6)] = RGB15(16,16,16) | BIT(15);

    buffer[((y+98)*maxx)+(x+7)] = RGB15(16,16,16) | BIT(15);

    buffer[((y+98)*maxx)+(x+8)] = RGB15(16,16,16) | BIT(15);

    buffer[((y+98)*maxx)+(x+9)] = RGB15(16,16,16) | BIT(15);

    buffer[((y+98)*maxx)+(x+10)] = RGB15(16,16,16) | BIT(15);

    buffer[((y+98)*maxx)+(x+11)] = RGB15(16,16,16) | BIT(15);

    buffer[((y+98)*maxx)+(x+12)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+98)*maxx)+(x+13)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+98)*maxx)+(x+14)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+98)*maxx)+(x+15)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+98)*maxx)+(x+16)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+98)*maxx)+(x+17)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+98)*maxx)+(x+18)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+98)*maxx)+(x+19)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+98)*maxx)+(x+20)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+98)*maxx)+(x+21)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+98)*maxx)+(x+22)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+98)*maxx)+(x+23)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+98)*maxx)+(x+24)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+98)*maxx)+(x+25)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+98)*maxx)+(x+26)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+98)*maxx)+(x+27)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+98)*maxx)+(x+28)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+98)*maxx)+(x+29)] = RGB15(16,16,16) | BIT(15);

    buffer[((y+98)*maxx)+(x+30)] = RGB15(16,16,16) | BIT(15);

    buffer[((y+98)*maxx)+(x+31)] = RGB15(16,16,16) | BIT(15);

    buffer[((y+98)*maxx)+(x+32)] = RGB15(16,16,16) | BIT(15);

    buffer[((y+98)*maxx)+(x+33)] = RGB15(16,16,16) | BIT(15);

    buffer[((y+98)*maxx)+(x+34)] = RGB15(16,16,16) | BIT(15);

    buffer[((y+98)*maxx)+(x+35)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+98)*maxx)+(x+36)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+98)*maxx)+(x+37)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+98)*maxx)+(x+38)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+98)*maxx)+(x+39)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+98)*maxx)+(x+40)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+99)*maxx)+(x+0)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+99)*maxx)+(x+1)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+99)*maxx)+(x+2)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+99)*maxx)+(x+3)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+99)*maxx)+(x+4)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+99)*maxx)+(x+5)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+99)*maxx)+(x+6)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+99)*maxx)+(x+7)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+99)*maxx)+(x+8)] = RGB15(16,16,16) | BIT(15);

    buffer[((y+99)*maxx)+(x+9)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+99)*maxx)+(x+10)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+99)*maxx)+(x+11)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+99)*maxx)+(x+12)] = RGB15(16,16,16) | BIT(15);

    buffer[((y+99)*maxx)+(x+13)] = RGB15(16,16,16) | BIT(15);

    buffer[((y+99)*maxx)+(x+14)] = RGB15(16,16,16) | BIT(15);

    buffer[((y+99)*maxx)+(x+15)] = RGB15(16,16,16) | BIT(15);

    buffer[((y+99)*maxx)+(x+16)] = RGB15(16,16,16) | BIT(15);

    buffer[((y+99)*maxx)+(x+17)] = RGB15(16,16,16) | BIT(15);

    buffer[((y+99)*maxx)+(x+18)] = RGB15(16,16,16) | BIT(15);

    buffer[((y+99)*maxx)+(x+19)] = RGB15(16,16,16) | BIT(15);

    buffer[((y+99)*maxx)+(x+20)] = RGB15(16,16,16) | BIT(15);

    buffer[((y+99)*maxx)+(x+21)] = RGB15(16,16,16) | BIT(15);

    buffer[((y+99)*maxx)+(x+22)] = RGB15(16,16,16) | BIT(15);

    buffer[((y+99)*maxx)+(x+23)] = RGB15(16,16,16) | BIT(15);

    buffer[((y+99)*maxx)+(x+24)] = RGB15(16,16,16) | BIT(15);

    buffer[((y+99)*maxx)+(x+25)] = RGB15(16,16,16) | BIT(15);

    buffer[((y+99)*maxx)+(x+26)] = RGB15(16,16,16) | BIT(15);

    buffer[((y+99)*maxx)+(x+27)] = RGB15(16,16,16) | BIT(15);

    buffer[((y+99)*maxx)+(x+28)] = RGB15(16,16,16) | BIT(15);

    buffer[((y+99)*maxx)+(x+29)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+99)*maxx)+(x+30)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+99)*maxx)+(x+31)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+99)*maxx)+(x+32)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+99)*maxx)+(x+33)] = RGB15(16,16,16) | BIT(15);

    buffer[((y+99)*maxx)+(x+34)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+99)*maxx)+(x+35)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+99)*maxx)+(x+36)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+99)*maxx)+(x+37)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+99)*maxx)+(x+38)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+99)*maxx)+(x+39)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+99)*maxx)+(x+40)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+100)*maxx)+(x+0)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+100)*maxx)+(x+1)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+100)*maxx)+(x+2)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+100)*maxx)+(x+3)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+100)*maxx)+(x+4)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+100)*maxx)+(x+5)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+100)*maxx)+(x+6)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+100)*maxx)+(x+7)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+100)*maxx)+(x+8)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+100)*maxx)+(x+9)] = RGB15(16,16,16) | BIT(15);

    buffer[((y+100)*maxx)+(x+10)] = RGB15(16,16,16) | BIT(15);

    buffer[((y+100)*maxx)+(x+11)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+100)*maxx)+(x+12)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+100)*maxx)+(x+13)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+100)*maxx)+(x+14)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+100)*maxx)+(x+15)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+100)*maxx)+(x+16)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+100)*maxx)+(x+17)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+100)*maxx)+(x+18)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+100)*maxx)+(x+19)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+100)*maxx)+(x+20)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+100)*maxx)+(x+21)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+100)*maxx)+(x+22)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+100)*maxx)+(x+23)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+100)*maxx)+(x+24)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+100)*maxx)+(x+25)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+100)*maxx)+(x+26)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+100)*maxx)+(x+27)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+100)*maxx)+(x+28)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+100)*maxx)+(x+29)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+100)*maxx)+(x+30)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+100)*maxx)+(x+31)] = RGB15(16,16,16) | BIT(15);

    buffer[((y+100)*maxx)+(x+32)] = RGB15(16,16,16) | BIT(15);

    buffer[((y+100)*maxx)+(x+33)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+100)*maxx)+(x+34)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+100)*maxx)+(x+35)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+100)*maxx)+(x+36)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+100)*maxx)+(x+37)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+100)*maxx)+(x+38)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+100)*maxx)+(x+39)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+100)*maxx)+(x+40)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+101)*maxx)+(x+0)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+101)*maxx)+(x+1)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+101)*maxx)+(x+2)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+101)*maxx)+(x+3)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+101)*maxx)+(x+4)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+101)*maxx)+(x+5)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+101)*maxx)+(x+6)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+101)*maxx)+(x+7)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+101)*maxx)+(x+8)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+101)*maxx)+(x+9)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+101)*maxx)+(x+10)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+101)*maxx)+(x+11)] = RGB15(16,16,16) | BIT(15);

    buffer[((y+101)*maxx)+(x+12)] = RGB15(16,16,16) | BIT(15);

    buffer[((y+101)*maxx)+(x+13)] = RGB15(16,16,16) | BIT(15);

    buffer[((y+101)*maxx)+(x+14)] = RGB15(16,16,16) | BIT(15);

    buffer[((y+101)*maxx)+(x+15)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+101)*maxx)+(x+16)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+101)*maxx)+(x+17)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+101)*maxx)+(x+18)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+101)*maxx)+(x+19)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+101)*maxx)+(x+20)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+101)*maxx)+(x+21)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+101)*maxx)+(x+22)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+101)*maxx)+(x+23)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+101)*maxx)+(x+24)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+101)*maxx)+(x+25)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+101)*maxx)+(x+26)] = RGB15(31,29,20) | BIT(15);

    buffer[((y+101)*maxx)+(x+27)] = RGB15(16,16,16) | BIT(15);

    buffer[((y+101)*maxx)+(x+28)] = RGB15(16,16,16) | BIT(15);

    buffer[((y+101)*maxx)+(x+29)] = RGB15(16,16,16) | BIT(15);

    buffer[((y+101)*maxx)+(x+30)] = RGB15(16,16,16) | BIT(15);

    buffer[((y+101)*maxx)+(x+31)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+101)*maxx)+(x+32)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+101)*maxx)+(x+33)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+101)*maxx)+(x+34)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+101)*maxx)+(x+35)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+101)*maxx)+(x+36)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+101)*maxx)+(x+37)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+101)*maxx)+(x+38)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+101)*maxx)+(x+39)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+101)*maxx)+(x+40)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+102)*maxx)+(x+0)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+102)*maxx)+(x+1)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+102)*maxx)+(x+2)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+102)*maxx)+(x+3)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+102)*maxx)+(x+4)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+102)*maxx)+(x+5)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+102)*maxx)+(x+6)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+102)*maxx)+(x+7)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+102)*maxx)+(x+8)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+102)*maxx)+(x+9)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+102)*maxx)+(x+10)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+102)*maxx)+(x+11)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+102)*maxx)+(x+12)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+102)*maxx)+(x+13)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+102)*maxx)+(x+14)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+102)*maxx)+(x+15)] = RGB15(16,16,16) | BIT(15);

    buffer[((y+102)*maxx)+(x+16)] = RGB15(16,16,16) | BIT(15);

    buffer[((y+102)*maxx)+(x+17)] = RGB15(16,16,16) | BIT(15);

    buffer[((y+102)*maxx)+(x+18)] = RGB15(16,16,16) | BIT(15);

    buffer[((y+102)*maxx)+(x+19)] = RGB15(16,16,16) | BIT(15);

    buffer[((y+102)*maxx)+(x+20)] = RGB15(16,16,16) | BIT(15);

    buffer[((y+102)*maxx)+(x+21)] = RGB15(16,16,16) | BIT(15);

    buffer[((y+102)*maxx)+(x+22)] = RGB15(16,16,16) | BIT(15);

    buffer[((y+102)*maxx)+(x+23)] = RGB15(16,16,16) | BIT(15);

    buffer[((y+102)*maxx)+(x+24)] = RGB15(16,16,16) | BIT(15);

    buffer[((y+102)*maxx)+(x+25)] = RGB15(16,16,16) | BIT(15);

    buffer[((y+102)*maxx)+(x+26)] = RGB15(16,16,16) | BIT(15);

    buffer[((y+102)*maxx)+(x+27)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+102)*maxx)+(x+28)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+102)*maxx)+(x+29)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+102)*maxx)+(x+30)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+102)*maxx)+(x+31)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+102)*maxx)+(x+32)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+102)*maxx)+(x+33)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+102)*maxx)+(x+34)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+102)*maxx)+(x+35)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+102)*maxx)+(x+36)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+102)*maxx)+(x+37)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+102)*maxx)+(x+38)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+102)*maxx)+(x+39)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+102)*maxx)+(x+40)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+103)*maxx)+(x+0)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+103)*maxx)+(x+1)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+103)*maxx)+(x+2)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+103)*maxx)+(x+3)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+103)*maxx)+(x+4)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+103)*maxx)+(x+5)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+103)*maxx)+(x+6)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+103)*maxx)+(x+7)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+103)*maxx)+(x+8)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+103)*maxx)+(x+9)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+103)*maxx)+(x+10)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+103)*maxx)+(x+11)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+103)*maxx)+(x+12)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+103)*maxx)+(x+13)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+103)*maxx)+(x+14)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+103)*maxx)+(x+15)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+103)*maxx)+(x+16)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+103)*maxx)+(x+17)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+103)*maxx)+(x+18)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+103)*maxx)+(x+19)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+103)*maxx)+(x+20)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+103)*maxx)+(x+21)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+103)*maxx)+(x+22)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+103)*maxx)+(x+23)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+103)*maxx)+(x+24)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+103)*maxx)+(x+25)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+103)*maxx)+(x+26)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+103)*maxx)+(x+27)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+103)*maxx)+(x+28)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+103)*maxx)+(x+29)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+103)*maxx)+(x+30)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+103)*maxx)+(x+31)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+103)*maxx)+(x+32)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+103)*maxx)+(x+33)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+103)*maxx)+(x+34)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+103)*maxx)+(x+35)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+103)*maxx)+(x+36)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+103)*maxx)+(x+37)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+103)*maxx)+(x+38)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+103)*maxx)+(x+39)] = RGB15(0,0,0) | BIT(15);

    buffer[((y+103)*maxx)+(x+40)] = RGB15(0,0,0) | BIT(15);

  }

  int GetWidth() const { return 41; }

  int GetHeight() const { return 104; }

};



#endif // ARM9

#endif // PICBEER_H

Go back to Richel Bilderbeek's C++ page.

Go back to Richel Bilderbeek's homepage.

(C++) BeerWanter source code (version 6.1)

Technical facts

Qt project file: GameBeerWanterNds.pro

Qt project file: GameBeerWanterUbuntu.pro

Qt project file: GameBeerWanterWin.pro

Qt project file: GameBeerWanterWt.pro

beerwanter.cpp

beerwanter.h

beerwanterdialog.cpp

beerwanterdialog.h

beerwanterqtwidget.cpp

beerwanterqtwidget.h

beerwanterwtwidget.cpp

beerwanterwtwidget.h

mainDesktop.cpp

mainNds.cpp

mainWt.cpp

myassert.h

picbeer.h