# File: karel.py

import atexit
import copy
import importlib
import inspect
import io
import math
import os
import random
import ssl
import sys
import threading
import time
import tokenize
import urllib.request

# Original file: pgl.py

"""
The pgl module implements the Portable Graphics Library (pgl) on top of
Tkinter, which is the most common graphics package for use with Python.
"""

# Version information

PGL_VERSION = 0.95
PGL_BUGFIX = 0
PGL_DATE = "20-Jun-21"

# Conditional imports

try:
    import tkinter                          # pylint: disable=import-error
    try:
        import tkinter.font as tk_font      # pylint: disable=import-error
    except Exception:
        import tk_font                      # pylint: disable=import-error
except Exception as e:
    print('Could not load tkinter: ' + str(e))

try:
    from PIL import ImageTk, Image          # pylint: disable=import-error
    _image_model = "PIL"
except Exception:
    _image_model = "PhotoImage"

spyder_flag = False

try:
    import spydercustomize as customize     # pylint: disable=import-error
    spyder_flag = True
except Exception:
    try:
        import sitecustomize as customize   # pylint: disable=import-error
        spyder_flag = True
    except Exception:
        pass

if spyder_flag:
    try:
        sys_clear_post_mortem = customize.clear_post_mortem
        def patched_clear_post_mortem():
            customize.clear_post_mortem = sys_clear_post_mortem
            try:
                if tkinter._root is not None:
                    tkinter._root.mainloop()
            except Exception:
                pass
            sys_clear_post_mortem()
        customize.clear_post_mortem = patched_clear_post_mortem
    except Exception:
        pass

# Class GWindow

class GWindow(object):
    """
    This class represents a graphics window that can contain graphical
    objects.
    """

# Public constants

    DEFAULT_WIDTH = 500
    DEFAULT_HEIGHT = 300
    MIN_WAKEUP = 20

# Constructor: GWindow

    def __init__(self, width=DEFAULT_WIDTH, height=DEFAULT_HEIGHT):
        """
        The constructor takes either of the following forms:

        <pre>
           GWindow()
           GWindow(width, height)
        </pre>

        If the dimensions are missing, the constructor creates a
        <code>GWindow</code> with a default size.
        """
        try:
            tk = tkinter._root
            tk.deiconify()
        except AttributeError:
            tk = tkinter.Tk()
            tkinter._root = tk
        self._window_width = width
        self._window_height = height
        self._tk = tk
        self._tk.protocol("WM_DELETE_WINDOW", self._delete_window)
        for w in tk.winfo_children():
            w.destroy()
        self._canvas = tkinter.Canvas(tk, width=width, height=height,
                                      highlightthickness=0, background="white")
        try:
            self._canvas.pack()
        except:
            pass
        if spyder_flag:
            def cancel_topmost():
                tk.attributes("-topmost", False)
            tk.attributes("-topmost", True)
            tk.focus_force()
            self._canvas.after(0, cancel_topmost)
        self._canvas.update()
        self._images = { }
        self._timers = [ ]
        self._base = GCompound()
        self._base._gw = self
        self._event_manager = _EventManager(self)
        self.set_window_title(_get_program_name())
        self._event_loop_started = False
        self._active = True
        if not spyder_flag:
            atexit.register(self._start_event_loop)

    def __eq__(self, other):
        if isinstance(other, GWindow):
            return self._canvas is other._canvas
        return False

# Public method: close

    def close(self):
        """
        Deletes the window from the screen.
        """
        self._delete_window()

# Public method: event_loop

    def event_loop(self):
        """
        Waits for events to happen in the window.
        """
        self._event_loop_started = True
        tkinter._root.mainloop()

# Public method: request_focus

    def request_focus(self):
        """
        Asks the system to assign the keyboard focus to the window, which
        brings it to the top and ensures that key events are delivered to
        the window.
        """
        tkinter._root.canvas.focus_set()

# Public method: clear

    def clear(self):
        """
        Clears the contents of the window.
        """
        self._base.remove_all()

# Public method: get_width

    def get_width(self):
        """
        Returns the width of the graphics window in pixels.
        """
        return self._window_width

# Public method: get_height

    def get_height(self):
        """
        Returns the height of the graphics window in pixels.
        """
        return self._window_height

# Public method: add_event_listener

    def add_event_listener(self, type, fn):
        """
        Adds an event listener of the specified type to the window.
        """
        self._event_manager.add_event_listener(type, fn)

# Public method: repaint

    def repaint(self):
        """
        Schedule a repaint on this window.
        """
        pass

# Public method: set_window_title

    def set_window_title(self, title):
        """
        Sets the title of the graphics window.
        """
        self._window_title = title
        self._tk.title(title)

# Public method: get_window_title

    def get_window_title(self):
        """
        Returns the title of the graphics window.
        """
        return self._window_title

# Public method: add

    def add(self, gobj, x=None, y=None):
        """
        Adds the <code>GObject</code> to the window.  The first parameter
        is the object to be added.  The <code>x</code> and <code>y</code>
        parameters are optional.  If they are supplied, the location of
        the object is set to (<code>x</code>, <code>y</code>).
        """
        self._base.add(gobj, x, y)

# Public method: remove

    def remove(self, gobj):
        """
        Removes the object from the window.
        """
        self._base.remove(gobj)

# Public method: get_element_at

    def get_element_at(self, x, y):
        """
        Returns the topmost <code>GObject</code> containing the
        point (x, y), or <code>None</code> if no such object exists.
        """
        return self._base.get_element_at(x, y)

# Public method: create_timer

    def create_timer(self, fn, delay):
        """
        Creates a new timer object that calls fn after the specified
        delay, which is measured in milliseconds.  The timer must be
        started by calling the <code>start</code> method.
        """
        return GTimer(self, fn, delay)

# Public method: set_timeout

    def set_timeout(self, fn, delay):
        """
        Creates and starts a one-shot timer that calls fn after the
        specified delay, which is measured in milliseconds.  The
        set_timeout method returns the <code>GTimer</code> object.
        """
        timer = GTimer(self, fn, delay)
        timer.start()
        return timer

# Public method: set_interval

    def set_interval(self, fn, delay):
        """
        Creates and starts an interval timer that calls fn after the
        specified delay, which is measured in milliseconds.  The
        set_interval method returns the <code>GTimer</code> object.
        """
        timer = GTimer(self, fn, delay)
        timer.set_repeats(True)
        timer.start()
        return timer

# Public method: pause

    def pause(self, delay):
        """
        Pauses the current thread for the specified delay, which is
        measured in milliseconds.  The pause method periodically checks
        the event queue to update the contents of the window.
        """
        n_cycles = delay // GWindow.MIN_WAKEUP
        for i in range(n_cycles):           # pylint: disable=unused-variable
            self._tk.update_idletasks()
            self._tk.update()
            time.sleep(delay / n_cycles / 1000)

# Public static method: exit

    @staticmethod
    def exit():
        """
        Closes all graphics windows and exits from the application without
        waiting for any additional user interaction.
        """
        sys.exit()

# Public static method: get_program_name

    @staticmethod
    def get_program_name():
        """
        Returns the name of this program.
        """
        return _get_program_name()

# Public static method: get_screen_width

    @staticmethod
    def get_screen_width():
        """
        Returns the width of the entire display screen.
        """
        return _get_screen_width()

# Public static method: get_screen_height

    def get_screen_height():
        """
        Returns the height of the entire display screen.
        """
        return _get_screen_height()

# Public static method: convert_color_to_rgb

    def convert_color_to_rgb(color_name):
        """
        Converts a color name into an integer that encodes the
        red, green, and blue components of the color.
        """
        return _convert_color_to_rgb(color_name)

# Public static method: convert_rgb_to_color

    @staticmethod
    def convert_rgb_to_color(rgb):
        """
        Converts an rgb value into a name in the form <code>"#rrggbb"</code>.
        Each of the <code>rr</code>, <code>gg</code>, and <code>bb</code>
        values are two-digit hexadecimal numbers indicating the intensity
        of that component.
        """
        return _convert_rgb_to_color(rgb)

# Private method: _delete_window

    def _delete_window(self):
        """
        Closes the window and exits from the event loop.
        """
        try:
            self._active = False
            try:
                for timer in self._timers:
                    timer.stop()
            except:
                pass
            tkinter._root.destroy()
            del tkinter._root
        except:
            pass

# Private method: _start_event_loop

    def _start_event_loop(self):
        """
        Starts the event loop if it wasn't run explicitly.
        """
        if not self._event_loop_started:
            self.event_loop()

# Private method: _rebuild

    def _rebuild(self):
        """
        Rebuilds the tkinter data structure for the window.  This
        operation is triggered if a global update is necessary.
        """
        self._canvas.delete("all")
        self._base._install(self, _GTransform())

# Define camel-case names

    eventLoop = event_loop
    requestFocus = request_focus
    getWidth = get_width
    getHeight = get_height
    addEventListener = add_event_listener
    setWindowTitle = set_window_title
    getWindowTitle = get_window_title
    getElementAt = get_element_at
    createTimer = create_timer
    setTimeout = set_timeout
    setInterval = set_interval
    getProgramName = get_program_name
    getScreenWidth = get_screen_width
    getScreenHeight = get_screen_height
    convertColorToRGB = convert_color_to_rgb
    convertRGBToColor = convert_rgb_to_color

# Allow British spelling

    convert_colour_to_rgb = convert_color_to_rgb
    convert_rgb_to_colour = convert_rgb_to_color
    convertColourToRGB = convert_color_to_rgb
    convertRGBToColour = convert_rgb_to_color

# Class: GObject

class GObject(object):
    """
    This class is the common superclass of all graphical objects that can
    be displayed on a graphical window. For examples illustrating the use
    of the <code>GObject</code> class, see the descriptions of the
    individual subclasses.
    """

# Constructor: GObject

    def __init__(self):
        """
        Creates a new <code>GObject</code>.  The constructor is called
        only by subclasses.
        """
        self._x = 0.0
        self._y = 0.0
        self._sf = 1
        self._angle = 0
        self._color = "Black"
        self._line_width = 1.0
        self._visible = True
        self._parent = None
        self._tkid = None
        self._gw = None
        self._ctm_base = _GTransform()

# Public method: get_x

    def get_x(self):
        """
        Returns the x-coordinate of the object.
        """
        return self._x

# Public method: get_y

    def get_y(self):
        """
        Returns the y-coordinate of the object.
        """
        return self._y

# Public method: get_location

    def get_location(self):
        """
        Returns the location of this object as a <code>GPoint</code>.
        """
        return GPoint(self._x, self._y)

# Public method: set_location

    def set_location(self, x, y):
        """
        Sets the location of this object to the specified point.
        """
        if isinstance(x, GPoint):
            x, y = x.get_x(), x.get_y()
        elif isinstance(x, dict):
            x, y = x.x, x.y
        self._x = x
        self._y = y
        self._update_location()

# Public method: move

    def move(self, dx, dy):
        """
        Moves the object on the screen using the displacements
        <code>dx</code> and <code>dy</code>.
        """
        self.set_location(self._x + dx, self._y + dy)

# Public method: move_polar

    def move_polar(self, r, theta):
        """
        Moves the object on the screen the distance <i>r</i> in the
        direction <i>theta</i>.
        """
        dx = r * math.cos(math.radians(theta))
        dy = -r * math.sin(math.radians(theta))
        self.move(dx, dy)

# Public method: get_width

    def get_width(self):
        """
        Returns the width of this object, which is defined to be the width of
        the bounding box.
        """
        return self.get_bounds().get_width()

# Public method: get_height

    def get_height(self):
        """
        Returns the height of this object, which is defined to be the height
        of the bounding box.
        """
        return self.get_bounds().get_height()

# Public method: get_size

    def get_size(self):
        """
        Returns the size of the object as a <code>GDimension</code>.
        """
        bounds = self.get_bounds()
        return GDimension(bounds.get_width(), bounds.get_height())

# Public method: set_line_width

    def set_line_width(self, line_width):
        """
        Sets the width of the line used to draw this object.
        """
        self._line_width = line_width
        self._update_properties(width=line_width)

# Public method: get_line_width

    def get_line_width(self):
        """
        Returns the width of the line used to draw this object.
        """
        return self._line_width

# Public method: set_color

    def set_color(self, color):
        """
        Sets the color used to display this object.  The color parameter is
        usually one of the CSS color names.  The color can also be specified
        as a string in the form <code>"#rrggbb"</code> where <code>rr</code>,
        <code>gg</code>, and <code>bb</code> are pairs of hexadecimal digits
        indicating the red, green, and blue components of the color.
        """
        rgb = _convert_color_to_rgb(color)
        self._color = _convert_rgb_to_color(rgb)
        self._update_color()

# Public method: get_color

    def get_color(self):
        """
        Returns the current color as a string in the form
        <code>"#rrggbb"</code>.  In this string, the values <code>rr</code>,
        <code>gg</code>, and <code>bb</code> are two-digit hexadecimal
        values representing the red, green, and blue components.
        """
        return self._color

# Public method: scale

    def scale(self, sf):
        """
        Scales the object by the specified scale factor.
        """
        raise Exception("Not yet implemented")

# Public method: rotate

    def rotate(self, theta):
        """
        Transforms the object by rotating it theta degrees counterclockwise
        around its origin.
        """
        self._angle += theta
        self._update_rotation()

# Public method: set_visible

    def set_visible(self, flag):
        """
        Sets whether this object is visible.
        """
        self._visible = flag
        self._update_visible()

# Public method: is_visible

    def is_visible(self):
        """
        Returns true if this object is visible.
        """
        return self._visible

# Public method: send_forward

    def send_forward(self):
        """
        Moves this object one step toward the front in the z dimension.
        If it was already at the front of the stack, nothing happens.
        """
        parent = self.get_parent()
        if parent is not None:
            parent._send_forward(self)

# Public method: send_to_front

    def send_to_front(self):
        """
        Moves this object to the front of the display in the z dimension.
        By moving it to the front, this object will appear to be on top of the
        other graphical objects on the display and may hide any objects that
        are further back.
        """
        parent = self.get_parent()
        if parent is not None:
            parent._send_to_front(self)

# Public method: send_backward

    def send_backward(self):
        """
        Moves this object one step toward the back in the z dimension.
        If it was already at the back of the stack, nothing happens.
        """
        parent = self.get_parent()
        if parent is not None:
            parent._send_backward(self)

# Public method: send_to_back

    def send_to_back(self):
        """
        Moves this object to the back of the display in the z dimension.
        By moving it to the back, this object will appear to be behind
        the other graphical objects on the display and may be obscured
        by other objects in front.
        """
        parent = self.get_parent()
        if parent is not None:
            parent._send_to_back(self)

# Public method: contains

    def contains(self, x, y):
        """
        Returns true if the specified point is inside the object.
        """
        if isinstance(x, GPoint):
            x, y = x.get_x(), x.get_y()
        elif isinstance(x, dict):
            x, y = x.x, x.y
        bounds = self.get_bounds()
        if bounds is None:
            return False
        return bounds.contains(x, y)

# Public method: get_parent

    def get_parent(self):
        """
        Returns a pointer to the <code>GCompound</code> that contains this
        object.  Every <code>GWindow</code> is initialized to contain a
        single <code>GCompound</code> that is aligned with the window.
        Adding objects to the window adds them to that <code>GCompound</code>,
        which means that every object you add to the window has a parent.
        Calling <code>get_parent</code> on the top-level <code>GCompound</code>
        returns <code>None</code>.
        """
        return self._parent

# Abstract method: get_type

    def get_type(self):
        """
        Returns the concrete type of the object as a string, as in
        "GOval" or "GRect".
        """
        raise Exception("get_type is not defined in the GObject class")

# Abstract method: get_bounds

    def get_bounds(self):
        """
        Returns the bounding box of this object, which is defined to be the
        smallest rectangle that covers everything drawn by the figure.  The
        coordinates of this rectangle do not necessarily match the location
        returned by <code>get_location</code>.  Given a <code>GLabel</code>
        object, for example, <code>get_location</code> returns the
        coordinates of the point on the baseline at which the string begins.
        The <code>get_bounds</code> method, by contrast, returns a rectangle
        that covers the entire window area occupied by the string.
        """
        raise Exception("get_bounds is not defined in the GObject class")

# Protected method: _update_properties

    def _update_properties(self, **options):
        """
        Updates the specified properties of the object, if it is installed
        in a window.
        """
        gw = self._get_window()
        if gw is None:
            return
        tkc = gw._canvas
        tkc.itemconfig(self._tkid, **options)

# Protected method: _update_location

    def _update_location(self):
        """
        Updates the location for this object from the stored x and y
        values.  Some subclasses need to override this method.
        """
        gw = self._get_window()
        if gw is None:
            return
        tkc = gw._canvas
        coords = tkc.coords(self._tkid)
        offx = 0
        offy = 0
        gobj = self.get_parent()
        while gobj is not None:
            offx += gobj._x
            offy += gobj._y
            gobj = gobj.get_parent()
        dx = (self._x + offx) - coords[0]
        dy = (self._y + offy) - coords[1]
        tkc.move(self._tkid, dx, dy)

# Protected method: _update_color

    def _update_color(self):
        """
        Updates the color properties.  Some subclasses need to override
        this method.
        """
        self._update_properties(fill=self._color)

# Protected method: _update_visible

    def _update_visible(self):
        """
        Updates the visible property.
        """
        if self._visible:
            self._update_properties(state=tkinter.NORMAL)
        else:
            self._update_properties(state=tkinter.HIDDEN)

# Protected method: _update_rotation

    def _update_rotation(self):
        """
        Updates the rotation angle for this object.  Subclasses that
        support rotation need to override this method.
        """
        raise Exception("Rotation not yet implemented for this class")

# Private method: _get_window

    def _get_window(self):
        """
        Returns the <code>GWindow</code> in which this <code>GObject</code>
        is installed.  If the object is not installed in a window, this
        method returns <code>None</code>.
        """
        gobj = self
        while gobj._parent is not None:
            gobj = gobj._parent
        return gobj._gw

# Private abstract method: _install

    def _install(self, target, ctm):
        """
        Installs the object in the target, creating any tkinter objects
        that are necessary.
        """
        raise Exception("_install is not defined in the GObject class")

# Define camel-case names

    getX = get_x
    getY = get_y
    getLocation = get_location
    setLocation = set_location
    movePolar = move_polar
    getWidth = get_width
    getHeight = get_height
    getSize = get_size
    setLineWidth = set_line_width
    getLineWidth = get_line_width
    setColor = set_color
    getColor = get_color
    setVisible = set_visible
    isVisible = is_visible
    sendForward = send_forward
    sendToFront = send_to_front
    sendBackward = send_backward
    sendToBack = send_to_back
    getParent = get_parent

# Allow British spelling

    set_colour = set_color
    get_colour = get_color
    setColour = set_color
    getColour = get_color

# Class: GFillableObject

class GFillableObject(GObject):
    """
    This abstract class is the superclass of all objects that are fillable.
    """

# Constructor: GFillableObject

    def __init__(self):
        """
        Initializes a <code>GFillableObject</code>.  Because this is an
        abstract class, clients should not call this constructor explicitly.
        """
        GObject.__init__(self)
        self._fill_flag = False
        self._fill_color = ""

# Public method: set_filled

    def set_filled(self, flag):
        """
        Sets the fill status for the object, where <code>False</code>
        is outlined and <code>True</code> is filled.
        """
        self._fill_flag = flag
        self._update_color()

# Public method: is_filled

    def is_filled(self):
        """
        Returns <code>True</code> if the object is filled.
        """
        return self._fill_flag

# Public method: set_fill_color

    def set_fill_color(self, color):
        """
        Sets the color used to display the filled region of the object.
        """
        rgb = _convert_color_to_rgb(color)
        self._fill_color = _convert_rgb_to_color(rgb)
        self._update_color()

# Public method: get_fill_color

    def get_fill_color(self):
        """
        Returns the color used to display the filled region of this
        object.  If no fill color has been set, <code>get_fill_color</code>
        returns the empty string.
        """
        return self._fill_color

# Override method: _update_color

    def _update_color(self):
        """
        Updates the color properties for a <code>GFillableObject</code>.
        """
        outline = self._color
        if self._fill_flag:
            fill = self._fill_color
            if fill is None or fill == "":
                fill = outline
        else:
            fill = ""
        self._update_properties(outline=outline, fill=fill)

# Define camel-case names

    setFilled = set_filled
    isFilled = is_filled
    setFillColor = set_fill_color
    getFillColor = get_fill_color

# Allow British spelling

    set_fill_colour = set_fill_color
    get_fill_colour = get_fill_color
    setFillColour = set_fill_color
    getFillColour = get_fill_color

# Class: GRect

class GRect(GFillableObject):
    """
    This class represents a graphical object whose appearance consists of
    a rectangular box.
    """

# Constructor: GRect

    def __init__(self, a1, a2, a3=None, a4=None):
        """
        The <code>GRect</code> constructor takes either of the following
        forms:

        <pre>
           GRect(width, height)
           GRect(x, y, width, height)
        </pre>

        If the <code>x</code> and <code>y</code> parameters are missing,
        the origin is set to (0, 0).
        """
        GFillableObject.__init__(self)
        if a3 is None:
            x = 0
            y = 0
            width = a1
            height = a2
        else:
            x = a1
            y = a2
            width = a3
            height = a4
        self._width = width
        self._height = height
        self.set_location(x, y)

# Public method: set_size

    def set_size(self, width, height=None):
        """
        Changes the size of this rectangle as specified.
        """
        if isinstance(width, GDimension):
            width, height = width.get_width(), width.get_height()
        self._width = width
        self._height = height
        gw = self._get_window()
        if gw is None:
            return
        tkc = gw._canvas
        coords = tkc.coords(self._tkid)
        tkc.coords(self._tkid, coords[0], coords[1],
                   coords[0] + width, coords[1] + height)

# Public method: set_bounds

    def set_bounds(self, x, y=None, width=None, height=None):
        """
        Changes the bounds of this rectangle to the specified values.
        """
        if isinstance(x, GRectangle):
            width, height = x.get_width(), x.get_height()
            x, y = x.get_x(), x.get_y()
        self.set_location(x, y)
        self.set_size(width, height)

# Override method: get_bounds

    def get_bounds(self):
        """
        Returns the bounds of this <code>GRect</code>.
        """
        ctm = self._ctm_base
        lctm = _GTransform(tx=self._x + ctm._tx,
                           ty=self._y + ctm._ty,
                           rotation=self._angle + ctm._rotation,
                           sf=self._sf * ctm._sf)
        p0 = lctm.transform(0, 0)
        bb = GRectangle(p0.get_x(), p0.get_y()) 
        bb.add(lctm.transform(self._width, 0))
        bb.add(lctm.transform(0, self._height))
        bb.add(lctm.transform(self._width, self._height))        
        return bb

# Override method: get_type

    def get_type(self):
        """
        Returns the type of this object.
        """
        return "GRect"

# Override method: _install

    def _install(self, target, ctm):
        """
        Installs the <code>GRect</code> in the canvas.
        """
        gw = target
        tkc = gw._canvas
        self._ctm_base = ctm
        lctm = _GTransform(rotation=self._angle + ctm._rotation,
                           sf=self._sf * ctm._sf)
        p0 = ctm.transform(self._x, self._y)
        if lctm._rotation == 0:
            self._rep = "Rectangle"
            p1 = ctm.transform(self._x + self._width, self._y + self._height)
            self._tkid = tkc.create_rectangle(p0._x, p0._y, p1._x, p1._y,
                                              width=self._line_width)
        else:
            self._rep = "Polygon"
            coords = self._create_rect_coords(p0._x, p0._y,
                                              self._width, self._height, lctm)
            self._tkid = tkc.create_polygon(*coords, width=self._line_width)
        self._update_color()
        self._update_visible()

# Override method: _update_rotation

    def _update_rotation(self):
        """
        Updates the points for this <code>GRect</code> after a rotation.
        """
        gw = self._get_window()
        if gw is not None:
            if self._rep == "Rectangle":
                gw._rebuild()
            else:
                tkc = gw._canvas
                ctm = self._ctm_base
                lctm = _GTransform(rotation=self._angle + ctm._rotation,
                                   sf=self._sf * ctm._sf)
                p0 = ctm.transform(self._x, self._y)
                coords = self._create_rect_coords(p0._x, p0._y,
                                                  self._width, self._height,
                                                  lctm)
                tkc.coords(self._tkid, *coords)

# Private method: _create_rect_coords

    def _create_rect_coords(self, x, y, width, height, ctm):
        p1 = ctm.transform(width, 0)
        p2 = ctm.transform(width, height)
        p3 = ctm.transform(0, height)
        return [ x, y,
                 x + p1._x, y + p1._y,
                 x + p2._x, y + p2._y,
                 x + p3._x, y + p3._y ]

# Override method: __str__

    def __str__(self):
        return ("GRect(" + str(self._x) + ", " + str(self._y) + ", " +
                str(self._width) + ", " + str(self._height) + ")")

# Define camel-case names

    setSize = set_size
    setBounds = set_bounds
    getBounds = get_bounds
    getType = get_type

# Class: GOval

class GOval(GFillableObject):
    """
    This graphical object subclass represents an oval inscribed in
    a rectangular box.
    """

# Constructor: GOval

    def __init__(self, a1, a2, a3=None, a4=None):
        """
        The <code>GOval</code> constructor takes either of the following
        forms:

        <pre>
           GOval(width, height)
           GOval(x, y, width, height)
        </pre>

        If the <code>x</code> and <code>y</code> parameters are missing,
        the origin is set to (0, 0).
        """
        GFillableObject.__init__(self)
        if a3 is None:
            x = 0
            y = 0
            width = a1
            height = a2
        else:
            x = a1
            y = a2
            width = a3
            height = a4
        self._width = width
        self._height = height
        self.set_location(x, y)

# Public method: set_size

    def set_size(self, width, height=None):
        """
        Changes the size of this oval as specified.
        """
        if isinstance(width, GDimension):
            width, height = width.get_width(), width.get_height()
        self._width = width
        self._height = height
        gw = self._get_window()
        if gw is None:
            return
        tkc = gw._canvas
        coords = tkc.coords(self._tkid)
        tkc.coords(self._tkid, coords[0], coords[1],
                   coords[0] + width, coords[1] + height)

# Public method: set_bounds

    def set_bounds(self, x, y=None, width=None, height=None):
        """
        Changes the bounds of this rectangle to the specified values.
        """
        if isinstance(x, GRectangle):
            width, height = x.get_width(), x.get_height()
            x, y = x.get_x(), x.get_y()
        self.set_location(x, y)
        self.set_size(width, height)

# Override method: get_bounds

    def get_bounds(self):
        """
        Returns the bounds of this <code>GOval</code>.
        """
        return GRectangle(self._x, self._y, self._width, self._height)

# Override method: contains

    def contains(self, x, y):
        rx = self._width / 2
        ry = self._height / 2
        tx = x - (self._x + rx)
        ty = y - (self._y + ry)
        return (tx * tx) / (rx * rx) + (ty * ty) / (ry * ry) <= 1.0

# Override method: get_type

    def get_type(self):
        """
        Returns the type of this object.
        """
        return "GOval"

# Override method: _install

    def _install(self, target, ctm):
        """
        Installs the <code>GOval</code> in the canvas.
        """
        gw = target
        tkc = gw._canvas
        self._ctm_base = ctm
        lctm = _GTransform(rotation=self._angle + ctm._rotation,
                           sf=self._sf * ctm._sf)
        p0 = ctm.transform(self._x, self._y)
        if lctm._rotation == 0:
            self._rep = "Oval"
            lctm = ctm.compose(_GTransform(sf=self._sf))
            p1 = ctm.transform(self._x + self._width, self._y + self._height)
            self._tkid = tkc.create_oval(p0._x, p0._y, p1._x, p1._y,
                                         width=self._line_width)
        else:
            self._rep = "Polygon"
            coords = self._create_oval_coords(p0._x, p0._y,
                                              self._width, self._height, lctm)
            self._tkid = tkc.create_polygon(*coords, width=self._line_width,
                                            smooth=1)
        self._update_color()
        self._update_visible()

# Override method: _update_rotation

    def _update_rotation(self):
        """
        Updates the points for this <code>GOval</code> after a rotation.
        """
        gw = self._get_window()
        if gw is not None:
            if self._rep == "Oval":
                gw._rebuild()
            else:
                tkc = gw._canvas
                ctm = self._ctm_base
                lctm = _GTransform(rotation=self._angle + ctm._rotation,
                                   sf=self._sf * ctm._sf)
                p0 = ctm.transform(self._x, self._y)
                coords = self._create_oval_coords(p0._x, p0._y,
                                                  self._width, self._height,
                                                  lctm)
                tkc.coords(self._tkid, *coords)

# Private method: _create_oval_coords

    def _create_oval_coords(self, x, y, width, height, ctm):
        n = 16
        dth = 360 / n
        r1 = width / 2
        r2 = height / 2
        coords = [ ]
        for i in range(0, n):
            theta = math.radians(i * dth)
            pt = ctm.transform(r1 + r1 * math.cos(theta),
                               r2 - r2 * math.sin(theta))
            coords.append(x + pt._x)
            coords.append(y + pt._y)
        return coords

# Override method: __str__

    def __str__(self):
        return ("GOval(" + str(self._x) + ", " + str(self._y) + ", " +
                str(self._width) + ", " + str(self._height) + ")")

# Define camel-case names

    setSize = set_size
    setBounds = set_bounds
    getBounds = get_bounds
    getType = get_type

# Class: GCompound

class GCompound(GObject):
    """
    This graphical object subclass consists of a collection of other
    graphical objects.  Once assembled, the internal objects can be
    manipulated as a unit.  The <code>GCompound</code> keeps track
    of its own position, and all items within it are drawn relative
    to that location.
    """

# Constructor: GCompound

    def __init__(self):
        """
        Creates a <code>GCompound</code> with no internal components.
        """
        GObject.__init__(self)
        self._contents = [ ]

# Public method: add

    def add(self, gobj, x=None, y=None):
        """
        Adds a new graphical object to the <code>GCompound</code>.  The
        first parameter is the object to be added.  The <code>x</code>
        and <code>y</code> parameters are optional.  If they are supplied,
        the location of the object is set to (<code>x</code>, <code>y</code>).
        """
        if x is not None:
            gobj.set_location(x, y)
        self._contents.append(gobj)
        gobj._parent = self
        if self._gw is None:
            gw = self._get_window()
            if gw is not None:
                gw._rebuild()
        else:
            gobj._install(self._gw, _GTransform())

# Public method: remove

    def remove(self, gobj):
        """
        Removes the specified object from the <code>GCompound</code>.
        """
        index = self._find_gobject(gobj)
        if index != -1:
            self._remove_at(index)
        gw = self._get_window()
        if gw is not None:
            gw._rebuild()

# Public method: remove_all

    def remove_all(self):
        """
        Removes all graphical objects from the <code>GCompound</code>.
        """
        while len(self._contents) > 0:
            self._remove_at(0)
        gw = self._get_window()
        if gw is not None:
            gw._rebuild()

# Public method: get_element_at

    def get_element_at(self, x, y):
        """
        Returns the topmost <code>GObject</code> containing the
        point (x, y), or <code>None</code> if no such object exists.
        Coordinates are interpreted relative to the reference point.
        """
        for gobj in reversed(self._contents):
            if gobj.contains(x, y):
                return gobj
        return None

# Public method: get_element_count

    def get_element_count(self):
        """
        Returns the number of graphical objects stored in the
        <code>GCompound</code>.
        """
        return len(self._contents)

# Public method: get_element

    def get_element(self, index):
        """
        Returns the graphical object at the specified index, numbering
        from back to front in the the <i>z</i> dimension.
        """
        return self._contents[index]

# Override method: get_bounds

    def get_bounds(self):
        """
        Returns a bounding rectangle for this compound.
        """
        x0 = self._x
        y0 = self._y
        if len(self._contents) == 0:
            return GRectangle(x0, y0, 0, 0)
        x_min = sys.float_info.max
        y_min = sys.float_info.max
        x_max = sys.float_info.min
        y_max = sys.float_info.min
        for gobj in self._contents:
            bounds = gobj.get_bounds()
            x_min = min(x_min, x0 + bounds._x)
            y_min = min(y_min, y0 + bounds._y)
            x_max = max(x_max, x0 + bounds._x)
            y_max = max(y_max, y0 + bounds._y)
            x_min = min(x_min, x0 + bounds._x + bounds.get_width())
            y_min = min(y_min, y0 + bounds._y + bounds.get_height())
            x_max = max(x_max, x0 + bounds._x + bounds.get_width())
            y_max = max(y_max, y0 + bounds._y + bounds.get_height())
        return GRectangle(x_min, y_min, x_max - x_min, y_max - y_min)

# Public method: contains

    def contains(self, x, y):
        """
        Returns true if the specified point is inside the object.
        """
        refpt = self.get_location()
        tx = x - refpt._x
        ty = y - refpt._y
        for gobj in self._contents:
            if gobj.contains(tx, ty):
                return True
        return False

# Override method: get_type

    def get_type(self):
        """
        Returns the type of this object
        """
        return "GCompound"

# Public method: __str__

    def __str__(self):
        return "GCompound(...)"

# Override method: _update_location

    def _update_location(self):
        """
        Updates the location for this <code>GCompound</code> by
        rebuilding the entire window if the component is installed.
        """
        gw = self._get_window()
        if gw is not None:
            gw._rebuild()

# Override method: _update_rotation

    def _update_rotation(self):
        """
        Redraws the window on rotation.
        """
        gw = self._get_window()
        if gw is not None:
            gw._rebuild()

# Override method: _update_visible

    def _update_visible(self):
        """
        Redraws the window on set_visible
        """
        gw = self._get_window()
        if gw is not None:
            gw._rebuild()

# Override method: _install

    def _install(self, target, ctm):
        if self._visible:
            lctm = ctm.compose(_GTransform(self._x, self._y,
                                           rotation=self._angle, sf=self._sf))
            for gobj in self._contents:
                gobj._install(target, lctm)

# Internal method: _send_forward

    def _send_forward(self, gobj):
        index = self._find_gobject(gobj)
        if index == -1:
            return
        if index != len(self._contents) - 1:
            self._contents.pop(index)
            self._contents.insert(index + 1, gobj)
            gw = self._get_window()
            if gw is not None:
                gw._rebuild()

# Internal method: _send_to_front

    def _send_to_front(self, gobj):
        index = self._find_gobject(gobj)
        if index == -1:
            return
        if index != len(self._contents) - 1:
            self._contents.pop(index)
            self._contents.append(gobj)
            gw = self._get_window()
            if gw is not None:
                gw._rebuild()

# Internal method: _send_backward

    def _send_backward(self, gobj):
        index = self._find_gobject(gobj)
        if index == -1:
            return
        if index != 0:
            self._contents.pop(index)
            self._contents.insert(index - 1, gobj)
            gw = self._get_window()
            if gw is not None:
                gw._rebuild()

# Internal method: _send_to_back

    def _send_to_back(self, gobj):
        index = self._find_gobject(gobj)
        if index == -1:
            return
        if index != 0:
            self._contents.pop(index)
            self._contents.insert(0, gobj)
            gw = self._get_window()
            if gw is not None:
                gw._rebuild()

# Internal method: _find_gobject

    def _find_gobject(self, gobj):
        n = len(self._contents)
        for i in range(n):
            if self._contents[i] == gobj:
                return i
        return -1

# Internal method: _remove_at

    def _remove_at(self, index):
        gobj = self._contents[index]
        self._contents.pop(index)
        gobj._parent = None

# Define camel-case names

    removeAll = remove_all
    getElementAt = get_element_at
    getElementCount = get_element_count
    getElement = get_element
    getBounds = get_bounds
    getType = get_type

# Class: GArc

class GArc(GFillableObject):
    """
    This graphical object subclass represents an elliptical arc.  The
    arc is specified by the following parameters:

    <ul>
       <li>The coordinates of the bounding rectangle (x, y, width, height)</li>
       <li>The angle at which the arc starts (start)</li>
       <li>The number of degrees that the arc covers (sweep)</li>
    </ul>

    All angles in a <code>GArc</code> description are measured in
    degrees moving counterclockwise from the +<i>x</i> axis.  Negative
    values for either <code>start</code> or <code>sweep</code> indicate
    motion in a clockwise direction.
    """

# Constructor: GArc

    def __init__(self, a1, a2, a3=None, a4=None, a5=None, a6=None):
        """
        The <code>GArc</code> constructor takes either of the following
        forms:

        <pre>
           GArc(width, height, start, sweep)
           GArc(x, y, width, height, start, sweep)
        </pre>

        If the <code>x</code> and <code>y</code> parameters are missing,
        the origin is set to (0, 0).
        """
        GFillableObject.__init__(self)
        if a5 is None:
            x = 0
            y = 0
            width = a1
            height = a2
            start = a3
            sweep = a4
        else:
            x = a1
            y = a2
            width = a3
            height = a4
            start = a5
            sweep = a6
        self._frame_width = width
        self._frame_height = height
        self._start = start
        self._sweep = sweep
        self.set_location(x, y)

# Public method: set_start_angle

    def set_start_angle(self, start):
        """
        Sets the starting angle for this <code>GArc</code> object.
        """
        self._start = start
        self._update_properties(start=start)

# Public method: get_start_angle

    def get_start_angle(self):
        """
        Returns the starting angle for this GArc object.
        """
        return self._start

# Public method: set_sweep_angle

    def set_sweep_angle(self, sweep):
        """
        Sets the sweep angle for this GArc object.
        """
        self._sweep = sweep
        self._update_properties(extent=sweep)

# Public method: get_sweep_angle

    def get_sweep_angle(self):
        """
        Returns the sweep angle for this GArc object.
        """
        return self._sweep

# Public method: get_start_point

    def get_start_point(self):
        """
        Returns the point at which the arc starts.
        """
        return self._get_arc_point(self._start)

# Public method: get_end_point

    def get_end_point(self):
        """
        Returns the point at which the arc ends.
        """
        return self._get_arc_point(self._start + self._sweep)

# Public method: set_frame_rectangle

    def set_frame_rectangle(self, x, y=None, width=None, height=None):
        """
        Changes the boundaries of the rectangle used to frame the arc.
        """
        if isinstance(x, GRectangle):
            width, height = x.get_width(), x.get_height()
            x, y = x.get_x(), x.get_y()
        self.set_location(x, y)
        gw = self._get_window()
        if gw is None:
            return
        tkc = gw._canvas
        coords = tkc.coords(self._tkid)
        tkc.coords(self._tkid, coords[0], coords[1],
                   coords[0] + width, coords[1] + height)

# Public method: get_frame_rectangle

    def get_frame_rectangle(self):
        """
        Returns the boundaries of the rectangle used to frame the arc.
        """
        return GRectangle(self._x, self._y,
                          self._frame_width, self._frame_height)

# Override method: set_filled

    def set_filled(self, flag):
        """
        Sets the fill status for the arc, where <code>False</code> is
        outlined and <code>True</code> is filled.  If a <code>GArc</code>
        is unfilled, the figure consists only of the arc itself.  If a
        <code>GArc</code> is filled, the figure consists of the
        pie-shaped wedge formed by connecting the endpoints of the arc to
        the center.
        """
        GFillableObject.set_filled(self, flag)
        style = tkinter.ARC
        if flag:
            style = tkinter.PIESLICE
        self._update_properties(style=style)

# Public method: get_bounds

    def get_bounds(self):
        """
        Gets the bounding rectangle for this object
        """
        rx = self._frame_width / 2
        ry = self._frame_height / 2
        cx = self._x + rx
        cy = self._y + ry
        start_radians = self._start * math.pi / 180
        sweep_radians = self._sweep * math.pi / 180
        p1x = cx + math.cos(start_radians) * rx
        p1y = cy - math.sin(start_radians) * ry
        p2x = cx + math.cos(start_radians + sweep_radians) * rx
        p2y = cy - math.sin(start_radians + sweep_radians) * ry
        x_min = min(p1x, p2x)
        x_max = max(p1x, p2x)
        y_min = min(p1y, p2y)
        y_max = max(p1y, p2y)
        if self._contains_angle(0):
            x_max = cx + rx
        if self._contains_angle(90):
            y_min = cy - ry
        if self._contains_angle(180):
            x_min = cx - rx
        if self._contains_angle(270):
            y_max = cy + ry
        if self._fill_flag:
            x_min = min(x_min, cx)
            y_min = min(y_min, cy)
            x_max = max(x_max, cx)
            y_max = max(y_max, cy)
        return GRectangle(x_min, y_min, x_max - x_min, y_max - y_min)

# Public method: contains

    def contains(self, x, y):
        """
        Returns true if the specified point is inside the object.
        """
        rx = self._frame_width / 2
        ry = self._frame_height / 2
        if rx == 0 or ry == 0:
            return False
        dx = x - (self._x + rx)
        dy = y - (self._y + ry)
        r = (dx * dx) / (rx * rx) + (dy * dy) / (ry * ry)
        if self._fill_flag:
            if r > 1.0:
                return False
        else:
            t = __ARC_TOLERANCE__ / ((rx + ry) / 2)
            if abs(1.0 - r) > t:
                return False
        return self._contains_angle(math.atan2(-dy, dx) * 180 / math.pi)

# Override method: get_type

    def get_type(self):
        """
        Returns the type of this object
        """
        return "GArc"

# Public method: __str__

    def __str__(self):
        return ("GArc(" + str(self._x) + ", " + str(self._y) + ", " +
                str(self._frame_width) + ", " +
                str(self._frame_height) + ", " +
                str(self._start) + ", " + str(self._sweep) + ")")

# Override method: _install

    def _install(self, target, ctm):
        """
        Installs the <code>GArc</code> in the canvas.
        """
        gw = target
        tkc = gw._canvas
        lctm = _GTransform(rotation=self._angle + ctm._rotation,
                           sf=self._sf * ctm._sf)
        p0 = ctm.transform(self._x, self._y)
        if lctm._rotation == 0:
            p1 = ctm.transform(self._x + self._frame_width,
                               self._y + self._frame_height)
            if abs(self._sweep) >= 360:
                self._rep = "Oval"
                self._tkid = tkc.create_oval(p0._x, p0._y, p1._x, p1._y,
                                             width=self._line_width)
            else:
                self._rep = "Arc"
                style = tkinter.ARC
                if self._fill_flag:
                    style = tkinter.PIESLICE
                self._tkid = tkc.create_arc(p0._x, p0._y, p1._x, p1._y,
                                            start=self._start,
                                            extent=self._sweep,
                                            width=self._line_width,
                                            style=style)
        else:
            self._rep = "Polygon"
            if self._fill_flag:
                coords = self._create_arc_coords(p0._x, p0._y,
                                                 self._frame_width,
                                                 self._frame_height,
                                                 self._start, self._sweep,
                                                 True, lctm)
                self._tkid = tkc.create_polygon(*coords,
                                                width=self._line_width,
                                                smooth=1)
            else:
                coords = self._create_arc_coords(p0._x, p0._y,
                                                 self._frame_width,
                                                 self._frame_height,
                                                 self._start, self._sweep,
                                                 False, lctm)
                self._tkid = tkc.create_line(*coords,
                                             width=self._line_width,
                                             smooth=1)
        self._update_color()
        self._update_visible()

# Override method: set_filled

    def set_filled(self, flag):
        GFillableObject.set_filled(self, flag)
        gw = self._get_window()
        if gw is not None:
            gw._rebuild()

# Override method: _update_rotation

    def _update_rotation(self):
        """
        Updates the points for this <code>GArc</code> after a rotation.
        """
        gw = self._get_window()
        if gw is not None:
            tkc = gw._canvas
            ctm = self._ctm_base
            lctm = _GTransform(rotation=self._angle + ctm._rotation,
                               sf=self._sf * ctm._sf)
            coords = self._create_arc_coords(p0._x, p0._y,
                                             self._frame_width,
                                             self._frame_height,
                                             self._start, self._sweep,
                                             self._fill_flag, lctm)
            tkc.coords(self._tkid, *coords)

# Override method: _update_color

    def _update_color(self):
        """
        Updates the color properties for a <code>GArc</code>.
        """
        if self._fill_flag:
            outline = self._color
            fill = self._fill_color
            if fill is None or fill == "":
                fill = outline
            self._update_properties(outline=outline, fill=fill)
        else:
            if self._rep == "Oval":
                self._update_properties(fill='')
            else:
                self._update_properties(fill=self._color)

# Private method: _create_arc_coords

    def _create_arc_coords(self, x, y, width, height, start, sweep, fill, ctm):
        """
        Creates an array of coordinates for an elliptical arc inside the
        bounding box with the specified start and sweep values.  The ctm
        parameter represents the local transformation.
        """
        n = max(3, round(abs(sweep) / 30))
        dth = sweep / n
        r1 = width / 2
        r2 = height / 2
        coords = [ ]
        for i in range(0, n + 1):
            theta = math.radians(start + i * dth)
            pt = ctm.transform(r1 + r1 * math.cos(theta),
                               r2 - r2 * math.sin(theta))
            coords.append(x + pt._x)
            coords.append(y + pt._y)
        if fill:
            pt = ctm.transform(r1, r2)
            center = [ x + pt._x, y + pt._y ]
            coords = center + coords[0:2] + coords + coords[-2:]
        return coords
        
# Private method: _get_arc_point

    def _get_arc_point(self, theta):
        rx = self._frame_width / 2
        ry = self._frame_height / 2
        cx = self._x + rx
        cy = self._y + ry
        radians = theta * math.pi / 180
        return GPoint(cx + rx * math.cos(radians), cy - ry * math.sin(radians))

# Private method: _get_arc_point

    def _get_arc_point(self, theta):
        rx = self._frame_width / 2
        ry = self._frame_height / 2
        cx = self._x + rx
        cy = self._y + ry
        radians = theta * math.pi / 180
        return GPoint(cx + rx * math.cos(radians), cy - ry * math.sin(radians))

# Private method: _contains_angle

    def _contains_angle(self, theta):
        start = min(self._start, self._start + self._sweep)
        sweep = abs(self._sweep)
        if sweep >= 360:
            return True
        if theta < 0:
            theta = 360 - math.fmod(-theta, 360)
        else:
            theta = math.fmod(theta, 360)
        if start < 0:
            start = 360 - math.fmod(-start, 360)
        else:
            start = math.fmod(start, 360)
        if start + sweep > 360:
            return (theta >= start or theta <= start + sweep - 360)
        else:
            return (theta >= start and theta <= start + sweep)

# Define camel-case names

    setStartAngle = set_start_angle
    getStartAngle = get_start_angle
    setSweepAngle = set_sweep_angle
    getSweepAngle = get_sweep_angle
    getStartPoint = get_start_point
    getEndPoint = get_end_point
    setFrameRectangle = set_frame_rectangle
    getFrameRectangle = get_frame_rectangle
    setFilled = set_filled
    getBounds = get_bounds
    getType = get_type

# Class: GLine

class GLine(GObject):
    """
    This graphical object subclass represents a line segment.
    """

# Constructor: GLine

    def __init__(self, x0, y0, x1, y1):
        """
        Initializes a line segment from its endpoints.  The point
        (<code>x0</code>, <code>y0</code>) defines the start of the
        line and the point (<code>x1</code>, <code>y1</code>) defines
        the end.
        """
        GObject.__init__(self)
        self._x = x0
        self._y = y0
        self._dx = x1 - x0
        self._dy = y1 - y0

# Public method: set_start_point

    def set_start_point(self, x, y):
        """
        Sets the initial point to (<code>x</code>, <code>y</code>),
        leaving the end point unchanged.  This method is therefore
        different from <code>set_location</code>, which moves both
        components of the line segment.
        """
        self._dx += self._x - x
        self._dy += self._y - y
        self._x = x
        self._y = y
        self._update_points()

# Public method: get_start_point

    def get_start_point(self):
        """
        Returns the point at which the line starts.
        """
        return GPoint(self._x, self._y)

# Public method: set_end_point

    def set_end_point(self, x, y):
        """
        Sets the end point in the line to (x, y), leaving the start point
        unchanged.
        """
        self._dx = x - self._x
        self._dy = y - self._y
        self._update_points()

# Public method: get_end_point

    def get_end_point(self):
        """
        Returns the point at which the line ends.
        """
        return GPoint(self._x + self._dx, self._y + self._dy)

# Overload method: contains

    def contains(self, x, y):
        """
        Returns true if the specified point is inside the object.
        """
        x0 = self._x
        y0 = self._y
        x1 = x0 + self._dx
        y1 = y0 + self._dy
        t_squared = __LINE_TOLERANCE__ * __LINE_TOLERANCE__
        if _dsq(x, y, x0, y0) < t_squared:
            return True
        if _dsq(x, y, x1, y1) < t_squared:
            return True
        if x < min(x0, x1) - __LINE_TOLERANCE__:
            return False
        if x > max(x0, x1) + __LINE_TOLERANCE__:
            return False
        if y < min(y0, y1) - __LINE_TOLERANCE__:
            return False
        if y > max(y0, y1) + __LINE_TOLERANCE__:
            return False
        if (x0 - x1) == 0 and (y0 - y1) == 0:
            return False
        d = _dsq(x0, y0, x1, y1)
        u = ((x - x0) * (x1 - x0) + (y - y0) * (y1 - y0)) / d
        return _dsq(x, y, x0 + u * (x1 - x0), y0 + u * (y1 - y0)) < t_squared

# Override method: get_type

    def get_type(self):
        """
        Returns the type of this object
        """
        return "GLine"

# Public method: __str__

    def __str__(self):
        return ("GLine(" + str(self._x) + ", " + str(self._y) + ", " +
                str(self._x + self._dx) + ", " + str(self._y + self._dy) + ")")

# Override method: get_bounds

    def get_bounds(self):
        """
        Returns the bounds of this <code>GLine</code>.
        """
        x0 = min(self._x, self._x + self._dx)
        y0 = min(self._y, self._y + self._dy)
        x1 = max(self._x, self._x + self._dx)
        y1 = max(self._y, self._y + self._dy)
        return GRectangle(x0, y0, x1 - x0, y1 - y0)

# Override method: _install

    def _install(self, target, ctm):
        """
        Installs the <code>GLine</code> in the canvas.
        """
        gw = target
        tkc = gw._canvas
        self._base_ctm = ctm
        p0 = ctm.transform(self._x, self._y)
        angle = ctm._rotation + self._angle
        ctm = _GTransform(rotation=angle, sf=ctm._sf)
        deltas = ctm.transform(self._dx, self._dy)
        x1 = p0._x + deltas._x
        y1 = p0._y + deltas._y
        dp = ctm.transform(self._dx, self._dy)
        self._tkid = tkc.create_line(p0._x, p0._y,
                                     p0._x + dp._x, p0._y + dp._y,
                                     width=self.get_line_width(),
                                     fill=self._color)
        self._update_visible()

# Override method: _update_points

    def _update_points(self):
        """
        Updates the points in the <code>GLine</code>.
        """
        gw = self._get_window()
        if gw is None:
            return
        tkc = gw._canvas
        ctm = self._base_ctm
        p0 = ctm.transform(self._x, self._y)
        angle = ctm._rotation + self._angle
        ctm = _GTransform(rotation=angle, sf=ctm._sf)
        dp = ctm.transform(self._dx, self._dy)
        tkc.coords(self._tkid, p0._x, p0._y, p0._x + dp._x, p0._y + dp._y)

# Override method: _update_rotation

    def _update_rotation(self):
        """
        Updates the points for this <code>GLine</code> after a rotation.
        """
        self._update_points()

# Define camel-case names

    setStartPoint = set_start_point
    getStartPoint = get_start_point
    setEndPoint = set_end_point
    getEndPoint = get_end_point
    getType = get_type

# Class: GImage

class GImage(GObject):
    """
    This graphical object subclass represents an image from a file.
    """

    def __init__(self, source, x=0, y=0):
        """
        Initializes a new image by loading the image from the specified
        source, which must be the name of a file containing the image, a
        URL that holds a remote image, or a two-dimensional array of pixels.
        """
        GObject.__init__(self)
        self._source = source
        self._image_model = _image_model
        if _image_model == "PIL":
            if isinstance(source, str):
                if "://" in source or source.startswith("data:"):
                    ctx = ssl.create_default_context()
                    ctx.check_hostname = False
                    ctx.verify_mode = ssl.CERT_NONE
                    with urllib.request.urlopen(source, context=ctx) as req:
                        self._image = Image.open(io.BytesIO(req.read()))
                else:
                    self._image = Image.open(source)
                self._image.load()
            else:
                width = len(source[0])
                height = len(source)
                ba = bytearray(4 * width * height)
                for i in range(height):
                    for j in range(width):
                        argb = source[i][j]
                        base = 4 * (i * width + j)
                        ba[base] = (argb >> 16) & 0xFF
                        ba[base + 1] = (argb >> 8) & 0xFF
                        ba[base + 2] = argb & 0xFF
                        ba[base + 3] = (argb >> 24) & 0xFF
                self._image = Image.frombytes("RGBA", (width, height),
                                              bytes(ba))
            self._photo = ImageTk.PhotoImage(self._image)
        else:
            if isinstance(source, str):
                self._photo = tkinter.PhotoImage(file=source)
            else:
                raise ImportError("get_pixel_array requires the " +
                                  "Pillow library")
        self.set_location(x, y)
        self._sf = 1

# Public method: get_bounds

    def get_bounds(self):
        """
        Returns the bounding rectangle for this object
        """
        photo = self._photo
        return GRectangle(self._x, self._y, photo.width(), photo.height())

# Public method: get_pixel_array

    def get_pixel_array(self):
        """
        Returns a two-dimensional array of integers containing the pixel data.
        """
        if self._image_model == "PIL":
            image = self._image
            width = image.width
            height = image.height
        else:
            width = self._photo.width()
            height = self._photo.height()
        pixels = height * [ [ 0 ] ]
        for y in range(height):
            pixels[y] = width * [ 0 ]
        if self._image_model == "PIL":
            data = image.convert("RGBA").getdata()
            i = 0
            for i in range(height):
                for j in range(width):
                    rgba = data[i * width + j]
                    p = rgba[3] << 24 | rgba[0] << 16 | rgba[1] << 8 | rgba[2]
                    pixels[i][j] = p
        return pixels

# Override method: scale

    def scale(self, sf):
        """
        Scales the GImage by the specified scale factor.
        """
        if self._image_model != "PIL":
            raise Exception("Image scaling is available only if PIL is loaded")
        self._sf *= sf
        gw = self._get_window()
        if gw is not None:
            gw._rebuild()

# Override method: get_type

    def get_type(self):
        """
        Returns the type of this object.
        """
        return "GImage"

# Override method: _install

    def _install(self, target, ctm):
        """
        Installs the <code>GImage</code> in the canvas.
        """
        gw = target
        tkc = gw._canvas
        pt = ctm.transform(self._x, self._y)
        x = pt._x
        y = pt._y
        ctm = ctm.compose(_GTransform(rotation=self._angle, sf=self._sf))
        img = self._image
        rotation = ctm._rotation % 360
        if ctm._sf != 1:
            w = round(img.width * ctm._sf)
            h = round(img.height * ctm._sf)
            img = img.resize((w, h), Image.LANCZOS)
        if rotation != 0:
            w = img.width 
            h = img.height
            img = img.rotate(rotation, expand=True)
            if rotation > 0 and rotation <= 90:
                theta = math.radians(rotation)
                y -= w * math.sin(theta)
            elif rotation > 90 and rotation <= 180:
                theta = math.radians(rotation - 90)
                x -= w * math.sin(theta)
                y -= h * math.sin(theta) + w * math.cos(theta)
            elif rotation > 180 and rotation <= 270:
                theta = math.radians(rotation - 180)
                x -= h * math.sin(theta) + w * math.cos(theta)
                y -= h * math.cos(theta)
            else:
                theta = math.radians(rotation - 270)
                x -= h * math.cos(theta)            
        self._photo = ImageTk.PhotoImage(img)
        self._tkid = tkc.create_image(x, y,
                                      anchor=tkinter.NW,
                                      image=self._photo)
        self._update_visible()

# Override method: _update_rotation

    def _update_rotation(self):
        """
        Updates this <code>GImage</code> after a rotation.
        """
        gw = self._get_window()
        if gw is not None:
            gw._rebuild()

# Static method: get_red

    @staticmethod
    def get_red(pixel):
        """
        Returns the red component of the pixel.
        """
        return pixel >> 16 & 0xFF

# Static method: get_green

    @staticmethod
    def get_green(pixel):
        """
        Returns the green component of the pixel.
        """
        return pixel >> 8 & 0xFF

# Static method: get_blue

    @staticmethod
    def get_blue(pixel):
        """
        Returns the blue component of the pixel.
        """
        return pixel & 0xFF

# Static method: get_alpha

    @staticmethod
    def get_alpha(pixel):
        """
        Returns the alpha component of the pixel.
        """
        return pixel >> 24 & 0xFF

# Static method: create_rgb_pixel

    @staticmethod
    def create_rgb_pixel(a1=None, a2=None, a3=None, a4=None, **kw):
        """
        Creates an RGB pixel from the arguments.  The kw dictionary allows
        clients to name these parameters to override the conventional order.
        """
        if a4 is None:
            a = 0xFF
            r = a1
            g = a2
            b = a3
        else:
            a = a1
            r = a2
            g = a3
            b = a4
        if "alpha" in kw:
            a = kw["alpha"]
        if "red" in kw:
            r = kw["red"]
        if "green" in kw:
            g = kw["green"]
        if "blue" in kw:
            b = kw["blue"]
        return a << 24 | (r & 0xFF) << 16 | (g & 0xFF) << 8 | (b & 0xFF)

# Public method: __str__

    def __str__(self):
        if isinstance(self._image, str):
            return "GImage(\"" + self._source + "\")"
        else:
            return "GImage(<data>)"

# Define camel-case names

    getBounds = get_bounds
    getPixelArray = get_pixel_array
    getType = get_type
    getRed = get_red
    getGreen = get_green
    getBlue = get_blue
    getAlpha = get_alpha
    createRGBPixel = create_rgb_pixel

# Class: GLabel

class GLabel(GObject):
    """
    This graphical object subclass represents a text string.
    """

# Constants

    DEFAULT_FONT = "13pt 'Helvetica Neue','Helvetica','Arial','Sans-Serif'"

# Constructor: GLabel

    def __init__(self, text, x=0, y=0):
        """
        Initializes a <code>GLabel</code> object containing the specified
        string.  By default, the baseline of the first character appears
        at the origin.
        """
        GObject.__init__(self)
        self._text = text
        self._font = self.DEFAULT_FONT
        self._tk_font = _decode_font(self._font)
        self.set_location(x, y)

# Public method: set_font

    def set_font(self, font):
        """
        Changes the font used to display the GLabel as specified by
        <code>font</code>, which has the form <code>family-style-size</code>,
        where both <code>style</code> and <code>size</code> are optional.
        """
        self._font = font
        self._tk_font = _decode_font(self._font)
        self._update_properties(font=self._tk_font)
        self._update_location()

# Public method: get_font

    def get_font(self):
        """
        Returns the current font for the GLabel.
        """
        return self._font

# Public method: set_label

    def set_label(self, text):
        """
        Changes the string stored within the GLabel object, so that
        a new text string appears on the display.
        """
        self._text = text
        self._update_properties(text=text)

# Public method: get_label

    def get_label(self):
        """
        Returns the string displayed by this object.
        """
        return self._text

# Public method: get_ascent

    def get_ascent(self):
        """
        Returns the maximum distance strings in this font extend above
        the baseline.
        """
        return self._tk_font.metrics("ascent")

# Public method: get_descent

    def get_descent(self):
        """
        Returns the maximum distance strings in this font descend below
        the baseline.
        """
        return self._tk_font.metrics("descent")

# Override method: get_width

    def get_width(self):
        """
        Returns the width for this <code>GLabel</code>.
        """
        return self._tk_font.measure(self._text)

# Override method: get_height

    def get_height(self):
        """
        Returns the height for this <code>GLabel</code>.
        """
        return self._tk_font.metrics("linespace")

# Override method: get_bounds

    def get_bounds(self):
        """
        Returns the bounding rectangle for this object.
        """
        return GRectangle(self._x, self._y - self.get_ascent(),
                          self.get_width(), self.get_height())

# Override method: get_type

    def get_type(self):
        """
        Returns the type of this object.
        """
        return "GLabel"

# Override method: _update_location

    def _update_location(self):
        """
        Updates the location for this <code>GLabel</code> from the stored
        x and y values.  This override is necessary to adjust for the
        baseline.
        """
        gw = self._get_window()
        if gw is None:
            return
        tkc = gw._canvas
        coords = tkc.coords(self._tkid)
        offx = 0
        offy = self.get_height() - self.get_ascent()
        gobj = self.get_parent()
        while gobj is not None:
            offx += gobj._x
            offy += gobj._y
            gobj = gobj.get_parent()
        dx = (self._x + offx) - coords[0]
        dy = (self._y + offy) - coords[1]
        tkc.move(self._tkid, dx, dy)

# Override method: _install

    def _install(self, target, ctm):
        """
        Installs the <code>GLabel</code> in the canvas.
        """
        gw = target
        tkc = gw._canvas
        self._ctm_base = ctm
        pt = ctm.transform(self._x, self._y)
        dtm = _GTransform(rotation=self._angle, sf=self._sf)
        ctm = ctm.compose(dtm)
        dp = dtm.transform(0, self.get_height() - self.get_ascent())
        x = pt._x + dp._x
        y = pt._y + dp._y
        baseline = y
        if ctm.get_rotation() == 0:
            self._tkid = tkc.create_text(x,
                                         baseline,
                                         text=self._text,
                                         font=self._tk_font,
                                         fill=self._color,
                                         anchor="sw")
        else:
            try:
                self._tkid = tkc.create_text(x,
                                             baseline,
                                             text=self._text,
                                             font=self._tk_font,
                                             fill=self._color,
                                             angle=ctm.get_rotation(),
                                             anchor="sw")
            except:
                raise Exception("GLabel rotation requires tkinter v6")
        self._update_visible()

# Override method: _update_rotation

    def _update_rotation(self):
        """
        Updates this <code>GLabel</code> after a rotation.
        """
        gw = self._get_window()
        if gw is None:
            return
        ctm = self._ctm_base
        ctm = ctm.compose(_GTransform(rotation=self._angle, sf=self._sf))
        self._update_properties(angle=ctm.get_rotation())

# Override method: __str__

    def __str__(self):
        return "GLabel(\"" + self._text + "\")"

# Define camel-case names

    setFont = set_font
    getFont = get_font
    setLabel = set_label
    getLabel = get_label
    getAscent = get_ascent
    getDescent = get_descent
    getWidth = get_width
    getHeight = get_height
    getBounds = get_bounds
    getType = get_type

# Class: GPolygon

class GPolygon(GFillableObject):
    """
    This graphical object subclass represents a polygon bounded by line
    segments.  The <code>GPolygon</code> constructor creates an empty
    polygon.  To complete the figure, you need to add vertices to the
    polygon using some combination of the methods <code>add_vertex</code>,
    <code>add_edge</code>, and <code>add_polar_edge</code>.
    """

# Constructor: GPolygon

    def __init__(self):
        """
        Initializes a new empty polygon at the origin.
        """
        GFillableObject.__init__(self)
        self._cx = None
        self._cy = None
        self._vertices = [ ]

# Public method: add_vertex

    def add_vertex(self, x, y):
        """
        Adds a vertex at (<code>x</code>, <code>y</code>) relative to the
        polygon origin.
        """
        self._cx = x
        self._cy = y
        self._vertices.append(GPoint(x, y))

# Public method: add_edge

    def add_edge(self, dx, dy):
        """
        Adds an edge to the polygon whose components are given by the
        displacements <code>dx</code> and <code>dy</code> from the
        last vertex.
        """
        self.add_vertex(self._cx + dx, self._cy + dy)

# Public method: add_polar_edge

    def add_polar_edge(self, r, theta):
        """
        Adds an edge to the polygon specified in polar coordinates.  The
        length of the edge is given by <code>r</code>, and the edge extends
        in direction <code>theta</code>, measured in degrees counterclockwise
        from the +<i>x</i> axis.
        """
        self.add_edge(r * math.cos(theta * math.pi / 180),
                      -r * math.sin(theta * math.pi / 180))

# Public method: get_vertices

    def get_vertices(self):
        """
        Returns a list of the points in the polygon.
        """
        return self._vertices

# Public method: get_bounds

    def get_bounds(self):
        """
        Returns the bounding rectangle for this object.
        """
        x_min = 0
        y_min = 0
        x_max = 0
        y_max = 0
        for i in range(len(self._vertices)):
            x = self._vertices[i]._x
            y = self._vertices[i]._y
            if i == 0 or x < x_min:
                x_min = x
            if i == 0 or y < y_min:
                y_min = y
            if i == 0 or x > x_max:
                x_max = x
            if i == 0 or y > y_max:
                y_max = y
        x0 = self._x
        y0 = self._y
        return GRectangle(x0 + x_min, y0 + y_min, x_max - x_min, y_max - y_min)

# Public method: contains

    def contains(self, x, y):
        """
        Returns true if the specified point is inside the object.
        """
        tx = x - self._x
        ty = y - self._y
        crossings = 0
        n = len(self._vertices)
        if n < 2:
            return False
        if self._vertices[0] == self._vertices[n - 1]:
            n = n - 1
        x0 = self._vertices[0]._x
        y0 = self._vertices[0]._y
        for i in range(1, n + 1):
            x1 = self._vertices[i % n]._x
            y1 = self._vertices[i % n]._y
            if (y0 > ty) != (y1 > ty):
                if tx - x0 < (x1 - x0) * (ty - y0) / (y1 - y0):
                    crossings = crossings + 1
            x0 = x1
            y0 = y1
        return (crossings % 2 == 1)

# Override method: get_type

    def get_type(self):
        """
        Returns the type of this object.
        """
        return "GPolygon"

# Override method: _update_location

    def _update_location(self):
        """
        Updates the location for this object from the stored x and y values.
        """
        gw = self._get_window()
        if gw is None:
            return
        tkc = gw._canvas
        coords = tkc.coords(self._tkid)
        oldx = coords[0]
        oldy = coords[1]
        coords = self._create_coords()
        dx = coords[0] - oldx
        dy = coords[1] - oldy
        tkc.move(self._tkid, dx, dy)

# Override method: _update_rotation

    def _update_rotation(self):
        """
        Updates this <code>GPolygon</code> after a rotation.
        """
        gw = self._get_window()
        if gw is None:
            return
        tkc = gw._canvas
        coords = self._create_coords()
        tkc.coords(self._tkid, *coords)

# Override method: _install

    def _install(self, target, ctm):
        """
        Installs the <code>GPolygon</code> in the canvas.
        """
        gw = target
        tkc = gw._canvas
        self._ctm_base = ctm
        coords = self._create_coords()
        self._tkid = tkc.create_polygon(*coords, width=self._line_width)
        self._update_color()
        self._update_visible()

# Override method: __str__

    def __str__(self):
        return "GPolygon(" + str(len(self._vertices)) + " vertices)"

# Private method: _create_coords

    def _create_coords(self):
        ctm = self._ctm_base
        ctm = ctm.compose(_GTransform(self._x, self._y,
                                      rotation=self._angle, sf=self._sf))
        coords = [ ]
        for pt in self._vertices:
            tp = ctm.transform(pt)
            coords.append(tp._x)
            coords.append(tp._y)
        return coords

# Define camel-case names

    addVertex = add_vertex
    addEdge = add_edge
    addPolarEdge = add_polar_edge
    getVertices = get_vertices
    getBounds = get_bounds
    getType = get_type

# Class: GPoint

class GPoint:
    """
    This class contains real-valued x and y fields. It is used to represent
    a location on the graphics plane.
    """

# Constructor: GPoint

    def __init__(self, x=0, y=0):
        """Initializes a point with the specified coordinates."""
        self._x = x
        self._y = y

# Public method: get_x

    def get_x(self):
        """Returns the x component of the point."""
        return self._x

# Public method: get_y

    def get_y(self):
        """Returns the y component of the point."""
        return self._y

# Public method: __str__

    def __str__(self):
        """Returns the string representation of a point."""
        return "(" + str(self._x) + ", " + str(self._y) + ")"

# Public method: __eq__

    def __eq__(self, other):
        """Returns a Boolean indicating whether two points are equal."""
        if isinstance(other, GPoint):
            return self._x == other._x and self._y == other._y
        return False

# Define camel-case names

    getX = get_x
    getY = get_y

# Class: GDimension

class GDimension:
    """
    This class contains real-valued witdth and height fields.  It is
    used to indicate the size of a graphical object.
    """

# Constructor: GDimension

    def __init__(self, width=0.0, height=0.0):
        """
        Initializes a <code>GDimension</code> object with the specified size.
        """
        self._width = width
        self._height = height

# Public method: get_width

    def get_width(self):
        """
        Returns the width component of the <code>GDimension</code>.
        """
        return self._width

# Public method: get_height

    def get_height(self):
        """
        Returns the height component of the <code>GDimension</code>.
        """
        return self._height

# Public method: __str__

    def __str__(self):
        return "(" + str(self._width) + ", " + str(self._height) + ")"

# Public method: __eq__

    def __eq__(self, other):
        if isinstance(other, GDimension):
            return (self._width == other._width and
                    self._height == other._height)
        return False

# Define camel-case names

    getWidth = get_width
    getHeight = get_height

# Class: GRectangle

class GRectangle:
    """
    This type contains real-valued x, y, width, and height fields. It is
    used to represent the bounding box of a graphical object.
    """

# Constructor: GRectangle

    def __init__(self, x=0.0, y=0.0, width=0.0, height=0.0):
        """
        Initializes a <code>GRectangle</code> object with the specified
        fields.
        """
        self._x = x
        self._y = y
        self._width = width
        self._height = height

# Public method: get_x

    def get_x(self):
        """
        Returns the x component of the upper left corner.
        """
        return self._x

# Public method: get_y

    def get_y(self):
        """
        Returns the x component of the upper left corner.
        """
        return self._y

# Public method: get_width

    def get_width(self):
        """
        Returns the width component of the GRectangle.
        """
        return self._width

# Public method: get_height

    def get_height(self):
        """
        Returns the width component of the GRectangle.
        """
        return self._height

# Public method: is_empty

    def is_empty(self):
        """
        Returns <code>True</code> if the rectangle is empty.
        """
        return self._width <= 0 or self._height <= 0

# Public method: add

    def add(self, x, y=None):
        """
        Adds a <code>GPoint</code> or <code>x</code>/<code>y</code> pair
        to this <code>GRectangle</code>.
        """
        if isinstance(x, GPoint):
            x, y = x.get_x(), x.get_y()
        elif isinstance(x, dict):
            x, y = x.x, x.y
        if x < self._x:
            self._width += self._x - x
            self._x = x
        elif x > self._x + self._width:
            self._width = x - self._x
        if y < self._y:
            self._height += self._y - y
            self._y = y
        elif y > self._y + self._height:
            self._height = y - self._y
        
# Public method: contains

    def contains(self, x, y=None):
        """
        Returns <code>True</code> if the specified point is inside the
        rectangle.
        """
        if isinstance(x, GPoint):
            x, y = x.get_x(), x.get_y()
        elif isinstance(x, dict):
            x, y = x.x, x.y
        return (x >= self._x and
                y >= self._y and
                x < self._x + self._width and
                y < self._y + self._height)

# Public method: __str__

    def __str__(self):
        return ("(" + str(self._x) + ", " + str(self._y) + ", " +
                str(self._width) + ", " + str(self._height) + ")")

# Public method: __eq__

    def __eq__(self, other):
        if isinstance(other, GRectangle):
            return (self._x == other._x and
                    self._y == other._y and
                    self._width == other._width and
                    self._height == other._height)
        return False

# Define camel-case names

    getX = get_x
    getY = get_y
    getWidth = get_width
    getHeight = get_height
    isEmpty = is_empty

# Class: GTimer

class GTimer:
    """
    This type implements a timer running in the window.  This class supports
    both one-shot and interval timers.
    """

# Constructor: GTimer

    def __init__(self, gw, fn, delay):
        """
        Creates a new GTimer that calls fn after the specified delay.
        """
        self._gw = gw
        self._fn = fn
        self._delay = delay
        self._repeats = False
        self._after_id = None
        gw._timers.append(self)

# Public method: set_repeats

    def set_repeats(self, flag):
        """
        Determines whether the timer should repeat.
        """
        self._repeats = flag

# Public method: set_delay

    def set_delay(self, delay):
        """
        Sets the delay time for this timer.
        """
        self._delay = delay

# Public method: start

    def start(self):
        """
        Starts the timer.
        """
        tkc = self._gw._canvas
        self._after_id = tkc.after(self._delay, self._timer_ticked)

# Public method: stop

    def stop(self):
        """
        Stops the timer.
        """
        if self._after_id is not None:
            tkc = self._gw._canvas
            tkc.after_cancel(self._after_id)
            self._after_id = None

# Private method: _timer_ticked

    def _timer_ticked(self):
        self._fn()
        if self._repeats and self._after_id is not None:
            tkc = self._gw._canvas
            self._after_id = tkc.after(self._delay, self._timer_ticked)

# Class: GEvent

class GEvent(object):
    """
    This type is the abstract superclass for all events in the graphics
    package.
    """

# Constructor: GEvent

    def __init__(self):
        """
        Creates a new <code>GEvent</code> object.  This method should
        not be called by clients.
        """

# Public abstract method: get_source

    def get_source(self):
        """
        Returns the source of this event.  Subclasses must override this
        method with an appropriate definition.
        """
        raise Exception("get_source is not defined in the base class")

# Class: GMouseEvent

class GMouseEvent(GEvent):
    """
    This class maintains the data for a mouse event.
    """

# Constructor: GMouseEvent

    def __init__(self, tke):
        """
        Creates a new <code>GMouseEvent</code> from the corresponding
        tkinter event tke.
        """
        self._x = tke.x
        self._y = tke.y

# Public method: get_x

    def get_x(self):
        """
        Returns the x coordinate of the mouse event.
        """
        return self._x

# Public method: get_y

    def get_y(self):
        """
        Returns the y coordinate of the mouse event.
        """
        return self._y

# Override method: get_source

    def get_source(self):
        """
        Returns the source of the mouse event, which is always the
        root window.
        """
        return tkinter._root

# Define camel-class methods

    getX = get_x
    getY = get_y
    getSource = get_source

# Class: GKeyEvent

class GKeyEvent(GEvent):
    """
    This class maintains the data for a key event.
    """

# Constructor: GKeyEvent

    def __init__(self, tke):
        """
        Creates a new <code>GKeyEvent</code> from the corresponding
        tkinter event tke.
        """
        keysym = tke.keysym.upper()
        if len(keysym) > 1:
            underscore = keysym.find("_")
            if underscore > 0:
                self._key = "<" + keysym[0:underscore] + ">"
            else:
                self._key = "<" + keysym + ">"
        else:
            self._key = tke.char

# Public method: get_key

    def get_key(self):
        """
        Returns the character that triggered the event.  The return
        value will be a single-character string for normal keys and
        the name of the key enclosed in angle brackets for special
        keys like <RETURN>.
        """
        return self._key

# Override method: get_source

    def get_source(self):
        """
        Returns the source of the key event, which is always the
        root window.
        """
        return tkinter._root

# Define camel-class methods

    getKey = get_key
    getSource = get_source

# Class: GState

class GState:
    """
    This class implements a simple record type that allows clients to
    define and maintain attributes.  The purpose of this class it to
    allow callback functions to share state with the calling environment.
    Although the closure of the callback function makes it possible to
    read the contents of variables defined in the caller, Python's
    implicit declaration rule makes it impossible to reassign new
    values.  Having this class makes it possible to avoid introducing
    the nonlocal declaration.
    """

# Constructor: GState

    def __init__(self):
        """
        Creates a new GState with no fields.
        """
        pass

# Override method: __str__

    def __str__(self):
        s = ""
        for key in sorted(self.__dict__):
            if not key.startswith("_"):
                if len(s) > 0:
                    s += ", "
                s += str(key) + ":" + repr(self.__dict__[key])
        return "GState(" + s + ")"

# Private function: get_screen_width

def _get_screen_width():
    """
    Returns the width of the entire display screen.
    """
    return tkinter._root.winfo_screenwidth()

# Private function: get_screen_height

def _get_screen_height():
    """
    Returns the height of the entire display screen.
    """
    return tkinter._root.winfo_screenheight()

# Private function: convert_color_to_rgb

def _convert_color_to_rgb(color_name):
    """
    Converts a color name into an integer that encodes the
    red, green, and blue components of the color.
    """
    if color_name == "":
        return -1
    if color_name[0] == "#":
        color_name = "0x" + color_name[1:]
        return int(color_name, 16)
    name = _canonical_color_name(color_name)
    if name not in COLOR_TABLE:
        raise Exception("set_color: Illegal color - " + color_name)
    return COLOR_TABLE[name]

# Private function: convert_rgb_to_color

def _convert_rgb_to_color(rgb):
    """
    Converts an rgb value into a name in the form <code>"#rrggbb"</code>.
    Each of the <code>rr</code>, <code>gg</code>, and <code>bb</code>
    values are two-digit hexadecimal numbers indicating the intensity
    of that component.
    """
    hex_string = hex(0xFF000000 | rgb)
    return "#" + hex_string[4:].upper()

# Private function: exit_graphics

def _exit_graphics():
    """
    Closes all graphics windows and exits from the application without
    waiting for any additional user interaction.
    """
    sys.exit()

# Private function: get_program_name

def _get_program_name():
    """
    Returns the name of the program.
    """
    name = None
    try:
        stack = inspect.stack()
        i = len(stack) - 1
        while i >= 0 and name is None:
            code = stack[i].code_context[stack[i].index]
            rf = code.find("runfile(")
            if rf >= 0:
                start = rf + len("runfile('")
                finish = code.find("'", start)
                name = code[start:finish]
            else:
                i -= 1
        if name is None:
            i = len(stack) - 1
            while i >= 0 and name is None:
                if stack[i].filename:
                    name = stack[i].filename
                else:
                    i -= 1
    except Exception:
        return "Graphics Window"
    if name is None:
        return "Graphics Window"
    name = name[name.rfind("/") + 1:]
    dot = name.find(".")
    if dot != -1:
        name = name[:dot]
    return name

# Private function: canonical_color_name

def _canonical_color_name(str):
    result = ""
    for char in str:
        if not char.isspace() and char != "_":
            result += char.lower()
    return result

# Private function: dsq

def _dsq(x0, y0, x1, y1):
    """
    Returns the square of the distance between two points.
    """
    return (x1 - x0) * (x1 - x0) + (y1 - y0) * (y1 - y0)

# Private function: decode_font

def _decode_font(name):
    """
    Parses a font string into a tkinter <code>Font</code> object.
    This method accepts a font in either the <code>Font.decode</code>
    used by Java or in the form of a CSS-based style string.
    """
    font = _parse_js_font(name)
    if font is None:
        font = _parse_java_font(name)
    return font

def _parse_js_font(name):
    """
    Attempts to parse a font specification as a JavaScript font.
    If the parse succeeds, <code>parse_js_font</code> returns the font.
    If the parse fails, <code>parse_js_font</code> returns <code>None</code>.
    """
    name = name.lower().strip()
    family = None
    size = -1
    weight = "normal"
    slant = "roman"
    start = 0
    while size == -1:
        sp = name.find(" ", start)
        if sp == -1:
            return None
        token = name[start:sp]
        start = sp + 1
        if token == "bold":
            weight = "bold"
        elif token == "italic":
            slant = "italic"
        elif token[0].isdigit():
            size = _parse_js_units(token)
            if size == -1:
                return None
        else:
            return None
    families = name[start:].split(",")
    if len(families) == 0:
        return None
    for family in families:
        if family.startswith("'") or family.startswith("\""):
            family = family[1:-1]
        # // Add code to test for existence of font family
        return tk_font.Font(family=family, size=-size,
                            weight=weight, slant=slant)
    return None

def _parse_java_font(name):
    """
    Attempts to parse a font specification as a Java font.
    If the parse succeeds, <code>parse_java_font</code> returns the font.
    If the parse fails, <code>parse_java_font</code> returns <code>None</code>.
    """
    components = name.lower().strip().split("-")
    family = components[0]
    weight = "normal"
    slant = "roman"
    if components[1][0].isdigit():
        size = components[1]
    else:
        size = components[2]
        if "bold" in components[1]:
            weight = "bold"
        if "italic" in components[1]:
            slant = "italic"
    return tk_font.Font(family=family, size=-size,
                        weight=weight, slant=slant)

def _parse_js_units(spec):
    ux = len(spec)
    while ux > 0 and spec[ux - 1] >= "A":
        ux = ux - 1
    if ux == 0 or ux == len(spec):
        return -1
    value = float(spec[:ux])
    units = spec[ux:]
    if units == "em":
        return round(16 * value)
    elif units == "pt":
        return round(value / 0.75)
    else:
        return round(value)

# Private class: _GTransform

class _GTransform:

    def __init__(self, tx=0.0, ty=0.0, rotation=0.0, sf=1.0):
        self._tx = tx
        self._ty = ty
        self._rotation = rotation
        self._sf = sf

    def __str__(self):
       return "{{tx:{} ty:{} rot:{} sf:{}}}".format(self._tx, self._ty,
                                                    self._rotation, self._sf)

    def get_tx(self):
        return self._tx

    def get_ty(self):
        return self._ty

    def get_rotation(self):
        return self._rotation

    def get_sf(self):
        return self._sf

    def transform(self, a1, a2=None):
        if a2 is None:
            x0 = a1.get_x()
            y0 = a1.get_y()
        else:
            x0 = a1
            y0 = a2
        if self._rotation == 0:
            x1 = self._tx + self._sf * x0
            y1 = self._ty + self._sf * y0
        else:
            ct = math.cos(math.radians(self._rotation))
            st = math.sin(math.radians(self._rotation))
            x1 = self._tx + self._sf * (x0 * ct + y0 * st)
            y1 = self._ty + self._sf * (y0 * ct - x0 * st)
        return GPoint(x1, y1)

    def compose(self, transform):
        return _GTransform(self._tx + transform.get_tx(),
                           self._ty + transform.get_ty(),
                           rotation=self._rotation + transform._rotation,
                           sf=self._sf * transform._sf)

# Private class: _EventManager

class _EventManager:

    CLICK_MAX_DISTANCE = 2
    CLICK_MAX_DELAY = 0.5
    DOUBLE_CLICK_TIME = 0.5

    def __init__(self, gw):
        self._gw = gw
        self._down_x = -1
        self._down_y = -1
        self._press_handler = None
        self._release_handler = None
        self._motion_handler = None
        self._drag_handler = None
        self._key_handler = None
        self._click_listeners = [ ]
        self._dblclick_listeners = [ ]
        self._mousedown_listeners = [ ]
        self._mouseup_listeners = [ ]
        self._mousemove_listeners = [ ]
        self._drag_listeners = [ ]
        self._key_listeners = [ ]
        self._down_x = None
        self._down_y = None
        self._down_time = None
        self._last_click_time = None

    def _press_action(self, tke):
        self._down_x = tke.x
        self._down_y = tke.y
        self._down_time = time.time()
        e = GMouseEvent(tke)
        for fn in self._mousedown_listeners:
            fn(e)

    def _release_action(self, tke):
        e = GMouseEvent(tke)
        for fn in self._mouseup_listeners:
            fn(e)
        if abs(self._down_x - e._x) <= self.CLICK_MAX_DISTANCE:
            if abs(self._down_y - e._y) <= self.CLICK_MAX_DISTANCE:
                t = time.time()
                if t - self._down_time < self.CLICK_MAX_DELAY:
                    for fn in self._click_listeners:
                        fn(e)
                    last_click = self._last_click_time
                    self._last_click_time = t
                    if last_click is not None:
                        if t - last_click < self.DOUBLE_CLICK_TIME:
                            for fn in self._dblclick_listeners:
                                fn(e)
                            self._last_click_time = None

    def _motion_action(self, tke):
        e = GMouseEvent(tke)
        for fn in self._mousemove_listeners:
            fn(e)

    def _drag_action(self, tke):
        e = GMouseEvent(tke)
        for fn in self._drag_listeners:
            fn(e)

    def _key_action(self, tke):
        e = GKeyEvent(tke)
        for fn in self._key_listeners:
            fn(e)

    def add_event_listener(self, type, fn):
        tkc = self._gw._canvas
        if type == "click":
            if self._press_handler is None:
                self._press_handler = self._press_action
                tkc.bind("<ButtonPress-1>", self._press_handler)
            if self._release_handler is None:
                self._release_handler = self._release_action
                tkc.bind("<ButtonRelease-1>", self._release_handler)
            if fn not in self._click_listeners:
                self._click_listeners.append(fn)
        elif type == "mousedown" or type == "press":
            if self._press_handler is None:
                self._press_handler = self._press_action
                tkc.bind("<ButtonPress-1>", self._press_handler)
            if fn not in self._mousedown_listeners:
                self._mousedown_listeners.append(fn)
        elif type == "mouseup" or type == "release":
            if self._release_handler is None:
                self._release_handler = self._release_action
                tkc.bind("<ButtonRelease-1>", self._release_handler)
            if fn not in self._mouseup_listeners:
                self._mouseup_listeners.append(fn)
        elif type == "dblclick":
            if self._press_handler is None:
                self._press_handler = self._press_action
                tkc.bind("<ButtonPress-1>", self._press_handler)
            if self._release_handler is None:
                self._release_handler = self._release_action
                tkc.bind("<ButtonRelease-1>", self._release_handler)
            if fn not in self._dblclick_listeners:
                self._dblclick_listeners.append(fn)
        elif type == "mousemove" or type == "move":
            if self._motion_handler is None:
                self._motion_handler = self._motion_action
                tkc.bind("<Motion>", self._motion_handler)
            if fn not in self._mousemove_listeners:
                self._mousemove_listeners.append(fn)
        elif type == "drag":
            if self._drag_handler is None:
                self._drag_handler = self._drag_action
                tkc.bind("<B1-Motion>", self._drag_handler)
            if fn not in self._drag_listeners:
                self._drag_listeners.append(fn)
        elif type == "key":
            if self._key_handler is None:
                self._key_handler = self._key_action
                tkc.bind("<Key>", self._key_handler)
                tkc.focus_set()
            if fn not in self._key_listeners:
                self._key_listeners.append(fn)
        else:
            raise Exception("Illegal event type: " + type)

# Constants

__LINE_TOLERANCE__ = 2
__ARC_TOLERANCE__ = 2

# Color table

COLOR_TABLE = {
    "aliceblue": 0xF0F8FF,
    "antiquewhite": 0xFAEBD7,
    "aqua": 0x00FFFF,
    "aquamarine": 0x7FFFD4,
    "azure": 0xF0FFFF,
    "beige": 0xF5F5DC,
    "bisque": 0xFFE4C4,
    "black": 0x000000,
    "blanchedalmond": 0xFFEBCD,
    "blue": 0x0000FF,
    "blueviolet": 0x8A2BE2,
    "brown": 0xA52A2A,
    "burlywood": 0xDEB887,
    "cadetblue": 0x5F9EA0,
    "chartreuse": 0x7FFF00,
    "chocolate": 0xD2691E,
    "coral": 0xFF7F50,
    "cornflowerblue": 0x6495ED,
    "cornsilk": 0xFFF8DC,
    "crimson": 0xDC143C,
    "cyan": 0x00FFFF,
    "darkblue": 0x00008B,
    "darkcyan": 0x008B8B,
    "darkgoldenrod": 0xB8860B,
    "darkgray": 0xA9A9A9,
    "darkgrey": 0xA9A9A9,
    "darkgreen": 0x006400,
    "darkkhaki": 0xBDB76B,
    "darkmagenta": 0x8B008B,
    "darkolivegreen": 0x556B2F,
    "darkorange": 0xFF8C00,
    "darkorchid": 0x9932CC,
    "darkred": 0x8B0000,
    "darksalmon": 0xE9967A,
    "darkseagreen": 0x8FBC8F,
    "darkslateblue": 0x483D8B,
    "darkslategray": 0x2F4F4F,
    "darkslategrey": 0x2F4F4F,
    "darkturquoise": 0x00CED1,
    "darkviolet": 0x9400D3,
    "deeppink": 0xFF1493,
    "deepskyblue": 0x00BFFF,
    "dimgray": 0x696969,
    "dimgrey": 0x696969,
    "dodgerblue": 0x1E90FF,
    "firebrick": 0xB22222,
    "floralwhite": 0xFFFAF0,
    "forestgreen": 0x228B22,
    "fuchsia": 0xFF00FF,
    "gainsboro": 0xDCDCDC,
    "ghostwhite": 0xF8F8FF,
    "gold": 0xFFD700,
    "goldenrod": 0xDAA520,
    "gray": 0x808080,
    "grey": 0x808080,
    "green": 0x008000,
    "greenyellow": 0xADFF2F,
    "honeydew": 0xF0FFF0,
    "hotpink": 0xFF69B4,
    "indianred": 0xCD5C5C,
    "indigo": 0x4B0082,
    "ivory": 0xFFFFF0,
    "khaki": 0xF0E68C,
    "lavender": 0xE6E6FA,
    "lavenderblush": 0xFFF0F5,
    "lawngreen": 0x7CFC00,
    "lemonchiffon": 0xFFFACD,
    "lightblue": 0xADD8E6,
    "lightcoral": 0xF08080,
    "lightcyan": 0xE0FFFF,
    "lightgoldenrodyellow": 0xFAFAD2,
    "lightgray": 0xD3D3D3,
    "lightgrey": 0xD3D3D3,
    "lightgreen": 0x90EE90,
    "lightpink": 0xFFB6C1,
    "lightsalmon": 0xFFA07A,
    "lightseagreen": 0x20B2AA,
    "lightskyblue": 0x87CEFA,
    "lightslategray": 0x778899,
    "lightslategrey": 0x778899,
    "lightsteelblue": 0xB0C4DE,
    "lightyellow": 0xFFFFE0,
    "lime": 0x00FF00,
    "limegreen": 0x32CD32,
    "linen": 0xFAF0E6,
    "magenta": 0xFF00FF,
    "maroon": 0x800000,
    "mediumaquamarine": 0x66CDAA,
    "mediumblue": 0x0000CD,
    "mediumorchid": 0xBA55D3,
    "mediumpurple": 0x9370DB,
    "mediumseagreen": 0x3CB371,
    "mediumslateblue": 0x7B68EE,
    "mediumspringgreen": 0x00FA9A,
    "mediumturquoise": 0x48D1CC,
    "mediumvioletred": 0xC71585,
    "midnightblue": 0x191970,
    "mintcream": 0xF5FFFA,
    "mistyrose": 0xFFE4E1,
    "moccasin": 0xFFE4B5,
    "navajowhite": 0xFFDEAD,
    "navy": 0x000080,
    "oldlace": 0xFDF5E6,
    "olive": 0x808000,
    "olivedrab": 0x6B8E23,
    "orange": 0xFFA500,
    "orangered": 0xFF4500,
    "orchid": 0xDA70D6,
    "palegoldenrod": 0xEEE8AA,
    "palegreen": 0x98FB98,
    "paleturquoise": 0xAFEEEE,
    "palevioletred": 0xDB7093,
    "papayawhip": 0xFFEFD5,
    "peachpuff": 0xFFDAB9,
    "peru": 0xCD853F,
    "pink": 0xFFC0CB,
    "plum": 0xDDA0DD,
    "powderblue": 0xB0E0E6,
    "purple": 0x800080,
    "rebeccapurple": 0x663399,
    "red": 0xFF0000,
    "rosybrown": 0xBC8F8F,
    "royalblue": 0x4169E1,
    "saddlebrown": 0x8B4513,
    "salmon": 0xFA8072,
    "sandybrown": 0xF4A460,
    "seagreen": 0x2E8B57,
    "seashell": 0xFFF5EE,
    "sienna": 0xA0522D,
    "silver": 0xC0C0C0,
    "skyblue": 0x87CEEB,
    "slateblue": 0x6A5ACD,
    "slategray": 0x708090,
    "slategrey": 0x708090,
    "snow": 0xFFFAFA,
    "springgreen": 0x00FF7F,
    "steelblue": 0x4682B4,
    "tan": 0xD2B48C,
    "teal": 0x008080,
    "thistle": 0xD8BFD8,
    "tomato": 0xFF6347,
    "turquoise": 0x40E0D0,
    "violet": 0xEE82EE,
    "wheat": 0xF5DEB3,
    "white": 0xFFFFFF,
    "whitesmoke": 0xF5F5F5,
    "yellow": 0xFFFF00,
    "yellowgreen": 0x9ACD32,
    "color.black": 0x000000,
    "color.darkgray": 0x595959,
    "color.gray": 0x999999,
    "color.lightgray": 0xBFBFBF,
    "color.white": 0xFFFFFF,
    "color.red": 0xFF0000,
    "color.yellow": 0xFFFF00,
    "color.green": 0x00FF00,
    "color.cyan": 0x00FFFF,
    "color.blue": 0x0000FF,
    "color.magenta": 0xFF00FF,
    "color.orange": 0xFFC800,
    "color.pink": 0xFFAFAF
}

# Check for successful compilation


# Original file: scanner.py

# Class: Scanner

# This class uses Python's tokenize package to build a token scanner
# that is similar to the TokenScanner used in the portable library
# framework.

class Scanner:

    def __init__(self, input=""):
        self.set_input(input)

    def set_input(self, input):
        if isinstance(input, str):
            self._source = io.StringIO(input)
        else:
            self._source = input
        self._tokenizer = tokenize.generate_tokens(self._source.readline)
        self._saved_tokens = [ ]
        self._last_token = None

    def has_more_tokens(self):
        token = self.next_token()
        self.save_token(token)
        return token != "<EOF>"

    def next_token(self):
        if self._saved_tokens:
            if self._saved_tokens[-1].get_token_type() == tokenize.ENDMARKER:
                self._last_token = self._saved_tokens[-1]
            else:
                self._last_token = self._saved_tokens.pop()
        else:
            pytoken = self._tokenizer.__next__()
            self._last_token = Token(pytoken)
        return self._last_token

    def save_token(self, token):
        self._saved_tokens.append(token)

    def get_last_token(self):
        """Returns the last token read."""
        return self._last_token

    def get_token_type(self, token):
        return token.get_token_type()

    def verify_token(self, expected):
        """Checks that the token appears next in the input stream."""
        token = self.next_token()
        if token != expected:
            if token == "<EOF>":
                msg = "Missing " + mark_code(expected)
            else:
                msg = "Found {} when expecting {}".format(token, expected)
            raise Exception(msg)

# Constants

    WORD = tokenize.NAME
    NAME = tokenize.NAME
    NUMBER = tokenize.NUMBER
    STRING = tokenize.STRING
    OPERATOR = tokenize.OP
    NL = tokenize.NL
    NEWLINE = tokenize.NEWLINE
    COMMENT = tokenize.COMMENT
    INDENT = tokenize.INDENT
    DEDENT = tokenize.DEDENT
    EOF = tokenize.ENDMARKER

# Class: Token

class Token:

    def __init__(self, pytoken):
        self._pytoken = pytoken

    def __str__(self):
        if self._pytoken.type == tokenize.ENDMARKER:
            return "<EOF>"
        elif self._pytoken.type == tokenize.NL:
            return "<NL>"
        elif self._pytoken.type == tokenize.NEWLINE:
            return "<NEWLINE>"
        elif self._pytoken.type == tokenize.INDENT:
            return "<INDENT>"
        elif self._pytoken.type == tokenize.DEDENT:
            return "<DEDENT>"
        else:
            return self._pytoken.string

    def get_python_token(self):
        return self._pytoken

    def get_token_type(self):
        return self._pytoken.type        

    def get_start(self):
        return self._pytoken.start

    def get_end(self):
        return self._pytoken.end

    def __eq__(self, other):
        return str(self) == str(other)

# Constants

    WORD = tokenize.NAME
    NAME = tokenize.NAME
    NUMBER = tokenize.NUMBER
    STRING = tokenize.STRING
    OPERATOR = tokenize.OP
    NL = tokenize.NL
    NEWLINE = tokenize.NEWLINE
    INDENT = tokenize.INDENT
    DEDENT = tokenize.DEDENT


# Original file: codevector.py

"""
This module exports the CodeVector class, which implements an expandable
code sequence.
"""

# Class: CodeVector

class CodeVector:

    """
    This class implements an expandable code array in which each instruction
    is a 32-bit integer.  The instruction codes are defined as constants
    in the SVMOp class.
    """

    def __init__(self):
        """Creates an empty code vector."""
        self._code = [ ]
        self._labels = { }
        self._label_refs = { }
        self._int_refs = { }
        self._string_refs = { }
        self._label_count = 0
        self._source = None

    def add_word(self, word):
        """Adds a 32-bit word to the code vector."""
        self._code.append(word)

    def add_instruction(self, op, addr=0):
        """Adds an instruction to the code vector."""
        self.add_word((op << 24) | addr)

    def get_current_address(self):
        """Returns the address of the next instruction."""
        return len(self._code)

    def new_label(self):
        """Returns a label used for internal references within the code."""
        label = "#" + str(self._label_count)
        self._label_count += 1
        return label

    def define_label(self, label):
        """Defines a label as the address of the current instruction."""
        self.define_symbol(label, self.get_current_address())

    def define_symbol(self, label, value):
        """Defines a label so that it has the specified value."""
        self._labels[self.create_module_label(label)] = value

    def is_defined(self, label):
        """Returns True if the label is defined."""
        return self.create_module_label(label) in self._labels

    def get_label(self, label):
        """Returns the value of the label."""
        module_label = self.create_module_label(label)
        if module_label in self._labels:
            return self._labels.get(module_label)
        else:
            raise Exception("Undefined symbol " + label)

    def label_ref(self, label):
        """Creates a reference to the specified label."""
        module_label = self.create_module_label(label)
        if module_label in self._labels:
            return self._labels.get(module_label)
        else:
            refs = self._label_refs.get(module_label)
            if refs is None:
                refs = [ ]
                self._label_refs[module_label] = refs
            refs.append(len(self._code))
            return 0

    def string_ref(self, s):
        """Returns a reference to the specified string."""
        refs = self._string_refs.get(s)
        if refs is None:
            refs = [ ]
            self._string_refs[s] = refs
        refs.append(len(self._code))
        return 0

    def int_ref(self, n):
        """Returns a reference to an integer."""
        refs = self._int_refs.get(n)
        if refs is None:
            refs = [ ]
            self._int_refs[n] = refs
        refs.append(len(self._code))
        return 0

    def get_code(self):
        """Gets the array of integers corresponding to the code."""
        self.resolve_references()
        n = len(self._code)
        array = [ 0 ] * n
        for i in range(n):
            array[i] = self._code[i]
        return array

    def set_source(self, source):
        """Sets the source for the code."""
        self._source = source

    def get_source(self):
        """Gets the source for the code."""
        return self._source

    def set_module_name(self, name):
        """Sets the module name."""
        self._module_name = name

    def get_module_name(self):
        """Gets the module name."""
        return self._module_name

    def create_module_label(self, label):
        """Adds the module name to any label beginning with a dollar sign."""
        if label.startswith("$"):
            return module_name + label
        else:
            return label

    def resolve_references(self):
        for label in self._label_refs:
            if label in self._labels:
                refs = self._label_refs.get(label)
                value = self._labels.get(label)
                for addr in refs:
                    self._code[addr] = self._code[addr] + value
            else:
                raise Exception("Unresolved reference: " + label)
        for s in self._string_refs:
            start = len(self._code)
            refs = self._string_refs.get(s)
            array = bytearray(s, "utf-8")
            shift = 24
            word = 0
            for b in array:
                word |= b << shift
                shift -= 8
                if shift < 0:
                    self._code.append(word)
                    shift = 24
                    word = 0
            if shift == 24:
                self._code.append(0)
            else:
                self._code.append(word)
            for addr in refs:
                self._code[addr] = self._code[addr] + start
        for n in self._int_refs:
            start = len(self._code)
            refs = int_refs.get(n)
            code.append(n)
            for addr in refs:
                self._code[addr] = self._code[addr] + start

    @staticmethod
    def get_string(code, addr):
        """Gets a string stored at addr in the code array."""
        array = bytearray()
        index = 0
        shift = 24
        finished = False
        while not finished:
            b = (code[addr + index] >> shift) & 0xFF
            if b == 0:
                finished = True
            else:
                array.append(b)
                shift -= 8
                if shift < 0:
                    index += 1
                    shift = 24
        return array.decode("utf-8")

# Unit test


# Original file: codewindow.py

"""
This module defines a simple CodeWindow class, which implements a
scrollable code viewer as an independent tkinter window.  This
implementation is limited to a side-by-side geometry with a
graphics window.
"""

# Class: CodeWindow

class CodeWindow(GWindow):

    """Implements a scrollable code window."""

# Implementation notes: CodeWindow
# --------------------------------
# Unlike most constructors, this function does not call the superclass
# constructor because the code needs to defer the display.  Inheriting
# for GWindow ensures that all the methods are present, but the code
# must explicitly assemble the internal state so that it behaves like
# a GWindow.

    def __init__(self, gw, width, height=None):
        """
        Creates a new code window that will be positioned to the
        right of the GWindow gw, although the window does not
        immediately appear on the screen.  Clients should create
        the CodeWindow first, set any display parameters such as
        font and line spacing, and then call set_code to display
        the window.  If height is not specified, it is set to
        match the height of gw.
        """
        if height is None:
            height = gw.get_height()
        self._gw = gw
        self._window_width = width
        self._window_height = height
        self._family = CodeWindow.DEFAULT_FONT_FAMILY
        self._pointsize = CodeWindow.DEFAULT_POINTSIZE
        self._spacing = CodeWindow.DEFAULT_SPACING
        self._left_margin = CodeWindow.DEFAULT_LEFT_MARGIN
        self._top_margin = CodeWindow.DEFAULT_TOP_MARGIN
        self._keywords = { };
        self._base = GCompound()
        self._base._gw = self
        self._highlight = None

    def set_code(self, code):
        """Sets the code and displays the window."""
        if not isinstance(code, str):
            code = "\n".join(code) + "\n"
        self._compound = self._create_code_labels(code)
        self._create_window()
        self.add(self._compound)

    def set_font(self, font):
        self._font = font

    def set_spacing(self, spacing):
        self._spacing = spacing

    def add_keyword(self, keyword, color=None):
        if color is None:
            color = CodeWindow.KEYWORD_COLOR
        self._keywords[keyword] = color

    def set_highlight(self, linenum):
        self.clear_highlight()
        self._highlight = self.create_highlight_box(linenum)
        self.add(self._highlight)
        self.ensure_visible(linenum)

    def clear_highlight(self):
        if self._highlight is not None:
            self.remove(self._highlight)

    def create_highlight_box(self, linenum):
        if linenum in self._linemap:
            start,end = self._linemap[linenum]
            x = start - 2
            w = end - start + 4
        else:
            x = self._left_margin
            w = 5
        y = self._top_margin + (linenum - 2) * self._spacing + 4
        h = self._spacing
        box = GRect(x, y, w, h)
        box.set_color("Red");
        box.set_line_width(2)
        return box
                
# Private methods

    def _create_code_labels(self, code):
        compound = GCompound()
        self._font = "bold " + str(self._pointsize) + "px " + self._family
        self._ufont = None
        if self._family != "Monaco":
            self._ufont = "bold " + str(self._pointsize) + "px " + "'Monaco'"
        self._linemap = { }
        space = GLabel(" ")
        space.set_font(self._font)
        self._cwidth = space.get_width()
        scanner = Scanner(code)
        prev = -1
        while scanner.has_more_tokens():
            token = scanner.next_token()
            ttype = scanner.get_token_type(token)
            if ttype == Scanner.STRING:
                color = CodeWindow.STRING_COLOR
            elif ttype == Scanner.NUMBER:
                color = CodeWindow.STRING_COLOR
            elif ttype == Scanner.COMMENT:
                color = CodeWindow.COMMENT_COLOR
            elif str(token) in self._keywords:
                color = self._keywords[str(token)]
            else:
                color = CodeWindow.CODE_COLOR
            if ttype in CodeWindow.VISIBLE_TYPES:
                row,col = token.get_start()
                x = self._left_margin + col * self._cwidth
                y = self._top_margin + (row - 1) * self._spacing
                if row != prev:
                    if prev != -1:
                        self._linemap[prev] = (start,end)
                    start = x
                    prev = row
                lines = str(token).splitlines()
                nlines = len(lines)
                for i in range(nlines):
                    line = lines[i]
                    if self._ufont is None:
                        label = GLabel(line)
                        label.set_font(self._font)
                        label.set_color(color)
                        compound.add(label, x, y)
                        x += label.get_width()
                        end = x
                    else:
                        parts = line.split("_")
                        for i in range(len(parts)):
                            if i > 0:
                                label = GLabel("_")
                                label.set_font(self._ufont)
                                label.set_color(color)
                                compound.add(label, x, y)
                                x += label.get_width()
                            label = GLabel(parts[i])
                            label.set_font(self._font)
                            label.set_color(color)
                            compound.add(label, x, y)
                            x += label.get_width()
                            end = x
                    if i < nlines - 1:
                        x = self._left_margin
                        y += self._spacing
                        row += 1
        if prev != -1:
            self._linemap[prev] = (start,end)
        return compound

    def _create_window(self):
        gw = self._gw
        width = self._window_width
        height = self._window_height        
        cwidth = self._compound.getWidth()
        cheight = self._compound.getHeight()
        tk = gw._tk
        self._tk = tk
        gwc = gw._canvas
        gwc.pack_forget()
        frame = tkinter.Frame(tk, width=width, height=height,
                              highlightthickness=0)
        border = tkinter.Canvas(tk, width=1, height=height,
                                highlightthickness=0, bg="#000000")
        cwc = tkinter.Canvas(frame, width=width, height=height,
                                    scrollregion=(0, 0, cwidth, cheight),
                                    highlightthickness=0, background="white")
        hbar = None
        if cwidth > width:
            hbar = tkinter.Scrollbar(frame, orient=tkinter.HORIZONTAL)
            hbar.pack(side=tkinter.BOTTOM, fill=tkinter.X)
            hbar.config(command=cwc.xview)
        vbar = None
        if cheight > height:
            vbar = tkinter.Scrollbar(frame, orient=tkinter.VERTICAL)
            vbar.pack(side=tkinter.RIGHT, fill=tkinter.Y)
            vbar.config(command=cwc.yview)
        self._window_width = width
        self._window_height = height
        self._canvas = cwc
        self._active = True
        bounds = "{}x{}".format(gw._window_width + width + 1, height)
        tk.geometry(bounds)
        tk.resizable(width=0, height=0)
        gwc.pack(side=tkinter.LEFT)
        border.pack(side=tkinter.LEFT)
        frame.pack(side=tkinter.LEFT)
        cwc.pack(side=tkinter.LEFT, expand=True, fill=tkinter.BOTH)
        if hbar is not None and vbar is not None:
            cwc.config(xscrollcommand=hbar.set, yscrollcommand=vbar.set)
        elif hbar is not None:
            cwc.config(xscrollcommand=hbar.set)
        elif vbar is not None:
            cwc.config(yscrollcommand=vbar.set)
        self._hbar = hbar
        self._vbar = vbar

    def ensure_visible(self, linenum):
        """Ensures that the specified line is visible."""
        if self._vbar is None:
            return
        h = self._compound.get_height()
        y = self._top_margin + (linenum - 1) * self._spacing
        start,end = self._vbar.get()
        top = start * h
        bottom = end * h
        if y < top or y > bottom:
            start = max(0.0, (y - self._window_height / 2) / h) 
            end = min(1.0, start + self._window_height / h)
            self._canvas.yview_moveto(start)
            

# Constants

    DEFAULT_FONT_FAMILY = "Monaco"
    DEFAULT_POINTSIZE = 18
    DEFAULT_SPACING = 20
    DEFAULT_LEFT_MARGIN = 6
    DEFAULT_TOP_MARGIN = 18

    VISIBLE_TYPES = {
        Scanner.COMMENT,
        Scanner.WORD,
        Scanner.NUMBER,
        Scanner.STRING,
        Scanner.OPERATOR
    }

    STRLIT_COLOR = "#006600"
    COMMENT_COLOR = "#009999"
    KEYWORD_COLOR = "#CC6600"
    BUILTIN_COLOR = "#993399"
    ERROR_COLOR = "#FF0000"
    CODE_COLOR = "Black"
    DOCSTRING_COLOR = STRLIT_COLOR
    STRING_COLOR = STRLIT_COLOR
    NUMBER_COLOR = CODE_COLOR

# Original file: exp.py

"""
This package defines a simple expression hierarchy for Python.
"""

# Class: Expression

class Expression:
    """This abstract class forms the top of the expression hierarchy."""

    def __init__(self):
        """Common initializer (not called by clients)."""
        self._start = -1
        self._end = -1

# Abstract methods

    def eval(self, ec):
        """Evaluates the expression in the evaluation context ec."""
        raise NotImplementedError("No eval method defined")

    def get_type(self):
        """Returns the type code for this expression."""
        raise NotImplementedError("No get_type method defined")

    def is_operator():
        """Returns True if this expression is an operator."""
        return False

# Public methods

    def set_bounds(self, start, end):
        """Sets the boundary markers to the (row,col) pairs start and end."""
        self._start = start
        self._end = end

    def get_start(self):
        """Returns the tuple (row,col) of the start of this expression."""
        return self._start

    def get_end(self):
        """Returns the tuple (row,col) of the end of this expression."""
        return self._end

# Generator methods

# Implementation notes
# --------------------
# The eval_generator method returns a generator that implements a
# postorder walk on the evaluation tree.  On each call, the generator
# returns a tuple consisting of the expression and its value.

    def eval_generator(self, ec):
        """Returns a generator that calls back on the each subexpression."""
        yield from self.eval_step(ec)

    def eval_step(self, ec):
        v = self.eval(ec)
        yield (self,v)

# Static methods

    @staticmethod
    def eval_args(args, ec):
        actuals = [ ]
        for arg in args:
            actuals.append(arg.eval(ec))
        return actuals

# Constants 

    CONSTANT = 1
    IDENTIFIER = 2
    COMPOUND = 3
    OPERATOR = 4
    FUNCTION = 5
        
# Class: Compound

class Compound(Expression):

    def __init__(self, fn, args):
        Expression.__init__(self)
        self._fn = fn
        self._args = args

    def __str__(self):
        s = ""
        for arg in self._args:
            if len(s) > 0:
                s += ", "
            s += str(arg)
        return str(self._fn) + "(" + s + ")"

    def get_type(self):
        return Expression.COMPOUND

    def get_function(self):
        return self._fn

    def get_args(self):
        return self._args

    def eval(self, ec):
        fn = self.get_function()
        actuals = [ ]
        for arg in self.get_args():
            actuals.append(arg.eval(ec))
        return ec.apply(fn, actuals)

    def eval_step(self, ec):
        fn = self.get_function()
        actuals = [ ]
        for arg in self.get_args():
            for e,v in arg.eval_generator(ec):
                yield (e,v)
            actuals.append(v)
        v = ec.apply(fn, actuals)
        yield (self,v)

    @staticmethod
    def create(fn, *args):
        return Compound(fn, args)

# Class: Constant

class Constant(Expression):

    def __init__(self, value):
        Expression.__init__(self)
        self._value = value

    def __str__(self):
        return str(self._value)

    def get_type(self):
        return Expression.CONSTANT

    def get_value(self):
        return self._value

    def eval(self, ec):
        return ec.eval_constant(self)

    @staticmethod
    def create(value):
        return Constant(value)

# Class: Identifier

class Identifier(Expression):

    def __init__(self, name):
        Expression.__init__(self)
        self._name = str(name)

    def __str__(self):
        return self._name

    def get_type(self):
        return Expression.IDENTIFIER

    def get_name(self):
        return self._name

    def eval(self, ec):
        return ec.eval_identifier(self)

    def get(self, ec):
        return ec.get_value(self._name)

    def set(self, ec, value):
        ec.set_value(self._name, value)

    @staticmethod
    def create(name):
        return Identifier(name)

# Class: EvalContext

# Implementation notes: EvalContext
# ---------------------------------
# In the Java implementation, EvalContext is an interface and therefore
# only specifies the methods.  This class provides a simple implementation
# that is used in the unit test at the end of this file.  Other clients
# can either extend this class or implement the same methods.

class EvalContext:

    def __init__(self):
        self._symtab = { }

    def get_value(self, name):
        """Returns the value of the identifier in this context."""
        return self._symtab.get(str(name))

    def set_value(self, name, value):
        self._symtab[str(name)] = value

    def is_defined(self, name):
        """Returns True if the identifier is defined in this context."""
        return str(name) in self._symtab

    def eval_constant(self, exp):
        """Evaluates a constant expression."""
        return exp.get_value()

    def eval_identifier(self, exp):
        """Evaluates an identifier expression."""
        return self.get_value(exp.get_name())

    def apply(self, fn, actuals):
        """Applies a function to a list of evaluated arguments."""
        return fn.apply(actuals)


# Class: Value

class Value:
    """This class implements a type-value pair."""

    def __init__(self, type, value):
        self._type = type
        self._value = value
        self._properties = None

    def __str__(self):
        """Convert this value to a string."""
        if self._value is None:
            return "null"
        if self.is_integral():
            return str(self.get_integer_value())
        return str(self._value)

    def get_type(self):
        """Returns the type of this object."""
        return self._type

    def get_value(self):
        """Returns the value of this object."""
        return self._value

    def set_property(self, key, value):
        """Sets a property for this value."""
        if self._properties is None:
            self._properties = { }
        self._properties[key] = value

    def get_property(self, key, value=None):
        """Returns the specified property for this value."""
        if self._properties is None:
            return value
        return self._properties.get(name, value)

    def is_integral(self):
        """Returns True if the value is equal to an integer."""
        if self._type == Value.INTEGER:
            return True
        elif self._type == Value.DOUBLE:
            return float.is_integer(self._value)
        else:
            return False

    def is_numeric(self):
        """Returns True if this value is numeric."""
        return self._type == Value.INTEGER or self._type == Value.DOUBLE

    def get_integer_value(self):
        """Returns the value of this object coerced to an int."""
        if self._type == Value.INTEGER:
            return self._value
        elif self._type == Value.DOUBLE:
            if not float.is_integer(self._value):
                raise Exception("Illegal integer")
            return int(self._value)
        else:
            raise Exception("Illegal integer")

    def get_double_value(self):
        """Returns the value of this object coerced to a double."""
        if self._type == Value.INTEGER or self._type == Value.DOUBLE:
            return float(self._value)
        else:
            raise Exception("Illegal double")

    def get_string_value(self):
        """Returns the value of this object coerced to a string."""
        return str(self._value)

    def get_boolean_value(self):
        """Returns the value of this object coerced to a boolean."""
        if self._type != Value.BOOLEAN:
            raise Exception("Illegal boolean")
        return self._value

    @staticmethod
    def create_integer(n):
        """Creates an integer value."""
        return Value(Value.INTEGER, n)

    @staticmethod
    def create_double(d):
        """Creates a double-precision value."""
        return Value(Value.DOUBLE, d)

    @staticmethod
    def create_boolean(b):
        """Creates a Boolean value."""
        return Value(Value.BOOLEAN, b)

    @staticmethod
    def create_character(ch):
        """Creates a character value."""
        return Value(Value.CHARACTER, ch)

    @staticmethod
    def create_string(s):
        """Creates a string value."""
        return Value(Value.STRING, s)

# Constants 

    ASSIGNABLE = "$ASSIGNABLE"
    BOOLEAN = "$BOOLEAN"
    CHARACTER = "$CHARACTER"
    DOUBLE = "$DOUBLE"
    FUNCTION = "$FUNCTION"
    INTEGER = "$INTEGER"
    LONG = "$LONG"
    OBJECT = "$OBJECT"
    REF = "$REF"
    STRING = "$STRING"
    VOID = "$VOID"

Value.TRUE = Value(Value.BOOLEAN, True)
Value.FALSE = Value(Value.BOOLEAN, False)
Value.NULL = Value(Value.REF, "null")
Value.UNDEFINED = Value(Value.VOID, "undefined")



# Original file: pglapp.py

"""
This module defines the structure of an application that runs
using the Portable Graphics Library.
"""

class PGLApplication(GWindow):

    """
    This class is the root of a hierarchy for applications that
    run in a PGL GWindow.
    """

    def __init__(self, width, height):
        """Creates a new PGLApplication object."""
        GWindow.__init__(self, width, height)
        self.add_event_listener("click", self.mouse_click)
        self.add_event_listener("mousedown", self.mouse_down)
        self.add_event_listener("mouseup", self.mouse_up)
        self.add_event_listener("mousemove", self.mouse_move)
        self.add_event_listener("drag", self.mouse_drag)
        self._current_obj = None

    def run(self):
        """Runs the application."""
        # Subclasses override this method

    def add_control_strip(self, controls, x, y):
        """Adds a control strip containing the specified controls."""
        self._controls = { }
        for name in controls.split("+"):
            cname = "PGL" + name + "Control"
            control = importlib.__import__(cname).__dict__[cname]()
            self.add(control, x, y)
            x += PGLApplication.CONTROL_SEP
            self._controls[name] = control

    def get_control(self, name):
        return self._controls[name]

    def mouse_click(self, e):
        obj = self.get_element_at(e.get_x(), e.get_y())
        attr = None
        if obj is not None:
            attr = getattr(obj, "click_action", None)
        if attr is None:
            obj = self
            attr = getattr(obj, "click_action", None)
        if attr is not None:
            attr(e)

    def mouse_down(self, e):
        obj = self.get_element_at(e.get_x(), e.get_y())
        attr = None
        if obj is not None:
            attr = getattr(obj, "mousedown_action", None)
        if attr is None:
            obj = self
            attr = getattr(obj, "mousedown_action", None)
        if attr is not None:
            attr(e)

    def mouse_up(self, e):
        obj = self.get_element_at(e.get_x(), e.get_y())
        attr = None
        if obj is not None:
            attr = getattr(obj, "mouseup_action", None)
        if attr is None:
            obj = self
            attr = getattr(obj, "mouseup_action", None)
        if attr is not None:
            attr(e)

    def mouse_move(self, e):
        obj = self.get_element_at(e.get_x(), e.get_y())
        if self._current_obj is None and obj is not None:
            self._current_obj = obj
            attr = getattr(obj, "mouseenter_action", None)
            if attr is not None:
                attr(e)
        if self._current_obj != obj:
            attr = getattr(self._current_obj, "mouseexit_action", None)
            if attr is not None:
                attr(e)
            self._current_obj = None
        attr = None
        if obj is not None:
            attr = getattr(obj, "mousemove_action", None)
        if attr is None:
            obj = self
            attr = getattr(obj, "mousemove_action", None)
        if attr is not None:
            attr(e)

    def mouse_drag(self, e):
        obj = self.get_element_at(e.get_x(), e.get_y())
        attr = None
        if obj is not None:
            attr = getattr(obj, "drag_action", None)
        if attr is None:
            obj = self
            attr = getattr(obj, "drag_action", None)
        if attr is not None:
            attr(e)

# Constants

    CONTROL_SEP = 65

# Class: PGLControl

class PGLControl(GCompound):

    def __init__(self):
        "Creates a new control."""
        GCompound.__init__(self)
        self._icon = None
        self._icons = { }
        self._listeners = [ ]

    def set_name(self, name):
        """Sets the name of this control."""
        self._name = name

    def get_name(self):
        """Gets the name for this control."""
        return self._name

    def add_action_listener(self, listener):
        """Adds an action listener to this control."""
        self._listeners.append(listener)

    def remove_action_listener(self, listener):
        """Removes an action listener from this control."""
        self._listeners.remove(listener)

    def fire_action_listeners(self):
        """Fires the action listeners for this control."""
        for listener in self._listeners:
            listener()

    def set_state(self, state):
        """Sets the state of this control."""
        self._state = state
        if self._icon is not None:
            self.remove(self._icon)
        self._icon = self._icons[state]
        self.add(self._icon)
        self._icon.send_to_back()
        
    def state_changed(self):
        """Called when the controller state changes."""
        pass

    def execute(self):
        """Executes this control in the context of the current controller."""
        self.fire_action_listeners()

    def update(self):
        if self._updater is not None:
            self._updater.update(self)

    def set_updater(self, updater):
        self._updater = updater

    def set_active_icon(self, icon):
        if isinstance(icon, str):
            icon = self.create_image_icon(icon)
        self._icons[PGLControl.ACTIVE] = icon

    def set_disabled_icon(self, icon):
        if isinstance(icon, str):
            icon = self.create_image_icon(icon)
        self._icons[PGLControl.DISABLED] = icon

    def set_pressed_icon(self, icon):
        if isinstance(icon, str):
            icon = self.create_image_icon(icon)
        self._icons[PGLControl.PRESSED] = icon

    def set_rollover_icon(self, icon):
        if isinstance(icon, str):
            icon = self.create_image_icon(icon)
        self._icons[PGLControl.ROLLOVER] = icon

    def create_image_icon(self, url):
        image = GImage(url)
        image.scale(PGLControl. ICON_SF)
        return image

    def mouseenter_action(self, e):
        """Called when the mouse enters the interactor."""
        if self._state == PGLControl.ACTIVE:
            self.set_state(PGLControl.ROLLOVER)

    def mouseexit_action(self, e):
        """Called when the mouse exits the interactor."""
        if self._state == PGLControl.ROLLOVER:
            self.set_state(PGLControl.ACTIVE)

    def mousedown_action(self, e):
        """Called when the mouse is pressed in the interactor."""
        if self._state in { PGLControl.ROLLOVER, PGLControl.ACTIVE }:
            self.set_state(PGLControl.PRESSED)

    def mouseup_action(self, e):
        """Called when the mouse is pressed in the interactor."""
        if self._state == PGLControl.PRESSED:
            self.set_state(PGLControl.ROLLOVER)

    def click_action(self, e):
        if self._state != PGLControl.DISABLED:
            self.fire_action_listeners()


# Constants

    ACTIVE = "ACTIVE"
    DISABLED = "DISABLED"
    PRESSED = "PRESSED"
    ROLLOVER = "ROLLOVER"

    ICON_SF = 0.2
    CONTROL_SIZE = 279 * ICON_SF

# Original file: filechooser.py
# Version: 0.6 (17-Jan-21)

"""
The filechooser module implements a simple wrapper for the filedialog
class in Tkinter, which is the most common graphics package for use
with Python.
"""

try:
    import tkinter
    try:
        import tkinter.filedialog as tkFileDialog
    except Exception:
        import tkFileDialog
except Exception as e:
    print('Could not load tkinter: ' + str(e))

# Function: choose_input_file

def choose_input_file(dir=".", title="Open File", initialfile=None):
    """
    Opens a file chooser for selecting an input file.
    """
    try:
        tk = tkinter._root
    except AttributeError:
        tk = tkinter.Tk()
        tkinter._root = tk
        tk.withdraw()
    filename = tkFileDialog.askopenfilename(parent=None,
                                            initialdir=dir,
                                            initialfile=initialfile,
                                            title=title)
    tk.update()
    return filename

# Function: choose_output_file

def choose_output_file(dir=".", title="Save File", initialfile=None):
    """
    Opens a file chooser for selecting an output file.
    """
    try:
        tk = tkinter._root
    except AttributeError:
        tk = tkinter.Tk()
        tkinter._root = tk
        tk.withdraw()
    filename = tkFileDialog.asksaveasfilename(parent=None,
                                              initialdir=dir,
                                              initialfile=initialfile,
                                              title=title)
    tk.update()
    return filename

# Define camel-case names

chooseOutputFile = choose_output_file
chooseInputFile = choose_input_file

# Check for successful compilation


# Original file: mvc.py

"""
This module implements the model-view-controller (MVC) pattern.
"""

# Class: Model

class Model:
    """
    This abstract class defines the interface for a model in the
    MVC pattern.  Subclasses override the methods to support specific
    controller models.
    """

    def __init__(self):
        """Initializes the model."""
        self._views = [ ]

    def __str__(self):
        """Returns a string version of the model."""
        return "<" + self.__class__.__name__ + ">"

    def reset(self):
        """Resets the controller state for the class."""

    def step(self):
        """Executes one step in the execution of the model."""

    def is_finished(self):
        """Returns True if the execution of the class is complete."""
        return False

    def is_callable(self):
        """Returns True if this model supports call/return operations."""
        return False

    def get_stack_depth(self):
        """Returns the current stack depth for the model."""
        return 0;

    def add_view(self, view):
        """Adds a view to this model."""
        self._views.append(view)

    def remove_view(self, view):
        """Removes a view from this model."""
        if view in self._views:
            self._views.remove(view)

    def update_views(self):
        """Updates all views that are monitoring this model."""
        for view in self._views:
            view.update(self)


# Class: View

class View:

    """
    This class defines the interface for a view in the MVC pattern.
    Most clients will not extend View but instead define a new class
    that implements the update method.
    """

    def update(self, model):
        """Updates the view for the specified model."""


# Class: Controller

class Controller:

    """
    This class is the base class for implementing the controller
    component of the model/view/controller (MVC) pattern.
    """

    def __init__(self):
        """Creates a Controller object."""
        self._controls = { }
        self._step_hooks = [ ]
        self._finish_hooks = [ ]
        self._error_handler = None
        self._speed_control = None
        self._target = self
        self._timer = None
        self._cstate = Controller.INITIAL
        self._fail_on_errors = True

    def set_model(self, obj):
        """Sets the model for this controller."""
        self._model = obj
        self._timer = self.create_timer(0, self.timer_action)
        self.set_speed(50)

    def set_target(self, target):
        self._target = target

    def get_target(self):
        return self._target

    def get_model(self):
        """Returns the model of this controller."""
        return self._model

    def add_control(self, control):
        """Adds the control to the list of controls for this controller."""
        self._controls[control.get_name()] = control
        control.set_controller(self)
#        self.add_change_listener(control)
#        if control.get_name() == "Speed":
#            speed_control = (Adjustable) control
#            speed_control.add_adjustment_listener(speed_listener)
#            set_speed(speed_control.get_value())

    def get_control(self, name):
        """Gets the control filed under the specified name."""
        return self._controls.get(name)

    def set_state(self, state):
        """Sets the controller state."""
        self._cstate = state

    def get_state(self):
        """Returns the state of the controller."""
        return self._cstate

    def set_fail_on_errors(self, flag):
        """Sets a flag indicating whether errors should simply fail."""
        self._fail_on_errors = flag

    def get_fail_on_errors(self):
        """Returns the setting of the fail_on_errors flag."""
        return self._fail_on_errors

    def get_state_name(self, state):
        """Translates a numeric controller state code into a state name."""
        return Controller.STATE_NAMES[state]

    def is_active(self):
        """Returns True if the controller is in an active state."""
        return self._cstate in Controller.ACTIVE_STATES

    def start_action(self):
        """Triggers a "start" action."""
        self.start(Controller.RUNNING)

    def stop_action(self):
        """Triggers a "stop" action."""
        if self.is_active():
            self.stop(Controller.STOPPED)

    def step_action(self):
        """Triggers a "step" action."""
        self.start(Controller.STEPPING)

    def call_action(self):
        """Triggers a "call" action."""
        if self._model.is_callable():
            self._call_depth = self._model.get_stack_depth()
            self.start(Controller.CALLING)
        else:
            self.start(Controller.STEPPING)

    def speed_to_timer_delay(self, speed):
        """Converts a speed into the corresponding timer delay."""
        if speed > 90:
            return 0
        return int((Controller.SLOW_DELAY +
                   (Controller.FAST_DELAY - Controller.SLOW_DELAY)
                   * speed / 90.0))

    def speed_to_cycle_count(self, speed):
        """Converts a speed into cycles to execute before yielding."""
        if speed < 90:
            return 1
        return min(Controller.MAX_CYCLE_COUNT, 1 << (speed - 90))

    def get_timer_delay(self):
        """Returns the timer delay for the current speed."""
        return self.speed_to_timer_delay(self._speed)

    def get_cycle_count(self):
        """Returns the cycle count for the current speed."""
        return self.speed_to_cycle_count(self._speed)

    def set_speed(self, speed):
        """Sets the speed for the controller."""
        self._timer.set_delay(self.speed_to_timer_delay(speed))

    def get_speed(self):
        """Returns the speed of the controller"""
        return self._speed

    def signal_error(self, msg):
        """Signals the occurrence of an error."""
        if self._fail_on_errors:
            raise Exception(msg)
        self.set_error_message(msg)
        self.set_state(Controller.ERROR)
        if self._error_handler is not None:
            self._error_handler.error(msg)

    def set_error_handler(self, handler):
        """Sets the error handler for this controller."""
        self._error_handler = handler

    def get_error_handler(self):
        """Returns the error handler for this controller."""
        return error_handler

    def get_error_message(self):
        """Gets the error message that caused the ERROR state."""
        return self._error_message

    def set_error_message(self, msg):
        """Sets the current error message."""
        error_message = msg

    def timer_action(self):
        """Executes a time step."""
        try:
            self.step_target()
        except Exception as ex:
            self.signal_error(str(ex))

    def stop(self, state):
        self.set_state(state)
        self._timer.stop()

    def start(self, state):
        self.set_state(state)
        self._timer.start()

    def get_call_depth(self):
        return self._call_depth

    def set_speed_callback(self, speed):
        this._speed = speed
        if self._timer is not None:
            self._timer.set_delay(self.speed_to_timer_delay(speed))

    def step(self):
        model = self._model
        old_state = self._cstate
        model.step()
        self.execute_step_hooks()
        if model.is_finished():
            self.execute_finish_hooks()
        if self.is_active():
            if old_state == Controller.RUNNING:
                if self._cstate == Controller.RUNNING:
                    self._timer.start()
            elif old_state == Controller.STEPPING:
                self.stop_action()
            elif old_state == Controller.CALLING:
                if model.get_stack_depth() <= self._call_depth:
                    self.stop_action()
                elif self._cstate == Controller.CALLING:
                    self._timer.start()

    def step_target(self):
        old_state = self._cstate
        self._target.step();
        self.step_complete(old_state);

    def should_keep_running(self):
        if self._cstate == Controller.RUNNING:
            return True
        elif self._cstate == Controller.CALLING:
            return self._model.get_stack_depth() > self._call_depth
        else:
            return False

    def step_complete(self, old_state):
        if old_state == Controller.RUNNING:
            if self._cstate == Controller.RUNNING:
                self._timer.start()
        elif old_state == Controller.STEPPING:
            self.stop_action()
        elif old_state == Controller.CALLING:
            if self._target.get_stack_depth() <= self._call_depth:
                self.stop_action()
            elif self._cstate == Controller.CALLING:
                self._timer.start()

    def add_step_hook(self, fn):
        """Adds a callback function that is run on every step."""
        self._step_hooks.append(fn)

    def remove_step_hook(self, fn):
        """Removes a previously added step hook."""
        if fn in self._step_hooks:
            self._step_hooks.remove(fn)

    def execute_step_hooks(self):
        """Calls all the registered step hooks."""
        for fn in self._step_hooks:
            fn()

    def add_finish_hook(self, fn):
        """Adds a callback function that is run when the model finishes."""
        self._finish_hooks.append(fn)

    def remove_finish_hook(self, fn):
        """Removes a previously added finish hook."""
        if fn in self._finish_hooks:
            self._finish_hooks.remove(fn)

    def execute_finish_hooks(self):
        """Calls all the registered finish hooks."""
        for fn in self._finish_hooks:
            fn()

# Factory methods

    def create_timer(self, delay, callback):
        return IntervalTimer(delay, callback)

    def create_timer_listener(self):
        return TimerListener(self)

    def create_speed_listener(self):
        return SpeedListener(self)

# Constants

    INITIAL = 0         # The controller has not yet started
    RUNNING = 1         # The controller is running
    STEPPING = 2        # The controller is running in single-step mode
    CALLING = 3         # The controller is running until the a return
    STOPPED = 4         # The controller is stopped at a breakpoint
    FINISHED = 5        # The controller has finished a process
    WAITING = 6         # The controller is waiting for some event
    ERROR = 7           # The controller has encountered an error

    ACTIVE_STATES = { RUNNING, CALLING, STEPPING }

    STATE_NAMES = [
        "INITIAL",
        "RUNNING",
        "STEPPING",
        "CALLING",
        "STOPPED",
        "FINISHED",
        "WAITING",
        "ERROR"
    ]

    MAX_CYCLE_COUNT = 10000
    SLOW_DELAY = 500
    FAST_DELAY = 5

# Class: IntervalTimer

class IntervalTimer:
    """This class simulates an interval timer."""

    def __init__(self, delay, fn):
        """Creates a new interval timer that calls fn() every delay ms."""
        self._timer = None
        self._delay = delay
        self._fn = fn
        self._running = False

    def start(self):
        """Starts the interval timer."""
        if not self._running:
            self._timer = threading.Timer(self._delay / 1000, self.step)
            self._running = True
            self._timer.start()

    def stop(self):
        """Stops the interval timer."""
        self._running = False
        self._timer.cancel()

    def step(self):
        """Runs the callback function on each timer tick."""
        self._fn()
        if self._running:
            self._running = False
            self.start()

    def set_delay(self, delay):
        """Sets the delay for the interval timer."""
        self._delay = delay


# Unit test


# Original file: parser.py

"""
This module defines a general-purpose parser.
"""

# Class: Operator

# Defines the default constructor for subclasses but is not called
# directly by clients.  The Parser class includes several methods
# that define operators.

class Operator(Expression):

    def __str__(self):
        return self._op_name

    def is_statement(self):
        return False

    def set_prefix_precedence(self, prec):
        self._prefix_prec = prec

    def get_prefix_precedence(self):
        return self._prefix_prec

    def set_infix_precedence(self, prec):
        self._infix_prec = prec

    def get_infix_precedence(self):
        return self._infix_prec

    def set_associativity(self, assoc):
        self._associativity = assoc

    def get_associativity(self):
        return self._associativity

    def get_type(self):
        return Expression.OPERATOR

    def is_assignment_operator(self):
        return False

    def set_name(self, name):
        self._op_name = name

    def get_name(self):
        return self._op_name

    def prefix_action(self, p):
        raise SyntaxError("Illegal use of operator " + str(self))

    def infix_action(self, p, lhs):
        raise SyntaxError("Illegal use of operator " + str(self))

    def unparse(self, p, args):
        raise NotYetImplemented("No implementation for unparse")

    def apply(self, ec, args):
        raise NotYetImplemented("Not implemented in the base class")

    def eval(self, ec):
        raise NotYetImplemented("Operators cannot be evaluated")

    def is_operator(self):
        return True

# Constants 

    LEFT = 0
    RIGHT = 1

# Class: Parser

# This class defines a simple recursive-descent parser driver.
# The parser structure was developed in 1974 by Eric Roberts
# and Greg Nelson and has proven to be extremely useful in
# the years since.  It is much less cumbersome to use than
# most parser-generator systems and makes it very easy to
# write simple actions for standard languages.  The parser
# algorithm is described in more detail in "Programming
# Abstractions in C" (Addison-Wesley, 1998).

class Parser:

    def __init__(self):
        self._scanner = self.create_token_scanner()
        self._operators = { }

    def parse(self):
        exp = self.read_e(0)
        token = self.next_token()
        if token != "<EOF>":
            raise SyntaxError("Unexpected token: " + token)
        return exp

# Parses the next expression from the parser input stream.  The prec
# argument specifies the prevailing precedence read_e will return if
# it encounters an operator whose precedence is lower than prec,
# using the associativity of the operator to break ties.   Since most
# clients will want to read a complete expression without stopping at
# any operator, the usual call is read_e(0).

    def read_e(self, prec):
        exp = self.read_t()
        token = self.next_token()
        while self.takes_precedence(token, prec):
            op = self.get_operator(token)
            if op.is_statement():
                raise SyntaxError("Illegal context for " + str(op))
            exp = op.infix_action(self, exp)
            token = self.next_token()
        self.save_token(token)
        return exp

# Reads a single term from the parser input stream.  A term may
# consist of an identifier, a parenthesized subexpression, or a
# prefix operator form.

    def read_t(self):
        token = self.next_token()
        if token == "<EOF>":
            raise SyntaxError("Unexpected end of line")
        ttype = self._scanner.get_token_type(token)
        if ttype == Scanner.WORD or ttype == Scanner.OPERATOR:
            op = self.get_operator(token)
            if op is None:
                if ttype == Scanner.OPERATOR:
                    raise SyntaxError("Undefined operator " + str(token))
                exp = Identifier.create(str(token))
                exp.set_bounds(token.get_start(), token.get_end())
                return exp
            if op.is_statement():
                raise SyntaxError("Illegal context for " + str(op))
            return op.prefix_action(self)
        else:
            exp = Constant.create(eval(str(token)))
            exp.set_bounds(token.get_start(), token.get_end())
            return exp

    def compile(self, exp, cv):
        raise Exception("No compiler defined in the base class")

    def define_prefix_operator(self, name, op, prec):
        """Defines a prefix-only operator."""
        self.define_operator(name, op, prec, 0)

    def define_infix_operator(self, name, op, prec, assoc=Operator.LEFT):
        """Defines a infix-only operator."""
        self.define_operator(name, op, 0, prec, assoc)

    def define_operator(self, name, op, prefix, infix, assoc=Operator.LEFT):
        """Defines a prefix/infix operator."""
        op.set_name(name)
        op.set_prefix_precedence(prefix)
        op.set_infix_precedence(infix)
        op.set_associativity(assoc)
        self._operators[name] = op

    def remove_operator(self, name):
        """Removes an operator from the operator table."""
        self._operators.pop(name, None)

    def get_operator_table(self):
        """Returns the operator table."""
        return self._operators

# Implementation notes: get_operator
# ----------------------------------
# The get_operator method returns a copy of the operator in the table
# so that the start and finish offsets from the token are recorded.

    def get_operator(self, token):
        """Returns the operator associated with token or None."""
        op = self._operators.get(str(token))
        if op is None:
            return None
        if isinstance(token, Token):
            op = copy.copy(op)
            op.set_bounds(token.get_start(), token.get_end())
        return op

    def get_scanner(self):
        """Returns the scanner used by the parser."""
        return self._scanner

    def set_input(self, input):
        """Sets the input for the scanner."""
        self._scanner.set_input(input)

    def has_more_tokens(self):
        """Returns True if the scanner has more tokens."""
        return self._scanner.has_more_tokens()

    def next_token(self):
        """Returns the next token from the scanner."""
        return self._scanner.next_token()

    def save_token(self, token):
        """Saves the token on the input stream to be read again."""
        self._scanner.save_token(token)

    def get_last_token(self):
        """Returns the last token read."""
        return self._scanner.get_last_token()

    def get_token_type(self, token):
        """Returns the token type."""
        return self._scanner.get_token_type(token)

    def verify_token(self, expected):
        """Checks that the token appears next in the input stream."""
        token = self.next_token()
        if token != expected:
            if token == "<EOF>":
                msg = "Missing " + mark_code(expected)
            else:
                msg = "Found {} when expecting {}".format(token, expected)
            raise SyntaxError(msg)

    def takes_precedence(self, token, prec):
        """Returns True if token has greater precedence than prec."""
        if token == "<EOF>":
            return False
        op = self.get_operator(str(token))
        if op is None:
            return False
        newprec = op.get_infix_precedence()
        if newprec == prec:
            return (op.get_associativity() == Operator.RIGHT)
        return (newprec > prec)

    def create_token_scanner(self):
        """Creates the scanner for use with this parser."""
        return Scanner()

# Class: PrefixForm

class PrefixForm(Operator):

    def __init__(self):
        Operator.__init__(self)

    def prefix_action(self, p):
        rhs = p.read_e(self.get_prefix_precedence())
        exp = Compound.create(self, rhs)
        exp.set_bounds(self.get_start(), rhs.get_end())
        return exp

# Class: PrefixOperator

class PrefixOperator(PrefixForm):

    def __init__(self):
        PrefixForm.__init__(self)

    def apply(self, ec, args):
        return self.apply1(ec, args[0].eval(ec))

    def apply1(self, ec, rhs):
        raise RuntimeError("Unimplemented operator '" + self + "'")

# Class: InfixForm

class InfixForm(Operator):

    def __init__(self):
        Operator.__init__(self)

    def infix_action(self, p, lhs):
        rhs = p.read_e(self.get_infix_precedence())
        exp = Compound.create(self, lhs, rhs)
        exp.set_bounds(lhs.get_start(), rhs.get_end())
        return exp

# Class: InfixOperator

class InfixOperator(InfixForm):

    def __init__(self):
        InfixForm.__init__(self)

    def apply(self, ec, args):
        return self.apply2(ec, args[0].eval(ec), args[1].eval(ec))

    def apply2(self, ec, lhs, rhs):
        raise RuntimeError("Undefined operator '" + self + "'")

# Class: NofixOperator

class NofixOperator(Operator):

    def prefix_action(self, p):
        Operator.__init__(self)
        exp = Compound.create(self)
        exp.set_bounds(self.get_start(), self.get_end())

# Class: Statement

class Statement(Operator):
    """This class is used as the superclass for all statements."""

    def __init__(self):
        Operator.__init__(self)

    def is_statement(self):
        return True


# Class: Module

class Module:

    """
    This class represents an ordered collection of entries, each of
    which is a tuple of a type name and an associated expression.
    """

    def __init__(self):
        """Creates a new Module object."""
        self._name = None
        self._entries = [ ]

    def to_string(self):
        if self._name is None:
            return "<module>"
        else:
            return "<module " + self._name + ">"

    def set_name(self, name):
        """Sets the name of this module."""
        self._name = name

    def get_name(self):
        """Gets the name of this module."""
        return self._name

    def add_entry(self, type, exp):
        """Adds the entry formed by the type code and expression."""
        self._entries.append((type,exp))

    def get_entries(self):
        """Returns a list of the entries in this module."""
        return self._entries

    def get_entries_by_type(self, type):
        """Returns a list containing entries of the specified type."""
        array = [ ]
        for entry in self._entries:
            if entry.type == type:
                array.append(entry)
        return array


# Unit test


# Original file: svm.py

"""
This file implements the Stanford Virtual Machine (SVM).
"""

class SVM(Controller):

    """
    This class implements the Stanford Virtual Machine (SVM), which
    interprets a stream of 32-bit integers as instructions in an
    environment that can be supplemented with library code.
    """

    def __init__(self):
        """Creates a SVM object."""
        Controller.__init__(self)
        self._globals = { }
        self._properties = { }
        self._code = None
        self._console = None
        self._source = None
        self._program = None
        self._trace_flag = False
        self._step_mode = SVM.BY_INSTRUCTION
        self._call_hooks = [ ]
        self._return_hooks = [ ]
        self._stop_hooks = [ ]
        self._statement_offset = 0
#        self.set_error_handler(SVMErrorHandler(self))
        self.define_class("Core", SVMCoreClass())
        self.define_class("Global", SVMGlobalClass())
#        self.define_class("Console", SVMConsoleClass())
        self.reset()

    def reset(self):
        """Resets the SVM to its initial state."""
        self._value_stack = [ ]
        self._frame_stack = [ ]
        self._exception_stack = [ ]
        self._event_queue = [ ]
        self._cf = SVMStackFrame()
        self.set_state(SVM.INITIAL)
        self.set_pc(0)

    def run(self):
        """Runs the code currently loaded into the SVM."""
        if self._code is None:
            self.set_state(SVM.INITIAL)
        else:
            self.set_state(SVM.RUNNING)
            while self.get_state() == SVM.RUNNING:
                try:
                    self.execute_instruction()
                except Exception as ex:
                    self.signal_error(str(ex))

    def stop_action(self):
        """Triggers a "stop" action."""
        Controller.stop_action(self)
        self.execute_stop_hooks()

    def step(self):
        """Executes one step of the virtual machine."""
        if self._code is None:
            self.set_state(SVM.INITIAL)
        else:
            if self._step_mode == SVM.BY_INSTRUCTION:
                self.execute_instruction()
            else:
                self.execute_instruction()
                while (self._code is not None and self._pc >= 0 and 
                       self._pc < len(self._code)):
                    state = self.get_state()
                    if state == SVM.ERROR or state == SVM.FINISHED:
                        break
                    self.execute_instruction()
                    if ((self._last_instruction >> 24) & 0xFF) == SVMOp.STMT:
                        break
            self.execute_step_hooks()

    def is_callable(self):
        """Returns True if the controller accepts CALL instructions."""
        return True

    def get_stack_depth(self):
        """Returns the call stack depth."""
        return len(self._frame_stack)

    def set_step_mode(self, mode):
        """Sets the step mode."""
        self._step_mode = mode

    def get_step_mode(self):
        """Returns the setting of the step-mode indicator."""
        return self._step_mode

    def execute_instruction(self):
        """Executes the next instruction."""
        if self._code is None:
            self.signal_error("No program")
        elif self._pc == SVM.ERROR_PC:
            self.signal_error("Illegal return without a function call")
        elif self._pc >= 0 and self._pc < len(self._code):
            self._last_instruction = self._code[self._pc]
            op = (self._last_instruction >> 24) & 0xFF
            addr = self._last_instruction & 0xFFFFFF
            ins = SVMInstruction.get(op)
            if self._trace_flag:
                print("(" + str(self._pc) + ") " + ins.unparse(self, addr))
            self._pc += 1
            ins.execute(self, addr)
        else:
            self.set_state(SVM.FINISHED)

    def get_last_instruction(self):
        """Returns the last instruction executed by the virtual machine."""
        return self._last_instruction

    def set_state(self, state):
        """Sets the controller state."""
        Controller.set_state(self, state)
        if state == SVM.WAITING or state == SVM.FINISHED:
            self.process_events()

    def set_trace_flag(self, flag):
        """Sets the trace flag for the SVM."""
        self._trace_flag = flag

    def get_trace_flag(self):
        """Gets the current value of the trace flag."""
        return self._trace_flag

    def set_console(self, console):
        """Sets the console attached to the SVM."""
        self._console = console

    def get_console(self):
        """Returns the console in use by the SVM."""
        return self._console

    def set_source(self, source):
        """Sets the source string for the parser."""
        self._source = source

    def get_source(self):
        """Gets the source string for the parser."""
        return self._source

    def set_statement_offset(self, offset):
        """Stores the offset in the source for the current statement."""
        self._statement_offset = offset

    def get_statement_offset(self):
        """Returns the offset in the source for the current statement."""
        return self._statement_offset

    def get_source_marker(self, index):
        """Returns a source marker for an index in the source string."""
        if self._source is None or index < 0:
            return None
        start = self._source.rfind("\n", index) + 1
        finish = self._source.find("\n", start)
        if finish == -1:
            finish = len(source)
        return SVMSourceMarker(source[start:finish], start)

    def set_code(self, code):
        """Sets the code array that represents the program."""
        self._code = code
        if self._cf is not None:
            self._cf.set_code(code)

    def get_code(self):
        """Gets the code array that represents the program."""
        return self._code

    def get(self, addr):
        """Gets the word at the specified address in the code array."""
        return self._code[addr]

    def get_string(self, addr):
        """Gets a string stored in the code array."""
        return CodeVector.get_string(self._code, addr)

    def set_pc(self, addr):
        """Sets the PC to the specified address."""
        self._pc = addr

    def get_pc(self):
        """Gets the current PC value."""
        return self._pc

    def push(self, v):
        """Pushes an SVM value on the value stack."""
        self._value_stack.append(v)

    def push_integer(self, n):
        """Pushes an integer Value on the stack."""
        self._value_stack.append(Value.create_integer(n))

    def push_double(self, d):
        """Pushes a double Value on the stack."""
        self._value_stack.append(Value.create_double(d))

    def push_boolean(self, b):
        """Pushes a Boolean Value on the stack."""
        self._value_stack.append(Value.create_boolean(b))

    def push_string(self, str):
        """Pushes a string Value on the stack."""
        self._value_stack.append(Value.create_string(str))

    def pop(self):
        """Pops the top item from the stack as a typed Value object."""
        return self._value_stack.pop()

    def pop_integer(self):
        """Pops the top item from the stack as an integer."""
        return self._value_stack.pop().get_integer_value()

    def pop_double(self):
        """Pops the top item from the stack as an double."""
        return self._value_stack.pop().get_double_value()

    def pop_boolean(self):
        """Pops the top item from the stack as an boolean."""
        return self._value_stack.pop().get_boolean_value()

    def pop_string(self):
        """Pops the top item from the stack as an string."""
        return self._value_stack.pop().get_string_value()

    def exch(self):
        """Exchanges the top two elements on the stack."""
        x = self.pop()
        y = self.pop()
        self.push(x)
        self.push(y)

    def roll(self, n):
        """Rolls the top n values on the stack up by one position."""
        values = [ ]
        for i in range(n):
            values.append(self.pop())
        self.push(values[0])
        for i in reversed(range(1, n)):
            self.push(values[i])

    def copy(self, n):
        """Copies the top n values on the stack."""
        for i in range(n):
            self.push(self.peek_back(n - 1))

    def get_value_stack_depth(self):
        """Returns the number of elements pushed on the value stack."""
        return len(self._value_stack)

    def peek_back(self, k):
        """Returns the element on the stack k elements from the top."""
        return self._value_stack[-k - 1]

    def get_current_frame(self):
        """Returns the current stack frame."""
        return self._cf

    def push_frame(self):
        """Pushes a empty stack frame onto the frame stack."""
        self._frame_stack.append(self._cf)
        self._cf = SVMStackFrame()
        self._cf.set_code(self._code)

    def pop_frame(self):
        """Pops the top stack frame and makes it the current frame."""
        if len(self._frame_stack) == 0:
            self._cf = None
        else:
            self._cf = self._frame_stack.pop()
        if self._cf is not None:
            self._code = self._cf.get_code()

    def get_argument_count(self):
        """Returns the number of arguments field from the frame."""
        return self.get_current_frame().get_argument_count()

    def get_nargs_count(self):
        """Returns the number of arguments from the NARGS instruction."""
        if self._pc < 0 or self._pc >= len(self._code):
            return -1
        ins = self.get(self._pc)
        if ((ins >> 24) & 0xFF) != SVMOp.NARGS:
            return -1
        return ins & 0xFFFFFF

    def check_signature(self, name, sig):
        """Checks that the arguments match the specified signature."""
        n_args = self.get_argument_count()
        if n_args == -1:
            return
        n = len(sig)
        if n != n_args:
            raise Exception("Wrong number of arguments to " + name)
        for i in range(n):
            if not self.check_arg_type(self.peek_back(n - i - 1), sig[i]):
                raise Exception("Type mismatch in call to " + name)

    def check_argument_count(self, n_args, n_params):
        """Checks that the number of arguments and parameters match."""
        for i in range(n_params, n_args):
            self.pop()
        for i in range(n_args, n_params):
            self.push(Value.UNDEFINED)

    def set_global(self, name, value):
        """Defines name in the table of global variables."""
        self._globals[name] = value

    def get_global(self, name):
        """Gets the definition of the named global variable."""
        return self._globals.get(name, Value.UNDEFINED)

    def get_global_integer(self, name, def_value):
        """Gets a global definition of an integer."""
        if self.is_global(name):
            return self._globals.get(name).get_integer_value()
        return def_value

    def get_global_double(self, name, def_value):
        """Gets a global definition of a floating-point number."""
        if self.is_global(name):
            return self._globals.get(name).get_double_value()
        return def_value

    def get_global_boolean(self, name, def_value):
        """Gets a global definition of a Boolean value."""
        if self.is_global(name):
            return self._globals.get(name).get_boolean_value()
        return def_value

    def get_global_string(self, name, def_value):
        """Gets a global definition of a string value."""
        if self.is_global(name):
            return self._globals.get(name).get_string_value()
        return def_value

    def is_global(self, name):
        """Returns True if the global variable is defined."""
        return name in self._globals

    def call(self, n):
        """Call the function or method closure on the top of the stack."""
        fn = self.peek_back(0)
        type = fn.get_type()
        if type != "SVMMethod":
            self.execute_call_hooks()
        self.pop()
        if type == "FunctionClosure":
            fc = fn.get_value()
            receiver = self.get_current_frame().get_receiver()
            self.push_frame()
            cf = self.get_current_frame()
            cf.set_self(receiver)
            cf.set_return_address(self.get_pc())
            cf.set_frame_link(fc.get_frame())
            cf.set_argument_count(n)
            code = fc.get_code()
            if code is not None:
                self.set_code(code)
            self.set_pc(fc.get_address())
        elif type == "MethodClosure":
            mc = fn.get_value()
            receiver = mc.get_receiver()
            c = SVMClass.lookup(mc.get_type())
            m = c.get_method(mc.get_method_name())
            self.get_current_frame().set_argument_count(n)
            m.execute(self, receiver)
        elif type == "SVMMethod":
            m = fn.get_value()
            self.get_current_frame().set_argument_count(n)
            m.execute(self, None)
        elif type == "Class":
            c = SVMClass.lookup(fn.get_value())
            m = c.get_method("new")
            self.get_current_frame().set_argument_count(n)
            m.execute(self, None)
        else:
            raise Exception("Illegal function call")

    def post_event(self, closure):
        """Posts an event closure on the event queue."""
        self._event_queue.append(closure)
        self.process_events()

    def set_property(self, name, value):
        """Sets a named property for self SVM."""
        self._properties[name] = value

    def get_property(self, name):
        """Gets a named property for self SVM."""
        return self._properties.get(name)

    def define_class(self, name, c):
        """Defines a class for self SVM."""
        SVMClass.define_class(self, name, c)

    def check_arg_type(self, v, type):
        if type == "B":
            return v.get_type() == Value.BOOLEAN
        elif type == "D":
            return v.is_numeric()
        elif type == "I":
            return v.is_integral()
        elif type == "O":
            return v.get_type() == Value.OBJECT
        elif type == "S":
            return v.get_type() == Value.STRING
        elif type == "*":
            return True
        raise Exception("Illegal type code: " + type)

    def process_events(self):
        state = self.get_state()
        if state == SVM.WAITING or state == SVM.FINISHED:
            "// Process event queue"

    def set_stack_base(self, offset):
        """Sets the base stack offset for the current stack frame."""
        self._cf.set_stack_base(len(self._value_stack) - offset)

    def restore_stack_base(self):
        """Restores the stack base to the value set in the frame."""
        if self._cf is None:
            return
        base = self._cf.get_stack_base()
        while len(self._value_stack) > base:
            self._value_stack.pop()

    def push_exception_frame(self, addr):
        """Pushes a exception frame."""
        self._exception_stack.append(ExceptionFrame(addr,
                                                    len(self._frame_stack)))

    def pop_exception_frame(self):
        """Removes the top exception frame."""
        self._exception_stack.pop()

    def raise_exception(self, ex, v):
        """Throws a runtime exception in the SVM."""
        "// Implement exceptions"

    def pstack(self):
        """Prints the contents of the stack, starting at the top."""
        if len(self._value_stack) == 0:
            print("")
        else:
            v = self._value_stack.pop()
            print(str(v) + " ", end="")
            self.pstack()
            self._value_stack.append(v)

    def unparse(self, word):
        op = (word >> 24) & 0xFF
        addr = word & 0xFFFFFF
        ins = SVMInstruction.get(op)
        if ins is None:
            return str(word)
        else:
            return ins.unparse(self, addr)
        
    def list(self):
        """Unparses the contents of the internal code array."""
        self.list_code(self._code)

    def list_code(self, code):
        """Unparses the contents of code as instructions."""
        n = len(code)
        for i in range(n):
            line = "(" + str(i) + ") " + self.unparse(code[i])
            if (code[i] >> 24) == SVMOp.END:
                break
            print(line)

    def add_call_hook(self, hook):
        """Adds a hook procedure called before any call instruction."""
        self._call_hooks.append(hook)

    def add_return_hook(self, hook):
        """Adds a hook procedure called after a function returns."""
        self._return_hooks.append(hook)

    def add_stop_hook(self, hook):
        """Adds a hook procedure called when the controller stops."""
        self._stop_hooks.append(hook)

    def execute_call_hooks(self):
        """Executes the call hooks registered for self SVM."""
        for hook in self._call_hooks:
            if callable(hook):
                hook()
            else:
                hook.execute()

    def execute_return_hooks(self):
        """Executes the return hooks registered for self SVM."""
        for hook in self._return_hooks:
            if callable(hook):
                hook()
            else:
                hook.execute()

    def execute_stop_hooks(self):
        """Executes the stop hooks registered for self SVM."""
        for hook in self._stop_hooks:
            if callable(hook):
                hook()
            else:
                hook.execute()

# Constants 

    ERROR_PC = -999
    BY_INSTRUCTION = 0
    BY_STATEMENT = 1

    INITIAL = Controller.INITIAL
    RUNNING = Controller.RUNNING
    STEPPING = Controller.STEPPING
    CALLING = Controller.CALLING
    STOPPED = Controller.STOPPED
    FINISHED = Controller.FINISHED
    WAITING = Controller.WAITING
    ERROR = Controller.ERROR


# Class: SVMFunctionClosure

class SVMFunctionClosure:

    """
    This class defines a structure consisting of a code vector, an
    entry address, and a stack frame.
    """

    def __init__(self, code, addr, frame):
        self._code = code
        self._addr = addr
        self._frame = frame

    def __str__(self):
        return "FunctionClosure@" + str(self._addr)

    def get_address(self):
        return self._addr

    def get_code(self):
        return self._code

    def get_frame(self):
        return self._frame


# Class: SVMMethodClosure

class SVMMethodClosure:

    """
    This class defines a structure consisting of a receiver, a class
    name, and a method name.
    """

    def __init__(self, receiver, class_name, method_name):
        self._receiver = receiver
        self._class_name = class_name
        self._method_name = method_name

    def __str__(self):
        self._receiver = receiver
        return self._class_name + "." + self._method_name

    def get_receiver(self):
        return self._receiver

    def get_class_name(self):
        return self._class_name

    def get_method_name(self):
        return self._method_name


# Class: SVMClass

class SVMClass:

    """
    This class defines a package that can be loaded into the SVM.
    """

    def __init__(self):
        """Creates an SVMClass object."""
        self._methods = { }

    def get_method(self, name):
        """Gets the method with the specified name."""
        m = self._methods.get(name)
        if m is None:
            raise Exception(name + " is not defined")
        return m

    def define_method(self, name, m):
        """Defines a method for this class."""
        self._methods[name] = m

    def init(self, svm):
        """Initializes a class."""
        fn = self._methods.get("_init")
        if fn is not None:
            fn.execute(svm, None)

    @staticmethod
    def is_defined(name):
        """Returns True if the class has been defined."""
        return name in SVMClass._classes

    @staticmethod
    def lookup(name):
        """Looks up a class by name."""
        c = SVMClass._classes.get(name)
        if c is None:
            raise Exception(name + " is not defined")
        return c

    @staticmethod
    def define_class(svm, name, c):
        """Defines the named class in the context of the SVM."""
        c.init(svm)
        SVMClass._classes[name] = c
        svm.set_global(name, Value("Class", name))

SVMClass._classes = { }

# Class: SVMMethod

class SVMMethod:

    """This class represents the superclass of all built-in methods."""

    def execute(self, svm, receiver):
        raise Exception("Not defined in the base class.")

    def is_constant(self):
        return False


# Class: SVMConstant

class SVMConstant(SVMMethod):
    def is_constant(self):
        return True


# Class: SVMCoreClass

class SVMCoreClass(SVMClass):

    def __init__(self):
        SVMClass.__init__(self)
        self.define_method("FALSE", Core_FALSE())
        self.define_method("TRUE", Core_TRUE())
        self.define_method("UNDEFINED", Core_UNDEFINED())
        # self.define_method("INFINITY", Core_INFINITY())
        # self.define_method("NaN", Core_NaN())
        # self.define_method("NULL", Core_NULL())
        # self.define_method("this", Core_this())
        # self.define_method("set_receiver", Core_set_receiver())
        # self.define_method("display", Core_display())
        # self.define_method("select", Core_select())
        # self.define_method("assign", Core_assign())
        # self.define_method("list", Core_list())
        # self.define_method("array", Core_array())
        # self.define_method("object", Core_object())
        # self.define_method("length", Core_length())

class Core_FALSE(SVMConstant):

    def execute(self, svm, receiver):
        svm.check_signature("Core.FALSE", "")
        svm.push_boolean(False)


class Core_TRUE(SVMConstant):

    def execute(self, svm, receiver):
        svm.check_signature("Core.TRUE", "")
        svm.push_boolean(True)


class Core_UNDEFINED(SVMConstant):

    def execute(self, svm, receiver):
        svm.check_signature("Core.UNDEFINED", "")
        svm.push(Value.UNDEFINED)


class SVMGlobalClass(SVMClass):

    def __init__(self):
        SVMClass.__init__(self)
        self.define_method("get", GlobalGet())
        self.define_method("set", GlobalSet())
        self.define_method("is_defined", GlobalIsDefined())


class GlobalGet(SVMMethod):
    def execute(self, svm, receiver):
        svm.check_signature("Global.get", "S")
        svm.push(svm.get_global(svm.pop_string()))


class GlobalSet(SVMMethod):
    def execute(self, svm, receiver):
        svm.check_signature("Global.set", "S*")
        value = svm.pop()
        key = svm.pop_string()
        svm.set_global(key, value)


class GlobalIsDefined(SVMMethod):
    def execute(self, svm, receiver):
        svm.check_signature("Global.is_defined", "S")
        svm.push_boolean(svm.is_global(svm.pop_string()))


# Class: ExceptionFrame

class ExceptionFrame:

    def __init__(self, addr, depth):
        self._addr = addr
        self._depth = depth

    def get_dispatch_address(self):
        """Gets the dispatch address for this frame."""
        return self._addr

    def get_stack_depth(self):
        """Return the stack depth at which this frame was declared."""
        return self._depth

# Class: SVMStackFrame

class SVMStackFrame:

    """This class represents a stack frame for the SVM."""

    def __init__(self):
        """Initializes a stack frame."""
        self._symbol_table = None
        self._stack_base = 0
        self._frame_size = 0
        self._arg_count = 0
        self._return_address = -1
        self._link = None
        self._code = None
        self._self_ref = Value.NULL
        self._receiver = Value.NULL

    def set_frame_size(self, n):
        """Sets the number of locals for the frame to n."""
        self._frame_size = n
        self._locals = [ None ] * n

    def get_frame_size(self):
        """Returns the number of locals for the frame."""
        return self._frame_size

    def set_argument_count(self, n):
        """Sets the number of arguments supplied for this frame."""
        self._arg_count = n

    def get_argument_count(self):
        """Gets the number of arguments supplied for this frame."""
        return self._arg_count

    def set_stack_base(self, base):
        """Sets the stack base for the frame."""
        self._stack_base = base

    def get_stack_base(self):
        """Gets the stack base for the frame."""
        return self._stack_base

    def set_code(self, code):
        """Sets the code array being executed by this frame."""
        self._code = code

    def get_code(self):
        """Gets the code array being executed by this frame."""
        return self._code

    def set_return_address(self, addr):
        """Sets the return address for this frame."""
        self._return_address = addr

    def get_return_address(self):
        """Gets the return address for this frame."""
        return self._return_address

    def set_source_file(self, filename):
        """Sets the name of the source file."""
        self._source_file = filename

    def get_source_file(self):
        """Gets the name of the source file."""
        return self._source_file

    def set_local(self, k, value):
        """Sets the value of the local at index k."""
        self._locals[k] = value

    def get_local(self, k):
        """Gets the value of the local at index k."""
        return self._locals[k]

    def declare_var(self, name):
        """Declares a named variable in the frame."""
        if self._symbol_table is None:
            self._symbol_table = { }
        self._symbol_table[name] = Value.UNDEFINED

    def is_declared(self, name):
        """Checks if a variable has been declared."""
        if self._symbol_table is None:
            return False
        return name in self._symbol_table

    def set_var(self, name, value):
        """Sets the value of a named variable."""
        if self._symbol_table is None:
            self._symbol_table = { }
        self._symbol_table[name] = value

    def get_var(self, name):
        """Gets the value of a named variable."""
        if self._symbol_table is None or name not in self._symbol_table:
            return Value.UNDEFINED
        return self._symbol_table.get(name)

    def set_frame_link(self, frame):
        """Sets the frame link field."""
        self._link = frame

    def get_frame_link(self):
        """Gets the frame link field."""
        return self._link

    def set_receiver(self, value):
        """Sets the receiver field."""
        self._receiver = value

    def get_receiver(self):
        """Gets the receiver field."""
        return self._receiver

    def set_self(self, value):
        """Sets the value of self."""
        self._self = value

    def get_self():
        """Gets the value of self."""
        return self._self

# Class: SVMInstruction

class SVMInstruction:

    def __init__(self, name, code):
        self._name = name
        self._code = code

    def get_name(self):
        return self._name

    def get_code(self):
        return self._code

    def execute(self, svm, addr):
        raise Exception("Not yet implemented")

    def unparse(self, svm, addr):
        return self._name

    def assemble(self, cv, scanner):
        cv.add_word(self._code << 24)

    @staticmethod
    def lookup(name):
        if SVMInstruction.INSTRUCTION_TABLE is None:
            SVMInstruction.initialize_tables()
        return SVMInstruction.INSTRUCTION_TABLE.get(name)

    @staticmethod
    def get(code):
        if SVMInstruction.INSTRUCTION_TABLE is None:
            SVMInstruction.initialize_tables()
        return SVMInstruction.CODE_TABLE.get(code)

    @staticmethod
    def initialize_tables():
        SVMInstruction.INSTRUCTION_TABLE = { }
        SVMInstruction.CODE_TABLE = { }
        SVMInstruction.define(END_Ins())
        SVMInstruction.define(VERSION_Ins())
        SVMInstruction.define(PSTACK_Ins())
        SVMInstruction.define(STMT_Ins())
        SVMInstruction.define(HALT_Ins())
        SVMInstruction.define(NOP_Ins())
        SVMInstruction.define(PUSHINT_Ins())
        SVMInstruction.define(PUSHNUM_Ins())
        SVMInstruction.define(PUSHSTR_Ins())
        SVMInstruction.define(PUSHFN_Ins())
        SVMInstruction.define(POP_Ins())
        SVMInstruction.define(DUP_Ins())
        SVMInstruction.define(EXCH_Ins())
        SVMInstruction.define(ROLL_Ins())
        SVMInstruction.define(COPY_Ins())
        SVMInstruction.define(ADD_Ins())
        SVMInstruction.define(SUB_Ins())
        SVMInstruction.define(MUL_Ins())
        SVMInstruction.define(DIV_Ins())
        SVMInstruction.define(IDIV_Ins())
        SVMInstruction.define(REM_Ins())
        SVMInstruction.define(NEG_Ins())
        SVMInstruction.define(EQ_Ins())
        SVMInstruction.define(NE_Ins())
        SVMInstruction.define(LT_Ins())
        SVMInstruction.define(LE_Ins())
        SVMInstruction.define(GT_Ins())
        SVMInstruction.define(GE_Ins())
        SVMInstruction.define(JUMP_Ins())
        SVMInstruction.define(JUMPT_Ins())
        SVMInstruction.define(JUMPF_Ins())
        SVMInstruction.define(DISPATCH_Ins())
        SVMInstruction.define(TRY_Ins())
        SVMInstruction.define(ENDTRY_Ins())
        SVMInstruction.define(THROW_Ins())
        SVMInstruction.define(NOT_Ins())
        SVMInstruction.define(AND_Ins())
        SVMInstruction.define(OR_Ins())
        SVMInstruction.define(XOR_Ins())
        SVMInstruction.define(LSH_Ins())
        SVMInstruction.define(ASH_Ins())
        SVMInstruction.define(CALL_Ins())
        SVMInstruction.define(CALLM_Ins())
        SVMInstruction.define(CALLFN_Ins())
        SVMInstruction.define(RETURN_Ins())
        SVMInstruction.define(LOCALS_Ins())
        SVMInstruction.define(PUSHLOC_Ins())
        SVMInstruction.define(POPLOC_Ins())
        SVMInstruction.define(ARG_Ins())
        SVMInstruction.define(VAR_Ins())
        SVMInstruction.define(PARAMS_Ins())
        SVMInstruction.define(NARGS_Ins())
        SVMInstruction.define(VARGS_Ins())
        SVMInstruction.define(PUSHVAR_Ins())
        SVMInstruction.define(POPVAR_Ins())
        SVMInstruction.define(PUSHFRM_Ins())
        SVMInstruction.define(POPFRM_Ins())

    @staticmethod
    def define(ins):
        SVMInstruction.INSTRUCTION_TABLE[ins.get_name()] = ins
        SVMInstruction.CODE_TABLE[ins.get_code()] = ins

SVMInstruction.INSTRUCTION_TABLE = None
SVMInstruction.CODE_TABLE = None

class SVMStringInstruction(SVMInstruction):

    def __init__(self, name, code):
        SVMInstruction.__init__(self, name, code)

    def assemble(self, cv, scanner):
        s = eval(str(scanner.next_token()))
        cv.add_word((self.get_code() << 24) | cv.string_ref(s))

    def unparse(self, svm, addr):
        return self.get_name() + " \"" + svm.get_string(addr) + "\""


class SVMVarInstruction(SVMInstruction):

    def __init__(self, name, code):
        SVMInstruction.__init__(self, name, code)

    def assemble(self, cv, scanner):
        token = scanner.next_token()
        cv.add_word((self.get_code() << 24) | cv.string_ref(str(token)))

    def unparse(self, svm, addr):
        return self.get_name() + " " + svm.get_string(addr)

class SVMAddressInstruction(SVMInstruction):

    def __init__(self, name, code):
        SVMInstruction.__init__(self, name, code)

    def assemble(self, cv, scanner):
        token = scanner.next_token()
        ttype = scanner.get_token_type(token)
        if ttype == Scanner.NUMBER:
            cv.add_word((self.get_code() << 24) | int(str(token)))
        elif ttype == Scanner.WORD:
            cv.add_word((self.get_code() << 24) | cv.label_ref(str(token)))
        else:
            raise Exception("Illegal argument " + str(token))

    def unparse(self, svm, addr):
        return self.get_name() + " " + str(addr)


class SVMOffsetInstruction(SVMInstruction):

    def __init__(self, name, code):
        SVMInstruction.__init__(self, name, code)

    def assemble(self, cv, scanner):
        token = scanner.next_token()
        ttype = scanner.get_token_type(token)
        if ttype == Scanner.NUMBER:
            cv.add_word((self.get_code() << 24) | int(str(token)))
        elif ttype == Scanner.WORD:
            cv.add_word((self.get_code() << 24) | cv.get_label(str(token)))
        else:
            raise Exception("Illegal argument " + str(token))

    def unparse(self, svm, addr):
        return self.get_name() + " " + str(addr)


class SVMNameInstruction(SVMInstruction):

    def __init__(self, name, code):
        SVMInstruction.__init__(self, name, code)

    def assemble(self, cv, scanner):
        name = ""
        finished = False
        while not finished:
            token = scanner.next_token()
            if token == "\n":
                finished = True
            else:
                name += str(token)
        scanner.save_token("\n")
        cv.add_word((self.get_code() << 24) | cv.string_ref(name))


class ArithmeticInstruction(SVMInstruction):

    def __init__(self, name, code):
        SVMInstruction.__init__(self, name, code)

    def execute(self, svm, addr):
        rhs = svm.pop()
        lhs = svm.pop()
        if not lhs.is_numeric() or not rhs.is_numeric():
            raise Exception("Illegal to apply " + get_name() +
                            " to " + lhs + " and " + rhs)
        lhtype = lhs.get_type()
        rhtype = rhs.get_type()
        if lhtype == Value.INTEGER and rhtype == Value.INTEGER:
            x = lhs.get_integer_value()
            y = rhs.get_integer_value()
            svm.push_integer(self.apply_integer(x, y))
        else:
            x = lhs.get_double_value()
            y = rhs.get_double_value()
            svm.push_double(self.apply_double(x, y))

    def apply_integer(self, x, y):
        raise Exception("Illegal types for operator")

    def apply_double(self, x, y):
        raise Exception("Illegal types for operator")


class ComparisonInstruction(SVMInstruction):

    def __init__(self, name, code):
        SVMInstruction.__init__(self, name, code)

    def execute(self, svm, addr):
        rhs = svm.pop()
        lhs = svm.pop()
        lhtype = lhs.get_type()
        rhtype = rhs.get_type()
        if lhtype == Value.STRING and rhtype == Value.STRING:
            s1 = lhs.get_string_value()
            s2 = rhs.get_string_value()
            svm.push_boolean(self.apply_string(s1, s2))
        elif lhtype == Value.INTEGER and rhtype == Value.INTEGER:
            x = lhs.get_integer_value()
            y = rhs.get_integer_value()
            svm.push_boolean(self.apply_integer(x, y))
        elif lhs.is_numeric() and rhs.is_numeric():
            x = lhs.get_double_value()
            y = rhs.get_double_value()
            svm.push_boolean(self.apply_double(x, y))
        else:
            v1 = lhs.get_value()
            v2 = rhs.get_value()
            svm.push_boolean(self.apply_object(v1, v2))

    def apply_integer(self, x, y):
        raise Exception("Illegal types for operator")

    def apply_double(self, x, y):
        raise Exception("Illegal types for operator")

    def apply_string(self, x, y):
        raise Exception("Illegal types for operator")

    def apply_object(self, v1, v2):
        raise Exception("Illegal types for operator")


class LogicalInstruction(SVMInstruction):

    def __init__(self, name, code):
        SVMInstruction.__init__(self, name, code)

    def execute(self, svm, addr):
        rhs = svm.pop()
        lhs = svm.pop()
        lhtype = lhs.get_type()
        rhtype = rhs.get_type()
        if lhtype == Value.BOOLEAN and rhtype == Value.BOOLEAN:
            v1 = lhs.get_boolean_value()
            v2 = rhs.get_boolean_value()
            svm.push_boolean(self.apply_boolean(v1, v2))
        else:
            x = lhs.get_integer_value()
            y = rhs.get_integer_value()
            svm.push_integer(self.apply_integer(x, y))

    def apply_integer(self, v1, v2):
        raise Exception("Illegal types for operator")

    def apply_boolean(self, v1, v2):
        raise Exception("Illegal types for operator")


class END_Ins(SVMInstruction):

    def __init__(self):
        SVMInstruction.__init__(self, "END", SVMOp.END)

    def execute(self, svm, addr):
        svm.set_pc(-1)


class VERSION_Ins(SVMOffsetInstruction):

    def __init__(self):
        SVMOffsetInstruction.__init__(self, "VERSION", SVMOp.VERSION)

    def execute(self, svm, addr):
        if addr != SVMOp.SVM_VERSION:
            raise Exception("Incompatible SVM version")


class PSTACK_Ins(SVMInstruction):

    def __init__(self):
        SVMInstruction.__init__(self, "PSTACK", SVMOp.PSTACK)

    def execute(self, svm, addr):
        svm.pstack()


class STMT_Ins(SVMOffsetInstruction):

    def __init__(self):
        SVMOffsetInstruction.__init__(self, "STMT", SVMOp.STMT)

    def execute(self, svm, addr):
        svm.set_statement_offset(addr)
        svm.restore_stack_base()


class HALT_Ins(SVMInstruction):

    def __init__(self):
        SVMInstruction.__init__(self, "HALT", SVMOp.HALT)

    def execute(self, svm, addr):
        svm.set_pc(-1)


class NOP_Ins(SVMInstruction):

    def __init__(self):
        SVMInstruction.__init__(self, "NOP", SVMOp.NOP)

    def execute(self, svm, addr):
        pass


class PUSHINT_Ins(SVMAddressInstruction):

    def __init__(self):
        SVMAddressInstruction.__init__(self, "PUSHINT", SVMOp.PUSHINT)

    def execute(self, svm, addr):
        svm.push_integer(addr)


class PUSHNUM_Ins(SVMInstruction):

    def __init__(self):
        SVMInstruction.__init__(self, "PUSHNUM", SVMOp.PUSHNUM)

    def assemble(self, cv, scanner):
        numstr = str(scanner.next_token())
        if numstr == "-":
            numstr += str(scanner.next_token())
        cv.add_word((self.get_code() << 24) | cv.string_ref(numstr))

    def execute(self, svm, addr):
        s = svm.get_string(addr)
        if s.find(".") == -1 and s.upper().find("E") == -1:
            svm.push_integer(int(s))
        else:
            svm.push_double(float(s))

    def unparse(self, svm, addr):
        return "PUSHNUM " + svm.get_string(addr)


class PUSHCH_Ins(SVMAddressInstruction):

    def __init__(self):
        SVMAddressInstruction.__init__(self, "PUSHCH", SVMOp.PUSHCH)

    def execute(self, svm, addr):
        svm.push(Value.create_character(addr))


class PUSHSTR_Ins(SVMStringInstruction):

    def __init__(self):
        SVMStringInstruction.__init__(self, "PUSHSTR", SVMOp.PUSHSTR)

    def execute(self, svm, addr):
        svm.push_string(svm.get_string(addr))


class PUSHFN_Ins(SVMAddressInstruction):

    def __init__(self):
        SVMAddressInstruction.__init__(self, "PUSHFN", SVMOp.PUSHFN)

    def execute(self, svm, addr):
        cf = svm.get_current_frame()
        code = svm.get_code()
        closure = SVMFunctionClosure(code, addr, cf)
        svm.push(Value("FunctionClosure", closure))


class POP_Ins(SVMInstruction):

    def __init__(self):
        SVMInstruction.__init__(self, "POP", SVMOp.POP)

    def assemble(self, cv, scanner):
        cv.add_word(SVMOp.POP << 24)

    def execute(self, svm, addr):
        svm.pop()


class DUP_Ins(SVMInstruction):

    def __init__(self):
        SVMInstruction.__init__(self, "DUP", SVMOp.DUP)

    def execute(self, svm, addr):
        svm.push(svm.peek_back(0))


class EXCH_Ins(SVMInstruction):

    def __init__(self):
        SVMInstruction.__init__(self, "EXCH", SVMOp.EXCH)

    def execute(self, svm, addr):
        svm.exch()


class ROLL_Ins(SVMOffsetInstruction):

    def __init__(self):
        SVMOffsetInstruction.__init__(self, "ROLL", SVMOp.ROLL)

    def execute(self, svm, addr):
        svm.roll(addr)


class COPY_Ins(SVMOffsetInstruction):

    def __init__(self):
        SVMOffsetInstruction.__init__(self, "COPY", SVMOp.COPY)

    def execute(self, svm, addr):
        svm.copy(addr)


class ADD_Ins(SVMInstruction):

    def __init__(self):
        SVMInstruction.__init__(self, "ADD", SVMOp.ADD)

    def execute(self, svm, addr):
        rhs = svm.pop()
        lhs = svm.pop()
        lhtype = lhs.get_type()
        rhtype = rhs.get_type()
        if lhtype == Value.STRING or rhtype == Value.STRING:
            svm.push_string(str(lhs) + str(rhs))
        elif not lhs.is_numeric() or not rhs.is_numeric():
            raise Exception("Illegal to apply " + self.get_name() +
                            " to " + lhs + " and " + rhs)
        elif lhtype == Value.INTEGER and rhtype == Value.INTEGER:
            x = lhs.get_integer_value()
            y = rhs.get_integer_value()
            svm.push_integer(x + y)
        else:
            x = lhs.get_double_value()
            y = rhs.get_double_value()
            svm.push_double(x + y)


class SUB_Ins(ArithmeticInstruction):

    def __init__(self):
        ArithmeticInstruction.__init__(self, "SUB", SVMOp.SUB)

    def apply_integer(self, x, y):
        return x - y

    def apply_double(self, x, y):
        return x - y


class MUL_Ins(ArithmeticInstruction):

    def __init__(self):
        ArithmeticInstruction.__init__(self, "MUL", SVMOp.MUL)

    def apply_integer(self, x, y):
        return x * y

    def apply_double(self, x, y):
        return x * y


class DIV_Ins(SVMInstruction):

    def __init__(self):
        SVMInstruction.__init__(self, "DIV", SVMOp.DIV)

    def execute(self, svm, addr):
        rhs = svm.pop()
        lhs = svm.pop()
        lhtype = lhs.get_type()
        rhtype = rhs.get_type()
        if not lhs.is_numeric() or not rhs.is_numeric():
            raise Exception("Illegal to apply " + self.get_name() +
                            " to " + str(lhs) + " and " + str(rhs))
        if lhtype == Value.INTEGER and rhtype == Value.INTEGER:
            num = lhs.get_integer_value()
            den = rhs.get_integer_value()
            if den != 0 and float.is_integer(num / den):
                svm.push_integer(num // den)
            else:
                svm.push_double(num / den)
        else:
            svm.push_double(lhs.get_double_value() / rhs.get_double_value())


class IDIV_Ins(ArithmeticInstruction):

    def __init__(self):
        SVMInstruction.__init__(self, "IDIV", SVMOp.IDIV)

    def apply_integer(self, x, y):
        return x // y

    def apply_double(self, x, y):
        return x // y


class REM_Ins(ArithmeticInstruction):

    def __init__(self):
        SVMInstruction.__init__(self, "REM", SVMOp.REM)

    def apply_integer(self, x, y):
        return x % y

    def apply_double(self, x, y):
        return x % y


class NEG_Ins(SVMInstruction):

    def __init__(self):
        SVMInstruction.__init__(self, "NEG", SVMOp.NEG)

    def execute(self, svm, addr):
        rhs = svm.pop()
        if not rhs.is_numeric():
            raise Exception("Illegal to apply " + self.get_name() +
                            " to " + str(rhs))
        if rhs.get_type() == Value.INTEGER:
            x = rhs.get_integer_value()
            svm.push_integer(-x)
        else:
            x = rhs.get_double_value()
            svm.push_double(-x)


class EQ_Ins(ComparisonInstruction):

    def __init__(self):
        ComparisonInstruction.__init__(self, "EQ", SVMOp.EQ)

    def apply_object(self, x, y):
        return x == y

    def apply_integer(self, x, y):
        return x == y

    def apply_double(self, x, y):
        return x == y

    def apply_string(self, x, y):
        return x == y


class NE_Ins(ComparisonInstruction):

    def __init__(self):
        ComparisonInstruction.__init__(self, "NE", SVMOp.NE)

    def apply_object(self, x, y):
        return x != y

    def apply_integer(self, x, y):
        return x != y

    def apply_double(self, x, y):
        return x != y

    def apply_string(self, x, y):
        return x != y


class LT_Ins(ComparisonInstruction):

    def __init__(self):
        ComparisonInstruction.__init__(self, "LT", SVMOp.LT)

    def apply_integer(self, x, y):
        return x < y

    def apply_double(self, x, y):
        return x < y

    def apply_string(self, x, y):
        return x < y


class LE_Ins(ComparisonInstruction):

    def __init__(self):
        ComparisonInstruction.__init__(self, "LE", SVMOp.LE)

    def apply_integer(self, x, y):
        return x <= y

    def apply_double(self, x, y):
        return x <= y

    def apply_string(self, x, y):
        return x <= y


class GT_Ins(ComparisonInstruction):

    def __init__(self):
        ComparisonInstruction.__init__(self, "GT", SVMOp.GT)

    def apply_integer(self, x, y):
        return x > y

    def apply_double(self, x, y):
        return x > y

    def apply_string(self, x, y):
        return x > y


class GE_Ins(ComparisonInstruction):

    def __init__(self):
        ComparisonInstruction.__init__(self, "GE", SVMOp.GE)

    def apply_integer(self, x, y):
        return x >= y

    def apply_double(self, x, y):
        return x >= y

    def apply_string(self, x, y):
        return x >= y


class JUMP_Ins(SVMAddressInstruction):

    def __init__(self):
        SVMAddressInstruction.__init__(self, "JUMP", SVMOp.JUMP)

    def execute(self, svm, addr):
        svm.set_pc(addr)


class JUMPT_Ins(SVMAddressInstruction):

    def __init__(self):
        SVMAddressInstruction.__init__(self, "JUMPT", SVMOp.JUMPT)

    def execute(self, svm, addr):
        if svm.pop_boolean():
            svm.set_pc(addr)


class JUMPF_Ins(SVMAddressInstruction):

    def __init__(self):
        SVMAddressInstruction.__init__(self, "JUMPF", SVMOp.JUMPF)


    def execute(self, svm, addr):
        if not svm.pop_boolean():
            svm.set_pc(addr)


class DISPATCH_Ins(SVMInstruction):

    def __init__(self):
        SVMInstruction.__init__(self, "DISPATCH", SVMOp.DISPATCH)

    def execute(self, svm, addr):
        svm.push_frame()
        svm.get_current_frame().set_return_address(svm.get_pc())
        svm.set_pc(svm.pop_integer())


class TRY_Ins(SVMAddressInstruction):

    def __init__(self):
        SVMAddressInstruction.__init__(self, "TRY", SVMOp.TRY)

    def execute(self, svm, addr):
        svm.push_exception_frame(addr)


class ENDTRY_Ins(SVMInstruction):

    def __init__(self):
        SVMInstruction.__init__(self, "ENDTRY", SVMOp.ENDTRY)

    def execute(self, svm, addr):
        svm.pop_exception_frame()


class THROW_Ins(SVMInstruction):

    def __init__(self):
        SVMInstruction.__init__(self, "THROW", SVMOp.THROW)

    def execute(self, svm, addr):
        v = svm.pop()
        svm.raise_exception(Exception(str(v)), v)


class NOT_Ins(SVMInstruction):

    def __init__(self):
        SVMInstruction.__init__(self, "NOT", SVMOp.NOT)

    def execute(self, svm, addr):
        v = svm.pop()
        type = v.get_type()
        if type == Value.BOOLEAN:
            svm.push_boolean(not v.get_boolean_value())
        else:
            svm.push_integer(~v.get_integer_value())


class AND_Ins(LogicalInstruction):

    def __init__(self):
        LogicalInstruction.__init__(self, "AND", SVMOp.AND)

    def apply_integer(self, x, y):
        return x & y


class OR_Ins(LogicalInstruction):

    def __init__(self):
        LogicalInstruction.__init__(self, "OR", SVMOp.OR)

    def apply_integer(self, x, y):
        return x | y


class XOR_Ins(LogicalInstruction):

    def __init__(self):
        LogicalInstruction.__init__(self, "XOR", SVMOp.XOR)

    def apply_integer(self, x, y):
        return x ^ y


class LSH_Ins(LogicalInstruction):

    def __init__(self):
        LogicalInstruction.__init__(self, "LSH", SVMOp.LSH)

    def apply_integer(self, x, y):
        if y < 0:
            return (x & 0xFFFFFFFF) >> y
        else:
            return x << y


class ASH_Ins(LogicalInstruction):

    def __init__(self):
        LogicalInstruction.__init__(self, "ASH", SVMOp.ASH)

    def apply_integer(self, x, y):
        if y < 0:
            return x >> y
        else:
            return x << y


class CALL_Ins(SVMInstruction):

    def __init__(self):
        SVMInstruction.__init__(self, "CALL", SVMOp.CALL)

    def assemble(self, cv, scanner):
        token = scanner.next_token()
        ttype = scanner.get_token_type(token)
        if ttype == Scanner.NUMBER:
            cv.add_word((self.get_code() << 24) | int(str(token)))
        elif ttype == Scanner.WORD:
            next = scanner.next_token()
            if next == ".":
                name = str(token) + "." + str(next)
                cv.add_word((SVMOp.CALLM << 24) | cv.string_ref(name))
            else:
                scanner.save_token(next)
                cv.add_word((SVMOp.CALL << 24) | cv.label_ref(str(token)))
        else:
            raise Exception("Illegal argument " + str(token))

    def execute(self, svm, addr):
        svm.execute_call_hooks()
        svm.push_frame()
        cf = svm.get_current_frame()
        cf.set_return_address(svm.get_pc())
        cf.set_argument_count(svm.get_nargs_count())
        svm.set_pc(addr)

    def unparse(self, svm, addr):
        return "CALL " + str(addr)


class CALLM_Ins(SVMNameInstruction):

    def __init__(self):
        SVMNameInstruction.__init__(self, "CALLM", SVMOp.CALLM)

    def assemble(self, cv, scanner):
        token = scanner.next_token()
        if scanner.get_token_type(token) != Scanner.WORD:
            raise Exception("CALLM requires a class and method name")
        scanner.verify_token(".")
        name = str(token) + "." + str(scanner.next_token())
        cv.add_word((SVMOp.CALLM << 24) | cv.string_ref(name))

    def execute(self, svm, addr):
        cf = svm.get_current_frame()
        cf.set_argument_count(svm.get_nargs_count())
        name = svm.get_string(addr)
        dot = name.rfind(".")
        if dot == -1:
            cname = self.receiver_class(svm)
        else:
            cname = name[:dot]
        mname = name[dot + 1:]
        c = SVMClass.lookup(cname)
        m = c.get_method(mname)
        m.execute(svm, None)

    def unparse(self, svm, addr):
        return "CALLM " + svm.get_string(addr)

    def receiver_class(self, svm):
        n_args = svm.get_argument_count()
        return svm.peek_back(n_args).get_type()


class CALLFN_Ins(SVMInstruction):

    def __init__(self):
        SVMInstruction.__init__(self, "CALLFN", SVMOp.CALLFN)

    def execute(self, svm, addr):
        svm.call(svm.get_nargs_count())


class RETURN_Ins(SVMInstruction):

    def __init__(self):
        SVMInstruction.__init__(self, "RETURN", SVMOp.RETURN)

    def execute(self, svm, addr):
        svm.set_pc(svm.get_current_frame().get_return_address())
        svm.pop_frame()
        if svm.get_current_frame() is None:
            svm.set_pc(-1)
        svm.execute_return_hooks()


class PUSHLOC_Ins(SVMOffsetInstruction):

    def __init__(self):
        SVMOffsetInstruction.__init__(self, "PUSHLOC", SVMOp.PUSHLOC)

    def execute(self, svm, addr):
        svm.push(svm.get_current_frame().get_local(addr))


class POPLOC_Ins(SVMOffsetInstruction):

    def __init__(self):
        SVMOffsetInstruction.__init__(self, "POPLOC", SVMOp.POPLOC)

    def execute(self, svm, addr):
        svm.get_current_frame().set_local(addr, svm.pop())


class LOCALS_Ins(SVMOffsetInstruction):

    def __init__(self):
        SVMOffsetInstruction.__init__(self, "LOCALS", SVMOp.LOCALS)

    def execute(self, svm, addr):
        svm.get_current_frame().set_frame_size(addr)

    def assemble(self, cv, scanner):
        nlocals = 0
        while True:
            token = scanner.next_token()
            if token == "\n":
                break
            cv.define_symbol(str(token), nlocals)
            nlocals += 1
        scanner.save_token(token)
        cv.add_word((get_code() << 24) | nlocals)

class ARG_Ins(SVMVarInstruction):

    def __init__(self):
        SVMVarInstruction.__init__(self, "ARG", SVMOp.ARG)

    def execute(self, svm, addr):
        cf = svm.get_current_frame()
        name = svm.get_string(addr)
        v = svm.pop()
        cf.declare_var(name)
        cf.set_var(name, v)


class VAR_Ins(SVMVarInstruction):

    def __init__(self):
        SVMVarInstruction.__init__(self, "VAR", SVMOp.VAR)

    def execute(self, svm, addr):
        cf = svm.get_current_frame()
        name = svm.get_string(addr)
        cf.declare_var(name)


class PARAMS_Ins(SVMOffsetInstruction):

    def __init__(self):
        SVMOffsetInstruction.__init__(self, "PARAMS", SVMOp.PARAMS)

    def execute(self, svm, addr):
        nparams = addr
        nargs = svm.get_argument_count()
        if nargs != -1:
            svm.check_argument_count(nargs, nparams)
            svm.set_stack_base(nargs)

class NARGS_Ins(SVMOffsetInstruction):

    def __init__(self):
        SVMOffsetInstruction.__init__(self, "NARGS", SVMOp.NARGS)

    def execute(self, svm, addr):
        pass

class VARGS_Ins(SVMInstruction):

    def __init__(self):
        SVMInstruction.__init__(self, "VARGS", SVMOp.VARGS)

    def execute(self, svm, addr):
        args = SVMArray()
        nargs = svm.get_argument_count()
        if nargs != -1:
            for i in range(nargs):
                args.add(0, svm.pop())
        svm.push(Value("Array", args))

class PUSHVAR_Ins(SVMVarInstruction):

    def __init__(self):
        SVMVarInstruction.__init__(self, "PUSHVAR", SVMOp.PUSHVAR)

    def execute(self, svm, addr):
        cf = svm.get_current_frame()
        name = svm.get_string(addr)
        while cf is not None:
            if cf.is_declared(name):
                svm.push(cf.get_var(name))
                return
            cf = cf.get_frame_link()
        if svm.is_global(name):
            svm.push(svm.get_global(name))
        else:
            raise Exception(name + " has not been declared")


class POPVAR_Ins(SVMVarInstruction):

    def __init__(self):
        SVMVarInstruction.__init__(self, "POPVAR", SVMOp.POPVAR)

    def execute(self, svm, addr):
        cf = svm.get_current_frame()
        name = svm.get_string(addr)
        while cf is not None:
            if cf.is_declared(name):
                cf.set_var(name, svm.pop())
                return
            cf = cf.get_frame_link()
        if svm.is_global(name):
            svm.set_global(name, svm.pop())
        else:
            raise Exception(name + " has not been declared")


class PUSHFRM_Ins(SVMInstruction):

    def __init__(self):
        SVMInstruction.__init__(self, "PUSHFRM", SVMOp.PUSHFRM)

    def execute(self, svm, addr):
        raise Exception("Not yet implemented")


class POPFRM_Ins(SVMInstruction):

    def __init__(self):
        SVMInstruction.__init__(self, "POPFRM", SVMOp.POPFRM)

    def execute(self, svm, addr):
        raise Exception("Not yet implemented")


# Unit test


# Original file: svmops.py

"""
This file defines the operation codes used in the Stanford Virtual
Machine.  This file appears in this package to eliminate dependencies
between the parser and the svm package.
"""

class SVMOp:

    # Version for compatibility check 

    SVM_VERSION = 4

    # Operation codes 

    END =      0x00;     # END                 
    VERSION =  0x01;     # VERSION n           
    PSTACK =   0x02;     # PSTACK              
    STMT =     0x03;     # STMT index          
    HALT =     0x04;     # HALT                
    NOP =      0x05;     # NOP                 

    PUSHINT =  0x10;     # PUSHINT int         
    PUSHNUM =  0x11;     # PUSHNUM num         
    PUSHCH =   0x12;     # PUSHCH ch           
    PUSHSTR =  0x13;     # PUSHSTR str         
    PUSHFN =   0x14;     # PUSHFN addr         
    POP =      0x15;     # POP                 
    DUP =      0x16;     # DUP                 
    EXCH =     0x17;     # EXCH                
    ROLL =     0x18;     # ROLL n              
    COPY =     0x19;     # COPY n              

    ADD =      0x20;     # ADD                 
    SUB =      0x21;     # SUB                 
    MUL =      0x22;     # MUL                 
    DIV =      0x23;     # DIV                 
    IDIV =     0x24;     # DIV                 
    REM =      0x25;     # REM                 
    NEG =      0x26;     # NEG                 

    EQ =       0x30;     # EQ                  
    NE =       0x31;     # NE                  
    LT =       0x32;     # LT                  
    LE =       0x33;     # LE                  
    GT =       0x34;     # GT                  
    GE =       0x35;     # GE                  

    JUMP =     0x40;     # JUMP addr           
    JUMPT =    0x41;     # JUMPT addr          
    JUMPF =    0x42;     # JUMPF addr          
    DISPATCH = 0x43;     # DISPATCH            
    TRY =      0x44;     # TRY addr            
    ENDTRY =   0x45;     # ENDTRY              
    THROW =    0x46;     # THROW               

    NOT =      0x50;     # NOT                 
    AND =      0x51;     # AND                 
    OR =       0x52;     # OR                  
    XOR =      0x53;     # XOR                 
    LSH =      0x54;     # LSH                 
    ASH =      0x55;     # ASH                 

    CALL =     0x60;     # CALL addr           
    CALLM =    0x61;     # CALLM name          
    CALLFN =   0x62;     # CALLFN              
    RETURN =   0x63;     # RETURN              
    LOCALS =   0x64;     # LOCALS vars         
    PUSHLOC =  0x65;     # PUSHLOC n           
    POPLOC =   0x66;     # POPLOC n            
    ARG =      0x67;     # ARG name            
    VAR =      0x68;     # VAR name            
    PARAMS =   0x69;     # PARAMS n            
    NARGS =    0x6A;     # NARGS n             
    VARGS =    0x6B;     # VARGS               
    PUSHVAR =  0x6C;     # PUSHVAR name        
    POPVAR =   0x6D;     # POPVAR name         
    PUSHFRM =  0x6E;     # PUSHFRM             
    POPFRM =   0x6F;     # POPFRM              

# Original file: EditWorldControl.py

class EditWorldControl(PGLControl):

    def __init__(self):
        PGLControl.__init__(self)
        self.set_name("EditWorld")
        self.set_active_icon(EDIT_WORLD_ACTIVE)
        self.set_disabled_icon(EDIT_WORLD_DISABLED)
        self.set_rollover_icon(EDIT_WORLD_ROLLOVER)
        self.set_pressed_icon(EDIT_WORLD_PRESSED)
        self.set_state(PGLControl.ACTIVE)

EDIT_WORLD_ACTIVE = ("data:image/png;base64," +
    "iVBORw0KGgoAAAANSUhEUgAAARcAAAEXCAYAAACH0wDUAABGFUlEQVR4Xu2d" +
    "978sWVXo3//0nqLCKEgSUEAEJYqAIqDAQxxA8El6IoKACBiYnCOTc7oTmXDv" +
    "MJnJicmBDAL6tF6v7lP37v6uVbXW3rWrT/c5VZ/P94ezV9yrdq1TVV1d/T/2" +
    "Nc3/mJiYmKiNGpiYmJiogRqYmJiYqIEamJiYmKiBGpjYHXzl+qZp+dsrm+Y9" +
    "5y7zqhOa5n/+m88LjtS2H774gO8Wxp/Y+aiBiZ2DHNRyoMsBz6awnbz5tAMN" +
    "iDlP7BzUwMTmIQdpztnGutKeBU1nOzsDNTCx/sh/fTkQeXDuVNqGwzpMrDdq" +
    "YGL9GLOZ/O7JTfOmM5b5qysWfPTyAxz97QVH3XlAPufyBa3tmxMYqwZSB6kH" +
    "azSxfqiBie1HbrDWusRpm4c0gk9/c9YcZg1izxNNc/2zBt9d5oZnNdShjxvE" +
    "zuDoWVP64mxyH53l8c7ZmchrTta5ljA1m/VFDUxsD3KTkwdOlIOOmDWQ05vm" +
    "/RcvziKkgZxyX9Nc90w/13o8a0AdQn2Hcx5umiO/vXwGJPPhHKNIU95n1Hdi" +
    "9aiBidUh/3F5cESQg+9PZv/9P3XN4uBsD+zrngUy1oNqDORZA+oQ6pfwzGJe" +
    "/7B31jAvapqXHqdrEEHu1ewz6j6xGtTAxLjIJU/u/ZO0mZx87+Lgs9hJzYU+" +
    "9zebi8vObKTu+4z9MTEeamCiPvJJR+49FLk8kHsk88ubZ40DzmAnNxfKpclK" +
    "s5Wmm9NsZD9MnzytBjUwUY+ch9fkAHnf7BLgazc1zTVPa64GlJfg+nzGgDqO" +
    "T0L9Wpx4T9N8ZE9eo5H7XNxnE/VQAxPDyTlL+eNzmubzNzTNJY/pAyZljIPU" +
    "9cnGssbNJUUatDRq1roLuUydzmbqowYmyok2Ffl4+JOzU/qzHtIHRhdjHKSu" +
    "TzaWDWkuLdKwpXG/8XS9DyymJlMXNTCRhyzGyA3alx67OG2X03ceBBHGOEhd" +
    "n2wsG9ZcUqSRS/1lP3DfkKnJ1EENTMSINpX3zk7Pv9pxHyWHMQ5S1ycbywY3" +
    "lxRp8NHLpulTpnLUwEQ/4aZyYdOc/mDTXPnUOFxloHSeBIZNln3AB/XpUyE6" +
    "DoxBH57cZOb39Aea5kOXxW4CT00mHzUwYSNNhQvOYuym0sIDyjqoeKBTn7j2" +
    "AR/Up0/FVgPpgzHow5ObJP4vfGTWZIKfNE1NJo4amNB4N2plUcp/QPlPOF+w" +
    "XMgjwAPKOqh4oFOfuPYBH9SnT8XWAd4HY9CHJzdhnNnYhY/GmoycuXKNTGjU" +
    "wMQBvOdUZBF+eM/iPx8X6tjwgLIOKh7o1CeufcAH9elTkdatA8agD09uwjiJ" +
    "TJrMJ672b/5Oz8n0owYm/EsgaSoHz85Uzv9O01z+RCWezIT2lg/KSa7+GDAH" +
    "C9o4XPHkMpSbdMT87HVN8xKnyUyfLNmogd2OdwlUvam0cHF70N7yQTnJ1R8D" +
    "5mBBG4eazaXl41f3Xy5Nl0oaNbBb8b6h/IbZKfBp9+tFVw0ubg/aWz4oJ7n6" +
    "Y8AcLGjjMEZzkbHzZ5e/f36hXhsp0zexD6AGdhveR8vy3+rLNxqLrTZc3B60" +
    "t3xQTnL1x4A5WNDGYazm0nLIbdOlUgQ1sJvwXtD0l5cuvup/2eP9XFoAfXhE" +
    "7KmzHTAnkqtvQR8etLegDaG+IOuj71Jpt7+4Sg3sFvrOVl5/2uK1jH0LK2dh" +
    "WtCHR8SeOtsBcyK5+hb04UF7C9oQ6recel/TvP1svYZSuPZ2C2pgp9P3SZD8" +
    "F/rMdfGFFV2YFvThEbGnznbAnEiuvgV9eNDegjaE+uTfbu2/VNqN7/lVAzuZ" +
    "vsug9hKIiyqysKgfgT48IvbU2Q6YE8nVt6APD9pb0IZQvwtZR1xbLbvtMkkN" +
    "7FS6LoPkbEXeSn/xY93IV/dTKFc8ahDR6dMfA8Yk1A/g1ioSAzquTxDSHxhD" +
    "kfg68o7ZWcwxeq21cG3uVNTATqPvMuhVJy1el6gWCsheeDyArIOIckL9MWBM" +
    "Qv0Abq0iMaDj+gQh/YExFPB31oNN87aeezG74TJJDewk+i6DPnhpfCFlLzwe" +
    "QEJEp09/DBiTUD+AW6tIDOi4PkFIf2AMBee1Nbe/vlKvvZadfpmkBnYKfZdB" +
    "X9qXt5CyFx4X2dZCc3X69MeAMQn1A7i1isSAjusThPQHxlBwXsnc5HeZ+m72" +
    "cu3uFNTAToA7r+WVJy5eFCRfTFviEeDJHS54VEMdBWPWgDGcPClX/iw8G09e" +
    "AXceBhcAyhlDyQn1YXPm7DLpj87Sa7JlJ77KQQ1sMrKDuNNa/uISY+cbi8Bc" +
    "KJQ7cLGHFjxj1oAxnDwpV/4sPBtPXgF3Hgarbi6tzseu0GtzpzYYNbCpdDWW" +
    "5x3eNF/Ya+x4ZxH0yh242EMLnjFrwBhOnpQrfxaejSevgDsPg+1qLsIRdzTN" +
    "i4/Ra1XYSa9xUAObSNeXDjsvg0jHIuiUO3CxhxY8Y9aAMZw8KVf+LDwbT14B" +
    "dx4G29lcBLlMkvXJNbuTGowa2DS6PhGSHXfaA4vXIwzlvEeAjA1ExciUW9CG" +
    "ePqefK6TWQva14AxiNJnztuUt8W7ztdrV9gJnySpgU2iq7G89axFY6m1SHIX" +
    "ZgQVI1NuQRvi6XvyuU5mLWhfA8YgSp85b1PeXXQ1mE1/R4wa2BS6PmqWHVV7" +
    "keQuzAgqRqbcgjbE0/fkc53MWtC+BoxBlD5z3qa8+/jAJXotb3qDUQObQLSx" +
    "1FokuQszgoqRKbegDfH0PflcJ7MWtK8BYxClz5y3KW+PT1+j13QLj4FNQA2s" +
    "O12N5VPX6AVSa5HkLswIKkam3II2xNP35HOdzFrQvgaMQZQ+c96mvCPspAaj" +
    "BtaZrsbyyaub5tyHFsg3mwcjflIoJxH9iM4QfcuGePqePKBz7sPLKH1A/YgN" +
    "Yyo5oX7EJhf6t2JQ3sEhty4eoeA637QGowbWFauxyA743PUHGsvUXBw8fU8e" +
    "0MltFNSP2DCmkhPqR2xyoX8rBuU97IQGowbWEeuN/FJ42QFpY5mai4On78kD" +
    "OrmNgvoRG8ZUckL9iE0u9G/FoNxB3tX7O8azMJtyk1cNrBvWx81tY5EdMDWX" +
    "Hhvi6XvygE5uo6B+xIYxlZxQP2KTC/1bMSj3eHjRYKwzmE1oMGpgnbAaiyC/" +
    "IXPmQwvkvRm9iI6DPC2Z4sqJ4VNBG48C+7Ym+2vj4M7LQMWgDmOQJF40pgIx" +
    "iIph6BBlk4mapwFtmEOXXF6haTWYdX/QTg2sC13fFUobi7nDCHeggVpYnpwY" +
    "PhW08SiwV4vZwZ2XgYpBHcYgSbxoTAViEBXD0CHKJhM1TwPaMIc+uTQYHgvC" +
    "On9VQA2sA12NRX6X2d1hhDvQQC0sT04MnwraeBTYq9o4uPMyUDGowxgkiReN" +
    "qUAMomIYOkTZZKLmaUAb5uDJ5fereUysc4NRA9tN12sp33nuouDuDiPcgQZq" +
    "YXlyYvhU0MajwF7VxsGdl4GKQR3GIEm8aEwFYhAVw9AhyiYTNU8D2jAHV/5Q" +
    "d4NZx9c1qIHthkUT/mTWWE5/YMEZmbR2ffbUGYNVxGQM4ul78howRgn0ecaD" +
    "y1C/BozpyS2dWrz3In2MrGODUQPbCYslvO7U5cJyB3pwx1Bu6YzBKmIyBvH0" +
    "PXkNGKME+txtzUWQf7g8VgQeU9uJGtgurIfkfvuEpjnhnuWicgd6cKdQbumM" +
    "wSpiMgbx9D15DRijBPrcjc1FWPcGowa2A+sjZ6uxCNyBHhF76ozBKmIyBvH0" +
    "PXkNGKME+tytzUWQ44THzrp8RK0GVo11A1c+0//qzU1z6v1N8437gIyNDWMS" +
    "6q+CQA5Sr5SITS+0t3wY8vMfXqB0V4WRkyKis24w5xnH3d00LzpGH0Pr8LtI" +
    "amDVsCiC/NZLtQOkBMYk1F8FgRzWpbkId32/aW571tBfBR05ZeusG8x5K++v" +
    "3ayPIYHH2qpRA6vEus/yx+dWPkBKYExC/VUQyGGdmovwwA+b5qmfbsNZTE9O" +
    "WTrrBnNO8j74Mn0sbXeDUQOrous+y7F3Vz5ASmBMQv1VEMhh3ZqLIA3mF/+v" +
    "aW58WstGw8kprLNuMGfk/eYz9DG1nfdf1MAqsO6zPPfwpvnKt5rmlHv7kd92" +
    "TjnlvmU8uYWyIdR3oL4Zg3JCfaD0LeCD0CehvmXjymd53D9rMLJ958dNc8b9" +
    "0Nmaf2+tCG0Yk/bUb+uTQB9Knz4ZM+KTNvTpxKR/csxdTfPCo/WxtV33X9TA" +
    "KuDkhY9dqYtvwYJ7O4RyC2VDqO9AfTMG5YT6QOlbwAehT0J9y8aVb+XSNhg5" +
    "i7n2iUTnPo3nk/qUK3vqb+WUQh9Knz4ZM+KTNvTpxKR/C/kHzWNL4DG4CtTA" +
    "2Fj3Wd5xzqIwLL4FC+7tEMotlA2hvgP1zRiUE+oDpW8BH4Q+CfUtG1ee5NM2" +
    "GNkeac9i7tN4PqlPubKnfpJTC30offpkzIhP2tCnE5P+TWZ6H7xUH2Pb0WDU" +
    "wJi8x3jo5xUnLE7nIjujZIdQbqFsCPUdqG/GoJxQHyh9C/gg9Emob9m4cuR0" +
    "/w8ONJj9ZzH3LeP5pD7lyp76ST4t9KH06ZMxIz5pQ59OTPo32dJ90+n6WFv1" +
    "/Rc1MCacrNxn+fLsNO7Ee7e4x+ckQPl2cNK9QMYAbTyG2q8z9yUNRjb5W25O" +
    "Um+3M2QNHPVt+/6L3O/kcTkWamAsrMuhj17RHGgsU3NZ9jnQft1hg/nuz5rm" +
    "woe13m5m6Br48o36mBN4bI6FGhgD6/0sb5ydti01lqm5LPscaL8JsMHIZdIN" +
    "T2q93UqNNfCeC/SxJ7cneIyOgRoYA05OLofkzVpTc+lmqP2mwAYjm4xRbzdS" +
    "aw1Yl0c8RsdADdTGelhOuul84lNz6WSo/SZhNRi5TDr7Aa27m6i1Bv7eeK5s" +
    "FS/4VgO14aRefnzTHH/3AvnSVUo73gdtPI6/axnKTR3AHLL1DdwcDJ0+/TmZ" +
    "MVz9EpwYXfJ7v8/2srhMuuoxw0cNOvLoxNFn7SL1y9VXOVgwxl0L3mD8kx/7" +
    "5q4aqIl1E/ez1yUTByyMBW08WHzKTR3AHLL1DdwcDJ0+/TmZMVz9EpwYfXKr" +
    "wch2x3cNP0PpycPE0WftIvXL1Vc5WDDGXQv++ebF7Qgejzxma6IGamHdxH3b" +
    "2Zg4YGEsaOPB4lNu6gDmkK1v4OZg6PTpz8mM4eqX4MTw5F0NRi6TznxA6xfj" +
    "5KFw9Fm7SP1y9VUOFoxx1wHefb4+Jsd8ubcaqAUnIV3ziDswccDCWNDGg8Wn" +
    "3NQBzKFP/8z7m+bSRxb/bYWHf9Q0T/zkAPJ3KxO98x/qyMHIsy/nOcjTtfH0" +
    "S3BiuPK7uxuMXCZJzahfRCCPHH3WLlK/XH2VgwVj3LXMKm/uqoEaWD+/+r8v" +
    "bppj7izgrmWOvXMZT1/JDZRP+iCJ7bkPNs3tzzbN4z/hoRDffj47aB764cLP" +
    "eQ92zIswp8Bcj70LyFgPtDd9gME5bdnc09FgZJOnetMYKm/mYEAbQn3mraC+" +
    "EYNy1wflBqp2BPqfuVYfm2Pd3FUDQ7G+8Sw3cefFLQHFUjuMOMW1UD7pI0Hu" +
    "2l/x6GLxS1MYY/vRLxaN5vT7dK6d8wzMlQuR8ya0N32AwTklNn0NRurTxlB5" +
    "MwcD2hDqM28F9Y0YlLs+KDdQtSOGzR+dpY/RMX45QA0MxbqJ+8W9W8UtAcVS" +
    "O4wEikuUz8T+9NllzsXfWbyP5KEfcYmPvz37s63/1Myb8wzMlQuR8ya0N32A" +
    "wTnBpq/ByP6QZq/yZg4GtCHUZ94K6hsxKHd9UG6gakcMm0NvW83NXTUwBOus" +
    "5V3nJcUtAcVSO4wEikuUzy1baSzrssnZzI1PzQ6muzvmGZgrFyLnTWhv+gCD" +
    "czJs+hqMNN+T70bezMGAcyXUZ04K6hsxKHd9UG6gakcMG+H9F+tjtfbZixoY" +
    "As9apDt+/dbFl6iKuRNQPiIXPcSlvP2bXIrd9kzTnHCXztelQi2PBJRXwcjz" +
    "7u+xEgc2qYk8cKf8bDfGPLLkI/ObI9/cVQNDYKJvPUtPKJtt3AH7nuIyXp9N" +
    "DqhvPq5z7qVCLberuQheg8mux9h0zCMsHxnrvbs1z17UQCnWJ0TyVixOKJtt" +
    "3AEPJi83WtftsZ9k/NeuUMvtbC5CX4ORTf4hKH/bRc88QvIVMObZixoohQlW" +
    "OWsRtmkHyGXHJm2hS6UKtdzu5iJ4DUbktNkWnHm48hXwvot0c6n1tQA1UIJ1" +
    "1vKPNzbN4Xf0Iw/VLXG7QUQn4XCg7AOI3WXf4ZJd/01u+p7/YDJ/mUsKa8Pa" +
    "OfoWVu2WgE83JvzNgY2M3eU0mMd+3DTHfbs7hofKYQyMefXJmaOVp1d/8i+3" +
    "NM1zD1s+dms996IGSmBj+cMz9SQsWBgWM1JwwuIq+wBid9d3uVw3Z7vl6a35" +
    "y1xSWBvWztG3sGq3BHy6MeFvDmzaca/BPPPviwZD/xFUDmPQMa8uOXO08vTq" +
    "r7jd/s3pGmcvaiCX0rMWgYVhMSMFJyyusg8gdmM9ILeqTQ4s+SoCF9JSbVi7" +
    "VNfQt7BqtwR8ujHhbw5sUlmkwcjHwIzhoXIYg555WXLmaOXp1V9x+3hnL2og" +
    "FzaW6FmLwMKwmJGCExZX2Qc48z4u0c3cpEHufTKpOWvD2rV6HfoWrB3l9OnG" +
    "hL85sKF8jAbDGKPgzIty5mjl6dVfsaU3xtmLGsjBepv/J69pmsNuXyBPAi4h" +
    "YymUWzg2bayumJ7cinHz01yem73d+d2tuXHerBWg3AS1U3IQ2h8FyBz7th/+" +
    "YvF1Csnx6Nml0qUPL9t7ea2iNiUwL0J9xVZuX5udvfxa5bMXNZADG8urT+rf" +
    "QUXFdmzcReHIrRiP/phLc/M3+e999B3G3NNaAcpNnP1DQvujEK/ByJncOQ8s" +
    "aiHbVY8esPXyWkVtSmBehPqKJD/5nXYe0zzmc1ADUaz3taRnLdYOKiq2Y+Mu" +
    "Ckduxdip2/y/973G/NtaAcpNnP1DQvtjAF6D+a//Xv67bTBeXquoTQnMi1Bf" +
    "keT3RePXAoa870UNRGESr8JZi7WDiort2HgxPTljyHd3dvIm/715SbC/VoBy" +
    "E2f/kND+GIjXYLhJg/HyWkVtSmBehPoK5PiWM3WD4bEfRQ1EYQIfuGTxPaIc" +
    "5BcAUii3dAj1XW4zSORy2rwbtpueLqtliU02PfsnyrczG8yVjy7b15gnfXjQ" +
    "voR/uw3IWAL1WevPXKebS+mNXTUQwbqR+9WbjMQd3IkbOoT6Lly4WLxy0O2W" +
    "TQ7A3FoOrn+Env2Tw5AGU2Oe9OFB+xKGNhfhBUctH9ulPwOrBiKwsbzlDCPp" +
    "AO7EDR1CfRejmKl8NzUX2dIGo2plMLj+EXr2Tw5H3tE0//6fnHH/1jaYGvOk" +
    "Dw/al1CjudS6sasGIjDwR/YYSQdwJ27oEOq7GMVM5ekPpe+W7ZEfL56RULUy" +
    "GFz/CD37J4o0lqe3PhXK3aTB1JgnfXjQvoQazeUL+3RzKfm2tBrw4BO58tm4" +
    "SjiIO3FDh1DfxShmKt+JH0NHNjkQ5YBU9QKD6x+hZ/9EGNJYZNvtzUWQD2jY" +
    "YNgLPNSABwO+45ym+ddbFshjxH20el36lFvQhnj6lFPnkR9xqe2e7emfLj4p" +
    "6a3VzcsoOciVR3QoT/ORT0hkHqXbvicN/wZuTgGdoXJLh1CfdOlbb6pjL/BQ" +
    "A31Yz7b832/qxLromkiX3II2xNOnnDq7ubnIljYY1mleqzVuLkMbi2w//8+m" +
    "OeUeI0ZuTgGdoXJLh1CfdOl/+Vv6WM/9AXs10AdfY/lbx9mJddE1kS65BW2I" +
    "p085de7reV/rbtnkAO2s1Zo2lxqNpd2kwaRncBZuTgGdoXJLh1Cf9Om/6Qzd" +
    "YNgT+lADfTCQ/IJbV2IWfROx5Ba0IZ4+5dT51hq/2nJV2+WP9NRqDZtLzcbS" +
    "brxEJF5OEZ2hckuHUJ/06X9oz4qay4eNa7DPXt80X7s5g5sKoA/i6VNukejL" +
    "G/Z387bnO0Z9hjBwf5gkuofe2jRPVW4s7SZ+xb+ZUyRnT2eovAaMAfhlxpxn" +
    "XtRAF2wsrz3FSNTDSN6FPoinT7lFor9TXrdQslVvLMLA/WGypTe0sch8b3+G" +
    "o8vb/gbTkUNvzp7OUHkNGAPI77vz2Gdv6EINdMEA8u5NlaiHkbwLfRBPn3KL" +
    "RF9+A2c3bqM0FmHg/jC5qU5jaeNFGoyVg5uzpzNUXgPGAJ+6ZuTmYv3Y2Wev" +
    "MxL1MJJ3oQ/i6VNuAZufZT7VuenbaI1FqLA/SM3G0uI1GPn52N55GHm6OkPl" +
    "NWAMA14ayS0S9ggLNWDB7xI9/6jFz4aQfwK58hL+6aZlcuUW936PS2vnbvIN" +
    "ae6X/ftH6kVQK9oQ6ofoifn1W4Y1lsseNuJ9a5Gr/IJC3ybPwKT6ufOkDcnV" +
    "t2xYO0/fkwu/d8ry8R99iZQasOBZi/yQNROIJOrJS/Cahye3kEW0G7a+xjLf" +
    "PzzIjfrRhlA/REfMsRqL0ObrNZjWR8k8aUNy9S0b1s7T9+TCn56nr1zYIyzU" +
    "gAUdf/BSnUAkUU9egtc8PLnFiXdySe28TQ4S7g/ChbqdzWXMxiKkOfc1GLlk" +
    "lvVRMk/akFx9y4a18/Q9ufCJq0dqLtb9li/s1QlEEvXkJXjNw5N38YOfc1nt" +
    "nK3rvy/hQt2u5jJ2YxGYt9dgjrw9f56MQXL1LRvWztP35C0l913UAJHX3KVO" +
    "X3Ls4qdD5uxb5ssO++1yQAwX2gf4MpCxvU9wSe2MTS6F0nn2wbpYNp58KPKg" +
    "3pM/4Szi2yUPa58Wah6ztXRrz+s3npSnmG/WfnrBWlXHhwf9GXAehPqE+m0t" +
    "3oA+ELnvogYIz1rkZ1r3J7NvGRaLcCIhEMOF9gFUMWccfhuX0+ZvaWMpXmiO" +
    "DuVDmDeWAWcs0cYiqHlsrae+BvPwD7WfXrBW1fHhQX8GnAehPqF+W4s/u0Bf" +
    "wewz+kWKGiB0KK+z3J/MvmVYLMKJhEAMF9oHUMXcYsjCXrdNDrSueXZBfcvG" +
    "k5eyysYiqHkka6qvwdz6jPbVCdaqOj486M+A8yDUJ9RvayFfUGYv8F5/qQZS" +
    "rPstn7shSUYmnMBiEU4kBGK40D6AKuYWskB3wtYeaF3z7IL6lo0nL2HVjUVQ" +
    "88C6kibStYXjwac6Pjzoz4DzINQn1E9r8Xx8cdn7lrQaSOH9lhcfu3hL1X72" +
    "LvPFXPYFoA1QOTj2S/lvQZ3U/vsbfmP34oeMmnTVxqtlBNYyM4Y8tDXkHkvv" +
    "fBPUGvDkexe/wd21nX2/4cOY79LcHahvwZjKhzGPJWjfw+vRD4R9Rt9oUQMp" +
    "dCQ/O7CULCeay74AtAEqB8eexfYKfuUjXEabs7kHGmvj1TICa5kRY1WNRVBr" +
    "wJNv5d/VYOQTpMNuhQ9jvktzd6C+BfNWPjrmsR/a9/CezPsuaiCFjg7eg2Q5" +
    "0Vz2BaANUDk49iy2V3BZ8Jv4dYDQgcbaeLWMwFoGY6yysQhqDXjyZA5dDUby" +
    "X/JhzHdp7g7Ut2DeykfPPObQvodPZd53UQMt1v0WJqommsu+ALQBKgfHXs3B" +
    "0KGP6zfsY+kbntBzMGFtvFpGYC0DMVbdWAS1Bjw55tHVYGR8vw9jvktzd6C+" +
    "BfNWPpx5KHsHPu9Spbn86szpP9ywzOdBtnzvMpRbPlwcn0pfxkUvBTZfuXGz" +
    "zl4k16NvN+bpQP0Ing9PLrUd0lgufFD7JMzByoN4+jJ2S8e7fy56sNFrylhX" +
    "hDEI9UtsPLnKGbwCL+jvu6mrBlr4ZUVxykS8RF353mUot3y4OD6VvoyziLAR" +
    "ZMFs0mY1GM6JsC4RPB998n9aQWOxcmAeFp5+O241GKn9MXc0oXXVF4NQv8TG" +
    "k6ucAX/ute9hOjXQwvflyg+fMREvUVe+dxnKLR8ujk+lL+MsImxaHvoBl9F6" +
    "b2wwnA9hXSJ4Prrk0lieWEFjsXKw8iSefiqzGow0TXlsPrKuumIQ6pfYeHJ1" +
    "LAA2F4G9w20udDA1l9l/o9u5hNZ/SxsM50NYlwieD0u+ysZi5WDlSTx9yq17" +
    "MDIWWVddMQj1S2w8uToWwMGXjdBcDr5UJ+Il6sr3LkO55cPF8an0ZZxFhE3K" +
    "9Y9zCa3/1jYYzoWwLhE8H5SvurFYOVh5Ek+fclk3VoNZuv9CG8AYhPolNp5c" +
    "HQvgkxlvplMDXc3lI5c3zd9fn8l1gPIajBDjc9ctk8rkScXv/4xLaP23+Td5" +
    "b9NzXaKglp8DfT6kdkMaywUPaJ+hvCmP6FAe5KanlnPeX3f6HxBjiaE+Yc/9" +
    "Od+ngL2h6xMjNSDwkyKBAUIMnXiEEWL0NRdhU9/34jaYglqqhdjho1pjsfLq" +
    "iNkpj+hQngEbjMz7H/du+a0UYz9DfcKe+9NqLi8+Zrk3dL1+QQ0I/BkRccYA" +
    "IYZOPMIIMbzmIlz72PICWuUmsUs/Gu9tMAW1VAvR8FG1sVh5GTF75REdyjNh" +
    "g7nz2aZ6jDlDfcKe+9NqLq8+abk/yNeE2EM6mws/hn758TpAiKETjzBCjEhz" +
    "EYYcMKXb/EC7ftEgqjeYglqqhQgf1RuLlVeuPKJDeQFsMGfc01SPMThv2HN/" +
    "Ws3lzafrKxv2kM7mQsM3zZz93bUBrgOUE+h/5lqNssmE/kwkdgLz6uKIAQd4" +
    "yXb+/cncBsYXuyNudWqFusyBDmuS+vvSDU3z+I8ZOb4tzTelJ6YlZ87zvD28" +
    "GEDVacsubTD/Pqv5P9+0LF/Kk/ZGHIXhZ0jeyt7w8c7gO3XVgNVcxBkDmDhJ" +
    "KaDPBRBaBA70Z5IUt7PAHexZ0WsZ1IG2Fb9mg/HqMgc6rEfrSxrLE2M0lp6Y" +
    "XXLmPM/bw4sBVJ0S27TBPPADLd+fJ+2NOArDz5C8lb3hQ97pxB7BHhJuLuKM" +
    "AUycpBTQ5wIILQIH+jNJittZ4B7G/n3p86wDLYlfq8F4dZkDHdZC/IzaWDpi" +
    "9smZ8zxvDy8GUHWCfdpg5J2+lM/zpL0RR2H4GZK3srd8XKebi/WJkWosVnOR" +
    "X11TASy8pAj0uQBCi8CB/ky2Cttb4B7E5vEB9xX6NmksZh2QQ40G49VlDnSY" +
    "x+iNxYjpyZmzWU/ixQCqTrS/7sA/ofbyiHJlb8RRGHGG5K3sLR/XVWwuf/vN" +
    "xWvuchG7FMoJ9ec21zoYfmqjcjL4h1lxv1f5+Zdz78vL4bBbFgu3ZBO7Q2/R" +
    "PklfHlKDIfdY0vku4ezzvpxKqeHT8nHjk4u5PvB9rT8GVg41YI8INRfrGZfS" +
    "pHInRv25DRcWMfzURuXUgRycpQc3Nx5okRxkfOwG05XHaI1FcPZ5V05DqOGz" +
    "y0fbYC59SNvUpiuHobzsuKm5VEHl1MM37l4+aEo260CL5NDKxmwwVh6jNhbB" +
    "2edWTkOp4bPPhzQYqfVXb9R2NenLYQhsLtaDdFNzCaBycrjmUR4+8a3rQIvk" +
    "kMrHajDMY/TGIjj7nDlRXkINn54PaTBjXx55OZTC5mK918VtLi88enFD91NX" +
    "G8h4gnypKYX6nyTUD0AfSg6YA/WLoE8y07nxCR5G/nbOfUasLhjzaj33Q24e" +
    "1mDEXsVNkAcMhzSWc+7VPk04V8odWJfoWhsbyWPfE4s36a1LTlGqNBdxMnfI" +
    "HWzsZLUDufgJ9QPQh5ID5kD9IuiTbOnlNJisxtKRg5r7NeM1mCqNJbo/OFfK" +
    "HViX6FobmzYXaTBf76jzulLUXPjo/9RcDOiTJLr3f5+Hld6yG0tHDmruW9Ru" +
    "MNUaS3R/cK6UO7Au0bU2Nmk+m9Zc+DMjU3Mx9IugT5LoegdiUWPpyEHNPaFW" +
    "g/Hm421LjSW6PzhXyh1YF9Zmu1jHnKKwuVivu3Sby28d1zSfmO3Qj1+Vj9jl" +
    "QPs5Mp7CGCBXPtfx8hiYgzx49JhxQJ51bxLTw/Drwbz+9aZhDUYetLPmEd3S" +
    "+fbBuXMe1Kdc1YH6hg1hDvTpyg0d5kB9NwcD2jAGUTGpQ3/Qb/mDbyz3CYG9" +
    "xG0uf3CanVQElbgD7efIeApjgFz5XMfLY2AOwmfRYHigqRjE8Omh8rp6WIP5" +
    "r//mSHzjfPvg3DkP6lOu6kB9w4YwB/p05YYOc6C+m4MBbRiDqJjUoT/otxQ1" +
    "l1edMDUXyofm0Oq0DcY60FQMYvj0UHlt+RrSYEo2a759cO6cB/UpV3WgvmFD" +
    "mAN9unJDhzlQ383BgDaMQVRM6tAf9FuKmgsNpubSDM7B0lExPQyfHoyZ+ltV" +
    "g8ltLFYtOA/qU67qQH3DhjAH+nTlhg5zoL6bgwFtGIOomNShP+i3/Fngp13d" +
    "5vL7sw71f66ccZWBjGfwN4DyCEN9/M1VBpk+XX3WyaiV54M5enJzHsiB8n/5" +
    "1qzB/AfbQb3tzHuMvJ0crVq5lNjn2lCfUD8A95+SA8qjOkt4eVPeoRP53eip" +
    "uQiZPl191smoleeDOXpycx7IQcmvHK/BWI3FnDdytGrlUmKfa0N9Qv0A3H9K" +
    "DiiP6izh5U15h05Rc5H3YU7NpR9Xn3UyauX5YI6e3JwHclDyLWo3mK7GYs4b" +
    "OVq1cimxz7WhPqF+AO4/JQeUR3WW8PKmvENH+kJ2c+GnRb97ckZQh+xCGAz1" +
    "wR1qHpQOrj7rZNTK88EcPbk5D+Sg5Am1GkxfY5nnzRyQo1UrlxL7XBvqE+oH" +
    "4P5TckB5VGcJL2/KO3SqNJeXHpsR1CG7EAZDfXCHmgelg6vPOhm18nwwR09u" +
    "zgM5KDmQLzsO+bj58oe1T6JyQI5WrVxK7HNtqE+oH4D7T8kB5VGdJby8Ke/Q" +
    "qdZcPnZF03zUQMaXuHwZT9+TW3xU/KYYfnp9IkcrT0J95bMAFYOUxHTmpfQT" +
    "Pn1N0zz6I7aLvE3OfL52o/adkpPTqDi14jrLtjegD09ehJOX0g9AH8LrTl3u" +
    "E/IIC3vJ1FwiPmhDnwWoGKQkpjMvpb9FjcbSbl6DieY0Ok6tuM6y7Q3ow5MX" +
    "4eSl9APQh8DmEvpuEb8VPTUXra98FqBikJKYzryU/hV1G0u79TWYSE4rwakV" +
    "11m2vQF9ePIinLyUfgD6EF5ybIXmctAR3QGYRO7EPLkFdzp9ENozRytPQn3l" +
    "swAVg5TEdOZF/TEaS7t1NRgvp5Xh1IrrLNvegD48eRFOXko/AH0IVZqL8JE9" +
    "TfNXl2tkfAkZS6GcUN8CNrk5/JXYJFA+1yGwIbQvwslbQX0L2pBE95NXjddY" +
    "2k0azFf2GXkksLYW7jwpJ9S3oA1wc6oA16HKMQDzVCT+rbXOnOYwzp6pucxR" +
    "xaN/+LMKTmhfhJO3gvoWtCFbeqtoLO3mNRjW1sKdJ+WE+ha0AW5OFeA6VDkG" +
    "YJ6KxL+11pnTHMbZo5vL3145NRcln+sQ2BDaF+HkraC+BW3IntU2lnbrazCs" +
    "rYU7T8oJ9S1oA9ycKsB1qHIMwDwViX9rrTOnOYwzG3vBUcs9IvT2f2FqLv3Q" +
    "vggnbwX1LWgDhjaWyx4sf9Cuq8GwthbuPCkn1LegDXBzqgDXocoxAPNUJP6t" +
    "tc6c5jDOHn0CUtxc3ndR03zoMoM9gHKHg/csQ/kYHGxAHQ/aq3mUYMTphfaO" +
    "j4/PTlsfGdBYTr1r4ecf9zbNT/+D0tgmdl/eu5yzqqWRO1H1NnSySXLyamlC" +
    "e8PH4LzpX/yI3wRlMxLsEcXN5U/O1c7ncLKUOwwudgHcGSU7hPZqHiUYcXqh" +
    "fY+PWo1FkPnVbDCqlkb+RNXb0MlmKx+vlp3Q3vAxOG/6Fz/iN0HZjMBf1Pwh" +
    "enkxDAPM4WQpdxhc7AK4M0p2CO3VPEow4vRC+w4fNRuL0M6xVoNRtTTmQFS9" +
    "DZ1sxE8K5R60N3wMzpv+xY/4TVA2IyAnG+wR7CHh5vJ7p+gAczhZyh0GF7sA" +
    "7oySHUJ7NY8SjDi90N7wUbuxCOk8azQYVUvO00DV29DJRvykUO5Be8PH4Lzp" +
    "X/yI3wRlMwKRt9B1Nhd+BeDFxzTNBy/V/GUmtCfUn9tcsgzlhD4j0AfJzgH6" +
    "po2MpdAH8OTkr6+YNZYfNsXbKXdqn1YeX7p+WIP50g1+DDJUv8SGckJ9y8Zd" +
    "E8RZI3OfDp6+kiPHObB5zckDmot8Zp0aPu9wHcBKzIP2hPpzm8wdQp8R6INk" +
    "58CdY9nIWAp9AE+eMlZjMfO4pH6DYQzi5USoX2JDOaG+ZeOuCeKskblPB09f" +
    "yZHjHNjIyUbaH6wH6Dqbi/WsCwNYiXnQnlB/bpO5Q+gzAn2Q7By4cywbGUuh" +
    "D+DJW8ZsLGYeW/Or2WAYg3g5EeqX2FBOqG/ZuGuCOGtk7tPB01dy5DgHNs/H" +
    "My7Wj9B3NheBzeVPz9NBmJgH7Qn15zaZO4Q+I9AHyc6BO8eykbEU+gCeXBi7" +
    "sZh5JHOs1WAYg3g5EeqX2FBOqG/ZuGuCOGtk7tPB01dy5DgHNuwN1sfQWc3l" +
    "LWc2zQcucbgYUE5y9S08H57cwrGRj+JSlL4Bbf5CxhIYwwX+P7qnab4zoLGc" +
    "9G3tU8U04lL+hYEN5ovXaZ8K5kCob0Eb4uhH9h/3OeX06cotGDPJqSuvPpgz" +
    "13f0k6Ks5vLqk3UiCmfiilx9C8+HJ7dwbPqK3wVthi6C1HeVxgKf1ryjOkMb" +
    "jNjTZ28OhPoWtCGOfmT/cZ9TTp+u3IIxk5y68uqDOXN9v+2sCs2FP4722yfo" +
    "RBTOxBW5+haeD09u4dj0Fb8L2gxdBK3fao0l8dk177DOJSM3GOZAqG9BG+Lo" +
    "R/Yf9znl9OnKLRgzyakrrz6YM9f3q0+q0Fz4cfSLjtGJKJyJK3L1LTwfntzC" +
    "sekrfhe0GboIxGfVxrLls2/eYZ0tRmswzIFQ34I2xNGP7D/uc8rp05VbMGaS" +
    "U1defTBnrm85yUj7gvV6S7e5WJ8Yvf+iPN538TKUE/kOE3m/2KU4NpQT6ps2" +
    "TkxPznnPYUz6IIwJPnLZsMZy4reNnAIoGyfvz187rMF8/rr8mK68BPh0c6oV" +
    "NxMvr5J1mcpfePRyT+j6GLq3uQhsLvITjpxMH5wI5YQTNSfr2FBOqG/aODE9" +
    "Oecd3Yl9PlNqNBaJoXIKoGycvEVncIO5Ni+mKy8BPt061IqbiZdXybpM5c85" +
    "dLkndH1SlN1c3nS6nkwfnAjlhBM1J+vYUE6ob9o4MT055x3diX0+W2o1FkHl" +
    "FEDZOHm3ejUbjBfTlZcAn24dasXNxMurZF22MnkchT2BPaO4ubzqJD2ZPjgR" +
    "ygknak7WsaGcUN+0cWJ6cs47uhP7fAo1G4ugcgqgbJy8U91aDcaL6cpLgE+3" +
    "DrXiZuLlVbIuW5l8x5A9gT0j3Fz4066/caSeTB+cCOWEEzUn69hQTqhv2jgx" +
    "PTnnHd2JfT4HN5Y7dAyVUwBl4+RN/RoNxovpykvwaseYteJm4uVVsi5bmfwS" +
    "SNoPXnDkgOZi3dR99/lN8+cX2rzXIVffsvnzCwDktI9AH8TT9+QlpP4+dGnT" +
    "PDygsRx/h/ZZmud7LwCJv7nPwP753MAG8/fXwi9iMicLlRfmRZ/UJ/RvQZtc" +
    "6G8Mn5SnOrzf0vXYf6i5CGwu8jOODM4kusjVt2y8nU77CPRBPH1PXkLrq1Zj" +
    "SX0OyZMHofIZ3D9VGwxiMicLlRfmRZ/UJ/RvQZtc6G8Mn5S3Om8/W59osFcQ" +
    "NUDo8OXH6+BdiZJcfcvG2+m0j0AfxNP35CWIn5qNpfU5NE8ehMpnxv6p1mAQ" +
    "kzlZqLwwL/qkPqF/C9rkQn9j+KS81XlN5v2WUHPhw3TPPVwH70qU5OpbNt5O" +
    "p30E+iCevicvoXZjEWrkyYNQ+czcP9IgBjcYxGQMC5UX5kWf1Cf0b0GbXOhv" +
    "DJ+Utzq591tCzcW67/KO2SnSe84PcIFDrv6MdwPKXRjTijtUHoE+Ej44u5Z9" +
    "+Ac8lOLbcbf7MUIwZ8sn5YT6ZKbzd98c1mDEXsXNySGC55PyqE4ftC+BPgvJ" +
    "vd8Sai4Cm8trZ6dIahIWRpJL5OpfsPObS7XG0hMjDHO2fFJOqE+29EZtMIxZ" +
    "gueT8qhOH7QvgT4LeGvGlxVT1IAFHb/suEZPwsJIdIlc/Qt2dnOp2lg6YmTB" +
    "nC2flBPqk0R3tAbDmCV4PimP6vRB+xLos4DfDb7WkqgBC3Xf5bBGT8LCSHSJ" +
    "XP0Ldm5zqd5YjBjZ0J/lk3JCfQL9URoMY5bg+aQ8qtMH7UugzwJ+E98n6vuy" +
    "Yooa6IKd621nN827zutHHhdOoZxQ3+T8Zd7lYcQhKoYHc4A/lYPo0UfCBy5q" +
    "mocGNJZjbzNyMOIQ6iuMeVDH9Ul7Qv0Zn7m6aX5S2GDE7jPXLMfg/rLWDeeh" +
    "9JEj9Sk35045oE9CfcuGcubgzYv6Ao9963ehLdRAFwwgXwVQiQF34o6+CYvj" +
    "YcQhKoYHc4A/lYPo0ccWYzWWyLyorzDmQR3XJ+0J9beo2WC4v6x1w3kofeRH" +
    "fcrNuVMO6JNQ37KhnDl486J+9GdELNRAF/LRUxrg148wEgPuxB19ExbHw4hD" +
    "VAwP5gB/KgfRo4/zxm0skXlRX2HMgzquT9oT6ifUajDcX9a64TyUPnKjPuXm" +
    "3CkH9Emob9lQzhy8eVFf7q+O3lz4cyOCd2nkTtzRN2FxPIw4RMXwYA7wp3IQ" +
    "PfgYu7FE5kV9hTEP6rg+aU+oD2o0GO4va91wHkofeVGf8jmMQzmgT0J9y4Zy" +
    "5uDNK9WV9+U+55DlY16+b8je0IUa6IPN5RUnLBIo5Z2A8jnnAModIjGoQ4bm" +
    "QN5/4bDGcsytOkdrbpQT6pcwhk/y6auGNRixp88+ZP/Ii8Jz7cjQ2gy1N8Fa" +
    "fidIdUs/JWpRA33wvbq/dpiRfAah4g08sCMxqEOG5pAyVmOx5kY5oX4JY/i0" +
    "GKvByPj59zXNHc/Qanl7+qdNc8XDTXP0rYt9SD8WQ2sz1N4ko7nIq21X1lys" +
    "p3Vff5oxgSCh4g08sCMxqEOG5tAyZmOx5kY5oX4JY/jsolaDkf0gDUUaRum2" +
    "9/HF2Q1zTBlam6H2JsHmYj04F3kqN0UNeDDgS48zJhAkVLyBB3YkBnXI0ByE" +
    "sRuLNTfKCfVLGMNnH0MazLeeWDSVUntrkzOeriYztDZD7U2CzeWVJ+rmwl7g" +
    "oQY8+AIpueHzjnMKORtQviqYB6F+JvLFrwcHNJajbll85T1F5RjI8+1A2RPL" +
    "R5KDmYdhs0REnzrgUwUN5okflz+cF9kuf6iZf+ExzVPVivMcA9aL8iAHHbF8" +
    "nEe+qEjUQAR2NPnBNCYXolIhBsM8CPUzqNFYJAe1UC2M+Ck7pbmITk6Deean" +
    "HBlne/D7s0uHSw/kqWrFeY6BUatc3ni6PmuJPjiXogYiMLD83AATDFGhEFVg" +
    "HoT6QWo1FkEtVAsjh5Sd1FyESIP50c85Mu72k1/M8rpykaeqFec5Bh21ykHe" +
    "2cRjnD0gghqIIDd2GFx+S5pJulQoRBWYB6F+gJqNRVAL1cLII2WnNRehr8Gs" +
    "urGkm3kpy3mOQU+tosinwOmxHf0uEVEDUdhc5JfY5KG6lD8iZy0jvzu7BOwt" +
    "PB+e3II2CmceRH7fSU6RS7cjb9Y+FcxJ6nNW3ryoX4LnM1cegT4+ccXijCHd" +
    "VnUp1Lfteag/b29eEXLXgCe33jjX99tEfaiBKPw6gHQ71QiIM1HaW3g+PLkF" +
    "bRTOPFLkm6hDG0tRTlKfs/LmRf0SPJ+58gj0IaQNRm7elmxiLw3hnHuXGbI/" +
    "0wbDnCPz8shdA578JXjjnMBjP4oaiGJ9HUC63m5uLrUaS1FOUp8t26gP6pfg" +
    "+cyVR6CPFmkwNz6e/6nQDY81zcev0HFS/my2b8+9l5b9mzSr1C/zZQzKI+Su" +
    "gT65dSO37+daPdRADkzk+bOzmd3aXGo2lqKcpD6JfcQH9UvwfObKI9BHSk4D" +
    "kP31+W/G8rAuvfo2NhYrb8agPELuGuiTv3jgE7lEDeTAl0gJr/tGs+uay9DG" +
    "cgQaS1FOUp9MH9QvwfOZK49AHy1ydhFtAHK2IvqRPKRJRP3KZjUWK29PHiF3" +
    "DXTJrbOW0hu5LWogFyYkv8r4h2fuHuSbpA8MaCyH36x9bjRnAMpH5Ox7WF17" +
    "u/4xbdvF31ye31jEhn7WndpnLYIayMU6e5HflGXyO5GpsRhsY3N56iessN5k" +
    "f8l+o63Fbmksb8BT9zXOWgQ1UAIT2w1nL1Nj6WCbmosc1JHts9doW4vd0liE" +
    "3xrwQqg+1EAJu+3sZWosPWxTc4lcEkUvh3ZTY3nzbB/9Ml4IVfI9Igs1UAqb" +
    "y4uOXiSexemaN52xDG2UnD4MG5ceH/Lt1CGN5bCbOmIANa8AtMmF/izeJLml" +
    "GH56gT39W/NQcsPHbU+x0nr72J7EJ+rd8td78huL2DCnEJwr5YT6xjw8OWtp" +
    "PddS+tAcUQOl8EVSgrzcl5PphYWwigWUnD4MG5cOH9UaixUDqHkFoE0u9GcR" +
    "WfC9wJ7+rXkoueHD26QJLPlEvYXSxmLlFIJzpZxQ35iHJ0/rKJ8QjXXWIqiB" +
    "IbC5yJusuDB6YSGsYgElpw/DxsXwUbWxWDGAmlcA2uRCfxaRBd8L7OnfmoeS" +
    "Gz687dIH4RP1HtJYrJxCcK6UE+ob8/DkaR35+881z1oENTCEwWcvLIRVLKDk" +
    "9GHYuMDH0MZy6E1+DKLmFYA2udCfRWTB9wJ7+rfmoeTwIfvH2866Bz6TWg9t" +
    "LFZOIThXygn1MQ9z3UDe5jv2WYugBobC5iJP7b7xNBv5CCyFckvnDacDxwf1" +
    "KbdI/f3x2U1z//e4vOLbITfZeTIvJa8A50WoH8LJmzE8aG/h2cgvBHjbmXdr" +
    "O+GjlzXNjzMai+iKDf1YeHkrnNpaZMfYwnqupeZZi6AGhmKdvfzOCboIViEo" +
    "t3S8HaDsoU+5Rervkge4vOLb/sZi5Mm8lLwCnBehfggnb8bwoL2FZ/OxPay8" +
    "3qzmMmZjEby8FU5tLbJjzHjtqfoYFXgsD0UN1IBJ/+qhTfP6b/iFoNzS8XaA" +
    "soc+5Rapv9Izl6XGYuTJvJS8ApwXoX4IJ2/G8KC9hWcjp/jexuYydmOZ5wUo" +
    "Vzi1tciOcdriBw15jNY+axHUQA2s515ecoxfCMotHW8HKHvoU25Bn7kNRjUW" +
    "I09XXgHOi1A/hJM3Y3jQ3sKziTQX2X+tfm5jkXssuY1lnhegXOHU1iI3hlxF" +
    "8Nis8TSuhRqoBScgyIN1coN3E3n7WbEG8/Ubta3JqYBy8PuA8hqMEaPEZ4nN" +
    "k4FH/2UffuTSvMYiumLDeKOANcE6/L6MAeWjh9edqm/iCu0xWxs1UAvrN44O" +
    "OkJPeJPwGsy8sZyq7UxEL4VywIVGeQ3GiFHis8Tm4sC9sTPuWuPGImBNsA5s" +
    "LLnNxfqRsyHva/FQAzWxbu7KT8By0ptEV4PZ31gEw07R6gZtuNAor8EYMUp8" +
    "lthI/WtuK28sAtYE68DGktNcXn2SPhYFOU7HQg3UhpP5lUMXp2ec/CbBBrPU" +
    "WKJzS/UDNlxolNdgjBglPktsZJ/U2ralsQhYE6wDG0tOc5GrBh6LY9zETVED" +
    "tbFu7spPkcjHYdJkljhF81pyqoOjr2LSPiAX3npm09w3azD/emMgZxkP+OzL" +
    "gVDftGFetHFypH3X3Hp9VEDl3cE3H2GbyN+ksXzoEu2bdVA5GrWgDw/6jODG" +
    "PMV+Enesm7gpamAMODHhlSfpQqkdyMJZxSOOvopJ+4CcuDnLeK5PB+qbNsyL" +
    "Nk6OtO+aW6+PCqi8O/jklWwVeVtXYxFYB5WjUQv68KDPCF7M15y82pu4KWpg" +
    "DKybu887QhdK7UAWziiewtFXMWkfkBM3ZxnP9elAfdOGedHGyZH2XXPr9VEB" +
    "lXcPtzzJlhHb+hqLwDqoHI1a0IcHfUbwYspVAo+93B+UL0UNjIV1c1cmvlQs" +
    "7kAWziiewtHnzpnvIEeHcuLmLOO5Ph2ob9owL9o4OdK+a269Piqg8u6h5OzF" +
    "aywC66ByNGpBHx70GaEv5suMX06s/f2hPtTAmHCigvx0pJy6dXIKyJXXoEIM" +
    "ecYnxfXpyUvYBp+/Bzz9kA2g/oX3s310b9JYDr5Y58AYSh6AeVHuxqA8QBvr" +
    "VSfal0Nj38RNUQNjYv3WkRRAPiZThe0qcK68BhViTM1l6wBz9EM2gPpvOX1x" +
    "s93b2sZSdOAHYF6UuzEoD9DG4k+yCm8+bXWNRVADYyMT5KSfdziK2lfgXHkN" +
    "KsSYmsvWAeboh2yA0p/x7nP7H5hLG0vRgR/AymsJLwblASTObx6lj7FVXg61" +
    "qIFVwJ+CFaQgqrhWgXPlNagQY2ouWweYox+yAUp/i7+8mC1lsbGxFB34Abry" +
    "2o8Xg/IALzNeti3wGFwFamBVcPKCef+FBcyV16BCjKm5bB1gjn7IBij9hH/Z" +
    "pxuLNJ0+m8i8IgyOQbmDPN6x3fdZUtTAqpCPw1iEXzpkcSNK7sFEEf0UyosQ" +
    "PymUF/AqQPkYMCahPqG+BW3GYGjMC+870Fg+eFGZT+oT6lu4Nlh3uWv7V9fg" +
    "PkuKGlgl1sfTzz1cF62P3B0QYmouIfuIjxrUiCkNpm0sJT6pT6hv4doMaC4v" +
    "WJP7LClqYNWwIPOiHKWL10XODggzNZeQfcRHDcaImeuT+oT6Fq5NYXOxHu8X" +
    "eKytGjWwHbAogtyYYhEtojsgi6m5hOwjPmowRsxcn9Qn1LdwbQqai7z8SW4n" +
    "8Pj5yvVTc5lj3n/5+uJnJqV4vZy4zCvJCctQfw59Ek+f8gChvDL1qUOor+ZB" +
    "qB+A9c+VF8G8I8BHbq2UvkH2XOkDciumvEKWx8523mdJUQPbhXX/RRrMb7Pg" +
    "hDuAcIdwhwr0STx9ygOE8srUpw6hvpoHoX4A1j9XXgTzjgAfubVS+gbZc6UP" +
    "yBnPaizbfZ8lRQ1sJ9bzL1LA3gbDHUCSHWIuGoE+iadPeYBQXpn61CHUV/Mg" +
    "1A/A+ufKi2DeEeAjt1ZK3yB7rvQBeRpPHjzlsSLwmNpO1MB2w2K5DYY7gCQ7" +
    "xFw0An0ST5/yAKG8MvWpQ6iv5kGoH4D1z5UXwbwjwEdurZS+QfZc6QPyNpb1" +
    "9v51ayyCGlgHWDRBPqJ+xfEGJ4Bc+YyXn7AM5R7y8F8K5XOQB2MqH8yb0H+B" +
    "jRuT/iugYpbg5enJNxjrjXKCfG+Px9F2owbWBRZPkMKy2O5C8uTH6wOdco/Q" +
    "AYM8GFP5YN6E/gts3Jj0XwEVswQvT0++oVjfGVrXxiKogXXB+ga12WC8heTJ" +
    "j9cHOuUeoQMGeTCm8sG8Cf0X2Lgx6b8CKmYJXp6efAPpaiyrevFTCWpgnehq" +
    "MFLo/YX3FpInP14f6JR7hA4Y5MGYygfzJvRfYOPGpP8KqJgleHl68g3Depuc" +
    "sC4fOXehBtYN6wXfwvOPWjwHIw/bpchYipIfa2DY9aF8OnIL2iicHOkv5BPQ" +
    "PgLzUnKQK49AH4T6JpJ7An0QZQ+oXwv5rSF5JIPrf90bi6AG1hHrHTBtg/F2" +
    "spLzoA0sLKJ8OnIL2iicHOkv5BPQPgLzUnKQK49AH4T6JkljWdfm0tVY1ulZ" +
    "lj7UwLrS1WDke0h9O1ktAh60gYVFlE9HbkEbhZMj/YV8AtpHYF5KDnLlEeiD" +
    "UN8kaSzr2FzkH+cmNxZBDawz1kN2gjxQ1LWT1SLgQRtYWET5dOQWtFE4OdJf" +
    "yCegfQTmpeQgVx6BPgj1TZLGsm7NRRoL1/imNRZBDaw7XQ3muYc1zUuOMTgW" +
    "UG7pkKH6EZtc6L8kxlB7ywfJ1bdsRkC+SZxCOXOiPlH2hg8F9Y/tfkBu0xqL" +
    "oAY2ga5LJHkp8Yu9HUi5pUOG6kdscqH/khhD7S0fJFffshkBtzkgJ+oTZW/4" +
    "UEBfHhTlmt7UxiKogU2hq8E85xA0mMgOpw4Zqh+xyYX+S2IMtbd8kFx9y2YE" +
    "3OaAnKhPlL3hQ5HodjWWVfzs6liogU2i62PqpQYT2eHUIUP1Iza50H9JjKH2" +
    "lg+Sq2/ZjIDbHJAT9YmyN3woZjovPtb+drOwCR8396EGNo2uB+3kTrt8kvSi" +
    "o5eRB5IIdRTHAMhfeAyA/0iMXH2Vk5GXgvpA5WDoKJwYyieg3NIhnn6N/UGU" +
    "vVcHy8aQyz9Crt2d0FgENbCJ9DWY5x+pdyjhTlc4C6nGYs7VVzkZeSmoD1QO" +
    "ho7CiaF8AsotHeLp19gfRNl7dbBsEuQfX1djWdfvCuWiBjYZ7qQWuZ7t2uHc" +
    "6SbOQqqxmHP1VU5GXgrqA5WDoaNwYiifgHJLh3j6NfYHUfZeHSybLeQTIesZ" +
    "lp3UWAQ1sOlwZ7X8yqF6Z3Ond+IspBqLOVdf5WTkpaA+UDkYOgonhvIJKLd0" +
    "iKdfY38QZe/VwbARrJ9ZbVmH997WRA3sBLqehZH/Fr9xpN7hXBQKZyHVWMy5" +
    "+ionIy8F9YHKwdBRODGUT0C5pUM8/Rr7gyh7rw7Qlwfjui6DBK7hnYAa2ClY" +
    "7+Rtkf8ecs3bIt+yTkllFrn6c5sjl6GclMTwoE8S0afOGHgxKS+BPj08e8pT" +
    "HXmC/H91XAZt6jMsEdTATsL6VYGW5xzavTC4cEiu/txmai5hvJiUl0CfHp49" +
    "5a2O9SuILTvhE6E+1MBOhDu1Rf6byM01a1H0kas/t5maSxgvJuUl0KeHZ0+5" +
    "XH5bv9vcstPur1iogZ2Kd5nUt3AIFxLlFlNziePFpLwE+vTw7FPZbr0MImpg" +
    "J9N7mXTI4hWa8h9nLZHcUii38GwoJ9S3bCj3GGpvUeLTs6GcGPpyFtx303an" +
    "XwYRNbAb6Po0SZBrZLVw1gFvcVt4NpQT6ls2lHsMtbco8enZUE6gL4/wd52t" +
    "CLvhMoiogd1C1xcfBfnIWh684wLaVpzFbeLZUE6ob9lQ7jHU3qLEp2dDOdnS" +
    "e94R/fdWdtNlEFEDu4murw20yCnur3PRbRcdi7sXz4ZyQn3LhnKPofYWJT49" +
    "G8rJkYsHM7lmUuSLtVxzuwk1sBvpu9kryCKSm3QtB5EjfFL7CG4Myg3ok1Cf" +
    "PE/yBgc5KH3Drwt9Ht5Prv7chng+tuYj/Mph/ZdAu/lsJUUN7FbkmpiLJEUu" +
    "leR+TGRhWqjF6uDGoNyAPgn1iRxI5CAHpW/4daHPw/vJ1Z/bEM/HEYtL5V/q" +
    "uQQSdtJ3g4aiBnY7Xe+IaZHra7U4sTAt1GJ18Ba/khvQJ6E+kQOKHOSg9A2/" +
    "LvR5eD+5+nMb4vjwLoF22ydBEdTAxALvUknux+xfpFiYFlysHt7iV3ID+iTU" +
    "J8+TvMFBDkrf8OtCn4f3k6s/tyGGDzlTkf08XQKVoQYmDuBdKglyJiMfQ8qD" +
    "ePuRv0kqn/HcQ5ehnMgLyIdCnx60t3x48k2l7xOglukSqB81MKHxLpUEuRbf" +
    "32TYWIzmMTWX9STSVDb5vbarRA1MdONdKi01GYJFPDWX9UH2V6SpyCXQbnwY" +
    "rhQ1MOETajKz6/RfmS3YqbmsL9JUvE9/pqZSjhqYiBNpMnIzUP4ryqcNOcgr" +
    "IfqQxuVi+B2ME0PlSRz7KjAGkP3R9ZrJlOnyZxhqYCKfyD0ZQRZ0tNHwICU8" +
    "YEwMv4NxYqg8iWNfBcaYIZ/6RBqKMDWVOqiBiXKiTUbOZuR03Dz4tuBBSnjw" +
    "mBh+B+PEUHkSx74KW76lofzy1/s/Sk6Zmkpd1MDEcKJNRui6bOJBStRBasGD" +
    "rgZODJUncexrIPWMNhRht38HaCzUwEQ95DmIvtc7kPkZjTSbrTObJbZkLXIA" +
    "EaUDlJw+qM8cDGhDn4ypsHwS5kW27HIaijA9pzIuamBiHD58sV7cfciB0l4+" +
    "zcEBpQ5ASwcoOX1Qv43dA23okzEVlk/CvLZoa8Ta9TGdpawONTAxPn3vkuli" +
    "f7PZQh2AxoHcdVB2+qB+csB3QRv6ZEyF5ZMk+rnNRJjupWwPamBidcizE5GP" +
    "sy32N5qeA5kHvpIbB/E6NReRlzQTQS5Hp8ue7UUNTGwPufdnLNqzm/TezSY0" +
    "lzTv0mbS8uGLp4ayLqiBifUg5xOn3YzUaXp6dj1RAxPrhxw8U7NZIPerpmay" +
    "GaiBifVHDq6Sm8KbyNRMNhc1MLGZtGc3pTeItxu539Re4kzNZGegBiZ2FnKg" +
    "ys3idbmskjzkpuvUQHY+amBid9GeKaRIA0jhJZicHVGHPqbmMaEGJiYmJmqg" +
    "BiYmJiZqoAYmJiYmaqAGJiYmJmrw/wGZiXnnwzAUkQAAAABJRU5ErkJggg==")

EDIT_WORLD_PRESSED = ("data:image/png;base64," +
    "iVBORw0KGgoAAAANSUhEUgAAARcAAAEXCAYAAACH0wDUAABEhElEQVR4Xu2d" +
    "edQtV1XgXUv/6cmp7V6rGwfsttu2xVa023Zqp3ZuW0UUkXZAUOZMJECAEMgA" +
    "CRmZ5yEBhWACBgJoCKMgoj6Sl+RleHl5mV4g04MACQFlqL677lcv5/72rtr7" +
    "VJ26w/fVWvkteGePZ59z9ldVd/qaXVX1NRMTExOlUQMTExMTJVADExMTEyVQ" +
    "AxMTExMlUAMTE8Izr6yqx+zyOWp3VdF2YkJQAxPbEzaFVfLca6aGtBNQAxOb" +
    "S/RqY12ZroK2F2pgYjOQg8jDuV3ZZcx/Yv1RAxPryVjN5OSrq+qs6xa54NY5" +
    "b0246rNz9nz2fnlKY3t2AmOVYLq62RzUwMR6UOoWp2ke0gDefdu8OXzuS1X1" +
    "5a8aVIt85asaZQOo/xXxM+Oqz1XVh+6aN6pX7p8/d2GufZiazfqiBiZWw5DD" +
    "duTueQN5w03zJiIN5IZ7q+pLXwVfWeSfPL5qQB1CfYfbvlhVVyZXQzIPmQ/n" +
    "GEWa8i6jvhPLRw1MLBcejghy+F6xv6reNbsSue0L9x9s1UyI6CSoxkCMZqB0" +
    "CPX78JX5vD5w57xhPqPnVdwuo94Ty0MNTIxP7vOTtJnsv3d++CxUMyGik0B7" +
    "BQ/91sHvhPp9MHzKFU7TbPpc2ewy1mFiXNTAxDjkPkOR2wN5RtLc3qgDZ6Ca" +
    "CRGdBNoreOgjeVC/D57Pr8ybrDRbabo5zWa6bVoeamCiLNzcbcgBOXf2V/lj" +
    "B6vqi1+e8ZVFvgAo78MXvrxIHTfFsFHAhnkSZV+IfbNmc/6BvEYzvZlvXNTA" +
    "xHByrlJefn1Vvf+Oqrr7H6vOgz3GId1OzSVFGrQ0ata6jekVp3FQAxP9iTYV" +
    "eXn4nZ+sqk/cV6nD2Xawxzik27W5NLlIw5bGfeZevQYWU5MpixqYyCfygFZe" +
    "8ZDL9n333L/5O8GBGeOQbvfmkiKNXOofeeVpajJlUAMTcSJN5ZzZ5fnffkpv" +
    "dhccmDEO6U5qLinS4KO3TbuMdZ+IoQYmfKJN5ZbZX8vPf3kc7jNQOl8Chk2W" +
    "fcAH9elTIToOjEEfnrwNWZ+3BB8C7zL2wUQ3amCiHW44i3NuHLepNPBAWYeK" +
    "B536xLUP+KA+fSqSJtIGY9CHJ/c4+I9TkxkDNTCh8R7UyqZ8yy2zpvL5an4g" +
    "jA1cGh4o61DxoFOfuPYBH9SnT8VWA+mCMejDk0eJNpnpmUwMNTCxCDcWm8qf" +
    "zzbjwS9WiwfC2Lil4YGyDhUPOvWJax/wQX36VKR1a4Ex6MOT5yJN5qJP+g9/" +
    "p/fJdKMGJuZwI7GpnDe7Urlz1lTu+dLEunEvoDyHS+6oqqc7TabZMxOLqIGd" +
    "jncLNDWV9adkc2l4xye7b5emWyWNGtjJcMOknLG3qm7+vN50E+vHGM1FkD8q" +
    "r79R742UZi9NTM2lpuulZflr9ZGDeqNNrC9jNZeGS++ebpUiqIGdhPcFTW++" +
    "Zf69Ip/9EvinRT5DvmQAHc8noT9lb8QYDGJa8yDMm9Af52BCHx6MAXsL5QNQ" +
    "X5D90XWrtNM/ga0GdgpdVyun751/X+yhjZW72bG5rUPp+ST0p+yNGINBTGse" +
    "hHkT+uMcTOjDgzFgb6F8AOo33HhvVb30er2HUtJ9t5NQAzsBLn6D/BW6+HZj" +
    "Y+Vudmxu61B6Pgn9KXsjxmAQ05oHYd6E/jgHE/rwYAzYWygfgPpk16e7b5W4" +
    "B3cCamA703Ub1NwCcVPVGyt3s2NzW4fS80noT9kbMQaDmNY8CPMm9Mc5mNCH" +
    "B2PA3kL5ANRvQ/YR91bDTrtNUgPblbbbILlakW+l//Q/tXM3oFzxjwYRnS79" +
    "MWBMQv2AjXzNQUquvYWqP3UQw9U3UHkTzoMkuld+ZnYVc4Xeaw3cm9sVNbAd" +
    "4eI2nHj1/OsS1UYBarN6cGNam5NyQv0xYExC/YCNOqSZ9haq/tRBDFffQOVN" +
    "OA8CffmKh5fs03tuJzUYNbCd6LoNetMtyeZzUJvVgxvT2pyUE+qPAWMS6gds" +
    "1CHNtLdQ9acOYrj6BipvwnkQ6m/xF7fqvdew3W+T1MB2oes26K/vwuZzUJvV" +
    "w9hkIZ0u/TFgTEL9gI06pJn2Fqr+1EEMV99A5U04D0L9hJ16m6QGtgNcvIYT" +
    "rpp/UZB8MG2BLwLKM7nLgDqlY/bBzbEES5hnn3koGy9PT+5w6+w26cU77DZJ" +
    "DWw6XLSGP7tZL/ghBm4cwo1rbvjCMfvg5liCJcyzzzyUjZenJw/yto7bJO7l" +
    "TUcNbDJcLOGIy6rqg3fqRV6g0MZp4MY1N3zhmH1wcyzBEubZZx7KxsvTk2dw" +
    "xew26diW26Tt9DUOamBT4SIJrbdBpODGEbhxzQ1fOGYf3BxLsIR59pmHsvHy" +
    "9OSZyG2S7E/u2e3UYNTAptH2ipAs3M33zT/JOpQ7RsCL4cktaEM8fU9u6XjQ" +
    "/s4vAMotYMMYJFffwstByXvy6hv03hW2wytJamCTaGssL9o3byzmJukBN14J" +
    "vBie3II2xNP35JaOB+17HdLMZpGrb+HloOQDaGswm/4dMWpgU2h7qVkWqnOT" +
    "9IAbrwReDE9uQRvi6XtyS8eD9r0OaWazyNW38HJQ8oH86c16L296g1EDm0C0" +
    "sZibpAf0WQIvhie3oA3x9D25peNB+16HNLNZ5OpbeDkoeQHefZve0w08A5uA" +
    "Glh32hrLu27TG8TcJD2gzxJ4MTy5BW2Ip+/JLR0P2vc6pJnNIlffwstByQux" +
    "nRqMGlhn2hqL/O7y7V+YI59snlgdzTpE14P6EZvtjnzTnbyFgvt80xqMGlhX" +
    "rMYiC/C+O6aNuU7kNgrqR2x2AtuhwaiBdcT6Rn4pvCzAtDHXi9z1oH7EZqcg" +
    "+/s5xnthNuUhrxpYN6yXm5vGIgswbcz1Inc9qB+x2Um0XcFsQoNRA+uE1VgE" +
    "+Q2ZW78wR743oxPRSaH8vvm7JVNy5QrGbInbSQ/7piaHakOoDyi3UDEMnS79" +
    "PjEVnBdQMQwdomwyUfM0oI3LVm67WhrMur/RTg2sEywmG0towbYW6BCU3+dv" +
    "LE+uYMyWuJ30sFebmVAfUG6hYhg6Xfp9Yio4L6BiGDpE2WSi5mlAG5ckP2kw" +
    "PAvCc69Z3wajBtYFFlGQ32XOXrBkgWoov29xU1kby5MrGLMlbic97FVtCPUB" +
    "5RYqhqHTpd8npoLzAiqGoUOUTSZqnga0cUGO8vvVPBPr3GDUwDrA4gmv3D8v" +
    "ePaCYYGUXHyCXLmCMVvidtLDXtWGUB9QbqFiGDpd+n1iKjgvoGIYOkTZZKLm" +
    "aUAbF+Z5X3uD4RlaB9TAqmHRhFfMGsst98058Pk8Grsue+rcImNdePqUG3Fd" +
    "G8oDMAZhjANAyQ0fLvQLOXNmTHPuXl6ISf1eIAfG9OS1juPThfZbnHOTPiPr" +
    "2GDUwCphsYRTr10sLBfQgwtDuaWjFpl4+pQbcV0bygMwBmEM71DSPgT9Qs6c" +
    "GdOcu5cXYlK/F8iBMT15reP4dKF9gvzB5VlZtwajBlaF9Sa5Z19VVdfdu1hU" +
    "LqAHF4VyS0ctMvH0KTfiujaUB2AMwhjeoaR9CPqFnDkzpjl3Ly/EpH4vkANj" +
    "evJax/HpQnuw7g1GDayC516jC2Q1FoEL6BGxp45aZOLpU27EdW0oD8AYhDG8" +
    "Q0n7EPQLOXNmTHPuXl6ISf1eIAfG9OS1juPThfYGck54dtblJWo1sApYHHlN" +
    "/28Pzn+H9ybyeeDJ+0CfhPrLIJDDjSBi0wntLR+G/MNXzVG6LfrFicSI6Kwb" +
    "zHnGtfdU1dOMr8zkGVsFamDZsCiC/NaLNJapuSQEcliX5iI8/uiqOvakuH5R" +
    "IjEiOusGc97K+2Of0mdoHRqMGlgm1nOWl19/f2OZmktCIId1ai7CIx5VVT/x" +
    "s7iK6dAvRiRGRGfdYM5J3ue1/EY1z9wyUQPLwnzOsqeqrvnc1FxMAjmsW3MR" +
    "pMF8wzdV1SkvjukXIRIjorNuMGfkffZ1+kyt8vmLGlgWLMLhl1XVRw9W1Q33" +
    "gnsWkd92TqG+J7fItaE+ob5l48lJrn4E+iT7pd7A01HyGb87azBf8zVV9Su/" +
    "WVW7b9U6JDdPErGP6OToU27pkEjtcrh69of5qWv0/EUNLANOXpAfi2Jxa5LG" +
    "MjWXuH4E+iTc/OYB8ORbNA1GrmJe8katZ9lE8yQR+4hOjj7llg6J1i4H+QPN" +
    "s7WqBqMGxsZ6zvKy6+eFYXFrksYyNZe4fgT6JNz85gHw5AlNg/GuYnLzJBH7" +
    "iE6OPuWWDsmpXQ5vWpPnL2pgbDjh4/fML+daFyNpLFNzietHoE/CzW8eAE8O" +
    "0gbTdhVDG8o9IvYRnRx9yi0dklu7HM5ag+cvamBMOFl5zvKRg1W1794t7vG5" +
    "HlC+Cq6/F8gYoI3HUPt15uFJgxHk3x8/oPV2OkP2wJ7Prv75ixoYC+t26K2z" +
    "y+JDjWVqLos+B9qvO2wwD3pwVV34Ya23kxm6B+QPN8/cMhuMGhgLTvDMvdVi" +
    "Y5may6LPgfabABuM3Cad/CKtt1MpsQdee+M2by6cnNwO7fp0NTWXDobabwps" +
    "MM1tEvV2IqX2wKpuj9RAaaw3y0k3rSc+NZdWhtpvElaDkduk91+pdXcSpfbA" +
    "e+/QZ3AZX/CtBkrDST1rT1Xt/dwc+dBVSjO+gIwn0OZa8dMB/Sl7I67ygRxc" +
    "/QCeDeWE+jXIM2SToPQ5b2PupfidP6pUg5HbpBe8ofJzoJxQP0KmD9auSL0N" +
    "m1wa32fs1Q2GZ7U0aqAk1kPcS25PJn7PIixMDQpOGy4QoT9lb8RVPpCDqx/A" +
    "s6GcUL8GeYZsEpQ+523MvSRWgxEe8+SqOwfmSKgfIdMHa1ek3oZNLo3vv/vU" +
    "/HEEzyPPbEnUQEk4kZdcj4nfswgLU4OC04YLROhP2RtxlQ/k4OoH8GwoJ9Sv" +
    "QZ4hmwSlz3kbcy9NW4OR26T3XVnZOTBHQv0ImT5YuyL1NmxySf2/5gbdXOSx" +
    "Bc9tKdRAKTgJ6ZpXfAYTv2cRFqYGBacNF4jQn7I34iofyKFL/71XVNU575jN" +
    "+ag5v/yQqvqxn7kf+beM/8mM18/03vrXLXk6UL8GeYZsEpQ+523MfQzaGozc" +
    "Jp1zkdZXORLqR8j0wdoVqbdhkwtjLPPhrhoogfXzq2+8qaqu/qzD53yu+ewi" +
    "rg/KDZRP+iCJ7QUfqqo/PmreOHgYosih+aWHzBuO+DPnRZhTYK7yifMFZKwD" +
    "2ps+gMqJBPzJ+MNaGoxwwosWfaq8GdOANoT6zFtBfSMG5a4Pyg1U7Qj0L75d" +
    "n82xHu6qgRIweXmIWxfXg4UxUAtGaEO5gfJJHwkfu6Wqzj53vvmlKXDjl+Db" +
    "vnPesN5zuc61dZ6BuXIjct6E9qYPoHIiAX+NrKvBSH0anypvxjSgDaE+81ZQ" +
    "34hBueuDcgNVO2LYvHifbjA8wyVQA0OxHuJ+6M6t4nqwMAZqwQhtKDdQPhP7" +
    "91xRVa99R1UdfeL86oKbfGy+98Gzv9Qv1DmreQbmyo3IeRPamz6AyokE/KXy" +
    "rgYj6yHNXuXNmAa0IdRn3grqGzEod31QbqBqRwyby+5ezsNdNTAUJvzqG5Li" +
    "erAwBmrBCG0oN1A+t2ylsXBDrwq5mjn6hNlhurllnoG5ciNy3oT2pg+gciIB" +
    "f9TpajDSfP/uZuTNmAacK6E+c1JQ34hBueuDcgNVO2LYCG+4acOaC69apDt+" +
    "/O75h6hMPgMoHwPGtNjSfc3bK7WZV803fGNVPfrIqvrozcbcSMu8WgnoXwko" +
    "Vz5IRN/Q+e1H6locqsk3VdWff8iw64rhQR8etO/jYxkk+T3l8nEbjBoYAhN9" +
    "0T5jci0TXdpiMKbFlu6TZ1cK3Mjrghyo57zQmF/XXCknAf1VNRfBazCt9aD/" +
    "CPThQfs+PpZBkp/1vbs800NQA32xXiH66KeMybVMdGmLwZgWW7q/+JBKbeJ1" +
    "40d/puOvdsu8Wgnor7K5CF0NRpA/CF32YejDg/Z9fCwD5PiUy/W55dnuixro" +
    "CxN0r1qMiSr5GDCmxWfntx3cuOvMo48ybpWMeXUS0F91cxG8BvPbf9RtH4I5" +
    "eNC+j49lgBzPvWnNm4t11fLhg1V1+We6kTfVZXN3N5cDZR9A7M44p1Kbdt35" +
    "1gdW1asuTOYvc0lxauPpW7g+QESfOha/9Ug9/5Qf+emq+shN1XxPGDE8GG8l" +
    "SH0TmKOVJ+Uef298LKDU+17UQB/YWF64T0/CgoUJgYITb/NHEDtv864zjzpy" +
    "a/4ylxSnNp6+hesDRPSp04a3Rv/1B+YNhv4jMNZKkPomMEcrT8pd7rZ/c5pn" +
    "vA9qIJe+Vy0CCxMCBSfe5o8gdl//jZXarJuEHKzzPoiaO7Xh+lDfwvUBIvrU" +
    "6WKsBsM4K0Hqm8AcrTwpd7l7vKsXNZALG0v0qkVgYUKg4MTb/BHkUHKTbiLS" +
    "II98TlJzpzZcH+pbuD5ARJ86HmM0GMZYCVLfBOZo5Um5y9Y6jnH1ogZyYULv" +
    "vK2qdn9mjrwTcGx2g1y5xR8dWakNusk89JF6jhZ9apVLszdK7xGZI+edIs+j" +
    "3vTBue5f31RVp52zaO/ltYza9IF5Eeq3Ib83fdhlZa9e1EAObCwnXd29QGPg" +
    "FdOTW8jDQG7OTUf+esuh4lyH1ioX7xAPwWswciX3mnfOayH/ftYL7rf18lpG" +
    "bfrAvAj1u3h54asXNZADE0mvWqwFGgOvmJ7cgptyu5D+9bboU6tcvEM8FK/B" +
    "fO3XLf67aTBeXsuoTR+YF6F+Fx+6SzeXId/3ogaiMIkTcdViLdAYeMX05OSd" +
    "u6Uq2xf5681bgr616sMy9ojXYIg0GC+vZdSmD8yLUN/jBcaPqfHsR1EDUZjA" +
    "n948/xzRAp/uRn4BIEXZ3611dslYAn26GDFSXn6hVGX788gjdW0jtXJtSsC4" +
    "lAf4zUfqOXfxzLMX7QfvM/HhUSAGoU/GpD5rbX3fC89+FDUQhQn87UGdqJoI" +
    "C8GJ094oDotHny5GjBQ5dNx42xU5gDkbz1oPZVMCxqU8yJAGM3ifiQ+PAjEI" +
    "fTIm9VWtZxxz+eLZ7vszsGogAhuLXEqZiXIiQE2c9kZxWDz6dDFipOyk5iKk" +
    "DSZSK66HsikB41Ie5IM3VtU3fYuecxdNgxm8z8SHR4EYhD4Zk/qq1neXe7Cr" +
    "BiIw8PkHWhLlRICaOO2N4rB49OlixEj5+d+Qquws/udPV9UHbozViuuhbErA" +
    "uJQHkMbyPT+g5xpBGszgffZpXStFgRiEPhmT+qrWMz5oPNhlD4igBjz4jtzD" +
    "LutIlBMBauK0N4rD4tGnixEjRQ4aN9tOQA6iHEivVlwPVd8SMC7lDkMai7DT" +
    "m4sgL9AMbTBqwIMBX3Z9Vf3Dp+bI24gX+PQi/wCoT3nNlu/WGI4PLwfq/PBP" +
    "S1V2JnIg33dDUksDVW9Pzlo7cq6HtWaUp/4k/yGN5VFHa581Xk7Ul7kBJXd8" +
    "KLkBdQh9EqW/xRtuXoPm8pe3Va3F8wpBfcprtny3xnB8eDlQZyc3FyFtMKy9" +
    "VX9Xzlo7cq6HtWaUN76GNhZBXqp/wwd0noypcqK+zA0oueNDyQ2oQ+iTKP0t" +
    "PnJwyc3lqN2LweQWqat4XiGoT3lN4t+M4fjwcqDOz+3AZy5EDmhdSwNVb0/O" +
    "Wjtyroe1ZpSLnxKNpUEaTHoFV+PlZM0dKLnjQ8kNqEPokyj9hLMGvudFDXTB" +
    "QPILbl3F8wpBfcprEv9mDMeHlwN1/nCHvVpk8Yyzt2ppoOrtyVlrR871sNaM" +
    "8pKNpYG3iIypcrLmDpTc8aHkBtQh9EmUfsJbDqywuVxyx/wDT2EOOlC/BIxh" +
    "kej/wRFSlZ3LsWcZ9RkC14NQP2KTcMmsAfyXwo2lQfxesj8/p0MMmNfScHI8" +
    "7LLFM5/znhc10AYbyynX6ERcDjpQvwSMYZHov/htUpWdSfHGInA9CPUjNlsM" +
    "bSzHzq7QfuMP9XjKoQZjxHfpOa+l4uQov+/Osz/7T/UHCzXQBgPId28yEZeD" +
    "DtQvAWNYJPrnvF+qsvOQg6bqUgKuB6F+xOZTZRpL4yvSYBg/RI95LR0nx3fd" +
    "toLmkn1LZE2EUL8EjGEBm03/FrpcDh001qUEXA9C/YDN4MYiV2jw6TUYkdPG" +
    "JXNeKyGQI2+NZv+p/mChBtpInR99eVV99KDmb8BH71rEk9NfBOXTkzOmEfdn" +
    "f10qszN42lm6Rm21tKANob5Xe4+L9w9rLE8708jhrnmuv+40mN8/4v483Hka" +
    "/I3ESaEPI6cFaC96RpyumEoOKBeed81ic5FXjWf/o3oEUQMWvGqRH7JmAmai" +
    "TrEop78IyqcnZ0wjrmwibqztSFdjsWppQRtCfa/2XYzVWIQmX6/BSM2seTNX" +
    "Cx505aMlp0PQXvSMOF0xlRxQLrzqhsXzH716UQMWdPymW3QCZqJOsSinvwjK" +
    "pydnTCPu698nldneeI3FqqUFbQj1vdq3MWZjEdKcuxqM3DLL/nDnacCDrnx0" +
    "5FRDe9Ez4nTFVHJAuXDRJ5fYXD54p07ATNQpFuX0F0H59OSM2RL3AQ+U6mxP" +
    "2v76EtbEgjaE+pHak7Ebi8C8vQZz/sedeRrwoDOml5OyFz0jTldMJQeUN/R5" +
    "7qIGiHzNXer06VdW1YfvsvmIA/VH4SCg3MDK8/8dLtXZfjz1zPh6sC6WjSfv" +
    "sx4p776+qr77+/U8ojzlTO3TwprHr/2B9tcgOUlu9JODFTMb1Jc+ibIH1G9s" +
    "zti72Aciz13UAOFVi/xMKxPqSoxJjs5BQLmBledbZPLGptpk0sYSWQ/WxbLx" +
    "5H3Wo2FZjUVom0dXg/nvP6X95NAWMwvUlz6JsgfUb2xed+NiH4hcvagBQofy" +
    "dZZMqCsxJjk6BwHlBm15DtnY64YctLZ5tkF9y8aT91kPYZmNReiaR1eDERl9" +
    "RemKGQb1pU+i7AH1Gxv5gDJ7wew/1S9S1AChw/fdoRPqSoxJjs5BQLlBW56y" +
    "QbmZNpHmoLXNsw3qWzaevM96LLuxCN48uhpMn3iCFzME6kufRNkD6qc28haU" +
    "Ys2Fz1uOvXL+LVWHuHORD+VyVwDagNwcFvLfgjpp/H//wPkG2lSOOTOZD+fJ" +
    "2gC1FhaGny68GO8a2Fjq+RpxibcHVJ53djeYE157/xwa6IMwJqG+BW2IN08F" +
    "5pCu8enX5l29qIEUOnrBPiQrySeoRD04CQvagNwcWGyz4En8xx5//wbaNBYa" +
    "izVP1gaotbAw/HTRFaNIYwnm5O0BlecWbQ3mX31jVZ23ayv+FvRBGJNQ34I2" +
    "xJunIsmfa/zazPe7qIEUOjrvAJKV5BNUoh6chAVtQG4OLLZZ8CS+bHjZONxM" +
    "645qLNY8WRug7C0MP120xSjWWII5eXtA5ZnQ1mAk/7Q29EEYk1DfgjbEm6ci" +
    "yZ/1fFfm+13UQAodMdHciSo4CQvagNwc1BysGMjhERv2srS8jM459Kol7S0M" +
    "P11YMYo2lmBO3h5QeYK2BiPjTR70QeiTUN+CNsSbpyKto1HPwy4dobk8aeb0" +
    "A3cs8n6g5Hcu4soNqMOYSg68mLUOgc1F123W1Yvk+or3ok4yF2eerAvtLeiT" +
    "PlQMILUd0liefIb2SZiDlUdu3jL2f1sazNFn3l+PHBiDMCcrLzUPxnDkHsfv" +
    "GaG5iFNvYkrOiXhyA+owppIDL2atQ2AjHH3G/ZtnE6gbzCWLtfLmybqoWhvQ" +
    "J32oGAnvWEJjqXM0oE5O3qlPq8FI7V/53nk9cmAMwpysvNQ8GMORe/DnXrve" +
    "TKcGGvh9ueLUm5iScyKe3IA6jKnkwItZ6xDYNPzQT+mNtM6wwXjzZF1UrQ3o" +
    "kz5UjC2ksfznJTSWOkcD6kTztnxaDUaa5kX7KlWfLhiDMCcrLzUPxnDkHmwu" +
    "XVcvaqCBDqbmMvtrdIneROtO2mC8ebIuqtYG9EkfKsYdy20sdY4G1Ink3eXT" +
    "ajAyxvp0wRiEMa281DwYw5F7nHfLCM1FnHoTU3JOxJMbUIcxlRx4MWsdApuU" +
    "RxymN9G60zQYb56si6q1AX3SB2Msu7HUORpQx8ub+pTL3K0Gk/P8hTGIimno" +
    "qHkwhiP3eGfGK0ZqoIEOzr+1qt57Rya3g1x5hBI+wPtuXySVXXjdZr6xThrM" +
    "yy/Rc12gRy3lHdspXT6kdkMay1FnaJ+hvCmP6FBOWvR/FQ2mrvt7DP1IDEJ7" +
    "C9p4wJ7rWa8pYG9g72hQAw10wAAhvIl78gglfICu5iKcdv7iBtoU3AbTo5Zq" +
    "I7b4KNZYrLxaYrbKIzqUkw59NhiZ94V7u21C0N6CNh6w53pazeXYKwo2F3HG" +
    "ACG8iXvyCCV8AK+5CA9f4e2RxO770nhng+lRS7URDR9FG4uVlxGzUx7RoZw4" +
    "+mwwP/Vrvo0L7S1o4wF7rqfVXE7C70jLx4TYPwQ10JAaP2uPDhDCm7gnj1DC" +
    "B4g0F2HIgelLfdDumF9qF28wPWqpNiJ8FG8sVl658ogO5SSg/6u/vziX41/t" +
    "23TCmBa08YA919NqLmcHXzFSAwIN5Wcd33P7+Fxs8J7bgGHXBf1FoI82Xjrg" +
    "gPfhyDPKxRe7l15cLdSWdYjAmqS8bXYr8J8GNBbOty8Xy9wAdbLBvmRdmtr8" +
    "n6TBSM3P/fv22ln2Y9Mn5iv3F2wu4owBxoATrSe7xs1F+OPj9KEYg7aDVrLB" +
    "sA4RmE+DNJYhVyxt8+0DG8sym4uQNpgf/Ektb2izH5M+MeU7ndgj2EMENSDQ" +
    "UJwxwBhwovVk17y5CL+Cy9/SHHGGjplSqsGwDhGYi7BOjUVgY1l2cxHSBvPo" +
    "47Rc6LIfi74x2SPYQwQ1INBQfnWNzseAE60nuwHNRWyGXP53IY0lklOJBsM6" +
    "RGAe69ZYBDaWVTQXofkj1NweUe7Zj0HfmOwR7CGCGhBo+Fe3zb/mLhexS6Gc" +
    "UL+2uR0YdmOjcjI4/9qq+nffoQ/LEA4/PS+Hl1w8rMG8+GLtk3TlITUY0mTT" +
    "+ebQlVNfSvi0fDQN5sE/qfXHwMqhBOwR7CGCGhBo2Dep3IlRv7bZkOYiyOHs" +
    "e7gJD1okBxkfu8G05bGqxtKV0xBK+Gzz0TSYRx2nbUrTlsNQjgt8OloNCFNz" +
    "WUTl1MEzXqUPTi7WQYvk0MjGbDBWHqtsLG05DaWEzy4f0mCk1q//O21Xkq4c" +
    "hjA1l0KonBweNuANdm0HLZJDKh+rwTCPVTcWKyfK+1DCp+dDGszYt0deDn0p" +
    "0lyeesX8ga58xZ2HfKgpxZMT6tdI7ATP5p2ik0A5/Zlz8+QBfvn39EHyOOy0" +
    "xEePHFibFw5sMC/8Kx0j5S3XzBrLf9O2URbmm+LN3ZMD1sXaN0sBecv+/KVZ" +
    "g3nkcS17tQSsFaG+BW1uK9RcxEk0CW8BKSfUr8GkPJt1aS5CToNRB61HDqo2" +
    "t43XYEZrLFt5d87dkwPWxdo3SwF5N3tUGswLLjb0S8BaEepb0Oa2qbmsvLkI" +
    "ctnLg0XMg9YjB1WbLdvSDWbUxpLk3Tp3Tw5YF2vfLAXkne7TTWsup++dmouS" +
    "0585N0+egXcQWw9ajxxUbRL7Ug3Gm49H63xTvLl7csC6WPtmKSBvd6+WgLUi" +
    "1LegzW26uVhfd6kaC5vLM6+sqotmAd7xiXzELgfa18h4CmOAXHmt4+UxMIc3" +
    "X11V32UcyCedlsT0MPx6MK+zZw3iX/ZsMGJ3ygX2PKKk8+2Cc+c8qE+5qgP1" +
    "DRvCHOjTlRs6zIH6bg4GtGEMomJSh/6g33Ba4AfSVGMRUoPT9tpJRVCJO9C+" +
    "RsZTGAPkymsdL4+BOQjnocHwoKkYxPDpofL65LAG87Vfp8eicL5dcO6cB/Up" +
    "V3WgvmFDmAN9unJDhzlQ383BgDaMQVRM6tAf9Bt6NRe5UpmaCxiYQ6PTNBjr" +
    "oKkYxPDpofLa8jWkwfTBmm8XnDvnQX3KVR2ob9gQ5kCfrtzQYQ7Ud3MwoA1j" +
    "EBWTOvQH/YZezYUGU3OpBudg6aiYHoZPD8ZM/S2rweQ2FqsWnAf1KVd1oL5h" +
    "Q5gDfbpyQ4c5UN/NwYA2jEFUTOrQH/QbXndjgeby/FmHuvATPbl1kbd/YhGl" +
    "H+Dt4ieBMRS0D0Ab+lT6Tsw+PnLlFsyB8jNHbjBPeL6Rg+SeQLlVKyX36GPf" +
    "x8aDPgHXQ8mB8i92AZ0xeO3UXAz7ALShT6XvxOzjI1duwRws+VgNpm4sRi3U" +
    "+hl5cq5K7tHHvo+NB30CtR6UA+Vf7AI6Y9Crucj3YU7NBXjzcGL28ZErt2AO" +
    "bfLSDeZQYzFqodbPyJNzVXKPPvZ9bDzoE6j1oBwo/2IX0BkD6QvZzUVIDU6+" +
    "WjsOw2J9AsXsgSqmB+0D0IY+lb4Ts4+PXLkFc+iSl2owC43FqIVaPyNPzlXJ" +
    "PfrY97HxoE+g1oNyoPyLXUBnDIo0l2dcqR2HYbE+gWL2QBXTg/YBaEOfSt+J" +
    "2cdHrtyCOXjyky8Y9nLzbx+h82QMtX5GHp4Plz72fWw86BOo9aAcKP9iF9AZ" +
    "g2LN5W2zpN9qIONdePqe3OKtB4Dhp9PnAQ1tCPWVzx6oGKRPTGdeSj/hjVdV" +
    "1X8c8AY5Qa58zvhL7TslJ6dlwrwI9b1aW9CHJ++Fk5fSD0AfwqloLvIWFvYR" +
    "1Vim5qKhvvLZAxWD9InpzEvpb1GisTR4DSaa07JhXoT6Xq0t6MOT98LJS+kH" +
    "oA+BzYU9ZGouLQtAqK989kDFIH1iOvNS+reWbSwNXQ0mktMqYF6E+l6tLejD" +
    "k/fCyUvpB6AP4el4sy17SKi5HLm7PQCTIJ6+J7eYmksHzryoP0ZjaWhrMF5O" +
    "q4J5Eep7tbagD0/eCycvpR+APoQizUU4f5bkBQYyvmxyc4joU8fj/FsB/G0C" +
    "5+wZr7E0SIN5/rt17BTW1oI2q2AZObkxuO+MvUcfudCfGffA1FzC+tTxsIq9" +
    "SSyjsTR4DYa1taDNKlhGTm4M7jtj79FHLvRnxj0wNZewPnU8rGJvCstsLA1d" +
    "DYa1taDNKlhGTm4M7jtj79FHLvRnxp2NHXP51FxC+tTxsIq9CQxtLA89vP8b" +
    "7doaDGtrQZtVsIyc3Bjcd8beo49c6M+Me2CxPwxqLufeVFVvucXgAKDc4bwD" +
    "i1Bu4sWkHDCmGZd2kJ9H6K8PzMGD9haJ/utml7H/YUBjecypcz+nvHtYgzn1" +
    "3Ys5qlpyngaq3oZONh21C0F7w8fgvOlf/IjfBGVTAsa9pWBzecV+I2BL0Bx6" +
    "FduLSTlgTDMu7SDngip/fWAOHrS32NIt1VjquR8o22BULTlPA1VvQyebltqF" +
    "ob3hY3De9C9+xG+CsikBYv5ZyR+il+90UQGNoEru0KvYXkzKAWOacWkHORdU" +
    "+esDc/CgvcUtZRtLPfcDc0o1GFVLztNA1dvQycaoXRa0N3wMzpv+xY/4TVA2" +
    "JUBMudhgj2APEdSAQMPnXWMENIIquUOvYnsxKQeMacalHeRcUOWvD8zBg/YG" +
    "pRtLPfcD91Oiwahacp4Gqt6GTjasH+UetDd8DM6b/sWP+E1QNiVAzMi30Alq" +
    "oCE1PPaKqnrTzZo335IH7d8kYwnUt2woJ9SP8Gbi+KScUN+M4aDsGcMi0X/1" +
    "FcMayx+faviX2Mjzue+cNYpv0PYRxE7svbkypsrJgfrWPJSNlxP1DZQOfeZi" +
    "+XRQ+k4OlFvwa1kGNZcjLtMB6sSM5LugvVcIy4ZyQv0ILLDnk3JCfTOGg7Jn" +
    "DIst3bqxfJ8+zFHaGku9RkaepRsM56piMicH6lvzUDZJPmZO1DdQOvSZi+XT" +
    "Qek7OVBuIRcbXmMR1EADOxMD1IkZyXdBe68Qlg3lhPoRWGDPJ+WE+mYMB2XP" +
    "GBY3j9tY6jVqybNkg+FcVUzm5EB9ax7KJpmbmRP1DZQOfeZi+XRQ+k4OlFsc" +
    "HXiPi6AGGthcXrVfB2HiHrT3CmHZUE6oH4EF9nxSTqhvxnBQ9oxhMHZjqdeo" +
    "I89SDYZzVTGZkwP1rXkoG8yNckL/Vl7KZy6WTwel7+RAuQV7A3tHgxpooIMX" +
    "XFdVf3rzGnITyJX3QF6KS1ExDGjzZzKWwBgu8P+qWWP5zgGN5dGnaJ8qphGX" +
    "8pNnDeJf9GwwYif29KlI41tQ34I2xNHneip9yE2dzJhKbuDGdKB97SPJ4RXX" +
    "j9BcTrpaJ7IWeAvgyXvQVfw2aFOyuRRpLPDZWquAzugNJo1vQX0L2hBHn+up" +
    "9CE3dTJjKrmBG9OB9rWPJIeX7CvQXPjjaM++SieyFngL4Ml70FX8NmhTqrkU" +
    "ayyJz85aRXRuHrnBpPEtqG9BG+Locz2VPuSmTmZMJTdwYzrQvvaR5CAXGYOb" +
    "i5A6eNoVOpG1wFsAT96DruK3QZsSzaVoY9ny6dYqorPFaA0mjW9BfQvaEEef" +
    "66n0ITd1MmMquYEb04H2tY8kh2fvWWws1tdbNqiBFHaoN9yUh3wmKYVyQv2Q" +
    "zY2LvIFQ34A6Q6H/GuZp2C3gzOMVAxvLo07ROTKGRa7NCQMbjNifm1u7JZBb" +
    "hxDOmkfw8qL83EBtU/2nBl+GFtRACpvL61qCt8GJUE6oH7JhcQj1DagzFPqv" +
    "YZ6G3QId8yjRWKw8VQ4GuTaiM7jBXJRZuyWQW4cQHWsexcuL8nMD+zLVf8Kl" +
    "IzWXs67TgbvgRCgn1A/ZsDiE+gbUGQr91zBPw26BlnmUaixWnioHg1ybRq9k" +
    "g2GMVZBbhxAta56Dlxfl5wb2ZaP7qhsW+0HR5nLi1TpwF5wI5YT6IRsWh1Df" +
    "gDpDof8a5mnYLWDMo2RjsfJUORjk2qS6pRoMY6yC3DqEMNY8Fy8vys8N7MtG" +
    "Vz5jyJ7AnpGiBlL4GYIn79aBu+BEKCfUD9mwOIT6BtQZCv3XME/DbgHMo3Rj" +
    "sfKk3CLXhvonFmgwjLEKOC/Ke+Hs3QheXpSfG9iXja78EkjaD47aPaC5COxU" +
    "r5ldGr3+RptzHF5/0yKUW9CGMQntI6gYTp5eTMpr6JdykPp72eVV9cABjeWR" +
    "z9M+W/N0oA9CfSI6z7loWIMRe/pdiHET2Irblacn96B9DfKgTS7Kv6GTS8Rf" +
    "I8t53iKoAcLmIj/jyOBMog0eMMotaMOYhPYRVAwnTy8m5TX0SzlofJVqLOE8" +
    "HeiDUJ80emM2GB5q5mjl6ck9aF+DPGiTi/Jv6OQS8SfjL814Z26DGiB0+Kw9" +
    "OnhbooQHjHIL2jAmoX0EFcPJ04tJeQ39Ug7ET8nGEs7TgT4I9UmqO1aD4aFm" +
    "jlaentyD9jXIgza5KP+GTi4RfzLORyRFmouQOjz8Mh28LVHCA0a5BW0Yk9A+" +
    "gorh5OnFpLyGfikHpRuLEMrTgT4I9Qn1x2gwPNSMaeXpyT1oX4M8aJOL8m/o" +
    "5BLxJ+O5z1sENWDBjvWy2SXSa28IcKMD9S1gI898UihX9utCRp4v3j2ssfzh" +
    "8/wYIZiz5ZNyQn2D498xrMEcf5ERNzMHF88n5ZaOx1B7C/rsww35z1sENWDB" +
    "5nLKNfOALkySUN8CNtu9uRRrLB0xwjBnyyflhPotjNpgjHjZeD4pt3Q8htpb" +
    "0GcPXpTxYcUUNWBBx8ftqfQkLIxEF6C+BWy2c3Mp2lhaYmTBnC2flBPqdzBa" +
    "gzFiZeP5pNzS8Rhqb0GfPTg548OKKWqgjdSxPHdRk7AwEl2A+haw2a7NpXhj" +
    "MWJkQ3+WT8oJ9R1GaTBGnGw8n5RbOh5D7S3oswdPwTfPdX1YMUUNtMHOJd/r" +
    "8Or94IZF5NvrUlz9HtBHH+hTgXlQTn8WykfCC2bN+jsGNJbff25l19OIleKt" +
    "RwRViwI+j3v7sAZz3DsW/TFHa81YG1efcs47MnfouznQP/VljDGA69Ow4dln" +
    "b2hDDbTBAPJRAC8xNXFC/R7QRx/oU4F5UE5/FsrHFsUai1VPI16Ktx4RVC0K" +
    "+BS7kg2GOVprxtq4+pRz3pG5Q9/Ngf6pL2OMAVyf0I/+jIiFGmhDXnpKA8i/" +
    "vcTUxAn1e0AffaBPBeZBOf1ZKB/7CzcWq55GzBRvPSKoWhTw2diWajDM0Voz" +
    "1sbVp5zzjswd+m4O9E99GWMM4PqEvjxfHb25CAyibo04EU6cUL8H9NEH+lRg" +
    "HpTTnwV9FG8sVj2ZN/DsI6haFPCZ2pdoMMzRWjPWxtWnnPOOzB36bg70T30Z" +
    "Ywzg+kx05ZcV+RK0vJmOfaENNdAFm8vxe+YJhLl+kVfuX0TpGza58kgM6hAv" +
    "RojE/qxLhzWW35s1lldK/QBjch6E+n0Ywyd5xsAG84wLq6w1PGvW+I984zwu" +
    "ZTkMrY2y5xyceZjAvmsPndzjXbkpaqALfq/uYZcZyXfBie0PFN8rpiOPxKAO" +
    "8WKE2LKtG8uDpPL9qBuL5CX1A4zJeRDq92EMnxbFG0zi9xcfV1Xf8+PaLuXf" +
    "fHtV/a/fnddfmg/zsxhaG2XPfWisuQvsu/aQfLXt0pqLwGCn7zUm0AYntj9Q" +
    "fK+YjjwSgzrEixHi+oKNRZD6AcbkPAj1+zCGzzZKNRhZB2ko0jCoF+WHfmV+" +
    "dcMcU4bWRtlzHxpr7gL7tj3U941zKWrAgwHlMwdqAm1wYvsDxfeK6cgjMahD" +
    "vBgRijYWQeoHGJPzINTvwxg+uxjSYH7gF2ZN5bH97S3kiqetyQytjbLnPjTW" +
    "3AX2bXvohJ5vnEtRAx78dKQ88JHPGm00+wDlAzljVqNvf5BUux+POHn+kfcU" +
    "xoiwLj6ywfocO7sC+eeZDeLffufM5uv1eCl+4uHzdU7zXkmtCnGk8eowe4GH" +
    "GojAjia/ZcLkNooRm0uJxiI5ldio6+IjG2N9chrMNz9Aj42BrPOJH7g/75XU" +
    "qgBn7h1+1SKogQgMLD83wAQ3CmPzlqBUY5maC9gajzSYf/nNemxMJB/JS/Jb" +
    "Sa0KIN/ZxDPOHhBBDURhcPktaSa5MbRs3iGUbCxTcwGJrKvBLLuxpJS6lV0F" +
    "8ipwerajnyUiaiAKm4v8EttLrl/kxWTfIvImvAVgb+H58OQWtFE48yCnD2ws" +
    "v3uy9qlgTlKffXnzon4fPJ+58gj08TSjwXzzA3Rdl82PP7w7b29eEXL3gCfn" +
    "M9W+Vy2CGojCjwMcNjtQqhEQZ6K0t/B8eHIL2iiceaSc9vHhjaVXTlKffXnz" +
    "on4fPJ+58gj0IaQNRh7esq4RxF4aws8/dpEh65k2GOYcmZdH7h7w5E/He9lW" +
    "0lwEJiFdbyc3l1KNpVdOUp8t26gP6vfB85krj0AfDdJgvv/n818V+sFfrqqn" +
    "XqjjpJw+W9tfeKy27UKaVeqX+TIG5RFy90CXvNSD3AY1kAMTOfryasc2l5KN" +
    "pVdOUp/EPuKD+n3wfObKI9BHSk4DkPU67NxYHtatVxdsLFbejEF5hNw90CU/" +
    "duA7cokayIXJnHptteOaS+nG0isnqU+mD+r3wfOZK49AHw1ydRFtAHK1IvqR" +
    "PKRJRP0KVmOx8vbkEXL3QJvcumrp+yC3QQ3kwoTkVxlfeF0L+wDlJfBiUG7p" +
    "EOonnDrboN/2oEptsCi/c5IRL4KRi9LJJeIvopOjT/kAfi541fLgWWNRebRw" +
    "zF/kNxaxoR8TYw4LUN+ij41B6asWQQ30gUnJb8oy+ZpChejEi0G5pUOov8XK" +
    "GktbTtTJJeIvopOjT/kAviXwWSFZr1Nne1TlYTBqYxGMOSxAfYs+NuCMEa5a" +
    "BDXQBybWevVSoBAuXgzKLR1C/X0rbiwtOSmdXCL+Ijo5+pT35JgLdY0tnnhO" +
    "pXMwGL2xCMY8FqC+RR8bwG87KHHVIqiBvjA58+qlQCFcvBiUWzoE+oMby8lG" +
    "jFw4h8g8PCL+Ijo5+pT3JHJLFL0dWkpjEYx5LEB9iz42CWfPePzHF89un88R" +
    "WaiBvrC5yHdBSOJZ7NWcdd0iuXIVI0KHj+ftGtZYHnZSSwzOC6gcDViLXOjP" +
    "gnnRh0tgXrRRcsPHd/+4rjV58l8kPsXO4Oi35TeWo8UvchoFqzZ7F/HkrGXJ" +
    "97UQNdAX69LqNGMynbAQgWJ5chUjQouPYo3FisF5AZWjAWuRC/1ZMC/6cAnM" +
    "izZKbvhgrYk0gQWfYgf6NhYrp1GwarN3EU+e1vHM68a7ahHUwBDYXLKvXliI" +
    "QLE8uYoRwfBRtLFYMTgvoHI0YC1yoT8L5kUfLoF50UbJDR+sN/nRh8On2CUM" +
    "aSxWTqNg1WbvIp48rSN//1ngmR6CGhjC4KsXFiJQLE+uYkSAj+KNxYhBuLGU" +
    "vQFrkQv9WTAv+nAJzIs2Sg4fsj6sOfnfj4FPib3F0MZi5TQKVm32LuLJm3zH" +
    "vmoR1MBQ2FyOniV85rVb7F3kjGsXOaSXQB152awLFcORW6T6J/1DVX3rgyq1" +
    "waL81klbvjLn4UJ/hk/Oi1BfQf9GDMIYHrS3UDbI6XHn6LqTn/0TbScc+db8" +
    "xnLk27QfC5X3UErE2LIb430tRA0Mxbp6ec6eamOby4/8TqU2WJRDjUXInIcL" +
    "/Rk+OS9CfQX9GzEIY3jQ3kLZIKej3qZrT6zm0ruxGDlYqLyHUiLGzOYU45PP" +
    "G9FcBCb9pEur6nSrECyUAXVUsYCK4cgtUv2+Vy4LjUXInIcL/Rk+OS9CfQX9" +
    "GzEIY3jQ3kLZICcZY/0Jm8ugxmLkYKHyHkqJGNfOb394RnmGS6AGSsHkn36F" +
    "UQgWyoA6qlhAxXDkFrTJbTCqsQiZ83ChP8Mn50Wor6B/IwZhDA/aWygb5CRj" +
    "XAMi69foD24sRg4WKu+hFIghdxE8myXejWuhBkrBCQjyxjr57dlN5IS/jzWY" +
    "h56gbUvwfEB5CcaI0cdnH5t//W16LYis4RE9GovYMN4oyPlIYB2eL2NA+ehA" +
    "PlTMh7gCz24p1EBJOAn5RnFOeJPwGkzdWDIXPAo3GuUlGCNGH599bCLPxn7m" +
    "T9a4sQgjN5ehP3KWixooifVwV34ClpPeJNoazKHGkrngUbjRKC/BGDH6+Oxj" +
    "89AT9ZoMYemNRRixucgvdPAsbnRzETiZJ146vzzj5DcJNpiFxpKx4Dlwo1Fe" +
    "gjFi9PHZx0bWhA2iLytpLMKIzYW/QzR2YxHUwBhwUvJTJPJymDSZBWQMiN4C" +
    "1wLKHejfiuHJJe7xs838gAdV1UNODOhD3qbTpc9aUd+0AdQn1LegDaG+gmse" +
    "gDHa+L5fqlSjyOWfzRrLk2aNhfvMmwdzqYEPJQcqRgD6sLDeiTvWQ9wUNTAG" +
    "nJhwwlWLi1MTKV7mghH6t2J4cubg6kPeptOlz1pR37QB1CfUt6ANob6Cax6A" +
    "Mdp49Osq1SxyaGss1hqHcqQfyoGKEYA+iHyv9TIf4qaogbHg5I64bHFxaiLF" +
    "y1wwQv9WDE/OHFx9yNt0uvRZK+qbNoD6hPoWtCHUV3DNAzBGF9/1Y5VqGhG6" +
    "Gou1xqEc6YdyoGIEoA8idwk8ezybY6EGxsJ6uCsTX1ikSPEyF4zQvxXDkzMH" +
    "Vx/yNp0u/chmVjaA+oT6FrQh1FdgHhEYo4s+Vy9eY7HWOJQj/VAOVIwA9JFy" +
    "nPGeltKfH+pCDYwJJyrIT0c+9+oOrgG58gj04UH7APIenxTl08Pwmc0KfD4P" +
    "ePohG0D9H35YpRpIG3VjuUDnwBhKTqgveQHXxpMHaGKdePXqboca1MDYcLJS" +
    "AHmZTBW2rcC58gj04UH7AGqj5WL4zGYFPnnwPf2QDaD+sz5WVQ/43ko1EtI0" +
    "ljoGYRzKCfUlL+DaePIATSz+JKsgcp7HMVEDYyMT5KTl+YsqbFuBc+UR6MOD" +
    "9gHURsvF8JnNCnzy4Hv6IRug9Gcc855582BDsRrLdmsuTzGesyzzdqhBDSwD" +
    "64NTT7kchW0rcK48An140D6A2mi5GD6zWYFPdfAd/ZANUPpbPPGCSjUVq7Fs" +
    "p+ZiPWcReAaXgRpYFpy8YD5/YQFz5RHow4P2AdRGy8Xwmc0KfKqD7+iHbIDS" +
    "T/iNEyrVWKTpdNlE5qWgvuQFXBtP7nDC1at/zpKiBpYJi/C4WWFOvKqqTkq5" +
    "uhvRT6F8wVcbng3lPZAHbCluDMoJ9Q0b1oZQn/6oX5PMoZ4HoU9C/QDMgXKP" +
    "//Gw6lBjefwFQZ/Im/Mmyt4gOyb1HeSrTXimpOnw3C0LNbBMrJenD78MReMC" +
    "DFwwE8+G8h6ozejFoJxQ37BhbQj16Y/6NckczENFn4T6AZgD5RGkwTSNJeQT" +
    "eXPeRNkbZMekfgfHXK7P0iqes6SogWXDgghSqEOF4wIMXDATz4byHqjN6MWg" +
    "nFDfsGFtCPXpj/o1yRzMQ0WfhPoBmAPlfXB9Im/Omyh7g+yY1G/hGcYDXIFn" +
    "bdmogVXAogjHXblVPC7AwAUz8Wwo74HajF4Mygn1DRvWhlCf/qhfk8zBPFT0" +
    "SagfgDlQ3gfXJ/LmvImyN8iOSX0D+fIneZzA88MztgrUwKpgcaRgz9wzL94C" +
    "UtAO5DNLXVC/hjGIp095gFBemfrUIdRX8yDUD+DF9ORF4DwsYOPmBfsTgNKP" +
    "+CRejoy5Z/2es6SogVVhPX+RBvNsp+CEC0qoX8MYxNOnPEAor0x96hDqq3kQ" +
    "6gfwYnryInAeFrBx84K9OujUj/gkXo5pvD12Y1n1c5YUNbBKrPe/SAEXGgwX" +
    "hAvgQP0aLirx9CkPEMorU586hPpqHoT6AbyYnrwInIcFbNy8YL/q5iJvPOVZ" +
    "EXimVokaWDUslmowXBAugAP1a7ioxNOnPEAor0x96hDqq3kQ6gfwYnryInAe" +
    "FrBx84L9KpuL9Ud43RqLoAbWARZNkJeo5Ssyx0DevJdCuUcfe9oQ6o/BTom5" +
    "bbiyqo7cgCuWBjWwLrB4gnxVnyp4AYZu+D72tCHUH4OdEnO7IB+R4ZlY18Yi" +
    "qIF1gkUcq8EM3fB97GlDqD8GOyXmdmDTGougBtYNFlOQQrP4Qxi64fvY04ZQ" +
    "fwx2SsxNx/o2OWFdXnJuQw2sIyyqcPTl8y8ZljfbpchYiifvg+eTcgt5D88C" +
    "hp8FoE9/Vh4etI/g+Rgqj0AfhPrySWFFrs+B9r2YxXnalfab5Na9sQhqYB2R" +
    "QrK4TYPxFtmT98HzSbkFmwV9KKBPf1YeHrSP4PkYKo9AH4T6qjEY9aMPMtS+" +
    "D22NZZ3ey9KFGlhX2hqMfA6pa5HH2ASeT8ot2CzoQwF9+rPy8KB9BM/HUHkE" +
    "+iDUV43BqB99kKH2ucgfzk1uLIIaWGfaXt+XNxS1LfIYm8DzSbkFmwV9KKBP" +
    "f1YeHrSP4PkYKo9AH4T6qjEY9aMPMtQ+B2ks3OOb1lgENbDutDUYeR/M068w" +
    "uBJQbuHZeHKLXBvqE+pb9LHpsregDcnV72uTifxQWIoXUz553AX1+9K2vzet" +
    "sQhqYBNou0U67NKqOpYL5mwaE8/Gk1vk2lCfUN+ij02XvQVtSK5+X5tM1rG5" +
    "yB9I7ulNbSyCGtgU2hrME9hgnE1j4tl4cotcG+oT6lv0semyt6ANydXva5PJ" +
    "ujWXtsYit0nc+5uCGtg0uBiqwTibxsSz8eQWuTbUJ9S36GPTZW9BG5Kr39cm" +
    "k3VpLrJPrU83C5vwcnMXamAT4aII8qRdXkl6GniqAXUUVwDI5U1OHsoHUDlR" +
    "x8spqtOBm4OFE9PzSXmtQxwbJQ9AGw8vpoUXU8bkDyH37nZoLIIa2FS4OE2D" +
    "OXp2v5puVG4SczMTbgzIuYkslA+gcqKOl1NUpwM3BwsnpueT8lqHODZKHoA2" +
    "Hl5Mi66Y8oevrbFwb28qamCT4SI1yP1ss1G5SczNTLhxIOcmslA+gMqJOl5O" +
    "UZ0O3BwsnJieT8prHeLYKHkA2nh4MS3aYsoDWus9LNupsQhqYNPhYjU88VK9" +
    "QVo3M+HGgZybyEL5ACon6ng5RXU6cHOwcGJ6PimvdYhjo+QBaOPhxbRgTMH6" +
    "mdXt2FgENbAdaHuvgPy1ePJuY6N4cONAzg1koXwAlRN1vJyiOh24OVg4MT2f" +
    "lNc6xLFR8gC08fBiWqTx5I1xbbdB27GxCGpguyAv4XEBG+Svh9zzNsinrFNS" +
    "mUWufm2ze5FjCPWBpx+BPklE382DchLQVzEBa0n9CPTJHCj37FVOiQ95B/lj" +
    "W26DNvU9LBHUwHaDi9kgf0WiG4fk6tc23HiE+sDTj0CfJKLv5kE5CeirmIC1" +
    "pH4E+mQOlHv2KqctH20vMwvb4RWhLtTAdoSL2iB/TeQvh7dxSK5+bcONR6gP" +
    "PP0I9Eki+m4elJOAvooJWEvqR6BP5kC5Z8+c5Pbb+t3mBu7R7Yga2K54t0ld" +
    "G4d4G82Cmy97Mzv6EeiTRPTdPCgnAX0VE7CW1I9An8yBcs8+zWen3gYRNbDd" +
    "4WI3yG2SfIWm/MWZmMhm1lCOmvGElqYibPfbIKIGdgJtryYJco+sNs7EhIPs" +
    "m7arFYF7cCegBnYKbR98FOQla3njHTfQxASRW6CuZys76TaIqIGdBjdDitwq" +
    "yebghpqYEOSNmdwzKc0e26mogZ1I18NeQTaR/IVqkB+mWmC3T2ofwY1BuQF9" +
    "EuoT6tc2Th5Kvw+ZtcvVr20cqH+E+N3iiZd13wLt5KuVFDWwk+EmSZFbJbmv" +
    "NjcmD5yB2qwObgzKDeiTUJ9Qv7Zx8lD6fcisXa5+beNAfWkqh+9u/0xQQ7OX" +
    "JqbmYsINkyL312pz8sAZqM3qwM1Of0puQJ+E+oT6tY2Th9LvQ2btcvVrGwfq" +
    "e7dAO+2VoAhqYGKOd6skz2MObVIeOANuVg9udvpTcgP6JNQn1K9tnDyUfh8y" +
    "a5erX9s4iI481Jd1nm6B+qEGJhbhZiJyJSO3S/L9vTkcDign1JeN7+LFuKwb" +
    "2ls+lJx+DBsX+iDU96B9gMdfqtea7DL2y8T9qIEJG24s0jyTURu7BXUoHaiv" +
    "GomFF8M4VCm0t3woOf0YNi70QajvQfsOIk1lk7/XdpmogYl2vFulnCajDqUD" +
    "9VUjsfBiGIcrhfaWDyWnH8PGhT4I9T1oD550WaypTLdAeaiBCZ9ok5GHgGqj" +
    "b6EOpQP1VSOx8GIYBy2F9pYPJacfw8aFPgj1PWi/hTQV79Wfqan0Rw1MxIk0" +
    "GXkYKM9lpNHkIA8Su3ii+PQw/A7GiaHyJI59WKcL2gNZj0hTmW5/hqEGJvrB" +
    "jWkhG1ouv9VhMOAhJTwwJobfwTgxVJ7EsQ/rdEH7GfKBwkhDEaamUgY1MDEM" +
    "blQLuZqRjW4evi14SAkPj4nhdzBODJUncezDOl1s2UlDkauUrpeSU6amUhY1" +
    "MFEGbtw22m6beEiJOoAWPHQlcGKoPIljH9bpIKehCLuM9ZsYjhqYKEvX1zuQ" +
    "x8543IzHy/9+vBs5QERsU5Tc87EVu4H6FrShT+pHoA9C/YachiLsMtZrohxq" +
    "YGI8uLm7kIPS3D5Z8MDVh27XIkru+RCbBOpb0IY+qR+BPkij19SItetil7Eu" +
    "E+OgBibGp+u7ZNpgs+GBqw/drkWUHFDORkF9C9rQJ/Uj0EfqJ7eZCNOzlNWg" +
    "BiaWS+TlbAur0Wy35iL/v08zEab3pqweNTCxOnKez1jIM5uGTWouzVVZn9sc" +
    "ssuo68RqUAMT6wMPzoRml1G3ifVADUysLzxYO5Hpe1M2BzUwsRn0eSi8iUzN" +
    "ZHNRAxObTd8HxKtmegC7/VADE9sXHuhVsMvIa2J7ogYmJghvwab3jUxEUAMT" +
    "ExMTJVADExMTEyVQAxMTExMlUAMTExMTJfj/mpgkhdLpNB8AAAAASUVORK5C" +
    "YII=")

EDIT_WORLD_ROLLOVER = ("data:image/png;base64," +
    "iVBORw0KGgoAAAANSUhEUgAAARcAAAEXCAYAAACH0wDUAABKGElEQVR4Xu2d" +
    "C9w113TwfV+VXqi2X0tblKqPlrbausUtiWuEhEhC4hoVIkTEnZA2SAQhbmkQ" +
    "hAjiEgQhQqlLJBGSJiQEQSKJEHcRl1b77e9Zc86878x/rZm195495znneWZ+" +
    "v//v9757XfeavddzZs45c652VghXm5iYmCiNGpiYmJgogRqYmJiYKIEamJiY" +
    "mCiBGpjY+Lzo2BCeeeRW9nlBCPd4fJub3H9N8dY+f3BXbfvAZ7b9C8xhYuOj" +
    "BiY2Bu/6t9mmlo0uG55NYT259cO2NqCj3zs1no2KGphYLepXISmvNpaV+lXQ" +
    "9GpnY6AGJpYbaSbyV182IjfnRqVuOKzFxHKjBiaWC7lsGLOZ3PqhIdz9cW2e" +
    "8UrNR87YCmUCfQiMVQKpg9RDmixrNbFcqIGJ9UWaidxgLXWJI/c36oZx2BvX" +
    "msPpIXz/RyH8+tcG/51BpA9pSq959yyP3Z8xy4u55jA1m+VFDUwsHtkYQzab" +
    "bLC77RvC3oeE8LRXhHDyaSGc/sUQfvmfifwKUG7pEOo7XHDRLF/JW5B5DHmV" +
    "Jk15ajTLgRqYWAzybo78xeXmiEE2325PD+HQY9Y25zfzN7YiplFQh1A/E2k6" +
    "R71r1jD/4n66BjHIvZrp3aj1Qw1MjItc8qT+ZW42ky2vSLipS2zsGH/UIdQv" +
    "RLPZpNZPkLpLQ+f5mBgPNTBRHnmnI/UeilwetJoJ4aYusbFj/FGHUH8kpC5S" +
    "H2m6Kc1GzsP0ztNiUAMTZZCX4ykfXvuD7UN41PNCOO5DIfzs5xH8QnMVoFz5" +
    "AFcBZW9BP5QDxmDOVd6JPoVTzwnhKS+b1ZG17ULuc033Z8ZDDUwMQ5pKyquU" +
    "BzwthFe9I4RLrzA2VR/GBlOblNAH4MZX9hb0QzlgDOac21yaSIOWRs1adyGv" +
    "fKZXM+VRAxN5yF/A2KbyDw8J4fmvD+G8rxsbKRZjU6lNSugDcOMrewv6oRww" +
    "BnMu0VxqO2nY0rjv+lh9DiymJlMWNTCRhizGmGv+v9h59rL9M+fMN+5QuKF+" +
    "YWxSQh+AG1/ZW9AP5YAxmHPJ5tJEGrnUX84Dzw2ZmkwZ1MBEHLFNpb6Pwk3F" +
    "xZ8MN9QvjE1K6AOoHGlvQT+UA8ZgzmM1lyZyfyb2skneZeK5n4hDDUz0E9tU" +
    "HvncEM79agg/vnIkfmZAHfATQHkUiTEXgpcT5XMdOT9POiKE34+4CTw1mXTU" +
    "wISNNBUuOIvRm0rNzwyoA6bmYutcfPnUZMZADUy0kQ9eeTdqZVHK4lxIU6mR" +
    "DUKoA6bm0qNzZXyTkVeu01vYPmpgYive51TqpiKLkgt1dOpN0oQ6YGouPToN" +
    "5Hw+9+gQbuzc/JXPyXDNTGxFDUz4l0DSVJ74khC+fmkI3//xxLLxg5+0oTyF" +
    "I97qN5npnSUbNbDZ8S6Bpqay/JRsLjX/8tr+yyW5VJq+JNlGDWxWvG8ob7fP" +
    "2sL5sl50E8vHGM1FkD8qjzhYr40mcinNtbVZUQObDe+tZflrdcz79UKbWF7G" +
    "ai417/n4dKkUgxrYTHgPaHrC4SF85eIQvvODDcL3HahfgkXEWCdkffRdKskl" +
    "9lmN9bbZUAObAXl7ue/VyraPmT2WkYtp5eFGJ9QvwSJirCNnnh/Czk/Wa6jJ" +
    "Zn3bWg1sdPreCZK/Qi85Ti+gDQM3OqF+CRYRYwmQP1g32kmvqRq5p3cW1uJG" +
    "Rw1sZPoug57w4rVLoIvCht4AaqMT6pdgETGWCLlU4tqq2WyXSWpgI9J3GSSv" +
    "Vl77ntnX84vxXYMYnT79MWBMQv0ILgOUR8WI0enBzUFAjMsA5cqeNHRP/kz/" +
    "q5jNcpmkBjYafZdBf7dnCKd/wVgoQ+HCtBYn5YT6Y8CYhPoRuBs7JkaMTg9u" +
    "DgJilGwuwvlfD2GnJ+k1V7MZLpPUwEai7zJovxc5i28IXJjW4qScUH8MGJNQ" +
    "PwJ3Y8fEiNHpwc1BQIzSzaW2efZReu3VbPTLJDWwEYi5DHIX3xC4yKzFSTmh" +
    "/hgwJqF+BO7GjokRo9ODm4OAGGM1F0F+l2kzXiapgVVHPoLNk1fzt3uE8Olz" +
    "QrjocvBtQDmB/sVA6V8++zJciwibPnvKx4Axzbhe7Tz5GDCmhWcDuTpfhP7g" +
    "8wtfC+G+B+g1WbMRH+WgBlYZOUE8aTWPe6Fx8o1F0LlQevTVwqP+5XqTxtj0" +
    "2VM+BoxpxvVq58nHgDEtPBvI1fki9Nfhs+8e4EZrMGpgVelqLNfZLoSjTjBO" +
    "vLMIeoG+WnjUv1xv0hibPnvKx4Axzbhe7Tz5GDCmhWcDuTpfhP56fJ50agh/" +
    "fl+9VoWN9BgHNbCKdH3psPMyiHQsgk6grxYe9S/XmzTGps+e8jFgTDOuVztP" +
    "PgaMaeHZQK7OF6E/x+cXLpytT67ZjdRg1MCq0fWO0N88KISzLwjh65e0udBA" +
    "vu3ahPILZawJ5THQB6F+BpyHO3cnB+WP+oaNKyfUz7GhnFA/wmZo7aJ01sb2" +
    "fLZeu8JGeCdJDawSXY1lxyfOGkvUIpHxS7GBqOMtkhjog1A/A87DnbuTg/JH" +
    "fcPGlRPq59hQTqgfYTO0dlE68/GuBiPveHLNrxJqYFXoeqt5zwPbJ9BdJDJ+" +
    "KTYQdbxFEgN9EOpnwHm4c3dyUP6ob9i4ckL9HBvKCfUjbIbWLkqnIXvsYXot" +
    "r3qDUQOrQGxjEdxFIuOXYgNRx1skMdAHoX4GnIc7dycH5Y/6ho0rJ9TPsaGc" +
    "UD/CZmjtonQgP/QYvaZrVvEpd2pg2elqLIe+wTh5l0QsEhm/FBuIOt4iiYE+" +
    "CPUz4DzcuTs5KH/UN2xcOaF+jg3lhPoRNkNrF6VD+aUbq8GogWWmq7HI7y7L" +
    "N5qFCzwuNqDOAqjz7crbk5egRAz6INQn8jAuRaKP9TifzNGCNrG8++Ozj1Bw" +
    "na9ag1EDy4rVWOQEvOL4xBPKhbigxUi8hejJS1AiBn0Q6hPVWKbmUtHXYLg3" +
    "lhU1sIxYT+SXwssJSD6hXIgLWozEy9uTl6BEDPog1CeqsUzNZQuyvm/5IL32" +
    "V+UmrxpYNqy3m+vGIicg+YRyIS5oMRIvb09eghIx6INQn6jGMjWXFl2vYFah" +
    "waiBZcJqLMLBR4dw3tfXkQsB5QbyfI8mntyD9qsK5xWD54PyEpSIQR8etd07" +
    "/81uMMv+QTs1sCx0fVdo3RuLMDWXYnBeMXg+KC9BiRj04dG0lQbDvSAs81cF" +
    "1MAy0NVYnnyEPmHrwtRcisF5xeD5oLwEJWLQhwft5Q8r98QyNxg1sN50fSVd" +
    "vpwYu5FHZ2ouxeC8YvB8UF6CEjHow4P2QleDWcbHNaiB9aTrQU+7PSOEc746" +
    "41zylTa1XieiQ6hDUvVjSPUZoa9qA6jvwdpWOD6VnHkTw4enwxiE+lkgB9aB" +
    "+pRbOqX4p+fpPbKMDUYNrBfyaEoWS9jmke3CciEln9DGgulavIpU/RhSfUbo" +
    "q9oA6nuwthWOTyVn3sTw4ekwBqF+FsiBdaA+5ZZOSeQPLveKsEyPzFQD64X1" +
    "IblbPDCET/9Hu6hcSMkntLFguhavIlU/hlSfEfqqNoD6HqxtheNTyZk3MXx4" +
    "OoxBqJ8FcmAdqE+5pVOargbDvbVeqIH1wHrL2WosAhdS8gltLJiuxatI1Y8h" +
    "1WeEvqoNoL4Ha1vh+FRy5k0MH54OYxDqZ4EcWAfqU27pjMEtdtd7Z1neolYD" +
    "i8a6gft724bwlg+F8PkvGXy5zVlfakN5DsonMWz67HPyUvbEsFGk2lDfwrE5" +
    "a23sixfOkH9TX83L0CHip4knZwwlFztvXg7KnwVjEOp70H6Nf1/bRDfYUe+h" +
    "ZfhdJDWwSLrus8hvvbCIXSeEC4nyHJRPYtj02efkpeyJYaNItaG+hWNTbzb5" +
    "6Vb5WQ3qq3nRn4G3kSlnDCUXO29eDsqfBWMQ6nvQfu7jLSfrPSSs9/0XNbBI" +
    "rPssuz7NKGDPCeFCojwH5ZMYNn32OXkpe2LYKFJtqG/h2DQ33Pd+FMJPr5o9" +
    "L7bWV/OiPwNvI1POGEoudt68HJQ/C8Yg1PegfcPH/h2/Uc09t0jUwKKw7rP8" +
    "9dr1479/3iigUcwaLiTKc1A+iWHTZ5+Tl7Inho0i1Yb6Fo4NN500mF//9+yh" +
    "1KKv5kV/BvTpyRlDycXOm5eD8mfBGIT6HrSHj3s8Xu+p9bz/ogYWQdd9lmNP" +
    "CuGzX2xzxlDOiwA2Kgfq58AY57Xx9BXUt6ANcwCUF2Etj+/+MFTHD34Swue+" +
    "pOUK+gCqdoZOn75Vb1UL6tCnp2/YuHj2lIOPnhnC9Zfo/osaWAScvPCsI/UJ" +
    "K7LgjZOggI3Kgfo5MMZ5bTx9BfUtaMMcAOVFmOdSNxh5FfPVb2l5Ut7noXaG" +
    "Tp++VW9VC+rQp6dv2Lh49pQbyB/oq91asx73X9TA2Fj3WXZ56qwwPGFFFjyK" +
    "bwIblQP1c2CM89p4+grqW9CGOQDKi9DIp24wrVcxzDkm7/NQO0OnT9+qt6oF" +
    "dejT0zdsXDx7yi3W9PZ7kd5jAvfi2KiBMbGuCf9qt9nLOSkMT1iRBc/iW8BG" +
    "5UD9HBjjvDaevoL6FrRhDoDyIiCnZoPZ8iomNe/zUDtDp0/fqreqBXXo09M3" +
    "bFw8e8ot5rp331fvtUXff1EDY2F9b+ja24bwhveHcOq5c87x+QygvAh1PnO8" +
    "mJ8RnSbQt2wYg3LX3iIxb+or+UjI29TN4zs/mG2Mzrw5L0D/1FfyHMbw6eDV" +
    "wcxjPn7y6SH82b31npP7ndybY6EGxsK6HHr6q5xCGaiCjwFOoBeTi536lg1j" +
    "UO7aWyTmTX0lHxE2mJ/9fPaJUzNvzgvQN/WVPIcxfDp4dTDzaMjkDzf3nMC9" +
    "ORZqYAys57Pc9bERhTJQBR8D5OXF5GKnvmXDGJS79haJeVNfyUeGDebXv579" +
    "5IbKm/MC9Et9Jc9hDJ8OXh3MPCB/6EF678ntCe7RMVADY8DJyeWQPFmLhVCF" +
    "MlAFHwPk5cXkYqe+ZcMYlLv2Fol5U1/JF4BcEvGQptPKm/MC9El9Jc9hDJ8O" +
    "6vwxBysPQ25dHi3iJ0rUQGmsD8tJN+0qhIcq+BggLy8mFzv1LRvGoNy1t0jM" +
    "m/pKvgjOtRuMXCbJh8SqvDkvYPksPq8xfDqo88ccrDwM+cuP13twEQ/4VgMl" +
    "kffWOamb7xrCJ8+a8Ykloc6nKy9PTqifY0N5DCV8eAyN0WX/7e+xvYTwX2uX" +
    "Sed/Q/soQVcescTYx+gM0bfo8rH9Pnovjn1zVw2UxLqJe8Rb9cTXmzqfrrw8" +
    "OaF+jg3lMZTw4TE0Rp+91WDk+NZ3tJ+h9OURQ4x9jM4QfYsuH8efMrsdwf14" +
    "lrFvS6EGSmHdxN35yfbE15tmTlZenpxQP8eG8hhK+PAYGsOz72owV141+/wG" +
    "9XPx8vCIsY/RGaJv0efjIc/Re3LMh3urgVJwEtI1P/jp7omvJ82crLw8eRPZ" +
    "APLAIvlrK8gX93700xB+OOeKH22ViZ584Sw1RhclfHgMjRFj39Vg5DJJakb9" +
    "HGLy6CPGPkZniL6F58O6uTvWVwPUQAmsn199zCEh/NtnwZkZ0AehPqH+Gh8D" +
    "yqYH+bTnRd+efZw995BNI59cFT9nrvn7mBEnCs6N8lToT+pzZj/KB4nwJ3ry" +
    "LJiu48vfNPwOxMqhhVGLFtSP8ZkKYxr1Uzbg8DfrvTnWzV01MBTrG883e0CY" +
    "bVpiTN6FPgj1CfU/O8sttrlI95fnk8jil6YwxvGLX84ajbwTwvi9cG6Up0J/" +
    "Up8z+1E+SIS/WrevwUh9lO8BdOWwBaMWLagf4zMVxjTqp2wM7nuA3qNj/HKA" +
    "GhiKdRP3NSeElW0ussHPviCEr13S/l7Mog552FL0X2rOjfJU6E/qc2Y/ygeJ" +
    "8NfU72swcj6k2asYGfTlUGHUogX1Y3ymwphG/ZSNwYmfCOHad9H7lHt5KGpg" +
    "CNarlj0PDFs3LTEm7kIfhPqE+p/dmh+bizSWZTl+/stZg+vdTJwb5anQn9Tn" +
    "zH6UDxLhjzaXXcFqbD2k+fbWJBIvB+atoH6Mz1QY06ifsung0YfovVr61Ysa" +
    "GAJftUh3POHjIXz49A5OA5QX4BSgYlrMbeWRAMt2yKXYNy6dLRDOlZxyGmAt" +
    "HH3Ko2AtgcrB0LF8XvIdVmLrITU57QuG3RzOq5qbB30AJbdiGHpj4+XZnOOf" +
    "7tDer6VfvaiBXKxvPd/nicbkOiZqndASqGIzpsXc9isXcxkvzyEbSn7ek/Nt" +
    "zf00wFo4+pRHwVoClYOh0+XTazBd9eC8qrl50AdQciuGoTc2Xp7NOT7xJXrP" +
    "lnz1ogZysd4hetNJxuQ6Jmqd0BKoYjOmxdzW+lj6sh3f/3H3X20udlULR5/y" +
    "KFhLoHIwdPp89jUYOeQPAu05r2puHvTBvCm3Yhh6Y+PlyXmO+epFDeSQ9arF" +
    "mKiSF0AVmzEtTp9ddqzS8Y3L9KUSF7uqBWsFfcqjYC2BysHQ8Xx6DeaS77bt" +
    "Oa9qbh7IQeVNuRXD0BsbL0/O81HP13u31NcC1EAO1quWN5wYwkmngk/3Ix+y" +
    "I9Qhrj5y+KCF4UOe6L5qx1W/mH2IT9WgAzXvxPNVkWPTZ2/APOWcyYcQ+w75" +
    "8KJsLhWvi4iYfWtGyQ1SY6gcc2BcyN/xkRCuhXeOSn3uRQ2kYr1quff+cRMj" +
    "qtiGDnH1eUItDB8XX87lujqHPBNF1cFAzTvxfFXk2PTZGzDP+rx5DebHVyY0" +
    "mMiYXWtGyQ1SY6gcc2BcytfY/Rl6D5d49aIGUul81RI5sSaq2IYOcfV5Qi0M" +
    "H//5X1yqq3XIxpLf2lb1aKDmnXi+KnJs+uwNmGfz3BVrMAkxrTWj5AapMVSO" +
    "OTAu5Z8e79WLGkjB+jnWLa9aIifWRBXb0CGuPk+oBXzIptwIhzRI+QCeqskc" +
    "zpu1or5Jjk2fvQHz5Pkr0mASY7pyg9QYKsccGJfyOWO8elEDKVhP83/+60N4" +
    "3ydnyCcBS/M+B6U/zyUlJ3ki/UY65KPyJ0bM3aulqSN+mxg2LfuM88GYRHRk" +
    "jn2H3I+SD9tJjh/8TAifOx9+nLwYk1A/hxyftCHUJ7Xe204u/+pFDaTAxnKr" +
    "B4feE1QCFo8ofWfRWFzxw7DhDvnrLX8NOdcmXi1NHalpE8OmZZ9xPhiT1Hpe" +
    "g5FXcvJkNqmFHOd8peHHyYsxCfVzyPFJG0J90tTd7ent/SwM+ca0GojFel5L" +
    "81WLdYJKwOIRpe8sGouNelR/vT+v57ulVoByU0dq2sSwadlnnA/GJE1dr8H8" +
    "z/9r/39Lg3HyYkxC/RxyfNKGUJ80dY9+j97TQ573ogZiYRJ81WKdoBKweETp" +
    "J+b0kTPChj7kr/eZ5+t5V7UClJs6UtMmhk3LPvF8VDYO1PcaDI+qwTh5MSah" +
    "fg45PmlDqE+ov8N+7X0tcO/HogZisN5+3vewEE74WD/vBpSXwI3xcYOG/FNn" +
    "h01xXHCRro1bOwPPxpNbeDaUW8iHClMO+VwT4/TBeJTnMIbPVF58nN7buTd2" +
    "1UAM1o3cN5+kEyWLKJ4bg40FzUU23WY5ZAMm1c7As/HkFp4N5V2M2WAYi/Ic" +
    "xvCZzNp+uN692ns792dg1UAMbCz3fHxcMRZRPDcGG8smbi5yNBuMWzsDz8aT" +
    "W3g2lHfx/rXLm1/9J2fcf8Q2GMaiPIcxfCazth92eVp7fwvysRP2AQ814GH9" +
    "XMhTXx5XjEUUz43BxoLmcul3udw2/iEPXZL7DG7tDDwbT27h2VBuIY1Fnl2c" +
    "c8Q0GMajPIcxfCazth+OOkHv8ZxvS6sBD34iV94bjy3GIornxmBjQXNZj6fN" +
    "LcMhG1E2ZG/tDLx6e3ILz4ZyMqSxyLHZm4vwd3u297nAXuChBjwY8P5PmX18" +
    "WHi7Q60Xq59j4+lTTp1VeMzCWIf8OsG7Px5fK0tnqDxGh/K3n7IV2ZQyj9xD" +
    "foRN+Tdwc4rU6SPGnjqE+qRL/zGHtve5kPoTsGqgD+uzLS98k06si66J9JFq" +
    "4+lTTp3N3FzkaDYY1om1snSGymN0KG81lgG/wiCHvFV/yhlGjNScInX6iLGn" +
    "DqE+6dJ/w/v1Xk/9AXs10AcfY3mT+9mJddE1kT5SbTx9yqnjfU9lMxzSYGJq" +
    "ZekMlcfoUF6qsdSHNJjmKzgLN6dInT5i7KlDqE/69O/+uPZ+F9gT+lADXVhf" +
    "UpRfcOtKzKJvIl2k2nj6lFPnS9/kUtt8hzw7OKZWls5QeYwO5SUbS33wEpF4" +
    "OcXq9BFjTx1CfdKn/6Qj9J5P+TqAGujigc8MKtDL3hbCW07u5q3gLR9yMHwM" +
    "5a0faqNiIu75X+cy21zHZ7/o1CoV45z0nZ8KGW9Amybv/OiwH6TrO8Tvuz4y" +
    "r4URuzUPA9aCchLjk9AmFdae8t+9c3vPp3zmRQ10wcZy+710IkQVAsVWGD6G" +
    "oopn0dBftcdbljyajaWzVqkY56Tv/FTIeAPa1AxtLPJrmV9zvgFfNxjGJszZ" +
    "Wu+UkxifhDapsPaUy++7c++zN3ShBrpgAHn2JhMhqhAotsLwMRRVPIuG/oc+" +
    "w+W1OY4zzousVSrGOek7PxUy3oA2QonGUvuPaTCMT5iztd4pJzE+CW1SYe0p" +
    "P+QN7X0vxF4aqQEL68fOvEuiKnHAYisMH0NRxbOAza9W/Cl0qYc0luhapWKc" +
    "k77zUyHjDWgztLHIc4YZw2swImcerXkYsBaUkxifhDapsPaUC7w0klsk7BEW" +
    "asCC3yW67j1COPYDGvkpkSZKDii3oE8P174RfwvQSf1W7Sofp51r1GPOsVJP" +
    "B9qkwvNlnrMGbztl9nMqucfp5+p4VcwP+L9T9cUL2/oebq0wN5UT5097KwYx" +
    "bFK53SPa+z/2IVJqwIKvWuSHrFkIqxhKDii3oE8P174RfwvQkUW0GY6+xlKd" +
    "H6mnA21S4fkyz9mcsRpLFXOO12BqH5yHhVsrzE/lxBrQ3opBDJtUHvSs9v4X" +
    "2CMs1ACx3oLe70W6EFYxlBxQbkGfHq59I/4WoPOBT3NJbbxDfkhN1QFw4VrQ" +
    "JhWeL/OcnTRuY6liNuhrMPJFyJM+pedh4dYKc1Q5sQ60t2IQwyaV575O94CY" +
    "+y5qgFj3W179Ll0IqxhKDii3oE8P174RfwvUWePKq7isNs5RNZauWjTgwrWg" +
    "TSo8X9Y5G7uxVDGB12Dkezi0IW6tME+VE+TK3opBDJtUxG/OfRc1QOQxd02n" +
    "N9ophNefaCM/KdLH69/XD/UrG+DKxU8DJbcwbM79KpfUxjjkGbJdtSGqThao" +
    "HeU8x4pGPIs3f3BYY5H5qphGXJX3if2P35CcJDf68Xz2yQn1TTAv+uD5Sbaf" +
    "6237mHYfiLnvogYIX7XsuL+R4BwmRTgRQv16Yn0xlNwpJu0rDBv5tOJGO5qN" +
    "xaoNUXWyQO0o5zlWNOKRIo2lKwfEUnnP6Wswl12h/cT47JIT6ptgXvTB85Ns" +
    "P9d7+L+0+4DAXkHUQBPrfos8zlIlOIdJEU6EUL+eWF8MJXeKSfuKDpshC3vZ" +
    "DjYWqzZE1ckCPinnOVY04jUp1li6ckA8lXeDvgYjMvqK8WnJCfVNMC/64PlJ" +
    "tp/ryReU2Qu8x1+qgSbW/ZZXvt1IcA6TIpwIoX49sb4YSu4Uk/YVHTayQDfC" +
    "UW+0rnl2oepkAZ+U8xwrGvFqijaWrhwQU+UN+hqMihfpk3JCfRPMiz54fpLt" +
    "G7p/fI92L/C+Ja0Gmlj3W17zngbv7ue1gHLy2vcYGH5SfCqa+c9RPhuyn674" +
    "jd1Pnr117mqeDtSPsUmF/t/4/tmPyOcezfmmwDws+Ze+wWhbj4+e4fsgqfoW" +
    "9EFS9fu4y6Pb/UA4y+gbNWqgJYSjHZ4QNl1zOeM8LqPVObjR1DwdqB9jk0rT" +
    "93o1FuZhzbMe72ow8g7S2z7c74N4MWOgD5Kq38fDDmr3g6LN5YAjwqZrLsd8" +
    "IP0hz8twWBtNzdOB+jE2qdR+17OxNPPommdT1tVgJP8+H8SLGQN9kFT9Pg41" +
    "vmfUd99FDdRY91u4KZk4YXKUE9VYjI1P6MOFczBiUP4fX+EyWu5D8rXOj5qn" +
    "A/VjbFIRn+vdWOo8+uZJeVeDkfEuH4Q+KY+BPkiqvgc/71KkufzOnUL413e2" +
    "ORKUlls6qfzrO9pQXuk4vP69IfxyhV69SK7v+Kg/T8pz8Hx69ZfaDvlt7n//" +
    "vPZJmKOVJ/HyFh9dz/6RnBgvBsYg1M+x8eQef7Vbuy/03dRVAzX8sqI4ZSAv" +
    "0aFySycVb5FUOhHIglmlw2ownBPrkIPns6/+r1tAY7FytPIkfXk3fVoNRmov" +
    "39xmTA/GINTPsfHkHvfCz732fZhODdTwebnilIG8RIfKLZ1UvEVS6URyyXe5" +
    "jJb7YIPhfFiHHDyfXfVfVGOxcrTyJF15Wz6tBiNzk1dljNsHYxDq59h4cg82" +
    "F4G9w20udDA1l9lfo1U7mg2G82EdcvB8WvVfZGOxcrTyJFbefT6tBiNj1OuD" +
    "MQj1c2w8ucf+h7f7QpHmIk4ZyEt0qNzSScVbJJVOAmd/mUto+Y+6wXAurEMO" +
    "nk/Wf9GNxcrRypMwbyU3sBpMyv0XxiDUz7Hx5B7PM74h3fV7RmpAsD72/7SX" +
    "h/CK4/t5OXlbG0+f8ijEbxPIGcOCNvTZ1H31CSH85GdcQst/SIORz2Fw7q06" +
    "9My7s1ak53y85oRhv2gpzzc215Hk2sCTx+gouUOtx2cBSd2PX6t7VU/S4aMT" +
    "yQt4Pl1gr2IasDd0vWOkBgS+UyQwgEVq4tSnPAoUm3LGsKANfVJffnJiFQ+v" +
    "wXjzNmtFOs5HqcZirqP5eKw8RkfJHZq6bDAyb5k/Y/T5MJG8gOfTBfYqpsEN" +
    "79PuDV2PX1ADAn9GRJwxgEVq4tSnPAoUm3LGsKANfVJfkN/2Wa9DYue+Nd7X" +
    "YGLmrWpFjPNRsrGY66ghi5HH6Ci5A/XZYOQZvIzh+VBIXsDz6QJ7FdPg7x/c" +
    "7g/yNSH2kM7mwrehb76rDmCRmjj1KY8CxaacMSxoQ5/UrxmyYXKPaqMdP3up" +
    "XbrBxMxb1YrAR+nGYq6jRHmMjpI7UF9gg/ngqYgT4aOF5AWYN326OPO2iP0l" +
    "RjVQDcLwbvuG8NLjIngLoJxA/yXHpaN8AuqbSOwGzIvUesd9aG2j/qq9gMY8" +
    "PnJGO0d5onxufLE77oNGLXrqUgGdrtoIr3rnsN/erufLc8qYnpw5V3kDJWcM" +
    "z6eMAdH7wte2zkdq/roTtV4XzNFkHqcTR58xLehjd+MHEtlDopuLOGMAEySu" +
    "5AT66oRFoHwC6puwmA5N3U+dvXXxjHk0G0szx1EbDOZaAZ2u2pRqLNVcJU4T" +
    "xPTkzLnKGyg5Y3g+ZQzUus0Gc/HlWq8L5mjSiGPi6DOmBX3sc1i7PwxqLo89" +
    "TAcwQeJKTqCvTlgEyiegvgmL6UD9cxuLZ4yDjYU5jtZgjLlSx6pNycZSzVXi" +
    "NEFMT86cq7yBkjOG51PGQFO/2WDkDxJ1LZijCeIoHH3GtKAPGWOPsN4xUo3F" +
    "ai7yq2sMYILElZxAX52wCJRPQH0TFtOB+sKQzdR3VBstIsdRGowxT+owj6GN" +
    "RZ6Lwpg8p4zpyZlzlTdQcsbwfMoYoE39Ryj28og5mhhxWjj6jGlBHzLGHhHV" +
    "XKzPuLzoTbPH3CmO7UfsBiN+GjCGyslB+Y/U6dMX5GbYj68MRY8Pn9adE+ML" +
    "8rT3IQ1GnvTOOB6swZDG8uHTw2zdOOecORDqW9DGg7WmPyUXO4kDzvlqqA75" +
    "4T3qEzeHCEr4UByre0RUc7E+49KZFAsMOLEscHIYQ+XkoPxH6vTp18jmzN3c" +
    "PJqNxcqJsSudYxffYOrYVWP5fuUm66gbS7VunHPOHAj1LWjjwVrTn5KLncQx" +
    "qBvMJz6vbVr2gPIYSvhQrM3hpg+YmotC+Y/U6dNvcuInwuCj2mhv6s+J8kpn" +
    "XqNFNhiJW7KxVOvGOefMgVDfgjYerDX9KbnYSZwOpMFIreWtetptsQeUx1DC" +
    "h+JY3VysD9JNzSVSp0+fyA+d5x6y0ap5vqk/J8ornUadFtVgSjeWat0455w5" +
    "EOpb0MaDtaY/JRc7idPDOV/pvzxyc4ighA/Fsbq5WM91cZvL9XcM4ZBjZo+4" +
    "85Abv008+XpwqMyFyHgDZZPB2ReE5ONDp2o/KTBvedr7LzIbjNjJk98Zo4nc" +
    "3Lv8+7SMP2Lny3l5xNhTh3j6njwG2VeyTj72udm/c3zShgzVr8B+Eb2/vH+B" +
    "5vKXu4SpuWSS0mBiN1ofKu9jxmswi2os1rw8YuypQzx9Tx5D1VDmDUZ+1iPH" +
    "J23IUP2KUs2FH/2fmouWp/DNy7it9CEfC6ddDirv+fxKN5hFNhZrXh4x9tQh" +
    "nr4nj6FuLsKqNZdtHz01FwULNXZz8TaiNJahMWpU3o05lmow3ny8I7WxWPPy" +
    "iLGnDvH0PXkMzeayapdFbC7W4y795rL28ue5R4dwcAZilwLtY/B8ePJYnT48" +
    "e7kJ9u3vcZuF8IFPdduUgHnJrykMaTByk9eaR+zRnG8f3jw8htpbPkrgxfDk" +
    "FrTxyLGnjXDnvdt9QmAvcZuLOOkK4MEkPWgfg+fDk8fq9BFjL3fqmxuTG436" +
    "JbDyGtJg/ud/OBJ/cL59ePPwGGpv+SiBF8OTW9DGI8eeNkJWc7kJbtRMzcUn" +
    "xl7G6wZjbTTql6ArxpAGk3NY8+3Dm4fHUHvLRwm8GJ7cgjYeOfa0EbKaCw2m" +
    "5uITY08dQv0S9MVYVINJbSzM05qHx1B7y0cJvBie3II2Hjn2tBEe8S8Fmssd" +
    "HxXCQa8O4TkZiF0f1LegjeIoQHkGzOE5R7VR+o48Rmeo3ILzoPyoE8ZtMO/7" +
    "pJGD5N6A8hg4DyVHDOpbsL70mUXiOaN91DwcHeXTgfoWovfQg6bmkgVz8BaJ" +
    "J4/RGSq34Dws+VgNRhqLmYPk3oDyGKx5tOSIQX0L1pc+s0g8Z7SPmoejo3w6" +
    "UN9C9LKaizwPc2ouwFkknjxGZ6jcgvPokpduMHVjMXOQ3BtQHkPXPLbIEYP6" +
    "FqwvfWaReM5oHzUPR0f5dKC+hehJX0huLny36B8fGh+UMHFCfQvaKJzi5sAc" +
    "vEXiyWN0hsotOI8+eakG02wsjFHlILk3oDyGvnlUcsSgvgXrS59ZJJ4z2kfN" +
    "w9FRPh2obyF6RZrLTe4XH5QwcUJ9C9oonOLmwBy8ReLJY3SGyi04D08uH7Qb" +
    "8nbzJ8/yY/B8UR5DagzqW7C+9JlF4jmjfdQ8HB3l04H6FqJXpLnceOcQnvWq" +
    "2fMayLPIq9p4+p7c9EkMP70+4c/Kk1CfPpV+BJ4N50m5iTcv+mzwvKNDuOwK" +
    "tou04+e/DOFV73DmBSgfA8as4qbWin5pb8GYgPpKTnvErKBfyFUMyhnHsFGs" +
    "6W3zyHafkI+wsJdMzSXGB23gU+lH4NlwnpSbePOizzklGkt9sMEwR+ZE+Rgw" +
    "ZhU3tVb0S3sLxgTUV3LaI2YF/UKuYlDOOIaN4kjdXKK+WySGU3OBD9rAp9KP" +
    "wLPhPCk38eZFn68q21jqo9lgmCNzonwMGLOKm1or+qW9BWMC6is57RGzgn4h" +
    "VzEoZxzDRnHkrC8Mbi6/v31HEkdGTMzR9+SmT2L46fUJf1aehPr0qfQj8Gw4" +
    "T8pNvHnB5xiNpT7qBsMcmRPlY8CYVdzEWtGnsrdgTEB9Jac9YlbQL+QqBuWM" +
    "Y9gojizUXISnvnz2Q/Qur2gjdn0ofQvaeMAn5fQX5ROoHIHKwdBhDpQre+gz" +
    "JzOvHpt/fnUIl36XLaHsIQ1GftVP5dWcpzEPoubh1IZQP+p80IcD9XPwcqTc" +
    "RPz04egzp4pGDvU5u9FOU3NRcvqL8glUjkDlYOgwB8qVPfSZk5lXh80iGkt9" +
    "eA2Gc7BQ83BqQ6gfdT7ow4H6OXg5Um4ifvpw9JlTRSOH+pyxuezzgqm5KH9R" +
    "PoHKEagcDB3mQLmyhz5zMvMybBbZWOqjr8FwDhZqHk5tCPWjzgd9OFA/By9H" +
    "yk3ETx+OPnOqaORQn7M/uVe7R0jfYC9RzcX63aJq4jEgcZUkUPoWtPGAT8rp" +
    "L8onUDkClYOhwxwoV/bQZ05mXrAZ2ljkR+GlUeQcXQ2Gc7DgPLzaEOpHnQ/6" +
    "cKB+Dl6OlJuInz4cfeZU0cihPmfsEVHNpRqE4T89L4QDXqp50hFtlBxQfoDY" +
    "NKHc8EGor2AMC9hwXm5M+FP2MXgxgLI/wsij4e/AtZN/yYDG8o6PzuLKr+0N" +
    "aTDyK3+tnI25EVWbnnnG1M6CtfR8Uq7sLR/I2/Xp2Uf4oJzE6FNHYI/Ibi67" +
    "Pl0HrIKimEoOKPcKZfkg1FcwhgVsOC83Jvwp+xi8GEDZH2HkMfdVqrHUcy3Z" +
    "YDgvC1WbjnnG1s6CtfR8Uq7sLR/I2/Xp2Uf4oJzE6FPncS/UzUV+KuUs9hEO" +
    "VIMwlGe6MGAVFMVUckC5VyjLB6G+gjEsYMN5uTHhT9nH4MUAyv4II4+XFm4s" +
    "jbmWajCcl4WqjTHPlNpZsJaeT8qVveUDebs+PfsIH5STGH3q7PZ03VzOsvoI" +
    "B6pBGN7m4TpgFRTFVHJAuVcoywehvoIxLGDDebkx4U/Zx+DFAMr+CJ1H8caC" +
    "uZZoMMq/gaoN5qnkGbCWnk/Klb3lA3m7Pj37CB+Ukxh96sQ8hU5QAwK/AnDD" +
    "+4Sw34s1T0iE9oT6lg3lTzi8DfVjUD7BUP0YG+LZU07kZt23vsMtHX8cf4r2" +
    "aeUhL4eHNBix92KQofo5NpQT6ls2njwH+iSevie34GNZkpqLvGfdNLzOdjqA" +
    "lZgH7Qn1LRvKp+aiGauxdOVRusEwBvFyItTPsaGcUN+y8eQ50Cfx9D25hbzY" +
    "aPYH6wN0nc3F+qwLA1iJedCeUN+yoXxqLm3GbCx9eZRsMIxBvJwI9XNsKCfU" +
    "t2w8eQ70STx9T25x3Xu2e4P1I/SdzcX6rMuDnqWDMDEP2hPqWzaUT81lK2M3" +
    "Fi+PUg2GMYiXE6F+jg3lhPqWjSfPgT6Jp+/JLdgbrLehO5tLJYCDe+0Xwr6H" +
    "9fNYh1T9GJtUuYVn48n3fUEb6ps2IFWfMZ9yRAgXX84tG3+89WSdgwXzoPyw" +
    "N4Zw1S/oPe4Qu8OO0T69mJ7cwrMZKrd0FDiHlCf7M6APD9pXNHLc3XinSF6M" +
    "sH8kNZd/eIgRFDBRkqofY5Mqt/BsPDkXCfVNG5CqX7qxWDlYMA9LPrTBvOCN" +
    "2qcXs09u4dkMlVs6ihVsLjs/qd0XBPYOt7nwx9Fu8UAjKGCiJFU/xiZVbuHZ" +
    "eHIuEuqbNiBVv3RjsXKwYB5d8pINJjZml9zCsxkqt3QUK9hc5EXG4ObCt6Nv" +
    "cB8jKGCiJFU/xiZVbuHZeHIuEuqbNiBVv3RjsXKwYB598lINJiWmJbfwbIbK" +
    "LR3FCjaXW+ze7gvW4y3d5mK9Y7T389s8+hAgYw32PqSfVP3KBqiciKNvzmMg" +
    "zLmCcSGnD28e+78khIsu55aMP477oM4hB+bFvJ//+mENRuy92lGucoog1UeU" +
    "vow38Gw8uQljiJ8G1Kc8JmZT//o7tntC19vQvc1F7tyzuTz8n51EnImSVP3K" +
    "BqjiEEffnMdAmHMF40JOH33zeGKBxtKZZyJe3qJTvMEwD9RW5RRBqo8ofRlv" +
    "4Nl4chPGED8NqE95TMym/jXv0O4JXe8U9TaXSojmcrd9nUSciZJU/coGqOIQ" +
    "R9+cx0CYcwXjQk4fXfOQxjLkUqhuLJ15JuLlXesVbTDMA7VVOUWQ6iNKf16D" +
    "LbVwbDy5CWOInwbUpzwmZq37oAPb/UCwvrCY1VxutaeTiDNRkqpf2QBVHOLo" +
    "m/MYCHOuYFzI6cOaR8nG0plnIl7eTd1iDYZ5oLYqpwhSfUTpN+pQ1cKx8eQm" +
    "jCF+GlCf8piYte5tH9HuBwJ7RnRz4XcI/ujuTiLOREmqfmUDVHGIo2/OYyDM" +
    "uYJxIacPzqN0Y+nMMxH6ZN7UP6REg2EeBc5nqo8ofdbCsfHkJowhfhpQn/KY" +
    "mLXuX9yv3Q/+4K4Dmot1U/fBzw5hr4PnPLfNIw/uR+lHQJstsbtyIMyDcvo3" +
    "UPrIQckjYF598se/MISLvh2yjzd9QPu0YnJeFvSh5m7YtOzXdA4+eliDOfi1" +
    "mAdgThacO+elfCbKzdp4GH7deSGmshkob8bl/Zauj/1HNZdKAc3lDv/UCIzi" +
    "MFGi9COgDSdOOe2Zg5LTv4HSRw5KHgHz6pKXaiwxMTkvC/pQczdsWvZzvZIN" +
    "pitGH5w756V8JsrN2ngYft15IaayGSiv4+785HYfEPrut2Q1l5vt2giM4jBR" +
    "ovQjoA0nTjntmYOS07+B0kcOSh4B87LkJRtLTEzOy4I+1NwNm5Z9Q7dUg+mL" +
    "0QXnznkpn4lyszYehl93XoipbAbK67jyTCf2AvYKogYIP0x37W0bgVEcJkqU" +
    "fgS04cQppz1zUHL6N1D6yEHJI2BelJduLDExOS8L+lBzN2xa9tCXBjG0wXgx" +
    "LDh3zkv5TJSbtfEw/LrzQkxlM1Bex+WPoHn3W6Kai3XfZZenhvCwg0J4KJCx" +
    "Jg/9536UvgXtIH+Y+Gmg5BnQB0nVr3Dm3mSfQ0P45oDGcsz7w6wehu8UmLOV" +
    "N+VE6QMZO+jVwxrMc16j4/bl0JVHH65PGQOpMQbbWxh59cF51nO95jbtHuDd" +
    "b4lqLpUSmss2e80CepNnkkTpW9AOclUcyjOgD5KqX+HMvaZqLJdxC8UfWxpL" +
    "T4xYmLOVN+VE6YN6fMwGwxz68ujC9SljIDXGYHsLI68+OE/hPk9s73/h6PeO" +
    "1Fz+7wNmiXuTZ5JE6VvQDnJVHMozoA+Sql/hzF0o2lg6YqTAnK28KSdKHzRl" +
    "YzUY5uDlYeH6lDGQGmOwvYWRVx+cp/CPCV9WbPUNDlio+y53mSXuTZ5JEqVv" +
    "QTvIVXEoz4A+SKp+hTP3wY3lfUHVgjFSYc5W3pQTpQ8oH6PBMEZMHsT1KWMg" +
    "NcZgewsjrz44T+FPd2jv/74vKzZRAxbW94x2elIIex7Yzx6AckJ9y8aT7/ls" +
    "QLmB55PyPZ7dhvoWykeDRz0vhG8MaCyve6+OZ8Wk3IW1NObqxqA9of6Bs18t" +
    "+FlmgxG7A//Vj0E4D+8cU5/yioi59vkk1LdsKCfevFTOz9Z73/pdaAs10AUD" +
    "3OrBRmKcCKCcUN+y8eQsjJIbeD4pd0+QgfIxZ6zGYsWk3IW1NObqxqA9of6c" +
    "og3G8E84D+8cU5/yisi5dvkk1LdsKCfevJjznfZu73sh5n5L1TM40IW89dQM" +
    "8Id3NRLjRADlhPqWjSdncZTcwPNJuXuCDJSPA8dtLFZMyl1YS2OubgzaE+o3" +
    "KNZgDN+E8/DOMfUpr0iYq+WTUN+yoZx482LON92lve8F9oYu1EAX/LkRQR55" +
    "p5JrTgRQTqhv2XhyFkfJDTyflLsnyIA+xm4sVkzKXVhLY65uDNoT6oMiDcbw" +
    "SzgP7xxTn/KKxLnSJ6G+ZUM58ebVzHe3Z4RwDbwFLd83ZG/oQg30webyV7uF" +
    "sPszupHkmlCeA30S6hPq59ikyol8MOnrl3IrxB+vfbf2mYOXN+WWTiox/qjz" +
    "9FeuNYqfswpxh9iJPX0yZhM5P899nW3XZU95rE6fPqG+ZUM5kQds99HU/ceH" +
    "tfe74H3kv9UvONAHn6t7rTvryfVNlPIc6JNQn1A/xyZV3mRZGovg5U25pZNK" +
    "jD/qCKUbTB3rGWvjJ34ihC98jVbt47s/COGjnw3hNWv1f8TBcTnH6PTpE+pb" +
    "NpQTNhPS1JVH27K5sCf0oQb6sD6tu+1j9AS7Jkp5DvRJqE+on2OTKq9ZpsYi" +
    "eHlTbumkEuOPOjWlGow0B2ko0jByj9O/EMLzXtefc+y8uvQJ9S0bygmbCan1" +
    "7m18cC7mU7lN1IAHA97kfnqCXROlPAf6JNQn1M+xSZULy9ZYBC9vyi2dVGL8" +
    "UafJkAbz2fNDeO8n8u2tQ17xSJNhntbcKCfUJ9S3bCgnbCak1vvbPdr7XOj6" +
    "faIu1IAHHyAlN3zu/9QZ8p2jFO7/lDaULwyJ3Qf06/l2QX35ANSQxvLqd+la" +
    "MaYVlyh9zJNyE+RBH4xZBMR46svTG8RlV+R/OC/mOOWMEB5ykFGvBpyXJ8+i" +
    "0Pn4/e3b+zzmi4pEDXhYH6j7+4fkFUctVENnIfCEEOhzUZCmbonGIjmwVozJ" +
    "uBZKH/Ok3AR50AdjFsGIkdJgrvghR8Y5Lrx09gEzVbM5nJcnz8KoVSrbP1bv" +
    "8dgPzjVRAzEwsPzcQE5x1EI1dBYCTwiBPhcFqfVKNRaBtWLMmPorfcyTchPk" +
    "QR+MWYSOGDEN5ic/48i4h+TzlJcbdeOcIuRZdNQqhZs9oL2/BfaAGNRADHJj" +
    "h8HvuZ9O0kMtVENnIfCEEOhzURDRKdlYBNaKMWMWp9LHPCk3QR70wZhF6InR" +
    "12AW3Viax1En6NpxXp48i55axfK7d27v7djvEhE1EIPc2GFz+evdZ983anJf" +
    "sNMBDrDPgj4L4M4DOciHmS68hMst/jjyHWtxJG4DxmBOVl7KRyqIaaFyoHxo" +
    "DrC3fBzwEt1gFnUp1Hd8+LTQroeRexJWfQvXn/dUhWceucDmIvDrANLt1MQ4" +
    "cWMyXvGSoc8CuPNoxC/RWKqYgPNkTlZeykcqiGmhcqB8aA6w7/LRbDBy8zbn" +
    "EHtpCCes/fE84WNbGXI+Ww3GyDsJq76F63+jndr7WuDej0UNxGJ9HUC6Xu/E" +
    "jcl4xUuGPgvgzmMeu1RjqWICzpM5WXkpH6kgpoXKgfKhOcC+z4c0mDO+GJK/" +
    "LnDqOTPblj/MQ86tNJqUQ5rVAS9t+DFyTsKqL1DyA+JqJ9zNuJHb93OtHmog" +
    "BSbyx/dwJm5MyCteMvRZAHceTyrbWKqYgPNkTlZeykcqiGmhcqB8aA6w93zI" +
    "q47YQ87Xc14dZrnSF+YhTYKXXn2HaixWjFSs+gIlPyC+dje6b3s/C7HfgLZQ" +
    "AynwIVLCNo/smbgxIa94ydBnAbx5DG4s79Q+1aLAPJmTlZfykQpiWqgcKB+a" +
    "A+z7fOzxrPgGIK9W5LxtyZX+GnMo0lisGKnQn9QXKPkBcbWzXrXk3sitUQOp" +
    "MCH5VcZ7P2HGDuDe+4O5XlEYIwb6ADvs36ZpK5+K/Nq3uLzij1ccP68NYwIl" +
    "R05VXobeIJ+GjaeT6lOdCwP66JK/86Osrn186j/aOfbxhBeHcGVCYxFdsanm" +
    "7mHMrTVP5KLsLR+OvMvnDY3vEQ151SKogVSsVy+3fbhdDC4KTrQIjBEDfQB1" +
    "guaUaixVbRgTKDlyshYOSfZp2Hg6qT7VuTCgjy755d9nhfUh52u3p7dz7GJI" +
    "Y6nm7mHMrTVP5KPsLR+O3PIp3w/kHh76qkVQAzkwsfrVCyfKRcGJFoExYqAP" +
    "oE7Q/mUbS1UbxgRKjpyshUOSfRo2nk6qT3UuDOjDku93OCtsH8860s6TDG0s" +
    "1dw9jLm15omclL3lw5FbPuX7gdzDKY9W6EIN5ND16oUT5aLgRIvAGDHQB+AJ" +
    "GtpYXvl2ozaM6cmRk7VwSLJPw8bTSfWpzoUBfVjymEsiuRzqyrNJicZSzd3D" +
    "mFtrnjH+aOfI6fPujwvhN2/f3rs53yOyUAM5WB+qu8GOs7exWjwunbs/vo2S" +
    "A8oVzMnwqWjoyicYvzqgsbzsbYZ/g+R5GTasnYeqi4EbI1HOOVjzoNzi7AtY" +
    "aX3s+8KtedC+5nEvTG8sYsOcFwXz9+SEv6Qo5H5ojqiBXPggKUEe7pu0iQ24" +
    "OJUcUK5o5hOb11xvUY1FSJ6XYcPaeai6GLgxEuWcgzUPyi28Q5pAa66Gj9zG" +
    "YtZlQXAOnrzJ9vuM96pFUAO5yJ1lNhf16sWYoAcXp5IDyhXNfGLzevxiG4uQ" +
    "PC/DhrXzUHUxcGMkyjkHax6UW3jHSae286D9kMZi1mVBcB6evMmYr1oENTAE" +
    "99WLMUEPLk4lB5Qr6lyaUAcsurEIyfMybFg7D1UXAzdGopxzsOZBOZHz4x1v" +
    "/0g7j6b90MZi1mVBsBaevGbsVy2CGhiC9erluveYTSSX7RyoXxr5INJXLuby" +
    "ij9e+hbtU+A8CPUJ9WNsxmBoDrSP8UH9p7yMVdfH2z6s/QjyS5dXXkXt7kN0" +
    "H3Oo9sOcYubhUcJfl48/Nz6NW/JVi6AGhmK9ernlA/WkY2FxCPVL84FPcXnF" +
    "H12NReA8CPUJ9WNsxmBoDrSP8UF9aRDeYTWX3MZi5cicLJ1USvizfMin6LlH" +
    "Be7loaiBoVivXn77jiHceW898RhYHEL90uS+culrLALnQahPqB9jMwZDc6B9" +
    "jA9L3zvYXIY0FitH5mTppFLCn+VDftCQe7T0qxZBDZRArkGZvLwM48RjYHEI" +
    "9ccgtcF4jUXgPAj1CfVjbMZgaA60j/Fh6XuHnL/afmhjsXJkTpZOKiX80Ydc" +
    "RXBvlvg0roUaKAUnINzmYWuvYB7VYO/VYcf91xboRVx2+jj82NCeY8dc7/So" +
    "NpQTuTHehHKLVJtU/RhS51nZAMotvv09ngl9yDnc+/npjUVsvPOZBX0C1oG1" +
    "jK1njVwOXR03cYXUp/rHogZKIS+zOAl5onjxE7RAvAbT2ViMuaYuEi40yi1S" +
    "bVL1Y0idZ2UDKLd4/yd5NvTx1pMzG4vEcM5nFvQJWAfWMraeNdaPnMlVBvdu" +
    "KdRASaybu/ITsEVP0ILpajC9jcWYa+oi4UKj3CLVJlU/htR5VjaAcovD38wz" +
    "MuxoNRbBOZ9Z0CdgHVjL2HoK8gsd3IsC92xJ1EBJrK8F/NYd116e7TUvoFGE" +
    "VYANxm0sxlxTFwkXGuUWqTap+jGkzrOyAZRbyDkpdajGIjjnMwv6BKwDaxlb" +
    "T4G/QySMcRO3iRoojXVz98/uHcLtHzm7Bmyxl+b2gDbipwntqZ8DYwgyrwsu" +
    "CuGFbwo6pkWEz9Y8HKifZbNXG+qrORi4PhbIxz4XBh8/vWr265j0zXm7ckOH" +
    "9ac8B7f+e9nfeh7rJm4TNTAGnJjwN3vYhSBe8dQJow/GyIAxiIppkerTgfpZ" +
    "No26WrVVczBwfSyQ/Q8Pg466sZi13At4ckOH9ac8B6/+8nSCq99O7z/u0TFQ" +
    "A2Ng3dy9zna6EOrkoHBW8dQJow/GyIAxiIppkerTgfpZNo26WrVVczBwfSyY" +
    "M88PWUezsZi13At4ckOH9ac8B6/+17+33nupPyifixoYC+vmrky8VQyeHBTO" +
    "Kp46YfQB/RwYg6iYFqk+HaifZdOoq1VbNQcD18eCyXn1wsZi1nIv4MkNHdaf" +
    "8hz66m/9cmLp7w/1oQbGhBMVbr7r7PMvgvw0CbnNw8FcdwuQK/sY6AMoOWIQ" +
    "5T8iBqG+8mdBG6Bi0D4HxqEcZOXAGA7v+bi0jLhDGsvDDtI+FANzivLhyFk7" +
    "c53M+bs97cuhsW/iNlEDY2L91pEU4B8eMismN2m1UVk47wTQPgb6AEqOGET5" +
    "j4hBqK/8WdAGqBi0z4FxKAdZOTCGw133CeHL32Qb0ceWxhITY2BOUT4cOWtn" +
    "rpM5/ElWQdYm9+SYqIGxkQly0r+37ayY3KTVRmXhvBNA+xjoAyg5YhDlPyIG" +
    "ob7yZ0EboGLQPgfGoRxk5cAYHms293/yrHl0Ha3GEhNjaE4xPhw5a2eukzX+" +
    "dAe9xxZ5OVSjBhYBfwpWkIJwk1YblcXzTgDtY6APoOSIQZT/iBiE+sqfBW2A" +
    "ikH7HBiHcpCVA2N4zO2keViHaiwxMYbmFOPDkbN21jr5S+PepjDWR/z7UAOL" +
    "QJ4szskLN9s16I3KAnongPYx0AdQcsQgyn9EDEJ95c+CNkDFoH0OjEM5yMqB" +
    "MTwati84JqKxxMRI1bfwfDhy1o7rZBnuszRRA4tC3g5jEaQwf7tHCH//4AYP" +
    "AU2ZRap+jI0nj8Hz4ckLcCtAeRTMk1A/B/hUeTOmw7s/vrWxPPg5HT494PNW" +
    "gHKL5JiJ/M6d9J6SP3bce4tCDSwS6+3pa2+LovEkGUUdpB9j48lj8Hx48gIU" +
    "WdzMk1A/B/hUeTNmBNJg6sZi+vSAv2VrLte7p95L63GfpYkaWDQsiCCF2lI4" +
    "niSjsC1S9WNsPHkMng9PXoAii5t5EurnAJ8qb8bMQPn0oD2g3CI5ZiTWg7aF" +
    "9bjP0kQNLJqu+y83vf+8eDxJRnFbpOrH2HjyGDwfnrwARRY38yTUzwE+Vd6M" +
    "mYHy6UF7QLlFcswIbrH7ct1naaIG1gPr/stv3G7WYP7mQWW5pQF1SKq+fG9K" +
    "QR0Px/6We2ioo3B8EvqPikEfgPIcxvC5CJg3ob6HNBZ5hCz3znreZ2miBtYL" +
    "6/6LNBgpIIs6BJ7QmJOaqq82ccam9Oy56aM2vuOT0H9UDPoAlOcwhs9FwLwJ" +
    "9fvoaizrfZ+liRpYT6zPv0gBSzYYntCYk5qqrzZxxqb07Lnpoza+45PQf1QM" +
    "+gCU5zCGz0XAvAn1+5Av/nKvCOt9n6WJGlhPrF8OKN1geEJjTmqqvtrEGZvS" +
    "s+emj9r4jk9C/1Ex6ANQnsMYPhcB8ybU78J6er8g+4d7aj1RA+tNV4ORrwjI" +
    "IzJddgWUG9wcUO6h7JmDkQdtCPXHYLPENHHOz1Kyq/1EOUG+t8e9tN6ogWWg" +
    "6x0kKawqOMlYNEMXvLJnDkYetCHUH4PNEtPEOT/LyJ/cS++JZW0sghpYFqxv" +
    "UEc1mIxFM3TBK3vmYORBG0L9MdgsMU2c87Ns/InxZURhUQ9+ykENLBNdDUYK" +
    "zeJvIWPRDF3wyp45GHnQhlB/DDZLTBPn/CwT199R7wFhWd5y7kINLBvWA76F" +
    "P77H7BugN90lDbEh1JHP17QYKrd0PDx7yi0doOZNaEM57IvULgbHh8qJ0N7y" +
    "sUs/yp4wZlfcHtQ81sZueN8QfuO2ev0ve2MR1MAyIoVkcesGwxPkwRNYZIN4" +
    "ckvHw7On3NIBat6ENpTDvkjtYnB8qJwI7S0fu/Sj7AljdsXtgfPoaizL9FmW" +
    "PtTAstLVYK57T32S+uAJLLJBPLml4+HZU27pADVvQhvKYV+kdjE4PlROhPaW" +
    "j136UfaEMbvi9tCcg/zhXOXGIqiBZcb6kJ0gHyjiieqCC7HIBvHklo6HZ0+5" +
    "pQPUvAltKId9kdrF4PhQORHaWz526UfZE8bsittDnb80Fq7xVWssghpYdroa" +
    "zLXvEsKNdzLYGVBu4djcaOc2nn6UDXD1jRhKh1CfUD8G+gBqHoaOgjEI9UmM" +
    "PnVIqr7BjXZqo3wadH1AbtUai6AGVoGuSyR5KPGf3xcnjCe9KevCsVEbhtBf" +
    "jA1w9Y0YSodQn1A/BvoAah6GjoIxCPVJjD51SKq+QWpzkT+QXNOr2lgENbAq" +
    "dDWYa26DBsOTXo/34dioDUPoL8YGuPpGDKVDqE+oHwN9ADUPQ0fBGIT6JEaf" +
    "OiRV3yCluXQ1lkX87OpYqIFVoutt6laD4UmXMQ/HRm0YQn8xNsDVN2IoHUJ9" +
    "Qv0Y6AOoeRg6CsYg1Ccx+tQhqfoGMc1F1qn17WZhFd5u7kMNrBpdH7T737ed" +
    "PdHuBjsW4D7AkcuHnoiyGQpzsvIi1HfyptzEi0E5YMwitUrMwcTz4cl39Ocl" +
    "vzh6jW302t0IjUVQA6tIX4ORO+88qcl4CwlyLiprYQ2GOVl5Eeo7eVNu4sWg" +
    "HDBmkVol5mDi+fDkO/bPS/7wdTWWZf2uUCpqYFXp+rKjIN+o5olPwltIkHNR" +
    "cWEVgTlZeRHqO3lTbuLFoBwwZpFaJeZg4vnw5Dt2z0tu0MofPq7TjdRYBDWw" +
    "ynQ9rkH4rTuE6mUoF0AU3kKCnIuqyIYhzMnKi1DfyZtyEy8G5YAxi9QqMQcT" +
    "z4cn31HPS9bfte6s12bNMjz3tiRqYNWRBtP1WZjsyyRvIUGuFhX1S8CcrLwI" +
    "9Z28KTfxYlAOGLNIrRJzMPF8ePId23OST5J3XQYJy/agpxKogY2C9Uzemmvd" +
    "ZfbN6i6uB+Q5Gr3QB+U5rIdPT27h2FwPUL4ZuM523ZdB8odwmR5NWRI1sJGw" +
    "flWg5pp3mC92bo4dpubSKbdwbDZzc5GbttavINZshHeE+lADG42+G73y1+QP" +
    "7xbUBpmaS4fcwrHZrM3lj+4ewm/eXq+5mo12f8VCDWxUUi6TpubSIbdwbDZj" +
    "c9msl0FEDWxk+i6T5GabPEJT/uJsGu7mQH3LhvLNylot/nD72afDubZqNvpl" +
    "EFEDGx25TOp6N0mQa+T/s1k2DRsFob5lQ/km5XfuuPZq5TZ6PdVshssgogY2" +
    "C11ffBTklx7lg3dcQBsONgpCfcuG8k2GXAJdvefeyqp+o7kEamAz0fW1gRq5" +
    "VJLna3BBbRjYKAj1LRvKNwny6va3Or5wWCNfrOWa20yogc1I381eQRbRdbaf" +
    "3ZPJZjtAeQkYw4P2S4rUvsl6z0O+xdx3CSSvVjbih+JSUQObFbkm5iJpIs8z" +
    "lYdRcaFFs4gNwRgetF9SlqW5XHvtUvnqt9Nro8lG+m7QUNTAZqfrGTE1cqn0" +
    "ezkLehEbgjE8aL+krHdzkZjeJdBmeycoBjUwEa4mn0PwLpXkE75JTWYRG4Ix" +
    "PGi/pKxXc5HzK+fZuwR60bFTY7FQAxNb8S6VBPkU5m/fafZBvC3cuQBNf5ZP" +
    "ymNI9UH9GMbwQajvQXsHufzt+3RtzXQJ1I8amNB4l0qCXItvaTJc3Dlw0Xvy" +
    "GFJ9UD+GMXwQ6nvQvoPYprLKz7VdJGpgwkbu/nuXSluazB2NBZ4KF78njyHV" +
    "B/VjGMMHob4H7YH8UYhpKnIJtBk/DJeLGpjoJ6XJyAOq1EKPhZvAk8eQ6oP6" +
    "MYzhg1Dfg/ZzpKl47/5MTSUfNTARR2yTkZuB8lfxmnecveOQi9g3kcblYvjp" +
    "hfY5pPqkvmVDuQftgZwP66dSiZzf6fMq+aiBiTTknaWYezKCfK3gN7cxNkME" +
    "U3NJgPZrXOP2ca9ShKmplEENTOQT22T+121mC/0aCRtnai4JzO3kG8pSZ6k3" +
    "z4HF1FTKogYmhhPbZAS5bJIvvnmXTVNziUNqI5c9Xc9TsZDztVmesbJI1MBE" +
    "OeRzEH2PdyDyF1buBchfW2k4LWSsCeWWzlDo38KzoZxQP8aG3H52yZnSUITp" +
    "cyrjogYmyiN/FfseVGUhjUY2i2wac8NxQ1o6Q6F/C8+GckL9GJvbzZqw1Cf2" +
    "kqdGXqVMlz6LQQ1MjIt8VLzvWTJdbGk2Xa9sIjdlEvRv4dlQTqjfYZPbTAS5" +
    "lzJ9RH/xqIGJxSGfnYh5O9tCvbLp2JSD4Ka38GwoJ9Sf29SXOTnNRJDL0emy" +
    "Z31RAxPrQ+r9GQu5OSwbsvUKZwjc9BaeDeWgbiI1uc2kRi4/p5uzy4EamFh/" +
    "5CV8yjtOmxmp0/Tp2eVEDUwsH7J5pmYzQ+5XST2mVyfLjxqYWH5kc+XcFF5F" +
    "pmayuqiBidVDLqPqVze5N4jXG7nfVF/iTJc5GwM1MLFxkL/2slHlZvGyXFZJ" +
    "HnLTdXo1svFRAxObh7r5EGkATXgJJq+OqEMfU/OYUAMTExMTJVADExMTEyVQ" +
    "AxMTExMlUAMTExMTJfj/GDqKJuyJe48AAAAASUVORK5CYII=")

EDIT_WORLD_DISABLED = ("data:image/png;base64," +
    "iVBORw0KGgoAAAANSUhEUgAAARcAAAEXCAYAAACH0wDUAABLUUlEQVR4Xu2d" +
    "ebsT1fK23+//DX7nOCuDCoqIiszzoIIoggiiAg4goAyCIh7zprp3dta6n+qu" +
    "7qQz7d19XfcfrKFWVa1aD0nvpPP/PhsM/l9PT09P10hDT09PTxdIQ09PT08X" +
    "SENPT09PF0hDz+bj2LFjgw8++CBj27Ztg//7v/8LeeWVV2Tu/v37B1yjZ/Mh" +
    "DT0bCzvoduApCovknXfe6QVoEyANPatJm1cby8roVRBj61lNpKFn+bH/9e0g" +
    "8nBuVHrBWU2koWf5mKWY7Ny5c7Bnz56MM2fPFpw9c2adH2/dKrg15Mzw34Q2" +
    "DK7VBZaH/i3VaiANPYvHbrB29RZnJB4mAJ9//nkhDn/++efgf//7n/Lvvxn/" +
    "DtuIzCGw8b9/re1/g1s/3hpcunxpKFpnCnHY+c5O8XUSerFZXqShZzHYTU4e" +
    "nKbYATMBOXr0aCEiN2/eHNy5c2fwzz//dM/znOf/5HB81P/b778Pbgz9PT30" +
    "27A4pnmVZqLM3PYsBmnomR/2Py4PRxPs8O3bt29w/vz5we/Dw8kDO1M6Fhf2" +
    "j8ZYXJcuXSoEc9JXcf29msUiDT2zxd7ytP2fORWTO3duDw/fczmkc2NO4kJS" +
    "sWmbP8Pyzr3omS3S0DMb2v7va28PcjEhegDnwoLEhXNuD9/2WX5MdNuITf+2" +
    "aX5IQ093tPnwmh2QI0eODq5evTb4++/nQ/6u57ny/PnzWsQGeA5ov1iDYwRb" +
    "J8HWTeB8+tjET9o0frl9e3D69OlWQmP3ubhnPd0hDT3T0+ZViv3P+9VXXw3+" +
    "+OMJDqZzqLIDpvCQErEBePBpf5nFJeXq1atDoT4iua7CBIl72DM90tAzOU1F" +
    "xf48fO7cucFvv/1WfSh5oIh38J2D2ubQ8uDT/qqIy2jcH3/8UQj3nvebfeam" +
    "F5lukYae9jR5Kb5t69biZfvtX35pdiilnwdM4SElYgPw4NP+qonLOK7nhZBb" +
    "/rdtjf8D6EWmG6ShpzlNRMVentvLdB4qHgA5lNLPA6bwkBKxAcRHbw2OERAH" +
    "Dj7n08cmftKmgPEmLim3f7nd+G1T/1emyZGGnphmonJ4cP/+vcGzZ38V/CU8" +
    "yxiNqx6f86yYkyNj/gJYQ+b/lfPMg+tyjWA8feSaJdY+JvKb/cytrFms+9fg" +
    "3r17g1OnTjW6CdyLTHukoacaFpzHkcO5qFSLRX4A4vE5esD0EMnBxxoyH4dc" +
    "hMIRC1kjGE8fueY8xWXEo0ePepGZAdLQo0Q3aq0orTjvD/8n9A+xU9w4APH4" +
    "HD1geojk4GMNmY9DLkLhiIWsEYynj1xzEeJSMBz36PHjRiLT35NphjT0jIk+" +
    "pzISlcfD//nqD7FT3DgA8fgcPWB6iOTgYw2Zj0MuQuGIhawRjKePXHOR4jLC" +
    "ROazz84Ntm7dKnue0n9Oph5p6ClhIVFUTp48OXj48GHxDeOejcBfoGz/8ssv" +
    "Q5Fh7fSUSMNmJ3oL1IvKRsUXlxGfffZZ7dul/q2SIg2blegbyu+///7g7t27" +
    "UnQ9G4V6cTHsP5XDhw9LbaT038QeIw2bkeh/pCtXrkih9Ww0YnEZ8d133/Vv" +
    "lRogDZuJ6AFNJ06eGPz+4PfB06dPwZOMJ8O2kCc5tPH0CXma8aRYZ4zMt3as" +
    "EWNzUtDPGIo4OIcEayAOD8n3E+SCNrkm7WF+SZ5viTOwYeueOHGi9q3SZv8G" +
    "tjRsFuqKYvfu3cVjGSuLvWhLDrUUpgMOAG2w2KWYWewOXCMmPaDOfMZQxME5" +
    "JFgDcXhIvp/owa5dk/YwvyTPt8QZ2BitbU/827t3r9RQCmtvsyANmwFu/ggT" +
    "nC+++EILi8VetCWHWgrTAQeANljsUszik8I1YsoDUn1IHWQOCdZAHB6S7yf+" +
    "wa5ck/YwvyTPt8QZ2KAP16/Xv1XajM/5lYaNTN3bIHuJa0878w6AFHvRlhxq" +
    "KUwHHADaYLFLMYtPCteIyQ+I9DOGIg7OIcEaiMND8v2k/mDLmrSH+SV5viXO" +
    "wEaVDydOnJTaGrHZ3iZJw0al6m2QtV++fLn4ev4sefzH44w/HpM/cmxMhtrs" +
    "HPFhehj346It4HHOQnIBGAf70728eePGYOuWLVJrI1ibGxVp2Ihwc0fs2LFj" +
    "cPv2bS2UGSDF2YtLNSsuLsZv9+/X3ovZDG+TpGEjEb0NkgKZIVKcvbhUswHE" +
    "pWDY/sknn0jtjdjob5OkYaOw6LdBRIqThSgHewEHSnyYHsYtQuKxgcTFsN+R" +
    "qrvZy9rdKEjDRoCbN+Ltt98e/PLLL8VX7HMe5zwG7Af2xcWUR4+Vx8W4asQn" +
    "zh/6kWNtJB9Dm+GaHC9rWj7gG+dN2++NAYy77X6VcF30c80kb27u6IPlKxl/" +
    "f/g26aOPPpKaHLERH+UgDauMbRA3bcTx48e1ICoLC7Af9OKSMG2/NwYw7rb7" +
    "VcJ10c81k7y5uaMPli/OGdo5e/as1OZGFRhpWFWqhOXll18ufkxLiqG2sAD7" +
    "QS8uCdP2e2MA4267XyVcF/1cM8mbmzv6YPninDVbN27cGGyp+GvSRnqMgzSs" +
    "IlVfOqx+G0RYWID9oBeXhGn7vTGAcbfdrxKui36umeTNzR19sHxxTmLP3iZZ" +
    "fbJmN5LASMOqUfUXIdu4e3fvFt9kzXjgwDEPH4C8/8EDYG0JDx88UII1HgD2" +
    "x/ZixM8Q9YM2Qr9pc5I42s5pMF7j4B4GODYV5oI8HBw8eFBq19gIf0mShlWi" +
    "Slg++vDDUli8wmKRuIWiRZDSi0tK4DdtThJH2zkNxmsc3MMAx6bCXJByXJXA" +
    "rPozYqRhVaj6U/PBAwfqC4tF4haKXwQjenFJCfymzUniaDunwXiNg3sY4NhU" +
    "mAsyHmt/cGAtr7rASMMqUCksw/8BwsJikbiFUl0ERi8uKYHftDlJHG3nNBiv" +
    "cXAPAxybCnNB8vHnz5+Xmh7BM7AKSMOyUyUstjHFJkWFxSJxC6W+CHpxSQn8" +
    "ps1J4mg7p8F4jYN7GODYVJgLwvEbS2CkYZmpEhb73WX7RnMjHjhwzKbhAWD/" +
    "7HkwXJdwTMgG20970p19hIJ1vmoCIw3LiicstgEXL16UzamFhbgBinFyenFZ" +
    "VjaCwEjDMuI9kd8SbxvATQlhIW6QYpyMXlyWGatv77Mwq3KTVxqWDe/PzRML" +
    "i8FC3EDF2J5eXJadqlcwqyAw0rBMeMJi2G/I3P/ttwJ7bkYtNibh/m/3lfu/" +
    "Zfz2m80bw34B9ji/gH4JFkuCzEe/zLe1y5yMoV/Ihc2pgfbLNQDnsZ8gd7Tf" +
    "iCKWaqI8GFEuZE3AOGjfgzboA/d45P/169ddgVn2D9pJw7JQ9V2hVFh6ccmJ" +
    "DpXkwubUQPvlGoDz2E+QO9pvRBFLNVEejCgXsiZgHLTvQRv0gXucxmACw7Ng" +
    "LPNXBaRhGagSltOnTmcJ78Ulh7lRv5ALm1MD7ZdrAM5jP0HuaL8RRSzVRHkw" +
    "olzImoBx0L4HbdAH7jHjsP9YeSaWWWCkYRlg8gz7cqKXcNkwwiJyNp2FIsXK" +
    "QiIsIg/6JaC4ZD6Lj/NtbeaHfiEXNqcG2i/XAJzHfoLc0X4jiliqifJgRLmQ" +
    "NQHjoH0P2qAP3GPGYbFVCcwyPq5BGhYNkzYSlnv37nXDXQeOIRh/916OjJ+A" +
    "Wdhsyzx8uGv5S2B/Qdv9WQbo8wz9PnLkiJyRZRQYaVgkTJaxa9cuSe5UsACa" +
    "FAHGz+IQzsJmW+bhQy8u3VD1mBGeqUUiDYvC+5DcW2+9VTyPhYmdChZAkyLA" +
    "+FkcwlnYbMs8fOjFpTuWXWCkYRF4f3KeibAYLIAmRYDxsziEs7DZlnn40ItL" +
    "t9g54dlZlj9RS8MiYHLsb/pXr14d/Prrrw53M+4O21J+vQtkvnL37t0c2sSa" +
    "wt2cu4VfOeIX5hD1gcR+RHMYN/t1vkI/jfvDoje8/eBY2vP9tD0awzhpswlc" +
    "Q33IYa4Ix/twTcAaaTD/p59/HrzxxhsiMMvwu0jSMG+YFMN+60UT6ydYiibc" +
    "IIWFIjadTc2QYlfEL8wh6gOJ/YjmMG7263yFfo6wnzi1n9dg3BxHe76fv2Yw" +
    "TtpsAtdQH3KYK8LxPlwTsEaazB+uffXaNTlDBs/avJGGeeLdZ9m3b5+T1OoE" +
    "S9GEG6SwUMQmN5QkhV4WuyJ+YQ5RH0jsRzSHcbNf5yv0M+XPp08Hz549G9y7" +
    "f289bo6hPd/PXzMYJ202gWuoD4gTuSIc78M1AWukyfy1HJw86f9GNc/cPJGG" +
    "eVF1n+Wnn35yklqdYCmacIMUForY5IaStQ0eF7sifmEOUR9I7Ec0h3GzX+cr" +
    "9JM8/fPp4H//+1/xUOpeXLgmYI00mZ/kYc8HH8iZWuT9F2mYF0yC3Wf55ptv" +
    "Bnfu3Mm5nXMbcHzU74I1pD/gNmC/P+Y24PjbGXdu59Cety5t6Ph6HyQvRW7y" +
    "OfZb2ymen0+Gr2Ds+vPPPwe/3vm11l5p806+h0T8xLpiU+dILsRGMF76mWu1" +
    "QSROjkHc9IF+/Pjjj0t1/0Ua5gGDN86ePavJ9RIcbEjU74I1pD+gbsOrx9Qf" +
    "AClU59CSyIaOr/dB8lLkJp/TRFyMkcDYqxj75nOVvdLmnXwPifiJdcWmzpFc" +
    "iI1gvPQz12qDSJwcg7jpg+eH/QfNs2XwDM4DaZg13n2Wjz/+uHozmOBgQ6J+" +
    "F6wh/QHRhvtj6g+AFGrFoa1blzZ0fL0PkpciN/mcpuJijAQmexUjPpidO/ke" +
    "EvET64pNnSO5EBvBeOlnrtUGkTg5BnHTB9ePoe8nTpyQM7YIgZGGWfKB857w" +
    "zTffHNz68Vb1ZjDBwYZE/S5YQ/oDog33x9QfACnUmkNbtS5t6Ph6HyQvRW7y" +
    "OW3ExXj6ZCwwxauYB787Nu/ke0jET6wbxQWfilyIjWC89DPXaoNInByDuOmD" +
    "68faPuzZs0fO2rzvv0jDLGGwdp/lyjdXBr/c/qXkl5jbv9zOYP8iuH07h/2T" +
    "cBuwfzIsXylt+7vB/kydXvZvO4xt6mDxdJGrehtSA6P8pNDmWvvNWzfd+y88" +
    "k7NEGmaF93bozNkz9Yly6MVlGuqLOe7vDgrM33//Pbh7727jOlg8XeSq3obU" +
    "AIXFy1XSZ/9x88zNU2CkYRZ4z2d5//3340Q59OIyDfXFHPd3CwWmeJv08IGM" +
    "W066yFW9DakBnhev1tB/6NAhOXt2e4JndBZIwyxgcPZ2yJ6sxURIohx6cZmG" +
    "+mKO+7uHAmOXtXHc8tFFruptSA3wvHi15vQv6u2RNHSN92E5U9OqRET04jIN" +
    "9cUc98+A277A2Nsk++CYjF8aushVvQ2pAZ4Xr9acfvv5HZ7BeTzgWxq6hkHZ" +
    "X4d+/umngp9+zvn5559D7ItaObBjdhNGa43X5PyfdcxPP2f8XPg2hmvIeA+J" +
    "I/c78oE+S7+3BvsDJC7mtoifa+Rz1CZ90FiNJ3/8QX0p3ibZE9gYu6zB/iYE" +
    "NoQwTuTOiZE+SG5QZwLtOX5UrWG3IXgWeVa7Rhq6xLuJ++UXX6wnJipcD9l0" +
    "2Ig2WOfbpmBMsOlcQ8Z7SBy535EP9Fn6vTXYHyBxMbdF/Fwjn6M26YPGOsIT" +
    "GLsePX6M/cIayA19dAlsCGGcyJ0TH32Q3KDOBNpz/Kha49q1b91fEOCZ7RJp" +
    "6ArvJu7evXuzxESF6yGbDhvRBut82xSMCTada8h4D4kj9zvygT5Lv7cG+wMk" +
    "Lua2iJ9r5HPUJn3QWFOqBObZ8G2Sfa6j3C+sgdzQR5fAhhDGidw5sdEHyQ3q" +
    "TKA9x4+6NQ4ePChncpYP95aGrmAQppo3fvghS0xUuB6y6bARbbDOt03BmGDT" +
    "uUY61j4MZQ8KevzoccHTp08Hf/311zr278fD/4nti3z2p1f7glovLjl/OPdg" +
    "7LK3SfYQK1mD+9mEwIYQxoncOXHRB8kN6kygPcePaI153tyVhi7wfn716NGj" +
    "gx9/vAV+DLkF2P/jLcD+RrTzK/XH/jd9+PBR8XH2SS87NCY6jx49Kj5lyfWa" +
    "cusWWPOxMncRzO3E+U1oYM8+sf34j8dM0/plT8rnnJkDv5lrGe+wiP3gmhcu" +
    "XJCzOaubu9LQBXR++/bta4lod4i95LC/bbJ9mvtl/yPdu39/WPx/FKIwi+v5" +
    "8+eF0Nidfq5fBws+zF0EcztxfhMa2DNxiQTG8sN5MwV+M9cy3mER++Gt+dFH" +
    "H4nAzOKXA6RhWrybuJcuXVpLRPNDXJecjJbJ9qn2yw64Pa/jwYMHxauLeV/2" +
    "sKWm/1Oz4MPcRTC3E+c3oYG9kbhEAmP7YWLP+TMBfjPXMt5hEfvhrfn9998P" +
    "XnrpJTmnPMvTIg3TQocPHDiQJKL6EFfhJSejZbJ9fL9MWJblslczJnB1h4kF" +
    "H+YugrmdOL8JDeyl4mL8UXGT1y4T37qcdAb8Zq5lvMMi9qNqTbtNwbPa9asX" +
    "aZgGvmoxdfzuu+8GN2/eLLl1K+cmWRuXcgtwDvuxxq2hjRSxX+DbvPPrHdby" +
    "wi97K/bw4cPi0DF2xipYPhKYB45nLkvyNSV3AtewPRmj49O11hjOs5vgVZfl" +
    "xD4wNs5DvoYH/RLgQzSf/cUYJ45sjtlNYL/kmvacObKHNbz++usiMDzT0yAN" +
    "00BH7b1dniwmhmgCJMGcw36s0SzZvs3fH/zOOl6aq/yA2f0sdsYqJIXsFTPH" +
    "M5claa6d3Alcg4fUgWuuzY0EZpQPruFBvwT4EM1nfzGmIo71OWY3gf2Sa9pz" +
    "5sge1uA9d7fLVy/SMCneX4jsqVh5spgYogmQBHMO+7FGs2T7Nr2PpS/bZX+l" +
    "Gv2vzViFpJC9YuZ45rIE+WbuBK7BQ+rANZP5dQJjl/2HwDU86JcAH6L57C/G" +
    "1MRRzDG7CeyXXNOeM0f2MGCWr16kYVLooLxqMSQxRIOXBHMO+7FGs2SrTXvb" +
    "sUqXvVX60Yk3Y62Iq4qZ45nLEuSbuRO4Bg+pA9eEjUhgrJ/rENoU4EM0n/3F" +
    "mCCOaD8k17TnzJE9DPB+d5pne1KkYRK8Vy1fX7kyuHHjRj0/kB+UcE7OD+DG" +
    "DbORAnsONs+erL5q199/Py8+xDeOXePKcsPc2ZgE2YshYkPWsDEJYhPI/jh7" +
    "RD+GbZHA/Pn0z+KAe3EVwM/QB+L41BrJBfvzNSQGjndsRuOvf3td/nLU1ede" +
    "pGESKCwffvihG4jA5HLDvE2TOTla/C2L5kY579Gj+uJd5uvBg4cVBx+5Ye5s" +
    "TILshRU4bcga8xEXIxKYZ389KwSGPhTAz9AHUuFTKyQX7M/XkBg43rHZZLz3" +
    "m9M845MgDW2petXiBkKYXG6Yt2kyJ0eLv2XR3Cjn/fPPbD4gN6/rr+HBsj+l" +
    "M66NJC5GE4Gxtw/0g36GPpAanxojuWB/vobEwPGOzSbjZ/XqRRraQmEZvWpx" +
    "AyFMLjfM2zSZk6PF37Johvz88/J8vmWay/6C8vvvv6/HJblh7mxMguyFFTht" +
    "IHc8tGoTyP44e0Q/0B8JzF/PHIGBn6EPJPCpEZIL9udrMJfuGYv2lKyNm8Wr" +
    "F2log/c0//Pnzw036/uC77//AVhbW2gj54fhmBSZb36kODY4xz6stpEu+6g8" +
    "Y/QIc9kFsh+ToPtnMdZd9vAp+7CdjbVDZd/hSm2OanZcuzk/FLU2hv3LwqR7" +
    "eO3atc5fvUhDGygsO3bswAZpEbSHNnLCZEoxqw3OWcTH/Gd92Tey7VAx1pQw" +
    "l10g+zEJ/v5FAvPPP/8UbxUtF3bZ1zpGcze7uBj2O+080zzzbZCGpnjPa0lf" +
    "tayyuGzUK/3f2yPMZRfIfkxC9f5FAvPvv/9m/x4JTC8u3w8uX74sZ3qa571I" +
    "Q1PoBF+1rKq42OcNNvJl/3vzLcGIMJddIPsxCdX7Z0QCw8sERms3ZzOIi+Hd" +
    "6uDZb4o0NIUOHD92fHD9u+8yvrtez/XvrmfY95DIdRuXInPaomuk2AN2NsNl" +
    "N3qZW82VInOuX8+Q/Yn2HPMLuC5syHj2D+fYhwrbXPa5przOcmSNBtgvXNQS" +
    "rYE8yHwndtpkvrl/HH/hC33eC89+U6ShCZ66Xf3mqjjKwAkD50FfhLjYodss" +
    "lx3ATCgkVwr3gwdd9ifac8zvSlyMqQQmqeMmtexBIRCiNZAHme/ETpvMN/fP" +
    "G8+vBEz6M7DS0AQKi4mNFxgDJwycB70Xl9lfqcBorhTuBw+67E+055jfpbjY" +
    "2xt7G9jmWheYpI6b1LIHhUCI1kAeZL4TO20y39w/b/zH+z6WFw/UgCZIQxO4" +
    "8OnTp93AGDhh4DzoixCXumeHbNTryZOnA7t3oblSuB886LI/0Z5jflfiYsIy" +
    "+qtQ26sQmKSOm9SyB4VAiNZAHmS+EzttMt/cP2/8V5e+EnGZ5NvS0hDBT+QW" +
    "z2ypCIyBEwbOg74IcdmIf4ZuctlBtAOp+crhfvCgy/5Ee475XYjLNMJi12YX" +
    "F8P+QEOBoRZESEMEF/z4448H3377bcE1MGofcw2wf/GswmMWZnXZgTSBZU4W" +
    "T1A318bYAZtGWOyRomL/2ya1HdOFjXnhfdSEWhAhDXV4C37++efrDsXJC4pk" +
    "CdjM4mLXcgpMUDepsPw5ubDYZfdo7OMIXCOu7ZgubMyLK1euyFlv+wP20lAH" +
    "H2Npb5FSh+LkBUWyBETfU9kMlwkM87JYgrrpSFhGlwkMBTau7ZgubMyTPXv2" +
    "iMBQE+qQhjq40MGDBzNn4uQFRbIE2MvizX7ZD8AzL4ulvm66FJbRxVdwcW3H" +
    "dGFjnpw6dWo+4uJ9a/LLixcHV69dq8S+DJVy9erVABsDrl2th+Nh8xrQ8WN/" +
    "Dfvh88183bl9O8mVh5O/mvzrfuVwfwqu5aiN8Xrffnt9qh+kq7vM7vXhIavO" +
    "RX0cMoZn4moO46Q95qXMTV6/tCFgv8QHwC8ztvnMizRUQWF59913ncBymEwm" +
    "W9HgJDmE47mhQMeP/TXs5xc265UKi3c4KveoJv+6XzncH+8QqY1yrWmFxeKN" +
    "vgE/Ehj6TSQGbwzPxNXlFxf7fXeefWpDFdJQBRc4cuSIE1gOk8lkKxqcJIdw" +
    "PDcU6Pixv8aNmzdZX5viug1h8Q5H5R7V5F/3K4dreodIbXQjLKP1mggM/SYS" +
    "gzeGZ+Lq8ovLuXPn5y8uX375pRNYDpPJZCsanCSHcDw3FOj4sb8j2n6qc9Uv" +
    "ExY/Vx5O/mryr/uVwzW9Q0Qb0wqLPWeYa0YCY/30PYpDxvBMXF1+cTH41shu" +
    "kVAfPKTBg98leu211wbffHOl+OmQlCvDtpRvrnyTcaUYM4b9tNeEeM36fm/d" +
    "tt+qXeXrl19uD65Ynrz9mQVB7iPsUE4lLMN4xYe12KOvfty/d388HtDPEjsj" +
    "Yzgnqk3uh8x3183X/OYK4Piof4jdAknPf9OHSEmDB1+12M+GbGRxuX//Putq" +
    "Q16ZsHj7MwuC3NcxK2Ep66QkEpiRjfiQG/lB55yoNrkfMt9dN18zFI+of4j9" +
    "JDM1gBrhIQ0eNHzixPE153Mn2iaL/bTXhHjN+n5vXXum6ka/bt/+RQpV9mcW" +
    "BLmvYpbCUtbJmDqBsbfM9jwX5o7+luQHnXOi2uR+yHx33XzNUDyi/iHnzp2b" +
    "n7hcuvTVmvO5E22TxX7aa0K8Zn1/1brPnj1jXW2Yy4TFL3bszyxokHsya2Ex" +
    "GHskMPa9nPpDbuQHXfNdX5v0Sea76+ZrhuIR9a8xyX0XaSD2mLvU6NatWwdf" +
    "f/31GlcyrgzbUsbj1rgC2N8FE6zh+X3v3j3W1Ia47BmyjL8K5sXb06hf9mNY" +
    "wBkcXzCuqW++uTqVsBTxig9cz4+jTmDMJzt0tNMGb82c/Hy5IC6xGcRNe5w/" +
    "8mv37t2ZDjS57yINhK9a7KdDmjomgYSBdsAEa3h+2ycUN9rVRli8vHh7GvXL" +
    "frQQl06ExfWB61XHUScw9ngO2mlD1ZpjHDEhiEtsBnHTHueP/Dp8+HCmAwa1" +
    "gkgDocHjx483dkwCCQPtgAnWqPJ7msJetqutsHh58fY06pf9aCgunQmL6wPX" +
    "q4+jTmCsj7aaUrdmiSMmBHGJzSBu2uP8kV/2BWVqAbWCSAOhwYsXLzZ2TAIJ" +
    "A+2ACdao8tsKdCNckwiLlxdvT6N+2Y8G4tKpsLg+6JpRHHUCI+s1JFqT58sF" +
    "cYnNIG7a4/zUL/sISqoF0bekpSGF91u2bN06uHT58phLl4C1jbksXMrIbA25" +
    "fPmSgjlEfIBN+nTpso3JEZtJ37Nnq31j1x44bj8Z4aG5ifcjGiP7IeRr0if7" +
    "qv80D+z6yY13gjiA1W/dl1rtMQ1ig/ll7Kw7AXPgs+e32JQ4AOe7lHnkfZfo" +
    "1Ys0pNDQBx9+mAcXJGMjiMvtO7dZRytz1QmLobmJ9yMaI/sh5Gt2LSylT2SC" +
    "OMCohqsExv6CZJ+YzXOB/DJ21p2AOfDZ81tsShyA813KPB46dGh24nLy1Kk8" +
    "uCAZG0Fc7KXkKn4d4Oeff1oviio0N/F+RGNkP4R8za6FpfSJTBAHSOu4SmDM" +
    "/zwXeaxE6k7AHPjs+S02JQ7A+S5lHs+fb/c9I2moExcGFiVjI4iLYT+atUqX" +
    "+ZsWRRWam3g/ojGyH0K+ZtfCUvpEJogDsJarBMbax7nIYyVSdwLmwGfPb7Ep" +
    "cQDOdxnnkp93oWZMJC4vvvji4KuvvmrJRcD+1cCSukqvXsxX+1M641hGLLdT" +
    "CctPP4nNyWhfq1VfE+nOp+XjzTffzMTlgw+qb+pKwwiblBoxo1wopv2GLStW" +
    "MKt0rYLALI+wGJPVqicwq5D7SaEu1H2YThpG8Hm5ZpQLxUy2YcvKqj1fd5mL" +
    "fLmExZi8Vj2BKe+/XJaxqw7FxaB2hOJCA724fLWSn9pdRoFZPmExpqtVT2Cs" +
    "jeNWnZMnT3YvLmaUC8VMt2HLiD28etWuZRKY5RQWY/pa9QRmdv4uhjbfkJaG" +
    "KnE5ffrM4MsvL2Zc/PLLDHtgd4a1Jch49g/nRHx50dYZc7HwYwx9jHwq1wX0" +
    "M5lvd/FX8YN15ecwruX5Yx4Yt4PkitBGsp7lbhph+fHHH4s9lTWiumRN2BjW" +
    "FeNcq6dxXTEXXLOEAjPKu5vPdC+K/NEv5jb3qYlfXENgHOKDQm2gdrQWFzpR" +
    "JpSFZMEkIHAZz34nEMLkaLJB4FO5LjexPi77yYlVvERgmAfG7SC5IrSxtlZX" +
    "wuLWXVSXrAkbw7pinIWdtK6YC645hgJjcVv8YmO0D2vQJ81tvk4Tv7iGwDjE" +
    "B2XLli2ZNlQ9fkEaDP6MiBmjE2VCWUgWTAICl/HsdwIhTI4mGwQ+letyE4O4" +
    "hmMW+fbI1p70T+OZwDAPjNtBckVo42K3wuLWXVSXrAkbw7pinIWdtK6YC66Z" +
    "Q4GxZ/CKDduDBPqkudV1xCb84hoCxqsPyo4dOzN9sK8JUUMqxYV3hO3P0HSi" +
    "TCgLyYJJQOAynv1OIITJ0WSDwKdyXW5iENfa2tMcmEmv4qANfTCBmFpgmAfG" +
    "7SC5IrDRtbC4ddeyvxjDumKchZ20rpgLrqlQYG7cuJHbWKuj9VqGT5pbXSPy" +
    "i2sIGK8+KHv2NPuLkTQYnLhnz/uDL774QrkAon6C8RcuKDrnQkBsU7BxCbSh" +
    "lGtdvfrN4Pnz51kBzfK6detmEud069u8q99czXLLPLggd3X5txuA0/z2tn0Z" +
    "UHPvUe2DQZ8Lvy9cyBGbAUneytxdEGxc+tAxy/nlr79O6qze78VAn5T9+/d1" +
    "Jy5mTJ34QhIc9hOMZwGURcA5GmxObFOwcQm0oYzXs+/wzOOisIzoUmCYBxfk" +
    "jv6McjQ/Yan2YQR9Lvyek7gYqcA8evQoqbN6vxcDfVKOHz/WnbiYMXXiC0lw" +
    "2E8wngVQFgHnaLA5sU3BxiXQhpKvOetHYpYHjXGO6UpgmAcX5I6+WH7mKyy+" +
    "Dyn0ufB7juJipDVi34VaZXExqBHUkMbicv78OceJLyTBYT/BeBZAWQSco4Hm" +
    "xDYFG5dAG0q+ps2Z5jDVXeODxjhzuhAY5sEFuaMf8xcW9YH99Lnwe87iYowE" +
    "ZvT2KPJ7MdAnH2oENaSxuNgj7hpxAXx+AThzImiTcLzQxIcmY+rH2820v/76" +
    "C0dluuvmzZvO2tXY09unERj7djJtxozzYDcEpxGWyniHhz8D/RcA+yfhwjCe" +
    "FPY3grU69P3umsDY2yMZPwPiOLSWFR1DjaCG9OLSakw83g7npIebV+VBq8EO" +
    "1vwFpszBzITF2EDikgqMfXpX5nRMHIdfy9GY7du39+LSzIcmY5qN//777/NT" +
    "M8FVe9BqGB2u+QrMjIXF2GDiMhIYy7X9qV7mdUgcR3Ut142huHgfpBNh6cWl" +
    "akzz8dM8GjM8aDWkB2xeAjNzYTE2oLgUAnP37szfHsVx1Ndy1RiKi/dcFxEW" +
    "issbb7wxOHf+/OD8uXPK+Rz7UlPK+XM2bwz7zW5rxAbh+Bz6XGLtY2hTxiMu" +
    "zcv5iZ5eZx+yGvvRck0nn/bE9mkExubLuolPdmNvGmEp40WcDtzzeL/Qjxoo" +
    "6oD5kzXr60b7HaI1hlid2AcFC7/TPHs2aa/IB2Jbs1tVu6wRHe+sC2zctu3b" +
    "pheXbUOFMicYlJusItgxTBb7NdAGiA3C8Tn0uUSTV7dBjEvzUtppIzC5sDh+" +
    "Rms6+TQ7nQvMmj+dCEvlfuRwz+P9Qj9qoKgD5k/WrK8b7XeI1ljD6kTy7Nmk" +
    "vSIfiC2x69Uua0THO+sCGzeRuPCj/724cKzGpXkZ23r48CHPlVwqLI6f0ZpO" +
    "Pke2OhWY8x0KS+V+5HDPmSvdL/SjBoo6YP5kzfq60X6HaI2EVRMX/sxILy7F" +
    "hqnfXvLqNohxaV7GtuyzA3UH0Q6a+UkfWq/p5DO115XAdCoslfuRwz1nrnS/" +
    "0I8aKOqA+ZM16+tG+x2iNeh3mhfPJu0V+UBstClr2pgUjnfWBTaO4uI97jIW" +
    "l23bBp999lnPFNgNMPtdYV4//PCDjJ0l9qCmaQTGbvJ6cTS95h1vz+x47733" +
    "Mp0wqCWhuJgRGu5pDwVmUQdtGoH5999/2dT4WlS8PbNhInGxVyq9uMyGkcAs" +
    "+qBNIzCTXIuOt6d7JhIXTujFZWMyL4HphWVjcvjw4S7EZdfg008/GXzi8Qn5" +
    "FOT9Ziflk08/zZH5nw4+tXlTQJ8/Ha6jWPsYzgnjQL/ML8bUx0Ub0RrsL6BN" +
    "+MDxX136aqYCY59WFr+L2MfQRy9X2g9QR8wD4y7Ja0BsEqyhwEfPT0CfpB9I" +
    "Xpw6IuIT/caa0u/EZvlq8rvRvbgUWPsYzgnjQL/ML8bUx0Ub0RrsL6BN+MDx" +
    "1jYrgfGEpfC7iL0XF4M+ST+QvDh1RMQn+o01pd+JbWJxeeedd3pxIWYnQcaj" +
    "X+YXY+rjoo1oDfYX0CZ84PhRe9cCUyUshd9F7L24GPRJ+oHkxakjIj7Rb6wp" +
    "/U5slq+J7rnwr0U7d+7MCrE+eQw+75dkMgiZHycvgj6zqHpxKelKYOqEpfC7" +
    "iL0XF4M+ST+QvDh1RMQn+o01pd+JrTNxsb8esRCrk8fg835JJoOQ+XHyIugz" +
    "i6oXlzGXv7481Z+b7REC9JP04jKGPkk/kLw4dUTEJ/qNNaXfia0zcdm6devg" +
    "7NmzzTiTc+ZsDsdH/aXNM6B+DaL2lNZz2N+IM4D9YJI1Ja4zGTI+wf4CMM0H" +
    "5OyyVz72dHjaTglzXdAyV5MQ5bdlP+PyYFzaPwnIlfjFGiC0F2O+vrtrl7wI" +
    "oZb04uLYCOewvxEtN3WSNSUuFpYz52w3wjK6IoEJc13QMleTEOW3ZT/j8mBc" +
    "2j8JyJX4xRogtBdjvlJcGn23yOjFJZjD/ka03NRJ1pS4WFg6p0thGV11AhPm" +
    "uqBlriYhym/Lfsblwbi0fxKQK/GLNUBoL8Z8NV2YWlzsC0k0XokEVp+8qL+0" +
    "aQlLqV+DqD2l9Rz2N6Llpk6ypsTFwsrHz0JYRleVwIS5LmiZq0mI8tuyn3F5" +
    "MC7tnwTkSvxiDRDaizFfOxEXw36E/ozD6dOnA2xMCvrPABnvzGnJGcB+jzBO" +
    "+k0khjPOmGlx1hCq59jNwMePZyMso8sExh5crn5ERHF0QMv90JogOmdq6KMH" +
    "5wi5nzwPROcnayVr9uJyumHyZE4QJ/0mEsMZZ8y0OGsI/px5CMvomkxgojg6" +
    "oOV+aE0QnTM19NGDc4TcT54HovOTtZI1KS7Hjh3rxYX9HmGc9JtIDGecMdPi" +
    "rCHonHkKy+hqLzBRHB3Qcj+0JojOmRr66ME5Qu4nzwPR+clayZqvv/56phHU" +
    "kF5cKgjjpN9EYjjjjJkWZw0hnzOtsNizXif9oF07gamPoxNa7ofWBNE5U0Mf" +
    "PThHyP3keSA6P1krWZMaQQ1pLC5HjhwZnDx1SjhFTp7MYT84eeokcNY4CcRG" +
    "RLwGOXXKfE9AXJFN+lgCm+xvvQbtcXxuz26GP378mGe+8fXtt98W69qvLk4j" +
    "MPZkvmz/LNYA1oDkIup3kDWcfGa55figLj24PyfN1wSxGcRVQL/oe2BD6s7B" +
    "s0mNoIY0Fpd9+/aJU+6mwVHpB5Js2C+DB2IjIl6DaDKxAYFN+ljCTUJ/6zVo" +
    "j+PHtroSlhFdCgwL2YM1ILmI+h1kDSefWW45PqhLD+7PqorL8ePHuxMX+6gv" +
    "nXI3DY5KP5Bkw34ZPBAbEfEahMlkXJFN+ljCTUJ/6zVoj+NLO10Ly4iuBIaF" +
    "7MEaoC9hv4Os4eQzyy3HB3Xpwf1ZVXGxFxvUCGpIY3Gxb0rTKXfT4Kj0A0k2" +
    "7JfBA7EREa9BmEzGFdmkjyXcJPS3XoP2OH52wjKiC4FhIXuwBuhH2O8gazj5" +
    "zHLL8UFdenB/VlVcmnyvqFJc+BWALVu2DE6cOBFyErC/Z37YTbdphOXatWti" +
    "08Me3TmNwNh82pyWvg5nCx/L0kpc7G/W6cSXX35ZFvDoN3U5mJewjFg2genr" +
    "cLbYi41UH7wP0FWKi0Fl4gIe/aYunnkLy4hlEpi+DmfLa6+9lmmD9yP0rcTl" +
    "wIEDsgjpN3WxLEpYRiyLwPR1OFuoDdSO1uJiL32OD98upRw7drye4zn2J6wU" +
    "e/uVcVw5DmgztAGf6IPrhxDYsLYEna9xyJwwbvSbzYTTp04NHj1+xDPb+DJh" +
    "YZxc08sn+z///PxQKP6m+UbX87+HAnP+c7EpuZD80qcY5k9tknwN3T+FfrNu" +
    "uEbY7yBril82pjn0gfW9f9/+7sXFHncpgSHhAgMHTB4DLYPNoc3QBnyiD64f" +
    "QmDD2hJ0vsYhc8K40W821zBhefxoOmEp8wCcdaMx5uu0AnN+OJ82s1xIfulT" +
    "jNZyRL6G7p9Cv1k3XCPsd5A1xS8b0xz6wPreu3fv9OLCH0d76623NDAkXGDg" +
    "gMljoGWwObQZ2oBP9MH1QwhsWFuCztc4ZE4YN/rN5rHuhKXMA3DWjcaM/J1G" +
    "YP4ezksFRnIh+aVPMVrLEfkaun8K/WbdcI2w30HWFL9sTHPoA+vbXmRMLS7y" +
    "5+g33tDAkHCBgQMmj4GWwebQZmgDPtEH1w8hsGFtCTpf45A5YdzoP9atsJR5" +
    "AM660ZjUZxOYv/+eXmAkF5Jf+hSjtRyRr6H7p9Bv1g3XCPsdZE3xy8Y0hz6w" +
    "vu1FRqoL3uMtQ3ExqFBHjx6t50jOkaM5Ov5IxpGjiswhWFPAePpU+mXrpHBe" +
    "1M81nDgCvwTkhv0nT54YPJpCWL755hux2QSJyxmT8tm5c5MLzHCezT9itZQg" +
    "+yG55X55qK/15PO1hhogfrbs98CctvvD+YyTsb4xfJGRakLVn6Fbi4v9hKM4" +
    "V+NouAG9uFRTIy72qclFCIshcTlj8vEdCMxnucDIfkhuuV8e6ms9+XytoQaI" +
    "ny37PTCn7f5wPuNkrC+88EKmCdSMicVlz5496lyNo+EG9OJSTYW4LFJYDInL" +
    "GZOPL+lSYGQ/JLfcLw/1tZ58vtZQA8TPlv0emNN2fzifcaax7j9wINODTsVl" +
    "x44d6lyNo+EG9OJSjSMuixYWQ+JyxuTjx3QlMLIfklvul4f6Wk8+X2uoAeJn" +
    "y34PzGm7P5zPONNY33n33e7Ehd8hePXVV9W5GkfDDejFpRrkZhmExZC4nDH5" +
    "+JxzHQiM7Ifklvvlob7Wk89nXDreQfxs2e+BOW33h/MZZxrrVvwF2R7eT81o" +
    "LC4GlergwYPFvRePI4ePAGsbc3h4SDIcG8IRcNjmJaCfaxKx760htPRb5jsE" +
    "c1KfTxw/PpWwXBkKi/ktuRCfkFv6iPkeHE+sLj779LOpBMZ+8Y92szUsfylS" +
    "l35s08A8FMAPzmkL7TWzWb+n9Jn9BWv1wfstVR/7n1hcdu3apYuvO8pNhONt" +
    "D2kxBzBZ6OeaROx7awgt/Zb5DsGckb9dCYshuRCfkFv6iPkeHE9GtTFLgeEB" +
    "1Lr0Y5sG5qEAfnBOW2ivmc36PaXP7C8YrrP34+YfnptYXN58801dfN1RbiIc" +
    "b3tIizmAyUI/1yRi31tDaOm3zHcI5pivXQqLIbkQn5Bb+oj5HhxP0vqYlcDw" +
    "AGpd+rFNA/NQAD84py2018xm/Z7SZ/YXDNfhLZJOxIUfprPHL8ji645yE+F4" +
    "20NazAFMFvq5JhH73hpCS79lvkMwZ2phuXIl93kJxcUwgehaYHgAuWYvLolN" +
    "wP6C4Tpbt+Y/JRLdb2kkLgYVyx5zd+jQocHBgznWlnIw4NDBgxkHDzUBNoI1" +
    "2X/I/CS0gbjEJuZHPpbkY2gjzcOxo0enFJavh3F4a7RDY8j9bLJntCkMx3z6" +
    "6SdTCcwnQ4Ghn7nPit07TGFcMl5sYry1AdZRsScZnJP36/wGNPCrDu5fsYfD" +
    "9rb3Wwxp8KC42H2XwpEgeG4IYSIYlA9sBGuyn0VTFjhsIC6xifmRjyX5GNoY" +
    "5aAQlocPeYYaX+vC4q7RDo1h7GfTPaNNYc3XWQqMrGmxme8JjEvGi02MtzbA" +
    "OqJ4cDz7dX4DGvhVB/fP+Oijj7Lzb1AjPKTBg4a3b99eOhIEzw0hTASD8oGN" +
    "YE32s2jKAocNxCU2MT/ysSQfQxsWf6fC4q7RDo2h9LPNntGmkPg7K4GRNS02" +
    "8z2Bccl4sYnx1gZYRxQPjme/zm9AA7/q4P4Zbb6smCINHrzv8tJLL5WOBMFz" +
    "QwgTwaB8YCNYk/0smrLAYQNxiU3Mj3wsycfQRufC4qzRFo3B2tvtGW0K8HkW" +
    "AiNrWmzmewLjkvFiE+OtDbCOGCvHs1/nN6CBX3Vw/wz+umLdlxVTpKEKKpc9" +
    "18GeTlfPQcB+wvFN5qw+9qNzD6cQlsuXL4vNZrTP9UHA/pCDgP1Dzp49O5XA" +
    "2HzaJFPH0QEL8aFB/gnPvn1Dm/rgIQ1VcAH7KgCdUNoWL8c3mbPaLE5YjPa5" +
    "nvpANCzuWQvM1HF0wEJ8aJj/EU1/RsRDGqqwPz2lC9i/6YjStng5vsmc1WWx" +
    "wmK0z/XUB6JFcc9SYKaOowMW4kOL/Bt8aNxMxMVeCnGR+K1R2+Ll+CZzVpPF" +
    "C4vRPtdTH4iWxT0rgZk6jg5YiA8t8m8fOeGfoO3DdNSGKqShDoqLfVp3//59" +
    "Cfsz9oH9Q2czsrn7hmMUeyBwCm3us7YUrik+eWsQrDlsy6APhOOB3TibSlgu" +
    "XXJ81nxG/VEe6HcZO+Ywx2Ij2Ztif4L5Tv7sVw2mEZjTp8+IH7Jm4tOhw4eK" +
    "L0hm88Rv5lLrQMYwlwHiozOGcQn022LPwH4lY3e+M9lfiUZIQx18ifTSSy8h" +
    "gdwwJBuBSPIdmAza1GRiTfHJW4NgTW4ofSAcnzAzYTGQz6g/ygN9L2PHHOZY" +
    "bCR7U+xPML8if10LzGitM2fODL7//vvBvXv3OC27njx5Mrh169bg0uVLhfho" +
    "LrUOZIwTVx1N8iL5Jcy3xZ6B/UrGvrElf+rcTMXF4GK7d+9OEohkMNkIRJLv" +
    "wGTQpiYTa4pP3hoEa3JD6QPh+DVmKiwG8hn1R3mg/2XsmMMci41kb4r9CebX" +
    "5K8rgTl06HAhKCYYk163b98enDv3WZJLrQPJtxNTHc3ygvwS5jup6zpx+fCj" +
    "D0VYzAfqQR3SEMEF7dXMOIFIBpONQCT5DkwGbWoysab45K1BsCY3lD4Qjt83" +
    "B2ExkM+oP8oDYyhjxxzmWGwke1PsTzC/In8jphGYO3fuDL777vuJ53uXveIx" +
    "kZEaKGJBvp146miWF+SXMN+obdmvtXFv73hbxIVaECENEfx2pN3w+fjjjxuy" +
    "F7B/EjqwuRewvzW5TwcPHphKWC59dan4ynuKrukR5Yb9hOM9ojnsJxzvgP2Z" +
    "RGD++OOP1nPaXLdu3Sz2OY1t79D3lIliXxDeX4epBRHS0AQqmn08mM75zCK5" +
    "HdicobiUwvKAtdj4MmExn3pxSfi4ncA8ffqUTTO5bJ+PHTu6Htuqisv7778v" +
    "r1qafnAuRRqawIXt5wbooM8sktuBTad4p6P0pSth6cUFrLU3EZhnz56xaaZX" +
    "eW/nVBHbqoqLfXeQZ5wa0ARpaIK9/+Pi9v0jOqnMIrkd2Kwo3snpVlh6cQFJ" +
    "X53AzFtY0uvSpa9WVlzsr8Dp2W76XSIiDU2huLz15pvFh+pSPtr7Uc5HOXuB" +
    "jB+yF4Q2gv69H+0VPoooYklgP9Y8cGD/4MGDyYXlq4sXxaas6eRKxgQ2NDft" +
    "iWyqD4Q+e37Xc+rkSRGYeb0Vqrtu3rwZxMXcsS7z8cxtkV+eF/YHNtg/7Wdb" +
    "UqShKbzh89KLL/biMsRe1U0rLF4csqaTKxkT2NDctCeyqT4Q+uz5XY+tkwqM" +
    "3byd5LL5JgjXr1/PmGY/c4Gh78wd61LjJKwB6Q9ssH/L1i2LFxfv6wD2l6TN" +
    "LC5dCYsXh6zp5ErGBDY0N+2JbKoPhD57ftczWssExj5/wlcx0fXLL78UP91C" +
    "uykHhntrQtPmMj9Onjw1qI6LuWNd+nFm+eV5YX9gI+3zbuTW/VxrhDS0gY68" +
    "9tprm1ZcuhQWLw5Z08mVjAlsaG7aE9lUHwh99vyuJ12vjQDYfn3yySeN1vTe" +
    "etVdKizeGswd67I6zvX88rywP7CR9m3Z0t2rFkMa2sCHSBn2CMzNJi7TCstF" +
    "CIsXB9dknsr80rd6G1xzEiKb6gOhz57f9YzWslcXTQXAXq3s33+g0Zr2qqap" +
    "XbtKYbFXQlFczB3r0o8zyy/PC/sDG6N271XLpDdyR0hDW+iQ/Srjh0PRMT74" +
    "8MOMD8nauHU+9HDmZTYA+5sgfuT9dXHYpySnEZYvv/yyeOnJuD8YxpIS+VT6" +
    "BTvIjY6PbbYlWtNiTRGfHWijqv/bb79let3r559/zuKu48SJE62F5cTxExWx" +
    "g8L3aiROzvdsSD9A/kftXb9qMaShLd6rl3ffeac4pAyMG6eH2sOZl9kA7G+C" +
    "+JH3V8XRlbB4h4xFEvlU+gU7yI2Oj222JVqTxS0+O9BGVX+T7wrZfn388b4s" +
    "7iqmERY/dlD4Xo3EyfmeDekHyL+17Z7BqxZDGiaBjo1evTAwbp4eag9nXmYD" +
    "sL8J4kfe78XRpbB4h4xFEvlU+gU7yI2Oj222JVqTxS0+O9CG1398KARNrjNn" +
    "zrr5JNMKix87KHyvRuLkfM+G9APk39r4tIMuXrUY0jAJ5iSds1cvDIwbqIfa" +
    "w5mX2QDsb4L4kfczjmmF5eLFXFi8Q8YiiXwq8ws7yI2Oj222JVozituDNrz+" +
    "Jm+J7O1QVT5TuhAWP3ZQ+F6NxMn5ng3pB8j/niH//e9/s7M7yfeIPKRhUigu" +
    "9pWAPR/sydkzAWsJWIf9baG9JjaTGOwTjNMIi71i2bOnwZqzINqPqL/AfE9h" +
    "fxe0X+Pu3btMtVzHjx8PYttTjGkrLIVdx9Y8+ACwP8rl1m35Lyl29arFkIZJ" +
    "8V5avbf7vQbFGtBWCCJor4nNzoWlwZqzIBKPqL+gvli7of0a0WUiEMW2asJi" +
    "TCMu9heiWb1qMaRhGigu9iSraEND2gpBBO01sdm5sDRYcxZE4hH1F1QXa3e0" +
    "XyO6bty4URvbKgqLMY248Pefu3zVYkjDNISvXiTwBrQVggjaa2Cze2GJ15wJ" +
    "kXhE/QXziKPdGrY/0WX3ZKpiW1VhMSYVl1m/ajGkYVooLvap3fd37y4ZBpRi" +
    "j8hMWR+XsHu3jUt4f3ctnP++tYXkfqXz7YNGv//+O+ur8XXhiwtrfpndMfbn" +
    "vwzGCegjc1fkryaOknofdL4D/aCNYM1ofhMbjNsecRBd165dg53Stv3SZZtv" +
    "T9vYo8eOOj4pEiv8ltrlePZLXpzcYA7XHM3bOoPPtRBpmBbv1cvbb71VBsXk" +
    "VQSewg2T5EUbYG0hKIRk/g8//MD6anyNhKX0i0UAGCegj8xdkb+aOErqfdD5" +
    "DvSDNoI1o/lNbDBue0BTdHniMqmwuPvpILHCb6ldjme/5MXxA3O4ps3Z9e67" +
    "ckZXQlwMOv3iiy8Odr/3nibPCZxwwyR50QZYWwgKIZk/6SuXVFhKv1gEgHEC" +
    "+sjcFfmriaOk3ged70A/aCNYM5rfxIbGvZvpl4viMo2wuPvpILHCb6ldjme/" +
    "5MXxA3O4ps3hEw1mISyGNHSB97kXexkmyXMCJ9wwSV60AdYWgkKADfueRxuB" +
    "obCUfrEIAOME9JG5K/IXxBH5oPMd6AdtBGtG85vY0LhjcbH9G80/dvTYVMLi" +
    "7qeDxAq/pUY4nv2SF8cPzOGa9i6CZ7OLT+N6SENXMADjnXd2Dt57b1fCew1I" +
    "xzed0zW7ig8xNRGYC59/7sx32AXYD3YB9nfBLNaYxGb7ObsaPcPFPiBnv3TZ" +
    "VlhsTtv9mgiswTzssjYgNmqwLxXzJq7Bs9sV0tAlDMJejrUXiuUQlyYCUwjL" +
    "roY+tixWFhr7u2AWa0xis/2cXcXvEEXX1atXJxMWW6Plfk0E1mAeKCxtxcX7" +
    "cqK9y+C57Qpp6BLv5q79BGw7oVgecakTmHVh6cUlYxKb7efsGly48Dm3ZKor" +
    "Exaj5X5NBNZgHigsbcTFfqGDZ9Hgme0SaegaBmM3d3ftenfQXCiWS1xKgfkw" +
    "E5hMWHpxyZjEZvs5peh3dYmwGC33ayKwBvNAYWkjLvO6iZsiDV3j3dy17x29" +
    "++67hchkWBt4991dOcNxGcWYFIxHv6zp2FAfwFBA7MN3JjCfD4VF+j12me8J" +
    "9BNx7Rq2ZQQ+e4RxcDxz08gG48gRm0VbCvt1jK4J1tb68ccfqROtLxOWw4cP" +
    "N9iPBj7ChuYKa0TQB9qrwHsHMaubuCnSMAsYmPH22287yVOYKG6IbCjHo1/W" +
    "dGyoD2CtmMdC4YwhMqc+LhZR5LNHGAfHMzeNbDCOHLGJQ6n9OkbXBGtrnTh5" +
    "klrR6qoSFn8/GvhIO5IrrBFBH2jP4Z133p3rTdwUaZgVDO7ll192kqcwWdwQ" +
    "2VCOR7+s6dhQH8BaMffiYjCOHLGJQ6n9OkbXBMl69nvQk1x1wuLvRwMfaUdy" +
    "hTUi6APtOdi7BJ49eywrz+cskIZZ4b00s8Dz5ClMFjdENpTj0S8b5thQH0BS" +
    "zL24MI4csYlDqf06RtcEyXqTvHqJhMXfjwY+0o7kCmtE0AfaA9u3vylnruvv" +
    "D9UhDbOEgRr21yP7SRJj504Ha094ZydYm7tuIxrvEdlgf+qfwfE7dyq0EWCf" +
    "CcqBH4zBiYPYD16lsL+RPRkDP6U/R3zgeM+moHZTvvvuO+pH5WXCcujgIbEh" +
    "iI+EPsZ+Kvl81oQH54xs7dixY2Fvh0ZIwyzxfuvIEmB/JrOEyKE1mMxgk8Px" +
    "HpEN9qf+GRxPYenFZR3xgeM9m4LaTbFPqv7222/UEbnWhcXxUxAfCX2M/VTy" +
    "+awJD84Z2eJPshrWzjM5S6Rh1liADNruv1i7HFqDyQw2ORzvEdlgf+qfwfEU" +
    "ll5c1hEfON6zKahd+mhf2aj7wFwmLI6fgvhI6GMDP4V8PmvCg3PMzuuvvy5n" +
    "bJ5vh0ZIwzzw/uZuCZFDazCZwSaH4z0iG+xP/TM4nsLSi8s64gPHezYFtev5" +
    "aOLhXSIsjp+C+EjoYwM/hXw+a8KDc7x7mwbP4DyQhnnB4A27ARUfXJBtToPx" +
    "HpEN9qf+GRxPYenFZR3xgeM9m4LarfLx/LnzsbA4fgrhePrYwE8hn8+a8EjH" +
    "79jx9sLvs6RIw7ywP4cxCZYY+/yL3YxaZydI+zzajh+yE+zYYRuVAJs6vgN2" +
    "2joJ7F8WmIuhrykyPgS5LuCYdtCn0U+8mrAcOHBAxvvQJ4LxrDsPzumAtA7t" +
    "0+88UyZaPHvzQhrmifcSzu6/ZAlsu0Ftx+/wxAKFBJs6vgN6cUngmHZ4PpnA" +
    "NBcWgz4RjGfdeXBOB4xq8PXXXpOztIj7LCnSMG+YEMMejbmewLYb1Hb8Dk8s" +
    "UEiwqeM7oBeXBI5px/Q+GfSJYDzrzoNzOsDqb5vzoG2DZ23eSMMiYFIMe1VT" +
    "JLDtBrUdv8MTCxQSbOr4DujFJYFj2jG9TwZ9IhjPuvPgnA6whz8t032WFGlY" +
    "BFX3X7Zv2z54a5i8nLdz3s6xZOdY2xiOL6BNIfeBNt9++60Mse9AG9IPmzre" +
    "1snhGCJrIFcSt+c3EB9APF+JxzDuIA4PrpnkqYA+BDUg9j0bAvZQ1iBY8823" +
    "lu4+S4o0LArv/osJjH2CtxcXXVMK0xlDZA3kSuL2/AbiA4jnK/EYxh3E4cE1" +
    "kzwV0IegBsS+Z0PAHsoaJFmvQlgWfZ8lRRoWiff5F0tgLjDYRCmS6g3xDlgB" +
    "bQrc9NxmdKA8aEP6YVPHozCdMUTWQK4kbs9vID6AeL4Sj2HcQRweXDPJUwF9" +
    "CGpA7Hs2BOyhrEHG69kfPnhWDJ6pRSINi4bJUoHBJkqRVG+Id8AKaFPgpuc2" +
    "owPlQRvSD5s6HoXpjCGyBnIlcXt+A/EBxPOVeAzjDuLw4JpJngroQ1ADYt+z" +
    "IWAPZQ1SrvXqK6/KGVk2YTGkYRlg0gxTahOYWbAdsD9i2vld2WjLZlnTZTtg" +
    "/zIy9POVl/XVvWHf2+M5WjTSsCwweYa9bZKEd8C0BT/t/K5stGWzrOmyguLy" +
    "+mv6naFlFRZDGpYF7xvUsxKYaQt+2vld2WjLZlnTZcXExfsyojGvBz9NgjQs" +
    "E1UCY4lm8qdh2oKfdn5XNtqyWdZ0WSFx8Z4mZyzLn5yrkIZlw3vAt2Gf4t22" +
    "bftg+/ZtGfYn7ZTtgP2dYOumsH+brb09I56zPWd7Du2VNkn9GpobrCk+KVH+" +
    "IxhDifrWZg/FHnwsCG0y/9syaE/nT4Kuab819J///Efqf9mFxZCGZcQSyeSO" +
    "BCba5LiIOgCFJ/3bbG0KQTSHhZZDe6VNUr+G5gZrik9KlP8IxlCivrXZQ7EH" +
    "HwtCm8z/tgza0/mTkK9ZJSzL9FmWOqRhWWkqMNywuIg6AIUn/dtsbQpBNIfF" +
    "nUN7pU1Sv4bmBmuKT8q0h4wxlKhvbfZQ7MHHVRAXq+tVFhZDGpYZ70N2hv2Z" +
    "umqT4yLqABSe9G+ztSkE0RwWdw7tlTZJ/RqaG6wpPinTHjLGUKK+tdlDsQcf" +
    "l11cTFhY46smLIY0LDuVAvPSy4OtW7YO2ZKxZevWjHIM2LqlFtrYUrSN2Wp2" +
    "U2h/izeH5Da4ZjTeh3MAcqXzm5Db3GKxpmxtkH8iaxDGwv72iJ8dwFw0yXdV" +
    "fa+asBjSsApUvUV66cWXZAOlaFjIRTGzWHNoQ4UCRUL7Vlwyh+Q2uGY03odz" +
    "QINij8lt8kBJHE5uBFmDMBb2t0f87ADmIsp31Uf6V1FYDGlYFaoE5oUXXsg2" +
    "UIqGhVwUM4s1hzZUKFBYtG/FJXNIboNrRuN9OAcExd6M3CYPlMTh5EaQNQhj" +
    "YX97xM8OYC7q8l0lLPZ2ibW/KkjDKlH1Z+pUYKRoWMhFMbNYcWBgQ4UChUX7" +
    "Vlwyh+Q2uGY03odzQE2xNye3yQMlcTi5EWQNwljY3x7xswOYi6p8e99uNlbh" +
    "z811SMOqUfVBO7vTbh+Xtg8gRWwB7H/jjS0A/VsA+2cAffb9BvSTcLzEvSWc" +
    "s2VLDvu7gX6xvz1T55L9BfV+2jr2HyFrdyMIiyENq0idwNidd24qiQurvkia" +
    "FVq30Gffb0A/CcdL3FvCOb24pFT7aXVZJSzL+l2htkjDKsNNGmHvZ3Xjx8SF" +
    "VV0kBY0KrVvos+83oJ+E4yXuLeGcXlxSfD/tBq33GZaNJCyGNKw63KwR9r+E" +
    "bn5JXFh+kazTqNC6hT77fgP6SThe4t4SzunFJUX99H5mdQRredWRho1A1WcF" +
    "qt4mxYWlRZLRqNC6hT77fgP6SThe4t4SzunFJWXs42uvvV75NmgjCoshDRsF" +
    "+xMeN3CE/e/x2uuvrfM6eO3118F4rD+ecP7rxe/KpFix1WHf/M6wthTPD7Fj" +
    "bWM4Xm0Ga3pgDtcUmKvM31Hs9BXrIJc6njh+wg/apN9R3NKfxGFvy6veBq3q" +
    "Z1iaIA0bCe9XBUbY/yLVYmHFl4JClPGE863YWLx6qPIDFhSv54fYwQHhHLEZ" +
    "rOmBOVxTYK4yf0ex01esg1zqeOL4CT9ok35HcUv/WhxVf2Y2NsJfhOqQho0I" +
    "N3WE/W/yyquvSDFSGKQQZTzhfCs2Fq8eqvyABcXr+SF2cEA4R2wGa3pgDtcU" +
    "mKvM31Hs9BXrIJc6njh+wg/apN9R3Ox/9dVX3d8TGsEa3YhIw0YlepuUFiOF" +
    "QQoRsF/n64HggSJR8dKHwg+xgwPCOWIzWNMDc7imwFxl/o5ip69YB7nU8cTx" +
    "E37QJv2O4k77NuvbICING5nobZJtvP2Ps5yYbyns71kor7xa1E/dTduN/jaI" +
    "SMNmoOqvSYa9R5bCWQp6cVlmrG6qXq0YrMHNgDRsFqq++GjYe2V7acsCWiy9" +
    "uCwjVid191Y209sgIg2biaqvDYxYrrdKvbgsG3V/CTLsi7Wsuc2ENGxG6m72" +
    "jkTG/oca8QoZClDKy6+8rCTzfV4Beb+sIeN1TtTPONj/chFLziuvmC9jJM5o" +
    "fOBD4Qdt0i/aCNZ4WfJgvuVriA2JfTw2egu0mV+tpEjDZoZFkmLFZEVVFDNZ" +
    "O/C9uOgcGR/4sMzi8tLLL9W+BTI20neDpkUaNjtVz4gZYcXFwyAHH4Xb5ICs" +
    "F32VEHANGa9zon7GwX49YI5YCMH4wIdlFZcXXqz+K5Cx2f4S1ARp6Clp8lap" +
    "FxcbQ4LxgQ/LJi62z/1boMmQhp4cFhOxVzL2dsk+iLeO/Ru8+OJLGfa83zpe" +
    "fCmH9rL1KrFxKewPcPySMQEad5M4pvS7A6K3P0b/FqgeaehRordKIjI8QL24" +
    "rIy4NBGVVX6u7TyRhp5qordK6yIzfCnNQ6SHrJ5eXKbwuyX2n0ITUenfArVD" +
    "GnpiJhEZPWT19OIyhd8N6UVltkhDT3OaiIzdDCzfMr2QYTcKM6wthf0d8OIL" +
    "L2a88CKwtozYhgloCsdHcH4jG8gVc6v28rj++9/6m7Qj+rc/0yENPe1pck/G" +
    "+O9//zMs7lJoogMj/R1AYdhM4mKC0uRVitGLSjdIQ8/kNBWZ0auZugMjB6oD" +
    "KAybQVwsz01epRi9qHSLNPRMT1ORMdaFpheX5jYCcXmhhaAYm/07QLNCGnq6" +
    "wz4HYTcDWcxVFEKzxn/sgKT8J8cEicgYIP20wfH0ocB8G8M5tGkx1QJ7hU0S" +
    "rTGihaAY/edUZos09MyGugdVeYwP3+jgBMLgjQHSTxscnx7cdSAEXEd8cgSl" +
    "I3EZ2WDu6uhfpcwPaeiZPXXPkqlifCArhKE4bBAPIP20wfGFmBAIAdcRnxxB" +
    "mVBcJhETo7+XshikoWe+NPlztsfooG1kcZlUTAx7O9q/7Vks0tCzGNren/HI" +
    "D64jFoBCIONFWGYkLmhjXG3Yv39/LyhLgjT0LAdt/uK0menvoSwv0tCznPRi" +
    "U9I/N2V1kIae1WCSm8KrSC8mq4s09Kwu9upm0hvEi8buN/VvcTYW0tCz8bCb" +
    "xcvytsr86G+6bg6koafHBCCFb8Hs1RHH0EZPjzT09PT0dIE09PT09HSBNPT0" +
    "9PR0gTT09PT0dMH/B8oeOZTT9IgAAAAAAElFTkSuQmCC")

# Original file: ResetControl.py

class ResetControl(PGLControl):

    def __init__(self):
        PGLControl.__init__(self)
        self.set_name("Reset")
        self.set_active_icon(RESET_ACTIVE)
        self.set_disabled_icon(RESET_DISABLED)
        self.set_rollover_icon(RESET_ROLLOVER)
        self.set_pressed_icon(RESET_PRESSED)
        self.set_state(PGLControl.ACTIVE)

RESET_ACTIVE = ("data:image/png;base64," +
    "iVBORw0KGgoAAAANSUhEUgAAARcAAAEXCAYAAACH0wDUAAAn7UlEQVR42u2d" +
    "+38VxfnH+z99VbRq6x1vLdaqVcHWKyqtWrWo1VZF66WKWrwCgYSQhADBJFwD" +
    "BAgEIvdLgECAhATCJdxB8Nbv9/Wa73myHDk7Z3bnsrOzM7PPvF6fX87ZnZmd" +
    "efa9zzw7O/OLTYT8AoVCoXQLGwGFQiFcUCgUwgWFQiFcsBHyqM/WE1LUO+2E" +
    "jFkY1oh6Qv5nEl/XTys/9+XWS3kXhW2OcEF5BhC40eGGFwGFKY1qvAQg7CeE" +
    "C8pyiMh4G7aq6AWht4NwQWUkeOrDjegySGRUBA72PcIF5RBMfjebkJHNYf19" +
    "VaBXV17S9F2Bqndf+n9IKwMVzx1VorS8G2gPtAuEC0pBEGDVNcQpwgNA8PY3" +
    "BTgUANF2lJD1Jxk6FdaGk+Wij6Hz2HCKrekFKH1cuLhXC/UYXfBE7p6NsEG4" +
    "oIwIgpyqN9i1VQWANBHyXGvgRQBAGnoIWXciXmt5OsmQyjkxWnCAkGm7wh4Q" +
    "XI9qWwCU0Z4QLjjcaVWHyROFp/9bHcHNWbyx152k5ABcosqA6xq/sQDMpYQM" +
    "r1OP1aCdIVxyNeSRjZ+UwmT2vugb2ye40Hn+DJtWNc8G2h3tD+Hi5ati2RgK" +
    "DA8gRjI0vBG5qT2HC/0/QBZgC9CVgQ30A755Qrg4L5nJa3CDPFsYAnyxlZCO" +
    "4+VaQ6lDg7h5nmBIMs806s3SzL2EvNImBxqIc6GdIlyckoyX8vgCQj7cQMiy" +
    "wwlBkHO4lAoADaCWeeOE3gzCxQuowOvhcQWXfl6/RhAgXMoEwAZwP9iEkEG4" +
    "OBpPEQnQDq8N3HZw31MBAcIlVgByaH/oB4QMwsULqDxTcM8/32oABAgXqfiM" +
    "6LAJ3zIhXOyDyhJCmvoIaT+WjlYzVHbMIKVj8eKeL5AHfTz3Wgb54taT839U" +
    "uU37CXlphVgQGCGDcEkVKiJPurShgnDRB5eilgwUINOGkEG4WBioBaOEJyA8" +
    "CdsH0wcLwkUvXIp9tuSQGGTAc8X7AuGS6jwVMMKX24InH22oCBf34FIUQObN" +
    "NfzgL86TQbhoHwIBVMYWPJWWg4SsPKpJg5ISyUO2zKMZSPVaY7RqMCylelz8" +
    "/f11hNzCgQy+WUK4aBkCaYcKwsVquBT1xpr44RIOlRAuyl8oP1BwgRt7M77J" +
    "EC6ZwQV+aykMf/+yBL/ERrhoerUMT6sJmy25yRAumcKlqIodOFRCuCRcoOlv" +
    "y4NP/VcciddyBa2QlMj5yy2QjuvQ3d468mSdA/YRN1TK+8JVub3wOG/l/sZg" +
    "WUbVGwbhkg+4gOb0EPLo/PiHFMIF3wQNPYXeXZf8hkG45AcuRU3aHj9UyuM6" +
    "vzgMooZAOm4YhEv+4FI6VMJhUs7gEjUMAm8FVqVvPRytZZRaeTrEkMgxccen" +
    "oRTqwG0rkTKoY2TbX+j4hGXE5Tetq+DF1OAwKdfDoBGzguUStRgrwgXhUqJ5" +
    "fYQ8Mj/fw6TcDoNeXK7ZWBEuCBfGtf2jPb/DpFwOgz7ZlIKxIlwQLhHXBvsy" +
    "xQV7ES4OKaoTfzszWCgIPkwLaYAS73+OFh8qF/e8QylIsp5KdZJtuxSuU7qt" +
    "4dopJbYBTtvMLQyTHp6Xr6UcvNsTKKrzXlim8QZBuCBcJOFSPOa1VfkBjPdg" +
    "uaaSkI82ar5BEC4IF0W4gKq6CLm5xv9lHLz+6DByGIRwQbhkCBcQDJPAPn0G" +
    "jLdvhKDjGvcHyyMk1aIBSgeTq6wMyf9F8kxaho62aElB0m07YEe9WXqqxd83" +
    "SV6C5U/zArDoMhKEC8IlC8C4vkaMd6+aoaN0GwnCBeGStp5f5h9gvAYLwgXh" +
    "4gpcQG93+DUXxhuwvNWRnpEgXBAuCBjP4RIFlnFrCFnYHwi+bE6sfko6jk8j" +
    "T945vDxk/xc4ZuGBsHh1XnhA/pzEbanLThK2VZQqtgdTKFwHjNNggQ74YP0l" +
    "sCBcEC4+wMUXwDi7Ij80PHRAKVgQLggXX+AyBJgdhPxmprtBXidfNxfBsqAf" +
    "4YJw8RcucA4AhuXBuAAYJ+exwB4yc/sDwboZsernC2ZLlor7v0IZ3Hry8hQ4" +
    "p9gmP7eN7HWrlMGpN328Spmy7c3rT11tEdcuLEn38cXfJ0UMkWyfaOfct0Kl" +
    "YEG4IFzyAJciYFz7VMApsMC+zNwOQ7ggXDyECwj2r3YJMM4sSzl6oaBxI1wQ" +
    "Lp7CJQ4wNi7X4MRCT08UwNK0P1CzpJooiRyThkyUmbQtZPNr1tAfWq6zL6ws" +
    "+s+kXT2z1A3AWA+We+ckM3iEC8LFN7iA4IFr+xwYqyfJ3VlPSP1ehAvCBeHi" +
    "ImCsfeXMAgvCBeGCcAnrznp7X1FbGcCFd/qfbyNkTi8hX/dQ6jWgHo56M5BA" +
    "HeZQUql3+xFCNh8npPsMIQPnCTn2XVg//R+JTKd/LD8e8gFBvi0H7GkrK/pU" +
    "g13W7SHkpho790WyMs4Ce70kuUEQLvy2g5u9eOPzoKE7AYQAXFA2gEw7dHIE" +
    "F/j9i212Do+si7M8vjD50xfhUt527YcvgcTGdOG/hOw/pwk2OYMLaOwK+wBj" +
    "XZyldg/CRQdc4AbdcdJemIjCZt0gwkUELqBRzXbFX6yJs1xdSchnWwhp2Bev" +
    "2ZQaesLi/c9S2Tm06OM5EiqDlyenTqxyIcDXeTIYdviUYMjWe5aQVYfY/SFr" +
    "I6z25va5Qn/otmWe3dV0E3LjdHviL9bEWV5r53cGwoVtzJsKQ4mD50ku0vmC" +
    "R7P7NCGL+hEuLMED2pbhkRVxlscWiHUGwuWSYHmJ3nNmA7G2JfDQAKwIl7Dd" +
    "vLjcDsAYLWwMY9LPHfWBO4dwEYMLDA1giIAp7M1sP0FIcy/CpXjsyKbs4y+Z" +
    "DocgzjKh4MbN3HdRe/maRWmmBZq1j5KGetLntw0QcvQ7BAkvNrPrVBDonLnX" +
    "fSWxoepd7PgLxDu9gwtrOPTqqhKwIFyY1wlQGUSo5BIySW1owuZsh0eZrc/y" +
    "YBMFFoRLSAv2I1R0QGbbifzCBTRmcfm9B+EJb+DCGg7ByloIl3LB0xaeupj0" +
    "pVM/BB5gHuECYg2PvIALa7Ic0HTowhEuIXUcCYKTmNJJPWfdGirpsvV/r89m" +
    "gW/jXsvtMwiZsSdQHaUZAqqT1IzusISOoVRWD9njOdcxtzAEOvAt3vymhkrr" +
    "B8v7kNtnnOPrFOxZ2v67BUSXcdEmH2g0H9w1HsR9fx3CpfQ6th7P91yVrNLR" +
    "CwWo9+YHLl9uC8IRJodHRoO4j8xP2LgewQXmOaC3kr0Xs/pwPuACerrF7OLe" +
    "RoO4VV0IF1BLPyHnf8Kb25bUdTIfcKnrNhvcNbb96l9bCanZraDusGp3h8U7" +
    "XqSMsjy7OZKsc6lgSQFM9qWTPxDS3BNjAwp9zrUrHbbbHRYvj3fXmgvuGvni" +
    "GYK4tbvzDReI9vfjMMjq9GNhmNR+yG+4gB6eZ2bnACNB3I835hsuABZ4MmJy" +
    "I6076jdcpuwwE9xN3Wt5alEMCHIAl4V9wRMRk1tp7xl/4QJ6rjV97yVVrwXo" +
    "OHl78BGVsnZT2pWBFOswfz+CxeW053TKdpOxbd+QcnA31TdEf5qX3Y2dNVxW" +
    "DiBYfEh95wip7/YTLqx1d3V6L6m+IYJVsfIIl2+O4E3p1Zuk7xUBYzlc0vZe" +
    "7PZaHIQLggUB4xJcnl2a3mcBqXkt/9lMSGVXvKpo7WRI5JgSVVKq6pIXnYfo" +
    "dXQc9uuG+vYnQg6fJ6Tz+CWtKVxjS98lLe6/JFgNrnjc/rPBuT6lEwXA1O1W" +
    "s6kqEXvn/C9yD8na7ledhFw9NZ15L6l4LX+cy78o3+Ayr9f9G6ezAIcVA8E3" +
    "N5WsdhBoX1bbwZsSmJW8cZCQvrNux6IgBuMTXOAY1p7TOryXzLwWn+ACYHHt" +
    "hgGvZHvBw2g7WHga74owXk1wCfX5xX6a1xPABvYmci11n/YLLml5L5l5Lb7A" +
    "Za5DYIF6wpBlbs/FtuEZb4pwKS0TPBsYbrk0jNICGEvgkpb3on01/3EdhEzd" +
    "GQhmAoa0k9IOAXHOKZYVVSbvf5V6Tb2omq5gOGF72n2KkOUHxa+rKB39I9sf" +
    "s7oJ2XCUkHMOfNi5+pDetlHRVI5E+++LgvfyS83ei1av5a5ZnBvZM7jYDhaA" +
    "yqw98teVJVxKBTev7ZBZfsAPuIAeX6j3tbTW9VpKvRbf4dJ53N6hz7bjgQeg" +
    "Ck1b4FIKmUPn7W3vobb2AC4fb9a73os2r2XELAHD8QQu8LSyMQFUpncl98hs" +
    "g0tRi/bb6cmAB+sDXEAPzdXnvWiDy/PLgu+IZDSJksgxIufEagdDEufDRCrb" +
    "ArjHvw+2Ikmj/XWck7iPSv6b1hUsDWpbgjrJ2m4abTlpByVeGVRbv7tOX2BX" +
    "WyD38635gMvx7+1yydcfTWCIDsKlFPK2DZVaD7gPF9D11Xq2gdXitTzUnJ5x" +
    "2wQXm56YcGPBUzyRIToMl6JgcSdbPEmoB0DPdbjoCuxqgcsrbf7DpfWA3S54" +
    "XuECatxnj0cJ9XAdLh9t0vO1dOIZufBuPE3jtgEu4CHY8HSEOqjEVnyHS7GP" +
    "bNmpsgh/V+ECghc0Sb2XxF7LYwsImdgZ6CuOJlLi/T9R4BwdZfDy3HLMgifi" +
    "d8Hbla86JbQtrKRtOVEhTx39wa13SX1WHrTgIfC/waxj3W3zlcI9o3q/sFaq" +
    "SxUurLkt//rGb7g07M3eWGHrCymo5BguIOgzuMGzTD1n3IbLhC3JN7BPtIzl" +
    "rXXp3/hZw2Xg2+zBMrET4SIDl+JDIWvAzO91Fy6gkc3JvJdEQyLYwc1nuMBS" +
    "lVkmGI6JXjfCJQyXImBgOJlVOvej23B5qc0QXF5mjMHeX0/IF9sktFVBsnmq" +
    "lMk4Z8p2Qn7I8MkHSyEkva4vKWnpj6T9Z6LPSwSzUI9lCJjNgxJtkeA6lcXp" +
    "C/pjRpk5L8peyz0N+i/EJrjsPJGhQR7Tc10Il0Dw9XqWDwoo31W4wP7uqt6L" +
    "Mlxg7U1f4QLGkFXaeVLfdSFcLh0/uzs7wMCDylW4vNWRMlxYm529v85fuGTl" +
    "tfwMFoSLdrhkDZgh78VBuLCGRhAi0QYX+lui66qDbUNofUpJ9n8Vfbo1LNn/" +
    "aU3uzMb4IC4Ak5o+23pROtpGsj/Kjt/KkGweKuKUSf8vU4cVGc203jQo31af" +
    "qrQvp21U7snfN6gtIqU0JIKNrH2FCxiB6QRP0+ouzg2FcNEClyz7eFKnm3B5" +
    "cpHa0EgJLi8u9xMu4LVk4Ta37Be4oRAu2uACyuINEs97sRUub65JCS6seMtH" +
    "G/2ESxZPNChT6IZCuGiFS/VO8w8SnvdiK1xAKnEXLlxgmbvSTG+pDbYOGdKm" +
    "sCZw9PN5MtokKYUyJhQ0cZt5Yxu8kOA6FM6ZQEn2+Aka8tRiA7L/R2hhBntN" +
    "bTwafb/osO0JHCn1eaHsBxrl4y5K27T6CJcslq6csQvhkiVcQHtPm+3zsz+6" +
    "CZc/L5YfGiktZ+kjXA6cy+4JhnDJDi6VO8x7rF/vcQ8u8IGy7PKX0vGWDzb4" +
    "B5eqHeafXl9tRbjYABcQ7C5gMsFOl67BBXTdNLmvpKXiLTfXBqtU/ayNYX0s" +
    "q00C4uRRVgfO+aH6X9SGI4a/lu0RuC6qjkLtsklSsm1por8Y/aPFjjhlQPzL" +
    "ZGD38y3ybfWRBntP0nb3N8oNjeTWyp3rJ1zO/GjOsPrPibUVwsUsXObsMfuA" +
    "WdrnHlzGLE4RLmPb/INLzS6zRtXQjXCxES7wW7/BuNueU+7B5S3JuIvc/JZN" +
    "/sHF5M6JRa8F4WInXEx7L1M73YILiJ7vogUuVxUyHb8hrA8pSf+/MazxAnlw" +
    "xcmTPt7kmwLY9lO0XuMVxGubpOd/qKPPBer0oWbJlNF/1pw9rDqYvP9098/4" +
    "jfG6o148qCv8sSJk6htcpu8067XIQA/hkg1c4AFgKnWfcg8u9HavcZPphNfL" +
    "hY3PfIPLqoPZeC0IF3vhYtJ7Aa/ZdbjEBXWldlX0DS6mjOjMD/LDNYRLdnBZ" +
    "0mfuoQNrzLgEl7ErUoDL2OX+wcVUWn8E4eISXD7dbNY2XILLuI4U4PLKSkL+" +
    "vV5S6yitT0GKZczcbc6A4KPI1K9bRCm05QeUUulzXp6y/wscs9XQRnh9Z7Ox" +
    "/6jzP2D1KSXR19HCr6EzufAUy1h72IzxHL1g6LoRLlrh0rzP3MPHNbjcXCO2" +
    "/ILQNiKQmW9w6TMUb1m8H+HiIlzgN4iVmUjgRbsEl7uofaThMyFhuNCvoW+f" +
    "4R9cTCX44Avh4iZcTHm3UI5LcBnVJBZ3EYq3jCxk9t5aAa2jJHn8u2vL9V5C" +
    "sfKs3G5oSHRe/Fq5//PaWkSybbWOIU69eXm+p0O869JhV4XzmgztE7775MV6" +
    "UlJqC9k+p8sUyGP0Io1wgcx8gkujoWneaw8hXFyGyycbzcXlXIILrOmkDS6Q" +
    "mU9w+cbQ+h1NexAuLsMFdNTQUgwuwQV+E3ljJAQX2HXNJ7hsMbQQ9ycbEC6u" +
    "w8VU3AUWD8slXN75JljmTlbvUJI9fuictRwp1Gv/mfSN5cj5cD3foSR7HSJt" +
    "KdveqfQp57rK2kGkXF6eKVx3Ma+vDQ2ha7sy6i9FKcGFNcfFN7h8b+BL6M2D" +
    "CBcf4PKFodm6y/vdgsttdQiXMo039Bq64xDCxQe4gIzZi8NwYU2kyx1cwP00" +
    "5uYiXLyAi4lhNJThMlxY67pw4XLj9CCg+9YahjrCGkeJPn4cLfp4AdF5yNah" +
    "xtAaLhXbxK5HWYz+UGnP1LWGI5U8JOswriNZ23SdSN9ees9Y0l+C0gIXyMQn" +
    "uDQYWgwoi5sW4ZIOXNYMpG8vh8/nAC701H/f4GLCUI6cR7j4BBdvHkgaRW8z" +
    "gnAxBBcjLi7CxRhcTA2lXYYLa7lLLlxuLcDlzUKHvrFaXnCejJj5rKFEl0GJ" +
    "9/9qA3DpOcOvR9m186TS/nTbUHmW9cFqAXHqzTteyA5k8+TZgMK1lpZfbWhH" +
    "Tl5/vaGhvbltI3BPgf7wNf8TAC5c/tCIcEG4IFwQLhrgMqIe4YJwQbhkAZf3" +
    "13oOF/oE3+DSY2DOAgAM4eIPXEAmEkDMFbj8ebEGuNxXINQ/2wtazVC7nF6n" +
    "JHrezF0FKJzWIxNT/0/9EEAsJNm6Xjxv1m5CphWMrmp7WPBbmbaHVbUjLNX2" +
    "16myOmiwK6XzJc8xkaBfZe8X6T7lXfdqsWPG+AIXENxweUvtBQ/o9dWBytpy" +
    "NUOcGxfhgnDJFC6jGu2EC0xd/v6/+QELTKoqBQfCJTu4VBlauRBs3BW43Kfj" +
    "bdHvZtsBF5OdnHUCiMIqaAiXfMFF5X5xGi7Da+2BC6j9oP9wgRgTDQ6EC8LF" +
    "S7i8toqQVxl6jdbKsHjHc/NjnVPId5/H8RfYv5rVliJtI9v+3LZelTwPHX2e" +
    "ijhtBXZW1NRtZvrexHW9pskO7p0T5gRMYfECLjAF3Mf4y6Fvo9sS4ZIdXJr2" +
    "IFx4cFH6KtpGuJh8mpiMs8BCVggX++Cy8kD6/Q/euEtwuaVWA1yurbITLqY6" +
    "3VSq74pvS4RLdnAxMQzPJVyGNqFvI+TvK8sFv4e0klIbRysFRJ1D12HfKffB" +
    "ApCUbQel9pQ9X+AYaZugz2/jKws7KxUMV1OHyylGWyqI2550n/HaOqK9cwGX" +
    "cavdjr+A4WoBA8IlNbiYesC4DJd32j2EC/w2xdH4C0Dxg7UIF5vhAv1jIrX0" +
    "uAWX66s17VtkO1xALsZf6nZqBAPCJRW4NBpahQ4ekC7BRdumaM8uJeSlFQy1" +
    "UVohp7FtYcmeT2uvQ/GXtgPJ2q6s7TW0n5E+o+o8dkW5TNtNnC2vM7Tj4hvt" +
    "an0u23a6pA0uTyx0Ay7QQd85EH8Z+FYDGBAuRuBy8nszNqHa51nA5QWdG9HD" +
    "wjAuwAU0eavdYAH4waJACBf74fK+oQ3RwON2CS5PLNQIl983uAMXUFu/vXCB" +
    "xZ61gAHhkjpc5hiKt8DQyyW4iKxCFwkX+hOAm2sIeXF5uf4mqRc5Yp6zLCzR" +
    "MvZYGH9Z0V9S12WUOG0l25Yi59B1UMqT6p806i3bNiJlipyz9lAGdrFc3Eb+" +
    "psMGeP3J6NO7ZyeAC7yzLj3xmkr34PKPVXbFXwbOyRkOwiV7uJiyn082uAUX" +
    "cDZ4E+gi4cKa6+IaXEATt9gTZ3m3A+HiElwadpuzjch6WAqX66r5m9BHwoUV" +
    "d3lykXtwAS23IP5SvV3ecBAu2cJl2zEztgHluAYXkdfQUnB5aC4hzy/jqJWS" +
    "7uNV8ij8tudkdmBZ1hfUAV7fhdQaVuLrbuUfwy1TpD909FmJXmhVaItWjpYl" +
    "y+PVNnP2MX+veP+JXGtSu3qBodLyRN8UScHlrtnuwgWMJYv4y8FzJTc2wsUZ" +
    "uMANbyp9tM4tuDwyTwNc6M3R7qx3Fy6gLzebj7O8vQbh4iJcTn5nzkZk+s8G" +
    "uNw1SwNc6NfRN9W4DRcQDFFMpWmd1I2NcHECLrN2mbORrYPuweXOev7ylly4" +
    "sN4YPbdUTs+2hsU9nqHnWilxzuGV0W0g/tLaV37t3OviXKcWUWXItt1zBvqH" +
    "ZTeyZSZpyxPfmYPLzC79fcxrKxW7LP3/xulir6Fj4cKKu8AWjq7D5eUV6cZf" +
    "IM7ybCvCxUW4VHWaHTq/ssI9uAybIvamSBouI5vchwsc8/mm9MbQb61GuLgK" +
    "l26DbxU7BtLp4zThAtNRROMt0nAZMcsPuIBa9+s3GHjyMW8OhIv1cDHttRRt" +
    "xSW4wDeG2uBCb+3662n+wOVZzU8qgFXkzYFwsRouMDwxGWsBDzeV/k0ZLsOp" +
    "pS2vn5YALqyg7tMthPxlCVvPcCR7POucvyympJBnUS9p+n7kwDlOnRX0jIJk" +
    "81Sq12JKdJ6S/SNULidP+n/Ztlq636zXAuXpsgnddhZ3DB1viZr2LwQX1tAI" +
    "tnH0BS6gzzYmfwq92Y5wcRUu/15LjCco0zW4PDpfbkikBJfbZ/gFl2cSPrlg" +
    "czbdHY5wMQeX3YY/DYHhl06bMAWXuxtSgAs9me7qSv/gompkRfcW4eImXJr3" +
    "mPdaZnS5CRfZeIsQXFhxl8cKLtKYFgEt5kj2+IKepjRGVhH1hK8/ZeIvB87K" +
    "1VuoHi0J85QtQ6UOSftYRxka6vBeh3mwgNditP902dFi+XiLEFxYQ6N7GvyD" +
    "C2jCBvE4yz9XIlxchcuLrWbfDhUTbGjvIlz+NE9+SKQMl9vq/IQLaEkv30gq" +
    "tmroQIRLZnDZfDSbBcPAO3YRLr+bnSJcyuIuU/2FC2j3iWgjAfho6UCESyZw" +
    "aeommaQhu1nsJlxumC7+saI0XFjeyyPzCXlqUbyepCR7PFMtYT3Fk0K5zy8l" +
    "5AIj/tJ/NqIOdJ6MevCuS7YtntLQntw8BNqTm2cK/SNb72I/1ezIBixgS/CF" +
    "chr9Jdv+KrZL3/usfaG1wgU+BfAVLqBP1pcbyGttCBdX4TIpw/2sFveKXauN" +
    "cBHdRiQRXODVU2kBv6ryGy6gxT2XDGTSlpg6IFyshss7HWxP1KjX4ihcIL6a" +
    "Olzo7UZEhkauwwW060QAmdg6IFyshcu7GYIFEmxkL3qttsEF1ssdVhG+5+F7" +
    "Q+1wYQ2N7qgPKqCq0ZSYxy2glEIZo2P01yXJ6yBUL04ZowUke04q12GR3l6d" +
    "LVjgwZSkbVJpW8rORlMqPVb1LZESXOh1dX851X+4jF6IcHERLtO3ZwsWSP9a" +
    "7TZcbqoxCBfWbN37GxEuCBe74AJgyTq19CRvmyzhwpo4JzIrVxkurKHR8DqE" +
    "C8LFHri09GQPFvCYnlviNlx+OzOZ16IEF3oBKQj4PLZAUfMpLchI8znKokxK" +
    "j1JSqeejlFSum1sPHX0uWS+4FvjArusEsSJVd0b0WRa2rJjPtVXyHyomhkvU" +
    "hmkIF4RLVnD5cF328ZVi2ng4ps8cgcuDTeoT57TDBbYbQLggXLKAy6IeYk06" +
    "fiFYhsJ1uMCaTUmHRMpwgcAOay9phAvCxRRcxhe8lePfEavSW+2cPnMELvAW" +
    "WOVbIi1wYXkvsBMbTKor1cO05oX1CK35fPHy4JYhcE6ZONdRVqZAvWWvg1un" +
    "+fJ5PKJBSfvjYUmNXUbIhsPEujS7K3kfK7W/pA3w/metOBe3N1EqcKE/BwDa" +
    "IVwQLmnBBb7wXbCPkAs/2QcWgN3D8/yAyy21eoZEieDC+hwAqIdwQbjohIvN" +
    "UIF07EKwLIEPcGEFcuO2a00NLqyh0XXTEC4IFz1wsR0qxfRGu5hNuACXm2v0" +
    "eS2J4UIvIgW692uEC8JF/f8vNhLS1k+cSLBroqhN2A4XlteiGsjVAheW9wK7" +
    "Mv5xLiq3aqYkcM7rKwmZv9d+L6U0VW7zq990ey1a4MLyXmBPWbzREC5RcIEF" +
    "suHmXNEXxCxcSwBCn/rsgUb9XosWuKD3goqDC4Dk/Q5CZnUFN6WLMClNAETf" +
    "+uzWOv1eiza4oPeSTwE4ABilgptv57FAviUfwTKq8AC4oiL5d0SpwYXlvdw0" +
    "Pai4lJrKNbI5LPqcsv/pPJo11IPz/0hazfx6s65V5rpHCbSFrITKKLnOd9eQ" +
    "3KQdx+JtYmSTgug+kD2+WcBuOLbMmteiOmkuNbjQC0mBYHFfhAvCxfW0vI9v" +
    "Ey7CBd4QpeW1aIUL03upQbggXDwAS7OfcBmeoteiHS6JvReEC8LFojRzp7hN" +
    "uAaXtL0W7XCJmrX7YCNbD1ASOeaBJkqcPOjjo+oSW6asmvj15P6vQalcZ0md" +
    "3/EYLlO2JG8r6fZWsAnVPmXNa9HptaQCF5b38pt6hAvCxY10/idC/rNeT1vZ" +
    "Cpd75pTfo7peP6cKF5b3ctUUQu7/GuGCcLE79Z4h5NU2tp34BJdfVaXvtaQG" +
    "F9a8l1tqEC4IF3vTsj5CHl8QbSe+wOU39enMxjUGF5b3UpxYBwFe7zSHUgrn" +
    "3EcpjeuQLePtdj+GQZM222lHdH/cN6dcMvnfO6c8iJvGcCh1uLD2OIIVxREu" +
    "CBdrhkGnCXl5eXrtaRtcWJucJVmvJTO4RAV3YQtYhAvCJevU3B0sOZBme9oE" +
    "l7tmmQniGoMLa3h05ZTAPUO4IFyy8lag3iba0ya4XGsoiGsULqzgLmxFAq/D" +
    "7qXVUK57aM3hiHP8vQzxjuGVya1zg0KeHAmdQ9eL01ay/TFulVuxlZrtEnbE" +
    "6eOy/lCxVck+Z9oBr8wG9kzctIK4RuESFdz97SyEC8LFTPpmgJAxixLe+I7C" +
    "5e7ZZoO4xuHCCu5eU4VwQbikmwbPF+rYrunGdxQuMEpIuqG81XCJCu7ChSNc" +
    "EC5pQGXi5hibyAlcbmPsnKj7+yEr4BI1PIKtI8F1i1QDJdn/dUhDGTDHp1SZ" +
    "XJfmPN9caRdUOgcJGf+NYH9QSqXPk5bRIK9iWSNmsodDaQdxM4MLa68jaAB4" +
    "TYZwQbgkgQrUJfImziFc6C1ZQaMazYHFOFxAoxiLAV9TiXBBuMi//VnSW6jD" +
    "KoGbOGdwuaE62+FQZnBhbQULggZBuCBceKljgJCvCkb0UHP50xrhQshtdeYn" +
    "y1kFF6n4C8Il93DpOU3I9O2EPL0ofiiQd7jA9I6s4yxWwAVeh9GNcHlFEIiC" +
    "GIyo4PhSyZwbqZmUNOQ5gtJdBjSCo6Tn/7MtvSHPmoOEVHcS8uLSdNpOd1to" +
    "KZOyO1nbvsqCOIsVcIl6PX11JcIlb3ChYWKi7XyDy/WWxFmsgUvU8AgaCuHi" +
    "J1x6TgUg+XoXIV9uJOT1tmzazie4sKb3ZxVnsQouUYCBwBTCxW64vFDwMrYN" +
    "hlUER1HgjQBAnlxgV9v5AhdY/Olyi+Is1sGFGX+ZHGwzCY0Xq5lh/ZZWfVj0" +
    "8UOSLIP7v4CE6iV5PH0M9xzZ6xa5Lkqy/yupXkGy7UudX3Y8Q9LXKlvH+mAJ" +
    "WZviLNbBJSr+AoC5E+GCcEG4lNUxCixZx1mshEvU/BdowDsRLggXhEuoPJh4" +
    "amOcxVq4RMVfYgGDcEG45AwurNX7bQOLlXCJAgy8or5jBkP1lGT/L+j2+rCY" +
    "5cTodkoi9aTLLMujniORtuCcwy1zhn4JtRVPGvrcVV0bARb4bg/hkgAw0LAI" +
    "F4RLXuHC+mbIVrBYDRfWF9RMwCBcEC45gEsUWEwt/OQVXOIAAw2NcEG45AUu" +
    "rNXkbHrl7CRcohb4HtrgvjqYB3MbpVsplf1fy1CdnGTLvE3gnDJx6qiUp0I9" +
    "ee0n3f466qDjumrDSprnrSkJ9hqCKRmugcUJuEStAVMEDMIF4eIrXKLAYtNc" +
    "FufhEgeY66sRLggX/+ACD06XweIUXKIm2RVXskO4IFx8gct1EcFbl8DiHFzi" +
    "AHP1VEJuqWGolpLIMbxzZI8XOUdWOsrQUccajmSPT6OtGBpOiVfP4bXx0tI2" +
    "tdET5FwDi5NwiRsiwaLENyNcEC6OwuXqSn/A4ixc4gAzrIICDMIF4eIAXKLA" +
    "YmLbVYSLxGvqEGAQLggXi+Fycy3762ZXXjd7C5e4iXYQaYc3STdND+tGhm7i" +
    "qYYSnWcNJYUyEtepRvGcEpXVoUZAnDJ415VGW+noD26ZAm0vcu3DKvwEixdw" +
    "4QHmumkIF4SLfXCBB18UWGz9ViiXcIn72LH4RTXCBeFiC1zgjRBrDotPYPEO" +
    "LnGAuXIK28gQLggXU3ABsbZZtWndW4SL4lwYeFr8ehrCBeFiHi7XxQyDbFzo" +
    "CeEiuSZv6XwYGPMWdQOl6zmSPX7onGlhpVGGbJ68Mm5IqR5Jr/0GDTJRp+J/" +
    "MIP8ssl+zWHJNVyidhX4+XX1FIQLwiV9uFwVMwzy4Y1QbuHCi8PA0wSCawgX" +
    "hIvuOsHw+4qK/MRXcgsXkWESwgXhoqtOeR0G5RYu3GFSRbCEJjxxrFQVJR3n" +
    "VHGkqx46z7e1baoCLzguaOv7MCjXcOG9TRraxmQqwgXhIt82MIU/ylvJyzAI" +
    "4cL58LH4yhom3iFcEC68trmmKj62kqdhEMJF4LOB0qHSrxAuCJeItrlySrz9" +
    "wIe1eb6/cg0XkWBvcXYvBOmKupZWFV+l54uIW0YlX9Jl0OdXlYt7nfTxlQqS" +
    "bDuVtpYus+SarpwaPwTKs7eCcGEIxsRxgIGhEsRjEC75hQsMlS+viLcTn74N" +
    "QrgYWiOmKBhfX4NwyR1ceEOgvL0JQrikOFQaVgoZhIuXcAFPBfoZh0AIF+ND" +
    "paInA68hYSLez5rC0NSwrp4SFv1/2fEa9EtJieSRtAxbdUUFv+9xCIRwSX2o" +
    "NBSTKYUMwsVrqLi8ri3CxdGhUggyCBdnBP0lAhUYAuVxMhzCxTbIFMbpV1Yg" +
    "XGyHyuUIFYSLq5CBYCA8FeFtg4yGcQTg4mpKCuKUUVZPyfNTqSMl6I/LJ+Pw" +
    "B+HiSUym6M2IggbhohcuwwSBglBBuDgNGfBmwB0fhnBJtY4AlCsmx79KRqgg" +
    "XLyETNywCeGirisqxIGC3wAhXJz9MDJueQemRzM5eNqCZxPS5LCuqChX2TGU" +
    "uHnQx1fwRZ/Dq1OZWHny6hWRhwxQcJ4KwiUXC1VFgeayyQiXOLhcNlkeKOil" +
    "IFxyu5YMFzY5hUspUGTbDmMpCJdcfl4g8jo7bgh1ucdwUYVJcW4KDnsQLiiF" +
    "+Eycd3OZY3AprbcqTIqC4SfaE8IFpemNU54F7YSzZxEuqATDJ4TNpXVTECYI" +
    "F1SKsFEJCiNMUAgXlLJ3oxogzloQbyoOcRAmCBeUI9CBYLEtwyqoBwRdESAI" +
    "F1QO4EMLAFAqeggG3hF9DCsfbF+ECwqFQiFcUCgUwgWFQiFcUCgUSq/+H0E0" +
    "6M3GfVu4AAAAAElFTkSuQmCC")

RESET_PRESSED = ("data:image/png;base64," +
    "iVBORw0KGgoAAAANSUhEUgAAARcAAAEXCAYAAACH0wDUAAAmGUlEQVR42u2d" +
    "Z7gdxXmA8zeJE5I8dpLHsbEdF2xTBI7bA7YMCQEMpoPB2FQ7qF91XfVy1Sgq" +
    "CAkhCYQKCAQImSJsBAgEwmBA0q26XbpXV4KriipI1Ml+Ovegs7Nlys7Ozsx+" +
    "P94/Z3en77vfzO7Z/Zv1hPwNgiCIarAREARBuSAIgnJBEATlgo2ABBlVS8it" +
    "69kMrCIE2wtBueQYHlHoYnIDCgnlgjgZbZgKRkEoF8QA4ES0WSQiYH+jXBAL" +
    "ZTKpnpAZzX5WbC/wRAmbDhSoO3B8eynFY2eWgNENygVxeIpTlAcI4E+dBTkc" +
    "/JiQTz4Lgfj59LMgnzAIHEMKbDpIyCu7C6Kav7mw7oKyQbkgGkhysg2oKghk" +
    "aXtBIiCQLYcJ+fgzik/9fMTisxBkjomh8yghtQf8EdCABFEaSBnHE8oFkbyL" +
    "AyffPO/q/6wXiXQeOX5iB2RigVyi8oB6vbyrIMyRtbhWg3JBUlk/KZXJ5sPR" +
    "J7ZLcqHThAinKBuZyAbHHcoF11C6gOkBrJEUpzcfccjAZbnQ20GyIFuQrohs" +
    "cNqEcsndtAdOkCXeVfmvewg5+onHp36OUBxVwJFP/Byl4UmHOubIp/EcTYkW" +
    "TzaPbxMTDT7Mh3JxOkq5t5WQl3YSsu/D+BMb5cIPCBpEjXecUC65kwrcHl71" +
    "LiHvfBByQqNcktNVFhA2iHt6E0oG5eLwAi3c8YCwveVQjFBQLkrlUgqIHNqf" +
    "584TSgblYoVUFnvh+Rt7OYWCcklNLqWA4HmnTTjOUS5GSqXDu1q+/0k6fBBC" +
    "YJ+PKT6Jh3k8Rxr0/sy6fMyGWU7G9iigfx7lXATGcY9yyfzOz+K2dKWCclEn" +
    "lyJ7PkTJoFwMXaiFQflohyeV97tOiE9QLjbJRVQyuCaDckk9WoFB+Jg3GPcc" +
    "pU4IlIuVcimVzDPvshd/8TkZlEsqUlnuRSq7PKkc+hgxjcMUSdJ6YSchI2px" +
    "qoRy0TAFQqnkSy5Fnn43frqEUyWUi3S0Mq2JkK3v44mbV7kAcFFZ1IZRDMpF" +
    "0a1luFq9tgdPWJTLcTbuw6kSyiXhC5oe6Si8V+TAxxQf+dlP83EI1D6sNAN5" +
    "UOkdCGH/R4rhqEegXgrqIdzejHIf4CmXRL1gfMRNlfL+D2yMVkK4s6nwvlhe" +
    "EaBc8ikXoO0wIfe0YhSDcmGsrcBVaPUOcRGgXPIrlyLr34ufKqFccjwNKk6B" +
    "QgcWygXlwgmMI5wm5UwuUdMgiFbgrfTvfRTNPor3WHwYAs8+cfungUwZGMfs" +
    "oxDOMyxNuv0Z5WTuz1Nu0f4o2bd2vxfF1GAUk+tpUEV94XWJrIGDckG5iLYl" +
    "vOJhTku+BZPbadDDHfyyQLmgXGTb8o/b8ztNyuU06NXdYrJAuaBckrRlXqdJ" +
    "uZoGTdhUeFEQ/DHNx1GKD5OxO4S081RRzlTy0VBPmXoEjmGVM2E9tnvTpNk5" +
    "myblRizLtuo7AVAuKJcoVm7Pj2CcF0v/SkLW7tJ7AqBcUC5x1HjTpOE17r/G" +
    "wWmxRE6DUC4olwzlUpwmwfh0WTDO3hGCjtv6QeGfrEnZmQKsPGTKIFoP0e27" +
    "FNRz1xEKnj6gjmHmKbh/auXm4L4t7t5JclIsd7cUxLLzKMoF5WK2XOIEY/s7" +
    "Ypy71QwdJXLCoVxQLlnLBXhoq3uCcVosKBeUiy1yAf7U6dadJGfE8myn3AmH" +
    "ckG5mCIX1wTjhFjgu8s7jhToRDJlB4Xo/tiHhTfdwSMUtgvGarFAB6zZiQMT" +
    "5YKCQbkofCM/NDx0AA5MlIvLghm/yd5FXitvNxfF0okDE+WS0wjGBsFY+RwL" +
    "fENm+5EC8N6MWI5QhOyznUJ0OzNPnnJKlDtQziN+WGkI1yssD8H9ZfLkat8S" +
    "AnkckThGkEA9j4i3VVQ910cIxvQH7ax7pL9ULCgXlEse5FIUjG1/FbBKLPBd" +
    "ZuEOQ7mgXByQCwDfr7ZJMNaIZf5mucGNckG5uCIX+C1KMCgXSbHM88TS8UGB" +
    "be+LUTwu7nh6n473GbD2/4Cdr3CaHAi3BQVPWzGh0xWtN0d7svLsUAGjbXna" +
    "PnGfRpRtcbsdgjFeLLc1JhvwKBeUi2tyAeCCa7pgjH5IbtwmQpoPo1xQLigX" +
    "GwVj7C3nMLGgXFAuKBc/4zaZe4vayOkQ3NN/Y0/hO7ztNO9TsLbLcJjB+xnA" +
    "UYY2CplyL1tFyNTZhPQaTMhFVxDys//2c8I/w6gJ59QzgvtDOgCku26Tprbk" +
    "ycOEPlUwLhsPEVJeY2b0YuQ6C3zrBcSCcklPLnCyF098ljRUAxICcfUaVBDZ" +
    "MemgXOTGpff7X/eaOT0ybp3l3tbjYkG5qJPLsmeOi0SXREQ48RuEXHeLItnk" +
    "TC7A8g7zBGPWOksdIQ0HUS4q5PKqd4IOn2iuTHhlM/chlAuPXICZzWatvxgz" +
    "HSqrJOT1PYRsOUxxyA9827kUen/W9i0KjtnMQCYP0TTD9qn0ppPDJhamHTYK" +
    "JQqYsv3GE82Dz6jrz6R9ztMfzDQP+REdEzT13oV5mEHrL8ass8DHokI7AeXC" +
    "3H+yN5W48Aq3hBIX0fQcRMgrdSiXMOACbcr0yIh1lrmtMZ2Bcgndf21d4Wqu" +
    "cyHWNCBCmzIb5ULzsCHrL5lHLWPrCuEcyoUvTZgagFTyKpSoaKbcmw5WbUe5" +
    "FJlhwPpL5ussr3lhXMvhLg6xaaVoMYDWwxQKykkfv8STylnnoEhYazM9vCnT" +
    "hm1mjIvE4yrBGKo7kP36S6bToSe2l4gF5RJaz6UoldxKJukYei3j9ZfMopbp" +
    "TZRYUC4+Xq5FqaiQzNCK/MoFWNjmuFzCpkPr30O5hAFXW7jqohzUccoZhWll" +
    "HuUCZDU9yuRhObDpsYqjXHzcvbSwOIlCSIdrb7FrqqRqrL+4M5sXfGuPWsbU" +
    "EdJ0sAD86aqU4u8+Dvmhj2k8GA+dXuMhdr6BNKgyMPfnoHT/F70ryy8vx5Nf" +
    "11Rp4t0cfcToc9YYaDwofoxoniLjbFqT/uhF+yLuCztQLqXHDKnI97MqWXHm" +
    "OYSsqcmPXN7cW1iO0CkYrVHLnNb4Ez1Pcnmrg5ALMFrJPIqZtTQfcgHu36L3" +
    "5d5aF3Fr9qNcgJWvEvJVXFsxhlsH5kMujZr/e6Tt86sPthNSf4DBQTYNB/ww" +
    "0zjAJpAmqxwJ6jG4Ak9mEzn5DG/KXh0zBiT6nDmuVIzdg35YaazeoW9xV9si" +
    "bsOBfMvlrzgNsmKadNcSt+UCzG7RE71oWcR9ZVe+5QJiOfkMPHltYcIst+VS" +
    "uU/P4m7qUct9W2JEkAO5rHgV7wbZyK9vdlcuwNJ2y+RCRy1gxw37Cn+iCmU/" +
    "xQEN7OdARRoej631xPJPeKLaytU3JxxXBwykpHxDq9MVTKpRy90tgh3ikFxm" +
    "LEaxuMD5lxPy+lY35RL23l0j5RJ2h+j1vfmUy/i78KR07U4SUzAWyiXt6CW7" +
    "qMVRuaBYcioYS+WypN1wuYRFLev2EFK9P54aGfbFU00hkwedBm89xjomlq98" +
    "nZCfnk3ILQOOA3Vc8GQ4pfudd1nhWJfa4/unE/Jau+S4VTDWec6hakHeCvlb" +
    "gKrnXlKJWma18FXMJbksX2v/iQNSmLa4UJfqsHbgaN+w9oETEuQzYHxBOv9o" +
    "8VoUlN8luUAfhn1z2gi5yEYtLskFTkbbThiISooyKV6NwwaeCrmE9Tm0WVE2" +
    "tgnmqpvckkta0UtmUYsrcrFJLFBOEMqxyIRHDCnKpXR/kBtMt2yaRmkRjCa5" +
    "pBW9KJfLqk5CqvYXgCcB06aKQnR7kjzXtRemE6afCFd6J8Idi5O3pZK22++H" +
    "3r7Ku2L2H1+IrExv1zF36RnjIn0m24fwvel+iqMXpWKZWB8/cFyTi+liAanA" +
    "yaqqLXXIpRQ4eU2XDI+0bZALcK/i6CW1qMV1ucD0wtSpz80DxKRiqlxKJWPq" +
    "lAnaW6atTZTLK7vVvu9FmVgq6uUGjo1yuXOxmQMdpPJqe3ptmZVcisx70sxI" +
    "BiJYF+QC3NWsLnpRJpeHthb+R+TjvXjWUwSO3xfcZ/0+P6w8AuzjIOb4pyvN" +
    "W8D9nje47/2jeN0D7c/RVsxjVBDTH2vbCLnJwKgRysQa38rHctg5RaUp2sdh" +
    "73vJXC5v7MmHXL53ulkhedk4+brbKJdSyf/EsKnS7YvslwswpFrNZ2CViAVC" +
    "Kd5BYbNcTLpiwokFV/EkdbdZLkVGzTQnkoRygPRsl4uqhV0lcnl8m/tygauS" +
    "ySF4XuUCPPSyOREllMN2uazdnZFc6Cdy+1XKDwpb5AIRgglXRygD19pKzuRS" +
    "7KMrbjJL/rbKBYAbNEkFkzhqmdtKyNt7C7xF856ftyno/d8O2aeYdmQejDRY" +
    "ZQjbh+bGAWZcEde0scvqQ7BtAvvvZbc/c7tEnzPHTUy5R8404yLw5Eb1bfMW" +
    "53iOS5M3j6VbDZDLnzvdlsvSl7MfrFfcKCiVHMsFWPpS9pHmuZfaLZfX9miW" +
    "C/0aS5gixZ74Dsjlx2dnL5a396JcRMptimDuWWmvXIAZCZ95SRS1wBfcXJZL" +
    "1iH2jf1L6o1yEZJLUTBZLvTCA382y+XRbRnK5YWdhT88cbOHwd4U2CORr/fb" +
    "C5uzvfINnylRL2qfN/f4UdJWouxNXo8kvOBdAL+boWBu6J/y+FZ9flDb6T8z" +
    "ijzzIi2WqQ0pnOgGyeWyGzMekHtRLqpYuSHbCwXkb6tc4PvustGLtFzg3Zuu" +
    "ygUGQ1YDEaQmXS+US2Qei9dkJ5hjfWqpXJ7tzEAuwlMii+SSVdTCLRaUi9QY" +
    "yFIwx6IXC+USNjVKVS6Dqwl5fU+Qv1C8vtsPa3tYmiwCaQqWic539eZsBh+s" +
    "C0DeMm3wOaz2ZrQNa//XVaShoM+ZZdjtpzS/8unZ9O/1/YPlEj1fAsdztB9r" +
    "f54+n9Ig9xIpqagFPmTtqlxgEGTx0NWKDQpONJQLUy7A9WXZ9PFzrXbKZcEW" +
    "uamRlFwe7nBTLqszukM06QE1JxnKhU8uwHe76e/n35XZKZdn3tUol7W73JRL" +
    "FlEL5KlELCgXIbmsWK//QhKIXiyRCyCz7sLcYTI13xpRS8i63eG8xmCdDvZQ" +
    "cBwDZftzq/7BdlI3vXUX7Q+ePmSmKdEfuqhYqP9i8tsy+f7g6fOk52DUMdOa" +
    "xNddpD7T6qJchmWw0Hf/iyiXrDnnUr19/uWv2ymXB9rEp0ZSr7N0US4/+kV2" +
    "VzCUS3Y86o3pf9Acsc58wj65/LlTg1zW7HRPLo+t13/1+lMrysUUeo7V2/+X" +
    "3GCfXIDB1QrlQq+3DK8tvKXqc3b5eUWU3Rww0hAtg6/8XfxW863J8ferrxdX" +
    "e4rmqaB/ZPKg+0e43hLj4CSNd48gUlrVIt5WaxWMd6kx1LXtzkax6EXsXbkt" +
    "bsrlyxo/V/HDX3CWE+WiVS4zVui9wAyZbp9cFm5JUS7Lt7knlwUv6h1U01eg" +
    "XEyUC/z2Q43rbmdfYp9cnn03RbkErvoOyOXiG/RHLSgXM+WiO3pZ/rZdcgH6" +
    "bUxBLn29RF/e6eclisD2XX6Y20Og96HzfGlXPKw8dd4pmLYiplx0W9JtsZMN" +
    "q61YaTLbmqOczPZnjJmXd/LlKwJXHl3l/S+N0cutY6i2U1iPqHOK55yLY2xd" +
    "CnKBRF2TyzyNUyIYtEInHcolE7lMW6F3amSbXOjPvcY9TMf9vlxI1DW5wJUj" +
    "i6gF5WKuXHRGLxA12y6XuOhF6KuKrslF1yCCu1HCJx3KJTO5DJqud4HfJrks" +
    "70hBLpCoa3LRNYCuK0O52CSXp1v0jg2b5LLq3RTk8vh2Ql7cKcgOCtHtKvKI" +
    "4I7H9Q2gB99KoR47JEihLddQKOlT1eNoh/g+v7pB31qcdDvsUNDe1PFrwvqU" +
    "QrlcMhkUKcrl2n56Bs93uqVUD5RLqnIZe7++i49tchleo1AukJhrctG13jJw" +
    "GsrFRrnAb7qe3IYo2ia5TKS+Iw1/E5KWy5g69+Si66r0ZDPKxVa56IpuIR+b" +
    "5DKT844R15QIPuv4/I70WR3C850UCtKc87y+KRFvuUS3K4Fq29U7xBFt/+cz" +
    "YHVnEJ7jRt+nZ5x0vyS7tpLJc/5mhXKBxFySi65Bc00/lIvNclnZpPciZItc" +
    "4J1OyuQCibkkl2s0hbsgMZSLvXIBvqPpVQw2yQVQJpdnO92Sy4XXa/oQVhPK" +
    "xXa56LoQLX0rp3J5rrPwmjtRnqMQ3f/YMTsoOpNzRvf0B8u3u/nL/RxFGm0p" +
    "2t6p9Cmjv5K2g656F9MatUCPXKY+llF/SYJyiUDHP6EhOkK52C+XxW/qkcst" +
    "o+2Sy+g6lEuAxxv1DJZf90O5uCAXQMt46YtysV4uEH5qCXMfR7m4IpcfaJhG" +
    "w1Q9d3IZVlNY0IVX3LFYRcHaztr/GJ1+mHl0+qG3T9Ykl1nPxdeD2Z6i+4e1" +
    "JysNiTzSKLdwGoJ5cI+1CH5+cfrj5fTuitqf1VYy/RNynBK5QCIuyWWEpgW6" +
    "xCcdysUYuVzdN/3x8q1uKBfr5aJjoHz7NJSLS3LJ7IJksFzubEK5ZCKXM7qj" +
    "XFySy+RHUS4suYS97pIpl1G1hDzjZfD0O+LAcSKEpvMuBZ0HBWv7VX30zJ9Z" +
    "5QjUnYVM+9NtQ6UZ6IN3OGCUm7U/1zgQTZM1BiTqWpr/RE1yYfXX0wram9k2" +
    "HOcUcAfHB9KYcrmjCeWCckG5oFwUyAUiFZQLygXlol8uy+sdlwt9gGtyOV3D" +
    "MwsgMJSLO3IBdMhl0nJ75PJAmwK53O4Z6sl3JNnu56l3/PCmM2w+Id26Fzj9" +
    "5366seju5wsaHv3/968F86XLBZIrJWo71L1iuRpk2z9Jn9Pbn9ruRyaNpGWQ" +
    "OUaHXKCPfOcLR1txtWcKLHRFLkC37kTb2+NM4co+JW3FaMswAgMR5YJyyVIu" +
    "8D5ME+WyrF5P1GEK3zqNaiuUS2ZygZNeR58v22SPXG5XcbdoUr0ZctHZyVkD" +
    "El3wBsolb3IJ9LHrchlZa45cgCv7uC+XYfNC2grlgnJxUS4rvUI/EcJKBqz9" +
    "RdM7dsy2woKnq2K5ok9XXbdR8LQPdYxM+8b1j0waKvpcB0/EME6TXJTURfEY" +
    "iGqb2yi5wCMsTshlaZ2b6y/fPC16kKBcspNLz9tRLiy5SP23yES5AOMecW+d" +
    "5d7XUS4myuVyDVNxiMZtksuIWgVyGVBlplyAy3u7I5ch8+IHCcolO7nomIbn" +
    "Ui7HPkLvFXJFCI9nAF2G0xxYf7msdzZtqaQ/tvtJ2p+mjLNSYLqa9hiAccys" +
    "9/YQJNpTuK1D8syFXBZbvv4CA9dWseRFLrouMCgXw+QCv419xN51lnv+gnIx" +
    "WS7QPzrGwu9G2iWXIdU5kQtwmYXrL4Pm2S2WPMilh6Y7RXCBtEkuyr5btKSd" +
    "kEc7QthG0SHG8m1+uI6LydOm9ZdLeydru0A7bEveHzzHS/VZTB7LO4KkMm4k" +
    "637ub/WMhwdq5fpctO1UtY0yuczbbIdcoINsWH/5z9NSEAHKJRW5/NvX9IwJ" +
    "2T7PQi7LVH6IHt7pYoNcgNGPmL/OMvsvKBcb5DL7NT1jAiJum+QCwYYyuUxp" +
    "sEcu8NulBq+/DJyXkghQLupD/9v0jAmYetkkF5630EXKhRbM8BpCHt4a5JEO" +
    "MQJpdPjhOYY3j1N/Zp5YLunllXErH6x6PxyG4DGBPDvYsMrJLIPEMaxyMscE" +
    "Rz3Cyvk/1xk2LjjrFtc2gbYW7E+Afi1LIrn0r7RPLvd5QvzCCQats5zKLxaU" +
    "ixly0TV+pqyySy4QbLDEwi0XwDa5ACOXGbLO4g3SWetQLjbJ5Q9T9Y0N7nFh" +
    "iFwGVyuWy4LN9skFgJAza7n0nysmFpRL9nL56UV6xgbkY5tceKZEQnK5q5mQ" +
    "h7YaSDtFyPZTMlx/ubhXoQxw+85Hu5/E9eZIgy6DcFtuFc+TWaZ2ibZoZ7A1" +
    "WRoLavSNj2uHx49d0Xox+1jw+GVUOea1piCXifX2ygUGy99nsP7yjVOPlwvl" +
    "Yo9c4ITXNUYmrbJLLnNaFMiF/jjauE32ygUYoXn9BWQ2cx3KxUa5/OuJ+sYI" +
    "z9g1SS4QZCSWCx29lNfYLRfgYo3rL2Vz/XmjXOyQy++n6hsjP7nIPrmMq2O/" +
    "3lJYLsDSdjGWUIjuz3VMm5+lNNT+J2tYf/lVr5C60OVk1Y1RDxWItrWKPpXJ" +
    "Q7jtEqAragFumaq+z1ntLdO2pfsP47wNLSyXB9rsl8u9Ka+/wDrLknaUi41y" +
    "6TtX79R5Xo19cum9MSW5zGi2Xy6QZvmy9ObQ09ehXGyVi867iudcl06fpymX" +
    "BVv411uE5VJR74ZcgF+lsP4CV76oeqBczJaL7qilOFZsksuUBoVyof9DMKjK" +
    "HbksUbz+ArKKqwfKxVy5wPRE51oLRLhp9XmachlJ3UEeWJVALmHRy/1eaLSo" +
    "LZzFDBa1+1kscUxU3rxlKGVutZr1l6+fSpU5jBTrEZtvTJqLJDChDMw82ikY" +
    "+V6k+SluyE9V2yduK470ittE1luk5AKfcXRFLsCwh5Jfhe58FeViq1zGP6P/" +
    "4UrI0za53NMqNiWSksuYOrfksjjhlav3PZwdjnIxUi4na/5rCEy/FrXZJ5fJ" +
    "DSnIhRZMWaV7clkkuf5SDG9RLnbK5epy/VHLTVPslIvoeouUXIC5Xoi0cAsH" +
    "bQwk0oA1n1Kk0gxhdpXY+gusswjlIVpOmbZT1BaxZUijj5O2nUQZxj6tXyxf" +
    "OlHxGFFxDrbxtZ/oeou0XKY2uCcXYMiD/Osst7+CcrFVLnAh+dKJ+uVyVbmd" +
    "crm7RXxKJC2X0XVuygW4sCd7kPSak8IJgnLRJpcfXahfLHBBAqnZKJdJ9SnK" +
    "JWzdxVW5AN+PWX8B+aRygqBctMjlqvJs3uvDNW4MlcvQav4/KyaWCwDvdbhv" +
    "M8UWP/D2ulKY+0twnwLoNO+KWH/52qlddZEoA90WrLYR3Z+n/UX7Q6btVKTJ" +
    "agvW/lFlvH5KNmKBsTSrSryezLblaRsF/SUTtSSSC/wVwFW5AAMfDA6QKWtR" +
    "LrbKpcec7N5G+MuecvU0QS68nxFJJBe49UTfinJZLsAFJesvMDgjOx3lYrRc" +
    "Rj+dzZsIY6MWS+Qyuk6DXLimRo7JZUHX+gtIJrbTUS7GyiVLsQBXlsvXM2u5" +
    "wJcV6VvQ8DCdFrmMrSsUgJtWP/M3++E5RnQ7Tx7zY5hZyVEGFXUXrMf81iAi" +
    "9Zq/WbIeEu2bFSOfylYs3zsrWdswx0irgnEYM4YmNchHLcJyod+r26/Sfbnw" +
    "nPgoF/Pk8rvJ2YoFGPWU3XIpr9Eol7Do5c4mlAvKxSy5gFiy/lbV+T2Tt02W" +
    "cpF9cE6pXOA/BygXlIspcjm/Z/ZigYhpRqXdcplQn4Fc6H9HwoIP/NfIaloo" +
    "DCwT/OW9FJk0TUlDdf9AOaZ54/C7Z5nx+d7rJmXYVooYUCX+R8XEcon6YBrK" +
    "BeWSVf+ULSXk704wQyw/uDDjtlLA9KbkUYsyucDnBlAuKJcs+ue8HmZIBfji" +
    "iYUIyna5jKnLUC5R35JGuaBcdPUPRCtfPNEcsQDDnzSgrRQAd4Fl/kuUmlzg" +
    "S2xzWv3MpmnxM4emlQ0rDWYeHMcEYNQjkCdHuUXrwSxTq3gacxSQtD9mCzL+" +
    "JW/q8UuzpAJcOjR5H0u1v+AYYG2f3KAmakkkF/rvAP02olxQLunJ5Y4NhPxv" +
    "D3PWVko540K+OtgglxG1BsglLHoB66FcUC4q5WKyVIrrLHdsdEMuqhZyU5HL" +
    "4GqUC8pFjVxMl0qRYU/yjQkb5DK8xiC5hAnmtkaUC8pFfvstdxNy1rVmC6XI" +
    "bybxjwnT5RIWtcgu5KYmF/gq46zmCFoomlOAlUeLRDlaGIju35JCPVs0tF2z" +
    "grYL2T7Eu/qfa0GUUso1E1PqQ9H+VDQGVEctSuQSJhj4pizKBeUStf/YNYWT" +
    "88xrzbudzMO5t6Y0VjOSy7QUopbU5BIZvaBccieXsS8R0mcJIZcMLUQnNsqk" +
    "FBBiamM1I7mMqlUftSiTC3f0gnJxSi4gDriKlwIn30lnFbBZIqmLxRC5zPTo" +
    "tSH5/4i0ygXeBTGzWZCmIDOa/YhuFy4DTxp0GWiaQ8rFUde4NHnKPSMhXHmU" +
    "lKnXYvcEEsVJZ8aPiRlNGmhWfz6MSClqUSqXsNDqjiaUC8rFjYiFNSZslMv0" +
    "FKMWpXJREr2gXFAuJoql2U25jEwxalEul8TRC8oF5WIQFw/lHxO2ySXtqEW5" +
    "XEKf2vUKPL2xiyY/0xr9TA+B3gdum8URyIOxfTrHMQEEyyR9jEh6jeJ1TZpH" +
    "D4flcvVERls1shFub4n+kO3TNJ5rSV0uYdHL+DqUC8rFDuBBvhtmcbSVxXKZ" +
    "GvLPZyvkEha99N1IyJ0oF5SL4XzlFEIGrOQbRzbLhX6jQRpiSU0uYYIZUYNy" +
    "QbmYy0+vIWTi2/zjyFa5jK9L52ncTOVSfLAOvj3rHA0UKeRxO4UJedy6yI1p" +
    "0JUVZo4juj9ubwgikj78qZhexE0raklVLmGCgTeKo1xQLiZNg8qeSK89TZNL" +
    "eY0+saQul7DFXfgELMoF5ZI1Z/+fN0V4K932NEkuE+v1LOJqk0tY9NJnYyE8" +
    "Q7mgXLKKVqDcOtrTJLkMqNIrFi1yifoUCdwOu62RoiHIVJpGigYxePIQLQNz" +
    "/wa+fWLLSbUVb90S5clI4/cP2COVvz2BkAsGx4wjBjL9ITpWb5OAZ8yHPYmb" +
    "1iJu5nIBJmxCuaBc9HDqBYQMfYExjhyVC7zXWucirna5hAmmfyXKBeWSLv/y" +
    "Va+MizhPfEflMqwmG7FolUvY4i5UHOWCcklDKpdXMMZIDuQyOuSZFtX/HzJC" +
    "LlHTI/h05OT6GBooRLfz0CCIRB7wjE8pOvJMpa1KuGWhWVL51pmEXDeTsz8o" +
    "ErdVSJ8F+jzp2OagmFdFfXbToUzkEiYYaICJKBeUS0Kp/H5hjChyKBf6k6zF" +
    "74o5LZewz0XC+gvKBeUievfnx7/2yvAAhyhyJpehNdlOhzKTS9inYIGh1SgX" +
    "lAvfnZ/LJnjT6TdLTiiUy+eErbPong5lKheh9ReUS+7l8h8nE3L+YEKGvBBx" +
    "EqNcjjHBgHUWI+QSJpieXsNUbCJkYin18cD+pQT22cQB65j65FRQCJeBp0zU" +
    "PhUMWGmGHldSh5sWpjflOcWLUM7zhNJrBUcfy/SH4LipqI8nlTxZ/UUBrzbJ" +
    "ep3FGLmE3Z4uq0S55E0utEyE+xjlQoZUm7HOYoxcoqZH0FAoFzflAlMcEEn3" +
    "PxBy6QRCbl6ooI9zLpeRNeassxgllyjBjK5FuZgul55elPHNM/2ccn5BHEXO" +
    "G1QQyKDV8m2JcomWC7z8qecG88RijFyi1l9G1RUaz8emeCYwCD2ujgFr/03i" +
    "cJVLcH/huovWW0E5RestRZ143UTbagKFij5mlpHOs868dRYj5RK2/gKCGYdy" +
    "QbmgXAJyiRJL1ussRsol6vkXaMBxKBeUC8rFl1//SjPXWYyVS9T6i08wKBeU" +
    "S87lEnYRNk0sRsolSjBwixpekZkGYyh0HD+GwVgN5CVPZ6glZEClHWIxVi5R" +
    "goFX9aFcUC55ZWi1PWIxWi46BYNyQbmgWHImlyjBQEOjXFAueWFYxENyptxy" +
    "tlYuUYIZXF14yfBoilEUrO0yiOYZBjzD44OVL7X/aAV1Gy1B0rZIowzMNOtC" +
    "EE0z4fFSePmU14Y/JGe6WKyRy+SID2eDYFAuKBdX5RIlFpOeZbFeLnGCGVKN" +
    "ckG5uCcXuHDaLBar5BL1kF3xTXYoF5SLK3IZHLF4a5NYrJNLnGDgOZgRNSHU" +
    "UtRwwDomjTRZ++vIU7QMtSmVIWm5OYAPhZXCynMkA1XlihrftonFSrnETZH6" +
    "bSRkOMoF5WKpXMoq3RGLtXKJE0xvWjAoF5SLBXKJEouOz66iXARuU/sEg3JB" +
    "uRgsFxinYf9utuV2s9NyiRIMrLTDnaRyimEhlLOooaDTrGFTziBQJkaeoenw" +
    "7JOkDBJ5stLk6g/RNBX0h4q2YeUJv/V2VCzOyCVOMIOrUC4oF/PkAhe+KLG4" +
    "ck46I5cowRTvJKFcUC6myAUWaMOeYXFJLM7JJU4wfTaGD2SUC8pFl1yAfhEL" +
    "t66JxUm5xD0LA1eLQVUoF5SLfrkMjpkGuSgWZ+US9U7ez5+HqSzMeYsMpRjC" +
    "QHT/Y8dU+RlCw8qDsf8QiXKz6jFUphxVDDj2Z5aLasuh1eIwyyHY54EylaQB" +
    "T5D32ODWMyy5lgtrmgRXEZQLyiVtufSNiVZcuCOUa7nECQauJgOrUC4oF/Vy" +
    "gel3rw35mgblUi480ySUC8pFlVzyOg3KrVx4pkkDuq44CCKMJ5SBHr035Hca" +
    "lHu5xN1NKn7GBE8WRBQYNz1yPg1CuTD++Fi8ZQ0P3uFJg7CAKVDc2kqepkEo" +
    "F85pUnGqNBBPICSCPjF3gvIaraBcBBZ7i0/3whWqyACaKjalx/PAzKOSjXAe" +
    "HMezyiGaxwCOujLrIdHWwnWvOk6fyvgpUJ6jFZSLRBQDU6W+G1EueZZLWcx/" +
    "gjBaQbkklgzMr/ujXHInF9YUKG93glAuKU6VepdGMSgXJ+UCi/q9N+IUCOWS" +
    "QRRTjGRgutRPkDIK0f3LKjlg5VEZTxlHOQPb6XQk2oZVLuXphdCLEangFAjl" +
    "ok0yPQUlg3IxUy48UrH5vbYoF0unSiKSQbmYI5e+nFLBKRDKxRjJ9EG5GC0X" +
    "kArr7g9KBeVirGRgMbBXl2hE6M2gzwYONqYAI49AOQWP595HpIwU0B88UsHp" +
    "D8rFijWZYjTTC+WSiVx6cwoFpYJysVoyPboGem+US6py6d0VpfRAqaBc8iaZ" +
    "uGkTykW+HiJCwVvKKBcnX+8QEA1MneDZma4pVBy9Qui53k9gOyuN9X5YZegZ" +
    "cgwrT640GUQdJyIUlArKJZfRTDGi6YFyiZVLDxQKygXhf5cMr2zyJhfZ6ATX" +
    "UlAueDtbQjb0yeiaXGRlgs+moFyQBOszUWs2PUrXbiyRSw+KJG2A4wjlgihe" +
    "o8krOE5QLgjKRgn43hSUC2LgojDKBEG5INoXiLMGF2BRLghOq3CNBEG5IOlM" +
    "wfC5EQTlgiAIygVBEJQLgiAIygVBkGz4fzVdfv8G/WWoAAAAAElFTkSuQmCC")

RESET_ROLLOVER = ("data:image/png;base64," +
    "iVBORw0KGgoAAAANSUhEUgAAARcAAAEXCAYAAACH0wDUAAAp2ElEQVR42u2d" +
    "eRxWU/7Hf4NhFsaM3wxmMGaMH4bZSbYWinalokVohGhRImIypQgpJaJUpD2V" +
    "tEqJtIpSJEWpVCJFKNuY1+v8nm+3J89z7rn3LPfcc88593tfr88/z3PvWb/n" +
    "fc/53rP8zzJC/geFQqF0CwsBhUIhXFAoFMIFhUIhXLAQ8qb7hhNy28Pf67p7" +
    "CKneplwn1C/ceDpfvzg//Oylt5WHD8JyR7igPNHTc4JGDQ0dGrwIKEzp9Bbf" +
    "A2jwMwgehAvK6l6ITG/DVhV7QdjbQbigMoIJvPWhIboMEhkVgYP1j3BBaRQM" +
    "G9KEyemXE1LthnLd+lBYzy/5Xqz/6TBAafVuoDwAsmgfCBeUJEzAwapriAP+" +
    "jSIwej1RgMNiQnZ8Ssh33zH0XwUJhgFQemxikI7GtwbpQtggXFAGhjpJGhs0" +
    "sAuuJ6RVT0Ju6U/IzEWELH6TkK+/ldQ3lETuEXkmRms2BumFdIMgH0l6aQBl" +
    "BA3CJfdfc+CNqwqTRp0JuXtYoXFuUG/YNsAlDjoDnw6A+fuL1X01+DUK4ZIb" +
    "wZBH9s1cCpP9PZI0GrZFcImDjUrPBsodgI42iHDxSvClQ9aHAsODMpiINHKP" +
    "4UILygXKB6ArAxuoB/zyhHBx3jErM3ntF1UJufouQkbMIGT3lwL6Kqw9lEL3" +
    "cMLcQ4kVBzdMzv10HHtY6ZYME7RgBSGdHgzKUcbZjf4ZhItTUJHppVxyCyED" +
    "xhGyZbsgVBAuXAGgAdQyw07szSBcrP7iIwqVvzcnpMcQQlatlwQKwkUqTQBs" +
    "APf5rREyCBdH/SkiY/7f1wu67QtX7Gu4SYVwEU/TlwHIofyhHhAyCBcvoFL0" +
    "o4QaLsLFKFxKBf4Z0WETfGVCe0e4WAWVlt0JWfkOIbu+SEm7GeI88xklLfF+" +
    "YYF4aYooK6ifjn0J+XlVhAzCJWOoiLzpUocKwkUbXIratA0hg3DJaCYtz1EL" +
    "RgnGaQQqCBftcJGFDPRc8RM2wiWRePNUilABo8y8QSFcEsOlFDLdBxPyu3r8" +
    "eTLYThAuWodAAJUbHyBk/RZCduxC2aadn5UrSVh9R/Ehg1+WEC5C4g2BECr5" +
    "gktR/x4UP1yCoRIukkS4MMVboVzluoLhvI0NN69wAcFL5cpu/JXY2J4QLkKf" +
    "luFtNWwKNliEy/eaNBeHSggXjngbNLXrTcjaTYR8uNMT7eDIRJw7/RHYR9xQ" +
    "CYbYCJccfl6O661UvjbYltGnhoBwSUdL3yKk3k3xL6m8frbGL0HUEOiBER5C" +
    "BeGSuuCFdXzdaNsCnx7CJafDoHb3F4ZAG/1uAAgXM0MlHCblCC5xwyDorQya" +
    "FCzP16aPGBK5J+7+NJRCGrZS4sapek+SNDDi2EpJOg0l985cGN+LycswKdfD" +
    "oL80JWTxG4YaLcIlN3ABvbWekLod8z1Myu0wqO19HONDuCBcEsCl+MwdA/M7" +
    "TMrtMIhrfAgXhIsGuIDgXKY8DpO83MM2qhL/3ISQ+SsI2biN0geUtnFE3b+J" +
    "EuuZTbQEnol7fqMBbRKJl1d2smWrQx8ISDKdofoSyVfJ/2+8S0idDvnaysG7" +
    "M4GiKu+GeyWMEeGCcNEMl+I9cT5A3wDjPVgOr0LIwAmSxohwQbikBBfQtAWE" +
    "/LaO/9s4eL3oMHIYhHBBuGQIF9Ab6wL79Bkw3n4R+tNlhCxfQ8j6zeVaxxCs" +
    "di1V6J4tlDYraAtHm5OLzgc375w0hMITSbdsvrZoeCaFOJKWndA9hd+a3uHv" +
    "lyQvwVLrxgAsQkaCcEG4ZAiXOMDAF0+ESwaK+tTc9HZJI0G4IFwyhguodS//" +
    "AOM1WBAuCBdX4AK6e1j0lyQXd7nzBix3D1U0EoQLwsUSuPgGGC/AAucuw4pm" +
    "0BqeNjG00bzWUpL930QaVMKQDRM24wpJNl0Z1OdaDXmP0sS5wRQK1wHjNFig" +
    "AvqPSWiICBeEi2Vw4QEG4ZLyjvxQ8FABiQ0R4YJwsRAuRcCcdpm7Tl4nPzcX" +
    "waLUQBAuCBdH4BLXg3EBME7OY+k2mJBV6zPUOkoCz7xFifc/T6s80Vsa8m6i" +
    "bHTEoZrP8XPYgLF9op1za4UyBwvCBeFiGC5FwLi2VMApsNzU15JGgXBBuBiG" +
    "CwherC4BxpltKWFxomhDRrggXHyESxxgbNyuwYmNnhrdSsiKdwKtpLW2XMX7" +
    "IrWWIdln3tGgFNKwkiPZNNJlu1ecMEP/r+VIIa+68ymSBp6drVyrYIuK+udd" +
    "bgDGqq0pWQV2VkuOYSFcEC45gwsIXri2b5lp9SS5Uy8lZP7rCBeEC8JFBjAI" +
    "F84nZxZYEC4IF4RLuU5tbO8naisduD+rTMjIGYS8tpqht8u1bHW56P9VFAqT" +
    "kwbe8yrpSpqGvZJ9ZnUwiQ12Tdu2g5BPPifk893l+u6/JPLa81Xhnj3lgnBA" +
    "EC7svqZSLsso8f4PlT8rDJXylEgTs/wTxskK48VCIzq2lp3nIlnpZ4GzXkQr" +
    "BOGiBhdo7MWGDxCIg4buCyD06efB8a7FLR8RLmpwgd9HzrTT/2Kdn6XhLXIV" +
    "gnARM8YiTAAkNl7ffEvIx5+yYYNwiYcLqH1v+/wvVvlZ/lgYP774GsJFRxqg" +
    "gcLBXDCUcfEqwgb2kEG48OECqt7GLv+LVX6W4dMIeeXNci1JqlUCop4JpWGV" +
    "BtFxrCoX736RfL1aMLb3PyRk91fEqwuGbB99QsjqDRFlxykr+n5WeXPrXMVG" +
    "ktqqpC3PXkrIMRb5X7IhGqP71uXhcIUhXMTy9d5WQnZ+RnJxfV3o0XzwcfAF" +
    "B+ESFrygbfG/WOFnaXAzu4IRLtF6fW3wNjfpiLXtAsfwhq0IF/qZtvfZ4X8x" +
    "GhlrTHhKo6A7h3ARM0wYGgBU8CrvzcBwEIaFCJdA1a7P3v+S6bqhwyoTMnQK" +
    "IQtW7tMKvhZSWpCGVpaLF+fClZRE0knFwcsnLJDc9QWCJNY3813gxIZGFle2" +
    "OmxiwYr0FbKhlQLp2Pf7zMWE/KZmuM2Bv9M7uLCGQ50HyFdY3uCCUFGEzPYS" +
    "yOQQLiB4cWc5PMpsf5bzW6tVWF7gAp8ZESrJIQOzjfMKF9DlXcNtD9wT3sCF" +
    "NRyCnbUQLuG8w3gZuvZ46bt2fxn0APMIF/iNNTwycURJJpPlgKaqFeYzXGBD" +
    "5q+/QRikdcFyA4B33uDSb0w2G3ynGjh8W6czdXJDQuYtC/SSJZpHSfZ/3v28" +
    "Z8DgYTYqXulf//kuWAohW6cqNpHUbnTactXrzDt3jTtx+45CuJQKpreDweNl" +
    "9oKFk/AJOS9wGTMrcEeYdO4adeLWuyl54fkCF+iubsfeSua9mNXv5QMuoOb/" +
    "Mru5t1En7vT5CBcQLDL7Cn0r1lwwAS8PcAGxnLtpLQ0wdvzqtT0JmfMKpaUK" +
    "eoUjhedfoJQ4TTH3vrsZG7ONF2xFAc74F5YG0mF3L1Cak1Qs25WMo/dT5py7" +
    "RlY8n3TJvkabY7jAWwOn7ds/THpznd9wAdXpYObkACNO3Mcm5BsuABZbN2nC" +
    "K3y9vcFvuEx+iZDDKqXv3E2919L09pJGm0O4wCI5/Brk3gXLB3yFC+ianun3" +
    "XlLttQAdJ8wl5LnFEVpEabF+zaIUinORfDpmLSpXVDiLViJYXL42fxRjRxyb" +
    "mJWSPUvbe0yb+3WNdHsvqa56rn0jpzA8hgtsZoRg8WBW787gTe8jXG58IN3e" +
    "S6pfiJ6clk+4wJm+ePlzfbY7GHL4Bpe0ey/Z9Vo8hQuCJR+A8QUuV/dIb1lA" +
    "ar2WoZMJmbaA0vx4TWdI9pnQPVQaprMkGWcoDfvCgc+YPl2wjSSseVq3+Xu9" +
    "8W707mjrtnx/H+xz69t6KQDM80vYNjN9AV8hW+SEMW2+BnHa4LjnCTm0Ujrz" +
    "XlLptdRsL5Yxn+AC0/mdbjhfBHBYtoaQ+SvE6ku0juENCiCCT7wAnW//4245" +
    "wdlPPsEF1PjWdHov6fVacgQXAItrzlvolawv9DCWv114Gy/el2/J+pqm+sz8" +
    "4BzwvbDZ4R5gYLmAT3BJq/ei/TjW/b2WnMAFGokrYIEeAwxZIM3MsjMIl9Ln" +
    "Zy0JDnH7eJdDgNnmD1zS6r1o382/xxBCnp0XCGYC6tazHIXun1cunXHOWODG" +
    "VpSw1ePS1fL5FLpnHiVeHJz6AJ/GW+uDnpXtF0w3iCurpHaWRnuIen70TP29" +
    "F60rn//aLHlDdgkutoMFoPL8KxIN3wK4lAoar+2QefUtP+ACatRZ74pprfu1" +
    "lPZafIfLu+/bO/SBtM1eotDwLYNLKWS2f2Jvee8taw/gMniS3v1eUuu1+AwX" +
    "eFvZeAFUYKim3PAthUsxLlhOYWNPBnqwPsAFVKOtvkl12j4/X9+LkAkvxGsi" +
    "pQkpiBvHXIYkwpi50L5PqbBl48vLw+mWLW+V+uE9oztMANLajfYBBjZXT912" +
    "Dej+Efocu9ocuU9NywdcoCHb1CWHiXtR6fYRLsX/n1to3/44MJfHdbhAezjq" +
    "Ij3HwGoZEl3YJj3jtQkuayx6Y0LDgrd4XLp9hktRME/Hlp4kpAN6tq7DpcEt" +
    "4c4DTDtJHS6s40Ju7uc/XOCtZMu1dqNY3vMAFxCs+bGlRwnpcB0uAyfoWS2d" +
    "eEYufBtP03htgAv0EGx4O0Ia5i+PLru8wgU0pVBH72112/9iC1xAf2ma3LGb" +
    "eEhUv1MwfRg0lqNxlMam8Azv/nEKYa7ekL3BflJ4I06cK1Zm+zWrXEnLcpyG" +
    "8k4jjtI82vAlD14CU+er2bus7Y/jSDWOa+9OfgRs4rkt9z7pN1xganrWFxyc" +
    "NlbBOPMIFxDUWdY9TVh/5DJchk5JfoB9om0sT7hYb8O3ES6wE1nWYFExzDzD" +
    "pfhSyBowL73mLlxA1W5INjRKtEgRTnDzGS6vrs7WOGHVsKph5h0uRcB8kqGj" +
    "d/eXbsOlY99kywGE4XLpbeGIHhxNyMiZ0RpFaeQMjmbq16gZ5RKKt/Db+ELh" +
    "fpPhmw9ODSgrO06+9oouczrvOspKVpJxsvKRpP7HzyZk52fZ1SMswiyWxaiZ" +
    "8eK1H5FnErcP6v+fnqc+50XZkVvxKoGEOwyXLNcOgUFyDQ/hIqzJL2b7ooD4" +
    "XYULnO+uOjRShgvsvekrXMAYslwfJGR4CBdxzQjWXGUFGKhTV+HSc6j60Ej5" +
    "sDPekMhluGTVa4kCC8IlOVyyBgy8sFyEC2toBC4SbXCh1xIdWZ2Q4VPDgqNE" +
    "ShX6n9JwAdFh8sR9npGO0v9Hz8rG+HbuImRMIe7h0wKF8kVrKr98ueU1NV7D" +
    "p/HFC4Mbh4Y6l4lj8cps6hfWgPHqR8V2Q/UhWTYiOvNKtU2klIZEcJC1r3DJ" +
    "Ygf/b74NJsjFGQnCRQ9cQFnV8ejn3ITLZV3U/C5Kn6Db3ucnXKDXAkaQxXwI" +
    "npEgXPTBBbRzlwW9F0fg0v1xNb+Lkr/l0af9hEsWb7SiwSFczMIF1u6YfpGE" +
    "ei+OwAXCVfG7cOEC29yVBnp8XUKGTGZrKEdDno0X8xlOHKH/ny2XUBoL942Y" +
    "Yd7YduyKLsuQ6PJSuIdXNrL1OZQRpmydC+c/Jp88m4iKF1ZTm75WviPRXjSU" +
    "BbfOBdtg5Wvl/S7S/pZa7f2ESxaHmsE2gwiX7OACMr2S+vM9bsLlin/L+12k" +
    "/S2wnaWPcNm6Pbs3GMIlO7jAlHfTPdYZC92DCyxQlt3+Utrf8tBY/+ACU8RN" +
    "v72emo5wsQEuoKWGt2mA/V5cgwvoV9XlVklL+1sem1SiifEaRIl7/ySGJsbr" +
    "MVlNCuv1tWaNCw7+ki4bkfsnxddP0jiVyltDHGmnAfTxp2Ydu8Om6MmXbPsY" +
    "lECVrpEbGkn5W2q08xMun+82Z1hbPtLT0BEuegVHmpq85i13Dy4tuqYIlw59" +
    "/YMLbOln8oIdyhAu9sEFwgXwm9ynxzW43D1Uzu8i5W/hGa+LcDG5hWWx14Jw" +
    "sRMupnsvMOfFJbiA6PkuWuDyk3MJeWR8uR6mpPt/1j2yemRcuej/vzb4pQA+" +
    "PScpC564ZaG5bIXywSl/Zj7GUdKcxri8bzbYe1n0RrL601HnsjZ2SiNxp67w" +
    "YkUI1De4jDP4lQiMNs1KR7joaZTwAjB1rdvsHlwuais+mU54v1wI1De4wJsj" +
    "i14LwsVeuJjsvUCv2XW4xDl1hZ25PsLFlBF9tjv9Ske46GuUL75m7qUDh7+7" +
    "BJf2vVOACwTqG1xMXXDkKMLFHbg8/oxZ23AJLnc9Ln6ekfC0/1v6EdJ/TLz6" +
    "0RpdLt79/VU0mhIvTfs00eAnaJgwxc27ZD5C948Ol3dIY+IVCk+ljhTrI1Y8" +
    "O5L8X+QeUyvk4Xwj5bJVqGPZsmVJ9HO08GdokUhdgoupY0PgwPh+YxAursEF" +
    "tsQ0dbkGl+Nqi22/IHSMCATmG1zgjWHimrMU4eIiXOC3zwzN3IZetEtw+Vuz" +
    "cj7AMiFhuNCfoU9u6B9cTF2PTkC4uAqX1wz1bqEX7RJcRE9iFHLmXnA9IX1G" +
    "CGgkJcn7HxghL14crGdGTDc0JNopkdeRlDj/91GRQNnEpomRrlC+ePeL1Bmd" +
    "V1k7E7ArXlnAc1NfNmMnazexy1qpzcmWjYDoMBrfphEuEJhPcJliyGiWrkK4" +
    "uAwXU18U4Txyl+ByXS+NcGndyy+4wFGpRhYpvoxwcRkuIOh9mrhcggv8JvLF" +
    "SAgucOqaT3CBXeBMXDBHA+HiNlxMbST1+OQcwIU1x+W+J4Nt7kIaHi94LrGG" +
    "lysUz5NygjA3fmCmq0unPS4fof8Z6S4VM290OJyy5cUhIq5NcNJ4r0hZSNoV" +
    "zy5lbNPUWqOxs9TqXMTek4bBqmMluLDmuPgGl6+/Sd9YVryDcPEBLo9NMAMX" +
    "OLvKJbiceAnCJST43GbiWvImwsUHuIBM2YvLcGFNpMsdXMYaOgt67PMIF1/g" +
    "YmIYDXG4DBfWvi5cuBxTi5Cew4It7njqSYn3fxYa9ZwZuMCu6WV5H0aJU1Yq" +
    "CoU5jBL9DO9/hTjTyKdsHYs8LxOnid0K4fwklbLSURbcOCk7gfv+UF8DXP7Q" +
    "wC+4TDK0YDGUd4SLs3BZtDJ9e9m2Iwdwoaf++wYXExtEgaEgXPyBi6kV9C7B" +
    "pfI1CJdM4LJhK8LFJ7iMmolw4cGFtd0lHy6F7k/3wYR0U1B3SemIg/e/iTOh" +
    "4dgI2bLoloJky6a7hjqzIUwdaSp9/ilDa9FUbMJE2bDiPa8VfwkAFy4QCMIF" +
    "4YJwQbgkhssJ9REuCBeESxZwgU/FXsOFfsA3uEDDT/sCgCFc/IELyMQFEHMF" +
    "Llf+WwNczrmakK6PEvIvBXXlSDQMmJAGUGBqM6Ut8frKwNT/Tz4Pxwtn1JRK" +
    "9H/I+xNTC5pCaaq8VMpfdx13HVguHXHy4ugqks6BlKgwTVxQR9L54NyTVpu8" +
    "vKsncAGZ6HHYdr38erTxd1Vp2AgXhEuWcIH9MG2EC3wCM9HrsOXa+nG88SNc" +
    "zMEFGr2RT9HD3IELcCHx16J/XG4HXLoarOSsr6++JqTvKIRL3uCilA+X4XLC" +
    "xfbABQRDBd8vWFzJM36EC8LFebj8rh4hXQYE+zXQ6kJrQLl493PDY4VZ0Lvv" +
    "+wuWecv2lc2AcnV5WECc8g+FSYtTPyJ1qKXONYuZLomyGjLZTN1zy0qgzljt" +
    "Ja7OeTbCVOG+s1pSnZD6nsAFPo99+bWHfpbtJWWDcLEGLqYWu7oMF6VV0TbC" +
    "xeTbxKSfpfdTCBcb4fLSsvTrH3rjLsEFuJAYLj+vaidcTFW6qWv0c1TZIFys" +
    "gYuJYXgu4QK6uV9wED1X/csFz8UpdD9L9DOU3vHA/zL31XC+eWXJKn/ZsuPW" +
    "B6veJNN5c/94idiVUjpj7r9FwM5KteWj9G0A7JiXxltEJNlGeWXNrPPCb8fX" +
    "zQFc7nzUbf8LGK5Ko0W4mIOLqReMy3C57h4P4QIaPNFNsAAU7xmGcLEZLlA/" +
    "Jq7pC9yCy9EXaTq3yHa4gF581T24wEI11UaLcDEDlwlzzNjCoIluwUXbiYv/" +
    "vIuQDn3C6ti3XKH/KYXC6EupDz+MuDDhQG9XrheWUuXHKytO2XfsGy5PmbIT" +
    "rQ/ZOELi2IyIDfDS0EFBofLcF5aJnQuLn6G59dWXX0fSdiRwPyst2uDSsLMb" +
    "cIEKcsH/svmjaGNGuNgFlx27zNiEkK1bApcb7mUcPzRcES6wp4sLcAENfNp+" +
    "PwvsQYpwsR8uPYeYsQnocbsEl0ad+VP/heFyxhXuwAU0Z6m9cHlyGhsMCBf7" +
    "4DJ+thmbgKGXS3AR2YUuEi70EoDjahPS9v6w2kmqLUciz4Tu6V2u4n1rNtoH" +
    "ltlL1MtKtizbWhKmjjjSiFPkGRNbosraRdI2pcMG6G1ZpOAC36xLHzy8intw" +
    "AU+4Tf6X9z9MVlYIF/NwMWU/9w93Cy7Q2eBNoIuEC2uui2twAQ0YZ4+fpdsg" +
    "hItLcBkzy5xtqIIlK7gceSH/EPpIuLDmulzWxT24gJ5fkj1chj6bvKwQLmbh" +
    "snyNGdt4fY17cBH5DB0JF5ZT96K2hFzfK16tOZK9X+QZkf/f3pAdWGYtZqdT" +
    "Nl8h3ROWbFlmVR+y+Ugap2w+bnrQnH08M7ck70ltQrEsuHGU1E1jxpci6Iwk" +
    "gsvfm7sLl04FY9nzlXmwbNqm3rARLtnBZdKL5myk1zC34FKvo5gzNxYu9OFo" +
    "p17qLlxA/ceYBQvADLYERLi4B5ePPzVnI2V5dwAu0MlIDBf6c/Sxtd2GCwiG" +
    "KKauwc8ka9gIl2zgMnKmORtZ9rZ7cDm1MX97Sy5cWF+MWvUo1zU9KfUoV6ue" +
    "8ZK9v1XPcJyhNNGi7l/9XvpGM3MRI+1UOnn54uVDqKw0hCFbH7w6vUZAsmXH" +
    "tUuROPc9a6rXAteI6RxbFkm7ZHmrlF3p/cfUEvsMHQsXWCtAw+WKO92HS/ve" +
    "6fpfwM/SqifCxUW4PDbB7ND5xgfcg8shZ4t9KYqFC8upe8H17sMF7ukzMr0x" +
    "NCyeRLi4CRcTvdriNW+5gC1bBpfLbhdbsKgEl7829QMuoJkL9RvMYxNjGi3C" +
    "xWq4mO61QHyuwaXCleLOXC5c6DUEv6zmD1x0v6nAzxLbaBEu1sIFhicmfS3Q" +
    "w23Vwz24/P7ich784vwEcGE5dZvdQchV3fape7ladotX6H4B0c/sjzsqDbTo" +
    "dJT81+Y+Pf6XjR9w0tydX1bcshQpK17ZcOIMPc8QL13c5yXvv6qbgF1x4uDZ" +
    "FWwxafKC+K7qLl/+LQXsm1d2sv+Xxkv7W6Km/QvBhTU0Ovuf/sAFBGcFJX0L" +
    "de6PcHEVLt0Gm59cCXG6Bpd6N8n5W5TgclJDv+DSMuGb65HxAmlGuFgLl7fe" +
    "MwuW7Z/G2IXFcIE9nWT8LUJwoSfTHVbZP7ioGtne7m03hIurcBk/x3yv5cmp" +
    "bsKFPgSN528RggvL79LgZkJadCXkckotKF1+Z7xC97NEP0fHeWe5eGmK0nV3" +
    "y/lfNmzlpJuTD26a7uRI5JmuySRUZwnrWCUdSdMAgqUZpq/tn8jVuaotS9kR" +
    "HWdE+R1ylpy/RQgurKHRWVf5BxfQvU+I+1lu6otwcRUu8CKBhm76Gve8m3Cp" +
    "fWO4gwHLW1KBy/9d4idcQFNf5hvJgLEC6Ua4WAuXV1aZBwu8kABqLsLlH83l" +
    "/S3CcAn5XSr5CxfQqvXRRgLwEUo3wsVKuEDvIYuLZTeuwOXXNcQXK0rDhbXO" +
    "qG5HQpreHq8mlGTvb6IS5h2UFOJtdRchuxn+l/e27rvnjnI1VcxbkrJpmtIz" +
    "sWV5h4b60FA/0une9/vjz2QDlt37Js2lYSPSdsSzXUYd0W2fdS60MlyYSwGa" +
    "+QsX+O3uoWEDgUWPCBc34dJvdHa7EU6ZJ5ZXG+Fybis1f4sUXODTU2kER5zv" +
    "N1xAYBTFC4xz/z0IF6fgcvvD7J6o0V6Lo3A5sYGav0UKLvRxI6B6Hf2GC+jN" +
    "dYQ8O4+6B+HiDFxufyQ7sMA1epZ4Xm2DS6NbCTmY+gQN6w21w4U1NDqlESGN" +
    "b41WI0qNNagRRyrPx90Pk4h495vIZ+MUJJuvRoby1UhSUXHd+lABLF9mB5Y3" +
    "3jVvu9w4Oser9N5/tJCf8q8MF3pf3UPP8x8uKo0Q4ZI9XAZNzBYscAHcXIbL" +
    "sbXVh0TScGHN1q18LcIF4WIXXAAsWV/PvJSN7eqCS03GxDmRWbnKcGENjU64" +
    "GOGCcLEHLpNfyh4s0GO6spvbcPlzE/HzibTBhd5AChw+9W8O1EBS9TuVq8HN" +
    "GakTR3S6OUojTXRZqcQbup+OQyBvoTrjlFUq9cPIV/OuhKx8h1hxDZwgVj8m" +
    "7EY1nJ9XlV+omBgurAl1f2uOcEG4ZAeXOwdl718pXgtXituFrXCp2lp94lwi" +
    "uLCGRnDcAMIF4ZIFXCbNJdZcH+4MelCuw+WkS5I5chPBBRw7dOQXtkW4IFzM" +
    "weXfg4LGbNPVqZ+cXdgKl5+ep7aWSAtcwLFDw+WPjYP1RqWqQ6luB446alAH" +
    "/eLmI4V016HEK9s6ImHISiDdoTTQ/ydNA/U8zHZdsIJYd8EmUKnbpoHyP50x" +
    "tyXubCLtcGEtBwDaIVwQLmnBpUkXQibMsce3UnoB7IzYpoHyP76uniFRIriw" +
    "lgMA9RAuCBedcLEZKnv9LDuCafc+wOUChiM37rjW1ODCcuz+qjrCBeGiBy62" +
    "Q6V4dehj0DZTLv/j66ivgNYOF3oTqb1bYLZEuCBc1OFy75OEPLeIOHE9PN6w" +
    "baZY/qxei6ojVwtcWL0XOJWxZrtANSjVbE+pXQpqryBOmDXal4t+ns4nfb/I" +
    "M6E4ef+z4uDlQzbMdgJ5SxgmlEW73oSMn03IF18SZ67+Y+LzzSpvETuJq0+V" +
    "+hAN87jaenstWuDC6r1UuALhgnCJDhNWmkPjnLGQkG07iHMXgJCXb5fgAusD" +
    "dfdatMAlrveCcEG4wHk8XR4mZOiUoFG6CJPSC4BYo51fcDnh4mRbK6QKl6je" +
    "C8LFb7jsPVhsdrmg8b2+JpBvVxRYXIZLtRsI+WHF5OuIUoMLa1LdsbWCz1hl" +
    "ukFe1dqUK/Q/JW6YbRTSxbmfTgOd5moKeZfOl2A64lRdQKXhd36I5OZavibe" +
    "JqrdkI2S2g19kmKSSXOpwIW1kRQINvdFuCBcXL/g2F6eTbgIl6rXpddr0QoX" +
    "8Cxzey8IF4SLD2DxBC5p9lq0wkWo94JwQbg4dA2ZLG4TrsEl7V6Ldriwei9H" +
    "Vg8yoqoqHFW1QCppSpovG8qi04P+gqXPSLk6TqM+dIQXFcZv66Tba9EOl6je" +
    "y2mXIlwQLm5cX+whpNtg+Tp2CS4wi55uo0kWKBqDC6v38uNzCDmvFcIF4WL3" +
    "tXZTcFi8Sh27BJcjzk+/15IKXKLmvUA3DOGCcLH1goPiYS2Oah27AhcYRaQx" +
    "G9cYXFizdkFntCj0YK4uUStPdLWAqGfOvbpcvDjOpSSSLtlnZO/v2Md9qHxe" +
    "GAbd/xS/vrj/p2A3dH3QNnOuZDpgOHRQxeS7+mcOF9YZR7CjOMIF4WLLtWYj" +
    "IVf32JfXHMCFdchZkv1aMoNLlHMXjoBFuCBcsr5GzgyWYezPq+dwgRM6TDhx" +
    "jcGFtSzgR+cUumdXIVwQLhk5bTcG6Q7l1XO40OcQpeXENQaXKOfub2oSUrFl" +
    "MAYs01VhVaREP1ORUiiMlslVkSNWunnp4IapkCbpZzhly8tT+/vd8q088nR0" +
    "WXHLkmdXCnWuxTYF6pC16jktJ65RuEQ5d//UBOGCcDFzvfAqIZd0ji8rX+EC" +
    "uxMcdKbZ4ZBRuLCcu4dXQbggXNK9tm4PdrkTKStf4XJMzeQHylsNlyjnLmQc" +
    "4YJwSQMqsBevTPn6CBfWyYm61w9ZAZeo4dHJDYP5L6DTGTrjCkotKFH/h54X" +
    "ER0GJV4cQnFy4uDFqZIPbr5aJFObe+2CyiurAielUn44ZSd9v0oYCjYTFddf" +
    "mrKHQ2k7cTODC+usIyiAvzdHuCBckkGlzX2SZeU5XOgjWYvnihntTJiMDMQ6" +
    "LvJnlREuCBf5rz+TXqSggnDZq1/XyHY4lBlcWEfBgqBAEC4IF941Zykh9wwj" +
    "5PzWEo04R3D5Q332ZLm0pvhbBxfYWZxVACc1RLggXMLX2xsIGTCOkPqdFBtx" +
    "TuBig58lc7iA4HMYy//y5yaE/K1ZiZpTasaR7P0iz6iEmUUcHP2VUtJ8tO6V" +
    "3pBn9iuE9B9LSLN/MdLdPLmky4J+nlIqcUrqJ+dm72exAi5Rn6cPq4xwyRtc" +
    "Pt9dgMmS4KC0ZncINEqES0hHXWiHn8UauER9noaCQrj4CZfV7wUgeWIKIT2G" +
    "FMK4R6AhI1xixdpoOys/i1VwifK/nFgf4WI7XGDIsmRVuYrgKAp6IwAQOARd" +
    "tawQLtE6tbFdfhar4BLlfznwzAAwf7pMr05jSPYZbjxNGJJNK+f505qElTRM" +
    "LXEkLbuMwjSh0ziSDQ/AAlvI2uRnsQ4uUf4XAAwUIMIF4YJwEQNL1n4WK+ES" +
    "Nf8FClAnYBAuCBcf4AILf230s1gLF9bJAboBg3BBuLgOF9bu/SBoPza1Z6vg" +
    "EgcYWCIAW2Ry1ZCSwDMnUzpFUqHnG/LTcTJHpxhQXuLUZSeZqyF7RzkQrNuz" +
    "rS1bB5e4L0hQsAgXhEte4XL0Re6AxVq4RK2gFgIMwgXh4iFcjq7Bbg+mNn7y" +
    "Ci5xgIGCRrggXPICl2NqsduBLZ+cnYRL1AbfoF9VD1aAnthATvAMrdB99Skl" +
    "/V8hnWnEEcq3Qhzay05EnDCk88UKo0G8pOtLg23Cb8fVIeTACu6BxQm4RO0B" +
    "UwQMwgXh4itcosBi01wW5+ESB5gjL0S4IFz8gwu8OF0Gi1NwiZpkVzxJAOGC" +
    "cPEFLgAWlp27BBbn4BIHmMMqEfK7ugzVo1RXQJxnjq9XLpE4uM9QUomDF6Z0" +
    "vuslDzOUj7oa0pGw/pTiUCib4+uWSyTvURPkXAOLk3CJGyLBpsS/rYNwQbi4" +
    "CRd4QfoCFmfhEgeYQ86iAINwQbg4AJcosJg4dhXhIvGZugwwCBeEi8VwATtl" +
    "rW525XOzt3CJm2h3QIVgR7tja2lQbUqc/2HSE61jdau2QLpEnolJN+9+kbLg" +
    "pSmVspItFw11LpK30P81CTn4LD/B4gVceIABzzvCBeFiG1zgxRcFFlvXCuUS" +
    "LnGLHYsrqhEuCBdb4AIO2gMq+A0Wr+ASt10D6EdnB91QhAvCJSu4gP0del60" +
    "jdqw7y3ChQOYqLkwysMkhAvCJSFcjowZBtm40RPCRXJP3qIOrRSsrI7SUZRg" +
    "H41Y0WFcpEFZhKkSJ+eZoygdnUPBDPKoYRC8CG3amhLhkuBUgf2fq8/eZ+wI" +
    "F4RLSgKnLesURJ++COUWLjxHL7xNjrgA4YJw0a9fViPkhxXz41/JJVxUhkkI" +
    "F4QLDoMQLtqGSeBsgy004Y2TG13Akcgz1VDFcjmiajA7PK/DoFzDpThMivqa" +
    "BIIx8v9egHBBuMjpJ+cUeitn5HsYlHu48BY+Fk96hIl3CBeEC08wBDooxrfi" +
    "6opmhEtKywZKh0qwvwbCBeFCC3q3Pzon3n5gYW2e21eu4SLi7N07u7dgRIdX" +
    "DXwyyqpCqWoKqiKpqm7ocEpZ5+PHnCEQ9FZ8nBSHcFEUjInjAAP7mcJmVAiX" +
    "/MLlsMJQ+aAz4+3Ep7VBCBdDe8SUDpV+VgXhkie4QJy8IVDevgQhXBQF8xB4" +
    "QyWY4SsFGYSLc3CB+oV65g2B4AskthuEi9ahEghmYf743GAi3n6dp0GVOGFW" +
    "UpBsGGmkWyWMpGFKlhMMf+Nm1+IQCOFibKgEgrH4fsggXJyEiyhUXN7XFuFi" +
    "6VYOvKHSfsicg3BxCS7wUhCBCgyB8jgZDuFiIWRggyqEi71wAajwvv4gVBAu" +
    "1kIGnIHwVjzknOCLg6oOoQTg4ko2nrM1SDZMkXRozgfUx4EVxIY/OF8F4ZLp" +
    "lyURn0xxWcEPz0K4ZAGXgyuK9VIQKggXZx2/oB+cERj6wWcjXNKEC6xQhnL+" +
    "wRkIFYRLziBTHDYdJDBsQriIQxiGPQdUEK8DqK+87LGCcPFoYWTc9g6sHg34" +
    "AuBtC8Ap05mUKgrck1QVBcR7RiUOhXTCkFMGKDhPBeHijV8mbqOqKNBAYznw" +
    "TIQLSwBhKB/RIU9pLwWHPggXbzerittLhgubCvmEiypMir4UnKKPcMnd8gKR" +
    "z9lCPRvP4FIc5qjApDg3BYc9CBeUgn8myjl8QAWqh2M5XIoQOaBCMpgUBcNP" +
    "dM4iXFAxQyeZL055FpQTzp5FuKASDJ8QNt/vmwLlgb0ThAsqJdioOIURJiiE" +
    "C0p6GFXs3ag6iLMW+JuKQxwc5iBcUA7Mr4GGCs5iW4ZVkA5wumJvBOGCygF8" +
    "aAEASkUPwaB3RN/DCgfhgXBBoVAohAsKhUK4oFAohAsKhULp1f8DGChghaO1" +
    "SZQAAAAASUVORK5CYII=")

RESET_DISABLED = ("data:image/png;base64," +
    "iVBORw0KGgoAAAANSUhEUgAAARcAAAEXCAYAAACH0wDUAAAsNElEQVR42u2d" +
    "aVvVOtuG3///Dx4VB5BBBUFERRRBmbfCRiaRQSYFlEEQBBXdfXsVFzR30qZd" +
    "q02b9u5xnB9gtWmmnk3SNvm/N47zfwzDMEnDmcAwDMuFYRiWC8MwLBfOhLLz" +
    "6tUr59GjRwLNzc3O//73Py03b96Ujn327JnD+cpwJhQcXOi44KOIwhT3799n" +
    "AbFcGFuI09rIK5VWEJcny4XJsDWCC9FmkcSBhcNyYSyUSVtbm9PV1SUwOjbm" +
    "MTY6esHHjQ2PDZdR928KDQOk1brhLhXLhalhgDWpLk5FHhDAv//+68nh9PTU" +
    "+fPnj8x//wn85/6P8kcHCePPf388Nj5uOLNzs660Rj05tN1vY9mwXBgTYJCz" +
    "lgsMAnn58qUnkfX1defz58/O79+/k+dM5Oy3CN1f9/v+16/OmhvfETfeI39b" +
    "QLW00iBlrk8sF+7uuHfcamXS09PjTExMOF/dizMViRiSy1nAPkjX7OysJ8xq" +
    "W3E8VsNyKV2XJ+6d2S+Tz5+33YvvzKxQMpALxS+balo2yHeufyyXQhL37ovu" +
    "gSgTSrnkQo/Zdrt9yB9IN45suNvEcinMuydxWif9/S+dhYVF59evM5df4ZzJ" +
    "nJ2dhaIL84ygPAfdR+JM5EyEHl9NPGmYYGt72xkZGYklGoxzcT1luRS2lYI7" +
    "78zMjHN8/J1cmCyXOHLxs7Cw4Iq6P5bYud6yXAohFTweHh8fd/b394MvSpZL" +
    "1XKp7Hd8fOyJu+thF0uG5WInUZrizU1NXrN9e2sr2kXJcqlZLpfpOvNEjvxv" +
    "bmpmybBciiEVNM/RTI99UbJcEpWLn+2t7cjdJn7KxHLJoVT6nL29Xefnzx8e" +
    "PyR+ClT2C95f5Kd3jIi0zw/CTwo5/ofITxX0vPQcmv2ltPz4qeCHgC7ect79" +
    "JCjy0A13d3fXGR4ejjQIzJJhuaRKlDtdf58oFZZLfuVS4du3bywZlks+B2pR" +
    "KVE599w7ofoiZrnkWS4e7n7fjo4iSYbHZFguqb+nUpHKkXvnC7+IWS42yKUC" +
    "JPPmzbjT1NTE78mwXMx2gSCVoaEh5/Dw0PvCmCkCPwjn/5+amtJKhq8Xlksi" +
    "XSCWSrnkUuHNmzeh3SXuKrFcqv5C+eHDh87Ozg5fhCWVC8BNpa+vj7/EZrkk" +
    "82gZv83Pz/PFx3K54MOHD9xVYrnUNkHT4NCg8/Xgq3NyckL4LvDd/Z+W7yI0" +
    "jJPvlBOB7955LjlRQM+h5zuB/K5Mx3cNmnOc6JHym+aFNt4kvO8nCsT8ltMa" +
    "HgbOOzg4GNpVKvsX2NxaUdDZ2elNyxhY2VkuLJe/58aMf93d3dyKYbmEPwmC" +
    "cN6+fauv7CwXlguJw/JyeFepjPP8cjeo0gVym7iY7Ux1AbBcWC5R4zA4OMTd" +
    "pLLJJagbhP/Pzc15n+enydHxkcDxEeVYBPsIHKePFIfk033k/U/DkUgmeaEr" +
    "PynvLstyfW3NaWpsLH03qdTdoNbWVmd7ezubyslyKaxcwP7eXuhYTBm6SaXu" +
    "BmVaOVkuhZaLh/v/f/75p7TdJO4GsVxYLinKBWAdqbDBXpZLAbpB9+7dc7a2" +
    "trxP7EWORI4I38LBh4t+vh3JHHn7BSPFiR7vxkPkmwJxHxqm9px0f+mcR3La" +
    "NPGO/XtA/ol5IRK3vL4p007rQHj5yXGW641//z23m/TkyZNSTeVQuDWBggpv" +
    "YGAg5EJiubBc0pXL0d8wx8bGSiOYwovlxo0b3mJa4RcSy4XlYkYuYG1tzWkM" +
    "eJpUpGkcCv3RYXA3iOXCcslOLgDdJNTPIgumsE+EUHC7Ozvel6wCBwroPocH" +
    "BPH3gwPCocjhwYGM5hwHBCkO2vD0SPHUcqCIJw1HE28p/6tIR9xjIux/oEFZ" +
    "T0LrTLT8o3nT29tb2CdJhRTLk8ePz8WiqlgsF5ZLjuQSJhjb54gp3KPm3ufP" +
    "wysWy4XlkjO5ADxwKJpgiiUW9w6grVgsF5ZLDuUCJiYmCvUuTGHEgoKJVLFY" +
    "LiyXnMqlaIIphFiw7jK+aI7EgYKvZeWAYD4OB+55KbHDKVh5YqY7vEJhu2Cs" +
    "FgsKYHp6uraKyHJhubBgyisX1Yz8yHgUQM0VkeXCcsmxYFTvwtgyyGvl4+aq" +
    "xcJyYbkUpAVjg2CsfI8Fa8js7e97YN6MULCPj739PZm9fYH9/T0B+rsECW9f" +
    "hS6eOK8f6XjyuyKMSp5cQuNF8gLHhKA+B807wr4Gmtd7e/HZD0eXD1HyQhcH" +
    "XR1QnlNTN2kZV+K/vLysFEzeX7Sz7lshv1hYLiyXMsilIhjbPhWwSiwjwyNS" +
    "xWG5sFzKIBeAG6tNgrFmPhZ8nKjKcJYLy6UsckHaggSTx+karBHL7u5uMuwo" +
    "iHnMzq5IEvFKI8w8xmFnRyRSGe1awI65ePf391shmNyLpaOjI/tKwHJhueRI" +
    "LiBomhGWS8SX5O7evevNx8JyYbmwXOwTTG4fOaciFpYLy6VAcgG4TvL6iDqX" +
    "3SE8019YWHC+fPmiYEdgx/2fny87hC96dnZ2RGiY5JwSOyI7X2SkeO3shCLH" +
    "ITwfVPHQ5h1JN/6Hl+kwExtWEfzx44fz8+dPgT9//jhB29mvX9L+lRUJ8XLb" +
    "7t5uhHSp4vlFQJdXUZDzL2YdkfIuSl3T1SNd3ZWP+bS56dy+fTuX6yLlcpwF" +
    "a71ELSCWS3VygUQqF75OGklvkBDEhXNjikjcgVku1ckF6V9YXMxl9yh34yw9" +
    "PT2xCojlEk0ulXWwIZI8br9///bWhT6XzR7LZSdemQ8NDeVOMLkbZ/n06RPL" +
    "JQG57O7teRNq51Um0WRz6s1xwnKJVuZdjx7lavwlV+Ms79+/dz5//iyyLbJN" +
    "oPvrfldCzhHpGP85CdH22SbQ/bcFPm+LbCvCRAWEUH653Y4ibeiynXw/8V40" +
    "U5YPyRtd3irLQwojXhnT8toOOG+sukrrviYeHz9+zNX4S27GWbBYVJQLn+Ui" +
    "ywV399PTU6cM2++z394SqWgtsFzkY3CDzkv3KBfjLE+fPg0uDJaLUi64uL6f" +
    "nBgdiM3bhhYaxMpy8Ye57QwODuZCMEZP9kjRJ7xz546z8XGD5RJRLuganHz/" +
    "7vDmb82ceYvRfalIouRyAV1dXZmPv2Q+zjL/ft7Z2t46Z0vP9ta2QJRj0mZ7" +
    "WySRMAn4mA6Pb3kLH5vBmBMurvTLfZuQfBi0DlxcJ35omH//v76xrhx/KaRc" +
    "VN2h0bHR8IxiuXhfz7JU8iiZfMsF4MadZfcos/lZHj58qM+oEssFj0tZKrVL" +
    "Bu/NlFUu4MWLF9K1h+GJwshF1R3CzFosF1VY295dl7dkB37RrSyjXPC/rLpH" +
    "mbwsB5sGZUSZ5YK3aM/OztgGKW14Qzm5rpI9csHyO1lM8G281YKnQ5ufPnl8" +
    "2hTZ3NzU8kmChPNJZJPwSRGGtM+nTYFNL26X0HNI+6uQ0nEZZzxZwKvvvJnp" +
    "Kh0cHEjl82lTg1SvyPGf9HVPqgOaeiahClNXz/6GjWEI060X44O4U2/fslx8" +
    "8cZ7GmV+VyWrDeNZeLxbFrksLi4pVxCwUi6qQdzu7m5yoZdXLptbm9xayUEr" +
    "BnPVlkEuoLe31+jk3kYHcddWV1kuLni7lsdW8rMdfTsqhVyAycFdY8uvvnz5" +
    "0vn4cYPwUcsGQdpng/CxGuLFi8ZpY0Mk7Fj093nL34avxzH4GVh2pJ7FKfPI" +
    "dVnHRvz6Ts85OTlpbHDXSKulpaXlb0aUVy64k3E3KP/dJDyyLrJc8L8nT54Y" +
    "WTnAyCDu7OxsqeUCsdg6r0oZN3y/VWS5rKysONevX0+9e5R6q+X58+e+jCif" +
    "XPAxGT8Nsm/DtA5FlQvAMEXarZdUWy2w44cPH5z19fVzNjZE1inrMhsEegz9" +
    "nZxjww3Dj/Ic2jBFdGFurG944CU/FovFA71HR756JBJU5sI+Un0nxyBcH9q6" +
    "vxEhzEj1/ZyGhoZUWy+ptlrQtxMzqzxywdISLJZivNXr3fULKBfVvLtJtl5S" +
    "fUKEWbHKKBe8O8FbsZ4keV2hgskl7daLuVZLSeSCpw28FV8wRZGLat3pXMlF" +
    "1Wp5Nz/vrK2thbNKWZXRHiOySlhbWyWsaaFhrLrH+VkLYG9vt1AXFNYXOj05" +
    "cQ4PDi7Ash9Bs6fhUwa8xwMwIFq0R+8QDCRwXg819TQKtP5Kv4vnWEXdJOjC" +
    "1O2/vLQsPTlK6r2XVFotjx8/Vie8wHLZ2tq0+8L58dM5cOWAJSo2t7bOy09R" +
    "HnL+0rxbFXH/hzsspmTcx9pJx9+dP7/tHYvCGEyR5IJ9VGtO50IuQa2WMskF" +
    "Yvnz57dVF8mvX2duS+TQW1MJTXhlRUxILmKY52xtbjlf97FQ27GVT5GKJJe0" +
    "Wi+ptVrKIhebxPL7N6YbOHQ23Qt7dTVCRUxRLpcX1Krb1Vj3upSnp/Z0ozAh" +
    "eFHkklbrJfHZ/Ccmxt1KteKxsrJKWKmC1VBW3X38SMevEpTh6M4p/l4517pb" +
    "ODZMRYmpHjEmostrbV4mgVQeIhjTwKC4DQu74QPUlbTyqUqqLcPFxcXEWy+J" +
    "tlpaW1svxFIGueRdLJAKLta0K2aScvGDizfvkokibRvkArBOe5Ktl0Tna/G3" +
    "Wooul7x+3Yw1lhG3OFLJq1z8ksnrkyfkdzV5nUe5zM3NJTrfS2qtliLLBYtv" +
    "5XGDVNCPzqJipimXCpgSIY8tGbRgiyAXoBrqyFwuA68GnOUPHwQ+LIez/GFZ" +
    "AN8hUZaXCdIxcfmgh8bTx9raune3ylvlxsRAuvzW5W2U/JOOWV4WkMpHV+bL" +
    "Cuh5fcevurLHROZ52xAnud4sh6O7XqS8l5Hzl0LKRLqeRCbfTmYrF5XdFt4v" +
    "lEIueRpngeQw+BkU7yLK5cPfc2IwPW/L2mJOXtvlgn3oJwHVLgObSKsFslEl" +
    "rGhyydMdE2MQeNQbFu8iy6UCFo/LS0sS8Vh3W7a2y+Vpz9NEWi+JyGVkZKTw" +
    "csGr7rlqgkeIdxnkAvDNT15alIiH7XKZmZ1J5Gvpmt/I9eZsCUhYUeSCQd08" +
    "3B0RB29sJWK8yyKXylgMvm3K0/iLrXIBeEBTa+ul5lbL06dPnaWlJY9FwpLE" +
    "ImHJCjDtYS7uiG7hx4r7ImHJVjT1xpfGL5+/5OImgC4rjaf++sgPqldNUpWL" +
    "6oT//vtvoeWCdxiy3g4PD6qLfwnlAlBmWbc08f2RzXKZn5+veQH7mqaxRBcp" +
    "XubZJ5fvGT+ROBfLIsslhlwqN4WsBYOJ2W2VC+jq6qqp9VJTlwgruBVZLl++" +
    "ZNvERnesprwqsVwqgslyoBcv/Nksl+HhYTNyUX01OTU97SwsLgaySFhYWNCw" +
    "KLO4EI50jBjmIkF9DsICKvBypnc+vDOx6MajAo3zopKFUOS80+VVxDIKyf+4" +
    "5/RYFNGXeXCdWVpeck5PTzMrR7yHdJFWek2Q8qPp1OXLed7Q+hvvepHiQKAf" +
    "M8Z556XqVkt7e3uoWGyXS5bfDu27FVJX6CyXaHIBHz6sZHqjwEC8rXLB+u7V" +
    "tl6qlgvm3iyqXFAZs/w+6DyuLJek5IL/ZfnZBsrUVrmMj0+Yl8vU1FRh5ZJV" +
    "q+VSLCyXpOWStWDQerFRLqquEYZIEpML/Zaovr7eef9+3ls6xM+8+z8/7+ff" +
    "C8y/F6G/0/CioD9n+O/0vCj0LDaMC+Dc1eTBBbr89srsknns40faPwUSKHNt" +
    "OubnBfznw0J12Yy97CryO971IqdTnzfv5wlSeWh+d8EQSDWTSFW9bEhR5ZLF" +
    "0iC4m+LOlvSFy3KR5QL2drMpY7QCbJQLlmSupmtUlVwGBwcKKRe0HLJoNuN9" +
    "iDQuXJaLWi4giydIWJbFRrmMj4+bk8vs7Ewh5ZJFqwXnTOvCZbkEywXf4Zi+" +
    "kUitF0vkAqoZd9GKBdPc+QNtampy3r1795d5gXn3f37eUeYJ71KginMgrgtu" +
    "BpqubLh7JpquhPN3XoFuH22c3AosoDz3PIGGGSWMsDic///jx48ZtF52o+ed" +
    "lA8KSLqkMLV1IvwarsSrs7Mz9rhLVUuHFFEumELR9IZpBVku2ckFmP6SGqs2" +
    "2iiXvr6+2F2j+NNZDgwUUi5YfjSrOxjLJTu54DV30y1WzHNsm1zwgXLqcpme" +
    "ni6cXJbdCmb67oV+LMsle7mAz4YnXMd8L7bJBeAVlDhfSccab2lsanJm5+Yu" +
    "mZ0lzAnMScwKCGG5zM3NysyGI8WBhEnjNDs3K4GlK0xu+KBuTpk/l8h5IyKl" +
    "a1aVf3OhyHmjLw/dPrOzOmicFfGi56gxr6Kkw+TSJWgp4ULW1mVN+SjLSLrG" +
    "RKRraC4K5/lIx110rZd4c+U+flxIuaAlYWyej+Ojv4XMcsmTXDC5k9nXDzat" +
    "k8uLFy/Sk8vQ8HDh5IIp/UxuqMQsl/zJBf87dsVvbp6eQ+vkMjExkZ5c5AvX" +
    "frmYnMKy0mphueRTLqZbL/heyCa5APq+SyJyqaurc2ZmZmIyTZjJHSafFODR" +
    "cx7zgLmsq5ie0tS2vb1tXT7duXMn8qBu5I8VEWjR5LJk8CkRKi1fwPmXy8rK" +
    "B6NfwduWT9QLYS/TRZ4vF4EWTS64c3CrhaF11VTrBa1m2+US1jWKtapi0eRi" +
    "qhLhaRRfvPbI5dOnj3zTCWBoaCh5uSDQosnF1IaJvvnitUcuGMTkuqEmzhfS" +
    "MZZsHXWmpqYFpqemBDBhtwD+50Pan/7uHqNjanpKYNqLxyU0jkFxwvwppjZ8" +
    "mTuNuPqQ82Y6FJqOaWV+TodD8i5u+ZyXkQapTlBoWiLso6t3MX/39qH1iqTT" +
    "1BfyaD1f1GWpvtO8VdQLqYw0ZS7VgfB8UZG4XJQFZLFcTC0bgjc/zwuN5WKT" +
    "XPD9j6nNNrk0NjZGmn4h0jIiCKxocjE13oLP+lku9skFeW7qzW20om2SS2tr" +
    "m+AHfCYUWS6qx9BFk4upDS9DsVzslIup1i3OY5NcurqiPTGK1CXq6nrovH37" +
    "VmaSoPtds//kpIx8zKQGfZjv3y8YqTRYClaZb1HyTmIydtrjlsfk2wjQ8tHl" +
    "PyF+uqvJmyj1alJEEa6pN3bxlXSk8jOCvp49e9aTnFwQWJHksrJiptLgU36W" +
    "i71yMfVE8fwmZI9cBgZeJScXBFYkuZiavwN3PpaLvXIBuPBNbDbJBSQml4mJ" +
    "8ULJBbPAmdhw52O52C0XUzeid+/myikXTHEXiUnCv5OEf+MzqUEbhhyHb9++" +
    "GWnq+uM56VZgP/HToWeSkEj+x81fTbqkfIhUByZFtOlOIi8nPfAGrZEvpBcX" +
    "UymfSjoqRLk+ouzDcgnImLOzs9Qry87uDsulAHLBlA5mJo/6ZJVcWlpaWC40" +
    "DqYeQ29/3ma5FEAuwNT0CzbLRfUiXenkYmot6MWlRZZLQeRiohuNc9gsF9W8" +
    "Llq53L592xmfmHAmxsdlJkTwUZOfifEJAfo7wo2NFAaF7i+yuLhgaIDunTct" +
    "YAVdPCckSP6SvFSVhz5MDeMRmBgPRVdeccNT1isSb5q30u/jMvq6fLmvidkK" +
    "Me2lnDe0fBRlTtMm5YWmfDR5pwL7Nbc01y6XZtdQRZLLB0Nz5uouAJaLPXLZ" +
    "2kp/3h88ACi8XOir/0WTy/b2lpmKwnIpjFyWl818QW+TXOgyIywXQ3Lxmrgs" +
    "l8LIBYvHs1zC5aKa7lIvl+Zm582bN4XBxJrQkEuR8qzsYHVME5tNefLgwQPt" +
    "uy5auSAQlgvLheXCcqlZLmipsFxYLox5ueARb6HlQg8omlxw4ae9QWB8URYL" +
    "ExskZkt+9PX1JSGXDuf163+cf1T8Q3lNEH9HOH7+ef1a5B+Z1+5xS4uLzuHB" +
    "QVUcHIqYePX/9MepdN6Dg0MBKZ6Ew8NzlpYWvTl4k0DOfx2vFWVEy/S1gFwn" +
    "yP5emV6irlekHujqHYnja+88Pl6riBdvU3Mti3klEnR9hKEtU01eniOGgfyK" +
    "sm60FXIBuADLtm1ubl7mlSYvPTQVi+XCcslULpgPM49ywWM3E62OvGzHx8di" +
    "XrFcMpMLLnoTGx6z2yKXRJ4WtbW15UIurw0WctYbJIq5NVgu5ZKLnFcFlwue" +
    "HuVFLgBdhaJv+LhSyiuWC8ulaHJpampyxsbGojEqMjomQvfX/X4e5ihhzBvw" +
    "LOqGeT1UeVld/o8KRC7Hi/IZrTmMqsrcO4+fseTR5a/vt3dz74yUfXVpIXml" +
    "rQO15y3Krb2jQ37ZtghyefP6TSHHXzDOErnys1yMycXU6pw2y6Wqr6LzKBeT" +
    "dxOT4yyY34Tlkj+5oDWZ9obWuE1ygRdqlgs+SMqjXEwVuslxlliVn+ViTC4m" +
    "uuGllEtlEfpRBSMjIxpGCeT3UYK0v/4cRRh/wZKv+rzU5W2UvIu7v57RUZFq" +
    "wohdb5JAqnvBmFj6F/VYG8fRePFW5eUoyiyEqHlVCrlghNvm8RdU3GQuQJZL" +
    "WnLJ7AZjkVxevXpVPLkArMds6zgL5sdgueRXLigfE9va2ppVcmloaEhm9v+8" +
    "ywXA/LZt+FAtuQuQ5ZKGXJaXzUyLihukTXJJbN2i/v5+Z2h4WGKYMjQkotrH" +
    "x9DwEEFxjiGCFMYlWNDbpnGWsLzT5c3w8JAEPUYqj5jniMJwjQwhHhpoHdDV" +
    "kShxlM4xrMbEzIXYRkfH5LquSddQlHRo847UCVX+K8JMTC49PT1WyAWj2DaM" +
    "v2CcRZd3LJd8yOX09NRInRjSiCVPchkYGEhOLnjV1wa5gJmcj79AfuPjb1gu" +
    "FsgF5WRiQ4vbJrmgsZGYXPCltC1yARs5Hn95/37+byGxXPIul6WlJSN1AkuX" +
    "2CSXKN8VBcqFfgLQ2NjoDA4OahkiDGZIHsdfNjY2Ms2TspBUPTQxJaqN9YJO" +
    "yxJLLnhm7T/wxo0b1skFI9p5Gn/BOAtf+HbJxVT9wdy5NuUvGhu6F+gC5aLq" +
    "GtkmFzA9PZ2bcRZ8ps4Xvj1yMbWmOOqGbflbX1+vXYQ+llyeP39unVwAmpxZ" +
    "b1g3mi96u+Sys7NjpG7gPLblb5QuUSy5oOkz4HaX/Lx6NRDOgMgA4ZUXho8B" +
    "mQECDVMbhhuP/f3sxl/W19e9eNF0DLjx8qNPN/n9lYycdhF6Trk8aPmp8zNs" +
    "HyneNA6afBioIkxdvVMh1+VLMOBrasN0Dpd5E359qMucpis8L3UMKK5Tf3jP" +
    "ep4lLxdMd2mrXIaHR5xfv8yPv3z79i3yRcVyyY9cTM3fgg2fF9gkl+7u7trl" +
    "QhdHu3v3rrVyAVNTZsdffv365X1UyXKxTy4nJyfG6oiYN/mXCxoZNctFehx9" +
    "+7bVcgHr6+bGX+bm5mJdVCyXfMhlYWHBWB358uWLdXJBI0M3vaVWLqqu0cuX" +
    "L8PpF+l/KSLv3y/Q/1Im7jklyP77+/vpf+G6vianQxMvXd7I+/Qr0OTNy9qJ" +
    "Wz7aOhDhmP5+ESndUjr7I6A+t6lWS+XD1ZrLS7rmarx+FHnlL4vbbiMjymPo" +
    "2HLBEo62y2VwaMhrjqY5zqJMB8sl93IxPXUH3n61TS7Xrl2L1CWKLZeuri7r" +
    "5YJ4TL59m1ofGtMAslzslIuJVm1l2/y0mUx5GZTLs+fPI4+3xJZLa2trIeQC" +
    "1tbXU5mTQ3UBslzyLxfTrZZKXbFJLvfb25OTC/2G4NatW4WRS3/Cdyq8zxJ0" +
    "AbJc8i0XdE9MjrWghassj5zLpYk8Qcbk/VXLRdV66e3t9cZeVPT39RP6BPrc" +
    "i0QgIByBfkJfvwj5nZ5TioMPjIQnMf6CcZbQOKvQpFOKe79ItLwT81suD03e" +
    "Kss4ev5GqSOR0hETmldyvRTPiykmTW44XyLpilQPwss0Uvn9rR90vCXotf+q" +
    "5dLR0VEYuQCsFVTrXQgfSbJc7JQLvvkyveGctsml+2l3rC5RVXK5c+dOoeRS" +
    "651rZmZGH2eWS27lsre3Z1Qs6H4lli6Dcok6zUIsudCX6TD9QtHkguP29veS" +
    "a96yXKyQi6nJoPwbFrW3US50KRHdeEskuQTNqfvixQunt1cE//PTq+FFb69A" +
    "74sokDA056S/v+hV4P4fb0DGGX/5dvjt4nhdHM8R95HjIebFC1XcBXr19L6o" +
    "iSTKTHueCPHWx0FXz2TwaYbpDa0WMa3hZaq7vpTErkf0+lGUofv/uOMtVcsF" +
    "4y5FkwvApD1Rx1kwZSDLxU65vHr5yujTocq2tLRopVyePHkSu0tUtVxaWloK" +
    "KRewurqqrSSYhEqs/CwXm+Ty+fNn42I5/0jxpZVyifOxYmy50HGX69evF1Yu" +
    "IGyQD/KRKz/LxRa5LC2aH2e5qDdSWu2QC11dMexjxdhyUbVeMK8DZqcLp5cQ" +
    "d/8oxyQPFoFTjb8cHh5mEp/0iJ/XvYTY5+wlGEwvvlTPYkNdQp1KPC8N5T+9" +
    "9lXrQicqF3wKUFS5gPHxcamCYIo/loudcpmamspsNsKVlZV08tJA/kddRqQm" +
    "ueDRE30UVWS5AFSKyobKWSyxlEcu+Jg0zS/hq2m12CIXOmlcKnKhy41E6xrZ" +
    "LReA8ZegOw/LJf9yyVIs2LCKQGp5mXL+45UT+ggaL9MlLpegt3WfPevx8Uyg" +
    "h/DMjazAM5EeBZgQ2A8Ns6eHQM8pxUl1Dsrl+fpe9HmZLKBImxinHi00XjQO" +
    "2rxTQfIzbn5LcVBBj9GlQyofzfGR8k8MU07XeZ6NjI5mKpbd3V0xXj3xiJYv" +
    "z8LRXE9yvbuk7X5b1a2W2HKhTSQ8NSq6XLxzslysk8vs3FymYsE2OjpitVxu" +
    "N942JxdV66Wzs5PlwnLJlVxmM3oqJCwZ4nalpfy2SC6PnzyWxBLlrdxE5YLW" +
    "DMuF5ZIXuaysfMhcLGgxvejrs1ou91rv1dRqqUou9OtIDPg8ffo0It2EpwmQ" +
    "QJjdhMTj1F1znPDJu59k8qZbQ07OEaF8MM8QxjjysM3Oznhp6376VCCd+p8O" +
    "qqfDqcslaME0lgvLJSu5YH6UrMdXKtvW1tZF2myVy8OHD6t+cS5xuWC5AZYL" +
    "yyULuZhcHVG3ff/+3W1BPbdeLvh2sNYuUdVyQf9PtZY0y4XlYkouaK3gYs7T" +
    "NjIyLKTNVrngKXA13xIlIhdV6+XunTveS3V+nnQ/EXki0k2Q9nfpJmjD0Pze" +
    "/aRb4omOboK0DzlnhHjHTYccJ0V+aeJFf+9W5k88dGE+0dIdId6X4G1XdD3y" +
    "tmESKH3adOVB66WuLiuul5jXA/291ndbEpELHfC5XlfHcmG5pCYXtJaXl5dz" +
    "M7ZCx1mipS3/cmlsasxeLqrPAfAkieXCcklSLnmWSmWc5dnzZ4WQi2ogN2y5" +
    "1tTkouoa1dfXs1xYLonIJe9SuViSdXhIWbdtlEtjY3KtlprlQieRqkyByXJh" +
    "uVQrF0w1up7CaphpbNMz04F12za5qFot1Q7kJiIXVesFqzI+dqUDHj1+LPCY" +
    "8ne/Cx6reBzOI8LjKpDiIf6uS8ejx4+00HRBzH7k3x8L6OJ0Hi8SDskbfTpq" +
    "R3dOVboHBwe8mfjz3krxb1PT06HpVqedELvORAhD+j08/yv/T7rVkohcVK2X" +
    "9vv3WS4sl0C5YDpFzI+DpVny9jg52kTbS9p02ySXzhRaLYnIJaz1wnJhueAb" +
    "m9GxMefd/Lx3UdooE7pWVZR02ySXWiaESl0uQa0Xlkux5fLi78JifnDx7ezs" +
    "eBRtCxKLzXLpcrl69WrN3xGlJpegTwK6HnWJdFXB3wy4oKurNmh4UcLUpuOR" +
    "yCPVMWSfWtNRVdo16YhUXpdpGB0ddcqyQZaZlJmGRwRt3SS/NzU3pdJqSVQu" +
    "qqbVg84HLBeWSyFaLHkUS61ywROitFoticpF2XppvM1yYbmwWHIqF7r+c5Kt" +
    "lsTlom29sFxYLhZt7969y7VYapFL2q2WxOUS9Nbuw87Oc9wE+cEUmX4eKujs" +
    "fCjysDMUKYyHURDjJcfjIYHGkaCMlxgGHv8JdIajy7vOzvjpoHGQj1fg+31k" +
    "ZKSwYnn7dlKoI9ryrKbMaJh0f13dVpYpCTfgGmtK4b2W1OWiar3cu3uX5cJy" +
    "sWL7+fOn8/rNa6mOFEkuHe3t0jVqhVxUrZe6ujqn88EDlgvLJdfb169fnZev" +
    "Xv690IsrFzqjQRpiSU0uqvde0AxjubBc8rphoXh8m3N5oRdTLuhFpPE2rjG5" +
    "qFov51MytDkPHnT4eBCBjiqOSRpNHDo6RKKE2UHQ7N9BSCOdcc8xNDRUiG7Q" +
    "v5OTiZdXVZBz0PLo6JCJVb5u3aSDuGm1WlKVi0owaI6xXFgueeoG9fX3R8vP" +
    "AshF9XFiLfO1ZCoX1eAuloBlubBcst4WFha81+Ej56flcsEKHSYGcY3JJWhw" +
    "t6OjneXCcsmstYJ4x85Py+ViahDXqFxUg7v47qi9vd2TjEC7THt7h4i7n0A7" +
    "hexPfpfOqQhDjgOho0NEtY/2mPB0dbj/E9DEWYU2Hbq80YQxODho1djKzMxM" +
    "cD3SIJeHiLrMaV3VlLkOGod2RT1SoOpBpDWIa1QuQYO79+7dY7mwXIxsHz9+" +
    "dJ4+7QmvRwWVy/377UYHcY3LRSWYGzdusFxYLqlux8fHzuDQoPrCK4lc0Euo" +
    "dUH53MtF1TRDwlkuLJc0pIK5eAMv6pLIpaXljqN6Ymvqmjcml6DuEZ4eYUkS" +
    "0Nam4L7I/TbCfRHt/m1VhEF/18axTUZzDvmcbQQSjwjpkM/ZJqANUxWO7/eB" +
    "VwO5ksrnz5+dsbGxaGUeM+/0+7fpy0yLeHxbDfWktbU1s+5QJnJRrXWEDGj7" +
    "e/GxXFgu1UplYGAgPG9KJhe6JGtlXbHCygUggarxF5YLyyXu0x8sQi9IheXi" +
    "hdPQ0JBpdygzuaiWggXIEJYLy0X/5GfDmZiY8L69iSyCEslFNbZpujuUqVyC" +
    "xl8wAMVyYbnQbX9/35menvYWl4t00ZZULq2t9zIfZ8mFXPA4TDX+gvdfMBh1" +
    "QRuhVUPc/V3aCK2tbSIkTHn/BGhrE0kq3KTx5QPG0NLq8mxsbHhrGz1//jx2" +
    "HDGG56e6tLZp0NS7turqYuy0+sDb71mPs+RCLkGPpzH+wnIpl1wuZTLtyqS3" +
    "9guuhHJpqK/PxThLbuQS1D3C1Jgsl2LKBV0ciGR+ft4ZHx/3wtBeuCyX0Lrb" +
    "rJhoO8vuUG7kEiQYtGpYLvmWy/Pe595jYD8VcVRA1wYCwWLn0S9ilktUMPlT" +
    "nsZZcieXoPGXluYW566beSL3RO6JILNF7gnQ/T3u6hDjQMO8d++ugPIcUjzD" +
    "40XDlPe/KyHFS3cOkle6vD2Pl4gUB01eyMffq2Ifmm5NOlRoykOKg6YOqM4R" +
    "Nx3yOTR1+c7d3I2z5E4uQeMvEAze4GW5sFxYLncjiSXrcZZcyiXo/RdkoCgY" +
    "lgvLheWCBx95HGfJrVyCxl9EwbBcWC7llsutm7dyL5ZcyiVIMDA1BJMGLQTT" +
    "xycVBp8zBi2EOxbgxvPmjZtKsWDQnOVSg2DQbWK5sFzKKpeG+gZrxJJruai+" +
    "oE5LMCwXlkvuxdKgFoupiZ8KJZcwwSCjWS4sl7LIRTWbXJ4eOVspl6AJvitv" +
    "8TY3tzgtLc0CeKTtp4XQnAYthGZVPFoE9Me0iLSI0PBaFPvoziHnDTlnhLTr" +
    "8l97fLMqLc2hxA6zRY6nPkya/2Je1pru5ojnxFpDV65csU4sVsglaA6YimBY" +
    "LiyXosolSCx5epfFernEEQzLheVSBLmgXtssFqvkEvSSXeUxNcuF5VIUudQr" +
    "vnC2TSzWySVUMNdvOE2NTS6NAo1NTQLn+xCaGkOhYTR6/7ukCeH6UZxDPoYi" +
    "hiHFW7O/mvB00byKFmb4ORqRVj9R8l8qj7jpaqoZOb8TCJPkRZT8DqrftonF" +
    "SrmEdZGu111nubBcrJVL0Cv9NorFWrmECebatWssF5aLdXIJEouJZVdZLjEe" +
    "U/sFw3JhueRdLqqvm2153FxYuYS9aIeRdrwujReQdDQS5H0aCeT3RsLt9GmM" +
    "FG9NPLXxbpTRHNPYKJJO+jXlkUB+xs7LKuKJ8+BGWESxFEIuOsFg5J3lwnLJ" +
    "m1xQL4PEktdvhUopl7CPHSuPqlkuLJe8yAUDtKp3WIoklsLJJUwwuEuwXFgu" +
    "WctFtcxqXudjYbnEeBcmqJvEcmG5pC2X+vqGwG5QEcVSWLkEzcl78T6Me/eo" +
    "b6i/oIFQ39BAqNfsT2mQwLoyflDZwsCX3wL1BFU8pHDqBaRjpDA151RBjqHn" +
    "lKB5pUw7jSuNl5iXqrwIPV5VplL5kLyrJq/+nh/d8qBukK3vsJRaLkGrCvi7" +
    "SSwXlkvacgl6zFyUJ0KllYtuHAZ3k5u3brJcWC6Jy+XWrVvK9YSK3A0qpVyi" +
    "dJNYLiyXpORS1m5QaeUSpZuEgscdJ5/cJNxi8sTNW179CRu0LXo3qNRy0T1N" +
    "qixjwnJh4oJ6E9RaKUs3iOWi+fCxstIjmrYsF0YH6knY2EqZukEslwifDeSz" +
    "q8RyyWNrJaz+4MPaMl9fpZZLlMHeimRwh6pwk+IKyM+Nmzdkbui4SRB/l85x" +
    "46b2GG2YBOl4Ly0iN2/eEJDTqtlfEwcvHjHzTncOZV6Rc8jpomm/3FfXBSpz" +
    "a4XlEvORdeWxNSoVy6W8crl+43poF6ho3waxXAzNEeMfj2G5lE8u1+quhdaL" +
    "sj0JYrmk3FViuRRfLihn7gKxXIx3lSotGXSX8CLeBfibUFd3XeC6hrrrIlKY" +
    "/vMFUke4Hg9V3GKGIac7SjpqjHcC6Lo/3AViuRjpKkmSYblYK5coUrF5XluW" +
    "i6VdpQvJuE1plos9csFNIYpUuAvEcsmlZFgu+ZMLS4XlYrVkMBh43mW6JoCB" +
    "QoE6wrXkqbtWJ3CtjnCNog+jzvvfJfHjdC1+GCSvaN7K4Ynpuno1fJCWuz8s" +
    "F6vGZM5bM1fcyn2V5ZKBXCCUKK0UlgrLxWrJVFozLJf05YJ8jtJKYamwXAol" +
    "GUE0LJfE5HIthlD4GyCWi7UfRoZN76AUzV+u4ALxc0UEQqJI+xC0YdD9r6q4" +
    "IkCPkeN0JZyrMlcpunNc5FF0ofB7KiyXUkxUFSSaK37JsFykc1TCiJOv3Eph" +
    "uZR2LhmtbEosl2pkwmMpLBd+nF2lbIosl2plUnk3hbs9LBemivGZ8NbNFbvk" +
    "Qv5XSx6g+8n1ieXCJPTEqczwGArLhWHZJALPm8JyYXI4KMwyYVguTNWtm2oH" +
    "iLMG403cxWG5MBYOFuelW4V48KAry4UpcQvID+2CoXVE9+F8Y1guDMOwXBiG" +
    "YbkwDMOwXBiGSZ//B0AayjzmHHnlAAAAAElFTkSuQmCC")

# Original file: LoadControl.py

class LoadControl(PGLControl):

    def __init__(self):
        PGLControl.__init__(self)
        self.set_name("Load")
        self.set_active_icon(LOAD_ACTIVE)
        self.set_disabled_icon(LOAD_DISABLED)
        self.set_rollover_icon(LOAD_ROLLOVER)
        self.set_pressed_icon(LOAD_PRESSED)
        self.set_state(PGLControl.ACTIVE)

LOAD_ACTIVE = ("data:image/png;base64," +
    "iVBORw0KGgoAAAANSUhEUgAAARcAAAEXCAYAAACH0wDUAAA1l0lEQVR4Xu2d" +
    "6d8kV3Xf/T8lNmBJWCwSO2K1AQmzGcxOWMTq2IADwdiQyEASkDRaZqTRhka7" +
    "BiQxQkgwYgaDwSCxmCXgmATljd/lVaVP99Mz1d/fqTr31tJd3X3v5/N9Mfcs" +
    "99S9t37TVdVP9e+drqrfKxQKhaGRjkKhUBgC6SgUCoUhkI5CoVAYAuko7Aef" +
    "e7Sqlnzioap6692rXHS0qv7dF2OedrXGfuC+s7mXcPzC7iMdhd3BTmo70e2E" +
    "pyhskktuPStArLmwO0hHYfuwkzTn08ZUWX4KKp92dgPpKEwf+1/fTkSenLvK" +
    "UnA4D4VpIx2F6TGmmLz4pqq6+LZVPvT1BR9+8CzX/mjBNY+dtc95cMEy9pIa" +
    "HGsIbB5sPjhHhekhHYXNYzdYh7rEWYqHCcFff3MmDjOBOPGvVfXoEw7/d5Vv" +
    "P6HQhzm+bXEO185E6bOzg/vwrI43zT6JvOQmrbULRWymi3QUNoPd5OSJk8p5" +
    "V80E5FhVveu+xacIE5Cbf1ZVJ3/XzrcinnCgD6F/wF2/qqqrf7T6CciOh8eY" +
    "ionyaWd+C+tHOgrrw/7H5cmRgp18b5z97//xRxYn5/LEPvkEsL4WRBjIEw70" +
    "IfTvwu8Wx/V3p2aC+dWqetZ1Ogcp2L2a0868F9aDdBTGxS55cu+f1MXkpp8u" +
    "Tj6PXRIX5jwjNvd1+2Rj837aWY/CeEhHYXjsSUfuPRS7PLB7JPPLmyecE85h" +
    "l8WFdhNZE1sT3RyxsXUoT57Wg3QUhiPny2t2grxzdgnwhe9W1SP/R3kY0N6F" +
    "MOfvHOgT5CT0H4obflJVHzyRJzR2n4trVhgO6Sj0J+dTyp/dVVV/++2quv9f" +
    "9ISpM8ZJGuaksExYXOqYQJtQc66bsMvU8mlmeKSj0J1UUbHHwx+bfaS/45d6" +
    "YjQxxkka5qSwbIm4LDHBNuF+1TFdA48iMsMiHYU8bDOm3KB91pHFx3b7+M6T" +
    "IIUxTtIwJ4Vly8Sljgm5zb+tA9eGFJEZBukopJEqKu+YfTz/fMN9lBzGOEnD" +
    "nBSWLRaXOibwqZdN5SlTd6Sj0E6yqHylqo79oqoe+t/j8A0H8fktcGKy4hNy" +
    "0J85BfMJ4BjMEdldZnmP/byq3v+1tJvARWTykY6Cj4kKN5zH2KKyhCeUd1Lx" +
    "RKc/CeMTctCfOYUDAWmDYzBHZHep5f/Kr2cik/ikqYhMOtJRUKIbtbYp7X9A" +
    "+59wvmG5kUeAJ5R3UvFEpz8J4xNy0J85hYMTvA2OwRyR3YXjzPq+8ps0kbFP" +
    "rtwjBUU6CmeJvqdim/ADJxb/83Gjjg1PKO+k4olOfxLGJ+SgP3MK9XlrgGMw" +
    "R2R34Tg1m4nMRx+Ob/6W78m0Ix2F+BLIROXS2SeVe/9nVT34rwPx20wY7+Wg" +
    "neT6jwFr8GBMwNd/uwrtLg1jfupkVV0YiEx5suQjHftOdAk0uKgs4eaOYLyX" +
    "g3aS6z8GrMGDMQFDisuSv3q4/XKpXCop0rGvRH+h/MrZR+Bb/1k33WBwc0cw" +
    "3stBO8n1HwPW4MGYgDHExfrunV3+vv0rujfqlL/EPot07BvRo2X73+qy7zib" +
    "bWi4uSMY7+WgneT6jwFr8GBMwFjisuTyH5RLpRSkY5+IXtD0vgcWf+r/tf/V" +
    "zgMdYI6IlHj6bALWRHL9PZgjgvEejCH0N2x/tF0q7fuLq6RjX2j7tPKKWxev" +
    "ZWzbWDkb04M5IlLi6bMJWBPJ9fdgjgjGezCG0H/JLT+rqtffqXuoDvfeviAd" +
    "u07bkyD7X+iTJ9M3VurG9GCOiJR4+mwC1kRy/T2YI4LxHowh9Cdf/H77pdI+" +
    "vudXOnaZtsug5SUQN1XKxqJ/CswRkRJPn03AmkiuvwdzRDDegzGE/k3YPuLe" +
    "WrJvl0nSsas0XQbZpxV7K/19/9KM/el+HdqF3zik+LT5jwHHJPRPIJyrlDHg" +
    "E+YESf49xxBqua7+4exTzGHda0u4N3cV6dg12i6DLrpx8bpE2Sgge+PxBPJO" +
    "ItoJ/ceAYxL6JxDOVcoY8AlzgiT/nmMIyHfHL6rqdS33YvbhMkk6dom2y6D3" +
    "PpC+kbI3Hk8gI8WnzX8MOCahfwLhXKWMAZ8wJ0jy7zmGwOM6OLa/eEj33pJd" +
    "v0ySjl2h7TLov5zO20jZG4+b7GCjhT5t/mPAMQn9EwjnKmUM+IQ5QZJ/zzEE" +
    "Hlft2Ox3mdpu9nLv7grSsQtw8Za88IbFi4LsD9NW+DWI7AHHf6PQR+CYQ8Ax" +
    "gjppl3weUUxkH4DwOByOA9o5htgJ/RFz++wy6bV36J5csouvcpCObcYWiIu2" +
    "5D33O4vvbAJ3o9AewM2etOE55hBwjKBO2iWfRxQT2QcgPA6HdYvL0ucjX9e9" +
    "uasCIx3bSpOwnHuoqj5zyln4YBO02gO42ZM2PMccAo4R1Em75POIYiL7AITH" +
    "4bApcTGu+mFVXXBY96qxS69xkI5tpOmPDhsvg0jDJmi0B3CzJ214jjkEHCOo" +
    "k3bJ5xHFRPYBCI/DYZPiYthlku1P7tldEhjp2DaangjZwt3688XrEfpyz6+B" +
    "9fVExsi0ezCGRP6Rfe6TOReMHwKOQcSfNW+obo8336t719iFJ0nSsU00Cctr" +
    "7lgIy1CbJHdjpiBjZNo9GEMi/8g+98mcC8YPAccg4s+aN1R3E00Cs+3viJGO" +
    "baHpUbMt1NCbJHdjpiBjZNo9GEMi/8g+98mcC8YPAccg4s+aN1R3G+++X/fy" +
    "tguMdGwDqcIy1CbJ3ZgpyBiZdg/GkMg/ss99MueC8UPAMYj4s+YN1R3x14/o" +
    "nl7Cc2AbkI6p0yQsH39EN8hQmyR3Y6YgY2TaPRhDIv/IPvfJnAvGDwHHIOLP" +
    "mjdUdwq7JDDSMWWahOVjD1fV3b9cYH/Z3BvLU4d2kuKf4tPH34shkX9kT/C5" +
    "+1eriD+gf0oMxxQ7oX9KTC7M741BewOXf3/xFQru820TGOmYKp6w2AJ8+tGz" +
    "wlLEJSDyj+wJPrlCQf+UGI4pdkL/lJhcmN8bg/YWdkFgpGOKeG/kt4m3BagL" +
    "SxGXgMg/sif45AoF/VNiOKbYCf1TYnJhfm8M2gPsXb0vcL4Lsy03eaVjaniP" +
    "m5fCYgtQxKUlhkT+kT3BJ1co6J8SwzHFTuifEpML83tj0B7xq4XAeJ9gtkFg" +
    "pGNKeMJi2G/I3P7LBfbejFbMJ8C+LVkntBMnp8CYiA7xyzk5MzcB4XE5yBj0" +
    "4RikNl7qmALGIDKG40MkJhM5TgfGsIYmu71C0xOYqX/RTjqmQtPfCtWFxV0w" +
    "wgV0kI0V2YmTU2BMRId42cwB4XE5yBj04RikNl7qmALGIDKG40MkJhM5TgfG" +
    "sIY2uwkMzwVjyn8qIB1ToElY7HeZwwUjXEAH2ViRnTg5BcZEdIiXuQkIj8tB" +
    "xqAPxyC18VLHFDAGkTEcHyIxmchxOjCGNUR2+/1qnhNTFhjp2DRNr6V8092L" +
    "CQ8XjHABHWRjRXbi5BQYE9EhXuYmIDwuBxmDPhyD1MZLHVPAGETGcHyIxGQi" +
    "x+nAGNYQ2n/ZLDBTfF2DdGwaTprxxpmwHPv5gtsyWca1xdNnDNYxJscgkX9k" +
    "HwKO0QXmvO0Xq9B/CDhmZPd8huIdX9VzZIoCIx2bhJNlvPyW1YnlAkZwYWj3" +
    "fMZgHWNyDBL5R/Yh4BhdYM59ExfD/sPluWLwnNok0rEpvC/JPf9oVR39yeqk" +
    "cgEjuCi0ez5jsI4xOQaJ/CP7EHCMLjDnPoqLMXWBkY5N4D1y9oTF4AJGpMTT" +
    "ZwzWMSbHIJF/ZB8CjtEF5txXcTHsPOG5M5VH1NKxbrwbuPZM//Pfq6pb/rmq" +
    "vvwzYH1jwzEJ/ddBQg02X3VSYlphvJcjsm+ClJpSfKYGa55x3Y+r6pmH9Rya" +
    "wu8iSce64aQY9lsvg50gXeCYhP7rIKGGIi4HpNSU4jM1WPNB3V/4np5DBs+1" +
    "dSMd68S7z/Jndw98gnSBYxL6r4OEGoq4HJBSU4rP1GDNtbov/ZqeS5sWGOlY" +
    "F033WY78eOATpAsck9B/HSTUUMTlgJSaUnymBmtG3ZfcpufUJu+/SMc68O6z" +
    "nHOoqj73D1V180/bsd92rnPzz1aJ7B4SQ+gfQH93DNoJ/YH4eyAHYU5Cfy8m" +
    "tKMm2jkP7lwRxnBMxtO/Vk9qXZKTY6bkZAxzBmMyPzn8eFU941o9tzZ1/0U6" +
    "1gEP3vjIQzr5HpzwaEFo95AYQv8A+rtj0E7oD8TfAzkIcxL6ezGhHTXRznlw" +
    "54owhmMynv61elLrkpwcMyUnY5gzGJP5Pew/aJ5bBs/BdSAdY+PdZ3nDXYuJ" +
    "4eR7cMKjBaHdQ2II/QPo745BO6E/EH8P5CDMSejvxYR21EQ758GdK8IYjsl4" +
    "+tfqSa1LcnLMlJyMYc5gTOZ3mfm99wE9xzYhMNIxJm91vvTzvKOLj3Mpi9Fl" +
    "QWj3kBhC/wD6u2PQTugPxN8DOQhzEvp7MaEdNdHOeXDnijCGYzKe/rV6UuuS" +
    "nBwzJSdjmDMYk/ldDnwvPqbn2rrvv0jHmPBg7T7LZbOPcTf89ICfxNwIaN8E" +
    "N/50lbcdr6qX3lzI5a3HdW73mT57/Zof+fdf7H4nz8uxkI6x8C6HPvz16qyw" +
    "7JC42InCYy2k8fo7dX73lb57/bLv6PwaPDfHQjrGwHs/y6tmH9tWhKWIS+GA" +
    "IjALhtjr9mmQ82u3J3iOjoF0jAEPzi6H7M1aRVwKTRSBGW6ve5dHPEfHQDqG" +
    "xvuy3Jlr6z0RF7sktP8tCj7eHikCM9xe/xvne2XreMG3dAwND+q511fV9T9e" +
    "YH90VWfZ3wZjIq5/fBXaXR/AGiL/l0Bc7AQqrb15l87G6+505n8IsIZiJ4E/" +
    "99R8XwXk+ksNHhzj8QWvdAR87Ju70jEk3k3cT52sHTjgxHgwJoKTT7vrA1hD" +
    "5F/EpVtbq8BgDcVOAn/uqfm+Csj1lxo8OMbjC/7b9xa3Izi3PGeHRDqGwtso" +
    "3CTZk+vERHDyaXd9AGuI/Iu4dG/evvH2Tm+whmIngT/31HxfBeT6Sw0eHOPx" +
    "s7zlXp3XMV/uLR1DwYMw1bzqhzhwwInxYEwEJ5921wewhsi/iEu/thaBwRqK" +
    "nQT+3FPzfRWQ6y81eHCMx1dZ581d6RgC7+dX/8N9VXX4sQ48vsqRx1aJ/MXu" +
    "IDmZgzg56rz4piIufVujwNyh65G9fk4MoT/XWKC/MwbtYQ7aHY7YODWiHJ/8" +
    "ls7pWDd3paMv3l88203c+eR2AZMlC0aCyfWQnMxBnBx1irgM05oE5rV3rq5H" +
    "9vo5MYT+XGOB/s4YtIc5aHfIFRfjtXfonI7xywHS0RfvJu5nTx1MbhcwWbJg" +
    "JGFyieRkDuLkqFPEZbiWIjDZ6+fEEPpzjQX6O2PQHuag3aGLuFzxg/Xc3JWO" +
    "PnifWt58T21yu4DJkgUjCZNLJCdzECdHnSIuw7ZIYLLXz4kh9OcaC/R3xqA9" +
    "zEG7QxdxMd51n87n0J9epKMP/NRi6vil7y/+iKozjwHa10FmDUVchm9NAvOa" +
    "O3T+J0O0byL7yDx95Ju70tEHFjrIwm94AeZk1lDEZZy2dQIT7ZvIPjLee3eH" +
    "/PQiHV3xnhDZW7F4QNlseAHmZNZQxGW8tlUCE+2byL4Gxvz0Ih1dYYGDLfYE" +
    "FiC3hiIu47atEZho30T2NfDOr+o8DvVnAdLRBe9Ty3/9TlUd+mE79qW6Ff7J" +
    "IcWnxiEg8QkwB+smjH/RjUVcxm6NAnN7pXvCWbMIrukooM7Izhq9OnP37n//" +
    "x6o658rVORzqey/S0QUu8J/ergfhwYnhZKZMOOHkSnwCzMG6CeOLuKynpQoM" +
    "1ysFrukocP8Gdtbo1Zm7d83H+83pIT69SEcuXT+1GJwYTmbKhBNOrsQnwBys" +
    "mzC+iMv6WorAcL1S4JqOAvdvYGeNXp25e9d8xvr0Ih25cFFTP7UYnBhOZsqE" +
    "E06uxCfAHKybML6Iy3pbJDBcrxS4pqPA/RvYWaNXZ+7eXfqN8elFOnKwk4YF" +
    "feyRqrrynxbYNwFXsL46tHsEMcuxmsaM7CljkCsB7RcVcVl7axKYV9/urK+z" +
    "xtE+idbcJRhzCFgXob9wUNsXZp9e/nDgTy/SkQMX0v7HblugTpMdxISbIrCn" +
    "jEGiBSzispmWJTBc02CfRGvuEow5BKyL0F+o1We/08654zmfg3Sk4i1k/VOL" +
    "t0CdJjuICTdFYE8Zg0QLWMRlc83bl67AcE2DfRKtuUvmvuoC6yL0F2r1fdb5" +
    "tYA+73uRjlRYhJ1Q0QJ1muwgJhozsqeMQaIFLOKy2ZYkMFzTYJ9Ea+6Sua+6" +
    "wLoI/QXUaHPEeeO5n4p0pMIC3n3/4u+IcrBfAKhDu+dD6B/yAwf69KSIy+Zb" +
    "k8BccpvuIW8fRfYUmCOC8V344g+A9dWgP8+FT57UOet6Y1c6UvBu5H7+u07h" +
    "AeGBOz6E/iEUliIuO9tyBIZrGNlTYI4Ixnehr7gYT7tmdb66/gysdKTAxXr1" +
    "bU7RCYQH7vgQ+oc4kyk+PSniMp2WKjBcw977DPEpML4LQ4jLUDd2pSMFDvzB" +
    "E07RCYQH7vgQ+oc4kyk+PSniMq2WIjBcw977DPEpML4LQ4jLZ07rXHX5a2np" +
    "iOA3cu3ZuBScSHjgjg+hf4gzmeLTkyIu02uRwHANe+8zxKfA+C4MIS4G97BB" +
    "LYiQjggO+Ia7qup//OMC+xpxG0u/Jn/aPRhDIn/aPZ+Q77XzwhuKuEyxNQnM" +
    "xbc5axyQsocin752z4fQnzT5e2+qoxZESEcb3uL8p29qYU00HUiT3YMxJPKn" +
    "3fMJcQSliMt2NG8PG7LGASl7KPLpa/d8CP1Jk/9l/6BzZPuYmtCGdLTB11g+" +
    "+zq/sCaaDqTJ7sEYEvnT7vmEOIJSxGV72gec/5VljQNS9lDk09fu+RD6kzZ/" +
    "+0THeaImtCEdbXAg+wW3psI82g7Es3swhkT+tHs+IY6gFHHZnua9SF7WOCBl" +
    "D0U+fe2eD6E/afN//wmdJ2pCG9LRhKf2n5ot0he+l8F3O8AcJPKn3aNLTAtF" +
    "XKbdPHHhGgrRHqE9xaevfQg4BuAfM+Z850U6muBivOxmp9AIp/gQ5iCRP+0e" +
    "XWJaKOIy7VbEpQbHAPYTupwrakMT0tEEB7B3b0qhEU7xIcxBIn/aPbrEtFDE" +
    "ZdqtiEsNjgE+/ojOFbWhCenw8BbjUyedQiOc4kOYg0T+tHt0iWmhiMu0m7ef" +
    "uYZCtEdoT/Hpax8CjuHASyO7RUKN8JAOD/4t0fnXLH42hPw9yLV34e+/u0qu" +
    "PQmLq0M7eEERl0k3T1y4NwnXOLJ7MIbk+nsx3KuRf2Q3Xnrz6lylvkRKOjy4" +
    "EPZD1iwgpdDI3oVIPCJ7EkVcdqoVcWkeg3bjz+/R+aJGeEiHBxO/9wEtIKXQ" +
    "yN6FSDwiexJFXHaqFXFpHoN246MP63xRIzykg3gL8ZlTWkBKoZG9C5F4RPYk" +
    "irjsVPP2NPcm4RpHdg/GkFx/L4Z7NfKP7Eu63HeRDmKvuasnvfDI4qdD5pxe" +
    "5bKAM3E5YIwQxidwGaCdY0T+z8cfd26ruPBeG9nW4/LERdZ0gH0lcB8B2gXm" +
    "c+BxEPoT+i/n4pXQgZT7LtJBuAj2k5lnijm9CieL8ECSwBghjE9AJpNgjMi/" +
    "iMu0WxGXZui/nIu3Hdc5O+3oRR3pIExor7M8U8zpVThZhAeSBMYIYXwCMpkE" +
    "Y0T+RVym3Yq4NEP/5VzYHyhzzqLXX0pHHW8RPv3tWjF2wDU4WYQHkgTGCGF8" +
    "AjKZBGNE/kVcpt28fS1rOsC+EriPAO0C8znwOAj9Cf3rc3E+/nDZ1v+0oxtL" +
    "pKMO77dccGTxlqoznFrls7mcToAxQGoI4lfqP4A+zBH6gyIu026euPRdc8bP" +
    "c5xqR3IA+ntwTMkRHQfjW3gF9MA47ejGEumow0T2swMrxfJAczmdAGOA1BDE" +
    "c7JTJjz0B0Vcpt2KuNRgfAtvzbzvIh11mOjSEyiWB5rL6QQYA6SGIJ6TnTLh" +
    "oT8o4jLtVsSlBuNb+HjmfRfpWOItAAuVA83ldAKMAVJDEC/H4PgwR+gPirhM" +
    "u3l7u++aM36e41Q7kgPQ34NjSo7oOBgfwO+7DCIuT5kl/btvr/K3INt+ahXa" +
    "vRwhQU7xt37zq4MYwnjyvCIuk27c2wbXMFpz2mUPeTAmGIPQv0tMZJeagbe3" +
    "qR2huHBjWVIWEhUa2k+tQruXIyTIKf7Wz0lEDGE88RZgGxv3ANnW4yri0myX" +
    "mgF/7rXty3TSsYTvy7UfPmMhUaGh/dQqtHs5QoKc4m/9nETEEMaTIi7TbkVc" +
    "mu1SM6C4GNSOUFyYoIhLe446RVym3Yq4NNulZnDp13TuqB3Z4nLpA1pIVGho" +
    "P7UK7V6OkCCn+Fs/JxExhPGkiMu0WxGXZrvUDD6W8WY66WgSlw8+WFV/82gm" +
    "JwHtQzDCGJ8+uQrtEc+9fjdOwn0SlzH2keQk9O9C35yI//SjCmM4d01PjKTD" +
    "cCffGSSk74GnMMIYRVwWrYhLT5iT0L8LfXMinsLiicsFh1fnrun1C9Jh8GdE" +
    "LBkHSKLvgacwwhhFXBatiEtPmJPQvwt9cyKewuKJy4tuXJ07+zMhakijuHBT" +
    "2cnCAZLoe+ApjDBGEZdF4z4g23pcRVya4yksnrhcckznjxrSKC4MvHiW7D9/" +
    "K4GTgHYC/09+S5GYTJjPxcauwboiGF/EZdrNExfuG66x2AH3gLePsu3OOIKT" +
    "p0/dEu/keFPiO3WlwxMXS8YBXIKiBPjLSU//DjCfS21yGye4BcYXcZl2K+Jy" +
    "FhnTAzH2TifOHzUkWVwsGQdwCYoS4C8nPf07wHwutcltnOAWGF/EZdqtiMtZ" +
    "ZEwPxp3U+fOeGImweOJiv7omA3hERRH4y0lP/w4wn8vBxLZOcAuML+Iy7VbE" +
    "5SwypgfjTur8dRaXT3xz8Zq7XCyuDu2E/vOYbwU4eYZGagp4zvW7cRLuk7hw" +
    "DXPX3GOIHH0ZqwbOX5K4eBPftajcA6P/PIZiQpw8QyM1BRRxmXbz9jjXMHfN" +
    "PYbI0ZexanjOdavzV8SlI1JTQBGXaTdvj3MNc9fcY4gcfRmrBoqL90W6Ii4J" +
    "SE0BRVym3bw9zjXMXXOPIXL0ZawaKC62F6globg849rFDd2PP+xg/TXsj5rq" +
    "0P9jhP4JMIfYAWugfyeYE3gTv41tn8RF1ngNyF7dIrw9Ti0JxcWSzBM6JxEH" +
    "lMmCP4VB/BNgDrED1kD/TjAn8CZ+G1sRl3GRvbpFeHucWiLiwg1VxMWBOYE3" +
    "8dvYuBfIth5XEZf+8GdGirg4/p1gTlDEZdqtiEt/KC7e6y5DcXn2dVX10dkJ" +
    "81ffyMficmD8HOuvwzFArn3uE9WRWYPN2S6chNwLZFuPyxMXrmG05qHd8Yn2" +
    "WViDA2M4BpEx6cN88F/yJ1/WOaSWhOLyJ7f6RaUghQcwfo711+EYINc+94nq" +
    "yKyhiMu0WxGX2pj0YT74L+kkLhcdXQ0o4lJl11DEZdqtiEttTPowH/yXdBIX" +
    "BhRxqbJrKOIy7VbEpTYmfZgP/kvelvDTrqG4/PFMof7jQzO+4WD9GfwloD2F" +
    "vjn+8hsOmTkj/2cVcZl088SFayhw7xP6J8B9KHZAe6rPClHdtDf4pPxudBEX" +
    "IzNn5F/EZdqtiEuNyN7g00lc7H2Y9YAiLkrkX8Rl2q2IS43I3uBjusA5pJaI" +
    "uHBDvfimjEEDsifCoW8OLmgRl+bGvUC29biKuNSI7A0+g4jLs45kDBqQPREO" +
    "fXNwQYu4NDfuBbKtx1XEpUZkb/AZTFw+8vWq+rCD9a/w4CqRf2T3+LDlrePk" +
    "ac2JGr06Cf0lJ7A524WTkHuBbOtxeeLCNec+4xpzT0i8A3NE9k4EdYl/Asxh" +
    "vPyW1fmzr7BQS4q4pORgDHOCIi7TbkVc8mAOg+Jie4FaIuLCiS/iov6SExRx" +
    "mXbjHje45txnXGPuCYl3YI7I3omgLvFPgDmMC509Ti0JxeW8q5oHYBG5BxbZ" +
    "PbjozEEYzxq9Ogn9JSco4jLtxj1ucM25z7jG3BMS78Ackb0TQV3inwBzGIOI" +
    "i/HBE1X1oQcV61/B+urQTujvgZjcGj5kMTVon/sQxBDGE2/it7Htk7jIPgKy" +
    "B0aA+5D7KgXWKdTye3udNc3hOCf8PU4tKeKCfN6EE8YTb+K3sRVxOYvsgRHg" +
    "PuS+SoF1CrX83l5nTXM4zgnd4594qIiL2Oc+BDGE8YQTv60nYRGXs8geGAHu" +
    "Q+6rFFinUMvv7XXWNIfjzPqeds3q/NmcUktEXAxv4qWog0GiIlqhvwdicmuQ" +
    "yWN+5PMmnDCeFHGZdiviUgN21jSH45zQ+essLu/8alW9/2sOJwDtAZeeWIX2" +
    "MbjUgT4RjOdxXFDEZdLNE5e+e1ninRzcJ7SHML/lsbw1JGYkOH+dxeWNd2vy" +
    "OTxY2gN6T3YHuBhdFoTxPI4piYt3Ik0Bu0bfVPPmpO9elngnB/cJ7SHMb3ks" +
    "bw2JGYH3DPlD9PZiGA4whwdLe0Dvye4AF6PLgjCexzElcbFmJzLXdJPYH8f+" +
    "2/9jletrRVz6YR82OH/UkGRxeenNOsAcHiztAb0nuwNcjC4Lwngex9TExU5k" +
    "/rX7prAXOW9SWKwVcelHylvoGsWF19oXHK6q9z6gvC8TxhP6z2PuX4V2wpwp" +
    "MAfJrcHmqz5/mxYXa3ZC24nNTbFObPzHfsfK1t88ceEaZu8RB/HJ3EfvM586" +
    "tFvOgMhf7KhxDmJecpPOHzWkUVz4MfrcQzqAV1gE4wn95zGZC8KcKTAHya1h" +
    "iuJizU7sTQrMrY+xos20Ii4tdtQ4BzHe/qaGNIqLN/kcwCssgvGE/vOYzAVh" +
    "zhSYg+TW4E3+VJqd4FzbdWB7airN299cw+w94iA+mftoquJyPr7j4v0IfaO4" +
    "GJz8P79HB2FhEYwn9J/HZC4Ic6bAHCS3himLizXv5BqTTT4Z8pp3/FzD7D3i" +
    "ID6Z+2iq4sK58x5DZ4nLq2+vqnffH3AfoJ3k+ntEOSK7RxBjj+Lq0P+ZExcX" +
    "a7z0HYtNPxnymicuXEOuOe3vAeLv7ROSOaYLx6zV1FRXG6yZ+zv1SVGWuLzo" +
    "Ji1ECA5cyPX3iHJEdo8gpm3yjW0Ql3U8QZrCkyGvFXFphjVzf7/uDp07akco" +
    "LvxxtOcf1UKE4MCFXH+PKEdk9whi2ibf2AZxsTbmE6SpPBnyWhGXZlgz9/eL" +
    "btS5o3aE4sLH0XbCsBAhOHAh198jyhHZPYKYtsk3tkVcrI31BGkqT4a8VsSl" +
    "GdbM/W0fMurz5r3eMhQXbwHe9dU83nnfKrQT+xsm8i6LqxPE0E7o78YEY0b2" +
    "Z2yRuFgb+gnSlJ4Mea3T3saayx7innD2xTqI6uI5GfnzWJ9x7eq8NT2GbhUX" +
    "gwtgP+HIg2mDB0I74YG6BxvE0E7o78YEY0b2bRMXa94J14WpPRnymnesXEMB" +
    "ay57iHvC2RfrIKqL52Tkz2N90hWr89b0pChbXC4+pgfTBg+EdsIDdQ82iKGd" +
    "0N+NCcaM7NsoLtb6PkGa4pMhrxVxqRH414/Vvo7CeaNmdBaXi27Ug2mDB0I7" +
    "4YG6BxvE0E7o78YEY0b2bRWXPk+QpvpkyGtFXGoE/vVjtb8x5LxRM5LFhRvt" +
    "j67Wg2mDB0I74YG6BxvE0E7o78YEY0b2bRUXa12eIE35yZDXirjUCPzrx8oX" +
    "z9u6UzOSxcVbhLfcW1Vv/4rPOwJy/b2Ytx8HsDM+BeYgkT/t3k2vbWq5T5Cm" +
    "/GTIa96+fsfxVaJ9RrgHPBiTC/ONkZP2ug/vtzR97T9JXAwugv2MIwdnEU3k" +
    "+nsx0aIzPgXmIJE/7dsuLtZSnyBN/cmQ14q4NOekfenz+jt1zqgVRDoIEz73" +
    "eh28qVCS6+/FRIvO+BSYg0T+tO+CuFjzTsI62/BkyGvecRVxac5n/S/JvN+S" +
    "JC78Mt05h3TwpkJJrr8XEy0641NgDhL5074r4mKt6QnStjwZ8loRl+actC99" +
    "cu+3JImLtxBvmH1Eeuu9CRwPyPWf8RZAewjH9MbtaX/6DomL9wRpm54Mec3b" +
    "07KmJHMPJPu0wfguMGdHcu+3JImLwYV42ewjkhyEh1PkCrn+x4u4bKLVnyBt" +
    "25MhrxVxyeM1GX+sWEc6PJj4OddVehAeTqEr5PofL+KyqbZ8grRtT4a8VsQl" +
    "jxcnvtaSSIeH3He5stKD8HAKXSHX/3gRl0223/wbe7azFXHJg/u57Y8V60hH" +
    "E1yM191ZVW++px37unAd2gn9Xe5d5c0RzjhExohgDcj3dLwGcFfEZVeaJy65" +
    "a0x/2udk7kXmJPT3YmhnDdFx0d/gXHm/C+0hHU1wAPtTACkMhAce+LtwciKc" +
    "cYiMEcEakK+Iy7RbEZezRP6pPyPiIR1N8BubT73KKQyEBx74u3ByIpxxiIwR" +
    "wRqQr4jLtFsRl7NE/nZ/lXNFbWhCOprwvu8QXRqFBx74u3ByIpxxiIwRwRqQ" +
    "r4jLtFsRl7O0+dv7cp90+eo82dcSqA1NSEcbXJDnHV0U0JU3Adrn3AVoD0gZ" +
    "gz4kt4anFXGZdPPEhWs4BLKPMukb74K9/CZQ9+36lGiJdLTB9+r+4ZVO8Rkk" +
    "TV7miU1SxqAPya2hiMu0WxGXs7SJC1/XOqq4eIvyiludA0gkafIyT2ySMgZ9" +
    "SG4NRVym3bx9zDUcAtlHmfSNd0kUF++Lcynfyq0jHREc8FnXOQeQSNLkZZ7Y" +
    "JGUM+pDcGoq4TLsVcTlLk7i88AadI2pBhHRE8O9M7IbPG+7qyJ2A9nXBOgj9" +
    "A/hzl0VcptU8ceGa2ysG6nCN6e8R5hgD1kF7IuddtTo/KX+oSKQjBS6M/WAa" +
    "i0tioInoDesg9A8o4jLtVsSlnVcd0/lJ/eJcHelIgQPbKwZYYBIDTMQgsA5C" +
    "/4AiLtNuRVzasXc2cX6oASlIRwp2Y4eD229Js8iQASZiEFgHoX9AEZdptyIu" +
    "7dhT4PrcpP4tEZGOVLg49kts9qW6Oq8ld6xivzu7AuI9ohyR3YMxQnAc5Hx8" +
    "m7mIy7SaJy5cQyJ7JnNPuDkCewqsQ+wgsntvnLP54vmfgnSkwj8HMLUTISDB" +
    "gTLeI8oR2T0YIwTHQYq4TLsVcWm2X4g3zhk891ORjlS8Pwcw1SviUsRl6q2I" +
    "i2/3buTa3uW5n4p05MBC7KQq4lLEZeqtiItvv6DnN3KJdORgJw2LefmXqyIu" +
    "RVwm3Yq4qN371NL1Ru4S6ciFBdmvMv7p7fuNzUERl+k2T1y4hvvG0J9aDOnI" +
    "xfv0Yr8py+L3iSIu025FXFZ5pfP74H0/tRjS0QUWtu+fXoq4TLsVcVnl2T1e" +
    "CNWGdHShfHpZpYjLtFsRl7NccltV/QFeCNXl74g8pKMrXKxnXrsoPItjysW3" +
    "rcIYsTOHExMS5WCN4KlFXCbdPHHhmkZrTjv3QBIWV4d2Qn+nrsjOur3vtXT9" +
    "0hyRjq7wRVKGvdyXB9MKJ8KbLCB25nBiQqIcrBEUcZl2K+KywJ4QjfWpxZCO" +
    "PnDB7E1WXIRWOBHeZAGxM4cTExLlYI2giMu0WxGXBfz9Z2OoTy2GdPSh96cX" +
    "ToQ3WUDszOHEhEQ5WCMo4jLtVsRl/E8thnT0hYtmXyh71a0+9gisDu2ezyuP" +
    "gSAH/Wn3YM5c7GdXirhMt3niEu0TrnEK2TmCve2RPcYB3vdahvzUYkhHX7xP" +
    "Ly84qpPgTQTtnk+0ABIfbBoP5syliMu0276Ly8tu0eM3eC73RTqGgEU/5Yqq" +
    "esWX44mg3fOJFkDig03jwZy5FHGZdtt3ceH+NIb+1GJIxxB433u58HA8EbR7" +
    "PtECSHywaTyYMxcuXhGXabV9Fhe7iuCxD/FtXA/pGAoegGFfrLMbvDvHLavw" +
    "5cZFXKbVPHGRNd0E2Ed//GVgfUBytPDyW/QmrrE8Z4dGOobCW0A76XjAO8Et" +
    "qxRxmXbz9qas6SbAPhpaXLwfObO9WT9vh0Q6hsS7uWs/AcuD3npuWaWIy7Tb" +
    "PorLi27UYzbq5+vQSMfQ8GCefMXi4xkPfqux46lRxGXabR/FhXvSGOMmbh3p" +
    "GBrv5q79FIk9DjORWeFm5WXkloDAX8ZkfIKdsOZzD+kxF6YN15RwjWWPcN85" +
    "ey+COVMIx7zZ/ybuWDdx60jHGPDAjBfeqBMlC8iJ8yaPBP4yJuMT7IQ1F3HZ" +
    "PrimhGsse4T7ztl7EcyZQjTmS25a703cOtIxBt7H0HOv0omSBeTEOZMnBP4y" +
    "JuMT7IQ1F3HZPrimhGsse4T7ztl7EcyZQjSmXSXwWHN/UL4r0jEW3s1dO/CV" +
    "yeICcuKcyRMCfy7OfIECH9oJay7isn1wTQnXWPYI952z9yKYM4W2MZ/j/HLi" +
    "0H8/1IZ0jAkP1LCfjrSPbo3cDHLtQ5A5hr0j4+nXgGsDIn/auzCFnLn+Xgyh" +
    "fwe4hrlr7vFSQHs4Bu0JLMe66Ab/cmjsm7h1pGNMvN86sgmwx2QysU0TnGsf" +
    "ggHGsC8Q1glzRvYubCCnnGCBf1IMEP8EwhiOQ3sCvcegPYHlWPxJVuOSW9cn" +
    "LIZ0jI0dIA/aLiNkYpsmONc+BAOMUcTl4AQL/JNigPgnEMZwHNoT6D0G7QnY" +
    "OPZJjOfYOi+HlkjHOuBPwRruR1NvgnPtQzDAGEVcDk6wwD8pBoh/AmEMx6E9" +
    "gd5j0J7Ac5yXbRs8B9eBdKwLHrzh3n/hBObah2CAMYq4HJxggX9SDBD/BMIY" +
    "jkN7Ar3HoD3Avt6x6fssdaRjXdjjME7C71++uBFl92BSMf86tHfC8tShvQMX" +
    "AdrHgGMS+hP6ezBmDMYYMzcn/Qn9PcIY7Lvcvf2UCdxnqSMd68R7PH3OIZ20" +
    "NnIXIIkiLknxKTmGYIwxc3PSn9DfI4zpIS5Pm8h9ljrSsW44IfNJuUYnr4mc" +
    "BUimiEtSfEqOIRhjzNyc9Cf09whjOoqL9/V+g+faupGOTcBJMezGFCfRI3UB" +
    "sijikhSfkmMIxhgzNyf9Cf09wpgO4mIvf7LbCTx/PvdoEZc57v2XLy1+ZtIm" +
    "r5UbVnkhOboK/ecwJ4n8aU8gqa5Mf/oQ+stxEPonwPnPtXeCdaeAHLlzJf4O" +
    "2cfKHLB7Y9orZHnubPI+Sx3p2BTe/RcTmOdzwgkXgHBBuKAGc5LIn/YEkurK" +
    "9KcPob8cB6F/Apz/XHsnWHcKyJE7V+LvkH2szAE7x/OEZdP3WepIxybxvv9i" +
    "E9gqMFwAUlsQd9MYzEkif9oTSKor058+hP5yHIT+CXD+c+2dYN0pIEfuXIm/" +
    "Q/axMgfs9fGa/n6N59QmkY5Nw8kKBYYLQGoL4m4agzlJ5E97Akl1ZfrTh9Bf" +
    "joPQPwHOf669E6w7BeTInSvxd8g+VuaAfTkWXwA/RWExpGMKcNIMe0T9vOsd" +
    "joJc+4znHl2F9gj78l8d2uegDo4pOVg3Yf4OMeGYzD8AMmYXojoj+xbjvVHO" +
    "sL/b43m0aaRjKnDyDJtYTna4kSL79Xqi0x6RdMKgDo4pOVg3Yf4OMeGYzD8A" +
    "MmYXojoj+5bi/c3QVIXFkI6p4P0FtSsw0UaK7NfriU57RNIJgzo4puRg3YT5" +
    "O8SEYzL/AMiYXYjqjOxbSJOwrOvFT12QjinRJDA20WcmPtpIkf16PdFpj0g6" +
    "YVAHx5QcrJswf4eYcEzmHwAZswtRnZF9y/DeJmdM5ZFzE9IxNbwXfBvnX7P4" +
    "Hox92a6O9dUR+xEHJ64NyRnYPRgjBDUyX1JOwPgUWJfYQa49BeYg9Hex2msw" +
    "B5F4QP+hsN8asq9kcP9PXVgM6Zgi3jtglgITLbLYedImbCwiOQO7B2OEoEbm" +
    "S8oJGJ8C6xI7yLWnwByE/i41YZmquDQJy5S+y9KGdEyVJoGxv0NqW2TZBDxp" +
    "EzYWkZyB3YMxQlAj8yXlBIxPgXWJHeTaU2AOQn+XmrBMUVzsP85tFhZDOqaM" +
    "9yU7w75Q1LTIsgl40iZsLCI5A7sHY4SgRuZLygkYnwLrEjvItafAHIT+LjVh" +
    "mZq4mLBwj2+bsBjSMXWaBOacK6vqwsMORwDtng/p658Skwvzdxmjb7yXg+T6" +
    "ezEjYH9JXId21kR/IvFODoH+R5q/ILdtwmJIxzbQdIlkLyW+IFpA2j0f0tc/" +
    "JSYX5u8yRt94LwfJ9fdiRiAUB9REfyLxTg4B/vZFUe7pbRUWQzq2hSaBedLl" +
    "EJiUBacP6eufEpML83cZo2+8l4Pk+nsxIxCKA2qiP5F4J4dQ820SlnX87OpY" +
    "SMc20fSYekVgUhacPqSvf0pMLszfZYy+8V4OkuvvxYxAKA6oif5E4p0cwszn" +
    "giP+Xzcb2/C4uQ3p2Daavmhnd9rtSdIzr13FvpBE6CMcBrA/4zBA/pQxcv2l" +
    "Jqcugf5AanB8hGAMyQlo93xI5D/EehCJj+bBi3Hs9h8h9+4uCIshHdtIm8Cc" +
    "f7UuKOGiC8FGGmIz5/pLTU5dAv2B1OD4CMEYkhPQ7vmQyH+I9SASH82DF1PD" +
    "/uNrEpap/q1QLtKxzXCRltj1bNOCc9Fdgo00xGbO9ZeanLoE+gOpwfERgjEk" +
    "J6Dd8yGR/xDrQSQ+mgcv5gB7IuR9h2WXhMWQjm2Hi7XkyVfoYnPRGwk20hCb" +
    "OddfanLqEugPpAbHRwjGkJyAds+HRP5DrAeR+GgenBjD+5nVJVN47+2QSMcu" +
    "0PRdGPvf4o+u1gXnphCCjTTEZs71l5qcugT6A6nB8RGCMSQnoN3zIZH/EOtB" +
    "JD6aB/jbF+OaLoMM7uFdQDp2Be+dvEvsfw+75l1if2Vdp27zyPWfx1y9Cu2k" +
    "yxgRzElS/OkzBtGYtHeBOSOieNrrPvYN8n/fcBm0rd9hSUE6dgnvVwWWPOmK" +
    "5o3BjUNy/ecxRVySicakvQvMGRHF07708X4FcckuPBFqQzp2ES7qEvvfxG6u" +
    "eZuijVz/eUwRl2SiMWnvAnNGRPG02+W397vNS3bt/oqHdOwq0WVS28Yh3Ei0" +
    "exRxSScak/YuMGdEFF+37etlEJGOXab1MunyxSs07X+cSWK11aHdI4qhndDf" +
    "i6E9om+8R5ecUQztxPG3T8FtN213/TKISMc+0PQ0ybBrZNk4UyDa3B5RDO2E" +
    "/l4M7RF94z265IxiaCfwt6/wN31aMfbhMohIx77Q9IePhj2yti/ecQNtlGBz" +
    "u0QxtBP6ezG0R/SN9+iSM4qhnRz4nXtV+72VfboMItKxTzT92cAS+4j7VG66" +
    "TdGwuVuJYmgn9PdiaI/oG+/RJWcUQzu5evHFTO6ZOvaHtdxz+4R07CNtN3sN" +
    "20R2k27JeeSqmHp8CuEYtDswJ6E/OdfqBucFiL+TN4Q5D7WT6z+PIVGOg+Mx" +
    "nnxl+yXQPn9aqSMd+4pdE3OT1LFLJbsfk7IxPWSzBoRj0O7AnIT+xE4kcl6A" +
    "+Dt5Q5jzUDu5/vMYEuW4anGp/Pstl0DGLv1tUF+kY99pekfMEru+ls2Jjekh" +
    "mzUg2vxid2BOQn9iJxQ5L0D8nbwhzHmonVz/eQwJckSXQPv2JCgF6SgsiC6V" +
    "7H7MmU2KjenBzRoRbX6xOzAnoT851+oG5wWIv5M3hDkPtZPrP48hTg77pGLr" +
    "XC6BuiEdhbNEl0qGfZKxx5D2Rbwz2L9J3T7jnCtWoZ3YC8j7wpwRjPdyRPZt" +
    "pe0J0JJyCdSOdBSU6FLJsGvxMyJDYXHEo4jLNEkRlW1+r+06kY5CM9Gl0orI" +
    "EGziIi7TwdYrRVTsEmgfvwzXFekoxCSJzOw6/cmzDVvEZbqYqERPf4qodEc6" +
    "CumkiIzdDLT/Fe1pQw72Sog2TLhCnLy9CcaQOkkQPwgcA9h6NL1msk65/OmH" +
    "dBTySbknY9iGThUanqSEJ4yLk7c3wRhSJwniB4FjzLCnPimCYhRRGQbpKHQn" +
    "VWTs04x9HHdPvgN4khKePC5O3t4EY0idJIgfhIPcJih/8KX2R8l1iqgMi3QU" +
    "+pMqMkbTZRNPUiInqQdPuiEIxpA6SRA/BDafqYJi7PvfAI2FdBSGw74H0fZ6" +
    "BzL/RGNic/DJZoUD2xI7gYj4ALEzB/1ZgwNjmJNjCl5OwrrIQVyOoBjleyrj" +
    "Ih2FcfjAfbq527ATZXn5NAcnlJyAng8QO3PQfzl2C4xhTo4peDkJ6zpgOUec" +
    "uzbKp5T1IR2F8Wl7l0wTZ8TmADkBnRO56aRszEH/2gnfBGOYk2MKXk5S888V" +
    "E6PcS9kM0lFYH/bdiZTH2R5nhKblROaJL3bnJJ6SuJi9i5gYdjlaLns2i3QU" +
    "NkPu/RmP5aeb+r2bbRCXet1dxWTJB+4rgjIVpKMwDXKeOO0zNk/l27PTRDoK" +
    "08NOniI2C+x+VRGT7UA6CtPHTq4uN4W3kSIm24t0FLaT5aebrjeIN43db1pe" +
    "4hQx2Q2ko7Bb2IlqN4unclllddhN1yIgu490FPaL5SeFOiYAdXgJZp+O6MMc" +
    "RTwK0lEoFApDIB2FQqEwBNJRKBQKQyAdhUKhMAT/H9+0TO4h343IAAAAAElF" +
    "TkSuQmCC")

LOAD_PRESSED = ("data:image/png;base64," +
    "iVBORw0KGgoAAAANSUhEUgAAARcAAAEXCAYAAACH0wDUAAA0QklEQVR4Xu2d" +
    "V9skx3XfeeU73fnOX0CfwHe685Xv+Al0Z4kBDGICcw4SoxgkBjFTDKYoWyIp" +
    "m6JEkRZFytYKi7CIu4u0IBdhQYAECGa2+8y8DdT8/qf7VPV0z/TM1PPM71mg" +
    "TqyqU+ed7knPOtc0z6pUKpWpkYFKpVKZAhmoVCqVKZCBSqVSmQIZqFSMV9/S" +
    "NP/tXMyLb2wa2lYqhgxUjhM2hX3y1ttrQzoFZKByuOQ+21gq9VnQcSEDlcPA" +
    "DiIP57Fyzpl/ZfnIQGWZzNVM3nJb07znrk3+6oE1X0m49cdrLvz4GXlKZ/ve" +
    "BMaagvrs5nCQgcoymOoSp2se1gD+7uq6OfzkV03z6986NJv85reK2ADq/8b8" +
    "tNz6k6b5ziPrRvWRy+v7Lsx1DLXZLBcZqOyHbQ7bi25cN5DP3LtuItZA7n6y" +
    "aX71W/CbTX4Z8VsH6hDqB1z9edPckjwbsnnYfDjHXKwpn3PWt7J7ZKCyW3g4" +
    "crDD9+HLTfP19pnI1Z89c7ClmRDTSZDGQJxmIDqE+mP4zXpe//TwumG+auSz" +
    "uHPOeld2hwxU5qf0/knaTC4/uT58HtJMiOkk0F7goT87+INQfwyOT3uG0zWb" +
    "Mc9szjn7UJkXGajMQ+k9FLs8sHsk3eWNHDgHaSbEdBJoL/DQ5+RB/TFEPn+z" +
    "brLWbK3pljSbetm0O2SgMi0s7j7sgHy6/av8r9ea5ue/bvnNJj8DlI/hZ7/e" +
    "ZBU3xbERYMM8idhPxMW22Xz5SlmjqW/mmxcZqGxPybOUP7/UNN96qGke+0Uz" +
    "eLDnOKTH1FxSrEFbo+Za91FfcZoHGaiMJ7ep2MvDX/th0/zgqUYOZ9/BnuOQ" +
    "Hmtz6XKxhm2N+9136h541CYzLTJQKSfnBq294mFP2y8+8UzxD4IDM8chPfbm" +
    "kmKN3NY/55Wn2mSmQQYq+eQ0lU+1T8+//6gWewgOzByH9JSaS4o1+NzLpnPO" +
    "vlfykIFKTG5Tub/9a/nTX8/DUw6i8yvg2BTZZ/igPn0KphPAGPQRyfuw/flS" +
    "5k3gc04dVIaRgUo/LDiPT90zb1Pp4IHyDhUPOvVJaJ/hg/r0KSRNpA/GoI9I" +
    "HnHtF7XJzIEMVJToRq0V5Zfub5vKT5v1gXAKeGp4oLxDxYNOfRLaZ/igPn0K" +
    "Zw1kCMagj0ieS26Tqfdk8pCByiYsLDaV/94W47WfN5sHwincqeGB8g4VDzr1" +
    "SWif4YP69Cmk69YDY9BHJC/FmsxXfxjf/K3vkxlGBiprWEhsKl9sn6k83DaV" +
    "J35VWRpPAspL+OZDTfPKoMl0NVPZRAZOnegSqDaV5TNlc+n42x8OXy7VSyVF" +
    "Bk4ZFkzKu+5smvt+qkVXWR5zNBfD/qh88h6tjZSuliq1uawYemnZ/lp995oW" +
    "WmW5zNVcOm54rF4q5SADp0T0BU1fuH/9vSI//hX45SaPk185QCfySehP7J0Y" +
    "W4OY3jwI8yb0xzm40EcEY8DeQ3wA6htWH0OXSqf+CWwZOBWGnq28887198U+" +
    "XVilxY7i9g5l5JPQn9g7MbYGMb15EOZN6I9zcKGPCMaAvYf4ANTvuOfJpvnQ" +
    "Ja2hlLTuTgkZOAW4+R32V+gbDzqFVVrsKG7vUEY+Cf2JvRNjaxDTmwdh3oT+" +
    "OAcX+ohgDNh7iA9AfXLuR8OXSqzBU0AGjpmhy6DuEohFtSqs0mJHcXuHMvJJ" +
    "6E/snRhbg5jePAjzJvTHObjQRwRjwN5DfADq92F1xNrqOLXLJBk4Vvoug+zZ" +
    "in0r/Y9+2c9jgHLhFw45OkP6c8CYhPoZNvY1Byml9h6y/tRBjFDfQfImnAdJ" +
    "dG95vH0Wc7PWWgdr81iRgWOEm9vxptvWX5cohQKkWCNYmF5xUk6oPweMSaif" +
    "YSOHtNDeQ9afOogR6jtI3oTzINC3r3j44EWtuVNqMDJwTAxdBn3+/qT4AqRY" +
    "I1iYXnFSTqg/B4xJqJ9hI4e00N5D1p86iBHqO0jehPMg1D/jfzygtddx7JdJ" +
    "MnAsDF0G/Z9HUHwBUqwRTpFl6QzpzwFjEupn2MghLbT3kPWnDmKE+g6SN+E8" +
    "CPUTTvUySQaOAW5exxtvXX9RkH0wbYOfA8oLecSBOlPHHEOY4xTsYJ5j5iE2" +
    "UZ6RPOCB9jLpAyd2mSQDhw43reMv79MNf5otC4ewcN2CnzjmGMIcp2AH8xwz" +
    "D7GJ8ozkmfz1wGUSa/nQkYFDhptlvPB803z7Yd3kDSYqnA4WrlvwE8ccQ5jj" +
    "FOxgnmPmITZRnpG8gJvby6Trey6TjulrHGTgUOEmGb2XQWTCwjFYuG7BTxxz" +
    "DGGOU7CDeY6Zh9hEeUbyQuwyyeqTNXtMDUYGDo2+V4Rs4+57av1J1m15aAai" +
    "GJHcgzYk0o/knk4E7R/+GaDcAzaMQUr1PaIcRD6Sj92ttWscwytJMnBI9DWW" +
    "919cNxa3SEbAwpuCKEYk96ANifQjuacTQftRh7SwWZTqe0Q5iHwL+hrMoX9H" +
    "jAwcCn0vNdtGDRbJCFh4UxDFiOQetCGRfiT3dCJoP+qQFjaLUn2PKAeRb8nn" +
    "7tNaPvQGIwOHQG5jcYtkBPQ5BVGMSO5BGxLpR3JPJ4L2ow5pYbMo1feIchD5" +
    "BPzdVa3pDp6BQ0AGlk5fY/n6VS0Qt0hGQJ9TEMWI5B60IZF+JPd0Img/6pAW" +
    "NotSfY8oB5FPxDE1GBlYMn2NxX53+cGfrbFPNlf2R7cPuftB/RybY8e+6c7e" +
    "QsE6P7QGIwNLxWsstgH/+FAtzCVR2iion2NzChxDg5GBJeJ9I78tvG1ALcxl" +
    "Ubof1M+xORWsvt/gvBfmUG7yysDS8F5u7hqLbUAtzGVRuh/Uz7E5JfqewRxC" +
    "g5GBJeE1FsN+Q+aBn62x780YxHRSKH9q/W7JlFK5wJg9cQcZYd+tydNrQ6gP" +
    "KPeQGI7OkP6YmALnBSSGo0PEphCZpwNtQs5yO9fTYJb+RjsZWBJcTDaWrA07" +
    "26CnofypuLAiucCYPXEHGWEvxUyoDyj3kBiOzpD+mJgC5wUkhqNDxKYQmacD" +
    "bUKS/KzB8CwYb719uQ1GBpYCF9Gw32Uu3rBkg1ZQ/tRmUXmFFckFxuyJO8gI" +
    "e1kbQn1AuYfEcHSG9MfEFDgvIDEcHSI2hcg8HWgTghzt96t5JpbcYGRgCXDx" +
    "jI9cXi948YZhg0RuPkGpXGDMnriDjLCXtSHUB5R7SAxHZ0h/TEyB8wISw9Eh" +
    "YlOIzNOBNiHM86n+BsMztARkYN9w0YwPt43l/qfWXPlpGZ3dkD117rexISJ9" +
    "yp24oQ3lGTAGYYwrQOSOjxD6hZw5M6Y79ygvxKT+KJADY0bylU7gM4T2Z3zq" +
    "Xj0jS2wwMrBPuFjGO+7YXFhuYAQ3hnJPRzaZRPqUO3FDG8ozYAzCGNGhpH0W" +
    "9As5c2ZMd+5RXohJ/VEgB8aM5CudwGcI7RPsDy7PytIajAzsC+9Ncq+/tWnu" +
    "enJzUbmBEdwUyj0d2WQS6VPuxA1tKM+AMQhjRIeS9lnQL+TMmTHduUd5ISb1" +
    "R4EcGDOSr3QCnyG0B0tvMDKwD956uy6Q11gMbmBEjj11ZJNJpE+5Eze0oTwD" +
    "xiCMER1K2mdBv5AzZ8Z05x7lhZjUHwVyYMxIvtIJfIbQ3sHOCc/OUl6iloF9" +
    "wMWx1/S/f239O7z3kp+CSD4G+iTU3wUZOdwDcmwGob3nI5KTUv0x5MTI0Vka" +
    "zLnljiea5hXOV2byjO0DGdg1XBTDfuvFGkttLgkZOdTmckZOjBydpcGcz/L+" +
    "10f1DC2hwcjALvHus/z5pWcaS20uCRk51OZyRk6MHJ2lwZyTvL/Y8xvVPHO7" +
    "RAZ2hXuf5ULT3P6T2lxcMnKozeWMnBg5OkuDOSPv996lZ2qf919kYFdwEV5w" +
    "vmm+d61p7n4SPLGJ/bZzCvUjuUepDfUJ9T2bSE5K9XOgT3LZ1htEOiIHlHuM" +
    "sSm1z9Ep0afc0yGlaxdxW/uH+eULuv8iA7uAkzfsx6K4uCuSxlKbS75+DvRJ" +
    "WPzuAYjkgHKPMTal9jk6JfqUezqkdO1ysD/QPFv7ajAyMDfefZY/u7ReGC7u" +
    "iqSx1OaSr58DfRIWv3sAIjmg3GOMTal9jk6JPuWeDildu1w+v5D7LzIwN5zw" +
    "6y6sn871bkbSWGpzydfPgT4Ji989AJEcUO4xxqbUPkenRJ9yT4eUrl0J71nA" +
    "/RcZmBNO1u6zfPda01x88ownYi4ByvfBpSc3+cQ9TfO22yulfPweXdtTZpta" +
    "v/Dj/d9/kYG58C6HvvJA80xjOaLmYgeFc63k8aFLur6nyra1bn+4ub7GOed8" +
    "zoEMzAUn+O47m83GUptL5YzaYNZMUev2bJDre845n3MgA3PAydnl0LkfNbW5" +
    "VHqpDWa6Wt/X5ZEMTI33Zrmnr61PpLn8/rea5r9+qNLHsz+rNVIbzHS1/g8P" +
    "6dru4gu+ZWBqOKnXXmiaO3+yxj50ldKNb2DjCbS5w/wMQH9i78QVH8gh0mdD" +
    "tQP0rGdVhvi9V+kBMD54KV5/kRPq51DogzXg1R4R/cKYOXS+33Wnrm37kPM6" +
    "JTIwJd5N3G8+mEz8iU24MCuw4LThBhH6E3snrvhADpF+bS7jyG4wWH/ZH0L9" +
    "HAp9sAa82iOiXxgzh873/310fTuCa9s+5NxOhQxMCSeyKpJ04k9swoVZgQWn" +
    "DTeI0J/YO3HFB3KI9GtzGU9Wg8H6y/4Q6udQ6IM14NUeEf3CmDmk/v/ibl1X" +
    "q9X2Hzm7UyADU8FJWNe8+XFM/IlNuDArsOC04QYR+hN7J674QA6Rfm0u2xE2" +
    "GKy/7A+hfg6FPlgDXu0R0S+MmQNj7PLmrgxMgffzq5+9t2lu+3HAT2Ju//Em" +
    "oQ/KHcQnfRDHR8pbanPZmt4Gc1H3o3j/HBtCfe6xQH0nBuWhD8od7FsEUiIf" +
    "33hQ13Sum7syMAVM3m7irhY3ggvjIBtGaEO5g/ikD+L4SKnNZRr6GswHLm3u" +
    "R/H+OTaE+txjgfpODMpDH5Q7lDYX4wMXdU3bh5zjbZGBbfFu4n7n4bPFjeDC" +
    "OMiGEdpQ7iA+6YM4PlJqc5mOnAZTvH+ODaE+91igvhOD8tAH5Q5jmsv5x3Zz" +
    "c1cGtoUJf+zuZHEjuDAOsmGENpQ7iE/6II6PlNpcpiVqMMX759gQ6nOPBeo7" +
    "MSgPfVDuMKa5GJ+5V9ezfch53gYZ2AY+a7Hu+O+PrT9E5fI4oHwOGNODNoT6" +
    "4C231eYyNX0N5v0Xnf0hzh6F0EcE7cf42AVJfi+7SdfTzvFUyMA2MNFw4/ex" +
    "GYzpQRtCfVCbyzyMbjDOHoXQRwTtx/jYBUl+3vfutg8512ORgbF4rxB971Fn" +
    "cj0T3dlmMKYHbQj1QW0u8zGqwTh7FEIfEbQf42MXIMeX3aRr2T7kfI9BBsbC" +
    "BAc3u2eiIp8DxvSgDaE+qM1lXoobjLNHIfQRQfsxPnYBcvz0vbqO7UPO9xhk" +
    "YAzes5Z/vtY0Nz0+jL2prpjHhrkJiH0G9MG8Ce3fXJvL7Aw1GKkJZ88iuKd7" +
    "IWMetKE84v85HwuY6n0vMjAGbvCfXtRJeHBhssCCEzYGsc+APpg3oX1tLruh" +
    "t8Hc1YSHMoJ7uhdY248rtKE85DH/N6fbh5zzUmSglLHPWgwuTBZYcMLGIPYZ" +
    "0AfzJrSvzWV35DQY7lcO3NO9wNp+XKEN5SGPzffsRQZK4abmPmsxuDBZYMEJ" +
    "G4PYZ0AfzJvQvjaX3RI1GO5XDtzTvcDaflyhDeUhZzU+x7MXGSiFCX3tatPc" +
    "+Pgaeyfg3NwISuVjiHy+qTaXndPXYN53l+6PR1ezfbUb7fm+YF6E+n3Y701f" +
    "d35z7bZ99iIDJXAj7S/20AbNQbSYkXwMkc/aXPbDNg3m1JuL8ecTP3uRgRKY" +
    "SPqsxdugOYgWM5KPIfJZm8v+GNtganNpmu88ouu2zfe9yEAuTMIOVLRBcxAt" +
    "ZiQfQ+SzNpf9MqbBRLUb7fm+YF6E+hG2Rly39iHnPwcZyIUJfO6+9eeINvjR" +
    "MPYLACli/5jqnLOxBPoMcWIItCmkNpf909dg3ntXXh1F8hykdskEMQh9Mib1" +
    "Wfve9720Dzn/OchALkzg+9c0UZkIF4ITp72zOFw8+gxxYgi0KaQ2l2Uw2GCC" +
    "OorkOUjtkgliEPpkTOpL7be89KbN9Rr7M7AykAM3y55KuYlyIkAmTntncbh4" +
    "9BnixBBoU0htLssht8FwD7euM/MRMUEMQp+MSX2p/cemu7ErAzkw8Jev9CTK" +
    "iQCZOO2dxeHi0WeIE0OgTSG1uSyLnAbDPdy6zsxHxAQxCH0yJvWl9lu+7dzY" +
    "bR/SByJkIILvyL3u/ECinAiQidPeWRwuHn2GODEE2hRSm8vyiBoM93DrOjMf" +
    "ERPEIPTJmNSX2j+DNTymwchABAP+2aWm+bdH19jbiDf40Sb/BqhP+Yoz370x" +
    "Ah9RDp5OiBM35Y231uayRPoazHvuythjyKWGqP/oZt16tRv5ELkDdQh9EtE/" +
    "4zP36Tq1D+kHQ8hABAP+r6tN7+JFC0F9ylec+e6NEfiIcvB0Qpy4KbW5LJe+" +
    "BhPuMeRSQ9R/dLNuvdqNfIjcgTqEPonon/Hda7pG7UP6wRAyMMSLb9wMZpdI" +
    "Q4sXLQT1KV+R+HdjBD6iHDydECduSm0uy+a/vEMPTrjHkEsNUf/Rzbr1ajfy" +
    "IXIH6hD6JKKfYM/ouE5dL8hBBoZgIPsFt6HFixaC+pSvSPy7MQIfUQ6eTogT" +
    "N6U2l2Xzn5+vhybcY8ilhqj/6GbderUb+RC5A3UIfRLRT/jSFV2n9iF9oQ8Z" +
    "GIKBvvnQ+gNP2VwLoP4UMIZHZEM5gX5tLsvGay7Rnoo8hyl8zE2Q43XnN9ep" +
    "5D0vMtAHN+Ptt2siIdcCqD8FjOER2VBOoF+by7KpzSUhyNF+Qpdr1T6kP3jI" +
    "QB8MYN+9yURCrgVQfwoYwyOyoZxAvzaXZVObS0KQ49ev6lq1D+kPHjLQBwMU" +
    "XxJ5EyHUnwLG8IhsKCfQr81l2dTmkpCRIy+N2of0Bw8Z6CN1/pKbmuZ715R/" +
    "Ad97ZJNITn85iM9Izpgj424Af2+ozWXReM2FdUK455Hc41/sDKTQB+qIcrE3" +
    "PSfOUEyRA8qNt+EXRO1V4/Yf6RFEBjy4EfZD1kzATTRYLMrpLwfxGckZc2Tc" +
    "DeCvNpdlU5tLIgeUGx+9W9erfUifIDLgQcefv18TcBMNFoty+stBfEZyxhwZ" +
    "dwP4q81l2dTmksgB5cZXf6jr1T6kTxAZ8KDjbz+sCbiJBotFOf3lID4jOWOO" +
    "jLsB/NXmsmxqc0nkgPKOMfddZIDY19ylTl95S9P88yM+3w2g/ixcA5Q7lOYZ" +
    "6b/+SJqL5c1DeAzz8ppLtKdzMElMq/EE+iRiD6jf2bzrzs31yrnvIgOEm2C/" +
    "aMeEhhJjkrNzDVDuUJpnpF+by7KpzaUf6nc2n7hH16x9SL9IkQFCh/Z1lkxo" +
    "KDEmOTvXAOUOpXlG+rW5LJvaXPqhfmdjH1DmmrUP6RcpMkDo8B8f0oSGEmOS" +
    "s3MNUO5QmmekX5vLsqnNpR/qpzb2FpR0zdqH9IsUGUjh/Zbrb1l/S9XTPLzJ" +
    "d0p5JAPagNIcNvI/gzrMIdQHr79wHIfwlJoL97C0rlgzq7px/JT4pL4HbUhp" +
    "7XIO6Rl85x26bu1D+kaHDKTQ0fsuIllLPkESjeAkPGgDSnPgYrsLjhxCfVCb" +
    "y7KpzWUAZx6d7OOF73eRgRQ6+uIVJGvJJ0iiEZyEB21AaQ5cbHfBkUOoD2pz" +
    "WTa1uQzgzKOTfb3w/S4ykEJHTLR0ogIn4UEbUJqDzMGLgRxCfVCby7KpzWUA" +
    "Zx6p/LobNtetfUjf6JCBlNTJ81un//TQJt8CIn94k1DuQB3GFDmIYq50CGyI" +
    "5ABeV5vLovGai9REsOeUSw2NgDGIxHR0ZB6MEcgjWNvtQ/pGhwykpE7MaTQx" +
    "kXMikdyBOowpchDFXOkQ2BDJAXADDvUQ1ubSv+eUSw2NgDGIxHR0ZB6MEcgj" +
    "+HOvQ2+mk4EOfl+uOY0mJnJOJJI7UIcxRQ6imCsdAhsiOYDaXJZNbS798gg2" +
    "F6N9SP8wZKCDDmpzSXwE1OaybGpz6ZdHfPF+Xbv2If3DkIEOOjCn0cREzolE" +
    "cgfqMKbIQRRzpUNgQyQHUJvLsqnNpV8e8bWCV4xkoIMOvvxA0/zDQ4U8CErl" +
    "OUzhA/zjg5tQHvHa2lwWjddciusoR586hPoRtPegTQTs7R34hDZcu/Yh/cOQ" +
    "gQ46YIAsoolH8hym8AFqc1lTm8sAOfrUIdSPoL0HbSJgz8biNZfrb95cu/Yh" +
    "/cOQgY7U2JwxQBbRxCN5DlP4ALW5rKnNZYAcfeoQ6kfQ3oM2EbBnY/Gay5vx" +
    "O9L2MaH2H+khMtCRGtthYYAsoolH8hym8AFqc1lTm8sAOfrUIdSPoL0HbSJg" +
    "z8biNZf3Zr5iJAMGDe1nHf/+wfn5hsPfXwWO3RD0lwN9RNC+Npdl4zUX7mkI" +
    "6pI14NXRtvI5GBPzI5d1/dqH9BEZMGhozhhgDjjR1WRrc9kbtbkMcMLNxb7T" +
    "ievXPqSPyIBBQ3PGAHPAia4mW5vL3qjNZYATbi4G1699SB+RAYOG9qtrdD4H" +
    "nOhqsrW57I3aXAaozWWD9iF9RAYMGv7vq+uvuSvF7FIoJ9Rf2TwIHLu5kZwC" +
    "XlOby6Lxmgv3sHTPPabwsS1z5cD1ax/SR2TAoOHYpEonRv2VTW0ue6M2l/w9" +
    "95jCx7bMlQNrvH1IH5EBgws/NqnSiVF/ZVOby96ozSV/zz2m8LEtc+XAGm8f" +
    "0kdkwODCj02qdGLUX9nU5rI3anPJ33OPKXxsy1w5sMbbh/QRGTBSo5ffvL6h" +
    "a19xF2EfakqJ5IT6Kyx2QmTzNdNJoJz+3LlF8oDX3HIch/CUmgv3cBZQV2Gt" +
    "TgFrmVDfgzZXJ2ou5iQ3ifDgB1B/BSYV2YQb5ixUqEN5QG0uy6Y2lwTqe9Dm" +
    "am0u/oY5CxXqUB5Qm8uyqc0lgfoetGl5J37etX1IH5EBIzWqzcWRB9Tmsmxq" +
    "c0mgvgdtrmpz8b7uUhqLkRq9uj0oX20D/O0PyjG7Emi/wsZTGAOUylc6UR6F" +
    "OdiaHcMhPKXmwj2M9jyUOzpRnYU5ONCGMYjEpA79Qb/jTzJ+IE0ai5Ea/Mmd" +
    "flI5SOIBtF9h4ymMAUrlK50oj8IcanNZNrW5JDGpQ3/Q7xjVXHgwanNpinPg" +
    "Gh7qIazNpX/PQ7mjE9VZmIMDbRiDSEzq0B/0O0Y1FxrU5tIU51Cby7KpzSWJ" +
    "SR36g37HJ+7RNWwfZc3lj9sO9T9/MJIHNvmbH2wi+hn8jflJYAyB9hnQhj5F" +
    "H/JX1eayaLzmwj2UGhgDfRbWkdQ6/Ztdhs4cfLw2F8c+A9rQp+hDXpvLsqnN" +
    "ZXtGNRf7PszUoDYX9Sn6kNfmsmxqc9ke6wtcw/Yx3FyM1OAtt6njbLhYP8Bi" +
    "jkAWM4L2GdCGPkUf8tpclk1tLtszSXOxg0LH2XCxfoDFHIEsZgTtM6ANfYo+" +
    "5LW5LJvaXLZnsuby123SX3Gw8SEi/Uju8ZUrwPEz6POKQhtCffEJanNZNl5z" +
    "4Z4T7jFrgvoe9BHJRxHkJfoZ0IfxDjQXe4W0/ac2F0IbQn3xCWpzWTa1uZRB" +
    "HwabS/uQPiIDRmpUm4vqi09Qm8uyqc2lDPowXokabx/SR2TASI1edGN/ACZB" +
    "Iv1I7lGby+6ozSW/jqjvQR+RfBRBXqKfAX0YkzQX48ttkn/lYOO7pjSHHH3q" +
    "RHz5AQB/XPhDPYSn1Fy4h0RqYAbCGKw7p/booxT6c+Ne0RpvH9JHZMDwFp5J" +
    "9CYyM6U55OhTJ8Jb7BQu/KEewtpc+muE8ikIY7DunNqjj1Loz417RWu8fUgf" +
    "kQHDW3gm0ZvIzJTmkKNPnQhvsVO48Id6CGtz6a8RyqcgjMG6c2qPPkqhPzdu" +
    "O/bSmzbXr31IH5EBw1t4JtGbyMyU5pCjT50Ib7FTanNZNrW59EN/btwrun7t" +
    "Q/qIDBg0/PS9TfOl+x2uAMoDvnhlE8pdopiUA8Z049IO8i8S+Lu+NpdF4zWX" +
    "aM9DaO/4YJ1QHkL/5sf8JojNFDDu/bp+7UP6iAwYNPzwZSdgT9ASRi12FJNy" +
    "wJhuXNpBzg2lvyU1F+8gLYHfe5Xmuiu8NYn2PIT2jg/WCeUh9G9+zG+C2EwB" +
    "Yv7llD9Eb9/pIgGdoCIPGLXYUUzKAWO6cWkHOTeU/pbUXAw7yNzTffLszzbN" +
    "f/gdzXNX1OZSCGLakw2uX/uQPiIDBg3fdrsT0Akq8oBRix3FpBwwphuXdpBz" +
    "Q+lvac3FDrIdaO7rPvj9b+23sRi1uRSCmDnfQmfIQEdqeP3NTfP5+5Qv3F8G" +
    "7T9vYwnU92woJ9TP4Qsk8Ek5sfVK12/fzcWwA20Hm0WxSyz+f/xdzW3XeM2F" +
    "e1i656xlr57FZymezwDRD3Kg3INfy2K0D+khMtCRGr7wvAZYJeYkPwTto4Xw" +
    "bCgn1M+BCxz5pJwssbkYdrD32WB+99ma0z6ozaU/B8o9WN/tQ/qHIQMdXHwG" +
    "WCXmJD8E7aOF8GwoJ9TPgQsc+aSccPGX0lwMO+Dc211gB5q57IvaXPpzoNzj" +
    "JRnvcTFkoIOL/9HLGoSJR9A+WgjPhnJC/Ry4wJFPysmSm4vhHa452ecrQx7e" +
    "/LmHpXvOWvbqWXyW4vkMEP0gB8o9uHbtQ/qHIQMddPC+u5rmc/ctkHtBqXwE" +
    "9lJcCmO8YuHNxdjVK0j7fmXIw2su3EPuOeVSAw6hTmFMkTuEMQNov/KR5PDh" +
    "S7p27UP6hyEDHXTw5ts0kUUQbUAkH8HQ4huH0Fx28QrSEl4Z8qjNpR/ar3wk" +
    "OXzwoq5d+5D+YchAB3975/W3aiKLINqASD6CocU3DqG5GHO+grSUV4Y8anPp" +
    "h/YrH0kO9iSDa9c+pH8YMpCSOrADw0QWQbQBkXwEQ4tvHEpzMeZ6BWkprwx5" +
    "1ObSD+1XPpIcXn9hc928r7fskIEUbsBn7i3DPpOUQjmhfpbNPZt8hlDfgTrb" +
    "8vIDai7G1K8gLemVIQ+vuXAPI2apoaB2c4jyovzTPD+BDWu7fUjf6JCBFG7A" +
    "J3qC98GJUE6on2XDxSHUd6DOtnADlt5cDO/AjWFprwx5eHPlHkbMUkNB7eYQ" +
    "5UX5p3l+Apvn3rC5bu1D+kaHDKRwA95zlwYeghOhnFA/y4aLQ6jvQJ1tOcTm" +
    "Ymz7CtISXxnyqM0lgednwOajd+u6tQ/pGx0ykEJHb7pNAw/BiVBOqJ9lw8Uh" +
    "1HegzrYcanPZ5hWkpb4y5FGbSwLPz4CNfcaQ69Y+pG90yEAKP0PwRzdq4CE4" +
    "EcoJ9bNsuDiE+g7U2ZZDbS7GmFeQlvzKkEdtLgk8PwM2/OL5F9+4RXMxuAl/" +
    "0T41+uQ9Pp8K+OS9m1DuQRvGJLTPQWIEeUYxD7m5GKWvIC35lSEPr7lwD7nH" +
    "EbRfce8mtClF/Ds6peT462Ql91sMGSDcBPsZRwZnEn1Eh9aDNoxJaJ+DxAjy" +
    "jGIeenMxcl9BWvorQx61ufT7pLzT+VDBO3M7ZIDQ4WsvaPC+REl0aD1ow5iE" +
    "9jlIjCDPKOYxNBfDO4Qph/DKkIc3L+4h9ziC9ivu3YQ2pYh/R6eUHH82zlsk" +
    "RvuQfpEiAx6pwxec1+B9iZLo0HrQhjEJ7XOQGEGeUcxjaS5G3ytIh/LKkEdt" +
    "Lv0+Ke90Su+3GDLgwY34s/Yp0sfvzuCeAOp7wMbu+aRQLvZ74GX4SPohNxfv" +
    "FaRDemXIw2su3EMhqjPKPZ2Ibe096HMMd5ffbzFkwIMb8fbb1wFDmCShvgds" +
    "anPZPekrSIf2ypBHbS5lvL/gw4opMuBBx6+50OgkPJxEN6C+B2xqc9kP3StI" +
    "h/bKkEdtLmW8peDDiiky0Efq2O67yCQ8nEQ3oL4HbGpz2R+/85907BCpzaUM" +
    "1vPQhxVTZKAPboZ9r8PHLoO7N7Fvr0sJ9UdAH2OgTwHzoJz+uBnH0lyOBa+5" +
    "lO6xyFnbTn0L0A9zoH/q2xhjgNCnY8O1ah/SHzxkoA8GsI8CRInJxAn1R0Af" +
    "Y6BPAfOgnP5qc1k2tbkM+IR+7s+IeMhAH/bSUxrA/j9KTCZOqD8C+hgDfQqY" +
    "B+X0V5vLsqnNZcAn9O3+KtfK+kEOMjAEg8ilESfCiRPqj4A+xkCfAuZBOf3V" +
    "5rJsanMZ8Jno2i8r8iVoezOd9YIcZGAIbsjrLqwTyObSJh+5vInoOzal8pwY" +
    "1CFRDPLS2lwWjddcuIdTIHVUiNizDjNqUYD9R0Cq+5YR78pNkYEh+L261513" +
    "kh+CE7ucsfjRYgbynBjUIVEMUpvLsqnN5RmGmgu/rnXW5mIw2DvvdCbQByd2" +
    "OWPxo8UM5DkxqEOiGKQ2l2VTm8sz9DWXsW+cS5GBCAa0zxzIBPrgxC5nLH60" +
    "mIE8JwZ1SBSD1OaybGpzeYa+5vLGkW+cS5GBCH460m742GeNDpqLgPJC+HOX" +
    "tbksC6+5cA/tKwZSKM9hCh/74kXOq8NdD8hFBnLgxthvmTC5g6I2l5OiNpdh" +
    "3n2nrk/7kD4QIQM5MLB9xQATPChqczkpanMZxr6zievTPqQPRMhALgxuvyXN" +
    "JA+G2lxOitpchrFXgdO1yf0sEZGBXLg59ktsH7y0yQfIxU3sTXgbwN4j8hHJ" +
    "PWgjBPMgtbksG6+5cA+J1ExhTbg+AnkOzEPkIJLznqrRPuT85yADufDjANfd" +
    "0GgjIMFEae8R+YjkHrQRgnmQ2lyWTW0u/fJX4r1se2kuBpOwrlebS20uS6c2" +
    "F18+1Y3cDhkogYnYoarNpTaXpVObiy+/fst35BIZKIXJvOOOpjaX2lwWTW0u" +
    "KveetYy9kdshA6UwIftVxj+9q4eLgPIpiGJQ7ukQ6hPo2xrU5rJcvObCPdwJ" +
    "rCNCfY8xNg5TP2sxZGAMTMp+U5bJr5hoIQaJYlDu6RDqE+jX5rJsanPZ5F0z" +
    "PGsxZGAMTKz32csECxESxaDc0yHUJ9CvzWXZ1OayCb/twGgfcs5LkYGxMDn3" +
    "2csECxESxaDc0yHUJ9CvzWXZ1ObyDO9tec6/b67FmM8RecjAWLhZ9l0QlngR" +
    "dyrvuWuTUrnEyCHywRwA3wNUm8uy8JoL9zTac8pZA7NgcQDziuTMe8r3tRAZ" +
    "GIv31OpPnMkMwoXIWKxILjFyiHwwB1Cby7KpzWXNu++a71mLIQPbwA0rfvbC" +
    "hchYrEguMXKIfDAHUJvLsqnNZQ1//9loH3KuxyID27D1sxcuRMZiRXKJkUPk" +
    "gzmA2lyWTW0u8z9rMWRgW7hpL2kTfvcdZ9y5ybvu2ORpvQTq2MtmQ0iMQO5B" +
    "GyHIqTaXZeM1F+5hWBOsAYfQRylTxDizm+N9LUQGtsV79vKGC01tLk6RV/bD" +
    "qTeXtzuffD6I5mIw6eff0DTv9BaCC+VAHVksIDECuQdthCCn2lyWzak3F9bn" +
    "HI3FkIGpYPKvvNlZCC6UA3VksYDECOQetBGCnLh5tbksi1NuLnYVwblP8W5c" +
    "DxmYCk7AsDfW2W/PHh02rwR+uXFtLsvCay6yp/sAdfTHdwAbA+JjAPtQMW/i" +
    "Gu1Dzu8UyMCUcBJ26Djho6A2l4PiVJvLtj9yVooMTIl3c9d+ApaTPnhqczko" +
    "TrG52C90cM4H3VwMTuZ5N6yfnnHyB01tLgfFKTYX1uTcjcWQgTngpOynSOzl" +
    "MGsyG9gYML0N7gCUB9C/FyOSMwfqvxDfnl5ZPtxTwj1m7UqNOHUiciAxMqAP" +
    "D++duHPdxE2RgTngxIw33rq5ObW5VPYJ95Rwj1m7UiNOnYgcSIwM6IPY91rv" +
    "8iZuigzMBSdnB5AbxIVzF69wwwj9ezEiOXOgfm0uhwf3lHCPWbtSI06diBxI" +
    "jAzog9hVAud6zjmfcyADc+Hd3LWJ1+ZSWQLcU8I9PoTm8hrnPS1Tf35oCBmY" +
    "E07UsJ+OfOttA9wOSuU50EcE7YG9YfBlNwEb2wb6G8MSfJbqezaE+iPgHpbu" +
    "uejfvn5fV0poE8kz6GK96bb9XQ51yMDccLK2APYymSxs3wKXynOgjwjaZyCF" +
    "Vorjs5g9+HwbiPSzbIDoZxDaMA7lhPqWFwhtInkGXSz+JKthcp7HOZGBubEJ" +
    "ctJ2GSEL27fApfIc6COC9hlIoZXi+CxmDz7lEAf6WTZA9DMIbRiHckJ9ywuE" +
    "NpE8A4tjz+Z4xnZ5OdQhA7uAn70x3Kem3gKXynOgjwjaZyCFVorjs5g9+JRD" +
    "HOhn2QDRzyC0YRzKCfUtLxDaRPIMvPssBs/gLpCBXcHJG+79Fy5gqTwH+oig" +
    "fQZSaKU4PovZg085xIF+lg0Q/QxCG8ahnFDf8gKhTSQPeONt+7/PkiIDu4SL" +
    "8Iftwrzp1qZ5c8ptw5h+CuUbvvqIbCgfgd1gSwljUE6o79hwbQj16Y/6K5I5" +
    "rOZB6JNQPwPmQPkYQp/Im/MmYu9QHJP6AfbVJjxT1nR47naFDOwS7+XpF5zH" +
    "onEDttwwl8iG8hFIMUYxKCfUd2y4NoT69Ef9Fckc3ENFn4T6GTAHyscQ+kTe" +
    "nDcRe4fimNQf4KU36Vnax32WFBnYNVwQwxbq6YXjBmy5YS6RDeUjkGKMYlBO" +
    "qO/YcG0I9emP+iuSObiHij4J9TNgDpSPIfSJvDlvIvYOxTGp38OrnBu4Bs/a" +
    "rpGBfcBFMV5zy9nicQO23DCXyIbyEUgxRjEoJ9R3bLg2hPr0R/0VyRzcQ0Wf" +
    "hPoZMAfKxxD6RN6cNxF7h+KY1HewL3+y2wk8Pzxj+0AG9gUXxxbs1RfWi7eB" +
    "LegA9pmlIai/gjFIpE95Bll5FepTh1Bf5kGon0EUM5JPAufhAZswL9i/EYh+" +
    "jk8S5ciYF5Z3nyVFBvaFd//FGszrgwUn3FBC/RWMQSJ9yjPIyqtQnzqE+jIP" +
    "Qv0MopiRfBI4Dw/YhHnBXg469XN8kijHNN4Fv7Hs+z5LigzsE+/9L7aAGw2G" +
    "G8INCKD+Cm4qifQpzyArr0J96hDqyzwI9TOIYkbySeA8PGAT5gX7fTeXvs+v" +
    "8UztExnYN1wsaTDcEG5AAPVXcFNJpE95Bll5FepTh1Bf5kGon0EUM5JPAufh" +
    "AZswL9jvs7l4f4SX1lgMGVgCXDTDXqK2r8icA3vzXgrlEWPsaUOoPwenEvNo" +
    "uKVpXnQAz1g6ZGApcPEM+6o+WfAJ2Lbgx9jThlB/Dk4l5rFgH5HhmVhqYzFk" +
    "YElwEedqMNsW/Bh72hDqz8GpxDwGDq2xGDKwNLiYhi00F38bti34Mfa0IdSf" +
    "g1OJeeh43yZnLOUl5z5kYIlwUY2X3LT+kmF7s12KjaVE8jFEPin3sPfwbOD4" +
    "2QD69OflEUH7HCIf28pzoA9CffuksFDqc0v7UbRxXnGL/ya5pTcWQwaWiC0k" +
    "F7drMNEmR/IxRD4p92CzoA8B+vTn5RFB+xwiH9vKc6APQn1pDM760QfZ1n4M" +
    "fY1lSe9lGUIGlkpfg7HPIQ1t8hxFEPmk3IPNgj4E6NOfl0cE7XOIfGwrz4E+" +
    "CPWlMTjrRx9kW/tS7A/nITcWQwaWTN/r+/aGor5NnqMIIp+Ue7BZ0IcAffrz" +
    "8oigfQ6Rj23lOdAHob40Bmf96INsa1+CNRbW+KE1FkMGlk5fg7H3wdgXYwu3" +
    "AMo9IptI7lFqQ31CfY8xNkP2HrQhpfpjbQqxHwpLiWLaJ4+HoP5Y+ur70BqL" +
    "IQOHQN8l0nU3NM313LCgaFwim0juUWpDfUJ9jzE2Q/YetCGl+mNtCllic7E/" +
    "kKzpQ20shgwcCn0N5rlsMEHRuEQ2kdyj1Ib6hPoeY2yG7D1oQ0r1x9oUsrTm" +
    "0tdY7DKJtX8oyMChwc2QBhMUjUtkE8k9Sm2oT6jvMcZmyN6DNqRUf6xNIUtp" +
    "Llan3qebjUN4uXkIGThEuCmG3Wm3V5JeAV7uQB3hZgC5vckpQnwAyYk6UU65" +
    "OgOEOXgEMSOflK90SGAj8gxoExHF9Ihi2pj9IWTtHkNjMWTgUOHmdA3mJe31" +
    "alqoLBK3mAkLA3IWkYf4AJITdaKccnUGCHPwCGJGPilf6ZDARuQZ0CYiiukx" +
    "FNP+8PU1Ftb2oSIDhww3qcOuZ7tCZZG4xUxYOJCziDzEB5CcqBPllKszQJiD" +
    "RxAz8kn5SocENiLPgDYRUUyPvph2g9Z7D8sxNRZDBg4dblbH827QAuktZsLC" +
    "gZxF5CE+gOREnSinXJ0Bwhw8gpiRT8pXOiSwEXkGtImIYnowpuH9zOoxNhZD" +
    "Bo6BvvcK2F+LP7rRKZQIFg7kLCAP8QEkJ+pEOeXqDBDm4BHEjHxSvtIhgY3I" +
    "M6BNRBTTI41nb4zruww6xsZiyMCxYC/hcQM77K+HXfN22KesU1KZR6n+yubG" +
    "TV5KqA8i/Rzok+Toh3lQTjL0JSbgWlI/B/pkDpRH9pJT4sPeQf4HPZdBh/oe" +
    "lhxk4NjgZnbYX5HcwiGl+isbFh6hPoj0c6BPkqMf5kE5ydCXmIBrSf0c6JM5" +
    "UB7ZS05nPvpeZjaO4RWhIWTgGOGmdthfE/vLERUOKdVf2bDwCPVBpJ8DfZIc" +
    "/TAPykmGvsQEXEvq50CfzIHyyJ452eW397vNHazRY0QGjpXoMmmocEhUaB4s" +
    "vuJiDvRzoE+Sox/mQTnJ0JeYgGtJ/RzokzlQHtmn+ZzqZRCRgWOHm91hl0n2" +
    "FZr2F6dSKaZtKC9ueW5PUzGO/TKIyMAp0PdqkmHXyFI4lUqA1U3fsxWDNXgK" +
    "yMCp0PfBR8NesrY33rGAKhVil0BD91ZO6TKIyMCpwWJIsUslKw4WVKVi2Bsz" +
    "WTMpXY2dKjJwigzd7DWsiOwvVIf9MNUGN8ak9jmEMSh3oE9CfUL9lU2Qh+iP" +
    "oXDtSvVXNgHUf6H5PeN554cvgU752UqKDJwyLJIUu1Sy62q3MHngHKRYA8IY" +
    "lDvQJ6E+of7KJshD9MdQuHal+iubAOpbU3nBjf2fCeroaqlSm4sLCybFrq+l" +
    "OHngHKRYA1js9CdyB/ok1CfUX9kEeYj+GArXrlR/ZRNA/egS6NReCcpBBipr" +
    "okslux/zdJHywDmwWCNY7PQncgf6JNQn1F/ZBHmI/hgK165Uf2UTYDp2U9/2" +
    "uV4CjUMGKpuwmIg9k7HLJfv+3hJeACgn1LfCD4linB+G9p4PkdOPYxNCH4T6" +
    "EbTP4Dk36F6Tc069VJ5BBio+LCzS3ZORwu5BDmUA9aWReEQxnEOVQnvPh8jp" +
    "x7EJoQ9C/QjaD5DTVA75e213iQxU+okulUqajBzKAOpLI/GIYjiHK4X2ng+R" +
    "049jE0IfhPoRtAfPP5/XVOolUBkyUInJbTJ2E1AK/Qw5lAHUl0biEcVwDloK" +
    "7T0fIqcfxyaEPgj1I2h/hjWV6NWf2lTGIwOVfHKajN0MtPsy1mhKsBuJQzzP" +
    "fEY4frcmiCF5ksA+W2cI2gPbj5ymUi9/tkMGKuNgYXpYQdvTbzkMDjykhAfG" +
    "xfG7NUEMyZME9tk6Q9C+xT5QmNNQjNpUpkEGKtvBQvWwZzNW6O7hO4OHlPDw" +
    "uDh+tyaIIXmSwD5bZ4gzO2so9ixl6KXklNpUpkUGKtPAwu2j77KJh5TIAfTg" +
    "oZuCIIbkSQL7bJ0BShqKcc7Zv8r2yEBlWoa+3oH8QcsftjzH/v33YewAEbNN" +
    "EXnk4yx2B/U9aEOf1M+BPgj1O0oainHO2a/KdMhAZT5Y3EPYQekunzx44FaH" +
    "7twmIo98mE0C9T1oQ5/Uz4E+SKfXrRHXbohzzr5U5kEGKvMz9F0yfbDZ8MCt" +
    "Dt25TUQOKGejoL4HbeiT+jnQR+qntJkY9V7KfpCBym7JeTnbw2s0x9Zc7L/H" +
    "NBOjvjdl/8hAZX+U3J/xsHs2HYfUXLpnZWMuc8g5Z10r+0EGKsuBB6einHPW" +
    "rbIMZKCyXHiwTpH6vSmHgwxUDoMxN4UPkdpMDhcZqBw2Y28Q75t6A/b4kIHK" +
    "8cIDvQ/OOXlVjhMZqFQIL8Hq+0YqOchApVKpTIEMVCqVyhTIQKVSqUyBDFQq" +
    "lcoU/H9uNGmzOVkzaAAAAABJRU5ErkJggg==")

LOAD_ROLLOVER = ("data:image/png;base64," +
    "iVBORw0KGgoAAAANSUhEUgAAARcAAAEXCAYAAACH0wDUAAA4ZklEQVR4Xu2d" +
    "efQ0V1nnmREBEQRRQGWJLLIjWyABQhKSQPKSBEISkpCFLSyBBBLWAKIsAWQx" +
    "BokIDDBENhdAdBBGR1EPm+GYGcQo6MCMHMMwMwePetBxZo5zTs3v6f71+1Z9" +
    "vk/Vc291VXd1973nfP65z3Lvfe5zn+6q6uVG11XVjQqFQmFopKNQKBSGQDoK" +
    "hUJhCKSjUCgUhkA6CtvPm66pqsuvPsSz31BVJzyvyV2fsKf4kJgffLTaPuny" +
    "pn+DcyhsP9JR2A5+/ffmh9oOuh14FoV18pDzDxWgd/9GKTzbinQUNovFu5Cc" +
    "dxtTZfEuqLzb2Q6kozBtrJjYq74dRB7ObWVRcBiLwrSRjsK0sMuGMYvJQ86r" +
    "quOf2+Rlv6D87h8fgjKDPgyONQQWB4uHFVnGqjAtpKOwXqyY2A3WoS5x7P7G" +
    "omC88d/uFYcvVtV3/q6q/uVfHP5fDxJ9WFF658fm8zjzZfN5ca59KMVmukhH" +
    "YfXYwVjmsNkBO+6iqrrwiqp6yduq6tNfqKov/llV/e//m8n/AZR7OoT6AV/7" +
    "6/l8bd6GrWOZd2lWlEuhmQbSUVgN9jTHXnF5OFKww3fGS6vq9e/bO5z/tf/B" +
    "FlIKBXUI9XtiRecdvz4vmHd5vMYgBbtXU55GrQ/pKIyLXfLkvjLXi8nBdyQ8" +
    "1EMc7BR/1CHUH4h6scmNn2Fxt4LO/SiMh3QUhseedOTeQ7HLg0YxITzUQxzs" +
    "FH/UIdQfCYuLxceKbk6xsX0oT55Wg3QUhsHejud8eO0Hj62qZ7y2qj7wqar6" +
    "x/+VwD8r/wQoFx/gn4DYe9AP5YBjcM6zeWf6ND735ap60c/P48jYtmH3ucr9" +
    "mfGQjsJyWFHJeZfyxJdU1dt/tapu+J/OoerCOWBySAl9AB58sfegH8oBx+Cc" +
    "+xaXOlagrVAz1m3YO5/ybmZ4pKPQD3sFTC0qDzq3ql73nqq6/hvOQUrFOVRy" +
    "SAl9AB58sfegH8oBx+CchyguCzsr2Fa4H/0c3QOPUmSGRToKeVgyplzz3+XU" +
    "+dv2z395/+AuCw/UPzuHlNAH4MEXew/6oRxwDM55yOJSxwq5xd/2gXtDSpEZ" +
    "BukopJFaVBb3UXiomPzZ8ED9s3NICX0AmSPtPeiHcsAxOOexiksduz+Tetlk" +
    "T5m494U0pKPQTWpRedprqupP/6qq/v67I/GPDtQB/wAoTyJzzJUQzYnyfR3b" +
    "n8uurKpbJ9wELkUmH+ko+FhRYcJ5jF5UFvyjA3VAKS6+zje/XYrMGEhHoYl9" +
    "8Cq6UWtJacm5kqKywA4IoQ4oxaVD57vpRcbeuZZH2DHSUThE9DmVRVGxpGSi" +
    "js7ikNShDijFpUOnhu3na95dVT8e3Py1z8kwZwqHkI5CfAlkReUFb62qb9xQ" +
    "Vd/5+8LU+Nt/aEJ5Dld+KC4y5cmSj3TsOtElUCkq02fI4rLgZ97Vfblkl0rl" +
    "S5JNpGNXib6hfMyz9xLnq5p0hekxRnEx7EXlKa/W3Khjl9LMrV1FOnaN6NGy" +
    "vVq977c00QrTZazisuDjnymXSilIxy4R/UDTJW+pqr/8ZlX997/dEr4TQP0h" +
    "WMUYa8Lyo+tSyS6xr6vl264hHbuAPV7uerdy9LPmP8vIZNp4eNAJ9YdgFWOs" +
    "kS/9eVWd+kLNoTq7+thaOradridB9ir01g9oAm0NPOiE+kOwijEmgL1gHXaK" +
    "5tQCu6d3HXJx25GObabrMuiSN+9dAv11tdUHQA46of4QrGKMCWGXSsytBbt2" +
    "mSQd20jXZZC9W3nXx+dfzx+M/+GQotOlPwYck1A/gW8BypPGSNHpIJyDgTG+" +
    "BSgXe1LT/fTnu9/F7MplknRsG12XQT95TlV98StOoiwLE9NLTsoJ9ceAYxLq" +
    "JxAe7JQxUnQ6COdgYIwhi4vx59+oqlMu05xbsAuXSdKxTXRdBl38piD5loGJ" +
    "6SUn5YT6Y8AxCfUTCA92yhgpOh2EczAwxtDFZWHzyndo7i3Y9ssk6dgGUi6D" +
    "wuRbBiaZl5yUE+qPAcck1E8gPNgpY6TodBDOwcAYYxUXw/6XaRcvk6Rj07GP" +
    "YHPzFtz/7Kr67Jer6q+/Df4boJxA/5tA9L89/zJcgwSbLnvKx4BjuuNGsYvk" +
    "Y8AxPSIbyGW/CP3B51f+c1WdfKnm5IJt/CkH6dhkbIO4aQue+7PO5jtJ0Joo" +
    "HfqSeNT/th7SFJsue8rHgGO640axi+RjwDE9IhvIZb8I/bX47LoHuG0FRjo2" +
    "lbbCcqtjquodH3U2PkiCTqAviUf9b+shTbHpsqd8DDimO24Uu0g+BhzTI7KB" +
    "XPaL0F+Hz09+rqrufLLmqrFNP+MgHZtI25cOWy+DSEsStAJ9STzqf1sPaYpN" +
    "lz3lY8Ax3XGj2EXyMeCYHpEN5LJfhP4Cn1/5+jw/mbPbVGCkY9NoeyJ0v7Oq" +
    "6j9+raq+8TdNvu5g33atQ/nXra8O5SnQB6F+D7iOcO3BHMQf9R2bUE6o38eG" +
    "ckL9BJtlY5eks9d3zis1d41teJIkHZtEW2E58IJ5YUlKEuu/AQeIOlGSpEAf" +
    "hPo94DrCtQdzEH/Ud2xCOaF+HxvKCfUTbJaNXZLOfn9bgbEnnsz5TUI6NoW2" +
    "R83nvKK5gWGSWP8NOEDUiZIkBfog1O8B1xGuPZiD+KO+YxPKCfX72FBOqJ9g" +
    "s2zsknRqsue8UXN50wuMdGwCqYXFCJPE+m/AAaJOlCQp0Aehfg+4jnDtwRzE" +
    "H/Udm1BOqN/HhnJC/QSbZWOXpAP569+nOb1gE3/lTjqmTlthef17nc37m4Qk" +
    "sf4bcICoEyVJCvRBqN8DriNcezAH8Ud9xyaUE+r3saGcUD/BZtnYJelQfsN2" +
    "FRjpmDJthcX+d9m+0Wx8LeKbDtRZAYv5ts07kg/BEGPQB6E+sR/jEjJ9rGM/" +
    "OUcP2qTysc/MP0LBPN+0AiMdU8UrLLYBb/tI5oYyEVeUjCRKxEg+BEOMQR+E" +
    "+kQKSykuM7oKDM/GVJGOKeL9Ir8F3jYge0OZiCtKRhLNO5IPwRBj0AehPpHC" +
    "UorLQSy/73uW5v6m3OSVjqnhPW5eFBbbgOwNZSKuKBlJNO9IPgRDjEEfhPpE" +
    "CkspLg3a3sFsQoGRjinhFRbj1e+uquu/sUa+Dih3sN/3qBPJI2i/qXBdKUQ+" +
    "KB+CIcagj4iF3a/9nl9gpv5BO+mYCm3fFVp7YTFKcRkMriuFyAflQzDEGPQR" +
    "Ube1AsOzYEz5qwLSMQXaCssLr9QNWwuluAwG15VC5IPyIRhiDPqIoL29sPJM" +
    "TLnASMe6aftKun05MfUgj04pLoPBdaUQ+aB8CIYYgz4iaG+0FZgp/lyDdKyT" +
    "th96OuNlVfXlv5rzp+Qvmyz0WjEdQh2Sq59Crs8EfYkNoH4EYzsj8Clyzps4" +
    "PiIdjkGo3wvMgXGgPuWezlA8/bV6RqZYYKRjXdhPUzJYxpFPawaWiZS9obWE" +
    "aUteIVc/hVyfCfoSG0D9CMZ2RuBT5Jw3cXxEOhyDUL8XmAPjQH3KPZ0hsRdc" +
    "nhVjSj+ZKR3rwvuQ3H2eVFWf/U/NoDKRsje0ljBtySvk6qeQ6zNBX2IDqB/B" +
    "2M4IfIqc8yaOj0iHYxDq9wJzYByoT7mnMzRtBYZna11IxzrwHjl7hcVgImVv" +
    "aC1h2pJXyNVPIddngr7EBlA/grGdEfgUOedNHB+RDscg1O8F5sA4UJ9yT2cM" +
    "7nOmnp2pPKKWjlXj3cD9gaOr6oOfqqo/+QuHrza57i+aUN4H8Ukcmy77PvMS" +
    "e+LYCLk21PcIbK77ahPqy7ocHRL6JBhD5GYXrStA/HlwDEL9CNrv8Qd7h+iO" +
    "B/QMTeF/kaRjlbTdZ7H/emEQ2zaEiUR5H8QncWy67PvMS+yJYyPk2lDfI7CJ" +
    "Dp2sy9EhoU+CMURudtG6AsSfB8cg1I+g/b6PD35az5Cx7vsv0rFKvPssp7/E" +
    "CWDHhjCRKO+D+CSOTZd9n3mJPXFshFwb6nsENtGhk3U5OiT0STCGyM0uWleA" +
    "+PPgGIT6EbSv+Xh+y39U88ytEulYFd59lnvvXT/+wZ84AXSCuYCJRHkfxCdx" +
    "bLrs+8xL7IljI+TaUN8jsIkOnazL0SGhT4IxRG520boCxJ8HxyDUj6A9fJzw" +
    "PD1T67z/Ih2roO0+yzWfrKpr/6zJHy/L9QnARuZA/T5wjOubRPoC9T1owzkA" +
    "ygchmhPlng6Q2Dk6XfpevCUW1KHPSN+xCYnsKQf/4UtVdYcJ3X+RjlXAxRsv" +
    "v1o3bJCEdzZBgI3Mgfp94BjXN4n0Bep70IZzAJQPQjQnyj0dILFzdLr0vXhL" +
    "LKhDn5G+YxMS2VPuYC/QN3qIso77L9IxNt59ltNePA8MN2yQhEfwXWAjc6B+" +
    "HzjG9U0ifYH6HrThHADlgxDNiXJPB0jsHJ0ufS/eEgvq0Gek79iERPaUe+zp" +
    "XfwmPWMGz+LYSMeYeNeE9zpj/nbOAsMNGyThGXwP2MgcqN8HjnF9k0hfoL4H" +
    "bTgHQPkgRHOi3NMBEjtHp0vfi7fEgjr0Gek7NiGRPeUe+7rHX6RnbdX3X6Rj" +
    "LLzvDd3y6Kp6729V1ef+dJ8vx3weUD4Ii/nsE435edOpcf6rquqhFzQ5PJNl" +
    "7YfysUrO++mWeHM/APeD+iLvwxg+A6I4uPPY7//0F6vqx07SM2f3O3k2x0I6" +
    "xsK7HHrp24NAOUjAxwAbGI3JZLeDzLUW0nj8i5x4cz8A94P6Iu/DGD4Doji4" +
    "86jJ7IWb8TV4NsdCOsbA+32WRz8nIVAOEvAxwLyiMZnspbgsxxNQYGQ/APeD" +
    "+iLvwxg+AyTvOAdvHpCf9yqNr92e4BkdA+kYAy7OLofsl7UYCAmUgwR8DDCv" +
    "aEwmeykuy1MvMLIfgPtBfZH3YQyfAZJ3nIM3D0fuXR6t4i9KpGNovA/LWTVt" +
    "C0SEBHwMMK9oTCY7i4tdEtqrRcHHy5F6gZH9ANwP6ou8D2P4DJC84xy8eTjy" +
    "qz6isV3FD3xLx5DYs3Uu6p6nV9UfXTfnDyfCYj5t84rk5HAcFjtApXU379LZ" +
    "OPWFGt8hyN1TkmKforOMvkebj2OfrbEd++audAyJdxP3yg/pwtfNYj5t84rk" +
    "pBSXfm2VBSZ3T0mKfYrOMvoebT4+8jvz2xGM7Z7oRmMhHUPhJYolyR9dpwtf" +
    "N/U5efOK5KQUl/7Ny5sxCkzunpIU+xSdZfQ9unyc+1Ma1zF/3Fs6hoKLsKr5" +
    "259tX/g6qc/Jm1ckJ6W4LNdWUWBy95Sk2KfoLKPvEfnwbu6O9dUA6RgC7+9X" +
    "n3VFVf3eteBLPaAPQn1C/T1+H4hNBPw9+Lzm2ktxyW9tBeaUS534D8DvA8q5" +
    "xwL1U3zmwjGvzR/jLb+sMR3r5q50LIv3jed7PHH/0BJn8SH0QahPqH9ts7CU" +
    "4jKd1lZgTh6hwISH1MmbBtRP8ZkLx7y23xgWP8Z0jH8OkI5l8W7ivvOj+4eW" +
    "OAsPoQ9CfUL9a5uFpRSXabVVFZjwkDp504D6KT5z4ZjX9hvjE39YVbd8lMaU" +
    "Z3lZpGMZvHct57yidmiJs/AQ+iDUJ9S/9tD8SnGZZltFgQkPqZM3Daif4jMX" +
    "jnlt/zGeeYXGc+h3L9KxDHzXYtXxo5+pqn//xRa+ACgfgN8BMqaH46fh8wtN" +
    "aP+gc5txKMVl+dZWYB73At0fwv3y9kygDyBybwxHb2yiedbX+KMnajx5ppdB" +
    "Ovrifes53PhgQ4dAgs0xPRw/DZ9fQBKBUlzGaX0LDPfL2zOBPoDIvTEcvbGJ" +
    "5llf4wveqrEc8t2LdPTFe0L0/k86i2tZqLehQyDB5pgejp+Gzy8giUApLuO1" +
    "PgWG++XtmUAfQOTeGI7e2ETz5DrHfPciHX3o9a7FWajIB0CCzTE9HD8Nn19A" +
    "EoFSXMZtuQWG++XtmUAfQOTeGI7e2ETz5Dqf8TqN41BfC5COPnjvWt77iar6" +
    "5OfAZ7uxD9kR6pBQH3P4bY/IRwD9PbAUl9FbW4E56fm6P0kwT2xf6wQ5I3KH" +
    "3DFkjn3guJD/6u9W1S3w5Gioz71IRy7eu5aDGxwsjEiwHR0S6nNDPSIfAfRX" +
    "istq2qAFhnli+1onyBmRO+SOIXPsA8elfI8zX6YxHOLdi3Tk0vquJXFhdSTY" +
    "jg4J9bmhHpGPAPorxWV1bbACwzyxfa0T5IzIHXLHkDn2geNS/tnx3r1IRw7e" +
    "37E2NjVhYXUk2I4OCfW5oR6RjwD6K8VltW2QAsM8sX2tE+SMyB1yx5A59oHj" +
    "Ur7PGO9epCMHOzSc0OveU1W/+Udz7JOAQ/ObAaK/P5dl5sQxCPUf8ORmTEpx" +
    "Gb+1FZjHXry3J7bvgHsY5YnoA+r3oY9P2hDqk4Xehz89/LsX6ciBG2mHqmuD" +
    "hoDBI6IfJE0KHINQvxSX9bTWAnNJVYpLC3XdM16qsVvmG9PSkYq3kfV3Ld4G" +
    "DQGDR0Q/SJoUOAahfiku62teXnoFhnsY5YnoA+r3oY9P2hDqk7ruuz+ucVvm" +
    "916kIxVOgu9avA0aAgaPiP4Ac+IYhPqluKy3pRQY7mGUJ6IPqN+HPj5pQ6hP" +
    "qH/ixRo3nv1UpCMF7/HzRW+sqo/+fjcfA5QPQTjGZxwyfVBOfvKcZmxKcVl9" +
    "ayswj3me7mcfuOeU92EMn7m8+QMas743dqUjBe9G7i9/UidKVhG8cAwWllJc" +
    "traNWWC455T3YQyf2eydh9s/thmvvn8DKx0peJuVEoxVBC8cg4WlFJetbmMV" +
    "GO455X0Yw2c2e+fhtJdovOxjJ6wDEdIR4f1dyIuvSgvGKoIXjsHCUorL1rcx" +
    "Cgz3nPI+jOEzm73z8I6Paqz6fFtaOiL4iVx7Np4ajFUELxyDhaUUl51oQxcY" +
    "7jnlfRjDZzb7Z4I5bLAWREhHBAe0f8Wzjw8bvxKw0EvV72MT6VPu6SzL/c9u" +
    "xqgUl2m0tgJz/HN1DyNScihFp4sUe+oQ6pM2/We9XuOU+xew0tGFtzk/+36d" +
    "WBttC+ki1ybSp9zTWZZSXKbbvBw2uIcRKTmUotNFij11CPVJm/57f0tjZHnM" +
    "mtCFdHTBn7G86+P9ibXRtpAucm0ifco9nWUpxWXa7UmXN/enFBdf397RMU6s" +
    "CV1IRxvelxTtH9zaJubRtZA2cm0ifco9nWUpxWXazfshee5hREoOpeh0kWJP" +
    "HUJ90qV/2ZUap5yvA0hHG161//kPV9UHP93Oh8AHPxXg+FiWD32qiYzpjQs5" +
    "1yFgjPud1YxTKS7Tal5xYQ5wTyknkhPWn5lHKT4JbXKJ1vn9RzXjlPOZF+lo" +
    "g5txxFN1IkQCgWALjo9lkeB50A5yrkPAGKW4TLuV4lIbI1in/YUuY8Xa0IZ0" +
    "tMEB7Lc3OREigUCwBcfHskjwPGgHOdchYIxSXKbdSnGpjRGs84r3aqxSL42k" +
    "w8PbjOiSaDZxwGALjo9lkeB50A5yrkPAGKW4TLt5+cwc4J5STiQnrD8zj1J8" +
    "EtrkkrJOXhrZLRLWCA/p8OB3iW53QlVd8+8U+yuROiIHlHvQZ0RoXxv/INSJ" +
    "gD3HvO9ZzXiV4jKt5hUX7in3nHss+g7XmF0NysMxIBd7bwzi2OTysKc0Y5X6" +
    "I1LS4cGNsL/RZCC8YIgcUO5BnxGhfW38g1AnAvYcsxSXabdSXPI46+UaL9YI" +
    "D+kg3iPoi9+kgfCCIXJAuQd9RoT2tfEPQp0I2HPMUlym3UpxyeM1/0bjlXLf" +
    "RTqItxG/9OsaCC8YIgeUe9BnRGhfG/8g1ImAPccsxWXazctp7in3nHss+g5y" +
    "8KkTjQG52HtjEMcmF/Pb576LdBD7mbu608NOqar3fMLH/lKki/f8ZjfUn9mA" +
    "UG5+aojcI7AhtKf8Pk9qxmxTiwvvtZFNXZdXXKI97UPkk3JCfZfoDEW5Hdnv" +
    "6x39rGa8Uu67SAfhJhx4vjPBfTgpwoUQ6i8W1jWGyINg0n5GYENoT3kpLtNu" +
    "pbhk2O/rXfAzGjPWCiIddbz7LfZzljLBfTgpwoUQ6i8W1jWGyINg0n5GYENo" +
    "T3kpLtNupbhk2O/r2ReUGbPo5y+lo463Cb/wK84E9+GkCBdCqL9YWNcYIg+C" +
    "SfsZgQ2hPeWluEy7eXkd7WkfIp+UE+q7RGcoyu3IvqZ72xN0/1kzkouLd7/l" +
    "nR+v8bFu3gUoJ+/6uIPjJ8enUJ//PuKTOvBBfXLvM5tx29RDuEvFhXsY7Xkk" +
    "93RIrr4HfZBc/S4e9UyN23WV1o0F0tEQwtGJl1Sdh45wcpQTKSzOwSf0EcLC" +
    "4YxBOX1Qn5TiMu1Wiks/zn+Vxu26SuvGAuloCOHo0iurzkNHODnKiRQW5+AT" +
    "+ghh4XDGoJw+qE9KcZl2K8WlH693vmfUdd9FOhZ4GxAdOsLJUU6ksDgHn9BH" +
    "CNfgjEE5fVCflOIy7eblNvcw2vNI7umQXH0P+iC5+hH8vMsgxeXmj6yqX/y1" +
    "JleDoeWeTi6/+KtNKJ/pZEJ7cq8zmrHb1EO4S8WFexjlDXNiCDgGoX4fm0ge" +
    "4eU2a0dYXJhY5pQDRRNdVu7p5BIlyUwnE9oTbwM2sTEHyKauqxSXdnnEY/F3" +
    "r10fppOOBfy9XHPKgaKJLiv3dHKJkmSmkwntSSku026luLTLI1hcDNaOsLjQ" +
    "QSku6XMqxWXarRSXdnnE89+isWPtyC4u5pQDRRNdVu7p5BIlyUwnE9qTUlym" +
    "3UpxaZdHvNb5hnTb/xlJh+F97P8lV1XV2z7SzVXkw00ifcqTML91IOcYHrSh" +
    "T+pH3PP0Zuw29RDuUnHJzVVCfTePSIqPDn8pPkNgL2M6MHZtT4ykw/CCzwE8" +
    "cidOfcqTQLAp5xgetKFP6keU4jLt5uV3bq4S6rt5RFJ8dPhL8RkCexnT4U6P" +
    "a8au7ecXpMPg34iYMw7gkTtx6lOeBIJNOcfwoA19Uj+iFJdpt1JcasBexnR4" +
    "4JObsbOvCbGGtBYXJpUdFg7gkTtx6lOeBIJNOcfwoA19Uj+iFJdpt1JcasBe" +
    "xnRI/SdG6Zh1wvC4i6rq5z6QwAcB5QT6b/1APuITUN/Fxq7BeRHqk3s8sRm/" +
    "TT2Eu1RcmBPcc0J95oCXR5RHMJddMIYQ6HNMD/o40/mDRNaQ5OJizjiACyYu" +
    "cgJ92bAExCegvguDGUB9UorLtFspLofgmB708ew3avxYQ5KLy3PeqAO4YOIi" +
    "J9CXDUtAfALquzCYAdQnpbhMu5XicgiO6UEf1sf4eU+MpLB4xcX+dY0DuGDi" +
    "IifQlw1LQHwC6rswmAHUJ6W4TLuV4nIIjulBH9bH+CUVF+8zLm96//xn7oRr" +
    "ujG7pTE/NTiGzClA/CfqdOmTnyjFZdLNKy7cY8I9TslD5i6hPgnnkMAQPoRr" +
    "NH5JxaUt8DLA/iBdcGG94IaQ9+ch/hN1uvRJKS7Tbm053gX3OCUPmbuE+iSc" +
    "QwJD+BD25n535HgpLvS9T4pOlz4pxWXarS3Hu+Aep+Qhc5dQn4RzSGAIH8I1" +
    "Wly8D9KV4pKo06VPSnGZdmvL8S64xyl5yNwl1CfhHBIYwodwjRYXywXWkrC4" +
    "3OFAVV3xvvlP3EXYjd86kXwdvN7WQqy/hthkcvcnaOA3se1SceEeRjkQyVOw" +
    "c9Wg5i/VJ23IsvozcF5M725OjrOWhMXlbqdVpbhkUorLtBtz3OAeRjkQyVPY" +
    "ueLChCrFReURpbhMu5Xi0g71ZzjF5ehnai6wlpTi4qxNbDIpxWXarRSXdqg/" +
    "I6G4eD93GReXvYPymndX1at7YHY50D6FyEckT9XpgvZ3LcVl0s0rLtxD7vEQ" +
    "RGNEcg/aRPSxp41x1IUaQ9aSsLiYk7YBIjjJCNqnEPmI5Kk6XdC+FJdpt1Jc" +
    "8uxpY/QqLjwYpbjE0J4x3NRDWIrLsERjRHIP2kT0saeN0au40KAUlxjal+Iy" +
    "7VaKS549bYyn/IzGUGqJdMDgEc+oqlf9UlX9VA/Mrgvqe9BGeAegvAecw0+9" +
    "o4noQ37XxzdjuKmHcJeKC/dQcqAPQd4Q2ifldqAjPgOo72F6571KYyi1RDpg" +
    "UIpLFSYJ5aW4TLuV4tIO9T1Mr1dxsd/DrBuU4lKFSUJ5KS7TbqW4tEN9D9Oz" +
    "usAYspZIcWFCPfi89EEJJ06o70EbIQhuHziHKEkoL8Vl2q0Ul3ao72F6gxQX" +
    "OyipgxJOnFDfgzZCENw+cA5RklBeisu0Wyku7VDfw/QGKS4/fmpVvfzt8w0h" +
    "LydvbxLpR3LXJ3H8dPqEP2+ehPr0SX2L2TYcQuYC2dR12R5xLdxD5hn3nDlB" +
    "fS836YP6Iqc9xvRykXIZg3KO49gIe3pHPq0ZP3tCylpSikuKD9rAJ/VLcZl2" +
    "sz3iWriHzDPuOXOC+l5u0gf1RU57jOnlIuUyBuUcx7ERrtbiYrnAWiLFxQzr" +
    "RqW4qD59Ur8Ul2k32yOuhXvIPOOeMyeo7+UmfVBf5LTHmF4uUi5jUM5xHBvh" +
    "aj/HWUvC4nLrY1smcXXCwgL9SO76JI6fTp/w582TUJ8+qe8FfhNbKS6H4J4z" +
    "J6jv5SZ9UF/ktMeYXi5SLmNQznEcG+FqP8dZS8LiYrz4qvkf0Ye8rYnZdSH6" +
    "HrSJgE/K6S/JJ5A5gsNO0cBvYtul4sKcIMwBQv0+MHeZV5S7mJ8uAn3OaUZt" +
    "DrN5XOXnOGtJKS60T0DmCLzAb2IrxSU9R6jfB+Yu84pyF/PTRaDPOc2ozWE2" +
    "j6s0x5/9hlJcxF+STyBzBAz8ph7CUlzSc4T6fWDuMq8odzE/XQT6nNOM2hxm" +
    "89jr+5HHNuNnMWUtkeLi/W/RbOEpYOIySSD6HrSJgE/K6S/JJ5A5glJcpt1K" +
    "cWnX55xm1OYwm8dVGr+k4jLrhOHTX1tVl/6cctmVTUQOKL/UbOpQ7vgg1Bc4" +
    "hgdsuK5wTPi788nN+G3qIdyl4pK755SLvecDeRL6jOwTfFBOUvSpYzB+vYvL" +
    "6S/VAWeDIpgiB5RHgfJ8EOoLHMMDNlxXOCb8Tam4eAdpCtg1+rqaF5PcPadc" +
    "7D0fyJPQZ2Sf4INykqJPnef+rMbP/irluqpHcbHfdOGAs0ERTJEDyqNAeT4I" +
    "9QWO4QEbriscE/6mVFys2UHmnq4T+3Ls332Xs1xdK8UlT586Z7xU43dd5dQR" +
    "dsw6YXj4BTrgbFAEU+SA8ihQng9CfYFjeMCG6wrHhL+pFRc7yPy2+7qwH3Je" +
    "Z2GxVopLnj51Un6FzpAOg9fad3pcVV38ZuWSTGhPqO/ZUH7JW5pQPwXxCXL1" +
    "LV71+K27uFizA20Hm0mxSma/EP81zmz1zSsu3MPcPae+ZxPJ+0CfJNKP5B7e" +
    "CxVrSGtx4dvoWx2jA3gTi6A9ob5nQ3kpLunNDvY6C8y7f4MzWk8rxSVd7uHl" +
    "N2tIa3Hxgs8BvIlF0J5Q37OhvBSXvGYHnHu7CiynptK8/OYe5u459T2bSN4H" +
    "+iSRfiT3uN1jmrHz/oS+tbh4n3U56+U6CCcWQXtCfc+G8lJc8pt3uMZknU+G" +
    "vOatn3uYu+fU92wieR/ok0T6kdyDsfMeQ7cWl5kADh57cVVd9MZunhOQq59i" +
    "kyv3iGwi+UVvaHLHiRcXa7z0HYt1Pxnymldcoj3OlXs6AvKG8mx/DvQRQfsZ" +
    "tTme6TwpsjcjrB9ZxeVB5zqDAk6U5Oqn2OTKPSKbSM4k2YTisoonSFN4MuS1" +
    "Ulzaof2M2hxPvUxjx9oRFhf+9859nuQMCjhRkqufYpMr94hsIjmTZBOKi7Ux" +
    "nyBN5cmQ10pxaYf2M2pztDcZjB1rR1hc+DjaDowMCjhRkqufYpMr94hsIjmT" +
    "ZFOKi7WxniBN5cmQ10pxaYf2M2pzvM+Zzbh5P28ZFhdvAy58XZNnXgGsr8aF" +
    "V3STqz+zATInEui761iSOxxoxm3KxcXa0E+QpvRkyGu9chsk6dfzMCHvIrkL" +
    "xzA/NahPecqYdX0vt1k7wuJi3xXgBlzw08FEgoWSXP2ZDZDgkEDfXceSeBsw" +
    "9eYduD5M7cmQ17y15uZEkn49DxPyLpK7cAzzU4P6lKeMWde/6cObcWt7UtRZ" +
    "XGZCbMBxFwUTCRZKcvVnNkCCQwJ9dx1LsonFxdqyT5Cm+GTIa6W41EgYc6F7" +
    "1is0bt4XFnsVlwecE0wkWCjJ1Z/ZAAkOCfTddSzJphaXZZ4gTfXJkNdKcamR" +
    "MOZC96FP0bixZiQXFybaDx8fTCRYKMnVn9kACQ4J9N11LMmmFhdrfZ4gTfnJ" +
    "kNdKcamRMOZC9y74s7/ZvldaN5KKi7cJT35lVT311fu8psnTXt2N6CdAm4Nj" +
    "t82BcB6U07+D6GMOlP/YSc2YbVJxsZb7BGnKT4a85uU180T2OFPu5RrzSnD8" +
    "duXZDIwpNkvK6+Pyfkvbx/6TistMAZvw8KfXBkZwOFEi+gnQhgunnPacg8jp" +
    "30H0MQfKN724WEt9gjT1J0NeK8UlXb4Y99QXasy67rf0Ki73OL02MILDiRLR" +
    "T4A2XDjltOccRE7/DqKPOVC+DcXFmncI62zCkyGveetinsgeZ8q9XGNeCY7f" +
    "rjybgTHFZkn5Ylz7TSfGjLWCSAfhh+lueXRtYASHEyWinwBtuHDKac85iJz+" +
    "HUQfc6B8W4qLtbYnSJvyZMhrpbikyxfj8k/QovstScXF24jTXlxV57+qqs4D" +
    "1lfnvJ/uRvQ9aAf5+eanhsh7QB8k0v/RE5vx2uTi4j1B2qQnQ17zcpp7SpiH" +
    "lDMPe+XisvYezry64DoXa73pkc14RfdbkorLTAkbceRT5wNGi+ckieh70A5y" +
    "CQ7lPaAPEulvU3GxVn+CtGlPhrxWiks7XKfxuBdovOyeHOsEkQ4POv6JJ84n" +
    "Hi2ekySi70E7yCU4lPeAPkikv23FxdriCdKmPRnyWiku7XCdxoMzvqzYqBvs" +
    "8JD7Lo+aTzxaPCdJRN+DdpBLcCjvAX2QSH8bi4u1//It9mxmK8WlHa7TYD53" +
    "fVmxjnR4eN8zOuWyqjrnFd2cDSgn1PdsIvk5rwSUO0Q+KT/7lU2oz7+63Jbi" +
    "si3NKy65e0x9ymdk5iJ9Eup7NpSTaF0y51dqrLz/hfaQjjY4wAOe7EyMCwGU" +
    "E+p7NpGcgRG5Q+ST8miDSnGZdivF5RCUc86PvFBjlXK/ZVYz2NEGP7F5m0c7" +
    "E+NCAOWE+p5NJGdwRO4Q+aQ82qBSXKbdSnE5BOWc891P01ixNrQhHW14n3ew" +
    "n7yTydUXAign1PdsIjmDI3KHyCfl0QaV4jLtVorLISivz/eMl1XVTfAI2j6W" +
    "wNrQhnR0wQ251xlVdebL2rHJ1aG8D/RJqE+o38cmkt/+Mc04leIyreYVl2hP" +
    "SYp+ik6XPqG+Z0M5sR/Y7qKu++DzNU7RR/4b9YIdXfB3dW9xlC6ua6GU94E+" +
    "CfUJ9fvYRPJSXKbdSnFpp67Ln2s1WBO6kI4uvE05+lm6wLaFUt4H+iTUJ9Tv" +
    "YxPJS3GZdvPyONpTkqKfotOlT6jv2VBOWEzIQu8k54NzKZ/KrSMdERzwro/X" +
    "BbYtlPI+0CehPqF+H5tIXorLtFspLu0s9O5/tsao7f+J2pCOCH7PxG74POHF" +
    "c+w7Rzk84UVNKF8ZNnYX0F+stw3+3WUpLtNql1/d3B+Dex7mJvWRAx70Ecl7" +
    "EeRuKrc+thmflC8qEumI8D5Q98Bz+wUn3MBVwQ0h0GdSkFJcpt0uv1pzmHse" +
    "5ib1kQMe9BHJexHkbgrHPkfjk/rBuTrSkQIHtp917BOccANXBTeEQJ9JQUpx" +
    "mXa7/Orm/pTi0uQeT9T4sAakIB0p2I0dDv6Yi3WSEeEGrgpuCIE+k4KU4jLt" +
    "dvnVmr/c8zA3qY8c8KCPSN6LIHdT+P6jmrFJ/S4RkY4U7MYON+feZ86/b1Tn" +
    "ZHDKpQGw7wV9DkC4Dszhtic0Y1OKy7Ta5Vdr/kZ7OggcIxf6u8zJTcovbSI+" +
    "Ae+pGhYv1oAUpCMVfh3Aqp0sjAt3FhMFLxv6HIBwHZhDKS7TbqW4tHPYKRob" +
    "nv1UpCMV7+sAVvU6F+4sJgpeNvQ5AOE6MIdSXKbdSnHxOc65kWu5y7OfinTk" +
    "wInYoepcuLOgKHjZ0OcAhOvAHEpxmXYrxcXnsJM1LqnfgPaQjhzs0HAyRz6t" +
    "Y+HOgqLgZUOfAxCuA3MoxWXarRQXxXvX0vdG7gLpyIUTsn9lPOmSOSeCk54P" +
    "9vUGhWOkQB/gxOc3oT3X+UPHN2NSisu0mldcuOeEe0yon2LDvCJJ/mgXyNt8" +
    "3sn5HtEy71oM6cjFe/fy0Av8YPBQcqGDwDFSoA8gGwS4zlJcpt1KcWn6tO8H" +
    "Mh7LvmsxpKMPnNji3QsXykPJhQ4Cx0iBPoBsEOA6S3GZdivFpenTvh/IeOT8" +
    "tEIb0tGHtncvXCgPJRc6CBwjBfoAskGA6yzFZdqtFJdDHP/cqvreI5qx6PM9" +
    "Ig/p6IP3obo7HpgfqgbPzef45zUROaBc4Jwcn0Kgzznc5rhmLEpxmVbzigv3" +
    "NAQ5wRxYFZxXJCf8J0Wj74fmiHT0hT8kZdiP+3YdyhRKcSlt6FaKy5xjnz3e" +
    "uxZDOvpid5a5YfLuxVlgRCkupQ3dSnGZM+a7FkM6liF89+IsMKIUl9KGbqW4" +
    "jP+uxZCOZfDevdzuhPlC+nJMAPXXAedkf7tSist0m1dcuKeEexzJPZ1chvDX" +
    "5uPOzqdxh3zXYkjHsnjvXu77JF10KgwOof464JxKcZl22/XiYp+i5/oNnuVl" +
    "kY5l8d69fN8jquqoC3XhKTA4hPrrgHMqxWXabdeLC/PTGPpdiyEdQ2CHiZO3" +
    "t2FceAoMDqH+OuCcuHmluEyr7XJxsasIrn2IT+N6SMdQcAHG4efvvYN5Ro0L" +
    "t4T6mp6hP25cisu0mldcuIfRHou8D/QJ7GFIA+sD4rMDuxy6MW7iGrm/6p+K" +
    "dAyFt4F26AbfoCmApCjFZdrNy03uYbTHIu8DfYKhi4v3J2eWmzy7QyEdQ+Ld" +
    "3LW/gB10g6YAkqIUl2m3XSwu9g8dXLPBMzsk0jEk3tcCbvaIvbdnT90PoBOE" +
    "jQRJUYrLtNsuFhfmpDHGTdw60jE03s3dHzupqo542vwasMFTlSMAbcxPHdpT" +
    "vw8cg3DMWx2jay5MG9lTEuUV5Y5OOEYPovNh8/C+9TzWTdw60jEGXJhxv7P9" +
    "QJAoeLJh9MExesAxCMcsxWXzkD0lUV5R7uiEY/QgOh/26wQ3fpiul2d0DKRj" +
    "DLy3oXYAGQjZHATOC55sGH1wjB5wDMIxS3HZPGRPSZRXlDs64Rg9iM7HHU7S" +
    "teb+oXxfpGMsvJu7tvBGMLg5CJwXPNkw+oB+HzgG4ZiluGwesqckyivKHZ1w" +
    "jB50nQ/vnxOH/v5QF9IxJlyocc/T559/MeyvScjhF4B93YNALvYp0AcQOcYg" +
    "P35KVf3oid38SAD1h2AVY0RMYQ4e3GMhyJkkIh+BnHnp5eaCnzzHvxwa+yZu" +
    "HekYE++/jiwADzp3Hkwe0llxYOCiDaB9CvQBRI4xiPhPGINQX/x50AbIGLTv" +
    "A8ehHPSaA8eIoH0K9EFy9T0iH4GcsXPzZB/+JathuckzOSbSMTa2QC76B46e" +
    "B5OHdHZQGbhoA2ifAn0AkWMMIv4TxiDUF38etAEyBu37wHEoB73mwDEiaJ8C" +
    "fZBcfY/IRyBn7Nw8uWD+ToxnbJWXQwukYxXwr2ANCwgP6eygMnjRBtA+BfoA" +
    "IscYRPwnjEGoL/48aANkDNr3geNQDnrNgWNE0D4F+iC5+h6Rj0DO2Hl5cjfn" +
    "3qYx1kf8u5COVWC/LM7FG/c4vdKDygBGG0D7FOgDiBxjEPGfMAahvvjzoA2Q" +
    "MWjfB45DOeg1B44RQfsU6IPk6ntEPgI5Y8c8mcJ9ljrSsSrscRiDYIG5/9lV" +
    "9cAn1zgX1GUeufopNpE8hchHJB+ABwDKk+A8CfX7AJ8yb47ZA/EZQXtAuUf2" +
    "mJnc/JF6puzFjmdvVUjHKvEeT9/yaASNm+QEdSn9FJtInkLkI5IPwCDJzXkS" +
    "6vcBPmXeHLMH4jOC9oByj+wxM7j9Y/QsreM+Sx3pWDUMiGGBOhg4bpIT2Aa5" +
    "+ik2kTyFyEckH4BBkpvzJNTvA3zKvDlmD8RnBO0B5R7ZYybi/dC2sY77LHWk" +
    "Y9W03X+5+xP2g8dNcoLbIFc/xSaSpxD5iOQDMEhyc56E+n2AT5k3x+yB+Iyg" +
    "PaDcI3vMBO5z5rTus9SRjnXg3X/5nofNC8z9zhqW+zpQh+Tq2/emBOpEBPb3" +
    "PVuhjhD4JPSfNAZ9AMr7MIbPVcB5E+pHWGGxn5Dl2VnnfZY60rEuvPsvVmAs" +
    "gAzqMnBDUzY1V18OcY9DGdnz0Ccd/MAnof+kMegDUN6HMXyuAs6bUL+LtsKy" +
    "7vssdaRjnXiff7EADllguKEpm5qrL4e4x6GM7Hnokw5+4JPQf9IY9AEo78MY" +
    "PlcB502o30Xb99fWfZ+ljnSsE++fA4YuMNzQlE3N1ZdD3ONQRvY89EkHP/BJ" +
    "6D9pDPoAlPdhDJ+rgPMm1G+DPwC/wM4Pz9Q6kY5101Zg7CsC9hOZIacDyh3u" +
    "CSiPEHvOwZkHbQj1x2BXxnQJ9meSnO7/opxh39vjWVo30jEF2p4gWWAl4KRH" +
    "0iyb8GLPOTjzoA2h/hjsypguwf5MkR95rJ6JqRYWQzqmgvcN6qQC0yNplk14" +
    "seccnHnQhlB/DHZlTJdgf6aG/TwFz4Kxqh9+6oN0TIm2AmOBZvAP0iNplk14" +
    "seccnHnQhlB/DHZlTJdgf6bEHQ7oGTCm8si5DemYGt4PfBu3PWH+DdC7n5aH" +
    "2RDq2OdrGiwr93QiInvKPR0g6ya0oRz2g8QuhcCHzInQ3vNxWjdiTzhm27gd" +
    "yDr2+u50clV9z0M1/6deWAzpmCIWSAZ3UWC4QRHcwEEOSCT3dCIie8o9HSDr" +
    "JrShHPaDxC6FwIfMidDe83FaN2JPOGbbuB1wHW2FZUqfZelCOqZKW4G53WN0" +
    "k7rgBg5yQCK5pxMR2VPu6QBZN6EN5bAfJHYpBD5kToT2no/TuhF7wjHbxu2g" +
    "vgZ74dzkwmJIx5TxPmRn2AeKuFFtMBEHOSCR3NOJiOwp93SArJvQhnLYDxK7" +
    "FAIfMidCe8/Had2IPeGYbeN2sJi/FRbm+KYVFkM6pk5bgbnlo+Y/jC2cCij3" +
    "CGwOO7VJpJ9kA0J9ZwzRIdQn1E+BPoCsw9EROAahPknRpw7J1Xc47JQm4tOh" +
    "7QNym1ZYDOnYBNoukexHie98MjaMm16XtRHYyIEh9JdiA0J9ZwzRIdQn1E+B" +
    "PoCsw9EROAahPknRpw7J1XfILS72Asmc3tTCYkjHptBWYG56JAoMN33R30Vg" +
    "IweG0F+KDQj1nTFEh1CfUD8F+gCyDkdH4BiE+iRFnzokV98hp7i0FZZV/O3q" +
    "WEjHJtH2mLpRYLjp1hcR2MiBIfSXYgNCfWcM0SHUJ9RPgT6ArMPRETgGoT5J" +
    "0acOydV3SCkulqfet5uNTXjc3IV0bBptH7T71w+d/6LdHQ8MwONAILcPPRGx" +
    "WRbOyZsXoX4wb8pdojEoBxxzkFhlzsEl8hHJD8Trsn8cvcmRmrvbUFgM6dhE" +
    "ugqM3XnnpmYTJRLkTCovsZaGc/LmRagfzJtyl2gMygHHHCRWmXNwiXxE8gPd" +
    "67IXvrbCMtXvCuUiHZtK25cdDftGNTc+iyiRIGdSMbEGgXPy5kWoH8ybcpdo" +
    "DMoBxxwkVplzcIl8RPID7euyG7T2wsc83abCYkjHJtP2cw3GzR5ezd6GMgGS" +
    "iBIJcibVIAeGcE7evAj1g3lT7hKNQTngmIPEKnMOLpGPSH5A12X5d4ujNDcX" +
    "TOF3b4dEOjYdKzBtn4XpfZkUJRLkklTUHwLOyZsXoX4wb8pdojEoBxxzkFhl" +
    "zsEl8hHJDzTXZJ8kb7sMMqb2Q09DIB3bgvebvAtu8aj5N6vbuD2w39HohD4o" +
    "78M6fEZyj8Dm9oDyXeBWx7RfBtkL4ZR+mnJIpGOb8P5VYMFNH76f7DwcJ5bi" +
    "0ir3CGx2ubjYTVvvXxAXbMMToS6kY9voutFrrya3Oa6SA1KKS4vcI7DZ1eLy" +
    "w8dX1fceoTm3YNvur3hIx7aSc5lUikuL3COw2cXisquXQUQ6tpmuyyS72WY/" +
    "oWmvODvDcQHU92wo31X2YnGbY+efDmduLdj2yyAiHduOXSa1PU0y7Br5h3bl" +
    "0LBQEOp7NpTvKDd/xN67lcM1nxbswmUQkY5doe2Lj4b906N98I4JtHWwUBDq" +
    "ezaU7xh2CXTjjnsrm/qN5iGQjl2i7WsDC+xSyX5fgwm1NbBQEOp7NpTvCPbu" +
    "9mYtXzhcYF+sZc7tEtKxi3Td7DUsiW517PyeTG+OAZQPAceIoP1EsdjXWfc6" +
    "7FvMXZdA9m5lGz8Ul4t07Cp2TcwkqWO/Z2o/RsVES2YVB4JjRNB+okyluNxy" +
    "71L5xg/T3KizTd8NWhbp2HXafiNmgV0q/UCfhF7FgeAYEbSfKOsuLjZmdAm0" +
    "a0+CUpCOQnUj+xxCdKlkn/DNKjKrOBAcI4L2E2VdxcX21/Y5ugR60zWlsHhI" +
    "R+EQ0aWSYZ/C/L5Hzj+Id5CjBqDuz/NJeQq5Pqifwhg+CPUjaB9gl79dn65d" +
    "UC6BupGOghJdKhl2LX6wyDC5+8Ckj+Qp5Pqgfgpj+CDUj6B9C6lFZZN/13aV" +
    "SEfBx+7+R5dKB4vMI5wEz4XJH8lTyPVB/RTG8EGoH0F7YC8KKUXFLoF28cNw" +
    "fZGOQjc5RcZ+oEoSPRUegkieQq4P6qcwhg9C/Qja72NFJXr6U4pKf6SjkEZq" +
    "kbGbgfaqeNNHzJ849MXs61jhCnH8dEL7PuT6pL5nQ3kE7YHth/dXqcT2t3xe" +
    "pT/SUcjDniyl3JMx7GsF33ukcxgSKMUlA9rvcZMj0t6lGKWoDIN0FPqTWmT+" +
    "1eHzRL9JxsEpxSWDfTv7hrLF2eLNPfAoRWVYpKOwPKlFxrDLJvviW3TZVIpL" +
    "GhYbu+xp+z0VD9uvXfmNlVUiHYXhsM9BdP28A7FXWLsXYK+2VnAaWF8dyj2d" +
    "ZaF/j8iGckL9FBtyxPySM6egGOVzKuMiHYXhsVfFrh+q8rBCY4fFDo174Hgg" +
    "PZ1loX+PyIZyQv0Um4fNi7DFJ/WSZ4G9SymXPqtBOgrjYh8V7/otmTYOFpu2" +
    "dzaJhzIL+veIbCgn1G+x6VtMDLuXUj6iv3qko7A67LMTKY+zPeSdTcuhXAoe" +
    "eo/IhnJC/X2bxWVOn2Ji2OVouexZL9JRWA+592c87OawHcjGO5xl4KH3iGwo" +
    "B4sisqBvMVlgl5/l5uw0kI7C+rG38DlPnHYZi1P59Ow0kY7C9LDDU4rNHLtf" +
    "ZfEo706mj3QUpo8drj43hTeRUkw2F+kobB52GbV4d9P3BvG6sftNi0uccpmz" +
    "HUhHYXuwV3s7qHazeCqXVTYPu+la3o1sP9JR2B0WxYdYAajDSzB7d0Qd+ijF" +
    "oyAdhUKhMATSUSgUCkMgHYVCoTAE0lEoFApD8P8Bz1qXUdTyfQMAAAAASUVO" +
    "RK5CYII=")

LOAD_DISABLED = ("data:image/png;base64," +
    "iVBORw0KGgoAAAANSUhEUgAAARcAAAEXCAYAAACH0wDUAAA4aElEQVR4Xu2d" +
    "+bsURbKG7///H8wooOA57IuAgCCLsqsgLiDCuCAuKOo4LnPH68z07aimOZnv" +
    "F1VR1cvp6u7M53l/OLlERkZGfqerqpf/eXcw+J9CoVCYNVJRKBQKs0AqCoVC" +
    "YRZIRaFQKMwCqSisH2+99dbgtddey9i7d+/gL3/5S8hLL70kY8+dOzfgHIX1" +
    "QyoKq4UddDvwFIVFcuTIkSJAa4BUFJaTLq82+sr4VRDXVlhOpKLQf+y/vh1E" +
    "Hs5VpQjOciIVhf4xTzE5fPjw4OTJkxk3bt6suHnjxnO+evy44vGQG8O/CW0Y" +
    "nGsWWBzKJdVyIBWFxWM3WGd1iTMWDxOA9957rxKH//3f/x385z//Uf7734z/" +
    "DuuIjCGw8Z//Wt1/Bo+/ejy4e+/uULRuVOJw+Mhh8XUSitj0F6koLAa7ycmD" +
    "0xY7YCYgb775ZiUiX3755eC7774b/Pvf/549f+b8+e8c9o/af/r73wePhv5e" +
    "H/pt2DqmeZVmoszYFhaDVBS2D/uPy8PRBjt8Z8+eHdy+fXvw9+Hh5IGdKzMW" +
    "F7aP+9i67t69WwnmpK/iyr2axSIVhflilzxd/zOnYvLdd0+Gh+9POaTbxjaJ" +
    "C0nFpmv8DIs796IwX6SiMB+6/ve1y4NcTIgewG1hQeLCMU+Gl30WHxPdLmJT" +
    "Lpu2D6kozI4ub16zA3Lp0puDBw8eDv7v//4c8n/N/Kn8+eefjYgN8Ceg/WoO" +
    "9hFsngSbN4Hj6WMbP2nT+PbJk8H169c7CY3d5+KeFWaHVBSmp8urFPvP+9FH" +
    "Hw1+++13HEznUGUHTOEhJWID8ODTfp/FJeXBgwdDob4ksa7DBIl7WJgeqShM" +
    "TltRscfDt27dGvz000/1h5IHingH3zmoXQ4tDz7tL4u4jPv99ttvlXCfPNHu" +
    "PTdFZGaLVBS60+al+N7Nzepl+5Nvv213KKWdB0zhISViA/Dg0/6yicvWuv6s" +
    "hNziv3cz/gdQRGY2SEWhPW1ExV6e28t0HioeADmU0s4DpvCQErEBxEdvDvYR" +
    "sA4cfI6nj238pE0B/U1cUp58+6T1ZVN5yjQ5UlGIaScqFwc//vjD4I8//lXx" +
    "L+GPjHG/+v45f1RjcqTPvwDmkPH/yvnDg/NyjqA/feScI6x+i8hvtjO2Mmc1" +
    "778GP/zww+DatWutbgIXkemOVBTqYcJ5XLqYi0q9WOQHIO6fowdMD5EcfMwh" +
    "43HIRSgcsZA5gv70kXNup7iM+eWXX4rIzAGpKCjRjVpLSkvOH4f/Cf1D7CQ3" +
    "DkDcP0cPmB4iOfiYQ8bjkItQOGIhcwT96SPnXIS4VAz7/fLrr61EptyTaYdU" +
    "FLaI3qcyFpVfh//5mg+xk9w4AHH/HD1geojk4GMOGY9DLkLhiIXMEfSnj5xz" +
    "keIyxkTm3XdvDTY3N2XPU8r7ZJqRisIIJhJF5erVq4N//OMf1SeMC6vAv8Co" +
    "/oMPPghFhrlTGCEV6050CVREZVXxxWXMu+++23i5VC6VFKlYV6JPKJ84cWLw" +
    "9OlTSbrCqtAsLob9U7l48aLkRkr5JPYWUrGORP+R7t+/L4lWWDVicRnz2Wef" +
    "lUulFkjFOhF9QdOVq1cGf//574N//vOf4PeM34d1Ib/n0MY/fyf/zPi9mmcL" +
    "GW/1mCPGxqSgnWuo1sExJJgD6/CQeP+OWNAm56Q9jB+Rx1vWGdiwea9cudJ4" +
    "qbTun8CWinWhKSmOHz9efS1jbbJXdcmhlsR0wAGgDSa7JDOT3YFzxKQH1BnP" +
    "NVTr4BgSzIF1eEi8f9eD3Tgn7WH8iDzess7Axnhu+8a/M2fOSA6lMPfWBalY" +
    "B7j5Y0xw3n//fU0sJntVlxxqSUwHHADaYLJLMotPCueIGR2Q+kPqIGNIMAfW" +
    "4SHx/t0/2LVz0h7Gj8jjLesMbNCHTz9tvlRax+/5lYpVpukyyF7i2redeQdA" +
    "kr2qSw61JKYDDgBtMNklmcUnhXPE5AdE2rmGah0cQ4I5sA4PiffvzQdb5qQ9" +
    "jB+Rx1vWGdio8+HKlauSW2PW7TJJKlaVussgq79371718fx58utvv2b89iv5" +
    "Lcf6ZKjNmSM+TA/X/WtVF/BrzkJiAbgOtqd7+eWjR4PNjQ3JtTHMzVVFKlYR" +
    "bu6YQ4cODZ48eaKJMgckOYu41LPk4mL89OOPjfdi1uEySSpWiegySBJkjkhy" +
    "FnGpZwXEpWJY//bbb0vujVn1yySpWBUWfRlEJDmZiHKwF3CgxIfp4bpFSDxW" +
    "SFwM+x2pppu9zN1VQSpWAW7emIMHDw6+/fbb6iP2Ob/m/ArYDuyDiym//Kr8" +
    "WvWrR3zi+KEfOVZH8j60Gc7J/jKnxQO+cdy07V4fwHV33a8RnBftnDOJmxs7" +
    "+mDxSvr/OLxMOn36tOTkmFX8KgepWGZsg7hpYy5fvqwJUZtYgO2giEvCtO1e" +
    "H8B1d92vEZwX7ZwziZsbO/pg8eKYoZ2bN29Kbq6qwEjFslInLLt27ap+TEuS" +
    "oTGxANtBEZeEadu9PoDr7rpfIzgv2jlnEjc3dvTB4sUxz2w9evRosFHzNGmV" +
    "vsZBKpaRug8d1l8GESYWYDso4pIwbbvXB3DdXfdrBOdFO+dM4ubGjj5YvDgm" +
    "sWeXSZafzNlVEhipWDbqngjZxv3w9Gn1SdaMnx3Y5x8/g7z955+B1SX84+ef" +
    "lWCOnwHbY3sx4meI+kEbod+0Ock6uo5p0V/XwT0McGwqjAX5x+D8+fOSu8Yq" +
    "PEmSimWiTlhOnzo1EhYvsZgkbqJoEqQUcUkJ/KbNSdbRdUyL/roO7mGAY1Nh" +
    "LMioX53ALPt3xEjFslD3qPn8G280JxaTxE0UPwnGFHFJCfymzUnW0XVMi/66" +
    "Du5hgGNTYSzIVl974MBcXnaBkYploFZYhv8BwsRikriJUp8ERhGXlMBv2pxk" +
    "HV3HtOiv6+AeBjg2FcaC5P1v374tOT2GZ2AZkIq+UycstjHVJkWJxSRxE6U5" +
    "CYq4pAR+0+Yk6+g6pkV/XQf3MMCxqTAWhP1XS2Ckos/UCYv97rJ9orkVPzuw" +
    "z9rwM2D7/Pl5OC9hn5AV20/7pjt7CwXzfNkERir6iicstgEffvihbE4jTMQV" +
    "SMbJKeLSV1ZBYKSij3jfyG+Btw3gpoQwEVckGSejiEufsfz23guzLDd5paJv" +
    "eI+bJxYWg4m4QsnYnSIufafuFcwyCIxU9AlPWAz7DZkff/qpwr43oxHrk/Dj" +
    "Tz8qP/6U8dNPNm4Ltguwx/EV9EuwtSTIeLTLeJt7FJMt6BdiYWMaoP3RHIDj" +
    "2E4QO9pvRbWWeqI4GFEsZE7AddC+B23QB+7x2P9PP/3UFZi+v9FOKvpC3WeF" +
    "UmEp4pITHSqJhY1pgPZHcwCOYztB7Gi/FdVa6oniYESxkDkB10H7HrRBH7jH" +
    "6RpMYHgWjD5/VEAq+kCdsFy/dj0LeBGXHMZG/UIsbEwDtD+aA3Ac2wliR/ut" +
    "qNZSTxQHI4qFzAm4Dtr3oA36wD3mOuwfK89EnwVGKvoAg2fYhxO9gMuGESaR" +
    "s+lMFElWJhJhEnnQLwHJJeOZfBxvczM+9AuxsDEN0P5oDsBxbCeIHe23olpL" +
    "PVEcjCgWMifgOmjfgzboA/eY67C11QlMH7+uQSoWDYM2FpYffvhhNjx1YB+C" +
    "/k9/yJH+EzAPm13ZDh+eWvwS2F7RdX/6AH2eo9+XLl2SM9JHgZGKRcJgGceO" +
    "HZPgTgUToE0SoP88DuE8bHZlO3wo4jIb6r5mhGdqkUjFovDeJHfgwIHq+1gY" +
    "2KlgArRJAvSfxyGch82ubIcPRVxmR98FRioWgffIeS7CYjAB2iQB+s/jEM7D" +
    "Zle2w4ciLrPFzgnPTl8eUUvFImBw7Jn+gwcPBt9//73D04ynw7qU758CGa88" +
    "ffo0hzYxp/A052nlV474hTFEfSCxH9EYrpvtOl6hn4TrlnYX+vl9BtdJm23g" +
    "HOpDDmNF2N+HcwLmSIvxX3/zzeCVV14RgenD7yJJxXbDoBj2Wy8aWD/AkjTh" +
    "BilMFLHpbGqGJLsifmEMUR9I7Ec0hutmu45X6CfhuqXdhX5+n8F10mYbOIf6" +
    "kMNYEfb34ZyAOdJm/HDuBw8fyhkyeNa2G6nYTrz7LGfPnnWCWh9gSZpwgxQm" +
    "itjkhpIk0UfJrohfGEPUBxL7EY3hutmu4xX6SbhuaXehn99ncJ202QbOoT7k" +
    "MFaE/X04J2COtBn/LAZXr/q/Uc0zt51IxXZRd5/l66+/doJaH2BJmnCDFCaK" +
    "2OSGkmcbvJXsiviFMUR9ILEf0Rium+06XqGfhOuWdhf6+X0G10mbbeAc6kMO" +
    "Y0XY34dzAuZIm/FJHE6+9pqcqUXef5GK7YJBsPssn3zyyeC7777LeZLzBLB/" +
    "1O6COaQ94Algu9/nCWD/JxnfPcmhPW9e2tD+zT5IXKrY5GPst7ZTIj8jeyOb" +
    "3+V7SMRPzCs2dYz6RRtBf2lnrNUGkXWyD9ZNH+jHV1991av7L1KxHXDxxs2b" +
    "NzW4XoCDDYnaXTCHtAc0bXh9n+YDIIkaHFpvXtrQ/s0+SFyq2ORjiriM2xlr" +
    "tUFkneyDddMHzw/7B82zZfAMbgdSMW+8+yyvv/56/WYwwMGGRO0umEPaA6IN" +
    "9/s0HwBJ1ODQevPShvZv9kHiUsUmH1PEZdzOWKsNIutkH6ybPrh+DH2/cuWK" +
    "nLFFCIxUzJPXnGvC/fv3Dx5/9bh+MxjgYEOidhfMIe0B0Yb7fZoPgCRqcGi9" +
    "eWlD+zf7IHGpYpOPKeIybmes1QaRdbIP1k0fXD+e7cPJkyflrG33/RepmCdc" +
    "rN1nuf/J/cG3T74d8W3Mk2+fZLB9ETx5knPhwoXqk6rTcBSwfTKOgq7tc+Do" +
    "Fha3tnmweCz3UtjehmYbT8Dzc5JCm8/qv3z8pXv/hWdynkjFvPAuh27cvNEc" +
    "KIdlEBc7NFxroR12icz49pNmYWhHs41pxMWwf9yMr8GzOS+kYh54389y4sSJ" +
    "OFAORVxWn+UQmGZhaEezjWnFxbBXg4yv3Z7gGZ0HUjEPuDi7HLJv1mIgJFAO" +
    "RVzWg/4LTLMwtKPZxizExeoWdXkkFbPGO2jVtXVNICKWUVzsktD+WxR8GK/l" +
    "EJhmYWhHs41ZiYv9/A5jux1f8C0Vs4aLsqdD33z9dcXX3+R88803IfZBrRzY" +
    "MbsJ47m25uT4b7TP199kfFP5tgXnYH8eFjtApTQX79LZOHPmjLNfOdLehsCG" +
    "IHmF8ZITmnv0gXnDPBNoz/Gjbg67DcHY8qzOGqmYJd5N3A/ef/95YCgMDIyH" +
    "bDpsRBus421T0CfYdM7B/kVcJittBYYHSvazDYENQfIK4yUnNPfoA/OGeSbQ" +
    "nuNH3RwPH/7N/QUBntlZIhWzwksUS5L8oOcwMB6y6bARbbCOt01Bn2DTOQf7" +
    "F3GZvHh5Q4HhgZL9bENgQ5C8wnjJCc09+sC8YZ4JtOf40TTH+fPnJa6Wqzy7" +
    "s0IqZgUXYar56IsvssBQGBgYD9l02Ig2WMfbpqBPsOmcg/2LuExXIoHhgZL9" +
    "bENgQ5C8wnjJCc09+sC8YZ4JtOf4Ec2xnTd3pWIWeD+/+uabbw6++uox+Crk" +
    "MWD7V48B21vRzS/69PhxzuHDh4u4TFnqBOb06dOyH9sC8ox7Lv0dmDdsD2Gu" +
    "t5iXc965c0diOq+bu1IxC+j8vn37ngWi2yH2gsP2rsH26eYXfWKiFXGZTemV" +
    "wCDPuOfS34F5w/YQ5nqLeb05LX6M6Tx+OUAqpsW7iXv37t0iLqVMVHojMMgz" +
    "7rn0d2DesD2Eud5iXm/Ozz//fLBz506JKc/ytEjFtNDhN954IwlEt0NcF5yM" +
    "jsH26eYXfWKiFXGZbemFwCDPuOfS34F5w/YQ5nqLeevmtNsUjOesX71IxTTw" +
    "VYup42effTb48ssvRzx+nPMledYv5THgGLZjjsdDGylivyKymRPZLOIy+9Ik" +
    "MLo/tu/NcM8EyaPm8Wyv+ki+Y4zZTWA71yX2nDFRbqbs2bNH4skzPQ1SMQ10" +
    "tNr4dEESGKIBkABzDNsxR7tgRzZzIptFXOZT2goMD7kH90yQPGoez/aqj+Q7" +
    "xpjdBLYz78SeMybKzRTve3dn+epFKibFe0Jk34qVB4uBIRoACTDHsB1ztAt2" +
    "ZDMnslnEZX6ljcDwkHtwzwTJo+bxbK/6SL5jjNlNYDvzTuw5Y6LcJPN89SIV" +
    "k0IH5VWLIYEhungJMMewHXO0C3ZkMyeyWcRlviUSGB5yD+6ZIHnUPJ7tVR/J" +
    "d4wxuwlsZ96JPWdMlJvE+91pnu1JkYpJ8F61fHz//uDRo0fNfEG+UMIxOV+A" +
    "R4/MRgrsOdDGF8NxKWoz5/DhQ0Vc5lzqBObUqVOaE7anZJhbKdxD5oQQ5Wkb" +
    "4Ke253PIGtjfsRn1//Rvn8qTo1m970UqJsHbYG8hAoPLDfM2TcbkUBg6J80j" +
    "tVHEpZ+lrcDwgBVxyft7vznNMz4JUtGVulct7kIIg8sN8zZNxuRQGDonzSO1" +
    "UcSlv6WNwPCAFXHJ+8/r1YtUdMXb1NqFEAaXG+ZtmozJoTB0TppHaqOIS79L" +
    "JDA8YEVctP88Xr1IRRfs0NCh27dvDTfr84rPP/8CWF1XaCPni2GfFBlvfqQ4" +
    "NmRM0B7NeehQEZftLnUCY7Hn/niMc3Yrd7nnlmtbsL0vRLlZx8OHD2f+6kUq" +
    "usCNtEOVb1DzIW0HbeSEwSzisjZlGoFZd3Ex7HfaGTue+S5IRVu8jUxftRRx" +
    "KeKyiOLlZRuBKeLy+eDevXsSt2m+70Uq2kIn+KqliEsRl0WVSQRGc5d7vvri" +
    "Yni3Onj22yIVbaEDl9+6PPj0s88yPvu0mU8/+zTDPodEPrV+KTKmKzqHQD8B" +
    "2zlHEZfFlyaBsV+eYB5xj7vmskc1TxPRHMgrGT+EY2iz6zrvvK/f98Kz3xap" +
    "aIOnbg8+eSCOcuGEC5dDbnYkGBzTFZ1DoJ+A7ZyjiEs/SqPAfNbt0Mmet4BC" +
    "IERzIK9k/BzExfrwIwGT/gysVLTB2yxvYVw44cLlkJsdCQbHdEXnEOgnYDvn" +
    "KOLSn9JaYLjPz3K4bS57UAiEaA7klYyfk7i8fvZ1iRc1oA1S0QZOfP36dXdh" +
    "XDjhwuWQmx0JBsd0RecQ6CdgO+co4tKv0kpguM/PcrhtLntQCIRoDuSVjJ+T" +
    "uHx09yOJ1SSflpaKCL4jt/rOlpqFceGEC5dDbnYkGBzTFZ1DoJ+A7ZyjiEv/" +
    "Sigw3OdnOdw2lz0oBEI0B/JKxs9JXAzmsEEtiJCKCE5ov4r3t7/9reIhGNdv" +
    "8RCwfTnhug8ePCgJXMriS53AnDx5UvaUcI/Z3oZZ2NguvFhRCyKkoglvwvfe" +
    "e++5Q3HwiriUstji5bDBPSXcY7a3YRY2tov79+9LjCyPqQlNSEUT/BpLu0RK" +
    "HYqDV8SllMUX73M03FPCPWZ7G2ZhYzuxV3SMEzWhCaloghOdP38+cyYOXhGX" +
    "UhZfbt68KYeGe0q4x2xvwyxsbCfXrl2TOFETmpCKOjy1/+DDDwcPHj6sxT4M" +
    "lfLgwYMA6wMePmiG/WHzIdD+W/4+h+2ANh9WdVsUcel38cQlzptm2N8bw/PA" +
    "vGFu095DqwOSuzwfRHIZPgB+mLHLe16kog5uxtGjR52F5TCYDLaii5PgEPbn" +
    "hgLtv+VvEZf1KEVc0lyGD8B+QpexojbUIRV1cIJLly45C8thMBlsRRcnwSHs" +
    "zw0F2n/L3yIu61GKuKS5DB/ArVu3JVbUhjqkog5O8MEHHzgLy2EwGWxFFyfB" +
    "IezPDQXaf8vfIi7rUYq4pLkMHxx4aWS3SKgPHlLhYYcjNb579+7BJ5/cr346" +
    "JOX+sC7lk/ufZNyv+mzBdtprQzxnc/uk82bcN7tbHCji0uviiQtzkzBn7gPJ" +
    "iQo7I1twTJSb9EHGu/PmczI3pX/UPsRugaSxavslUlLhwY2wn3Ao4pJQxGWp" +
    "ShGXhKh9iP0kM+NFjfCQCg8avnLl8jPncye6BovttNeGeM7m9knnzSjislSl" +
    "iEtC1D7k1q1bEi9qhIdUeNDw3bsfPXM+d6JrsNhOe22I52xun3TejCIuS1WK" +
    "uCRE7c+Y5L6LVBD7mrvU6Obm5uDjjz9+xv2M+8O6lK1+z7gP2D4LJpgj9Ltj" +
    "/wMHDqyEuPBeG1nWdbniEuzpPIjnzM+XC/JdbIbnofkMj/06fvx4Fq82912k" +
    "gnAT7Oca2jomCwkXOgMmmCP0u2P/Ii79LkVc6ufg+LFfFy9elJhRK4hUEBq8" +
    "fPlya8dkIeFCZ8AEc4R+d+xfxKXfpYhL/RwcP/bLPqDMmFEriFQQGvzwww9b" +
    "OyYLCRc6AyaYI/S7Y/8iLv0uRVzq5+D41C97Cwr3n3rRWlx4v2Vjc3Nw9969" +
    "Le7eBVa3xT3hbkZma8i9e3cVjCHiA2zSp7v3rE+O2HT65P25rpz9+4u49Ll4" +
    "4sK8C/cc/T0k94DkncDcVTin2EzW4OW6jHexee7JfReDmtFaXGjotVOn8sUF" +
    "wZANkYUHgfKCQRuEGyAbFAec7UTXlVPEpd+liEsCx7vYPPcGFy5ckLhRMyYW" +
    "l6vXruWLC4IhGyILDwLlBYM2CDdANigOONuJriuniEu/SxGXBI53sXnuDW7f" +
    "7vY5I6loEhcuLAqGbIgsPAiUFwzaIOIjeBbkpoCznei6coq49LsUcUngeBeb" +
    "ZwTf70LNmEhcduzYMfjoo4868iFg+6qQr3P//v0rcQjNbx7CVViXJy7cQ93j" +
    "guHlNnUjFBcmlhnlRDHrsmFFXJapFHGZHOZE05vppGIMvy/XjHKimHXZsCIu" +
    "y1SKuEyOlxPUjlBcaKCISxNFXJapFHGZnKtXr0rsqB2dxcWMcqKYddmwIi7L" +
    "VIq4TE6XT0hLRZ24XL9+Y/DBBx9mfPjBBxn2hd0ZVpcg/dk+HBPxwYc2zxYf" +
    "Vn5sQR8jn0bzAvpJG/CBcxZx6XfxxEVyQvKKeZPvOfuPaM535hFzXfOS9mO/" +
    "OIeA/uqDwthROzqLC50YBTQ4hFi49Ge7sxDC4GiwQeDTaF5uYrCuYIOKuPS7" +
    "FHFJQH/1QdnY2MhiV/f1C1Jh8GdEzBidGAU0OIRYuPRnu7MQwuBosEHg02he" +
    "bmKwrmCDirj0uxRxSUB/9UE5dOhwFjv7mBA1pFZcmFR2WOjEKKDBIcTCpT/b" +
    "nYUQBkeDDQKfRvNyE4N1BRtUxKXfpYhLAvqrD8rJk5oX1JBaceHAkydPDN5/" +
    "/33lDojaCfrfuaPomDsBsU3B+iXQhpLPyfH79u1biUO4TuKiexyAvLxT5UEO" +
    "xzBPmEfsvxjok3Lu3FmJHzWktbiYMXXifQlw2E7QXw49+1djdLE5sU3B+iXQ" +
    "hpLPyfFFXPpdirg0QZ+Uy5ffkvhRQ1qLixlTJ96XAIftBP3l0LN/NUYXmxPb" +
    "FKxfAm0o+ZwcX8Sl36WISxP0yYfxo4a0Fpfbt285TrwvAQ7bCfrLoWf/aowu" +
    "NCe2KVi/BNpQ8jk5vohLv0sRlybokw/jRw1pLS72FXetuAPeuwOcMRG0Sdhf" +
    "aONDmz7t+xdx6XfxxIV7eGe4rylsbwVz9c6dHPafA/E6mnO5rg/jRw0p4tKp" +
    "T/v+RVz6XYq4pDTncl0f5jg1pIhLpz7t+zPwy3oIi7g0HcoWMFdXWFy8N9KJ" +
    "sBRxqevTvj8Dv6yHsIhL06FsAXN1hcXFcoE6IsJCcXnllVcGt27fHty+dUu5" +
    "nWMfakq5fcvGbcF2s9sZsUHYP4c+j7D6LWhT+mNdjIsX+GUs6yQu3OMob7Td" +
    "AXkhNoDkVWSvOgPIcdqUOZ+di+ewvzMvsH579+2VXKCOiLBQXPYOD4o5wUW5" +
    "waoWuwWDxXZdaAvEBmH/HPo8QoPXtEFcF+NSxKXfpYhLCvs78wLrN5G4MKGK" +
    "uLCvrotxKeLS71LEJYX9nXmB9ePPjBRxqTZM/faC17RBXBfjUsSl36WISwr7" +
    "O/MC60dx8b7uMhaXvXsH7777bqEDFrNVOITMBbKs6/LEhXtYaObVV1/VGHYV" +
    "FzNCw4Vmirj0uxRxmZ6JxIUHo4hLdxjDZT2ERVwKdUwkLhxQxKU7RVz6XYq4" +
    "TM/Fixc1ht3F5djgnXfeHrzt8TZ5B+TtZifl7XfeyZHx7wzesXFTQJ/fGc6j" +
    "WP0WHBOuA+1FXPpdPHHhHgrMVcH6ANoAUR5JLk9wPsQn+o05pd1Zm52ZNr8b" +
    "XcSlwuq34JhwHWgv4tLvUsQlAXNKu7O2icXlyJEj2YAiLlxj3tdLiiIu/S5F" +
    "XBIwp7Q7a7MzM9E9FybU4cOH/QPnBIMLZ7sEk4uQ8XHwIuizCksRl7rCXCDL" +
    "uq4iLgmYU9qdtc1MXOyguAfOCQYXznYJJhch4+PgRdBnFZYiLnWFuUCWdV1F" +
    "XBIwp7Q7a5uZuGxublab0YobOTdu5rB/1D6yeQM0z0HUntJ5DNuBxWwVDiFz" +
    "gSzrumyPuBbuYbjnQQ553Lx5I0PbJyG3qX7ZPFtIf7EXY74ePXYsi1/1Ztsi" +
    "LkrnMWwHRVz6XWyPuBbuYbjnQQ558GBr+yT0Q1wsF6glIi5GOqiIi/aXdlDE" +
    "pd/F9ohr4R6Gex7kkAcPtrZPwmLExctx6ogIC8XFPpBE47XIwpqDF7WPbBZx" +
    "WVQp4tKw50EOefBga/skLLG4GPYj9Dccrl+/HmB9UtB+A0h/Z0xHbgC2e4Tr" +
    "pN/AC/wylnUSF9njMCeIjpkaJ7cEjhFyP3keiI5P5krm9HKcOiLCUsTFSyT0" +
    "od/AC/wyliIuW2hOEB0zNU5uCRwj5H7yPBAdn8yVzMkcf+utt4q4sN0jXCf9" +
    "Bgz8sh7CIi5baE4QHTM1Tm4JHCPkfvI8EB2fzJXMuWfPnix+1JAiLjWE66Tf" +
    "oIhLv0sRl3p0fDJXMifjRw1pLS6XLl0aXL12TbhGrl7NYTu4eu0qcOa4CsRG" +
    "RDwHuXbNfE/AuiKbGxsbK3EI10lcZM/BVdv3hCgvPSRvhuNSxCZgnlXQL/oe" +
    "2JDcdvBsMn7UkNbicvbsWXGqcozAUWkHEmzYHy0eiI2IeA6iwcQGBDY3Nvoj" +
    "Lt5B6gN2jb6o4sVE9hzIgQvy0kPyxg57gtgEzLMK+kXfAxuS2w60efnyZYkf" +
    "NaS1uNhbfelU5RiBo9IOJNiwP1o8EBsR8RyEweS6IpsbG/0RFyt2kLmni8Q+" +
    "HPvHH3/QzW0rRVy2kNx2oE17scH4UUNai4slA52qHCNwVNqBBBv2R4sHYiMi" +
    "noMwmFxXZHNjo1/iYgeZn3ZfFPa+qUUKi5UiLltIbjvQZpvPFdWKC6+1NzY2" +
    "BleuXAm5Cti+Lli80vgtWlys2IG2g82k2E5s/qdPn9K1bS+euHAPC/V4/6io" +
    "IbXiwpfRu3btkgk8iriM6KO4WLGDvUiB+fjjj+nSQkoRl+nw8psaUisuxiTB" +
    "L+Iywgt+X4odcO7tdmAHui+liMt07N69O4ud9yP0ncTljTfekElIEZcRfRYX" +
    "K97hmieLfDLkFW/93MNCPYwdtaOzuNgBuTxMkpS33rrczOUce4SVYkmXcVm5" +
    "DGgztAGf6IPrhxDYsLqEV155RWLXt2Lr4h7Pg0U/GfKKJy665wQ5ACQvq9xg" +
    "/jbnXdjuIHOKX9anPfSB+X3u7DmJHbWjs7jY113KwhBwgQsHDB4XOlpsDm2G" +
    "NuATfXD9EAIbVpewDOKyHU+Q+vBkyCtFXOqhD8zvM2fOSOyoHaG48KsaDxw4" +
    "oAtDwAUuHDB4XOhosTm0GdqAT/TB9UMIbFhdwjKIi5V5PkHqy5MhrxRxqYc+" +
    "ML/tRQZjR+0IxUUeRw8PjCwMARe4cMDgcaGjxebQZmgDPtEH1w8hsGF1Ccsi" +
    "Llbm9QSpL0+GvFLEpR76wPy2Fxlp3LyvtwzFxeAGvPnmm81cyrn0Zo72v5Rx" +
    "6U1FxhDMKaA/fRr5ZfOkcFzUnrNM4mJl1k+Q+vRkyCueuHAPlTwHNIdaEORm" +
    "2O6BMVOfH8n1fK1eblM3JhIX+wlHca7B0XADirj0pngHbhLsP2zfi7dW7qFS" +
    "f+Dc3PYIcjNs98CYqc+P5Hq+1hdffDGLGzVjYnE5efKkOtfgaLgBRVx6VUwY" +
    "uOdd6OOTIa8Ucakfz3Wmaz33xhsSN2rGxOJy6NAhda7B0XADirj0qkzzBKmv" +
    "T4a8UsSlfjzXma71yNGjEjdqRmtxYaK9/PLL6lyDo+EGFHHpXZnkCVKfnwx5" +
    "pYhL/XiuM13rJp4g275TM1qLi8FNOH/+fHXvxePSxUvA6ra4OBSQDMeGcAlc" +
    "tHEJaOecROx7cwjd/F5mcbHS9QlSn58MecUTF+5hV5hnFZaPCRzTFdprZxPn" +
    "hTYB2yuenQPeb6l72//E4nLs2DGd/LmjRVyMZRcXK22fIPX9yZBXirgkNgHb" +
    "K4bznHm9/ZvnJhaX/fv36+TPHS3iYqyCuFjxDmHKMjwZ8oq3Lu5hV5hnFZaP" +
    "CRzTFdprZ3M24sJbJAa1gkgF4Zvp7OsXZPLnjhZxMVZFXKzUPUFalidDXini" +
    "ktgEbK8YzrO5mX/pfHS/pZW4GNwI+5q7CxcuDM6fz7G6lPMBF86fzzh/oQ2w" +
    "EczJ9gvmJ6ENrEtsYjx95M8uLLO4eE+QlunJkFc8cWEu6h4zB9Cfeebk0YUL" +
    "1i+FY/J2Hd+CFn41wVw2rL7r/RZDKjy4EXbfpXIkWDw3hDAQXJQPbARzsp1J" +
    "U8QlLukTpGV7MuSVIi71MJeN06dPS7yoER5S4UHD+/btGzkSLJ4bQhgILsoH" +
    "NoI52c6kKeLSroyfIC3bkyGvFHGph7lsdPmwYopUePC+y86dO0eOBIvnhhAG" +
    "govygY1gTrYzaYq4tC+//PILq5ayFHGph7ns5XPThxVTpKIOboZ9r4N9O10z" +
    "5wHbCfu3GdM/uBmrIi6rUjxx4R5uB+cB2+fCecB2B8bKbvJTHzykog5OYB8F" +
    "oBNKV6Fg/zZj+kcRl36XIi4JbAdtf0bEQyrq4Ds27W86onQVCvZvM6Z/FHHp" +
    "dyniksB2wC+Nm4u4eO93iC+NugoF+7cZ0z+KuPS7FHFJYHuCveWEj6DtbQnU" +
    "hjqkogluiL1b99y5swnnMs6Cc0NnM7KxZ4d9FPtC4BTaPGt1KZxTfPLmIJhz" +
    "WJdBHwB/eqGIS7+KJy7MCc0r5AxgDoxyD32YRwGSu04f8ZPQb+Q2cz/te/jI" +
    "ZE+JxkhFE3yJtHPnTgSQBxnBxkIk+A4MBm1qMDGn+OTNQTAnN5Q+gCIu/S5F" +
    "XFLy3E/7vrKRv9N8ruJicLLjx48nAeRBRrCxEAm+A4NBmxpMzCk+eXMQzMkN" +
    "pQ+giEu/SxGXlDz3x/1OnT4lMTIfqAdNSEUEJ7RXM0Vccoq49LsUcUnJc3/c" +
    "7+ChgxIjakGEVETwcyZ2w+f1119vyRnA9kmYgc0zgO0dKeLS7+KJC3PgDOAe" +
    "K8zDM4Mzw/oUtquN/uA9HaYWREhFG7gx9vZgOuczj+DOwCYSS9o7UsSl36WI" +
    "SzMnTpyQ+LR941yKVLSBE9tXDNBBn3kEdwY2kVjS3pEiLv0uRVyasc8OMj7U" +
    "gDZIRRvs+o+T2wGik8o8gjsDm0gsae9IEZd+lyIuzdhT4DQ2bT9LRKSiLdyc" +
    "A/v3D+xNdSmnz5zOOZ1zBkj/IWdAaCNoP3P6jHA6olpLAtsx5+7dLxdx6XHx" +
    "xIV7SJhHzFP2H9GcJ2zXvMz70wfPD2kPbLB92ve2pEhFW3jDZ+eOHUVcnlHE" +
    "pd+liEt9+8bmhsSGZ78tUtEW7+MA9iSpiEsRl76XIi5+u3cj13KXZ78tUtEF" +
    "OmL3Goq4FHHpeyni4rdvbMzuVYshFV2wQ0Nn7Cswi7gUcelzKeKi7d6rlklv" +
    "5I6Riq7QIftVxlPDw2S8dupUxinyrN9zTnk44zIbgO1tED/y9mgdr52ytW5h" +
    "MSji0t/iiQv3lDAHiOTha9rnNatLQd4QngUZ79mQdmDnMuVZ/axftRhS0RXv" +
    "1cvRI0eqQ8qFccP0UHs44zIbgO1tED/y9mgd3OAiLv0uRVwShnXH5/CqxZCK" +
    "SaBj41cvXBg3TA+1hzMuswHY3gbxI2+P1sENLuLS71LEJWFYx287MHjGJ0Eq" +
    "JqHu1QsXxg3TQ+3hjMtsALa3QfzI26N1cIOLuPS7FHHZ4uSQF154IYvFJJ8j" +
    "8pCKSeFm2UcCTr52MufkBDwLwHPY3hXaa2MzXIfZ2KKIS7+LJy66p8vBa4Dt" +
    "zE22b+7Nf0nR4NmeFKmYFO+l1avHXw0OZQu6CkEE7bWxWcRlpUoRlxH2hGhe" +
    "r1oMqZgGbph9k1XzoWxBVyGIoL02Nou4rFQp4jKCv/9s8ExPg1RMQ/jqRRbe" +
    "gq5CEEF7bWwWcVmpUsRl/q9aDKmYFm6avWv3xPHjI4YLSrGvyEx53i/h+HHr" +
    "l3DieCMcf8LqQnK/xMZxq0vJ27kOfu6qiEu/iicukkdA2pETkqdWH+S72GR/" +
    "tkteOn7QV8w5Hrc5h/e1EKmYFu/Vy8EDB0aLYvBqFp4f3CIupcy2rLu4HDt6" +
    "VNa/FOJi0OkdO3YMjr/6qgbPWTjhhknwog2wuhAkAm1gA9nOdRRx6XdZd3Fh" +
    "fs5DWAypmAXe+17sZZgEz1k44YZJ8KINsLoQJAJtYAPZznVw84q49Kuss7jY" +
    "VQTXPot343pIxazgAowjRw4PXn31WMKrLUj7tx0zawIfjh3LKOLS7+KJi+wp" +
    "OQbYPgswx7FXgdUBsdGAfaiYN3ENnt1ZIRWzhIuwQ9d4SF2Cg70tBD4UcVmq" +
    "sq7i4n040XKT53ZWSMUs8W7u2k/A1h5Sl+BgbwuBD0Vclqqso7jYL3RwzQbP" +
    "7CyRilnDxdjN3WPHjg7cQ+oSHOxtIfChiMtSlXUUF+bkvIXFkIpZ493ctc8d" +
    "HT16tBKZDKsDR48eyxn2y6j6pKA/2mVOx4b6AI6ZHwlo37Vrl6y50G8kr8Cx" +
    "YS5lHMthDozyBDA3OUcEfaC9GrwriHndxE2RinnAhRkHDx50gqcwUNwQ2VD2" +
    "R7vM6dhQH0ARl5VD8grwUC+LuBw5cnRbb+KmSMW84OLsAGrwFAaLGyIbyv5o" +
    "lzkdG+oDKOKyckheAR7qZREXu0rgWrv+oPykSMW88F6a2cKLuBT6gOQV4KFe" +
    "BnHZt2+/rHPWnx9qQirmCRdq2NMj+0kS4/BhB6tPOHIYPBv73EbU3yOywfbU" +
    "PwP97Q2De/bsKSwR3GMhyBl7D5fCPhH5eOaVB8eMbR06dGhhl0NjpGKeeL91" +
    "ZAGwx2QWEDm0zsGNNjns7xHZYHvqn8H+th5CGwF1SfMcrsFZB7Ff00theyt7" +
    "0gd+SnuO+MD+nk1B7Tb62AbaIGF/+tjCTyEfz5zw4JixLf4kq2H1PJPzRCrm" +
    "jS2Qi7bLCKuXQ2swmMEmh/09IhtsT/0z2J/CUsTlOeID+3s2BbXb6GMbaIOE" +
    "/eljCz+FfDxzwoNjzI69EuMZ287LoTFSsR14z9wtIHJoDQYz2OSwv0dkg+2p" +
    "fwb7U1iKuDxHfGB/z6agdht9bANtkLA/fWzhp5CPZ054cIx3b9PgGdwOpGK7" +
    "4OINuwEVH1yQbU6L/h6RDban/hnsT2Ep4vIc8YH9PZuC2m30sQ20QcL+9LGF" +
    "n0I+njnhkfY/dOjgwu+zpEjFdmGPwxgEC4y9/8VuRj3nMEjbPLr2H3IYHDpk" +
    "G5UAm9p/Bhy2eRLY3hcYi6GvKdI/BLGuYJ9uTO+TQZ8I+jPvPDhmBqR5aO9+" +
    "55ky0eLZ2y6kYjvxXsLZ/ZcsgF03qGv/Q55YIJFgU/vPgCIuCezTjel9MugT" +
    "QX/mnQfHzIBxDu7ZvVvO0iLus6RIxXbDgBj21ZjPA9h1g7r2P+SJBRIJNrX/" +
    "DCjiksA+3ZjeJ4M+EfRn3nlwzAyw/NvrfNG2wbO23UjFImBQDHtVUwWw6wZ1" +
    "7X/IEwskEmxq/xlQxCWBfboxvU8GfSLoz7zz4JgZYF/+1Kf7LClSsQjq7r/s" +
    "27tvcGAYvJyDOQdzLNg5VrcF+1fQppD7QJsHDx7IEPsOtCHtsKn9bZ4c9iEy" +
    "B2Il6/b8BuIDiMcrcR+uO1iHB+dM4lRBH4IcEPueDQF7KHMQzLn/QO/us6RI" +
    "xaLw7r+YwNg7eIu46JySmE4fInMgVrJuz28gPoB4vBL34bqDdXhwziROFfQh" +
    "yAGx79kQsIcyB0nmqxGWRd9nSZGKReK9/8UCmAsMNlGSpH5DvANWQZsCNz23" +
    "GR0oD9qQdtjU/khMpw+RORArWbfnNxAfQDxeiftw3cE6PDhnEqcK+hDkgNj3" +
    "bAjYQ5mDbM1X9/k1nqlFIhWLhsFSgcEmSpLUb4h3wCpoU+Cm5zajA+VBG9IO" +
    "m9ofien0ITIHYiXr9vwG4gOIxytxH647WIcH50ziVEEfghwQ+54NAXsoc5DR" +
    "XC+/lP/oXh+FxZCKPsCgGabUJjDzYB9ge8S042dloyvrMqfLPsD2PjL086Vd" +
    "+uresM/t8RwtGqnoCwyeYZdNEvAZMG3CTzt+Vja6si5zuiyhuOzZrZ8Z6quw" +
    "GFLRF7xPUM9LYKZN+GnHz8pGV9ZlTpclExfvw4jGdn3x0yRIRZ+oExgLNIM/" +
    "DdMm/LTjZ2WjK+syp8sSiYv3bXJGXx451yEVfcP7gm/D3sW7d+++wb59ezPs" +
    "kXbKPsD2mWDzprB9r829LyMesy9nXw7tjWyS5jk0NphTfFKi+EdwDSPUty57" +
    "KPbgY0Vok/Hfm0F7On4SdE77raG//vWvkv99FxZDKvqIBZLBHQtMtMlxEs0A" +
    "JJ6077W5KQTRGCZaDu2NbJLmOTQ2mFN8UqL4R3ANI9S3Lnso9uBjRWiT8d+b" +
    "QXs6fhLyOeuEpU/vZWlCKvpKW4HhhsVJNAOQeNK+1+amEERjmNw5tDeySZrn" +
    "0NhgTvFJmfaQcQ0j1Lcueyj24OMyiIvl9TILiyEVfcZ7k51hj6nrNjlOohmA" +
    "xJP2vTY3hSAaw+TOob2RTdI8h8YGc4pPyrSHjGsYob512UOxBx/7Li4mLMzx" +
    "ZRMWQyr6Tq3A7Nw12NzYrL4cO2VjczNj1AdsbjRCGxtV3RabZjeF9je8MSS3" +
    "wTmj/j4cAxArHd+G3OaGrTVls0X8icxBuBa2d0f8nAGMRZt41+X3sgmLIRXL" +
    "QN0l0s4dO2UDJWmYyFUyM1lzaEOFAklC+5ZcMobkNjhn1N+HY0CLZI/JbfJA" +
    "yTqc2AgyB+Fa2N4d8XMGMBZRvOve0r+MwmJIxbJQJzAvvvhitoGSNEzkKpmZ" +
    "rDm0oUKBxKJ9Sy4ZQ3IbnDPq78MxIEj2duQ2eaBkHU5sBJmDcC1s7474OQMY" +
    "i6Z41wmLXS4x95cFqVgm6h5TpwIjScNErpKZyYoDAxsqFEgs2rfkkjEkt8E5" +
    "o/4+HAMakr09uU0eKFmHExtB5iBcC9u7I37OAMaiLt7ep5uNZXjc3IRULBt1" +
    "b7SzO+32dml7A1LEBmD7K69sALRvALbPAfrs+w3oJ2F/WfdGOGZjI4fts4F+" +
    "sb07U8eS7RXNfto89o+QubsKwmJIxTLSJDB2552bSuLEak6Sdok2W+iz7zeg" +
    "n4T9Zd0b4ZgiLin1flpe1glLXz8r1BWpWGa4SWPselY3fos4seqTpKJVos0W" +
    "+uz7DegnYX9Z90Y4pohLiu+n3aD13sOySsJiSMWyw80aY/8ldPNHxInlJ8lz" +
    "WiXabKHPvt+AfhL2l3VvhGOKuKSon97PrI5hLi87UrEK1L1XoO4yKU4sTZKM" +
    "Vok2W+iz7zegn4T9Zd0b4ZgiLilbPu7evaf2MmgVhcWQilXBHuFxA8fYf4/d" +
    "e3Y/Zw/YvWcP2Orr9yccv6f6XZkUS7Ym7JPfGVaX4vkhdqxuC/ZXm8GcHhjD" +
    "OQXGKvN3vHb6inkQS+1PHD/hB23S72jd0p6swy7L6y6DlvU9LG2QilXC+1WB" +
    "MfZfpF4sLPlSkIjSn3C8JRuTVw9VfsCC5PX8EDs4IBwjNoM5PTCGcwqMVebv" +
    "eO30FfMgltqfOH7CD9qk39G6pf3ZOuoeMxur8ESoCalYRbipY+y/yUsvvyTJ" +
    "SGGQRJT+hOMt2Zi8eqjyAxYkr+eH2MEB4RixGczpgTGcU2CsMn/Ha6evmAex" +
    "1P7E8RN+0Cb9jtbN9pdfftn9PaExzNFVRCpWlegyKU1GCoMkImC7jtcDwQNF" +
    "ouSlD5UfYgcHhGPEZjCnB8ZwToGxyvwdr52+Yh7EUvsTx0/4QZv0O1p32rau" +
    "l0FEKlaZ6DLJNt7+4/QT8y2F7YWF8tLLVf403bRd9csgIhXrQN3TJMOukSVx" +
    "ekERlz5jeVP3asVgDq4DUrEu1H3w0bBrZXtpywRaLEVc+ojlSdO9lXW6DCJS" +
    "sU7UfWxgTL8ulYq49I2mJ0GGfbCWObdOSMU60nSzdywy9h9qzEtkKEApu17a" +
    "pSTjfV4CebvMIf11TNTOdbB9V7WWnJdeMl+2kHVG/QMfKj9ok37RRjDHLomD" +
    "+ZbPITZk7Vt9o0ugdX61kiIV6wyTJMWSyZKqSmby7MAXcdEx0j/woc/isnPX" +
    "zsZLIGOVPhs0LVKx7tR9R8wYSy4eBjn4SNw2B+R50tcJAeeQ/jomauc62K4H" +
    "zBELIegf+NBXcXlxR/1TIGPdngS1QSoKI9pcKhVxsT4k6B/40DdxsX0ul0CT" +
    "IRWFHCYTsVcydrlkb8R7jv0NduzYmWHf99vEjp05tJfNV4v1S2F7gOOX9AnQ" +
    "dbdZx5R+z4Do8scol0DNSEVBiS6VRGR4gIq4LI24tBGVZf5e2+1EKgr1RJdK" +
    "z0Vm+FKah0gPWTNFXKbwuyP2T6GNqJRLoG5IRSFmEpHRQ9ZMEZcp/G5JEZX5" +
    "IhWF9rQRGbsZOLpkejHDbhRmWF0K22fAjhd3ZLy4A1hdRmzDBDSF/SM4vpUN" +
    "xIqxVXv5ul54ofkm7Zhy+TMdUlHoTpt7MsYLL/x1mNwjoYkOjLTPAArDOomL" +
    "CUqbVylGEZXZIBWFyWkrMuNXM00HRg7UDKAwrIO4WJzbvEoxiqjMFqkoTE9b" +
    "kTGeC00Rl/Y2AnF5sYOgGOv+GaB5IRWF2WHvg7CbgUzmOiqhecZf7YCk/DXH" +
    "BIlIHyDttMH+9KHCfNuCY2jT1tQI7FU2STTHmA6CYpT3qcwXqSjMh6YvqvLY" +
    "OnzjgxMIg9cHSDttsH96cJ8DIeA84pMjKDMSl7ENxq6J8ipl+5CKwvxp+i6Z" +
    "OrYOZI0wVIcN4gGknTbYvxITAiHgPOKTIygTisskYmKUeymLQSoK20ubx9ke" +
    "44O2yuIyqZgYdjlaLnsWi1QUFkPX+zMe+cF1xAJQCKS/CMucxAV1XFcXzp07" +
    "VwSlJ0hFoR90eeK0zpR7KP1FKgr9pIjNiPK9KcuDVBSWg0luCi8jRUyWF6ko" +
    "LC/26mbSG8SLxu43lUuc1UIqCquH3Szuy2WV+VFuuq4HUlEomACk8BLMXh2x" +
    "D20UClJRKBQKs0AqCoVCYRZIRaFQKMwCqSgUCoVZ8P8kbZ8gkB4FbQAAAABJ" +
    "RU5ErkJggg==")

# Original file: RunControl.py

"""
This class represents a control that doubles as a run and pause button.
"""

# // Implement the Pause side

class RunControl(PGLControl):

    def __init__(self):
        PGLControl.__init__(self)
        self.set_name("Run")
        self.set_active_icon(RUN_ACTIVE)
        self.set_disabled_icon(RUN_DISABLED)
        self.set_pressed_icon(RUN_PRESSED)
        self.set_rollover_icon(RUN_ROLLOVER)
        self.set_state(PGLControl.ACTIVE)

    def execute(self):
        self.fire_action_listeners()

# Images

RUN_ACTIVE = ("data:image/png;base64," +
    "iVBORw0KGgoAAAANSUhEUgAAARcAAAEXCAYAAACH0wDUAAAioElEQVR42u2d" +
    "+X9Vxd3H+z89Klq0BRVxq1irVoUu1motrfpUi3Vpa6V1qaKPVH0UAkkgCQGC" +
    "CfsWIGyBhIAgO4QlCCqyVG3Vbs/r9X3uN4cL986dc2Y5M+ee5TOv1+eX3Fm+" +
    "s5x3Zr5nzsw3thN9A4IgyLXQCBAEAS4QBAEuEAQBLmiEIurNfqKyXthINHFZ" +
    "tca1E/3XNLVGN9em/U33pbzLQpsDLlDOAMIPOj/wOqBIShM6LwEI/QS4QCmH" +
    "iMlsI60qz4Iw2wFcoDqJ/+vzg5hlkJioDBz0PeACZQgm351PNH5htZ7eEOiZ" +
    "9Zc0e3+gWQcu/T6s9YHKaSdUyNfshtsD4wJwgSzEDlZXS5wyPBgEf9xSgkMJ" +
    "ED2fEPWfk+h8tbadq5UYR8xj23m5Zpeg9Hqpcs+U7HioNBO5Yz5gA7hAiYid" +
    "nLYP2DVNJYB0ET3WHcwiGCAdR4j6zkZrq0rnJLJJE6GlJ4ia91fPgLg+tm3B" +
    "UMZ4Alyw3Om2h8mDpf/+k3uDh7P8YPedE5QBuISVwfWaMlAC5mqisW32vhqM" +
    "M8ClUEseU/9JJUzmD4Y/2HmCi5jnRdh0281suN0x/gCXXL4qNvWh8PKAfSTD" +
    "yxudhzrncBF/Z8gybBm6JrDhfsCbJ8Al8zLZvMYPyKOlJcDbO4l6z9Rqs6Be" +
    "B1LmeVYiwzx92C3T3MNET/WYgYb9XBingEumZDJL+elSole3Ea35KCYICg6X" +
    "SjGgGdQmb5wwmwFccgEVfj38fGlKv3jIIQgAlxoxsBnc93UBMoBLRv0pOg7a" +
    "sa3BtJ2n715AALhEikHO7c/9AMgALrmAyiOl6flbOxMAAeBi5J/RXTbhLRPg" +
    "kj6orCLqOk608VM/2iRRTZzTgj6NljK9Rh5ifGVdTqultFPxe1i5XceInlyn" +
    "5wQGZAAXr1DR+U/nGyqAizu4lLXqZAkyPYAM4JJCRy0PSv4PyP8JN572DxbA" +
    "xS1cyn226pQeZHjmiucCcPG6T4UH4W96gv984kAFXLIHl7IYMn/YrHb+Yp8M" +
    "4OJ8CcRQmVSaqaz4kGj9J4502lA6eZiW+UkdZFvXCG04XS0rOy78/eU+ohsU" +
    "kMGbJcDFyRLIOVQAl1TDpaznNkcvl7BUAlysv1C+tzQF7jxa54cMcKkbXPhv" +
    "K0rL31+uwpfYgIujV8v832rqjpQ8ZIBLXeFSVsMeLJUAl5gHNP16bfCp/7qP" +
    "o7XWQusMpZN+bQrkoh6u29tFnrI0PD6ilkpFP7iqsBWPmq3c0xkcy2j7wAAu" +
    "xYALa8ERop8sif4nBbjgTdDwf6EX++I/MIBLceBS1rTd0UulIp7zi2WQsARy" +
    "8cAALsWDS+VSCcukgsElbBnEsxU+lb77o3CtEdSt0imJdOJExfchDzYo20qn" +
    "DCGOaftrxY9ZRlR+zftKs5gWLJMKvQwaNy84LtHJYAVcAJcKLT5OdP+SYi+T" +
    "CrsMemKt48EKuAAukrr9dmNxl0mFXAb9z3YPgxVwAVxC6sb3MkU5ewGXDCms" +
    "E2+bGxwUxB+mVemkINXvCq08VStlulMeZGinlU2mbeehnsZtzXUXFHsMKNpm" +
    "UWmZ9OPFxTrKIXd3AoV13uNrHD4ggAvgYgiXcpxnNxQHMLkHy9WNRK8NOH5A" +
    "ABfAxRIurKZ9RGNa8n+MQ64/OgxdBgEugEsd4cLiZRKPzzwDJrdvhLjjOo8F" +
    "xyPE1fKTgj6Mr5oyDH/XyTNuGS7aYoUHGbftyXTYLdPDK/L7JimXYPnR4gAs" +
    "rgYJ4AK41AMwWT8jJnevmrmjXA8SwAVw8a1frckfYHINFsAFcMkKXFh/7M3X" +
    "XpjcgGVyr79BArgALgBMzuESBpbnNxMtGwrEXzbH1pAgF/F95KlKo8rD9HeN" +
    "OMtOVEtl87IT5mlit6WrcRKzrcLUsDvYQpF1wGQaLNwBr/RfAgvgArjkAS55" +
    "AUxmT+TnhucOqAQL4AK45AUuw4DZQ/Sdudl18mbydXMZLEuHABfAJb9w4TQM" +
    "GNkMJguAyeQ+Fr5DZtFQID43I1JDavFuyUopf7coQ2mnKk+NNOU2udg2pvW2" +
    "KUNhtxjfpkzT9lb1p6u2iGoXmYz7+MLfp4UskdK+0S5z3wpVggVwAVyKAJcy" +
    "YLL2qUCmwML3Mis7DHABXHIIFxbfX50lwGTmWMqHlmkObsAFcMkpXKIAk8bj" +
    "GjJx0NODJbB0HQu00FBdgnTi+FASZcZtC9P8FjroDyf1PF6tevRfkuPqkdXZ" +
    "AEzqwXLXgngDHnABXPIGFxb/w037HphUb5K7tZ2o/TDgArgALlkETGpfOcvA" +
    "ArgALoBLtW5tT+8r6lQ6cPmd/lu7iBYcJXrviKCjCeiIQkfrIA0bFgiKbbdO" +
    "3dPQNjY2pdFui/5oO0R0fUs670VKpZ+F73px9oAALoBLjuHCf397VzqXR6nz" +
    "s/x0meMHBHABXHIOF9akdekDTOr8LK2HABfABXCx6Y8JC9Plf0mNn2VkI9Gb" +
    "7xN1DEZrvqCOI9VS/S5TTRpRYnyFtMpQ5amwab6GHfMHo2Xa1vN1+kNhp6pt" +
    "bfrDdIzI2lvZ5xb94Xosq/q75SDRdbPT439JjZ/l2Y3qzgBcABfAJVr8Dzot" +
    "y6NU+FkeWKrXGYAL4AK4qPv8ibXpAEyihU2UbPq5pT2YzgEugAvg4gYurPFd" +
    "9fe/1HU5xH6WqaVp3NzBCzqs1jxBc1OgeYOCHNiZxnpCCY+rGGNg1n65/4X9" +
    "nbmDi2w59MyGCrAALoAL5HQMTN1R3+VR3c5nua9LAAvgArhAzsfAxJW1zx67" +
    "J3IDF9lyiE/WAlwAF8j/GJAtj3IBF9lmOabpcMUBF8AF8j4G/txfnwO+E5+1" +
    "3DyHaM6hQG2C5miozVBzDlZLK46gGjtM42vUQ8fOqPhzDpqXoYxvI0UZyt9d" +
    "2RHXTsP4bRZ2G9fzoIbEMi6MyXs7k3fuJu7EfbkPcAFcAJek4fK/uwJ3RJLL" +
    "o0SduPcviT+IABfABXAxhwvr5yuSPdw7USdu0z7ABXABXOoFl7aDyTp3E7t+" +
    "9b+7iVoOWOhgtVoPVEsVX6eMmjwPKmRos04eynrplKGq50FBB6KllYeg2DYd" +
    "NO8f4/7TqbuDPjfO02bsGrb/i1uTc+4m8sUzO3FbDwAugAvgUm+4sH68OJmb" +
    "AxJx4r4+ALgALoBLWuAyY08yzl3vs5aHlxs8MIAL4AK4eIcL67Fu/7MXr7MW" +
    "puP03cFHVNY6IGh/HeTDhnrUy0GZzYIy095pHDd1rue1np27Xt8Q/WhxTgYa" +
    "4AK45BAusnN3Xc5evL4h4lOxAJd4eR7/gui9QcAFcMne7CXdsxbA5WLYc5ao" +
    "/SDgAri41aOr/X0W4G3W8sYOosZ90WoStVcinTgVahTUtM9cYh7G9dDIU9eW" +
    "yvDP/yMaOB1eptJu0Qax7RTxGzXaV2WDskydcaFqN40yXPRpbBmOdR07Tcfu" +
    "Ox8QjZzpZ9+Ll1nLDxdZdiDgEgmXcjj7NdHKIcAFcIk/djmO7M5pF7OXus1a" +
    "ABd7uJQD+2M6DgMugEs8uPiavdRt1gK4xIdLOew+S9R2AHABXOzg4mv24vw0" +
    "/+d7iWbuDcQ7Aau0V9AeDSnSlMsKK1P1u41dMwUp89trUfcL8XQD+2M2nfJc" +
    "Lxdtp9MfrrXXwThKoG1sNFMhXRvfLs1evul49uJ01nL7PMXAAVy8waUcTv2d" +
    "aPkxwAVwMYML66fL3L6WdnpeS+WsBXCpD1zK4cB5onmHABfARd/G13e4Pe/F" +
    "2axl3DyNgQO4JAaX8lJp1xmi2fsBF8BFz8YfLHI3e3EGl1+tCb4jMtE0QTpx" +
    "dNJEao9Eu91qmkO7XYQv/kXUfcKu/V2kid1HdegPF/WcZignY2+PIFUZQlu/" +
    "2OfOsevMkfvWTsAlrXCp9Md0DgIugEv08zB6lptrYJ3MWn6w0E3jAy5+4VIO" +
    "+88TNe8DXAAX+fPgyrHrBC5P9QAuWYJL2R+z8wzgArjU6rXtbr6Wjr0jl9+N" +
    "u+p0wCU5uFT6Y5YeA1wAl2rxC5q4s5fYs5YHlhK9+0GgdxR6V5Dq93c10rgo" +
    "4x1T7YrWuxLV2CH+LuZxwbakwsm/BaelKdsqxE7d9rbpD2V/ie33gX/pjCHX" +
    "bfOOxTNjWw/ZSXVe4SLb2/KnLYBLHuBSDu9/GryKBVyKDZep78e/wD7WMZY3" +
    "tvl/8AGX5MM//0O0/iTgUmS4sMYvjDd7ibUk4hvcAJf8waUcznxFtOQo4FJU" +
    "uDzZkxBcfiNZg73cT/T2LgPttJBpnjZlurAzbj1CbEhDGPyMqGWfo3on0ec+" +
    "+tPGhrh5xB1DDp5J8WNGkz0v1rOWOzvcVwRwSSdcymHHaaIZuwGXIsGF73e3" +
    "nb1Yw4XP3gRcigUXDp//k6jnQ8ClKHCZ3OsZLrLLzl7uA1yKCJdy+PBvRIsG" +
    "AZe8w0W2NGIXiTO4iN8SjZoVXBsi6i+CTH+30V92Vsv0dy3tFGRok1a5IWWk" +
    "PfCtBM17a/s2Vh+r2lv4PaxsExtM86hHGVp1U7SNTT2+12F3iJTVkogvsgZc" +
    "AJdy+Md/SoPtNOCSV7j8bLnd0sgKLk+sBVwAF7k/hk/BA1zyBZc/bPYEF5m/" +
    "5bUBwAVwCQ8nviBqPwC45AUuLBu/ixIufMxdZaY3tAZXhwxre7WmKnQxnYm2" +
    "G8qijKmCVDYo47uo14V4WQ4DnwSb2t7YEVOqPvYxBhzkqRxH4vPhYGxPVcgm" +
    "PZd9b6e538XqmlbABXAx8cfwrQSAS7bh8ouV5ksjq+MsARfAxcYf895hwCWr" +
    "cOEPlE2PvzT2t7yyDXABXOL5Yxr3AC5ZgwtrVLPZV9JG/pYxrcEpVRc1UK3X" +
    "TbVdQ4o8amxQpK+y/4JUdinjD1jYqYp/oay8hv6Pid56X97nxu293Vw1ZXiw" +
    "4bWBaJmOmdccjPc4bXdPp9nSyOys3EWAC+Di1h/TPQS4ZAUuE1d6hMukHsAF" +
    "cHEfTn9JtOAQ4JJ2uEw29LuY7W/ZDrgALv7Cob8SzdwNuKQVLixxv4sTuFxV" +
    "ynTKtmq9Ksj494FqTdHIQylFnrI0UwYEbYuWyoYpFnUNy6NogZdKfR8T/WWH" +
    "Rd+b9IdhGmWeAxryMa4Srsct7fpOXe2PFTlTwAVwSSp89g+iVccBl7TVQ7zu" +
    "NWoznfZ5uXzxGeACuCQdhj4nmncQcEkrXKKcuka3KgIugEu9wq5P7ZdKgIu7" +
    "ekxa5wEuk9YCLoBLOvwxgEv96vF8rwe4PLWe6M/9huoT1O9BHsp4pa9aXuzW" +
    "FILcH7Nw0GAM9FnE8TE2kygjZvpX+mslptF9Ha39GjotDz7gglAOxz8PrmUB" +
    "XJKFy5gWveMXtK4R4cwAF8AlrWHrR0RvDAAuScHlduEeaf5MSBsu4mvom+cA" +
    "LoBL+v0x608ALknAZUKXnt9Fy98yvpTZS1s11CfIMP6LW2v1Uky9qKO+ar1k" +
    "qJr0FnUN+x3B3B/Tvt/BuDIcyy/2qceR8e82dsa0WyePh5Y7hAtnBrgALlkK" +
    "B84RvbMTcPEBFz7TyRlcODPABXDJqj/m9W2Ai0u48N903hhpwYVvXQNcAJes" +
    "hq//Q7T8KOCSSri8sCU45s5ULwgyjT+cZqtCW/zLtB4yO18QpFsPBHfh478T" +
    "te7z1Oee8kh87GrKCi6yPS6AC+CSp7DjNNFbOwCXOLqpDXABXBBCl0q9p4im" +
    "9AMuLuAi20gHuAAuhQ5//QfRsiOAS1y4yM51UcLlutmBQ3fyZol6q/W8IDH+" +
    "86LE+BoS8zC1YXKvA21WqNedEJIJRz8jatjltu+UY9li/KdFTuDCmQAugEth" +
    "/DGfBLuyARcPcBG3/gMugEsR/TGbTwIuURKvGQFcABcEQ39My17ARQcusuMu" +
    "lXC5sQSXP5QemOc2mYvTmUiaz2ZBYhmCTH+X2enaBlmcmjJDhFD/cOSz4Ktr" +
    "kzEhi6MaZzXjaLNaqnGlLFOMozmev/+e+hMAJVy+3wm4AC4IHDadDHaoAi6W" +
    "cBnXDrgALghR/pjVxwEXK7iICQAXwAWhNnz0d6JZe4oLl1+sdACXu0uE+t3G" +
    "kjZJtNFMvxf0u43J5/H7TRIZ5qmMr9FWqjzKtiGkOzTtsXsWZGPRZqwbPw+q" +
    "Z3iTXpyJgAvgguAn7DkbXIdq+ywUEi4TOgEXwAUhajl0cbayqbhwudvF26Lv" +
    "zgdcABcEduQuGgzpW8DFDi5jWwEXwKXYYeOHwcemoWABXOzh8uwGomckelbU" +
    "+mqp4ivzk6VZL2hDtFQ2PquTh5hmQ3zp2olQvzD4V6JX+4JxZjrWdcaizfhX" +
    "yvAZtBmrrLsWVHOCt7AALoALgiKc/5po5q7qcQa4RMPF6qtowAVwKYxf5d9E" +
    "K49e6JP1gEsUXG5odQCXa5oAF8Al/6H/4+CDvIt9Arj4h8vwJfQ9RE+vrxX/" +
    "vUrrBfUotF5DQhpTG57uqZasjJq69URLy27DeoXFQ/DvV3lzu3qs1owBD6oZ" +
    "2xZSjV3VWNd6TnsAF8AFIdKv0rZPf6wCLtFweWEj4AK4wK8yfKc0nwVkMlYB" +
    "l+q2Gj3L0b1FgAvgkgu/ykfBEZZa/QG4RD7Xzi5Fe3Q10ZPrJOoRtM5Mk3qq" +
    "ZZreRpMkip2HWA8bhZSFED8cPk80faeiX2OOZZ0+jT3eJWXEHcu2cgaXB5cB" +
    "LoBL9sJXpSXQgoOWDy7gEqrHXV5EzwfDAC6AS5ZCzxDRcxtjPLiAS6geXOYQ" +
    "Lt/rAFwAl2yEDz4lenmLgwcXcAmVzil0oXARPwEY00L0xNpa/dpQTygkTbOm" +
    "WnHLsKmHsQ1rNNKsERRSDwS9cPILomnv648J03FkM+7ijiPVGLF5pkxtHJaQ" +
    "5o75MeDC76wrE17dCLgALun1qywdjP/gAy76cOHJhmoDXShcZHtdABfAJW1h" +
    "7RDRbze4efABF324jJqlvoQ+FC4yv8vPlgMugEs6wqHzRC/0un3wARd9uOi8" +
    "hjaCyw8WEf1qjULdglzHt8nDpgxFmscF1cSXSEzzeHe1wmxBuBTOfU3UvFuj" +
    "vW362HAc6fRfzTiJO3Y17NQdV2F6XDG+dd8UGcHl9vmAC+BSP7/KmuMxwAC4" +
    "OIPL/YsdwEW8HO3WdsAFcEk+bDkVHHkQCwyAizO43D7PAVzE19HXtwAugEuy" +
    "fpXX+h2BAXBxBpdb29XHWyrhIntj9NhqMz3aXS1lfIke6xakSGNVhihFmUqb" +
    "uiVS1Sskz6KFs18Rzd1v2Ham/WcjIU+t/lydvFR22YzLyt+vm633GjoSLjK/" +
    "C1/hCLgALr78Kt3HiJ5aZ9F2gEticBkxQ+9NkTFcxncBLoCL+9B7kmjypoj2" +
    "A1xSARfejqLrbzGGy7h5gAvg4i58+AXR29s12g9wSQVc+BtDZ3ARr3b9djPg" +
    "Ari4WQLN3ac/bgCXdMBlrHC05ejmGHCROXV/voLol6vkekQh0/iyNL9cKcgi" +
    "T2UZijxNf7dROa+8hdXHiJ5ca9hWij4Xf7fp80dWVktZpouxbDkmfOYZFUf0" +
    "t4Rt+9eCi2xpxNc4Ai6Ai2l4/5PgfBWrtgJc6g6XnywxWxJZweXmOYAL4GL2" +
    "avnNgZhtBbjUHS53dHiAi7iZbmQj4AK46PlVFh5y1FaAS93hYupv0YKLzO/y" +
    "QGmKNHGFhlYqZBq/pJ8LmmgqHTvj/m5rhyTPLIZVR4OvaU3q6bX9VziQjQ1x" +
    "x4kPuy1l6m/RgotsaXRnB+ACuNSGA+eIXtpiV0/AJb1w+dFi8yWRNVxuagNc" +
    "AJdqv0rDznj1BFzSC5fvzvcIlxq/y0zABXAJ/Cq8BHJRT8AlvXC5drb+x4rG" +
    "cJHNXu5fQvTw8mj9TJBpfKlWVOthlVyVG2WDmKfEDlWeYTalNWw8QfT4ao0+" +
    "9tA/yjRi269QjxvTPtayybCupmNEyw5FW+j0l/jsy+6FdgoX/hQAcCkeXPaf" +
    "JXqj335wAy7ZgovuNSKx4MKvnioL+FYT4FIkuJz5iqh1T/zBDbhkCy7sX/UO" +
    "F/G6EZ2lEeCSfbh8+W+ilUeDg4ceXgG4FAkufF7uiIbqZ56/N3QOF9nS6Jb2" +
    "wABbPSRIGm+pIA9lPKRQXBu07Aopo55h4GOip9c56MOCKm7beGlbYZw9JKgy" +
    "ru1bIiu4iOfqfnMm4JJHuAx9TvR6Xx0fAMAlFXC5viVBuMh2697TCbjkBS68" +
    "BJq9OwUPAOBSd7jINs7p7Mq1hotsaTS2DXDJA1xWHCF6bFVKHgDApe5wuW1u" +
    "vFmLFVzEA6TY4fPAUkstEbS0TlqiUD3KvCDfYd+Z0n+ktfr15k/vK2XcVjrx" +
    "DfvjJ6KWqKUqoya+Rf8p80hiXFnmc02T+YeKseESdmEa4JItuPCr5SlbzesN" +
    "uOQfLvd12W+ccw4Xvm4AcMkGXNiv0nEgeAht6g245B8ufGZT3CWRNVzYsSO7" +
    "SxpwSTdc1p8IzucoP4SAC+AiE78FtvmWyAlcZLMXvomNN9VV6seiFlfrflFL" +
    "1FLloSxDI02NFPWoKVPDbt16uAh7zxA9t8GubUzbLu7vOlLapNFfpnbYlOFj" +
    "rKrsiNv+shPnou4m8gIX8XMAph3gki64fPol0dsD9g8p4FI8uNzQ6mZJFAsu" +
    "ss8BmHqAS/3h8uW/iJYNxn9IAZdiwUXmyI26rtUbXGRLo1HNgEu94dIzRPTk" +
    "GrsHBnApNlzGtLibtcSGi3iIFOuu9wCXesCF/Sqvbon3wAAuxYWLbNZi68h1" +
    "AhfZ7IVvZfzhIsiVdPwqjbtSZPNCQejDTMj1rMUJXGSzF75TFh3mHy5LDgef" +
    "yafKZsAlc7q30/2sxQlcMHtJHi79HxE90Z1SmwGXzOnGNvezFmdwwewlGbgc" +
    "+4zo5d6U2wy4ZEoTSn10RUP874i8wUU2e7l+dmC4kbpqNX5htcQ0Nb+LeSx0" +
    "YIfi9/GiFqrtltVVVu/yq+W5e9V2j48pnbbRqWukhPQ69VDZYGOjqv1Nx8T4" +
    "Lgsp2samHqbPg2xfi+2mOW9wEQ+SYvHhvoBLPLgsPhx8Aq/14AMugIvB88Bv" +
    "iHzNWpzCRTp7aQFc4sLF6MEHXAAXg+dhrMdZi3O4xJ69AC6AC+CSCFx8z1qc" +
    "wyVs1+59nXLdK0gnzr1dghR5iPHDbIks01RdajuVvzuQl3oatr8LG5Tjpqta" +
    "Lurloq2M87AYE7Z2yva1uJy1eIGLbPbynXbABXABXNIClzsX1D6jrl4/e4WL" +
    "bPZy1Qyie94DXAAXwCUNcPlWk/9Zize4yPa93NACuAAugEu94fKddj+7cROD" +
    "i2z2Ut5Yxw7e3GmBIA9p7hbkox4+yrDJM6t1dT2ORBvvXlArk/zvWlDrxPWx" +
    "HPIOF9kdR3yiOOACuAAu9YGL7JKzOOe11A0uYc5dvgIWcAFcAJdk4XL7vGSc" +
    "uInBRbY8unJGMD0DXAAXwCU5uFyTkBM3UbjInLt8FQm/DrtLVEet7hS1QCFF" +
    "/LskUsVRlam0ucMiT4W00oh2KdrKqj9UeTjQnXFlM44UfVxjo4sybNpGVWaH" +
    "fCeuLyduonAJc+7eNg9wAVwAF99wuWN+sk7cxOEic+5e3QS4AC6Ai2+48Coh" +
    "7oXyqYZLmHOXKw64AC6Aix+43CS5OdH190OpgEvY8oivjuSpW6g6BJn+7kIO" +
    "yuA9PpWqS73qkOf3BOnYoEwjqCa+Tn+o0rjo87hldJirXNa4ufLlkG8nbt3g" +
    "IrvriBuAX5MBLoAL4OIOLuKVrKwJncmBJXG4sCZIDgO+uhFwAVwAF1dwuXZW" +
    "fZdDdYOL7CpYFjcI4AK4AC7x4HJTW/Kb5VIFFyP/C+ACuAAuWuLtHfX2s6QC" +
    "Lvw6TGyEyxsCRxT7YHTF8StlkjZUcwU5yHOcoNsT0DiF4qavVz3qkaeLdlCm" +
    "Ecad6di+KgV+llTAJez19MhGwAVwAVxM4TI6JX6W1MAlbHnEDQW4AC6Ai97Y" +
    "lm3vr5efJVVwCQMMO6YAF8AFcIke23z40+Up8rOkDi5S/8v04JpJbrxIza3W" +
    "baLaqyXGH5ZhGcrfNaRll2F8MY4yjWm9deolyPR3K7VbyLR9hfQ18SUyrqup" +
    "je3BEbJp8rOkDi5h/hcGzK2AC+ACuNTYGAaWevtZUgmXsP0v3IC3Ai6AC+BS" +
    "VR5vPE2jnyW1cAnzv0QCBnABXAoGF9np/WkDSyrhEgYYfkV9yxyJ2gWZ/l7S" +
    "ze3VkpYToZsF6dgpllmTR7tCOm2hSKMsc457abWVSg76PKu6JgQs/N0e4BID" +
    "MNywgAvgUlS4yL4ZSitYUg0X2RfUUsAALoBLAeASBpakDn7KFVyiAMMNDbgA" +
    "LkWBi+w0uTS9cs4kXMIO+B6+4H5WsA/mJkE3Cqr5vVWiNjOZlnmTRpoaKWy0" +
    "ytPCTlX7Gbe/Cxtc1Ku1WnHzvNGT+K4h3pKRNbBkAi5hZ8CUAQO4AC55hUsY" +
    "WNK0lyXzcIkCzOhZgAvgkj+48D/OLIMlU3AJ22RXPskOcAFc8gKXUSHO2yyB" +
    "JXNwiQLMyJlEN7RI1CpIJ44qjWl8nTSmclGGCxtbFDKN76OtJBorSGXn2NZo" +
    "OWmb1vANclkDSybhErVE4kOJxwAugEtG4TKyMT9gySxcogAzokEADOACuGQA" +
    "LmFgSeLaVcDF4DV1FWAAF8AlxXAZ0yr/ujkrr5tzC5eojXbsaec3SdfPrtZ1" +
    "El2vUosgMc8WQRZlxLapxTJNhWpsaNGQogxVvXy0lYv+UJap0fY6dR/RkE+w" +
    "5AIuKsCMagZcAJf0wYX/8YWBJa3fChUSLlEfO5a/qAZcAJe0wIXfCMn2sOQJ" +
    "LLmDSxRgrpwhH2SAC+CSFFxYsmtW03TuLeBiuReG/1t8uxlwAVySh8uoiGVQ" +
    "Gg96AlwMz+St3A/Da96yrhU0WiHT+MNpmqvlowzTPFVlXOvJjrh1v9aBkrCp" +
    "/BvvIL9ser72sBQaLmG3Clx8XT0DcAFc/MPlqohlUB7eCBUWLio/DP83Yeca" +
    "4AK4uLaJl99XNBTHv1JYuOgskwAXwMWVTUVdBhUWLsplUkNwhCb/x0mlmgS5" +
    "SNOkkCs7XKZPa9s0BbPgKKdt3pdBhYaL6m3S8DUmMwEXwMW8bXgLf9hspSjL" +
    "IMBF8eFj+ZU1b7wDXAAXVdtc3RTtWynSMghw0fhsoHKp9C3ABXAJaZsrZ0SP" +
    "H/6wtsjPV6HhouPsLe/uZSddWdeIalKrMr2OlGU0qmVchpi+qVbKeorxGy1k" +
    "2HY2bW1cZkWdrpwZvQQq8mwFcJGI18RRgOGlEvtjAJfiwoWXypc3RI+TPH0b" +
    "BLgkdEZMWby+vhpwKRxcVEugor0JAlw8LpVGVEIGcMklXHimwv2MJRDgkvhS" +
    "qTyT4deQvBHvomZINLNaI2dUS/y9Jr4DfdNQOnnELSOtuqJB3fdYAgEu3pdK" +
    "wz6ZSsgALrmGSpbPtQVcMrpUqoIM4JIZcX/pQIWXQEXcDAe4pA0ypXX6lQ2A" +
    "S9qhcjmgArhkFTLsDOT/ivy2wUQjFGJwKTXDgxRl1NhpmN6LjYK4Py6fjuUP" +
    "4JITn0x5NqMLGsDFLVxGaAIFUAFcMg0Zns3wdHwE4OLVRgbKFdOjXyUDKoBL" +
    "LiETtWwCXOx1RYM+UPANEOCS2Q8jo453kM5opgf/bXlmU6Xp1bqioVY1cQQp" +
    "8xDjN6glplHZVCNZniq7QvIwAQr2qQAuhTioKgw0l00HXKLgctl0c6BglgK4" +
    "FPYsGSVsCgqXSqCYth18KYBLIT8v0HmdHbWEujzHcLGFSXlvCpY9gAtk4Z+J" +
    "mt1cljG4VNptC5OyePmJ8QS4QI7eOBVZ3E7YPQu4QDGWT4DNpXNTABPABfII" +
    "GxunMGACAS6Q9ezG1kFcb7G/qbzEAUwAFygj0GFncVqWVWwHO10BEMAFKgB8" +
    "RDEAKiUuwXh2JMaR5YP2BVwgCIIAFwiCABcIggAXCIIgt/p/3eN5ZYDjKDIA" +
    "AAAASUVORK5CYII=")

RUN_PRESSED = ("data:image/png;base64," +
    "iVBORw0KGgoAAAANSUhEUgAAARcAAAEXCAYAAACH0wDUAAAgsklEQVR42u2d" +
    "d7QdxX3H+TvVf6QX4+QkJ4mP63GccmyDHSf2ccWJ49jGuObEkp7aA/WOGkKo" +
    "0SRTDAjRJAtk2RSDbbAwMtggvd6L3tPTQ0/lqUtIIMEvd7hv0d3Z2Z2yM1u/" +
    "f3z+uXd36m8+d2Z27+4lu4guAQAA26ARAACQCwAAcgEAQC5oBBBkXivRd3fJ" +
    "ubqJCO0FIJcSoyKKpFjeCSFBLqCQs42sglkQ5AIyABuIeRaJDuhvyAXkUCbL" +
    "OojW9vh5eLjKIzW0n6jSduLi97V4566rAbMbyAUUeInjyYMJ4ImRqhxOnie6" +
    "8IYA8vP6G0EuSAicQ1XaTxI9e7gqqtv7q/sukA3kAhIgzmCrb6oKZNNgVSJM" +
    "IHtOE51/g+N1P6/JeEOAyTkRjJwjaj3hnwHVx5ilMSkjniAXYHgVhw2+2yq/" +
    "/o9XZiIjZy8O7IBMciCXsDxYvX5xqCrMua3Yq4FcgJP9k1qZ9J8OH9hFkguf" +
    "JpvheLIxmdkg7iAX7KGMwZYHbI/EW968piCDIsuF/55JlsmWSVdHNlg2QS6l" +
    "W/awAXJv5Vf516NE5y5UeN3PWY5zFjh7wc85HpV0uHPOvh7NOUf0VmSzdZ+e" +
    "aHAzH+RS6FnK9/qInjlIdOzV6IENuajDBM1EjStOkEvppMIuDz+2n+jlVwQD" +
    "GnKJz1hZmLCZuNd0QzKQS4E3aNkVDzZt7z0VIRTIxapcamEiZ+2vcuUJkoFc" +
    "ciGVjZXp+QtHFIUCuTiTSy1M8KrLJsQ55JJJqQxVfi3PXHDDKwICx5znuBCN" +
    "9HyFNPjjpXU5L0daTsn3YbD+2aK4CYy4h1xSv/KzccCtVCAXe3LxGH0VkoFc" +
    "MrpRy4Jyy1BFKmfGBsQFyCVPctGVDPZkIBfnsxUWhD+oBOPoOW5AQC65lEut" +
    "ZB7dL9/8xX0ykIsTqWyuzFQOVaRy6jzIGqc54qT1s4NEc1qxVIJcElgCQSrl" +
    "kovHj/dHL5ewVIJcjGcrq7uJ9p7BwC2rXBjsR+WeAcxiIBdLl5bZr9XOUQxY" +
    "yOUiDcewVIJcYj6g6aGh6nNFTpzneM3PcZ7zArhjZGkG8uDSOyHg+GuWUahH" +
    "oF4W6qHd3pJyn1Apl0G9WHxELZXK/g9szFYErOquPi9WVQSQSznlwhg4TbS+" +
    "D7MYyEWyt8J+hZ46oC8CyKW8cvHYdTR6qQS5lHgZ5C2BhIEFuUAuirA4wjKp" +
    "ZHIJWwax2Qp7Kv3R18I5xnFUxqsCVI6JOt4FJmWQnHOMQztPUZp8+0vKKT1e" +
    "pdy6/VFzbOvxyiymBbOYUi+DlnRUH5coCxzIBXLRbUv2iIdbe8stmNIugx4c" +
    "UpcF5AK5mLblD4fLu0wq5TLol4f1ZAG5QC5x2rKsy6RSLYMWt1cfFMT+mObj" +
    "HMer8TgswHWeNsrpJJ8E6mlSj8A5snLGrMdwZZl0S8mWSaURywN7kxsAkAvk" +
    "Esa24fIIpvBimdpItONQsgMAcoFcomipLJNmtxT/MQ6FFkvoMghygVxSlIu3" +
    "TGLxWWTBFPaKEOu4va9U/8kal4MOkOVhUgbdeuh+f8hCPQ+d5VDpA+4caZ6a" +
    "xzsrtwJ37inulaRCiuXm3qpYDp6DXCCXbMslSjB5f0ZM4S41s47SGXCQC+SS" +
    "tlwY9+8tnmAKLRbIBXLJi1wYT4wU60pSYcTy+IjZgINcIJesyKVogimEWNh7" +
    "lw+crTICUuUAh+7x6MPqk+7YLRR5F0yuxcI64OmDCEzIBYKBXCw+kZ81POsA" +
    "BCbkUmTBXNue303eXF5u9sQygsCEXEo6g8mDYHJ5Hwt7h8zw2SrsuRmRnOUQ" +
    "HDPMofu9NE+VchqUO1DOs35kaWjXS5SH5vEmeSq1bw2BPM4anKNJoJ5n9dsq" +
    "rJ67QgST9RvtcndLf61YIBfIpQxy8QSTt78K5Eos7L3M2h0GuUAuBZALg72/" +
    "Ok+CyY1Ybu83C27IBXIpilzYZ2GCgVwMxXJbRSxDr1TZd0YP77yo8/ljhs5I" +
    "kB3/ijxf7TQV0G4LDpW2ksKnq1tvhfaU5TlkA0nbqrR97D4NKdvGwXwIJvNi" +
    "ub4rXsBDLpBL0eTCYD+4WRdMpm+SW9RO1HMacoFcIJc8Ciazl5xFYoFcIBfI" +
    "xc+i9uxeos7kcohd039htPoe3kGeMxyy7004LeFMCiiUYYAjdrldtH8SbamS" +
    "Rxb61EJ/dJ0imtWSzdlLJvdZ2LtemFggF8gFcpH3x6+PZHN5lLl9lu/1XRQL" +
    "5AK5QC5q/bF5KHuCydY+SxtR50nIBXKBXEz6Y11PtvZfMrMcmtJI9Pwo0Z7T" +
    "HKf8sHc718IfL/t+j4Vz+iWY5KGbZr8FpPU8FUR2TBr9YXJ+3D5X6Q/d9o3b" +
    "xx2VH+aZGdp/ycw+C3tZlLATIBfIBXJRhv1AZ2V5lIl9lg19EZ0BuUAukIsW" +
    "D2Zk/yX1WcvCtup0DnKBXCAXe328NgP7L6nvs+ysTON6T49xSk4fR28G6DvN" +
    "YaGcWawnSDiuYsRA24n0919SXQ49MlwjFsgFcgFWY2Bnyvsvqc1a1nRzYoFc" +
    "IBdgPQbuGii4XETLoV1HIRfIBSQRA2ktj1K5WY7Z9M2KQy6QC3AeAz8/mM4D" +
    "vhOftSxoI+o+WYX96aoW73Mfp/zw53SdjIZPr+uUPN9AGlwZpMcrIC2nZr2E" +
    "baVZLmm9T6nVLS667S8sZ9wya6bRddJBe1tsy9Xdyc9eEt/E/dkByAVygVyS" +
    "lstvjlS3I5IUTKKzllv7ogc65AK5QC5u5ML4/p5kH+6d6CZuy3HIBXKBXNKS" +
    "S1fC/z1K7PWr9w0SdZyQcFJO5wk/0jROyAmkKSuHhXpIy2CSh6yeJzlORKOU" +
    "Bod2vUVpaPaPdv+p1N1Cn2unaRK7svbnjn/qQHKbu4lt4hoPGMgFcoFcrMmF" +
    "cUtvMrOXRDZxnz0EuUAukEtW5NJ4LJnNXeezljv3xBwwkAvkArlYlQtj02DO" +
    "5MLPWpgddx+r/olKyHGOEwlwXAEbacTNw0Zbxa2X4JhWDu22UTk+bpo2+stG" +
    "XJ3IIDXlm9HsVjBOZy039zoYMJAL5AK5WIl/0XN3MykX0RWi549ALnGD95P/" +
    "SfRkM+QCubiJf5ezl/RmLZCLEpdcUuV/6yuyHoRcIBe78X/vYMblIpq1PDdK" +
    "1Hw8mhYTjkXTzGGSB5+GjXqYlsuTC+P33kZUf214ntJyS8ogO775mEEakray" +
    "FhcRMdJ8XJ+WLKBQD93253lR8LcAW/e9OJm13NTrsANLLBePd76P6I7tkAvk" +
    "El8urA9F75zOhFxMZy2Qi7lcPD7xBaInmiAXyCWeXFzNXlKbtUAu8eXi8Z16" +
    "op2DkAvkYiYXV7MX63J5bISo6XgVdiega5o4dL93kWfjcQGGeanIxduPWXCj" +
    "43rZaLvjfpKIERvlSqJtbPSZaTnZ+6YnW569WBXL0o7kAwdy8fMvH638Cm2H" +
    "XCAX/XJ+z/LsxdmsBXJJRy4eX/xWpT+aIBfIRZ1nD9t93os1sSzpSCdwIJfo" +
    "pdK364l+OQi5QC5q3Nhjb/ZiTS73763+j8jH0Wh2cQTOPxY8ZtcxP7I8AhxT" +
    "4Gg8dimgmlYcuXj8xTuIVt4jb1uVtjKtR6w+ctEfkjiKHWcqcWAhD1m5dftY" +
    "9LyX1OXywijkklW5ePzzRys/AjsgF8gluo+nN9t5DawVsbCplElQQC7JysXj" +
    "v75FtGMQcoFcxH1sa2PXily27oNc8iQXbz/mW/WQC+QSZMfhlOTC35HLro2b" +
    "BgXkkp5cavdjNvwQcoFc/LALNHEFE3vWsqGP6KUjVV7kOernJQ7++JcEx3hp" +
    "h+YhSUNWBtExUmRlOCIvt+r3ruXi8U8fJdre4KAeBn0ujRvN/lDqQ83vZfVy" +
    "0TYvKsazrFwqeWzamwG5/GQEcimCXDy+OZXo6T2QS9nlsnM0Ybnwj7FkS6TI" +
    "gQ+55E4u3n7M3HWQS5nlwlgb856XWLMW9gY3yKV4cvH4h/cRrd8GuZRVLlv2" +
    "pSiXnx2s/uFJmVEJRxwwapCvbrlG3dUtTbl4fPwKom27Fetpo+2SiAHdc2zk" +
    "eySDSMrI/5lR554XY7Gs6HQw0CGXTMrF4xtTKz8o/ZBLmeTC3u9uOnsxlgt7" +
    "9ibkUi65MP78HUSz10IuZZHL4yMpyEV7SQS5FEIub126vpzolm2QS9HlIloa" +
    "OZXLtGai50eD/Irj+cN+ZN+L0pQRSFOzTKb5+pDUM05dsyoXjyu+SbR1t7jO" +
    "v1Joq9htL8r3sJ/nFQgrv3JcqZSTK5fueAmcf1g/T5N6XNdp9hApo1kLe5E1" +
    "5AK51F66vmoq5FJUudyxx2xpZCSXB4cgF8hFvB+z7G7IpWhyeXR/gnLZcQhy" +
    "gVzC+eDlRHc/DbkURS4Mk30X6QHLufXWnFai5w6L2SnhuSQY5VA4R7ecSdYr" +
    "j3Lx+NoUoif69fsjDdKIVSt5cvEedwyGnbO6W3/fxeg1rZAL5KLK776NaPxC" +
    "yCXvcrl7QH9pZPQ4S8gFctHlz95BtG4b5JJXufxkJAG5PH0QcoFczPnHy4m2" +
    "7IJc8iYXxrRmi3Lh91tmt1afUvUWh/w8q8thBSRp6JbBV/4xZOWSHn/IQTnH" +
    "KJpcPK6cQvRYr7jPtdtbM2ZEcRC3v4T1OBSNbszssBDvRmNy7LtVXXqzF71n" +
    "5fZCLpCL3f2Y6Wsgl7zI5a49DuWyeR/kArnY5+/eS7T2Ecgl63J5fL9DuQQG" +
    "JuQCuVjkY1dUfsB2QS5ZlQtjcoMDuUyqJPqLg36e4Qh8f8iP9HsB/DF8ns8c" +
    "ikaWpzDfg9E8I0GlHtK2HDuvTHLxlkpfnUz04x55O6ui1Ie6/cNzKD5O6iGL" +
    "Q00WtjmQC0sUcoFckrx0fc1qyCVrcuFf9xp1M53y83JZopAL5JI0H7icaPVW" +
    "yCWrcomavWi9VRFygVzS4rPfMF8qQS725LJ5yIFcWKKQC+SShf0YyCU9uTy2" +
    "34Fctg4T/fygJgc4dL+3kYcBTx/wYyNN03pAKuL9mIXfjxFnNmJR5fgDEuLG" +
    "iIM02R34PPw51uXiZOBDLpBLzP2Y+16EXJKWy+wWi3JhiUEukEtW+UplqbS9" +
    "G3JJSi5LufdIs78JGctlQRvkArlkfz/m/+ZDLknIZZ3iFSOlJRF7reNPD7jn" +
    "KQE/HeGwkKaMuHnYOMf7HOLQ408vJVq5lWvLkSCx45WLy6c0+tT0+yTGnMo5" +
    "t/dblAtLDHKBXPLEZZ8n2vQi5OIidtkznazJhSUGuUAueeTLk4ke6YJcbMYu" +
    "w5pcHh+BXCCXfO/HTF0FuWRSLk+OVB9zp8uTHLrHv3nOAY6R5NGtR6DMFZ7k" +
    "UM0bcrDH376XaMUPHPW5ozQSj11FIBfIBQj49NeJ7vkN5BKH+W2QC+QCQpdK" +
    "/zOJaGsX5AK5QC7A0aXrKasgl1TkMrOluqHLHnEn4zEO2fey499kxI80jxE/" +
    "svQeVzlmvwV00xw7DgJIhvdfRnTTk5b6WjWWZbHqIu5MYltwnhW5sEQgF8il" +
    "LHzqKqItnZAL5AK5AEf7MV+aBLlEpbGqG3KBXECs/ZjlWyAXFbmIHncplcu8" +
    "VqJHKxn8+GV92Hk6CNPZz8HnwaH7vaictssgOiaQZwgY5OnzvsuI7nxBLyZE" +
    "x8jiLBBH++XI4kqaJ3+MYjzfoPCCNKlcbuiGXCAXwPjviUQPdUAuxnJhMxXI" +
    "BXIBYn7nbUTfnAe5GMmFPwFygVxAkL95D9HSLeWVy90DFuSysmKo7S8bMuzn" +
    "Ry/7MUnzR8N+tsvgz1dAux6SPE3S8D7HQM42Szarx792DPCxrjIeXk6GuyAX" +
    "yAW44UOfI7r9Bb34L71c2PMwIRfIBYQvhyJnKyWRy0obV4uWdUAukAtgG7l1" +
    "N8SLf8iFk8vcVsgFcik3X5xI9EBH/PiHXARy2VYp9CMCtkmQHa+b3pvn7OMY" +
    "jiaQxr4g0jT4c4bjo1pODO70eO9HiDY8rxZHshiyFf9SJOWyEauM6zm5sFtY" +
    "IBfIBUj4k0uJFm3Wi6Oyy8Xov0WQC+RSpn2Vr881i6OyyWVOqwW51DdBLpBL" +
    "8fnEVUSb2s3jCHIxfBLd1kohHxawNQV0y6By/MOabB3mcFhfDHy3vOcjRCuf" +
    "sB93TmJ7WB57D8dkq0q++yAXyAWE8seXEl1zm7u4g1wgF8ilhPsqX6gj2tjm" +
    "Nu6KLpfpzZAL5ALe4j++RrT+V8nEXdHlYu29RfcOEm0ZErCPY0iPzfv8KJ0n" +
    "y3NfNJv3KeQryWMzD5+eCSH1hRTs7KvMfzBmXOnG5T5L8S7Jg4/FLS4Q1Mua" +
    "XG7rh1wgl3wugb57vaW4glze4gGbL6Jnz3SBXCCXPHFFHdHdrfF+nSEXcb5s" +
    "smFNLtd1Qi6QSz74188S3bLTztQfchHnq/IUulC58IKZ3UL04N4gDw3pEUhj" +
    "yI/KOdp5KPAQj4MyPKSJdx6EocZfv4do3oMh/SHAep8PyeM5bkyo5hunDCrj" +
    "hX8sSyy5TG2EXCCX7O6rXDnHYOBDLsZyYZMNmViU5cKAXCCXrPH5OqI7Ww0H" +
    "PuRiLJdpzZblckc/5AK5ZIN3f4Toxp3RcQO5uJOLypJISy439hDdvzeDDHLo" +
    "fm/AAxyBPATw5zww6CcsL8jkIn/0dqIpGxTa2yRuNOMoEAMqcZJA7KqUS+d8" +
    "Pr5v63Mgl6UdkAvkkg6//ftEn5sQQwyQizW53NprQS78y9EWtUMukEvy/NuV" +
    "lSV5S0wxQC7W5MImGbHlws9eZrVALpBLcrzrw0TLHrMkBsjFmlwWtckfb6kt" +
    "F8amQT3u5dA9XumcAT+beCzkEbfe94rKKUtnrPxl3Ff59oqYbZcATmJIErs2" +
    "ymUSl7XHz1S8DK0tl7sHIBfIxd2+ymcnEN3WYqHtIBdncqlrcCSXtT2QC+Ri" +
    "n49dSbTmuXgDAHJxL5c79qjvt2jLZUkH5AK52OOv3k006wE7AwBycS+X6zot" +
    "yoX/D8E1TZAL5GJnCfSdFRrtB7lkQi5zuSvIVzfFkIto9vL9ytTongExGyXc" +
    "M+hno8E5YXmrlkEpD0k5ZXkKy2ZYj6KJ5TMTiDY0S9oqJhsHOQYs9aFu3HHl" +
    "iF0vC+U0qbf3nc5+i5Fc2GscIRfIRZcPfobohl/aHxyQSzJyWd+ntyQyksuC" +
    "NsgFctG7tDzjfnuDGHJJRy7LOx3IhRfMlEbIBXJR21f50iz7gxhySUcuuvst" +
    "RnJhbKhMke7ao8CABIM02J5PLUZppoFuOceOy6NYPj2B6JZmi/0hazsbceai" +
    "DK5jxMYYHFBrP939FmO5rOiEXCCXIO/8MNHCRzMysCEXa3K5uVd/SWQsl/lt" +
    "kAvkcpE/fDvRhPUZG9iQizW5LOtwKBfRvgvkArmwfRW2BMrkwIZcrMllRrP6" +
    "nxVjy4XBnutwZz/HHj/s6XW1SI834E4LSPPh6mFShkAakrbxPs+qWC77KtFN" +
    "TYK2kPSxEiFt8VZbSY5X6V9p/8iOl9W7P349VfKQto1uuQXnmMxaYsmF/RUA" +
    "cimfXNi+yjX3xQtWyCU/clF9jUgsubBLT/ylKMilPHJh+ypfv87OLyHkkh+5" +
    "zG9LQC5KSyPIpXByYfsqnxpfXQLZmmZDLvmQC3uzIn8Jmt1Ml4hcFrZVC6BM" +
    "n5/b+/2onKP7vUoet0uQlsFG3UPySFMsH/g00bId0fVS6sO06bPUh5rEbRtp" +
    "jPRZiEOO2mOXdZrPWrTlwj9Xd3Ij5FJEuVz6bqL6+5IZQJBLduUyqyVBuYhm" +
    "L6u6IZeiyIUtga5anuwAglyyKRfTG+esyoX95wByyb9cPjmeaG1j8gMIcsmm" +
    "XBZ3pCAX/t+RbMOH/dco1/RyZKhMrqXy9x8iWvIL9XKt58hC/6w3QDdNk3Kn" +
    "0laWqG/S/6NibLmEvTANcsmXXP6Avb1wU04GDOSSKGu6489arMmFvW4AcsmH" +
    "XH7r94m+MDNnAwZySZQFbSnKJexd0pBLtuXy4a8QrW7I4YCBXBKFXQU2+S+R" +
    "M7mwN7Hd2ufnFp5eP7fy9MmRpSHNQ+GcAJJ6BPJUKLdqPWztq8zcbtY2um0X" +
    "93sVpGVS6C/dcpjk4SJWZeWI2/7LO+3MWmLJhf87wOQGyCVrcmH7Kt+52XyQ" +
    "Qi7lk8uc1gzIRTR7YdaDXNKXC9tX+cS4+IMUcimXXGxt5DqRy7RmyCVtubB9" +
    "lcXPmA0YyKXccpndkiG5iARzfRfkkoZc2L7K5HvjDRjIpbxyEc1aTDdyncmF" +
    "vZXxpp4Qejl6HCDLo9egHL0SdI/XqLvKvsqXl1lqT5Uyxm07k7aKS09GsVFu" +
    "S3W1PWuxIheRYNg7ZSEX93L593GVmeJui+0JuZRSLqsdzFqcySV09gK5WJHL" +
    "+z9FtPAZB+0JuZRSLvNa7c9arMlFefYCucSSy1++i2jixhj1gFwgF451FSbs" +
    "jv8/okTlwp4Fsa5Hk+4ga3v86H6vXQaVNPgy8PQIyqVQV1Ga3qXlz82Ql3tt" +
    "TFTaRqWukXDnq9RDVgaTMsraXzcm1nYnQI/98TDH0azFqlxEU6sbuiGXuHL5" +
    "+HeJlr+kOPAhF8hFYzyscThrsSoXK7MXyCU0TcgFcrEtl7kOZy3W5RJ79gK5" +
    "QC6QSyJycT1rsS4X4V27lQKv6Rqj28/qLj9rBPDHsMtmUQTykHy/RuGcAJpl" +
    "Mj5HJ70u/brayMOkfbXK0K0QN7I0uxTQjCOVNE3qqtsfpn3q4r4W53IRzV6u" +
    "bYNcIBfIJStyWSH453Mu5CKavUxqIFoFuUAukEsm5MI/0cCFWJzJRSSYOS2Q" +
    "C+QCuaQtl2vb3NyNm6pcvBvr2LtnC0cnh4M8VnLkJQ+TNPNaV9txxJdxZWcQ" +
    "nfTZn4r5TVxXsxanchEJhj1RHHKBXCCXdOQyqyU5sTiXi2hzl70CFnKBXCCX" +
    "ZOWytCOZTdzE5CKavUxsqE7PIBfIBXJJTi71TcmKJRG5hL2KhF0Ou76LozPI" +
    "Cp4ujk49VPLQLYP0+E61YyLLybWVat1i5ekijS59dPtYKUa69DDpD91Yvd4A" +
    "lfYQ3YnrahM3dbkwFrdDLpAL5OJaLuy51klu4iYuF5FgpjZCLpAL5OJaLjNb" +
    "0hFLonIRbe6yikMukAvk4kYu8wX3tNj+/1Am5BK2PGKvjlzeEUEnh+73KnRq" +
    "YpAHu8enliTydNJWmmlex6FSBuk5HIHjVfpDdo5uW4nKxfd53NhWwMtrSUd6" +
    "y6FU5CISDGuApZAL5AK5WJUL/0pW771ihZaL6HWRbP8FcoFcIBc7cpnRku5y" +
    "KDW5iF4Fy5jRDLlALpBLXLmI9lmSXg6lKhet/RfIBXKBXJRYnIF9lkzIRSSY" +
    "8ZWGWdJOtLSWjmjY8bUEjmlXQHZOR3yWcGiXQaVM3DFLJMjSFJ7H18NGueP2" +
    "sYs0+bbsiMZJnrL+4mCPNkl7nyUzchFdnp7SCLlALpCLrlymN2djnyUzcglb" +
    "HrGGglwgF8hFTS5zW7Kzz5IpuYQJZn4r5AK5QC4yubCHP43fnT2xZEYuYfsv" +
    "89qqjeejPZrFEoTntUmQHd+uj1K5NI/XrrtuvS2UU7feRrTp1023rRZz2Ohj" +
    "aRn5PNuyt8+SSbmI9l+YYBZBLpAL5BKQS5hY0t5nyaRcwu5/YQ24CHKBXCAX" +
    "X35TG7O5z5JZuYTtv/gEA7lALiWXi+hHOGtiyaRcwgTDLlGzR2S6YAFHEucv" +
    "kLAwAcqSZ2FoJapvzIdYMiuXMMGwR/VBLpBLWZnRnB+xZFouSQoGcoFcIJaS" +
    "ySVMMKyhIRfIpSzMDLlJLiuXnHMrlzDBTGuuPmR4Psc8Dtn3JujmKYLdw+ND" +
    "li93/HwLdZtvQNy2cFEGaZptAnTTjHm+EZV8ZrWKb5LLulhyI5flIS/OZoKB" +
    "XCCXosolTCxZupcl93KJEsz0ZsgFcimeXNgPZ57Fkiu5hN1k5z3JDnKBXIoi" +
    "l2khm7d5Ekvu5BIlGHYfzJwWAa0cLQrIznGRpuz4JPLULUOrozLELbcC7EVh" +
    "tcjynCvBVrnC4jtvYsmlXKKWSJMbiGZDLpBLTuUypbE4YsmtXKIEU8cLBnKB" +
    "XHIglzCxJPHaVchF4zK1TzCQC+SSYbmwOBX9uzkvl5sLLZcwwbCddnYlaRbH" +
    "TAGzZLRw8Gm2yJklIVAmSZ7CdFSOiVMGgzxlaSr1h26aFvrDRtvI8mSf1RVU" +
    "LIWRS5RgpjVBLpBL9uTCfvjCxFKUMVkYuYQJxruSBLlALlmRC9ugFd3DUiSx" +
    "FE4uUYKZ2CAOZMgFcklKLozJIRu3RRNLIeUSdS8M+7W4pglygVySl8u0iGVQ" +
    "EcVSWLmEPZP3rfthGqtrXo8ZHNMl6B7/5jlNfqbzyPKQHD/doNyyeswwKUeT" +
    "BIXjpeXi2nJGsz7Scmj2eaBMNWmwO8jH7S7WPSyllotsmcR+RSAXyMW1XCZF" +
    "zFaKcEWo1HKJEgz7Nbm6CXKBXOzLhS2/J+wu1zKolHJRWSZBLpCLLbmUdRlU" +
    "WrmoLJPqx35xANCmIpSrK9TtLu8yqPRyibqa5L3GBIMF6MLiZlzJl0GQi+SP" +
    "j94la3bjHQYNkMGWQFF7K2VaBkEuisskb6l0NQYQCGFixJWgss5WIBeNzV7v" +
    "7l72C+VRz9Mkp/Z8FaR5NMrRzkPhfFk5dPOoV6irtB4Gba1d96aLTGyMXgKV" +
    "ebYCuRjMYthSaVID5FJmuUyJ+E8QZiuQS2zJsPX1VMildHKRLYHKdiUIcnG4" +
    "VKqrncVALoWUC9vUr2vAEghySWEW481k2HJpsiZTOHSPn9KogCyPxmimKJQz" +
    "8D2fjkHbyMplPT0BEyQzFSyBIJfEJDNeUzKQSzbloiKVPD/XFnLJ6VJJRzKQ" +
    "S3bkMklRKlgCQS6ZkcxEyCXTcmFSkV39gVQgl8xKhm0GThgTjQ51EibuVqDB" +
    "AZI8AuXUPF/5GJ0ycrD+UJEKlj+QSy72ZLzZzATIJRW51CkKBVKBXHItmXFj" +
    "gV4HuTiVS93YLGUcpAK5lE0yUcsmyMW8HjpCwSVlyKWQj3cIiIYtndi9M2NL" +
    "qCgmCBi/y0/ge1kau/zIyjBecI4sT6U0JYSdpyMUSAVyKeVsxpvRjINcIuUy" +
    "DkKBXID6s2RUZVM2uZjOTrCXArngcraBbPjBWDS5mMoE96ZALiDG/kzYns24" +
    "2r2bnMhlHEecNkAcQS7A8h5NWUGcQC4AsrECnpsCuYAMbgpDJgByAYlvEKcN" +
    "NmAhF4BlFfZIAOQC3CzBcN8IgFwAAJALAAByAQAAyAUAkA7/DyEJI2izD+5Y" +
    "AAAAAElFTkSuQmCC")

RUN_ROLLOVER = ("data:image/png;base64," +
    "iVBORw0KGgoAAAANSUhEUgAAARcAAAEXCAYAAACH0wDUAAAkX0lEQVR42u2d" +
    "efxXU/7HZzDMwpjxm8EMxozxwzA7yVpRpE2pKNkaIYSyb42t7BqNJllCCFFk" +
    "KzspRWMpsmT0U4TGbmzDb36Px/v3fbt98v2ce+59n3PuufvrPB6vfz733rOf" +
    "5+ec99m+8RTRNyAIgnwLmQBBEOACQRDgAkEQ4IJMqJvOm0B04pivdcjZRJ0O" +
    "b9ZGPVte3FLWD3cKf7vnic3+s5DvgAtUEd3yQNCouaFzgzcBRVbact+vAXT5" +
    "bQAP4AIVuhdi09soqhq9IPR2ABcoJ5jwvz43xDKDxEYN4KD8ARfIo3jYkCZM" +
    "ttyHqONhzTrhr2Hd9/jX0j1X/WCl1bvh/GDIon4ALpAlTNjA6muIw/aNBjDO" +
    "uboFDnOI3v2A6D//0ej/HGToB0Np3JQgHn1PCOIF2AAuUAZDnSSNjRvYzocS" +
    "DRpBdNxooumzieY8R/TvLy31hSKTd0y+idFLi4P4crxZnI4kvTSGMkADuNR+" +
    "Nof/cV1h0ud4opFXtTTOV90bdhHgEgedsbcEwPzF7u62GsxGAS61EQ95bP+Z" +
    "W8NkRY8kjYZdILjEwcalZ8P5zkBHHQRcKiWe6bC1ofDwoAkmJo28wnBRxfnC" +
    "+cPQtYENlwNmngCX0htmbRav/bAD0YFnEl03jeiTzwz0eVifKgq9I/j5qSJd" +
    "GKKfwvtqGJ/q4m3pJ2vWPKJj/hLko42xG/YZwKVUULHppexxHNElk4iWvm0I" +
    "FcBFFAOaQW0z7ERvBnAp9IyPKVT+MIDorCuJFiyyBArgYhUnBjaDe6fBgAzg" +
    "UlJ7ismY/xc9gm77Y/OWN9ykAlzM4/RZAHLOfy4HQAZwqQRUGnaUUMMFXDKF" +
    "S2uxfcZ02MSzTKjvgEuhoDLwDKL5LxN9+HFK+kQj4ZuPFHkJ9+MCSIpTRF5x" +
    "+QwbRfSDDoAM4JIzVEz+6VKHCuDiDS4NLXkLkAFcclpJKxlquVJy5cwEKoCL" +
    "d7jYQoZ7rpjCBlwSSVqn0oAKV8rcGxTgkhgurSFzxuVEP+8hr5NBOwFcvA6B" +
    "GCpHXUi0aCnRux9CRdN7HzUriV+jJsqQwcwS4GIkaQgEqNQLLg2ddln8cImH" +
    "StgkCbhoJe1Qbn9IS8V5EQ23rnBh8Z/K/qfLO7HRngAXo6ll/re66g40WMDl" +
    "a936EIZKgIsg6YCmIy4gWriEaNl7FdG7grII873qiOtH3FCJh9iASw2nl+N6" +
    "K+0ODo5lrFJDAFzS0dzniXocHf8nVddpa8wEKUOgC6+rIFQAl9TFf1gbdo+u" +
    "W2zTA1xqOgw64vyWIdDiajcAwCWboRKGSTWCS9wwiHsrl90abM/3pn9qZPJO" +
    "3PtpKIU4vKFIDNP1nSRx0ITxhiLrOLR6d/pj8b2YugyTaj0M+m1/ojnPZtRo" +
    "AZfawIX1/CKi7sPqPUyq7TBoyHlC5QNcAJcEcGl8c8rY+g6TajsMEisf4AK4" +
    "eIALi+9lquMwqZJn2EYV4m/6Ec2cR7T4LUVvKnpLkPL+EkW6b5aoMvgm7vvF" +
    "GWiJSbhS3tnmrQ+9aSDLeIbKyyRdrZ4/+w+ibkPrdZRD5e4Eiiq8w861qIyA" +
    "C+DiGS6Nd+JsgFUDTOXBsmZ7orGTLSsj4AK4pAQX1l2ziH7WrfrHOFR602Hk" +
    "MAhwAVxyhAvr2VeC+lllwFR2RujXexE9/RLRoteb9YpGvNu1tULvLFX0uoOW" +
    "Cno9udR0iGkX4hDyzyTetula6uGbFMJImndG77T81v+U6s4kVRIsXY4KwGJU" +
    "SQAXwCVHuMQBhmc8AZccFDXV3P9ky0oCuAAuOcOFNfic6gGm0mABXACXssCF" +
    "NfKq6JmkMp5yVxmwjBzvWEkAF8ClIHCpGmAqARa+d5l3NLNekrREo8XZa6Ei" +
    "2+dZxMHFD1s/+TCukGzjlUN5LvSQ9ihNeShYQlF2wJQaLFwAo29MWBEBF8Cl" +
    "YHCRAAO4pHwiP2c8F0Diigi4AC4FhEsDMFvsVV4jbymnmxtgcWoggAvgUhK4" +
    "xPVgygCYUq5jOf1yogWLctQrigy+eV6R9FzSgoroeQ9pzyJvfIThms6bH9AD" +
    "pugL7Uq3Vyh3sAAugEvGcGkApmxbBUoFlqNHFaRRAC6AS8ZwYfEfa5kAU5pj" +
    "KXlzomlDBlwAlyrCJQ4wRTyuoRQHPfU5gWjey4Hmq1rYrMZ7kVqoke03L3tQ" +
    "CnGYL8g2jmrefiXBz9DzhYIc0uo7nSZxkOrZ/IUOddFRfzqzHIAp1NGUugzb" +
    "ZqBQsQAXwKVmcGHxH27Rj8ws9CK5zfckmvkM4AK4AC42gAFchClnHVgAF8AF" +
    "cGnW5n2LO0VdSAPu99sRXT+N6MkXNHqxWU+90Cz1uYtCfgpxkL53iVfSOHwl" +
    "229eMJDwzVMvNstHeYl+qlLzX+eHS35axMkoP23rpsaPh1sa0fpdinkvUiHt" +
    "LHzXi2mBAC6AS53hwr9fP72Y9pfC2Vl6H2dXIIAL4FJ3uLCOvKB49pdC2Vl+" +
    "1TJ+fPhJwAVwAVxs4cLqdHix7C+FsrNMuIvoieea9XhSLTCQ8k0oDgs8SA1j" +
    "QbOk932kS0xnGpLi5BJvNe8s39flt1jmLnUki7xqpfvnEq1XIPtLPkTTdN9O" +
    "GhMuMMAFcAFc7Mqc/6CLYn8phJ2l17H6AgZcABfAxb7Mh5xXDPtLpoHpxoSb" +
    "9Qm6c4AL4AK4+IELq+Oh+dtfct03tEY7ovF3EM2av1zzZD2maFYamt8sKczH" +
    "5isyiacShpd0WsZbikMmmm8Qb/W5okzSlUNeSfkwKybt0+cQ/XS3cJtje2fl" +
    "4KIbDh1/iX2BAS6AC+Aiw4XFf9x5Do9yO59lp8FuBQa4AC6AixlcWPsMD7c9" +
    "Nk9UBi664RCfrAW4AC6AS7pw4d90w6MsrijJZbEc09S1wAAXwAVwsYPLxTfm" +
    "c8B3qp7z3LqaqE17E814KtAjBdEMRbbPpfdneIjDIxn5kXYYWcSxKOkoUh3o" +
    "cEj2xt3MjbijJgIugAvgknUduPHewByRpXE3UyNuj6OLUbEAF8ClbnBhDTg1" +
    "28O9MzXi3j0TcAFcAJc864DOuJvW1oDMrl89eATRA08omuugJwQ5fP+gosRx" +
    "ckjXg4q85M3chNLl1dx42fpp4oeXvEma/w71znu8DcpD8uOCa7Mz7may43mT" +
    "PZY3WsAFcAFccoULq9vQbG4OyMSIO24y4AK4AC5FgcvUR4jW2DF9427qvZb+" +
    "J7dqtIAL4AK45A4X1kEj0u+9pNprYTpOfojonjkRmq1ojn/dqygU5mz7eNw7" +
    "u1n3uChpvOfYxzPkp5QulzwX0m1UHpZ+WueDQ/nY5t29KdVn63oTk5c/6Zxu" +
    "7yXVXc9dj7KsiIAL4AK4ZAaXoy5Mt/eS6gzRNXcBLknhsuw9okefBlwAF/9w" +
    "Sbv3kl+vBXAxinfD/c/SYIwNuAAuPuFy4FnpbQtIrdcyfirRXbMUzYzX3RrZ" +
    "fhN6R4nD3TpZhhmKwyxZ0jdRz1u7L/9D9OJiTb4a5q+Ydy7+JYxDZFpal5ka" +
    "V8u8domHGKZlnO52SJdTOizLZ9J9RKvvmM66l1R6Lbsd6VbxAJd4uDTch58E" +
    "RxoCLoCLj/Lpe0I6vZf0ei2AS2pwabg33yV66EnABXBJVj5p9V68X8e6otcC" +
    "uKQOl4Z7ZWnL+PpxwAVwcS+fNHov3k/zP+tKottnBOKVgL51u6DQ+zOalUWY" +
    "U2doJPgZFbap+/J/ieYtVPwU4uASp9A7tmE4lId1/huUR8gfIV6J4/CIn/z3" +
    "Ha/GezdM99978brz+Xd7J2/IgIsbXBru7feJZs8HXAAXO7iw+hzvd8e01/Na" +
    "WvdaAJd84NJwi98kuu8JwAVwMf/+8lv9nveSWq8FcMkXLo2h0suvtYzfHwNc" +
    "ABez7zsP8beoztv086HnEE1+MF5TFE1OQWIYD2lk6ccUQT7j7cN98nlwC18a" +
    "5WObV2n4mUZ55FGXs4i3pPOv82fY9WbIvfYuwKWocGm4f74f7IgFXACXSLW0" +
    "h3V29XMNrJch0S6Hm2UG4JIvXFZsJXgj6PoDLoCLrn30Oi7ceeBlJ6nDRXdd" +
    "yLEXAy5lgkvDHvPSYsAFcAm3j7GT/eyWTrwil+fGTTMDcCkOXFrbY3jXNeAC" +
    "uLRuH7/tn9ywm3hI1POYYPkw6yZBkxTdlMI30vuTHONhpXs1MnmnlRpxy8rx" +
    "0Q53zrTPK9/PXfwQ8zoFmdShpPXMJQxf7eXgkcmvgE28tuXcawCXKsCl4V54" +
    "teVf8yHApe5wGX9H8gvsEx1judHufhs+4JI/XBr2mL+/ALjUGS6sjoclGxol" +
    "2qTIN7gBLtWDS8O9/y+iR54EXOoKl2Gjkm0HMIbLnieGA/rLDUTXT4/WREXX" +
    "TxM03b8mTmuWUbjK84nTBbmEIeRVQ0VwS94imvqwQfm5pHuaRmq9SappcpmK" +
    "9cah/GzrkWmd8Jk3Ujq/t4P7mhdnQ27bA+wzHHApJ1wa7vlFRDffB7jUCS58" +
    "v7vr0MgZLnz2JuBSL7iw+/izYCsB4FIPuIwY7z40cr7sTBoSAS7VhEvDvfVu" +
    "cGA44FJtuOiGRmwi8QYXdS/R2p2IJtwZFl8l0lqh54omGEj1U5L4vSYetmFI" +
    "6TD5JuTHXc1qfFd0t3BJsPhKSl9kuj2UuUsYUt20rctGZWobhkE6o+qNad6Y" +
    "aOv93Q6RchoS8UXWgAvg0nBffEn03CuAS1XhstdJbnYXpynoIecBLoCLxh7z" +
    "aTB1DbhUCy5nXOFmd3Gyt1x6C+ACuMTcSvAO0Z2PAi5VgQv762J3EeHCx9y1" +
    "9nTD7kRXTtVrvKArb4+X9hshjNDz25tlFEfhG9s4+FSZ3fyXia6dJpS7S74I" +
    "9UZ6/8rbsylT27rsFAepDUl127ANtjvY3u5ibW/pciTgArjY2WPmPg+4lB0u" +
    "+51mb3extrfwcZaAC+Bi6/71KdG02YBLWeHCG5Rtj7+0trf89SbABXBxd2+8" +
    "TTTpfsClbHBh/biT3S5pa3vLuFtbaUq8LlMkvn+rRlPiNc5Wt4YV8vPW+HT6" +
    "iJPpN1V1zywkuuoOs/xLXOYeysP2+WVT/LePcVOS18XLEmjHg+yGRlb2ls5H" +
    "AC6Ai197DJ+CB7iUAy77Dk8RLkNHAS6Ai3/3zgfBfcWAS7HhMnK8nd3Fyt4i" +
    "NTrABXBJ4hYtJbrhHsClqHBhqetdvMDlu9sT/e3mZo1R5Pu57h1b/W1Ss8YY" +
    "hhsnMUyPeVE39++WodJTLxJd0QL1MZOWK2kdcClDod78LQWlkg6HNhenzfqY" +
    "G3WNNyuyp4AL4JKV++gToof/DrgUDS67DjFfTGd8Xi57CrgALlm715cFdxoD" +
    "LsWES5xR19iYC7gALnm6BYtahkq3AS55w+XIC1KAC3sKuAAuRbDHAC75weXM" +
    "K8zvMzJe9n/cxUSjb4zXxapuaJb0/mgX3aBIipNJuIqfF9+YXGLaI9IBp7fH" +
    "TJvVKi+lenaD/Tu29cikbobiYVv/b7D3U5SQbp1Mp6ONp6FNAgVcAJcs3WvL" +
    "iK6+A3DJGi4bdDU7fsHoGhH2DHABXIrq+AK3SycDLlnB5fd7N/OBtwkZw0Wd" +
    "ht60N+ACuBTfHjNrHuCSBVxMb2I0MubufCjRRdcZ6HpFlu9feJ29pDCM/Lm+" +
    "WRcJulCQU1pVf5b/DmfnPvyYiG2GUr2S6olYB6Tyc6g3RvVIanNSG3SIk+pH" +
    "3xM9woU9A1wAlzI5vpWAjwkAXPzD5ZBzPMJl8DmAC+BSTsen4F0yCXDxCRf+" +
    "zWTGyAgufOsa4AK4lNYe8wXRfY8DLrnDRbfG5bxrgmPuQpoQL/4usSY0KxTO" +
    "NXbShWHyTtz7oe8nyArllfp8uV9w/tyy94huus+tbop136Ee2NbVc69JXt/P" +
    "9aEJjnDRrXEBXACXKrl5LxONmwy4JIHLxnsALoALXORQ6fHngulXwCU5XHQL" +
    "6QAXwKX2U9f3zAZcksJFd66LCJf1uhCNuCo44k7SCEXS8zw08iqNLNPhIs7D" +
    "JhmGAZeNe/WN4KR717qcZZ2waVNJ3x+paTP83i97eoDLL3sBLoBLfdzTLwUz" +
    "IoBLCnBRl/4DLoBL3dznXxDNng+4xMGl3UGAC+AC5+w++BfRxOmAiwlcdMdd" +
    "ynBp6f6ccTnR6Q46w1I+wrB9frqHeLiEYRomXP6ObyXgDXunX55MPuqq7zbm" +
    "2i53GCRvARDhwp4ALoALXLDrmmdLABdHuGzUE3ABXODi7DH3PwG4OMFF/QBw" +
    "AVzgwu7Nd4iuvbu+cNn/NA9w2e5AouGXEp3qoOGCfPgxfKyiS5MrFI+xzQq9" +
    "LzwfnsAPuGK7q++Mqb8G9SKu3hnVbeGdtNrkPsMBF8AFLhXHV51cNFGov4BL" +
    "8w98HibgArjA6d0b7wi9lZrAhbmQeLboj/sALoALHBtyp86wbAOASzxcNtod" +
    "cAFc6u0efSZY5GbdBgCXeLj8vAfRSZcE5zWoOknVJc2S3hf90/mpaky8JP9O" +
    "MvFD/cYlHZbfNNIHl5/7x2tE508IysG6Xl5iXsYNiXXkErkuSvES6/4lBmp5" +
    "b5uBSiekJ+ACuMCJ7r2PgsO94xo+4OJhVzTgArjUxX32b6Lps/WNDHBpThdz" +
    "ITFcftABcAFcqu+eWEB0xhXRjQxwSQEurGMvDi6iFzW6WfxdnELv66R+YxkH" +
    "9bk2HpY6dnS8jhttkDY1HhF+wKXrXn4tuHlQrKtSnfAgqc4cZ6IU2kcoHi2/" +
    "bdgdcAFc4CLtKtdOiykPwMUKLoecDbgALrCr0MNPEg0fJ5QH4BILl3V39XRv" +
    "EeACuFTB8Wn/51xtWB6ASyxcvN24+KcziYZeFNawUc0KPVcU8mOUootkP0Q/" +
    "pTBGyeGq6bJNxzAXRYQBl9zxvdFjb4mvJ7ZlHqqLJmUq1Tupro+y90NqHybv" +
    "6+LiDS69jwdcAJdyDoEm3W9QRwAXK7gcdq7m+qEJjnDhM10AF8ClTO6BucHU" +
    "rAlYABc7uPQ5Xl76bwyXrfYDXACXcrh5C4nOutIcKoCLPVxMTqGLhIu6BWCD" +
    "rkRDzg/rCEsNEWTyTeidC5o15Hx72cbbJZ2ueQVn5l5bRjRmkr/ySKPMk9YJ" +
    "H23K9rlO6rEsVnDhOevWH67ZHnABXIprV7l9hv/yAFyixZ0NaQFdJFx0a10A" +
    "F8ClaO6+x4Pp1DTKA3CJ1tq7yJfQR8JFt9Zlr5MAF8ClGO6lxUSnXZZueQAu" +
    "0TKZho6Ei86ou+sQokPPiddgQbbvm3xj+/zQNPw8u1mDHeIR9T7c1+6dD4iu" +
    "uK2Y9cqlzNV646Muu+SFGEarOPbVzBRxZyQRXP4wAHABXPJxn35OdO+cZA0d" +
    "cPEDlx7DzIy5sXBRL0fbfE/ABXDJ3s18huiYvyRv6ICLH7hwJyMxXNTp6PW7" +
    "Ai6AS3buxVeJzr7aX0MHXPzAZfO+8vGWIlx0M0aDzmrWQSMUndWsQSPiZfv+" +
    "oBHhMENxUiW8r01HQmnjroYrpKsR/zraVfgmQ5u881Getn4Yva/Wb+Ebp3QI" +
    "bUismwZhtn5/vS5m09CxcOG9Aipc9vsz4AK4pGdX4SMmj7rQPu8Al+zgstq2" +
    "ZjNFsXDRGXV3PhRwAVz8u0efDvYBmTYAwCUfuOx1stmGRSe4/K4/4AK4+HNL" +
    "3iIaNdG+AQAu+cClzf7mxlwRLuoegh91BFwAFz9DoOvutsg/wKUQcPnF7s08" +
    "+OFOCeCiM+rufQrRAacv1xnNGnh6vELvG0j9ZkXYUXFQpcbDJAzBTzUOtv7p" +
    "8irqedXc3bOIDj8vOi91EuuVUB4mZS76afl8oEu9kPLBoH4njXdcuKq9JWrZ" +
    "vxFcdEOjbf8EuAAu9m7u88E+ICkvAZdiwqXH0Xb2Fie4bNIbcAFczN3b7xOd" +
    "f21MXgEupYALn+lkY28xgou6mG6NdoAL4GJmV7n5foO8AlxKARf1EjTJ3mIE" +
    "F53dpdexRPsOJ9pH0b6K9vlzvELv66R+p4b552ZJcTLRPoJs39elQ4zH8vSU" +
    "0d05k+jgs83K2Kg8pHpjWc9c4iH6+WcPdTGFuqyLV5yi8m+1bezsLUZw0Q2N" +
    "tjkAcAFcwm7BIqJTx9mVMeBSfLh0PSrcwbj8tpTg8t97AC6AS7Nd5a+T3MoY" +
    "cCk+XP44wN7eYgyXkN1lR8AFcAnsKjwESlLGgEvx4fKTzuabFa3hottn1H0Y" +
    "Uf+T49VPke37/Vz8PEXRycnjGYrXKc3q75g2k7wpqntwLtGgMx3KI4XySaMO" +
    "SGVsFCfLeLjUEes2JtVdTRmpbV93L7QzXLRbAfYGXOoIl+deIRo5PkF5AC6l" +
    "gsv2g9zsLVZw4amn1gGstRPgUie4/PN9oiumeigPwKVUcNm4l5u9xQou6nUj" +
    "rB7DAJeqw+WTz4numBHsO+l/CuBSJ7j0OYFoVWUKmvcbeoeLbmi0WR+ividE" +
    "q4+ivh7UR5DL97bfZJnOPN3sZ4kOO89v2kzyqo+lsihz2zrQJ6e6K4ZxfLxa" +
    "v/vHfe2X/DvDRT1Xd/UdAJcqwmXRUqIzr3DLK8ClOnBZv6v7kMgaLrrVuu0O" +
    "BlyqApdPPiO6bEqyvAJcqgGX3TQL50xW5TrDRTc02mh3wKUKcLntkWAfSdK8" +
    "AlyqAZff9DO/n8gbXNQDpNjg0/PYQL0s1fOYZvU6NicdI0iNtyCfcUrbzX+Z" +
    "aPDIIKyeBmkLlZmQV6mUj2V5qHHueYxc5mLdVN93qBdp1puk5fGDDvYbFRPD" +
    "Rbeg7vcDAJeywWXZe0SnjbNvIIBL9eHSYbD7wrlEcNENjfi6AcClHHBhuwpf" +
    "3dHTsYEALtWHyyZ7JDPkJoILG3bUwHcZArgUHS73Pk40YHireAIugItG39vB" +
    "bS+RF7iwYUeFy6/6BvuNWqubou5DBQ3zoKH+JaYjhXh3Wy4fbt5CoqEXOqTd" +
    "IN6hvFGfD22WU/7b+mFSJ6R3hqWgpHUxg/zfUrO2Je5uIu9w0W0HYNoBLsWC" +
    "y7J3ic69JkHDBlxqB5cNu/sZEiWCi247AFMPcMkfLmxXmfyAh4YNuNQKLjtr" +
    "DLlx17WmBhedYffHnQCXvOFyz+xgH5BTowRcag2XDbu574D2Dhf1EKmvjsAc" +
    "CLjkARe2q5w6NmGjBFxqCxddr8XVkOsFLrreC9/KuNsRgTor2u1IRUekoCMd" +
    "JPjZ+chmqd+r6VTfN/kmFOZySe6td4lG37Q8DCkdUphqvI8wSFtCP03KR8xL" +
    "2/JxqFedBbl8o6snTekw8U8qM0M/N+jqt9fiBS663kub/QCXLODCV3fwUu2o" +
    "igO4AC4mfvL+QN+9Fi9wieu9AC7pwGXmM8E9N1LFAVwAFxM/N9o92dEKqcIl" +
    "qvcCuPiFyz9eIzppTESjBVwAFwe4dDyM6Fttk+8jSg0uukV163cJprGadJi9" +
    "Oh7erNBzRaKfhzvES3hfjYMa544OaW/4xe7jz4iunGr+TVw84tTJQGIYls9N" +
    "0uGadz7LQ6oTHQ/LR0nzTr1JMcmiuVTgojtIisWH+wIuyeBy033B0nBfjQpw" +
    "AVwa6nBIer0Wr3Bhy7LYewFcnBsI4AK4+IZLmr0Wr3Ax6r0ALoAL4FIIuKTd" +
    "a/EOF13vZe1OQUJc1V5QhwLIJU5J01WUvEgaBx9pL0I60ygPH/5F+fGzbun2" +
    "WrzDJar3ssWegAvgArgUBS68il5to0k2KGYGF13v5TvbEe0wCHABXACXIsBl" +
    "rZ3S77WkApeodS/cDQNcABfAJV+48CgijdW4mcFFt2qXtdW+LT2YA1tpUEV0" +
    "oIGUb7Y/sFlSGNsrMomX7TcuYYh+WqYzrXiIYQjlJT5Pod6ocVTzcnvLePBw" +
    "aJW2yU/1zx0uujuO+ERxwAVwAVzygYvukrMk57XkBpco4y5fAQu4AC6AS7Zw" +
    "4Rs6sjDiZgYX3baAb2/X0j07AHABXACXLOGi3kOUlhE3M7hEGXd/uhtR24HB" +
    "GLBJB4TVVpH6TVtFIT8GJldbQbp4S/EQ/XSIk/U3Qt6apEv0Iwe1dchfMS+l" +
    "euVQ5l7SalCGul3PaRlxM4VLlHH31/0AF8AFcEkbLnw6wSpbZzscyhQuOuPu" +
    "mu0BF8AFcEkbLuvtlvxC+ULDJcq4ywkHXAAXwCUduOhuTvS9f6gQcIkaHm3a" +
    "O1j/wtpSo632U7SvIuV56HsTqX4oksIwClMIQwrTJR1iuvb1IMt4OsVhP0v5" +
    "SIdlvXOKl23dNqkny/Xb/vrhUNpG3NzgorvriDPgDwMAF8AFcPEJF/VK1sa9" +
    "Ypl2JrIMjKW7LvL77QAXwAVw8QWXn3TOdziUG1x0V8GyOEMAF8AFcEkGl1/2" +
    "1C+WS2uJf+HgwieL6zJgk96AC+ACuLjCpQh2ltzhwuLpMJ395Tf9iH6/dysN" +
    "ULS3INv3Tb5x8TOPMAT9TpGXdKQRb8XPULwHJJd1XqjfK0olTEt9d/v87SyF" +
    "gEvU9PQa7QAXwAVwsdU6uxTDzlIYuERNT3NGAS6AC+BiJt1B23nZWQoFlyj7" +
    "y8Y9ARfABXCRtHnfYtlZCgWXKPvLylsHgPn1Xn61hUa234jh9NPINq7C91v0" +
    "Cyupn17CSJp3OfmZhbYQZOsfg4WPkC2SnaVwcImyvzBgOAMBF8AFcDEDS952" +
    "lkLCJWr9C2egT8AALoBLFeDCG3+LaGcpLFx0Nwf4BgzgAriUHS660/tZ3H6K" +
    "1J4LBZc4wPAWAT4iU1RvRQbfbKpoM0uFvu8tx2NTQZtloLqE6aue5K7e+hPl" +
    "WLxvr2htuXBwiZtB4owFXACXusJl3V3LA5bCwiVqB7URYAAXwKWCcFm3s749" +
    "ZHXwU6XgEgcYzmjABXCpC1zW66JvB0WZci4lXKIO+Gb9uFOwA3TjXnbib1SF" +
    "3uupKOlzh3imEUYo3Q5heM87Ewl+WKdL50eveFmXl4e6yb9t0I1o5TblA0sp" +
    "4BJ1BkwDMIAL4FJVuESBpUhrWUoPlzjArL0L4AK4VA8u/MdZZrCUCi5Ri+wa" +
    "NwkALoBLVeDCYNHV8zKBpXRwiQPMGjsS/by7Rj0UdTeQ8M2GPZplEob4jSKX" +
    "MCQ/rdPdI7mfoXR09xCPhOXnFIZD3mzYvVkmaY9aIFc2sJQSLnFDJD6U+Gfd" +
    "ABfApZxw4T/IqoCltHCJA8xq2yiAAVwAlxLAJQosWVy7CrhYTFM3AQZwAVwK" +
    "DBeup7rdzWWZbq4sXOIW2q3UJjjRbv0uHtRVkfCcFz2pWt+3uhrEy+SbmHhL" +
    "75vkhRSnVPLKNl88lLlJ2kLPdyNadZtqgqUScJEAw5Z3wAVwKRpc+I8vCixF" +
    "3StUS7jEbXZs7KgGXACXosCFDbQrtak2WCoFl7jjGljf3jbohgIugEtecOH6" +
    "t/oO0XW0COfeAi4CYKLWwjgPkwAXwCUhXNaOGQYV8aAnwMXyTN6GVt8x2Fkd" +
    "pXUU8TkasVL92NWD8vDTJUzhm3UUrVtD8QryqGEQ/xEW6WhKwCXBrQIrpqu3" +
    "XV7ZARfAJSWx0VZ3C2KVZoRqCxfJ0Mv/JmvtDLgALv71o45E32pbH/tKLeHi" +
    "MkwCXAAXDIMAF2/DJDa28RGa/I9TG+0syOSbjlAjX9bqEKwOr+swqNZwaQyT" +
    "omaTWDxG/q+dARfAxU7f3a6lt7JVvYdBtYeLtPGxcdMjL7wDXAAXSTwEWiXG" +
    "tlLWHc2AS0rbBloPlfh8DcAFcFHFvdtvbxdff3hjbZ3bV63hYmLs/Wp1b0sl" +
    "WrNDYJNxVntFHVJQe0t1KIfWVJR3Or4jDIG4t1LFRXGAi6N4TBwHGD7PlA+j" +
    "AlzqC5c1WobKq2wdX0+qtDcIcMnojJjWQ6Xvtwdc6gQXDlMaAtVtJghwcRSv" +
    "Q5CGSrzC1woygEvp4MLly+UsDYF4BhLtBnDxOlRi8SrM72wfLMRboR08aEfB" +
    "zx0dZOtHGvF28SOpn5b5xMPfuNW1GAIBLpkNlVg8Fl8BGcCllHAxhUqZz7UF" +
    "XAp6lIM0VFoBme0AlzLBhf8UTKDCQ6A6LoYDXAoIGT6gCnApLlwYKtLsD6AC" +
    "uBQWMmwM5H/F1bYLZhxctZoiBpco23C29SBbP03i4TkdXB4rtzEb/mC9CuCS" +
    "68ySiU2msa3gW9sALnnAZdW2Zr0UQAVwKa3hl/XNrYKKvuq2gEuacOEdypzP" +
    "39wKUAFcagaZxrBpFYNhE+BiDmEe9qzUxrwMuLzqcsYK4FKhjZFxxzvoejRs" +
    "C+B/WwZOk7ZW1NbgnaRqayDpG5cwHOLJQ04boGCdCuBSGbtM3EFVUaDhxrLy" +
    "1oCLTgxhzh/TIU/rXgqGPoBLZQ+rijtLRoRNm3rCxRUmDVsKlugDLrXbXmAy" +
    "nW3Us6kYXBrDHBeYNNamYNgDuEAO9pko4/BKbZQeTsHh0oDISm2SwaQhHn7C" +
    "OAu4QDFDJ5sZpzqL8wmrZwEXKMHwCbD5+twUzg/0TgAXKCXYuBiFARMIcIGs" +
    "h1GN3o2rgThvsb2pMcTBMAdwgUqwvoYbKhuLizKs4niw0RW9EcAFqgF8VDEA" +
    "WksdgnHvSH1H5w/gAbhAEAQBLhAEAS4QBAEuEARBfvX/visAkuP9Xi8AAAAA" +
    "SUVORK5CYII=")

RUN_DISABLED = ("data:image/png;base64," +
    "iVBORw0KGgoAAAANSUhEUgAAARcAAAEXCAYAAACH0wDUAAAm9ElEQVR42u2d" +
    "eVvUPNuH3+//DR4VQZBFAUFANmWTRVxAFEEWUWAURllEUW+V27vvXIWR5kra" +
    "JJ220+XX4zj/0Gmz9yRJ2+T/njnO/wEAQNSgEAAAkAsAAHIBAEAuKISi8/Dh" +
    "Q+fevXsC7e3tzv/+9z8tTU1N0rX37993UK4AhZBz6EanG95EFElx584dCAhy" +
    "AVnBpreRVqq9INQn5ALq2BuhGzHLIrEBwoFcQAZl0t3d7QwMDAjMP37s8nh+" +
    "/i/vSyWXUoX5yr85PAwirt4NhlSQC6hhgjWqIU5VHiSA58+fu3L4559/nD9/" +
    "/sj895/Af5X/4/zRwcL4898fl9L7krOyulKR1rwrh+473ZAN5AKSgCY5a7nB" +
    "SCBTU1OuRHZ3d52PHz86//77b/SciZz9K8LP1/1+/Pmzs1NJ76NKuh9d9IBq" +
    "6aWRlNGeIBcMdyp/ccPKZHR01FlcXHQ+V27OWCSSkFzOfM6hfK2srLjCDNuL" +
    "w1wN5FK4IY/tX2avTD5+LFduvrNkhVIHuXC8sgnTs6FyR/uDXHKJ7V9fGh6I" +
    "MuEUSy78mnJl2EflQ9K1kQ2GTZBLbt49semdTE5OORsbm87v32cVfgdzJnN2" +
    "dhaILswzhjIOfo7EmciZCL8+TDp5mMR+uew8evTISjQ0z4V2CrnktpdCf3lf" +
    "vXrlfPv2nd2YkIuNXLxsbGxURD1pJXa0W8glF1Khx8MLCwvO8fGx/00JuYSW" +
    "S/W8b9++ueIe6B+AZCCXbGLSFW9va3O77eX9fbObEnKpWS6X+TpzRU7l397W" +
    "DslALvmQCnXPqZtufVNCLpHKxUt5v2w8bMJTJsglhVKZcI6ODp1fv366/JT4" +
    "JVA9z/98kV/uNSLSOT8Zvzjs+p8iv1TweHkcmvOlvPz8peCngC7dctn9YijK" +
    "sBLu4eGhMzc3ZzQJDMlALrFi8pduckKUCuSSXrlU+fr1KyQDuaRzopYaJTXO" +
    "o8pfQvVNDLmkWS4ulfO+np4aSQZzMpBL7O+pVKVyWvnLF3wTQy5ZkEsVksyz" +
    "ZwtOW1sb3pOBXJIdApFUZmdnnS9fvrhfGIM88JNx/v8vX77USgb3C+QSyRAI" +
    "UimWXKo8e/YscLiEoRLkEvoL5f7+fufg4AA3YUHlQtAflYmJCXyJDblE82iZ" +
    "fltbW8PNB7n85e3btxgqQS61LdA0MzvjfD757Pz48YPxXeB75f+0fBfhYfz4" +
    "zvkh8N2N55IfCngcer4z2O/KfHzXoInjhx6pvHlZaNPNwvv+Q4FY3nJeg8Og" +
    "eGdmZgKHSkX/Ahu9FQV9fX3usoy+jR1ygVwu4qYV/4aHh9GLgVyCnwSRcF68" +
    "eKFv7JAL5MLSsLUVPFQq4jq/GAZVh0CVLi6tdqa6ASAXyMU0DTMzsxgmFU0u" +
    "fsMg+v/V1VX38/w4Of12KvDtlPNNhM4R+BY/Uhqiz/ep+38aTkXqUha6+pPK" +
    "7rIud3d2nLbW1sIPkwo9DOrq6nLK5XJ9Gifkklu5EMdHR4FzMUUYJhV6GFTX" +
    "xgm55FouLpX/f/LkSWGHSRgGQS6QS4xyIWgfqaDJXsglB8Ogzs5OZ39/3/3E" +
    "XuRU5JTxNRj6cNHL11OZU/c8f6Q08esr6RD5qkA8h4epjZOfL8V5KudNk27r" +
    "333KTywLEdv6+qrMO28DwfUnp1luN97zjyrDpKGhoUIt5ZC7PYH8Km96ejrg" +
    "RoJcIJd45XJ6Eebjx48LI5jci6WxsdHdTCv4RoJcIJdk5ELs7Ow4rT5Pk/K0" +
    "jEOuPzr0HwZBLpBL/eRC0DCJ2meeBZPbJ0JUcYcHB+6XrAInCvg5X04Y4u8n" +
    "J4wvIl9OTmQ0cZwwpDRow9MjpVPLiSKdPBxNuqXyD5EP22sMzj/RoGwngW3G" +
    "rPx42YyNjeX2SVIuxTI0OHguFlXDglwglxTJJUgwWV8jJnePmscePAhuWJAL" +
    "5JIyuRD0wCFvgsmXWCp/AbQNC3KBXFIoF2JxcTFX78LkRixUMUYNC3KBXFIq" +
    "l7wJJhdioX2X6YtmI04UfC4qJ4zk03BSiZdjHU7O6pNWuqNXKLIumEyLhSpg" +
    "eXm5toYIuUAuEExx5aJakZ8Kniqg5oYIuUAuKRaM6l2YrEzyZvJxc2ixQC6Q" +
    "S056MFkQTCbfY6E9ZI6Oj11o3YxA6BwPR8dHMkfHAsfHRwL8dwkW3rEKXTop" +
    "Xi/S9ex3RRjVMrmEp4uVBV0TgDoOXnaMYw28rI+O7DkORlcOJmWhS4OuDSjj" +
    "1LRNXsfV9G9tbSkFk/YX7TL3rZBXLJAL5FIEuVQFk7VPBTIllkdzj6SGA7lA" +
    "LkWQC0F/WLMkmMysx0IfJ6oKHHKBXIoiF8qbn2DSuFxDZsRyeHgYDQcKLK85" +
    "OBSJIl1xhJnGNBwciBjV0WEGOEgu3ZOTk5kQTOrF0tvbW/9GALlALimSC+G3" +
    "zAjkYviS3O3bt931WCAXyAVyyZ5gUvvIORaxQC6QS47kQtB9ktZH1KkcDtEz" +
    "/Y2NDefTp08KDgQOKv/n5dMB45Oeg4MDER4mi1PiQOTgk4yUroODQOQ0BJeD" +
    "Kh3asmP5lsM0KDsNPN/6fKnS+UlAV1Ym2OZVaiNS2Zm0NV070rVd+ZoPe3vO" +
    "zZs3U7kvUirnWWivF9MKglwglyLLhfK/sbmZyuFR6uZZRkdHrSoIcoFcii4X" +
    "YnZ2NnWCSd08y4cPHyAXyAVyObCv84F791I1/5KqeZb19XXn48ePImWRMoOf" +
    "r/tdCYvD6BpvnAyzc8oMfn5Z4GNZpGwQLw/DNg1SuZTla2ivbS+6dOrCOw+T" +
    "1aGufni8unypyk4Kw66O5bIu69uNrq3ytq9Jx/v371M1/5KaeRbaLMrkxodc" +
    "IBfIxT8d9Ac6LcOjVMyzjIyM+FcG5AK5QC7GcqE6mJmZSYVgEo3snmJMeOvW" +
    "Laf0vgS5QC6QS0RyIQYGBuo+/1L3eZa19TVnv7x/zr6e8n5ZwOSauCmXRSIJ" +
    "kxFNWssM299joKxgPwtEUVbBYUhtwKSsLv5/t7SrnH/JpVxUw6H5x/PWjQpy" +
    "gVwgF71cCPrDXc/hUd3WZ+nv7w/VqCAXyAVyMZMLMT4+Lt17ND2RG7mohkO0" +
    "shbkArlALvHKhf6vXsOjurwsRzb1KwjIBXKBXKKVC22/U48FvhPvtdDTob0P" +
    "H1w+7Ins7e1p+SDBwvkgssf4oAhDOufDnsCem7ZLeBzS+SqkfLC8a9IgpfvD" +
    "niKdLA6TdHmQ8rWnryO5vHmYPA0ftHxQ1rO3vlgc/HcTNGHI5a3Lp77taeuH" +
    "tTMJZXlp2tlF2DQNkXTvJfFJ3JcvXkAukAvkkrBcNjffKHcQyKRcVJO4w8PD" +
    "rBFBLpAL5JKEXIixsbFEF/dOdBJ3Z3sbcoFcIJc6yYVIcnI3se1Xp6amnPfv" +
    "S4z3WkoM6ZwS430Y7NLF01QqiYRLQ+3wdGjLTkcpqvK1qy96Y9tLvcozKN1h" +
    "6rwe9cHjXFpaSmxyN5FeS0dHx0VBQC6QC+RST7nQ/w0NDSWyc0Aik7grKyuQ" +
    "C+QCuaRELu/evXOuX78e+/Ao9l7LgwcPPAUBuUAukEu95ULQNEXcvZdYey1k" +
    "x7dv3zq7u7vnlEoiu5xdmRKDX8N/Z3GUKmF4UcahDVNEF2ZptyShzxcLoySi" +
    "vV6RLgkqDw9yulm+eH2VSvr60NSpXC4KpHZiV1+q8tfWh1S+vB0FX6+MQ5MP" +
    "XX3o2vauSR0G0NLSEmvvJdZeC43tgioMcoFcIJf6yUW17m6UvZdYnxDRqliQ" +
    "S21y+f79u/sYEnKBXKKWS9y9l+R6LZBLKLlUjy9fvogNEHKBXCKQi2rf6VTJ" +
    "RdVreb225uzs7ASzzdmW0V4jss3Y2dlm7GjhYWxXrvOyEwZdviTOr/Mef/78" +
    "cT5//mycbu3vvOx2RFT1oY9jW0QKk6EsL17nlmWnyde2Ip3W7cS6Pg3avyYO" +
    "VT5s887P33qzJT05iuq9l1h6LYODg+qMQy41yaV6/Pr1y13SEHKBXGqVC52j" +
    "2nM6FXLx67VALvHJpXrQfAy9Zg65QC61yCWu3ktsvRbIJX658PkYyAVyCSOX" +
    "uHovka/mv7i4UKmsdy7v3m0z3oVgO5DtyjlepOu3GcpwdHGKv1vHuf0uZN7f" +
    "OabHv//+6+78FzYeo3xFQSTlEkW7YnnfFpHLZlvgXVzlU2s+Qtbh5uZm5L2X" +
    "SHstXV1drIIgl6TkUj1+/Pjhrj4GuUAutnVI+7RH2XuJdL0Wb68FcqmPXKrH" +
    "169f3aES5AK5mLK6uhrpei+x9Vogl/rKpTpUOjk5ccfWkAvkYoJqqqPucpl+" +
    "OO1svX0r8HYrmK23WwL0HRJna4shXWPLWz08nQwpLyyOLRVSOFsCbyXOw47i" +
    "+P37t7tjn65sTcpPLgsx3VL96OpclXcer1Tm6rLyrY8tBbr6sWzLyva9tRWM" +
    "Lg6DfMjly7HL59KLpfrKRWW3jfUNyCWlcvHOx9AXsZAL5OKXTzqHfxIQdhvY" +
    "SHotJJu3ISoEcklWLt5H1/T4FXKBXFTnj4yORNJ7iUQujx49glwyJJfqfAx9" +
    "SgC5QC78/FcrryL5WrrmN3LdNVt8Mga5pFcu3vkYWsgZcoFcvOfTA5paey81" +
    "91pGRkacN2/euGwy3khsMt7kAjnfm/q8borQS0xeqtclddCnBDRUSmcZ25Vl" +
    "MnVcnzCSQvWqSaxyUUX4/PlzyCUHcqkex8fHbu8Ncim2XNbW1mrewL6mZSxp" +
    "iGRXeJBL2uVSnY/59OkT5FJguRADAwM19V5qGhLRDm6QS/7kUj1+/vzpfnUN" +
    "uRRTLnNzc8nIRfXV5MvlZWejciP4wW+YjY0NDZsymxvBSNeIYW4y1HEwNoLZ" +
    "lMLdFAiTD78w03DQpwQ0VPKto4Dyl+sruH5cNkX0da4pa4M61LebYDYNruH3" +
    "g9RudG1iU1U2vP3a3S+6tss/ZrR55yV0r6WnpydQLJBLfuRSPY6Ojip/0bYg" +
    "lwLJhfZ3D9t7CS0XWnsTcimWXKqPrsvlj5BLQeSysLCYvFxevnwJuRRQLt5H" +
    "17QZGOSSb7mohkY0RRKZXPi3RM3Nzc76+pq7dYiXtcr/eVlfWxdYWxfhv/Pw" +
    "TNDHGfx72HgF1tYEeD5ryWvaD3rLl+ZjzMsqirJfE1ijehZYE1DWuaZt6uqP" +
    "xxkqnZb3y5pRvGKcvG3q2q4qHzQFEmYRqdDbhkAukIv30TXNx0Au+ZQLbckc" +
    "ZmgUSi4zM9OQC+Si3JWAHl1DLvmSy8LCQnJyWVl5BblALr7Ht2/f3E8JIJd8" +
    "yIUIM++iFQstc+cNtK2tzXn9+vUFawJrlf/z8pqzxngdAyHi0Kbb+vw1BeHy" +
    "k+Xj8PDQWd9YZ3WyJmJUfryOTcIIaBNrtbeBKAjXjhgsX1KY2vsh+B6upquv" +
    "r8963iXU1iGQC+RiMx/z8dNHyCXjcpmYmLAeGtkvZzk9DblALqHmY3Z2dyCX" +
    "jMqFPlCOXS7Ly8uQC+RS03zMm60tyCVjciHoFRSbr6St5lta29qcldXVS1ZW" +
    "GKsCqxIrAkJYFVZXV2RWgpHSwMLkaVpZXZGQ0xXMqjJvl6ys6OPVhnGR/rwe" +
    "tIEbNeZVt95FpHZhWFaX7Ygjtytd29PWl6qt8jD82sLf+0PTlqU2tKq/ZzRt" +
    "WbqHVk04L0c+76LrvditlTs4CLlALpHOx9AqeJBLNuQyPj4en1xm5+YgF8gl" +
    "8oN2JaBH15BLuuWyuLgYn1zkGxdygVyi3ZWAvrmBXNIpF4K/7xKJXBoaGpxX" +
    "r15Zssx4lVPiy2fRjuoqeNSQ81KHeeLWrVvGk7rGHytSoKgwyCXpTwkgl3TB" +
    "vRD0Mp3xerkUKCoMckn6OD09dfcwhlzSKZegoZHVroqoMMilnqvgxTtUglxM" +
    "mJ2djV4uFCgqDHJJw3wM5FI/bL6Qttiydd55+XJZYPnlSwFasFuA/s+DdD7/" +
    "vXKNjpfLLwWW3XRcwtOoS9N5vAxdvlgaXqri5WXF4pDLZlkJDp9PCXZ2PO1I" +
    "0y6V9cHalaY+5HbD41QR3N6ltiy1d94ul63TJbVVTds1uQcjl4uygiAXyKXO" +
    "8zG0pALkkqxcWltbjZZfMNpGhAKDXCCXtB40VKL3QiCXZOTS1dUt+IE+EzKW" +
    "i+oxNOQCuaR9PmZ/fx9ySUAuAwNmT4yMhkQDA/3OixcvZJYYut815y8tycjX" +
    "LGnQhynxQuSFFjFO++sNyu4CHHYH7RK5tbVl0K6WREzrzaf+ltx2ICK1Ramd" +
    "BLfd+rCk5f790ejkQoFBLpBLlg7alYCWCYBcopfL9PTD6ORCgUEukEsWj48f" +
    "P1a68q8glwjlQkQml8XFBcgFcsnscXZ25uzuliCXNMqFlrgzYonxfInx3J4l" +
    "DdowTNJgm07N+Yp0LlUasBfTfOCI7qBdIumra5N2t1SpVy/RtN0lkTBhWqLP" +
    "R7j7A3KBXHAoDloFjx5dQy7h74+Ojg7IBXLB4TdUKpfL7uNbyKV2uahepINc" +
    "IJfCP7re3d2FXGqUi2pdF61cbt686SwsLjqLCwsyiyL0UZOXxYVFAf47hWuN" +
    "FAaHny/C03zOogAPUzqf5Usul0VtmDyd8jXnceFI5qBV8OjR9WVbDm438u8K" +
    "dPcLb2e8XenCW5DToWu78j3Fz1/UQue1d7TXLpf2iqEgF8ilSPMx9DQEcolB" +
    "LvzVf8gFcinifMz+fhlyCZAL32YEcoFccFjOx2xsbEIuBnJRLXepl0t7u/Ps" +
    "2TNQJ3CkYz6GniqhPV5y9+5d7bsuWrlQIChMyAWH4351TU9K0C5DyoV6KpAL" +
    "5ILDfz6mVCpBLmHkwi+AXCAXHPLx7ds3Z319vbDtcmJiIgq59DpPnz5xnqh4" +
    "wnnKEH+ncLw8efpU5InMU7quBnian1bikeHpCs6ndD4vB2UYwfnyiwNHug9a" +
    "ZvO8/ZrcH3btSG4j9veHnC5+z/G2+1SBfA+Z7BsNuUAuOEIctNUJfUXsdwNC" +
    "Lgq50HqYkAvkgsN/OHTZW3laWLlE8rSou7sbcoFcMJF7dubu/Ki++SCXUHKh" +
    "p0eQC+RS5GNvb8994cxfLJBLKLm0tbU5jx8/NmNeZP6xCD9f9/t5mPOM4Di0" +
    "Yc7bp1O65nEY5hlmZYmjfsfJyYn7JbGyzi3b4byiDRi1f9t2JaVrXsC6Hfrc" +
    "tz29vfLLtpAL5IIj+Pjnn3+c16uvg+sccqn9q2jIBXIp0rwKre1iVOcFlwt5" +
    "oWa50AdJkAvkkveDdgmgl8OM6xxyqV0u1U3o5xU8evRIwzyD/T7PkM43iSOY" +
    "eYbZNZp8zmtQ5UM6xwwc8c+r0M6D9m0i2naqZN6krdndg/OKe0J7fyjihFwg" +
    "FxwB8yrrG+vG9QG5BMvl4cOHkAvkgnmV9+/fu49UbeoDchHjbGlpiWb1f8gF" +
    "csnDQav902JHfjcM5GIul8j2LZqcnHRm5+Yk5jizsyKqczzMzs0yFHHMMqQw" +
    "dOjjkPM1K8LypQtTnV8WpqbsqmHjqP2gfaNpnyKh3VAZe5DrR0Q6X9Mujdr7" +
    "7JzAnAZle9XlQxOG1O4UqMKMTC6jo6OQC+SSySHQmzdv1G0Pcgktl+np6ejk" +
    "Qq/6Qi6QS5aO0vv37iNTv/qAXMLLhTobkcmFvpSGXCCXLByHB4fOs4UFbX1A" +
    "LuHlYvJdka9c+CcAra2tzszMjJZZxgyoGRxmx+npqbO8vIx2mAB8WRYrudAz" +
    "a++FjY2NkAvkktp5FVoKAe0wOaizoXuBzlcuqqER5AK5pG5epVRyH4uiHSZL" +
    "c3OzdhN6K7k8ePAAcoFcUvNomdYUQTusDyZDIiu5UNdnujJc8vLw4XQw0yLT" +
    "jIduGB6mZaYZPExtGCxN0ybpkNCE8VBEFQbPh3SNT75xeF/Z/+G8fr2qrR+p" +
    "jSiQ27JlG5DqT9Xeeb0Htzvt7wrkfAW3Kx2q+8Mb3v3R+9HLhZa7hFwgl/rM" +
    "q/yuDIF2L9sA5FI3uQwPD9cuF7452u3btyEXyCXxY29/z3n0aE5sA5BL3eRC" +
    "nYya5SI9jr55E3KBXBI7jj8fO4vPF9VtAHKpm1yok6Fb3lIrF9XQaGpqKphJ" +
    "kckpEfn8SYHJKRnbOCXY+ZNTqnRNMvh1ut95HIp8aNLlVzZFO378+OHuZCjU" +
    "0aSIVB9S2U4aMGWJeL22bZu0Vdvfje65Gu8fRVl583mz0skweQxtLRfawhFy" +
    "gVziOH7//u0uMUlvhEp1BLmkRi7Xrl0zGhJZy2VgYABygVyin1fZ23OXT/St" +
    "I8glFXK5/+CB8XyLtVy6urogF8glsuPr16/ulqjaOoJcUiGXOz090cmFf0Nw" +
    "48YNyAVyiWQIRPMq/uUHuaRRLm3sCTIt3h9aLqrey9jYmDv3omJyYpIxITBR" +
    "uVkEfMIRmGRMTIqw33mcUhpM4pCwTPekAZprqunN27Gzs+PMTM/8bSNGbcCS" +
    "yUmG1C6jj1fZ3lg6Is+XUZjsftGkO6g98/kWv9f+Q8ult7cXcoFcrA/auoO+" +
    "A4r7Jodc4pHL8Miw1ZAolFxu3boFuUAuVo+Wl5aWfNsI5JINuZgus2AlF/4y" +
    "HS2/ALlALibzKrTEpK6NQC7ZkAvfSkQ332IkF781dcfHx52xMRH6Py9jGsbH" +
    "xgTGxk1gYWji5L+PjyngYbB8yekW0aXxHPEcOR1iWVTTksVje3vbmXo45ZNP" +
    "XvZjMlL56tqNrp0p6oyu8yCVv2Uaxsf17UjOK79G/F13fykxSFcQqnuO/t92" +
    "viW0XGjeBXKBXPhxdHTk7gcUnE/IJWtyGRoash4ShZZLR0cH5AK5CPMqtMSk" +
    "8q8e5JJ5udh8rGgtFz7vcv36dcgFcnHnVWgIFFRfkEv25cJ3Vwz6WNFaLqre" +
    "C63rQKvTBTPGsD3f5Jp8k9aDtkSll/ys8zTGqFO5jjEKk4YQ5c/vfdW+0JHK" +
    "hT4FgFyKJxeaV1lcWAh/Q0AumZKL6TYiNcmFHj3xR1GQS3HkQvMqq6urtd8Q" +
    "kEum5MIXjYtFLny7EbOhEeSSdbnQvApt3TF5MQSCXIojF3rlhD+CppfpIpeL" +
    "39u69++PergvMMq4X0mswH2RUQW0ILAXHuboKIPHKaVJFQeHxVn5PwFF3sQ0" +
    "jWrh6eJpqIZVz6NcLrsrkYl5Z2Wny4dUP5rrjcpPDFNuR5o2MmrQLrTp1sR5" +
    "X5GuUTvMyuV+MJr7SW53l3Tf6Q7da7GWC+8i0VMjyCV/cvny5Yuz8OyZOu2Q" +
    "S2HkcrP1ZnJyUfVe+vr6IJecyIWGQKsrKx4xQC5Flcvg0KAkFpO3ciOVC/Vm" +
    "IJfsy+Xtu7fOxPg4EwPkUlS5dHZ11tRrCSUX/nUkTfiMjIwYMswYiYAIwhxm" +
    "RJ6m4dBpivs4PDx0Hj6cqiHNumuGNcRfP8PDMiMapPND1Pkwxe0hnvYfD6qn" +
    "w7HLxW/DNMglW3L5/v278/Tpk9pvfMgld3Lp7+8P/eJc5HKh7QYgl2zIpbrE" +
    "ZGQ3PuSSO7nQt4O1DolCy4XGf6q9pCGXdMulVCq539FEeuNDLrmTCz0FDvMt" +
    "USRyUfVebt+65b5U52VoeEhkSGSYIZ1fYZihDUPz+/DQsMSQjmGGdA6L0yDd" +
    "pvmI4jg4OHD3A+LpHlaWjx26MIe06MvTuuyk+jKJ1zaO4LZtFgcvO94udW1Z" +
    "cb9Y3g/891rfbYlELnzC53pDA+SSMrnQvMrz588DGjPkArmItLa11l8uqs8B" +
    "6EkS5FJ/udC8ytbWlkFjhlwgl0tUE7lB27XGJhfV0Ki5uRlyqbNcaEtU2tvH" +
    "rDFDLpCLp9fSGl2vpWa58EWkqktgQi7Jy+Xg8MB58uSJZWOGXCAX/15L2Inc" +
    "SOSi6r3QroyDFekQ9wYHBQY5F+f9ZVDFYDD3GIMhkNIh/q7Lx73Be1p4vkjM" +
    "XuTfB11M5lVeLi9fpIuFw8pGn4/a0cWpy7cKOd2631m+7snYthHbfKvzzrBu" +
    "MwZhSL8Hl3/1/6PutUQiF1XvpefOHcglAbnQ1h0jo6O+Nx3kArmYyKUvhl5L" +
    "JHIJ6r1ALvHIZW9vzxmfmNDedJAL5GIil1oWhIpdLn69F8glWrmcnJw4jx8/" +
    "9m3skAvkYiuXgQpXr16t+Tui2OTi90nAwL0BkYEQXBTAXwYGaoOHZxKmNh/3" +
    "RO6prmHnGKa3+mj59evXEeRdkw+j+gqXDzsijuPeQDRtMYXcY9iWZVt7Wyy9" +
    "lkjloupa3e27C7nUKBd3XmVkJJrGCLlALp7f6AlRXL2WSOWi7L203oRcapRL" +
    "pEAukIu319IWX68lcrloey+QC+QCuaRCLnH3WiKXi99bu/19fedUMuSFlsj0" +
    "0q+gr69fpL8vECmMfhPEdMnp6GfwNDKU6RLDoMd/An3B6Mqur88+HzwN8vUK" +
    "eDp4GLqy01xvEoacbw2qfPA65PXF0NZnmDqT4uRlo2nbyjpl4frcY20xvNcS" +
    "u1xUvZfO27chF8gFckmJXHp7eqR7NBNyUfVeGhoanL67dyEXyAVySYFc+IoG" +
    "cYglNrmo3nuhbhjkArlALvWVC40i4ngbNzG5qHov50sydDt37/Z6uGtAb4hr" +
    "okaTht5eEZMwexma83sZceQzjjjChGl/jX0bsY7Dsr5CweLgaeztlbGqi0rb" +
    "5JO4cfVaYpWLSjDUHYNcIBfIpT5yUX2cWMt6LXWVi2pyl7aAhVwgF8glWbnQ" +
    "Dh1JTOImJhe/yd3e3h7IBXKBXBKUS1KTuInKRTW5S98d9fT0uJIR6JHp6ekV" +
    "qZwn0MNh57PfpTgVYchpYPT2iqjO0V4TnK/eyv8JaNKsQpsPXdkYhcHzISKX" +
    "dy+jR3uOddlKbURf3jrk+jBIoy4dPA4dPA2qfClQjSDimsRNVC5+k7udnZ2Q" +
    "C+QCucQslzt3ehKdxE1cLirBNDY2Qi6QC+QSs1xolFDrhvKpl4uqa0YZh1wg" +
    "F8glHrl0dNxyVE9sk7rnE5OL3/CInh7RliREd7eCOyJ3uhl3RLTnd4cIg/+u" +
    "TWO3jCYOOc5uBkuHQT7kOLsFtGGqwpHOYenUli1LQ7dBmLqyMCkbyzZgXzYh" +
    "0qkJo7uGdtLV1VW34VBd5KLa64gKoPvi5oNcIBfIJRq58C1Zq/uK5VYuBGVQ" +
    "Nf8CuUAukEs0cmlpaanrcKhuclFtBUtQgUAukAvkUptcVHObSQ+H6ioXv/kX" +
    "moCCXCAXyCWcXLq6Ous+z5IKudDjMNX8C73/QpNRf+lmdGmwPb9CN6Orq1uE" +
    "hSmfHwHd3SJRhRs1vCwqafViH2a3gtrSWHua/NIVkMZuA2KoD287pLff6z3P" +
    "kgq5+D2epvkXyAVygVzs2m5Lc3Mq5llSIxe/4REtjQm5QC6Qi1nbbVcstF3P" +
    "4VBq5OInGOrVQC6QC+QSDC3+lKZ5ltTJxW/+paO9w7ldKTyRTpFOESpskU4B" +
    "fr7LbR1iGniYnZ23BZRxSOkMThcPUz7/toSULl0crKx0ZXueLhEpDZqykK/v" +
    "DHEOz7cmHyo09SGlQdMGVHHY5kOOQ9OWb91O3TxL6uTiN/9CgqE3eCEXyAVy" +
    "uW0klnrPs6RSLn7vv1ABioKBXCAXyIUefKRxniW1cvGbfxEFA7lALsWWy42m" +
    "G6kXSyrl4icYMjUJJg46GElfH1UYiNOCDsatDFBJZ1Njk1Is9N0e5FKDYGjY" +
    "BLlALkWVS0tzS2bEkmq5qL6gjkswkAvkknqxtKjFktTCT7mSS5BgqKAhF8il" +
    "KHJRrSaXpkfOmZSL3wLf1bd429s7nI6OdgF6pO2lg9EeBx2MdlU6OgT013SI" +
    "dIjw8DoU5+jikMuGxWmQd135a69vV+WlPRDrMDvkdOrD5OUvlmWt+W43jJP2" +
    "Grpy5UrmxJIJufitAVMVDOQCueRVLn5iSdO7LJmXi41gIBfIJQ9yoXadZbFk" +
    "Si5+L9lVH1NDLpBLXuTSrPjCOWtiyZxcAgVzvdFpa22r0CrQ2tYmcH4Oo601" +
    "EB5Gq/t/l7RRuF4UccjXcMQwpHRrzlcTnC9eVmZhBsfRSnn1YlL+Un3Y5qut" +
    "ZuTyjiBMVhYm5e3XvrMmlkzKJWiIdL3hOuQCuWRWLn6v9GdRLJmVS5Bgrl27" +
    "BrlALpmTi59Ykth2FXKxeEztFQzkArmkXS6qr5uz8rg5t3IJetGOZtrpdWl6" +
    "AUlHK0M+p5XBfm9l3IyfVqN0a9KpTXerjOaa1laRePKvqY8IytO6LEOkk+Kh" +
    "P4R5FEsu5KITDM28Qy6QS9rkQu3STyxp/VaokHIJ+tix+qgacoFc0iIXmqBV" +
    "vcOSJ7HkTi5BgqG/EpAL5FJvuai2WU3reiyQi8W7MH7DJMgFcolbLs3NLb7D" +
    "oDyKJbdy8VuT9+/7MJW/Hs0tzX9pYTS3tDCaNedzWiRoXxkv1NiCoC+/BZoZ" +
    "qnRI4TQLSNdIYWriVMGu4XFK8LJS5p2nladLLEtVWQRer6pTqX5Y2YUpq4v4" +
    "aVjuNwzK6jsshZaL364C3mES5AK5xC0Xv8fMeXkiVFi56OZh6K9J040myAVy" +
    "iVwuN27cUO4nlOdhUCHlYjJMglwgl6jkUtRhUGHlYjJMooqnvzjppIlxA6SJ" +
    "phtu+wmatM37MKjQctE9TapuYwK5AFuo3fj1VooyDIJcNB8+Vnd6pK4t5AJ0" +
    "UDsJmlsp0jAIcjH4bCCdQyXIJY29laD2Qx/WFvn+KrRcTCZ7q5Khv1BVmjgV" +
    "AXlpbGqUadTRxBB/l+JobNJeow2TIV3v5kWkqalRQM6r5nxNGtx0WJadLg5l" +
    "WbE45HzxvF+eqxsCFbm3ArlYPrKuPramRgW5FFcu1xuvBw6B8vZtEOSS0Box" +
    "3vkYyKV4crnWcC2wXRTtSRDkEvNQCXLJv1yonjEEglwSHypVezI0XKIX8f5C" +
    "/2Y0NFwXuK6h4bqIFKY3Pl8aGNftUKXNMgw53yb5qDHdEaAb/mAIBLkkMlSS" +
    "JAO5ZFYuJlLJ8rq2kEtGh0p/JVPpSkMu2ZEL/VEwkQqGQJBLKiUDuaRPLpAK" +
    "5JJpydBk4PmQ6ZoATRQKNDCuRU/DtQaBaw2Maxx9GA3u/11in6Zr9mGwsuJl" +
    "K4cn5uvq1eBJWgx/IJdMzcmc92auVBr3VcilDnIhoZj0UiAVyCXTkqn2ZiCX" +
    "+OVC5WzSS4FUIJdcSUYQDeQSmVyuWQgF3wBBLpn9MDJoeQelaC64QjeIlysi" +
    "JCSOdA5DGwY//6qKKwL8GjlNV4K5KnOVo4vjbxmZCwXvqUAuhVioyk80V7yS" +
    "gVykOKph2JQreimQS2HXktHKpsByCSMTzKVALnicHVI2eZZLWJlU303BsAdy" +
    "ASHmZ4J7N1eyJRf2f7WUAQ0/0Z4gFxDRE6cigzkUyAVANpGAdVMgF5DCSWHI" +
    "BEAuIHTvJuwEcb2h+SYMcSAXkMHJ4rQMqygdmHSFXECBe0Be+BCMekf8HJQb" +
    "gFwAAJALAAByAQAAyAUAED//D3COiyBpCsKdAAAAAElFTkSuQmCC")

PAUSE_ACTIVE = ("data:image/png;base64," +
    "iVBORw0KGgoAAAANSUhEUgAAARcAAAEXCAYAAACH0wDUAAAgf0lEQVR42u2d" +
    "eZsWxbmH852OgAokgCzuuGFUMK6gkqhHDa7HRMgRjaInuERggAFmhoEZnGEH" +
    "HWDYRoZNUGRRUHHJ0ZyYz1DnfaZ59e3q6n6qqqt6/XFd9z+81bXXPVXV3dW/" +
    "OibErwAAwDWoBAAA5AIAgFwAAJALKqGOvH1YiCYv7xdi7rYw07uF+I+lPBNX" +
    "Ra99ZuCXuJugziEXUDGB0ECnAa8jiqyY1feLgNBOkAsouERMZhtFpTkLwmwH" +
    "cgE5QX/1aSCWWSQmNIWDtodcQIlkcnOPEDM3hnluX8Dze39hzZmA1Wd/+X2E" +
    "vQHNa2e14Gt2Q/WBfgG5AAtog9XVEqcpDxLBXz5qyKEhiMEfhDj8k4J/hzny" +
    "UxQ5jBzHkX+rWdOQ0puNwj3fyMecxkzklh7IBnIBmUCbnLYDbHx7QyD9Qjw+" +
    "EMwiSCC9F4QY/lcyhzh+UmBzTQJbvxFi1ZnwDIjKY1sXJGX0J8gFy50Be5nM" +
    "bvz1XzAUDM7mwB7+SaIEcolLg8q16GhDmB8KMa3Lfq8G/QxyqdWSx3T/pFUm" +
    "PefjB3aV5CLH+bNsBuxmNlTv6H+QSyVvFZvuodDygPZIRpY3OoO64nKRfyfJ" +
    "kmxJuiayoXbAnSfIpfSYPLxGA+SxxhLg3RNCDP1flIMSQw5g4/yXAsM4feRb" +
    "xbovhHh20Ew0tM+Ffgq5lAqTWcqDW4V4/YgQu/6RUgQ1l0srJGgStckdJ8xm" +
    "IJdKSIVuD89vTOk3X3QoAsglAgmbxH1XPyQDuZR0P0Vng3ZaZzBtp+m7FxFA" +
    "LomQyKn+qR0gGcilElJ5tDE9f+dEBiKAXIz2Z3SXTbjLBLkUTyofCNH/tRD7" +
    "/+mHAwoiYX6U+Gcy7PUaccjh2bL8yMPmk/k9Lt3+r4R4eo/eJjAkA7l4lYrO" +
    "XzrfUoFc3MmlyQffNSQzCMlALgXcqKVOSX8B6S/h/h/9iwVycSuXZpt98L2e" +
    "ZGjminEBuXh9ToU64TODwV8+uaNCLuWTSxOSzEsH+c1fPCcDuThfApFU5jVm" +
    "Kju+FWLvD4740RCdOEzT/CEHbMuawL4fw1jl49L/vzosxFRGMrizBLk4WQI5" +
    "lwrkUmi5NPnzweTlEpZKkIv1G8p3NqbAfV/mPMggl9zkQv+3o7H8/cMHeBMb" +
    "cnF0a5n+Wi0+XpBBBrnkKpcmbaewVIJcUh7Q9Mfdwav+e/43md0W7DFE5/rd" +
    "BcBFOVzXt4s4VddQ/0haKtX94KraFjxptnJHX3Aso+2AgVzqIRdiwwUh7t+S" +
    "/EcKcsGdoJG/QguH0w8YyKU+cmmy9NPkpVIdz/nFMkhaArkYMJBL/eTSulTC" +
    "MqlmcolbBtFshU6lH/hHPLskBji+V6ATJim8Dzzkga0rnTSkMKb1rxU+ZRpJ" +
    "8a063ZjFdGCZVOtl0PT1wXGJTjor5AK5tLD5ayHu21LvZVJtl0FP7XbcWSEX" +
    "yEVRtv/aX99lUi2XQf9zzENnhVwgl5iy0XeZkjZ7IZcSEdeIN64LDgqiF9NC" +
    "fCfB/c6w8/so7HXfe8Awn1Z5Mq07D+U0rmsqu0TqPsDUzabGMunezfU6yqFy" +
    "3wSKa7wndzkcIJAL5GIol2aYF/bVRzCVF8u4lUK8cdTxAIFcIBdLuRDtp4WY" +
    "0lH9Yxwq/dJh7DIIcoFccpQLQcsk6p9VFkxl7whRw/V9FRyPkJbt30l8m55I" +
    "Goa/68SZNg0XdbHDA8Z1+10x8q3i4R3VvZNUSbHcszkQi6tOArlALnkIpuxn" +
    "xFTuVjM1lOtOArlALr55Ylf1BFNpsUAukEtZ5EL8Zahaz8JURiwLhvx1EsgF" +
    "coFgKi6XOLHMPyjEtosB9GZzai5KuAjvI07uGi4O0981wmz7JgyX523fmF+T" +
    "ui5d9ZOUdRVH26fBIxRlF0ypxUIN8NrhX8QCuUAuVZBLVQRT2hP5qeKpAVrF" +
    "ArlALlWRy4hgTglxw7rybvKW8nZzUyxbL0IukEt15ULXkGBUM5gyCKaUz7HQ" +
    "N2Q2XQygczMSuchDT0u2wv5ukQabTy5OjWuadfJz3ZiW2yYNJt9yeJs0Teub" +
    "a09XdZFULyqM2/jS/y+NWSIV/UG70r0r1CoWyAVyqYNcmoIp26sCpRILfZeZ" +
    "bTDIBXKpoFwI+n51mQRTmmMp52zT7NyQC+RSUbkkCaaIxzWU4qCn2Q2x9H8V" +
    "sNGQfgmdMD7IIs20dWEa30YH7eGknF+HyaP9suxXj35YDsEUXiwzNqTr8JAL" +
    "5FI1uRD0B7foz8AU+iG567uF6P4CcoFcIJcyCqawt5xVYoFcIBfIJcz13cW9" +
    "RV3IDVy6p//OSSE2fCnE+xckvsyACwxf5oBGHjZIpM63TtmLUDc2eSpivi3a" +
    "o+tzISZ3FPO7SIXcZ6FvvTgbIJAL5FJhudD/v3uymMujwu2zPLjN8QCBXCCX" +
    "isuFmLeneIIp3D5L5+eQC+QCudi0x6yNxdp/Kcw+y9iVQrz9sRC955Ppkei9" +
    "EIb7XUXkGhk5PINWGlycTJ56NPLRcz4Z07ru0WkPJp9c3dq0h2kfUdU32+YW" +
    "7eG6L3Pt3XFOiKvWFGf/pTD7LC/s5xsDcoFcIJdk6A90UZZHhdhneWCrXmNA" +
    "LpAL5MK3+VO7iyGYTBObq3jo57ruYDoHuUAukIsbuRAz+/Pff8l1OUT7LIsb" +
    "07h15y/xBc96iXUFYP15CQf5LGI5Qcb9KkUfWH1Gvf9C+52Vk4tqOfT8vhax" +
    "QC6QC3DaBxYfz3d5lNv5LHf1S2KBXCAX4LwPzN0ZHXu0PVEZuaiWQ3SyFuQC" +
    "uQD/fUC1PKqEXFQPy5FNRwoOuUAuwHsf+OvhfA74znzWcu1aIdZ+HtAlsVaD" +
    "LkPWngujFUYikg/T8Brl0MlnUvi158zTYMPbwKTB/u4qH2nzaRi+yyLfxuU8" +
    "p4GcxqU+eWdf9pu7mW/ivjoMuUAukEvWcvn7yWA7IsvlUaabuPdtSd+JIBfI" +
    "BXIxlwvxyI5sD/fOdBO3/TTkArlALnnJpetctpu7mX1+9T8HhOg4a8G5MJ1n" +
    "w3DhddKIxHmOwTDPOnGw5dJJgyvnOYmzyWjFIZE6T+fM28e4/XTK7qDNjeO0" +
    "6buG9b/wUHabu5m88UybuJ1nIRdOLj2NvzS7vgkY4PhWAXPNrm8lLqVF6bqU" +
    "C93ZsM6T4ppdEnK55XJALslx3Ls5my8HZLKJ++ZRyEVHLjRA8vhH6bqUCw34" +
    "PMsBuSTHsfxUNpu73mctD283mOpDLpAL5OJdLsTjA/5nL15nLWTHZZ8GL1FZ" +
    "c1biTA74yIMizg8v5jMoKV3dfK+SUIUpQzkK0W9y7tuTPG/uer1DdM/mgg5s" +
    "yAVygVyU5+66nL14vUNEp2JBLpAL5FJMufievRR71gK5QC6Qi1ce+9DfawHe" +
    "Zi1/Oy7EytPJtMt8pkAnTAsrJdpPmyPHYVwOjThVYXbmNCh3fn2p7uSyfcaj" +
    "KueOr3Mqx0V1H+Haz7ZNU2PY13Xyadp33/tEiLEr/Dz34mXW8rtNlg0IuUAu" +
    "kEumcqEwqm9Ou5i95DZrgVwgF8ilGHLxNXvJbdYCuUAukEsx5OJr9uL8NP/5" +
    "Q0Ks+CyAngQM8ZnEKQ2Ya5ppxaXJ/W6TrxUSbHyf6aWx/at8BiWlq1UuzbrL" +
    "uxxa7WHajxzVjWtWMOjm8d3G7OVKx7MXp7OWm9YzAxlygVwgl0LKhXhwm9vb" +
    "0k7Pa2mdtUAukAvkUi65vHnc7XkvzmYt09drDGTIBXKBXAorF+LuTe5mL87k" +
    "8sSu4D0iE5ZK6ITRuSaRUwo+dctSy3xvzWlQUrpLHbZZnuVw1R6p+5lmumnT" +
    "iKR5SoJLQxoLC4fdbew628h95wTkArlALmWXCzFxtZvPwDqZtdy90U3lQy6Q" +
    "C+SSv1xcbew6kcuzg5AL5AK5VEUubxxz87Z06idy6d64q0EIuUAukEv+ciHo" +
    "Bk3a2UvqWcsDW4VY8knAewxLJLjfl2hc4yKN90w5mcwSBZF8yL832Hwhn0G5" +
    "+Uu9ulyiKLuqLim+XMpx4VK+PvGPTh8y7Ysu0nA1XlQn1XmVi+rZlv/+CHKB" +
    "XCCXqsll8cfpP2Cf6hjLq7v8D3zIBXKBXLKXCzFzY7rZS6olEX3BDXKBXCCX" +
    "asrl6cGM5PKMYg326mEh3j1pwAkLTOO0SdNFPtOWo8GmnOSy6bzbslJ8uZTj" +
    "gsN+Z9pHXPRNmzTSwpRbfpnR5JkX61nLbb3uCwK5QC6QS7HkQt93t529WMuF" +
    "zt6EXCAXyKXaclkw5Fkuqo+dvToMuUAukEvV5aJaGtEWiTO5yO8STVgdfDZE" +
    "5i0J099teOtEGNPftTghYZgnrXQbYfpzGpSU7luq9jnBl111XeHKodOPGFz0" +
    "5bRpaJVNai8X5bi11+4QKaslEX3IGnKBXCCXesjloe12SyMruTy1G3KBXCCX" +
    "usjlpYOe5KLab3njKOQCuUAudZELYbPvwsqFjrlrjXRqZ/DpkBGOhVnM8PN1" +
    "JhwzxCKNxRJcHtjwluV6//N8BuX7X+jVy2LNuqP4cinH5w77gIN+xfYjeXw4" +
    "6NuLGWyup7Tv7DPfd7H6TCvkArlALvWSy+93mi+NrI6zhFwgF8ilXnKhF5RN" +
    "j7803m957QjkArlALnWTCzFhldlb0kb7LVM6g1OqfuZomDdNOaYBE0ckD8z1" +
    "ofxfgssXG/6oRT4VbDiXz6CkdLXqUrO9civH5/r5jLRp2jZXxXE0GdM+84aD" +
    "/m41Bi9xR5/Z0sjsrNxNkAvkArnUVS5zd3qUy7xByAVygVzqKpcFhvsuZs+3" +
    "HINcIBfIpa5yIeTnXZzI5YpGpIuOhHldwvj3o2EWacTBwsSpumbRUYkjyXB5" +
    "WGRRVrpufU6DsuecZV0fKVY5KF3t9rAoV2KcRzXw0a8yLsd13fqbutovK1Kk" +
    "kAvkArnUWy7y516THqbTPi+XPnwGuUAukAvkorupa/RVRcgFcoFc6i2XeXs8" +
    "yGXebsgFcoFc6i6X+UMe5PLsXiH+etiQYYnDHvCQxmvDYbzkW8G6s/kMSkrX" +
    "ti5fk6Dr1p3JqRxnYvI9rFE2H311mKEI/V+6/jVVm0ro3o7Wvg1dlIEPuUAu" +
    "kEu+cpnSoXf8gtZnRCgyyAVygVwgF+Im6TvS9JqQtlzk29DXroVcIBfIBXIJ" +
    "mNWvt++itd8ysxHZK4c0GJYwDL/wUJRXUrJQh+EwrxgSud6irPR/3TkNyu7T" +
    "MXWlKJsq33KbU3x5lsNJvzLsy6q6YvuJTT/i8pky3zpxzNnuUC4UGeQCuUAu" +
    "kAtBZzo5kwtFBrlALpAL5NJMU+eOkZZc6KtrkAvkArlALs7l8vJHwTF3prws" +
    "YRp+5JpDDB/5x7Qcqny+LKEqR2dOg5LSdVYXh/IrR9dp+76aus09xVGEcqiw" +
    "kovqGRfIBXKBXCCXVq7pglwgF8gFcslALqoH6SAXyAVygVxSy0V1rgsrl6vW" +
    "BBu6Cw4qGAozX0IOP19GDq+BHIdpHhYMOeAgg2W8HZ/lMygpXSf1UtByzB+y" +
    "62u+KWKedHEiF4oEcoFcIBfIJbVc5Ef/IRfIBXKBXGTkz4xALpAL5AK5eJGL" +
    "6rhLVi5XN+TyUmPA/PmAOXSdCcp4DkrIaUiY/q7Kp+s8qMJE0myw+lQ+g5LS" +
    "HcnHAQ0U+W6FwuRaDt1+yJSTa3P2d0UYrp+xeYip76T2YdPUqBdV2X77Pv8K" +
    "ACuX3/ZBLpAL5AK5OJDL9G7IBXKBXCAXD3KRL4BcIBfIBXKR+f1OB3K5vWGo" +
    "F/c3OKBgvxl/knhxf/Zx/OmAAsM42fAadaWKo/3TfAYlpfvifnfkVo5TBv3S" +
    "tC8fYHDQF236uvF44PJ9QC/MXMgFcoFcIJfCyGVWH+QCuUAukEtymNtd3C26" +
    "uQdygVwgF8jFg1ymdUIukAvkArl4kssL+4R4XsELMnvDcOHZ+FTX7JXYlwyX" +
    "xxd04pCv2ZceVT5XfpLPoKR0dfKo20ZFK8cLFn1V7mfG1+/z0//TlstFXyVm" +
    "bAh7gh5hgVwgF8gFcnEuF6u3oiEXyAVygVxkpnY6kMv4dsgFcoFcIBcPchn5" +
    "CP2gEM/tjUL/H2KvxCDDXg2ka0zz8NxgGFUakbINJqOVb8Ny0f8tP5nPoKR0" +
    "tduPqTsKk3s5HPSzSL+T+4AHInVpAdd3ub6uVX+DkAvkArlALhnJ5eX9kAvk" +
    "ArlALg7kMnG1o+8WQS6QC+QCubTWlbOPoj32oRBP71EwKLHHjHmDYUyvt2Ge" +
    "gtRxyOWwoRHPshP5DEpK12WblaEcrvtyXJs67e+KNNL2ZVucyWX2NsgFcoFc" +
    "IJeAJ11+iJ4OhoFcIBfIBXIhZm9zKJdbeyEXyAVygVwCdE6hi5WL/ArAlA4h" +
    "ntod5Y+GPMWgvGZXmLRp2JTDOA+7NK7ZJdH4v6Uf5zMolx4P8mBTV5GyNv5v" +
    "SV7l+Fi/T5j2I5t+l7YfqfpI2jFl3J6KfnFLTwq50D3r1gvHrYRcIBfIBXIJ" +
    "oMkG9wBdrFxUz7pALpAL5AK5EBNW8x+hj5WLat/loe2QC+QCuUAuerehjeRy" +
    "9yYhntjFMCDhOrxNHDZpMNc8KREJr0C+5smBMBTv34/nMygpXe260giTazls" +
    "29iwH6naj+0nafuuRj518pXEk0z/1r1TZCSXm3ogF8gFcqm7XO7b7EAu8sfR" +
    "ru+GXCAXyKXucrlpvQO5yLejJ3dALpAL5FJ3uVzfzR9vycpFdcfo8Q/NeGwg" +
    "DBteweMDEsw1VmnIMGmyeRpQwJWrwbs5Dcp3junV3eOa7fPusXzKQelqtZ8N" +
    "Upw67ekkXdMxx+TLpl+2/n7VGr3b0IlyUe270CccIRfIBXKpr1zGLNe7U2Qs" +
    "l5n9kAvkArnUVS70OIrufouxXKavh1wgF8ilrnKhdwydyUX+tOtvVkEukAvk" +
    "Ule5TJOOtpy4KoVcVJu6j+wQ4g8fqHmUwTS86po/7JSwiJNNg4nT9Hdd3j6a" +
    "z6CkdHXz+OhOCbnsjf97+0hO5TgSpG/T5nK5uH7mpC8bkkWcSWHk/Za4x/61" +
    "5KJaGtFnHCEXyAVyqZdc7t9itiSyksu1ayEXyAVyqZtcbun1IBf5YbqxKyEX" +
    "yAVyqZtcTPdbtOSi2nd5oDFFmrtDg50MpuEbPCIx1xSdfKb93TIfi3MalJSu" +
    "dvtphMm1HLptbopNH0jbT3zk2xLT/RYtuaiWRrf1Qi6QC+RSF7ncs9l8SWQt" +
    "l2u6IBfIBXKpi1xu7vEol8i+ywrIBXKBXOoil0lr9F9WNJaLavZy3xYhHt6e" +
    "zEMSpuGV7AjzMIerdJPyIMepyAcXJ133t8P5DEpKV1k3GvVZyHLIdb+D7zem" +
    "bazVtw37ok4fMc4HUxc6bS6PfdV3oZ3KhV4FgFwgF8il2nLR/YxIKrnQrafW" +
    "BH7dDrlALpBL1eVC+6ve5SJ/bkRnaQS5QC6QS3nlQufljmkLj3l639C5XFRL" +
    "o+u6gwzYMkdCGW6rhIc05jCkzYNWvhrxvjmcz6CkdF22YRnL4QOt/u3xep3x" +
    "NEeiNaztXSIrucjn6l65AnKBXCCXqsplckeGclE9rXtHH+QCuUAuVZOL6sE5" +
    "nadyreWiWhpN64JcIBfIpWpyuXFdulmLlVzkA6Row+eBrZZskdiaE1sYMkpz" +
    "0aF8BiWlq1tuevW+FdU1i3KSy+uNdO9X5FEF1+aR8KZ9RieOLPqVZTzj281f" +
    "VEwtl7gPpkEukAvkUg253NVv/+Ccc7nQ5wYgF8gFcqmGXOjMprRLImu50MaO" +
    "6lvSkAvkArmUXy50F9jmXSInclHNXuhLbPRQXSv3ymwOc5/MFh4uDjYNjWsi" +
    "MOWIpKmRb1U+X/8op0H5kV493adZ33mXQ6e9TPtAJLxhn3DVV7l8mKYh/646" +
    "cS7p20Re5CK/DkC2g1wgF8il3HKZ2ulmSZRKLqrXAch6kAvkArmUUy6qjdyk" +
    "z7V6k4tqaTRhFeQCuUAuZZXLlA53s5bUcpEPkSJmvA+5QC6QS9nkopq12G7k" +
    "OpGLavZCX2X83SZgw6tD+QxKStdZOTZWpBw1w/WsxYlcVLMX+qYsGgxygVzK" +
    "wZ197mctTuSC2QvkArmUm6u73M9anMkFsxfIBXIpJ7Ma7TW6Lf17RN7kopq9" +
    "TF4TZNyI/igzN4aRr4n8Lsex0UE+mN9nymzk860q6ysH8xmUC4di8qiqb42y" +
    "LsxJLq8M6edRVf8mbc7Wiw5yvkzDb9QYL0y+Vc+12D40500u8kFSBB3uC7lA" +
    "LpBLMeVCd4h8zVqcykU5e+mAXCAXyKWocpnmcdbiXC6pZy+QC+QCuWQiF9+z" +
    "FudyiXtq964+NXdK6IS5s1+CiUMOH5eXxDRN6efzqfr95QP5DEpK17psivpf" +
    "mFM5Fh4MBo2LNnPRJ4zj4PqMizQuoXquxeWsxYtcVLOXG7ohF8gFcimKXG7b" +
    "EB2jrm4/e5WLavZyxXIh7ngfcuHK8eCWYKC7YiFDMxyl61Ius7fwact5MClH" +
    "5PeDAbO3Qi4619AHDX3PWrzJRfXcy9QOyCVtR0rbuZ2U07D+XeSB7Tf9YSCX" +
    "eG7o9vM0bmZyUc1emg/W0QZv5dgg4eGa2yV8lMNHGjZxlrWsrvuRnMfbN0Qx" +
    "iX/Ghugmro/lkHe5qL5xRCeKQy6QC+SSj1xUHzlLc15LbnKJ29ylT8BCLpAL" +
    "5JKtXG5an80mbmZyUS2PLl8eTM8gF8gFcslOLuMz2sTNVC6qzV36FAndDpsh" +
    "0xvlNpkNDEz4GQq4MFyabJ57LeJk0LpGzhdTV1btwcXhgNvSYtOPmDaO5NFF" +
    "GjZ1w6XZq34S19cmbqZyidvcvXE95AK5QC6+5XJLT7abuJnLRbW5O64dcoFc" +
    "IBffcqFVQtoPyhdaLnGbu1RwyAVygVz8yOUaxZcTXb8/VAi5xC2P6NORNHWL" +
    "pVfC9HcXOEiDnvFpJZdy5RDnrRI6eWCvkYiE12kP7hoXbZ42jV5zmmlNX6de" +
    "DvnexM1NLqpvHVEF0G0yyAVygVzcyUX+JCsxqy87sWQuF2KW4jDgcSshF8gF" +
    "cnEll0mr810O5SYX1adgCaoQyAVygVzSyeWaruwfliuUXIz2XyAXyAVy0YIe" +
    "78h7n6UQcqHbYXIljGoLNqJoD0YXCt+KybWxrJNwEOd0iZsyYDpD2uvzKkce" +
    "cbqoB/Yaqd+Z9u0rCrDPUgi5xN2eHrsScoFcIBdTuUwsyD5LYeQStzyiioJc" +
    "IBfIRa9vqx7vz2ufpVByiRMMbUxBLpAL5JLct+nwp1EF2mcpnFyU+y/Lgs9M" +
    "UuUlsi7MjTLdYeTwIximwf6ugVa+DMPLYdhrTMutUy4J09+t6LbAtH6l6yPh" +
    "FRiX1TSP3cERskXaZymcXOL2X0gw10MukAvkEsljnFjy3mcppFzinn+hCrwe" +
    "coFcIJdQevTgaRH3WQorl7j9l0TBQC6QS83kojq9v2hiKaRc4gRDt6ivW6ug" +
    "W8L09wbXdodRppPAtRI6+ZTTjMTRzaBTF8w1bJpr3aNVVxwO2rysjI8RC723" +
    "B7mkEAxVLOQCudRVLqp3hooqlkLLRfUGtVIwkAvkUgO5xIklq4OfKiWXJMFQ" +
    "RUMukEtd5KI6Ta5It5xLKZe4A75HPnC/OngO5hqJqyUiv3cq6DLDNM1rNK6J" +
    "wOTRKk6LfHL1Z1z/LvLgolydYdLGebUn6FtD9EhG2cRSCrnEnQHTFAzkArlU" +
    "VS5xYinSsyyll0uSYCauhlwgl+rJhf5wllkspZJL3EN2zZPsIBfIpSpymRCz" +
    "eVsmsZROLkmCGbtCiKkdCjoldMJw15iG17nGFBdpuMhjB4NpeB91pWCaBJfP" +
    "aZ3JOKmbzvgH5MomllLKJWmJRIcST4FcIJeSymXsyuqIpbRySRLMmDZJMJAL" +
    "5FICucSJJYvPrkIuBrepQ4KBXCCXAstlSqf67eay3G6urFySHrSjnXa6kzR5" +
    "TZirFEzm6JCQ4+yQsEgjdZ46LK9pIZKHDg2YNLhy+agrF+3BpqlR9zplH9NW" +
    "TbFUQi6cYCasglwgl+LJhf7wxYmlqO8K1VIuSS87Nt+ohlwgl6LIhe4IqZ5h" +
    "qZJYKieXJMFcvlzdySAXyCUruRCqz6wW6dxbyMXyWRj6a/GbVZAL5JK9XCYk" +
    "LIOKeNAT5GJ4Jm/r8zC05m0ySWIig2n4kWtWhfGRhmmcXBqTPOUjbdknOSCL" +
    "PDV/oyfIL1tWrWdYai2XuK8K/Hy7ejnkArn4l8sVCcugKtwRqq1cuH0Y+mtC" +
    "m2uQC+TiOk+0/B7dVp/9ldrKRWeZBLlALq7yVNdlUG3lwi6T2oIjNOkvTiFp" +
    "l3BxTTuDq3y4vL6oddMezIKTNm2rvgyqtVy4u0kjnzFZAblALuZ1Q4/wx81W" +
    "6rIMglyYFx+bt6zpwTvIBXLh6mZce/LeSp2WQZCLxmsDrUulX0MukEtM3Vy+" +
    "PLn/0Iu1dR5ftZaLzmZv8+le2qRrMl6mnaf1eh3YNFbyGKchX98ehS2nHH6l" +
    "BYZ1Z1PXxmm2lOnyFclLoDrPViAXBbQmThIMLZVoPwZyqa9caKk8qi25n1Tp" +
    "3SDIJaMzYprQ+noc5FI7uXBLoLrdCYJcPC6VxrRKBnKppFxopkLtjCUQ5JL5" +
    "Uqk5k6HbkPQg3s8sV7AizNjlYeTfI+EdcKUhOnGkTaOojG7j2x5LIMjF+1Jp" +
    "ZE+mVTKQS6WlUuZzbSGXki6VQpKBXEoDtZeOVGgJVMeH4SCXokmmsU6/vA1y" +
    "KbpURkEqkEtZJUObgfRXke42mDCGgcTFstwDTBqRfBpe7yWPEtQeo5Zh+QO5" +
    "VGRPpjmb0RUN5OJWLmM0hQKpQC6llgzNZmg6PgZy8ZpHEsroZcm3kiEVyKWS" +
    "kklaNkEu9oxu0xcK3gGCXEr7YmTS8Q7KGc2y4K8tzWxCLAszui1KJIwEG4cc" +
    "vo1HvobLUwRVnFy+YuIwEQqeU4FcanFQVZxoLlsGuSTJ5bJl5kLBLAVyqe1Z" +
    "MqxsaiqXVqGY1h32UiCXWr5eoHM7O2kJNarCcrGVSfPZFCx7IBdgsT+TNLu5" +
    "rGRyac23rUya0PIT/QlyAY7uONUZqic8PQu5gBTLJ8jml3NTIBPIBXiUjc2m" +
    "MGQCIBdgPbux3SDOG9pvai5xIBPIBZREOrRZXJRlFeWDNl0hEMgF1EA+MiSA" +
    "VuQlGM2O5DCqeFC/kAsAAEAuAADIBQAAuQAAgFv+H3HzS5V7I1v4AAAAAElF" +
    "TkSuQmCC")

PAUSE_PRESSED = ("data:image/png;base64," +
    "iVBORw0KGgoAAAANSUhEUgAAARcAAAEXCAYAAACH0wDUAAAeO0lEQVR42u2d" +
    "6WMVRdaH/WtfNsE47JvIJqIso4L7AqgsIrgyo+Po6KujjgJZyUICCSEQCGEJ" +
    "i6CgPfdwc8fb1dV9qqqruqq7fx+eL7ndVae2J1XV2yPHo+gRAACwDSoBAAC5" +
    "AAAgFwAA5IJKAElW90bR/x3nebwrilBfAHKpMSqiKIrNAxAS5AIqOdsIFcyC" +
    "IBcQADQQyywSHdDekAsooUw29UfRjtNx3p9ocqSNUzNN+mb+/L2d1rk728Ds" +
    "BnIBFV7itORBAvjbZFMON+9H0YM/JERxfv8jyQOGxDlRk1M3o+ibK01RvXKm" +
    "ue8C2UAuoADyDLaOrqZA9o01JUICOXs7iu7/IfB7nN84/pBgck4Gk/eiqHcm" +
    "PgPqyDFLIymjP0EuwPAqDg2+lxv//Y81ZiKTd/8c2AmZlEAuaXlQuf411RTm" +
    "ql7s1UAuwMn+SbtMztxOH9hVkouYJs1wWrIxmdmg30Eu2EOZhZYHtEfSWt78" +
    "piCDKstF/J0kS7Il6erIBssmyKV2yx4aIHsb/5V/nI6iew8a/B7nrsA9C9x9" +
    "EOeeiEo6wjl3f8/mniOGG7I5fF5PNLiZD3Kp9CzlpZEo+upyFF3/NXtgQy7q" +
    "kKBJ1LjiBLnUTip0efjTi1F04RfJgIZc8jMbCwmbxL19CJKBXCq8QUtXPGja" +
    "PnwrQyiQi1W5tEMip/pXufIEyUAupZDKnsb0/IerikKBXJzJpR0SvOqyCf0c" +
    "cglSKuON/5Z3HrjhFwmJY+4LPMiGPV8hDfF4tiz3edg4md/ToPY5pLgJjH4P" +
    "uXi/8rNn1K1UIBd7cmkx/SskA7kEulFLnfLQeEMqd2YHxAPIpUxy0ZUM9mQg" +
    "F+ezFeqE7zU64/Q9YUBALqWUS7tkPrnIb/7iPhnIxYlUDjZmKlMNqdy6D0Lj" +
    "tkCetL64HEUre7FUglwKWAJBKvWSS4uPL2Yvl7BUglyMZyvbhqLo3B0M3LrK" +
    "haB/Km+NYhYDuVi6tEz/rb6bxoCFXP7k5HUslSCXnC9oOjDefK/IzH2B3+Lc" +
    "ELkvQTiGSzORh5DejIQbv1lGoRyJclkoh3Z9M3HPqMRlUC7qH1lLpbo/gY3Z" +
    "ioRnh5rvi1UVAeRST7kQo7ejaPcIZjGQC7O3Qv+FPr+kLwLIpb5yaXH8WvZS" +
    "CXKp8TKotQSSdizIBXJRhPoRlkk1k0vaMohmK/RW+mu/pXNd4BrHrxJUjsk6" +
    "3gUmMTDnXBfQzlOWplj/TJzs8Spx67ZH27G9NxqzmB7MYmq9DNrQ33xdItdx" +
    "IBfIRbcu6RUPu4brLZjaLoP2j6vLAnKBXEzr8oOJ+i6TarkM+v8rerKAXCCX" +
    "PHVZ12VSrZZB6081XxRED6bFuCfwaz6uSHCdp404neRTQDlNypE4h4szZzkm" +
    "GsukF2q2TKqNWN49V9wAgFwglzSOTtRHMJUXy2OdUfT1VLEDAHKBXLLoaSyT" +
    "VvRU/zUOlRZL6jIIcoFcPMqltUyi/lllwVT2ihA13Llfmk+y5uWyA7g8TGLQ" +
    "LYfu71MWyjl1V0ClDYRz2Dw1j3cWtwKvna3ulaRKiuX54aZYLt+DXCCXsOWS" +
    "JZiyvyOmcpeaqaF0BhzkArn4lgvxzrnqCabSYoFcIJeyyIX422S1riRVRizH" +
    "Js0GHOQCuYQil6oJphJioe8uX7rbZBJ45ZKA7vFow+ab7ugWirILptRioQb4" +
    "8jI6JuQCwUAuFt/ITxVPDYCOCblUWTBPnirvJm8pLze3xDKJjgm51HQGUwbB" +
    "lPI+FvqGzMTdJvTejEzuCkiOmRDQ/Z3NUyVOg7gTcd6Nw6WhXS5ZHprHm+Sp" +
    "VL9tJPK4a3COJoly3tWvq7RyHk8RTOg32pXulv52sUAukEsd5NISTNkeFSiV" +
    "WOi7zNoNBrlALhWQC0Hfry6TYEojllfOmHVuyAVyqYpc6G9pgoFcDMXyckMs" +
    "4780OX9Hj9Z5WeeLx4zfYeCO/4XPVztNBbTrQkClrljEdHXLrVCfXJ7jNmDq" +
    "VqXuc7dpSmx7xsohmODF8vRgvg4PuUAuVZMLQf9wQxdM0DfJrTsVRadvQy6Q" +
    "C+RSRsEEe8lZJhbIBXKBXOKsOxXuJeogl0N0Tf+H6eZ3eMdE7ghwv5twm+GO" +
    "BxRiGBXIHbeL+i+iLlXyCKFNLbTH4K0oWt4T5uwlyH0W+tYLiQVygVwgF749" +
    "frwa5vIouH2Wl0b+FAvkArlALmrtcXA8PMGEtc/SF0UDNyEXyAVyMWmPnafD" +
    "2n8JZjm0qDOKvp+OorO3BW7FoW87tyMez/1+1sI5ZxhM8tBN84wF2HLeSsId" +
    "46M9TM7P2+Yq7aFbv3nbuL/xj3lZQPsvweyz0MeipI0AuUAukIsy9A86lOVR" +
    "EPssL45kNAbkArlALlrsD2T/xfus5Ym+5nQOcoFcIBd7bbwjgP0X7/ss3zWm" +
    "ccO3Z7nFMyIwHAAjtwUsxBliOUHB/SpHH+ib8b//4nU5dGSiTSyQC+QCrPaB" +
    "7zzvv3ibtWwfEsQCuUAuwHofeGO04nKRLYeOX4NcIBdQRB/wtTzycrMc2fRh" +
    "wSEXyAU47wP/vOznBd+Fz1rW9kXR0M0m9NBVO62/x7gVRzxn8GY2YnqDt/h8" +
    "E2kIMbDHK8DGqVkuaV1pxsWW+5Za2fKiW//SOPPGrJnG4E0H9W2xLrcNFT97" +
    "KXwT94tLkAvkArkULZf/XG1uRxQpmEJnLbtGsgc65AK5QC5u5EK8frbYl3sX" +
    "uonbcwNygVwgF19yGSz42aPCPr/69lgU9c8w3OQZmInDpjHDk0iTi8NCOdgY" +
    "TPLgynlTYCYbpTQEtMstS0OzfbTbT6XsFtpcO02TvsvVv3D855eK29wtbBPX" +
    "eMDUSC7/ORdFb37U5A2OjyUw57z5scBsXpSvTbn8OJ4S38cKMcmOERDTFMsB" +
    "uWSn8cJwMbOXQjZxv5mCXFTkQgPkkUeKh/K1KRca8D7LAblkp9F5vZjNXeez" +
    "ltfO5pzqQy6QC+RiVS7EvrGSyUWctZAdT1xvPkQl5YbATAHcUMBGGgZ5vO5J" +
    "LpSvanv0Csjq5vUPPZfDRnvZ6FczAdIW39Jut4JxOmt5flizQSAXyAVyKaz/" +
    "y967G6RcZFeIvr8KuUAukEuocnE9e/E3a4FcIBfIxbtc9o4FLhfZrOXb6Sjq" +
    "vpFNjwnXs+kWMMlDTMNGOVTietXToKR8e2Rlu86TKGcA5Uj0iRv69ISAQjlk" +
    "9a/DT5LHAmzd9+Jk1vLcsMMGhFwgF8jFmlyoDWXfnA5CLqazFsgFcoFcwpCL" +
    "q9mLt1kL5AK5QC5hyMXV7MW6XD6djKKuG03oTkDXdAno/u4iz84bEhTSfdnT" +
    "oKR8bdaV73IYtemNOEX0Ixd90TRO+t70QsuzF6ti2dif3UCQC+QCuYQpF+Il" +
    "y7MXZ7MWyAVygVzKJZdvrth934s1sWzo5xsIcoFcIJdw5UL89bS92Ys1ubxz" +
    "rvkcUYxr2RwXSJx/PXnM8etxuDwSXFfgWj6OKyA776UP/AzKFz9IiUmhPUIq" +
    "B+Wr3B5MP8rdz1T6gYU8uLjZ9hLaV/a+F+9y+WEacoFcIJeyy4VY0m3nM7BW" +
    "xEJTKWmgkAvkArmUTi62NnatyOXwecgFcoFcqiKXr694kot4Ry5dG08NFHKB" +
    "XCCX0smFoAs0eQWTe9by4kgU/Xy1yU8i1+L8LCAe/7PkmFbaqXkwaXAxyI5h" +
    "4WK4ysct+333UT+DcvcH8nKVrhxHU9pEpQ01f+f68k8qdac5Hn5S7M9cXCp5" +
    "7DsXgFz+Pgm5QC6QS9Xk8t10wXIRX2NJS6TMgQ+5QC6QSynlQuzIec9LrlkL" +
    "fcENcoFcIJdqyuXQeY9y+eJy84EnZaYZrjpg2iBf3bim7ZTtBU+DkvJVLocC" +
    "3suh0j66bWqj710NECZG8WFGnXtejMWyZcDBQIdcIBfIJSi50PfdTWcvxnKh" +
    "d29CLpAL5FJtuRyb9CAX7SUR5AK5QC6lk4tsaeRULou7o+j76ST/Fvj+Shzu" +
    "d1maHIk0NWMyzTcGU07Vsj7vaVA+dzQlZoP6J57zXY4rcb5X4N/T2ej2O2ld" +
    "CXHpjpfE+Vf08zQpx1MDZi+RMpq10IesIRfIBXKph1xePWu2NDKSy/5xyAVy" +
    "gVzqIpdPLhYol6+nIBfIBXKpi1wIk30X9oDNwnprZW8UfXtFzncM3xbBtIDC" +
    "ObpxuirXziN+BiXlq9qeKnURWjm+9dimzvMU+nveMZh2zrYh/X0Xo8+0Qi6Q" +
    "C+RSL7m8Oaq/NDJ6nSXkArlALvWSy98nC5DLl5chF8gFcqmbXIjF3RblIu63" +
    "rOhtvqXqf0zF+UaXKwowaejGEIt/Fi4u9vgpO3HueN/PoKR8pTEato+3chxR" +
    "6zOyfpC3X8nq5uupbHT7zNcW+rvRmJz97dlBvdmL3rtyhyEXyAVyqatc3jjr" +
    "UC4Hz0MukAvkUle5HLvoUC6JgQm5QC6QS23kQiw86UAujzYS/dflOF8JJH6f" +
    "isP+LkE8Rszzq6lsuDyl+V7O5isGlXLI0tx22M+g3H44pW4MykrnbfMkF6q/" +
    "rxT6pbQNFdonM82p/LB1bVIOrh9q8kSfA7lQopAL5AK51Fsu4udes26mU35f" +
    "LiUKuUAukAvkorrvovVVRcgFcoFc6i2Xg+MO5EKJQi6QC+RSb7l8etGBXA5P" +
    "RNE/L2tySUD3dxt5GPDlpTg20lQpxzOe5EL5mtbllwLey6HSz2z0RZXjLzHk" +
    "7esO0vxS1qYC1uXiZOBDLpAL5FI6uazosSgXSgxygVwgF8iF2Ch8R5oeEzKW" +
    "y9o+yAVygVwglyY7Fa8YKS2J6LOO/7jkns8l/GNSwEKaHHnzMD1nq6dBufW9" +
    "Zt3aqitv5TicUteTSXL3V6FfqtRN3t+LGHMq57xyxqJcKDHIBXKBXCAXgt7p" +
    "ZE0ulBjkArlALpBLC2tyOTYJuUAukAvk4kAun002X3Ony2cCusc/POeSwGTx" +
    "6JYjEXODzwRk5215z8+gpHyt1UWjbFsO+yvHZ77a3FEaIZRDBuQCuUAukIuT" +
    "GNb0QS6QC+QCuUAukAvkArnUSi7LepobuvSKO45PBbjfueMfMhmHzWMyDpfe" +
    "MZVjLlpAIc3Nh/wMys3v2S3nZk+SpPo7ptjvjvlA7MtcX3XR70z6tuQ8K3Kh" +
    "RCAXyAVygVwgF8gFcoFcnMvl2SHIBXKBXCCXAuQie90lK5fVvVH0SSODjy/o" +
    "Q+fpIE3nooCYh4Du77I4bccgOyaRZ4ONnuSy6dBsHBcUkMTdDh2z6aCnchxM" +
    "6QOy/saUk2tz9nfJMVw/Y2NIqe+s9mHzVKgXWdmeUfhAGiuXZ4YgF8gFcoFc" +
    "LMiFZiqQC+QCuUAu1uUingC5QC6QC+Qi8uaoBblsbRjqwwuGTMT56EIckzQ/" +
    "mojzIYd4vgLa5WDyVE1jg6dBSfkat7GknN7LodIeTPvYqossuH6U6Osq4+FC" +
    "MbwBuUAukAvkEoxc6H2YkAvkArlALllstXG1aFM/5AK5QC6QiwO5rOqFXCAX" +
    "yAVycSSXo42gj0g4ysAdr5vew3POC0xkk0jjfBI2DfGcifzI4nzS06CkfFVi" +
    "VG2j0Mph0h66/eiIQRomdcvCxGWrbp4W5EK3sEAukAvkArlYl4vRs0WQC+QC" +
    "uUAuIit7LcilowtygVwgF8jFgVwefoS+EeT7Eg57QDcGlePf1+TwhIClsj1x" +
    "wM+gpHyN22MiTlnLYbvfOcljgu977+fksEq+5yEXyAVygVwgF8gFcoFcyiSX" +
    "Jd2QC+QCuUAuDuRi7btFe8ei6NC4hPMC43ocPB9H6Twuz/PZHDyvkC+Tx0ER" +
    "MT0TGums2e9nUFK+qu2p0mbey2FCzr6c1qa5+zuTh9gXD7lAUi5rcnn5DOQC" +
    "uUAukEuTd21+iJ7e6QK5QC6QC+RC0GTDmlyeGoBcIBfIBXJpovIWulS5iIJZ" +
    "0RNF+88lOTCuRyKN8Tgq52jnocABEQcxHFBg9bt+BiXle0DSHjLEmGVlXeWr" +
    "HPtT2kOhHLnbfJzvzyZ9IivGAyrtpRmDyngRX8uSSy6PdUIukAvkArk0ockG" +
    "JxZluRCQC+QCuUAuxOJuy3J59QzkArlALpCL2pJISy5/PR1F75wLkDEB3d8N" +
    "eFcgkYcE8Zx3x+JQuis9DUrKV7muFI7xWo4xw36j2Y8SfUClnxTQd1Xi0jlf" +
    "7N8vjziQy8Z+yAVygVzqLpddwxbkIn4cbd0pyAVygVzqLheaZOSWizh7Wd4D" +
    "uUAukEvd5bKuj3+9pbZciH1jeuwV0D1e6ZzROPtELOSRt9x7ZXFKzlvuaVBS" +
    "vnsttqnPcuwbKwYnfYjpuzbiMumX7ccvU7wMrS2XN0chF8gFcqmzXOafdCSX" +
    "HachF8gFcqmrXF49q77foi2XDf2QC+QCudRVLk8NWJSL+AzBX7ogF8gFcqmr" +
    "XFYJV5Af78ohF9ns5fXG1OitUTl7GN4ai7PH4Jy0vFVjUMqDiZPLUxqbQjmW" +
    "vuNnUFK+XL0qt3EA5dgzJjBqqQ1160WI463RfOyxEKdJuVu/6ey3GMmFPuMI" +
    "uUAukEu95LJ7RG9JZCSXtX2QC+QCudRNLpsHHMhFFMyiTsgFcoFc6iYX3f0W" +
    "I7kQLzamSG+cVWCUwSAN2vNpxyhNHyjEueRtP4OS8lVuP4VjlniSC+Vr3M/y" +
    "tp+NfIuI24Sz+vstxnLZMgC5QC6QS13k8vyw/pLIWC5r+iAXyAVyqYtcNvU7" +
    "lIts3wVygVwgl3rIZWm3+sOKueVC0HsdXjsjcDYOvb2uHfZ4A16zAJuPUA6T" +
    "GBJpSOrmL57kQvnK2sOk7kIsh0q/0W1jWbm5/p1AOJ6N4Qx/jkl7cTGbzFpy" +
    "yYUeBYBcIBfIpdpyUf2MSC650KUn8VIU5AK5QC7VlsuavgLkorQ0glwgF8il" +
    "MnKhLyuKl6DpZrpC5PJEXzMAZUbivHImjso5ur+r5PEKAxuDjbI3/taxz8+g" +
    "7HjbsEwp9dvxdmDlGLHUhhbqJtf5Nsoh9kOB9mM3DZjPWrTlIr5Xd2En5AK5" +
    "QC5VlcvyngLlIpu9PDsEuUAukEvV5GJ645xVudAzB5AL5AK5VEsu6/s9yEV8" +
    "OpI2fOhZo1IzLOApjkWe5EL5qsa4WyC0cuweUYNrc5Vy2qirUOno0n9QMbdc" +
    "0j6YBrlALpBLNeSyfSj/rMWaXOhzA5AL5AK5VEMua/s8yiXtW9KQC+QCuZRf" +
    "LnQV2ORZImdyoS+x7RqJ84LIcJxdIiM8XBpsHgrnJGDKkchTIW5ZnAv3+hmU" +
    "lO+uYTNCLIdKe+n2gcTxmn3CVl/l4tDNQ/x984CdWUsuuYiPAyw8CblALpBL" +
    "2eWysjcAuchmL2Q9yAVygVzKKRdbG7lO5LK4G3KBXCCXssplRU9AcpEJ5ulB" +
    "yAVygVzKJhfZrMV0I9eZXOirjM+dTmFY4LQDuDyGDeIYZtA9PiXPBXv8DErK" +
    "V7l9Qi7HXsP29YVBH3E1pmzPWqzIRSYY+qYs5AK5QC7lkMs2B7MWZ3JJnb1A" +
    "LpAL5BKcXFb32p+1WJOL8uwFcoFcIJeg5LKzwbwT+Z8jKlQu9C6Inac1GUqy" +
    "43Qc3d+1Y1BJQ4xB5LQkLoWyzvM0KCnfHYp1o1JWn+VQjVFW/zptztaLC07b" +
    "Hw8rHc1arMpFNrV6ZghygVwgl1Dlst3hrMWqXKzMXiAXyAVyKUwuqxzOWqzL" +
    "JffsBXKBXCCXQuTietZiXS7Su3YbAW8fnGUozrbBONsliMfQZbMsEnkwv29X" +
    "OCeBZkyq58zxNCgpX6WYFet/rqdyUL7bVcvBlIvtEwppavcr3T40aN53XdzX" +
    "4lwustnLk32QC+QCuYQily2SJ59LIRfZ7OXRk1H0LOTCnrPx5+ZAV+ItCcIx" +
    "cxlax1G+NuWy6Wc+bzGGLBLnCOVu/Z3yhVz4NMQ3GrgQizO5yASzsgdy0T5H" +
    "s6PpltVGHib1qzvg2H5jQQR1kcuTfW7uxvUql9aNdfTt2coxIOAgj60CZcnD" +
    "JM2yltV2PxJj3DqQRCd9eqhY3MR1NWtxKheZYOiN4pAL5AK5+JHL8p7ixOJc" +
    "LrLNXfoELOQCuUAuxcplY38xm7iFyUU2e1lwsjk9g1wgF8ilOLl0dBUrlkLk" +
    "kvYpEroc9vSgwECSLSKDAgN6qOShGwN7/IDaMZlxCnWlWrZcebpIY1Af3TZW" +
    "6iODepi0h25ffdoAlfqQ3YnrahPXu1yI9acgF8gFcnEtF3qvdZGbuIXLRSaY" +
    "xzohF8gFcnEtl2U9fsRSqFxkm7tUcMgFcoFc3MhljeSeFtvPDwUhl7TlEX06" +
    "cnN/BgMCur+rMKCJQR50j087ReTppK4003xKQCUG9hyBxPEq7cGdo1tXsrjE" +
    "Ns/btxVo5bWh399yyItcZIKhCtgIuUAukItVuYifZG19V6zScpF9LpL2XyAX" +
    "yAVysSOXpT1+l0Pe5CL7FCyxtBtygVwgl7xyke2zFL0c8ioXrf0XyAVygVyU" +
    "WB/APksQcpEJZm6jYjaciqKN7fRnQ8e3kzjmlALcOf352SCgHYNKTMIxGxi4" +
    "NKXnieWwEXfeNnaRpliX/dk4yZNrLwF6tYnvfZZg5CK7PL2oE3KBXCAXXbks" +
    "6Q5jnyUYuaQtj6iiIBfIBXJRk8uqnnD2WYKSS5pg1vRCLpAL5MLJhV7+NPdE" +
    "eGIJRi5p+y+r+5qVF+NUNusZpOf1MXDHn9JHKS7N47XLrltuC3HqltuIPv2y" +
    "6dbVegEbbczGKObZF94+S5Byke2/kGDWQS6QC+SSkEuaWHzvswQpl7T7X6gC" +
    "10EukAvkEsvvsc4w91mClUva/ktMMJAL5FJzucj+CYcmliDlkiYYukRNr8h0" +
    "wVqBIs5fy/BEAdQlz8rQG0UdneUQS7BySRMMvaoPcoFc6srS7vKIJWi5FCkY" +
    "yAVygVhqJpc0wVBFQy6QS11YlnKTXCiXnEsrlzTBLO5uvmR4jcBqAe53E3Tz" +
    "lEH38MTg8hWOX2OhbGsMyFsXLmJg0+yToJtmzvONaOSzvFd+k1zoYimNXDan" +
    "fDibBAO5QC5VlUuaWEK6l6X0cskSzJJuyAVyqZ5c6B9nmcVSKrmk3WTXepMd" +
    "5AK5VEUui1M2b8skltLJJUswdB/Myh4JvQI9CnDnuEiTO76IPHVj6HUUQ964" +
    "FaAPhbXD5bmKwVZcaf27bGIppVyylkgLT0bRCsgFcimpXBZ1VkcspZVLlmDm" +
    "i4KBXCCXEsglTSxFfHYVctG4TB0TDOQCuQQsF+qnsqeby3K5udJySRMM7bTT" +
    "laTlAsskLOfoERDT7OFZzpCIiclTmo7KMXliMMiTS1OpPXTTtNAeNuqGy5P+" +
    "Nr+iYqmMXLIEs7gLcoFcwpML/eNLE0tVxmRl5JImmNaVJMgFcglFLrRBK7uH" +
    "pUpiqZxcsgSz4KS8I0MukEtRciEWpmzcVk0slZRL1r0w9N/iL12QC+RSvFwW" +
    "ZyyDqiiWysol7Z28/7sfprO55m2xVGAJg+7xD8/pirNEhMuDOX6JQdxcOZaa" +
    "xNHFoHA8G5dQl0u79WHj0GzzRExtadAd5HNOVOsellrLhVsm0X8RyAVycS2X" +
    "RzNmK1W4IlRruWQJhv6bPN4FuUAu9uVCy+95J+q1DKqlXFSWSZAL5GJLLnVd" +
    "BtVWLirLpI7Z/zgAaNMQyuMN5p+o7zKo9nLJuprU+owJBgvQhfrNnJovgyAX" +
    "5sHH1iVruvEOgwZw0BIoa2+lTssgyEVxmdRaKj2OAQRSWJBxJaiusxXIRWOz" +
    "t3V3L/2HatEh0sXTfr4KbB6dPNp5KJzPxaGbR4dCWdlyGNS1dtm7/mRBZ/YS" +
    "qM6zFcjFYBZDS6VHT0IudZbLooxngjBbgVxyS4bW149BLrWTC7cEqtuVIMjF" +
    "4VJpfvssBnKppFxoU3/+SSyBIBcPs5jWTIaWSws1WSSge/yiTgW4PDqzWaQQ" +
    "Z+J3MR2DuuHisp6ehHnMTAVLIMilMMnM1ZQM5BKmXFSkUub32kIuJV0q6UgG" +
    "cglHLo8qSgVLIMglGMksgFyClgtJhbv6A6lALsFKhjYD582KRof5DAtOKHDS" +
    "AUweiTg1z1c+RidGAWoPFalg+QO5lGJPpjWbmQe5eJHLfEWhQCqQS6klM2e2" +
    "o8+HXJzKZf7sLGUOpAK51E0yWcsmyMW8HDpCwSVlyKWSr3dIiIaWTnTvzOwS" +
    "Kot5EuYej5P4nUvjeBwuhrmSc7g8ldJkSDtPRyiQCuRSy9lMa0YzB3LJlMsc" +
    "CAVyAervklGVTd3kYjo7wV4K5ILL2QayEQdj1eRiKhPcmwK5gBz7M2l7NnPa" +
    "925KIpc5AnnqAP0IcgGW92jqCvoJ5AIgGyvgvSmQCwhwUxgyAZALKHyD2DfY" +
    "gIVcAJZV2CMBkAtwswTDfSMAcgEAQC4AAMgFAAAgFwCAH/4L4wzvWKe6y4cA" +
    "AAAASUVORK5CYII=")

PAUSE_ROLLOVER = ("data:image/png;base64," +
    "iVBORw0KGgoAAAANSUhEUgAAARcAAAEXCAYAAACH0wDUAAAiA0lEQVR42u2d" +
    "edAXxZnHE2+NxsSNVzxQY9RovEWQW0C5BQEFORRFBQQEBRQVBQXxfAORoKCo" +
    "KIioEDUq4m1A8V4xeOBqrZYm7m5pbVKJ2aOyVb3v448f/KanZ57unp7pOb5v" +
    "1fefd/rupz+/7me6e773thDfgyAIci00AgRBgAsEQYALBEGACxqharpxsRCX" +
    "z9uiC68XoutFQR3Utzng8bx+fHI47hmXB9Mnod0BF6gkevi52qCmgU4DXgcU" +
    "Wen4YVsAtPC3AA/gAuV6FmIy28ir6rMgzHYAF8gTTOhXnwZikUFiojpw0P+A" +
    "C+RQtGxIEybHDxWiy5igLvt1WM+8tkWq53IapLRmN9QeBFnYB+ACGcKEHKyu" +
    "ljjk36gDY/Y9zXBYJ8TX/ynEP/6h0P9ZSDMNgtIdK2rlGHhZrVyADeACZbDU" +
    "STLYaIB1Hi3EyJlCTJ4rxKpXhVj3ByH++38N9T+SdMLoxInRR5/VykvlJlE9" +
    "kszSCMoADeBS+bc59ItrC5MBU4SYdXfz4PxX+4GdB7jEQWf+wzVgHniava8G" +
    "b6MAl8qIljymv8yNMNk8I0ljYOcILnGwsZnZULsT0GGDgEupRG86TH0otDwI" +
    "wERnkJcYLrKoXah9CLomsKF+wJsnwKXwjlmTzWs/7iTEedcKcf9TQvzt7xr6" +
    "r7C+lRQKw6T5rSRVHmyaTHg5j29V5TZMk7T2XSEu/VWtHU2c3fDPAC6FgorJ" +
    "LOX0yULctlyIL/9DEyqACysCNIHaZNmJ2Qzgkus3PrpQOXaIENfdJcSGTw2B" +
    "ArgYlYmATeA+eRQgA7gU1J+is+Y/sE9t2v7Ku5sGblIBLvpl+nsN5NT+1A+A" +
    "DOBSCqjU/SihgQu4ZAqXRpF/RnfZRG+ZYO+AS66gMmKGEOs/FuLPf01Jf1OI" +
    "ifMXSU7y/WsOxJUpoq2ofyY2CfGjToAM4OIZKjq/dKlDBXBxBpe6Pv8KkAFc" +
    "PO2k5Ry1ZJRknJlABXBxDhdTyNDMFa+wAZdE4vap1KFCRul9QAEuieHSCJkZ" +
    "C4U4oA+/TwbjBHBxugQiqFx8ixCffinE13+G8qZv/hJUkrSalvKQwZslwEVL" +
    "3BIIUKkWXOq6ZkH8comWSjgkCbgoxZ1Q7nhhs+F8iIFbVbiQ6Efl7On8SWyM" +
    "J8BF69Uy/Vrd/TgGLOCyRStfwFIJcGHEXdA07mYhNn4uxL99UxJ9zSiLPL8p" +
    "j8g+4pZKtMQGXCr4ejluttLhgtq1jGUaCIBLOnrjfSH6XBL/I1XV19Z4EyQt" +
    "gW65v4RQAVxSF/1gtegdbVvk0wNcKroMGndT8xLos3IPAMAlm6USlkkVgkvc" +
    "MohmKwtW1o7nO9O/K6QTJi58GkqhDH+UxOZpGyZJGRR5/FGScRkawq56JX4W" +
    "U5VlUqWXQUcNFmLdexkNWsClMnAhvf+pEL0nVnuZVNll0NgbGeMDXACXBHCp" +
    "x7lyfnWXSZVdBrHGB7gALg7gQqLvMlVxmVTKO2yjOvHIQUKseVeIz76S9CdJ" +
    "XzGSwn8uSRXnc1kaceLif5aBPtfJl2s707Z1oT9pyLCcof7SqVfD8/f+RYhe" +
    "E6p1lUPpvgkU1XljbjAwRsAFcHEMl3qYOB9g2QBTerDs2lGI+Y8YGiPgArik" +
    "BBfSE2uF2L9X+a9xKPWhw8hlEOACuHiEC+m9T2r2WWbAlPaN0C/PFOKdj4T4" +
    "9IugPlGITrs2KhTmS0lfWOhLRl8kl1wPtu5MGULp6ZTbtF5fOoiTQh5J204r" +
    "TPP/Bl9Z3jdJpQRLj4trYNEyEsAFcPEIlzjA0BtPwMWDol41D77C0EgAF8DF" +
    "M1xIo2aXDzClBgvgArgUBS6kWXdHv0kq4i13pQHLrEWWRgK4AC45gUvZAFMK" +
    "sNB3l+lEM+kjTp8r9Fn22ijJ9HkWZbBJwzRNuowrJNNyeejPjQ7qHqUVL9S2" +
    "UBQdMIUGC3XA3GUJDRFwAVxyBhcOMIBLyjfyU8NTByQ2RMAFcMkhXOqAOeLM" +
    "4jp5C/m6uQ4WqwECuAAuBYFL3AymCIAp5D6W6QuF2PCpR30iSSPO+5K455w2" +
    "lETvO6h7Fm3jIg/bej70nBowed9oV7izQt7BArgALhnDpQ6Yoh0VKBRYLmnK" +
    "yaAAXACXjOFCoh/WIgGmMNdS0uFE3YEMuAAuZYRLHGDyeF1DIS56GnCZEO9+" +
    "XNN6WRuDqoeL1EaFTON87EAplGE9I9Myym37nZg0Q883MrKoq+t66pSBs7P1" +
    "Gy1s0VLnXlsMwOTqakpVg7UewRgW4AK4VAwuJPrBzfuVmbneJHf4GUKs+WfA" +
    "BXABXEwAA7gwr5xVYAFcABfAJajDB+b3FXUuHbg/7CDEkqeEeOsDhT4M6u0P" +
    "gpKf2yiUJlMGLr5NuZKW4TuZxvlAQ0yctz8MykV/sWnKkttflYZNexqUSas9" +
    "TW1TkcaLzYNo3x75/C5SLv0s9K0X3Q4BXACXKsOF/r9kVT79L7nzs/SfbNYh" +
    "gAvgUnW4kMbfnD//S678LL9oXj+++BbgArgALqZwIXW9KF/+l1z5WRY/IcTr" +
    "fwjqtaTaoCEpTqgMGxxIzmNDUFx4F/Vi65mGuDLZlFtuO8PwqvZm+9zGRrJo" +
    "qwY9+4YQ++TI/+KHaIrp29R54Q4DXAAXwMWsz+kHOi/+l1z4WfpNUncw4AK4" +
    "AC7mfT72xnz4XzLNTLUmPGxAbToHuAAugIsbuJC6jPbvf/F6bmiXDkIselyI" +
    "tes36V1er0ham4bWB8Xl+cp6STrllPJwUk/DcnNlyETrNcotP5eUSb08tBXX" +
    "Dmtj6r5qnRA/7R4ec+TvLB1cVMuhKbeZdxjgArgALjxcSPTD7XN55O1+lpNH" +
    "2XUY4AK4AC56cCENnRYee+SeKA1cVMshulkLcAFcAJd04UL/Uy2PsvhEiZfN" +
    "ckRT2w4DXAAXwMUMLnOW+bngO9XE6d26XKlD+wvx8ts1vZQTvSzJ9DkX/mUH" +
    "ZXgpozTSziOLMualHnmygU4XZu/czdyJ27QUcAFcAJesbWDZ6po7IkvnbqZO" +
    "3D6X5MOwABfApWpwIQ25KtvLvTN14j65BnABXAAXnzagcu6mdTQgs8+vXjBT" +
    "iOdel/SGhV5nZBH/eUmJy2RRr+clOWmbNxJK1VZvxMs0TZ00nLRN0va3sDvn" +
    "5dboDy6Nm+/LzrmbyYnnQ07fNGgBl1jjpl+adz5KoA8lacajXzSXcHnpbfdl" +
    "TFQPwCWgXhOy+XJAJk7cOx4BXHSMmwaIjz/K1yVcclcPwCWgR18SYpf26Tt3" +
    "U5+1DL6iYdACLoAL4OIdLqTzZ6Y/e0l11kJ0fOQFIZ5eF6FXJa1zr9WSQnm+" +
    "al6O1a8G9bSNFOm++YGfQUn5Kutl0+bN8d583289uP5abdE/ITvSyWNd9uLK" +
    "2VjHvbulO3tJ9dRzz4t5QwRcABfAxQ9cLr4l3dlLqm+I7n0CcAFcAJe8wiXt" +
    "2Yu/WQvgArgALt7hct516R0LSG3WsuhRIZ5YK2lNvJ5UyDROKIxUhidVMswz" +
    "VIa1vLg49D+6QczHH92k9uQa8/56IiKOt3psULe1TT1CtsjYjJYNGOZhVQ+N" +
    "/mnU8meE2Ll9OvteUpm1dB+vVzHABXABXPzChTTwsnRmL+nNWgAXwAVwKQRc" +
    "0pq9OP8c6+ZZC+ACuAAuhYBLWrMX57f5X3eXEI+9XBPtBHStxxiFwr8cVBZ5" +
    "PvqyQkya9D+6+MjHH+X7qE69VGEU9fRdD53+CPUjYyfGNuDAzlKxzYj4D6xy" +
    "P3txevL56LOSD2TABXABXLKHC2nAFLcnpp3e19I4awFcABfApVhwWbjS7X0v" +
    "qc1aABfABXApFlxI3ca621Tn7PXz6NlCPPJ8vFZIeiQFsXm8oJBhGisY2ZZ7" +
    "zTt+BuXv37HvH1Wc33uqB7XfirzYWU7SNNVN97tz7Dpz5N73BOACuAAuRYcL" +
    "jYc9T3XzGVgnS6JTLtJrDMAFcAFc8g+XfpPDkwfadpI6XFSfC5k0B3ABXACX" +
    "ssBl/iNuTksn3pFL78Z1GwNwAVwAl/zDhXTU4OSO3cRLor6X1rYPkx5ktFzS" +
    "gynE4cIvtyyHkVYrpBHmxTf9DMoX39Jry+Wa7U3peanHmxFtnYJ0bCipndnk" +
    "4Wq8XDAr+SdgE+9tueFewAVwAVzKBpdFjyf/gH2iaywPOs3twAdcABfAJR9w" +
    "IXUZk2xplOiQIn3BDXABXACXcsJlYlOy4wDacDnj8nBGv3pAiCWrorVU0pKn" +
    "GK1yr6VPBaWVr/R86SpGNnko2opub/fxR7fBa7eVhuhWep/14PpT1aes3awy" +
    "s/WlFnakkyYXJ/H4kJ7/oJ39nhdrR26rc8wbHHABXACXYsGFvu9uuzSyhgvd" +
    "vQm4AC6AS7nhMnOR/dLI+mNn3JIIcAFcAJfiw0W1NCIXiTO4yGeJ9ugqxOLf" +
    "hUWfEmlU6LmkxRqS0+TExleUwzQPrh46cUJpNId55jU/g5JuiY8qEydVPEov" +
    "V/XQsTPGJtjwGu1nnIeGDYXyMLQ7HZ14tt0lUlZLIvqQNeACuAAu1YDLmVPt" +
    "/C5Wr6DH3gi4AC6AS1XgMuNOO7+Llb/l9ocBF8AFcKkKXChdG78LCxe65q4x" +
    "0Ra9hbjrUbUWMbrrsXgp4zB5hJ4/FpRWGZk4pmWw1VOv+BmUlK9Nf6rajv63" +
    "ylM9KF9lf6jsLYM+NbVlqzJwY4izbc0x2OECc7+Lsb+lx3jABXABXKoGl+HX" +
    "mPtdjP0tdJ0l4AK4AC7VggsdUDa9/tLY3/LrBwEXwAVwqRpcSLt3NTslbexv" +
    "uWNlg1bEa4EkNvxKhVbE6w5TrQwrlObK+Hq6KJMqzu/W+BmUlK9OGXXrlrd6" +
    "2PZHkucLVrgfH7p9ZFpOXbU/32xpZORv6TYOcAFcAJeqwmXYtBThMqEJcAFc" +
    "AJeqwmXWIjO/i5G/hRt0gAvgAriUFy4keb+LE7js1FaI3zwU1DxJrp+rwpjq" +
    "N8uDmqeZb5zYPC3bgr6A5+OP8rVu3wLUw6oPGbv5TQpyYVcuxlycDhug79TV" +
    "PqxIiQIugAvgUm24nDpWfzOd9n25lCjgArgALoCLrlNX25kLuAAugAvgMv7m" +
    "FOBCiQIugAvgUm24XHun/veMtLf9T54jxNxl8Zoj64GguPBzbfSAJK5MOvlK" +
    "ac5Zllxs3ZvzWfmCn0G54oUtZeDqrdMfXuuhsoEHNGzR0Fa12kVuT1kWbWua" +
    "Jium3irpvo7Wfg2tkyngArgALuWHy3499a5f0PqMCCUGuAAugAvgQjrmrCAf" +
    "6JiQNlzk19CH9gdcABfABXCpSfdLjFrO3M6jhbj1fg0tkWQY/pb7zcXloZXO" +
    "kqBuZXQLI6u6Nv/voef8DMqHntVrl1sU5Va1ja96PPysvl1xdsLagEZbmdqN" +
    "lh1xY44bgxZlktMYeLlDuFBigAvgArgALqQLZzuEy6jZgAvgArgALpvaaone" +
    "GyMtuNBX1wAXwAVwAVwSwUW1x+XGe2vX3IW0OF4UL7EWBxXK514zqfLQCRMX" +
    "PhR/Ma9QWzXrwWf8DMoHV+vVW6stPNfjRg27tLFN1vYt7MDUVm+4N7m93+BC" +
    "iy3hotrjArgALoAL4NJY94NPB1wAF8AFcMkALqqNdIAL4AK4AC6J4aK614WF" +
    "yz49hJh5d+2KO04zJXHPfWjW3QoZ1sNG1IYBKfJYusrPoFz6tLodbPqc6kbp" +
    "eanHKn27c23LadmEcfsnHIPKfKTxQuF+1tcBXH7WD3ABXAAXwMUBXOSt/4AL" +
    "4AK4AC4yXDqcD7gALoAL4JIBXFTXXfJwaZ7+zFgoxHQLzTCUizxMn093UA6b" +
    "PFRx7nvSz6CkfGcstJOqnr7rkdQObW0xC1t1PcZs26LdSP4IAAsXSgRwAVwA" +
    "F8AlMVwO6gu4AC6AC+CSAlzkCIAL4AK4AC6yzr7GAVzanCfEtNuFuMpC0xi5" +
    "SGPafEm3J1eoHPODCoVnnk/TTOOex/0Mynt+Z9e/Uf1D6fmsh41NyP1j2x4m" +
    "dsPZnVY9mDBpjcmh0wAXwAVwAVzyAhe6DxNwAVwAF8Alrs+JC4nfFh03FHAB" +
    "XAAXwCUFuBx0GuACuAAugEsKcDmgjxBTb6vd1yBrqqzbguLCs+mp0pQ1L15c" +
    "elN10pDj2NRDI86iR/0MSspXp146fUi6y2c9NMvI2oBkZ8Z2qWP/TB6sHVqU" +
    "y7TeUfVqPUKahPQFXAAXwAVwSQEuVqeiARfABXABXOR6ERcSw+VHnQAXwAVw" +
    "AVxSgAtp0pzah+hZzQ2K4sUpFF4lOY5hGeTnynIYatLceE2eq1E3uRzN/1uw" +
    "0s+gXLAioj/mqMsZV1cKQ+n5rAdnZ1r9YWgjkxyIK+NkHaUwPkLlaP5fi96A" +
    "C+ACuAAuGcDlwusBF8AFcAFcHMBlr1MdfbcIcAFcABfApREuzr64eO61Qky4" +
    "NayJTUGFnksKpdEk6VY+DTZNLo8mPl+5Xqb1mGij5nRuf9jPoJz/sH5/hOqq" +
    "6BNf9aB8tWzi1uR9Hqp3k0YanN1xtt5kngZbb43wqrI4g0v/KYAL4AK4AC41" +
    "jblB8fmhxZZwoTtdABfABXABXEgDpvBb/7XhcsJwwAVwAVwAl5p0bqGLhIt8" +
    "BGC/nkKMvSmscYYay0gnTijMzUGNvclcpuW2qadO+8xb7mdQUr7jLNtK9dx3" +
    "PVz0Rxp9nnT8uBhTps9Vkq9lMYILvbNujLhrR8AFcAFcAJeaaLLBbaCLhItq" +
    "rwvgArgALoALaY9T+I/QR8JFtdflzKmAC+ACuAAueq+hI+GicuqeOlaI0bPj" +
    "NYqRaXidOKbPR6eR5vVBjbIoB4WZs8zPoJy7zG1/zC1JPZI817I9yW5c2LLN" +
    "GGPzaCjjQMWbIpqMJILLsUMAF8AFcKk6XPpM1HPmxsJF/jja4WcALoAL4FJ1" +
    "uNAkIzFc5NfR+/YEXAAXwKXqcDl8IH+9JQsX1RujkdcFdf5MSdcFNXJmvEzD" +
    "j5wZzjNUJllMeGU9EkpZdjlfRb2alvoZlLcu1Wt7nf6gNm9a4qkeS+z709Qm" +
    "tMLL9s3EsbJLZgyxtqmRZ2P4fXrovYaOhQudFZDhMvxqwAVwAVyqDJftT9J7" +
    "UxQLF5VTt/NowAVwAVyqCpczr9A7sGgFl6MHAy6AC+BSVbi0PFvfmcvCRT5D" +
    "8JMugAvgArhUFS4HnhbkwY9PTgAXlVP3rCuFOGf6Js0IasT0eIXCa0iOsznv" +
    "qDLIksuhkweTplwG0/RUbUX/u+k+P4OS8lW2rUJce1IYr/WYbmdXof5g6s22" +
    "i41dcG2vYd9Jyx2Xr+xvidr2rwUX1dLopHMBF8AFcKkaXPpcYuZvsYLLIf0B" +
    "F8AFcKkaXOhOJxN/ixZc5M10u3QAXAAXwKVqcJE/gsb5W7TgovK79JskxLBp" +
    "QgyVNEzS0KvjFQqvkhxPzvPqoLgy6WgoI9Pwqnqo8r3hHj+DkvIdptl/OmFm" +
    "3+unHpSvTpl1bJerZyjM1Q5sMQVbVpUrTlHtt31rM3+LFlxUS6PW5wAugAvg" +
    "UhW49Lw4PMFY+NuU4PLz0wEXwAVwqQpcjhti7m/RhkvI79IecAFcAJeqwGXv" +
    "bvqHFY3hojpn1HuiEIOviNcgSabhB9mkeaWkK5KXM1SuK4MabFk3Oc9Zi/wM" +
    "Ssp3sE5bXqnXdt7r4cAGuD7Wsm3DcujYSOIxxtmuos/lsa/6LrQ1XJRHAc4C" +
    "XAAXwKXscGk70s7fYgQXevXUmMFuJwMugAvgUna4HNzPzt9iBBf5cyOkPhMB" +
    "F8AFcCkrXAZcJsR20itoOm/oHC6qpdFhA4QYeFm0Bkga6EADGNnEN42TVj2v" +
    "vdPPoJxxp169BuS8HpRvWn1uagMDPNkum8eUeDWGPW6Y+ZZ/a7jI9+ru3A5w" +
    "AVwAl7LCZd+e9ksiY7iodut2uABwAVwAl7LBpbti45zOrlxruKiWRgedBrgA" +
    "LoBL2eBy5CD97xM5g4t8gRQ5fPpOqqmfofpeGlS/SZ50KSO53Ixsy3HNAj+D" +
    "8po7avXsq1G3UJ8p2spXPa5eoFfmvpfyfc7aphzewi5c2U2sLVum86NO5gcV" +
    "E8NFtaHumCGAC+ACuJQFLp1G2W+cSwQX1dKIPjcAuAAugEs54HLI6ckcuYng" +
    "Qo4dOfNTxgIugAvgUga4/KCd3VkiJ3Ahx44Ml18MrJ03alQvSb0nMJroQBPc" +
    "i62Ho3JfNd/PoKR8bfsj1DbNuup2z/XQsQkuzMQUlNQWNds/8HxCUFwexyv2" +
    "tsR9m8g5XFTHAYh2gAvgArgUGy4tertZEiWCi+o4AFEPcAFcAJdiwqWzwpEb" +
    "97nW1OCicuzu3hVwAVwAl6LCpUUv+xPQzuEiXyL13RWYIwAXwAVwKRpcVLMW" +
    "W0euE7ioZi/0Vcbu42rqJqn7eEnjUtB4CzFpdhsflBxfrqccXicO5TN1np9B" +
    "Sfmq6tltnEbdclYPrf6xsKtujGziqOwkYDM66XF9ppnmfj3dzlqcwEU1e2k5" +
    "HHABXACXosCFzge6nrU4gUvc7AVwAVwAl/zD5aDTkl2tkCpcomYvgAvgArjk" +
    "Gy5dxgixbavk54hSg4tqU92+PWqvsQIaY64uFwUVei6JTfMii3Ix4eUyyGXu" +
    "oln3Kb/2Mygp3y4XRbSNJLaunuvhsj9MbKLLGD9KOh7kLykm2TSXClxUF0mR" +
    "6HJfwAVwAVzyCZdOF6Y3a3EKF/Iss7MXwAVwAVxyA5c0Zy1O4aI1ewFcABfA" +
    "JRdwSXvW4hwuqtnLHl1rFbFVR0adciCbMqnqcumv/AxKytdl3YtYj6R9nIZt" +
    "ukgvKo39e6U7a3EOl6jZyxFnAC6AC+CSF7jQLnp5jCY5oJgZXFSzlx3bCNFu" +
    "JODC1Yu2b9MAyVq0Tdxl3XsXsB5VgstuJ6c/a0kFLlH7XmgaBri4q1de2iJp" +
    "GVzUPQ/1LApcaBWRxm7czOCi2rVLOmFY8wzmvAaNLInO05AUp+15QXF5tJWk" +
    "Uy7TODZ5sGka1jOtcrB5MP3FPk/BbuQyym3Z1rActBzaplXyW/29w0X1jSO6" +
    "URxwAVwAFz9wUX3kLMl9Ld7gEuXcpU/AAi6AC+CSLVzoCx1ZOHEzg4vqWMAO" +
    "bZqnZ+cALoAL4JIlXOTvEKXlxM0MLlHO3Z92F6LViNoaMKBzwmolSY7TSlIo" +
    "jRHJ1YqRqtxcOdg0LcpkHIdpW516sWl4UCuL9mXbkrMriz53UleNPlSdek7L" +
    "iZspXKKcu78cBLgALoBL2nCh2wm2OTHb5VCmcFE5d3ftCLgALoBL2nDZp3vy" +
    "D8rnGi5Rzl2qOOACuAAu6cBF9eVE1+eHcgGXqOXRof1r+19Ixyt0wnBJwyRJ" +
    "z0PxdSSnIYnLQytPJg8uT5t6sPUa5kCG5bQqw3BDuaiHod1ZlcvUtnXsZJOO" +
    "GqxeDqXtxPUGF9W3jqgBjh0CuAAugItLuMifZK1/VyzTyUSWmZFUn4v8YQfA" +
    "BXABXFzBZe9ufpdD3uCi+hQsiRoEcAFcAJdkcPlZX/VmubS2+OcOLnSzuKoB" +
    "DukPuAAugIstXPLgZ/EOFxK9DlP5X44cJMQxZzVoiKSzGJmG14ljk6aPPBgd" +
    "LclJPdIot5RmqNxDksu4LeT4klLJ01A7tfXvZ8kFXKJeT+/SAXABXAAXU+15" +
    "Sj78LLmBS9TraWoowAVwAVz0pLpo25efJVdwifK/HNwXcAFcABdOhw/Ml58l" +
    "V3CJ8r9sfWINML88062OUMg0DpvPIIVMy8rEP2JQWEnTdJJH0rbzlGYWOoKR" +
    "aXoEFrpCNk9+ltzBJcr/QoChBgRcABfARQ8svv0suYRL1P4XakCXgAFcAJcy" +
    "wIUO/ubRz5JbuKi+HOAaMIAL4FJ0uKhu7yfR+MnTeM4VXOIAQ0cE6IpMVv0l" +
    "acQ5VNJhhgrF78+X41BGh2WgquTpyk68q7/6RjkSndvL21jOHVzi3iBRwwIu" +
    "gEtV4bLXqcUBS27hEnWCWgswgAvgUkK47NVNPR6yuvipVHCJAww1NOACuFQF" +
    "Lvv0UI+DvLxyLiRcoi74Ju3etXYC9OB+ZqI4skLh+kpK+tyinGnkEaq3RR7O" +
    "205HTBrG9VKl0S9exv3lwDbpf/v1EmLrlsUDSyHgEnUHTB0wgAvgUla4RIEl" +
    "T3tZCg+XOMDscQrgAriUDy70w1lksBQKLlGb7OpfEgBcAJeywIXAorLzIoGl" +
    "cHCJA8wu7YU4oLdCfST11hATp0WfoHTyYONIssmDS9O43n2SpxmqR28H5UjY" +
    "f1Z5WLRNi95B6dQ9aoNc0cBSSLjELZHoUuL9ewEugEsx4UI/kGUBS2HhEgeY" +
    "7VtLgAFcAJcCwCUKLFl8dhVwMXhNHQAM4AK45BguZKeq081Fed1cWrjEbbTb" +
    "qmXtRrt9ezhQT0nMc9r0JGtf1+qpUS6dODHl5sLrtAVXplTayrRdHPS5Tt1C" +
    "z7sLsV3rcoKlFHDhAEOed8AFcMkbXOiHLwoseT0rVEm4xB12rJ+oBlwAl7zA" +
    "hRy0W7UsN1hKBZe46xpIO5xUm4YCLoCLL7iQ/e3cLtpG83DvLeDCACZqL4z1" +
    "MglwAVwSwmWPmGVQHi96AlwM7+Sta+f2tZPVUdpTEt2jESs5jVMdyEeaNnky" +
    "cfaUtFcFRTvIo5ZB9EOYp6spAZcEXxXY/Lr6pE3GDrgALimJnLaqryCW6Y1Q" +
    "ZeHCOXrp12S3zoAL4OJeP+kixLatquNfqSRcbJZJgAvggmUQ4OJsmUTONrpC" +
    "k35xKqPOjHTidIHq7bJbp9ru8KougyoNl/oyKeptEonWyP/UGXABXMy0U5vm" +
    "2coJ1V4GVR4u3MHH+pceaeMd4AK4cKIl0DYxvpWinmgGXFI6NtC4VKL7NQAX" +
    "wEUWzW53aBNvP3Swtsrjq9Jw0XH2fre7t9mIdu1U88lYq6OkTimoo6E6FUO7" +
    "SvJdjx2ZJRDNVsq4KQ5wsRStieMAQ/eZ0mVUgEt14bJL81J5mxPj7aRMZ4MA" +
    "l4zuiGlcKv2wI+BSJbhQntwSqGpvggAXS9E+BG6pRDt8jSADuBQOLtS/1M/c" +
    "EojeQGLcAC5Ol0ok2oW5Y9vaRrzNaudA7Zk021vINI00ym2TRtI0DduJlr9x" +
    "u2uxBAJcMlsqkWgtvhkygEsh4aILlSLfawu45PQqB26ptBkybQCXIsGFfhR0" +
    "oEJLoCpuhgNccggZuqAKcMkvXAgq3NsfQAVwyS1kyBlIv4rbt6m9cbDV9pII" +
    "XKxM8znJgUzT1CmH43pQf2zdUm/5g/0qgIvXN0s6Ppn6sYJtWwMuPuCyXSu9" +
    "WQqgArgU1vFL+v4JNUPf7iTAJU240AllaufvnwCoAC4Vg0x92bSNxrIJcNGH" +
    "MC17tmqp3wfUX1W5YwVwKdHByLjrHVQzGvIF0K8tASegEyW10giTVK00xMWx" +
    "ycOinLTkNAEK9qkALqXxy8RdVBUFGhosW58IuKhEEKb20V3yNM5SsPQBXEp7" +
    "WVXcXTIsbFpWEy62MKn7UrBFH3Cp3PECndfZWjObksGlvsyxgUl9bwqWPYAL" +
    "ZOGfiXIOb9VSmuHkHC51iGzVMhlM6qLlJ5yzgAsUs3QyeeNUZVE7Yfcs4AIl" +
    "WD4BNlvuTaH2wOwEcIFSgo2NUxgwgQAXyHgZVZ/d2DqIfYv8TfUlDpY5gAtU" +
    "gP01NFDJWZyXZRWVg5yumI0ALlAF4COLANAoeQlGsyM5jCodwANwgSAIAlwg" +
    "CAJcIAgCXCAIgtzq/wEqL7osxHypYwAAAABJRU5ErkJggg==")

PAUSE_DISABLED = ("data:image/png;base64," +
    "iVBORw0KGgoAAAANSUhEUgAAARcAAAEXCAYAAACH0wDUAAAks0lEQVR42u2d" +
    "aVvVyNaG3///D44yCTLIIMgsyqDMIsgsgiiDKIrattNpj92dN2vD1tSqSlYl" +
    "O9mZHq/r/uBOpebcVFWSyv89dpz/AwCAuEElAAAgFwAA5AIAgFxQCWXn4cOH" +
    "zsjIiEJnZ6fzn//8R6SlpUU79969ew7qFaASCg5d6HTB24iiXty+fRsCglxA" +
    "Xggz2sgq1VEQ2hNyASmORuhCzLNIwgDhQC4ghzLp6+tzhoeHFZaWlyssLy39" +
    "4tXpaYVTlyX3/xweB5HU6AZTKsgF1LDAGtcUpyoPEsCTJ08qcvjvf//r/PPP" +
    "Pzr//qvwr/sb5x8JFsc///5T4fTVqbOzu+NKa6kih77bfZAN5ALqAS1y1nKB" +
    "kUAePHhQkcjJyYnz9u1b5++//46fnyo//1bh4aXjH//4wzl287vo5nvxagRU" +
    "yyiNpIz+BLlguuP+xY0qk4mJCWdtbc35w704E5FIneTy0ycMlWtnZ6cizKij" +
    "OKzVQC6lm/KE/cvslcnbt+fuxfezvkJJQS4cr2yijGyo3tH/IJdCEvavL00P" +
    "VJlwyiUXfs65O+2j+iHphpENpk2QS2GePQkzOpmZeeDs7x84//vfT5f/BfNT" +
    "5+fPn4FIcf5kGNPgYTR+qvxU4edHySePk3hzfu4sLi6GEg2tc6GfQi6FHaXQ" +
    "X97t7W3n69dv7MKEXMLIxcv+/r4r6plQYke/hVwKIRW6Pby6uup8/PjR/6KE" +
    "XCLLpRru69evFXEPDw1DMpBLPrEZind2dFSG7edv3thdlJBLzXL5Xa6fFZFT" +
    "/Xd2dEIykEsxpELDcxqmh74oIZdY5eLl/M259bQJd5kglwxKZdr58OG98+PH" +
    "XxX+0vihUA3nH17lR+UcFS3MX4wfHHb+Xyo/TPB0eRpCeK0sf/0w8JeClG+9" +
    "7n4wDHXoxvv+/XtnYWHBahEYkoFcEsXmL93MtCoVyCW7cqny+fNnSAZyyeZC" +
    "LXVK6pwf3L+E5osYcsmyXCq44T5/+WIlGazJQC6JP6dSlcoX9y9f8EUMueRB" +
    "LlVIMo8frzodHR14TgZyqe8UiKQyPz/v/Pnnn5U3jEER+Itx+fvm5qYoGVwv" +
    "kEssUyBIpVxyqfL48ePA6RKmSpBL5DeUh4aGnIuLC1yEJZULQX9Upqen8SY2" +
    "5BLPrWU6tre3h4sPcvnFixcvMFWCXGrboGlufs7549Mfzvfv3xnfFL65v4l8" +
    "U+FxfP/G+a7wrZLOb74b4GnIfGOw48ZyfBMQ0vguo9U3rwsx3yy+b98NqPWt" +
    "lzU4Dkp3bm4ucKpU9jewMVoxMDg4WNmW0bezQy6Qy1XatOPf+Pg4RjGQS/Cd" +
    "IBLOxsaG3NkhF8iF5eHwMHiqVMZ9fjENqk6B3CEu7XZmugAgF8jFNg9zc/OY" +
    "JpVNLn7TIPp9d3e38np+knz5+kXh6xfOVxUKo/A1ebQ8xF/uL5XfBL6opFIX" +
    "Uvtpdfe7LU+Oj52O9vbST5NKPQ3q7e11zs/P0+mckEth5UJ8/PAhcC2mDNOk" +
    "Uk+DUu2ckEuh5VLB/f3Ro0elnSZhGgS5QC4JyoWg70gFLfZCLgWYBvX09Dhv" +
    "3rypvGKv8kXlC+NzMPTiopfPX3S+VML5o+WJn+/mQ+WzATUMj1NMk4fX0vyi" +
    "l03Id+jjPvWn1oVK2Pb6bCw77wPB7afnWe833vAf3GnS2NhYqbZyKNw3gfwa" +
    "b3Z2NuBCglwgl2Tl8uUqzuXl5dIIpvBiaW5urnxMK/hCglwgl/rIhTg+Pnba" +
    "fe4mFWkbh0K/dOg/DYJcIJf05ELQNIn6Z5EFU9g7QtRw7y8uKm+yKnwywMP8" +
    "+YmhHv/0ifGnyp+fPukIaXxiaHkQ45PR8inyyZBPHo+Qb63+I5Qj7DkW4T8J" +
    "GPtJYJ+xqz9eN5OTk4W9k1RIsYyNjl6KxdSxIBfIJUNyCRJM3veIKdyt5sn7" +
    "94M7FuQCuWRMLgTdcCiaYIolFvcvgNixIBfIJYNyIdbW1gr1LExhxEINY9Wx" +
    "IBfIJaNyKZpgCiEW+u4yvdFsxScDf5SVT4z65+GTmy4ndDwFa0/a6Y4eoci7" +
    "YHItFmqAra2t2joi5AK5QDDllYtpR36qeGqAmjsi5AK5ZFgwpmdh8rLIm8vb" +
    "zZHFArlALgUZweRBMLl8joW+IfPh48cKtG9GIBTGw4ePH3Q+fFT4+PGDAj+u" +
    "weL7aELKJ6XrRTufHTfEUa2T3/B8sbqgcwIwp8HrjvFRgNf1hw/h+RiMVA82" +
    "dSHlQeoDxjSFvsnbuJr/w8NDo2Cy/qBd7t4V8ooFcoFcyiCXqmDy9qpArsSy" +
    "uLCodRzIBXIpg1wI+sOaJ8HkZj8WejnRVOGQC+RSFrlQ2fwEk8XtGnIjlvfv" +
    "38fDhYGQ51y8V4kjX0nEmcU8XFyoWLXR+xxwUb98z8zM5EIwmRfLwMBA+p0A" +
    "coFcMiQXwm+bEcjF8iG57u7uyn4skAvkArnkTzCZveWciFggF8ilQHIh6DrJ" +
    "6i3qTE6H6J7+/v6+8+7dOwMXChfub17eXTDeyVxcXKjwOFmaGhcqF+90tHxd" +
    "XASi5yG4Hkz5EOuOlVuP06LuBHi55XKZ8vlOQaorG8KWVesjWt3Z9DWpH0l9" +
    "Vz/n7PVr5+bNm5n8LlIm11noWy+2DQS5QC5llguVf//gIJPTo8yts0xMTIRq" +
    "IMgFcim7XIj5+fnMCSZz6yxnZ2eQC+QCuVyEb/PhkZFMrb9kap3l2bNnztu3" +
    "b1XOVc4ZPLx03AhLw+ocb5oMuzDnDB7+XOHtucq5Rbo8jrB50OrlXD+HvrXt" +
    "RcqnFN9lnKwNpfbh6UrlMtWdFke4Ntbr+lzuN1Jf5X1fyMerV68ytf6SmXUW" +
    "+liUzYUPuUAukIt/PugPdFamR5lYZ7l7965/Y0AukAvkYi0XaoO5ublMCKau" +
    "iY0Y5oS3bt1yTl+dQi6QC+QSk1yI4eHh1NdfUl9n2Xu257w5f3PJG5nzN+cK" +
    "Nuckzfm5SixxMuLJ6zkj7PEEODfwJg/EUVfBcWh9wKaurn4/OT0xrr8UUi6m" +
    "6dDS8lLoTgW5QC6QiywXgv5wpzk9Sm1/lqGhoUidCnKBXCAXO7kQU1NT2rVH" +
    "yxOFkYtpOkQ7a0EukAvkkqxc6Le0pkepPCxHNvWrCMgFcoFc4pULfX4njQ2+" +
    "6z5qobtDr8/OKpy9Vnn9+rXImQaL50zlNePMEIcW5uy1wutK3n7D09DCm9DK" +
    "wcou5EHL99lrQz5ZGjb58qCV67XcRnp98zh5Hs5Ezozt7G0vlgY/boMQh17f" +
    "Ujnlvie2D+tnGsb6EvrZVdy0DFHv0UvdF3E3NzYgF8gFcqmzXA4Onhu/IJBL" +
    "uZgWccfHx1knglwgF8ilHnIhJicn67q5d10XcY+PjiAXyAVySUkuRD0Xd+v2" +
    "+dUHDx44r16dMl6JnDK0MKeMV1EIly+ep9NTlWh5qB2eD7HuJE7jqt9w7UVP" +
    "bHtJqz6D8h2lzdNoD57m+vp63RZ36zJq6erquqoIyCUI+msnvdof/Nq/sBWE" +
    "D5RunHIJLAffjsJUDr5Ng2X5fcsBuShpjo2N1eXLAXVZxN3Z2YFcLKALJI1/" +
    "lG6ccslcOSAXJc2XL186TU1NiU+PEh+13L9/31MRkAvkArmkLReClimSHr0k" +
    "OmohO7548cI5OTm55PRU5YRzonPK4Ofw4yyNUzcOL8Y0xDhVpDhPT0415HKd" +
    "VN5qTeMfpXtyYigXb6/TU7k9XN6+fZdOOd69vWqfU5ET375g7qvS+cY0tP7O" +
    "zqF4PYh95NQiTqv+fklbW1uio5dERy00twtqMMgFcoFc0pOLad/dOEcvid4h" +
    "ol2xIBfIBXLJplySHr3Ub9QCuUAukEvm5GL67nSm5GIatTzd23OOj4+DOeIc" +
    "6YjnqBwxjo+PGMciPI4j9zwvx1GQyuWSmlzO317W3bGKqT30+uV1d1TZCS0t" +
    "SZr6CC/X0VU+vYTuJxbtGbr/C2mYyiHFKYU/fH6o3TmK67mXREYto6Oj5oJD" +
    "LpAL5JIpuVAY0zenMyEXv1EL5AK5QC75kEtSo5fERi2QC+QCueRDLkmNXmLf" +
    "zX9tbdVtrJcVXr48YryMwFEgR24YL9r5RwxjPFKa6vHQaR7ZlZU29knjH6Vr" +
    "Va6X+ShHFKp99nff5W1+pPCyhvpJkqhteHBwEPvoJdZRS29vL2sgyAVygVzy" +
    "IBeCvtMe5+gl1v1avKMWyAVygVzyJZfd3d1Y93tJbNQCuUAukEu+5EKYljpS" +
    "l8vsw1nn8MULhReHwRy+OFSg95A4h4cM7ZywvJDh+WRoZWFpHJrQ4jlUeOFC" +
    "m/uk8Y/SPTSUw4ReF4cKVNY0y2Fsj0MDUvuE7MvG/n14GIyUhkU59GuKE66c" +
    "6xvr6crFZLf9Z/uQC+QCueRcLhSGvxIQ9TOwsYxaSDYvIjQI5AK5QC7Zk8vd" +
    "ibuxjF5ikcvi4iLkArlALgWRy/bOdixvS9f8RG5lzxafgkEukAvkkj+5EHSD" +
    "ptbRS82jlrt37zrPnz+vcMB4rnHAeF4I9HIfyGU9UKGHmGiHsDT+0d6zcdYH" +
    "xZdKOV6dXdZnXdo4nTjqhelRk0TlYkrwyZMnkAvkArkUTC57e3s1f8C+pm0s" +
    "aYoUrvIgF8gFcsmDXIjh4eGaRi81TYnoC26QC+QCuRRTLgsLC/WRi+mtyc2t" +
    "LWffvSj8OGDs7+8LHOgc7AejnaPGecAwp8HYD+ZAi/dAIUo5KJ5Xp6epXJS0" +
    "C5q5rizbiNX/aWrleGWua4s2lPtNMAcW5/DrQes3hj6hcKCjX3fhrhep7/KX" +
    "GcM88xJ51NLf3x8oFsgFcoFc8i8X+r571NFLZLnQ3puQC+QCuRRbLqura/WX" +
    "y+bmJuQCuUAuBZeLaWpESySxyYW/S9Ta2uo8e7ZX+XSIlz33Ny/P9p4p7D1T" +
    "4cd5fDbIaQYfj5quwt6eAi+nbVnTuihpx/49U/tEJPVyUBt4MLa50Del9ttj" +
    "mOtiT4GfE/Z62bNKV02T902p75rKQUsgUTaRivzZEMgFcoFcyiEX+iRzlKlR" +
    "JLnMzc1CLpAL5FISuayurtZPLjs725AL5AK5lEQuRJR1F1EstM2dN9KOjg7n" +
    "6dOnV+wp7Lm/eXnK2WM8TYAIaYj5Dh1+z4AcL+3GnsY/StemnHuWdZG1cmh9" +
    "Yq/2PhAH0foRg5VLi1O8HoKv4Wq+BgcHQ6+7RPp0COQCuUAu5ZLL9PR06KlR" +
    "+O0sZ2chF8gFcimZXOgF5cTlsrW1BblALpBLyeRC0CMoYd6SDrXe0t7R4ezs" +
    "7v5mZ4exq7CrsaOgxOWyu7ujsxOMlgcWJ8/Tzu6Ohp6vYHaNZfvNzo6cruk8" +
    "+vJfGv8o3cs8yu0hhaE2SLUclTxxIpRDai9TX9XqYjcQsS9rfciijYS+rF1D" +
    "uzZc1iNfd5FGL+H2yh0dhVwgF8ilpHKZmppKTi7zCwuQC+QCuZRULmtra8nJ" +
    "Rb9wIRfIBXIpi1wI/rxLLHJpbGx0tre3Q7LF2C4o8ZSTvniXxj9KN876yGc5" +
    "ytJXa+PWrVvWi7rWLytSpGgwyAVyKTfcC0EP01nvl0uRosEgF8gFcrFddwn1" +
    "VUU0GOQCuZSb+fn5+OVCkaLBIBfIpdyEeUM6xCdbl5zNzS2Frc1NBdqwW4F+" +
    "86CF58fdcyQ2tzYVtir5+A3Po5Sny3QZUrlYHjZN6fK6YmnodbNV+dpjGv8o" +
    "XZv2MdaVoe7SLYehXxrbg/UrQ3uo/YrXBb8WTAj1yfuy1t953W6FzpfWV4W+" +
    "a3MNxi4XYwNBLpAL5FI6ubS3t1ttv2D1GRGKDHKBXCAXyIXo7e1T/ECvCVnL" +
    "xXQbGnKBXCAXyIUYHra7Y2Q1JRoeHnI2NjZ01hnScSH8+rqOfs66gBynxobK" +
    "hoiaZvjzzXVxeHiYykV5+PywkgdeDiO8fQz1n1o5Dp9b94GN9XUV23bzab/1" +
    "Sj9Q0fKh9ZPgvpsO6yL37k3EJxeKDHKBXCAXyIWYnX0Yn1woMsgFcoFcIJcq" +
    "scllbW0VcoFcIBfIJX650BZ3VqwznqwznoRnXUCMwyYPYfMphDfkc93twF5M" +
    "5aCv8KXxj9KN1DamunDLcvA8nXI8d8uxHrkcKutuWbzE03fXVWLKa23liHZ9" +
    "QC6QC+QCuSQil66uLsgFcoFcIJfk5WJ6kA5ygVwgF8ilZrmY9nUR5XLz5k1n" +
    "dW3NWVtd1VlToZeavKytrinw4xRvaLQ4ODy8Cs/zJWsKPE4tPCuXXi9rYpw8" +
    "nxQmTblU8rlqgbH+PH3AjWc/pXLsH+xftRer+1VDPxD7cnC/0Y8bkNLg/Uyr" +
    "ayG+VT0fUt/Vrykefk2EwnV2ddYul07XUJAL5AK5QC41y4U/+g+5QC6QC+TC" +
    "+zL/zAjkArlALpBLInIxbXcpy6Wz03n8+DGoA8+ePUvloqR0UQ4Qhjt37ojP" +
    "uohyoUhQmZAL5AJqlguNVCAXyAXlALHLhZ8AuUAukAvgTE9PxyGXAWdl5ZHz" +
    "yMQjzgpDPU7xeHm0sqLySGeFzqsBnucVNx0dnq/gcmrheT0Y4wguF523t7eX" +
    "ykVJ6RrzzNtnxdSmal2mXw5Dn1kxoec7EFNdKNhcH+H6kd5Hwl8fYptalVO/" +
    "hmy+Gw25QC6QC+RSH7nQfpiQC+QCuUAuQXKJ5W5RX18f5AK5QC6QS/xyobtH" +
    "kAvkArlALrHLpaOjw1leXrZjSWVpWYWHl45fxrnECE5DjHMpfD61c5ajsMTQ" +
    "wzx9+jSVi5LSXTa2z5KGTVmzVo7lKG0a8rjUD5cMfcCq/4ftV1q+ePvJ/VCC" +
    "8to/MKA/bAu5QC6QC+QSt1wivRUNuUAukAvkwq9b8kLNcqEXkiAXyAVygVxi" +
    "l0v1I/RLBhYXFwWWGOz4EkMLb5NGMEsMu3OEci4JmMqhhdHZ2dlJ5aLc2dmN" +
    "XNdLSyrplmPHPu8W7RHcJ+Ltp1Z5XAqfb57PJcM1IV4fhjQhF8gFcoFc6iKX" +
    "hw8fQi6QC+QCudQul7a2tnh2/4dcIBfIBXLxphnbd4tmZmac+YUFjQXO/LyK" +
    "KYyH+YV5hiGNeYYWh4Schl6ueRVWLilOc3lZnIa629neTuWi3N7Ztq4bm7Km" +
    "JpftnUofscnjPLWjB719VLTwQr+06u+UVw8LAsY2kMohxKH1bQOmOGOTy8TE" +
    "BOQCuUAukEuF2dnZ+ORCj/pCLpAL5AK5EDTYiE0u9KY05AK5QC6QC2HzXpGv" +
    "XPgrAO3t7c7c3JzIPGMOhGJrayuVi5LSLVI50A+ThW/LEkoudM/ae2JzczPk" +
    "ArlALqACDTakB+h85WKaGkEukAvkAojW1lbxI/Sh5HL//n3IBXKBXIDVlCiU" +
    "XGjoM+tOl7w8fDgbzKzKLONhJQ4PszqzDB6nGAfL06xNPjSEOB6qmOLg5dDO" +
    "cX/b3NpM7aK8rAfefnJ9mtprK6VybG5uGfudCb0vh+wDWvuZ+jtv9+B+Jx43" +
    "oJdL71dhMF0f3vjuTdyLXy603SXkArlALuWWy/j4eO1y4R9H6+7uhlwgF8il" +
    "5HKhQUbNctFuR9+8CblALpBLyeVCgwxpe0tRLqap0YMHD4KZUZl5oKKHn1GY" +
    "eaATNk0NFn7mgSlfMwx+nnScp2Eoh5AvYmNjI5WLktIV69mnbJkqx/rGVd3O" +
    "WPAgJOr5Yt+26athj1tdczVeP4a68pbzpjvIsLkNHVou9AlHyAVygVzKK5eG" +
    "hgarKVFouQwPD0MukAvkUlK53Lt/33q9JbRcent7IRfIBXIpqVxu9/fHJxf+" +
    "DsGNGzcgF8gFcimpXDrYHWTavD+yXEyjl8nJycrai4mZ6RnGtMK0KxAFn3gU" +
    "ZhjTMyrsOE9Ty4NNGhoh8z1jgeGc9fX1VC5KStdYt8Y2lus31XJQPmYYWr+0" +
    "7HshMNYHy0fNacxEiTO4TcNcH3y9xe+x/8hyGRgYgFwgF8ilZHIZvzseakoU" +
    "SS63bt2CXCAXyKVkcrHdZiGUXPjDdLT9AuQCuUAu5ZIL/5SItN5iJRe/PXWn" +
    "pqacyUkV+s3LpMDU5KTC5JQNLA4hTX58atIAj4OVS8+3ipTHS9Qwej4mnSdr" +
    "a6lclE/WnhjrJWqbrT1JpxxrT5745NlQNsq7hymN4LrQwk/J/WiK2l2Bn6Me" +
    "l64vIxb5CsLUnvR72PWWyHKhdRfIBXKBXMohl7GxsdBToshy6erqglwgF8il" +
    "JHIJ87JiaLnwdZempibIBXKBXEoiF/51xaCXFUPLxTR6oX0daHe6YCYZYcPb" +
    "nFMcVldXU7koV1fXrOt6kpGtcqxa17VNOZImlTxMMizO4de+6bvQscqFXgWA" +
    "XCAXyKXYcrH9jEhNcqFbT/xWFOQCuUAuxZYL3zQuEbnwz43YTY0gF8gFcsmr" +
    "XOiRE34Lmh6mi10ufk/r3rs34eGewgTjnptZhXsqEwZoQ2AvPM6JCQZPU8uT" +
    "KQ0OS9P9TcFQNjVPEyI8X5Tu6uPHqVyUj1cfG+vBmHdedxkqx6pbjst+JPSR" +
    "CYt+ofUrXm7ed019j4WZCIeWR2O4e8EI15PW5p6wfbf7Io9aQsuFD5HorhHk" +
    "ArlALsWUy832m/WTi2n0Mjg4CLlALpBLweQyOjaqicXmqdxY5UKjGcgFcoFc" +
    "iiWXnt6emkYtkeTC346kBZ+7d+9aMs64GwMxxDnOiD1PdvlaWVlJ5aJcWXkU" +
    "Oc+mc9Irx4oxj+PjOncFtPAR2nyc0vaQTP9PBtPd4cTl4vfBNMgFcoFciiGX" +
    "oaGhyA/OxS4X+twA5AK5QC7FkAu9O1jrlCiyXGj+Z/qWNOQCuUAu+ZcL3QWO" +
    "8i5RLHIxjV66b92qPFTnZWx8TGVMZZyhhXcZZ4hxCMfHx8Y1xiTGGVoYlqZF" +
    "vk35fPToUSoXJaU7bqwrGV4XWSiH3l6mOg9uw9B9NVIavO54v5T6suF6CXk9" +
    "8OO1PtsSi1z4gk9TYyPkArlALjmXS3tHe/pyMb0OQHeSIBfIBXLJp1xMC7lB" +
    "n2tNTC6mqVFrayvkArlALjmVS3t7fKOWmuXCN5GqboEJuUAukEu+5GIatURd" +
    "yI1FLqbRC32VcdSVDjEyOqowyrkK94tRE6PBjDBGI6DlQz0ulWNkdESEl4vE" +
    "7IV+W15eSuWiXF5eNpYzCtQGy0vLqZRjyS2HsX1GdML2EZtyc7RwPB+h+4xF" +
    "HNpxngfW965+j3vUEotcTKOX/tu3IRfIBXLJiVwGExi1xCKXoNEL5AK5QC7Z" +
    "l0stG0IlLhe/0QvkArlALtmWy7DL9evXa36PKDG5+L0SMDwyrDIcgasK+MXw" +
    "cG3w+GziFMsxojJiOoeFMaSztJSOXChdu3LmpBxS+40M196PMsIII2x7dXR2" +
    "JDJqiVUupqHVncE7kAvkArlkVC50hyipUUuscjGOXtpvQi6QC+SSUbnw7z/H" +
    "OWqJXS7i6AVygVwgl0zIJelRS+xy8Xtqd2hw8BK3QF5oi0wvQwYGB4dUhgYD" +
    "0eIYskHNl56PIQbPI8OYLzUOuv2n4P62sLCYykW5sLhYyYNeDwZ4GzKoPhYX" +
    "FlIpx+Ligrl9TeXgbcjbiyG2pwGpv+tp8roV+vagqV+xeH2usY4EnmtJXC6m" +
    "0UtPdzfkArlALhmRy0B/v3aN5kIuptFLY2OjM3jnDuQiyIUeASfBmFhcVFlw" +
    "L2AOD0MXucqiAkmFoEfk45QLPVbul6ZWDgNivrVyX0KvWUAuslz4jgZJiCUx" +
    "uZiee6FhGOQSLJcgxI46GL4cmhhikktg3Qnn28Shl1sAcvkFzSKSeBq3bnIx" +
    "jV4ut2Toc+7cGfBwx4KBCOfEjZCHgQEVmzgHGEL4AUYS5UwijShxhj8nfB8J" +
    "nUbI9ooES4PncWBAJ1RbuH2TL+ImNWpJVC4mwdBwDHKBXCCXdORiejmxlv1a" +
    "UpWLaXGXPgELuUAukEt95UJf6KjHIm7d5OK3uDsw0A+5QC6QSx3lUq9F3LrK" +
    "xbS4S+8d9ff3VySj0K/T3z+g4oZT6Oew8Oy4lqYhDj0PjIEBFVMY8Zzgcg24" +
    "vykIeTYhlkOqG6s4eDlU9PoeYPSLYULXrdZH5PqW0NvDIo9SPngaEjwPpnIZ" +
    "MM0gklrEratc/BZ3e3p6IBfIBXJJWC63b/fXdRG37nIxCaa5uRlygVwgl4Tl" +
    "QrOEWj8on3m5mIZmVHDIBXKBXJKRS1fXLcd0x7Ze13zd5OI3PaK7R/RJEqKv" +
    "z8Btldt9jNsqYvi+CHHw42Ie+3SENPQ0+xgsHxbl0NPsUxDjNMWjhWH5FOuW" +
    "5aHPIk6pLmzqJmQfCF83EfIpxNFXQz/p7e1NbTqUilxM3zqiCui7uvggF8gF" +
    "colHLvyTrNXvihVWLgQV0LT+ArlALpBLPHJpa2tLdTqUmlxMn4IlqEIgF8gF" +
    "cqlNLqa1zXpPh1KVi9/6Cy1AQS6QC+QSTS69vT2pr7NkQi50O8y0/kLPv9Bi" +
    "1C/6GL0CYcO79DF6e/tUWJx6+Bjo61OJK9644XXh5tVL+Dj7DNSWx9rz5Jev" +
    "gDz2WZBAe3j7IT39nvY6Sybk4nd7mtZfIBfIBXIJ13fbWlszsc6SGbn4TY9o" +
    "a0zIBXKBXOz6bqdho+00p0OZkYufYGhUA7lALpBLMLT5U5bWWTInF7/1l67O" +
    "LqfbrTyVHpUeFapslR4FHr5Ct4SaBx5nT0+3gjENLZ/B+eJx6uG7NbR8SWmw" +
    "upLq9jJfKloehLrQz++JEIaXWyiHCaE9tDwIfcCURthy6GkIfflWd+bWWTIn" +
    "F7/1FxIMPcELuUAukEu3lVjSXmfJpFz8nn+hClQFA7lALpAL3fjI4jpLZuXi" +
    "t/6iCgZygVzKLZcbLTcyL5ZMysVPMGRqEkwSdDHqfX5ccSDNEHQxbuUAN58t" +
    "zS1GsdB7e5BLDYKhaRPkArmUVS5trW25EUum5WJ6gzopwUAukEvmxdJmFku9" +
    "Nn4qlFyCBEMVDblALmWRi2k3uSzdcs6lXPw2+K4+xdvZ2eV0dXUq0C1tL12M" +
    "ziToYnSa8tGlIJ/TpdKlwuPrMoSR0tDrhqVpUXap/sXzO01l6QwkdJxdej7l" +
    "OHn9q3VZa7k7LdOkbw1du3Ytd2LJhVz89oCpCgZygVyKKhc/sWTpWZbcyyWM" +
    "YCAXyKUIcqF+nWex5Eoufg/ZVW9TQy6QS1Hk0mp4wzlvYsmdXAIF09TsdLR3" +
    "uLQrtHd0KFyGYXS0B8LjaK/89psOiteLIQ39HI4ah5ZvIbyZ4HLxurKLMziN" +
    "diqrF5v619ojbLk6akav7xjiZHVhU99+/TtvYsmlXIKmSE2NTZAL5JJbufg9" +
    "0p9HseRWLkGCaWhogFwgl9zJxU8s9fjsKuQS4ja1VzCQC+SSdbmY3m7Oy+3m" +
    "wsol6EE7Wmmnx6XpASSJdoYepp3BjrczbiZPu1W+hXyK+W7XEc5pb1dJpvxC" +
    "e8RQn6HrMkI+KR36Q1hEsRRCLpJgaOUdcoFcsiYX6pd+Ysnqu0KllEvQy47V" +
    "W9WQC+SSFbnQAq3pGZYiiaVwcgkSDP2VgFwgl7TlYvrMalb3Y4FcQjwL4zdN" +
    "glwgl6Tl0tra5jsNKqJYCisXvz15fz0P4/71aG1r/UUbo7WtjdEqhOe0adB3" +
    "ZbxQZwuC3vxWaGWY8qHF06qgnaPFKaRpgp3D09TgdWUsO88rz5dal6a6CDzf" +
    "1KZa+7C6i1JXV+nTtNxvGpTXZ1hKLRe/rwp4p0mQC+SStFz8bjMX5Y5QaeUi" +
    "rcPQX5OWGy2QC+QSu1xu3Lhh/J5QkadBpZSLzTQJcoFc4pJLWadBpZWLzTSJ" +
    "Gp7+4mSTFsYNkCVablT6T9CibdGnQaWWi3Q3qfoZE8gFhIX6jd9opSzTIMhF" +
    "ePGx+qVHGtpCLkCC+knQ2kqZpkGQi8VrA9mcKkEuWRytBPUferG2zNdXqeVi" +
    "s9hblQz9harSwnEF5KW5pVmnWaKFoR7X0mhuEc8R42Ro51fKotLS0qygl1UI" +
    "L+Shko+QdSelYawrloZeLl7232GlKVCZRyuQS8hb1tXb1tSpIJfyyqWpuSlw" +
    "ClS0d4MglzrtEeNdj4FcyieXhsaGwH5RtjtBkEvCUyXIpfhyoXbGFAhyqftU" +
    "qTqSoekSPYj3C/o/o7GxSaFJoLFJRYvTm54vjYymcJjyFjIOvdw25agx3zEg" +
    "TX8wBYJc6jJV0iQDueRWLjZSyfO+tpBLTqdKvyTjDqUhl/zIhf4o2EgFUyDI" +
    "JZOSgVyyJxdIBXLJtWRoMfByytSgQAuFCo2MhvhpbGhUaGhkNHDkOBorv/0m" +
    "fJ4awsfB6orXrR6fWq7r14MXaTH9gVxytSZzOZq55nbu65BLCnIhodiMUiAV" +
    "yCXXkqmOZiCX5OVC9WwzSoFUIJdCSUYRDeQSm1waQggF7wBBLrl9MTJoewej" +
    "aK64RheIl2sqJCSOFoYhxsHDXzdxTYGfo+fpWjDXda5zpDR+1ZG9UPCcCuRS" +
    "io2q/ERzzSsZyEVLoxpHmHrFKAVyKe1eMqJsSiyXKDLBWgrkgtvZEWVTZLlE" +
    "lUn12RRMeyAXEGF9Jnh0cy1fcmG/1VIHNP1Ef4JcQEx3nMoM1lAgFwDZxAL2" +
    "TYFcQAYXhSETALmAyKObqAvEaUPrTZjiQC4gh4vFWZlWUT6w6Aq5gBKPgLzw" +
    "KRiNjngY1BuAXAAAkAsAAHIBAADIBQCQPP8PTKOxDveSSHEAAAAASUVORK5C" +
    "YII=")

# Original file: SaveControl.py

class SaveControl(PGLControl):

    def __init__(self):
        PGLControl.__init__(self)
        self.set_name("Save")
        self.set_active_icon(SAVE_ACTIVE)
        self.set_disabled_icon(SAVE_DISABLED)
        self.set_rollover_icon(SAVE_ROLLOVER)
        self.set_pressed_icon(SAVE_PRESSED)
        self.set_state(PGLControl.ACTIVE)

SAVE_ACTIVE = ("data:image/png;base64," +
    "iVBORw0KGgoAAAANSUhEUgAAARcAAAEXCAYAAACH0wDUAAAx2ElEQVR4Xu2d" +
    "698sVXXn8z/NJGqABFTAO4iaiGDUGI3iLV4QxUwiOBrjLUPUyShwzgEOd+Rw" +
    "FfCABxDkdgzEG94vkUycgXnjO1/V9Op+6pzq71pVa+/qXdXV3Wt/Pt8Xz15r" +
    "r32ptX9PVXV19R8crao/CIIgKI2qCIIgKIGqCIIgKIGqCIIgKIGqCHaDLz5W" +
    "VTWffLCqzrtzmTOurar/8hWfUw7othccPh67hv0H24+qCLYH2dSy0WXDUxTW" +
    "ybk3HxcgjjnYHlRFsHnIJs0525gq9VlQnO1sB6oimD7yX182IjfntlILDtch" +
    "mDaqIpgeQ4rJq2+oqnNuWeajDyy48P7jXPnDBVc8fdw+5/4FddtzG7CvEsg6" +
    "yHpwjYLpoSqC9SM3WEtd4tTiIULwiW/PxGEmEEf+s6oee87g/y3z+HMa+jDG" +
    "49LO4MqZKH1hNrkLZ+N4++xM5Kwb9Fj7EGIzXVRFsB7kJic3Tion7Z8JyKGq" +
    "et/hxVmECMiNP6uqR5/t5hGP5wzoQ+jvcMevq+rAD5fPgGQ+nGMqIspHjfUN" +
    "xkdVBOMh/3G5OVKQzfe22X//ix9ebM56Yz/6HJC6DpQwkOcM6EPo34dnF/P6" +
    "3BMzwfxGVZ1+tV6DFORezVFj3YNxUBXBsMglT+79k6aY3PDTxeaz2CZxYcxj" +
    "YnO435mNrPtR43gEw6EqgvLIJx2591Dk8kDukcwvb54zNpzBNosL7SKyIrYi" +
    "ujliI8chPnkaB1URlCPn4TXZIO+dXQJ8+cmqevj/ah4CtPfBjfmsAX2cmIT+" +
    "pbjuJ1X1kSN5QiP3uXjMgnKoimB1cs5S/uqOqvrs41V173/oDdNkiE3qxqSw" +
    "TFhcmohAi1BzrduQy9Q4mymPqgj6kyoq8vHwRbNT+tt+pTdGG0NsUjcmhWVD" +
    "xKVGBFuE+w2H9DGwCJEpi6oI8pBkTLlBe/rBxWm7nL5zE6QwxCZ1Y1JYNkxc" +
    "moiQy/rLceCxISEyZVAVQRqpovKe2en5l1ruo+QwxCZ1Y1JYNlhcmojAp142" +
    "xadM/VEVQTfJonJPVR36ZVU9+H+G4VsGyue3wGiT1T4hBv0ZUyE+DuyDMTy7" +
    "ySzuoV9U1Ye/mXYTOEQmH1UR2IioMOEshhaVGm4oa1Nxo9OfuO0TYtCfMRV7" +
    "AtIF+2AMz27SiH/Pb2Yik/hJU4hMOqoi0Hg3aiUp5T+g/CecJywTeQC4oaxN" +
    "xY1Of+K2T4hBf8ZU7G3wLtgHY3h2E/Yzq7vnmTSRkTNX5kigURXBcbznVCQJ" +
    "Lziy+M/HRB0abihrU3Gj05+47RNi0J8xFc11a4F9MIZnN2E/DZuIzMcf8m/+" +
    "xnMy3aiKwL8EElE5f3amcte/V9X9/1mI32bC9lYM2kmu/xBwDBZs4/DAb5eh" +
    "3aSlz08/WlWnOSITnyzZqIpdx7sEKi4qNUxuD7a3YtBOcv2HgGOwYBuHkuJS" +
    "8/cPdV8uxaWSRlXsKt43lM+enQLf/HOddMVgcnuwvRWDdpLrPwQcgwXbOAwh" +
    "LlJ31+zy99336NxoEt/EPo6q2DW8j5blv9Ul3zGSrTRMbg+2t2LQTnL9h4Bj" +
    "sGAbh6HEpebS78WlUgqqYpfwXtD0ofsWX/X/5v/u5r4eMIZHSnv6rAOOieT6" +
    "WzCGB9tbsA2hvyD50XWptOsvrlIVu0LX2crrb168lrErsXIS04IxPFLa02cd" +
    "cEwk19+CMTzY3oJtCP1rbvpZVf3l7TqHmjD3dgVVse10fRIk/4U+9Wh6YqUm" +
    "pgVjeKS0p8864JhIrr8FY3iwvQXbEPqTr3y3+1JpF9/zqyq2ma7LoPoSiEmV" +
    "klj0T4ExPFLa02cdcEwk19+CMTzY3oJtCP3bkDxibtXs2mWSqthW2i6D5GxF" +
    "3kp/+D/aka/uN6Fd8YxBik+X/xCwT0L/BNy1SukDPm5MkOS/Yh+KRqwDP5id" +
    "xVylc62GubmtqIpto+sy6IzrF69LVIkCshOPG8jaRLQT+g8B+yT0T8Bdq5Q+" +
    "4OPGBEn+K/ahQLzbfllVb+m4F7MLl0mqYpvougz64H3piZSdeNxAQopPl/8Q" +
    "sE9C/wTctUrpAz5uTJDkv2IfCs5rb25/+6DOvZptv0xSFdtC12XQPx3NS6Ts" +
    "xGOS7SWa69PlPwTsk9A/AXetUvqAjxsTJPmv2IeC82rMTX6XqetmL3N3W1AV" +
    "2wAPXs2rrlu8KEi+mLbEb4Bnd7j7GQ19FOyzBOzDGSftKp6F18azF8Cdh8Hd" +
    "gHb2oeyE/mhz6+wy6c236Zys2cZXOaiKTUYOEA9azQfuNQ6+kQRmotDuwGRP" +
    "Snj2WQL24YyTdhXPwmvj2QvgzsNgbHGpfT72gM7NbRUYVbGptAnLifuq6vNP" +
    "GAfeSYJOuwOTPSnh2WcJ2IczTtpVPAuvjWcvgDsPg3WJi7D/B1V16lU6V4Vt" +
    "eo2DqthE2r502HoZRFqSoNXuwGRPSnj2WQL24YyTdhXPwmvj2QvgzsNgneIi" +
    "yGWS5CdzdpsERlVsGm2fCMmBu/kXi9cjrMrXfwOkbkVUH5l2C7Yhnr9nn/tk" +
    "rgXbl4B9EOXPMa9p3BbvuEvnrrANnySpik2iTVjedNtCWEolSW5ipqD6yLRb" +
    "sA3x/D373CdzLdi+BOyDKH+OeU3jbqNNYDb9HTGqYlNo+6hZDlTpJMlNzBRU" +
    "H5l2C7Yhnr9nn/tkrgXbl4B9EOXPMa9p3F28/16dy5suMKpiE0gVllJJkpuY" +
    "Kag+Mu0WbEM8f88+98lcC7YvAfsgyp9jXtO4PT7xsM7pGu6BTUBVTJ02Ybn4" +
    "YZ0gpZIkNzFTUH1k2i3Yhnj+nn3uk7kWbF8C9kGUP8e8pnGnsE0CoyqmTJuw" +
    "XPRQVd35qwXyzeaVkThNaCcp/ik+q/hbbYjn79kTfO789TLKH9A/pQ37VHZC" +
    "/5Q2uTC+1QftLVz63cUjFMzzTRMYVTFVLGGRA/CZx44LS4iLg+fv2RN8coWC" +
    "/ilt2KeyE/qntMmF8a0+aO9gGwRGVUwR6438svByAJrCEuLi4Pl79gSfXKGg" +
    "f0ob9qnshP4pbXJhfKsP2h3kXb2vNJ6F2ZSbvKpialgfN9fCIgcgxKWjDfH8" +
    "PXuCT65Q0D+lDftUdkL/lDa5ML7VB+0ev14IjHUGswkCoyqmhCUsgvyGzK2/" +
    "WiDvzehEfBzkackmrp0YMRVs49Gjfb0mx9bGwZ2XgeqDPuyDNPpL7VOBPojq" +
    "w/Ahqk0map4GbMMxtNnlFZqWwEz9QTtVMRXavivUFBbzgBEeQAOVWJ6dGDEV" +
    "bOPRo71KZgd3XgaqD/qwD9LoL7VPBfogqg/Dh6g2mah5GrANx9BlF4HhXhCm" +
    "/FUBVTEF2oRFfpfZPWCEB9BAJZZnJ0ZMBdt49Giv1sbBnZeB6oM+7IM0+kvt" +
    "U4E+iOrD8CGqTSZqngZswzF4dvn9au6JKQuMqlg3ba+lfPudiwV3DxjhATRQ" +
    "ieXZiRFTwTYePdqrtXFw52Wg+qAP+yCN/lL7VKAPovowfIhqk4mapwHbcAyu" +
    "/VftAjPF1zWoinXDRRPeNhOWQ79YcEsmdbuu9vQZgjH6ZB/E8/fsJWAffWDM" +
    "W365DP1LwD49u+VTivd8Q++RKQqMqlgnXCzhdTctLywPoAcPDO2WzxCM0Sf7" +
    "IJ6/Zy8B++gDY+6auAjyD5d7ReCeWieqYl1YD8m94tqquvYny4vKA+jBg0K7" +
    "5TMEY/TJPojn79lLwD76wJi7KC7C1AVGVawD6yNnS1gEHkCPlPb0GYIx+mQf" +
    "xPP37CVgH31gzF0VF0H2CffOVD6iVhVjY93Alc/0v/RUVd3086r62s+A1A0N" +
    "+yT0H4OEMch6NUlp0wnbWzE8+zpIGVOKz9TgmGdc/eOqevFVeg9N4XeRVMXY" +
    "cFEE+a2XYhukD+yT0H8MEsYQ4rJHyphSfKYGx7w37i8/pfeQwL02NqpiTKz7" +
    "LH91Z+EN0gf2Seg/BgljCHHZI2VMKT5Tg2NujPv8b+q9tG6BURVj0Xaf5eCP" +
    "C2+QPrBPQv8xSBhDiMseKWNK8ZkaHDPGfe4tek+t8/6LqhgD6z7LCfuq6ov/" +
    "WlU3/rQb+W3nJjf+bBnPbqHaEPo70N/sg3ZCf6D8LRCDMCahv9XGtWNMtHMd" +
    "zLUibMM+2Z7+jfGkjkvFZJ8pMdmGMZ0+GZ9c9aOqetGVem+t6/6LqhgDTl74" +
    "2IN68S244N4Bod1CtSH0d6C/2QfthP5A+VsgBmFMQn+rjWvHmGjnOphrRdiG" +
    "fbI9/RvjSR2Xisk+U2KyDWM6fTK+hfyD5t4SuAfHQFUMjXWf5a13LBaGi2/B" +
    "BfcOCO0Wqg2Bv/yH+MS3q+pd91TVa24MtoWlM+fMHOEmT8lnFdPpk/FNZn4f" +
    "vE/vsXUIjKoYkvOMh35efu1is6YcjD4HhHYL1QZc+v2FkJxzi33aGWwHS5fm" +
    "mTmiNrm0M/yW2jCm0yfjm+z5nnNIz2/s+y+qYkg4WTmYl8wO5nU/3eMnPtcD" +
    "2ktz3t36IAXbyzwnv6PzYB2skutX/ND+Ryj3O7kvh0JVDIV1OXThA9VxYZmY" +
    "uMj7M15+jR5zsP1MRWBWzXWZA+cmcG8OhaoYAuv9LG+YnbYtCcuExOUD9y4S" +
    "jGO2kI/U5XIv2Fx4TIUpCEyJXLfOvGXO3KNDoCqGgJOTAydnBlMTFzmVlBt7" +
    "HG+NXLPKx3oHnqqqx56pomxJuflpfazrPF2nwJTKdevyiHt0CFRFaayH5URN" +
    "5xOfmLh0CYucff3u90zLKNtSpigwpXL9H43nysZ4wbeqKA0n9bJrquqaHy+Q" +
    "L101qeu7YBuPa360DO21z/sP6wNQH4TDP2cqRtnG0iUw/3QUuSR504A5Nc8r" +
    "h1x/5rIJ+5Ccn3G28U9+6Ju7qqIk1k3cTz/amDjgwliwjQcXn3bhX56y77HI" +
    "JVCcrexWSRYYya0GzKl57jnk+jOXTdiH5PyM/9mS49yzJVEVpbBu4r7ldkwc" +
    "cGEs2MaDi0+7cNYNeqwiLFF2syQJjORWA+bUPPcccv2ZyybsY09chHfepec0" +
    "5Mu9VUUpOAk5MPt/gIkDLowF23hw8Wn/m3v1gssZ17rOWORGcdCPksfMFRjJ" +
    "rQbMq3nuOeT6M5dN2EdDXIQxb+6qihJYP7/6N7Mzgaue7sGPljn49DKev7I3" +
    "+PKT9qni2PdYnvnd4oaxdRkZ5CHrKOtZonQJzOefcPLOylX6MCc9u8FB6aeB" +
    "F+NTj+j5DHVzV1WsivWNZ7mJawpBClgsdcCIs7hNLjiixzr25ZAIWYhKeUQY" +
    "SpRkgWHeWblKH+akZzfIFRfhzbfp+QzxywGqYlWsjfKFJ1qEIAUsljpgJGFx" +
    "a97xdT3WkqfWXhFhYf9BOeR5pBIlSWCYd1au0oc56dkN+ojLZd+zz9i5l1dF" +
    "VayCddYiG7hVCFLAYqkDRhIWt+bVuJErTy6OVeTU3RLioCxyL6ZEcQWGeWfl" +
    "Kn2Yk57doI+4CO8zHr0offaiKlaBm0UW/qvfXTz52punAe0rwMUVcRyrWJ+m" +
    "BeUp+Q+jS2A++7jOLzd3PfvAvHDgm7uqYhU40DfdpieUzUAHQJKB4y11nZ5S" +
    "KMTBcJS6wSslS2C83PXsA2O9d7fk2Yuq6Iv1CZG8G4MTymagA2At7NPPMpWG" +
    "KXKqzr63lZKFsVMpde+lLskC4+WuZx+BIc9eVEVfOMAiZy3CQAfgr7+uF3Ws" +
    "EuLSrzB2KkNc7iYJjJe7nn0E3vsNPYdSXwtQFX2wzlr+x3eqat8PupGH6pb4" +
    "vkGKT4N9QLXf48zrl8db8trcKyEu/QpjpzKEuEhpFZjLq+ozj+mcUzB/HTv3" +
    "j7WHmP/0J//yb4vxNsdf6rkXVdEHLu5f3KonYcGF4WKmLDjh4qr2e4S4jEPJ" +
    "wtipDCUuUlYSGOavY+f+sfYQ85/+iu/bvzld4uxFVeTS96xF4MJwMVMWnHBx" +
    "Vfs9QlzGoWRh7FSGFBcpvQWG+evYuX+sPcT8p7/i+8OdvaiKXLigqWctAheG" +
    "i5my4ISLq9rvEeIyDiULY6cytLhIaRMYyTPmXmsuO3buH2sPMf/pr9jzG+Ls" +
    "RVXkYL0i8KKHq+ry7y+QJwGXkLomtFs4beq+2vpss58R4jIKJQtjpzKGuEix" +
    "BEbyrC13S3C5A/0Ve2P78uzs5Y8Ln72oihy4kKLS1kbmRLIW22nTJh6ePcRl" +
    "HEoWxk5lLHGRwn+4myIugvxOO9eOez4HVZGK9YRp86zF2uieUJg4bdrEw7OH" +
    "uIxDycLYqYS4dNDYW18wfi1glfe9qIpUOAhZxLaNbE0kebGdNl6fbfYQl3Eo" +
    "WRg7lRCXDrC/3nirXj/u/VRURSocwPvvXXyPKAf5BYAmtFs+hP4u31sQ4jIO" +
    "JQtjp7JucWHOtqFytQdf+R6Qugb0r/dDzacetdeP+z8FVZECF1D40pPGwB3c" +
    "iRs+hP4uIS6jUrIwdiohLh19QFyEU67AHHr+DKyqSIEH7423GINOwJ244UPo" +
    "7xLiMiolC2OnEuLS0YchLqVu7KqKFNjxR44Yg07AnbjhQ+jvEuIyKiULY6cS" +
    "4tLRhyEunz+q17DPt6VVhQefyJXPxtWAE3EnbvgQ+ruEuIxKycLYqYS4dPRh" +
    "iIu1PwRqgYeq8GCHb72jqv7Xvy2Qx4i7qP3a/Gm3YBvi+df1r7pueR4hLsNQ" +
    "sjB2KusUF8kzLxf72i0fQn/S5m+9qY5a4KEqurCebfnv39YDa6NtIm12C7Yh" +
    "nn9dH+IyDiULY6cS4tJOm/8l/6rXUeZGTehCVXTBt6e95Gp7YG20TaTNbsE2" +
    "xPOv60NcxqFkYexUQlza6fI/5xa9ltSELlRFF+xIfsGtbWAWXROx7BZsQzz/" +
    "uj7EZRxKFsZOJcSlnS7/Dx/Ra0lN6EJVtCG/58OOPj07aF9+KoMne8AYxPOn" +
    "fY8Ql3EoWRg7lXWLS3Ju5tpLwD4Av8yY88yLqmiDB+y1NxoD9TAG78IYxPOn" +
    "fY8Ql3EoWRg7lRCXDtgHkN9353pSG9pQFW2wA3n3phqohzF4F8Ygnj/te4S4" +
    "jEPJwtiphLh0wD7AxQ/r9aQ2tKEqLOTgsINPP2oM1MMYvAtjEM+f9j1CXMah" +
    "ZGHsVEJcOmAfBrw0klsk1AgLVWHBBTv5imr+syHkn0GuvQ///OQyqfZXhriM" +
    "QsnC2KmsU1wkz47looPK3QTY5ouS4w08f88uvObG5TmlvkRKVVjwYMkPWXMA" +
    "KQP17H1oEw/PHuIyDiULY6cS4tLu79kF62d4qBEWqsKCgT94nx5AykA9ex/a" +
    "xMOzh7iMQ8nC2KmEuLT7e3bh4w/pNaVGWKgKYt1vkR/e5gBSBurZ+9AmHp49" +
    "xGUcShbGTiXEpd3fs9f0ue+iKoi85q4Z9LSDi58OmXN0mUscjrXLAX24sH0L" +
    "r8AXMENchqFkYexU1ikukmdtuaz2h4eRx+QSB/oT+s/bzPo+GzqQct9FVRAe" +
    "KPmZ1mODOboMF4twIkmgDxe2byHEZRxKFsZOJcTlOPQn9K/F5V1363U9auhF" +
    "E1VBGFBeZ3lsMEeX4WIRTiQJ9OHC9i2EuIxDycLYqYS4HIf+hP61uMgXlK11" +
    "PWpoRo2qaGLdb/nM443ByIQbcLEIJ5IE+nBh+xZCXMahZGHsVEJcjkN/Qv9a" +
    "XIST8cVlmetRQzdqVEUT3m859eDiLVXHeGKZL+RyNAG2AWoMTvt67C8PcRmF" +
    "koWxU1mnuEieMUdT9wv9LVLzvYZ21b6D10MPhKOGbtSoiiYMJD87EOKyeglx" +
    "6VcYO5UQl+PQrtp3cF7mfRdV0YSBzj+CwXKiuRxNgG2AGoPTfgri8rvf64O0" +
    "rex/shyMncrTz/IIDFe2WVwuzrzvoipqrPstHKiaaC5HE2AboMbgtJ+CuEix" +
    "XmERlEc+Mh2zbLO4CHzepYi4vGAW9HOPL/NZkG1/YhnarRguTszab93iskuX" +
    "RutEfhx+zGKJy+ckD41cJCqXAf37tPHsx8bagrVvqB2uuJiLlDlQ1+4IgRXD" +
    "xYlZ+1mLNHax3kkclGMdx9TcN/XmRC4SlcuA/n3aeHaKCeHPvXY9TKcqavi+" +
    "XPnhMw7EG6hrd4TAiuHixKz9piAuUkJghkGOp9zbGrvsmrgI1A5XXBggxGW4" +
    "Iqfu/D2ooB/yT3HMT4dYtl1czv+mXnNqR7a4nH+fHog3UNfuCIEVw8WJWftN" +
    "SVzqcvjni40hN3tlPEE6sm4i0us4W2kWGcs2i8tFGW+mUxVt4vKR+6vqHx/L" +
    "5FFAewl69vGya6YnLlE2v1BcJM9UjmbmaierxkT7zzymYRtqQ9snRqpC4CdF" +
    "AjtIYtWJp9CzjxCXKEOUXRCXU69anmPb6xdUhcBnMCQYO0hi1Ymn0LOPEJco" +
    "Q5RdEJczr1+eo3xNiBrSKi7mAhmduKw68RR69hHiEmWIYu4d5mhmrnayaky0" +
    "p7BY4nLuoeU5CtSQVnFhw3Nmwf7hkQQeBbQT+H/qEY1qkwnj1YS4RBmiWOJy" +
    "LL+Byn/ajXxWGHGWoD9QfVqgzdsT36mrKixxkWDswMQZlAL+FIAQlyibVnZB" +
    "XOSdTtQIakiyuEgwdmDiDEoBfwpAiEuUTSu7IC5SR42wPjFSwmKJi/zqmurA" +
    "whsUgT8FIMQlyqaVEJdMcfnktxevuctF2jWhndB/3uYRByNOCi+9OsQlSvlC" +
    "cZE8S83/IVD7qRDUiCRxsZ5x6Tuo3InRP8QlyqaVXREX7p8QlwZcnBCXKCXK" +
    "roqL9SBdiEuIS5SCZVfFReZNLXHF5UVXLm7oXvyQgdQ3kC81NaH/RYT+CTCG" +
    "sgOOofazFidKlFWLJS7M0dZc3SCs/UMtccXl2OJwk/bY2BQG5Z8AYyg74Bhq" +
    "P2txokRZtYS4dIhL6+Jwk/bY2BQG5Z8AYyg74BhqP2txokRZtbTuHwOVqxsE" +
    "f2YkxKXhH+ISZYjSun8MVK5uEBQX63WXrri85Oqq+vhsU/79t/KRdjmw/Ryp" +
    "b8I+QKpd5hXiEqV0sfZPnbtevqtcZe4bsA37IKpP+jAe/Gv+/GvL8xSoJa64" +
    "/PnN9qBSUAN3YPs5Ut+EfYBUe4hLlCEK90+ISwO+yzXEJUqU9BLi0iEubBDi" +
    "EiVKetkVcXlXwk+7uuLyZzOF+m8PzviWgdRn8HeA9hRWjfF331pweohLlAEK" +
    "xeX0gzoHmYs1yg5oT/VZwtvDtLf4pPxudIhLiEuUgiXEpUNc5H2YIS5RovQr" +
    "uyIuogvZ4sLFefUNGZ06ZC+EwaoxQlyiDFm4f0JcOsTl2OKwQ6tTh+yFMFg1" +
    "RohLlCFL6/4xCHGZLc7HHqiqCw2kfon7l/H8PbvFhRK3iRGnM+be2GReIS5R" +
    "Shfun9MOtueim6t9yNyDKTCG8Lqblucpj7BQS0JcQlyiFCzcP7siLjJvaokS" +
    "F34rOsQlSpT0siviIvPi/qGWuOJy0v72DjiI3Il5dosQlyhTLiEuGeIifORI" +
    "VX30fo3ULyF1TWgn9LdAm9wxfFTaNKjrrcWJEmXVYomLytEWVG73gPmuaMSf" +
    "AzvHZO0pqbP2D7UkxCXEJUrBsqvi8skHQ1yO1XNxQlyilCi7Ii6nXLE8z6S3" +
    "/wshLlGi9Cu7Ii7UiN7i8t5vVNWHv2lwBNDucP6RZWgfgvP3OPWqEJco5QvF" +
    "RfLsWO4dWTHfpQ2o87lGtRkIakRvcXnbnTr4HE6WdoeVF7sHIS5Rhiy7IC4f" +
    "KPlD9PJiGHYwh5Ol3WHlxe5BiEuUIcsuiIucbFAjqCHJ4vKaG3UHczhZ2h1W" +
    "XuwehLhEGbLsgrikvIWuVVysBfrgfZoPZcL2hP7zNvcuQzthzDZCXKIMUay9" +
    "0zeXPyQ+TWjfy+UuPH9lxxjnoM1ZN6wgLvKZdbPhift0B9bAPNie0H/eJvOA" +
    "MGYbIS5Rhii7IC7W3qGGtIqL9awLO7AG5sH2hP7zNpkHhDHbsBYoSpRVyy6I" +
    "y8l4xsX6EfpWcREoLn/9dd0JB+bB9oT+8zaZB4Qx2whxiTJE2QVxoTZYH0Nn" +
    "icsbb62q99/rcBjQTnL9LbwYLfYXh7hEGaBQXCTP5KNbITU3W+0WaPOBw8vQ" +
    "7lGPtUmzv9RPirLE5cwb9EAUzsQVuf4WXowWe4hLlCHKtovLW24rIC78cbRX" +
    "XKsHonAmrsj1t/BitNhDXKIMUbZdXM68voC4WIvEgSiciSty/S28GC32EJco" +
    "QxRr32yTuMhJRnN+1ustXXGxPjF63zfyeO/hZWgn8h0m8j5p18RpQzup/V50" +
    "ZYhLlPKF4iJ5xhwcErUfsH+4Jz3/eZuG3do31A5XXASKi/yEIyfTBSdCO+FE" +
    "zck6bWgnXYsUJcqqZdvF5XmXLc+v7ZOibHE555CeTBecCO2EEzUn67ShndR+" +
    "IS5RhijbLC7yOAo1gZrRW1zOuF5PpgtOhHbCiZqTddrQTmq/EJcoQ5RtFhf5" +
    "jiE1gZqRLC78adc/PaAn0wUnQjvhRM3JOm1oJ7VfiEuUIco2iwtfan/KgRXE" +
    "xbqp+867qurd99i8xyHX32rz7rsB7GzfRohLlCGKJS6tuZwJc3iImLQ3fXi/" +
    "pe2x/yRxESgu8jOO7JyDaCPX32oT4hJlymVbxeUvb1+el0CtIKqCMODLrtGd" +
    "tw2U5PpbbUJcoky5bKu4nJV5vyVJXLhYJ+zTnbcNlOT6W21CXKJMuXC/bIu4" +
    "5N5vSRIX677LW2enSOfdlcDdDrn+M94JaHfZ6+uF+Np4iEuUEoXiInmWk99W" +
    "rq4EY/Yk935LkrgIFJfXzk6R1CQsjEEuket/d4hLlGmXbRSXN2V8WbGJqrBg" +
    "4JdeXelJWBgDXSLX/+4QlyjTLtsoLq9OfK0lURUWXLATLq/0JCyMgS6R6393" +
    "iEuUaRfulW0Qlxfi/mTXlxWbqIo2qFxvub2q3vH1buRx4Sa0E/qb3LXMOzyM" +
    "foQQlyhDFEtcvFxMzX/6W21o535Q+8fxF7j3rd+FtlAVbbAD+SqAGhhwJ+74" +
    "m3BxPIx+hBCXKEOUbROX1J8RsVAVbchHT80O/mS/MTDgTtzxN+HieBj9CCEu" +
    "UYYo2yYucn91cHHhz40I3qWRO3HH34SL42H0I4S4RBmibJO4yPtyn3fp8nzk" +
    "+4bUhjZURRcUl5dfuxhAX94OaJ9zB6Ddoa2PU0JcogxQKC6SZ8y9VNpydyWw" +
    "n94Omr59PyWqURVd8L26f3y5MfgMkhYvxCXKBpVtEhe+CnZQcbGe1n39zcYE" +
    "EklavBCXKBtUtkVcrAfnUp7KbaIqPNjh6VcbE0gkafFCXKJsUNkWcXnVdVpc" +
    "qAUeqsKDL5CSGz5vvaMntwPaB4Q/SRniEqVEobicfGDxugKBOTgIhfbUSfsh" +
    "kglfVCSqIgUqmvxgGgeXRKGF6EOIS5QhyjaIyxsOLc9BSH1wromqSIEdy9fK" +
    "OcAkCixEX0JcogxRtkFc5J1N3OPUgBRURQpyY4edy29Jc5AuBRaiLyEuUYYo" +
    "2yAu8ilwcw6p3yUiqiIViov8Eps8VNfkzeS2ZeR3Z5dAewsvhmevkYMe4hKl" +
    "dKG4yEvt23IxNVe74B5TduDZrTfOdf02UReqIhV+HUDUTgkBcSbK9hZeDM9e" +
    "E+ISZYiy6eJyGt44J3Dvp6IqUrG+DiCqF+ISZZfLJouLdSNX5sO9n4qqyIED" +
    "kQ0b4hJll8smi8upKz6RS1RFDlxI4XVfq0Jcouxs4Z7YFHGxzlr63sitURW5" +
    "cECymH9x6/SRcYa4RCldLHFh7k2R0mctgqrIhYspyG/KcvBTI8QlyhCF+2ET" +
    "xOVsPHUvrHrWIqiKPnBgm7CgIS5RhiibKC4vWeGFUF2oij5wQYWpn71QXOQ7" +
    "U1GirFq4F6YuLufeUlV/hBdC9fkekYWq6AvF5cVXLgaexSHNObcswzbKzhhG" +
    "G4G/ICdEibJq4Rd75XWw50geWzB/aSf0N/Lds3MfWM+19H1ojqiKvvBFUoK8" +
    "3JeT6YQLYS0WUHbGMNoI8oJxjvexZ5gqUaLkFeaUbF4lEjXMX9oJ/Y189+zN" +
    "PSCfEA111iKoilXgwsqbrLipO+FCWIsFlJ0xjDaC9VbzA08xVaJESS/yz4k5" +
    "Je9FUSJRw/ylndDfyHfP3twD1tl7qbMWQVWswspnL1wIa7GAsjOG0aaGqi1P" +
    "HUeJ0rfIPyfm/5/N8l+JRA3zl3ZCf8njOs/38Ox17g991iKoilXh4srDam+4" +
    "2UY+AmtCu+Vz9iHgxKB/0ybXw82xxk3dKKsUvi3gBZc5uUyc3LZQ+Z6I9VxL" +
    "ybMWQVWsinX28spr9SJYC0G75eMdANW+Q1xOMxb4md8xZaJE8cvvfr94NqSZ" +
    "S/zHylxVOLltofI9gdfepPNe4F5eFVVRAg5aFPz1X/MXgnbLxzsAqn2HuIjo" +
    "cazxvEuUPsX6Iq/88+rMZeLktoXK9wR4xi6UPmsRVEUJ+Fm/tdDWQtBu+XgH" +
    "QLXvEBcRPF531gsdJUpqOfxznUPC625ycpk4uW2h8t3B+oda4mlcC1VRCk5A" +
    "kAfr5AbvlJAfduM4haefZQpFiaKLXA7x3UaCfFLKXHO5aRm5GbyE1AEVowMR" +
    "O+ufKfduKVRFKazfOJI3inPCU4A/7SrEzd0oKYU3cYUTLtc5lsRNy5QWF+tH" +
    "zuQqg3u3FKqiJLzBJciZAie9bkTRn3+ZHqsITJzBRLGKnLFYwiJnBr3P0G9a" +
    "pqS4nGk8NCpwz5ZEVZSGk5FNLJuZk1831o9A1cQ9mCjNIvdYrEshQR5MY24l" +
    "I/uiQUlx4e8Q1XnN/VoSVVEa6+au/BSJfBwmIrPEjZrXkpscHH/VZ8Mm4+JY" +
    "a2Qe8TH1bpe2s5WaE/d1554H8zIFL9+lznoSd6ibuE1UxRBwYsKrrtcLRWEZ" +
    "W1zkHcBdAiPIpZJ87ChPY8Z3kba7yCXxzU8v/sNb/ySbiLCcdUN37nkwL1Pw" +
    "8l3GNOZN3CaqYgism7sn7tcLRWEZW1xq5GdSrHswbYjgSPIF2wOPcRuyceXL" +
    "iSrvjNzzYF6m4PVp/bPM/UH5vqiKobBu7srElxbrRo23eArHnwdnfoAMH7kp" +
    "xx+rD4Imch/j1Te0bHIj9zyYlyl09flS45cTS39/qAtVMSScqCA/HSmnbq3c" +
    "CHLtKyJv6bJOK4PdRfJBPtZlrpDXANrd3KU9gbqvM66z83bom7hNVMWQWI9I" +
    "ywLIx2RqYdsWONdegDNvWIjMC69cXFtbBy3YbuS4y/NQcgkknywyRyzWKS78" +
    "SVZBLt+5J4dEVQwN39RVHzi1sG0LnGsvgdGHJNhccK5YjD/YLuQfiQjJK0RI" +
    "eubVusTFeih0zMuhGlUxBtYzArIganGtBc61l6BAH3IPp4kb07P3YQ0x1QZz" +
    "/JPaAOWfgNuG/dCewMp90J7AS42XbQvcg2OgKsaCkxfM+y9cwFx7CQr0EeKy" +
    "t8Ec/6Q2QPkn4LZhP7QnsHIftDvI4x3WJfuY91maqIqxsB5G+sNLFzei5B5M" +
    "KuLfhPZeSJwmtPdA3tnbhPYhYJ+E/oT+FmwzBEP0mRuT/oT+Fm4b5F1ubr9g" +
    "AvdZmqiKMbE+nj5hn160LnIPQBIhLkntU2KUYIg+c2PSn9Dfwm2zgrhYj02s" +
    "4z5LE1UxNlyQ+aJcoRevjZwDkEyIS1L7lBglGKLP3Jj0J/S3cNv0FBfr8X6B" +
    "e21sVMU64KIIcmOKi2iRegCyCHFJap8SowRD9Jkbk/6E/hZumx7iIi9/ktsJ" +
    "3D9ffCzEZY55/+Wri496ZfE6uW4Z+Yh4iWuXof8cxiSeP+0JJI0r058+hP5q" +
    "HoT+CXD9c+294LhTQIzctVL+BtlzZQzYrT7lFbLcO+u8z9JEVawL6/6LCIx8" +
    "z0ctetcBIDwgPKACYxLPn/YEksaV6U8fQn81D0L/BLj+ufZecNwpIEbuWil/" +
    "g+y5Mgbs7M8SlnXfZ2miKtaJ9fyLLGCnwPAAkMYBMZNGYEzi+dOeQNK4Mv3p" +
    "Q+iv5kHonwDXP9feC447BcTIXSvlb5A9V8aAvdmfPOjHvSJwT60TVbFuuFiu" +
    "wPAAkMYBMZNGYEzi+dOeQNK4Mv3pQ+iv5kHonwDXP9feC447BcTIXSvlb5A9" +
    "V8aAve7Lenv/1IRFUBVTgIsmyEfUL7/G4FqQa5/xsmuXod1DHv5rQvscjIN9" +
    "qhgcN2H8Hm3cPhm/AKrPPnjj9OwbzEktwiLf2+M+WjeqYipw8QRZWC62m0ie" +
    "/Rq90Wn3SNowGAf7VDE4bsL4Pdq4fTJ+AVSfffDG6dk3FOs7Q1MVFkFVTAXr" +
    "G9SmwHiJ5Nmv0Ruddo+kDYNxsE8Vg+MmjN+jjdsn4xdA9dkHb5yefQNpE5ax" +
    "XvzUB1UxJdoERhb62MJ7ieTZr9EbnXaPpA2DcbBPFYPjJozfo43bJ+MXQPXZ" +
    "B2+cnn3DsN4mJ0zlI+c2VMXUaHvl4MlXLJ6DkYftmkhdE2U/aGC060LFdOwW" +
    "bKNwxsh4STEB26fAcSk7yLWnwBiE/iYy9gaMQVR7QP9SyEup5JEM5v/UhUVQ" +
    "FVPEegdMLTDeQVZ2btqExCIqpmO3YBuFM0bGS4oJ2D4FjkvZQa49BcYg9Ddp" +
    "CMtUxaVNWKb0LEsXqmKqtAmMfA+p6yCrJOCmTUgsomI6dgu2UThjZLykmIDt" +
    "U+C4lB3k2lNgDEJ/k4awTFFc5B/nJguLoCqmjPWQnSAPFLUdZJUE3LQJiUVU" +
    "TMduwTYKZ4yMlxQTsH0KHJeyg1x7CoxB6G/SEJapiYsIC3N804RFUBVTp01g" +
    "5Pd5T7vK4CCg3fIhq/qntMmF8fv0sWp7KwbJ9bfaDIB8k7gJ7RwT/Ylqb8RQ" +
    "0P9g+wNymyYsgqrYBNoukeSlxKd6B5B2y4es6p/SJhfG79PHqu2tGCTX32oz" +
    "AK44YEz0J6q9EUMBf3lQlDm9qcIiqIpNoU1gnncpBCblgNOHrOqf0iYXxu/T" +
    "x6rtrRgk199qMwCuOGBM9CeqvRFD0fBtE5YxfnZ1KFTFJtH2MfWSwKQccPqQ" +
    "Vf1T2uTC+H36WLW9FYPk+lttBsAVB4yJ/kS1N2IoZj6nHrS/3SxswsfNXaiK" +
    "TaPtQTu50y6fJL34ymXkgSRCH8VVAPYXXQUQP6WPXH81JmNcCvoDNQbDR+H0" +
    "oWIC2i0f4vmXOB5EtffWwWpj2OUfIXN3G4RFUBWbSJfAnHxAH1DCg65wEqlE" +
    "Muf6qzEZ41LQH6gxGD4Kpw8VE9Bu+RDPv8TxIKq9tw5Wmwbyj69NWKb6XaFc" +
    "VMUmw4NUI9ezbQecB93ESaQSyZzrr8ZkjEtBf6DGYPgonD5UTEC75UM8/xLH" +
    "g6j23jpYbfaQT4SsZ1i2SVgEVbHp8GDVPP8yfbB50FtxEqlEMuf6qzEZ41LQ" +
    "H6gxGD4Kpw8VE9Bu+RDPv8TxIKq9tw5GG8H6mdWaKbz3tiSqYhtoexZG/lv8" +
    "6QF9wJkUCieRSiRzrr8akzEuBf2BGoPho3D6UDEB7ZYP8fxLHA+i2nvrAH95" +
    "MK7tMkhgDm8DqmJbsN7JWyP/PeSat0a+Zd2kabPI9Z+3ObAM7aRPHx6MSVL8" +
    "6TMEXp+094ExPbz2tDd95Any/9pyGbSpz7CkoCq2CetXBWqed1l7YjBxSK7/" +
    "vE2ISzJen7T3gTE9vPa01z7WryDWbMMnQl2oim2EB7VG/pvIzTUrKbrI9Z+3" +
    "CXFJxuuT9j4wpofXnna5/LZ+t7lm2+6vWKiKbcW7TOpKHMJEot0ixCUdr0/a" +
    "+8CYHl77pm1XL4OIqthmOi+TLl28QlP+40wSGVsT2i28NrQT+lttaPdYtb1F" +
    "n5heG9qJ4S9nwV03bbf9Moioil2g7dMkQa6RVeJMAS+5Lbw2tBP6W21o91i1" +
    "vUWfmF4b2gn85RH+trMVYRcug4iq2BXavvgoyEfW8uAdE2itOMlt4rWhndDf" +
    "akO7x6rtLfrE9NrQTvb8TtzffW9lly6DiKrYJdq+NlAjp7h/wqRbFy3J3YnX" +
    "hnZCf6sN7R6rtrfoE9NrQzs5sHgwkznTRL5Yy5zbJVTFLtJ1s1eQJJKbdDUn" +
    "kf0+zfYpuH3QbsCYhP7kRBk3OMlB+RtxXRhzXze5/vM2xIuxNx/h+Zd3XwLt" +
    "8tlKE1Wxq8g1MZOkiVwqyf2YlMS0UMnq4PZBuwFjEvoT2UjkJAflb8R1Ycx9" +
    "3eT6z9sQL8b+xaXyH3ZcAgnb9N2gVVEVu07bO2Jq5PpaJScS00Ilq4OX/Mpu" +
    "wJiE/kQ2FDnJQfkbcV0Yc183uf7zNsSJ4V0C7donQSmoimCBd6kk92OOJSkS" +
    "04LJ6uElv7IbMCahPzlRxg1OclD+RlwXxtzXTa7/vA0xYsiZihznuATqh6oI" +
    "juNdKglyJiMfQ8qDeMeQv0nTPuOEy5ahncgLyFeFMT3Y3orh2TeVrk+AauIS" +
    "qBtVEWi8SyVBrsWPiQyFxRCPEJdpkiIqm/xe2zFRFUE73qXSksgQJHGIy3SQ" +
    "45UiKnIJtIsPw/VFVQQ+SSIzu05//ixhQ1ymi4iK9+lPiEp/VEWQTorIyM1A" +
    "+a8onzbkIK+E6EKEy8WIuzJOH2qcxGlfBPYB5Hi0vWaySVz+rIaqCPJJuScj" +
    "SEKnCg03KeGGMTHirozThxoncdoXgX3MkE99UgRFCFEpg6oI+pMqMnI2I6fj" +
    "5ubbg5uUcPOYGHFXxulDjZM47YuwF1sE5Y++2v1RcpMQlbKoimB1UkVGaLts" +
    "4iYlapNacNOVwOlDjZM47Usg65kqKMKufwdoKFRFUA55DqLr9Q5kfkYjYrN3" +
    "ZrPEnq1GNhBRPkDZGYP+HIMB2zAm+1RYMQnHRfba5QiKEM+pDIuqCIbhgsM6" +
    "ubuQjVJfPs3BhlIb0PIBys4Y9K/77oBtGJN9KqyYhOPao14jrl0XcZYyHqoi" +
    "GJ6ud8m0cUxs9lAb0NjIbZuyNQb9Gxu+DbZhTPapsGKShn+umAhxL2U9qIpg" +
    "POTZiZSPsy2OCU3HRubGV3ZjE09JXMTeR0wEuRyNy571oiqC9ZB7f8aiPrtp" +
    "3rvZBHFpjruvmNRccDgEZSqoimAa5HzitMvIOsXTs9NEVQTTQzZPiM0CuV8V" +
    "YrIZqIpg+sjm6nNTeBMJMdlcVEWwmdRnN31vEK8bud9UX+KEmGwHqiLYLmSj" +
    "ys3iqVxWyTjkpmsIyPajKoLdoj5TaCIC0ISXYHJ2RB/GCPEIVEUQBEEJVEUQ" +
    "BEEJVEUQBEEJVEUQBEEJ/j+xIIAdBRfKPwAAAABJRU5ErkJggg==")

SAVE_PRESSED = ("data:image/png;base64," +
    "iVBORw0KGgoAAAANSUhEUgAAARcAAAEXCAYAAACH0wDUAAAwlklEQVR4Xu2d" +
    "SdgkV3WmWbFjx44dK3b2ih07rXrHjp161TaDGMwkxCCEBMhICMw8GBBghGiM" +
    "GxtwN8aWwabB3f5RlVSlKpWqSlUqSZSGEpolQIhwnsyMqpvvORHn3hgyIzPP" +
    "8+T7lHTPcIc49/sjIiMzX3JQVS8JgiAYGtUQBEEwBKohCIJgCFRDEATBEKiG" +
    "IBDee6Sq/seBz9sOVxVjg0BQDcFuQlHYJB8+HoK0D6iGYHvJPduYKnEWtFuo" +
    "hmA7kI3IzbmrHBjzD6aPagimyVhict2xqrrpnlX+9oEF30u468kFR5+8ZE+p" +
    "Yz+RwL6GIM5utgfVEEyDoS5xavEQAfjH8wtxeOqFqvrDHw2qVV78o0bFAPq/" +
    "KHlm3PVUVf3s0YVQffH04r4Lx9qFEJvpohqCzdBns7318EJAvnF2ISIiIPc+" +
    "U1Uv/BG8uMrvPf5oQB9Cf4fzv62qI8nZkMxD5sM55iKifGCsb7B+VEOwXrg5" +
    "cpDN94XTVfWj2ZnI+ecvbWwlJkR8EpQwEEMMlA+hfxdeXMzrXx9ZCOZVHc/i" +
    "Doz1DtaHagjGp/T+SSomp59ZbD4LJSZEfBIYr+CmX278VujfBSOnnOHUYtPl" +
    "zObAOA7BuKiGYBxK76HI5YHcI6kvb9SGM1BiQsQngfEKbvqccdC/C17OFxci" +
    "K2IrolsiNnHZtD5UQzAsLO4mZIN8ffZX+T8uVNVv/zDjxVWeB7R34fk/rDLv" +
    "N8WIUSCG4yQqfiBOzsTmu/eXCU08zDcuqiHoT8lZyudPVdVtD1fV47+rWjf2" +
    "GJt0l8QlRQRahJpr3US84zQOqiHoTq6oyNvDP/x1VT34XKU2Z9PGHmOT7qq4" +
    "1GMRwRbh/vgJfQwsQmSGRTUE5eTcoJV3POS0/eTTl4q/FWyYMTbprotLigi5" +
    "rH/OO08hMsOgGoJ8ckTl5tnp+S8f08Xugg0zxibdJ3FJEYHPvWw6MI57kIdq" +
    "CHxyReXc7K/ls38Yh+cMlM8LwIgpis/IQX/mVIiPA/tgDs/ehByf72TeBD4w" +
    "6iBoRzUEzbDgLG4+M66o1HBDWZuKG53+xI3PyEF/5lQkItIE+2AOz+5x4Xch" +
    "MmOgGgKNd6NWivI752ai8my12BBGAQ8NN5S1qbjR6U/c+Iwc9GdOxVJA2mAf" +
    "zOHZc8kVmbgnk4dqCFZhYVFU/uesGC/8tlrdEEbhDg03lLWpuNHpT9z4jBz0" +
    "Z05Fum4NsA/m8OyliMj84Nf+zd94TqYd1RAsYCFRVG6dnak8MhOVp18IpsYz" +
    "gPYSfvJwVb3HEZm6ZoJVVMO+410ChahMnyHFpeYfft1+uRSXShrVsM+wYFJu" +
    "PFFV9z2riy6YHmOIiyB/VL52RtdGSl1LQYjLnLa3luWv1c8v6EILpstY4lJz" +
    "++NxqZSDatgnvC9o+va5xfeKPPkC+P0qT5AXDODj5STMp+KNPnqDPq15EI6b" +
    "MB/nYMIcHuwD8RYqB6C/IPXRdqm075/AVg37QtvZyg0nFt8Xe7GwSosdxW1t" +
    "Si8nYT4Vb/TRG/RpzYNw3IT5OAcT5vBgH4i3UDkA/WvOPFNVnz2layglrbt9" +
    "QjXsAzz4NfJX6McPGYVVWuwobmtTejkJ86l4o4/eoE9rHoTjJszHOZgwhwf7" +
    "QLyFygHoTw5+036pxBrcB1TDLtN2GVRfArGo5oVVWuwobmtTejkJ86l4o4/e" +
    "oE9rHoTjJszHOZgwhwf7QLyFygHo34TUEWurZt8uk1TDrtJ0GSRnK/Kt9L/5" +
    "fTOPA9oVvzPI8WnzHwP2SeifESNfc5BSGm+h1p8+6MP1N1DjJpwHSXyPPDE7" +
    "i7lT11oNa3NXUQ27CA9uzYeOLb4uURUKUMXqwcK0ipN2Qv8xYJ+E/hkxapMW" +
    "xluo9acP+nD9DdS4CedB4C9f8fCZk7rm9klgVMMu0XYZdMu5pPgcVLF6sDCt" +
    "4qSd0H8M2Cehf0aM2qSF8RZq/emDPlx/AzVuwnkQ+i/5Xw/o2qvZ9csk1bAr" +
    "tF0G/dujKD4HVaweRpFl+bT5jwH7JPTPiFGbtDDeQq0/fdCH62+gxk04D0L/" +
    "hH29TFINuwAPXs01dy2+KEg+mLbCbwHthTxqQJ+h++yCO8YhWMM8u8xDxXjj" +
    "9OwOD8wukz69Z5dJqmHb4UGr+dZ9+oBfpGfhEBauWfAD99kFd4xDsIZ5dpmH" +
    "ivHG6dkz+buWyyTW8rajGrYZHizhLYeq6qeP6IO8wkCFU8PCNQt+4D674I5x" +
    "CNYwzy7zUDHeOD17AXfOLpOubLhM2qWvcVAN2woPktB4GUQGLByBhWsW/MB9" +
    "dsEd4xCsYZ5d5qFivHF69kLkMknqkzW7SwKjGraNpneE5MDd99zik6x9eXgE" +
    "vD48uwVjiOfv2S0fD8Y/8jyg3QIx7IOU+lt4Y1D2jnz5Xl27wi68k6Qatokm" +
    "YfnUyYWwmEXSARbeEHh9eHYLxhDP37NbPh6M77RJC8Wi1N/CG4Oy96BJYLb9" +
    "O2JUw7bQ9FazHKjWIukAC28IvD48uwVjiOfv2S0fD8Z32qSFYlHqb+GNQdl7" +
    "8jf36VredoFRDdtArrCYRdIB5hwCrw/PbsEY4vl7dsvHg/GdNmmhWJT6W3hj" +
    "UPYB+MfzuqZruAe2AdUwdZqE5UfndYGYRdIB5hwCrw/PbsEY4vl7dsvHg/Gd" +
    "NmmhWJT6W3hjUPaB2CWBUQ1TpklY5HeXH3p+gXyyOdgc9XHIPR70z4nZdeSb" +
    "7uQRCtb5tgmMapgqlrDIAfiXh6Mwp0SpUNA/J2Yf2AWBUQ1TxPpGfll4OQBR" +
    "mNOi9HjQPydmX5D6/qDxLMy23ORVDVPDeru5FhY5AFGY06L0eNA/J2afaDqD" +
    "2QaBUQ1TwhIWQX5D5oHnF8j3ZrQiPim0P7d4WjKl1K5gnw39ttIhvl6Ti2tD" +
    "6A9ot1B9GD5t/l36VHBeQPVh+BAVU4iapwFjXJZjO2gQmKk/aKcapgQXk8KS" +
    "dcCWB+gitD/nF5ZnV7DPhn5b6RCvipnQH9BuofowfNr8u/Sp4LyA6sPwISqm" +
    "EDVPA8a4JOMTgeFeED58fLoCoxqmAhdRkN9lLj5gyQGaQ/tzq0VlFZZnV7DP" +
    "hn5b6RCv1obQH9BuofowfNr8u/Sp4LyA6sPwISqmEDVPA8a4YIzy+9XcE1MW" +
    "GNUwBbh4whdPLxa8+IDhACm75ASldgX7bOi3lQ7xam0I/QHtFqoPw6fNv0uf" +
    "Cs4LqD4MH6JiClHzNGCMC8f5XLPAcA9NAdWwabhowhdmwnLuuQX3P1tGHdcW" +
    "T59z0taG50+70a8bQ3sG7IOwj/uBshs5XJgXdo6ZfZpz98aFPunfCYyBfXr2" +
    "uY+T04XxS24+q/fIFAVGNWwSLpZw/d2rC8sD6MEDQ7vlow4y8fxpN/p1Y2jP" +
    "gH0Q9uFtSsZnwbywc8zs05y7Ny70Sf9OYAzs07PPfZycLoxPkD+43CtTExjV" +
    "sCmsh+Suvquq7nlmdVF5AD14UGi3fNRBJp4/7Ua/bgztGbAPwj68Tcn4LJgX" +
    "do6ZfZpz98aFPunfCYyBfXr2uY+T04XxYOoCoxo2wYeP6wWyhEXgAfTIiaeP" +
    "OsjE86fd6NeNoT0D9kHYh7cpGZ8F88LOMbNPc+7euNAn/TuBMbBPzz73cXK6" +
    "MN5A9gn3zlTeolYNm4CLI+/p//LC4nd4z5JngWfvAnMS+q+DjDGcATkxrTDe" +
    "yuHZSal/F3L6yPGZGhzzjLufrqp3G1+ZyT22CVTDuuGiCPJbLyIsIS4JGWMI" +
    "cVmS00eOz9TgmJfj/o/H9B6agsCohnVi3Wf5/KlLwhLikpAxhhCXJTl95PhM" +
    "DY45GfetDb9RzT23TlTDujDvsxytquNPhbiYZIwhxGVJTh85PlODY8a4P3GP" +
    "3lObvP+iGtYFF+HNh6rqFxeq6t5nwNOryG87p9Dfs1uUxtCf0N+K8eyk1D8H" +
    "5iSnZb2B56PsgHaLLjGl8Tk+Jf60Wz6kdO08js3+ML9rQvdfVMM64OQF+bEo" +
    "Lu6cRFhCXPL9c2BOwuI3N4BnB7RbdIkpjc/xKfGn3fIhpWuXg/yB5t7alMCo" +
    "hrGx7rN87tRiYbi4cxJhmYq4yF8I+TrCr56pqo8cD3YF88x5iVcjtFs+ZAxx" +
    "EW6ZyP0X1TA2nPAHji42a+PBmIC4yHdqiJDcdI992hnsBo2X5hk1QrvlQ8YS" +
    "F0FqlfNb9/0X1TAmnKwczJ9fqKqTzyx52ucUoH1ovnJGH6Rgd7lYk0YtrJs+" +
    "tX70SfsP4YGxL8dCNYyFdTn0vQeqS8IyMXE5+M3irIpjDnafqQhM31qXOXBu" +
    "woGxP8dANYwFJ/jxE9WqsExIXL5136LAOGaL136zqv7bZ4NthsdUmILADFHr" +
    "1pn3gbE/x0A1jAEnJwdOzgymJi5yKik39jjemtd9v6ouu76q/uTyqnrFq2cT" +
    "e0mwC7zqtfpY13W6SYEZqtY3dXmkGobGelhO1HQ+8YmJS5uwvOaqqnrpyypV" +
    "mMFuMEWBGarW//lhPa91fMG3ahgaTur9R6vqxFML5ENXKXX7CtKewJi7JU8L" +
    "zKfil/02/Vbv5bdV1Ssvq1QxBrtHm8D826O6llbqyoA+RPmj1unfhTr3jSf0" +
    "vGYvtV+HRDUMiXUT9ycPJRM3NrkCC84YHiDCfCp+xv9/zL7HIpdAcbayX3QV" +
    "GNadVXtE+aPW6d+FOvf/a6jx2Uvt26FQDUPCiXzmFCaOTc6FmYMFZwwPEGE+" +
    "Ff/04guOOVYRFhZesB90ERjWnVV7RPmj1unfhTT/X9+r5yS1P/tH7d0hUA1D" +
    "wUnIgbnzCUwcm5wLMwcLzhgeIMJ8jP+mcTkkl0KbOmORG8VBN4Y8ZqUCw7qz" +
    "ao8of9Q6/bvAPtZ5c1c1DIH186vfPFtVx550eMrn+JOruDloT5DvwbBOFdd9" +
    "j+Vlr1jcMBZR41iCMmQdZT25xl1oE5ifPuLUnVWr9GFNenYD+RaBFC/Hjx/S" +
    "8xnr5q5qGAIOXm7imkJAuDAG6oARxtCeIL+DxLGu+3JIhCxEZXhEGLjWXcgW" +
    "GNadVav0YU16doNScRE+fVLPZ/ZS+7gvqqEv1k3cnz3SIASEC2OgDhhhDO0J" +
    "XzauQYc8tfYQYWH/wXDI80hc8y5kCQzrzqpV+rAmPbtBF3E59Lh9xj57qf3c" +
    "B9XQFw5YNnCjEBAujIE6YIQxtCdcd2x1rPK0JgtrLOTUPc5YxkfuxXDtu+AK" +
    "DOvOqlX6sCY9u0EXcRG+cVbPZfZS+7kPqqEPPGuRhf/V44snX02eALSPQdIf" +
    "F/fVb6pUUY2F3Btg/8HwDPkHo01gbnt4tbbWVs+lJON75x16LrOX2tddUQ19" +
    "4EA/ddKYXMNE13Ywln1JMXC8Q12n5xBnLetjqBu8QpHAsPamQDI+63t3Zy+1" +
    "r7uiGrpivUP0i8eMyTVMdG0Ho2VhX/6qShXTGMipOvveVTj3PjB3LkPde6nJ" +
    "FhjW3hTAnnvnHXoes5fa311QDV3hAN2zFmOiyj4Gy76+ZPxaHYtoLEJcusHc" +
    "uYxxuZslMKy9KYA99/Wzeg6zl9rfXVANXbDOWv79QlXd8UQ78lBdMY+3cwdQ" +
    "8Uuu3eDN3BCXbjB3LmOIi9AmMP/ysK65YljbT2gYQ7uH9dGXoZ57UQ1d4OL+" +
    "1Uk9CQsuTBaGoIS4TBfOvQ/MnctY4iKMKjCs7Sc0jKHd5XH7N6dnL7XPS1EN" +
    "pXQ9axG4MFkYghLiMl049z4wdy5jioswmsCwtp/QMIZ2l8fHO3tRDaVwQXPP" +
    "WgQuTBaGoIS4TBfOvQ/MncvY4iI0CYzUGWsvG9b2ExrG0O6y3CdjnL2ohlI4" +
    "oB+er6rDTyyQJwHH5jDItX8oxGUtcO59YO5c1iEugiUwUmesySFhfRP6NyGf" +
    "s7vi0OrY+569qIYSuJCi0rWwhLg0E+LSDebOZV3iIvA7ebdFXITPD3z2ohpK" +
    "4EDSs5YQl2ZCXLrB3LmEuOTxs0f12vX5vhfVkAsHIYuYCkuISzMhLt1g7lxC" +
    "XPL5pPFjarOX2v85qIZcOAD5Dlr5HNEKv2lHfgEgRcU/rn0OpC2BOV2WeUNc" +
    "1gPn3gfmzmXT4qJquKZvLRswJ/ukP/eb9X0vs5fa/zmohlw4gF9e0ANVE+FC" +
    "cOKMNxaHi8ecLsu8IS7rgXPvA3PnEuJyCfpzvwnvuGN1Dl1/BlY15MCDJ6dS" +
    "5kA5EaAmznhjcbh4zOmyzBvish449z4wdy4hLpegP/ebMNSNXdWQAzv+7v0N" +
    "A+VEgJo4443F4eIxp8syb4jLeuDc+8DcuYS4XIL+3G/CT40bu7OX0gEP1eDB" +
    "J3KvONQyUE4EqIkz3lgcLh5zuizzhrisB869D8ydS4jLJejP/da0P4TZS+lB" +
    "G6rBgx1+7lRV/edjC+Qx4hV+s8p/AvrTPmeZu7EPJ0fTGK4JcVkLnHsfmDuX" +
    "TYrLNXc1166qVc9uQB/CnET5L/mG8asYs5fSgzZUgwc7/N/nq8bF8xaC/rTP" +
    "WeZu7MPJ0TSGEJf1wLn3gblzCXFpRvkvkZ+w5TrOXkoP2lANbfBrLOUSqXXj" +
    "J4O1FoL+tM9J8pt9ODmaxhDish449z4wdy4hLs0o/4Sbej7zohraYEfyC26t" +
    "Gx+DVRNxJjonyW/24eRoGkOIy3rg3PvA3LmEuDSj/BO+Y/z0zuyldKEJ1dAG" +
    "O/rJw4sPPGVzwYH+Q8A+lshBT+cS4jIOnHsfmDuXTYvLqPXdl3psDWOUN2zS" +
    "+ZQ886IamuAB++hxPRCXCw70HwL2sSTEZT1w7n1g7lxCXFqox9YwRvl9d67n" +
    "7KX0wUI1NMEO5Ls3ORCXCw70HwL2sSTEZT1w7n1g7lxCXFqox9Ywxh+d1+s5" +
    "eyl9sFANTbCD4ksiayKE/kPAPpaEuKwHzr0PzJ1LiEsL9dhaxshLo9lL6YOF" +
    "amgiTf72O6rqFxc0/xf84tFVPDvz5aByevZlXx8McVkLnHsfmDuXTYqL1NnF" +
    "WpQ9kCJtCdwPtKv4jD3j+bMP2oWPHF+dU+6XSKkGCx4s+SFrDsAcqLNYtDNf" +
    "DiqnZ1/2FeKyHjj3PjB3LiEuzf7sg3bhS8Zvqs9eSieIarBg4lvO6QGYA3UW" +
    "i3bmy0Hl9OzLvkJc1gPn3gfmziXEpdmffdAu/ODXek1nL6UTRDVYMLH88DYH" +
    "YA7UWSzamS8HldOzL/sKcVkPnHsfmDuXEJdmf/ZBe02X+y6qgcjX3KVJ33Ok" +
    "qv79UZufO9B/FC4A2pdcHeKyFjj3PjB3LpsUF6kz1l7NIPvjwirMSVQ8oH8d" +
    "c+OJ1Xnl3HdRDYQHSn6mlQNqGxgHOToXAO1LQlzWA+feB+bOJcQlvw/61zFf" +
    "PaPXdfZSepGiGggTytdZckBtA+MgR+cCoH1JiMt64Nz7wNy5hLjk90H/OkY+" +
    "oMx1nb2UXqSoBsKE8gtyHFDbwDjI0bkAaF8S4rIeOPc+MHcuIS75fdA/jZFH" +
    "UNK5zV5KL1JUQwrvt1x5ZPEtVRd5ZJWflfJoBowBpWOox/6BEJe1wLn3gblz" +
    "2aS4fOCortHsWs2AMWRlv2bsJ7X/kpgb7tZrO3sp3ahRDSlM9MmTGKwMPkEN" +
    "1IOTsGAMKB1DiMt64dz7wNy5hLhcgnYF918S85XC511UQwoT3Xo/BiuDT1AD" +
    "9eAkLBgDSscwBXF56cv0QdpV/vS/Dwdz5/LyV+ljMBa7LC4/KnzeRTWkMBEH" +
    "WjpRBSdhwRhQOoYpiItw2fX6QAXDc/lteu3HZJfFRbji9tX5zV5KN2pUQ0qa" +
    "5E2zpP/68Cq3AWV/ZBXXbkAf9qnsoKlPOejp/NYtLvt0abRJ5MfhufZjYokL" +
    "a7oJVduAtTyvZ8L6Zx+O3YP7ZvZSulGjGlLUIjkTU3ZOxLMb0Id9Kjto6pOL" +
    "tG5xEV5zld4MwXBs4pjuurjw517bHqZTDTX8vlxJ6k1M2TkRz25AH/ap7KCp" +
    "zymIixACMw5yPOXeFtd7bPZNXITZS+mHoBpqmCDEZTzk1P1139cHLShH7rGs" +
    "890hsuvicus5veazl9IPQTXUMIEk9Sam7JyIZzegD/tUdtDU55TEpeaVly02" +
    "htzslfEE+ci6iUhv4mwlRcayy+Lyw4J3jFRDDRN894Gq+ueHC3kIlNpz6Jjj" +
    "/RMUl2D7obhInakaLazVizDegjEeiJcn8AljqA21ZhDVUMME7CALb+KePYeO" +
    "OUJcgjHYB3G58s4BxUWSsYMsvIl79hw65ghxCcZgH8Tl2mOrc5SPCVE/BNVQ" +
    "oxbI6MTFm7hnz6FjjhCXYAz2QVw+kfmOkWoQGCg/6/hPD43Pjw3+6Tww4tpg" +
    "vpoQl2AMLHFpqkWvVmkfgy59fvH0gOIiydjBGHCi88mGuARbxD6Ii3ynEzWi" +
    "1o4U1SAwUJKxgzHgROeTDXEJtoh9EBeBGlFrR4pqEBgov7rG5GPAic4nG+IS" +
    "bBEhLoXi8n/OL77mrhSJS6Gd0H8e8xAw4rrwvhCXYAQoLlJnufU/Bmo/DQQ1" +
    "otaOFNUgMLDroEonRv8Ql2Db2Bdx4f5J9aNGNQghLkHQjRCXEBe1OCEuwRCE" +
    "uBSIy7vuXNzQla+485APNaV4dkL/OdJ3ghfzQ/FJoL3Ow8UJcQmGQInLEV17" +
    "F2vZq9UhQJ8K+lsw5rzeP9QQQTUIK4tzNH8Q7sZ3oP8cTMqLcQ9Yw+KEuARD" +
    "EOIS4qIWJ8QlGIJ9EZcb8POu1BBBNQghLkHQjX0VF+vrLpWwCGnQe2eL84NZ" +
    "B//wYDkSVwLj50h7CvsAuXaZV4hLMDQUF6mzuna9ele1yto3YAz7IKpP+jAf" +
    "/Gs+lvEDaUpYhDTgYyfsQeWgBu7A+DnSnsI+QK49xCUYgxCXFnHhpgtxCYJ8" +
    "QlxaxIUBIS5BkM++iMtXzwwgLn85U6jvP9iRB1b5+wdXUf4Z/L3kSWAfCsYv" +
    "uSrEJRgBiovUmarJJWo/0A5Yy+Z+MHzG4CshLkb8khCXYAxCXFrERb4PM8Ql" +
    "CLqxL+IiulAsLkIacN0xnTgbLtaDWMwOqMX0YPySEJdgDEJcCsRlvjhG8iy4" +
    "WA9iMTugFtOD8UtCXIIxCHEpFJe/mw36ewbS3obn79ktvnc/MPK05rx/QYhL" +
    "MAYUl/ccaa5Ft1a7sKzvmiH6YA7heoiLvCtGHVHCIoS4BEE39lVcqCGCahBC" +
    "XIKgG/siLjKv3uLy1sPNHXAQxPP37BYhLsGUCXEpEBfhu7NB/q2BtK+b0jE0" +
    "+XNxQlyCIbDEhTXZRFOtXuQBAydHKcxn9nu/3j+pftSoBiHEJQi6EeIS4qIW" +
    "J8QlGIJ9EZd33BHi0ugf4hKMwb6ICzWi1o4U1SAw8Otnq+o75wzuB7Q73Hr/" +
    "KrSbeH3SDuq+rgxxCUaA4nLlnZdqs1O9O7V9q+RNUDFDwH7PDSguXzhtdNjQ" +
    "aQmdFtvrk3YQ4hKMyT6Iy7eG/CF6+U4X1aHRqbI7dFpsr0/aQYhLMCb7IC5y" +
    "skGNqLUjRTUIDPzIcaNDo1Nld+i02F6ftIMQl2BM9kFccr6FTlANNVygW+7T" +
    "fPtcGYy/RdoS6G/F0E7o34TMKcQlGBpLXJpq89ulWPXuoPydMdBuwa9l6SUu" +
    "bzmkO5gPzBh8G4z3FsKKoZ3Qv4kQl2AM9kFcuHeoHTWqoYbKxA7mAzMG3wbj" +
    "vYWwYmgn9G+CCxTiEgzBPojL2zOecRFUQw3F5UundSccuAfjvYWwYmgn9G8i" +
    "xCUYg30QF2pDrRlENdQwwSfvqaq/uW+CnAWZ9neHuAQjQHGROpO3boXc2sy2" +
    "G9R9NfbpwPh5jmQMXzg1grhce0wPZBJ4B6DBHuISjMGui8tnTg4gLvxdn6vv" +
    "0gOZBN4BaLCHuARjsOviIicZvcVF4CJxIJPAOwAN9hCXYAx2XVyuPro6P+vr" +
    "LWtUQwoV6htny5DPJKXQTuifFXNmlW8Q+i95V4hLMAIUF6kz1mAjTu3m4O0f" +
    "2r/O/ePEcN+kekFUQwrF5asNnTfBidBO6J8Vw8Uh9F/CRQpxCYZg18XlDbeP" +
    "JC433aM7boMToZ3QPyuGi0PovyTEJRiDXRaXL927OrdBxeVDx3THbXAitBP6" +
    "Z8VwcQj9l4S4BGOwy+IinzGkJtRaYaEaUvgZgr84rDtugxOhndA/K4aLQ+i/" +
    "JMQlGINdFhd+qf3bDvcQF4FK9dezU6OvnbG52eFrZ1eh3YIx7JMwvokQl2AM" +
    "LHG5+ewC1moprOH5/uhJTr7aVnK/RVANhOIiP+PIzjmIJigUtFswhn0SxjcR" +
    "4hKMwa6Ky2cLnsytUQ2ECd9/VHfeNFBCoaDdgjHskzC+iRCXYAx2VVx4i2QQ" +
    "cRHShG8+pDtvGiihUNBuwRj2SRjfRIhLMAa7Ki6l91sE1WBBxfrc7BTpK/dm" +
    "cMaB/haIkXs+KbSr+AbeiY+Nh7gEQ0BxkTpj7TXSsZZbYc4u3Ft+v0VQDRYU" +
    "l48eX3TowkES+lsgJsQlmDK7KC6fKviwYopqsGDi9x2t9CQsjIGuQH8LxIS4" +
    "BFNmF8XluoIPK6aohibSxHLfRU3CwhjoCvS3QEyISzBldlFcuFfaPqyYohqa" +
    "oHLJ9zp8+TS4dxX59roU178DzJELFyzEJRgCS1xYexfBfuB+UbXO/UN/aWMf" +
    "wM1pxHDv15rgoRqaYAfyUQBvYGrihP4dYI5cQlyCMdg1ccn9GREL1dCEvPWU" +
    "diD/7w1MTZzQvwPMkUuISzAGuyYucn91dHER2Im6NOJEOHFC/w4wRy4hLsEY" +
    "7JK4yC8r8i1oeZgu1YQ2VEMbFJcPHF0MIJtTq3zx9CrK34gptTf18Y4Ql2AE" +
    "KC5SZ6y9XFTtstaNendB/BdB6ntdh6dyU1RDG/xe3SsOGYNvgxM7bW/8tphS" +
    "e1MfIS7BGOySuPCrYEcVF4Gd3XDCmEATnNhpe+O3xZTam/oIcQnGYFfEpeuD" +
    "cymqwYMdymcO1ASa4MRO2xu/LabU3tRHiEswBrsiLtd0fHAuRTV48NORcsNH" +
    "Pmu0bfAnKUNcgiGguEidydcVCKzBKfNW491haoGHasiBiia/ZcLBTZ0Ql2AM" +
    "dkFcPn5idQ5CvfdLUA05sGP5WDkHOHVCXIIx2AVxke9s4h6v934JqiEXdi6/" +
    "Jc1BTpkQl2AMdkFc5F3gdA65nyUiqiEXiov8EttnTq3yaXJyFXkIbwXEW3g5" +
    "PHvN23FNGeISDAHFRb7UvqkWc2u1De4xZQeenfdUhXrPl6IacuHHAa64vdJC" +
    "QJyJMt7Cy+HZa0JcgjHYdnF5D55l24i4CByEqF6IS7DPbLO4DHUjt0Y1lMCB" +
    "yPVliEuwz2yzuFzZ84lcohpK4WCuv7sKcQn2lm0VF+uspeuN3BrVUAoHJIv5" +
    "V/c0cBLQPgReH8t2GWeISzA0lrioGmyqVUJ/iy4xBkOftQiqoQsclPymLAc/" +
    "Z6CFaMXrY9ke4hKMwTaKy40jnLUIqqELHFjjgg6wEC5eH8v2EJdgDLZRXPht" +
    "B0K9t/ugGrrCwZlnLwMshIvXx7Kd4vLab1aqUIKglG0Tl0/MeP2vVsfc5XNE" +
    "FqqhKxQX+S4IGXgRJzQ33bNKqV31sYS/ICewUIKgFPkjxY16k9TpEKDWrXr3" +
    "7NwHQz7XQlRDV6xTq48Zk2mFC5GxWJ5d9bFEvmCc433FqytVLEFQAmtKNq8S" +
    "ia6g1q169+zpHvj4PeOdtQiqoQ9c2OKzFy5ExmJ5dtXHEhE+jvdPLq9UsQRB" +
    "LvLHiTV1zV2VFomuoNatevfs6R6wzt5nL7Wvu6Ia+tD77IULkbFYnl31kUDV" +
    "fs1VlSqYIMhF/jix/v/y7kqLRFdQ61a9e/a69sc+axFUQ1+4uPKw2sfvXnJi" +
    "lRvvXuWiXwJ95G2zNlQfLXZ+Pipu6gZ9uOz61Xp60+3ttVgM94LskROFfSzj" +
    "xniuhaiGvlhnLx88uhQLLgQXyoA+arGA6qPFbt3MetkrKlU0QeDx0pdV1eu+" +
    "v1pL8nGYtloshntB9siJwj5mMR81Pvm8FeIicNCi4DdYC8GFMqCPWiyg+mix" +
    "f/AuvcDxvEvQBbmkZi3JH6+2WiyGe0H2yInCPu7WZ+xjCIugGoaCg3/PncZC" +
    "cKEM6KMWC6g+WuzyywW87hRe/aZKFU8QNPHKy3QNCfI5u7ZaLIZ7Aflz+pCr" +
    "CI5ziKdxLVTDUHACgjxYJ789OyXkh904TuHlr6pUEQUBkcuhy2/T9SPvlLLW" +
    "XGR/JMjN4BWkDagcLYjYWX9MZy+1f4dANQwJJyHfKM4JTwH+tKsQN3eDHHgT" +
    "V3jzIV1jWYwsLn1/5KwU1TAk1s1dOVPgpDeNKPob8Zu4tcDEGUxgIWcslrDI" +
    "mUHnM/QRxUV+oYNjFWYvtW+HQjUMDScjm1g2Mye/aeRhJ461Ju7BBClyj8W6" +
    "FBLkwTTWVjYjigt/h0iYvdR+HRLVMAaclPwUibwdJiKzgrQB8VvhbkC7A/On" +
    "fci4ONYaeRcp3qbeb5rOVmrecgj1VlirrMscmMPCehJ3rJu4KaphDDgxQc4U" +
    "piYu8h3AbQIjyKWSvO0oT2PGZ5F2G7kkftVrF2eu/LQzEWGR+lmpt8JaZV3m" +
    "wBxExrTOm7gpqmEsODk5GFMTl5qr77LvwTQhgiPFF+wOPMZNyMaV51lYQ3MK" +
    "a5V1mQNzEOuP5YGxP8dANYyFdXNXJj5FcZE2uSnHH6sPghS5j3Gd1EtTHRbW" +
    "KusyB+ZIeZ/xmMXQnx9qQzWMCScqyE9HfvhYC8dBqT0H5kh471H7tDLYX6Qe" +
    "5G1dr4bkD1SKW3eePYO6L/lKEatuD4x9ORaqYWw4WVkAeZtMLWzTApfac2AO" +
    "cO3xhci8887F5Zx10ILdRo67PA8lT5rL/cKcGtqkuPAnWQWxHxh7cixUw9jI" +
    "BDnp+c0wLmzTApfac2AOj2OLApNLPSk4GX+wW8gfErmXIvffsuqKNXJ8c+Ii" +
    "Y+ceW+flUI1qWAfWB6dkk6rFtRa41J4Dc3gwPgNVaKUYOYvZQM6PAM8/KwYo" +
    "/wzcGPZDO6G/jAu4MZ49A+s+i8A9uA5Uw7rg5AXz/gsXsNSeA3N4MD4DVWil" +
    "GDmL2UBOtYkd/6wYoPwzcGPYD+2E/jIu4MZ4dodrjtmX7Nx760I1rBMuwp/P" +
    "FuZDs9PQa1OOtSP+KbSv5GrCi6G9A3KDLcXtg3ZCfyOGa0Poz3z0n5PMYT4P" +
    "wpyE/hlwDLR3wc2JcXPeRMUbFPdJfwf5ahPuKREd7rt1oRrWifX2tHzoa2XR" +
    "eAB6HjATL4b2Dqhi9PqgndDfiOHaEPozH/3nJHMwNxVzEvpnwDHQ3gU3J8bN" +
    "eRMVb1DcJ/1bsB6b2MR9lhTVsG64IIIs1MWF4wHoecBMvBjaO6CK0euDdkJ/" +
    "I4ZrQ+jPfPSfk8zB3FTMSeifAcdAexfcnBg3501UvEFxn/Rv4CrjBq7AvbZu" +
    "VMMm4KII7zuyXDwegJ4HzMSLob0Dqhi9Pmgn9DdiuDaE/sxH/znJHMxNxZyE" +
    "/hlwDLR3wc2JcXPeRMUbFPdJfwP58ie5ncD9wz22CVTDpuDiyILJsyWyeCvI" +
    "grYgbxG3Qf857IN4/rRnkDWuQn/6EPqreRD6Z+D16dkHgfOwQIw7LsRfA5R/" +
    "Tk7ijZF9Hp3efZYU1bAprPsvIjBXOwtOeEAJ/eewD+L5055B1rgK/elD6K/m" +
    "QeifgdenZx8EzsMCMe64EK82Ov1zchJvjGl/R21h2fR9lhTVsEms519kAVcE" +
    "hgeEB8CB/nN4UInnT3sGWeMq9KcPob+aB6F/Bl6fnn0QOA8LxLjjQvymxUUe" +
    "9ONeEbinNolq2DRcLCUwPCA8AA70n8ODSjx/2jPIGlehP30I/dU8CP0z8Pr0" +
    "7IPAeVggxh0X4jcpLtYf4akJi6AapgAXTZC3qOUrMsdAHt5Lod2jSzxjCP3H" +
    "YF/63BmOVNVbt+CMpUY1TAUuniAfcVcLPgB9C75LPGMI/cdgX/rcFawvkp+q" +
    "sAiqYUpwEccSmL4F3yWeMYT+Y7Avfe4C2yYsgmqYGlxMQRaai9+HvgXfJZ4x" +
    "hP5jsC99bjvWt8kJU3nLuQnVMEW4qIL8Dq+8fS0P26VIW4pn74KXk3YLeYZn" +
    "BSPPCvBnPmscHozPwcvR154DcxD6yyeFFaU5e8Z3YtbPu4/YD8lNXVgE1TBF" +
    "ZCG5uLXAeAfZs3fBy0m7BcWCORTwZz5rHB6Mz8HL0deeA3MQ+ithMNaPOUjf" +
    "+C40CcuUnmVpQzVMlSaBkc8htR3kMYrAy0m7BcWCORTwZz5rHB6Mz8HL0dee" +
    "A3MQ+ithMNaPOUjf+FLkD+c2C4ugGqZM0/v78kBR00Eeowi8nLRbUCyYQwF/" +
    "5rPG4cH4HLwcfe05MAehvxIGY/2Yg/SNL0GEhTW+bcIiqIap0yQw8hyMfL+p" +
    "4gig3cKL8ewWpTH0J/S36BLTFm/BGFLq3zWmEPmhsBSvT/nkcRv070pTfW+b" +
    "sAiqYRtoukS64vaqupIHzCkaEy/Gs1uUxtCf0N+iS0xbvAVjSKl/15hCpigu" +
    "8geSNb2twiKohm2hSWDeQIFxisbEi/HsFqUx9Cf0t+gS0xZvwRhS6t81ppCp" +
    "iUuTsMhlEmt/W1AN2wYPhhIYp2hMvBjPblEaQ39Cf4suMW3xFowhpf5dYwqZ" +
    "irhInVqfbha24e3mNlTDNsKDIsiddnkn6d3gXQb0UdwJYJeHnDxUDqDGRB9v" +
    "TLk+LbhjsHD69HLSPvchToyyZ8AYD69PC69PaZM/hKzdXRAWQTVsKzw4tcC8" +
    "fXa9mhYqi8QsZsLCgJ1FZKFyADUm+nhjyvVpwR2DhdOnl5P2uQ9xYpQ9A8Z4" +
    "eH1atPUpf/iahIW1va2ohm2GB6lGrmfrQmWRmMVMWDiws4gsVA6gxkQfb0y5" +
    "Pi24Y7Bw+vRy0j73IU6MsmfAGA+vT4umPuUGrfUMyy4Ji6Aath0erJo33q4L" +
    "pLGYCQsHdhaRhcoB1Jjo440p16cFdwwWTp9eTtrnPsSJUfYMGOPh9WnBPgXr" +
    "Z1Z3UVgE1bALND0rIH8t/uKwUSgeLBzYWUAWKgdQY6KPN6ZcnxbcMVg4fXo5" +
    "aZ/7ECdG2TNgjIfXp0XanzwY13QZtIvCIqiGXUHewuMBrJG/HnLNWyOfsk5J" +
    "bRal/vOYw6u8g9AfeP45MCfJ8XfHQTvJ8Fd9Aq4l/XNgTo6Bdi9ejSnJIU+Q" +
    "/1nDZdC2PsOSg2rYNXgwa+SvSG7hkFL/eQwLj9AfeP45MCfJ8XfHQTvJ8Fd9" +
    "Aq4l/XNgTo6Bdi9ejWmZo+ltZmEX3hFqQzXsIjyoNfLXRP5yeIVDSv3nMSw8" +
    "Qn/g+efAnCTH3x0H7STDX/UJuJb0z4E5OQbavXiOSS6/rd9trmGN7iKqYVfx" +
    "LpPaCod4hWbB4isuZsc/B+YkOf7uOGgnGf6qT8C1pH8OzMkx0O7Fp+PZ18sg" +
    "ohp2HR7sGrlMkq/QlL84QVDMTFDeNuMNDaIi7PplEFEN+0DTu0mCXCOrwgkC" +
    "B6mbprMVgTW4D6iGfaHpg4+CvGUtD96xgIKAyCVQ272VfboMIqph32AxpMil" +
    "khQHCyoIBHkwkzWTUtfYvqIa9pG2m72CFJH8haqRH6Za4bBPGp+D2wftBsxJ" +
    "6E/oP49xxqH8u1C4dqX+8xgH+r9F8i5546H2S6B9PltJUQ37DIskRS6V5Lra" +
    "LExuOANVrA5uH7QbMCehP6H/PMYZh/LvQuHalfrPYxzoL6Ly5sPNnwmqqWsp" +
    "CHExYcGkyPW1Kk5uOANVrA4sduZTdgPmJPQn9J/HOONQ/l0oXLtS/3mMA/29" +
    "S6B9eycoB9UQLPAuleR+zMUi5YYzYLF6sNiZT9kNmJPQn9B/HuOMQ/l3oXDt" +
    "Sv3nMQ7iIzf15TjHJVA3VEOwCouJyJmMXC7J9/eW8GZAO6G/FL6L18ehdhhv" +
    "5VB25jFiXJiD0N+D8Rm8/nZ9rMmBUS/BJVRDYMPCIvU9GVXYDahN6UB/JSQW" +
    "Xh/GpkphvJVD2ZnHiHFhDkJ/D8a3kCMq2/y9tutENQTNeJdKJSKjNqUD/ZWQ" +
    "WHh9GJsrhfFWDmVnHiPGhTkI/T0YD950KE9U4hKoDNUQ+OSKjNwEVIW+RG1K" +
    "B/orIbHw+jA2WgrjrRzKzjxGjAtzEPp7MH6JiIr37k+ISndUQ5BPjsjIzUC5" +
    "LyNCU4LcSGzjjZLTw8jbG6cPNU7ixGf7tMF4IMcjR1Ti8qcfqiHoBgvTQgpa" +
    "Tr/VZjDgJiXcMCZG3t44fahxEic+26cNxs+QDxTmCIoQojIMqiHoBwvVQs5m" +
    "pNDNzbeEm5Rw85gYeXvj9KHGSZz4bJ82lnEiKHKW0vZWckqIyrCohmAYWLhN" +
    "NF02cZMStQEtuOmGwOlDjZM48dk+LZQIinBgHL+gP6ohGJa2r3cgfzbjz2e8" +
    "Xv79VTuygYjEpii7l2PZdw39LRjDnPTPgTkI/WtKBEU4MI5XMByqIRgPFncb" +
    "slHqyycLbrj5pjtYRdm9HBKTQH8LxjAn/XNgDlL71WvEtWvjwDguwTiohmB8" +
    "2r5LpgmKDTfcfNMdrKLsgHYKBf0tGMOc9M+BOdI8pWIixL2UzaAagvWS83a2" +
    "hSU0uyYu8t9dxESIZ1M2j2oINkfJ/RkLuWdTs03iUp+VdbnMIQfGugabQTUE" +
    "04EbJ9AcGOsWTAPVEEwXbqx9JL43ZXtQDcF20OWm8DYSYrK9qIZgu+l6g3jT" +
    "xA3Y3UM1BLsLN/QmODDGFewmqiEICC/B4rmRIAfVEARBMASqIQiCYAhUQxAE" +
    "wRCohiAIgiH4L/kL3SGuybvcAAAAAElFTkSuQmCC")

SAVE_ROLLOVER = ("data:image/png;base64," +
    "iVBORw0KGgoAAAANSUhEUgAAARcAAAEXCAYAAACH0wDUAAAzjUlEQVR4Xu2d" +
    "edQ8ZXXnnYlbjLgl7gsuuIG7CIgICCj8BGQVkEVRlEVAcENFIyqIqCEYcWPU" +
    "SNwVjTpEJhmX5LjCyW9GDYkkoxk9wWFmjjkmRzPOzMmcU/Pet7t+VH3ufeo+" +
    "Vf1Ud7/d9znn889z73Ofpe7z7arq6urbbK+q2wRBEJRGVQRBEJRAVQRBEJRA" +
    "VQRBEJRAVQSrz2VXV9VrrryV099aVQe9tM1Dj9hwfLLP3Z+h2z73Ne34AscQ" +
    "rD6qIlgNPvuVyaaWjS4bnqKwSJ588q0CdNUfh/CsKqoi2FrUZyF9zjaWlfos" +
    "KM52VgNVESw3IibyqS8bkZtzVakFh2sRLDeqIlgu5LJhTDF58klVdeBZbS74" +
    "A82fffdWaBMYQ2BfJZB1kPUQkeVaBcuFqggWi4iJ3GAtdYkj9zdqwbj0DzfE" +
    "4TtV9fNfVNW//qvB/xtAZgwRpfd/bjKOYy+YjItjHUKIzfKiKoL5Ixtjls0m" +
    "G+yAM6vqtIur6lXvqqrrvl1V3/mrqvrf/7cn/wfQbvkQ+jvc9JPJeGXcgsxj" +
    "lrM0EeUQmuVAVQTzQb7NkU9cbo4cZPMd8+qquuTDG5vzvw7f2IocoaAPof9A" +
    "RHTe+9mJYD7kOXoNcpB7NfFt1OJQFcG4yCVP30/mppjsOCPhpi6xsXPi0YfQ" +
    "vxBNsem7foKsuwg6j0cwHqoiKI9809H3HopcHrTEhHBTl9jYOfHoQ+g/ErIu" +
    "sj4iun3ERo5DfPM0H1RFUAY5He/z8Nrd96+qF725qj765ar61f/K4NeafwG0" +
    "qxjgX4Bqb8E4tAP2wTFvjrtnTOGb36uqV/z+ZB25tinkPlfcnxkPVRHMhohK" +
    "n7OUo15VVe/+dFXd/D+NTdWFscHUJiWMAbjxVXsLxqEdsA+Oeai4NBGBFqHm" +
    "WqeQM584mymPqgiGIZ+AuaLyxBOr6i0frKobf2xspFyMTaU2KWEMwI2v2lsw" +
    "Du2AfXDMJcSlbieCLcL9jDP0MbAIkSmLqgj6IcmYc83/kMMnp+3f+t50484K" +
    "N9SvjU1KGANw46v2FoxDO2AfHHNJcWkiQi7rL8eBx4aEyJRBVQR55IpKfR+F" +
    "m4rJ3xtuqF8bm5QwBlBjZHsLxqEdsA+OeSxxaSL3Z3Ivm+RbJh77IA9VEXST" +
    "Kyqnvqmqvv93VfVPvxyJXxnQB/wzoD2Lnn3OBW9MtE995Picf3lV3S3jJnCI" +
    "TH9URWAjosKEsxhdVGp+ZUAfEOJi+/z0lhCZMVAVQRt58Mq7UStJKck5F1Gp" +
    "kQ1C6ANCXDp8fpkvMnLmGl9h+6iK4Fa851RqUZGkZKKOTr1JmtAHhLh0+DSQ" +
    "4/mmq6rqwc7NX3lOhjkT3IqqCPxLIBGVl72zqn58c1X9/J+CZeMf/7kN7X24" +
    "/OO+yMQ3SzaqYt3xLoFCVJafkuJS88YPdF8uyaVS/EiyjapYV7xfKO93+kbi" +
    "/FAnXbB8jCEugnyoPP8inRtN5FKaubWuqIp1w/tqWT6tPvwlnWjB8jKWuNR8" +
    "/mtxqZSDqlgnvBc0nfOOqvrbn1bVf//HFeHnDvQvwTz6WBCSH12XSnKJvb2R" +
    "b+uGqlgH5OvlrrOVfV8yeS0jk2nLw41O6F+CefSxQG7466o6/OU6h5qs69fW" +
    "qmLV6fomSD6F3vlRnUArAzc6oX8J5tHHEiAfWDsfpnOqRu7pbUcurjqqYpXp" +
    "ugw65+0bl0A/qVZ6A6iNTuhfgnn0sUTIpRJzq2bdLpNUxSrSdRkkZysf+Pzk" +
    "5/nF+B8GOT5d/mPAPgn9M/gZoD2rjxyfDtwxCOjjZ4B21Z40fK/7VvdZzLpc" +
    "JqmKVaPrMuhxJ1TVd35gJMqsMDGt5KSd0H8M2Cehfwbuxs7pI8enA3cMAvoo" +
    "KS7CX/+4qg47X+dczTpcJqmKVaLrMujsy5zkmwUmppWctBP6jwH7JPTPwN3Y" +
    "OX3k+HTgjkFAH6XFpW5z4Xt17tWs+mWSqlgFci6D3OSbBSaZlZy0E/qPAfsk" +
    "9M/A3dg5feT4dOCOQUAfY4mLIP/LtI6XSapiqyOPYPPg1Tz2+Kr6xveq6ie3" +
    "gP8GaCfw/ylQ/rdMfgzXIqNNV3vax4B9mv16a+fZx4B9WnhtYFfHizAeYv7g" +
    "v1TVoefpnKxZxVc5qIqtjBwgHrSas95mHHwjCZKJ0uGvEo/+t+hNmtOmqz3t" +
    "Y8A+zX69tfPsY8A+Lbw2sKvjRRgvEbPrHuCqCYyq2KqkhOWu+1XVe68xDryT" +
    "BJ3AXyUe/W/RmzSnTVd72seAfZr9emvn2ceAfVp4bWBXx4swXkfMa79ZVQ86" +
    "VOeqsEqvcVAVW5HUjw6Tl0EkkQRJ4K8Sj/636E2a06arPe1jwD7Nfr218+xj" +
    "wD4tvDawq+NFGM+J+YMfTfKTObtKAqMqthqpb4Qec1xV/aebqurH/9DmRwby" +
    "a9cmtP9I6prQngNjEPoPgPNw5+6MQcWjv9HGtRP6D2lDO6F/RptZ1y7LZ6Pu" +
    "hAt17gqr8E2SqthKpIRl28smwpKVJFJ/MzYQfbwkyYExCP0HwHm4c3fGoOLR" +
    "32jj2gn9h7ShndA/o82sa5flM61PCYx848mc30qoiq1C6qvmE17XPoBukkj9" +
    "zdhA9PGSJAfGIPQfAOfhzt0Zg4pHf6ONayf0H9KGdkL/jDazrl2WT8N2xqU6" +
    "l7e6wKiKrUCusAhukkj9zdhA9PGSJAfGIPQfAOfhzt0Zg4pHf6ONayf0H9KG" +
    "dkL/jDazrl2WD+yXfFjndM1WfMudqlh2UsJyyYeMg/cPGUki9TdjA9HHS5Ic" +
    "GIPQfwCchzt3ZwwqHv2NNq6d0H9IG9oJ/TPazLp2WT6037xaAqMqlpmUsMj/" +
    "LssvmoWbPH5qQJ85UI83NW7PXoISfTAGoT+Rl3EpesZYxPHkGC3YJpfPfW3y" +
    "CAXzfKsJjKpYVixhkQPwrk/2PKBMxDklI/ES0bOXoEQfjEHoT5SwhLhs0iUw" +
    "3BvLiqpYRqw38svCywHofUCZiHNKRuKN27OXoEQfjEHoT5SwhLjsQPJ7t+N0" +
    "7m+Vm7yqYtmwvm6uhUUOQO8DykScUzISb9yevQQl+mAMQn+ihCXEpUXqDGYr" +
    "CIyqWCYsYREuuqqqbvzxAvkRoN1A3u/RxLN7sP1WhfPKwYtBewlK9MEYHnW7" +
    "z3zFFphlf9BOVSwLqd8KLVxYhBCXYnBeOXgxaC9BiT4Yw6PZVgSGe0FY5p8K" +
    "qIplICUsL79cH7CFEOJSDM4rBy8G7SUo0QdjeLC9fLByTyyzwKiKRZP6Sbr8" +
    "ODF3I49OiEsxOK8cvBi0l6BEH4zhwfZCSmCW8XUNqmKRpF70dMwFVfW9v5vw" +
    "ffK3bWq/JOJD6EP6+ufQN2aGv1obQH8Pru0mTkxl57iJEcPzYR+E/oPAGLgO" +
    "9Kfd8inFC9+s98gyCoyqWBTyakoulrDXqe2FZSL1PqCNhEklr6Kvfw59Y2b4" +
    "q7UB9Pfg2m7ixFR2jpsYMTwf9kHoPwiMgetAf9otn5LIBy73irBMr8xUFYvC" +
    "ekhu1+dW1Tf+c3tRmUi9D2gjYVLJq+jrn0PfmBn+am0A/T24tps4MZWd4yZG" +
    "DM+HfRD6DwJj4DrQn3bLpzQpgeHeWhSqYhFYXzlbwiIwkXof0EbCpJJX0dc/" +
    "h74xM/zV2gD6e3BtN3FiKjvHTYwYng/7IPQfBMbAdaA/7ZbPGOx6rN47y/IV" +
    "taqYN9YN3LvsW1Uf+3JV/eXfGPywzfa/aUP7EFRMYrTpaj9kXKo9Mdoo+rah" +
    "v4XTZvsP29BfzcvwIW5Mgj6UXdp583JQ8SzYB6G/B9tv8PWNTfSAbXoPLcP/" +
    "IqmKeZK6zyL/9cJFTB0QJhLtQ1AxidGmq/2Qcan2xGij6NuG/hZOG2/TqXkZ" +
    "PsSNSdCHsks7b14OKp4F+yD092D7aYyPXaf3kLDo+y+qYp5Y91mOfpWxgB0H" +
    "hIlE+xBUTGK06Wo/ZFyqPTHaKPq2ob+F08bbdGpehg9xYxL0oezSzpuXg4pn" +
    "wT4I/T3YvhHj3MR/VHPPzRNVMS+s+yyP3rh+/PpfGgtoLGYNE4n2IaiYxGjT" +
    "1X7IuFR7YrRR9G1Dfwunjbfp1LwMH+LGJOhD2aWdNy8HFc+CfRD6e7A9Yhz0" +
    "Ur2nFnn/RVXMg9R9lquvrarr/6rNd2flxgzQRo2B/kNgHze28fwV9LdgG44B" +
    "0F4Eb0y0Wz5ArZ3h0+VvrbdaC/owpudvtHHx2tMO/uMNVXX/Jbr/oirmAScv" +
    "vPZKfcCKJLxxEBRoo8ZA/yGwjxvbeP4K+luwDccAaC+CNybaLR+g1s7w6fK3" +
    "1lutBX0Y0/M32rh47Wk3kA/o2zxZs4j7L6pibKz7LEe+crIwPGBFEh6Lb4I2" +
    "agzwl0+It/5hVZ3yxqra4/nBqtA8c+Yx75sjVhsXrz3tFht+Z1+m95jAvTg2" +
    "qmJMrGvCRx0z2ayyMDxgyyIun//6REgOPMs+7QxWg+al+Xdv7Jcjyt9o4+K1" +
    "p91i6nvgmXp+877/oirGwvrd0E4bB/NDX6qqb35/yvd8vgVoL0I9ng1O+l09" +
    "7mB12czJL3bnRG6uzorKdY7BGse0/rrvVNX9DtHzk/ud3JtjoSrGwrocevW7" +
    "nYUyUAs+Bhtj+cxXq+qRx+gxB6uPKTDeph4BlescgzWOhk0+uDk3gXtzLFTF" +
    "GFjvZ3nGGRkLZaAWfATOfNskwThmC/lKXS73gq0Lj6mgBGZArs6KynWOwRoH" +
    "7Ce9Qc9N5sw9OgaqYgw4OTlw8mYtLoRaKAO14AW57ttVtfsp7bE2kWtW+VpP" +
    "7rx/5YYqyooU65K9ztMdAjMgV2dF5TrHYI3DsFuXR/P4ixJVURrrYTlR09RC" +
    "eKgFL0iXsMjZ1y9+ybSMsirFFZgBuTorKtc5Bmschv2KT+p5zeMF36qiJPIJ" +
    "z0k98uiq+ovtE/58SZCxnGFcutUHQX4DFWX1S5fAiI0504Q5leszi79FKsb+" +
    "p+t5jX1zV1WUxLqJe/nH9cQXzaf+1L7HIpdAcbayXiVXYOoc7srlHJ9Z/C1S" +
    "MT6ZyPEN023GQlWUwrqJe/jL7Ykvmt2NSzcRlijrWXIEppnHqVzO8ZnF36Ir" +
    "xomv13Ma8+XeqqIUnIQcmD/5Rnrii8ISQTnjWtQZi9woDoZR8ph5AtPM41Qu" +
    "5/jM4m/hxbBu7o710wBVUQLr71dfcvFGAlwPjARxYQxCf9LwlRdS7fR0PdZ5" +
    "32P5+59NRM66jAz6Ieso61miJAVmI2fed42fd18FtPeGuX59/z7e8Ud6PmPd" +
    "3FUVs2L94vkRR21M3FgYTjwLxiD0Jw1f+R8kjnXel0MiZCEq5RFhKFGyBYZ5" +
    "dkP/je/CXL9+WB+HnqfnM8Y/B6iKWbE2yvuvWU5xOeF1eqwlT629knoTX1AG" +
    "Od0vUbIEhnl2w7CN3wlz/fphfXzhz+0zdu7lWVEVs2CdtcgGFmFZRnF50knt" +
    "scqTi/MqcupuCXFQFjnmJYorMMyzG4Zt/E6Y69cP7+PFF+u5lD57URWzwM0i" +
    "C3/N16rqP3wnwbcB7QX4U9Dsj4sr4jivYt1IDspT8gOjS2De8+mN/Pp2G+bi" +
    "PFD5Thr5f9+D9Vy4p2dBVQzFWvhnv8yYXGKi8xaXKz+tx1vqOj2nUIiD8Sh1" +
    "g1eKleeCJTDMxXmg8p009tvL3qnnUfLsRVUMxfqG6CPXGpNLTHTe4mIt7Pab" +
    "mErjFDktZd+rSsnC2LmUuvdSl1yBYS7OA5XvBHtuzLMXVTEEa7HdsxZjospe" +
    "ALXY076Oe60e87xKiMuwwti5jHG5a+W80BQY5uI8UPlOsOde9BY9h1I/C1AV" +
    "Q7DOWj70haq69pvgG93IQ3aEPsT1xxj+ZMoTTmyPt+S1uVdCXIYVxs5lDHGR" +
    "khKYO28IzLs+dWuu1ahcZP7Sn7k8BPYL+6f/bDLe5vhLPfeiKvpiLfAh5+ZN" +
    "jKjFNnyI688DOiXEZT6ULIydy1jiIsXKf8ESGJWLzN+G77zERTj2Aj3+Emcv" +
    "qqIvybOWzIk1UYtt+BDXnwd0SojLfChZGDuXMcVFSq7AqFxk/jbyc57iMtbZ" +
    "i6rog/UQ2I6zlsyJNVGLbfgQ158HdEqIy3woWRg7l7HFRUpKYCTPll1chDHO" +
    "XlRFH6xXBL7lg1X1xb+YIE8CluaLDsp/OhaO6fHPa487xGUcShbGzmUe4iLF" +
    "EhjJM+ZkCi+XLdiG0J/Ufp+4rvzZi6rog7WQ1kYuCRePKP8Ql4VSsjB2LvMS" +
    "Fyn8wN0q4iIc82q9drP8YlpV5GI9Ydo8awlxSZcQl2GFsXMJcUnT9L3q83rt" +
    "Znnfi6rIhYPgWUuIS7qEuAwrjJ1LiEsa+h98tl4/7v1cVEUO1rXlmZdW1TVf" +
    "7eZzgPYSuH18bcLjTmiPP8RlHEoWxs5lkeIieaZyMIGbu3Pg7R+1148akIOq" +
    "yIELKPzRtXqgZB6L5/YR4jJXShbGziXEpQcbe+Pez2rPYejfwKqKHHjwnvnS" +
    "vMWYx+K5fYS4zJWShbFzCXHpwcbeOPJVeg3lsRPqgIeq8LD+LuSVV+QtxjwW" +
    "z+0jxGWulCyMnUuISw829sZ7r9FrOOTX0qrCg0/kynfjuYsxj8Vz+whxmSsl" +
    "C2PnEuLSg8T+EKgFHqrCgx0e8YrJ48PCpxxqv1z/IW08/7r+sce35xHiMg4l" +
    "C2PnskhxkTxL5aKHl8uWD6E/Sfm/5BK9jvJFDvWgC1XRhfVsy9s+ogeWIjWR" +
    "Lvq28fzr+hCX+VCyMHYuIS5pUv4f+pJeR5kbNaELVdEF35720OfYA0uRmkgX" +
    "fdt4/nV9iMt8KFkYO5cQlzRd/geepdeSmtCFqkhh/UhR/sEtNTCLromk6NvG" +
    "86/rQ1zmQ8nC2LmEuKTp8j//cr2WfX4OoCpSyP/5sKPf/0RVfey6NB8H8idk" +
    "nRgxZuXjX25T9/WY49pzCXEZh5KFsXNZpLhIntU5x/1AVO5mwDZ9UfsD9t/a" +
    "pz2fPs+8qIoUPGB7vkAPhKiFoJgQI8asqMWbEuIyH0oWxs4lxCWN2h+wy/+7" +
    "cz2pDSlURQp2IO/e5ECIWgiKCTFizIpavCkhLvOhZGHsXEJc0qj9AfvFH9Lr" +
    "mXtppCos5OCwA++SaHPgQIkJMWLMilq8KSEu86FkYexcQlzSqP1h+PDSSG6R" +
    "UCMsVIUFF+xeB1XV1f9eI38l0kTZAe0WjOnhtp/2vdtz23MKcRmHkoWxc1mk" +
    "uOx23EYeXjuB+c/czM3d1h6axt7RBzHa9GWP57fnlPsSKVVhwYMlf2TNhbAW" +
    "Q9kB7RaM6eG2n/Yd4jIfShbGziXEZTasv+GhRlioCmJ9BX32ZXohrMVQdkC7" +
    "BWN6uO2nfYe4zIeShbFzCXGZjTf9O72mOfddVAWx7re877N6IazFUHZAuwVj" +
    "erjtp32HuMyHkoWxcwlxmQ2JO+S+i6og8pq7ZtCdD6uqD37BRv5SpIsPfrEb" +
    "+m+2Aa5d4jRQ9im7hrjMhZKFsXNZpLhIniVz1YH+Jt4ecvaD237qt+9L2vPK" +
    "ue+iKggP1LZzjQFO4aAIJ0LoX0+sqw9ldxazbhfiMh9KFsbOJcTlVnq3n/qd" +
    "8ka9rtQKoiqaWPdb5HWWaoBTOCjCiRD61xPr6kPZncWs24W4zIeShbFzCXG5" +
    "ld7tp37yA2VrXakZ2eJi3W/5g08ZA5zCQRFOhNC/nlhXH8ruLGbdLsRlPpQs" +
    "jJ1LiMut9G7f8L3nQe25yVypGdniYt1vef/nG3yumw8A2skHPm9gxOkTUzEd" +
    "+6OPbc8txGUcShbGzmWR4iJ5pnJwysy5jPYWff27ePqL9dpur7Ru1KiKlhGB" +
    "Dj6nCnEpUEJchhXGziXEJd+/i5PfoNd2e6V1o0ZVtIwIdN7lVYhLgfKLX7b7" +
    "XmUu+0g5GDuX7TdVcyurLC6XGL8z6rrvoipqrPstLWEJcZmpWK+wCMojX5nO" +
    "s6yyuAh83qWIuNzpaVX1ns+0uRKUtls+fXnPp9vU9Y86pj2/eYvLOl0aLRJ5" +
    "7+s8C8VF8ow5nYK5S+g/pI1n97D2DbXDFZecRfIGOqvd8unLsoqLFOudxEE5" +
    "FnFMc/ZNCuYuof+QNp7d41lnt+fX9TCdqqjh+3IlKDvyBjqr3fLpyzKLi5QQ" +
    "mHGQ4yn3tuZd1k1cBGqHKy4MEOIyXpFTd/4fVDAM+VCc57dDLKsuLue+Q685" +
    "taO3uEhQduQNdFa75dOXrSAudZEnomVjyM1eGU+Qj6ybiPQizlaaRcayyuLy" +
    "ZuMX0qn/M1IVgvXY/6uuqKp3fbKbK8gn2nj+tGchcZvAzj5qHnl0e36SFFGi" +
    "zFooLpJndW5yPzAnmbsK5jrjGTFd0F71aUBtSH1jpCoEflMksAOLvgOnP+1Z" +
    "YLFpZx81IS5RxijrIC4PfHZ7jqnXL6gKgc9gSDB2YNF34PSnPQssNu3soybE" +
    "JcoYZR3E5QnPa89RfiZEDUmKi7lARiek78DpT3sWWGza2UdNiEuUMYq5d6a5" +
    "yf3AnGTuKpjrjGfEdEF71adB7j8xqorNSjQ84Myq+r2PZvAxQDuB/zs/2h8V" +
    "E9C/5hFHtecY4hKlRKG4SJ7tyO+eMJdNprGTOP7s04IxjjWeLqeGZIuLBGMH" +
    "Jhi4shP4UwByUDEB/WtCXKKMUdZBXE6/tD3HmcTljEt1ByYYuLIT+FMAclAx" +
    "Af1rQlyijFHWQVykjhphfWOkhMUSF/nXNXZggoErO4E/BSAHFRPQvybEJcoY" +
    "JcSlQ1ysZ1zk5+7ymjvF1d3wJ/ODkDgN2Icak0Md9+FHtucY4hKlRKG4PPwo" +
    "ncM7cvkj3XAv0J5DiRiKq7VGZImL9YxLclDc6IATGwQPCPlIP+q4IS5Rxijr" +
    "Ii674Mw/xKURN8QlyhhlXcXFepAuxCXEJUrBsq7iIvOmlrjicv9tVXXxhyev" +
    "uPOQG79NPPsiuETmssEuIS5RRigUl12O0Ptgx374MGCuZsA2ZFb/TaZ7pkb8" +
    "HoZf8Q8Sl4dtbMIQlyhR8kqIS4e4cHFCXKJEyS/cP6sqLvu+WO8fakmIS4hL" +
    "lIKF+2ddxMV63aUvLhuL86arquqiAUi7PrB9Dl6MlJ1vfgtxiVKicP9Innm5" +
    "mGu3YBuPIe3ZRtjntPY8BWqJKy4SJNWBBwfpwfY5eDFS9hCXKGMU7p8Qlwbc" +
    "dCEuUaLklxCXDnFhgxCXKFHyy7qIy/Pf2J7nIHHZ+0VV9Yb3VdXrByDtuqC/" +
    "Bdso3gtoT/DQ57TnGeISpUShuDxkI89e/94JzEGicj8ntx0fFdOB/hbid9Ib" +
    "2vMMcWkQ4hJljBLi0iEu8j7MEJcoUYaVdREX0YXe4sLFedJJ+Z0SDpzQ34Jt" +
    "FM7ipghxiTJG4f4JcWnAxZFNmNsp4cAJ/S3YRuEsbooQlyhjFO6fEJcGXJwH" +
    "H15Vr3335H0N5LXk3W08f89uxiRGnM6Y0zgyrxCXKKWLtX9SuchcVnbAvbAJ" +
    "48Ku+qCd/RhtFBt+e53anqd8K0YtCXGZEuISpUSx9k8qF5nLyg64FzZhXNhV" +
    "H7SzH6ON4kotLjJvaokSF2nIxTEHcWXGxBx/z27GJEaczpjTOCEuUcYo6yIu" +
    "1v6hlrjicrf9E4O4MmNijr9nN2MSI05nzGkca3GiRJm1hLj0EBfhlVdM/oje" +
    "5V1tpF0Xyt+CbTwQk/Y6zs6H6cWJEmXWQnGRPGMOp2Duci/QboJ8Vzj+HNMm" +
    "jTFsjuMKe/9QS0JcQlyiFCzrKi6nvzXEZUccLk6IS5QSZV3E5T7Pas9TdINa" +
    "osTF+t+izYnngIGrQQLlb8E2HohJex0nxCXKGGVdxIUakSUum5Vo+MI3V9V5" +
    "v6c5//I2yg5oP0/aNKHdiEHor2AfUx50aHuOIS5RShSKi+TZjlxlHiJXmdtE" +
    "tc+IQTvJ8aePQI0YLC5Hv1p3uNnp5W2UHdDuLZQVg9BfwT6mhLhEGaOsg7ic" +
    "9bb2HAX5q5TtDQ0RlLBsVqKhvNOFHW52enkbZQe0ewtlxSD0V7CPKSEuUcYo" +
    "6yAux7y6PUdhe0M/alTFZiUa7n6K7nCz08vbKDug3VsoKwahv4J9TAlxiTJG" +
    "WQdxyXkLnaAqBC7QA59dVWe/XXNOT9ie0N9qQ/s572hD/xQypxCXKKWLtXey" +
    "c3kAjEk8f89uwdey9BIX+c662fCu++kOrIF5sD2hv9WG9hCXKMtU1kFcrL1D" +
    "DUmKi/WsCzuwBubB9oT+VhvaQ1yiLFNZB3G51zPbc7T+hD4pLtazLse9VnfC" +
    "gXmwPaG/1Yb2EJcoy1TWQVyoDdbX0Elx2TQgwLPOrqozL+3mDIe+/jlt+tpr" +
    "HhDiEmWEQnGRPGPu7eCtAPbcXO6CMTzYfpPGGI81vimSkxHqRy9xeeKJRqeA" +
    "AyV9/XPa9LXXhLhEGaOsurgcfn57fgK1wxUX/q/Prs81OgUcKOnrn9Omr70m" +
    "xCXKGGXVxUVOMmYWl16LNIUDJX39c9r0tdeEuEQZo/TaN1tQXHY9tj0/6/WW" +
    "rrhY3xid9pY2L74YSF2D0y7upq//ZhugxkQS/vff1p5biEuUEoXiInm2I7+Z" +
    "q4ncTNlNkO/ufiEZfTb9rX1D7XDFRX4rQHE55XedgTgTJX39N9sAtTgk4W8t" +
    "UpQos5ZVF5c7PLU9v9Q3RZ3ismmEuBxwpjMQZ6Kkr/9mG6AWhyT8Q1yijFFW" +
    "WVyOe117boL1g8VB4vL4E5yBOBMlff032wC1OCThH+ISZYyyyuLylOe35yZQ" +
    "M7LFhb8h+J0DnYE4EyV9/TfbALU4JOEf4hJljLLK4iJ/8Nac292fMYO4WDd1" +
    "n3dhVb3goilvanPqRd0o/wzYZkffqTEQjmNaf79D2vMKcYlSolBcJM+SuUwu" +
    "6kbltiD1DVSbGe3Nfnm/JfXYf5a4bDpAXJ76wkbHWBwOlCj/DNiGE6ed7TmG" +
    "uj7EJcoYZVXF5fCXt+cldN1vGSQujzi60TEWhwMlyj8DtuHEaWd7jqGuD3GJ" +
    "MkZZVXGRdzpRC6gVRFUQLtZO+zY6xuJwoET5Z8A2nDjtbM8x1PUhLlHGKNwv" +
    "qyIu/BM0735LlrhY912OfGVVnfyGqjoJSF2Tk363G+VvwXawnyxxGih7gvse" +
    "3J5TiEuUEoXiInnm5eIOBuZyJ4jpofab1G/EucNe7Xl591uyxGXTCeKy1wsm" +
    "HXqT5yCJ8rdgO9jV4tCeIMQlyhhlFcXl2S9rz0m46o9HEpeHHzUZuDd5DpIo" +
    "fwu2g10tDu0JQlyijFFWUVye1OPHii3dYIUFF2ynp08G7k2egyTK34LtYFeL" +
    "Q3uCEJcoYxTulVUQF+6Vrh8rNlEVFtbvjA47v6pOeF03xwPaCf2tNp79hAsB" +
    "7VP4d5QhLlFKFIqL5JmXizXMbUJ/qw3t5PgL29Cu9s+Feu9b/wttoSpSsIPH" +
    "P88YGCcCaCf0t9p4di6Msk8JcYkyRlk1cXnaae35CDn3WzY1gxUp5KunZgf3" +
    "eIYxME4E0E7ob7Xx7FwcZZ8S4hJljLJq4rLLke35CNSGFKoiBf9uRJBX3qnB" +
    "NScCaCf0t9p4di6Osk8JcYkyRlklcTnmgqq6Pb6Clt8bUhtSqIouKC6POqaq" +
    "jr0gjQyuCe1DYExCf1L73fuZ7bmEuEQpUSgukmfMvRTMVUJ/qw3tRF6w3UXT" +
    "90knt+cieI/8t/SCFV3wvbp33kdPrmuitA+BMQn9Se0X4hJljLJK4sJXwQrU" +
    "hC5URRfW07r7vkRPMDVR2ofAmIT+pPYLcYkyRlkVcTnEeHAu56ncJqrCgx0+" +
    "9Dl6gqmJ0j4ExiT0J7VfiEuUMcqqiMtjj2/PQ0j9P1EKVeHBF0jJDZ8jXjlB" +
    "fnPUhyNe0Yb2MeFfUoa4RClRKC6SZ6n9Uden7IOQfdSE9kzutn97Hjk/VCSq" +
    "wsN6oO4JJw5bnBCXKKtWVkFc9j9D7/HcB+eaqIoc2LG8ym/I4oS4RFm1sgri" +
    "8oij2nMQqAE5qIoc5MYOO3/m2XqQHiEuUVatrIK4/NY+7Tnk/paIqIoc5MYO" +
    "xeXRx05+b9TkUHDYeQ5oPwjGTHDPA9vjD3GJUqJQXO55UP/cTMJcP9/YY7Sf" +
    "10bFBLynKrzmyjmKi8CfA4jaqYlx4sZkvMXrDWMmCHGJMkbZ6uKy82Ht8Qvc" +
    "+7moilysnwOI6nVO3JiMt3i9YcwEIS5RxihbWVwOMG7kyny493NRFX3gQFoL" +
    "aU3cmJC3eL1hzAQhLlHGKFtZXHY+tD12IfcX0Baqog9cSGGvUzsmbkzIW7ze" +
    "MGaCEJcoYxTuia0iLtZZy9AbuTWqoi8ckPwr4yHnTDgYHHIumPoVhX0kkHGG" +
    "uEQpXSguv32g3gc7OLcb5rZqb8Vw7KmYD3x2e9zCLGctgqroCxdTeMop9mJw" +
    "g3OiRWAfCUJcooxRuB+2grjI7wO5h2c9axFUxRA4sPrshRPlBudEi8A+EoS4" +
    "RBmjbEVxkd8Hcg/3ebVCClUxBC6oIGcvnCg3OCdaBPaRgOIi33RFiTJr4V5Y" +
    "dnE58Kyqut2e7TEP+R2RhaoYgvVQ3QO2TRa6xVn9OfClbZQd0K6YjoX/ICdE" +
    "iTJr4UNo9zhA52hJmN+enVj7YOhDc0RVDIUvkhLk5b7LKi6PO0GP9ys3MFWi" +
    "ROlXmFOyeZmjJWF+e/Ym+58+3lmLoCqGIneWubDq7MWYoMdY4mK91VyuM6NE" +
    "GVrkw4k5Je9FYY6WhPnt2ZuMedYiqIpZcM9ejAl6jCUuAlVbnjqOEmVosV5H" +
    "8rQX6RwtCfPbs9eMfdYiqIpZsM5e7nXQZCJD2c+B/n2Qv0dpjjVu6kaZpfBt" +
    "Ab+5t865PpTI9VSMBxlP45Y8axFUxaxYZy+7PVdPOhcuDqF/H6wF/vufMWWi" +
    "RPHLL345eTakmUulP1hpz8GKIU/RM+8F7uVZURWzYp29iILvc5qeeA5cHEL/" +
    "PojocaxyuRQlSt9i/ZBXPryYc30oketWDJ6xC6XPWgRVUQLZoBz80IXm4hD6" +
    "90EEj9ed9UJHiZJbrEcxBDlDYM71oUSuM4b1gVriaVwLVVEKTkDY/eSNDf2i" +
    "BqctHvljN45T2H4TUyhKFF3kcojvNhLkP3+Ya4rmXjCQL0NaSB1QMTsQsbut" +
    "8WHa963+uaiKUsinPychbxRfNnER7nOwHmvc3I2SU3gTV7jz03WOmRiCMqa4" +
    "WH9yJlcZ3LulUBUl4Q0uQc4Ulk1cRNHvuLce6+b/4sYZTBSjyBmLJSxyZrD7" +
    "KTrHTAxBGUtc5B86OFaBe7YkqqIk1rWobOK9XjBdQGMRFsVjjD+Bqol7MFGa" +
    "RfLauhQS5ME05lYSQ1DGEhf+D1Gd19yzJVEVpbFu7t7vkKra89TJGUOLF2j2" +
    "BGwjcZqwPf27uP8heqw1Mo/4mnq9S+pspeau+3XnnsrVAnj7Q8Zh/ep5rJu4" +
    "TVTFGHBigpwpWAtBvMVTB4wx2EcH8kvuLoER5FJJvnaUpzHjt0irXeSSWB6t" +
    "kE9460OyiQiL5E9X7qlcLYC3P2RMt91Dj5d7dAxUxRhYN3c3VZ6L1TwwU7zF" +
    "UweMMdhHBrseu3H59lQ95hQiOK3fUAVbHh7jFLJx5TELlXdG7qlcLYC3P6wP" +
    "y75/KD8UVTEW1s1dmXhrMXhwsHDW4qkDxhjwz0UUn39WHwRN5APyiSdOc4Z5" +
    "Z+SeytUCdO0P658TS/9+qAtVMSacqPDIoyfPvwhyBkDkznuLqe8OYFftc2CM" +
    "BiKK1mllsL5IPsjXuswbFyfvPHszL2voUyOvFLHyduybuE1UxZhYj0jLAoj6" +
    "y2JSGJZBXIQnnlRVD9sQmfseXFV32c8+aMFqc5d9J8f/wYdtbNzjdc5k4eSd" +
    "Z2dedokL/5JVkP3APTkmqmJsZIKctBw4WUwKw7KIi7KfPHlPh5zVyAN4Mn6X" +
    "/WaE8SzYxoPth9A3Zl9/q40H2+eAGJtCcnhV7frc6XF3ciYLL4ZjZ15auSnI" +
    "2LnH5nk5VKMq5oH1jIAsCIVhmcWlCxU/ow9CfxXPgm2A6oPth8B+aAeDxsA+" +
    "PNg+B8Ygff0tvBiOnWtn5YmcYXNvCWM94t+FqpgH1kt1hEccXemNygX0DgDb" +
    "58AYQNnRB1HxM/og9FfxLNgGqD7Yfgjsh3YwaAzsw4Ptc2AM0tffwovh2Ll2" +
    "zJNluM/SRFXMC+thJFkYudx4wvManAiaNou+/jltPHsOXgzPXoDHA9qz4DgJ" +
    "/YeAmGrc7HMAKqYH2wPaLXr32ZM7PU3vKfmw496bF6pinlhfT++0LxaNB8lY" +
    "1Jn8c9p49hy8GJ69AEWSm+Mk9B8CYqpxs88BqJgebA9ot+jdZw+sxyYWcZ+l" +
    "iaqYN1wQQRZqx8LxIBkL26Kvf04bz56DF8OzF6BIcnOchP5DQEw1bvY5ABXT" +
    "g+0B7Ra9+8zEetG2sIj7LE1UxbxJ3X/Z5Yjp4vEgGYvboq9/ThvPnoMXw7MX" +
    "oEhyc5yE/kNATDVu9jkAFdOD7QHtFr37zECeJl+m+yxNVMUisO6//MYeE4F5" +
    "zHFl2c2APqSvv/xuSkEfD6f9bsdr6KNwYhLGz+qDMQDtQxgj5jzguAn9PURY" +
    "5BWy3DuLvM/SRFUsCuv+iwiMLCAXdRZ4QHMOal9/tYkHbEqvPTd91sZ3YhLG" +
    "z+qDMQDtQxgj5jzguAn9u0gJy6LvszRRFYvEev5FFrCkwPCA5hzUvv5qEw/Y" +
    "lF57bvqsje/EJIyf1QdjANqHMEbMecBxE/p3Ib9r4l4RFn2fpYmqWCTWPweU" +
    "Fhge0JyD2tdfbeIBm9Jrz02ftfGdmITxs/pgDED7EMaIOQ84bkL/FNbb+wXZ" +
    "P9xTi0RVLJqUwMgj2vKKTJejAe0GjwS0e6j2HIMxDrYh9B+DdenTxDk+S8nR" +
    "9hvlBPndHvfSolEVy0DqGyRZWLXgZEDSzJrwqj3HYIyDbQj9x2Bd+jRxjs8y" +
    "cp9n6T2xrMIiqIplwfoFdZbADEiaWRNetecYjHGwDaH/GKxLnybO8Vk2rH+o" +
    "EOb14qchqIplIiUwstBc/B0MSJpZE1615xiMcbANof8YrEufJs7xWSbuv03v" +
    "AWFZvnJOoSqWjdQrB+950OQXoLsc2Q9pQ+gjz9e0mNVu+Xh47Wm3fICaN2Eb" +
    "2tG+yNrl4MRQYyJsb8U4shvVnrDPVL8dqHls1D3w0Kr6jafo/F92YRFUxTIi" +
    "C8nFrQWGB8iDB7DIBvHslo+H1552yweoeRO2oR3ti6xdDk4MNSbC9laMI7tR" +
    "7Qn7TPXbAeeREpZlepalC1WxrKQE5l7P1AepCx7AIhvEs1s+Hl572i0foOZN" +
    "2IZ2tC+ydjk4MdSYCNtbMY7sRrUn7DPVbwfNOcgH51YWFkFVLDPWQ3aCPFDE" +
    "A5WCiVhkg3h2y8fDa0+75QPUvAnb0I72RdYuByeGGhNheyvGkd2o9oR9pvrt" +
    "oB6/CAtzfKsJi6Aqlp2UwOz09Mn7TRWHA9otnDY7H97G889qA1x/ow/lQ+hP" +
    "6J8DYwA1D8NHwT4I/UmOP31IX3+DnQ9ro2IapB6Q22rCIqiKrUDqEkleSiz/" +
    "IdOZFE1bCqeN2jCE8XLaANff6EP5EPoT+ufAGEDNw/BRsA9Cf5LjTx/S19+g" +
    "r7jIByRzeqsKi6AqtgopgbnDXhAYHvS6vgunjdowhPFy2gDX3+hD+RD6E/rn" +
    "wBhAzcPwUbAPQn+S408f0tffoI+4pIRlHn+7OhaqYiuR+pq6JTA86FLn4bRR" +
    "G4YwXk4b4PobfSgfQn9C/xwYA6h5GD4K9kHoT3L86UP6+hvkiIvkqfXrZmEr" +
    "fN3charYaqQetPu3T5m80e4B2wrwbODY5aEnotrMCsdkjYvQ3xk37SZeH7QD" +
    "9llkrXqOwcSL4dm3+fOSfxy9/V46d1dBWARVsRXpEhi5886D2hsvkWBnUlmJ" +
    "NTMckzUuQn9n3LSbeH3QDthnkbXqOQYTL4Zn39Y9L/ngSwnLsv5WqC+qYquS" +
    "+rGjIL+o5oHvhZdIsDOpmFhF4JiscRH6O+Om3cTrg3bAPousVc8xmHgxPPu2" +
    "9LzkBq188DFPV0lYBFWxlUm9rkG441OrzdNQJkAWXiLBzqQqsmEIx2SNi9Df" +
    "GTftJl4ftAP2WWSteo7BxIvh2bfpeUn+3XkfnZs1y/De25Koiq2OCEzqWZjB" +
    "l0leIsGukor+JeCYrHER+jvjpt3E64N2wD6LrFXPMZh4MTz7tvac5Eny1GWQ" +
    "sGwveiqBqlgVrHfy1tz56ZNfVqe4N5D3aHTCGLQPYRExPbuF0+begPZ14K77" +
    "pS+D5INwmV5NWRJVsUpY/ypQc4enTpOdm+PgEJek3cJps87iIjdtrX9BrFmF" +
    "b4S6UBWrRteNXvk0uccBldogIS4Ju4XTZl3F5XcOrKrb7alzrmbV7q9YqIpV" +
    "pc9lUohLwm7htFlHcVnXyyCiKlaZrsskudkmr9CUT5y14QAH+lttaF9XNtbi" +
    "HvtPng5nbtWs+mUQURWrjlwmpb5NEuQa+bfXZdNQKAj9rTa0ryl32nvjbGV3" +
    "nU8163AZRFTFupD64aMg//QoD94xgVYOCgWhv9WG9jVDLoFu23FvZav+orkE" +
    "qmKdSP1soEYuleT9GkyolYFCQehvtaF9TZCz2zsmfnBYIz+sZc6tE6piHem6" +
    "2StIEt11/8k9mcHsB2gvAfvwYPslRda+yaLnIb9i7roEkrOVVXwori+qYl2R" +
    "a2ImSRN5n6m8jIqJls08NgT78GD7JWVZxGWnjUvl2+6hc6PJKv02aFZUxbqT" +
    "ekdMjVwq3WVIQs9jQ7APD7ZfUhYtLtKndwm0bt8E5aAqguo28hyCd6kkT/j2" +
    "Epl5bAj24cH2S8qixEWOrxxn7xLosqtDWCxURXAr3qWSIE9h/ubTJg/i7WCf" +
    "AjTjWTFpz6FvDPrnMEYMQn8PtneQy9+up2tr4hKoG1URaLxLJUGuxXeIDJN7" +
    "CEx6z55D3xj0z2GMGIT+HmyfIFdUtvJ7beeJqghs5O6/d6m0Q2T2NhK8L0x+" +
    "z55D3xj0z2GMGIT+HmwP5EMhR1TkEmgdH4YbiqoIuukjMvKCKpXouXATePYc" +
    "+sagfw5jxCD092D7KSIq3rc/ISrDURVBHrkiIzcD5VPxDntPvnEYirRvIsLl" +
    "YsTphO2H0Dcm/a02tHuwPZDjYf1VKpHjG8+rDEdVBP2Qb5Zy7skI8rOC2+1l" +
    "bIYMQlx6wPYb3H7PvLMUIUSlDKoiGE6uyPyb3SeJfvseGyfEpQfTdvILZVln" +
    "WW8eA4sQlbKoimB2ckVGkMsm+eGbd9kU4pKHrI1c9qTep2Ihx2td3rEyT1RF" +
    "UA55DqLr9Q5EPmHlXoB82orgtJC6JrRbPrPC+BZeG9oJ/XPakD0nl5x9BEWI" +
    "51TGRVUE5ZFPxa4XVVmI0MhmkU1jbjhuSMtnVhjfwmtDO6F/Tps9JiIs65N7" +
    "yVMjZylx6TMfVEUwLvKoeNe7ZFLsEJvUmU3mpuwF41t4bWgn9E+0GSomgtxL" +
    "iUf054+qCOaHPDuR83W2hTqzSWzKmeCmt/Da0E7oP21TX+YMERNBLkfjsmex" +
    "qIpgMfS9P2MhN4dlQ7bOcGaBm97Ca0M7qEWkZqiY1MjlZ9ycXQ5URbB45BS+" +
    "zzdO64ysUzw9u5yoimD5kM0TYjNB7lfJesTZyfKjKoLlRzbXkJvCW5EQk62L" +
    "qgi2HnIZVZ/dDL1BvGjkflN9iROXOauBqghWB/m0l40qN4uX5bJKxiE3XeNs" +
    "ZPVRFcH6UIsPEQFowkswOTuiD2OEeASqIgiCoASqIgiCoASqIgiCoASqIgiC" +
    "oAT/H4eNiRkiCdUdAAAAAElFTkSuQmCC")

SAVE_DISABLED = ("data:image/png;base64," +
    "iVBORw0KGgoAAAANSUhEUgAAARcAAAEXCAYAAACH0wDUAAAzn0lEQVR4Xu2d" +
    "aZsURdaG3///D2Zkh262ZkdW2WRXQUBBBFERFxR1VHRGxpmpt05WV3fG/URm" +
    "RFZl1nriuu4PHcuJE5HnPJ2ZVZn1fx/0ev/nOI7TNlLhOI7TBlLhOI7TBlLh" +
    "OI7TBlLhLB/vvvtu7+233w7Yu3dv729/+1uSHTt2yNjz58/3OIezfEiFs1hY" +
    "olvCUxSmyeHDh12AlgCpcOaTJmcbs8rwLIhrc+YTqXBmH/uvb4nI5FxUXHDm" +
    "E6lwZo8uxeTQoUO9kydPBty6fbvg9q1bG3z94kXBiz63+n8T2jA4VxvYPvgl" +
    "1XwgFc70sRusbV3iDMXDBODDDz8sxOFf//pX77///a/yv/8F/K9fR2QMgY3/" +
    "/s/q/tt78fWL3sNHD/uidasQh0OHD4mvo+BiM7tIhTMd7CYnEycXSzATkCtX" +
    "rhQi8tVXX/W+//773n/+85/2+Svkr/+EsH+q/ed//KP3vO/vzb7fhq1jnLM0" +
    "E2XurTMdpMKZHPYfl8mRgyXfuXPnenfv3u39o5+cTNhOaVlc2D7sY+t6+PBh" +
    "IZijnsX5vZrpIhVOt9glT9P/zGUx+f77l/3k+0uSdGJMSFxIWWya7p9h+85j" +
    "4XSLVDjd0PS/r10ehGJCNAEnwpTEhWNe9i/7bH9MdJuIjV82TQ6pcNqjyZfX" +
    "LEEuX77Se/Lkae/f//6rz7/r+Uv566+/ahEb4C9A+8Uc7CPYPCVs3hIcTx9z" +
    "/KRN47uXL3s3b95sJDR2n4vHzGkPqXDGp8lZiv3n/fjjj3u///4HEjOSVEGC" +
    "KUxSIjYAE5/2Z1lcyjx58qQv1Jdlr6swQeIxdMZHKpzRyRUV+3j4zp07vZ9/" +
    "/rk6KZlQJJb4kURtkrRMfNqfF3EZ9vv9998L4T55Iu87Ny4y7SIVTnNyTsX3" +
    "rq4Wp+0vv/suLymlnQmmMEmJ2ABMfNqfN3HZXNdfhZDb/u9dTf8DcJFpB6lw" +
    "8skRFTs9t9N0JhUTQJJS2plgCpOUiA0gPsbmYB8B60Diczx9zPGTNgX0N3Ep" +
    "8/K7l9mXTf4p0+hIhZMmT1Qu9X766cfemzd/FvwpvAkY9qvuH/KmGBMiff4E" +
    "mEPG/xnyJgbn5RyJ/vSRcw6w+k1SfrOdeytzFvP+2fvxxx97N27cyLoJ7CLT" +
    "HKlwqmHAxbh8KRSVarEIEyDdP0QTTJNIEh9zyHgkuQhFRCxkjkR/+sg5Jyku" +
    "Q3777TcXmQ6QCkdJ3ai1oLTg/Kn/nzCexJHgRgKk+4dogmkSSeJjDhmPJBeh" +
    "iIiFzJHoTx855zTEpaDf77fXr7NExu/J5CEVziap76kMReV1/z9ffRJHghsJ" +
    "kO4fogmmSSSJjzlkPJJchCIiFjJHoj995JzTFJchJjIffHCnt7q6Kse8jH9P" +
    "ph6pcAYwkCgq169f7/3666/FE8bOIvAnGNQ/ePAgKTKMHWeAVCw7qUsgF5VF" +
    "JS4uQz744IPayyW/VFKkYllJPaF84sSJ3qtXryTonEWhXlwM+6dy6dIliY0y" +
    "/iT2JlKxjKT+Iz1+/FgCzVk00uIy5PPPP/dLpQykYplIvaDp2vVrvX/88o/e" +
    "P//5T/BHwB/9uiR/hNDGP/8g/wz4o5hnExlv9ZgjjY0pg3auoVgHx5DEHFhH" +
    "DNnvP7AXtMk5aQ/jB4T7LetM2LB5r127VnuptOxPYEvFslAXFMePHy9ey1gZ" +
    "7EVdKaklMCMgAWiDwS7BzGCPwDnSlBM0Mp5rKNbBMSQxB9YRQ/b7D03s2jlp" +
    "D+MHhPst60zYGM5tb/w7c+aMxFAZxt6yIBXLAA/+EBOc+/fva2Ax2Iu6UlJL" +
    "YEZAAtAGg12CWXxSOEeaQYJUJ2kEGUMSc2AdMWS//4gnduWctIfxA8L9lnUm" +
    "bNCHZ8/qL5WW8T2/UrHI1F0G2Smuve0slgAS7EVdKaklMCMgAWiDwS7BLD4p" +
    "nCNNmCDSzjUU6+AYkpgD64gh+/1HfWLLnLSH8QPC/ZZ1JmxU+XDt2nWJrSHL" +
    "dpkkFYtK1WWQ1T969Kh4PL9LXv/+OuD31+T3EOsToDZbR3wYH677dVGX4HXI" +
    "VPYCcB1sLx/Lr54/762urEisDWFsLipSsYjw4A5ZW1vrvXz5UgOlAyQ4XVyq" +
    "mXNxMX7+6afaezHLcJkkFYtE6jJIAqRDJDhdXKpZAHEp6Ne/9957EntDFv0y" +
    "SSoWhWlfBhEJTgaiJPYUEkp8GB+uW4QkxgKJi2G/I1V3s5exuyhIxSLAgzfk" +
    "4MGDve+++654xD7kdchrwHZgDy6W+e218rroV434xPF9P0KsjoR9aDM5J/vL" +
    "nLYf8I3jxm2P9QFcd9PjNYDzop1zlvYtunf0wfar1P+n/mXS6dOnJSaHLOKr" +
    "HKRinrEDxIM25OrVqxoQlYEF2A5cXEqM2x7rA7jupsdrAOdFO+cs7Vt07+iD" +
    "7RfH9O3cvn1bYnNRBUYq5pUqYdm+fXvxY1oSDLWBBdgOXFxKjNse6wO47qbH" +
    "awDnRTvnLO1bdO/og+0Xx6zbev78eW+l4tOkRXqNg1TMI1UPHVZfBhEGFmA7" +
    "cHEpMW57rA/gupserwGcF+2cs7Rv0b2jD7ZfHFOyZ5dJFp+M2UUSGKmYN6o+" +
    "EbID9+OrV8WTrAG/RGCfX38BYfsvvwCrK/HrL78oiTl+AWxP20sjfiZRP2gj" +
    "6TdtjrKOpmMy+us6eAwTRGwq3Avya+/ChQsSu8YifJIkFfNElbCcPnVqICyx" +
    "wGKQRANFg6CMi0uZhN+0Oco6mo7J6K/r4DFMELGpcC/IoF+VwMz7O2KkYl6o" +
    "+qj5wjvv1AcWgyQaKPEgGOLiUibhN22Oso6mYzL66zp4DBNEbCrcC7LZ1z5w" +
    "YCzPu8BIxTxQKSz9/wDJwGKQRAOlOggMF5cyCb9pc5R1NB2T0V/XwWOYIGJT" +
    "4V6QsP/du3clpocwB+YBqZh1qoTFDkxxkFKBxSCJBkp9ELi4lEn4TZujrKPp" +
    "mIz+ug4ewwQRmwr3grD/YgmMVMwyVcJiv7tsTzRn8UsE9lkafgFs755f+vMS" +
    "9kmyYMfT3nRnX6FgnM+bwEjFrBITFjsAH330kRycWhiICxCMo+PiMqssgsBI" +
    "xSwSeyO/bbwdAB6UJAzEBQnG0XBxmWUsvmPfhZmXm7xSMWvEPm4eWVgMBuIC" +
    "BWNzXFxmnaozmHkQGKmYJWLCYthvyPz0888F9t6MWqxPiZ9+/kn56eeAn3+2" +
    "cZuwXYA9ji+gX4KtpYSMR7uMt7kHe7IJ/cJe2JgaaH8wB+A4thPsHe1nUayl" +
    "mtQ+GKm9kDkB10H7MWiDPvAYD/1/9uxZVGBm/Yt2UjErVD0rVBYWF5eQVFLJ" +
    "XtiYGmh/MAfgOLYT7B3tZ1GspZrUPhipvZA5AddB+zFogz7wGJfXYALDXDBm" +
    "+VEBqZgFqoTl5o2bwYa7uIRwb9Qv7IWNqYH2B3MAjmM7wd7RfhbFWqpJ7YOR" +
    "2guZE3AdtB+DNugDjzHXYf9YmROzLDBSMQtw8wx7ODG24XLACIMoctAZKBKs" +
    "DCTCIIpBvwQEl4xn8HG8zc39oV/YCxtTA+0P5gAcx3aCvaP9LIq1VJPaByO1" +
    "FzIn4DpoPwZt0AceY67D1lYlMLP4ugapmDbctKGw/Pjjj+3wKgL7EPR/9WOI" +
    "9B+BLmw2ZRI+vLL9K8H2gqbHZxagzx36ffnyZcmRWRQYqZgm3Czj6NGjsrlj" +
    "wQDICQL07yIJu7DZlEn44OLSDlWvGWFOTROpmBaxL8kdOHCgeB8LN3YsGAA5" +
    "QYD+XSRhFzabMgkfXFzaY9YFRiqmQewj506ExWAA5AQB+neRhF3YbMokfHBx" +
    "aRfLE+bOrHxELRXTgJtjn+k/efKk98MPP0R4FfCqX1fmh1dAxiuvXr0KoU3M" +
    "KbwKeVX4FSJ+YQxRH0jaj9QYrpvtOl6hn4TrlvYo9POHAK6TNnPgHOpDCPeK" +
    "sH8czgkYIxnjv/n2296ePXtEYGbhd5GkYtJwUwz7rRfd2PgGS9AkD5DCQBGb" +
    "kYMaIMGuiF8YQ9QHkvYjNYbrZruOV+gn4bqlPQr9/CGA66TNHDiH+hDCvSLs" +
    "H4dzAsZIzvj+3E+ePpUcMphrk0YqJknsPsu5c+cim1q9wRI0yQOkMFDEJg8o" +
    "KQX6INgV8QtjiPpA0n6kxnDdbNfxCv0kXLe0R6GfPwRwnbSZA+dQH0K4V4T9" +
    "43BOwBjJGb++B9evx3+jmjk3SaRiUlTdZ/nmm28im1q9wRI0yQOkMFDEJg8o" +
    "WT/Am8GuiF8YQ9QHkvYjNYbrZruOV+gn4bqlPQr9/CGA66TNHDiH+hDCvSLs" +
    "H4dzAsZIzvjSPpx8+23JqWnef5GKScFNsPssn376ae/7778PeRnyErB/qj0K" +
    "5pD2BC8B2+N9XgL2fxnw/csQ2ovNSxvav94H2Zdib8Ix9lvbZVJ+puwNbH4f" +
    "HkMifmJesalj1C/aSPSXdu612iCyTvbBuukD/fj6669n6v6LVEwCLt64ffu2" +
    "bm5sgxMHJNUeBXNIe4K6A17dpz4BJFATSRublza0f70Psi/F3oRjXFyG7dxr" +
    "tUFkneyDddOHmB/2D5q5ZTAHJ4FUdE3sPsvZs2erDwY3OHFAUu1RMIe0A/sP" +
    "8eGHH/YuXbrUO3LkiLMgFGfOcy4uJvDXrl2THJuGwEhFl7wduSbcv39/78XX" +
    "L6oPBjc4cUBS7VEwB9u/+OKLQkhOnjwZPe10FoONS/M5FxfDYpXrm/T9F6no" +
    "Ei7WDubjTx/3vnv53YDv0rz87mUA29vm4sWLcpCcxaWIycePJQ4Ui70ybM+h" +
    "3sZLsJEnZWhzvf6rF19F/xEyJ7tEKroidjl06/at+o2KMClxsfdn2FkVfXYW" +
    "nzyBqReGPOptjCMuhv3j5toM5mZXSEUXxN7PcuLEifRGRZiEuNgPVMXe/BXD" +
    "PlK3yz1nfuExNdICUy8MedTbGFdcjNiZt62ZOdoFUtEFXJwdODsz4EbIRkXo" +
    "Uly++uqrQizo7xC7ZrWP9e7du1fc1PWyGOWTTz6RYz2M02qBqReGPOpttCEu" +
    "VjetyyOpaJtYspqaVm1Eii7FJebrEDv7evPmDePSy4KU5gJTLwx51NtoS1zs" +
    "53e4rkm84Fsq2oaLsvsY337zTcE334Z8++23SexBrRDYMbslhnNtzsnx3xb1" +
    "VyOXbsODYGdZXha/1AnMo0ePEFcWN5sw7mKxJ7FcjNvk2yIHaqC9iB9Vc9ht" +
    "CK6Ludo2UtEmsZu4D+7f39gYCgM3JgaFgTZSB1jHf9v77OnT6D0WuwTys5Xl" +
    "KrkCw6Rm3MViT2J5guLy9Oln0RhnzraJVLRF7CbumTNngo2hMHBjYlAYaCN1" +
    "gHX8t9HLIRMWL8tZcgSGSc24i8WexPIExcW4cOGCrKnLl3tLRVtwEXZgnn/5" +
    "ZbAxFAZuTAwKA22kDjDHv3v1qmy4nXFN64zFbhQ7o9HmMUsJDJOacReLPYnl" +
    "CYuLMcmbu1LRBrGfX71y5Uo/AF4ADRDyArD96xeA7TXYC6m2bdsmvk76Hstv" +
    "v/1W3DCOXUY6zbB9tP1so1QJjMXMw4cPey/68TaEsRUjGcspGOsZ83JO+6ST" +
    "6+nq5q5UtAGd37dv3/pGzJa43LhxQzZ60pdDJmQuKu1jwtBGyRUYxlaMZCyn" +
    "YKxnzBub8/Tp07KeLn45QCrGJZYodhBmUVzeeecd8bXNU+tUqfoVPacd7L90" +
    "GyVHYBhbMZKxnIKxnjFvbE57Vi52xs5cHhepGBc6bAm8uRGzJS6HDh0KfLVv" +
    "Lk6q2Kl7TIiddrHj3EZJCQxjK0YyllMw1jPivWpOu03BtbR99iIV48BksY3/" +
    "/PPPi2++Frx4EfIVWe9X5gXgGLZjjhd9G2XKtrm5t2/fZkx1VmKfpjnt0+Y/" +
    "jFqB+bh/BvOVxdsmjEXG9guLzxJsT8V21CZge5ndu3fLWpjT4yAV40BH7dou" +
    "3CxuDNENkA3mGLZjjqrN/vjjj2Vj27pOzykUYqc72rrBa6WJwDAWGdvTFpfY" +
    "e3fbPHuRilGJfUJk78YIN4sbQ3QDZIM5hu2Yo2qzYxtr70KdRLHTUs69qLRZ" +
    "aDuXtu69DEuuwDAWGdvTFhejy7MXqRgVOihnLYZsDNHFywZzDNsxR9Vmx27m" +
    "Tqq4uIxWaDuXLi53cwSGscjYngVxif3uNHN7VKRiFGJnLZ88ftx7/vx5PV+S" +
    "L5XkmJAvwfPnZqPMwM40b+a6uIxWaDuXLsTFSp3A2MOCEruE8SvtYS582a8j" +
    "OiYk1f/ZZ8/kk6O2vvciFaPAzT116lR0IQI3l8Li4jL3tFloO5euxMXKWALD" +
    "+JX27sXF+sR+c5o5PgpS0ZSqs5boQgg3l8Li4jL3tFloO5cuxcXKyALD+JX2" +
    "yYhLV2cvUtEUbujwrCW6EMLNpbC4uMw9bRbazqVrcbFSJTAWZxLDVbEs7ZMR" +
    "F6OLsxepaELsFYF3797pJ/UXBV988SWwuqbQRsiX/T5lZLz5UWZ93NraWuC3" +
    "i0s3tFloO5dJiIuVmMBYnElMdkgyHyp4+vRp62cvUtGE2EYOhcXFpbq4uIxW" +
    "aDuXSYmLFf7DnRdxMex32rl3zPkmSEUusW+Yls9aXFyqi4vLaIW2c3FxycNe" +
    "JcG9G+d9L1KRC53gWYuLS3VxcRmt0HYuLi750H+DuZ+LVORCB66+e7X37PPP" +
    "Az5/Vs+zz58F2HNI5Jn1KyNjmjKw6+IyGdostJ3LtMXFnn6PksoXxK6M78Mx" +
    "tMl80XwKuXdf3/fC3M9FKnLgBhpPPn0ijnLhhAunsLi4zD9tFtrOxcWlhOQT" +
    "eSaPBIz6M7BSkQMPnm1obGFcOOHCKSwuLvNPm4W2c3FxKSH5RJ71zp47K3tI" +
    "DchBKnLgxDdv3owujAsnXDiFxcVl/mmz0HYuLi4lJJ/Is97HD/WNAaM8LS0V" +
    "KfiN3OKdLRUL48IJF05hcXGZf9ostJ2Li0sJyScy6Mf8MKgFKaQiBSc8e/Zs" +
    "77PPPit4Cob1mzwFbJ8cBw8eDNbh4tINbRbazmWa4mJxNoy5dH7MDrGvmlAL" +
    "UkhFHbEJP/zwww2H0pvn4mLFxWW0Qtu5uLg0x37Clvtoa6Mm1CEVdfDtaXaJ" +
    "VHYovXkuLlZcXEYrtJ2Li8tonDx5UvaSmlCHVNTBiS5cuBA4k948FxcrLi6j" +
    "FdrOxcVlNGI/vUNNqEMqqog9Nfngo496T54+rcQehipjP0JWj/UBT5/Uw/6w" +
    "+RQM+7m4TIY2C23nMm1x2YhF5sSTEMY2Y/ep1QHmHG0IyBfxAfBhxibfeZGK" +
    "KnjAjhw5EllYCDeTia/o4mRzCPvDJg/QsJ+Ly2Ros9B2Li4uJZAv4gOw33fn" +
    "flIbqpCKKjjB5cuXIwsL4WYy8RVdnGwOYX/Y5AEa9nNxmQxtFtrOxcWlBPJF" +
    "fAB37tyV/aQ2VCEVVXCCBw8eRBYWws1k4iu6ONkcwv6wyQM07OfiMhnaLLSd" +
    "i4tLCeSL+BCBl0Z2i4T6EEMqYnDDdu3a1fv008fFT4eUedyvK/Pp408DHhd9" +
    "NmE77eWQnjPefvCAi8skaLPQdi7TFZcDvUGu9OPP4rFMRWxW5YuMt36SE4O5" +
    "NngM2D/V3sdugZTXlPsSKamIwYNlPxvi4jJ6cXEZrdB2Li4uNeKRau8T+xke" +
    "akQMqYhBw9euXV13PnSi6WaxnfZySM8Zb3dxmQxtFtrOxcWlRjxS7X3u3Lkj" +
    "e0qNiCEVMWj44cOP150PnWi6WWynvRzSc8bbXVwmQ5uFtnNxcakRj1T7OqPc" +
    "d5EKYq+5KxtdXV0tXkQ84HHA435dmc1+6zwGbG+DzDkOHDgQrMvFpRvaLLSd" +
    "yzTFxeKMsTckmS/IryiId7GZzIf6HB76dfz48WBdOfddpILwQNlPh+Q6JgtJ" +
    "LrQFMudwcZkMbRbazsXFpURiDo4f+nXp0iXZV2oFkQpCg1evXs12TBaSXGgL" +
    "ZM7h4jIZ2iy0nYuLS4nEHBw/9MseUOa+UiuIVBAatF+Qy3VMFpJcaAtkzuHi" +
    "MhnaLLSdi4tLicQcHF/2y76CUl6brZV6kS0uvN+ysrrae/jo0SYPHwKr2+SR" +
    "8DAgsNXn0aOHCsYQ8QE26dPDR9bnYW//gf2yUZMqLi6jFdrOZZrisn//AY3B" +
    "jfxIxDLHMLZjOUOb6/E+hO0yPorN80juuxjUjGxxoaG3T51C4tZvhotLvLi4" +
    "jFZoOxcXl03YLuOjDMTl4sWLsrfUjJHF5fqNG0jc+s1wcYmXN2/eyEFaVOxa" +
    "vS1oO5dXr17xEHRWLI7Kcy+SuNy92+w5I6moExcuLLUZLi7VJfYKC6d97CPT" +
    "SRaLo/L8iyQuBr/vQs0YSVy2bt3a+/jjjxvyEWD79Ni/f7riskyXRtPEbkRO" +
    "sqi47JfYm2dieUPdSIpLO5vk4lJXYu8kdtpjGse0nbyZXbi+ui/TScUQvi/X" +
    "jHKiNC4uqeIC0w12PO3e1qQLk2/RxcWgdiTFhQZcXLordurO34NyRsP+KU7y" +
    "0yEWJt+iicv169dlz6kdjcXFjHKiNC4uTYr9yJUlht3sNX+cfGzfTKSncbZS" +
    "LubLIotLkyekpaJKXG7evNV78OCjgI8ePAiwF3YHWF0J6c/2/pgUDz6yeTb5" +
    "qPBjE/pY5dMsiouX+S8xcamKd4lliXerK4FYH8Q77TL+dZ4A9FcfFGoDtaOx" +
    "uNCJwpH1TXNx8eJlUJZBXFZWVoI1Vr1+QSoMfgfDjNGJwpH1TXNx8eJlUJZB" +
    "XNbWDgVrtMeEqCGV4hLbIDpROLK+aS4uXrwMSix3quJdYlnifTbF5eTJvE+M" +
    "pMLgwJMnT/Tu37+v3AOpdoL+9+4pOuZegrRNY9++fS4uXlovFBeLs41YBKnY" +
    "nQ70STl//lx74mLG1In7kcRPtBP0pwC4uHiZt7IM4nL1qn43ixqSLS5mTJ24" +
    "H0n8RDtBfwqAi4uXeSvLIC4GNYIaki0ud+/eiThxP5L4iXaC/hQAFxcv81Zc" +
    "XBqKCx99r+Qe+PAeiIxJQZuE/YW4Dy4uXrooMXHZjNd7IRKr7XOvH/Nl2F6V" +
    "H6k+1AhqiIuLi4uXlsuyiAvzhxri4uLi4qXlsqziEvsinQiLi4sXL6OXZRUX" +
    "Wzd1RISF4rJnz57enbt3e3fv3FHuhthDTWXu3rFxm7Dd7DZGbBD2Dxn6um9f" +
    "+BSyi4uXNoqIy9691fkCmC/2WsmAoZ0SjG+xKXMyp9g/Mi+wfnsj+UMdEWGh" +
    "uOztK5Q5wUVFNwuJz81iuy40A7FB2D/ExcVLl8XFpUZcuDkuLl685Bfmz6KK" +
    "C39mxMXFxcVLx4X5syziEnvdZVpc+pvzwQcfLBx885uLi5c2yrLkz7Fjx4J1" +
    "GtSSpLiYERpeBFxcvHRRmD8uLiWYdC4uXrzkFxeXGnHhABcXL17yy7KIy6VL" +
    "l9oQl6O9999/r/dejPfI+yBsNztl3nv//RAZ/37vfRs3BvT5/f48houLly5K" +
    "TFyYB5X5wHbG8gj5wfjXnMO8bC8IbVj+5PxutIuLi4uXFouLS424HD582MXF" +
    "i5cRy7KIy0j3XLg5hw4dcnHx4iWzMH9cXGrExTbHxcWLl7wSyx/mQWU+sJ2x" +
    "PEJ+MP415zAv27sUl9XV1eLX7LK4FXLrdgj7p9oHNm+B+jmI2htg63Jx8dJ2" +
    "ieXPZizeCkjGahahTc0Pm2cT6S/20pivR44eFRGllri4uLh4abHE8mczFhdX" +
    "XGzd1BIRF4ObQ+OVyMLqNy/VPrDp4uJlfsqyiEssf6gjIiwUF3sgicYrkYXV" +
    "b16qfWDTxcXL/BQXlwbiYtiP0N+KcPPmzQTWpwzabwHpHxnTkFtgWB/bHC9e" +
    "xi0xcWFMZsP8iMExQphPzAei40tzleaM5Q91RITFxcWLl9HLsorLu+++6+Iy" +
    "rOfmuLh4aaMsi7js3r07WCc1xMXFxcVLy2VZxIUaQQ3JFpfLly/3rt+4Idwg" +
    "16+HsB1cv3EdROa4DsRGivgcKysrLi5eWi8UF4uzynjvx3MZiXWgsW3jzM4m" +
    "N26AhA3mLO1V2aRGUEOyxeXcuXPiVOEYgaPSDmSzYX+weCA2UsTncHHx0kVZ" +
    "BnG5evVqe+JiX/WlU4VjBI5KO5DNhv3B4oHYSBGfw8XFSxdlGcTFTjaoEdSQ" +
    "bHGxJ6XpVOEYgaPSDmSzYX+weCA2UsTncHHx0kVZBnHJea6oUlxiG3Tt2rUk" +
    "1wHbZwkXFy9dlFFzZ57ga1kaiYt9Zl0euH37dpkghouLl2UvyyAusdyhhlSK" +
    "i0Fl4gQxXFy8LHtZBnHZtWtXsMbYj9A3Epd33nlHJiEuLl6WvSyDuFAbqB2N" +
    "xcU27Wr/cqnMu+9eredqiH2EVcYuvwKuKlcBbSZtwKfh3C4uXrooKi57SvFb" +
    "H//J9gjMh6sW4yUkHxLQh4KSvfPnzrcvLva6S1kYxYRw4YCbx4UOFuvi4mV+" +
    "yqKLy5kzZ8YXF74G8sCBA7owignhwgE3jwsdLNbFxcv8lEUXFzvJGFtcZJP2" +
    "7NGFUUwIFw64eVzoYLEuLl7mp0jeLJi42ElGeX2x11smxcWgQl25cqWeyyGX" +
    "r4Ro/8sBl68oMoZgTgH9h77s6Yuli4uXtgvFxeKsMlZTscz2GBgzdv4UY0LK" +
    "ORzLG+rGSOJiP+EoztU46uLiZdnKoovLli1bgvVRM0YWl5MnT6pzNY66uHhZ" +
    "trLI4nL+nXeCtbUqLmtra+pcjaMuLl6WrSyyuBw+cqQ9ceEzBDt37lTnahx1" +
    "cfGybGWRxWUVnyDby/upGdniYlCpLly4UNx7iXH50mVgdZtc6gtIQMSGcBlc" +
    "snEl0M45ydCui4uXLkpMXC5bXBaxOx5DO2XYR0G+0CZge8F6bvF+S9XX/kcW" +
    "l6NHj+rkG466uHhZ7rKo4nLmbP6X50YWl/379+vkG466uHhZ7rKo4sJbJK2I" +
    "CzfLXr8gk2846uLiZbkL82VRxGV1NXyhfep+S5a4GFQse83dxYsXexcuhFhd" +
    "mQsJLl64EHDhYg6wkZiT7RfNzz78aQQXFy9tFIqLxdlmflwAjM+wPZVfUZBT" +
    "0p5A821go+n9FkMqYlBc7L5L4Uhi8Ux0wo3gouLARmJOtru4eOmyLKK4nD59" +
    "OliTQY2IIRUxaHjfvn0DRxKLZ6ITbgQXFQc2EnOy3cXFS5dlEcWlycOKZaQi" +
    "Bjds27ZtA0cSi2eiE24EFxUHNhJzst3FxUuXhbmyCOLCXKl7WLGMVFRB5bL3" +
    "Otjb6eq5ANhO2D9nzGhww1xcvLRRYuLC2BtyAbC9Ey4Atkdg7tsT2tSHGFJR" +
    "BSewRwHohNJUKNg/Z8xouLh46aIsmrjk/oxIDKmowj56Kk9gf9MRpalQsH/O" +
    "mNFwcfHSRVk0ceFL4zoRFzsV4iTpS6OmQsH+OWNGw8XFSxdlkcTFvnLCj6Dt" +
    "y3TUhiqkog6Ki31b9/z5cyXOB5wD5/vOBgRjz/X7KPZC4DK0ec7qynBO8Wlg" +
    "d9fu8OcRXFy8tFFUXHZtxve5ZkjsRvpI/JNEPjEny30PHR7tU6IhUlEHT5Hs" +
    "UyMXFy9eNssiicuelfBb7J2Ki8HJjh8/XhIIJjISHQtxcfGyaGVRxOXU6VMi" +
    "LOYD9aAOqUjBCe1sxsXFi5dBWRRxObh2UMSFWpBCKlLw6Ui74XP27NlMzgC2" +
    "j8JoNvmTlC4uXtooFBeLszP9eDNGjdVpEPt0mFqQQipyoKLZ14PpXJwuNnc0" +
    "my4uXrooiyAuJ06cCNZg5H5xroxU5MCJ7bFyOhini80dzaaLi5cuyiKIiz07" +
    "yBynBuQgFTnY9R8nt02lk0oXmzuaTRcXL12URRAX+xS4vIbcZ4mIVORCcTmw" +
    "f3/xpboyp8+cDjkdcgZI/z5nQNJGov3M6TMFu3a6uHhpv1Bcdvbj7HQ/3gYw" +
    "Pof1A4axOYT9NZYHORLkC9sTNtg+7ndbykhFLrzhs23rVhcXL0tf5l1cVlbD" +
    "nzmeirjEHgewT5JcXLwsc5lncYndyLX1MPdzkYom0JHi+tLFxcsSl3kWl5WV" +
    "9s5aDKloAjfSsFdgurh4WdbCnJgXcYmdtYx6I3eIVDSFDtmvMp7qb7Dx9qlT" +
    "AafIer8NTsWIjAtsALZXYH66uHhpu6i47NzMgbfBKcuRapgLMj5mQ9qB5WWZ" +
    "9fq2z1oMqWgKN9M4cviwi4uXpSzMh3kQl+MdnLUYUjEKdGx49sKFMcFdXLws" +
    "WplHceHbDgzm+ChIxShwQw07e+HCmOCzJC72SZcXL+MW5sKsi8vJPm+99Vbg" +
    "8yjPEcWQilGhuNgjASffPhlycgTWN2ADtjdl3c5qRK29eBm38MFeExeJwRZ5" +
    "G7D95EnLmTJh++re8JcUDeb2qEjFqMROrY4dPzaz4nJwbU38/frrrxkrXrw0" +
    "Kowp+xlUicEWGUdc7BOirs5aDKkYB26svclqVsXl2PHjEgj37t1jrHjxkl3s" +
    "nxNj6uDBgxqDLTKOuPD3nw3m9DhIxTgkz15k4Rl0JC4GVdu+dezFy6jF/jlJ" +
    "/B87pjHYIqOKS9dnLYZUjAs31761e6J/llDQX1AZe0VmmY1+JY4ft34lThyv" +
    "heNPWF0FfD7Kb+p6GafwbQFbt26tjXeJXeYH2xnbBScCOIZzDsetdvC9FiIV" +
    "4xI7ezl44MB6os+WuKxGHtL67bffGDNevCTLmzdv5CPd4h9rTbxL7DI/2M7Y" +
    "LmguLkePHJG4nwtxMei0Kfjx/umhbF5k4aRLcTl48IBssH/fxcsoJfYgr93T" +
    "qIt3iV3mB9sZ2wXNxYVn7F0IiyEVbcDP+ouN7p+GyeZFFk66FJfjx4/Jdadx" +
    "+/Ztxo4XL5Xl2bNnEkOGPWdXF+8Su8wPtjO2C5qJi11F0M82vo0bQyraggsw" +
    "Dh8+1Dt27GiJYxmU++eOycd+2I1+Gq9evWIMefEixS6HYmcC9qwOYy3J0ZCj" +
    "x4DVAbFRg4ld7J8pc7ctpKJNuAg7CM2FoltxMfjTrobf3PWSU3gT17DXRDLG" +
    "suhYXGIPJ9pVBvO2LaSiTXiDy7AzhWZC0b24mKLbfSH6agLjZzBeYsXOWGLC" +
    "YmcGFjeMsSw6FBf7hQ76ajBn20Qq2oaLsSQ+evRIL18ouhcXw77sRF+H+D0Y" +
    "L+Vi91hil0KG3cRlbGXTobjE/GWuto1UtE3s5q49d3TkyJFCZAKsDhw5cjSk" +
    "3y+g6FMG/dEuc5ZsmF/0dYitwz+mXu5SdbYyZPv27WG8SazWxzLjUuiPIWIz" +
    "QuwKoqubuGWkogu4MMPOFHTzFG4UDwjFQ/qjXeYs2bDT2TqBMayPfexo38b0" +
    "Z5EWu9gl8SeffFKcucb+SZYxYbHYmDVxOXz4yERv4paRiq7g4uxg6OYp3Cwe" +
    "EIqH9Ee7zBmxceDAgd7WLVvkgFRhQcVH2Z35hse4CktcuxRiDBVIrNbHMuNS" +
    "ONJcXGL/LO3si/nZBVLRFbFTM1v4LIpLMW9fMHbjh9Mcp4zdx7AbpfaBAGOo" +
    "QGK1PpYZl8KRZuKyb59+zaLt54fqkIou4UIN+/TI/vMbhw5FsPoShw+B9bEb" +
    "NlL9Y9TYMFGMnVY6y4vFg32sG8bNoQgaW/WE4xnLMThmaGttbS0at8zJLpGK" +
    "Lol9Rdo2wNTfNkSExeBmNhCGaP8YCRvmn4mMfR/GLudiB81ZbOy42/FfXVnt" +
    "rR1ck5jRJJ+uuPAnWQ2rZ052iVR0jS2Qix7eDBNhMbiZDYVB+sdI2WB7f8zB" +
    "foCVBcdZLAohWV0t7r8Vxz0RM5rk0xOX2JdCJ3k5NEQqJkHsM3fbEBEWg5uZ" +
    "OMjJ/jFSNthe9s9gfzsTI7SRIBY0AVxDZB3Efge4DNuz7Ekf+CntIeID+8ds" +
    "Cmq31sccaIMk+9PHDD+FcDxjIgbHxO5tGszBSSAVk4KLN+wGVDpxQXBwMvrH" +
    "SNlge9k/g/0pLC4uG4gP7B+zKajdWh9zoA2S7E8fM/wUwvGMiRjl/mtrB6OX" +
    "7My9SSEVkyL2ZSTbGPv+i92M2uAQKLfFaNq/zyGwtmYHqgRsav8WOGTzlGD7" +
    "rMC96PtaRvonwV4XsE8zxvfJoE8E/Rl3MTimBcpxWPUIC3NvUkjFJImdwtn1" +
    "brCBTQ9Q0/5rMbFAIMGm9m8BF5cS7NOM8X0y6BNBf8ZdDI5pgWEMxr42MY37" +
    "LGWkYtJwQwx7g9fGBjY9QE37r8XEAoEEm9q/BVxcSrBPM8b3yaBPBP0ZdzE4" +
    "pgUs/vZGXrRtMNcmjVRMA26KYWc1xQY2PUBN+6/FxAKBBJvavwVcXEqwTzPG" +
    "98mgTwT9GXcxOKYF7OVPs3SfpYxUTIOq+y/79u4rPgoMORhyMMQ2O8TqNmH/" +
    "AtoUQh9o016XWUbsR6ANaYdN7W/zhLAPkTmwV7LumN9AfADp8Uq6D9edWEcM" +
    "zlnapwL6kIgBsR+zIeAYyhwEc+4/MHP3WcpIxbSI3X8xgbFv8Lq46JwSmJE+" +
    "RObAXsm6Y34D8QGkxyvpPlx3Yh0xOGdpnwroQyIGxH7MhoBjKHOQ0nwVwjLt" +
    "+yxlpGKaxL7/YhsYCgwOogRJ9QGJJVgBbQo86KHNVELFoA1ph03tj8CM9CEy" +
    "B/ZK1h3zG4gPID1eSffhuhPriME5S/tUQB8SMSD2YzYEHEOZg2zOZx98MFcM" +
    "5tQ0kYppw81SgcFBlCCpPiCxBCugTYEHPbSZSqgYtCHtsKn9EZiRPkTmwF7J" +
    "umN+A/EBpMcr6T5cd2IdMThnaZ8K6EMiBsR+zIaAYyhzkMFcO3fslByZNWEx" +
    "pGIW4KYZptQmMF2wD7A9xbjj27LRlGWZM8o+wPZZpO/nju16dm/Yc3vMo2kj" +
    "FbMCN8+wyybZ8BYYN+DHHd+WjaYsy5xR5lBcdu/SZ4ZmVVgMqZgVYk9QdyUw" +
    "4wb8uOPbstGUZZkzypyJS+xhRGNSL34aBamYJaoExjaamz8O4wb8uOPbstGU" +
    "ZZkzyhyJS+xtcsasfORchVTMGlWvHLRv8e7du6+3b9/eAPtIu8w+wPZWsHnL" +
    "sH2vzb0vID1mX8i+ENob2CT1c+jeYE7xSUntfwquYYD61uQYij34WJC0yf3f" +
    "G0B7On4UdE57KdXf//53if9ZFxZDKmYR20hu7lBgUgc5HUQtgMCT9r02N4Ug" +
    "NYaBFkJ7A5ukfg7dG8wpPimp/U/BNQxQ35ocQ7EHHwuSNrn/ewNoT8ePQjhn" +
    "lbDM0ndZ6pCKWSVXYHjA0kHUAgg8ad9rc1MIUmMY3CG0N7BJ6ufQvcGc4pMy" +
    "bpJxDQPUtybHUOzBx3kQF4vreRYWQypmmdiX7Az7mLrqIKeDqAUQeNK+1+am" +
    "EKTGMLhDaG9gk9TPoXuDOcUnZdwk4xoGqG9NjqHYg4+zLi4mLIzxeRMWQypm" +
    "nUqB2ba9eL/pav9UsszK6mrAoA9YXamFNlaKuk3sdYgBtL8SG0NCG5wz1T8O" +
    "xwDslY7PIbS5Ymsts5qx/0TmIFwL25sjfrYA9yJnv6vie96ExZCKeaDqEmnb" +
    "1m1yACVoGMhFMDNYQ2hDhQJBQvsWXDKGhDY4Z6p/HI4BGcGeJrTJhJJ1RPZG" +
    "kDkI18L25oifLcC9SO131Vf651FYDKmYF6oEZsuWLcEBlKBhIBfBzGANoQ0V" +
    "CgQW7VtwyRgS2uCcqf5xOAYkgj2P0CYTStYR2RtB5iBcC9ubI362APeibr+r" +
    "hMUulxj784JUzBNVH1OXBUaChoFcBDODFQkDGyoUCCzat+CSMSS0wTlT/eNw" +
    "DKgJ9nxCm0woWUdkbwSZg3AtbG+O+NkC3Iuq/Y493WzMw8fNdUjFvFH1RTu7" +
    "025fl7YvIKVYAWzfs2cFoH0FsL0D6HPcb0A/CfvLuleSY1ZWQtjeDvSL7c0Z" +
    "ey/ZXlDvp81j/wgZu4sgLIZUzCN1AmN33nlQSTqw6oMkL9DahT7H/Qb0k7C/" +
    "rHslOcbFpUy1nxaXVcIyq88KNUUq5hkepCF2PasHfpN0YFUHSUFWoLULfY77" +
    "DegnYX9Z90pyjItLmbifdoM29h2WRRIWQyrmHR6sIfZfQg/+gHRgxYNkg6xA" +
    "axf6HPcb0E/C/rLuleQYF5cy6mfsZ1aHMJbnHalYBKq+K1B1mZQOLA2SgKxA" +
    "axf6HPcb0E/C/rLuleQYF5cymz7u2rW78jJoEYXFkIpFwT7C4wEcYv89du3e" +
    "tcFusGv3brDZN96fcPzu4ndlyliw1WFPfgdYXZmYH2LH6jZhf7WZmDMGxnBO" +
    "gXsV+DtcO33FPNhL7U8ifsIP2qTfqXVLe2kddlledRk0r99hyUEqFonYrwoM" +
    "sf8i1WJhwVcGgSj9CcdbsDF4NanCBEsEb8wPsYME4RixmZgzBsZwToF7Ffg7" +
    "XDt9xTzYS+1PIn7CD9qk36l1S/v6Oqo+ZjYW4ROhOqRiEeFBHWL/TXbs3CHB" +
    "SGGQQJT+hOMt2Bi8mlRhgiWCN+aH2EGCcIzYTMwZA2M4p8C9Cvwdrp2+Yh7s" +
    "pfYnET/hB23S79S62b5z587o7wkNYYwuIlKxqKQuk8rBSGGQQARs1/GaEEwo" +
    "kgpe+lD4IXaQIBwjNhNzxsAYzilwrwJ/h2unr5gHe6n9ScRP+EGb9Du17nLb" +
    "sl4GEalYZFKXSXbg7T/ObGK+lWG7M1V27Czip+6m7aJfBhGpWAaqPk0y7BpZ" +
    "AmcmcHGZZSxuqs5WDMbgMiAVy0LVg4+GXSvbqS0DaLq4uMwiFid191aW6TKI" +
    "SMUyUfXYwJDZulRycZk16j4JMuzBWsbcMiEVy0jdzd6hyNh/qCE7SF+Aymzf" +
    "sV0pjY+zA4TtMof01zGpdq6D7duLtYTs2GG+bCLrTPVP+FD4QZv0izYSc2yX" +
    "fTDfwjnEhqx9s2/qEmiZz1bKSMUywyApY8FkQVUEM1lPeBcXHSP9Ez7Msrhs" +
    "276t9hLIWKRng8ZFKpadqnfEDLHgYjJI4iNwcxJkI+irhIBzSH8dk2rnOtiu" +
    "CRYRCyHRP+HDrIrLlq3VnwIZy/ZJUA5S4QzIuVRycbE+JNE/4cOsiYsdZ78E" +
    "Gg2pcEIYTMTOZOxyyb6It4H9DbZu3RZg7/utY+u2ENoL5qvE+pVhe4KIX9In" +
    "ga47Zx1j+t0Cqcsfwy+B6pEKR0ldKonIMIFcXOZGXHJEZZ7faztJpMKpJnWp" +
    "tCEy/VNpJpEmWT0uLmP43RD7p5AjKn4J1AypcNKMIjKaZPW4uIzhdyYuKt0i" +
    "FU4+OSJjNwMHl0xbAuxGYYDVlWF7C2zdsjVgy1ZgdQFpGyagZdg/Bcdn2cBe" +
    "cW/VXriut96qv0k7xC9/xkMqnObk3JMx3nrr7/3gHghNKmGkvQUoDMskLiYo" +
    "OWcphotKO0iFMzq5IjM8m6lLGEmoFqAwLIO42D7nnKUYLirtIhXO+OSKjLEh" +
    "NC4u+TYS4rKlgaAYy/4MUFdIhdMe9j0IuxnIYK6iEJp1/m4JUubvISZIRPoA" +
    "aacN9qcPBebbJhxDm7amWmCvsElScwxpICiGf0+lW6TC6Ya6F1XF2Ey+YeIk" +
    "hCHWB0g7bbB/OXE3gBBwHvEpIigticvQBveuDj9LmRxS4XRP3btkqthMyAph" +
    "KJIN4gGknTbYvxATAiHgPOJTRFBGFJdRxMTweynTQSqcyZLzcXaMYaItsriM" +
    "KiaGXY76Zc90kQpnOjS9PxMjTNyIWAAKgfQXYelIXFDHdTXh/PnzLigzglQ4" +
    "s0GTT5yWGb+HMrtIhTObuNgM8PemzA9S4cwHo9wUnkdcTOYXqXDmFzu7GfUG" +
    "8bSx+01+ibNYSIWzeNjN4lm5rDI//KbrciAVjmMCUIaXYHZ2xD604ThS4TiO" +
    "0wZS4TiO0wZS4TiO0wZS4TiO0wb/D/py7p8YzCpJAAAAAElFTkSuQmCC")

# Original file: SpeedControl.py

class SpeedControl(PGLControl):

    def __init__(self):
        PGLControl.__init__(self)
        self.set_active_icon(SPEED_ACTIVE)
        self.set_disabled_icon(SPEED_DISABLED)
        self.set_rollover_icon(SPEED_ACTIVE)
        self.set_pressed_icon(SPEED_ACTIVE)
        needle = GPolygon()
        needle.add_vertex(0, SpeedControl.SHORT_DELTA)
        needle.add_vertex(SpeedControl.SHORT_DELTA, 0)
        needle.add_vertex(0, -SpeedControl.LONG_DELTA)
        needle.add_vertex(-SpeedControl.SHORT_DELTA, 0)
        needle.set_filled(True)
        needle.set_color(SpeedControl.NEEDLE_COLOR)
        self._listeners = [ ]
        self._rotation = 0
        size = PGLControl.CONTROL_SIZE
        self.add(needle, size / 2, size / 2)
        self._needle = needle
        self.set_speed(50)
        self.set_state(PGLControl.ACTIVE)

    def set_state(self, state):
        PGLControl.set_state(self, state)
        self._needle.send_to_front()

    def mousedown_action(self, e):
        if self._state in { PGLControl.ROLLOVER, PGLControl.ACTIVE }:
            self.set_speed_from_point(e.get_x(), e.get_y())

    def drag_action(self, e):
        if self._state in { PGLControl.ROLLOVER, PGLControl.ACTIVE }:
            self.set_speed_from_point(e.get_x(), e.get_y())
        
    def set_speed(self, speed):
        speed = max(0, min(100, int(speed)))
        range = SpeedControl.MAX_ANGLE - SpeedControl.MIN_ANGLE
        angle = SpeedControl.MAX_ANGLE - range * speed / 100
        self._needle.rotate(angle - self._rotation)
        self._rotation = angle
        self._speed = speed
        self.fire_speed_listeners()

    def set_speed_from_point(self, x, y):
        range = SpeedControl.MAX_ANGLE - SpeedControl.MIN_ANGLE
        x -= self.get_x() + self.get_width() / 2
        y -= self.get_y() + self.get_height() / 2
        y = -y
        if x != 0 or y != 0:
            angle = (math.degrees(math.atan2(y, x)) + 90) % 360 - 180
            angle = max(SpeedControl.MIN_ANGLE, angle)
            angle = min(SpeedControl.MAX_ANGLE, angle)
            speed = 100 - (angle - SpeedControl.MIN_ANGLE) / range * 100
            self.set_speed(speed)
        
    def get_speed(self):
        return self._speed

    def add_speed_listener(self, listener):
        self._listeners.append(listener)

    def remove_speed_listener(self, listener):
        self._listeners.remove(listener)

    def fire_speed_listeners(self):
        for listener in self._listeners:
            listener()

# Constants

    NEEDLE_COLOR = "White"
    LONG_DELTA = PGLControl.CONTROL_SIZE / 3
    SHORT_DELTA = PGLControl.CONTROL_SIZE / 14
    MIN_ANGLE = -120
    MAX_ANGLE = 120

# Images

SPEED_ACTIVE = ("data:image/png;base64," +
    "iVBORw0KGgoAAAANSUhEUgAAARcAAAEXCAYAAACH0wDUAAAlq0lEQVR42u2d" +
    "e5sVxbXGz3c6DoiKCnJRjIKIGiCGkQQ0JuBR0ChGROMliZqTaG4wAwPMBZgB" +
    "ZmCA4T4oIiNgUPBCAlGM5MQTcz5Dn71o9ri7urpXXfv6/vE+PMzurlq1qurX" +
    "Vaurq/7jTBD8BwRBkGvBCRAEAS4QBAEuEAQBLnBC3bR8JAjah77VvP4gmLop" +
    "qokdQfCfa3ldty5+76zeaPok+B1wgSqiX58MOzV1dOrwKqDISjdt+BZAz40C" +
    "PIALVOhRiM5oo6hqjoIw2gFcoJxgQk996ohlBomOmsBB/QMukEPRtKFuMOFG" +
    "N+QPgizaB+ACacKEAqyupjj3NNJa2HjqP3MsCF56Lwg2fxoEx/4ZBKf+3fjb" +
    "235B8NihRj7/F2rzZ0Hw60YBVzXyXLo3COb2AzaAC5TJVIeCnKYdbHJXAyCD" +
    "YWcmiGxsAKT/UhCc/EbQv6M6+j9BMLPHH1z2fBkEY99EJdpE15C9ZDeJQEjl" +
    "Mc2ToAzQAC61f5tDT1xTmCxpPP1fPBF2ziR4cHChv71+2g9YCBSUBweXmE10" +
    "T0N7G+V643QITFMAUqwGb6MAl9qIpjy68ZMmTH7egMnAxYROaggX0j39bsFC" +
    "9h79px1cIvqmBTYHzUY25HcCOtog4FIp0ZsO3RgKTXNoZNJ/MeyEbCe1gAtN" +
    "S3yMWlzCJZLGv8Np34vvhdDVgQ3VA948AS6lD8zqLF6jDrK88VT+/dkgOPGv" +
    "IHiX0QkDpaWxYNANWGgKc+Jf2WvrX4Pg6VE90FCcC/EZwKVUUNEZpfxwTxC8" +
    "dioIDv8jHQS+4UKd0wVcqCx5wKVVBGgCtc4bJ4xmAJdCv/FRhcqcxvz/hcaU" +
    "Z/dldRD4hgtJp0PKRKOfvMHSKgI2wU51VAbIAC6Fi6eoBmgpPrDlr2pwyAMu" +
    "BDub18BdnxQLLuP6plG2L4Ng6T5ABnCpGFSa2vCJOhzygAuJ4hZVGLWIcCFt" +
    "vWj2lgntHXApLFSaWn8+CI5/Ldc7ov43Kvb6r5PTHr9HSDN2f+NvB6+YjV4G" +
    "v5CkL9FxUTJbhWtkdmr93iLTURkgA7h4hYptsLMMcCGteVevXMsOqIGlzHAB" +
    "ZAAXLytpXX3nUxa4kFRXxdIo58CV+sClGZPBK2zAxUquN1kqE1zeOqtWpqdG" +
    "1cFSFbi0rpNBPwFcMp8CydRxPvwi+aq+FvTP4mn+ID9qGfnKshxfe1BKfj7q" +
    "FW+WABcl+dzNLbVTFRAuBMO08vxizEE5KgCX5lQJH0kCLlKZfqFcZbiQXYv3" +
    "yMsyo8dROSoCl9YvsdGfABfrV8t1gMvOz5kpXsngYrNIEFMlwEVZNhs0mYg2" +
    "Z2rqiKCjDnSEkWl6K49EyzF/p3k5TGzi7tEpN9meVX3TFBtwqeHr5bTRyqTO" +
    "asPliKZoQ6rWJ/7ac+YAqyJcuDhdXV9b402Q8Pbj1bFwYyLxaV0FuNio6Y8f" +
    "77cbHVUNLg8Nh/Al4M5IWRtEMT3ApabTIOo8BJXWhsg1mDrBhToQ+WLgEuDS" +
    "fBC9MpYMYUyTagKXtGkQNRLalf7QP+SiL4VXOBrF0BYASTqUh64wkviCS5Mt" +
    "F5OHiV2Hr0SVZtN3HcCF0th2MTmPTZ+mP5TqMk2q9TRo9rZ4I0kSAcjmTQM1" +
    "yLLDRUU+4MKlmRVcqP5/9o5auYcvh1OmOk+TajsNotGIbsfZzTQYwKW6cJGN" +
    "VtLK3bSTYFTXaRKmQQYyGcVoweUK4KIDFxEwaTY9ul8fLEmjFRW4kDbWdJpU" +
    "yT1skyrx7q3hXrEHvopqvyD6yjeir+La9UUQtO9Wb6AP7IimyebpQl+la/+V" +
    "qGLXmOSh+7sDseVo0ROH1euM2gvtrsf5UUVce6niVg6VOxMoqfKoUSV1OBO4" +
    "NEVHpKosxkuCi89OB7iYw+Vqe/nKvZ59uz6AqTxYqOPTYVppHc4GLiTaF5fg" +
    "oQOXLDod4KIPF5ejlSRR+tO7q7+NQ6U/OhyfBl3xC5dmo6ZD1pNGMeNwSUoH" +
    "cMkdLuOj2yt+4dKcJlH7rDJgKvtGiCqOProb+TuvfYJGNNV6b+9fguB+ySiG" +
    "/paWB2fDPgXZllMlvX1fCbK0acTS3yp5ttr7uAQuNIro/NjOlyaidB4Zqe6b" +
    "pEqCZdHuECz7/p49XJqiI01b7aNGDbgUDy70/8HP7X1pCpc0wNAbT8AlByW9" +
    "aqaK0m3cPuBCoqdhc+gLuBQLLjRa+d1Zd760gQvp8cPVA0ylwZI3XJqihgO4" +
    "FAMudHg91cXOz9360hYupJ+fSI4HlXGXu8qAhSrGFBS+4bLPQccGXNzAxZXd" +
    "PuBSNcBUAix07jJ9tXtVlwV9mYFU8tS1y6Qclxnp5mGQBn1Z3irO5r1f6t9j" +
    "7cvL+nY5qR9F0S5/SfHEMgGm1GChCvjl+9lVOuBSH7iI9mUJFw4wgIvnHfnJ" +
    "8R3nsq90wKVecHFaPwaAuWtreYO8pXzdPA6Wy4AL4FJduKSNYMoAmFKuY1lz" +
    "PAh2f3FNlxl9oSDmnl2C2PtN7dCwSaZdl6PibGLLpZIHY7d4vUmeuv6O5eHD" +
    "F5cNxLWrhOvXfiQHTNEX2pXuW6EIWAAXwKUGcGkCpmyfCpQKLD8dNahk2458" +
    "GXABXBwBxgIuJHqwlgkwpdmWculewwq26ciXARfAxSFgLOGSBpgibtdQio2e" +
    "Fg6F33+oaEgQ9/vQ5+pp2yiLPIcYufCVrbyU84uoilJ/sXu+EGSYZ9JuekUD" +
    "TKG2pkxambhkL+ACuBQbLkMZwmXZwXJsmVn41bdN0QY7gAvgUmS4DGUAF9qY" +
    "jNv5EHDRPLNZdfQCuAAuecJlyDNcnjpanjOqC32ukCjawmDH39K1XdAOE11i" +
    "9LccpGBDrOy2dquUvQi+MbHJs93bDe/h2u60brW+UoRzkQobZ5HpJwcAF8Cl" +
    "HHDZ4QEuz72j11/yjr8UOs4ie59P20gCLoBLHeGiOmopSvyl0HEWk9EL4AK4" +
    "VBEuuqOWIsRfCh9nEXVjA0rdF4Kg/1KogYuauhRX/8WouHv6GSnlwaXJ2NSv" +
    "YIeYBltOMQ+Fe3Tt9FEfrE2XeH+zdW5QH9ptMaUc9w6Y95m84i+5wMXUSU09" +
    "+w7gArjUBy6vnbLrL3nFXwofZ5Hpts2GcLkEuAAu5YOLzaglz/hLpplN3eTG" +
    "Sa2jF1uwAC6AS5Hh4mLUklf8pRAHxJuOXrZeDE9UzFvbLgr6a1zaaVreD5VQ" +
    "FwU1/rZ42G2/oXhn5eDiYjok25gbcIGqCpe159z3mSynR7nuz2IrmosCLlBV" +
    "4eJ61NIUhScqAxcfDmqKdv8HXKCqwWXteX99JqsjSgq7WK5MoxfABXINl6Q9" +
    "W1wpiw2+vSa+fMSvg5r67w/CzwJk6rsQldI1gvr+Ikj3eolM7Ey7vu+Cfh7s" +
    "9SZi8mB/d2WHrZ2a1/ca2J1Utxs+CReL+u43voO7pQviyvTQMOACuFQHLj/K" +
    "6KHsO7hbuiBukv7wEeACuJQbLn0Zjlqy2Nw7syDuhI4gmLMt+9EL4AK4lAku" +
    "Tx/z10fmDgTB9Z3ZfRqQ2fGrjx0Kgp4L3+qVsYZOBsEj+0Ld0xjpzLUc7fz+" +
    "bPhRY0Sf8eoRFEtDN80L+mnEbDDJgyvnBUGfpUspDUHWNl3Qrx/t+lMpu4M6" +
    "106z8bepm83bP/UhUrNPUf8itdrwysnsgruZfPE8q++aszUaUdMxTUfNVYAP" +
    "XQe4AC5lhctPmVXs1I9a4bH6ePiQph0addpV++5sTg7IJIj7xhl9uHANXoQP" +
    "OX3+TsAFcCkvXNqHr8FjJNRVeDTaeOd5jXwV2hWlJ4vrFBouslELOWnc2Q7h" +
    "0p3UAQAXwKXE0yLdtmvarihM4Xv04nXUQnRcdy4INn2aoM8EfVpQ+bAzj7I7" +
    "yHOjoNL4u4jtJudyyuI7hYSL7KvnRbsr0ogAF8ClgnB58qjf0YvXN0Rv/Rlw" +
    "AVwAl6LCxffoJb9RC+ACuAAuuZdz+UF/nwV4G7X89oNwtWGruj6OaoMgOrJV" +
    "FJeGSZqcxDQ2fJIukzS1bVLIk7VbtEH0HXP9BgX/cjawecrKJtrK+UshDxd1" +
    "ai2uXLrlNtCfPgqCG9f7WffiZ9SySw0MunDpAlwAlxrDZYMnG5bu9TN68TZq" +
    "AVwAF8ClHHDxNXpxfhxrc9TiGi5dgAvgAri4t+1jf6MX57v5rzkRLke+qvN6" +
    "Wi/R+O8Jaa7/OCrd3yNpK9qdaGNSeh/r58Hdv97EDttyuchDpT5cS8H/bDvK" +
    "wDe2fWX9efNy/v7DILjB8ejF6ZfPs7fZOTOxw3wMuAAugItPuJB+uNftF9NO" +
    "92uJjFoAF8AFcPEGl04PcPn1Gbf7vTgbtczZZu9M184CXAAXwEWvnN/f5W5R" +
    "nbPXz48fDr8jStNaQevO81p7Ll3rdCXL55xbrT3nwe5z/u30dY91HeVQHy7K" +
    "uVZTRfDVyyfdBXadBXJ/d9YDXM4BLoAL4JK1r6ZscnMMrJMp0YNDhg0TcAFc" +
    "ABd7Xzr21Q/2xAcPtOzEO1xkx4U8PeoBLucAF8AFcMkDLq+fdvO1tPWKXHo3" +
    "btyYARfABXApHFxIs7fZB3atp0Q0hKLlw6Q/CvqTpv74YajUaxhx15ukGdOH" +
    "6fqTRDE7xN/FNGxt/Mg+zbQ6Uk3TRX2wdov++8i/VHzp2jeu2rvK9f91yP4I" +
    "WOu1LS+9B7gALoBL1eDy5p/tD7C32sby9l67gskarq4zABfABXBxDxfS94bs" +
    "pkZWHynSsZOAC+ACuFQTLrKjTnQ+B1CGy6zeeEa/GAsPIlPWh4JM7uHScJHH" +
    "WQ/6UFMObPyDoEzKWYQ691FOExts07BtQx/al0v8mFFnzYtxIHfe9pI0NMAF" +
    "cAFcjMtFxySbTo2M4UJ7bwIugAvgUm24vHjCfGpkfNjZL94HXAAXwKXqcJFN" +
    "jShE4gwu4rdEt24Kjw15k9FbZ6NKvdZQb56NSvd3JQnl0LVJKV/NPJR8w/hY" +
    "t/5kdrFp+PC3Rrt609BXur7LIg+lsnnoZ/cOmG0iZTQlooOsARfABXCpB1we" +
    "3mcWdzF6Bb3iiFu4vAW4AC6AizO4uO5ra941i7sYxVveOA24AC6AS13gQjKJ" +
    "u7BwoW3uWhO9ZWMQ/OYDuX4r6DeczlyTyjWq+kBfrN1CHtrlNCmXyf225WSu" +
    "/62LOnfhK93fTdqAgzTZdiTIRduOlOOMvA5N6mtuv37cRTve0jyq1RlcPgBc" +
    "ABfApchwWSLZuFsl7qIdb2lqRk8Q/OoU4AK4AC5VhQv17/k7kxnAbX+pHW8R" +
    "93J5+hjgArgALlWDy+rj4QAirf9zX0lrxVuSROed0LEEMZ1O1xtnEu7TSUMQ" +
    "dz/lKSqWrpAGe/1pAzsVfBPJU8UvZzSl68ss6svE3wZ2cv51YcMbp9Ol66s3" +
    "DNq7STujvVzEAG6SjOGiknhTFPChVbtaBQVcABfApVBwkR0tkjtcmnGYn70D" +
    "uAAugEvZ4PJqY2Bw5xa9/s7FXYzjLWlxmEf3Ay6AC+BSFrg8ORoEk9ab9fdM" +
    "4dJ63MjrpwSdjuo1QbHrG3pNV0yasntEu2R26NgkvUfTrtcNZGKXla9P6ZdD" +
    "yVeO5cJXbJqnFeSjXVmWY/Eeu36eFtTVOvhMV9O7G8OtkwkVcApwAVwAl7zg" +
    "8kqjX97Tb9/H0xbTKe+Xayoabj15BHABXACXosBl1dvhg99F/04L6joL5ipN" +
    "kwAXwAVwyRUuj4yYx1cKCxcSDcNeHQNcABfAJQ+4PDjkvk+nnWekvezfVvTh" +
    "I63q/eX7jjQmyEGavxqLypmt73sst4o8+PJXgnzUB5um7u9j2bQj6/pw1P7p" +
    "bDGX0yDVN0Ze3hSpxGFoAxrABXABXPz6hvZecj0NEpW0/YLyMSI+dP8OwAVw" +
    "AVx8+Ua2c78P0WdCynBx8RpaVeQAwAVwAVzc+mbZAf8jFi6om1kwNzKM6guC" +
    "pXvDYwsowNsUvXsX9aqlXlHRWFSvaip2v8yWsfSysr8z6SlJ11eSsnF2c2m+" +
    "6kJcucYctCtd343x7Uj7dxM7Bf14fxDM3lZxuFAglzb2/tnbjhsB4AK4AC5s" +
    "nb/4bvhAn9ZdEbgQUBYMBsFTR9U6COACuAAufuDSej19XLxwMOyfPt8YOYcL" +
    "zfPu294Yjh3Q7yCAC+ACuPiHS6t+ejQEjW18RgkupmtcZm8NgiV7gmDN8SB4" +
    "+b1QL2nqZYleOsnoPf+K2cRJYufLgnTLoWKDtp0+fMGUK+YHE39mUG4XaWZR" +
    "Hzo2cO3sRyNBMG/AI1x01rhM2xwEi3ZFgWLjTMAFcAFc8oNL83rqzzRQoAFD" +
    "pnC5uSvctHfVMTkMABfABXApN1xa9eyxcABBAwndhXRKcJnUGQ6XVh7hYQC4" +
    "AC6AS3Xg0mo39X8aWNAAQ2VfFxYulBCtR6FXWdo6EdcL77boRFQvKihyvySP" +
    "WJoKNmnLoNzOJcnXxJ952KntK0v/vnCimL7Jw6YXGKmmI45kjOByRy/gArgA" +
    "LoBLVHf0GsBFXPoPuAAugAvgIuq7OwEXwAVwAVwygItsu0sWLrc34PJ8o0LX" +
    "KOh5QfRKq1VcOs8fl0hMV/g9lofm71ev4eywtEF2Dec7Lk8VyfwfqR9RxxWk" +
    "Wedr3tWXdppcGzAoK+t/lfph/K1bX89b+tu4HBJ/PrCT/wSAhQslArgALoAL" +
    "4GINl4kdgAvgArgALh7gIt4AuAAugEs14LLGIVx+csABXGi3uOcaCa5+J67n" +
    "OB0XpHu/RKst01h9XCLNNNnrj8vLrpOGaKNROQQbrH1nWGep5VbwlUk7c37P" +
    "cUYO2qJJW1/toE/ptl0SnaoKuAAuTuCyGnABXGzhQvthAi6AS5KtgAvgQiIu" +
    "WL8torOGAJf6wmU14AK4+ILLzF7Apa5wUanz1YAL4GIKlxk94dmyz6romCDh" +
    "91WS/7dKJQ/a6iGit9PF2qiSBlMuE2nbaeB/E/+2prVKIu/lzkpcG+DKrdmG" +
    "VmXlizS7junblGQX7TbZyglawgK4AC7K6QAugIsqXIy+igZcagaXY4AL4MLb" +
    "NbPHAVwmdwEutYHLMXu4rAJcABednejo4HgljUb1jKDYdSZpHotK/F28P9GG" +
    "1mtEjaZL2R8a5dK+ftR9GiblTPSRok2cr59RKaetX0x840Gxtm0gtt0a+EaW" +
    "zgzABXDJCy7PAC61gsu8fsAFcMkQLs8ALoWBi3G7S+hDUzY5OrcIcAFcjOEy" +
    "CrhUES7OTlxcfjAInjwa11OiRhkJ1z85GtVTR/1LqRy6aYjlMJGuHS7SMCk7" +
    "V9YkOxPsNqkPL+0mg/qwtnuU95+RnQZt0xlcluwFXAAXS7iMAi5VgcsTh+Nw" +
    "WT5iCJcHdgAugIsDuIwCLlWACw02uKX/ynC5dwBwAVwcweUo4FJ2uDywwwIu" +
    "4icA07vD09ZErRAUu+awoIT7Eu+nvx+OauWRdK0wEJumrg2HFe5J8I2qb3XL" +
    "tcKgvkx8pSqr+rC8Pq88dNsR10ZWarQBV32BNLffAi7zhJtpjxfApbxwWVFA" +
    "uKwEXEoLFxpscAvoEuEiW+viEi4rAZfM4LKiwHBZCbiUEi63buIPoU+Ei2yt" +
    "y8P7AJeywWVFCeAiywdwKTZcVF5DJ8JFFtR9sJHAE4eievwwo0OCdH8/nFMe" +
    "zD1PCIpdL5F4j7YvORs91McTh3g7WV8wNqnkoVR22zq29I20bKJvbNuugp2+" +
    "60v2pogGI1ZwuWcb4AK4AC51h8tDw2rB3FS4iIej3bUFcAFcAJe6w2VOvwO4" +
    "iK+jp3UDLoAL4FJ3uHxnC7+9JQsX2Rujxw4KOiTooJ2WS8TlEbveJA/dcnE2" +
    "HZKIK5cDX3LlWs7osSykWE4t33lul7I0lerzYPay7Q/c9bdtVnsNnQoX+lZA" +
    "hMuP9wMugEs2cIn4EXApDFwmdqq9KUqFiyyou3AQcAFcsoPLuC8Bl0LAhZaj" +
    "qHywaASX2dvcVuLyQ4AL4GJQLsBFyVeuYUTfGKoGc1m4iEe7km7ZGG7OS6BZ" +
    "tLsxVToAuAAufuEidmbAJRu4UP8moNy5Jez3IguuW2cBF1lQV6YbN4SBntlb" +
    "g2BBY+q0dG8QLGtAZ9n+qH5yIK5ljGL37BekmZ5SHkyaur+biLNXpRyc/2P3" +
    "M741qT9d36Xek2SXYLeRHaKvNH3hop2Z5GF7Pf3t0cbU5vu7wv5Le+PeuEGt" +
    "3yct+1eCi2xqpCoK/DSBc//2IFi827wjAS7xtGsJlwOAiy1caIXt/MYA4O6t" +
    "Yf8UA7Q6Sou3eIVLkqhAVLC5jeHWg7sAF9OGVFu4HABcVNKk3xYPh2c6z94a" +
    "f4XsQhw7WLiIi+l8iOZzd/aFTiCHAC5mnbIucFkGuMTSpBEJPbBn9cnjI67F" +
    "xVuU4KIad3EhGqJREOnR/cn6kaBHdTUiEXeN7u+mdiSlOWKoLOzOw3diWra+" +
    "9uVL27Jq2LdoV7haNqu+ysVblODiY2qUpHnbeYfXDi4jgAtrD+CSOWCeGy0R" +
    "XOYNqDm8VnAZAVycqCZwyRIwKtxQgovvuMvVEcsI4OJcgEvt4EL63qDn8EWH" +
    "Q7jIvjNyJVqk88i+UA+raCSqRzjt4/WwrkQbxDQldnBpPpKBdPN82NE9uuXU" +
    "9i/z+8MjfLvRrWOlcmm2RRPfxa65lpdsNa2zwUC/Q7j4mhrd0WvQyQEXwAVw" +
    "YeHiEzAq8RYtuNCrJ59gAVwAF8DFLVx8AUaVGcpwmdfvFyzKHR1wAVyYOhY7" +
    "WZ3hQtfM2eau79L3hs7h4mpqNLM3XPAj01LZ3/cI2qunpYJUrondY2kDl+cS" +
    "hXKrlMOlTap2ZWEnl2aszvaEWrI3X9n6woUvm/fe3usGLtySf2O42L7imtwV" +
    "BIv3AC5LVBoM4GINl7wBUyS4uAKMDi+04GKzWpcDS2KHqzBclgAu3uGSJ2CK" +
    "BhfSzF6/q3KN4WI6NVIBS93gsgRwAVxygAv9bVq3GVySzidyBpebNuiDpX04" +
    "CH6wJ/wosVU/ELUnJw0zyiI/XZuGDexmfl8syEtZXdxjWD+pbU9QrK0a1A+b" +
    "hgexddiwo3132C9df6hoDRedBXUUo6FtFWSVW1u4DAMuecGltQ3WGS4mgFFd" +
    "OGcFF9WpEYGFdqVLenLUEi7DgEvecGm2w7rDRRcwJpwwgsusXh4s83emD0tr" +
    "B5dhwKUocFHxbx3gQlrU0A3r3XxL5AQuFNhJM+S7O4Lgod0hGVv1kKB2BdHZ" +
    "tK3STfMhBbF2DAuytFmp3JyGJeLKJZRD9/r2YX07Tcoes5MrJ2fjsLxOdOzU" +
    "zbN9t5+2yrUD7T7XuOeBxkBgQsoyk7SziZzDJe1zgLn96s5TbWhlhkv7bsCl" +
    "qHBpB1zG7U8DjCkjjOEi+xyAdg7XcV7V4WIKFsAlO7i0Ay7jund7vE+nHdfq" +
    "DS6ywO6tG/3Apb2EcLEBC+CSLVzaAZermt5j/gW0c7jINpG6bzvg4kKAC+CS" +
    "JVwWDLkL5DqBi2z0QjuP0wFLRhqSaBcEQaZaJCjpuundbkctTuAiG73QHhKA" +
    "CwSVAy60bMT1qMUJXJyOXgAXCMocLrKvpXW2VvAKF2ejF8AFgjKFy/eG4q+g" +
    "Tb4j8gYX2aI6+vKSDE/VIK+FooQ0FgqKpTFkIC4Nwb6YzRK7xHLY2rlwUCFN" +
    "3Tw43yfUR8T/Huqc869JHmyaos8YXy4cNBDTRiI+GJK3K1vfzexxt2jOC1yS" +
    "NpJ6YIcfuCwsCFwWAi7Vh8tgdeFCB9L7GrU4hQtFlrVHLyWGy0LApT5wGcwX" +
    "Lklt3RYuMzyOWpzCxWj0YgGXhTnCZSHgAriUHC6+Ry3O4SIbvdCqXXrVJdMC" +
    "QdrXDCpcPxjVgp285qdJIU/tNHeapWmbR1HF1aH29YN8GrE0B6NyUg6VtqVR" +
    "zgUmeV5Le7rnUYtzuCSNXu7a4gkuOzOGyyDgAriUHy7zdrj9QDEzuMhGL5M6" +
    "w+lRqeEyCLgALhnCZac/uNzc5X/U4gUuSeteaHlxaeEyCLgALhnCZac/uNy1" +
    "1c9q3MzgkrQVJi2soxFMorZLxF2zo5y6f3tUpbFbUNb3e0uzCO3Oczugj4pl" +
    "e7bo7uqfO1xkZxzRfp2AC+ACuOQDF9mRIjb7teQGl6Tg7p1bABfABXDJWknn" +
    "Rfvs/17hIvss4PrOcHgGuAAugEu0DD7rbXJGQdzM4JIU3L1tcxDMG2hou6AB" +
    "fRGoZBq/RshDeq1ow/Z03WeiAUZJ9jfLOaCfBvt7mh88ScUm2zSU6pxrW0wa" +
    "Sm1X1ScW4voD/U32/ZCvIG6mcEkK7t691S9c7ttuAJcBwAVwyRYu93mGC22Y" +
    "LwviZtHvM4GLLLhLx8L6hotyQ9uu1ygAF8ClLHChWYLtgfKFhktScPfq9KgI" +
    "cBkAXACX7OFyn2e4zOpzc+Zz4eGSND2ataUxdBu4pn4P8pVuiu6VyDYNablE" +
    "MdfcK4rJQ1qOAUacnap1lnKPtm9M241OGgn+SLTTc7uksINsOuQ7iJsbXGRn" +
    "HZED5vR7hssA4AK45AOXVsBk2SZlR7RSKCLL/p4pXEhUQFmhvcNlIKQ5LSRq" +
    "flsBuAAuvuFCnZzaN33+8p0tDuxSkOwNbZbTodzgknQU7NTNfhxN0y5Km9bX" +
    "tOZHgAFcABffcJm6Ob7O69ZN4abYtLDNdduTbbbtc4l/4eBCO4tL4y99buaa" +
    "tMMWwSPtcG0awQAugItvuNDDLakNNh9y1Bap3VYhzpI7XEizJIRt6wgdNHvb" +
    "t5ojaLZEBKUpjafBpPXpFSnuMTNnm1yzdbVVkMI9cyzlIk3R7jnb3MtFua3L" +
    "6aBOjfK4dm/bOrU2ObEzbMf0cFSt31YbJ3XmH2cpBFySXk/fuIGHSzN2Qucj" +
    "tXWoA6W1Ep02RsAFcElJY/IG/Tba/NB32rVYDQeXKRuLEWcpDFySXk8TvcWG" +
    "dGdfuC5GZ3SSJEofcAFcsoLLtM32bZbaPbXbO3rjdTijuzhxlkLBJSn+MrM3" +
    "HB7S6GRip33ltEqsIMAFcPEJl+/0uW2/NFqnfkFvoOihK5t25RVnKRRckuIv" +
    "vkQVQbtxpWqLIM3radomikvj7i1RmdgUy1dMkxOXp4K0y7GF95+2LwzqQ7Rb" +
    "14a7GU3qzK6N5xlnKRxckuIvvhwPuAAuWcPl1o3ZtO+84yyFhEvS+hfXorgN" +
    "4AK4ZA2XOzIanecdZyksXGQnB7gWvbYGXACXrOFCavP88KT+U6T+XCi4+AYM" +
    "rY6kbTZj6tPTLEHSNC3zyESMjbMUysr6woNdrN1bojLKQ7cNKEi2G5wr0Xd7" +
    "RevLhYNL2hskW1GEHXABXPKCi+ybn6qCpbBwSfqC2la03R/gArjkBZdZfR6m" +
    "+b3FBEuh4eIaMDTfvbMPcAFc8oML6frO6r1yLiVckjb4Nq0I+mJURXcI4n73" +
    "IV0bXaSRRx5KZesR5KF+Ynb0ROWiHPS3WzbWAyylgEvSHjC6an7mDrgALnnC" +
    "ZVp3tdaylB4uLgAzsxdwAVzyhwtpQkf1wVIquNgssqN57u2AC+BSELiYPijL" +
    "BJbSwcUUMLS+gN4UJYm+Kk1Vj6BuA3Fp9DDSvV6iWLmLoG4HcpCHtW807Lp1" +
    "U/XBUkq4mEyRaMk/4AK4FAUu03uqD5bSwkUHMDS/TQML4AK4ZA0XkupX0lkc" +
    "uwq4GL6mpp3tABfApWhwubmrGq+bKwsXlYV2t3SFO4GNq1uizZpi7r9NQbF7" +
    "uqOaxknBTu08N+uLtZvxnYpvuHt0bbytW99XMRsUfBcrW8v1UzZXGyyVgAsH" +
    "GNpHA3ABXIoGFwrqJr2cKOq3QrWEC/exI02NABfApShwobeXbRUHS6Xgwm3X" +
    "QGtdbgNcAJcc4TK1W37MapH2vQVcGMAkDTfpaUHDUcAFcMkaLtTu0rZyLdpG" +
    "T4CL4Z68N1w7piFJUwVN2WR//VRGUzQ1daNEjvOgs3BE2eaRi68MNMWhKDib" +
    "9MCjvxdpa0rAxcGpAs3T7QAXwMUnXNLO2arCG6HawoUL9NJTg9YbAC6Ai2u4" +
    "0NYKaR8oVi2+Uku4mEyTABfABdMgwMXdNKkjfEVITxxrdUmke8/GAqhLQVmU" +
    "owi+UfDDzczpoFWfBtUaLs1pUtqX1TRHBlwAF11fULtJa1d1mAbVHi4qHz7S" +
    "K2taeAe4AC6cL6gdpcVWyvpFM+Di+bskmirdDLgALgm+4DbbpthNnftXreGi" +
    "ek41NSJ6QjU1mdFNBpqsq664MslDkG6aSjZ1pUvXBqkvGN+l5c9Ngei3Ki6K" +
    "A1wMRXNi7mgSalSAS33hQlPlto5yHlAGuJRgjxiaX98EuNQOLtwUqG5vggAX" +
    "Q9E6BG6qNDEFMoBLNeBCadOrZW4KRG8g0W8AF6dTpeZIhrYspIV4WepGBXH3" +
    "ZGHXDSWVyvEfmAIBLplsp9mWMWQAl/ygUuZ9bQGXgm7lMLGjOJABXNyJ6ksF" +
    "KjQFquNiOMClgJC5vhNwKTpU2gAVwKWskKGGOeEaaCLqiGqioNj1giYaSMyT" +
    "yyN2fYdCGszvrE0qdunaLfxO9dG2Tm36g/UqgEuub5amKp6g19YKGsAlU7iQ" +
    "T9s61M8KAlQAl9IFfpujGQLNRMDFK1zIjxPWpb9KBlQAl0pCZnzatA5wcQkX" +
    "Gh3qnClO9VWXPVYAlwp9GKnTyJsjmgnX/m0VdRhObYImrEuXmEdbB69Ynppp" +
    "xOyW2SXety5dzbLr+BrrVACXysRl0jaqSgLNdYBLKlyuW6cPFBqlYOoDuFR2" +
    "s6q0vWS4UU1bjeFiApNmLAVL9AGX2n1eMLFDv7MkwaZqcDGFSdM/mPYALpBB" +
    "fCZtKnXdunLBxXZk0iqafiI4C7hAKVMnnTdOdRb5CatnARfIYvoE2Hy7bwr5" +
    "A6MTwAXyBBuToDBgAgEukPY0qjm6MQ0Q5y2KtTSnOJjmAC5QCdbXUEelYHFR" +
    "plVkBwVdMRoBXKAawEeUeLSpOAWj0ZF4jSwdwANwgSAIAlwgCAJcIAgCXCAI" +
    "gtzq/wFey2EufhX6mAAAAABJRU5ErkJggg==")

SPEED_DISABLED = ("data:image/png;base64," +
    "iVBORw0KGgoAAAANSUhEUgAAARcAAAEXCAYAAACH0wDUAAAqcElEQVR42u2d" +
    "aUPUSNeG3///Dx6BAVEEZd8RRNlpZHDHQRFFGRV13GecxXmevH0aG7pOVXKq" +
    "kko6y/3h+kIntZyqXFRVksr//RwE/wcAAL5BEAAAkAsAAHIBAEAuCELVmJ2d" +
    "DcbGxk65cuVKcP78eYWOjo7gP//5j8i5c+e0c/v6+pT0CcQdcgElgi5qutDp" +
    "grcRRVb89NNPpwK6ceMGxAO5gDyPQlxGG3mlOQrCaAdyAW2SCf3XpwuxyCJx" +
    "oSkctD/kAjxC04aqyUQa3VA8SLLoH5ALcJQJLbD6muIMDw8HU1NTQa1WC27f" +
    "vh38evRr8NeffwX/++//Gn9LUwTLK8vBf//33wZHvx4Fuw93g62tWrCwsBCM" +
    "jAxDNpALyGKqQ4uccS+wnp6ehkCWl5cbwnjx4kXw5s2b4N/v/6r8q/Lt27eg" +
    "v78/Nbl8+PhBy/P7d5WPHz82ykvlJqgeVJ+4eZKUIRrIpfLQf9y4Mpmfnw9u" +
    "3brVuDj5BXyKIBdid3c3FbFs1jaD7/9+F+USVnaqF5WNhBlXgLRWg7tRkEtl" +
    "oCmP6/pJq0waI5J//7XDQi4ETZ18ioXK+8e3PxLJhdfj44e6bB6cyCbOyIbi" +
    "jv4HuZTyeRPXNRSaHjjLJKZcaFqSxqjFp1x4PSguFB+SrotsqB1w5wlyKfzC" +
    "rMvDa3SBLC0vBY/3Hwf/fP8n+OefGHxnaMd8V/l+xmRdZj7EcunSJaFMvAw2" +
    "5Vb5zqBzXh+/DjY3N51EQ+tcWJ+BXAolFZdRCv3nffDgQfD7H787XWC+5fL6" +
    "+NiLXKgu7ZBLKyRoErXLHSeMZiCXXN/xsZUKrXHs7OwEHz58cBBDunIhlpeW" +
    "EollanLKokzpy6UJCZtkNzk1CclALsVcT7FdoKXnO16/Pv5xYbmKIX25kOyS" +
    "3AZ+/vx5ruTSCtWN4g/JQC6lkop68X3PrVzoQqV1i7ijlu9W9WqPXJrrMrjL" +
    "BLmUSipNDp8dBn//9beRvzh/q/z9118xYPn8rcLzpL99/fo11ujlt/fvtTL/" +
    "ZczjLxVTPNgxpnIqSPVsIe6oDJKBXFKVStLFziLIhaD1IJd63VhaMoulRHKB" +
    "ZCCXVPD1nk9R5ELQLWXbW+hf6qOdqsiluSaDW9iQSyJ8b7JUJLk8evTIqk4b" +
    "GxvhYimpXFqfk8F1ArlkPgUy8fTp0+DPP/8sDJOTk+Ko5fPnz4WqUxrtijtL" +
    "kEumUyATRboICZJhVH3u3btXuDqluc8MXpKEXLy+oVxmuRBXr14Nfcy/iPXJ" +
    "Ytc8XE+QS+Jby1WQy7t370oxxWuS5CFBTJUgF2uSbNAUhz/++BbKN40/GN9E" +
    "/qgfFwVPUzqetk0g1tbXlHpMTEwE3+p/J/RzvinIZZRjoR3zjfOHinbOWX5U" +
    "9qzam6bYkEsFiRqtdHV1lVoupovOeKH/uHg/fvqk/Mc/ODiIyMd8YZdZLp2d" +
    "nZG/V/W2Ne4Esbsfd+/eDT5+/BSsra2XQC7fBOzkQqytn8Tj+vXrgsSEPEQR" +
    "FEsuc3Nzjf5Cwo16NojW9CCXik6D1usXz6f6f2jaV7bZKQ8Onlo/TNZ2uXyz" +
    "kUl8udDohWJBmzR5lYuBIsil+Y+I57G2toZpUtXkEjYN6unpDh4+fBj8/vvv" +
    "Ruht2qgO40JYHrnhK8MQC9c0v/7+lfG7zFcG+z1JHX3IhdI4Pj4OzYN29ov6" +
    "p1SVaVKlp0FDQ4P1TvLaqlOSgJLcaaAOWXS5xMGHXH6vn6fSHrlQ+9+8edMq" +
    "HxIxTZmqPE2q7DRobW3VubNKHSYduSS/oCCX5HKRRithkIyqOk2q6DRoN1Fn" +
    "3a2PYrodRzFOcvF8QUEuZ9CCtKtYtixHK5gmlVwu9Ah2WCMODg4Gr1+/Dr5+" +
    "+arw5csXla8qX7+ofKmf8/79+0ansO2g4+PjarpfBHgZvn5lfDGgHsPTFOvN" +
    "j9fy/KqVSyq38++mY7RYqHxplKuFL+Gsrq5atxn1F9rg60sjXrwPuCH1lzJu" +
    "5VC6bwKFNR51qi/s4koilyb0idTu7u7YcrEuA+SSqVya/aVJUrl8+XHe1tZW" +
    "ZQRTerHQhU9f7jvrJH7lQtBoiOThIhfnMkAumcildbSShlwISj/sXbYybeNQ" +
    "6pcOm9MgtZP4l0vzPPqvFDaKacrla9wyQC6py4V+O4tNenL5+mOaRP2zzIIp" +
    "7R0harh3v/0WfP78SeTT588Knz99UuHnfPqs0Hruy1evjKMY+hvtfXIGL4OK" +
    "nicv02dntHqKyLESy83TjFMP13MijjfJhf45HR4esjQYQnt9MsZXasNPweLi" +
    "tdLeSSqlWGZmZxti+RRygaQplwb1v9VqNWUUQ50acsmfXFZXV4LffntnSCMb" +
    "uUQJhu54Qi45utV8bXExuoEzkgudd/js2enQF3LJl1xotPLo8ePwWGQoF4Ik" +
    "VzbBlEosi9euyQ2cgVz4+asrK5BLTuRCH6+ntmiObEPjkbFcCCpb6BcWCrjL" +
    "XWnEQg1DDZZHuZgvCMilHXIJi4UWlzbIhfIpk2BKIRb6zs7Hjx/NfGJ8BGd8" +
    "YmRfhk/1fDnO6aTQxp8YWcaEdvkLu+tYJMEUWizUAPfv38+840Eu5ZcLl8zH" +
    "HAkGckl5R34KPDVAOzse5FJ+ubQT6t+mZ2GKsshbyNvN1mKBXCCXEgjGNIIp" +
    "gmAK+RzLzz//HLx//6EBbYMQRfO4KD58eK9gc44CndPCBxPvJT6oaOez3w1p" +
    "vKf6KvBy8di8j8ScB4Of90GAx/79e3c+RCPFwSYWYXmH9hktzw9iH9Dy1Prh" +
    "CbSFpkkweX/QrnDvCrWKBXKBXLKWS1gZ0pRLUzBFe1WgUGLZ3Ng0iCFduVjJ" +
    "BnKpnFx4v0lbLgT9Yy2SYAqzLeXCwkLjospSLtYjGcilknJR+kgGcqH8wgST" +
    "x+0aCrHR0/T0dPDbb7+1j3cq9HRnKz7ySCPNPJbh3TsVm3i3te1zGP+w3fTy" +
    "JphcySXsyUQatUAukEuueZdd/JeWlgqxZWYhvoBI0AY7kAvkkmu5vEs//rQ/" +
    "kbTzIeTi+M3mto5eIBfIxaWPpBj/jY2NwnyjOtffFeIcPj8M3r59y3jHcP39" +
    "bb2Tv1Ohv7Wgp8F4p/Lurc7bd28Z7yLRyyDVy5COcA6vt02stNgJ8HrL9TKV" +
    "862CFCsbXOuq9REtdqY6RMfKOc/63y5evGh1reThu0i5XWcxvrS1dANygVwK" +
    "Ipe33uWyHfENpDyuv+R6ncX02P/Lly8hF8ilknKxHbXkZf0l1+ssYa+cQy6Q" +
    "S9Xksr29Het6aef6S+7XWUyjl6Nffw2O37xp8IZzLGBzzhs3jhl2xxwz+PHH" +
    "Cm+OVY4t8uVpuJbBHD/1HPrEaStSOaX0TtJ8oyC2D89Xqpcpdloabm2sx/rY" +
    "uR/xerbmNzo6Gvuaadf6S+7XWYyf19zaglwgl8rI5f6DB0HSa6Yd6y+5X2cx" +
    "QXPPWHJ5A7lALsWTS5JRSzvXXzLN7Pz5816C1Dp6sZbLG8gFcimeXHyMWtq1" +
    "/pKLD8THHb28Pn7deGJR5ZjxOnWOj1W8pMnwU1YpNtnHrtGGnNdFIIVYGeJw" +
    "9epVr9cNrXeWTi4+pkPaxty3diAXyKW0cgnbw6Uo06O27s+SlJHREaHRX0Mu" +
    "kEuO5XIcGQvfo5YmtDxRGrmkEaAmtPu/udFfQy6QSwHkcmyMxcHTgyDN6yaL" +
    "T5Tk9mE569HLyEj0fwPIBXLJvVyOtViE7dniiyw2+E41cbq3nmaAmjz85WHw" +
    "8tXLE16qvGK8fPVKQzvm5SuFV/V0W+F5aMebeKVyWt4fSGXQyv3ylaGcLA+b" +
    "crWg1euVjp4HjzdPk5fhpYipjdT2Ynnw320Q0tDjLdVT7ntS+zRjTC/oStsq" +
    "FGFxt3CLuCbm5uYgF8ilNHJZXFzM5LpJe3G3cIu4Yew/2YdcIJdCy+VVhqOW" +
    "LDb3zmwRlx7gGRoeSn/0ArlALgWWS622mer6ZGdnZ2avBmT2+dXl5eXg119/" +
    "PeXOnTsNrl271mB4eLhBkuA9fvxYycOeI0b08UecI5V4ZUgOLwcvp3OaRwaS" +
    "ltMivaN6G7TSrnhGlTtOm9u0x4ULF2L3/+Y11LymmtcYv+6yWtzN5I3ngYEB" +
    "58aMIx86DnKBXIoqF2kLS7qOWuVB2zDQNfLs2bPQPmCqh+lGSxpfDshkEXd3" +
    "d9d7Y5vkMzExAblALoWVC130ofI4itcHTPWg9EyPiORaLqZRS/zRhL/OCrlA" +
    "LkWZFkXm60kuBC1TpD16SXXUQnZ8+vRp8OLFiwZHRyovjo4UjugYxotQjk5o" +
    "pNNKdJqRaYWmqSKlefTiSEPLk6fL0+Cxks43lEuD4tGCXm5WLxbLE3i5jwSi" +
    "Y2M8h+fp2F6m+IvtocWX96Po8415CPWQ2sOmXbVyav1GjVXruab1nVzKxfTW" +
    "Mw3zIi8YyAVygVzaJpeN9fVURy+p3iF69OhRSnI5glwgl8rIJaptk8gl7dFL" +
    "ZqMWyAVygVzyJxfTp2F9vRaQ2qhlb++X4PD5c4Xnh4cKh4fPFeiTrSKH0ehp" +
    "HjLkPHga9NRkK8/jwOoulyN5ucXfeeyE9rJps8PGMS1oaTKM8eJt7hg7oV6H" +
    "hnI6x9u5PS36spiHTT8T0mTHHzx5ot058vXcSyqjlpmZmUbBIRfIBXLxJ5fD" +
    "58+9y4XSpU8lpzF6SW3UArlALpBLMeSS1ujF+ztEzVEL5AK5QC7+5SIKJoZc" +
    "0hq9eN/Nf2dnp/EEoJlDxjMHDo0c1n9rRTvvkGFMx62cznkePnOsq009/CPW" +
    "61le6pGkH4XU/VBFj82hwrO04hOzrU7bTIhvWD339/e9j168jlqGhoZS6hSH" +
    "kAvkArmkKBdifn7e6xvTXvdriR61QC6QC+SStmCSyOXhw4de93vJcNQSt1Mc" +
    "Qi6QC+SSgVyImZlpbw/Vebv9vLq6Gjx9ehDJgcZThacGDg4YLI2nzjyVOVDh" +
    "ZeC/y/U80OtxcKDwVIPn4V5uKQ2tXhbx02OhlltrHx5L7XcDPF+tLlKseJkN" +
    "SO3D++aBO8Z8lTIIecSph3O51VjeuXvX28Kut4Vc2qgJcoFcIJdiy4XO4a8E" +
    "xP0MrJcp0fT09I8OC7lALpBLlnLRY5pcLlcNC7uZyMW0i9Xm5ibkArlALiWR" +
    "y4PdXS9vSyd+Ire5ZwvkArlALuWQC0E3aJKOXhJPieh7tk+ePPHD/g+eFIt9" +
    "xpMn+wZC6voDeoipFfF8l3gWNK5nuMUymzZuTxpZsbKykvgTsImfbbl9+zbk" +
    "ArlALiWTy97eXuIP2CfaxrK/v99vpQp6AUAukEvZ5EJMTU0lmholmhLRZych" +
    "F8gFcimnXEyfOnF5HcBaLH19fVpG9+7dazzf0mSf8Zizz2C/n5yzr7L/OBp+" +
    "vCFNtUz7hjwYj6PZ19LdVzDnEV0P1zT3jTyOxCb+ke0XFr+I+Lvm2WBfRW5z" +
    "IdYWbRgvFtH10I5h/0C0Npb6xL4pNmrf1fuN0H7a+Wqe/GVGl2deYo9aRkdH" +
    "3RtE6GhxLkrIBXKBXNKTC30mOe7UKLZclpeXIBfIBXIpuVxu7ezEnhrF/tjZ" +
    "/fv3IBfIBXLJmVxOzvMnF9PUiJZIvMmFv0vU29vb+GwIZ29PRfpdOdZwvA17" +
    "j/YUHjXT+oH0e9x8Ffb2FPYa5VLxnqexHLzurAxU/xa0dtCOT7+M8dIR6kFt" +
    "0IKxzYVYSe0n9XWrcop9l2GVr5qmGAtWRhO0BBJnE6lYUyIaFkEukAvkUg25" +
    "0CeZ46y7xJLL2tqaV7k8glwgF8jFm1weeZbLTsx1l1jrLbu7u5AL5AK5VEQu" +
    "lG6cdRdRLjxRWn/55ZdfjOz9sqegHbPH+CUFYuSxx0h+/J6BDOrlOb57FnUV" +
    "Y8HLVO/gClbx42napBFVhuR9wAfx+hGD1Yunp7XhnoptnxkeHnZed3GeEjU/" +
    "HwK5QC6QSzXkYvrsiM26Syy5EJcuXQru378PuUAukEtJ5ULX98TERBDmAGn7" +
    "S+f1Fr6XC20UBblALpBLueSyvb3dGEBEXf/SW9JO6y1h0LZ4uw8fNj5NoLCr" +
    "sst5qPLw4a7ObjS7HJamnueuhpbmw2h4vcR6GvIV09Bio2LKQ4/fw0jitId0" +
    "zO6uBC+zoVw8j4SxilUPqb1MfVWLxcNIxL4stI+xjfg1ol2T0X2d0lhZWa4P" +
    "HLqsrv3YcrFJvMnwyEjjRUbIBXKBXIorF9OnRdoul+Y6zM2bNyEXyAVyKZhc" +
    "7t67G1y+cjlwveaj1l1ir7dErcNcv34dcoFcIJeCyGV9Yz3ospwGtVUurZ8b" +
    "efDgQUW4z3gA0IY5rZv6G+2BneQ6j1rUdfrwmSv0FN/du3fRMQHaMGdyoeuS" +
    "PxgXh6iH6az3y41LV1dXsL6+jo4J0IY5kcvW1lZg2lkyLs5y8ZVxNaZJkAva" +
    "sBh1o32v6R++z2u77XJp3K6uD8PKOU2CXNCG+a8b/YNP47oO+55RpnJpLgBt" +
    "1jaD+/fuNZ6LaYUeN5a4d/+ewv179xXuce4zjPky7qloabAy3DPly+B5aGVg" +
    "9dDqxcrAy3gST6EcWrl5GXh6FrESY8cRYmk6hsdSqLdNXLR+JbSHHguepwkh" +
    "nrwva/2dx/a+c7ko3dt3bnudBtneMUrlTpHNOgxtQAO5QC6QS7pyWV1b9T4N" +
    "Mt24sZZLmpbjxoNcIBfIJR25mHbuTwN6ts1aLj5uQ9tCAYBcIBfIxa9cbtxY" +
    "Sn3EIi3qZrre0mRgYCBYmF8Ibt261VjgbXLnjs5dzt07AnfFNDXuqtwVUfN0" +
    "P99UL7c8beou5sng9TDC20eKP4+Nc73jxOauRb+6o+Kapxa7OxpiLFzbLwa0" +
    "2Do0NFRuudBoiPbdvHlzK7RjQS6QC+SSDvSPnDZ96uu7WA65kFDoY9b0zVml" +
    "E0AukAvkkqlcWmNF/+CnpiYDn8sfpjtG3uVC8zzKiIZjxk4Q0bEgF8gFcklf" +
    "Lq1srG8EU5NTiddnUpXL0OBgMD8/H+z8/HNw5/btBrd9cEdATOMOI+4xDscb" +
    "ynmn3oFbca+HzB2Ge73iwPIQ6qXFwaoP3FER6+0jlncU/PTd6HqkgVIHIU96" +
    "epd/AM2rXFyecbl48WIwOzOjCMV3I0MukAvkko1cmvxcv55poDBYHzBkKhea" +
    "p01OTga1rZpRKJAL5AK5FFsurdRqtcbXPmgg4fognZVcaD5GwyV6u1m5YCAX" +
    "yAVyKbVcWqHrnwYWpoVg074uolzoJLqNdWvHxI6AfvxOK/V0ndHS4PDjVW7V" +
    "j9G5pcDT1I6X4sDSM6XJy6mf45jnjk2aAjsWGON3htReruk10uRpiO3Fft8x" +
    "9AOtzXie0f1G/90UTyEPXm4tNkJ6O3o5ovqu8frQ+oypv+v9jI9kYsmFHniD" +
    "XCAXyAVyae1n/XUvOMuFD3kgF8gFcoFceD/jH0uDXCAXyAVySUUupu0uRbn0" +
    "9/c3bk0BAECT8fFx8RUAUS6UCIIJAEgsl46ODsgFAOBfLvwEyAUAwKF3BxPL" +
    "ZWx8LLi5fTPYNkCfbo1ke1vlJjtf+11nm85JwM1tle16Pjq8XAxWLzEOxjSi" +
    "6+Wah6k95LoL9dRQ22f7tPyt5VBjKfWJ7ZvbCjaxktpDLyeLhbH/upVb66sa" +
    "cr9xbmOtj7hfH1L/j9Ov6Dz6qirkArl4kcupDJhgIJfiyGX7ZpvlQvthQi6Q" +
    "S6tcFBkwwUAu1ZSLl7tF9K0hyKW6ctFkwOsBuUAuceVCz7lALtWUCxeBWS43" +
    "IRfIJZ5cLl26FNS2thrflxWpMYTjawxzmjWGmkdtKxqxjLUY52zFocbwG0vT" +
    "ObQtRitO5a3HukZpMMLrZZeuVZu7xioOUnwdf5f6Yc1QL7tYOParqD5Qqzm3" +
    "T1i5+DuI9AgL5AK5WInFXS41yKXCcon1VjTkUjG5tMTaXS41yKUiciEvJJZL" +
    "T08P5FIVubBYQy6QS6pyITbrhaKPx2tsRlPbrClox2jp1QxsJqLGsDvHsdw2" +
    "9XCMnUzNApdz4sbKjN+6bfoncV9uQxljXIPOZTTkYWpbyAVysTxn07tcapBL" +
    "peRy5coVyAVyCT/Gt1xqkEuO5LLpVS4XLlzw890iyKWsctmEXCCXWHLx9lG0" +
    "paWlYH1jXWNjnbHB2YhET3NDg74Ip6ClISHnoeXJ68HqKaVprq8QG+c89HiL" +
    "7aO0lR5bm3rIsXODdpSXEMsZpx48j41opDJZ1ZW3EZW1hQ0BY8ylepyWL6SP" +
    "bNjUnZdz3Z9c6ANJkEuJ5HKaJ+QCubjLZXV1VZPL7OxsPLnQo76QS0nkouQJ" +
    "uUAu7nKhwYb06L+1XEZGRiCXMshFy7MNclmHXIouF5v3ikLlwl8BoE81rq2t" +
    "ObO+tq4QJw3gk3WV9TUV6fiCtOE6A+3uFxpsxJYL3bNuPbG7uxtygVwgF9CA" +
    "BhvSA3ShcjE96wK5QC6QCyB6e3vFj9CHysW07nLt2jXIBXKBXIDVbWgnuUxP" +
    "TwerKysqqyorDH78ysrqKXQ7a6XxtxZMaWh5rKpIabTk2cyXo6WhIaSxomJK" +
    "g9dDO0esd3RsV1f4+auGWDjGyoBYTpaGqU3N9XDJI7p9tD5iQO+bjn1Ai4sh" +
    "D63s0f1O/N3Y5rxehvaK6Id6347ue/MLdneKnORC211CLsWQy2m9CiWXFcil" +
    "AHKZm5tLLhf+cTRa5IVc8i8XpV6Fk8sK5JJzudAgI7FctNvRFy96lcvKCuTi" +
    "Wy5avQoplxXIJcdy4XeSTdtbinIx3TFaXl5OyJLKksrSso6Y5pIAO37JgFYu" +
    "qdxCmYz1EMql14vFx6JMWr20PNVz9DjEwLVeNu3H67Kkovej6HqaSdZ3Y8VO" +
    "ilWcWLJzEl8/wvEX64MMm9vQkXKhdwW4XOgTjpBLHuWyXDq5LEMuuZRLZ2en" +
    "1Z2iSLmYFnWnpqYgl9zJZbm0clmGXHIlF3ocxeaFxVhyGRoa8isXdhFBLq5y" +
    "WS69XJYhl9hy8d1+o6Oj1ou5olz4p12bcyz6UBqJhqzlNlWCXPzJZbkycuGC" +
    "gVyykQtd3ySUy5cvB/wGD3Hu3Ln4cjEt6pqgd49ooWdwcCiYnJwM5ucX6tKp" +
    "V7AunlbobwpLNxpyimSJYUqjBZ6nXgaLPDSWVFzLbEI4Ryv70hk3Gn9b0uBp" +
    "inWX6sV/X5LzoI3FWpHiYKqHVu6wmIXQGqulJbtYJcXY35b0dkuUx5Jjmjb9" +
    "rM7164vBzMx0fcAw2Ngbl65nm+s+7LF/K7mYpka20MIPCWdocDAYr0vq6txc" +
    "uBggF2u5nHXmCsplCXJJKhd6wpYGAIN1kdD1yRdoXYhab0lVLmE0Rzj02vZ0" +
    "3ZaQi71c1M5cUbksQS5WadZ/m7s617ibMzg4qN1C9oHkDlEuprmWbygPmtdR" +
    "EOYaIxzIRSp3leWyBLloadLucPQPO2x9xDfSeouVXGzXXXxAQ7SZ2ZlgsT4H" +
    "DOe6wnWG9Pv1RQM8jUUGT5OdL5XxBPUYvRyLKkqZ9eMX63/TkOousGiBXncG" +
    "K5Me/4h6nrLICPn9RxquZTbFTyuXUE+bevB+ZF2vH+jnh0NTlCRTHFek9RYr" +
    "uaQxNQpjdGxUEEsF5RLW2SGXU8FALtkLhkZLhZHL2KiNWComl6jODrmcXYSQ" +
    "y5lgZmYyEYyNN6zkkvYcjqZeJ/+BIJdwIJeo3yGXs/hOT02ner1GvazoLBfT" +
    "e0a+oEUoeqz4hEUD14ARPVaL9b+3kjzNNMqZPM3k9fSTRh7qEYZpE21fmL4L" +
    "HVsuaU2N6Elf6YKBRCAXyCVfgrFZb3GSC916SlcskAvkArkUQTC2zrCWC98k" +
    "xr9Y0uzgkAvkUk25EPQeoK9rl9439C4XX1MjEgs9gtxgXmVhfv7stx8szC8o" +
    "zC8w5hns9wUGT/8kDw7Lk5VTK4NWpnkRXiZeTqlMC4a6aecsqOixYcdoeRjS" +
    "YPF2jZ3eHgvO5dLKEHJ8aB+Zt+gXWr9ifUaIrakeNv0iMlbG41rbIryedN35" +
    "uH6lR/5jy4Xvq+tKT09P45FkyGVeKw/k4l8up/0FcvEmGBdfOMklydO6mlhC" +
    "5MIFU2a5qJ0VcklDLqbjyyiXBQu5JBWMzVO5seUSd2pEYqG3ovUGrK5c9M4K" +
    "uaQlF2O5KyoXKtdF9jnWNEYtseRi2kBKEgvN065evRrMzanQ35Izx4iRxhzD" +
    "e5nmPNU1osweyj3HuJpXnOt90gZK3xNw76t6m+vxTLlPGNuQ5Vmvy+zMbOO6" +
    "9P2iYmK5uDxQR48h05caTysOuUAubZRLq2CqLJc4grF9cC6RXGynRiQW2pRG" +
    "qTjkArm0WS5NwVRdLq6CieOJWHLpE+ZsJJYJJhbIBXLJi1z4RVZVuRAz9ZmI" +
    "tNRh+y6RF7lEjV46O+piGZ8I5mbnGmstKnOMWZG5ORXtd4b0O5WLMysxxxDq" +
    "IZXZjJAmZ86AFgtej1kVqQz8+Dmb+LIyaOfbxHs2Ej0P3j7R7XHWJvZ9Ua7X" +
    "bIz+rv6u90uLvi7EV7o+6JzxifGgo7Mj8sXiTOUS9jrAyPBIaHDiyGW24HKx" +
    "Ewvk0h65zBZWLrMe5SIJJq4jYsvF9DrApb5LkcGpmlzsxQK5tE8us5DLD0ZG" +
    "R4xb0GYuF9PUqPd8bypymS2gXNzEArm0Vy6zhZLLbEpy6bvUF/sNaO9yMW0i" +
    "NTY6Vnm5xANygVzaJ5fJqUlvC7le5GIavZBwZmZmGtCnQ1RmFGYY9EwMhz7W" +
    "dIZ+zsw0YyYGlE8rvFxSuVvqOBMKP0/9XctDK5McCz0NlWkBqYxx6iHFzqpN" +
    "tTYWYqf1K5u6RiPWy1BO7TheDu36mI7sS41yC311JrIPThuusZOymO4AJxm1" +
    "eJGLafRCn4CsolxmIBfIpYBymZjwP2rxIpeo0Yt/uUznVi4zkAvkkrJctD7h" +
    "SS6mlxldtlZIVS5ho5eqyGUGcimhXKYrIZepqemAb6US5z2i1ORiGr3Q5yOn" +
    "pqYcmTYw5RcKKEc8h8F+n2Zox0+7l3NaIE7dp6dVvMe2VKTU/9pWD3N96MPz" +
    "vh6aS00upo2kxsfHIRfIpQQXZTnlQu/+pTVq8SoXWllOPnqBXCCXYvzHL0M9" +
    "0hy1eJWLn9EL5AK5QC5Z1CPtUYt3uZhGL729vfWKTPxgUmViQoHepOZMTqio" +
    "v09o8DTP8o4iulxKGUznT8jQ7T4FoZ5ambQyGmIj5sHLxFHPN9VVO0Yqg5CH" +
    "sQ15noZ+4RI7Ux5aOqycYW181s+kehvKwWOh1Vsvt1oGU7tH9NUJU7xO8jI9" +
    "jetz1OJdLmGjl8HBKynJZTJbuYSdD7lURi5NwWQhl8mU5DI6Nur1BcXM5GIa" +
    "vXR1ddWDOZ6OXCYykkvU+ZBLpeRivIg9y2UiRbmYNojyPWpJRS5hz71cqg/D" +
    "UpPLRMpykc6HXConlwl2IfuUy0SKcrkyeCWVp3Ezk0vYZlL0aUla4A1lzMD4" +
    "mErk7+M5YcyAUNfxYjDGyGeZxiz6Be9XjHa0V8r9gEYnpmWLtByQmlxM3zii" +
    "4Vi6chmDXCAXyCUE08uJSfZraZtcwhZ3L1++DLlALpBLxgwPD2eyiJuZXEzT" +
    "I1rcHRsbg1wgF8iF1SHNGGW1iJupXEyLu/TkLr3YODo65oFRhbEfhP4+psOP" +
    "kRhjSL+PGeo6phGdpk0eYp7O9ZbjTbc1FXyUO2GaUr1jtbl4viE+Wj1YLH/8" +
    "fczYHyxiPWbXN01vPae1iJupXMIWdwcHB1OVy1kng1wglyzlMuYklzCx+JIL" +
    "3UTJchE3c7mYFne7u7tTl8uYRSeBXCAX/3IZy41caJaQ9IPyuZZL2OLuyfQI" +
    "coFcyiiXMVEuYwJJ5XJ5YMDLN59zL5ew6RHdPaKhWyjDwwrD9b+1Qt9JamV4" +
    "ZFhhhBgeCadxjJonray3opdrmMHLbMonOg2xXlqZhuU0HMutx27EHWN8o3Av" +
    "p8RwDJzzZP0yTqy0eEt9ZliOb7M+g0NDxulQ2ou4bZOL6VtHFIDhqMbxIZcw" +
    "wYRdZJAL5FJwuXQZPtFKn23N8nrPVC6E6bu0tP6SulzqDA0OBX0X+05vy0Eu" +
    "kEvacqH+Tv2b1jnon2sWcrlw4UJbp0Ntk0vYp2ApIGnI5fLlgUbanZ2d2tPC" +
    "kAvkkrZc+IVO/ZC2IaHbw0PDQ97lYrrtnNXdoVzIhXYWt15/cZTL4NBgY68K" +
    "kodpznm2Yn4RcoFcUpcL9emwPtj8J3ex3hep3yaVy1A9jXavs7RdLoTpPQcK" +
    "DD3/MjQ0FMEwY6jRgPTfgJ7+jWrIVmiIGprHMMP1dwuG62VvRT5exa7caqys" +
    "0igDsdpH71fJOUkr6p+caVRD20/a9AHehqb+n/U6Sy7kEnZ7muanUoMN0tpJ" +
    "XU709K9tw/FGTNQ5IRfIxSFN06P3NtB5zbUaSS4kpTyss+RGLmG3pylQvKFo" +
    "dELPxbiMTsIwpQ+5QC5pycU0SneF+v2Fer8d6O/X2tC00Xa71llyJZew9Rda" +
    "mKKg0eiEL8YmpbGYBrlALhnJ5cqVQa/9l0brdF2QtOifbp7WWXIll7D1l7Ro" +
    "ruu0coVTH4YqDDKuRMPTP+GKyhUBdjx1UAVDubU8hTx4mjbn6/VlaWj1YLHm" +
    "9TDFT2RQQWqfWO1hPKe1HrzMgwbO0vMx4ralnessuZNL2PpLGtCaDuQCuWQt" +
    "l17D7gBp0O51llzKJez5F9/Qug3kArlkLZeBkOdPfJOn6zlXcjF9OcA3NEeF" +
    "XCCXrOVCpD06p+sHcmmTYGjeS3IRGWBczgFamQYMJM1HTW+g/jcOP0f6vR20" +
    "p0xye8S9JW373FberuXcySXqDlJSaIUdcoFc2iUX0zs/ZRVLbuUS9gZ1UujW" +
    "NuQCubRLLgOG/VWSktXGT6WSi2/B0Hw3/oUMuUAuyeVC+LwlnZdbzoWUS9gG" +
    "33FvQfcP9NcZ0OnvVxhg6L8PMPpFpDzov1orJ2VtRS2zXgYdPQ0VvYwDCua6" +
    "sDw4vJyUTwv9/TL8HNcyaLEYkNPU6qGVibWPRT20mNf/5qs/510shZBL2B4w" +
    "cR75h1wgl3bLxccDo3l6lqXwcvEhmLPGhlwgl/bJhUhyS7ooYimUXJI8ZEfv" +
    "JoVdpJAL5JK1XGiKXnaxFE4ucQVDzxfQnaJQ+hjs9z6GeL4BnkZfn4pznha4" +
    "p9FngXSO4+/1aYJOdHuIv9vA83SOjUUfCEnLtD1C2cRSSLnEmSLRI/+QC+SS" +
    "F7mEbZFQJrEUVi4ugqH5rdzRIBfIJVu52N6SzuKzq5BLzNvUNL+FXCCXvMnF" +
    "5lWAItxuLq1cbB60IwHRtOiUPgMXJfoU+up/a+WiD/ocsSin+HsfI41ys+Np" +
    "Y/RWvMROrHde0jxDehWg6GIphVwkwdDiGeQCueRNLtQvw25O5PVdoUrKRXrZ" +
    "kaZGkAvkkhe50JSo7GIplVyk7RroWRfIBXJpt1yibkTkYd9byEUQTNh/Bfp7" +
    "Y5oEuUAuGadJ/S5qo/m8bfQEucTck5f+e/T2XjjjgsoFhnJsHfrEg4J2fK/G" +
    "BQGehykNMb0LHF4X9fdejlRPQ121erBY6mnawPNlv1/ojUSLlaFNtfO09ohO" +
    "Q+szEW1K0/Kof3hlvQZLKxfpqwInX7eDXCCXdOUS9TxLGe4IVVYu0kIv/dfo" +
    "6TkPuUAu3uUifQ20bOsrlZSL9TQJcoFcPMmlqtOgysrFZppEtwjpP0429DDO" +
    "g4JD/Sdq0bbs06BKy6U5TYp6s5rmyJALcIX6TVS/qsI0qPJysXnxkaZQNLSF" +
    "XIAE9ZOoKXeVpkGQi8N7SelOlSCXMoxWpPfaqnx9VVoutt+p7uzqDLp7uk/p" +
    "6Y6m20RdUirdkWny87V8enS6uyV6FMRy98iQfFXcytRjVTc1Dz12PQxWL2O5" +
    "eTlZbCLKIE2B6LcyPhQHucSE5sTShj1dP3VBLhWWizQFKtu7QZBLxnvEdHR2" +
    "QC4VlIs0BaranSDIJc2pEq3HQC6llwu1szQFojuQuGYgF69TpeadJfqvRv+5" +
    "oulS6Kr/rZWfnOky4HqO+rtNmboaZT/jp66fVGKkKZ/jWs84sVJ/t/n8B6ZA" +
    "kEsm22nKkoFciiAXG6kUeV9byCWnWznYdjyzZCCXvMqF2sumbWkKVMWH4SCX" +
    "3EsGcsmbXCAVyKXQkqGO2Vk/jhYGo+liSL93yed0qXR1qkhl6qqnKdHZxeBp" +
    "dKnoeZjKJcUiWSyp3Ww+rkfH4XkVyCX3azJN0XSEigZySVMuFHfbbzRDKpBL" +
    "ySQDuaQhF9tRCqQCuZRKMqpoIBdfcuno6Axcvile9XeAIJeCvhjp0skbovnB" +
    "OUZzWB/FuY5zCh3nouHHn2ukEU0HpduKY5r6+R0aWr7nGCFpusQaz6lALpXY" +
    "qCpMNJCLIJdz7kKhUQqmPpBLaTeritpLRpJNteXiLpPmWgoe0YdcKvd6ge0d" +
    "DBvZlE4uMWXSjA+mPZALiLE+I06lCiQXPgVMEgOafqI/QS4gYurkcsepylCc" +
    "8PQs5AISTJ8gm7N9UyATyAWkKJs4i8KQCYBcgPM0qjm6ibtA3G5oraU5xYFM" +
    "IBdQkFEOLRbnZVpF5aBFVwgEcgEVkA+Hf0KDT8FodMSPMaWD+EIuAAAAuQAA" +
    "IBcAAOQCAAB++X/IR+6jSUpTYQAAAABJRU5ErkJggg==")

# Original file: StepInControl.py

class StepInControl(PGLControl):

    def __init__(self):
        PGLControl.__init__(self)
        self.set_name("StepIn")
        self.set_active_icon(STEP_IN_ACTIVE)
        self.set_disabled_icon(STEP_IN_DISABLED)
        self.set_rollover_icon(STEP_IN_ROLLOVER)
        self.set_pressed_icon(STEP_IN_PRESSED)
        self.set_state(PGLControl.ACTIVE)

# // Update state_changed

# Images

STEP_IN_ACTIVE = ("data:image/png;base64," +
    "iVBORw0KGgoAAAANSUhEUgAAARcAAAEXCAYAAACH0wDUAAA81klEQVR4Xu2d" +
    "+b8tVXXg8z91J2qERKNoHCJqNHHKoEajxqHV4JTOoGltY6I2KnaUmffgMckk" +
    "CPqAp4jygMcggzIJOEUU7CHG5If+ofqsc27dt893raq19q6qM9y76/P5/nD3" +
    "Gve0blWdOnV+7VjT/FqlUqmMjWqoVCqVMVANlUqlMgaqoVKpVMZANVT2B5+9" +
    "tWlaPnpT07ztmmVOPtQ0/+kLPs8+R9u+//Bx3y2MX9n7qIbK3kE2tWx02fAs" +
    "CuvkdZcdL0DMubJ3UA2V7UM2ac7ZxqbSngXVs529gWqobD7yX182IjfnXqUt" +
    "OByHymajGiqbx5TF5GUXN81rr1jmg99Y8KGvH+e87y4493vH5XO+vqC1fV0C" +
    "Y42BjIOMB8eosnmohsr6kRusY13itMVDCsHff3tWHGYF4shPm+bWpwx+scxt" +
    "T2moQx+3iZ3BebOi9KlZ5z40y+PNszORl1+scy2hFpvNRTVU1oPc5OTGiXLi" +
    "2bMCcnnTvOvw4ixCCsgljzTN0Sf7ucXjKQPqEOo7XP2Dpjnnu8tnQNIf9jGK" +
    "FOVjxvhWVo9qqKwO+Y/LzRFBNt+bZv/9P/KtxeZsN/bRp4C09aAKA3nKgDqE" +
    "+iU8uejXP90+K5hfa5rnn6/HIILcqzlmjHtlNaiGyrTIJU/u/ZO0mFz88GLz" +
    "Weyl4kKfu8XmcNmZjYz7MWM+KtOhGirjI5905N5DkcsDuUcyv7x5ythwBnu5" +
    "uFAuRVaKrRTdnGIj81A/eVoNqqEyHjkPr8kGeefsEuC0u5rmWz/X3AwoL8H1" +
    "+aQBdRyfhPpjceFDTfOBI3mFRu5zcc4q46EaKsPJOUv5s6ub5h9va5rrf6I3" +
    "TMoUm9T1ycKywcUlRQq0FGqOdRdymVrPZsZHNVTKiRYV+Xj4w7NT+qse1xuj" +
    "iyk2qeuThWVLikuLFGwp3K+5XM+BRS0y46IaKnnIYozcoH3+wcVpu5y+cxNE" +
    "mGKTuj5ZWLasuKRIIZfxl3ng3JBaZMZBNVRiRIvKO2an55/ruI+SwxSb1PXJ" +
    "wrLFxSVFCnz0sql+ylSOaqj0Ey4qX22ayx9rmpt+Ng3fNFA6TwDDJss+4IP6" +
    "9KkQHQfGoA9PbjLze/mjTfO+G2M3gWuRyUc1VGykqHDBWUxdVFq4oaxNxY1O" +
    "feLaB3xQnz4VOwWkD8agD09ukvj/6o9mRSb4SVMtMnFUQ0Xj3aiVRSn/AeU/" +
    "4XzBciFPADeUtam40alPXPuAD+rTp2Jng/fBGPThyU0YZ9b21R/HioycuXKN" +
    "VDSqoXIc7zkVWYTvP7L4z8eFOjXcUNam4kanPnHtAz6oT5+KdNw6YAz68OQm" +
    "jJPIpMj83c3+zd/6nEw/qqHiXwJJUTlldqZy7Q+b5us/HYknMqG95YNykqs/" +
    "BczBgjYO33hiGcpNOmJ+/GjTPM8pMvWTJRvVsN/xLoFGLyotXNwetLd8UE5y" +
    "9aeAOVjQxmHM4tLytzf3Xy7VSyWNativeN9QfvXsFPiy7+tFNxpc3B60t3xQ" +
    "TnL1p4A5WNDGYYriIm3Xzi5/3/5VvTZS6jexj6Ma9hveR8vy3+rUO4zFNjZc" +
    "3B60t3xQTnL1p4A5WNDGYari0nL6vfVSKYJq2E94L2j6yxsWX/W/8V/6uaEA" +
    "+vCI2FNnHTAnkqtvQR8etLegDaG+IOuj71Jpv7+4SjXsF/rOVl512eK1jH0L" +
    "K2dhWtCHR8SeOuuAOZFcfQv68KC9BW0I9VsufaRp3vBlvYZSuPb2C6phr9P3" +
    "SZD8F/rY0fjCii5MC/rwiNhTZx0wJ5Krb0EfHrS3oA2hPvnCPf2XSvvxPb+q" +
    "YS/TdxnUXgJxUUUWFvUj0IdHxJ4664A5kVx9C/rwoL0FbQj1u5B1xLXVst8u" +
    "k1TDXqXrMkjOVuSt9Id/0o18dT+FcsWPDSI6ffpTwJiE+gHcsYrEgI7rE4T0" +
    "B8ZQJL7OuX92FnNAr7UWrs29imrYa/RdBp180eJ1iWqhgOyFxw1kbSLKCfWn" +
    "gDEJ9QO4YxWJAR3XJwjpD4yhgL+rHmua1/fci9kPl0mqYS/Rdxn03hviCyl7" +
    "4XEDCRGdPv0pYExC/QDuWEViQMf1CUL6A2Mo2K+dvv3Xm/Taa9nrl0mqYa/Q" +
    "dxn06WN5Cyl74XGR7Sw0V6dPfwoYk1A/gDtWkRjQcX2CkP7AGAr2K+mb/C5T" +
    "381ert29gmrYC3DyWl5y4eJFQfLFtCV+BDy5w3U/1lBHwZhjwBhOnpQrfxae" +
    "jScfAbcfBtcByhlDyQn1YXPl7DLpT6/Sa7JlL77KQTVsMzJBnLSW91xvTL6x" +
    "CMyFQrkDF3towTPmGDCGkyflyp+FZ+PJR8Dth8Gqi0ur81ff0GtzrxYY1bCt" +
    "dBWWE85qmk/ebky8swh65Q5c7KEFz5hjwBhOnpQrfxaejScfAbcfBusqLsLZ" +
    "9zfNSQf0WhX20mscVMM20vWlw87LINKxCDrlDlzsoQXPmGPAGE6elCt/Fp6N" +
    "Jx8Btx8G6ywuglwmyfrkmt1LBUY1bBtdnwjJxF326OL1CEP5yo+AtA1ExciU" +
    "W9CGePqefK6TORa0HwPGIEqfOa8pb4u3XKvXrrAXPklSDdtEV2H5k6sWhWWs" +
    "RZK7MCOoGJlyC9oQT9+Tz3Uyx4L2Y8AYROkz5zXl3UVXgdn2d8Sohm2h66Nm" +
    "maixF0nuwoygYmTKLWhDPH1PPtfJHAvajwFjEKXPnNeUdx/vvl6v5W0vMKph" +
    "G4gWlrEWSe7CjKBiZMotaEM8fU8+18kcC9qPAWMQpc+c15S3x99/S6/pFu6B" +
    "bUA1bDpdheUj39ILZKxFkrswI6gYmXIL2hBP35PPdTLHgvZjwBhE6TPnNeUd" +
    "YS8VGNWwyXQVlg/f3DTXPL5Avtk8GPGTQjmJ6Ed0huhbNsTT9+QBnWt+sIzS" +
    "B9SP2DCmkhPqR2xyoX8rBuUdnH7P4hEKrvNtKzCqYVOxCotMwCduPV5YanFx" +
    "8PQ9eUAnt1BQP2LDmEpOqB+xyYX+rRiU97AXCoxq2ESsN/LLwMsEpIWlFhcH" +
    "T9+TB3RyCwX1IzaMqeSE+hGbXOjfikG5g7yr9/eMZ2G25Savatg0rI+b28Ii" +
    "E1CLS48N8fQ9eUAnt1BQP2LDmEpOqB+xyYX+rRiUe/xgUWCsM5htKDCqYZOw" +
    "CosgvyFz5eML5L0ZvYiOgzwtmeLKieFTQRuPAvt2THbHxsHtl4GKQR3GIEm8" +
    "aEwFYhAVw9AhyiYT1U8D2jCHLrm8QtMqMJv+oJ1q2BS6viuUFhZzwggn0EAt" +
    "LE9ODJ8K2ngU2KvF7OD2y0DFoA5jkCReNKYCMYiKYegQZZOJ6qcBbZhDn1wK" +
    "DPeCsMlfFVANm0BXYZHfZXYnjHACDdTC8uTE8KmgjUeBvRobB7dfBioGdRiD" +
    "JPGiMRWIQVQMQ4com0xUPw1owxw8ufx+NffEJhcY1bBuul5L+eZrFgPuThjh" +
    "BBqoheXJieFTQRuPAns1Ng5uvwxUDOowBkniRWMqEIOoGIYOUTaZqH4a0IY5" +
    "uPLHuwvMJr6uQTWsGw6a8KZZYbn80QVXZNLa9dlTZwpWEZMxiKfvyceAMUqg" +
    "zyseW4b6Y8CYntzSGYt3fE3vkU0sMKphnXCwhFdeujywnEAPTgzlls4UrCIm" +
    "YxBP35OPAWOUQJ/7rbgI8g+Xe0XgnlonqmFdWA/JvfhQ0xx6aHlQOYEenBTK" +
    "LZ0pWEVMxiCevicfA8YogT73Y3ERNr3AqIZ1YH3kbBUWgRPoEbGnzhSsIiZj" +
    "EE/fk48BY5RAn/u1uAiyT7h3NuUjatWwaqwbuPKZ/ufubppLv980X3oESNvU" +
    "MCah/ioI5CDjlRKx6YX2lg9Pvg4iOUV0Ng3mPOP8B5vmuQf0HtqE30VSDauG" +
    "gyLIb72MtkFKYExC/VUQyKEWlx0iOUV0Ng3mvJP3aXfrPSRwr60a1bBKrPss" +
    "f3bNyBukBMYk1F8FgRxqcdkhklNEZ9Ngzknep9yo99K6C4xqWBVd91kOPjjy" +
    "BimBMQn1V0Egh1pcdojkFNHZNJgz8n7dFXpPrfP+i2pYBdZ9lmee1TSfvbNp" +
    "Lnm4H/lt55RLHlnGk1soG0J9B+qbMSgn1AdK3wI+CH0S6ls2rhw5Uc5xMMeK" +
    "0IYxaU/9JJ9oXsonY0Z80oY+nZj0Tw480DTPOU/vrXXdf1ENq4CdF/7qJj34" +
    "Fhxwb0Iot1A2hPoO1DdjUE6oD5S+BXwQ+iTUt2xcOXKinONgjhWhDWPSnvpJ" +
    "PtG8lE/GjPikDX06MenfQv5Bc28J3IOrQDVMjXWf5Y1XLwaGg2/BAfcmhHIL" +
    "ZUOo70B9MwblhPpA6VvAB6FPQn3LxpUjJ8o5DuZYEdowJu2pn+QTzUv5ZMyI" +
    "T9rQpxOT/k1meu+9Qe+xdRQY1TAlbzMe+nnRocXpXGQySiaEcgtlQ6jvQH0z" +
    "BuWE+kDpW8AHoU9CfcvGlSMnyjkO5lgR2jAm7amf5BPNS/lkzIhP2tCnE5P+" +
    "TXZ0X3u53murvv+iGqaEnZX7LKfOTuMufHiHh3wuApSvg4seBtIGaOMx1L6y" +
    "/QxZA+d+177/Ivc7uS+nQjVMhXU59KFvNMcLSy0uyz4H2le2n6Fr4NQ79J4T" +
    "uDenQjVMgfV+ltfMTtuWCkstLss+B9pXtp8x1sDbrtN7T25PcI9OgWqYAnZO" +
    "LofkzVq1uHQz1L6y/Yy1BqzLI+7RKVANY2M9LCfVdN7xWlw6GWpf2X7GWgP/" +
    "YDxXtooXfKuGsWGnXnhB01zw4AL50lVK294HbTwueGAZyk0dwByy9Q3cHAyd" +
    "Pv05mTFc/RKcGK78wZHy8AjkkaPPnCN55+qrHCwY44EFrzb+yU99c1c1jIl1" +
    "E/fjR5OOAw6MBW08OPiUmzqAOWTrG7g5GDp9+nMyY7j6JTgxXPmDI+XhEcgj" +
    "R585R/LO1Vc5WDDGAws+f/fidgT3I/fsmKiGsbBu4r7+y+g44MBY0MaDg0+5" +
    "qQOYQ7a+gZuDodOnPyczhqtfghPDlT84Uh4egTxy9JlzJO9cfZWDBWM8cJy3" +
    "Xqv35JQv91YNY8FOSNU8+350HHBgLGjjwcGn3NQBzCFb38DNwdDp05+TGcPV" +
    "L8GJ4cofHCkPj0AeOfrMOZJ3rr7KwYIxHlhmlTd3VcMYWD+/+l8ON82B7xXw" +
    "wDIHv7eMp6/kBsonfRDDxxLUt/By8KA/wyc5+ACQth5ob/oAg3MybFReiOHJ" +
    "LWhDqM+cFNQ3YlDu+qDcQI0dgf7HbtF7c6qbu6phKNY3nuUm7nxwS8BgqQkj" +
    "zuBaKJ/0QQwfS1DfwsvBg/4Mn4QLkTEJ7U0foDSnrzzWNNf/cMHhHyxzPTgs" +
    "Ogme3EL0JCb7vNv3zH4ofelXrk9PblAy/n96ld6jU/xygGoYinUT91O37wxu" +
    "CRgsNWEkMLhE+aQPYvhYgvoWXg4e9Gf4JFyIjElob/oApTn9y781Kz8kJvu8" +
    "2/fMfih96VeuT09uUDL+Z9y7mpu7qmEI1lnLW76SDG4JGCw1YSQwuET5pA9i" +
    "+FiC+hZeDh70Z/gkXIiMSWhv+gClOdXiEpAblI7/uw7rvTr22YtqGALPWqQ6" +
    "fvGexZeoivkeoHwVTJHDFD49Roh5DqC8lJ+sobhITOYxKt54e/KJ+Z3zdIHh" +
    "nh6CahgCE/2Tq3SHslnzBMyZIocpfHqMELMWlwy88fbkE2O9d3fMsxfVUIr1" +
    "CZG8FYsdymbNEzBnihym8OkxQsxaXDLwxtuTr4Apz15UQylMcJSzFmEDJmCS" +
    "HKbw6TFCzFpcMvDG25OvgHd+TReXsb4WoBpKsM5a/scdTXPW/f3IQ3VL3GcQ" +
    "0Uk4Cyj7APTBvAntLeiTco9ITMagDeVq7Bx9i9wcumL+5Jfc+tMfEpP57ea5" +
    "CjAWnpw5Wnl640/+53ea5plnLu/dsZ57UQ0lsLD88ZW6ExYcGA5mZMAJB1fZ" +
    "B6AP5k1ob0GflHtEYjIGbShXY+foW+Tm0BWzFhdfzhytPL3xV9xn/+b0GGcv" +
    "qiGX0rMWgQPDwYwMOOHgKvsA9MG8Ce0t6JNyj0hMxqAN5WrsHH2L3By6Ytbi" +
    "4suZo5WnN/6K+6Y7e1ENubCwRM9aBA4MBzMy4ISDq+wD0AfzJrS3oE/KPSIx" +
    "GYM2lKuxc/QtcnPoilmLiy9njlae3vgrdvSmOHtRDTlYb/P/8Lea5sz7FsiT" +
    "gEtIWwrlFo5NG6srpiePxCBnAsqVPwvaEOoD5hDKg3Lg+rPIjSG5J7TtP/4l" +
    "t/70h8T08tqVA8pNMsemBOZFqK/Yye202dnLb4589qIacmBheelF/RNUNNiO" +
    "jbsoHHkkBnEnkP4saEOoD5hDKA/KgevPIjeG5J7QttfiUgbzItRXJPnJ77Rz" +
    "T3PP56Aaoljva0nPWqwJKhpsx8ZdFI48EoO4E0h/FrQh1AfMIZQH5cD1Z5Eb" +
    "Q3JPaNtrcSmDeRHqK5L8PmX8WsCQ972ohihM4mSctVgTVDTYjo0X05NHYhB3" +
    "AunPgjaE+oA5hPKgHLj+LHJjSO4JbXstLmUwL0J9BXL8oyt1geHej6IaojCB" +
    "d1+/+B5RDvILACmUWzqE+i73GlBnIMzRgjbroCSnEpsI6yguP/pldz/G6Cd9" +
    "eNC+hC/cC6QtgfrcCx87qotL6Y1d1RDBupH7ubuMxB3cjhs6hPouLCy1uGTl" +
    "VGIToRYXbV/C0OIiPPvc5b1d+jOwqiECC8sfXWEkHcDtuKFDqO9iDKbSGQhz" +
    "tKDNOijJqcQmQi0u2r6EMYrLWDd2VUMEBv7AESPpAG7HDR1CfRdjMJXOQJij" +
    "BW3WQUlOJTYRanHR9iWMUVw+eUwXl5JvS6sGDz6RK5+Nq4SDuB03dAj1XYzB" +
    "VDoDYY4WtFkHJTmV2ESoxUXblzBGcRHkAxoWGNYCD9XgwYBvvLpp/vk7C+Qx" +
    "4j5avS59yi1oQzx9yi0dl7v7+WcD+lBy+hCdBNqHGOiT+nObTJ9R+Y/+lVt/" +
    "+kNiMp8oXr8iOkPllg6hPunSt95Ux1rgoRr6sJ5t+W/f1ol10dWRLrkFbYin" +
    "T7ml42IUg6UNZ0AfSk4fopNA+xADfVJ/bpPpMyqvxSVfbukQ6pMu/VPv1Hs9" +
    "9wfsVUMffI3l755vJ9ZFV0e65Ba0IZ4+5ZaOi1EMljacAX0oOX2ITgLtQwz0" +
    "Sf25TabPqLwWl3y5pUOoT/r0X3uFLjCsCX2ohj4YSH7BrSsxi76OWHIL2hBP" +
    "n3JLx8UoBksbzoA+lJw+RCeB9iEG+qT+3CbTZ1Rei0u+3NIh1Cd9+u87sqLi" +
    "8n7jGuzjtzbNaXdncFcB9EE8fcotSmxyYQwPz55yg8+DEh+DCcb84RqKi8Rk" +
    "Hp14/aA8ojNUPgaMAfhlxpxnXlRDFywsr7jESNTDSN6FPoinT7lFiU0ujOHh" +
    "2VNuUItL/1GLS6NjAPl9d+591oYuVEMXDCDv3lSJehjJu9AH8fQptyixyYUx" +
    "PDx7yg1qcek/anFpdAzwkW9NXFysHzv7+FEjUQ8jeRf6IJ4+5RYlNrkwhodn" +
    "T7lBLS79Ry0ujY5hwEsjuUXCGmGhGiz4XaJnnbv42RDyGZArL+Ezdy2TKw8h" +
    "dimUA8YMxc2MEcEbb8qJysnIizaE+l388P9y609/SMzSfnhyC9qQXH3LhvPl" +
    "6Xty4fcvWd7/0ZdIqQYLnrXID1kzgUiinrwEbxN78hDOBiOMGYqbGSOCN96U" +
    "E5WTkRdtCPW7qMUlX9+y4Xx5+p5c+POv6CsX1ggL1WBBx++9QScQSdSTl+Bt" +
    "Yk8ewtlghDFDcTNjRPDGm3KicjLyog2hfhe1uOTrWzacL0/fkwt/d/NExcW6" +
    "3/LJ23UCkUQ9eQneJvbkIZwNRhgzFDczRgRvvCknKicjL9oQ6ndRi0u+vmXD" +
    "+fL0PXlLyX0X1UDkNXep0+cdXPx0yJxjy5zqsGuXA2K40D7AqYByxnD1IzBv" +
    "Qn1C/YBNbt7Ut2w8eZQfrKG4SMzOfmSObQj4VPvDg/4M2A9CfUL9dixejToQ" +
    "ue+iGgjPWuRnWneTObYMB4uwIyEQw4X2AdRgEsRw9SMwb0J9Qv2ATW7e1Lds" +
    "PHmUWly0XEF/BuwHoT6hfjsWf3GdvoI5ZtSLFNVA6FBeZ7mbzLFlOFiEHQmB" +
    "GC60D6AGkyCGqx+BeRPqE+o7Nl96qGnufbKZf9Ugmjf7adl48ii1uGi5gv4M" +
    "2A9CfUL9dizkC8qsBd7rL1VDinW/5RO3JclIhxM4WIQdCYEYLrQPoAaTIIar" +
    "H4F5E+oT6js2Ulzk+NmvmubQ92J5s5+WjSePUouLlivoz4D9INQn1E/H4ln4" +
    "4rL3LWnVkML7LScdXLylapfbl/lULscC0AaoHBz7pfx3oA59uPoBVJ4OKiYx" +
    "bJROwqUPHt9U//H/mubw49pe5Wj4cWFOwRiPr6G4SMyu8VXjb/RlCcuH0d+s" +
    "NRCAMZUPrx+07+FVqAfCMaNutKiGFDqSnx1YSpYdzeVYANoAlYNjz8GODLir" +
    "H0Dl6aBiEsNG6SSkxaU9vvPzpjntzuP2KkfDjwtzAl0xanHRUN+CMZUPrx+0" +
    "7+FtmfddVEMKHZ1yBMmyo7kcC0AboHJw7DnYkQF39QOoPB1UTGLYKJ0Eq7jI" +
    "8cS/Nc3B+xf2KkfDjwtzAl0xanHRUN+CMZUPrx+07+EjmfddVEOLdb+FiaqO" +
    "5nIsAG2AysGxV30wdOjD1Q+g8nRQMYlho3QSuoqLHPPLpMeMHA0/LswJdMWo" +
    "xUVDfQvGVD68ftDegc+7jFJcnjFz+k+3LfOPIFt++zKUWz5cHJ9KX9pFLwU2" +
    "hPaE+nObzLwoj0AfKRc9wK2lj7t/1jSfuUPb9uHlEJU//n+YzfSHxGQ+zMvL" +
    "exeuIQvaODEI9UtsPLnKGbwIL+jvu6mrGlr4ZUVxykS8RF357ctQbvlwcXwq" +
    "fWnnIMKG0J5Qf26TmRflEegjJVJc5Pjp7DLpvPu0fRdeDlF5LS46BqF+iY0n" +
    "VzkD/txr38N0qqGF78uVHz5jIl6irvz2ZSi3fLg4PpW+tHMQYUNoT6g/t8nM" +
    "i/II9JESLS5yyGXSVx/TPiy8HKLyWlx0DEL9EhtPrnIGLC4Ca4dbXOigFpd+" +
    "H0v+DHLzojwCfaTkFJf2iFwmeTlE5bW46BiE+iU2nlzlDE65cYLicsoNOhEv" +
    "UVd++zKUWz5cHJ9KX9o5iLAhtCfUn9tk5kV5BPpIKSkucniXSV4OUXktLjoG" +
    "oX6JjSdXOYMPZ7yZTjV0FZcPfL1p/uHWTI4CysdgghifOLoM5RsB++1w4Xe5" +
    "teKHXCZd96iRw4xPAMalfhePraG4SMzdHArz7oU+CfVLGOoT9pzP+ZwC1oau" +
    "T4xUg8BPigQGCDG04xEmiFGLi33c9bPFY+BpHmohMjbz7qAWl0KG+oQ959Mq" +
    "LicdWK4NXa9fUA0Cf0ZEnDFAiKEdjzBBjFpcug+5TDrn3uN5qIXI2My7g1pc" +
    "ChnqE/acT6u4vPSi5fogXxNiDeksLvwY+oUX6AAhhnY8wgQxanHpP9LLJLUQ" +
    "GZt5d1CLSyFDfcKe82kVl9ddrq9sWEM6iwsNXztz9t9vCXAUUE6g/7FbNMom" +
    "E/ozkdgJzMtD2Rt5KBvk4MoJ9D0OjVhc2uPOJ5rm07cjFvJ0+7HDuooL8+gc" +
    "X8oB14C1jrLlRhyF4WdI3sre8PHm4Dt1VYNVXMQZA5g4SSmgz4XYtxij0J9J" +
    "MridA9yDsjfyUDbIwZUT6HtMUVzkkMuks+9NYiFPtx871OJiyI04CsPPkLyV" +
    "veFD3unEGsEaEi4u4owBTJykFNDnQuxbjFHozyQZ3M4B7kHZG3koG+Tgygn0" +
    "PaYqLnLIZdK1j+7EQp5uP3aoxcWQG3EUhp8heSt7y8dRXVysT4xUYbGKi/zq" +
    "mgpg4SVFoM+F2LcYo9Cfyc7AWgMsp/2yMfu4ABy634A29y/jygn0PY78gFtr" +
    "/EM+Tfr0bf3jz/lpqcXFkBtxFIafIXkre8vH0RGLy0e/vXjNXS5il0I5of7c" +
    "5hYHw8+YyOsI6hE//uWXTXPGPU3n/Hz0lmXa9kf/Nz1Nf0hM5rebJ6A8whg+" +
    "hjJVDqwRoeJiPeNSmlRux6g/t2ExIYafManFJf/499ll0jXfb8z5qcVltUyV" +
    "wwvOr8VlMLW4lB93PNE0/3Tr8njW4rJapsqBxcV6kK4WF4daXIYd88uk7xwf" +
    "z1pcVstUObC4WO91cYvLc85b3ND9yM0G0p4gX2pKof6HCfUD0IeSA+ZAfY8D" +
    "93FJ1iP3kMukqx825iKZj++vobhITM73KlFrdYsYpbiIk7lDLgpjo6rBgj4L" +
    "g9IPQB9KDpgD9T1qcRnvuOOnTfOJW+z5qMVFyzeZouLCR/9rceGSrMeQQy6T" +
    "Tr9Lz0ctLlq+yfBnRmpxMfQ9anEZ/1i6TNoZ51pctHyTYXGxXnfpFpffPb9p" +
    "/m62CP72m/mIXQ60nyPtKYwBcuVznZ48zr2XS7IeYx3HZpdJH79lMebrKi5c" +
    "H7vrxFl3rtzQ6Vtn83UIaG9BG8YgKiZ16A/6LX/4peU6IbCWuMXlDy+zk4qg" +
    "Eneg/RxpT2EMkCuf6/TkUYvLtMdPZpdJX7irFpf5OgS0t6ANYxAVkzr0B/2W" +
    "ouJy8qFaXFJZLS7TH3KZ9PNfsXX6oxYXLVf+oN9SVFxoUIsLl2Q99spRi4uW" +
    "K3/Qb/mLwE+7usXlD2YV6q9vmvFNA2nP4G8A5RGG+vibbxr0+Dz7Hi7JeuyV" +
    "45FZcQmvZa59Qv0AXIdKDiiP6izh5U15h07kd6NrcRF6fNbisnePWlwC8g6d" +
    "ouIi78OsxeU4tbhMf/ziP5rmR//K1umPWlwC8g4dqQvZxYWfFr3s4oygDtkD" +
    "YTDUBye0Fpf1Hvc+ufiOkWz0VR+1uATkHTqjFJfnH8wI6pA9EAZDfXBCa3FZ" +
    "3/G1R5vdtVSLiyEHlEd1lvDyprxDZ7Ti8lffaJoPGUj7El9fxtP35BYfEr8p" +
    "hp9en8jRyjPlzO9wSdZj6PGLf2+az92xPD8P/y9qTX9IzM41gHXmrSNlb0Af" +
    "nrwIJy+lH4A+hFdeulwn5BEW1pJaXBwftbiMe9zz88Xj45yfWly0vAgnL6Uf" +
    "gD4EFpfQd4v4rehaXLgk61F6XPd9Pb7tvNTiouVFOHkp/QD0ITzv4AjF5cSz" +
    "uwMwidyOeXILTjp9ENozRyvPlFpchh9yGXTaHTvz1zE/tbhoeRFOXko/AH0I" +
    "oxQX4QNHmuaDX9dI+xLSlkI5ob4FbHJz+KDYJFA+1yGJ/hl3N/UYcMhlkHx7" +
    "nWPO+Xn4F7Sc/pDispvLkX7UOpoArkOOVQTmqUj8c6139otxjtTiMkcNHv3D" +
    "Hwe8Fpfy49pH9FiTdpxrcdHrkGMVgXkqEv9c6539Ypwjurh89KZaXJR8rkMS" +
    "/Vpc8g+5DPrs7fZ8kHaca3HR65BjFYF5KhL/XOud/WKcWduzz12uEaG3/wu1" +
    "uBynFpe8456fzS6Dvtk9H6Qd51pc9DrkWEVgnorEP9d6Z78Y54g+ASkuLu/8" +
    "WtO870aDI4Byh1OOLEP5FJxiQB0P2qt+lGDE6YX2jo8v3tVMflzziI6rOLJM" +
    "O4YPraG4SMyuvFTeHrQ3fKh1Qh8e9C9+xG+CspkI1oji4vKma7TzOews5Q6D" +
    "B7sATkbJhNBe9aMEI04vtHd8TFlcnppdBp16u45pcmSZWlwyoH/xI34TlM0E" +
    "vGfMH6KXF8MwwBx2lnKHwYNdACejZEJor/pRghGnF9o7PqYqLt+ZXQb97U06" +
    "XidHlqnFJQP6Fz/iN0HZTICcbLBGsIaEi8vvX6IDzGFnKXcYPNgFcDJKJoT2" +
    "qh8lGHF6ob3jY4riEroMIkeWqcUlA/oXP+I3QdlMQOQtdJ3FhV8BOOlA07z3" +
    "Bs1fZkJ7Qv25zfXLUE7oMwJ9kOwcoG/aSFsKfQBPbpHqf+HOZrRDLoM+fdtO" +
    "HuxrTw59eT+4huIiMZlfV56UE+pbNhwryhXOGpn7dPD0lZzzaczpyy8eUFzk" +
    "M+vU8ISzdAArMQ/aE+rPbTInhD4j0AfJzoGTY9lIWwp9AE9ukeqPVVzunl0G" +
    "/fU3kjzY154c+vKuxcXAWSNznw6evpJzPo05lZONtD5YD9B1FhfrWRcGsBLz" +
    "oD2h/twmc0LoMwJ9kOwcODmWjbSl0Afw5Bap/hjFRX5rSOXBvvbk0Jd3LS4G" +
    "zhqZ+3Tw9JWc82nM6bPwjIv1I/SdxUVgcfnzr+ggTMyD9oT6c5vMCaHPCPRB" +
    "snPg5Fg20pZCH8CTW6T6Q4pLexlEn/M82NeeHPryrsXFwFkjc58Onr6Scz6N" +
    "OWVtsD6Gziouf3Rl07z7eofDgHKSq2/h+fDkFo6NfBSXovQNaPMeaUtgDBcj" +
    "Rp/O5+/g1ooddz3RzL+4Z/k0Y2bS9v/Bpxh5+kNiqv509QvyyPxxzimnT1du" +
    "wZhJTl159cGcub6jnxRlFZeXXqwTUTgdV+TqW3g+PLmFY9M3+F3QZugioH8r" +
    "z1RWUly+/HC/TzNmJrW4JHhyC8ZMcurKqw/mzPX9+qtGKC78cbQXH9KJKJyO" +
    "K3L1LTwfntzCsekb/C5oM3QR0L+VZyrLKS5P/appPnnU8GfFpTyTWlwSPLkF" +
    "YyY5deXVB3Pm+n7pRSMUF34c/dwDOhGF03FFrr6F58OTWzg2fYPfBW2GLgL6" +
    "t/JMZdHiMr8MOtLhz4pLeSa1uCR4cgvGTHLqyqsP5sz1LScZaV2wXm/pFhfr" +
    "E6N3fS2Pdx5ehnIi32Ei7xK7FMeGckJ908aJ6cnZ7zmMSR+EMQdy2jFuLX1c" +
    "9ZC2I24/PP0OHlhDcZGYzKMT9FP1i+NgjMUq8PIqWZep/DnnLdeEro+he4uL" +
    "wOIiP+HIzvTBjlBO2FGzs44N5YT6po0T05Oz39FJ7PM5lL7i8uTsMugfb9E2" +
    "Fm4/PP0OanEZBy+vknWZyp92xnJN6PqkKLu4vPZy3Zk+2BHKCTtqdtaxoZxQ" +
    "37RxYnpy9js6iX0+h9JVXO6cXQa9/8aOcTBw++Hpd1CLyzh4eZWsy1Ymj6Ow" +
    "JrBmpKiGFDo6+SLdmT7YEcoJO2p21rGhnFDftHFienL2OzqJfT6HYhWXKx9y" +
    "xsHA7Yen30EtLuPg5VWyLluZfMeQNYE1I0U1pPCnXX/7HN2ZPtgRygk7anbW" +
    "saGcUN+0cWJ6cvY7Ool9PoeSFpf5ZdBRI6cAysbJW+l3UIvLOHh5lazLVia/" +
    "BJLWg2efM6C4WDd133pt07z9qzbvcMjVt2zefh2AnPYR6IN4+p68BPqMQB8p" +
    "8tpJOe78adO87wZfv4t3XAekLSF3ftr2762huEjMrn55/SDslwVtcqG/KXxS" +
    "nurwfkvXY/+h4iKwuMjPODI4k+giV9+y8Sad9hHog3j6nrwE+oxAHyn/cMvs" +
    "MujBuH4X3IQqh8z5adtrcfGhvyl8Ut7qvOHL+kSDtYKoBkKHL7xAB+9KlOTq" +
    "WzbepNM+An0QT9+Tl0CfEeiD5OpbcBMqn5nz07bX4uJDf1P4pLzVeXnm/RZB" +
    "NRA+TPfMs3TwrkRJrr5l40067SPQB/H0PXkJ9BmBPkiuvgU3ofKZOT9tey0u" +
    "PvQ3hU/KW53c+y2CaiDWfZc3zk6R3nZtgOsccvVnvBVQ7sKYVtyh8gj0Qahf" +
    "An3mQn+WT8oJ9cmO3lqKy5NGPl14/aI8qtMH7Uugz0Jy77cIqsGCxeUVs1Mk" +
    "1QkLI8klcvWvq8UlC/rMhf4sn5QT6pMdvVpcDGhfAn0W8CcZX1ZMUQ0WdPyC" +
    "8xvdCQsj0SVy9a+rxSUL+syF/iyflBPqkx29WlwMaF8CfRbwsuBrLYlqsFD3" +
    "Xc5sdCcsjESXyNW/rhaXLOgzF/qzfFJOqE929GpxMaB9CfRZwO/g+0R9X1ZM" +
    "UQ1dsHK9/stN85av9COPC6dQTqhvcu0yb/Ew4hAVw4M5wJ/KQfToA9AH5YT6" +
    "FrQh1FcY/aCO65P2ZEfvu09y609/SMzO+ZG2BPaL+pSbfacc0CehvmVDOXPw" +
    "+kV9gXvf+l1oC9XQBQPIVwFUYsDtuKNvwsHxMOIQFcODOcCfykH06APQB+WE" +
    "+ha0IdRXGP2gjuuT9mRHrxYX7ZNQ37KhnDl4/aJ+9GdELFRDF/LRUxrgt842" +
    "EgNuxx19Ew6OhxGHqBgezAH+VA6iRx+APign1LegDaG+wugHdVyftCc7erW4" +
    "aJ+E+pYN5czB6xf15f7q5MWFPzcieJdGbscdfRMOjocRh6gYHswB/lQOokcf" +
    "gD4oJ9S3oA2hvsLoB3Vcn7QnO3q1uGifhPqWDeXMwetXqivvy33a6ct7Xr5v" +
    "yNrQhWrog8XlRYcWCZTyZkD5nKsB5Q6RGNQhQ3OwyI1BfYtcG+qXMJbP+9dQ" +
    "XCQm8xiToWMz1N4E6+zNINUt/ZSoRTX0wffq/uaZRvIZhAbP2XQekRjUIUNz" +
    "sMiNQX2LXBvqlzCWz1pcNEPtTbDO+oqLvNp2ZcXFelr3VZcZHQgSGjxn03lE" +
    "YlCHDM3BIjcG9S1ybahfwlg+a3HRDLU3wTrrKi7Wg3ORp3JTVIMHAz7/fKMD" +
    "QUKD52w6j0gM6pChOVjkxqC+Ra4N9UsYy2ctLpqh9iZYZ13F5SUX6uLCWuCh" +
    "Gjz4Aim54fPGqwv5MqB8VTAPQv0xYAwH+cp7CuVzGAO8ASh7YvlIcjDzMGyW" +
    "6NBfS3H5uZHPDqqfXj8MXB9TwDwoD3Li2cv7PPJFRaIaIrCiyQ+mMbkQIw3E" +
    "YJgHof4YMIaDWqgWjAFqcVk+anGxec3l+qwl+uBcimqIwMDycwNMMMQIAzEK" +
    "zINQfwwYw0EtVAvGALW4LB+1uNjIO5u4x1kDIqiGCHJjh8Hlt6SZpMsIAzEK" +
    "zINQfwwYw0EtVAvGALW4LB+1uNjIp8Dp3o5+l4iohigsLvJLbPJQXcqfkquW" +
    "kd+dXQL2Fp4PT25BG4XTD8KcrbzJ4JwkTqYP6pfg+YzK7/s5t/70h8RkHl2o" +
    "vDn+hg1RPhx5BOah5MCTW2+c6/ttoj5UQxR+HUCqndpQxOko7S08H57cgjYK" +
    "px+EOVt5k8E5SZxMH9QvwfMZldfiouURmIeSA0/+PLxxTuDej6IaolhfB5Cq" +
    "t7ShiNNRbkgLz4cnt6CNwukHYc5W3mRwThIn0wf1S/B8RuW1uGh5BOah5KBP" +
    "bt3I7fu5Vg/VkAMTedbsbGZpQxGno9yQFp4PT25BG4XTD8KcrbzJ4JwkTqYP" +
    "6pfg+YzKa3HR8gjMQ8lBn/ykgU/kEtWQA18iJbzyS00tLoG8yeCcJE6mD+qX" +
    "4PmMymtx0fIIzEPJQZfcOmspvZHbohpyYULyq4x/fGVl33IFoLyDdRUX5rFf" +
    "GfusRVANuVhnL/Kbsky+sk+oxWXreDWeuh/jrEVQDSUwsXr2so+pxWXr+N0B" +
    "L4TqQzWUUM9eKrvU4rJVvG42R7+BF0KVfI/IQjWUwuLy3PMWiWdxuea1VyxD" +
    "GyWnD8PGxfPBHMkVGs8Hce0NaJML/VlE+toL7Fu/9/6MW3/6Q2Jy3HfZyWsX" +
    "R85+hXDGRkF9Iy9Pzryt51pKH5ojqqEUvkhKkJf7sjO9cCCswQJKTh+GjYvn" +
    "gzmSKzSeD+LaG9AmF/qziPS1F9i3fmtxMeSE+kZenjzNWT4hmuqsRVANQ2Bx" +
    "kTdZcRJ64UBYgwWUnD4MGxfPB3MkV2g8H8S1N6BNLvRnEelrL7Bv/dbiYsgJ" +
    "9Y28PHmaM3//ecyzFkE1DGHw2QsHwhosoOT0Ydi4eD6YI7lC4/kgrr0BbXKh" +
    "P4tIX3uBfeu3FhdDTqhv5OXJ23ynPmsRVMNQWFzkqd3XXGYjH4GlUG7pvPpy" +
    "4PigPuUW9JkNczTydOUjwH4R6odw8mYMj9bunjUUF4nZ1a+uPHPI9uGMrUV2" +
    "jB2s51rGPGsRVMNQrLOX3zukB8EaCMotHW8ClL2zaCzoMxvmaOTpykeA/SLU" +
    "D+HkzRgerV0tLo3KQckNsmPMeMWleo8K3MtDUQ1jwKSfcUbTvOpL/kBQbul4" +
    "E6DsnUVjQZ/ZMEcjT1c+AuwXoX4IJ2/G8GjtPnRj03z0mzYfA0p+8zKUdyEx" +
    "u/rVlWcO2T6csbXIjnHZ4gcNuUfHPmsRVMMYWM+9PO+APxCUWzreBCh7Z9FY" +
    "0Gc2zNHI05WPAPtFqB/CyZsxPGhv4dnI/YMUykOgX17MCNk+nLG1yI0hVxHc" +
    "m2M8jWuhGsaCHRDkwTq5wbvnuBRQbpFp8weA8jGYIkaJzxKbXFYRIxusCeb4" +
    "B9IGlI8eXnmpvokrHDP27xiohrGwfuNI3ijODu8JLgWUW2TacKFRPgZTxCjx" +
    "WWKTyypiZIM1wRxZWHKLi/UjZ0Pe1+KhGsbEurkrPwHLTm89lwLKLTJtuNAo" +
    "H4MpYpT4LLHJZRUxssGaYI4sLDnF5aUX6b0oHDP27ViohrFhZ55+xuL0jJ3f" +
    "aqQ/KZRbZNpwoVE+BlPEKPFZYpPLKmJkgzXBHFlYcooLf4dImOImbopqGBvr" +
    "5q78FIl8HCZFZolLNK8glzo4+iom7QNy4uYs7bk+Hahv2jAv2jg50r6rb70+" +
    "RkDlnYuRp9Jx4DioHOm/JEYBbsxL7Cdxp7qJm6IapoAdE15ykR4oNYEcOGvw" +
    "iKOvYtI+ICduztKe69OB+qYN86KNkyPtu/rW62MEVN65GHkqHQeOg8qR/kti" +
    "FODFfPnFq72Jm6IapsC6uXvC2Xqg1ARy4IzBUzj6KibtA3Li5iztuT4dqG/a" +
    "MC/aODnSvqtvvT5GQOWdi5Gn0nHgOKgc6b8kRgFeTLlK4N7L/UH5UlTDVFg3" +
    "d6XjS4PFCeTAGYOncPQ5OfMJcnQoJ27O0p7r04H6pg3zoo2TI+27+tbrYwRU" +
    "3rkYeSodB46DypH+S2IU0BfzBcYvJ479/aE+VMOUsKOC/HSknLp1cgnIlY/B" +
    "CDHkGZ8U16cnL2ENPn8fePohG6D0A7g2jEN5gMExKA/Qxjr5QvtyaOqbuCmq" +
    "YUqs3zqSAZCPydTAdg1wrnwMRohRi8vOBnP0QzZA6QdwbRiH8gCDY1AeoI3F" +
    "n2QVXnfZ6gqLoBqmRjrITp9wFga1b4Bz5WMwQoxaXHY2mKMfsgFKP4BrwziU" +
    "Bxgcg/IAEud3ztV7bJWXQy2qYRXwp2AFGRA1uNYA58rHYIQYtbjsbDBHP2QD" +
    "lH4A14ZxKA8wOAblAV5gvGxb4B5cBaphVbDzgnn/hQOYKx+DEWLU4rKzwRz9" +
    "kA1Q+gFcG8ahPMDgGJQ7yOMd677PkqIaVoV8HMZB+PXTFzei5B5MFNFPobwI" +
    "8ZNCeQEnA8qngDEJ9Qn1LWgzBVPEzPVJfUJ9C9cG6y53bT9jA+6zpKiGVWJ9" +
    "PP3Ms/Sg9ZE7ASFqcQnZR3yMwRQxc31Sn1DfwrUZUFyevSH3WVJUw6rhgMwH" +
    "5Vw9eF3kTECYWlxC9hEfYzBFzFyf1CfUt3BtCouL9Xi/wL22alTDOuCgCHJj" +
    "ioNoEZ2ALGpxCdlHfIzBFDFzfVKfUN/CtSkoLvLyJ7mdwP3z2VtrcZlj3n/5" +
    "4uJnJmXwerlwmZeQQ8tQfw59Ek+f8gChvDL1qUOor/pBqB+A458rL4J5R4CP" +
    "3LFS+gbZfaUPyK2Y8gpZ7p113mdJUQ3rwrr/IgXmxRxwwgkgnBBOqECfxNOn" +
    "PEAor0x96hDqq34Q6gfg+OfKi2DeEeAjd6yUvkF2X+kDcsazCsu677OkqIZ1" +
    "Yj3/IgPYW2A4ASSZEHPRCPRJPH3KA4TyytSnDqG+6gehfgCOf668COYdAT5y" +
    "x0rpG2T3lT4gT+PJg6fcKwL31DpRDeuGg+UWGE4ASSbEXDQCfRJPn/IAobwy" +
    "9alDqK/6QagfgOOfKy+CeUeAj9yxUvoG2X2lD8jbWNbb+zetsAiqYRPgoAny" +
    "EfWLLjA4BHLlM154aBnKPeThvxTK5yAPxlQ+mDeh/wIbNyb9j4CKWYKXpyff" +
    "Yqw3ygnyvT3uo3WjGjYFDp4gA8vBdheSJ79Ab3TKPUIbBnkwpvLBvAn9F9i4" +
    "Mel/BFTMErw8PfmWYn1naFMLi6AaNgXrG9RmgfEWkie/QG90yj1CGwZ5MKby" +
    "wbwJ/RfYuDHpfwRUzBK8PD35FtJVWFb14qcSVMMm0VVgZKB3B95bSJ78Ar3R" +
    "KfcIbRjkwZjKB/Mm9F9g48ak/xFQMUvw8vTkW4b1NjlhUz5y7kI1bBrWC76F" +
    "Z527eA5GHrZLkbYUJT9oYNj1oXw6cgvaKJwc6S/kE9A+AvNScpArj0AfhPom" +
    "knsCfRBlD6g/FvJbQ/JIBtf/phcWQTVsItY7YNoC402yknPTBhYWUT4duQVt" +
    "FE6O9BfyCWgfgXkpOciVR6APQn2TpLBsanHpKiyb9CxLH6phU+kqMPI9pL5J" +
    "VouAmzawsIjy6cgtaKNwcqS/kE9A+wjMS8lBrjwCfRDqmySFZROLi/zj3ObC" +
    "IqiGTcZ6yE6QB4q6JlktAm7awMIiyqcjt6CNwsmR/kI+Ae0jMC8lB7nyCPRB" +
    "qG+SFJZNKy5SWLjGt62wCKph0+kqMM88s2med8DgIKDc0iFD9SM2udB/SYyh" +
    "9pYPkqtv2UyAfJM4hXLmRH2i7A0fCuof7H5AbtsKi6AatoGuSyR5KfFJ3gRS" +
    "bumQofoRm1zovyTGUHvLB8nVt2wmwC0OyIn6RNkbPhTQlwdFuaa3tbAIqmFb" +
    "6CowTzsdBSYy4dQhQ/UjNrnQf0mMofaWD5Krb9lMgFsckBP1ibI3fCgS3a7C" +
    "soqfXZ0K1bBNdH1MvVRgIhNOHTJUP2KTC/2XxBhqb/kgufqWzQS4xQE5UZ8o" +
    "e8OHYqZz0kH7283CNnzc3Idq2Da6HrSTO+3ySdJzz1tGHkgi1FEcAJA/5wCA" +
    "/0iMXH2Vk5GXgvpA5WDoKJwYyieg3NIhnv4Y80GUvTcOlo0hl3+EXLt7obAI" +
    "qmEb6SswzzpHTyjhpCuchTTGYs7VVzkZeSmoD1QOho7CiaF8AsotHeLpjzEf" +
    "RNl742DZJMg/vq7CsqnfFcpFNWwznKQWuZ7tmnBOuomzkMZYzLn6KicjLwX1" +
    "gcrB0FE4MZRPQLmlQzz9MeaDKHtvHCybHeQTIesZlr1UWATVsO1wslqefoae" +
    "bE56J85CGmMx5+qrnIy8FNQHKgdDR+HEUD4B5ZYO8fTHmA+i7L1xMGwE62dW" +
    "Wzbhvbdjohr2Al3Pwsh/i98+R084F4XCWUhjLOZcfZWTkZeC+kDlYOgonBjK" +
    "J6Dc0iGe/hjzQZS9Nw7Qlwfjui6DBK7hvYBq2CtY7+Rtkf8ecs3bIt+yTkll" +
    "Frn6c5tzlqGclMTwoE8S0afOFHgxKS+BPj08e8pTHXmC/D93XAZt6zMsEVTD" +
    "XsL6VYGWp53RvTC4cEiu/tymFpcwXkzKS6BPD8+e8lbH+hXElr3wiVAfqmEv" +
    "wkltkf8mcnPNWhR95OrPbWpxCePFpLwE+vTw7CmXy2/rd5tb9tr9FQvVsFfx" +
    "LpP6Fg7hQqLcohaXOF5MykugTw/PPpXt18sgohr2Mr2XSacvXqEp/3E2Eskt" +
    "hXILz4ZyQn3LhnKPofYWJT49G8qJoS9nwX03bff6ZRBRDfuBrk+TBLlGVgtn" +
    "E/AWt4VnQzmhvmVDucdQe4sSn54N5QT68gh/19mKsB8ug4hq2C90ffFRkI+s" +
    "5cE7LqC14ixuE8+GckJ9y4Zyj6H2FiU+PRvKyY7eCWf331vZT5dBRDXsJ7q+" +
    "NtAip7i/xUW3LjoWdy+eDeWE+pYN5R5D7S1KfHo2lJNzFg9mcs2kyBdrueb2" +
    "E6phP9J3s1eQRSQ36VpOJGf7pPYR3BiUG9AnoT45QfIGJzoofcOvC32e1U+u" +
    "/tyGeD52+iM8/cz+S6D9fLaSohr2K3JNzEWSIpdKcj8msjAt1GJ1cGNQbkCf" +
    "hPpENhI50UHpG35d6POsfnL15zbE83H24lL513sugYS99N2goaiG/U7XO2Ja" +
    "5PpaLU4sTAu1WB28xa/kBvRJqE9kQ5ETHZS+4deFPs/qJ1d/bkMcH94l0H77" +
    "JCiCaqgs8C6V5H7M7iLFwrTgYvXwFr+SG9AnoT45QfIGJzoofcOvC32e1U+u" +
    "/tyGGD7kTEXmuV4ClaEaKsfxLpUEOZORjyHlQbxd5G+Symc884xlKCfyAvKh" +
    "0KcH7S0fnnxb6fsEqKVeAvWjGioa71JJkGvx3SLDwmIUj1pcNpNIUdnm99qu" +
    "EtVQ6ca7VFoqMgSLuBaXzUHmK1JU5BJoPz4MV4pqqPiEiszsOv3pswVbi8vm" +
    "IkXF+/SnFpVyVEMlTqTIyM1A+a8onzbkIK+E6EMKl4vhdzBODJUncexHgTGA" +
    "zEfXayZT6uXPMFRDJZ/IPRlBFnS00HCTEm4YE8PvYJwYKk/i2I8CY8yQT30i" +
    "BUWoRWUcVEOlnGiRkbMZOR03N98O3KSEm8fE8DsYJ4bKkzj2o7DjWwrKb3yx" +
    "/6PklFpUxkU1VIYTLTJC12UTNylRm9SCm24MnBgqT+LYj4GMZ7SgCPv9O0BT" +
    "oRoq4yHPQfS93oHMz2ik2Oyc2SyxI2uRDUSUDlBy+qA+czCgDX0ypsLySZgX" +
    "2bHLKShCfU5lWlRDZRref1gv7j5ko7SXT3OwodQGtHSAktMH9dvYPdCGPhlT" +
    "YfkkzGuHdow4dn3Us5TVoRoq09P3LpkudovNDmoDGhu5a1N2+qB+suG7oA19" +
    "MqbC8kkS/dxiItR7KetBNVRWhzw7Efk422K30PRsZG58JTc28SYVF5GXFBNB" +
    "LkfrZc96UQ2V9ZB7f8aiPbtJ791sQ3FJ8y4tJi3vP1wLyqagGiqbQc4nTvsZ" +
    "Gaf69Oxmohoqm4dsnlpsFsj9qlpMtgPVUNl8ZHOV3BTeRmox2V5UQ2U7ac9u" +
    "Sm8Qrxu539Re4tRisjdQDZW9hWxUuVm8KZdVkofcdK0FZO+jGir7i/ZMIUUK" +
    "QAovweTsiDr0UYtHRTVUKpXKGKiGSqVSGQPVUKlUKmOgGiqVSmUM/j+2mbTD" +
    "/jnvbwAAAABJRU5ErkJggg==")

STEP_IN_PRESSED = ("data:image/png;base64," +
    "iVBORw0KGgoAAAANSUhEUgAAARcAAAEXCAYAAACH0wDUAAA7DklEQVR4Xu2d" +
    "2fdkV3Xf+QOStfIU5yXOS4ydwSZxEmyD45C3JCbJW0Y7eckKo0AghAbEJGY0" +
    "MM9ISAoIYQExIDFjg43Bjhu1pG611JNmaA2NZsTMTe2q3+0+97P3vXufU/fW" +
    "8PudtfRZ2Gd/93DOPWd33Vv1q3rKvqZ5SqVSqYyNGqhUKpUxUAOVSqUyBmqg" +
    "UqlUxkANVCrCKw40zf/e5/OSG5uGvpWKoAYquxM2hXXyhltrQ9oLqIHK9hJ9" +
    "tbGp1FdBuws1UNkO5CDycO5W9hnzr2w+aqCymUzVTF5/qGkuPdLlk/cu+FTC" +
    "LY8uOPjoaXtK6/u2BOYag/rqZntQA5XNYKxbnLZ5SAP4/IlFc3jsp03zs18Y" +
    "NF1+/guN8gHU/1zizLjlsab5xoOLRvWB44vnLqy1hNpsNhc1UFkPyxy2M29c" +
    "NJCr7lw0EWkgtz/RND/9Bfh5l594/MKAGkK9w4kfNc2B5NWQzEPmwzlGkaa8" +
    "z1jfyupRA5XVwsMRQQ7f+483zfWzVyInfnj6YKtmQkSToBoDMZqB0hDqS/j5" +
    "Yl5/+sCiYZ5f+Cpun7HeldWhBirTk/v8JG0mx59YHD4L1UyIaBLor+Ch3zn4" +
    "g1BfghFTXuG0zabklc0+4zpUpkUNVKYh9xmK3B7IM5L29kYdOAPVTIhoEuiv" +
    "4KGP1EF9CV7Mny+arDRbabo5zabeNq0ONVAZF27uPuSAXDn7V/kvTzbNj342" +
    "4+ddfghoL+GHP+syz5ti+CjgwzqJ8h+Jo7Nmc+09eY2mfphvWtRAZXlyXqW8" +
    "71jT/Mn9TfPwj5vBgz3FId1NzSVFGrQ0aq51H/Udp2lQA5Vyok1F3h6+7ntN" +
    "890nG3U4+w72FId0tzaXthZp2NK4Lzmsr4FFbTLjogYq+UQe0Mo7HvKy/ejj" +
    "pzf/IDgwUxzS3d5cUqSRy/pH3nmqTWYc1EAlTqSpXDF7ef7t7+vN7oIDM8Uh" +
    "3UvNJUUafPS2aZ9x3Ssx1EDFJ9pU7p79a/mDn03DkwZK81Ng+GT5B2JQz5gK" +
    "0TgwB2N49j7k+nwi+BB4n7EPKsOogUo/3HAWV9wxbVNp4YGyDhUPOvXE9Q/E" +
    "oJ4xFUkT6YM5GMOze5z8cW0yU6AGKhrvQa1syk/cPWsqP2gWB8LYwGPDA2Ud" +
    "Kh506onrH4hBPWMqdhrIEMzBGJ49SrTJ1GcyMdRApQs3FpvKH80248kfNd0D" +
    "YWzcseGBsg4VDzr1xPUPxKCeMRXpuvXAHIzh2XORJvO57/kPf+vnZIZRA5UF" +
    "3EhsKtfMXqk8MGsqj/+0smk8AWjP4Sv3N815TpNp90ylixrY63i3QLWpbD5j" +
    "NpeWz35v+Hap3ipp1MBehhsm5eLDTXPXD/Smq2weUzQXQf5R+cgdem+ktHup" +
    "UpvLnKG3luVfq2+e1ButsrlM1Vxabni43ipFUAN7Ce8Lmj5+9+J7RR79KfhJ" +
    "l0fITw2g8WISxlP+Ro6lQU5rHoR1E8bjHEwYw4M54G+hYgDqBdkfQ7dKe/0v" +
    "sNXAXmHo1cpFhxffF3tqY+Vudmxu61B6MQnjKX8jx9IgpzUPwroJ43EOJozh" +
    "wRzwt1AxAPUtdzzRNO85pvdQSrrv9hJqYC/Ai98i/wp96T5jY+Vudmxu61B6" +
    "MQnjKX8jx9IgpzUPwroJ43EOJozhwRzwt1AxAPVk30PDt0rcg3sBNbCbGboN" +
    "am+BuKnmGyt3s2NzW4fSi0kYT/kbOZYGOa15ENZNGI9zMGEMD+aAv4WKAajv" +
    "Q/YR91bLXrtNUgO7lb7bIHm1It9K/9BP+nkY0K74sUFEM6SfAuYk1Ad85GsO" +
    "UnL9LdT6U4Mcrt5A1U04D5JoDzwyexVzs95rLdybuxU1sBvhxW258NDi6xLV" +
    "RgFqs3pwY1qbk3ZC/RQwJ6E+4KMOaaa/hVp/apDD1RuougnnQaCXr3h491G9" +
    "5/ZSg1EDu4mh26Cr7042n4ParB7cmNbmpJ1QPwXMSagP+KhDmulvodafGuRw" +
    "9QaqbsJ5EOp3+L/36r3Xsttvk9TAbmHoNujPHsTmc1Cb1cPYZCHNkH4KmJNQ" +
    "H/BRhzTT30KtPzXI4eoNVN2E8yDUJ+zV2yQ1sBvgxWt57S2LLwqSP0zr8CNA" +
    "eyYPGlAzds4S3BrHYAXzLJmH8vHq9OwO985uk961x26T1MC2w4vW8rG79AU/" +
    "xZIbh3Djmht+5JwluDWOwQrmWTIP5ePV6dmDfHrgNol7edtRA9sML5bw4v1N" +
    "8/UH9EXuMNLGaeHGNTf8yDlLcGscgxXMs2Qeyser07NncPPsNuncntuk3fQ1" +
    "DmpgW+FFEnpvg8iIG0fgxjU3/Mg5S3BrHIMVzLNkHsrHq9OzZyK3SbI/uWd3" +
    "U4NRA9tG3ztCcuHuenLxl6zLcv8EeDk8uwV9iKf37JbGg/4P/BDQbgEf5iC5" +
    "eguvBmUv5EO3670r7IZ3ktTANtHXWN55dNFYzE1SADfeGHg5PLsFfYin9+yW" +
    "xoP+RYc0s1nk6i28GpR9CfoazLZ/R4wa2Bb63mqWCzW4SQrgxhsDL4dnt6AP" +
    "8fSe3dJ40L/okGY2i1y9hVeDsi/JR+/Se3nbG4wa2AaijcXcJAUw5hh4OTy7" +
    "BX2Ip/fslsaD/kWHNLNZ5OotvBqUfQQ+f0Lv6RaegW1ADWw6fY3l+hN6g5ib" +
    "pADGHAMvh2e3oA/x9J7d0njQv+iQZjaLXL2FV4Oyj8RuajBqYJPpayzyu8v3" +
    "/XCB/GVzZX201yF6PaiP+Ox25Jvu5CMU3Ofb1mDUwKZiNRa5AF+7v27MTSK3" +
    "UVAf8dkL7IYGowY2Eesb+WXh5QLUjblZ5F4P6iM+ewXZ368xPguzLQ951cCm" +
    "Yb3d3DYWuQB1Y24WudeD+ojPXqLvFcw2NBg1sElYjUWQ35C594cL5HszBhFN" +
    "Cu1PLj4tmZJrVzBnT95BCvzbNTm1NoR6QLuFymFohvQlORWcF1A5DA1RPpmo" +
    "eRrQx2Wntn09DWbTP2inBjYJLiYbS+iC7VygU9D+pL+xPLuCOXvyDlLgrzYz" +
    "oR7QbqFyGJohfUlOBecFVA5DQ5RPJmqeBvRxSeqTBsOzILzh1s1tMGpgU+Ai" +
    "CvK7zNkXLLlAc2h/sruprI3l2RXM2ZN3kAJ/tTaEekC7hcphaIb0JTkVnBdQ" +
    "OQwNUT6ZqHka0McFNcrvV/NMbHKDUQObABdP+MDxxYJnXzBcIGWXmCDXrmDO" +
    "nryDFPirtSHUA9otVA5DM6QvyangvIDKYWiI8slEzdOAPi6s88n+BsMztAmo" +
    "gXXDRRPeP2ssdz+54J4f5NH6DflTc7eMDeHpaTfyuj60B2AOwhz3AGU3Yrgw" +
    "LuysmTnNuXt1ISf1RaAG5vTsc40T04X+O1xxpz4jm9hg1MA64WIJb76tu7C8" +
    "gB68MLRbGnWRiaen3cjr+tAegDkIc3iHkv4hGBd21syc5ty9upCT+iJQA3N6" +
    "9rnGielC/wT5B5dnZdMajBpYF9aH5F59S9MceaK7qLyAHrwotFsadZGJp6fd" +
    "yOv60B6AOQhzeIeS/iEYF3bWzJzm3L26kJP6IlADc3r2ucaJ6UJ/sOkNRg2s" +
    "gzfcqhfIaiwCL6BHxJ8adZGJp6fdyOv60B6AOQhzeIeS/iEYF3bWzJzm3L26" +
    "kJP6IlADc3r2ucaJ6UJ/AzknPDub8ha1GlgHXBx5T//bJxe/w3sn+QHw7CUw" +
    "JqF+FQRquANEfAahvxXDs5NcfQmRHBHNpsGaZ9z2eNOcY3xlJs/YOlADq4aL" +
    "IshvvUhjqc0lIVBDbS47RHJENJsGa96p+y+/r8/QJjQYNbBKrOcs7zt2urHU" +
    "5pIQqKE2lx0iOSKaTYM1J3Vf0/Mb1Txzq0QNrArzOcvBprn1sdpcTAI11Oay" +
    "QyRHRLNpsGbU/bYj+kyt8/mLGlgVXIQX7W+ab51smtufAI93kd92TqHes1vk" +
    "+lBPqLd8PDvJ1UdgTHJc1ht4GmUHtFuU+OT6RzQ5etotDcldO49Ds3+YX75B" +
    "z1/UwCrg5AX5sSgu7pyksdTmEtdHYEzCzW8eAM8OaLco8cn1j2hy9LRbGpK7" +
    "dhHkH2ierXU1GDUwNdZzlvceWywMF3dO0lhqc4nrIzAm4eY3D4BnB7RblPjk" +
    "+kc0OXraLQ3JXbsoV2/I8xc1MDWc8KsOLl7O9V6MpLHU5hLXR2BMws1vHgDP" +
    "Dmi3KPHJ9Y9ocvS0WxqSu3Y5XLoBz1/UwJRwsvKc5Zsnm+boEzs87nMM0L4O" +
    "jj0BZAzQx2NZ/8r2s8weOPjo+p+/qIGpsG6HPnVvc7qx1ObSjbmkf2X7WXYP" +
    "yD/cPHOrbDBqYCo4wUsON93GUptLN+aS/pXtZ4w9cNkdu7y5cHJyO7TvoaY2" +
    "lwGW9a9sP2PtgXXdHqmBsbE+LCfddD7x2lx6Wda/sv2MtQe+er8+g6v4gm81" +
    "MDac1CsPNs3hxxbIH12ltOMdZDyBPrdJnAEYT/kbeVUM1ODqA3g+tBPq56DO" +
    "kE+C0nPextynwK2DPrQT6iNkxmDNo6y34ZNLG/viw7rB8KyOjRoYE+sh7lfu" +
    "Syb+eBcuzBwsOH14gQjjKX8jr4qBGlx9AM+HdkL9HNQZ8klQes7bmPsUuHXQ" +
    "h3ZCfYTMGKx5lPU2fHJpY//V9xePI3geeWbHRA2MCSfy7mOY+ONduDBzsOD0" +
    "4QUijKf8jbwqBmpw9QE8H9oJ9XNQZ8gnQek5b2PuU+DWQR/aCfURMmOw5lHW" +
    "2/DJJY3/4dt1c5HHFjy3Y6EGxoKTkK558yOY+ONduDBzsOD04QUijKf8jbwq" +
    "Bmpw9QE8H9oJ9XNQZ8gnQek5b2PuU+DWQR/aCfURMmOw5lHW2/DJhTlW+XBX" +
    "DYyB9fOr/+fOpjn0qMNjPrc+2sWNQbuBiskYxIjRgXoLrwYPxjNiEvmL8w4y" +
    "NgD9zRhA1UQC8ZQGMKZnt6APoZ41Kag3ctDuxqDdQK0dgf5L9+mzOdXDXTUw" +
    "BixeHuLOF9eDC2OgLhihD+0GKiZjECNGB+otvBo8GM+ISbgRmZPQ34wBVE2k" +
    "J94n/6xpLv/sgss+0+VycJloEjy7heg++Q0951Nzf2y4bgX1jxXE9OwG7vob" +
    "Pu86qhsMz/AYqIFlsR7ifuOBncX14MIYqAtG6EO7gYrJGMSI0YF6C68GD8Yz" +
    "YhJuROYk9DdjAFUT6Yn3jH892zxPWS2Sk3M+NXenbgX1Mq/cmJ7dwF1/w2f/" +
    "w6t5uKsGloUFf+j2ZHE9uDAG6oIR+tBuoGIyBjFidKDewqvBg/GMmIQbkTkJ" +
    "/c0YQNVEeuLV5hKwG7jrb/gIV925Zc2Fr1qkO37n4cUfUZk8AmifAua0oA+h" +
    "vgTG9Cjxz/UJ6A8A2lUM0qP/nWc16vBPjeRU9fXV6UH/khirIKnv7JumbTBq" +
    "YBlY6DuPGpPrmejKLgZzWtCHUF8CY3qU+Of6BPS1ufRA/5IYqyCpz/reXZ7p" +
    "ZVADpVjvEH3r+8bkeia6sovBnBb0IdSXwJgeJf65PgF9bS490L8kxipAjWff" +
    "pM8tz3YpaqAUFui+ajEmquxTwJwW9CHUl8CYHiX+uT4BfW0uPdC/JMYqQI1X" +
    "3rnhzcV61fLnJ5vmpkeGkQ/VZfPwMDcB5R+AMVg3ob8FY9LuEcnJHPShXfkT" +
    "xjNwY4A+/W/PDjoP/9RITtbXV+dakPVNYI1WnbR7/D/jzwLG+tyLGiiBjeUd" +
    "R/UkLLgwIbDgxNv8ERiDdRP6WzAm7R6RnMxBH9qVP2E8AzcG6NPX5mIg65vA" +
    "Gq06aXd52P7NaZ7xEtRALqWvWgQuTAgsOPE2fwTGYN2E/haMSbtHJCdz0Id2" +
    "5U8Yz8CNAfr0tbkYyPomsEarTtpdHp7u1YsayIWNJfqqReDChMCCE2/zR2AM" +
    "1k3ob8GYtHtEcjIHfWhX/oTxDNwYoE9fm4uBrG8Ca7TqpN1l5zpO8epFDeTC" +
    "gq470TQ3PrJAPgk4NTeCXHsJbkyZO6EmF8RjDWYdmYwdz6LdG9wj62ouXl2n" +
    "7ID2dcG6CPV9yO9Nn7F/3FcvaiAHNpbXHRq+QFPgLaZnL8GNiUZQm8tp+g5x" +
    "bS5lsC5C/RDvG/nVixrIgYWkr1qsCzQF3mJ69hLcmGgEtbmcpu8Q1+ZSBusi" +
    "1A/xjQd1c1nm+17UQBQWcSFetVgXaAq8xfTsJbgx0QhqczlN3x6pzaUM1kWo" +
    "93i78WNqPPtR1EAUFvDRuxZ/R9ThoWHkFwBSlP/DWrNPxhIY08XIoaBPJqpm" +
    "A/qsBMzTrYnrEvEp5LeeJbtxtUjOvn209D6TGB4j5CCMyZzU8/pa3/fCsx9F" +
    "DURhAd8+qQtVE+FCcOL0NxaHi8eYLkYOBX0yUTUb0GclYJ5uTVyXiE8htblo" +
    "/xIYkzmp5/UVXnZT92yX/gysGojAxiIvpcxCORGgJk5/Y3G4eIzpYuRQ0CcT" +
    "VbMBfVYC5unWxHWJ+BRSm4v2L4ExmZN6Xl9hrAe7aiACE197T0+hnAhQE6e/" +
    "sThcPMZ0MXIo6JOJqtmAPisB83Rr4rpEfAqpzUX7l8CYzEk9r6/wdePBLntA" +
    "BDXgwU/knrF/oFBOBKiJ099YHC4eY7oYORT0yUTVbECflYB5ujVxXSI+hdTm" +
    "ov1LYEzmpJ7Xt0XeoFm2wagBDyZ877Gm+evvL5CPEXd4qMtfA+ppn7MTuzeH" +
    "E8OrwdK4GHk7NRh4GtfOGiIw5kNdXL2Bp1F25uyxr6O5PP1ZSS3OWtDuzWs+" +
    "N6DsTgxlN6CGMCZR+h2uumsDmssXTjS9i+ctBPW0z9mJ3ZvDieHVYGlcjLyd" +
    "Ggw8jWtnDREY86Eurt7A0yg7c/bYa3MJ2A2oIYxJlH6Hb55ccXN5yY3dZHKL" +
    "NLR43kJQT/ucJL6Zw4nh1WBpXIy8nRoMPI1rZw0RGPOhLq7ewNMoO3P22Gtz" +
    "CdgNqCGMSZQ+4dIlP/OiBoZgIvkFt6HF8xaCetrnJPHNHE4MrwZL42Lk7dRg" +
    "4GlcO2uIwJgPdXH1Bp5G2Zmzx16bS8BuQA1hTKL0CZ+4Z43N5Sv3L/7gKcxJ" +
    "B+rHgDksPB/aCfUW9FkWxjdy/NXJLrQrGG8MmIPs6J7+r2Q3rhZpLqqevrWg" +
    "PcIYMabGqfGM/d0zn/OZFzXQBxvLm27VhbicdKB+DJjDwvOhnVBvQZ9lYXwj" +
    "R20uw9Tm0rg1yu+78+zP/lP9wUIN9MEE8t2bLMTlpAP1Y8AcFp4P7YR6C/os" +
    "C+MbOWpzGaY2l8at8foTa2gu2bdE1kQI9WPAHBaeD+2Eegv6LAvjGzlqcxmm" +
    "NpcmVCNvjWb/qf5goQb6SIOfdVPTfOuk5i/Atx7s4tkZL4KK6dmZszBvB2ee" +
    "Zl7GGAOnDuppJ9Rb0IdQzxrb8X+xhuYiOfvWinAent3iLyRPCmM410/5J+vX" +
    "h6dnDtqFN97abS7yrvHsf1SPIGrAgq9a5IesWYBZqLNYtDNeBBXTszNnYd4O" +
    "zjzNvIwxBk4d1NNOqLegD6GeNbbjtbmcrqW3Jvon69eHp2cO2oUP3t49/9FX" +
    "L2rAgoGvvlsXYBbqLBbtjBdBxfTszFmYt4MzTzMvY4yBUwf1tBPqLehDqGeN" +
    "7XhtLqdr6a2J/sn69eHpmYN24XPfW2Fz+foDugCzUGexaGe8CCqmZ2fOwrwd" +
    "nHmaeRljDJw6qKedUG9BH0I9a2zHa3M5XUtvTfRP1q8PT88ctLeUPHdRA0S+" +
    "5i4Net6BpvnzB22+6UD9JJwEtBvk1pmrXxnO3HPrpt7y8exeTS3/fA3NRXKG" +
    "5zEBo+TE+jImUf6A+tbn4sPdPhB57qIGCF+1yM+0sqChwljk5JwEtBvk1pmr" +
    "XxnO3HPrpt7y8exeTS21uWh7CKwvYxLlD6hvfS6/o9sHIq9e1ABhQPk6SxY0" +
    "VBiLnJyTgHaD3Dpz9StjYO5v+1TT/Mf/0TRfOBavm/O0fDz7UE0ptbloewis" +
    "L2MS5Q+ob33kD5TZC2b/qX6RogYIA37tfl3QUGEscnJOAtoNcuvM1a+MgblL" +
    "c5ED9WtPa5rLvhqrm/O0fDz7UE0ptbloewisL2MS5Q+oT33kIyijNRc+bzn3" +
    "wOJbqk7xQJdv5PJgAPqA3Bo69e9ADWtw9QGy68zUz0HdKZfuNBfhb/6tpnnZ" +
    "Jdpf5TTiKFiDQ1+OdTWXvmuq6vTgukhcI05OTOot6EOy964xj9Z20W15r17U" +
    "QAoDvf0oipXiE1ShHpyEBX1Abg1cbHPBUYOrD5BdZ6Z+DupOSZtLy3+Y3SZd" +
    "f/S0v8ppxFGwBoe+HLW5aKi3oA/J3rvGPFrbZZmfd1EDKQx0zT0oVopPUIV6" +
    "cBIW9AG5NXCxzQVHDa4+QHadmfo5qDvFai7Cr85ukz701YW/ymnEUbAGh74c" +
    "tbloqLegD8neu8Y8Wtv1mZ93UQMpDMRCcyeq4CQs6ANya1BzsHKgBlcfILvO" +
    "TP0c1J3S11yE9jZJ5TTiKFiDQ1+O2lw01FvQh2TvXWMeqf2MGyZoLi+cBf3T" +
    "+7v8CVD2B7q4dgNqmFPZgZdzriHwIaoGoOJZOZ2Y9KfegjnSeBdfe/pQ9fHs" +
    "2W3SZ4/a/n2wTtagaqT/Dv9sDc1Fcp6qpbDuU2AdSmAOonIaGjUP5nDsHq86" +
    "OEFzkaDexJSdE/HsBtQwp7IDL+dcQ+BDVA1AxbNyOjHpT70Fc6TxIs1FeOrs" +
    "Nun9X9X+fbBO1qBqpP8OtbnoHETlNDRqHszh2D34c69DH6ZTAy38vlwJ6k1M" +
    "2TkRz25ADXMqO/ByzjUEPkTVAFQ8K6cTk/7UWzBHGi/aXAS5TXrpJbomC9bJ" +
    "GlSN9N+hNhedg6ichkbNgzkcuweby9CrFzXQwgC1uSQxHFQ8K6cTk/7UWzBH" +
    "Gi+nubTMb5OO6NqG6mQNqkb671Cbi85BVE5Do+bBHI7d45q7J2guEtSbmLJz" +
    "Ip7dgBrmVHbg5ZxrCHyIqgGoeFZOJyb9qbdgjjReSXMR5rdJX9H19dXJGlSN" +
    "9N+hNhedg6ichkbNgzkcu8d1Ge8YqYEWBrj23qb56v2Z3Ady7RHGiAG+dl8X" +
    "2ichdx7UO7y1sLkIcpv0kouNGu5ffGI7hXmp72NdzeVUDbl1R/TUEOo96G9B" +
    "Hw/483rOrylgb2DvaFEDLQzABCG8iXv2CGPEALW52Mht0h8f6dahNiJzs+4e" +
    "anMJQH8L+njAn9fTai7n3jxic5FgTBDCm7hnjzBGDFCbSz9ym/S+r5yuQ21E" +
    "5mbdPdTmEoD+FvTxgD+vp9VcXoffkZY/E2L/ENRAS+r8yoM6QQhv4p49whgx" +
    "QG0uw6S3SWojMjfr7qE2lwD0t6CPB/x5Pa3m8rbgO0ZqQKCj/Kzjl++bni8Z" +
    "fPkEMPyGYLwIjOFR4u/5ePZc3jJic2n5d3/YNJ8+rHOlROfxm7+n40+N5GQd" +
    "YbAvOU9rrsvap6Ak5weOj9hcJBgTTAEnOp9sbS6mPZcpmosgt0nv+bLO1xKd" +
    "R20uvn0KSnLKdzqxR7CHCGpAoKMEY4Ip4ETnk63NxbTnMlVzEeQ26cyLdU4h" +
    "Oo/aXHz7FJTmZI9gDxHUgEBH+dU1Bp8CTnQ+2TU3F3nZLwdziDcD2i08H8+e" +
    "y/+6QB+usfl94zZpaG1TanPx7VNQmpM9gj1EUAMCHb94YvE1d7mIXwrthPq5" +
    "z33A8JuSN/2R3pSVfn5ldpv0rtltUt/1+uJ9Xdrxf7qG5iI5Wd+pOgHtEcaI" +
    "sSxT1cAewR4iqAGBjqVF5U6M+rlPbS5bh9wmvejixrxetbmslqlquCDw19Fq" +
    "QKjN5TS1uZQj7yZde1t3PWtzWS1T1VCbywjU5rIc89ukL51ez9pcVstUNYzS" +
    "XF5+8+KBrnzFnYf8UVOKZyfUz5HcCZ7PdaJJoJ3xzLkltjfU5rI0cpt0xluN" +
    "dU5YV3NhHZPCvezt1THgXifUW9DnxEjNRYJEi3APvgP1czApz8e9YMZCDWlq" +
    "cxmPf/sHTfOJW431/l5tLuZeHQPudUK9BX1O1OZiXzBjoYY0tbmMy6/8RtO8" +
    "44t6zWtzMfRjwL1OqLegz4yL8POu7CG1ubQMaGpzGR/rNqk2F0M/BtzrhHoL" +
    "+pzQzcX6ukvVWNhcXnGgaT43S/DZ7+YjfjnQf46MpzAHyLXPNQN1vO4avSkr" +
    "4/BvZrdJ19y6WPN/sobmIjm5P07tE2ffuXZDM7TP5vsQ0N+CPsxBVE5qGA/6" +
    "lrcGfiBNNRY2l7cetouKoAp3oP8cGU9hDpBrn2sG6qjNZVr+/uw26e1frM1l" +
    "vg8B/S3owxxE5aSG8aBvKWou8kqlNpfT1OYyPX9jdpv0d5+qx6emNhdtV/Gg" +
    "bylqLnSozUVvysruoDYXbVfxoG+5/I4RmstbZh3qj79byL1dPvPdLkof4DMS" +
    "J4E5FPQPkOovrM1l1/K030uutbNvimBMoPYd7UDFF7+AZgouq83F8A+Q6mtz" +
    "2b3U5lJOUXOR78OszeU0tblMz9/5e03z1N/U41NTm0s50heym4uQOrz+kA4c" +
    "hov13f5DHEUtpgf9A6T62lym5Zn/vmk+dmhx0GmbmtpcyhmluZx/QAcOw8X6" +
    "bv8hjqIW04P+AVJ9bS7T8T/PP73OtbkYdqDii19AMwWjNZdPz4r+lIGMD+Hp" +
    "PbvFp+4BRpzBmPdo6JPy6tpcRkdugy76Qvf6PO1fat3USM5T+8rB20fUWzCG" +
    "Zy/CqUvpAzCG8GY0F/kIC/uIaiy1uXSpzWVcnvHsprnqFn19anPR9iKcupQ+" +
    "AGMIbC7sIYIaEGpzOU1tLuPxh+fr9W2vS20u2l6EU5fSB2AM4Tx82JY9JNRc" +
    "zryxPwGLIJ7es1vU5rJ9yG3QxV/YuX4916c2F20vwqlL6QMwhjBKcxGunRX5" +
    "SQMZXzW5NUT01KS8+uN6U1bi/M6zm+aKg3rNufa/sYbmIjlZTx/cF7SPgZvj" +
    "XgMnRi6MZ+a9pzaXsJ6alNpcyvmD8/Vak3ada3MJ5OAhr81lXHJriOipSanN" +
    "JZ9fmt0GveXzep0t2nWuzSWQg4d8jc3lZTfV5hLSU5NSm0se3m0Qade5NpdA" +
    "Dh7yNTYX9gj2EEENCHS88s6m+cTdBvcA2h2uuacL7SZeTtoBc5p56Qf7NYTx" +
    "SmANHvS3SPQXXK0P19j89/OMOglqbNfw19fUXPrqUnV70N+IofYJY3gwvsSR" +
    "uAnKZwyY9+4Rm8v7jxsJe5LmULTYXk7aAXOaeekHOy+oilcCa/Cgv0Win7K5" +
    "yG3Qm683arRAjbW5ZMD4EkfiJiifMUDOj435Q/TynS4qoZFU2R2KFtvLSTtg" +
    "TjMv/WDnBVXxSmANHvS3SPRTNRe5Dbr8gFFfH6ixNpcMGF/iSNwE5TMGyCkv" +
    "Ntgj2EMENSDQ8Y23GgmNpMruULTYXk7aAXOaeekHOy+oilcCa/Cgv0Win6K5" +
    "/Lfzjbo8UGNtLhkwvsSRuAnKZwyQM/ItdIIaaEkdz725aa6+S/Pxu/Og/9Uy" +
    "lkC95UM7oT7Cx4kTk3ZCvZnDQfkzh8WAzytGbC6/9Muzf3Cus+skqm5DI/z6" +
    "7+o8UyM5R7vmBkrDmLlYMR2U3qmBdgt+LctSzeXF+3WCeWFG8UPQ31sIy4d2" +
    "Qn0ELrAXk3ZCvZnDQfkzh8WAz1jN5bd/v2k+fHN/nUTVbWiE2lwCWDEdlN6p" +
    "gXYLebHhNRZBDbSwMzHBvDCj+CHo7y2E5UM7oT4CF9iLSTuh3szhoPyZw2LA" +
    "Z4zm8l/P8+skqm5DI9TmEsCK6aD0Tg20W5wV+IyLoAZa2Fw+eFwnYeEe9PcW" +
    "wvKhnVAfgQvsxaSdUG/mcFD+zGEx4LNMc5F3g95w/SKHVydRdRsaoTaXAFZM" +
    "B6V3aqDdgr2BvaNFDbQwwNuPNM1H79pA7gS59gLkrbgUlcOAPh+TsQTmcDFy" +
    "KE3CeR/ThyvCb81ugz5480BeI1cO7fz/8Rqai+RU82lhrbDzeio97KYmM6ey" +
    "G7g5Heg/j5HU8P5jEzSX1x3ShWwE3gXw7AUMLX4f9NmG5vJfztVxcnJGqM0l" +
    "Iddu4OZ0oP88RlLDu4+O0Fz442ivvkUXshF4F8CzFzC0+H3QZ5Oby9/+5aZ5" +
    "/XU6hpmX9kxqc0nItRu4OR3oP4+R1CAvMpZuLkIa4Jz0pfEm4V0Az17A0OL3" +
    "QZ9NbS6nboP64mXkjFCbS0Ku3cDN6UD/eYykhlcf7DYW6+stW9RACjvUVXfm" +
    "IX+TlEI7oT7kc0eXqwj1BtQsC+PPYZ2GXwdnHrmcE2gu//lc7Uc4L9pJVL+u" +
    "5sI6okTnlcUI19yri/YrA/sy1b88+Da0oAZS2Fwu70neBydCO6E+5MPFIdQb" +
    "ULMsjD+HdRp+HZx55DLUXOQ26LXXaR8Lzot2EtXX5tKMcs29umi/MrAvU/3z" +
    "b5iouVx6RCceghOhnVAf8uHiEOoNqFkWxp/DOg2/Ds48culrLk+f3Qa97+b4" +
    "OnBetJOovjaXZpRr7tVF+5WBfdlqP3h7tx+M2lwuPKQTD8GJ0E6oD/lwcQj1" +
    "BtQsC+PPYZ2GXwdnHrlYzeU/nZu/DpwX7SSqr82lGeWae3XRfmVgX7Za+RtD" +
    "9gT2jBQ1kMK/IXjpjTrxEJwI7YT6kA8Xh1BvQM2yMP4c1mn4dXDmkUvaXOQ2" +
    "6MLrdI30scj1ieprc2lGueZeXbRfGdiXrVZ+CSTtBy+5cYnmIrBTfXj20ugj" +
    "d9hc4fCRO7vQbkEf5iT0j6ByOHV6OWmfw7i0A8aMwBgpZ390caDkNui9N/n6" +
    "PpiTUE/69P9oDc1Fcnp1RaH/nDu70CcXFd/Q5BKJ19pynrcIaoCwucjPODI5" +
    "i+iDB4x2C/owJ6F/BJXDqdPLSfscxqUdMGYExkh5zedmt0HnxPV9MCehnvTp" +
    "a3PxUfENTS6ReDL+nmPdPjBJc3nlQZ28r1DCA0a7BX2Yk9A/gsrh1OnlpH0O" +
    "49IOGDMCY5BcvQVjEOpJn742Fx8V39DkEokn43xEMkpzEdKAL9qvk/cVSnjA" +
    "aLegD3MS+kdQOZw6vZy0z2Fc2gFjRmAMkqu3YAxCPenT1+bio+Ibmlwi8WQ8" +
    "93mLoAYs2LHeO3uJdNntAe5woN4CPvLMJ4V25b8p5NZJPaHe8qE9F8azYtJO" +
    "qO/hH/6u7MbVIjlZRy/evGi3NB7L+lswZgm35z9vEdSABZvLm25dJHRhkYR6" +
    "C/jU5jLgH9HkwHhWTNoJ9T3U5jKCvwVjFvDOjD9WTFEDFgx8wcFGT8LCKLQD" +
    "9Rbwqc1lwD+iyYHxrJi0E+p7qM1lBH8Lxizg9Rl/rJiiBvpIA8tzFzUJC6PQ" +
    "DtRbwKc2lwH/iCYHxrNi0k6o76E2lxH8LRizgLPxzXNDf6yYogb6YOeS73X4" +
    "0HFwexf59roUV18AY5TAmArMg3bGs1AxnLWhnVBvrqfhNxjDqNtDrUVhzHU1" +
    "l1Pz4PpwXkDZOe/I3KF3a2B86mWMOYAb0/Dh2Wdv6EMN9MEE8qcAXmFq4oT6" +
    "AhijBMZUYB60M56FiuGsDe2EenM9Db/BGEbdHmotCmPW5hKogfGplzHmAG5M" +
    "6KM/I2KhBvqQt57SBPL/e4WpiRPqC2CMEhhTgXnQzngWKoazNrQT6s31NPwG" +
    "Yxh1e6i1KIxZm0ugBsanXsaYA7gxoZfnq5M3F4FJ1K0RJ8KJE+oLYIwSGFOB" +
    "edDOeBYqhrM2tBPqzfU0/AZjGHV7qLUojFmbS6AGxqdexpgDuDETrfyyIt+C" +
    "lg/TsS/0oQaGYHN51cFFAWGOdfnA8S5Kb/jk2iM5qCFejhDe3J0c1H9AYgDX" +
    "B1Bfwlgx/8EzZTeuFsnJOsZk2bVR/twjxjV3gf/QHnp9wadyU9TAEPxe3TP2" +
    "G8UPwYkdDyy+t5iOPZKDGuLlCOHN3clBPTcFN4bpA6gvYayYtblolD/3iHHN" +
    "XeA/tIfkq21X1lwEJrvosDGBPjix44HF9xbTsUdyUEO8HCG8uTs5qOem4MYw" +
    "fQD1JYwVszYXjfLnHjGuuQv8+/ZQ6QfnUtSABxPK3xyoCfTBiR0PLL63mI49" +
    "koMa4uUI4c3dyUE9N0VtLvnU5tL07qHXFn5wLkUNePCvI+WBj/yt0VZzFNC+" +
    "DlCT/Ml7itIH2JQYFr+2huYiOfuu+RjzHCPGujjTeHeYvcBDDURgR5PfMmFx" +
    "W0VtLmHGiGFRm8vmcMnh5V+1CGogAhPLzw2wwK2iNpcwY8SwqM1lc5DvbOIZ" +
    "Zw+IoAaiMLn8ljSL3BpqcwkzRgyL2lw2B3kXOD3b0b8lImogCpuL/BLbu491" +
    "eRc52kU+hNcB/hZeDM9uQR+FMw/Cmq26ydI1SZ7MGNSX4MWM2tfVXFhHH6pu" +
    "rr/hQ1QMxx6BdSg78Ox8plr6qkVQA1H45wBn3NDoA0WcidLfwovh2S3oo3Dm" +
    "QVizVTdZuibJkxmD+hK8mFF7bS7aHoF1KDvw7Ofhs2xraS4Ci5Cu1zlQxJko" +
    "D6SFF8OzW9BH4cyDsGarbrJ0TZInMwb1JXgxo/baXLQ9AutQdjBkH+tBbosa" +
    "yIGFnHVT0z1QxJkoD6SFF8OzW9BH4cyDsGarbrJ0TZInMwb1JXgxo/baXLQ9" +
    "AutQdjBkP3fJT+QSNZALi3nzbU1tLoG6ydI1SZ7MGNSX4MWM2mtz0fYIrEPZ" +
    "QZ/detVS+iC3RQ3kwoLkVxnfcaSHo4D2MfBy0G5pCPUkV2/55MJ4U8SkParJ" +
    "0e+M/+ozG3X4p0ZyqnpWCdeGUG9R4mMw9qsWQQ2UwKLkN2VZ/JyRFmIQLwft" +
    "loZQT3L1lk8ujDdFTNqjmhz9znhtLgbUW5T4gIsneNUiqIESWFjvq5cRFsLF" +
    "y0G7pSHUk1y95ZML400Rk/aoJke/M16biwH1FiU+gN92MMarFkENlMLizFcv" +
    "IyyEi5eDdktDqCe5essnF8abIibtUU2Ofme8NhcD6i1KfBLeNuN53+me3ZK/" +
    "I7JQA6Wwuch3QUjhWRzWXHqkS65d5YjgxWAN5IjGi0EYU/kbMGcujGfBuhjD" +
    "pWdea2kuz2jUup9ip65TOHbOaxK4lkZdnp11j/m5FqIGSrFeWr3VmMwgXIjA" +
    "Ynl2lSOCF4M1kCMaLwZhTOVvwJy5MJ4F62IMl5551eYSgGtp1OXZ05ovOTLd" +
    "qxZBDSwDm0v2qxcuRGCxPLvKEcGLwRrIEY0XgzCm8jdgzlwYz4J1MYZLz7xq" +
    "cwnAtTTq8uxpzfz95zFftQhqYBmWfvXChQgslmdXOSJ4MVgDOaLxYhDGVP4G" +
    "zJkL41mwLsZw6ZlXbS4BuJZGXZ69rXfqVy2CGlgWNpezZgVfctsOh7tcfFuX" +
    "U7oEauRtsyFUDsduQR9FZk3FPkMwnhGT8yLUKxjfyEGYw6P1e+ozGnX4p0Zy" +
    "9s2rr85TcF0M3Bi5jJFjx2+Kz7UQNbAs1quX1xxsanMp8RmC8YyYnBehXsH4" +
    "Rg7CHB6tX20uAcbIMfN5k/GXz1vRXAQW/cIbmuYiayG4UAbUqMUCKodjt6CP" +
    "IrOmYp8hGM+IyXkR6hWMb+QgzOHR+p356aZ5zhU2zwXP+UgXZSfQt5z5qf55" +
    "9dV5Cq6LgRsjlzFy3La4/eEZ5RkeAzUwFiz+vJuNheBCGVCjFguoHI7dgj6K" +
    "zJqKfYZgPCMm50WoVzC+kYMwhwf9LZQPalJ2wjlYeDkJ/Q3cGLmMkEPuIng2" +
    "x/g0roUaGAtOQJAP1slvz+46ZF4ptI/AWwDtYzBFjpKYJT65rCJHNthHrPEt" +
    "MgZUjAHkj4r5EFfg2R0LNTAmnIR8ozgnvCuozaWXkpglPrmsIkc2EzeXZX/k" +
    "LBc1MCbWw135CVhOeuupzaWXkpglPrmsIkc2EzYX+YUOnsWtbi4CJ/OCGxYv" +
    "zzj5raY2l15KYpb45LKKHNlM2Fz4O0RTNxZBDUwBJyU/RSJvh0mT6SBjQHQd" +
    "bgO0OzC+lcOzswZXD3ufZkjPtaLe9AHUE+ot6EOoV/CaB2AOF/FJod3SOHjz" +
    "UPGtHLQDlSMAY1hYn8Sd6iFuihqYAk5MeO0t3YszJ7J4mReMML6Vw7OzBlcP" +
    "e59mSM+1ot70AdQT6i3oQ6hX8JoHYA4X8Umh3dI4ePNQ8a0ctAOVIwBjEPle" +
    "61U+xE1RA1PByb14f/fizIksXuYFI4xv5fDsrMHVw96nGdJzrag3fQD1hHoL" +
    "+hDqFbzmAZjDRXxSaLc0Dt48VHwrB+1A5QjAGETuEnj2eDanQg1MhfVwVybe" +
    "uUiRxcu8YITxrRyenTW4etj7NEP6yGZWPoB6Qr0FfQj1CswjAnO4iE8K7ZbG" +
    "wZuHim/loB2oHAEYI+UC4zMtY//90BBqYEo4UUF+OvINhwa4FeTaIzCGB/0D" +
    "yGd8UlRMDyNmNmuI+Ubg6UM+QOkDuD7MQzuhXuoCro9nD9DmuvDQ+m6HWtTA" +
    "1HCysgDyNpla2L4FzrVHYAwP+gdQGy0XI2Y2a4ipDrGjD/kApQ/g+jAP7YR6" +
    "qQu4Pp49QJuLP8kqiJ3ncUrUwNTIBDlpef6iFrZvgXPtERjDg/4B1EbLxYiZ" +
    "zRpiqkPs6EM+QOkDuD7MQzuhXuoCro9nDyB5zjaes6zydqhFDawC6w+nzr4J" +
    "C9u3wLn2CIzhQf8AaqPlYsTMZg0x1SF29CEfoPQBXB/moZ1QL3UB18ezB7Ce" +
    "swg8g6tADawKTl4wn79wAXPtERjDg/4B1EbLxYiZzRpiqkPs6EM+QOkDuD7M" +
    "QzuhXuoCro9nd3jtofU/Z0lRA6uEi/Dc2cJceEvTvC7l0DCiT6G9E6sPz4f2" +
    "AuQBW4qbg3ZCveHDtSHUMx71c5I5zOdBGJNQH4A10F6CGxN1c95E+Rtk56Te" +
    "Qb7ahGdKmg7P3apQA6vEenv6RfuxaLwAS14wE8+H9gLUZvRy0E6oN3y4NoR6" +
    "xqN+TjIH81AxJqE+AGugvQQ3JurmvInyN8jOSf0AL7tJn6V1PGdJUQOrhgsi" +
    "yEKdWjhegCUvmInnQ3sBajN6OWgn1Bs+XBtCPeNRPyeZg3moGJNQH4A10F6C" +
    "GxN1c95E+Rtk56S+h/ONB7gCz9qqUQPrgIsiXHBgZ/F4AZa8YCaeD+0FqM3o" +
    "5aCdUG/4cG0I9YxH/ZxkDuahYkxCfQDWQHsJbkzUzXkT5W+QnZN6A/nyJ3mc" +
    "wPPDM7YO1MC64OLIgr3i4GLxOsiCDiB/szQE9XOYg3h62gOE6srUU0OoV/Mg" +
    "1Afwcnr2UeA8LODj1gX/1wKlj8QkXo3MeXDznrOkqIF1YT1/kQbzamfBCS8o" +
    "oX4OcxBPT3uAUF2ZemoI9WoehPoAXk7PPgqchwV83Lrgrw469ZGYxKsxzXfQ" +
    "bizrfs6SogbWifX5F1nAToPhBeEFcKB+Di8q8fS0BwjVlamnhlCv5kGoD+Dl" +
    "9OyjwHlYwMetC/7rbi7ywVOeFYFnap2ogXXDxVINhheEF8CB+jm8qMTT0x4g" +
    "VFemnhpCvZoHoT6Al9OzjwLnYQEfty74r7O5WP8Ib1pjEdTAJsBFE+QtavmK" +
    "zCmQD++l0O5R4k8fQv0U7JWcu4YDTXPmFrxiaVEDmwIXT5Cv6lMLPgLLbvgS" +
    "f/oQ6qdgr+TcLcifyPBMbGpjEdTAJsFFnKrBLLvhS/zpQ6ifgr2SczewbY1F" +
    "UAObBhdTkIXm4i/Dshu+xJ8+hPop2Cs5tx3r2+SETXnLuQ81sIlwUYWzblp8" +
    "ybB82C5FxlI8ewleTNot5DM8HYw4HaBnPKsOD/pH8GIsa4/AGIR6+UthRW7M" +
    "Jf2LmOU554D9IblNbyyCGthEZCG5uG2D8S6yZy/Bi0m7BZsFYyigZzyrDg/6" +
    "R/BiLGuPwBiEetUYjPVjDLKsfwl9jWWTPssyhBrYVPoajPwd0tBFnmITeDFp" +
    "t2CzYAwF9Ixn1eFB/whejGXtERiDUK8ag7F+jEGW9c9F/uHc5sYiqIFNpu/9" +
    "fflAUd9FnmITeDFpt2CzYAwF9Ixn1eFB/whejGXtERiDUK8ag7F+jEGW9c9B" +
    "Ggv3+LY1FkENbDp9DUY+B3PezQYHAO0Wno9nt8j1oZ5Qb1HiM+RvQR+Sqy/1" +
    "yUR+KCzFyyl/eTwE9aX07e9tayyCGtgG+m6Rzrihac7lBXM2jYnn49ktcn2o" +
    "J9RblPgM+VvQh+TqS30y2cTmIv9Ack9va2MR1MC20Ndgns8G42waE8/Hs1vk" +
    "+lBPqLco8Rnyt6APydWX+mSyac2lr7HIbRL3/ragBrYNXgzVYJxNY+L5eHaL" +
    "XB/qCfUWJT5D/hb0Ibn6Up9MNqW5yD61/rpZ2Ia3m4dQA9sIL4ogT9rlnaRz" +
    "wMsNqFHcDGCXDzl5qBhA1USNV1NUM4Bbg4WT04tJ+1xDHB9lD0AfDy+nhZdT" +
    "xuQfQu7d3dBYBDWwrfDitA3mrNn9arpRuUnMzUy4MWDnJrJQMYCqiRqvpqhm" +
    "ALcGCyenF5P2uYY4PsoegD4eXk6LoZzyD19fY+He3lbUwDbDi9Qi97PtRuUm" +
    "MTcz4caBnZvIQsUAqiZqvJqimgHcGiycnF5M2uca4vgoewD6eHg5LfpyygNa" +
    "6zMsu6mxCGpg2+HFannBDXqD9G5mwo0DOzeRhYoBVE3UeDVFNQO4NVg4Ob2Y" +
    "tM81xPFR9gD08fByWjCnYP3M6m5sLIIa2A30fVZA/rV46Y3GRvHgxoGdG8hC" +
    "xQCqJmq8mqKaAdwaLJycXkza5xri+Ch7APp4eDkt0nzywbi+26Dd2FgENbBb" +
    "kLfweAFb5F8Puedtkb+yTkltFrn6uc+NXV5GqAeePgJjkojerYN2EtCrnIBr" +
    "SX0ExmQNtHv+qqYkhnyC/Dk9t0Hb+hmWCGpgt8GL2SL/ikQ3DsnVz3248Qj1" +
    "wNNHYEwS0bt10E4CepUTcC2pj8CYrIF2z1/VtBOj721mYTe8IzSEGtiN8KK2" +
    "yL8m8i+Ht3FIrn7uw41HqAeePgJjkojerYN2EtCrnIBrSX0ExmQNtHv+rElu" +
    "v63fbW7hHt2NqIHdinebNLRxiLfRLLj5sjezo4/AmCSid+ugnQT0KifgWlIf" +
    "gTFZA+2ef1rPXr0NImpgt8OL3SK3SfIVmvIvTqWSzayhvGTG83uairDbb4OI" +
    "GtgL9L2bJMg9sto4lYqD7Ju+VysC9+BeQA3sFfr+8FGQt6zlg3fcQJUKkVug" +
    "oWcre+k2iKiBvQY3Q4rcKsnm4IaqVAT5YCb3TEq7x/YqamAvMvSwV5BNJP9C" +
    "tcgPU3W40Sf1j+DmoN2AMQn1hPq5j1OH0peQuXa5+rmPA/Uvlrg7vGD/8C3Q" +
    "Xn61kqIG9jLcJClyqyT31ebG5IEzUJvVwc1BuwFjEuoJ9XMfpw6lLyFz7XL1" +
    "cx8H6qWpvOjG/r8Jamn3UqU2FxNumBS5v1abkwfOQG1WB252xlN2A8Yk1BPq" +
    "5z5OHUpfQuba5ernPg7Ue7dAe+2doAhqoLLAu1WS5zGnNikPnAE3qwc3O+Mp" +
    "uwFjEuoJ9XMfpw6lLyFz7XL1cx8H0chDfbnO9RaoDDVQ6cLNROSVjNwuyff3" +
    "5vAiQDuhXja+i5dj/zD0t2IoO+MYPi6MQaj3oH+A592grzXZZ+yXymnUQMWG" +
    "G4u0z2TUxu5BHUoH6lUjsfByGIcqhf5WDGVnHMPHhTEI9R70HyDSVLb5e21X" +
    "iRqo9OPdKuU0GXUoHahXjcTCy2EcrhT6WzGUnXEMHxfGINR70B+8cH+sqdRb" +
    "oDzUQMUn2mTkIaDa6DuoQ+lAvWokFl4O46Cl0N+KoeyMY/i4MAah3oP+O0hT" +
    "8d79qU2lHDVQiRNpMvIwUJ7LSKPJQR4kDvECielhxF0aJ4eqkzj+Yc0Q9Ady" +
    "PSJNpd7+LIcaqJTBjWkhG1pefqvDYMBDSnhgTIy4S+PkUHUSxz+sGYL+M+QP" +
    "CiMNRahNZRzUQGU5uFEt5NWMbHTz8O3AQ0p4eEyMuEvj5FB1Esc/rBlix08a" +
    "irxKGXorOaU2lXFRA5Vx4Mbto++2iYeUqANowUM3Bk4OVSdx/MOaAXIairDP" +
    "uH6V5VEDlXEZ+noH8pwZz53xPPnf7wwjB4iIb4qyezF2crdQb0EfxqQ+AmMQ" +
    "6ltyGoqwz7helfFQA5Xp4OYeQg5Ke/tkwQM3P3T7uii7F0N8Eqi3oA9jUh+B" +
    "MUira9eIazfEPuO6VKZBDVSmZ+i7ZPpgs+GBmx+6fV2UHdDORkG9BX0Yk/oI" +
    "jJHGyW0mQn2Wsh7UQGW1RN7OtrAazW5rLvJ/lzQToX42Zf2ogcr6yHk+YyHP" +
    "bFq2qbm0r8pKbnPIPmNdK+tBDVQ2Bx6cimafsW6VzUANVDYXHqy9SP3elO1B" +
    "DVS2g5KHwttIbSbbixqobDelD4jXTX0Au/tQA5XdCw/0Othn1FXZnaiBSoXw" +
    "Fqx+bqQSQQ1UKpXKGKiBSqVSGQM1UKlUKmOgBiqVSmUM/j+phKYqfB+CNgAA" +
    "AABJRU5ErkJggg==")

STEP_IN_ROLLOVER = ("data:image/png;base64," +
    "iVBORw0KGgoAAAANSUhEUgAAARcAAAEXCAYAAACH0wDUAABArklEQVR4Xu2d" +
    "ebR8RXXvfS9GMzjFl6iJA0aNGk2ixgFUBBQUfgKKgIKzEUUUUZyHmDiAc1Aj" +
    "MYpDxDEqEkfQOMWgoDxRVBRUSDSiOIDRF/NMsvLWqnd3d5/f75zP3ufsqjp1" +
    "uvveW73W55/a3z1Unap9u8/t4UrnhXClSqVSKY0aqFQqlRKogUqlUimBGqhU" +
    "KpUSqIHK1uclp4bwjJN3cfQLQ9jvcV1uct8N4e19fuPu2vf+z+jGF1hDZeuj" +
    "Bipbg/d8fH6o5aDLgWdTWCW3f8iuBnTK39XGs1VRA5XNRfMsJOXZxrrSPAuq" +
    "z3a2Bmqgst5IM5G/+nIQeTi3Kk3D4VpU1hs1UFkv5GXDlM3k9g8OYd/Hdnn6" +
    "X2r+/nO7oE1gDIG5SiDrIOshTZZrVVkv1EBltUgzkRuspV7iyP2NpmG86G82" +
    "msM5IVz+ryH8938b/L8MImNIU3rte+d1HP70eV2sNYfabNYXNVBZPnIwxhw2" +
    "OWD3OCaEo04I4amvCuHMs0M456sh/Md/JfKfgHZLQ6h3uOjb83qlbkHmMeZZ" +
    "mjTl2mjWAzVQWQ7y3xz5i8vDEYMcvsOeFsKJb9o4nP+cf7AVMY2CGkJ9JtJ0" +
    "XvOeecP83fvoNYhB7tXU/0atDjVQmRZ5yZP6l7ndTHY+I+GhLnGwY+JRQ6gv" +
    "RLvZpK6fIOsuDZ3XozIdaqBSHvlPR+o9FHl50GkmhIe6xMGOiUcNoX4iZF1k" +
    "faTppjQbuQ71P0/LQQ1UyiBPx1PevPYb+4TwyOeH8NYzQvj5/43gF5p/B7Sr" +
    "GODfgfK3YBzaAXOw5lndiTGFz5wfwpNfMV9Hrm0fcp+r3p+ZDjVQGYc0lZRn" +
    "Kfd7agivflcIl/7IOFRDGAdMHVLCGIAHX/lbMA7tgDlYc25zaSMNWho117oP" +
    "eeZTn82URw1U8pC/gLFN5XYPCuEFbwjhgkuMgxSLcajUISWMAXjwlb8F49AO" +
    "mIM1l2gujZ80bGncd3+MvgYWtcmURQ1U0pDNGPOa/3cPnj9t/+z5i4M7Fh6o" +
    "XxiHlDAG4MFX/haMQztgDtZcsrm0kUYu6y/XgdeG1CZTBjVQiSO2qTT3UXio" +
    "uPmT4YH6hXFICWMAVSP9LRiHdsAcrHmq5tJG7s/EvmyS/zLx2lfiUAOVYWKb" +
    "yiOeF8KXvxnCT/9tIn5uQA34GaA9isScS8GrifaFRq7P8SeFcK2Im8C1yaSj" +
    "Bio20lS44SwmbyoNPzegBtTmYmu+c1ltMlOgBipd5I1X3o1a2ZSyOZfSVBrk" +
    "gBBqQG0uA5p/i28y8sy1/gvbRw1UduG9T6VpKrIpuVEnpzkkbagBtbkMaFrI" +
    "9XzeKSHc2Ln5K++T4Z6p7EINVPyXQNJUnvDyEC65NITLf1pZN674WRfaUzjp" +
    "7X6Tqf9ZslED2x3vJVBtKutPyebS8OevG365JC+V6ocku6iB7Yr3CeW9j97Y" +
    "OBfqTVdZP6ZoLoL8UXnYc/XeaCMvpbm3titqYLvh/WtZ/lq96QN6o1XWl6ma" +
    "S8Ppn6wvlWJQA9sJ7wuaHv+yEL7xnRB+cMUW4XIH6kuwjBwrQvbH0EsleYl9" +
    "Xmu/bTfUwHZA/r089Gxlr0fPv5aRm2nTw4NOqC/BMnKskHO/FsLBT9J7qM12" +
    "/be1GtjqDP0nSP4KvfytegNtGXjQCfUlWEaONUD+YO12kN5TDXJP7zzsxa2O" +
    "GtjKDL0MevxLN14CfTts6QOgDjqhvgTLyLFGyEsl7q2G7fYySQ1sRYZeBsmz" +
    "ldedPv94fjF+aBCjGdJPAXMS6iP4HqA9KkeMZgC3BgE5vgdoV/6kpT3zs8PP" +
    "YrbLyyQ1sNUYehn0R0eGcM5XjI0yFm5Ma3PSTqifAuYk1EfgHuyYHDGaAdwa" +
    "BOQo2VyEr10SwkHH6z3XsB1eJqmBrcTQy6BjX+JsvjFwY1qbk3ZC/RQwJ6E+" +
    "Avdgx+SI0Qzg1iAgR+nm0vg8+zV67zVs9ZdJamArEPMyyN18Y+AmszYn7YT6" +
    "KWBOQn0E7sGOyRGjGcCtQUCOqZqLIL/LtB1fJqmBzY68BZsXr+EPjwjhrPND" +
    "+PZl4PuAdgL9d4DSXzb/MFyHCJ8hf9qngDnNvN7aefYpYE4Lzwd2db0I4yHm" +
    "V74VwoFP1HuyYSt+lYMa2MzIBeJFa3jsi42Lb2yC3o0yoFcbj/rL9CGN8Rny" +
    "p30KmNPM662dZ58C5rTwfGBX14swXk/MoXuAW63BqIHNSl9juebeIbzmNOPC" +
    "O5tgEOjVxqP+Mn1IY3yG/GmfAuY083pr59mngDktPB/Y1fUijDcQ80OfCeFG" +
    "B+q9Kmylr3FQA5uRvg8d9r4MIj2boBfo1caj/jJ9SGN8hvxpnwLmNPN6a+fZ" +
    "p4A5LTwf2NX1IoznxPzKxfP9yT27lRqMGths9P1H6A8eEMIXLwrhku92udhA" +
    "Pu3ahvaLZawN7TEwBqE+A87DnbtTg4pHveHj2gn1OT60E+ojfMauXZRmY+zI" +
    "Z+u9K2yF/ySpgc1EX2PZ8YR5Y4naJDJ+KQ4QNd4miYExCPUZcB7u3J0aVDzq" +
    "DR/XTqjP8aGdUB/hM3btojSL8b4GI//x5J7fTKiBzULfv5qPfFb3ArqbRMYv" +
    "xQGixtskMTAGoT4DzsOdu1ODike94ePaCfU5PrQT6iN8xq5dlKZle8yL9F7e" +
    "7A1GDWwGYhuL4G4SGb8UB4gab5PEwBiE+gw4D3fuTg0qHvWGj2sn1Of40E6o" +
    "j/AZu3ZRGthPfJPe0w2b8Vvu1MC609dYTnyjcfG+G7FJZPxSHCBqvE0SA2MQ" +
    "6jPgPNy5OzWoeNQbPq6dUJ/jQzuhPsJn7NpFaWi/dGs1GDWwzvQ1FvndZflE" +
    "s3CRx3cMqFkCTb19dXv2EpTIwRiEeiJfxqVIjLGK68kaLegTy3s/OX8LBff5" +
    "ZmswamBdsRqLXIBXvTPxgnIjLmkzEm8jevYSlMjBGIR6ohpLbS4zhhoMz8a6" +
    "ogbWEesb+WXh5QIkX1BuxCVtRuLV7dlLUCIHYxDqiWostbnsRPb3rR+g9/5m" +
    "ucmrBtYN69/NTWORC5B8QbkRl7QZiVe3Zy9BiRyMQagnqrHU5tKh7xnMZmgw" +
    "amCdsBqL8NxTQrjgkhVyMaDdQL7fo41n96D/ZoXzisGLQXsJSuRgDI/G790f" +
    "txvMur/RTg2sC32fFVp5YxFqcykG5xWDF4P2EpTIwRgebV9pMDwLwjp/VEAN" +
    "rAN9jeVJJ+kLthJqcykG5xWDF4P2EpTIwRge9Jc/rDwT69xg1MCq6ftIunw4" +
    "MfYgT05tLsXgvGLwYtBeghI5GMOD/kJfg1nHr2tQA6uk74ueDnt6COd/c86X" +
    "yTe6NLpeREOoIan6GFJjRujV2gDqPbi2M5yYys66iRHD0zAHoT4L1MB1oJ52" +
    "S1OKP3m+PiPr2GDUwKqQr6bkYgl7PKK7sNxIyRe0tWH6Nq8iVR9DaswIvVob" +
    "QL0H13aGE1PZWTcxYnga5iDUZ4EauA7U025pSiJ/cHlWhHX6ykw1sCqsN8nd" +
    "6v4hnPWl7qJyIyVf0NaG6du8ilR9DKkxI/RqbQD1HlzbGU5MZWfdxIjhaZiD" +
    "UJ8FauA6UE+7pSlNX4Ph2VoVamAVWP9ythqLwI2UfEFbG6Zv8ypS9TGkxozQ" +
    "q7UB1HtwbWc4MZWddRMjhqdhDkJ9FqiB60A97ZZmCm51uD476/IvajWwbKwb" +
    "uNfYK4S3nRHCF75ucGGX877ehfYcVExi+Az559Sl/Inho0j1od7C8Tnvwi7U" +
    "q3kZGuLGJMih7OLnzctBxbNgDkK9B/03+NTGIbrBDn2G1uF3kdTAMum7zyK/" +
    "9cJF7Lsg3Ei056BiEsNnyD+nLuVPDB9Fqg/1Fo6Pd+jUvAwNcWMS5FB28fPm" +
    "5aDiWTAHod6D/osYbztTnyFh1fdf1MAyse6zHPpUYwEHLgg3Eu05qJjE8Bny" +
    "z6lL+RPDR5HqQ72F4+MdOjUvQ0PcmAQ5lF38vHk5qHgWzEGo96B/K8ZxPb9R" +
    "zTO3TNTAsrDus/z+xuvHT33BWEBjMRu4kWjPQcUkhs+Qf05dyp8YPopUH+ot" +
    "HB/v0Kl5GRrixiTIoezi583LQcWzYA5CvQf9EWO/x+kztcr7L2pgGfTdZzn1" +
    "QyF8/qtdPjeWCyKAj6qB+hyY44Iunl5BvQV9WAOgvQheTbRbGqDWztAM6a31" +
    "VmtBDWN6esPHxfOnHXzs3BCuv0b3X9TAMuDkhWeerC9YkQ1vXAQFfFQN1OfA" +
    "HBd08fQK6i3owxoA7UXwaqLd0gC1doZmSG+tt1oLahjT0xs+Lp4/7QbyB/pK" +
    "t9es4v6LGpga6z7LIU+ZLwwvWJENj8U3gY+qgfocmOOCLp5eQb0FfVgDoL0I" +
    "Xk20Wxqg1s7QDOmt9VZrQQ1jenrDx8Xzp91iQ3fsS/QZE3gWp0YNTIn1mvCW" +
    "h82fzsnC8IIV2fBcfAv4qBqoz4E5Luji6RXUW9CHNQDai+DVRLulAWrtDM2Q" +
    "3lpvtRbUMKanN3xcPH/aLRbafY/RZ23Z91/UwFRYnxu6+l4hvPEDIXzmywvO" +
    "9/ksoL0ITT0LvJyfFU0b6C0f5qDd9bdIrJt6ZV8GrMGqm3bgxqQ9hyliOnjr" +
    "YNaxGD/znBB+5wB95uR+J8/mVKiBqbBeDj3t1c5CGagFnwJcQC8nNzv1lg9z" +
    "0O76WyTWTb2yLwPWYNVNO3Bj0p7DFDEdvHUw62jZ5A83z5zAszkVamAKrO9n" +
    "uftjIhbKQC34FKAuLyc3O/WWD3PQ7vpbJNZNvbIvA9Zg1U07cGPSnsMUMR28" +
    "dTDrgP3Bz9FnT25P8IxOgRqYAk5OXg7JN2txIdRCGagFnwLU5eXkZqfe8mEO" +
    "2l1/i8S6qVf2ZcAarLppB25M2nOYIqaDtw5mHYbdenm0jJ8oUQOlsd4sJ920" +
    "byE81IJPAerycnKzU2/5MAftrr9FYt3UK/syYA1W3bQDNybtOUwR08FbB7MO" +
    "w/7Kd+ozuIwv+FYDJZH/rXNStzg0hE+fN+cf1oSmnr66PDuhPseH9hhKxPAY" +
    "m2OsfynG1hHjH6MZo7foi7HP0fosTn1zVw2UxLqJe9Lb9cRXTVNPX12enVCf" +
    "40N7DCVieIzNMda/FGPriPGP0YzRW/TFeOdH57cjeB7PM85tKdRAKaybuAc/" +
    "yZ74qmnXZNXl2Qn1OT60x1AihsfYHGP9SzG2jhj/GM0YvcVQjAf9qT6TU365" +
    "txooBSchXfPDZ/VPfJW0a7Lq8uyE+hwf2mMoEcNjbI6x/qUYW0eMf4xmjN7C" +
    "i2Hd3J3qowFqoATWz68++oQQPv55cG4GjEGoJ9Rv8AmgfDwYk/YIPgFoj6JA" +
    "HYPxZH3OHUbFIBHx6OPZS+DmMNaiA/UxMVNhTmP9lA942Vv02Zzq5q4aGIv1" +
    "ieeb3y/MDy0xJu/CGIR6Qv3n57XV5mLAeLI+5w6jYpCeeOdeEMIXL1ou8jGA" +
    "pi53HsZadKA+JmYqzNlav5QcBz5Rn9EpfjlADYzFuon72tNCbS4OOZtEUaCO" +
    "wXiyPucOo2KQnng/+VlY+uOKn+2qy52HsRYdqI+JmQpzttYvJcf7/iGEq99N" +
    "n1Oe5bGogTFYz1qOfFbYdWiJMXEXxiDUE+o/v6u+2lwA48n6nDuMikF64tXm" +
    "EgFzttYvNcejTtBntfSzFzUwBj5rke542idD+Mg5PZwNaC/AR4HKaWHE6cQ8" +
    "u4vyj8GIm1S34UNYp4rp6GmPgnUCVcNi/PKf8uhP/5CcrK9vfVXdtMvcADXL" +
    "wKuzPcff3r97Xks/e1EDuVifer73E4zJ9UzUuqAlUIvNnBZGnE7Ms7GJcjDi" +
    "JtVt+BDWqWI6etqjYJ1A1bAYr82lDF6d7Tk+4eX6zJZ89qIGcrH+Q/TmDxmT" +
    "65modUFLoBabOS2MOJ2YZ2MT5WDETarb8CGsU8V09LRHwTqBqmExXptLGbw6" +
    "Oc8pn72ogRyynrUYE1X2AqjFZk4LI04n5tnYRDkYcZPqNnwI61QxHT3tUbBO" +
    "oGpYjNfmUgavTs7zkS/QZ7fUxwLUQA7Ws5Y3vi+ED30GnDWMvMmOUENcPWr4" +
    "sIUXw0HFM/B8XHsMRm1DqHnnxMvxMfx/vILm8uN/1XU0cG14PVy7QWoOtVY5" +
    "MC/s7/r7EK6G/xyVet+LGkjFetZywHFxEyNqsQ0NcfW8oBZeDAcVz8Dzce0x" +
    "GLUNoeadEy/Hx/CvzcXQN7WNgXlp3+Dwp+szXOLZixpIpfdZS+TE2qjFNjTE" +
    "1fOCWngxHFQ8A8/Htcdg1DaEmndOvBwfw782F0Pf1DYG5qX9rOmevaiBFKyf" +
    "Y935rCVyYm3UYhsa4up5QS28GA4qnoHn49pjMGobQs07J16Oj+Ffm4uhb2ob" +
    "A/PSvmCKZy9qIAXr2/xf8IYQ3v/pOfJOwNK830HpF7WMqYk5CPXvkzzEiUm7" +
    "AvHob0EfFRMofwOlSc0htbdoxn/0k7D0h+TcOZeeuvrmTajPIScmfQj1pNG9" +
    "48zyz17UQApsLLd5YBi8QCXg4hGldzZNDMxBqFcHzsjrxiCIR38L+qiYQPkb" +
    "KE1qDqm9RTNem0teTPoQ6klbe9jTuudZGPOJaTUQi/V9Le1nLdYFKgEXjyi9" +
    "s2liYA5CvTpwRl43BkE8+lvQR8UEyt9AaVJzSO0tmvHaXPJi0odQT9raU07X" +
    "Z3rM972ogVhYBJ+1WBeoBFw8ovQFamIOQr06cEZeNwZBPPpb0EfFBMrfQGlS" +
    "c0jtLZrx2lzyYtKHUE+o3//Y7rkWePZjUQMxWP9+PuZFIZz2iWHeC2gvgZvj" +
    "kwaJMWgn1MfgxfDsloZQT1L1MT6eveGHPwlLf0hO1hFL7LxSmCJmKi99qz7b" +
    "uTd21UAM1o3ct3xIF0qWsXhuDjaW2lx6/Wm38Hw8e0NtLtPETGbjPFz3Xt2z" +
    "nfszsGogBjaWez4ubjGWsXhuDjaW2lx6/Wm38Hw8e0NtLtPETGbjPBzy1O75" +
    "FuRtJ+wDHmrAw/q5kKe8Mm4xlrF4bg42ltpcev1pt/B8PHtDbS7TxExm4zy8" +
    "5jR9xnM+La0GPPiOXPnfeOxiLGPx3BxsLLW59PrTbuH5ePaG2lymiZnM4kz8" +
    "0ZHdcy6wF3ioAQ8mvO+T528fFv7WodHF6nN8PD3tlmY0HzWI0bQoUuPImNRb" +
    "PqXsP7iCR3/6h+RkPbF484rVDBHjTw2hnvTpH31i95wLqT8BqwaGsN7b8uI3" +
    "68L66JvIEKk+np52SzMao1lEaUY0ApORMam3fErZa3PRxPhTQ6gnffo3fkCf" +
    "9dQfsFcDQ/BrLG9yH7uwPvomMkSqj6en3dKMxmgWUZoRjcBkZEzqLZ9S9tpc" +
    "NDH+1BDqyZB+38d2z7vAnjCEGujD+pCi/IJbX2EWQxPpI9XH09NuaUZjNIso" +
    "zYhGYDIyJvWWTyl7bS6aGH9qCPVkSH/8SfrMp3wcQA30cf9nBJXoFe8I4W1n" +
    "9vN28LYzHIwYY3n7GV1UTisv7JyHIicHUDGB0iPnDPqxLiPOUEw1hxyMPFbO" +
    "yy7n0Z/+ITlj15d2otZexrEWtJOYmIQ+qXjz/PU9u2c+5T0vaqAPNpbdH64L" +
    "IWohsNgKI8ZY1OJZ0A92zkORkwOomEDpkXMG/ViXEWcopppDDkYeK2dtLnEx" +
    "CX1S8eYpv+/Os8/e0Ica6IMJ5Ls3WQhRC4HFVhgxxqIWz4J+sHMeipwcQMUE" +
    "So+cM+jHuow4QzHVHHIw8lg5a3OJi0nok4o3zxPe2D33QuxLIzVgYf3YmfeS" +
    "aFY44GIrjBhjUYtnQT/YOQ9FTg6gYgKlR84Z9GNdRpyhmGoOORh5rJy1ucTF" +
    "JPRJJWaefGkkt0jYIyzUgAU/S3Sd/UI49YMa+SmRNsoOaLdgTA/Xv5V/J9R4" +
    "wN/NafiQUz/Uhf60M+csLzHijKnJgj6pNLV//8c8+tM/JGfs2rlrbeCulZcD" +
    "duVv5SCGTyp3elj3/Md+iZQasOCzFvkhay6EtRjKDmi3YEwP17+VfyfUeMDf" +
    "zWn4EG+T0M6cs7zEiDOmJgv6pNLUXpuLkQN25W/lIIZPKg94Zvf8C+wRFmqA" +
    "WP+CPvYleiGsxVB2QLsFY3q4/q38O6HGA/5uTsOHeJuEduac5SVGnDE1WdAn" +
    "lab22lyMHLArfysHMXxSed7rdQ+Iue+iBoh1v+Wv36MXwloMZQe0WzCmh+vf" +
    "yr8Tajzg7+Y0fIi3SWhnzlleYsQZU5MFfVJpaq/NxcgBu/K3chDDJxWJm3Pf" +
    "RQ0Q+Zq7dtDdDgrhDe+zkZ8UGeIN7x+G+pkPcO0Sp4WyWzg+hP60TwLXi/YI" +
    "zdh5miAm7aomssj1vR/x6E//kJx9c+Va5ODFpJ1Qb4L1ZAxen2T/hW6vR3f7" +
    "QMx9FzVA+Kxlx3FGgQtYFOFECPXNxIZyKLuzmPSf4fgQ+tM+CVwv2iM0Y+dp" +
    "gpi0q5rIIldtLhrqTbCejMHrk+y/0D30z7t9QGCvIGqgjXW/Rb7OUhW4gEUR" +
    "ToRQ30xsKIeyO4tJ/xmOD6E/7ZPA9aLd0Zzx2RAu+nYIbz0jf54mWDvaVU1k" +
    "kas2Fw31JlhPxuD1SfZf6OQDyuwF3tdfqoE21v2Wv/xbo8AFLIpwIoT6ZmJD" +
    "OZTdWUz6z3B8CP1pnwSuF+2ORpqLPOTH1+WLmXPmaYK1o13VRBa5anPRUG+C" +
    "9WQMXp9k/5b2t/br9gLvU9JqoI11v+W1p7d47zCvA7ST151uYMRJialo179A" +
    "xaQGMagn1Fuk+kTpB+r+4Fm7DtV//lcI//hFwx8wZ2/eETRxL/3hrvqW9ZCc" +
    "rKNvnql2S0NS9RaMQVL1Q9ztUd1+IJxn9I0GNdAxItD+jw+9m9eCxdFOVGMR" +
    "jDgpMRU8gEYO2hmDekK9RapPlH6g7nZzaR5f/6cQ3vQBI84C5uzNO4Imbm0u" +
    "2h4DY5BU/RAPeU63HxRtLk88KfRuXgsWRztRjUUw4qTEVPAAGjloZwzqCfUW" +
    "qT5R+oG6reYiD/m9ZPl6QxUL+QbzjqCJW5uLtsfAGCRVP8SJxueMhu67qIEG" +
    "637L0Oa1YHG0E9VYBCNOSkwF52DkoJ0xqCfUW6T6ROkH6u5rLvKQl0mf/qKO" +
    "x5y9eUfQxK3NRdtjYAySqvfg+12KNJdfu2sIf/XuLieD0nZLk8pfvasL7TNN" +
    "IvQn1Fs+qfYYGKPN+/6BR0s/LrgkhNf/nfYdwqvBW//G77sraC6Sk/Wk1l0S" +
    "5iDU5/h4do9bHtbtC0M3ddVAAz+sKEGZyCt0rN3SpOJtkpkmEfoT6i2fVHsM" +
    "jNEmprnIQ37i9F0f0/59eDV469/41eaicxDqc3w8u8e98HOvQ2+mUwMN/L5c" +
    "CcpEXqFj7ZYmFW+TzDSJ0J9Qb/mk2mNgjDaxzUUe/7HxMulTX9AxLLwavPVv" +
    "/Gpz0TkI9Tk+nt2DzUVg73CbCwPU5hJfE/WWT6o9BsZok9JcmkfMyySvBm/9" +
    "G7/aXHQOQn2Oj2f3OO5l3b5QpLlIUCbyCh1rtzSpeJtkpkmE/oR6yyfVHgNj" +
    "tMlpLvLwXiZ5NXjr3/jV5qJzEOpzfDy7x/ONT0j3/Z6RGhCst/0/9ZUhvOqd" +
    "w7ySvKOLp6c9ConbBnbmsKAPY1KfA3Moe+I8lF7qHOC9n+TRin/Iy6SPn2vP" +
    "Q8G6YOc8Gv7lB8w6/UNy7qwL6xVb987rYYG1YI6oGAPxYmK6wF/lNGBv6PuP" +
    "kRoQ+J8igQksUgunnvYosNi0M4cFfRiT+hyYQ9kT56H0UucAY5pL8/jqxSG8" +
    "9jRd29Da0c55NNTmYvgTri3jGTFd4K9yGtzw3t3e0Pf1C2pA4M+ISDAmsEgt" +
    "nHrao8Bi084cFvRhTOpzYA5lT5yH0kudA5RoLvKQ31d+50d0fX1rRzvn0VCb" +
    "i+FPuLaMZ8R0gb/KaXDbB3b7g3xMiD2kt7nw39C3OFQnsEgtnHrao8Bi084c" +
    "FvRhTOpzYA5lT5yH0kudA5RqLvKQl0mfOFfXaK0d7ZxHQ20uhj/h2jKeEdMF" +
    "/iqnQewvMaqB2SAc73FMCH/x1gjeBmgn0L/8remomIB6E8ndgnUR6glriJor" +
    "4zh2xvOQ+2ilH1/+5vymYGdeBPNQ67LgO5cx+vQPydm3T7h+hHo1b8snEa6R" +
    "CXIoHD1zWjDG4cYPJLKHRDcXCcYEJihc2Qn06oJFoGIC6k24mA7UE9YQNVfG" +
    "ceyM5zFFc5HHD68Is5/N2DkvgnmodVlQm4uGa2SCHApHz5wWjHH0i7r9YVRz" +
    "ecyLdAITFK7sBHp1wSJQMQH1JlxMB+oJa4iaK+M4dsbzmKq5yOM//jOEj31u" +
    "MS+Ceah1WVCbi4ZrZIIcCkfPnBaMIWPsEdZ/jFRjsZqL/OoaE5igcGUn0KsL" +
    "FoGKCag34WK2kKf9cjDbvNvhPR8zYIyPAcZx7IznId/fMvXjK98K4dXvxnpi" +
    "rXl9Gmpz0XCNTJBD4eiZ04IxZIw9Iqq5yEak40vePP+aO8Wpw4jfaCROC+ZQ" +
    "NTmo+I7mbz8a6iPh8YMrwuxb5/uuT9/1/Pb3u3GW8ZCc3At9cB4x+5BzJdQT" +
    "t4YISsRQnKp7RFRzsd7j0lsUFxhwYlnwgpA3p6HiO5raXNIf8jLpI+cE8/r0" +
    "Xc/aXDRuDRGUiKHYqP1m96vNRaHiO5raXPIf539z/u/Nztr2XM/aXDRuDRGU" +
    "iKE4VTcX6410tbk4mtpcxj1+cPn8h7V2rm3P9azNRePWEEGJGIpTdXOxvtfF" +
    "bS7X3xHCCW+af8Wdh9z4bePZV8GJMhci4y3a+refGepj5OMXGy+TPvyZxfr3" +
    "8M/fo9f0D8nJOqw9YNXt2WOQc9WhFS82Jn3IWP0MnBfR3fS+BZrLTQ8JtbnU" +
    "R5HHFy+a/7eB6y3U5pIXkz5krH5GqebCt/7X5sItWR9jHpddPv8tHK55bS55" +
    "MelDxupnGM1lr0fV5qLgQtXmsvyHvEw64zPdNa/NJS8mfchY/YyI5mJ93aXf" +
    "XDae/jzvlBCem4H4pUD/GLwYnt3TvOXD3JL1Uepx3oXzm4yy5v90Ka3TPyQn" +
    "r721B0rh5fDsFvTxyPGnj7DnUd0+IbCXuM1FgvQl8GCRHvSPwYvh2T1NbS7T" +
    "Pr7/4xBOOb02lxi7BX08cvzpI2Q1l5vgRk1tLtyS9VH6IS+T5MfZlv2ozUXb" +
    "LegjZDUXOtTmwi1ZH1vlUZuLtlvQR3jYnxdoLnd5ZAjP+esQ/jQD8RuCegv6" +
    "KF4DaM+gnf9vPsgtWR9b5XHJpa1r/hqAfZAFYnKfEfpH7W1Ho2I6UG8hugc/" +
    "pzaXLNr5a3PZuo/aXDTUW4guq7nI92HW5rKL2lymf/zk/6zmp0Vqc9FQbyE6" +
    "6QvJzYX/LfrjB8cnJSycUG9BH4WzuDm089fmMu1DfnhN3uNx8Qr+W1Sbi4Z6" +
    "C9EVaS43uU98UsLCCfUW9FE4i5tDO39tLtM9/v6cXetcm4v2j9rbjkbFdKDe" +
    "QnRFmsuNDw7hma+ef18DeSZ5dRdP79nNmMSIMxgT8aw627zhfdyS9TH2ccXP" +
    "Qnj1u7rX5+LvUjX94+J/GdgD2GfePqLe2puMQb2y0x85ZzAu7CoH7cxj+Cg2" +
    "dHs8otsn5C0s7CW1uTgxanMp+/jKxSE87/X6+tTmYtjpj5wzGBd2lYN25jF8" +
    "FCfr5hL12SJxrM1lF7W5lHt85Gy9vs11qc3FsNMfOWcwLuwqB+3MY/goTp73" +
    "hdHN5Vr79BRxcsTEHL1nN2MSI85gTMSz6mxTm8v4x082Xgad/K75+nN9m+tS" +
    "m4thpz9yzmBc2FUO2pnH8FGcXKi5CE955fyH6F1e1UX8hlB6C/p4ICbtjOfF" +
    "POW93JL1kfL48rdCeM5rjeu6oFnnb/4LPad/SM6+fUa4Lwj1OXDvqrWKQeIM" +
    "4ehZ04xWDc012+2g2lyUnfG8mLW55D/k2+fU9QTNOtfmEtTeVWsVg8QZwtGz" +
    "phmtGpprxuZy9Atrc1HxvJi1uaQ/5L9B8sXcs/Xl9QTNOtfmEtTeVWsVg8QZ" +
    "wtGzphmtGpprdr17dXuE9A32EtVcrN8tmk08BhSuigRKb0EfD8SknfG8mLW5" +
    "pD3k96PlfRA715fXEzTrXJtLUHtXrVUMEmcIR8+aZrRqaK4Ze0RUc5kNwvFP" +
    "nh/CE/9Cc/xJXZQd0P5E8WlDuxGDUK9gDgv4cF5uTsRT/jF4OYDyP8mooxXv" +
    "r9/Do1X+8cF/1PNQsObFfL7xHUab/iE5e9cTdav1J/S3YrSujbnvHJR/RAza" +
    "SYyeGoE9Iru5HPo0nXCWFIup7IB2b6GsGIR6BXNYwIfzcnMinvKPwcsBlP9J" +
    "Rh2teFM2l8t/Ov9pUM7BhDUv5lObi9YT5R8Rg3YSo6fmsS/WzUV+KuU89hEO" +
    "zAbhKN/pwoSzpFhMZQe0ewtlxSDUK5jDAj6cl5sT8ZR/DF4OoPxPMupoxZuq" +
    "uZz/jRCedbKuvxfWvJhPbS5aT5R/RAzaSYyemsOeppvLeVYf4cBsEI53eKhO" +
    "OEuKxVR2QLu3UFYMQr2COSzgw3m5ORFP+cfg5QDK/ySjjla8KZrLB8/Sdbuw" +
    "5r+YU5uL1hPlHxGDdhKjpybmW+gENSDwIwA3vHcIx75U8/hE6E+ot3xof/zL" +
    "ulAfg4oJxupjfIjnT7tFWy9vYiv1kJdBLz3VroN1EuobLvo2s0z/kJysr69O" +
    "2gn1lo9nz4Exiaf37Bb8Wpak5iL/s247XnNvncAqzIP+hHrLh/baXPpp60s1" +
    "ly9dFMLTXtVfB+sk1DfU5pIHYxJP79kt5MlGuz9Yb6DrbS7We12YwCrMg/6E" +
    "esuH9tpc+mnrSzSX93/ar4N2Qn1DbS55MCbx9J7d4jr37PYG60foe5uL9V6X" +
    "BzxTJ2FhHvQn1Fs+tNfm0k9bP6a5yMsg+W8AY1p10E6ob6jNJQ/GJJ7es1uw" +
    "N1j/hu5tLjMDAtzr2BCOedEwj3FI1cf4pNotPB/PfswLu1Bv+oBUPXP25W14" +
    "5Tt5tOIe8sNlT3pFf13Mk2pvar/wn5l5+ofkjK0z1W5pFLyGsCfHM2AMD/rP" +
    "aNV4uPGfInkywv6R1Fxu9yAjKWChJFUf45Nqt/B8PDs3CfWmD0jVM2df3oac" +
    "5nL6p3Qc1jHW3tRem4u2J8czYAwP+s9o1Xjw8d2+ILB3uM2FP452q/sbSQEL" +
    "Jan6GJ9Uu4Xn49m5Sag3fUCqnjn78jakNBf5gbIX/o2OYdU11t7UXpuLtifH" +
    "M2AMD/rPaNUoTzJGNxf+O/oG9zaSAhZKUvUxPql2C8/Hs3OTUG/6gFQ9c/bl" +
    "bYhtLnwZRFjHWHtTe20u2p4cz4AxPOg/o1XjrQ7v9gXr6y3d5mL9x+ioF3R5" +
    "1AlAxlocdcIwqfqZD1A1EUdvzmMkrHkG88LOGO48Imj7n/Q2Hi39OO0TOoYH" +
    "62Ldrn7B1/+J1Uz/kJw71xPXh/WRKD3XwvHx7CbMIXFaUE97TM62/vo7uj2h" +
    "79/Qg81F/jvA5vLQP3MKcSZKUvUzH6AWhzh6cx4jYc0zmBd2xnDnEUHbf6i5" +
    "yMugF7xB+8fAuli3q19Qm4tvN2EOidOCetpjcrb1V71ztyf0/adosLnMjGgu" +
    "9zjGKcSZKEnVz3yAWhzi6M15jIQ1z2Be2BnDnUcEbf++5vKFr4dw3Mu1byys" +
    "i3W7+gW1ufh2E+aQOC2opz0mZ6N9wLO6/UCwPrCY1Vxuc6RTiDNRkqqf+QC1" +
    "OMTRm/MYCWuewbywM4Y7jwja/lZzyXkZRFgX63b1C2pz8e0mzCFxWlBPe0zO" +
    "RnvHh3X7gcCeEd1c+BmC39zXKcSZKEnVz3yAWhzi6M15jIQ1z2Be2BnDnUcE" +
    "bf92c5GXQSdkvgwirIt1u/oFtbn4dhPmkDgtqKc9Jmej/d37dPvBb9x9RHOx" +
    "buo+8NkhPPy5C57X5RHPHUbpI6DPztx9NRDWQTvjGyg9alD2CFiXZ2cOC9bV" +
    "jvfSt4TZ439/LYTHvdjOqfwNvLqoJ336r10Slv742kZz6VtvVXei3VwbDyNu" +
    "JwfizUBO5TPS3s7L+y19b/uPai4zAZrLnf+klRiLw0KJ0kdAH06cdvqzBmVn" +
    "fAOlRw3KHgHr8uzMYcG62vGee0oI7/nYcE7lb+DVRT3p09fmomMSxpuBnMpn" +
    "pL3Je/CTun1AGLrfktVcbn5oKzEWh4USpY+APpw47fRnDcrO+AZKjxqUPQLW" +
    "5dmZw4J1eTFpV/4GjOHWQP8efW0uOiZhvBnIqXxG2pu88p1O7AXsFUQNEL6Z" +
    "7up7tRJjcVgoUfoI6MOJ005/1qDsjG+g9KhB2SNgXZ6dOSxYlxeTduVvwBhu" +
    "DfTv0dfmomMSxpuBnMpnpL3Jyx9B8+63RDUX677LIU8J4SHPCeHBQMbaPPjP" +
    "hlF6C/rB/hCJ00LZM2AMkqqf4cxdgXkpqLd8aE+ENVt1006UHjTjF1wSlv6Q" +
    "nKyjD29eau1Ft4gdm2O0v4VR1xCcZzPXq+7R7QHe/Zao5jITobns8fB5Qm/y" +
    "LJIovQX9YFeLQ3sGjEFS9TOcuSswLwX1lg/tibBmq27aidKDZrw2lwL+FkZd" +
    "Q3Cewr2f0D3/wil/N1Fz+b37zQv3Js8iidJb0A92tTi0Z8AYJFU/w5m7AvNS" +
    "UG/50J4Ia7bqpp0oPWjGa3Mp4G9h1DUE5yn8ccKHFTt9gwMW6r7L3eaFe5Nn" +
    "kUTpLegHu1oc2jNgDJKqn+HMXYF5Kai3fGhPhDVbddNOlB4047W5FPC3MOoa" +
    "gvMUfnv/7vkf+rBiGzVgYX3O6KDjQzjyWcMcAWgn1Fs+nv3IZwPaDbyYtB/x" +
    "7C7UW6gYgHqSqs/16cC1NObq5qA/Wei+ejGP/vQPydk3D+8aU0+7OXfaAWMS" +
    "6i0f2ok3L1Xzs/XZt34X2kIN9MEEt3mgURgnAmgn1Fs+np0Lo+wGXkza3Qtk" +
    "oGIA6kmqPtenA9fSmKubg/5koavNRcck1Fs+tBNvXqz5rkd1z70Qc79l1jM4" +
    "0If866md4Np3NwrjRADthHrLx7NzcZTdwItJu3uBDFQMQD1J1ef6dOBaGnN1" +
    "c9CfLHS1ueiYhHrLh3bizYs13+yQ7rkX2Bv6UAN98OdGBPnKO1VceyKAdkK9" +
    "5ePZuTjKbuDFpN29QAYqBqCepOpzfTpwLY25ujnoTxa62lx0TEK95UM78ebV" +
    "rvewp4dwFfwLWj5vyN7QhxoYgs3lloeFcPjT+5Hi2tCeA2MS6gn1OT6p9hym" +
    "iEm8HLRbmlT64n3lWzz60z8kJ+vrq5PE6GM0Q3pCveVDO5Ev2B6irf3jh3TP" +
    "u+C95b/TLzgwBL9X92p76skNTZT2HBiTUE+oz/FJtecwRUzi5aDd0qTSF682" +
    "F60n1Fs+tBM2E9LWylfbsrmwJwyhBoaw3q2716P1BPsmSnsOjEmoJ9Tn+KTa" +
    "c5giJvFy0G5pUumLV5uL1hPqLR/aCZsJaXQHGG+ci3lXbhs14MGEN7mPnmDf" +
    "RGnPgTEJ9YT6HJ9Uew5TxCReDtotTSp98Wpz0XpCveVDO2EzIY3uD4/onnOh" +
    "7/eJ+lADHvwCKbnhc9+nzJHPHKVw3yd3oX1pSO4hoG/m2wf1WaAGrhVzxuRV" +
    "euYwNArUwRjMGcuXv8mjP/1Dcqr6m7XgPFkz9U/xYQzPngXnQnsk19qne85j" +
    "PqhI1ICH9Ya62z4ob3HcC7gseEEI9NwUhPosUAPXijlj8io9cxgaBepgDOaM" +
    "pTYXbc+Cc6E9gn0eo8947Bvn2qiBGJhYfm4gZ3HcC7gseEEI9NwUhPosUAPX" +
    "ijlj8io9cxgaBepgDOaMpTYXbc+Cc6E9gpvfr3u+BfaAGNRADHJjh8nveawu" +
    "0sO9gMuCF4RAz01BqM8CNXCtmDMmr9Izh6FRoA7GYM5YanPR9iw4F9oj+PU9" +
    "u2c79rNERA3EIDd22Fx+//D5543aHAgOeqID/LNgzAK482ANOTAnoJ41WXWp" +
    "GKmwRgNVA+2RNZz/DR796R+Sc2etrMmYy2iYIxXGO77c+jfwnqrwjJOX2FwE" +
    "fhxAup2aGCduTMZbvGQYswDuPFhDDswJqGdNVl0qRiqs0UDVQHtkDbW5RMB4" +
    "x5db/4bdDuqea4FnPxY1EIv1cQDpeoMTNybjLV4yjFkAdx6sIQfmBNSzJqsu" +
    "FSMV1migaqA9sobaXCJgvOPLrb9wD+NG7tDPtXqogRRYyG/t50zcmJC3eMkw" +
    "ZgHcebCGHJgTUM+arLpUjFRYo4GqgfbIGmpziYDxji+3/sJuB3bPsxD7CWgL" +
    "NZACv0RK2OMRAxM3JuQtXjKMWQB3HqwhB+YE1LMmqy4VIxXWaKBqoD2yhtpc" +
    "ImC848utv/WsJfdGboMaSIUFya8yHvD4OfuDA44DC11RmCMGxgD7H9eF/pwn" +
    "9TE+Kqdnt3IYulExDR9PkxqzWY8vraC5fOkiXW8frJtQH+Oj1gZExaOfY++L" +
    "eUPjc0RjnrUIaiAV69nLHR9qLwYPGCdaBOaIgTGAukCA86Q+xkfl9OxWDkM3" +
    "Kqbh42lSYzbrUZuLJioe/Ry7FVM+H8gzPPZZi6AGcmBhzbMXTpQHjBMtAnPE" +
    "wBhAXSDAeVIf46NyenYrh6EbFdPw8TSpMZv1qM1FExWPfo7diimfD+QZTvlq" +
    "hT7UQA59z144UR4wTrQIzBEDYwB1gQDnSX2Mj8rp2a0chm5UTMPH06TGbNaj" +
    "NhdNVDz6OXbG3PexIfzy7t2zm/M5Igs1kIP1prob7Jj/G6vDY9PZ93FdlB3Q" +
    "rmBNRkyFo2cNrNmq24MxabegD2vwUPM0cHMk2pvav3gRj/70D8nJNYzGW5cl" +
    "wbo8O+EvKQq5b5ojaiAXfpGUIF/uO3QoY+DmVHZAuwKbIqouR88aWLNVtwdj" +
    "0m5BH9bgoeZp4OZItDe11+aSB+vy7G32OXq6Zy2CGshF7iyzuahnL8YEPbg5" +
    "lR3QrsCmiKrL0bMG1mzV7cGYtFvQhzV4qHkauDkS7U3ttbnkwbo8e5spn7UI" +
    "amAM7rMXY4Ie3JzKDmhXYFNE1eXoWQNrtur2YEzaLejDGjzUPA3cHIn2pvba" +
    "XPJgXZ69YepnLYIaGIP17OU6+80nksveDtSvgpya6EOoJ9TH+EzB2Boavy9c" +
    "yKM//eO8C3U9fXjzpN3SpFIiXl+MGxnvxi35rEVQA2Oxnr3c+v560rFwcQj1" +
    "qyCnJvoQ6gn1MT5TMLaGxq82F02JeFYMeRc9z6jAszwWNTAW69nLr94lhD2P" +
    "0hOPgYtDqF8FOTXRh1BPqI/xmYKxNTR+jz4xhCe/YrkcfaKupw9vnrRbmlRK" +
    "xLNiyA8a8oyWftYiqIESyGtQFi9PwzjxGLg4hPpVkFMTfQj1hPoYnykYWwP9" +
    "Y2Kk6kvg5aTd0qRSIh5jyKsIns0S78a1UAOl4ASEOzxk4xnMI1sctUVoz6kP" +
    "+Nz1kV1oJ3JjvA3tFqk+qfoYUuc58wG0l0DlcK6Xa8+BMQFr5FrGrmeDvBy6" +
    "Mm7iCqnf6h+LGiiFPM3iJOQbxYtfoHXA2BgK+KRuEm402i1SfVL1MaTOc+YD" +
    "aC+ByuFcL9eeA2MC1si1jF3PButHzuRVBs9uKdRASaybu/ITsEUv0DpgbAwF" +
    "fFI3CTca7RapPqn6GFLnOfMBtJdA5XCul2vPgTEBa+Raxq6nIL/QwbMo8MyW" +
    "RA2UxPpYwK/cZePp2cMXC2gswqbE2BgK+KRuEm402i1SfVL1MaTOc+YDaC+B" +
    "yuFcL9eeA2MC1si1jF1Pgb9DJExxE7eNGiiNdXP3dw4IYfdHzF8Ddni4ZndA" +
    "H4nThv7U58AcROW0SI3pQH2WT2tdrbVVczBwY6wANU8Dz4d2ztu1Gxo3Rwbu" +
    "+j/c/tTzVDdx26iBKeDEhD84wl4I4i2eumCMwRwZMAdROS1SYzpQn+XTWldr" +
    "bdUcDNwYK0DN08DzoZ3zdu2Gxs2Rgbf+8u0EV76TPn88o1OgBqbAurl7zb31" +
    "QqiLg4WzFk9dMMZgjgyYg6icFqkxHajP8mmtq7W2ag4GbowVoOZp4PnQznm7" +
    "dkPj5sjAW//rH6DPXuoPyueiBqbCurkrE+8sBi8OFs5aPHXBGAP6HJiDqJwW" +
    "qTEdqM/yaa2rtbZqDgZujBWg5mng+dDOebt2Q+PmyGBo/a1fTiz9+aEh1MCU" +
    "cKLCLQ6dv/9FkJ8mIXd4KFhodwK78o+BMYCyIwdR8SNyEOpVPAv6AJWD/jkw" +
    "D+0gqwbm8KB/DIxBUvUWXgzHzrUz98mCPzrSfjk09U3cNmpgSqzfOpIFuN2D" +
    "5ovJQzo7qFw47wLQPwbGAMqOHETFj8hBqFfxLOgDVA7658A8tIOsGpjDg/4x" +
    "MAZJ1Vt4MRw7187cJwv4k6yC7E2eySlRA1MjE+Skr7HXfDF5SGcHlQvnXQD6" +
    "x8AYQNmRg6j4ETkI9SqeBX2AykH/HJiHdpBVA3N40D8GxiCpegsvhmPn2pn7" +
    "ZIPf3l+fsWW+HGpQA8uAPwUryILwkM4OKhfPuwD0j4ExgLIjB1HxI3IQ6lU8" +
    "C/oAlYP+OTAP7SCrBubwoH8MjEFS9RZeDMfOtbP2yU2Ne5vCVG/xH0INLAP5" +
    "ZnFOXrj5oUEfVC6gdwHoHwNjAGVHDqLiR+Qg1Kt4FvQBKgf9c2Ae2kFWDczh" +
    "Qf8YGIOk6i28GI6da8d9sg73WdqogWUh/w7jIsjC/OERIdz2gS0eBNo2i1R9" +
    "jI9nj8GL4dkLcBtAexSsk1CfA2KqupkzAxXTg/6AdovknIn82l31mZI/djx7" +
    "y0INLBPr39NX3wuLxotkLOoofYyPZ4/Bi+HZC1Bkc7NOQn0OiKnqZs4MVEwP" +
    "+gPaLZJzJnDde+qztIr7LG3UwLLhggiyUDsXjhfJWNgOqfoYH88egxfDsxeg" +
    "yOZmnYT6HBBT1c2cGaiYHvQHtFsk54zE+qJtYRX3WdqogWXTd//lZvddLB4v" +
    "krG4HVL1MT6ePQYvhmcvQJHNzToJ9TkgpqqbOTNQMT3oD2i3SM4Zwa0OX6/7" +
    "LG3UwCqw7r/80p3mDeYPHlCWWxtQQ1L18rkpBTUejv+tj9BQo3BiEsaPysEY" +
    "gPYcpoi5DFg3od5DGot8hSzPzirvs7RRA6vCuv8iDUYWkIs6Bl7QmIuaqleH" +
    "OONQev489FEH34lJGD8qB2MA2nOYIuYyYN2E+iH6Gsuq77O0UQOrxHr/iyxg" +
    "yQbDCxpzUVP16hBnHErPn4c+6uA7MQnjR+VgDEB7DlPEXAasm1A/hHzwl2dF" +
    "WPV9ljZqYJVYvxxQusHwgsZc1FS9OsQZh9Lz56GPOvhOTML4UTkYA9CewxQx" +
    "lwHrJtT3YX17vyDnh2dqlaiBVdPXYOQjAvIVmS6HAtoNbgFo91D+rMGogz6E" +
    "+inYLjlNnOuzlhxqf6OcIJ/b41laNWpgHej7D5IsrFpwkrFpxm545c8ajDro" +
    "Q6ifgu2S08S5PuvI9e6lz8S6NhZBDawL1ieooxpMxqYZu+GVP2sw6qAPoX4K" +
    "tktOE+f6rBvXMz6MKCzri59yUAPrRF+DkYXm4u8kY9OM3fDKnzUYddCHUD8F" +
    "2yWniXN91onr79BnQFiXfzn3oQbWDesLvoXf2m/+CdCbHZKG+BBq5P01Hcba" +
    "LY2H50+7pQFq3oQ+tMO/yNrF4MRQNRH6WzEOGUb5E+bsyzuAmsfG2A0PDOGX" +
    "7qj3/7o3FkENrCOykFzcpsHwAnnwAhY5IJ7d0nh4/rRbGqDmTehDO/yLrF0M" +
    "TgxVE6G/FeOQYZQ/Yc6+vANwHn2NZZ3eyzKEGlhX+hrMde6pL9IQvIBFDohn" +
    "tzQenj/tlgaoeRP60A7/ImsXgxND1UTob8U4ZBjlT5izL+8A7TnIH87N3FgE" +
    "NbDOWG+yE+QNRbxQfXAjFjkgnt3SeHj+tFsaoOZN6EM7/IusXQxODFUTob8V" +
    "45BhlD9hzr68AzT1S2PhHt9sjUVQA+tOX4O5+t1CuPFBBgcD2i0cn90O7uLp" +
    "o3yAqzdyKA2hnlAfA2MANQ9Do2AOQj2J0VNDUvUGux3URcU06HuD3GZrLIIa" +
    "2Az0vUSSLyW+0YG4YLzobVsfjo86MITxYnyAqzdyKA2hnlAfA2MANQ9Do2AO" +
    "Qj2J0VNDUvUGqc1F/kByT2/WxiKogc1CX4O56h5oMLzozfgQjo86MITxYnyA" +
    "qzdyKA2hnlAfA2MANQ9Do2AOQj2J0VNDUvUGKc2lr7Es42dXp0INbCb6/k3d" +
    "aTC86DLm4fioA0MYL8YHuHojh9IQ6gn1MTAGUPMwNArmINSTGD01JFVvENNc" +
    "ZJ9an24WNsO/m4dQA5uNvjfa/c87zr/R7gY7CnBv4NjlTU9E+YyFNVl1Eeqd" +
    "umk38XLQDpizyFol1mDixfDsO/x5yS+OXmUPvXe3QmMR1MBmZKjByJ13XtRk" +
    "vI0EOzeVtbFGw5qsugj1Tt20m3g5aAfMWWStEmsw8WJ49h3D85I/fH2NZV0/" +
    "K5SKGtis9H3YUZBPVPPCJ+FtJNi5qbixisCarLoI9U7dtJt4OWgHzFlkrRJr" +
    "MPFiePYd/fOSG7Tyh4/7dCs1FkENbGb6vq5B+JU7h9nTUG6AKLyNBDs3VZED" +
    "Q1iTVReh3qmbdhMvB+2AOYusVWINJl4Mz75Dz0v239X21HuzYR2+97YkamCz" +
    "Iw2m770w2S+TvI0Eu9pU1JeANVl1Eeqdumk38XLQDpizyFol1mDixfDsO7pz" +
    "kneS970MEtbti55KoAa2CtZ38jZc7W7zT1b3cV0g36MxCGPQnsMqYnp2C8fn" +
    "uoD27cA19+5/GSR/CNfpqylLoga2EtavCjRc9c6Lzc7DsX9tLr12C8dnOzcX" +
    "uWlr/Qpiw1b4j9AQamCrMXSjV/6aXPseQR2Q2lx67BaOz3ZtLr+5bwi/vLve" +
    "cw1b7f6KhRrYqqS8TKrNpcdu4fhsx+ayXV8GETWwlRl6mSQ32+QrNOUvzrbh" +
    "Hg7UWz60b1c21uLa+8zfHc691bDVXwYRNbDVkZdJff9NEuQ18v/aLoeGjYJQ" +
    "b/nQvk35tbtsPFu5g95PDdvhZRBRA9uFvg8+CvJLj/LGO26gLQcbBaHe8qF9" +
    "myEvga48cG9ls36iuQRqYDvR97GBBnmpJN+vwQ21ZWCjINRbPrRvE+TZ7a/0" +
    "fOCwQT5Yyz23nVAD25Ghm72CbKJr7jO/J5PN3oD2EjCHB/3XFFn7Nqueh3yK" +
    "eeglkDxb2YpviktFDWxX5DUxN0kb+T5T+TIqbrRolnEgmMOD/mvKujSXq2+8" +
    "VL7ynfTeaLOVPhs0FjWw3en7jpgGeal0jZwNvYwDwRwe9F9TVt1cJKf3Emi7" +
    "/ScoBjVQCVeS9yF4L5XkHb5JTWYZB4I5POi/pqyqucj1levsvQR6yam1sVio" +
    "gcouvJdKgrwL81fvOn8j3k72LEA7nhWT9hhSY1AfwxQxCPUe9HeQl79D765t" +
    "qC+BhlEDFY33UkmQ1+I7mww3dw7c9J49htQY1McwRQxCvQf9e4htKpv5e22X" +
    "iRqo2Mjdf++l0s4mcxdjg6fCze/ZY0iNQX0MU8Qg1HvQH8gfhZimIi+BtuOb" +
    "4XJRA5VhUpqMfEGV2uix8BB49hhSY1AfwxQxCPUe9F8gTcX7709tKvmogUoc" +
    "sU1GbgbKX8Wr3mX+H4dcxL+NNC4XI84g9M8hNSb1lg/tHvQHcj2sn0olcn3r" +
    "+1XyUQOVNOQ/SzH3ZAT5WMEv72Echghqc0mA/htcZfe4ZylCbSplUAOVfGKb" +
    "zP+4w3yjXyXh4NTmksDCTz6hLOss681rYFGbSlnUQGU8sU1GkJdN8sE372VT" +
    "bS5xyNrIy56+71OxkOu1Xb5jZZmogUo55H0QQ1/vQOQvrNwLkL+20nA6yFgb" +
    "2i3NWBjfwvOhnVAf40N2n7/kTGkoQn2fyrSogUp55K/i0BdVWUijkcMih8Y8" +
    "cDyQlmYsjG/h+dBOqI/xudO8Ccv6xL7kaZBnKfWlz3JQA5VpkbeKD32XTB87" +
    "m03fM5vIQ5kE41t4PrQT6nt8cpuJIPdS6lv0l48aqCwPee9EzL+zLdQzm55D" +
    "OQoeegvPh3ZC/cKneZmT00wEeTlaX/asFjVQWQ2p92cs5OawHMjOM5wx8NBb" +
    "eD60g6aJNOQ2kwZ5+Vlvzq4HaqCyeuQpfMp/nLYzsk713bPriRqorB9yeGqz" +
    "mSP3q2Q96rOT9UcNVNYfOVw5N4U3I7WZbF7UQGXzIS+jmmc3uTeIV43cb2pe" +
    "4tSXOVsDNVDZOshfezmocrN4XV5WSR1y07U+G9n6qIHK9qFpPkQaQBu+BJNn" +
    "R9QwRm0eFTVQqVQqJVADlUqlUgI1UKlUKiVQA5VKpVKC/w8vzUrHpGpR2wAA" +
    "AABJRU5ErkJggg==")

STEP_IN_DISABLED = ("data:image/png;base64," +
    "iVBORw0KGgoAAAANSUhEUgAAARcAAAEXCAYAAACH0wDUAABCRklEQVR4Xu2d" +
    "e5sURdK33+//DZ5dAQUHUDmJCAgiIOdVEFRcBFEBD8ggoojuPu4+/XZUTU9X" +
    "3r+oiqru6tNM9nXdf0xmZJwyMqar+vT/Ph4M/l8mk8n0jQxkMplMH8hAJpPJ" +
    "9IEMZDKZTB/IQGb78eGHHw7efffdhH379g3+53/+J+TVV1+VtadPnx7QRmb7" +
    "IQOZrYUddDvwbAqL5NChQ7kBbQNkILOadHm2sayMngUxtsxqIgOZ5cf+69tB" +
    "5OHcquSGs5rIQGb5mGUzOXjw4ODYsWMJV69dK7h29eom3z16VPBoyNXh34Q6" +
    "DNrqA8tDvqRaDWQgs3jsBmtflzij5mEN4JNPPimaw59//jn473//q/zf/yX8" +
    "33CMyBoCHf/9Pxv77+DRd48Gt7+4PWxaV4vmcPDQQfF1EnKzWV5kILMY7CYn" +
    "D05b7IBZAzl//nzRRB4+fDj46aefBv/5z3/656+Uv/6TQvlo/tkvvwweDP29" +
    "MvTbsDimeZZmTZm5zSwGGcjMD/uPy8PRBjt8p06dGty4cWPwy/Bw8sDOlJ6b" +
    "C+dHMhbX7du3i4Y56bO4fK9mschAZrbYJU/X/8zVZvLTT4+Hh+8vOaRzY07N" +
    "hVSbTdf8GZZ37kVmtshAZjZ0/e9rlwdpMyF6AOfCgpoL1zweXvZZfqzpdmk2" +
    "+bJpfshApj+6vHnNDsi5c+cHd+/eG/zv//415H+b+Uv566+/GhEd4C9A/YUN" +
    "yghmp4LZrcD19LGNn9Rp/Pj48eDKlSudGo3d5+KeZfpDBjLT0+VZiv3n/fzz" +
    "zwe///4SB9M5VMkBU3hIiegAPPjUv8zNpcrdu3eHjfqc5LoOa0jcw8z0yEBm" +
    "cto2FXt5+Pr164Nnz57VH0oeKOIdfOegdjm0PPjUvyrNZST3+++/F4372Dvt" +
    "3nOTm0y/yECmO22eiu/bu7d42v74xx/bHUqZ5wFTeEiJ6AA8+NS/as1lHNdf" +
    "RSO3/O/bG/8DyE2mH2Qg0542TcWentvTdB4qHgA5lDLPA6bwkBLRAcRHzwZl" +
    "BMSBg8/19LGNn9QpQN6aS5XHPz5ufdmUX2WaHBnIxLRrKmcHP//8dPDvf/+r" +
    "4F/CvxNGcvXyKf8u1qSIzL8AbMj6f6X824N2aSOQp4+0WWLjYyK/Oc/cis3C" +
    "7r8GT58+HVy+fLnVTeDcZLojA5l6WHAe586mTaW+WaQHIJZP0QOmh0gOPmzI" +
    "ehxyaRROsxAbgTx9pM15NpcRv/32W24yM0AGMkp0o9aK0orz5+F/Qv8QO8WN" +
    "AxDLp+gB00MkBx82ZD0OuTQKp1mIjUCePtLmIppLwVDutxcvWjWZfE+mHTKQ" +
    "GRO9T2XUVF4M//M1H2KnuHEAYvkUPWB6iOTgw4asxyGXRuE0C7ERyNNH2lxk" +
    "cxlhTebjj68P9u7dK3teJb9PphkZyJSwkNhULl26NPj111+LTxhntgL/AuX4" +
    "p59+GjYZ1k6mRAa2O9ElUG4qWxW/uYz4+OOPGy+X8qWSIgPblegTyu+8885g" +
    "fX1dii6zVWhuLob9Uzl79qzURpX8SewxMrAdif4j3blzRwots9WIm8uIr7/+" +
    "Ol8qtUAGthPRFzRdvHRx8MvzXwZ//PEHeJnwcjgW8jKFOv54Sf5IeFnYGSPr" +
    "bRw2YmxNFcwzhiIOriGBDcThIfl+iVxQJ21SH9aXpPmWOAMdZvfixYuNl0rb" +
    "/RPYMrBdaCqKo0ePFl/LWFvsxVjlUEthOuAAUAeLXYqZxe5AGzHVA+qsZwxF" +
    "HFxDAhuIw0Py/VIPdqNN6sP6kjTfEmegY2TbvvHv5MmTUkNVWHvbBRnYDnDz" +
    "R1jDuXXrlhYWi70YqxxqKUwHHADqYLFLMYtPCm3ElAek/pA6yBoS2EAcHpLv" +
    "l/7BrrVJfVhfkuZb4gx00If795svlbbj9/zKwFam6TLInuLat515B0CKvRir" +
    "HGopTAccAOpgsUsxi08KbcSkB0TmGUMRB9eQwAbi8JB8v2w+2GKT+rC+JM23" +
    "xBnoqPPh4sVLUlsjtttlkgxsVeoug2z8iy++KD6eP0te/P4i4fcX5PcUk0lQ" +
    "nb0jPkwP435RjAW8SFlILgDj4Hx1Lx8+eDDYu7YmtTaCtblVkYGtCDd3xIED" +
    "BwaPHz/WQpkBUpy5udSz4s3FePbzz433YrbDZZIMbCWiyyApkBkixZmbSz1b" +
    "oLkUDMf/8Y9/SO2N2OqXSTKwVVj0ZRCR4mQhysFewIESH6aHcUsj8dhCzcWw" +
    "35FqutnL2t0qyMBWgJs34q233hr8+OOPxUfsU16kvACcB/bBxSq/vVBeFHL1" +
    "iE9cP/QjxcZIKkOdoU3Ki03LB3zjumnnPRnAuLvuVwntYp42K3lzc0cfLF8V" +
    "+Z+Hl0knTpyQmhyxFb/KQQZWGdsgbtqICxcuaEHUFhbgPMjNpcK0854MYNxd" +
    "96uEdjFPm5W8ubmjD5YvrhnquXbtmtTmVm0wMrCq1DWWXbt2FT+mJcXQWFiA" +
    "8yA3lwrTznsygHF33a8S2sU8bVby5uaOPli+uGZD14MHDwZrNa8mbaWvcZCB" +
    "VaTuQ4f1l0GEhQU4D3JzqTDtvCcDGHfX/SqhXczTZiVvbu7og+WLayr67DLJ" +
    "6pM1u5UajAysGnWvCNnGPV1fLz7JmvDcgTK/Pgfp/PPnwMYq/Pr8uRLYeA44" +
    "H+uLET9D1A/qCP2mzkni6LqmhbzGwT0McHQqzAX5dXDmzBmpXWMrvJIkA6tE" +
    "XWM5cfx42Vi8wmKRuIWiRVAlN5cqgd/UOUkcXde0kNc4uIcBjk6FuSClXF2D" +
    "WfXviJGBVaHupeYz77/fXFgsErdQ/CIYkZtLlcBv6pwkjq5rWshrHNzDAEen" +
    "wlyQsay94MBaXvUGIwOrQG1jGf4HCAuLReIWSn0RGLm5VAn8ps5J4ui6poW8" +
    "xsE9DHB0KswFSeVv3LghNT2CZ2AVkIFlp66x2MYUmxQVFovELZTmIsjNpUrg" +
    "N3VOEkfXNS3kNQ7uYYCjU2EuCOW3VoORgWWmrrHY7y7bJ5pb8dyBMtuG54Dz" +
    "s+f50C6hTMgW20/7pjt7CwXrfNUajAwsK15jsQ347LPPZHMaYSFugWKcnNxc" +
    "lpWt0GBkYBnxvpHfEm8bwE0JYSFukWKcjNxclhmrb++9MKtyk1cGlg3v5eaJ" +
    "G4vBQtxCxdid3FyWnbpnMKvQYGRgmfAai2G/IfPzs2cF9r0ZjZhMhZ+f/az8" +
    "/Czh2TNbN4bzAvRxfQH9EiyWCrIe87LebJc5GUO/kAtb0wD1lzYA13GeIHfU" +
    "34oilnqiPBhRLsQmYBzU70Ed9IF7PPL//v37boNZ9jfaycCyUPdZoWpjyc0l" +
    "JTpUkgtb0wD1lzYA13GeIHfU34oilnqiPBhRLsQmYBzU70Ed9IF7XI3BGgzP" +
    "grHMHxWQgWWgrrFcuXwlSXhuLinMjfqFXNiaBqi/tAG4jvMEuaP+VhSx1BPl" +
    "wYhyITYB46B+D+qgD9xjxmH/WHkmlrnByMAywOQZ9uFEL+GyYYRF5Gw6C0WK" +
    "lYVEWEQe9EtAccl6Fh/Xm23mh34hF7amAeovbQCu4zxB7qi/FUUs9UR5MKJc" +
    "iE3AOKjfgzroA/eYcVhsdQ1mGb+uQQYWDZM2aixPnz7th3UHyhDIrz9NEfkJ" +
    "mIXOrszDh3XLXwXOF3Tdn2WAPs/Q73PnzskZWcYGIwOLhMkyjhw5IsmdChZA" +
    "myKA/CwO4Sx0dmUePuTm0g91XzPCM7VIZGBReG+Se/PNN4vvY2Fip4IF0KYI" +
    "ID+LQzgLnV2Zhw+5ufTHsjcYGVgE3kvOM2ksBgugTRFAfhaHcBY6uzIPH3Jz" +
    "6Rc7Jzw7y/IStQwsAibHXtO/e/fu4MmTJw7rCevDsSpP1oGsV9bX11OoEzaF" +
    "9ZT1wq8U8QtriPpAYj+iNYyb87peoZ+Eccu8C/18ksA4qbMNtKE+pDBXhPI+" +
    "tAlYIy3Wf//DD4PXX39dGswy/C6SDMwbJsWw33rRxPoJlqIJN0hhoYhOZ1MT" +
    "pNgV8QtriPpAYj+iNYyb87peoZ+Eccu8C/18ksA4qbMNtKE+pDBXhPI+tAlY" +
    "I23WD23fvXdPzpDBszZvZGCeePdZTp065SS1PsFSNOEGKSwU0ckNJZVCL4td" +
    "Eb+whqgPJPYjWsO4Oa/rFfpJGLfMu9DPJwmMkzrbQBvqQwpzRSjvQ5uANdJm" +
    "/UYOLl3yf6OaZ26eyMC8qLvP8v333ztJrU+wFE24QQoLRXRyQ8nGBo+LXRG/" +
    "sIaoDyT2I1rDuDmv6xX6SRi3zLvQzycJjJM620Ab6kMKc0Uo70ObgDXSZn0l" +
    "D8fefVfO1CLvv8jAvGAS7D7Ll19+Ofjpp59SHqc8BpSP5l1gQ+YDHgPO+zKP" +
    "AeUfJ/z0OIX6PLvUofLNPkheityka+y3tqtEfkb6Sp0/pXtIxE/YFZ26Rv2i" +
    "jkBe5plr1UEkTsogbvpAP7777ruluv8iA/OAwRvXrl3T5HoJDjYkmneBDZkP" +
    "aNrwepnmAyCFGhxazy51qHyzD5KXIjfpmtxcRvPMteogEidlEDd98Pywf9A8" +
    "WwbP4DyQgVnj3Wd577336jeDCQ42JJp3gQ2ZD4g23JdpPgBSqMGh9exSh8o3" +
    "+yB5KXKTrsnNZTTPXKsOInFSBnHTB9ePoe8XL16UM7aIBiMDs+Rd55rwjTfe" +
    "GDz67lH9ZjDBwYZE8y6wIfMB0Yb7Ms0HQAo1OLSeXepQ+WYfJC9FbtI1ubmM" +
    "5plr1UEkTsogbvrg+rGxD8eOHZOzNu/7LzIwSxis3We58+WdwY+Pfyz5Mebx" +
    "j48TOL8IHj9O4fwkPAacnwzLV5Wu8zNgtPdVKLOU9JGrZh1SA8yTl6uN8YeP" +
    "Hrr3X3gmZ4kMzArvcujqtavNiXLIzWUamos5np8BPCw95W/29JGrZh1SA8yT" +
    "l6vKnP3j5pmbZ4ORgVngfT/LO++8EyfKITeXaWgu5nh+BrAGesrf7OkjV806" +
    "pAaYJy9XmP/ggw/k7NntCZ7RWSADs4DB2eWQfbMWEyGJcsjNZRqaizmenwGs" +
    "gZ7yN3v6yFWzDqkB5snLlTO/qMsjGegb781y1k3rEhGRm8s0NBdzPD8DWAM9" +
    "5W/29JGrZh1SA8yTlytn3n5+h2dwHl/wLQN9w6Ds1aEfvv++4PsfUn744YcQ" +
    "+6BWCvSY3gojW2ObXP+Dynz/Q8IPhW9jaEPkPSSO1O/IB/os854NzgdIXMxt" +
    "ET9tpGtUJ33QWInECsQG59sQ6BDCOJE7Jy76ILlBnQnU5/hRZ8NuQ/As8qz2" +
    "jQz0iXcT99NbtzYTExWuh2w6dEQbrOttUyATbDptiLyHxJH6HflAn2Xes8H5" +
    "AImLuS3ip410jeqkDxorkViB2OB8GwIdQhgncufERR8kN6gzgfocP+ps3Lv3" +
    "lfsLAjyzfSIDfeHdxD158mSSmKhwPWTToSPaYF1vmwKZYNNpQ+Q9JI7U78gH" +
    "+izzng3OB0hczG0RP22ka1QnfdBYicQKxAbn2xDoEMI4kTsnLvoguUGdCdTn" +
    "+NFk48yZM3ImZ/nl3jLQFwzCuuaDb79NEhMVrodsOnREG6zrbVMgE2w6bYi8" +
    "h8SR+h35QJ9l3rPB+QCJi7kt4qeNdI3qpA8aK5FYgdjgfBsCHUIYJ3LnxEUf" +
    "JDeoM4H6HD8iG/O8uSsDfeD9/Or58+cH3333CHwX8ghw/rtHgPOt6OYXfXr0" +
    "KIXy84J+0E/KhzC3fcTWQp+9Y7sK5xcC/GauRd5hEftBmzdv3pSzOaubuzLQ" +
    "B3R+//79G4nodoi95HC+a7J9uvlFnyYptFlAP+gn5UOY2z5iq9Fnb13f/PoC" +
    "fk2D8xUHfWA2xb864DdzLfIOi9gPz+aJEyekwczilwNkYFq8m7i3b9/eSES3" +
    "Q1yXnISOyfbp5hd9mqTQZgH9oJ+UD2Fu+4itRt+ff/45mPfDbIp/dcBv5lrk" +
    "HRaxH57Nb775ZrBz5045pzzL0yID00KH33///Uoiuh3iuuQkdEy2Tze/6NMk" +
    "hTYL6Af9pHwIc9tHbDX6cnNpAXPXwm6dTbtNwbPa97MXGZgGPmux7vj1118P" +
    "Hj58WPLoUcpDsiFX5RHgGs7DxqOhjiqivyDSmRLpfPTQ7KZQhjo5/8jsVOC8" +
    "rHf8EiwfFaiT8sxlCewydwJtMC8li2ou9G+c3zRu9bs5rkKGueOayl54+yG5" +
    "pj5njexhA3v27JEGwzM9DTIwDXTUru3SZDExRBMgCeYazsNGu2RHOlMinSwy" +
    "rxipk/O5ucz+sd2bi/e9u30+e5GBSfFeIbJvxUqTxcQQTYAkmGs4Dxvtkh3p" +
    "TIl0ssi8YqROzufmMvvHdm8uxiyfvcjApNBBedZiSGKIBi8J5hrOw0a7ZEc6" +
    "UyKdLDKvGKmT87m5zP6Rm8tD93enebYnRQYmwXvW8s87dwYPHjxo5lvyrRKu" +
    "SfkWPHhgOqpAnwN1fDtcV0V1tiCKS6AOziv0O5wH35pMBfF5iOgQGyZTQXSC" +
    "jfj+/PMPnv2ZP/74449NPzvnm7nhfBskF5xH7h84e0SiPQX3v7ovrxz19b4X" +
    "GZgENpbjx4+7gQhMLjfM2zRZk6LF37FoHqiO3FzGiA6xkZtLayQXnEfuHzh7" +
    "RKI9JUMZ7zenecYnQQa6UvesxQ2EMLncMG/TZE2KFn/HonmgOnJzGSM6xEZu" +
    "Lq2RXHAeuX/g7BGJ9pR8O7tnLzLQFTaW0bMWNxDC5HLDvE2TNSla/B2L5oHq" +
    "yM1ljOgQG7m5tEZywXnk/oGzRyTaU7IhN4tnLzLQBe/b/G/cuD7crG8Kvvnm" +
    "W2BjXaGOlG+HMlVkvflRxdEha4L5zjYLu1PStz6HMK4+qInDDvq8H2ZzZH9U" +
    "s+PaTfm2qLUxnF8WJt3De/fu9f7sRQa6wMZy4MABbFDzIW0HdaSEyZRiVh2y" +
    "JpjvbNMp1s70rc8hjKsPauLIzaUfptlD+512nmme+S7IQFvszTZ0pPqsJTcX" +
    "QJmu9K3PIYyrD2riyM2lH6bZwy+++ELO9DTf9yIDbaETfNaSmwugTFf61ucQ" +
    "xtUHNXHk5tIP0+6hd6uDZ78tMtAWOnDhwwuD+19/nfD1/Wbuf30/wT6HRO6b" +
    "XBVZ0xW1IdBPwHnaoI8FosfGxnwt0EYLuIZAnj4xDg9ZA78ZN33Q+ZI/Xr7k" +
    "2Z/54+UfL+v3x/JTgXG0gXssRDYk9wrXUCfzHcV585Z+3wvPfltkoA1ed7v7" +
    "5V1xlIETBs7i9w6ArumK2hDoJ+A8bdBHd1OlSAhttIBrCOTpE+PwkDXwm3HT" +
    "B50vyc1F12vuFa6hTuY7itNk+JGASX8GVgbawMZizcYLjIETBs7i9w6ArumK" +
    "2hDoJ+A8bdBHd1OlSAhttIBrCOTpE+PwkDXwm3HTB50vyc1F12vuFa6hTuY7" +
    "itNk3jv1njx5YA9ogwy0gYavXLniBsbACQNn8XsHQNd0RW0I9BNwnjboo7up" +
    "UiSENlrANQTy9IlxeMga+M246YPOl+Tmous19wrXUCfzHcVpMp/f/lyayySf" +
    "lpaBCL4jt/jOlprAGDhh4Cx+7wDomq6oDYF+As7TBn10N1WKhNBGC7iGQJ4+" +
    "MQ4PWQO/GTd90PmS3Fx0veZe4RrqZL6jOEdy9gINGwx7QYQMRNDge++9N/jq" +
    "q68K7oHR+Jh7gPOricbNOJ1Y76XYm5iqhOvbABsyv0S8XERzGdqkH3XoHnen" +
    "Dx3zwnurCXtBhAw04Rn85JNPNh2Kk9fDgVlCNG7G6cSam0tCbi7LxZ07d+Ss" +
    "d/0Bexlogl9jaZdIVYfi5PVwYJYQjZtxOrHm5pKQm8vycezYMWkw7AlNyEAT" +
    "NHTmzJnEmTh5PRyYJUTjZpxOrLm5JOTmsnxcvnx5Ps3F+9Tkp599Nrg7PAh1" +
    "8MDcvXs3wGTAvbvNUB467wGVH/u7CecBdd4rxsZQvrTh+F6hq07Ol1AHYqdd" +
    "G6sg8i7qSwrkW9pcVHOpi7VdLurlvTU8D9w/5or67tkYkNplvgn2S3wA/DBj" +
    "l/e8yEAdbCyHDx92AkthMplsRYOT5BDKc0OByo/9zc0F8i7qSwrkW9rMzUVr" +
    "hPrYWObRXOz33Xn22RvqkIE6aODcuXNOYClMJpOtaHCSHEJ5bihQ+bG/ublA" +
    "3kV9SYF8S5u5uWiNUB8byzyay/XrN+bfXD799FMnsBQmk8lWNDhJDqE8NxSo" +
    "/Njf3Fwg76K+pEC+pc3cXLRGqI+NZR7NxeClkd0iYX/wkAEPfpZo9+7dgy+/" +
    "vFP8dEiVO8OxKl/e+TLhTiEzhvPU14bYZvP8pHYT7pjeMYyzr1hDJHb4UOzZ" +
    "mDsmU0XkZ0BNHn7//Xee/Zk/zGZdrgj9Zu4kzoIo3821SR9kvWs3tcnaFPlo" +
    "fojdAqme/7ZfIiUDHnzWYj8bkptLhdxc2lOTh9xctDbpg6x37aY2WZsiH80P" +
    "sZ9kZg9gj/CQAQ8qvnjxwobzqRNdk8V56mtDbLN5flK7Cbm5tKcmD7m5aG3S" +
    "B1nv2k1tsjZFPpofcv369fk1l9u3P99wPnWia7I4T31tiG02z09qNyE3l/bU" +
    "5CE3F61N+iDrXbupTdamyEfzG0xy30UGiH3NXVXp3r17B//85z83uJNwZzhW" +
    "ZSy3wR3A+T6YwEbod2f5NC8llOlIm7jayHSAcXqxRvPi07CAEzbkFtVcWscx" +
    "A2KbrCEH5Fd0Mv+BDa4f+XX06NGkD7S57yIDhM9a7KdD2jomgYSB9sAENkK/" +
    "O8s7RSAyHWkTVxuZDjBOL9ZoXnzKzWWT2CZryAH5FZ3Mf2CD60d+nT17NukD" +
    "BnsFkQFChRcuXGjtmAQSBtoDE9gI/e4s7xSByHSkTVwNMvYbNb/88kvxFFfW" +
    "1cA4vVijefEpN5dNYpusIQfkV3Qy/4ENrh/5ZR9QZi9gryAyQKjws88+a+2Y" +
    "BBIG2gMT2Aj97izvFIHIdKRNXA0y1lzsYT++bl/ELGsdGKcXazQvPuXmskls" +
    "kzXkgPyKTuY/sMH1Vb/sLSjVXhB9SloGqvB+y9revYPbX3wx5vZtYGNjvhBu" +
    "JyS6hnzxxW0Fa4j4AJ306fYXJpMiOh2ZVJ5xpYhNxy7XEMZhP/tQRfTbOtOb" +
    "MJa3XxUcPf7zn/8MfvjhB1mvNqlP8yvz3A+BPpcsorm8GNqsjQNwfyjvwViJ" +
    "1J2ANci957forMRQxgG43qXcI953iZ69yEAVKnr3+PE0uCAZsiESeJAoLxnU" +
    "QbgBskFxwjlPNK4UsenY5RrCOPpsLqPHs2fPiv9WYx9pk/o0vzLP/RDoc0lu" +
    "LsyTsx659/wWnZUYyjgA17uUe/TBBx/Mrrlcunw5DS5IhmyIBB4kyksGdRBu" +
    "gGxQnHDOE40rRWw6drmGMI5ZNBd72G/32Ncdlj7SJvVpfmWe+yHQ55LcXJgn" +
    "Zz1y7/ktOisxlHEArncp9+jGjW6fM5KBpubCwKJkyIZI4EGivGRQBxEfwUaS" +
    "mxLOeaJxpYhNxy7XEMYxq+ZiD7tM+v77Hxyb1Kf5lXnuh0CfS3JzYZ6c9ci9" +
    "57forMRQxgG43mW8T3y/C3vGRM1lx44dg88//7wjnwHObxWWP067iRs9fv75" +
    "56KAuHYevHjxgu7M/GE2xz4s/x4uA2+88UbSXN59t/6mrgyMsEVVJaaUhmK2" +
    "y4Ytf5xtmos97DLJvoWM62dNbi6rAftC05vpZGAEvy/XlNJQzHbZsOWPs21z" +
    "sUd5mfS96JglubmsBmwuBntH2FyoIDeXJpY/zi7NZfSY52VSbi6rwaVLl/pv" +
    "LqaUhmK2y4Ytf5yTNBd7zOsyKTeX1aDLJ6RloK65XLlydfDpp58lfPbppwn2" +
    "hd0JNlZB5Dk/XBPx6WdmZ8xnhR9j6GPkU2kX0E/qgA9i04E2xIdKDB70gT6W" +
    "+VS7I+wXFid92GXSd999V/rJXBH6xFzV5PLFi8U0l826CvaD88wv5Uu4PwC5" +
    "Ya1rbqk/9os2BMirDwp7A3tH5+ZCJ8qEspAsmAoIXOQ57wRCmBxNNgh8Ku1y" +
    "E4O4gg3yoA3xoRKDB32gj2U+1e6IaZrL6GGXSfYSKWNpzh1hLOX4ixe5ubDW" +
    "NbfUH/tFGwLk1QdlbW0t6Q11X78gAwZ/RsSU0YkyoSwkC6YCAhd5zjuBECZH" +
    "kw0Cn0q73MQgrmCDPGhDfKjE4EEf6GOZT7U7oo/mYg+7TLLvf2U89bkjjKUc" +
    "f/EiNxfWuuaW+mO/aEOAvPqgHDhwMOkP9jEh9pDa5sI7wvYyNJ0oE8pCsmAq" +
    "IHCR57wTCGFyNNkg8Km0y00M4go2yIM2xIdKDB70gT6W+VS7I/pqLvYYXSYx" +
    "Jj93hLGU4y9e5ObCWtfcUn/sF20IkFcflGPH2r1iJAMGFx479s7g1q1byk0Q" +
    "zRPI37yp6JqbAbFOweQqUIeS2uy+/pYTVwTj9OCaMffv3+fZmvrx9OnTgd38" +
    "bPJBclMT92+//Ub1M3+YzVs3b5Y4OWsEcdws6iCFayQXHfZvftAn5fTpU/01" +
    "F1OmTtySBIfzBPJy6ClfrNFgU2KdgslVoA4ltdl9/S0nrgjG6cE1Y2bRXOxh" +
    "P89x9+6XtT5Ibmrizs1F5RcDfVIuXPiwv+ZiytSJW5LgcJ5AXg495Ys1GmxK" +
    "rFMwuQrUoaQ2u6+/5cQVwTg9uGbMrJqLPf7666/Bo0cPXR8kNzVx5+ai8ouB" +
    "PvmwR7CHtG4uN25cd5y4JQkO5wnk5dBTvlijgabEOgWTq1Bdb6/t28FM+Srh" +
    "q+FYFZV3+ApwXkht+nDNGPv+llk/ysukz9P8M7eynyW5uaj8YqBPPuwR7CGt" +
    "m4t9xV0rboJPbgJnTQR1EsoLbXyol7FXRvKj/cMuk+yb7Ov25+bwIFcZjS+q" +
    "udC/TT+HdVCF861grVq8VSg/A+I46mu/SYY9gj0kN5cWMrm5dH/YZdLDhw/d" +
    "/cnNpQLlZ0AcR33tN8ns378/N5d2PtTL5OYy+WP96Xrx8mg1n7m5VKD8DIjj" +
    "qK/9Jhk2F++NdNJYcnNJZXJzme5RXCbdubOZz9xcKlB+BsRx1Nd+kwybi/e9" +
    "LtJY2Fxef/31wfUbNwY3rl9XbqTYh5qq3Lhu68Zw3vR2RnQQyqfQ5xIbH1PV" +
    "d/feXdZkfnR82GWS/fqAVxOjPfj111+5bOYPs1lfy811o/MOI911NoDmJtBX" +
    "nAHUOHWKzY1zsQnlHbvA5Pbt3zd9c9k37FDmBINyk1UEO4bJ4rwG2gLRQSif" +
    "Qp9LNHkjcnPp77G+vl68spKby4YOwPMS6ivOAGqcOsXmxrnYhPKOXWByEzUX" +
    "vvU/N5fcXPp82GWS/QZObi6sW5NJz0uorzgDqHHqFJsb52ITyjt2gcnxZ0Zy" +
    "cyk2TP32kjciN5f+H6PLpNxcUnheQn3FGUCNU6fY3DgXm1DesQtMjs3F+7rL" +
    "uLns2zf4+OOPty3286f5MZvHkydPipuDludFNRfud6Ydb7/9dtInDPaSsLmY" +
    "EireTuTmMtuH/aSIfZVmbi6rxUTNxZ6p5OYyJjeX2T/sMsm+J2bej9xcJmei" +
    "5sIFubnk5rJVH7m5TM7Zs2f7aC5HBh999I/BPzz+QT4C6bzpqfKPjz5KkfUf" +
    "DT6ydVNAnz8a2lFsfExV3t4Alh9b82HNZVQDrFWBtSporYkOIHXHecCz0eZ8" +
    "iE/0GzZl3onN8tXmd6Nzcymw8TFV+dxctu4jNxcnbs47sU3cXA4dOpSbS4Xc" +
    "XGb/+PNffy7kay5zc3Hi5rwTm+VronsufLXo4MGDcuDqk8fg03lJJoOQ9XHy" +
    "IuizNpbcXBb5sF8UsPdNPP/1Oadm/sjNxYmb805svTUXe/WIB64+eQw+nZdk" +
    "MghZHycvgj5rY8nNZVGPRw8fbeY5NxdnHvBstDkf4hP9hk2Zd2Lrrbns3bt3" +
    "cO3atXZcTbl6LYXy0Xyp8ypotkFUn9K0xt6qnh/9Pv7888/iW+SruX7+fP7N" +
    "xWxu1kFUJ8E8a8jj2rWrCTo/CalO9cvsjBF50Rdjvh4+ckSehLCX5Obi6KjK" +
    "5+bS7+Pp8DLoo48/llzn5uLYaMVyNJdWny0ycnMZk5tLfw/7drq6XOfm4tho" +
    "xWKai/WFqZuLfSCJymuRwJqTF82XOnNzWfXH6DKoac9zc3FstGKFm4thP0J/" +
    "1eHKlSsBJlMF81eByDtrOnIVcN6jGuMXt79gTeZHh4f9IoDdKGSOyaKay7j2" +
    "mtHaJ7pmang+PLhGSP3keSC6vmKrYjM3lystkydrcnPp42Ffq8Dc1pGbiwPP" +
    "hwfXCKmfPA9E11dsVWyyuXz44Ye5uXDeIzeX6R52GWRfzM28NpGbiwPPhwfX" +
    "CKmfPA9E11dsVWzu2bMn6RHsIbm51JCby+SPtpdBJDcXB54PD64RUj95Hoiu" +
    "r9iq2GSPYA9p3VzOnTs3uHT5snCZXLqUwnlw6fIl4Ni4BERHRGyDXL5svldA" +
    "XJFO+lgCnZzvbIP6KJ/qu/355zxbvT++/fZbjSvgksU65JdffqG6mT/M5sg+" +
    "c0lGcpvyQV16cH8uXbL4x4hOwBoooF/0PdAhdefg6WSPYA9p3VxOnTolTpUF" +
    "DuCozANJNvSXwQPRERHbIJpMbECgkz6WcJMw39kG9VE+1TfL5mKXQfZToBJT" +
    "C0YFnJsL9DmwBgroF30PdEjdOVDnhQsX+msu9lZfOlUWOICjMg8k2dBfBg9E" +
    "R0RsgzCZjCvSSR9LuEmY72yD+iif6ptVc7HLIHt5UuJpyaiAc3OBPgfWQAH9" +
    "ou+BDqk7B+q0JxvsEewhrZuLfVKaTpUFDuCozANJNvSXwQPRERHbIEwm44p0" +
    "0scSbhLmO9ugPsqn+mbRXCa5DCKjAs7NBfocWAMF9Iu+Bzqk7hyos83nimqb" +
    "Cz8CsLa2Nrh48WLIJcD5zOKwN7H19bDLIPtibdqYhkU1F/qRieHXsnRqLvaa" +
    "dXXhrl27xIBHbi7LS1/NZX19vXi1gPqnJTeX1cGebFT7g/cGutrmYrAz0YBH" +
    "bi7LSx/N5ZtvvhG9fZGby+qwe/fupDd4P0Lfqbm8//77YoTk5rK8TNNcZnEZ" +
    "RHJzWR3YG9g7OjcXe+pzYXi5VOXDDy80cyHFXsKqYpdfCReUC4A6Qx3wiT64" +
    "fgiBDhuroOs1DlkTxo150wkoU7Vv75id5PFk/cng8pXLtfmkTfG7ZR5+ebaA" +
    "5vLs2Th3IagB2T9FYg3qLpx3EJvil8m0hz6wvk+fOt1/c7Gvu5TAkHCBgQMm" +
    "j4GWwaZQZ6gDPtEH1w8h0GFjFXS9xiFrwrgxbzoBZar2J2kuX3/ztaMzzQXn" +
    "xe+WecjNpcW8g9gUv0ymPfSB9X3y5Mnpmwt/HO3NN9/UwJBwgYEDJo+BlsGm" +
    "UGeoAz7RB9cPIdBhYxV0vcYha8K4MW86AWWq9rs0lz/++HNw48Ynqq/QmeaC" +
    "8+J3yzzk5tJi3kFsil8m0x76wPq2JxlTNxd5Ofr11zUwJFxg4IDJY6BlsCnU" +
    "GeqAT/TB9UMIdNhYBV2vcciaMG7Mm05Amar9ts3lyZP1weXLV8pYqa/QmeaC" +
    "8+J3yzzk5tJi3kFsil8m0x76wPq2JxnVvuB9vWXYXAx2qPPnzzdzLuXc+RSV" +
    "P5dw7rwiawhsCpCnT6VfZqcK10XztOHEEfglIDcyLz45MhV7t27e4tmSx/37" +
    "91UHkLgcmVSeufZ5Njzo836YTfpRT5rrtnElRDUQzXtgTdf94XrGyVhfHz7J" +
    "qPaEupehOzcX+wlHca7B0XADcnOpZ47NxX6n+fr167reQeJyZFJ55tonN5cW" +
    "8x5Y03V/uJ5xMtZXXnkl6QnsGRM3l2PHjqlzDY6GG5CbSz1zai5Pnjwp3uIt" +
    "a2uQuByZVJ659snNpcW8B9Z03R+uZ5zVWE+//37SD3ptLgcOHFDnGhwNNyA3" +
    "l3rm0FzaXAYRicuRSeWZa5/cXFrMe2BN1/3hesZZjfXQ4cP9NRd+huC1115T" +
    "5xocDTcgN5d6ZthculwGEYnLkUnlmWuf3FxazHtgTdf94XrGWY11L15Bti/v" +
    "Z89o3VwMdqozZ84U9148zp09B2xszNnhIUlwdAjnwFlbVwHztElEv2dD6Oi3" +
    "rHcI1tDvczZWQdZ7VHy+efNmcaCe/PTT4OKFC4VO2jzL3FLfyJcGKE9YI6Nx" +
    "+1nXeT/MJv2bFOZh4j1rgPra6WzeU/rM+YKN+uD9lrq3/U/cXI4cOaLGNx3N" +
    "zaWdvngN/e5eVKZn7LP9ENn9r75KdNLmWeaW+ipr66A8YY2MxnNziaG+djqb" +
    "95Q+c75gaOfke+3fPDdxc3njjTfU+Kajubm00xevod/di8r0pH5TJ22eZW6p" +
    "D+s9KE9YI6Px3FxiqK+dzuY9pc+cLxja4S2SXpoL30xnX78gxjcdzc2lnb54" +
    "Df3uXlSmJ/WbOmnzLHNLfVjvQXnCGhmN5+YSQ33tdDbvKX3mfMHQzt696U+J" +
    "RPdbWjUXgx3Lvubugw8+GJw5k2JjVc4EfHDmTMKZD9oAHYFNzn9gfhLqQFyi" +
    "E+sjH0tSGepgLuiTYjIBYqMbGoONp34yLkKdwoavi2oudg/RYFz0M8qD7s8H" +
    "UkeyP7Imndf1LWjhVxPcv2IPh+Nd77cYMuDB5mL3XQpHguC5IYSJYFA+0BHY" +
    "5DyLpixw6EBcohPrIx9LUhnqYC7ok5IWoovY6IbGYOOpn4yLUKew4WtuLjqv" +
    "61vQwq8muH/GiRMnkvNvsEd4yIAHFe/fv790JAieG0KYCAblAx2BTc6zaMoC" +
    "hw7EJTqxPvKxJJWhDuaCPilpIbqIjW5oDDae+sm4CHUKG77m5qLzur4FLfxq" +
    "gvtndPmwYhUZ8OB9l507d5aOBMFzQwgTwaB8oCOwyXkWTVng0IG4RCfWRz6W" +
    "pDLUwVzQJyUtRBex0Q2NwcZTPxkXoU5hw9fcXHRe17eghV9NcP8M/rpi04cV" +
    "q8hAHexc9r0O9u10zZwBnCeUb7MmMzndc30GcD7kDNgYX1hzmTSOHpg6l5NQ" +
    "k/8mePbtE9rsDx4yUAcN2EcB6ITStXgp32ZNZnK653rqA1FT3Lm56PxMqMl/" +
    "HW1/RsRDBuqwl56qBuxvOqJ0LV7Kt1mTmZzuuZ76QNQUd24uOj8TavJfB780" +
    "bibNxZ4K0Uh8adS1eCnfZk1mcrrneuoDUVPcubno/Eyoyb+HveWEL0Hbm+nY" +
    "G+qQgSbYXOzduqdPn6pwOuEUOD10NiFZe2ooo9gXAlehzlM2VoU2xSfPBoHN" +
    "4VgCfSCUd6Bf9IE6Oe+CfEbzUR7ocxk71kRxyP746+1nYef9MJu1dRH6zVyi" +
    "Bgq9kGEuA5hbzpfAT0K/T5U1PQb7VZE9eGiyV4lGyEATfIq0c+dOJBDJYLIR" +
    "iCTfgcmgTk0mbIpPng0Cm9xQ+kAo70C/6AN1ct4F+YzmozzQ5zJ2rInikP3x" +
    "1+fmojC3nC+Bn4R+nypruk1zeX0t/da5mTYXg8aOHj1aSSCSwWQjEEm+A5NB" +
    "nZpM2BSfPBsENrmh9IFQ3oF+0Qfq5LwL8hnNR3mgz2XsWBPFIfvjr8/NRWFu" +
    "OV8CPwn9PlXWdNRcjp84Lo3FfGA/aEIGImjQns2ME4hkMNkIRJLvwGRQpyYT" +
    "NsUnzwaBTW4ofSCUd6Bf9IE6Oe+CfEbzUR7ocxk71kRxyP7463NzUZhbzpfA" +
    "T0K/T5U1HTWXtw68Jc2FvSBCBiL46Ui74fPee++15CTg/CT0oPMk4Hxn6NME" +
    "fsEn+8h7FZF3iXzgPKG8R7SG86SUW1RzYZ438w00LsK4bJ9s38ZwXnUsD96r" +
    "w+wFETLQBnY0e3swnfOZRXJ70Mni4nxn6NMEfsGn3Fz6f+Tm4vPOO+/Is5a2" +
    "b5yrIgNtoGH7uQE66DOL5PagE4Ul852hTxP4BZ9yc+n/kZuLj312kGecPaAN" +
    "MtAGu/6jcfv8EZ1UZpHcHnSisGS+M/RpAr/gU24u/T9yc/GxV4GrZ7vtZ4mI" +
    "DLSFzeXNN94Y2Jvqqpw4eSLlRMpJIPJDToJQRzB/8sRJ4UREEUsFztNmC78J" +
    "/eS82HRyJTKBDtqchEin+kDKdevrT3n2Z/4wm/W5SpG4JPceXfeDdZnK0wfP" +
    "D5kPdHB+2ve2VJGBtvCGz84dO3JzGdls4Tehn5wXm06uRCbQQZuTEOlUH0i5" +
    "LjcXry5Tefrg+SHzgQ7Or+1dW3xz8T4OYK8k5eaiPnt+E/rJebHp5EpkAh20" +
    "OQmRTvWBlOtyc/HqMpWnD54fMh/oqM55N3Kbfq41Qga6QEd2796dm4vZaOE3" +
    "oZ+cF5tOrkQm0EGbkxDpVB9IuS43F68uU3n64Pkh84GO6tzaWn/PWgwZ6AK/" +
    "RMqwr8DMzUWhDKGfnBebTq5EJtBBm5MQ6VQfSLkuNxevLlN5+uD5IfOBjtG4" +
    "96xl0hu5I2SgK3TIfpXx+LDpGO8eP55wnGzIbXLcw1mX6ACcb4P4kc5Hcbx7" +
    "3GJthnFZY66i88cT1KZCHcyNysc6uxLZrIt7fX2dZ3/mD7PJHNQhcQDG7ccO" +
    "NmqjDu6nrPd0yDxA/kfjfT9rMWSgK96zl8OHDhWHlIFxw/RQezjrEh2A820Q" +
    "P9L5KA7ZYAfGxU3W+UqBOHHRp9Iv6EFuVD7W2ZXIZl3cubko3E9Z7+mQeYD8" +
    "29jRGTxrMWRgEujY6NkLA+OG6aH2cNYlOgDn2yB+pPNRHLLBDoyLm6zzaZGo" +
    "TYU6mBuVj3V2JbJZF3duLgr3U9Z7OmQeIP82xm876ONZiyEDk2BO0jl79sLA" +
    "uGF6qD2cdYkOwPk2iB/pfBSHbLAD4+Im63xaJGpToQ7mRuVjnV2JbNbFnZuL" +
    "wv2U9Z4OmQfI/7Ehf//735OzO8nniDxkYFLYXOwjAcfePZZybAI2ErAJ57tC" +
    "fW10hnGYjgqUL9ZARnTMAfGp43zBbOJYVHOhH6vGu4Dz0X7t3Zf+kmJfz1oM" +
    "GZgU76nV20ffblGsAV0bQQT1tdEZHjpsIOWLNZARHXNAfOo4XzCbOHJzmYxp" +
    "mou9QjSrZy2GDEwDm4t9k1VcrAFdG0EE9bXRGR46bCDlizWQER1zQHzqOF8w" +
    "mzhyc5mMaZoLf/+5z2cthgxMQ/jsRQJvQddGEEF9bXSGhw4bSPliDWRExxwQ" +
    "nzrOF8wmjtxcJmPS5jLrZy2GDEwLm4u9a/edo0dLhgFVsa/IrLIpV+HoUZOr" +
    "8M7RRrj+HRsLSf0SHUdtrEo6zzjoU+lXqsNe/ktgnIA+ik3zpWMc9EHXO9AP" +
    "6ghs1q1/8uQJz/7MH2Zzcw+5X0DmmUsHiZV7Rp2U57zk1vGDvsLmaN3eGbyv" +
    "hcjAtHjPXt56880yKCavJvAq3DBJXrQBNhaCQqAObCDnGQd9Kv1iEQDGCeij" +
    "2DRfOsZBH3S9A/2gjsBm3frcXHT/ZF5y6/hBX2HT1hw5fFjO6Eo0F4NO79ix" +
    "Y3D07bc1eU7ghBsmyYs2wMZCUAjUgQ3kPOOgT6VfLALAOAF9FJvmS8c46IOu" +
    "d6Af1BHYrFt//sMPB5evXCm4cvkysLExl4djVa5cCcD6ksuDD8+f3/RT9gvI" +
    "PHPpILFyz6iT8pyX3Dp+0FfYtDX8RoNZNBZDBvrAe9+LPQ2T5DmBE26YJC/a" +
    "ABsLQSFQBzaQ84yDPpV+sQgA4wT0UWyaLx3joA+63oF+UEdgM1rfRofGHUAf" +
    "ClIbsl9A5sUnRWKF36KT8pyXvDh+0FfYtKsIns0+3o3rIQN9wQCMQ4cODt5+" +
    "+0iFt1tQlW+7pm8CH44cSeG8xxHAeXAEcL4PZmFjEp3d1wT749DZRsf9mgjY" +
    "oI9HbAyIjgbsQ8W8iWvw7PaFDPQJg7CnY12LYJLC6Z/Ah9xcaplEZ/c1wf44" +
    "dLbRcb8mAjboIxtL1+bifTjRrjJ4bvtCBvrEu7lrPwHbpQgmKZz+CXzIzaWW" +
    "SXR2XxPsj0NnGx33ayJggz6ysXRpLvYLHTyLBs9sn8hA3zAYu7l75MjhQdsi" +
    "mKRw+ifwITeXWibR2X1NsD8OnW103K+JgA36yMbSpbnM6yZuFRnoG+/mrn3u" +
    "6PDhw0WTSbAxcPjwkZShXEIhUwXymBebjg71ARwxPypw3kPWNMd1ZDiWEPjs" +
    "EcZBeeamlQ7GkSI6i7EqnFcZtQmYW8tPFfro5DtC96OFj9QT+KB5APSB+mrw" +
    "riBmdRO3igzMAgZmvPXWW07yFCaKGyIbSnnMi01Hh/oAWMyc95A1zXGxiCKf" +
    "PcI4KM/ctNLBOFJEJw6lzquM2gTMreWnCn108h2h+9HCR+oJfNA8APpAfQ6H" +
    "Dh2e603cKjIwKxjcrl27nOQpTBY3RDaU8pgXm44O9QGwmDnvIWua42IRRT57" +
    "hHFQnrlppYNxpIhOHEqdVxm1CZhby08V+ujkO0L3o4WP1BP4oHkA9IH6HOwq" +
    "gWfPfneM53MWyMCs8J6aWeBp8hQmixsiG0p5zMuGOTrUB8Bi5ryHrGmOi0UU" +
    "+ewRxkF55qaVDsaRIjpxKHVeZdQmYG4tP1Xoo5PvCN2PFj5ST+CD5gHQB+oD" +
    "+/e/IWeu788PNSEDs4SBGvbqkf0kiXHwoIONVzh0EGys3dQRyXtEOjhf9c+g" +
    "/MGDCnUE2HuCUuAHY3DiIPaDV1U430qfyMBPmU8RHyjv6RRUb6OPbaAOEsrT" +
    "xxZ+Cul61oQH14x0HThwYGGXQyNkYJZ4v3VkCbCXySwhcmgNJjPY5FDeI9LB" +
    "+ap/BuXZWHJz2UR8oLynU1C9jT62gTpIKE8fW/gppOtZEx5cM9LFn2Q1bJxn" +
    "cpbIwKyxABm03X+xcTm0BpMZbHIo7xHp4HzVP4PybCy5uWwiPlDe0ymo3kYf" +
    "20AdJJSnjy38FNL1rAkPrjE9e/bskTM2z8uhETIwD7zX3C0hcmgNJjPY5FDe" +
    "I9LB+ap/BuXZWHJz2UR8oLynU1C9jT62gTpIKE8fW/gppOtZEx5c493bNHgG" +
    "54EMzAsGb9gNqPjggmRzWsh7RDo4X/XPoDwbS24um4gPlPd0Cqq30cc2UAcJ" +
    "5eljCz+FdD1rwqMqf+DAWwu/z1JFBuaFvRzGJFhi7P0vdjNqk4OgOufRVX7I" +
    "QXDggG1UBehU+R44aHYqcH5ZYC6GvlYR+RDkuoAy3ZjeJ4M+Eciz7jy4pgeq" +
    "dWjvfueZsqbFszcvZGCeeE/h7P5LksCuG9RV/oDXLFBI0KnyPZCbSwXKdGN6" +
    "nwz6RCDPuvPgmh4Y1eCe3bvlLC3iPksVGZg3TIhhX425mcCuG9RV/oDXLFBI" +
    "0KnyPZCbSwXKdGN6nwz6RCDPuvPgmh6w+tvnfNG2wbM2b2RgETAphj2rKRLY" +
    "dYO6yh/wmgUKCTpVvgdyc6lAmW5M75NBnwjkWXceXNMD9uVPy3SfpYoMLIK6" +
    "+y/79+0fvDlMXspbKW+lWLJTbGwM5QuoU0h9oM633nozQfQ7UIfMQ6fKm50U" +
    "yhCxgVxJ3J7fQHwA8XollmHcQRwetFnJUwF9CGpA9Hs6BOyh2CCw+cabS3ef" +
    "pYoMLArv/os1GHsHb24ualMK05EhYgO5krg9v4H4AOL1SizDuIM4PGizkqcC" +
    "+hDUgOj3dAjYQ7FBKvZqGsui77NUkYFF4r3/xRKYNhhsohRJ/YZ4B6yAOgVu" +
    "eqozOlAe1CHz0KnyKExHhogN5Eri9vwG4gOI1yuxDOMO4vCgzUqeCuhDUAOi" +
    "39MhYA/FBhnbsxc+eFYMnqlFIgOLhsnSBoNNlCKp3xDvgBVQp8BNT3VGB8qD" +
    "OmQeOlUehenIELGBXEncnt9AfADxeiWWYdxBHB60WclTAX0IakD0ezoE7KHY" +
    "IKWt1159Tc7IsjUWQwaWASbNsE5tDWYW7Aecj5h2fV86urJdbLrsB5xfRoZ+" +
    "vrpLn90b9rk9nqNFIwPLApNn2GWTJLwHpi34adf3paMr28Wmywo2lz279TND" +
    "y9pYDBlYFrxPUM+qwUxb8NOu70tHV7aLTZcVay7ehxGNeX3x0yTIwDJR12As" +
    "0Uz+NExb8NOu70tHV7aLTZcVai7et8kZy/KScx0ysGx4X/Bt2Lt49+3bP9i/" +
    "f1+CvaRdZT/gfC+Y3Sqc32e29yfEa/an7E+hvlInabahuYFN8UmJ8h/BGErU" +
    "ty57KPrgY0Gok/nfl0B9un4S1Kb91tDf/vY3qf9lbyyGDCwjlkgmd9Rgok2O" +
    "i6gHUHgyv89ssxFEa1hoKdRX6iTNNjQ3sCk+KVH+IxhDifrWZQ9FH3wsCHUy" +
    "//sSqE/XT0Jqs66xLNN7WZqQgWWlbYPhhsVF1AMoPJnfZ7bZCKI1LO4U6it1" +
    "kmYbmhvYFJ+UaQ8ZYyhR37rsoeiDj6vQXKyuV7mxGDKwzHhvsjPsZeq6TY6L" +
    "qAdQeDK/z2yzEURrWNwp1FfqJM02NDewKT4p0x4yxlCivnXZQ9EHH5e9uVhj" +
    "YY2vWmMxZGDZqW0wO3cN9q7tHbKWsLZ3b0IpA/auNUIda8XYmL2mtwr1r3lr" +
    "SKqDNiN5H64ByJWub0Oqc81irbK3Rf6J2CCMhfPdET97gLlok++6+l61xmLI" +
    "wCpQd4m0c8dO2UApGhZyUcws1hTq0EaBIqF+Ky5ZQ1IdtBnJ+3ANaFHsMalO" +
    "HiiJw8mNIDYIY+F8d8TPHmAuonzXvaV/FRuLIQOrQl2DeeWVV5INlKJhIRfF" +
    "zGJNoQ5tFCgs6rfikjUk1UGbkbwP14Cg2NuR6uSBkjic3AhigzAWzndH/OwB" +
    "5qIp33WNxS6XWPurggysEnUvU1cbjBQNC7koZhYrDgx0aKNAYVG/FZesIakO" +
    "2ozkfbgGNBR7e1KdPFASh5MbQWwQxsL57oifPcBc1OXb+3SzsQovNzchA6tG" +
    "3Rvt7E67vV3a3oAUsQY4//rrawDza4DzM4A++34D+kkoL3GvhWvW1lI43w/0" +
    "i/PdmTqXnC9o9tPs2D9C1u5WaCyGDKwiTQ3G7rxzU0lcWM1F0q7Q+oU++34D" +
    "+kkoL3GvhWtyc6lS76fVZV1jWdbPCnVFBlYZbtIIu57VjR8TF1Z9kRS0KrR+" +
    "oc++34B+EspL3Gvhmtxcqvh+2g1a7z0sW6mxGDKw6nCzRth/Cd38kriw/CLZ" +
    "pFWh9Qt99v0G9JNQXuJeC9fk5lJF/fR+ZnUEa3nVkYGtQN17Beouk+LC0iJJ" +
    "aFVo/UKffb8B/SSUl7jXwjW5uVQZ+7h7957ay6Ct2FgMGdgq2Et43MAR9t9j" +
    "957dm+wBu/fsAWNZX55w/Z7id2WqWLE1YZ/8TrCxKp4fosfGxlBedQY2PbCG" +
    "NgXmKvF3FDt9hR3kUuWJ4yf8oE76HcUt85U47LK87jJoVd/D0gYZ2Ep4vyow" +
    "wv6L1DcLK74qKESRJ1xvxcbi1UOVHrCgeD0/RA8OCNeIzsCmB9bQpsBcJf6O" +
    "YqevsINcqjxx/IQf1Em/o7hlfiOOupeZja3wilATMrAV4aaOsP8mr772qhQj" +
    "G4MUosgTrrdiY/HqoUoPWFC8nh+iBweEa0RnYNMDa2hTYK4Sf0ex01fYQS5V" +
    "njh+wg/qpN9R3Jx/7bXX3N8TGsEa3YrIwFYlukyqFiMbgxQi4Lyu1wPBA0Wi" +
    "4qUPhR+iBweEa0RnYNMDa2hTYK4Sf0ex01fYQS5Vnjh+wg/qpN9R3NW57XoZ" +
    "RGRgKxNdJtnG23+c5cR8q8L5zEJ59bWifppu2m71yyAiA9uBuleTDLtGlsJZ" +
    "CnJzWWasbuqerRiswe2ADGwX6j74aNi1sj21ZQEtltxclhGrk6Z7K9vpMojI" +
    "wHai7mMDI5brUik3l2Wj6ZUgwz5Yy5rbTsjAdqTpZu+oydh/qBGvkmEDqrLr" +
    "1V1KZb3PqyCdFxsir2uiecbB+V1FLCmvvmq+jJE4I/nAh8IP6qRf1BHY2CV5" +
    "MN9SG6JDYh/LRpdA2/nZShUZ2M6wSKpYMVlRFcVMNg58bi66RuQDH5a5uezc" +
    "tbPxEsjYSp8NmhYZ2O7UfUfMCCsuHgY5+CjcNgdks+jrGgFtiLyuieYZB+f1" +
    "gDnNQgjkAx+Wtbm8sqP+VSBju70S1AYZyJS0uVTKzcVkSCAf+LBszcX2OV8C" +
    "TYYMZFJYTMSeydjlkr0RbxP7G+zYsTPBvu+3iR07U6gvsVeLyVXhfIDjl8gE" +
    "aNxt4pjS7x6ILn+MfAnUjAxklOhSSZoMD1BuLivTXNo0lVX+Xtt5IgOZeqJL" +
    "pc0mM3wqzUOkh6yZ3Fym8Lsj9k+hTVPJl0DdkIFMzCRNRg9ZM7m5TOF3S3JT" +
    "mS0ykGlPmyZjNwPLS6ZXEuxGYYKNVeF8D+x4ZUfCKzuAjSXEOqyBVqF8BNe3" +
    "0oFcMbeqL43r739vvkk7Il/+TIcMZLrT5p6M8fe//21Y3GWjiQ6MzPcAG8N2" +
    "ai7WUNo8SzFyU+kHGchMTtsmM3o203Rg5ED1ABvDdmguluc2z1KM3FT6RQYy" +
    "09O2yRibjSY3l/Y6gubySoeGYmz3zwDNChnI9Ie9D8JuBrKY6ygazQZ/swNS" +
    "5W8p1pCIyACZpw7K04cC820M11CnxdQI9BU6SWRjRIeGYuT3qcwWGcjMhqYv" +
    "qvIYH77RwQkagycDZJ46KF89uJugEdCO+OQ0lJ6ay0gHc9dEfpYyP2QgM3ua" +
    "vkumjvGBrGkMxWFD8wAyTx2UL5oJQSOgHfHJaSgTNpdJmomR76UsBhnIzJc2" +
    "L2d7jA7aVm4ukzYTwy5H82XPYpGBzGLoen/GIz24TrMAbAQiL41lRs0FY4yr" +
    "C6dPn84NZUmQgcxy0OUVp+1MvoeyvMhAZjnJzaYkf2/K6iADmdVgkpvCq0hu" +
    "JquLDGRWF3t2M+kN4kVj95vyJc7WQgYyWw+7Wbwsl1XmR77puj2QgUzGGkAV" +
    "XoLZsyPKUEcmIwOZTCbTBzKQyWQyfSADmUwm0wcykMlkMn3w/wG8pLxrPpTz" +
    "OwAAAABJRU5ErkJggg==")

# Original file: StepOverControl.py

class StepOverControl(PGLControl):

    def __init__(self):
        PGLControl.__init__(self)
        self.set_name("StepOver")
        self.set_active_icon(STEP_OVER_ACTIVE)
        self.set_disabled_icon(STEP_OVER_DISABLED)
        self.set_rollover_icon(STEP_OVER_ROLLOVER)
        self.set_pressed_icon(STEP_OVER_PRESSED)
        self.set_state(PGLControl.ACTIVE)

STEP_OVER_ACTIVE = ("data:image/png;base64," +
    "iVBORw0KGgoAAAANSUhEUgAAARcAAAEXCAYAAACH0wDUAAA+uklEQVR4Xu2d" +
    "+dslV1Wo/Z/uVVASBSEgoAQRlEkFUUQUuIiR6d6r4IWLiEgYVEjSGbqTzjyR" +
    "iQx0CAmZOmROutMQMgGRBBAUnO7z1D3rnK+667xrVa21q3bVGb69n+f94dtr" +
    "3Lv2Xl9VnTp1fuZgVf1MoVAo5EZ1FAqFQg5UR6FQKORAdRQKhUIOVEdhd/CZ" +
    "26uq5iM3VdXbr1zmxP1V9d8+7/OCM7Tte6875ruG8Qvbj+oobA+yqWWjy4Zn" +
    "UVglb7z4WAFizoXtQXUUNg/ZpClnG+tKfRZUzna2A9VRWH/kv75sRG7ObaUu" +
    "OJyHwnqjOgrrx5jF5NfPr6o3XLrM+7+y4AM3HuOshxac+fAx+ZwbF9S2b2zA" +
    "WDmQeZD54BwV1g/VUVg9coM11yVOXTykEPzV12bFYVYgDny3qm5/1uD7y9zx" +
    "rIY69HGH2BmcNStKn5wN7gOzPN46OxN51fk61z6UYrO+qI7CapCbnNw4UY4/" +
    "fVZALqmqd123OIuQAnLBN6rqtme6udXjWQPqEOo7XPF4VZ3x0PIZkIyHY4wi" +
    "RfmgMb+F6VEdhemQ/7jcHBFk8/3B7L//h29ZbM56Y9/2LJC+DlRhIM8aUIdQ" +
    "vw/PLMb1iTtnBfPaqnrJ2XoOIsi9moPGvBemQXUUxkUueVLvnzSLyflHFpvP" +
    "YpuKC30eLTbX9TuzkXk/aByPwniojkJ+5JOO1Hsocnkg90jmlzfPGhvOYJuL" +
    "C+VSZKXYStFNKTZyHMonT9OgOgr5SHl4TTbIO2eXAJ+7u6pu+Z7mZkB5H1yf" +
    "zxhQx/FJqJ+Lcx+pqvcdSCs0cp+Lx6yQD9VRGE7KWcrvX1FVf3NHVV3/bb1h" +
    "moyxSV2fLCxrXFyaSIGWQs25bkMuU8vZTH5UR6E/0aIiHw9/aHZKf/ljemO0" +
    "McYmdX2ysGxIcamRgi2F+/WX6GNgUYpMXlRHIQ1ZjJEbtC/Ztzhtl9N3boII" +
    "Y2xS1ycLy4YVlyZSyGX+5Tjw2JBSZPKgOgoxokXlHbPT88+23EdJYYxN6vpk" +
    "Ydng4tJECnz0sql8ytQf1VHoJlxUvlRVl3yrqm76p3H4qoHSeRoYNkn2AR/U" +
    "p0+F6DgwBn14cpOZ30serao//3LsJnApMumojoKNFBUuOIuxi0oNN5S1qbjR" +
    "qU9c+4AP6tOnYqeAdMEY9OHJTRr+v/TkrMgEP2kqRSaO6ihovBu1sijlP6D8" +
    "J5wvWC7kEeCGsjYVNzr1iWsf8EF9+lTsbPAuGIM+PLkJ48z6vvRUrMjImSvX" +
    "SEGjOgrH8J5TkUX43gOL/3xcqGPDDWVtKm506hPXPuCD+vSpaM5bC4xBH57c" +
    "hHEaMikyf3mzf/O3PCfTjeoo+JdAUlROmp2pXP1EVd343Uw8nQjtLR+Uk1T9" +
    "MWAOFrRx+MrTy1Bu0hLzY7dV1YudIlM+WbJRHbsd7xIoe1Gp4eL2oL3lg3KS" +
    "qj8GzMGCNg45i0vNX9zcfblULpU0qmO34n1D+XWzU+CLv6kXXTa4uD1ob/mg" +
    "nKTqjwFzsKCNwxjFRfqunl3+/smX9NpoUr6JfQzVsdvwPlqW/1Yn32Usttxw" +
    "cXvQ3vJBOUnVHwPmYEEbh7GKS80p95dLpQiqYzfhvaDpz25YfNX/y9/p5oYe" +
    "0IdHxJ46q4A5kVR9C/rwoL0FbQj1BVkfXZdKu/3FVapjt9B1tvLaixevZexa" +
    "WCkL04I+PCL21FkFzImk6lvQhwftLWhDqF9z4Teq6ve+qNdQE6693YLq2Ha6" +
    "PgmS/0IfvS2+sKIL04I+PCL21FkFzImk6lvQhwftLWhDqE8+f1/3pdJufM+v" +
    "6thmui6D6ksgLqrIwqJ+BPrwiNhTZxUwJ5Kqb0EfHrS3oA2hfhuyjri2anbb" +
    "ZZLq2FbaLoPkbEXeSn/dt9uRr+43oVzxlEFEp0t/DBiTUD+AO1eRGNBxfYKQ" +
    "/sAYioavMx6cncXs1WuthmtzW1Ed20bXZdCJ5y1el6gWCkheeNxA1iainFB/" +
    "DBiTUD+AO1eRGNBxfYKQ/sAYCvi7/FtV9eaOezG74TJJdWwTXZdB77khvpCS" +
    "Fx43kBDR6dIfA8Yk1A/gzlUkBnRcnyCkPzCGguPaGdv/vEmvvZptv0xSHdtC" +
    "12XQ3x1MW0jJC4+LbGehuTpd+mPAmIT6Ady5isSAjusThPQHxlBwXI2xye8y" +
    "dd3s5drdFlTHNsCDV/OKcxcvCpIvpi3xJPDkDtc8paGOgjFzwBhOnpQrfxae" +
    "jSfPgDsOg2sA5Yyh5IT6sLlsdpn0psv1mqzZxlc5qI5NRg4QD1rNn15vHHxj" +
    "EZgLhXIHLvbQgmfMHDCGkyflyp+FZ+PJM+COw2Dq4lLrfPArem1ua4FRHZtK" +
    "W2E5bk9V/e2dxoF3FkGn3IGLPbTgGTMHjOHkSbnyZ+HZePIMuOMwWFVxEU5/" +
    "sKpO2KvXqrBNr3FQHZtI25cOWy+DSMsiaJU7cLGHFjxj5oAxnDwpV/4sPBtP" +
    "ngF3HAarLC6CXCbJ+uSa3aYCozo2jbZPhOTAXfzo4vUIQ7nqSSB9A1ExEuUW" +
    "tCGevief6yTOBe1zwBhE6TPnFeVt8bar9doVtuGTJNWxSbQVlt+9fFFYci2S" +
    "1IUZQcVIlFvQhnj6nnyukzgXtM8BYxClz5xXlHcbbQVm098Rozo2hbaPmuVA" +
    "5V4kqQszgoqRKLegDfH0PflcJ3EuaJ8DxiBKnzmvKO8u3n29XsubXmBUxyYQ" +
    "LSy5FknqwoygYiTKLWhDPH1PPtdJnAva54AxiNJnzivK2+OvbtFruoZ7YBNQ" +
    "HetOW2H58C16geRaJKkLM4KKkSi3oA3x9D35XCdxLmifA8YgSp85ryjvCNtU" +
    "YFTHOtNWWD50c1Vd+dgC+WbzYMRPE8pJRD+iM0TfsiGevicP6Fz5+DJKH1A/" +
    "YsOYSk6oH7FJhf6tGJS3cMp9i0couM43rcCojnXFKixyAD5++7HCUoqLg6fv" +
    "yQM6qYWC+hEbxlRyQv2ITSr0b8WgvINtKDCqYx2x3sgvEy8HoFlYSnFx8PQ9" +
    "eUAntVBQP2LDmEpOqB+xSYX+rRiUO8i7en/NeBZmU27yqo51w/q4uS4scgBK" +
    "cemwIZ6+Jw/opBYK6kdsGFPJCfUjNqnQvxWDco/HFwXGOoPZhAKjOtYJq7AI" +
    "8hsylz22QN6b0YnoOMjTkk1cOTF8Kmjj0cO+npOjc+PgjstAxaAOY5BGvGhM" +
    "BWIQFcPQIcomETVOA9owhza5vELTKjDr/qCd6lgX2r4r1Cws5gEjPIAGamF5" +
    "cmL4VNDGo4e9WswO7rgMVAzqMAZpxIvGVCAGUTEMHaJsElHjNKANc+iSS4Hh" +
    "XhDW+asCqmMdaCss8rvM7gEjPIAGamF5cmL4VNDGo4e9mhsHd1wGKgZ1GIM0" +
    "4kVjKhCDqBiGDlE2iahxGtCGOXhy+f1q7ol1LjCqY9W0vZbyrVcuJtw9YIQH" +
    "0EAtLE9ODJ8K2nj0sFdz4+COy0DFoA5jkEa8aEwFYhAVw9AhyiYRNU4D2jAH" +
    "V/5Ye4FZx9c1qI5Vw0kT/mBWWC55dMGlidR2XfbUGYMpYjIG8fQ9eQ4Yow/0" +
    "eem3lqF+DhjTk1s6uXjHtXqPrGOBUR2rhJMlvObC5YnlAfTggaHc0hmDKWIy" +
    "BvH0PXkOGKMP9Lnbiosg/3C5VwTuqVWiOlaF9ZDcr+6vqv2PLE8qD6AHDwrl" +
    "ls4YTBGTMYin78lzwBh9oM/dWFyEdS8wqmMVWB85W4VF4AH0iNhTZwymiMkY" +
    "xNP35DlgjD7Q524tLoLsE+6ddfmIWnVMjXUDVz7T/+w9VXXhN6vqom8A6Rsb" +
    "xiTUn4JADjJfTSI2ndDe8uHJV0Ekp4jOusGcZ5x9uKpetFfvoXX4XSTVMTWc" +
    "FEF+6yXbBukDYxLqT0Egh1JcdojkFNFZN5jzTt6fu0fvIYF7bWpUx5RY91l+" +
    "/8rMG6QPjEmoPwWBHEpx2SGSU0Rn3WDOjbxP+rLeS6suMKpjKtrus+w7nHmD" +
    "9IExCfWnIJBDKS47RHKK6KwbzBl5v/FSvadWef9FdUyBdZ/leXuq6jNfr6oL" +
    "jnQjv+3c5IJvLOPJLZQNob4D9c0YlBPqA6VvAR+EPgn1LRtXjpwo5zyYc0Vo" +
    "w5i0p34jn2heyidjRnzShj6dmPRP9h6qqheepffWqu6/qI4p4OCFD96kJ9+C" +
    "E+4dEMotlA2hvgP1zRiUE+oDpW8BH4Q+CfUtG1eOnCjnPJhzRWjDmLSnfiOf" +
    "aF7KJ2NGfNKGPp2Y9G8h/6C5twTuwSlQHWNj3Wd5yxWLieHkW3DCvQNCuYWy" +
    "IdR3oL4Zg3JCfaD0LeCD0CehvmXjypET5ZwHc64IbRiT9tRv5BPNS/lkzIhP" +
    "2tCnE5P+TWZ677lB77FVFBjVMSZvNx76efn+xelc5GD0OSCUWygbQn0H6psx" +
    "KCfUB0rfAj4IfRLqWzauHDlRznkw54rQhjFpT/1GPtG8lE/GjPikDX06Menf" +
    "ZEf3DZfovTb1/RfVMSYcrNxnOXl2GnfukR0e8TkPUL4KzjsCpA/QxmOofWHz" +
    "GbIGznzIvv8i9zu5L8dCdYyFdTn0ga9UxwpLKS7LPgfaFzafoWvg5Lv0nhO4" +
    "N8dCdYyB9X6W189O25YKSykuyz4H2hc2nxxr4O3X6L0ntye4R8dAdYwBByeX" +
    "Q/JmrVJc2hlqX9h8cq0B6/KIe3QMVEdurIflpJrOB16KSytD7QubT6418NfG" +
    "c2VTvOBbdeSGg3rZOVV1zuEF8qWrJnV/F7TxOOfQMpSbOoA5JOsbuDkYOl36" +
    "cxJjuPp9cGK48sOZ8vAI5JGiz5wjeafqqxwsGOPQgtcZ/+THvrmrOnJi3cT9" +
    "2G2NgQNOjAVtPDj5lJs6gDkk6xu4ORg6XfpzEmO4+n1wYrjyw5ny8AjkkaLP" +
    "nCN5p+qrHCwY49CCv79ncTuC+5F7NieqIxfWTdw3fxEDB5wYC9p4cPIpN3UA" +
    "c0jWN3BzMHS69OckxnD1++DEcOWHM+XhEcgjRZ85R/JO1Vc5WDDGoWP80dV6" +
    "T475cm/VkQsOQqrm6Q9i4IATY0EbD04+5aYOYA7J+gZuDoZOl/6cxBiufh+c" +
    "GK78cKY8PAJ5pOgz50jeqfoqBwvGOLTMlDd3VUcOrJ9f/R/XVdXeh3twaJl9" +
    "Dy/j6Su5gfJJH8TwsQT1LbwcPOjP8En2HQLS1wHtTR9gcE6GjcoLMTy5BW0I" +
    "9ZmTgvpGDMpdH5QbqLkj0P/orXpvjnVzV3UMxfrGs9zEnU9uHzBZ6oARZ3It" +
    "lE/6IIaPJahv4eXgQX+GT8KFyJiE9qYPMDgnw0blhRie3II2hPrMSUF9Iwbl" +
    "rg/KDdTcEcPmTZfrPTrGLweojqFYN3E/eefO5PYBk6UOGAlMLlE+6YMYPpag" +
    "voWXgwf9GT4JFyJjEtqbPsDgnAwblRdieHIL2hDqMycF9Y0YlLs+KDdQc0cM" +
    "m1Pvn+bmruoYgnXW8rarGpPbB0yWOmAkMLlE+aQPYvhYgvoWXg4e9Gf4JFyI" +
    "jElqu/MOV9V1jy+4/omqOv8Rw9cOg3MybFReiOHJLWhDqM+cFNQ3YlDu+qDc" +
    "QM0dMWyEd12n92rusxfVMQSetUh1/MJ9iy9R9eZhQPkUjJHDGD49jJjXPlZV" +
    "Nz5ZVfc/U1Xf+lFVfftfq17t2Z8u7MXP176z8KviRzHy3Ei8cXjykfnlkW/u" +
    "qo4hMNHfvVwPKJkVH4A5Y+Qwhk+H/bMzkBufmhWAZ6vqx//B8jBOkziHf7Ao" +
    "OBcd0TmZrGBuRsEbhycfGeu9uznPXlRHX6xPiOStWBxQMis+AHPGyGEMnwZy" +
    "BiFnE3JmsQ6tLjZytsRcjzLR3IyONw5PPgFjnr2ojr4wwSxnLcIaHIBRchjD" +
    "5w5yhiAFZaqzk77t3//fotB88VGMYcS5mRRvHJ58At55rS4uub4WoDr6YJ21" +
    "fOquqtrzYDfyUN0SDxhEdBrsAco+AH0wb0J7C/qk3MOLefZscd75dFU981Nu" +
    "4c1oUgjvfWZxs5hj4zFWcgJ9zl0E5XMMvHEFxkEbrjPqk3+4t6qed9ry3s31" +
    "3Ivq6AMLy+9cpgdhwYnhZEYmnHBylX0A+mDehPYW9Em5R1tMKSr3PbM4C9iW" +
    "dmh2NnNBs8jgGHNuFNDn3EVQPsfAG1dgHLThOqO+4gH7N6dznL2ojlT6nrUI" +
    "nBhOZmTCCSdX2QegD+ZNaG9Bn5R7MOY2FhW2o0UGx5hzo4A+5y6C8jkG3rgC" +
    "46AN1xn1FQ+Md/aiOlJhYYmetQicGE5mZMIJJ1fZB6AP5k1ob0GflHvUseR5" +
    "Cbl82E3t0PdnReZw1b4mSK23A49XBOVzDJCnJ2eOVp5cZ9RX7OiNcfaiOlKw" +
    "3ub/oVuq6rQHFsiTgEtIXxPKLRybOlZbTE8eiUFOA5Qrfxa0IdSfccMT232m" +
    "0tVk3Hd815inCMZcUsdbJ+4xt3Bi5oB5EeordnL73Ozs5Rcyn72ojhRYWF55" +
    "XvcB6jXZjo27KBx5JAZxDyD9WdCGNHTlCdmn/oXbbXc2uWF91aPGfHXBuTfm" +
    "31sn7jG3cGLmgHkR6isa+cnvtHNPc8+noDqiWO9raZ61WAeo12Q7Nu6icOSR" +
    "GMQ9gPRnQRuyo3fP97i9SpMm83LWg8a8WXDujfn31ol7zC2cmDlgXoT6ikZ+" +
    "nzR+LWDI+15URxQmcSLOWqwD1GuyHRsvpiePxCDuAaQ/C9qAsx4qZytek7OY" +
    "S47ouVNw7o3599aJe8wtnJg5YF6E+grk+NuX6QLDvR9FdURhAu++fvE9ohTk" +
    "FwCaUG7pEOq73G9AnYEwRwvaNLni0d17byW1yTzd9JSew6HHw5NHoA8P2vfh" +
    "8/cD6WtAfe6Fj96mi0vfG7uqI4J1I/ezdxuJO7gDN3QI9V1YWNasuNxdLoN6" +
    "tYe+X1VnPKjns+/x8OQR6MOD9n0YWlyEF5y5vLf7/gys6ojAwvLblxpJB3AH" +
    "bugQ6rsYk6l0BsIcLWgjG6NcBg1r3/upXWA49xaeDeUR6MOD9n3IUVxy3dhV" +
    "HREY+H0HjKQDuAM3dAj1XYzJVDoDYY4WTX3ZELIxShve5DLp4iPDjodlQ3kE" +
    "+vCgfR9yFJe/PaiLS59vS6sODz6RK5+Nq4SDuAM3dAj1XYzJVDoDYY4Wte7+" +
    "Q6Ww5G4sMJx7C+8YUh6BPjxo34ccxUWQD2hYYFgLPFSHBwO+5Yqq+sd7F8hj" +
    "xF3Uem36lFvQhnj6lFs6Lvd0848G9CF9Fx6ebYT/4tYoLUeTef3SY3recxFZ" +
    "Q57OULmlQ6hP2vStN9WxFnioji6sZ1v+z9d0Ym20DaRNbkEb4ulTbum4GAUl" +
    "tbiUwjJNG6vAcA1ZcaiTW27pEOqTNv2Tv673euoP2KuOLvgay185206sjbaB" +
    "tMktaEM8fcotHRejoKQUF3mOohSWaZrMs3z5UR3DgXANPfnjBXJs23Q8H6ly" +
    "S4dQn3Tpv+FSXWBYE7pQHV0wkPyCW1tiFl0DseQWtCGePuWWjotRUKLFRRbf" +
    "937CLVDamG2MAsM1JIWljnX5N20dz0eq3NIh1Cdd+n9+YKLi8l7jGuxjt1fV" +
    "5+5J4O4e0Afx9Cm36GOTyj2LJyL/qRSWlbR/m236U+8zjksUZ408sVNc6nbX" +
    "P2kdz0eyPAeMAfhlxpRnXlRHGywsr77ASNTDSN6FPoinT7lFH5tUZn6P/HB5" +
    "AZY2bZPC3rvAOGuExUWa9C3Fc3wky3PAGEB+3517n7WhDdXRBgPIuzdVoh5G" +
    "8i70QTx9yi362CQi/8lKW3174Bl9bEI4a8QqLtLkjOmyIzEfyfIcMAb48C0j" +
    "Fxfrx84+dpuRqIeRvAt9EE+fcos+NgnI4iptfdqBJ/QxcnHWSFtxqdtdT/s+" +
    "kuU5YAwDXhrJLRLWCAvVYcHvEj3/zMXPhpBPg1R5Hz599zKp8hBi14Ry0Iwn" +
    "Dy7Jf69NaY//aLZwnl4g3ziuaY692X/zUwtdsduUcUqe5z6MY+agjjF44keM" +
    "opvM0efv1bbRGBa04Vr19D258BsXLO//6EukVIcFz1rkh6yZQCRRT94Hr3h4" +
    "8hA4YEoOmvEed/6jrbrJfYi6kKjjw3EbY6fN/ocXBeeRHzDSejUZ9xfubR8H" +
    "8cYdKS7SpLBZcx2JYUEbHi9P35MLf3iVvnJhjbBQHRZ0/J4bdAKRRD15H7zi" +
    "4clDOBuM1LFk065j++d/r6pbZgXgjAf0MVk6Phy3MXbaNJH/0hJnXT8hk+MT" +
    "Gcd8LgDl0eJSN4lNH14MC9rweHn6nlz4y5tHKi7W/Za/vVMnEEnUk/fBKx6e" +
    "PISzwYjEkS8jrttlgmyA+SVOnaeDGrcxdtqQWk/iHvkBM1p9q+eDeRNv3KnF" +
    "RRovk7wYFrTh8fL0PXlNn/suqoPIa+6aTl+8b/HTIXMOLnOyw1G7FBDDhfYB" +
    "TgaUM4arf9d6XRbIIr7okVjeTahv2Xhysuf+9Zqbp3/SMo7EdSVz3KfJP6CL" +
    "D1eL/eFhxCUcB6E+oX49F69DHYjcd1EdhGct8jOtR5M5uAyLCeFAQiCGC+0D" +
    "qMkkiOHpy0ZehyYL9/rHE8YJqG/ZePI2ZI7k8mwd2lefMsaRuK76Fpe63fld" +
    "IyYx4hKOg1CfUL+eiz++Rl/BHDTqRRPVQehQXmd5NJmDy7CYEA4kBGK40D6A" +
    "mkyCGJ7+Omwa+cE0+SpC0jgB9S0bT+4hm2rVTYrw6fdjHInramhxkSY+/uFu" +
    "I3YwB4HHg1CfUL+eC/mCMmuB9/pL1dHEut/y8TsayciAG7CYEA4kBGK40D6A" +
    "mkyCGF36q94sPFtJGqejb9l48ghyFrPq+1P3P4NxJK6rHMVFmszDRYeN+IEc" +
    "BB4PQn1C/eZcPB9fXPa+Ja06mvB+ywn7Fm+pOsqdy3wylYMBaANUDo79Uv47" +
    "UIc+XP0dPvf11W6Sp/+1qvY9pPNvhXMDlH4EY14iMeRhLcl/le20+47lEz3m" +
    "NY9lKi51u+M7eq4svPl3x0H7Dl6LeiAcNOpGjepoQkfyswNLyXKgqRwMQBug" +
    "cnDsOdmRCXf1d5AFsaomG1M2KHPvhHMDlH4EY15SYty7wheUS+w6j+gxr8ld" +
    "XKSJz89+Xc9Z1/wxL3cctO/g7Yn3XVRHEzo66QCS5UBTORiANkDl4NhzsiMT" +
    "7urvsKqzFlmEctbEvF04N0DpRzDmJTXGKgtMffYSPeY1YxQXabKmLjik5611" +
    "/pCXOw7ad/DhxPsuqqPGut/CRNVAUzkYgDZA5eDYqzEYOvTh6s+47ltcFtM0" +
    "OWNpy9uFcwOUfgRjblJjyByvqsDUZy+RY95krOJSt9tbLpM4d8zLHQftHfi8" +
    "S5bi8vMzp5+4Y5m/AcnyO5eh3PLhAp9yUB77Z4cfAcoD/OcKfsRMCstn7orP" +
    "FeeWUD+C5yNV3tS5Z0XfJH/qx/r4ekxx1ipxmsfbmk/SNrdt8k/IPuzg5XhB" +
    "f9dNXdVRwy8rilMm4iXqyicoLnJAtrH98N+GLzRC/Qiej1Q5db674pu869ak" +
    "iJ1/yJ4ri665teQsJoQ/99r1MJ3qqOH7cuWHz5iIl6grL8Wld9v7QPpcUZ9Q" +
    "P4LnI1VOnU/fNc1ZwaY1OSPnXFl0za0lZzEhLC4Ca4dbXOigFJf1aV95Qs9T" +
    "ZK6oT6gfwfORKrd0zjvEGShNmqxtKb6cr6759eQsJuSkL49QXE66QSfiJerK" +
    "S3FJboe+r+coOlfUl/9+TW7rgefjlHu7c2ROlo4gvkrTTc7qpPhyvtrm15Oz" +
    "mJAPJbyZTnW0FZf33VhVf317IrcBynPgxPjWFhUXWUjySwLmuCNgbqZo8lIm" +
    "xk1mJ3+5z1Sa3W799s48ce48sEY+fruGNqwNbZ8YqQ6BnxQJDBDCWdxZcGJs" +
    "U3G58YmOcUfA3EzRchaXcx+i99KaTda6PKav5q8LrBEWFqu4nLB3uTa0vX5B" +
    "dQj8GRFxxgAhnMWdBSfGthQX+a/dOe4ImJspWs7iIjz8LCOU1mxydps051gj" +
    "LCxWcXnlecv1Qb4mxBrSWlz4MfTLztEBQjiLOwtOjG0pLtc86ow7AuZmipa0" +
    "0NtojOEf72aE0qw2v0ziPFpgjbCwWMXljZfoKxvWkNbiQsM3zJz931sD3AYo" +
    "J9D/6K0aZZPIo1tQXH7wb3pcnLsQ8DFFO+fBvMdTKGcvsSb/WP/uDj1/TT4q" +
    "+66BWjPGunlr8J26qsMqLuKMAUycpBTQZ2HJsRi3obhc9U09Ls5dCPiYoo1R" +
    "XPaXey/hJpdJ+x/Uc1jTp7jIO51YI1hDwsVFnDGAiZOUAvosLDkW46YXl5/+" +
    "V8s8cK4jwMcUbYziImMpT+6mtVufMubx1n7FRfpYI6xPjFRhsYqL/OqaCmDh" +
    "JUWgz8KSYzFuenH5+tMt88C5jgAfU7SxisuBxxmpNK9Zl0krLy4f+driNXep" +
    "iF0Tygn15za3Ohh+mjz6Q07xZrVT712MQ82LQUSnyRRt34PI8dZlmJOJccw/" +
    "cTsjlea1rz1lzG1PWCNCxcV6xiWyUC1SFzv15zZcWMTw02STi4vcyG2bG44z" +
    "qtNkijZWcREeepbRSrOaXFrLqzMjayLKS88uxWWji4v8vnDb3HCcUZ0mU7Qx" +
    "i8sNjzFaaWzf+Zeq+txd8TURhcXFepCuFJc1bld+49g41LwYRHSaTNHGLC5y" +
    "yVhae5Nfu0xdE1FYXKz3urjF5YVnLW7ofvhmA+lvIF9qakL9DxHqB6APJQff" +
    "3ODi8umDenxH4bHoMZ9TtL336zy71pBJh42c8pe23GRO5NWYah4zkqW4iJO5" +
    "Qx5gY2GoxQ19FgalH4A+lBxsanH58X/osS3BY9FjPqdoYxeXTT2+YzW5DOr8" +
    "p5SJXsWFj/6X4rKaJouEY1uCx6LHfE7Rxi4uNz/JiLu3yVyouRsJ/sxIKS4b" +
    "1O7/nh7bEjwWPeZzijZ2cbm+3NSd5DKIsLhYr7t0i8uvnF1Vfzk7oH/x1XTE" +
    "LgXaz5H+JowBKN/k4tI17ghqbjCXU7Qz79fH2YN5chxNXfG/m9u3Z2e4n7rT" +
    "nhsLtUaow7mGfs1vXbRcJwTWEre4/NbFdlIRVOIOtJ8j/U0YA1C+qcVFnkDt" +
    "GncENTeYyylaKS7jta8+2T03FmqNUIf+oF/Tq7icuL8Ul3Vo1z7aPe4Iam4w" +
    "l1O0UlzyN7kMOu9hf24s1BqhDv1Bv6ZXcaFBKS6raaW4HIPjoP5uavVlUHRu" +
    "iFoj1KE/6Nf8ceCnXd3i8puzCvW/bprxVQPpT+B/A8ojpPq47JGquumJBk8a" +
    "NOUBnvjR+Jx272x8Xz0Gx9WUHUX6G/B4UT5FO/0+5O3k2Gddce7GQH4HXK2b" +
    "Bt//KUeev8na49jVfHp4c015i07kd6O3vrgQtSGFRJ+uPufJmCvPB3P05OY4" +
    "kAPlU7Qpiksv+1Qb6oNv/IAjz9d++p+zy6CHjJxuMubTg7l78hadXsVF3odZ" +
    "iks3rj7nyZgrzwdz9OTmOJAD5VO0UlyGtW//ePGaBGuNCGo+PZi7J2/RkbqQ" +
    "XFz4adGvn58Q1CF5IgyG+lAbUkj06epznoy58nwwR09ujgM5UD5FK8Wlf5PL" +
    "oK41Iqj59GDunrxFJ0txecm+hKAOyRNhMNSH2pBCok9Xn/NkzJXngzl6cnMc" +
    "yIHyKVopLulNLoPkZ1TUXBlEdDrH4clbdLIVlw9+pao+YCD9S9y4jKfvyS0+" +
    "IH6bGH46fSJHK09CfeWzByoG6RPTGRf1p2h77l2O6eU0Gc5ccZ159kcyFZen" +
    "frx4EZaKF8UZl9IPQB/Cay5crhPyCAtrSSkuER+0oc8eqBikT0xnXNSfopXi" +
    "Em/yG+AqTirOuJR+APoQWFxC3y3it6JLcdH6ymcPVAzSJ6YzLupP0Upx8Ztc" +
    "Bsm7hlWMPjjjUvoB6EN48b4MxeX409sDMInUgXlyCx50+iC0Z45WnoT6ymcP" +
    "VAzSJ6YzLupP0Upx6W5yGfQ3t2ecC2dcSj8AfQhZiovwvgNV9f4bNdK/hPQ1" +
    "oZxQ3wI2qTm8X2waUD7XIbAhtO+Fk7eC+ha0IdCfop16j5FHA86tBfOmDyUn" +
    "1LegDfByOvL9Krnd+DhiyHw0UDkGYJ6Khn9rrXNccxjnQCkuc9Tk0T/8WRNO" +
    "aN8LJ28F9S1oQ6A/RSvFRTe5DDr7Ae2D61DlGIB5Khr+rbXOnOYwzgFdXD5y" +
    "UykuSj7XIbAhtO+Fk7eC+ha0IdCfopXistzkMujjt2r7eQyZjwYqxwDMU9Hw" +
    "b6115jSHcWZ9LzhzuUaE3v4vlOLSDe174eStoL4FbQj0p2iluBxrvAwiXIcq" +
    "xwDMU9Hwb6115jSHcQ7oE5DexeWd11bVn3/Z4ACg3OGkA8tQPgYnGVDHg/Zq" +
    "HH0w4nRC+x4+pmhfuBtxDyyj5tLIk6j5NnSSQV5K7vBIR3H5yX8u3sg3OG+x" +
    "AalzlwvWiN7F5Q+u1M7ncLCUOwye7B7wYPQ5ILRX4+iDEacT2vfwMUXb7cXl" +
    "ydll0Me+ttAZnLfYgNS5y8Gf5vwhenkxDAPM4WApdxg82T3gwehzQGivxtEH" +
    "I04ntO/hY4q2m4vLgceWdQbnLTYgde5yICcbrBGsIeHi8hsX6ABzOFjKHQZP" +
    "dg94MPocENqrcfTBiNMJ7Xv4mKLtxuIyvwx6QOsMzps5ih/x20DZjEDkLXSt" +
    "xYVfAThhb1W95wbNnyVCe0L9uc31y1BO6DMCfZDkHKBv2khfE/oAntzCs5mi" +
    "ff7r3TlYMG8yVL+PDeXk8E5xefJHVfWRW2wbd00QZ43MfTp4+kqOHOfA5lXn" +
    "Dygu8pl10/C4PTqAlZgH7Qn15zaJB4Q+I9AHSc6BB8eykb4m9AE8uYVnM0Xb" +
    "TcVFfru6y8ZdE8RZI3OfDp6+kiPHObCRk41mfbAeoGstLtazLgxgJeZBe0L9" +
    "uU3iAaHPCPRBknPgwbFspK8JfQBPbuHZTNF2S3Gpz1a6bNw1QZw1Mvfp4Okr" +
    "OXKcA5vn4xkX60foW4uLwOLyh1fpIEzMg/aE+nObxANCnxHogyTnwINj2Uhf" +
    "E/oAntzCs5mi7ZbiQn3Lxl0TxFkjc58Onr6SI8c5sGFtsD6GTiouv31ZVb37" +
    "eofrAOUkVd/C8+HJLRwb+SiuidI3oM2fSl8DxnAxYng6jDlF+/u7jLwaMKfQ" +
    "XGBcCupb0IY4+pGcecwpp09XbsGYjZza8uqCOXN9Rz8pSiourzxfJ6JwBq5I" +
    "1bfwfHhyC8ema/LboM3QRUD/Vp6UM+YUrRSXY1BOn67cgjEbObXl1QVz5vp+" +
    "8+UZigt/HO1X9+tEFM7AFan6Fp4PT27h2HRNfhu0GboI6N/Kk3LGnKKV4nIM" +
    "yunTlVswZiOntry6YM5c3688L0Nx4cfRL9qrE1E4A1ek6lt4Pjy5hWPTNflt" +
    "0GboIqB/K0/KGXOKVorLMSinT1duwZiNnNry6oI5c33LSUazLlivt3SLi/WJ" +
    "0buuTeOd1y1DOZHvMJF3iV0Tx4ZyQn3TxonpyTnuOYxJH4Qxc4AYU7TPHnTm" +
    "2iB57ujDk/cBPt2ccsVNxMsreW6h88KzlmtC28fQncVFYHGRn3DkYLrgQCgn" +
    "HKg5WMeGckJ908aJ6ck57uhB7PKZBcSYopXiMi1eXslzC53nnLpcE9o+KUou" +
    "Lm+4RA+mCw6EcsKBmoN1bCgn1DdtnJienOOOHsQun1lAjClaKS7T4uWVPLcN" +
    "HXkchTWBNaN3cTnxPD2YLjgQygkHag7WsaGcUN+0cWJ6co47ehC7fGYBMaZo" +
    "pbhMi5dX8tw2dOQ7hqwJrBnh4sKfdv2lM/RguuBAKCccqDlYx4ZyQn3Txonp" +
    "yTnu6EHs8pkFxJiileIyLV5eyXPb0JFfAmnWgxecMaC4WDd1/+jqqvqTL9m8" +
    "wyFV37L5k2sA5LSPQB/E0/fkfaDPCPRBqD9F+8yd3TkwRxPnmFPOGBb08Q6x" +
    "a0Cf1Cf0b0GbVOhvDJ+UN3V4v6Xtsf9QcRFYXORnHBmcSbSRqm/ZeAed9hHo" +
    "g3j6nrwP9BmBPgj1p2iluLTHTIX+xvBJea3ze1/UJxqsFUR1EDp82Tk6eFui" +
    "JFXfsvEOOu0j0Afx9D15H+gzAn0Q6k/RSnFpj5kK/Y3hk/Ja51WJ91tCxYUP" +
    "0z1vjw7elihJ1bdsvINO+wj0QTx9T94H+oxAH4T6U7RSXNpjpkJ/Y/ikvNZJ" +
    "vd8SKi7WfZe3zE6R3n51gGscUvVn/BGg3IUxrbhD5RHog1C/D/QJpmgn36Hj" +
    "uuP0dDw5oX4fPJ+UR3W6oH0f6LMnqfdbQsVFYHF59ewUSQ3CwkhyiVT9a0px" +
    "SYI+wRStFBdHpwva94E+e/C7CV9WbKI6LOj4pWdXehAWRqJLpOpfU4pLEvQJ" +
    "pmiluDg6XdC+D/TZg18PvtaSqA4Ldd/ltEoPwsJIdIlU/WtKcUmCPsEUrRQX" +
    "R6cL2veBPnvwy/g+UdeXFZuojjZYud78xap621XdyOPCTSgn1De5epm3eRhx" +
    "iIrhwRzgT+UgevQB6INyQn0L2pAp2qfuWJ4HhZE3Yd6UKzj3BkqHcaiPGNSn" +
    "3MpDyQF9EupbNpQzB29c1Be4963fhbZQHW0wgHwVQCUG3IE7+iacHA8jDlEx" +
    "PJgD/KkcRI8+AH1QTqhvQRsyRSvFpQHlgD4J9S0bypmDNy7qR39GxEJ1tCEf" +
    "PTUD/OLpRmLAHbijb8LJ8TDiEBXDgznAn8pB9OgD0AflhPoWtCFTtFJcGlAO" +
    "6JNQ37KhnDl446K+3F8dvbjw50YE79LIHbijb8LJ8TDiEBXDgznAn8pB9OgD" +
    "0AflhPoWtCFTtFJcGlAO6JNQ37KhnDl442rqyvtyn3PK8p6X7xuyNrShOrpg" +
    "cXn5/kUCfXkroHzOFYByh0gM6pChOVikxqC+RarNFO2Tt+m8dgucb8o9htqb" +
    "YJ29FTR1+35KVKM6uuB7dX/hNCP5BEKT52w6j0gM6pChOVikxqC+RarNFK0U" +
    "l/bj4zHU3gTrrKu4yKttJysu1tO6r73YGECQ0OQ5m84jEoM6ZGgOFqkxqG+R" +
    "ajNFK8Wl/fh4DLU3wTprKy7Wg3ORp3KbqA4PBnzJ2cYAgoQmz9l0HpEY1CFD" +
    "c7BIjUF9i1SbKVopLu3Hx2OovQnWWVtxecW5uriwFnioDg++QEpu+Lzlip58" +
    "EVA+FcyDUD8HjOEgX3lvQvkcxgC/B6Zon7gNeURypg5xxsW5slA+gdJPzTHi" +
    "YwyYB+VBjj99eZ9HvqhIVEcEVjT5wTQmFyLTRAyGeRDq54AxHNRCtWAMwE04" +
    "RSvFpcPHGDAPygO8/hJ91hJ9cK6J6ojAwPJzA0wwRIaJyALzINTPAWM4qIVq" +
    "wRiAm3CKVopLh48xYB6UB5B3NnGPswZEUB0R5MYOg8tvSTNJlwwTkQXmQaif" +
    "A8ZwUAvVgjEAN+EUrRSXDh9jwDwoDyCfAjf3dvS7RER1RGFxkV9ik4fqmryJ" +
    "XL6M/O7sErC38Hx4cgvaKJxxEOZs5U0G5yRxEn1ceWQ4VwDKT7p+OWZqjhb0" +
    "QTgvtLd8UE6UfiAGUT4ceQTmoeTAk1tvnOv6baIuVEcUfh1Aqp3aUMQZKO0t" +
    "PB+e3II2CmcchDlbeZPBOUmcRB/U74PnM1UegT4I54X2lg/KidIPxCDKhyOP" +
    "wDyUHHjyF+ONcwL3fhTVEcX6OoBUvaUNRZyBckNaeD48uQVtFM44CHO28iaD" +
    "c5I4iT6o3wfPZ6o8An0QzgvtLR+UE6UfiEGUD0cegXkoOeiSWzdyu36u1UN1" +
    "pMBEnj87m1naUMQZKDekhefDk1vQRuGMgzBnK28yOCeJk+iD+n3wfKbKI9AH" +
    "4bzQ3vJBOVH6gRhE+XDkEZiHkoMu+QkDn8glqiMFvkRKeM1FVSkugbzJ4Jwk" +
    "TqIP6vfB85kqj0AfhPNCe8sH5UTpB2IQ5cORR2AeSg7a5NZZS98buTWqIxUm" +
    "JL/K+DuXFXYtlwLKC2tJ7rMWQXWkYp29yG/KMvnCLqEUl43jdXjqPsdZi6A6" +
    "+sDEytnLLqYUl43jVwa8EKoL1dGHcvZSOEopLhvFG2fH6OdOWd67fb5HZKE6" +
    "+sLi8qKzFokncYnmDZcuQxslpw/DxsXzwRzJpRrPB3HtDWiTCv1ZRMbaCezp" +
    "3xqHkjs+KKe/uU+x64JxHbmKGYF5UU6ob+TlyZm39VxL34fmiOroC18kJcjL" +
    "fTmYTjgR1mQBJacPw8bF88EcyaUazwdx7Q1okwr9WUTG2gns6d8ah5I7Piin" +
    "v7lPseuCcR25ihmBeVFOqG/k5cmbOcsnRGOdtQiqYwgsLvImKx6ETjgR1mQB" +
    "JacPw8bF88EcyaUazwdx7Q1okwr9WUTG2gns6d8ah5I7Piinv7lPseuCcR25" +
    "ihmBeVFOqG/k5cmbOfP3n3OetQiqYwiDz144EdZkASWnD8PGxfPBHMmlGs8H" +
    "ce0NaJMK/VlExtoJ7OnfGoeSOz4op7+5T7HrgnEduYoZgXlRTqhv5OXJ63zH" +
    "PmsRVMdQWFzkqd3XX2wjH4E1odzSed0lwPFBfcot6DMZ5mjk6cozwHER6odw" +
    "8mYMD9pbeDayUZpQHgLj8mJGSPbhzK1FcowdrOdacp61CKpjKNbZy6/t15Ng" +
    "TQTllo53AJS9s2gs6DMZ5mjk6cozwHER6odw8mYMD9pbeDaluCTEmPHqC/Ue" +
    "FbiXh6I6csCkf/7UqnrtRf5EUG7peAdA2TuLxoI+k2GORp6uPAMcF6F+CCdv" +
    "xvCgvYVnU4pLQoyLFz9oyD2a+6xFUB05sJ57efFefyIot3S8A6DsnUVjQZ/J" +
    "MEcjT1eeAY6LUD+EkzdjeNDewrMpxSUeQ64iuDdzPI1roTpywQEI8mCd3ODd" +
    "Oi4ElFsk2vwmoDwHY8To47OPTSpTxEgGa4I5/qb0AeWjg9dcqG/iCgeN/ZsD" +
    "1ZEL6zeO5I3iHPBWcCGg3CLRhguN8hyMEaOPzz42qUwRIxmsCebIwpJaXKwf" +
    "ORvyvhYP1ZET6+au/AQsB73xXAgot0i04UKjPAdjxOjjs49NKlPESAZrgjmy" +
    "sKQUl1eep/eicNDYt7lQHbnhYJ576uL0jIPfaGQ8TSi3SLThQqM8B2PE6OOz" +
    "j00qU8RIBmuCObKwpBQX/g6RMMZN3CaqIzfWzV35KRL5OEyKzBIXaF5NLnRw" +
    "9FVM2gfkxM1Z+lN9OlDftGFetHFypH3b2Dp9ZEDlnYqRp9Jx4DyoHOm/T4we" +
    "uDEvsJ/EHesmbhPVMQYcmPCK8/REqQPIibMmjzj6KibtA3Li5iz9qT4dqG/a" +
    "MC/aODnSvm1snT4yoPJOxchT6ThwHlSO9N8nRg+8mK86f9qbuE1UxxhYN3eP" +
    "O11PlDqAnDhj8hSOvopJ+4CcuDlLf6pPB+qbNsyLNk6OtG8bW6ePDKi8UzHy" +
    "VDoOnAeVI/33idEDL6ZcJXDvpf6gfF9Ux1hYN3dl4EuTxQPIiTMmT+Ho8+DM" +
    "D5CjQzlxc5b+VJ8O1DdtmBdtnBxp3za2Th8ZUHmnYuSpdBw4DypH+u8Towdd" +
    "MV9q/HJi7u8PdaE6xoQDFeSnI+XUrZULQKo8BxliyDM+TVyfnrwPK/D5G8DT" +
    "D9kApR/AtWEcygMMjkF5gDrWiefal0Nj38RtojrGxPqtI5kA+ZhMTWzbBKfK" +
    "c5AhRikuOxvM0Q/ZAKUfwLVhHMoDDI5BeYA6Fn+SVXjjxdMVFkF1jI0MkIM+" +
    "bg8mtWuCU+U5yBCjFJedDeboh2yA0g/g2jAO5QEGx6A8gMT55TP1HpvycqhG" +
    "dUwBfwpWkAlRk2tNcKo8BxlilOKys8Ec/ZANUPoBXBvGoTzA4BiUB3ip8bJt" +
    "gXtwClTHVHDwgnn/hROYKs9BhhiluOxsMEc/ZAOUfgDXhnEoDzA4BuUO8njH" +
    "qu+zNFEdUyEfh3ESfvaUxY0ouQcTRfSbUN4L8dOE8h6cCCgfA8Yk1CfUt6DN" +
    "GIwRM9Un9Qn1LVwbrLvUtf3za3CfpYnqmBLr4+nn7dGT1kXqAQhRikvIPuIj" +
    "B2PETPVJfUJ9C9dmQHF5wZrcZ2miOqaGEzKflDP15LWRcgDClOISso/4yMEY" +
    "MVN9Up9Q38K16VlcrMf7Be61qVEdq4CTIsiNKU6iRfQAJFGKS8g+4iMHY8RM" +
    "9Ul9Qn0L16ZHcZGXP8ntBO6fz9xeissc8/7LFxY/MymT18m5y7yC7F+G+nPo" +
    "k3j6lAcI5ZWoTx1CfTUOQv0AnP9UeS+YdwT4SJ0rpW+QPFb6gNyKKa+Q5d5Z" +
    "5X2WJqpjVVj3X6TA/ConnPAAEB4QHlCBPomnT3mAUF6J+tQh1FfjINQPwPlP" +
    "lfeCeUeAj9S5UvoGyWOlD8gZzyosq77P0kR1rBLr+ReZwM4CwwNAGgfEXDQC" +
    "fRJPn/IAobwS9alDqK/GQagfgPOfKu8F844AH6lzpfQNksdKH5A348mDp9wr" +
    "AvfUKlEdq4aT5RYYHgDSOCDmohHok3j6lAcI5ZWoTx1CfTUOQv0AnP9UeS+Y" +
    "dwT4SJ0rpW+QPFb6gLyOZb29f90Ki6A61gFOmiAfUb/8HIP9IFU+42X7l6Hc" +
    "Qx7+a0L5HOTBmMoH8yb038PGjUn/GVAx++Dl6ck3GOuNcoJ8b4/7aNWojnWB" +
    "kyfIxHKy3YXkyc/RG51yj9CGQR6MqXwwb0L/PWzcmPSfARWzD16ennxDsb4z" +
    "tK6FRVAd64L1DWqzwHgLyZOfozc65R6hDYM8GFP5YN6E/nvYuDHpPwMqZh+8" +
    "PD35BtJWWKZ68VMfVMc60VZgZKKPTry3kDz5OXqjU+4R2jDIgzGVD+ZN6L+H" +
    "jRuT/jOgYvbBy9OTbxjW2+SEdfnIuQ3VsW5YL/gWnn/m4jkYediuifQ1UfJ9" +
    "BoZdF8qnI7egjcLJkf5CPgHtIzAvJQep8gj0QahvIrk3oA+i7AH1cyG/NSSP" +
    "ZHD9r3thEVTHOmK9A6YuMN5BVnJu2sDCIsqnI7egjcLJkf5CPgHtIzAvJQep" +
    "8gj0Qahv0igs61pc2grLOj3L0oXqWFfaCox8D6nrIKtFwE0bWFhE+XTkFrRR" +
    "ODnSX8gnoH0E5qXkIFUegT4I9U0ahWUdi4v849zkwiKojnXGeshOkAeK2g6y" +
    "WgTctIGFRZRPR25BG4WTI/2FfALaR2BeSg5S5RHog1DfpFFY1q24SGHhGt+0" +
    "wiKojnWnrcA877SqevFeg32AckuHDNWP2KRC/31iDLW3fJBUfctmBOSbxE0o" +
    "Z07UJ8re8KGg/r72B+Q2rbAIqmMTaLtEkpcSn+AdQMotHTJUP2KTCv33iTHU" +
    "3vJBUvUtmxFwiwNyoj5R9oYPBfTlQVGu6U0tLILq2BTaCsxzTkGBiRxw6pCh" +
    "+hGbVOi/T4yh9pYPkqpv2YyAWxyQE/WJsjd8KBq6bYVlip9dHQvVsUm0fUy9" +
    "VGAiB5w6ZKh+xCYV+u8TY6i95YOk6ls2I+AWB+REfaLsDR+Kmc4J++xvNwub" +
    "8HFzF6pj02h70E7utMsnSS86axl5IIlQR7EXQP7CvQD+IzFS9VVORl4K6gOV" +
    "g6GjcGIon4ByS4d4+jmOB1H23jxYNoZc/hFy7W5DYRFUxybSVWCef4Y+oIQH" +
    "XeEspByLOVVf5WTkpaA+UDkYOgonhvIJKLd0iKef43gQZe/Ng2XTQP7xtRWW" +
    "df2uUCqqY5PhQaqR69m2A86DbuIspByLOVVf5WTkpaA+UDkYOgonhvIJKLd0" +
    "iKef43gQZe/Ng2Wzg3wiZD3Dsk2FRVAdmw4PVs1zT9UHmwe9FWch5VjMqfoq" +
    "JyMvBfWBysHQUTgxlE9AuaVDPP0cx4Moe28eDBvB+pnVmnV4721OVMc20PYs" +
    "jPy3+KUz9AHnolA4CynHYk7VVzkZeSmoD1QOho7CiaF8AsotHeLp5zgeRNl7" +
    "8wB9eTCu7TJI4BreBlTHtmC9k7dG/nvINW+NfMu6SVNmkao/tzljGcpJnxge" +
    "9Eki+tQZAy8m5X2gTw/PnvKmjjxB/t9bLoM29RmWCKpjm7B+VaDmOae2Lwwu" +
    "HJKqP7cpxSWMF5PyPtCnh2dPea1j/QpizTZ8ItSF6thGeFBr5L+J3FyzFkUX" +
    "qfpzm1JcwngxKe8DfXp49pTL5bf1u80123Z/xUJ1bCveZVLXwiFcSJRblOIS" +
    "x4tJeR/o08Ozb8p262UQUR3bTOdl0imLV2jKf5y1RHJrQrmFZ0M5ob5lQ7nH" +
    "UHuLPj49G8qJoS9nwV03bbf9Moiojt1A26dJglwjq4WzDniL28KzoZxQ37Kh" +
    "3GOovUUfn54N5QT68gh/29mKsBsug4jq2C20ffFRkI+s5cE7LqCV4ixuE8+G" +
    "ckJ9y4Zyj6H2Fn18ejaUkx29407vvreymy6DiOrYTbR9baBGTnF/kYtuVbQs" +
    "7k48G8oJ9S0byj2G2lv08enZUE7OWDyYyTXTRL5YyzW3m1Adu5Gum72CLCK5" +
    "SVdzPDndp2kfwY1BuQF9EuqT4yRvcLyD0jf8utDnnm5S9ec2xPOxMx7huad1" +
    "XwLt5rOVJqpjtyLXxFwkTeRSSe7HRBamhVqsDm4Myg3ok1CfyEYixzsofcOv" +
    "C33u6SZVf25DPB+nLy6Vf7bjEkjYpu8GDUV17Hba3hFTI9fXanFiYVqoxerg" +
    "LX4lN6BPQn0iG4oc76D0Db8u9Lmnm1T9uQ1xfHiXQLvtk6AIqqOwwLtUkvsx" +
    "RxcpFqYFF6uHt/iV3IA+CfXJcZI3ON5B6Rt+XehzTzep+nMbYviQMxU5zuUS" +
    "qB+qo3AM71JJkDMZ+RhSHsQ7ivxNmvIZzzt1GcqJvIB8KPTpQXvLhyffVLo+" +
    "Aaopl0DdqI6CxrtUEuRa/GiRYWExikcpLutJpKhs8nttp0R1FNrxLpWWigzB" +
    "Ii7FZX2Q4xUpKnIJtBsfhuuL6ij4hIrM7Dr9ubMFW4rL+iJFxfv0pxSV/qiO" +
    "QpxIkZGbgfJfUT5tSEFeCdGFFC4Xw+9gnBgqT+LYZ4ExgByPttdMNimXP8NQ" +
    "HYV0IvdkBFnQ0ULDTUq4YUwMv4NxYqg8iWOfBcaYIZ/6RAqKUIpKHlRHoT/R" +
    "IiNnM3I6bm6+HbhJCTePieF3ME4MlSdx7LOw41sKys99ofuj5CalqORFdRSG" +
    "Ey0yQttlEzcpUZvUgpsuB04MlSdx7HMg8xktKMJu/w7QWKiOQj7kOYiu1zuQ" +
    "+RmNFJudM5sldmQ1soGI0gFKTh/UZw4GtKFPxlRYPgnzIjt2KQVFKM+pjIvq" +
    "KIzDe6/Ti7sL2Sj15dMcbCi1AS0doOT0Qf06dge0oU/GVFg+CfPaoZ4jzl0X" +
    "5SxlOlRHYXy63iXTxtFis4PagMZGbtuUrT6o39jwbdCGPhlTYfkkDf3UYiKU" +
    "eymrQXUUpkOenYh8nG1xtNB0bGRufCU3NvE6FReR9ykmglyOlsue1aI6Cqsh" +
    "9f6MRX1207x3swnFpZl332JS897rSkFZF1RHYT1I+cRpNyPzVJ6eXU9UR2H9" +
    "kM1Tis0CuV9VislmoDoK649srj43hTeRUkw2F9VR2Ezqs5u+N4hXjdxvqi9x" +
    "SjHZDlRHYbuQjSo3i9flskrykJuupYBsP6qjsLuozxSaSAFowkswOTuiDn2U" +
    "4lFQHYVCoZAD1VEoFAo5UB2FQqGQA9VRKBQKOfj/kc1UAmT5wT0AAAAASUVO" +
    "RK5CYII=")

STEP_OVER_PRESSED = ("data:image/png;base64," +
    "iVBORw0KGgoAAAANSUhEUgAAARcAAAEXCAYAAACH0wDUAAA980lEQVR4Xu2d" +
    "edAlV3XY+S+VqqyVP5I4cZksjp04AWwndvKHgSSVpVIxENskjmMwOIkBgTaQ" +
    "QGIV+yaJHYTYJAFCQkhmD5jdFmIbNCNptMymZUYwWgYkkBA7nXfe+3q+7t85" +
    "3efc+7rf9t2q+ZXgnvWee+/5uvttD9pVVQ8qFAqFoVEDhUKhMARqoFAoFIZA" +
    "DRQKhcIQqIFCQXjOdVX1J7t8Tt1TVbQtFAQ1UNhM2BSWyUtvLA1pJ6AGCutL" +
    "9GpjVSlXQZuFGiisB3IQeTg3lV3G/AurjxoorCZjNZOX3FBV5+5v84HbZ1ze" +
    "4PrvzNj7nW15k9r2NQ0YawjK1c36oAYKq8FQtzh185AG8PGjs+bw3R9X1U9+" +
    "ZlC1+enPNMoGUP+n4mfC9d+tqi/cPWtUbz00e+7CXHMozWZ1UQOF5TDPYTtl" +
    "z6yBXHTrrIlIA7n5/qr68c/AT9v8yONnBtQh1Hc4+oOquq5xNSTzkPlwjlGk" +
    "Ke8y6ltYPGqgsFh4OCLI4TvvUFV9bHIlcvT72wdbNRMiOg1UYyBGM1A6hPo5" +
    "/HQ2r8/dNWuYz868ittl1LuwONRAYXxSn580m8mh+2eHz0I1EyI6DWiv4KHf" +
    "Ovi9UD8Hw6dc4dTNJufKZpexDoVxUQOFcUh9hiK3B/KMpL69UQfOQDUTIjoN" +
    "aK/goY/kQf0cPJ8/nTVZabbSdFOaTbltWhxqoDAs3NxdyAG5cPJX+cvHquoH" +
    "P5nw0zbfB5Tn8P2ftJnGbWLYKGDDPImyH4gDk2Zz2ZG0RlPezDcuaqAwPylX" +
    "KW85WFWfvbOq7vlh1Xuwxzikm9RcmkiDlkbNWndRXnEaBzVQyCfaVOTl4Y9+" +
    "s6q+8UClDmfXwR7jkG5qc6lzkYYtjfucfXoNLEqTGRY1UEgn8oBWXvGQy/YD" +
    "921v/l5wYMY4pJveXJpII5f6R155Kk1mGNRAIU6kqVwwuTz/0rf0ZnfBgRnj" +
    "kO6k5tJEGnz0tmmXse6FGGqg4BNtKocnfy2/95NxeMBA6fwYGDZJ9gEf1KdP" +
    "heg4MAZ9ePIuZH0uDT4E3mXsg0I/aqDQDTecxQW3jNtUanigrEPFg0594toH" +
    "fFCfPhWNJtIFY9CHJ/c49sPSZMZADRQ03oNa2ZSXHp40le9VswNhbOCh4YGy" +
    "DhUPOvWJax/wQX36VGw1kD4Ygz48eZRokynPZGKogUIbbiw2lfdPNuOxH1Tt" +
    "A2Fs3KHhgbIOFQ869YlrH/BBffpUNOvWAWPQhydPRZrMR77pP/wt75PpRw0U" +
    "ZnAjsalcMrlSuWvSVO77cWHVuB9QnsKn7qyqM50mU++ZQhs1sNPxboFKU1l9" +
    "hmwuNR/+Zv/tUrlV0qiBnQw3TJOz91XVbd/Tm66weozRXAT5o/KuW/TeaFLv" +
    "pUJpLlP6XlqWv1ZXHtMbrbC6jNVcaq6+p9wqRVADOwnvC5red3j2vSLf+TH4" +
    "UZt7yY8NoOP5JPSn7I0Yc4OY1jwI8yb0xzmY0IcHY8DeQvkA1Bdkf/TdKu30" +
    "T2CrgZ1C39XKq/fNvi/2+MZK3ezY3Nah9HwS+lP2Roy5QUxrHoR5E/rjHEzo" +
    "w4MxYG+hfADq19xyf1W96aDeQ02a+24noQZ2Alz8Gvkr9Mk7jI2Vutmxua1D" +
    "6fkk9KfsjRhzg5jWPAjzJvTHOZjQhwdjwN5C+QDUJ7u+3X+rxD24E1ADm0zf" +
    "bVB9C8RNNd1YqZsdm9s6lJ5PQn/K3ogxN4hpzYMwb0J/nIMJfXgwBuwtlA9A" +
    "/S5kH3Fv1ey02yQ1sKl03QbJ1Yp8K/23f9TNPYByxQ8NIjp9+mPAmIT6ARv5" +
    "moMmqfYWqv7UQQxX30DlTTgP0tC97t7JVcy1eq/VcG9uKmpgE+Hi1rzohtnX" +
    "JaqNAtRm9eDGtDYn5YT6Y8CYhPoBG3VIE+0tVP2pgxiuvoHKm3AeBPryFQ9v" +
    "PKD33E5qMGpgk+i7Dbr4cGPzOajN6sGNaW1Oygn1x4AxCfUDNuqQJtpbqPpT" +
    "BzFcfQOVN+E8CPW3+NPb9d6r2fTbJDWwKfTdBv353dh8DmqzehibLKTTpz8G" +
    "jEmoH7BRhzTR3kLVnzqI4eobqLwJ50Go32Cn3iapgU2Ai1fzwutnXxQkH0xr" +
    "8QNAeSJ3G1Bn6Jg5uDkOwQLmmTMPZePl6ckdbp/cJr1hh90mqYF1h4tW897b" +
    "9IIfZ86NQ7hxzQ0/cMwc3ByHYAHzzJmHsvHy9ORBrui5TeJeXnfUwDrDxRJO" +
    "3l1Vn79LL3KLgTZODTeuueEHjpmDm+MQLGCeOfNQNl6enjyBaye3SWd03CZt" +
    "0tc4qIF1hYskdN4GkQE3jsCNa274gWPm4OY4BAuYZ848lI2XpydPRG6TZH9y" +
    "z25Sg1ED60bXK0KycLc9MPsk67zcOQJeDE9uQRvi6XtyS8eD9nd9H1BuARvG" +
    "IKn6Fl4OSp7J227We1fYhFeS1MA60dVYXn9g1ljMTZIBN94QeDE8uQVtiKfv" +
    "yS0dD9pnHdLEZpGqb+HloORz0NVg1v07YtTAutD1UrMsVO8myYAbbwi8GJ7c" +
    "gjbE0/fklo4H7bMOaWKzSNW38HJQ8jl5z216L697g1ED60C0sZibJAP6HAIv" +
    "hie3oA3x9D25peNB+6xDmtgsUvUtvByUfAA+flTv6RqegXVADaw6XY3lY0f1" +
    "BjE3SQb0OQReDE9uQRvi6XtyS8eD9lmHNLFZpOpbeDko+UBsUoNRA6tMV2OR" +
    "312+4/sz5JPNheVRr0N0Pagfsdl05Jvu5C0U3Ofr1mDUwKpiNRZZgM/cWTbm" +
    "KpHaKKgfsdkJbEKDUQOriPWN/FJ4WYCyMVeL1PWgfsRmpyD7+yzjvTDr8pBX" +
    "Dawa1svNdWORBSgbc7VIXQ/qR2x2El1XMOvQYNTAKmE1FkF+Q+b278+Q783o" +
    "RXSaUP7A7N2STVLlCsbsiNtLhn1dk+O1IdQHlFuoGIZOn35OTAXnBVQMQ4co" +
    "m0TUPA1o47KV266OBrPqb7RTA6sEi8nGElqwrQU6DuUP+BvLkysYsyNuLxn2" +
    "ajMT6gPKLVQMQ6dPPyemgvMCKoahQ5RNImqeBrRxaeQnDYZnQXjpjavbYNTA" +
    "qsAiCvK7zMkL1ligKZQ/0N5U1sby5ArG7IjbS4a9qg2hPqDcQsUwdPr0c2Iq" +
    "OC+gYhg6RNkkouZpQBsX5Ci/X80zscoNRg2sAiye8NZDs4InLxgWSMnFJ0iV" +
    "KxizI24vGfaqNoT6gHILFcPQ6dPPiangvICKYegQZZOImqcBbVyY5wPdDYZn" +
    "aBVQA8uGRRPOmzSWww/MOPK9NGq7PnvqHJaxPjx9yo24rg3lARiDMMYRoOSG" +
    "Dxf6hZw5M6Y5dy8vxKR+FsiBMT35VMfx6UL7LS64VZ+RVWwwamCZsFjCK25q" +
    "F5YL6MGFodzSUYtMPH3KjbiuDeUBGIMwhncoaR+CfiFnzoxpzt3LCzGpnwVy" +
    "YExPPtVxfLrQvoH8weVZWbUGowaWhfUmuRdcX1X7728XlQvowUWh3NJRi0w8" +
    "fcqNuK4N5QEYgzCGdyhpH4J+IWfOjGnO3csLMamfBXJgTE8+1XF8utAerHqD" +
    "UQPL4KU36gJZjUXgAnpE7KmjFpl4+pQbcV0bygMwBmEM71DSPgT9Qs6cGdOc" +
    "u5cXYlI/C+TAmJ58quP4dKG9gZwTnp1VeYlaDSwDFkde0//Ssdnv8N5Kvgc8" +
    "eQ70Sai/CAI53AIiNr3Q3vLhyUmqfg6RGBGdVYM5T7jpvqp6lvGVmTxjy0AN" +
    "LBoWRZDfepHGUppLg0AOpblsEYkR0Vk1mPNW3l/+lj5Dq9Bg1MAisZ6zvOXg" +
    "dmMpzaVBIIfSXLaIxIjorBrMuZH3JR2/Uc0zt0jUwKIwn7Psraobv1uai0kg" +
    "h9JctojEiOisGswZeb9mvz5Ty3z+ogYWBYtw0u6quupYVd18P7ivjfy2cxPq" +
    "e3KLVBvqE+pbNp6cpOpHoE9ySOoNPB0lB5Rb5Nik2kd0UvQpt3RIau08bpj8" +
    "YX7mCj1/UQOLgJMX5MeiWNwpjcZSmktcPwJ9Em5+8wB4ckC5RY5Nqn1EJ0Wf" +
    "ckuHpNYugvyB5tlaVoNRA2NjPWd588FZYVjcKY3GUppLXD8CfRJufvMAeHJA" +
    "uUWOTap9RCdFn3JLh6TWLsrFK/L8RQ2MDSf8/L2zy7nOxWg0ltJc4voR6JNw" +
    "85sHwJMDyi1ybFLtIzop+pRbOiS1dimcuwLPX9TAmHCy8pzlymNVdeD+Le7z" +
    "OQgoXwYH7wcyBmjjMa99Yf2ZZw/s/c7yn7+ogbGwbocuv73abiylubR9zmlf" +
    "WH/m3QPyh5tnbpENRg2MBSd4zr6q3VhKc2n7nNO+sP4MsQfeccuGNxdOTm6H" +
    "dn27Ks2lh3ntC+vPUHtgWbdHamBorDfLSTedTrw0l07mtS+sP0PtgU/fqc/g" +
    "Ir7gWw0MDSf1vL1Vte+7M+RDV03q8RYy3oA2N4mfHuhP2RtxlQ/k4OoH8Gwo" +
    "J9SfgjxDNg2UPudtzH0M3DxoQzmhfoREH8x5kHobNqnUvs/epxsMz+rQqIEh" +
    "sR7ifuqOxsTva8PCTEHBacMFIvSn7I24ygdycPUDeDaUE+pPQZ4hmwZKn/M2" +
    "5j4Gbh60oZxQP0KiD+Y8SL0Nm1Rq31/51uxxBM8jz+yQqIEh4UTeeBATv68N" +
    "CzMFBacNF4jQn7I34iofyMHVD+DZUE6oPwV5hmwaKH3O25j7GLh50IZyQv0I" +
    "iT6Y8yD1NmxSafp/+826uchjC57boVADQ8FJSNe89l5M/L42LMwUFJw2XCBC" +
    "f8reiKt8IAdXP4BnQzmh/hTkGbJpoPQ5b2PuY+DmQRvKCfUjJPpgzoPU27BJ" +
    "hTEW+XBXDQyB9fOr7761qm74jsN3fW78ThvXB+UGyid9EMNHC+pbeDl40J/h" +
    "k8gnzlvIWA+0N30AlRMJ+FM6gD49uQVtCPWZk4L6RgzKXR+UG6jaEeh/8g59" +
    "Nsd6uKsGhoDJy0PcaXE9WBgDtWCENpQbKJ/0QQwfLahv4eXgQX+GT8KNyJiE" +
    "9qYPoHIiAX9KB9CnJ7egDaE+c1JQ34hBueuDcgNVO2LYvOGAbjA8w0OgBubF" +
    "eoj7hbu2iuvBwhioBSO0odxA+aQPYvhoQX0LLwcP+jN8Em5ExiS0N30AlRMJ" +
    "+FM6gD49uQVtCPWZk4L6RgzKXR+UG6jaEcNm9z2LebirBuaFCb/t5kZxPVgY" +
    "A7VghDaUGyif9EEMHy2ob+Hl4EF/hk/CjciYpLb78m1V9Y4PzXjnh6vqK4cN" +
    "X1uonIiXk6XDvODTk1vQhlCfOSmob8Sg3PVBuYGqHTFshIuM3z7iWZ4XNTAP" +
    "vGqR7vj1e2YfojK5F1A+BoxpQRtC/Rzo0yPHPmDz9g9V1bkXVtX/PrWq/tNj" +
    "qurfPHKykA9K51d+dWL/3yZ+Tqmqs1478ftBI76VA+VRnT59Qv0I9OFB+xwf" +
    "i6CR3+nXjNtg1MA8MNHXHzAm1zHRhS0GY1rQhlA/B/r0yLGHzVW3bTeSn/8H" +
    "lWoQY/DzD66qxz5h1nA+scfP0Zwb5YT6hPoR6MOD9jk+FkEjP+t7d3mm50EN" +
    "5GK9QnTVt4zJdUx0YYvBmBa0IdTPgT49cuzvnV1ByNXErzysUgd/GUhTe+wT" +
    "Z03OnJc1N8oJ9Qn1I9CHB+1zfCwC5Hj6Nfrc8mznogZyYYLuVYsxUSUfA8a0" +
    "oA2hfg706ZFg/4lrtq5OHlypw71K/PW/Obuqef/nnblx7oT6hPoR6MOD9jk+" +
    "FgFyvPDWFW8u1lXLXxyrqmvu7UfeVJfMPf1cA5R9APpg3oT2FvRJuYcX88rJ" +
    "JjnlrKr6Zw+r1CFeB/7+g6vqj0+pqo/v0XNLhnvi3nSUz2UQmAdtKPf4qvGx" +
    "gKHe96IGcmBjed0BPQkLFiYECk7mPcQCfTBvQnsL+qTcoyumNBU5lH/tb1Tq" +
    "wK4rv/eEOZsM98S96SifyyAwD9pQ7nKP/ZvTPOM5qIFUcq9aBBYmBApO5j3E" +
    "An0wb0J7C/qk3IMxN7GpkOwmwz1xbzrK5zIIzIM2lLvcM97VixpIhY0letUi" +
    "sDAhUHAy7yEW6IN5E9pb0CflHnWsuqnwIG4yyU2Ge6JRvyjK5zIIzIM2lLts" +
    "7ccxrl7UQCpM6KNHq2rPvTPknYBjswekynNwfcrcCXVSmfh41QWbfaXSh8z7" +
    "5LOMugxEvWe79q675kuCeRHqdyG/N33i7mGvXtRACmwsL76hf4HGwCumJ8/B" +
    "9cnGMmctPjpZ5H/9SFmtgjywPu+DukbzstObi/CWga9e1EAKTKR51WIt0Bh4" +
    "xfTkObg+2VjmqMUTT5FVKhCpy5/fquuVS2kuVfWFu3Vzmef7XtRAFCbxIly1" +
    "WAs0Bl4xPXkOrk82loxayMEpVyv9yFXMxZ/XtcvB27vumi8J5kWo7/Fa48fU" +
    "ePajqIEoTOA9t80+R9Ti2/3ILwA0Ufb3aJ1dMtaAPl2MGAraJKJyNqBNk7f8" +
    "6c59tpKK1Ok5r9E1dNfD2UeePIKKSQaIQeiTManPvW993wvPfhQ1EIUJfOmY" +
    "TlRNhIXgxGlvFIfFo08XI4aCNomonA1oU/OEU2RVCqn8zhOq6vO36Hp2roez" +
    "jzx5BBWTDBCD0CdjUl/t/QmnXdM+27k/A6sGIrCxyKWUmSgnAtTEaW8Uh8Wj" +
    "TxcjhoI2iaicDWgjB+M3HykrUsjlnz7MbjCsfWQfefIIKiYZIAahT8akvtr7" +
    "9wz3YFcNRGDgy450JMqJADVx2hvFYfHo08WIoaBNIipng6a+HAg5GDwshXTk" +
    "Nuk9nwush7OPPHkEFZMMEIPQJ2NSX+39CZ83HuyyB0RQAx58R+6Ju3sS5USA" +
    "mjjtjeKwePTpYsRQ0CYRlbNBrfvh3aWxDA0bDGsf2UeePIKKSQaIQeiTMamv" +
    "9v4W8gLNvA1GDXgw4JsPVtXXvjVD3kbc4tttvgaoT/mULd+dMRwfXg6WjosR" +
    "t5WDgaXz7s+WB7djIXV9+Tu36s31s9YwUa72EPW31rh3Dzg+lNyAOoQ+idLf" +
    "4qLbVqC5/L+jVWfxvEJQn/IpW747Yzg+vBwsHRcjbisHA+qUxrIYpg2G62et" +
    "YaKce+h4I2vg7QH6cOUG1CH0SZT+FlceW3BzOXVPO5jcIvUVzysE9Smf0vBv" +
    "xnB8eDlYOi5G3FYOBk35Z24ujWVRSJ0v+lxgDRPl3EO/8cgZsrZd+4A+6cOV" +
    "G1CH0CdR+g3OnfM9L2qgDwaSX3DrK55XCOpTPqXh34zh+PBysHRcjLitHAxq" +
    "mWy+8oxlsZgNhuvmrTHk3EPSWOpYb7piZtO1B47vE/hw5QbUIfRJlH6DS48s" +
    "sbl86s7ZB57CHHOg/hAwhoVnQzmhvsVE71OTxvLLpbEsBTn0nzrUXo9ejPXr" +
    "o24uNY8/Od3HUnByPHF3+8ynvOdFDXTBxvLyG3UiLsccqD8EjGHh2VBOqG8x" +
    "0fv3j5aKF5aFNPbjDYZrSIz164PNRfiNRyQ2tGXgzFN+351nf/JP9QcLNdAF" +
    "A8h3bzIRl2MO1B8CxrDwbCgn1DeQv2TcfIXF85g/2loTriHhGlIOrOYiyBXT" +
    "G66I+VgKzjw/dnQJzSX5lsiaCKH+EDCGhWdDOaE+kM3FTVdYHmeca6wh4TpS" +
    "DrqaS830NsmwWzqBefLWaPJP9QcLNdBF0/kzrqmqq45pvgiuuruNJ6e/CMqn" +
    "J2fMzLgteub5iUPr9crQv5pcyv/hyTNef8U2zfk2x094/kxX7NZlnpLnuz7d" +
    "vWYWXHPKZf6MQ0TnE5PbjC9KPCNm3z6aUts1YF7E02cMyoWX3dhuLvKq8eQ/" +
    "qkcQNWDBqxb5IWsmYCbqFIty+ougfHpyxsyM26JnnpFNt0zkOYQ0h9ddYdQq" +
    "AG3e+ZlZw/l3K/586ZcfWlWfPGivmYU37+g6S2N73eXVWjWX829un//o1Ysa" +
    "sKDjiw/rBMxEnWJRTn8RlE9PzpiZcVt0zFMOLTfXKvD3HjxrAJd9Xdenr5YW" +
    "tGkiV20SZ1VfIXvcSXrNuvDmHW0uNX94kvbRtY+OI2OAeRFPnzEoFz7yzQU2" +
    "l8/fpRMwE3WKRTn9RVA+PTljZsZtYcxTDu6q3SbIAWje4rA2RM3TgDak1pO4" +
    "q3g18/rLt9esD2/eqc1FmN4mHWrEMPZRCxkDzIt4+oxBeU3Ocxc1QORr7ppO" +
    "z7yuqv7ibpsrHag/CscA5QapeUb0/+0KHaR/OdnEr7k8lnffPC0bT871uHTX" +
    "atXmlx4anIeD1Ji+I8gfoNdurQ19hkB9OQ+i7AH1a5uz97X7QOS5ixogvGqR" +
    "n2llQn2JMcnROQYoN0jN09OXg8xNtAz+6mTjnn5OPG9CfcvGk3eth9To5x6s" +
    "c14GT35+YB4Ouc2lRm6T6DME6st5EGUPqF/bvPOWdh+IXL2oAUKH8nWWTKgv" +
    "MSY5OscA5QapeXr6q3BoHvVHVfXxg2l5E+pbNp7cW4//dZLOfdFIE37/Lmce" +
    "DvM2F0F8cM1cUF+uB1H2gPq1jXxAmb1g8k/1iyZqgNDhZ+7UCfUlxiRH5xig" +
    "3CA1zz79ZR+W6dXKuZU59768Lahv2XjyyHrIVYzkzbkskkc/3pmHwxDNRZA6" +
    "SD3ovxPUl+tBlD2gftNG3oIyWHPh85Yzrpt9S9Vx7mrzhVTuDkAbkJpDK/8t" +
    "qMMcXP0tPnZguYdEnh+87dM6/+xa0t7C8NNHV4yPHZzlzzktkku+1pOnw1DN" +
    "pUb+SDEHC+ZBonv3OFzfhs2rb0q7elEDTejotQeQrCTfQCXqwUlY0Aak5sBi" +
    "mwVHDq7+Fsu8apGDKQeUuc9VS9pbGH768GI86vF6botCYnfm6TB0cxHE50fl" +
    "zBn5RPOK7t3jcH0bNu9IfL+LGmhCR5ccQbKSfAOVqAcnYUEbkJoDi20WHDm4" +
    "+lss66pFNqFcNTFvhZFzE1VL2lsYfvqIxPjtJTaY+upF5ekwRnMRZE+d8wGd" +
    "TzSv6N49jrEetexjie93UQNN6IiJpk5UwUlY0Aak5qDmYMVADq7+hNPO2d4Q" +
    "i0SuWLryVhh5N1G1pL2F4aePSAyp8bIaTH31ovJ0GKu51PxBx20S8yCRvdvC" +
    "WI+m/MSrR2guT5s4/dydbT4LlPyuNq7cgDqMqeTgD06sql9/xPj8pb+8vREW" +
    "hTSWj+zvridrxdp660F7C/qkDxWD9ga17L8uqcH889/U6+uxiKtWidNcb6ue" +
    "qv7e+iTy/L0jNBdx2rUJujaKmognN6AOYyo5kAXhIm0C8nK32micP2rF2nrr" +
    "QXsL+qQPFYP2Bk35P1nyQ95VY3qbdJldqymsv7c+ifDnXvveTKcGavh9ueK0" +
    "bxNYG0VNxJMbUIcxlRxsanN566f8erJWrG2qvQV90oeKQXuDpvzD+xdzVbBu" +
    "yBU5azWF9ffWJxE2l76rFzVQQweluawOf/I8XUurnqwVa5tqb0Gf9KFi0N6A" +
    "OmdfpmtQmO1tab6terH+3vokcsnhEZqLOPU2gZJzIp7cgDqMqeRg05rLIx+l" +
    "69hVT9aKtZW/fk3+50lAxhzkQWMT+rj4q8iRORlQR5BYrEVhdlUnzbfrPHDN" +
    "PbnHRxNeMVIDNXRw2e1V9ek7E7kDpMojOD42qbnIRnr3VzvmHQG1of8xeNVl" +
    "Om4yW/n/3C9o/4UZv3/iVp1YOw/sEXkHPqENewN7R40aqKEDBgjhbG5XHsHx" +
    "sUnN5f8+r2feEVAb+h+DIZuL+KL/wja//vCq+uB+o359YI+wsVjN5YxrB2wu" +
    "4owBQjib25VHcHxsSnORV4d65x0BtWGMMRiyuQiPeJSOUdhGrm6Tao49wsZi" +
    "NZcX43ek5WNC7B+CGqhpGj9vrw4QwtncrjyC42NTmsupZzvzjoDaMMYYJG30" +
    "LhpzkNtCxihoprdJrKMF9ggbi9VcXhN8xUgNCDSUn3X8szvG55MGf3YUGHZ9" +
    "/NrDdeHXjb/7C3peQ8A4Y/CKy7CeA/DwcvUSQvb+Fft0/Zqo8xbgrYcGbC7i" +
    "jAHGgBMtzWXGyWfreQ0B44zBGM3lleXZSxi5TZJ6sYY16rwFkO90Yo9gDxHU" +
    "gEBDccYAY8CJluYy2xzRRU+FscZgjOYilHfupvE/TtQ1FNR5C8IewR4iqAGB" +
    "hvKra3Q+BpxoaS5V9V8el7boKTDWGIzVXP7Pc3WsQj/WbZI6b0HYI9hDBDUg" +
    "0PATR2dfc5eK2DWhnFB/anMHMOz6+NU1by5v+ORsHqouBhGdJow1Bi9/P3K8" +
    "ow1zinLZTTpWoZ///jRdx1zYI9hDBDUg0DCyUS1SNzv1pzY7uLnIg9yu2nCe" +
    "UZ0mjDcGYzUX4bd+W8craOTW+jnnx/ZElOcGPh2tBoTSXFYDuSXqqg3nGdVp" +
    "wnhjMGZz+eNya+Tyiw+tqgu+Et8TUUpzObrezeWkV2/PQ9XFIKLThPHGYMzm" +
    "IreMjFfYRm6DUvdElEGayzOvnT3Qla+485APNTXx5IT6UyR2A8/mo6LTYJ2b" +
    "yzu+0pi7MVeiaoPaUZ/xxuCll+q4Lk7eTVn5OgaN1OTM83WtTFhbC9ocHai5" +
    "iJNoEmpzO3JC/SmYlGezKc3lb/1tzN2YK1G1Qe2oz5hjMHZzWdf1HYtffMjk" +
    "j9KX7VqZsLYWtDlamstaN5d//BDM3ZgrUbVB7ajPmGMwdnN57NN0zJ2K1KKv" +
    "VibUt6DNhFfj513ZQwQ1IJTmsnwe8RjM3ZgrUbVB7ajPmGMwdnN5Ynmo274N" +
    "Iqwlob4FbY7q5mJ93aVqLGwuz7muqj4yCfDhb6QjdinQfoqMN2EMQPnD1rS5" +
    "PPwx/fOOoGqDWjLmGLzkUr3OHsyT82jqin/G3EnIFe7bv2TXxkLtEeqw1tCv" +
    "eVXgB9JUY2FzedU+O6kIKnEH2k+R8SaMAShf1+by+6f2zzuCqg1qyZhjUJrL" +
    "ePze0/prY6H2CHXoD/o1Wc1FrlRKc1k+crnfN+8IqjaoJWOOQWkuw/NXJrdB" +
    "zzrfr42F2iPUoT/o12Q1FxqU5rIcSnPZhvOgPmNuMnIb9LYvx2tD1B6hDv1B" +
    "v+adtwzQXF456VAf/EYmt7f50DfaKP0AHxI/DRiDnPCqqvrdpw7LL/3a+Lzs" +
    "ctTKqaWFqh3gxh2DF12CHLh+Rp6cq5ID1m4M/vPj9D5o8ncW8P2+EodzD9Vz" +
    "BN5RmothH4A29Kn0nZg5PlLlFsyBcm7eMVhEc1Hk2OfYNHjoiFfIchv0zPN0" +
    "TCFUzxHIai7yfZiluQBvHk7MHB+pcgvmQDk38RiU5jIfcht0/lXdtQrVcwSk" +
    "LyQ3F6Fp8JIbtOMwWDBubqUfQBXTg/YBaEOfSt+JmeMjVW7BHCjnRh6D0lzy" +
    "kdsgr1aheo7AIM3l2ddpx2GwYNzcSj+AKqYH7QPQhj6VvhMzx0eq3II5UM7N" +
    "PAaluaRT3wZFahXRGYPBmssVk6QvN5DxPjx9T25x+RFg+On1eURDG0J95TMD" +
    "FYPkxHTmRX1u6jE465J2TC+nZcG8CPVZ64f+lp57Dv9ochv0lquMeFES90AE" +
    "+hBegeYib2FhH1GNpTQXDfWVzwxUDJIT05kX9bmxx6A0lzi/81QjTiqJeyAC" +
    "fQhsLuwhpbl0LAChvvKZgYpBcmI686I+N/cYlObiI7dBp51nxMghcQ9EoA/h" +
    "TLzZlj0k1FxO2dMdgEkQT9+TW5Tm0oMzL+pzk49BaS79yG3Qm6/qiJFD4h6I" +
    "QB/CIM1FuGyS5AcMZHzRpOYQ0aeOx2W3A/hbF7jRx+D579Nxm7C2FrRZBl5O" +
    "D8loLo85IS2G2nfG3qOPVOjPjHukNJewPnU8rGKvI9zsY1Cai0Zug55+nvbh" +
    "xVD7zth79JEK/Zlxj5TmEtanjodV7HWEm34MSnNpI7dBb/qito/EUPvO2Hv0" +
    "kQr9mXEnY6ddU5pLSJ86Hlax1xFu/DEozWUb3gYRL4bad8beo49U6M+Me6Td" +
    "H+ZqLhfeWlWXHjY4Aih3uORIG8pNvJiUA8Y049IO8ksI/eXAHDxob0EbwM0/" +
    "Bs+9GHGRo6qlkSdR9TZ0kkmsHelrLnIbdOpbBsibOYqfw2m1y4JxDw/YXM47" +
    "ZATsCJpCVrG9mJQDxjTj0g5yLqjylwNz8KC9BW0AD8EY7PTm8g8nt0FvuHKm" +
    "M3fezFH8iN8GymYIEPO9Q/4QvXyniwpoBFVyh6xiezEpB4xpxqUd5FxQ5S8H" +
    "5uBBewvaAB6EMdjJzeXRJ7R15s6bOYof8dtA2QwBYsrFBnsEe4igBgQavuxG" +
    "I6ARVMkdsortxaQcMKYZl3aQc0GVvxyYgwftLWgDeBjGYCc2l+lt0HlaZ+68" +
    "maP4Eb8NlM0QIGbkW+gENVDTNDzj2qq6+DbN+w6nQfuLZawB9S0bygn1I7yP" +
    "OD4pJ9Q3Yzgoe8awSLRhIxiD51yMHIy5EeataoN5KH1A/akNfCobLyfwL7aa" +
    "i9wGvfZKOy/lMxXLp4PSd3Kg3IJfyzJXczl5tw4wTcxIvg/ae4WwbCgn1I/A" +
    "Ans+KSfUN2M4KHvGsEi0YSMYg53UXB51Qn9eymcqlk8Hpe/kQLmFXGx4jUVQ" +
    "AzXsTAwwTcxIvg/ae4WwbCgn1I/AAns+KSfUN2M4KHvGsEi0YSMYg53SXOqr" +
    "lb68lM9ULJ8OSt/JgXKLZwTe4yKogRo2l/MP6SBM3IP2XiEsG8oJ9SOwwJ5P" +
    "ygn1zRgOyp4xLBJt2AjGYKc0F/q38lI+U7F8Oih9JwfKLdgb2Dtq1EANHbx2" +
    "f1W957YV5FaQKs9AXopromIY0Oa9MtaAMVyMGEoHMAc2gjE48706j1ZOt2qo" +
    "oxCdPqhvQRvi6LOWSh9yUycxppIbuDEdaD/10cjhvIMjNJcX36ATWQm8BfDk" +
    "GfQVvwvaJB8oYsRQOoA5sBGMQWkuPTqJMZXcwI3pQPupj0YObzwwQHPhj6O9" +
    "4HqdyErgLYAnz6Cv+F3QJvlAESOG0gHMgY1gDEpz6dFJjKnkBm5MB9pPfTRy" +
    "kIuMuZuL0HTwrGt1IiuBtwCePIO+4ndBm+QDRYwYSgcwBzaCMSjNpUcnMaaS" +
    "G7gxHWg/9dHI4QV7243F+nrLGjXQhB3qolvTkM8kNaGcUD9kc0ubiwj1Dagz" +
    "L/Q/hXkadi2ceQwBG8EYPOu96bWeu3YLgDlSnsUAa+7lRfmFgdo29Z8ZfBla" +
    "UANN2Fze2RG8C06EckL9kA2LQ6hvQJ15of8pzNOwa+HMYwjYCMagNJcEBlhz" +
    "Ly/KLwzUtql/wtUjNZdz9+vAfXAilBPqh2xYHEJ9A+rMC/1PYZ6GXQtnHkPA" +
    "RjAGpbkkMMCae3lRfmGgtrXu+Te3+8GgzeVFN+jAfXAilBPqh2xYHEJ9A+rM" +
    "C/1PYZ6GXQtnHkPARjAGpbkkMMCae3lRfmGgtrWufMaQPYE9o4kaaMLPEDx9" +
    "jw7cBydCOaF+yIbFIdQ3oM680P8U5mnYtXDmMQRsBGNQmksCA6y5lxflFwZq" +
    "W+vKL4E0+8Gpe+ZoLgI71dsnl0bvusXmAod33dqGcgvaMCahfQQVw8nTi0n5" +
    "FPqlHNBnBPog1GcjGIPT39OfA3McggtuBTIGlI0j96D9FORBm1SUf0MnlYi/" +
    "WpbyvEVQA4TNRX7GkcGZRBc8YJRb0IYxCe0jqBhOnl5MyqfQL+WAPiPQB6E+" +
    "G8EYlOayDW1SUf4NnVQi/mT8TQnvzK1RA4QOn7dXB+9KlPCAUW5BG8YktI+g" +
    "Yjh5ejEpn0K/lAP6jEAfhPpsBGNQmss2tElF+Td0Uon4k3E+IhmkuQhNhyft" +
    "1sG7EiU8YJRb0IYxCe0jqBhOnl5MyqfQL+WAPiPQB6E+G8EYlOayDW1SUf4N" +
    "nVQi/mQ89XmLoAYs2LHePLlEesfNAW5xoL4FbOSZTxPKlf2qkJon9Qn1LRvK" +
    "ARvBGJz2bh03GW9elBPq5+D5pNzS8ZjX3oI+c7g5/XmLoAYs2FxefuMsoAuT" +
    "JNS3gE1pLj32EZ0GbARjUJpLAvPaW9BnBq9P+LBiEzVgQcfP3VvpSVgYibag" +
    "vgVsSnPpsY/oNGAjGIPSXBKY196CPjN4ScKHFZuogS6ajuW5i5qEhZFoC+pb" +
    "wKY0lx77iE4DNoIxKM0lgXntLegzg9PxzXN9H1Zsoga6YOeS73V42yFwcxv5" +
    "9romrn4G9JEDfSowD8rpz0L5cGpDOaG+WU/DrgkbwRg8/d06LxfMi3l7+pRz" +
    "vaw1YwxXn3LmYOShgL6bA/1TX8YYA7g+DRueffaGLtRAFwwgHwXwElMTJ9TP" +
    "gD5yoE8F5kE5/VkoH05tKCfUN+tp2DVhIxiD0lx6gL6bA/1TX8YYA7g+oR/9" +
    "GRELNdCFvPTUDCD/30tMTZxQPwP6yIE+FZgH5fRnoXw4taGcUN+sp2HXhI1g" +
    "DEpz6QH6bg70T30ZYwzg+oS+PF8dvbkIDKJujTgRTpxQPwP6yIE+FZgH5fRn" +
    "oXw4taGcUN+sp2HXhI1gDEpz6QH6bg70T30ZYwzg+mzoyi8r8iVoeTMd+0IX" +
    "aqAPNpfn750lEOZgm7ceaqP0DZtUeSQGdYgXI4Q3dycG9d8qPoBrA9gIxuCU" +
    "d+u8Fg5ra9RqDFhvyj2UPeeQMw/Y9+2hl2S8K7eJGuiD36t74m4j+T44sUOB" +
    "4nvFdOSRGNQhXowQ3tydGNTnpuDGMG0AG8EYlOayDeUeyp5zyJkH7Pv2kHy1" +
    "7cKai8Bgr95nTKALTuxQoPheMR15JAZ1iBcjhDd3Jwb1uSm4MUwbwEYwBqW5" +
    "bEO5h7LnHHLmAfuuPZT7xrkmasCDAeUzB2oCXXBihwLF94rpyCMxqEO8GCG8" +
    "uTsxqM9NUZpLD6ytUasxYL0p91D2nEPOPGDftYdemPnGuSZqwIOfjpQHPvJZ" +
    "o7XmAKB8GSAn+ch7E6UfgD7YCMbgpIt0Hsk468N5RUj1SXmEIXwsi1OMV4fZ" +
    "CzzUQAR2NPktEya3VjgbbSmU5rKNsz6cV4RUn5RHGMLHMjhn3/xXLYIaiMDA" +
    "8nMDTHCtcDbaUijNZRtnfTivCKk+KY8whI9lIN/ZxDPOHhBBDURhcPktaSa5" +
    "NjgbbSmU5rKNsz6cV4RUn5RHGMLHMpBXgZtnO/pZIqIGorC5yC+xvfFgmzeQ" +
    "A23kTXgtYG/h+fDkFrRROPMgzNnKm8ydk8RJ9PEfnzQ//wFQftZn2zFTc7Sg" +
    "D8K60N7yQTlR+oEYRPlw5BGYh5IDT85nqrlXLYIaiMKPA5x4daUPFHEmSnsL" +
    "z4cnt6CNwpkHYc5W3mTunCROog/q5+D5TJVHoA/CutDe8kE5UfqBGET5cOQR" +
    "mIeSA09+Jt7LtpTmIjAJ6XqtA0WcifJAWng+PLkFbRTOPAhztvImc+ckcRJ9" +
    "UD8Hz2eqPAJ9ENaF9pYPyonSD8Qgyocjj8A8lBz0yYd6kFujBlJgIs+4pmof" +
    "KOJMlAfSwvPhyS1oo3DmQZizlTeZOyeJk+iD+jl4PlPlEeiDsC60t3xQTpR+" +
    "IAZRPhx5BOah5KBPfsac78glaiAVJvOKm6rSXAJ5k7lzkjiJPqifg+czVR6B" +
    "PgjrQnvLB+VE6QdiEOXDkUdgHkoOuuTWVUvug9waNZAKE5JfZXzd/g4OAMqH" +
    "wItBuaVDqE9S9S2bVOhvDJ+UR3VS9CkfA8ZcFZgnob5Fjo3B0FctghrIgUnJ" +
    "b8oy+SkDFaIXLwbllg6hPknVt2xSob8xfFIe1UnRp3wMGHNVYJ6E+hY5NuDs" +
    "Ea5aBDWQAxPrvHoZoBAuXgzKLR1CfZKqb9mkQn9j+KQ8qpOiT/kYMOaqwDwJ" +
    "9S1ybAC/7WCIqxZBDeTC5MyrlwEK4eLFoNzSIdQnqfqWTSr0N4ZPyqM6KfqU" +
    "jwFjrgrMk1DfIsemwWsmPOXr7bOb8zkiCzWQC5uLfBeEJJ7EPs25+9ukylWM" +
    "CJ4P5kD2azwfhD6VvQFjpkJ/FsyLPlwC86KNkjs+KKe/qU+x64NxHbmKOQaB" +
    "eXhy5j3k+1qIGsjFurR6lTGZXliIQLE8uYoRwfPBHMh+jeeD0KeyN2DMVOjP" +
    "gnnRh0tgXrRRcscH5fQ39Sl2fTCuI1cxxyAwD0/ezPmc/eNdtQhqYB7YXJKv" +
    "XliIQLE8uYoRwfPBHMh+jeeD0KeyN2DMVOjPgnnRh0tgXrRRcscH5fQ39Sl2" +
    "fTCuI1cxxyAwD0/ezJm//zzkVYugBuZh7qsXFiJQLE+uYkTwfDAHsl/j+SD0" +
    "qewNGDMV+rNgXvThEpgXbZTc8UE5/U19il0fjOvIVcwxCMzDk9f5jn3VIqiB" +
    "eWFzecYk4XNu2mJfm7NvanNcrwF15GWzPlQMR25BG0ViTtk2fdCf4ZPzItRX" +
    "0L8RgzCGB+0tlA1yUnLCOVh4MQntDVwfqQwRY8tujPe1EDUwL9bVy1l7q9Jc" +
    "cmz6oD/DJ+dFqK+gfyMGYQwP2lsoG+Sk5IRzsPBiEtobuD5SGSLGxOblxief" +
    "16K5CEz6aVdX1autQrBQBtRRxQIqhiO3oI0iMadsmz7oz/DJeRHqK+jfiEEY" +
    "w4P2FsoGOSk54RwsvJiE9gauj1SGiHHT7PaHZ5RneAjUwFAw+TOvNQrBQhlQ" +
    "RxULqBiO3II2isScsm36oD/DJ+dFqK+gfyMGYQwP2lsoG+Sk5IRzsPBiEtob" +
    "uD5SGSCG3EXwbA7xblwLNTAUnIAgb6yT357dOGReTSgfgFcCyodgjBg5PnNs" +
    "UllEjGSwj5jjK2UMKB89yIeK+RBX4NkdCjUwJJyEfKM4J7wRlObSSY7PHJtU" +
    "FhEjmZGby7w/cpaKGhgS6+Gu/AQsJ732lObSSY7PHJtUFhEjmRGbi/xCB8/i" +
    "WjcXgZN56tWzyzNOfq0pzaWTHJ85NqksIkYyIzYX/g7R2I1FUANjwEnJT5HI" +
    "y2HSZFrIGBC9FjcByh3o34rhyZmDqw95l06fPmtFfdMGUJ9Q34I2hPoKrnkA" +
    "xnARmyaUWzoO3jyUfysG5UDFCEAfFtY7ccd6iNtEDYwBJya88Pr24kyJFC9x" +
    "wQj9WzE8OXNw9SHv0unTZ62ob9oA6hPqW9CGUF/BNQ/AGC5i04RyS8fBm4fy" +
    "b8WgHKgYAeiDyPdaL/IhbhM1MBac3Mm724szJVK8xAUj9G/F8OTMwdWHvEun" +
    "T5+1or5pA6hPqG9BG0J9Bdc8AGO4iE0Tyi0dB28eyr8Vg3KgYgSgDyJ3CTx7" +
    "PJtjoQbGwnq4KxNvLVKkeIkLRujfiuHJmYOrD3mXTp9+ZDMrG0B9Qn0L2hDq" +
    "KzCPCIzhIjZNKLd0HLx5KP9WDMqBihGAPpo813hPy9CfH+pDDYwJJyrIT0e+" +
    "9IYebgSp8gj04UH7APIenybKp4fhM5kl+HwZ8PRDNkDpB3BtGIdyQn3JC7g2" +
    "njxAHetFNyzvdqhGDYwNJysFkJfJVGG7Cpwqj0AfHrQPoDZaKobPZJbgUx1i" +
    "Rz9kA5R+ANeGcSgn1Je8gGvjyQPUsfiTrILIeR7HRA2MjUyQk5bnL6qwXQVO" +
    "lUegDw/aB1AbLRXDZzJL8KkOsaMfsgFKP4BrwziUE+pLXsC18eQBJM7pxnOW" +
    "Rd4O1aiBRWB9cOr0a1DYrgKnyiPQhwftA6iNlorhM5kl+FSH2NEP2QClH8C1" +
    "YRzKCfUlL+DaePIA1nMWgWdwEaiBRcHJC+bzFxYwVR6BPjxoH0BttFQMn8ks" +
    "wac6xI5+yAYo/QCuDeNQTqgveQHXxpM7vPCG5T9naaIGFgmL8ORJYV50fVW9" +
    "uMkN/Yh+E8pbvrrwbCjPQB6wNXFjUE6ob9iwNoT69Ef9KY05TOdB6JNQPwBz" +
    "oDwH1yfy5ryJsjdIjkl9B/lqE54paTo8d4tCDSwS6+Xpk3ajaFyAORfMxLOh" +
    "PAO1Gb0YlBPqGzasDaE+/VF/SmMO5qGiT0L9AMyB8hxcn8ib8ybK3iA5JvV7" +
    "OO0afZaW8ZyliRpYNCyIIIU6XjguwJwLZuLZUJ6B2oxeDMoJ9Q0b1oZQn/6o" +
    "P6UxB/NQ0SehfgDmQHkOrk/kzXkTZW+QHJP6HTzbeIAr8KwtGjWwDFgU4bnX" +
    "bRWPCzDngpl4NpRnoDajF4NyQn3DhrUh1Kc/6k9pzME8VPRJqB+AOVCeg+sT" +
    "eXPeRNkbJMekvoF8+ZM8TuD54RlbBmpgWbA4UrDn7J0Vr4UUtAf5zFIf1J/C" +
    "GMTTpzxAKK9EfeoQ6qt5EOoH8GJ68kHgPCxg4+YF+xcCpR/xSbwcGXPv6j1n" +
    "aaIGloX1/EUazAucghMuKKH+FMYgnj7lAUJ5JepTh1BfzYNQP4AX05MPAudh" +
    "ARs3L9irg079iE/i5diMt9duLMt+ztJEDSwT6/0vUsBWg+GCcAEcqD+Fi0o8" +
    "fcoDhPJK1KcOob6aB6F+AC+mJx8EzsMCNm5esF92c5E3nvKsCDxTy0QNLBsW" +
    "SzUYLggXwIH6U7ioxNOnPEAor0R96hDqq3kQ6gfwYnryQeA8LGDj5gX7ZTYX" +
    "64/wqjUWQQ2sAiyaIC9Ry1dkjoG8ea8J5R459rQh1B+DnRJzY7iuqk5ZgyuW" +
    "GjWwKrB4gnxVnyr4AMy74XPsaUOoPwY7JeamIB+R4ZlY1cYiqIFVgkUcq8HM" +
    "u+Fz7GlDqD8GOyXmJrBujUVQA6sGiylIoVn8eZh3w+fY04ZQfwx2Ssx1x/o2" +
    "OWFVXnLuQg2sIiyq8IxrZl8yLG+2ayJjTTx5Dp5Pyi3kPTwtDD8toE9/Vh4e" +
    "tI/g+ZhXHoE+CPXlk8KKVJ9z2mcxifOs6+w3ya16YxHUwCoihWRx6wbjLbIn" +
    "z8HzSbkFmwV9KKBPf1YeHrSP4PmYVx6BPgj1VWMw6kcfZF77HLoayyq9l6UP" +
    "NbCqdDUY+RxS3yKPsQk8n5RbsFnQhwL69Gfl4UH7CJ6PeeUR6INQXzUGo370" +
    "Qea1T0X+cK5zYxHUwCrT9fq+vKGoa5HH2ASeT8ot2CzoQwF9+rPy8KB9BM/H" +
    "vPII9EGorxqDUT/6IPPapyCNhXt83RqLoAZWna4GI++DOfNag+sA5RaejSe3" +
    "SLWhPqG+RY5Nn70FbUiqfq5NIvJDYU28mPLJ4z6on0vX/l63xiKogXWg6xbp" +
    "xKur6gwumLNpTDwbT26RakN9Qn2LHJs+ewvakFT9XJtEVrG5yB9I7ul1bSyC" +
    "GlgXuhrMCWwwzqYx8Ww8uUWqDfUJ9S1ybPrsLWhDUvVzbRJZtebS1VjkNol7" +
    "f11QA+sGF0M1GGfTmHg2ntwi1Yb6hPoWOTZ99ha0Ian6uTaJrEpzkX1qfbpZ" +
    "WIeXm/tQA+sIF0WQJ+3yStKzwDMNqKO4FkAub3LyUD6Ayok6Xk5RnR7cHCyc" +
    "mJ5Pyqc6xLFR8gC08fBiWngxZUz+EHLvbkJjEdTAusLFqRvMMyb3q82Nyk1i" +
    "bmbCjQE5N5GF8gFUTtTxcorq9ODmYOHE9HxSPtUhjo2SB6CNhxfToi+m/OHr" +
    "aizc2+uKGlhnuEg1cj9bb1RuEnMzE24cyLmJLJQPoHKijpdTVKcHNwcLJ6bn" +
    "k/KpDnFslDwAbTy8mBZdMeUBrfUelk1qLIIaWHe4WDVPvVpvkM7NTLhxIOcm" +
    "slA+gMqJOl5OUZ0e3BwsnJieT8qnOsSxUfIAtPHwYlowpmD9zOomNhZBDWwC" +
    "Xe8VkL8WT99jbBQPbhzIuYEslA+gcqKOl1NUpwc3BwsnpueT8qkOcWyUPABt" +
    "PLyYFs148sa4rtugTWwsghrYFOQlPC5gjfz1kHveGvmUdZOmzCJVf2qzp81p" +
    "hPrA049AnySi7+ZBOQnoq5iAtaR+BPpkDpR79iqnhg95B/mTOm6D1vU9LBHU" +
    "wKbBxayRvyLRjUNS9ac23HiE+sDTj0CfJKLv5kE5CeirmIC1pH4E+mQOlHv2" +
    "KqctH10vMwub8IpQH2pgE+Gi1shfE/nL4W0ckqo/teHGI9QHnn4E+iQRfTcP" +
    "yklAX8UErCX1I9Anc6Dcs2dOcvtt/W5zDffoJqIGNhXvNqlv4xBvo1lw8yVv" +
    "Zkc/An2SiL6bB+UkoK9iAtaS+hHokzlQ7tk389mpt0FEDWw6XOwauU2Sr9CU" +
    "vziFQjKThnLqhBM6moqw6bdBRA3sBLpeTRLkHlltnELBQfZN19WKwD24E1AD" +
    "O4WuDz4K8pK1vPGOG6hQIHIL1PdsZSfdBhE1sNPgZmgit0qyObihCgVB3pjJ" +
    "PdOk3mM7FTWwE+l72CvIJpK/UDXyw1Qt9vg07SO4MSg3oE9CfUL9qY2Th9LP" +
    "IbF2qfpTGwfqnyx+t3jq7v5boJ18tdJEDexkuEmayK2S3FebG5MHzkBtVgc3" +
    "BuUG9EmoT6g/tXHyUPo5JNYuVX9q40B9aSon7en+TFBNvZcKpbmYcMM0kftr" +
    "tTl54AzUZnXgZqc/JTegT0J9Qv2pjZOH0s8hsXap+lMbB+p7t0A77ZWgCGqg" +
    "MMO7VZLnMcc3KQ+cATerBzc7/Sm5AX0S6hPqT22cPJR+Dom1S9Wf2jiIjjzU" +
    "l3Uut0B5qIFCG24mIlcycrsk39+bwkmAckJ92fguXozd/dDe8qHk9GPYuNAH" +
    "ob4H7QM85Wq91mSXsV8K26iBgg03FqmfyaiN3YE6lA7UV43EwothHKomtLd8" +
    "KDn9GDYu9EGo70H7HiJNZZ2/13aRqIFCN96tUkqTUYfSgfqqkVh4MYzD1YT2" +
    "lg8lpx/DxoU+CPU9aA+etjvWVMotUBpqoOATbTLyEFBt9C3UoXSgvmokFl4M" +
    "46A1ob3lQ8npx7BxoQ9CfQ/abyFNxXv1pzSVfNRAIU6kycjDQHkuI40mBXmQ" +
    "2MdTxaeH4XdunBgqT+LYh3X6oD2Q9Yg0lXL7Mx9qoJAHN6aFbGi5/FaHwYCH" +
    "lPDAmBh+58aJofIkjn1Ypw/aT5APFEYailCayjCogcJ8cKNayNWMbHTz8G3B" +
    "Q0p4eEwMv3PjxFB5Esc+rNPHlp00FLlK6XspuUlpKsOiBgrDwI3bRddtEw8p" +
    "UQfQgoduCJwYKk/i2Id1ekhpKMIuY/0K86MGCsPS9/UO5EkTnjzhKfLfr/cj" +
    "B4iIbRMl93xsxa6hvgVt6JP6EeiDUL8mpaEIu4z1KgyHGiiMBzd3H3JQ6tsn" +
    "Cx646aHb1UbJPR9i04D6FrShT+pHoA9S69U1Yu362GWsS2Ec1EBhfPq+S6YL" +
    "NhseuOmh29VGyQHlbBTUt6ANfVI/An00/aQ2E6E8S1kOaqCwWCIvZ1tYjWbT" +
    "mov875xmIpT3piwfNVBYHinPZyzkmU3NOjWX+qos5zaH7DLqWlgOaqCwOvDg" +
    "FDS7jLoVVgM1UFhdeLB2IuV7U9YHNVBYD3IeCq8jpZmsL2qgsN7kPiBeNuUB" +
    "7OahBgqbCw/0Mthl5FXYTNRAoUB4C1beN1KIoAYKhUJhCNRAoVAoDIEaKBQK" +
    "hSFQA4VCoTAE/x/kF6zNcMVrGAAAAABJRU5ErkJggg==")

STEP_OVER_ROLLOVER = ("data:image/png;base64," +
    "iVBORw0KGgoAAAANSUhEUgAAARcAAAEXCAYAAACH0wDUAABCaUlEQVR4Xu2d" +
    "edx9VVXwfd9MGzSrt7RSw8xXSysrB1ARUFBAQBFQcDZxQFHBnM2cwDnSJGdQ" +
    "RMUBERVBUBFEUREIldGgQFHAcEpNLd/PZ7/Puvc5v98537XOWXvvM9z7PHef" +
    "z+f7z17jXmfvdc85d7rBeSHcoFAoFIZGDRQKhcIQqIFCoVAYAjVQKBQKQ6AG" +
    "CpufVx0TwnOP3MoTXx7CLk9pctsHrSnexee37qNtH/Lcpn+BORQ2P2qgsDn4" +
    "4Kfmm1o2umx4NoVFcpdHbm1Ab/1waTybFTVQ2FhUVyEpVxvLSnUVVK52Ngdq" +
    "oLDcSDORV33ZiNycm5Wq4bAWheVGDRSWC7ltGLOZ3OURIez85CbP+SfNaV/c" +
    "CmUCfQiMNQRSB6mHNFnWqrBcqIHCYpFmIg9Yh7rFkecbVcN4xTvWmsMXQrj+" +
    "+yH84hcG/y+DSB/SlN78oXke+z1nnhdzzaE0m+VFDRSmRzZGn80mG+y+B4Vw" +
    "4GEhPOv1IZxydghf+FoIP/vvRH4OKLd0CPUdLr1ynq/kLcg8+lylSVMujWY5" +
    "UAOFaZB3c+QVl5sjBtl8+z47hMOPXtuc/56/sRUxjYI6hPqZSNN54wfnDfOP" +
    "HqhrEIM8qynvRi0ONVAYF7nlSX1lrjeTLVck3NRDbOwYf9Qh1B+IerNJrZ8g" +
    "dZeGzvNRGA81UBgeeacj9RmK3B40mgnhph5iY8f4ow6h/khIXaQ+0nRTmo2c" +
    "h/LO0zSogcIwyOV4yofXfmunEB730hCOPTmEH/9XBD/V/ARQrnyAnwBlb0E/" +
    "lAPGYM6zvBN9Cp+7IIS//cd5HVnbNuQ5V3k+Mx5qoNAPaSopVykPflYIb3h/" +
    "CFd/x9hUXRgbTG1SQh+AG1/ZW9AP5YAxmHNuc6kjDVoaNWvdhlz5lKuZ4VED" +
    "hTzkFTC2qfzVw0N42dtDuPAKYyPFYmwqtUkJfQBufGVvQT+UA8ZgzkM0l8pO" +
    "GrY07vs8SZ8Di9JkhkUNFNKQxRhzz/9He80v2z9/wfrG7Qs31E+NTUroA3Dj" +
    "K3sL+qEcMAZzHrK51JFGLvWX88BzQ0qTGQY1UIgjtqlUz1G4qbj4k+GG+qmx" +
    "SQl9AJUj7S3oh3LAGMx5rOZSR57PxN42ybtMPPeFONRAoZvYpvLYl4Twla+H" +
    "8IMfjcSPDagDfggojyIx5iR4OVG+riPn59AjQvjNiIfApcmkowYKNtJUuOAs" +
    "Rm8qFT82oA4ozcXWueqa0mTGQA0UmsgHr7wHtbIoZXFO0lQqZIMQ6oDSXDp0" +
    "fhTfZOTKtbyF7aMGClvxPqdSNRVZlFyoo1NtkjrUAaW5dOjUkPP5kreGcBvn" +
    "4a98ToZrprAVNVDwb4GkqTz9tSFccXUI1/+gsGx894dNKE/hiPf4Taa8s2Sj" +
    "BlYd7xaoNJXlZ8jmUvGit3TfLsmtUvmSZBM1sKp431De8YlrC+cSvegKy8cY" +
    "zUWQF5VHv1ivjTpyK821taqogVXDe2tZXq2O/qheaIXlZazmUnHC6eVWKQY1" +
    "sEp4P9D01NeEcNlVIVz73U3C9Q7UH4IpYiwIWR9dt0pyi31ebb2tGmpgFZC3" +
    "l7uuVnZ4wvxnGbmYNjzc6IT6QzBFjAVyzkUh7PUMvYbqrOrb1mpgs9P1TpC8" +
    "Cr32WL2ANg3c6IT6QzBFjCVAXrC22VOvqQp5pnce1uJmRw1sZrpug5766rVb" +
    "oCvDpt4AaqMT6g/BFDGWCLlV4tqqWLXbJDWwGem6DZKrlbecMP96/mBcZxCj" +
    "06U/BoxJqB/BtwDlUTFidDpwcxAQ41uAcmVParqnfL77KmZVbpPUwGaj6zbo" +
    "Lw4I4QtfNRZKX7gwrcVJOaH+GDAmoX4E7saOiRGj04Gbg4AYQzYX4aIrQtjz" +
    "UL3mKlbhNkkNbCa6boMOfpWz+PrAhWktTsoJ9ceAMQn1I3A3dkyMGJ0O3BwE" +
    "xBi6uVQ2L3ijXnsVm/02SQ1sBmJug9zF1wcuMmtxUk6oPwaMSagfgbuxY2LE" +
    "6HTg5iAgxljNRZD/ZVrF2yQ1sNGRj2Dz5FX8+f4hnHVBCFdeA74NKCfQvwoo" +
    "/WvmX4ZrEGHTZU/5GDCmGdernScfA8a08GwgV+eL0B98fvVfQ9jjEL0mKzbj" +
    "TzmogY2MnCCetIonv9I4+cYiaF0oHfpq4VH/Gr1JY2y67CkfA8Y043q18+Rj" +
    "wJgWng3k6nwR+mvx2fUMcLM1GDWwUWlrLDfbMYQ3Hm+ceGcRdAJ9tfCof43e" +
    "pDE2XfaUjwFjmnG92nnyMWBMC88GcnW+CP11+DzpcyH84R56rQqb6Wcc1MBG" +
    "pO1Lh623QaRlEbQCfbXwqH+N3qQxNl32lI8BY5pxvdp58jFgTAvPBnJ1vgj9" +
    "OT6/evl8fXLNbqYGowY2Gm3vCP3ZQ0M4/9IQrvhmk8sN5NuudSi/XMbqUB4D" +
    "fRDqZ8B5uHN3clD+qG/YuHJC/Rwbygn1I2z61i5KZ23sgBfotStshneS1MBG" +
    "oq2x7P70eWOJWiQyfjU2EHW8RRIDfRDqZ8B5uHN3clD+qG/YuHJC/Rwbygn1" +
    "I2z61i5KZ328rcHIO55c8xsJNbBRaHur+YDnN0+gu0hk/GpsIOp4iyQG+iDU" +
    "z4DzcOfu5KD8Ud+wceWE+jk2lBPqR9j0rV2UTk32pFfotbzRG4wa2AjENhbB" +
    "XSQyfjU2EHW8RRIDfRDqZ8B5uHN3clD+qG/YuHJC/Rwbygn1I2z61i5KB/LD" +
    "j9ZrumIj/sqdGlh22hrL4UcZJ++bEYtExq/GBqKOt0hioA9C/Qw4D3fuTg7K" +
    "H/UNG1dOqJ9jQzmhfoRN39pF6VB+9eZqMGpgmWlrLPK/y/KNZuFSj6sMqDMB" +
    "Vb5teXvyIRgiBn0Q6hP5MS5Foo9FnE/maEGbWD50+vwjFFznG63BqIFlxWos" +
    "cgJef1ziCeVCnGgxEm8hevIhGCIGfRDqE9VYSnOZ0dVguDeWFTWwjFi/yC+F" +
    "lxOQfEK5ECdajMTL25MPwRAx6INQn6jGUprLFmR93+mheu1vlIe8amDZsN5u" +
    "rhqLnIDkE8qFONFiJF7ennwIhohBH4T6RDWW0lwatF3BbIQGowaWCauxCC9+" +
    "awgXXrFALgeUG8jve9Tx5B6036hwXjF4PigfgiFi0IdHZfeBT9kNZtk/aKcG" +
    "loW27wotvLEIpbkMBucVg+eD8iEYIgZ9eNRtpcFwLwjL/FUBNbAMtDWWZxyh" +
    "T9hCKM1lMDivGDwflA/BEDHow4P28sLKPbHMDUYNLJq2r6TLlxNjN/LolOYy" +
    "GJxXDJ4PyodgiBj04UF7oa3BLOPPNaiBRdL2Q0/7PieEC74+5yvksiaVXiui" +
    "Q6hDUvVjSPUZoa9qA6jvwdrOcHwqOfMmhg9PhzEI9bNADqwD9Sm3dIbib16q" +
    "98gyNhg1sCjkpylZLGG7xzYLy4WUfEJrC6Zt8SpS9WNI9Rmhr2oDqO/B2s5w" +
    "fCo58yaGD0+HMQj1s0AOrAP1Kbd0hkRecLlXhGX6yUw1sCisD8nd8SEhnPUv" +
    "zaJyISWf0NqCaVu8ilT9GFJ9Ruir2gDqe7C2MxyfSs68ieHD02EMQv0skAPr" +
    "QH3KLZ2haWsw3FuLQg0sAustZ6uxCFxIySe0tmDaFq8iVT+GVJ8R+qo2gPoe" +
    "rO0Mx6eSM29i+PB0GINQPwvkwDpQn3JLZwzuuJ/eO8vyFrUamBrrAe5v7BDC" +
    "u08O4dyLDS5pct7FTSjPQfkkhk2XfU5eyp4YNopUG+pbODbnXdKE+mpehg5x" +
    "fRLEUHKx8+bloPxZMAahvgft1/jM2ia61e56Dy3D/yKpgSlpe84i//XCIrad" +
    "EC4kynNQPolh02Wfk5eyJ4aNItWG+haOjbfp1LwMHeL6JIih5GLnzctB+bNg" +
    "DEJ9D9qv+3j3KXoPCYt+/qIGpsR6zrLPs4wCdpwQLiTKc1A+iWHTZZ+Tl7In" +
    "ho0i1Yb6Fo6Nt+nUvAwd4vokiKHkYufNy0H5s2AMQn0P2td8PK3lP6q556ZE" +
    "DUyF9ZzlT9fuHz9zrlFAo5gVXEiU56B8EsOmyz4nL2VPDBtFqg31LRwbb9Op" +
    "eRk6xPVJEEPJxc6bl4PyZ8EYhPoetIePXZ6i99Qin7+ogSloe85yzEkhfOlr" +
    "Tb7YlwsjgI3Kgfo5MMaFTTx9BfUtaMMcAOWD4OVEuaUDVO0MnS59q96qFtSh" +
    "T0/fsHHx7CkHnzwnhFsu0fMXNTAFnLzwvCP1CRtkwRsnQQEblQP1c2CMC5t4" +
    "+grqW9CGOQDKB8HLiXJLB6jaGTpd+la9VS2oQ5+evmHj4tlTbiAv0De4i2YR" +
    "z1/UwNhYz1n2fua8MDxhgyx4FN8ENioH6ufAGBc28fQV1LegDXMAlA+ClxPl" +
    "lg5QtTN0uvSteqtaUIc+PX3DxsWzp9xiTe/gV+k9JnAvjo0aGBPrnvBP9p1f" +
    "zklheMIGWfAsvgVsVA7Uz4ExLmzi6Suob0Eb5gAoHwQvJ8otHaBqZ+h06Vv1" +
    "VrWgDn16+oaNi2dPucW67s4H6b029fMXNTAW1veGbrpDCEd9NITPfWWdC3w+" +
    "DygfhCqfdbyYnxedOtC3bBiDctfeIjFv6iv5FDAHK2/KgeuT8hzG8Ong1cHM" +
    "Y338lC+E8Ae76T0nzzu5N8dCDYyFdTv07Dc4hTJQBR8DnEAvJhc79S0bxqDc" +
    "tbdIzJv6Sj4FzMHKm3Lg+qQ8hzF8Onh1MPOoyeSFm3tO4N4cCzUwBtbvs9zn" +
    "SRGFMlAFHwPk5cXkYqe+ZcMYlLv2Fol5U1/Jp4A5WHlTDlyflOcwhk8Hrw5m" +
    "HpA/4oV678njCe7RMVADY8DJye2Q/LIWC6EKZaAKPgbIy4vJxU59y4YxKHft" +
    "LRLzpr6STwFzsPKmHLg+Kc9hDJ8OXh3MPAy5dXs0xV+UqIGhsT4sJ920rRAe" +
    "quBjgLy8mFzs1LdsGINy194iMW/qK/kUMAcrb8qB65PyHMbw6eDVwczDkL/u" +
    "OL0Hp/iBbzUwJPLeOid1h31COPO8OWcsCVU+bXl5ckL9HBvKYxjCh0ffGH3t" +
    "h6JvHjH2MTp99C3afOz0RL0Xx364qwaGxHqIe8R79MQXTZVPW16enFA/x4by" +
    "GIbw4dE3Rl/7oeibR4x9jE4ffYs2H8edOn8cwf14nrFvh0INDIX1EHevZ9gT" +
    "XzT1nKy8PDmhfo4N5TEM4cOjb4y+9kPRN48Y+xidPvoWXT4e/nd6T475495q" +
    "YCg4CemaHz+rfeKLpJ6TlZcnJ9TPsaE8hiF8ePSN0dd+KPrmEWMfo9NH38Lz" +
    "YT3cHeurAWpgCKy/X33CYSF86kvgnAzog1CfUH+NTwNl40GflEfwaUB5FAPk" +
    "0elP6nNON8oHifBHG08+BG4MoxYNqB/jMxXGNOqnbMBr3qX35lgPd9VAX6xv" +
    "PN/+wWG+aYkxeRf6INQn1P/SPLfSXAzoT+pzTjfKB4nwRxtPPgRuDKMWDagf" +
    "4zMVxjTqp2wM9jhE79Ex/jlADfTFeoj75uNDaS4OOYtEMUAenf6kPud0o3yQ" +
    "CH+08eRD4MYwatGA+jE+U2FMo37KxuDEM0K46b31PuVe7osa6IN11XLA88PW" +
    "TUuMibvQB6E+of6XtuZXmgtY93PGuSGcf8k6l87v5ZlvdN7IkfaWD08+BG4M" +
    "1pZQP8ZnKoxp1E/ZtPD4w/ReHfrqRQ30gVct0h2PPz2ET3yhhbMB5QNwKlAx" +
    "LQw/DZ9nN1H2MRh+k/I2bAjzVD7X+PLF81+R/7dvhXDt9SF89wch6/jhj9fs" +
    "v7vm5+r5PwN++SIjZysHQ4fzUHJCfaDqQHsL+gBKbsUw9MbGy7M+x9/ftblf" +
    "h756UQO5WN96fsDTjcm1TNQ6oUOgis2YFoafhs+zsYhyMPwm5W3YEOYpr2xV" +
    "I/mvn7E9jHNInG9eO284Z54XMS9rbpQT6jt1iDpn9AGU3Iph6I2Nl2d9jk9/" +
    "rd6zQ169qIFcrHeI3nmSMbmWiVondAhUsRnTwvDT8Hk2FlEOht+kvA0bIrnJ" +
    "FYRcTciVxTIcs2Zz3bzJmfOy5kY5ob5RB6J8EPoASm7FMPTGxsuT8xzz6kUN" +
    "5JB11WJMVMkHQBWbMS0MPw2fZ2MR5WD4TcrbsKk48/xpr05yj//5xfyq5uyv" +
    "OHPj3An1Ac9X1DmjD6DkVgxDb2y8PDnPx71M792hvhagBnKwrlqOOjGEkz4H" +
    "zupGPmRHqENcfeTwcQvPh4PyZ+DZuHKHU78YwiX/HsIPfsQtvDGOn6w1wsuv" +
    "DuH0c/XceH5YG8JaRpEa05MbpMZQOebAuJC//7QQboJ3job63IsaSMW6atnt" +
    "aXETI6rYhg5x9XlCLTwfDsqfgWfjyluQpiKb8r9/we26cY+rrm02GZ4f1oaw" +
    "llGgrm5MT26QGkPlmAPjUr7Gfs/Re3iIqxc1kErrVUvkxOqoYhs6xNXnCbXw" +
    "fDgofwaejSsHm7Gp8KiaDM8Pa0NYyyhQXzemJzdIjaFyzIFxKT9rvKsXNZCC" +
    "9XesW65aIidWRxXb0CGuPk+ohefDQfkz8Gxc+TpVU1ml4xvXhPCZL4fWTUhY" +
    "yyhqNZ6tkypWBeN4coPUGCrHHBiX8nXGuHpRAylYv+b/sreH8JEz58gnAYfm" +
    "Iw5Kfz2XPjkxBqH+iRKHOD4pV6z5OOfitSuV/wkreci8L7pC1y22doQ+vHWi" +
    "9AH1c8jxSRtCfVLpvfeU4a9e1EAKbCx3fljoPEFDwOIRpe8smhgYg1CfC7lv" +
    "czlt7WrlO98P5QjzB9by7lJs7WbwXMhaqNnPcNaJ0gfUzyHHJ20I9Uldd99n" +
    "N/ez0Ocb02ogFuv3WupXLdYJGgIWjyh9Z9HEwBiE+lzIfZrL178RymEc/7pW" +
    "l5M/1127LfBcyFo4AzjrROkD6ueQ45M2hPqkrvvWE/Se7vN7L2ogFibBqxbr" +
    "BA0Bi0eU/gA5MQahPhdyTnORe+7vfC+Uo+OQqxj53hNrp+C5kLVwBnDWidIH" +
    "1M8hxydtCPUJ9Xc9uLmvBe79WNRADNbbzwe9IoTjP93NhwDlQ+DGON0g0Qfl" +
    "hPox1O3POn91n62kHlIn+UIlz0Hf8+ExRowxfKby6mP13s59sKsGYrAe5L7r" +
    "JJ0omaJ4bgw2liVrLpddye1TjphDPpH80TP1ucg9Hx5jxBjDZzJr++EW92/u" +
    "7dy/gVUDMbCx3O8pccWYonhuDDaWJWkusjGu+x63TDlSju//p91gWOshGCPG" +
    "GD6TWdsPez+rub8F+dgJ+4CHGvCw/i7kma+LK8YUxXNjsLEsQXORe3zZGOXo" +
    "f8htknz7u8/5iKHvObcYw2cya/vhjcfrPZ7zbWk14MFP5Mp747HFmKJ4bgw2" +
    "lgU3l1M+XxrL0AcbDGs+BH3OeRtj+ExmfU/8xQHNfS6wF3ioAQ8GfNDfzj8+" +
    "LLzPodKL1c+x8fQpt3R6c6qBoSPfWi0Pbsc5pK7yb4yq7gMRs4ZidLqIsacO" +
    "oT5p03/C4c19LqT+Bawa6ML6bMsr36kTa6NtIl2k2nj6lFs6vWFjMZpLaSzT" +
    "HGM1GK4hKw51KPeIsacOoT5p0z/qo3qvp/6BvRrogj9jedsH2om10TaRLlJt" +
    "PH3KLZ3esLGguXzo9NJYpjqkzvJ9LHWOesI1JD/xKci5bdOhD48Ye+oQ6pMu" +
    "/Z2f3NzvAntCF2qgDetLivIPbm2JWXRNpI1UG0+fckunN2wsteYii+975RnL" +
    "pMcYDYZrSBpLFesz59o69OERY08dQn3SpX/oEXrPp3wdQA208ZDnBhXoH98b" +
    "wrtPaec94N0nOxg++vKek5uomFZcyDkPRWSMD3wyhO/+sLnwyzHN8fO1Tf+B" +
    "09rPKdeAOqeGTp1rrm/Gky9Zcg0wJqFPyi1ok4o3z1/fvrnnUz7zogbaYGPZ" +
    "9jE6EaIKgWIrDB99UcWzoB3knIciMsZV1zQXYDmmPaSxVw2G55BrQJ1TQ6cO" +
    "m4scMtbV0Ah9Um5Bm1S8ecr/u3Pvsze0oQbaYAD57U0mQlQhuOGI4aMvqngW" +
    "tIOc81BExJBXsnIs/pAvPFrnlGtAnVNDp47VXOSQKyb5fyErJqFPyi1ok4o3" +
    "z8OOau57IfbWSA1YWH925t0SzRIH3HAKw0dfVPEsaAc556FwYsjiKsfyHF/8" +
    "mj6HXAPqnBo6ddqaS3XIiwtjEvqk3II2qcTMk7dG8oiEPcJCDVjwu0Q33yWE" +
    "Yz6mkb8SqaPkgHIL+vRw7Wvxt0AdD9h3xXzvqWuvXv/Npba8x7f/I4SvXT5H" +
    "fkem4piTtlIfP/fiua7YbZR5Sp4nfRbnjOCcq3MMZP7eITrv/URCDMgZc7b2" +
    "audFiLFJ5e6Pbu7/2B+RUgMWvGqRP7JmIaxiKDmg3II+PVz7WvwtUMcD9l0x" +
    "YxbdIo/rfzBvDvK5GzWvk3xo87HPzhvOld9mpOU65J8lj/tE7ZwRnHN1jkHs" +
    "eZbGtqXWXgzIGVNQ54MYNqk89HnN/S+wR1ioAWK9BX3wq3QhrGIoOaDcgj49" +
    "XPta/C1QxwP2bTFl0y7j8aOfrDWAS+Yf9+ZcGvM6yYc2deRVWhqNNLBlPOT8" +
    "bDlnBOdcnWMQ21yqQ2K7MSBnTEGdD2LYpPKSt+keEPPcRQ0Q63nLmz6oC2EV" +
    "Q8kB5Rb06eHa1+JvgToesLdiyvczlu02QTaAfN6jbR6EC9eCNm3Iq/UyXs2c" +
    "9oX1c0ZwztU5BqnNRY7ZbdKpHTGQA2MK6nwQwyYV8Zvz3EUNEPmZu7rTbfYM" +
    "4e0n2shfinTx9o90Q/2ZDXDl4qeGkls4NoT2lAvy+yLLcnzrOyGc/Pn+8zSB" +
    "T8p5jt//yeWqjVxVWXNlLTykxjmHvADJl1cZPzoH1Jc+eH6S7df1dnhCsw/E" +
    "PHdRA4RXLbs/zUhwHSZFOBFC/WpiXTGU3Ckm7Wc4NoT2lMtGXoZDFu7nLqjl" +
    "3XOeJvBJOc9xxclnh/CfP2HGiznOucjIO5Hc5lIdX/l6Zg6oK33w/CTbr+s9" +
    "6kXNPiCwVxA1UMd63iI/Z6kSXIdJEU6EUL+aWFcMJXeKSfsZjg2hPeXLsGku" +
    "vTKEd30cefecpwl8Us5zTGRTLfqQJiwfdus6px59m4sc4uPYjyfmgHqy/jw/" +
    "yfbrevIFZfYC7+cv1UAd63nLP73PSHAdJkU4EUL9amJdMZTcKSbtZzg2hPZ1" +
    "2aI3y5arFWMefedpAp+U8xwrTpxf6S36+ZQ047ZzGsMQzUWO+m0SY5ignqw/" +
    "z0+yfU33d3dp9gLvW9JqoI71vOXNJ9T4UDdvAZSTt5xgYPhJ8amo57+O8kkd" +
    "+KB+xTs+uthN8h/fnz9Ijs2bckL9GJtU6rWT/Bd5yLtbbfP06nD1dfTW7/iX" +
    "y3QMC+ZFUvW7uPfjm/1AOM/oGxVqoCGEo12fGjo3HWFylBPVWIyNT+jDhY3D" +
    "iEE5fVC/QhbEog7ZmEd/LC1vygn1Y2xSof+L/40zm+6Q2G3zZJ6UD91c5BCf" +
    "R39Ux+rKi6Tqd/HIFzb7waDN5ZAjQufiJUyOcqIai7HxCX24sHEYMSinD+pX" +
    "LOqqZcsiTMybckL9GJtU6F9YZIOprl68PCkfo7nIIWvqY2fpeG15kVT9Lg43" +
    "vmfU9dxFDVRYz1u8xUuYHOVENRbB8JPiU8E5GDEopw/qC589n8timkOuWFrn" +
    "5uRNOaF+jE0q9F/FWFSDqa5evDwpH6u5VEfbbRLzIqn6Hvy8yyDN5dfuFcI/" +
    "f6DJkWBouaWTivxh1jevrXHdOPziF1wO4x/yj4xv/3B8rYaureD5/Of3N1Fy" +
    "gyNFb40LF/RN8m9fH5prJmLd/GyCq1aJUz/fVr2Jqq0j9/iTfZt9oeuhrhqo" +
    "4JcVxSkDeYn2lVs6qcjC2IzHD388/ELLwfPZp7kI5S9tm4c0sY+c0V5vomrr" +
    "yD3uj7977fownRqo4O/lilMG8hLtK7d0UtmszUV+1S61Vqn6MXg++zaXt50w" +
    "zVXBRjvkityqN1G1deQebC4Ce4fbXOigNJflOc7+qq5TTK1S9WPwfPZtLsKJ" +
    "Z7AC5ZBDbpPe9mFd0676enKPp72m2RcGaS7ilIG8RPvKLZ1UNltzufybukax" +
    "taL+eZf0R15B61B+7Emhd3MRPfFVDn3IVZ00X9a1rb6e3OOlxjek2/7PSA0I" +
    "1sf+n/W6EF5/XDevI+9t4ulTHoX4rQP5NzZRc5GFJG85z2rFeaPWJsc1meI4" +
    "4fTm+WAOUaznL8+ZymEfX754vU6snQfWCPePBXtD2ztGakDgO0UCA1ikJk59" +
    "yqMQv3Ug30zNRT7Wv6VWnDdqbbJuWzHFMWRzkb9lKUf7IWv9Tccb9esCa4T7" +
    "x+LWD2j2hrafX1ADAv9GRJwxgEVq4tSnPArxWwfyzdJc5FW7USvOG7U2qdkL" +
    "UxxDNhfh699ghHLUD7m6lSasatgG1gj3j8VfPqzZH+RrQuwhrc2Fb0PfYR8d" +
    "wCI1cepTHoX4rQP5ZmkunzoHteK8UWuTmr0wxTF0c5HbwnL4x+w2iXW0wBrh" +
    "/rGI/SdGNTAbhOF9DwrhH46N4N2AcgL91x6bjvIJNsN/Bf3gR2tzlfrUYO2i" +
    "QG2mOOQt85TzJai5Qn7ZVYxSDuuQtS8PxBv1w5pgrS1Y//2MP0hkD4luLuKM" +
    "AUyQuJIT6LNxxKB8gs3QXORX9tUJzwG1meIYo7nIGw7liDt+9vO1en2yVj+s" +
    "CdbagvV/4iua/aFXc3nSK3QAEySu5AT6bBwxKJ9gozcXWRyzufKE54DaTHGM" +
    "0VxkLtd9l5HK0XWcc+HW2tVhrS1Yfxljj7DeMVKNxWou8q9rDGCCxJWcQJ+N" +
    "IwblE2z05iI/PjWbK094DqjNFMdYzWVRXxTdyMfsNukD8/pVsNYWrL+MsUdE" +
    "NRfrMy6veuf8Z+4Ux3Qjdr0RPzUYQ+UElvEX51MO+fV1mQfrwnnOdFAr2pAp" +
    "jved2p2jOp+cgyV/5/zhYznSDvmnSa6ZLI7RPSKquVifcWlbzDzphIs5i9oi" +
    "sxaaygls5OYiD3KrebAunOdMB7WiDZniGKu5CJdeWY9UjrZDbq3lU7xt6yaZ" +
    "tXNwuweX5rKhm8sFl22dB+vCec50UCvakCmOMZvLGec2QpXDOK69PoQ3H7+1" +
    "ZlwzWRyjm4v1QbrSXJb4+MTZW+fBunCeMx3UijZkimPM5iK3jOVoP+Q2iOec" +
    "ayaLY3RzsX7XxW0ut9w9hMOOnv/EnYc8+K3jyadgmf6AK/WQL4qxhl1w7ofL" +
    "easD/SmO95yCnDLgvOr89OeMWA6piXxK16o360eoPwPrSPT++EEDNJc/3juU" +
    "5rKAQ/7PmfXz4Ny5KKg/xTF2c9mo53es45rr5+8ItdWb9SPUnzFUc+FH/0tz" +
    "Wcwhi4T18+DcuSioP8UxdnM5+yuMuLqH1IL1SamlpT/DaC47PL40lw3bXC66" +
    "QtfPg3PnoqD+FMfYzeXTX2bE1Tvqt0EkpZaW/oyI5mL93KXfXNYuf17y1hBe" +
    "nIHYpUD7GDwf/3Y1T8XGOC68XM8lFa82Uxzyl7LMw4N5Ul5H/K/y8e3/mH+Z" +
    "kHVpI6W2bTbC9gc2+4TAXuI2F3HSFsCDSXrQPgbPx0ZtLmecr+eSilebKY7S" +
    "XMY75Pd9WA+PlNq22QhZzeW2eFBTmstijk9+Sc8lFa82UxyluQx/yG3QBz7l" +
    "18YipbZtNkJWc6FBaS6LOUpzaZ8HWaWjug2KrQ1Jra1lIzz6RQM0l3s+LoQX" +
    "vimEv8tA7LqgvgVtFG8EkH/kzBA++y89Ob8J/xAr6g+0PB3Ij/pIcx5/98Ym" +
    "nKeFV8spjnd8DDngfDHHGDgPr5ZKbuHYnHORsS5qfO8/OfPhD4nDubOelHu1" +
    "I9S3EL1HvLA0lyyYg7exPXmMTl+5BedB+RTHFM1FyRGD+hasL316XD7iFfJP" +
    "fzb/pDNznuHMlXlSTqhvIXpZzUV+D7M0F4CFp/QdeYxOX7kF50H5FEdpLv2O" +
    "b30nhCPe3TEPZ67Mk3JCfQvRk76Q3Fz4btFfPyI+KGHihPoWtFE4xc2BOXDh" +
    "KX1HHqPTV27BeVA+xVGaS/4ht+DuPJy5Mk/KCfUtRG+Q5nLbB8YHJUycUN+C" +
    "NgqnuDkwBy48pe/IY3T6yi04D8qnOEpzST/k3aD3nRY5D0eHeVJOqG8heoM0" +
    "l9vsFcLz3jD/vQbyPPKGJp6+Jzd9EsNPp0/4s/Ik1KdPpR+BZ8N5Um7izQs+" +
    "pziOOhHzAmoOI8CYs7iJtaJP2v/rQH95IrdBr3mXnTdjznDyUvOgnHEMG8Wa" +
    "3naPbfYJ+QgLe0lpLjE+aAOfSj8Cz4bzpNzEmxd8TnGU5hJ/nHled96MOcPJ" +
    "S82DcsYxbBRH6uYS9d0iMSzNBT5oA59KPwLPhvOk3MSbF3xOcZTm4h//9bP5" +
    "d7AYgzkx5gwnLzUPyhnHsFEcOe8LvZvLb+7UksSRERNz9D256ZMYfjp9wp+V" +
    "J6E+fSr9CDwbzpNyE29e8DnFUZpL93H12m3Qq4+xYzAnxpzh5KXmQTnjGDaK" +
    "IwdqLsIzXzf/I3qX1zcRuy6UvgVtPOCTcvqL8glUjkDlYOgwB8qVPfSZk5mX" +
    "YzPF8ZYTjLzq8zTyImoeTm0I9aPOB3045PzN7Olf7s6TOVJuYuTWwNHnvGfU" +
    "cqjO2TZ7luai5PQX5ROoHIHKwdBhDpQre+gzJzMvx2aKozQXfchtkHwtQsVw" +
    "cqTcxMitgaPPnGbUcqjOGZvLE19emovyF+UTqByBysHQYQ6UK3voMyczL8dm" +
    "iqM0l+Zx9XUhvPxo7d/KkzlSbmLk1sDRZ04zajlU5+z37t/sEdI32EtUc7H+" +
    "tyimuFbiKkmg9C1o4wGflNNflE+gcgQqB0OHOVCu7KHPnMy8HJspjtJcth68" +
    "DSJejpSbGLk1cPSZ04xaDtU5Y4+Iai6zQRj+zUtDOOQfNIce0UTJAeWHiE0d" +
    "yg0fhPoKxrCADeflxoQ/ZR+DFwMo+yOMPOCTTHG86YOIy5yNuRHm7c2T9jEw" +
    "L88n5ZddxZlvPeQ2SP6pgHl7Pomyj/BBOYnRp47AHpHdXPZ5tg44C4oTouSA" +
    "cq9Qlg9CfQVjWMCG83Jjwp+yj8GLAZT9EUYe8EmmOFa9ucg3qg97+7oP5O35" +
    "JMo+wgflJEafOk9+pW4u8hcw57GPcGA2CEP5TRcGnAXFCVFyQLlXKMsHob6C" +
    "MSxgw3m5MeFP2cfgxQDK/ggjD/gkUxyr3Fw+fQ58IG/PJ1H2ET4oJzH61Nn3" +
    "2bq5nGf1EQ7MBmF410fpgLOgOCFKDij3CmX5INRXMIYFbDgvNyb8KfsYvBhA" +
    "2R9h5AGfZIpjFZvL7DboJK3DvD2fRNlH+KCcxOhTJ+ZX6AQ1IPArALd+QAgH" +
    "v1rz1ERoT6hv2VD+1Nc0oX4Myifoqx9jQzx7yi08mymOI9/fnYMF8yZ99XNs" +
    "KCeXXjmf7zeuDeFFb7FtUn3GQJ/E0/fkFvxZlqTmIu9Z1w1vtqMOYCXmQXtC" +
    "fcuG8tJc2vFspjhWqbmc9sVum1SfMdAn8fQ9uYVcbNT7g/UButbmYn3WhQGs" +
    "xDxoT6hv2VBemks7ns0Ux6o0l+pqpcvGk+dAn8TT9+QWN79fszdYf0Lf2lys" +
    "z7o89Hk6CBPzoD2hvmVDeWku7Xg2Uxyr0lyob9l48hzok3j6ntyCvcF6G7q1" +
    "ucwEcHD/g0M46BXdPMkhVT/GJlVu4dl48oNe3oT6pg1I1WfMtrhdPqc4Xndc" +
    "dw6cgzUP2qTKLTybvnJLR8G5Q57sz4A+PGg/o5bjfsY7RXIxwv6R1Fz+6uFG" +
    "UMBESap+jE2q3MKz8eRcJNQ3bUCqPmO2xe3yOcVRmksHnDvkyf4M6MOD9jNq" +
    "Oe51aLMvCOwdbnPhn6Pd8SFGUMBESap+jE2q3MKz8eRcJNQ3bUCqPmO2xe3y" +
    "OcVRmksHnDvkyf4M6MOD9jNqOcpFRu/mwrejb/UAIyhgoiRVP8YmVW7h2Xhy" +
    "LhLqmzYgVZ8x2+J2+ZziKM2lA84d8mR/BvThQfsZtRzvuF+zL1g/b+k2F+sd" +
    "owNf1uTxhwEZq3HgYd2k6s9sgMqJOPrmPHrCnGcwLuT04c4jAs/HFMc/vMeZ" +
    "pwHn4dWOcvqLIdVHlL6M1/BsPLkJY4ifGtSnPCZmXf+Wuzd7Qtvb0J3NRb4r" +
    "wObyqL93EnEmSlL1ZzZAFYc4+uY8esKcZzAu5PThziMCz8cUR2kuW/FsPLkJ" +
    "Y4ifGtSnPCZmXf/G92j2hLZ3ijqby0yI5nLfg5xEnImSVP2ZDVDFIY6+OY+e" +
    "MOcZjAs5fbjziMDzMcVRmstWPBtPbsIY4qcG9SmPiVnpPvT5zX4gWF9YzGou" +
    "dz7AScSZKEnVn9kAVRzi6Jvz6AlznsG4kNOHO48IPB9THKW5bMWz8eQmjCF+" +
    "alCf8piYle7dHt3sBwJ7RnRz4XcIfmdnJxFnoiRVf2YDVHGIo2/OoyfMeQbj" +
    "Qk4f7jwi8HxMcZTmshXPxpObMIb4qUF9ymNiVrp/9MBmP/it+/RoLtZD3Ye9" +
    "IITHvHidlzR57Iu7UfoR0GZL7LYcCPOgnP4NlD5yUPIImJcnZwwL5uX5nOJ4" +
    "9buaObk5GzBvovSN2hCvNspnonyGE1Nh+HXnhZjKpqe8HpfPW9o+9h/VXGYK" +
    "aC73+JtaYBSHiRKlHwFtOHHKac8clJz+DZQ+clDyCJiXJ2cMC+bl+ZziKM1l" +
    "K4ypMPy680JMZdNTXsXd6xnNPiB0PW/Jai6336cWGMVhokTpR0AbTpxy2jMH" +
    "Jad/A6WPHJQ8AublyRnDgnl5Pqc4SnPZCmMqDL/uvBBT2fSUV3HlN53YC9gr" +
    "iBog/DDdTXeoBUZxmChR+hHQhhOnnPbMQcnp30DpIwclj4B5eXLGsGBens8p" +
    "jtJctsKYCsOvOy/EVDY95VVc/gma97wlqrlYz132fmYIj3xhCI8AMlbnEX/f" +
    "jdK3oB3kjxQ/NZQ8A/ogqfoznLkrMC8F9S0bysEUxyvf0YzJujAnC692lBPq" +
    "z2wA5cT1KWMgNUZvewsjry44z2quN96u2QO85y1RzWWmhOay3WPmAb3JM0mi" +
    "9C1oB7kqDuUZ0AdJ1Z/hzF2BeSmob9lQDqY4SnOJj9Hb3sLIqwvOU3jA05v7" +
    "X3jrh0dqLv/3wfPEvckzSaL0LWgHuSoO5RnQB0nVn+HMXYF5Kahv2VAOpjhK" +
    "c4mP0dvewsirC85T+OuELys2+gYHLNRzl3vPE/cmzySJ0regHeSqOJRnQB8k" +
    "VX+GM3cF5qWgvmVDOZjiKM0lPkZvewsjry44T+H3d23u/64vK9ZRAxbW94z2" +
    "PDSEA57fzf6AckJ9y8aTH/ACQLmB55Py/V/QhPoWygegPknVj7GZ4jj86KDP" +
    "ycDnRzFADO8cU5/yGYl50CehvmVDOfHmpXJ+gd771v9CW6iBNhjgzg8zEuNE" +
    "AOWE+paNJ2dhlNzA80m5e4IMlA9AfZKqH2MzxVGaSw3KAX0S6ls2lBNvXsz5" +
    "Xgc2970Q87xl1jM40Ia89VQP8Nv3MRLjRADlhPqWjSdncZTcwPNJuXuCDJQP" +
    "QH2Sqh9jM8VRmksNygF9EupbNpQTb17M+XZ7N/e9wN7Qhhpog383IshP3qnk" +
    "6hMBlBPqWzaenMVRcgPPJ+XuCTJQPgD1Sap+jM0UR2kuNSgH9Emob9lQTrx5" +
    "1fPd9zkh3AhvQcv3Ddkb2lADXbC5/Mm+Iez3nHYkuTqU50CfhPqE+jk2qfIc" +
    "xvBJpjhe+rZmzJh5UceD9oT6uTZd9pTH6nTpE+pbNpQT+YHtLuq6f/3I5n4X" +
    "vI/8N/oFB7rg7+reZHs9ua6JUp4DfRLqE+rn2KTKcxjDJ5niKM2lW6dLn1Df" +
    "sqGcsJmQuq78tC2bC3tCF2qgC+vTujs8QU+wbaKU50CfhPqE+jk2qfIcxvBJ" +
    "pjhKc+nW6dIn1LdsKCdsJqTS28344FzMp3LrqAEPBrztA/UE2yZKeQ70SahP" +
    "qJ9jkyrPYQyfZIqjNJdunS59Qn3LhnLCZkIqvT/fv7nPhbb/J2pDDXjwB6Tk" +
    "gc+DnjlHvnOUwoP+tgnlkyGxu4B+Nd82qJ8FcmCtGDMmLvWnOORvTplHMj3P" +
    "h6od/RkofScnFdOAPjx5FpwL5ZH85k7NfR7zRUWiBjysD9T95cPziuOewKng" +
    "CSHQ56Ig1M8CObBWjBkTl/pTHKW5bIU+PHkWnAvlEez0JL3HYz84V0cNxMDA" +
    "8ncDOcVxT+BU8IQQ6HNREOpngRxYK8aMiUv9KY7SXLZCH548C86F8ghu/+Dm" +
    "/hbYA2JQAzHIgx0Gv9/BOkkP9wROBU8IgT4XBaF+FsiBtWLMmLjUn+IozWUr" +
    "9OHJs+BcKI/g17dv7u3Y7xIRNRCDPNhhc/nT/ebfN6qzB9jzEAfYZ0GfA+DO" +
    "gznkwJiA+szJykv5AMd/yuHT/ZEffe7KIQZvHgqntlE6lA8BY6RCf4caa4Dy" +
    "Q9Jqx2eqwnOPnLC5CPw6gHQ7NTFO3JiMV7xk6HMA3HkwhxwYE1CfOVl5KR+p" +
    "MEcDlQPlfXOAfZQP5kF5jA7lQ8AYqdDfocPXf5s9m/ta4N6PRQ3EYn0dQLpe" +
    "58SNyXjFS4Y+B8CdB3PIgTEB9ZmTlZfykQpzNFA5UN43B9hH+WAelMfoUD4E" +
    "jJEK/R06bP3vazzI7fq7Vg81kAIT+d1dnIkbE/KKlwx9DoA7D+aQA2MC6jMn" +
    "Ky/lIxXmaKByoLxvDrCP8sE8KI/RoXwIGCMV+jt02Ppvs0dzPwux34C2UAMp" +
    "8EekhO0e2zFxY0Je8ZKhzwFw58EccmBMQH3mZOWlfKTCHA1UDpT3zQH2UT6Y" +
    "B+UxOpQPAWOkQn+HDld/66ol90FuhRpIhQnJvzLu9tQ5u4LdngbW9QaFMWKg" +
    "D7Dr05rQnvOkfoyNiunJrRiGXi+fho2nk+qTdbGgj2Q552Dk6UF7Qv0YG+ZN" +
    "ovzRzpG3+by18T2iPlctghpIxbp6uduj7GLwpHOig8AYMdAHUCcIcJ7Uj7FR" +
    "MT25FcPQ6+XTsPF0Un2yLhb0kSznHIw8PWhPqB9jw7xJlD/aOXLLp3w/kHu4" +
    "71WLoAZyYGLV1QsnypPOiQ4CY8RAH0CdIMB5Uj/GRsX05FYMQ6+XT8PG00n1" +
    "ybpY0EeynHMw8vSgPaF+jA3zJlH+aOfILZ/y/UDu4ZSfVmhDDeTQdvXCifKk" +
    "c6KDwBgx0AdQJwhwntSPsVExPbkVw9Dr5dOw8XRSfbIuFvSRLOccjDw9aE+o" +
    "H2PDvEmUP9o5cvrc+ckh/PK2zb2b8z0iCzWQg/WhulvtPn8bq8GT09n5KU2U" +
    "HFCuYE6GT4WjzxyYs5W3B31SbkEb5uCh5mngxkiUcw7WPCj3oL3KQeZi2CVR" +
    "q4lZl4lgXp6c8J8UhdwPzRE1kAt/SEqQH/ft2pQxeIsitZhcFFF5OfrMgTlb" +
    "eXvQJ+UWtGEOHmqeBm6MRDnnYM2Dcg/aqxxkLoZdErWamHWZCOblyevs9MTx" +
    "rloENZCLPFlmc1FXL8YEPbxFkVLMGVgUUXk5+syBOVt5e9An5Ra0YQ4eap4G" +
    "boxEOedgzYNyD9qrHGQuhl0StZqYdZkI5uXJ64x51SKogT64Vy/GBD28RZFS" +
    "zBlYFFF5OfrMgTlbeXvQJ+UWtGEOHmqeBm6MRDnnYM2Dcg/aqxxkLoZdErWa" +
    "mHWZCOblySvGvmoR1EAfrKuXm+8yn0guOzpQfxHk5EQbQn1C/RibMeibA+1j" +
    "fKTqD4EXk3JLJ5Uh/LX5+EPj07hDXrUIaqAv1tXLnR6iJx0Li0OovwhycqIN" +
    "oT6hfozNGPTNgfYxPlL1h8CLSbmlk8oQ/iwf8il67lGBe7kvaqAv1tXLr94z" +
    "hO0P1BOPgcUh1F8EOTnRhlCfUD/GZgz65kD7GB+p+kPgxaTc0kllCH+WD/lD" +
    "Q+7Roa9aBDUwBHIPyuTlMowTj4HFIdRfBDk50YZQn1A/xmYM+uZA+xgfqfpD" +
    "4MWk3NJJZQh/9CF3EdybQ3wa10INDAUnINz1kWtXMI+rceAmoT6nNmBzr8c1" +
    "oZzIg/E6lFuk2qTqx5A6z5kNoHwIVAznfLnyHOgTMEfWMraeFXI7dEM8xBVS" +
    "f9U/FjUwFHKZxUnIL4oPfoKWAWNhKGCTuki40Ci3SLVJ1Y8hdZ4zG0D5EKgY" +
    "zvly5TnQJ2COrGVsPSusPzmTuwzu3aFQA0NiPdyVv4Ad9AQtA8bCUMAmdZFw" +
    "oVFukWqTqh9D6jxnNoDyIVAxnPPlynOgT8AcWcvYegryDx3ciwL37JCogSGx" +
    "vhbwK/dcuzx7zHoBjSJsSIyFoYBN6iLhQqPcItUmVT+G1HnObADlQ6BiOOfL" +
    "ledAn4A5spax9RT4P0TCGA9x66iBobEe7v7BbiFs+9j5PWCDx2i2BbQRP3Vo" +
    "T/0cGIOomBapPh2on2VTq6tVWzUHA9fHAlDzNPBsKOe8Xbmh48bIwK3/Y+xv" +
    "PY/1ELeOGhgDTkz4s/3tQhCveOqE0QdjZMAYRMW0SPXpQP0sm1pdrdqqORi4" +
    "PhaAmqeBZ0M55+3KDR03RgZe/eXXCW54d73/uEfHQA2MgfVw92Y76kKok4PC" +
    "WcVTJ4w+GCMDxiAqpkWqTwfqZ9nU6mrVVs3BwPWxANQ8DTwbyjlvV27ouDEy" +
    "8Op/y9303kv9Q/lc1MBYWA93ZeKNYvDkoHBW8dQJow/o58AYRMW0SPXpQP0s" +
    "m1pdrdqqORi4PhaAmqeBZ0M55+3KDR03RgZd9bf+OXHo7w91oQbGhBMV7rDP" +
    "/PMvgvw1Cbnro8C67hYgV/Yx0AdQcsQgyn9EDEJ95c+CNkDFoH0OjEM5yMqB" +
    "MTxoHwN9kFR9C8+HI2ftzHWyzl8cYN8Ojf0Qt44aGBPrv46kAH/18HkxuUln" +
    "G5WF804A7WOgD6DkiEGU/4gYhPrKnwVtgIpB+xwYh3KQlQNjeNA+BvogqfoW" +
    "ng9HztqZ62Qd/iWrIGuTe3JM1MDYyAQ56d/YYV5MbtLZRmXhvBNA+xjoAyg5" +
    "YhDlPyIGob7yZ0EboGLQPgfGoRxk5cAYHrSPgT5Iqr6F58ORs3bmOlnj93fV" +
    "e2zK26EKNTAF/CtYQQrCTTrbqCyedwJoHwN9ACVHDKL8R8Qg1Ff+LGgDVAza" +
    "58A4lIOsHBjDg/Yx0AdJ1bfwfDhy1s5aJ39sPNsUxvqIfxdqYArkl8U5eeH2" +
    "+wS9UVlA7wTQPgb6AEqOGET5j4hBqK/8WdAGqBi0z4FxKAdZOTCGB+1joA+S" +
    "qm/h+XDkrB3XyTI8Z6mjBqZC3g5jEaQwf75/CH/5sBoPB3WZRap+jI0nj8Hz" +
    "4ckH4M6A8iiYJ6F+DvCp8mbMDJRPD9oDyi2SYybya/fSe0pe7Lj3pkINTIn1" +
    "9vRNd0DReJKMovbSj7Hx5DF4Pjz5AAyyuJknoX4O8KnyZswMlE8P2gPKLZJj" +
    "JnCL++m9tIjnLHXUwNSwIIIUakvheJKMwjZI1Y+x8eQxeD48+QAMsriZJ6F+" +
    "DvCp8mbMDJRPD9oDyi2SY0Zi/dC2sIjnLHXUwNS0PX+53YPWi8eTZBS3Qap+" +
    "jI0nj8Hz4ckHYJDFzTwJ9XOAT5U3Y2agfHrQHlBukRwzgjvut1zPWeqogUVg" +
    "PX/5pbvPG8yfPXRY7mRAHZKqL9+bUlDHw7G/0/4a6igcn4T+o2LQB6A8hzF8" +
    "TgHzJtT3kMYiPyHLvbPI5yx11MCisJ6/SIORArKofeAJjTmpqfpqE2dsSs+e" +
    "mz5q4zs+Cf1HxaAPQHkOY/icAuZNqN9FW2NZ9HOWOmpgkViff5ECDtlgeEJj" +
    "TmqqvtrEGZvSs+emj9r4jk9C/1Ex6ANQnsMYPqeAeRPqdyFf/OVeERb9nKWO" +
    "Glgk1j8HDN1geEJjTmqqvtrEGZvSs+emj9r4jk9C/1Ex6ANQnsMYPqeAeRPq" +
    "t2H9er8g+4d7apGogUXT1mDkKwLyE5ku+wDKDe4AKPdQ9szByIM2hPpjsCox" +
    "TZzzs5TsY/+inCDf2+NeWjRqYBloewdJCqsKTjIWTd8Fr+yZg5EHbQj1x2BV" +
    "Ypo452cZ+b376z2xrI1FUAPLgvUN6qgGk7Fo+i54Zc8cjDxoQ6g/BqsS08Q5" +
    "P8vG7xlfRhSm+uGnHNTAMtHWYKTQLP4WMhZN3wWv7JmDkQdtCPXHYFVimjjn" +
    "Z5m45e56DwjL8pZzG2pg2bB+4Fv43V3m3wC93d5piA2hjny+pkFfuaXj4dlT" +
    "bukANW9CG8phP0jtYnB8qJwI7S0fe3ej7AljtsXtQM1jbezWe4TwS3fT63/Z" +
    "G4ugBpYRKSSLWzUYniAPnsBBNognt3Q8PHvKLR2g5k1oQznsB6ldDI4PlROh" +
    "veVj726UPWHMtrgdcB5tjWWZPsvShRpYVtoazM3vp09SFzyBg2wQT27peHj2" +
    "lFs6QM2b0IZy2A9SuxgcHyonQnvLx97dKHvCmG1xO6jPQV44N3JjEdTAMmN9" +
    "yE6QDxTxRLXBhTjIBvHklo6HZ0+5pQPUvAltKIf9ILWLwfGhciK0t3zs3Y2y" +
    "J4zZFreDKn9pLFzjG62xCGpg2WlrMDe9dwi32dNgL0C5hWOzzV5NPP0oG+Dq" +
    "GzGUDqE+oX4M9AHUPAwdBWMQ6pMYfeqQVH2DbfZsonwatH1AbqM1FkENbATa" +
    "bpHkR4n/cA+cMJ70uqwNx0ZtGEJ/MTbA1TdiKB1CfUL9GOgDqHkYOgrGINQn" +
    "MfrUIan6BqnNRV4guaY3amMR1MBGoa3B3Hg7NBie9Gq8C8dGbRhCfzE2wNU3" +
    "YigdQn1C/RjoA6h5GDoKxiDUJzH61CGp+gYpzaWtsUzxt6tjoQY2Em1vUzca" +
    "DE+6jHk4NmrDEPqLsQGuvhFD6RDqE+rHQB9AzcPQUTAGoT6J0acOSdU3iGku" +
    "sk6tbzcLG+Ht5i7UwEaj7YN2//tu81+0u9XuA/AA4MjlQ09E2fSFOVl5Eeo7" +
    "eVNu4sWgHDDmILVKzMHE8+HJd/fnJf84eqPt9NrdDI1FUAMbka4GI0/eeVKT" +
    "8RYS5FxU1sLqDXOy8iLUd/Km3MSLQTlgzEFqlZiDiefDk+/ePS954WtrLMv6" +
    "XaFU1MBGpe3LjoJ8o5onPglvIUHORcWFNQjMycqLUN/Jm3ITLwblgDEHqVVi" +
    "DiaeD0++e/u85AGtvPBxnW6mxiKogY1M2881CL9yjzC7DOUCiMJbSJBzUQ2y" +
    "YQhzsvIi1HfyptzEi0E5YMxBapWYg4nnw5Pvrucl6+8m2+u1WbEMv3s7JGpg" +
    "oyMNpu2zMNm3Sd5CglwtKuoPAXOy8iLUd/Km3MSLQTlgzEFqlZiDiefDk+/e" +
    "nJN8krztNkhYth96GgI1sFmwfpO34ib3nn+zuo1bAPkdjU7og/IcFuHTk1s4" +
    "NrcAlK8CN9ux/TZIXgiX6acph0QNbCasfxWouPE91hc7N8eupbm0yi0cm1Vu" +
    "LvLQ1voXxIrN8I5QF2pgs9H1oFdeTX77vkFtkNJcWuQWjs2qNpff2TmEX95W" +
    "r7mKzfZ8xUINbFZSbpNKc2mRWzg2q9hcVvU2iKiBzUzXbZI8bJOf0JRXnJXh" +
    "vg7Ut2woX1XWavHbO80/Hc61VbHZb4OIGtjsyG1S27tJgtwj/59V2TRsFIT6" +
    "lg3lK8qv3XPtauWuej1VrMJtEFEDq0LbFx8F+adH+eAdF9Cmg42CUN+yoXzF" +
    "kFugG3Y8W9mo32geAjWwSrR9baBCbpXk9zW4oDYNbBSE+pYN5SuCXN3+SssX" +
    "Divki7Vcc6uEGlhFuh72CrKIbrbT/JlMNjsCyoeAMTxov6RI7esseh7yLeau" +
    "WyC5WtmMH4pLRQ2sKnJPzEVSR37PVH6Migstmik2BGN40H5JWZbmctO1W+Ub" +
    "3l2vjTqb6btBfVEDq07bb8RUyK3Sb+Qs6Ck2BGN40H5JWXRzkZjeLdCqvRMU" +
    "gxoohBvI5xC8WyX5hG9Sk5liQzCGB+2XlEU1Fzm/cp69W6BXHVMai4UaKGzF" +
    "u1US5FOYv3qv+QfxtrD9ANT9WT4pjyHVB/VjGMMHob4H7R3k9rfr07UV5Rao" +
    "GzVQ0Hi3SoLci29pMlzcOXDRe/IYUn1QP4YxfBDqe9C+hdimspF/13ZK1EDB" +
    "Rp7+e7dKW5rMPY0FngoXvyePIdUH9WMYwwehvgftgbwoxDQVuQVaxQ/D5aIG" +
    "Ct2kNBn5gSq10GPhJvDkMaT6oH4MY/gg1Peg/TrSVLx3f0pTyUcNFOKIbTLy" +
    "MFBeFW98z/k7DrmIfR1pXC6Gn05on0OqT+pbNpR70B7I+bD+KpXI+S2fV8lH" +
    "DRTSkHeWYp7JCPK1gl/eztgMEZTmkgDt17jRtnFXKUJpKsOgBgr5xDaZ/3XX" +
    "+UK/UcLGKc0lgXU7+Yay1FnqzXNgUZrKsKiBQn9im4wgt03yxTfvtqk0lzik" +
    "NnLb0/Z7KhZyvlblN1amRA0UhkM+B9H18w5EXmHlWYC82krDaSBjdSi3dPpC" +
    "/xaeDeWE+jE2ZNv5LWdKQxHK51TGRQ0UhkdeFbt+qMpCGo1sFtk05objhrR0" +
    "+kL/Fp4N5YT6MTZ3nzdhqU/sLU+FXKWUW59pUAOFcZGPinf9lkwbW5pN25VN" +
    "5KZMgv4tPBvKCfVbbHKbiSDPUspH9KdHDRSmQz47EfN2toW6smnZlL3gprfw" +
    "bCgn1F+3qW5zcpqJILej5bZnsaiBwmJIfT5jIQ+HZUM2rnD6wE1v4dlQDqom" +
    "UpHbTCrk9rM8nF0O1EBh8cglfMo7TquM1Kl8enY5UQOF5UM2T2k2c+R5ldSj" +
    "XJ0sP2qgsPzI5sp5KLwRKc1k46IGChsPuY2qrm5yHxAvGnneVN3ilNuczYEa" +
    "KGwe5NVeNqo8LF6W2yrJQx66lquRzY8aKKwOVfMh0gDq8BZMro6oQx+leRTU" +
    "QKFQKAyBGigUCoUhUAOFQqEwBGqgUCgUhuD/A5L3SxS2t8lyAAAAAElFTkSu" +
    "QmCC")

STEP_OVER_DISABLED = ("data:image/png;base64," +
    "iVBORw0KGgoAAAANSUhEUgAAARcAAAEXCAYAAACH0wDUAABE6ElEQVR4Xu2d" +
    "e5vUVNa33+//DZ4ZAQUbUEEQERBEWwHFA4giDoI4clKQgyAeh3HqrZXq6sq+" +
    "fytZSVUqVdW9c133H70P67TXXp2kKqn/99lg8P8ymUyma6Qhk8lkukAaMplM" +
    "pgukIZPJZLpAGjLbjw8++GDw1ltvJezbt2/wf//3fyEvvviizD116tSAOjLb" +
    "D2nIbC1so9uGZ1FYJK+//nouQNsAacisJm3ONpaV8VkQfcusJtKQWX7sv75t" +
    "RG7OrUouOKuJNGSWj3kWk4MHDw6OHj2acP7jjws+Pn9+kzu3bxfcHnJ++Deh" +
    "DIO6usDikC+pVgNpyCweu8Ha1SXOuHhYAfj888+L4vDHH38M/v77b+V//0v4" +
    "37CNyBwCGX//z9r+Hty+c3tw5esrw6J1vigOB18/KLZOQy42y4s0ZBaD3eTk" +
    "xmmKbTArIO+//35RRG7dujW4f//+4L///W/3PE95/t8Ujo/6H//88+Dm0N6P" +
    "hnYb5scsZ2lWlBnbzGKQhkx/2H9cbo4m2OY7efLk4OLFi4Ofh5uTG3audFxc" +
    "2D8eY35duXKlKJjTnsXlezWLRRoy88Uuedr+Zy4Xk/v37w0333PZpL3RU3Eh" +
    "5WLTNn6GxZ1rkZkv0pCZD23/+9rlQVpMiG7AXlhQceGce8PLPouPFd02xSZf" +
    "NvWHNGS6o82X12yDrK+/P7h27frgP/95PuQ/9TxXnj9/XovIAM8B5Rc6OEYw" +
    "PSVMbwnOp41N7KRM48d79wYfffRRq0Jj97m4ZpnukIbM7LQ5S7H/vF999dXg" +
    "119/w8Z0NlWywRRuUiIyADc+5S9zcSlz7dq1YaFel1hXYQWJa5iZHWnITE/T" +
    "omIfD1+4cGHw+PHj6k3JDUW8je9s1Dablhuf8leluIzH/frrr0XhPvpms+/c" +
    "5CLTLdKQaU+TU/F9e/cWp+33fvyx2aaUfm4whZuUiAzAjU/5q1ZcJn49Lwq5" +
    "xX/f3vgfQC4y3SANmeY0KSp2em6n6dxU3ACyKaWfG0zhJiUiA4iNng6OEeAH" +
    "Nj7n08YmdlKmgPFWXMrc+/Fe48um/CnT9EhDJqZZUXlv8OjRw8Fff/1Z8Kfw" +
    "V8J4XPX4lL+KOSky5k8AHTL/z5S/PKiXOoLxtJE6R1j7hMhu9jO2orPQ++fg" +
    "4cOHgw8//LDRTeBcZNojDZlqmHAe6++lRaW6WKQbIB6fohtMN5FsfOiQ+djk" +
    "UiicYiE6gvG0kTr7LC5jfvnll1xk5oA0ZJToRq0lpSXno+F/Qn8TO8mNDRCP" +
    "T9ENpptINj50yHxscikUTrEQHcF42kidiyguBcNxvzx71qjI5HsyzZCGzITo" +
    "eyrjovJs+J+vfhM7yY0NEI9P0Q2mm0g2PnTIfGxyKRROsRAdwXjaSJ2LLC5j" +
    "rMh89tmFwd69e2XNy+TvydQjDZkRTCQWlXPnzg2ePn1aPGGc2Qr8CUbtX375" +
    "ZVhkmDuZEdKw3YkugXJR2ar4xWXMZ599Vnu5lC+VFGnYrkRPKL/55puDBw8e" +
    "SNJltgr1xcWwfyrvvfee5EaZ/CT2BGnYjkT/ka5evSqJltlqxMVlzHfffZcv" +
    "lRogDduJ6AVNZ8+dHfz85OfB77//Dn5L+G3YFvJbCmX8/hv5PeG3Qs8EmW/t" +
    "0BFjc8qgnz4UfnAOCXTADw+J92+IBWVSJ+Vh/og03uJnIMP0nj17tvZSabs/" +
    "gS0N24W6pDhy5EjxWsbKZC/aSptaEtMBG4AymOySzEx2B+qIKW9QZz59KPzg" +
    "HBLogB8eEu/fdGPX6qQ8zB+Rxlv8DGSMddsb/06cOCE5VIa5t12Qhu0AF3+M" +
    "FZwvvvhCE4vJXrSVNrUkpgM2AGUw2SWZxSaFOmJGG6R6kzrIHBLogB8eEu/f" +
    "/I1dqZPyMH9EGm/xM5BBG27cqL9U2o7v+ZWGrUzdZZCd4trbzrwNIMletJU2" +
    "tSSmAzYAZTDZJZnFJoU6YtINIv30ofCDc0igA354SLx/q9/YopPyMH9EGm/x" +
    "M5BRZcPZs+ckt8Zst8skadiqVF0GWfvXX39dPJ4/T579+izh12fk1xQbk6Ay" +
    "O0dsmB36/axoC3iWspBYAPrB/vJa3rp5c7B3bU1ybQxzc6siDVsRLu6YAwcO" +
    "DO7du6eJMgckOXNxqWbFi4vx+NGj2nsx2+EySRq2EtFlkCTIHJHkzMWlmi1Q" +
    "XAqG7Z988onk3pitfpkkDVuFRV8GEUlOJqJs7AVsKLFhdui3FBKPLVRcDPsd" +
    "qbqbvczdrYI0bAW4eGNee+21wY8//lg8Yp/yLOUZYD+wBxfL/PJMeVaMq0Zs" +
    "4vyhHSnWRtIxlBnq5HjRafGAbZw3a783BtDvtus1gnrRT52luLmxow0Wr9L4" +
    "R8PLpOPHj0tOjtmKr3KQhlXGFoiLNubMmTOaEJWJBdgPcnEpMWu/NwbQ77br" +
    "NYJ60U+dpbi5saMNFi/OGcr5+OOPJTe3aoGRhlWlqrDs2rWr+DEtSYbaxALs" +
    "B7m4lJi13xsD6Hfb9RpBveinzlLc3NjRBosX52zIunnz5mCt4tOkrfQaB2lY" +
    "RaoeOqy+DCJMLMB+kItLiVn7vTGAfrddrxHUi37qLMXNjR1tsHhxTkmeXSZZ" +
    "fjJnt1KBkYZVo+oTIVu4hw8eFE+yJjxx4JinT0Da/+QJsLYST588UQIdTwD7" +
    "Y3kxYmeI2kEZod2UOY0fbec0GK9+cA0DHJkKY0GeDk6fPi25a2yFT5KkYZWo" +
    "KizHjx0bFRYvsZgkbqJoEpTJxaVMYDdlTuNH2zkNxqsfXMMAR6bCWJDRuKoC" +
    "s+rviJGGVaHqo+bT77xTn1hMEjdR/CQYk4tLmcBuypzGj7ZzGoxXP7iGAY5M" +
    "hbEgk7H2gQNzedULjDSsApWFZfgfIEwsJombKNVJYOTiUiawmzKn8aPtnAbj" +
    "1Q+uYYAjU2EsSDr+4sWLktNjuAdWAWlYdqoKiy1MsUhRYjFJ3ESpT4JcXMoE" +
    "dlPmNH60ndNgvPrBNQxwZCqMBeH4rVVgpGGZqSos9rvL9kRzI544cMy24Qlg" +
    "//x5MtRLOCZki62nvenOvkLBPF+1AiMNy4pXWGwBLl++LItTCxNxCyTj9OTi" +
    "sqxshQIjDcuI90Z+C7wtABclhIm4RZJxOnJxWWYsv73vwqzKTV5pWDa8j5un" +
    "LiwGE3ELJWN7cnFZdqrOYFahwEjDMuEVFsN+Q+bR48cF9t6MWmxMiUePHymP" +
    "Hic8fmzzJrBfgDzOL6BdgvlSQuajX+ab7lFMJtAuxMLm1ED5Ix2A89hPEDvK" +
    "b0ThSzVRHIwoFqIT0A/K96AM2sA1Htt/48YNt8As+xftpGFZqHpWqFxYcnFJ" +
    "iTaVxMLm1ED5Ix2A89hPEDvKb0ThSzVRHIwoFqIT0A/K96AM2sA1LvtgBYZ7" +
    "wVjmRwWkYRmoKiwfffhREvBcXFIYG7ULsbA5NVD+SAfgPPYTxI7yG1H4Uk0U" +
    "ByOKhegE9IPyPSiDNnCN6Yf9Y+WeWOYCIw3LAINn2MOJXsBlwQiTyFl0Jook" +
    "KxOJMIk8aJeA5JL5TD7ON92MD+1CLGxODZQ/0gE4j/0EsaP8RhS+VBPFwYhi" +
    "IToB/aB8D8qgDVxj+mG+VRWYZXxdgzQsGgZtXFgePnzYDQ8cOIZg/IOHKTJ+" +
    "CuYhsy192PDA4leC/QVt12cZoM1ztHt9fV32yDIWGGlYJAyWcfjwYQnuTDAB" +
    "miQBxs9jE85DZlv6sCEXl26oes0I99QikYZF4X1J7tVXXy3ex8LAzgQToEkS" +
    "YPw8NuE8ZLalDxtycemOZS8w0rAIvI+c51JYDCZAkyTA+HlswnnIbEsfNuTi" +
    "0i22T7h3luUjamlYBAyOfaZ/7dq1wU8//eTwIOHBsK3MTw+AzFcePHiQQpnQ" +
    "KTxIeVDYlSJ2YQ5RG0hsRzSHfrNf5yu0k9Bv6XehnT8l0E/KbAJ1qA0pjBXh" +
    "eB/qBMyRBvPv/vDD4OWXX5YCswy/iyQNfcOgGPZbLxpYP8CSNOECKUwUkeks" +
    "aoIkuyJ2YQ5RG0hsRzSHfrNf5yu0k9Bv6XehnT8l0E/KbAJ1qA0pjBXheB/q" +
    "BMyRJvOHuq9dvy57yOBe6xtp6BPvPsvJkyedoFYHWJImXCCFiSIyuaCklOij" +
    "ZFfELswhagOJ7Yjm0G/263yFdhL6Lf0utPOnBPpJmU2gDrUhhbEiHO9DnYA5" +
    "0mT+RgzOnfN/o5p7rk+koS+q7rPcvXvXCWp1gCVpwgVSmCgikwtKNhZ4kuyK" +
    "2IU5RG0gsR3RHPrNfp2v0E5Cv6XfhXb+lEA/KbMJ1KE2pDBWhON9qBMwR5rM" +
    "L8Xh6FtvyZ5a5P0XaegLBsHus3zzzTeD+/fvp9xLuQc4Pup3gQ7pD7gH2O+P" +
    "uQc4/l7C/XsplOfppQwdX2+DxKWITTrHfmu7TGRnJG8k8366hkTshF6RqXPU" +
    "LsoIxks/Y60yiPjJMfCbNtCOO3fuLNX9F2noAzpvfPzxxxpcL8DBgkT9LtAh" +
    "/QF1C149pn4DSKIGm9bTSxk6vt4GiUsRm3ROLi7jfsZaZRDxk2PgN23w7LB/" +
    "0NxbBvdgH0jDvPHus7z99tvVi8EABwsS9btAh/QHRAvuj6nfAJKowab19FKG" +
    "jq+3QeJSxCadk4vLuJ+xVhlE/OQY+E0bXDuGtp89e1b22CIKjDTMk7eca8JX" +
    "XnllcPvO7erFYICDBYn6XaBD+gOiBffH1G8ASdRg03p6KUPH19sgcSlik87J" +
    "xWXcz1irDCJ+cgz8pg2uHRvrcPToUdlrfd9/kYZ5QmftPsvVb64Ofrz344gf" +
    "Y+79eC+B/Yvg3r0U9k/DPcD+6bB4lWnbPwfGa1+GY5aSLmJVL0NygHHyYrXR" +
    "fuv2Lff+C/fkPJGGeeFdDp3/+Hx9oBxycZmF+mSO++cAN0tH8Zs/XcSqXobk" +
    "AOPkxarUZ/+4uef6LDDSMA+897O8+eabcaAccnGZhfpkjvvnAHOgo/jNny5i" +
    "VS9DcoBx8mKF/nfffVf2nt2e4B6dB9IwD+icXQ7Zm7UYCAmUQy4us1CfzHH/" +
    "HGAOdBS/+dNFrOplSA4wTl6snP5FXR5JQ9d4X5azaloViIhcXGahPpnj/jnA" +
    "HOgofvOni1jVy5AcYJy8WDn99vM73IN9vOBbGrqGTtmnQz/cvVtw94eUH374" +
    "IcQe1EqBHJNbYqxropPzf9Axd39I+KGwbQJ1yHgP8SO1O7KBNku/p4P9AeIX" +
    "Y1v4Tx3pHJVJG9RXIr4C0cH+JgQyhNBPxM7xizZIbJBnAuU5dlTpsNsQ3Ivc" +
    "q10jDV3i3cT98osvNgMTJa6HLDpkRAus821RMCZYdOqQ8R7iR2p3ZANtln5P" +
    "B/sDxC/GtvCfOtI5KpM2qK9EfAWig/1NCGQIoZ+IneMXbZDYIM8EynPsqNJx" +
    "/fq37i8IcM92iTR0hXcT98SJE0lgosT1kEWHjGiBdb4tCsYEi04dMt5D/Ejt" +
    "jmygzdLv6WB/gPjF2Bb+U0c6R2XSBvWViK9AdLC/CYEMIfQTsXP8og0SG+SZ" +
    "QHmOHXU6Tp8+LXtyni/3loauoBNWNW9+/30SmChxPWTRISNaYJ1vi4IxwaJT" +
    "h4z3ED9SuyMbaLP0ezrYHyB+MbaF/9SRzlGZtEF9JeIrEB3sb0IgQwj9ROwc" +
    "v2iDxAZ5JlCeY0eko8+bu9LQBd7Pr77//vuDO3dugzshtwH779wG7G9EO7to" +
    "0+3bKRzfF7SDdnJ8CGPbhW8N5Nk3tsuwfyHAbsZaxjssYj2o89KlS7I353Vz" +
    "Vxq6gMbv379/IxDtNrEXHPa3DbZPO7to0zSJNg9oB+3k+BDGtgvfGsjLxaUC" +
    "xq6BXk/n8ePHpcDM45cDpGFWvJu4V65c2QhEu01cFZyElsH2aWcXbZom0eYB" +
    "7aCdHB/C2HbhWwN5ubhUwNg10Ovp/Pe//z3YuXOn7FPu5VmRhlmhwe+8804p" +
    "EO02cVVwEloG26edXbRpmkSbB7SDdnJ8yEZM7965O9h88dWDB8X9BBnblAbr" +
    "lYtLBYxdA71VOu02Bfdq12cv0jALPGux6vjdd98Nbt26NeL27ZRbZGNcmduA" +
    "c9gPHbeHMsqI/IJIZkok8/Yt05vCMZTJ/tumpwT7Zb5jl2DxKGFy7ElaKxhP" +
    "nz4d/Pbbb4M//vhjMM3x119/FfNNjv0C4f37Pw28NdW4OEie0H+OZxw0/kRl" +
    "Asmj+vnsL8YEfnjrkdpAGsgE7C+zZ88eKTDc07MgDbNAQ+3aLg0WA0M0ABJg" +
    "zmE/dDQLdiQzJZLJJPOSkTLZP4/iYv+x7OcorAA8f/6c9WEuh+l59uxZ8ROp" +
    "dsajcXGQPKH/HM84aPyJygSSR/Xz2V+MCfxYdHHx3rvb5dmLNEyL9wmRvRUr" +
    "DRYDQzQAEmDOYT90NAt2JDMlkskk85KRMtnfVXH5aXhmYsXEziyW4RgXG/td" +
    "n1FcHCRP6D/HMw4af6IygeRR/Xz2F2MCPxZdXIx5nr1Iw7TQQDlrMSQwRJ2X" +
    "AHMO+6GjWbAjmSmRTCaZl4yUyf5Ziot9/6HPs5Npj7///rsoNPZcTRp/QN+D" +
    "9WLsPVQmkDyqn8/+YkzgxzIUF+93p7m3p0UapsE7a/nX1auDmzdv1vM9+V4J" +
    "56R8D27eNBllIM+BMr4fziujMhsQ+SVQBvtTLDkfP/558Oefy3GG0vZ4/vw/" +
    "w4L4ZHjpdEd8ax075sRNh6GcMm3j3domD9ip/akO8YHjHZnR+Bvf3pBPjrr6" +
    "3os0TAMLy7Fjx1xHBAaXC+YtmsxJYWFonTQ3VcYyFxcrKnaWYmcBW+Wwsxm7" +
    "P7PpZ9vYMSduOthmLdE03lPb5AE7tT/VIT5wvCOzyXjvN6e5x6dBGtpSddbi" +
    "OkIYXC6Yt2gyJ4WFoXXS3FQZy1hctmJR4bFZZNrGjjlx08E2a4ko3kJbmzxg" +
    "p/anOsQHjndkNhk/r7MXaWgLC8v4rMV1hDC4XDBv0WROCgtD66S5qTKWqbiM" +
    "i8p2Op798svg7p07zWPHnLjpYJu1RFW8K2m9ng6wU/tTHeIDxzsym46fx9mL" +
    "NLTBe5v/xYsXhov174J///t7YG1toYyU74djysh8s6OMI0PmBP2tdRZ6Z2Qo" +
    "4/5P9wf//e9/ufe2xWF+28fZo3jUr880jHN2krvoL3JtAvuXhTA3K7h+/Xrn" +
    "Zy/S0AYWlgMHDmCBukgCykgJgymbXGXInKC/tU4nWdtgZyu///4799u2PP78" +
    "88/i06W69ZmG7V5cDPuddu5p7vk2SENT7Ms2NKR81pKLC+CYhjx58oT7Kx/D" +
    "w+Jy8+atgbc+05CLy78HX3/9tezpWd73Ig1NoRE8a8nFBXBMgF0P57OV+sPO" +
    "YuwdJYzdNGjuor/Ita1dXAzvVgf3flOkoSk04MwHZwY3vvsu4bsb9dz47kaC" +
    "PYdEbti4MjKnLapDoJ2A/dRBGwtEjrVN+K6EveRnu95baXtYnOyBytr1QKwL" +
    "ovXZyOGmuewhOkmko4EfnEOZbf289IW+74V7vynS0ASvul375poYSscJHZdN" +
    "bnIkGJzTFtUh0E7Afuqgje6iSpKM+Pnnn7l/8tHgsE/Q7IzCXQ9nU4brs5HD" +
    "TXPZQ3SSSEcDPziHMtv6aWP4SMC0PwMrDU1gYbFi4zlGxwkdl01uciQYnNMW" +
    "1SHQTsB+6qCN7qIiSewU9vfffuOeyUeLwy6TigLD9XA2Zbg+GzncNJc9RCeJ" +
    "dDTwg3Mos62fNubtk2/LyQNrQBOkoQlU/NFHH7mO0XFCx2WTmxwJBue0RXUI" +
    "tBOwnzpoo7uopQSxa13bGPmY/bDLJHsnT7IezqYM12cjh5vmsofoJJEO5hXn" +
    "D+Ecymzrp4356spXUlymeVpaGiL4jdzinS0VjtFxQsdlk5scCQbntEV1CLQT" +
    "sJ86aKO7qBvJYTduc2Hp9mCB4YYcbexgfTZyuGkue4hOEulgXnH+EM6hzLZ+" +
    "jsfZBzQsMKwFEdIQQYVvv/324Ntvvy24DsbtE64D9q8m6jf9dHy9/m3x5Gy+" +
    "cTufw+JqvzYocZ8SXeP2dCGjL7yvmrAWREhDHZ7Czz//fNOgOHjBhltR1G/6" +
    "qb7mwtLP0VWB0TVOaaInkrFMXL16VfZ62x+wl4Y6+BpLu0QqGxQHr37DrSrq" +
    "N/1MfbVLr1xY+jkszvYNZ65ZW3SNU+wVn4atLfuaylg2jh49KgWGNaEOaaiD" +
    "ik6fPp0YEwevesOtMuo3/Zz4asmX77H0e3RRYHSNU6ywjHXZk9zsbyJj2fjw" +
    "ww/7KS7eU5NfXr48uHb9eiX2MFSZa9euBdgYcP1aPRwPmdeBjp/Yuwn7AWVe" +
    "L9omcPxIx7XBtze+nfoF2PmY7bBN/+23NyrXMM6besbFZXw8fvRIxnA/SN4g" +
    "t2nDdWsDkrvcHwR5KTYAPszY5jsv0lAFC8uhQ4ccx1IYTAZbUeckOITjuaBA" +
    "x0/snXdx+eXZL0kC5qPfwwr7uMBwDeO8qYfFxQ5rszOATZncE8wb5DZtYGHp" +
    "o7jY77tz77M2VCENVVDB+vq641gKg8kFUdQ5CQ7heMjkAun4ib3zLC6PHj9i" +
    "7uVjAYc98OitYZw39XjFxY7xJVkhk3uCeYPcpg0sLH0UlwsXLvZfXL788kvH" +
    "sRQGkwuiqHMSHMLxkMkF0vETe+dVXOxHs/KxPMe9e/dlDeO8qaequIwPexcN" +
    "94PkDXKbNrCw9FFcDF4a2S0S1gcPafDgs0S7d+8efPPN1eKnQ8pcHbaV+ebq" +
    "NwlXizET2E95TYh11vdPqzfhqsmdUPbRFnyVPhn69ddfBw+HG8Eov5m+7G+5" +
    "/aeffio2js1bFT/NTntMoC43CXPmKjD/o8PG2GbdnBfkJm2gTkNy0eSUQW7K" +
    "+Kh/iN0CKe//pi+RkgYPnrXYz4bk4lKiprg0SbpFHnYf4uHDRwP7iQ5Znymw" +
    "V0Zawfnll+W+v2R+23/qqtwkzBlu8qbrbIWtiHWD3KQN1NlXcbGfZGYNYI3w" +
    "kAYPCj579syG8akRbYPFfsprQqyzvn9avQkVxcX++y/j8ddffxUFwL7+nSTr" +
    "ht2b6zMjdupvepb1E7JHw6JalZuEOcNN3rS4jA8r6FFu0gbq7Ku4XLhwob/i" +
    "cuXKVxvGp0a0DRb7Ka8Jsc76/mn1JjjFxZ7TWLbLBNsA9gNr48Rjosr6dIhd" +
    "Qi3j2Yx9U9rLTcKcYezaFhc7isuk69cqc5M2UGdfxcWY5r6LNBB7zV1Z6N69" +
    "ewf/+te/NriacHXYVmYyboOrgP1dMIWO0O7W468Onj5dno1kSWwPSKqd9dBP" +
    "z9eon+vx7Y0bg6dLVGTsrKqRHwHTFBc7isuk4dr4OtP95YL4ih/hfqjfw2O7" +
    "jhw5ktSBJvddpIHwrMV+OqSpYeJI6GgHTKEjtLvleHu36zIc44f3aF9T6Kfn" +
    "a9Qv63HVNsTVwc1bt5bm96vv378f+xEwbXEZHw8fPhSZ3F8uiK/4wfgHOjh/" +
    "HIv33nsvqQMGawWRBkKBZ86caWyYOBI62gFT6Ajtbjl+GTaNvdHOTmdpWxvo" +
    "p+dr1C/rsVFcxtimWvRhRfjGt9/W+xEwa3Gxw2Ska+YUE4L4ynow/mJ7/R4e" +
    "x8IeUGYtYK0g0kAo8PLly40NE0dCRztgCh2h3S3GL3qzbJ6tNPS9DvpJX70x" +
    "7Jf1QHGxMXbJtuj7U1aMa/0I6KK42GFxmFzCOsWEIL6yHoy/2F6/h8uxsK+g" +
    "lGtB9JS0NJTh/Za1vXsHV77+esKVK8DaJnwtXElIZA35+usrCuYQsQEyadOV" +
    "r21Mish0xqTj6deIq8PFWeQmsV8LsJcKTeJnMa1GYxOvRzRG1kNIdY5tsUf8" +
    "F/1rB/altImfwZrD719/fUZxMx0PHjyQWDH2XvyjXGa/zHcZrRHvu0RnL9JQ" +
    "hoLeOnYsdS5KHCF1LAyUFwzKIFwAWaA44Own6tcIS4hFHbYxrw7/M3lJUYXG" +
    "Jl6PaIysh5DqpE2PHz+ma70dpnviZ7Dm8Lvr4mLHs2e/FmcTVevjxT/KZfbL" +
    "fJfR2rz77rvzKy7nPvwwdS5KHCF1LAyUFwzKIFwA2MRgewFnP1G/RizqrGWc" +
    "hBK7jaSoQmMTr0c0RtZDSHXSpkUXmPHZS7jm8HsexcWO4tvE33/vro8X/yiX" +
    "2S/zXUbrcvFiu+eMpKGuuNCxMHGE1DHKU6fS8R5ig9gINoJcF3D2E/Xr68EP" +
    "d39gXvRy2BnLZKMidhtJUYXGJkXlaXyln+shpDppU2HX14srMOOzl3DN4fe8" +
    "isv4KC6TEHsv/lEus1/mu0zWht93Yc2Yqrjs2LFj8NVXX7XkMmD//LFviD57" +
    "9mzu/P3338yHuR9WWGzB6fNWwZ5ZWsRhN2e5vhF9nLWankWv9yuvvJIUl7fe" +
    "qr6pKw1jbFJZiAmlopjFFxdbkK142Mfdi060Plj0Td5lO6yI2U/RME59wbpQ" +
    "92U6aRjD9+WaUCqKycVlXoe9hIi+bkWsgPZxVrBqh52RM1Z9wOJisHaExYUC" +
    "cnFZnuPevXvi51bG/lPnQ49FXCadO3eu++JiQqkoJheXrg97kxp9nBb77zdv" +
    "7Bun1DsNJisfevR9mdTmCWlpqCouH310fvDll5cTLn/5ZYK9sDvB2krIePYP" +
    "50R8edn0TLhc2DGBNm6l4mKJZF82s9gylqN4qv8JiF0fh/3aQaq3lB/Oerpj" +
    "NuxfhscqlvWw4jvaR/VrLmA895sHawNrR+viQiMKQ5jckhRm/AQZz37HEcLg" +
    "bKfiYl/rH8eWsdwOxcVk5aP6sFy3j/vr1lxAjnC/eaytrSW1oer1C9Jg8GdE" +
    "TBiNKAxhcktSmPETZDz7HUcIg7Ndiov91y7HlrHcDsXFsMvCfFQfdnZbxLxi" +
    "zQXkCPebx4EDB5P6YI8JsYZUFhfeEbaPoWlEYQiTW5LCjJ8g49nvOEIYnO1S" +
    "XO7cuZPElrHcLsXFLgvzER+jy6Sq+JZAjnC/eRw92uwTI2kwOPHo0TcHX3zx" +
    "hXIJRP0E4y9dUnTOpYBU5jK+/azt8eeffzp+emhM69ajj8NeDnXJ1nYD2iA2" +
    "NsCeYM5HfFju201Yxq8e5pRy6tTJ7oqLCVMjvogThf0E41lYcnEZHfaKSPXT" +
    "Q2Natx59HPMoLjeGMvPR7Hj+/HkRL8awGuaUcubMB90VFxOmRnwRJwr7Ccaz" +
    "sOTiMkqOkS/000NjmoBY9nHMo7gY0e8E5SM97G17jKEPc8qHNYI1pHFxuXjx" +
    "gmPEF3GisJ9gPAtLLi6j1x+OfKGfHhrTBMSyj2NexeWHHxbzoOgqH80uk5hT" +
    "PqwRrCGNi4u94q4Rl8Dnl4AzJ4IyCceDVS8udgOTPlVxCUTx7+OwnxdJbLx0" +
    "KYE2udi4MsM2+wAgH+2O+/fua2yDHKkawxrBGpKLy5IfdiOX/tSxnYqLkW/s" +
    "Njvs0tq+xXvJyYEoR6rG7N+/PxeXVS4u9g4P+lPHdisud+/epbp84LB7U/b+" +
    "GSss8ywu3hfppLDk4rI8x61bt8SfOrZbccnfeak/7AHXcVGZd3Hx3usihYXF" +
    "5eWXXx5cuHhxcPHCBeViij3UVObiBZs3gf0mtzUig6Tjnz59ypivzGEPe27G" +
    "F7GUtXDiaa8lrKOP49q1a7U5wRzy4JqXfbBT/nykR/Hx83c3iv0gsUSOcP8w" +
    "Rzxs3L79+2YvLvuGFapIVCeZxXAmQS4uUx/2df8kvtyUXAsnnkwK0scx7+Ky" +
    "qus7r8Mugy4P/ylNigViiRzh/mGOeExdXPjV/1xcFnPYqxaT+HJTci2ceDIp" +
    "SB/HvIuLnfrnY3T8+OM92Q8SS+SIjtc8ITaOPzOSi8sKHY8fP0rjy03JtXDi" +
    "yaQgfRzzLi72zNV2P0bfwv1uGBtb93Q/SCyRIzpe84R4xcV73WVcXPbtG3z2" +
    "2Wcry6oWF3s5NX3pmj4Oe1kU9XaJyd/Oh53h2nd+GJd588YbbyR1wmAtCYuL" +
    "CaHgVWJVi4t9A5W+dE0fRy4u8zvs/T6MR19MVVzsTCUXl8Uf9rAifemaPo5c" +
    "XLo/xg8jMhZ9MlVx4YRcXBZz5OLSnO10LOoyiLz33ntdFJfDg08//WTwiccn" +
    "5FOQ9pucMp98+mmKzP908KnNmwH72rNdYnTJs2f6o1hd869//SuN1Sf1sSyA" +
    "71wvju/jsC+6JXYXazqBNo7yCnkg/SmM3Tywp4qZB2X++PMPut75YXoYG645" +
    "kdjJnkM82V+Qyvh02Nbkd6O3fHGhzRYYxdoncE7oB/plfjGm3i/KiHSwv4Ay" +
    "YQPH93H0UVyYR4wD/R6R5oDIJNBBnjyd3+s37TLo2+vXNS5OHhGJHW1v5Gcq" +
    "Y+riYu/DzMUFmJwSMh79Mr8YU+8XZUQ62F9AmbCB4/s4cnGZ7bDLIHsVwihH" +
    "EBcnj4jEjrY38jOVYfGa6p4LPy06ePBgsRhU4C6yOJ/2c4HFCZkfBy+CNjOp" +
    "cnGZ75GLy/SHXQalOYK4OHlEJHa0vZGfqYzOiot9elQktwcNE+fTfi6wOCHz" +
    "4+BF0GYmVS4u8z1ycWl/2GWQPfBJPyQuTh4RiR1tb+RnKqOz4rJ3797Bxx9/" +
    "3IzzKec/TuH4qH8k8zyo10FUntJ6DvsbcR6wH0yjU/w6n8DxfRx2Y7qsM4x1" +
    "QctYTUMU35b9T550U1zsMsieFhd9lSBWYQ4QyouxdTt0+LCchLCW5OLiyAjn" +
    "sL8RLRd1Gp3iFxMrHd/HkYtL88PeTyN6QhCrMAcI5cXYurG4NHq2yMjFJZjD" +
    "/ka0XNRpdIpfTKx0fB9HLi7xYZdB14aXQaKjEYhVmAOE8mJs3awuzFxc7IEk" +
    "Cq9EHKtPpKh/JNMCVqZeB1F5Sus57G9Ey0WdRqf4xcRKx/dx5OJSf9hlkL0A" +
    "qzoWEYhVmAOE8mLM1k6Ki2E/Qn/e4aOPPgqwMWXQfx7IeGdOS84D9nuEftJu" +
    "Ij6cd8bMiqNDqJ/Tx2G/Xax2RER+dEDL9dCcSJmmuNgT3dRTa6MH5wipndwP" +
    "ROeXdJV05uLyUcPgyZzAT9pNxIfzzphZcXQI9XP6OHJx0cMug+yxCOoQaKMH" +
    "5wipndwPROeXdJV0srh88MEHubiw3yP0k3YT8eG8M2ZWHB1C/Zw+jlxc0sMe" +
    "JbB3olC+C2304BwhtZP7gej8kq6Szj179iQ1gjUkF5cKQj9pNxEfzjtjZsXR" +
    "IdTP6ePIxWVyhJdBhDZ6cI6Q2sn9QHR+SVdJJ2sEa0jj4rK+vj449+GHwofk" +
    "3LkU9oNzH54Djo5zQGRExDrIhx+a7SXgVySTNo6ATPa31kF5HK92kz4OKy7i" +
    "a4lz5msAc0BiEfU7iA4nnklsOR46635DaXwZxPU5Z7aWoExCvwpoF20PZDAn" +
    "KK9KJmsEa0jj4nLy5Ekxyl00GCr9QIIN+SPngciIiHUQDSYWIJBJG0dwkdDf" +
    "WgflcbzaTfo4tntxscsgezVnoZNrZLaWoExCvwpoF20PZDAnKM+TeebMme6K" +
    "i33Vl0a5iwZDpR9IsCF/5DwQGRGxDsJg0q9IJm0cwUVCf2sdlMfxajfp49jO" +
    "xcUugxKdXCOztQRlEvpVQLtoeyCDOUF5nkw72WCNYA1pXFzsSWka5S4aDJV+" +
    "IMGG/JHzQGRExDoIg0m/Ipm0cQQXCf2tdVAex6vdpI9jOxaX8WWQ6OQama0l" +
    "KJPQrwLaRdsDGcwJyvNkNnmuqLK48BGAtbW1wdmzZ0POAfZnlos+jsuXL4ve" +
    "ebOIPBwXF7sMsgf72L+V4GtZWhUX+8y6PHHXrl2iwGMRi5qZnj6O7VRc7NWk" +
    "bN+K2MlGuT54X6CrLC4GKxMVeCxiUTPT08exXYrLVj9bKbN79+6kNng/Qt+q" +
    "uLzzzjuihCxiUTPT08exXYrLdoK1gbWjdXGxU58zw8ulMh98cKaeMyn2EVYZ" +
    "u/xKOKOcAZQZyoBNtMG1QwhkWFsJna9+yJzQb/SbTMAxYgN09nHYm+rbxKFR" +
    "LOAX10dyxEFiF5LqUJsV2s28oY6w30F0il02pjm0gfl96uSp7ouLve5SHEPA" +
    "BToOGDw6OnI2hTJDGbCJNrh2CIEMayuh89UPmRP6jX6TCThGbIDOPo5cXMpY" +
    "2wTqCPsdRKfYZWOaQxuY3ydOnJi9uPDH0V599VV1DAEX6Dhg8OjoyNkUygxl" +
    "wCba4NohBDKsrYTOVz9kTug3+k0m4BixATr7OHJxKWNtE6gj7HcQnWKXjWkO" +
    "bWB+20nGzMVFPo5++WV1DAEX6Dhg8OjoyNkUygxlwCba4NohBDKsrYTOVz9k" +
    "Tug3+k0m4BixATr7OHJxKWNtE6gj7HcQnWKXjWkObWB+20lGuS54r7cMi4vB" +
    "CvX+++/Xs56y/n6Kjl9PWH9fkTkEOgWMp00ju0xPGc6L+qnD8SOwS0BspF9s" +
    "csYEOvs4Ln3xBWIdw/VZX08Rv8VPxsVD9daTzqeNOt5B7GzZ74E5knccT0Qn" +
    "45T6+vLwJKNcE6o+hm5dXOwnHMW4GkPDBcjFpZpcXCasp4jf4ifj4qF660nn" +
    "00Yd7yB2tuz3wBzJO44nopNxSn194YUXkprAmjF1cTl69KgaV2NouAC5uFST" +
    "i8uE9RTxW/xkXDxUbz3pfNqo4x3Ezpb9HpgjecfxRHQyThNfT73zTlIPOi0u" +
    "Bw4cUONqDA0XIBeXanJxmbCeIn6Ln4yLh+qtJ51PG3W8g9jZst8DcyTvOJ6I" +
    "TsZp4uvrhw51V1z4DMFLL72kxtUYGi5ALi7V5OIyYT1F/BY/GRcP1VtPOp82" +
    "6ngHsbNlvwfmSN5xPBGdjNPE1734BNle3s+a0bi4GKxUp0+fLu69eKy/tw6s" +
    "bcJ7w02S4MgQ1sF7Nq8E+qmTiHxPh9DSbpnvEMyh3evWVkLme8BuyuzjsB/4" +
    "KtvEHBGbO4Cxos556GVsp16zGiivmUzsF8oE7C8wPUN4v6Xqa/9TF5fDhw+r" +
    "8k1DuYgwvO0mLeYABgv91ElEvqdDaGm3zHcI5tDu9kllclK7KbOPIxeXCZzT" +
    "FsprJhP7hTIB+wuGek683fzLc1MXl1deeUWVbxrKRYThbTdpMQcwWOinTiLy" +
    "PR1CS7tlvkMwh3a3TyqTk9pNmX0cubhM4Jy2UF4zmdgvlAnYXzDUw1sknRQX" +
    "fpnOXr8gyjcN5SLC8LabtJgDGCz0UycR+Z4OoaXdMt8hmEO72yeVyUntpsw+" +
    "jlxcJnBOWyivmUzsF8oE7C8Y6tm7N/0pkeh+S6PiYrBi2Wvu3n333cHp0ynW" +
    "VuZ0wLunTyecfrcJkBHoZP+7ZiehDPglMjE/snFEOoYyGAvapNiYANGR0sfx" +
    "+cXPRW8CbXbsZiwZK/YTyitk2rwSlCnjRSbGWxtgHomfMift1/kNaGBXHczT" +
    "IleH7W3vtxjS4MHiYvddCkMC57kghIGgUz6QEehkP5OmgDLgl8jE/MjGEekY" +
    "ymAsaJOSJqKL6Ejp48jFZYL4KXPSfp3fgAZ21cE8NY4fP57sf4M1wkMaPCh4" +
    "//79I0MC57kghIGgUz6QEehkP5OmgDLgl8jE/MjGEekYymAsaJOSJqKL6Ejp" +
    "48jFZYL4KXPSfp3fgAZ21cE8Ndo8rFhGGjx432Xnzp0jQwLnuSCEgaBTPpAR" +
    "6GQ/k6aAMuCXyMT8yMYR6RjKYCxok5ImoovoSOnjyMVlgvgpc9J+nd+ABnbV" +
    "wTw1+OuKdQ8rlpGGKli57L0O9na6ek4D9hOObzInMy19HPabPYne08Cxqw9O" +
    "A/b3wUJsmCL+3Pv2hDbrg4c0VEEF9igAjVDaFgqObzInMy19HLm4VLMQG1rG" +
    "v+nPiHhIQxX20VNZgf1NQ5S2hYLjm8zJTEsfRy4u1SzEhpbx50vj5lJc7FSI" +
    "SuJLo7aFguObzMlMSx9HLi7VLMSGFvG3r5zwI2j7Mh1rQxXSUAeLi31b99Sp" +
    "kyVOJZwEp4bGJiRzTw7HKPZC4DKUedLaylCn2OTpINA5bEugDYTjHWgXbaBM" +
    "9rsgnlF/H8dnn13A+iD2jEOj+JXk2RrBL8aO40dzoBN2cTz7Q52FXIwRP+oR" +
    "G50xYieh3eZ7grVNKI89+Pp0nxKNkYY6eIq0c+dOBJALhmDDEQm+A4NBmRpM" +
    "6BSbPB0EOrmgtIFwvAPtog2UyX4XxDPq7+PIxaU0RvyoR2x0xoidhHab7wnW" +
    "NqE89uW19K1zcy0uBpUdOXKkFEAuGIINRyT4DgwGZWowoVNs8nQQ6OSC0gbC" +
    "8Q60izZQJvtdEM+ov48jF5fSGPGjHrHRGSN2EtptvidY24TxuGPHj0lhMRtY" +
    "D+qQhggqtLOZSQC5YAg2HJHgOzAYlKnBhE6xydNBoJMLShsIxzvQLtpAmex3" +
    "QTyj/j6OXFxKY8SPesRGZ4zYSWi3+Z5gbRPG41478JoUF9aCCGmI4NORdsPn" +
    "7bffbsgJwP5p6EDmCcD+1tCmKeyCTfbIexkZ71JvQx/Hp59+4thRbZPLjOtz" +
    "wuIHRCaQ8Y7cFPpl62TrNoH9KmN58D4dZi2IkIYmlJUa9vVgGuczj+B2IJPJ" +
    "xf7W0KYp7IJNubiUYH8AC0UuLvW8+eabctbS9ItzZaShCVRsPzdAA33mEdwO" +
    "ZCKxpL81tGkKu2BTLi4l2B/AQlEUiwAZ78hNoV+rW1zs2UHucdaAJkhDE+z6" +
    "j8rt+SMaqcwjuB3IRGJJf2to0xR2waZcXEqwP4CFoigWATLekZtCv1a3uNin" +
    "wOW93fRZIiINTWFxefWVVwb2pboyx08cTzmecgLI+CEnQCgj6D9x/IRwPKLw" +
    "pQT7qbOB3YR2sl90OrGSMYGMGzduzJ319XXHjmqbfLvrkdjJeumctjpVB3Dm" +
    "xDrSfs3LdDxt8OyQ/kAG+2f9bksZaWgKb/js3LEjF5exzgZ2E9rJftHpxErG" +
    "BDKocxoimWoDoc2e3fWITlkvndNWp+oAzpxYR9qveZmOpw2eHdIfyGD/2t61" +
    "xRcX73EA+yQpFxe12bOb0E72i04nVjImkEGd0xDJVBsIbfbsrkd0ynrpnLY6" +
    "VQdw5sQ60n7Ny3Q8bfDskP5ARrnPu5Fb93OtEdLQBhqye/fuXFxMRwO7Ce1k" +
    "v+h0YiVjAhnUOQ2RTLWB0GbP7npEp6yXzmmrU3UAZ06sI+3XvEzH0wbPDukP" +
    "ZJT71ta6O2sxpKENfImUYa/AzMVF4RhCO9kvOp1YyZhABnVOQyRTbSC02bO7" +
    "HtEp66Vz2upUHcCZE+tI+zUv0/G0wbND+gMZ43bvrGXaG7ljpKEtNMh+lfHY" +
    "sOgYbx07lnCMbIzb5JiHMy+RAdjfBLEj7Y/8eOuY+VoP/bLCXEb7jyWoToUy" +
    "GBsdH8tsS6Qz8tuDMuJ++IVYevGMoA5Cv33fQWF7NeIn53sypB8g/uP2rs9a" +
    "DGloi3f2cuj114tNSse4YLqpPZx5iQzA/iaIHWl/5IcssAP94iJrfylBHL9o" +
    "08guyEFsdHwssy2RzshvD8qI++EXYunFM4I6CP32fQeF7dWIn5zvyZB+gPhb" +
    "25E5nLUY0jANNGx89kLHuGC6qT2ceYkMwP4miB1pf+SHLLAD/eIia3+aJKpT" +
    "oQzGRsfHMtsS6Yz89qCMuB9+IZZePCOog9Bv33dQ2F6N+Mn5ngzpB4i/tfFt" +
    "B12ctRjSMA1mJI2zsxc6xgXTTe3hzEtkAPY3QexI+yM/ZIEd6BcXWfvTJFGd" +
    "CmUwNjo+ltmWSGfktwdlxP3wC7H04hlBHYR++76DwvZqxE/O92RIP0D8jw75" +
    "5z//mezdaZ4j8pCGaWFxsUcCjr51NOXoFGwEYBP2t4XymsgM/TAZJTi+mIMx" +
    "IqMHxKaW/QV9+NGxDvpV6dvq8RZgfxTLvfvSX1Ls6qzFkIZp8U6t3jjyxuwL" +
    "2rYQRFBeE5lhYmIBOb6YgzEiowfEppb9BX340bEO+lXp2+oxS3GxT4jmddZi" +
    "SMMssLjYm6xmXtC2hSCC8prIDBMTC8jxxRyMERk9IDa17C/ow4+OddCvSt9W" +
    "j1mKC3//ucuzFkMaZiE8exHHG9C2EERQXhOZYWJiATm+mIMxIqMHxKaW/QV9" +
    "+NGxDvpV6dvqMW1xmfdZiyENs8LiYt/affPIkRFDh8rYKzLLbI4rceSIjSvx" +
    "5pFaOP9NawtJ7RIZR6ytTNpPP2jTyK5Uhn38l0A/AW0UnWZLSz9og853oB2U" +
    "EeiM5jeRoX4H0IaCVIesF5B+sUkRX2G3yOR49ktcHDtoK3SO5+2dw/daiDTM" +
    "inf28tqrr46cYvAqHE8WnYvG4EULYG0hSATKwAKyn37QppFdTAJAPwFtFJ1m" +
    "S0s/aIPOd6AdlBHojOY3kaF+B9CGglSHrBeQfrFJEV9ht8jkePZLXBw7aCt0" +
    "2pzDhw7JHl2J4mLQ6B07dgyOvPGGBs9xnHDBJHjRAlhbCBKBMrCA7KcftGlk" +
    "F5MA0E9AG0Wn2dLSD9qg8x1oB2UEOqP5TWSo3wG0oSDVIesFpF9sUsRX2C0y" +
    "OZ79EhfHDtoKnTaHbzSYR2ExpKELvO+92GmYBM9xnHDBJHjRAlhbCBKBMrCA" +
    "7KcftGlkF5MA0E9AG0Wn2dLSD9qg8x1oB2UEOqP5TWSo3wG0oSDVIesFpF9s" +
    "UsRX2C0yOZ79EhfHDtoKnXYVwb3ZxbdxPaShK+iA8frrBwdvvHG4xBsNKI9v" +
    "OqdrAhsOH05hv8dhwH5wGLC/C+ahYxqZ7ecE6+PQWkfL9ZoK6KCNh60NiIwa" +
    "7KFi3sQ1uHe7Qhq6hE7Y6VjbJJgmcbonsCEXl0qmkdl+TrA+Dq11tFyvqYAO" +
    "2sjC0ra4eA8n2lUG921XSEOXeDd37Sdg2yTBNInTPYENubhUMo3M9nOC9XFo" +
    "raPlek0FdNBGFpY2xcV+oYN70eCe7RJp6Bo6Yzd3Dx8+NGiaBNMkTvcENuTi" +
    "Usk0MtvPCdbHobWOlus1FdBBG1lY2hSXvm7ilpGGrvFu7tpzR4cOHSqKTIK1" +
    "gUOHDqcMxyUUY8pgPPpFpyNDbQCHzY4S7PeQOfV+HR62JQQ2e4R+cDxj00gG" +
    "/UgRmUVbGfbrGNUJGFuLTxna6MQ7QtejgY2UE9igcQC0gfIq8K4g5nUTt4w0" +
    "zAM6Zrz22mtO8BQGigsiC8rx6Bedjgy1ATCZ2e8hc+r9YhJFNnuEfnA8Y9NI" +
    "Bv1IEZnYlNqvY1QnYGwtPmVooxPvCF2PBjZSTmCDxgHQBspzeP31Q73exC0j" +
    "DfOCzu3atcsJnsJgcUFkQTke/aLTkaE2ACYz+z1kTr1fTKLIZo/QD45nbBrJ" +
    "oB8pIhObUvt1jOoEjK3FpwxtdOIdoevRwEbKCWzQOADaQHkOdpXAvWe/O8b9" +
    "OQ+kYV54p2bmeBo8hcHigsiCcjz6ZcEcGWoDYDKz30Pm1PvFJIps9gj94HjG" +
    "ppEM+pEiMrEptV/HqE7A2Fp8ytBGJ94Ruh4NbKScwAaNA6ANlAf2739F9lzX" +
    "zw/VIQ3zhI4a9umR/SSJcfCgg7WXeP0g2Ji7KSMa7xHJYH/ZPoPjDx5UKCPA" +
    "vhOUAjvog+MHsR+8KsP+RvJkDOyU/hSxgeM9mYLKrbWxCZRBwvG0sYGdQjqf" +
    "OeHBOWNZBw4cWNjl0BhpmCfebx1ZAOxjMguIbFqDwQwWORzvEclgf9k+g+NZ" +
    "WHJx2URs4HhPpqBya21sAmWQcDxtbGCnkM5nTnhwzlgWf5LVsHbuyXkiDfPG" +
    "HKTTdv/F2mXTGgxmsMjheI9IBvvL9hkcz8KSi8smYgPHezIFlVtrYxMog4Tj" +
    "aWMDO4V0PnPCg3NMzp49e2SP9Xk5NEYa+sD7zN0CIpvWYDCDRQ7He0Qy2F+2" +
    "z+B4FpZcXDYRGzjekymo3Fobm0AZJBxPGxvYKaTzmRMenOPd2zS4B/tAGvqC" +
    "zht2AyreuCBZnAbjPSIZ7C/bZ3A8C0suLpuIDRzvyRRUbq2NTaAMEo6njQ3s" +
    "FNL5zAmP8vgDB15b+H2WMtLQF/ZxGINggbHvv9jNqE0OgnKfR9vxQw6CAwds" +
    "oUpApo7vgIOmpwT7lwXGYmhrGRkfglgXcEw7ZrfJoE0E45l3HpzTAeU8tG+/" +
    "c09Z0eLe6wtp6BPvFM7uvyQBbLtAbccf8IoFEgkydXwH5OJSgmPaMbtNBm0i" +
    "GM+88+CcDhjn4J7du2UvLeI+Sxlp6BsGxLBXY24GsO0CtR1/wCsWSCTI1PEd" +
    "kItLCY5px+w2GbSJYDzzzoNzOsDyb5/zom2De61vpGERMCiGndUUAWy7QG3H" +
    "H/CKBRIJMnV8B+TiUoJj2jG7TQZtIhjPvPPgnA6wlz8t032WMtKwCKruv+zf" +
    "t3/w6jB4Ka+lvJZiwU6xtgkcX0CZQmoDZb722qsJIt+BMqQfMnW86UnhGCI6" +
    "ECvx27MbiA0gnq/EY+h34IcHdZbiVEAbghwQ+Z4MAWsoOgh0vvLq0t1nKSMN" +
    "i8K7/2IFxr7Bm4uL6pTEdMYQ0YFYid+e3UBsAPF8JR5DvwM/PKizFKcC2hDk" +
    "gMj3ZAhYQ9FBSvoqCsui77OUkYZF4n3/xQKYFhgsoiRJ9YJ4G6yAMgUueioz" +
    "2lAelCH9kKnjkZjOGCI6ECvx27MbiA0gnq/EY+h34IcHdZbiVEAbghwQ+Z4M" +
    "AWsoOshEn33wwb1icE8tEmlYNAyWFhgsoiRJ9YJ4G6yAMgUueioz2lAelCH9" +
    "kKnjkZjOGCI6ECvx27MbiA0gnq/EY+h34IcHdZbiVEAbghwQ+Z4MAWsoOshI" +
    "10svviR7ZNkKiyENywCDZliltgIzD/YD9kfMOr8rGW3ZLjpd9gP2LyNDO1/c" +
    "pWf3hj23x320aKRhWWDwDLtskoB3wKwJP+v8rmS0ZbvodFnB4rJntz4ztKyF" +
    "xZCGZcF7gnpeBWbWhJ91flcy2rJddLqsWHHxHkY0+nrx0zRIwzJRVWAs0Az+" +
    "LMya8LPO70pGW7aLTpcVKi7e2+SMZfnIuQppWDa8F3wb9i3effv2D/bv35dg" +
    "H2mX2Q/Y3wmmtwz795nu/QnxnP0p+1MobyST1OvQ2ECn2KRE8Y+gDyPUtjZr" +
    "KPJgY0Eok/Hfl0B5On8aVKf91tA//vEPyf9lLyyGNCwjFkgGd1xgokWOk6gD" +
    "kHjSv890sxBEc5hoKZQ3kknqdWhsoFNsUqL4R9CHEWpbmzUUebCxIJTJ+O9L" +
    "oDydPw2pzqrCskzfZalDGpaVpgWGCxYnUQcg8aR/n+lmIYjmMLlTKG8kk9Tr" +
    "0NhAp9ikzLrJ6MMIta3NGoo82LgKxcXyepULiyENy4z3JTvDPqauWuQ4iToA" +
    "iSf9+0w3C0E0h8mdQnkjmaReh8YGOsUmZdZNRh9GqG1t1lDkwcZlLy5WWJjj" +
    "q1ZYDGlYdioLzM5dg71re4esJazt3ZswGgP2rtVCGWtF24S9JrcM5a95c0gq" +
    "gzqj8T6cAxArnd+EVOaa+Vpmb4P4E9FB6Av72yN2dgBj0STeVfm9aoXFkIZV" +
    "oOoSaeeOnbKAkjRM5CKZmawplKGFAklC+ZZcMoekMqgzGu/DOaBBssekMrmh" +
    "xA8nNoLoIPSF/e0ROzuAsYjiXfWV/lUsLIY0rApVBeaFF15IFlCSholcJDOT" +
    "NYUytFAgsSjfkkvmkFQGdUbjfTgHBMnejFQmN5T44cRGEB2EvrC/PWJnBzAW" +
    "dfGuKix2ucTcXxWkYZWo+pi6XGAkaZjIRTIzWbFhIEMLBRKL8i25ZA5JZVBn" +
    "NN6Hc0BNsjcnlckNJX44sRFEB6Ev7G+P2NkBjEVVvL2nm41V+Li5DmlYNaq+" +
    "aGd32u3r0vYFpIg1wP6XX14D6F8D7J8DtNm3G9BOwvHi91o4Z20thf3dQLvY" +
    "356ZY8n+gno7TY/9I2TuboXCYkjDKlJXYOzOOxeVxIlVnyTNEq1baLNvN6Cd" +
    "hOPF77VwTi4uZarttLysKizL+qxQW6RhleEijbHrWV34CXFiVSdJQaNE6xba" +
    "7NsNaCfhePF7LZyTi0sZ3067Qet9h2UrFRZDGlYdLtYY+y+hiz8iTiw/STZp" +
    "lGjdQpt9uwHtJBwvfq+Fc3JxKaN2ej+zOoa5vOpIw1ag6rsCVZdJcWJpkiQ0" +
    "SrRuoc2+3YB2Eo4Xv9fCObm4lJnYuHv3nsrLoK1YWAxp2CrYR3hcwDH232P3" +
    "nt2b7AG79+wBk7H+eML5e4rflSljyVaHPfmdYG1lPDtEjrVN4HiVGej0wBzq" +
    "FBirxN6x77QVehBLHU8cO2EHZdLuyG/pL/lhl+VVl0Gr+h2WJkjDVsL7VYEx" +
    "9l+kulhY8pVBIsp4wvmWbExe3VTpBguS17ND5GCDcI7IDHR6YA51CoxVYu/Y" +
    "d9oKPYiljieOnbCDMml35Lf0b/hR9TGzsRU+EapDGrYiXNQx9t/kxZdelGRk" +
    "YZBElPGE8y3ZmLy6qdINFiSvZ4fIwQbhHJEZ6PTAHOoUGKvE3rHvtBV6EEsd" +
    "Txw7YQdl0u7Ib/a/9NJL7u8JjWGObkWkYasSXSaVk5GFQRIRsF/n64bghiJR" +
    "8tKGwg6Rgw3COSIz0OmBOdQpMFaJvWPfaSv0IJY6njh2wg7KpN2R3+W+7XoZ" +
    "RKRhKxNdJtnC23+c5cRsK8P+zEJ58aUif+pu2m71yyAiDduBqk+TDLtGlsRZ" +
    "CnJxWWYsb6rOVgzm4HZAGrYLVQ8+GnatbKe2TKDFkovLMmJ5UndvZTtdBhFp" +
    "2E5UPTYwZrkulXJxWTbqPgky7MFa5tx2Qhq2I3U3e8dFxv5DjXmRDAtQmV0v" +
    "7lJK831eBGm/6JDxOifqpx/s31X4kvLii2bLBPEzGh/YUNhBmbSLMgIduyQO" +
    "ZluqQ2SI75Ox0SXQdj5bKSMN2xkmSRlLJkuqIpnJxobPxUXnyPjAhmUuLjt3" +
    "7ay9BDK20rNBsyIN252qd8SMseTiZpCNj8RtskE2k76qEFCHjNc5UT/9YL9u" +
    "MKdYCMH4wIZlLS4v7Kj+FMjYbp8ENUEaMiOaXCrl4mJjSDA+sGHZioutc74E" +
    "mg5pyKQwmYidydjlkn0RbxP7G+zYsTPB3vdbx46dKZSX6KvExpVhf4Bjl4wJ" +
    "UL+b+DGj3R0QXf4Y+RKoHmnIKNGlkhQZbqBcXFamuDQpKqv8Xts+kYZMNdGl" +
    "0maRGZ5KcxPpJqsnF5cZ7G6J/VNoUlTyJVA7pCETM02R0U1WTy4uM9jdkFxU" +
    "5os0ZJrTpMjYzcDRJdMLCXajMMHayrC/A3a8sCPhhR3A2hJiGVZAy3B8BOc3" +
    "koFYMbYqL/Xrn/+sv0k7Jl/+zIY0ZNrT5J6M8c9//mOY3KNCE20Y6e8AFobt" +
    "VFysoDQ5SzFyUekGachMT9MiMz6bqdswsqE6gIVhOxQXi3OTsxQjF5VukYbM" +
    "7DQtMsZmocnFpbmMoLi80KKgGNv9GaB5IQ2Z7rDvQdjNQCZzFUWh2eAftkHK" +
    "/CPFChKRMUD6KYPjaUOB2TaBcyjTfKoF8gqZJNIxpkVBMfL3VOaLNGTmQ92L" +
    "qjwmm2+8cYLC4I0B0k8ZHF/euJugEFCP2OQUlI6Ky1gGY1dHPkvpD2nIzJ+6" +
    "d8lUMdmQFYWh2GwoHkD6KYPji2JCUAioR2xyCsqUxWWaYmLkeymLQRoy/dLk" +
    "42yP8UbbysVl2mJi2OVovuxZLNKQWQxt7894pBvXKRaAhUDGS2GZU3FBG/1q" +
    "w6lTp3JBWRKkIbMctPnEaTuT76EsL9KQWU5ysRmR35uyOkhDZjWY5qbwKpKL" +
    "yeoiDZnVxc5upr1BvGjsflO+xNlaSENm62E3i5flssrsyDddtwfSkMlYASjD" +
    "SzA7O+IYyshkpCGTyWS6QBoymUymC6Qhk8lkukAaMplMpgv+PxEoEFbef8ra" +
    "AAAAAElFTkSuQmCC")

# Original file: KC.py

"""
This module defines the constants for the Karel package.
"""

class KC:

    NORTH = 0
    EAST = 1
    SOUTH = 2
    WEST = 3

    DIRECTIONS = [ "NORTH", "EAST", "SOUTH", "WEST" ]

    INFINITE = math.inf
    PLUS1 = -1
    MINUS1 = -2
    BLANKB = -3

    SIMPLE = 0
    FANCY = 1

    CWINDOW_WIDTH = 650
    GWINDOW_WIDTH = 550
    GWINDOW_HEIGHT = 675

    WORLD_X = 10
    WORLD_Y = 10
    WORLD_WIDTH = 500
    WORLD_HEIGHT = 500

    ERROR_DIALOG_WIDTH = 500
    ERROR_DIALOG_HEIGHT = 150
    ERROR_DIALOG_COLOR = "#FFFFCC"
    ERROR_MESSAGE_FONT = "18px 'Helvetica Neue','Sans-Serif'"
    ERROR_MESSAGE_DX = 6
    ERROR_MESSAGE_DY = 6
    ERROR_BUG_SF = 0.25
    ERROR_BUG_X_FRACTION = 0.05
    ERROR_BUTTON_SF = 0.45
    ERROR_BUTTON_Y_FRACTION = 0.7

    FRAME_VIEW_X = WORLD_X + WORLD_WIDTH + 20
    FRAME_VIEW_Y = WORLD_Y
    FRAME_VIEW_WIDTH = 650
    FRAME_VIEW_HEIGHT = 650
    FRAME_WIDTH = 600
    FRAME_HEIGHT = 400

    CONTROL_X = 32
    CONTROL_Y = WORLD_Y + WORLD_HEIGHT + 10
    CONTROL_SEP = 61

    SCREEN_WIDTH_MARGIN = 20
    SCREEN_HEIGHT_MARGIN = 60
    WORLD_EDITOR_X = WORLD_X
    WORLD_EDITOR_Y = CONTROL_Y
    WORLD_EDITOR_WIDTH = WORLD_WIDTH
    WORLD_EDITOR_HEIGHT = 80
    LEFT_MARGIN = 10
    RIGHT_MARGIN = 10
    TOP_MARGIN = 10
    BOTTOM_MARGIN = 10
    COMPONENT_SEP = 10

    LEFT_NUMBER_MARGIN = 16
    BOTTOM_NUMBER_MARGIN = 15
    DOUBLE_WALL_THRESHOLD = 24
    CROSS_THRESHOLD = 11
    NUMBER_THRESHOLD = 15
    NUMBER_FONT = "10px 'Times New Roman','Serif'"
    RESIZE_BG_DX = -2
    RESIZE_BG_DY = -10
    RESIZE_BG_DW = 4
    RESIZE_BG_HEIGHT = 12
    RESIZE_DY = 3
    RESIZE_BG = "#FFCCFF"
    RESIZE_FONT = "12px 'Times New Roman','Serif'"

    TICK_FRACTION = 0.20
    WALL_FRACTION = 0.30
    WALL_TOLERANCE = 0.15

    MAX_WIDTH = 50
    MAX_HEIGHT = 50

    TOKEN_TRACE = False
    MAX_TRACE_SPEED = 80

    BEEPER_FILL_COLOR = "#CCCCCC"
    APPLICATION_BACKGROUND = "#CCFFFF"
    MARKED_COLOR = "#666666"
    INFINITY_SYMBOL = "\u221E"
    MULTIPLY = "\u2A09"
    BEEPER_FONT_FAMILY = "'Times New Roman','Serif'"
    BEEPER_BORDER = 1
    MIN_FANCY = 20
    MIN_BEEPER = 4
    MIN_LABEL = 15
    KAREL_FRACTION = 0.50
    KAREL_LABEL_DELTA = 0.15
    BEEPER_FRACTION = 0.70
    SIMPLE_FRACTION = 0.70
    BEEPER_LABEL_FRACTION = 0.5
    BEEPER_LABEL_DX_FRACTION = 0.05
    BEEPER_LABEL_DY_FRACTION = 0.35
    BEEPER_LABEL_MAX_SIZE = 20
    BEEPER_LABEL_MIN_SIZE = 6

    KAREL_INSET = 7
    BODY_OFFSET_X = -0.20
    BODY_OFFSET_Y = -0.33
    BODY_WIDTH = 0.60
    BODY_HEIGHT = 0.80
    UPPER_NOTCH = 0.15
    LOWER_NOTCH = 0.10
    SCREEN_OFFSET_X = -0.07
    SCREEN_OFFSET_Y = -0.05
    SCREEN_WIDTH = 0.30
    SCREEN_HEIGHT = 0.40
    SLOT_WIDTH = 0.15
    FOOT_WIDTH = 0.08
    FOOT_LENGTH = 0.20
    UPPER_ANKLE = 0.08
    LOWER_ANKLE = 0.08

    SELECTED_BORDER_COLOR = "Blue"
    SELECTED_BORDER_WIDTH = 2
    WALL_TOOL_SIZE = 32
    KAREL_TOOL_SIZE = 32
    BEEPER_TOOL_SIZE = 32
    EXIT_TOOL_SIZE = 32
    TOOL_SEP = 6
    TOOL_Y_DELTA = 8
    TOOL_MARGIN = 20
    TOOL_X = 8
    TOOL_Y = 3
    LABEL_SEP = 5
    WALL_TOOL_LENGTH = 16
    WALL_LINEWIDTH = 4
    DISK_SIZE_FRACTION = 0.7
    DISK_CORNER_FRACTION = 0.15
    DISK_MASK_X_FRACTION = -0.02
    DISK_MASK_Y_FRACTION = -0.08
    DISK_MASK_WIDTH_FRACTION = 0.35
    DISK_MASK_HEIGHT_FRACTION = 0.2
    CROSS_SIZE = 10
    WALL_CROSS_SIZE = 12
    CROSS_LINEWIDTH = 1.5
    EXIT_CHECK_FRACTION = 0.65
    CHECK_LINEWIDTH = 3
    ARC_DX = -0.05 * KAREL_TOOL_SIZE
    ARC_DY = 0.13 * KAREL_TOOL_SIZE
    ARC_RADIUS = 0.28 * KAREL_TOOL_SIZE
    ARC_ARROW_SIZE = 0.18 * KAREL_TOOL_SIZE
    RESIZE_TOOL_SIZE = 46
    RESIZE_DY = 4

    COLORS = [
        None,
        "Black",
        "DarkGray",
        "Gray",
        "LightGray",
        "White",
        "Red",
        "Pink",
        "Orange",
        "Yellow",
        "Green",
        "Cyan",
        "Blue",
        "Magenta"
    ]

# Original file: KarelCodeWindow.py

"""
This file creates a continuous code viewer for Karel.
"""

class KarelCodeWindow(CodeWindow):

    """
    This class extends the Karel application window to implement the
    tracing features.
    """

    def __init__(self, gw, width):
        """Creates a new KarelCodeWindow object."""
        CodeWindow.__init__(self, gw, width)
        for keyword in KarelCodeWindow.KAREL_KEYWORDS:
            self.add_keyword(keyword)

# Constants

    KAREL_KEYWORDS = { "def", "if", "else", "while", "for", "in", "range" }

# Original file: KarelWorld.py

"""
This file defines all the classes in the Karel system outside of the
graphics library.
"""

# Functions: Directions

def left_from(dir):
    return (dir + 3) % 4

def right_from(dir):
    return (dir + 1) % 4

def opposite(dir):
    return (dir + 2) % 4

def adjacent_point(pt, dir):
    x,y = pt
    if dir == KC.NORTH:
        return (x, y + 1)
    elif dir == KC.EAST:
        return (x + 1, y)
    elif dir == KC.SOUTH:
        return (x, y - 1)
    elif dir == KC.WEST:
        return (x - 1, y)
    else:
        raise KarelException("Illegal direction")

# Class: KarelWorld

class KarelWorld(GCompound):

    def __init__(self, width, height):
        GCompound.__init__(self)
        self._world_width = width
        self._world_height = height
        self.resize(10, 10)
        self._kpoly = None
        self._klabel = None
        self.init_karel()
        self._number_squares_flag = True
        self._display_one_flag = False
        self._monitor = None
        self.set_speed(0.50)

    def move(self):
        """
        Moves Karel forward one square. If Karel is blocked by a wall,
        executing this method raises a KarelException.
        """
        if self.check_wall(self._kx, self._ky, self._dir):
            raise KarelException("Karel is blocked")
        x,y = adjacent_point((self._kx, self._ky), self._dir)
        self.set_karel_location(x, y)
        self._kpoly.rotate(0)

    def turn_left(self):
        """Turns Karel left 90 degrees."""
        self.set_karel_direction(left_from(self._dir))
        self.trace()

    def turn_right(self):
        """Turns Karel right 90 degrees."""
        self.set_karel_direction(right_from(self._dir))
        self.trace()

    def turn_around(self):
        """Turns Karel around 180 degrees."""
        self.set_karel_direction(opposite(self._dir))
        self.trace()

    def pick_beeper(self):
        """
        Picks up a beeper from the current square and places it in
        Karel's beeper bag. If there are no beepers on the current
        square, this method raises a KarelException.
        """
        nb = self.get_beepers_on_corner(self._kx, self._ky)
        if nb < 1:
            raise KarelException("No beepers on this corner")
        cb = KarelWorld.adjust_beepers(nb, -1)
        self.set_beepers_on_corner(self._kx, self._ky, cb)
        nb = KarelWorld.adjust_beepers(self.get_beepers_in_bag(), +1)
        self.set_beepers_in_bag(nb)
        self.trace()

    def put_beeper(self):
        """
        Takes a beeper from Karel's beeper bag and puts it on the current
        square. If there are no beepers in the beeper bag, this method
        raises a KarelException.
        """
        nb = self.get_beepers_in_bag()
        if nb < 1:
            raise KarelException("No beepers in bag")
        cb = self.get_beepers_on_corner(self._kx, self._ky)
        cb = KarelWorld.adjust_beepers(cb, +1)
        self.set_beepers_on_corner(self._kx, self._ky, cb)
        self.set_beepers_in_bag(KarelWorld.adjust_beepers(nb, -1))
        self.trace()

    def front_is_clear(self):
        """Returns True if Karel is not facing a wall."""
        return not self.check_wall(self._kx, self._ky, self._dir)

    def front_is_blocked(self):
        """Returns True if Karel is facing a wall."""
        return self.check_wall(self._kx, self._ky, self._dir)

    def left_is_clear(self):
        """Returns True if Karel has an opening to its left."""
        return not self.check_wall(self._kx, self._ky,
                                          left_from(self._dir))

    def left_is_blocked(self):
        """Returns True if Karel has a wall to its left."""
        return self.check_wall(self._kx, self._ky,
                                      left_from(self._dir))

    def right_is_clear(self):
        """Returns True if Karel has an opening to its right."""
        return not self.check_wall(self._kx, self._ky,
                                          right_from(self._dir))

    def right_is_blocked(self):
        """Returns True if Karel has a wall to its right."""
        return self.check_wall(self._kx, self._ky,
                                      right_from(self._dir))

    def beepers_present(self):
        """Returns True if there are any beepers on the square."""
        return self.get_beepers_on_corner(self._kx, self._ky) > 0

    def no_beepers_present(self):
        """Returns True if there are no beepers on the square."""
        return self.get_beepers_on_corner(self._kx, self._ky) == 0

    def beepers_in_bag(self):
        """Returns True if there are any beepers in Karel's bag."""
        return self.get_beepers_in_bag() > 0

    def no_beepers_in_bag(self):
        """Returns True if there are no beepers in Karel's bag."""
        return self.get_beepers_in_bag() == 0

    def facing_north(self):
        """Returns True if Karel is facing north."""
        return self._dir == KC.NORTH

    def not_facing_north(self):
        """Returns True if Karel is not facing north."""
        return self._dir != KC.NORTH

    def facing_east(self):
        """Returns True if Karel is facing east."""
        return self._dir == KC.EAST

    def not_facing_east(self):
        """Returns True if Karel is not facing east."""
        return self._dir != KC.EAST

    def facing_south(self):
        """Returns True if Karel is facing south."""
        return self._dir == KC.SOUTH

    def not_facing_south(self):
        """Returns True if Karel is not facing south."""
        return self._dir != KC.SOUTH

    def facing_west(self):
        """Returns True if Karel is facing west."""
        return self._dir == KC.WEST

    def not_facing_west(self):
        """Returns True if Karel is not facing west."""
        return self._dir != KC.WEST

    def update(self):
        self._get_window().repaint()

    def trace(self):
        pass
        # // Fill in

    def get_current_corner(self):
        """Returns a tuple of the current (x,y) location."""
        return (self._kx, self._ky)

    def resize(self, cols, rows):
        self.remove_all()
        self._cols = cols
        self._rows = rows
        self._map = [ [ KarelWorld._Corner() for y in range(rows + 2) ]
                      for x in range(cols + 2) ]
        self._kx = 1
        self._ky = 1
        self._dir = KC.EAST
        for x in range(0, cols + 2):
            for y in range(0, rows + 2):
                self._map[x][y].wall_west = None
                self._map[x][y].wall_south = None
                self._map[x][y].color = "None"
                self._map[x][y].beepers = 0
                self._map[x][y].bpoly = None
                self._map[x][y].blabel = None
                self._map[x][y].cross = None
                self._map[x][y].bg = None

    def init_display(self):
        if self._number_squares_flag:
            width = self._world_width - KC.LEFT_NUMBER_MARGIN
            height = self._world_height - KC.BOTTOM_NUMBER_MARGIN - 2
            self._x0 = self._x + KC.LEFT_NUMBER_MARGIN
        else:
            width = self._world_width - 2
            height = self._world_height - 2
            self._x0 = 2
        fixed = GCompound()
        border = GCompound()
        self._y0 = self._y + 2
        self._sqsize = int(min(width / self._cols, height / self._rows))
        self._width = self._cols * self._sqsize
        self._height = self._rows * self._sqsize
        bsize = self._sqsize * KC.BEEPER_FRACTION
        labelsize = int(bsize * KC.BEEPER_LABEL_FRACTION + 0.5)
        labelsize = min(KC.BEEPER_LABEL_MAX_SIZE, labelsize)
        labelsize = max(KC.BEEPER_LABEL_MIN_SIZE, labelsize)
        self._labelsize = labelsize
        for x in range(1, self._cols + 1):
            self.set_wall_in_compound(border, x, 1, KC.SOUTH)
            self.set_wall_in_compound(border, x, self._rows, KC.NORTH)
        for y in range(1, self._rows + 1):
            self.set_wall_in_compound(border, 1, y, KC.WEST)
            self.set_wall_in_compound(border, self._cols, y, KC.EAST)
        for x in range(1, self._cols + 1):
            for y in range(1, self._rows + 1):
                cx = self._x0 + (x - 0.5) * self._sqsize
                cy = self._y0 + (self._rows - y + 0.5) * self._sqsize
                cross = GCompound()
                line = GLine(-KC.CROSS_SIZE / 2, 0, KC.CROSS_SIZE / 2, 0)
                line.setLineWidth(KC.CROSS_LINEWIDTH)
                cross.add(line)
                line = GLine(0, -KC.CROSS_SIZE / 2, 0, KC.CROSS_SIZE / 2)
                line.setLineWidth(KC.CROSS_LINEWIDTH)
                cross.add(line)
                fixed.add(cross, cx, cy)
        self.add(fixed)
        for x in range(1, self._cols + 1):
            for y in range(1, self._rows + 1):
                cx = self._x0 + (x - 0.5) * self._sqsize
                cy = self._y0 + (self._rows - y + 0.5) * self._sqsize
                bg = GRect(self._sqsize, self._sqsize)
                bg.set_visible(False)
                bg.set_filled(True)
                self.add(bg, cx - self._sqsize / 2, cy - self._sqsize / 2)
                self._map[x][y].bg = bg
        ksize = self._sqsize * KC.KAREL_FRACTION
        kpoly = KarelWorld.create_karel_polygon(ksize)
        self._kpoly = kpoly
        self.add(kpoly)
        klabel = GLabel("")
        self._klabel = klabel
        klabel.set_font(str(labelsize) + "px " + KC.BEEPER_FONT_FAMILY)
        self.add(klabel)
        self.set_karel_location(self._kx, self._ky)
        self.set_karel_direction(self._dir)
        self.update_karel_label()
        self.add(border)

    def reset(self):
        pass

    def get_cols(self):
        return self._cols

    def get_rows(self):
        return self._rows

    def out_of_bounds(self, x, y):
        return x < 1 or x > self._width or y < 1 or y > self._height

    def get_beepers_in_bag(self):
        return self._beepers

    def set_beepers_in_bag(self, n):
        self._beepers = n
        self.update_karel_label()

    def get_beepers_on_corner(self, x, y):
        return self._map[x][y].beepers

    def set_beepers_on_corner(self, x, y, n):
        self._map[x][y].beepers = n
        bpoly = self._map[x][y].bpoly
        blabel = self._map[x][y].blabel
        bsize = self._sqsize * KC.BEEPER_FRACTION
        if bpoly is None:
            bpoly = KarelWorld.create_beeper_polygon(bsize)
            bx = self._x0 + (x - 0.5) * self._sqsize
            by = self._y0 + (self._rows - y + 0.5) * self._sqsize
            self.add(bpoly, bx, by)
            self._map[x][y].bpoly = bpoly
            blabel = GLabel("")
            self._map[x][y].blabel = blabel
            labelsize = self._labelsize
            blabel.set_font(str(labelsize) + "px " + KC.BEEPER_FONT_FAMILY)
            self.add(blabel)
            if self._kpoly is not None:
                self._kpoly.send_to_front()
                self._klabel.send_to_front()
        bpoly.set_visible(n > 0)
        if n <= 1:
            KarelWorld.set_beeper_label(bpoly, blabel, self._labelsize, "")
        else:
            KarelWorld.set_beeper_label(bpoly, blabel, self._labelsize, n)

    def set_beepers(self, n, delta):
        if delta == KC.INFINITE:
            return KC.INFINITE
        elif delta == KC.PLUS1:
            if n == KC.INFINITE:
                return KC.INFINITE
            return n + 1
        elif delta == KC.MINUS1:
            if n == KC.INFINITE:
                return KC.INFINITE
            return n - 1
        return delta

    def paint_corner(self, color=None):
        if color is None:
            color = self._color
        self.set_corner_color(self._kx, self._ky, color)

    def get_corner_color(self, x=None, y=None):
        if x is None:
            return self._map[self._kx, self._ky].color
        return self._map[x][y].color

    def set_corner_color(self, x, y, color):
        sq = self._map[x][y]
        sq.color = color
        if color.lower() == "none":
            sq.bg.set_visible(False)
        else:
            sq.bg.set_color(color)
            sq.bg.set_visible(True)

    def get_paint_color(self):
        return self._color

    def set_paint_color(self, color):
        self._color = color

    def check_wall(self, x, y, dir):
        if dir == KC.SOUTH:
            return self._map[x][y].wall_south is not None
        elif dir == KC.WEST:
            return self._map[x][y].wall_west is not None
        elif dir == KC.NORTH:
            return self._map[x][y + 1].wall_south is not None
        elif dir == KC.EAST:
            return self._map[x + 1][y].wall_west is not None
        raise KarelException("Internal error: Illegal direction")

    def set_wall(self, x, y, dir):
        self.set_wall_in_compound(self, x, y, dir)

    def set_wall_in_compound(self, compound, x, y, dir):
        sqsize = self._sqsize
        wx = self._x0 + (x - 1) * sqsize
        wy = self._y0 + (self._rows - y) * sqsize
        if dir == KC.SOUTH:
            if self._map[x][y].wall_south is not None:
                return
            wall = GLine(wx, wy + sqsize, wx + sqsize, wy + sqsize)
            self._map[x][y].wall_south = wall
        elif dir == KC.WEST:
            if self._map[x][y].wall_west is not None:
                return
            wall = GLine(wx, wy, wx, wy + sqsize)
            self._map[x][y].wall_west = wall
        elif dir == KC.NORTH:
            if self._map[x][y + 1].wall_south is not None:
                return
            wall = GLine(wx, wy, wx + sqsize, wy)
            self._map[x][y + 1].wall_south = wall
        elif dir == KC.EAST:
            if self._map[x + 1][y].wall_west is not None:
                return
            wall = GLine(wx + sqsize, wy, wx + sqsize, wy + sqsize)
            self._map[x + 1][y].wall_west = wall
        else:
            raise KarelException("Internal error: Illegal direction")
        wall.set_line_width(2)   # // Adjust for size
        compound.add(wall)

    def clear_wall(self, x, y, dir):
        if dir == KC.SOUTH:
            if self._map[x][y].wall_south is not None:
                self.remove(self._map[x][y].wall_south)
                self._map[x][y].wall_south = None
        elif dir == KC.WEST:
            if self._map[x][y].wall_west is not None:
                self.remove(self._map[x][y].wall_west)
            self._map[x][y].wall_west = None
        elif dir == KC.NORTH:
            if self._map[x][y + 1].wall_south is not None:
                self.remove(self._map[x][y + 1].wall_south)
                self._map[x][y + 1].wall_south = None
        elif dir == KC.EAST:
            if self._map[x + 1][y].wall_west is not None:
                self.remove(self._map[x + 1][y].wall_west)
                self._map[x + 1][y].wall_west = None
        else:
            raise KarelException("Internal error: Illegal direction")

    def init_karel(self):
        self._kx = 1
        self._ky = 1
        self._dir = KC.EAST
        self._beepers = 0

    def set_karel_location(self, x, y):
        kx = self._x0 + (x - 0.5) * self._sqsize
        ky = self._y0 + (self._rows - y + 0.5) * self._sqsize
        self._kpoly.set_location(kx, ky)
        self._kx = x
        self._ky = y
        self.update_karel_label()
        # A hack until I figure out what is wrong with repainting
        dummy = GRect(0, 0)
        self.add(dummy)
        self.remove(dummy)

    def set_karel_direction(self, dir):
        rotation = (dir + 4 - self._dir) % 4
        if rotation != 0:
            self._kpoly.rotate(-90 * rotation)
        self._dir = dir
        self.update_karel_label()

    def get_text(self):
        result = ""
        result += "Dimension: ({}, {})\n".format(self._cols, self._rows)
        for x in range(1, self._cols + 1):
            for y in range(1, self._rows + 1):
                if self.check_wall(x, y, KC.WEST):
                    result += "Wall: ({}, {}) WEST\n".format(x, y)
                if self.check_wall(x, y, KC.SOUTH):
                    result += "Wall: ({}, {}) SOUTH\n".format(x, y)
        for x in range(1, self._cols + 1):
            for y in range(1, self._rows + 1):
                beepers = self.get_beepers_on_corner(x, y)
                if beepers != 0:
                    if beepers == KC.INFINITE:
                        s = "INFINITE"
                    else:
                        s = str(beepers)
                    result += "Beeper: ({}, {}) {}\n".format(x, y, s)
        kx = self._kx
        ky = self._ky
        dir = KC.DIRECTIONS[self._dir]
        result += "Karel: ({}, {}) {}\n".format(kx, ky, dir)
        beepers = self.get_beepers_in_bag()
        if beepers == KC.INFINITE:
            s = "INFINITE"
        else:
            s = str(beepers)
        result += "BeeperBag: " + s + "\n"
        s = (str(self.get_speed()) + "00")[0:4]
        result += "Speed: " + s + "\n"
        return result

    def load(self, filename):
        self.remove_all()
        with open(filename) as f:
            finished = False
            lines = f.read().splitlines()
            first = True
            for line in lines:
                line = line.strip().lower()
                if line != "":
                    self.load_line(line, first)
                    first = False
        self.trace()

    def load_line(self, line, first):

        def scan_point(args):
            finish = args.find(")")
            if not args.startswith("(") or finish == -1:
                raise KarelException("Missing parentheses")
            args = args[1:finish].split(",")
            return (int(args[0].strip()), int(args[1].strip()))

        def scan_direction(args):
            dir = args[args.find(")") + 1:].strip()
            if dir == "" or dir == "east":
                return KC.EAST
            elif dir == "west":
                return KC.WEST
            elif dir == "north":
                return KC.NORTH
            elif dir == "south":
                return KC.SOUTH
            else:
                raise KarelException("Illegal direction")

        def scan_beeper_count(args):
            if args == "inf" or args == "infinity" or args == "infinite":
                return KC.INFINITE
            else:
                return int(args)

        def dimension_cmd(args):
            ncols,nrows = scan_point(args)
            self.resize(ncols, nrows)

        def karel_cmd(args):
            x,y = scan_point(args)
            self.set_karel_location(x, y)
            self.set_karel_direction(scan_direction(args))

        def wall_cmd(args):
            x,y = scan_point(args)
            dir = scan_direction(args)
            self.set_wall(x, y, dir)

        def setcolor_cmd(args):
            pass

        def speed_cmd(args):
            self.set_speed(float(args.strip()))

        def beeper_cmd(args):
            x,y = scan_point(args)
            n = scan_beeper_count(args[args.find(")") + 1:].strip())
            self.set_beepers_on_corner(x, y, n)

        def beeperbag_cmd(args):
            n = scan_beeper_count(args[args.find(")") + 1:].strip())
            self.set_beepers_in_bag(n)

        colon = line.find(":")
        if colon == -1:
            raise KarelException("Illegal command: " + line)
        cmd = line[:colon].strip()
        args = line[colon + 1:].strip()
        if cmd == "dimension":
            if first:
                dimension_cmd(args)
                self.init_display()
            else:
                raise KarelException("Dimension must be first")
        else:
            if first:
                self.init_display()
            elif cmd == "karel":
                karel_cmd(args)
            elif cmd == "wall":
                wall_cmd(args)
            elif cmd == "color":
                setcolor_cmd(args)
            elif cmd == "speed":
                speed_cmd(args)
            elif cmd == "beeper":
                beeper_cmd(args)
            elif cmd == "beeperbag":
                beeperbag_cmd(args)
            else:
                raise KarelException("Illegal command: " + line)

    def set_speed(self, speed):
        self._speed = speed

    def get_speed(self):
        return self._speed

    def set_monitor(self, monitor):
        self._monitor = monitor
        self.update_karel_label()

    def get_monitor(self):
        return self._monitor

    def update_karel_label(self):
        if self._monitor is None:
            self.set_karel_label("")
        else:
            self.set_karel_label(self.get_beepers_in_bag())

    def mousedown_action(self, e):
        x = e.get_x() - self._x0
        y = e.get_y() - self._y0
        if self._monitor is not None:
            pt = self.get_click_corner(x, y)
            if pt is None:
                self.check_for_wall_click(x, y)
            else:
                if pt.get_x() == self._kx and pt.get_y() == self._ky:
                    self._monitor.set_dragging_karel(True)
                    self._monitor.set_dragging_started(False)
                self._monitor.corner_action(pt.get_x(), pt.get_y())

    def mouseup_action(self, e):
        if self._monitor is not None:
            self._monitor.set_dragging_karel(False)

    def drag_action(self, e):
        x = e.get_x() - self._x0
        y = e.get_y() - self._y0
        if self._monitor is not None:
            self._monitor.set_dragging_started(True)
            pt = self.get_click_corner(x, y)
            if pt is None:
                self.check_for_wall_click(x, y)
            else:
                self._monitor.corner_action(pt.get_x(), pt.get_y())

    def get_click_corner(self, x, y):
        x -= self.get_x()
        y -= self.get_y()
        sx = (x + self._sqsize / 2) / self._sqsize
        sy = self._rows - (y + self._sqsize / 2) / self._sqsize + 1
        tx = round(sx)
        ty = round(sy)
        if tx < 1 or tx > self._cols or ty < 1 or ty > self._rows:
            return None
        if (abs(sx - tx) > 0.3 or abs(sy - ty) > 0.3):
            return None
        return GPoint(tx, ty)

    def check_for_wall_click(self, x, y):
        x -= self.get_x()
        y -= self.get_y()
        sx = (x + self._sqsize / 2) / self._sqsize
        sy = self._rows - (y + self._sqsize / 2) / self._sqsize + 1
        tx = round(sx)
        ty = round(sy)
        dx = abs(sx - tx)
        dy = abs(sy - ty)
        ncols = self._cols
        nrows = self._rows
        if dx > KC.WALL_TOLERANCE and dy < KC.WALL_FRACTION:
            if tx > sx:
                tx -= 1
            if tx >= 0 and tx <= ncols and ty >= 1 and ty <= nrows:
                self._monitor.wall_action(tx, ty, KC.EAST)
        elif dy > KC.WALL_TOLERANCE and dx < KC.WALL_FRACTION:
            if ty > sy:
                ty -= 1
            if tx >= 1 and tx <= ncols and ty >= 1 or ty <= nrows:
                self._monitor.wall_action(tx, ty, KC.NORTH)
  
    @staticmethod
    def create_beeper_polygon(bsize):
        bpoly = GPolygon()
        bpoly.add_vertex(0, -bsize / 2)
        bpoly.add_vertex(bsize / 2, 0)
        bpoly.add_vertex(0, bsize / 2)
        bpoly.add_vertex(-bsize / 2, 0)
        bpoly.set_filled(True)
        bpoly.set_fill_color(KC.BEEPER_FILL_COLOR)
        return bpoly

    @staticmethod
    def create_karel_polygon(ksize):
        kpoly = GPolygon()
        kpoly.add_vertex(-ksize / 2, -ksize / 2)
        kpoly.add_edge(ksize / 2, 0)
        kpoly.add_edge(ksize / 2, ksize / 2)
        kpoly.add_edge(-ksize / 2, ksize / 2)
        kpoly.add_edge(-ksize / 2, 0)
        kpoly.add_edge(0, -ksize)
        kpoly.set_filled(True)
        kpoly.set_fill_color("White")
        return kpoly

    @staticmethod
    def set_beeper_label(bpoly, blabel, labelsize, label):
        if not isinstance(label, str):
            if label == KC.INFINITE:
                label = KC.INFINITY_SYMBOL
            elif label < 0:
                label = "\u2212" + str(abs(label))
            else:
                label = str(label)
        blabel.set_label(label)
        x = bpoly.get_x() - blabel.get_width() / 2
        x += labelsize * KC.BEEPER_LABEL_DX_FRACTION
        y = bpoly.get_y() + labelsize * KC.BEEPER_LABEL_DY_FRACTION
        blabel.set_location(x, y)

    def set_karel_label(self, label):
        kpoly = self._kpoly
        klabel = self._klabel
        labelsize = self._labelsize
        dir = self._dir
        if not isinstance(label, str):
            if label == KC.INFINITE:
                label = KC.INFINITY_SYMBOL
            elif label < 0:
                label = "\u2212" + str(abs(label))
            else:
                label = str(label)
        klabel.set_label(label)
        x = kpoly.get_x() - klabel.get_width() / 2
        x += labelsize * KC.BEEPER_LABEL_DX_FRACTION
        y = kpoly.get_y() + labelsize * KC.BEEPER_LABEL_DY_FRACTION
        if dir == KC.NORTH:
            y += labelsize * KC.KAREL_LABEL_DELTA
        elif dir == KC.EAST:
            x -= labelsize * KC.KAREL_LABEL_DELTA
        elif dir == KC.SOUTH:
            y -= labelsize * KC.KAREL_LABEL_DELTA
        elif dir == KC.WEST:
            x += labelsize * KC.KAREL_LABEL_DELTA
        klabel.set_location(x, y)

    @staticmethod
    def adjust_beepers(n, delta):
        if n == KC.INFINITE:
            return KC.INFINITE
        return max(n + delta, 0)

    @staticmethod
    def get_main_frame():
        for i in range(100):
            frame = sys._getframe(i)
            if frame.f_globals.get("__name__") == "__main__":
                return frame
        raise KarelException("Imports too deeply nested")

    @staticmethod
    def get_source_file():
        return KarelWorld.get_main_frame().f_globals.get("__file__")

    @staticmethod
    def get_world_file():
        filename = KarelWorld.get_main_frame().f_globals.get("__file__")
        return filename[:filename.find(".")] + ".w"

    @staticmethod
    def get_main_function():
        main = None
        filename = KarelWorld.get_main_frame().f_globals.get("__file__")
        with open(filename) as f:
            for line in f:
                line = line.strip()
                if main is None and line.startswith("def "):
                    main = line[4:line.find("(")].strip()
                elif (line.startswith("if ") and
                      line.find("__name__") > 0 and
                      line.find("__main__") > 0):
                    main = None
        return main


#
# Implementation note: _Corner
# ----------------------------
# This private record class holds the information for each corner in the
# following fields:
#
#     color         # String indicating the color
#     wall_south    # GLine for the wall or None
#     wall_west     # GLine for the wall or None
#     beepers       # int for the number of beepers
#     bpoly         # The GPolygon displaying a beeper
#     blabel        # The GLabel displaying a beeper label
#     cross         # The cross-hatch at the center of the square
#
# The bpoly and blabel fields are maintained separately and not combined
# into a GCompound.  Changing the visibility of a GCompound requires
# redrawing the entire window.
#/

    class _Corner:
        """Private record class for each corner."""


class KarelException(Exception):

    def __init__(self, msg="KarelException"):
        Exception.__init__(self, msg)

# Original file: KarelErrorDialog.py

class KarelErrorDialog(GCompound):

    def __init__(self):
        GCompound.__init__(self)
        frame = GRect(KC.ERROR_DIALOG_WIDTH, KC.ERROR_DIALOG_HEIGHT)
        frame.set_filled(True)
        frame.set_fill_color(KC.ERROR_DIALOG_COLOR)
        self.add(frame)
        bug = GImage(KarelErrorDialog.KAREL_BUG)
        bug.scale(KC.ERROR_BUG_SF)
        x = KC.ERROR_DIALOG_WIDTH * KC.ERROR_BUG_X_FRACTION
        y = (KC.ERROR_DIALOG_HEIGHT - bug.get_height() * KC.ERROR_BUG_SF) / 2
        self.add(bug, x, y)
        label = GLabel("")
        label.set_font(KC.ERROR_MESSAGE_FONT)
        x += bug.get_width() * KC.ERROR_BUG_SF + KC.ERROR_MESSAGE_DX
        y = KC.ERROR_DIALOG_HEIGHT / 2 + KC.ERROR_MESSAGE_DY
        self.add(label, x, y)
        self._label = label
        ok = GImage(KarelErrorDialog.OK_BUTTON)
        ok.scale(KC.ERROR_BUTTON_SF)
        x = (KC.ERROR_DIALOG_WIDTH - ok.get_width() * KC.ERROR_BUTTON_SF) / 2
        y = KC.ERROR_DIALOG_HEIGHT * KC.ERROR_BUTTON_Y_FRACTION
        self.add(ok, x, y)

    def set_message(self, msg):
        self._label.set_label(msg)

# Images

    KAREL_BUG = ("data:image/png;base64," +
        "iVBORw0KGgoAAAANSUhEUgAAAYwAAAGMCAYAAADJOZVKAACAAElEQVR4Xuy9" +
        "B3RUR57vP2/f7r7zztk977+7b9/bN2MkMkitDEJkMNlgMAYDNthgbBxxxDlH" +
        "xjl7HMYzztk4Z5KkzrlbOSAkkARIAgECgRAgfv/6FW5Zqmp137597+17pfqe" +
        "8zmeKVr31k31rfirP3gB/iAQCAQCQTS4BIFAIBAIwsElCAQCgUAQDi5BIBAI" +
        "BIJwcAkCgUAgEISDSxAIBAKBIBxcgkAgEAgE4eASBAKBQCAIB5cgEAgEAkE4" +
        "uASBQCAQCMLBJQgEAoFAEA4uQSAQCNQmWFUFxdu2wY7vvoXAW29C1eefQbCw" +
        "AIqqq4H9rUA/cAkCgUCgJME9eyHw5Sbw3XIjFEybACXjM8GbPgTsKeeAefSf" +
        "wELA/+L/92UMBceYVLCtXA7+774T5qEzuASBQCCIl6DLBb4XXwDHovOgIGM4" +
        "eNIGU1MoJGwe+UfYQtgahlA6/tZL/sY6IRs8L78EJXv3CfPQAVyCQCAQyMX5" +
        "xuvgWDgPCjNHgDk1CfJH/Qm2j+rbICKBf4N/byHHsU7OBb/bLUwjwXAJAoFA" +
        "ECu+xx8Fe04KaUGcI8scpOBMHwr+998TppFAuASBQCCQQnFtLbg3Pga2rFF0" +
        "/IEt4JUGu7IcpOUS/OUXYRoJgksQCASCSJTu3Amexx4B+/gsYhSDYNtIeV1O" +
        "csAuKuvEMVBCzIrNl0B9uASBQCDoC+drr4I1Nx0KRg+iYxNsga4FOCDuWLZY" +
        "GEYC4BIEAoGApbSoCJyzpoItdRBXgGsNtma8acngEdNuNYdLECSW4t31ENy2" +
        "Fdx/eQXcd9wGvlUrwL7oPLCQj9U6byY4ly4C77q1YHv8UfC8+Qa4t2+DotJS" +
        "8eEIVKG4cQ+47rkLbGmDoXDUnzTrekIinQtbN9bpE8R7rzFcgiAxBEnB77ju" +
        "arBPGQeWtCFgNyXTOesFo8JjHX0O/U1BajLYxprAOvdccN1wHbj++iYU1TeI" +
        "D0kQN+4PPwDr1Dwwp5xDxynYQlsNQlNpneSczqwRsJX8b/Y3od9ZTMng/fpr" +
        "8a5rCJcg0B73NevIyz8YtpGPQ86HiX9DIX9fmDIILOnDwLlwLgTfelN8TAJZ" +
        "2C6/jBhFkqz3UQ44AworQk5TElgm54Lvr29A0c8/gy2l7y6w7eT3rhuvF++4" +
        "hnAJAu0IlJSAc2IOHcSL1PyWC9bSCtKGgv3Ky8HvdIoPSxAV/9YtYMlNpy1Y" +
        "Nd7JnqAZYaFfmJoEjrwMwIpTsMfiPM/zz4Ejpe984N/bZ0yCoj17xbutEVyC" +
        "QBvcWzbTlgB2O/X1QcQLHhf7ejFWj9WUTFod88D9xutQtFNMSRTwuB97BGzp" +
        "Q2lNX613EsF33pk2GCx5meC87mpwf/QhlIUp9O2Lz6d5Yf++17HIN+S327m/" +
        "FagDlyBQn4DZDLacFNpXy34AaoG1MRy0pF1W47PBefsGKK6sFB+a4A+BYBA8" +
        "i+bRVdpqdEGFzIeOS2QOB9elF4P/k4+hqKYm4vtnyRwR1bhwHMP/4QcRjyNQ" +
        "Di5BoC5FzS3gOH8ObYqzL7+WYMvDTmqTzptvgNIwtTvBwCD4/fdgyRrJvR9K" +
        "gIU9thAspJLinjIOPK++AiV1uyS9a8Vbt9JWcTTDwDEO2wP3STqmIH64BIG6" +
        "uJ9/DpymZO7FTwR0pgl2D5ACw7vxMQju2i0+vAGE+7lnwZE2WNEFeHgsOrsv" +
        "NRnsk8aCff21ENy8Oeb3yv7IQ1AwOnq4ETQk9+qVMR9fIA8uQaAuVlI4K/mB" +
        "KoXLlEyn9LpIIRKuP1nQfwiSWj52C3nSh3DvgRyw4oEm4SLmY8vLpDOXfJ9/" +
        "BsVxhCS3LlkIWyV8J9it65g9TfZ5BLHBJQjUAwO1xRKkDWtPckNDywHPVUCa" +
        "+I7JueD54gvxEfZDin0+MJOKgRLjZ6Eup2DOaHCsWAq+b74BXOjHnjNWiqqq" +
        "wDY+iztfOPA6zHlZcZ9TIA0uQaAe5tx0ya0LbI5bll5AF07hwB5tnkv8WyVw" +
        "mJLAvnwJlIktM/sNfrOZLoZTwiwQbFU4Lr8UKhQwiZ4Evv8eCk2DufOFg1aq" +
        "MoYren5B33AJAnUIWq2kyT5EUmsBf2NPTYLgr7/SDyFgMYP9oQfotNhC8nFY" +
        "U5Pph6JmlNBQN4OP1B59zz4DpfuaxEdpZN76K50hp5RZIG7yjtpeekHx98Lx" +
        "6MNgjrBgj8U/NhWqG0R0Ay3gEgTqgB9BtDnlIbCwtqWcA9ZXXuY+gqDHA743" +
        "Xwfr/Fl0JW6oi0st40BwxzP77GngITU/Nj8C/YNTqO2ksqL0lFlcVGclFRn2" +
        "fPFinTsjpm+leFw67KivVzwfAh4uQaAOhRdfFFPtDld/W598IuJHUFJWBr67" +
        "7wQcSMfZTmq2ODDsCE5ztKxbGzFPAn1hveoKOq2VfZ5KgO9z4PprFH0f6Nqg" +
        "7FGS32NqGHnEMHaLGX5awCUYmXe3b4f1Dz6kO+579FEonJzLveyRwNg6Wy9b" +
        "Cbc+8yx3PJZ7H3sMPlt/HfyUmwFmE06TlBeTKhr4cZpHnwObx5jgifXr4aYw" +
        "eRH0Bt9J9j3VgsrmFnBeuFDVEB9oGJ61lyl6ff5XX6Gta/ZcfYHvuTVjOFSK" +
        "LlNN4BKMDH6gf/jDH3THf/7jf4cvh/MveyTwI38vNwv+6X/+T+54ffF//uM/" +
        "YP6gP8FjwwbBlrRhdL2HGmEecGzDmjYE7h+WBEn/9v9x+RD8zh+Tk2Hj2+9o" +
        "WphhuHv7zCmqxSgLQaPKYrj9MHmQi/m8mTTf7Ln64uyg9whF8yDoGy7ByCxe" +
        "vYb7YPXAxMHJ8HNKEveyR+PtlKHw3//pn7jjReN/kL9J+9//AdcMHgTfpQwG" +
        "T6o622jiGMrXacNh3tDBXB4Ev6OlaQTKysBKWrNSxwDigYbZnzVVsesq2V1P" +
        "FxKy54kE5qEge7RieRBEhkswMnptYVwyYTwUZo7gXvZIYAH/xqD/4I4VK/9C" +
        "WihXDRsMW0gtDPc1UNo0cJrw9pRBcHdGGnduwe9oYRqBHTvoeJYWZoHgeXBN" +
        "B5sPuTie2BgxOm046B7fU8crlgdBZLgEIxPOMB566KGE87dbb4GCtNhW1aJh" +
        "bM5JhWc3buSOJ4enyHE+vWwVbMf9mEkBr2Shgnn1pSXDpplT4bn77uXOPRCZ" +
        "Nm0a9y6qahpOJ6mUnDWLWArceKDvUPowxa7Hcu4k7hzRoCu9F8xRLA+CyHAJ" +
        "RoY1DPxw9aC9v/4C5rSh3MseDfeksdBev5s9XFw60dIMje+/B/7zZtLNapQq" +
        "XM5OBR4EbvLRt2z+lT3tgFR+fr4mpuEuLIQCjaMfI3T8QCHD8Hs8YE0fGvP7" +
        "iBGYnVderkgeBNHhEoyMXg2j2VwIlozh3MseDde4DGgrK2MPp4hOHjoEjR9+" +
        "AIG8DEUHR0NRcHe98Rp7ygEptU3DFwhAAXm3tDYLBN+ZYK5JkevAPerzJQQb" +
        "ZBHRarWFSzAyejWMAz4fWLNHcS97NJw5o+GA08EeTlGdPHIESm69iU7HxbUW" +
        "bB7kgAWJMzUJiq9YA6fI8Qe61DINf1ERjQqrZPdiLOBzLhqTApV1dXFdB+Jc" +
        "gCH/+XNEw2ZKBt9fXo37/AJpcAlGRq+GcbSmBly5adzLHg17xjBo2rKZPZwq" +
        "Ouj1QtmaVdQ4lNgFEP8ej+M9fy4cJAXbQJfSpuEpLKS7zWk5ZsFCWxjZI6G0" +
        "vFzWNYQI2O1QKKPLFrGQ97Xoqy/jOr9AOlyCkdGrYRyr3w2eCdKib/Ykn9Qe" +
        "9377NXs41dR1/DgdfwgsnAtuhcY3cGaWc1w6NP3yM3u6ASelTMNns4E5AWMW" +
        "LPh+BDKHQTDOLVJdT2wEq8zV6Gg0eD/YYwrUgUswMno1jM6DByE4dzr3skcD" +
        "I3bufu9d9nCqC7upqshH7MoYSgslJYwDYxlVk2MOdMVrGsHKSjBnjUy4WSD4" +
        "XvjTh4AvP77V7IVT8+jgNXv8aODsPNvEMVC0c2dc5xdIh0swMno1jDOnT0Pp" +
        "8gtjLngLU5Og5uUX2cNppraSEvAvnk8jh8YbagSv3UJaG5X33wMn29rYUw0o" +
        "yTWNYEUFnTyRqDELFnymPtMgcGzaFDHfkSgqyAdfurQoziw0LMj82bLPLYgd" +
        "LsHI6NUwUMGr1sb8oeMeGJWPPUIc5wx7OM10pqsLdr70Athz02iAQzaPsYKm" +
        "UbJmFRxtqGdPNaAUq2kUBQJgJbXpRI5ZhMOVOgg8778XNs9SsF2yLKZQID3B" +
        "SRqu9dfKPrcgdrgEI6Nnw6h+5qmYuxGwmV5+z5200E60jtXWQtGlK86GU5cx" +
        "m6XXdREj9M6YBIdIC2YgS6pplO3eDbbpE2J+f7QADaz0+WdlFdq4haslVf7+" +
        "9ri/h/2Zp2WdWyAPLsHI6NkwmrdvA2uMYQ/ox3jtOjh9/Dh7uISp9rVXwZM1" +
        "Iu4uKsQ9PgsO+/3sKQaUpJiGddF8RVp3aoCVGv9998gqtJ0PPyi7dYGYidkE" +
        "yXfFHlegHlyCkdGzYRzdVQfuzOExG0Zw5TI6CK0n7beYwT93OqnhnROXceD1" +
        "+fMyBvwMqr5M48m3/gaWSy+mrbpY3hstQcPwbrhZVqGNQRJpGH8Z4P1wjlVm" +
        "0aBAOlyCkdGzYaAck8bG1K1AC9SFc6GztZU9VMLV0dIM5bfdQrsU5Cy4CoF/" +
        "a8OV4W++zp5iQIk1jX//13+F19JGgS11kG7NAkHDsF92ScwFt3vTJiiMozsK" +
        "vw3Lwnkxn1cQH1yCkdG7YRTfciNdzMa+/H2BH4V7ah50NDexh4pLXSdPQltp" +
        "KXTsb2H/KSZ1dXZC0w/fgytrRFymga0UiykZap59ij3FgFLINDA8/ROZJjCn" +
        "xh4SX2vQMMyL5sdccLvXxT4JpCfYRef68+Mxn1cQH1yCkdG7Yez77hvwpw2W" +
        "XGOkcZnyMuH43j3soSILZ1WdPg1dJ07AyaNH6YB1008/wk7ygbkWnQe+CdlQ" +
        "kjkM6l56gf1LWcLpt66JYyA/BjNkQdPAAmTnKy9BJ8n3QBWaxqz/9a/0XsTT" +
        "3acVWAHaNjk3poK7qLoaCrNHy65k0AWDGUMhWFQU03kF8cMlGBm9GwZ241jS" +
        "hkguCOiHMSEL2nfuZA/VW8QgOg8dgiOVlXR8Yd+HH0DVQw9A8WWXgIMYjm9M" +
        "CnhMybRWhtA1EeS/wUsvVmwGVvu+vVCy9jLa5Sb1+sKBBUHV3XdAp44G+rXU" +
        "PtJis5NKRSxdl4kEja1gcmx7YnheeB4ccbSeaDfmuPSYzilQBi7ByOjdME6T" +
        "gt01f3ZMTXFX9ihqBD115uRJOFpXC3tJi6XyiY1Qtf4a8M6bAY5xGWAmhoSr" +
        "qi2jzzn7MfdxLvzozGNM0NXR0evY8Qhnc9U88xQ406WbIgs1M1KYlK67HDqI" +
        "CQ4kHbDbwEGet9yadyLAQWtvjC2MAvKexmOI2KpxX3tVTOcUKAOXYGT0bhjY" +
        "EqjBkBsm6bUrG6ltNn7zFbRs3wY7Hn0Y3EsvAO+UXDrYjCuwcU3DVhm1evy9" +
        "nRTMUVsvMrT3889oFFX2nLGAixZLrlgNJ9vb2cP3S7Xv3gWuqXkxP8dEg4bh" +
        "ycuQXHh7SOsXF/uxx4kFP2mF+r/9VvI5BcrBJRgZ3RsGUavbRUN+SC4YSG0T" +
        "Yzo5U86h3UhK7V2Bx8AAg7Wv/4XNoiLCrjH7WFNcNUnstiglrScch+nP6mxr" +
        "g8CKpbRVyN4DvYOG4c5Nk1x4W8dnS3/3w4Ctr8KsUVDSuEfyOQXKwSUYGSMY" +
        "BobEcE0bH1O3gxIGEQ7srvJdchGbRcV0qLgYfOfNPNsKCnP+aNC59sTUcGyk" +
        "8/Bh9vD9RmU330DHmNR6zmpCn1HmcEkBAH2bNtGotPFcJ75L9tUro55LoA5c" +
        "gpExgmHglNaK66+Oq+atFHRmUuYINouKqqNpH/guPL97sJ3NQzTwb7B7qvjS" +
        "FXCiH45pVD38YExTrfUGPh8cpPeTygH7PbLYLlrM/X2s4LvgevONqOcSqAOX" +
        "YGSMYBiounffod1S7MegNfixW1OTaUtAVXV1gW/pIhoahc2DVHBVefGVl/er" +
        "MY29338LThn7WOsC7BoihTeNC2ZKBle0PTEK8sGSGfs2xSyW7FHgc7sjn0ug" +
        "GlyCkTGKYbTjhkp5GdzHoDVYUOFKYrXGMViVXHcVWGRulBPqniolrbNOnYVK" +
        "kaPDpaXgHJ8VV3++GuB9xtZvCNwAy0paELgqG7cZtk7IBtu8meC79iowP3Af" +
        "BD/8AIpLSqIW4I6bb6Cmz54vFuhEjUXnRT2XQD24BCNjFMNABS67JKZxDDXx" +
        "X7GazZ4qOn3s2NlwIjL7sc8aXBJdX3JCh+FSpAqnH3vOnyt7lzmlwAFragq/" +
        "rc/xEEP2ZY+EgsyRYJk+ATyrV4Hjvruh5O9vgefHHyHockFpQ2PMBXbpjh1g" +
        "zYw/YCV23dn/vDHm8wuUg0swMkYyjL0//gAukz4GOr0zJsNpjbp6cDOpyjtv" +
        "A+to+QH18snf4jqNkwquIdFS/jWrNB+3CAX5w/tOw2qQlmVgXBoUjMsE28UX" +
        "QeCJjeD85hso8fuhuKlZ0ULZde/dZ8Pih8mXVGgLM30o4CZS7PEF2sElGBkj" +
        "GQbKlpepi8Fv11gTHAoE2Oypqoo7NtDNlNi8SMVKWhqVd98BJw0WRmTna68q" +
        "NjU6Krg40zQYzBnD6RoP28J5YLvtVih+9x3wk+fNfj9qkU/yEHfrgnwnlvNm" +
        "aZZnQXi4BCNjNMPY8exT4IxzEZMSYKGy5+sv2eyprqp776IFP5sfKWCBG8gY" +
        "AjsMtE/4vi2bwZoxTBOzoBMa0odB6Y8/QtGevQkraK23b4g7PDv+LU479n/8" +
        "UcKuQ3AWLsHIGM0wjjc2gCd7FPeBaA3OdKlKQMGLYxq4BkHumAaCq92rHn+U" +
        "PbTudKJpH7g03DUP76cjbTAEEtiFg0EGrRnxz4zC1olD7H2hC7gEI2M0w8A1" +
        "GWXXX53wFb64gA/32T6ViBXVZ85AcNUK2es0EAyNXvvyi+yRdaXiK9aALY4u" +
        "ODngc/3isUcTVtBab70ZtitgkA5y3+wP3Jew6xD8DpdgZIxmGKjmzb9CQYq8" +
        "bhmlwNlajok5cHzfXjZ7msl/8VLZ23ViDRQ3Ydr3zVfsYXWhmpdeoF2Pcg1R" +
        "LtiaeXH2TG6PcC0IlJeDZVxG3GMXCEZ4LnI4NL8GAQ+XYGSMaBjHmvaBd+YU" +
        "RT6seHBnjaCbKiVKuA2tf+ki2es00PS8OaOhpSCfPXRC1bx1Cy3wtDYLBO/J" +
        "g0n/xe0RrgXOJ5+Q/Sx7gq0k+5KFmuZd0DdcgpExomGgqp95ioY8YD8WLcHu" +
        "ksaPPmSzpqmO1NSAZ9p42eaJNWqc73/Q62EPnRDhAk3vuRNlX48SbMrNhHP+" +
        "+EfNTQNDziixzqiAmI7n5Zc0y7cgMlyCkTGqYRxrqAcPqR0nohYawkE+zOJr" +
        "17FZ01ytfj/Y41jkhX/nzMuEtooK9tCa6vSJE1Bx+610pTSbRy35Kn0E/Onf" +
        "/o1+D1qZhuPO2xUbr8GIx0FSkWDPIUgMXIKRMaphoIqvu0p2H74SYEGLYR/0" +
        "oJbCAroJlNwaKi6K850/l3b3JUp7v/kKCokJyzU+pfhyxJ9g6L/8S/c3obZp" +
        "lFdWQjBnlCKVH2wxuq68XLW8CmKHSzAyRjYMbGXgTnXsR6MlzrTBcKx+N5u1" +
        "uHWGcKyujk2OqF1//xvdJIrNoxTolFJTEhStvYw9rCY6TApNV478PauVxExa" +
        "awtNqb2+CzVNw7FyhWLXjWt0AiLQoK7gEoyMkQ0DVXr7rXQKIfvhaAEWsnRD" +
        "pXfeZrMlW0fKyqBy42PgmnMuFKYPg67OTvYnferMqVN0X3JcZ8HmVSrYYitd" +
        "fy17aFWFe6S7Zk1VrNCMl0JcZf3sM72+C7VMw79lMx3gZ/MgB1zZbV0wR9H8" +
        "CeKHSzAyRjeM9l11Zz/wMB+QFmCcoaLrrmazJUloBh0HD9IBZ1xIZ5+cC4HM" +
        "YXR9BR1XIAVJc4wzmE4cPgz+hXNlF750tTMxnJqnnmAPrZqq/vw45Cewa5EF" +
        "J1PsfvtvUFBYqLpp2FavVGTdBeJNHwyBX35RLG8CZeASjIweDAOD653C8Nuk" +
        "phmrMJhe6bXrNA9M1xOcOy9VXceP0700Gj79BMpvvQlck8aCL3M4DQWB0yFD" +
        "Ae+w4EbjqHnlJfYQUXV09y468InHY/MqFVyjgWMKagvN0po1MmGGHw5LKmk1" +
        "EhPD9zI/P1810/Bv3aJYZQfff+u8mXHnSaA8XIKR0YNhNH78EQRnTIKyK1ZD" +
        "+QP30kJy/7at0F5bC6fa2mh/fiQ1bd8GlvRh3EekFXZSuB6pqmKz1S1sSbS6" +
        "nFD58INQcuH5YMtJITXqQfQjx0HKSIOdgavWsoeTpAN2G5hNybILI7owkeSz" +
        "rayMPbRiwvuCIcsTafbhwFla5TdcC12/BWlUyzRwj4x4TL0nOFnA88UXceVH" +
        "oA5cgpHRg2H4V63oLjix8MA4TdgPjwO4ToyHM3sa+EjTvebJP8Oe776l/fwn" +
        "W1vh9G9/jzXBklXLuY9IK7BGuvv993pd0ylS2BywWaGStCIs5BrwN1g4RDIH" +
        "FtotNWc67eOPVWfOnIFdb74O7rTB3HGlgn3i9rxMGr9KDVUQA03Eau5o0AWN" +
        "F8yHDlJZCUlp0/B98D4Nl86eWw40btSUcVBUt0tWXgTqwiUYGT0YhjU3vc+a" +
        "VqiLBrtnEOy68WcMhdJJOWCfNLZ7T4p9uDrYlJi9MraQvBffciN0tLRAyw/f" +
        "0em+1rFpNFpoKN6T3Hx5J+ZAW3U1c8ek6eTx41C0ZpXs4H2hbjH/4gWK7/2x" +
        "32IGL3mOoeerJ7AAxnfr+IEDvfKspGmYSetNbuuPBfc6cT30QMx5EGgDl2Bk" +
        "Em0Yx/c0gi87tjno+NtfCaXnTug+DnZbBS+5qE/jURuc0WQbkwou3JqTFLKx" +
        "tib6AkN7N2/f9vsNi1FoNtgFxh5XKngN2Noru/1W6DodatPFp46WZvDNSnxo" +
        "l77AFkahaQgca2xgs66IabjuvF3R99RGvp/iHTskn1+gLVyCkUm0YTRt2Uxr" +
        "4rEWrlgoe5dd2OtYuC4D91JOREGE55Q7MykS+SlJUPf3t3pdZ6xq/PpLcJJ7" +
        "jJsDsceXijk1GRo+eB9i7xzjVf3nx6FgtDLdMWrhIUaN407hFI9pBJxOOsjP" +
        "nk8u2AK03Xpz1PMKEgeXYGQSbRi4p4ScLhPs+6548D72cFD10P3gUKhvWA9g" +
        "TRSvCUOax6OKe++Ku8/cmz0S2nfuZA8dkzBYY2Ha0ISYeix404fAni8+Z7Pf" +
        "LbmmYV1/rWKD/HgPcTYbew6BvuASjEyiDcN78VI6uMp+DNHAxXp7vtrEHg6O" +
        "kgINu4b0XiBJBQuXoosvgs7Dh9lLjUm4b4d71hRZ9zoEtqBcE7Kho7mJPbwk" +
        "YZeWb+kixQpMNXGS96s6ylqUWE3DX1gA7sz4N0cKgbHMxJ4X+odLMDKJNIzT" +
        "nZ3gnT5BVuGOITmOlJezh6QzinY88lBcq531BBbSzslj6e5z8Qr3EYlnVTEd" +
        "zyCFfWDFUjgpY+OoHS88B05TYvcxkQq2eoNXrmEvgVMspmGeOUUxs8T8WcaY" +
        "ErqVrEAaXIKRSaRhtNfVgltGxFn8ffHkMXTwNJzaG+rBkafMRjR6wJYxDA4r" +
        "tB6i9Pqr415ZjHP+d258LKZussOlpWBJH8odS69ggWyb/vukikiSYhrOhx6g" +
        "M/zY88gF981wkRYQ+z0L9AeXYGQSaRh7f/2FLi5jP4ZoYLeKe9ZUOH38OHvI" +
        "bu148fm4tjDVExh+pOnnn9hLlCW6CjyOWVMIGrHZNBj2529nDx9WuK2ud8lC" +
        "Qxk4tuxwMajU6AORTKOoqoreLyWnEFvHZYCfVCLY71mgP7gEI5NIw6h5+UVZ" +
        "s2WwW6T48ku7V+KG02lSSLmm5skaUNcbztQkqLjvbvYSZWv3e++CLc4uO7qr" +
        "W246HCWtuUjCNsiezz+jBSZ7DD2DhXvR2BQ4WlPDXlKfCmcao1NT4ac5MxQ1" +
        "S7z3jjtuE2ZhELgEI5Mow8CVyNV3bJDVPYL9wDue2EhcIfK6AIxTZDfF3oLR" +
        "G9ii8ixewF5eXAqsXBb3hj20n3/hXPIY+n4OGNrFaUDjxpapP30wNEtsRYXU" +
        "0zT+4R/+AS4fPVJRs8R8ObJHQUl9gzAMg8AlGJlEGQbuR12yYoksw8CQIQ24" +
        "NWqUPvSuU6eg4pYb465N6wFcnIVdO0qpndScLRnD4l47grVdnLLbl2qefSpu" +
        "Y0oU2JLd+dqr7CVFVcg0/tc//zNsGp2s2CI9NAu8l65HHxZmYSC4BCOTKMPo" +
        "PHQIKq5YDY7MEVCYcjbOktTCCwdPm7duYQ8ZVkerqsAxLl3RLgGtwbxbSUER" +
        "S/dINGH8rerHHqED2Oz5YsVJnmHzls1ckEi897iTXDwLBhMJtoqKb72JuSpp" +
        "QtN4JiOVrn1RahwN3wPnhGxhFgaDSzAyiTIMFHZXtFotsOPZp6FoxVKwklq0" +
        "Jy2ZdjnhxxHuQ8N0DN19uKSEPVyfwpXFGNCQPZZRwPvgI/el9q032UuLS7hm" +
        "xTkxhztfrGDB6pw2Hk70iL2EXY6+xfPjWveRaLAS45w/u8cdky6MYKB0dyju" +
        "puf/4nNhGAaDSzAyiTSMnsL9MI43NkDzN1+D/5JldL0ALs7DAqfn7BI0DNf4" +
        "LGirrGQP0adOd3TQtQxGbmXgfZC7UVMk1bz0AliImYYz51jAGWlB0mIMCcOZ" +
        "YMuR/Z2RoOMYxAhxvVAs6mxtBc/Ucdzx4gHNy7b4fGEWBoRLMDJ6MQxWpw8f" +
        "ht3vvE3DTNuZ1bEFpsF0EVosatq2FXw6jY4qFeuksexlKSIbMWAlzBT713Fj" +
        "qM6DB8E3Z7oix0w0nlxT2CCEkVTx4P2yxuYigQPnvk1ivwsjwiUYGamGgaEl" +
        "4iGWvalZNf/8E1h6zDTBGvGO33ZEi0Xlt91CwynEW5tOBDRuEDHOTibkthLa" +
        "++3XdN+MeO/LNlJIOrJGQhm5zxhym/13PYPXjmNoWJPHwW4red9wHUbxzMnQ" +
        "FmFzLFYHLGawZo5Q1CzxWBhCh/12BcaASzAyUgzjYFER3SnOt3CeLEoWzeM2" +
        "GIpFx/Y0gntaXvegOI5x+C44L+I6jHDCGEh4HKVmrWgJFmi4x3dTjC0rKcKl" +
        "ad6LFis23mBOTVK0wFQDvJ9IaJ8VX/oQGhQRW0YVd90O9aR1ixtgHdu9i71d" +
        "fQo3mnKRv1cq/AeCebQTMw96vcIwDAqXYGSkGEbd23+ng8ZYCMjBTmr1u959" +
        "hz2sZGHrpPz6q3vN5ceQIriXRqxq/OxTGgKd/TCNANbad778IntJiggLR2dG" +
        "4ra51YqQSWCYDi95h+wzJsGOhx+A/Vu30AoFFvpnTp2KOmU7nMrvu1vR8B/d" +
        "02g33CLMwsBwCUZGimGUP3i/7FlG9KUnNc795kL2sDFp55uv95oCih9m86+/" +
        "sD+LqpMdHRBctVz3NeCwkBZW8Oor2EtSRJ1HjkBw5TLDLbDrC3y+2CJFk8Vo" +
        "AjiJwokbXC2YA+X33kWnAXce2M/eBtnCMTLs1lNyjIx2j41LF2ZhcLgEIyPF" +
        "MMrWX0P7p9kXWir5pEZ38uBB9rAxqdXvp/3joX52rCUGLr+M/ZkkHS4vB2vG" +
        "cMOZBuY3sOg8xbdLDQk3WlJyVbJWhN4Jugc5qUjYiTnYskeDd94MqLzpeqh5" +
        "5SU4sH0bdCgQ8TeccFDcPUXZWVEIdkH6PvpQGIbB4RKMTDTDwMKp+KILZC++" +
        "wo/ZmpMS16B3SN7Z03rVgHHdBs73l6Nd77xNC5d4B3q1BA3DOyknpkHYWHTq" +
        "+HHwzJpiiHuCNXkcK6B7vKeT1kOuCXwXng81Tz8Je7//Fo6Qe3SCtCCUXB0f" +
        "Tvhel918g+wWeF9g68guptH2C7gEIxPNMDr2t4D33Imya+P4YXvnTO91TLkq" +
        "vfuObsM42787CA7YbezPJCtw2SWKDlBqAe4dfsBqYS9FMdW99y5YdT6TDPPm" +
        "HmsC96J5UEtaDwfdLhpqhkpmBUKuWjb/CgXkfsn9PvoCW3ren34ShtEP4BKM" +
        "TDTDOFhaCvbcNO6FlgoO2sntOmK1nxSULtPZ/b/p7BFybJzzLlcd+/aCfZyx" +
        "9s0wpyRB/YcfsJeiqOyTxuh2LAOflXvJwqiBJ7UQVqYC5F5JDWkjBXyvsWvt" +
        "wwlj4blPPxWG0Q/gEoxMNMNoLsiXvfENvvy4WrvqsUd6HVOusO5oG5vW/YFi" +
        "4eGcOZn9mWTh8XZhqG8DzZrCro/qhx84O5NHJTVs+pzumc6eWw/QjY0m57JZ" +
        "1lxdpCUTuOgCxaYih8B3ezNpXQz53//BbcIkMCZcgpGJZhh7N30BhanyQzyg" +
        "Yez9+stex4xHpTet7/WRunJGQxtpBckVbulafMVqw6zNMBPDCCy/ELqOHWMv" +
        "RTHh1FJL7u/GrDdspAJzsq2Nzbamqnr4QShQeNwCK1geUnlZ8Mf/6v4ehWkY" +
        "Hy7ByEQyDFxJvevF58Fqkh9EDTf/aauu/v1Li1MYEiSQMbS7j92cmgz1GOo8" +
        "Dp1obQXX2FQu73oEC3FbXiYcI3nG3eDwGSkOab3U4o6FCq4pUAp87oGs4XDQ" +
        "72cfo2Zq3raVC1ejBFgRsi1dBP/jn/+51zcpTMPYcAlGJpJhYNC1its3yC44" +
        "6MdNCmIcK1BKWLO0ZI3qrv1uJ7W8sg0305ZCPMKuN49BFq7hgGj57bdC9aMP" +
        "Q/UjD6lC8XVXQb4Coc+VBt8pDBkebyVBro417QP3zMmKj/Fg96otJ4VGYQ63" +
        "c58wDePCJRiZSIbReewY+Jcvievj8EwaQ6PFKiU0sZJ1l9N4Unh8NA7/eTOh" +
        "o6WZ/WnM2vn8s2CPo/tNK7DQpPGOyD1QCz3PHsP3seyeO9nHp4mCV66he5Ow" +
        "eYoXvN/Vjz/afR5hGv0HLsHIRDQMur3mONmGgYvr3KQwj7f230tnzkDD238D" +
        "y28FO9bMzBnD4XAwyP4yZmHXFMao0mvfveAsON7kXnQe+/hUVyUp0HEygNJT" +
        "jvF43ukT4DQTG02YRv+ASzAykQwDa+2FpiH0A5Uz9RQNo+S6qxSfG7/f7QZz" +
        "+u/dR7hRzZ4vN7E/kyU8tmuMMcYzBipo6I6JOdwOf2pqzw/f0ynNapiFL3NY" +
        "n2MywjSMD5dgZCIZRvuuOihauohuC2lOHwqezOF07QM2n5HQegj2IwiBhlHz" +
        "zFO/v/0KCVfwBufP6jYxakzXK7e50O533wF/j4F1gb6gNfKxJmivq2UfnSrC" +
        "rXFdk3NlVZoigdeB8aewKzSShGkYGy7ByEQyDJwxc+rQIRriGeMvHfjpB6h9" +
        "9WUou+ZKsE/NA/+4NDpjCRfnYaGNXVc9C1kcD9ij4JTaniq7aX33JjU0Iu64" +
        "DOhSaKwEa66VD9xLr0uYhv7AZ4Lxog447OyjU0X+FUvpdGY2H/GCla7i5RdC" +
        "5+HD7Ck5CdMwLlyCkYlkGBF15gzdzKctGKQ1cpxVg90EPeem0w/i+muUHcP4" +
        "Tbs//YR2EYTO5SDmdLi4mP2ZbHUePw7eBbMVX5glUAacwVX79t/Zx6a4yu6+" +
        "g1Yc2PMrgS1rBLTGENpGmIYx4RKMjGzDCKOOvXvAPen3vbOxJlicTT4KFWqC" +
        "9FxjUrq7xZzko6585CH2Z3EJDciRm6Z4V4QgfjACcvn997CPTFHtIoaEgQ3V" +
        "aGViaxz34YhVwjSMB5dgZJQ0DFTNs0/1amXgAKV71hTFByjxeJ5F87pnNOHA" +
        "vG36BPZncavhg/dpOA41Cg2BfLA7smzdWlVaryjc2RC3aGXPqwTY8vbMnQGn" +
        "ZUbSFaZhLLgEI6O0YZxqbwfv1HHdBSz+Fxf+1b31JvvTuIXHxEVcoVaGJTUZ" +
        "2muVHwgt3XCz4UKh93dwf5aixQvg5KFD7OOKW+31u8E+IVuV6dU0bHnmcFm7" +
        "RfaUMA3jwCUYGaUNA9X0y8/gNp2NKosfCf7XNTUPOuPcRIlVe0M9DRyIXUZ4" +
        "DhsxDzWMCRVYsVTXi9kGGvjMXZPH0pl8SgoXmfouWkwXRrLnVAIreUfj2d++" +
        "p4RpGAMuwcioYRgo/8VL6cyp0IeCMZ9qX3qB/Vncss+Y3D0wjYWIf80q9ieK" +
        "6MT+/eCYNNYwQQoHArac0XDA52MflWxhFIHSq9Z2t1rZ88ULjluUrrscTik0" +
        "mw8lTEP/cAlGRi3DOFJWBrbM37dBpU3xCTmKb5O587lnSGvm99lSWOvEdRpK" +
        "C8dMWgoLwNpjm1hBYskfPQiafv6JfVSyVX7X7XQquBrPl7ayx2Wo0mUqTEPf" +
        "cAlGRi3DwIin1Q/eB+YeAewcpOaGW2gqqTZiTAWjf9/xzJoxDJq2bWV/pph2" +
        "vPoy7fpSo1ARxIbNlAz1f31DkYHvujdeA7NJflTmSOCuk770IbD3h+/Z0yom" +
        "YRr6hUswMmoZBurgb9NSQx8OFuq4GdOJ/S3sT2XreGsrOKbmdQ9Q4t4dNS8+" +
        "z/5MUZXfeZtqfdwC6djIs8ZKSby77zVv3QLu7JGqTZ/GYIWV993NnlZxCdPQ" +
        "J1yCkVHTMFA7HnmoV78/jjeUXHMl+zPZwoBtlbfdQqe+dh//ysvh9PHj7E8V" +
        "E3ZPFa+7nG4XyxYOAu1A0y5avZKOPcjVQa8XrNmjVFugiXn0XXg+nFE4nlpf" +
        "EqahP7gEI6O2YZwiBbdjfGZ3CwC7cnBDpiZSq1NKDZ98DAW/dX2dHSvJjnva" +
        "YjQd27cXfPNniZlTCYTuITElV3bloNXnA3dehuxozNHA/LnJu4h7XGgpYRr6" +
        "gkswMmobBmrPV5vAm9Z7mq1/2WIunLNctQaDYOsRYdaZPgRanQ72Z4qrrbwc" +
        "7GNNXEEh4MFC2YyBKxUsnLFykJ+aDJ0y1mK07ayhIcXZYyqJOTUJ6hWaQhur" +
        "hGnoBy7ByGhhGCjfRRf0Kixw17imn35kfyZLuAd18QXzu/ugMfbPjif/zP5M" +
        "FTV++zXY04eqssirv4CTBCruvweatmyGqqeegLLrrgL/+XNoFGSMp1RAClYs" +
        "XLG1hsaC91LKpAL8jTdjKBz0etjHElEdBw5A4MLzu7sxlYa2okmLt+SG69hT" +
        "ayphGvqASzAyWhlGq9sF5rSh3YU6jmt4ly6CLoVaGRUP3tfdtYAFj+u8mexP" +
        "VFPjZ5/SAk+tQVOjg4vV9n33Ta97hiaP3YbYEmz44nOoe+4ZKL3xehrw0Zw1" +
        "EgI5o8FlSqJreXAcAGcasSZCW6ppg6H+g/d7HTuSujo7IbBmFZ2xxx5PCfCY" +
        "DmIWwRVLadSDREuYRuLhEoyMVobRdfIkDUneM84U7gWwj9TQldB+mxUcpt+7" +
        "vbBb6riCe4lH1JkzsPvvb9GNnNgCRHB25lqkAJR0OLirixbmuGd7R3MTtBcX" +
        "Q+OXX0D1ww+C5/y5UDRlLN1oCEO0oIlgKwRNBM2kXOJ2rV2nToFn8QJVZ7jR" +
        "zZ3yMuFYYwN7+oRJmEZi4RKMjFaGgTrg8YA9e1T3x0Wn2eamxT0tEoWG5MrL" +
        "6A4Tgqt1d73zNvsz1YTh0MvWXwP5KnVzGBnbWBMcqapib1lMwvEuXPSGaxnK" +
        "7r2LbtGKMcswNIx74Tz255xOk9p+8dVXqB5I0pI2BJo3/8qePuESppE4uAQj" +
        "o6VhoCoeuJfWEPGjRbDGWPXERvZnshS89ipae8TjYreU75Jl7E9U1amjRyF4" +
        "yUXd18cWJgMRGq343ElwTIVZa2c6OuhueM1RFmqi2ZRtuJmOpbD5UxI0ox0b" +
        "H1M8MrNSEqaRGLgEI6O1YWCh6mBmFmFMoKMKBJHDmh3uABgqrM0Zw2k3h5bC" +
        "3dNwBphDRLel4LhSycVL4aSEXeXUUtmtN9FFfmqNMYUqPsG1l0GXRust5EqY" +
        "hvZwCUZGa8NANX76Sa+NabAbp/ruO9ifxSzcohX3Hg/NssExBYycq7U6Ww+A" +
        "d8Zk1eb3Gwnc6Kjilhvpdr+JUNF1V6u+VgZn/3nmTFdsAofaEqahLVyCkUmE" +
        "YeAgsX/Jwu4PmS7AIq2MQ0VF7C9jVtHa1d2Dmrhngtq7svUlDL7omjRmwE+3" +
        "xY2OKjc+xt4e1YWL+SruubNXLDM1oAtFc9NUXyiqtIRpaAeXYGQSYhhELfnb" +
        "6VqM0IeH89bLb7+V/VnM2kNaLz1DduCufEotEIxVOGXUMSaF1kAHavdUQWqy" +
        "Yvs/SBU+b3yXtJi1Zk4bAvu+/1a34xaRJExDG7gEI5Mow8CNakqvWE1roKGP" +
        "z04+vqM7drA/jUmHSc3emjmi+5ju8ZnQVlHB/oyq6+hRWjM8unMnHPL7odVq" +
        "gSPV1TQNd3JTohA4FAjQrT7V7hbRK9b0oTQsvGYirdfAymV0l0c2L0qCU3o9" +
        "pmSo+9tf2RwYSsI01IdLMDKJMgwUrtB1ZQ7vrn1j8951/lz2ZzHpRGsrBBYv" +
        "6B4/yE9JIjXA72hBcurIEWj67hsoufF6cM6eBsEJWWBPHwKW0efQbiwEZzhh" +
        "mmtMKrhnTobS9dfQGjJu29mFJ5AxqInXackYNiC7p9xjU+FInJUAqcKps/5L" +
        "LtLEnDGaQMXtG9gsGFLCNNSFSzAyiTQMVPEN13V/4HSVbGoSNH61if2ZdJEC" +
        "veqh++lgKx4Tx0c8SxZCcNVyKCQ1fV9aMjUF7CYKt3o4lA/8N7pOBA2EFA6e" +
        "7FEQuOgC2PXm63CoqirmQdy9335NV7qz5+rveKeNpzPj1NaJpn1QdOWaXrs8" +
        "qgWNiHz5pWwWDC1hGurBJRiZRBvGiQMHwDsuvdeUR8+MyXFNw2z8+Sco7DE+" +
        "gh84gq2OcAYhFTQ2hymZBjosu/kGOGAxS+62wt/Vv/M2uDOHxZUHI4EtKue8" +
        "GeytUFyHq6shuGieqiu4Q2BIG/+i86CTvLf9TcI01IFLMDKJNgxUw8cf0dg+" +
        "oY8yP2UQ1L71JvszScIYRRW330qPwX7sSoHmhuaD/fPBq9bCcYnbzqJpYLiL" +
        "QNaIAWEaeJ+KVA7A1xoIgHdSTq+xMLXA68HoxG1xrlrXs4RpKA+XYGT0YBhY" +
        "yHvOm9kdzRZrpp5ZU2lMoViEay4wPIgW3RJIaEW5N2c0NH7wPg1PIkW4f4c1" +
        "fRh3vP4GPs+av7zCXr5iavV6wZmbptqCvJ7gO4lhPw76/Ww2+p2EaSgLl2Bk" +
        "9GAYWPPGIISWHt1InrTBdLxAik4c2A81jz4ETvI38XY7yQHP50kfQrup2nfu" +
        "ZLPHiXZPvf03ul2t1nnVCrwuL3keuP2pGsI9Vpzj0jUZ4EazQINvsZjpubXa" +
        "PS+REqahHFyCkdGDYaBwm03/8iXdtUX8L26d2dnayv6UKvTRYlC7wAXzaQht" +
        "9kPXGrrid0outFgtTG7Dq/7dd8DXI5RJf8OVMQyO7t7FXnbcqn78UbARs+25" +
        "9a+a4Ln2fPap5PGq/iJhGsrAJRgZvRgGCgtaO2llhApQnLpYcutN7M+6dbi4" +
        "GNy5abqbrurIGhE1IF5IjZu+AF/W71OL+wvY0stPG8Jeblw6cfQolFx/jeqr" +
        "t0PgM8EYVDuff5bNyoCRMI344RKMjJ4MA1VEQ1CfrTnS/Q5MyWEX3h2wWcGe" +
        "qd/BY+xuavr+WzbbYdX40Yf091r0xWsFnSE1Zzp7qbJ1vKUZgiuX0U2V2HOp" +
        "AZ1SjWst7rubzcqAkzCN+OASjIzeDANnHLnHmnp1TRVdenGvdQ8HXU6w5/ae" +
        "iqs3sHvKkjEc9psLe1xdeHXB2e4pK/l9fwkjgqZfcvMN7KXKUsuWzeCbPZWu" +
        "h9Hi3uB7haHKsetL6KyEaciHSzAyejMMVP07f+9VkyxMI7X13zalOVa/G5x5" +
        "mbrrhgoH3X0texS0SDANHJM55PPRloYWA7lq4yHPT+qkhb6ERlr36ss01IuW" +
        "kX+tqUlQdedtmofG17uEaciDSzAyejSM4/v3g2fWlB57dJ9DV9aeOn4cPHNn" +
        "GKpAxRqxOy8DDkucu99WWgr2MSmaFpBKg9fsSx8C+7dvYy9PsnBfCYw2i9v4" +
        "ssdXE4xwXHzZJdCpwep0I0qYRuxwCUZGj4aBwn593As69CEXpA0B15xzDbmb" +
        "He5jXrR6peQQGQdcThoaPRFThJUAu3QKRg+i4TrkCE3Tv3gBnfSwVcOWpCVl" +
        "EO3+PNXRwWZJqIeEacQGl2Bk9GoYGKLav3Bu98ccWl3NfuRGwWFKhp0vPMde" +
        "Zp/CQhO3NrWqvAe1GuCzcoxLh5NHjrCXFVXYHWkbm0ZbkVpet51UTorXXiYr" +
        "zwNRwjSkwyUYGb0aBmrf5l/Bmz6UzpZiP3AjgpF528rL2cvsU7gGBbd71SJG" +
        "kpLQfbwXzIGTMdTUcR1OybXr6O6LWk9mwC5PDE6JC0CFpEuYhjS4BCOjZ8NA" +
        "FZNCRKtQH2qDLSTnrKnsJUYU7huCNV8s1Njj6RVryjlQtv5aSaFScKxiv8UM" +
        "zoljaBeUlq0KBKMaYzj8zoMH2awJSZAwjehwCUZG74ax57tvwZuWrHlBEo54" +
        "u8XwGrCrpeblF9nLjKiTR49Cxa03gcsgazXoYrdnnooaAr6jaR/UPLGRxmjC" +
        "VdtaPmM8F+7IV7rucuiMIzKykDCNaHAJRkbPhoGhGLzzZuimkMxPTQb71Ly4" +
        "TANxTR4LR+t3s5cbUac6O6HhvXdJjXhQ3OdXGzTFxi8+Zy+hl3CatHvWFChM" +
        "GZSQ5+tKGwzlxISlTkQQiixhGn3DJRgZPRvG7s8+pTNXtKx59gX2ywcWzqVd" +
        "F7Zx6XEV2uaUJKh9/S/s5UbXmTPQTApaR9bIhBSyUsF9rlsK8tncU3Vi+Pm7" +
        "76Db8bJ/pwX4LuE7VXbTemEWCkuYRni4BCOjV8PAvvvggtm6MAtkO6nZ1/wW" +
        "U2i/ywlWU7LsQhvNxnXuJDjZR2DFaGq128A+IZuOa+jl/vTEOiYVDpWU9Mpz" +
        "14kTcMBcCC7SQsOZX+zfaMHZcB+DoPyu23vlTUg5CdPg4RKMjF4No2XrFt3s" +
        "GUH7u8ea6L7eIe145kk6VZb9rVSwS2R//vYeVxyb2nfvgqJLltGw6uyxEwkW" +
        "yt5zJ8KxxobuvB4qKoLy66+GQtKy0nq6bAgaopw8r7pXXupxF4XUkDCN3nAJ" +
        "RkaPhoGza6pJLbAQF26F+fi1hHZhkEKunAlC13HwIPgWz5cdooSGQl+ysNcx" +
        "Y1XHoUNQ+dADumpp4ErpkuUX0jEX7PIpvedOGqYeFy/KbZHFC94ba9oQaPjw" +
        "A/JydbG3UUgFCdP4HS7ByOjRMI7t3QN2HcWLMpsGQycpnFk1mQtprCj291LB" +
        "2UQYGyteYcwmHDdgj58IsLut6LqrYd9PP4IrV/sFeOFwZ42EPZ9/xt42IZUl" +
        "TOMsXIKR0aNh7PvmK7rjHvvhJwIHDpDeexebxW7VPPc0OEjBH2uhiL93khZU" +
        "+f33sIeMSSePHYNWjwfcs6Zy50gU21OTqRmy6VqDLS/H+Cw45Haxt01IIwnT" +
        "EIahuoJXrNZNgEEnqZ2276pjs9gt7OAIXHIRMZbYu4Wwi8Y2aSx7SMlqyd8O" +
        "xSuX0Qi37LG1gnb3EHPo2RpMVNdTCDrmRPLkXTgP2ior2dsmpLEGumlwCUZG" +
        "d4Zx5gxYSCEdz7RVpbCQGmrFhpvhzKlTbC57qWPfXrCNSY25C422MjKGwX6n" +
        "gz1kRLXX1NCIqjbSCtue4PuExh689iooTBuScKNAqFkQ8w6sXgkn29rYWyeU" +
        "IA1k0+ASjIzeDKPpl58hkD4k5tq6GphJzf2A3cZmMaz2fPE5nYXDHiMa23Gj" +
        "nmeeZA8XVhhye9df3wA7MRk9bLREDY8YRavXC+U3Xk8HttnfaA3G3SpZdzl7" +
        "64R0oIFqGlyCkdGbYZTeeRstDNmCQGtwtk9g+RLokhhA7+Tx41B29RUxtzLw" +
        "PEVrV7OH6yVc8Y7xlopXLAG/jqbRomF4ckbBsT2N0LZjB7jGJX4XRGyZOnLT" +
        "6SrufaTyget5hPSjgWgaXIKR0Zth4D7QGFeILQi0xpyaBA2ffsJmL6JwrMOZ" +
        "mxZTdF0sYAPzZkBHcxN7OCo0i53PPwOWzJG6mHHUEzoGkzWqu8uu/uOPwGNK" +
        "jun61QBN20xaOzhzzLNwHuz5+sveN1UooRpopsElGBk9GUbH/hbwklpqogtF" +
        "2g8+ITtq8LxwaiSFk8skPVgiFroOYjK4/wUr3CK0aO1lujDQcGBt3jpxTK88" +
        "B65cQ2d/sb9NJOaUQTRKcEthAZ2kIJR4DSTT4BKMjJ4M44DbRSOISi1s1YD2" +
        "y5PWxa5332Gz16fQWI7U7qTjC24MThjjDC975nBo3rql1zFxfYaHtLZwADeR" +
        "9yMSaHa+VSt65Rv3lLCNy9CVyeH9w1aHN30IBC+9GA56vaKrSgcaKKbBJRgZ" +
        "PRlG/Ref0a092Q9eS7Cgs0/MgTNd0uqiOMMJYxPZc9PBaUqWVVBixNaGHtFd" +
        "W60Wajx6GNiOBA4wh1tHsmfTF2Ax6WMdTU/wXmK3niNrBFTccC0c9vvYrAtp" +
        "rIFgGlyCkdGTYVQ//2zCZ9o4UwdB42efslnjdIC0CEpWLQdb5oi4w15gf3vt" +
        "b3tkYJRXe/aomAfPtQYLX68pCer+/hZzZ86GdsGBfD1fAx0cJ/e5+s7boPPA" +
        "AfYShDRUfzcNLsHI6MkwSjbcLKuGrhRY6FvHZ8OJ/fxWnWfOnKH7jO/fshl8" +
        "582k4xTs38vFknIOVN17F7S6nBAcM1rXrYoQmEecscV2pYV0tHYnOHJGc3+n" +
        "J/Aa8H0zZ42Cxk8+hlPk+QolRv3ZNLgEI6Mnwyi7/uqELkTDrqEdGx/jBruP" +
        "1NXCblKTds+eRsOAYCGj5EwgrO165s2AAp1E55UKRso9umNHr3vVU7s+/oje" +
        "L/bv9Abd6yRjKJSvuxwO+UQ3VaLUX02DSzAyejEMnD5aec062JrAbgw77uNQ" +
        "VNSdpyOVlTRKLe6QZzPJG5+QCg6Ux9OtpTVYyG5PSYq6TqX0pvW0m0/vrSbM" +
        "H67sx8i65aS1dzJMsEkh9dUfTYNLMDJ6MQzs9y5bszJhhoEFYPH119C8tBHT" +
        "KLliNTgyR9AWj5EKcq2g3Xc4pfYMWn3fwn273VPG6WIxphTwunBMyjdzMhxy" +
        "OdnLEdJA/c00uAQjoxfDONXeDiUrltCVz+xHrDa0dpmaBLWvvQrFV18B7vQh" +
        "tJtIyW6n/gYWrJ5li+Hskr3Iavz8MyhMVW7MRwvooHjaYNj558fFFNwEqD+Z" +
        "BpdgZPRiGKePHYPSi5cmxDBC2IlR4GZJeu8+0QO4PqTijg20KzGacCV48RVr" +
        "dLXRk1TwOj2L5sHBGANECsWv/mIaXIKR0Yth4LqHiqvWJqxLCjFaYZZIcJbY" +
        "rjdeYx9jn8J4UzYDTBcOB67dcOaMhtrf9nQX0k79wTS4BCOjF8NAVSV40Fsg" +
        "HYcpGZp//IF9hBG1l/zemzbYkMaMecaFisWXXUzD2QtpJ6ObBpdgZPRkGDit" +
        "NpFdUgJp4PgFblvbc0aZVJXdfAPYdBZrSipnZ1L9CTwzJsMhj5u9NCEVZWTT" +
        "4BKMjK4M4/57Er7SWyANS246HN29i32EUYUxslwYb8vAFQPsorJnjYS6v77B" +
        "Xp6QijKqaXAJRkZPhlHz2qvCMAwArkfxz58VdkW8FO397huwGmyRIgttZaUk" +
        "QclVa+HkkSPsJQqpJCOaBpdgZPRkGLjhDa62Zj9Ogb5AUy8nBSVOhY5VuN4G" +
        "w3AUpiVuH3IlwZlfwRVLaZReIW1kNNPgEoyMngzjSHk5uDOGGXJQdCCBLYyq" +
        "B+9jH19UHaqshJJr14E1NSkhiyHzVWq94tRb78zJcNDvZy9ZSCUZyTS4BCOj" +
        "J8PA+fqOvExDTr0cSBSkhI9S25dOk+eKe4W4xmfR/n/2eFpA43Utmgf5acrv" +
        "Fx8KYugca4J933/LXr6QSjKKaXAJRkZPhoFyL1lomDASAxVz2lDYt2Uz++jC" +
        "6kRLM/iXLyEmMyghrYoQGBG4+pEH6Tay9hR1Ylvh9eFmWI0ffsDeBiGVZATT" +
        "4BKMjN4Mo+blF8GqUteBQBk8eRnQvnMn++h66fTJk1D/6Sdgzxmti73ILcQk" +
        "Ku+8jeat+LqraTcS+xsloHu0Zw2H3W+9CV0ytvgVil16Nw0uwcjozTCwHxj3" +
        "WUh0ASMID92WddaUvuMrnTkDR0pLoWzd2u6xCj08SzSMKmIYOOiOA9TumZPp" +
        "gDX7OyXA68XQ75UP3kf3ZRdSX3o2DS7ByOjNME6TAsc+PkuMY+gUNAD/2svY" +
        "x/a7urpo7dqdpq8tWqlh3HMnNQxU8/ZtYM0Yzv1OSXDGX8XtG+jYnJD60qtp" +
        "cAlGRm+Ggap++EFwqNRlIJAP1pxxlfbu999jH1kvte/dQ2vwiRyzYMHWTu2z" +
        "T/faHAv3OlF7AaGNnLfqoQeokQqpLz2aBpdgZPRoGAfsNrDrrIYqOGsYGPpd" +
        "SkiQ+o8+BHNqsi66oxBqGM881cswukgh7p09TfXWrC8tGaofeai7dSOkrvRm" +
        "GlyCkdGjYXQcOADuWVNUr/0JYoNumpQzOuqmSSEFVy7TzYw3ahhPP8lvv7tj" +
        "B/jGpatuGg5TElRiOHjRPaWJ9GQaXIKR0aNhoDCUtAgToi/QwAPrLmcfVZ86" +
        "1lAPwbEpumhloGHUkXeKNQzU3q+/1CTCQGFKEux49OGweRBSXnoxDS7ByOjV" +
        "MFo9brBnj+I+OkFiwELflzYY9mz6gn1UEbXrrTfpugf2eFpjMSVDw9/+GrZ1" +
        "dPrECSi74TrVZk31xEXu4a43X4euMPkQUl56MA0uwcjo1TBQJWsvE91SOgG7" +
        "o2wZw6CztZV9TBGF02/dC+Yk/DmGDAM36gqn9l114J6Sy/2d0qDxluSMhD1f" +
        "bWKzIKSSEm0aXIKR0bNhNH73LdhUWpUriA0ci/BceD50yeiD3/PjD2BNT2yw" +
        "wfzRf4KGTz9hs9ZLLdu2git9iOqbeNEV4cR89333DZsFIZWUSNPgEoyMXg3j" +
        "WGMDeKaN19XUzIGMlRh33Ssvhe3SiaYz5G+CCW4tbifnbvjiczZrnCoff1ST" +
        "DZ7wvcbYUwfdLjYLQiopUabBJRgZPRoGmoX3vJl0S0z2QxMkhsL0YXDQ52Mf" +
        "lWS1794F9swR3HG1oiA1Gfb+9CObrbByL5xHgwmyx1AaNFDvzClwTGz5qpkS" +
        "YRpcgpHRm2G0N9SDd/4scOhgoFRwFqydB0ghGuv4Bava1/9CYzgloosR999o" +
        "zt/OZims2kpLwU5q/1q0brFSVHTZJXD6+HE2G0IqSWvT4BKMjJ4MA2uh7ql5" +
        "omWhM7aPPgeqn/wz+7hiFgbj81xwHt0Xmz2H2phJ62a/y8lmqU/VvfEanYqr" +
        "hbnZUgdB8XVXsVkQUlFamgaXYGT0YhjHScvCM32C6guoBLGBBaYrawQcLilh" +
        "H5ksHfJ5aXh0LWrvPbHkpMD+YJDNTkQFVi7X7H00kxb1bpz2K6SZtDINLsHI" +
        "6MEw0CywG0qENdcf2JfvXXYh+8hkCVc5dx46BKXrr6GzlthzqYljfBYcrq5m" +
        "sxRRp44eBXuu+qvAQzjR1Bx2NhtCKkoL0+ASjEyiDQO7obyzp6q2P4FAPqHF" +
        "es0F+exji6iujg44sb8FDvn9sPf772Dnm69D3ZN/hvKb1kNg+YVgzctQfepq" +
        "T7A14z13Ihzfu4fNalQd9HrAkjFckxYRHQSfNwNOHjnCZkNIRaltGlyCkUmk" +
        "YRwjZuGaOEaTGSmC2KHbjs49l31sVLS1QEyhrbwcmn75GWqeexr8V18B/qWL" +
        "wDtjEt04yZo+DMymwTTsRv5o5BzNaus9wcI+eP4cWYP22BVnGWPSLN9YcSoj" +
        "xiqkrcKZBqKEaXAJRiZRhkEHuGdM7r9mgQWMRoWMWuCeFk19bMWKs9lKiZk4" +
        "U5NoVyJOVMDB7M0j9bFhUk+2kXesbOVyOBXDTCT8be1LL0BR9kjueGqC9w83" +
        "EBMrwbUXln2sYWBLY0ttbVymwSUYmUQYBrYsPOfN1GSBlNZgYYldC67pE8A+" +
        "LoP7d6NAV3ZfMB+6TpxgH1+3AqRFgdeqN4NgwRZGyVVr2ez3KZxN5VuyEJym" +
        "JFqAs8dTGzync0wqjaQrpI36amG8u317XGaBcAlGRmvDwJg9rql5/XKAGwtO" +
        "JzFB7/lz4UhFBRRfeD6t3bK/MwKFuNDt26/Zx9dLuGudJUHrKmIBox6X3H4r" +
        "m31Opzo6oPz+e8BB9yFP7PuJRlx+7TqaJyF1paZZIFyCkdHSMKhZTByjWX+w" +
        "1njTBkMlKZhwH+dTx45B6UUXGNMwyPMJkrxL6cIxG6AVhWMnOzCsSQQd9vsh" +
        "MAc3U9LP87KakmFfFNMWik9qmwXCJRgZrQwDzcIze5oqG+pglwMWCtaMYXS6" +
        "phYzWnqCtUEnqZXiYq/QTge450HZmpWGMwy6DSsxvv02a6/n15d2PPMkOFP1" +
        "HSASB91xtlY4dR49CnWv/wXcWSN0V5Gh79WEbOg8cIDNtpAC0sIsEC7ByGhh" +
        "GNQs5kxXbcwCQ1eXbbgZ9lstUHz9NVBoGkKNSe1CDAd6sXAtuvRiaPV42MuG" +
        "wNrVuiuEIoH3C6+p7N672EvpU7hJkiVd+4V4UsFrcpBndJC0IMJp17vvQGnG" +
        "UNXfFTnQLk5ixmXrr2WzLRSntDILhEswMmobxtG6WtoNVajwQi38mLAw9mSP" +
        "goaPPuzeL/l0Zyc1Dv/i+eBNH6y4cYTO605NAt+C2dCyZXOf8+bL7r5D8wVq" +
        "8YDPyHnuJDhF7qFkYSTalct0OyaFz8uba4KOPgL8YaBLX+YwRd8RJcF82U3J" +
        "sOfrL9msC8mUlmaBcAlGRk3DoGMWk8eqUsvGmrB90tiIM0kOWszgX7YYzClJ" +
        "dPpuvIUCHgPjC3lmTYWmH74D6OpiT9lLNa+8ZJguKXxG2FI4XFzMXkZEYejy" +
        "fd98BRadBovEbh3bhGw2273kXXpBQuJbSYUuPCQt9JNtbWzWhWKU1maBcAlG" +
        "Ri3DOFZXB5655yoeSBALNnNqMpTeeL3kCJ8Yv6jyoQegePECsGWPpovJsBsL" +
        "a9RYoIQD/81CzlOI6wyyRkJg/iwov/cuaCUmJFV7vvuWxghir0GPYD8/7qMu" +
        "Z7+LozU1dAqxHrul8Fl6lixis9xLe774HJzkfWD/Vk+YyXuIW7sKyVcizALh" +
        "EoyMGobRXlcL7nMngVXBMYtQ/3ph5kjY88nHpHIfuXYfTl3EYA4XFcG+n3+C" +
        "xtdehfINN0PR6pXgWzwf3OfNBBepxXkvmE/T8N9qX3gWGkjtudXtgtPt7ezh" +
        "ouqQzwfuDP12dyCYN5xCWrRymaRZUeGEazVwnYMeu9+w5VD9zJNslnvpWP1u" +
        "GpxQj4YXgq7tmTKOhlwRil2JMguESzAyShsGmoUjL1PxFdw4YO5dMAfaa2vZ" +
        "U8oTMRwc98BWCgaZw+Y+gv8b0+iYiAxT6qnOgwfBNSaVuxY9gQWRfUI2nCR5" +
        "jUf1n34CVtJyY4+fSNAMcdX0vigbJ+E06JIbrlP8nVUaXFVfRyo6QrEpkWaB" +
        "cAlGRknDQLPARXlYCLEvu1yw1oddSBV3bIDTp0OTVo0jK6kV6rUgwu49a+YI" +
        "6GhuYrMds3BQ2amzNRl07+y0IXRgO5rqP/4ICkiBzB5DT9BxJtJiFWMZ0pVo" +
        "s0C4BCOjlGHQMYs50xWdLYNdWq5JY6D+g/fZ0xlGxeuvVWXQP16oWWSNpIED" +
        "Yx+1CC//Fat1ZY5YcbHkprHZDCtsuToxim6Y4+iF7mnPN9/AZl8ojPRgFgiX" +
        "YGSUMAz82HA2lJIzTSzYr75qBZ2Wa2Sh2blN2uzcFgs46N/42adsduNSS2EB" +
        "eNIG6+Za8X0suuZKyYboX7NK1+MYCN5b3NAKZyAK9S29mAXCJRiZeA2jfedO" +
        "cIxTbpMZ/CBwoVX1Exslz4LSs6iZpg3hrjORYBTa3Z9+wmZVEdkm5+qmleFJ" +
        "S4bdb73JZrFP7fnmK7BptC1rPGBsrPJ77mSzL/Sb9GQWCJdgZOIxDJxO6Tp3" +
        "omIFBJ0CmZcJTT98z57K0LKOz1LMUOPh7JTkJNj93rtsFhVTzUsv0EWN7LkT" +
        "Aa7CP+hxs1nsUzjRQe+zpUK4JmTT70+ot/RmFgiXYGTkGga+rO6ZkxUbs3Cn" +
        "D4Hiyy+FI5WV7KkMLwxbolZYlFjAhXm4Kl5NdezdAxbSokp0oYvnt5HKx7Gm" +
        "fWwWI6rykYcMsftjaF3GmThn8vUn6dEsEC7ByMgxDDQLnDobb7gPbPrjh41d" +
        "ULv+8oqstQ5GUNN334DLlLiFYbSbjxhy4+efsVkLKwx2dzrCPhiRhGsyMFSI" +
        "0gs2YwXXlpSuvQxOxfhOYRernkOFhMBWvWvWVDh57Bh7CQNSejULhEswMrEa" +
        "BjULhbpY0HDsY03Qkr+dPU2/Em4YZc0elZBaN54T423h3hVS5ZyaB/6JOWA/" +
        "dyJ4ll9I94hoePdtaN66BdrKyuDkgf10i1aErlXB1eE9VojXf/gBrQGzedES" +
        "XERY++rLPa5KmjDKsGvBnLgrQ1pgJ/f4QAyRB/qr9GwWCJdgZGIxDIzb5Jk5" +
        "Oe6Pia6tIC970drV0NHSzJ6m3wmDExZdskyV0O6RoLvmzZhMQ6PEInNu+tkV" +
        "4DgtFUOkELDr0WNKgkD2SAjmpdN9rl1zzoUgqcVX3HMn1JEW4r4vN9GZUnVf" +
        "f0UMcjSXHy3B7rd9xODkaNdbb9LCmD2m3sBWnO/ipWz2B5T0bhYIl2BkpBoG" +
        "HbOYFt9OeaF55AVpQ+jsFYwsO1BU++LzNF4Te0/UgE69JIW7f9mFsqZfWvIy" +
        "+2wN4bER7BJBQ6H/xZYiKWCdpJC2ZQyji8u2j9bmWvvCN2287MpIW2kpWDJH" +
        "9nkP9ALmDzdZwhbsQJQRzALhEoyMFMOgweXGmuKeDYUFC8aYwm6NgaYDbhfY" +
        "s0dx90RpsBDBcBg1jz4Mp2Vu7xnJMKQQz98qAc62C159BXtZkoX3LbhqhSLd" +
        "rmqDrb+y++9hL6HfyyhmgXAJRiaaYRypqgLnxJy4wn1gAYJRX8vJRyx3MNXo" +
        "wjUl/nkzVC1MaSjvrBFxT5uN1zASCbZ+bKQlt++Xn9nLkiQ6NnP6NJ0enJ/g" +
        "VpJUPJPHwukBNPhtJLNAuAQjE8kw0CywRSB3BXeoH9yekwI1f3kFumSEzu5P" +
        "qnj8UVXGMegU0tRBEFw0Dw5I3Fo1koxsGPRekPdNasXk5OHDcJi0eJu2bIa9" +
        "H7wPVQ/eB0WXXQI2uhhV+WelNNQg0wbT/A8EGc0sEC7ByPRlGG3YshifFZdZ" +
        "4FRS38J50FZS0vupD1BhGG2lw53TgHSkRl1x521wIs6IsyEZ2TAcKedA6d13" +
        "dF8LbvCEwtUKGIn4UHEx7P38Myh/8H4ovXINeGdOAXtuOt3W14L7pJC/x65X" +
        "I3RHhcAZYVX33d19zf1VRjQLhEswMuEM40h1NdjHpMTVDWUlNd6SW26E431s" +
        "XzpQ5bv0YsVaGVioO3NG0wCCoGAkXyMbhi9jKBxmKih1f38L/OfNBGduGt19" +
        "Eddo0Jl+BjKFSKC5BRbMhhMHDvS67v4ko5oFwiUYGdYwnrjxRnBNkR8PiPaj" +
        "k0Js11/fYJ+5EFGrww4BUqjF08rAAqKAtCqKlixUJTyEUQ0DTcCzeAF7ObD7" +
        "/ffAbxoEm8P8TX8An5UlcwQcCgbZS+8XMrJZIFyCkelpGMn/9I/wY8ZI2VNn" +
        "sQvKv3wJHPR62Wcu9JvowrB5M2S1MtBkaMj38VlQi2NCuMmTCjKqYTjI+9f4" +
        "ycfd3VAhYVeUOXt0XC1mvYNbAeNOlHK22NWzjG4WCJdgZEKGgWbx1fD/J2tR" +
        "HhYuaBbVjz8KJw8dYp+5EKN9P3wPlhgXhtExIfI3/kuW0QWUasqIhoGtLtfk" +
        "XGgPsyYBTRrHeORWhIwAfrcl11wJp3H1fT9RfzALhEswMmgYg4lZfE3MQk4N" +
        "DLuubNmjYO83X7HPWyiM8IPe9+3XYI4h5DkW3u6c0dAY40ZSXR0dcKKtjRaY" +
        "bK07koxoGPnEDCrv2NBnML6WgnzIT01cPC+1od8heW4Yy6s/qL+YBcIlGJk7" +
        "16+H94f835hbFnRtBWkG+y88X7l9tvuxcH5/W1ERlF2xmkbmZe9nX2BBGFyz" +
        "Ctrrd7OHjCxiELWvvASe3DQoveE62PvJx7SPu7O1lf0lJyMahi1jOOx32NlL" +
        "6daJ/S104NtIs59iAVug3szh0FZRwV664dSfzALhEoxKgLxcP6QNi3nq7Nl9" +
        "FZJh59NP0jhJQpF1tLoaqm67BWxZo6gxxzLgjYZRcfcdMbUQUPj7kuuvodNM" +
        "8ZwYEdhMClX//Fk03Hrjp5/A8YZ69s+oLOMyDGUYOB5UtHpl1J31Kh68D7b3" +
        "424pZ+og2P3uO+xlG0r9zSwQLsGI+MvLwZI9KubZUPhx+sZn0dk+sRZiA00Y" +
        "K6v6yT/TghrnyrP3Uio4DbTo0oujFoi91NUFzjnTuWOhEWChaSGG7yDP30sM" +
        "pPrpJ+i4SKgzx0Ker5EMA3cQlFKzPuj1gDV9KPf3/QWsGASvWstetmHUH80C" +
        "4RKMhr+sDMzj0mMaswh1QRWvWAIdMW5KM9DUdfw4tG7fBvZJY+jGSbG0KMJB" +
        "V8yTwsC3ZCFdmSxFuA8ETrWMVPDjcenCP3Jsb/oQsE3IgbJ77oTCLPVjXikF" +
        "DmQHr13HXn6fss+cEvGeGBkaBHLKOPaSDaH+ahYIl2Ak0CwKyUsldYObUHgP" +
        "7CPe8efH4dQAilkTq7DF1Wq1QPmVa8BKavBoyPGaRYjQc/BdcB5dMR5NR6uq" +
        "wGFKklw44vGxtSn1vdADeG02YopH66SPoe16521wpQ5S7LnoCTqTjrQaO/a3" +
        "sJeta/Vns0C4BKOA3VCFuekxFQoO8nFhPKlY91QYaDpWW0sjpFpJARbrBIJY" +
        "wO4pz+xp0NHcxGahlxq//AJ86YP7ZcEYwpaaBDseeSimrlGs8Jiz9B+6XA74" +
        "rJ2mZGiNYR/zRKu/mwXCJRgB2g1FCrNYuqHMpHAKrFmlWIyi/qqdzz8D1vRh" +
        "Md3beKBdD+PSI5pG1eOP0gFv9m/7C3Sq8eSxcLR2J3vpUVV2xwZw9tN7g63Q" +
        "epX3bVdKA8EsEC5B7/hKSqAwL0vyADcWSFhTrn3hOfYZC/0mXD3c8tOP4J0x" +
        "mRbMWtbk8VzYSrTkpsEhv797sLqnPEsv0DRPWoMtrZrnnmEvW5IwGCZu9sQe" +
        "sz+A324lqSzoXQPFLBAuQc/4SkuhYNJYyd1QGHrCt2A27Bd7Bfeppm1bIXDJ" +
        "RbTQQRNORMEcGgi3E9OgwQcZmcek9ts1B3jPPXNnwCmZOzbi3hGeRfMkV6CM" +
        "BJ0pFcMkgERoIJkFwiXoFR92Q+WkSIpbhIHZrCmD4IdFC+giJyFexxsbILB6" +
        "JdiIUehlrwTsmrFmDIM9333bK5/OzOEJMTK1oQPdaYPj25b0zBmoe+M1OrWY" +
        "Pb7RwUpC0arl7BXrRgPNLBAuQZeQZrc5a5TkfnUXKXTuzM7kdtwb8CKFC+6W" +
        "V//6X8CRNVLy/dQSNAZcPd7wW991i7mQBuLrb4ZBZwGR66p99WXmIcWuQ4EA" +
        "3XaYPYfRwYpfydKFNByM3jQQzQLhEvSGv6gIzBPHRG1ZYG0No1x+lTESJv3X" +
        "/6UPTxjG78JxisZNX9BNdtwxTFGNB3xm2D/PpkcDC1OLKRnqP/4Iat98Peqz" +
        "NyLY3eJfsVSReEm4qDJIjqXFM9USfA/8c6fTd1dPGqhmgXAJegLHLMzjs6KO" +
        "WdDwHsQsPl04Hwb/+791P0BhGGfVsvlX8F14Pt13Qsn1FH2BBZc95RzwzJ8F" +
        "wUsvhgIZpkEX4ZGWoo08f/bfjA7ef9xn5SBpGSil2r+9RTf6UvvZao13+gRJ" +
        "McO00kA2C4RL0As4dRZX90YbzMN/945JAd+WzXBDmB33BrKw5ll56020n3xb" +
        "lPuoFPg8sD+9+omNcPr0aTi6cyc4J2RzvxuonO2KSqKtJyWFXY0WA61ql4p3" +
        "ah506mT3vYFuFgiXoAf8xcVQmBN9W1WsuTrOnwPFO3bQB8buuDfgDePECSie" +
        "PVWT3dmwVYHPAxdGYpyjnqr/5GMaioX9m4EIhi4pv/3WXvdHkrq66CZTpzs6" +
        "aBfNyYMHob2lBdpramgstOZffwH7uRO58xkdvRiGMIuzcAmJxh8MQiGOWfTR" +
        "DYU1NKzF4sC2/f57ez0sYRi8cEe8aMYbL3RKbNZIqHnskT5DOZRhS0fjNR56" +
        "A2fu4RTmSGu5T7a10ZlhbaWl0FJYAA3ff0f3Dql74TmovPsOKFl3OfiXLATH" +
        "lHGkRTESguPSwJc1go5LsefrD+jBMIRZ/A6XkEjomMVYU59mgWCANgyE5//p" +
        "J+5hCcPg5V+9Mmq3XjzgWIV3wZyoW9lirdi/eAE1DfYYAwF8Bu5ZU6PGziom" +
        "huAcn0VnPeEYjtk0GCxpQ8CcmgRmcu/wOFgBCIEG3J9NGA3jxIH97G3STMIs" +
        "esMlJAo/MQsLhs6OULjRnbgWzoPS+oawD0sYBq8SUrNXY9EbHrMwJQl2kFZF" +
        "l8RFZ0crK8E2JrXfzeaRgn1MCm01RBM+r4Fqqix0ltScxM2SEmbBwyUkAl8g" +
        "AObcvkOU04HU9KHgueO2iA9KGAavqqef6PO+yuGsUZwDvnkzoDl/O3u6qKr/" +
        "4H1Sa+5/i8z6As3RkTkCGr//jr0VYbXr/fdo91J/bjVIBe+Bj7TK2utqz25u" +
        "puF6DGEW4eEStIaOWUzI7nPqLJoF9tf6fv456oMShsGr/rNPabdRvAUQXRuB" +
        "MZ8yhtGNlLCvXY5wn+qqe++i3Y7x5knvoLnayP1q+vEH9jb0qfbdu+hYB3us" +
        "gcp2ci9c2AW9dBHU3Hc3jVx8bFcde9sUlTCLvuEStMT/2wrucAuz6Fx1UtC5" +
        "li+Boto6SQ9KGAav5u3bwJ0W30ppWksmH66XtCqOlJfTGTvxCP/af/FSakDx" +
        "5EvP0DAnpFW87/tv6Qp7qcL90n0Tc/rtfZED3ks034LRg2jr1DU2FQLk/dnz" +
        "+Wcx3VspEmYRGS5BK3ykZWHJ7HvMAvdtdj/9ZEwPSRgGr4N+P3hJLVduAUQX" +
        "4ZGCr+rRh9lDxyXsl8YpuGoOyCcSjNHV8OEH7GVLkveixXRyB3tMwVlCMyWx" +
        "QmnNy4Ddr74MJw8dirsiI8wiOlyCFvi8XijMy+QKC3wRMJSEZWoeePNjf0jC" +
        "MHhh/28gZ1TMazHQyHGsAvfJPqBStN+2sjJwGGzP7WiEuqF2v/8ee7mSVb3x" +
        "MdqiY48t6A2WF/ie4q6DOKus9rln4GhNDXs7JUmYhTS4BLXxFRXRnfLYqbP4" +
        "8AMZQ8Fx7VVQ0tAo6yEJw+CFq71tpCUntVA+a9p/AmvGcKh77VXVo/02//wT" +
        "2EkBu1WFmVxaQ9cHjUmFli2b2cuMSS2ksiRmSkkH31kaSoaYLE5J3vn4ozGN" +
        "sQmzkA6XoCa+4mIwh9nNDf+/gxQa3k8+jusBCcMIL3P2KK41F47QuJFn7rlw" +
        "uKRE8f7hvrTnq03gTR/C5cdIoCFbclLgoNvFXl7Mwlqyb2wqdw6BNOhC0rxM" +
        "WhmJJmEWscElqIXP5wsbojwfF+JNmwDFbnfcD0gYRng550zn7jsLjfabNgQq" +
        "H7yP/XN19Zsp7frbX4lZGbMbBkOi4EyetooK5uLkCYPtuaaNl2TygvDQsTdT" +
        "MlTcsQFOtDSzt5hKmEXscAlq4KdjFlm9ZkNhAWY1JYPnpvWyu6BYhGGEl+/i" +
        "pVEX77kyh8Peb79m/1QTHdu7B0qvuVJWKPREg6uvcZOf9oZ69rJkC3fRK1mz" +
        "KuzsQUFs4OSBwPxZ3K6bwizkwSUoDR2zyB7da8wCCy9r1kjwf/apog9HGEZ4" +
        "lW64OWJtFZ+HfXwWHG9uYv9UdR2rqwPvrCk0PD2bL73jNCXDjo2PxdRfLkmk" +
        "1VVFjjuQDAPLB5xmTfd37/G/cbKG3Bl+3cfGymnmCNj53NPk1p4RZhEHXIKS" +
        "0M2P0ob26g7B7UBxE5/i0lLFH44wjPCqeflF8Kb2XSDTvZMvugA6cWqihjoc" +
        "CIB7Yo7kAXm9gPnNT0mSPW1Wiho+/ojGkWLP3R+hWxSQ9w9nlu169x2oeekF" +
        "KCGVHPcF88E/LQ8s5D7gO4r3PR7zMJNnlr92Nfzjf/tvwixkwiUohc/tBvMY" +
        "U7dZ4EtRmJoMtquvVO3BCMMIr3pSsHnT+i588NlU3nU7XTSmlfYXFoAta1TE" +
        "rjIsIPRmJnivfHOmwcFgkL0kRXXAbqMRgNnz90ewNVFx603sLaDC7VmPNTZA" +
        "w2efQvH114Bv5mQoNA2hU74jvTt9gef6bMp4GPJ//lOYhQy4BCXAdRbmvMzu" +
        "8A90kc24dPB8/rmqD0YYRnhhaApf+pA+a2eFqUlQ98Zr7J+pIuwSaHjn7zQC" +
        "a+Rusj/R1qkexjVC8/1xI6qqe+7UJNx2+6468EzJ5fLSH8FCvHT9tZKCWHa2" +
        "HoCmn3+CqrvvAFv2aHDK2G7YSszmq8zRkPaf/ynMIka4hHih3VC/7ZQXmqbp" +
        "WDAHiqqrVX8wwjDC65DXA4GsEX0aBgZ2bIpz7YAUnSYtmKoH76NdDJE+cswn" +
        "dsdgnureehPcxNAStU4D84IFmiM3Hfb+9CN0xbmaWLKIsbrmz4p4n/oLeH/L" +
        "brhOkmGEdObkSTpZYscTG+m7EmtrAyskBdMmKDbhZqDAJcSDz+8HMyl8Qg/P" +
        "SWpkjnvv0uyBCMMIr459e+n05b4KHw9pDbZhjCgVhbvF4RRHHCjuy7hC4AB4" +
        "5WOPdP/trnfeBkcC+vPxfmH8osDK5WejpcoUFoSBK1ZTykgLpYoUcg1/f4uu" +
        "P2ne/Cu0Oh3QVlJyNiprSzOcam+nhlFy0/qEGaWWyDGMnsL4Zt6F8+h709c7" +
        "Hg7sAXHOn61Z+dQf4BJk43TSFdw0/DWG9xifBT6FZ0FFQxhGeOEsnsK0342c" +
        "xTNrCnR1dLB/pphONDdBcN3l4MVd4frIA4JG4iStiSLy2279tk6j4aMP6cy6" +
        "SN1YSoI1UM/UcVD/3ru0Gy1eleFMsN9m/oRmAmFIC29aMvgyhtHwLcFcE5RO" +
        "yoHCzJFgIyaOCy7ZfPVH4jWMkHaT1qhj7O/jptHA9w2n3aJplDW3aFpWGRUu" +
        "QQ7Ysigcm0anr2H3gX3lCiipqND8AQjDCK/TpMZq7SNmE340/jWr2D9RTFj7" +
        "w3nwUqaIYo3Pt2A2dLS2soeh25riWIx9TKrqodHx+N4L5is2VoF5t8+exp2n" +
        "J3g9CE4jxQIPjTHc8+qPKGUYeJ9b3S5wz5gsORIy/gbfTd8lF2leXhkRLiFW" +
        "6OZHpPZKZ0GRJqH/macSduOFYYRX5/Hj4JozPWwBZCY1rB3PP8v+iSLqIC0L" +
        "19Q8Sa0CbP24xmVE3ZXuRNM+cEzM6XP/FKXArijX+XPp/gunFRi38K9cTvcl" +
        "Yc8jUM4wQrL98gt8nDGKth6kmAaST/Jg33BLwsouo8AlxAROnc0YTrugMHZL" +
        "4IcfEnrDhWGE18kTJyCwchlXcOPH5DAlw77Nv7J/oog6SOHuGp/JfZzhMKcm" +
        "Q/2777CHCCsMZe1fslD1GVRY83SZksAxfQI0fbkJOjEQo8xd34JrVwvD6AMl" +
        "DaPnorxH/vjvMVUsPOlDwPv/t3fm31FV2R7v1/3T+xtaCZNARjIAYQYFFARE" +
        "BAQUFbShRURwaNsBEdFWwAknaAVBpUWfQytCN2hLQmoeUlMqISEJEMKQBJkE" +
        "mSH73X2g6HDOvVW3KjXcU9nftT7L5a665w6hzveeaZ8PV6e0DjM6QkA3djuY" +
        "+mQrP6gMcD40Eyp27Ur5gybDUBcOOFc9No9NJ+R/JGXZna/sJZAAnVPKxZaN" +
        "1tgJwvqRs25kq9GjEQ5CVz25kKWXUWs5xQu8PjRarEwcAwqgfukSOO71svUB" +
        "0aj62afJMDSIl2HwK7j/9w9/gPd7ZOh+sWAZKHI6g89sTnldZlSEgB7YbCil" +
        "ZWHL6QKuv68yzMMlw1AXLsirfXERWHF6apsfCPaX24cW81+Pm3DsJHj/PWF/" +
        "sFhZuG4fxUwtWuE0XRyUxjUdegc6YwWNIzShAxcclk8cBwc3fc/6zfWo/o3l" +
        "imFor7bvyMTDMHizCPHVli1gHzlUaF1rgS8f7oEFEGxqNky9ZiSEQEQ8HrbQ" +
        "yzOoEHxOp6EeKhmGuvBteM/bbwiGgWtkAsoPNVHCCqBGaQWEyxPlyu4Euz94" +
        "jz80KuG4h7N/fsJNgwf3X3COGAxNX38VcZX8vvXryDA0aK9haJlFaFFesHE/" +
        "WxsWrqXbFjQNx/QphqrbjIIQCIfLZGJTG21TJxnyYZJhaKi1FQ5u+AwsWRnX" +
        "fhT4xowz2nCNQ8J0+TLsXbGMpXHgf5QhsJV6qraWPzJqnWluutKayYx+5W+s" +
        "4DNEk3IrpucYWAT7lNY23otaa6lpy2baFEmD9hhGJLMIUVGynf1b0/tvw6z8" +
        "VtzrPjZkPZdKhIAW7h07wDF8oKG6oHjIMLR1aPMPbG1B2x+FTTGMU3V1/Ffj" +
        "qoaP17AZKPwPEsHK1ja4b9yyvV46cwYa160Fd1FmwqfetiVkHGbsrirKgoq5" +
        "s6GJWzl/1G4DC7UwVInVMNAs/keHWYRwLF/G9sjgz68Gy+DcLw8q9jWqltVR" +
        "EQJquBSzsN86HPwG64LiIcPQ1uGyHbCjzWpprOT8g4rY3guJVNPmTWxgnf9B" +
        "Ijilt1KpXC+dO8cfFruU1hSumsa1H+ZM/dMq4wW+waIxW5S3Wf+4W+HQl1+w" +
        "yzq5axfbVZL/PhGbYThWfQDzR9+m2yxCOMaPFl6ctMBpubZ5D4ctr6MhBAQs" +
        "FvBI8tDIMLR11H1lCnTox4DTDT13jY/LKuZwarGYWf8x/2NEsKtqn9IiSIRw" +
        "L3NMkc26IXRWEInAqbTiHIox73plKZRqGGdHR49hYDcfzow7uPFzKBvWn6Xr" +
        "3zjrgajMgrF1q+608TgpxJ/XFXxKa1Eop4MiBNpSUVcH3q/+T5qHRYahreNV" +
        "VWDtk3Ptx4D96ZgIMNH7dp+sqWEL8vgfI1KW203YCS3eatn+M3jGjAALN+Cf" +
        "LEIrt/F5J7u1IwvhDOPCsWNweEcpy05rL84Dd07GlUXCyjHr7p8RnVlcxTLr" +
        "fnY8fx1q4N/MMbBQd9npjhCQGTIMbf3WuA9cQ/pdG/TDGT6Y/C7RLYwzTYfA" +
        "c/NA4YeIuIcPgNNx3NpUS+d+OQx73nwd3IU9WcuKKm5jgYbBpzf/bfdu2L3y" +
        "LfCOHXU1zf0fmfGG/nb4/+uvGkY0ZoEE9zWCQ6PVqwbu2e5OYQYLIyEEZIYM" +
        "Q1tnD7eAb/Qt1wzDUdgLjric/NfirounTkHFhDHCjxCvw3P/PfzXEyZM7oGV" +
        "EO7iZo0yqymRWNAwqp9cCLgU8pjbBd5Z94EFM0jgrDKNqbAhw4jWLEK4lizW" +
        "vZAS/63YlZetwN6GmM6VTggBmSHD0BbORKqYdAfrz2d5mwYVwamGvfzXEiLv" +
        "tElCBY1vbbgVZyq0d/UHbHEW5j7jr4tIPqxCVlqbzjEjwJPXVXeiSvtbb8Zc" +
        "gVcePATmgp66//6YjcD17jsxny9dEAIyQ4ahrcvnzsHOmTOuGUZg8oSEpQTh" +
        "hfs6tP1hYrcCDkYfcTr4ryZNuO1n3eLnwaJUGpgyhbqpUgt2N0UzFRq/W7lu" +
        "bbsqcMfiRWEXlbaFjUMNoLEMISAzZBjhVTnvz8ww8B9/EPdQTvD4RUh1ry+7" +
        "bqYSmoe5KIv/WtKFK+CP19RA5YJHwZ3XjRmp3gqLSC3xMAxfeTmU5evfc8Sh" +
        "tDJ8HXwxnxCQGTKM8Ao+9Tgzi5LMTrD73ZX8xwnTwe//yRa1hSpjnOWC/dRG" +
        "Em5jWz72VjBnJW+lOBE78TAMxD5tsuY4CQ92lZUNKW73OWVGCMgMGUZ41b2x" +
        "AkpwNXJuV2jatpX/OGE6YrexLVbRMBBMpdG44TP+a4ZQ06bvwH/HaDZXn4zD" +
        "uMTLMNzr1+nulsJ/u5j7zP3NN+0+r6wIAZkhwwivPWs/Yobh7JMFp3bv5j9O" +
        "mNjspPwe11oYdsWwcKqrUYVZdnFvDhzopC4qYxIvw0AshZlC+VrgS4Rj/G1x" +
        "Oa+MCAGZIcMIr4M/bGLJ+axD+vEfJVS41gOTVl5Jm6H84EYM5r9iPCnXXBpF" +
        "sjoiucTTMKwPz2ZTe/lzaGHO6w44/sGX0xEQAjJDhhFeR91usOMGMbPu5z9K" +
        "uMz9C9j4CQ4c1ix6lv/YkLKPGi5UFoQxiKdh4DYN2NXEn0ML3L7X/uYbcTm3" +
        "bAgBmSHDCK9fq6vBX9ADalOw/qF8ykT2to7ZQn8p2c5/bEgFn1wIDp2Lu4jk" +
        "Ek/DQMr65eneZIlNsZ18Z9zOLRNCQGbIMMIL1x5U9MuBIzYr/1HCVf3iCyz7" +
        "p6mgJ/y2r4H/2JA68PVXLHkgX2FoEVpwRuMeiSfehmF/bJ7ubil88Snr3QP8" +
        "lZVxO78sCAGZIcMIL1zt7R7WHy6eOcN/lHA1fLwW/DkZ4McFgydO8B8bUqcb" +
        "9rKcW3rGMXYoxuKeNIGltMCKJx3XdOA96XkWySDehlG+ZQvbt50/jxaOnM7g" +
        "+WJj/M4vCUJAZsgwIsv/8J/4UFLU8tOPEMjrCrv+9jL/kWGFK+Fx61e+suBh" +
        "GU2Vyga7/C6fPs2mDHunTwaXcizuN44pSLAbwyiVrV7QIDCFC27J7CzOA9fE" +
        "cWDKNcaeHtEYRmVzCwTttrDfraqvB/PViRn8udTA8zvnzglbZjoiBGSGDCOC" +
        "WlvZhkapEE6txUr1wLdf8x8ZVhfPnoXycbfpy22kmML+b7667vgz+xth/+Yf" +
        "oPalF8E36Q6wFvYCl2Ka2ALBCsdorRC8FjQ27DrEle+2vjmwc+5sOKAYIGYV" +
        "RgN1jxgsHJcK9BhGZTAIztdXgHNwHzCNGRn2u4ht7K2694VnOyz2y4tYZroh" +
        "BGSGDCOCFMPAnFKp0CWl8sU0DL9WVvIfGVa4aU/144+xnfv4CoMHd3Gre+sN" +
        "vgim1suXWXcgdnEdK9kOdcteBd+dY9kbrSenMzMQrKSTbSB4Lpam5er5ffnd" +
        "wTG4L+x6cREc3f4znDl4gP3d2so/c0ZSr1GLcIYRsFrB8cC9YCvKhFLlvvDe" +
        "rH/+k+p322J/YqFSbuS/NYLPwIubK/l8EctNJ4SAzJBhGFetFy+C/6EHVDfJ" +
        "MawUg21cv05XJYL7luMOf9HowqlTcNzjgd3vvws+5dk4bx4INsVEcOUxpvbG" +
        "86IRsQpaZ/oKLUJlYEWL5eI5rHndwa2cMzB7FjR8+gmc3rOHmVs41b/3ju6V" +
        "0YlEzTAqTWVgu2u8MO6E3w3o2c/iow+hNIp7QyPyr/0ocrlphBCQGTIM4+qy" +
        "YhhNWzbzYcOr+cdtbByCryx4sHUQbOf+HpgK8tyRX+DXmhrWdVe74jWo+utT" +
        "UKO8Hfun3Mm6g3DTKceAfNiRlSFcgxbYfeJUjq1d8CjsXLwIGpRKDvd4j2W1" +
        "/THljdqacyXNC3+eZIImUPXJOlZZe77+CmxjRrI3frXuQ9z3wv9t5HQeTvxb" +
        "53YVjtcCN+OyPTQzYrnphBCQGTIMgytJ2XHjqRPBINj6ZEccDMVsvMFJ41nX" +
        "UyKEXYlY9vmjR1nXlmf6ZN17leObcM2SxXyRMcs2qEg4R7LBv4d93G1gGzmU" +
        "JYzENRRqJoYx7PZz2+0RK/ZgVRVYirKEMrRgaUJwf3GVstIVISAzZBikeOvM" +
        "oYPgvXVYZMNQ8I4cAmebm/giEqL6N68kkuSvQw2sTOOZDqZm6RL21q5WQScT" +
        "NMxIfxe8Rn9RL6isr9dVsZuGFAtlaMFmx+X3gGBzi66y0wEhIDNkGKR4C9/s" +
        "A9On6HqbtxfnwYmaGr6IhKj5Pz+BLbeL7krbmds1bgsmT+P+8HnddJ87leA1" +
        "Bvr31l+h3zc9qvvCtP0+5W8ulJOmCAGZIcMgJULBvzyhyzCsBb3gsN3GH54Q" +
        "XTh2DKw6s6xiBYgp5fd99ilfTMxyTxynOl5gNPAaS/rm6q7QrQsf050ihJWP" +
        "g+9bt+ouX3aEgMyQYZASob0fr2HrLPjKggcHopu2/ps/PGHCSjtSl8y1a1Mq" +
        "Qc+UiXwRMevgd9+CKycjqrfxVIAVunnMCN0VuuO9d9g0Y733heW7V72vu3zZ" +
        "EQIyQ4ZBSoSaS0vAoaMLBivlxji+xUcSboiF2X8jXRfCBn/758P5I0f4YmLS" +
        "mQP7wa6Uh7PD+HMZCWxhlM95SHeFXrHpezb7Sc8zZeUr37UuWay7fNkRAjJD" +
        "hkFKhHCFs62wl1BZ8FiyOkGDUonjXuHJEM7gskeRHNGitICa45QpGNdr7Hrx" +
        "BV1rVFIJzhArf/kl3RV6pc+nGIb+e0LD2LFgvu7yZUcIyAwZBilRsg4bELH7" +
        "B1eE73rq8aQuTjQVZka8rhC46rkmjrm8cOtda/5NwnmMBO5zYVt/Zb2GHgIt" +
        "h8GiY91NCGyNlDy+QHf5siMEZIYMg5Qo+WbPitj9gpVH4N6pcCmJ2YD9D97P" +
        "prjy16IGrhqvvOduuHj6NF9MzPJMnqDbsFKBG9N3/OtfUVXojuI8+EmlLDWw" +
        "y8s0f15U5cuMEJAZMgxSolT/7ko20yhS33b56Fvg3MmT/OEJ0/4vNoJdp2Fg" +
        "xe4a0jdu02tRptWrwJoV+bmkArwmb2FPqHa5oqrQ3UOLdRsGPlP3w7OjKl9m" +
        "hIDMkGGQEqHfGveBc0i/iC0MlsivMJNNeU2WTu/dywbk+WvRwpTdma3hiIdK" +
        "S0vZ72xDYQ7ry+fPlWpYevacruCv3x1Vhe5STJ8vSwtsVZY++XhU5cuMEJAZ" +
        "MgxSvHXh9GnwzZjG9oXgKwseNIwdmTeyVODJEtuz4+ZButcOYGtgL2bVbefA" +
        "fMgskP5duoC7oKdwrlSDhmHqmwv+AwejqtC3jx/NBsv58tRg03YXPRdV+TIj" +
        "BGSGDIMUV7W2wr7VH4BZZ6I/7ALx5XWFI2U7+JISJhxgr1rwqO43fDQW79S7" +
        "4GI70ty3NQvkD7//PawaVAxWnV1jyQINwzFqWNSVuenBB3TfCz53x/JlUZ9D" +
        "VoSAzJBhkOKpE14PlClmoXdQF6eYesaMYPtIJFMN69eBSef0WqxEy3K7wXml" +
        "ZRKLeLMIseHLL8EysChit10ywSy9jrvviroyt85/JKoWhmfdx1GfQ1aEgMyQ" +
        "YZDipbOHW8Be3FvXDmzYssA9GKofmcOOS7aOWMxg6a1/emt5Tmc4vP1nvpiI" +
        "0jKLT0pKWIXp+PDvYMrUZ1zJgHVJDR8Iri+/gMDOnborddvCx3QbBpsZF+Wg" +
        "uswIAZkhwyDFQ5fOn4fgtEm63pax9eHr3Q1qX30lqesv2gpbNO5h/YVr0wKn" +
        "4VY9+zRfTFhFMosQtrGjhPOlElx7gnuSW/rmgPXOceBcugT8EXbJ8yx7VZdh" +
        "4IuCs3d3COw/ELa8dEIIyAwZBikeqlv+Ghu85isIHjQUS25X2P+PDWzzo1Sq" +
        "fNpk3bvy4XVblQpUr/SaBVJRXw+e3pHTqKQKlupdMZCyQUXgePopqLDZhHvw" +
        "vr5cl2Hgy4JtQKFwfDojBGSGDIPUXh22mMFR0DPiuAXrH1cq3V9+/g9fREqE" +
        "u/PpmcmFsMH5/Jt07a8ejVmEcK56H2xZkQ03VeD9M7PH1OR5XcHULw+cinl4" +
        "t26FioOHwKe0FrGriT+OB483zZim+RzSESEgM2QYpPbozOEW1rUTbtyCjVco" +
        "lYnv9pFwrLycLyJlwi1Xbdn6t07FCrHuvXf4Yq5TLGbh9XrBMftBXdl9jQA+" +
        "L2x1YOXvzO0CZsU8EP57amDXnmftGs1nkY4IAZkhwyC1R55Jd7ANcfiKoS2Y" +
        "7C8w6z6297aRhMkAywoiJ0gMgZVk+eQJfDHXFItZ2Ja9Bpb8HrpbOkZEz7gV" +
        "gkYTKOoFVdXVms8jHRECMkOGQYpV1YsXgSnCtqMm5a25at7DbDGf0YRbw1r7" +
        "ZAvXrAVLmzEgH04f2M8XFbVZVNbUgP32USz5In+edIWNhYwYovo80hkhIDNk" +
        "GKRY1LxtK5hztLc7Zf3dOZ3ZOEGqB7fVhJW++7ZbdL8ds4R52Z1h54JH4fyv" +
        "v15XVjRmEWw5DM7X/gZmpSxcj6D1/NIRHKPBsRr+maQ7QkBmyDBI0QqnpLqG" +
        "FWum1sDK1d0vBw798D1/qCF08eRJKL9rPGsd8deuBo6/OIf0heat/4bW1uvt" +
        "Lxqz8Hz3HVhHDWOtrkgTBNINvF9TbjfweTzCc0l3hIDMkGGQopV32iTNvanx" +
        "jd05qA/8WlHBH2YI4biFd8qdmtffFsy+imYRmDEVflPJdRWNWdhn3qe0KvSv" +
        "gE83cFKEfcpE4bl0BISAzJBhkKIRbnGKOYPUulLYHtgjh8CpvXv4wwwj/+xZ" +
        "bKaO2vW3hRlf/k1Qq7F5kl6z8GzaBM7iPFZepHOqgQajt9vMyGC6GNfGz8kw" +
        "ZIcMg6RXTf/aAi5MC85VYFipWbJuhJ0L56ckzYcetV68CLue+ytrWUSquC2Z" +
        "N7L8VkftNr4YJj1m4a2qAsfcOeDM7RpzhY/TeMvyuoPprvFsJpqsrRO2WC+G" +
        "hIbpghCQGTIMkh6drK8H56Ai1UrLkdMZ6lcsg8vtyOaaaNUuXRJ5nQOu5s7q" +
        "BLUvLtKcAqzHLFyvK62wfrkxz4AKrVsxD+sPXlMZK7fs6afAbuCFfVpgtx4u" +
        "9PNs2UKGkQ6QYZAi6eLZs+CfdZ/Q74/mUapUbI2ffsIfYijVr3wLnIqp8ZUZ" +
        "fy/+4jxo+XEbf/g16TELywMz2LoTvny9hMzCNXMGVLUcvq6Stb/wPBsw548x" +
        "MuxeFjzaYc0CEQIyQ4ZBiqQ9q95X3hKvn0KLacntfXOh2SBpPtR0WaHhw9VQ" +
        "nqu9mju0gVPF9ClhN3HSYxZI6dBi3fts8OAYkK0oE7wr39auYDEFR25XzRlq" +
        "RoLl3+pgeaPUEAIyQ4ZBCqemLZvB1GYzJKx4sUIsH3cbHAsE+K8bSpjgEBMd" +
        "apkFjhFY83vCnnfeDtudptcsEO/NA4Xz6AEH4i0TxoJfR9pvt9IKcgwsZGMt" +
        "WvdmBCx53aF829aI95PuCAGZIcMgaenX2lqw9cm+Nm6B/dGYP8g/fTKcT+Ie" +
        "3LEI80Thm7jamAuCpuceMwJOKfeIU221FI1ZIL5BRVFV4jjd1JbVCfwvv6Ra" +
        "nhaB3bvBMmmC5oy1VILXg/fkfu/dqO4pXRECMkOGQVLThZMnIThjKhujCFUE" +
        "uOFR1fxH+K8aTicqKsCUnaGZEBF32tv52Dy4dOYMf+h1itYscMzB0y9XdwXO" +
        "zKK4N/h++lG1PD24X3iOrRqPdSZWIsAV3dbnnon5ntINISAzZBgkNe1+6w02" +
        "ToEVAL6lm5W39YbVH/BfM5yOOh1gzuum2sePs5a8w4pZV1UkRWsWSHBvA7jz" +
        "ewjn5cHKHRfxuWfOgGDjfs3y9BJQWlOWieOYEeJ96zWseHMlHUwXcK5Y3u57" +
        "SieEgMyQYZB4NZeWgKt3d1YJsAytfbLh0Pf/NGROqLY67vGAvX++0LJg6wCU" +
        "yrTyT7Pgt927+cMExWIWiG/nzoizsbArrKz3TeD+9JOwZcWCZ8NnYBpYBO7s" +
        "jJgXCsZCaFzLlNcdfB10cV44hIDMkGGQ2urMoYPgKspiFQEbFC7uDb/V1Rne" +
        "LM4c2A/OwX1Vu2Zwu9F9az6E1kuX+MMExWoWiAcz0IZZe4HX5hjaD4IJTu/t" +
        "XPMRmAszde2AFw9wwN4xfjRUKv9O+GshyDBIaapLZ8+C586xrGLD7ijvuFs1" +
        "F7AZSTgW4bz1ZqGCxJaGe3h/OObz8Yeoqj1mgezcujWsYeD0XbtSmfPHJQrr" +
        "0iVgH1jIDBOfhdYEgFjAfyO497dVeblwvfpK0u5JRoSAzJBhkFCXW1uh5pWl" +
        "YMrsBBalgqmYOwfOHz3Kf81wOnfkCDM5NAvsGkGwcsRU5HXPPwPnjx/nD1FV" +
        "e80Cqfx0PTMMra4gW98cCNTW6i4vXri/2Aj2h2ay1uJ2lbGdSITuB7udrIrp" +
        "4YQC24gh4Fi+DCr2NiT9fmRDCMgMGQYJdbhkO5tt4+/dDfa89QZcOn+e/4rh" +
        "dE4xg8C0ydctlMNppo5+uWz9SLjpsm0VD7NAfO+sBIdGC4N1Rz3y56jKizdB" +
        "xawchZmahtbWIHBVP67SRiP25nYBZ2EvKBs+ENx/exkCTicEDzWl9F5kQgjI" +
        "DBkGCddUYNeCLbcrHPz2G/5jQwoNrXLubDbVN1TR4QC9b/pkuMBtcBRO8TIL" +
        "xLF4kWqXFFbAjpwuUKFjUV4iCTa3gCOvW0TDwBZa2cih4F6yGAKrV4HPbk/p" +
        "dcuOEJAZMoyOrUvKW3j57SPB1ScLWrb/zH9sSF04dw6qn3oCXNmdrs7QuYHt" +
        "i737zRVRDc7H0ywQy2PzVA0DW0DmCWNjKjOe+Pc2COM8ariybgRbAmZxdVSE" +
        "gMyQYXRcYeVa95cnIDhhDJzw+/mPDavKhfPBlp3BzMKp/Dc45U44YjHzXwur" +
        "eJsFUnrvVDZjqG3li9eIebh8ihnz3082VXabLsNw53QG95dfpPx60wUhIDNk" +
        "GB1Xjf/YAMF5D8P5Eyf4jwyr2mWvsjTlOOPHmp0BdS+9yMYyolEizAJx3TFa" +
        "6O7BbjLTzYPaVW688G/8PGIqEfzMndcN/Nu2GeKa0wEhIDNkGB1TZ1uaoXbF" +
        "aywFiAzCAezGDZ+B+eoU0bLePaAphj3DE2UWiHvUMJZvq20F7MjOAO/a5E2l" +
        "DYfrnZW6DMNT0BOqnQ5DXHM6IARkhgyjY+p04z62z4Us2v/FRnDldGaD3GyP" +
        "beX6o1UizQLBNQ9tK2OWUqUoGyoSvFBPL6bnnom4PS1esymnC1Tt2mWIa04H" +
        "hIDMkGGQjK6GT9aDXTELS243aPx4TcSkgWpKtFkg1sLM6ypfbAlZ586JW/nt" +
        "xfbwbNUcW21hizaV1pt/X6Nhrlt2hIDMkGGQjKymzZvYPuLltwyG4zHuv5EM" +
        "s0DMypt528oXFw96vv8+rudoD57pU4QuMx6WGLF/AQQOHjLMdcuOEJAZMgyS" +
        "UYUGgYvwMKV6NNNl2ypZZoG0TXrIEh4OHxj3c7QH6+gRYbujQoZhV8yZP5aI" +
        "HSEgM2QYJCPqmMsJ7gm3w8GNn/Mf6VYyzaKmvv7aIkKslHFwufz99+J+nvaA" +
        "mWx5g+BBw3Aqz50/logdISAzZBgkownXVNS+/BKc3LWL/0i3kmkWyE5TGdiz" +
        "r6wNwdYFLiTkv5NqSvN7CgbBw1KCPDDDcNcuM0JAZsgwSEbShePH4YjVAtAa" +
        "aydU8s0CCWzeDPasKyvPcaW0ffmyhJ0rFmoU87UW6DCMXjeA7dG5hrp22REC" +
        "MkOGQUonpcIsENwQCbcmxUrXktfNcHtDBOx25bqubIoVDlPmjeBa9Kyhrl12" +
        "hIDMkGGQ0kWpMgvEvvJttsbBhNlyZz+Y8PNFi+c/P7FtdnmD4MFtXv0rjNU6" +
        "kh0hIDNkGKR0UCrNAil77dUrhpHdGXybNiXlnNHg2Pi5YgYZgkG0BafcunK7" +
        "QPDjNYa7fpkRAjJDhkGSXak2C8T1xIIrU2lHDIFgU3PSzqsHXyAA1gEFYTdP" +
        "ws9wzwvXqvcNde3pgBCQGTIMkswyglkg7tkPsimptiWLk3reSHg9HrbTHu7P" +
        "zpsEDtCz5IhKq8j54P2AGyzxxxPtRwjIDBkGSVYZxSwQ69RJYMFNkgyUg8n1" +
        "4zaw9clm+3GoLdjDLjTL4L7gM9Bq9HRECMgMGQZJRhnJLBDzyKFgu3dqSs6t" +
        "hlt5DrgWBLvJeKPAlhDu2+5+6gnDXG86IwRkhgyDJJuMZhaI45ZBUGG1puz8" +
        "bfGXloC5MFNINIjmsaPXjeAYMQQCBtjQqaMgBGSGDIMkk4xoFohl/iMpPX8I" +
        "/6efgLeo13Vmgd1RlswbwJzfE2wvv2SI6+xICAGZIcMgySKjmkXNgQNQ5XKl" +
        "9BoQ76oP2AB221YFTpV1ZncC+z13Q6CyMuXX2BERAjJDhkGSQUY1C6Pg/nC1" +
        "YBYsTQOj+LoAAAJuSURBVElBD3AbLAliR0MIyAwZBsnoIrMIj3vtGnDn/XcV" +
        "N9vCNqsTOKdNhqr6enpGKUYIyAwZBsnIIrMIj/OVpWC/unETtihwqqxtSD9w" +
        "bvycno9BEAIyQ4ZBMqrILMJje+6vYMrsdG2qrC07A9x/eZKejcEQAjJDhkEy" +
        "osgswmNfsRysWZ3YVNmSXjeAY2gxBEu207MxIEJAZsgwSEYTmUV4LIueA4di" +
        "FuZefwRT75vA+fwz9FwMjBCQGTIMkpFEZhGesrlzWKoPZ3YGOKZOAp8BpvMS" +
        "4RECMsMbRsg0CCLZDBs2TPi3SGbxXzyz7lNaFTeAO/8mwDUX/OeEMRECMqNm" +
        "GARhFMgsrvLQA+DKyQBMclhVXU3PRCKEgMyQYRBGhcwCfhfY1wi+uyeCszgP" +
        "XGtpYyMZEQIyQ4ZBGBEyC/hdcG8DOEcMBv+TC6Gy5XCHfx6yIgRkBn+YaBoE" +
        "YRTILBSzUAzCPXcO4F7c/GeEXAgBgiCIeOJfvw6CjfvJLNIAIUAQBEEQaggB" +
        "giAIglBDCBAEQRCEGkKAIAiCINQQAgRBEAShhhAgCIIgCDWEAEEQBEGoIQQI" +
        "giAIQg0hQBAEQRBqCAGCIAiCUEMIEARBEIQaQoAgCIIg1BACBEEQBKGGECAI" +
        "giAINYQAQRAEQaghBAiCIAhCDSFAEARBEGoIAYIgCIJQQwgQBEEQhBpCgCAI" +
        "giDUEAIEQRAEoYYQIAiCIAg1hABBEARBqCEECIIgCEINIUAQBEEQaggBgiAI" +
        "glBDCBAEQRCEGkKAIAiCINQQAgRBEAShhhAgCIIgCDWEAEEQBEGoIQQIgiAI" +
        "Qo3/ByN6Uaz4wUyFAAAAAElFTkSuQmCC")

    OK_BUTTON = ("data:image/png;base64," +
        "iVBORw0KGgoAAAANSUhEUgAAAOkAAABaCAYAAABdaXE4AAATeElEQVR4Xu3d" +
        "d1hUd77H8SSbbNreFFN372Y3m3Kz2WRNNtl0s0nMpm1isGCJoogCGo1GjSWW" +
        "FE0wGrNREFA0dgWlCEibYegMRRAB6Qy9WEFFOsN9Pvf3G2YU53uUYVyR+/D9" +
        "4/Xgc/ie35wnz3n7O0Mx1x0CrmOM9V/kAGOsfyEHGGP9CznAGOtfyAHGWP9C" +
        "DjDG+hdygDHWv5ADjLH+hRxgjPUv5ABjrH8hB3pyuLgGaQXVSM2rQmp+NVLy" +
        "qpGce0ESYwNQ9wZkE7KNg0J6YTWydLUw76g3yAElhwvKoUrOgU9kOrwOJGOd" +
        "fyJ+3JuA1T5arPLW4gfvJKwUXLyTBfmRsYEm2dCAbGGV6OLHvYlYsy8BbgFa" +
        "/BKaAr/oDESnFVgVKzmgJCQxG17BWrjs1mDBZhVmeITD0S0cU9xUmOymhr1r" +
        "JCa5ajDRLYqxAUs2IFuQTUx1jYCTWxhmeUZg8RY1fvSJxrawFERZESo5YE51" +
        "MB8bgpPxzQ4NZnlFYIqnGp+4R8LWPQoj3ONg45GAYR6J+MhDKyQxNoBp8bFo" +
        "YbhoYqR7LEaLRiZ4RMJpgxrzxObmsicaO1RpSMjS9SpUcsAkNacE++MOwz1Q" +
        "i6XbozDDKxIOm6JhvysVdvsy8UlAPsYE6mAbXI6RwRUYEVzJ2IAnW7ANKsPY" +
        "wGKMD8iF3d4M2G9PwlQvDWZvisTy3dHYLB5/w8XbxyPFlRbFSg6YBMVnws0/" +
        "Hou3qjFtYyQmesVgwvYUOATlwTGyHE7xx+CsrYdzSgOcUs8ZNXb7M2MDibz3" +
        "G+Es/uycfBbOiXVwij2KqapSTPbPxoQtWthvjMJMLzW+3RGJTQe0Fr9HJQek" +
        "zOIabA1NxTIZqGc47DbFYvz2VEzyz8WM6ErMPXgKi7PPYXleK1YWdmB1sR6r" +
        "BPmRsYFKNiC5FLbjm9wWLMpswJzkE3BWl4odNQvjtyZhkgj1sw3hcNkdhYDY" +
        "LOsjPZhfBdcALWZvUMFOPFPb7UnH5OAifBpTgy/T67Ey7xw8S1qxt6oDobUd" +
        "iDzWRXNcD80xxgYgce/LBtTCgZoO7K5sh5uuBStyGvBFykk4aSphvz9PPI0m" +
        "w949Aot+icROVYb1kWpzKrHKJwGObhEY7RGD8f75mBpdi7npZ/BDQRM2l7ch" +
        "6GgHkk51Iue0HroznSg526W0gbGBR977soOiM3pk1Xci7qQevjXt8CxtxfLc" +
        "RsxKqcdkdSXG7snEGNdIzNqghldImvWRxh+pxHe7EzBpnQojPOIxNrgETto6" +
        "LMltxkYRaLD42yK5To8CcWHVjZ040dSJU82dqJNaGBuAxL1/SnRwXKhs/F/k" +
        "iGDjT+nhV9uOtSVt+CKrCZNjj8N2by5GrovCNHc1PIKvMNIVu7WYKIq38UzE" +
        "6APlhjfDKwra4VfdgVQRaHGDvJhOHDVGeqKZMSYjrRVNlJ/rNGxiCWJH3VHR" +
        "gcU5bZgcV4eR+wow3DUGTh4auAenX1mky0WkE1w1GOaZhFEhVZiWes7w5lgl" +
        "dtECsaUfFRdzzPg3h2R+sYwNRKYeZBs1Qla9Hv41enyd3wH7hDMY7lsMG9c4" +
        "OLpHiUgPWR9pXLaIdJeMNAofeiZjZGg1ph1sxE86PWLEG+Syhq7tXe6gpoti" +
        "jF1w0khuaMFH9fi2QESaeBY2fjoMM0a6PugKdtJLRbpG7KTRx/SGN8nyAo41" +
        "MsaUHDfKO61HUK0e38id9GpF+pFZpFHHur6ay5EydmnnIxWPu4E1fRjpj8Vd" +
        "3xPiSBm7PFOkudcyUvncLS9GfnWXMXYxU6zXLNJi8WZYRiovRn65mfVeRX0L" +
        "vIMiMHXGbLz93r/w7PMv4vd/eBh33HkXfvf7h/D0M3/DG2+/g0mO07HFJwBF" +
        "x86QNSyxeY8fHGd+jvH2U+EwbSZcvbaRmctRJaZh5ryFsJvijAkOTpi3+Ctk" +
        "l9aSOXYx0waWe/oaRiovwvzCWM8OFVZgzAR73H77b8R//essduNNN2HYyNFI" +
        "yi4ka17OXXcPImuV1zWTOSXh8am4+ZZbyPnfrVlHZtnFTDtqzrXYSSOPdqDo" +
        "dIeIVI+ac8xScuec++Uy3HrrbeSm7w0Zq/Nnc1B5po28hpI777qbrFF6spHM" +
        "mcsuO2rY0c3Pvf766xEal0Lm2cVqjTjS/ydKTpzD0Hc/IDf8lXjng48sis2a" +
        "SCtOt+KV198g50mfzplP5hl1PtI6PfZfq0iPKlwYo3QnGvDSq0PIzd7dY088" +
        "iU/Ee0a50y5dsdIQwnDbcYqPqt29MfQdVDd0kNfszppIHcX7ZPNzpH++/yGq" +
        "zraTeUaZIj1yrSItrO+KtLqB9WTK9M/IzW4y5I2hCIlNIeeYlNe1YIt3AO69" +
        "/wFyrsn3P7mS87pTirTkRCOZM3HdtJ3MS08+9TQKa0+TeaasxujIKRFpdR9G" +
        "Kn92V13bFan8W0JeTBW7JL/wGMN7OPMbXrIRO2WZiND8HCXa7CL86dHHyRrS" +
        "bbfdjtS8UnKOiVKkOhGp+ZwUkZiOW269lcwPuvc+JOfoyDy7NBmo7ENGGlBt" +
        "/NndqxnpKBGpc7dIC0Sk8iLML4xd7KnBz5IbXpry6SxUnu0g85eTXXYMzz7/" +
        "AllLmjF3IZk3sTTS7PLjhm8Bmc/++uabEaCOJ/Ps8kw7ava1iFQlIs2v64q0" +
        "8iy7lAMxKeSGl0aNsyOzlsqtqjPsnOZr3v/gb8Wu3ErmJaVIi483XjRTVt+G" +
        "18Sjt/mc9PPGrWRN1rMqoywRqX9fRHr+cbfoQqTVChfGLhg70YHc8JJKm0Fm" +
        "e+NS6273CyGzkiWROs+aR2YkuUObr8csQyLN64NInVMvjpR30stT+srs319+" +
        "lcz1VlBUEllX+nzhUjIr9RSp+9Y95PPSex/aoOJMB1mPWeaaRhohIs2TO6kx" +
        "0gpGxB8uIDe95Lp5J5m1xp+f+itZ+613PyBzklKkRSJS+TlV0mHFH6548unB" +
        "yD96lqzFLGeKNVP+EyrXItLcuq4vepSfZUrWiRjNb3wZQ/HJZjJrjbmLvybr" +
        "3/fAg2ROUoq0UESaVXESf3j4EfI5+e2e5Lwysg7rHVOsh69VpDkiUnkB5hfG" +
        "ujjP/oLc/I88/gSZs9Zq901kfamkvo3MKkWaJ3bJf7z9Ljkuf043UDxOm6/B" +
        "rNdnkcqv7sp/nfsHGenRrh91kpGWnWFKbCfYkwBe+cdbZM5aW30PkPWlw+Un" +
        "yaxSpFM+Vf6JorXiCcD8fGYdGaj8KCP1re7EMhHppL6IdGWhHqG1Xd/7KTut" +
        "R8npDqbg3Y+GkwBsxownc9YKjk0j60txWToye4dCpEpmzl9CzmXWKzVKP9mJ" +
        "vVWdWJorIk3og0i/L9AjSGzdh07oUSh20/xTTMlLQ94kETjOXkDmrBWfU0nW" +
        "v+GGGxCdWUpmLY10o08IOZdZr0D+u9TiY8rxTuyp7MSSnKsdaUg1HFOasDxf" +
        "bN0VemjFI2/mcT0yhEOMePq5F0kETl8sI3PWiso/RtaXApLyyKylkd559z0I" +
        "O1xOzmfWkW1IseLJc3uZHl/m6DExXkTqexUjnSoi/TpPD+9yPWJqOpB6tAPJ" +
        "IlZGPf/aGySCkZOnkzlrecdlk/WloIxyMvtfd9JI5363lhyTBr/wKhKrWska" +
        "rPdSjB/V1R34pVSPhUc6+iDS5CZ8JSLdVdaByOp2aGs7kCgkMGLIe8NIAG9+" +
        "OILMWevnvRFkfUldfJrMKkWqKW3A0I9tyXFp/Iz5ZA3We7INKbyqHV4lHVjQ" +
        "l5HuLBWRVslI25FQw5S8b2tHbv7BL75K5qy1ZN0Wsv6vbryRzElKkUaJSMML" +
        "TuJ3f/wT+Zz8rZ3VOwLJOqx3Eo3CKtuxUdeHkS7L1WOH+FtBXdV1AfFSNTNn" +
        "O5X+Dul/P/wombPWtCUuZP2HHnmczElKkWpKGgyf2xiixY033kQ+f8ddg+B3" +
        "sISsxSxnijW0oivS+dl9FWmOjLQdKvG3Q4K4kDimaMGaDeTGv/GmX+NAznEy" +
        "a43nhrxF1n9nxCdkTlKKNLLk3PnPT1+2inxeeur5lxBV3kTWY5aRocqPMtIN" +
        "xe2Yn9VHkX4lIt2pE5FWtCG+qg2xTJFXmPKvqc1e8TOZ7a1d8XmKv0g+a/m/" +
        "yaykFKla13D+8zGVrXjxrffIjDTGeQ5Zj1kmziikXOykMtI+3Uk50h7JnUrp" +
        "MfLRvwwms701dtpcsq60OSKNzEo9RSoFZtbgnvt/S+Ykly0BZE3WswuRtnXt" +
        "pH0TaaMh0u26NkRwpD16aej75IaX5C5rPmspGf+dg+4laz7+9LNk1sSSSKWf" +
        "fVS4/oYbyKw8f29yMZlnlycDlR8NkRa1iUjb+yZS+bi7o1hEWt4qLqLV8KjE" +
        "lH2zwZvc8NLLQz8wxGY+35Po8mYMm+BI1pPmuLiSeROlSFXFZ8mcNHH2YjIr" +
        "Pfm3FxBZ2vtrHshijQ6UtfZdpFNEpEvlTmqMVF6AvJhopkhd0qC460nPvfYW" +
        "QvJOknMuRa715kejyDrSoPseRGjeKXKOiVKkEcVnyJykKWvCX194lcxLto6z" +
        "yTy7NFOs1yTSbSLScGOk5hfGLrbgJy9ys5s89tQz8DtUQc4xF5pfh+eGKP/7" +
        "Q9KKTb7knO56E6nkk1Ji+BaM+TmWvBa7wLSBBYtIPUWkX/R1pGHihWMqWhHF" +
        "evT862+Tm93krnvuw/DJM7DWNwr7M2uhKW8xnBOYdRTuQYmwdfrcsFOan2cy" +
        "1GYMeT1zSpGGF50hc92t2ORHzpF+c8dd2K0tIvOMija6ZpGGlskLaYFGXAS7" +
        "vH1p5fjj//yF3PBX6pV//guhIjbz1zOnFKkl541wmEnOk5545nmE6xrIPFMW" +
        "VNoKj0IRaVZfRJrUhKVHOrC1SD5ny0BbEMksEpBViyee/Tu54a319ohPEFFy" +
        "jryOEuVIT5M5c2HikVg+kpufK412nkPm2cVMfewvbemKNLMddjLSq/mrag4i" +
        "0iUi0i0yUvHCkeXNUDOLhRTWw3Gxi+GR0fymt9RDj/0Z328LJGtfjlKk8lrM" +
        "55RsjcnGLQr/i8ZbbrvdELH5PLtA9iHtL2mBu4h0Xl9HGlzadQHmF8Z65p9Z" +
        "g6mLvsPgl1/HrxR+4MGcjOzNj8dgsdt2w2Om+Xo9kT9A0X29Qfc9YNiFzecu" +
        "5asN3oYoL1rj/gc50h6YIg0wRNrat5H+UtTCkf6HBOWewM9+0fjGay8+X+lu" +
        "MP3rH7Hgp834fnsQPMNSehWUElVZE/Yk6wy7ovxozXpy592lLTSssTu52Ko1" +
        "BhpTHwElzVhvjNTwnrRPIi0UkZbIi2gy3ACMMUptZIi0oI8ilV/dlZFuLhQ7" +
        "QEnXBciLiShljJkzxeqvk5G29F2ki4+0n49UpXBhjLEupj78dU1wM0TadvUj" +
        "degWaaB4YZUINUIIZ4wRsg3Jr7gr0rlZbf/ZLxzFHxGR7paRajDMM8n4nrQR" +
        "i7Lb4ZnfbHjhUBFqqLiIMEnHGDORXUgh4s8+Rc1Ymy8iFTupXdwZ2PgWw8YY" +
        "qXvwoSuLdIWIdKJrJD721GLUgUo4aBswP7MVa/OasVPspgEi1GBd14UYgmWM" +
        "GcgmgnRdu+jWgmasymnB7IxW2MXWY7hvEYa7xsLJQyMivcKddMXuBBGpCjae" +
        "CRgdXIbJCacx53ALVh5pFrtpE3YVNiGgqAkHihsRxhg774CI01e0sV00sl60" +
        "8m12M2amN2FizEmM3JcvIo2Gk7taRJpmfaSJOZVw8U6Ag5sKIz3iMCagAJOi" +
        "j2FG6lksPXwOq3Ma4SFefEdBE/aJC/EX/BhjBj7CNtGGW14TXLIbsfDQOUxL" +
        "Pg07dTVsvbNhK95GzvBUY2PIFUSakluJn3wT8amHCuM8ojDWJxN2YaVwjD2G" +
        "z1PqsUSE+p3YUf+d24z14vHXM6+FMWYkm1gj2lie3YRFhxrwWdIpOETVYHxw" +
        "EcbuSMMEsfnN84rElvAreE+aVlANzyAt5nuFw8E9HOO3JGCcdwYmiBeZKkL9" +
        "VOyoszOaMU+8R12Q1YaFWe2MMSPZxFzRxqxDTZgudlCHqGp8sj8f43aJQDfF" +
        "wGl9GL7apoa3JsP6SKW9mkNY5R2NeZtVcNykwYStiSLUw4YdVT762sfXG/5/" +
        "i5O15xhj3dgnNsA+4Qzs4+owSdO1g8pAJ/4Sh2mipUVbVHD1j0dYUs6VRRqX" +
        "UYw9mnSs8YvH/G0aQ6hyRx3rnYnR/vmwDSzBqKByjAyuZIx1F1Qh2iiD7X4d" +
        "xvjlYdzudNhtjsP0zRos2RmF9YGJCIjLRHpe+ZVFKqXlVyAgIRs/+saJHTUC" +
        "DmKbHueuwQj3GNi4x+Nj9wQMc9fiI48kQX5kbCCTHSSJJhINbdi4x2GUaGX8" +
        "ejWcxNvGL7eq4R6UBNXBfBzR1VgUqEQOmDsoQt0dmYbV4tF3waYIw1elpqxX" +
        "YZKrWogUNJjoFsUYM5JNyDbsXcVbRdHKrA0qLP4lAmv94hCYkGVxnCbkgJJ4" +
        "8ejrG50BrwPJWBeQhNX7tFjpIyXBxScZLt5JjDET0YRsQzayxlcLt/1J2BKa" +
        "gqD4LKTlWvaI2x05cDmHi2uRXliD1PxqJAsp8mNeNZIYY+fJJmQb0kFBNpOl" +
        "q+11nCbkAGOsfyEHGGP9CznAGOtfyAHGWP9CDjDG+hdygDHWv5ADjLH+hRxg" +
        "jPUv5ABjrH8hBxhj/Qs5wBjrX8gBxlj/8n+40mjYFLSgCgAAAABJRU5ErkJg" +
        "gg==")


# Original file: KarelFrameViewer.py

"""
This file creates a stack frame viewer for Python Karel programs.
"""

class KarelFrameViewer(GCompound):

    """
    This class acts as a view for the model/controller combination
    supported by the KarelVM class.
    """

    def __init__(self, width, height):
        """Creates a new KarelFrameViewer object."""
        GCompound.__init__(self)
        self._width = width
        self._height = height
        self._frame_dx = KarelFrameViewer.DEFAULT_FRAME_DX
        self._frame_dy = KarelFrameViewer.DEFAULT_FRAME_DY
        self._frame_width = KarelFrameViewer.DEFAULT_FRAME_WIDTH
        self._frame_height = KarelFrameViewer.DEFAULT_FRAME_HEIGHT
        self._frame_stack = [ ]
        self._last_frame_displayed = None

    def push_function(self, code, baseline, width=None, height=None):
        """Pushes a frame containing code whose first line is baseline."""
        if width is None:
            width = self._frame_width
        if height is None:
            height = self._frame_height
        self.push_frame(CodeFrame(code, baseline, width, height))

    def push_frame(self, frame):
        """Pushes a frame onto the stack but doesn't display it."""
        x = len(self._frame_stack) * self._frame_dx
        y = len(self._frame_stack) * self._frame_dy
        frame.set_location(x, y)
        self._frame_stack.append(frame)

    def pop_frame(self):
        """Pops a frame from the stack."""
        if len(self._frame_stack) > 0:
            frame = self._frame_stack.pop()

    def clear(self):
        """Clears all frames from the display."""
        self.clear_highlight()
        self.remove_all()
        self._frame_stack.clear()

    def update_frames(self):
        if self.get_current_frame() != self._last_frame_displayed:
            self.clear_highlight()
            self.remove_all()
            frame = None
            for frame in self._frame_stack:
                self.add(frame)
            self._last_frame_displayed = frame

    def set_frame_size(self, width, height):
        self._frame_width = width
        self._frame_height = height

    def get_frame_width(self):
        return self._frame_width

    def get_frame_height(self):
        return self._frame_height

    def get_current_frame(self):
        if len(self._frame_stack) == 0:
            return None
        else:
            return self._frame_stack[-1]

    def set_highlight(self, line):
        cf = self.get_current_frame()
        if cf is not None:
            cf.set_highlight(line - cf.get_baseline() + 1)

    def clear_highlight(self):
        cf = self.get_current_frame()
        if cf is not None:
            cf.clear_highlight()
        
# Constants

    VISIBLE_TYPES = {
        Scanner.WORD,
        Scanner.NUMBER,
        Scanner.STRING,
        Scanner.OPERATOR,
        Scanner.COMMENT
    }

    KEYWORDS = { "def", "if", "else", "while", "for", "in", "range" }

    DEFAULT_FONT_FAMILY = "'Monaco','Monospace'"
    DEFAULT_POINTSIZE = 18
    DEFAULT_SPACING = 21
    DEFAULT_FRAME_LEFT_MARGIN = 6
    DEFAULT_FRAME_TOP_MARGIN = 18
    DEFAULT_FRAME_DX = 10
    DEFAULT_FRAME_DY = 20
    DEFAULT_FRAME_WIDTH = 400
    DEFAULT_FRAME_HEIGHT = 300
    DEFAULT_VIEW_LEFT_MARGIN = 6
    DEFAULT_VIEW_TOP_MARGIN = 6

    STRLIT_COLOR = "#006600"
    COMMENT_COLOR = "#009999"
    KEYWORD_COLOR = "#CC6600"
    BUILTIN_COLOR = "#993399"
    ERROR_COLOR = "#FF0000"
    CODE_COLOR = "Black"
    DOCSTRING_COLOR = STRLIT_COLOR
    STRING_COLOR = STRLIT_COLOR
    NUMBER_COLOR = CODE_COLOR

class CodeFrame(GCompound):

    """
    This class implements one frame in the frame stack.
    """

    def __init__(self, code, baseline, width, height):
        GCompound.__init__(self)
        self._code = code
        self._baseline = baseline
        frame = GRect(width, height)
        frame.set_filled(True)
        frame.set_fill_color("White")
        self.add(frame)
        self._gci = CodeImage()
        self._gci.set_code(code)        
        self.add(self._gci)
        self._highlight = None

    def get_code(self):
        """Returns the code for this frame."""
        return self._code

    def get_code_image(self):
        """Returns the CodeImage object for the frame."""
        return self._gci

    def get_baseline(self):
        """Returns the baseline for this frame in the source code."""
        return self._baseline

    def set_highlight(self, line):
        if self._highlight is not None:
            self.remove(self._highlight)
        self._highlight = self._gci.create_highlight_box(line)
        self.add(self._highlight)

    def clear_highlight(self):
        if self._highlight is not None:
            self.remove(self._highlight)


class CodeImage(GCompound):

    def __init__(self):
        GCompound.__init__(self)
        self._family = KarelFrameViewer.DEFAULT_FONT_FAMILY
        self._pointsize = KarelFrameViewer.DEFAULT_POINTSIZE
        self._spacing = KarelFrameViewer.DEFAULT_SPACING
        self._left_margin = KarelFrameViewer.DEFAULT_FRAME_LEFT_MARGIN
        self._top_margin = KarelFrameViewer.DEFAULT_FRAME_TOP_MARGIN

    def set_code(self, code):
        if not isinstance(code, str):
            code = "\n".join(code) + "\n"
        self._nlines = code.count("\n")
        self._font = "bold " + str(self._pointsize) + "px " + self._family
        self._ufont = "bold " + str(self._pointsize) + "px " + "'Monaco'"
        self._linemap = { }
        space = GLabel(" ")
        space.set_font(self._font)
        self._cwidth = space.get_width()
        scanner = Scanner(code)
        prev = -1
        while scanner.has_more_tokens():
            token = scanner.next_token()
            ttype = scanner.get_token_type(token)
            if ttype == Scanner.STRING:
                color = KarelFrameViewer.STRING_COLOR
            elif ttype == Scanner.NUMBER:
                color = KarelFrameViewer.NUMBER_COLOR
            elif str(token) in KarelFrameViewer.KEYWORDS:
                color = KarelFrameViewer.KEYWORD_COLOR
            else:
                color = KarelFrameViewer.CODE_COLOR
            if ttype in KarelFrameViewer.VISIBLE_TYPES:
                row,col = token.get_start()
                x = self._left_margin + col * self._cwidth
                y = self._top_margin + (row - 1) * self._spacing
                if row != prev:
                    if prev != -1:
                        self._linemap[prev] = (start,end)
                    start = x
                    prev = row
                lines = str(token).split("\n")
                for i in range(len(lines)):
                    x = self.add_token(lines[i], color, x, y)
                    if i == len(lines) - 1:
                        end = x
                    else:
                        x = self._left_margin
                        y += self._spacing
        if prev != -1:
            self._linemap[prev] = (start,end)

    def add_token(self, token, color, x, y):
        parts = str(token).split("_")
        for i in range(len(parts)):
            if i > 0:
                label = GLabel("_")
                label.set_font(self._ufont)
                label.set_color(color)
                self.add(label, x, y)
                x += label.get_width()
            label = GLabel(parts[i])
            label.set_font(self._font)
            label.set_color(color)
            self.add(label, x, y)
            x += label.get_width()
        return x
        
    def create_highlight_box(self, linenum):
        linenum = min(self._nlines, linenum)
        if linenum in self._linemap:
            start,end = self._linemap[linenum]
            x = start - 2
            w = end - start + 4
        else:
            x = self._left_margin
            w = 5
        y = self._top_margin + (linenum - 2) * self._spacing + 4
        h = self._spacing
        box = GRect(x, y, w, h)
        box.set_color("Red");
        box.set_line_width(2)
        return box

# Test program


# Original file: KarelParser.py

"""
This abstract class defines a Karel parser using Python syntax.
"""

TRACE_TOKENS = False

class KarelParser(Parser):

    def __init__(self):
        Parser.__init__(self)
        self.init_parser()
        self._statement_stack = [ ]

    def next_token(self):
        trace = TRACE_TOKENS and len(self._scanner._saved_tokens) == 0
        token = Parser.next_token(self)
        ttype = self.get_token_type(token)
        while ttype in { Scanner.NL, Scanner.COMMENT }:
            token = Parser.next_token(self)
            ttype = self.get_token_type(token)
        if trace:
            print(token)
        return token

    def init_parser(self):
        self._block_operator = KarelBlockOperator()
        self._statement_operator = KarelStatementOperator()
        self._def_keyword = KarelDefKeyword()
        self.define_operators()
        self.define_statement_forms()

    def create_token_scanner(self):
        return Scanner()

    def define_operators(self):
        LEFT = Operator.LEFT
        RIGHT = Operator.RIGHT
        self.define_operator("(", KarelParenOperator(), 0, 110, RIGHT)
        self.define_prefix_operator("not", KarelNotOperator(), 100)
        self.define_infix_operator("and", KarelAndOperator(), 30, LEFT)
        self.define_infix_operator("or", KarelOrOperator(), 20, LEFT)
        self.define_prefix_operator("corner_color_is",
                                    KarelCornerColorIsOperator(), 110)
        self.define_prefix_operator("random", KarelRandomOperator(), 110)

    def read_module(self):
        module = self.create_module()
        while True:
            token = self.next_token()
            ttype = self.get_token_type(token)
            while ttype == Scanner.STRING:
                self.verify_token("<NEWLINE>")
                token = self.next_token()
                ttype = self.get_token_type(token)
            if ttype == Scanner.EOF:
                break
            if token == "import":
                token = self.next_token()
                self.verify_token("<NEWLINE>")
                module.add_entry("import", Identifier.create(str(token)))
            elif token == "def":
                self.save_token(token)
                module.add_entry("function", self.read_function())
            else:
                raise SyntaxError("Unexpected token: " + str(token))
        return module

    def read_function(self):
        token = self.next_token()
        start,_ = token.get_start()
        if token == "def":
            fn = self.read_function_entry()
            token = self.next_token()
            self.save_token(token)
            end,_ = token.get_start()
            fn.set_bounds(start, end)
            return fn
        else:
            raise SyntaxError("Illegal top-level definition")

    def read_function_entry(self):
        name = str(self.next_token())
        self.verify_token("(")
        self.verify_token(")")
        self.verify_token(":")
        self.verify_token("<NEWLINE>")
        body = self.read_code_block()
        token = self.next_token()
        pos = Constant.create(Value.create_integer(0))  # // Update pos later
        self.save_token(token)
        fn = Compound.create(self._def_keyword,
                             Identifier.create(name),
                             [ ], [ ], body, pos)
        return fn

    def define_statement_forms(self):
        self.define_statement_form("if", KarelIfStatement())
        self.define_statement_form("for", KarelForStatement())
        self.define_statement_form("while", KarelWhileStatement())
        self.define_statement_form("paint_corner",
                                   KarelPaintCornerStatement())
        self.define_statement_form("set_paint_color",
                                   KarelSetPaintColorStatement())

    def read_statement(self):
        token = self.next_token()
        ttype = self.get_token_type(token)
        while ttype == Scanner.STRING:
            self.verify_token("<NEWLINE>")
            token = self.next_token()
            ttype = self.get_token_type(token)
        if ttype == Scanner.EOF:
            raise SyntaxError("Unexpected end of input")
        self.save_token(token)
        start,_ = token.get_start()
        pos = Constant.create(Value.create_integer(start))
        op = self.get_operator(token)
        if op is None or not op.is_statement():
            token = self.next_token()
            exp = Compound.create(Identifier.create(token))
            self.verify_token("(")
            self.verify_token(")")
            self.verify_token("<NEWLINE>")
            return Compound.create(self._statement_operator, pos, exp)
        self.next_token()
        return Compound.create(self._statement_operator, pos,
                               op.prefix_action(self))

    def read_code_block(self):
        statements = [ ]
        token = self.next_token()
        ttype = self.get_token_type(token)
        while ttype == Scanner.STRING:
            self.verify_token("<NEWLINE>")
            token = self.next_token()
            ttype = self.get_token_type(token)
        self.save_token(token)
        self.verify_token("<INDENT>")
        token = self.next_token()
        ttype = self.get_token_type(token)
        while ttype == Scanner.STRING:
            self.verify_token("<NEWLINE>")
            token = self.next_token()
            ttype = self.get_token_type(token)
        if ttype != Scanner.DEDENT:
            self.save_token(token)
            while True:
                statements.append(self.read_statement())
                token = self.next_token()
                ttype = self.get_token_type(token)
                while ttype == Scanner.STRING:
                    token = self.next_token()
                    ttype = self.get_token_type(token)
                if ttype == Scanner.DEDENT:
                    break
                self.save_token(token)
        return Compound.create(self._block_operator, *statements)

    def compile_function(self, fn):
        args = fn.get_args()
        body = args[3]
        cv = CodeVector()
        self.compile(body, cv)
        if len(args) == 5:
            cv.add_instruction(SVMOp.STMT,
                               args[4].get_value().get_integer_value())
        cv.add_instruction(SVMOp.RETURN, 0)
        return cv

    def compile(self, exp, cv):
        type = exp.get_type()
        if type == Expression.CONSTANT:
            self.compile_constant(exp.get_value(), cv)
        elif type == Expression.IDENTIFIER:
            self.compile_identifier(exp.get_name(), cv)
        elif type == Expression.COMPOUND:
            self.compile_compound(exp, cv)

    def compile_constant(self, value, cv):
        type = value.get_type()
        if type == Value.DOUBLE:
            cv.add_instruction(SVMOp.PUSHNUM,
                               cv.string_ref(str(value.get_value())))
        elif type == Value.INTEGER:
            n = value.get_value()
            if (n & 0xFFFFFF) == n:
                cv.add_instruction(SVMOp.PUSHINT, n)
            else:
                cv.add_instruction(SVMOp.PUSHNUM, cv.string_ref(str(n)))
        elif type == Value.STRING:
            s = value.get_string_value()
            cv.add_instruction(SVMOp.PUSHSTR, cv.string_ref(s))
        else:
            raise SyntaxError("Illegal value: " + str(value))

    def compile_identifier(self, name, cv):
        cv.add_instruction(SVMOp.PUSHVAR, cv.string_ref(name))

    def compile_compound(self, exp, cv):
        fn = exp.get_function()
        type = fn.get_type()
        if type == Expression.OPERATOR:
            fn.compile(self, exp.get_args(), cv)
        else:
            self.compile_call(str(fn), cv)

    def compile_call(self, name, cv):
        tag = cv.new_label()
        cv.add_instruction(SVMOp.PUSHSTR, cv.string_ref(name))
        cv.add_instruction(SVMOp.CALLM, cv.string_ref("Global.is_defined"))
        cv.add_instruction(SVMOp.JUMPT, cv.label_ref(tag))
        cv.add_instruction(SVMOp.PUSHSTR,
                           cv.string_ref("Function " + name + " is undefined"))
        cv.add_instruction(SVMOp.THROW, 0)
        cv.define_label(tag)
        cv.add_instruction(SVMOp.PUSHSTR, cv.string_ref(name))
        cv.add_instruction(SVMOp.CALLM, cv.string_ref("Global.get"))
        cv.add_instruction(SVMOp.CALLFN, 0)

    def read_t(self):
        token = self.next_token()
        if token is None:
            raise SyntaxError("Unexpected end of line")
        ttype = self.get_token_type(token)
        if ttype == Scanner.WORD or ttype == Scanner.OPERATOR:
            op = self.get_operator(token)
            if op is None:
                self.verify_token("(")
                self.verify_token(")")
                return Compound.create(Identifier.create(token))
            if op.is_statement():
                raise SyntaxError("Illegal context for " + str(op))
            return op.prefix_action(self)
        else:
            raise SyntaxError("Illegal condition " + str(token))

    def define_statement_form(self, name, op):
        self.define_operator(name, op, 0, 0, Operator.LEFT)

    def parse_constant(self, token):
        ttype = self.get_token_type(token)
        if ttype == Scanner.NUMBER:
            if str(token).find(".") >= 0:
                return Constant.create(Value.create_double(float(str(token))))
            else:
                return Constant.create(Value.create_integer(int(str(token))))
        elif ttype == Scanner.STRING:
            s = eval(str(token))
            return Constant(Value.create_string(s))
        else:
            raise SyntaxError("Illegal constant: " + str(token))

    def push_parser_context(self, break_label, continue_label):
        sc = KarelParserContext()
        sc.break_label = break_label
        sc.continue_label = continue_label
        sc.next_label = None
        self._statement_stack.append(sc)

    def pop_parser_context(self):
        self._statement_stack.pop()

    def get_statement_depth(self):
        return len(self._statement_stack)

    def set_next_label(self, s):
        self._statement_stack[-1].next_label = s

    def get_next_label(self):
        return self._statement_stack[-1].next_label

    def get_break_label(self):
        return statement_stack[-1].break_label

    def get_continue_label(self):
        return statement_stack[-1].continue_label

    def create_module(self):
        return Module()

# Constants

class KarelAndOperator(InfixForm):

    def compile(self, p, args, cv):
        tag1 = cv.new_label()
        tag2 = cv.new_label()
        p.compile(args[0], cv)
        cv.add_instruction(SVMOp.JUMPF, cv.label_ref(tag1))
        p.compile(args[1], cv)
        cv.add_instruction(SVMOp.JUMP, cv.label_ref(tag2))
        cv.define_label(tag1)
        cv.add_instruction(SVMOp.CALLM, cv.string_ref("Core.FALSE"))
        cv.define_label(tag2)


class KarelBlockOperator(Operator):

    def __init__(self):
        Operator.__init__(self)
        self.set_name("BLOCK")

    def compile(self, p, args, cv):
        for arg in args:
            p.compile(arg, cv)


class KarelDefKeyword(PrefixOperator):

    def prefix_action(self, p):
        return p.read_function_entry()

    def compile(self, p, args, cv):
        cv.add_instruction(SVMOp.PUSHFN, cv.label_ref(args[0].get_name()))


class KarelForStatement(Statement):

    def prefix_action(self, p):
        token = p.next_token()
        ttype = p.get_token_type(token)
        if ttype != Scanner.WORD:
            raise SyntaxError("Missing required variable name")
        p.verify_token("in")
        p.verify_token("range")
        p.verify_token("(")
        token = p.next_token()
        type = p.get_token_type(token)
        if type != Scanner.NUMBER:
            raise SyntaxError("Missing repeat count")
        count = p.parse_constant(token)
        p.verify_token(")")
        p.verify_token(":")
        p.verify_token("<NEWLINE>")
        stmt = p.read_code_block()
        return Compound.create(self, count, stmt)

    def compile(self, p, args, cv):
        count = args[0]
        stmt = args[1]
        tag1 = cv.new_label()
        tag2 = cv.new_label()
        tag3 = cv.new_label()
        p.push_parser_context(tag3, tag2)
        index = "i_" + str(p.get_statement_depth())
        max = "n_" + str(p.get_statement_depth())
        cv.add_instruction(SVMOp.VAR, cv.string_ref(index))
        cv.add_instruction(SVMOp.VAR, cv.string_ref(max))
        p.compile(count, cv)
        cv.add_instruction(SVMOp.POPVAR, cv.string_ref(max))
        cv.add_instruction(SVMOp.PUSHINT, 0)
        cv.add_instruction(SVMOp.POPVAR, cv.string_ref(index))
        cv.define_label(tag1)
        cv.add_instruction(SVMOp.PUSHVAR, cv.string_ref(index))
        cv.add_instruction(SVMOp.PUSHVAR, cv.string_ref(max))
        cv.add_instruction(SVMOp.LT, 0)
        cv.add_instruction(SVMOp.JUMPF, cv.label_ref(tag3))
        p.compile(stmt, cv)
        cv.define_label(tag2)
        cv.add_instruction(SVMOp.PUSHVAR, cv.string_ref(index))
        cv.add_instruction(SVMOp.PUSHINT, 1)
        cv.add_instruction(SVMOp.ADD, 0)
        cv.add_instruction(SVMOp.POPVAR, cv.string_ref(index))
        cv.add_instruction(SVMOp.JUMP, cv.label_ref(tag1))
        cv.define_label(tag3)
        p.pop_parser_context()

class KarelIfStatement(Statement):

    def prefix_action(self, p):
        exp = p.read_e(0)
        p.verify_token(":")
        p.verify_token("<NEWLINE>")
        s1 = p.read_code_block()
        token = p.next_token()
        if token == "else":
            p.verify_token(":")
            p.verify_token("<NEWLINE>")
            return Compound.create(self, exp, s1, p.read_code_block())
        p.save_token(token)
        return Compound.create(self, exp, s1)

    def compile(self, p, args, cv):
        tag = cv.new_label()
        p.compile(args[0], cv)
        cv.add_instruction(SVMOp.JUMPF, cv.label_ref(tag))
        p.compile(args[1], cv)
        if len(args) == 3:
            tag2 = cv.new_label()
            cv.add_instruction(SVMOp.JUMP, cv.label_ref(tag2))
            cv.define_label(tag)
            p.compile(args[2], cv)
            cv.define_label(tag2)
        else:
            cv.define_label(tag)


class KarelNotOperator(PrefixOperator):

    def compile(self, p, args, cv):
        p.compile(args[0], cv)
        cv.add_instruction(SVMOp.NOT, 0)


class KarelOrOperator(InfixForm):

    def compile(self, p, args, cv):
        tag1 = cv.new_label()
        tag2 = cv.new_label()
        p.compile(args[0], cv)
        cv.add_instruction(SVMOp.JUMPT, cv.label_ref(tag1))
        p.compile(args[1], cv)
        cv.add_instruction(SVMOp.JUMP, cv.label_ref(tag2))
        cv.define_label(tag1)
        cv.add_instruction(SVMOp.CALLM, cv.string_ref("Core.TRUE"))
        cv.define_label(tag2)


class KarelParserContext:

    def __init__(self):
        self._next_label = None
        self._break_label = None
        self._continue_label = None


class KarelParenOperator(Operator):

    def prefix_action(self, p):
        exp = p.read_e(0)
        p.verify_token(")")
        return Compound.create(self, exp)

    def infix_action(self, p, lhs):
        p.verify_token(")")
        return Compound.create(lhs, Expression[0])

    def compile(self, p, args, cv):
        p.compile(args[0], cv)

    def unparse(self, p, args):
        return "(" + p.unparse(args[0]) + ")"


class KarelPaintCornerStatement(Statement):

    def prefix_action(self, p):
        p.verify_token("(")
        token = p.next_token()
        if token == ")":
            p.verify_token("<NEWLINE>")
            return Compound.create(self)
        if p.get_token_type(token) != Scanner.STRING:
            raise SyntaxError("paint_corner requires an argument")
        p.verify_token(")")
        p.verify_token("<NEWLINE>")
        return Compound.create(self, p.parse_constant(token))

    def compile(self, p, args, cv):
        nargs = len(args)
        if nargs == 1:
            p.compile(args[0], cv)
        p.compile_call("paint_corner", cv)
        cv.add_instruction(SVMOp.NARGS, nargs)

    def unparse(self, p, args):
        if len(args) == 0:
            return "paint_corner()"
        return "paint_corner(" + p.unparse(args[0]) + ")"


class KarelSetPaintColorStatement(Statement):

    def prefix_action(self, p):
        p.verify_token("(")
        token = p.next_token()
        if p.get_token_type(token) != Scanner.STRING:
            raise SyntaxError("set_paint_color requires an argument")
        p.verify_token(")")
        p.verify_token("<NEWLINE>")
        return Compound.create(self, p.parse_constant(token))

    def compile(self, p, args, cv):
        p.compile(args[0], cv)
        p.compile_call("set_paint_color", cv)
        cv.add_instruction(SVMOp.NARGS, 1)

    def unparse(self, p, args):
        return "set_paint_color(" + p.unparse(args[0]) + ")"


class KarelCornerColorIsOperator(Operator):

    def prefix_action(self, p):
        p.verify_token("(")
        token = p.next_token()
        if p.get_token_type(token) != Scanner.STRING:
            raise SyntaxError("corner_color_is requires an argument")
        p.verify_token(")")
        return Compound.create(self, p.parse_constant(token))

    def compile(self, p, args, cv):
        p.compile(args[0], cv)
        p.compile_call("corner_color_is", cv)
        cv.add_instruction(SVMOp.NARGS, 1)

    def unparse(self, p, args):
        return "corner_color_is(" + p.unparse(args[0]) + ")"


class KarelRandomOperator(Operator):

    def prefix_action(self, p):
        p.verify_token("(")
        token = p.next_token()
        if token == ")":
            return Compound.create(self)
        if p.get_token_type(token) != Scanner.NUMBER:
            raise SyntaxError("Illegal argument to random function")
        p.verify_token(")")
        return Compound.create(self, self.compile_constant(token))

    def compile(self, p, args, cv):
        if len(args) > 0:
            p.compile(args[0], cv)
        p.compile_call("random", cv)
        cv.add_instruction(SVMOp.NARGS, len(args))

    def unparse(self, p, args):
        if len(args) == 0:
            arg = ""
        else:
            arg = p.unparse(args[0])
        return "corner_color_is(" + arg + ")"


class KarelStatementOperator(Operator):

    def __init__(self):
        Operator.__init__(self)
        self.set_name("STMT")

    def compile(self, p, args, cv):
        cv.add_instruction(SVMOp.STMT, args[0].get_value().get_integer_value())
        p.compile(args[1], cv)


class KarelWhileStatement(Statement):

    def prefix_action(self, p):
        exp = p.read_e(0)
        p.verify_token(":")
        p.verify_token("<NEWLINE>")
        stmt = p.read_code_block()
        return Compound.create(self, exp, stmt)

    def compile(self, p, args, cv):
        tag1 = cv.new_label()
        tag2 = cv.new_label()
        p.push_parser_context(tag2, tag1)
        cv.define_label(tag1)
        p.compile(args[0], cv)
        cv.add_instruction(SVMOp.JUMPF, cv.label_ref(tag2))
        p.compile(args[1], cv)
        cv.add_instruction(SVMOp.JUMP, cv.label_ref(tag1))
        cv.define_label(tag2)
        p.pop_parser_context()

# Original file: KarelVM.py

"""
This module implements the extended virtual machine for Karel.
"""

class KarelVM(SVM):

    def __init__(self):
        SVM.__init__(self)
        self.define_builtin("move", KarelMove())
        self.define_builtin("turn_left", KarelTurnLeft())
        self.define_builtin("pick_beeper", KarelPickBeeper())
        self.define_builtin("put_beeper", KarelPutBeeper())
        self.define_builtin("front_is_clear", KarelFrontIsClear())
        self.define_builtin("front_is_blocked", KarelFrontIsBlocked())
        self.define_builtin("left_is_clear", KarelLeftIsClear())
        self.define_builtin("left_is_blocked", KarelLeftIsBlocked())
        self.define_builtin("right_is_clear", KarelRightIsClear())
        self.define_builtin("right_is_blocked", KarelRightIsBlocked())
        self.define_builtin("beepers_in_bag", KarelBeepersInBag())
        self.define_builtin("no_beepers_in_bag", KarelNoBeepersInBag())
        self.define_builtin("beepers_present", KarelBeepersPresent())
        self.define_builtin("no_beepers_present", KarelNoBeepersPresent())
        self.define_builtin("facing_north", KarelFacingNorth())
        self.define_builtin("not_facing_north", KarelNotFacingNorth())
        self.define_builtin("facing_south", KarelFacingSouth())
        self.define_builtin("not_facing_south", KarelNotFacingSouth())
        self.define_builtin("facing_east", KarelFacingEast())
        self.define_builtin("not_facing_east", KarelNotFacingEast())
        self.define_builtin("facing_west", KarelFacingWest())
        self.define_builtin("not_facing_west", KarelNotFacingWest())
        self._function_names = { }
        self._function_bounds = { }
        self._function_code = { }
        self._app = None
        self._world = None
        self._frame_viewer = None
        self._code_window = None
        self.set_step_mode(SVM.BY_STATEMENT)
        self.add_stop_hook(self.stop_hook)
        self.add_call_hook(self.call_hook)
        self.add_return_hook(self.return_hook)

    def import_turns(self):
        self.define_builtin("turn_right", KarelTurnRight())
        self.define_builtin("turn_around", KarelTurnAround())

    def import_paint(self):
        self.define_builtin("paint_corner", KarelPaintCorner())
        self.define_builtin("set_paint_color", KarelSetPaintColor())
        self.define_builtin("corner_color_is", KarelCornerColorIs())

    def import_random(self):
        self.define_builtin("random", KarelRandom())

    def set_world(self, world):
        self._world = world

    def get_world(self):
        return self._world

    def set_app(self, app):
        self._app = app

    def get_app(self):
        return self._app

    def define_builtin(self, name, method):
        self.set_global(name, Value("SVMMethod", method))

    def init_model(self, gw):
        self._gw = gw
        self.set_model(self)

    def create_timer(self, delay, callback):
        timer = GTimer(self._gw, callback, delay)
        timer.set_repeats(False)
        return timer

    def define_function(self, name, fc, bounds):
        self._function_names[fc] = name
        self._function_bounds[name] = bounds

    def get_function_name(self, fc):
        return self._function_names.get(fc)

    def get_function_bounds(self, name):
        return self._function_bounds.get(name)

    def set_function_code(self, name, code):
        self._function_code[name] = code

    def get_function_code(self, name):
        return self._function_code.get(name)

    def set_frame_viewer(self, viewer):
        self._frame_viewer = viewer

    def set_code_window(self, window):
        self._code_window = window

    def speed_to_cycle_count(self, speed):
        """Overrides more complex mvc.py definition."""
        return 1

    def signal_error(self, msg):
        """Passes an error back to the application."""
        self._app.show_error_dialog(msg)

    def stop_hook(self):
        if self._frame_viewer is not None:
            self._frame_viewer.update_frames()
            line = self.get_statement_offset()
            if line is not None:
                self._frame_viewer.set_highlight(line)
        if self._code_window is not None:
            if self.get_stack_depth() == 0:
                self._code_window.clear_highlight()
            else:
                line = self.get_statement_offset()
                if line is not None:
                    self._code_window.set_highlight(line)
            
    def call_hook(self):
        if self._frame_viewer is not None:
            if self.get_state() in { SVM.STOPPED, SVM.STEPPING }:
                name = self.get_function_name(self.peek_back(0).get_value())
                code = self.get_function_code(name)
                bounds = self.get_function_bounds(name)
                if bounds is not None:
                    start,end = bounds
                    self._frame_viewer.push_function(code, start)

    def return_hook(self):
        if self._frame_viewer is not None:
            if self.get_state() in { SVM.STOPPED, SVM.STEPPING }:
                self._frame_viewer.pop_frame()        

    def clear_viewer(self):
        if self._frame_viewer is not None:
            self._frame_viewer.clear()
        if self._code_window is not None:
            self._code_window.clear_highlight()

    def clear_highlight(self):
        if self._frame_viewer is not None:
            self._frame_viewer.clear_highlight()
        if self._code_window is not None:
            self._code_window.clear_highlight()


class KarelMove(SVMMethod):

    def execute(self, svm, receiver):
        svm.get_world().move()


class KarelTurnLeft(SVMMethod):

    def execute(self, svm, receiver):
        svm.get_world().turn_left()


class KarelTurnRight(SVMMethod):

    def execute(self, svm, receiver):
        svm.get_world().turn_right()


class KarelTurnAround(SVMMethod):

    def execute(self, svm, receiver):
        svm.get_world().turn_around()


class KarelPickBeeper(SVMMethod):

    def execute(self, svm, receiver):
        svm.get_world().pick_beeper()


class KarelPutBeeper(SVMMethod):

    def execute(self, svm, receiver):
        svm.get_world().put_beeper()


class KarelFrontIsClear(SVMMethod):

    def execute(self, svm, receiver):
        svm.push_boolean(svm.get_world().front_is_clear())


class KarelFrontIsBlocked(SVMMethod):

    def execute(self, svm, receiver):
        svm.push_boolean(svm.get_world().front_is_blocked())


class KarelLeftIsClear(SVMMethod):

    def execute(self, svm, receiver):
        svm.push_boolean(svm.get_world().left_is_clear())


class KarelLeftIsBlocked(SVMMethod):

    def execute(self, svm, receiver):
        svm.push_boolean(svm.get_world().left_is_blocked())


class KarelRightIsClear(SVMMethod):

    def execute(self, svm, receiver):
        svm.push_boolean(svm.get_world().right_is_clear())


class KarelRightIsBlocked(SVMMethod):

    def execute(self, svm, receiver):
        svm.push_boolean(svm.get_world().right_is_blocked())


class KarelBeepersInBag(SVMMethod):

    def execute(self, svm, receiver):
        svm.push_boolean(svm.get_world().beepers_in_bag())


class KarelNoBeepersInBag(SVMMethod):

    def execute(self, svm, receiver):
        svm.push_boolean(svm.get_world().no_beepers_in_bag())


class KarelBeepersPresent(SVMMethod):

    def execute(self, svm, receiver):
        svm.push_boolean(svm.get_world().beepers_present())


class KarelNoBeepersPresent(SVMMethod):

    def execute(self, svm, receiver):
        svm.push_boolean(svm.get_world().no_beepers_present())


class KarelFacingNorth(SVMMethod):

    def execute(self, svm, receiver):
        svm.push_boolean(svm.get_world().facing_north())


class KarelNotFacingNorth(SVMMethod):

    def execute(self, svm, receiver):
        svm.push_boolean(svm.get_world().not_facing_north())


class KarelFacingSouth(SVMMethod):

    def execute(self, svm, receiver):
        svm.push_boolean(svm.get_world().facing_south())


class KarelNotFacingSouth(SVMMethod):

    def execute(self, svm, receiver):
        svm.push_boolean(svm.get_world().not_facing_south())


class KarelFacingEast(SVMMethod):

    def execute(self, svm, receiver):
        svm.push_boolean(svm.get_world().facing_east())


class KarelNotFacingEast(SVMMethod):

    def execute(self, svm, receiver):
        svm.push_boolean(svm.get_world().not_facing_east())


class KarelFacingWest(SVMMethod):

    def execute(self, svm, receiver):
        svm.push_boolean(svm.get_world().facing_west())


class KarelNotFacingWest(SVMMethod):

    def execute(self, svm, receiver):
        svm.push_boolean(svm.get_world().not_facing_west())


class KarelPaintCorner(SVMMethod):

    def execute(self, svm, receiver):
        world = svm.get_world()
        if svm.get_argument_count() == 0:
            color = world.get_paint_color()
        else:
            color = svm.pop_string()
        x,y = world.get_current_corner()
        world.set_corner_color(x, y, color)


class KarelSetPaintColor(SVMMethod):

    def execute(self, svm, receiver):
        svm.get_world().set_paint_color(svm.pop_string())


class KarelCornerColorIs(SVMMethod):

    def execute(self, svm, receiver):
        world = svm.get_world()
        x,y = world.get_current_corner()
        color = svm.pop_string().lower()
        svm.push_boolean(world.get_corner_color(x, y).lower() == color)


class KarelRandom(SVMMethod):

    def execute(self, svm, receiver):
        if svm.get_argument_count() == 0:
            p = 0.5
        else:
            p = svm.pop_double()
        svm.push_boolean(random.random() < p)

# Original file: KarelWorldEditor.py

"""
This module implements the world editor.
"""

class KarelWorldEditor(GCompound):

    def __init__(self, app):
        GCompound.__init__(self)
        self._app = app
        self._bg = GRect(KC.WORLD_EDITOR_WIDTH, KC.WORLD_EDITOR_HEIGHT)
        self._bg.set_filled(True)
        self._bg.set_color("White")
        self.add(self._bg)
        self.init_editor_tools()
        self._dragging_karel = False
        self._dragging_started = False
        self._setting_size = False
        self._size_text = ""

    def get_app(self):
        return self._app

    def get_world(self):
        return self._app.get_world()

    def init_editor_tools(self):
        self._tools = [ ]
        x = KC.TOOL_X
        y = KC.TOOL_Y
        self.add_tool(WallTool(x, y, True))
        x += KC.WALL_TOOL_SIZE + KC.TOOL_SEP
        self.add_tool(WallTool(x, y, False))
        x += KC.WALL_TOOL_SIZE + 2 * KC.TOOL_SEP
        self.add_tool(BeeperTool(x, y, 1))
        x += KC.BEEPER_TOOL_SIZE + KC.TOOL_SEP
        self.add_tool(BeeperTool(x, y, KC.PLUS1))
        x += KC.BEEPER_TOOL_SIZE + KC.TOOL_SEP
        self.add_tool(BeeperTool(x, y, KC.MINUS1))
        x += KC.BEEPER_TOOL_SIZE + KC.TOOL_SEP
        self.add_tool(BeeperTool(x, y, 0))
        x += KC.BEEPER_TOOL_SIZE + KC.TOOL_SEP
        self.add_tool(BeeperTool(x, y, KC.INFINITE))
        x += KC.BEEPER_TOOL_SIZE + 2 * KC.TOOL_SEP
        self.add_tool(KarelTool(x, y))
        x += KC.KAREL_TOOL_SIZE + 2 * KC.TOOL_SEP
        self._resize_tool = ResizeTool(x, y, self)
        self.add_tool(self._resize_tool)
        x += KC.RESIZE_TOOL_SIZE + KC.TOOL_SEP
        self.add_tool(ExitTool(x, y))
        self._selected_tool = None
        self.set_selected_tool(self._tools[0])

    def click_action(self, e):
        if self._setting_size and KC.MULTIPLY in self._size_text:
            self.set_size_complete()
        tool = self.find_tool(e.get_x(), e.get_y())
        if tool is not None:
            tool.tool_action(self)

    def set_size_complete(self):
        x = self._size_text.find(KC.MULTIPLY)
        cols = int(self._size_text[:x])
        rows = int(self._size_text[x + 1:])
        self.get_world().resize(cols, rows)
        self.get_world().init_display()
        self._setting_size = False

    def set_selected_tool(self, tool):
        if self._selected_tool is not None:
            self._selected_tool.deselect()
        self._selected_tool = tool
        if tool is not None:
            tool.select()

    def get_selected_tool(self):
        return self._selected_tool

    def wall_action(self, x, y, dir):
        if not self._dragging_karel:
            tool = self.get_selected_tool()
            if tool is not None:
                tool.wall_action(self, x, y, dir)

    def corner_action(self, x, y):
        tool = self.get_selected_tool()
        if self._dragging_karel:
            world = self.get_world()
            if x != world._kx or y != world._ky:
                world.set_karel_location(x, y)
            if isinstance(tool, BeeperTool) and not self._dragging_started:
                nb = world.get_beepers_in_bag()
                if tool._beepers == KC.PLUS1:
                    nb = KarelWorld.adjust_beepers(nb, +1)
                elif tool._beepers == KC.MINUS1:
                    nb = KarelWorld.adjust_beepers(nb, -1)
                else:
                    nb = tool._beepers
                world.set_beepers_in_bag(nb)
        elif tool is not None:
            tool.corner_action(self, x, y)

    def set_dragging_karel(self, flag):
        self._dragging_karel = flag

    def set_dragging_started(self, flag):
        self._dragging_started = flag

    def key_typed(self, e):
        if self._setting_size:
            self._resize_tool.key_typed(e.get_key())

    def add_tool(self, tool):
        self._tools.append(tool)
        self.add(tool)

    def find_tool(self, x, y):
        x -= self.get_x()
        y -= self.get_y()
        for tool in self._tools:
            tx = tool._x
            ty = tool._y
            tw = tool._width
            th = tool._height
            if x >= tx and x < tx + tw and y >= ty and y < ty + th:
                return tool
        return None


class MapTool(GCompound):

    def __init__(self, x, y, width, height):
        GCompound.__init__(self)
        self._x = x
        self._y = y
        self._width = width
        self._height = height
        self.set_location(x, y)

    def tool_action(self, editor):
        editor.set_selected_tool(self)

    def select(self):
        pass

    def deselect(self):
        pass

    def wall_action(self, editor, x, y, dir):
        pass

    def corner_action(self, editor, x, y):
        pass

    def set_selected(self, state):
        pass


class WallTool(MapTool):

    def __init__(self, x, y, create_wall):
        MapTool.__init__(self, x, y, KC.WALL_TOOL_SIZE, KC.WALL_TOOL_SIZE)
        self._create_wall = create_wall
        frame = GRect(KC.WALL_TOOL_SIZE, KC.WALL_TOOL_SIZE)
        frame.set_filled(True)
        frame.set_color("Gray")
        frame.set_fill_color("White")
        self.add(frame)
        self._frame = frame
        wall = GLine((KC.WALL_TOOL_SIZE - KC.WALL_TOOL_LENGTH) / 2,
                     KC.WALL_TOOL_SIZE / 2,
                     (KC.WALL_TOOL_SIZE + KC.WALL_TOOL_LENGTH) / 2,
                     KC.WALL_TOOL_SIZE / 2)
        wall.set_line_width(KC.WALL_LINEWIDTH)
        self.add(wall)
        if create_wall:
            wall.set_color("Black")
        else:
            wall.set_color("Gray")
            line = GLine((KC.WALL_TOOL_SIZE - KC.WALL_CROSS_SIZE) / 2,
                         (KC.WALL_TOOL_SIZE - KC.WALL_CROSS_SIZE) / 2,
                         (KC.WALL_TOOL_SIZE + KC.WALL_CROSS_SIZE) / 2,
                         (KC.WALL_TOOL_SIZE + KC.WALL_CROSS_SIZE) / 2)
            line.set_line_width(KC.CROSS_LINEWIDTH)
            line.set_color("Gray")
            self.add(line)
            line = GLine((KC.WALL_TOOL_SIZE - KC.WALL_CROSS_SIZE) / 2,
                         (KC.WALL_TOOL_SIZE + KC.WALL_CROSS_SIZE) / 2,
                         (KC.WALL_TOOL_SIZE + KC.WALL_CROSS_SIZE) / 2,
                         (KC.WALL_TOOL_SIZE - KC.WALL_CROSS_SIZE) / 2)
            line.set_line_width(KC.CROSS_LINEWIDTH)
            line.set_color("Gray")
            self.add(line)

    def select(self):
        self._frame.set_color(KC.SELECTED_BORDER_COLOR)
        self._frame.set_fill_color("White")
        self._frame.set_line_width(KC.SELECTED_BORDER_WIDTH)

    def deselect(self):
        self._frame.set_color("Gray")
        self._frame.set_fill_color("White")
        self._frame.set_line_width(1)

    def wall_action(self, editor, x, y, dir):
        world = editor.get_world()
        if self._create_wall:
            world.set_wall(x, y, dir)
        else:
            world.clear_wall(x, y, dir)


class BeeperTool(MapTool):

    def __init__(self, x, y, beepers):
        MapTool.__init__(self, x, y, KC.BEEPER_TOOL_SIZE, KC.BEEPER_TOOL_SIZE)
        bsize = KC.BEEPER_TOOL_SIZE
        self._size = KC.BEEPER_TOOL_SIZE
        self._beepers = beepers
        if beepers == 1:
            label = ""
        elif beepers == KC.PLUS1:
            label = "+1"
        elif beepers == KC.MINUS1:
            label = "\u2212" + "1"
        elif beepers == KC.INFINITE:
            label = KC.INFINITY_SYMBOL
        else:
            label = str(beepers)
        bpoly = KarelWorld.create_beeper_polygon(bsize)
        self._bpoly = bpoly
        xc = KC.BEEPER_TOOL_SIZE / 2
        yc = KC.BEEPER_TOOL_SIZE / 2
        self.add(bpoly, xc, yc)
        blabel = GLabel("")
        self.add(blabel, xc, yc)
        labelsize = int(bsize * KC.BEEPER_LABEL_FRACTION + 0.5)
        blabel.set_font(str(labelsize) + "px " + KC.BEEPER_FONT_FAMILY)
        KarelWorld.set_beeper_label(bpoly, blabel, labelsize, label)
        
    def select(self):
        self._bpoly.set_color(KC.SELECTED_BORDER_COLOR)
        self._bpoly.set_line_width(KC.SELECTED_BORDER_WIDTH)

    def deselect(self):
        self._bpoly.set_color("Gray")
        self._bpoly.set_line_width(1)

    def corner_action(self, editor, x, y):
        world = editor.get_world()
        nb = world.get_beepers_on_corner(x, y)
        if self._beepers == KC.PLUS1:
            nb = KarelWorld.adjust_beepers(nb, +1)
        elif self._beepers == KC.MINUS1:
            nb = KarelWorld.adjust_beepers(nb, -1)
        else:
            nb = self._beepers
        world.set_beepers_on_corner(x, y, nb)


class KarelTool(MapTool):

    def __init__(self, x, y):
        MapTool.__init__(self, x, y, KC.KAREL_TOOL_SIZE, KC.KAREL_TOOL_SIZE)
        size = KC.KAREL_TOOL_SIZE
        self.add(KarelWorld.create_karel_polygon(size), size / 2, size / 2)
        r = KC.ARC_RADIUS
        arc = GArc(size / 2 - r + KC.ARC_DX, size / 2 - r + KC.ARC_DY,
                   2 * r, 2 * r, 15, 120)
        self.add(arc)
        arrow = GPolygon()
        p = size / 2 - r / math.sqrt(2)
        arrow.add_vertex(p - KC.ARC_ARROW_SIZE / 2 + KC.ARC_DX,
                         p + KC.ARC_ARROW_SIZE / 2 + KC.ARC_DY)
        arrow.add_edge(KC.ARC_ARROW_SIZE, 0)
        arrow.add_edge(-KC.ARC_ARROW_SIZE, -KC.ARC_ARROW_SIZE)
        arrow.set_filled(True)
        self.add(arrow)

    def tool_action(self, editor):
        editor.get_world().turn_left()


class ResizeTool(MapTool):

    def __init__(self, x, y, editor):
        MapTool.__init__(self, x, y, KC.RESIZE_TOOL_SIZE, KC.RESIZE_TOOL_SIZE)
        frame = GRect(KC.RESIZE_TOOL_SIZE, KC.RESIZE_TOOL_SIZE)
        frame.set_filled(True)
        frame.set_color("Gray")
        frame.set_fill_color("White")
        self.add(frame)
        self._frame = frame
        self._editor = editor
        world = editor.get_world()
        text = str(world.get_cols()) + KC.MULTIPLY + str(world.get_rows())
        label = GLabel(text)
        label.set_font(KC.RESIZE_FONT)
        self._label = label
        x = (KC.RESIZE_TOOL_SIZE - label.get_width()) / 2
        y = KC.RESIZE_TOOL_SIZE / 2 + KC.RESIZE_DY
        self.add(label, x, y)
        self._editor._size_text = ""

    def select(self):
        self._frame.set_color(KC.SELECTED_BORDER_COLOR)
        self._frame.set_line_width(KC.SELECTED_BORDER_WIDTH)
        self._editor._setting_size = True
        self._editor._size_text = ""
        self.update_size_label()

    def deselect(self):
        self._frame.set_color("Gray")
        self._frame.set_line_width(1)
        self._editor._setting_size = True

    def key_typed(self, ch):
        if ch == "x" and KC.MULTIPLY not in self._editor._size_text:
            self._editor._size_text += KC.MULTIPLY
        elif ch.isdigit():
            self._editor._size_text += ch
        elif ch == "<DELETE>" and len(self._editor._size_text) > 0:
            self._editor._size_text = self._editor._size_text[:-1]
        elif ch == "<RETURN>" and KC.MULTIPLY in self._editor._size_text:
            self._editor.set_size_complete()
        else:
            return
        self.update_size_label()

    def update_size_label(self):
        label = self._label
        label.set_label(self._editor._size_text)
        x = (KC.RESIZE_TOOL_SIZE - label.get_width()) / 2
        y = KC.RESIZE_TOOL_SIZE / 2 + KC.RESIZE_DY
        label.set_location(x, y)


class ExitTool(MapTool):

    def __init__(self, x, y):
        MapTool.__init__(self, x, y, KC.EXIT_TOOL_SIZE, KC.EXIT_TOOL_SIZE)
        frame = GRect(KC.EXIT_TOOL_SIZE, KC.EXIT_TOOL_SIZE)
        frame.set_filled(True)
        frame.set_color("Gray")
        frame.set_fill_color("White")
        self.add(frame)
        check = KC.EXIT_TOOL_SIZE * KC.EXIT_CHECK_FRACTION
        short_check = check / 3
        long_check = 2 * check / 3
        line = GLine((KC.EXIT_TOOL_SIZE - check) / 2,
                     KC.EXIT_TOOL_SIZE / 2,
                     (KC.EXIT_TOOL_SIZE - check) / 2 + short_check,
                     KC.EXIT_TOOL_SIZE / 2 + short_check)
        line.set_line_width(KC.CHECK_LINEWIDTH)
        self.add(line)
        line = GLine((KC.EXIT_TOOL_SIZE - check) / 2 + short_check,
                     KC.EXIT_TOOL_SIZE / 2 + short_check,
                     (KC.EXIT_TOOL_SIZE + check) / 2,
                     KC.EXIT_TOOL_SIZE / 2 - short_check)
        line.set_line_width(KC.CHECK_LINEWIDTH)
        self.add(line)

    def tool_action(self, editor):
        editor.get_app().editworld_action()

# Original file: KarelApplication.py

"""
This module implements the user interface for Python Karel.
"""

class KarelApplication(PGLApplication):

    """This class runs the Karel application."""

    def __init__(self):
        """Creates the KarelApplication object."""
        PGLApplication.__init__(self, KC.GWINDOW_WIDTH, KC.GWINDOW_HEIGHT)
        cw = KarelCodeWindow(self, KC.CWINDOW_WIDTH)
        self._code_window = cw
        world = KarelWorld(KC.WORLD_WIDTH, KC.WORLD_HEIGHT)
        self._world = world
        svm = KarelVM()
        svm.init_model(self)
        svm.set_app(self)
        svm.set_world(world)
        self._svm = svm
        self.add(world, KC.WORLD_X, KC.WORLD_Y)
        self.init_control_strip()
        if self._world_file is not None and os.path.exists(self._world_file):
            world.load(self._world_file)
            self._speed_control.set_speed(world.get_speed() * 100)
        else:
            world.resize(10, 10)
            world.init_display()
        self._editor = None
        self._error_dialog = None
        self._error_showing = False
        self.load(KarelApplication.get_source_file())
        self._frame = KarelApplication.get_main_frame()
        loader = self._frame.f_globals.get("__loader__")
        self._main = KarelApplication.get_main_function()
        self.add_event_listener("key", self.key_typed)

    def get_world(self):
        """Returns the world used by this application."""
        return self._world

    def init_control_strip(self):
        """Initializes the various controls."""
        x = KC.CONTROL_X
        y = KC.CONTROL_Y
        self._load_control = LoadControl()
        self._load_control.add_action_listener(self.load_action)
        self.add(self._load_control, x, y)
        x += KC.CONTROL_SEP
        self._save_control = SaveControl()
        self._save_control.add_action_listener(self.save_action)
        self.add(self._save_control, x, y)
        x += KC.CONTROL_SEP
        self._run_control = RunControl()
        self._run_control.add_action_listener(self.run_action)
        self.add(self._run_control, x, y)
        x += KC.CONTROL_SEP
        self._stepin_control = StepInControl()
        self._stepin_control.add_action_listener(self.stepin_action)
        self.add(self._stepin_control, x, y)
        x += KC.CONTROL_SEP
        self._stepover_control = StepOverControl()
        self._stepover_control.add_action_listener(self.stepover_action)
        self.add(self._stepover_control, x, y)
        x += KC.CONTROL_SEP
        self._speed_control = SpeedControl()
        self._speed_control.add_speed_listener(self.speed_changed)
        self.add(self._speed_control, x, y)
        x += KC.CONTROL_SEP
        self._editworld_control = EditWorldControl()
        self._editworld_control.add_action_listener(self.editworld_action)
        self.add(self._editworld_control, x, y)
        x += KC.CONTROL_SEP
        self._reset_control = ResetControl()
        self._reset_control.add_action_listener(self.reset_action)
        self.add(self._reset_control, x, y)
        self._world_file = KarelApplication.get_world_file()

    def run(self):
        """Runs the application after everything is loaded."""
        if self._main is not None:
            self._svm.set_code_window(self._code_window)
#            viewer = KarelFrameViewer(KC.FRAME_VIEW_WIDTH,
#                                      KC.FRAME_VIEW_HEIGHT)
#            self.add(viewer, KC.FRAME_VIEW_X, KC.FRAME_VIEW_Y)
#            viewer.set_frame_size(KC.FRAME_WIDTH, KC.FRAME_HEIGHT)
#            self._svm.set_frame_viewer(viewer)
            sys.exit()

# Implementation notes: load
# --------------------------
# This function tries to parse the file being read by the loader.
# If any syntax errors occur, this function raises a standard Python 
# SyntaxError after assembling the appropriate file components.

    def load(self, filename):
        """Loads the source file and returns True on success."""
        try:
            self.load_source_file(filename)
            return True
        except Exception as ex:
            kp = self._kp
            token = kp.get_last_token()
            if token is None:
                raise ex
            pytoken = token.get_python_token()
            msg = str(ex)
            filename = KarelApplication.get_source_file()
            lineno,colno = pytoken.end
            text = self.get_source_line(filename, lineno)
            raise SyntaxError(msg, (filename, lineno, colno, text))

    def load_source_file(self, filename):
        """Processes the source file in a couple of passes."""
        with open(filename) as f:
            self._source = f.read()
        if len(self._source) > 0 and self._source[-1] != "\n":
            self._source += "\n"
        if self._code_window is not None:
            self._code_window.set_code(self._source)
        self._lines = ["1-based-dummy"] + self._source.splitlines()
        self.compile_source()
        self.save_code_lines()
        last_dot = filename.rfind(".")
        if last_dot != -1:
            root = filename[:last_dot]
        else:
            root = filename
        self.set_window_title(root)

    def get_source_line(self, filename, lineno):
        with open(filename) as f:
            return f.read().splitlines()[lineno - 1]

    def compile_source(self):
        """Compiles the source into SVM code."""
        svm = self._svm
        kp = KarelParser()
        self._kp = kp
        kp.set_input(self._source)
        lines = self._source.splitlines()
        self._module = kp.read_module()
        cv = CodeVector()
        main = KarelApplication.get_main_function()
        cv.add_instruction(SVMOp.PUSHSTR, cv.string_ref(main))
        cv.add_instruction(SVMOp.CALLM, cv.string_ref("Global.get"))
        cv.add_instruction(SVMOp.NARGS, 1)
        cv.add_instruction(SVMOp.CALLFN)
        cv.add_instruction(SVMOp.NARGS, 0)
        cv.add_instruction(SVMOp.HALT)
        fns = { }
        for type,exp in self._module.get_entries():
            if type == "function":
                args = exp.get_args()
                name = str(args[0])
                body = args[3]
                fns[name] = cv.get_current_address()
                kp.compile(body, cv)
                end = exp.get_end()
                if end < len(lines):
                    while end > 1 and (lines[end - 2] == "" or
                                       lines[end - 2].startswith("#")):
                        end -= 1
                cv.add_instruction(SVMOp.STMT, end)
                cv.add_instruction(SVMOp.RETURN)
            elif type == "import":
                lib = str(exp)
                if lib == "turns":
                    svm.import_turns()
                elif lib == "paint":
                    svm.import_paint()
                elif lib == "random":
                    svm.import_random()
                elif lib != "karel" and lib != "exportkarel":
                    print("Unrecognized library: " + lib)
        cv.add_instruction(SVMOp.END)
        code = cv.get_code()
        for type,fn in self._module.get_entries():
            if type == "function":
                args = fn.get_args()
                name = str(args[0])
                closure = SVMFunctionClosure(code, fns[name], None)
                bounds = (fn.get_start(), fn.get_end())
                svm.define_function(name, closure, bounds)
                svm.set_global(name, Value("FunctionClosure", closure))
        svm.set_code(code)

    def save_code_lines(self):
        """Stores the source lines for tracing."""
        for type,fn in self._module.get_entries():
            if type == "function":
                args = fn.get_args()
                name = str(args[0])
                start,end = self._svm.get_function_bounds(name)
                finished = False
                while not finished:
                    line = self._lines[end - 1].strip()
                    if len(line) == 0 or line.startswith("#"):
                        end -= 1
                    else:
                        finished = True
                lines = self._lines[start:end] + [ "" ]
                self._svm.set_function_code(name, lines)

# Implementation notes: load_action and load_file
# -----------------------------------------------
# This implementation defers the actual load dialog so that the action
# exits, thereby allowing the event loop to proceed.  The actual dialog
# is displayed by load_file.

    def load_action(self):
        """Implements the LoadWorld control."""
        timer = GTimer(self, self.load_file, 0)
        timer.start()
        self._load_control.set_state(PGLControl.ACTIVE)

    def load_file(self):
        """Displays the LoadWorld dialog and then loads the world."""
        pathname = choose_input_file()
        if pathname is not None and pathname != "":
            self._world_file = pathname
            self._world.load(self._world_file)
            self._speed_control.set_speed(self._world.get_speed() * 100)

# Implementation notes: save_action and save_file
# -----------------------------------------------
# This implementation defers the actual save dialog so that the action
# exits, thereby allowing the event loop to proceed.  The actual dialog
# is displayed by save_file.  On Mac OSX, save_file generates a warning
# in the console window if the file already exists.  Although there are
# several postings about this problem on the web, I've been unable to
# find a fix.

    def save_action(self):
        """Implements the SaveWorld control."""
        timer = GTimer(self, self.save_file, 0)
        timer.start()
        self._save_control.set_state(PGLControl.ACTIVE)

    def save_file(self):
        """Implements tha actual SaveWorld dialog."""
        pathname = choose_output_file(initialfile=self._world_file)
        if pathname is not None and pathname != "":
            with open(pathname, "w") as f:
                f.write(self._world.get_text())

    def run_action(self):
        """Implements the Run control."""
        self._svm.clear_highlight()
        self._svm.start_action()

    def stepin_action(self):
        """Implements the StepIn control."""
        self._svm.step_action()

    def stepover_action(self):
        """Implements the StepOver control."""
        self._svm.clear_highlight()
        self._svm.call_action()

    def editworld_action(self):
        """Implements the EditWorld control."""
        if self._editor is None:
            self._editor = KarelWorldEditor(self)
        if self._world.get_monitor() is None:
            self._world.set_monitor(self._editor)
            self.add(self._editor, KC.WORLD_EDITOR_X, KC.WORLD_EDITOR_Y)
        else:
            self._world.set_monitor(None)
            self.remove(self._editor)

    def reset_action(self):
        """Implements the Reset control."""
        self._svm.reset()
        self._svm.clear_viewer()
        if self._world_file is not None and os.path.exists(self._world_file):
            self._world.load(self._world_file)
            self._world.set_speed(self._speed_control.get_speed() / 100)
        else:
            self._world.resize(10, 10)
            self._world.init_display()

    def mouse_in_world(self, e):
        """Returns True if the mouse event is in Karel's world."""
        x = e.get_x()
        y = e.get_y()
        return (x >= KC.WORLD_X and x < KC.WORLD_X + KC.WORLD_WIDTH and
                y >= KC.WORLD_Y and y < KC.WORLD_Y + KC.WORLD_HEIGHT)

    def mouse_down(self, e):
        """Responds to a mouse-down event."""
        if self._error_showing:
            self.remove(self._error_dialog)
            self._error_showing = False
        elif self.mouse_in_world(e):
            self._world.mousedown_action(e)
        else:
            PGLApplication.mouse_down(self, e)

    def mouse_drag(self, e):
        """Responds to a drag event."""
        if self.mouse_in_world(e):
            self._world.drag_action(e)
        else:
            PGLApplication.mouse_drag(self, e)

    def key_typed(self, e):
        """Responds to a key-typed event (used only in resizing)."""
        if self._world.get_monitor() is not None:
            self._world.get_monitor().key_typed(e)

    def speed_changed(self):
        """Callback function for when the speed is changed."""
        self._svm.set_speed(self._speed_control.get_speed())

    def show_error_dialog(self, msg):
        """Displays an error dialog with the specified message."""
        if self._error_dialog is None:
            self._error_dialog = KarelErrorDialog()
        self._error_dialog.set_message(msg)
        x = (KC.GWINDOW_WIDTH - KC.ERROR_DIALOG_WIDTH) / 2
        y = (KC.GWINDOW_HEIGHT - KC.ERROR_DIALOG_HEIGHT) / 2
        self.add(self._error_dialog, x, y)
        self._error_showing = True

    @staticmethod
    def get_source_file():
        """Returns the name of the file being loaded."""
        return KarelApplication.get_main_frame().f_globals.get("__file__")

    @staticmethod
    def get_world_file():
        """Returns the name of the corresponding world file."""
        filename = KarelApplication.get_main_frame().f_globals.get("__file__")
        return filename[:filename.find(".")] + ".w"

    @staticmethod
    def get_main_function():
        """Returns the name of the first function."""
        main = None
        filename = KarelApplication.get_main_frame().f_globals.get("__file__")
        with open(filename) as f:
            for line in f:
                line = line.strip()
                if main is None and line.startswith("def "):
                    main = line[4:line.find("(")].strip()
                elif (line.startswith("if ") and 
                      line.find("__name__") > 0 and
                      line.find("__main__") > 0):
                    main = None
        return main

    @staticmethod
    def get_main_frame():
        """Returns the frame in which the load is happening."""
        for i in range(100):
            frame = sys._getframe(i)
            if frame.f_globals.get("__name__") == "__main__":
                return frame
        raise KarelException("Imports too deeply nested")

# Define the builtin commands

def move():
    _ka.move()

def turn_left():
    _ka.turn_left()

def pick_beeper():
    _ka.pick_beeper()

def put_beeper():
    _ka.put_beeper()

def front_is_clear():
    return _ka.front_is_clear()

def front_is_blocked():
    return _ka.front_is_blocked()

def left_is_clear():
    return _ka.left_is_clear()

def left_is_blocked():
    return _ka.left_is_blocked()

def right_is_clear():
    return _ka.right_is_clear()

def right_is_blocked():
    return _ka.right_is_blocked()

def beepers_present():
    return _ka.beepers_present()

def no_beepers_present():
    return _ka.no_beepers_present()

def beepers_in_bag():
    return _ka.beepers_in_bag()

def no_beepers_in_bag():
    return _ka.no_beepers_in_bag()

def facing_north():
    return _ka.facing_north()

def not_facing_north():
    return _ka.not_facing_north()

def facing_east():
    return _ka.facing_east()

def not_facing_east():
    return _ka.not_facing_east()

def facing_south():
    return _ka.facing_south()

def not_facing_south():
    return _ka.not_facing_south()

def facing_west():
    return _ka.facing_west()

def not_facing_west():
    return _ka.not_facing_west()

_ka = KarelApplication()
    
# Add the builtins to the calling environment

__builtins__["move"] = move
__builtins__["turn_left"] = turn_left
__builtins__["pick_beeper"] = pick_beeper
__builtins__["put_beeper"] = put_beeper
__builtins__["front_is_clear"] = front_is_clear
__builtins__["front_is_blocked"] = front_is_blocked
__builtins__["left_is_clear"] = left_is_clear
__builtins__["left_is_blocked"] = left_is_blocked
__builtins__["right_is_clear"] = right_is_clear
__builtins__["right_is_blocked"] = right_is_blocked
__builtins__["beepers_present"] = beepers_present
__builtins__["no_beepers_present"] = no_beepers_present
__builtins__["beepers_in_bag"] = beepers_in_bag
__builtins__["no_beepers_in_bag"] = no_beepers_in_bag
__builtins__["facing_north"] = facing_north
__builtins__["facing_east"] = facing_east
__builtins__["facing_south"] = facing_south
__builtins__["facing_west"] = facing_west
__builtins__["_ka"] = _ka

_ka.run()