pop-fe.py

#!/usr/bin/env python
# coding: utf-8
#
# A utility to automate building and installing PSX games onto different
# systems.
# The current directory where you run this utility from needs to be writable
# so that we can use it to store temporary files during the conversing process.

# clean ppf patches for libcrypt
# https://archive.org/details/lib-crypt-ppf-patches

try:
    from PIL import Image, ImageDraw, ImageFont
except:
    print('You need to install python module pillow')
import argparse
import datetime
import hashlib
import io
import os
import re
import random
import shutil
import struct
import sys
have_pycdlib = False
try:
    import pycdlib
    have_pycdlib = True
except:
    True
have_iso9660 = False
try:
    import iso9660      # python-pycdio
    have_iso9660 = True
except:
    True
have_pytube = False
try:
    from pytube import YouTube
    from pytube.contrib.search import Search
    have_pytube = True
except:
    True
try:
    import rarfile
except:
    print('rarfile is not installed.\nYou should install requests by running:\npip3 install rarfile')
try:
    import PyPDF2
except:
    print('PyPDF2 is not installed.\nYou should install requests by running:\npip3 install PyPDF2')
try:
    import requests
except:
    print('requests is not installed.\nYou should install requests by running:\npip3 install requests')
import subprocess
import zipfile
try:
    from vmp import encode_vmp
except:
    True
from pathlib import Path
from bchunk import bchunk
from document import create_document
from gamedb import games, libcrypt, themes, ppf_fixes, gameid_translation, gameid_by_md5sum
try:
    from make_isoedat import pack
except:
    True
from cue import parse_ccd, ccd2cue, write_cue
from popstation import popstation, GenerateSFO
from ppf import ApplyPPF
from riff import copy_riff, create_riff, parse_riff
try:
    from theme_ascii import create_ascii_pic0, create_ascii_pic1
    from theme_dotpainting import create_dotpainting_pic0, create_dotpainting_pic1
    from theme_opencv import create_oilpainting_pic0, create_oilpainting_pic1, create_watercolor_pic0, create_watercolor_pic1, create_colorsketch_pic0, create_colorsketch_pic1
except:
    print('You need to install python module pillow and opencv-contrib-python')
    
temp_files = []  

