
(********************************************************************)
(*                                                                  *)
(*  cards.s7i     Playing card pictures of a french deck            *)
(*  Copyright (C) 2006, 2013  Thomas Mertes                         *)
(*                                                                  *)
(*  This file is part of the Seed7 Runtime Library.                 *)
(*                                                                  *)
(*  The Seed7 Runtime Library is free software; you can             *)
(*  redistribute it and/or modify it under the terms of the GNU     *)
(*  Lesser General Public License as published by the Free Software *)
(*  Foundation; either version 2.1 of the License, or (at your      *)
(*  option) any later version.                                      *)
(*                                                                  *)
(*  The Seed7 Runtime Library 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 Lesser General Public License for more    *)
(*  details.                                                        *)
(*                                                                  *)
(*  You should have received a copy of the GNU Lesser General       *)
(*  Public License along with this program; if not, write to the    *)
(*  Free Software Foundation, Inc., 51 Franklin Street,             *)
(*  Fifth Floor, Boston, MA  02110-1301, USA.                       *)
(*                                                                  *)
(********************************************************************)


include "pic_util.s7i";


const array string: black_A_sign is [](
  "     X     ",
  "     X     ",
  "    XXX    ",
  "    XXX    ",
  "   XX XX   ",
  "   XX XX   ",
  "  XX   XX  ",
  "  XXXXXXX  ",
  " XXXXXXXXX ",
  " XX     XX ",
  "XXXX   XXXX",
  "XXXX   XXXX");

const array string: black_K_sign is [](
  "XXXX XXXX ",
  "XXXX XXXX ",
  " XX  XX   ",
  " XX XX    ",
  " XXXX     ",
  " XXX      ",
  " XXXX     ",
  " XX XX    ",
  " XX  XX   ",
  " XX   XX  ",
  "XXXX XXXX ",
  "XXXX XXXX ");


const array string: black_Q_sign is [](
  "  XXXXX   ",
  " XXXXXXX  ",
  " XX   XX  ",
  " XX   XX  ",
  " XX   XX  ",
  " XX   XX  ",
  " XX   XX  ",
  " XX   XX  ",
  " XX   XX  ",
  " XX   XX  ",
  " XXXXXXX  ",
  "  XXXXX   ",
  "     XXX  ",
  "      XX  ");


const array string: black_J_sign is [](
  "    XXXX  ",
  "    XXXX  ",
  "     XX   ",
  "     XX   ",
  "     XX   ",
  "     XX   ",
  "     XX   ",
  "     XX   ",
  " XX  XX   ",
  " XX  XX   ",
  " XXXXXX   ",
  "  XXXX    ");


const array string: black_10_sign is [](
  " XX  XXXX ",
  " XX XXXXXX",
  " XX XX  XX",
  " XX XX  XX",
  " XX XX  XX",
  " XX XX  XX",
  " XX XX  XX",
  " XX XX  XX",
  " XX XX  XX",
  " XX XX  XX",
  " XX XXXXXX",
  " XX  XXXX ");


const array string: black_9_sign is [](
  "  XXXXX   ",
  " XXXXXXX  ",
  " XX   XX  ",
  " XX   XX  ",
  " XX   XX  ",
  " XX   XX  ",
  " XXXXXXX  ",
  "  XXXXXX  ",
  "      XX  ",
  "     XXX  ",
  "  XXXXX   ",
  "  XXXX    ");


const array string: black_8_sign is [](
  "  XXXXX   ",
  " XXXXXXX  ",
  " XX   XX  ",
  " XX   XX  ",
  " XX   XX  ",
  "  XXXXX   ",
  " XXXXXXX  ",
  " XX   XX  ",
  " XX   XX  ",
  " XX   XX  ",
  " XXXXXXX  ",
  "  XXXXX   ");


const array string: black_7_sign is [](
  " XXXXXXX  ",
  " XXXXXXX  ",
  " XX   XX  ",
  "     XX   ",
  "     XX   ",
  "    XX    ",
  "    XX    ",
  "    XX    ",
  "   XX     ",
  "   XX     ",
  "   XX     ",
  "   XX     ");


const array string: black_6_sign is [](
  "   XXXX   ",
  "  XXXXX   ",
  " XXX      ",
  " XX       ",
  " XXXXXX   ",
  " XXXXXXX  ",
  " XX   XX  ",
  " XX   XX  ",
  " XX   XX  ",
  " XX   XX  ",
  " XXXXXXX  ",
  "  XXXXX   ");


const array string: black_5_sign is [](
  " XXXXXXX  ",
  " XXXXXXX  ",
  " XX       ",
  " XX       ",
  " XXXXXX   ",
  " XXXXXXX  ",
  "      XX  ",
  "      XX  ",
  " XX   XX  ",
  " XX   XX  ",
  " XXXXXXX  ",
  "  XXXXX   ");


const array string: black_4_sign is [](
  "     XX   ",
  "    XXX   ",
  "   XXXX   ",
  "  XXXXX   ",
  " XXX XX   ",
  "XXX  XX   ",
  "XXXXXXXXX ",
  "XXXXXXXXX ",
  "     XX   ",
  "     XX   ",
  "    XXXX  ",
  "    XXXX  ");


const array string: black_3_sign is [](
  " XXXXXXX  ",
  " XXXXXXX  ",
  " XX  XX   ",
  "    XX    ",
  "   XX     ",
  "  XXXXX   ",
  "  XXXXX   ",
  "      XX  ",
  "      XX  ",
  " XX   XX  ",
  " XXXXXXX  ",
  "  XXXXX   ");


const array string: black_2_sign is [](
  "  XXXXX   ",
  " XXXXXXX  ",
  " XX   XX  ",
  "      XX  ",
  "     XXX  ",
  "    XXX   ",
  "   XXX    ",
  "  XXX     ",
  " XXX  XX  ",
  " XX   XX  ",
  " XXXXXXX  ",
  " XXXXXXX  ");


const array string: red_A_sign is [](
  "     R     ",
  "     R     ",
  "    RRR    ",
  "    RRR    ",
  "   RR RR   ",
  "   RR RR   ",
  "  RR   RR  ",
  "  RRRRRRR  ",
  " RRRRRRRRR ",
  " RR     RR ",
  "RRRR   RRRR",
  "RRRR   RRRR");

const array string: red_K_sign is [](
  "RRRR RRRR ",
  "RRRR RRRR ",
  " RR  RR   ",
  " RR RR    ",
  " RRRR     ",
  " RRR      ",
  " RRRR     ",
  " RR RR    ",
  " RR  RR   ",
  " RR   RR  ",
  "RRRR RRRR ",
  "RRRR RRRR ");


const array string: red_Q_sign is [](
  "  RRRRR   ",
  " RRRRRRR  ",
  " RR   RR  ",
  " RR   RR  ",
  " RR   RR  ",
  " RR   RR  ",
  " RR   RR  ",
  " RR   RR  ",
  " RR   RR  ",
  " RR   RR  ",
  " RRRRRRR  ",
  "  RRRRR   ",
  "     RRR  ",
  "      RR  ");


const array string: red_J_sign is [](
  "    RRRR  ",
  "    RRRR  ",
  "     RR   ",
  "     RR   ",
  "     RR   ",
  "     RR   ",
  "     RR   ",
  "     RR   ",
  " RR  RR   ",
  " RR  RR   ",
  " RRRRRR   ",
  "  RRRR    ");


const array string: red_10_sign is [](
  " RR  RRRR ",
  " RR RRRRRR",
  " RR RR  RR",
  " RR RR  RR",
  " RR RR  RR",
  " RR RR  RR",
  " RR RR  RR",
  " RR RR  RR",
  " RR RR  RR",
  " RR RR  RR",
  " RR RRRRRR",
  " RR  RRRR ");


const array string: red_9_sign is [](
  "  RRRRR   ",
  " RRRRRRR  ",
  " RR   RR  ",
  " RR   RR  ",
  " RR   RR  ",
  " RR   RR  ",
  " RRRRRRR  ",
  "  RRRRRR  ",
  "      RR  ",
  "     RRR  ",
  "  RRRRR   ",
  "  RRRR    ");


const array string: red_8_sign is [](
  "  RRRRR   ",
  " RRRRRRR  ",
  " RR   RR  ",
  " RR   RR  ",
  " RR   RR  ",
  "  RRRRR   ",
  " RRRRRRR  ",
  " RR   RR  ",
  " RR   RR  ",
  " RR   RR  ",
  " RRRRRRR  ",
  "  RRRRR   ");


const array string: red_7_sign is [](
  " RRRRRRR  ",
  " RRRRRRR  ",
  " RR   RR  ",
  "     RR   ",
  "     RR   ",
  "    RR    ",
  "    RR    ",
  "    RR    ",
  "   RR     ",
  "   RR     ",
  "   RR     ",
  "   RR     ");


const array string: red_6_sign is [](
  "   RRRR   ",
  "  RRRRR   ",
  " RRR      ",
  " RR       ",
  " RRRRRR   ",
  " RRRRRRR  ",
  " RR   RR  ",
  " RR   RR  ",
  " RR   RR  ",
  " RR   RR  ",
  " RRRRRRR  ",
  "  RRRRR   ");


const array string: red_5_sign is [](
  " RRRRRRR  ",
  " RRRRRRR  ",
  " RR       ",
  " RR       ",
  " RRRRRR   ",
  " RRRRRRR  ",
  "      RR  ",
  "      RR  ",
  " RR   RR  ",
  " RR   RR  ",
  " RRRRRRR  ",
  "  RRRRR   ");


