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
#
# Configs for PSP: https://www.psdevwiki.com/psp/POPS

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 pytubefix import YouTube
    from pytubefix.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'], h

    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:
        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'], h
            if buf != '         ':
                return buf, h
            else:
                return 'UNKN00000', h

    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], h
    return game_id, h

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

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':
            if psn_frame_size:
                return Image.new("RGBA", psn_frame_size[0], (255,255,255,0))
            else:
                return Image.new("RGBA", (80,80), (255,255,255,0))

        l = 'https://raw.githubusercontent.com/xlenore/psx-covers/main/covers/default/' + game_id[:4] + '-' + game_id[4:9] +'.jpg'
        ret = requests.get(l, stream=True)
        if ret.status_code == 200:
            fcb = ret.content
            
        if not fcb:
            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 trailing 'binary '
        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] == '"' and line[-1] == '"':
            line = line[1:-1]
        # remove single quotes
        if line[0] == '\'' and line[-1] == '\'':
            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, no_pstitleimg=False):
    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 no_pstitleimg:
        p.no_pstitleimg = no_pstitleimg
    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, no_pstitleimg=False, watermark=False, subchannels=[], manual=None, configs=None, use_cdda=False, logo=None, no_libcrypt=None):
    if not no_libcrypt:
        try:
            # The libcrypt patcher crashes on some games like 'This Is Football (Europe) (Fr,Nl)'
            cue_files, img_files = patch_libcrypt(disc_ids, cue_files, img_files, subdir=subdir)
        except:
            print('patch_libcrypt crashed :-(')
            True
    
    # 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
    if len(disc_ids) > 1:
        no_pstitleimg = False

    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, no_pstitleimg=no_pstitleimg)

    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, [], None)

    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, no_libcrypt=None):
    print('Create PS3 PKG for', game_title) if verbose else None

    if not no_libcrypt:
        try:
            # The libcrypt patcher crashes on some games like 'This Is Football (Europe) (Fr,Nl)'
            cue_files, img_files = patch_libcrypt(disc_ids, cue_files, img_files, subdir=subdir)
        except:
            print('patch_libcrypt crashed :-(')
            True
    
    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)
    if disc_ids[0][:4] == 'SLED':
        print('Apply hotfix for SLED games')
        p.hotfixes = [ (b'SLED', b'SLES'), ]
    if disc_ids[0][:4] == 'SCED':
        print('Apply hotfix for SCED games')
        p.hotfixes = [ (b'SCED', b'SCES'), ]

    # 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': games[disc_ids[0]]['id']},
        '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': games[disc_ids[0]]['id']},
        '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_id(cue, real_cue_file, tmp):
    try:
        with open(create_path(real_cue_file, 'GAME_ID'), 'r') as d:
            gid = d.read()[:9]
            print('Read disc id from', create_path(real_cue_file, 'GAME_ID'))
            return gid, '0'
    except:
        True
    print('Convert ' + cue + ' to a normal style ISO') if verbose else None
    bc = bchunk()
    bc.verbose = False
    bc.open(cue)
    bc.writetrack(1, tmp)

    gid, md5 = get_gameid_from_iso(tmp)
    return gid, md5


def get_disc_ids(cue_files, real_cue_files, subdir='./'):
    disc_ids = []
    md5_sums = []
    for idx in range(len(cue_files)):
        gid, md5 = get_disc_id(cue_files[idx], real_cue_files[idx], subdir + 'ISO%02x01.iso' % idx)
        disc_ids.append(gid)
        md5_sums.append(md5)

    return disc_ids, md5_sums


def install_deps():
    print(os.name)
    subprocess.call(['git', 'submodule', 'update', '--init'])

    # 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 pytubefix import YouTube
        print('Pytube is already installed')
    except:
        print('Installing python pytube')
        subprocess.call(['pip', 'install', 'pytubefix'])
    # 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
    if os.name == 'posix':
        cue2cu2_path = 'Cue2cu2/cue2cu2.py'
        os.makedirs('Cue2cu2', exist_ok=True)
    else:
        cue2cu2_path = 'cue2cu2.exe'
    try:
        os.stat(cue2cu2_path)
        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)
        with open(cue2cu2_path, 'wb') as f:
            f.write(bytes(ret.content.decode(ret.apparent_encoding), encoding='utf-8'))
    # binmerge
    if os.name == 'posix':
        binmerge_path = 'binmerge/binmerge'
        os.makedirs('binmerge', exist_ok=True)
    else:
        binmerge_path = 'binmerge'
    try:
        os.stat(binmerge_path)
        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_path, '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('../../..')

    if os.name == 'posix':
        # libcrypt-patcher
        try:
            os.stat('Xlibcrypt-patcher')
            print('libcrypt-patcher is already installed')
        except:
            print('Cloning libcrypt-patcher')
            subprocess.call(['wget', 'https://github.com/alex-free/libcrypt-patcher/releases/download/v1.0.8/libcrypt-patcher-v1.0.8-linux-i386-static.zip'])
            subprocess.call(['unzip', '-j', 'libcrypt-patcher-v1.0.8-linux-i386-static.zip', '*/lcp'])

            
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/'):

    # 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://':
        if (gameid in games and 'manual' in games[gameid] and
            games[gameid]['manual'] == source):
            _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

        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, md5_sums, 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 tag and 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 = md5_sums[i]
                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)

        # 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, 'to', img_files[i])
        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/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