i0 = bytes([
 0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a,
 0x00, 0x00, 0x00, 0x0d, 0x49, 0x48, 0x44, 0x52,
 0x00, 0x00, 0x00, 0xb0, 0x00, 0x00, 0x00, 0xb0,
 0x08, 0x06, 0x00, 0x00, 0x00, 0xaf, 0xb7, 0xe4,
 0x5e, 0x00, 0x00, 0x10, 0xa6, 0x7a, 0x54, 0x58,
 0x74, 0x52, 0x61, 0x77, 0x20, 0x70, 0x72, 0x6f,
 0x66, 0x69, 0x6c, 0x65, 0x20, 0x74, 0x79, 0x70,
 0x65, 0x20, 0x65, 0x78, 0x69, 0x66, 0x00, 0x00,
 0x78, 0xda, 0xed, 0x9a, 0x59, 0x96, 0xe4, 0xb8,
 0x0d, 0x45, 0xff, 0xb9, 0x0a, 0x2f, 0x81, 0x33,
 0xc8, 0xe5, 0x70, 0x3c, 0xc7, 0x3b, 0xf0, 0xf2,
 0x7d, 0x41, 0x29, 0xa2, 0x72, 0x1e, 0xba, 0xed,
 0xbf, 0xce, 0xac, 0x0a, 0x45, 0x4a, 0x14, 0x08,
 0xe2, 0x01, 0x0f, 0x00, 0x25, 0xb3, 0xfe, 0xf3,
 0xef, 0x6d, 0xfe, 0xc5, 0x4f, 0xf6, 0x36, 0x9b,
 0x98, 0xa4, 0xe4, 0x9a, 0xb3, 0xe5, 0x27, 0xd6,
 0x58, 0x7d, 0xe3, 0x4b, 0xb1, 0xd7, 0x4f, 0x3b,
 0x9f, 0xce, 0xc6, 0xf3, 0x79, 0x7e, 0xfa, 0x7d,
 0x89, 0xbf, 0x5f, 0x9d, 0x37, 0xcf, 0x0b, 0x9e,
 0x53, 0x81, 0x63, 0xb8, 0xfe, 0x2c, 0xf9, 0x1e,
 0xff, 0x38, 0xef, 0x9e, 0x02, 0xae, 0x43, 0xe3,
 0x5b, 0x7a, 0x21, 0xa8, 0x8c, 0xfb, 0x42, 0x7f,
 0x7d, 0xa1, 0xc6, 0x5b, 0x7e, 0x79, 0x23, 0xc8,
 0x5f, 0x87, 0xa0, 0x1a, 0xe9, 0xf7, 0x79, 0x0b,
 0xaa, 0xb7, 0xa0, 0xe0, 0xaf, 0x0b, 0xee, 0x16,
 0xd0, 0xae, 0x65, 0xd9, 0x5c, 0x8b, 0xbc, 0x5a,
 0xda, 0xba, 0x8e, 0xf3, 0xb1, 0x92, 0x72, 0xfd,
 0x37, 0xfa, 0x11, 0xcb, 0x6b, 0xb5, 0xdf, 0xfd,
 0x2d, 0x58, 0x6f, 0x26, 0xe6, 0x09, 0xde, 0xaf,
 0xe0, 0x82, 0xe5, 0x33, 0x04, 0x7f, 0x29, 0x10,
 0xf4, 0x7f, 0x34, 0xa1, 0x9d, 0x2f, 0xfa, 0xc9,
 0x15, 0x06, 0x45, 0xbe, 0xc7, 0xfb, 0xd3, 0xdf,
 0xc2, 0x30, 0xc8, 0x47, 0x76, 0x7a, 0xfe, 0x54,
 0x34, 0xda, 0xaa, 0x6a, 0xfc, 0x70, 0xd0, 0x2b,
 0x54, 0x9e, 0xdf, 0xdc, 0xc7, 0xe7, 0xcd, 0x5b,
 0xb4, 0xa2, 0xbf, 0x87, 0x84, 0x37, 0x46, 0xce,
 0xcf, 0xe3, 0x87, 0xe7, 0x8d, 0x4b, 0x6f, 0x2e,
 0x84, 0xe7, 0x3c, 0xfe, 0xe5, 0xcc, 0xb1, 0xdc,
 0xdf, 0xfc, 0xeb, 0xf3, 0xdb, 0xba, 0x7c, 0x69,
 0xf4, 0xc6, 0xfa, 0xfa, 0x7f, 0xef, 0x59, 0xf6,
 0x59, 0x33, 0xab, 0x68, 0x31, 0x63, 0xea, 0x7c,
 0x2f, 0xea, 0xb1, 0x94, 0xf3, 0x8d, 0x71, 0xb8,
 0x61, 0xd4, 0xa9, 0x8b, 0x41, 0xb5, 0x6c, 0x85,
 0xff, 0x09, 0x11, 0x72, 0x7e, 0x2b, 0xbf, 0x05,
 0xaf, 0x1e, 0xb8, 0xc2, 0xb4, 0x03, 0x67, 0xee,
 0x7c, 0xaf, 0xce, 0x03, 0xd7, 0x76, 0xd1, 0x4d,
 0xd7, 0xdc, 0x76, 0xeb, 0x1c, 0x87, 0x1b, 0xa8,
 0x18, 0xfd, 0x32, 0x5e, 0xf8, 0xe2, 0xfd, 0xf0,
 0xe1, 0x9c, 0x2c, 0x41, 0x7c, 0xf5, 0x23, 0x5c,
 0xf8, 0xf1, 0xeb, 0xb6, 0x97, 0x50, 0xc3, 0x0c,
 0x05, 0x6c, 0xc7, 0x81, 0x1d, 0x34, 0x9f, 0xba,
 0xb8, 0x33, 0x6d, 0xb5, 0xc3, 0x9c, 0xd9, 0x0a,
 0x33, 0x4f, 0xc7, 0x50, 0xef, 0x10, 0xe6, 0xb8,
 0xe5, 0xd7, 0xbf, 0xe6, 0xb7, 0x37, 0xec, 0xad,
 0xa1, 0xe0, 0x9c, 0x2d, 0x4f, 0x5b, 0xa1, 0x97,
 0xf7, 0x6a, 0x6c, 0xd4, 0x50, 0xe4, 0xf4, 0x93,
 0x61, 0x20, 0xe2, 0xf6, 0x6d, 0xd4, 0x74, 0x0c,
 0xfc, 0xf8, 0x7d, 0xfb, 0xa3, 0xb8, 0x06, 0x10,
 0x4c, 0x6a, 0x65, 0x0d, 0x91, 0x8a, 0x61, 0xfb,
 0x25, 0xa2, 0x27, 0xf7, 0x87, 0x09, 0xc2, 0x01,
 0x3a, 0x30, 0x30, 0x71, 0xbc, 0x62, 0xd0, 0xc9,
 0xbc, 0x05, 0x60, 0x22, 0xa6, 0x4e, 0x28, 0xe3,
 0x02, 0x08, 0x80, 0x9a, 0x0b, 0xc9, 0x65, 0x67,
 0xc5, 0x7b, 0x71, 0x0e, 0x43, 0x16, 0x00, 0x6a,
 0xa8, 0x4e, 0x00, 0xf9, 0x0e, 0x02, 0x2e, 0x25,
 0x3f, 0x51, 0xd2, 0xc7, 0x10, 0x32, 0xd8, 0x14,
 0xaf, 0x53, 0x73, 0x8b, 0xb8, 0x33, 0xd4, 0x27,
 0xcf, 0x69, 0xc3, 0x79, 0xc8, 0x0c, 0x24, 0x52,
 0xc8, 0x41, 0xc0, 0xa6, 0x86, 0x06, 0x58, 0x31,
 0x26, 0xfc, 0x47, 0x62, 0xc1, 0x87, 0x5a, 0x0a,
 0x29, 0xa6, 0x94, 0x72, 0x92, 0x54, 0x52, 0x4d,
 0x2d, 0x87, 0x1c, 0x73, 0xca, 0x39, 0x4b, 0x56,
 0x52, 0x6c, 0x12, 0x24, 0x1a, 0x49, 0x92, 0x45,
 0xa4, 0x48, 0x95, 0x56, 0x42, 0x89, 0x25, 0x95,
 0x5c, 0xa4, 0x94, 0x52, 0x4b, 0xab, 0xbe, 0x06,
 0x48, 0x33, 0xd5, 0x5c, 0xa5, 0x96, 0x5a, 0x6b,
 0x6b, 0xcc, 0xd9, 0x90, 0xdc, 0xb8, 0xbb, 0x31,
 0xa0, 0xb5, 0xee, 0x7b, 0xe8, 0xb1, 0x27, 0xd3,
 0x73, 0x97, 0x5e, 0x7a, 0xed, 0x6d, 0xe0, 0x3e,
 0x23, 0x8e, 0x34, 0xf2, 0x90, 0x51, 0x46, 0x1d,
 0x6d, 0xfa, 0x19, 0x26, 0xfc, 0x31, 0xf3, 0x94,
 0x59, 0x66, 0x9d, 0x6d, 0xb9, 0x85, 0x2b, 0xad,
 0xb8, 0xd2, 0xca, 0x4b, 0x56, 0x59, 0x75, 0xb5,
 0x8d, 0xab, 0xed, 0x60, 0x76, 0xdc, 0x69, 0xe7,
 0x2d, 0xbb, 0xec, 0xba, 0xdb, 0x13, 0xb5, 0x1b,
 0xd6, 0x77, 0xbf, 0xbf, 0x40, 0xcd, 0xdd, 0xa8,
 0xf9, 0x83, 0x94, 0x0e, 0x94, 0x27, 0x6a, 0x9c,
 0x15, 0x79, 0x88, 0x70, 0x4a, 0x27, 0x49, 0x31,
 0x03, 0x30, 0x6f, 0xa2, 0x03, 0x71, 0x51, 0x08,
 0x70, 0x68, 0xaf, 0x98, 0xd9, 0xe2, 0x62, 0xf4,
 0x8a, 0x9c, 0x62, 0x66, 0xab, 0x27, 0x2a, 0x92,
 0x47, 0xc9, 0xa4, 0x98, 0x4d, 0xa7, 0x88, 0x81,
 0x60, 0x5c, 0xce, 0xa7, 0xed, 0x1e, 0xd8, 0x19,
 0x7f, 0x21, 0xaa, 0xc8, 0xfd, 0x2d, 0xdc, 0x8c,
 0xc4, 0x57, 0xb8, 0xf9, 0xbf, 0x8a, 0x9c, 0x51,
 0xe8, 0x7e, 0x89, 0xdc, 0x7b, 0xdc, 0x3e, 0x42,
 0x6d, 0x6a, 0x1a, 0x1a, 0x07, 0xb1, 0x2b, 0x0a,
 0xd5, 0xa8, 0x36, 0x10, 0x7d, 0x50, 0xd1, 0x86,
 0xcb, 0x8a, 0x80, 0xc8, 0x76, 0x21, 0xb7, 0xee,
 0x16, 0xb7, 0xe4, 0xd9, 0x51, 0x26, 0x98, 0x50,
 0x35, 0x09, 0x84, 0x92, 0xdc, 0x6a, 0x71, 0xe7,
 0xb6, 0x71, 0xcb, 0xe1, 0x64, 0xdb, 0xbc, 0x47,
 0xe8, 0xcd, 0x66, 0xec, 0x67, 0x73, 0x27, 0x22,
 0x32, 0x8b, 0x98, 0x7b, 0x14, 0x91, 0xd1, 0x43,
 0x1a, 0xd1, 0x37, 0x98, 0x6f, 0xe7, 0x94, 0x2c,
 0x86, 0xb5, 0xca, 0x90, 0x92, 0x56, 0x2c, 0x63,
 0x4b, 0xeb, 0xdc, 0xdf, 0x3a, 0xea, 0xe4, 0xb9,
 0xec, 0xda, 0x76, 0x0e, 0xe7, 0xc7, 0xcc, 0x6b,
 0xf4, 0xd6, 0xd3, 0x8c, 0xcc, 0x22, 0x98, 0x78,
 0xb8, 0x5c, 0x26, 0x80, 0x42, 0xa1, 0x20, 0x86,
 0x94, 0x51, 0x56, 0xaf, 0xa6, 0xad, 0xbc, 0x97,
 0x6f, 0x32, 0x52, 0xae, 0x21, 0xa6, 0x5a, 0x77,
 0x8c, 0xd3, 0x41, 0x72, 0x69, 0x62, 0xa1, 0x01,
 0x9a, 0x55, 0x3d, 0xd7, 0x4d, 0x2b, 0x7d, 0xc9,
 0xae, 0x64, 0x75, 0x4c, 0x3c, 0x59, 0x62, 0x09,
 0xb1, 0x4d, 0x28, 0xaa, 0xba, 0x85, 0x99, 0xcc,
 0xb2, 0x65, 0x8f, 0xee, 0x6a, 0x4e, 0xd8, 0xd0,
 0x63, 0x8b, 0xd5, 0xd3, 0x98, 0x1d, 0xc1, 0x75,
 0xc3, 0x08, 0xc1, 0xa5, 0xd0, 0x5a, 0x19, 0x24,
 0x03, 0xd2, 0x78, 0x8e, 0xe4, 0x04, 0x97, 0x76,
 0xa8, 0x23, 0x10, 0x2d, 0x33, 0xef, 0xb4, 0xaa,
 0x9d, 0x73, 0x35, 0xe0, 0x07, 0x3b, 0x97, 0x57,
 0x4b, 0x0b, 0x7f, 0x8b, 0x33, 0x82, 0x84, 0xdb,
 0x65, 0xed, 0xb0, 0x57, 0xcb, 0xc5, 0x86, 0x55,
 0x02, 0xb3, 0xa7, 0x2e, 0xcb, 0xce, 0x23, 0xcc,
 0xb6, 0x23, 0xb4, 0x83, 0x92, 0x1e, 0x07, 0xfa,
 0xeb, 0x11, 0xce, 0xc6, 0xaa, 0x8e, 0x08, 0x51,
 0x17, 0xdf, 0x5b, 0x00, 0x42, 0x11, 0x2a, 0xb5,
 0xed, 0xba, 0xae, 0xf9, 0xdb, 0xb9, 0x01, 0x60,
 0xe7, 0x7d, 0x93, 0x6d, 0x7b, 0xca, 0x5e, 0xd2,
 0x9f, 0x93, 0xc5, 0x6d, 0x7e, 0x32, 0xdb, 0x4f,
 0x26, 0x33, 0x3f, 0x99, 0xed, 0x9f, 0xa5, 0xfd,
 0xb3, 0xb4, 0x7f, 0x96, 0xf6, 0xcf, 0xd2, 0xfe,
 0xd6, 0xd2, 0x52, 0xda, 0xa5, 0x07, 0xb2, 0x81,
 0x76, 0x87, 0xb9, 0xb5, 0xe0, 0xb9, 0x5e, 0x6b,
 0x38, 0xc2, 0xa8, 0xd2, 0x26, 0x1d, 0xd4, 0xa4,
 0x3c, 0x2e, 0xd3, 0x49, 0x4a, 0xa5, 0xe6, 0xd8,
 0x61, 0x5a, 0x4f, 0xc9, 0x30, 0xa9, 0xee, 0x28,
 0x15, 0xf6, 0x8a, 0xa2, 0x73, 0x6a, 0xae, 0x0c,
 0xd4, 0x2e, 0x3b, 0xa0, 0x36, 0xb9, 0xdb, 0x8d,
 0x4e, 0xda, 0x9f, 0x89, 0x6c, 0x46, 0x26, 0x5d,
 0x75, 0x4a, 0x5b, 0x6d, 0x98, 0x3a, 0x43, 0x26,
 0xa7, 0x6a, 0xff, 0x25, 0xd3, 0xa5, 0xe5, 0x27,
 0x8b, 0xad, 0xcb, 0x95, 0xed, 0xc8, 0xe1, 0x95,
 0x04, 0x31, 0x46, 0x74, 0xc2, 0x27, 0x39, 0x81,
 0xac, 0x40, 0x25, 0xbf, 0xd6, 0xd4, 0x1b, 0x96,
 0x90, 0x32, 0xc8, 0x88, 0xcb, 0xf7, 0x95, 0xb0,
 0x91, 0x1b, 0x52, 0xd0, 0x89, 0x72, 0x83, 0xc4,
 0x45, 0x62, 0xe8, 0xd4, 0x05, 0x63, 0x93, 0xcc,
 0x50, 0xa4, 0xd6, 0xe1, 0xf7, 0x68, 0x2b, 0x90,
 0xd2, 0x33, 0xfd, 0x5f, 0x92, 0xee, 0xc8, 0x9b,
 0x98, 0x87, 0x14, 0x97, 0xc4, 0xb5, 0x12, 0xa5,
 0x91, 0x77, 0x56, 0x22, 0xaf, 0x51, 0x52, 0x58,
 0x4d, 0x77, 0xcc, 0x4b, 0x1d, 0x32, 0x54, 0x31,
 0xa9, 0x18, 0x29, 0xad, 0x22, 0x54, 0x2d, 0x58,
 0x39, 0x87, 0x21, 0x64, 0x9f, 0x58, 0x25, 0xce,
 0xb2, 0x52, 0x2c, 0x79, 0xd5, 0x54, 0x22, 0x08,
 0x78, 0xf4, 0x09, 0xa2, 0xad, 0x87, 0xb6, 0xa2,
 0xf4, 0x18, 0x11, 0x09, 0x4b, 0x3b, 0xda, 0x5c,
 0x76, 0x19, 0x9d, 0xd2, 0x65, 0xda, 0x3e, 0x3c,
 0x99, 0x57, 0x06, 0x59, 0xda, 0xb9, 0x0a, 0x5a,
 0x89, 0x59, 0x74, 0x82, 0xed, 0x17, 0x8d, 0xb9,
 0x9f, 0x7d, 0xf7, 0xb4, 0x13, 0xb5, 0xc7, 0x8c,
 0x6d, 0x15, 0xb3, 0x36, 0x35, 0x4d, 0xce, 0x63,
 0x53, 0xc0, 0xe4, 0xbe, 0x4a, 0x46, 0x12, 0x86,
 0x25, 0xc5, 0xf5, 0xa4, 0x19, 0xcd, 0x02, 0x51,
 0xc9, 0x3d, 0x2d, 0x5b, 0x97, 0xcd, 0xcb, 0x8f,
 0xba, 0xc0, 0xb2, 0x75, 0x3a, 0xfc, 0xa1, 0x06,
 0x72, 0x91, 0xaa, 0x29, 0x02, 0xff, 0x9a, 0x3d,
 0xaa, 0x4e, 0x52, 0x9d, 0xfe, 0xed, 0x28, 0x00,
 0xc0, 0x6d, 0x77, 0xd6, 0xd5, 0x92, 0x54, 0x0c,
 0xd8, 0xc5, 0x6d, 0x5a, 0x64, 0xbb, 0xc5, 0xe3,
 0x4b, 0x4d, 0x73, 0x76, 0x3e, 0xd0, 0x53, 0xcc,
 0xa5, 0x26, 0x1b, 0x83, 0xc6, 0x3d, 0xcc, 0xc2,
 0x21, 0x40, 0x93, 0x12, 0x57, 0x2f, 0xd6, 0x35,
 0xea, 0x06, 0xd0, 0x0a, 0xca, 0xd1, 0xba, 0xd5,
 0x8f, 0xb7, 0xd8, 0xea, 0xe6, 0xf3, 0x8e, 0x85,
 0xcf, 0x52, 0x8b, 0xad, 0x19, 0xd4, 0xdb, 0xbc,
 0xa8, 0x35, 0xf1, 0x1b, 0x73, 0x8a, 0x82, 0x71,
 0xdc, 0xd2, 0x47, 0xc9, 0xc7, 0x67, 0xc3, 0x44,
 0x3a, 0xdd, 0xf1, 0x73, 0x86, 0x0f, 0xe5, 0xbf,
 0x96, 0x7e, 0x3c, 0xfb, 0x83, 0x09, 0x1e, 0xf2,
 0x1f, 0xd2, 0xdf, 0xc9, 0x7e, 0xab, 0xbd, 0xf9,
 0x8d, 0xfa, 0x5f, 0x69, 0x6f, 0x7e, 0xa3, 0xfe,
 0x57, 0xda, 0x9b, 0xdf, 0xa8, 0xff, 0x95, 0xf6,
 0xe6, 0x37, 0xea, 0x7f, 0xa5, 0xbd, 0x79, 0xa3,
 0x7e, 0x8d, 0xd4, 0xd7, 0xaf, 0x85, 0xf7, 0x4b,
 0xf8, 0x1e, 0x44, 0xf9, 0x6c, 0x04, 0x38, 0x8d,
 0x01, 0x34, 0xe2, 0x89, 0x8b, 0x8c, 0xa7, 0x52,
 0xfb, 0xd5, 0x92, 0xad, 0x59, 0xd2, 0x26, 0x4e,
 0xb7, 0x6a, 0x0e, 0xf8, 0x6b, 0xaa, 0x28, 0xda,
 0xb2, 0x32, 0x17, 0xbd, 0x5f, 0xa3, 0x66, 0xcd,
 0xae, 0xd3, 0x78, 0xa8, 0x5e, 0xf9, 0x08, 0x0c,
 0x8e, 0x0a, 0xb1, 0x07, 0x97, 0xa7, 0x1f, 0xae,
 0xb5, 0xd4, 0x29, 0x1c, 0x69, 0x3d, 0xac, 0xd1,
 0x5a, 0x72, 0x68, 0x6c, 0x68, 0x05, 0xbd, 0xa9,
 0x2e, 0x57, 0xa7, 0xa4, 0xed, 0x1c, 0x77, 0xe3,
 0x4e, 0xe8, 0xa3, 0x76, 0xba, 0x93, 0xcd, 0x62,
 0x7c, 0xdf, 0x13, 0xca, 0x80, 0xf3, 0x5c, 0xa9,
 0xd8, 0x06, 0xee, 0x13, 0xd8, 0x62, 0x1e, 0x86,
 0xbd, 0x18, 0x92, 0xb5, 0xce, 0x40, 0x50, 0xe9,
 0x1a, 0x57, 0x19, 0x99, 0xa2, 0x9d, 0xc5, 0x66,
 0x14, 0x21, 0x00, 0x67, 0xab, 0xda, 0x5a, 0x1f,
 0x33, 0xd3, 0x68, 0x36, 0x9a, 0x52, 0x28, 0x87,
 0x78, 0x8c, 0x9e, 0x05, 0xcb, 0xbc, 0x82, 0x93,
 0x2e, 0xfb, 0x11, 0x9f, 0xba, 0x9b, 0xf1, 0x8c,
 0x50, 0xa8, 0xb5, 0x85, 0xd2, 0x61, 0x34, 0x6b,
 0x39, 0xb5, 0x88, 0x7b, 0xd8, 0x0b, 0xfa, 0x58,
 0x22, 0x4a, 0x7e, 0x3a, 0x1a, 0x06, 0x66, 0x0d,
 0x28, 0x10, 0xdb, 0x8e, 0x64, 0x11, 0x02, 0x7e,
 0x8e, 0xa3, 0xf5, 0xd8, 0x5d, 0xab, 0x62, 0x88,
 0x6a, 0x22, 0x70, 0x72, 0x8a, 0x40, 0xa7, 0xfb,
 0xf0, 0x85, 0x7f, 0xb0, 0xf9, 0x57, 0x47, 0xf3,
 0xdd, 0x80, 0xcf, 0x8f, 0x7e, 0xa2, 0x20, 0x84,
 0xe3, 0x4a, 0xf7, 0x67, 0x69, 0x8d, 0x22, 0xfe,
 0xd0, 0x42, 0xf4, 0x70, 0xf6, 0xe8, 0x62, 0x65,
 0xe5, 0xe3, 0x8e, 0xb4, 0x60, 0xdb, 0xd3, 0xb3,
 0xd2, 0x22, 0x61, 0xd8, 0xe8, 0x01, 0x11, 0xfa,
 0x9f, 0x0b, 0x3b, 0x4c, 0x5b, 0x94, 0x77, 0x13,
 0xc3, 0xf1, 0x19, 0xd6, 0x6d, 0xca, 0x86, 0x3c,
 0x2d, 0x30, 0x2c, 0x7a, 0xa5, 0xbd, 0xe9, 0x0a,
 0x43, 0x5a, 0xd4, 0xec, 0xf6, 0x70, 0xce, 0x8a,
 0xb5, 0xad, 0x4a, 0x46, 0xcb, 0xf3, 0x32, 0x76,
 0x0e, 0x89, 0xce, 0x0e, 0x7f, 0xa1, 0xb2, 0x8f,
 0x67, 0x68, 0x38, 0x43, 0x97, 0x79, 0x8c, 0xc4,
 0x4f, 0x74, 0xac, 0x8e, 0xc4, 0x95, 0xfb, 0x0a,
 0x8a, 0x5b, 0xa5, 0xbd, 0x39, 0xba, 0x2d, 0xdd,
 0xed, 0x80, 0xf5, 0xa6, 0x0c, 0xdd, 0x58, 0x9a,
 0x17, 0x0e, 0xbb, 0x01, 0xca, 0x3d, 0xd0, 0x9c,
 0x91, 0x67, 0x1c, 0x8b, 0xbc, 0x46, 0x6a, 0x6b,
 0xa4, 0x23, 0xd5, 0x0b, 0x80, 0xe1, 0x0f, 0x18,
 0xb8, 0x93, 0x4b, 0x00, 0xb5, 0xe0, 0xfd, 0x0b,
 0x2d, 0xb2, 0xd5, 0x01, 0xb4, 0x76, 0x18, 0x32,
 0x91, 0x72, 0x0a, 0x0e, 0x44, 0x8f, 0xd8, 0x49,
 0x6d, 0x37, 0x9b, 0xd2, 0x36, 0x12, 0x47, 0x49,
 0x37, 0x26, 0x7f, 0x74, 0x34, 0x3f, 0x1d, 0xf8,
 0x3c, 0xa6, 0x3e, 0x01, 0xe9, 0x8f, 0xe9, 0x8f,
 0x41, 0xbc, 0x33, 0x89, 0x90, 0xa0, 0x09, 0x27,
 0xb8, 0x65, 0x77, 0x02, 0xbc, 0xc2, 0xf8, 0x24,
 0xf3, 0x13, 0xf5, 0xde, 0x65, 0xe5, 0x0d, 0x16,
 0xf0, 0x88, 0xbd, 0xd4, 0x49, 0x1f, 0xc4, 0x7d,
 0xd8, 0x93, 0x52, 0x61, 0xb4, 0xa2, 0x7b, 0x98,
 0xb4, 0x7a, 0x74, 0xd9, 0xcd, 0x57, 0x6d, 0x0c,
 0x77, 0x61, 0xcd, 0x9a, 0x84, 0x48, 0x82, 0x7b,
 0xf7, 0x8b, 0x3e, 0x5a, 0x20, 0xa9, 0x0c, 0x4f,
 0xef, 0xe6, 0x25, 0xe8, 0x1f, 0x9b, 0xfc, 0x71,
 0x06, 0x9e, 0x78, 0x38, 0x43, 0xb5, 0x54, 0xd1,
 0x69, 0x0c, 0x97, 0x8b, 0x75, 0x93, 0x38, 0x84,
 0x3a, 0x62, 0xed, 0xf4, 0xe0, 0xc7, 0xa9, 0xf0,
 0x14, 0x02, 0x72, 0x61, 0x7b, 0x4b, 0x84, 0x26,
 0x3a, 0x4a, 0xa1, 0x89, 0x7c, 0x3b, 0xcc, 0x1e,
 0x5e, 0xd0, 0xa1, 0x86, 0xb1, 0x84, 0x61, 0xbd,
 0xc6, 0xe2, 0x03, 0x03, 0x07, 0xd9, 0x3a, 0x17,
 0x90, 0xa8, 0xd6, 0xc4, 0x7d, 0x27, 0xab, 0x5e,
 0x11, 0x43, 0x3f, 0x5d, 0xc7, 0x01, 0x49, 0x31,
 0xa2, 0xdc, 0xc1, 0x15, 0xf7, 0x05, 0x91, 0xb9,
 0x31, 0xda, 0xbf, 0x34, 0xf9, 0xbb, 0xa3, 0xf9,
 0x0e, 0x23, 0x18, 0x4a, 0x17, 0xe3, 0xa9, 0x46,
 0x5e, 0x60, 0x94, 0x96, 0x1a, 0x16, 0x06, 0xbd,
 0x43, 0x29, 0x89, 0xa9, 0x31, 0xab, 0x63, 0x73,
 0xed, 0x22, 0xf6, 0x0b, 0x22, 0x75, 0x4e, 0x05,
 0x29, 0x2a, 0x90, 0x7d, 0xbc, 0x88, 0x3c, 0xd8,
 0x0b, 0x62, 0x0b, 0x4a, 0x6c, 0xf0, 0x21, 0x71,
 0x77, 0x97, 0x8d, 0xe6, 0x3d, 0xa9, 0x6d, 0x9b,
 0x08, 0xb9, 0xe7, 0xc8, 0x7e, 0x46, 0x7e, 0xc8,
 0x7d, 0x72, 0xb8, 0x8f, 0xa4, 0x02, 0xfb, 0x99,
 0x76, 0xe6, 0x3f, 0x04, 0x78, 0xe8, 0xaf, 0x02,
 0x94, 0x2f, 0xe2, 0xb2, 0x9d, 0x89, 0x33, 0xf2,
 0x29, 0x4f, 0x62, 0xf5, 0x11, 0x82, 0xa7, 0x96,
 0xcd, 0x64, 0xad, 0x66, 0x6c, 0x25, 0x36, 0xf0,
 0xab, 0x8c, 0xab, 0xe0, 0x91, 0x59, 0x6b, 0x10,
 0x37, 0x17, 0x05, 0x67, 0xdf, 0x99, 0xf2, 0x36,
 0x2b, 0x2d, 0xe2, 0x32, 0xe3, 0x89, 0x65, 0x14,
 0xaa, 0xdd, 0xad, 0x39, 0xe3, 0x49, 0x7e, 0xd6,
 0x17, 0xa3, 0x2c, 0xa5, 0x8f, 0x08, 0xfe, 0xee,
 0xf1, 0x13, 0x41, 0x3d, 0xb5, 0xc3, 0x47, 0xa3,
 0x24, 0xaf, 0x49, 0xae, 0x77, 0xad, 0x89, 0x0b,
 0xe0, 0xcd, 0x48, 0x79, 0x89, 0xf7, 0x38, 0xb9,
 0xa3, 0xa4, 0xc3, 0x6d, 0x71, 0x91, 0x20, 0xab,
 0x6d, 0x5a, 0x2e, 0x4d, 0xb9, 0x58, 0xf1, 0x50,
 0x5f, 0x93, 0x39, 0x59, 0xf2, 0x59, 0xe0, 0x89,
 0x3f, 0xcd, 0x85, 0x10, 0xe9, 0x00, 0x6f, 0xd1,
 0xbd, 0x96, 0xf1, 0x2e, 0xa4, 0xcc, 0x33, 0xa6,
 0xc8, 0x51, 0xd4, 0x9e, 0x91, 0x22, 0xb5, 0xb6,
 0x1c, 0xdc, 0x14, 0x37, 0x26, 0x51, 0x91, 0xbe,
 0xe0, 0xca, 0x97, 0x0c, 0xf8, 0x01, 0xb1, 0xf5,
 0x99, 0xab, 0xc0, 0x97, 0x79, 0x64, 0x4f, 0x06,
 0xa7, 0xa6, 0x65, 0x69, 0x94, 0x9d, 0xf6, 0xf3,
 0x4c, 0x57, 0xb5, 0xce, 0x5e, 0xd9, 0xd1, 0x7c,
 0x1c, 0xfa, 0x4f, 0x9a, 0xc4, 0x5a, 0xca, 0x2b,
 0xf9, 0xc5, 0x04, 0x83, 0xb5, 0xd8, 0xe2, 0x7d,
 0x27, 0x8f, 0x3b, 0x0f, 0x85, 0xc0, 0x3f, 0x92,
 0x94, 0xf8, 0x72, 0x06, 0x74, 0x38, 0x52, 0xb7,
 0xb5, 0xba, 0xe7, 0xa8, 0x3b, 0x5a, 0x8a, 0x6a,
 0x5a, 0x70, 0x52, 0x0c, 0x7e, 0x84, 0x4c, 0xcc,
 0xb6, 0x9a, 0x14, 0x74, 0x4d, 0x09, 0x3f, 0xa7,
 0x49, 0xf3, 0xd7, 0x62, 0x34, 0xc1, 0x6d, 0x27,
 0x43, 0xdd, 0x85, 0x4f, 0x9a, 0xe6, 0xea, 0x72,
 0x4e, 0x1c, 0xd2, 0x36, 0x75, 0x5c, 0x0e, 0xad,
 0x9c, 0xee, 0x26, 0x91, 0x21, 0x68, 0x60, 0x84,
 0x26, 0x6a, 0xe5, 0x4d, 0x77, 0x91, 0x43, 0xef,
 0x25, 0x0d, 0x3a, 0xa0, 0xea, 0x62, 0xa1, 0x04,
 0xea, 0x51, 0xd2, 0xec, 0x03, 0x10, 0xda, 0x72,
 0x06, 0x57, 0x19, 0x11, 0xe7, 0x24, 0x43, 0x1c,
 0x94, 0x19, 0x3a, 0x97, 0xa3, 0xc4, 0xa0, 0xb3,
 0x49, 0xa7, 0x7b, 0x51, 0x5f, 0x9f, 0xa1, 0x7e,
 0x95, 0xe9, 0x46, 0x57, 0xd4, 0x0e, 0x71, 0xda,
 0x56, 0xe1, 0xc3, 0x96, 0x3f, 0xa5, 0xdc, 0x8f,
 0x68, 0xf4, 0x0f, 0x3f, 0xf6, 0x65, 0xd2, 0x39,
 0x55, 0x71, 0xda, 0x4d, 0xd2, 0xd4, 0x53, 0xad,
 0x5c, 0x85, 0xca, 0x87, 0x75, 0xca, 0xf6, 0x27,
 0x99, 0x8e, 0xe1, 0x71, 0x6d, 0x65, 0x4f, 0x85,
 0x24, 0x13, 0x78, 0x26, 0x23, 0xfe, 0xea, 0x05,
 0xb5, 0x68, 0x83, 0x46, 0x4f, 0xe2, 0xc3, 0xc3,
 0x90, 0x09, 0xe0, 0x72, 0x15, 0x30, 0xb1, 0x6b,
 0x0b, 0x7a, 0xe7, 0xbc, 0x4c, 0xb3, 0xa9, 0x46,
 0xc7, 0xc6, 0x7f, 0x8e, 0xe6, 0xed, 0x89, 0xbf,
 0x7a, 0xbc, 0x04, 0x69, 0xd5, 0x87, 0x4f, 0xa3,
 0xfe, 0x3e, 0x9d, 0x94, 0x04, 0x1a, 0x1c, 0xdd,
 0x1a, 0x44, 0xb9, 0x26, 0xc7, 0x12, 0x4d, 0x7d,
 0x16, 0x18, 0x40, 0x0b, 0x00, 0x9b, 0x56, 0x51,
 0x94, 0x87, 0xea, 0x6c, 0x42, 0x86, 0xd6, 0x22,
 0xc2, 0x11, 0xdf, 0x42, 0x6b, 0xfc, 0x0d, 0x2a,
 0xdf, 0x81, 0x62, 0x7e, 0x8a, 0xca, 0x77, 0xa0,
 0x98, 0x9f, 0xa2, 0xf2, 0x1d, 0x28, 0xe6, 0xa7,
 0xa8, 0xfc, 0xcc, 0xd8, 0x3f, 0xbd, 0xe1, 0x0b,
 0x50, 0xcc, 0x4f, 0x51, 0xf9, 0x0e, 0x14, 0xf3,
 0x53, 0x54, 0xbe, 0x03, 0xc5, 0xfc, 0x14, 0x95,
 0xef, 0x40, 0x31, 0x3f, 0x45, 0xe5, 0x3b, 0x50,
 0xfe, 0xc7, 0x21, 0xf2, 0x03, 0x54, 0xbe, 0x03,
 0xc5, 0xfc, 0x14, 0x95, 0xef, 0x40, 0x31, 0xbf,
 0x25, 0xb0, 0xcf, 0x40, 0x31, 0xbf, 0x25, 0xb0,
 0xcf, 0x40, 0x31, 0xbf, 0x25, 0xb0, 0xff, 0x4d,
 0x88, 0x7c, 0x01, 0x8a, 0xf9, 0x2d, 0x81, 0x7d,
 0x06, 0x8a, 0xf9, 0x1e, 0x95, 0xfa, 0xa3, 0x50,
 0x31, 0xbf, 0x25, 0xb0, 0xcf, 0x40, 0x31, 0xbf,
 0x25, 0xb0, 0xcf, 0x40, 0xf9, 0x3f, 0x85, 0xc8,
 0x7d, 0x74, 0x3e, 0x9e, 0xa5, 0x38, 0xdd, 0xf5,
 0xd3, 0xb6, 0x65, 0x50, 0xb5, 0x4d, 0xaa, 0xf5,
 0x44, 0xbb, 0xbb, 0xd5, 0xf6, 0x89, 0x82, 0xec,
 0x6e, 0xd9, 0x0b, 0x3d, 0x21, 0x6b, 0x32, 0x5a,
 0x0b, 0xf4, 0x14, 0x13, 0x7f, 0x69, 0xa3, 0x05,
 0x2e, 0xfa, 0xde, 0x81, 0xcb, 0x7e, 0x82, 0xee,
 0x00, 0x4c, 0xea, 0xa8, 0x56, 0x75, 0x87, 0x55,
 0x3e, 0x28, 0xb6, 0x77, 0xc5, 0x1a, 0x67, 0xa0,
 0x69, 0x4b, 0x47, 0x16, 0xf9, 0x64, 0xe4, 0x9b,
 0xb2, 0xfc, 0x5d, 0x55, 0x9e, 0x8e, 0x0b, 0x50,
 0xab, 0x99, 0x53, 0xac, 0xa9, 0xac, 0xf6, 0xec,
 0x73, 0xf1, 0x92, 0xbe, 0x5f, 0xb4, 0xc3, 0xdd,
 0x5d, 0x5b, 0x50, 0x95, 0x72, 0x68, 0x57, 0x06,
 0xe3, 0x2b, 0xce, 0x51, 0x0e, 0xb6, 0xde, 0x7a,
 0xb0, 0x99, 0x25, 0xb9, 0x61, 0xdc, 0x58, 0xce,
 0x5d, 0xe5, 0x5c, 0x0e, 0xb5, 0xc9, 0xa0, 0x89,
 0x19, 0xa5, 0x95, 0x36, 0xc4, 0x3b, 0x7d, 0xae,
 0xa8, 0x36, 0x73, 0xdf, 0x5b, 0xdb, 0xfc, 0x2d,
 0xb8, 0x1c, 0x9d, 0x9c, 0x04, 0x49, 0x17, 0x67,
 0xf7, 0xd5, 0xb5, 0xfc, 0xc2, 0xb3, 0xd3, 0xa9,
 0xb4, 0xa3, 0x6e, 0xce, 0x0b, 0x8b, 0xf4, 0xdd,
 0x35, 0xaa, 0xdb, 0x2a, 0xa8, 0x2c, 0xfa, 0xf2,
 0xcd, 0x56, 0x37, 0x4b, 0x83, 0xf6, 0x28, 0xb3,
 0xce, 0xb0, 0xf3, 0x40, 0xdf, 0x5a, 0x55, 0x6a,
 0x37, 0x05, 0x87, 0x5c, 0x3e, 0x89, 0x06, 0x50,
 0x20, 0x80, 0x90, 0x70, 0x9c, 0xfe, 0xcd, 0xa6,
 0x82, 0x70, 0xbb, 0x3d, 0x0f, 0xdf, 0x2f, 0x74,
 0xf0, 0x78, 0xbb, 0x6f, 0x8b, 0x6a, 0x35, 0x49,
 0x77, 0x74, 0xc3, 0xe3, 0xd0, 0x04, 0x80, 0x0e,
 0x0a, 0x5a, 0x4b, 0x83, 0xb9, 0xbc, 0xae, 0xa5,
 0x69, 0x7d, 0x36, 0xcd, 0x67, 0x6c, 0x97, 0xc5,
 0x75, 0xc0, 0xf2, 0xfb, 0xde, 0x7f, 0x2a, 0xe6,
 0x2d, 0x42, 0xad, 0x75, 0xdd, 0x21, 0x69, 0x48,
 0x0c, 0x1a, 0x38, 0xd5, 0x15, 0xe9, 0x52, 0x5b,
 0x21, 0xee, 0xa9, 0xb9, 0x59, 0xdc, 0x84, 0x14,
 0x6c, 0x2f, 0x44, 0x94, 0xa3, 0x86, 0x05, 0x3b,
 0x67, 0xef, 0x10, 0x19, 0xf5, 0xaf, 0xee, 0xfc,
 0xbc, 0x38, 0x9a, 0x0f, 0x2f, 0xb8, 0xa1, 0x3c,
 0xe4, 0x64, 0x35, 0xdf, 0x75, 0xc7, 0xc3, 0x7a,
 0xdd, 0x90, 0x53, 0x7f, 0xd3, 0xb6, 0xda, 0xb6,
 0xa9, 0xdb, 0xdd, 0xb6, 0x95, 0xea, 0x5a, 0x0a,
 0x9e, 0xd6, 0x42, 0xf9, 0xc8, 0x79, 0xdd, 0x86,
 0xd3, 0x3d, 0x25, 0x7d, 0x22, 0x7b, 0xc8, 0x62,
 0x05, 0xfa, 0x26, 0x22, 0xfe, 0x4f, 0xc3, 0x93,
 0xd7, 0x1d, 0x7d, 0x7e, 0x9e, 0xc1, 0x7e, 0x97,
 0x78, 0x76, 0xbd, 0x97, 0xdc, 0x43, 0x69, 0xd7,
 0x19, 0x59, 0x47, 0x4c, 0x41, 0x89, 0x4a, 0x7a,
 0x85, 0x46, 0xdd, 0x3b, 0x43, 0x97, 0xe4, 0x24,
 0xb4, 0xc3, 0x8d, 0x22, 0x44, 0xc0, 0xa4, 0x7b,
 0x4a, 0x60, 0x4c, 0x81, 0x9f, 0x74, 0xa7, 0x0d,
 0xcf, 0x96, 0xea, 0x36, 0x05, 0x7e, 0xd9, 0xb4,
 0x1d, 0x32, 0xea, 0xe8, 0x79, 0xec, 0xbc, 0x09,
 0x59, 0xf8, 0x37, 0xf8, 0x35, 0x2b, 0x3d, 0x6a,
 0x4e, 0x3e, 0x4c, 0x62, 0xa1, 0x76, 0x17, 0xe3,
 0xb0, 0x54, 0xfb, 0x93, 0xfe, 0x9b, 0xc8, 0x11,
 0xba, 0xf9, 0x5c, 0xf3, 0x9c, 0xfa, 0x08, 0xda,
 0x5b, 0x02, 0x82, 0xf8, 0x81, 0xc1, 0xb9, 0xb3,
 0x84, 0x14, 0xf0, 0x29, 0xa2, 0x28, 0xb8, 0x55,
 0xc0, 0x71, 0xf7, 0x40, 0x9b, 0x3e, 0x87, 0x8b,
 0x32, 0x2b, 0xf4, 0xd8, 0x8b, 0x67, 0x06, 0x47,
 0x18, 0x0d, 0x22, 0xc9, 0xe3, 0xc7, 0x6b, 0xcc,
 0x6b, 0xfb, 0x50, 0x6c, 0x0a, 0x35, 0xdb, 0xa2,
 0x0f, 0x68, 0x52, 0x2d, 0xdc, 0x47, 0xf0, 0xea,
 0x16, 0x5c, 0x4c, 0x68, 0x37, 0x6b, 0x0b, 0xd7,
 0xf6, 0x2f, 0xdd, 0x1b, 0x4e, 0x19, 0xb3, 0xee,
 0x12, 0x8c, 0x0a, 0x2b, 0x0e, 0x68, 0x2a, 0xe7,
 0x81, 0x8f, 0xfa, 0x2e, 0xc6, 0xe1, 0x17, 0xdc,
 0x48, 0x03, 0x53, 0x9a, 0x08, 0xee, 0xae, 0x4c,
 0x1d, 0x9b, 0xee, 0xbc, 0xa9, 0x40, 0xb2, 0x01,
 0x8d, 0xbb, 0x4b, 0x28, 0x82, 0xfe, 0x83, 0xa0,
 0x4f, 0x65, 0xe5, 0xb2, 0xbb, 0x8f, 0x4a, 0xc4,
 0x4c, 0xdc, 0x02, 0x93, 0xcf, 0x6a, 0xe0, 0x01,
 0x96, 0xb0, 0x8a, 0xcb, 0x8e, 0x06, 0x66, 0x48,
 0xc5, 0x41, 0x59, 0x02, 0x8b, 0x6f, 0x01, 0x3a,
 0x60, 0x72, 0x2c, 0x38, 0x1c, 0xfa, 0xab, 0xb2,
 0x49, 0xa2, 0x5b, 0x91, 0xd0, 0x12, 0x24, 0x7a,
 0x9d, 0xcd, 0x23, 0x5c, 0x5f, 0x4a, 0x32, 0xdd,
 0xb3, 0x70, 0x7a, 0xe9, 0x45, 0x5a, 0x43, 0x4f,
 0x7d, 0x5f, 0x02, 0xb1, 0xd8, 0xac, 0xd4, 0x42,
 0x17, 0xda, 0x92, 0xe3, 0x2a, 0xe9, 0xa9, 0x14,
 0xbf, 0xf4, 0x4f, 0xdd, 0x7d, 0x7a, 0x8e, 0x6d,
 0x3a, 0x56, 0xe8, 0xba, 0x5d, 0x36, 0xf3, 0xa1,
 0x04, 0xde, 0xdf, 0x47, 0x3c, 0xa1, 0xaa, 0x26,
 0x50, 0xca, 0x95, 0x00, 0x98, 0x35, 0x9c, 0xcd,
 0xd1, 0xde, 0x7c, 0xee, 0x52, 0xce, 0xee, 0xf2,
 0x25, 0xdd, 0xed, 0x2c, 0x05, 0x49, 0x97, 0x78,
 0x73, 0xcb, 0x8f, 0xc8, 0xcf, 0x2a, 0x7f, 0xa4,
 0xae, 0x0f, 0x9d, 0x1e, 0x9a, 0x03, 0xd5, 0x82,
 0x74, 0xca, 0xf6, 0x55, 0xb7, 0x58, 0xf4, 0xd5,
 0x83, 0x23, 0x7a, 0xa8, 0x68, 0xa7, 0xa6, 0x3a,
 0x61, 0x1e, 0x86, 0xa1, 0x45, 0xc4, 0x27, 0x90,
 0x74, 0x76, 0x95, 0xeb, 0x6d, 0x65, 0x02, 0xd5,
 0x63, 0x65, 0x46, 0xad, 0x4e, 0x8f, 0x49, 0x0a,
 0x4f, 0xd3, 0xfa, 0xa2, 0x8f, 0x85, 0xfc, 0xcc,
 0x5e, 0x5f, 0x86, 0x72, 0x9a, 0xd1, 0x25, 0x96,
 0x5a, 0x0b, 0xb1, 0x45, 0xee, 0xef, 0x22, 0xac,
 0xde, 0x6a, 0x67, 0xed, 0xe1, 0x93, 0x8a, 0xd1,
 0x04, 0xc7, 0xdd, 0xf6, 0x4a, 0xc7, 0xea, 0x98,
 0x3b, 0xd5, 0x17, 0x69, 0x7d, 0x4d, 0x10, 0x9b,
 0x4b, 0xdf, 0x65, 0x69, 0xa4, 0x58, 0x42, 0x46,
 0x9f, 0x3a, 0x19, 0xdd, 0xda, 0xbe, 0x76, 0x8c,
 0xac, 0xcb, 0x85, 0xb8, 0x61, 0xf9, 0x41, 0xdf,
 0x68, 0x69, 0x31, 0x33, 0xcc, 0x05, 0xa9, 0x84,
 0x2b, 0x46, 0xd2, 0x3e, 0x7d, 0xa6, 0x81, 0x0d,
 0x20, 0x77, 0xe8, 0xb3, 0x6e, 0x37, 0x23, 0x09,
 0x23, 0x6c, 0x3b, 0x62, 0xec, 0xc6, 0x47, 0x1a,
 0xf7, 0x45, 0xc9, 0x90, 0x4b, 0xa9, 0x52, 0x68,
 0x8c, 0x47, 0x57, 0x77, 0x3d, 0xa2, 0x03, 0x14,
 0x04, 0xde, 0x01, 0x4f, 0xaf, 0x0b, 0x52, 0xa3,
 0xb1, 0xa5, 0x3a, 0x98, 0x28, 0x4f, 0x5c, 0x35,
 0xdc, 0x2b, 0x5a, 0x2e, 0x60, 0x28, 0x6f, 0x0d,
 0x74, 0xd8, 0xcb, 0x6a, 0xb0, 0x6c, 0x50, 0xe6,
 0x06, 0xfe, 0x6d, 0x09, 0xdc, 0xb1, 0xf5, 0x75,
 0x0f, 0xe2, 0x32, 0x56, 0x91, 0x16, 0x23, 0xa5,
 0x84, 0x6e, 0xf0, 0x60, 0x5b, 0x82, 0x75, 0xb4,
 0x65, 0xb3, 0x38, 0xa2, 0x54, 0x9f, 0x67, 0xd2,
 0x3b, 0x0f, 0x47, 0x35, 0xe2, 0x6a, 0xd0, 0x77,
 0x5f, 0x20, 0x5c, 0x4f, 0x42, 0x85, 0x84, 0x76,
 0xae, 0x2d, 0x01, 0x68, 0x96, 0x1c, 0xbb, 0x9d,
 0x2c, 0xa6, 0x35, 0x32, 0x5b, 0x26, 0x74, 0xb9,
 0x19, 0x43, 0xd9, 0x1d, 0x97, 0xad, 0x43, 0xf4,
 0xc1, 0x66, 0x88, 0x43, 0xd9, 0xaa, 0x26, 0xd3,
 0x4b, 0x0f, 0xd5, 0x8e, 0xc0, 0x8c, 0xc4, 0x8f,
 0x1d, 0xb4, 0xfe, 0x31, 0x34, 0x77, 0x0a, 0x2d,
 0x28, 0x76, 0x66, 0xd1, 0x27, 0x7f, 0x9e, 0x89,
 0xb7, 0xa6, 0x1d, 0x3c, 0xa5, 0x86, 0x86, 0xfd,
 0x16, 0x20, 0xe5, 0x60, 0xc9, 0x13, 0xbb, 0xc1,
 0x18, 0xba, 0xb4, 0xf3, 0x28, 0xa1, 0xc2, 0x1d,
 0x25, 0xc9, 0x72, 0x90, 0x86, 0x1f, 0x12, 0x87,
 0x53, 0xa0, 0xee, 0x47, 0xae, 0xe4, 0x06, 0xf5,
 0xda, 0x14, 0xc2, 0xca, 0xfa, 0xa4, 0x85, 0x50,
 0xb6, 0xc7, 0x4d, 0x5e, 0xcc, 0x63, 0xae, 0x0d,
 0x27, 0xfc, 0x24, 0x49, 0x89, 0x9a, 0x51, 0x4e,
 0x15, 0x86, 0xfb, 0x90, 0x31, 0x1e, 0x4f, 0x6e,
 0x75, 0x9f, 0x55, 0xc5, 0x5a, 0xad, 0xb7, 0x64,
 0xa7, 0x4b, 0x78, 0x59, 0x38, 0x77, 0x50, 0xd6,
 0x52, 0x81, 0x46, 0x0e, 0x3e, 0x44, 0xc8, 0x3e,
 0xe2, 0xb7, 0xee, 0xfa, 0xce, 0xa0, 0x63, 0x1f,
 0xf7, 0xeb, 0x2b, 0xa5, 0x57, 0xc5, 0x76, 0x64,
 0x20, 0xe1, 0x54, 0x02, 0x29, 0xa5, 0xa5, 0x55,
 0x0f, 0x39, 0x94, 0x34, 0xd5, 0xcd, 0xb5, 0xe1,
 0x03, 0x4b, 0x8b, 0x2f, 0x72, 0xe4, 0xef, 0x3f,
 0x0a, 0xa7, 0x3f, 0xeb, 0x48, 0x3b, 0xde, 0x4f,
 0x94, 0x5a, 0xc3, 0x59, 0x75, 0x2f, 0x57, 0x6b,
 0x8e, 0xb9, 0x29, 0x6a, 0xb6, 0xbb, 0x1e, 0x8b,
 0xbd, 0x5d, 0xd5, 0x55, 0x25, 0x42, 0x5c, 0x8d,
 0x0a, 0x83, 0x14, 0x3b, 0x29, 0x80, 0xab, 0x7a,
 0xea, 0x80, 0xcb, 0x87, 0x3e, 0x71, 0x8a, 0xe1,
 0x52, 0xfc, 0xc5, 0xd2, 0xcd, 0x8b, 0xb5, 0xdf,
 0x86, 0xd5, 0x87, 0x3f, 0x49, 0xed, 0x7e, 0xed,
 0x72, 0xd9, 0xab, 0x3a, 0x3a, 0xe5, 0xcf, 0x0b,
 0xc5, 0xb5, 0x86, 0xcb, 0xf5, 0x52, 0x3c, 0x0c,
 0x96, 0xf6, 0x5a, 0x3c, 0x6a, 0xbf, 0xb3, 0x8b,
 0x7b, 0x69, 0x17, 0x79, 0x69, 0x97, 0x97, 0x66,
 0x31, 0x0f, 0xf1, 0xfb, 0x85, 0x5d, 0x96, 0x96,
 0x13, 0xca, 0x4b, 0xea, 0xb6, 0xe7, 0x31, 0x3c,
 0x49, 0xef, 0xa3, 0xc5, 0x3f, 0xa6, 0x4e, 0x87,
 0xfc, 0xdf, 0xcc, 0x5d, 0x1f, 0xca, 0xe3, 0x26,
 0x47, 0x3a, 0xda, 0x90, 0x29, 0x74, 0xa3, 0x5c,
 0xe6, 0x55, 0x34, 0x3c, 0xef, 0x7e, 0x61, 0x14,
 0xf3, 0xca, 0x2a, 0xfe, 0x13, 0xab, 0xe8, 0xc6,
 0xac, 0x56, 0x73, 0xbb, 0x47, 0x2c, 0x01, 0xdb,
 0x35, 0x7d, 0xbb, 0xed, 0x48, 0x9e, 0xb7, 0x56,
 0xc6, 0xa7, 0xaf, 0x2d, 0xe2, 0x3f, 0xb4, 0xc8,
 0xa5, 0xf2, 0x7e, 0x08, 0x84, 0x75, 0x4d, 0x39,
 0x93, 0xe0, 0x25, 0x5d, 0x6b, 0x34, 0x6a, 0x1a,
 0x0b, 0xa7, 0xbe, 0xf1, 0x91, 0x87, 0x95, 0xfa,
 0xa7, 0x2e, 0x32, 0xf1, 0xa3, 0x7c, 0x44, 0xed,
 0x09, 0x29, 0x2f, 0xea, 0xeb, 0xaa, 0x2d, 0xc6,
 0xba, 0xca, 0xde, 0xcf, 0x75, 0x7a, 0x3f, 0xa7,
 0x19, 0xa7, 0xbb, 0x60, 0x5a, 0x8a, 0xc2, 0x89,
 0xd3, 0xe9, 0xd3, 0x86, 0x3f, 0x0a, 0x3f, 0x26,
 0xf9, 0x5e, 0xb4, 0xf9, 0x78, 0x3d, 0xef, 0x44,
 0x67, 0x15, 0x7d, 0xa5, 0x95, 0xf3, 0x7d, 0xbd,
 0x15, 0x6d, 0x7e, 0xa2, 0xf6, 0x97, 0xa2, 0x13,
 0xbc, 0xe8, 0x49, 0x47, 0x6b, 0xf9, 0xd0, 0xa9,
 0xcb, 0xaa, 0x4f, 0x15, 0xea, 0xa3, 0x0c, 0xa3,
 0xc9, 0x9b, 0xd4, 0xf5, 0xd0, 0x73, 0x18, 0x9e,
 0x0e, 0x0b, 0x9b, 0x52, 0xd2, 0x68, 0x49, 0xa2,
 0xb3, 0xe8, 0x63, 0x3b, 0x7d, 0x16, 0x31, 0x42,
 0xa0, 0x57, 0xa0, 0x74, 0xd6, 0x6e, 0x85, 0xec,
 0xa1, 0x6f, 0x8c, 0xa7, 0x55, 0x68, 0x76, 0x68,
 0x0f, 0xc2, 0x81, 0xb6, 0x8e, 0xb1, 0xf5, 0x5d,
 0x0d, 0xd1, 0xfc, 0x90, 0xa1, 0xf3, 0xbe, 0x0a,
 0x25, 0xe7, 0x14, 0x97, 0x2a, 0x89, 0x40, 0x6b,
 0x8a, 0xe8, 0xf1, 0x17, 0xcd, 0xd8, 0x5e, 0xb7,
 0x3a, 0xdb, 0x82, 0xe9, 0x0d, 0x91, 0x55, 0xa6,
 0x95, 0xe2, 0x88, 0xe0, 0xea, 0x17, 0xd9, 0x78,
 0xc4, 0xd3, 0xda, 0x04, 0xea, 0x26, 0x0a, 0x15,
 0x09, 0x83, 0xba, 0xcb, 0x42, 0xd2, 0xca, 0xd7,
 0xdc, 0x4a, 0x96, 0xa5, 0x11, 0xa5, 0x90, 0xee,
 0xfa, 0x82, 0xe4, 0xa0, 0x8c, 0x72, 0xfa, 0xbc,
 0xd5, 0x90, 0x5c, 0xf4, 0x75, 0x87, 0x9d, 0x28,
 0x6b, 0x9c, 0xbe, 0xaa, 0xe9, 0x5d, 0x9d, 0xae,
 0x93, 0x22, 0x3a, 0xf4, 0xef, 0x69, 0xcb, 0x74,
 0x83, 0x9c, 0x62, 0x7f, 0x51, 0x08, 0xb8, 0x99,
 0x5b, 0x42, 0x38, 0xbd, 0x9b, 0x6e, 0xd0, 0x4e,
 0x0a, 0x4a, 0x9a, 0x38, 0x1c, 0x3f, 0xe8, 0xfb,
 0x90, 0xba, 0x47, 0x2b, 0x99, 0x7e, 0x60, 0x11,
 0x1e, 0x3d, 0x96, 0x92, 0x51, 0x95, 0x98, 0xa2,
 0xe6, 0xf9, 0x2f, 0x0d, 0xd3, 0x3c, 0xae, 0xa2,
 0xf1, 0x62, 0x69, 0x00, 0x00, 0x01, 0x84, 0x69,
 0x43, 0x43, 0x50, 0x49, 0x43, 0x43, 0x20, 0x50,
 0x72, 0x6f, 0x66, 0x69, 0x6c, 0x65, 0x00, 0x00,
 0x78, 0x9c, 0x7d, 0x91, 0x3d, 0x48, 0xc3, 0x40,
 0x1c, 0xc5, 0x5f, 0xd3, 0x8a, 0x22, 0x15, 0x07,
 0x3b, 0x88, 0x08, 0x66, 0xa8, 0x2e, 0x5a, 0x10,
 0x15, 0x71, 0xd4, 0x2a, 0x14, 0xa1, 0x42, 0xa8,
 0x15, 0x5a, 0x75, 0x30, 0xb9, 0xf4, 0x0b, 0x9a,
 0x34, 0x24, 0x29, 0x2e, 0x8e, 0x82, 0x6b, 0xc1,
 0xc1, 0x8f, 0xc5, 0xaa, 0x83, 0x8b, 0xb3, 0xae,
 0x0e, 0xae, 0x82, 0x20, 0xf8, 0x01, 0xe2, 0xec,
 0xe0, 0xa4, 0xe8, 0x22, 0x25, 0xfe, 0x2f, 0x29,
 0xb4, 0x88, 0xf1, 0xe0, 0xb8, 0x1f, 0xef, 0xee,
 0x3d, 0xee, 0xde, 0x01, 0x42, 0xbd, 0xcc, 0x34,
 0x2b, 0x34, 0x0e, 0x68, 0xba, 0x6d, 0xa6, 0x12,
 0x71, 0x31, 0x93, 0x5d, 0x15, 0x3b, 0x5f, 0x21,
 0x20, 0x88, 0x10, 0x46, 0x31, 0x24, 0x33, 0xcb,
 0x98, 0x93, 0xa4, 0x24, 0x7c, 0xc7, 0xd7, 0x3d,
 0x02, 0x7c, 0xbd, 0x8b, 0xf1, 0x2c, 0xff, 0x73,
 0x7f, 0x8e, 0x1e, 0x35, 0x67, 0x31, 0x20, 0x20,
 0x12, 0xcf, 0x32, 0xc3, 0xb4, 0x89, 0x37, 0x88,
 0xa7, 0x37, 0x6d, 0x83, 0xf3, 0x3e, 0x71, 0x84,
 0x15, 0x65, 0x95, 0xf8, 0x9c, 0x78, 0xcc, 0xa4,
 0x0b, 0x12, 0x3f, 0x72, 0x5d, 0xf1, 0xf8, 0x8d,
 0x73, 0xc1, 0x65, 0x81, 0x67, 0x46, 0xcc, 0x74,
 0x6a, 0x9e, 0x38, 0x42, 0x2c, 0x16, 0xda, 0x58,
 0x69, 0x63, 0x56, 0x34, 0x35, 0xe2, 0x29, 0xe2,
 0xa8, 0xaa, 0xe9, 0x94, 0x2f, 0x64, 0x3c, 0x56,
 0x39, 0x6f, 0x71, 0xd6, 0xca, 0x55, 0xd6, 0xbc,
 0x27, 0x7f, 0x61, 0x38, 0xa7, 0xaf, 0x2c, 0x73,
 0x9d, 0xe6, 0x20, 0x12, 0x58, 0xc4, 0x12, 0x24,
 0x88, 0x50, 0x50, 0x45, 0x09, 0x65, 0xd8, 0x88,
 0xd1, 0xaa, 0x93, 0x62, 0x21, 0x45, 0xfb, 0x71,
 0x1f, 0xff, 0x80, 0xeb, 0x97, 0xc8, 0xa5, 0x90,
 0xab, 0x04, 0x46, 0x8e, 0x05, 0x54, 0xa0, 0x41,
 0x76, 0xfd, 0xe0, 0x7f, 0xf0, 0xbb, 0x5b, 0x2b,
 0x3f, 0x39, 0xe1, 0x25, 0x85, 0xe3, 0x40, 0xc7,
 0x8b, 0xe3, 0x7c, 0x0c, 0x03, 0x9d, 0xbb, 0x40,
 0xa3, 0xe6, 0x38, 0xdf, 0xc7, 0x8e, 0xd3, 0x38,
 0x01, 0x82, 0xcf, 0xc0, 0x95, 0xde, 0xf2, 0x57,
 0xea, 0xc0, 0xcc, 0x27, 0xe9, 0xb5, 0x96, 0x16,
 0x3d, 0x02, 0x7a, 0xb7, 0x81, 0x8b, 0xeb, 0x96,
 0xa6, 0xec, 0x01, 0x97, 0x3b, 0x40, 0xff, 0x93,
 0x21, 0x9b, 0xb2, 0x2b, 0x05, 0x69, 0x0a, 0xf9,
 0x3c, 0xf0, 0x7e, 0x46, 0xdf, 0x94, 0x05, 0xfa,
 0x6e, 0x81, 0xee, 0x35, 0xaf, 0xb7, 0xe6, 0x3e,
 0x4e, 0x1f, 0x80, 0x34, 0x75, 0x95, 0xbc, 0x01,
 0x0e, 0x0e, 0x81, 0x91, 0x02, 0x65, 0xaf, 0xfb,
 0xbc, 0xbb, 0xab, 0xbd, 0xb7, 0x7f, 0xcf, 0x34,
 0xfb, 0xfb, 0x01, 0x43, 0x4a, 0x72, 0x94, 0x28,
 0xa6, 0xf3, 0x48, 0x00, 0x00, 0x0d, 0x78, 0x69,
 0x54, 0x58, 0x74, 0x58, 0x4d, 0x4c, 0x3a, 0x63,
 0x6f, 0x6d, 0x2e, 0x61, 0x64, 0x6f, 0x62, 0x65,
 0x2e, 0x78, 0x6d, 0x70, 0x00, 0x00, 0x00, 0x00,
 0x00, 0x3c, 0x3f, 0x78, 0x70, 0x61, 0x63, 0x6b,
 0x65, 0x74, 0x20, 0x62, 0x65, 0x67, 0x69, 0x6e,
 0x3d, 0x22, 0xef, 0xbb, 0xbf, 0x22, 0x20, 0x69,
 0x64, 0x3d, 0x22, 0x57, 0x35, 0x4d, 0x30, 0x4d,
 0x70, 0x43, 0x65, 0x68, 0x69, 0x48, 0x7a, 0x72,
 0x65, 0x53, 0x7a, 0x4e, 0x54, 0x63, 0x7a, 0x6b,
 0x63, 0x39, 0x64, 0x22, 0x3f, 0x3e, 0x0a, 0x3c,
 0x78, 0x3a, 0x78, 0x6d, 0x70, 0x6d, 0x65, 0x74,
 0x61, 0x20, 0x78, 0x6d, 0x6c, 0x6e, 0x73, 0x3a,
 0x78, 0x3d, 0x22, 0x61, 0x64, 0x6f, 0x62, 0x65,
 0x3a, 0x6e, 0x73, 0x3a, 0x6d, 0x65, 0x74, 0x61,
 0x2f, 0x22, 0x20, 0x78, 0x3a, 0x78, 0x6d, 0x70,
 0x74, 0x6b, 0x3d, 0x22, 0x58, 0x4d, 0x50, 0x20,
 0x43, 0x6f, 0x72, 0x65, 0x20, 0x34, 0x2e, 0x34,
 0x2e, 0x30, 0x2d, 0x45, 0x78, 0x69, 0x76, 0x32,
 0x22, 0x3e, 0x0a, 0x20, 0x3c, 0x72, 0x64, 0x66,
 0x3a, 0x52, 0x44, 0x46, 0x20, 0x78, 0x6d, 0x6c,
 0x6e, 0x73, 0x3a, 0x72, 0x64, 0x66, 0x3d, 0x22,
 0x68, 0x74, 0x74, 0x70, 0x3a, 0x2f, 0x2f, 0x77,
 0x77, 0x77, 0x2e, 0x77, 0x33, 0x2e, 0x6f, 0x72,
 0x67, 0x2f, 0x31, 0x39, 0x39, 0x39, 0x2f, 0x30,
 0x32, 0x2f, 0x32, 0x32, 0x2d, 0x72, 0x64, 0x66,
 0x2d, 0x73, 0x79, 0x6e, 0x74, 0x61, 0x78, 0x2d,
 0x6e, 0x73, 0x23, 0x22, 0x3e, 0x0a, 0x20, 0x20,
 0x3c, 0x72, 0x64, 0x66, 0x3a, 0x44, 0x65, 0x73,
 0x63, 0x72, 0x69, 0x70, 0x74, 0x69, 0x6f, 0x6e,
 0x20, 0x72, 0x64, 0x66, 0x3a, 0x61, 0x62, 0x6f,
 0x75, 0x74, 0x3d, 0x22, 0x22, 0x0a, 0x20, 0x20,
 0x20, 0x20, 0x78, 0x6d, 0x6c, 0x6e, 0x73, 0x3a,
 0x78, 0x6d, 0x70, 0x4d, 0x4d, 0x3d, 0x22, 0x68,
 0x74, 0x74, 0x70, 0x3a, 0x2f, 0x2f, 0x6e, 0x73,
 0x2e, 0x61, 0x64, 0x6f, 0x62, 0x65, 0x2e, 0x63,
 0x6f, 0x6d, 0x2f, 0x78, 0x61, 0x70, 0x2f, 0x31,
 0x2e, 0x30, 0x2f, 0x6d, 0x6d, 0x2f, 0x22, 0x0a,
 0x20, 0x20, 0x20, 0x20, 0x78, 0x6d, 0x6c, 0x6e,
 0x73, 0x3a, 0x73, 0x74, 0x45, 0x76, 0x74, 0x3d,
 0x22, 0x68, 0x74, 0x74, 0x70, 0x3a, 0x2f, 0x2f,
 0x6e, 0x73, 0x2e, 0x61, 0x64, 0x6f, 0x62, 0x65,
 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x78, 0x61, 0x70,
 0x2f, 0x31, 0x2e, 0x30, 0x2f, 0x73, 0x54, 0x79,
 0x70, 0x65, 0x2f, 0x52, 0x65, 0x73, 0x6f, 0x75,
 0x72, 0x63, 0x65, 0x45, 0x76, 0x65, 0x6e, 0x74,
 0x23, 0x22, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x78,
 0x6d, 0x6c, 0x6e, 0x73, 0x3a, 0x64, 0x63, 0x3d,
 0x22, 0x68, 0x74, 0x74, 0x70, 0x3a, 0x2f, 0x2f,
 0x70, 0x75, 0x72, 0x6c, 0x2e, 0x6f, 0x72, 0x67,
 0x2f, 0x64, 0x63, 0x2f, 0x65, 0x6c, 0x65, 0x6d,
 0x65, 0x6e, 0x74, 0x73, 0x2f, 0x31, 0x2e, 0x31,
 0x2f, 0x22, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x78,
 0x6d, 0x6c, 0x6e, 0x73, 0x3a, 0x47, 0x49, 0x4d,
 0x50, 0x3d, 0x22, 0x68, 0x74, 0x74, 0x70, 0x3a,
 0x2f, 0x2f, 0x77, 0x77, 0x77, 0x2e, 0x67, 0x69,
 0x6d, 0x70, 0x2e, 0x6f, 0x72, 0x67, 0x2f, 0x78,
 0x6d, 0x70, 0x2f, 0x22, 0x0a, 0x20, 0x20, 0x20,
 0x20, 0x78, 0x6d, 0x6c, 0x6e, 0x73, 0x3a, 0x74,
 0x69, 0x66, 0x66, 0x3d, 0x22, 0x68, 0x74, 0x74,
 0x70, 0x3a, 0x2f, 0x2f, 0x6e, 0x73, 0x2e, 0x61,
 0x64, 0x6f, 0x62, 0x65, 0x2e, 0x63, 0x6f, 0x6d,
 0x2f, 0x74, 0x69, 0x66, 0x66, 0x2f, 0x31, 0x2e,
 0x30, 0x2f, 0x22, 0x0a, 0x20, 0x20, 0x20, 0x20,
 0x78, 0x6d, 0x6c, 0x6e, 0x73, 0x3a, 0x78, 0x6d,
 0x70, 0x3d, 0x22, 0x68, 0x74, 0x74, 0x70, 0x3a,
 0x2f, 0x2f, 0x6e, 0x73, 0x2e, 0x61, 0x64, 0x6f,
 0x62, 0x65, 0x2e, 0x63, 0x6f, 0x6d, 0x2f, 0x78,
 0x61, 0x70, 0x2f, 0x31, 0x2e, 0x30, 0x2f, 0x22,
 0x0a, 0x20, 0x20, 0x20, 0x78, 0x6d, 0x70, 0x4d,
 0x4d, 0x3a, 0x44, 0x6f, 0x63, 0x75, 0x6d, 0x65,
 0x6e, 0x74, 0x49, 0x44, 0x3d, 0x22, 0x67, 0x69,
 0x6d, 0x70, 0x3a, 0x64, 0x6f, 0x63, 0x69, 0x64,
 0x3a, 0x67, 0x69, 0x6d, 0x70, 0x3a, 0x62, 0x38,
 0x38, 0x39, 0x33, 0x34, 0x35, 0x61, 0x2d, 0x30,
 0x39, 0x33, 0x62, 0x2d, 0x34, 0x36, 0x30, 0x66,
 0x2d, 0x61, 0x30, 0x35, 0x30, 0x2d, 0x62, 0x64,
 0x37, 0x65, 0x36, 0x65, 0x35, 0x39, 0x35, 0x37,
 0x66, 0x36, 0x22, 0x0a, 0x20, 0x20, 0x20, 0x78,
 0x6d, 0x70, 0x4d, 0x4d, 0x3a, 0x49, 0x6e, 0x73,
 0x74, 0x61, 0x6e, 0x63, 0x65, 0x49, 0x44, 0x3d,
 0x22, 0x78, 0x6d, 0x70, 0x2e, 0x69, 0x69, 0x64,
 0x3a, 0x63, 0x65, 0x31, 0x36, 0x33, 0x34, 0x63,
 0x63, 0x2d, 0x61, 0x66, 0x30, 0x61, 0x2d, 0x34,
 0x66, 0x63, 0x39, 0x2d, 0x61, 0x31, 0x36, 0x38,
 0x2d, 0x39, 0x32, 0x31, 0x33, 0x35, 0x62, 0x30,
 0x65, 0x64, 0x64, 0x32, 0x32, 0x22, 0x0a, 0x20,
 0x20, 0x20, 0x78, 0x6d, 0x70, 0x4d, 0x4d, 0x3a,
 0x4f, 0x72, 0x69, 0x67, 0x69, 0x6e, 0x61, 0x6c,
 0x44, 0x6f, 0x63, 0x75, 0x6d, 0x65, 0x6e, 0x74,
 0x49, 0x44, 0x3d, 0x22, 0x78, 0x6d, 0x70, 0x2e,
 0x64, 0x69, 0x64, 0x3a, 0x31, 0x34, 0x66, 0x32,
 0x33, 0x66, 0x62, 0x38, 0x2d, 0x65, 0x34, 0x63,
 0x35, 0x2d, 0x34, 0x64, 0x30, 0x66, 0x2d, 0x61,
 0x32, 0x33, 0x32, 0x2d, 0x34, 0x32, 0x30, 0x33,
 0x30, 0x65, 0x39, 0x66, 0x36, 0x33, 0x31, 0x36,
 0x22, 0x0a, 0x20, 0x20, 0x20, 0x64, 0x63, 0x3a,
 0x46, 0x6f, 0x72, 0x6d, 0x61, 0x74, 0x3d, 0x22,
 0x69, 0x6d, 0x61, 0x67, 0x65, 0x2f, 0x70, 0x6e,
 0x67, 0x22, 0x0a, 0x20, 0x20, 0x20, 0x47, 0x49,
 0x4d, 0x50, 0x3a, 0x41, 0x50, 0x49, 0x3d, 0x22,
 0x32, 0x2e, 0x30, 0x22, 0x0a, 0x20, 0x20, 0x20,
 0x47, 0x49, 0x4d, 0x50, 0x3a, 0x50, 0x6c, 0x61,
 0x74, 0x66, 0x6f, 0x72, 0x6d, 0x3d, 0x22, 0x4c,
 0x69, 0x6e, 0x75, 0x78, 0x22, 0x0a, 0x20, 0x20,
 0x20, 0x47, 0x49, 0x4d, 0x50, 0x3a, 0x54, 0x69,
 0x6d, 0x65, 0x53, 0x74, 0x61, 0x6d, 0x70, 0x3d,
 0x22, 0x31, 0x37, 0x30, 0x36, 0x39, 0x33, 0x35,
 0x34, 0x39, 0x30, 0x36, 0x30, 0x36, 0x33, 0x38,
 0x34, 0x22, 0x0a, 0x20, 0x20, 0x20, 0x47, 0x49,
 0x4d, 0x50, 0x3a, 0x56, 0x65, 0x72, 0x73, 0x69,
 0x6f, 0x6e, 0x3d, 0x22, 0x32, 0x2e, 0x31, 0x30,
 0x2e, 0x33, 0x32, 0x22, 0x0a, 0x20, 0x20, 0x20,
 0x74, 0x69, 0x66, 0x66, 0x3a, 0x4f, 0x72, 0x69,
 0x65, 0x6e, 0x74, 0x61, 0x74, 0x69, 0x6f, 0x6e,
 0x3d, 0x22, 0x31, 0x22, 0x0a, 0x20, 0x20, 0x20,
 0x78, 0x6d, 0x70, 0x3a, 0x43, 0x72, 0x65, 0x61,
 0x74, 0x6f, 0x72, 0x54, 0x6f, 0x6f, 0x6c, 0x3d,
 0x22, 0x47, 0x49, 0x4d, 0x50, 0x20, 0x32, 0x2e,
 0x31, 0x30, 0x22, 0x0a, 0x20, 0x20, 0x20, 0x78,
 0x6d, 0x70, 0x3a, 0x4d, 0x65, 0x74, 0x61, 0x64,
 0x61, 0x74, 0x61, 0x44, 0x61, 0x74, 0x65, 0x3d,
 0x22, 0x32, 0x30, 0x32, 0x34, 0x3a, 0x30, 0x32,
 0x3a, 0x30, 0x33, 0x54, 0x31, 0x34, 0x3a, 0x34,
 0x34, 0x3a, 0x34, 0x32, 0x2b, 0x31, 0x30, 0x3a,
 0x30, 0x30, 0x22, 0x0a, 0x20, 0x20, 0x20, 0x78,
 0x6d, 0x70, 0x3a, 0x4d, 0x6f, 0x64, 0x69, 0x66,
 0x79, 0x44, 0x61, 0x74, 0x65, 0x3d, 0x22, 0x32,
 0x30, 0x32, 0x34, 0x3a, 0x30, 0x32, 0x3a, 0x30,
 0x33, 0x54, 0x31, 0x34, 0x3a, 0x34, 0x34, 0x3a,
 0x34, 0x32, 0x2b, 0x31, 0x30, 0x3a, 0x30, 0x30,
 0x22, 0x3e, 0x0a, 0x20, 0x20, 0x20, 0x3c, 0x78,
 0x6d, 0x70, 0x4d, 0x4d, 0x3a, 0x48, 0x69, 0x73,
 0x74, 0x6f, 0x72, 0x79, 0x3e, 0x0a, 0x20, 0x20,
 0x20, 0x20, 0x3c, 0x72, 0x64, 0x66, 0x3a, 0x53,
 0x65, 0x71, 0x3e, 0x0a, 0x20, 0x20, 0x20, 0x20,
 0x20, 0x3c, 0x72, 0x64, 0x66, 0x3a, 0x6c, 0x69,
 0x0a, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x73,
 0x74, 0x45, 0x76, 0x74, 0x3a, 0x61, 0x63, 0x74,
 0x69, 0x6f, 0x6e, 0x3d, 0x22, 0x73, 0x61, 0x76,
 0x65, 0x64, 0x22, 0x0a, 0x20, 0x20, 0x20, 0x20,
 0x20, 0x20, 0x73, 0x74, 0x45, 0x76, 0x74, 0x3a,
 0x63, 0x68, 0x61, 0x6e, 0x67, 0x65, 0x64, 0x3d,
 0x22, 0x2f, 0x22, 0x0a, 0x20, 0x20, 0x20, 0x20,
 0x20, 0x20, 0x73, 0x74, 0x45, 0x76, 0x74, 0x3a,
 0x69, 0x6e, 0x73, 0x74, 0x61, 0x6e, 0x63, 0x65,
 0x49, 0x44, 0x3d, 0x22, 0x78, 0x6d, 0x70, 0x2e,
 0x69, 0x69, 0x64, 0x3a, 0x64, 0x31, 0x65, 0x36,
 0x38, 0x64, 0x63, 0x30, 0x2d, 0x66, 0x34, 0x62,
 0x61, 0x2d, 0x34, 0x34, 0x39, 0x65, 0x2d, 0x38,
 0x62, 0x65, 0x35, 0x2d, 0x38, 0x39, 0x36, 0x35,
 0x36, 0x63, 0x36, 0x37, 0x32, 0x37, 0x63, 0x38,
 0x22, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
 0x73, 0x74, 0x45, 0x76, 0x74, 0x3a, 0x73, 0x6f,
 0x66, 0x74, 0x77, 0x61, 0x72, 0x65, 0x41, 0x67,
 0x65, 0x6e, 0x74, 0x3d, 0x22, 0x47, 0x69, 0x6d,
 0x70, 0x20, 0x32, 0x2e, 0x31, 0x30, 0x20, 0x28,
 0x4c, 0x69, 0x6e, 0x75, 0x78, 0x29, 0x22, 0x0a,
 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x73, 0x74,
 0x45, 0x76, 0x74, 0x3a, 0x77, 0x68, 0x65, 0x6e,
 0x3d, 0x22, 0x32, 0x30, 0x32, 0x34, 0x2d, 0x30,
 0x32, 0x2d, 0x30, 0x33, 0x54, 0x31, 0x34, 0x3a,
 0x34, 0x34, 0x3a, 0x35, 0x30, 0x2b, 0x31, 0x30,
 0x3a, 0x30, 0x30, 0x22, 0x2f, 0x3e, 0x0a, 0x20,
 0x20, 0x20, 0x20, 0x3c, 0x2f, 0x72, 0x64, 0x66,
 0x3a, 0x53, 0x65, 0x71, 0x3e, 0x0a, 0x20, 0x20,
 0x20, 0x3c, 0x2f, 0x78, 0x6d, 0x70, 0x4d, 0x4d,
 0x3a, 0x48, 0x69, 0x73, 0x74, 0x6f, 0x72, 0x79,
 0x3e, 0x0a, 0x20, 0x20, 0x3c, 0x2f, 0x72, 0x64,
 0x66, 0x3a, 0x44, 0x65, 0x73, 0x63, 0x72, 0x69,
 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x3e, 0x0a, 0x20,
 0x3c, 0x2f, 0x72, 0x64, 0x66, 0x3a, 0x52, 0x44,
 0x46, 0x3e, 0x0a, 0x3c, 0x2f, 0x78, 0x3a, 0x78,
 0x6d, 0x70, 0x6d, 0x65, 0x74, 0x61, 0x3e, 0x0a,
 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
 0x20, 0x20, 0x20, 0x20, 0x0a, 0x20, 0x20, 0x20,
 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
 0x20, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x0a, 0x20,
 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
 0x20, 0x20, 0x20, 0x0a, 0x20, 0x20, 0x20, 0x20,
 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
 0x0a, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
 0x20, 0x20, 0x20, 0x20, 0x20, 0x0a, 0x20, 0x20,
 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
 0x20, 0x20, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x20,
 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x0a,
 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
 0x20, 0x20, 0x20, 0x20, 0x0a, 0x20, 0x20, 0x20,
 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
 0x20, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x0a, 0x20,
 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
 0x20, 0x20, 0x20, 0x0a, 0x20, 0x20, 0x20, 0x20,
 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
 0x0a, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
 0x20, 0x20, 0x20, 0x20, 0x20, 0x0a, 0x20, 0x20,
 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
 0x20, 0x20, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x20,
 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x0a,
 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
 0x20, 0x20, 0x20, 0x20, 0x0a, 0x20, 0x20, 0x20,
 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
 0x20, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x0a, 0x20,
 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
 0x20, 0x20, 0x20, 0x0a, 0x20, 0x20, 0x20, 0x20,
 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20,
 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x20, 0x0a,
 0x3c, 0x3f, 0x78, 0x70, 0x61, 0x63, 0x6b, 0x65,
 0x74, 0x20, 0x65, 0x6e, 0x64, 0x3d, 0x22, 0x77,
 0x22, 0x3f, 0x3e, 0x2b, 0x21, 0xab, 0xc6, 0x00,
 0x00, 0x00, 0x06, 0x62, 0x4b, 0x47, 0x44, 0x00,
 0x00, 0x00, 0x00, 0x00, 0x00, 0xf9, 0x43, 0xbb,
 0x7f, 0x00, 0x00, 0x00, 0x09, 0x70, 0x48, 0x59,
 0x73, 0x00, 0x00, 0x0b, 0x13, 0x00, 0x00, 0x0b,
 0x13, 0x01, 0x00, 0x9a, 0x9c, 0x18, 0x00, 0x00,
 0x00, 0x07, 0x74, 0x49, 0x4d, 0x45, 0x07, 0xe8,
 0x02, 0x03, 0x04, 0x2c, 0x32, 0xa8, 0x59, 0x5d,
 0x33, 0x00, 0x00, 0x17, 0xa2, 0x49, 0x44, 0x41,
 0x54, 0x78, 0xda, 0xed, 0x9d, 0x5b, 0x6c, 0x1c,
 0xd7, 0x79, 0xc7, 0xff, 0xdf, 0x39, 0x67, 0x66,
 0x2f, 0xe4, 0x92, 0xd4, 0xa5, 0x62, 0xdc, 0xc8,
 0x8e, 0x2d, 0x59, 0x8a, 0xed, 0x34, 0x46, 0x73,
 0x6b, 0x9c, 0x00, 0xb1, 0x1b, 0xf7, 0xe2, 0x17,
 0x3b, 0x4d, 0x63, 0xb4, 0x6e, 0xe2, 0x22, 0x75,
 0x03, 0x03, 0x01, 0x1c, 0x20, 0xe9, 0x73, 0xd3,
 0x02, 0x7e, 0x4a, 0xda, 0x34, 0xed, 0x43, 0x5f,
 0xfa, 0x10, 0xa0, 0x15, 0xf2, 0xe2, 0xbc, 0x24,
 0xb1, 0x81, 0xc4, 0x10, 0xe0, 0x87, 0xca, 0x97,
 0xc4, 0x6e, 0x6b, 0xf8, 0x12, 0xbb, 0x8e, 0x53,
 0x3b, 0xae, 0x2c, 0x89, 0x14, 0x29, 0x52, 0x22,
 0x57, 0x24, 0x97, 0x3b, 0xb7, 0x73, 0xfa, 0xb0,
 0x33, 0xb3, 0x67, 0x66, 0x67, 0x97, 0x33, 0xbb,
 0xab, 0x58, 0x4e, 0xbf, 0xbf, 0xb0, 0x26, 0xb9,
 0x5e, 0xee, 0x2c, 0x67, 0x7e, 0xf3, 0x9f, 0xff,
 0xf9, 0xce, 0x37, 0x33, 0x84, 0x09, 0x65, 0x8c,
 0x21, 0xb0, 0x58, 0x13, 0x88, 0x88, 0xcc, 0xd8,
 0xbf, 0x3b, 0x06, 0xac, 0x94, 0xfb, 0xfd, 0xa2,
 0xe7, 0x58, 0xac, 0x91, 0x28, 0x59, 0x5f, 0x4d,
 0xc1, 0x73, 0xa5, 0xa1, 0xa6, 0x92, 0xd0, 0xda,
 0xb0, 0x8a, 0x21, 0x5f, 0x19, 0x5e, 0xd6, 0xb8,
 0x00, 0x1b, 0x00, 0x3a, 0x7e, 0x24, 0xdf, 0x03,
 0x80, 0xd9, 0x0b, 0x64, 0x2a, 0xe9, 0xb8, 0x09,
 0xa8, 0x32, 0xfe, 0xaa, 0x00, 0x08, 0xdf, 0xf7,
 0x85, 0xe7, 0x79, 0x52, 0x6b, 0x2d, 0xc2, 0x30,
 0x14, 0xbd, 0x1d, 0x87, 0x18, 0x62, 0xd6, 0x28,
 0xa6, 0x0c, 0x00, 0x48, 0x29, 0xb5, 0x10, 0x42,
 0x3b, 0x8e, 0xa3, 0x5d, 0xd7, 0x8d, 0xa4, 0x94,
 0x51, 0x0c, 0x6e, 0x14, 0x3f, 0x6c, 0xa0, 0x87,
 0x3a, 0x32, 0x95, 0x80, 0x37, 0x01, 0x57, 0x19,
 0x63, 0x94, 0xe7, 0x79, 0x4e, 0xb7, 0xdb, 0x75,
 0x89, 0x48, 0x9d, 0x3a, 0x75, 0x6a, 0xff, 0xe3,
 0x8f, 0x3f, 0x7e, 0x4d, 0xa7, 0xd3, 0x69, 0xad,
 0xad, 0xad, 0x2d, 0x0a, 0x21, 0x18, 0x5e, 0x56,
 0x29, 0x35, 0x9b, 0xcd, 0xf6, 0xc2, 0xc2, 0xc2,
 0xc6, 0xb1, 0x63, 0xc7, 0xd6, 0xee, 0xbc, 0xf3,
 0xce, 0xf5, 0xe3, 0xc7, 0x8f, 0x77, 0x94, 0x52,
 0x41, 0xad, 0x56, 0x0b, 0x94, 0x52, 0x41, 0x0c,
 0x71, 0x68, 0x41, 0x5c, 0xe8, 0xc6, 0x34, 0x02,
 0x5e, 0x61, 0xb9, 0xad, 0x13, 0x86, 0xa1, 0xbb,
 0xb6, 0xb6, 0x56, 0xff, 0xce, 0x77, 0xbe, 0x73,
 0xfc, 0xd4, 0xa9, 0x53, 0x9f, 0xda, 0xd9, 0xd9,
 0xf9, 0xf0, 0xd6, 0xd6, 0xd6, 0xf5, 0x17, 0x2e,
 0x5c, 0x68, 0x6a, 0xad, 0xe5, 0xee, 0xee, 0x6e,
 0x8d, 0xcd, 0x97, 0x55, 0x56, 0x4a, 0xa9, 0xd0,
 0x75, 0xdd, 0xa0, 0xd9, 0x6c, 0x06, 0xfb, 0xf6,
 0xed, 0x5b, 0x99, 0x9b, 0x9b, 0x7b, 0xf5, 0xc8,
 0x91, 0x23, 0xcf, 0xdc, 0x77, 0xdf, 0x7d, 0x2f,
 0xdd, 0x75, 0xd7, 0x5d, 0x1b, 0x42, 0x08, 0x9f,
 0x88, 0x82, 0x18, 0xe2, 0xc4, 0x91, 0x07, 0x20,
 0xa6, 0x11, 0xf0, 0xca, 0x18, 0x5e, 0x17, 0x80,
 0xfb, 0xad, 0x6f, 0x7d, 0xeb, 0x96, 0x1f, 0xff,
 0xf8, 0xc7, 0xf7, 0x9c, 0x3b, 0x77, 0xee, 0x8e,
 0xb3, 0x67, 0xcf, 0x1e, 0x0e, 0xc3, 0x70, 0x1e,
 0x40, 0x5d, 0x4a, 0x09, 0x22, 0x4a, 0x1f, 0x2c,
 0x56, 0xc9, 0x28, 0x01, 0x63, 0x0c, 0xb4, 0xd6,
 0x30, 0xc6, 0x84, 0x44, 0xb4, 0xb5, 0xb0, 0xb0,
 0xb0, 0x7e, 0xf8, 0xf0, 0xe1, 0x17, 0x6e, 0xbb,
 0xed, 0xb6, 0x1f, 0x7e, 0xf9, 0xcb, 0x5f, 0x7e,
 0xee, 0x43, 0x1f, 0xfa, 0xd0, 0x16, 0x00, 0x1f,
 0x40, 0x30, 0x0c, 0x62, 0x1a, 0x12, 0x1b, 0x24,
 0x00, 0x07, 0x40, 0xed, 0xcc, 0x99, 0x33, 0xcd,
 0x6f, 0x7e, 0xf3, 0x9b, 0xbf, 0x7f, 0xea, 0xd4,
 0xa9, 0x2f, 0xbc, 0xf9, 0xe6, 0x9b, 0x1f, 0x05,
 0xb0, 0xe0, 0x38, 0x8e, 0x70, 0x1c, 0x07, 0x8e,
 0xe3, 0x40, 0x29, 0x05, 0x21, 0x04, 0x03, 0xcc,
 0xaa, 0x0c, 0xb0, 0xd6, 0x1a, 0x51, 0x14, 0x21,
 0x0c, 0x43, 0x04, 0x41, 0x00, 0xdf, 0xf7, 0x11,
 0x45, 0xd1, 0xce, 0xe2, 0xe2, 0xe2, 0x2f, 0x6f,
 0xbd, 0xf5, 0xd6, 0xc7, 0x1e, 0x7c, 0xf0, 0xc1,
 0x47, 0xee, 0xbd, 0xf7, 0xde, 0x0b, 0x31, 0xc4,
 0x7e, 0x02, 0x31, 0x11, 0xe9, 0xd4, 0xc9, 0x87,
 0xc0, 0xab, 0x00, 0xd4, 0x7e, 0xf1, 0x8b, 0x5f,
 0xcc, 0x3e, 0xfc, 0xf0, 0xc3, 0xf7, 0x3d, 0xf3,
 0xcc, 0x33, 0xf7, 0x2f, 0x2f, 0x2f, 0xdf, 0x5c,
 0xaf, 0xd7, 0x6b, 0xcd, 0x66, 0x13, 0x8d, 0x46,
 0x03, 0xfb, 0xf7, 0xef, 0xc7, 0xa1, 0x43, 0x87,
 0xd0, 0x6a, 0xb5, 0x40, 0x44, 0x88, 0xb3, 0x39,
 0x8b, 0x55, 0x5a, 0x44, 0x04, 0xad, 0x35, 0xda,
 0xed, 0x36, 0xce, 0x9f, 0x3f, 0x8f, 0x4b, 0x97,
 0x2e, 0x61, 0x77, 0x77, 0x77, 0x66, 0x6d, 0x6d,
 0xed, 0x83, 0xcf, 0x3d, 0xf7, 0xdc, 0x81, 0x76,
 0xbb, 0xbd, 0x6f, 0x75, 0x75, 0xf5, 0xc4, 0x43,
 0x0f, 0x3d, 0x74, 0xda, 0xae, 0x58, 0x18, 0x63,
 0x28, 0x71, 0x61, 0x95, 0x8b, 0x13, 0xc2, 0x72,
 0x5f, 0xf7, 0xdb, 0xdf, 0xfe, 0xf6, 0xdd, 0x4f,
 0x3d, 0xf5, 0xd4, 0x17, 0x57, 0x57, 0x57, 0x3f,
 0xd0, 0x6a, 0xb5, 0xc4, 0xdc, 0xdc, 0x1c, 0x0e,
 0x1f, 0x3e, 0x8c, 0xa3, 0x47, 0x8f, 0x62, 0x71,
 0x71, 0x11, 0xb5, 0x5a, 0x2d, 0x75, 0xdd, 0x04,
 0x60, 0x06, 0x99, 0x55, 0x06, 0xdc, 0xe4, 0x6b,
 0x62, 0x7e, 0xbe, 0xef, 0x63, 0x79, 0x79, 0x19,
 0xaf, 0xbe, 0xfa, 0x2a, 0x96, 0x96, 0x96, 0x68,
 0x7b, 0x7b, 0xfb, 0xbd, 0x2f, 0xbe, 0xf8, 0xe2,
 0x9f, 0x0a, 0x21, 0xa2, 0x6b, 0xaf, 0xbd, 0xf6,
 0x5f, 0xee, 0xbe, 0xfb, 0xee, 0xb5, 0xd8, 0x79,
 0x13, 0x88, 0x41, 0x44, 0x46, 0x15, 0x54, 0x1c,
 0x14, 0x80, 0xda, 0xd7, 0xbf, 0xfe, 0xf5, 0x8f,
 0x3f, 0xf9, 0xe4, 0x93, 0x9f, 0x5f, 0x5d, 0x5d,
 0xbd, 0xb9, 0xd5, 0x6a, 0x89, 0x83, 0x07, 0x0f,
 0xe2, 0xf8, 0xf1, 0xe3, 0x38, 0x72, 0xe4, 0x08,
 0xf6, 0xef, 0xdf, 0x0f, 0xa5, 0x54, 0x7a, 0x18,
 0x60, 0x80, 0x59, 0x55, 0xe1, 0x4d, 0xbe, 0x17,
 0x42, 0x40, 0x4a, 0x89, 0x66, 0xb3, 0x89, 0x66,
 0xb3, 0x89, 0xb9, 0xb9, 0x39, 0xbc, 0xf1, 0xc6,
 0x1b, 0x78, 0xe5, 0x95, 0x57, 0xd0, 0x6e, 0xb7,
 0x0f, 0xbd, 0xf6, 0xda, 0x6b, 0x9f, 0x3d, 0x71,
 0xe2, 0xc4, 0x85, 0x4f, 0x7f, 0xfa, 0xd3, 0x27,
 0x66, 0x67, 0x67, 0x07, 0xca, 0x6b, 0x79, 0x07,
 0x96, 0x51, 0x14, 0x39, 0x27, 0x4f, 0x9e, 0xdc,
 0x7f, 0xf2, 0xe4, 0xc9, 0xfb, 0xde, 0x7a, 0xeb,
 0xad, 0x0f, 0xcf, 0xcc, 0xcc, 0xa8, 0xfd, 0xfb,
 0xf7, 0xe3, 0xd6, 0x5b, 0x6f, 0xc5, 0x0d, 0x37,
 0xdc, 0x80, 0x56, 0xab, 0x05, 0x00, 0xf0, 0x3c,
 0x0f, 0x51, 0x14, 0xa5, 0x61, 0xbc, 0x4a, 0xf6,
 0x61, 0xfd, 0xff, 0x81, 0x74, 0x2f, 0x25, 0xe3,
 0x27, 0x29, 0x25, 0x5c, 0xd7, 0xc5, 0x35, 0xd7,
 0x5c, 0x83, 0x5a, 0xad, 0x06, 0xa5, 0x14, 0x5e,
 0x78, 0xe1, 0x05, 0x6c, 0x6c, 0x6c, 0x5c, 0xfb,
 0xf2, 0xcb, 0x2f, 0x7f, 0xf6, 0x1b, 0xdf, 0xf8,
 0xc6, 0xcf, 0x1e, 0x7e, 0xf8, 0xe1, 0xff, 0x70,
 0x5d, 0x37, 0xa9, 0x13, 0x1b, 0x00, 0x46, 0xe5,
 0xe3, 0x43, 0x10, 0x04, 0xee, 0x23, 0x8f, 0x3c,
 0xf2, 0xc9, 0x33, 0x67, 0xce, 0xfc, 0x8e, 0x52,
 0x6a, 0xa6, 0xd5, 0x6a, 0xe1, 0xc6, 0x1b, 0x6f,
 0xc4, 0xfb, 0xde, 0xf7, 0x3e, 0xcc, 0xcd, 0xcd,
 0x21, 0x08, 0x02, 0x04, 0x41, 0x90, 0xc2, 0x3b,
 0x0e, 0x94, 0x7b, 0xbe, 0x9e, 0x21, 0xbf, 0x5a,
 0xc9, 0x9c, 0x2a, 0xbc, 0xf9, 0x38, 0x11, 0x04,
 0x01, 0x6a, 0xb5, 0x1a, 0x0e, 0x1c, 0x38, 0x80,
 0x63, 0xc7, 0x8e, 0x61, 0x6d, 0x6d, 0x0d, 0x41,
 0x10, 0x88, 0xb7, 0xdf, 0x7e, 0xfb, 0xf8, 0xd3,
 0x4f, 0x3f, 0x7d, 0xcf, 0xd6, 0xd6, 0xd6, 0x4b,
 0x07, 0x0e, 0x1c, 0xf0, 0xe3, 0x98, 0xab, 0x8d,
 0x31, 0xa4, 0xec, 0xf8, 0xa0, 0xb5, 0x56, 0x67,
 0xcf, 0x9e, 0x6d, 0xbc, 0xf1, 0xc6, 0x1b, 0x7f,
 0x70, 0xe9, 0xd2, 0xa5, 0x6b, 0xe6, 0xe6, 0xe6,
 0x70, 0xe0, 0xc0, 0x01, 0x5c, 0x7f, 0xfd, 0xf5,
 0x68, 0xb5, 0x5a, 0xf6, 0x48, 0x31, 0x29, 0x7f,
 0xa4, 0x31, 0x22, 0x79, 0x94, 0x86, 0xd9, 0x7a,
 0x9d, 0x61, 0x80, 0xdf, 0x95, 0x00, 0xd3, 0x18,
 0x90, 0x27, 0xc0, 0x0a, 0x21, 0xd2, 0x47, 0x92,
 0x85, 0x13, 0x53, 0x94, 0x52, 0x62, 0x7e, 0x7e,
 0x1e, 0x47, 0x8f, 0x1e, 0xc5, 0xea, 0xea, 0x2a,
 0x3a, 0x9d, 0xce, 0xfc, 0xca, 0xca, 0xca, 0x47,
 0x4f, 0x9c, 0x38, 0x71, 0xc3, 0x57, 0xbe, 0xf2,
 0x95, 0x9f, 0xd7, 0xeb, 0xf5, 0x20, 0x59, 0x7c,
 0xc6, 0x81, 0x7d, 0xdf, 0x97, 0x8f, 0x3e, 0xfa,
 0xe8, 0x6f, 0xae, 0xaf, 0xaf, 0xdf, 0x24, 0xa5,
 0x9c, 0x69, 0x34, 0x1a, 0x38, 0x74, 0xe8, 0x10,
 0xe6, 0xe6, 0xe6, 0xd2, 0x3d, 0xc4, 0x86, 0x57,
 0x6b, 0x0d, 0xdf, 0xf7, 0xd3, 0x38, 0x91, 0x40,
 0x3c, 0x11, 0xbc, 0xac, 0x77, 0x17, 0xd3, 0x23,
 0x00, 0xce, 0x0f, 0xd6, 0xec, 0xcc, 0xab, 0x94,
 0x82, 0x94, 0x32, 0x85, 0x39, 0x51, 0xc2, 0x94,
 0xe3, 0x38, 0x58, 0x5c, 0x5c, 0xc4, 0xfc, 0xfc,
 0x3c, 0xb6, 0xb6, 0xb6, 0xb0, 0xbc, 0xbc, 0xbc,
 0xf8, 0xc4, 0x13, 0x4f, 0x7c, 0xec, 0x4b, 0x5f,
 0xfa, 0xd2, 0x9b, 0xf5, 0x7a, 0x3d, 0xe9, 0xbf,
 0x21, 0x1b, 0x60, 0xf2, 0x3c, 0x4f, 0x3d, 0xfb,
 0xec, 0xb3, 0xef, 0x5f, 0x5b, 0x5b, 0xdb, 0xe7,
 0x38, 0x0e, 0xea, 0xf5, 0x3a, 0xf6, 0xed, 0xdb,
 0x07, 0x29, 0x25, 0xc2, 0x30, 0xcc, 0xc0, 0x9b,
 0x2c, 0xac, 0xdb, 0xed, 0xa2, 0xdd, 0x6e, 0x63,
 0x63, 0xe3, 0x12, 0xa2, 0x68, 0x0f, 0x07, 0x4e,
 0x22, 0x07, 0x6f, 0xf7, 0x5f, 0x7f, 0x98, 0x2d,
 0x68, 0x13, 0x70, 0x13, 0x78, 0x93, 0xc7, 0xe2,
 0xe2, 0x22, 0x66, 0x67, 0x67, 0x33, 0xb1, 0x43,
 0x6b, 0x8d, 0x30, 0x0c, 0xe1, 0x38, 0x4e, 0x5a,
 0xae, 0xbd, 0x70, 0xe1, 0x02, 0x3a, 0x9d, 0x4e,
 0xab, 0xdd, 0x6e, 0xff, 0x56, 0x18, 0x86, 0x0a,
 0xfd, 0x59, 0xe2, 0x48, 0x59, 0xcb, 0x15, 0x51,
 0x14, 0xc9, 0x76, 0xbb, 0x7d, 0x9d, 0xef, 0xfb,
 0x0d, 0xd7, 0x75, 0x51, 0xab, 0xd5, 0xd0, 0x68,
 0x34, 0xd2, 0x7a, 0x5d, 0x1e, 0xce, 0x30, 0x0c,
 0xe1, 0x79, 0x1e, 0xc2, 0x30, 0xc4, 0xa5, 0x4b,
 0x17, 0xf1, 0xb3, 0x9f, 0xbd, 0xca, 0x5b, 0x91,
 0x55, 0x5a, 0xf7, 0xdf, 0x7f, 0x3f, 0xe6, 0xe7,
 0xe7, 0x33, 0x85, 0x00, 0x3b, 0x92, 0x12, 0x11,
 0x5a, 0xad, 0x56, 0x52, 0xf1, 0x6a, 0x04, 0x41,
 0x70, 0xad, 0xd6, 0x3a, 0x69, 0x28, 0x23, 0x00,
 0x24, 0x6c, 0x07, 0x36, 0xc6, 0x08, 0xdf, 0xf7,
 0x17, 0xa2, 0x28, 0x52, 0x42, 0x88, 0x8c, 0xcd,
 0x17, 0x65, 0x5c, 0xad, 0x35, 0x82, 0x20, 0x80,
 0x52, 0x0a, 0x07, 0x0f, 0x1e, 0xe2, 0x99, 0x38,
 0x56, 0x05, 0xbb, 0xee, 0xb1, 0x95, 0xc4, 0x07,
 0x3b, 0x96, 0xda, 0xac, 0x25, 0xae, 0x0d, 0xc0,
 0xd1, 0x5a, 0x2f, 0x58, 0xee, 0x4b, 0x88, 0xbf,
 0xb1, 0x01, 0x26, 0x63, 0x4c, 0x0d, 0x80, 0x4c,
 0x6c, 0x3f, 0xd9, 0x2b, 0x86, 0x3d, 0x2a, 0x0d,
 0xdc, 0x58, 0xac, 0x34, 0x4e, 0x86, 0x48, 0x4c,
 0xb2, 0x68, 0x32, 0xcc, 0x1e, 0x4f, 0x59, 0xc6,
 0x58, 0xcb, 0x9f, 0x01, 0xa4, 0x72, 0x23, 0xc4,
 0xa2, 0xe6, 0x9e, 0x81, 0x47, 0xd1, 0xff, 0x63,
 0xb1, 0xaa, 0x2a, 0xc9, 0xc2, 0xc9, 0x6c, 0x9c,
 0xdd, 0x92, 0x30, 0xac, 0x44, 0x9b, 0x67, 0x54,
 0x8c, 0xaa, 0xcb, 0xe5, 0x41, 0x2d, 0x1a, 0x94,
 0x31, 0xbc, 0xac, 0x69, 0x00, 0x5c, 0x04, 0x6d,
 0x01, 0xbc, 0xf6, 0x78, 0x31, 0x53, 0x85, 0x18,
 0x51, 0x38, 0x30, 0x43, 0x41, 0x36, 0x05, 0x65,
 0x31, 0x16, 0xab, 0xac, 0xd2, 0x3a, 0x70, 0xcc,
 0x56, 0xde, 0x34, 0x0b, 0xa3, 0x73, 0xce, 0x81,
 0x55, 0x51, 0x05, 0x64, 0x2f, 0x90, 0x53, 0x68,
 0x93, 0xe7, 0x78, 0xf0, 0xc6, 0x1a, 0x67, 0x1c,
 0x97, 0x34, 0xf3, 0x14, 0x18, 0xe5, 0x30, 0x88,
 0xf3, 0xcf, 0xa9, 0x32, 0x0b, 0xb2, 0xdf, 0xd0,
 0x58, 0xe0, 0x1a, 0x76, 0x5f, 0xd6, 0x24, 0x0e,
 0x6c, 0xf5, 0x90, 0x17, 0x01, 0x3c, 0xca, 0x89,
 0x2b, 0x01, 0x3c, 0x6c, 0xc0, 0x96, 0x7e, 0xcf,
 0x10, 0xb3, 0x26, 0xae, 0x4a, 0x64, 0x8f, 0xe6,
 0x65, 0x8b, 0x03, 0xaa, 0x2c, 0xb8, 0x99, 0x81,
 0x5b, 0x6e, 0x10, 0xc7, 0xf8, 0xb2, 0xc6, 0x8e,
 0x11, 0xc3, 0x98, 0x2a, 0x69, 0x8a, 0xa5, 0x23,
 0x84, 0xc9, 0xc3, 0xca, 0xf0, 0xb2, 0x26, 0x35,
 0x5d, 0x00, 0x3a, 0x07, 0x6c, 0xd5, 0xd1, 0x94,
 0xaa, 0xbe, 0xd4, 0x3e, 0xb4, 0x76, 0x1e, 0x66,
 0xb1, 0xc6, 0x8a, 0x0d, 0x31, 0x4f, 0xc6, 0x1a,
 0x57, 0x4d, 0xdd, 0x81, 0x6d, 0x17, 0xd6, 0xb9,
 0x32, 0x1a, 0xe3, 0xcb, 0x9a, 0xc4, 0x81, 0x4d,
 0xce, 0x08, 0x4d, 0xc1, 0x64, 0xc6, 0x74, 0x33,
 0x70, 0x6e, 0xef, 0x01, 0xc7, 0x08, 0xd6, 0xd8,
 0x06, 0x9c, 0x9b, 0xe1, 0x25, 0xea, 0x83, 0x3c,
 0xad, 0x41, 0x5c, 0xf2, 0x66, 0x03, 0xcd, 0x3c,
 0xdc, 0x1a, 0xc9, 0xba, 0x42, 0x95, 0x88, 0x2a,
 0x2d, 0x0a, 0x6a, 0x92, 0x85, 0x24, 0x01, 0x9c,
 0xbb, 0xd0, 0x58, 0xe3, 0x3a, 0x70, 0x7a, 0x14,
 0x8f, 0x8f, 0xe4, 0xc2, 0x62, 0xac, 0x4c, 0x8c,
 0x28, 0x1d, 0x21, 0x06, 0x32, 0x30, 0x47, 0x08,
 0xd6, 0x94, 0x63, 0x04, 0x8d, 0x31, 0x88, 0x13,
 0x55, 0x47, 0x8c, 0x76, 0x25, 0xc2, 0x80, 0xcf,
 0x32, 0x66, 0x4d, 0x16, 0x19, 0x4c, 0x8e, 0xa5,
 0xb4, 0x30, 0x70, 0xc5, 0xea, 0xc0, 0x36, 0xc4,
 0xf1, 0x02, 0x89, 0x21, 0x66, 0x4d, 0x63, 0x10,
 0x67, 0x73, 0x55, 0x32, 0x9e, 0x96, 0x8e, 0x10,
 0x69, 0xc1, 0x59, 0xeb, 0x1e, 0xb4, 0x15, 0xf6,
 0x12, 0x16, 0xab, 0x8c, 0x13, 0x83, 0x08, 0x34,
 0xa4, 0xf7, 0x7c, 0xf2, 0x08, 0x81, 0xc1, 0xeb,
 0xc1, 0x1b, 0xce, 0xc0, 0xac, 0x69, 0x38, 0x70,
 0xee, 0xe7, 0x2a, 0xc6, 0x58, 0x79, 0x22, 0x03,
 0x13, 0x2e, 0x90, 0xc5, 0xca, 0x1b, 0xa2, 0xd1,
 0x1a, 0x26, 0x3e, 0x89, 0xd3, 0x58, 0xed, 0x95,
 0x65, 0x5c, 0x58, 0x55, 0x02, 0x37, 0x81, 0xd7,
 0x9e, 0xf6, 0x03, 0xdf, 0x18, 0x83, 0x35, 0x7e,
 0x74, 0x40, 0x7e, 0xe0, 0x96, 0x8b, 0xac, 0xd3,
 0x71, 0xe0, 0x82, 0x26, 0x1e, 0x20, 0x5b, 0xc7,
 0x63, 0xb1, 0xc6, 0x75, 0xe0, 0x94, 0xa5, 0x38,
 0x03, 0x63, 0xda, 0xfd, 0xc0, 0x43, 0xeb, 0xc0,
 0xe0, 0x99, 0x38, 0xd6, 0x14, 0x1c, 0x38, 0xe7,
 0xc4, 0x53, 0xad, 0x03, 0x1b, 0xab, 0x5b, 0xa8,
 0x30, 0x4a, 0xf0, 0x89, 0x9d, 0xac, 0x09, 0x01,
 0xce, 0x1c, 0xd5, 0xf3, 0xae, 0x3c, 0x69, 0x84,
 0x18, 0xa8, 0xd1, 0xe5, 0xa2, 0x04, 0xa3, 0xcb,
 0x9a, 0x78, 0x10, 0x97, 0x1b, 0x5b, 0xa1, 0x42,
 0x71, 0xa0, 0x5a, 0x15, 0xc2, 0x8e, 0x0e, 0xb6,
 0x33, 0xf3, 0xb6, 0x60, 0x8d, 0x65, 0xc0, 0xd9,
 0xa3, 0x79, 0x52, 0x10, 0x30, 0x15, 0xcc, 0xb1,
 0xfc, 0x49, 0x9d, 0xb9, 0xb2, 0x86, 0x3d, 0x80,
 0xe3, 0x2a, 0x04, 0x6b, 0x12, 0x88, 0x07, 0x22,
 0xc4, 0x34, 0xbb, 0xd1, 0xf2, 0xf0, 0x96, 0x3d,
 0xfd, 0x99, 0xc5, 0x2a, 0x13, 0x21, 0x90, 0x77,
 0xdf, 0x5c, 0x61, 0x60, 0x3a, 0x55, 0x08, 0x20,
 0x63, 0xf3, 0x99, 0x0c, 0xcc, 0xf0, 0xb2, 0x26,
 0x18, 0xc4, 0x15, 0x45, 0x88, 0x2a, 0xaa, 0x56,
 0x46, 0x43, 0xf1, 0xa9, 0xf4, 0x8c, 0x30, 0x6b,
 0xec, 0x41, 0x5c, 0x5c, 0x9a, 0xd5, 0x05, 0xed,
 0x94, 0x57, 0x3e, 0x42, 0x30, 0xbc, 0xac, 0x29,
 0x39, 0x71, 0x1e, 0xea, 0xe9, 0x9e, 0x52, 0x34,
 0x6c, 0x81, 0x3c, 0x13, 0xc7, 0x9a, 0x34, 0x42,
 0x00, 0xc5, 0x97, 0x96, 0x9a, 0xf6, 0x59, 0xc9,
 0x18, 0xd1, 0xcc, 0xc3, 0xf8, 0xb2, 0xc6, 0xae,
 0x40, 0x14, 0xb8, 0x70, 0x95, 0x58, 0x3a, 0xf6,
 0x85, 0x4d, 0xc6, 0xe9, 0x9e, 0x67, 0xb1, 0x8a,
 0x32, 0xf0, 0x24, 0xd7, 0x9d, 0xae, 0x7c, 0x4e,
 0x5c, 0xd2, 0xd0, 0x0e, 0x06, 0x97, 0x35, 0x8d,
 0xec, 0x5b, 0xd0, 0x53, 0x6e, 0x2a, 0x34, 0xb5,
 0x8b, 0x2a, 0x7b, 0x4b, 0xde, 0xda, 0x07, 0x4a,
 0x6b, 0x2c, 0x56, 0x55, 0x07, 0x46, 0xb6, 0x95,
 0xb2, 0xaa, 0x2a, 0xf5, 0x42, 0xe4, 0x7b, 0x22,
 0xb8, 0x0e, 0xcc, 0x9a, 0x46, 0x0e, 0xce, 0x5f,
 0xd8, 0xe4, 0x8a, 0x5e, 0x5a, 0x8a, 0x2f, 0xa9,
 0xca, 0x9a, 0x6a, 0x84, 0x48, 0x94, 0x9c, 0xbc,
 0x59, 0x11, 0x60, 0x51, 0x05, 0xde, 0x81, 0xf2,
 0x47, 0xbe, 0x8b, 0x88, 0xc5, 0x1a, 0x03, 0xe2,
 0xcc, 0x95, 0x9f, 0xae, 0x44, 0x84, 0xc8, 0x38,
 0x70, 0x7c, 0xeb, 0xa3, 0x4c, 0x3f, 0x30, 0x6f,
 0x06, 0xd6, 0x04, 0x39, 0x18, 0x13, 0xdc, 0xf9,
 0xaa, 0xf2, 0xc5, 0xfd, 0x4c, 0x41, 0x08, 0x67,
 0xb1, 0x26, 0x81, 0x37, 0x03, 0x71, 0x7c, 0x75,
 0xca, 0x2b, 0x76, 0x81, 0x6b, 0xe4, 0xda, 0xde,
 0xf8, 0x8c, 0x0c, 0xd6, 0xd8, 0x00, 0x27, 0x17,
 0x8b, 0x2c, 0xb8, 0x3a, 0x65, 0x3e, 0x01, 0x4c,
 0x3c, 0x88, 0x03, 0x30, 0x70, 0x85, 0x76, 0x16,
 0x6b, 0x62, 0x25, 0x83, 0xb7, 0xdc, 0xbd, 0x31,
 0xa6, 0xe6, 0xc0, 0xf9, 0x3b, 0xd4, 0x17, 0x0e,
 0xe2, 0x58, 0xac, 0x31, 0x23, 0x44, 0xfe, 0x9c,
 0xcb, 0xfc, 0xbd, 0xe2, 0xc2, 0x30, 0x9c, 0x0c,
 0xe0, 0x20, 0x08, 0x10, 0x45, 0x51, 0xe6, 0xde,
 0xc8, 0x40, 0xbf, 0x6f, 0x93, 0xe3, 0x03, 0x6b,
 0xfc, 0x02, 0x44, 0xf6, 0xa4, 0x4e, 0xca, 0xb9,
 0xb0, 0xd6, 0x1a, 0x51, 0x14, 0x8d, 0x7c, 0x8f,
 0x3d, 0xcb, 0x68, 0x9e, 0xe7, 0xa5, 0x7b, 0xc1,
 0xc0, 0x60, 0x8e, 0xe1, 0x65, 0x4d, 0xc3, 0x85,
 0x0b, 0xc6, 0x5a, 0xc6, 0x18, 0x44, 0x51, 0x04,
 0xcf, 0xf3, 0xc6, 0x07, 0x98, 0x88, 0xd0, 0xe9,
 0x74, 0x10, 0x86, 0x61, 0xf1, 0xdd, 0xea, 0x13,
 0x88, 0x19, 0x64, 0xd6, 0x34, 0xdc, 0x38, 0x77,
 0xe4, 0x4f, 0xd8, 0x9b, 0xc8, 0x81, 0x77, 0x77,
 0x77, 0xe1, 0x79, 0x5e, 0x1a, 0x1d, 0x46, 0xed,
 0x41, 0x2c, 0x56, 0x45, 0x6a, 0x07, 0x5a, 0x15,
 0x92, 0xef, 0xbb, 0xdd, 0x2e, 0x36, 0x37, 0x37,
 0x27, 0x1f, 0xc4, 0x69, 0xad, 0xb1, 0xb9, 0xb9,
 0x09, 0x22, 0x82, 0x52, 0x6a, 0xe4, 0xcd, 0xbf,
 0x59, 0xac, 0xaa, 0xf1, 0xa1, 0x88, 0x23, 0xad,
 0x35, 0x76, 0x77, 0x77, 0xb1, 0xb9, 0xb9, 0x09,
 0xa5, 0xd4, 0x64, 0x0e, 0x0c, 0x00, 0x6b, 0x6b,
 0x6b, 0xe8, 0x74, 0x3a, 0x85, 0x31, 0x82, 0xc5,
 0x9a, 0x34, 0x3a, 0xe4, 0x79, 0xda, 0xdd, 0xdd,
 0xc5, 0xc5, 0x8b, 0x17, 0xe1, 0xfb, 0xfe, 0x9e,
 0x17, 0xb8, 0x2e, 0x05, 0x70, 0xf2, 0x86, 0xbb,
 0xbb, 0xbb, 0xec, 0xbc, 0xac, 0x2b, 0x92, 0x7d,
 0x93, 0xaf, 0x61, 0x18, 0xa2, 0xdd, 0x6e, 0x63,
 0x65, 0x65, 0xa5, 0xd4, 0xef, 0x97, 0x6e, 0xe6,
 0x59, 0x5e, 0x5e, 0xc6, 0xe6, 0xe6, 0xe6, 0x9e,
 0xa1, 0x9a, 0xc5, 0x1a, 0x47, 0x44, 0x84, 0xed,
 0xed, 0x6d, 0x2c, 0x2d, 0x2d, 0xe1, 0xfc, 0xf9,
 0xf3, 0xe8, 0x74, 0x3a, 0xa5, 0x7e, 0xaf, 0xf4,
 0x4c, 0xdc, 0xce, 0xce, 0x0e, 0x96, 0x97, 0x97,
 0xe1, 0xba, 0x2e, 0xe6, 0xe7, 0xe7, 0x7b, 0x17,
 0x23, 0xae, 0x70, 0x2f, 0x03, 0x16, 0x6b, 0x94,
 0xfb, 0x26, 0xf0, 0xbe, 0xfd, 0xf6, 0xdb, 0x10,
 0x42, 0x60, 0x66, 0x66, 0x66, 0xba, 0x00, 0x13,
 0x11, 0x96, 0x96, 0x96, 0xa0, 0x94, 0x4a, 0x17,
 0xc0, 0x6e, 0xcc, 0x9a, 0x54, 0x5a, 0x6b, 0x6c,
 0x6f, 0x6f, 0xe3, 0xcc, 0x99, 0x33, 0x38, 0x7b,
 0xf6, 0x2c, 0x82, 0x20, 0x80, 0xe3, 0x38, 0xa5,
 0x7f, 0xbf, 0x52, 0x2f, 0x04, 0x11, 0xe1, 0xf4,
 0xe9, 0xd3, 0x20, 0x22, 0xcc, 0xcf, 0xcf, 0x43,
 0x6b, 0x0d, 0xc7, 0x71, 0x50, 0xaf, 0xd7, 0x79,
 0x4b, 0xb0, 0x2a, 0xcb, 0xf3, 0x3c, 0x6c, 0x6c,
 0x6c, 0x60, 0x69, 0x69, 0x09, 0x6f, 0xbd, 0xf5,
 0x56, 0xca, 0x58, 0x95, 0xa3, 0xb9, 0x1a, 0x67,
 0xc1, 0xa7, 0x4f, 0x9f, 0x06, 0x00, 0xcc, 0xcc,
 0xcc, 0xe0, 0xe0, 0xc1, 0x83, 0x70, 0x1c, 0x07,
 0xcd, 0x66, 0x93, 0xb7, 0x08, 0xab, 0x92, 0x56,
 0x57, 0x57, 0xd3, 0xf1, 0xd5, 0xb8, 0x1a, 0x0b,
 0xe0, 0x24, 0xbb, 0x6c, 0x6f, 0x6f, 0x63, 0x7b,
 0x7b, 0x1b, 0xad, 0x56, 0x8b, 0x01, 0x66, 0x55,
 0xd6, 0xca, 0xca, 0xca, 0xc4, 0x47, 0x6f, 0x31,
 0x8d, 0x0f, 0x32, 0x6c, 0x96, 0x8e, 0xc5, 0xda,
 0x2b, 0x92, 0x4e, 0x3a, 0xf8, 0x17, 0xbc, 0x1a,
 0x59, 0xef, 0x66, 0x31, 0xc0, 0x2c, 0x06, 0x98,
 0xc5, 0x62, 0x80, 0x59, 0x2c, 0x06, 0x98, 0xc5,
 0x00, 0xb3, 0x58, 0x0c, 0x30, 0x8b, 0xc5, 0x00,
 0xb3, 0x58, 0x0c, 0x30, 0x8b, 0x01, 0x66, 0xb1,
 0x18, 0x60, 0x16, 0x8b, 0x01, 0x66, 0xb1, 0x18,
 0x60, 0x16, 0x03, 0xcc, 0x62, 0x31, 0xc0, 0x2c,
 0x16, 0x03, 0xcc, 0x62, 0x80, 0x59, 0x2c, 0x06,
 0x98, 0xc5, 0x62, 0x80, 0x59, 0x2c, 0x06, 0x98,
 0xc5, 0x00, 0xb3, 0x58, 0x0c, 0x30, 0x8b, 0xc5,
 0x00, 0xb3, 0x58, 0x0c, 0x30, 0x8b, 0x01, 0x66,
 0xb1, 0x18, 0x60, 0x16, 0x8b, 0x01, 0x66, 0xb1,
 0x18, 0x60, 0x16, 0x03, 0xcc, 0x62, 0x31, 0xc0,
 0x2c, 0x16, 0x03, 0xcc, 0x62, 0x80, 0x59, 0x2c,
 0x06, 0x98, 0xc5, 0x62, 0x80, 0x59, 0x2c, 0x06,
 0x98, 0xc5, 0x00, 0xb3, 0x58, 0x0c, 0x30, 0x8b,
 0xc5, 0x00, 0xb3, 0x58, 0x0c, 0x30, 0x8b, 0x01,
 0x66, 0xb1, 0x18, 0x60, 0x16, 0x8b, 0x01, 0x66,
 0xb1, 0x18, 0x60, 0x16, 0x03, 0xcc, 0x62, 0x4d,
 0x2c, 0x8a, 0x1f, 0xb0, 0xbe, 0x0e, 0x7b, 0x5d,
 0xd1, 0x6b, 0x14, 0xaf, 0x42, 0xd6, 0x3b, 0x06,
 0x2f, 0x11, 0x90, 0x3c, 0x92, 0x9f, 0x13, 0xa8,
 0xc9, 0xfa, 0xd9, 0x7a, 0x0d, 0x72, 0x37, 0x07,
 0x67, 0x07, 0x66, 0xbd, 0xa3, 0xee, 0x3b, 0xe0,
 0xb0, 0xf1, 0x1d, 0xec, 0x7b, 0xff, 0xb0, 0xe7,
 0xdd, 0xec, 0x19, 0x60, 0xd6, 0xd5, 0x13, 0x21,
 0x88, 0x90, 0x31, 0x65, 0x1a, 0x7c, 0x0d, 0x03,
 0xcc, 0xba, 0x8a, 0x22, 0x44, 0x1f, 0xce, 0x14,
 0xde, 0xbe, 0xf7, 0xc6, 0x5f, 0xad, 0x48, 0x51,
 0xf0, 0x1e, 0x9c, 0x81, 0x59, 0xef, 0xa8, 0xff,
 0x26, 0x6e, 0x2b, 0x00, 0x08, 0xf4, 0x28, 0xcd,
 0x44, 0xde, 0xf8, 0x3f, 0x34, 0x64, 0x94, 0xc7,
 0x00, 0xb3, 0xde, 0x59, 0x07, 0x26, 0x82, 0x48,
 0x72, 0x6f, 0x4c, 0x69, 0xfa, 0x8f, 0x6c, 0x77,
 0x2e, 0x0e, 0x12, 0x0c, 0x30, 0xeb, 0x9d, 0xf4,
 0x5f, 0x08, 0x1b, 0xd6, 0xb4, 0xea, 0x60, 0x47,
 0x8b, 0x18, 0xe9, 0x21, 0x83, 0x39, 0x06, 0x98,
 0xf5, 0xce, 0x56, 0x21, 0x28, 0x89, 0x08, 0x71,
 0xe2, 0xb5, 0xdc, 0x38, 0x93, 0x81, 0x0d, 0x03,
 0xcc, 0xba, 0x4a, 0x23, 0x44, 0xbf, 0xfa, 0x60,
 0x55, 0x21, 0x90, 0x7f, 0xce, 0xf0, 0x20, 0x8e,
 0x75, 0xb5, 0x01, 0x4c, 0x10, 0xc9, 0x20, 0x2e,
 0xce, 0xc2, 0x69, 0x0a, 0xb6, 0x06, 0x73, 0x76,
 0xbc, 0x60, 0x80, 0x59, 0x57, 0x8d, 0x84, 0x35,
 0x69, 0x21, 0xac, 0xca, 0x83, 0xc8, 0x0d, 0xe8,
 0xc0, 0x19, 0x98, 0x75, 0x55, 0x3a, 0xb0, 0x20,
 0x08, 0x12, 0x10, 0xa2, 0x07, 0xa8, 0xb0, 0x32,
 0x30, 0xec, 0x6a, 0x70, 0x0a, 0x34, 0x03, 0xcc,
 0xba, 0xaa, 0x1c, 0x58, 0x40, 0x0a, 0x61, 0x95,
 0xd1, 0xfa, 0xb0, 0xf6, 0xdd, 0x19, 0xd6, 0xe0,
 0x8e, 0x01, 0x66, 0x5d, 0x45, 0x92, 0x42, 0x40,
 0xc4, 0x00, 0x8b, 0x38, 0x3a, 0x80, 0xe2, 0xd2,
 0x1a, 0xa1, 0x1f, 0x2b, 0x68, 0xf8, 0x54, 0x32,
 0x03, 0xcc, 0x7a, 0x47, 0x01, 0x96, 0x71, 0x8c,
 0x48, 0x27, 0x2b, 0xac, 0x41, 0x1d, 0x25, 0x33,
 0x73, 0x69, 0x41, 0x8d, 0x01, 0x66, 0x5d, 0x4d,
 0x11, 0x42, 0x10, 0xa4, 0x90, 0x10, 0xa2, 0x37,
 0x88, 0x13, 0xf1, 0xcc, 0x45, 0x02, 0x6f, 0xbf,
 0x2b, 0xad, 0x07, 0xf9, 0x54, 0x67, 0xe2, 0x92,
 0x22, 0xb4, 0x31, 0x80, 0x17, 0x7a, 0xe8, 0xf8,
 0x1d, 0xde, 0x22, 0xac, 0x8a, 0x0c, 0xf5, 0x9d,
 0x37, 0x2d, 0xa3, 0xc5, 0xa5, 0xb5, 0x04, 0xd7,
 0x6c, 0x6d, 0x78, 0x4c, 0x07, 0xce, 0x34, 0x1a,
 0xe7, 0x9e, 0x33, 0x30, 0xd8, 0xf6, 0x2f, 0x42,
 0xee, 0x7a, 0x30, 0x30, 0xbc, 0x55, 0x58, 0xe5,
 0x01, 0x26, 0x80, 0x60, 0x32, 0xd5, 0x06, 0xe4,
 0x06, 0x73, 0xfd, 0x7e, 0x88, 0x0a, 0x11, 0xa2,
 0xdf, 0x11, 0x6f, 0xff, 0xdc, 0xaf, 0x2a, 0x93,
 0xe5, 0xc0, 0x64, 0x08, 0x22, 0x32, 0x10, 0xa1,
 0x06, 0x01, 0x8c, 0x30, 0xab, 0xb4, 0x8c, 0xd6,
 0x88, 0xa2, 0x10, 0x3a, 0x0a, 0xe3, 0x18, 0xd1,
 0xa3, 0x55, 0xa4, 0x13, 0x1c, 0x7d, 0xd6, 0x04,
 0xaa, 0xd4, 0x81, 0xd3, 0xce, 0x9f, 0x3e, 0xc1,
 0xb9, 0x67, 0x52, 0x90, 0xa5, 0x00, 0xd6, 0x96,
 0x2e, 0xe3, 0xc2, 0xb9, 0xcb, 0x30, 0x4c, 0x2f,
 0xab, 0x82, 0xa2, 0x28, 0x42, 0x77, 0x77, 0x17,
 0x5e, 0xb7, 0x0b, 0x29, 0x44, 0x3c, 0x80, 0xeb,
 0x4f, 0x6c, 0x08, 0xe4, 0xce, 0xd0, 0x28, 0x5b,
 0x46, 0xcb, 0x9f, 0x68, 0x67, 0xcf, 0x94, 0xe4,
 0x3b, 0x86, 0x7a, 0x61, 0x5c, 0xf4, 0x9c, 0x57,
 0x6b, 0xde, 0x2a, 0xac, 0xd2, 0xea, 0x76, 0x77,
 0x41, 0x46, 0x23, 0xf0, 0xfd, 0xd4, 0x7d, 0x93,
 0x0c, 0xdc, 0x3f, 0xda, 0x53, 0xf5, 0xa9, 0x64,
 0xdb, 0x6d, 0x4d, 0xfa, 0x5c, 0xf2, 0xcf, 0x64,
 0x3b, 0x85, 0xa8, 0x57, 0x90, 0x66, 0xf3, 0x65,
 0x55, 0xd5, 0xc6, 0xfa, 0x3a, 0x6a, 0x4a, 0x02,
 0x5a, 0x67, 0x66, 0xdb, 0xec, 0xfe, 0x07, 0xbb,
 0xb5, 0xb2, 0x14, 0xc0, 0x84, 0x81, 0xf4, 0xd0,
 0x2f, 0x26, 0x27, 0xa5, 0x8e, 0x9c, 0x9d, 0x6b,
 0x1d, 0x41, 0x73, 0x7e, 0x60, 0x55, 0x8e, 0x10,
 0x21, 0xb4, 0xc8, 0x9e, 0xbc, 0x69, 0x37, 0xf6,
 0x90, 0x75, 0x26, 0x46, 0xa5, 0x2a, 0x04, 0x59,
 0x67, 0x26, 0xc1, 0x6a, 0x28, 0x16, 0x44, 0xd0,
 0xd6, 0x82, 0x30, 0xa2, 0xc0, 0xcc, 0x62, 0xed,
 0xa5, 0xb4, 0xf6, 0xdb, 0xb7, 0xce, 0x34, 0x07,
 0x27, 0xb3, 0x73, 0x99, 0x8a, 0x44, 0x29, 0x80,
 0x29, 0xeb, 0xb8, 0xc6, 0xd8, 0xa7, 0xd8, 0xd9,
 0xb3, 0x23, 0x76, 0x69, 0x83, 0xb8, 0xfc, 0xc0,
 0xaa, 0xac, 0x04, 0x54, 0x93, 0x39, 0xfa, 0x53,
 0xb6, 0x37, 0x02, 0xd9, 0x13, 0x3d, 0x4b, 0x38,
 0x30, 0x65, 0x1e, 0x44, 0x66, 0xa0, 0x37, 0x33,
 0x59, 0x38, 0xe5, 0xa1, 0x67, 0xb1, 0xaa, 0x38,
 0x30, 0x28, 0xcb, 0x91, 0xe5, 0xc0, 0x76, 0x17,
 0x5a, 0x7f, 0x96, 0xae, 0x64, 0x06, 0x16, 0x56,
 0x23, 0x85, 0x31, 0x48, 0x8b, 0xcb, 0x82, 0xb2,
 0xa4, 0xda, 0x0b, 0xe7, 0x49, 0x0c, 0xd6, 0x38,
 0x0e, 0x5c, 0x04, 0xb0, 0xb0, 0x27, 0x30, 0xd0,
 0x8f, 0x03, 0x95, 0x67, 0xe2, 0xfa, 0x96, 0x8e,
 0xc1, 0x32, 0x5a, 0x2e, 0x42, 0x10, 0x5b, 0x30,
 0xab, 0x32, 0xc0, 0x83, 0x19, 0x98, 0x60, 0x9f,
 0xa9, 0x6c, 0x99, 0x6a, 0xd9, 0x2a, 0x44, 0x9a,
 0x4d, 0x12, 0x0b, 0x37, 0xc6, 0x3a, 0xcd, 0x99,
 0xd2, 0x73, 0x93, 0xf2, 0x97, 0xfd, 0xe1, 0x0a,
 0x30, 0xab, 0xfa, 0x20, 0xae, 0x7f, 0x1a, 0x91,
 0x6d, 0x9b, 0x22, 0x33, 0x79, 0x41, 0xc5, 0x4e,
 0x3d, 0xba, 0x0a, 0x61, 0x3b, 0x6b, 0x32, 0x91,
 0x91, 0x8d, 0x10, 0x79, 0x80, 0x05, 0x3b, 0x30,
 0x6b, 0x0c, 0x07, 0xb6, 0x19, 0x22, 0x2b, 0x1b,
 0x8b, 0x7c, 0x3f, 0x44, 0xd9, 0x5e, 0x08, 0xb2,
 0xe7, 0xa2, 0xed, 0x05, 0x59, 0xd6, 0x5e, 0x04,
 0xb0, 0x66, 0x7e, 0x59, 0x55, 0x01, 0x1e, 0x62,
 0x7c, 0x99, 0x06, 0x1e, 0x2b, 0x0b, 0x97, 0x77,
 0x60, 0xab, 0x8c, 0x46, 0x49, 0x19, 0x2d, 0x9e,
 0x9b, 0xd6, 0xc9, 0x48, 0x11, 0x76, 0x6d, 0x8e,
 0x33, 0x30, 0x6b, 0xdc, 0x41, 0xdc, 0xe0, 0x51,
 0xdf, 0x9e, 0xc4, 0xb0, 0x2f, 0x7c, 0x52, 0xb2,
 0x0a, 0x41, 0xd6, 0x15, 0x53, 0xb2, 0x97, 0xff,
 0x11, 0x44, 0x30, 0x44, 0x03, 0xd7, 0x6f, 0x05,
 0xf8, 0x2a, 0x81, 0xac, 0x31, 0x32, 0x70, 0xcc,
 0x59, 0x96, 0xe0, 0x6c, 0xee, 0xb5, 0xa3, 0x06,
 0x95, 0x6d, 0x68, 0xcf, 0xd4, 0x7d, 0x81, 0x7e,
 0x6b, 0x5b, 0xda, 0x2d, 0x8f, 0xb4, 0xed, 0xcd,
 0xde, 0x9b, 0x58, 0xac, 0xea, 0x0e, 0x9c, 0xcb,
 0xc0, 0xd6, 0xc5, 0xfe, 0xb2, 0x97, 0x97, 0x1a,
 0x9d, 0x81, 0x8d, 0xfd, 0x26, 0xd9, 0x16, 0x36,
 0x93, 0x99, 0x9f, 0xce, 0x3b, 0x30, 0xf1, 0x20,
 0x8e, 0x35, 0x41, 0x08, 0x16, 0xf1, 0x24, 0x6e,
 0xa6, 0x4d, 0xd7, 0x9e, 0x85, 0xab, 0xda, 0xd0,
 0x9e, 0xa1, 0x3f, 0x77, 0xe9, 0x1f, 0x41, 0x80,
 0x21, 0xee, 0x80, 0x60, 0x4d, 0x6f, 0x10, 0x07,
 0x0c, 0x5e, 0xa9, 0x5d, 0xd8, 0x93, 0x17, 0x99,
 0x2b, 0xb6, 0x1b, 0x18, 0x93, 0xed, 0x1a, 0x1b,
 0x00, 0xd8, 0x18, 0x33, 0x50, 0x7b, 0xb3, 0xcb,
 0x1a, 0x19, 0xa7, 0xb5, 0xce, 0x18, 0x65, 0x03,
 0x66, 0x4d, 0x1a, 0x21, 0xb2, 0xd5, 0x09, 0x64,
 0x3a, 0x20, 0x72, 0x2f, 0x33, 0xc9, 0x43, 0xe5,
 0xe9, 0xed, 0x97, 0x2f, 0xfa, 0x37, 0xd8, 0xe8,
 0x5d, 0x39, 0x45, 0xf4, 0xe1, 0xcd, 0x0d, 0x1d,
 0xcb, 0xdc, 0xcb, 0x80, 0xc5, 0x2a, 0x02, 0x75,
 0xb0, 0x19, 0x8d, 0x40, 0x22, 0x7b, 0xbd, 0xe0,
 0x82, 0x57, 0x17, 0x66, 0x60, 0x03, 0x22, 0x23,
 0x84, 0xf4, 0x88, 0x44, 0x04, 0xd3, 0xeb, 0x6e,
 0xe8, 0x01, 0xdc, 0x3b, 0x7f, 0xbf, 0x7f, 0xee,
 0x3e, 0x0d, 0x5c, 0x31, 0x9b, 0x33, 0x30, 0x6b,
 0x2c, 0x80, 0x73, 0xdc, 0xd8, 0x15, 0xaf, 0xa4,
 0x9c, 0x66, 0x4c, 0x5a, 0x72, 0xf3, 0x90, 0xeb,
 0x7b, 0xcc, 0x00, 0x4c, 0x44, 0xba, 0xe6, 0xba,
 0x9b, 0x52, 0xca, 0x10, 0x46, 0x43, 0x87, 0x11,
 0xc8, 0x15, 0x10, 0x42, 0xc6, 0x10, 0x0b, 0xd8,
 0x27, 0xbe, 0xe5, 0xd2, 0x04, 0x8b, 0x55, 0x35,
 0x43, 0x64, 0xa3, 0x81, 0xb1, 0xa6, 0x8f, 0x05,
 0x81, 0x84, 0x00, 0x91, 0x80, 0x31, 0x1a, 0x04,
 0x04, 0x52, 0x88, 0x4d, 0x02, 0x22, 0xf4, 0xa6,
 0x23, 0x4c, 0x02, 0x70, 0x42, 0xa4, 0x96, 0x52,
 0x46, 0x0b, 0x0b, 0xf3, 0x67, 0x1c, 0xc7, 0xd9,
 0xd5, 0x5a, 0x23, 0x0c, 0x7d, 0x34, 0xea, 0x35,
 0xb8, 0x8e, 0x82, 0x92, 0x12, 0x81, 0x10, 0x30,
 0x5a, 0x27, 0xbb, 0x84, 0x95, 0x83, 0x01, 0x57,
 0x49, 0xbc, 0x67, 0xb6, 0x31, 0x22, 0xad, 0xd3,
 0x48, 0xd8, 0x07, 0xef, 0x81, 0xd0, 0xdb, 0xf5,
 0x48, 0x08, 0x38, 0x8e, 0x03, 0xd7, 0x75, 0x61,
 0x8c, 0x81, 0xd7, 0xed, 0x22, 0x8a, 0xa2, 0xa1,
 0x99, 0xca, 0x75, 0x1c, 0x38, 0x6e, 0x0d, 0x80,
 0x41, 0xb7, 0xdb, 0x45, 0x14, 0x85, 0x20, 0x00,
 0x8e, 0xeb, 0x42, 0x29, 0x07, 0x42, 0xf4, 0xae,
 0x45, 0x60, 0xe2, 0x1e, 0x0f, 0xc0, 0x20, 0x08,
 0x03, 0x04, 0xbe, 0x0f, 0x6d, 0x4c, 0xba, 0xac,
 0xdd, 0x9d, 0x9d, 0x81, 0xfe, 0xba, 0xb4, 0x89,
 0x9f, 0x08, 0xb5, 0x5a, 0x0d, 0x4a, 0x39, 0x99,
 0xbf, 0x27, 0xd2, 0x11, 0x7c, 0xdf, 0x47, 0x14,
 0x86, 0x7d, 0x87, 0x50, 0x0a, 0xae, 0xeb, 0x42,
 0x48, 0x09, 0x18, 0x20, 0x0c, 0x43, 0x78, 0x5e,
 0x17, 0x82, 0x08, 0x4a, 0x29, 0x48, 0xa5, 0x20,
 0xa5, 0x84, 0xd5, 0xd6, 0xd7, 0x7b, 0xaf, 0x30,
 0x84, 0xe7, 0x7b, 0x80, 0x01, 0xa4, 0x52, 0xa8,
 0xb9, 0x2e, 0x48, 0x08, 0x18, 0x63, 0xe0, 0xfb,
 0x1e, 0xa2, 0x30, 0x84, 0x72, 0x5c, 0x38, 0x8e,
 0x03, 0x63, 0x34, 0x7c, 0xcf, 0x83, 0x8e, 0xd7,
 0x8b, 0x10, 0x02, 0x8e, 0x5b, 0x83, 0x52, 0x2a,
 0x3d, 0x5a, 0x6a, 0x1d, 0x21, 0x08, 0x02, 0x84,
 0x41, 0x90, 0xae, 0x5f, 0xe5, 0xf4, 0x3e, 0x1b,
 0x00, 0xf8, 0x5e, 0xef, 0x73, 0x1b, 0x18, 0x48,
 0x29, 0xe1, 0xba, 0x2e, 0xa4, 0x52, 0x08, 0x82,
 0x00, 0xbe, 0xe7, 0x41, 0x4a, 0x05, 0xc7, 0x71,
 0x40, 0x24, 0xa0, 0x75, 0x04, 0xdf, 0xf7, 0x60,
 0xb4, 0xc9, 0x6e, 0x4f, 0x1a, 0x35, 0x58, 0x1b,
 0x0c, 0xb1, 0x75, 0x47, 0x65, 0x0a, 0x02, 0x44,
 0xf1, 0x05, 0xff, 0x84, 0x80, 0x94, 0x0a, 0x42,
 0x08, 0x68, 0x63, 0xa0, 0xa3, 0x08, 0x44, 0xb4,
 0x5b, 0xaf, 0xb9, 0x67, 0x85, 0x10, 0x36, 0xc0,
 0x26, 0xe3, 0xc0, 0xb5, 0x5a, 0x2d, 0xfc, 0xd8,
 0xc7, 0x6f, 0x7b, 0xfd, 0xe5, 0x97, 0x5f, 0xde,
 0x68, 0x5f, 0x5c, 0xbf, 0xde, 0xf7, 0x7c, 0xa8,
 0x05, 0x09, 0xd4, 0x6a, 0x70, 0x1c, 0x07, 0x81,
 0x94, 0x80, 0x8e, 0x7a, 0x26, 0x6c, 0xec, 0x58,
 0x42, 0x50, 0x52, 0x62, 0xb6, 0x21, 0x4b, 0x80,
 0x59, 0x5c, 0xc5, 0x18, 0x76, 0x13, 0x0f, 0x22,
 0x82, 0x92, 0x2a, 0x85, 0xc5, 0x81, 0x81, 0x31,
 0x7a, 0xc8, 0x8a, 0x22, 0x28, 0x25, 0x7b, 0x1b,
 0x0e, 0x80, 0x43, 0x06, 0x5a, 0x3b, 0xa0, 0x18,
 0x24, 0x29, 0x55, 0x1a, 0x83, 0x0c, 0xfa, 0x00,
 0x47, 0x8a, 0x10, 0xca, 0x1e, 0x1c, 0x52, 0xf5,
 0x96, 0xe5, 0xe4, 0x96, 0x91, 0xed, 0x7d, 0x26,
 0x38, 0x8e, 0x03, 0x29, 0x55, 0xe6, 0x43, 0x6b,
 0x1d, 0x21, 0x12, 0x04, 0xad, 0x9d, 0x74, 0xf5,
 0x08, 0x25, 0xe2, 0x1d, 0x47, 0x02, 0xc6, 0x20,
 0x52, 0x02, 0x0d, 0xd9, 0x73, 0x9e, 0x64, 0x23,
 0x09, 0x29, 0xfb, 0x4e, 0x94, 0x00, 0xac, 0x24,
 0x1a, 0x4a, 0x00, 0x06, 0x10, 0x52, 0xc2, 0x71,
 0x54, 0xec, 0x46, 0x06, 0xa1, 0x20, 0x68, 0x1d,
 0xf5, 0xe0, 0x57, 0x0a, 0xc6, 0x18, 0x44, 0x52,
 0x40, 0xc7, 0x27, 0xd5, 0x12, 0x11, 0x94, 0x72,
 0xe2, 0x1d, 0x23, 0x19, 0xbd, 0x2b, 0x84, 0x4a,
 0x22, 0x72, 0x9d, 0x74, 0xe3, 0x49, 0x29, 0xe1,
 0x38, 0xbd, 0xf5, 0x1a, 0x48, 0x91, 0xd9, 0x01,
 0x94, 0xa3, 0x20, 0xa4, 0x44, 0x24, 0x25, 0x42,
 0xd5, 0x3b, 0x0a, 0x4b, 0xd5, 0x5b, 0x7f, 0x46,
 0x6b, 0x84, 0x8e, 0x88, 0x4d, 0x60, 0xef, 0xe3,
 0xef, 0x28, 0xc0, 0x93, 0x03, 0x7a, 0xda, 0x73,
 0x23, 0x08, 0x42, 0x4a, 0x48, 0xc7, 0x01, 0x11,
 0xc1, 0xf7, 0x3d, 0x84, 0x61, 0x00, 0x21, 0xe5,
 0xf6, 0xc2, 0xfc, 0xc2, 0x6b, 0x4a, 0xa9, 0x30,
 0x06, 0x58, 0xe7, 0x23, 0x84, 0xae, 0xb9, 0xb5,
 0xe8, 0xee, 0xcf, 0x7c, 0x66, 0xf9, 0x87, 0x3f,
 0xf8, 0xfe, 0xcf, 0xdb, 0xeb, 0x17, 0x8e, 0x7b,
 0xdd, 0xee, 0x4c, 0x18, 0x45, 0x90, 0x8e, 0x83,
 0x7a, 0xbd, 0x81, 0x28, 0x08, 0x00, 0xf4, 0xf6,
 0x08, 0xa3, 0x35, 0x72, 0x15, 0xbc, 0x62, 0x87,
 0xdd, 0x23, 0x66, 0x50, 0xd1, 0x13, 0xc6, 0x7a,
 0xde, 0xf4, 0xdc, 0x28, 0x75, 0xb5, 0x82, 0xa2,
 0x36, 0x59, 0xfb, 0x75, 0xf6, 0xb5, 0x94, 0xce,
 0x10, 0x66, 0x9e, 0x2f, 0xfc, 0x9c, 0x3d, 0xb0,
 0x93, 0xd7, 0xe5, 0x33, 0x3d, 0xe5, 0xd6, 0x7a,
 0xe0, 0xfb, 0x08, 0xe0, 0x0f, 0xdd, 0x25, 0xd3,
 0x2b, 0x17, 0x45, 0x1a, 0x41, 0xe4, 0x15, 0x6c,
 0x38, 0x42, 0x18, 0x86, 0xa5, 0xd6, 0x95, 0x8e,
 0x42, 0x78, 0x51, 0x38, 0x60, 0x00, 0x45, 0x7f,
 0x53, 0xf2, 0xf9, 0xc2, 0xc0, 0x47, 0x18, 0x0c,
 0x3f, 0xd4, 0x11, 0x00, 0x1d, 0x45, 0xf0, 0x0a,
 0x8e, 0x66, 0x5a, 0x6b, 0x04, 0x9e, 0x9f, 0x7b,
 0x2e, 0x82, 0xf6, 0xa3, 0x3d, 0x9d, 0x75, 0x8c,
 0x14, 0xd1, 0x3f, 0xcb, 0x87, 0x04, 0x84, 0x74,
 0xa0, 0x1c, 0x17, 0xb5, 0x7a, 0x1d, 0x24, 0x04,
 0x76, 0x3b, 0x1d, 0x84, 0xbe, 0x8f, 0x99, 0x85,
 0x7d, 0xab, 0x9f, 0xbc, 0xfd, 0x8e, 0xe7, 0xeb,
 0xf5, 0x7a, 0x90, 0x71, 0x60, 0x22, 0x32, 0x71,
 0x6d, 0x4d, 0x93, 0xa0, 0xf0, 0xf0, 0xb5, 0xd7,
 0x76, 0x6f, 0xb9, 0xe5, 0x03, 0x27, 0x57, 0x97,
 0x97, 0x3e, 0xe2, 0x75, 0x3b, 0xef, 0xdf, 0xde,
 0xda, 0xc2, 0xc2, 0xc2, 0x02, 0x9a, 0xb3, 0xb3,
 0xd0, 0x51, 0xd8, 0x3b, 0xe4, 0xfa, 0x7e, 0x0f,
 0xe2, 0xd4, 0x8a, 0xad, 0x5d, 0x69, 0x58, 0x54,
 0x28, 0xdc, 0x38, 0x54, 0x70, 0x88, 0x1e, 0xe2,
 0xc4, 0xf9, 0x9f, 0x46, 0xcc, 0xce, 0xd0, 0x10,
 0x6b, 0xdf, 0xeb, 0x5e, 0xbc, 0xc6, 0x3a, 0xff,
 0x4f, 0x4a, 0x91, 0xd9, 0xa3, 0x74, 0xa4, 0x51,
 0xf0, 0x11, 0x86, 0xbe, 0x1b, 0x8d, 0xd8, 0x4b,
 0x47, 0x7f, 0x0e, 0x2a, 0x71, 0x38, 0x1e, 0x6d,
 0x73, 0x7b, 0x21, 0x45, 0x25, 0xde, 0xb4, 0x2c,
 0x9c, 0x54, 0xe6, 0x8f, 0x2a, 0xd8, 0xe6, 0x99,
 0x0a, 0x43, 0x0a, 0xaf, 0x82, 0xaa, 0xd5, 0x50,
 0x6b, 0x36, 0xa1, 0xdc, 0x1a, 0xc2, 0x30, 0xc4,
 0xce, 0xf6, 0x16, 0x8c, 0x31, 0x9b, 0x87, 0xde,
 0x73, 0xcd, 0xb3, 0xf7, 0x3f, 0xf0, 0x97, 0x6f,
 0xd6, 0x1b, 0x8d, 0x20, 0x9f, 0x81, 0x53, 0x07,
 0x06, 0x10, 0x39, 0x8e, 0xe3, 0x7f, 0xf1, 0x81,
 0x07, 0x7e, 0xfa, 0xfa, 0xcf, 0xff, 0xfb, 0xb9,
 0xff, 0xfd, 0x9f, 0xd7, 0xdf, 0xbb, 0x75, 0xb9,
 0x3d, 0xdb, 0x68, 0x34, 0xd0, 0x6c, 0x34, 0x31,
 0x3b, 0x3f, 0x0f, 0x22, 0x82, 0x27, 0x76, 0x11,
 0x85, 0x01, 0x74, 0xa4, 0xa1, 0x8d, 0xce, 0x1c,
 0xd2, 0x69, 0x38, 0x72, 0x25, 0xc0, 0xcc, 0xff,
 0x81, 0x65, 0x56, 0xfe, 0xe8, 0x55, 0x5d, 0x15,
 0xa4, 0xa4, 0xf2, 0x22, 0xa5, 0xcc, 0xe6, 0x5b,
 0x8a, 0xc6, 0xfe, 0xcc, 0x7b, 0x02, 0x48, 0xbf,
 0x5a, 0xf0, 0xca, 0x40, 0x47, 0xe5, 0x77, 0x9d,
 0xa1, 0xdb, 0xb6, 0x5c, 0x0d, 0xb8, 0x37, 0x58,
 0x13, 0x52, 0x42, 0x39, 0x0e, 0xdc, 0xc6, 0x0c,
 0x6a, 0xcd, 0x19, 0x44, 0x5a, 0xe3, 0x72, 0xbb,
 0x8d, 0x6e, 0xa7, 0xa3, 0x67, 0xf7, 0x1d, 0x78,
 0xfd, 0x93, 0xb7, 0xdf, 0xfe, 0xd8, 0xcc, 0xcc,
 0x8c, 0x87, 0xde, 0x20, 0x2e, 0x8a, 0x8b, 0x0e,
 0x99, 0x3a, 0xb0, 0x01, 0x10, 0x09, 0x21, 0x82,
 0x8f, 0x7f, 0xe2, 0x13, 0x97, 0x3f, 0x75, 0xc7,
 0xef, 0xfe, 0xe0, 0xf2, 0xe6, 0xe6, 0x91, 0x8d,
 0xb5, 0x0b, 0xb7, 0x6d, 0x5c, 0xbc, 0xe8, 0xc8,
 0xdf, 0x90, 0xa8, 0xd7, 0xea, 0x90, 0x0b, 0x02,
 0x5e, 0xad, 0x06, 0xdf, 0xeb, 0x22, 0x0c, 0x02,
 0x68, 0x1d, 0x03, 0x6c, 0x30, 0x34, 0x52, 0x0c,
 0xae, 0xb4, 0xaa, 0x03, 0xba, 0xbd, 0x37, 0xf0,
 0x74, 0x00, 0xa6, 0xcc, 0xa9, 0x51, 0x76, 0x99,
 0x27, 0x8e, 0x8a, 0x7b, 0xba, 0x60, 0x95, 0x0d,
 0x5f, 0xce, 0xcd, 0x87, 0xac, 0x01, 0xc2, 0x38,
 0x4b, 0x1a, 0xb9, 0x2d, 0xc6, 0x7d, 0xbf, 0x3d,
 0x0e, 0x1a, 0x03, 0x06, 0x91, 0x00, 0xdc, 0x8b,
 0x6d, 0x02, 0x24, 0x25, 0x94, 0x72, 0xe0, 0xd6,
 0x1b, 0x70, 0x6a, 0x35, 0x68, 0x63, 0xb0, 0xb3,
 0xb5, 0x85, 0xcb, 0xed, 0x4d, 0x08, 0xe5, 0x9c,
 0xbb, 0xf1, 0xa6, 0x9b, 0x7f, 0xf4, 0xd0, 0x57,
 0xff, 0xea, 0x55, 0xc7, 0x75, 0x7d, 0x00, 0xe1,
 0x80, 0x03, 0xdb, 0x31, 0x02, 0x40, 0x48, 0x44,
 0xde, 0x5f, 0xff, 0xcd, 0xdf, 0xfe, 0xe7, 0xea,
 0xca, 0xca, 0xf7, 0x7e, 0x72, 0xea, 0xdf, 0x17,
 0x76, 0xb6, 0xb7, 0x3e, 0x00, 0x40, 0xec, 0xdb,
 0xbf, 0x1f, 0xcd, 0x46, 0x03, 0xcd, 0xd9, 0x59,
 0x34, 0x9a, 0x4d, 0x44, 0x51, 0x88, 0x28, 0x8c,
 0xe2, 0xf0, 0x6f, 0x92, 0x13, 0xe8, 0xf6, 0xcc,
 0x3c, 0xa5, 0x7c, 0x83, 0x26, 0xd8, 0x30, 0x7b,
 0xbd, 0x7f, 0x55, 0xb7, 0xa8, 0x74, 0x88, 0xac,
 0x6e, 0x4d, 0x57, 0xc3, 0x21, 0xfd, 0x57, 0x27,
 0x63, 0x01, 0xdc, 0x73, 0x5e, 0xa1, 0x14, 0x84,
 0x90, 0x20, 0x21, 0x10, 0x46, 0x11, 0xb6, 0x2e,
 0xb7, 0xd1, 0xde, 0xdc, 0x44, 0x14, 0x46, 0x6b,
 0xd7, 0x1d, 0x3b, 0xfe, 0xd8, 0x9f, 0xdd, 0xff,
 0xe7, 0xdf, 0x6f, 0xce, 0xcc, 0x74, 0x01, 0x04,
 0x89, 0xfb, 0xe6, 0xeb, 0xc0, 0x99, 0x18, 0x01,
 0x20, 0xa8, 0xd5, 0xeb, 0xdd, 0xaf, 0x7e, 0xed,
 0x6b, 0x3f, 0xf2, 0xba, 0xdd, 0x99, 0x97, 0x9e,
 0xff, 0xaf, 0xfb, 0xb7, 0xdb, 0x1b, 0x37, 0x47,
 0x81, 0xef, 0xce, 0xb4, 0x5a, 0x98, 0x6b, 0xcd,
 0xa1, 0x56, 0xaf, 0x41, 0x39, 0x4e, 0xcf, 0x81,
 0x23, 0x1d, 0x3b, 0x97, 0x29, 0xbf, 0xaa, 0xa9,
 0xc2, 0xea, 0xa4, 0xf1, 0x57, 0x73, 0x29, 0x7f,
 0x19, 0x1b, 0xce, 0x49, 0x96, 0x3f, 0xfd, 0xc3,
 0xfe, 0x88, 0xf0, 0x76, 0x95, 0xc9, 0xc4, 0xd5,
 0x11, 0xd1, 0xab, 0xf5, 0xc6, 0xe0, 0x76, 0xb6,
 0xb6, 0xb0, 0xbd, 0x75, 0x19, 0xbb, 0x9d, 0x8e,
 0x21, 0x12, 0x2b, 0x87, 0x8f, 0xde, 0xf8, 0xe8,
 0x1f, 0xdd, 0xfb, 0x27, 0xdf, 0xbd, 0xeb, 0xee,
 0x7b, 0xd6, 0x00, 0x64, 0xdc, 0x97, 0x88, 0x4c,
 0xc1, 0xe0, 0xda, 0x24, 0x85, 0x31, 0x09, 0xc0,
 0x01, 0x50, 0x5b, 0x3e, 0x77, 0x6e, 0xe6, 0x1f,
 0xfe, 0xfe, 0xef, 0xfe, 0xf0, 0xb9, 0x67, 0x9e,
 0xfe, 0xfc, 0xa5, 0xd5, 0xf3, 0x1f, 0x26, 0x21,
 0xf6, 0xb9, 0x6e, 0x8d, 0x5c, 0xd7, 0x85, 0xe3,
 0xb8, 0x50, 0x4a, 0xc6, 0xb5, 0x55, 0x31, 0x9e,
 0x73, 0xd2, 0x38, 0x5c, 0x50, 0xa5, 0xc3, 0x1b,
 0x99, 0x12, 0x79, 0x62, 0xaa, 0x3b, 0xc7, 0x95,
 0xc3, 0x87, 0x2a, 0xfc, 0x0d, 0x57, 0xf3, 0xe4,
 0x92, 0x81, 0x81, 0x36, 0x1a, 0x3a, 0xd2, 0x08,
 0xa3, 0x10, 0xbe, 0xef, 0x23, 0xf0, 0x3c, 0x44,
 0x61, 0xd8, 0xa9, 0xcf, 0xcc, 0xfe, 0xf2, 0x86,
 0xe3, 0x37, 0x3d, 0xf6, 0x85, 0x2f, 0xfe, 0xc5,
 0xf7, 0xee, 0xfe, 0xe3, 0xcf, 0xad, 0xc4, 0xf0,
 0xfa, 0xb1, 0xb9, 0x6a, 0x22, 0xd2, 0x43, 0xff,
 0xc6, 0x18, 0x62, 0x11, 0x43, 0xac, 0x00, 0xb8,
 0x00, 0xdc, 0x7f, 0xfe, 0xa7, 0x7f, 0xbc, 0xe5,
 0x89, 0x93, 0x27, 0x3f, 0x73, 0x7e, 0x79, 0xe9,
 0xf6, 0xed, 0x8d, 0x8b, 0x87, 0x8d, 0xd6, 0x0b,
 0x20, 0x51, 0x4b, 0x26, 0x06, 0x88, 0xa6, 0xb5,
 0x21, 0xa9, 0x74, 0x63, 0x10, 0x55, 0x5d, 0x12,
 0x4d, 0x23, 0x8e, 0x4c, 0x0a, 0xfa, 0x38, 0x11,
 0xeb, 0xd7, 0x53, 0xa6, 0xd7, 0x5d, 0x06, 0x63,
 0x74, 0x08, 0xd0, 0x96, 0x5b, 0xab, 0xaf, 0xef,
 0x3b, 0xb4, 0xf8, 0xe2, 0x6f, 0x7f, 0xe4, 0x63,
 0x8f, 0x3e, 0xf0, 0xe0, 0x83, 0x3f, 0xbd, 0xe5,
 0x83, 0xb7, 0x6e, 0xc5, 0xe0, 0x26, 0xd1, 0x21,
 0xe3, 0xbe, 0xa3, 0x00, 0x06, 0x92, 0x1b, 0x88,
 0xf7, 0x20, 0x76, 0xc2, 0x30, 0x74, 0x2f, 0xae,
 0xaf, 0xd7, 0xbf, 0xfb, 0x6f, 0xff, 0x7a, 0xfc,
 0xd9, 0x67, 0x9e, 0xfe, 0xd4, 0xe6, 0xe6, 0xe6,
 0x47, 0xb7, 0x2e, 0x5f, 0xbe, 0xbe, 0xbb, 0xb3,
 0x5d, 0x37, 0x5a, 0xab, 0x28, 0x0c, 0xdc, 0xa9,
 0x1d, 0xca, 0xe8, 0xdd, 0x01, 0x67, 0xd5, 0x4c,
 0x4d, 0xd3, 0xcc, 0x1d, 0xef, 0x72, 0x09, 0x21,
 0x42, 0x21, 0x55, 0x20, 0x1d, 0x37, 0x9c, 0x69,
 0xcd, 0xad, 0xcc, 0x2f, 0xcc, 0xbf, 0x72, 0xe4,
 0xc8, 0xd1, 0x67, 0xee, 0xf9, 0xdc, 0xbd, 0x2f,
 0xdd, 0x7e, 0xe7, 0xef, 0x6d, 0x08, 0x21, 0x7c,
 0x22, 0x0a, 0xe2, 0xd8, 0x50, 0x08, 0xef, 0xc8,
 0x55, 0x65, 0xc5, 0x89, 0xd4, 0x8d, 0x8d, 0x31,
 0xca, 0xf3, 0x3c, 0xc7, 0xf7, 0x3d, 0xb7, 0xbd,
 0xd9, 0x76, 0x7f, 0xf2, 0xd4, 0x93, 0x07, 0x5e,
 0x7a, 0xfe, 0xf9, 0xc5, 0x9d, 0x9d, 0xed, 0xd6,
 0xa5, 0x8b, 0xeb, 0x87, 0x88, 0x04, 0x5d, 0x91,
 0xae, 0xb4, 0x92, 0xa4, 0xd0, 0xb4, 0xb9, 0xf8,
 0xb5, 0xc8, 0x9b, 0x57, 0x61, 0xfe, 0x05, 0xd0,
 0x6c, 0x36, 0xdb, 0x73, 0xf3, 0x0b, 0x1b, 0x87,
 0xaf, 0xbb, 0x6e, 0xfd, 0x13, 0xb7, 0xdf, 0xb1,
 0x7e, 0xec, 0xfd, 0x37, 0x75, 0x94, 0x94, 0x41,
 0xad, 0x5e, 0xf7, 0xa5, 0x94, 0x89, 0xe3, 0xda,
 0x15, 0x87, 0x01, 0x78, 0xf7, 0x5c, 0xe3, 0x16,
 0xc4, 0x36, 0xc8, 0x12, 0x80, 0x34, 0xc6, 0x08,
 0xdf, 0xf7, 0x65, 0xe0, 0xfb, 0x32, 0xd2, 0x9a,
 0xa2, 0x30, 0x14, 0x20, 0x22, 0xe2, 0xad, 0xc8,
 0x1a, 0x8d, 0xaf, 0x01, 0x00, 0x29, 0x84, 0x16,
 0x52, 0x6a, 0xa5, 0x94, 0x76, 0x5d, 0x37, 0x92,
 0x52, 0x46, 0x56, 0x11, 0x21, 0xf9, 0x3e, 0x2d,
 0x97, 0x15, 0xc1, 0x5b, 0xca, 0x32, 0xac, 0x48,
 0x61, 0x83, 0x5c, 0xf4, 0x95, 0x2d, 0x88, 0x55,
 0xcd, 0x86, 0xad, 0xc6, 0xf4, 0x1c, 0xb0, 0xc9,
 0x20, 0xcd, 0x0c, 0x03, 0x77, 0xac, 0x63, 0x9e,
 0xe5, 0xc8, 0xc8, 0x41, 0x4d, 0x7c, 0x1c, 0x65,
 0x4d, 0x00, 0x70, 0xfe, 0x39, 0xec, 0x05, 0xee,
 0x54, 0x60, 0xb3, 0xdc, 0x99, 0xc5, 0x1a, 0x7f,
 0x88, 0x53, 0x12, 0xd6, 0x22, 0xfd, 0x1f, 0x25,
 0xb5, 0x2c, 0xf1, 0x27, 0xc2, 0x5a, 0x69, 0x00,
 0x00, 0x00, 0x00, 0x49, 0x45, 0x4e, 0x44, 0xae,
 0x42, 0x60, 0x82
])