const array string: red_4_sign is [](
  "     RR   ",
  "    RRR   ",
  "   RRRR   ",
  "  RRRRR   ",
  " RRR RR   ",
  "RRR  RR   ",
  "RRRRRRRRR ",
  "RRRRRRRRR ",
  "     RR   ",
  "     RR   ",
  "    RRRR  ",
  "    RRRR  ");


const array string: red_3_sign is [](
  " RRRRRRR  ",
  " RRRRRRR  ",
  " RR  RR   ",
  "    RR    ",
  "   RR     ",
  "  RRRRR   ",
  "  RRRRR   ",
  "      RR  ",
  "      RR  ",
  " RR   RR  ",
  " RRRRRRR  ",
  "  RRRRR   ");


const array string: red_2_sign is [](
  "  RRRRR   ",
  " RRRRRRR  ",
  " RR   RR  ",
  "      RR  ",
  "     RRR  ",
  "    RRR   ",
  "   RRR    ",
  "  RRR     ",
  " RRR  RR  ",
  " RR   RR  ",
  " RRRRRRR  ",
  " RRRRRRR  ");


const array string: small_spades_sign is [](
  "    X    ",
  "   XXX   ",
  "  XXXXX  ",
  " XXXXXXX ",
  "XXXXXXXXX",
  "XXXXXXXXX",
  "XXXXXXXXX",
  " XX X XX ",
  "    X    ",
  "   XXX   ");

const array string: small_hearts_sign is [](
  " RRR RRR ",
  "RRRR RRRR",
  "RRRRRRRRR",
  "RRRRRRRRR",
  "RRRRRRRRR",
  " RRRRRRR ",
  "  RRRRR  ",
  "   RRR   ",
  "    R    ",
  "         ");


const array string: small_diamonds_sign is [](
  "    R    ",
  "   RRR   ",
  "  RRRRR  ",
  " RRRRRRR ",
  " RRRRRRR ",
  " RRRRRRR ",
  "  RRRRR  ",
  "   RRR   ",
  "    R    ",
  "         ");


const array string: small_clubs_sign is [](
  "   XXX   ",
  "  XXXXX  ",
  "  XXXXX  ",
  " X XXX X ",
  "XXXXXXXXX",
  "XXXXXXXXX",
  "XXXXXXXXX",
  " XX X XX ",
  "    X    ",
  "   XXX   ");


const array string: big_spades_sign is [](
  "       X       ",
  "      XXX      ",
  "     XXXXX     ",
  "    XXXXXXX    ",
  "   XXXXXXXXX   ",
  "  XXXXXXXXXXX  ",
  " XXXXXXXXXXXXX ",
  " XXXXXXXXXXXXX ",
  "XXXXXXXXXXXXXXX",
  "XXXXXXXXXXXXXXX",
  "XXXXXXXXXXXXXXX",
  "XXXXXX X XXXXXX",
  " XXXX  X  XXXX ",
  "      XXX      ",
  "     XXXXX     ",
  "               ",
  "               ");


const array string: big_hearts_sign is [](
  "               ",
  "               ",
  "  RRRR   RRRR  ",
  " RRRRRR RRRRRR ",
  "RRRRRRR RRRRRRR",
  "RRRRRRRRRRRRRRR",
  "RRRRRRRRRRRRRRR",
  "RRRRRRRRRRRRRRR",
  "RRRRRRRRRRRRRRR",
  " RRRRRRRRRRRRR ",
  " RRRRRRRRRRRRR ",
  "  RRRRRRRRRRR  ",
  "   RRRRRRRRR   ",
  "    RRRRRRR    ",
  "     RRRRR     ",
  "      RRR      ",
  "       R       ");


const array string: big_diamonds_sign is [](
  "               ",
  "       R       ",
  "      RRR      ",
  "     RRRRR     ",
  "    RRRRRRR    ",
  "   RRRRRRRRR   ",
  "   RRRRRRRRR   ",
  "  RRRRRRRRRRR  ",
  " RRRRRRRRRRRRR ",
  "  RRRRRRRRRRR  ",
  "   RRRRRRRRR   ",
  "   RRRRRRRRR   ",
  "    RRRRRRR    ",
  "     RRRRR     ",
  "      RRR      ",
  "       R       ",
  "               ");


const array string: big_clubs_sign is [](
  "      XXX      ",
  "     XXXXX     ",
  "    XXXXXXX    ",
  "    XXXXXXX    ",
  "    XXXXXXX    ",
  "     XXXXX     ",
  "  XXX XXX XXX  ",
  " XXXXXXXXXXXXX ",
  "XXXXXXXXXXXXXXX",
  "XXXXXXXXXXXXXXX",
  "XXXXXXXXXXXXXXX",
  " XXXXX X XXXXX ",
  "  XXX  X  XXX  ",
  "      XXX      ",
  "     XXXXX     ",
  "               ",
  "               ");


const array string: king_of_spades_pic is [](
  "               XYYYYYYYYYYYYYYYYYYYYX        ",
  "        X       XYYYYYYYXYXYXYXYXYXX         ",
  "       XXX       XXYXYXYXRXRXRXRXRX          ",
  "      XXXXX       XRXRXRRRRRRRRRRX          X",
  "     XXXXXXX      XRRRRRXXXXXXXXXX         XX",
  "    XXXXXXXXX     XXXXXXX        XX       XYX",
  "   XXXXXXXXXXX    X X X X        X X      XYX",
  "  XXXXXXXXXXXXX   X X X XXXXX XXXX X      XYX",
  "  XXXXXXXXXXXXX   X X X XX XXX XXXX       XYX",
  " XXXXXXXXXXXXXXX  X X X X    X   X X      XYX",
  " XXXXXXXXXXXXXXX  X X X X    X   X X      XYX",
  " XXXXXXXXXXXXXXX  X X X X    X   X X      XYX",
  " XXXXXX X XXXXXX  X X X X   XXX  X X      XYX",
  "  XXXX  X  XXXX   X X X X XX   X X X      XYX",
  "       XXX      XXX X X X X XXX  XX XX    XYX",
  "      XXXXX    X  X X X X        X X  X   XYX",
  "              X X X X X X  X   X X X  X   XYX",
  "            XXX XX  X X XX X X X X  XXYXX XYX",
  "          XXXYXX   X  X X  X XXX  XXXYXX XXYX",
  "        XXYXRYXXXXX XX X  X X XYXRXXYXX XRXYX",
  "      XXXXYXXXYXXYXXXXXXXX X XXYXXXYXX XXXXYX",
  "    XXYXYXXYXXYXRXXYXYXYXXXXXXYXRXYXX XRRRXYX",
  "  XXRRXXXXXYXRXYXRRXXXXXXYXYXXYXXXYXX XRXXXYX",
  " XRYYXXYXXXYXXXYXRRRYYYYXXXXXYXRXYXX XRRRRXYX",
  "XYRRXXXXXYXXYXXYXRRRYXXXYYRRXYXXXYXX XRXXXXYX",
  "RYYRXXYXYXYXYXRXYXRRYYYYYYRRXYXXYXX XRRRRRXYX",
  "RRYXXXXXYXXXYXXXYXXXXXXXXXXXYXRXYXX XRXXXXXXX",
  "YRRXXYXYXYYYXYXXYXX   X   XXYXXXYXX XRXYYYYXX",
  "YYRXXXXYXYXXXYXXYX  X   X  XYXXYXX XRXYXXXYYY",
  "RYYXXYXYXYYYXYXRXYX X X X  XYXXYXX XRXYYX XYY",
  "RRYXXXXYXYXXXYXXXYX   X   XYXRXYXXXXRRXXXX XX",
  "YRRXXYXYXYYYYXYXXYX X   X XYXXXYXYXXXRRRRRXXX",
  "RYRXXXXYXYXXXXYXXYXXXXXXXXXYXXYXXXXXXXXXXX   ",
  "RRYXXYXXYXYYYXYXXYXYYYYYYYYYXXYXXXXXXXX   XXX",
  "XXRXXXXXYXYXXXYXXYXXXXXXXXXYXXYXYYXXXYXX X   ",
  "  X XXYXXYXYYXYXRYXXXRRRXXXYXXYXXXYYXXXX  XXX");