def process_disk_file(cue_file, idx, temp_files, subdir='./'):
    real_cue_file = cue_file

    if cue_file[-4:].lower() == '.chd':
        print('This is a CHD file. Uncompress the file.') if verbose else None
        chd = cue_file
        try:
            tmpcue = subdir + 'CDH%d.cue' % (idx)
            tmpbin = subdir + 'CDH%d.bin' % (idx)
            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_file = cue_file

    if cue_file[-4:].lower() == '.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_file = cue_file

    if cue_file[-3:].lower() == 'img' or cue_file[-3:].lower() == 'bin':
        tmpcue = subdir + 'TMP%d.cue' % (idx)
        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' % os.path.abspath(cue_file))
            f.write('  TRACK 01 MODE2/2352\n')
            f.write('    INDEX 01 00:00:00\n')

        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_file = cue_file

    if cue_file[-3:].lower() == 'ccd':
        tmpcue = subdir + 'TMP%d.cue' % (idx)
        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

    if cue_file[-3:].lower() != 'cue':
        print('%s is not a CUE file. Skipping' % cue_file) if verbose else None
        return None, None, None

    i = get_imgs_from_bin(cue_file)
    img_file = i[0]

    if len(i) > 1:
        try:
            if os.name == 'posix':
                os.stat('binmerge/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' % (idx)
        temp_files.append(mb)
        if os.name == 'posix':
            subprocess.call(['python3', 'binmerge/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)
        
    return cue_file, real_cue_file, img_file

def patch_libcrypt(real_disc_ids, cue_files, img_files, subdir='pop-fe-work/'):
    for idx in range(len(real_disc_ids)):
        if real_disc_ids[idx] not in libcrypt:
            continue
        print('Need to patch libcrypt for', real_disc_ids[idx])
        if len(cue_files[idx]) < len(subdir) or cue_files[idx][:len(subdir)] != subdir:
            print('Copy the files')
            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], subdir + '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(subdir + 'LCP%02x.cue' % idx, 'w') as fo:
                    fo.writelines(l)
                temp_files.append('LCP%02x.cue' % idx)
            cue_files[idx] = subdir + 'LCP%02x.cue' % idx
            img_files[idx] = subdir + 'LCP%02x.bin' % idx
            if os.name == 'posix':
                subprocess.run(['./lcp', img_files[idx]], check=True)
            else:
                subprocess.run(['lcp.exe', img_files[idx]], check=True)
    return cue_files, img_files


# 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('--no-libcrypt', action='store_true',
                    help='Do not patch libcrypt')
    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('--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/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())

        # 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, '...')

        cue_file , real_cue_file, img_file = process_disk_file(cue_file, 0 if not idx else idx[0], temp_files, subdir=subdir)

        if not cue_file:
            continue

        img_files.append(img_file)
        cue_files.append(cue_file)
        real_cue_files.append(real_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, md5_sums = get_disc_ids(cue_files, 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, md5_sums, 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][:3] == 'SLE' or real_disc_ids[0][:3] == 'SCE'):
        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', pfs)

    # 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 and args.pic0.lower() != 'none':
        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 and not args.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 and args.pic1.lower() != 'none':
        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 and not args.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:', games[disc_ids[0]]['id'])
    print('Title:', game_title)

    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']))

    # for psp and ps3 we patch libcrypt in the respective create_[pps|ps3] functions
    if not args.no_libcrypt and not args.ps3_pkg and not args.psp_dir:
        try:
            # The libcrypt patcher crashes on some games like 'This Is Football (Europe) (Fr,Nl)'
            cue_files, img_files = patch_libcrypt(disc_ids, cue_files, img_files, subdir=subdir)
        except:
            print('patch_libcrypt crashed :-(')
            True
    
    print('Cue Files', cue_files) if verbose else None
    print('Img Files', img_files) if verbose else None
    print('Real Disc IDs', real_disc_ids) if verbose else None
    
    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 snd0 == 'no':
        print('Disable SND0')
        snd0 = None

    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, no_libcrypt=args.no_libcrypt)
    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, no_libcrypt=args.no_libcrypt)
    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, None)
    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)