PSX_SITE = 'https://psxdatacenter.com/'
verbose = False
if sys.platform == 'win32':
    font = 'arial.ttf'
else:
    font = 'DejaVuSansMono.ttf'

def _get_gameid_from_iso(path='NORMAL01.iso'):
    with open(path, 'rb') as f:
        h = hashlib.md5(f.read(1024*1024)).hexdigest()
        print('MD5 fingerprint', h)
        if h in gameid_by_md5sum:
            return gameid_by_md5sum[h]['id']

    if not have_pycdlib and not have_iso9660:
        raise Exception('Can not find either pycdlib or pycdio. Try either \'pip3 install pycdio\' or \'pip3 install pycdlib\'.')

    buf = None
    if have_pycdlib:
        try:
            iso = pycdlib.PyCdlib()
            iso.open(path)
            extracted = io.BytesIO()
            iso.get_file_from_iso_fp(extracted, iso_path='/SYSTEM.CNF;1')
            extracted.seek(0)
            buf = str(extracted.read(1024))
            iso.close()
        except:
            True
    if not buf and have_iso9660:
        try:
            iso = iso9660.ISO9660.IFS(source=path)
            st = iso.stat('system.cnf', True)
            if st is None:
                raise Exception('Could not open system.cnf')

            buf = iso.seek_read(st['LSN'])[1][:128]
            iso.close()
        except:
            True

    if not buf:
        with open(path, 'rb') as f:
            h = hashlib.md5(f.read(1024*1024)).hexdigest()
            print('MD5 fingerprint', h)
            if h in gameid_by_md5sum:
                return gameid_by_md5sum[h]['id']

    if not buf:
        print('Failed to read game id. Falling back to raw read')
        with open(path, 'rb') as f:
            f.seek(0x8028)
            buf = str(f.read(9))[2:-1]
            if buf in gameid_translation:
                return gameid_translation[buf]['id']
            if buf != '         ':
                return buf
            else:
                return 'UNKN00000'

    idx = buf.find('cdrom:')
    if idx < 0:
        raise Exception('Could not read system.cnf')

    buf = buf[idx + 6:idx + 50]
    idx = buf.find('\\r')
    if idx > 0:
        buf = buf[:idx]
    idx = buf.find('\r')
    if idx > 0:
        buf = buf[:idx]
    idx = buf.find('\\n')
    if idx > 0:
        buf = buf[:idx]
    idx = buf.find('\n')
    if idx > 0:
        buf = buf[:idx]
    idx = buf.find(';1')
    if idx > 0:
        buf = buf[:idx]
    # Some games are of the form \DIR\SLPS12345, get rid of the path
    buf = buf.split('\\')[-1]
    
    bad_chars = "\\_. -"
    for i in bad_chars:
        buf = buf.replace(i, "")

    game_id = buf.upper()
    # Special handling of games with broken id in system.cnf
    if game_id in gameid_translation:
        game_id = gameid_translation[game_id]['id']
    if len(game_id) != 9:
        print('cdrom: line in system.cnf does not contain a proper id, read disc label instead')
        with open(path, 'rb') as f:
            f.seek(0x8028)
            game_id = str(f.read(9))[2:-1].upper()
    # Special handling of games with broken id in system.cnf
    if game_id in gameid_translation:
        game_id = gameid_translation[game_id]['id']
    if game_id not in games and buf[:9] in games:
        return buf[:9]
    return game_id