const array string: queen_of_spades_pic is [](
  "          XX XX X X RXYXXYYYYX               ",
  "  X      XXXXX X XX RXYYXYYYX       X        ",
  "  X      XX X XX  X RXYYYYYYX      XXX       ",
  "  X      XXX X  X  XRXYXXYYX      XXXXX      ",
  " XYX     X XX    X XRXYYXYYX     XXXXXXX     ",
  " XYX    XX X      XXRRXYYYYYX   XXXXXXXXX    ",
  " XYX    XR XXXX XXXXRRXYXXYYX  XXXXXXXXXXX   ",
  " XYX    XR XXX XXX XRRRXYXYX  XXXXXXXXXXXXX  ",
  "XYYYX   XR X   X   X RRXYYX   XXXXXXXXXXXXX  ",
  "XYXYX   XR X   X    XRRRXYX  XXXXXXXXXXXXXXX ",
  "XYYYX  XRR X   X    X RRRXX  XXXXXXXXXXXXXXX ",
  " XYX   XR XX  XXX    XRRRXX  XXXXXXXXXXXXXXX ",
  " XYX   XR XX         X RRRX  XXXXXX X XXXXXX ",
  "XXXXX  X XXXX XXX   XRX RRRX  XXXX  X  XXXX  ",
  "XYYYX XR XXXX  X   XRXX RRRXX      XXX       ",
  " XXX  XR XXXYX    XXXYXX RRRXX    XXXXX      ",
  "XYYYX XR XYXXYXXXXYXYXYYX RRRXX              ",
  "XYYYX XXXXYYXXYXYXYXXYYXXX    XX       RR    ",
  " XXX  XXXXYYYYXXXXXYYYXXXXXXXXRXX    RRXXRR  ",
  " XRX XXX XXYXYYYYYYXYXXX  XXRRRRXY  RRXYYXRR ",
  " XYXXYXX XXYYXYXYXYYXX  XXXRRR XYXX  RRXXRR X",
  " XYXRYYXXXXXYYYYYYYXX XXXRRRR XYXXYXX  RR  XR",
  "XXYXRRYXX XXYXYXYYXX XXXRRR  XYXXXYYYX X  XYR",
  "XXYXRRYXXXXXXYYYYXX XXRRRR  XYXRXXXYYYXX XXXY",
  "XXYXRRYYXX XXYYYXX XXRRRR RRXYXXXXXXXXYXXXXXY",
  "XXYX RRYXXX XXXYX XXRRR  RRRXYXRRRXXXXX    XY",
  "XXYXXRRYYXXXXYYX XXRRR RRRXXXYXXXXXXXX     XY",
  "XXYX XRRYXXXYRRYXXRRR RRXXXXXYYXRRRRX      XY",
  "XXYXX RRYYXXYRRYXRRR RXXX  XXXYXXXXX  X  XXYR",
  "XXYX XXRRYYXYRRYXRR RXX     XXXYXRRX XXXXXXXR",
  "XXYXX XRRRYYXYYXRR XXX  XXX  XXXYXXXXXYXXXXXX",
  "XXYX X XRRRYYXXXR XXX  XXXXX  XXXYXRXYYXYXXXY",
  "XXYXX X XRRRRRRRRXXX           XXXYXYYYXYYYYX",
  "XXYX X X XXXXXXXXXXXXXXXXXXXXXXXXXXXXYYYYYXXY",
  "XXYXX X XRRRRRRRRRRRRRRRRRRRRRRRRRRRXXXXXXYYX",
  "XXYX X XXX XXX XXX XXX XXX XXX XXX XXXYYYYXXX");


const array string: jack_of_spades_pic is [](
  "   XX   XRRXRRRXRXRRXRXRRRXRRX               ",
  "  XYYX   XRRXRRXRXRRXRXRRXRRX       X        ",
  " XYXRYX   XRRXXXRXXXXRXXXRRX       XXX       ",
  " XYXRYX    XRRRRRRRRRRRRRRX       XXXXX      ",
  " XYXRYX    XXXXXXXXXXXXXXX       XXXXXXX     ",
  "  XYYX     X     XYXYXYXYX      XXXXXXXXX    ",
  "   XX      X XX  XYXYXYXYX     XXXXXXXXXXX   ",
  "  XYYX     X X XX XYXYXYXYX   XXXXXXXXXXXXX  ",
  " XYXRYX    X      XYXYXYXYX   XXXXXXXXXXXXX  ",
  "  XYYX    X       XYXYXYXYX  XXXXXXXXXXXXXXX ",
  "   XX    X        XYXYXYXYX  XXXXXXXXXXXXXXX ",
  "  XYYX   XX  XX X XYXYXYXYX  XXXXXXXXXXXXXXX ",
  " XYXRYX    X  XXX XYXYXYXYX  XXXXXX X XXXXXX ",
  " XYXRYX    X      XYXYXYXYYXX XXXX  X  XXXX  ",
  " XYXRYX    XXX   XYYXYXYXYYYYX     XXX       ",
  "  XYYX     X     XYYXYYXYXYXYYX   XXXXX      ",
  " XXXXX    XX     RXXYXYXYXYYXYX              ",
  " X   XX XXXXX  RRRRXYXXYXYXXYYX              ",
  "  XX  XXXXXXXXRRRRRXXYYXYXYYYXX              ",
  " X  XXXX XXXXXXXXXXXXXXXXXXXXXXXX            ",
  " X XXX X XXXXXXXXXXXXXXXXXXXX X XXX          ",
  " XXX XXXX XYXYXYXYXYXYXYXYXYX XXX XXX        ",
  "XRXXX X X XXXXXXXXXXXXXXXXXXX X X XXRXX      ",
  "RXXRX XXXX XRRRRRRRRRRRRRRRRX XXX XRRRXXX  XX",
  "XXRXXX X X XXRYRRYRRYRRYRRYRX X X XRXXXRRXXYX",
  "XRXXYX XXXX XRRRYXYRYRYXYRRRX XXX XXXRRXXYYYX",
  "RXXYXYX X X XXRYXYRYYYRYXYRRX X X XRRXXYYXXXX",
  "XXYXYXX XXXXXYXRYRRYXYRRYRRRX XXX XXXXYYYYYXX",
  "XYXYXYXX XXYXXXXXX XXX XXX XX X X XXXYYXXXXXY",
  "YXYXYXXXXXYXXYX X X X X X X X XXXXXXYYYYYYXXY",
  "XYXYXXRXXYXXYYXX XXX XXX XXXX X XXXYYXYXXXXYX",
  "YYYXX RXYXXXXYXXXXXXXXXXXXXXXXXXXXYYYYYYYXXYX",
  "YXXXRRXYXXYYYYX                  XYYXYXXXXYXR",
  "XXX RXYXXYXXXYXRRRRRRRRRRRRRRRRRXYYYYYYYXXYRR",
  "XXRRXYXXYYYYYXXXXXXXXXXXXXXXXXXXXYXYXXXXXYXRR",
  "XYRXYXXXXYXXYXXXYXX X   XX XX XXYYYYYYYXYRRRR");


const array string: king_of_hearts_pic is [](
  "               XYXYYYXYYYXYYYXYYYYYYX        ",
  "   RRRR   RRRR  XXXYXXXYXXXYXXXYXXYX         ",
  "  RRRRRR RRRRRR  XYYYYYYYYYYYYXYYXX  XX      ",
  " RRRRRRR RRRRRRR  XRRRRRRRRRYYYYYX  XYYX     ",
  " RRRRRRRRRRRRRRR  XXXXXXXXXXRRRRRX  XYYXXX   ",
  " RRRRRRRRRRRRRRR  X        XXXXXXXXXXYX  XX  ",
  " RRRRRRRRRRRRRRR  X        X X X X  XYX  XYX ",
  " RRRRRRRRRRRRRRR XXXXX XXXXX X X XXXYYXXXXYX ",
  "  RRRRRRRRRRRRR X XXX XXX XX X X XXXYYXX  X  ",
  "  RRRRRRRRRRRRR X X   X    X X X X XYYX   X  ",
  "   RRRRRRRRRRR  X X   X    X X X X  XXXXXXX  ",
  "    RRRRRRRRR   X X   X    X X X  X  XRRRRX  ",
  "     RRRRRRR   X X   XXX    X X X X XXXXXXXX ",
  "      RRRRR    X X          X  X X XXRXRXRXRX",
  "       RRR      XX X XXX     X X X XRRRRRRRXX",
  "        R   XXXXX  X      X X X X  XXRRRRRX  ",
  "          XXXRXX  X X   X X X X   X  XXXRX RR",
  "       XXXXXXXRXXX  X X X XXX   XX X   XXXRRX",
  "     XXXRX  XXRRX XX  X X  X XXX     XXRXXXXX",
  "   XX  XRX   XXRRXX  XX XX XYYX  X  XRXRXYXXX",
  " XXX X XRX X  XXRRXXXYXX XXYYYX X  XRYXRXXXYX",
  "XYYRX X XRX X  XRRXXYXYXXYYYYX    XRYXRXXXXXY",
  "YRRRXX  XRX    XXRRXXYXXYYYYYXX   XYRXRXYXXXX",
  "RRXXXXX  XRX X  XRRRXXXYYYYYYX   XYRXRXXRYYXX",
  "RXXXXXRX XRRX X XXRRXXYYYYYYX  X XRXRRXXXXYYX",
  "XYXXXRRRX XRRX   XRRRXYYYYYXX X  XXRRXXXXRRYY",
  "YRRYXXXRRX XRRRX XXRXYYYYYXRX   XXRRXXXXRRRRY",
  "RRYYYRXXXXX XXRRXX XXYYYYYXX  XXRRXXXXXRRYRXY",
  "RYYYXRYYXXXX  XXXXXXXXXXXXXXXXRRXXXXXXRRRRRYY",
  "YYYXRXXXYXXXXX     RRRRRRRRRRRXXXXXXXRRYRXYYX",
  "YYYXRYYYYXYX    RXXXXXXXXXXXXX XXXXXRRRRRYYYX",
  "YYYXRXXXYXYX         XRRRRX    XXXXRRYRXYYYXX",
  "YYYXRYYYYXYX       XXX RRRX X XXXXRYRRRYYYXXX",
  "XYYYXRYYXXXXXXXXXXX XXXXXRXX XXXXXXXRXYYYXXXR",
  "XXYYYYXXXXXXXXX   XXYYYYYXX  XXXXRRXYYYYXXXRX",
  "RXXYXXXXXYYYYYX   XXYXRXYX  X XYYYYYYYYXXXXRR");