def get_gameid_from_iso(path='NORMAL01.iso'):
    game_id = _get_gameid_from_iso(path=path)
    if game_id not in games:
        game_id = 'UNKN00000'
    return game_id

def fetch_cached_file(path):
    try:
        ret = requests.get(PSX_SITE + path)
    except:
        return None
    print('get', PSX_SITE + path) if verbose else None
    if ret.status_code != 200:
        raise Exception('Failed to fetch file ', PSX_SITE + path)

    if ret.apparent_encoding:
        return ret.content.decode(ret.apparent_encoding)
    else:
        return ret.content

def fetch_cached_binary(path):
    try:
        ret = requests.get(PSX_SITE + path, stream=True)
    except:
        print('fetch_cached_binary: Failed to fetch file ', PSX_SITE + path)
        return None
    if ret.status_code != 200:
        print('fetch_cached_binary: Failed to fetch file ', PSX_SITE + path)
        return None

    return ret.content

def get_game_from_gamelist(game_id):
    if 'url' not in games[game_id]:
        return None
    return fetch_cached_file(games[game_id]['url']) if game_id in games else None

def get_title_from_game(game_id):
    return games[game_id]['title'] if game_id in games else "Unknown"

def get_snd0_from_theme(theme, game_id, subdir):
    try:
        tmpfile = subdir + '/snd0.theme'
        temp_files.append(tmpfile)
        url = themes[theme]['url'] + '/blob/main/data/' + game_id + '/SND0.WAV' + '?raw=true'
        print('Try URL', url)
        subprocess.run(['wget', '-q', url, '-O', tmpfile], timeout=30, check=True)
        return tmpfile
    except:
        return None
    