const array string: queen_of_hearts_pic is [](
  "           XX X X  XXXRYYYYYX                ",
  "          XX X X X XXXRYXYYX   RRRR   RRRR   ",
  "         XXXX XX   XXXRYYYYX  RRRRRR RRRRRR  ",
  "         XYX X  X   XXRYXYX  RRRRRRR RRRRRRR ",
  "        XXYXX    XX XXRRYYX  RRRRRRRRRRRRRRR ",
  "        XYRX       XXXXRYYX  RRRRRRRRRRRRRRR ",
  "       XXYRXXXX XXX XXXRRYYX RRRRRRRRRRRRRRR ",
  "       XYRRXXX XXX XXXXXRRYX RRRRRRRRRRRRRRR ",
  "      XXYRRX   X    X XXXRX   RRRRRRRRRRRRR  ",
  "      XYRRYX   X    X XXXX    RRRRRRRRRRRRR  ",
  "      XYRRYX   X    X  XXXX    RRRRRRRRRRR   ",
  "      XYRRYX  XXX    X XXXXX    RRRRRRRRR    ",
  "     XYRRYYX         X  XXXXX    RRRRRRR     ",
  "     XYRRYXXX XXX   XYX  XXXXX    RRRRR      ",
  "     XYRRXXYX  X   XYYX   XXXXXX   RRR       ",
  "     XYRXYXXYX    XYYXXX   XXXXXXX  R        ",
  "     XYX YXXXYXXXXYYXXXYX   XXXXXX           ",
  "     XXY XYXXXYYYYXXXXYX X   XXXX    XX XX   ",
  "    XXYXYR YXXXXXXXXXYR YXXX   X    XYYXYYX  ",
  "   XYYYYXY XYYXXXXYYYX YXXXXXXXX    XYRRRX   ",
  "  XXXYXXYXYR XYYYYX RYYXXXX     X    XYRYYX  ",
  " XYYYYYYYYXYYYR XRYYYXX XX  X X XX XXXXYYX X ",
  "XXXXYXXXYYXXXXYYYYXXXXYXX X    XRRXYYYXXXYXX ",
  "YYYYYYYYYXX  XXXXXYXXXYXX    XXRRXYYYX  XXYX ",
  "XXXYXXXXYX X XXXXXXYXYXX X XXRRXXXXXX   XYYX ",
  "YYYYYYYYXX XXXX  XXYXYXX  XRRRXYYYX XXXXXYX  ",
  "XYXYXXXYXXX XX  X XXYXX X XRRXYRRRX XRX XX   ",
  "YYYYYYYYX X XRXX  XXYXX  XRRXYRRYRXX XX XX   ",
  "XXYXYXXYXXX XYRRX  XYX X XRRXYRRRXXX X X  X  ",
  "YYYYYYYYXX XXYYRRX XXX  XRRXYRRYRXX XX X  X  ",
  "XYXXXXYXX XXYXYYRXXXXX  XRRXYRRRRX XXX  XXX  ",
  "YYYYYYYXX XXYXXYRXXYYXXXXRRXYRYRRX X X   XRX ",
  "XYXXYYXXX XXYRXYYRXXXYYYXXRXYRRXXX XXX XXRRRX",
  "YYYYYXRXXX XYRXYRRXYXXXXYYXXXXXRRXX XXXRRRRRR",
  "XXXYXRRX X XYXXYYRXYXYYYXXYYXRRRYX X XRRRRRRX",
  "YYYXRRRXX XXYXYYRXYXYRRRYXXXRRYYYXXX XRRRRXXY");


const array string: jack_of_hearts_pic is [](
  "        XR RRR RR RR RR RRR RX               ",
  "X  XXX   XR RR RR RR RR RR RX  RRRR   RRRR   ",
  "RX  XYX   XR   RR    RR   RX  RRRRRR RRRRRR  ",
  "RX  XYYX   XRRRRRRRRRRRRRRX  RRRRRRR RRRRRRR ",
  "RX  XYYX    XXXXXXXXXXXXXXX  RRRRRRRRRRRRRRR ",
  "XXXX XYYX   XYXYXYXYX     X  RRRRRRRRRRRRRRR ",
  " R R  XYX   XYXYXYXYX  XX X  RRRRRRRRRRRRRRR ",
  " R R   XX  XYXYXYXYX XX X X  RRRRRRRRRRRRRRR ",
  " X X  XYX  XYXYXYXYX      X   RRRRRRRRRRRRR  ",
  "XXXX XYYX  XYXYXYXYX       X  RRRRRRRRRRRRR  ",
  "RX  XYYX   XYXYXYXYX        X  RRRRRRRRRRR   ",
  "RX  XYYX   XYXYXYXYX   XX XXX   RRRRRRRRR    ",
  "RX  XYX    XYXYXYXYX XXX  X      RRRRRRR     ",
  "RX XXX   XXXYXYXYXYX      X       RRRRR      ",
  "RX      XYYYXXYXYXYX    XXX        RRR   X   ",
  "RX     XYYXYXYXYXXYX      X         R  XXRXX ",
  "RX     XYXYYXYXYXYXRRR    XXXXXX       XRRRX ",
  "RX     XYYXXYYXYXXRRRRRXXXYYXYYYX       XRX  ",
  "RX      XYYYYXYXXRRRRRRRRRXYYXXYX       XRX  ",
  "RX      XXXXXXXYYXXRRRRRRRXXYYYYX   XXXXXRX  ",
  "RX    XXR RXYYYYYYYXXXXXXYYYXYYXX  XX    XXX ",
  "RX  XXXXXXR XXYYYYYYYYYYYYYYYXX RXXX  XX X X ",
  "RXXX  RRXXXXR XXXYYYYYYYYYXXX RRRXXXX  XXXXX ",
  "RXRR    RRXXXXR RXXXXXXXXXR RRRXXXXRRX  X  X ",
  "XXXXRR    RRXXXXR R R R R RRRXXXXRR   XXXXXX ",
  "YYYXXXRR    RRXXXXRXXXXXXXRXXXXRR    RXX  X  ",
  "YYXYYYXXRR    RRXXXRX   XRXXXRR    RRXX XXX  ",
  "YXYYYXYYXXRR    RRXXRX XRXXRR    RRXXYX    X ",
  "XXXYXYYRXXXXRR    RXXRXRXXR    RRXXYYYX X XXX",
  "   XYYRXXYYYXXRR   RXXRXXR    RXXYYYYYX    XX",
  "X   XRXXYYYYYYXRR   RXXXR   RRXYYYYYYYX X XXX",
  "  X XXXYXXXXXXXXXR   RXR   RXXXXXXXXXYX    XX",
  "X    XYYX       XRR  XXX  RRX       XYX X XXX",
  "XX X XYYX XXXXX XXRRX   XRRXX XXXXX XYX    XX",
  "XX    XYX XYYXXXX XX XXX XX XXXXYYX XYX X XXX",
  "XXX X XYX XYYXX  XX XRRRX XX  XXYYX XYX    XX");


const array string: king_of_diamonds_pic is [](
  "             XYYYYXYYYXYYYYYYYYYYYYYX        ",
  "       R      XYYXXXYXXXYYXYYYYYYYYX   XXX  X",
  "      RRR      XRRRRRRRRYXXXYYXYYYX   XYX  XR",
  "     RRRRR     XXXXXXXXXRRRRYXXXYXX  XYYX  XR",
  "    RRRRRRR     XXXXXXXXXXXXRRRRRX   XYYX  XR",
  "   RRRRRRRRR    X      XX XXXXXXXX  XYYX XXXX",
  "   RRRRRRRRR    X XX   X X XXXXXXX  XYX  R R ",
  "  RRRRRRRRRRR   XXX X  X X X X X X  XX   R R ",
  " RRRRRRRRRRRRR  X      X X X X X X  XYX  X X ",
  "  RRRRRRRRRRR  X       X X X X X X  XYYX XXXX",
  "   RRRRRRRRR  X        X X X X X X   XYYX  XR",
  "   RRRRRRRRR  XXX       X X X X X X  XYYX  XR",
  "    RRRRRRR     XXXX X  X X X X X X   XYX  XR",
  "     RRRRR      X  XXX   X X X X X X   XXX XR",
  "      RRR        XX       X X X X X X      XR",
  "       R        X      XXX  X X X X X      XR",
  "  XXX           XX    X   X X X X X X      XR",
  " X X XXX     XX X     X XX  X X X X X      XR",
  " XX X X X   X XX      XX   X X X X X       XR",
  "XX X X X X  X          XXXXXXXXXXXXXXXX    XR",
  "X X X     XXYX     XXXXXXXXYYX   XYYX  XXXXXX",
  " X X    XXXXXYXXXXXXXXXXX XXYYX XXXYYX  XYYX ",
  "  X  XXXXXRRXXYXXXRRXXXX XX XYYXXX XYYX XXYYX",
  "   XXRXXYXRRXXXYXRXRRXXXXXXXXXXXXXXXXXXXX XY ",
  " XXRRRRRXYXX XXYXRRXRXXYYYYYYYYYYYYYYXXXXXXXX",
  "XRRRRRXXYXYXXRRXXXRRXX X X X X X X  XYXXXXXXX",
  "RRRRXXYYYYXYXRRXYXXX               XYXRRXX  X",
  "RRXXYYYYXXXXYXXXYX   XXXXXXXXXXX  XYXYXRRXX X",
  "RXYYYYXXXXXXYX XYX XXYYYYYYYYYYX XYXXRYXRRXXX",
  "XYYYXXXXX XXYXXXYXXYYXXXXXXXXYX XYXYYXRYXRRXX",
  "YYYXXXX   XXXYXXXXYXXXXRRRRXYX  XYXXYYXRYXRRX",
  "YYXRRXXX   XXYXXXYXXXRRRRRRXYX XYXXXXYXXXXXXX",
  "YXRXRRXXX  XXYXXXYXXXXXXXXXYX  XYXXXXXRYXRYXR",
  "XYYRXRRXXX XXXYXXYXRRRRRRRXYX XYXXXXYXRYXRYXR",
  "XRYYRXRRXXX XXYXXYXXXXXXXXYX  XYXXRRYXRXXXXXX",
  "RRXRYYRXXXXXXXXXXXYX     XYXXXXXXXXXXXRYYRXRR");