def get_image_from_theme(theme, game_id, subdir, image):
    if theme == 'ASCIIART':
        if image[:4] == 'PIC0':
            return create_ascii_pic0(game_id, games[game_id]['title'])
        if image[:4] == 'PIC1':
            game = get_game_from_gamelist(game_id)
            icon0 = get_icon0_from_game(game_id, game, None, subdir + '/ICON0-theme.jpg')

            return create_ascii_pic1(game_id, icon0)
    if theme == 'DOTPAINTING':
        if image[:4] == 'PIC0':
            return create_dotpainting_pic0(game_id, games[game_id]['title'])
        if image[:4] == 'PIC1':
            game = get_game_from_gamelist(game_id)
            icon0 = get_icon0_from_game(game_id, game, None, subdir + '/ICON0-theme.jpg')

            return create_dotpainting_pic1(game_id, icon0)
    if theme == 'OILPAINTING':
        if image[:4] == 'PIC0':
            tmpfile = subdir + '/pic0-tmp.png'
            temp_files.append(tmpfile)
            return create_oilpainting_pic0(game_id, games[game_id]['title'], tmpfile)
        if image[:4] == 'PIC1':
            game = get_game_from_gamelist(game_id)
            icon0 = get_icon0_from_game(game_id, game, None, subdir + '/ICON0-theme.jpg')
            tmpfile = subdir + '/pic1-tmp.png'
            temp_files.append(tmpfile)
            return create_oilpainting_pic1(game_id, icon0, tmpfile)
    if theme == 'WATERCOLOR':
        if image[:4] == 'PIC0':
            tmpfile = subdir + '/pic0-tmp.png'
            temp_files.append(tmpfile)
            return create_watercolor_pic0(game_id, games[game_id]['title'], tmpfile)
        if image[:4] == 'PIC1':
            game = get_game_from_gamelist(game_id)
            icon0 = get_icon0_from_game(game_id, game, None, subdir + '/ICON0-theme.jpg')
            tmpfile = subdir + '/pic1-tmp.png'
            temp_files.append(tmpfile)
            return create_watercolor_pic1(game_id, icon0, tmpfile)
    if theme == 'COLORSKETCH':
        if image[:4] == 'PIC0':
            tmpfile = subdir + '/pic0-tmp.png'
            temp_files.append(tmpfile)
            return create_colorsketch_pic0(game_id, games[game_id]['title'], tmpfile)
        if image[:4] == 'PIC1':
            game = get_game_from_gamelist(game_id)
            icon0 = get_icon0_from_game(game_id, game, None, subdir + '/ICON0-theme.jpg')
            tmpfile = subdir + '/pic1-tmp.png'
            temp_files.append(tmpfile)
            return create_colorsketch_pic1(game_id, icon0, tmpfile)
    if 'auto' in themes[theme]:
        return None
    try:
        url = themes[theme]['url'] + '/raw/main/data/' + game_id + '/' + image
        print('Try URL', url) #if verbose else None
        ret = requests.get(url, stream=True)
        if ret.status_code != 200:
            return None

        d = ret.content
        return Image.open(io.BytesIO(d))
    except:
        return None