const array string: queen_of_diamonds_pic is [](
  " XYYYYYYYYYXRRX  X X XXYX                    ",
  "  XYYYYYXXYXRRX X X X XYYX           R       ",
  "  XYYYYYYYYXRRX   XX XXXYX          RRR      ",
  "   XYYYYXXYXRRX  X  X XXXYX        RRRRR     ",
  "   XYYYYYYXXRX XX    XXXXXYX      RRRRRRR    ",
  "   XYYYXXYXRRXX       XRXXYX     RRRRRRRRR   ",
  "   XYYYYYXXRX  XXX XXXXRXXXYX    RRRRRRRRR   ",
  "   XYYXXYXRRX X XXX XXXRRXXYX   RRRRRRRRRRR  ",
  "   XYYYYXXRXX     X   XRRXXXYX RRRRRRRRRRRRR ",
  "  XYYXXYXRRX X    X   XRRRXXYX  RRRRRRRRRRR  ",
  "  XYYYYXXRX X X   X   XRRRXXYX   RRRRRRRRR   ",
  " XYYXYXXRRX XX   XXX  XRRRXXYX   RRRRRRRRR   ",
  "  XYYXXRRX  X         XRRRRXXYX   RRRRRRR    ",
  "   XXXRRX  XRX   XXX XYXRRRXXYX    RRRRR     ",
  "    XRRX   XXRX   X  XYXXRRXXYX     RRR      ",
  "   XRRX   XYYXXX    XYYX XRXXYX      R       ",
  "  XRRXXXXX XYYYXXXXXXYYX XXXXYX              ",
  " XRRXX XXXX XXXXYYYYXXX XXXXXYX      XXX     ",
  "XRRXX X XXXX    XXXX   XXX XXYX    XXYYXX    ",
  "RRX XX XXXXXXXX      XXX XXXYXX    XYXXYYX X ",
  "RXYX XXXX XX XXXXXXXXXX X XXXYX   XYYYYYX  XX",
  "XXXYX XXXXX X XXXX XXXXX XXX XYX   XXXYX  XYX",
  "XXYXYX XXXX X X X X X XXXXX XYYXX     XX XYYX",
  "XYXXXYX  XXX XXXX X XXXXXX XYYXXXX     XXYXX ",
  "YXXRXXYXX  XXXXXXX XXXXX  XYXYXX XX   XXXXX  ",
  "XXRXXYXYYXX   XXXXXXXX  XXYXXYX XXXX X   XXX ",
  "XRXXYXRXXYYXXX        XXYYXXXYX XXXXX  XXX X ",
  "RXXYXXXR XXYYYXXXXXXXXYYXXXRXYX XXXXYX  X XX ",
  "XXYXXRXXR XXXXYYYYYYYYXXYXXRXYXX XXYYXX  X X ",
  "XYXXYXRXXR RXYXXXXXXXXYYYXXR XYXXXYYXXXX X X ",
  "YXXXYXXRX R XXYXXXXXYYXXYXXR XYYXYYX X XX X  ",
  " X XXYXRXR R XYX RXXYYYYYXXR RXYYYXXXXXXXX   ",
  "XXXXXYXRX R XXYX RXXYXXXYXXRXXRXYXXX X X XX  ",
  " X X XYXXR R XYX RXXYYYYYXXXRRXYXXYXXXXXXXXX ",
  "XXXXXXYXR R XXYXXXXXXXXXXRRRYRXYXRXYXX X X XX",
  " X X XXYXR R XYXRRRRRRRRRYYYRXYXX RXYXXXXXXXX");


const array string: jack_of_diamonds_pic is [](
  "         XR RRR RR RR RR RRR RX              ",
  "          XR RR RR RR RR RR RX       R       ",
  "           XR   RR    RR   RX       RRR      ",
  "X           XRRRRRRRRRRRRRRX       RRRRR     ",
  "XX          XXXXXXXXXXXXXXXX      RRRRRRR    ",
  "XYX         XXXXXYX        XX    RRRRRRRRR   ",
  "XYX         XXXYXYX        XX    RRRRRRRRR   ",
  "XYX         XYXYXYX XXX XXXXYX  RRRRRRRRRRR  ",
  "XYX    X    XYXYXYXX XXX XXXYX RRRRRRRRRRRRR ",
  "XYX   XX    XYXYXYX    X   XYX  RRRRRRRRRRR  ",
  "XYX XXYX    XYXYXYX    X   XYX   RRRRRRRRR   ",
  "XXXXYYX     XYXYXYX    X   XYX   RRRRRRRRR   ",
  "RYYYXXX     XYXYXYX   XXX  XYX    RRRRRRR    ",
  "XYXXXX      XYXYXYX        XYXXX   RRRRR     ",
  "RYXX      XXYYXYXYX   XXX X YXYYX   RRR      ",
  "XYX      XYYXYXYXYXX      XXYYXYX    R       ",
  "RYX      XYXXYXXYXR X    X RXYYYX           X",
  "XYX      XYYYXYYXRRRRXXXXRRRRXXXXX         XR",
  "RYX      XXXXXXXXRRRRRRRRRRRXX XYXXX      XYX",
  "XYX    XXRXXX XXXXXRRRRRRRXXXXXXYX XXX    XYR",
  "RYX  XXXYXRXXXX XXXXXXXXXXXXX XXYXXXYYXX  XYX",
  "XYXXXXXXXYXRXXXXX XXXXXXXXX XXXXYX XYYXRXXXYR",
  "RYXXXXXXXXYXRXXXXXX X X X XXXRXXYXXXXYXRRRXYX",
  "XYXXXRXXXXXYXRXXXXXXXXXXXXXRXRXXYYX XYYXXRXYR",
  "XXX XXRXXXXXYXRXXRXRXRXRXRXRXRX XYXXXXYYYXXYX",
  "  X XYXRXXXXXYXRXXRYRYRYRYRYRYX XYYX XXXYYXYR",
  "XXX XXYXRXXXXXYXRXXRXRXRXRXRXRX XXYYXX XXXXYX",
  "  XXXYXYXRXXXXXYXRXXXRXRXRXRXRX XXXYYYXXX XYR",
  "XXXRRXYXXXYXXXXXYXRXXRXRXRXRXRX XX XXYYYXXXYX",
  " XX RXYXYYXRXXXXXYXRXXRYRYRYRYX XX X XXYYYXYR",
  "XYXRRRXYXXXRYXXXXXYXRXXRXRXRXRX XX XXYXXXXXYX",
  "XYX  RXYXYXRYRXXXXXYXRXXXRXRXRX XX XXXXYXRXYR",
  "RYXRRRXYXXXRYRYXX XXYXRXXRXRXRX XX XYYXYX XYX",
  "XYX  RXYXYXRYRXXXXXXRYXRXXRYRYXXXX XXXYXRRXYR",
  "RYXRRRXYXXXRYXX XXXYRRYXRXXRXRXXXXXYYXYXR XYX",
  "XYX  RXYXYXRXXXXXXRXYRRYXRXXRXX XXXXXYXRRRXYR");


const array string: king_of_clubs_pic is [](
  "                XYYYXYYYXYYYXYYYYYYYYX       ",
  "       XXX       XYXXXYXXXYXXXYYXYYYX        ",
  "      XXXXX       XRRRRRRRRRRRRXXXYX         ",
  "     XXXXXXX       XXXXXXXXXXXXRRRX        X ",
  "     XXXXXXX       XXXXXXXXXXXXXXXX       XXX",
  "     XXXXXXX      XX        X XXXXX      X XR",
  "      XXXXX      X X        X X XXX      X XR",
  "   XXX XXX XXX   X XXXX XXXXX X X X      X XR",
  "  XXXXXXXXXXXXX  XXXXX XXX XX X X X      X XR",
  " XXXXXXXXXXXXXXX X X   X    X X X X      X XR",
  " XXXXXXXXXXXXXXX X X   X    X X X X      X XR",
  " XXXXXXXXXXXXXXX X X   X    X X X X      X XR",
  "  XXXXX X XXXXX  X X  XXX   X X X X      X XR",
  "   XXX  X  XXX  X  XXX   XX X X X XXX    X XR",
  "       XXX      XXXX  XXX   X X X X  X   X XR",
  "      XXXXX      X X        X X  X X XX  X XR",
  "               XXX X X   X XX X XXX XXRXXX XR",
  "              X  X X X X X X XX X X XRRRRX XR",
  "              X X  X X X X XX X   XXRYRRRX XR",
  "           XXXX   X X XRX X  XRXXXRRYYRRRX XR",
  "        XXXXXXXXXXXXRXRRRXRXXRRRRXRRRRRYXX XR",
  "     XXXRRXYYXX XXYXXRRRRRRRRRRXXRYRRRRX X XR",
  "    XRRRRRRXYYXXXXXYXXXRRRRRRXXXRYYRRYX  X XR",
  "  XXR R R R XYYXX XYXYXXXRRXXXYXRRRRRX  XX XR",
  " XXXRRRRRRRRRXYYXXXXYXYXXXXXXYXRRRRYX  XXX XR",
  "RXXX R R R R RXYYXXXYXYYXXXXYYXRYRRRX XXXX XR",
  "RXXXRRRRRRRRRRXXYRXXXYXXYXXYXXRYYRRX  XXXX XR",
  "RXXXR R R R R XXXYRXXYXYYYYYYXRRRRYX XXRXX XR",
  "RXXXRRRRRXXXXRXXRXYXXXYXXXRXXXRRRRRX XXXXX XR",
  "XYYXXR RX    XXXXXXYXXYXYYYYYXRYRYX  XXRXX XR",
  "YYYYXRRX  XX  XXRRXYXXYXXXRXXRYYRRX XXXXXX XR",
  "XYYXXXRX XRRX XXXXXXYXXYXYYYXRRRRYX XXXXXXXXR",
  "XXXXXXXX XRRX XXRRRXYXXYXXRXXRRRRRX XXX  X  X",
  "XRRXXXXX  XX  XXXXXXXYXYXYYYXRRYRYX XX    XXX",
  "XXXXXXXXX    XXXXXXXXXXXXXXXXRYYRRX XX XX   X",
  "X  X  XXXXXXXRRX    XRRRXXXXXXRRRYX XX   XXXX");


const array string: queen_of_clubs_pic is [](
  "YYYYYYYYYYRXXR X X XX X                      ",
  "XYYYYYYYYYRXXR XX X XXX            XXX       ",
  " XYYYYYXXYRXXR X  XX XX           XXXXX      ",
  "  XYYYYXYRRXXR X X  X X          XXXXXXX     ",
  "  XYYYYYRRXXRR XX    XXX         XXXXXXX     ",
  "   XYYYYRRXXR  X      XX         XXXXXXX     ",
  "   XYXXYRXXXR  XXX XXXXRX         XXXXX      ",
  "   XYXYRRXXRR X XX  XXXRX      XXX XXX XXX   ",
  "  XYYYRRXXXR  X   X   XXRX    XXXXXXXXXXXXX  ",
  "  XYYYRRXXRR X    X   XXRX   XXXXXXXXXXXXXXX ",
  " XYXXRRXXRR  X    X   XXXRX  XXXXXXXXXXXXXXX ",
  "XYYXRRXXXR  X    XXX  XRXRRX XXXXXXXXXXXXXXX ",
  " XXRRXXXRR  X         XRRXRRX XXXXX X XXXXX  ",
  "   XXXXRR  XRX   XXX XXXRXXRRX XXX  X  XXX   ",
  "    XXXR   XXRX   X  XXXXRXXRRX    XXX       ",
  "   XXXRR  XXYXXX    XYXXXXRXXRRX  XXXXX      ",
  "  XXXRR XXRYRYXYXXXXYXRYYRXRRXXRX            ",
  " XXXRR X  XRYRRYXYXYRRYYRX XRRXXRX   XX      ",
  "XXXRXXXXXXXXRYYRRRRRYYYRXXXXXRRXRX  XRRXX    ",
  "XXRYYYXXXXX XXRYYYYYYRRX X XYXRXRX XRXXRRX   ",
  "XYYXYYYX  X  XXXRXXXRXX  XXYXYXRX XRRRRRX    ",
  "YYYYXYXYX X XXX XRRRX XXXXYYYXXX   XXXRX XXX ",
  "RRRRRXYYYXXXX X XRYRX X XYXYXXXYX     X XYYYX",
  "RRRRRRXYYXYXX X XRRRX XXYYYXRXXYXX XXX XYYXX ",
  "RRRRRRRXXYYYYXXXXXRXXXXYXYXRRXXYXXXYYYXXXXX  ",
  "YXYXYXRRRXXYXYYYYXXXYYYYXXXYRXXYXXYYYX X   X ",
  "XYXYXYXYXRRXXXYYYYYYYYXXXXXYRRXXYXXXXX  XXXX ",
  "YXYXXXXXXXXRRYXXXXXXXXXXYXXYRRXXXRRXRXX X  X ",
  "XYXXYYYYYYYXXRRYXXXXYXXYXXYRRRRXR  RXXXXXXXX ",
  "YXYYYXXXXXYYYXRRXXXXXYXYXXYRRRXYXR RRXRX   X ",
  "XYYXXXYXYXXXYYXRYXXXXXYXXXYRRXYYXXRRRRXXXXX  ",
  "RXXXYXYXYXYXXYYXRXXXXYXYXXYRRXYXYYXR  RXRX   ",
  "RRXXYXXXXXXYYXYXRYXXYXXXYXYRXYYXXXXXR RRXXX  ",
  "R RXXRRRRRXXXXYYXRXYXXXXXXYRXYXYYXRRXRRRRXRX ",
  "R  RXR   RRXYYXYXXXXXYYYXXXXXYXXXXR  XR  RXXX",
  "XRRRRX XX RXXXXYXRRXRRRRRXYYXYXYYXR X XR RRXR");


const array string: jack_of_clubs_pic is [](
  "        XRRXRRRXRXRRXRXRRRXRRX               ",
  "X        XRRXRRXRXRRXRXRRXRRX      XXX       ",
  "RX       XXRRXXXRXXXXRXXXRRX      XXXXX      ",
  "RRX     XGGXRRRRRRRRRRRRRRX      XXXXXXX     ",
  "RRRX    XGXXXXXXXXXXXXXXXXX      XXXXXXX     ",
  "XXXXX   GGXX        XYXYXYX      XXXXXXX     ",
  "YYYX   XGGXX        XYXYXYX       XXXXX      ",
  "XYYX   XXXYXXXX XXX XYXYXYX    XXX XXX XXX   ",
  "YYYX     XYXXX XXX XXYXYXYX   XXXXXXXXXXXXX  ",
  "XYYX     XYX   X    XYXYXYX  XXXXXXXXXXXXXXX ",
  "YYYX    XXYX   X    XYXYXYX  XXXXXXXXXXXXXXX ",
  "XYYX   XYXYX   X    XYXYXYX  XXXXXXXXXXXXXXX ",
  "YYYX   XYXYX  XXX   XYXYXYXX  XXXXX X XXXXX  ",
  "XXYX   XXXYX        XYXYXXYYX  XXX  X  XXX   ",
  "YYYX  XYYXY X XXX   XYXXXYYXX      XXX       ",
  "XXYX  XYXYYXX      XXYXYYXXXXXX   XXXXX      ",
  "YYYX  XYYYXXRX    XRXYXXYXXX X X             ",
  "YYYXX  XXXRXRRXXXXRRRXYYYXX XX RXX          X",
  "XYX  XXRXRXXRRRRXXRRRXXXXXXXYX RRRXX       XY",
  " X    XXRXRXRYYRXXXRXX  XX XYX RRYR XX    XYY",
  "XXXXX XRXRXXRRRRX XXX  XX XYYX RYYYR XXXXXYYY",
  "  XX  XXRXRXRYYRX  X  XX XYYYX YYRYY XXXXXYYY",
  "XXYX  XRXRXXRRRRXX   XX XYYXXX RYYYR XXXXXYYY",
  " XYX  XXRXRXRYYRXXX XX RXYYYYX RRYRR XXXXXYYY",
  "XYYX  XRXRXXRRRRX XXX RXYYXXXX RRRRR XXXXXYYY",
  " XYX XRXRXXXRYYRXX X XXYYYYYYX RRYRR XXXXXYYY",
  "XYYXXXXRXXXXRRRRXRX XRXYXYXXXX RYYYR XXXXXYYY",
  "YYYXXXXXXXXRYYRXYXRXRXYYYYYYYX YYRYY XXXXXYYY",
  "YYYXX XXX XRRRRXXYXRXYXYXXXXXX RYYYRXXXRRXYYY",
  "YYYX   X  XRYYRXYYYXYYYYYYYYYX RRYRRXRRRYXYYY",
  "YYYX X   XXRRRRXXXXYYXYXXXXXXX XXXXRRYYRRXYYY",
  "YYYXX X X XRYYRXYYYYYYYYYYYYYXX  XRRRRRRRXYYY",
  "YYYX X X XXRRRRXXYRXYXXXYXRYX   XRRYYRRXXXYYY",
  "YYYXX X X RYYRXYYYXRX   XRXX    XRRRRRXX XYYY",
  "YYYX X X XRRRRXXYYYX XXX X     XRYYRRX X XYYY",
  "YYYXX X XXRYYRXYXXX XRRRX X   XXRRRRX X XXYYY");