def get_icon0_from_game(game_id, game, cue, tmpfile, psn_frame_size=None):
    try:
        image = Image.open(cue[:-4] + '_cover.png')
        print('Use existing file %s as cover' % (cue[:-4] + '_cover.png')) if verbose else None 
        return image
    except:
        True

    if 'icon0' in games[game_id]:
        if not games[game_id]['icon0']:
            return None
        ret = requests.get(games[game_id]['icon0'], stream=True)
        if ret.status_code != 200:
            return None
        fcb = ret.content
    else:
        if not game or game_id[:4] == 'UNKN':
            return Image.new("RGBA", psn_frame_size[0], (255,255,255,0))

        i = None
        g = re.findall('images/covers/./.*/.*.jpg', game)
        if not g:
            return None
        fcb = fetch_cached_binary(g[0])

    if not fcb:
        return None
    i = Image.open(io.BytesIO(fcb))

    if psn_frame_size:
        im0 = Image.open(io.BytesIO(i0))
        im0 = im0.resize(psn_frame_size[0], Image.Resampling.HAMMING)
        i = i.resize(psn_frame_size[1], Image.Resampling.HAMMING)
        Image.Image.paste(im0, i,
                box=((psn_frame_size[0][0] - psn_frame_size[1][0]) // 2,
                     (psn_frame_size[0][1] - psn_frame_size[1][1]) // 2))
        return im0
    return i

def get_pic_from_game(pic, game_id, game, filename):
    try:
        image = Image.open(filename)
        print('Use existing', filename, 'as', pic) if verbose else None
        return image
    except:
        True

    if game_id in games and pic in games[game_id]:
        # pic None-ed out in gamedb
        if not games[game_id][pic]:
            return None

        _h = hashlib.md5(games[game_id][pic].encode('utf-8')).hexdigest()
        f = 'https://github.com/sahlberg/pop-fe-assets/raw/master/' + pic + '/' + _h
        ret = requests.get(f, stream=True)
        if ret.status_code == 200:
            print('Found cached prebuilt', pic.upper(), f)
            return Image.open(io.BytesIO(ret.content))
    
        ret = requests.get(games[game_id][pic], stream=True)
        if ret.status_code == 200:
            if ret.apparent_encoding:
                return Image.open(io.BytesIO(ret.content.decode(ret.apparent_encoding)))
            else:
                return Image.open(io.BytesIO(ret.content))
    if not game or game_id[:4] == 'UNKN':
        return Image.new("RGBA", (80, 80), (255,255,255,0))
    
    # Screenshots might be from a different release of the game
    # so we can not use game_id
    filter = 'images/screens/./.*/.*/ss..jpg'
    fcb = fetch_cached_binary(random.choice(re.findall(filter, game)))
    if not fcb:
        return None
    return Image.open(io.BytesIO(fcb))

def get_pic0_from_game(game_id, game, cue):
    try:
        pic0 = get_pic_from_game('pic0', game_id, game, cue[:-4] + '_pic0.png')
        # If we need to rescale, paste the image into a larger transparent
        # canvas first before we rescale it below
        if 'pic0-scaling' in games[game_id]:
            i = Image.new(pic0.mode,
                    (int(pic0.size[0] / games[game_id]['pic0-scaling']),
                     int(pic0.size[1] / games[game_id]['pic0-scaling'])),
                    (0,0,0)).convert('RGBA')
            i.putalpha(0)
            ns = (int((i.size[0] - pic0.size[0]) / 2),
                  int((i.size[1] - pic0.size[1]) / 2))
            i.paste(pic0, ns)
            pic0 = i
    
        # resize to maximum 1000,560 (ps3 PIC0 size) keeping aspect ratio
        ar = pic0.height / pic0.width
        if pic0.height * ar > 560:
            if int(560 / ar) < 1000:
                pic0 = pic0.resize((int(560 / ar), 560), Image.Resampling.NEAREST)
            else:
                ar = 1000 / pic0.width
                pic0 = pic0.resize((1000, int(pic0.height * ar)), Image.Resampling.NEAREST)
            i = Image.new(pic0.mode, (1000, 560), (0,0,0)).convert('RGBA')
            i.putalpha(0)
            ns = (int((1000 - pic0.size[0]) / 2), 0)
            i.paste(pic0, ns)
            pic0 = i
        else:
            ns = (1000, int(1000 * ar))
            if ns[1] > 500:
                ns = (int(ns[0] * 500 / ns[1]), int(ns[1] * 500 / ns[1]))
            pic0 = pic0.resize(ns, Image.Resampling.NEAREST)
            i = Image.new(pic0.mode, (1000, 560), (0,0,0)).convert('RGBA')
            i.putalpha(0)
            i.paste(pic0, (int((1000 - pic0.size[0]) / 2),
                           int((560 - pic0.size[1]) / 2)))
            pic0 = i
    except:
        return None

    return pic0

def get_pic1_from_game(game_id, game, cue):
    try:
        return get_pic_from_game('pic1', game_id, game, cue[:-4] + '_pic1.png')
    except:
        return None

def get_pic1_from_bc(game_id, game, cue):
    if game_id[:4] == 'UNKN':
        return Image.new("RGBA", (80, 80), (255,255,255,0))
    
    path = games[game_id]['url'][:-5].replace('games', 'images/hires')
    path = path + '/' + path.split('/')[-1] + '-B-ALL.jpg'
    ret = requests.get(PSX_SITE + path, stream=True)
    if ret.status_code != 200:
        return Image.new("RGBA", (80, 80), (255,255,255,0))

    return Image.open(io.BytesIO(ret.content))

def get_icon0_from_disc(game_id, game, cue, filename):
    if game_id[:4] == 'UNKN':
        return Image.new("RGBA", (80, 80), (255,255,255,0))
    
    path = games[game_id]['url'][:-5].replace('games', 'images/hires')
    path = path + '/' + path.split('/')[-1] + '-D-ALL.jpg'
    ret = requests.get(PSX_SITE + path, stream=True)
    if ret.status_code != 200:
        return Image.new("RGBA", (80, 80), (255,255,255,0))

    return Image.open(io.BytesIO(ret.content))

def convert_snd0_to_at3(snd0, at3, duration, max_size, subdir = './'):
    print('Creating SND0.AT3')
    tmp_wav = subdir + 'SND0.WAV'
    tmp_snd0 = subdir + 'SND0.EA3'
    temp_files.append(tmp_wav)
    temp_files.append(tmp_snd0)
    s = parse_riff(snd0)
    if not s:
        print('Not a WAVE file')
        return None

    loop = True
    while loop:
        print('Creating temporary WAV file clamped to %d second duration %s' % (duration, tmp_wav))
        copy_riff(snd0, tmp_wav, max_duration_ms=duration * 1000)
        s = parse_riff(tmp_wav)
        print('Creating temporary ATRAC3 file', tmp_snd0) if verbose else None
        try:
            if os.name == 'posix':
                subprocess.run(['./atracdenc/src/atracdenc', '--encode=atrac3', '-i', tmp_wav, '-o', tmp_snd0], check=True, stdout=subprocess.DEVNULL)
            else:
                subprocess.run(['atracdenc/src/atracdenc', '--encode=atrac3', '-i', tmp_wav, '-o', tmp_snd0], check=True, stdout=subprocess.DEVNULL)
        except:
            print('XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX\natracdenc not found.\nCan not create SND0.AT3\nPlease see README file for how to install atracdenc\nXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX')
            return None
        print('Converting EA3 to AT3 file') if verbose else None
        temp_files.append(at3)
        create_riff(tmp_snd0, at3, number_of_samples=int(len(s['data']['data'])/4), max_data_size=0, loop=True)
        if os.stat(at3).st_size < max_size:
            break
        # Too big. Clamp duration and try again
        duration = int(duration * 0.95 / (os.stat(at3).st_size / max_size))
    return snd0

# caller adds the wav file to temp_files
def get_snd0_from_link(link, subdir='./'):
    _h = hashlib.md5(link.encode('utf-8')).hexdigest()
    f = 'https://github.com/sahlberg/pop-fe-assets/raw/master/snd0/' + _h
    try:
        ret = requests.get(f, stream=True)
    except:
        return None
    if ret.status_code == 200:
        print('Found cached prebuilt SND0', f)
        _d = subdir + 'SND0.tmp'
        with open(_d, 'wb') as o:
            o.write(ret.content)
            temp_files.append(_d)
        return _d

    if not have_pytube:
        return None
    try:
        fn = YouTube(link).streams.filter(only_audio=True)[0].download(subdir)
    except:
        print('Failed to download', link)
        return None
    temp_files.append(fn)
    return fn;

# caller adds the wav file to temp_files
def get_snd0_from_game(game_id, subdir='./'):
    if not have_pytube or not game_id in games:
        return None
    if not 'snd0' in games[game_id]:
        return None

    return get_snd0_from_link(games[game_id]['snd0'], subdir=subdir)

def get_psio_cover(game_id):
    f = 'https://raw.githubusercontent.com/logi-26/psio-assist/main/covers/' + game_id + '.bmp'
    ret = requests.get(f, stream=True)
    if ret.status_code != 200:
        raise Exception('Failed to fetch file ', f)

    return ret.content

def generate_magic_word(url):
    print('Compute MagicWord from URL', url)
    
    ret = requests.get(url)
    print('get', url) if verbose else None
    if ret.status_code != 200:
        raise Exception('Failed to fetch file ', url)

    b = ret.content.decode(ret.apparent_encoding)
    idx = b.find('Sectors with LibCrypt protection')
    if idx == -1:
        print('Subchannel data not found at', url)
        return 0
    b = b[idx:]
    idx = b.find('table')
    b = b[:idx]

    mw = 0
    if b.find('<td>14105</td>') > 0 or b.find('<td>14110</td>') > 0:
        mw = mw | 0x8000
    if b.find('<td>14231</td>') > 0 or b.find('<td>14236</td>') > 0:
        mw = mw | 0x4000
    if b.find('<td>14485</td>') > 0 or b.find('<td>14490</td>') > 0:
        mw = mw | 0x2000
    if b.find('<td>14579</td>') > 0 or b.find('<td>14584</td>') > 0:
        mw = mw | 0x1000

    if b.find('<td>14649</td>') > 0 or b.find('<td>14654</td>') > 0:
        mw = mw | 0x0800
    if b.find('<td>14899</td>') > 0 or b.find('<td>14904</td>') > 0:
        mw = mw | 0x0400
    if b.find('<td>15056</td>') > 0 or b.find('<td>15061</td>') > 0:
        mw = mw | 0x0200
    if b.find('<td>15130</td>') > 0 or b.find('<td>15135</td>') > 0:
        mw = mw | 0x0100
        
    if b.find('<td>15242</td>') > 0 or b.find('<td>15247</td>') > 0:
        mw = mw | 0x0080
    if b.find('<td>15312</td>') > 0 or b.find('<td>15317</td>') > 0:
        mw = mw | 0x0040
    if b.find('<td>15378</td>') > 0 or b.find('<td>15383</td>') > 0:
        mw = mw | 0x0020
    if b.find('<td>15628</td>') > 0 or b.find('<td>15633</td>') > 0:
        mw = mw | 0x0010
        
    if b.find('<td>15919</td>') > 0 or b.find('<td>15924</td>') > 0:
        mw = mw | 0x0008
    if b.find('<td>16031</td>') > 0 or b.find('<td>16036</td>') > 0:
        mw = mw | 0x0004
    if b.find('<td>16101</td>') > 0 or b.find('<td>16106/td>') > 0:
        mw = mw | 0x0002
    if b.find('<td>16167</td>') > 0 or b.find('<td>16172</td>') > 0:
        mw = mw | 0x0001

    print('MagicWord %04x' % mw)
    return mw
    
def get_first_bin_in_cue(cue):
    with open(cue, "r") as f:
        files = re.findall('".*"', f.read())
        return files[0][1:-1]

def add_image_text(image, title, game_id):
    # Add a nice title text to the background image
    # Split it into separate lines
    #   for ' - '
    print('Add image text: title:', title) if verbose else None
    strings = title.split(' - ')
    y = 18
    txt = Image.new("RGBA", image.size, (255,255,255,0))
    fnt = ImageFont.truetype(font, 8)
    d = ImageDraw.Draw(txt)

    # Add Title (multiple lines) to upper right
    for t in strings:
        ts = d.textsize(t, font=fnt)
        d.text((image.size[0] - ts[0], y), t, font=fnt,
               fill=(255,255,255,255))
        y = y + ts[1] + 2

    # Add game-id to bottom right
    fnt = ImageFont.truetype(font, 10)
    ts = d.textsize(game_id, font=fnt)
    d.rectangle([(image.size[0] - ts[0] - 1, image.size[1] - ts[1] + 1),
                 (image.size[0] + 1, image.size[1] + 1)],
                fill=(0,0,0,255))
    d.text((image.size[0] - ts[0], image.size[1] - ts[1] - 1),
           game_id, font=fnt, fill=(255,255,255,255))

    image = Image.alpha_composite(image, txt)
    return image

def copy_file(inp, oup):
    with open(inp, "rb") as i:
        with open(oup, "wb") as o:
            while True:
                buf = i.read(1024*1024)
                if len(buf) == 0:
                    break
                o.write(buf)


def create_path(bin, f):
    s = bin.split('/')
    if len(s) > 1:
        f = '/'.join(s[:-1]) + '/' + f
    return f

def create_retroarch_thumbnail(dest, game_title, icon0, pic1):
        try:
            os.stat(dest + '/Named_Boxarts')
        except:
            os.mkdir(dest + '/Named_Boxarts')
    
        image = icon0.resize((256,256), Image.Resampling.BILINEAR)
        #The following characters in playlist titles must be replaced with _ in the corresponding thumbnail filename: &*/:`<>?\|
        f = args.retroarch_thumbnail_dir + '/Named_Boxarts/' + game_title + '.png'
        print('Save cover as', f) if verbose else None
        image.save(f, 'PNG')

        try:
            os.stat(args.retroarch_thumbnail_dir + '/Named_Snaps')
        except:
            os.mkdir(args.retroarch_thumbnail_dir + '/Named_Snaps')
        image = pic1.resize((512,256), Image.Resampling.BILINEAR)
        #The following characters in playlist titles must be replaced with _ in the corresponding thumbnail filename: &*/:`<>?\|
        f = args.retroarch_thumbnail_dir + '/Named_Snaps/' + game_title + '.png'
        print('Save snap as', f) if verbose else None
        image.save(f, 'PNG')


def create_metadata(cue, game_id, game_title, icon0, pic0, pic1, snd0, manual):
    print('fetching metadata for', game_id, 'to directory', cue) if verbose else None

    f = cue.split('/')[-1][:-4]

    # GAME_ID
    try:
        os.stat(create_path(cue, 'GAME_ID'))
    except:
        print('Installing GAME_ID')
        with open(create_path(cue, 'GAME_ID'), 'w') as d:
            d.write(game_id)

    # GAME_TITLE
    try:
        os.stat(create_path(cue, 'GAME_TITLE'))
    except:
        print('Installing GAME_TITLE')
        with open(create_path(cue, 'GAME_TITLE'), 'w') as d:
            d.write(game_title)

    # COVER
    try:
        os.stat(create_path(cue, f + '_cover.png'))
    except:
        print('Installing COVER')
        icon0.save(create_path(cue, f + '_cover.png'))
            
    # PIC0
    if pic0 and game_id in games and 'pic0' in games[game_id]:
        try:
            os.stat(create_path(cue, f + '_pic0.png'))
        except:
            print('Installing PIC0')
            pic0.save(create_path(cue, f + '_pic0.png'))
            
    # PIC1
    if game_id in games and 'pic1' in games[game_id]:
        try:
            os.stat(create_path(cue, f + '_pic1.png'))
        except:
            print('Installing PIC1')
            pic1.save(create_path(cue, f + '_pic1.png'))

    # SND0
    if snd0 and game_id in games and 'snd0' in games[game_id]:
        try:
            os.stat(create_path(cue, f + '.snd0'))
        except:
            print('Installing SND0')
            with open(snd0, 'rb') as i:
                with open(create_path(cue, f + '.snd0'), 'wb') as o:
                    o.write(i.read())
        
    # MANUAL
    if manual and game_id in games and 'manual' in games[game_id]:
        try:
            os.stat(create_path(cue, f + '.manual'))
        except:
            print('Installing MANUAL')
            with open(manual, 'rb') as i:
                with open(create_path(cue, f + '.manual'), 'wb') as o:
                    o.write(i.read())

        
def get_imgs_from_bin(cue):
    def get_file_name(line):
        # strip off leading 'FILE '
        pos = line.lower().index('file ')
        line = line[pos + 5:]
        # strip off leading 'FILE '
        pos = line.lower().index(' binary')
        line = line[:pos+1]
        #strip off leading ' '
        while line[0] == ' ':
            line = line[1:]
        #strip off trailing ' '
        while line[-1] == ' ':
            line = line[:-1]
        # remove double quotes
        if line[0] == '"':
            line = line[1:-1]
        # remove single quotes
        if line[0] == '\'':
            line = line[1:-1]
        return line
    
    print('CUE', cue) if verbose else None

    img_files = []
    with open(cue, 'r') as f:
        lines = f.readlines()
        for line in lines:
            # FILE
            if re.search('^\s*FILE', line):
                f = get_file_name(line)
                # unix absilute paths start with /
                # windows absolute patsh start with ?:/
                if f[0] != '/' and f[1:3] != '://':
                    s = cue.split('/')
                    if len(s) > 1:
                        f = '/'.join(s[:-1]) + '/' + f
                img_files.append(f)
    return img_files


def create_retroarch_bin(dest, game_title, cue_files, img_files):
    try:
        os.mkdir(dest)
    except:
        True
    with open(dest + '/' + game_title + '.m3u', 'wb') as md:
        for i in range(len(img_files)):
            g = game_title
            g = g + '-%d' % i + '.img'
            md.write(bytes(g + chr(13) + chr(10), encoding='utf-8'))

            f = dest + '/' + g
            print('Installing', f) if verbose else None
            copy_file(img_files[i], f)
            

def create_retroarch_cue(dest, game_title, cue_files, img_files, magic_word):
    try:
        os.mkdir(dest)
    except:
        True
    with open(dest + '/' + 'PSISO.m3u', 'wb') as md:
        for i in range(len(cue_files)):
            p = 'PSISO%d' % i
            with open(dest + '/' + p + '.CD', 'wb') as nc:
                md.write(bytes(p + '.CD' + chr(13) + chr(10), encoding='utf-8'))
                cur_cue = open(cue_files[i], 'r')
                for line in cur_cue:
                    m = re.search('FILE "?(.*?)"? BINARY', line)
                    if m:
                        nc.write(bytes('FILE \"%s.bin\" BINARY' % p + chr(13) + chr(10), encoding='utf-8'))
                    else:
                        nc.write(bytes(line, encoding='utf-8'))
                
                b = dest + '/' + p + '.bin'
                print('Installing', b) if verbose else None
                copy_file(img_files[i], b)
            if i < len(magic_word):
                print('Create magic word for disc', i)
                create_sbi(dest + '/' + p + '.sbi', magic_word[i])
                
def create_psio(dest, game_id, game_title, icon0, cu2_files, img_files):
    f = dest + '/' + game_title
    try:
        os.mkdir(f)
    except:
        True

    with open(f + '/' + game_id[0:4] + '-' + game_id[4:9] + '.bmp', 'wb') as d:
        image = icon0.resize((80,84), Image.Resampling.BILINEAR)
        i = io.BytesIO()
        image.save(i, format='BMP')
        i.seek(0)
        d.write(i.read())
            
    try:
        os.unlink(f + '/MULTIDISC.LST')
    except:
        True
    with open(f + '/MULTIDISC.LST', 'wb') as md:
        for i in range(len(img_files)):
            g = game_title
            g = g + '-%d' % i
            g = g + '.img'
            md.write(bytes(g + chr(13) + chr(10), encoding='utf-8'))

            print('Installing', f + '/' + g) if verbose else None
            copy_file(img_files[i], f + '/' + g)
            copy_file(cu2_files[i], f + '/' + g[:-4] + '.cu2')


def get_toc_from_cu2(cu2):
    def bcd(i):
        return int(i % 10) + 16 * (int(i / 10) % 10)

    _toc_header = bytes([
        0x41, 0x00, 0xa0, 0x00, 0x00, 0x00, 0x00, 0x01, 0x20, 0x00,
        0x01, 0x00, 0xa1, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
        0x01, 0x00, 0xa2, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
        ])
    
    toc = bytearray(_toc_header)

    with open(cu2, 'r') as f:
        lines = f.readlines()

        # Find the number of tracks and trk_end
        num_tracks = None
        trk_end = None
        data = None
        for line in lines:
            if re.search('data', line):
                data = line[10:10 + 8]
            if re.search('^ntracks', line):
                num_tracks = int(line[7:])
            if re.search('^trk end', line):
                trk_end = line[10:]
        # number of tracks
        toc[17] = bcd(num_tracks)
        # size of image
        m = bcd(int(trk_end[:2]))
        s = bcd(int(trk_end[3:5]) - 2)
        f = bcd(int(trk_end[6:8]))

        # lead-out is the next frame
        f = f + 1
        if f == 75:
            s = s + 1
            f = 0
        if s == 60:
            m = m + 1
            s = 0
        toc[27] = m
        toc[28] = s
        toc[29] = f
        track = 1
        for line in lines:
            if not re.search('^data', line) and not re.search('^track', line):
                continue
            
            msf = line[10:]
            buf = bytearray(10)
            if track == 1:
                buf[0] = 0x41
                buf[2] = bcd(track)
                buf[3] = bcd(int(data[:2]))
                buf[4] = bcd(int(data[3:5]))
                buf[5] = 1
                m = int(data[:2])
                s = int(data[3:5])
                f = int(data[6:8])
                buf[7] = m
                buf[8] = s
                buf[9] = f
            else:
                buf[0] = 0x01
                buf[2] = bcd(track)
                m = bcd(int(msf[:2])  - 2*int(data[:2]))
                _s = int(msf[3:5]) - 2*int(data[3:5])
                _s = _s + 2
                if _s >= 60:
                    m = m + 1
                    _s = _s - 60
                s = bcd(_s)
                f = bcd(int(msf[6:8]) - 2*int(data[6:8]))
                buf[3] = m
                buf[4] = s
                buf[5] = f
                m = bcd(int(msf[:2])  - int(data[:2]))
                f = bcd(int(msf[6:8]) - 2*int(data[6:8]))
                _s = int(msf[3:5]) - int(data[3:5])
                _s = _s + 2
                if _s >= 60:
                    m = m + 1
                    _s = _s - 60
                s = bcd(_s)
                f = bcd(int(msf[6:8]) - int(data[6:8]))
                buf[7] = m
                buf[8] = s
                buf[9] = f
            
            track = track + 1
            toc = toc + buf

        return toc


def generate_pbp(dest_file, disc_ids, game_title, icon0, pic0, pic1, cue_files, cu2_files, img_files, aea_files, snd0=None, whole_disk=True, subchannels=[], configs=None, logo=None):
    print('Create PBP file for', game_title) if verbose else None

    SECTLEN = 2352
    p = popstation()
    p.verbose = verbose
    p.disc_ids = disc_ids
    p.game_title = game_title
    p.subchannels = subchannels
    if configs:
        p.configs = configs
    if logo:
        p.logo = logo
    if icon0:
        p.icon0 = icon0
    if pic0:
        p.pic0 = pic0
    if pic1:
        p.pic1 = pic1
    if len(aea_files):
        p.aea = aea_files
    if snd0:
        p.snd0 = snd0
    for i in range(len(img_files)):
        f = img_files[i]
        print('Need to create a TOC') if verbose else None
        toc = get_toc_from_cu2(cu2_files[i])

        print('Add image', f) if verbose else None
        p.add_img((f, toc))
        
        if not whole_disk:
            bc = bchunk()
            bc.towav = True
            bc.open(cue_files[i])
            # store how big the data track is
            p.add_track0_size(bc.tracks[1]['INDEX'][1]['STOPSECT'] * SECTLEN)
            p.striptracks = True

    p.eboot = dest_file
    print('Create PBP file at', p.eboot)
    p.create_pbp()
    try:
        os.sync()
    except:
        True

    
def create_psp(dest, disc_ids, game_title, icon0, pic0, pic1, cue_files, cu2_files, img_files, mem_cards, aea_files, subdir = './', snd0=None, watermark=False, subchannels=[], manual=None, configs=None, use_cdda=False, logo=None):
    # Convert LOGO to a file object
    if logo:
        image = logo
        if image.size != (480,272):
            image = image.resize((480, 272), Image.Resampling.HAMMING)
        i = io.BytesIO()
        image.save(i, format='PNG')
        i.seek(0)
        logo = i.read()

    # Convert ICON0 to a file object
    if icon0:
        image = icon0
        if icon0.size[0] / icon0.size[1] < 1.4 and icon0.size[0] / icon0.size[1] > 0.75:
            if icon0.size != (80,80):
                image = icon0.resize((80, 80), Image.Resampling.HAMMING)
        else:
            if icon0.size != (144,80):
                image = icon0.resize((144, 80), Image.Resampling.HAMMING)
        i = io.BytesIO()
        image.save(i, format='PNG')
        i.seek(0)
        icon0 = i.read()

    # Convert PIC0 to a file object
    if pic0:
        pic0 = pic0.resize((310, 180), Image.Resampling.BILINEAR).convert("RGBA")
        i = io.BytesIO()
        pic0.save(i, format='PNG')
        i.seek(0)
        pic0 = i.read()
    
    # Convert PIC1 to a file object
    if pic1:
        pic1 = pic1.resize((480, 272), Image.Resampling.BILINEAR).convert("RGBA")
        if watermark:
            try:
                pic1 = add_image_text(pic1, game_title, disc_ids[0])
            except:
                True
        i = io.BytesIO()
        pic1.save(i, format='PNG')
        i.seek(0)
        pic1 = i.read()

    # Try /PSP/GAME/ if it exists as this is where a PSP memorystick will
    # store the games. 
    try:
        os.stat(dest + '/PSP/GAME/')
        f = dest + '/PSP/GAME/' + disc_ids[0]
    except:
        f = dest + '/' + disc_ids[0]

    print('Install EBOOT in', f) if verbose else None
    try:
        os.mkdir(f)
    except:
        True

    snd0_data = None
    if snd0:
        # Check if it is already in ATRAC3 format
        with open(snd0, 'rb') as s:
            buf = s.read(36)
            if buf[:4] == b'RIFF':
                riff = parse_riff(snd0)
                if riff['fmt ']['compression_code'] in [624, 65534]:
                    print('SND0 is already in AT3 format. No conversion needed.')
                    s.seek(0)
                    snd0_data = s.read()
                    snd0 = None
    if snd0:
        try:
            temp_files.append(subdir + 'snd0_tmp.wav')
            if os.name == 'posix':
                subprocess.call(['ffmpeg', '-y', '-i', snd0, '-filter:a', 'atempo=1.00', '-ar', '44100', '-ac', '2', subdir + 'snd0_tmp.wav'], stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL)
            else:
                subprocess.call(['ffmpeg.exe', '-y', '-i', snd0, '-filter:a', 'atempo=1.00', '-ar', '44100', '-ac', '2', subdir + 'snd0_tmp.wav'], stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL)
            snd0 = subdir + 'snd0_tmp.wav'
        except:
            snd0 = None
    if snd0:
        if convert_snd0_to_at3(snd0, subdir + '/SND0.AT3', 59, 500000, subdir=subdir):
            with open(subdir + 'SND0.AT3', 'rb') as i:
                snd0_data = i.read()

    dest_file = f + '/EBOOT.PBP'
    whole_disk=False
    if use_cdda:
        aea_files = []
        whole_disk = True
    generate_pbp(dest_file, disc_ids, game_title, icon0, pic0, pic1, cue_files, cu2_files, img_files, aea_files, snd0=snd0_data, whole_disk=whole_disk, subchannels=subchannels, configs=configs, logo=logo)

    if manual:
        print('Installing manual as', f + '/DOCUMENT.DAT')
        copy_file(manual, f + '/DOCUMENT.DAT')

    idx = 0
    for mc in mem_cards:
        mf = f + ('/SCEVMC%d.VMP' % idx)
        with open(mf, 'wb') as of:
            print('Installing MemoryCard in temporary location as', mf)
            of.write(encode_vmp(mc))
        idx = idx + 1 
    if idx > 0:
        print('###################################################')
        print('###################################################')
        print('Memory card images temporarily written to the game directory.')
        print('1, Remove the PSP/VITA')
        print('2, Start the game to create the SAVEDATA directory')
        print('   and then quit the game.')
        print('3, Reconnect the PSP/VITA')
        print('4, Run this command to finish installing the memory cards:')
        print('')
        print('./pop-fe.py --psp-dir=%s --disc_id=%s --psp-install-memory-card' % (dest, disc_ids[0]))
        print('###################################################')
        print('###################################################')
        try:
            os.sync()
        except:
            True


def create_psc(dest, disc_ids, game_title, icon0, pic1, cue_files, cu2_files, img_files, watermark=True):
    print('Create PS Classics/AutoBleem EBOOT.PBP for', game_title) if verbose else None

    # Convert ICON0 to a file object
    image = icon0.resize((80,80), Image.Resampling.BILINEAR)
    i = io.BytesIO()
    image.save(i, format='PNG')
    i.seek(0)
    icon0 = i.read()

    # Convert PIC1 to a file object
    pic1 = pic1.resize((480, 272), Image.Resampling.BILINEAR).convert("RGBA")
    if watermark:
        try:
            pic1 = add_image_text(pic1, game_title, disc_ids[0])
        except:
            True
    i = io.BytesIO()
    pic1.save(i, format='PNG')
    i.seek(0)
    pic1 = i.read()
    
    dest_file = dest + '/Games/' + game_title + '.PBP'
    print('Install EBOOT as', dest_file) if verbose else None
    generate_pbp(dest_file, disc_ids, game_title, icon0, None, pic1, cue_files, cu2_files, img_files, [])

    try:
        os.sync()

    except:
        True

            
def create_ps3(dest, disc_ids, game_title, icon0, pic0, pic1, cue_files, cu2_files, img_files, mem_cards, aea_files, magic_word, resolution, subdir = './', snd0=None, whole_disk=True, subchannels=[], configs=None):
    print('Create PS3 PKG for', game_title) if verbose else None

    SECTLEN = 2352
    p = popstation()
    p.verbose = verbose
    p.disc_ids = disc_ids
    p.game_title = game_title
    p.subchannels = subchannels
    #p.icon0 = icon0
    #p.pic1 = pic1
    if not whole_disk:
        p.striptracks = True
    p.complevel = 0
    p.magic_word = magic_word
    if len(aea_files):
        p.aea = aea_files
    if configs:
        p.configs = configs
    for i in range(len(img_files)):
        f = img_files[i]
        print('Need to create a TOC') if verbose else None
        toc = get_toc_from_cu2(cu2_files[i])
        p.add_img((f, toc))
        
        if not whole_disk:
            bc = bchunk()
            bc.towav = True
            bc.open(cue_files[i])
            # store how big the data track is
            p.add_track0_size(bc.tracks[1]['INDEX'][1]['STOPSECT'] * SECTLEN)

    # create directory structure
    f = subdir + disc_ids[0]
    print('GameID', f)
    try:
        os.mkdir(f)
    except:
        True

    sfo = {
        'ANALOG_MODE': {
            'data_fmt': 1028,
            'data': 1},
        'ATTRIBUTE': {
            'data_fmt': 1028,
            'data': 2},
        'BOOTABLE': {
            'data_fmt': 1028,
            'data': 1},
        'CATEGORY': {
            'data_fmt': 516,
            'data_max_len': 4,
            'data': '1P'},
        'PARENTAL_LEVEL': {
            'data_fmt': 1028,
            'data': 3},
        'PS3_SYSTEM_VER': {
            'data_fmt': 516,
            'data_max_len': 8,
            'data': '01.7000'},
        'RESOLUTION': {
            'data_fmt': 1028,
            'data': resolution},
        'SOUND_FORMAT': {
            'data_fmt': 1028,
            'data': 1},
        'TITLE': {
            'data_fmt': 516,
            'data_max_len': 128,
            'data': game_title},
        'TITLE_ID': {
            'data_fmt': 516,
            'data_max_len': 16,
            'data': disc_ids[0]},
        'VERSION': {
            'data_fmt': 516,
            'data_max_len': 8,
            'data': '01.00'}
        }
    with open(f + '/PARAM.SFO', 'wb') as of:
        of.write(GenerateSFO(sfo))
        temp_files.append(f + '/PARAM.SFO')
    if snd0:
        # Check if it is already in ATRAC3 format
        with open(snd0, 'rb') as s:
            buf = s.read(36)
            if buf[:4] == b'RIFF':
                riff = parse_riff(snd0)
                if riff['fmt ']['compression_code'] in [624, 65534]:
                    print('SND0 is already in AT3 format. No conversion needed.')
                    copy_file(snd0, f + '/SND0.AT3')
                    snd0 = None
    if snd0:
        try:
            temp_files.append(subdir + 'snd0_tmp.wav')
            if os.name == 'posix':
                subprocess.call(['ffmpeg', '-y', '-i', snd0, '-filter:a', 'atempo=1.00', '-ar', '44100', '-ac', '2', subdir + 'snd0_tmp.wav'], stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL)
            else:
                subprocess.call(['ffmpeg.exe', '-y', '-i', snd0, '-filter:a', 'atempo=1.00', '-ar', '44100', '-ac', '2', subdir + 'snd0_tmp.wav'], stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL)
            snd0 = subdir + 'snd0_tmp.wav'
        except:
            snd0 = None
        convert_snd0_to_at3(snd0, f + '/SND0.AT3', 299, 2500000, subdir=subdir)

    image = icon0
    if icon0.size[0] / icon0.size[1] < 1.4 and icon0.size[0] / icon0.size[1] > 0.75:
        if icon0.size != (176, 176):
            icon0 = icon0.resize((176, 176), Image.Resampling.HAMMING)
        image = Image.new(icon0.mode, (320, 176), (0,0,0)).convert('RGBA')
        image.putalpha(0)
        image.paste(icon0, (72,0))
    else:
        if icon0.size != (320, 176):
            image = icon0.resize((320, 176), Image.Resampling.HAMMING)
    image.save(f + '/ICON0.PNG', format='PNG')
    temp_files.append(f + '/ICON0.PNG')

    if pic0:
        # 4:3 == 1.333   16:9 == 1.7777
        aspect = pic0.size[0] / pic0.size[1]
        pp = pic0
        if aspect < 1.555:
            # Looks like pic0 is 4:3. We need to add some transparent
            # columns on each side to turn this into 16:9 aspect ratio
            # which is what PS3 expects for PIC0.PNG
            pp = Image.new(pic0.mode, (int(pic0.size[1] * 1.777), pic0.size[1]), (0,0,0)).convert('RGBA')
            pp.putalpha(0)
            pp.paste(pic0, (int((pic0.size[1] * 1.777 - pic0.size[0]) / 2),0))

        image = pp.resize((1000, 560), Image.Resampling.NEAREST)
        image.save(f + '/PIC0.PNG', format='PNG')
        temp_files.append(f + '/PIC0.PNG')

    if pic1:
        image = pic1.resize((1920, 1080), Image.Resampling.NEAREST)
        image.save(f + '/PIC1.PNG', format='PNG')
        temp_files.append(f + '/PIC1.PNG')
    
    if pic0:
        # 4:3 == 1.333   16:9 == 1.7777
        aspect = pic0.size[0] / pic0.size[1]
        pp = pic0
        if aspect > 1.555:
            # Looks like pic0 is 16:9. We need to add some transparent
            # areas above and below the image to turn this into 4:3 aspect ratio
            # which is what PS3 expects for PIC2.PNG
            pp = Image.new(pic0.mode, (pic0.size[0], int(pic0.size[0] / 1.333)), (0,0,0)).convert('RGBA')
            pp.putalpha(0)
            pp.paste(pic0, (0, int((pic0.size[0] / 1.333 - pic0.size[1]) / 2)))

        image = pp.resize((310, 250), Image.Resampling.NEAREST)
        image.save(f + '/PIC2.PNG', format='PNG')
        temp_files.append(f + '/PIC2.PNG')
    
    with open('PS3LOGO.DAT', 'rb') as i:
        with open(f + '/PS3LOGO.DAT', 'wb') as o:
            o.write(i.read())
            temp_files.append(f + '/PS3LOGO.DAT')

    f = subdir + disc_ids[0] + '/USRDIR'
    try:
        os.mkdir(f)
    except:
        True

    _cfg = bytes([
        0x1c, 0x00, 0x00, 0x00, 0x50, 0x53, 0x31, 0x45,
        0x6d, 0x75, 0x43, 0x6f, 0x6e, 0x66, 0x69, 0x67,
        0x46, 0x69, 0x6c, 0x65, 0x00, 0xe3, 0xb7, 0xeb,
        0x04, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
        0xbb, 0xfa, 0xe2, 0x1b, 0x10, 0x00, 0x00, 0x00,
        0x64, 0x69, 0x73, 0x63, 0x5f, 0x6e, 0x6f, 0x00,
        0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
        0x93, 0xd1, 0x5b, 0xf8
    ])
    with open(f + '/CONFIG', 'wb') as o:
        o.write(_cfg)
        temp_files.append(f + '/CONFIG')

        
    f = subdir + disc_ids[0] + '/USRDIR/CONTENT'
    try:
        os.mkdir(f)
    except:
        True

    p.eboot = subdir + disc_ids[0] + '/USRDIR/CONTENT/EBOOT.PBP'
    p.iso_bin_dat = subdir + disc_ids[0] + '/USRDIR/ISO.BIN.DAT'
    try:
        os.unlink(p.iso_bin_dat)
    except:
        True
    print('Create EBOOT.PBP at', p.eboot)
    p.create_pbp()
    temp_files.append(p.eboot)
    temp_files.append(p.iso_bin_dat)
    try:
        os.sync()
    except:
        True

    # sign the ISO.BIN.DAT
    print('Signing', p.iso_bin_dat)
    if os.name == 'posix':
        subprocess.call(['python3', './sign3.py', p.iso_bin_dat])
    else:
        subprocess.call(['sign3.exe', p.iso_bin_dat])

    #
    # USRDIR/SAVEDATA
    #
    f = subdir + disc_ids[0] + '/USRDIR/SAVEDATA'
    try:
        os.mkdir(f)
    except:
        True
    image = icon0.resize((80,80), Image.Resampling.BILINEAR)
    i = io.BytesIO()
    image.save(f + '/ICON0.PNG', format='PNG')
    temp_files.append(f + '/ICON0.PNG')    

    if len(mem_cards) < 1:
        create_blank_mc(f + '/SCEVMC0.VMP')
    if len(mem_cards) < 2:
        create_blank_mc(f + '/SCEVMC1.VMP')
    idx = 0
    for mc in mem_cards:
        mf = f + ('/SCEVMC%d.VMP' % idx)
        with open(mf, 'wb') as of:
            print('Installing MemoryCard as', mf)
            of.write(encode_vmp(mc))
        idx = idx + 1 
    temp_files.append(f + '/SCEVMC0.VMP')
    temp_files.append(f + '/SCEVMC1.VMP')

    sfo = {
        'CATEGORY': {
            'data_fmt': 516,
            'data_max_len': 4,
            'data': 'MS'},
        'PARENTAL_LEVEL': {
            'data_fmt': 1028,
            'data': 1},
        'SAVEDATA_DETAIL': {
            'data_fmt': 516,
            'data_max_len': 4,
            'data': ''},
        'SAVEDATA_DIRECTORY': {
            'data_fmt': 516,
            'data_max_len': 4,
            'data': disc_ids[0]},
        'SAVEDATA_FILE_LIST': {
            'data_fmt': 4,
            'data_max_len': 3168,
            'data': str(bytes(3168))},
        'SAVEDATA_TITLE': {
            'data_fmt': 516,
            'data_max_len': 128,
            'data': ''},
        'TITLE': {
            'data_fmt': 516,
            'data_max_len': 128,
            'data': game_title},
        'SAVEDATA_PARAMS': {
            'data_fmt': 4,
            'data_max_len': 128,
            'data': str(b"A\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xda\xdaC4\x1br\xc2\xede\xa1/k'D\xc6\x11(\xcf\xc8\xb7(\xb8tG+*f\x85L\nm\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x8a\xfa,\xa1\xe7+mA\xc5m.\x9a\xba\xbct\xb0")}
    }
    with open(f + '/PARAM.SFO', 'wb') as of:
        of.write(GenerateSFO(sfo))
        temp_files.append(f + '/PARAM.SFO')

    #
    # Create ISO.BIN.EDAT
    #
    print('Create ISO.BIN.EDAT')
    pack(subdir + '%s/USRDIR/ISO.BIN.DAT' % disc_ids[0],
         subdir + '%s/USRDIR/ISO.BIN.EDAT' % disc_ids[0],
         'UP9000-%s_00-0000000000000001' % disc_ids[0])
    temp_files.append(subdir + '%s/USRDIR/ISO.BIN.EDAT' % disc_ids[0])

    #
    # Create PS3 PKG
    #
    print('Create PKG')
    if os.name == 'posix':
        subprocess.call(['python3','PSL1GHT/tools/ps3py/pkg.py','-c', 'UP9000-%s_00-0000000000000001' % disc_ids[0],subdir + disc_ids[0], dest])
    else:
        subprocess.call(['pkg.exe','-c', 'UP9000-%s_00-0000000000000001' % disc_ids[0],subdir + disc_ids[0], dest])
    temp_files.append(subdir + disc_ids[0] + '/USRDIR/CONTENT')
    temp_files.append(subdir + disc_ids[0] + '/USRDIR/SAVEDATA')
    temp_files.append(subdir + disc_ids[0] + '/USRDIR')
    temp_files.append(subdir + disc_ids[0])
    print('Finished.', dest, 'created')
    for f in temp_files:
        print('Deleting temp file', f) if verbose else None
        try:
            os.unlink(f)
        except:
            try:
                os.rmdir(f)
            except:
                True

    
def install_psp_mc(dest, game_id, mem_cards):
    if mem_cards and len(mem_cards) >= 1:
        try:
            with open(dest + '/PSP/SAVEDATA/' + game_id + '/SCEVMC0.VMP', 'wb') as f:
                f.write(encode_vmp(mem_cards[0]))
                print('Installed', dest + '/PSP/SAVEDATA/' + game_id + '/SCEVMC0.VMP')
        except:
            raise Exception('Can not install memory card file.', dest + '/PSP/SAVEDATA/' + game_id, 'does not exist')
    if mem_cards and len(mem_cards) >= 2:
        try:
            with open(dest + '/PSP/SAVEDATA/' + game_id + '/SCEVMC1.VMP', 'wb') as f:
                f.write(encode_vmp(mem_cards[1]))
                print('Installed', dest + '/PSP/SAVEDATA/' + game_id + '/SCEVMC1.VMP')
        except:
            raise Exception('Can not install memory card file.', dest + '/PSP/SAVEDATA/' + game_id, 'does not exist')
            
    try:
        os.stat(dest + '/PSP/GAME/' + game_id + '/SCEVMC0.VMP')
        try:
            copy_file(dest + '/PSP/GAME/' + game_id + '/SCEVMC0.VMP',
                      dest + '/PSP/SAVEDATA/' + game_id + '/SCEVMC0.VMP')
            print('Installed', dest + '/PSP/SAVEDATA/' + game_id + '/SCEVMC0.VMP')
            os.unlink(dest + '/PSP/GAME/' + game_id + '/SCEVMC0.VMP')
        except:
            print('Could not install /PSP/SAVEDATA/' + game_id + '/SCEVMC0.VMP')
    except:
        True
        
    try:
        os.stat(dest + '/PSP/GAME/' + game_id + '/SCEVMC1.VMP')
        try:
            copy_file(dest + '/PSP/GAME/' + game_id + '/SCEVMC1.VMP',
                      dest + '/PSP/SAVEDATA/' + game_id + '/SCEVMC1.VMP')
            print('Installed', dest + '/PSP/SAVEDATA/' + game_id + '/SCEVMC1.VMP')
            os.unlink(dest + '/PSP/GAME/' + game_id + '/SCEVMC1.VMP')
        except:
            print('Could not install /PSP/SAVEDATA/' + game_id + '/SCEVMC1.VMP')
    except:
        True
    try:
        os.sync()
    except:
        True

def check_memory_card(f):
    if os.stat(f).st_size == 131072:
        with open(f, 'rb') as mc:
            return [mc.read(131072)]
    if os.stat(f).st_size == 131200:
        with open(f, 'rb') as mc:
            mc.seek(0x80)
            return [mc.read(131072)]
    if os.stat(f).st_size == 131136:
        with open(f, 'rb') as mc:
            mc.seek(0x40)
            return [mc.read(131072)]
    if os.stat(f).st_size == 262144:
        with open(f, 'rb') as mc:
            return [mc.read(131072), mc.read(131072)]
    if os.stat(f).st_size == 134976:
        with open(f, 'rb') as mc:
            mc.seek(0xf40)
            return [mc.read(131072)]
    

def find_psp_mount():
    candidates = ['/d', '/e', '/f', '/g']
    if os.name == 'posix':
        with open('/proc/self/mounts', 'r') as f:
            lines = f.readlines()
            for line in lines:
                strings = line.split(' ')
                if strings[1][:11] == '/run/media/' or strings[1][:7] == '/media/':
                    candidates.append(strings[1])
    for c in candidates:
        try:
            os.stat(c + '/PSP/GAME')
            return c
        except:
            True
        try:
            os.stat(c + '/pspemu/PSP/GAME')
            return c + '/pspemu'
        except:
            True
    raise Exception('Could not find any PSP or VITA memory cards')


def find_psc_mount():
    candidates = ['/d', '/e', '/f', '/g']
    if os.name == 'posix':
        with open('/proc/self/mounts', 'r') as f:
            lines = f.readlines()
            for line in lines:
                strings = line.split(' ')
                if strings[1][:11] == '/run/media/' or strings[1][:7] == '/media/':
                    candidates.append(strings[1])
    for c in candidates:
        try:
            os.stat(c + '/Games')
            return c
        except:
            True
    raise Exception('Could not find any PS Classic/AutoBleem devices')


def create_blank_mc(mc):
    with open(mc, "wb") as f:
        f.seek(131071)
        f.write(bytes(1))
        f.seek(0)
        
        buf = bytearray(2)
        buf[0] = 0x4d
        buf[1] = 0x43
        f.write(buf)

        buf = bytearray([0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
                         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0e,
                         0xa0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
                         0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00])
        f.seek(0x70)
        f.write(buf)

        buf = bytearray([0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
                         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xa0,
                         0xa0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
                         0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00])
        for i in range(0xf0, 0x780, 0x80):
            f.seek(i)
            f.write(buf)

        buf = bytearray([0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
                         0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xa0,
                         0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00,
                         0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00])
        f.seek(0x7f0)
        f.write(buf)

        buf = bytearray([0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00,
                         0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00])
        for i in range(0x880, 0x1190, 0x80):
            f.seek(i)
            f.write(buf)

            
def create_ps2(dest, disc_ids, game_title, icon0, pic1, cue_files, cu2_files, img_files):
    print('Create PS2 VCD for', game_title) if verbose else None
    print('Install VCD in', dest + '/POPS')

    try:
        os.stat(dest + '/POPS')
    except:
        raise Exception('No POPS directory found')
    try:
        os.stat(dest + '/ART')
    except:
        raise Exception('No ART directory found')
        
    p = popstation()
    p.verbose = verbose
    p.disc_ids = disc_ids
    p.game_title = game_title

    discs_txt = None
    vmcdir_txt = None
    game_id = disc_ids[0]
    if len(img_files) > 1:
        for i in range(4):
            pp = game_id[:4] + '_' + game_id[4:7] + '.' + game_id[7:9] + '.' + game_title
            pp = pp + '_CD%d.VCD\n' % (i + 1)
            if not vmcdir_txt:
                vmcdir_txt = pp[:-5] + '\n'
            if i >= len(img_files):
                pp = '\n'
            if not discs_txt:
                discs_txt = pp
            else:
                discs_txt = discs_txt + pp

    for i in range(len(img_files)):
        f = img_files[i]
        print('Need to create a TOC') if verbose else None
        toc = get_toc_from_cu2(cu2_files[i])

        print('Add image', f) if verbose else None
        p.add_img((f, toc))

        print('GameID', game_id, game_title) if verbose else None
        pp = dest + '/POPS/' + game_id[:4] + '_' + game_id[4:7] + '.' + game_id[7:9] + '.' + game_title
        if len(img_files) > 1:
            pp = pp + '_CD%d' % (i + 1)
        try:
            os.mkdir(pp)
        except:
            True
        p.vcd = pp + '.VCD'
        print('Create VCD at', p.vcd) if verbose else None
        p.create_vcd()
        try:
            os.sync()
        except:
            True

        if discs_txt:
            with open(pp + '/DISCS.TXT', 'w') as f:
                f.write(discs_txt)
        if vmcdir_txt:
            with open(pp + '/VMCDIR.TXT', 'w') as f:
                f.write(vmcdir_txt)


        if i == 0:
            create_blank_mc(pp + '/SLOT0.VMC')
            create_blank_mc(pp + '/SLOT1.VMC')
            
    pp = dest + '/ART/'
    f = pp + game_id[0:4] + '_' + game_id[4:7] + '.' + game_id[7:9] + '_COV.jpg'
    image = icon0.resize((200, 200))
    image = image.convert('RGB')
    image.save(f, format='JPEG', quality=100, subsampling=0)
    f = pp + game_id[0:4] + '_' + game_id[4:7] + '.' + game_id[7:9] + '_BG.jpg'
    image = pic1.resize((640, 480))
    image = image.convert('RGB')
    image.save(f, format='JPEG', quality=100, subsampling=0)


def get_disc_ids(cue_files, subdir='./'):
    disc_ids = []
    for idx in range(len(cue_files)):
        try:
            with open(create_path(cue_files[idx], 'GAME_ID'), 'r') as d:
                disc_ids.append(d.read())
                print('Read disc id from', create_path(cue_files[idx], 'GAME_ID'))
                continue
        except:
            True
        print('Convert CUE to a normal style ISO to read the disc id', cue_files[idx]) if verbose else None
        bc = bchunk()
        bc.verbose = args.v
        bc.open(cue_files[idx])
        fn = subdir + 'ISO%02x01.iso' % idx
        bc.writetrack(1, fn)
        temp_files.append(fn)
        gid = get_gameid_from_iso(fn)
        disc_ids.append(gid)

    return disc_ids


def apply_ppf(img, disc_id, magic_word, auto_libcrypt):
    if auto_libcrypt:
        # https://red-j.github.io/Libcrypt-PS1-Protection-bible/index.htm
        print('Try to automatically generate libcrypt patch for', img)
        with open(img, 'rb+') as f:
            while True:
                off = f.tell()
                buf = bytearray(f.read(0x9300))
                if not buf:
                    break
                pos = buf.find(bytes([0x25, 0x30, 0x86, 0x00]))
                if pos > 0:
                    print('Found libcrypt signature. Patching it')
                    struct.pack_into('<H', buf, pos, magic_word)
                    struct.pack_into('<H', buf, pos + 2, 0x34c6)
                    f.seek(off)
                    f.write(buf)
        return
    if 'credit' in libcrypt[disc_id]:
        print(libcrypt[disc_id]['credit'])
    if 'ppf' in libcrypt[disc_id]:
        print('Patching ', disc_id, 'to remove libcrypt')
        ApplyPPF(img, libcrypt[disc_id]['ppf'])
        return
    if not 'ppfzip' in libcrypt[disc_id]:
        print('##################################')
        print('WARNING! No PPF found for', disc_id, 'the game might not work unless you have already patched the image file')
        print('##################################')
        return
    print('Fetching PPF for', disc_id)  if verbose else None
    ret = requests.get(libcrypt[disc_id]['ppfzip'][0])
    if ret.status_code != 200:
        print('##################################')
        print('WARNING! PPF to remove libcrypt was not found for %s. Game might not work.')
        print('##################################')
        return

    z = zipfile.ZipFile(io.BytesIO(ret.content))
    print('Extracting PPF ', libcrypt[disc_id]['ppfzip'][1]) if verbose else None
    z.extract(libcrypt[disc_id]['ppfzip'][1])
    temp_files.append(libcrypt[disc_id]['ppfzip'][1])

    print('Patching ', disc_id, 'to remove libcrypt')
    ApplyPPF(img, libcrypt[disc_id]['ppfzip'][1])

def install_deps():
    print(os.name)
    # PyPDF2
    try:
        import PyPDF2
        print('PyPDF2 is already installed')
    except:
        print('Installing python PyPDF2')
        subprocess.call(['pip', 'install', 'PyPDF2'])
    # requests
    try:
        import requests
        print('requests is already installed')
    except:
        print('Installing python requests')
        subprocess.call(['pip', 'install', 'requests'])
        import requests
    # pycdlib
    try:
        import pycdlib
        print('pycdlib is already installed')
    except:
        print('Installing python pycdlib.  This will fail on some platforms')
        subprocess.call(['pip', 'install', 'pycdlib'])
    # iso9660
    try:
        import iso9660
        print('iso9660 is already installed')
    except:
        print('Installing python iso9660.  This will fail on some platforms')
        subprocess.call(['pip', 'install', 'iso9660'])
    # rarfile
    try:
        import rarfile
        print('rarfile is already installed')
    except:
        print('Installing python rarfile.  This will fail on some platforms')
        subprocess.call(['pip', 'install', 'rarfile'])
    # ecdsa
    try:
        import ecdsa
        print('ecdsa is already installed')
    except:
        print('Installing python ecdsa')
        subprocess.call(['pip', 'install', 'ecdsa'])
    # PIL / pillow
    try:
        import pillow
        print('pillow is already installed')
    except:
        print('Installing python pillow')
        subprocess.call(['pip', 'install', 'pillow']) 
    # tkinterdnd2
    try:
        import tkinterdnd2
        print('tkinterdnd2 is already installed')
    except:
        print('Installing python tkinterdnd2')
        subprocess.call(['pip', 'install', 'tkinterdnd2']) 
    # pycryptodome
    try:
        import Cryptodome
        print('Crypto/pycryptodome is already installed')
    except:
        print('Trying to install python pycryptodome(Crypto)')
        subprocess.call(['pip', 'install', 'pycryptodome'])
    # Crypto
    try:
        import Crypto
        print('Crypto is already installed')
    except:
        print('Installing python Crypto')
        subprocess.call(['pip', 'install', 'Crypto'])
    # pytube
    try:
        from pytube import YouTube
        print('Pytube is already installed')
    except:
        print('Installing python pytube')
        subprocess.call(['pip', 'install', 'git+https://github.com/nficano/pytube'])
    # opencv-contrib-python
    try:
        import cv2
        print('opencv is already installed')
    except:
        print('Installing python opencv')
        subprocess.call(['pip', 'install', 'opencv-contrib-python'])
    # opencv-contrib-python
    try:
        import scipy
        print('scipy is already installed')
    except:
        print('Installing python scipy scikit-learn')
        subprocess.call(['pip', 'install', 'scipy', 'scikit-learn'])
    # cue2cu2
    try:
        if os.name == 'posix':
            os.stat('cue2cu2.py')
            print('cue2cu2.py is already installed')
        else:
            os.stat('cue2cu2.exe')
            print('cue2cu2.py is already installed')
    except:
        print('Downloading cue2cu2.py')
        ret = requests.get('https://raw.githubusercontent.com/NRGDEAD/Cue2cu2/master/cue2cu2.py')
        if ret.status_code != 200:
            print('Failed to download cue2cu2. Aborting install.')
            exit(1)
        if os.name == 'posix':
            with open('cue2cu2.py', 'wb') as f:
                f.write(bytes(ret.content.decode(ret.apparent_encoding), encoding='utf-8'))
        else:
            with open('cue2cu2.exe', 'wb') as f:
                f.write(bytes(ret.content.decode(ret.apparent_encoding), encoding='utf-8'))
    # binmerge
    try:
        os.stat('binmerge')
        print('binmerge is already installed')
    except:
        print('Downloading binmerge')
        ret = requests.get('https://raw.githubusercontent.com/putnam/binmerge/master/binmerge')
        if ret.status_code != 200:
            print('Failed to download binmerge. Aborting install.')
            exit(1)
        with open('binmerge', 'wb') as f:
            f.write(bytes(ret.content.decode(ret.apparent_encoding), encoding='utf-8'))
    if os.name == 'posix':
        # atracdenc
        try:
            os.stat('atracdenc/src/atracdenc')
            print('atracdenc is already installed')
        except:
            print('Cloning atracdenc')
            subprocess.call(['git', 'clone', 'https://github.com/dcherednik/atracdenc.git'])
            os.chdir('atracdenc/src')
            subprocess.call(['cmake', '.'])
            subprocess.call(['make'])
            os.chdir('../..')
        # PSL1GHT
        try:
            os.stat('PSL1GHT')
            print('PSL1GHT is already installed')
        except:
            print('Cloning PSL1GHT')
            subprocess.call(['git', 'clone', 'http://github.com/sahlberg/PSL1GHT'])
            os.chdir('PSL1GHT/tools/ps3py')
            subprocess.call(['git', 'checkout', 'origin/use-python3'])
            subprocess.call(['make'])
            os.chdir('../../..')
            
def generate_subchannels(magic_word):
    def generate_subchannel(sector, is_corrupt):
        def bcd(i):
            return int(i % 10) + 16 * (int(i / 10) % 10)

        sc = bytearray(12)
        s = sector - 150
        struct.pack_into('<I', sc, 0, s)
        struct.pack_into('<B', sc, 4, 1)
        struct.pack_into('<B', sc, 5, 1)
        if is_corrupt:
            s = s - 1
        struct.pack_into('<B', sc, 8, bcd(s % 75))
        s = s - (s % 75)
        s = int(s / 75)
        struct.pack_into('<B', sc, 7, bcd(s % 60))
        struct.pack_into('<B', sc, 6, bcd(int(s / 60)))

        s = sector
        if is_corrupt:
            s = s - 1
        struct.pack_into('<B', sc, 11, bcd(s % 75))
        s = s - (s % 75)
        s = int(s / 75)
        struct.pack_into('<B', sc, 10, bcd(s % 60))
        struct.pack_into('<B', sc, 9, bcd(int(s / 60)))

        return sc

    sector_pairs = {
        15: [14105,14110],
        14: [14231,14236],
        13: [14485,14490],
        12: [14579,14584],
        11: [14649,14654],
        10: [14899,14904],
         9: [15056,15061],
         8: [15130,15135],
         7: [15242,15247],
         6: [15312,15317],
         5: [15378,15383],
         4: [15628,15633],
         3: [15919,15924],
         2: [16031,16036],
         1: [16101,16106],
         0: [16167,16172]
        }
    scd = bytes(0)
    scd = scd + bytes([0xff,0xff,0xff,0xff,0x00,0x00,0x00,0x00,0xff,0xff,0xff,0xff])
    for i in range(15, -1, -1):
        scd = scd + generate_subchannel(sector_pairs[i][0], magic_word & (1<<i))
        scd = scd + generate_subchannel(sector_pairs[i][1], magic_word & (1<<i))
    scd = scd + bytes([0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff])

    return scd

def create_sbi(sbi, magic_word):
    def generate_sbi(sector):
        def bcd(i):
            return int(i % 10) + 16 * (int(i / 10) % 10)

        sc = bytearray(4)
        s = sector
        struct.pack_into('<B', sc, 2, bcd(s % 75))
        s = s - (s % 75)
        s = int(s / 75)
        struct.pack_into('<B', sc, 1, bcd(s % 60))
        struct.pack_into('<B', sc, 0, bcd(int(s / 60)))
        struct.pack_into('<B', sc, 3, 1)

        sc = sc + bytes([0xff, 0xff, 0xff, 0xff,
                         0xff, 0xff, 0xff, 0xff,
                         0xff, 0xff])
        return sc

    sector_pairs = {
        15: [14105,14110],
        14: [14231,14236],
        13: [14485,14490],
        12: [14579,14584],
        11: [14649,14654],
        10: [14899,14904],
         9: [15056,15061],
         8: [15130,15135],
         7: [15242,15247],
         6: [15312,15317],
         5: [15378,15383],
         4: [15628,15633],
         3: [15919,15924],
         2: [16031,16036],
         1: [16101,16106],
         0: [16167,16172]
        }
    with open(sbi, 'wb') as f:
        f.write(bytes([0x53, 0x42, 0x49, 0x00]))
        for i in range(15, -1, -1):
            if magic_word & (1<<i):
                f.write(generate_sbi(sector_pairs[i][0]))
                f.write(generate_sbi(sector_pairs[i][1]))

# Convert scans of the manual into a DOCUMENT.DAT for PSP
# XXX add support for pdf manuals
# https://www.gamesdatabase.org/Media/SYSTEM/Sony_Playstation//Manual/formated/Air_Combat_-_1995_-_Namco_Limited.pdf
def create_manual(source, gameid, subdir='./pop-fe-work/'):

    if gameid in games and 'manual' in games[gameid]:
        _h = hashlib.md5(games[gameid]['manual'].encode('utf-8')).hexdigest()
        f = 'https://github.com/sahlberg/pop-fe-assets/raw/master/manual/' + _h + '.DAT'
        try:
            ret = requests.get(f, stream=True)
        except:
            return None
        if ret.status_code == 200:
            print('Found cached prebuilt manual', f)
            _d = subdir + 'DOC.DAT'
            with open(_d, 'wb') as o:
                o.write(ret.content)
            temp_files.append(_d)
            return _d

    # already have a manual in the proper format
    if source[-7:] == '.manual':
        return source
    
    print('Create manual', source)
    files = []

    if source[:8] != 'https://':
        with open(source, 'rb') as f:
            buf = f.read(4)
            signature = struct.unpack_from('<I', buf, 0)[0]
            if signature == 0x20434F44: # a PSP DOCUMENT.DAT file?
                return source
            if signature == 0x04034b50: # a ZIP file?
                print('Is a zip file')
                tmpfile = subdir + '/DOCUMENT.zip'
                temp_files.append(tmpfile)
                copy_file(source, tmpfile)
                source = tmpfile

    print('Create DOCUMENT.DAT from', source)
    if source[:8] == 'https://':
        print('Download manual from', source)
        try:
            tmpfile = subdir + '/DOCUMENT-' + source.split('/')[-1]
            temp_files.append(tmpfile)
            subprocess.run(['wget', source, '-O', tmpfile], timeout=240, check=True)
            print('Downloaded manual as', tmpfile)
            source = tmpfile
        except:
            print('Failed to download manual from', source)
            return None
    if source[-4:] == '.zip':
        print('Unzip manual', source, 'from ZIP')
        subdir = subdir + '/DOCUMENT-tmp'
        os.mkdir(subdir)
        temp_files.append(subdir)
                
        z = zipfile.ZipFile(source)
        for f in z.namelist():
            f = z.extract(f, path=subdir)
            temp_files.append(f)
            files.append(f)
            source = subdir
    if source[-4:] == '.cbr':
        print('Unzip manual', source, 'from CBR')
        subdir = subdir + '/DOCUMENT-tmp'
        os.mkdir(subdir)
        temp_files.append(subdir)

        try:
            r = rarfile.RarFile(source)
            for f in r.namelist():
                f = r.extract(f, path=subdir)
                temp_files.append(f)
                files.append(f)
            source = subdir
        except:
            print('Failed to create SOFTWARE MANUAL. Could not extract images from CBR file. Make sure that UNRAR is installed.')
            return None

    if source[-4:] == '.pdf':
        print('Extract manual', source, 'from PDF')
        subdir = subdir + '/DOCUMENT-tmp'
        os.mkdir(subdir)
        temp_files.append(subdir)
        try:
            idx = 0
            r = PyPDF2.PdfReader(source)
            for p in r.pages:
                for i in p.images:
                    f = subdir + '/' + f"{idx:04d}" + '.img'
                    with open(f, "wb") as fp:
                        fp.write(i.data)                   
                    idx = idx + 1
                    temp_files.append(f)
                    files.append(f)
            source = subdir
        except:
            print('Failed to parse PDF.')
            return None
            
    if not os.path.isdir(source):
        print('Can not create manual.', source, 'is not a directory')
        return None

    tmpfile = subdir + '/DOCUMENT.DAT'
    temp_files.append(tmpfile)
    tmpfile = create_document(files, gameid, 480, tmpfile)
    if not tmpfile:
        print('Failed to create DOCUMENT.DAT')
    return tmpfile


#
# Apply all PPF fixes that may be needed
#
def apply_ppf_fixes(real_disc_ids, cue_files, img_files, subdir, tag=None):
    for i in range(len(real_disc_ids)):
        ppf = None
        disc_id = real_disc_ids[i]
        if disc_id not in ppf_fixes:
            continue
        if 'tags' in ppf_fixes[disc_id]:
            if not tag:
                continue
            if tag not in ppf_fixes[disc_id]['tags']:
                continue
        if 'ppf' in ppf_fixes[disc_id]:
            ppf = ppf_fixes[disc_id]['ppf']
        if 'hashes' in ppf_fixes[disc_id]:
            with open(img_files[i], 'rb') as f:
                h = hashlib.md5(f.read(1024*1024)).hexdigest()
                if h in ppf_fixes[disc_id]['hashes']:
                    ppf = ppf_fixes[disc_id]['hashes'][h]['ppf']
        if not ppf:
            continue
        print('Found PPF:', ppf_fixes[disc_id]['desc'], ppf)
        if subdir != cue_files[i][:len(subdir)]:
            # Need to copy the bin/cue to the work directory.
            # We know this is a single bin at this point as if it would have
            # been merged into the work directory otherwise
            _c = subdir + 'PPF%02x.cue' % i
            _b = subdir + 'PPF%02x.bin' % i
            print('Copy %s -> %s so we can apply PPF' % (img_files[i], _b))
            copy_file(img_files[i], _b) 
            temp_files.append(_b)
            with open(cue_files[i], 'r') as fi:
                l = fi.readlines()
                l[0] = 'FILE "%s" BINARY\n' % ('PPF%02x.bin' % i)
                with open(_c, 'w') as fo:
                    fo.writelines(l)
                    temp_files.append(_c)
            cue_files[i] = _c
            img_files[i] = _b

        print('Applying', ppf)
        ApplyPPF(img_files[i], ppf)
            
    return cue_files, img_files


def ApplyXDELTA(img, romhack):
    print('Applying XDELTA', romhack)
    _tmp = img + 'tmp'
    try:
        subprocess.run(['xdelta3', 'decode', '-s', img, romhack, _tmp], timeout=30, check=True)
    except:
        print('Could not apply xdelta3 patch. Is xdelta3 installed?')
        return
    os.remove(img)
    os.rename(_tmp, img)

#
# Apply all romhacks
#
def apply_romhacks(real_disc_ids, cue_files, img_files, romhacks, subdir):
    for i in range(len(real_disc_ids)):
        if romhacks[i] == 'none':
            continue
        if subdir != cue_files[i][:len(subdir)]:
            # Need to copy the bin/cue to the work directory.
            # We know this is a single bin at this point as if it would have
            # been merged into the work directory otherwise
            _c = subdir + 'PATCH%02x.cue' % i
            _b = subdir + 'PATCH%02x.bin' % i
            print('Copy %s -> %s so we can apply ROMHACK' % (img_files[i], _b))
            copy_file(img_files[i], _b) 
            temp_files.append(_b)
            with open(cue_files[i], 'r') as fi:
                l = fi.readlines()
                l[0] = 'FILE "%s" BINARY\n' % ('PATCH%02x.bin' % i)
                with open(_c, 'w') as fo:
                    fo.writelines(l)
                    temp_files.append(_c)
            cue_files[i] = _c
            img_files[i] = _b

        if romhacks[i][-4:] == '.ppf':
            ApplyPPF(img_files[i], romhacks[i])
        if romhacks[i][-7:] == '.xdelta':
            ApplyXDELTA(img_files[i], romhacks[i])
    return cue_files, img_files

def generate_cu2_files(cue_files, img_files, subdir):
    cu2_files = []

    for i in range(len(cue_files)):
        cue_file = cue_files[i]
        img_file = img_files[i]
        cu2_file = cue_file[:-4] + '.cu2'
        try:
            os.stat(cu2_file).st_size
            print('Using existing CU2 file: %s' % cu2_file) if verbose else None
        except:
            cu2_file = subdir + 'TMP%d.cu2' % (i)
            print('Creating temporary CU2 file: %s' % cu2_file) if verbose else None
            if os.name == 'posix':
                subprocess.call(['python3', './cue2cu2.py', '-n', cu2_file, '--size', str(os.stat(img_file).st_size), cue_file])
            else:
                subprocess.call(['cue2cu2.exe', '-n', cu2_file, '--size', str(os.stat(img_file).st_size), cue_file])
            temp_files.append(cu2_file)
        cu2_files.append(cu2_file)
    
    return cu2_files

def generate_aea_files(cue_files, img_files, subdir):
    aea_files = []

    extra_data_track_found = False
    for d in range(len(cue_files)):
        cue_file = cue_files[d]
        img_file = img_files[d]
        aea_files.append([])
        
        bc = bchunk()
        bc.towav = True
        bc.open(cue_file)
        for i in range(2, len(bc.cue) + 1):
            if extra_data_track_found:
                continue
            if bc.tracks[i]['MODE'] != 'AUDIO':
                aea_files[d] = []
                extra_data_track_found = True
                continue
            f = subdir + 'TRACK_%d_%02d.wav' % (d, i)
            bc.writetrack(i, f)
            temp_files.append(f)
            aea_file = f[:-3] + 'aea'
            temp_files.append(aea_file)
            print('Converting', f, 'to', aea_file)
            try:
                if os.name == 'posix':
                    subprocess.run(['./atracdenc/src/atracdenc', '--encode=atrac3', '-i', f, '-o', aea_file], check=True, stdout=subprocess.DEVNULL)
                else:
                    subprocess.run(['atracdenc/src/atracdenc', '--encode=atrac3', '-i', f, '-o', aea_file], check=True, stdout=subprocess.DEVNULL)
            except:
                print('XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX\natracdenc not found.\nCan not convert CDDA tracks.\nCreating EBOOT.PBP without support for CDDA audio.\nPlease see README file for how to install atracdenc\nXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX')
                break
            aea_files[d].append(aea_file)    

    return aea_files, extra_data_track_found


#
# This one is special since the same command may be used for other things
# so we need to merge the argument if teh command is already there
#
def force_ntsc_config(ps3config):
    c = bytearray(ps3config)
    merged = False
    for i in range(0, len(c), 8):
        if c[i] == 0x20:
            c[i + 4] = c[i + 4] | 0x40
            merged = True
    if not merged:
        c = c + bytes([0x20, 0x00, 0x00, 0x00, 0x40,  0x00, 0x00, 0x00])
    return c


# ICON0 is the game cover
# PIC0 is logo
# PIC1 is background image/poster
#
if __name__ == "__main__":
    parser = argparse.ArgumentParser()
    parser.add_argument('-v', action='store_true', help='Verbose')
    parser.add_argument('--retroarch-thumbnail-dir',
                    help='Where to store retroarch thumbnails')
    parser.add_argument('--retroarch-bin-dir',
                    help='Where to store retroarch games as (m3u/img)')
    parser.add_argument('--retroarch-cue-dir',
                    help='Where to store retroarch games as (m3u/cue)')
    parser.add_argument('--retroarch-pbp-dir',
                    help='Where to store retroarch games as (pbp)')
    parser.add_argument('--psio-dir',
                    help='Where to store images for PSIO')
    parser.add_argument('--psp-dir',
                    help='Where the PSP memory card is mounted')
    parser.add_argument('--psp-install-memory-card', action='store_true',
                        help='Finish installing a PSX memory card after '
                        'running the game at least once')
    parser.add_argument('--psp-use-cdda', action='store_true', help='Use CDDA instead of ATRAC3 for audio tracks on PSP')
    parser.add_argument('--ps2-dir',
                    help='Where the PS2 USB-stick is mounted')
    parser.add_argument('--ps3-pkg',
                    help='Name of the PS3 pckage to create')
    parser.add_argument('--psc-dir',
                    help='Where the PS Classic/AutoBleem memory card is mounted')
    parser.add_argument('--fetch-metadata', action='store_true',
                    help='Just fetch metadata for the game')
    parser.add_argument('--game_id',
                        help='Force game_id for this iso.')
    parser.add_argument('--manual',
                        help='Directory/Zip/HTTP-link containing images for themanual')
    parser.add_argument('--force-no-assets', action='store_true',
                        help='Do not download any assets for this')
    parser.add_argument('--title',
                    help='Force title for this iso')
    parser.add_argument('--ps3-libcrypt', action='store_true', help='Apply libcrypt patches also for PS3 Packages')
    parser.add_argument('--auto-libcrypt', action='store_true', help='Apply automatically generated libcrypt patches')
    parser.add_argument('--resolution',
                        help='Force setting resolution to 1: NTSC 2: PAL')
    parser.add_argument('--install', action='store_true', help='Install/Build all required dependencies')
    parser.add_argument('--whole-disk', action='store_true', help='Encode the entire disk and not just the first track. (Only applies to PS3)')
    parser.add_argument('--snd0',
                        help='WAV file to inject in PS3 PKG')
    parser.add_argument('--cover',
                        help='Cover image to use')
    parser.add_argument('--pic0',
                        help='PIC0/screenshot image to use')
    parser.add_argument('--pic1',
                        help='PIC1/screenshot image to use')
    parser.add_argument('--logo',
                        help='Boot/logo image to use')
    parser.add_argument('--watermark', action='store_true',
                    help='Add a disc-id/game-title watermark for PSP/PSC')
    parser.add_argument('--list-themes', action='store_true',
                    help='List available themes')
    parser.add_argument('--theme',
                        help='Theme to use')
    parser.add_argument('--romhacks', help='Romhacks to apply')
    parser.add_argument('--ps1-newemu', action='store_true',
                    help='Use the ps1_newemu emulator (only valid for PS3 PKG')
    parser.add_argument('files', nargs='*')
    args = parser.parse_args()

    if args.v:
        verbose = True

    if args.list_themes:
        for theme in themes:
            print(theme, ':', themes[theme]['description'], 'AUTO' if 'url' not in themes[theme] else themes[theme]['url'])
        exit(0)

    if args.theme:
        if args.theme[:4] == 'http':
            themes['http'] = {'url': args.theme,
                              'description': 'direct link to theme'}
            args.theme = 'http'
        if args.theme not in themes:
            print('No such theme:', args.theme)
            exit(1)

    if args.install:
        print('Install/Update required dependencies')
        install_deps()
        exit(0)

    ps3configs = None
    pspconfigs = None
    
    if args.psp_dir and args.psp_dir.upper() == 'AUTO':
        args.psp_dir = find_psp_mount()

    if args.psc_dir and args.psc_dir.upper() == 'AUTO':
        args.psc_dir = find_psc_mount()

    if not args.files and not args.psp_install_memory_card:
        print('You must specify at least one file to fetch images for')
        exit(1)

    subdir = 'pop-fe-work/'
    shutil.rmtree(subdir, ignore_errors=True)
    os.mkdir(subdir)
        
    try:
        if os.name == 'posix':
            os.stat('./cue2cu2.py')
        else:
            os.stat('cue2cu2.exe')
    except:
        raise Exception('PSIO prefers CU2 files but cue2cu2.pu is not installed. See README file for instructions on how to install cue2cu2.')

    try:
        os.unlink('NORMAL01.iso')
    except:
        True

    idx = None
    cue_files = []
    real_cue_files = []
    img_files = []
    mem_cards = []

    if len(args.files) > 1:
        idx = (1, len(args.files))
    for cue_file in args.files:
        if args.ps3_pkg:
            if not ps3configs:
                ps3configs = []
            ps3configs.append(bytes())
        if args.psp_dir:
            if not pspconfigs:
                pspconfigs = []
            pspconfigs.append(bytes())

        real_cue_file = cue_file
        real_cue_files.append(real_cue_file)
        # Try to find which ones are memory cards
        if os.stat(cue_file).st_size <= 262144:
            mc = check_memory_card(cue_file)
            if mc:
                for i in mc:
                    mem_cards.append(i)
                continue
        
        zip = None
        print('Processing', cue_file, '...')

        if cue_file[-4:] == '.chd':
            print('This is a CHD file. Uncompress the file.') if verbose else None
            chd = cue_file
            try:
                tmpcue = subdir + 'CDH%d.cue' % (0 if not idx else idx[0])
                tmpbin = subdir + 'CDH%d.bin' % (0 if not idx else idx[0])
                temp_files.append(tmpcue)
                temp_files.append(tmpbin)
                print('Extracting', tmpcue, 'and', tmpbin, 'chd')  if verbose else None
                subprocess.run(['chdman', 'extractcd', '-f', '-i', chd, '-ob', tmpbin, '-o', tmpcue], check=True)
            except:
                print('XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX\nCHDMAN not found.\nCan not convert game\nPlease see README file for how to install chdman\nXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX')
                os._exit(10)
            cue_file = tmpcue
            # we didn't actually have a CUE file to start with so just
            # replace the "real" cue filename with our temporary one
            real_cue_files[-1] = cue_file
        if cue_file[-4:] == '.zip':
            print('This is a ZIP file. Uncompress the file.') if verbose else None
            zip = cue_file
            with zipfile.ZipFile(zip, 'r') as zf:
                for f in zf.namelist():
                    print('Extracting', subdir + f) if verbose else None
                    temp_files.append(subdir + f)
                    zf.extract(f, path=subdir)
                    if re.search('.cue$', f):
                        print('Found CUE file', f) if verbose else None
                        cue_file = subdir + f
                        # we didn't actually have a CUE file to start with so just
                        # replace the "real" cue filename with our temporary one
                        real_cue_files[-1] = cue_file

        if cue_file[-3:] == 'img' or cue_file[-3:] == 'bin':
            tmpcue = subdir + 'TMP%d.cue' % (0 if not idx else idx[0])
            print('IMG or BIN file. Create a temporary cue file for it', tmpcue) if verbose else None
            temp_files.append(tmpcue)
            with open(tmpcue, "w") as f:
                f.write('FILE "%s" BINARY\n' % cue_file)
                f.write('  TRACK 01 MODE2/2352\n')
                f.write('    INDEX 01 00:00:00\n')

            cue_file = tmpcue

        if cue_file[-3:] == 'ccd':
            tmpcue = subdir + 'TMP%d.cue' % (0 if not idx else idx[0])
            print('CCD file. Create a temporary cue file for it', tmpcue) if verbose else None
            temp_files.append(tmpcue)
            ccd = parse_ccd(cue_file)
            cue = ccd2cue(ccd)
            write_cue(cue, tmpcue)

            cue_file = tmpcue
            # we didn't actually have a CUE file to start with so just
            # replace the "real" cue filename with our temporary one
            real_cue_files[-1] = cue_file
            
        if cue_file[-3:] != 'cue':
            print('%s is not a CUE file. Skipping' % cue_file) if verbose else None
            continue

        i = get_imgs_from_bin(cue_file)
        img_file = i[0]
        if len(i) > 1:
            try:
                if os.name == 'posix':
                    os.stat('./binmerge')
                else:
                    os.stat('binmerge.exe')
            except:
                raise Exception('binmerge is required in order to support multi-bin disks. See README file for instructions on how to install binmerge.')
            mb = 'MB%d' % (0 if not idx else idx[0])
            temp_files.append(mb)
            if os.name == 'posix':
                subprocess.call(['python3', './binmerge', '-o', subdir, cue_file, mb])
            else:
                subprocess.call(['binmerge.exe', '-o', subdir, cue_file, mb])
            cue_file = subdir + mb + '.cue'
            temp_files.append(cue_file)
            img_file = subdir + mb + '.bin'
            temp_files.append(img_file)

        img_files.append(img_file)
        cue_files.append(cue_file)

        if idx:
            idx = (idx[0] + 1, idx[1])

    # We need to convert the first track of every ISO so we can open the
    # disk and read system.cnf
    disc_ids = get_disc_ids(real_cue_files, subdir=subdir)
    real_disc_ids = disc_ids[:]
    if args.ps3_pkg:
        for i in range(len(real_disc_ids)):
            try:
                os.stat(real_cue_files[i][:-3]+'ps3config').st_size
                print('Found an external config ', real_cue_files[i][:-3]+'ps3config')
                with open(real_cue_files[i][:-3]+'ps3config', 'rb') as f:
                      f.seek(8)
                      ps3configs[-1] = ps3configs[-1] + f.read()
            except:
                True
                
            disc_id = real_disc_ids[i]
            if disc_id in games and 'ps3config' in games[disc_id]:
                print('Found an external config for', disc_id) if verbose else None
                with open(games[disc_id]['ps3config'], 'rb') as f:
                      f.seek(8)
                      ps3configs[i] = ps3configs[i] + f.read()
            if args.resolution == '1':
                print('Inject config to force NTSC') if verbose else None
                ps3configs[i] = force_ntsc_config(ps3configs[i])
    if args.psp_dir:
        for i in range(len(real_disc_ids)):
            disc_id = real_disc_ids[i]
            if disc_id in games and 'pspconfig' in games[disc_id]:
                print('Found an external config for', disc_id)
                with open(games[disc_id]['pspconfig'], 'rb') as f:
                      pspconfigs[i] = f.read()
            try:
                os.stat(real_cue_files[i][:-3]+'pspconfig').st_size
                print('Found an external config ', real_cue_files[i][:-3]+'pspconfig')
                with open(real_cue_files[i][:-3]+'pspconfig', 'rb') as f:
                      pspconfigs[-1] = f.read()
            except:
                True
                
    #
    # Force use of ps1_newemu, this disables all other config settings
    #
    if args.ps1_newemu and args.ps3_pkg:
        print('Forcing ps1_newemu on all disks for this game')
        for i in range(len(real_disc_ids)):
            ps3configs[i] = bytes([0x38, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00])

    #
    # Apply all PPF fixes we might need
    #
    cue_files, img_files = apply_ppf_fixes(real_disc_ids, cue_files, img_files, subdir, tag='psp' if args.psp_dir else None)

    #
    # Apply all romhacks
    #
    if args.romhacks:
        romhacks = args.romhacks.split(',')
        if len(romhacks) != len(cue_files):
            print('--romhacks must have one patch for each disk. Found %d disks but only %d romhacks.' % (len(cue_files), len(romhacks)))
            shutil.rmtree('pop-fe-work', ignore_errors=True)
            os._exit(1)
        cue_files, img_files = apply_romhacks(real_disc_ids, cue_files, img_files, romhacks, subdir)
    
    cu2_files = generate_cu2_files(cue_files, img_files, subdir)

    if args.psp_dir or args.ps3_pkg or args.retroarch_pbp_dir:
        aea_files, extra_data_tracks = generate_aea_files(cue_files, img_files, subdir)
        if extra_data_tracks:
            args.whole_disk = True
            args.psp_use_cdda = False
            print('Extra data tracks found, forcing WHOLE DISK encoding')

    if args.game_id:
        args.game_id = args.game_id.split(',')
        # override the disc_ids with the content of --game_id
        for idx in range(len(args.game_id)):
            if idx < len(disc_ids):
                disc_ids[idx] = args.game_id[idx]
    if args.psp_install_memory_card:
        if not args.game_id:
            raise Exception('Must specify --game_id when using --psp-install-memory-card')
        install_psp_mc(args.psp_dir, args.game_id[0], mem_cards)
        quit()

    resolution = 1
    if args.ps3_pkg and (real_disc_ids[0][:4] == 'SLES' or real_disc_ids[0][:4] == 'SCES'):
        print('SLES/SCES PAL game. Default resolution set to 2 (640x512)') if verbose else None
        resolution = 2
    if args.resolution:
        print('Resolution set to', args.resolution) if verbose else None
        resolution = int(args.resolution)
    
    game_title = None
    if args.title:
        game_title = args.title
    if not game_title:
        try:
            with open(create_path(args.files[0], 'GAME_TITLE'), 'r') as d:
                game_title = d.read()
        except:
            True
    if not game_title:
        game_title = get_title_from_game(disc_ids[0])

    game = get_game_from_gamelist(disc_ids[0])

    # ICON0.PNG
    icon0 = None
    if args.cover:
        print('Get cover from', args.cover)
        icon0 = Image.open(args.cover)
    if args.theme:
        icon0 = get_image_from_theme(args.theme, disc_ids[0], subdir, 'ICON0.PNG')
        if not icon0:
            icon0 = get_image_from_theme(args.theme, disc_ids[0], subdir, 'ICON0.png')
    if not icon0:
        print('Fetch ICON0 for', game_title) if verbose else None
        temp_files.append(subdir + 'ICON0.jpg')
        pfs = None
        if args.ps3_pkg:
            pfs = ((176,176),(138,138))
        if args.psp_dir:
            pfs = ((80,80),(62,62))
        icon0 = get_icon0_from_game(disc_ids[0], game, args.files[0], subdir + 'ICON0.jpg')

    # LOGO.PNG
    logo = None
    if args.logo:
        print('Get LOGO from', args.logo)
        logo = Image.open(args.logo)
        
    # PIC0.PNG
    pic0 = None
    if args.pic0:
        print('Get PIC0/Screenshot from', args.pic0)
        pic0 = Image.open(args.pic0)
    if args.theme:
        pic0 = get_image_from_theme(args.theme, disc_ids[0], subdir, 'PIC0.PNG')
        if not pic0:
            pic0 = get_image_from_theme(args.theme, disc_ids[0], subdir, 'PIC0.png')
    if not pic0:
        print('Fetch PIC0 for', game_title) if verbose else None
        pic0 = get_pic0_from_game(disc_ids[0], game, args.files[0])
        
    # PIC1.PNG
    pic1 = None
    if args.pic1:
        print('Get PIC1/Screenshot from', args.pic1)
        pic1 = Image.open(args.pic1)
    if args.theme:
        pic1 = get_image_from_theme(args.theme, disc_ids[0], subdir, 'PIC1.PNG')
        if not pic1:
            pic1 = get_image_from_theme(args.theme, disc_ids[0], subdir, 'PIC1.png')
    if not pic1:
        print('Fetch PIC1 for', game_title) if verbose else None
        pic1 = get_pic1_from_game(disc_ids[0], game, args.files[0])

    manual = None
    if not args.force_no_assets and (args.psp_dir or args.fetch_metadata):
        if args.manual:
            manual = args.manual
        if not manual:
            try:
                os.stat(args.files[0][:-4] + '.manual')
                manual = args.files[0][:-4] + '.manual'
                print('Use locally stored manual from', manual)
            except:
                True
        if disc_ids[0] in games and not manual and 'manual' in games[disc_ids[0]]:
            manual = games[disc_ids[0]]['manual']
        if manual:
            manual = create_manual(manual, disc_ids[0])
        
    print('Id:', disc_ids[0])
    print('Title:', game_title)
    print('Cue Files', cue_files) if verbose else None
    print('Imb Files', img_files) if verbose else None
    print('Disc IDs', disc_ids) if verbose else None

    subchannels = []
    magic_word = []
    for idx in range(len(real_disc_ids)):
        if 'psp-use-cdda' in games[real_disc_ids[idx]]:
            args.psp_use_cdda = True
        if real_disc_ids[idx] not in libcrypt:
            magic_word.append(0)
            subchannels.append(None)
            continue
        
        magic_word.append(libcrypt[real_disc_ids[idx]]['magic_word'])
        subchannels.append(generate_subchannels(libcrypt[real_disc_ids[idx]]['magic_word']))

        patch_libcrypt = False
        if args.auto_libcrypt:
            patch_libcrypt = True
        if args.ps3_pkg and args.ps3_libcrypt:
            patch_libcrypt = True
        if args.ps2_dir or args.psio_dir:
            print('#####################################')
            print('WARNING! This disc is protected with libcrypt.')
            print('Will attempt to apply libcrypt PPF patch')
            print('#####################################')
            patch_libcrypt = True
        if args.ps3_pkg:
            print('#####################################')
            print('WARNING! This disc is protected with libcrypt.')
            print('Will attempt to inject MagicWord and Subchannel data')
            print('into ISO.BIN.DAT')
            print('This should work for most games. If not then try')
            print('creating the package again with --ps3-libcrypt')
            print('#####################################')
        if patch_libcrypt:
            #
            # Copy the CUE and BIN locally so we can patch them
            # qqq we don't need to copy them if they are already in
            # our temporary work directory pop-fe-work/
            i = get_imgs_from_bin(cue_files[idx])
            print('Copy %s to LCP%02x.bin so we can patch libcrypt' % (i[0], idx)) if verbose else None
            copy_file(i[0], 'LCP%02x.bin' % idx) 
            temp_files.append('LCP%02x.bin' % idx)
            with open(cue_files[idx], 'r') as fi:
                l = fi.readlines()
                l[0] = 'FILE "%s" BINARY\n' % ('LCP%02x.bin' % idx)
                with open('LCP%02x.cue' % idx, 'w') as fo:
                    fo.writelines(l)
                temp_files.append('LCP%02x.cue' % idx)
            cue_files[idx] = 'LCP%02x.cue' % idx
            img_files[idx] = 'LCP%02x.bin' % idx
            apply_ppf(img_files[idx], real_disc_ids[idx], magic_word[idx], args.auto_libcrypt)

    snd0 = args.snd0
    if not args.force_no_assets:
        # if we did not get an --snd0 argument see if can find one in the gamedb
        if not snd0 and args.theme:
            snd0 = get_snd0_from_theme(args.theme, disc_ids[0], subdir)
        if not snd0:
            try:
                os.stat(args.files[0][:-4] + '.snd0')
                snd0 = args.files[0][:-4] + '.snd0'
                print('Use locally stored SND0 from', snd0)
            except:
                True
        if not snd0:
            snd0 = get_snd0_from_game(disc_ids[0], subdir=subdir)
            if snd0:
                temp_files.append(snd0)
        if snd0 == 'auto':
            a = Search(game_title + ' ps1 ost')
            snd0 = 'https://www.youtube.com/watch?v=' + a.results[0].video_id
            print('Found Youtube link', 'https://www.youtube.com/watch?v=' + a.results[0].video_id)
        if snd0 and snd0[:24] == 'https://www.youtube.com/':
            snd0 = get_snd0_from_link(snd0, subdir=subdir)
            if snd0:
                temp_files.append(snd0)

    if args.psp_dir:
        create_psp(args.psp_dir, disc_ids, game_title, icon0, pic0, pic1, cue_files, cu2_files, img_files, mem_cards, aea_files, snd0=snd0, subdir=subdir, watermark=args.watermark, subchannels=subchannels, manual=manual, configs=pspconfigs, use_cdda=args.psp_use_cdda, logo=logo)
    if args.ps2_dir:
        create_ps2(args.ps2_dir, disc_ids, game_title, icon0, pic1, cue_files, cu2_files, img_files)
    if args.ps3_pkg:
        create_ps3(args.ps3_pkg, disc_ids, game_title, icon0, pic0, pic1, cue_files, cu2_files, img_files, mem_cards, aea_files, magic_word, resolution, snd0=snd0, subdir=subdir, whole_disk=args.whole_disk, subchannels=subchannels, configs=ps3configs)
    if args.psc_dir:
        create_psc(args.psc_dir, disc_ids, game_title, icon0, pic1, cue_files, cu2_files, img_files, watermark=True if args.watermark else False)
    if args.fetch_metadata:
        create_metadata(args.files[0], disc_ids[0], game_title, icon0, pic0, pic1, snd0, manual)
    if args.psio_dir:
        create_psio(args.psio_dir, disc_ids[0], game_title, icon0, cu2_files, img_files)
    if args.retroarch_bin_dir:
        new_path = args.retroarch_bin_dir + '/' + game_title
        create_retroarch_bin(new_path, game_title, cue_files, img_files)
    if args.retroarch_cue_dir:
        new_path = args.retroarch_cue_dir + '/' + game_title
        create_retroarch_cue(new_path, game_title, cue_files, img_files, magic_word)
    if args.retroarch_pbp_dir:
        new_path = args.retroarch_pbp_dir + '/' + game_title + '.pbp'
        if icon0:
            image = icon0.resize((80,80), Image.Resampling.BILINEAR)
            i = io.BytesIO()
            image.save(i, format='PNG')
            i.seek(0)
            icon0 = i.read()

        if pic1:
            image = pic1
            i = io.BytesIO()
            image.save(i, format='PNG')
            i.seek(0)
            pic1 = i.read()
        
        generate_pbp(new_path, disc_ids, game_title, icon0, None, pic1, cue_files, cu2_files, img_files, aea_files)
    if args.retroarch_thumbnail_dir:
        create_retroarch_thumbnail(args.retroarch_thumbnail_dir, game_title, icon0, pic1)

    for f in temp_files:
        print('Deleting temp file', f) if verbose else None
        try:
            os.unlink(f)
        except:
            try:
                os.rmdir(f)
            except:
                True
    shutil.rmtree('pop-fe-work', ignore_errors=True)