const array string: backside_pic is [](
  "   BBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB   ",
  "  B B                                                     B B  ",
  " B B  BBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB  B B ",
  "B B  B      B B      B B      B B      B B      B B      B  B B",
  "BB  B  BBBB  B  BBBB  B  BBBB  B  BBBB  B  BBBB  B  BBBB  B  BB",
  "B  B  B BB B   B BB B   B BB B   B BB B   B BB B   B BB B  B  B",
  "BB B B BBBB B B BBBB B B BBBB B B BBBB B B BBBB B B BBBB B B BB",
  "BB B BBB  BBB BBB  BBB BBB  BBB BBB  BBB BBB  BBB BBB  BBB B BB",
  "BB B BBB  BBB BBB  BBB BBB  BBB BBB  BBB BBB  BBB BBB  BBB B BB",
  "BB B B BBBB B B BBBB B B BBBB B B BBBB B B BBBB B B BBBB B B BB",
  "B  B  B BB B   B BB B   B BB B   B BB B   B BB B   B BB B  B  B",
  "BB BB  BBBB  B  BBBB  B  BBBB  B  BBBB  B  BBBB  B  BBBB  BB BB",
  "B  B B      B B      B B      B B      B B      B B      B B  B",
  "BB BB  BBBB  B  BBBB  B  BBBB  B  BBBB  B  BBBB  B  BBBB  BB BB",
  "B  B  B BB B   B BB B   B BB B   B BB B   B BB B   B BB B  B  B",
  "BB B B BBBB B B BBBB B B BBBB B B BBBB B B BBBB B B BBBB B B BB",
  "BB B BBB  BBB BBB  BBB BBB  BBB BBB  BBB BBB  BBB BBB  BBB B BB",
  "BB B BBB  BBB BBB  BBB BBB  BBB BBB  BBB BBB  BBB BBB  BBB B BB",
  "BB B B BBBB B B BBBB B B BBBB B B BBBB B B BBBB B B BBBB B B BB",
  "B  B  B BB B   B BB B   B BB B   B BB B   B BB B   B BB B  B  B",
  "BB BB  BBBB  B  BBBB  B  BBBB  B  BBBB  B  BBBB  B  BBBB  BB BB",
  "B  B B      B B      B B      B B      B B      B B      B B  B",
  "BB BB  BBBB  B  BBBB  B  BBBB  B  BBBB  B  BBBB  B  BBBB  BB BB",
  "B  B  B BB B   B BB B   B BB B   B BB B   B BB B   B BB B  B  B",
  "BB B B BBBB B B BBBB B B BBBB B B BBBB B B BBBB B B BBBB B B BB",
  "BB B BBB  BBB BBB  BBB BBB  BBB BBB  BBB BBB  BBB BBB  BBB B BB",
  "BB B BBB  BBB BBB  BBB BBB  BBB BBB  BBB BBB  BBB BBB  BBB B BB",
  "BB B B BBBB B B BBBB B B BBBB B B BBBB B B BBBB B B BBBB B B BB",
  "B  B  B BB B   B BB B   B BB B   B BB B   B BB B   B BB B  B  B",
  "BB BB  BBBB  B  BBBB  B  BBBB  B  BBBB  B  BBBB  B  BBBB  BB BB",
  "B  B B      B B      B B      B B      B B      B B      B B  B",
  "BB BB  BBBB  B  BBBB  B  BBBB  B  BBBB  B  BBBB  B  BBBB  BB BB",
  "B  B  B BB B   B BB B   B BB B   B BB B   B BB B   B BB B  B  B",
  "BB B B BBBB B B BBBB B B BBBB B B BBBB B B BBBB B B BBBB B B BB",
  "BB B BBB  BBB BBB  BBB BBB  BBB BBB  BBB BBB  BBB BBB  BBB B BB",
  "BB B BBB  BBB BBB  BBB BBB  BBB BBB  BBB BBB  BBB BBB  BBB B BB",
  "BB B B BBBB B B BBBB B B BBBB B B BBBB B B BBBB B B BBBB B B BB",
  "B  B  B BB B   B BB B   B BB B   B BB B   B BB B   B BB B  B  B",
  "BB BB  BBBB  B  BBBB  B  BBBB  B  BBBB  B  BBBB  B  BBBB  BB BB",
  "B  B B      B B      B B      B B      B B      B B      B B  B",
  "BB BB  BBBB  B  BBBB  B  BBBB  B  BBBB  B  BBBB  B  BBBB  BB BB",
  "B  B  B BB B   B BB B   B BB B   B BB B   B BB B   B BB B  B  B",
  "BB B B BBBB B B BBBB B B BBBB B B BBBB B B BBBB B B BBBB B B BB",
  "BB B BBB  BBB BBB  BBB BBB  BBB BBB  BBB BBB  BBB BBB  BBB B BB");

const type: suitSignPosition is array array integer;


const proc: drawPic (inout PRIMITIVE_WINDOW: pixmap,
    in integer: xPos, in integer: yPos, in array string: pattern,
    in integer: scale) is func
  local
    var integer: line is 0;
    var integer: column is 0;
    var char: ch is ' ';
    var color: col is black;
  begin
    for line range 1 to length(pattern) do
      for column range 1 to length(pattern[1]) do
        ch := pattern[line][column];
        if ch <> ' ' then
          col := charColor(ch, white);
          rect(pixmap, (xPos + column) * scale, (yPos + line) * scale,
              scale, scale, col);
        end if;
      end for;
    end for;
  end func;


const proc: drawPic2 (inout PRIMITIVE_WINDOW: pixmap,
    in integer: xPos, in integer: yPos, in array string: pattern,
    in integer: scale) is func
  local
    var integer: height is 0;
    var integer: width is 0;
    var integer: line is 0;
    var integer: column is 0;
    var char: ch is ' ';
    var color: col is black;
  begin
    height := height(pixmap) div scale;
    width := width(pixmap) div scale;
    for line range 1 to length(pattern) do
      for column range 1 to length(pattern[1]) do
        ch := pattern[line][column];
        if ch <> ' ' then
          col := charColor(ch, white);
          rect(pixmap, (xPos + column) * scale, (yPos + line) * scale,
              scale, scale, col);
          rect(pixmap, pred(width - xPos - column) * scale,
              pred(height - yPos - line) * scale,
              scale, scale, col);
        end if;
      end for;
    end for;
  end func;


const func PRIMITIVE_WINDOW: genPixmap (in array string: pattern,
    in array string: small_suit_sign, in array string: color_sign,
    in integer: scale) is func
  result
    var PRIMITIVE_WINDOW: pixmap is PRIMITIVE_WINDOW.value;
  local
    var integer: height is 0;
    var integer: width is 0;
  begin
    height := 2 * (length(pattern) + 12);
    width := length(pattern[1]) + 2 * 13;
    pixmap := newPixmap(width * scale, height * scale);
    clear(pixmap, black);
    rectTo(pixmap, 1 * scale, 1 * scale,
        pred(pred(width) * scale),
        pred(pred(height) * scale), white);
    rect(pixmap, scale, scale,
        scale, scale, light_gray);
    rect(pixmap, (width - 2) * scale, scale,
        scale, scale, light_gray);
    rect(pixmap, scale, (height - 2) * scale,
        scale, scale, light_gray);
    rect(pixmap, (width - 2) * scale, (height - 2) * scale,
        scale, scale, light_gray);
    rectTo(pixmap, 12 * scale, 11 * scale,
        pred((width - 12) * scale),
        pred((height - 11) * scale), black);
    rectTo(pixmap, 13 * scale, 12 * scale,
        pred((width - 13) * scale),
        pred((height - 12) * scale), white);
    drawPic2(pixmap, 12, 11, pattern, scale);
    drawPic2(pixmap,  1,  3, small_suit_sign, scale);
    drawPic2(pixmap,  1, 18, color_sign, scale);
  end func;


const func PRIMITIVE_WINDOW: genPixmap (in array string: big_suit_sign,
    in array string: small_suit_sign, in array string: color_sign,
    in suitSignPosition: positions, in integer: scale) is func
  result
    var PRIMITIVE_WINDOW: pixmap is PRIMITIVE_WINDOW.value;
  local
    var integer: height is 0;
    var integer: width is 0;
    var color: col is black;
    var integer: index is 0;
  begin
    height := 96;
    width := 71;
    pixmap := newPixmap(width * scale, height * scale);
    clear(pixmap, black);
    rectTo(pixmap, 1 * scale, 1 * scale,
        pred(pred(width) * scale),
        pred(pred(height) * scale), white);
    rect(pixmap, scale, scale,
        scale, scale, light_gray);
    rect(pixmap, (width - 2) * scale, scale,
        scale, scale, light_gray);
    rect(pixmap, scale, (height - 2) * scale,
        scale, scale, light_gray);
    rect(pixmap, (width - 2) * scale, (height - 2) * scale,
        scale, scale, light_gray);
    for index range 1 to length(positions) do
      if positions[index][3] = 2 then
        drawPic2(pixmap, positions[index][1], positions[index][2],
            big_suit_sign, scale);
      else
        drawPic(pixmap, positions[index][1], positions[index][2],
            big_suit_sign, scale);
      end if;
    end for;
    drawPic2(pixmap,  1,  3, small_suit_sign, scale);
    drawPic2(pixmap,  1, 18, color_sign, scale);
  end func;


(**
 *  Describes the suits of a french deck.
 *)
const type: cardSuit is new enum
    clubs, diamonds, hearts, spades
  end enum;

const func string: str (in cardSuit: suit) is
  return [] ("clubs", "diamonds", "hearts", "spades") [succ(ord(suit))];

const set of cardSuit: blackCardSuit is {clubs, spades};
const set of cardSuit: redCardSuit is {diamonds, hearts};


(**
 *  Describes the ranks of a french deck.
 *)
const type: cardRank is new enum
    two, three, four, five, six, seven, eight, nine, ten, jack, queen, king, ace
  end enum;

const func string: str (in cardRank: rank) is
  return [] ("two", "three", "four", "five", "six", "seven",
             "eight", "nine", "ten", "jack", "queen", "king", "ace") [succ(ord(rank))];


(**
 *  Create a pixmap with a card from the french deck.
 *  @return the created pixmap.
 *)
const func PRIMITIVE_WINDOW: cardPixmap (in cardSuit: suit, in cardRank: rank, in integer: scale) is func
  result
    var PRIMITIVE_WINDOW: pixmap is PRIMITIVE_WINDOW.value;
  local
    const suitSignPosition: ACE_POS   is []([](27, 39, 1));
    const suitSignPosition: TEN_POS   is []([](13,  8, 2), [](41,  8, 2), [](13, 28, 2), [](41, 28, 2), [](27, 18, 2));
    const suitSignPosition: NINE_POS  is []([](13,  8, 2), [](41,  8, 2), [](13, 28, 2), [](41, 28, 2), [](27, 39, 1));
    const suitSignPosition: EIGHT_POS is []([](13,  8, 2), [](41,  8, 2), [](13, 39, 1), [](41, 39, 1), [](27, 23, 2));
    const suitSignPosition: SEVEN_POS is []([](13,  8, 2), [](41,  8, 2), [](13, 39, 1), [](41, 39, 1), [](27, 23, 1));
    const suitSignPosition: SIX_POS   is []([](13,  8, 2), [](41,  8, 2), [](13, 39, 1), [](41, 39, 1));
    const suitSignPosition: FIVE_POS  is []([](13,  8, 2), [](41,  8, 2), [](27, 39, 1));
    const suitSignPosition: FOUR_POS  is []([](13,  8, 2), [](41,  8, 2));
    const suitSignPosition: THREE_POS is []([](27,  8, 2), [](27, 39, 1));
    const suitSignPosition: TWO_POS   is []([](27,  8, 2));
  begin
    case suit of
      when {clubs}:
        case rank of
          when {ace}:   pixmap := genPixmap(big_clubs_sign,     black_A_sign,  small_clubs_sign, ACE_POS,   scale);
          when {king}:  pixmap := genPixmap(king_of_clubs_pic,  black_K_sign,  small_clubs_sign, scale);
          when {queen}: pixmap := genPixmap(queen_of_clubs_pic, black_Q_sign,  small_clubs_sign, scale);
          when {jack}:  pixmap := genPixmap(jack_of_clubs_pic,  black_J_sign,  small_clubs_sign, scale);
          when {ten}:   pixmap := genPixmap(big_clubs_sign,     black_10_sign, small_clubs_sign, TEN_POS,   scale);
          when {nine}:  pixmap := genPixmap(big_clubs_sign,     black_9_sign,  small_clubs_sign, NINE_POS,  scale);
          when {eight}: pixmap := genPixmap(big_clubs_sign,     black_8_sign,  small_clubs_sign, EIGHT_POS, scale);
          when {seven}: pixmap := genPixmap(big_clubs_sign,     black_7_sign,  small_clubs_sign, SEVEN_POS, scale);
          when {six}:   pixmap := genPixmap(big_clubs_sign,     black_6_sign,  small_clubs_sign, SIX_POS,   scale);
          when {five}:  pixmap := genPixmap(big_clubs_sign,     black_5_sign,  small_clubs_sign, FIVE_POS,  scale);
          when {four}:  pixmap := genPixmap(big_clubs_sign,     black_4_sign,  small_clubs_sign, FOUR_POS,  scale);
          when {three}: pixmap := genPixmap(big_clubs_sign,     black_3_sign,  small_clubs_sign, THREE_POS, scale);
          when {two}:   pixmap := genPixmap(big_clubs_sign,     black_2_sign,  small_clubs_sign, TWO_POS,   scale);
        end case;
      when {diamonds}:
        case rank of
          when {ace}:   pixmap := genPixmap(big_diamonds_sign,     red_A_sign,  small_diamonds_sign, ACE_POS,   scale);
          when {king}:  pixmap := genPixmap(king_of_diamonds_pic,  red_K_sign,  small_diamonds_sign, scale);
          when {queen}: pixmap := genPixmap(queen_of_diamonds_pic, red_Q_sign,  small_diamonds_sign, scale);
          when {jack}:  pixmap := genPixmap(jack_of_diamonds_pic,  red_J_sign,  small_diamonds_sign, scale);
          when {ten}:   pixmap := genPixmap(big_diamonds_sign,     red_10_sign, small_diamonds_sign, TEN_POS,   scale);
          when {nine}:  pixmap := genPixmap(big_diamonds_sign,     red_9_sign,  small_diamonds_sign, NINE_POS,  scale);
          when {eight}: pixmap := genPixmap(big_diamonds_sign,     red_8_sign,  small_diamonds_sign, EIGHT_POS, scale);
          when {seven}: pixmap := genPixmap(big_diamonds_sign,     red_7_sign,  small_diamonds_sign, SEVEN_POS, scale);
          when {six}:   pixmap := genPixmap(big_diamonds_sign,     red_6_sign,  small_diamonds_sign, SIX_POS,   scale);
          when {five}:  pixmap := genPixmap(big_diamonds_sign,     red_5_sign,  small_diamonds_sign, FIVE_POS,  scale);
          when {four}:  pixmap := genPixmap(big_diamonds_sign,     red_4_sign,  small_diamonds_sign, FOUR_POS,  scale);
          when {three}: pixmap := genPixmap(big_diamonds_sign,     red_3_sign,  small_diamonds_sign, THREE_POS, scale);
          when {two}:   pixmap := genPixmap(big_diamonds_sign,     red_2_sign,  small_diamonds_sign, TWO_POS,   scale);
        end case;
      when {hearts}:
        case rank of
          when {ace}:   pixmap := genPixmap(big_hearts_sign,     red_A_sign,  small_hearts_sign, ACE_POS,   scale);
          when {king}:  pixmap := genPixmap(king_of_hearts_pic,  red_K_sign,  small_hearts_sign, scale);
          when {queen}: pixmap := genPixmap(queen_of_hearts_pic, red_Q_sign,  small_hearts_sign, scale);
          when {jack}:  pixmap := genPixmap(jack_of_hearts_pic,  red_J_sign,  small_hearts_sign, scale);
          when {ten}:   pixmap := genPixmap(big_hearts_sign,     red_10_sign, small_hearts_sign, TEN_POS,   scale);
          when {nine}:  pixmap := genPixmap(big_hearts_sign,     red_9_sign,  small_hearts_sign, NINE_POS,  scale);
          when {eight}: pixmap := genPixmap(big_hearts_sign,     red_8_sign,  small_hearts_sign, EIGHT_POS, scale);
          when {seven}: pixmap := genPixmap(big_hearts_sign,     red_7_sign,  small_hearts_sign, SEVEN_POS, scale);
          when {six}:   pixmap := genPixmap(big_hearts_sign,     red_6_sign,  small_hearts_sign, SIX_POS,   scale);
          when {five}:  pixmap := genPixmap(big_hearts_sign,     red_5_sign,  small_hearts_sign, FIVE_POS,  scale);
          when {four}:  pixmap := genPixmap(big_hearts_sign,     red_4_sign,  small_hearts_sign, FOUR_POS,  scale);
          when {three}: pixmap := genPixmap(big_hearts_sign,     red_3_sign,  small_hearts_sign, THREE_POS, scale);
          when {two}:   pixmap := genPixmap(big_hearts_sign,     red_2_sign,  small_hearts_sign, TWO_POS,   scale);
        end case;
      when {spades}:
        case rank of
          when {ace}:   pixmap := genPixmap(big_spades_sign,     black_A_sign,  small_spades_sign, ACE_POS,   scale);
          when {king}:  pixmap := genPixmap(king_of_spades_pic,  black_K_sign,  small_spades_sign, scale);
          when {queen}: pixmap := genPixmap(queen_of_spades_pic, black_Q_sign,  small_spades_sign, scale);
          when {jack}:  pixmap := genPixmap(jack_of_spades_pic,  black_J_sign,  small_spades_sign, scale);
          when {ten}:   pixmap := genPixmap(big_spades_sign,     black_10_sign, small_spades_sign, TEN_POS,   scale);
          when {nine}:  pixmap := genPixmap(big_spades_sign,     black_9_sign,  small_spades_sign, NINE_POS,  scale);
          when {eight}: pixmap := genPixmap(big_spades_sign,     black_8_sign,  small_spades_sign, EIGHT_POS, scale);
          when {seven}: pixmap := genPixmap(big_spades_sign,     black_7_sign,  small_spades_sign, SEVEN_POS, scale);
          when {six}:   pixmap := genPixmap(big_spades_sign,     black_6_sign,  small_spades_sign, SIX_POS,   scale);
          when {five}:  pixmap := genPixmap(big_spades_sign,     black_5_sign,  small_spades_sign, FIVE_POS,  scale);
          when {four}:  pixmap := genPixmap(big_spades_sign,     black_4_sign,  small_spades_sign, FOUR_POS,  scale);
          when {three}: pixmap := genPixmap(big_spades_sign,     black_3_sign,  small_spades_sign, THREE_POS, scale);
          when {two}:   pixmap := genPixmap(big_spades_sign,     black_2_sign,  small_spades_sign, TWO_POS,   scale);
        end case;
    end case;
  end func;


(**
 *  Create a pixmap with the backside of a card.
 *  @return the created pixmap.
 *)
const func PRIMITIVE_WINDOW: cardBackside (in integer: scale) is func
  result
    var PRIMITIVE_WINDOW: pixmap is PRIMITIVE_WINDOW.value;
  local
    var integer: height is 0;
    var integer: width is 0;
    var integer: xPos is 0;
    var integer: yPos is 0;
  begin
    height := 96;
    width := 71;
    pixmap := newPixmap(width * scale, height * scale);
    clear(pixmap, black);
    rectTo(pixmap, 1 * scale, 1 * scale,
        pred(pred(width) * scale),
        pred(pred(height) * scale), white);
    rect(pixmap, scale, scale,
        scale, scale, light_gray);
    rect(pixmap, (width - 2) * scale, scale,
        scale, scale, light_gray);
    rect(pixmap, scale, (height - 2) * scale,
        scale, scale, light_gray);
    rect(pixmap, (width - 2) * scale, (height - 2) * scale,
        scale, scale, light_gray);
    drawPic2(pixmap, 3, 3, backside_pic, scale);
  end func;
