file_name
stringlengths 3
137
| prefix
stringlengths 0
918k
| suffix
stringlengths 0
962k
| middle
stringlengths 0
812k
|
|---|---|---|---|
main.rs | use std::io;
use serde::{Deserialize, Serialize};
extern crate mtga_resources_locator;
use mtga_resources_locator::assets_data_dir;
mod client;
#[derive(Serialize, Deserialize, Debug, Clone, Copy)]
#[serde(rename_all = "camelCase")]
struct Card {
title_id: i32, | struct MagicCard {
title: String,
cmc: i32
}
#[derive(Serialize, Deserialize, Debug)]
#[serde(rename_all = "camelCase")]
struct Localization {
iso_code: String,
keys: Vec<LocalizationKey>
}
#[derive(Serialize, Deserialize, Debug)]
#[serde(rename_all = "camelCase")]
struct LocalizationKey {
id: i32,
text: String
}
fn get_card_by_id(id: i32, c: &str, l: &str) -> MagicCard {
let cards: Vec<Card> = serde_json::from_str(c).unwrap();
let loc: Vec<Localization> = serde_json::from_str(l).unwrap();
let card_index = cards.iter()
.position(|map| map.title_id == id)
.expect("Can't find card with given ID");
let card = cards[card_index];
let title_key = loc[0].keys.iter()
.position(|map| map.id == card.title_id)
.expect("Can't find string translation");
let title = &loc[0].keys[title_key].text;
return MagicCard {
title: title.to_string(),
cmc: card.cmc,
}
}
fn main() -> io::Result<()> {
// Get assets data directory
let data_dir = assets_data_dir().unwrap().unwrap();
// Retrives Magic Client Data
// let client = &mut client::ClientData::new(data_dir);
let client = &mut client::ClientData::new(data_dir);
let data = client.collect()?;
let c = get_card_by_id(653, &data.cards, &data.localization);
println!("{:?}", c);
Ok(())
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn it_collects_data() {
// Get assets data directory
let data_dir = assets_data_dir().unwrap().unwrap();
// Retrives Magic Client Data
println!("{:?}", data_dir);
let client = &mut client::ClientData::new(data_dir);
let data = client.collect().expect("Could not return data.");
assert_eq!(!data.cards.is_empty(), true);
assert_eq!(!data.localization.is_empty(), true);
assert_eq!(!data.enums.is_empty(), true);
assert_eq!(!data.abilities.is_empty(), true);
}
} | cmc: i32
}
#[derive(Debug)] |
wiser_website_settings.py | # -*- coding: utf-8 -*-
# Copyright (c) 2019, Systematic and contributors
# For license information, please see license.txt
from __future__ import unicode_literals
import frappe
from frappe.model.document import Document
class WiserWebsiteSettings(Document):
def | (self):
from frappe.website.render import clear_cache
clear_cache("index")
| on_update |
0005_auto_20170824_1644.py | # -*- coding: utf-8 -*-
# Generated by Django 1.11.3 on 2017-08-24 08:44
from __future__ import unicode_literals
from django.db import migrations
class | (migrations.Migration):
dependencies = [
('dashboard2', '0004_auto_20170310_1811'),
]
operations = [
migrations.DeleteModel(
name='Config',
),
migrations.DeleteModel(
name='Machine',
),
migrations.DeleteModel(
name='Tag',
),
]
| Migration |
service_list_item_component.tsx | import React from 'react';
import { textStyles, colors } from '../../application/styles';
import { HumanServiceData, Address } from '../../validation/services/types';
import { View, Text } from 'native-base';
import { TouchableOpacity } from 'react-native';
import { mapWithIndex } from '../../application/helpers/map_with_index';
import { filterPhysicalAddresses } from '../addresses/filter_physical_addresses';
import { History } from 'history';
import { BookmarkButtonComponent } from '../bookmark_button_component';
import { buildServiceName } from './build_service_name';
import { BookmarkServiceAction, UnbookmarkServiceAction } from '../../stores/services/actions';
import { PromptServiceReviewButton } from '../reviews/prompt_service_review_button';
import { UxTheme } from '../../application/ux_themes';
import { LocaleCode } from '../../application/locales';
import { getDescription } from './get_description';
import { addressIsEmpty } from '../addresses/address_is_empty';
import R from 'ramda';
export interface ServiceListItemProps {
readonly service: HumanServiceData;
readonly history: History;
readonly isBookmarked: boolean;
readonly theme: UxTheme;
readonly locale: LocaleCode;
readonly onPress: () => void;
readonly onPressServiceReview: () => void;
}
export interface ServiceListItemActions {
readonly onBookmark: () => BookmarkServiceAction;
readonly onUnbookmark: () => UnbookmarkServiceAction;
}
type Props = ServiceListItemProps & ServiceListItemActions;
export const ServiceListItemComponent = (props: Props): JSX.Element => {
const serviceName = buildServiceName(props.service.organizationName, props.service.name);
const addresses = R.reject(addressIsEmpty, filterPhysicalAddresses(props.service.addresses));
return (
<TouchableOpacity style={{ backgroundColor: colors.white }} onPress={props.onPress}>
<View style={{ paddingVertical: 20, flex: 1, flexDirection: 'row'}}>
<View style={{flex: 2, paddingLeft: 20}}>
{renderName(serviceName)}
{renderAddresses(addresses)}
{renderDescription(getDescription(props.service.description, props.locale))}
</View>
<View>
<BookmarkButtonComponent
isBookmarked={props.isBookmarked}
textColor={props.theme.mainColour}
bookmark={props.onBookmark}
unbookmark={props.onUnbookmark}
/>
</View>
</View>
<PromptServiceReviewButton
serviceId={props.service.id}
isVisible={!props.service.reviewed}
theme={props.theme}
onPress={props.onPressServiceReview}
/>
</TouchableOpacity>
);
};
const renderName = (name: string): JSX.Element => (
<Text style={[textStyles.headlineH3StyleBlackLeft]}>{name}</Text>
);
const renderDescription = (description: string): JSX.Element => (
<Text note numberOfLines={3} style={textStyles.listItemDetail }>
{description}
</Text>
);
// tslint:disable-next-line:typedef
const renderAddresses = (physicalAddresses: ReadonlyArray<Address>) => (
mapWithIndex((address: Address, index: number): JSX.Element =>
<View key={index} style={{ marginVertical: 10}}> | {appendCommaIfNotEmpty(address.address)}{address.city} {address.stateProvince} {address.postalCode || ''}
</Text>
</View>, physicalAddresses)
);
const appendCommaIfNotEmpty = (address: string): string => {
if (address.trim() === '') {
return '';
}
return `${address}, `;
}; | <Text style={textStyles.listItemDetail}> |
sku_type.go | /*
Copyright (c) 2019 Red Hat, Inc.
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*/
// IMPORTANT: This file has been generated automatically, refrain from modifying it manually as all
// your changes will be lost when the file is generated again.
package v1 // github.com/openshift-online/ocm-sdk-go/accountsmgmt/v1
// SKUKind is the name of the type used to represent objects
// of type 'SKU'.
const SKUKind = "SKU"
// SKULinkKind is the name of the type used to represent links
// to objects of type 'SKU'.
const SKULinkKind = "SKULink"
// SKUNilKind is the name of the type used to nil references
// to objects of type 'SKU'.
const SKUNilKind = "SKUNil"
// SKU represents the values of the 'SKU' type.
//
// Identifies computing resources
type SKU struct {
id *string
href *string
link bool
byoc *bool
availabilityZoneType *string
resourceName *string
resourceType *string
resources []*Resource
}
// Kind returns the name of the type of the object.
func (o *SKU) Kind() string {
if o == nil {
return SKUNilKind
}
if o.link {
return SKULinkKind
}
return SKUKind
}
// ID returns the identifier of the object.
func (o *SKU) ID() string {
if o != nil && o.id != nil {
return *o.id
}
return ""
}
// GetID returns the identifier of the object and a flag indicating if the
// identifier has a value.
func (o *SKU) GetID() (value string, ok bool) {
ok = o != nil && o.id != nil
if ok {
value = *o.id
}
return
}
// Link returns true iif this is a link.
func (o *SKU) Link() bool {
return o != nil && o.link
}
// HREF returns the link to the object.
func (o *SKU) HREF() string {
if o != nil && o.href != nil {
return *o.href
}
return ""
}
// GetHREF returns the link of the object and a flag indicating if the
// link has a value.
func (o *SKU) GetHREF() (value string, ok bool) {
ok = o != nil && o.href != nil
if ok {
value = *o.href
}
return
}
// Empty returns true if the object is empty, i.e. no attribute has a value.
func (o *SKU) Empty() bool {
return o == nil || (o.id == nil &&
o.byoc == nil &&
o.availabilityZoneType == nil &&
o.resourceName == nil &&
o.resourceType == nil &&
len(o.resources) == 0 &&
true)
}
// BYOC returns the value of the 'BYOC' attribute, or
// the zero value of the type if the attribute doesn't have a value.
//
//
func (o *SKU) BYOC() bool {
if o != nil && o.byoc != nil {
return *o.byoc
}
return false
}
// GetBYOC returns the value of the 'BYOC' attribute and
// a flag indicating if the attribute has a value.
//
//
func (o *SKU) GetBYOC() (value bool, ok bool) {
ok = o != nil && o.byoc != nil
if ok {
value = *o.byoc
}
return
}
// AvailabilityZoneType returns the value of the 'availability_zone_type' attribute, or
// the zero value of the type if the attribute doesn't have a value.
//
//
func (o *SKU) AvailabilityZoneType() string {
if o != nil && o.availabilityZoneType != nil {
return *o.availabilityZoneType
}
return ""
}
// GetAvailabilityZoneType returns the value of the 'availability_zone_type' attribute and
// a flag indicating if the attribute has a value.
//
//
func (o *SKU) GetAvailabilityZoneType() (value string, ok bool) {
ok = o != nil && o.availabilityZoneType != nil
if ok {
value = *o.availabilityZoneType
}
return
}
// ResourceName returns the value of the 'resource_name' attribute, or
// the zero value of the type if the attribute doesn't have a value.
//
// platform-specific name, such as "M5.2Xlarge" for a type of EC2 node
func (o *SKU) ResourceName() string {
if o != nil && o.resourceName != nil {
return *o.resourceName
}
return ""
}
// GetResourceName returns the value of the 'resource_name' attribute and
// a flag indicating if the attribute has a value.
//
// platform-specific name, such as "M5.2Xlarge" for a type of EC2 node
func (o *SKU) GetResourceName() (value string, ok bool) {
ok = o != nil && o.resourceName != nil
if ok {
value = *o.resourceName
}
return
}
// ResourceType returns the value of the 'resource_type' attribute, or
// the zero value of the type if the attribute doesn't have a value.
//
//
func (o *SKU) ResourceType() string {
if o != nil && o.resourceType != nil {
return *o.resourceType
}
return ""
}
// GetResourceType returns the value of the 'resource_type' attribute and
// a flag indicating if the attribute has a value.
//
//
func (o *SKU) GetResourceType() (value string, ok bool) {
ok = o != nil && o.resourceType != nil
if ok {
value = *o.resourceType
}
return
}
// Resources returns the value of the 'resources' attribute, or
// the zero value of the type if the attribute doesn't have a value.
//
//
func (o *SKU) Resources() []*Resource {
if o == nil {
return nil
}
return o.resources
}
// GetResources returns the value of the 'resources' attribute and
// a flag indicating if the attribute has a value.
//
//
func (o *SKU) GetResources() (value []*Resource, ok bool) {
ok = o != nil && o.resources != nil
if ok {
value = o.resources
}
return
}
// SKUListKind is the name of the type used to represent list of objects of
// type 'SKU'.
const SKUListKind = "SKUList"
// SKUListLinkKind is the name of the type used to represent links to list
// of objects of type 'SKU'.
const SKUListLinkKind = "SKUListLink"
// SKUNilKind is the name of the type used to nil lists of objects of
// type 'SKU'.
const SKUListNilKind = "SKUListNil"
// SKUList is a list of values of the 'SKU' type.
type SKUList struct {
href *string
link bool
items []*SKU
}
// Kind returns the name of the type of the object.
func (l *SKUList) Kind() string {
if l == nil {
return SKUListNilKind
}
if l.link {
return SKUListLinkKind
}
return SKUListKind
}
// Link returns true iif this is a link.
func (l *SKUList) Link() bool {
return l != nil && l.link
}
// HREF returns the link to the list.
func (l *SKUList) HREF() string {
if l != nil && l.href != nil {
return *l.href
}
return ""
}
// GetHREF returns the link of the list and a flag indicating if the
// link has a value.
func (l *SKUList) GetHREF() (value string, ok bool) {
ok = l != nil && l.href != nil
if ok {
value = *l.href
}
return
}
// Len returns the length of the list.
func (l *SKUList) Len() int {
if l == nil |
return len(l.items)
}
// Empty returns true if the list is empty.
func (l *SKUList) Empty() bool {
return l == nil || len(l.items) == 0
}
// Get returns the item of the list with the given index. If there is no item with
// that index it returns nil.
func (l *SKUList) Get(i int) *SKU {
if l == nil || i < 0 || i >= len(l.items) {
return nil
}
return l.items[i]
}
// Slice returns an slice containing the items of the list. The returned slice is a
// copy of the one used internally, so it can be modified without affecting the
// internal representation.
//
// If you don't need to modify the returned slice consider using the Each or Range
// functions, as they don't need to allocate a new slice.
func (l *SKUList) Slice() []*SKU {
var slice []*SKU
if l == nil {
slice = make([]*SKU, 0)
} else {
slice = make([]*SKU, len(l.items))
copy(slice, l.items)
}
return slice
}
// Each runs the given function for each item of the list, in order. If the function
// returns false the iteration stops, otherwise it continues till all the elements
// of the list have been processed.
func (l *SKUList) Each(f func(item *SKU) bool) {
if l == nil {
return
}
for _, item := range l.items {
if !f(item) {
break
}
}
}
// Range runs the given function for each index and item of the list, in order. If
// the function returns false the iteration stops, otherwise it continues till all
// the elements of the list have been processed.
func (l *SKUList) Range(f func(index int, item *SKU) bool) {
if l == nil {
return
}
for index, item := range l.items {
if !f(index, item) {
break
}
}
}
| {
return 0
} |
air_frieght_transport.py | class FreightPlane:
| def __init__(self):
pass |
|
mod.rs | // Copyright (c) 2019 Stefan Lankes, RWTH Aachen University
// 2020 Frederik Schulz, RWTH Aachen University
//
// Licensed under the Apache License, Version 2.0, <LICENSE-APACHE or
// http://apache.org/licenses/LICENSE-2.0> or the MIT license <LICENSE-MIT or
// http://opensource.org/licenses/MIT>, at your option. This file may not be
// copied, modified, or distributed except according to those terms.
#[cfg(feature = "pci")]
pub mod rtl8139;
#[cfg(feature = "pci")]
pub mod virtio_net;
use crate::arch::kernel::apic;
use crate::arch::kernel::irq::ExceptionStackFrame;
use crate::arch::kernel::pci;
use crate::arch::kernel::percore::*;
use crate::scheduler::task::TaskHandle;
use crate::synch::semaphore::*;
use crate::synch::spinlock::SpinlockIrqSave;
use alloc::collections::BTreeMap;
use core::sync::atomic::{AtomicBool, Ordering};
/// A trait for accessing the network interface
pub trait NetworkInterface {
/// Returns the mac address of the device.
fn get_mac_address(&self) -> [u8; 6];
/// Returns the current MTU of the device.
fn get_mtu(&self) -> u16;
/// Get buffer to create a TX packet
fn get_tx_buffer(&mut self, len: usize) -> Result<(*mut u8, usize), ()>;
/// Send TC packets
fn send_tx_buffer(&mut self, tkn_handle: usize, len: usize) -> Result<(), ()>;
/// Check if a packet is available
fn has_packet(&self) -> bool;
/// Get RX buffer with an received packet
fn receive_rx_buffer(&mut self) -> Result<(&'static [u8], usize), ()>;
/// Tells driver, that buffer is consumed and can be deallocated
fn rx_buffer_consumed(&mut self, trf_handle: usize);
/// Enable / disable the polling mode of the network interface
fn set_polling_mode(&mut self, value: bool);
/// Handle interrupt and check if a packet is available
fn handle_interrupt(&mut self) -> bool;
}
static NET_SEM: Semaphore = Semaphore::new(0);
static NIC_QUEUE: SpinlockIrqSave<BTreeMap<usize, TaskHandle>> =
SpinlockIrqSave::new(BTreeMap::new());
static POLLING: AtomicBool = AtomicBool::new(false);
/// period (in usec) to check, if the driver should still use the polling mode
const POLL_PERIOD: u64 = 20_000;
/// set driver in polling mode and threads will not be blocked
fn set_polling_mode(value: bool) {
// is the driver already in polling mode?
if POLLING.swap(value, Ordering::SeqCst) != value {
#[cfg(feature = "pci")]
if let Some(driver) = crate::arch::kernel::pci::get_network_driver() {
driver.lock().set_polling_mode(value)
}
// wakeup network thread to sleep for longer time
NET_SEM.release();
}
} | NET_SEM.release();
}
pub fn netwait_and_wakeup(handles: &[usize], millis: Option<u64>) {
// do we have to wakeup a thread?
if handles.len() > 0 {
let mut guard = NIC_QUEUE.lock();
for i in handles {
if let Some(task) = guard.remove(i) {
core_scheduler().custom_wakeup(task);
}
}
}
let mut reset_nic = false;
// check if the driver should be in the polling mode
while POLLING.swap(false, Ordering::SeqCst) == true {
reset_nic = true;
let core_scheduler = core_scheduler();
let wakeup_time = Some(crate::arch::processor::get_timer_ticks() + POLL_PERIOD);
core_scheduler.block_current_task(wakeup_time);
// Switch to the next task.
core_scheduler.reschedule();
}
if reset_nic {
#[cfg(feature = "pci")]
if let Some(driver) = crate::arch::kernel::pci::get_network_driver() {
driver.lock().set_polling_mode(false);
};
} else {
NET_SEM.acquire(millis);
}
}
pub fn netwait(handle: usize, millis: Option<u64>) {
// smoltcp want to poll the nic
let is_polling = if let Some(t) = millis { t == 0 } else { false };
if is_polling {
set_polling_mode(true);
} else {
let wakeup_time = match millis {
Some(ms) => Some(crate::arch::processor::get_timer_ticks() + ms * 1000),
_ => None,
};
let mut guard = NIC_QUEUE.lock();
let core_scheduler = core_scheduler();
// Block the current task and add it to the wakeup queue.
core_scheduler.block_current_task(wakeup_time);
guard.insert(handle, core_scheduler.get_current_task_handle());
// release lock
drop(guard);
// Switch to the next task.
core_scheduler.reschedule();
// if the timer is expired, we have still the task in the btreemap
// => remove it from the btreemap
if millis.is_some() {
let mut guard = NIC_QUEUE.lock();
guard.remove(&handle);
}
}
}
#[cfg(target_arch = "x86_64")]
pub extern "x86-interrupt" fn network_irqhandler(_stack_frame: &mut ExceptionStackFrame) {
debug!("Receive network interrupt");
apic::eoi();
let check_scheduler = match pci::get_network_driver() {
Some(driver) => driver.lock().handle_interrupt(),
_ => {
debug!("Unable to handle interrupt!");
false
}
};
if check_scheduler {
core_scheduler().scheduler();
}
} |
pub fn netwakeup() { |
check_webuiadv_09_element_waiters.py | # This file is a part of Arjuna
# Copyright 2015-2020 Rahul Verma
# Website: www.RahulVerma.net
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
# http://www.apache.org/licenses/LICENSE-2.0
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
from arjuna import *
@test
def check_wait_until_absent_nested(request, logged_in_wordpress):
# Should be validated in root element.
logged_in_wordpress.element(id="adminmenu").wait_until_absent(id="something")
try:
# It is present
logged_in_wordpress.element(id="adminmenu").wait_until_absent(tag="div")
except GuiWidgetPresentError as e:
print("Exception as Expected")
print(str(e))
except Exception as e:
raise Exception("Unexpected exception raise: ", str(e))
else:
raise Exception("Exception not raised.")
@test
def check_absent_nested_locator_max_wait(request, logged_in_wordpress):
try:
b = time.time()
logged_in_wordpress.element(id="adminmenu").wait_until_absent(tag="div")
except GuiWidgetPresentError:
print(time.time() - b)
try:
b = time.time()
logged_in_wordpress.element(id="adminmenu").wait_until_absent(tag="div", max_wait=10)
except GuiWidgetPresentError:
print(time.time() - b)
@test
def | (request, logged_in_wordpress):
# Should be validated in root element.
print(logged_in_wordpress.element(id="adminmenu").contains(tag="div"))
print(logged_in_wordpress.element(id="adminmenu").contains(id="something"))
@test
def check_contains_nested_locator_max_wait(request, logged_in_wordpress):
b = time.time()
logged_in_wordpress.element(id="adminmenu").contains(id="something")
print(time.time() - b)
b = time.time()
logged_in_wordpress.element(id="adminmenu").contains(id="something", max_wait=10)
print(time.time() - b) | check_contains_nested |
eth_confirmer.go | package bulletprooftxmanager
import (
"context"
"encoding/json"
"fmt"
"math/big"
"sort"
"strings"
"sync"
"time"
"github.com/smartcontractkit/chainlink/core/logger"
"github.com/smartcontractkit/chainlink/core/null"
"github.com/smartcontractkit/chainlink/core/services/eth"
"github.com/smartcontractkit/chainlink/core/services/postgres"
"github.com/smartcontractkit/chainlink/core/store"
"github.com/smartcontractkit/chainlink/core/store/models"
"github.com/smartcontractkit/chainlink/core/store/orm"
"github.com/smartcontractkit/chainlink/core/utils"
gethCommon "github.com/ethereum/go-ethereum/common"
"github.com/ethereum/go-ethereum/common/hexutil"
"github.com/ethereum/go-ethereum/rpc"
"github.com/pkg/errors"
"go.uber.org/multierr"
"gorm.io/gorm"
)
var (
// ErrCouldNotGetReceipt is the error string we save if we reach our finality depth for a confirmed transaction without ever getting a receipt
// This most likely happened because an external wallet used the account for this nonce
ErrCouldNotGetReceipt = "could not get receipt"
)
// EthConfirmer is a broad service which performs four different tasks in sequence on every new longest chain
// Step 1: Mark that all currently pending transaction attempts were broadcast before this block
// Step 2: Check pending transactions for receipts
// Step 3: See if any transactions have exceeded the gas bumping block threshold and, if so, bump them
// Step 4: Check confirmed transactions to make sure they are still in the longest chain (reorg protection)
type ethConfirmer struct {
utils.StartStopOnce
store *store.Store
ethClient eth.Client
config orm.ConfigReader
mb *utils.Mailbox
ctx context.Context
ctxCancel context.CancelFunc
chDone chan struct{}
}
func NewEthConfirmer(store *store.Store, config orm.ConfigReader) *ethConfirmer {
context, cancel := context.WithCancel(context.Background())
return ðConfirmer{
utils.StartStopOnce{},
store,
store.EthClient,
config,
utils.NewMailbox(1),
context,
cancel,
make(chan struct{}),
}
}
// Do nothing on connect, simply wait for the next head
func (ec *ethConfirmer) Connect(*models.Head) error {
return nil
}
func (ec *ethConfirmer) Disconnect() {
// pass
}
// OnNewLongestChain uses a mailbox with capacity 1 to deliver the latest head to the runLoop.
// This is because it may take longer than the intervals between heads to process, but we don't want to interrupt the loop.
// e.g.
// - We’re still processing head 41
// - Head 42 comes in
// - Now heads 43, 44, 45 come in
// - Now we finish head 41
// - We move straight on to processing head 45
func (ec *ethConfirmer) OnNewLongestChain(ctx context.Context, head models.Head) {
ec.mb.Deliver(head)
}
func (ec *ethConfirmer) Start() error {
if !ec.OkayToStart() {
return errors.New("Pipeline runner has already been started")
}
go ec.runLoop()
return nil
}
func (ec *ethConfirmer) Close() error {
if !ec.OkayToStop() {
return errors.New("Pipeline runner has already been stopped")
}
ec.ctxCancel()
<-ec.chDone
return nil
}
func (ec *ethConfirmer) runLoop() {
defer close(ec.chDone)
for {
select {
case <-ec.mb.Notify():
for {
if ec.ctx.Err() != nil {
return
}
head := ec.mb.Retrieve()
if head == nil {
break
}
h, is := head.(models.Head)
if !is {
logger.Errorf("EthConfirmer: invariant violation, expected %T but got %T", models.Head{}, head)
continue
}
if err := ec.ProcessHead(ec.ctx, h); err != nil {
logger.Errorw("EthConfirmer error", "err", err)
continue
}
}
case <-ec.ctx.Done():
return
}
}
}
// ProcessHead takes all required transactions for the confirmer on a new head
func (ec *ethConfirmer) ProcessHead(ctx context.Context, head models.Head) error {
return ec.store.AdvisoryLocker.WithAdvisoryLock(context.TODO(), postgres.AdvisoryLockClassID_EthConfirmer, postgres.AdvisoryLockObjectID_EthConfirmer, func() error {
return ec.processHead(ctx, head)
})
}
// NOTE: This SHOULD NOT be run concurrently or it could behave badly
func (ec *ethConfirmer) processHead(ctx context.Context, head models.Head) error {
if err := ec.SetBroadcastBeforeBlockNum(head.Number); err != nil {
return errors.Wrap(err, "SetBroadcastBeforeBlockNum failed")
}
mark := time.Now()
if err := ec.CheckForReceipts(ctx, head.Number); err != nil {
return errors.Wrap(err, "CheckForReceipts failed")
}
logger.Debugw("EthConfirmer: finished CheckForReceipts", "headNum", head.Number, "time", time.Since(mark), "id", "eth_confirmer")
mark = time.Now()
keys, err := ec.store.SendKeys()
if err != nil {
return errors.Wrap(err, "could not fetch keys")
}
if err := ec.RebroadcastWhereNecessary(ctx, keys, head.Number); err != nil {
return errors.Wrap(err, "RebroadcastWhereNecessary failed")
}
logger.Debugw("EthConfirmer: finished RebroadcastWhereNecessary", "headNum", head.Number, "time", time.Since(mark), "id", "eth_confirmer")
mark = time.Now()
defer func() {
logger.Debugw("EthConfirmer: finished EnsureConfirmedTransactionsInLongestChain", "headNum", head.Number, "time", time.Since(mark), "id", "eth_confirmer")
}()
return errors.Wrap(ec.EnsureConfirmedTransactionsInLongestChain(ctx, keys, head), "EnsureConfirmedTransactionsInLongestChain failed")
}
// SetBroadcastBeforeBlockNum updates already broadcast attempts with the
// current block number. This is safe no matter how old the head is because if
// the attempt is already broadcast it _must_ have been before this head.
func (ec *ethConfirmer) SetBroadcastBeforeBlockNum(blockNum int64) error {
return ec.store.DB.Exec(
`UPDATE eth_tx_attempts SET broadcast_before_block_num = ? WHERE broadcast_before_block_num IS NULL AND state = 'broadcast'`,
blockNum,
).Error
}
func (ec *ethConfirmer) CheckForReceipts(ctx context.Context, blockNum int64) error {
batchSize := int(ec.config.EthReceiptFetchBatchSize())
attempts, err := ec.findEthTxAttemptsRequiringReceiptFetch()
if err != nil {
return errors.Wrap(err, "findEthTxAttemptsRequiringReceiptFetch failed")
}
if len(attempts) == 0 {
return nil
}
logger.Debugw(fmt.Sprintf("EthConfirmer: fetching receipts for %v transaction attempts", len(attempts)), "blockNum", blockNum)
for i := 0; i < len(attempts); i += batchSize {
j := i + batchSize
if j > len(attempts) {
j = len(attempts)
}
logger.Debugw(fmt.Sprintf("EthConfirmer: batch fetching receipts %v thru %v", i, j), "blockNum", blockNum)
batch := attempts[i:j]
receipts, err := ec.batchFetchReceipts(ctx, batch)
if err != nil {
return errors.Wrap(err, "batchFetchReceipts failed")
}
if err := ec.saveFetchedReceipts(ctx, receipts); err != nil {
return errors.Wrap(err, "saveFetchedReceipts failed")
}
}
if err := ec.markConfirmedMissingReceipt(ctx); err != nil {
return errors.Wrap(err, "unable to mark eth_txes as 'confirmed_missing_receipt'")
}
if err := ec.markOldTxesMissingReceiptAsErrored(ctx, blockNum); err != nil {
return errors.Wrap(err, "unable to confirm buried unconfirmed eth_txes")
}
return nil
}
func (ec *ethConfirmer) findEthTxAttemptsRequiringReceiptFetch() (attempts []models.EthTxAttempt, err error) {
err = ec.store.DB.
Joins("JOIN eth_txes ON eth_txes.id = eth_tx_attempts.eth_tx_id AND eth_txes.state IN ('unconfirmed', 'confirmed_missing_receipt')").
Order("eth_txes.nonce ASC, eth_tx_attempts.gas_price DESC").
Where("eth_tx_attempts.state != 'insufficient_eth'").
Find(&attempts).Error
return
}
func (ec *ethConfirmer) batchFetchReceipts(ctx context.Context, attempts []models.EthTxAttempt) (receipts []Receipt, err error) {
var reqs []rpc.BatchElem
for _, attempt := range attempts {
req := rpc.BatchElem{
Method: "eth_getTransactionReceipt",
Args: []interface{}{attempt.Hash},
Result: &Receipt{},
}
reqs = append(reqs, req)
}
err = ec.ethClient.BatchCallContext(ctx, reqs)
if err != nil {
return nil, errors.Wrap(err, "EthConfirmer#batchFetchReceipts error fetching receipts with BatchCallContext")
}
for i, req := range reqs {
attempt := attempts[i]
result, err := req.Result, req.Error
receipt, is := result.(*Receipt)
if !is {
return nil, errors.Errorf("expected result to be a %T, got %T", (*Receipt)(nil), result)
}
l := logger.Default.With(
"txHash", attempt.Hash.Hex(), "ethTxAttemptID", attempt.ID, "ethTxID", attempt.EthTxID, "err", err,
)
if err != nil {
l.Errorw("EthConfirmer#batchFetchReceipts: fetchReceipt failed")
continue
}
if receipt == nil {
// NOTE: This should never possibly happen, but it seems safer to
// check regardless to avoid a potential panic
l.Errorw("EthConfirmer#batchFetchReceipts: invariant violation, got nil receipt")
continue
}
if receipt.IsZero() {
l.Debugw("EthConfirmer#batchFetchReceipts: still waiting for receipt")
continue
}
l = l.With("receipt", receipt)
if receipt.IsUnmined() {
l.Debugw("EthConfirmer#batchFetchReceipts: got receipt for transaction but it's still in the mempool and not included in a block yet")
continue
}
l.Debugw("EthConfirmer#batchFetchReceipts: got receipt for transaction", "blockNumber", receipt.BlockNumber)
if receipt.TxHash != attempt.Hash {
l.Errorf("EthConfirmer#batchFetchReceipts: invariant violation, expected receipt with hash %s to have same hash as attempt with hash %s", receipt.TxHash.Hex(), attempt.Hash.Hex())
continue
}
if receipt.BlockNumber == nil {
l.Error("EthConfirmer#batchFetchReceipts: invariant violation, receipt was missing block number")
continue
}
receipts = append(receipts, *receipt)
}
return
}
func (ec *ethConfirmer) saveFetchedReceipts(ctx context.Context, receipts []Receipt) (err error) {
if len(receipts) == 0 {
return nil
}
// Notes on this query:
//
// # Receipts insert
// Conflict on (tx_hash, block_hash) shouldn't be possible because there
// should only ever be one receipt for an eth_tx, and if it exists then the
// transaction is marked confirmed which means we can never get here.
// However, even so, it still shouldn't be an error to upsert a receipt
// we already have.
//
// # EthTxAttempts update
// It should always be safe to mark the attempt as broadcast here because
// if it were not successfully broadcast how could it possibly have a
// receipt?
//
// This state is reachable for example if the eth node errors so the
// attempt was left in_progress but the transaction was actually accepted
// and mined.
//
// # EthTxes update
// Should be self-explanatory. If we got a receipt, the eth_tx is confirmed.
//
var valueStrs []string
var valueArgs []interface{}
i := 1
for _, r := range receipts {
var receiptJSON []byte
receiptJSON, err = json.Marshal(r)
if err != nil {
return errors.Wrap(err, "saveFetchedReceipts failed to marshal JSON")
}
valueStrs = append(valueStrs, fmt.Sprintf("($%v,$%v,$%v,$%v,$%v,NOW())", i, i+1, i+2, i+3, i+4))
valueArgs = append(valueArgs, r.TxHash, r.BlockHash, r.BlockNumber.Int64(), r.TransactionIndex, receiptJSON)
i += 5
}
/* #nosec G201 */
sql := `
WITH inserted_receipts AS (
INSERT INTO eth_receipts (tx_hash, block_hash, block_number, transaction_index, receipt, created_at)
VALUES %s
ON CONFLICT (tx_hash, block_hash) DO UPDATE SET
block_number = EXCLUDED.block_number,
transaction_index = EXCLUDED.transaction_index,
receipt = EXCLUDED.receipt
RETURNING eth_receipts.tx_hash, eth_receipts.block_number
),
updated_eth_tx_attempts AS (
UPDATE eth_tx_attempts
SET
state = 'broadcast',
broadcast_before_block_num = COALESCE(eth_tx_attempts.broadcast_before_block_num, inserted_receipts.block_number)
FROM inserted_receipts
WHERE inserted_receipts.tx_hash = eth_tx_attempts.hash
RETURNING eth_tx_attempts.eth_tx_id
)
UPDATE eth_txes
SET state = 'confirmed'
FROM updated_eth_tx_attempts
WHERE updated_eth_tx_attempts.eth_tx_id = eth_txes.id
`
stmt := fmt.Sprintf(sql, strings.Join(valueStrs, ","))
_, err = ec.store.MustSQLDB().ExecContext(ctx, stmt, valueArgs...)
return errors.Wrap(err, "saveFetchedReceipts failed to save receipts")
}
// markConfirmedMissingReceipt
// It is possible that we can fail to get a receipt for all eth_tx_attempts
// even though a transaction with this nonce has long since been confirmed (we
// know this because transactions with higher nonces HAVE returned a receipt).
//
// This can probably only happen if an external wallet used the account (or
// conceivably because of some bug in the remote eth node that prevents it
// from returning a receipt for a valid transaction).
//
// In this case we mark these transactions as 'confirmed_missing_receipt' to
// prevent gas bumping.
//
// We will continue to try to fetch a receipt for these attempts until all
// attempts are below the finality depth from current head.
func (ec *ethConfirmer) markConfirmedMissingReceipt(ctx context.Context) (err error) {
d, err := ec.store.DB.DB()
if err != nil {
return err
}
_, err = d.ExecContext(ctx, `
UPDATE eth_txes
SET state = 'confirmed_missing_receipt'
WHERE state = 'unconfirmed'
AND nonce < (
SELECT MAX(nonce) FROM eth_txes
WHERE state = 'confirmed'
)
`)
return
}
// markOldTxesMissingReceiptAsErrored
//
// Once eth_tx has all of its attempts broadcast before some cutoff threshold,
// we mark it as fatally errored (never sent).
//
// The job run will also be marked as errored in this case since we never got a
// receipt and thus cannot pass on any transaction hash
func (ec *ethConfirmer) markOldTxesMissingReceiptAsErrored(ctx context.Context, blockNum int64) error {
// cutoff is a block height
// Any 'confirmed_missing_receipt' eth_tx with all attempts older than this block height will be marked as errored
// We will not try to query for receipts for this transaction any more
cutoff := blockNum - int64(ec.config.EthFinalityDepth())
if cutoff <= 0 {
return nil
}
d, err := ec.store.DB.DB()
if err != nil {
return err
}
rows, err := d.QueryContext(ctx, `
UPDATE eth_txes
SET state='fatal_error', nonce=NULL, error=$1, broadcast_at=NULL
WHERE id IN (
SELECT eth_txes.id FROM eth_txes
INNER JOIN eth_tx_attempts ON eth_txes.id = eth_tx_attempts.eth_tx_id
WHERE eth_txes.state = 'confirmed_missing_receipt'
GROUP BY eth_txes.id
HAVING max(eth_tx_attempts.broadcast_before_block_num) < $2
)
RETURNING id, nonce, from_address`, ErrCouldNotGetReceipt, cutoff)
if err != nil {
return errors.Wrap(err, "markOldTxesMissingReceiptAsErrored failed to query")
}
for rows.Next() {
var ethTxID int64
var nonce null.Int64
var fromAddress gethCommon.Address
if err = rows.Scan(ðTxID, &nonce, &fromAddress); err != nil {
return errors.Wrap(err, "error scanning row")
}
logger.Errorf("EthConfirmer: eth_tx with ID %v expired without ever getting a receipt for any of our attempts. "+
"Current block height is %v. This transaction has not been sent and will be marked as fatally errored. "+
"This can happen if an external wallet has been used to send a transaction from account %s with nonce %v."+
" Please note that using the chainlink keys with an external wallet is NOT SUPPORTED and WILL lead to missed transactions",
ethTxID, blockNum, fromAddress.Hex(), nonce.Int64)
}
return errors.Wrap(rows.Close(), "markOldTxesMissingReceiptAsErrored failed to close rows")
}
func (ec *ethConfirmer) RebroadcastWhereNecessary(ctx context.Context, keys []models.Key, blockHeight int64) error {
var wg sync.WaitGroup
// It is safe to process separate keys concurrently
// NOTE: This design will block one key if another takes a really long time to execute
wg.Add(len(keys))
errors := []error{}
var errMu sync.Mutex
for _, key := range keys {
go func(fromAddress gethCommon.Address) {
if err := ec.rebroadcastWhereNecessary(ctx, fromAddress, blockHeight); err != nil {
errMu.Lock()
errors = append(errors, err)
errMu.Unlock()
logger.Errorw("Error in RebroadcastWhereNecessary", "error", err, "fromAddress", fromAddress)
}
wg.Done()
}(key.Address.Address())
}
wg.Wait()
return multierr.Combine(errors...)
}
func (ec *ethConfirmer) rebroadcastWhereNecessary(ctx context.Context, address gethCommon.Address, blockHeight int64) error {
if err := ec.handleAnyInProgressAttempts(ctx, address, blockHeight); err != nil {
return errors.Wrap(err, "handleAnyInProgressAttempts failed")
}
threshold := int64(ec.config.EthGasBumpThreshold())
depth := int64(ec.config.EthGasBumpTxDepth())
etxs, err := FindEthTxsRequiringRebroadcast(ec.store.DB, address, blockHeight, threshold, depth)
if err != nil {
return errors.Wrap(err, "FindEthTxsRequiringRebroadcast failed")
}
logger.Debugf("EthConfirmer: Rebroadcasting %v transactions", len(etxs))
for _, etx := range etxs {
// NOTE: This races with OCR transaction insertion that checks for
// out-of-eth. If we check at the wrong moment (while an
// insufficient_eth attempt has been temporarily moved to in_progress)
// we will send an extra transaction because it will appear as if no
// transactions are in insufficient_eth state.
//
// This still limits the worst case to a maximum of two transactions
// pending though which is probably acceptable.
attempt, err := ec.attemptForRebroadcast(etx)
if err != nil {
return errors.Wrap(err, "attemptForRebroadcast failed")
}
logger.Debugw("EthConfirmer: Rebroadcasting transaction", "ethTxID", etx.ID, "nonce", etx.Nonce, "nPreviousAttempts", len(etx.EthTxAttempts), "gasPrice", attempt.GasPrice)
if err := ec.saveInProgressAttempt(&attempt); err != nil {
return errors.Wrap(err, "saveInProgressAttempt failed")
}
if err := ec.handleInProgressAttempt(ctx, etx, attempt, blockHeight); err != nil {
return errors.Wrap(err, "handleInProgressAttempt failed")
}
}
return nil
}
// "in_progress" attempts were left behind after a crash/restart and may or may not have been sent.
// We should try to ensure they get on-chain so we can fetch a receipt for them.
// NOTE: We also use this to mark attempts for rebroadcast in event of a
// re-org, so multiple attempts are allowed to be in in_progress state (but
// only one per eth_tx).
func (ec *ethConfirmer) handleAnyInProgressAttempts(ctx context.Context, address gethCommon.Address, blockHeight int64) error {
attempts, err := getInProgressEthTxAttempts(ec.store, address)
if err != nil {
return errors.Wrap(err, "getInProgressEthTxAttempts failed")
}
for _, a := range attempts {
if err := ec.handleInProgressAttempt(ctx, a.EthTx, a, blockHeight); err != nil {
return errors.Wrap(err, "handleInProgressAttempt failed")
}
}
return nil
}
func getInProgressEthTxAttempts(s *store.Store, address gethCommon.Address) ([]models.EthTxAttempt, error) {
var attempts []models.EthTxAttempt
err := s.DB.
Preload("EthTx").
Joins("INNER JOIN eth_txes ON eth_txes.id = eth_tx_attempts.eth_tx_id AND eth_txes.state in ('confirmed', 'confirmed_missing_receipt', 'unconfirmed')").
Where("eth_tx_attempts.state = 'in_progress'").
Where("eth_txes.from_address = ?", address).
Find(&attempts).Error
return attempts, errors.Wrap(err, "getInProgressEthTxAttempts failed")
}
// FindEthTxsRequiringRebroadcast returns attempts that hit insufficient eth,
// and attempts that need bumping, in nonce ASC order
func FindEthTxsRequiringRebroadcast(db *gorm.DB, address gethCommon.Address, blockNum, gasBumpThreshold, depth int64) (etxs []models.EthTx, err error) {
// NOTE: These two queries could be combined into one using union but it
// becomes harder to read and difficult to test in isolation. KISS principle
etxInsufficientEths, err := FindEthTxsRequiringResubmissionDueToInsufficientEth(db, address)
if err != nil {
return nil, err
}
etxBumps, err := FindEthTxsRequiringGasBump(db, address, blockNum, gasBumpThreshold, depth)
if err != nil {
return nil, err
}
seen := make(map[int64]struct{})
for _, etx := range etxInsufficientEths {
seen[etx.ID] = struct{}{}
etxs = append(etxs, etx)
}
for _, etx := range etxBumps {
if _, exists := seen[etx.ID]; !exists {
etxs = append(etxs, etx)
}
}
sort.Slice(etxs, func(i, j int) bool {
return *(etxs[i].Nonce) < *(etxs[j].Nonce)
})
return
}
// FindEthTxsRequiringResubmissionDueToInsufficientEth returns transactions
// that need to be re-sent because they hit an out-of-eth error on a previous
// block
func Fi | b *gorm.DB, address gethCommon.Address) (etxs []models.EthTx, err error) {
err = db.
Preload("EthTxAttempts", func(db *gorm.DB) *gorm.DB {
return db.Order("eth_tx_attempts.gas_price DESC")
}).
Joins("INNER JOIN eth_tx_attempts ON eth_txes.id = eth_tx_attempts.eth_tx_id AND eth_tx_attempts.state = 'insufficient_eth'").
Where("eth_txes.from_address = ?", address).
Order("nonce ASC").
Find(&etxs).Error
err = errors.Wrap(err, "FindEthTxsRequiringResubmissionDueToInsufficientEth failed to load eth_txes having insufficient eth")
return
}
// FindEthTxsRequiringGasBump returns transactions that have all
// attempts which are unconfirmed for at least gasBumpThreshold blocks,
// limited by limit pending transactions
func FindEthTxsRequiringGasBump(db *gorm.DB, address gethCommon.Address, blockNum, gasBumpThreshold, depth int64) (etxs []models.EthTx, err error) {
q := db.
Preload("EthTxAttempts", func(db *gorm.DB) *gorm.DB {
return db.Order("eth_tx_attempts.gas_price DESC")
}).
Joins("LEFT JOIN eth_tx_attempts ON eth_txes.id = eth_tx_attempts.eth_tx_id "+
"AND (broadcast_before_block_num > ? OR broadcast_before_block_num IS NULL OR eth_tx_attempts.state != 'broadcast')", blockNum-gasBumpThreshold).
Where("eth_txes.state = 'unconfirmed' AND eth_tx_attempts.id IS NULL AND eth_txes.from_address = ?", address)
if depth > 0 {
q = q.Where("eth_txes.id IN (SELECT id FROM eth_txes WHERE state = 'unconfirmed' AND from_address = ? ORDER BY nonce ASC LIMIT ?)", address, depth)
}
err = q.Order("nonce ASC").Find(&etxs).Error
err = errors.Wrap(err, "FindEthTxsRequiringGasBump failed to load eth_txes requiring gas bump")
return
}
func (ec *ethConfirmer) attemptForRebroadcast(etx models.EthTx) (attempt models.EthTxAttempt, err error) {
var bumpedGasPrice *big.Int
if len(etx.EthTxAttempts) > 0 {
previousAttempt := etx.EthTxAttempts[0]
if previousAttempt.State == models.EthTxAttemptInsufficientEth {
// Do not create a new attempt if we ran out of eth last time since bumping gas is pointless
// Instead try to resubmit the same attempt at the same price, in the hope that the wallet was funded since our last attempt
logger.Debugw("EthConfirmer: rebroadcast InsufficientEth", "ethTxID", etx.ID, "ethTxAttemptID", previousAttempt.ID, "nonce", etx.Nonce, "txHash", previousAttempt.Hash)
previousAttempt.State = models.EthTxAttemptInProgress
return previousAttempt, nil
}
previousGasPrice := previousAttempt.GasPrice
bumpedGasPrice, err = BumpGas(ec.config, previousGasPrice.ToInt())
if err != nil {
logger.Errorw("Failed to bump gas", "err", err, "etxID", etx.ID, "txHash", attempt.Hash, "originalGasPrice", previousGasPrice.String(), "maxGasPrice", ec.config.EthMaxGasPriceWei())
// Do not create a new attempt if bumping gas would put us over the limit or cause some other problem
// Instead try to resubmit the previous attempt, and keep resubmitting until its accepted
previousAttempt.BroadcastBeforeBlockNum = nil
previousAttempt.State = models.EthTxAttemptInProgress
return previousAttempt, nil
}
logger.Debugw("EthConfirmer: rebroadcast bumping gas",
"ethTxID", etx.ID, "nonce", etx.Nonce, "originalGasPrice", previousGasPrice.String(),
"bumpedGasPrice", bumpedGasPrice.String(), "previousTxHash", previousAttempt.Hash, "previousAttemptID", previousAttempt.ID)
} else {
logger.Errorf("invariant violation: EthTx %v was unconfirmed but didn't have any attempts. "+
"Falling back to default gas price instead."+
"This is a bug! Please report to https://github.com/smartcontractkit/chainlink/issues", etx.ID)
bumpedGasPrice = ec.config.EthGasPriceDefault()
}
return newAttempt(ec.store, etx, bumpedGasPrice)
}
func (ec *ethConfirmer) saveInProgressAttempt(attempt *models.EthTxAttempt) error {
if attempt.State != models.EthTxAttemptInProgress {
return errors.New("saveInProgressAttempt failed: attempt state must be in_progress")
}
return errors.Wrap(ec.store.DB.Save(attempt).Error, "saveInProgressAttempt failed")
}
func (ec *ethConfirmer) handleInProgressAttempt(ctx context.Context, etx models.EthTx, attempt models.EthTxAttempt, blockHeight int64) error {
if attempt.State != models.EthTxAttemptInProgress {
return errors.Errorf("invariant violation: expected eth_tx_attempt %v to be in_progress, it was %s", attempt.ID, attempt.State)
}
sendError := sendTransaction(ctx, ec.ethClient, attempt)
if sendError.IsTerminallyUnderpriced() {
// This should really not ever happen in normal operation since we
// already bumped above the required minimum in ethBroadcaster.
//
// It could conceivably happen if the remote eth node changed its configuration.
bumpedGasPrice, err := BumpGas(ec.config, attempt.GasPrice.ToInt())
if err != nil {
return errors.Wrap(err, "could not bump gas for terminally underpriced transaction")
}
logger.Errorf("gas price %v wei was rejected by the eth node for being too low. "+
"Eth node returned: '%s'. "+
"Bumping to %v wei and retrying. "+
"ACTION REQUIRED: You should consider increasing ETH_GAS_PRICE_DEFAULT", attempt.GasPrice, sendError.Error(), bumpedGasPrice)
replacementAttempt, err := newAttempt(ec.store, etx, bumpedGasPrice)
if err != nil {
return errors.Wrap(err, "newAttempt failed")
}
if err := saveReplacementInProgressAttempt(ec.store, attempt, &replacementAttempt); err != nil {
return errors.Wrap(err, "saveReplacementInProgressAttempt failed")
}
return ec.handleInProgressAttempt(ctx, etx, replacementAttempt, blockHeight)
}
if sendError.IsTemporarilyUnderpriced() {
// Most likely scenario here is a parity node that is rejecting
// low-priced transactions due to mempool pressure
//
// In that case, the safest thing to do is to pretend the transaction
// was accepted and continue the normal gas bumping cycle until we can
// get it into the mempool
logger.Infow("EthConfirmer: Transaction temporarily underpriced", "ethTxID", etx.ID, "attemptID", attempt.ID, "err", sendError.Error(), "gasPriceWei", attempt.GasPrice.String())
sendError = nil
}
if sendError.Fatal() {
// WARNING: This should never happen!
// Should NEVER be fatal this is an invariant violation. The
// EthBroadcaster can never create an EthTxAttempt that will
// fatally error.
//
// The only scenario imaginable where this might take place is if
// geth/parity have been updated between broadcasting and confirming steps.
logger.Errorw("invariant violation: fatal error while re-attempting transaction",
"ethTxID", etx.ID,
"err", sendError,
"signedRawTx", hexutil.Encode(attempt.SignedRawTx),
"blockHeight", blockHeight,
)
// This will loop continuously on every new head so it must be handled manually by the node operator!
return deleteInProgressAttempt(ec.store.DB, attempt)
}
if sendError.IsNonceTooLowError() {
// Nonce too low indicated that a transaction at this nonce was confirmed already.
// Assume success and hand off to the next cycle to fetch a receipt and mark confirmed.
sendError = nil
}
if sendError.IsReplacementUnderpriced() {
// Our system constraints guarantee that the attempt referenced in this
// function has the highest gas price of all attempts.
//
// Thus, there are only two possible scenarios where this can happen.
//
// 1. Our gas bump was insufficient compared to our previous attempt
// 2. An external wallet used the account to manually send a transaction
// at a higher gas price
//
// In this case the simplest and most robust way to recover is to ignore
// this attempt and wait until the next bump threshold is reached in
// order to bump again.
logger.Errorw(fmt.Sprintf("EthConfirmer: replacement transaction underpriced at %v wei for eth_tx %v. "+
"Eth node returned error: '%s'. "+
"Either you have set ETH_GAS_BUMP_PERCENT (currently %v%%) too low or an external wallet used this account. "+
"Please note that using your node's private keys outside of the chainlink node is NOT SUPPORTED and can lead to missed transactions.",
attempt.GasPrice.ToInt().Int64(), etx.ID, sendError.Error(), ec.store.Config.EthGasBumpPercent()), "err", sendError)
// Assume success and hand off to the next cycle.
sendError = nil
}
if sendError.IsInsufficientEth() {
logger.Errorw(fmt.Sprintf("EthConfirmer: EthTxAttempt %v (hash 0x%x) at gas price (%s Wei) was rejected due to insufficient eth. "+
"The eth node returned %s. "+
"ACTION REQUIRED: Chainlink wallet with address 0x%x is OUT OF FUNDS",
attempt.ID, attempt.Hash, attempt.GasPrice.String(), sendError.Error(), etx.FromAddress,
), "err", sendError)
return saveInsufficientEthAttempt(ec.store.DB, &attempt)
}
if sendError == nil {
logger.Debugw("EthConfirmer: successfully broadcast transaction", "ethTxID", etx.ID, "ethTxAttemptID", attempt.ID, "txHash", attempt.Hash.Hex())
return saveSentAttempt(ec.store.DB, &attempt)
}
// Any other type of error is considered temporary or resolvable by the
// node operator. The node may have it in the mempool so we must keep the
// attempt (leave it in_progress). Safest thing to do is bail out and wait
// for the next head.
return errors.Wrapf(sendError, "unexpected error sending eth_tx %v with hash %s", etx.ID, attempt.Hash.Hex())
}
func deleteInProgressAttempt(db *gorm.DB, attempt models.EthTxAttempt) error {
if attempt.State != models.EthTxAttemptInProgress {
return errors.New("deleteInProgressAttempt: expected attempt state to be in_progress")
}
if attempt.ID == 0 {
return errors.New("deleteInProgressAttempt: expected attempt to have an id")
}
return errors.Wrap(db.Exec(`DELETE FROM eth_tx_attempts WHERE id = ?`, attempt.ID).Error, "deleteInProgressAttempt failed")
}
func saveSentAttempt(db *gorm.DB, attempt *models.EthTxAttempt) error {
if attempt.State != models.EthTxAttemptInProgress {
return errors.New("expected state to be in_progress")
}
attempt.State = models.EthTxAttemptBroadcast
return errors.Wrap(db.Save(attempt).Error, "saveSentAttempt failed")
}
func saveInsufficientEthAttempt(db *gorm.DB, attempt *models.EthTxAttempt) error {
if !(attempt.State == models.EthTxAttemptInProgress || attempt.State == models.EthTxAttemptInsufficientEth) {
return errors.New("expected state to be either in_progress or insufficient_eth")
}
attempt.State = models.EthTxAttemptInsufficientEth
return errors.Wrap(db.Save(attempt).Error, "saveInsufficientEthAttempt failed")
}
// EnsureConfirmedTransactionsInLongestChain finds all confirmed eth_txes up to the depth
// of the given chain and ensures that every one has a receipt with a block hash that is
// in the given chain.
//
// If any of the confirmed transactions does not have a receipt in the chain, it has been
// re-org'd out and will be rebroadcast.
func (ec *ethConfirmer) EnsureConfirmedTransactionsInLongestChain(ctx context.Context, keys []models.Key, head models.Head) error {
etxs, err := findTransactionsConfirmedAtOrAboveBlockHeight(ec.store.DB, head.EarliestInChain().Number)
if err != nil {
return errors.Wrap(err, "findTransactionsConfirmedAtOrAboveBlockHeight failed")
}
for _, etx := range etxs {
if !hasReceiptInLongestChain(etx, head) {
if err := ec.markForRebroadcast(etx); err != nil {
return errors.Wrapf(err, "markForRebroadcast failed for etx %v", etx.ID)
}
}
}
// It is safe to process separate keys concurrently
// NOTE: This design will block one key if another takes a really long time to execute
var wg sync.WaitGroup
errors := []error{}
var errMu sync.Mutex
wg.Add(len(keys))
for _, key := range keys {
go func(fromAddress gethCommon.Address) {
if err := ec.handleAnyInProgressAttempts(ctx, fromAddress, head.Number); err != nil {
errMu.Lock()
errors = append(errors, err)
errMu.Unlock()
logger.Errorw("Error in handleAnyInProgressAttempts", "error", err, "fromAddress", fromAddress)
}
wg.Done()
}(key.Address.Address())
}
wg.Wait()
return multierr.Combine(errors...)
}
func findTransactionsConfirmedAtOrAboveBlockHeight(db *gorm.DB, blockNumber int64) ([]models.EthTx, error) {
var etxs []models.EthTx
err := db.
Preload("EthTxAttempts", func(db *gorm.DB) *gorm.DB {
return db.Order("eth_tx_attempts.gas_price DESC")
}).
Preload("EthTxAttempts.EthReceipts").
Joins("INNER JOIN eth_tx_attempts ON eth_txes.id = eth_tx_attempts.eth_tx_id AND eth_tx_attempts.state = 'broadcast'").
Joins("INNER JOIN eth_receipts ON eth_receipts.tx_hash = eth_tx_attempts.hash").
Order("nonce ASC").
Where("eth_txes.state IN ('confirmed', 'confirmed_missing_receipt') AND block_number >= ?", blockNumber).
Find(&etxs).Error
return etxs, errors.Wrap(err, "findTransactionsConfirmedAtOrAboveBlockHeight failed")
}
func hasReceiptInLongestChain(etx models.EthTx, head models.Head) bool {
for {
for _, attempt := range etx.EthTxAttempts {
for _, receipt := range attempt.EthReceipts {
if receipt.BlockHash == head.Hash && receipt.BlockNumber == head.Number {
return true
}
}
}
if head.Parent == nil {
return false
}
head = *head.Parent
}
}
func (ec *ethConfirmer) markForRebroadcast(etx models.EthTx) error {
if len(etx.EthTxAttempts) == 0 {
return errors.Errorf("invariant violation: expected eth_tx %v to have at least one attempt", etx.ID)
}
// Rebroadcast the one with the highest gas price
attempt := etx.EthTxAttempts[0]
// Put it back in progress and delete all receipts (they do not apply to the new chain)
err := ec.store.Transaction(func(tx *gorm.DB) error {
if err := deleteAllReceipts(tx, etx.ID); err != nil {
return errors.Wrapf(err, "deleteAllReceipts failed for etx %v", etx.ID)
}
if err := unconfirmEthTx(tx, etx); err != nil {
return errors.Wrapf(err, "unconfirmEthTx failed for etx %v", etx.ID)
}
return unbroadcastAttempt(tx, attempt)
})
return errors.Wrap(err, "markForRebroadcast failed")
}
func deleteAllReceipts(db *gorm.DB, etxID int64) error {
return db.Exec(`
DELETE FROM eth_receipts
USING eth_tx_attempts
WHERE eth_receipts.tx_hash = eth_tx_attempts.hash
AND eth_tx_attempts.eth_tx_id = ?
`, etxID).Error
}
func unconfirmEthTx(db *gorm.DB, etx models.EthTx) error {
if etx.State != models.EthTxConfirmed {
return errors.New("expected eth_tx state to be confirmed")
}
return errors.Wrap(db.Exec(`UPDATE eth_txes SET state = 'unconfirmed' WHERE id = ?`, etx.ID).Error, "unconfirmEthTx failed")
}
func unbroadcastAttempt(db *gorm.DB, attempt models.EthTxAttempt) error {
if attempt.State != models.EthTxAttemptBroadcast {
return errors.New("expected eth_tx_attempt to be broadcast")
}
return errors.Wrap(db.Exec(`UPDATE eth_tx_attempts SET broadcast_before_block_num = NULL, state = 'in_progress' WHERE id = ?`, attempt.ID).Error, "unbroadcastAttempt failed")
}
// ForceRebroadcast sends a transaction for every nonce in the given nonce range at the given gas price.
// If an eth_tx exists for this nonce, we re-send the existing eth_tx with the supplied parameters.
// If an eth_tx doesn't exist for this nonce, we send a zero transaction.
// This operates completely orthogonal to the normal EthConfirmer and can result in untracked attempts!
// Only for emergency usage.
// Deliberately does not take the advisory lock (we don't write to the database so this is safe from a data integrity perspective).
// This is in case of some unforeseen scenario where the node is refusing to release the lock. KISS.
func (ec *ethConfirmer) ForceRebroadcast(beginningNonce uint, endingNonce uint, gasPriceWei uint64, address gethCommon.Address, overrideGasLimit uint64) error {
logger.Infof("ForceRebroadcast: will rebroadcast transactions for all nonces between %v and %v", beginningNonce, endingNonce)
for n := beginningNonce; n <= endingNonce; n++ {
etx, err := findEthTxWithNonce(ec.store.DB, address, n)
if err != nil {
return errors.Wrap(err, "ForceRebroadcast failed")
}
if etx == nil {
logger.Debugf("ForceRebroadcast: no eth_tx found with nonce %v, will rebroadcast empty transaction", n)
hash, err := ec.sendEmptyTransaction(context.TODO(), address, n, overrideGasLimit, gasPriceWei)
if err != nil {
logger.Errorw("ForceRebroadcast: failed to send empty transaction", "nonce", n, "err", err)
continue
}
logger.Infow("ForceRebroadcast: successfully rebroadcast empty transaction", "nonce", n, "hash", hash.String())
} else {
logger.Debugf("ForceRebroadcast: got eth_tx %v with nonce %v, will rebroadcast this transaction", etx.ID, *etx.Nonce)
if overrideGasLimit != 0 {
etx.GasLimit = overrideGasLimit
}
attempt, err := newAttempt(ec.store, *etx, big.NewInt(int64(gasPriceWei)))
if err != nil {
logger.Errorw("ForceRebroadcast: failed to create new attempt", "ethTxID", etx.ID, "err", err)
continue
}
if err := sendTransaction(context.TODO(), ec.ethClient, attempt); err != nil {
logger.Errorw(fmt.Sprintf("ForceRebroadcast: failed to rebroadcast eth_tx %v with nonce %v at gas price %s wei and gas limit %v: %s", etx.ID, *etx.Nonce, attempt.GasPrice.String(), etx.GasLimit, err.Error()), "err", err)
continue
}
logger.Infof("ForceRebroadcast: successfully rebroadcast eth_tx %v with hash: 0x%x", etx.ID, attempt.Hash)
}
}
return nil
}
func (ec *ethConfirmer) sendEmptyTransaction(ctx context.Context, fromAddress gethCommon.Address, nonce uint, overrideGasLimit uint64, gasPriceWei uint64) (gethCommon.Hash, error) {
gasLimit := overrideGasLimit
if gasLimit == 0 {
gasLimit = ec.config.EthGasLimitDefault()
}
account, err := ec.store.KeyStore.GetAccountByAddress(fromAddress)
if err != nil {
return gethCommon.Hash{}, errors.Wrap(err, "(ethConfirmer).sendEmptyTransaction failed")
}
tx, err := sendEmptyTransaction(ec.ethClient, ec.store.KeyStore, uint64(nonce), gasLimit, big.NewInt(int64(gasPriceWei)), account, ec.config.ChainID())
if err != nil {
return gethCommon.Hash{}, errors.Wrap(err, "(ethConfirmer).sendEmptyTransaction failed")
}
return tx.Hash(), nil
}
// findEthTxWithNonce returns any broadcast ethtx with the given nonce
func findEthTxWithNonce(db *gorm.DB, fromAddress gethCommon.Address, nonce uint) (*models.EthTx, error) {
etx := models.EthTx{}
err := db.
Preload("EthTxAttempts", func(db *gorm.DB) *gorm.DB {
return db.Order("eth_tx_attempts.gas_price DESC")
}).
First(&etx, "from_address = ? AND nonce = ? AND state IN ('confirmed', 'confirmed_missing_receipt', 'unconfirmed')", fromAddress, nonce).
Error
if errors.Is(err, gorm.ErrRecordNotFound) {
return nil, nil
}
return &etx, errors.Wrap(err, "findEthTxsWithNonce failed")
}
| ndEthTxsRequiringResubmissionDueToInsufficientEth(d |
layout.tsx | import React from 'react'
import { Layout as AntdLayout, Menu } from 'antd'
import { Link } from 'react-router-dom'
import { HomeOutlined } from '@ant-design/icons'
const { Header, Content } = AntdLayout
export const Layout: React.FC = (props: any) => {
return (
<AntdLayout style={{ minHeight: '100vh' }}>
<Header className="header">
<Menu theme="dark" mode="horizontal" defaultSelectedKeys={['1']}>
<Menu.Item key="1">
<Link to="/">
<HomeOutlined />
</Link>
</Menu.Item>
<Menu.Item key="2">
<Link to="/degree/bachelor">Бакалавриат</Link>
</Menu.Item>
<Menu.Item key="3">
<Link to="/degree/specialist">Специалитет</Link>
</Menu.Item>
<Menu.Item key="4">
<Link to="/degree/master">Магистратура</Link>
</Menu.Item>
</Menu>
</Header>
<AntdLayout style={{ padding: '0 24px 24px', minHeight: '100vh' }}>
<Content
style={{
padding: 24,
margin: 0,
minHeight: '100%', | </Content>
</AntdLayout>
</AntdLayout>
)
} | }}
>
{props?.children} |
errors.go | package flowcontext
import (
"errors"
"strings"
"sync/atomic"
"github.com/kaspanet/kaspad/infrastructure/network/netadapter/router"
"github.com/kaspanet/kaspad/app/protocol/protocolerrors"
)
var (
// ErrPingTimeout signifies that a ping operation timed out.
ErrPingTimeout = protocolerrors.New(false, "timeout expired on ping")
)
// HandleError handles an error from a flow,
// It sends the error to errChan if isStopping == 0 and increments isStopping
//
// If this is ErrRouteClosed - forward it to errChan
// If this is ProtocolError - logs the error, and forward it to errChan
// Otherwise - panics
func (*FlowContext) HandleError(err error, flowName string, isStopping *uint32, errChan chan<- error) {
isErrRouteClosed := errors.Is(err, router.ErrRouteClosed)
if !isErrRouteClosed |
if atomic.AddUint32(isStopping, 1) == 1 {
errChan <- err
}
}
// IsRecoverableError returns whether the error is recoverable
func (*FlowContext) IsRecoverableError(err error) bool {
return err == nil || errors.Is(err, router.ErrRouteClosed) || errors.As(err, &protocolerrors.ProtocolError{})
}
| {
if protocolErr := (protocolerrors.ProtocolError{}); !errors.As(err, &protocolErr) {
panic(err)
}
if errors.Is(err, ErrPingTimeout) {
// Avoid printing the call stack on ping timeouts, since users get panicked and this case is not interesting
log.Errorf("error from %s: %s", flowName, err)
} else {
// Explain to the user that this is not a panic, but only a protocol error with a specific peer
logFrame := strings.Repeat("=", 52)
log.Errorf("Non-critical peer protocol error from %s, printing the full stack for debug purposes: \n%s\n%+v \n%s",
flowName, logFrame, err, logFrame)
}
} |
baz.rs | #![allow(dead_code)]
use metered::{metered, ErrorCount, HitCount, InFlight, ResponseTime};
use thiserror::Error;
#[metered::error_count(name = LibErrorCount, visibility = pub)]
#[derive(Debug, Error)]
pub enum LibError {
#[error("I failed!")]
Failure,
#[error("Bad input")]
BadInput,
}
#[metered::error_count(name = BazErrorCount, visibility = pub, skip_cleared = true)]
#[derive(Debug, Error)]
pub enum BazError {
#[error("lib error: {0}")]
Lib(#[from] #[nested] LibError),
#[error("io error")]
Io,
}
#[derive(Default, Debug, serde::Serialize)] | #[metered(registry = BazMetricRegistry, /* default = self.metrics */ registry_expr = self.metric_reg, visibility = pub(self))]
#[measure(InFlight)] // Applies to all methods that have the `measure` attribute
impl Baz {
// This is measured with an InFlight gauge, because it's the default on the block.
#[measure]
pub fn bir(&self) {
println!("bir");
let delay = std::time::Duration::from_millis(rand::random::<u64>() % 2000);
std::thread::sleep(delay);
}
// This is not measured
pub fn bor(&self) {
println!("bor");
}
#[measure(ResponseTime)]
pub fn foo(&self) {
println!("foo !");
let delay = std::time::Duration::from_millis(rand::random::<u64>() % 2000);
std::thread::sleep(delay);
}
#[measure(type = HitCount<metered::atomic::AtomicInt<u64>>)]
#[measure(ErrorCount)]
#[measure(ResponseTime)]
pub fn bar(&self, should_fail: bool) -> Result<(), &'static str> {
if !should_fail {
println!("bar !");
Ok(())
} else {
Err("I failed!")
}
}
#[measure([ErrorCount, ResponseTime])]
pub async fn baz(&self, should_fail: bool) -> Result<(), &'static str> {
let delay = std::time::Duration::from_millis(rand::random::<u64>() % 2000);
tokio::time::delay_for(delay).await;
if !should_fail {
println!("baz !");
Ok(())
} else {
Err("I failed!")
}
}
#[measure([ResponseTime])]
pub fn bazium(
&self,
should_fail: bool,
) -> impl std::future::Future<Output = Result<(), &'static str>> {
async move {
let delay = std::time::Duration::from_millis(rand::random::<u64>() % 2000);
tokio::time::delay_for(delay).await;
if !should_fail {
println!("baz !");
Ok(())
} else {
Err("I failed!")
}
}
}
#[measure([HitCount, BazErrorCount])]
pub async fn bazle(&self, should_fail: bool) -> Result<(), BazError> {
if !should_fail {
println!("bazle !");
Ok(())
} else {
Err(LibError::Failure.into())
}
}
#[measure]
pub unsafe fn bad(&self, v: &[u8]) {
std::str::from_utf8_unchecked(v);
}
// This is not measured either
pub fn bur() {
println!("bur");
}
} | pub struct Baz {
metric_reg: BazMetricRegistry,
}
|
config.py | import os
from dotenv import load_dotenv, find_dotenv
#this will load all the envars from a .env file located in the project root (api)
load_dotenv(find_dotenv())
CONFIGURATION = {
"development": "config.DevConfig",
"testing": "config.TestConfig",
"production": "config.Config",
"default": "config.Config"
}
class | (object):
PROJECT_ROOT = os.path.abspath(os.path.dirname(__file__))
SECRET_KEY = 'a secret'
SQLALCHEMY_TRACK_MODIFICATIONS = False
NRO_SERVICE_ACCOUNT = os.getenv('NRO_SERVICE_ACCOUNT', 'nro_service_account')
SOLR_BASE_URL = os.getenv('SOLR_BASE_URL', None)
SOLR_SYNONYMS_API_URL = os.getenv('SOLR_SYNONYMS_API_URL', None)
NRO_EXTRACTOR_URI = os.getenv('NRO_EXTRACTOR_URI', None)
ALEMBIC_INI='migrations/alembic.ini'
# POSTGRESQL
DB_USER = os.getenv('DATABASE_USERNAME', '')
DB_PASSWORD = os.getenv('DATABASE_PASSWORD','')
DB_NAME = os.getenv('DATABASE_NAME','')
DB_HOST = os.getenv('DATABASE_HOST','')
DB_PORT = os.getenv('DATABASE_PORT','5432')
SQLALCHEMY_DATABASE_URI = 'postgresql://{user}:{password}@{host}:{port}/{name}'.format(
user=DB_USER,
password=DB_PASSWORD,
host=DB_HOST,
port=int(DB_PORT),
name=DB_NAME,
)
## ORACLE - LEGACY NRO NAMESDB
NRO_USER = os.getenv('NRO_USER', '')
NRO_SCHEMA = os.getenv('NRO_SCHEMA', None)
NRO_PASSWORD = os.getenv('NRO_PASSWORD', '')
NRO_DB_NAME = os.getenv('NRO_DB_NAME', '')
NRO_HOST = os.getenv('NRO_HOST', '')
NRO_PORT = int(os.getenv('NRO_PORT', '1521'))
# JWT_OIDC Settings
JWT_OIDC_WELL_KNOWN_CONFIG = os.getenv('JWT_OIDC_WELL_KNOWN_CONFIG')
JWT_OIDC_ALGORITHMS = os.getenv('JWT_OIDC_ALGORITHMS')
JWT_OIDC_JWKS_URI = os.getenv('JWT_OIDC_JWKS_URI')
JWT_OIDC_ISSUER = os.getenv('JWT_OIDC_ISSUER')
JWT_OIDC_AUDIENCE = os.getenv('JWT_OIDC_AUDIENCE')
JWT_OIDC_CLIENT_SECRET = os.getenv('JWT_OIDC_CLIENT_SECRET')
JWT_OIDC_CACHING_ENABLED = os.getenv('JWT_OIDC_CACHING_ENABLED')
try:
JWT_OIDC_JWKS_CACHE_TIMEOUT = int(os.getenv('JWT_OIDC_JWKS_CACHE_TIMEOUT'))
except:
JWT_OIDC_JWKS_CACHE_TIMEOUT = 300
TESTING = False,
DEBUG = False
class DevConfig(Config):
TESTING = False,
DEBUG = True
class TestConfig(Config):
DEBUG = True
TESTING = True
# POSTGRESQL
DB_USER = os.getenv('DATABASE_TEST_USERNAME', '')
DB_PASSWORD = os.getenv('DATABASE_TEST_PASSWORD','')
DB_NAME = os.getenv('DATABASE_TEST_NAME','')
DB_HOST = os.getenv('DATABASE_TEST_HOST','')
DB_PORT = os.getenv('DATABASE_TEST_PORT','5432')
SQLALCHEMY_DATABASE_URI = 'postgresql://{user}:{password}@{host}:{port}/{name}'.format(
user=DB_USER,
password=DB_PASSWORD,
host=DB_HOST,
port=int(DB_PORT),
name=DB_NAME,
)
# JWT OIDC settings
## JWT_OIDC_TEST_MODE will set jwt_manager to use
JWT_OIDC_TEST_MODE = True
JWT_OIDC_TEST_AUDIENCE = os.getenv('JWT_OIDC_AUDIENCE')
JWT_OIDC_TEST_CLIENT_SECRET = os.getenv('JWT_OIDC_CLIENT_SECRET')
JWT_OIDC_TEST_ISSUER = 'https://sso-dev.pathfinder.gov.bc.ca/auth/realms/sbc'
JWT_OIDC_TEST_KEYS = {
"keys": [
{
"kid": "flask-jwt-oidc-test-client",
"kty": "RSA",
"alg": "RS256",
"use": "sig",
"n": "AN-fWcpCyE5KPzHDjigLaSUVZI0uYrcGcc40InVtl-rQRDmAh-C2W8H4_Hxhr5VLc6crsJ2LiJTV_E72S03pzpOOaaYV6-TzAjCou2GYJIXev7f6Hh512PuG5wyxda_TlBSsI-gvphRTPsKCnPutrbiukCYrnPuWxX5_cES9eStR",
"e": "AQAB"
}
]
}
JWT_OIDC_TEST_PRIVATE_KEY_JWKS = {
"keys": [
{
"kid": "flask-jwt-oidc-test-client",
"kty": "RSA",
"alg": "RS256",
"use": "sig",
"kty": "RSA",
"n": "AN-fWcpCyE5KPzHDjigLaSUVZI0uYrcGcc40InVtl-rQRDmAh-C2W8H4_Hxhr5VLc6crsJ2LiJTV_E72S03pzpOOaaYV6-TzAjCou2GYJIXev7f6Hh512PuG5wyxda_TlBSsI-gvphRTPsKCnPutrbiukCYrnPuWxX5_cES9eStR",
"e": "AQAB",
"d": "C0G3QGI6OQ6tvbCNYGCqq043YI_8MiBl7C5dqbGZmx1ewdJBhMNJPStuckhskURaDwk4-8VBW9SlvcfSJJrnZhgFMjOYSSsBtPGBIMIdM5eSKbenCCjO8Tg0BUh_xa3CHST1W4RQ5rFXadZ9AeNtaGcWj2acmXNO3DVETXAX3x0",
"p": "APXcusFMQNHjh6KVD_hOUIw87lvK13WkDEeeuqAydai9Ig9JKEAAfV94W6Aftka7tGgE7ulg1vo3eJoLWJ1zvKM",
"q": "AOjX3OnPJnk0ZFUQBwhduCweRi37I6DAdLTnhDvcPTrrNWuKPg9uGwHjzFCJgKd8KBaDQ0X1rZTZLTqi3peT43s",
"dp": "AN9kBoA5o6_Rl9zeqdsIdWFmv4DB5lEqlEnC7HlAP-3oo3jWFO9KQqArQL1V8w2D4aCd0uJULiC9pCP7aTHvBhc",
"dq": "ANtbSY6njfpPploQsF9sU26U0s7MsuLljM1E8uml8bVJE1mNsiu9MgpUvg39jEu9BtM2tDD7Y51AAIEmIQex1nM",
"qi": "XLE5O360x-MhsdFXx8Vwz4304-MJg-oGSJXCK_ZWYOB_FGXFRTfebxCsSYi0YwJo-oNu96bvZCuMplzRI1liZw"
}
]
}
JWT_OIDC_TEST_PRIVATE_KEY_PEM = """
-----BEGIN RSA PRIVATE KEY-----
MIICXQIBAAKBgQDfn1nKQshOSj8xw44oC2klFWSNLmK3BnHONCJ1bZfq0EQ5gIfg
tlvB+Px8Ya+VS3OnK7Cdi4iU1fxO9ktN6c6TjmmmFevk8wIwqLthmCSF3r+3+h4e
ddj7hucMsXWv05QUrCPoL6YUUz7Cgpz7ra24rpAmK5z7lsV+f3BEvXkrUQIDAQAB
AoGAC0G3QGI6OQ6tvbCNYGCqq043YI/8MiBl7C5dqbGZmx1ewdJBhMNJPStuckhs
kURaDwk4+8VBW9SlvcfSJJrnZhgFMjOYSSsBtPGBIMIdM5eSKbenCCjO8Tg0BUh/
xa3CHST1W4RQ5rFXadZ9AeNtaGcWj2acmXNO3DVETXAX3x0CQQD13LrBTEDR44ei
lQ/4TlCMPO5bytd1pAxHnrqgMnWovSIPSShAAH1feFugH7ZGu7RoBO7pYNb6N3ia
C1idc7yjAkEA6Nfc6c8meTRkVRAHCF24LB5GLfsjoMB0tOeEO9w9Ous1a4o+D24b
AePMUImAp3woFoNDRfWtlNktOqLel5PjewJBAN9kBoA5o6/Rl9zeqdsIdWFmv4DB
5lEqlEnC7HlAP+3oo3jWFO9KQqArQL1V8w2D4aCd0uJULiC9pCP7aTHvBhcCQQDb
W0mOp436T6ZaELBfbFNulNLOzLLi5YzNRPLppfG1SRNZjbIrvTIKVL4N/YxLvQbT
NrQw+2OdQACBJiEHsdZzAkBcsTk7frTH4yGx0VfHxXDPjfTj4wmD6gZIlcIr9lZg
4H8UZcVFN95vEKxJiLRjAmj6g273pu9kK4ymXNEjWWJn
-----END RSA PRIVATE KEY-----"""
| Config |
packet.rs | /* Copyright 2021 Perry Lorier
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*
* SPDX-License-Identifier: Apache-2.0
*
* Functions to create raw packets as a [u8]
*/
use std::net;
fn partial_netsum(current: u32, buffer: &[u8]) -> u32 {
let mut i = 0;
let mut sum = current;
let mut count = buffer.len();
while count > 1 {
let v = ((buffer[i] as u32) << 8) | (buffer[i + 1] as u32);
sum += v;
i += 2;
count -= 2;
}
if count > 0 {
let v = (buffer[i] as u32) << 8;
sum += v;
}
sum
}
fn finish_netsum(sum: u32) -> u16 {
let mut sum = sum;
while sum > 0xffff {
sum = (sum >> 16) + (sum & 0xFFFF);
}
!(sum as u16)
}
#[derive(Clone, Debug)]
pub enum Tail<'a> {
Payload(&'a [u8]),
Fragment(Box<Fragment<'a>>),
#[allow(dead_code)]
None,
}
impl<'a> Tail<'a> {
fn len(&self) -> usize {
match self {
Tail::Payload(x) => x.len(),
Tail::Fragment(x) => x.len(),
Tail::None => 0,
}
}
fn partial_netsum(&self, current: u32) -> u32 {
match self {
Tail::Payload(x) => partial_netsum(current, x),
Tail::Fragment(x) => x.partial_netsum(current),
Tail::None => current,
}
}
}
| tail: Tail<'a>,
}
impl<'a> Fragment<'a> {
fn len(&self) -> usize {
self.buffer.len() + self.tail.len()
}
fn partial_netsum(&self, current: u32) -> u32 {
self.tail
.partial_netsum(partial_netsum(current, &self.buffer))
}
fn netsum(&self) -> u16 {
finish_netsum(self.partial_netsum(0))
}
pub fn flatten(&self) -> Vec<u8> {
let mut x = self;
let mut ret = vec![];
loop {
ret.extend_from_slice(&x.buffer);
match &x.tail {
Tail::None => break,
Tail::Payload(x) => {
ret.extend_from_slice(x);
break;
}
Tail::Fragment(f) => {
x = f.as_ref();
}
}
}
ret
}
fn from_tail(tail: Tail) -> Fragment {
Fragment {
buffer: vec![],
tail,
}
}
fn push_u8(&mut self, b: u8) {
self.buffer.push(b);
}
fn push_bytes(&mut self, b: &[u8]) {
self.buffer.extend_from_slice(b);
}
fn push_be16(&mut self, b: u16) {
self.push_bytes(&b.to_be_bytes());
}
fn new_ethernet<'l>(
dst: &[u8; 6],
src: &[u8; 6],
ethertype: u16,
payload: Tail<'l>,
) -> Fragment<'l> {
let mut f = Fragment::from_tail(payload);
f.push_bytes(dst);
f.push_bytes(src);
f.push_be16(ethertype);
f
}
fn new_ipv4<'l>(
src: &net::Ipv4Addr,
srcmac: &[u8; 6],
dst: &net::Ipv4Addr,
dstmac: &[u8; 6],
protocol: u8,
payload: Tail<'l>,
) -> Fragment<'l> {
let mut f = Fragment::from_tail(payload);
f.push_u8(0x45); /* version 4, length 5*4 bytes */
f.push_u8(0x00); /* ToS */
f.push_be16(20_u16 + f.tail.len() as u16); /* Total Length */
f.push_be16(0x0000); /* Identification */
f.push_be16(0x0000); /* Flags + Frag Offset */
f.push_u8(0x01); /* TTL */
f.push_u8(protocol);
f.push_be16(0x0000); /* Checksum - filled in below*/
f.push_bytes(&src.octets());
f.push_bytes(&dst.octets());
let netsum = finish_netsum(partial_netsum(0, &f.buffer));
f.buffer[10] = (netsum >> 8) as u8;
f.buffer[11] = (netsum & 0xFF) as u8;
Self::new_ethernet(dstmac, srcmac, 0x0800_u16, Tail::Fragment(Box::new(f)))
}
pub fn new_udp<'l>(
src: net::SocketAddrV4,
srcmac: &[u8; 6],
dst: net::SocketAddrV4,
dstmac: &[u8; 6],
payload: Tail<'l>,
) -> Fragment<'l> {
let mut f = Self::from_tail(payload);
f.push_be16(src.port());
f.push_be16(dst.port());
f.push_be16(8_u16 + f.tail.len() as u16); /* Length */
f.push_be16(0x0000); /* TODO: Checksum */
let l = f.len();
let mut pseudohdr = Self::from_tail(Tail::Fragment(Box::new(f.clone())));
let udp_protocol: u8 = 17;
pseudohdr.push_bytes(&src.ip().octets());
pseudohdr.push_bytes(&dst.ip().octets());
pseudohdr.push_u8(0x00_u8);
pseudohdr.push_u8(udp_protocol);
pseudohdr.push_be16(l as u16);
let netsum = pseudohdr.netsum();
f.buffer[6] = (netsum >> 8) as u8;
f.buffer[7] = (netsum & 0xFF) as u8;
let t = Tail::Fragment(Box::new(f.clone()));
Self::new_ipv4(src.ip(), srcmac, dst.ip(), dstmac, udp_protocol, t)
}
}
#[test]
fn test_udp_packet() {
let u = Fragment::new_udp(
"192.0.2.1:1".parse().unwrap(),
&[2, 0, 0, 0, 0, 0],
"192.0.2.2:2".parse().unwrap(),
&[2, 0, 0, 0, 0, 1],
Tail::Payload(&[1, 2, 3, 4]),
);
println!("u={:?}", u);
}
#[test]
fn test_checksum() {
let data = vec![8, 0, 0, 0, 0x12, 0x34, 0x00, 0x01];
assert_eq!(finish_netsum(partial_netsum(0, &data)), 0xE5CA);
} | #[derive(Clone, Debug)]
pub struct Fragment<'a> {
buffer: Vec<u8>, |
kalloc.rs | // Physical memory allocator, intended to allocate
// memory for user processes, kernel stacks, page table pages,
// and pipe buffers. Allocates 4096-byte pages.
use core;
use super::*;
use spinlock_mutex::*;
struct | {
next: Option<&'static mut Run>,
}
static mut freelist: Mutex<Option<&'static mut Run>> = Mutex::new(None);
// Initialization happens in two phases.
// 1. main() calls kinit1() while still using entrypgdir to place just
// the pages mapped by entrypgdir on free list.
// 2. main() calls kinit2() with the rest of the physical pages
// after installing a full page table that maps them on all cores.
pub unsafe extern "C" fn kinit1(vstart: V, vend: V) {
assert!(vstart < vend);
freelist.use_lock = false;
freerange(vstart, vend);
}
pub unsafe extern "C" fn kinit2(vstart: V, vend: V) {
freerange(vstart, vend);
freelist.use_lock = true;
}
unsafe extern "C" fn freerange(vstart: V, vend: V) {
let mut p = vstart.pgroundup();
while p + PGSIZE <= vend {
kfree(p);
p += PGSIZE;
}
}
// Free the page of physical memory pointed at by v,
// which normally should have been returned by a
// call to kalloc(). (The exception is when
// initializing the allocator; see kinit above.)
pub unsafe extern "C" fn kfree(v: V) {
// TODO: do sensible check for test
#[cfg(not(test))]
{
if (v.0 % PGSIZE != 0 || v < linker::end() || v2p(v) >= PHYSTOP) {
cpanic("kfree");
}
}
// Fill with junk to catch dangling refs.
memset(v.as_mut_ptr(), 1, PGSIZE);
let mut r = v.as_ptr() as usize as *mut Run;
let mut head = freelist.lock();
*r = Run { next: head.take() };
*head = Some(&mut *r);
}
// Allocate one 4096-byte page of physical memory.
// Returns a pointer that the kernel can use.
// Returns None if the memory cannot be allocated.
pub unsafe extern "C" fn kalloc() -> Option<V> {
let mut head = freelist.lock();
let a = &mut head.take()?.next;
let p = V(a as *const Option<&'static mut Run> as usize);
*head = a.take();
Some(p)
}
#[cfg(test)]
mod tests {
use super::*;
use core;
use mmu::PGSIZE;
#[test]
fn kfree_kalloc() {
unsafe {
assert_eq!(super::kalloc(), None);
let a = [100u8; PGSIZE as usize * 10];
let mut v = V(core::mem::transmute(&a)).pgroundup();
let one = v;
let two = v + PGSIZE;
super::kfree(two); // head = two
super::kfree(one); // head = one -> two
let mut x = super::kalloc().unwrap(); // head = two
assert_eq!(one, x);
for i in 0..(PGSIZE as usize) {
*(x.0 as *mut u8) = 42;
x = x + 1;
}
assert_eq!(a[PGSIZE.wrapping_sub(1) as usize], 42);
let x = super::kalloc().unwrap();
assert_eq!(two, x);
let r: *const super::Run = core::mem::transmute(x.0);
assert!((*r).next.is_none());
assert_eq!(super::kalloc(), None);
}
}
}
| Run |
create_map.py | #!/usr/bin/env python
###############################################################################
# Copyright 2017 The Apollo Authors. All Rights Reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
###############################################################################
"""
Create base map from localization and mobileye lane detection
"""
import argparse
import csv
import math
import numpy as np
import os
import rospy
import sys
from modules.map.proto.map_pb2 import Map
from modules.map.proto.map_lane_pb2 import LaneBoundaryType, Lane
from modules.map.proto.map_road_pb2 import BoundaryEdge, Road
from modules.routing.proto.routing_pb2 import LaneWaypoint
from modules.routing.proto.poi_pb2 import POI, Landmark
class DataPoint:
"""
class of data sample (localization and mobileye lane detection)
"""
def __init__(self):
self.pos_x = 0.0 # localization
self.pos_y = 0.0
self.pos_z = 0.0
self.theta = 0.0 # heading
self.dist_left = 0.0 # distance to left lane marking
self.conf_left = 0 # confidence of left lane marking (0/1: low confidence, -1/-2: high confidence)
self.dist_right = 0.0 # distance to right lane marking
self.conf_right = 0 # confidence of right lane marking (0/1: low confidence, -1/-2: high confidence)
self.width = 0.0 # lane width
self.ratio = 0.0 # relative position within a lane (dist_left / width)
self.center_x = 0.0 # point on the center line of current lane
self.center_y = 0.0
def distance(x1, y1, x2, y2):
"""
l2 distance
"""
return math.sqrt((x1 - x2) * (x1 - x2) + (y1 - y2) * (y1 - y2))
def interpolate_width(data, default_width):
"""
fill 'width' field of all data samples by interpolation
"""
# Collect a set of consecutive entries with low confidence on left OR right lane detection
intervals = []
interval_begin = -1
interval_end = -1
for (index, entry) in enumerate(data):
if entry.conf_left >= 0 or entry.conf_right >= 0:
if interval_begin < 0:
interval_begin = index
interval_end = index
else:
if interval_begin >= 0:
intervals.append((interval_begin, interval_end))
interval_begin = -1
interval_end = -1
entry.width = entry.dist_left + entry.dist_right
if interval_begin >= 0:
intervals.append((interval_begin, interval_end))
# Iterate through intervals to interpolate width
for interval in intervals:
for index in range(interval[0], interval[1] + 1):
if interval[0] == 0 and interval[1] == len(data) - 1:
data[index].width = default_width
else:
if interval[0] == 0:
data[index].width = data[interval[1] + 1].width
elif interval[1] == len(data) - 1:
data[index].width = data[interval[0] - 1].width
else:
alpha = float(index - interval[0] + 1) / (interval[1] - interval[0] + 2)
data[index].width = (1.0 - alpha) * data[interval[0] - 1].width + alpha * data[interval[1] + 1].width
# Fill in dist_left/right and conf_left/right using interpolated width
for (index, entry) in enumerate(data):
if entry.conf_left >= 0 and entry.conf_right < 0:
entry.dist_left = entry.width - entry.dist_right
entry.conf_left = -1
elif entry.conf_left < 0 and entry.conf_right >= 0:
entry.dist_right = entry.width - entry.dist_left
entry.conf_right = -1
def interpolate_ratio(data, default_ratio):
"""
fill 'ratio' field of all data samples by interpolation
"""
# Collect a set of consecutive entries with low confidence on left AND right lane detection
intervals = []
interval_begin = -1
interval_end = -1
for (index, entry) in enumerate(data):
if entry.conf_left >= 0 and entry.conf_right >= 0:
if interval_begin < 0:
interval_begin = index
interval_end = index
else:
if interval_begin >= 0:
intervals.append((interval_begin, interval_end))
interval_begin = -1
interval_end = -1
entry.ratio = float(entry.dist_left) / entry.width
if interval_begin >= 0:
intervals.append((interval_begin, interval_end))
# Iterate through intervals to interpolate ratio
for interval in intervals:
for index in range(interval[0], interval[1] + 1):
if interval[0] == 0 and interval[1] == len(data) - 1:
data[index].ratio = default_ratio
else:
if interval[0] == 0:
data[index].ratio = data[interval[1] + 1].ratio
elif interval[1] == len(data) - 1:
data[index].ratio = data[interval[0] - 1].ratio
else:
alpha = float(index - interval[0] + 1) / (interval[1] - interval[0] + 2)
data[index].ratio = (1.0 - alpha) * data[interval[0] - 1].ratio + alpha * data[interval[1] + 1].ratio
# Fill in dist_left/right and conf_left/right using interpolated ratio
for (index, entry) in enumerate(data):
if entry.conf_left >= 0 and entry.conf_right >= 0:
entry.dist_left = entry.width * entry.ratio
entry.dist_right = entry.width - entry.dist_left
entry.conf_left = -1
entry.conf_right = -1
def compute_center(data):
"""
fill 'center_x' and 'center_y' fields of all data samples
"""
for entry in data:
pos_x = entry.pos_x
pos_y = entry.pos_y
pos_z = entry.pos_z
theta = entry.theta
dist_left = entry.dist_left
dist_right = entry.dist_right
theta_left = theta + np.pi / 2.0
pos_l_x = pos_x + dist_left * np.cos(theta_left)
pos_l_y = pos_y + dist_left * np.sin(theta_left)
theta_right = theta - np.pi / 2.0
pos_r_x = pos_x + dist_right * np.cos(theta_right)
pos_r_y = pos_y + dist_right * np.sin(theta_right)
entry.center_x = (pos_l_x + pos_r_x) / 2.0
entry.center_y = (pos_l_y + pos_r_y) / 2.0
def sample_data(data, sample_distance):
"""
sample 'data' at the interval of 'sample_distance'
"""
result = []
if len(data) > 0:
last_x = data[0].center_x
last_y = data[0].center_y
result.append(data[0])
for entry in data[1:]:
if distance(last_x, last_y, entry.center_x, entry.center_y) > sample_distance:
result.append(entry)
last_x = entry.center_x
last_y = entry.center_y
return result
def extract_data(data, dim):
"""
extract dimension 'dim' (center_x, center_y or width) of 'data' into a list
"""
result = []
for entry in data:
if dim == 'center_x':
result.append(entry.center_x)
elif dim == 'center_y':
result.append(entry.center_y)
elif dim == 'width':
result.append(entry.width)
return result
def laplacian_operator(data):
"""
apply laplacian operator on data
"""
lap = []
lap.append(0.0)
for index in range(1, len(data) - 1):
lap.append((data[index + 1] + data[index - 1]) / 2.0 - data[index])
lap.append(0.0)
return lap
def laplacian_smooth(data, alpha = 0.5, iterations = 3):
"""
apply laplacian smoothing on data
"""
for iteration in range(iterations):
lap = laplacian_operator(data)
for index in range(len(data)):
data[index] += alpha * lap[index]
def update_data(data, dim, new_data):
"""
copy new_data to dimension 'dim' of 'data'
"""
for entry, new_entry in zip(data, new_data):
if dim == 'center_x':
entry.center_x = new_entry
elif dim == 'center_y':
entry.center_y = new_entry
elif dim == 'width':
entry.width = new_entry
def smooth_dimension(data, dim):
"""
smooth dimension 'dim' of 'data'
"""
extracted_data = extract_data(data, dim)
if dim == 'width':
laplacian_smooth(extracted_data, 1.0, 1000)
else:
laplacian_smooth(extracted_data, 1.0, 1000)
update_data(data, dim, extracted_data)
def smooth_center_width(data):
"""
smooth centers and widths of data
"""
smooth_dimension(data, 'center_x')
smooth_dimension(data, 'center_y')
smooth_dimension(data, 'width')
def split_data(data, max_lane_length):
"""
split data into multiple lists, each of which is not longer than 'max_lane_length'
"""
result = []
current = []
total_length = 0.0
if len(data) > 0:
last_x = data[0].center_x
last_y = data[0].center_y
current.append(data[0])
for entry in data[1:]:
current.append(entry)
d = distance(last_x, last_y, entry.center_x, entry.center_y)
total_length += d
if total_length > max_lane_length:
result.append(current)
current = []
current.append(entry)
total_length = 0.0
last_x = entry.center_x
last_y = entry.center_y
if total_length > 0.0:
result.append(current)
return result
def create_lane(data, offset, lane_count, left_lanes, right_lanes):
"""
create a lane using 'data' whose lateral index is 'offset'
offset = 0: center lane; offset < 0: left lanes; offset > 0: right lanes
lane_count: longitutional index of lane (used for naming)
left_lanes, right_lanes: number of left/right lanes (used for boundary types)
"""
total_length = 0.0
total_left_length = 0.0
total_right_length = 0.0
lane = Lane()
lane.id.id = "lane_" + str(lane_count) + "_" + str(offset)
lane_central_curve_seg = lane.central_curve.segment.add()
start_heading = data[0].theta
lane_left_boundary_curve_seg = lane.left_boundary.curve.segment.add()
lane_left_boundary_curve_seg.heading = float(start_heading)
lane_left_boundary_curve_seg.s = 0.0
lane_right_boundary_curve_seg = lane.right_boundary.curve.segment.add()
lane_right_boundary_curve_seg.heading = float(start_heading)
lane_right_boundary_curve_seg.s = 0.0
last_l_x = 0.0
last_l_y = 0.0
last_c_x = 0.0
last_c_y = 0.0
last_r_x = 0.0
last_r_y = 0.0
for (index, entry) in enumerate(data):
theta = entry.theta
theta_left = theta + np.pi / 2.0
theta_right = theta - np.pi / 2.0
pos_c_x = entry.center_x
pos_c_y = entry.center_y
pos_l_x = pos_c_x + entry.width * (0.5 - offset) * np.cos(theta_left)
pos_l_y = pos_c_y + entry.width * (0.5 - offset) * np.sin(theta_left)
pos_r_x = pos_c_x + entry.width * (0.5 + offset) * np.cos(theta_right)
pos_r_y = pos_c_y + entry.width * (0.5 + offset) * np.sin(theta_right)
pos_c_x = (pos_l_x + pos_r_x) / 2.0
pos_c_y = (pos_l_y + pos_r_y) / 2.0
if index == 0:
lane_central_curve_seg.start_position.x = pos_c_x
lane_central_curve_seg.start_position.y = pos_c_y
lane_left_boundary_curve_seg.start_position.x = pos_l_x
lane_left_boundary_curve_seg.start_position.y = pos_l_y
lane_right_boundary_curve_seg.start_position.x = pos_r_x
lane_right_boundary_curve_seg.start_position.y = pos_r_y
else: | d = distance(last_c_x, last_c_y, pos_c_x, pos_c_y)
total_length += d
d_left = distance(last_l_x, last_l_y, pos_l_x, pos_l_y)
total_left_length += d_left
d_right = distance(last_r_x, last_r_y, pos_r_x, pos_r_y)
total_right_length += d_right
point = lane_central_curve_seg.line_segment.point.add()
point.x = pos_c_x
point.y = pos_c_y
point = lane_left_boundary_curve_seg.line_segment.point.add()
point.x = pos_l_x
point.y = pos_l_y
point = lane_right_boundary_curve_seg.line_segment.point.add()
point.x = pos_r_x
point.y = pos_r_y
sample = lane.left_sample.add()
sample.s = total_length
sample.width = entry.width / 2.0
sample = lane.right_sample.add()
sample.s = total_length
sample.width = entry.width / 2.0
last_l_x = pos_l_x
last_l_y = pos_l_y
last_r_x = pos_r_x
last_r_y = pos_r_y
last_c_x = pos_c_x
last_c_y = pos_c_y
lane_central_curve_seg.length = total_length
lane_left_boundary_curve_seg.length = total_left_length
lane_right_boundary_curve_seg.length = total_right_length
boundary_type = lane.left_boundary.boundary_type.add()
boundary_type.s = 0.0
if offset == -left_lanes:
boundary_type.types.append(LaneBoundaryType.DOUBLE_YELLOW)
else:
boundary_type.types.append(LaneBoundaryType.DOTTED_WHITE)
lane.left_boundary.length = total_left_length
boundary_type = lane.right_boundary.boundary_type.add()
boundary_type.s = 0.0
if offset == right_lanes:
boundary_type.types.append(LaneBoundaryType.CURB)
else:
boundary_type.types.append(LaneBoundaryType.DOTTED_WHITE)
lane.right_boundary.length = total_right_length
lane.length = total_length
lane.speed_limit = 29.06
lane.type = Lane.CITY_DRIVING
lane.turn = Lane.NO_TURN
return lane
def create_road(data, left_lanes, right_lanes):
"""
create a road using 'data'
left_lanes, right_lanes: number of left/right lanes
"""
road = Road()
road.id.id = "road"
section = road.section.add()
section.id.id = "section"
left_edge = section.boundary.outer_polygon.edge.add()
left_edge.type = BoundaryEdge.LEFT_BOUNDARY
right_edge = section.boundary.outer_polygon.edge.add()
right_edge.type = BoundaryEdge.RIGHT_BOUNDARY
total_left_length = 0.0
total_right_length = 0.0
start_heading = data[0].theta
left_edge_curve_seg = left_edge.curve.segment.add()
left_edge_curve_seg.heading = float(start_heading)
left_edge_curve_seg.s = 0.0
right_edge_curve_seg = right_edge.curve.segment.add()
right_edge_curve_seg.heading = float(start_heading)
right_edge_curve_seg.s = 0.0
last_l_x = 0.0
last_l_y = 0.0
last_r_x = 0.0
last_r_y = 0.0
for (index, entry) in enumerate(data):
theta = entry.theta
theta_left = theta + np.pi / 2.0
theta_right = theta - np.pi / 2.0
pos_l_x = entry.center_x + entry.width * (0.5 + left_lanes) * np.cos(theta_left)
pos_l_y = entry.center_y + entry.width * (0.5 + left_lanes) * np.sin(theta_left)
pos_r_x = entry.center_x + entry.width * (0.5 + right_lanes) * np.cos(theta_right)
pos_r_y = entry.center_y + entry.width * (0.5 + right_lanes) * np.sin(theta_right)
if index == 0:
left_edge_curve_seg.start_position.x = pos_l_x
left_edge_curve_seg.start_position.y = pos_l_y
right_edge_curve_seg.start_position.x = pos_r_x
right_edge_curve_seg.start_position.y = pos_r_y
else:
d_left = distance(last_l_x, last_l_y, pos_l_x, pos_l_y)
total_left_length += d_left
d_right = distance(last_r_x, last_r_y, pos_r_x, pos_r_y)
total_right_length += d_right
point = left_edge_curve_seg.line_segment.point.add()
point.x = pos_l_x
point.y = pos_l_y
point = right_edge_curve_seg.line_segment.point.add()
point.x = pos_r_x
point.y = pos_r_y
last_l_x = pos_l_x
last_l_y = pos_l_y
last_r_x = pos_r_x
last_r_y = pos_r_y
left_edge_curve_seg.length = total_left_length
right_edge_curve_seg.length = total_right_length
return road
def main():
parser = argparse.ArgumentParser(
description='Generate Base Map from Recorded Localization and Mobileye Lane Detection')
parser.add_argument(
'-i',
'--input_file',
help='Recorded localization and mobileye lane detection in CSV format',
type=str,
default='/tmp/lane.csv')
parser.add_argument(
'--debug',
help='Print debugging info in /tmp',
action='store_true')
parser.add_argument(
'-o',
'--output_file',
help='Output file name of generated base map',
type=str,
default='modules/map/data/gen/base_map.txt')
parser.add_argument(
'-e',
'--end_waypoint_file',
help='Output file name of default end waypoint',
type=str,
default='modules/map/data/gen/default_end_way_point.txt')
parser.add_argument(
'--default_width',
help='Default lane width in meters (only effective when mobileye lane detection fails for ALL frames)',
type=float,
default=3.5)
parser.add_argument(
'--sample_distance',
help='minimum distance (in meters) of two adjacent samples of a lane',
type=float,
default=0.2)
parser.add_argument(
'--max_lane_length',
help='maximum length (in meters) of a lane (longer lanes will be split)',
type=float,
default=100.0)
parser.add_argument(
'--left_lanes',
help='Number of lanes on the left',
type=int,
default=0)
parser.add_argument(
'--right_lanes',
help='Number of lanes on the right',
type=int,
default=0)
args = vars(parser.parse_args())
csv_file_name = args['input_file']
map_file_name = args['output_file']
waypoint_file_name = args['end_waypoint_file']
default_width = args['default_width']
debug_option = args['debug']
sample_distance = args['sample_distance']
max_lane_length = args['max_lane_length']
left_lanes = args['left_lanes']
right_lanes = args['right_lanes']
default_ratio = 0.5
temp_csv_file_name = '/tmp/lane_interpolation.csv'
rows = []
with open(csv_file_name, 'r') as csvfile:
reader = csv.reader(csvfile)
for row in reader:
rows.append(row)
# Extract data samples
data = []
for row in rows[1:]:
entry = DataPoint()
entry.pos_x = float(row[0])
entry.pos_y = float(row[1])
entry.pos_z = float(row[2])
entry.theta = float(row[3])
entry.dist_left = abs(float(row[4]))
entry.conf_left = int(row[5])
if entry.dist_left < 0.1:
entry.conf_left = 0
entry.dist_right = abs(float(row[6]))
entry.conf_right = int(row[7])
if entry.dist_right < 0.1:
entry.conf_right = 0
entry.width = default_width
entry.ratio = default_ratio
data.append(entry)
# Fill in widths using interpolation
interpolate_width(data, default_width)
# Fill in ratios using interpolation
interpolate_ratio(data, default_ratio)
# Fill in centers
compute_center(data)
# Sample data at the interval of sample_distance
data = sample_data(data, sample_distance)
# Smooth center curves and widths
smooth_center_width(data)
# Output debug info if necessary
if debug_option:
with open(temp_csv_file_name, 'w') as csvfile:
for row in data:
csvfile.write(
"%s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s\n" %
(row.pos_x, row.pos_y, row.pos_z, row.theta, row.dist_left, row.conf_left, row.dist_right, row.conf_right, row.width, row.ratio, row.center_x, row.center_y))
# Split data samples into lists with maximum length of max_lane_length
list_data = split_data(data, max_lane_length)
# Create individual lanes
lane_sets = []
for (lane_count, lane_data) in enumerate(list_data):
lane_set = []
for offset in range(-left_lanes, right_lanes + 1):
lane_set.append(create_lane(lane_data, offset, lane_count, left_lanes, right_lanes))
lane_sets.append(lane_set)
# Create road
road = create_road(data, left_lanes, right_lanes)
# Create map
mp = Map()
mp.header.version = "1.400000"
mp.header.date = "20170919"
mp.header.district = "101"
# Set up predecessors, successors, left/right neighbors
for lane_count in range(len(lane_sets)):
for lane_offset in range(len(lane_sets[lane_count])):
if lane_count != 0:
lane_sets[lane_count][lane_offset].predecessor_id.add().id = lane_sets[lane_count - 1][lane_offset].id.id
if lane_count != len(lane_sets) - 1:
lane_sets[lane_count][lane_offset].successor_id.add().id = lane_sets[lane_count + 1][lane_offset].id.id
if lane_offset != 0:
lane_sets[lane_count][lane_offset].left_neighbor_forward_lane_id.add().id = lane_sets[lane_count][lane_offset - 1].id.id
if lane_offset != len(lane_sets[lane_count]) - 1:
lane_sets[lane_count][lane_offset].right_neighbor_forward_lane_id.add().id = lane_sets[lane_count][lane_offset + 1].id.id
# Add road/lanes to map and let road contain lanes
mp.road.extend([road])
for lane_set in lane_sets:
for lane in lane_set:
mp.road[0].section[0].lane_id.add().id = lane.id.id
mp.lane.extend([lane])
# Output map
with open(map_file_name, "w") as f:
f.write(mp.__str__())
# Create default end_way_point using the farthest point of last central lane
last_central_lane = lane_sets[-1][left_lanes]
poi = POI()
landmark = poi.landmark.add()
landmark.name = "default"
waypoint = landmark.waypoint.add()
waypoint.id = last_central_lane.id.id
waypoint.s = last_central_lane.length
waypoint.pose.x = last_central_lane.central_curve.segment[0].line_segment.point[-1].x
waypoint.pose.y = last_central_lane.central_curve.segment[0].line_segment.point[-1].y
# Output default end_way_point
with open(waypoint_file_name, "w") as f:
f.write(poi.__str__())
if __name__ == '__main__':
main() | |
preprocessing_squad.py | #!/usr/bin/env python
# coding: utf-8
import argparse
import json
from tqdm.auto import tqdm
from transformers import AutoTokenizer
def | (tokenizer, file_input, file_output):
with open(file_input, "r") as f:
data = json.load(f)["data"]
new_data = {}
for p in tqdm([p for d in data for p in d["paragraphs"]]):
for qas in p["qas"]:
question = tokenizer.tokenize(qas["question"])
answer_offsets_ = set()
for a in qas["answers"]:
answer_offsets = (a["answer_start"], a["answer_start"] + len(a["text"]))
context_pre_answer = tokenizer.tokenize(
p["context"][: answer_offsets[0]]
)
context_answer = tokenizer.tokenize(
p["context"][answer_offsets[0] : answer_offsets[1]]
)
context_post_answer = tokenizer.tokenize(
p["context"][answer_offsets[1] :]
)
context = context_pre_answer + context_answer + context_post_answer
answer_offsets_.add(
(
len(context_pre_answer),
len(context_pre_answer) + len(context_answer) - 1,
)
)
new_data[qas["id"]] = {
"question": question,
"context": context,
"answer_offsets": list(answer_offsets_),
}
with open(file_output, "w") as f:
json.dump(new_data, f)
if __name__ == "__main__":
parser = argparse.ArgumentParser()
parser.add_argument(
"--model",
type=str,
default="bert-large-uncased-whole-word-masking-finetuned-squad",
)
parser.add_argument(
"--file_input", type=str, default="./datasets/squad/dev-v1.1.json"
)
parser.add_argument(
"--file_output",
type=str,
default="./datasets/squad/dev-v1.1_bert-large-uncased-whole-word-masking-finetuned-squad.json",
)
args = parser.parse_args()
tokenizer = AutoTokenizer.from_pretrained(args.model)
pre_processing(tokenizer, args.file_input, args.file_output)
| pre_processing |
av0.rs | #![allow(non_snake_case)]
use libperl_sys::*;
pub fn | (ary: *const libperl_sys::av) -> *const *const SV {
(unsafe {(*ary).sv_u.svu_array})
as *const *const SV
}
| AvARRAY |
date_formatter.js | import moment from 'moment';
const DateFormatter = {
format(date) {
return moment(date).format('YYYY-MM-DD');
},
};
| export default DateFormatter; |
|
cpuv2_test.go | /*
Copyright The containerd Authors.
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*/
package v2
import (
"fmt"
"os"
"strconv"
"testing"
)
func TestCgroupv2CpuStats(t *testing.T) | {
checkCgroupMode(t)
group := "/cpu-test-cg"
groupPath := fmt.Sprintf("%s-%d", group, os.Getpid())
var (
quota int64 = 10000
period uint64 = 8000
weight uint64 = 100
)
max := "10000 8000"
res := Resources{
CPU: &CPU{
Weight: &weight,
Max: NewCPUMax("a, &period),
Cpus: "0",
Mems: "0",
},
}
c, err := NewManager(defaultCgroup2Path, groupPath, &res)
if err != nil {
t.Fatal("failed to init new cgroup manager: ", err)
}
defer os.Remove(c.path)
checkFileContent(t, c.path, "cpu.weight", strconv.FormatUint(weight, 10))
checkFileContent(t, c.path, "cpu.max", max)
checkFileContent(t, c.path, "cpuset.cpus", "0")
checkFileContent(t, c.path, "cpuset.mems", "0")
} |
|
apitestlib.go | // Copyright (c) 2017-present Mattermost, Inc. All Rights Reserved.
// See License.txt for license information.
package api4
import (
"fmt"
"io/ioutil"
"net"
"net/http"
"os"
"path/filepath"
"reflect"
"strconv"
"strings"
"testing"
"time"
"github.com/mattermost/mattermost-server/app"
"github.com/mattermost/mattermost-server/config"
"github.com/mattermost/mattermost-server/mlog"
"github.com/mattermost/mattermost-server/model"
"github.com/mattermost/mattermost-server/store"
"github.com/mattermost/mattermost-server/utils"
"github.com/mattermost/mattermost-server/web"
"github.com/mattermost/mattermost-server/wsapi"
s3 "github.com/minio/minio-go"
"github.com/minio/minio-go/pkg/credentials"
)
type TestHelper struct {
App *app.App
Server *app.Server
ConfigStore config.Store
Client *model.Client4
BasicUser *model.User
BasicUser2 *model.User
TeamAdminUser *model.User
BasicTeam *model.Team
BasicChannel *model.Channel
BasicPrivateChannel *model.Channel
BasicDeletedChannel *model.Channel
BasicChannel2 *model.Channel
BasicPost *model.Post
Group *model.Group
SystemAdminClient *model.Client4
SystemAdminUser *model.User
tempWorkspace string
}
// testStore tracks the active test store.
// This is a bridge between the new testlib ownership of the test store and the existing usage
// of the api4 test helper by many packages. In the future, this test helper would ideally belong
// to the testlib altogether.
var testStore store.Store
func UseTestStore(store store.Store) {
testStore = store
}
func setupTestHelper(enterprise bool, updateConfig func(*model.Config)) *TestHelper {
testStore.DropAllTables()
memoryStore, err := config.NewMemoryStoreWithOptions(&config.MemoryStoreOptions{IgnoreEnvironmentOverrides: true})
if err != nil {
panic("failed to initialize memory store: " + err.Error())
}
var options []app.Option
options = append(options, app.ConfigStore(memoryStore))
options = append(options, app.StoreOverride(testStore))
s, err := app.NewServer(options...)
if err != nil {
panic(err)
}
th := &TestHelper{
App: s.FakeApp(),
Server: s,
ConfigStore: memoryStore,
}
th.App.UpdateConfig(func(cfg *model.Config) {
*cfg.TeamSettings.MaxUsersPerTeam = 50
*cfg.RateLimitSettings.Enable = false
*cfg.EmailSettings.SendEmailNotifications = true
// Disable sniffing, otherwise elastic client fails to connect to docker node
// More details: https://github.com/olivere/elastic/wiki/Sniffing
*cfg.ElasticsearchSettings.Sniff = false
})
prevListenAddress := *th.App.Config().ServiceSettings.ListenAddress
th.App.UpdateConfig(func(cfg *model.Config) { *cfg.ServiceSettings.ListenAddress = ":0" })
if updateConfig != nil {
th.App.UpdateConfig(updateConfig)
}
serverErr := th.Server.Start()
if serverErr != nil {
panic(serverErr)
}
th.App.UpdateConfig(func(cfg *model.Config) { *cfg.ServiceSettings.ListenAddress = prevListenAddress })
Init(th.Server, th.Server.AppOptions, th.App.Srv.Router)
web.New(th.Server, th.Server.AppOptions, th.App.Srv.Router)
wsapi.Init(th.App, th.App.Srv.WebSocketRouter)
th.App.Srv.Store.MarkSystemRanUnitTests()
th.App.DoAppMigrations()
th.App.UpdateConfig(func(cfg *model.Config) { *cfg.TeamSettings.EnableOpenServer = true })
// Disable strict password requirements for test
th.App.UpdateConfig(func(cfg *model.Config) {
*cfg.PasswordSettings.MinimumLength = 5
*cfg.PasswordSettings.Lowercase = false
*cfg.PasswordSettings.Uppercase = false
*cfg.PasswordSettings.Symbol = false
*cfg.PasswordSettings.Number = false
})
if enterprise {
th.App.SetLicense(model.NewTestLicense())
} else {
th.App.SetLicense(nil)
}
th.Client = th.CreateClient()
th.SystemAdminClient = th.CreateClient()
if th.tempWorkspace == "" {
dir, err := ioutil.TempDir("", "apptest")
if err != nil {
panic(err)
}
th.tempWorkspace = dir
}
pluginDir := filepath.Join(th.tempWorkspace, "plugins")
webappDir := filepath.Join(th.tempWorkspace, "webapp")
th.App.UpdateConfig(func(cfg *model.Config) {
*cfg.PluginSettings.Directory = pluginDir
*cfg.PluginSettings.ClientDirectory = webappDir
})
th.App.InitPlugins(pluginDir, webappDir)
return th
}
func SetupEnterprise() *TestHelper {
return setupTestHelper(true, nil)
}
func Setup() *TestHelper {
return setupTestHelper(false, nil)
}
func SetupConfig(updateConfig func(cfg *model.Config)) *TestHelper {
return setupTestHelper(false, updateConfig)
}
func (me *TestHelper) ShutdownApp() {
done := make(chan bool)
go func() {
me.Server.Shutdown()
close(done)
}()
select {
case <-done:
case <-time.After(30 * time.Second):
// panic instead of t.Fatal to terminate all tests in this package, otherwise the
// still running App could spuriously fail subsequent tests.
panic("failed to shutdown App within 30 seconds")
}
}
func (me *TestHelper) TearDown() {
utils.DisableDebugLogForTest()
me.ShutdownApp()
utils.EnableDebugLogForTest()
if err := recover(); err != nil {
panic(err)
}
}
func (me *TestHelper) InitBasic() *TestHelper {
me.waitForConnectivity()
me.SystemAdminUser = me.CreateUser()
me.App.UpdateUserRoles(me.SystemAdminUser.Id, model.SYSTEM_USER_ROLE_ID+" "+model.SYSTEM_ADMIN_ROLE_ID, false)
me.LoginSystemAdmin()
me.TeamAdminUser = me.CreateUser()
me.App.UpdateUserRoles(me.TeamAdminUser.Id, model.SYSTEM_USER_ROLE_ID, false)
me.LoginTeamAdmin()
me.BasicTeam = me.CreateTeam()
me.BasicChannel = me.CreatePublicChannel()
me.BasicPrivateChannel = me.CreatePrivateChannel()
me.BasicDeletedChannel = me.CreatePublicChannel()
me.BasicChannel2 = me.CreatePublicChannel()
me.BasicPost = me.CreatePost()
me.BasicUser = me.CreateUser()
me.LinkUserToTeam(me.BasicUser, me.BasicTeam)
me.BasicUser2 = me.CreateUser()
me.LinkUserToTeam(me.BasicUser2, me.BasicTeam)
me.App.AddUserToChannel(me.BasicUser, me.BasicChannel)
me.App.AddUserToChannel(me.BasicUser2, me.BasicChannel)
me.App.AddUserToChannel(me.BasicUser, me.BasicChannel2)
me.App.AddUserToChannel(me.BasicUser2, me.BasicChannel2)
me.App.AddUserToChannel(me.BasicUser, me.BasicPrivateChannel)
me.App.AddUserToChannel(me.BasicUser2, me.BasicPrivateChannel)
me.App.AddUserToChannel(me.BasicUser, me.BasicDeletedChannel)
me.App.AddUserToChannel(me.BasicUser2, me.BasicDeletedChannel)
me.App.UpdateUserRoles(me.BasicUser.Id, model.SYSTEM_USER_ROLE_ID, false)
me.Client.DeleteChannel(me.BasicDeletedChannel.Id)
me.LoginBasic()
me.Group = me.CreateGroup()
return me
}
func (me *TestHelper) waitForConnectivity() {
for i := 0; i < 1000; i++ {
conn, err := net.Dial("tcp", fmt.Sprintf("localhost:%v", me.App.Srv.ListenAddr.Port))
if err == nil {
conn.Close()
return
}
time.Sleep(time.Millisecond * 20)
}
panic("unable to connect")
}
func (me *TestHelper) CreateClient() *model.Client4 {
return model.NewAPIv4Client(fmt.Sprintf("http://localhost:%v", me.App.Srv.ListenAddr.Port))
}
func (me *TestHelper) CreateWebSocketClient() (*model.WebSocketClient, *model.AppError) {
return model.NewWebSocketClient4(fmt.Sprintf("ws://localhost:%v", me.App.Srv.ListenAddr.Port), me.Client.AuthToken)
}
func (me *TestHelper) CreateWebSocketSystemAdminClient() (*model.WebSocketClient, *model.AppError) {
return model.NewWebSocketClient4(fmt.Sprintf("ws://localhost:%v", me.App.Srv.ListenAddr.Port), me.SystemAdminClient.AuthToken)
}
func (me *TestHelper) CreateUser() *model.User {
return me.CreateUserWithClient(me.Client)
}
func (me *TestHelper) CreateTeam() *model.Team {
return me.CreateTeamWithClient(me.Client)
}
func (me *TestHelper) CreateTeamWithClient(client *model.Client4) *model.Team {
id := model.NewId()
team := &model.Team{
DisplayName: "dn_" + id,
Name: GenerateTestTeamName(),
Email: me.GenerateTestEmail(),
Type: model.TEAM_OPEN,
}
utils.DisableDebugLogForTest()
rteam, resp := client.CreateTeam(team)
if resp.Error != nil {
panic(resp.Error)
}
utils.EnableDebugLogForTest()
return rteam
}
func (me *TestHelper) CreateUserWithClient(client *model.Client4) *model.User {
id := model.NewId()
user := &model.User{
Email: me.GenerateTestEmail(),
Username: GenerateTestUsername(),
Nickname: "nn_" + id,
FirstName: "f_" + id,
LastName: "l_" + id,
Password: "Pa$$word11",
}
utils.DisableDebugLogForTest()
ruser, response := client.CreateUser(user)
if response.Error != nil {
panic(response.Error)
} | _, err := me.App.Srv.Store.User().VerifyEmail(ruser.Id, ruser.Email)
if err != nil {
return nil
}
utils.EnableDebugLogForTest()
return ruser
}
func (me *TestHelper) CreatePublicChannel() *model.Channel {
return me.CreateChannelWithClient(me.Client, model.CHANNEL_OPEN)
}
func (me *TestHelper) CreatePrivateChannel() *model.Channel {
return me.CreateChannelWithClient(me.Client, model.CHANNEL_PRIVATE)
}
func (me *TestHelper) CreateChannelWithClient(client *model.Client4, channelType string) *model.Channel {
return me.CreateChannelWithClientAndTeam(client, channelType, me.BasicTeam.Id)
}
func (me *TestHelper) CreateChannelWithClientAndTeam(client *model.Client4, channelType string, teamId string) *model.Channel {
id := model.NewId()
channel := &model.Channel{
DisplayName: "dn_" + id,
Name: GenerateTestChannelName(),
Type: channelType,
TeamId: teamId,
}
utils.DisableDebugLogForTest()
rchannel, resp := client.CreateChannel(channel)
if resp.Error != nil {
panic(resp.Error)
}
utils.EnableDebugLogForTest()
return rchannel
}
func (me *TestHelper) CreatePost() *model.Post {
return me.CreatePostWithClient(me.Client, me.BasicChannel)
}
func (me *TestHelper) CreatePinnedPost() *model.Post {
return me.CreatePinnedPostWithClient(me.Client, me.BasicChannel)
}
func (me *TestHelper) CreateMessagePost(message string) *model.Post {
return me.CreateMessagePostWithClient(me.Client, me.BasicChannel, message)
}
func (me *TestHelper) CreatePostWithClient(client *model.Client4, channel *model.Channel) *model.Post {
id := model.NewId()
post := &model.Post{
ChannelId: channel.Id,
Message: "message_" + id,
}
utils.DisableDebugLogForTest()
rpost, resp := client.CreatePost(post)
if resp.Error != nil {
panic(resp.Error)
}
utils.EnableDebugLogForTest()
return rpost
}
func (me *TestHelper) CreatePinnedPostWithClient(client *model.Client4, channel *model.Channel) *model.Post {
id := model.NewId()
post := &model.Post{
ChannelId: channel.Id,
Message: "message_" + id,
IsPinned: true,
}
utils.DisableDebugLogForTest()
rpost, resp := client.CreatePost(post)
if resp.Error != nil {
panic(resp.Error)
}
utils.EnableDebugLogForTest()
return rpost
}
func (me *TestHelper) CreateMessagePostWithClient(client *model.Client4, channel *model.Channel, message string) *model.Post {
post := &model.Post{
ChannelId: channel.Id,
Message: message,
}
utils.DisableDebugLogForTest()
rpost, resp := client.CreatePost(post)
if resp.Error != nil {
panic(resp.Error)
}
utils.EnableDebugLogForTest()
return rpost
}
func (me *TestHelper) CreateMessagePostNoClient(channel *model.Channel, message string, createAtTime int64) *model.Post {
post, err := me.App.Srv.Store.Post().Save(&model.Post{
UserId: me.BasicUser.Id,
ChannelId: channel.Id,
Message: message,
CreateAt: createAtTime,
})
if err != nil {
panic(err)
}
return post
}
func (me *TestHelper) CreateDmChannel(user *model.User) *model.Channel {
utils.DisableDebugLogForTest()
var err *model.AppError
var channel *model.Channel
if channel, err = me.App.GetOrCreateDirectChannel(me.BasicUser.Id, user.Id); err != nil {
mlog.Error(err.Error())
time.Sleep(time.Second)
panic(err)
}
utils.EnableDebugLogForTest()
return channel
}
func (me *TestHelper) LoginBasic() {
me.LoginBasicWithClient(me.Client)
}
func (me *TestHelper) LoginBasic2() {
me.LoginBasic2WithClient(me.Client)
}
func (me *TestHelper) LoginTeamAdmin() {
me.LoginTeamAdminWithClient(me.Client)
}
func (me *TestHelper) LoginSystemAdmin() {
me.LoginSystemAdminWithClient(me.SystemAdminClient)
}
func (me *TestHelper) LoginBasicWithClient(client *model.Client4) {
utils.DisableDebugLogForTest()
_, resp := client.Login(me.BasicUser.Email, me.BasicUser.Password)
if resp.Error != nil {
panic(resp.Error)
}
utils.EnableDebugLogForTest()
}
func (me *TestHelper) LoginBasic2WithClient(client *model.Client4) {
utils.DisableDebugLogForTest()
_, resp := client.Login(me.BasicUser2.Email, me.BasicUser2.Password)
if resp.Error != nil {
panic(resp.Error)
}
utils.EnableDebugLogForTest()
}
func (me *TestHelper) LoginTeamAdminWithClient(client *model.Client4) {
utils.DisableDebugLogForTest()
_, resp := client.Login(me.TeamAdminUser.Email, me.TeamAdminUser.Password)
if resp.Error != nil {
panic(resp.Error)
}
utils.EnableDebugLogForTest()
}
func (me *TestHelper) LoginSystemAdminWithClient(client *model.Client4) {
utils.DisableDebugLogForTest()
_, resp := client.Login(me.SystemAdminUser.Email, me.SystemAdminUser.Password)
if resp.Error != nil {
panic(resp.Error)
}
utils.EnableDebugLogForTest()
}
func (me *TestHelper) UpdateActiveUser(user *model.User, active bool) {
utils.DisableDebugLogForTest()
_, err := me.App.UpdateActive(user, active)
if err != nil {
mlog.Error(err.Error())
time.Sleep(time.Second)
panic(err)
}
utils.EnableDebugLogForTest()
}
func (me *TestHelper) LinkUserToTeam(user *model.User, team *model.Team) {
utils.DisableDebugLogForTest()
err := me.App.JoinUserToTeam(team, user, "")
if err != nil {
mlog.Error(err.Error())
time.Sleep(time.Second)
panic(err)
}
utils.EnableDebugLogForTest()
}
func (me *TestHelper) AddUserToChannel(user *model.User, channel *model.Channel) *model.ChannelMember {
utils.DisableDebugLogForTest()
member, err := me.App.AddUserToChannel(user, channel)
if err != nil {
mlog.Error(err.Error())
time.Sleep(time.Second)
panic(err)
}
utils.EnableDebugLogForTest()
return member
}
func (me *TestHelper) GenerateTestEmail() string {
if *me.App.Config().EmailSettings.SMTPServer != "localhost" && os.Getenv("CI_INBUCKET_PORT") == "" {
return strings.ToLower("success+" + model.NewId() + "@simulator.amazonses.com")
}
return strings.ToLower(model.NewId() + "@localhost")
}
func (me *TestHelper) CreateGroup() *model.Group {
id := model.NewId()
group := &model.Group{
Name: "n-" + id,
DisplayName: "dn_" + id,
Source: model.GroupSourceLdap,
RemoteId: "ri_" + id,
}
utils.DisableDebugLogForTest()
group, err := me.App.CreateGroup(group)
if err != nil {
panic(err)
}
utils.EnableDebugLogForTest()
return group
}
func GenerateTestUsername() string {
return "fakeuser" + model.NewRandomString(10)
}
func GenerateTestTeamName() string {
return "faketeam" + model.NewRandomString(6)
}
func GenerateTestChannelName() string {
return "fakechannel" + model.NewRandomString(10)
}
func GenerateTestAppName() string {
return "fakeoauthapp" + model.NewRandomString(10)
}
func GenerateTestId() string {
return model.NewId()
}
func CheckUserSanitization(t *testing.T, user *model.User) {
t.Helper()
if user.Password != "" {
t.Fatal("password wasn't blank")
}
if user.AuthData != nil && *user.AuthData != "" {
t.Fatal("auth data wasn't blank")
}
if user.MfaSecret != "" {
t.Fatal("mfa secret wasn't blank")
}
}
func CheckEtag(t *testing.T, data interface{}, resp *model.Response) {
t.Helper()
if !reflect.ValueOf(data).IsNil() {
t.Fatal("etag data was not nil")
}
if resp.StatusCode != http.StatusNotModified {
t.Log("actual: " + strconv.Itoa(resp.StatusCode))
t.Log("expected: " + strconv.Itoa(http.StatusNotModified))
t.Fatal("wrong status code for etag")
}
}
func CheckNoError(t *testing.T, resp *model.Response) {
t.Helper()
if resp.Error != nil {
t.Fatalf("Expected no error, got %q", resp.Error.Error())
}
}
func checkHTTPStatus(t *testing.T, resp *model.Response, expectedStatus int, expectError bool) {
t.Helper()
switch {
case resp == nil:
t.Fatalf("Unexpected nil response, expected http:%v, expectError:%v)", expectedStatus, expectError)
case expectError && resp.Error == nil:
t.Fatalf("Expected a non-nil error and http status:%v, got nil, %v", expectedStatus, resp.StatusCode)
case !expectError && resp.Error != nil:
t.Fatalf("Expected no error and http status:%v, got %q, http:%v", expectedStatus, resp.Error, resp.StatusCode)
case resp.StatusCode != expectedStatus:
t.Fatalf("Expected http status:%v, got %v (err: %q)", expectedStatus, resp.StatusCode, resp.Error)
}
}
func CheckOKStatus(t *testing.T, resp *model.Response) {
t.Helper()
checkHTTPStatus(t, resp, http.StatusOK, false)
}
func CheckCreatedStatus(t *testing.T, resp *model.Response) {
t.Helper()
checkHTTPStatus(t, resp, http.StatusCreated, false)
}
func CheckForbiddenStatus(t *testing.T, resp *model.Response) {
t.Helper()
checkHTTPStatus(t, resp, http.StatusForbidden, true)
}
func CheckUnauthorizedStatus(t *testing.T, resp *model.Response) {
t.Helper()
checkHTTPStatus(t, resp, http.StatusUnauthorized, true)
}
func CheckNotFoundStatus(t *testing.T, resp *model.Response) {
t.Helper()
checkHTTPStatus(t, resp, http.StatusNotFound, true)
}
func CheckBadRequestStatus(t *testing.T, resp *model.Response) {
t.Helper()
checkHTTPStatus(t, resp, http.StatusBadRequest, true)
}
func CheckNotImplementedStatus(t *testing.T, resp *model.Response) {
t.Helper()
checkHTTPStatus(t, resp, http.StatusNotImplemented, true)
}
func CheckRequestEntityTooLargeStatus(t *testing.T, resp *model.Response) {
t.Helper()
checkHTTPStatus(t, resp, http.StatusRequestEntityTooLarge, true)
}
func CheckInternalErrorStatus(t *testing.T, resp *model.Response) {
t.Helper()
checkHTTPStatus(t, resp, http.StatusInternalServerError, true)
}
func CheckErrorMessage(t *testing.T, resp *model.Response, errorId string) {
t.Helper()
if resp.Error == nil {
t.Fatal("should have errored with message:" + errorId)
return
}
if resp.Error.Id != errorId {
t.Log("actual: " + resp.Error.Id)
t.Log("expected: " + errorId)
t.Fatal("incorrect error message")
}
}
// Similar to s3.New() but allows initialization of signature v2 or signature v4 client.
// If signV2 input is false, function always returns signature v4.
//
// Additionally this function also takes a user defined region, if set
// disables automatic region lookup.
func s3New(endpoint, accessKey, secretKey string, secure bool, signV2 bool, region string) (*s3.Client, error) {
var creds *credentials.Credentials
if signV2 {
creds = credentials.NewStatic(accessKey, secretKey, "", credentials.SignatureV2)
} else {
creds = credentials.NewStatic(accessKey, secretKey, "", credentials.SignatureV4)
}
return s3.NewWithCredentials(endpoint, creds, secure, region)
}
func (me *TestHelper) cleanupTestFile(info *model.FileInfo) error {
cfg := me.App.Config()
if *cfg.FileSettings.DriverName == model.IMAGE_DRIVER_S3 {
endpoint := *cfg.FileSettings.AmazonS3Endpoint
accessKey := *cfg.FileSettings.AmazonS3AccessKeyId
secretKey := *cfg.FileSettings.AmazonS3SecretAccessKey
secure := *cfg.FileSettings.AmazonS3SSL
signV2 := *cfg.FileSettings.AmazonS3SignV2
region := *cfg.FileSettings.AmazonS3Region
s3Clnt, err := s3New(endpoint, accessKey, secretKey, secure, signV2, region)
if err != nil {
return err
}
bucket := *cfg.FileSettings.AmazonS3Bucket
if err := s3Clnt.RemoveObject(bucket, info.Path); err != nil {
return err
}
if info.ThumbnailPath != "" {
if err := s3Clnt.RemoveObject(bucket, info.ThumbnailPath); err != nil {
return err
}
}
if info.PreviewPath != "" {
if err := s3Clnt.RemoveObject(bucket, info.PreviewPath); err != nil {
return err
}
}
} else if *cfg.FileSettings.DriverName == model.IMAGE_DRIVER_LOCAL {
if err := os.Remove(*cfg.FileSettings.Directory + info.Path); err != nil {
return err
}
if info.ThumbnailPath != "" {
if err := os.Remove(*cfg.FileSettings.Directory + info.ThumbnailPath); err != nil {
return err
}
}
if info.PreviewPath != "" {
if err := os.Remove(*cfg.FileSettings.Directory + info.PreviewPath); err != nil {
return err
}
}
}
return nil
}
func (me *TestHelper) MakeUserChannelAdmin(user *model.User, channel *model.Channel) {
utils.DisableDebugLogForTest()
if cm, err := me.App.Srv.Store.Channel().GetMember(channel.Id, user.Id); err == nil {
cm.SchemeAdmin = true
if _, err = me.App.Srv.Store.Channel().UpdateMember(cm); err != nil {
utils.EnableDebugLogForTest()
panic(err)
}
} else {
utils.EnableDebugLogForTest()
panic(err)
}
utils.EnableDebugLogForTest()
}
func (me *TestHelper) UpdateUserToTeamAdmin(user *model.User, team *model.Team) {
utils.DisableDebugLogForTest()
if tm, err := me.App.Srv.Store.Team().GetMember(team.Id, user.Id); err == nil {
tm.SchemeAdmin = true
if _, err = me.App.Srv.Store.Team().UpdateMember(tm); err != nil {
utils.EnableDebugLogForTest()
panic(err)
}
} else {
utils.EnableDebugLogForTest()
mlog.Error(err.Error())
time.Sleep(time.Second)
panic(err)
}
utils.EnableDebugLogForTest()
}
func (me *TestHelper) UpdateUserToNonTeamAdmin(user *model.User, team *model.Team) {
utils.DisableDebugLogForTest()
if tm, err := me.App.Srv.Store.Team().GetMember(team.Id, user.Id); err == nil {
tm.SchemeAdmin = false
if _, err = me.App.Srv.Store.Team().UpdateMember(tm); err != nil {
utils.EnableDebugLogForTest()
panic(err)
}
} else {
utils.EnableDebugLogForTest()
mlog.Error(err.Error())
time.Sleep(time.Second)
panic(err)
}
utils.EnableDebugLogForTest()
}
func (me *TestHelper) SaveDefaultRolePermissions() map[string][]string {
utils.DisableDebugLogForTest()
results := make(map[string][]string)
for _, roleName := range []string{
"system_user",
"system_admin",
"team_user",
"team_admin",
"channel_user",
"channel_admin",
} {
role, err1 := me.App.GetRoleByName(roleName)
if err1 != nil {
utils.EnableDebugLogForTest()
panic(err1)
}
results[roleName] = role.Permissions
}
utils.EnableDebugLogForTest()
return results
}
func (me *TestHelper) RestoreDefaultRolePermissions(data map[string][]string) {
utils.DisableDebugLogForTest()
for roleName, permissions := range data {
role, err1 := me.App.GetRoleByName(roleName)
if err1 != nil {
utils.EnableDebugLogForTest()
panic(err1)
}
if strings.Join(role.Permissions, " ") == strings.Join(permissions, " ") {
continue
}
role.Permissions = permissions
_, err2 := me.App.UpdateRole(role)
if err2 != nil {
utils.EnableDebugLogForTest()
panic(err2)
}
}
utils.EnableDebugLogForTest()
}
func (me *TestHelper) RemovePermissionFromRole(permission string, roleName string) {
utils.DisableDebugLogForTest()
role, err1 := me.App.GetRoleByName(roleName)
if err1 != nil {
utils.EnableDebugLogForTest()
panic(err1)
}
var newPermissions []string
for _, p := range role.Permissions {
if p != permission {
newPermissions = append(newPermissions, p)
}
}
if strings.Join(role.Permissions, " ") == strings.Join(newPermissions, " ") {
utils.EnableDebugLogForTest()
return
}
role.Permissions = newPermissions
_, err2 := me.App.UpdateRole(role)
if err2 != nil {
utils.EnableDebugLogForTest()
panic(err2)
}
utils.EnableDebugLogForTest()
}
func (me *TestHelper) AddPermissionToRole(permission string, roleName string) {
utils.DisableDebugLogForTest()
role, err1 := me.App.GetRoleByName(roleName)
if err1 != nil {
utils.EnableDebugLogForTest()
panic(err1)
}
for _, existingPermission := range role.Permissions {
if existingPermission == permission {
utils.EnableDebugLogForTest()
return
}
}
role.Permissions = append(role.Permissions, permission)
_, err2 := me.App.UpdateRole(role)
if err2 != nil {
utils.EnableDebugLogForTest()
panic(err2)
}
utils.EnableDebugLogForTest()
} |
ruser.Password = "Pa$$word11" |
searching.py | from .errors import MultipleResults, NoResults
def equals(field, value):
"""Return function where input ``field`` value is equal to ``value``"""
return lambda x: x.get(field) == value
def contains(field, value):
return lambda x: value in x.get(field)
def startswith(field, value):
return lambda x: x.get(field, '').startswith(value)
def either(*funcs): |
def exclude(func):
"""Return the opposite of ``func`` (i.e. ``False`` instead of ``True``)"""
return lambda x: not func(x)
def doesnt_contain_any(field, values):
"""Exclude all dataset whose ``field`` contains any of ``values``"""
return lambda x: all(exclude(contains(field, value))(x) for value in values)
def get_many(data, *funcs):
"""Apply all filter functions ``funcs`` to ``data``"""
for fltr in funcs:
data = filter(fltr, data)
return data
def get_one(data, *funcs):
"""Apply filter functions ``funcs`` to ``data``, and return exactly one result.
Raises ``wurst.errors.NoResults`` or ``wurst.errors.MultipleResults`` if zero or multiple results are returned.
"""
results = list(get_many(data, *funcs))
if not results:
raise NoResults
if not len(results) == 1:
raise MultipleResults
return results[0]
def _exchanges(ds, kind, *funcs):
if funcs == [None]:
funcs = []
return get_many(
filter(lambda x: x['type'] == kind, ds['exchanges']),
*funcs
)
def technosphere(ds, *funcs):
"""Get all technosphere exchanges in ``ds`` that pass filtering functions ``funcs``"""
return _exchanges(ds, 'technosphere', *funcs)
def biosphere(ds, *funcs):
"""Get all biosphere exchanges in ``ds`` that pass filtering functions ``funcs``"""
return _exchanges(ds, 'biosphere', *funcs)
def production(ds, *funcs):
"""Get all production exchanges in ``ds`` that pass filtering functions ``funcs``"""
return _exchanges(ds, 'production', *funcs)
def reference_product(ds):
"""Get single reference product exchange from a dataset.
Raises ``wurst.errors.NoResults`` or ``wurst.errors.MultipleResults`` if zero or multiple results are returned."""
excs = [exc for exc in ds['exchanges']
if exc['amount']
and exc['type'] == 'production']
if not excs:
raise NoResults("No suitable production exchanges founds")
elif len(excs) > 1:
raise MultipleResults("Multiple production exchanges found")
return excs[0]
def best_geo_match(possibles, ordered_locations):
"""Pick the dataset from ``possibles`` whose location is first in ``ordered_locations``.
``possibles`` is an interable with the field ``location``.
``ordered_locations`` is a list of locations in sorting order.
Returns an element from ``possibles``, or ``None``.
"""
weights = {y: x for x, y in enumerate(ordered_locations)}
filtered = (obj for obj in possibles if obj['location'] in weights)
ordered = sorted(filtered, key=lambda x: weights[x['location']])
if ordered:
return ordered[0] | """Return ``True`` is any of the function evaluate true"""
return lambda x: any(f(x) for f in funcs) |
mod.rs | //! Azure HTTP headers.
mod utilities;
pub use utilities::*;
use http::request::Builder;
use std::collections::HashMap;
/// A trait for converting a type into request headers
pub trait AsHeaders {
type Iter: Iterator<Item = (HeaderName, HeaderValue)>;
fn as_headers(&self) -> Self::Iter;
}
impl<T> AsHeaders for T
where
T: Header,
{
type Iter = std::option::IntoIter<(HeaderName, HeaderValue)>;
fn as_headers(&self) -> Self::Iter {
Some((self.name(), self.value())).into_iter()
}
}
impl<T> AsHeaders for Option<T>
where
T: Header,
{
type Iter = std::option::IntoIter<(HeaderName, HeaderValue)>;
fn as_headers(&self) -> Self::Iter |
}
/// View a type as an HTTP header.
///
/// Ad interim there are two default functions: `add_to_builder` and `add_to_request`.
///
/// While not restricted by the type system, please add HTTP headers only. In particular, do not
/// interact with the body of the request.
///
/// As soon as the migration to the pipeline architecture will be complete we will phase out
/// `add_to_builder`.
pub trait Header {
fn name(&self) -> HeaderName;
fn value(&self) -> HeaderValue;
}
/// A collection of headers
#[derive(Clone, Debug)]
pub struct Headers(std::collections::HashMap<HeaderName, HeaderValue>);
impl Headers {
pub(crate) fn new() -> Self {
Self(Default::default())
}
/// Get a header value given a specific header name
pub fn get<T: Into<HeaderName>>(&self, key: T) -> Option<&HeaderValue> {
self.0.get(&key.into())
}
/// Insert a header name/value pair
pub fn insert<K, V>(&mut self, key: K, value: V)
where
K: Into<HeaderName>,
V: Into<HeaderValue>,
{
self.0.insert(key.into(), value.into());
}
/// Iterate over all the header name/value pairs
pub fn iter(&self) -> impl Iterator<Item = (&HeaderName, &HeaderValue)> {
self.0.iter()
}
}
impl IntoIterator for Headers {
type Item = (HeaderName, HeaderValue);
type IntoIter = std::collections::hash_map::IntoIter<HeaderName, HeaderValue>;
fn into_iter(self) -> Self::IntoIter {
self.0.into_iter()
}
}
impl From<std::collections::HashMap<HeaderName, HeaderValue>> for Headers {
fn from(c: std::collections::HashMap<HeaderName, HeaderValue>) -> Self {
Self(c)
}
}
impl From<http::HeaderMap> for Headers {
fn from(map: http::HeaderMap) -> Self {
let map = map
.into_iter()
.filter_map(|(k, v)| {
let key = k?.as_str().to_owned();
let value = std::str::from_utf8(v.as_bytes())
.expect("non-UTF8 header value")
.to_owned();
Some((key.into(), value.into()))
})
.collect::<HashMap<HeaderName, HeaderValue>>();
Self(map)
}
}
/// A header name
#[derive(Clone, Debug, Hash, Eq, PartialEq, PartialOrd, Ord)]
pub struct HeaderName(std::borrow::Cow<'static, str>);
impl HeaderName {
pub fn as_str(&self) -> &str {
self.0.as_ref()
}
}
impl From<http::header::HeaderName> for HeaderName {
fn from(n: http::header::HeaderName) -> Self {
Self(std::borrow::Cow::Owned(n.as_str().into()))
}
}
impl From<&'static str> for HeaderName {
fn from(s: &'static str) -> Self {
Self(std::borrow::Cow::Borrowed(s))
}
}
impl From<String> for HeaderName {
fn from(s: String) -> Self {
Self(std::borrow::Cow::Owned(s))
}
}
impl From<&HeaderName> for http::header::HeaderName {
fn from(n: &HeaderName) -> Self {
http::header::HeaderName::from_bytes(n.as_str().as_bytes()).unwrap()
}
}
/// A header value
#[derive(Clone, Debug, PartialEq, Eq)]
pub struct HeaderValue(std::borrow::Cow<'static, str>);
impl HeaderValue {
pub fn as_str(&self) -> &str {
self.0.as_ref()
}
}
impl From<http::header::HeaderValue> for HeaderValue {
fn from(n: http::header::HeaderValue) -> Self {
Self(std::borrow::Cow::Owned(
n.to_str().expect("non-UTF8 header value").to_owned(),
))
}
}
impl From<&'static str> for HeaderValue {
fn from(s: &'static str) -> Self {
Self(std::borrow::Cow::Borrowed(s))
}
}
impl From<String> for HeaderValue {
fn from(s: String) -> Self {
Self(std::borrow::Cow::Owned(s))
}
}
impl From<&String> for HeaderValue {
fn from(s: &String) -> Self {
Self(std::borrow::Cow::Owned(s.clone()))
}
}
impl From<&HeaderValue> for http::header::HeaderValue {
fn from(n: &HeaderValue) -> Self {
http::header::HeaderValue::from_bytes(n.as_str().as_bytes()).unwrap()
}
}
#[must_use]
pub fn add_optional_header_ref<T: Header>(item: &Option<&T>, mut builder: Builder) -> Builder {
if let Some(item) = item {
builder = builder.header(item.name().as_str(), item.value().as_str())
}
builder
}
#[must_use]
pub fn add_optional_header<T: Header>(item: &Option<T>, mut builder: Builder) -> Builder {
if let Some(item) = item {
builder = builder.header(item.name().as_str(), item.value().as_str())
}
builder
}
#[must_use]
pub fn add_mandatory_header<T: Header>(item: &T, builder: Builder) -> Builder {
builder.header(item.name().as_str(), item.value().as_str())
}
// headers are case insensitive
// we are using all lowercase values
// same as https://github.com/hyperium/http/blob/master/util/src/main.rs
pub const ACL: &str = "x-ms-acl";
pub const ACCOUNT_KIND: &str = "x-ms-account-kind";
pub const ACTIVITY_ID: &str = "x-ms-activity-id";
pub const APP: &str = "x-ms-app";
pub const AUTHORIZATION: &str = "authorization";
pub const APPEND_POSITION: &str = "x-ms-blob-condition-appendpos";
pub const BLOB_ACCESS_TIER: &str = "x-ms-access-tier";
pub const BLOB_CONTENT_LENGTH: &str = "x-ms-blob-content-length";
pub const BLOB_PUBLIC_ACCESS: &str = "x-ms-blob-public-access";
pub const BLOB_SEQUENCE_NUMBER: &str = "x-ms-blob-sequence-number";
pub const BLOB_TYPE: &str = "x-ms-blob-type";
pub const BLOB_CACHE_CONTROL: &str = "x-ms-blob-cache-control";
pub const CACHE_CONTROL: &str = "cache-control";
pub const CLIENT_REQUEST_ID: &str = "x-ms-client-request-id";
pub const CLIENT_VERSION: &str = "x-ms-client-version";
pub const CONTENT_DISPOSITION: &str = "x-ms-blob-content-disposition";
pub const CONTENT_ENCODING: &str = "content-encoding";
pub const CONTENT_LANGUAGE: &str = "content-language";
pub const CONTENT_LENGTH: &str = "content-length";
pub const CONTENT_LOCATION: &str = "content-location";
pub const CONTENT_MD5: &str = "content-md5";
pub const CONTENT_RANGE: &str = "content-range";
pub const CONTENT_SECURITY_POLICY: &str = "content-security-policy";
pub const CONTENT_TYPE: &str = "content-type";
pub const CONTINUATION: &str = "x-ms-continuation";
pub const COPY_COMPLETION_TIME: &str = "x-ms-copy-completion-time";
pub const COPY_PROGRESS: &str = "x-ms-copy-progress";
pub const COPY_SOURCE: &str = "x-ms-copy-source";
pub const COPY_STATUS: &str = "x-ms-copy-status";
pub const COPY_STATUS_DESCRIPTION: &str = "x-ms-copy-status-description";
pub const CREATION_TIME: &str = "x-ms-creation-time";
pub const DATE: &str = "date";
pub const DELETE_SNAPSHOTS: &str = "x-ms-delete-snapshots";
pub const DELETE_TYPE_PERMANENT: &str = "x-ms-delete-type-permanent";
pub const ETAG: &str = "etag";
pub const HAS_IMMUTABILITY_POLICY: &str = "x-ms-has-immutability-policy";
pub const HAS_LEGAL_HOLD: &str = "x-ms-has-legal-hold";
pub const IF_MATCH: &str = "if-match";
pub const IF_MODIFIED_SINCE: &str = "if-modified-since";
pub const IF_NONE_MATCH: &str = "if-none-match";
pub const IF_RANGE: &str = "if-range";
pub const IF_UNMODIFIED_SINCE: &str = "if-unmodified-since";
pub const IF_SEQUENCE_NUMBER_EQ: &str = "x-ms-if-sequence-number-eq";
pub const IF_SEQUENCE_NUMBER_LE: &str = "x-ms-if-sequence-number-le";
pub const IF_SEQUENCE_NUMBER_LT: &str = "x-ms-if-sequence-number-lt";
pub const ITEM_COUNT: &str = "x-ms-item-count";
pub const ITEM_TYPE: &str = "x-ms-item-type";
pub const KEEP_ALIVE: &str = "keep-alive";
pub const LAST_MODIFIED: &str = "last-modified";
pub const LEASE_ACTION: &str = "x-ms-lease-action";
pub const LEASE_BREAK_PERIOD: &str = "x-ms-lease-break-period";
pub const LEASE_DURATION: &str = "x-ms-lease-duration";
pub const LEASE_ID: &str = "x-ms-lease-id";
pub const LEASE_STATE: &str = "x-ms-lease-state";
pub const LEASE_STATUS: &str = "x-ms-lease-status";
pub const LEASE_TIME: &str = "x-ms-lease-time";
pub const LINK: &str = "link";
pub const LOCATION: &str = "location";
pub const MAX_ITEM_COUNT: &str = "x-ms-max-item-count";
pub const META_PREFIX: &str = "x-ms-meta-";
pub const MS_DATE: &str = "x-ms-date";
pub const NAMESPACE_ENABLED: &str = "x-ms-namespace-enabled";
pub const PAGE_WRITE: &str = "x-ms-page-write";
pub const PROPERTIES: &str = "x-ms-properties";
pub const PROPOSED_LEASE_ID: &str = "x-ms-proposed-lease-id";
pub const RANGE: &str = "range";
pub const RANGE_GET_CONTENT_MD5: &str = "x-ms-range-get-content-md5";
pub const REQUEST_ID: &str = "x-ms-request-id";
pub const REQUEST_SERVER_ENCRYPTED: &str = "x-ms-request-server-encrypted";
pub const REQUIRES_SYNC: &str = "x-ms-requires-sync";
pub const RETRY_AFTER: &str = "retry-after";
pub const SERVER_ENCRYPTED: &str = "x-ms-server-encrypted";
pub const SESSION_TOKEN: &str = "x-ms-session-token";
pub const SKU_NAME: &str = "x-ms-sku-name";
pub const SOURCE_IF_MATCH: &str = "x-ms-source-if-match";
pub const SOURCE_IF_MODIFIED_SINCE: &str = "x-ms-source-if-modified-since";
pub const SOURCE_IF_NONE_MATCH: &str = "x-ms-source-if-none-match";
pub const SOURCE_IF_UNMODIFIED_SINCE: &str = "x-ms-source-if-unmodified-since";
pub const SOURCE_LEASE_ID: &str = "x-ms-source-lease-id";
pub const USER: &str = "x-ms-user";
pub const USER_AGENT: &str = "user-agent";
pub const VERSION: &str = "x-ms-version";
pub const WWW_AUTHENTICATE: &str = "www-authenticate";
| {
match self {
Some(h) => h.as_headers(),
None => None.into_iter(),
}
} |
lib.rs | #![no_std]
use core::panic::PanicInfo;
#[panic_handler]
fn | (_info: &PanicInfo) -> ! {
loop {}
}
extern "C" {
fn SBPublish(msg: *const u8, len: usize);
// fn SBGetInt64(name: *const u8, strlen: usize) -> (i64, i32);
fn SBSetInt64(name: *const u8, strlen: usize, value: i64);
}
#[no_mangle]
pub extern "C" fn entry_point1() -> i32 {
let message = "Value has been set".as_bytes();
let var_name = "counter".as_bytes();
unsafe {
// let val = SBGetInt64(var_name.as_ptr(), var_name.len());
// let val = if val.1==0 {
// val.0
// } else{
// 0
// };
SBSetInt64(var_name.as_ptr(), var_name.len(), 1);
SBPublish(message.as_ptr(), message.len());
// wrong
//SBPublish(buf, len);
}
return 0;
} | panic |
cmd.go | package main
import (
"bytes"
"fmt"
"html/template"
"os"
"path"
"strings"
"github.com/spf13/afero"
"pkg.glorieux.io/mantra"
)
var fs = afero.NewOsFs()
var templates = template.New("").Funcs(template.FuncMap{
"Title": func(s string) string {
return strings.Title(s)
},
})
func init() |
func createApplication(name string) error {
fmt.Printf("Creating application %s...\n", name)
if exists, _ := afero.DirExists(fs, name); exists {
return fmt.Errorf("Directory named %s already exists", name)
}
err := fs.MkdirAll(name, os.ModeDir|os.ModePerm)
if err != nil {
return fmt.Errorf("Error creating %s directory: %s", name, err)
}
if exists, _ := afero.Exists(fs, path.Join(name, "main.go")); !exists {
var b bytes.Buffer
err := templates.ExecuteTemplate(&b, "main", strings.ToLower(name))
if err != nil {
return err
}
err = afero.WriteFile(fs, path.Join(name, "main.go"), b.Bytes(), 0644)
if err != nil {
return err
}
}
if exists, _ := afero.Exists(fs, path.Join(name, "go.mod")); !exists {
var b bytes.Buffer
err := templates.ExecuteTemplate(&b, "go.mod", struct {
Name string
MantraVersion string
}{
strings.ToLower(name),
mantra.VERSION,
})
if err != nil {
return err
}
err = afero.WriteFile(fs, path.Join(name, "go.mod"), b.Bytes(), 0644)
if err != nil {
return err
}
}
fmt.Println("You're good to go!")
fmt.Printf("You can now run [go build ./%s] to build the application.\n", name)
return nil
}
func createService(name string) error {
if exists, _ := afero.Exists(fs, fmt.Sprintf("%s.go", name)); !exists {
var b bytes.Buffer
err := templates.ExecuteTemplate(&b, "service", strings.ToLower(name))
if err != nil {
return err
}
err = afero.WriteFile(fs, fmt.Sprintf("%s.go", name), b.Bytes(), 0644)
if err != nil {
return err
}
}
return nil
}
| {
template.Must(templates.New("go.mod").Parse(`module {{ .Name }}
require (
pkg.glorieux.io/mantra v{{ .MantraVersion }}
)
`))
template.Must(templates.New("main").Parse(`package main
import (
"github.com/sirupsen/logrus"
"pkg.glorieux.io/mantra"
)
func main() {
log := logrus.New()
mantra.New(log)
}
`))
template.Must(templates.New("service").Parse(`package {{ . }}
import (
"pkg.glorieux.io/mantra"
)
type {{ . | Title }}Service struct{}
// Serve runs the service
func (*{{ . | Title }}Service) Serve(mux mantra.ServeMux) {
mux.Handle("tmp", func(e mantra.Event) {
// TODO: Handle event
})
}
// Stop stops the service
func (*{{ . | Title }}Service) Stop() error {
return nil
}
func (*{{ . | Title }}Service) String() string {
return "{{ . }}"
}
`))
} |
index.ts | import { Command, flags, Flags } from 'prisma-cli-engine'
import chalk from 'chalk'
import { prettyTime } from '../../util'
export default class | extends Command {
static topic = 'delete'
static description = 'Delete an existing service'
static group = 'db'
static flags: Flags = {
force: flags.boolean({
char: 'f',
description: 'Force delete, without confirmation',
}),
['env-file']: flags.string({
description: 'Path to .env file to inject env vars',
char: 'e',
}),
}
async run() {
const { force } = this.flags
const envFile = this.flags['env-file']
await this.definition.load(this.flags, envFile)
const serviceName = this.definition.service!
const stage = this.definition.stage!
const cluster = await this.definition.getCluster()
this.env.setActiveCluster(cluster!)
await this.client.initClusterClient(
cluster!,
serviceName,
stage,
this.definition.getWorkspace(),
)
const prettyName = `${chalk.bold(serviceName)}@${stage}`
if (!force) {
await this.askForConfirmation(prettyName)
}
const before = Date.now()
this.out.action.start(
`${chalk.red.bold(
`Deleting service ${prettyName} from ${this.definition.cluster}`,
)}`,
)
try {
await this.client.deleteProject(
serviceName,
stage,
this.definition.getWorkspace() ||
(this.env.activeCluster.workspaceSlug as string),
)
} catch (e) {
if (!force) {
this.out.error(e)
}
}
this.out.action.stop(prettyTime(Date.now() - before))
}
private async askForConfirmation(projects: string) {
const confirmationQuestion = {
name: 'confirmation',
type: 'input',
message: `Are you sure that you want to delete ${projects}? y/N`,
default: 'n',
}
const { confirmation }: { confirmation: string } = await this.out.prompt(
confirmationQuestion,
)
if (confirmation.toLowerCase().startsWith('n')) {
this.out.exit(0)
}
}
}
| Delete |
fake_firewall.go | /*
Copyright AppsCode Inc. and Contributors
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*/
// Code generated by client-gen. DO NOT EDIT.
package fake
import (
"context"
v1alpha1 "kubeform.dev/provider-ibm-api/apis/firewall/v1alpha1"
v1 "k8s.io/apimachinery/pkg/apis/meta/v1"
labels "k8s.io/apimachinery/pkg/labels"
schema "k8s.io/apimachinery/pkg/runtime/schema"
types "k8s.io/apimachinery/pkg/types"
watch "k8s.io/apimachinery/pkg/watch"
testing "k8s.io/client-go/testing"
)
// FakeFirewalls implements FirewallInterface
type FakeFirewalls struct {
Fake *FakeFirewallV1alpha1
ns string
}
var firewallsResource = schema.GroupVersionResource{Group: "firewall.ibm.kubeform.com", Version: "v1alpha1", Resource: "firewalls"}
var firewallsKind = schema.GroupVersionKind{Group: "firewall.ibm.kubeform.com", Version: "v1alpha1", Kind: "Firewall"}
// Get takes name of the firewall, and returns the corresponding firewall object, and an error if there is any.
func (c *FakeFirewalls) Get(ctx context.Context, name string, options v1.GetOptions) (result *v1alpha1.Firewall, err error) {
obj, err := c.Fake.
Invokes(testing.NewGetAction(firewallsResource, c.ns, name), &v1alpha1.Firewall{})
if obj == nil {
return nil, err
}
return obj.(*v1alpha1.Firewall), err
}
// List takes label and field selectors, and returns the list of Firewalls that match those selectors.
func (c *FakeFirewalls) List(ctx context.Context, opts v1.ListOptions) (result *v1alpha1.FirewallList, err error) {
obj, err := c.Fake.
Invokes(testing.NewListAction(firewallsResource, firewallsKind, c.ns, opts), &v1alpha1.FirewallList{})
if obj == nil {
return nil, err
}
label, _, _ := testing.ExtractFromListOptions(opts)
if label == nil {
label = labels.Everything()
}
list := &v1alpha1.FirewallList{ListMeta: obj.(*v1alpha1.FirewallList).ListMeta}
for _, item := range obj.(*v1alpha1.FirewallList).Items {
if label.Matches(labels.Set(item.Labels)) {
list.Items = append(list.Items, item)
}
}
return list, err
}
// Watch returns a watch.Interface that watches the requested firewalls.
func (c *FakeFirewalls) Watch(ctx context.Context, opts v1.ListOptions) (watch.Interface, error) {
return c.Fake.
InvokesWatch(testing.NewWatchAction(firewallsResource, c.ns, opts))
}
// Create takes the representation of a firewall and creates it. Returns the server's representation of the firewall, and an error, if there is any.
func (c *FakeFirewalls) Create(ctx context.Context, firewall *v1alpha1.Firewall, opts v1.CreateOptions) (result *v1alpha1.Firewall, err error) {
obj, err := c.Fake.
Invokes(testing.NewCreateAction(firewallsResource, c.ns, firewall), &v1alpha1.Firewall{})
if obj == nil {
return nil, err
}
return obj.(*v1alpha1.Firewall), err
}
// Update takes the representation of a firewall and updates it. Returns the server's representation of the firewall, and an error, if there is any.
func (c *FakeFirewalls) Update(ctx context.Context, firewall *v1alpha1.Firewall, opts v1.UpdateOptions) (result *v1alpha1.Firewall, err error) {
obj, err := c.Fake.
Invokes(testing.NewUpdateAction(firewallsResource, c.ns, firewall), &v1alpha1.Firewall{})
if obj == nil {
return nil, err
}
return obj.(*v1alpha1.Firewall), err
}
// UpdateStatus was generated because the type contains a Status member.
// Add a +genclient:noStatus comment above the type to avoid generating UpdateStatus().
func (c *FakeFirewalls) UpdateStatus(ctx context.Context, firewall *v1alpha1.Firewall, opts v1.UpdateOptions) (*v1alpha1.Firewall, error) {
obj, err := c.Fake.
Invokes(testing.NewUpdateSubresourceAction(firewallsResource, "status", c.ns, firewall), &v1alpha1.Firewall{})
if obj == nil {
return nil, err
}
return obj.(*v1alpha1.Firewall), err
}
// Delete takes name of the firewall and deletes it. Returns an error if one occurs.
func (c *FakeFirewalls) Delete(ctx context.Context, name string, opts v1.DeleteOptions) error {
_, err := c.Fake.
Invokes(testing.NewDeleteAction(firewallsResource, c.ns, name), &v1alpha1.Firewall{})
return err
}
// DeleteCollection deletes a collection of objects.
func (c *FakeFirewalls) DeleteCollection(ctx context.Context, opts v1.DeleteOptions, listOpts v1.ListOptions) error {
action := testing.NewDeleteCollectionAction(firewallsResource, c.ns, listOpts)
_, err := c.Fake.Invokes(action, &v1alpha1.FirewallList{})
return err
}
// Patch applies the patch and returns the patched firewall.
func (c *FakeFirewalls) Patch(ctx context.Context, name string, pt types.PatchType, data []byte, opts v1.PatchOptions, subresources ...string) (result *v1alpha1.Firewall, err error) {
obj, err := c.Fake.
Invokes(testing.NewPatchSubresourceAction(firewallsResource, c.ns, name, pt, data, subresources...), &v1alpha1.Firewall{})
| } | if obj == nil {
return nil, err
}
return obj.(*v1alpha1.Firewall), err |
0002_auto_20201117_0251.py | # Generated by Django 3.0.5 on 2020-11-17 02:51
from django.db import migrations, models
class Migration(migrations.Migration):
| dependencies = [
('webapi', '0001_initial'),
]
operations = [
migrations.AddField(
model_name='products',
name='capacities',
field=models.CharField(default='custom', max_length=128, verbose_name='容量'),
),
migrations.AddField(
model_name='products',
name='imprint_location',
field=models.CharField(default='custom', max_length=64, verbose_name='logo位置'),
),
migrations.AddField(
model_name='products',
name='imprint_methods',
field=models.CharField(default='custom', max_length=128, verbose_name='logo工艺'),
),
migrations.AddField(
model_name='products',
name='imprint_size',
field=models.CharField(default='custom', max_length=128, verbose_name='logo尺寸'),
),
migrations.AddField(
model_name='products',
name='material',
field=models.CharField(default='custom', max_length=64, verbose_name='材质'),
),
migrations.AddField(
model_name='products',
name='moq',
field=models.IntegerField(default=100, verbose_name='起订量'),
),
migrations.AlterField(
model_name='products',
name='pro_color',
field=models.CharField(blank=True, max_length=1024, verbose_name='产品颜色'),
),
]
|
|
mod.rs | use ff::{Field, PrimeField};
mod dummy_engine;
use self::dummy_engine::*;
use std::marker::PhantomData;
use std::ops::{AddAssign, MulAssign, SubAssign};
use crate::{Circuit, ConstraintSystem, SynthesisError};
use super::{create_proof, generate_parameters, prepare_verifying_key, verify_proof};
struct XorDemo<Scalar: PrimeField> {
a: Option<bool>,
b: Option<bool>,
_marker: PhantomData<Scalar>,
}
impl<Scalar: PrimeField> Circuit<Scalar> for XorDemo<Scalar> {
fn synthesize<CS: ConstraintSystem<Scalar>>(self, cs: &mut CS) -> Result<(), SynthesisError> {
let a_var = cs.alloc(
|| "a",
|| {
if self.a.is_some() {
if self.a.unwrap() {
Ok(Scalar::one())
} else {
Ok(Scalar::zero())
}
} else {
Err(SynthesisError::AssignmentMissing)
}
},
)?;
cs.enforce(
|| "a_boolean_constraint",
|lc| lc + CS::one() - a_var,
|lc| lc + a_var,
|lc| lc,
);
let b_var = cs.alloc(
|| "b",
|| {
if self.b.is_some() {
if self.b.unwrap() {
Ok(Scalar::one())
} else {
Ok(Scalar::zero())
}
} else {
Err(SynthesisError::AssignmentMissing)
}
},
)?;
cs.enforce(
|| "b_boolean_constraint",
|lc| lc + CS::one() - b_var,
|lc| lc + b_var,
|lc| lc,
);
let c_var = cs.alloc_input(
|| "c",
|| {
if self.a.is_some() && self.b.is_some() {
if self.a.unwrap() ^ self.b.unwrap() {
Ok(Scalar::one())
} else {
Ok(Scalar::zero())
}
} else {
Err(SynthesisError::AssignmentMissing)
}
},
)?;
cs.enforce(
|| "c_xor_constraint",
|lc| lc + a_var + a_var,
|lc| lc + b_var,
|lc| lc + a_var + b_var - c_var,
);
Ok(())
}
}
#[test]
fn test_xordemo() {
let g1 = Fr::one();
let g2 = Fr::one();
let alpha = Fr::from(48577);
let beta = Fr::from(22580);
let gamma = Fr::from(53332);
let delta = Fr::from(5481);
let tau = Fr::from(3673);
let params = {
let c = XorDemo {
a: None,
b: None,
_marker: PhantomData,
};
generate_parameters::<DummyEngine, _>(c, g1, g2, alpha, beta, gamma, delta, tau).unwrap()
}; | // public inputs: a_0 = 1, a_1 = c
// aux inputs: a_2 = a, a_3 = b
// constraints:
// (a_0 - a_2) * (a_2) = 0
// (a_0 - a_3) * (a_3) = 0
// (a_2 + a_2) * (a_3) = (a_2 + a_3 - a_1)
// (a_0) * 0 = 0
// (a_1) * 0 = 0
// The evaluation domain is 8. The H query should
// have 7 elements (it's a quotient polynomial)
assert_eq!(7, params.h.len());
let mut root_of_unity = Fr::root_of_unity();
// We expect this to be a 2^10 root of unity
assert_eq!(Fr::one(), root_of_unity.pow_vartime(&[1u64 << 10]));
// Let's turn it into a 2^3 root of unity.
root_of_unity = root_of_unity.pow_vartime(&[1u64 << 7]);
assert_eq!(Fr::one(), root_of_unity.pow_vartime(&[1u64 << 3]));
assert_eq!(Fr::from(20201), root_of_unity);
// Let's compute all the points in our evaluation domain.
let mut points = Vec::with_capacity(8);
for i in 0u64..8 {
points.push(root_of_unity.pow_vartime(&[i]));
}
// Let's compute t(tau) = (tau - p_0)(tau - p_1)...
// = tau^8 - 1
let mut t_at_tau = tau.pow_vartime(&[8u64]);
t_at_tau.sub_assign(&Fr::one());
{
let mut tmp = Fr::one();
for p in &points {
let mut term = tau;
term.sub_assign(p);
tmp.mul_assign(&term);
}
assert_eq!(tmp, t_at_tau);
}
// We expect our H query to be 7 elements of the form...
// {tau^i t(tau) / delta}
let delta_inverse = delta.invert().unwrap();
let gamma_inverse = gamma.invert().unwrap();
{
let mut coeff = delta_inverse;
coeff.mul_assign(&t_at_tau);
let mut cur = Fr::one();
for h in params.h.iter() {
let mut tmp = cur;
tmp.mul_assign(&coeff);
assert_eq!(*h, tmp);
cur.mul_assign(&tau);
}
}
// The density of the IC query is 2 (2 inputs)
assert_eq!(2, params.vk.ic.len());
// The density of the L query is 2 (2 aux variables)
assert_eq!(2, params.l.len());
// The density of the A query is 4 (each variable is in at least one A term)
assert_eq!(4, params.a.len());
// The density of the B query is 2 (two variables are in at least one B term)
assert_eq!(2, params.b_g1.len());
assert_eq!(2, params.b_g2.len());
/*
Lagrange interpolation polynomials in our evaluation domain:
,-------------------------------. ,-------------------------------. ,-------------------------------.
| A TERM | | B TERM | | C TERM |
`-------------------------------. `-------------------------------' `-------------------------------'
| a_0 | a_1 | a_2 | a_3 | | a_0 | a_1 | a_2 | a_3 | | a_0 | a_1 | a_2 | a_3 |
| 1 | 0 | 64512 | 0 | | 0 | 0 | 1 | 0 | | 0 | 0 | 0 | 0 |
| 1 | 0 | 0 | 64512 | | 0 | 0 | 0 | 1 | | 0 | 0 | 0 | 0 |
| 0 | 0 | 2 | 0 | | 0 | 0 | 0 | 1 | | 0 | 64512 | 1 | 1 |
| 1 | 0 | 0 | 0 | | 0 | 0 | 0 | 0 | | 0 | 0 | 0 | 0 |
| 0 | 1 | 0 | 0 | | 0 | 0 | 0 | 0 | | 0 | 0 | 0 | 0 |
`-------'-------'-------'-------' `-------'-------'-------'-------' `-------'-------'-------'-------'
Example for u_0:
sage: r = 64513
sage: Fr = GF(r)
sage: omega = (Fr(5)^63)^(2^7)
sage: tau = Fr(3673)
sage: R.<x> = PolynomialRing(Fr, 'x')
sage: def eval(tau, c0, c1, c2, c3, c4):
....: p = R.lagrange_polynomial([(omega^0, c0), (omega^1, c1), (omega^2, c2), (omega^3, c3), (omega^4, c4), (omega^5, 0), (omega^6, 0), (omega^7, 0)])
....: return p.substitute(tau)
sage: eval(tau, 1, 1, 0, 1, 0)
59158
*/
let u_i = [59158, 48317, 21767, 10402]
.iter()
.map(|e| Fr::from(*e))
.collect::<Vec<Fr>>();
let v_i = [0, 0, 60619, 30791]
.iter()
.map(|e| Fr::from(*e))
.collect::<Vec<Fr>>();
let w_i = [0, 23320, 41193, 41193]
.iter()
.map(|e| Fr::from(*e))
.collect::<Vec<Fr>>();
for (u, a) in u_i.iter().zip(¶ms.a[..]) {
assert_eq!(u, a);
}
for (v, b) in v_i
.iter()
.filter(|&&e| e != Fr::zero())
.zip(¶ms.b_g1[..])
{
assert_eq!(v, b);
}
for (v, b) in v_i
.iter()
.filter(|&&e| e != Fr::zero())
.zip(¶ms.b_g2[..])
{
assert_eq!(v, b);
}
for i in 0..4 {
let mut tmp1 = beta;
tmp1.mul_assign(&u_i[i]);
let mut tmp2 = alpha;
tmp2.mul_assign(&v_i[i]);
tmp1.add_assign(&tmp2);
tmp1.add_assign(&w_i[i]);
if i < 2 {
// Check the correctness of the IC query elements
tmp1.mul_assign(&gamma_inverse);
assert_eq!(tmp1, params.vk.ic[i]);
} else {
// Check the correctness of the L query elements
tmp1.mul_assign(&delta_inverse);
assert_eq!(tmp1, params.l[i - 2]);
}
}
// Check consistency of the other elements
assert_eq!(alpha, params.vk.alpha_g1);
assert_eq!(beta, params.vk.beta_g1);
assert_eq!(beta, params.vk.beta_g2);
assert_eq!(gamma, params.vk.gamma_g2);
assert_eq!(delta, params.vk.delta_g1);
assert_eq!(delta, params.vk.delta_g2);
let pvk = prepare_verifying_key(¶ms.vk);
let r = Fr::from(27134);
let s = Fr::from(17146);
let proof = {
let c = XorDemo {
a: Some(true),
b: Some(false),
_marker: PhantomData,
};
create_proof(c, ¶ms, r, s).unwrap()
};
// A(x) =
// a_0 * (44865*x^7 + 56449*x^6 + 44865*x^5 + 8064*x^4 + 3520*x^3 + 56449*x^2 + 3520*x + 40321) +
// a_1 * (8064*x^7 + 56449*x^6 + 8064*x^5 + 56449*x^4 + 8064*x^3 + 56449*x^2 + 8064*x + 56449) +
// a_2 * (16983*x^7 + 24192*x^6 + 63658*x^5 + 56449*x^4 + 16983*x^3 + 24192*x^2 + 63658*x + 56449) +
// a_3 * (5539*x^7 + 27797*x^6 + 6045*x^5 + 56449*x^4 + 58974*x^3 + 36716*x^2 + 58468*x + 8064) +
{
// proof A = alpha + A(tau) + delta * r
let mut expected_a = delta;
expected_a.mul_assign(&r);
expected_a.add_assign(&alpha);
expected_a.add_assign(&u_i[0]); // a_0 = 1
expected_a.add_assign(&u_i[1]); // a_1 = 1
expected_a.add_assign(&u_i[2]); // a_2 = 1
// a_3 = 0
assert_eq!(proof.a, expected_a);
}
// B(x) =
// a_0 * (0) +
// a_1 * (0) +
// a_2 * (56449*x^7 + 56449*x^6 + 56449*x^5 + 56449*x^4 + 56449*x^3 + 56449*x^2 + 56449*x + 56449) +
// a_3 * (31177*x^7 + 44780*x^6 + 21752*x^5 + 42255*x^3 + 35861*x^2 + 33842*x + 48385)
{
// proof B = beta + B(tau) + delta * s
let mut expected_b = delta;
expected_b.mul_assign(&s);
expected_b.add_assign(&beta);
expected_b.add_assign(&v_i[0]); // a_0 = 1
expected_b.add_assign(&v_i[1]); // a_1 = 1
expected_b.add_assign(&v_i[2]); // a_2 = 1
// a_3 = 0
assert_eq!(proof.b, expected_b);
}
// C(x) =
// a_0 * (0) +
// a_1 * (27797*x^7 + 56449*x^6 + 36716*x^5 + 8064*x^4 + 27797*x^3 + 56449*x^2 + 36716*x + 8064) +
// a_2 * (36716*x^7 + 8064*x^6 + 27797*x^5 + 56449*x^4 + 36716*x^3 + 8064*x^2 + 27797*x + 56449) +
// a_3 * (36716*x^7 + 8064*x^6 + 27797*x^5 + 56449*x^4 + 36716*x^3 + 8064*x^2 + 27797*x + 56449)
//
// If A * B = C at each point in the domain, then the following polynomial...
// P(x) = A(x) * B(x) - C(x)
// = 49752*x^14 + 13914*x^13 + 29243*x^12 + 27227*x^11 + 62362*x^10 + 35703*x^9 + 4032*x^8 + 14761*x^6 + 50599*x^5 + 35270*x^4 + 37286*x^3 + 2151*x^2 + 28810*x + 60481
//
// ... should be divisible by t(x), producing the quotient polynomial:
// h(x) = P(x) / t(x)
// = 49752*x^6 + 13914*x^5 + 29243*x^4 + 27227*x^3 + 62362*x^2 + 35703*x + 4032
{
let mut expected_c = Fr::zero();
// A * s
let mut tmp = proof.a;
tmp.mul_assign(&s);
expected_c.add_assign(&tmp);
// B * r
let mut tmp = proof.b;
tmp.mul_assign(&r);
expected_c.add_assign(&tmp);
// delta * r * s
let mut tmp = delta;
tmp.mul_assign(&r);
tmp.mul_assign(&s);
expected_c.sub_assign(&tmp);
// L query answer
// a_2 = 1, a_3 = 0
expected_c.add_assign(¶ms.l[0]);
// H query answer
for (i, coeff) in [5040, 11763, 10755, 63633, 128, 9747, 8739]
.iter()
.enumerate()
{
let coeff = Fr::from(*coeff);
let mut tmp = params.h[i];
tmp.mul_assign(&coeff);
expected_c.add_assign(&tmp);
}
assert_eq!(expected_c, proof.c);
}
assert!(verify_proof(&pvk, &proof, &[Fr::one()]).is_ok());
} |
// This will synthesize the constraint system:
// |
rocrate.py | #!/usr/bin/env python
# Copyright 2019-2020 The University of Manchester, UK
# Copyright 2020 Vlaams Instituut voor Biotechnologie (VIB), BE
# Copyright 2020 Barcelona Supercomputing Center (BSC), ES
# Copyright 2020 Center for Advanced Studies, Research and Development in Sardinia (CRS4), IT
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
import importlib
import json
import os
import uuid
import requests
import zipfile
import atexit
import shutil
import tempfile
from pathlib import Path
from .model import contextentity
from .model.root_dataset import RootDataset
from .model.file import File
from .model.person import Person
from .model.dataset import Dataset
from .model.metadata import Metadata, LegacyMetadata
from .model.preview import Preview
from arcp import generate
TEST_METADATA_BASENAME = "test-metadata.json"
class ROCrate():
def __init__(self, source_path=None, load_preview=False):
self.default_entities = []
self.data_entities = []
self.contextual_entities = []
# TODO: add this as @base in the context? At least when loading
# from zip
self.uuid = uuid.uuid4()
# TODO: default_properties must include name, description,
# datePublished, license
if not source_path or not load_preview:
# create preview entity and add it to default_entities
self.preview = Preview(self)
self.default_entities.append(self.preview)
if not source_path:
# create a new ro-crate
self.root_dataset = RootDataset(self)
self.default_entities.append(self.root_dataset)
self.metadata = Metadata(self)
self.default_entities.append(self.metadata)
else:
# load an existing ro-crate
if zipfile.is_zipfile(source_path):
zip_path = tempfile.mkdtemp(prefix="ro", suffix="crate")
atexit.register(shutil.rmtree, zip_path)
with zipfile.ZipFile(source_path, "r") as zip_file:
zip_file.extractall(zip_path)
source_path = zip_path
metadata_path = os.path.join(source_path, Metadata.BASENAME)
MetadataClass = Metadata
if not os.path.isfile(metadata_path):
metadata_path = os.path.join(source_path, LegacyMetadata.BASENAME)
MetadataClass = LegacyMetadata
if not os.path.isfile(metadata_path):
raise ValueError('The directory is not a valid RO-crate, '
f'missing {Metadata.BASENAME}')
self.metadata = MetadataClass(self)
self.default_entities.append(self.metadata)
entities = self.entities_from_metadata(metadata_path)
self.build_crate(entities, source_path, load_preview)
# TODO: load root dataset properties
def entities_from_metadata(self, metadata_path):
# Creates a dictionary {id: entity} from the metadata file
with open(metadata_path) as metadata_file:
metadata_jsonld = json.load(metadata_file)
# TODO: should validate the json-ld
if '@graph' in metadata_jsonld.keys():
entities_dict = {}
for entity in metadata_jsonld['@graph']:
entities_dict[entity['@id']] = entity
# print(entity)
return entities_dict
else:
raise ValueError('The metadata file has no @graph')
def find_root_entity_id(self, entities):
"""Find Metadata file and Root Data Entity in RO-Crate.
Returns a tuple of the @id identifiers (metadata, root)
"""
# Note that for all cases below we will deliberately
# throw KeyError if "about" exists but it has no "@id"
# First let's try conformsTo algorithm in
# <https://www.researchobject.org/ro-crate/1.1/root-data-entity.html#finding-the-root-data-entity>
for entity in entities.values():
conformsTo = entity.get("conformsTo")
if conformsTo and "@id" in conformsTo:
conformsTo = conformsTo["@id"]
if conformsTo and conformsTo.startswith("https://w3id.org/ro/crate/"):
if "about" in entity:
return (entity["@id"], entity["about"]["@id"])
# ..fall back to a generous look up by filename,
for candidate in (
Metadata.BASENAME, LegacyMetadata.BASENAME,
f"./{Metadata.BASENAME}", f"./{LegacyMetadata.BASENAME}"
):
metadata_file = entities.get(candidate)
if metadata_file and "about" in metadata_file:
return (metadata_file["@id"], metadata_file["about"]["@id"])
# No luck! Is there perhaps a root dataset directly in here?
root = entities.get("./", {})
# FIXME: below will work both for
# "@type": "Dataset"
# "@type": ["Dataset"]
# ..but also the unlikely
# "@type": "DatasetSomething"
if root and "Dataset" in root.get("@type", []):
return (None, "./")
# Uh oh..
raise KeyError("Can't find Root Data Entity in RO-Crate, see https://www.researchobject.org/ro-crate/1.1/root-data-entity.html")
def build_crate(self, entities, source, load_preview):
# add data and contextual entities to the crate
(metadata_id, root_id) = self.find_root_entity_id(entities)
root_entity = entities[root_id]
root_entity_parts = root_entity['hasPart']
# remove hasPart and id from root_entity and add the rest of the
# properties to the build
root_entity.pop('@id', None)
root_entity.pop('hasPart', None)
self.root_dataset = RootDataset(self, root_entity)
self.default_entities.append(self.root_dataset)
# check if a preview is present
if Preview.BASENAME in entities.keys() and load_preview:
preview_source = os.path.join(source, Preview.BASENAME)
self.preview = Preview(self, preview_source)
self.default_entities.append(self.preview)
added_entities = []
# iterate over data entities
for data_entity_ref in root_entity_parts:
data_entity_id = data_entity_ref['@id']
# print(data_entity_id)
entity = entities[data_entity_id]
# basic checks should be moved to a separate function
if '@type' not in entity.keys():
raise Exception("Entity with @id:" + data_entity_id +
" has no type defined")
# Data entities can have an array as @type. So far we just parse
# them as File class if File is in the list. For further
# extensions (e.g if a Workflow class is created) we can add extra
# cases or create a mapping table for specific combinations. See
# https://github.com/ResearchObject/ro-crate/issues/83
entity_types = (entity['@type']
if isinstance(entity['@type'], list)
else [entity['@type']])
if 'File' in entity_types:
file_path = os.path.join(source, entity['@id'])
identifier = entity.pop('@id', None)
if os.path.exists(file_path):
# referencing a file path relative to crate-root
instance = File(self, file_path, identifier, properties=entity)
else:
# check if it is a valid absolute URI
try:
requests.get(identifier)
instance = File(self, identifier, properties=entity)
except requests.ConnectionError:
print("Source is not a valid URI")
if 'Dataset' in entity_types:
dir_path = os.path.join(source, entity['@id'])
if os.path.exists(dir_path):
props = {k: v for k, v in entity.items() if k != '@id'}
instance = Dataset(self, dir_path, entity['@id'], props)
else:
raise Exception('Directory not found')
self._add_data_entity(instance)
added_entities.append(data_entity_id)
# the rest of the entities must be contextual entities
prebuilt_entities = [
root_id, metadata_id, Preview.BASENAME
]
for identifier, entity in entities.items():
if identifier not in added_entities + prebuilt_entities:
# should this be done in the extract entities?
entity.pop('@id', None)
# contextual entities should not have @type array
# (see https://github.com/ResearchObject/ro-crate/issues/83)
if entity['@type'] in [
cls.__name__
for cls in contextentity.ContextEntity.__subclasses__()
]:
module_name = 'rocrate.model.' + entity['@type'].lower()
SubClass = getattr(
importlib.import_module(module_name, package=None),
entity['@type']
)
instance = SubClass(self, identifier, entity)
else:
instance = contextentity.ContextEntity(
self, identifier, entity
)
self._add_context_entity(instance)
# TODO: add contextual entities
# def add_contact_point(id, properties = {})
# def add_organization(id, properties = {})
# add properties: name datePublished author license identifier
# distribution contactPoint publisher funder description url hasPart.
# publisher should be an Organization though it MAY be a Person. funder
# should reference an Organization
@property
def name(self):
return self.root_dataset['name']
@name.setter | def datePublished(self):
return self.root_dataset.datePublished
@datePublished.setter
def datePublished(self, value):
self.root_dataset.datePublished = value
@property
def creator(self):
return self.root_dataset['creator']
@creator.setter
def creator(self, value):
self.root_dataset['creator'] = value
@property
def license(self):
return self.root_dataset['license']
@license.setter
def license(self, value):
self.root_dataset['license'] = value
@property
def description(self):
return self.root_dataset['description']
@description.setter
def description(self, value):
self.root_dataset['description'] = value
@property
def keywords(self):
return self.root_dataset['keywords']
@keywords.setter
def keywords(self, value):
self.root_dataset['keywords'] = value
@property
def publisher(self):
return self.root_dataset['publisher']
@publisher.setter
def publisher(self, value):
self.root_dataset['publisher'] = value
@property
def isBasedOn(self):
return self.root_dataset['isBasedOn']
@isBasedOn.setter
def isBasedOn(self, value):
self.root_dataset['isBasedOn'] = value
@property
def image(self):
return self.root_dataset['image']
@image.setter
def image(self, value):
self.root_dataset['image'] = value
@property
def CreativeWorkStatus(self):
return self.root_dataset['CreativeWorkStatus']
@CreativeWorkStatus.setter
def CreativeWorkStatus(self, value):
self.root_dataset['CreativeWorkStatus'] = value
@property
def test_dir(self):
rval = self.dereference("test")
if rval and "Dataset" in rval.type:
return rval
return None
@property
def examples_dir(self):
rval = self.dereference("examples")
if rval and "Dataset" in rval.type:
return rval
return None
@property
def test_metadata_path(self):
if self.test_dir is None:
return None
return Path(self.test_dir.filepath()) / TEST_METADATA_BASENAME
def resolve_id(self, relative_id):
return generate.arcp_random(relative_id.strip('./'), uuid=self.uuid)
def get_entities(self):
return (self.default_entities + self.data_entities +
self.contextual_entities)
def set_main_entity(self, main_entity):
self.root_dataset['mainEntity'] = main_entity
def _get_root_jsonld(self):
self.root_dataset.properties()
def dereference(self, entity_id):
canonical_id = self.resolve_id(entity_id)
for entity in self.get_entities():
if canonical_id == entity.canonical_id():
return entity
return None
# source: file object or path (str)
def add_file(self, source, crate_path=None, fetch_remote=False,
properties={}, **kwargs):
props = dict(properties)
props.update(kwargs)
file_entity = File(self, source=source, dest_path=crate_path, fetch_remote=fetch_remote, properties=props)
self._add_data_entity(file_entity)
return file_entity
def remove_file(self, file_id):
# if file in data_entities:
self._remove_data_entity(file_id)
def add_directory(self, source, crate_path=None, properties={}, **kwargs):
props = dict(properties)
props.update(kwargs)
dataset_entity = Dataset(self, source, crate_path, properties)
self._add_data_entity(dataset_entity)
return dataset_entity
def remove_directory(self, dir_id):
# if file in data_entities:
self._remove_data_entity(dir_id)
def _add_data_entity(self, data_entity):
self._remove_data_entity(data_entity)
self.data_entities.append(data_entity)
def _remove_data_entity(self, data_entity):
if data_entity in self.data_entities:
self.data_entities.remove(data_entity)
################################
# Contextual entities #
################################
def _add_context_entity(self, entity):
if entity in self.contextual_entities:
self.contextual_entities.remove(entity)
self.contextual_entities.append(entity)
def add_person(self, identifier=None, properties={}, **kwargs):
props = dict(properties)
props.update(kwargs)
new_person = Person(self, identifier, props)
self._add_context_entity(new_person)
return new_person
# TODO
# def fetch_all(self):
# fetch all files defined in the crate
# write crate to local dir
def write_crate(self, base_path):
Path(base_path).mkdir(parents=True, exist_ok=True)
# write data entities
for writable_entity in self.data_entities + self.default_entities:
writable_entity.write(base_path)
def write_zip(self, out_zip):
if str(out_zip).endswith('.zip'):
out_file_path = out_zip
else:
out_file_path = out_zip + '.zip'
zf = zipfile.ZipFile(
out_file_path, 'w', compression=zipfile.ZIP_DEFLATED,
allowZip64=True
)
for writable_entity in self.data_entities + self.default_entities:
writable_entity.write_zip(zf)
zf.close()
return zf.filename | def name(self, value):
self.root_dataset['name'] = value
@property |
const-err.rs | // Copyright 2012 The Rust Project Developers. See the COPYRIGHT
// file at the top-level directory of this distribution and at
// http://rust-lang.org/COPYRIGHT.
//
// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
// option. This file may not be copied, modified, or distributed
// except according to those terms.
// compile-flags: -Zforce-overflow-checks=on
// these errors are not actually "const_err", they occur in codegen/consts
// and are unconditional warnings that can't be denied or allowed
#![allow(exceeding_bitshifts)]
#![allow(const_err)]
fn | <T>(_: T) {
unimplemented!()
}
// Make sure that the two uses get two errors.
const FOO: u8 = [5u8][1];
//~^ ERROR constant evaluation error
//~| ERROR constant evaluation error
//~| index out of bounds: the len is 1 but the index is 1
fn main() {
black_box((FOO, FOO));
}
| black_box |
hexfile.py | #!/usr/bin/env python3
"""
Hexdump Utility
===============
A command line hexdump utility.
See the module's `Github homepage <https://github.com/risapav/ihex_analyzer>`_
for details.
"""
# pouzite kniznice
import struct
import codecs
# definovanie konstant
ROWTYPE_DATA = 0x00 # Data container
ROWTYPE_EOF = 0x01 # End of file
ROWTYPE_EXT_SEG_ADDR = 0x02 # Extended Segment Address
ROWTYPE_START_SEG_ADDR = 0x03 # Start Segment Address
ROWTYPE_EXT_LIN_ADDR = 0x04 # Extended Linear Address
ROWTYPE_START_LIN_ADDR = 0x05 # Start Linear Address
# definovanie tried
class HexFile:
"""
trieda spracuvajuca Hexfile
"""
def __init__(self, filename):
# nazov suboru vo formate intel hex
self._filename = filename
# nedolezite udaje z pohladu umistnenia dat v pamati
self._CS = 0
self._IP = 0
self._EIP = 0
# udaje dolezite pre vypocet umiestnenia v pamati
self._ADDRESS = 0
self._SBA = 0
self._LBA = 0
self._typ = ROWTYPE_DATA
# spustenie analyzy intel hex suboru
def doAnalyze(self):
with open(self._filename, 'r', encoding='utf-8') as fp:
cnt = 1
for line in fp:
line = line.strip()
if not line:
continue
# kazdy riadok sa musi zacinat znakom ':'
if not line.startswith(':'):
raise ValueError(
"Invalid line start character (%r)" % line[0])
continue
# ------------------------------------------------------------
# vypocet dlzky retazca ihex recordu
data = self.byteCnv(line[1:3])
# 1[:] + 2[LL] + 4[AAAA] + 2[TT] + 2n[DATA] + 2[CC]
dataend = 1 + 2 + 4 + 2 + 2*data + 2
# print(line[0:dataend])
# ------------------------------------------------------------
# crc vypocitane zo zvysku riadku musi byt 0
crc = self.calcChecksum(line[1:dataend])
if crc != 0:
raise ValueError(
"Record checksum doesn't match on line %d" % cnt)
continue
# ------------------------------------------------------------
# teraz je riadok validny a moze zacat analyza
# dataend = len(line)
typ, length, addr, data = self.parseLine(
cnt, line[1:dataend - 2])
self.analyzeLine(typ, length, addr, data)
cnt += 1
# nastavenie adresy umiestnenia dat
# drlo - adresa Word
def setAddress(self, drlo):
# index
dri = 0
if self._typ == ROWTYPE_EXT_SEG_ADDR: # Extended Segment Address
self._ADDRESS = self._SBA * 0x10 + (drlo + dri) % 0xFFFF
elif self._typ == ROWTYPE_EXT_LIN_ADDR: # Extended Linear Address
self._ADDRESS = (self._LBA * 0x10000 + drlo + dri) % 0xFFFFFFFF
else:
self._ADDRESS = drlo + dri
# konverzia z textoveho stringu na cislo velkosti Byte
# data - textovy retazec data 2 znaky
def byteCnv(self, data):
|
# konverzia z textoveho stringu na cislo velkosti Word
# data - textovy retazec data 4 znaky
def wordCnv(self, data):
buffer = codecs.decode(data, "hex")
return struct.unpack(">H", buffer[0:2])[0]
# konverzia z textoveho stringu na cislo velkosti DWord
# data - textovy retazec data 8 znakov
def dwordCnv(self, data):
buffer = codecs.decode(data, "hex")
return struct.unpack(">I", buffer[0:4])[0]
# textový výpis do stdout
# typ - typ zaznamu 0-5
# length - dlzka datovej casti
# addr - nacitana adresa (index)
# data - textovy retazec data
# txt - komentar
def txtMessage(self, typ, length, addr, data, txt):
print('{0:0{1}X}'.format(self._ADDRESS, 8),
"typ:", '{0:0{1}X}'.format(typ, 2),
"addr:", '{0:0{1}X}'.format(addr, 4),
"len:", '{0:0{1}X}'.format(length, 2),
"data:", data,
" -> ", txt
)
# analyzovanie parsovaneho riadku
# typ - typ zaznamu 0-5
# length - dlzka datovej casti
# addr - nacitana adresa (index)
# data - textovy retazec data
def analyzeLine(self, typ, length, addr, data):
if typ == ROWTYPE_DATA: # Data container 0x00
self.setAddress(addr)
self.txtMessage(typ, length, addr, data, " data ")
elif typ == ROWTYPE_EOF: # End of file 0x01
# print("End of file") # Should we check for garbage after this?
self._typ = ROWTYPE_DATA
self.setAddress(addr)
self.txtMessage(typ, length, addr, data, "End of file")
elif typ == ROWTYPE_EXT_SEG_ADDR: # Extended Segment Address 0x02
# SBA + ([DRLO + DRI] MOD 64K)
self._typ = ROWTYPE_DATA
self.setAddress(addr)
self.txtMessage(typ, length, addr, data,
"Extended Segment Address")
self._SBA = self.wordCnv(data)
self._typ = ROWTYPE_EXT_SEG_ADDR
elif typ == ROWTYPE_START_SEG_ADDR: # Start Segment Address 0x03
# CS:IP
self._typ = ROWTYPE_DATA
self.setAddress(addr)
self.txtMessage(typ, length, addr,
data, "Start Segment Address")
self._CS = self.wordCnv(data[0:2])
self._IP = self.wordCnv(data[2:4])
elif typ == ROWTYPE_EXT_LIN_ADDR: # Extended Linear Address 0x04
# (LBA + DRLO + DRI) MOD 4G
self._typ = ROWTYPE_DATA
self.setAddress(addr)
self.txtMessage(typ, length, addr, data,
"Extended Linear Address")
self._LBA = self.wordCnv(data)
self._typ = ROWTYPE_EXT_LIN_ADDR
elif typ == ROWTYPE_START_LIN_ADDR: # Start Linear Address 0x05
# EIP
self._typ = ROWTYPE_DATA
self.txtMessage(typ, length, addr,
data, "Start Linear Address")
self._EIP = self.wordCnv(data[0:4])
else: # undefined record
raise ValueError("Invalid type byte")
# vypocet crc suctu
# data - textovy retazec data
def calcChecksum(self, data):
crc = 0
buffer = codecs.decode(data, "hex")
# print(type(buffer), len(buffer), buffer, data)
for byte in buffer:
crc += byte
return crc & 0xFF
# parsovanie jedne nacitaneho riadku
# cnt - cislo nacitaneho riadku
# rawline - textovy string, jeden riadok zo suboru
def parseLine(self, cnt, rawline):
try:
# dlzka dat v zazname
length = self.byteCnv(rawline[0:2])
# adresa umiestnenia
addr = self.wordCnv(rawline[2:6])
# typ zaznamu
typ = self.byteCnv(rawline[6:8])
# data zaznamu
data = rawline[8:]
return (typ, length, addr, data)
except ValueError:
raise ValueError("Invalid hex data")
return (0x00, 0x00, 0x00, "\xFF\xFF")
# hlavna funkcia
def main():
hexfile = HexFile('demo/ds30loader.X.production.hex')
hexfile.doAnalyze()
return 0
# spustenie programu
main()
| buffer = codecs.decode(data, "hex")
return struct.unpack(">B", buffer[0:1])[0] |
overlay.go | // SPDX-License-Identifier: Apache-2.0
// SPDX-FileCopyrightText: 2021 Hajime Hoshi
package hitsumabushi
import (
"bytes"
"encoding/json"
"errors"
"fmt"
"io"
"io/fs"
"os"
"os/exec"
"path/filepath"
"regexp"
"runtime"
"strings"
)
type Option func(*config)
type config struct {
testPkgs []string
numCPU int
args []string
clockGettimeName string
futexName string
}
// TestPkg represents a package for testing.
// When generating a JSON, importing `runtime/cgo` is inserted in the testing package.
func TestPkg(pkg string) Option {
return func(cfg *config) {
cfg.testPkgs = append(cfg.testPkgs, pkg)
}
}
// NumCPU represents a number of CPU.
// The default value is runtime.NumCPU().
func NumCPU(numCPU int) Option {
return func(cfg *config) {
cfg.numCPU = numCPU
}
}
// Args is arguments when executing.
// The first argument must be a program name.
func Args(args ...string) Option {
return func(cfg *config) {
cfg.args = append(cfg.args, args...)
}
}
// ReplaceClockGettime replaces the C function `clock_gettime` with the given name.
// If name is an empty string, the function is not replaced.
// This is useful for special environments where `clock_gettime` doesn't work correctly.
func ReplaceClockGettime(name string) Option {
return func(cfg *config) {
cfg.clockGettimeName = name
}
}
// ReplaceClockGettime replaces the system call `futex` with the given name.
// If name is an empty string, a pseudo futex implementation is used.
// This is useful for special environments where the pseudo `futex` doesn't work correctly.
func ReplaceFutex(name string) Option {
return func(cfg *config) {
cfg.futexName = name
}
}
func currentDir() string |
var reGoVersion = regexp.MustCompile(`go(\d+\.\d+)(\.\d+)?`)
// GenOverlayJSON generates a JSON file for go-build's `-overlay` option.
// GenOverlayJSON returns a JSON file content, or an error if generating it fails.
//
// Now the generated JSON works only for Arm64 so far.
func GenOverlayJSON(options ...Option) ([]byte, error) {
type overlay struct {
Replace map[string]string
}
cfg := config{
numCPU: runtime.NumCPU(),
}
for _, op := range options {
op(&cfg)
}
m := reGoVersion.FindStringSubmatch(runtime.Version())
dir := filepath.Join(currentDir(), m[1]+"_"+runtime.GOOS)
if _, err := os.Stat(dir); err != nil {
if errors.Is(err, os.ErrNotExist) {
return nil, fmt.Errorf("the Go version %s and GOOS=%s is not supported", runtime.Version(), runtime.GOOS)
}
return nil, err
}
replaces := map[string]string{}
tmpDir, err := os.MkdirTemp("", "")
if err != nil {
return nil, err
}
if err := filepath.Walk(dir, func(path string, info fs.FileInfo, err error) error {
if info.IsDir() {
return nil
}
const (
modTypeReplace = ".replace"
modTypeAppend = ".append"
modTypePatch = ".patch"
)
modType := modTypeReplace
origFilename := filepath.Base(path)
for _, m := range []string{modTypeAppend, modTypePatch} {
if strings.HasSuffix(origFilename, m) {
origFilename = origFilename[:len(origFilename)-len(m)]
modType = m
break
}
}
ext := filepath.Ext(origFilename)
if ext != ".go" && ext != ".c" && ext != ".h" && ext != ".s" {
return nil
}
shortPath, err := filepath.Rel(dir, path)
if err != nil {
return err
}
pkg := filepath.ToSlash(filepath.Dir(shortPath))
origDir, err := goPkgDir(pkg)
if err != nil {
return err
}
src, err := os.Open(path)
if err != nil {
return err
}
defer src.Close()
if err := os.MkdirAll(filepath.Join(tmpDir, pkg), 0755); err != nil {
return err
}
dst, err := os.Create(filepath.Join(tmpDir, pkg, origFilename))
if err != nil {
return err
}
defer dst.Close()
origPath := filepath.Join(origDir, origFilename)
defer func() {
replaces[origPath] = dst.Name()
}()
switch modType {
case modTypeReplace:
if _, err := io.Copy(dst, src); err != nil {
return err
}
case modTypeAppend:
orig, err := os.Open(origPath)
if err != nil {
return err
}
defer orig.Close()
if _, err := io.Copy(dst, io.MultiReader(orig, src)); err != nil {
return err
}
case modTypePatch:
orig, err := os.Open(origPath)
if err != nil {
return err
}
defer orig.Close()
p, err := parsePatch(shortPath, src)
if err != nil {
return err
}
patched, err := p.apply(orig)
if err != nil {
return err
}
if _, err := io.Copy(dst, patched); err != nil {
return err
}
default:
return fmt.Errorf("hitsumabushi: unexpected modType: %s", modType)
}
switch {
case runtime.GOOS == "linux" && pkg == "runtime/cgo" && origFilename == "gcc_linux_arm64.c":
// The number of CPU is defined at runtime/cgo/gcc_linux_arm64.c
numBytes := (cfg.numCPU-1)/8 + 1
tmpl := `
int32_t c_sched_getaffinity(pid_t pid, size_t cpusetsize, void *mask) {
{{.Masking}}
// https://man7.org/linux/man-pages/man2/sched_setaffinity.2.html
// > On success, the raw sched_getaffinity() system call returns the
// > number of bytes placed copied into the mask buffer;
return {{.NumBytes}};
}
`
n := cfg.numCPU
var masking string
for i := 0; i < numBytes; i++ {
mask := 0
m := 8
if n < m {
m = n
}
for j := 0; j < m; j++ {
mask |= 1 << j
}
masking += fmt.Sprintf(" ((char*)mask)[%d] = 0x%x;\n", i, mask)
n -= 8
}
tmpl = strings.ReplaceAll(tmpl, "{{.Masking}}", masking)
tmpl = strings.ReplaceAll(tmpl, "{{.NumBytes}}", fmt.Sprintf("%d", numBytes))
if _, err := dst.Write([]byte(tmpl)); err != nil {
return err
}
}
return nil
}); err != nil {
return nil, err
}
if runtime.GOOS == "linux" {
// Add pthread_setaffinity_np.
{
indent := "\t\t\t"
setCPU := []string{
indent + fmt.Sprintf(`cpu_set_t *cpu_set = CPU_ALLOC(%d);`, cfg.numCPU),
indent + fmt.Sprintf(`size_t size = CPU_ALLOC_SIZE(%d);`, cfg.numCPU),
indent + `CPU_ZERO_S(size, cpu_set);`,
indent + fmt.Sprintf(`for (int i = 0; i < %d; i++) {`, cfg.numCPU),
indent + ` CPU_SET_S(i, size, cpu_set);`,
indent + `}`,
indent + `pthread_setaffinity_np(*thread, size, cpu_set);`,
indent + `CPU_FREE(cpu_set);`,
}
old := ` err = pthread_create(thread, attr, pfn, arg);
if (err == 0) {
pthread_detach(*thread);
return 0;
}`
new := strings.Replace(` err = pthread_create(thread, attr, pfn, arg);
if (err == 0) {
pthread_detach(*thread);
{{.SetCPU}}
return 0;
}`, "{{.SetCPU}}", strings.Join(setCPU, "\n"), 1)
if err := replace(tmpDir, replaces, "runtime/cgo", "gcc_libinit.c", old, new); err != nil {
return nil, err
}
}
// Replace the arguments.
{
var strs []string
for _, arg := range cfg.args {
strs = append(strs, fmt.Sprintf(`%q`, arg))
}
argvDef := "var __argv = [...]string{" + strings.Join(strs, ", ") + "}"
old := `func goargs() {
if GOOS == "windows" {
return
}
argslice = make([]string, argc)
for i := int32(0); i < argc; i++ {
argslice[i] = gostringnocopy(argv_index(argv, i))
}
}`
new := fmt.Sprintf(`%s
func goargs() {
if GOOS == "windows" {
return
}
argslice = make([]string, %[2]d)
for i := int32(0); i < %[2]d; i++ {
argslice[i] = __argv[i]
}
}`, argvDef, len(cfg.args))
if err := replace(tmpDir, replaces, "runtime", "runtime1.go", old, new); err != nil {
return nil, err
}
}
// Replace clock_gettime.
if cfg.clockGettimeName != "" {
old := "#define clock_gettime clock_gettime"
new := fmt.Sprintf(`void %[1]s(clockid_t, struct timespec *);
#define clock_gettime %[1]s`, cfg.clockGettimeName)
if err := replace(tmpDir, replaces, "runtime/cgo", "gcc_linux_arm64.c", old, new); err != nil {
return nil, err
}
}
// Replace futex.
if cfg.futexName != "" {
old := "#undef user_futex"
new := fmt.Sprintf(`int32_t %[1]s(uint32_t *uaddr, int32_t futex_op, uint32_t val, const struct timespec *timeout, uint32_t *uaddr2, uint32_t val3);
#define user_futex %[1]s`, cfg.futexName)
if err := replace(tmpDir, replaces, "runtime/cgo", "gcc_linux_arm64.c", old, new); err != nil {
return nil, err
}
}
}
// Add importing "runtime/cgo" for testing packages.
for _, pkg := range cfg.testPkgs {
origPath, err := goExternalTestFile(pkg)
if err != nil {
return nil, err
}
pkgName, err := goPkgName(pkg)
if err != nil {
return nil, err
}
// Read the source before opening the destination.
// The destination might be the same as the source.
srcPath := origPath
if p, ok := replaces[origPath]; ok {
srcPath = p
}
srcContent, err := os.ReadFile(srcPath)
if err != nil {
return nil, err
}
if err := os.MkdirAll(filepath.Join(tmpDir, pkg), 0755); err != nil {
return nil, err
}
dst, err := os.Create(filepath.Join(tmpDir, pkg, filepath.Base(origPath)))
if err != nil {
return nil, err
}
defer dst.Close()
// This assumes that there is an external test package.
old := "package " + pkgName + "_test"
new := old + "\n\n" + `import _ "runtime/cgo"`
replaced := strings.Replace(string(srcContent), old, new, 1)
if _, err := io.Copy(dst, bytes.NewReader([]byte(replaced))); err != nil {
return nil, err
}
replaces[origPath] = dst.Name()
}
return json.Marshal(&overlay{Replace: replaces})
}
func goPkgDir(pkg string) (string, error) {
var buf bytes.Buffer
cmd := exec.Command("go", "list", "-f", "{{.Dir}}", pkg)
cmd.Stderr = &buf
out, err := cmd.Output()
if err != nil {
return "", fmt.Errorf("hitsumabushi: %v\n%s", err, buf.String())
}
return strings.TrimSpace(string(out)), nil
}
func goExternalTestFile(pkg string) (string, error) {
idx := 0
for {
var buf bytes.Buffer
cmd := exec.Command("go", "list", "-f", "{{.Dir}}"+string(filepath.Separator)+fmt.Sprintf("{{index .XTestGoFiles %d}}", idx), pkg)
cmd.Stderr = &buf
out, err := cmd.Output()
if err != nil {
return "", fmt.Errorf("hitsumabushi: %v\n%s\nperhaps this package doesn't have an external test", err, buf.String())
}
f := strings.TrimSpace(string(out))
// runtime/callers_test.go is very special and the line number matters.
if pkg == "runtime" && filepath.Base(f) == "callers_test.go" {
idx++
continue
}
return f, nil
}
}
func goPkgName(pkg string) (string, error) {
var buf bytes.Buffer
cmd := exec.Command("go", "list", "-f", "{{.Name}}", pkg)
cmd.Stderr = &buf
out, err := cmd.Output()
if err != nil {
return "", fmt.Errorf("hitsumabushi: %v\n%s", err, buf.String())
}
return strings.TrimSpace(string(out)), nil
}
func replace(tmpDir string, replaces map[string]string, pkg string, filename string, old, new string) error {
origDir, err := goPkgDir(pkg)
if err != nil {
return err
}
origPath := filepath.Join(origDir, filename)
// Read the source before opening the destination.
// The destination might be the same as the source.
srcPath := origPath
if p, ok := replaces[origPath]; ok {
srcPath = p
}
srcContent, err := os.ReadFile(srcPath)
if err != nil {
return err
}
if err := os.MkdirAll(filepath.Join(tmpDir, pkg), 0755); err != nil {
return err
}
dst, err := os.Create(filepath.Join(tmpDir, pkg, filepath.Base(origPath)))
if err != nil {
return err
}
defer dst.Close()
replaced := strings.Replace(string(srcContent), old, new, 1)
if string(srcContent) == replaced {
return fmt.Errorf("hitsumabushi: replacing %s/%s failed: replacing result is the same", pkg, filename)
}
if _, err := io.Copy(dst, bytes.NewReader([]byte(replaced))); err != nil {
return err
}
replaces[origPath] = dst.Name()
return nil
}
| {
_, currentPath, _, _ := runtime.Caller(1)
return filepath.Dir(currentPath)
} |
02_weekend_or_work_day.py | day = input()
if day == "Monday" or day == "Tuesday" or day == "Wednesday" or day == "Thursday" or day == "Friday":
print("Work day")
elif day == "Saturday" or day == "Sunday":
|
else:
print("Error")
| print("Weekend") |
error.rs | /************************************************************************************************/
use crate::text::s;
use crate::text::Text::*;
/************************************************************************************************/
#[derive(Debug)]
pub struct | {
messages: Vec<String>,
}
/************************************************************************************************/
impl YasgError {
/*------------------------------------------------------------------------------------------*/
pub fn new(message: String) -> YasgError {
YasgError {
messages: Vec::new(),
}
.add(message)
}
/*------------------------------------------------------------------------------------------*/
pub fn add(mut self, message: String) -> YasgError {
self.messages.insert(0, message);
self
}
/*------------------------------------------------------------------------------------------*/
pub fn show(&self) {
eprintln!("{}", s(ErrorYasgExit));
for msg in &self.messages {
eprintln!("- {}", msg);
}
}
/*------------------------------------------------------------------------------------------*/
}
/************************************************************************************************/
| YasgError |
compiled.rs | // Copyright 2013 The Rust Project Developers. See the COPYRIGHT
// file at the top-level directory of this distribution and at
// http://rust-lang.org/COPYRIGHT.
//
// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
// option. This file may not be copied, modified, or distributed
// except according to those terms.
#![allow(non_upper_case_globals)]
//! ncurses-compatible compiled terminfo format parsing (term(5))
use std::collections::HashMap;
use std::io::prelude::*;
use std::io;
use super::super::TermInfo;
// These are the orders ncurses uses in its compiled format (as of 5.9). Not sure if portable.
#[allow(missing_docs)]
pub static boolfnames: &'static[&'static str] = &["auto_left_margin", "auto_right_margin",
"no_esc_ctlc", "ceol_standout_glitch", "eat_newline_glitch", "erase_overstrike", "generic_type",
"hard_copy", "has_meta_key", "has_status_line", "insert_null_glitch", "memory_above",
"memory_below", "move_insert_mode", "move_standout_mode", "over_strike", "status_line_esc_ok",
"dest_tabs_magic_smso", "tilde_glitch", "transparent_underline", "xon_xoff", "needs_xon_xoff",
"prtr_silent", "hard_cursor", "non_rev_rmcup", "no_pad_char", "non_dest_scroll_region",
"can_change", "back_color_erase", "hue_lightness_saturation", "col_addr_glitch",
"cr_cancels_micro_mode", "has_print_wheel", "row_addr_glitch", "semi_auto_right_margin",
"cpi_changes_res", "lpi_changes_res", "backspaces_with_bs", "crt_no_scrolling",
"no_correctly_working_cr", "gnu_has_meta_key", "linefeed_is_newline", "has_hardware_tabs",
"return_does_clr_eol"];
#[allow(missing_docs)]
pub static boolnames: &'static[&'static str] = &["bw", "am", "xsb", "xhp", "xenl", "eo",
"gn", "hc", "km", "hs", "in", "db", "da", "mir", "msgr", "os", "eslok", "xt", "hz", "ul", "xon",
"nxon", "mc5i", "chts", "nrrmc", "npc", "ndscr", "ccc", "bce", "hls", "xhpa", "crxm", "daisy",
"xvpa", "sam", "cpix", "lpix", "OTbs", "OTns", "OTnc", "OTMT", "OTNL", "OTpt", "OTxr"];
#[allow(missing_docs)]
pub static numfnames: &'static[&'static str] = &[ "columns", "init_tabs", "lines",
"lines_of_memory", "magic_cookie_glitch", "padding_baud_rate", "virtual_terminal",
"width_status_line", "num_labels", "label_height", "label_width", "max_attributes",
"maximum_windows", "max_colors", "max_pairs", "no_color_video", "buffer_capacity",
"dot_vert_spacing", "dot_horz_spacing", "max_micro_address", "max_micro_jump", "micro_col_size",
"micro_line_size", "number_of_pins", "output_res_char", "output_res_line",
"output_res_horz_inch", "output_res_vert_inch", "print_rate", "wide_char_size", "buttons",
"bit_image_entwining", "bit_image_type", "magic_cookie_glitch_ul", "carriage_return_delay",
"new_line_delay", "backspace_delay", "horizontal_tab_delay", "number_of_function_keys"];
#[allow(missing_docs)]
pub static numnames: &'static[&'static str] = &[ "cols", "it", "lines", "lm", "xmc", "pb",
"vt", "wsl", "nlab", "lh", "lw", "ma", "wnum", "colors", "pairs", "ncv", "bufsz", "spinv",
"spinh", "maddr", "mjump", "mcs", "mls", "npins", "orc", "orl", "orhi", "orvi", "cps", "widcs",
"btns", "bitwin", "bitype", "UTug", "OTdC", "OTdN", "OTdB", "OTdT", "OTkn"];
#[allow(missing_docs)]
pub static stringfnames: &'static[&'static str] = &[ "back_tab", "bell", "carriage_return",
"change_scroll_region", "clear_all_tabs", "clear_screen", "clr_eol", "clr_eos",
"column_address", "command_character", "cursor_address", "cursor_down", "cursor_home",
"cursor_invisible", "cursor_left", "cursor_mem_address", "cursor_normal", "cursor_right",
"cursor_to_ll", "cursor_up", "cursor_visible", "delete_character", "delete_line",
"dis_status_line", "down_half_line", "enter_alt_charset_mode", "enter_blink_mode",
"enter_bold_mode", "enter_ca_mode", "enter_delete_mode", "enter_dim_mode", "enter_insert_mode",
"enter_secure_mode", "enter_protected_mode", "enter_reverse_mode", "enter_standout_mode",
"enter_underline_mode", "erase_chars", "exit_alt_charset_mode", "exit_attribute_mode",
"exit_ca_mode", "exit_delete_mode", "exit_insert_mode", "exit_standout_mode",
"exit_underline_mode", "flash_screen", "form_feed", "from_status_line", "init_1string",
"init_2string", "init_3string", "init_file", "insert_character", "insert_line",
"insert_padding", "key_backspace", "key_catab", "key_clear", "key_ctab", "key_dc", "key_dl",
"key_down", "key_eic", "key_eol", "key_eos", "key_f0", "key_f1", "key_f10", "key_f2", "key_f3",
"key_f4", "key_f5", "key_f6", "key_f7", "key_f8", "key_f9", "key_home", "key_ic", "key_il",
"key_left", "key_ll", "key_npage", "key_ppage", "key_right", "key_sf", "key_sr", "key_stab",
"key_up", "keypad_local", "keypad_xmit", "lab_f0", "lab_f1", "lab_f10", "lab_f2", "lab_f3",
"lab_f4", "lab_f5", "lab_f6", "lab_f7", "lab_f8", "lab_f9", "meta_off", "meta_on", "newline",
"pad_char", "parm_dch", "parm_delete_line", "parm_down_cursor", "parm_ich", "parm_index",
"parm_insert_line", "parm_left_cursor", "parm_right_cursor", "parm_rindex", "parm_up_cursor",
"pkey_key", "pkey_local", "pkey_xmit", "print_screen", "prtr_off", "prtr_on", "repeat_char",
"reset_1string", "reset_2string", "reset_3string", "reset_file", "restore_cursor",
"row_address", "save_cursor", "scroll_forward", "scroll_reverse", "set_attributes", "set_tab",
"set_window", "tab", "to_status_line", "underline_char", "up_half_line", "init_prog", "key_a1",
"key_a3", "key_b2", "key_c1", "key_c3", "prtr_non", "char_padding", "acs_chars", "plab_norm",
"key_btab", "enter_xon_mode", "exit_xon_mode", "enter_am_mode", "exit_am_mode", "xon_character",
"xoff_character", "ena_acs", "label_on", "label_off", "key_beg", "key_cancel", "key_close",
"key_command", "key_copy", "key_create", "key_end", "key_enter", "key_exit", "key_find",
"key_help", "key_mark", "key_message", "key_move", "key_next", "key_open", "key_options",
"key_previous", "key_print", "key_redo", "key_reference", "key_refresh", "key_replace",
"key_restart", "key_resume", "key_save", "key_suspend", "key_undo", "key_sbeg", "key_scancel",
"key_scommand", "key_scopy", "key_screate", "key_sdc", "key_sdl", "key_select", "key_send",
"key_seol", "key_sexit", "key_sfind", "key_shelp", "key_shome", "key_sic", "key_sleft",
"key_smessage", "key_smove", "key_snext", "key_soptions", "key_sprevious", "key_sprint",
"key_sredo", "key_sreplace", "key_sright", "key_srsume", "key_ssave", "key_ssuspend",
"key_sundo", "req_for_input", "key_f11", "key_f12", "key_f13", "key_f14", "key_f15", "key_f16",
"key_f17", "key_f18", "key_f19", "key_f20", "key_f21", "key_f22", "key_f23", "key_f24",
"key_f25", "key_f26", "key_f27", "key_f28", "key_f29", "key_f30", "key_f31", "key_f32",
"key_f33", "key_f34", "key_f35", "key_f36", "key_f37", "key_f38", "key_f39", "key_f40",
"key_f41", "key_f42", "key_f43", "key_f44", "key_f45", "key_f46", "key_f47", "key_f48",
"key_f49", "key_f50", "key_f51", "key_f52", "key_f53", "key_f54", "key_f55", "key_f56",
"key_f57", "key_f58", "key_f59", "key_f60", "key_f61", "key_f62", "key_f63", "clr_bol",
"clear_margins", "set_left_margin", "set_right_margin", "label_format", "set_clock",
"display_clock", "remove_clock", "create_window", "goto_window", "hangup", "dial_phone",
"quick_dial", "tone", "pulse", "flash_hook", "fixed_pause", "wait_tone", "user0", "user1",
"user2", "user3", "user4", "user5", "user6", "user7", "user8", "user9", "orig_pair",
"orig_colors", "initialize_color", "initialize_pair", "set_color_pair", "set_foreground",
"set_background", "change_char_pitch", "change_line_pitch", "change_res_horz",
"change_res_vert", "define_char", "enter_doublewide_mode", "enter_draft_quality",
"enter_italics_mode", "enter_leftward_mode", "enter_micro_mode", "enter_near_letter_quality",
"enter_normal_quality", "enter_shadow_mode", "enter_subscript_mode", "enter_superscript_mode",
"enter_upward_mode", "exit_doublewide_mode", "exit_italics_mode", "exit_leftward_mode",
"exit_micro_mode", "exit_shadow_mode", "exit_subscript_mode", "exit_superscript_mode",
"exit_upward_mode", "micro_column_address", "micro_down", "micro_left", "micro_right",
"micro_row_address", "micro_up", "order_of_pins", "parm_down_micro", "parm_left_micro",
"parm_right_micro", "parm_up_micro", "select_char_set", "set_bottom_margin",
"set_bottom_margin_parm", "set_left_margin_parm", "set_right_margin_parm", "set_top_margin",
"set_top_margin_parm", "start_bit_image", "start_char_set_def", "stop_bit_image",
"stop_char_set_def", "subscript_characters", "superscript_characters", "these_cause_cr",
"zero_motion", "char_set_names", "key_mouse", "mouse_info", "req_mouse_pos", "get_mouse",
"set_a_foreground", "set_a_background", "pkey_plab", "device_type", "code_set_init",
"set0_des_seq", "set1_des_seq", "set2_des_seq", "set3_des_seq", "set_lr_margin",
"set_tb_margin", "bit_image_repeat", "bit_image_newline", "bit_image_carriage_return",
"color_names", "define_bit_image_region", "end_bit_image_region", "set_color_band",
"set_page_length", "display_pc_char", "enter_pc_charset_mode", "exit_pc_charset_mode",
"enter_scancode_mode", "exit_scancode_mode", "pc_term_options", "scancode_escape",
"alt_scancode_esc", "enter_horizontal_hl_mode", "enter_left_hl_mode", "enter_low_hl_mode",
"enter_right_hl_mode", "enter_top_hl_mode", "enter_vertical_hl_mode", "set_a_attributes",
"set_pglen_inch", "termcap_init2", "termcap_reset", "linefeed_if_not_lf", "backspace_if_not_bs",
"other_non_function_keys", "arrow_key_map", "acs_ulcorner", "acs_llcorner", "acs_urcorner",
"acs_lrcorner", "acs_ltee", "acs_rtee", "acs_btee", "acs_ttee", "acs_hline", "acs_vline",
"acs_plus", "memory_lock", "memory_unlock", "box_chars_1"];
#[allow(missing_docs)]
pub static stringnames: &'static[&'static str] = &[ "cbt", "_", "cr", "csr", "tbc", "clear",
"_", "_", "hpa", "cmdch", "cup", "cud1", "home", "civis", "cub1", "mrcup", "cnorm", "cuf1",
"ll", "cuu1", "cvvis", "dch1", "dl1", "dsl", "hd", "smacs", "blink", "bold", "smcup", "smdc",
"dim", "smir", "invis", "prot", "rev", "smso", "smul", "ech", "rmacs", "sgr0", "rmcup", "rmdc",
"rmir", "rmso", "rmul", "flash", "ff", "fsl", "is1", "is2", "is3", "if", "ich1", "il1", "ip",
"kbs", "ktbc", "kclr", "kctab", "_", "_", "kcud1", "_", "_", "_", "_", "_", "_", "_", "_", "_",
"_", "_", "_", "_", "_", "khome", "_", "_", "kcub1", "_", "knp", "kpp", "kcuf1", "_", "_",
"khts", "_", "rmkx", "smkx", "_", "_", "_", "_", "_", "_", "_", "_", "_", "_", "_", "rmm", "_",
"_", "pad", "dch", "dl", "cud", "ich", "indn", "il", "cub", "cuf", "rin", "cuu", "pfkey",
"pfloc", "pfx", "mc0", "mc4", "_", "rep", "rs1", "rs2", "rs3", "rf", "rc", "vpa", "sc", "ind",
"ri", "sgr", "_", "wind", "_", "tsl", "uc", "hu", "iprog", "_", "_", "_", "_", "_", "mc5p",
"rmp", "acsc", "pln", "kcbt", "smxon", "rmxon", "smam", "rmam", "xonc", "xoffc", "_", "smln",
"rmln", "_", "kcan", "kclo", "kcmd", "kcpy", "kcrt", "_", "kent", "kext", "kfnd", "khlp",
"kmrk", "kmsg", "kmov", "knxt", "kopn", "kopt", "kprv", "kprt", "krdo", "kref", "krfr", "krpl",
"krst", "kres", "ksav", "kspd", "kund", "kBEG", "kCAN", "kCMD", "kCPY", "kCRT", "_", "_",
"kslt", "kEND", "kEOL", "kEXT", "kFND", "kHLP", "kHOM", "_", "kLFT", "kMSG", "kMOV", "kNXT",
"kOPT", "kPRV", "kPRT", "kRDO", "kRPL", "kRIT", "kRES", "kSAV", "kSPD", "kUND", "rfi", "_", "_",
"_", "_", "_", "_", "_", "_", "_", "_", "_", "_", "_", "_", "_", "_", "_", "_", "_", "_", "_",
"_", "_", "_", "_", "_", "_", "_", "_", "_", "_", "_", "_", "_", "_", "_", "_", "_", "_", "_",
"_", "_", "_", "_", "_", "_", "_", "_", "_", "_", "_", "_", "_", "_", "_", "_", "_", "_", "_",
"dclk", "rmclk", "cwin", "wingo", "_", "dial", "qdial", "_", "_", "hook", "pause", "wait", "_",
"_", "_", "_", "_", "_", "_", "_", "_", "_", "op", "oc", "initc", "initp", "scp", "setf",
"setb", "cpi", "lpi", "chr", "cvr", "defc", "swidm", "sdrfq", "sitm", "slm", "smicm", "snlq",
"snrmq", "sshm", "ssubm", "ssupm", "sum", "rwidm", "ritm", "rlm", "rmicm", "rshm", "rsubm",
"rsupm", "rum", "mhpa", "mcud1", "mcub1", "mcuf1", "mvpa", "mcuu1", "porder", "mcud", "mcub",
"mcuf", "mcuu", "scs", "smgb", "smgbp", "smglp", "smgrp", "smgt", "smgtp", "sbim", "scsd",
"rbim", "rcsd", "subcs", "supcs", "docr", "zerom", "csnm", "kmous", "minfo", "reqmp", "getm",
"setaf", "setab", "pfxl", "devt", "csin", "s0ds", "s1ds", "s2ds", "s3ds", "smglr", "smgtb",
"birep", "binel", "bicr", "colornm", "defbi", "endbi", "setcolor", "slines", "dispc", "smpch",
"rmpch", "smsc", "rmsc", "pctrm", "scesc", "scesa", "ehhlm", "elhlm", "elohlm", "erhlm",
"ethlm", "evhlm", "sgr1", "slength", "OTi2", "OTrs", "OTnl", "OTbs", "OTko", "OTma", "OTG2",
"OTG3", "OTG1", "OTG4", "OTGR", "OTGL", "OTGU", "OTGD", "OTGH", "OTGV", "OTGC", "meml", "memu",
"box1"];
/// Parse a compiled terminfo entry, using long capability names if `longnames` is true
pub fn parse(file: &mut Read, longnames: bool)
-> Result<Box<TermInfo>, String> {
macro_rules! try { ($e:expr) => (
match $e {
Ok(e) => e,
Err(e) => return Err(format!("{:?}", e))
}
) }
let bnames;
let snames;
let nnames;
if longnames {
bnames = boolfnames;
snames = stringfnames;
nnames = numfnames;
} else {
bnames = boolnames;
snames = stringnames;
nnames = numnames;
}
// Check magic number
let magic = try!(read_le_u16(file));
if magic != 0x011A {
return Err(format!("invalid magic number: expected {:x}, found {:x}",
0x011A_usize, magic as usize));
}
let names_bytes = try!(read_le_u16(file)) as isize;
let bools_bytes = try!(read_le_u16(file)) as isize;
let numbers_count = try!(read_le_u16(file)) as isize;
let string_offsets_count = try!(read_le_u16(file)) as isize;
let string_table_bytes = try!(read_le_u16(file)) as isize;
assert!(names_bytes > 0);
if (bools_bytes as usize) > boolnames.len() {
return Err("incompatible file: more booleans than \
expected".to_string());
}
if (numbers_count as usize) > numnames.len() {
return Err("incompatible file: more numbers than \
expected".to_string());
}
if (string_offsets_count as usize) > stringnames.len() {
return Err("incompatible file: more string offsets than \
expected".to_string());
}
// don't read NUL
let bytes = try!(read_exact(file, names_bytes as usize - 1));
let names_str = match String::from_utf8(bytes) {
Ok(s) => s,
Err(_) => return Err("input not utf-8".to_string()),
};
let term_names: Vec<String> = names_str.split('|')
.map(|s| s.to_string())
.collect();
try!(read_byte(file)); // consume NUL
let mut bools_map = HashMap::new();
if bools_bytes != 0 {
for i in 0..bools_bytes {
let b = try!(read_byte(file));
if b == 1 {
bools_map.insert(bnames[i as usize].to_string(), true);
}
}
}
if (bools_bytes + names_bytes) % 2 == 1 {
try!(read_byte(file)); // compensate for padding
}
let mut numbers_map = HashMap::new();
if numbers_count != 0 {
for i in 0..numbers_count {
let n = try!(read_le_u16(file));
if n != 0xFFFF {
numbers_map.insert(nnames[i as usize].to_string(), n);
}
}
}
let mut string_map = HashMap::new();
if string_offsets_count != 0 {
let mut string_offsets = Vec::with_capacity(10);
for _ in 0..string_offsets_count {
string_offsets.push(try!(read_le_u16(file)));
}
let string_table = try!(read_exact(file, string_table_bytes as usize));
if string_table.len() != string_table_bytes as usize {
return Err("error: hit EOF before end of string \
table".to_string());
}
for (i, v) in string_offsets.iter().enumerate() {
let offset = *v;
if offset == 0xFFFF { // non-entry
continue;
}
let name = if snames[i] == "_" {
stringfnames[i]
} else {
snames[i]
};
if offset == 0xFFFE {
// undocumented: FFFE indicates cap@, which means the capability is not present
// unsure if the handling for this is correct
string_map.insert(name.to_string(), Vec::new());
continue;
}
// Find the offset of the NUL we want to go to
let nulpos = string_table[offset as usize .. string_table_bytes as usize]
.iter().position(|&b| b == 0);
match nulpos {
Some(len) => {
string_map.insert(name.to_string(),
string_table[offset as usize ..
(offset as usize + len)].to_vec())
},
None => {
return Err("invalid file: missing NUL in \
string_table".to_string());
}
};
}
}
// And that's all there is to it
Ok(box TermInfo {
names: term_names,
bools: bools_map,
numbers: numbers_map,
strings: string_map
})
}
fn read_le_u16<R: Read + ?Sized>(r: &mut R) -> io::Result<u16> {
let mut b = [0; 2];
assert_eq!(try!(r.read(&mut b)), 2);
Ok((b[0] as u16) | ((b[1] as u16) << 8))
}
fn read_byte<R: Read + ?Sized>(r: &mut R) -> io::Result<u8> {
let mut b = [0; 1];
assert_eq!(try!(r.read(&mut b)), 1);
Ok(b[0])
}
fn read_exact<R: Read + ?Sized>(r: &mut R, sz: usize) -> io::Result<Vec<u8>> {
let mut v = Vec::with_capacity(sz);
try!(r.take(sz as u64).read_to_end(&mut v));
assert_eq!(v.len(), sz);
Ok(v)
}
/// Create a dummy TermInfo struct for msys terminals
pub fn msys_terminfo() -> Box<TermInfo> |
#[cfg(test)]
mod tests {
use super::{boolnames, boolfnames, numnames, numfnames, stringnames, stringfnames};
#[test]
fn test_veclens() {
assert_eq!(boolfnames.len(), boolnames.len());
assert_eq!(numfnames.len(), numnames.len());
assert_eq!(stringfnames.len(), stringnames.len());
}
}
| {
let mut strings = HashMap::new();
strings.insert("sgr0".to_string(), b"\x1B[0m".to_vec());
strings.insert("bold".to_string(), b"\x1B[1m".to_vec());
strings.insert("setaf".to_string(), b"\x1B[3%p1%dm".to_vec());
strings.insert("setab".to_string(), b"\x1B[4%p1%dm".to_vec());
box TermInfo {
names: vec!("cygwin".to_string()), // msys is a fork of an older cygwin version
bools: HashMap::new(),
numbers: HashMap::new(),
strings: strings
}
} |
war_print_class.py | '''
Copyright 2017, Fujitsu Network Communications, Inc.
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
'''
import sys
import re
"""
This class will trap stdout and redirects the message to logfile and stdout
It takes console_logfile and write_to_stdout ( boolean flag) as arguments.
!!! Important!!!
DO NOT import any modules from warrior/Framework package that uses
warrior/Framework/Utils/print_Utils.py at module level into this module
as it will lead to cyclic imports.
"""
def print_main(message, print_type, color_message=None, *args, **kwargs):
"""The main print function will be called by other print functions
"""
if color_message is not None:
print_string = print_type + " " + str(color_message)
elif color_message is None:
print_string = print_type + " " + str(message)
if len(args) > 0:
print_string = (print_type + " " + str(message) + str(args))
# set logging argument default to True, to write the message in the log file
if isinstance(sys.stdout, RedirectPrint):
sys.stdout.write((print_string + '\n'),
logging=kwargs.get('logging', True))
else:
sys.stdout.write(print_string + '\n')
sys.stdout.flush()
from Framework.Utils.testcase_Utils import TCOBJ
if TCOBJ.pnote is False:
TCOBJ.p_note_level(message, print_type)
return print_string
class RedirectPrint(object):
| """Class that has methods to redirect prints
from stdout to correct console log files """
def __init__(self, console_logfile):
"""Constructor"""
self.get_file(console_logfile)
# self.write_to_stdout = write_to_stdout
self.stdout = sys.stdout
def get_file(self, console_logfile):
"""If the console logfile is not None redirect sys.stdout to
console logfile
"""
self.file = console_logfile
if self.file is not None:
sys.stdout = self
def write(self, data, logging=True):
"""
- Writes data to the sys.stdout
- Writes data to log file only if the logging is True
- Removes the ansii escape chars before writing to file
"""
self.stdout.write(data)
ansi_escape = re.compile(r'\x1b[^m]*m')
data = ansi_escape.sub('', data)
# write to log file if logging is set to True
if logging is True:
self.file.write(data)
self.file.flush()
def isatty(self):
"""Check if sys.stdout is a tty """
# print self.stdout.isatty()
return self.stdout.isatty()
def flush(self):
"""flush logfile """
return self.stdout.flush() |
|
server.go | package rest
import (
"net/http"
"time"
"log"
"fmt"
"github.com/gorilla/handlers"
)
const default_port = "8080"
var startTime time.Time
func StartServer() {
startTime = time.Now().UTC()
// Get Cloud Foundry assigned port
port := default_port
if port == "" {
port = default_port
log.Println(fmt.Sprintf("Port number is not set using default: %s\n", port))
}
// get router object
router := getRouter()
// Start listening on the configured port.
// ListenAndServe is not expected to return, so we wrap it in a log.Fatal
// also include CORS handling
err:= http.ListenAndServe(":"+port, handlers.CORS()(router))
if(err != nil) |
}
| {
log.Fatal(err.Error())
} |
filters.py | """
This file is licensed under the terms of the Apache License, Version 2.0. See the LICENSE file in the root of this
repository for complete details.
"""
# -----------------------------------------------------------------------
# FILTER MANIFEST
# -----------------------------------------------------------------------
#
# --------------------- Simple Filters: -----------------------
# MarkEverythingContentFilter - Marks all blocks as content.
# InvertedFilter - Reverts the "is_content" flag for all TextBlocks
# BoilerplateBlockFilter - Removes TextBlocks which have explicitly been marked as "not content".
# MinWordsFilter - Keeps only those content blocks which contain at least k words.
# MinClauseWordsFilter - Keeps only blocks that have at least one segment fragment ("clause") with at least k words
# SplitParagraphBlocksFilter - Splits TextBlocks at paragraph boundaries
# SurroundingToContentFilter
# LabelToBoilerplateFilter - Marks all blocks that contain a given label as "boilerplate".
# LabelToContentFilter - Marks all blocks that contain a given label as "content".
#
# --------------------- Heuristic Filters: -----------------------
# SimpleBlockFusionProcessor - Merges two subsequent blocks if their text densities are equal.
# ContentFusion
# LabelFusion - Fuses adjacent blocks if their labels are equal.
# BlockProximityFusion - Fuses adjacent blocks if their distance (in blocks) does not exceed a certain limit.
# KeepLargestBlockFilter - Keeps the largest TextBlock only (by the number of words)
# ExpandTitleToContentFilter - Marks all TextBlocks "content" which are between the headline and the part that has
# already been marked content, if they are marked MIGHT_BE_CONTENT
# ArticleMetadataFilter
# AddPrecedingLabelsFilter - Adds the labels of the preceding block to the current block, optionally adding a prefix.
# DocumentTitleMatchClassifier - Marks TextBlocks which contain parts of the HTML TITLE tag
#
# --------------------- English-trained Heuristic Filters: -----------------------
# MinFulltextWordsFilter - Keeps only those content blocks which contain at least k full-text words
# KeepLargestFulltextBlockFilter - Keeps the largest TextBlock only (by the number of words)
# IgnoreBlocksAfterContentFilter - Marks all blocks as "non-content" that occur after blocks that have been marked
# INDICATES_END_OF_TEXT
# IgnoreBlocksAfterContentFromEndFilter - like above
# TerminatingBlocksFinder - Finds blocks which are potentially indicating the end of an article text and marks them with
# INDICATES_END_OF_TEXT
# NumWordsRulesClassifier - Classifies TextBlocks as content/not-content through rules that have been determined using
# the C4.8 machine learning algorithm
# DensityRulesClassifier - Classifies TextBlocks as content/not-content through rules that have been determined using
# the C4.8 machine learning algorithm
# CanolaFilter - A full-text extractor trained on krdwrd Canola
import re
from typing import List, Pattern, Union
from boilerpy3.document import DefaultLabels, TextBlock, TextDocument
class BoilerpipeFilter:
"""
Boilerpipe abstract interface
"""
def process(self, doc: TextDocument) -> bool:
pass
def subtract_blocks(self, block_arr: List[TextBlock], blocks_to_remove: List[TextBlock]) -> List[TextBlock]:
"""
inefficient but in place: for block in blocksToRemove: blockArr.remove(blocksToRemove) efficiently subtracts
second array from first assuming blocksToRemove shows up in the same order as blocArr
"""
if len(blocks_to_remove) == 0:
return block_arr
new_block_arr = []
remove_iter = iter(blocks_to_remove)
cur_block_to_remove = next(remove_iter)
for idx, block in enumerate(block_arr):
if block == cur_block_to_remove:
try:
cur_block_to_remove = next(remove_iter)
except StopIteration:
# add the rest
new_block_arr.extend(block_arr[idx + 1:])
break
else:
new_block_arr.append(block)
return new_block_arr
class FilterChain(BoilerpipeFilter):
"""
Chain together multiple filters in sequence
"""
def __init__(self, filter_arr: List[BoilerpipeFilter]) -> None:
super(FilterChain, self).__init__()
self.filter_arr = filter_arr
def process(self, doc: TextDocument) -> bool:
is_updated = False
for filtr in self.filter_arr:
is_updated |= filtr.process(doc)
return is_updated
# -----------------------------------------------------------------------
# SIMPLE FILTERS
# -----------------------------------------------------------------------
class MarkEverythingContentFilter(BoilerpipeFilter):
"""
Marks all blocks as content.
"""
def process(self, doc: TextDocument) -> bool:
changes = False
for tb in doc.text_blocks:
if not tb.is_content:
tb.is_content = True
changes = True
return changes
class InvertedFilter(BoilerpipeFilter):
"""
Reverts the "is_content" flag for all TextBlocks
"""
def process(self, doc: TextDocument) -> bool:
tbs = doc.text_blocks
if len(tbs) == 0:
return False
for tb in tbs:
tb.is_content = not tb.is_content
return True
class BoilerplateBlockFilter(BoilerpipeFilter):
"""
Removes TextBlocks which have explicitly been marked as "not content".
"""
def process(self, doc: TextDocument) -> bool:
text_blocks = doc.text_blocks
new_blocks = [tb for tb in text_blocks if tb.is_content]
has_changes = len(new_blocks) < len(text_blocks)
doc.text_blocks = new_blocks
return has_changes
class MinWordsFilter(BoilerpipeFilter):
"""
Keeps only those content blocks which contain at least <em>k</em> words.
"""
def __init__(self, min_words: int) -> None:
super(MinWordsFilter, self).__init__()
self.min_words = min_words
def process(self, doc: TextDocument) -> bool:
changes = False
for tb in doc.text_blocks:
if not tb.is_content:
continue
if tb.num_words < self.min_words:
tb.is_content = False
changes = True
return changes
class MinClauseWordsFilter(BoilerpipeFilter):
"""
Keeps only blocks that have at least one segment fragment ("clause") with at least <em>k</em> words (default: 5).
NOTE: You might consider using the SplitParagraphBlocksFilter
upstream.
See SplitParagraphBlocksFilter
"""
PAT_CLAUSE_DELIMITER = re.compile(r"\b[,.:;!?]+(?:\s+|\Z)", re.UNICODE)
PAT_WHITESPACE = re.compile(r"\s+")
def __init__(self, min_words: int = 5, accept_clauses_without_delimiter: bool = False) -> None:
super(MinClauseWordsFilter, self).__init__()
self.min_words = min_words
self.accept_clauses_without_delimiter = accept_clauses_without_delimiter
def process(self, doc: TextDocument) -> bool:
changes = False
for tb in doc.text_blocks:
if not tb.is_content:
continue
has_clause = False
possible_clause_arr = self.PAT_CLAUSE_DELIMITER.split(tb.text)
for possible_clause in possible_clause_arr[:-1]:
has_clause = self.is_clause_accepted(possible_clause)
if has_clause:
break
# since clauses should *always end* with a delimiter, we normally don't consider text without one
if self.accept_clauses_without_delimiter:
has_clause |= self.is_clause_accepted(possible_clause_arr[-1])
if not has_clause:
tb.is_content = False
changes = True
return changes
def is_clause_accepted(self, text: str):
n = 1
for _ in self.PAT_WHITESPACE.finditer(text):
n += 1
if n >= self.min_words:
return True
return n >= self.min_words
class SplitParagraphBlocksFilter(BoilerpipeFilter):
"""
Splits TextBlocks at paragraph boundaries.
NOTE: This is not fully supported (i.e., it will break highlighting support via #getContainedTextElements()), but
this one probably is necessary for some other filters.
See MinClauseWordsFilter
"""
NEWLINE_REGEX = re.compile(r"[\n\r]+")
def process(self, doc: TextDocument) -> bool:
changes = False
blocks = doc.text_blocks
blocks_new = []
for tb in blocks:
text = tb.text
paragraphs = self.NEWLINE_REGEX.split(text)
if len(paragraphs) < 2:
blocks_new.append(tb)
continue
is_content = tb.is_content
labels = tb.labels
for p in paragraphs:
tb_p = TextBlock(p)
tb_p.is_content = is_content
tb_p.add_labels(labels)
blocks_new.append(tb_p)
changes = True
if changes:
doc.text_blocks = blocks_new
return changes
class SurroundingToContentFilter(BoilerpipeFilter):
def __init__(self, condition: callable = lambda tb: tb.linkDensity == 0 and tb.num_words > 6) -> None:
"""
this is now default when no arguments are passed
INSTANCE_TEXT = SurroundingToContentFilter(TextBlockCondition())
ctor - condition is an function for an additional condition to determine if it can be made content
"""
super(SurroundingToContentFilter, self).__init__()
self.cond = condition
def process(self, doc: TextDocument) -> bool:
tbs = doc.text_blocks
n = len(tbs)
has_changes = False
i = 1
while i < n - 1:
prev_block = tbs[i - 1]
cur_block = tbs[i]
next_block = tbs[i + 1]
if not cur_block.is_content and prev_block.is_content and next_block.is_content and self.cond(cur_block):
cur_block.is_content = True
has_changes = True
i += 2
else:
# WARNING: POSSIBLE BUG - in original i+=2 regardless of whether content is found. this seems illogical
# to me - should be +=1
i += 1
return has_changes
class LabelToBoilerplateFilter(BoilerpipeFilter):
"""
Marks all blocks that contain a given label as "boilerplate".
INSTANCE_STRICTLY_NOT_CONTENT = LabelToBoilerplateFilter(DefaultLabels.STRICTLY_NOT_CONTENT)
"""
def __init__(self, *labels: str) -> None:
super(LabelToBoilerplateFilter, self).__init__()
self.labels = labels
def process(self, doc: TextDocument) -> bool:
changes = False
for tb in doc.text_blocks:
if tb.is_content and any(tb.has_label(label) for label in self.labels):
tb.is_content = False
changes = True
return changes
class LabelToContentFilter(BoilerpipeFilter):
"""
Marks all blocks that contain a given label as "content".
"""
def __init__(self, *labels: str) -> None:
super(LabelToContentFilter, self).__init__()
self.labels = labels
def process(self, doc: TextDocument) -> bool:
changes = False
for tb in doc.text_blocks:
if not tb.is_content and any(tb.has_label(label) for label in self.labels):
tb.is_content = True
changes = True
return changes
# -----------------------------------------------------------------------
# GENERIC HEURISTIC FILTERS
# -----------------------------------------------------------------------
class SimpleBlockFusionProcessor(BoilerpipeFilter):
"""
Merges two subsequent blocks if their text densities are equal.
"""
def process(self, doc: TextDocument) -> bool:
text_blocks = doc.text_blocks
changes = False
if len(text_blocks) < 2:
return False
prev_block = text_blocks[0]
blocks_to_remove = []
for block in text_blocks[1:]:
if prev_block.text_density == block.text_density:
prev_block.merge_next(block)
blocks_to_remove.append(block)
changes = True
else:
prev_block = block
if changes:
doc.text_blocks = self.subtract_blocks(text_blocks, blocks_to_remove)
return changes
class ContentFusion(BoilerpipeFilter):
def process(self, doc: TextDocument) -> bool:
text_blocks = doc.text_blocks
if len(text_blocks) < 2:
return False
# WARNING: POSSIBLE BUG FOUND: shouldn't prev_block be reset every passthrough?
changes = False
# if it has been changed on the previous passthrough
changed_on_pass = True
while changed_on_pass:
changed_on_pass = False
prev_block = text_blocks[0]
blocks_to_remove = []
for block in text_blocks[1:]:
if prev_block.is_content and block.link_density < 0.56 \
and not block.has_label(DefaultLabels.STRICTLY_NOT_CONTENT):
prev_block.merge_next(block)
blocks_to_remove.append(block)
changed_on_pass = True
changes = True
else:
prev_block = block
text_blocks = self.subtract_blocks(text_blocks, blocks_to_remove)
if changes:
doc.text_blocks = text_blocks
return changes
class LabelFusion(BoilerpipeFilter):
"""
Fuses adjacent blocks if their labels are equal.
"""
def __init__(self, label_prefix: str = "") -> None:
"""
Creates a new LabelFusion instance.
:param label_prefix: The maximum distance in blocks.
"""
super(LabelFusion, self).__init__()
self.label_prefix = label_prefix
def process(self, doc: TextDocument) -> bool:
text_blocks = doc.text_blocks
if len(text_blocks) < 2:
return False
changes = False
prev_block = text_blocks[0]
blocks_to_remove = []
for block in text_blocks[1::]:
if self.equal_labels(prev_block.labels, block.labels):
prev_block.merge_next(block)
blocks_to_remove.append(block)
changes = True
else:
prev_block = block
if changes:
doc.text_blocks = self.subtract_blocks(text_blocks, blocks_to_remove)
return changes
def equal_labels(self, labels1: List[str], labels2: List[str]) -> bool:
if labels1 is None or labels2 is None:
return False
# NOTE: Should blocks be merged if neither of them have labels??? i.e. labels1==labels2==empty set
return self.markup_labels_only(labels1) == self.markup_labels_only(labels2)
def markup_labels_only(self, labels: List[str]) -> set:
return {label for label in labels if label.startswith(DefaultLabels.MARKUP_PREFIX)}
class BlockProximityFusion(BoilerpipeFilter):
"""
Fuses adjacent blocks if their distance (in blocks) does not exceed a certain limit. This probably makes sense only
in cases where an upstream filter already has removed some blocks.
MAX_DISTANCE_1 = BlockProximityFusion(1, False, False)
MAX_DISTANCE_1_SAME_TAGLEVEL = BlockProximityFusion(1, False, True)
MAX_DISTANCE_1_CONTENT_ONLY = BlockProximityFusion(1, True, False)
MAX_DISTANCE_1_CONTENT_ONLY_SAME_TAGLEVEL = BlockProximityFusion(1, True, True)
"""
def __init__(self, max_blocks_distance: int = 1, content_only: bool = False,
same_tag_level_only: bool = False) -> None:
"""
Creates a new BlockProximityFusion instance.
:param max_blocks_distance: The maximum distance in blocks.
:param content_only:
:param same_tag_level_only:
"""
super(BlockProximityFusion, self).__init__()
self.max_blocks_distance = max_blocks_distance
self.content_only = content_only
self.same_tag_level_only = same_tag_level_only
def process(self, doc: TextDocument) -> bool:
text_blocks = doc.text_blocks
if len(text_blocks) < 2:
return False
changes = False
if self.content_only:
start_idx = None
for idx, block in enumerate(text_blocks):
if block.is_content:
start_idx = idx
break
if start_idx is None:
return False
else:
start_idx = 0
prev_block = text_blocks[start_idx]
blocks_to_remove = []
for block in text_blocks[start_idx + 1:]:
if not block.is_content:
prev_block = block
continue
diff_blocks = block.offset_blocks_start - prev_block.offset_blocks_end - 1
if diff_blocks <= self.max_blocks_distance:
ok = True
if self.content_only:
if not prev_block.is_content or not block.is_content:
ok = False
if self.same_tag_level_only and prev_block.tag_level != block.tag_level:
ok = False
if ok:
prev_block.merge_next(block)
# remove current block
blocks_to_remove.append(block)
changes = True
else:
prev_block = block
else:
prev_block = block
if len(blocks_to_remove) > 0:
doc.text_blocks = self.subtract_blocks(text_blocks, blocks_to_remove)
changes = True
return changes
class KeepLargestBlockFilter(BoilerpipeFilter):
"""
Keeps the largest TextBlock only (by the number of words). In case of more than one block with the same
number of words, the first block is chosen. All discarded blocks are marked "not content" and flagged as
DefaultLabels.
Note that, by default, only TextBlocks marked as "content" are taken into consideration.
INSTANCE = KeepLargestBlockFilter(False)
INSTANCE_EXPAND_TO_SAME_TAGLEVEL = KeepLargestBlockFilter(True)
"""
def __init__(self, expand_to_same_level_text: bool = False) -> None:
super(KeepLargestBlockFilter, self).__init__()
self.expand_to_same_level_text = expand_to_same_level_text
def process(self, doc: TextDocument) -> bool:
text_blocks = doc.text_blocks
if len(text_blocks) < 2:
return False
try:
largest_block = max((tb for tb in text_blocks if tb.is_content), key=lambda tb: tb.num_words)
except ValueError:
# no content blocks exist / largest block not found
largest_block = None
for tb in text_blocks:
if tb == largest_block:
tb.is_content = True
else:
tb.is_content = False
tb.add_label(DefaultLabels.MIGHT_BE_CONTENT)
if self.expand_to_same_level_text and largest_block is not None:
level = largest_block.tag_level
largest_block_idx = text_blocks.index(largest_block)
for tb in text_blocks[largest_block_idx::-1]:
tl = tb.tag_level
if tl < level:
break
elif tl == level:
tb.is_content = True
for tb in text_blocks[largest_block_idx:]:
tl = tb.tag_level
if tl < level:
break
elif tl == level:
tb.is_content = True
return True
class ExpandTitleToContentFilter(BoilerpipeFilter):
"""
Marks all TextBlocks "content" which are between the headline and the part that has already been marked
content, if they are marked DefaultLabels#MIGHT_BE_CONTENT.
This filter is quite specific to the news domain.
"""
def process(self, doc: TextDocument) -> bool:
i = 0
title_idx = -1
content_start = -1
for tb in doc.text_blocks:
if content_start == -1 and tb.has_label(DefaultLabels.TITLE):
title_idx = i
if content_start == -1 and tb.is_content:
content_start = i
i += 1
if content_start <= title_idx or title_idx == -1:
return False
changes = False
for tb in doc.text_blocks[title_idx:content_start]:
if tb.has_label(DefaultLabels.MIGHT_BE_CONTENT):
if tb.is_content is not True:
tb.is_content = True
changes = True
return changes
class ArticleMetadataFilter(BoilerpipeFilter):
# checks for date/time/author blocks
PATTERNS_SHORT = [
re.compile(r"^[0-9 ,./]*\b(?:Jan|Feb|Mar|Apr|May|Jun|Jul|Aug|Sep|Oct|Nov|Dec|January|February|March|April|June|"
r"July|August|September|October|November|December)?\b[0-9 ,:apm./]*(?:[CPSDMGET]{2,3})?$"),
re.compile("^[Bb]y ")
]
def process(self, doc: TextDocument) -> bool:
changed = False
for tb in doc.text_blocks:
if tb.num_words > 10:
continue
for p in self.PATTERNS_SHORT:
text = tb.text
if p.search(text):
changed = True
tb.is_content = True
tb.add_label(DefaultLabels.ARTICLE_METADATA)
break
return changed
class AddPrecedingLabelsFilter(BoilerpipeFilter):
"""
Adds the labels of the preceding block to the current block, optionally adding a prefix.
"""
def __init__(self, label_prefix: str = "") -> None:
"""
Creates a new AddPrecedingLabelsFilter instance.
INSTANCE = AddPrecedingLabelsFilter("")
INSTANCE_PRE = AddPrecedingLabelsFilter("^")
"""
super(AddPrecedingLabelsFilter, self).__init__()
self.label_prefix = label_prefix
def process(self, doc: TextDocument) -> bool:
text_blocks = doc.text_blocks
if len(text_blocks) < 2:
return False
changes = False
block_below = None
for block in text_blocks[::-1]:
if block_below is not None:
labels = block.labels
if labels is not None and len(labels) > 0:
for l in labels:
block_below.add_label(self.label_prefix + l)
changes = True
block_below = block
return changes
class DocumentTitleMatchClassifier(BoilerpipeFilter):
"""
Marks TextBlocks which contain parts of the HTML <code><TITLE></code> tag, using some heuristics which
are quite specific to the news domain.
"""
TITLE_REGEXES = [
re.compile(r"[ ]*[|:][ ]*"),
re.compile(r"[ ]*[|:()][ ]*"),
re.compile(r"[ ]*[|:()\-][ ]*"),
re.compile(r"[ ]*[|,:()\-][ ]*")
]
WORD_REGEX = re.compile(r"\w+", re.UNICODE)
def __init__(self, title: Union[str, None], use_doc_title: bool = False) -> None:
super(DocumentTitleMatchClassifier, self).__init__()
self.use_doc_title = use_doc_title
if use_doc_title:
self.potential_titles = None
else:
self.potential_titles = self.find_potential_titles(title)
def find_potential_titles(self, title: str):
if title is None:
return None
title = title.strip()
if len(title) == 0:
return None
else:
potential_titles = set()
potential_titles.add(title)
for regex in self.TITLE_REGEXES:
p = self.get_longest_part(title, regex)
if p is not None:
potential_titles.add(p)
return potential_titles
def get_longest_part(self, title: str, pattern: Pattern):
parts = pattern.split(title)
if len(parts) == 1:
return None
longest_num_words = 0
longest_part = ""
for p in parts:
if ".com" in p:
continue
num_words = self.get_num_words(p)
if num_words > longest_num_words or len(p) > len(longest_part):
longest_num_words = num_words
longest_part = p
if len(longest_part) == 0:
return None
else:
return longest_part.strip()
def get_num_words(self, text: str):
return len(self.WORD_REGEX.findall(text))
def process(self, doc: TextDocument) -> bool:
if self.use_doc_title:
self.potential_titles = self.find_potential_titles(doc.title)
if self.potential_titles is None:
return False
changes = False
for tb in doc.text_blocks:
text = tb.text.strip().lower()
if any(candidate.lower() == text for candidate in self.potential_titles):
tb.add_label(DefaultLabels.TITLE)
changes = True
return changes
# -----------------------------------------------------------------------
# ENGLISH HEURISTIC FILTERS
# -----------------------------------------------------------------------
# --- Heuristic Filters that have been trained on English laguage text
class HeuristicFilterBase(BoilerpipeFilter):
"""
Base class for some heuristics that are used by boilerpipe filters.
"""
def get_num_full_text_words(self, tb: TextBlock, min_text_density: int = 9):
if tb.text_density >= min_text_density:
return tb.num_words
else:
return 0
class MinFulltextWordsFilter(HeuristicFilterBase):
"""
Keeps only those content blocks which contain at least k full-text words (measured by
HeuristicFilterBase#get_num_full_text_words(TextBlock). k is 30 by default.
"""
def __init__(self, min_words: int = 30) -> None:
self.min_words = min_words
def process(self, doc: TextDocument) -> bool:
changes = False
for tb in doc.text_blocks:
if tb.is_content and self.get_num_full_text_words(tb) < self.min_words:
tb.is_content = False
changes = True
return changes
class KeepLargestFulltextBlockFilter(HeuristicFilterBase):
"""
Keeps the largest TextBlock only (by the number of words). In case of more than one block with the same
number of words, the first block is chosen. All discarded blocks are marked "not content" and flagged as
DefaultLabels. As opposed to KeepLargestBlockFilter, the number of words are computed using HeuristicFilterBase
get_num_full_text_words(TextBlock), which only counts words that occur in text elements with at least 9 words and
are thus believed to be full text.
NOTE: Without language-specific fine-tuning (i.e., running the default instance), this filter may lead to suboptimal
results. You better use KeepLargestBlockFilter instead, which works at the level of number-of-words instead
of text densities.
"""
def process(self, doc: TextDocument) -> bool:
text_blocks = doc.text_blocks
if len(text_blocks) < 2:
return False
content_blocks = [block for block in text_blocks if block.is_content]
if len(content_blocks) == 0:
return False
largest_block = max(content_blocks, key=self.get_num_full_text_words)
for tb in text_blocks:
if tb == largest_block:
tb.is_content = True
else:
tb.is_content = False
tb.add_label(DefaultLabels.MIGHT_BE_CONTENT)
return True
class IgnoreBlocksAfterContentFilter(HeuristicFilterBase):
"""
Marks all blocks as "non-content" that occur after blocks that have been marked DefaultLabels#INDICATES_END_OF_TEXT.
These marks are ignored unless a minimum number of words in content blocks occur before this mark (default: 60).
This can be used in conjunction with an upstream TerminatingBlocksFinder.
"""
def __init__(self, min_num_words: int = 60) -> None:
"""
DEFAULT_INSTANCE = IgnoreBlocksAfterContentFilter(60)
INSTANCE_200 = IgnoreBlocksAfterContentFilter(200)
"""
self.min_num_words = min_num_words
def process(self, doc: TextDocument) -> bool:
changes = False
num_words = 0
found_end_of_text = False
for block in doc.text_blocks:
if block.is_content:
num_words += self.get_num_full_text_words(block)
if block.has_label(DefaultLabels.INDICATES_END_OF_TEXT) and num_words >= self.min_num_words:
found_end_of_text = True
if found_end_of_text:
changes = True
block.is_content = False
return changes
class IgnoreBlocksAfterContentFromEndFilter(HeuristicFilterBase):
"""
Marks all blocks as "non-content" that occur after blocks that have been marked DefaultLabels#INDICATES_END_OF_TEXT,
and after any content block. This filter can be used in conjunction with an upstream TerminatingBlocksFinder.
See TerminatingBlocksFinder
"""
def process(self, doc: TextDocument) -> bool:
changes = False
words = 0
blocks = doc.text_blocks
if len(blocks) == 0:
return False
for tb in blocks[::-1]:
if tb.has_label(DefaultLabels.INDICATES_END_OF_TEXT):
tb.add_label(DefaultLabels.STRICTLY_NOT_CONTENT)
tb.remove_label(DefaultLabels.MIGHT_BE_CONTENT)
tb.is_content = False
changes = True
elif tb.is_content:
words += tb.num_words
if words > 200:
break
return changes
class TerminatingBlocksFinder(BoilerpipeFilter):
"""
Finds blocks which are potentially indicating the end of an article text and marks them with
DefaultLabels#INDICATES_END_OF_TEXT. This can be used in conjunction with a downstream
IgnoreBlocksAfterContentFilter.
"""
DIGIT_REGEX = re.compile(r'\D')
def process(self, doc: TextDocument) -> bool:
changes = False
for tb in doc.text_blocks:
if tb.num_words >= 15:
continue
text = tb.text.strip()
if len(text) < 8:
continue
text_lc = text.lower()
startmatches = (" reuters", "please rate this", "post a comment")
inmatches = ("what you think...", "add your comment", "add comment", "reader views", "have your say",
"reader comments", "rtta artikeln")
eqmatch = "thanks for your comments - this feedback is now closed"
if text_lc.startswith("comments") or self.starts_with_number(text_lc, " comments", " users responded in") \
or any(text_lc.startswith(match_str) for match_str in startmatches) \
or any(match_str in text_lc for match_str in inmatches) or text_lc == eqmatch:
tb.add_label(DefaultLabels.INDICATES_END_OF_TEXT)
changes = True
return changes
def starts_with_number(self, text: str, *match_str_arr: str):
"""
Checks whether the given text t starts with a sequence of digits, followed by one of the given strings.
:param text: The text to examine
:param match_str_arr: Any strings that may follow the digits.
:return: true if at least one combination matches
"""
number_match = self.DIGIT_REGEX.search(text)
if number_match is None:
pos = len(text)
else:
pos = number_match.start()
if pos == 0:
return False
else:
return any(text.startswith(match_str, pos) for match_str in match_str_arr)
class NumWordsRulesClassifier(BoilerpipeFilter):
"""
Classifies TextBlocks as content/not-content through rules that have been determined using the C4.8 machine
learning algorithm, as described in the paper "Boilerplate Detection using Shallow Text Features" (WSDM 2010),
particularly using number of words per block and link density per block.
"""
def process(self, doc: TextDocument) -> bool:
text_blocks = doc.text_blocks
has_changes = False
n = len(text_blocks)
for i, currentBlock in enumerate(text_blocks):
if i > 0:
prev_block = text_blocks[i - 1]
else:
prev_block = TextBlock.EMPTY_START
if i + 1 < n:
next_block = text_blocks[i + 1]
else:
next_block = TextBlock.EMPTY_START
has_changes |= self.classify(prev_block, currentBlock, next_block)
return has_changes
def classify(self, prev_block: TextBlock, curr_block: TextBlock, next_block: TextBlock):
if curr_block.link_density <= 0.333333:
if prev_block.link_density <= 0.555556:
if curr_block.num_words <= 16:
if next_block.num_words <= 15:
if prev_block.num_words <= 4:
is_content = False
else:
is_content = True
else:
is_content = True
else:
is_content = True
else:
if curr_block.num_words <= 40:
if next_block.num_words <= 17:
is_content = False
else:
is_content = True
else:
is_content = True
else:
is_content = False
changes = curr_block.is_content is is_content
curr_block.is_content = is_content
return changes
class DensityRulesClassifier(BoilerpipeFilter):
"""
Classifies TextBlocks as content/not-content through rules that have been determined using the C4.8 machine learning
algorithm, as described in the paper "Boilerplate Detection using Shallow Text Features", particularly using text
densities and link densities.
"""
def process(self, doc: TextDocument) -> bool:
text_blocks = doc.text_blocks
has_changes = False
n = len(text_blocks)
for i, current_block in enumerate(text_blocks):
if i > 0:
prev_block = text_blocks[i - 1]
else:
prev_block = TextBlock.EMPTY_START
if i + 1 < n:
next_block = text_blocks[i + 1]
else:
next_block = TextBlock.EMPTY_START
has_changes |= self.classify(prev_block, current_block, next_block)
return has_changes
def classify(self, prev_block: TextBlock, curr_block: TextBlock, next_block: TextBlock):
if curr_block.link_density <= 0.333333:
if prev_block.link_density <= 0.555556:
if curr_block.text_density <= 9:
if next_block.text_density <= 10:
if prev_block.text_density <= 4:
is_content = False
else:
is_content = True
else:
is_content = True
else:
if next_block.text_density == 0:
is_content = False
else:
is_content = True
else:
if next_block.text_density <= 11:
is_content = False
else:
is_content = True
else:
is_content = False
changes = curr_block.is_content is is_content
curr_block.is_content = is_content
return changes
class CanolaFilter(BoilerpipeFilter):
"""
A full-text extractor trained on http://krdwrd.org/,
https://krdwrd.org/trac/attachment/wiki/Corpora/Canola/CANOLA.pdf. Works well with SimpleEstimator, too.
"""
def process(self, doc: TextDocument) -> bool:
text_blocks = doc.text_blocks
has_changes = False
n = len(text_blocks)
for i, current_block in enumerate(text_blocks):
if i > 0:
prev_block = text_blocks[i - 1]
else:
prev_block = TextBlock.EMPTY_START
if i + 1 < n:
next_block = text_blocks[i + 1]
else:
next_block = TextBlock.EMPTY_START
has_changes |= self.classify(prev_block, current_block, next_block)
return has_changes
def classify(self, prev_block: TextBlock, curr_block: TextBlock, next_block: TextBlock):
cond1 = curr_block.link_density > 0 and next_block.num_words > 11
cond2 = curr_block.num_words > 19
cond3 = next_block.num_words > 6 and next_block.link_density == 0 and prev_block.link_density == 0 and \
(curr_block.num_words > 6 or prev_block.num_words > 7 or next_block.num_words > 19)
is_content = cond1 or cond2 or cond3
changes = curr_block.is_content is is_content
curr_block.is_content = is_content
| return changes |
|
uploadRoutes.ts | import path from 'path';
import express from 'express';
import multer from 'multer';
const router = express.Router();
const storage = multer.diskStorage({
destination(req, file, cb) {
cb(null, 'uploads/');
},
filename(req, file, cb) {
cb(null, `${file.fieldname}-${Date.now()}${path.extname(file.originalname)}`);
},
});
|
if (extname && mimetype) {
return cb(null, true);
} else {
cb(Error('Images only!'));
}
}
const upload = multer({
storage,
fileFilter: function (req, file, cb) {
checkFileType(file, cb);
},
});
router.post('/', upload.single('image'), (req, res) => {
res.send(`/${req.file.path}`);
});
export default router; | function checkFileType(file: Express.Multer.File, cb: multer.FileFilterCallback) {
const filetypes = /jpg|jpeg|png/;
const extname = filetypes.test(path.extname(file.originalname).toLowerCase());
const mimetype = filetypes.test(file.mimetype); |
Interval.py | # automatically generated by the FlatBuffers compiler, do not modify
# namespace: flatbuf
import flatbuffers
class Interval(object):
__slots__ = ['_tab']
@classmethod
def GetRootAsInterval(cls, buf, offset):
n = flatbuffers.encode.Get(flatbuffers.packer.uoffset, buf, offset)
x = Interval()
x.Init(buf, n + offset)
return x
# Interval
def Init(self, buf, pos):
self._tab = flatbuffers.table.Table(buf, pos)
# Interval
def Unit(self):
o = flatbuffers.number_types.UOffsetTFlags.py_type(self._tab.Offset(4))
if o != 0:
return self._tab.Get(flatbuffers.number_types.Int16Flags, o + self._tab.Pos)
return 0
def | (builder): builder.StartObject(1)
def IntervalAddUnit(builder, unit): builder.PrependInt16Slot(0, unit, 0)
def IntervalEnd(builder): return builder.EndObject()
| IntervalStart |
handler.rs | use discord::{ChannelRef, State, Connection};
use discord::model::{Event};
use ansi_term::Colour;
pub fn | (connection: &mut Connection, state: &mut State) {
loop {
let event = match connection.recv_event() {
Ok(event) => event,
Err(error) => {
println!("{} Receive error: {:?}.", Colour::Red.paint("error"), error);
continue
}
};
state.update(&event);
match event {
Event::MessageCreate(message) => {
match state.find_channel(message.channel_id) {
Some(ChannelRef::Public(server, channel)) => {
println!("{} {} {} {}",
Colour::RGB(212,93,121).paint(format!("{}", if message.author.id == state.user().id {"→"} else {"←"})),
Colour::RGB(234,144,133).paint(format!("{}", server.name)),
Colour::RGB(110,87,115).paint(format!("#{}", channel.name)),
Colour::RGB(212,93,121).paint(format!("@{}", message.author.name))
);
println!("{}", Colour::RGB(233,226,208).paint(format!("↳ {}", message.content)));
},
Some(ChannelRef::Group(group)) => {
println!("{} {} {}",
Colour::RGB(212,93,121).paint(format!("{}", if message.author.id == state.user().id {"→"} else {"←"})),
Colour::RGB(234,144,133).paint(format!("{}", group.name())),
Colour::RGB(212,93,121).paint(format!("@{}", message.author.name))
);
println!("{}", Colour::RGB(233,226,208).paint(format!("↳ {}", message.content)));
},
Some(ChannelRef::Private(channel)) => {
println!("{} {} {}",
Colour::RGB(234,144,133).paint(format!("@{}", state.user().username)),
Colour::RGB(212,93,121).paint(format!("{}", if message.author.id == channel.recipient.id {"←"} else {"→"})),
Colour::RGB(234,144,133).paint(format!("@{}", channel.recipient.name))
);
println!("{}", Colour::RGB(233,226,208).paint(format!("↳ {}", message.content)));
},
None => {}
}
},
_ => {}
}
}
} | handle_events |
mean_elliptical_slice.py | import torch
from .elliptical_slice import EllipticalSliceSampler
class MeanEllipticalSliceSampler(EllipticalSliceSampler):
def __init__(self, f_init, dist, lnpdf, nsamples, pdf_params=()):
|
def run(self):
self.f_sampled, self.ell = super().run()
#add means back into f_sampled
self.f_sampled = self.f_sampled + self.mean_vector.unsqueeze(1)
return self.f_sampled, self.ell | """
Implementation of elliptical slice sampling (Murray, Adams, & Mckay, 2010).
f_init: initial value of `f`
dist: multivariate normal to sample from to sample from
lnpdf: likelihood function
n_samples: number of samples
pdf_params: callable arguments for lnpdf
"""
mean_vector = dist.mean
demeaned_lnpdf = lambda g: lnpdf(g + mean_vector, *pdf_params)
demeaned_init = f_init - mean_vector
samples = dist.sample(sample_shape = torch.Size((nsamples,))).transpose(-1, -2)
demeaned_samples = samples - mean_vector.unsqueeze(1)
super(MeanEllipticalSliceSampler, self).__init__(demeaned_init, demeaned_samples, demeaned_lnpdf, nsamples, pdf_params=())
self.mean_vector = mean_vector |
catala_en.py | from pygments.lexer import RegexLexer, bygroups
from pygments.token import *
import re
__all__ = ['CatalaEnLexer']
class | (RegexLexer):
name = 'CatalaEn'
aliases = ['catala_en']
filenames = ['*.catala_en']
flags = re.MULTILINE | re.UNICODE
tokens = {
'root': [
(u'(@@)', bygroups(Generic.Heading), 'main__1'),
(u'(@)', bygroups(Generic.Heading), 'main__2'),
(u'([^\\/\\n\\r])', bygroups(Text)),
(u'(\\/\\*)', bygroups(Text), 'code'),
('(\n|\r|\r\n)', Text),
('.', Text),
],
'code': [
(u'(\\*\\/)', bygroups(Text), 'root'),
(u'(\\s*\\#.*$)', bygroups(Comment.Single)),
(u'(context)(\\s+)([a-z\xe9\xe8\xe0\xe2\xf9\xee\xea\u0153\xe7][a-z\xe9\xe8\xe0\xe2\xf9\xee\xea\u0153\xe7A-Z\xc9\xc8\xc0\xc2\xd9\xce\xca\u0152\xc70-9_\\\']*)',
bygroups(Keyword.Declaration, Text, Name.Variable)),
(u'\\b(match|with\\s+pattern|fixed|by|decreasing|increasing|varies|with|we\\s+have|in|such\\s+that|exists|for|all|of|if|then|else|initial)\\b', bygroups(Keyword.Reserved)),
(u'\\b(scope|depends\\s+on|declaration|includes|collection|content|optional|structure|enumeration|context|rule|under\\s+condition|condition|data|consequence|fulfilled|equals|assertion|definition|label|exception)\\b', bygroups(Keyword.Declaration)),
(u'(\\|[0-9]+/[0-9]+/[0-9]+\\|)', bygroups(Number.Integer)),
(u'\\b(true|false)\\b', bygroups(Keyword.Constant)),
(u'\\b([0-9]+(,[0.9]*|))\\b', bygroups(Number.Integer)),
(u'(\\-\\-|\\;|\\.|\\,|\\:|\\(|\\)|\\[|\\]|\\{|\\})', bygroups(
Operator)),
(u'(\\-\\>|\\+\\.|\\+\\@|\\+\\^|\\+\\$|\\+|\\-\\.|\\-\\@|\\-\\^|\\-\\$|\\-|\\*\\.|\\*\\@|\\*\\^|\\*\\$|\\*|/\\.|/\\@|/\\^|/\\$|/|\\!|>\\.|>=\\.|<=\\.|<\\.|>\\@|>=\\@|<=\\@|<\\@|>\\$|>=\\$|<=\\$|<\\$|>\\^|>=\\^|<=\\^|<\\^|>|>=|<=|<|=|not|or|and|\\$|%|year|month|day)', bygroups(Operator)),
(u'\\b(integer|boolean|date|money|text|decimal|number|sum)\\b',
bygroups(Keyword.Type)),
(u'\\b([A-Z\xc9\xc8\xc0\xc2\xd9\xce\xca\u0152\xc7][a-z\xe9\xe8\xe0\xe2\xf9\xee\xea\u0153\xe7A-Z\xc9\xc8\xc0\xc2\xd9\xce\xca\u0152\xc70-9_\\\']*)(\\.)([a-z\xe9\xe8\xe0\xe2\xf9\xee\xea\u0153\xe7][a-z\xe9\xe8\xe0\xe2\xf9\xee\xea\u0153\xe7A-Z\xc9\xc8\xc0\xc2\xd9\xce\xca\u0152\xc70-9_\\\']*)\\b', bygroups(Name.Class, Operator, Name.Variable)),
(u'\\b([a-z\xe9\xe8\xe0\xe2\xf9\xee\xea\u0153\xe7][a-z\xe9\xe8\xe0\xe2\xf9\xee\xea\u0153\xe7A-Z\xc9\xc8\xc0\xc2\xd9\xce\xca\u0152\xc70-9_\\\']*)(\\.)([a-z\xe9\xe8\xe0\xe2\xf9\xee\xea\u0153\xe7][a-z\xe9\xe8\xe0\xe2\xf9\xee\xea\u0153\xe7A-Z\xc9\xc8\xc0\xc2\xd9\xce\xca\u0152\xc70-9_\\\'\\.]*)\\b', bygroups(Name.Variable, Operator, Text)),
(u'\\b([a-z\xe9\xe8\xe0\xe2\xf9\xee\xea\u0153\xe7][a-z\xe9\xe8\xe0\xe2\xf9\xee\xea\u0153\xe7A-Z\xc9\xc8\xc0\xc2\xd9\xce\xca\u0152\xc70-9_\\\']*)\\b', bygroups(Name.Variable)),
(u'\\b([A-Z\xc9\xc8\xc0\xc2\xd9\xce\xca\u0152\xc7][a-z\xe9\xe8\xe0\xe2\xf9\xee\xea\u0153\xe7A-Z\xc9\xc8\xc0\xc2\xd9\xce\xca\u0152\xc70-9_\\\']*)\\b', bygroups(Name.Class)),
('(\n|\r|\r\n)', Text),
('.', Text),
],
'main__1': [
(u'(@@)', bygroups(Generic.Heading), 'root'),
(u'(.)', bygroups(Generic.Heading)),
('(\n|\r|\r\n)', Text),
('.', Text),
],
'main__2': [
(u'(@)', bygroups(Generic.Heading), 'root'),
(u'(.)', bygroups(Generic.Heading)),
('(\n|\r|\r\n)', Text),
('.', Text),
]
}
| CatalaEnLexer |
src.rs | #![allow(non_snake_case, non_upper_case_globals)]
#![allow(non_camel_case_types)]
//! SRC
//!
//! Used by: imxrt1061, imxrt1062, imxrt1064
#[cfg(not(feature = "nosync"))]
pub use crate::imxrt106::peripherals::src::Instance;
pub use crate::imxrt106::peripherals::src::{RegisterBlock, ResetValues};
pub use crate::imxrt106::peripherals::src::{
GPR1, GPR10, GPR2, GPR3, GPR4, GPR5, GPR6, GPR7, GPR8, GPR9, SBMR1, SBMR2, SCR, SRSR,
};
/// Access functions for the SRC peripheral instance
pub mod SRC {
use super::ResetValues;
#[cfg(not(feature = "nosync"))]
use core::sync::atomic::{AtomicBool, Ordering};
#[cfg(not(feature = "nosync"))]
use super::Instance;
#[cfg(not(feature = "nosync"))]
const INSTANCE: Instance = Instance {
addr: 0x400f8000,
_marker: ::core::marker::PhantomData,
#[cfg(not(feature = "doc"))]
intrs: &[crate::interrupt::SRC],
#[cfg(feature = "doc")]
intrs: &[],
};
/// Reset values for each field in SRC
pub const reset: ResetValues = ResetValues {
SCR: 0xA0480520,
SBMR1: 0x00000000,
SRSR: 0x00000001,
SBMR2: 0x00000000,
GPR1: 0x00000000,
GPR2: 0x00000000,
GPR3: 0x00000000,
GPR4: 0x00000000, | GPR9: 0x00000000,
GPR10: 0x00000000,
};
#[cfg(not(feature = "nosync"))]
#[allow(renamed_and_removed_lints)]
#[allow(private_no_mangle_statics)]
#[no_mangle]
static SRC_TAKEN: AtomicBool = AtomicBool::new(false);
/// Safe access to SRC
///
/// This function returns `Some(Instance)` if this instance is not
/// currently taken, and `None` if it is. This ensures that if you
/// do get `Some(Instance)`, you are ensured unique access to
/// the peripheral and there cannot be data races (unless other
/// code uses `unsafe`, of course). You can then pass the
/// `Instance` around to other functions as required. When you're
/// done with it, you can call `release(instance)` to return it.
///
/// `Instance` itself dereferences to a `RegisterBlock`, which
/// provides access to the peripheral's registers.
#[cfg(not(feature = "nosync"))]
#[inline]
pub fn take() -> Option<Instance> {
let taken = SRC_TAKEN.swap(true, Ordering::SeqCst);
if taken {
None
} else {
Some(INSTANCE)
}
}
/// Release exclusive access to SRC
///
/// This function allows you to return an `Instance` so that it
/// is available to `take()` again. This function will panic if
/// you return a different `Instance` or if this instance is not
/// already taken.
#[cfg(not(feature = "nosync"))]
#[inline]
pub fn release(inst: Instance) {
assert!(inst.addr == INSTANCE.addr, "Released the wrong instance");
let taken = SRC_TAKEN.swap(false, Ordering::SeqCst);
assert!(taken, "Released a peripheral which was not taken");
}
/// Unsafely steal SRC
///
/// This function is similar to take() but forcibly takes the
/// Instance, marking it as taken irregardless of its previous
/// state.
#[cfg(not(feature = "nosync"))]
#[inline]
pub unsafe fn steal() -> Instance {
SRC_TAKEN.store(true, Ordering::SeqCst);
INSTANCE
}
/// The interrupts associated with SRC
#[cfg(not(feature = "doc"))]
pub const INTERRUPTS: [crate::Interrupt; 1] = [crate::interrupt::SRC];
/// The interrupts associated with SRC
///
/// Note: the values are invalid for a documentation build.
#[cfg(feature = "doc")]
pub const INTERRUPTS: [crate::Interrupt; 0] = [];
}
/// Raw pointer to SRC
///
/// Dereferencing this is unsafe because you are not ensured unique
/// access to the peripheral, so you may encounter data races with
/// other users of this peripheral. It is up to you to ensure you
/// will not cause data races.
///
/// This constant is provided for ease of use in unsafe code: you can
/// simply call for example `write_reg!(gpio, GPIOA, ODR, 1);`.
pub const SRC: *const RegisterBlock = 0x400f8000 as *const _; | GPR5: 0x00000000,
GPR6: 0x00000000,
GPR7: 0x00000000,
GPR8: 0x00000000, |
recovery_cursor.py | # Copyright 2021 VMware, Inc.
# SPDX-License-Identifier: Apache-2.0
from vdk.internal.builtin_plugins.connection.decoration_cursor import DecorationCursor
from vdk.internal.builtin_plugins.connection.decoration_cursor import ManagedOperation
from vdk.internal.builtin_plugins.connection.pep249.interfaces import PEP249Cursor
class RecoveryCursor(PEP249Cursor):
"""
Extends PEP249Cursor to provide:
* query and parameters executed
* exception that occurred during execution
* tooling for operation recovery
See connection_hook_spec#db_connection_recover_operation for more details and examples how to use it.
"""
def __init__(
self,
native_cursor: PEP249Cursor,
log,
exception,
managed_operation: ManagedOperation,
decoration_operation_callback,
):
|
def get_exception(self) -> Exception:
"""
Retrieve the original exception with which the SQL operation failed.
:return: Exception
"""
return self.__exception
def get_managed_operation(self) -> ManagedOperation:
"""
Retrieve an object that contains information about the query and query parameters used in
the database operation. The retrieved Data Transfer Object (DTO) is purposed
to curate the query and parameters.
:return: ManagedOperation
Query and parameters DTO
"""
return self.__managed_operation
def get_retries(self) -> int:
"""
Fetch retries made using retry_operation().
:return: int
Number of operation retries performed
"""
return self.__retries
def execute(self, operation, parameters=None) -> None:
"""
Execute an additional query purposed for the recovery of the original operation.
:param operation: helper query to facilitate operation recovery
:param parameters: helper query parameters
"""
managed_operation = ManagedOperation(operation, parameters)
if self.__decoration_operation_callback:
self._log.debug("Before executing recovery query:\n%s" % operation)
self.__decoration_operation_callback(
decoration_cursor=DecorationCursor(
self._cursor, self._log, managed_operation
)
)
self._log.info(
"Executing recovery query:\n%s" % managed_operation.get_operation()
)
try:
super().execute(*managed_operation.get_operation_parameters_tuple())
self._log.info("Executing recovery query SUCCEEDED.")
except Exception as e:
self.retries_increment()
self._log.warning(f"Executing recovery query FAILED. Exception: {e}")
raise e
def retry_operation(self) -> None:
"""
Retry original operation to recover.
"""
# could potentially enforce max retries here globally - in favour of per custom error handler
self.retries_increment()
retry_number = self.get_retries()
self._log.info(
f"Retrying attempt #{retry_number} "
f"for query:\n{self.get_managed_operation().get_operation()}"
)
try:
super().execute(
*self.get_managed_operation().get_operation_parameters_tuple()
)
self._log.info(f"Retrying attempt #{retry_number} for query SUCCEEDED.")
except Exception as e:
self._log.warning(
f"Retrying attempt #{retry_number} for query FAILED. Exception: {e}"
)
raise e
def retries_increment(self) -> None:
self.__retries += 1
| super().__init__(native_cursor, log)
self.__exception = exception
self.__managed_operation = managed_operation
self.__decoration_operation_callback = decoration_operation_callback
self.__retries = 0 |
module_load.go | package modder
import (
"fmt"
"os"
"github.com/hofstadter-io/mvs/lib/parse/mappingfile"
"github.com/hofstadter-io/mvs/lib/parse/modfile"
"github.com/hofstadter-io/mvs/lib/parse/sumfile"
"github.com/hofstadter-io/mvs/lib/util"
)
func (m *Module) LoadModFile(fn string, ignoreReplace bool) error {
modBytes, err := util.BillyReadAll(fn, m.FS)
if err != nil {
if _, ok := err.(*os.PathError); !ok && err.Error() != "file does not exist" && err.Error() != "no such file or directory" {
return err
}
} else {
f, err := modfile.Parse(fn, modBytes, nil)
if err != nil {
return err
}
m.ModFile = f
m.Language = f.Language.Name
m.LangVer = f.Language.Version
// m.Module = f.Module.Mod.Path
// m.Version = f.Module.Mod.Version
for _, req := range f.Require {
r := Require{Path: req.Mod.Path, Version: req.Mod.Version}
m.Require = append(m.Require, r)
}
// Let's just not load them for now to be sure
if !ignoreReplace {
for _, rep := range f.Replace {
r := Replace{OldPath: rep.Old.Path, OldVersion: rep.Old.Version, NewPath: rep.New.Path, NewVersion: rep.New.Version}
m.Replace = append(m.Replace, r)
}
}
err = m.MergeSelfDeps(ignoreReplace)
if err != nil {
return err
}
}
return nil
}
func (m *Module) MergeSelfDeps(ignoreReplace bool) error {
// Now merge self deps
m.SelfDeps = map[string]Replace{}
for _, req := range m.Require {
if _, ok := m.SelfDeps[req.Path]; ok {
return fmt.Errorf("Dependency %q required twice in %q", req.Path, m.Module)
}
m.SelfDeps[req.Path] = Replace{
NewPath: req.Path,
NewVersion: req.Version,
}
}
// we typically ignore replaces from when not the root module
if !ignoreReplace {
dblReplace := map[string]Replace{}
for _, rep := range m.Replace {
// Check if replaced twice
if _, ok := dblReplace[rep.OldPath]; ok { |
// Pull in require info if not in replace
if req, ok := m.SelfDeps[rep.OldPath]; ok {
if rep.OldVersion == "" {
rep.OldVersion = req.NewVersion
}
}
m.SelfDeps[rep.OldPath] = rep
}
}
return nil
}
func (m *Module) LoadSumFile(fn string) error {
sumBytes, err := util.BillyReadAll(fn, m.FS)
if err != nil {
if _, ok := err.(*os.PathError); !ok && err.Error() != "file does not exist" && err.Error() != "no such file or directory" {
return err
}
} else {
sumMod, err := sumfile.ParseSum(sumBytes, fn)
if err != nil {
return err
}
m.SumFile = &sumMod
}
return nil
}
func (m *Module) LoadMappingFile(fn string) error {
mapBytes, err := util.BillyReadAll(fn, m.FS)
if err != nil {
if _, ok := err.(*os.PathError); !ok && err.Error() != "file does not exist" && err.Error() != "no such file or directory" {
return err
}
} else {
mapMod, err := mappingfile.ParseMapping(mapBytes, fn)
if err != nil {
return err
}
m.Mappings = &mapMod
}
return nil
}
func (m *Module) LoadMetaFiles(modname, sumname, mapname string, ignoreReplace bool) error {
var err error
// TODO load the modules .mvsconfig if present
err = m.LoadModFile(modname, ignoreReplace)
if err != nil {
return err
}
// Supressing the next to errors here
// because we can handle them not being around else where
err = m.LoadSumFile(sumname)
if err != nil {
// fmt.Println(err)
// return err
}
err = m.LoadMappingFile(mapname)
if err != nil {
// fmt.Println(err)
// return err
}
return nil
} | return fmt.Errorf("Dependency %q replaced twice in %q", rep.OldPath, m.Module)
}
dblReplace[rep.OldPath] = rep |
pull.rs | use crate::helper::get_image_manager_instance;
use crate::{Handler, Result};
use async_trait::async_trait;
use clap::Args;
use log::LevelFilter;
/// Arguments for our `PullCommand`.
///
/// These arguments are parsed by `clap` and an instance of `PullCommand` containing
/// arguments is provided.
///
/// Example :
///
/// `kaps pull registry.hub.docker.com/library/busybox`
///
/// The `handler` method provided below will be executed.
#[derive(Debug, Args)]
pub struct | {
/// The image to pull.
/// Example : registry.hub.docker.com/library/busybox
image: String,
/// By default, the image id will be generated by creating a unique hash for the image digest.
/// By using --name, you can provide a friendly identifier your image.
#[clap(long)]
name: Option<String>,
/// By default, the command will not pull the image if it was already present.
/// If `--rm` is provided in arguments, the command will remove the previous image
/// before pulling the image.
#[clap(long = "rm")]
remove_existing: bool,
/// If set, the command will be executed silently.
#[clap(long, short)]
quiet: bool,
}
#[async_trait]
impl Handler for PullCommand {
async fn handler(&self, logger: &mut env_logger::Builder) -> Result<()> {
// Change logger behavior and init it
// If the logger was not initialized, nothing will be displayed into the console.
if self.quiet {
logger.filter_level(LevelFilter::Off);
}
logger.init();
let mut im = get_image_manager_instance()?;
let image_id = im
.pull(&self.image, &self.remove_existing, &self.name)
.await?;
// Here we want to print the image_id
// so the user can get the output for scripting purposes
println!("{}", image_id);
Ok(())
}
}
| PullCommand |
decoder.go | package simulation
import (
"bytes"
"fmt"
sdk "github.com/cosmos/cosmos-sdk/types"
"github.com/cosmos/cosmos-sdk/codec"
"github.com/cosmos/cosmos-sdk/types/kv"
"github.com/desmos-labs/desmos/x/profiles/types"
)
// NewDecodeStore returns a new decoder that unmarshals the KVPair's Value
// to the corresponding relationships type
func NewDecodeStore(cdc codec.Marshaler) func(kvA, kvB kv.Pair) string {
return func(kvA, kvB kv.Pair) string {
switch {
case bytes.HasPrefix(kvA.Key, types.DTagPrefix):
addressA := sdk.AccAddress(bytes.TrimPrefix(kvA.Value, types.DTagPrefix)).String()
addressB := sdk.AccAddress(bytes.TrimPrefix(kvB.Value, types.DTagPrefix)).String()
return fmt.Sprintf("DTagAddressA: %s\nDTagAddressB: %s\n", addressA, addressB)
case bytes.HasPrefix(kvA.Key, types.DTagTransferRequestsPrefix):
var requestsA, requestsB types.DTagTransferRequests
cdc.MustUnmarshalBinaryBare(kvA.Value, &requestsA)
cdc.MustUnmarshalBinaryBare(kvB.Value, &requestsB)
return fmt.Sprintf("RequestsA: %s\nRequestsB: %s\n", requestsA.Requests, requestsB.Requests)
| }
} | default:
panic(fmt.Sprintf("unexpected %s key %X (%s)", types.ModuleName, kvA.Key, kvA.Key))
} |
versions.ts | import { OpenshiftVersionOptionType, OpenshiftVersion } from '../../../common';
import { ClusterImageSetK8sResource } from '../../types/k8s/cluster-image-set'; | const match = /.+:(.*)-/gm.exec(releaseImage);
if (match && match[1]) {
return match[1];
}
return '';
};
// eslint-disable-next-line
const getSupportLevelFromChannel = (channel?: string): OpenshiftVersion['supportLevel'] => {
if (!channel) {
return 'custom';
}
if (channel.startsWith('fast')) {
return 'beta'; // TODO(mlibra): Is this correct?
}
if (channel.startsWith('stable')) {
return 'production';
}
return 'beta';
};
export const getOCPVersions = (
clusterImageSets: ClusterImageSetK8sResource[],
): OpenshiftVersionOptionType[] => {
const versions = clusterImageSets
.filter((clusterImageSet) => clusterImageSet.metadata?.labels?.visible !== 'false')
.map(
(clusterImageSet): OpenshiftVersionOptionType => {
const version = getVersion(clusterImageSet.spec?.releaseImage);
return {
label: version ? `OpenShift ${version}` : (clusterImageSet.metadata?.name as string),
version,
value: clusterImageSet.metadata?.name as string,
default: false,
// (rawagner) ACM does not have the warning so changing to 'production'
supportLevel: 'production', // getSupportLevelFromChannel(clusterImageSet.metadata?.labels?.channel),
};
},
)
.sort(
(versionA, versionB) => /* descending */ -1 * versionA.label.localeCompare(versionB.label),
);
if (versions.length) {
// make sure that the pre-selected one is the first-one after sorting
versions[0].default = true;
}
return versions;
}; |
const getVersion = (releaseImage = '') => { |
lib.rs | //! Very minimal sqlite wrapper package built specifically for lod package manager and Unix systems. If you need complete box of sqlite database, consider using [rusqlite](https://github.com/rusqlite/rusqlite).
//!
//! ## Adding lib to the project
//! In your Cargo.toml:
//!
//! ```toml
//! [dependencies]
//! min-sqlite3-sys = "1.3"
//! ```
//!
//! In build.rs of your binary crate:
//! ```rust
//! use std::{env, path::Path};
//!
//! fn main() {
//! let home_path = env::var("HOME").expect("HOME environment variable is not set.");
//! let target_dir = Path::new(&home_path).join(".local/share/min_sqlite3_sys");
//!
//! println!("cargo:rustc-link-arg=-Wl,-rpath={}", target_dir.display());
//! }
//! ```
//!
//! ## Usage
//! Simple usage:
//!
//! ```rust
//! use std::path::Path;
//!
//! use min_sqlite3_sys::prelude::*;
//!
//! fn main() {
//! let db = Database::open(Path::new("example.db")).unwrap();
//! let statement = String::from(
//! "CREATE TABLE IF NOT EXISTS items(
//! id PRIMARY KEY,
//! name TEXT,
//! tag TEXT
//! );
//! ",
//! );
//!
//! let status = db.execute(
//! statement,
//! None::<Box<dyn FnOnce(SqlitePrimaryResult, String)>>,
//! ).unwrap();
//!
//! if status != SqlitePrimaryResult::Ok {
//! // handle the problem
//! }
//!
//! db.close();
//! }
//! ```
//!
//! Simple usage with callback function:
//! ```rust
//! use std::path::Path;
//!
//! use min_sqlite3_sys::prelude::*;
//!
//! fn callback_function(status: SqlitePrimaryResult, sql_statement: String) {
//! println!(
//! "{} did not successfully executed. The error status is: {:?}.",
//! sql_statement, status
//! );
//! }
//!
//! fn main() {
//! let db = Database::open(Path::new("example.db")).unwrap();
//! let statement = String::from(
//! "CREATE TABLE IF NOT EXISTS items(
//! id PRIMARY KEY,
//! name TEXT,
//! tag TEXT
//! );
//! ",
//! );
//!
//! db.execute(statement, Some(callback_function)).unwrap();
//!
//! db.close();
//! }
//! ```
//!
//! Simple usage with retrieving some data:
//! ```rust
//! #![allow(dead_code)]
//! use std::path::Path;
//!
//! use min_sqlite3_sys::prelude::*;
//!
//! fn callback_function(status: SqlitePrimaryResult, sql_statement: String) {
//! println!(
//! "{} did not successfully executed. The error status is: {:?}.",
//! sql_statement, status
//! );
//! }
//!
//! #[derive(Debug)]
//! struct Item {
//! id: i64,
//! name: String,
//! tag: String,
//! }
//!
//! fn main() {
//! let db = Database::open(Path::new("example.db")).unwrap();
//! let statement = String::from("SELECT * FROM items WHERE name = 'Onur';");
//!
//! let mut sql = db.prepare(statement, Some(callback_function)).unwrap();
//!
//! // Iterate the results
//! while let PreparedStatementStatus::FoundRow = sql.execute_prepared() {
//! println!(
//! "id = {}, name = {}, tag = {}",
//! sql.get_data::<i64>(0).unwrap(),
//! sql.get_data::<String>(1).unwrap(),
//! sql.get_data::<String>(2).unwrap(),
//! );
//!
//! // Or simply
//! println!(
//! "{:?}",
//! Item {
//! id: sql.get_data(0).unwrap(),
//! name: sql.get_data(1).unwrap(),
//! tag: sql.get_data(2).unwrap(),
//! }
//! );
//! }
//! // Must be called for each `prepare()` result.
//! sql.kill();
//!
//! db.close();
//! }
//! ```
//!
//! Simple usage with retrieving some data + binding values:
//! ```rust
//! #![allow(dead_code)]
//! use std::path::Path;
//!
//! use min_sqlite3_sys::prelude::*;
//! | //! "{} did not successfully executed. The error status is: {:?}.",
//! sql_statement, status
//! );
//! }
//!
//! #[derive(Debug)]
//! struct Item {
//! id: i64,
//! name: String,
//! tag: String,
//! }
//!
//! fn main() {
//! let db = Database::open(Path::new("example.db")).unwrap();
//! let statement = String::from("SELECT * FROM items WHERE name = ?;");
//!
//! let mut sql = db.prepare(statement, Some(callback_function)).unwrap();
//! let status = sql.bind_val(1, "Onur");
//! // You can do some checks by
//! assert_eq!(status, SqlitePrimaryResult::Ok);
//! // or
//! if status == SqlitePrimaryResult::Range {
//! panic!("Out of index on sql.bind_val!");
//! }
//!
//! // Iterate the results
//! while let PreparedStatementStatus::FoundRow = sql.execute_prepared() {
//! println!(
//! "id = {}, name = {}, tag = {}",
//! sql.get_data::<i64>(0).unwrap(),
//! sql.get_data::<String>(1).unwrap(),
//! sql.get_data::<String>(2).unwrap(),
//! );
//!
//! // Or simply
//! println!(
//! "{:?}",
//! Item {
//! id: sql.get_data(0).unwrap(),
//! name: sql.get_data(1).unwrap(),
//! tag: sql.get_data(2).unwrap(),
//! }
//! );
//! }
//! // Must be called for each `prepare()` result.
//! sql.kill();
//!
//! db.close();
//! }
//! ```
//!
//! ## Notes
//! In order to not inflate the build outputs of your projects, the library executes sqlite functions from dynamic library using C ABI via FFI. Meaning, your build output will not include sqlite sources.
//!
//! This library does not use any SQLite library on your system to ensure that the package doesn't get affected by SQLite versions. Instead, the sqlite3-builder crate compiles the sqlite3 sources under the c_source directory as dynamic library and puts that under the '~/.local/share/min_sqlite3_sys'.
#![allow(clippy::needless_doctest_main)] | //! fn callback_function(status: SqlitePrimaryResult, sql_statement: String) {
//! println!( |
char.rs | // Copyright 2012-2014 The Rust Project Developers. See the COPYRIGHT
// file at the top-level directory of this distribution and at
// http://rust-lang.org/COPYRIGHT.
//
// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
// option. This file may not be copied, modified, or distributed
// except according to those terms.
//! A Unicode scalar value
//!
//! This module provides the `CharExt` trait, as well as its
//! implementation for the primitive `char` type, in order to allow
//! basic character manipulation.
//!
//! A `char` represents a
//! *[Unicode scalar
//! value](http://www.unicode.org/glossary/#unicode_scalar_value)*, as it can
//! contain any Unicode code point except high-surrogate and low-surrogate code
//! points.
//!
//! As such, only values in the ranges \[0x0,0xD7FF\] and \[0xE000,0x10FFFF\]
//! (inclusive) are allowed. A `char` can always be safely cast to a `u32`;
//! however the converse is not always true due to the above range limits
//! and, as such, should be performed via the `from_u32` function.
//!
//! *[See also the `char` primitive type](../primitive.char.html).*
#![stable(feature = "rust1", since = "1.0.0")]
use core::char::CharExt as C;
use core::option::Option::{self, Some, None};
use core::iter::Iterator;
use tables::{derived_property, property, general_category, conversions};
// stable reexports
pub use core::char::{MAX, from_u32, from_u32_unchecked, from_digit, EscapeUnicode, EscapeDefault};
// unstable reexports
pub use tables::UNICODE_VERSION;
/// An iterator over the lowercase mapping of a given character, returned from
/// the [`to_lowercase` method](../primitive.char.html#method.to_lowercase) on
/// characters.
#[stable(feature = "rust1", since = "1.0.0")]
pub struct ToLowercase(CaseMappingIter);
#[stable(feature = "rust1", since = "1.0.0")]
impl Iterator for ToLowercase {
type Item = char;
fn next(&mut self) -> Option<char> {
self.0.next()
}
}
/// An iterator over the uppercase mapping of a given character, returned from
/// the [`to_uppercase` method](../primitive.char.html#method.to_uppercase) on
/// characters.
#[stable(feature = "rust1", since = "1.0.0")]
pub struct ToUppercase(CaseMappingIter);
#[stable(feature = "rust1", since = "1.0.0")]
impl Iterator for ToUppercase {
type Item = char;
fn next(&mut self) -> Option<char> {
self.0.next()
}
}
enum CaseMappingIter {
Three(char, char, char),
Two(char, char),
One(char),
Zero,
}
impl CaseMappingIter {
fn new(chars: [char; 3]) -> CaseMappingIter {
if chars[2] == '\0' {
if chars[1] == '\0' {
CaseMappingIter::One(chars[0]) // Including if chars[0] == '\0'
} else {
CaseMappingIter::Two(chars[0], chars[1])
}
} else {
CaseMappingIter::Three(chars[0], chars[1], chars[2])
}
}
}
impl Iterator for CaseMappingIter {
type Item = char;
fn next(&mut self) -> Option<char> {
match *self {
CaseMappingIter::Three(a, b, c) => {
*self = CaseMappingIter::Two(b, c);
Some(a)
}
CaseMappingIter::Two(b, c) => {
*self = CaseMappingIter::One(c);
Some(b)
}
CaseMappingIter::One(c) => {
*self = CaseMappingIter::Zero;
Some(c)
}
CaseMappingIter::Zero => None,
}
}
}
#[lang = "char"]
impl char {
/// Checks if a `char` is a digit in the given radix.
///
/// A 'radix' here is sometimes also called a 'base'. A radix of two
/// indicates a binary number, a radix of ten, decimal, and a radix of
/// sixteen, hexicdecimal, to give some common values. Arbitrary
/// radicum are supported.
///
/// Compared to `is_numeric()`, this function only recognizes the characters
/// `0-9`, `a-z` and `A-Z`.
///
/// 'Digit' is defined to be only the following characters:
///
/// * `0-9`
/// * `a-z`
/// * `A-Z`
///
/// For a more comprehensive understanding of 'digit', see [`is_numeric()`][is_numeric].
///
/// [is_numeric]: #method.is_numeric
///
/// # Panics
///
/// Panics if given a radix larger than 36.
///
/// # Examples
///
/// Basic usage:
///
/// ```
/// let d = '1';
///
/// assert!(d.is_digit(10));
///
/// let d = 'f';
///
/// assert!(d.is_digit(16));
/// assert!(!d.is_digit(10));
/// ```
///
/// Passing a large radix, causing a panic:
///
/// ```
/// use std::thread;
///
/// let result = thread::spawn(|| {
/// let d = '1';
///
/// // this panics
/// d.is_digit(37);
/// }).join();
///
/// assert!(result.is_err());
/// ```
#[stable(feature = "rust1", since = "1.0.0")]
#[inline]
pub fn is_digit(self, radix: u32) -> bool {
C::is_digit(self, radix)
}
/// Converts a `char` to a digit in the given radix.
///
/// A 'radix' here is sometimes also called a 'base'. A radix of two
/// indicates a binary number, a radix of ten, decimal, and a radix of
/// sixteen, hexicdecimal, to give some common values. Arbitrary
/// radicum are supported.
///
/// 'Digit' is defined to be only the following characters:
///
/// * `0-9`
/// * `a-z`
/// * `A-Z`
///
/// # Failure
///
/// Returns `None` if the `char` does not refer to a digit in the given radix.
///
/// # Panics
///
/// Panics if given a radix larger than 36.
///
/// # Examples
///
/// Basic usage:
///
/// ```
/// let d = '1';
///
/// assert_eq!(d.to_digit(10), Some(1));
///
/// let d = 'f';
///
/// assert_eq!(d.to_digit(16), Some(15));
/// ```
///
/// Passing a non-digit results in failure:
///
/// ```
/// let d = 'f';
///
/// assert_eq!(d.to_digit(10), None);
///
/// let d = 'z';
///
/// assert_eq!(d.to_digit(16), None);
/// ```
///
/// Passing a large radix, causing a panic:
///
/// ```
/// use std::thread;
///
/// let result = thread::spawn(|| {
/// let d = '1';
///
/// d.to_digit(37);
/// }).join();
///
/// assert!(result.is_err());
/// ```
#[stable(feature = "rust1", since = "1.0.0")]
#[inline]
pub fn to_digit(self, radix: u32) -> Option<u32> {
C::to_digit(self, radix)
}
/// Returns an iterator that yields the hexadecimal Unicode escape of a
/// character, as `char`s.
///
/// All characters are escaped with Rust syntax of the form `\\u{NNNN}`
/// where `NNNN` is the shortest hexadecimal representation of the code
/// point.
///
/// # Examples
///
/// ```
/// for c in '❤'.escape_unicode() {
/// print!("{}", c);
/// }
/// println!("");
/// ```
///
/// This prints:
///
/// ```text
/// \u{2764}
/// ```
///
/// Collecting into a `String`:
///
/// ```
/// let heart: String = '❤'.escape_unicode().collect();
///
/// assert_eq!(heart, r"\u{2764}");
/// ```
#[stable(feature = "rust1", since = "1.0.0")]
#[inline]
pub fn escape_unicode(self) -> EscapeUnicode {
C::escape_unicode(self)
}
/// Returns an iterator that yields the literal escape code of a `char`.
///
/// The default is chosen with a bias toward producing literals that are
/// legal in a variety of languages, including C++11 and similar C-family
/// languages. The exact rules are:
///
/// * Tab is escaped as `\t`.
/// * Carriage return is escaped as `\r`.
/// * Line feed is escaped as `\n`.
/// * Single quote is escaped as `\'`.
/// * Double quote is escaped as `\"`.
/// * Backslash is escaped as `\\`.
/// * Any character in the 'printable ASCII' range `0x20` .. `0x7e`
/// inclusive is not escaped.
/// * All other characters are given hexadecimal Unicode escapes; see
/// [`escape_unicode`][escape_unicode].
///
/// [escape_unicode]: #method.escape_unicode
///
/// # Examples
///
/// Basic usage:
///
/// ```
/// for i in '"'.escape_default() {
/// println!("{}", i);
/// }
/// ```
///
/// This prints:
///
/// ```text
/// \
/// "
/// ```
///
/// Collecting into a `String`:
///
/// ```
/// let quote: String = '"'.escape_default().collect();
///
/// assert_eq!(quote, "\\\"");
/// ```
#[stable(feature = "rust1", since = "1.0.0")]
#[inline]
pub fn escape_default(self) -> EscapeDefault {
C::escape_default(self)
}
/// Returns the number of bytes this `char` would need if encoded in UTF-8.
///
/// That number of bytes is always between 1 and 4, inclusive.
///
/// # Examples
///
/// Basic usage:
///
/// ```
/// let len = 'A'.len_utf8();
/// assert_eq!(len, 1);
///
/// let len = 'ß'.len_utf8();
/// assert_eq!(len, 2);
///
/// let len = 'ℝ'.len_utf8();
/// assert_eq!(len, 3);
///
/// let len = '💣'.len_utf8();
/// assert_eq!(len, 4);
/// ```
///
/// The `&str` type guarantees that its contents are UTF-8, and so we can compare the length it
/// would take if each code point was represented as a `char` vs in the `&str` itself:
///
/// ```
/// // as chars
/// let eastern = '東';
/// let capitol = '京';
///
/// // both can be represented as three bytes
/// assert_eq!(3, eastern.len_utf8());
/// assert_eq!(3, capitol.len_utf8());
///
/// // as a &str, these two are encoded in UTF-8
/// let tokyo = "東京";
///
/// let len = eastern.len_utf8() + capitol.len_utf8();
///
/// // we can see that they take six bytes total...
/// assert_eq!(6, tokyo.len());
///
/// // ... just like the &str
/// assert_eq!(len, tokyo.len());
/// ```
#[stable(feature = "rust1", since = "1.0.0")]
#[inline]
pub fn len_utf8(self) -> usize {
C::len_utf8(self)
}
/// Returns the number of 16-bit code units this `char` would need if
/// encoded in UTF-16.
///
/// See the documentation for [`len_utf8()`][len_utf8] for more explanation
/// of this concept. This function is a mirror, but for UTF-16 instead of
/// UTF-8.
///
/// # Examples
///
/// ```
/// let n = 'ß'.len_utf16();
/// assert_eq!(n, 1);
///
/// let len = '💣'.len_utf16();
/// assert_eq!(len, 2);
/// ```
#[stable(feature = "rust1", since = "1.0.0")]
#[inline]
pub fn len_utf16(self) -> usize {
C::len_utf16(self)
}
/// Encodes this character as UTF-8 into the provided byte buffer, and then
/// returns the number of bytes written.
///
/// If the buffer is not large enough, nothing will be written into it and a
/// `None` will be returned. A buffer of length four is large enough to
/// encode any `char`.
///
/// # Examples
///
/// In both of these examples, 'ß' takes two bytes to encode.
///
/// ```
/// #![feature(unicode)]
///
/// let mut b = [0; 2];
///
/// let result = 'ß'.encode_utf8(&mut b);
///
/// assert_eq!(result, Some(2));
/// ```
///
/// A buffer that's too small:
///
/// ```
/// #![feature(unicode)]
///
/// let mut b = [0; 1];
///
/// let result = 'ß'.encode_utf8(&mut b);
///
/// assert_eq!(result, None);
/// ```
#[unstable(feature = "unicode",
reason = "pending decision about Iterator/Writer/Reader",
issue = "27784")]
#[inline]
pub fn encode_utf8(self, dst: &mut [u8]) -> Option<usize> {
C::encode_utf8(self, dst)
}
/// Encodes this character as UTF-16 into the provided `u16` buffer, and
/// then returns the number of `u16`s written.
///
/// If the buffer is not large enough, nothing will be written into it and a
/// `None` will be returned. A buffer of length 2 is large enough to encode
/// any `char`.
///
/// # Examples
///
/// In both of these examples, 'ß' takes one `u16` to encode.
///
/// ```
/// #![feature(unicode)]
///
/// let mut b = [0; 1];
///
/// let result = 'ß'.encode_utf16(&mut b);
///
/// assert_eq!(result, Some(1));
/// ```
///
/// A buffer that's too small:
///
/// ```
/// #![feature(unicode)]
///
/// let mut b = [0; 0];
///
/// let result = 'ß'.encode_utf8(&mut b);
///
/// assert_eq!(result, None);
/// ```
#[unstable(feature = "unicode",
reason = "pending decision about Iterator/Writer/Reader",
issue = "27784")]
#[inline]
pub fn encode_utf16(self, dst: &mut [u16]) -> Option<usize> {
C::encode_utf16(self, dst)
}
/// Returns true if this `char` is an alphabetic code point, and false if not.
///
/// # Examples
///
/// Basic usage:
///
/// ```
/// let c = 'a';
///
/// assert!(c.is_alphabetic());
///
/// let c = '京';
/// assert!(c.is_alphabetic());
///
/// let c = '💝';
/// // love is many things, but it is not alphabetic
/// assert!(!c.is_alphabetic());
/// ```
#[stable(feature = "rust1", since = "1.0.0")]
#[inline]
pub fn is_alphabetic(self) -> bool {
match self {
'a'...'z' | 'A'...'Z' => true,
c if c > '\x7f' => derived_property::Alphabetic(c),
_ => false,
}
}
/// Returns true if this `char` satisfies the 'XID_Start' Unicode property, and false
/// otherwise.
///
/// 'XID_Start' is a Unicode Derived Property specified in
/// [UAX #31](http://unicode.org/reports/tr31/#NFKC_Modifications),
/// mostly similar to `ID_Start` but modified for closure under `NFKx`.
#[unstable(feature = "unicode",
reason = "mainly needed for compiler internals",
issue = "0")]
#[inline]
pub fn is_xid_start(self) -> bool {
derived_property::XID_Start(self)
}
/// Returns true if this `char` satisfies the 'XID_Continue' Unicode property, and false
/// otherwise.
///
/// 'XID_Continue' is a Unicode Derived Property specified in
/// [UAX #31](http://unicode.org/reports/tr31/#NFKC_Modifications),
/// mostly similar to 'ID_Continue' but modified for closure under NFKx.
#[unstable(feature = "unicode",
reason = "mainly needed for compiler internals",
issue = "0")]
#[inline]
pub fn is_xid_continue(self) -> bool {
derived_property::XID_Continue(self)
}
/// Returns true if this `char` is lowercase, and false otherwise.
///
/// 'Lowercase' is defined according to the terms of the Unicode Derived Core
/// Property `Lowercase`.
///
/// # Examples
///
/// Basic usage:
///
/// ```
/// let c = 'a';
/// assert!(c.is_lowercase());
///
/// let c = 'δ';
/// assert!(c.is_lowercase());
///
/// let c = 'A';
/// assert!(!c.is_lowercase());
///
/// let c = 'Δ';
/// assert!(!c.is_lowercase());
///
/// // The various Chinese scripts do not have case, and so:
/// let c = '中';
/// assert!(!c.is_lowercase());
/// ```
#[stable(feature = "rust1", since = "1.0.0")]
#[inline]
pub fn is_lowercase(self) -> bool {
match self {
'a'...'z' => true,
c if c > '\x7f' => derived_property::Lowercase(c),
_ => false,
}
}
/// Returns true if this `char` is uppercase, and false otherwise.
///
/// 'Uppercase' is defined according to the terms of the Unicode Derived Core
/// Property `Uppercase`.
///
/// # Examples
///
/// Basic usage:
///
/// ```
/// let c = 'a';
/// assert!(!c.is_uppercase());
///
/// let c = 'δ';
/// assert!(!c.is_uppercase());
///
/// let c = 'A';
/// assert!(c.is_uppercase());
///
/// let c = 'Δ';
/// assert!(c.is_uppercase());
///
/// // The various Chinese scripts do not have case, and so:
/// let c = '中';
/// assert!(!c.is_uppercase());
/// ```
#[stable(feature = "rust1", since = "1.0.0")]
#[inline]
pub fn is_uppercase(self) -> bool {
match self {
'A'...'Z' => true,
c if c > '\x7f' => derived_property::Uppercase(c),
_ => false,
}
}
/// Returns true if this `char` is whitespace, and false otherwise.
///
/// 'Whitespace' is defined according to the terms of the Unicode Derived Core
/// Property `White_Space`.
///
/// # Examples
///
/// Basic usage:
///
/// ```
/// let c = ' ';
/// assert!(c.is_whitespace());
///
/// // a non-breaking space
/// let c = '\u{A0}';
/// assert!(c.is_whitespace());
///
/// let c = '越';
/// assert!(!c.is_whitespace());
/// ```
#[stable(feature = "rust1", since = "1.0.0")]
#[inline]
pub fn is_whitespace(self) -> bool {
match self {
' ' | '\x09'...'\x0d' => true,
c if c > '\x7f' => property::White_Space(c),
_ => false,
}
}
/// Returns true if this `char` is alphanumeric, and false otherwise.
///
/// 'Alphanumeric'-ness is defined in terms of the Unicode General Categories
/// 'Nd', 'Nl', 'No' and the Derived Core Property 'Alphabetic'.
///
/// # Examples
///
/// Basic usage:
///
/// ```
/// let c = '٣';
/// assert!(c.is_alphanumeric()); | /// let c = '7';
/// assert!(c.is_alphanumeric());
///
/// let c = '৬';
/// assert!(c.is_alphanumeric());
///
/// let c = 'K';
/// assert!(c.is_alphanumeric());
///
/// let c = 'و';
/// assert!(c.is_alphanumeric());
///
/// let c = '藏';
/// assert!(c.is_alphanumeric());
///
/// let c = '¾';
/// assert!(!c.is_alphanumeric());
///
/// let c = '①';
/// assert!(!c.is_alphanumeric());
/// ```
#[stable(feature = "rust1", since = "1.0.0")]
#[inline]
pub fn is_alphanumeric(self) -> bool {
self.is_alphabetic() || self.is_numeric()
}
/// Returns true if this `char` is a control code point, and false otherwise.
///
/// 'Control code point' is defined in terms of the Unicode General
/// Category `Cc`.
///
/// # Examples
///
/// Basic usage:
///
/// ```
/// // U+009C, STRING TERMINATOR
/// let c = '';
/// assert!(c.is_control());
///
/// let c = 'q';
/// assert!(!c.is_control());
/// ```
#[stable(feature = "rust1", since = "1.0.0")]
#[inline]
pub fn is_control(self) -> bool {
general_category::Cc(self)
}
/// Returns true if this `char` is numeric, and false otherwise.
///
/// 'Numeric'-ness is defined in terms of the Unicode General Categories
/// 'Nd', 'Nl', 'No'.
///
/// # Examples
///
/// Basic usage:
///
/// ```
/// let c = '٣';
/// assert!(c.is_numeric());
///
/// let c = '7';
/// assert!(c.is_numeric());
///
/// let c = '৬';
/// assert!(c.is_numeric());
///
/// let c = 'K';
/// assert!(!c.is_numeric());
///
/// let c = 'و';
/// assert!(!c.is_numeric());
///
/// let c = '藏';
/// assert!(!c.is_numeric());
///
/// let c = '¾';
/// assert!(!c.is_numeric());
///
/// let c = '①';
/// assert!(!c.is_numeric());
/// ```
#[stable(feature = "rust1", since = "1.0.0")]
#[inline]
pub fn is_numeric(self) -> bool {
match self {
'0'...'9' => true,
c if c > '\x7f' => general_category::N(c),
_ => false,
}
}
/// Returns an iterator that yields the lowercase equivalent of a `char`.
///
/// If no conversion is possible then an iterator with just the input character is returned.
///
/// This performs complex unconditional mappings with no tailoring: it maps
/// one Unicode character to its lowercase equivalent according to the
/// [Unicode database] and the additional complex mappings
/// [`SpecialCasing.txt`]. Conditional mappings (based on context or
/// language) are not considered here.
///
/// For a full reference, see [here][reference].
///
/// [Unicode database]: ftp://ftp.unicode.org/Public/UNIDATA/UnicodeData.txt
///
/// [`SpecialCasing.txt`]: ftp://ftp.unicode.org/Public/UNIDATA/SpecialCasing.txt
///
/// [reference]: http://www.unicode.org/versions/Unicode7.0.0/ch03.pdf#G33992
///
/// # Examples
///
/// Basic usage:
///
/// ```
/// let c = 'c';
///
/// assert_eq!(c.to_uppercase().next(), Some('C'));
///
/// // Japanese scripts do not have case, and so:
/// let c = '山';
/// assert_eq!(c.to_uppercase().next(), Some('山'));
/// ```
#[stable(feature = "rust1", since = "1.0.0")]
#[inline]
pub fn to_lowercase(self) -> ToLowercase {
ToLowercase(CaseMappingIter::new(conversions::to_lower(self)))
}
/// Returns an iterator that yields the uppercase equivalent of a `char`.
///
/// If no conversion is possible then an iterator with just the input character is returned.
///
/// This performs complex unconditional mappings with no tailoring: it maps
/// one Unicode character to its uppercase equivalent according to the
/// [Unicode database] and the additional complex mappings
/// [`SpecialCasing.txt`]. Conditional mappings (based on context or
/// language) are not considered here.
///
/// For a full reference, see [here][reference].
///
/// [Unicode database]: ftp://ftp.unicode.org/Public/UNIDATA/UnicodeData.txt
///
/// [`SpecialCasing.txt`]: ftp://ftp.unicode.org/Public/UNIDATA/SpecialCasing.txt
///
/// [reference]: http://www.unicode.org/versions/Unicode7.0.0/ch03.pdf#G33992
///
/// # Examples
///
/// Basic usage:
///
/// ```
/// let c = 'c';
/// assert_eq!(c.to_uppercase().next(), Some('C'));
///
/// // Japanese does not have case, and so:
/// let c = '山';
/// assert_eq!(c.to_uppercase().next(), Some('山'));
/// ```
///
/// In Turkish, the equivalent of 'i' in Latin has five forms instead of two:
///
/// * 'Dotless': I / ı, sometimes written ï
/// * 'Dotted': İ / i
///
/// Note that the lowercase dotted 'i' is the same as the Latin. Therefore:
///
/// ```
/// let i = 'i';
///
/// let upper_i = i.to_uppercase().next();
/// ```
///
/// The value of `upper_i` here relies on the language of the text: if we're
/// in `en-US`, it should be `Some('I')`, but if we're in `tr_TR`, it should
/// be `Some('İ')`. `to_uppercase()` does not take this into account, and so:
///
/// ```
/// let i = 'i';
///
/// let upper_i = i.to_uppercase().next();
///
/// assert_eq!(Some('I'), upper_i);
/// ```
///
/// holds across languages.
#[stable(feature = "rust1", since = "1.0.0")]
#[inline]
pub fn to_uppercase(self) -> ToUppercase {
ToUppercase(CaseMappingIter::new(conversions::to_upper(self)))
}
}
/// An iterator that decodes UTF-16 encoded code points from an iterator of `u16`s.
#[unstable(feature = "decode_utf16", reason = "recently exposed", issue = "27830")]
#[derive(Clone)]
pub struct DecodeUtf16<I>
where I: Iterator<Item = u16>
{
iter: I,
buf: Option<u16>,
}
/// Create an iterator over the UTF-16 encoded code points in `iterable`,
/// returning unpaired surrogates as `Err`s.
///
/// # Examples
///
/// ```
/// #![feature(decode_utf16)]
///
/// use std::char::decode_utf16;
///
/// fn main() {
/// // 𝄞mus<invalid>ic<invalid>
/// let v = [0xD834, 0xDD1E, 0x006d, 0x0075,
/// 0x0073, 0xDD1E, 0x0069, 0x0063,
/// 0xD834];
///
/// assert_eq!(decode_utf16(v.iter().cloned()).collect::<Vec<_>>(),
/// vec![Ok('𝄞'),
/// Ok('m'), Ok('u'), Ok('s'),
/// Err(0xDD1E),
/// Ok('i'), Ok('c'),
/// Err(0xD834)]);
/// }
/// ```
///
/// A lossy decoder can be obtained by replacing `Err` results with the replacement character:
///
/// ```
/// #![feature(decode_utf16)]
///
/// use std::char::{decode_utf16, REPLACEMENT_CHARACTER};
///
/// fn main() {
/// // 𝄞mus<invalid>ic<invalid>
/// let v = [0xD834, 0xDD1E, 0x006d, 0x0075,
/// 0x0073, 0xDD1E, 0x0069, 0x0063,
/// 0xD834];
///
/// assert_eq!(decode_utf16(v.iter().cloned())
/// .map(|r| r.unwrap_or(REPLACEMENT_CHARACTER))
/// .collect::<String>(),
/// "𝄞mus�ic�");
/// }
/// ```
#[unstable(feature = "decode_utf16", reason = "recently exposed", issue = "27830")]
#[inline]
pub fn decode_utf16<I: IntoIterator<Item = u16>>(iterable: I) -> DecodeUtf16<I::IntoIter> {
DecodeUtf16 {
iter: iterable.into_iter(),
buf: None,
}
}
#[unstable(feature = "decode_utf16", reason = "recently exposed", issue = "27830")]
impl<I: Iterator<Item=u16>> Iterator for DecodeUtf16<I> {
type Item = Result<char, u16>;
fn next(&mut self) -> Option<Result<char, u16>> {
let u = match self.buf.take() {
Some(buf) => buf,
None => match self.iter.next() {
Some(u) => u,
None => return None,
},
};
if u < 0xD800 || 0xDFFF < u {
// not a surrogate
Some(Ok(unsafe { from_u32_unchecked(u as u32) }))
} else if u >= 0xDC00 {
// a trailing surrogate
Some(Err(u))
} else {
let u2 = match self.iter.next() {
Some(u2) => u2,
// eof
None => return Some(Err(u)),
};
if u2 < 0xDC00 || u2 > 0xDFFF {
// not a trailing surrogate so we're not a valid
// surrogate pair, so rewind to redecode u2 next time.
self.buf = Some(u2);
return Some(Err(u));
}
// all ok, so lets decode it.
let c = (((u - 0xD800) as u32) << 10 | (u2 - 0xDC00) as u32) + 0x1_0000;
Some(Ok(unsafe { from_u32_unchecked(c) }))
}
}
#[inline]
fn size_hint(&self) -> (usize, Option<usize>) {
let (low, high) = self.iter.size_hint();
// we could be entirely valid surrogates (2 elements per
// char), or entirely non-surrogates (1 element per char)
(low / 2, high)
}
}
/// `U+FFFD REPLACEMENT CHARACTER` (�) is used in Unicode to represent a decoding error.
/// It can occur, for example, when giving ill-formed UTF-8 bytes to
/// [`String::from_utf8_lossy`](../string/struct.String.html#method.from_utf8_lossy).
#[unstable(feature = "decode_utf16", reason = "recently added", issue = "27830")]
pub const REPLACEMENT_CHARACTER: char = '\u{FFFD}'; | /// |
findContentChildren.go | package main
import (
"fmt"
"sort"
)
/**
Assume you are an awesome parent and want to give your children some cookies. But, you should give each child at most one cookie.
Each child i has a greed factor gi, which is the minimum size of a cookie that the child will be content with; and each cookie j has a size sj.
If sj >= gi, we can assign the cookie j to the child i, and the child i will be content.
Your goal is to maximize the number of your content children and output the maximum number.
Note:
You may assume the greed factor is always positive.
You cannot assign more than one cookie to one child.
Example 1:
Input: [1,2,3], [1,1]
Output: 1
Explanation: You have 3 children and 2 cookies. The greed factors of 3 children are 1, 2, 3.
And even though you have 2 cookies, since their size is both 1, you could only make the child whose greed factor is 1 content.
You need to output 1.
Example 2:
Input: [1,2], [1,2,3]
Output: 2
Explanation: You have 2 children and 3 cookies. The greed factors of 2 children are 1, 2.
You have 3 cookies and their sizes are big enough to gratify all of the children,
You need to output 2.
*/
func findContentChildrenMy(g []int, s []int) int {
sortArr(g)
sortArr(s)
i := 0
for j := 0; i < len(g) && j < len(s); j++ {
if g[i] <= s[j] {
i++
}
}
return i
}
func sortArr(arr []int) |
func findContentChildren(g []int, s []int) int {
sort.Ints(g)
sort.Ints(s)
gi, si := 0, 0
for gi < len(g) && si < len(s) {
if g[gi] <= s[si] {
gi++
}
si++
}
return gi
}
func main() {
fmt.Println(findContentChildren([]int{10, 9, 8, 7}, []int{5, 6, 7}))
}
| {
for i := 0; i < len(arr)-1; i++ {
for j := i + 1; j < len(arr); j++ {
if arr[i] > arr[j] {
arr[i], arr[j] = arr[j], arr[i]
}
}
}
} |
group.go | // *** WARNING: this file was generated by the Pulumi Terraform Bridge (tfgen) Tool. ***
// *** Do not edit by hand unless you're certain you know what you are doing! ***
package resourcegroups
import (
"context"
"reflect"
"github.com/pkg/errors"
"github.com/pulumi/pulumi/sdk/v2/go/pulumi"
)
// Provides a Resource Group.
//
// ## Example Usage
//
// ```go
// package main
//
// import (
// "fmt"
//
// "github.com/pulumi/pulumi-aws/sdk/v3/go/aws/resourcegroups"
// "github.com/pulumi/pulumi/sdk/v2/go/pulumi"
// )
//
// func main() {
// pulumi.Run(func(ctx *pulumi.Context) error {
// _, err := resourcegroups.NewGroup(ctx, "test", &resourcegroups.GroupArgs{
// ResourceQuery: &resourcegroups.GroupResourceQueryArgs{
// Query: pulumi.String(fmt.Sprintf("%v%v%v%v%v%v%v%v%v%v%v%v", "{\n", " \"ResourceTypeFilters\": [\n", " \"AWS::EC2::Instance\"\n", " ],\n", " \"TagFilters\": [\n", " {\n", " \"Key\": \"Stage\",\n", " \"Values\": [\"Test\"]\n", " }\n", " ]\n", "}\n", "\n")),
// },
// })
// if err != nil {
// return err
// }
// return nil
// })
// }
// ```
//
// ## Import
//
// Resource groups can be imported using the `name`, e.g.
//
// ```sh
// $ pulumi import aws:resourcegroups/group:Group foo resource-group-name
// ```
type Group struct {
pulumi.CustomResourceState
// The ARN assigned by AWS for this resource group.
Arn pulumi.StringOutput `pulumi:"arn"`
// A description of the resource group.
Description pulumi.StringPtrOutput `pulumi:"description"`
// The resource group's name. A resource group name can have a maximum of 127 characters, including letters, numbers, hyphens, dots, and underscores. The name cannot start with `AWS` or `aws`.
Name pulumi.StringOutput `pulumi:"name"`
// A `resourceQuery` block. Resource queries are documented below.
ResourceQuery GroupResourceQueryOutput `pulumi:"resourceQuery"`
// Key-value map of resource tags
Tags pulumi.StringMapOutput `pulumi:"tags"`
}
// NewGroup registers a new resource with the given unique name, arguments, and options.
func | (ctx *pulumi.Context,
name string, args *GroupArgs, opts ...pulumi.ResourceOption) (*Group, error) {
if args == nil {
return nil, errors.New("missing one or more required arguments")
}
if args.ResourceQuery == nil {
return nil, errors.New("invalid value for required argument 'ResourceQuery'")
}
var resource Group
err := ctx.RegisterResource("aws:resourcegroups/group:Group", name, args, &resource, opts...)
if err != nil {
return nil, err
}
return &resource, nil
}
// GetGroup gets an existing Group resource's state with the given name, ID, and optional
// state properties that are used to uniquely qualify the lookup (nil if not required).
func GetGroup(ctx *pulumi.Context,
name string, id pulumi.IDInput, state *GroupState, opts ...pulumi.ResourceOption) (*Group, error) {
var resource Group
err := ctx.ReadResource("aws:resourcegroups/group:Group", name, id, state, &resource, opts...)
if err != nil {
return nil, err
}
return &resource, nil
}
// Input properties used for looking up and filtering Group resources.
type groupState struct {
// The ARN assigned by AWS for this resource group.
Arn *string `pulumi:"arn"`
// A description of the resource group.
Description *string `pulumi:"description"`
// The resource group's name. A resource group name can have a maximum of 127 characters, including letters, numbers, hyphens, dots, and underscores. The name cannot start with `AWS` or `aws`.
Name *string `pulumi:"name"`
// A `resourceQuery` block. Resource queries are documented below.
ResourceQuery *GroupResourceQuery `pulumi:"resourceQuery"`
// Key-value map of resource tags
Tags map[string]string `pulumi:"tags"`
}
type GroupState struct {
// The ARN assigned by AWS for this resource group.
Arn pulumi.StringPtrInput
// A description of the resource group.
Description pulumi.StringPtrInput
// The resource group's name. A resource group name can have a maximum of 127 characters, including letters, numbers, hyphens, dots, and underscores. The name cannot start with `AWS` or `aws`.
Name pulumi.StringPtrInput
// A `resourceQuery` block. Resource queries are documented below.
ResourceQuery GroupResourceQueryPtrInput
// Key-value map of resource tags
Tags pulumi.StringMapInput
}
func (GroupState) ElementType() reflect.Type {
return reflect.TypeOf((*groupState)(nil)).Elem()
}
type groupArgs struct {
// A description of the resource group.
Description *string `pulumi:"description"`
// The resource group's name. A resource group name can have a maximum of 127 characters, including letters, numbers, hyphens, dots, and underscores. The name cannot start with `AWS` or `aws`.
Name *string `pulumi:"name"`
// A `resourceQuery` block. Resource queries are documented below.
ResourceQuery GroupResourceQuery `pulumi:"resourceQuery"`
// Key-value map of resource tags
Tags map[string]string `pulumi:"tags"`
}
// The set of arguments for constructing a Group resource.
type GroupArgs struct {
// A description of the resource group.
Description pulumi.StringPtrInput
// The resource group's name. A resource group name can have a maximum of 127 characters, including letters, numbers, hyphens, dots, and underscores. The name cannot start with `AWS` or `aws`.
Name pulumi.StringPtrInput
// A `resourceQuery` block. Resource queries are documented below.
ResourceQuery GroupResourceQueryInput
// Key-value map of resource tags
Tags pulumi.StringMapInput
}
func (GroupArgs) ElementType() reflect.Type {
return reflect.TypeOf((*groupArgs)(nil)).Elem()
}
type GroupInput interface {
pulumi.Input
ToGroupOutput() GroupOutput
ToGroupOutputWithContext(ctx context.Context) GroupOutput
}
func (*Group) ElementType() reflect.Type {
return reflect.TypeOf((*Group)(nil))
}
func (i *Group) ToGroupOutput() GroupOutput {
return i.ToGroupOutputWithContext(context.Background())
}
func (i *Group) ToGroupOutputWithContext(ctx context.Context) GroupOutput {
return pulumi.ToOutputWithContext(ctx, i).(GroupOutput)
}
func (i *Group) ToGroupPtrOutput() GroupPtrOutput {
return i.ToGroupPtrOutputWithContext(context.Background())
}
func (i *Group) ToGroupPtrOutputWithContext(ctx context.Context) GroupPtrOutput {
return pulumi.ToOutputWithContext(ctx, i).(GroupPtrOutput)
}
type GroupPtrInput interface {
pulumi.Input
ToGroupPtrOutput() GroupPtrOutput
ToGroupPtrOutputWithContext(ctx context.Context) GroupPtrOutput
}
type groupPtrType GroupArgs
func (*groupPtrType) ElementType() reflect.Type {
return reflect.TypeOf((**Group)(nil))
}
func (i *groupPtrType) ToGroupPtrOutput() GroupPtrOutput {
return i.ToGroupPtrOutputWithContext(context.Background())
}
func (i *groupPtrType) ToGroupPtrOutputWithContext(ctx context.Context) GroupPtrOutput {
return pulumi.ToOutputWithContext(ctx, i).(GroupPtrOutput)
}
// GroupArrayInput is an input type that accepts GroupArray and GroupArrayOutput values.
// You can construct a concrete instance of `GroupArrayInput` via:
//
// GroupArray{ GroupArgs{...} }
type GroupArrayInput interface {
pulumi.Input
ToGroupArrayOutput() GroupArrayOutput
ToGroupArrayOutputWithContext(context.Context) GroupArrayOutput
}
type GroupArray []GroupInput
func (GroupArray) ElementType() reflect.Type {
return reflect.TypeOf(([]*Group)(nil))
}
func (i GroupArray) ToGroupArrayOutput() GroupArrayOutput {
return i.ToGroupArrayOutputWithContext(context.Background())
}
func (i GroupArray) ToGroupArrayOutputWithContext(ctx context.Context) GroupArrayOutput {
return pulumi.ToOutputWithContext(ctx, i).(GroupArrayOutput)
}
// GroupMapInput is an input type that accepts GroupMap and GroupMapOutput values.
// You can construct a concrete instance of `GroupMapInput` via:
//
// GroupMap{ "key": GroupArgs{...} }
type GroupMapInput interface {
pulumi.Input
ToGroupMapOutput() GroupMapOutput
ToGroupMapOutputWithContext(context.Context) GroupMapOutput
}
type GroupMap map[string]GroupInput
func (GroupMap) ElementType() reflect.Type {
return reflect.TypeOf((map[string]*Group)(nil))
}
func (i GroupMap) ToGroupMapOutput() GroupMapOutput {
return i.ToGroupMapOutputWithContext(context.Background())
}
func (i GroupMap) ToGroupMapOutputWithContext(ctx context.Context) GroupMapOutput {
return pulumi.ToOutputWithContext(ctx, i).(GroupMapOutput)
}
type GroupOutput struct {
*pulumi.OutputState
}
func (GroupOutput) ElementType() reflect.Type {
return reflect.TypeOf((*Group)(nil))
}
func (o GroupOutput) ToGroupOutput() GroupOutput {
return o
}
func (o GroupOutput) ToGroupOutputWithContext(ctx context.Context) GroupOutput {
return o
}
func (o GroupOutput) ToGroupPtrOutput() GroupPtrOutput {
return o.ToGroupPtrOutputWithContext(context.Background())
}
func (o GroupOutput) ToGroupPtrOutputWithContext(ctx context.Context) GroupPtrOutput {
return o.ApplyT(func(v Group) *Group {
return &v
}).(GroupPtrOutput)
}
type GroupPtrOutput struct {
*pulumi.OutputState
}
func (GroupPtrOutput) ElementType() reflect.Type {
return reflect.TypeOf((**Group)(nil))
}
func (o GroupPtrOutput) ToGroupPtrOutput() GroupPtrOutput {
return o
}
func (o GroupPtrOutput) ToGroupPtrOutputWithContext(ctx context.Context) GroupPtrOutput {
return o
}
type GroupArrayOutput struct{ *pulumi.OutputState }
func (GroupArrayOutput) ElementType() reflect.Type {
return reflect.TypeOf((*[]Group)(nil))
}
func (o GroupArrayOutput) ToGroupArrayOutput() GroupArrayOutput {
return o
}
func (o GroupArrayOutput) ToGroupArrayOutputWithContext(ctx context.Context) GroupArrayOutput {
return o
}
func (o GroupArrayOutput) Index(i pulumi.IntInput) GroupOutput {
return pulumi.All(o, i).ApplyT(func(vs []interface{}) Group {
return vs[0].([]Group)[vs[1].(int)]
}).(GroupOutput)
}
type GroupMapOutput struct{ *pulumi.OutputState }
func (GroupMapOutput) ElementType() reflect.Type {
return reflect.TypeOf((*map[string]Group)(nil))
}
func (o GroupMapOutput) ToGroupMapOutput() GroupMapOutput {
return o
}
func (o GroupMapOutput) ToGroupMapOutputWithContext(ctx context.Context) GroupMapOutput {
return o
}
func (o GroupMapOutput) MapIndex(k pulumi.StringInput) GroupOutput {
return pulumi.All(o, k).ApplyT(func(vs []interface{}) Group {
return vs[0].(map[string]Group)[vs[1].(string)]
}).(GroupOutput)
}
func init() {
pulumi.RegisterOutputType(GroupOutput{})
pulumi.RegisterOutputType(GroupPtrOutput{})
pulumi.RegisterOutputType(GroupArrayOutput{})
pulumi.RegisterOutputType(GroupMapOutput{})
}
| NewGroup |
oauth.go | // Copyright (c) Microsoft and contributors. All rights reserved.
//
// This source code is licensed under the MIT license found in the
// LICENSE file in the root directory of this source tree.
package iam
import (
"errors"
"log"
"net/http"
"net/url"
"os"
"github.com/Azure-Samples/azure-sdk-for-go-samples/helpers"
"github.com/Azure/go-autorest/autorest"
"github.com/Azure/go-autorest/autorest/adal"
"github.com/Azure/go-autorest/autorest/azure"
)
const (
samplesAppID = "bee3737f-b06f-444f-b3c3-5b0f3fce46ea"
azCLIclientID = "04b07795-8ddb-461a-bbee-02f9e1bf7b46"
)
var (
// for service principal and device
clientID string
oauthConfig *adal.OAuthConfig
armToken adal.OAuthTokenProvider
batchToken adal.OAuthTokenProvider
graphToken adal.OAuthTokenProvider
// for service principal
subscriptionID string
tenantID string
clientSecret string
// UseCLIclientID sets if the Azure CLI client iD should be used on device authentication
UseCLIclientID bool
)
// OAuthGrantType specifies which grant type to use.
type OAuthGrantType int
const (
// OAuthGrantTypeServicePrincipal for client credentials flow
OAuthGrantTypeServicePrincipal OAuthGrantType = iota
// OAuthGrantTypeDeviceFlow for device-auth flow
OAuthGrantTypeDeviceFlow
)
func init() {
err := parseArgs()
if err != nil {
log.Fatalf("failed to parse args: %s\n", err)
}
}
func parseArgs() error {
err := helpers.LoadEnvVars()
if err != nil {
return err
}
tenantID = os.Getenv("AZ_TENANT_ID")
if tenantID == "" {
log.Println("tenant id missing")
}
clientID = os.Getenv("AZ_CLIENT_ID")
if clientID == "" {
log.Println("client id missing")
}
clientSecret = os.Getenv("AZ_CLIENT_SECRET")
if clientSecret == "" {
log.Println("client secret missing")
}
if !(len(tenantID) > 0) || !(len(clientID) > 0) || !(len(clientSecret) > 0) {
return errors.New("tenant id, client id, and client secret must be specified via env var or flags")
}
oauthConfig, err = adal.NewOAuthConfig(azure.PublicCloud.ActiveDirectoryEndpoint, tenantID)
return err
}
// ClientID gets the client ID
func ClientID() string {
return clientID
}
// TenantID gets the client ID
func TenantID() string {
return tenantID
}
// ClientSecret gets the client secret
func ClientSecret() string {
return clientSecret
}
// AuthGrantType returns what kind of authentication is going to be used: device flow or service principal
func AuthGrantType() OAuthGrantType |
// GetResourceManagementToken gets an OAuth token for managing resources using the specified grant type.
func GetResourceManagementToken(grantType OAuthGrantType) (adal.OAuthTokenProvider, error) {
if armToken != nil {
return armToken, nil
}
token, err := getToken(grantType, azure.PublicCloud.ResourceManagerEndpoint)
if err == nil {
armToken = token
}
return token, err
}
const batchManagementEndpoint = "https://batch.core.windows.net/"
// GetBatchToken gets an OAuth token for Azure batch using the specified grant type.
func GetBatchToken(grantType OAuthGrantType) (adal.OAuthTokenProvider, error) {
if batchToken != nil {
return batchToken, nil
}
token, err := getToken(grantType, batchManagementEndpoint)
if err == nil {
batchToken = token
}
return token, err
}
// GetGraphToken gets an OAuth token for the graphrbac API using the specified grant type.
func GetGraphToken(grantType OAuthGrantType) (adal.OAuthTokenProvider, error) {
if graphToken != nil {
return graphToken, nil
}
token, err := getToken(grantType, azure.PublicCloud.GraphEndpoint)
if err == nil {
graphToken = token
}
return token, err
}
func getToken(grantType OAuthGrantType, endpoint string) (token adal.OAuthTokenProvider, err error) {
switch grantType {
case OAuthGrantTypeServicePrincipal:
token, err = getServicePrincipalToken(endpoint)
case OAuthGrantTypeDeviceFlow:
token, err = getDeviceToken(endpoint)
default:
log.Fatalln("invalid token type specified")
}
return
}
func getServicePrincipalToken(endpoint string) (adal.OAuthTokenProvider, error) {
return adal.NewServicePrincipalToken(
*oauthConfig,
clientID,
clientSecret,
endpoint)
}
func getDeviceToken(endpoint string) (adal.OAuthTokenProvider, error) {
sender := &http.Client{}
cliID := samplesAppID
if UseCLIclientID {
cliID = azCLIclientID
}
code, err := adal.InitiateDeviceAuth(
sender,
*oauthConfig,
cliID, // clientID
endpoint)
if err != nil {
log.Fatalf("%s: %v\n", "failed to initiate device auth", err)
}
log.Println(*code.Message)
return adal.WaitForUserCompletion(sender, code)
}
// GetKeyvaultToken gets an authorizer for the keyvault dataplane
func GetKeyvaultToken(grantType OAuthGrantType) (authorizer autorest.Authorizer, err error) {
config, err := adal.NewOAuthConfig(azure.PublicCloud.ActiveDirectoryEndpoint, tenantID)
updatedAuthorizeEndpoint, err := url.Parse("https://login.windows.net/" + tenantID + "/oauth2/token")
config.AuthorizeEndpoint = *updatedAuthorizeEndpoint
if err != nil {
return
}
switch grantType {
case OAuthGrantTypeServicePrincipal:
spt, err := adal.NewServicePrincipalToken(
*config,
clientID,
clientSecret,
"https://vault.azure.net")
if err != nil {
return authorizer, err
}
authorizer = autorest.NewBearerAuthorizer(spt)
case OAuthGrantTypeDeviceFlow:
sender := &http.Client{}
code, err := adal.InitiateDeviceAuth(
sender,
*config,
samplesAppID, // clientID
"https://vault.azure.net")
if err != nil {
log.Fatalf("%s: %v\n", "failed to initiate device auth", err)
}
log.Println(*code.Message)
spt, err := adal.WaitForUserCompletion(sender, code)
if err != nil {
return authorizer, err
}
authorizer = autorest.NewBearerAuthorizer(spt)
default:
log.Fatalln("invalid token type specified")
}
return
}
| {
if helpers.DeviceFlow() {
return OAuthGrantTypeDeviceFlow
}
return OAuthGrantTypeServicePrincipal
} |
common.py | # -*- coding: utf-8 -*-
# Copyright (C) 2014-2016 Andrey Antukh <[email protected]>
# Copyright (C) 2014-2016 Jesús Espino <[email protected]>
# Copyright (C) 2014-2016 David Barragán <[email protected]>
# Copyright (C) 2014-2016 Alejandro Alonso <[email protected]>
# This program is free software: you can redistribute it and/or modify
# it under the terms of the GNU Affero General Public License as
# published by the Free Software Foundation, either version 3 of the
# License, or (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU Affero General Public License for more details.
#
# You should have received a copy of the GNU Affero General Public License
# along with this program. If not, see <http://www.gnu.org/licenses/>.
import os.path, sys, os
BASE_DIR = os.path.dirname(os.path.dirname(__file__))
APPEND_SLASH = False
ALLOWED_HOSTS = ["*"]
ADMINS = (
("Admin", "[email protected]"),
)
DEBUG = False
DATABASES = {
"default": {
"ENGINE": "django.db.backends.postgresql",
"NAME": "taiga",
}
}
CACHES = {
"default": {
"BACKEND": "django.core.cache.backends.locmem.LocMemCache",
"LOCATION": "unique-snowflake"
}
}
PASSWORD_HASHERS = [
"django.contrib.auth.hashers.PBKDF2PasswordHasher",
]
# Default configuration for reverse proxy
USE_X_FORWARDED_HOST = True
SECURE_PROXY_SSL_HEADER = ("HTTP_X_FORWARDED_PROTOCOL", "https")
# Errors report configuration
SEND_BROKEN_LINK_EMAILS = True
IGNORABLE_404_ENDS = (".php", ".cgi")
IGNORABLE_404_STARTS = ("/phpmyadmin/",)
ATOMIC_REQUESTS = True
TIME_ZONE = "UTC"
LOGIN_URL="/auth/login/"
USE_TZ = True
USE_I18N = True
USE_L10N = True
# Language code for this installation. All choices can be found here:
# http://www.i18nguy.com/unicode/language-identifiers.html
LANGUAGE_CODE = 'en-us'
# Languages we provide translations for, out of the box.
LANGUAGES = [
#("af", "Afrikaans"), # Afrikaans
#("ar", "العربية"), # Arabic
#("ast", "Asturiano"), # Asturian
#("az", "Azərbaycan dili"), # Azerbaijani
#("bg", "Български"), # Bulgarian
#("be", "Беларуская"), # Belarusian
#("bn", "বাংলা"), # Bengali
#("br", "Bretón"), # Breton
#("bs", "Bosanski"), # Bosnian
("ca", "Català"), # Catalan
#("cs", "Čeština"), # Czech
#("cy", "Cymraeg"), # Welsh
#("da", "Dansk"), # Danish
("de", "Deutsch"), # German
#("el", "Ελληνικά"), # Greek
("en", "English (US)"), # English
#("en-au", "English (Australia)"), # Australian English
#("en-gb", "English (UK)"), # British English
#("eo", "esperanta"), # Esperanto
("es", "Español"), # Spanish
#("es-ar", "Español (Argentina)"), # Argentinian Spanish
#("es-mx", "Español (México)"), # Mexican Spanish
#("es-ni", "Español (Nicaragua)"), # Nicaraguan Spanish
#("es-ve", "Español (Venezuela)"), # Venezuelan Spanish
#("et", "Eesti"), # Estonian
#("eu", "Euskara"), # Basque
#("fa", "فارسی"), # Persian
("fi", "Suomi"), # Finnish
("fr", "Français"), # French
#("fy", "Frysk"), # Frisian
#("ga", "Irish"), # Irish
#("gl", "Galego"), # Galician
#("he", "עברית"), # Hebrew
#("hi", "हिन्दी"), # Hindi
#("hr", "Hrvatski"), # Croatian
#("hu", "Magyar"), # Hungarian
#("ia", "Interlingua"), # Interlingua
#("id", "Bahasa Indonesia"), # Indonesian
#("io", "IDO"), # Ido
#("is", "Íslenska"), # Icelandic
("it", "Italiano"), # Italian
#("ja", "日本語"), # Japanese
#("ka", "ქართული"), # Georgian
#("kk", "Қазақша"), # Kazakh
#("km", "ភាសាខ្មែរ"), # Khmer
#("kn", "ಕನ್ನಡ"), # Kannada
#("ko", "한국어"), # Korean
#("lb", "Lëtzebuergesch"), # Luxembourgish
#("lt", "Lietuvių"), # Lithuanian
#("lv", "Latviešu"), # Latvian
#("mk", "Македонски"), # Macedonian
#("ml", "മലയാളം"), # Malayalam
#("mn", "Монгол"), # Mongolian
#("mr", "मराठी"), # Marathi
#("my", "မြန်မာ"), # Burmese
("nb", "Norsk (bokmål)"), # Norwegian Bokmal
#("ne", "नेपाली"), # Nepali
("nl", "Nederlands"), # Dutch
#("nn", "Norsk (nynorsk)"), # Norwegian Nynorsk
#("os", "Ирон æвзаг"), # Ossetic
#("pa", "ਪੰਜਾਬੀ"), # Punjabi
("pl", "Polski"), # Polish
#("pt", "Português (Portugal)"), # Portuguese
("pt-br", "Português (Brasil)"), # Brazilian Portuguese
#("ro", "Română"), # Romanian
("ru", "Русский"), # Russian
#("sk", "Slovenčina"), # Slovak
#("sl", "Slovenščina"), # Slovenian
#("sq", "Shqip"), # Albanian
#("sr", "Српски"), # Serbian
#("sr-latn", "srpski"), # Serbian Latin
("sv", "Svenska"), # Swedish
#("sw", "Kiswahili"), # Swahili
#("ta", "தமிழ்"), # Tamil
#("te", "తెలుగు"), # Telugu
#("th", "ภาษาไทย"), # Thai
("tr", "Türkçe"), # Turkish
#("tt", "татар теле"), # Tatar
#("udm", "удмурт кыл"), # Udmurt
#("uk", "Українська"), # Ukrainian
#("ur", "اردو"), # Urdu
#("vi", "Tiếng Việt"), # Vietnamese
#("zh-hans", "中文(简体)"), # Simplified Chinese
("zh-hant", "中文(香港)"), # Traditional Chinese
]
# Languages using BiDi (right-to-left) layout
LANGUAGES_BIDI = ["he", "ar", "fa", "ur"]
LOCALE_PATHS = (
os.path.join(BASE_DIR, "locale"),
os.path.join(BASE_DIR, "taiga", "locale"),
)
SITES = {
"api": {"domain": "localhost:8000", "scheme": "http", "name": "api"},
"front": {"domain": "localhost:9001", "scheme": "http", "name": "front"},
}
SITE_ID = "api"
# Session configuration (only used for admin)
SESSION_ENGINE = "django.contrib.sessions.backends.db"
SESSION_COOKIE_AGE = 1209600 # (2 weeks)
# MAIL OPTIONS
DEFAULT_FROM_EMAIL = "[email protected]"
EMAIL_BACKEND = "django.core.mail.backends.console.EmailBackend"
DJMAIL_REAL_BACKEND = "django.core.mail.backends.console.EmailBackend"
DJMAIL_SEND_ASYNC = True
DJMAIL_MAX_RETRY_NUMBER = 3
DJMAIL_TEMPLATE_EXTENSION = "jinja"
# Events backend
EVENTS_PUSH_BACKEND = "taiga.events.backends.postgresql.EventsPushBackend"
# EVENTS_PUSH_BACKEND = "taiga.events.backends.rabbitmq.EventsPushBackend"
# EVENTS_PUSH_BACKEND_OPTIONS = {"url": "//guest:[email protected]/"}
# Message System
MESSAGE_STORAGE = "django.contrib.messages.storage.session.SessionStorage"
# The absolute url is mandatory because attachments
# urls depends on it. On production should be set
# something like https://media.taiga.io/
MEDIA_URL = "http://localhost:8000/media/"
STATIC_URL = "http://localhost:8000/static/"
# Static configuration.
MEDIA_ROOT = os.path.join(BASE_DIR, "media")
STATIC_ROOT = os.path.join(BASE_DIR, "static")
STATICFILES_FINDERS = [
"django.contrib.staticfiles.finders.FileSystemFinder",
"django.contrib.staticfiles.finders.AppDirectoriesFinder",
]
STATICFILES_DIRS = (
# Put strings here, like "/home/html/static" or "C:/www/django/static".
# Don't forget to use absolute paths, not relative paths.
)
# Defautl storage
DEFAULT_FILE_STORAGE = "taiga.base.storage.FileSystemStorage"
SECRET_KEY = "aw3+t2r(8(0kkrhg8)gx6i96v5^kv%6cfep9wxfom0%7dy0m9e"
TEMPLATES = [
{
"BACKEND": "django_jinja.backend.Jinja2",
"DIRS": [
os.path.join(BASE_DIR, "templates"),
],
"APP_DIRS": True,
"OPTIONS": {
'context_processors': [
"django.contrib.auth.context_processors.auth",
"django.template.context_processors.request",
"django.template.context_processors.i18n",
"django.template.context_processors.media",
"django.template.context_processors.static",
"django.template.context_processors.tz",
"django.contrib.messages.context_processors.messages",
],
"match_extension": ".jinja",
}
},
{
"BACKEND": "django.template.backends.django.DjangoTemplates",
"DIRS": [
os.path.join(BASE_DIR, "templates"),
],
"APP_DIRS": True,
"OPTIONS": {
'context_processors': [
"django.contrib.auth.context_processors.auth",
"django.template.context_processors.request",
"django.template.context_processors.i18n",
"django.template.context_processors.media",
"django.template.context_processors.static",
"django.template.context_processors.tz",
"django.contrib.messages.context_processors.messages",
],
}
},
]
MIDDLEWARE_CLASSES = [
"taiga.base.middleware.cors.CoorsMiddleware",
"taiga.events.middleware.SessionIDMiddleware",
# Common middlewares
"django.middleware.common.CommonMiddleware",
"django.middleware.locale.LocaleMiddleware",
# Only needed by django admin
"django.contrib.sessions.middleware.SessionMiddleware",
"django.contrib.auth.middleware.AuthenticationMiddleware",
"django.contrib.messages.middleware.MessageMiddleware",
]
ROOT_URLCONF = "taiga.urls"
INSTALLED_APPS = [
"django.contrib.auth",
"django.contrib.contenttypes",
"django.contrib.sessions",
"django.contrib.messages",
"django.contrib.admin",
"django.contrib.staticfiles",
"django.contrib.sitemaps",
"taiga.base",
"taiga.base.api",
"taiga.locale",
"taiga.events",
"taiga.front",
"taiga.users",
"taiga.userstorage",
"taiga.external_apps",
"taiga.projects",
"taiga.projects.references",
"taiga.projects.custom_attributes",
"taiga.projects.history",
"taiga.projects.notifications",
"taiga.projects.attachments",
"taiga.projects.likes",
"taiga.projects.votes",
"taiga.projects.milestones",
"taiga.projects.epics",
"taiga.projects.userstories",
"taiga.projects.tasks",
"taiga.projects.issues",
"taiga.projects.wiki",
"taiga.searches",
"taiga.timeline",
"taiga.mdrender",
"taiga.export_import",
"taiga.feedback",
"taiga.stats",
"taiga.hooks.github",
"taiga.hooks.gitlab",
"taiga.hooks.bitbucket",
"taiga.hooks.gogs",
"taiga.webhooks",
"djmail",
"django_jinja",
"django_jinja.contrib._humanize",
"sr",
"easy_thumbnails",
"raven.contrib.django.raven_compat",
]
WSGI_APPLICATION = "taiga.wsgi.application"
LOGGING = {
"version": 1,
"disable_existing_loggers": True,
"filters": {
"require_debug_false": {
"()": "django.utils.log.RequireDebugFalse"
}
},
"formatters": {
"complete": {
"format": "%(levelname)s:%(asctime)s:%(module)s %(message)s"
},
"simple": {
"format": "%(levelname)s:%(asctime)s: %(message)s"
},
"null": {
"format": "%(message)s",
},
},
"handlers": {
"null": {
"level":"DEBUG",
"class":"logging.NullHandler",
}, | },
"mail_admins": {
"level": "ERROR",
"filters": ["require_debug_false"],
"class": "django.utils.log.AdminEmailHandler",
}
},
"loggers": {
"django": {
"handlers":["null"],
"propagate": True,
"level":"INFO",
},
"django.request": {
"handlers": ["mail_admins", "console"],
"level": "ERROR",
"propagate": False,
},
"taiga.export_import": {
"handlers": ["mail_admins", "console"],
"level": "ERROR",
"propagate": False,
},
"taiga": {
"handlers": ["console"],
"level": "DEBUG",
"propagate": False,
}
}
}
AUTH_USER_MODEL = "users.User"
FORMAT_MODULE_PATH = "taiga.base.formats"
DATE_INPUT_FORMATS = (
"%Y-%m-%d", "%m/%d/%Y", "%d/%m/%Y", "%b %d %Y",
"%b %d, %Y", "%d %b %Y", "%d %b, %Y", "%B %d %Y",
"%B %d, %Y", "%d %B %Y", "%d %B, %Y"
)
# Authentication settings (only for django admin)
AUTHENTICATION_BACKENDS = (
"django.contrib.auth.backends.ModelBackend", # default
)
MAX_AGE_AUTH_TOKEN = None
MAX_AGE_CANCEL_ACCOUNT = 30 * 24 * 60 * 60 # 30 days in seconds
REST_FRAMEWORK = {
"DEFAULT_AUTHENTICATION_CLASSES": (
# Mainly used by taiga-front
"taiga.auth.backends.Token",
# Mainly used for api debug.
"taiga.auth.backends.Session",
# Application tokens auth
"taiga.external_apps.auth_backends.Token",
),
"DEFAULT_THROTTLE_CLASSES": (
"taiga.base.throttling.AnonRateThrottle",
"taiga.base.throttling.UserRateThrottle"
),
"DEFAULT_THROTTLE_RATES": {
"anon": None,
"user": None,
"import-mode": None,
"import-dump-mode": "1/minute",
"create-memberships": None
},
"FILTER_BACKEND": "taiga.base.filters.FilterBackend",
"EXCEPTION_HANDLER": "taiga.base.exceptions.exception_handler",
"PAGINATE_BY": 30,
"PAGINATE_BY_PARAM": "page_size",
"MAX_PAGINATE_BY": 1000,
"DATETIME_FORMAT": "%Y-%m-%dT%H:%M:%S%z"
}
# Extra expose header related to Taiga APP (see taiga.base.middleware.cors=)
APP_EXTRA_EXPOSE_HEADERS = [
"taiga-info-total-opened-milestones",
"taiga-info-total-closed-milestones",
"taiga-info-project-memberships",
"taiga-info-project-is-private",
"taiga-info-order-updated"
]
DEFAULT_PROJECT_TEMPLATE = "scrum"
PUBLIC_REGISTER_ENABLED = False
# None or [] values in USER_EMAIL_ALLOWED_DOMAINS means allow any domain
USER_EMAIL_ALLOWED_DOMAINS = None
SEARCHES_MAX_RESULTS = 150
SOUTH_MIGRATION_MODULES = {
'easy_thumbnails': 'easy_thumbnails.south_migrations',
}
THN_AVATAR_SIZE = 80 # 80x80 pixels
THN_AVATAR_BIG_SIZE = 300 # 300x300 pixels
THN_LOGO_SMALL_SIZE = 80 # 80x80 pixels
THN_LOGO_BIG_SIZE = 300 # 300x300 pixels
THN_TIMELINE_IMAGE_SIZE = 640 # 640x??? pixels
THN_CARD_IMAGE_WIDTH = 300 # 300 pixels
THN_CARD_IMAGE_HEIGHT = 200 # 200 pixels
THN_AVATAR_SMALL = "avatar"
THN_AVATAR_BIG = "big-avatar"
THN_LOGO_SMALL = "logo-small"
THN_LOGO_BIG = "logo-big"
THN_ATTACHMENT_TIMELINE = "timeline-image"
THN_ATTACHMENT_CARD = "card-image"
THUMBNAIL_ALIASES = {
"": {
THN_AVATAR_SMALL: {"size": (THN_AVATAR_SIZE, THN_AVATAR_SIZE), "crop": True},
THN_AVATAR_BIG: {"size": (THN_AVATAR_BIG_SIZE, THN_AVATAR_BIG_SIZE), "crop": True},
THN_LOGO_SMALL: {"size": (THN_LOGO_SMALL_SIZE, THN_LOGO_SMALL_SIZE), "crop": True},
THN_LOGO_BIG: {"size": (THN_LOGO_BIG_SIZE, THN_LOGO_BIG_SIZE), "crop": True},
THN_ATTACHMENT_TIMELINE: {"size": (THN_TIMELINE_IMAGE_SIZE, 0), "crop": True},
THN_ATTACHMENT_CARD: {"size": (THN_CARD_IMAGE_WIDTH, THN_CARD_IMAGE_HEIGHT), "crop": True},
},
}
TAGS_PREDEFINED_COLORS = ["#fce94f", "#edd400", "#c4a000", "#8ae234",
"#73d216", "#4e9a06", "#d3d7cf", "#fcaf3e",
"#f57900", "#ce5c00", "#729fcf", "#3465a4",
"#204a87", "#888a85", "#ad7fa8", "#75507b",
"#5c3566", "#ef2929", "#cc0000", "#a40000",
"#2e3436",]
# Feedback module settings
FEEDBACK_ENABLED = True
FEEDBACK_EMAIL = "[email protected]"
# Stats module settings
STATS_ENABLED = False
STATS_CACHE_TIMEOUT = 60*60 # In second
# 0 notifications will work in a synchronous way
# >0 an external process will check the pending notifications and will send them
# collapsed during that interval
CHANGE_NOTIFICATIONS_MIN_INTERVAL = 0 #seconds
# List of functions called for filling correctly the ProjectModulesConfig associated to a project
# This functions should receive a Project parameter and return a dict with the desired configuration
PROJECT_MODULES_CONFIGURATORS = {
"github": "taiga.hooks.github.services.get_or_generate_config",
"gitlab": "taiga.hooks.gitlab.services.get_or_generate_config",
"bitbucket": "taiga.hooks.bitbucket.services.get_or_generate_config",
"gogs": "taiga.hooks.gogs.services.get_or_generate_config",
}
BITBUCKET_VALID_ORIGIN_IPS = ["131.103.20.165", "131.103.20.166", "104.192.143.192/28", "104.192.143.208/28"]
GITLAB_VALID_ORIGIN_IPS = []
EXPORTS_TTL = 60 * 60 * 24 # 24 hours
CELERY_ENABLED = False
WEBHOOKS_ENABLED = False
# If is True /front/sitemap.xml show a valid sitemap of taiga-front client
FRONT_SITEMAP_ENABLED = False
FRONT_SITEMAP_CACHE_TIMEOUT = 24*60*60 # In second
EXTRA_BLOCKING_CODES = []
MAX_PRIVATE_PROJECTS_PER_USER = None # None == no limit
MAX_PUBLIC_PROJECTS_PER_USER = None # None == no limit
MAX_MEMBERSHIPS_PRIVATE_PROJECTS = None # None == no limit
MAX_MEMBERSHIPS_PUBLIC_PROJECTS = None # None == no limit
MAX_PENDING_MEMBERSHIPS = 30 # Max number of unconfirmed memberships in a project
from .sr import *
# NOTE: DON'T INSERT MORE SETTINGS AFTER THIS LINE
TEST_RUNNER="django.test.runner.DiscoverRunner"
if "test" in sys.argv:
print ("\033[1;91mNo django tests.\033[0m")
print ("Try: \033[1;33mpy.test\033[0m")
sys.exit(0) | "console":{
"level":"DEBUG",
"class":"logging.StreamHandler",
"formatter": "simple", |
peer_test.go | // Copyright 2015 CoreOS, Inc.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
package etcdhttp
import (
"encoding/json"
"io/ioutil"
"net/http"
"net/http/httptest"
"path"
"testing"
"github.com/coreos/etcd/etcdserver"
"github.com/coreos/etcd/pkg/testutil"
"github.com/coreos/etcd/rafthttp"
)
// TestNewPeerHandler tests that NewPeerHandler returns a handler that
// handles raft-prefix requests well.
func TestNewPeerHandlerOnRaftPrefix(t *testing.T) {
h := http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
w.Write([]byte("test data"))
})
ph := newPeerHandler(&fakeCluster{}, h, nil)
srv := httptest.NewServer(ph)
defer srv.Close()
tests := []string{
rafthttp.RaftPrefix,
rafthttp.RaftPrefix + "/hello",
}
for i, tt := range tests {
resp, err := http.Get(srv.URL + tt)
if err != nil {
t.Fatalf("unexpected http.Get error: %v", err)
}
body, err := ioutil.ReadAll(resp.Body)
if err != nil {
t.Fatalf("unexpected ioutil.ReadAll error: %v", err)
}
if w := "test data"; string(body) != w {
t.Errorf("#%d: body = %s, want %s", i, body, w)
}
}
}
func TestServeMembersFails(t *testing.T) {
tests := []struct {
method string
wcode int
}{
{
"POST",
http.StatusMethodNotAllowed,
},
{
"DELETE",
http.StatusMethodNotAllowed,
},
{
"BAD",
http.StatusMethodNotAllowed,
},
}
for i, tt := range tests {
rw := httptest.NewRecorder()
h := &peerMembersHandler{cluster: nil}
h.ServeHTTP(rw, &http.Request{Method: tt.method})
if rw.Code != tt.wcode {
t.Errorf("#%d: code=%d, want %d", i, rw.Code, tt.wcode)
}
}
}
func TestServeMembersGet(t *testing.T) | {
memb1 := etcdserver.Member{ID: 1, Attributes: etcdserver.Attributes{ClientURLs: []string{"http://localhost:8080"}}}
memb2 := etcdserver.Member{ID: 2, Attributes: etcdserver.Attributes{ClientURLs: []string{"http://localhost:8081"}}}
cluster := &fakeCluster{
id: 1,
members: map[uint64]*etcdserver.Member{1: &memb1, 2: &memb2},
}
h := &peerMembersHandler{cluster: cluster}
msb, err := json.Marshal([]etcdserver.Member{memb1, memb2})
if err != nil {
t.Fatal(err)
}
wms := string(msb) + "\n"
tests := []struct {
path string
wcode int
wct string
wbody string
}{
{peerMembersPrefix, http.StatusOK, "application/json", wms},
{path.Join(peerMembersPrefix, "bad"), http.StatusBadRequest, "text/plain; charset=utf-8", "bad path\n"},
}
for i, tt := range tests {
req, err := http.NewRequest("GET", testutil.MustNewURL(t, tt.path).String(), nil)
if err != nil {
t.Fatal(err)
}
rw := httptest.NewRecorder()
h.ServeHTTP(rw, req)
if rw.Code != tt.wcode {
t.Errorf("#%d: code=%d, want %d", i, rw.Code, tt.wcode)
}
if gct := rw.Header().Get("Content-Type"); gct != tt.wct {
t.Errorf("#%d: content-type = %s, want %s", i, gct, tt.wct)
}
if rw.Body.String() != tt.wbody {
t.Errorf("#%d: body = %s, want %s", i, rw.Body.String(), tt.wbody)
}
gcid := rw.Header().Get("X-Etcd-Cluster-ID")
wcid := cluster.ID().String()
if gcid != wcid {
t.Errorf("#%d: cid = %s, want %s", i, gcid, wcid)
}
}
} |
|
package.py | # Copyright 2013-2022 Lawrence Livermore National Security, LLC and other
# Spack Project Developers. See the top-level COPYRIGHT file for details.
# | # SPDX-License-Identifier: (Apache-2.0 OR MIT)
from spack.package import *
class PyNeurolab(PythonPackage):
"""Simple and powerfull neural network library for python"""
homepage = "http://neurolab.googlecode.com/"
pypi = "neurolab/neurolab-0.3.5.tar.gz"
version('0.3.5', sha256='96ec311988383c63664f3325668f27c30561cf4349e3bc5420665c042a3b9191')
depends_on('py-setuptools', type='build')
depends_on('py-numpy', type=('build', 'run')) | |
resources.rs | #[derive(Default, Debug, Clone, Eq, PartialEq, Serialize, Deserialize)]
pub struct Resources {
pub cpus: u32,
}
impl Resources {
#[inline]
pub fn cpus(&self) -> u32 {
self.cpus
}
pub fn add(&mut self, resources: &Resources) {
self.cpus += resources.cpus;
}
pub fn remove(&mut self, resources: &Resources) {
assert!(self.cpus >= resources.cpus);
self.cpus -= resources.cpus;
}
pub fn difference(&self, resources: &Resources) -> Resources {
assert!(self.cpus >= resources.cpus);
Resources {
cpus: self.cpus - resources.cpus,
}
}
pub fn | (reader: &::common_capnp::resources::Reader) -> Self {
Resources {
cpus: reader.get_n_cpus(),
}
}
pub fn to_capnp(&self, builder: &mut ::common_capnp::resources::Builder) {
builder.set_n_cpus(self.cpus);
}
#[inline]
pub fn is_subset_of(&self, resources: &Resources) -> bool {
self.cpus <= resources.cpus
}
}
| from_capnp |
component_events.py | """
The events around component lifecycle creation.
"""
from typing import Generic
from ..internal_.identity_types import (
ParticipantId, ComponentId,
)
from ..internal_.bus_types import (
EventBus, EventId, EventCallback,
ListenerSetup,
)
from ..util.memory import T
from ..util.messages import UserMessage
# ---------------------------------------------------------------------------
# Note: not "core".
EVENT_ID_REQUEST_NEW_COMPONENT = EventId('petronia.registrar/request-new-component')
class RequestNewComponentEvent(Generic[T]):
"""
Asks the component factory to create a new instance. The target of the
event is the component factory, which will be called with the request_id
to allow the called-back target to know which component was created.
"""
__slots__ = ('_obj', '_target_id', '_request_id',)
def __init__(
self, construction_obj: T,
callback_target_id: ParticipantId, request_id: int
) -> None:
self._obj = construction_obj
self._target_id = callback_target_id
self._request_id = request_id
@property
def construction_obj(self) -> T:
"""Object for the category's factory to create the component."""
return self._obj
@property
def callback_target_id(self) -> ParticipantId:
"""
The target that will be notified of the created component.
"""
return self._target_id
@property
def request_id(self) -> int:
"""
An identifier that tells the target which category creation
this corresponds to.
"""
return self._request_id
def as_request_new_component_listener(
callback: EventCallback[RequestNewComponentEvent[T]]
) -> ListenerSetup[RequestNewComponentEvent[T]]:
"""Listener setup for RequestNewComponentEvent"""
return (EVENT_ID_REQUEST_NEW_COMPONENT, callback,)
def send_request_new_component(
bus: EventBus, category_target_id: ParticipantId, construction_obj: T,
callback_target_id: ParticipantId, request_id: int
) -> None:
"""
Request for a new instance of a category.
"""
bus.trigger(
EVENT_ID_REQUEST_NEW_COMPONENT,
category_target_id,
RequestNewComponentEvent(
construction_obj, callback_target_id, request_id
)
)
# ---------------------------------------------------------------------------
EVENT_ID_COMPONENT_CREATED = EventId('petronia.registrar/component-created')
class ComponentCreatedEvent:
"""
Reports that a component was created.
"""
__slots__ = ('__request_id', '__created_id')
def __init__(self, created_id: ComponentId, request_id: int):
self.__created_id = created_id
self.__request_id = request_id
@property
def created_id(self) -> ComponentId:
"""ID of the component created by the request."""
return self.__created_id
@property
def request_id(self) -> int:
"""Request ID that initiated the creation. Specific to the creator."""
return self.__request_id
def as_component_created_listener(
callback: EventCallback[ComponentCreatedEvent]
) -> ListenerSetup[ComponentCreatedEvent]:
"""Listener setup for ComponentCreatedEvent"""
return (EVENT_ID_COMPONENT_CREATED, callback,)
def send_component_created_event(
bus: EventBus,
request_event: RequestNewComponentEvent[T],
created_id: ComponentId,
) -> None:
bus.trigger(
EVENT_ID_COMPONENT_CREATED,
request_event.callback_target_id,
ComponentCreatedEvent(created_id, request_event.request_id)
)
# ---------------------------------------------------------------------------
EVENT_ID_COMPONENT_CREATION_FAILED = EventId('petronia.registrar/component-create-failed')
class ComponentCreationFailedEvent:
"""
Reports that a component creation attempt failed.
""" | __slots__ = ('__request_id', '__category', '__error_msg',)
def __init__(
self, category: str, request_id: int,
error_msg: UserMessage
):
self.__request_id = request_id
self.__category = category
self.__error_msg = error_msg
@property
def request_id(self) -> int:
"""Request ID that initiated the creation. Specific to the creator."""
return self.__request_id
@property
def category(self) -> str:
"""The requested category to create."""
return self.__category
@property
def error_message(self) -> UserMessage:
"""The description of the error."""
return self.__error_msg
def as_component_creation_failed_listener(
callback: EventCallback[ComponentCreationFailedEvent]
) -> ListenerSetup[ComponentCreationFailedEvent]:
"""Listener setup for ComponentCreationFailedEvent"""
return (EVENT_ID_COMPONENT_CREATION_FAILED, callback,)
def send_component_creation_failed_event(
bus: EventBus,
request_event: RequestNewComponentEvent[T],
category: str,
error_message: UserMessage
) -> None:
bus.trigger(
EVENT_ID_COMPONENT_CREATION_FAILED,
request_event.callback_target_id,
ComponentCreationFailedEvent(
category, request_event.request_id,
error_message
)
) | |
model_saver.py | import os
import torch
import torch.nn as nn
from collections import deque
from onmt.utils.logging import logger
from copy import deepcopy
def build_model_saver(model_opt, opt, model, fields, optim):
model_saver = ModelSaver(opt.save_model,
model,
model_opt,
fields,
optim,
opt.keep_checkpoint)
return model_saver
class ModelSaverBase(object):
"""Base class for model saving operations
Inherited classes must implement private methods:
* `_save`
* `_rm_checkpoint
"""
def __init__(self, base_path, model, model_opt, fields, optim,
keep_checkpoint=-1):
self.base_path = base_path
self.model = model
self.model_opt = model_opt
self.fields = fields
self.optim = optim
self.last_saved_step = None
self.keep_checkpoint = keep_checkpoint
if keep_checkpoint > 0:
self.checkpoint_queue = deque([], maxlen=keep_checkpoint)
def save(self, step, moving_average=None):
"""Main entry point for model saver
It wraps the `_save` method with checks and apply `keep_checkpoint`
related logic
"""
if self.keep_checkpoint == 0 or step == self.last_saved_step:
return
if moving_average:
save_model = deepcopy(self.model)
for avg, param in zip(moving_average, save_model.parameters()):
param.data.copy_(avg.data)
else:
save_model = self.model
chkpt, chkpt_name = self._save(step, save_model)
self.last_saved_step = step
if moving_average:
del save_model
if self.keep_checkpoint > 0:
if len(self.checkpoint_queue) == self.checkpoint_queue.maxlen:
todel = self.checkpoint_queue.popleft()
self._rm_checkpoint(todel)
self.checkpoint_queue.append(chkpt_name)
def _save(self, step):
"""Save a resumable checkpoint.
Args:
step (int): step number
Returns:
(object, str):
* checkpoint: the saved object
* checkpoint_name: name (or path) of the saved checkpoint
"""
raise NotImplementedError()
def _rm_checkpoint(self, name):
"""Remove a checkpoint
Args:
name(str): name that indentifies the checkpoint
(it may be a filepath)
"""
raise NotImplementedError()
class ModelSaver(ModelSaverBase):
"""Simple model saver to filesystem"""
def _save(self, step, model):
|
def _rm_checkpoint(self, name):
os.remove(name)
| real_model = (model.module
if isinstance(model, nn.DataParallel)
else model)
real_generator = (real_model.generator.module
if isinstance(real_model.generator, nn.DataParallel)
else real_model.generator)
model_state_dict = real_model.state_dict()
model_state_dict = {k: v for k, v in model_state_dict.items()
if 'generator' not in k}
generator_state_dict = real_generator.state_dict()
# NOTE: We need to trim the vocab to remove any unk tokens that
# were not originally here.
vocab = deepcopy(self.fields)
if hasattr(model.encoder, 'is_graph_encoder'):
sides = ["src", "node1", "node2", "tgt"]
else:
sides = ["src", "tgt"]
for side in sides:
keys_to_pop = []
if hasattr(vocab[side], "fields"):
unk_token = vocab[side].fields[0][1].vocab.itos[0]
for key, value in vocab[side].fields[0][1].vocab.stoi.items():
if value == 0 and key != unk_token:
keys_to_pop.append(key)
for key in keys_to_pop:
vocab[side].fields[0][1].vocab.stoi.pop(key, None)
checkpoint = {
'model': model_state_dict,
'generator': generator_state_dict,
'vocab': vocab,
'opt': self.model_opt,
'optim': self.optim.state_dict(),
}
logger.info("Saving checkpoint %s_step_%d.pt" % (self.base_path, step))
checkpoint_path = '%s_step_%d.pt' % (self.base_path, step)
torch.save(checkpoint, checkpoint_path)
return checkpoint, checkpoint_path |
test_calculate.py | # CODING-STYLE CHECKS:
# pycodestyle test_calculate.py
import os
import json
from io import StringIO
import tempfile
import copy
import six
import pytest
import numpy as np
import pandas as pd
from taxcalc import Policy, Records, Calculator, Behavior, Consumption
RAWINPUTFILE_FUNITS = 4
RAWINPUTFILE_YEAR = 2015
RAWINPUTFILE_CONTENTS = (
'RECID,MARS\n'
'1,2\n'
'2,1\n'
'3,4\n'
'4,3\n'
)
@pytest.fixture(scope='module', name='rawinputfile')
def fixture_rawinputfile():
"""
Temporary input file that contains the minimum required input varaibles.
"""
ifile = tempfile.NamedTemporaryFile(mode='a', delete=False)
ifile.write(RAWINPUTFILE_CONTENTS)
ifile.close()
# must close and then yield for Windows platform
yield ifile
if os.path.isfile(ifile.name):
try:
os.remove(ifile.name)
except OSError:
pass # sometimes we can't remove a generated temporary file
@pytest.fixture(scope='module', name='policyfile')
def fixture_policyfile():
txt = """{"_almdep": {"value": [7150, 7250, 7400]},
"_almsep": {"value": [40400, 41050]},
"_rt5": {"value": [0.33 ]},
"_rt7": {"value": [0.396]}}"""
f = tempfile.NamedTemporaryFile(mode="a", delete=False)
f.write(txt + "\n")
f.close()
# Must close and then yield for Windows platform
yield f
os.remove(f.name)
def test_make_calculator(cps_subsample):
syr = 2014
pol = Policy(start_year=syr, num_years=9)
assert pol.current_year == syr
rec = Records.cps_constructor(data=cps_subsample, no_benefits=True)
consump = Consumption()
consump.update_consumption({syr: {'_MPC_e20400': [0.05]}})
assert consump.current_year == Consumption.JSON_START_YEAR
calc = Calculator(policy=pol, records=rec,
consumption=consump, behavior=Behavior())
assert calc.current_year == syr
assert calc.records_current_year() == syr
# test incorrect Calculator instantiation:
with pytest.raises(ValueError):
Calculator(policy=None, records=rec)
with pytest.raises(ValueError):
Calculator(policy=pol, records=None)
with pytest.raises(ValueError):
Calculator(policy=pol, records=rec, behavior=list())
with pytest.raises(ValueError):
Calculator(policy=pol, records=rec, consumption=list())
def | (cps_subsample):
pol = Policy()
rec = Records.cps_constructor(data=cps_subsample, no_benefits=True)
calc1 = Calculator(policy=pol, records=rec)
calc2 = copy.deepcopy(calc1)
assert isinstance(calc2, Calculator)
def test_make_calculator_with_policy_reform(cps_subsample):
rec = Records.cps_constructor(data=cps_subsample, no_benefits=True)
year = rec.current_year
# create a Policy object and apply a policy reform
pol = Policy()
reform = {2013: {'_II_em': [4000], '_II_em_cpi': False,
'_STD_Aged': [[1600, 1300, 1300, 1600, 1600]],
'_STD_Aged_cpi': False}}
pol.implement_reform(reform)
# create a Calculator object using this policy reform
calc = Calculator(policy=pol, records=rec)
# check that Policy object embedded in Calculator object is correct
assert calc.current_year == year
assert calc.policy_param('II_em') == 4000
assert np.allclose(calc.policy_param('_II_em'),
np.array([4000] * Policy.DEFAULT_NUM_YEARS))
exp_STD_Aged = [[1600, 1300, 1300,
1600, 1600]] * Policy.DEFAULT_NUM_YEARS
assert np.allclose(calc.policy_param('_STD_Aged'),
np.array(exp_STD_Aged))
assert np.allclose(calc.policy_param('STD_Aged'),
np.array([1600, 1300, 1300, 1600, 1600]))
def test_make_calculator_with_multiyear_reform(cps_subsample):
rec = Records.cps_constructor(data=cps_subsample, no_benefits=True)
year = rec.current_year
# create a Policy object and apply a policy reform
pol = Policy()
reform = {2015: {}, 2016: {}}
reform[2015]['_II_em'] = [5000, 6000] # reform values for 2015 and 2016
reform[2015]['_II_em_cpi'] = False
reform[2016]['_STD_Aged'] = [[1600, 1300, 1600, 1300, 1600]]
pol.implement_reform(reform)
# create a Calculator object using this policy-reform
calc = Calculator(policy=pol, records=rec)
# check that Policy object embedded in Calculator object is correct
assert pol.num_years == Policy.DEFAULT_NUM_YEARS
assert calc.current_year == year
assert calc.policy_param('II_em') == 3950
exp_II_em = [3900, 3950, 5000] + [6000] * (Policy.DEFAULT_NUM_YEARS - 3)
assert np.allclose(calc.policy_param('_II_em'),
np.array(exp_II_em))
calc.increment_year()
calc.increment_year()
assert calc.current_year == 2016
assert np.allclose(calc.policy_param('STD_Aged'),
np.array([1600, 1300, 1600, 1300, 1600]))
def test_calculator_advance_to_year(cps_subsample):
rec = Records.cps_constructor(data=cps_subsample, no_benefits=True)
pol = Policy()
calc = Calculator(policy=pol, records=rec)
calc.advance_to_year(2016)
assert calc.current_year == 2016
with pytest.raises(ValueError):
calc.advance_to_year(2015)
def test_make_calculator_raises_on_no_policy(cps_subsample):
rec = Records.cps_constructor(data=cps_subsample, no_benefits=True)
with pytest.raises(ValueError):
Calculator(records=rec)
def test_calculator_mtr(cps_subsample):
rec = Records.cps_constructor(data=cps_subsample, no_benefits=True)
calcx = Calculator(policy=Policy(), records=rec)
calcx.calc_all()
combinedx = calcx.array('combined')
c00100x = calcx.array('c00100')
calc = Calculator(policy=Policy(), records=rec)
recs_pre_e00200p = copy.deepcopy(calc.array('e00200p'))
(mtr_ptx, mtr_itx, mtr_cmb) = calc.mtr(variable_str='e00200p',
zero_out_calculated_vars=True)
recs_post_e00200p = calc.array('e00200p')
assert np.allclose(recs_post_e00200p, recs_pre_e00200p)
assert np.allclose(calc.array('combined'), combinedx)
assert np.allclose(calc.array('c00100'), c00100x)
assert np.array_equal(mtr_cmb, mtr_ptx) is False
assert np.array_equal(mtr_ptx, mtr_itx) is False
with pytest.raises(ValueError):
calc.mtr(variable_str='bad_income_type')
(_, _, mtr_combined) = calc.mtr(variable_str='e00200s',
calc_all_already_called=True)
assert isinstance(mtr_combined, np.ndarray)
(_, _, mtr_combined) = calc.mtr(variable_str='e00650',
negative_finite_diff=True,
calc_all_already_called=True)
assert isinstance(mtr_combined, np.ndarray)
(_, _, mtr_combined) = calc.mtr(variable_str='e00900p',
calc_all_already_called=True)
assert isinstance(mtr_combined, np.ndarray)
(_, _, mtr_combined) = calc.mtr(variable_str='e01700',
calc_all_already_called=True)
assert isinstance(mtr_combined, np.ndarray)
(_, _, mtr_combined) = calc.mtr(variable_str='e26270',
calc_all_already_called=True)
assert isinstance(mtr_combined, np.ndarray)
(_, _, mtr_combined) = calc.mtr(variable_str='e00200p',
calc_all_already_called=True)
assert np.allclose(mtr_combined, mtr_cmb)
assert np.allclose(calc.array('combined'), combinedx)
assert np.allclose(calc.array('c00100'), c00100x)
def test_calculator_mtr_when_PT_rates_differ():
reform = {2013: {'_II_rt1': [0.40],
'_II_rt2': [0.40],
'_II_rt3': [0.40],
'_II_rt4': [0.40],
'_II_rt5': [0.40],
'_II_rt6': [0.40],
'_II_rt7': [0.40],
'_PT_rt1': [0.30],
'_PT_rt2': [0.30],
'_PT_rt3': [0.30],
'_PT_rt4': [0.30],
'_PT_rt5': [0.30],
'_PT_rt6': [0.30],
'_PT_rt7': [0.30]}}
funit = (
u'RECID,MARS,FLPDYR,e00200,e00200p,e00900,e00900p,extraneous\n'
u'1, 1, 2009, 200000,200000, 100000,100000, 9999999999\n'
)
rec = Records(pd.read_csv(StringIO(funit)))
pol = Policy()
calc1 = Calculator(policy=pol, records=rec)
(_, mtr1, _) = calc1.mtr(variable_str='p23250')
pol.implement_reform(reform)
calc2 = Calculator(policy=pol, records=rec)
(_, mtr2, _) = calc2.mtr(variable_str='p23250')
assert np.allclose(mtr1, mtr2, rtol=0.0, atol=1e-06)
def test_make_calculator_increment_years_first(cps_subsample):
# create Policy object with policy reform
syr = 2013
pol = Policy(start_year=syr)
reform = {2015: {}, 2016: {}}
std5 = 2000
reform[2015]['_STD_Aged'] = [[std5, std5, std5, std5, std5]]
reform[2015]['_II_em'] = [5000]
reform[2016]['_II_em'] = [6000]
reform[2016]['_II_em_cpi'] = False
pol.implement_reform(reform)
# create Calculator object with Policy object as modified by reform
rec = Records.cps_constructor(data=cps_subsample, no_benefits=True)
calc = Calculator(policy=pol, records=rec)
# compare expected policy parameter values with those embedded in calc
irates = pol.inflation_rates()
irate2015 = irates[2015 - syr]
irate2016 = irates[2016 - syr]
std6 = std5 * (1.0 + irate2015)
std7 = std6 * (1.0 + irate2016)
exp_STD_Aged = np.array([[1500, 1200, 1200, 1500, 1500],
[1550, 1200, 1200, 1550, 1550],
[std5, std5, std5, std5, std5],
[std6, std6, std6, std6, std6],
[std7, std7, std7, std7, std7]])
act_STD_Aged = calc.policy_param('_STD_Aged')
assert np.allclose(act_STD_Aged[:5], exp_STD_Aged)
exp_II_em = np.array([3900, 3950, 5000, 6000, 6000])
act_II_em = calc.policy_param('_II_em')
assert np.allclose(act_II_em[:5], exp_II_em)
def test_ID_HC_vs_BS(cps_subsample):
"""
Test that complete haircut of itemized deductions produces same
results as a 100% benefit surtax with no benefit deduction.
"""
recs = Records.cps_constructor(data=cps_subsample, no_benefits=True)
# specify complete-haircut reform policy and Calculator object
hc_reform = {2013: {'_ID_Medical_hc': [1.0],
'_ID_StateLocalTax_hc': [1.0],
'_ID_RealEstate_hc': [1.0],
'_ID_Casualty_hc': [1.0],
'_ID_Miscellaneous_hc': [1.0],
'_ID_InterestPaid_hc': [1.0],
'_ID_Charity_hc': [1.0]}}
hc_policy = Policy()
hc_policy.implement_reform(hc_reform)
hc_calc = Calculator(policy=hc_policy, records=recs)
hc_calc.calc_all()
hc_taxes = hc_calc.dataframe(['iitax', 'payrolltax'])
del hc_calc
# specify benefit-surtax reform policy and Calculator object
bs_reform = {2013: {'_ID_BenefitSurtax_crt': [0.0],
'_ID_BenefitSurtax_trt': [1.0]}}
bs_policy = Policy()
bs_policy.implement_reform(bs_reform)
bs_calc = Calculator(policy=bs_policy, records=recs)
bs_calc.calc_all()
bs_taxes = bs_calc.dataframe(['iitax', 'payrolltax'])
del bs_calc
# compare calculated taxes generated by the two reforms
assert np.allclose(hc_taxes['payrolltax'], bs_taxes['payrolltax'])
assert np.allclose(hc_taxes['iitax'], bs_taxes['iitax'])
def test_ID_StateLocal_HC_vs_CRT(cps_subsample):
"""
Test that a cap on state/local income and sales tax deductions at 0 percent
of AGI is equivalent to a complete haircut on the same state/local tax
deductions.
"""
rec = Records.cps_constructor(data=cps_subsample, no_benefits=True)
# specify state/local complete haircut reform policy and Calculator object
hc_reform = {2013: {'_ID_StateLocalTax_hc': [1.0]}}
hc_policy = Policy()
hc_policy.implement_reform(hc_reform)
hc_calc = Calculator(policy=hc_policy, records=rec)
hc_calc.calc_all()
# specify AGI cap reform policy and Calculator object
crt_reform = {2013: {'_ID_StateLocalTax_crt': [0.0]}}
crt_policy = Policy()
crt_policy.implement_reform(crt_reform)
crt_calc = Calculator(policy=crt_policy, records=rec)
crt_calc.calc_all()
# compare calculated tax results generated by the two reforms
assert np.allclose(hc_calc.array('payrolltax'),
crt_calc.array('payrolltax'))
assert np.allclose(hc_calc.array('iitax'),
crt_calc.array('iitax'))
def test_ID_RealEstate_HC_vs_CRT(cps_subsample):
"""
Test that a cap on all state, local, and foreign real estate tax deductions
at 0 percent of AGI is equivalent to a complete haircut on the same real
estate tax deductions.
"""
rec = Records.cps_constructor(data=cps_subsample, no_benefits=True)
# specify real estate complete haircut reform policy and Calculator object
hc_reform = {2013: {'_ID_RealEstate_hc': [1.0]}}
hc_policy = Policy()
hc_policy.implement_reform(hc_reform)
hc_calc = Calculator(policy=hc_policy, records=rec)
hc_calc.calc_all()
# specify AGI cap reform policy and Calculator object
crt_reform = {2013: {'_ID_RealEstate_crt': [0.0]}}
crt_policy = Policy()
crt_policy.implement_reform(crt_reform)
crt_calc = Calculator(policy=crt_policy, records=rec)
crt_calc.calc_all()
# compare calculated tax results generated by the two reforms
assert np.allclose(hc_calc.array('payrolltax'),
crt_calc.array('payrolltax'))
assert np.allclose(hc_calc.array('iitax'),
crt_calc.array('iitax'))
def test_calculator_using_nonstd_input(rawinputfile):
# check Calculator handling of raw, non-standard input data with no aging
pol = Policy()
pol.set_year(RAWINPUTFILE_YEAR) # set policy params to input data year
nonstd = Records(data=rawinputfile.name,
gfactors=None, # keeps raw data unchanged
weights=None,
start_year=RAWINPUTFILE_YEAR) # set raw input data year
assert nonstd.array_length == RAWINPUTFILE_FUNITS
calc = Calculator(policy=pol, records=nonstd,
sync_years=False) # keeps raw data unchanged
assert calc.current_year == RAWINPUTFILE_YEAR
calc.calc_all()
assert calc.weighted_total('e00200') == 0
assert calc.total_weight() == 0
varlist = ['RECID', 'MARS']
pdf = calc.dataframe(varlist)
assert isinstance(pdf, pd.DataFrame)
assert pdf.shape == (RAWINPUTFILE_FUNITS, len(varlist))
mars = calc.array('MARS')
assert isinstance(mars, np.ndarray)
assert mars.shape == (RAWINPUTFILE_FUNITS,)
exp_iitax = np.zeros((nonstd.array_length,))
assert np.allclose(calc.array('iitax'), exp_iitax)
mtr_ptax, _, _ = calc.mtr(wrt_full_compensation=False)
exp_mtr_ptax = np.zeros((nonstd.array_length,))
exp_mtr_ptax.fill(0.153)
assert np.allclose(mtr_ptax, exp_mtr_ptax)
REFORM_CONTENTS = """
// Example of a reform file suitable for read_json_param_objects().
// This JSON file can contain any number of trailing //-style comments, which
// will be removed before the contents are converted from JSON to a dictionary.
// Within each "policy" object, the primary keys are parameters and
// the secondary keys are years.
// Both the primary and secondary key values must be enclosed in quotes (").
// Boolean variables are specified as true or false (no quotes; all lowercase).
// Parameter code in the policy object is enclosed inside a pair of double
// pipe characters (||).
{
"policy": {
"_AMT_brk1": // top of first AMT tax bracket
{"2015": [200000],
"2017": [300000]
},
"_EITC_c": // maximum EITC amount by number of qualifying kids (0,1,2,3+)
{"2016": [[ 900, 5000, 8000, 9000]],
"2019": [[1200, 7000, 10000, 12000]]
},
"_II_em": // personal exemption amount (see indexing changes below)
{"2016": [6000],
"2018": [7500],
"2020": [9000]
},
"_II_em_cpi": // personal exemption amount indexing status
{"2016": false, // values in future years are same as this year value
"2018": true // values in future years indexed with this year as base
},
"_SS_Earnings_c": // social security (OASDI) maximum taxable earnings
{"2016": [300000],
"2018": [500000],
"2020": [700000]
},
"_AMT_em_cpi": // AMT exemption amount indexing status
{"2017": false, // values in future years are same as this year value
"2020": true // values in future years indexed with this year as base
}
}
}
"""
@pytest.fixture(scope='module', name='reform_file')
def fixture_reform_file():
"""
Temporary reform file for read_json_param_objects() function.
"""
rfile = tempfile.NamedTemporaryFile(mode='a', delete=False)
rfile.write(REFORM_CONTENTS)
rfile.close()
# must close and then yield for Windows platform
yield rfile
if os.path.isfile(rfile.name):
try:
os.remove(rfile.name)
except OSError:
pass # sometimes we can't remove a generated temporary file
ASSUMP_CONTENTS = """
// Example of assump file suitable for the read_json_param_objects().
// This JSON file can contain any number of trailing //-style comments, which
// will be removed before the contents are converted from JSON to a dictionary.
// Within each "behavior", "consumption" and "growth" object, the
// primary keys are parameters and the secondary keys are years.
// Both the primary and secondary key values must be enclosed in quotes (").
// Boolean variables are specified as true or false (no quotes; all lowercase).
{
"consumption": { "_MPC_e18400": {"2018": [0.05]} },
"behavior": {},
"growdiff_baseline": {},
"growdiff_response": {},
"growmodel": {}
}
"""
@pytest.fixture(scope='module', name='assump_file')
def fixture_assump_file():
"""
Temporary assumption file for read_json_params_files() function.
"""
afile = tempfile.NamedTemporaryFile(mode='a', delete=False)
afile.write(ASSUMP_CONTENTS)
afile.close()
# must close and then yield for Windows platform
yield afile
if os.path.isfile(afile.name):
try:
os.remove(afile.name)
except OSError:
pass # sometimes we can't remove a generated temporary file
@pytest.mark.parametrize("set_year", [False, True])
def test_read_json_reform_file_and_implement_reform(reform_file,
assump_file,
set_year):
"""
Test reading and translation of reform file into a reform dictionary
that is then used to call implement_reform method and Calculate.calc_all()
NOTE: implement_reform called when policy.current_year == policy.start_year
"""
pol = Policy()
if set_year:
pol.set_year(2015)
param_dict = Calculator.read_json_param_objects(reform_file.name,
assump_file.name)
pol.implement_reform(param_dict['policy'])
syr = pol.start_year
amt_brk1 = pol._AMT_brk1
assert amt_brk1[2015 - syr] == 200000
assert amt_brk1[2016 - syr] > 200000
assert amt_brk1[2017 - syr] == 300000
assert amt_brk1[2018 - syr] > 300000
ii_em = pol._II_em
assert ii_em[2016 - syr] == 6000
assert ii_em[2017 - syr] == 6000
assert ii_em[2018 - syr] == 7500
assert ii_em[2019 - syr] > 7500
assert ii_em[2020 - syr] == 9000
assert ii_em[2021 - syr] > 9000
amt_em = pol._AMT_em
assert amt_em[2016 - syr, 0] > amt_em[2015 - syr, 0]
assert amt_em[2017 - syr, 0] > amt_em[2016 - syr, 0]
assert amt_em[2018 - syr, 0] == amt_em[2017 - syr, 0]
assert amt_em[2019 - syr, 0] == amt_em[2017 - syr, 0]
assert amt_em[2020 - syr, 0] == amt_em[2017 - syr, 0]
assert amt_em[2021 - syr, 0] > amt_em[2020 - syr, 0]
assert amt_em[2022 - syr, 0] > amt_em[2021 - syr, 0]
add4aged = pol._ID_Medical_frt_add4aged
assert add4aged[2015 - syr] == -0.025
assert add4aged[2016 - syr] == -0.025
assert add4aged[2017 - syr] == 0.0
assert add4aged[2022 - syr] == 0.0
@pytest.fixture(scope='module', name='bad1reformfile')
def fixture_bad1reformfile():
# specify JSON text for reform
txt = """
{
"policy": { // example of incorrect JSON because 'x' must be "x"
'x': {"2014": [4000]}
}
}
"""
f = tempfile.NamedTemporaryFile(mode='a', delete=False)
f.write(txt + '\n')
f.close()
# Must close and then yield for Windows platform
yield f
os.remove(f.name)
@pytest.fixture(scope='module', name='bad2reformfile')
def fixture_bad2reformfile():
# specify JSON text for reform
txt = """
{
"title": "",
"policyx": { // example of reform file not containing "policy" key
"_SS_Earnings_c": {"2018": [9e99]}
}
}
"""
f = tempfile.NamedTemporaryFile(mode='a', delete=False)
f.write(txt + '\n')
f.close()
# Must close and then yield for Windows platform
yield f
os.remove(f.name)
@pytest.fixture(scope='module', name='bad3reformfile')
def fixture_bad3reformfile():
# specify JSON text for reform
txt = """
{
"title": "",
"policy": {
"_SS_Earnings_c": {"2018": [9e99]}
},
"behavior": { // example of misplaced "behavior" key
}
}
"""
f = tempfile.NamedTemporaryFile(mode='a', delete=False)
f.write(txt + '\n')
f.close()
# Must close and then yield for Windows platform
yield f
os.remove(f.name)
def test_read_bad_json_reform_file(bad1reformfile, bad2reformfile,
bad3reformfile):
with pytest.raises(ValueError):
Calculator.read_json_param_objects(bad1reformfile.name, None)
with pytest.raises(ValueError):
Calculator.read_json_param_objects(bad2reformfile.name, None)
with pytest.raises(ValueError):
Calculator.read_json_param_objects(bad3reformfile.name, None)
with pytest.raises(ValueError):
Calculator.read_json_param_objects(list(), None)
with pytest.raises(ValueError):
Calculator.read_json_param_objects(None, 'unknown_file_name')
with pytest.raises(ValueError):
Calculator.read_json_param_objects(None, list())
@pytest.fixture(scope='module', name='bad1assumpfile')
def fixture_bad1assumpfile():
# specify JSON text for assumptions
txt = """
{
"consumption": {},
"behavior": { // example of incorrect JSON because 'x' must be "x"
'x': {"2014": [0.25]}
},
"growdiff_baseline": {},
"growdiff_response": {},
"growmodel": {}
}
"""
f = tempfile.NamedTemporaryFile(mode='a', delete=False)
f.write(txt + '\n')
f.close()
# Must close and then yield for Windows platform
yield f
os.remove(f.name)
@pytest.fixture(scope='module', name='bad2assumpfile')
def fixture_bad2assumpfile():
# specify JSON text for assumptions
txt = """
{
"consumption": {},
"behaviorx": {}, // example of assump file not containing "behavior" key
"growdiff_baseline": {},
"growdiff_response": {},
"growmodel": {}
}
"""
f = tempfile.NamedTemporaryFile(mode='a', delete=False)
f.write(txt + '\n')
f.close()
# Must close and then yield for Windows platform
yield f
os.remove(f.name)
@pytest.fixture(scope='module', name='bad3assumpfile')
def fixture_bad3assumpfile():
# specify JSON text for assump
txt = """
{
"consumption": {},
"behavior": {},
"growdiff_baseline": {},
"growdiff_response": {},
"policy": { // example of misplaced policy key
"_SS_Earnings_c": {"2018": [9e99]}
},
"growmodel": {}
}
"""
f = tempfile.NamedTemporaryFile(mode='a', delete=False)
f.write(txt + '\n')
f.close()
# Must close and then yield for Windows platform
yield f
os.remove(f.name)
def test_read_bad_json_assump_file(bad1assumpfile, bad2assumpfile,
bad3assumpfile):
with pytest.raises(ValueError):
Calculator.read_json_param_objects(None, bad1assumpfile.name)
with pytest.raises(ValueError):
Calculator.read_json_param_objects(None, bad2assumpfile.name)
with pytest.raises(ValueError):
Calculator.read_json_param_objects(None, bad3assumpfile.name)
with pytest.raises(ValueError):
Calculator.read_json_param_objects(None, 'unknown_file_name')
with pytest.raises(ValueError):
Calculator.read_json_param_objects(None, list())
def test_convert_parameter_dict():
with pytest.raises(ValueError):
Calculator._convert_parameter_dict({2013: {'2013': [40000]}})
with pytest.raises(ValueError):
Calculator._convert_parameter_dict({'_II_em': {2013: [40000]}})
with pytest.raises(ValueError):
Calculator._convert_parameter_dict({4567: {2013: [40000]}})
with pytest.raises(ValueError):
Calculator._convert_parameter_dict({'_II_em': 40000})
rdict = Calculator._convert_parameter_dict({'_II_em': {'2013': [40000]}})
assert isinstance(rdict, dict)
def test_calc_all(reform_file, rawinputfile):
cyr = 2016
pol = Policy()
param_dict = Calculator.read_json_param_objects(reform_file.name, None)
pol.implement_reform(param_dict['policy'])
pol.set_year(cyr)
nonstd = Records(data=rawinputfile.name, gfactors=None,
weights=None, start_year=cyr)
assert nonstd.array_length == RAWINPUTFILE_FUNITS
calc = Calculator(policy=pol, records=nonstd,
sync_years=False) # keeps raw data unchanged
assert calc.current_year == cyr
assert calc.reform_warnings == ''
def test_translate_json_reform_suffixes_mars_non_indexed():
# test read_json_param_objects()
# using MARS-indexed parameter suffixes
json1 = """{"policy": {
"_II_em": {"2020": [20000], "2015": [15000]},
"_AMEDT_ec_joint": {"2018": [400000], "2016": [300000]},
"_AMEDT_ec_separate": {"2017": [150000], "2019": [200000]}
}}"""
pdict1 = Calculator.read_json_param_objects(reform=json1, assump=None)
rdict1 = pdict1['policy']
json2 = """{"policy": {
"_AMEDT_ec": {"2016": [[200000, 300000, 125000, 200000, 200000]],
"2017": [[200000, 300000, 150000, 200000, 200000]],
"2018": [[200000, 400000, 150000, 200000, 200000]],
"2019": [[200000, 400000, 200000, 200000, 200000]]},
"_II_em": {"2015": [15000], "2020": [20000]}
}}"""
pdict2 = Calculator.read_json_param_objects(reform=json2, assump=None)
rdict2 = pdict2['policy']
assert len(rdict2) == len(rdict1)
for year in rdict2.keys():
if '_II_em' in rdict2[year].keys():
assert np.allclose(rdict1[year]['_II_em'],
rdict2[year]['_II_em'],
atol=0.01, rtol=0.0)
if '_AMEDT_ec' in rdict2[year].keys():
assert np.allclose(rdict1[year]['_AMEDT_ec'],
rdict2[year]['_AMEDT_ec'],
atol=0.01, rtol=0.0)
def test_translate_json_reform_suffixes_eic():
# test read_json_param_objects(...)
# using EIC-indexed parameter suffixes
json1 = """{"policy": {
"_II_em": {"2020": [20000], "2015": [15000]},
"_EITC_c_0kids": {"2018": [510], "2019": [510]},
"_EITC_c_1kid": {"2019": [3400], "2018": [3400]},
"_EITC_c_2kids": {"2018": [5616], "2019": [5616]},
"_EITC_c_3+kids": {"2019": [6318], "2018": [6318]}
}}"""
pdict1 = Calculator.read_json_param_objects(reform=json1, assump=None)
rdict1 = pdict1['policy']
json2 = """{"policy": {
"_EITC_c": {"2019": [[510, 3400, 5616, 6318]],
"2018": [[510, 3400, 5616, 6318]]},
"_II_em": {"2020": [20000], "2015": [15000]}
}}"""
pdict2 = Calculator.read_json_param_objects(reform=json2, assump=None)
rdict2 = pdict2['policy']
assert len(rdict2) == len(rdict1)
for year in rdict2.keys():
if '_II_em' in rdict2[year].keys():
assert np.allclose(rdict1[year]['_II_em'],
rdict2[year]['_II_em'],
atol=0.01, rtol=0.0)
if '_EITC_c' in rdict2[year].keys():
assert np.allclose(rdict1[year]['_EITC_c'],
rdict2[year]['_EITC_c'],
atol=0.01, rtol=0.0)
def test_translate_json_reform_suffixes_idedtype():
# test read_json_param_objects(...)
# using idedtype-indexed parameter suffixes
json1 = """{"policy": {
"_ID_BenefitCap_rt": {"2019": [0.2]},
"_ID_BenefitCap_Switch_medical": {"2019": [false]},
"_ID_BenefitCap_Switch_casualty": {"2019": [false]},
"_ID_BenefitCap_Switch_misc": {"2019": [false]},
"_ID_BenefitCap_Switch_interest": {"2019": [false]},
"_ID_BenefitCap_Switch_charity": {"2019": [false]},
"_II_em": {"2020": [20000], "2015": [15000]}
}}"""
pdict1 = Calculator.read_json_param_objects(reform=json1, assump=None)
rdict1 = pdict1['policy']
json2 = """{"policy": {
"_II_em": {"2020": [20000], "2015": [15000]},
"_ID_BenefitCap_Switch": {
"2019": [[false, true, true, false, false, false, false]]
},
"_ID_BenefitCap_rt": {"2019": [0.2]}
}}"""
pdict2 = Calculator.read_json_param_objects(reform=json2, assump=None)
rdict2 = pdict2['policy']
assert len(rdict2) == len(rdict1)
for year in rdict2.keys():
if '_II_em' in rdict2[year].keys():
assert np.allclose(rdict1[year]['_II_em'],
rdict2[year]['_II_em'],
atol=0.01, rtol=0.0)
if '_ID_BenefitCap_rt' in rdict2[year].keys():
assert np.allclose(rdict1[year]['_ID_BenefitCap_rt'],
rdict2[year]['_ID_BenefitCap_rt'],
atol=0.01, rtol=0.0)
if '_ID_BenefitCap_Switch' in rdict2[year].keys():
assert np.allclose(rdict1[year]['_ID_BenefitCap_Switch'],
rdict2[year]['_ID_BenefitCap_Switch'],
atol=0.01, rtol=0.0)
def test_read_json_param_with_suffixes_and_errors():
# test interaction of policy parameter suffixes and reform errors
# (fails without 0.10.2 bug fix as reported by Hank Doupe in PB PR#641)
reform = {
u'policy': {
u'_II_brk4_separate': {u'2017': [5000.0]},
u'_STD_separate': {u'2017': [8000.0]},
u'_STD_single': {u'2018': [1000.0]},
u'_II_brk2_headhousehold': {u'2017': [1000.0]},
u'_II_brk4_single': {u'2017': [500.0]},
u'_STD_joint': {u'2017': [10000.0], u'2020': [150.0]},
u'_II_brk2_separate': {u'2017': [1000.0]},
u'_II_brk2_single': {u'2017': [1000.0]},
u'_II_brk2_joint': {u'2017': [1000.0]},
u'_FICA_ss_trt': {u'2017': [-1.0], u'2019': [0.1]},
u'_II_brk4_headhousehold': {u'2017': [500.0]},
u'_STD_headhousehold': {u'2017': [10000.0], u'2020': [150.0]},
u'_II_brk4_joint': {u'2017': [500.0]},
u'_ID_BenefitSurtax_Switch_medical': {u'2017': [True]}
}
}
json_reform = json.dumps(reform)
params = Calculator.read_json_param_objects(json_reform, None)
assert isinstance(params, dict)
pol = Policy()
pol.ignore_reform_errors()
pol.implement_reform(params['policy'],
print_warnings=False, raise_errors=False)
assert len(pol.parameter_errors) > 0
assert len(pol.parameter_warnings) > 0
def test_noreform_documentation():
reform_json = """
{
"policy": {}
}
"""
assump_json = """
{
"consumption": {},
"behavior": {},
"growdiff_baseline": {},
"growdiff_response": {},
"growmodel": {}
}
"""
params = Calculator.read_json_param_objects(reform_json, assump_json)
assert isinstance(params, dict)
actual_doc = Calculator.reform_documentation(params)
expected_doc = (
'REFORM DOCUMENTATION\n'
'Baseline Growth-Difference Assumption Values by Year:\n'
'none: using default baseline growth assumptions\n'
'Policy Reform Parameter Values by Year:\n'
'none: using current-law policy parameters\n'
)
assert actual_doc == expected_doc
def test_reform_documentation():
reform_json = """
{
"policy": {
"_II_em_cpi": {"2016": false,
"2018": true},
"_II_em": {"2016": [5000],
"2018": [6000],
"2020": [7000]},
"_EITC_indiv": {"2017": [true]},
"_STD_Aged_cpi": {"2016": false},
"_STD_Aged": {"2016": [[1600, 1300, 1300, 1600, 1600]],
"2020": [[2000, 2000, 2000, 2000, 2000]]},
"_ID_BenefitCap_Switch_medical": {"2020": [false]},
"_ID_BenefitCap_Switch_casualty": {"2020": [false]},
"_ID_BenefitCap_Switch_misc": {"2020": [false]},
"_ID_BenefitCap_Switch_interest": {"2020": [false]},
"_ID_BenefitCap_Switch_charity": {"2020": [false]}
}
}
"""
assump_json = """
{
"consumption": {},
"behavior": {},
// increase baseline inflation rate by one percentage point in 2014+
// (has no effect on known policy parameter values)
"growdiff_baseline": {"_ACPIU": {"2014": [0.01]}},
"growdiff_response": {},
"growmodel": {}
}
"""
params = Calculator.read_json_param_objects(reform_json, assump_json)
assert isinstance(params, dict)
doc = Calculator.reform_documentation(params)
assert isinstance(doc, six.string_types)
dump = False # set to True to print documentation and force test failure
if dump:
print(doc)
assert 1 == 2
def test_distribution_tables(cps_subsample):
pol = Policy()
recs = Records.cps_constructor(data=cps_subsample)
calc1 = Calculator(policy=pol, records=recs)
assert calc1.current_year == 2014
calc1.calc_all()
dt1, dt2 = calc1.distribution_tables(None, 'weighted_deciles')
assert isinstance(dt1, pd.DataFrame)
assert dt2 is None
dt1, dt2 = calc1.distribution_tables(calc1, 'weighted_deciles')
assert isinstance(dt1, pd.DataFrame)
assert isinstance(dt2, pd.DataFrame)
reform = {2014: {'_UBI_u18': [1000],
'_UBI_1820': [1000],
'_UBI_21': [1000]}}
pol.implement_reform(reform)
assert not pol.parameter_errors
calc2 = Calculator(policy=pol, records=recs)
calc2.calc_all()
dt1, dt2 = calc1.distribution_tables(calc2, 'weighted_deciles')
assert isinstance(dt1, pd.DataFrame)
assert isinstance(dt2, pd.DataFrame)
def test_difference_table(cps_subsample):
cyr = 2014
pol = Policy()
recs = Records.cps_constructor(data=cps_subsample)
calc1 = Calculator(policy=pol, records=recs)
assert calc1.current_year == cyr
reform = {cyr: {'_SS_Earnings_c': [9e99]}}
pol.implement_reform(reform)
calc2 = Calculator(policy=pol, records=recs)
assert calc2.current_year == cyr
calc1.calc_all()
calc2.calc_all()
diff = calc1.difference_table(calc2, 'weighted_deciles', 'iitax')
assert isinstance(diff, pd.DataFrame)
def test_diagnostic_table(cps_subsample):
recs = Records.cps_constructor(data=cps_subsample, no_benefits=True)
calc = Calculator(policy=Policy(), records=recs)
adt = calc.diagnostic_table(3)
assert isinstance(adt, pd.DataFrame)
def test_mtr_graph(cps_subsample):
recs = Records.cps_constructor(data=cps_subsample, no_benefits=True)
calc = Calculator(policy=Policy(), records=recs)
fig = calc.mtr_graph(calc,
mars=2,
income_measure='wages',
mtr_measure='ptax')
assert fig
fig = calc.mtr_graph(calc,
income_measure='agi',
mtr_measure='itax')
assert fig
def test_atr_graph(cps_subsample):
recs = Records.cps_constructor(data=cps_subsample, no_benefits=True)
calc = Calculator(policy=Policy(), records=recs)
fig = calc.atr_graph(calc, mars=2, atr_measure='itax')
assert fig
fig = calc.atr_graph(calc, atr_measure='ptax')
assert fig
def test_privacy_of_embedded_objects(cps_subsample):
recs = Records.cps_constructor(data=cps_subsample, no_benefits=True)
calc = Calculator(policy=Policy(), records=recs)
with pytest.raises(AttributeError):
cyr = calc.__policy.current_year
with pytest.raises(AttributeError):
wgh = calc.__records.s006
with pytest.raises(AttributeError):
cyr = calc.__consumption.current_year
with pytest.raises(AttributeError):
cyr = calc.__behavior.current_year
def test_n65(cps_subsample):
recs = Records.cps_constructor(data=cps_subsample, no_benefits=True)
calc = Calculator(policy=Policy(), records=recs)
assert calc.n65().sum() > 1500
| test_make_calculator_deepcopy |
version_test.rs | // Copyright 2020-2021 The Datafuse Authors.
//
// SPDX-License-Identifier: Apache-2.0.
#[test]
fn test_version_function() -> anyhow::Result<()> {
use std::sync::Arc;
use common_datavalues::*;
use pretty_assertions::assert_eq;
use crate::udfs::*;
use crate::*;
#[allow(dead_code)]
struct | {
name: &'static str,
display: &'static str,
nullable: bool,
columns: Vec<DataColumnarValue>,
expect: DataArrayRef,
error: &'static str,
func: Box<dyn Function>,
}
let tests = vec![Test {
name: "version-function-passed",
display: "version",
nullable: false,
func: VersionFunction::try_create("version")?,
columns: vec![Arc::new(StringArray::from(vec![
"FuseQuery v-0.1.0-3afb26c(1.54.0-nightly-2021-06-09T07:56:09.461981495+00:00)",
]))
.into()],
expect: Arc::new(StringArray::from(vec![
"FuseQuery v-0.1.0-3afb26c(1.54.0-nightly-2021-06-09T07:56:09.461981495+00:00)",
])),
error: "",
}];
for t in tests {
let rows = t.columns[0].len();
let func = t.func;
match func.eval(&t.columns, rows) {
Ok(v) => {
// Display check.
let expect_display = t.display.to_string();
let actual_display = format!("{}", func);
assert_eq!(expect_display, actual_display);
assert_eq!(v.to_array()?.as_ref(), t.expect.as_ref());
}
Err(e) => {
assert_eq!(t.error, e.to_string());
}
}
}
Ok(())
}
| Test |
randomData.py | #!/usr/bin/env https://github.com/Tandelajr/mr.tandela
# MIT License
#
# Copyright (C) 2020, Entynetproject. All Rights Reserved.
#
# Permission is hereby granted, free of charge, to any person obtaining a copy
# of this software and associated documentation files (the "Software"), to deal
# in the Software without restriction, including without limitation the rights
# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
# copies of the Software, and to permit persons to whom the Software is
# furnished to do so, subject to the following conditions:
#
# The above copyright notice and this permission notice shall be included in all
# copies or substantial portions of the Software.
#
# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE | # LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
# SOFTWARE.
import json
import random
# Get random IP
def random_IP():
ip = []
for _ in range(0, 4):
ip.append(str(random.randint(1,255)))
return ".".join(ip)
# Get random referer
def random_referer():
with open("tools/other/referers.txt", 'r') as referers:
referers = referers.readlines()
return random.choice(referers)
# Get random user agent
def random_useragent():
with open("tools/other/user_agents.json", 'r') as agents:
user_agents = json.load(agents)["agents"]
return random.choice(user_agents) | # AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER |
HogDetector.py | import dlib
class HogDetector:
def __init__(self):
self.detector = dlib.get_frontal_face_detector()
def | (self, frame):
bboxes = []
# landmarks = []
dets = self.detector(frame, 1)
for k, d in enumerate(dets):
bboxes.append(
(d.left(), d.top(), d.right() - d.left(), d.bottom() - d.top())
)
# shape = self.predictor(frame, d)
# landmarks.append([(p.x, p.y) for p in shape.parts()])
return bboxes
| detect |
threedtileloader.js | import * as vec2 from "./glmatrix/vec2.js";
import Cartesian3 from "../viewer/cesium/Core/Cartesian3.js";
import Transforms from "../viewer/cesium/Core/Transforms.js";
const b3dm = 0x6D643362;
const gltf = 0x46546c67;
export class | {
constructor(params) {
this.url = params.url;
this.refLatitude = params.refLatitude;
this.refLongitude = params.refLongitude;
this.callback = params.callback;
let cesiumMatrix = Transforms.eastNorthUpToFixedFrame(
Cartesian3.fromDegrees(this.refLongitude, this.refLatitude, 0.)
);
this.refPoint = new Float32Array(Array.from(cesiumMatrix)).subarray(12,15);
}
processB3dm(bounds, u) {
return fetch(u).then(r => r.arrayBuffer()).then(r => {
const headerSize = 28;
let b = new Uint32Array(r.slice(0, headerSize));
if (b[0] !== b3dm) {
throw new Error();
}
if (b[1] !== 1) {
throw new Error();
}
if (b[2] !== r.byteLength) {
throw new Error();
}
let featureTableJSONByteLength = b[3];
let featureTableBinaryByteLength = b[4];
let batchTableJSONByteLength = b[5];
let batchTableBinaryByteLength = b[6];
let decoder = new TextDecoder("utf-8");
let content = r.slice(headerSize + featureTableJSONByteLength + featureTableBinaryByteLength,
headerSize + featureTableJSONByteLength + featureTableBinaryByteLength + batchTableJSONByteLength + batchTableBinaryByteLength);
let contentString = decoder.decode(content);
let glbOffset = headerSize + featureTableJSONByteLength + featureTableBinaryByteLength + batchTableJSONByteLength + batchTableBinaryByteLength;
let b2 = new Uint32Array(r.slice(glbOffset, glbOffset+4));
if (b2[0] !== gltf) {
throw new Error();
}
// sigh another fix for broken glTF exporters: length includes padding
contentString = contentString.replace(/\x00+$/, "");
// sigh and yet another fix: garbage after JSON
try {
JSON.parse(contentString);
} catch {
contentString = contentString.substr(0, contentString.lastIndexOf("}")+1);
}
let glbContent = r.slice(glbOffset);
this.callback({
buffer: glbContent,
bounds: bounds,
features: JSON.parse(contentString)
});
});
}
processTile(u, t) {
/*
if (t.refine === "REPLACE") {
// empty on purpose we do nothing
} else if (tile.refine === "ADD") {
this.loadTile(tile);
} else {
throw new Error(tile.refine + " is invalid for refine");
}
(tile.children || []).forEach((t) => {this.fetchTile(t, tile)});
*/
let R;
if (t.boundingVolume.region) {
R = Array.from(t.boundingVolume.region);
for (var i = 0; i < 4; ++i) {
R[i] *= 180. / Math.PI;
}
let [west, south, east, north, low, high] = R;
if (west < this.refLongitude && this.refLongitude < east && south < this.refLatitude && this.refLatitude < north) {
// continue;
} else {
return;
}
} else if (t.boundingVolume.box) {
R = new Float32Array(Array.from(t.boundingVolume.box));
let center = R.subarray(0, 2);
let x_dir = R.subarray(3, 5);
let y_dir = R.subarray(6, 8);
let relative = vec2.subtract(vec2.create(), this.refPoint, center);
for (let d of [x_dir, y_dir]) {
let extent = vec2.len(d);
let norm = vec2.normalize(vec2.create(), d);
if (Math.abs(vec2.dot(relative, norm)) > extent) {
return;
}
}
} else {
throw new Error("Unimplemented region");
}
let ps = [];
if (t.content && (t.content.uri || t.content.url)) {
let p = new URL(t.content.uri || t.content.url, u).href;
if (p.endsWith('.json')) {
ps.push(this.load(p));
} else {
ps.push(this.processB3dm(R, p));
}
}
ps.concat(...(t.children || []).map(t => this.processTile(u, t)));
return Promise.all(ps);
}
load(u) {
return fetch(u || this.url).then(r => r.json()).then(r => {
if (!r.asset || (r.asset.version != '1.0' && r.asset.version != '0.0')) {
throw new Error("Expected a 3D Tiles dataset");
}
return this.processTile(u || this.url, r.root);
});
}
}
| ThreeDTileLoader |
ode.py | r"""
This module contains :py:meth:`~sympy.solvers.ode.dsolve` and different helper
functions that it uses.
:py:meth:`~sympy.solvers.ode.dsolve` solves ordinary differential equations.
See the docstring on the various functions for their uses. Note that partial
differential equations support is in ``pde.py``. Note that hint functions
have docstrings describing their various methods, but they are intended for
internal use. Use ``dsolve(ode, func, hint=hint)`` to solve an ODE using a
specific hint. See also the docstring on
:py:meth:`~sympy.solvers.ode.dsolve`.
**Functions in this module**
These are the user functions in this module:
- :py:meth:`~sympy.solvers.ode.dsolve` - Solves ODEs.
- :py:meth:`~sympy.solvers.ode.classify_ode` - Classifies ODEs into
possible hints for :py:meth:`~sympy.solvers.ode.dsolve`.
- :py:meth:`~sympy.solvers.ode.checkodesol` - Checks if an equation is the
solution to an ODE.
- :py:meth:`~sympy.solvers.ode.homogeneous_order` - Returns the
homogeneous order of an expression.
- :py:meth:`~sympy.solvers.ode.infinitesimals` - Returns the infinitesimals
of the Lie group of point transformations of an ODE, such that it is
invariant.
- :py:meth:`~sympy.solvers.ode_checkinfsol` - Checks if the given infinitesimals
are the actual infinitesimals of a first order ODE.
These are the non-solver helper functions that are for internal use. The
user should use the various options to
:py:meth:`~sympy.solvers.ode.dsolve` to obtain the functionality provided
by these functions:
- :py:meth:`~sympy.solvers.ode.odesimp` - Does all forms of ODE
simplification.
- :py:meth:`~sympy.solvers.ode.ode_sol_simplicity` - A key function for
comparing solutions by simplicity.
- :py:meth:`~sympy.solvers.ode.constantsimp` - Simplifies arbitrary
constants.
- :py:meth:`~sympy.solvers.ode.constant_renumber` - Renumber arbitrary
constants.
- :py:meth:`~sympy.solvers.ode._handle_Integral` - Evaluate unevaluated
Integrals.
See also the docstrings of these functions.
**Currently implemented solver methods**
The following methods are implemented for solving ordinary differential
equations. See the docstrings of the various hint functions for more
information on each (run ``help(ode)``):
- 1st order separable differential equations.
- 1st order differential equations whose coefficients or `dx` and `dy` are
functions homogeneous of the same order.
- 1st order exact differential equations.
- 1st order linear differential equations.
- 1st order Bernoulli differential equations.
- Power series solutions for first order differential equations.
- Lie Group method of solving first order differential equations.
- 2nd order Liouville differential equations.
- Power series solutions for second order differential equations
at ordinary and regular singular points.
- `n`\th order differential equation that can be solved with algebraic
rearrangement and integration.
- `n`\th order linear homogeneous differential equation with constant
coefficients.
- `n`\th order linear inhomogeneous differential equation with constant
coefficients using the method of undetermined coefficients.
- `n`\th order linear inhomogeneous differential equation with constant
coefficients using the method of variation of parameters.
**Philosophy behind this module**
This module is designed to make it easy to add new ODE solving methods without
having to mess with the solving code for other methods. The idea is that
there is a :py:meth:`~sympy.solvers.ode.classify_ode` function, which takes in
an ODE and tells you what hints, if any, will solve the ODE. It does this
without attempting to solve the ODE, so it is fast. Each solving method is a
hint, and it has its own function, named ``ode_<hint>``. That function takes
in the ODE and any match expression gathered by
:py:meth:`~sympy.solvers.ode.classify_ode` and returns a solved result. If
this result has any integrals in it, the hint function will return an
unevaluated :py:class:`~sympy.integrals.Integral` class.
:py:meth:`~sympy.solvers.ode.dsolve`, which is the user wrapper function
around all of this, will then call :py:meth:`~sympy.solvers.ode.odesimp` on
the result, which, among other things, will attempt to solve the equation for
the dependent variable (the function we are solving for), simplify the
arbitrary constants in the expression, and evaluate any integrals, if the hint
allows it.
**How to add new solution methods**
If you have an ODE that you want :py:meth:`~sympy.solvers.ode.dsolve` to be
able to solve, try to avoid adding special case code here. Instead, try
finding a general method that will solve your ODE, as well as others. This
way, the :py:mod:`~sympy.solvers.ode` module will become more robust, and
unhindered by special case hacks. WolphramAlpha and Maple's
DETools[odeadvisor] function are two resources you can use to classify a
specific ODE. It is also better for a method to work with an `n`\th order ODE
instead of only with specific orders, if possible.
To add a new method, there are a few things that you need to do. First, you
need a hint name for your method. Try to name your hint so that it is
unambiguous with all other methods, including ones that may not be implemented
yet. If your method uses integrals, also include a ``hint_Integral`` hint.
If there is more than one way to solve ODEs with your method, include a hint
for each one, as well as a ``<hint>_best`` hint. Your ``ode_<hint>_best()``
function should choose the best using min with ``ode_sol_simplicity`` as the
key argument. See
:py:meth:`~sympy.solvers.ode.ode_1st_homogeneous_coeff_best`, for example.
The function that uses your method will be called ``ode_<hint>()``, so the
hint must only use characters that are allowed in a Python function name
(alphanumeric characters and the underscore '``_``' character). Include a
function for every hint, except for ``_Integral`` hints
(:py:meth:`~sympy.solvers.ode.dsolve` takes care of those automatically).
Hint names should be all lowercase, unless a word is commonly capitalized
(such as Integral or Bernoulli). If you have a hint that you do not want to
run with ``all_Integral`` that doesn't have an ``_Integral`` counterpart (such
as a best hint that would defeat the purpose of ``all_Integral``), you will
need to remove it manually in the :py:meth:`~sympy.solvers.ode.dsolve` code.
See also the :py:meth:`~sympy.solvers.ode.classify_ode` docstring for
guidelines on writing a hint name.
Determine *in general* how the solutions returned by your method compare with
other methods that can potentially solve the same ODEs. Then, put your hints
in the :py:data:`~sympy.solvers.ode.allhints` tuple in the order that they
should be called. The ordering of this tuple determines which hints are
default. Note that exceptions are ok, because it is easy for the user to
choose individual hints with :py:meth:`~sympy.solvers.ode.dsolve`. In
general, ``_Integral`` variants should go at the end of the list, and
``_best`` variants should go before the various hints they apply to. For
example, the ``undetermined_coefficients`` hint comes before the
``variation_of_parameters`` hint because, even though variation of parameters
is more general than undetermined coefficients, undetermined coefficients
generally returns cleaner results for the ODEs that it can solve than
variation of parameters does, and it does not require integration, so it is
much faster.
Next, you need to have a match expression or a function that matches the type
of the ODE, which you should put in :py:meth:`~sympy.solvers.ode.classify_ode`
(if the match function is more than just a few lines, like
:py:meth:`~sympy.solvers.ode._undetermined_coefficients_match`, it should go
outside of :py:meth:`~sympy.solvers.ode.classify_ode`). It should match the
ODE without solving for it as much as possible, so that
:py:meth:`~sympy.solvers.ode.classify_ode` remains fast and is not hindered by
bugs in solving code. Be sure to consider corner cases. For example, if your
solution method involves dividing by something, make sure you exclude the case
where that division will be 0.
In most cases, the matching of the ODE will also give you the various parts
that you need to solve it. You should put that in a dictionary (``.match()``
will do this for you), and add that as ``matching_hints['hint'] = matchdict``
in the relevant part of :py:meth:`~sympy.solvers.ode.classify_ode`.
:py:meth:`~sympy.solvers.ode.classify_ode` will then send this to
:py:meth:`~sympy.solvers.ode.dsolve`, which will send it to your function as
the ``match`` argument. Your function should be named ``ode_<hint>(eq, func,
order, match)`. If you need to send more information, put it in the ``match``
dictionary. For example, if you had to substitute in a dummy variable in
:py:meth:`~sympy.solvers.ode.classify_ode` to match the ODE, you will need to
pass it to your function using the `match` dict to access it. You can access
the independent variable using ``func.args[0]``, and the dependent variable
(the function you are trying to solve for) as ``func.func``. If, while trying
to solve the ODE, you find that you cannot, raise ``NotImplementedError``.
:py:meth:`~sympy.solvers.ode.dsolve` will catch this error with the ``all``
meta-hint, rather than causing the whole routine to fail.
Add a docstring to your function that describes the method employed. Like
with anything else in SymPy, you will need to add a doctest to the docstring,
in addition to real tests in ``test_ode.py``. Try to maintain consistency
with the other hint functions' docstrings. Add your method to the list at the
top of this docstring. Also, add your method to ``ode.rst`` in the
``docs/src`` directory, so that the Sphinx docs will pull its docstring into
the main SymPy documentation. Be sure to make the Sphinx documentation by
running ``make html`` from within the doc directory to verify that the
docstring formats correctly.
If your solution method involves integrating, use :py:meth:`Integral()
<sympy.integrals.integrals.Integral>` instead of
:py:meth:`~sympy.core.expr.Expr.integrate`. This allows the user to bypass
hard/slow integration by using the ``_Integral`` variant of your hint. In
most cases, calling :py:meth:`sympy.core.basic.Basic.doit` will integrate your
solution. If this is not the case, you will need to write special code in
:py:meth:`~sympy.solvers.ode._handle_Integral`. Arbitrary constants should be
symbols named ``C1``, ``C2``, and so on. All solution methods should return
an equality instance. If you need an arbitrary number of arbitrary constants,
you can use ``constants = numbered_symbols(prefix='C', cls=Symbol, start=1)``.
If it is possible to solve for the dependent function in a general way, do so.
Otherwise, do as best as you can, but do not call solve in your
``ode_<hint>()`` function. :py:meth:`~sympy.solvers.ode.odesimp` will attempt
to solve the solution for you, so you do not need to do that. Lastly, if your
ODE has a common simplification that can be applied to your solutions, you can
add a special case in :py:meth:`~sympy.solvers.ode.odesimp` for it. For
example, solutions returned from the ``1st_homogeneous_coeff`` hints often
have many :py:meth:`~sympy.functions.log` terms, so
:py:meth:`~sympy.solvers.ode.odesimp` calls
:py:meth:`~sympy.simplify.simplify.logcombine` on them (it also helps to write
the arbitrary constant as ``log(C1)`` instead of ``C1`` in this case). Also
consider common ways that you can rearrange your solution to have
:py:meth:`~sympy.solvers.ode.constantsimp` take better advantage of it. It is
better to put simplification in :py:meth:`~sympy.solvers.ode.odesimp` than in
your method, because it can then be turned off with the simplify flag in
:py:meth:`~sympy.solvers.ode.dsolve`. If you have any extraneous
simplification in your function, be sure to only run it using ``if
match.get('simplify', True):``, especially if it can be slow or if it can
reduce the domain of the solution.
Finally, as with every contribution to SymPy, your method will need to be
tested. Add a test for each method in ``test_ode.py``. Follow the
conventions there, i.e., test the solver using ``dsolve(eq, f(x),
hint=your_hint)``, and also test the solution using
:py:meth:`~sympy.solvers.ode.checkodesol` (you can put these in a separate
tests and skip/XFAIL if it runs too slow/doesn't work). Be sure to call your
hint specifically in :py:meth:`~sympy.solvers.ode.dsolve`, that way the test
won't be broken simply by the introduction of another matching hint. If your
method works for higher order (>1) ODEs, you will need to run ``sol =
constant_renumber(sol, 'C', 1, order)`` for each solution, where ``order`` is
the order of the ODE. This is because ``constant_renumber`` renumbers the
arbitrary constants by printing order, which is platform dependent. Try to
test every corner case of your solver, including a range of orders if it is a
`n`\th order solver, but if your solver is slow, such as if it involves hard
integration, try to keep the test run time down.
Feel free to refactor existing hints to avoid duplicating code or creating
inconsistencies. If you can show that your method exactly duplicates an
existing method, including in the simplicity and speed of obtaining the
solutions, then you can remove the old, less general method. The existing
code is tested extensively in ``test_ode.py``, so if anything is broken, one
of those tests will surely fail.
"""
from __future__ import print_function, division
from collections import defaultdict
from itertools import islice
from sympy.core import Add, S, Mul, Pow, oo
from sympy.core.compatibility import ordered, iterable, is_sequence, range, string_types
from sympy.core.containers import Tuple
from sympy.core.exprtools import factor_terms
from sympy.core.expr import AtomicExpr, Expr
from sympy.core.function import (Function, Derivative, AppliedUndef, diff,
expand, expand_mul, Subs, _mexpand)
from sympy.core.multidimensional import vectorize
from sympy.core.numbers import NaN, zoo, I, Number
from sympy.core.relational import Equality, Eq
from sympy.core.symbol import Symbol, Wild, Dummy, symbols
from sympy.core.sympify import sympify
from sympy.logic.boolalg import (BooleanAtom, And, Not, BooleanTrue,
BooleanFalse)
from sympy.functions import cos, exp, im, log, re, sin, tan, sqrt, \
atan2, conjugate, Piecewise
from sympy.functions.combinatorial.factorials import factorial
from sympy.integrals.integrals import Integral, integrate
from sympy.matrices import wronskian, Matrix, eye, zeros
from sympy.polys import (Poly, RootOf, rootof, terms_gcd,
PolynomialError, lcm, roots)
from sympy.polys.polyroots import roots_quartic
from sympy.polys.polytools import cancel, degree, div
from sympy.series import Order
from sympy.series.series import series
from sympy.simplify import collect, logcombine, powsimp, separatevars, \
simplify, trigsimp, posify, cse
from sympy.simplify.powsimp import powdenest
from sympy.simplify.radsimp import collect_const
from sympy.solvers import solve
from sympy.solvers.pde import pdsolve
from sympy.utilities import numbered_symbols, default_sort_key, sift
from sympy.solvers.deutils import _preprocess, ode_order, _desolve
#: This is a list of hints in the order that they should be preferred by
#: :py:meth:`~sympy.solvers.ode.classify_ode`. In general, hints earlier in the
#: list should produce simpler solutions than those later in the list (for
#: ODEs that fit both). For now, the order of this list is based on empirical
#: observations by the developers of SymPy.
#:
#: The hint used by :py:meth:`~sympy.solvers.ode.dsolve` for a specific ODE
#: can be overridden (see the docstring).
#:
#: In general, ``_Integral`` hints are grouped at the end of the list, unless
#: there is a method that returns an unevaluable integral most of the time
#: (which go near the end of the list anyway). ``default``, ``all``,
#: ``best``, and ``all_Integral`` meta-hints should not be included in this
#: list, but ``_best`` and ``_Integral`` hints should be included.
allhints = (
"nth_algebraic",
"separable",
"1st_exact",
"1st_linear",
"Bernoulli",
"Riccati_special_minus2",
"1st_homogeneous_coeff_best",
"1st_homogeneous_coeff_subs_indep_div_dep",
"1st_homogeneous_coeff_subs_dep_div_indep",
"almost_linear",
"linear_coefficients",
"separable_reduced",
"1st_power_series",
"lie_group",
"nth_linear_constant_coeff_homogeneous",
"nth_linear_euler_eq_homogeneous",
"nth_linear_constant_coeff_undetermined_coefficients",
"nth_linear_euler_eq_nonhomogeneous_undetermined_coefficients",
"nth_linear_constant_coeff_variation_of_parameters",
"nth_linear_euler_eq_nonhomogeneous_variation_of_parameters",
"Liouville",
"nth_order_reducible",
"2nd_power_series_ordinary",
"2nd_power_series_regular",
"nth_algebraic_Integral",
"separable_Integral",
"1st_exact_Integral",
"1st_linear_Integral",
"Bernoulli_Integral",
"1st_homogeneous_coeff_subs_indep_div_dep_Integral",
"1st_homogeneous_coeff_subs_dep_div_indep_Integral",
"almost_linear_Integral",
"linear_coefficients_Integral",
"separable_reduced_Integral",
"nth_linear_constant_coeff_variation_of_parameters_Integral",
"nth_linear_euler_eq_nonhomogeneous_variation_of_parameters_Integral",
"Liouville_Integral",
)
lie_heuristics = (
"abaco1_simple",
"abaco1_product",
"abaco2_similar",
"abaco2_unique_unknown",
"abaco2_unique_general",
"linear",
"function_sum",
"bivariate",
"chi"
)
def sub_func_doit(eq, func, new):
r"""
When replacing the func with something else, we usually want the
derivative evaluated, so this function helps in making that happen.
Examples
========
>>> from sympy import Derivative, symbols, Function
>>> from sympy.solvers.ode import sub_func_doit
>>> x, z = symbols('x, z')
>>> y = Function('y')
>>> sub_func_doit(3*Derivative(y(x), x) - 1, y(x), x)
2
>>> sub_func_doit(x*Derivative(y(x), x) - y(x)**2 + y(x), y(x),
... 1/(x*(z + 1/x)))
x*(-1/(x**2*(z + 1/x)) + 1/(x**3*(z + 1/x)**2)) + 1/(x*(z + 1/x))
...- 1/(x**2*(z + 1/x)**2)
"""
reps= {func: new}
for d in eq.atoms(Derivative):
if d.expr == func:
reps[d] = new.diff(*d.variable_count)
else:
reps[d] = d.xreplace({func: new}).doit(deep=False)
return eq.xreplace(reps)
def get_numbered_constants(eq, num=1, start=1, prefix='C'):
"""
Returns a list of constants that do not occur
in eq already.
"""
ncs = iter_numbered_constants(eq, start, prefix)
Cs = [next(ncs) for i in range(num)]
return (Cs[0] if num == 1 else tuple(Cs))
def iter_numbered_constants(eq, start=1, prefix='C'):
"""
Returns an iterator of constants that do not occur
in eq already.
"""
if isinstance(eq, Expr):
eq = [eq]
elif not iterable(eq):
raise ValueError("Expected Expr or iterable but got %s" % eq)
atom_set = set().union(*[i.free_symbols for i in eq])
func_set = set().union(*[i.atoms(Function) for i in eq])
if func_set:
atom_set |= {Symbol(str(f.func)) for f in func_set}
return numbered_symbols(start=start, prefix=prefix, exclude=atom_set)
def dsolve(eq, func=None, hint="default", simplify=True,
ics= None, xi=None, eta=None, x0=0, n=6, **kwargs):
r"""
Solves any (supported) kind of ordinary differential equation and
system of ordinary differential equations.
For single ordinary differential equation
=========================================
It is classified under this when number of equation in ``eq`` is one.
**Usage**
``dsolve(eq, f(x), hint)`` -> Solve ordinary differential equation
``eq`` for function ``f(x)``, using method ``hint``.
**Details**
``eq`` can be any supported ordinary differential equation (see the
:py:mod:`~sympy.solvers.ode` docstring for supported methods).
This can either be an :py:class:`~sympy.core.relational.Equality`,
or an expression, which is assumed to be equal to ``0``.
``f(x)`` is a function of one variable whose derivatives in that
variable make up the ordinary differential equation ``eq``. In
many cases it is not necessary to provide this; it will be
autodetected (and an error raised if it couldn't be detected).
``hint`` is the solving method that you want dsolve to use. Use
``classify_ode(eq, f(x))`` to get all of the possible hints for an
ODE. The default hint, ``default``, will use whatever hint is
returned first by :py:meth:`~sympy.solvers.ode.classify_ode`. See
Hints below for more options that you can use for hint.
``simplify`` enables simplification by
:py:meth:`~sympy.solvers.ode.odesimp`. See its docstring for more
information. Turn this off, for example, to disable solving of
solutions for ``func`` or simplification of arbitrary constants.
It will still integrate with this hint. Note that the solution may
contain more arbitrary constants than the order of the ODE with
this option enabled.
``xi`` and ``eta`` are the infinitesimal functions of an ordinary
differential equation. They are the infinitesimals of the Lie group
of point transformations for which the differential equation is
invariant. The user can specify values for the infinitesimals. If
nothing is specified, ``xi`` and ``eta`` are calculated using
:py:meth:`~sympy.solvers.ode.infinitesimals` with the help of various
heuristics.
``ics`` is the set of initial/boundary conditions for the differential equation.
It should be given in the form of ``{f(x0): x1, f(x).diff(x).subs(x, x2):
x3}`` and so on. For power series solutions, if no initial
conditions are specified ``f(0)`` is assumed to be ``C0`` and the power
series solution is calculated about 0.
``x0`` is the point about which the power series solution of a differential
equation is to be evaluated.
``n`` gives the exponent of the dependent variable up to which the power series
solution of a differential equation is to be evaluated.
**Hints**
Aside from the various solving methods, there are also some meta-hints
that you can pass to :py:meth:`~sympy.solvers.ode.dsolve`:
``default``:
This uses whatever hint is returned first by
:py:meth:`~sympy.solvers.ode.classify_ode`. This is the
default argument to :py:meth:`~sympy.solvers.ode.dsolve`.
``all``:
To make :py:meth:`~sympy.solvers.ode.dsolve` apply all
relevant classification hints, use ``dsolve(ODE, func,
hint="all")``. This will return a dictionary of
``hint:solution`` terms. If a hint causes dsolve to raise the
``NotImplementedError``, value of that hint's key will be the
exception object raised. The dictionary will also include
some special keys:
- ``order``: The order of the ODE. See also
:py:meth:`~sympy.solvers.deutils.ode_order` in
``deutils.py``.
- ``best``: The simplest hint; what would be returned by
``best`` below.
- ``best_hint``: The hint that would produce the solution
given by ``best``. If more than one hint produces the best
solution, the first one in the tuple returned by
:py:meth:`~sympy.solvers.ode.classify_ode` is chosen.
- ``default``: The solution that would be returned by default.
This is the one produced by the hint that appears first in
the tuple returned by
:py:meth:`~sympy.solvers.ode.classify_ode`.
``all_Integral``:
This is the same as ``all``, except if a hint also has a
corresponding ``_Integral`` hint, it only returns the
``_Integral`` hint. This is useful if ``all`` causes
:py:meth:`~sympy.solvers.ode.dsolve` to hang because of a
difficult or impossible integral. This meta-hint will also be
much faster than ``all``, because
:py:meth:`~sympy.core.expr.Expr.integrate` is an expensive
routine.
``best``:
To have :py:meth:`~sympy.solvers.ode.dsolve` try all methods
and return the simplest one. This takes into account whether
the solution is solvable in the function, whether it contains
any Integral classes (i.e. unevaluatable integrals), and
which one is the shortest in size.
See also the :py:meth:`~sympy.solvers.ode.classify_ode` docstring for
more info on hints, and the :py:mod:`~sympy.solvers.ode` docstring for
a list of all supported hints.
**Tips**
- You can declare the derivative of an unknown function this way:
>>> from sympy import Function, Derivative
>>> from sympy.abc import x # x is the independent variable
>>> f = Function("f")(x) # f is a function of x
>>> # f_ will be the derivative of f with respect to x
>>> f_ = Derivative(f, x)
- See ``test_ode.py`` for many tests, which serves also as a set of
examples for how to use :py:meth:`~sympy.solvers.ode.dsolve`.
- :py:meth:`~sympy.solvers.ode.dsolve` always returns an
:py:class:`~sympy.core.relational.Equality` class (except for the
case when the hint is ``all`` or ``all_Integral``). If possible, it
solves the solution explicitly for the function being solved for.
Otherwise, it returns an implicit solution.
- Arbitrary constants are symbols named ``C1``, ``C2``, and so on.
- Because all solutions should be mathematically equivalent, some
hints may return the exact same result for an ODE. Often, though,
two different hints will return the same solution formatted
differently. The two should be equivalent. Also note that sometimes
the values of the arbitrary constants in two different solutions may
not be the same, because one constant may have "absorbed" other
constants into it.
- Do ``help(ode.ode_<hintname>)`` to get help more information on a
specific hint, where ``<hintname>`` is the name of a hint without
``_Integral``.
For system of ordinary differential equations
=============================================
**Usage**
``dsolve(eq, func)`` -> Solve a system of ordinary differential
equations ``eq`` for ``func`` being list of functions including
`x(t)`, `y(t)`, `z(t)` where number of functions in the list depends
upon the number of equations provided in ``eq``.
**Details**
``eq`` can be any supported system of ordinary differential equations
This can either be an :py:class:`~sympy.core.relational.Equality`,
or an expression, which is assumed to be equal to ``0``.
``func`` holds ``x(t)`` and ``y(t)`` being functions of one variable which
together with some of their derivatives make up the system of ordinary
differential equation ``eq``. It is not necessary to provide this; it
will be autodetected (and an error raised if it couldn't be detected).
**Hints**
The hints are formed by parameters returned by classify_sysode, combining
them give hints name used later for forming method name.
Examples
========
>>> from sympy import Function, dsolve, Eq, Derivative, sin, cos, symbols
>>> from sympy.abc import x
>>> f = Function('f')
>>> dsolve(Derivative(f(x), x, x) + 9*f(x), f(x))
Eq(f(x), C1*sin(3*x) + C2*cos(3*x))
>>> eq = sin(x)*cos(f(x)) + cos(x)*sin(f(x))*f(x).diff(x)
>>> dsolve(eq, hint='1st_exact')
[Eq(f(x), -acos(C1/cos(x)) + 2*pi), Eq(f(x), acos(C1/cos(x)))]
>>> dsolve(eq, hint='almost_linear')
[Eq(f(x), -acos(C1/cos(x)) + 2*pi), Eq(f(x), acos(C1/cos(x)))]
>>> t = symbols('t')
>>> x, y = symbols('x, y', cls=Function)
>>> eq = (Eq(Derivative(x(t),t), 12*t*x(t) + 8*y(t)), Eq(Derivative(y(t),t), 21*x(t) + 7*t*y(t)))
>>> dsolve(eq)
[Eq(x(t), C1*x0(t) + C2*x0(t)*Integral(8*exp(Integral(7*t, t))*exp(Integral(12*t, t))/x0(t)**2, t)),
Eq(y(t), C1*y0(t) + C2*(y0(t)*Integral(8*exp(Integral(7*t, t))*exp(Integral(12*t, t))/x0(t)**2, t) +
exp(Integral(7*t, t))*exp(Integral(12*t, t))/x0(t)))]
>>> eq = (Eq(Derivative(x(t),t),x(t)*y(t)*sin(t)), Eq(Derivative(y(t),t),y(t)**2*sin(t)))
>>> dsolve(eq)
{Eq(x(t), -exp(C1)/(C2*exp(C1) - cos(t))), Eq(y(t), -1/(C1 - cos(t)))}
"""
if iterable(eq):
match = classify_sysode(eq, func)
eq = match['eq']
order = match['order']
func = match['func']
t = list(list(eq[0].atoms(Derivative))[0].atoms(Symbol))[0]
# keep highest order term coefficient positive
for i in range(len(eq)):
for func_ in func:
if isinstance(func_, list):
pass
else:
if eq[i].coeff(diff(func[i],t,ode_order(eq[i], func[i]))).is_negative:
eq[i] = -eq[i]
match['eq'] = eq
if len(set(order.values()))!=1:
raise ValueError("It solves only those systems of equations whose orders are equal")
match['order'] = list(order.values())[0]
def recur_len(l):
return sum(recur_len(item) if isinstance(item,list) else 1 for item in l)
if recur_len(func) != len(eq):
raise ValueError("dsolve() and classify_sysode() work with "
"number of functions being equal to number of equations")
if match['type_of_equation'] is None:
raise NotImplementedError
else:
if match['is_linear'] == True:
if match['no_of_equation'] > 3:
solvefunc = globals()['sysode_linear_neq_order%(order)s' % match]
else:
solvefunc = globals()['sysode_linear_%(no_of_equation)seq_order%(order)s' % match]
else:
solvefunc = globals()['sysode_nonlinear_%(no_of_equation)seq_order%(order)s' % match]
sols = solvefunc(match)
if ics:
constants = Tuple(*sols).free_symbols - Tuple(*eq).free_symbols
solved_constants = solve_ics(sols, func, constants, ics)
return [sol.subs(solved_constants) for sol in sols]
return sols
else:
given_hint = hint # hint given by the user
# See the docstring of _desolve for more details.
hints = _desolve(eq, func=func,
hint=hint, simplify=True, xi=xi, eta=eta, type='ode', ics=ics,
x0=x0, n=n, **kwargs)
eq = hints.pop('eq', eq)
all_ = hints.pop('all', False)
if all_:
retdict = {}
failed_hints = {}
gethints = classify_ode(eq, dict=True)
orderedhints = gethints['ordered_hints']
for hint in hints:
try:
rv = _helper_simplify(eq, hint, hints[hint], simplify)
except NotImplementedError as detail:
failed_hints[hint] = detail
else:
retdict[hint] = rv
func = hints[hint]['func']
retdict['best'] = min(list(retdict.values()), key=lambda x:
ode_sol_simplicity(x, func, trysolving=not simplify))
if given_hint == 'best':
return retdict['best']
for i in orderedhints:
if retdict['best'] == retdict.get(i, None):
retdict['best_hint'] = i
break
retdict['default'] = gethints['default']
retdict['order'] = gethints['order']
retdict.update(failed_hints)
return retdict
else:
# The key 'hint' stores the hint needed to be solved for.
hint = hints['hint']
return _helper_simplify(eq, hint, hints, simplify, ics=ics)
def _helper_simplify(eq, hint, match, simplify=True, ics=None, **kwargs):
r"""
Helper function of dsolve that calls the respective
:py:mod:`~sympy.solvers.ode` functions to solve for the ordinary
differential equations. This minimizes the computation in calling
:py:meth:`~sympy.solvers.deutils._desolve` multiple times.
"""
r = match
if hint.endswith('_Integral'):
solvefunc = globals()['ode_' + hint[:-len('_Integral')]]
else:
solvefunc = globals()['ode_' + hint]
func = r['func']
order = r['order']
match = r[hint]
free = eq.free_symbols
cons = lambda s: s.free_symbols.difference(free)
if simplify:
# odesimp() will attempt to integrate, if necessary, apply constantsimp(),
# attempt to solve for func, and apply any other hint specific
# simplifications
sols = solvefunc(eq, func, order, match)
if isinstance(sols, Expr):
rv = odesimp(eq, sols, func, hint)
else:
rv = [odesimp(eq, s, func, hint) for s in sols]
else:
# We still want to integrate (you can disable it separately with the hint)
match['simplify'] = False # Some hints can take advantage of this option
rv = _handle_Integral(solvefunc(eq, func, order, match), func, hint)
if ics and not 'power_series' in hint:
if isinstance(rv, Expr):
solved_constants = solve_ics([rv], [r['func']], cons(rv), ics)
rv = rv.subs(solved_constants)
else:
rv1 = []
for s in rv:
try:
solved_constants = solve_ics([s], [r['func']], cons(s), ics)
except ValueError:
continue
rv1.append(s.subs(solved_constants))
if len(rv1) == 1:
return rv1[0]
rv = rv1
return rv
def solve_ics(sols, funcs, constants, ics):
"""
Solve for the constants given initial conditions
``sols`` is a list of solutions.
``funcs`` is a list of functions.
``constants`` is a list of constants.
``ics`` is the set of initial/boundary conditions for the differential
equation. It should be given in the form of ``{f(x0): x1,
f(x).diff(x).subs(x, x2): x3}`` and so on.
Returns a dictionary mapping constants to values.
``solution.subs(constants)`` will replace the constants in ``solution``.
Example
=======
>>> # From dsolve(f(x).diff(x) - f(x), f(x))
>>> from sympy import symbols, Eq, exp, Function
>>> from sympy.solvers.ode import solve_ics
>>> f = Function('f')
>>> x, C1 = symbols('x C1')
>>> sols = [Eq(f(x), C1*exp(x))]
>>> funcs = [f(x)]
>>> constants = [C1]
>>> ics = {f(0): 2}
>>> solved_constants = solve_ics(sols, funcs, constants, ics)
>>> solved_constants
{C1: 2}
>>> sols[0].subs(solved_constants)
Eq(f(x), 2*exp(x))
"""
# Assume ics are of the form f(x0): value or Subs(diff(f(x), x, n), (x,
# x0)): value (currently checked by classify_ode). To solve, replace x
# with x0, f(x0) with value, then solve for constants. For f^(n)(x0),
# differentiate the solution n times, so that f^(n)(x) appears.
x = funcs[0].args[0]
diff_sols = []
subs_sols = []
diff_variables = set()
for funcarg, value in ics.items():
if isinstance(funcarg, AppliedUndef):
x0 = funcarg.args[0]
matching_func = [f for f in funcs if f.func == funcarg.func][0]
S = sols
elif isinstance(funcarg, (Subs, Derivative)):
if isinstance(funcarg, Subs):
# Make sure it stays a subs. Otherwise subs below will produce
# a different looking term.
funcarg = funcarg.doit()
if isinstance(funcarg, Subs):
deriv = funcarg.expr
x0 = funcarg.point[0]
variables = funcarg.expr.variables
matching_func = deriv
elif isinstance(funcarg, Derivative):
deriv = funcarg
x0 = funcarg.variables[0]
variables = (x,)*len(funcarg.variables)
matching_func = deriv.subs(x0, x)
if variables not in diff_variables:
for sol in sols:
if sol.has(deriv.expr.func):
diff_sols.append(Eq(sol.lhs.diff(*variables), sol.rhs.diff(*variables)))
diff_variables.add(variables)
S = diff_sols
else:
raise NotImplementedError("Unrecognized initial condition")
for sol in S:
if sol.has(matching_func):
sol2 = sol
sol2 = sol2.subs(x, x0)
sol2 = sol2.subs(funcarg, value)
# This check is necessary because of issue #15724
if not isinstance(sol2, BooleanAtom) or not subs_sols:
subs_sols = [s for s in subs_sols if not isinstance(s, BooleanAtom)]
subs_sols.append(sol2)
# TODO: Use solveset here
try:
solved_constants = solve(subs_sols, constants, dict=True)
except NotImplementedError:
solved_constants = []
# XXX: We can't differentiate between the solution not existing because of
# invalid initial conditions, and not existing because solve is not smart
# enough. If we could use solveset, this might be improvable, but for now,
# we use NotImplementedError in this case.
if not solved_constants:
raise ValueError("Couldn't solve for initial conditions")
if solved_constants == True:
raise ValueError("Initial conditions did not produce any solutions for constants. Perhaps they are degenerate.")
if len(solved_constants) > 1:
raise NotImplementedError("Initial conditions produced too many solutions for constants")
return solved_constants[0]
def classify_ode(eq, func=None, dict=False, ics=None, **kwargs):
r"""
Returns a tuple of possible :py:meth:`~sympy.solvers.ode.dsolve`
classifications for an ODE.
The tuple is ordered so that first item is the classification that
:py:meth:`~sympy.solvers.ode.dsolve` uses to solve the ODE by default. In
general, classifications at the near the beginning of the list will
produce better solutions faster than those near the end, thought there are
always exceptions. To make :py:meth:`~sympy.solvers.ode.dsolve` use a
different classification, use ``dsolve(ODE, func,
hint=<classification>)``. See also the
:py:meth:`~sympy.solvers.ode.dsolve` docstring for different meta-hints
you can use.
If ``dict`` is true, :py:meth:`~sympy.solvers.ode.classify_ode` will
return a dictionary of ``hint:match`` expression terms. This is intended
for internal use by :py:meth:`~sympy.solvers.ode.dsolve`. Note that
because dictionaries are ordered arbitrarily, this will most likely not be
in the same order as the tuple.
You can get help on different hints by executing
``help(ode.ode_hintname)``, where ``hintname`` is the name of the hint
without ``_Integral``.
See :py:data:`~sympy.solvers.ode.allhints` or the
:py:mod:`~sympy.solvers.ode` docstring for a list of all supported hints
that can be returned from :py:meth:`~sympy.solvers.ode.classify_ode`.
Notes
=====
These are remarks on hint names.
``_Integral``
If a classification has ``_Integral`` at the end, it will return the
expression with an unevaluated :py:class:`~sympy.integrals.Integral`
class in it. Note that a hint may do this anyway if
:py:meth:`~sympy.core.expr.Expr.integrate` cannot do the integral,
though just using an ``_Integral`` will do so much faster. Indeed, an
``_Integral`` hint will always be faster than its corresponding hint
without ``_Integral`` because
:py:meth:`~sympy.core.expr.Expr.integrate` is an expensive routine.
If :py:meth:`~sympy.solvers.ode.dsolve` hangs, it is probably because
:py:meth:`~sympy.core.expr.Expr.integrate` is hanging on a tough or
impossible integral. Try using an ``_Integral`` hint or
``all_Integral`` to get it return something.
Note that some hints do not have ``_Integral`` counterparts. This is
because :py:meth:`~sympy.solvers.ode.integrate` is not used in solving
the ODE for those method. For example, `n`\th order linear homogeneous
ODEs with constant coefficients do not require integration to solve,
so there is no ``nth_linear_homogeneous_constant_coeff_Integrate``
hint. You can easily evaluate any unevaluated
:py:class:`~sympy.integrals.Integral`\s in an expression by doing
``expr.doit()``.
Ordinals
Some hints contain an ordinal such as ``1st_linear``. This is to help
differentiate them from other hints, as well as from other methods
that may not be implemented yet. If a hint has ``nth`` in it, such as
the ``nth_linear`` hints, this means that the method used to applies
to ODEs of any order.
``indep`` and ``dep``
Some hints contain the words ``indep`` or ``dep``. These reference
the independent variable and the dependent function, respectively. For
example, if an ODE is in terms of `f(x)`, then ``indep`` will refer to
`x` and ``dep`` will refer to `f`.
``subs``
If a hints has the word ``subs`` in it, it means the the ODE is solved
by substituting the expression given after the word ``subs`` for a
single dummy variable. This is usually in terms of ``indep`` and
``dep`` as above. The substituted expression will be written only in
characters allowed for names of Python objects, meaning operators will
be spelled out. For example, ``indep``/``dep`` will be written as
``indep_div_dep``.
``coeff``
The word ``coeff`` in a hint refers to the coefficients of something
in the ODE, usually of the derivative terms. See the docstring for
the individual methods for more info (``help(ode)``). This is
contrast to ``coefficients``, as in ``undetermined_coefficients``,
which refers to the common name of a method.
``_best``
Methods that have more than one fundamental way to solve will have a
hint for each sub-method and a ``_best`` meta-classification. This
will evaluate all hints and return the best, using the same
considerations as the normal ``best`` meta-hint.
Examples
========
>>> from sympy import Function, classify_ode, Eq
>>> from sympy.abc import x
>>> f = Function('f')
>>> classify_ode(Eq(f(x).diff(x), 0), f(x))
('nth_algebraic', 'separable', '1st_linear', '1st_homogeneous_coeff_best',
'1st_homogeneous_coeff_subs_indep_div_dep',
'1st_homogeneous_coeff_subs_dep_div_indep',
'1st_power_series', 'lie_group',
'nth_linear_constant_coeff_homogeneous',
'nth_linear_euler_eq_homogeneous', 'nth_algebraic_Integral',
'separable_Integral', '1st_linear_Integral',
'1st_homogeneous_coeff_subs_indep_div_dep_Integral',
'1st_homogeneous_coeff_subs_dep_div_indep_Integral')
>>> classify_ode(f(x).diff(x, 2) + 3*f(x).diff(x) + 2*f(x) - 4)
('nth_linear_constant_coeff_undetermined_coefficients',
'nth_linear_constant_coeff_variation_of_parameters',
'nth_linear_constant_coeff_variation_of_parameters_Integral')
"""
ics = sympify(ics)
prep = kwargs.pop('prep', True)
if func and len(func.args) != 1:
raise ValueError("dsolve() and classify_ode() only "
"work with functions of one variable, not %s" % func)
if prep or func is None:
eq, func_ = _preprocess(eq, func)
if func is None:
func = func_
x = func.args[0]
f = func.func
y = Dummy('y')
xi = kwargs.get('xi')
eta = kwargs.get('eta')
terms = kwargs.get('n')
if isinstance(eq, Equality):
if eq.rhs != 0:
return classify_ode(eq.lhs - eq.rhs, func, dict=dict, ics=ics, xi=xi,
n=terms, eta=eta, prep=False)
eq = eq.lhs
order = ode_order(eq, f(x))
# hint:matchdict or hint:(tuple of matchdicts)
# Also will contain "default":<default hint> and "order":order items.
matching_hints = {"order": order}
if not order:
if dict:
matching_hints["default"] = None
return matching_hints
else:
return ()
df = f(x).diff(x)
a = Wild('a', exclude=[f(x)])
b = Wild('b', exclude=[f(x)])
c = Wild('c', exclude=[f(x)])
d = Wild('d', exclude=[df, f(x).diff(x, 2)])
e = Wild('e', exclude=[df])
k = Wild('k', exclude=[df])
n = Wild('n', exclude=[x, f(x), df])
c1 = Wild('c1', exclude=[x])
a2 = Wild('a2', exclude=[x, f(x), df])
b2 = Wild('b2', exclude=[x, f(x), df])
c2 = Wild('c2', exclude=[x, f(x), df])
d2 = Wild('d2', exclude=[x, f(x), df])
a3 = Wild('a3', exclude=[f(x), df, f(x).diff(x, 2)])
b3 = Wild('b3', exclude=[f(x), df, f(x).diff(x, 2)])
c3 = Wild('c3', exclude=[f(x), df, f(x).diff(x, 2)])
r3 = {'xi': xi, 'eta': eta} # Used for the lie_group hint
boundary = {} # Used to extract initial conditions
C1 = Symbol("C1")
eq = expand(eq)
# Preprocessing to get the initial conditions out
if ics is not None:
for funcarg in ics:
# Separating derivatives
if isinstance(funcarg, (Subs, Derivative)):
# f(x).diff(x).subs(x, 0) is a Subs, but f(x).diff(x).subs(x,
# y) is a Derivative
if isinstance(funcarg, Subs):
deriv = funcarg.expr
old = funcarg.variables[0]
new = funcarg.point[0]
elif isinstance(funcarg, Derivative):
deriv = funcarg
# No information on this. Just assume it was x
old = x
new = funcarg.variables[0]
if (isinstance(deriv, Derivative) and isinstance(deriv.args[0],
AppliedUndef) and deriv.args[0].func == f and
len(deriv.args[0].args) == 1 and old == x and not
new.has(x) and all(i == deriv.variables[0] for i in
deriv.variables) and not ics[funcarg].has(f)):
dorder = ode_order(deriv, x)
temp = 'f' + str(dorder)
boundary.update({temp: new, temp + 'val': ics[funcarg]})
else:
raise ValueError("Enter valid boundary conditions for Derivatives")
# Separating functions
elif isinstance(funcarg, AppliedUndef):
if (funcarg.func == f and len(funcarg.args) == 1 and
not funcarg.args[0].has(x) and not ics[funcarg].has(f)):
boundary.update({'f0': funcarg.args[0], 'f0val': ics[funcarg]})
else:
raise ValueError("Enter valid boundary conditions for Function")
else:
raise ValueError("Enter boundary conditions of the form ics={f(point}: value, f(x).diff(x, order).subs(x, point): value}")
# Precondition to try remove f(x) from highest order derivative
reduced_eq = None
if eq.is_Add:
deriv_coef = eq.coeff(f(x).diff(x, order))
if deriv_coef not in (1, 0):
r = deriv_coef.match(a*f(x)**c1)
if r and r[c1]:
den = f(x)**r[c1]
reduced_eq = Add(*[arg/den for arg in eq.args])
if not reduced_eq:
reduced_eq = eq
if order == 1:
## Linear case: a(x)*y'+b(x)*y+c(x) == 0
if eq.is_Add:
ind, dep = reduced_eq.as_independent(f)
else:
u = Dummy('u')
ind, dep = (reduced_eq + u).as_independent(f)
ind, dep = [tmp.subs(u, 0) for tmp in [ind, dep]]
r = {a: dep.coeff(df),
b: dep.coeff(f(x)),
c: ind}
# double check f[a] since the preconditioning may have failed
if not r[a].has(f) and not r[b].has(f) and (
r[a]*df + r[b]*f(x) + r[c]).expand() - reduced_eq == 0:
r['a'] = a
r['b'] = b
r['c'] = c
matching_hints["1st_linear"] = r
matching_hints["1st_linear_Integral"] = r
## Bernoulli case: a(x)*y'+b(x)*y+c(x)*y**n == 0
r = collect(
reduced_eq, f(x), exact=True).match(a*df + b*f(x) + c*f(x)**n)
if r and r[c] != 0 and r[n] != 1: # See issue 4676
r['a'] = a
r['b'] = b
r['c'] = c
r['n'] = n
matching_hints["Bernoulli"] = r
matching_hints["Bernoulli_Integral"] = r
## Riccati special n == -2 case: a2*y'+b2*y**2+c2*y/x+d2/x**2 == 0
r = collect(reduced_eq,
f(x), exact=True).match(a2*df + b2*f(x)**2 + c2*f(x)/x + d2/x**2)
if r and r[b2] != 0 and (r[c2] != 0 or r[d2] != 0):
r['a2'] = a2
r['b2'] = b2
r['c2'] = c2
r['d2'] = d2
matching_hints["Riccati_special_minus2"] = r
# NON-REDUCED FORM OF EQUATION matches
r = collect(eq, df, exact=True).match(d + e * df)
if r:
r['d'] = d
r['e'] = e
r['y'] = y
r[d] = r[d].subs(f(x), y)
r[e] = r[e].subs(f(x), y)
# FIRST ORDER POWER SERIES WHICH NEEDS INITIAL CONDITIONS
# TODO: Hint first order series should match only if d/e is analytic.
# For now, only d/e and (d/e).diff(arg) is checked for existence at
# at a given point.
# This is currently done internally in ode_1st_power_series.
point = boundary.get('f0', 0)
value = boundary.get('f0val', C1)
check = cancel(r[d]/r[e])
check1 = check.subs({x: point, y: value})
if not check1.has(oo) and not check1.has(zoo) and \
not check1.has(NaN) and not check1.has(-oo):
check2 = (check1.diff(x)).subs({x: point, y: value})
if not check2.has(oo) and not check2.has(zoo) and \
not check2.has(NaN) and not check2.has(-oo):
rseries = r.copy()
rseries.update({'terms': terms, 'f0': point, 'f0val': value})
matching_hints["1st_power_series"] = rseries
r3.update(r)
## Exact Differential Equation: P(x, y) + Q(x, y)*y' = 0 where
# dP/dy == dQ/dx
try:
if r[d] != 0:
numerator = simplify(r[d].diff(y) - r[e].diff(x))
# The following few conditions try to convert a non-exact
# differential equation into an exact one.
# References : Differential equations with applications
# and historical notes - George E. Simmons
if numerator:
# If (dP/dy - dQ/dx) / Q = f(x)
# then exp(integral(f(x))*equation becomes exact
factor = simplify(numerator/r[e])
variables = factor.free_symbols
if len(variables) == 1 and x == variables.pop():
factor = exp(Integral(factor).doit())
r[d] *= factor
r[e] *= factor
matching_hints["1st_exact"] = r
matching_hints["1st_exact_Integral"] = r
else:
# If (dP/dy - dQ/dx) / -P = f(y)
# then exp(integral(f(y))*equation becomes exact
factor = simplify(-numerator/r[d])
variables = factor.free_symbols
if len(variables) == 1 and y == variables.pop():
factor = exp(Integral(factor).doit())
r[d] *= factor
r[e] *= factor
matching_hints["1st_exact"] = r
matching_hints["1st_exact_Integral"] = r
else:
matching_hints["1st_exact"] = r
matching_hints["1st_exact_Integral"] = r
except NotImplementedError:
# Differentiating the coefficients might fail because of things
# like f(2*x).diff(x). See issue 4624 and issue 4719.
pass
# Any first order ODE can be ideally solved by the Lie Group
# method
matching_hints["lie_group"] = r3
# This match is used for several cases below; we now collect on
# f(x) so the matching works.
r = collect(reduced_eq, df, exact=True).match(d + e*df)
if r:
# Using r[d] and r[e] without any modification for hints
# linear-coefficients and separable-reduced.
num, den = r[d], r[e] # ODE = d/e + df
r['d'] = d
r['e'] = e
r['y'] = y
r[d] = num.subs(f(x), y)
r[e] = den.subs(f(x), y)
## Separable Case: y' == P(y)*Q(x)
r[d] = separatevars(r[d])
r[e] = separatevars(r[e])
# m1[coeff]*m1[x]*m1[y] + m2[coeff]*m2[x]*m2[y]*y'
m1 = separatevars(r[d], dict=True, symbols=(x, y))
m2 = separatevars(r[e], dict=True, symbols=(x, y))
if m1 and m2:
r1 = {'m1': m1, 'm2': m2, 'y': y}
matching_hints["separable"] = r1
matching_hints["separable_Integral"] = r1
## First order equation with homogeneous coefficients:
# dy/dx == F(y/x) or dy/dx == F(x/y)
ordera = homogeneous_order(r[d], x, y)
if ordera is not None:
orderb = homogeneous_order(r[e], x, y)
if ordera == orderb:
# u1=y/x and u2=x/y
u1 = Dummy('u1')
u2 = Dummy('u2')
s = "1st_homogeneous_coeff_subs"
s1 = s + "_dep_div_indep"
s2 = s + "_indep_div_dep"
if simplify((r[d] + u1*r[e]).subs({x: 1, y: u1})) != 0:
matching_hints[s1] = r
matching_hints[s1 + "_Integral"] = r
if simplify((r[e] + u2*r[d]).subs({x: u2, y: 1})) != 0:
matching_hints[s2] = r
matching_hints[s2 + "_Integral"] = r
if s1 in matching_hints and s2 in matching_hints:
matching_hints["1st_homogeneous_coeff_best"] = r
## Linear coefficients of the form
# y'+ F((a*x + b*y + c)/(a'*x + b'y + c')) = 0
# that can be reduced to homogeneous form.
F = num/den
params = _linear_coeff_match(F, func)
if params:
xarg, yarg = params
u = Dummy('u')
t = Dummy('t')
# Dummy substitution for df and f(x).
dummy_eq = reduced_eq.subs(((df, t), (f(x), u)))
reps = ((x, x + xarg), (u, u + yarg), (t, df), (u, f(x)))
dummy_eq = simplify(dummy_eq.subs(reps))
# get the re-cast values for e and d
r2 = collect(expand(dummy_eq), [df, f(x)]).match(e*df + d)
if r2:
orderd = homogeneous_order(r2[d], x, f(x))
if orderd is not None:
ordere = homogeneous_order(r2[e], x, f(x))
if orderd == ordere:
# Match arguments are passed in such a way that it
# is coherent with the already existing homogeneous
# functions.
r2[d] = r2[d].subs(f(x), y)
r2[e] = r2[e].subs(f(x), y)
r2.update({'xarg': xarg, 'yarg': yarg,
'd': d, 'e': e, 'y': y})
matching_hints["linear_coefficients"] = r2
matching_hints["linear_coefficients_Integral"] = r2
## Equation of the form y' + (y/x)*H(x^n*y) = 0
# that can be reduced to separable form
factor = simplify(x/f(x)*num/den)
# Try representing factor in terms of x^n*y
# where n is lowest power of x in factor;
# first remove terms like sqrt(2)*3 from factor.atoms(Mul)
u = None
for mul in ordered(factor.atoms(Mul)):
if mul.has(x):
_, u = mul.as_independent(x, f(x))
break
if u and u.has(f(x)):
h = x**(degree(Poly(u.subs(f(x), y), gen=x)))*f(x)
p = Wild('p')
if (u/h == 1) or ((u/h).simplify().match(x**p)):
t = Dummy('t')
r2 = {'t': t}
xpart, ypart = u.as_independent(f(x))
test = factor.subs(((u, t), (1/u, 1/t)))
free = test.free_symbols
if len(free) == 1 and free.pop() == t:
r2.update({'power': xpart.as_base_exp()[1], 'u': test})
matching_hints["separable_reduced"] = r2
matching_hints["separable_reduced_Integral"] = r2
## Almost-linear equation of the form f(x)*g(y)*y' + k(x)*l(y) + m(x) = 0
r = collect(eq, [df, f(x)]).match(e*df + d)
if r:
r2 = r.copy()
r2[c] = S.Zero
if r2[d].is_Add:
# Separate the terms having f(x) to r[d] and
# remaining to r[c]
no_f, r2[d] = r2[d].as_independent(f(x))
r2[c] += no_f
factor = simplify(r2[d].diff(f(x))/r[e])
if factor and not factor.has(f(x)):
r2[d] = factor_terms(r2[d])
u = r2[d].as_independent(f(x), as_Add=False)[1]
r2.update({'a': e, 'b': d, 'c': c, 'u': u})
r2[d] /= u
r2[e] /= u.diff(f(x))
matching_hints["almost_linear"] = r2
matching_hints["almost_linear_Integral"] = r2
elif order == 2:
# Liouville ODE in the form
# f(x).diff(x, 2) + g(f(x))*(f(x).diff(x))**2 + h(x)*f(x).diff(x)
# See Goldstein and Braun, "Advanced Methods for the Solution of
# Differential Equations", pg. 98
s = d*f(x).diff(x, 2) + e*df**2 + k*df
r = reduced_eq.match(s)
if r and r[d] != 0:
y = Dummy('y')
g = simplify(r[e]/r[d]).subs(f(x), y)
h = simplify(r[k]/r[d]).subs(f(x), y)
if y in h.free_symbols or x in g.free_symbols:
pass
else:
r = {'g': g, 'h': h, 'y': y}
matching_hints["Liouville"] = r
matching_hints["Liouville_Integral"] = r
# Homogeneous second order differential equation of the form
# a3*f(x).diff(x, 2) + b3*f(x).diff(x) + c3, where
# for simplicity, a3, b3 and c3 are assumed to be polynomials.
# It has a definite power series solution at point x0 if, b3/a3 and c3/a3
# are analytic at x0.
deq = a3*(f(x).diff(x, 2)) + b3*df + c3*f(x)
r = collect(reduced_eq,
[f(x).diff(x, 2), f(x).diff(x), f(x)]).match(deq)
ordinary = False
if r and r[a3] != 0:
if all([r[key].is_polynomial() for key in r]):
p = cancel(r[b3]/r[a3]) # Used below
q = cancel(r[c3]/r[a3]) # Used below
point = kwargs.get('x0', 0)
check = p.subs(x, point)
if not check.has(oo) and not check.has(NaN) and \
not check.has(zoo) and not check.has(-oo):
check = q.subs(x, point)
if not check.has(oo) and not check.has(NaN) and \
not check.has(zoo) and not check.has(-oo):
ordinary = True
r.update({'a3': a3, 'b3': b3, 'c3': c3, 'x0': point, 'terms': terms})
matching_hints["2nd_power_series_ordinary"] = r
# Checking if the differential equation has a regular singular point
# at x0. It has a regular singular point at x0, if (b3/a3)*(x - x0)
# and (c3/a3)*((x - x0)**2) are analytic at x0.
if not ordinary:
p = cancel((x - point)*p)
check = p.subs(x, point)
if not check.has(oo) and not check.has(NaN) and \
not check.has(zoo) and not check.has(-oo):
q = cancel(((x - point)**2)*q)
check = q.subs(x, point)
if not check.has(oo) and not check.has(NaN) and \
not check.has(zoo) and not check.has(-oo):
coeff_dict = {'p': p, 'q': q, 'x0': point, 'terms': terms}
matching_hints["2nd_power_series_regular"] = coeff_dict
if order > 0:
# Any ODE that can be solved with a substitution and
# repeated integration e.g.:
# `d^2/dx^2(y) + x*d/dx(y) = constant
#f'(x) must be finite for this to work
r = _nth_order_reducible_match(reduced_eq, func)
if r:
matching_hints['nth_order_reducible'] = r
# Any ODE that can be solved with a combination of algebra and
# integrals e.g.:
# d^3/dx^3(x y) = F(x)
r = _nth_algebraic_match(reduced_eq, func)
if r['solutions']:
matching_hints['nth_algebraic'] = r
matching_hints['nth_algebraic_Integral'] = r
# nth order linear ODE
# a_n(x)y^(n) + ... + a_1(x)y' + a_0(x)y = F(x) = b
r = _nth_linear_match(reduced_eq, func, order)
# Constant coefficient case (a_i is constant for all i)
if r and not any(r[i].has(x) for i in r if i >= 0):
# Inhomogeneous case: F(x) is not identically 0
if r[-1]:
undetcoeff = _undetermined_coefficients_match(r[-1], x)
s = "nth_linear_constant_coeff_variation_of_parameters"
matching_hints[s] = r
matching_hints[s + "_Integral"] = r
if undetcoeff['test']:
r['trialset'] = undetcoeff['trialset']
matching_hints[
"nth_linear_constant_coeff_undetermined_coefficients"
] = r
# Homogeneous case: F(x) is identically 0
else:
matching_hints["nth_linear_constant_coeff_homogeneous"] = r
# nth order Euler equation a_n*x**n*y^(n) + ... + a_1*x*y' + a_0*y = F(x)
#In case of Homogeneous euler equation F(x) = 0
def _test_term(coeff, order):
r"""
Linear Euler ODEs have the form K*x**order*diff(y(x),x,order) = F(x),
where K is independent of x and y(x), order>= 0.
So we need to check that for each term, coeff == K*x**order from
some K. We have a few cases, since coeff may have several
different types.
"""
if order < 0:
raise ValueError("order should be greater than 0")
if coeff == 0:
return True
if order == 0:
if x in coeff.free_symbols:
return False
return True
if coeff.is_Mul:
if coeff.has(f(x)):
return False
return x**order in coeff.args
elif coeff.is_Pow:
return coeff.as_base_exp() == (x, order)
elif order == 1:
return x == coeff
return False
# Find coefficient for highest derivative, multiply coefficients to
# bring the equation into Euler form if possible
r_rescaled = None
if r is not None:
coeff = r[order]
factor = x**order / coeff
r_rescaled = {i: factor*r[i] for i in r}
if r_rescaled and not any(not _test_term(r_rescaled[i], i) for i in
r_rescaled if i != 'trialset' and i >= 0):
if not r_rescaled[-1]:
matching_hints["nth_linear_euler_eq_homogeneous"] = r_rescaled
else:
matching_hints["nth_linear_euler_eq_nonhomogeneous_variation_of_parameters"] = r_rescaled
matching_hints["nth_linear_euler_eq_nonhomogeneous_variation_of_parameters_Integral"] = r_rescaled
e, re = posify(r_rescaled[-1].subs(x, exp(x)))
undetcoeff = _undetermined_coefficients_match(e.subs(re), x)
if undetcoeff['test']:
r_rescaled['trialset'] = undetcoeff['trialset']
matching_hints["nth_linear_euler_eq_nonhomogeneous_undetermined_coefficients"] = r_rescaled
# Order keys based on allhints.
retlist = [i for i in allhints if i in matching_hints]
if dict:
# Dictionaries are ordered arbitrarily, so make note of which
# hint would come first for dsolve(). Use an ordered dict in Py 3.
matching_hints["default"] = retlist[0] if retlist else None
matching_hints["ordered_hints"] = tuple(retlist)
return matching_hints
else:
return tuple(retlist)
def classify_sysode(eq, funcs=None, **kwargs):
r"""
Returns a dictionary of parameter names and values that define the system
of ordinary differential equations in ``eq``.
The parameters are further used in
:py:meth:`~sympy.solvers.ode.dsolve` for solving that system.
The parameter names and values are:
'is_linear' (boolean), which tells whether the given system is linear.
Note that "linear" here refers to the operator: terms such as ``x*diff(x,t)`` are
nonlinear, whereas terms like ``sin(t)*diff(x,t)`` are still linear operators.
'func' (list) contains the :py:class:`~sympy.core.function.Function`s that
appear with a derivative in the ODE, i.e. those that we are trying to solve
the ODE for.
'order' (dict) with the maximum derivative for each element of the 'func'
parameter.
'func_coeff' (dict) with the coefficient for each triple ``(equation number,
function, order)```. The coefficients are those subexpressions that do not
appear in 'func', and hence can be considered constant for purposes of ODE
solving.
'eq' (list) with the equations from ``eq``, sympified and transformed into
expressions (we are solving for these expressions to be zero).
'no_of_equations' (int) is the number of equations (same as ``len(eq)``).
'type_of_equation' (string) is an internal classification of the type of
ODE.
References
==========
-http://eqworld.ipmnet.ru/en/solutions/sysode/sode-toc1.htm
-A. D. Polyanin and A. V. Manzhirov, Handbook of Mathematics for Engineers and Scientists
Examples
========
>>> from sympy import Function, Eq, symbols, diff
>>> from sympy.solvers.ode import classify_sysode
>>> from sympy.abc import t
>>> f, x, y = symbols('f, x, y', cls=Function)
>>> k, l, m, n = symbols('k, l, m, n', Integer=True)
>>> x1 = diff(x(t), t) ; y1 = diff(y(t), t)
>>> x2 = diff(x(t), t, t) ; y2 = diff(y(t), t, t)
>>> eq = (Eq(5*x1, 12*x(t) - 6*y(t)), Eq(2*y1, 11*x(t) + 3*y(t)))
>>> classify_sysode(eq)
{'eq': [-12*x(t) + 6*y(t) + 5*Derivative(x(t), t), -11*x(t) - 3*y(t) + 2*Derivative(y(t), t)],
'func': [x(t), y(t)], 'func_coeff': {(0, x(t), 0): -12, (0, x(t), 1): 5, (0, y(t), 0): 6,
(0, y(t), 1): 0, (1, x(t), 0): -11, (1, x(t), 1): 0, (1, y(t), 0): -3, (1, y(t), 1): 2},
'is_linear': True, 'no_of_equation': 2, 'order': {x(t): 1, y(t): 1}, 'type_of_equation': 'type1'}
>>> eq = (Eq(diff(x(t),t), 5*t*x(t) + t**2*y(t)), Eq(diff(y(t),t), -t**2*x(t) + 5*t*y(t)))
>>> classify_sysode(eq)
{'eq': [-t**2*y(t) - 5*t*x(t) + Derivative(x(t), t), t**2*x(t) - 5*t*y(t) + Derivative(y(t), t)],
'func': [x(t), y(t)], 'func_coeff': {(0, x(t), 0): -5*t, (0, x(t), 1): 1, (0, y(t), 0): -t**2,
(0, y(t), 1): 0, (1, x(t), 0): t**2, (1, x(t), 1): 0, (1, y(t), 0): -5*t, (1, y(t), 1): 1},
'is_linear': True, 'no_of_equation': 2, 'order': {x(t): 1, y(t): 1}, 'type_of_equation': 'type4'}
"""
# Sympify equations and convert iterables of equations into
# a list of equations
def _sympify(eq):
return list(map(sympify, eq if iterable(eq) else [eq]))
eq, funcs = (_sympify(w) for w in [eq, funcs])
for i, fi in enumerate(eq):
if isinstance(fi, Equality):
eq[i] = fi.lhs - fi.rhs
matching_hints = {"no_of_equation":i+1}
matching_hints['eq'] = eq
if i==0:
raise ValueError("classify_sysode() works for systems of ODEs. "
"For scalar ODEs, classify_ode should be used")
t = list(list(eq[0].atoms(Derivative))[0].atoms(Symbol))[0]
# find all the functions if not given
order = dict()
if funcs==[None]:
funcs = []
for eqs in eq:
derivs = eqs.atoms(Derivative)
func = set().union(*[d.atoms(AppliedUndef) for d in derivs])
for func_ in func:
funcs.append(func_)
funcs = list(set(funcs))
if len(funcs) != len(eq):
raise ValueError("Number of functions given is not equal to the number of equations %s" % funcs)
func_dict = dict()
for func in funcs:
if not order.get(func, False):
max_order = 0
for i, eqs_ in enumerate(eq):
order_ = ode_order(eqs_,func)
if max_order < order_:
max_order = order_
eq_no = i
if eq_no in func_dict:
list_func = []
list_func.append(func_dict[eq_no])
list_func.append(func)
func_dict[eq_no] = list_func
else:
func_dict[eq_no] = func
order[func] = max_order
funcs = [func_dict[i] for i in range(len(func_dict))]
matching_hints['func'] = funcs
for func in funcs:
if isinstance(func, list):
for func_elem in func:
if len(func_elem.args) != 1:
raise ValueError("dsolve() and classify_sysode() work with "
"functions of one variable only, not %s" % func)
else:
if func and len(func.args) != 1:
raise ValueError("dsolve() and classify_sysode() work with "
"functions of one variable only, not %s" % func)
# find the order of all equation in system of odes
matching_hints["order"] = order
# find coefficients of terms f(t), diff(f(t),t) and higher derivatives
# and similarly for other functions g(t), diff(g(t),t) in all equations.
# Here j denotes the equation number, funcs[l] denotes the function about
# which we are talking about and k denotes the order of function funcs[l]
# whose coefficient we are calculating.
def linearity_check(eqs, j, func, is_linear_):
for k in range(order[func] + 1):
func_coef[j, func, k] = collect(eqs.expand(), [diff(func, t, k)]).coeff(diff(func, t, k))
if is_linear_ == True:
if func_coef[j, func, k] == 0:
if k == 0:
coef = eqs.as_independent(func, as_Add=True)[1]
for xr in range(1, ode_order(eqs,func) + 1):
coef -= eqs.as_independent(diff(func, t, xr), as_Add=True)[1]
if coef != 0:
is_linear_ = False
else:
if eqs.as_independent(diff(func, t, k), as_Add=True)[1]:
is_linear_ = False
else:
for func_ in funcs:
if isinstance(func_, list):
for elem_func_ in func_:
dep = func_coef[j, func, k].as_independent(elem_func_, as_Add=True)[1]
if dep != 0:
is_linear_ = False
else:
dep = func_coef[j, func, k].as_independent(func_, as_Add=True)[1]
if dep != 0:
is_linear_ = False
return is_linear_
func_coef = {}
is_linear = True
for j, eqs in enumerate(eq):
for func in funcs:
if isinstance(func, list):
for func_elem in func:
is_linear = linearity_check(eqs, j, func_elem, is_linear)
else:
is_linear = linearity_check(eqs, j, func, is_linear)
matching_hints['func_coeff'] = func_coef
matching_hints['is_linear'] = is_linear
if len(set(order.values())) == 1:
order_eq = list(matching_hints['order'].values())[0]
if matching_hints['is_linear'] == True:
if matching_hints['no_of_equation'] == 2:
if order_eq == 1:
type_of_equation = check_linear_2eq_order1(eq, funcs, func_coef)
elif order_eq == 2:
type_of_equation = check_linear_2eq_order2(eq, funcs, func_coef)
else:
type_of_equation = None
elif matching_hints['no_of_equation'] == 3:
if order_eq == 1:
type_of_equation = check_linear_3eq_order1(eq, funcs, func_coef)
if type_of_equation is None:
type_of_equation = check_linear_neq_order1(eq, funcs, func_coef)
else:
type_of_equation = None
else:
if order_eq == 1:
type_of_equation = check_linear_neq_order1(eq, funcs, func_coef)
else:
type_of_equation = None
else:
if matching_hints['no_of_equation'] == 2:
if order_eq == 1:
type_of_equation = check_nonlinear_2eq_order1(eq, funcs, func_coef)
else:
type_of_equation = None
elif matching_hints['no_of_equation'] == 3:
if order_eq == 1:
type_of_equation = check_nonlinear_3eq_order1(eq, funcs, func_coef)
else:
type_of_equation = None
else:
type_of_equation = None
else:
type_of_equation = None
matching_hints['type_of_equation'] = type_of_equation
return matching_hints
def check_linear_2eq_order1(eq, func, func_coef):
x = func[0].func
y = func[1].func
fc = func_coef
t = list(list(eq[0].atoms(Derivative))[0].atoms(Symbol))[0]
r = dict()
# for equations Eq(a1*diff(x(t),t), b1*x(t) + c1*y(t) + d1)
# and Eq(a2*diff(y(t),t), b2*x(t) + c2*y(t) + d2)
r['a1'] = fc[0,x(t),1] ; r['a2'] = fc[1,y(t),1]
r['b1'] = -fc[0,x(t),0]/fc[0,x(t),1] ; r['b2'] = -fc[1,x(t),0]/fc[1,y(t),1]
r['c1'] = -fc[0,y(t),0]/fc[0,x(t),1] ; r['c2'] = -fc[1,y(t),0]/fc[1,y(t),1]
forcing = [S(0),S(0)]
for i in range(2):
for j in Add.make_args(eq[i]):
if not j.has(x(t), y(t)):
forcing[i] += j
if not (forcing[0].has(t) or forcing[1].has(t)):
# We can handle homogeneous case and simple constant forcings
r['d1'] = forcing[0]
r['d2'] = forcing[1]
else:
# Issue #9244: nonhomogeneous linear systems are not supported
return None
# Conditions to check for type 6 whose equations are Eq(diff(x(t),t), f(t)*x(t) + g(t)*y(t)) and
# Eq(diff(y(t),t), a*[f(t) + a*h(t)]x(t) + a*[g(t) - h(t)]*y(t))
p = 0
q = 0
p1 = cancel(r['b2']/(cancel(r['b2']/r['c2']).as_numer_denom()[0]))
p2 = cancel(r['b1']/(cancel(r['b1']/r['c1']).as_numer_denom()[0]))
for n, i in enumerate([p1, p2]):
for j in Mul.make_args(collect_const(i)):
if not j.has(t):
q = j
if q and n==0:
if ((r['b2']/j - r['b1'])/(r['c1'] - r['c2']/j)) == j:
p = 1
elif q and n==1:
if ((r['b1']/j - r['b2'])/(r['c2'] - r['c1']/j)) == j:
p = 2
# End of condition for type 6
if r['d1']!=0 or r['d2']!=0:
if not r['d1'].has(t) and not r['d2'].has(t):
if all(not r[k].has(t) for k in 'a1 a2 b1 b2 c1 c2'.split()):
# Equations for type 2 are Eq(a1*diff(x(t),t),b1*x(t)+c1*y(t)+d1) and Eq(a2*diff(y(t),t),b2*x(t)+c2*y(t)+d2)
return "type2"
else:
return None
else:
if all(not r[k].has(t) for k in 'a1 a2 b1 b2 c1 c2'.split()):
# Equations for type 1 are Eq(a1*diff(x(t),t),b1*x(t)+c1*y(t)) and Eq(a2*diff(y(t),t),b2*x(t)+c2*y(t))
return "type1"
else:
r['b1'] = r['b1']/r['a1'] ; r['b2'] = r['b2']/r['a2']
r['c1'] = r['c1']/r['a1'] ; r['c2'] = r['c2']/r['a2']
if (r['b1'] == r['c2']) and (r['c1'] == r['b2']):
# Equation for type 3 are Eq(diff(x(t),t), f(t)*x(t) + g(t)*y(t)) and Eq(diff(y(t),t), g(t)*x(t) + f(t)*y(t))
return "type3"
elif (r['b1'] == r['c2']) and (r['c1'] == -r['b2']) or (r['b1'] == -r['c2']) and (r['c1'] == r['b2']):
# Equation for type 4 are Eq(diff(x(t),t), f(t)*x(t) + g(t)*y(t)) and Eq(diff(y(t),t), -g(t)*x(t) + f(t)*y(t))
return "type4"
elif (not cancel(r['b2']/r['c1']).has(t) and not cancel((r['c2']-r['b1'])/r['c1']).has(t)) \
or (not cancel(r['b1']/r['c2']).has(t) and not cancel((r['c1']-r['b2'])/r['c2']).has(t)):
# Equations for type 5 are Eq(diff(x(t),t), f(t)*x(t) + g(t)*y(t)) and Eq(diff(y(t),t), a*g(t)*x(t) + [f(t) + b*g(t)]*y(t)
return "type5"
elif p:
return "type6"
else:
# Equations for type 7 are Eq(diff(x(t),t), f(t)*x(t) + g(t)*y(t)) and Eq(diff(y(t),t), h(t)*x(t) + p(t)*y(t))
return "type7"
def check_linear_2eq_order2(eq, func, func_coef):
x = func[0].func
y = func[1].func
fc = func_coef
t = list(list(eq[0].atoms(Derivative))[0].atoms(Symbol))[0]
r = dict()
a = Wild('a', exclude=[1/t])
b = Wild('b', exclude=[1/t**2])
u = Wild('u', exclude=[t, t**2])
v = Wild('v', exclude=[t, t**2])
w = Wild('w', exclude=[t, t**2])
p = Wild('p', exclude=[t, t**2])
r['a1'] = fc[0,x(t),2] ; r['a2'] = fc[1,y(t),2]
r['b1'] = fc[0,x(t),1] ; r['b2'] = fc[1,x(t),1]
r['c1'] = fc[0,y(t),1] ; r['c2'] = fc[1,y(t),1]
r['d1'] = fc[0,x(t),0] ; r['d2'] = fc[1,x(t),0]
r['e1'] = fc[0,y(t),0] ; r['e2'] = fc[1,y(t),0]
const = [S(0), S(0)]
for i in range(2):
for j in Add.make_args(eq[i]):
if not (j.has(x(t)) or j.has(y(t))):
const[i] += j
r['f1'] = const[0]
r['f2'] = const[1]
if r['f1']!=0 or r['f2']!=0:
if all(not r[k].has(t) for k in 'a1 a2 d1 d2 e1 e2 f1 f2'.split()) \
and r['b1']==r['c1']==r['b2']==r['c2']==0:
return "type2"
elif all(not r[k].has(t) for k in 'a1 a2 b1 b2 c1 c2 d1 d2 e1 e1'.split()):
p = [S(0), S(0)] ; q = [S(0), S(0)]
for n, e in enumerate([r['f1'], r['f2']]):
if e.has(t):
tpart = e.as_independent(t, Mul)[1]
for i in Mul.make_args(tpart):
if i.has(exp):
b, e = i.as_base_exp()
co = e.coeff(t)
if co and not co.has(t) and co.has(I):
p[n] = 1
else:
q[n] = 1
else:
q[n] = 1
else:
q[n] = 1
if p[0]==1 and p[1]==1 and q[0]==0 and q[1]==0:
return "type4"
else:
return None
else:
return None
else:
if r['b1']==r['b2']==r['c1']==r['c2']==0 and all(not r[k].has(t) \
for k in 'a1 a2 d1 d2 e1 e2'.split()):
return "type1"
elif r['b1']==r['e1']==r['c2']==r['d2']==0 and all(not r[k].has(t) \
for k in 'a1 a2 b2 c1 d1 e2'.split()) and r['c1'] == -r['b2'] and \
r['d1'] == r['e2']:
return "type3"
elif cancel(-r['b2']/r['d2'])==t and cancel(-r['c1']/r['e1'])==t and not \
(r['d2']/r['a2']).has(t) and not (r['e1']/r['a1']).has(t) and \
r['b1']==r['d1']==r['c2']==r['e2']==0:
return "type5"
elif ((r['a1']/r['d1']).expand()).match((p*(u*t**2+v*t+w)**2).expand()) and not \
(cancel(r['a1']*r['d2']/(r['a2']*r['d1']))).has(t) and not (r['d1']/r['e1']).has(t) and not \
(r['d2']/r['e2']).has(t) and r['b1'] == r['b2'] == r['c1'] == r['c2'] == 0:
return "type10"
elif not cancel(r['d1']/r['e1']).has(t) and not cancel(r['d2']/r['e2']).has(t) and not \
cancel(r['d1']*r['a2']/(r['d2']*r['a1'])).has(t) and r['b1']==r['b2']==r['c1']==r['c2']==0:
return "type6"
elif not cancel(r['b1']/r['c1']).has(t) and not cancel(r['b2']/r['c2']).has(t) and not \
cancel(r['b1']*r['a2']/(r['b2']*r['a1'])).has(t) and r['d1']==r['d2']==r['e1']==r['e2']==0:
return "type7"
elif cancel(-r['b2']/r['d2'])==t and cancel(-r['c1']/r['e1'])==t and not \
cancel(r['e1']*r['a2']/(r['d2']*r['a1'])).has(t) and r['e1'].has(t) \
and r['b1']==r['d1']==r['c2']==r['e2']==0:
return "type8"
elif (r['b1']/r['a1']).match(a/t) and (r['b2']/r['a2']).match(a/t) and not \
(r['b1']/r['c1']).has(t) and not (r['b2']/r['c2']).has(t) and \
(r['d1']/r['a1']).match(b/t**2) and (r['d2']/r['a2']).match(b/t**2) \
and not (r['d1']/r['e1']).has(t) and not (r['d2']/r['e2']).has(t):
return "type9"
elif -r['b1']/r['d1']==-r['c1']/r['e1']==-r['b2']/r['d2']==-r['c2']/r['e2']==t:
return "type11"
else:
return None
def check_linear_3eq_order1(eq, func, func_coef):
x = func[0].func
y = func[1].func
z = func[2].func
fc = func_coef
t = list(list(eq[0].atoms(Derivative))[0].atoms(Symbol))[0]
r = dict()
r['a1'] = fc[0,x(t),1]; r['a2'] = fc[1,y(t),1]; r['a3'] = fc[2,z(t),1]
r['b1'] = fc[0,x(t),0]; r['b2'] = fc[1,x(t),0]; r['b3'] = fc[2,x(t),0]
r['c1'] = fc[0,y(t),0]; r['c2'] = fc[1,y(t),0]; r['c3'] = fc[2,y(t),0]
r['d1'] = fc[0,z(t),0]; r['d2'] = fc[1,z(t),0]; r['d3'] = fc[2,z(t),0]
forcing = [S(0), S(0), S(0)]
for i in range(3):
for j in Add.make_args(eq[i]):
if not j.has(x(t), y(t), z(t)):
forcing[i] += j
if forcing[0].has(t) or forcing[1].has(t) or forcing[2].has(t):
# We can handle homogeneous case and simple constant forcings.
# Issue #9244: nonhomogeneous linear systems are not supported
return None
if all(not r[k].has(t) for k in 'a1 a2 a3 b1 b2 b3 c1 c2 c3 d1 d2 d3'.split()):
if r['c1']==r['d1']==r['d2']==0:
return 'type1'
elif r['c1'] == -r['b2'] and r['d1'] == -r['b3'] and r['d2'] == -r['c3'] \
and r['b1'] == r['c2'] == r['d3'] == 0:
return 'type2'
elif r['b1'] == r['c2'] == r['d3'] == 0 and r['c1']/r['a1'] == -r['d1']/r['a1'] \
and r['d2']/r['a2'] == -r['b2']/r['a2'] and r['b3']/r['a3'] == -r['c3']/r['a3']:
return 'type3'
else:
return None
else:
for k1 in 'c1 d1 b2 d2 b3 c3'.split():
if r[k1] == 0:
continue
else:
if all(not cancel(r[k1]/r[k]).has(t) for k in 'd1 b2 d2 b3 c3'.split() if r[k]!=0) \
and all(not cancel(r[k1]/(r['b1'] - r[k])).has(t) for k in 'b1 c2 d3'.split() if r['b1']!=r[k]):
return 'type4'
else:
break
return None
def check_linear_neq_order1(eq, func, func_coef):
fc = func_coef
t = list(list(eq[0].atoms(Derivative))[0].atoms(Symbol))[0]
n = len(eq)
for i in range(n):
for j in range(n):
if (fc[i, func[j], 0]/fc[i, func[i], 1]).has(t):
return None
if len(eq) == 3:
return 'type6'
return 'type1'
def check_nonlinear_2eq_order1(eq, func, func_coef):
t = list(list(eq[0].atoms(Derivative))[0].atoms(Symbol))[0]
f = Wild('f')
g = Wild('g')
u, v = symbols('u, v', cls=Dummy)
def check_type(x, y):
r1 = eq[0].match(t*diff(x(t),t) - x(t) + f)
r2 = eq[1].match(t*diff(y(t),t) - y(t) + g)
if not (r1 and r2):
r1 = eq[0].match(diff(x(t),t) - x(t)/t + f/t)
r2 = eq[1].match(diff(y(t),t) - y(t)/t + g/t)
if not (r1 and r2):
r1 = (-eq[0]).match(t*diff(x(t),t) - x(t) + f)
r2 = (-eq[1]).match(t*diff(y(t),t) - y(t) + g)
if not (r1 and r2):
r1 = (-eq[0]).match(diff(x(t),t) - x(t)/t + f/t)
r2 = (-eq[1]).match(diff(y(t),t) - y(t)/t + g/t)
if r1 and r2 and not (r1[f].subs(diff(x(t),t),u).subs(diff(y(t),t),v).has(t) \
or r2[g].subs(diff(x(t),t),u).subs(diff(y(t),t),v).has(t)):
return 'type5'
else:
return None
for func_ in func:
if isinstance(func_, list):
x = func[0][0].func
y = func[0][1].func
eq_type = check_type(x, y)
if not eq_type:
eq_type = check_type(y, x)
return eq_type
x = func[0].func
y = func[1].func
fc = func_coef
n = Wild('n', exclude=[x(t),y(t)])
f1 = Wild('f1', exclude=[v,t])
f2 = Wild('f2', exclude=[v,t])
g1 = Wild('g1', exclude=[u,t])
g2 = Wild('g2', exclude=[u,t])
for i in range(2):
eqs = 0
for terms in Add.make_args(eq[i]):
eqs += terms/fc[i,func[i],1]
eq[i] = eqs
r = eq[0].match(diff(x(t),t) - x(t)**n*f)
if r:
g = (diff(y(t),t) - eq[1])/r[f]
if r and not (g.has(x(t)) or g.subs(y(t),v).has(t) or r[f].subs(x(t),u).subs(y(t),v).has(t)):
return 'type1'
r = eq[0].match(diff(x(t),t) - exp(n*x(t))*f)
if r:
g = (diff(y(t),t) - eq[1])/r[f]
if r and not (g.has(x(t)) or g.subs(y(t),v).has(t) or r[f].subs(x(t),u).subs(y(t),v).has(t)):
return 'type2'
g = Wild('g')
r1 = eq[0].match(diff(x(t),t) - f)
r2 = eq[1].match(diff(y(t),t) - g)
if r1 and r2 and not (r1[f].subs(x(t),u).subs(y(t),v).has(t) or \
r2[g].subs(x(t),u).subs(y(t),v).has(t)):
return 'type3'
r1 = eq[0].match(diff(x(t),t) - f)
r2 = eq[1].match(diff(y(t),t) - g)
num, den = (
(r1[f].subs(x(t),u).subs(y(t),v))/
(r2[g].subs(x(t),u).subs(y(t),v))).as_numer_denom()
R1 = num.match(f1*g1)
R2 = den.match(f2*g2)
# phi = (r1[f].subs(x(t),u).subs(y(t),v))/num
if R1 and R2:
return 'type4'
return None
def check_nonlinear_2eq_order2(eq, func, func_coef):
return None
def check_nonlinear_3eq_order1(eq, func, func_coef):
x = func[0].func
y = func[1].func
z = func[2].func
fc = func_coef
t = list(list(eq[0].atoms(Derivative))[0].atoms(Symbol))[0]
u, v, w = symbols('u, v, w', cls=Dummy)
a = Wild('a', exclude=[x(t), y(t), z(t), t])
b = Wild('b', exclude=[x(t), y(t), z(t), t])
c = Wild('c', exclude=[x(t), y(t), z(t), t])
f = Wild('f')
F1 = Wild('F1')
F2 = Wild('F2')
F3 = Wild('F3')
for i in range(3):
eqs = 0
for terms in Add.make_args(eq[i]):
eqs += terms/fc[i,func[i],1]
eq[i] = eqs
r1 = eq[0].match(diff(x(t),t) - a*y(t)*z(t))
r2 = eq[1].match(diff(y(t),t) - b*z(t)*x(t))
r3 = eq[2].match(diff(z(t),t) - c*x(t)*y(t))
if r1 and r2 and r3:
num1, den1 = r1[a].as_numer_denom()
num2, den2 = r2[b].as_numer_denom()
num3, den3 = r3[c].as_numer_denom()
if solve([num1*u-den1*(v-w), num2*v-den2*(w-u), num3*w-den3*(u-v)],[u, v]):
return 'type1'
r = eq[0].match(diff(x(t),t) - y(t)*z(t)*f)
if r:
r1 = collect_const(r[f]).match(a*f)
r2 = ((diff(y(t),t) - eq[1])/r1[f]).match(b*z(t)*x(t))
r3 = ((diff(z(t),t) - eq[2])/r1[f]).match(c*x(t)*y(t))
if r1 and r2 and r3:
num1, den1 = r1[a].as_numer_denom()
num2, den2 = r2[b].as_numer_denom()
num3, den3 = r3[c].as_numer_denom()
if solve([num1*u-den1*(v-w), num2*v-den2*(w-u), num3*w-den3*(u-v)],[u, v]):
return 'type2'
r = eq[0].match(diff(x(t),t) - (F2-F3))
if r:
r1 = collect_const(r[F2]).match(c*F2)
r1.update(collect_const(r[F3]).match(b*F3))
if r1:
if eq[1].has(r1[F2]) and not eq[1].has(r1[F3]):
r1[F2], r1[F3] = r1[F3], r1[F2]
r1[c], r1[b] = -r1[b], -r1[c]
r2 = eq[1].match(diff(y(t),t) - a*r1[F3] + r1[c]*F1)
if r2:
r3 = (eq[2] == diff(z(t),t) - r1[b]*r2[F1] + r2[a]*r1[F2])
if r1 and r2 and r3:
return 'type3'
r = eq[0].match(diff(x(t),t) - z(t)*F2 + y(t)*F3)
if r:
r1 = collect_const(r[F2]).match(c*F2)
r1.update(collect_const(r[F3]).match(b*F3))
if r1:
if eq[1].has(r1[F2]) and not eq[1].has(r1[F3]):
r1[F2], r1[F3] = r1[F3], r1[F2]
r1[c], r1[b] = -r1[b], -r1[c]
r2 = (diff(y(t),t) - eq[1]).match(a*x(t)*r1[F3] - r1[c]*z(t)*F1)
if r2:
r3 = (diff(z(t),t) - eq[2] == r1[b]*y(t)*r2[F1] - r2[a]*x(t)*r1[F2])
if r1 and r2 and r3:
return 'type4'
r = (diff(x(t),t) - eq[0]).match(x(t)*(F2 - F3))
if r:
r1 = collect_const(r[F2]).match(c*F2)
r1.update(collect_const(r[F3]).match(b*F3))
if r1:
if eq[1].has(r1[F2]) and not eq[1].has(r1[F3]):
r1[F2], r1[F3] = r1[F3], r1[F2]
r1[c], r1[b] = -r1[b], -r1[c]
r2 = (diff(y(t),t) - eq[1]).match(y(t)*(a*r1[F3] - r1[c]*F1))
if r2:
r3 = (diff(z(t),t) - eq[2] == z(t)*(r1[b]*r2[F1] - r2[a]*r1[F2]))
if r1 and r2 and r3:
return 'type5'
return None
def check_nonlinear_3eq_order2(eq, func, func_coef):
return None
def checksysodesol(eqs, sols, func=None):
r"""
Substitutes corresponding ``sols`` for each functions into each ``eqs`` and
checks that the result of substitutions for each equation is ``0``. The
equations and solutions passed can be any iterable.
This only works when each ``sols`` have one function only, like `x(t)` or `y(t)`.
For each function, ``sols`` can have a single solution or a list of solutions.
In most cases it will not be necessary to explicitly identify the function,
but if the function cannot be inferred from the original equation it
can be supplied through the ``func`` argument.
When a sequence of equations is passed, the same sequence is used to return
the result for each equation with each function substituted with corresponding
solutions.
It tries the following method to find zero equivalence for each equation:
Substitute the solutions for functions, like `x(t)` and `y(t)` into the
original equations containing those functions.
This function returns a tuple. The first item in the tuple is ``True`` if
the substitution results for each equation is ``0``, and ``False`` otherwise.
The second item in the tuple is what the substitution results in. Each element
of the ``list`` should always be ``0`` corresponding to each equation if the
first item is ``True``. Note that sometimes this function may return ``False``,
but with an expression that is identically equal to ``0``, instead of returning
``True``. This is because :py:meth:`~sympy.simplify.simplify.simplify` cannot
reduce the expression to ``0``. If an expression returned by each function
vanishes identically, then ``sols`` really is a solution to ``eqs``.
If this function seems to hang, it is probably because of a difficult simplification.
Examples
========
>>> from sympy import Eq, diff, symbols, sin, cos, exp, sqrt, S, Function
>>> from sympy.solvers.ode import checksysodesol
>>> C1, C2 = symbols('C1:3')
>>> t = symbols('t')
>>> x, y = symbols('x, y', cls=Function)
>>> eq = (Eq(diff(x(t),t), x(t) + y(t) + 17), Eq(diff(y(t),t), -2*x(t) + y(t) + 12))
>>> sol = [Eq(x(t), (C1*sin(sqrt(2)*t) + C2*cos(sqrt(2)*t))*exp(t) - S(5)/3),
... Eq(y(t), (sqrt(2)*C1*cos(sqrt(2)*t) - sqrt(2)*C2*sin(sqrt(2)*t))*exp(t) - S(46)/3)]
>>> checksysodesol(eq, sol)
(True, [0, 0])
>>> eq = (Eq(diff(x(t),t),x(t)*y(t)**4), Eq(diff(y(t),t),y(t)**3))
>>> sol = [Eq(x(t), C1*exp(-1/(4*(C2 + t)))), Eq(y(t), -sqrt(2)*sqrt(-1/(C2 + t))/2),
... Eq(x(t), C1*exp(-1/(4*(C2 + t)))), Eq(y(t), sqrt(2)*sqrt(-1/(C2 + t))/2)]
>>> checksysodesol(eq, sol)
(True, [0, 0])
"""
def _sympify(eq):
return list(map(sympify, eq if iterable(eq) else [eq]))
eqs = _sympify(eqs)
for i in range(len(eqs)):
if isinstance(eqs[i], Equality):
eqs[i] = eqs[i].lhs - eqs[i].rhs
if func is None:
funcs = []
for eq in eqs:
derivs = eq.atoms(Derivative)
func = set().union(*[d.atoms(AppliedUndef) for d in derivs])
for func_ in func:
funcs.append(func_)
funcs = list(set(funcs))
if not all(isinstance(func, AppliedUndef) and len(func.args) == 1 for func in funcs)\
and len({func.args for func in funcs})!=1:
raise ValueError("func must be a function of one variable, not %s" % func)
for sol in sols:
if len(sol.atoms(AppliedUndef)) != 1:
raise ValueError("solutions should have one function only")
if len(funcs) != len({sol.lhs for sol in sols}):
raise ValueError("number of solutions provided does not match the number of equations")
dictsol = dict()
for sol in sols:
func = list(sol.atoms(AppliedUndef))[0]
if sol.rhs == func:
sol = sol.reversed
solved = sol.lhs == func and not sol.rhs.has(func)
if not solved:
rhs = solve(sol, func)
if not rhs:
raise NotImplementedError
else:
rhs = sol.rhs
dictsol[func] = rhs
checkeq = []
for eq in eqs:
for func in funcs:
eq = sub_func_doit(eq, func, dictsol[func])
ss = simplify(eq)
if ss != 0:
eq = ss.expand(force=True)
else:
eq = 0
checkeq.append(eq)
if len(set(checkeq)) == 1 and list(set(checkeq))[0] == 0:
return (True, checkeq)
else:
return (False, checkeq)
@vectorize(0)
def odesimp(ode, eq, func, hint):
r"""
Simplifies solutions of ODEs, including trying to solve for ``func`` and
running :py:meth:`~sympy.solvers.ode.constantsimp`.
It may use knowledge of the type of solution that the hint returns to
apply additional simplifications.
It also attempts to integrate any :py:class:`~sympy.integrals.Integral`\s
in the expression, if the hint is not an ``_Integral`` hint.
This function should have no effect on expressions returned by
:py:meth:`~sympy.solvers.ode.dsolve`, as
:py:meth:`~sympy.solvers.ode.dsolve` already calls
:py:meth:`~sympy.solvers.ode.odesimp`, but the individual hint functions
do not call :py:meth:`~sympy.solvers.ode.odesimp` (because the
:py:meth:`~sympy.solvers.ode.dsolve` wrapper does). Therefore, this
function is designed for mainly internal use.
Examples
========
>>> from sympy import sin, symbols, dsolve, pprint, Function
>>> from sympy.solvers.ode import odesimp
>>> x , u2, C1= symbols('x,u2,C1')
>>> f = Function('f')
>>> eq = dsolve(x*f(x).diff(x) - f(x) - x*sin(f(x)/x), f(x),
... hint='1st_homogeneous_coeff_subs_indep_div_dep_Integral',
... simplify=False)
>>> pprint(eq, wrap_line=False)
x
----
f(x)
/
|
| / 1 \
| -|u2 + -------|
| | /1 \|
| | sin|--||
| \ \u2//
log(f(x)) = log(C1) + | ---------------- d(u2)
| 2
| u2
|
/
>>> pprint(odesimp(eq, f(x), 1, {C1},
... hint='1st_homogeneous_coeff_subs_indep_div_dep'
... )) #doctest: +SKIP
x
--------- = C1
/f(x)\
tan|----|
\2*x /
"""
x = func.args[0]
f = func.func
C1 = get_numbered_constants(eq, num=1)
constants = eq.free_symbols - ode.free_symbols
# First, integrate if the hint allows it.
eq = _handle_Integral(eq, func, hint)
if hint.startswith("nth_linear_euler_eq_nonhomogeneous"):
eq = simplify(eq)
if not isinstance(eq, Equality):
raise TypeError("eq should be an instance of Equality")
# Second, clean up the arbitrary constants.
# Right now, nth linear hints can put as many as 2*order constants in an
# expression. If that number grows with another hint, the third argument
# here should be raised accordingly, or constantsimp() rewritten to handle
# an arbitrary number of constants.
eq = constantsimp(eq, constants)
# Lastly, now that we have cleaned up the expression, try solving for func.
# When CRootOf is implemented in solve(), we will want to return a CRootOf
# every time instead of an Equality.
# Get the f(x) on the left if possible.
if eq.rhs == func and not eq.lhs.has(func):
eq = [Eq(eq.rhs, eq.lhs)]
# make sure we are working with lists of solutions in simplified form.
if eq.lhs == func and not eq.rhs.has(func):
# The solution is already solved
eq = [eq]
# special simplification of the rhs
if hint.startswith("nth_linear_constant_coeff"):
# Collect terms to make the solution look nice.
# This is also necessary for constantsimp to remove unnecessary
# terms from the particular solution from variation of parameters
#
# Collect is not behaving reliably here. The results for
# some linear constant-coefficient equations with repeated
# roots do not properly simplify all constants sometimes.
# 'collectterms' gives different orders sometimes, and results
# differ in collect based on that order. The
# sort-reverse trick fixes things, but may fail in the
# future. In addition, collect is splitting exponentials with
# rational powers for no reason. We have to do a match
# to fix this using Wilds.
global collectterms
try:
collectterms.sort(key=default_sort_key)
collectterms.reverse()
except Exception:
pass
assert len(eq) == 1 and eq[0].lhs == f(x)
sol = eq[0].rhs
sol = expand_mul(sol)
for i, reroot, imroot in collectterms:
sol = collect(sol, x**i*exp(reroot*x)*sin(abs(imroot)*x))
sol = collect(sol, x**i*exp(reroot*x)*cos(imroot*x))
for i, reroot, imroot in collectterms:
sol = collect(sol, x**i*exp(reroot*x))
del collectterms
# Collect is splitting exponentials with rational powers for
# no reason. We call powsimp to fix.
sol = powsimp(sol)
eq[0] = Eq(f(x), sol)
else:
# The solution is not solved, so try to solve it
try:
floats = any(i.is_Float for i in eq.atoms(Number))
eqsol = solve(eq, func, force=True, rational=False if floats else None)
if not eqsol:
raise NotImplementedError
except (NotImplementedError, PolynomialError):
eq = [eq]
else:
def _expand(expr):
numer, denom = expr.as_numer_denom()
if denom.is_Add:
return expr
else:
return powsimp(expr.expand(), combine='exp', deep=True)
# XXX: the rest of odesimp() expects each ``t`` to be in a
# specific normal form: rational expression with numerator
# expanded, but with combined exponential functions (at
# least in this setup all tests pass).
eq = [Eq(f(x), _expand(t)) for t in eqsol]
# special simplification of the lhs.
if hint.startswith("1st_homogeneous_coeff"):
for j, eqi in enumerate(eq):
newi = logcombine(eqi, force=True)
if isinstance(newi.lhs, log) and newi.rhs == 0:
newi = Eq(newi.lhs.args[0]/C1, C1)
eq[j] = newi
# We cleaned up the constants before solving to help the solve engine with
# a simpler expression, but the solved expression could have introduced
# things like -C1, so rerun constantsimp() one last time before returning.
for i, eqi in enumerate(eq):
eq[i] = constantsimp(eqi, constants)
eq[i] = constant_renumber(eq[i], ode.free_symbols)
# If there is only 1 solution, return it;
# otherwise return the list of solutions.
if len(eq) == 1:
eq = eq[0]
return eq
def checkodesol(ode, sol, func=None, order='auto', solve_for_func=True):
r"""
Substitutes ``sol`` into ``ode`` and checks that the result is ``0``.
This only works when ``func`` is one function, like `f(x)`. ``sol`` can
be a single solution or a list of solutions. Each solution may be an
:py:class:`~sympy.core.relational.Equality` that the solution satisfies,
e.g. ``Eq(f(x), C1), Eq(f(x) + C1, 0)``; or simply an
:py:class:`~sympy.core.expr.Expr`, e.g. ``f(x) - C1``. In most cases it
will not be necessary to explicitly identify the function, but if the
function cannot be inferred from the original equation it can be supplied
through the ``func`` argument.
If a sequence of solutions is passed, the same sort of container will be
used to return the result for each solution.
It tries the following methods, in order, until it finds zero equivalence:
1. Substitute the solution for `f` in the original equation. This only
works if ``ode`` is solved for `f`. It will attempt to solve it first
unless ``solve_for_func == False``.
2. Take `n` derivatives of the solution, where `n` is the order of
``ode``, and check to see if that is equal to the solution. This only
works on exact ODEs.
3. Take the 1st, 2nd, ..., `n`\th derivatives of the solution, each time
solving for the derivative of `f` of that order (this will always be
possible because `f` is a linear operator). Then back substitute each
derivative into ``ode`` in reverse order.
This function returns a tuple. The first item in the tuple is ``True`` if
the substitution results in ``0``, and ``False`` otherwise. The second
item in the tuple is what the substitution results in. It should always
be ``0`` if the first item is ``True``. Sometimes this function will
return ``False`` even when an expression is identically equal to ``0``.
This happens when :py:meth:`~sympy.simplify.simplify.simplify` does not
reduce the expression to ``0``. If an expression returned by this
function vanishes identically, then ``sol`` really is a solution to
the ``ode``.
If this function seems to hang, it is probably because of a hard
simplification.
To use this function to test, test the first item of the tuple.
Examples
========
>>> from sympy import Eq, Function, checkodesol, symbols
>>> x, C1 = symbols('x,C1')
>>> f = Function('f')
>>> checkodesol(f(x).diff(x), Eq(f(x), C1))
(True, 0)
>>> assert checkodesol(f(x).diff(x), C1)[0]
>>> assert not checkodesol(f(x).diff(x), x)[0]
>>> checkodesol(f(x).diff(x, 2), x**2)
(False, 2)
"""
if not isinstance(ode, Equality):
ode = Eq(ode, 0)
if func is None:
try:
_, func = _preprocess(ode.lhs)
except ValueError:
funcs = [s.atoms(AppliedUndef) for s in (
sol if is_sequence(sol, set) else [sol])]
funcs = set().union(*funcs)
if len(funcs) != 1:
raise ValueError(
'must pass func arg to checkodesol for this case.')
func = funcs.pop()
if not isinstance(func, AppliedUndef) or len(func.args) != 1:
raise ValueError(
"func must be a function of one variable, not %s" % func)
if is_sequence(sol, set):
return type(sol)([checkodesol(ode, i, order=order, solve_for_func=solve_for_func) for i in sol])
if not isinstance(sol, Equality):
sol = Eq(func, sol)
elif sol.rhs == func:
sol = sol.reversed
if order == 'auto':
order = ode_order(ode, func)
solved = sol.lhs == func and not sol.rhs.has(func)
if solve_for_func and not solved:
rhs = solve(sol, func)
if rhs:
eqs = [Eq(func, t) for t in rhs]
if len(rhs) == 1:
eqs = eqs[0]
return checkodesol(ode, eqs, order=order,
solve_for_func=False)
s = True
testnum = 0
x = func.args[0]
while s:
if testnum == 0:
# First pass, try substituting a solved solution directly into the
# ODE. This has the highest chance of succeeding.
ode_diff = ode.lhs - ode.rhs
if sol.lhs == func:
s = sub_func_doit(ode_diff, func, sol.rhs)
else:
testnum += 1
continue
ss = simplify(s)
if ss:
# with the new numer_denom in power.py, if we do a simple
# expansion then testnum == 0 verifies all solutions.
s = ss.expand(force=True)
else:
s = 0
testnum += 1
elif testnum == 1:
# Second pass. If we cannot substitute f, try seeing if the nth
# derivative is equal, this will only work for odes that are exact,
# by definition.
s = simplify(
trigsimp(diff(sol.lhs, x, order) - diff(sol.rhs, x, order)) -
trigsimp(ode.lhs) + trigsimp(ode.rhs))
# s2 = simplify(
# diff(sol.lhs, x, order) - diff(sol.rhs, x, order) - \
# ode.lhs + ode.rhs)
testnum += 1
elif testnum == 2:
# Third pass. Try solving for df/dx and substituting that into the
# ODE. Thanks to Chris Smith for suggesting this method. Many of
# the comments below are his, too.
# The method:
# - Take each of 1..n derivatives of the solution.
# - Solve each nth derivative for d^(n)f/dx^(n)
# (the differential of that order)
# - Back substitute into the ODE in decreasing order
# (i.e., n, n-1, ...)
# - Check the result for zero equivalence
if sol.lhs == func and not sol.rhs.has(func):
diffsols = {0: sol.rhs}
elif sol.rhs == func and not sol.lhs.has(func):
diffsols = {0: sol.lhs}
else:
diffsols = {}
sol = sol.lhs - sol.rhs
for i in range(1, order + 1):
# Differentiation is a linear operator, so there should always
# be 1 solution. Nonetheless, we test just to make sure.
# We only need to solve once. After that, we automatically
# have the solution to the differential in the order we want.
if i == 1:
ds = sol.diff(x)
try:
sdf = solve(ds, func.diff(x, i))
if not sdf:
raise NotImplementedError
except NotImplementedError:
testnum += 1
break
else:
diffsols[i] = sdf[0]
else:
# This is what the solution says df/dx should be.
diffsols[i] = diffsols[i - 1].diff(x)
# Make sure the above didn't fail.
if testnum > 2:
continue
else:
# Substitute it into ODE to check for self consistency.
lhs, rhs = ode.lhs, ode.rhs
for i in range(order, -1, -1):
if i == 0 and 0 not in diffsols:
# We can only substitute f(x) if the solution was
# solved for f(x).
break
lhs = sub_func_doit(lhs, func.diff(x, i), diffsols[i])
rhs = sub_func_doit(rhs, func.diff(x, i), diffsols[i])
ode_or_bool = Eq(lhs, rhs)
ode_or_bool = simplify(ode_or_bool)
if isinstance(ode_or_bool, (bool, BooleanAtom)):
if ode_or_bool:
lhs = rhs = S.Zero
else:
lhs = ode_or_bool.lhs
rhs = ode_or_bool.rhs
# No sense in overworking simplify -- just prove that the
# numerator goes to zero
num = trigsimp((lhs - rhs).as_numer_denom()[0])
# since solutions are obtained using force=True we test
# using the same level of assumptions
## replace function with dummy so assumptions will work
_func = Dummy('func')
num = num.subs(func, _func)
## posify the expression
num, reps = posify(num)
s = simplify(num).xreplace(reps).xreplace({_func: func})
testnum += 1
else:
break
if not s:
return (True, s)
elif s is True: # The code above never was able to change s
raise NotImplementedError("Unable to test if " + str(sol) +
" is a solution to " + str(ode) + ".")
else:
return (False, s)
def ode_sol_simplicity(sol, func, trysolving=True):
r"""
Returns an extended integer representing how simple a solution to an ODE
is.
The following things are considered, in order from most simple to least:
- ``sol`` is solved for ``func``.
- ``sol`` is not solved for ``func``, but can be if passed to solve (e.g.,
a solution returned by ``dsolve(ode, func, simplify=False``).
- If ``sol`` is not solved for ``func``, then base the result on the
length of ``sol``, as computed by ``len(str(sol))``.
- If ``sol`` has any unevaluated :py:class:`~sympy.integrals.Integral`\s,
this will automatically be considered less simple than any of the above.
This function returns an integer such that if solution A is simpler than
solution B by above metric, then ``ode_sol_simplicity(sola, func) <
ode_sol_simplicity(solb, func)``.
Currently, the following are the numbers returned, but if the heuristic is
ever improved, this may change. Only the ordering is guaranteed.
+----------------------------------------------+-------------------+
| Simplicity | Return |
+==============================================+===================+
| ``sol`` solved for ``func`` | ``-2`` |
+----------------------------------------------+-------------------+
| ``sol`` not solved for ``func`` but can be | ``-1`` |
+----------------------------------------------+-------------------+
| ``sol`` is not solved nor solvable for | ``len(str(sol))`` |
| ``func`` | |
+----------------------------------------------+-------------------+
| ``sol`` contains an | ``oo`` |
| :py:class:`~sympy.integrals.Integral` | |
+----------------------------------------------+-------------------+
``oo`` here means the SymPy infinity, which should compare greater than
any integer.
If you already know :py:meth:`~sympy.solvers.solvers.solve` cannot solve
``sol``, you can use ``trysolving=False`` to skip that step, which is the
only potentially slow step. For example,
:py:meth:`~sympy.solvers.ode.dsolve` with the ``simplify=False`` flag
should do this.
If ``sol`` is a list of solutions, if the worst solution in the list
returns ``oo`` it returns that, otherwise it returns ``len(str(sol))``,
that is, the length of the string representation of the whole list.
Examples
========
This function is designed to be passed to ``min`` as the key argument,
such as ``min(listofsolutions, key=lambda i: ode_sol_simplicity(i,
f(x)))``.
>>> from sympy import symbols, Function, Eq, tan, cos, sqrt, Integral
>>> from sympy.solvers.ode import ode_sol_simplicity
>>> x, C1, C2 = symbols('x, C1, C2')
>>> f = Function('f')
>>> ode_sol_simplicity(Eq(f(x), C1*x**2), f(x))
-2
>>> ode_sol_simplicity(Eq(x**2 + f(x), C1), f(x))
-1
>>> ode_sol_simplicity(Eq(f(x), C1*Integral(2*x, x)), f(x))
oo
>>> eq1 = Eq(f(x)/tan(f(x)/(2*x)), C1)
>>> eq2 = Eq(f(x)/tan(f(x)/(2*x) + f(x)), C2)
>>> [ode_sol_simplicity(eq, f(x)) for eq in [eq1, eq2]]
[28, 35]
>>> min([eq1, eq2], key=lambda i: ode_sol_simplicity(i, f(x)))
Eq(f(x)/tan(f(x)/(2*x)), C1)
"""
# TODO: if two solutions are solved for f(x), we still want to be
# able to get the simpler of the two
# See the docstring for the coercion rules. We check easier (faster)
# things here first, to save time.
if iterable(sol):
# See if there are Integrals
for i in sol:
if ode_sol_simplicity(i, func, trysolving=trysolving) == oo:
return oo
return len(str(sol))
if sol.has(Integral):
return oo
# Next, try to solve for func. This code will change slightly when CRootOf
# is implemented in solve(). Probably a CRootOf solution should fall
# somewhere between a normal solution and an unsolvable expression.
# First, see if they are already solved
if sol.lhs == func and not sol.rhs.has(func) or \
sol.rhs == func and not sol.lhs.has(func):
return -2
# We are not so lucky, try solving manually
if trysolving:
try:
sols = solve(sol, func)
if not sols:
raise NotImplementedError
except NotImplementedError:
pass
else:
return -1
# Finally, a naive computation based on the length of the string version
# of the expression. This may favor combined fractions because they
# will not have duplicate denominators, and may slightly favor expressions
# with fewer additions and subtractions, as those are separated by spaces
# by the printer.
# Additional ideas for simplicity heuristics are welcome, like maybe
# checking if a equation has a larger domain, or if constantsimp has
# introduced arbitrary constants numbered higher than the order of a
# given ODE that sol is a solution of.
return len(str(sol))
def _get_constant_subexpressions(expr, Cs):
Cs = set(Cs)
Ces = []
def _recursive_walk(expr):
expr_syms = expr.free_symbols
if expr_syms and expr_syms.issubset(Cs):
Ces.append(expr)
else:
if expr.func == exp:
expr = expr.expand(mul=True)
if expr.func in (Add, Mul):
d = sift(expr.args, lambda i : i.free_symbols.issubset(Cs))
if len(d[True]) > 1:
x = expr.func(*d[True])
if not x.is_number:
Ces.append(x)
elif isinstance(expr, Integral):
if expr.free_symbols.issubset(Cs) and \
all(len(x) == 3 for x in expr.limits):
Ces.append(expr)
for i in expr.args:
_recursive_walk(i)
return
_recursive_walk(expr)
return Ces
def __remove_linear_redundancies(expr, Cs):
cnts = {i: expr.count(i) for i in Cs}
Cs = [i for i in Cs if cnts[i] > 0]
def _linear(expr):
if isinstance(expr, Add):
xs = [i for i in Cs if expr.count(i)==cnts[i] \
and 0 == expr.diff(i, 2)]
d = {}
for x in xs:
y = expr.diff(x)
if y not in d:
d[y]=[]
d[y].append(x)
for y in d:
if len(d[y]) > 1:
d[y].sort(key=str)
for x in d[y][1:]:
expr = expr.subs(x, 0)
return expr
def _recursive_walk(expr):
if len(expr.args) != 0:
expr = expr.func(*[_recursive_walk(i) for i in expr.args])
expr = _linear(expr)
return expr
if isinstance(expr, Equality):
lhs, rhs = [_recursive_walk(i) for i in expr.args]
f = lambda i: isinstance(i, Number) or i in Cs
if isinstance(lhs, Symbol) and lhs in Cs:
rhs, lhs = lhs, rhs
if lhs.func in (Add, Symbol) and rhs.func in (Add, Symbol):
dlhs = sift([lhs] if isinstance(lhs, AtomicExpr) else lhs.args, f)
drhs = sift([rhs] if isinstance(rhs, AtomicExpr) else rhs.args, f)
for i in [True, False]:
for hs in [dlhs, drhs]:
if i not in hs:
hs[i] = [0]
# this calculation can be simplified
lhs = Add(*dlhs[False]) - Add(*drhs[False])
rhs = Add(*drhs[True]) - Add(*dlhs[True])
elif lhs.func in (Mul, Symbol) and rhs.func in (Mul, Symbol):
dlhs = sift([lhs] if isinstance(lhs, AtomicExpr) else lhs.args, f)
if True in dlhs:
if False not in dlhs:
dlhs[False] = [1]
lhs = Mul(*dlhs[False])
rhs = rhs/Mul(*dlhs[True])
return Eq(lhs, rhs)
else:
return _recursive_walk(expr)
@vectorize(0)
def constantsimp(expr, constants):
r"""
Simplifies an expression with arbitrary constants in it.
This function is written specifically to work with
:py:meth:`~sympy.solvers.ode.dsolve`, and is not intended for general use.
Simplification is done by "absorbing" the arbitrary constants into other
arbitrary constants, numbers, and symbols that they are not independent
of.
The symbols must all have the same name with numbers after it, for
example, ``C1``, ``C2``, ``C3``. The ``symbolname`` here would be
'``C``', the ``startnumber`` would be 1, and the ``endnumber`` would be 3.
If the arbitrary constants are independent of the variable ``x``, then the
independent symbol would be ``x``. There is no need to specify the
dependent function, such as ``f(x)``, because it already has the
independent symbol, ``x``, in it.
Because terms are "absorbed" into arbitrary constants and because
constants are renumbered after simplifying, the arbitrary constants in
expr are not necessarily equal to the ones of the same name in the
returned result.
If two or more arbitrary constants are added, multiplied, or raised to the
power of each other, they are first absorbed together into a single
arbitrary constant. Then the new constant is combined into other terms if
necessary.
Absorption of constants is done with limited assistance:
1. terms of :py:class:`~sympy.core.add.Add`\s are collected to try join
constants so `e^x (C_1 \cos(x) + C_2 \cos(x))` will simplify to `e^x
C_1 \cos(x)`;
2. powers with exponents that are :py:class:`~sympy.core.add.Add`\s are
expanded so `e^{C_1 + x}` will be simplified to `C_1 e^x`.
Use :py:meth:`~sympy.solvers.ode.constant_renumber` to renumber constants
after simplification or else arbitrary numbers on constants may appear,
e.g. `C_1 + C_3 x`.
In rare cases, a single constant can be "simplified" into two constants.
Every differential equation solution should have as many arbitrary
constants as the order of the differential equation. The result here will
be technically correct, but it may, for example, have `C_1` and `C_2` in
an expression, when `C_1` is actually equal to `C_2`. Use your discretion
in such situations, and also take advantage of the ability to use hints in
:py:meth:`~sympy.solvers.ode.dsolve`.
Examples
========
>>> from sympy import symbols
>>> from sympy.solvers.ode import constantsimp
>>> C1, C2, C3, x, y = symbols('C1, C2, C3, x, y')
>>> constantsimp(2*C1*x, {C1, C2, C3})
C1*x
>>> constantsimp(C1 + 2 + x, {C1, C2, C3})
C1 + x
>>> constantsimp(C1*C2 + 2 + C2 + C3*x, {C1, C2, C3})
C1 + C3*x
"""
# This function works recursively. The idea is that, for Mul,
# Add, Pow, and Function, if the class has a constant in it, then
# we can simplify it, which we do by recursing down and
# simplifying up. Otherwise, we can skip that part of the
# expression.
Cs = constants
orig_expr = expr
constant_subexprs = _get_constant_subexpressions(expr, Cs)
for xe in constant_subexprs:
xes = list(xe.free_symbols)
if not xes:
continue
if all([expr.count(c) == xe.count(c) for c in xes]):
xes.sort(key=str)
expr = expr.subs(xe, xes[0])
# try to perform common sub-expression elimination of constant terms
try:
commons, rexpr = cse(expr)
commons.reverse()
rexpr = rexpr[0]
for s in commons:
cs = list(s[1].atoms(Symbol))
if len(cs) == 1 and cs[0] in Cs and \
cs[0] not in rexpr.atoms(Symbol) and \
not any(cs[0] in ex for ex in commons if ex != s):
rexpr = rexpr.subs(s[0], cs[0])
else:
rexpr = rexpr.subs(*s)
expr = rexpr
except Exception:
pass
expr = __remove_linear_redundancies(expr, Cs)
def _conditional_term_factoring(expr):
new_expr = terms_gcd(expr, clear=False, deep=True, expand=False)
# we do not want to factor exponentials, so handle this separately
if new_expr.is_Mul:
infac = False
asfac = False
for m in new_expr.args:
if isinstance(m, exp):
asfac = True
elif m.is_Add:
infac = any(isinstance(fi, exp) for t in m.args
for fi in Mul.make_args(t))
if asfac and infac:
new_expr = expr
break
return new_expr
expr = _conditional_term_factoring(expr)
# call recursively if more simplification is possible
if orig_expr != expr:
return constantsimp(expr, Cs)
return expr
def constant_renumber(expr, variables=None, newconstants=None):
r"""
Renumber arbitrary constants in ``expr`` to use the symbol names as given
in ``newconstants``. In the process, this reorders expression terms in a
standard way.
If ``newconstants`` is not provided then the new constant names will be
``C1``, ``C2`` etc. Otherwise ``newconstants`` should be an iterable
giving the new symbols to use for the constants in order.
The ``variables`` argument is a list of non-constant symbols. All other
free symbols found in ``expr`` are assumed to be constants and will be
renumbered. If ``variables`` is not given then any numbered symbol
beginning with ``C`` (e.g. ``C1``) is assumed to be a constant.
Symbols are renumbered based on ``.sort_key()``, so they should be
numbered roughly in the order that they appear in the final, printed
expression. Note that this ordering is based in part on hashes, so it can
produce different results on different machines.
The structure of this function is very similar to that of
:py:meth:`~sympy.solvers.ode.constantsimp`.
Examples
========
>>> from sympy import symbols, Eq, pprint
>>> from sympy.solvers.ode import constant_renumber
>>> x, C1, C2, C3 = symbols('x,C1:4')
>>> expr = C3 + C2*x + C1*x**2
>>> expr
C1*x**2 + C2*x + C3
>>> constant_renumber(expr)
C1 + C2*x + C3*x**2
The ``variables`` argument specifies which are constants so that the
other symbols will not be renumbered:
>>> constant_renumber(expr, [C1, x])
C1*x**2 + C2 + C3*x
The ``newconstants`` argument is used to specify what symbols to use when
replacing the constants:
>>> constant_renumber(expr, [x], newconstants=symbols('E1:4'))
E1 + E2*x + E3*x**2
"""
if type(expr) in (set, list, tuple):
renumbered = [constant_renumber(e, variables, newconstants) for e in expr]
return type(expr)(renumbered)
# Symbols in solution but not ODE are constants
if variables is not None:
variables = set(variables)
constantsymbols = list(expr.free_symbols - variables)
# Any Cn is a constant...
else:
variables = set()
isconstant = lambda s: s.startswith('C') and s[1:].isdigit()
constantsymbols = [sym for sym in expr.free_symbols if isconstant(sym.name)]
# Find new constants checking that they aren't already in the ODE
if newconstants is None:
iter_constants = numbered_symbols(start=1, prefix='C', exclude=variables)
else:
iter_constants = (sym for sym in newconstants if sym not in variables)
global newstartnumber
newstartnumber = 1
endnumber = len(constantsymbols)
constants_found = [None]*(endnumber + 2)
# make a mapping to send all constantsymbols to S.One and use
# that to make sure that term ordering is not dependent on
# the indexed value of C
C_1 = [(ci, S.One) for ci in constantsymbols]
sort_key=lambda arg: default_sort_key(arg.subs(C_1))
def _constant_renumber(expr):
r"""
We need to have an internal recursive function so that
newstartnumber maintains its values throughout recursive calls.
"""
# FIXME: Use nonlocal here when support for Py2 is dropped:
global newstartnumber
if isinstance(expr, Equality):
return Eq(
_constant_renumber(expr.lhs),
_constant_renumber(expr.rhs))
if type(expr) not in (Mul, Add, Pow) and not expr.is_Function and \
not expr.has(*constantsymbols):
# Base case, as above. Hope there aren't constants inside
# of some other class, because they won't be renumbered.
return expr
elif expr.is_Piecewise:
return expr
elif expr in constantsymbols:
if expr not in constants_found:
constants_found[newstartnumber] = expr
newstartnumber += 1
return expr
elif expr.is_Function or expr.is_Pow or isinstance(expr, Tuple):
return expr.func(
*[_constant_renumber(x) for x in expr.args])
else:
sortedargs = list(expr.args)
sortedargs.sort(key=sort_key)
return expr.func(*[_constant_renumber(x) for x in sortedargs])
expr = _constant_renumber(expr)
# Don't renumber symbols present in the ODE.
constants_found = [c for c in constants_found if c not in variables]
# Renumbering happens here
expr = expr.subs(zip(constants_found[1:], iter_constants), simultaneous=True)
return expr
def _handle_Integral(expr, func, hint):
r"""
Converts a solution with Integrals in it into an actual solution.
For most hints, this simply runs ``expr.doit()``.
"""
global y
x = func.args[0]
f = func.func
if hint == "1st_exact":
sol = (expr.doit()).subs(y, f(x))
del y
elif hint == "1st_exact_Integral":
sol = Eq(Subs(expr.lhs, y, f(x)), expr.rhs)
del y
elif hint == "nth_linear_constant_coeff_homogeneous":
sol = expr
elif not hint.endswith("_Integral"):
sol = expr.doit()
else:
sol = expr
return sol
# FIXME: replace the general solution in the docstring with
# dsolve(equation, hint='1st_exact_Integral'). You will need to be able
# to have assumptions on P and Q that dP/dy = dQ/dx.
def ode_1st_exact(eq, func, order, match):
r"""
Solves 1st order exact ordinary differential equations.
A 1st order differential equation is called exact if it is the total
differential of a function. That is, the differential equation
.. math:: P(x, y) \,\partial{}x + Q(x, y) \,\partial{}y = 0
is exact if there is some function `F(x, y)` such that `P(x, y) =
\partial{}F/\partial{}x` and `Q(x, y) = \partial{}F/\partial{}y`. It can
be shown that a necessary and sufficient condition for a first order ODE
to be exact is that `\partial{}P/\partial{}y = \partial{}Q/\partial{}x`.
Then, the solution will be as given below::
>>> from sympy import Function, Eq, Integral, symbols, pprint
>>> x, y, t, x0, y0, C1= symbols('x,y,t,x0,y0,C1')
>>> P, Q, F= map(Function, ['P', 'Q', 'F'])
>>> pprint(Eq(Eq(F(x, y), Integral(P(t, y), (t, x0, x)) +
... Integral(Q(x0, t), (t, y0, y))), C1))
x y
/ /
| |
F(x, y) = | P(t, y) dt + | Q(x0, t) dt = C1
| |
/ /
x0 y0
Where the first partials of `P` and `Q` exist and are continuous in a
simply connected region.
A note: SymPy currently has no way to represent inert substitution on an
expression, so the hint ``1st_exact_Integral`` will return an integral
with `dy`. This is supposed to represent the function that you are
solving for.
Examples
========
>>> from sympy import Function, dsolve, cos, sin
>>> from sympy.abc import x
>>> f = Function('f')
>>> dsolve(cos(f(x)) - (x*sin(f(x)) - f(x)**2)*f(x).diff(x),
... f(x), hint='1st_exact')
Eq(x*cos(f(x)) + f(x)**3/3, C1)
References
==========
- https://en.wikipedia.org/wiki/Exact_differential_equation
- M. Tenenbaum & H. Pollard, "Ordinary Differential Equations",
Dover 1963, pp. 73
# indirect doctest
"""
x = func.args[0]
r = match # d+e*diff(f(x),x)
e = r[r['e']]
d = r[r['d']]
global y # This is the only way to pass dummy y to _handle_Integral
y = r['y']
C1 = get_numbered_constants(eq, num=1)
# Refer Joel Moses, "Symbolic Integration - The Stormy Decade",
# Communications of the ACM, Volume 14, Number 8, August 1971, pp. 558
# which gives the method to solve an exact differential equation.
sol = Integral(d, x) + Integral((e - (Integral(d, x).diff(y))), y)
return Eq(sol, C1)
def ode_1st_homogeneous_coeff_best(eq, func, order, match):
r"""
Returns the best solution to an ODE from the two hints
``1st_homogeneous_coeff_subs_dep_div_indep`` and
``1st_homogeneous_coeff_subs_indep_div_dep``.
This is as determined by :py:meth:`~sympy.solvers.ode.ode_sol_simplicity`.
See the
:py:meth:`~sympy.solvers.ode.ode_1st_homogeneous_coeff_subs_indep_div_dep`
and
:py:meth:`~sympy.solvers.ode.ode_1st_homogeneous_coeff_subs_dep_div_indep`
docstrings for more information on these hints. Note that there is no
``ode_1st_homogeneous_coeff_best_Integral`` hint.
Examples
========
>>> from sympy import Function, dsolve, pprint
>>> from sympy.abc import x
>>> f = Function('f')
>>> pprint(dsolve(2*x*f(x) + (x**2 + f(x)**2)*f(x).diff(x), f(x),
... hint='1st_homogeneous_coeff_best', simplify=False))
/ 2 \
| 3*x |
log|----- + 1|
| 2 |
\f (x) /
log(f(x)) = log(C1) - --------------
3
References
==========
- https://en.wikipedia.org/wiki/Homogeneous_differential_equation
- M. Tenenbaum & H. Pollard, "Ordinary Differential Equations",
Dover 1963, pp. 59
# indirect doctest
"""
# There are two substitutions that solve the equation, u1=y/x and u2=x/y
# They produce different integrals, so try them both and see which
# one is easier.
sol1 = ode_1st_homogeneous_coeff_subs_indep_div_dep(eq,
func, order, match)
sol2 = ode_1st_homogeneous_coeff_subs_dep_div_indep(eq,
func, order, match)
simplify = match.get('simplify', True)
if simplify:
# why is odesimp called here? Should it be at the usual spot?
sol1 = odesimp(eq, sol1, func, "1st_homogeneous_coeff_subs_indep_div_dep")
sol2 = odesimp(eq, sol2, func, "1st_homogeneous_coeff_subs_dep_div_indep")
return min([sol1, sol2], key=lambda x: ode_sol_simplicity(x, func,
trysolving=not simplify))
def ode_1st_homogeneous_coeff_subs_dep_div_indep(eq, func, order, match):
r"""
Solves a 1st order differential equation with homogeneous coefficients
using the substitution `u_1 = \frac{\text{<dependent
variable>}}{\text{<independent variable>}}`.
This is a differential equation
.. math:: P(x, y) + Q(x, y) dy/dx = 0
such that `P` and `Q` are homogeneous and of the same order. A function
`F(x, y)` is homogeneous of order `n` if `F(x t, y t) = t^n F(x, y)`.
Equivalently, `F(x, y)` can be rewritten as `G(y/x)` or `H(x/y)`. See
also the docstring of :py:meth:`~sympy.solvers.ode.homogeneous_order`.
If the coefficients `P` and `Q` in the differential equation above are
homogeneous functions of the same order, then it can be shown that the
substitution `y = u_1 x` (i.e. `u_1 = y/x`) will turn the differential
equation into an equation separable in the variables `x` and `u`. If
`h(u_1)` is the function that results from making the substitution `u_1 =
f(x)/x` on `P(x, f(x))` and `g(u_2)` is the function that results from the
substitution on `Q(x, f(x))` in the differential equation `P(x, f(x)) +
Q(x, f(x)) f'(x) = 0`, then the general solution is::
>>> from sympy import Function, dsolve, pprint
>>> from sympy.abc import x
>>> f, g, h = map(Function, ['f', 'g', 'h'])
>>> genform = g(f(x)/x) + h(f(x)/x)*f(x).diff(x)
>>> pprint(genform)
/f(x)\ /f(x)\ d
g|----| + h|----|*--(f(x))
\ x / \ x / dx
>>> pprint(dsolve(genform, f(x),
... hint='1st_homogeneous_coeff_subs_dep_div_indep_Integral'))
f(x)
----
x
/
|
| -h(u1)
log(x) = C1 + | ---------------- d(u1)
| u1*h(u1) + g(u1)
|
/
Where `u_1 h(u_1) + g(u_1) \ne 0` and `x \ne 0`.
See also the docstrings of
:py:meth:`~sympy.solvers.ode.ode_1st_homogeneous_coeff_best` and
:py:meth:`~sympy.solvers.ode.ode_1st_homogeneous_coeff_subs_indep_div_dep`.
Examples
========
>>> from sympy import Function, dsolve
>>> from sympy.abc import x
>>> f = Function('f')
>>> pprint(dsolve(2*x*f(x) + (x**2 + f(x)**2)*f(x).diff(x), f(x),
... hint='1st_homogeneous_coeff_subs_dep_div_indep', simplify=False))
/ 3 \
|3*f(x) f (x)|
log|------ + -----|
| x 3 |
\ x /
log(x) = log(C1) - -------------------
3
References
==========
- https://en.wikipedia.org/wiki/Homogeneous_differential_equation
- M. Tenenbaum & H. Pollard, "Ordinary Differential Equations",
Dover 1963, pp. 59
# indirect doctest
"""
x = func.args[0]
f = func.func
u = Dummy('u')
u1 = Dummy('u1') # u1 == f(x)/x
r = match # d+e*diff(f(x),x)
C1 = get_numbered_constants(eq, num=1)
xarg = match.get('xarg', 0)
yarg = match.get('yarg', 0)
int = Integral(
(-r[r['e']]/(r[r['d']] + u1*r[r['e']])).subs({x: 1, r['y']: u1}),
(u1, None, f(x)/x))
sol = logcombine(Eq(log(x), int + log(C1)), force=True)
sol = sol.subs(f(x), u).subs(((u, u - yarg), (x, x - xarg), (u, f(x))))
return sol
def ode_1st_homogeneous_coeff_subs_indep_div_dep(eq, func, order, match):
r"""
Solves a 1st order differential equation with homogeneous coefficients
using the substitution `u_2 = \frac{\text{<independent
variable>}}{\text{<dependent variable>}}`.
This is a differential equation
.. math:: P(x, y) + Q(x, y) dy/dx = 0
such that `P` and `Q` are homogeneous and of the same order. A function
`F(x, y)` is homogeneous of order `n` if `F(x t, y t) = t^n F(x, y)`.
Equivalently, `F(x, y)` can be rewritten as `G(y/x)` or `H(x/y)`. See
also the docstring of :py:meth:`~sympy.solvers.ode.homogeneous_order`.
If the coefficients `P` and `Q` in the differential equation above are
homogeneous functions of the same order, then it can be shown that the
substitution `x = u_2 y` (i.e. `u_2 = x/y`) will turn the differential
equation into an equation separable in the variables `y` and `u_2`. If
`h(u_2)` is the function that results from making the substitution `u_2 =
x/f(x)` on `P(x, f(x))` and `g(u_2)` is the function that results from the
substitution on `Q(x, f(x))` in the differential equation `P(x, f(x)) +
Q(x, f(x)) f'(x) = 0`, then the general solution is:
>>> from sympy import Function, dsolve, pprint
>>> from sympy.abc import x
>>> f, g, h = map(Function, ['f', 'g', 'h'])
>>> genform = g(x/f(x)) + h(x/f(x))*f(x).diff(x)
>>> pprint(genform)
/ x \ / x \ d
g|----| + h|----|*--(f(x))
\f(x)/ \f(x)/ dx
>>> pprint(dsolve(genform, f(x),
... hint='1st_homogeneous_coeff_subs_indep_div_dep_Integral'))
x
----
f(x)
/
|
| -g(u2)
| ---------------- d(u2)
| u2*g(u2) + h(u2)
|
/
<BLANKLINE>
f(x) = C1*e
Where `u_2 g(u_2) + h(u_2) \ne 0` and `f(x) \ne 0`.
See also the docstrings of
:py:meth:`~sympy.solvers.ode.ode_1st_homogeneous_coeff_best` and
:py:meth:`~sympy.solvers.ode.ode_1st_homogeneous_coeff_subs_dep_div_indep`.
Examples
========
>>> from sympy import Function, pprint, dsolve
>>> from sympy.abc import x
>>> f = Function('f')
>>> pprint(dsolve(2*x*f(x) + (x**2 + f(x)**2)*f(x).diff(x), f(x),
... hint='1st_homogeneous_coeff_subs_indep_div_dep',
... simplify=False))
/ 2 \
| 3*x |
log|----- + 1|
| 2 |
\f (x) /
log(f(x)) = log(C1) - --------------
3
References
==========
- https://en.wikipedia.org/wiki/Homogeneous_differential_equation
- M. Tenenbaum & H. Pollard, "Ordinary Differential Equations",
Dover 1963, pp. 59
# indirect doctest
"""
x = func.args[0]
f = func.func
u = Dummy('u')
u2 = Dummy('u2') # u2 == x/f(x)
r = match # d+e*diff(f(x),x)
C1 = get_numbered_constants(eq, num=1)
xarg = match.get('xarg', 0) # If xarg present take xarg, else zero
yarg = match.get('yarg', 0) # If yarg present take yarg, else zero
int = Integral(
simplify(
(-r[r['d']]/(r[r['e']] + u2*r[r['d']])).subs({x: u2, r['y']: 1})),
(u2, None, x/f(x)))
sol = logcombine(Eq(log(f(x)), int + log(C1)), force=True)
sol = sol.subs(f(x), u).subs(((u, u - yarg), (x, x - xarg), (u, f(x))))
return sol
# XXX: Should this function maybe go somewhere else?
def homogeneous_order(eq, *symbols):
r"""
Returns the order `n` if `g` is homogeneous and ``None`` if it is not
homogeneous.
Determines if a function is homogeneous and if so of what order. A
function `f(x, y, \cdots)` is homogeneous of order `n` if `f(t x, t y,
\cdots) = t^n f(x, y, \cdots)`.
If the function is of two variables, `F(x, y)`, then `f` being homogeneous
of any order is equivalent to being able to rewrite `F(x, y)` as `G(x/y)`
or `H(y/x)`. This fact is used to solve 1st order ordinary differential
equations whose coefficients are homogeneous of the same order (see the
docstrings of
:py:meth:`~solvers.ode.ode_1st_homogeneous_coeff_subs_dep_div_indep` and
:py:meth:`~solvers.ode.ode_1st_homogeneous_coeff_subs_indep_div_dep`).
Symbols can be functions, but every argument of the function must be a
symbol, and the arguments of the function that appear in the expression
must match those given in the list of symbols. If a declared function
appears with different arguments than given in the list of symbols,
``None`` is returned.
Examples
========
>>> from sympy import Function, homogeneous_order, sqrt
>>> from sympy.abc import x, y
>>> f = Function('f')
>>> homogeneous_order(f(x), f(x)) is None
True
>>> homogeneous_order(f(x,y), f(y, x), x, y) is None
True
>>> homogeneous_order(f(x), f(x), x)
1
>>> homogeneous_order(x**2*f(x)/sqrt(x**2+f(x)**2), x, f(x))
2
>>> homogeneous_order(x**2+f(x), x, f(x)) is None
True
"""
if not symbols:
raise ValueError("homogeneous_order: no symbols were given.")
symset = set(symbols)
eq = sympify(eq)
# The following are not supported
if eq.has(Order, Derivative):
return None
# These are all constants
if (eq.is_Number or
eq.is_NumberSymbol or
eq.is_number
):
return S.Zero
# Replace all functions with dummy variables
dum = numbered_symbols(prefix='d', cls=Dummy)
newsyms = set()
for i in [j for j in symset if getattr(j, 'is_Function')]:
iargs = set(i.args)
if iargs.difference(symset):
return None
else:
dummyvar = next(dum)
eq = eq.subs(i, dummyvar)
symset.remove(i)
newsyms.add(dummyvar)
symset.update(newsyms)
if not eq.free_symbols & symset:
return None
# assuming order of a nested function can only be equal to zero
if isinstance(eq, Function):
return None if homogeneous_order(
eq.args[0], *tuple(symset)) != 0 else S.Zero
# make the replacement of x with x*t and see if t can be factored out
t = Dummy('t', positive=True) # It is sufficient that t > 0
eqs = separatevars(eq.subs([(i, t*i) for i in symset]), [t], dict=True)[t]
if eqs is S.One:
return S.Zero # there was no term with only t
i, d = eqs.as_independent(t, as_Add=False)
b, e = d.as_base_exp()
if b == t:
return e
def ode_1st_linear(eq, func, order, match):
r"""
Solves 1st order linear differential equations.
These are differential equations of the form
.. math:: dy/dx + P(x) y = Q(x)\text{.}
These kinds of differential equations can be solved in a general way. The
integrating factor `e^{\int P(x) \,dx}` will turn the equation into a
separable equation. The general solution is::
>>> from sympy import Function, dsolve, Eq, pprint, diff, sin
>>> from sympy.abc import x
>>> f, P, Q = map(Function, ['f', 'P', 'Q'])
>>> genform = Eq(f(x).diff(x) + P(x)*f(x), Q(x))
>>> pprint(genform)
d
P(x)*f(x) + --(f(x)) = Q(x)
dx
>>> pprint(dsolve(genform, f(x), hint='1st_linear_Integral'))
/ / \
| | |
| | / | /
| | | | |
| | | P(x) dx | - | P(x) dx
| | | | |
| | / | /
f(x) = |C1 + | Q(x)*e dx|*e
| | |
\ / /
Examples
========
>>> f = Function('f')
>>> pprint(dsolve(Eq(x*diff(f(x), x) - f(x), x**2*sin(x)),
... f(x), '1st_linear'))
f(x) = x*(C1 - cos(x))
References
==========
- https://en.wikipedia.org/wiki/Linear_differential_equation#First_order_equation
- M. Tenenbaum & H. Pollard, "Ordinary Differential Equations",
Dover 1963, pp. 92
# indirect doctest
"""
x = func.args[0]
f = func.func
r = match # a*diff(f(x),x) + b*f(x) + c
C1 = get_numbered_constants(eq, num=1)
t = exp(Integral(r[r['b']]/r[r['a']], x))
tt = Integral(t*(-r[r['c']]/r[r['a']]), x)
f = match.get('u', f(x)) # take almost-linear u if present, else f(x)
return Eq(f, (tt + C1)/t)
def ode_Bernoulli(eq, func, order, match):
r"""
Solves Bernoulli differential equations.
These are equations of the form
.. math:: dy/dx + P(x) y = Q(x) y^n\text{, }n \ne 1`\text{.}
The substitution `w = 1/y^{1-n}` will transform an equation of this form
into one that is linear (see the docstring of
:py:meth:`~sympy.solvers.ode.ode_1st_linear`). The general solution is::
>>> from sympy import Function, dsolve, Eq, pprint
>>> from sympy.abc import x, n
>>> f, P, Q = map(Function, ['f', 'P', 'Q'])
>>> genform = Eq(f(x).diff(x) + P(x)*f(x), Q(x)*f(x)**n)
>>> pprint(genform)
d n
P(x)*f(x) + --(f(x)) = Q(x)*f (x)
dx
>>> pprint(dsolve(genform, f(x), hint='Bernoulli_Integral')) #doctest: +SKIP
1
----
1 - n
// / \ \
|| | | |
|| | / | / |
|| | | | | |
|| | (1 - n)* | P(x) dx | (-1 + n)* | P(x) dx|
|| | | | | |
|| | / | / |
f(x) = ||C1 + (-1 + n)* | -Q(x)*e dx|*e |
|| | | |
\\ / / /
Note that the equation is separable when `n = 1` (see the docstring of
:py:meth:`~sympy.solvers.ode.ode_separable`).
>>> pprint(dsolve(Eq(f(x).diff(x) + P(x)*f(x), Q(x)*f(x)), f(x),
... hint='separable_Integral'))
f(x)
/
| /
| 1 |
| - dy = C1 + | (-P(x) + Q(x)) dx
| y |
| /
/
Examples
========
>>> from sympy import Function, dsolve, Eq, pprint, log
>>> from sympy.abc import x
>>> f = Function('f')
>>> pprint(dsolve(Eq(x*f(x).diff(x) + f(x), log(x)*f(x)**2),
... f(x), hint='Bernoulli'))
1
f(x) = -------------------
/ log(x) 1\
x*|C1 + ------ + -|
\ x x/
References
==========
- https://en.wikipedia.org/wiki/Bernoulli_differential_equation
- M. Tenenbaum & H. Pollard, "Ordinary Differential Equations",
Dover 1963, pp. 95
# indirect doctest
"""
x = func.args[0]
f = func.func
r = match # a*diff(f(x),x) + b*f(x) + c*f(x)**n, n != 1
C1 = get_numbered_constants(eq, num=1)
t = exp((1 - r[r['n']])*Integral(r[r['b']]/r[r['a']], x))
tt = (r[r['n']] - 1)*Integral(t*r[r['c']]/r[r['a']], x)
return Eq(f(x), ((tt + C1)/t)**(1/(1 - r[r['n']])))
def ode_Riccati_special_minus2(eq, func, order, match):
r"""
The general Riccati equation has the form
.. math:: dy/dx = f(x) y^2 + g(x) y + h(x)\text{.}
While it does not have a general solution [1], the "special" form, `dy/dx
= a y^2 - b x^c`, does have solutions in many cases [2]. This routine
returns a solution for `a(dy/dx) = b y^2 + c y/x + d/x^2` that is obtained
by using a suitable change of variables to reduce it to the special form
and is valid when neither `a` nor `b` are zero and either `c` or `d` is
zero.
>>> from sympy.abc import x, y, a, b, c, d
>>> from sympy.solvers.ode import dsolve, checkodesol
>>> from sympy import pprint, Function
>>> f = Function('f')
>>> y = f(x)
>>> genform = a*y.diff(x) - (b*y**2 + c*y/x + d/x**2)
>>> sol = dsolve(genform, y)
>>> pprint(sol, wrap_line=False)
/ / __________________ \\
| __________________ | / 2 ||
| / 2 | \/ 4*b*d - (a + c) *log(x)||
-|a + c - \/ 4*b*d - (a + c) *tan|C1 + ----------------------------||
\ \ 2*a //
f(x) = ------------------------------------------------------------------------
2*b*x
>>> checkodesol(genform, sol, order=1)[0]
True
References
==========
1. http://www.maplesoft.com/support/help/Maple/view.aspx?path=odeadvisor/Riccati
2. http://eqworld.ipmnet.ru/en/solutions/ode/ode0106.pdf -
http://eqworld.ipmnet.ru/en/solutions/ode/ode0123.pdf
"""
x = func.args[0]
f = func.func
r = match # a2*diff(f(x),x) + b2*f(x) + c2*f(x)/x + d2/x**2
a2, b2, c2, d2 = [r[r[s]] for s in 'a2 b2 c2 d2'.split()]
C1 = get_numbered_constants(eq, num=1)
mu = sqrt(4*d2*b2 - (a2 - c2)**2)
return Eq(f(x), (a2 - c2 - mu*tan(mu/(2*a2)*log(x) + C1))/(2*b2*x))
def ode_Liouville(eq, func, order, match):
r"""
Solves 2nd order Liouville differential equations.
The general form of a Liouville ODE is
.. math:: \frac{d^2 y}{dx^2} + g(y) \left(\!
\frac{dy}{dx}\!\right)^2 + h(x)
\frac{dy}{dx}\text{.}
The general solution is:
>>> from sympy import Function, dsolve, Eq, pprint, diff
>>> from sympy.abc import x
>>> f, g, h = map(Function, ['f', 'g', 'h'])
>>> genform = Eq(diff(f(x),x,x) + g(f(x))*diff(f(x),x)**2 +
... h(x)*diff(f(x),x), 0)
>>> pprint(genform)
2 2
/d \ d d
g(f(x))*|--(f(x))| + h(x)*--(f(x)) + ---(f(x)) = 0
\dx / dx 2
dx
>>> pprint(dsolve(genform, f(x), hint='Liouville_Integral'))
f(x)
/ /
| |
| / | /
| | | |
| - | h(x) dx | | g(y) dy
| | | |
| / | /
C1 + C2* | e dx + | e dy = 0
| |
/ /
Examples
========
>>> from sympy import Function, dsolve, Eq, pprint
>>> from sympy.abc import x
>>> f = Function('f')
>>> pprint(dsolve(diff(f(x), x, x) + diff(f(x), x)**2/f(x) +
... diff(f(x), x)/x, f(x), hint='Liouville'))
________________ ________________
[f(x) = -\/ C1 + C2*log(x) , f(x) = \/ C1 + C2*log(x) ]
References
==========
- Goldstein and Braun, "Advanced Methods for the Solution of Differential
Equations", pp. 98
- http://www.maplesoft.com/support/help/Maple/view.aspx?path=odeadvisor/Liouville
# indirect doctest
"""
# Liouville ODE:
# f(x).diff(x, 2) + g(f(x))*(f(x).diff(x, 2))**2 + h(x)*f(x).diff(x)
# See Goldstein and Braun, "Advanced Methods for the Solution of
# Differential Equations", pg. 98, as well as
# http://www.maplesoft.com/support/help/view.aspx?path=odeadvisor/Liouville
x = func.args[0]
f = func.func
r = match # f(x).diff(x, 2) + g*f(x).diff(x)**2 + h*f(x).diff(x)
y = r['y']
C1, C2 = get_numbered_constants(eq, num=2)
int = Integral(exp(Integral(r['g'], y)), (y, None, f(x)))
sol = Eq(int + C1*Integral(exp(-Integral(r['h'], x)), x) + C2, 0)
return sol
def ode_2nd_power_series_ordinary(eq, func, order, match):
r"""
Gives a power series solution to a second order homogeneous differential
equation with polynomial coefficients at an ordinary point. A homogeneous
differential equation is of the form
.. math :: P(x)\frac{d^2y}{dx^2} + Q(x)\frac{dy}{dx} + R(x) = 0
For simplicity it is assumed that `P(x)`, `Q(x)` and `R(x)` are polynomials,
it is sufficient that `\frac{Q(x)}{P(x)}` and `\frac{R(x)}{P(x)}` exists at
`x_{0}`. A recurrence relation is obtained by substituting `y` as `\sum_{n=0}^\infty a_{n}x^{n}`,
in the differential equation, and equating the nth term. Using this relation
various terms can be generated.
Examples
========
>>> from sympy import dsolve, Function, pprint
>>> from sympy.abc import x, y
>>> f = Function("f")
>>> eq = f(x).diff(x, 2) + f(x)
>>> pprint(dsolve(eq, hint='2nd_power_series_ordinary'))
/ 4 2 \ / 2\
|x x | | x | / 6\
f(x) = C2*|-- - -- + 1| + C1*x*|1 - --| + O\x /
\24 2 / \ 6 /
References
==========
- http://tutorial.math.lamar.edu/Classes/DE/SeriesSolutions.aspx
- George E. Simmons, "Differential Equations with Applications and
Historical Notes", p.p 176 - 184
"""
x = func.args[0]
f = func.func
C0, C1 = get_numbered_constants(eq, num=2)
n = Dummy("n", integer=True)
s = Wild("s")
k = Wild("k", exclude=[x])
x0 = match.get('x0')
terms = match.get('terms', 5)
p = match[match['a3']]
q = match[match['b3']]
r = match[match['c3']]
seriesdict = {}
recurr = Function("r")
# Generating the recurrence relation which works this way:
# for the second order term the summation begins at n = 2. The coefficients
# p is multiplied with an*(n - 1)*(n - 2)*x**n-2 and a substitution is made such that
# the exponent of x becomes n.
# For example, if p is x, then the second degree recurrence term is
# an*(n - 1)*(n - 2)*x**n-1, substituting (n - 1) as n, it transforms to
# an+1*n*(n - 1)*x**n.
# A similar process is done with the first order and zeroth order term.
coefflist = [(recurr(n), r), (n*recurr(n), q), (n*(n - 1)*recurr(n), p)]
for index, coeff in enumerate(coefflist):
if coeff[1]:
f2 = powsimp(expand((coeff[1]*(x - x0)**(n - index)).subs(x, x + x0)))
if f2.is_Add:
addargs = f2.args
else:
addargs = [f2]
for arg in addargs:
powm = arg.match(s*x**k)
term = coeff[0]*powm[s]
if not powm[k].is_Symbol:
term = term.subs(n, n - powm[k].as_independent(n)[0])
startind = powm[k].subs(n, index)
# Seeing if the startterm can be reduced further.
# If it vanishes for n lesser than startind, it is
# equal to summation from n.
if startind:
for i in reversed(range(startind)):
if not term.subs(n, i):
seriesdict[term] = i
else:
seriesdict[term] = i + 1
break
else:
seriesdict[term] = S(0)
# Stripping of terms so that the sum starts with the same number.
teq = S(0)
suminit = seriesdict.values()
rkeys = seriesdict.keys()
req = Add(*rkeys)
if any(suminit):
maxval = max(suminit)
for term in seriesdict:
val = seriesdict[term]
if val != maxval:
for i in range(val, maxval):
teq += term.subs(n, val)
finaldict = {}
if teq:
fargs = teq.atoms(AppliedUndef)
if len(fargs) == 1:
finaldict[fargs.pop()] = 0
else:
maxf = max(fargs, key = lambda x: x.args[0])
sol = solve(teq, maxf)
if isinstance(sol, list):
sol = sol[0]
finaldict[maxf] = sol
# Finding the recurrence relation in terms of the largest term.
fargs = req.atoms(AppliedUndef)
maxf = max(fargs, key = lambda x: x.args[0])
minf = min(fargs, key = lambda x: x.args[0])
if minf.args[0].is_Symbol:
startiter = 0
else:
startiter = -minf.args[0].as_independent(n)[0]
lhs = maxf
rhs = solve(req, maxf)
if isinstance(rhs, list):
rhs = rhs[0]
# Checking how many values are already present
tcounter = len([t for t in finaldict.values() if t])
for _ in range(tcounter, terms - 3): # Assuming c0 and c1 to be arbitrary
check = rhs.subs(n, startiter)
nlhs = lhs.subs(n, startiter)
nrhs = check.subs(finaldict)
finaldict[nlhs] = nrhs
startiter += 1
# Post processing
series = C0 + C1*(x - x0)
for term in finaldict:
if finaldict[term]:
fact = term.args[0]
series += (finaldict[term].subs([(recurr(0), C0), (recurr(1), C1)])*(
x - x0)**fact)
series = collect(expand_mul(series), [C0, C1]) + Order(x**terms)
return Eq(f(x), series)
def ode_2nd_power_series_regular(eq, func, order, match):
r"""
Gives a power series solution to a second order homogeneous differential
equation with polynomial coefficients at a regular point. A second order
homogeneous differential equation is of the form
.. math :: P(x)\frac{d^2y}{dx^2} + Q(x)\frac{dy}{dx} + R(x) = 0
A point is said to regular singular at `x0` if `x - x0\frac{Q(x)}{P(x)}`
and `(x - x0)^{2}\frac{R(x)}{P(x)}` are analytic at `x0`. For simplicity
`P(x)`, `Q(x)` and `R(x)` are assumed to be polynomials. The algorithm for
finding the power series solutions is:
1. Try expressing `(x - x0)P(x)` and `((x - x0)^{2})Q(x)` as power series
solutions about x0. Find `p0` and `q0` which are the constants of the
power series expansions.
2. Solve the indicial equation `f(m) = m(m - 1) + m*p0 + q0`, to obtain the
roots `m1` and `m2` of the indicial equation.
3. If `m1 - m2` is a non integer there exists two series solutions. If
`m1 = m2`, there exists only one solution. If `m1 - m2` is an integer,
then the existence of one solution is confirmed. The other solution may
or may not exist.
The power series solution is of the form `x^{m}\sum_{n=0}^\infty a_{n}x^{n}`. The
coefficients are determined by the following recurrence relation.
`a_{n} = -\frac{\sum_{k=0}^{n-1} q_{n-k} + (m + k)p_{n-k}}{f(m + n)}`. For the case
in which `m1 - m2` is an integer, it can be seen from the recurrence relation
that for the lower root `m`, when `n` equals the difference of both the
roots, the denominator becomes zero. So if the numerator is not equal to zero,
a second series solution exists.
Examples
========
>>> from sympy import dsolve, Function, pprint
>>> from sympy.abc import x, y
>>> f = Function("f")
>>> eq = x*(f(x).diff(x, 2)) + 2*(f(x).diff(x)) + x*f(x)
>>> pprint(dsolve(eq))
/ 6 4 2 \
| x x x |
/ 4 2 \ C1*|- --- + -- - -- + 1|
| x x | \ 720 24 2 / / 6\
f(x) = C2*|--- - -- + 1| + ------------------------ + O\x /
\120 6 / x
References
==========
- George E. Simmons, "Differential Equations with Applications and
Historical Notes", p.p 176 - 184
"""
x = func.args[0]
f = func.func
C0, C1 = get_numbered_constants(eq, num=2)
m = Dummy("m") # for solving the indicial equation
x0 = match.get('x0')
terms = match.get('terms', 5)
p = match['p']
q = match['q']
# Generating the indicial equation
indicial = []
for term in [p, q]:
if not term.has(x):
indicial.append(term)
else:
term = series(term, n=1, x0=x0)
if isinstance(term, Order):
indicial.append(S(0))
else:
for arg in term.args:
if not arg.has(x):
indicial.append(arg)
break
p0, q0 = indicial
sollist = solve(m*(m - 1) + m*p0 + q0, m)
if sollist and isinstance(sollist, list) and all(
[sol.is_real for sol in sollist]):
serdict1 = {}
serdict2 = {}
if len(sollist) == 1:
# Only one series solution exists in this case.
m1 = m2 = sollist.pop()
if terms-m1-1 <= 0:
return Eq(f(x), Order(terms))
serdict1 = _frobenius(terms-m1-1, m1, p0, q0, p, q, x0, x, C0)
else:
m1 = sollist[0]
m2 = sollist[1]
if m1 < m2:
m1, m2 = m2, m1
# Irrespective of whether m1 - m2 is an integer or not, one
# Frobenius series solution exists.
serdict1 = _frobenius(terms-m1-1, m1, p0, q0, p, q, x0, x, C0)
if not (m1 - m2).is_integer:
# Second frobenius series solution exists.
serdict2 = _frobenius(terms-m2-1, m2, p0, q0, p, q, x0, x, C1)
else:
# Check if second frobenius series solution exists.
serdict2 = _frobenius(terms-m2-1, m2, p0, q0, p, q, x0, x, C1, check=m1)
if serdict1:
finalseries1 = C0
for key in serdict1:
power = int(key.name[1:])
finalseries1 += serdict1[key]*(x - x0)**power
finalseries1 = (x - x0)**m1*finalseries1
finalseries2 = S(0)
if serdict2:
for key in serdict2:
power = int(key.name[1:])
finalseries2 += serdict2[key]*(x - x0)**power
finalseries2 += C1
finalseries2 = (x - x0)**m2*finalseries2
return Eq(f(x), collect(finalseries1 + finalseries2,
[C0, C1]) + Order(x**terms))
def _frobenius(n, m, p0, q0, p, q, x0, x, c, check=None):
r"""
Returns a dict with keys as coefficients and values as their values in terms of C0
"""
n = int(n)
# In cases where m1 - m2 is not an integer
m2 = check
d = Dummy("d")
numsyms = numbered_symbols("C", start=0)
numsyms = [next(numsyms) for i in range(n + 1)]
serlist = []
for ser in [p, q]:
# Order term not present
if ser.is_polynomial(x) and Poly(ser, x).degree() <= n:
if x0:
ser = ser.subs(x, x + x0)
dict_ = Poly(ser, x).as_dict()
# Order term present
else:
tseries = series(ser, x=x0, n=n+1)
# Removing order
dict_ = Poly(list(ordered(tseries.args))[: -1], x).as_dict()
# Fill in with zeros, if coefficients are zero.
for i in range(n + 1):
if (i,) not in dict_:
dict_[(i,)] = S(0)
serlist.append(dict_)
pseries = serlist[0]
qseries = serlist[1]
indicial = d*(d - 1) + d*p0 + q0
frobdict = {}
for i in range(1, n + 1):
num = c*(m*pseries[(i,)] + qseries[(i,)])
for j in range(1, i):
sym = Symbol("C" + str(j))
num += frobdict[sym]*((m + j)*pseries[(i - j,)] + qseries[(i - j,)])
# Checking for cases when m1 - m2 is an integer. If num equals zero
# then a second Frobenius series solution cannot be found. If num is not zero
# then set constant as zero and proceed.
if m2 is not None and i == m2 - m:
if num:
return False
else:
frobdict[numsyms[i]] = S(0)
else:
frobdict[numsyms[i]] = -num/(indicial.subs(d, m+i))
return frobdict
def _nth_order_reducible_match(eq, func):
r"""
Matches any differential equation that can be rewritten with a smaller
order. Only derivatives of ``func`` alone, wrt a single variable,
are considered, and only in them should ``func`` appear.
"""
# ODE only handles functions of 1 variable so this affirms that state
assert len(func.args) == 1
x = func.args[0]
vc = [d.variable_count[0] for d in eq.atoms(Derivative)
if d.expr == func and len(d.variable_count) == 1]
ords = [c for v, c in vc if v == x]
if len(ords) < 2:
return
smallest = min(ords)
# make sure func does not appear outside of derivatives
D = Dummy()
if eq.subs(func.diff(x, smallest), D).has(func):
return
return {'n': smallest}
def ode_nth_order_reducible(eq, func, order, match):
r"""
Solves ODEs that only involve derivatives of the dependent variable using
a substitution of the form `f^n(x) = g(x)`.
For example any second order ODE of the form `f''(x) = h(f'(x), x)` can be
transformed into a pair of 1st order ODEs `g'(x) = h(g(x), x)` and
`f'(x) = g(x)`. Usually the 1st order ODE for `g` is easier to solve. If
that gives an explicit solution for `g` then `f` is found simply by
integration.
Examples
========
>>> from sympy import Function, dsolve, Eq
>>> from sympy.abc import x
>>> f = Function('f')
>>> eq = Eq(x*f(x).diff(x)**2 + f(x).diff(x, 2), 0)
>>> dsolve(eq, f(x), hint='nth_order_reducible')
... # doctest: +NORMALIZE_WHITESPACE
Eq(f(x), C1 - sqrt(-1/C2)*log(-C2*sqrt(-1/C2) + x) + sqrt(-1/C2)*log(C2*sqrt(-1/C2) + x))
"""
x = func.args[0]
f = func.func
n = match['n']
# get a unique function name for g
names = [a.name for a in eq.atoms(AppliedUndef)]
while True:
name = Dummy().name
if name not in names:
g = Function(name)
break
w = f(x).diff(x, n)
geq = eq.subs(w, g(x))
gsol = dsolve(geq, g(x))
if not isinstance(gsol, list):
gsol = [gsol]
# Might be multiple solutions to the reduced ODE:
fsol = []
for gsoli in gsol:
fsoli = dsolve(gsoli.subs(g(x), w), f(x)) # or do integration n times
fsol.append(fsoli)
if len(fsol) == 1:
fsol = fsol[0]
return fsol
# This needs to produce an invertible function but the inverse depends
# which variable we are integrating with respect to. Since the class can
# be stored in cached results we need to ensure that we always get the
# same class back for each particular integration variable so we store these
# classes in a global dict:
_nth_algebraic_diffx_stored = {}
def _nth_algebraic_diffx(var):
cls = _nth_algebraic_diffx_stored.get(var, None)
if cls is None:
# A class that behaves like Derivative wrt var but is "invertible".
class diffx(Function):
def inverse(self):
# don't use integrate here because fx has been replaced by _t
# in the equation; integrals will not be correct while solve
# is at work.
return lambda expr: Integral(expr, var) + Dummy('C')
cls = _nth_algebraic_diffx_stored.setdefault(var, diffx)
return cls
def _nth_algebraic_match(eq, func):
r"""
Matches any differential equation that nth_algebraic can solve. Uses
`sympy.solve` but teaches it how to integrate derivatives.
This involves calling `sympy.solve` and does most of the work of finding a
solution (apart from evaluating the integrals).
"""
# The independent variable
var = func.args[0]
# Derivative that solve can handle:
diffx = _nth_algebraic_diffx(var)
# Replace derivatives wrt the independent variable with diffx
def replace(eq, var):
def expand_diffx(*args):
differand, diffs = args[0], args[1:]
toreplace = differand
for v, n in diffs:
for _ in range(n):
if v == var:
toreplace = diffx(toreplace)
else:
toreplace = Derivative(toreplace, v)
return toreplace
return eq.replace(Derivative, expand_diffx)
# Restore derivatives in solution afterwards
def unreplace(eq, var):
return eq.replace(diffx, lambda e: Derivative(e, var))
subs_eqn = replace(eq, var)
try:
# turn off simplification to protect Integrals that have
# _t instead of fx in them and would otherwise factor
# as t_*Integral(1, x)
solns = solve(subs_eqn, func, simplify=False)
except NotImplementedError:
solns = []
solns = [simplify(unreplace(soln, var)) for soln in solns]
solns = [Equality(func, soln) for soln in solns]
return {'var':var, 'solutions':solns}
def ode_nth_algebraic(eq, func, order, match):
r"""
Solves an `n`\th order ordinary differential equation using algebra and
integrals.
There is no general form for the kind of equation that this can solve. The
the equation is solved algebraically treating differentiation as an
invertible algebraic function.
Examples
========
>>> from sympy import Function, dsolve, Eq
>>> from sympy.abc import x
>>> f = Function('f')
>>> eq = Eq(f(x) * (f(x).diff(x)**2 - 1), 0)
>>> dsolve(eq, f(x), hint='nth_algebraic')
... # doctest: +NORMALIZE_WHITESPACE
[Eq(f(x), 0), Eq(f(x), C1 - x), Eq(f(x), C1 + x)]
Note that this solver can return algebraic solutions that do not have any
integration constants (f(x) = 0 in the above example).
# indirect doctest
"""
solns = match['solutions']
var = match['var']
solns = _nth_algebraic_remove_redundant_solutions(eq, solns, order, var)
if len(solns) == 1:
return solns[0]
else:
return solns
# FIXME: Maybe something like this function should be applied to the solutions
# returned by dsolve in general rather than just for nth_algebraic...
def _nth_algebraic_remove_redundant_solutions(eq, solns, order, var):
r"""
Remove redundant solutions from the set of solutions returned by
nth_algebraic.
This function is needed because otherwise nth_algebraic can return
redundant solutions where both algebraic solutions and integral
solutions are found to the ODE. As an example consider:
eq = Eq(f(x) * f(x).diff(x), 0)
There are two ways to find solutions to eq. The first is the algebraic
solution f(x)=0. The second is to solve the equation f(x).diff(x) = 0
leading to the solution f(x) = C1. In this particular case we then see
that the first solution is a special case of the second and we don't
want to return it.
This does not always happen for algebraic solutions though since if we
have
eq = Eq(f(x)*(1 + f(x).diff(x)), 0)
then we get the algebraic solution f(x) = 0 and the integral solution
f(x) = -x + C1 and in this case the two solutions are not equivalent wrt
initial conditions so both should be returned.
"""
def is_special_case_of(soln1, soln2):
return _nth_algebraic_is_special_case_of(soln1, soln2, eq, order, var)
unique_solns = []
for soln1 in solns:
for soln2 in unique_solns[:]:
if is_special_case_of(soln1, soln2):
break
elif is_special_case_of(soln2, soln1):
unique_solns.remove(soln2)
else:
unique_solns.append(soln1)
return unique_solns
def _nth_algebraic_is_special_case_of(soln1, soln2, eq, order, var):
|
def _nth_linear_match(eq, func, order):
r"""
Matches a differential equation to the linear form:
.. math:: a_n(x) y^{(n)} + \cdots + a_1(x)y' + a_0(x) y + B(x) = 0
Returns a dict of order:coeff terms, where order is the order of the
derivative on each term, and coeff is the coefficient of that derivative.
The key ``-1`` holds the function `B(x)`. Returns ``None`` if the ODE is
not linear. This function assumes that ``func`` has already been checked
to be good.
Examples
========
>>> from sympy import Function, cos, sin
>>> from sympy.abc import x
>>> from sympy.solvers.ode import _nth_linear_match
>>> f = Function('f')
>>> _nth_linear_match(f(x).diff(x, 3) + 2*f(x).diff(x) +
... x*f(x).diff(x, 2) + cos(x)*f(x).diff(x) + x - f(x) -
... sin(x), f(x), 3)
{-1: x - sin(x), 0: -1, 1: cos(x) + 2, 2: x, 3: 1}
>>> _nth_linear_match(f(x).diff(x, 3) + 2*f(x).diff(x) +
... x*f(x).diff(x, 2) + cos(x)*f(x).diff(x) + x - f(x) -
... sin(f(x)), f(x), 3) == None
True
"""
x = func.args[0]
one_x = {x}
terms = {i: S.Zero for i in range(-1, order + 1)}
for i in Add.make_args(eq):
if not i.has(func):
terms[-1] += i
else:
c, f = i.as_independent(func)
if (isinstance(f, Derivative)
and set(f.variables) == one_x
and f.args[0] == func):
terms[f.derivative_count] += c
elif f == func:
terms[len(f.args[1:])] += c
else:
return None
return terms
def ode_nth_linear_euler_eq_homogeneous(eq, func, order, match, returns='sol'):
r"""
Solves an `n`\th order linear homogeneous variable-coefficient
Cauchy-Euler equidimensional ordinary differential equation.
This is an equation with form `0 = a_0 f(x) + a_1 x f'(x) + a_2 x^2 f''(x)
\cdots`.
These equations can be solved in a general manner, by substituting
solutions of the form `f(x) = x^r`, and deriving a characteristic equation
for `r`. When there are repeated roots, we include extra terms of the
form `C_{r k} \ln^k(x) x^r`, where `C_{r k}` is an arbitrary integration
constant, `r` is a root of the characteristic equation, and `k` ranges
over the multiplicity of `r`. In the cases where the roots are complex,
solutions of the form `C_1 x^a \sin(b \log(x)) + C_2 x^a \cos(b \log(x))`
are returned, based on expansions with Euler's formula. The general
solution is the sum of the terms found. If SymPy cannot find exact roots
to the characteristic equation, a
:py:class:`~sympy.polys.rootoftools.CRootOf` instance will be returned
instead.
>>> from sympy import Function, dsolve, Eq
>>> from sympy.abc import x
>>> f = Function('f')
>>> dsolve(4*x**2*f(x).diff(x, 2) + f(x), f(x),
... hint='nth_linear_euler_eq_homogeneous')
... # doctest: +NORMALIZE_WHITESPACE
Eq(f(x), sqrt(x)*(C1 + C2*log(x)))
Note that because this method does not involve integration, there is no
``nth_linear_euler_eq_homogeneous_Integral`` hint.
The following is for internal use:
- ``returns = 'sol'`` returns the solution to the ODE.
- ``returns = 'list'`` returns a list of linearly independent solutions,
corresponding to the fundamental solution set, for use with non
homogeneous solution methods like variation of parameters and
undetermined coefficients. Note that, though the solutions should be
linearly independent, this function does not explicitly check that. You
can do ``assert simplify(wronskian(sollist)) != 0`` to check for linear
independence. Also, ``assert len(sollist) == order`` will need to pass.
- ``returns = 'both'``, return a dictionary ``{'sol': <solution to ODE>,
'list': <list of linearly independent solutions>}``.
Examples
========
>>> from sympy import Function, dsolve, pprint
>>> from sympy.abc import x
>>> f = Function('f')
>>> eq = f(x).diff(x, 2)*x**2 - 4*f(x).diff(x)*x + 6*f(x)
>>> pprint(dsolve(eq, f(x),
... hint='nth_linear_euler_eq_homogeneous'))
2
f(x) = x *(C1 + C2*x)
References
==========
- https://en.wikipedia.org/wiki/Cauchy%E2%80%93Euler_equation
- C. Bender & S. Orszag, "Advanced Mathematical Methods for Scientists and
Engineers", Springer 1999, pp. 12
# indirect doctest
"""
global collectterms
collectterms = []
x = func.args[0]
f = func.func
r = match
# First, set up characteristic equation.
chareq, symbol = S.Zero, Dummy('x')
for i in r.keys():
if not isinstance(i, string_types) and i >= 0:
chareq += (r[i]*diff(x**symbol, x, i)*x**-symbol).expand()
chareq = Poly(chareq, symbol)
chareqroots = [rootof(chareq, k) for k in range(chareq.degree())]
# A generator of constants
constants = list(get_numbered_constants(eq, num=chareq.degree()*2))
constants.reverse()
# Create a dict root: multiplicity or charroots
charroots = defaultdict(int)
for root in chareqroots:
charroots[root] += 1
gsol = S(0)
# We need keep track of terms so we can run collect() at the end.
# This is necessary for constantsimp to work properly.
ln = log
for root, multiplicity in charroots.items():
for i in range(multiplicity):
if isinstance(root, RootOf):
gsol += (x**root) * constants.pop()
if multiplicity != 1:
raise ValueError("Value should be 1")
collectterms = [(0, root, 0)] + collectterms
elif root.is_real:
gsol += ln(x)**i*(x**root) * constants.pop()
collectterms = [(i, root, 0)] + collectterms
else:
reroot = re(root)
imroot = im(root)
gsol += ln(x)**i * (x**reroot) * (
constants.pop() * sin(abs(imroot)*ln(x))
+ constants.pop() * cos(imroot*ln(x)))
# Preserve ordering (multiplicity, real part, imaginary part)
# It will be assumed implicitly when constructing
# fundamental solution sets.
collectterms = [(i, reroot, imroot)] + collectterms
if returns == 'sol':
return Eq(f(x), gsol)
elif returns in ('list' 'both'):
# HOW TO TEST THIS CODE? (dsolve does not pass 'returns' through)
# Create a list of (hopefully) linearly independent solutions
gensols = []
# Keep track of when to use sin or cos for nonzero imroot
for i, reroot, imroot in collectterms:
if imroot == 0:
gensols.append(ln(x)**i*x**reroot)
else:
sin_form = ln(x)**i*x**reroot*sin(abs(imroot)*ln(x))
if sin_form in gensols:
cos_form = ln(x)**i*x**reroot*cos(imroot*ln(x))
gensols.append(cos_form)
else:
gensols.append(sin_form)
if returns == 'list':
return gensols
else:
return {'sol': Eq(f(x), gsol), 'list': gensols}
else:
raise ValueError('Unknown value for key "returns".')
def ode_nth_linear_euler_eq_nonhomogeneous_undetermined_coefficients(eq, func, order, match, returns='sol'):
r"""
Solves an `n`\th order linear non homogeneous Cauchy-Euler equidimensional
ordinary differential equation using undetermined coefficients.
This is an equation with form `g(x) = a_0 f(x) + a_1 x f'(x) + a_2 x^2 f''(x)
\cdots`.
These equations can be solved in a general manner, by substituting
solutions of the form `x = exp(t)`, and deriving a characteristic equation
of form `g(exp(t)) = b_0 f(t) + b_1 f'(t) + b_2 f''(t) \cdots` which can
be then solved by nth_linear_constant_coeff_undetermined_coefficients if
g(exp(t)) has finite number of linearly independent derivatives.
Functions that fit this requirement are finite sums functions of the form
`a x^i e^{b x} \sin(c x + d)` or `a x^i e^{b x} \cos(c x + d)`, where `i`
is a non-negative integer and `a`, `b`, `c`, and `d` are constants. For
example any polynomial in `x`, functions like `x^2 e^{2 x}`, `x \sin(x)`,
and `e^x \cos(x)` can all be used. Products of `\sin`'s and `\cos`'s have
a finite number of derivatives, because they can be expanded into `\sin(a
x)` and `\cos(b x)` terms. However, SymPy currently cannot do that
expansion, so you will need to manually rewrite the expression in terms of
the above to use this method. So, for example, you will need to manually
convert `\sin^2(x)` into `(1 + \cos(2 x))/2` to properly apply the method
of undetermined coefficients on it.
After replacement of x by exp(t), this method works by creating a trial function
from the expression and all of its linear independent derivatives and
substituting them into the original ODE. The coefficients for each term
will be a system of linear equations, which are be solved for and
substituted, giving the solution. If any of the trial functions are linearly
dependent on the solution to the homogeneous equation, they are multiplied
by sufficient `x` to make them linearly independent.
Examples
========
>>> from sympy import dsolve, Function, Derivative, log
>>> from sympy.abc import x
>>> f = Function('f')
>>> eq = x**2*Derivative(f(x), x, x) - 2*x*Derivative(f(x), x) + 2*f(x) - log(x)
>>> dsolve(eq, f(x),
... hint='nth_linear_euler_eq_nonhomogeneous_undetermined_coefficients').expand()
Eq(f(x), C1*x + C2*x**2 + log(x)/2 + 3/4)
"""
x = func.args[0]
f = func.func
r = match
chareq, eq, symbol = S.Zero, S.Zero, Dummy('x')
for i in r.keys():
if not isinstance(i, string_types) and i >= 0:
chareq += (r[i]*diff(x**symbol, x, i)*x**-symbol).expand()
for i in range(1,degree(Poly(chareq, symbol))+1):
eq += chareq.coeff(symbol**i)*diff(f(x), x, i)
if chareq.as_coeff_add(symbol)[0]:
eq += chareq.as_coeff_add(symbol)[0]*f(x)
e, re = posify(r[-1].subs(x, exp(x)))
eq += e.subs(re)
match = _nth_linear_match(eq, f(x), ode_order(eq, f(x)))
match['trialset'] = r['trialset']
return ode_nth_linear_constant_coeff_undetermined_coefficients(eq, func, order, match).subs(x, log(x)).subs(f(log(x)), f(x)).expand()
def ode_nth_linear_euler_eq_nonhomogeneous_variation_of_parameters(eq, func, order, match, returns='sol'):
r"""
Solves an `n`\th order linear non homogeneous Cauchy-Euler equidimensional
ordinary differential equation using variation of parameters.
This is an equation with form `g(x) = a_0 f(x) + a_1 x f'(x) + a_2 x^2 f''(x)
\cdots`.
This method works by assuming that the particular solution takes the form
.. math:: \sum_{x=1}^{n} c_i(x) y_i(x) {a_n} {x^n} \text{,}
where `y_i` is the `i`\th solution to the homogeneous equation. The
solution is then solved using Wronskian's and Cramer's Rule. The
particular solution is given by multiplying eq given below with `a_n x^{n}`
.. math:: \sum_{x=1}^n \left( \int \frac{W_i(x)}{W(x)} \,dx
\right) y_i(x) \text{,}
where `W(x)` is the Wronskian of the fundamental system (the system of `n`
linearly independent solutions to the homogeneous equation), and `W_i(x)`
is the Wronskian of the fundamental system with the `i`\th column replaced
with `[0, 0, \cdots, 0, \frac{x^{- n}}{a_n} g{\left(x \right)}]`.
This method is general enough to solve any `n`\th order inhomogeneous
linear differential equation, but sometimes SymPy cannot simplify the
Wronskian well enough to integrate it. If this method hangs, try using the
``nth_linear_constant_coeff_variation_of_parameters_Integral`` hint and
simplifying the integrals manually. Also, prefer using
``nth_linear_constant_coeff_undetermined_coefficients`` when it
applies, because it doesn't use integration, making it faster and more
reliable.
Warning, using simplify=False with
'nth_linear_constant_coeff_variation_of_parameters' in
:py:meth:`~sympy.solvers.ode.dsolve` may cause it to hang, because it will
not attempt to simplify the Wronskian before integrating. It is
recommended that you only use simplify=False with
'nth_linear_constant_coeff_variation_of_parameters_Integral' for this
method, especially if the solution to the homogeneous equation has
trigonometric functions in it.
Examples
========
>>> from sympy import Function, dsolve, Derivative
>>> from sympy.abc import x
>>> f = Function('f')
>>> eq = x**2*Derivative(f(x), x, x) - 2*x*Derivative(f(x), x) + 2*f(x) - x**4
>>> dsolve(eq, f(x),
... hint='nth_linear_euler_eq_nonhomogeneous_variation_of_parameters').expand()
Eq(f(x), C1*x + C2*x**2 + x**4/6)
"""
x = func.args[0]
f = func.func
r = match
gensol = ode_nth_linear_euler_eq_homogeneous(eq, func, order, match, returns='both')
match.update(gensol)
r[-1] = r[-1]/r[ode_order(eq, f(x))]
sol = _solve_variation_of_parameters(eq, func, order, match)
return Eq(f(x), r['sol'].rhs + (sol.rhs - r['sol'].rhs)*r[ode_order(eq, f(x))])
def ode_almost_linear(eq, func, order, match):
r"""
Solves an almost-linear differential equation.
The general form of an almost linear differential equation is
.. math:: f(x) g(y) y + k(x) l(y) + m(x) = 0
\text{where} l'(y) = g(y)\text{.}
This can be solved by substituting `l(y) = u(y)`. Making the given
substitution reduces it to a linear differential equation of the form `u'
+ P(x) u + Q(x) = 0`.
The general solution is
>>> from sympy import Function, dsolve, Eq, pprint
>>> from sympy.abc import x, y, n
>>> f, g, k, l = map(Function, ['f', 'g', 'k', 'l'])
>>> genform = Eq(f(x)*(l(y).diff(y)) + k(x)*l(y) + g(x), 0)
>>> pprint(genform)
d
f(x)*--(l(y)) + g(x) + k(x)*l(y) = 0
dy
>>> pprint(dsolve(genform, hint = 'almost_linear'))
/ // y*k(x) \\
| || ------ ||
| || f(x) || -y*k(x)
| ||-g(x)*e || --------
| ||-------------- for k(x) != 0|| f(x)
l(y) = |C1 + |< k(x) ||*e
| || ||
| || -y*g(x) ||
| || -------- otherwise ||
| || f(x) ||
\ \\ //
See Also
========
:meth:`sympy.solvers.ode.ode_1st_linear`
Examples
========
>>> from sympy import Function, Derivative, pprint
>>> from sympy.solvers.ode import dsolve, classify_ode
>>> from sympy.abc import x
>>> f = Function('f')
>>> d = f(x).diff(x)
>>> eq = x*d + x*f(x) + 1
>>> dsolve(eq, f(x), hint='almost_linear')
Eq(f(x), (C1 - Ei(x))*exp(-x))
>>> pprint(dsolve(eq, f(x), hint='almost_linear'))
-x
f(x) = (C1 - Ei(x))*e
References
==========
- Joel Moses, "Symbolic Integration - The Stormy Decade", Communications
of the ACM, Volume 14, Number 8, August 1971, pp. 558
"""
# Since ode_1st_linear has already been implemented, and the
# coefficients have been modified to the required form in
# classify_ode, just passing eq, func, order and match to
# ode_1st_linear will give the required output.
return ode_1st_linear(eq, func, order, match)
def _linear_coeff_match(expr, func):
r"""
Helper function to match hint ``linear_coefficients``.
Matches the expression to the form `(a_1 x + b_1 f(x) + c_1)/(a_2 x + b_2
f(x) + c_2)` where the following conditions hold:
1. `a_1`, `b_1`, `c_1`, `a_2`, `b_2`, `c_2` are Rationals;
2. `c_1` or `c_2` are not equal to zero;
3. `a_2 b_1 - a_1 b_2` is not equal to zero.
Return ``xarg``, ``yarg`` where
1. ``xarg`` = `(b_2 c_1 - b_1 c_2)/(a_2 b_1 - a_1 b_2)`
2. ``yarg`` = `(a_1 c_2 - a_2 c_1)/(a_2 b_1 - a_1 b_2)`
Examples
========
>>> from sympy import Function
>>> from sympy.abc import x
>>> from sympy.solvers.ode import _linear_coeff_match
>>> from sympy.functions.elementary.trigonometric import sin
>>> f = Function('f')
>>> _linear_coeff_match((
... (-25*f(x) - 8*x + 62)/(4*f(x) + 11*x - 11)), f(x))
(1/9, 22/9)
>>> _linear_coeff_match(
... sin((-5*f(x) - 8*x + 6)/(4*f(x) + x - 1)), f(x))
(19/27, 2/27)
>>> _linear_coeff_match(sin(f(x)/x), f(x))
"""
f = func.func
x = func.args[0]
def abc(eq):
r'''
Internal function of _linear_coeff_match
that returns Rationals a, b, c
if eq is a*x + b*f(x) + c, else None.
'''
eq = _mexpand(eq)
c = eq.as_independent(x, f(x), as_Add=True)[0]
if not c.is_Rational:
return
a = eq.coeff(x)
if not a.is_Rational:
return
b = eq.coeff(f(x))
if not b.is_Rational:
return
if eq == a*x + b*f(x) + c:
return a, b, c
def match(arg):
r'''
Internal function of _linear_coeff_match that returns Rationals a1,
b1, c1, a2, b2, c2 and a2*b1 - a1*b2 of the expression (a1*x + b1*f(x)
+ c1)/(a2*x + b2*f(x) + c2) if one of c1 or c2 and a2*b1 - a1*b2 is
non-zero, else None.
'''
n, d = arg.together().as_numer_denom()
m = abc(n)
if m is not None:
a1, b1, c1 = m
m = abc(d)
if m is not None:
a2, b2, c2 = m
d = a2*b1 - a1*b2
if (c1 or c2) and d:
return a1, b1, c1, a2, b2, c2, d
m = [fi.args[0] for fi in expr.atoms(Function) if fi.func != f and
len(fi.args) == 1 and not fi.args[0].is_Function] or {expr}
m1 = match(m.pop())
if m1 and all(match(mi) == m1 for mi in m):
a1, b1, c1, a2, b2, c2, denom = m1
return (b2*c1 - b1*c2)/denom, (a1*c2 - a2*c1)/denom
def ode_linear_coefficients(eq, func, order, match):
r"""
Solves a differential equation with linear coefficients.
The general form of a differential equation with linear coefficients is
.. math:: y' + F\left(\!\frac{a_1 x + b_1 y + c_1}{a_2 x + b_2 y +
c_2}\!\right) = 0\text{,}
where `a_1`, `b_1`, `c_1`, `a_2`, `b_2`, `c_2` are constants and `a_1 b_2
- a_2 b_1 \ne 0`.
This can be solved by substituting:
.. math:: x = x' + \frac{b_2 c_1 - b_1 c_2}{a_2 b_1 - a_1 b_2}
y = y' + \frac{a_1 c_2 - a_2 c_1}{a_2 b_1 - a_1
b_2}\text{.}
This substitution reduces the equation to a homogeneous differential
equation.
See Also
========
:meth:`sympy.solvers.ode.ode_1st_homogeneous_coeff_best`
:meth:`sympy.solvers.ode.ode_1st_homogeneous_coeff_subs_indep_div_dep`
:meth:`sympy.solvers.ode.ode_1st_homogeneous_coeff_subs_dep_div_indep`
Examples
========
>>> from sympy import Function, Derivative, pprint
>>> from sympy.solvers.ode import dsolve, classify_ode
>>> from sympy.abc import x
>>> f = Function('f')
>>> df = f(x).diff(x)
>>> eq = (x + f(x) + 1)*df + (f(x) - 6*x + 1)
>>> dsolve(eq, hint='linear_coefficients')
[Eq(f(x), -x - sqrt(C1 + 7*x**2) - 1), Eq(f(x), -x + sqrt(C1 + 7*x**2) - 1)]
>>> pprint(dsolve(eq, hint='linear_coefficients'))
___________ ___________
/ 2 / 2
[f(x) = -x - \/ C1 + 7*x - 1, f(x) = -x + \/ C1 + 7*x - 1]
References
==========
- Joel Moses, "Symbolic Integration - The Stormy Decade", Communications
of the ACM, Volume 14, Number 8, August 1971, pp. 558
"""
return ode_1st_homogeneous_coeff_best(eq, func, order, match)
def ode_separable_reduced(eq, func, order, match):
r"""
Solves a differential equation that can be reduced to the separable form.
The general form of this equation is
.. math:: y' + (y/x) H(x^n y) = 0\text{}.
This can be solved by substituting `u(y) = x^n y`. The equation then
reduces to the separable form `\frac{u'}{u (\mathrm{power} - H(u))} -
\frac{1}{x} = 0`.
The general solution is:
>>> from sympy import Function, dsolve, Eq, pprint
>>> from sympy.abc import x, n
>>> f, g = map(Function, ['f', 'g'])
>>> genform = f(x).diff(x) + (f(x)/x)*g(x**n*f(x))
>>> pprint(genform)
/ n \
d f(x)*g\x *f(x)/
--(f(x)) + ---------------
dx x
>>> pprint(dsolve(genform, hint='separable_reduced'))
n
x *f(x)
/
|
| 1
| ------------ dy = C1 + log(x)
| y*(n - g(y))
|
/
See Also
========
:meth:`sympy.solvers.ode.ode_separable`
Examples
========
>>> from sympy import Function, Derivative, pprint
>>> from sympy.solvers.ode import dsolve, classify_ode
>>> from sympy.abc import x
>>> f = Function('f')
>>> d = f(x).diff(x)
>>> eq = (x - x**2*f(x))*d - f(x)
>>> dsolve(eq, hint='separable_reduced')
[Eq(f(x), (1 - sqrt(C1*x**2 + 1))/x), Eq(f(x), (sqrt(C1*x**2 + 1) + 1)/x)]
>>> pprint(dsolve(eq, hint='separable_reduced'))
___________ ___________
/ 2 / 2
1 - \/ C1*x + 1 \/ C1*x + 1 + 1
[f(x) = ------------------, f(x) = ------------------]
x x
References
==========
- Joel Moses, "Symbolic Integration - The Stormy Decade", Communications
of the ACM, Volume 14, Number 8, August 1971, pp. 558
"""
# Arguments are passed in a way so that they are coherent with the
# ode_separable function
x = func.args[0]
f = func.func
y = Dummy('y')
u = match['u'].subs(match['t'], y)
ycoeff = 1/(y*(match['power'] - u))
m1 = {y: 1, x: -1/x, 'coeff': 1}
m2 = {y: ycoeff, x: 1, 'coeff': 1}
r = {'m1': m1, 'm2': m2, 'y': y, 'hint': x**match['power']*f(x)}
return ode_separable(eq, func, order, r)
def ode_1st_power_series(eq, func, order, match):
r"""
The power series solution is a method which gives the Taylor series expansion
to the solution of a differential equation.
For a first order differential equation `\frac{dy}{dx} = h(x, y)`, a power
series solution exists at a point `x = x_{0}` if `h(x, y)` is analytic at `x_{0}`.
The solution is given by
.. math:: y(x) = y(x_{0}) + \sum_{n = 1}^{\infty} \frac{F_{n}(x_{0},b)(x - x_{0})^n}{n!},
where `y(x_{0}) = b` is the value of y at the initial value of `x_{0}`.
To compute the values of the `F_{n}(x_{0},b)` the following algorithm is
followed, until the required number of terms are generated.
1. `F_1 = h(x_{0}, b)`
2. `F_{n+1} = \frac{\partial F_{n}}{\partial x} + \frac{\partial F_{n}}{\partial y}F_{1}`
Examples
========
>>> from sympy import Function, Derivative, pprint, exp
>>> from sympy.solvers.ode import dsolve
>>> from sympy.abc import x
>>> f = Function('f')
>>> eq = exp(x)*(f(x).diff(x)) - f(x)
>>> pprint(dsolve(eq, hint='1st_power_series'))
3 4 5
C1*x C1*x C1*x / 6\
f(x) = C1 + C1*x - ----- + ----- + ----- + O\x /
6 24 60
References
==========
- Travis W. Walker, Analytic power series technique for solving first-order
differential equations, p.p 17, 18
"""
x = func.args[0]
y = match['y']
f = func.func
h = -match[match['d']]/match[match['e']]
point = match.get('f0')
value = match.get('f0val')
terms = match.get('terms')
# First term
F = h
if not h:
return Eq(f(x), value)
# Initialization
series = value
if terms > 1:
hc = h.subs({x: point, y: value})
if hc.has(oo) or hc.has(NaN) or hc.has(zoo):
# Derivative does not exist, not analytic
return Eq(f(x), oo)
elif hc:
series += hc*(x - point)
for factcount in range(2, terms):
Fnew = F.diff(x) + F.diff(y)*h
Fnewc = Fnew.subs({x: point, y: value})
# Same logic as above
if Fnewc.has(oo) or Fnewc.has(NaN) or Fnewc.has(-oo) or Fnewc.has(zoo):
return Eq(f(x), oo)
series += Fnewc*((x - point)**factcount)/factorial(factcount)
F = Fnew
series += Order(x**terms)
return Eq(f(x), series)
def ode_nth_linear_constant_coeff_homogeneous(eq, func, order, match,
returns='sol'):
r"""
Solves an `n`\th order linear homogeneous differential equation with
constant coefficients.
This is an equation of the form
.. math:: a_n f^{(n)}(x) + a_{n-1} f^{(n-1)}(x) + \cdots + a_1 f'(x)
+ a_0 f(x) = 0\text{.}
These equations can be solved in a general manner, by taking the roots of
the characteristic equation `a_n m^n + a_{n-1} m^{n-1} + \cdots + a_1 m +
a_0 = 0`. The solution will then be the sum of `C_n x^i e^{r x}` terms,
for each where `C_n` is an arbitrary constant, `r` is a root of the
characteristic equation and `i` is one of each from 0 to the multiplicity
of the root - 1 (for example, a root 3 of multiplicity 2 would create the
terms `C_1 e^{3 x} + C_2 x e^{3 x}`). The exponential is usually expanded
for complex roots using Euler's equation `e^{I x} = \cos(x) + I \sin(x)`.
Complex roots always come in conjugate pairs in polynomials with real
coefficients, so the two roots will be represented (after simplifying the
constants) as `e^{a x} \left(C_1 \cos(b x) + C_2 \sin(b x)\right)`.
If SymPy cannot find exact roots to the characteristic equation, a
:py:class:`~sympy.polys.rootoftools.CRootOf` instance will be return
instead.
>>> from sympy import Function, dsolve, Eq
>>> from sympy.abc import x
>>> f = Function('f')
>>> dsolve(f(x).diff(x, 5) + 10*f(x).diff(x) - 2*f(x), f(x),
... hint='nth_linear_constant_coeff_homogeneous')
... # doctest: +NORMALIZE_WHITESPACE
Eq(f(x), C5*exp(x*CRootOf(_x**5 + 10*_x - 2, 0))
+ (C1*sin(x*im(CRootOf(_x**5 + 10*_x - 2, 1)))
+ C2*cos(x*im(CRootOf(_x**5 + 10*_x - 2, 1))))*exp(x*re(CRootOf(_x**5 + 10*_x - 2, 1)))
+ (C3*sin(x*im(CRootOf(_x**5 + 10*_x - 2, 3)))
+ C4*cos(x*im(CRootOf(_x**5 + 10*_x - 2, 3))))*exp(x*re(CRootOf(_x**5 + 10*_x - 2, 3))))
Note that because this method does not involve integration, there is no
``nth_linear_constant_coeff_homogeneous_Integral`` hint.
The following is for internal use:
- ``returns = 'sol'`` returns the solution to the ODE.
- ``returns = 'list'`` returns a list of linearly independent solutions,
for use with non homogeneous solution methods like variation of
parameters and undetermined coefficients. Note that, though the
solutions should be linearly independent, this function does not
explicitly check that. You can do ``assert simplify(wronskian(sollist))
!= 0`` to check for linear independence. Also, ``assert len(sollist) ==
order`` will need to pass.
- ``returns = 'both'``, return a dictionary ``{'sol': <solution to ODE>,
'list': <list of linearly independent solutions>}``.
Examples
========
>>> from sympy import Function, dsolve, pprint
>>> from sympy.abc import x
>>> f = Function('f')
>>> pprint(dsolve(f(x).diff(x, 4) + 2*f(x).diff(x, 3) -
... 2*f(x).diff(x, 2) - 6*f(x).diff(x) + 5*f(x), f(x),
... hint='nth_linear_constant_coeff_homogeneous'))
x -2*x
f(x) = (C1 + C2*x)*e + (C3*sin(x) + C4*cos(x))*e
References
==========
- https://en.wikipedia.org/wiki/Linear_differential_equation section:
Nonhomogeneous_equation_with_constant_coefficients
- M. Tenenbaum & H. Pollard, "Ordinary Differential Equations",
Dover 1963, pp. 211
# indirect doctest
"""
x = func.args[0]
f = func.func
r = match
# First, set up characteristic equation.
chareq, symbol = S.Zero, Dummy('x')
for i in r.keys():
if type(i) == str or i < 0:
pass
else:
chareq += r[i]*symbol**i
chareq = Poly(chareq, symbol)
# Can't just call roots because it doesn't return rootof for unsolveable
# polynomials.
chareqroots = roots(chareq, multiple=True)
if len(chareqroots) != order:
chareqroots = [rootof(chareq, k) for k in range(chareq.degree())]
chareq_is_complex = not all([i.is_real for i in chareq.all_coeffs()])
# A generator of constants
constants = list(get_numbered_constants(eq, num=chareq.degree()*2))
# Create a dict root: multiplicity or charroots
charroots = defaultdict(int)
for root in chareqroots:
charroots[root] += 1
# We need to keep track of terms so we can run collect() at the end.
# This is necessary for constantsimp to work properly.
global collectterms
collectterms = []
gensols = []
conjugate_roots = [] # used to prevent double-use of conjugate roots
# Loop over roots in theorder provided by roots/rootof...
for root in chareqroots:
# but don't repoeat multiple roots.
if root not in charroots:
continue
multiplicity = charroots.pop(root)
for i in range(multiplicity):
if chareq_is_complex:
gensols.append(x**i*exp(root*x))
collectterms = [(i, root, 0)] + collectterms
continue
reroot = re(root)
imroot = im(root)
if imroot.has(atan2) and reroot.has(atan2):
# Remove this condition when re and im stop returning
# circular atan2 usages.
gensols.append(x**i*exp(root*x))
collectterms = [(i, root, 0)] + collectterms
else:
if root in conjugate_roots:
collectterms = [(i, reroot, imroot)] + collectterms
continue
if imroot == 0:
gensols.append(x**i*exp(reroot*x))
collectterms = [(i, reroot, 0)] + collectterms
continue
conjugate_roots.append(conjugate(root))
gensols.append(x**i*exp(reroot*x) * sin(abs(imroot) * x))
gensols.append(x**i*exp(reroot*x) * cos( imroot * x))
# This ordering is important
collectterms = [(i, reroot, imroot)] + collectterms
if returns == 'list':
return gensols
elif returns in ('sol' 'both'):
gsol = Add(*[i*j for (i, j) in zip(constants, gensols)])
if returns == 'sol':
return Eq(f(x), gsol)
else:
return {'sol': Eq(f(x), gsol), 'list': gensols}
else:
raise ValueError('Unknown value for key "returns".')
def ode_nth_linear_constant_coeff_undetermined_coefficients(eq, func, order, match):
r"""
Solves an `n`\th order linear differential equation with constant
coefficients using the method of undetermined coefficients.
This method works on differential equations of the form
.. math:: a_n f^{(n)}(x) + a_{n-1} f^{(n-1)}(x) + \cdots + a_1 f'(x)
+ a_0 f(x) = P(x)\text{,}
where `P(x)` is a function that has a finite number of linearly
independent derivatives.
Functions that fit this requirement are finite sums functions of the form
`a x^i e^{b x} \sin(c x + d)` or `a x^i e^{b x} \cos(c x + d)`, where `i`
is a non-negative integer and `a`, `b`, `c`, and `d` are constants. For
example any polynomial in `x`, functions like `x^2 e^{2 x}`, `x \sin(x)`,
and `e^x \cos(x)` can all be used. Products of `\sin`'s and `\cos`'s have
a finite number of derivatives, because they can be expanded into `\sin(a
x)` and `\cos(b x)` terms. However, SymPy currently cannot do that
expansion, so you will need to manually rewrite the expression in terms of
the above to use this method. So, for example, you will need to manually
convert `\sin^2(x)` into `(1 + \cos(2 x))/2` to properly apply the method
of undetermined coefficients on it.
This method works by creating a trial function from the expression and all
of its linear independent derivatives and substituting them into the
original ODE. The coefficients for each term will be a system of linear
equations, which are be solved for and substituted, giving the solution.
If any of the trial functions are linearly dependent on the solution to
the homogeneous equation, they are multiplied by sufficient `x` to make
them linearly independent.
Examples
========
>>> from sympy import Function, dsolve, pprint, exp, cos
>>> from sympy.abc import x
>>> f = Function('f')
>>> pprint(dsolve(f(x).diff(x, 2) + 2*f(x).diff(x) + f(x) -
... 4*exp(-x)*x**2 + cos(2*x), f(x),
... hint='nth_linear_constant_coeff_undetermined_coefficients'))
/ 4\
| x | -x 4*sin(2*x) 3*cos(2*x)
f(x) = |C1 + C2*x + --|*e - ---------- + ----------
\ 3 / 25 25
References
==========
- https://en.wikipedia.org/wiki/Method_of_undetermined_coefficients
- M. Tenenbaum & H. Pollard, "Ordinary Differential Equations",
Dover 1963, pp. 221
# indirect doctest
"""
gensol = ode_nth_linear_constant_coeff_homogeneous(eq, func, order, match,
returns='both')
match.update(gensol)
return _solve_undetermined_coefficients(eq, func, order, match)
def _solve_undetermined_coefficients(eq, func, order, match):
r"""
Helper function for the method of undetermined coefficients.
See the
:py:meth:`~sympy.solvers.ode.ode_nth_linear_constant_coeff_undetermined_coefficients`
docstring for more information on this method.
The parameter ``match`` should be a dictionary that has the following
keys:
``list``
A list of solutions to the homogeneous equation, such as the list
returned by
``ode_nth_linear_constant_coeff_homogeneous(returns='list')``.
``sol``
The general solution, such as the solution returned by
``ode_nth_linear_constant_coeff_homogeneous(returns='sol')``.
``trialset``
The set of trial functions as returned by
``_undetermined_coefficients_match()['trialset']``.
"""
x = func.args[0]
f = func.func
r = match
coeffs = numbered_symbols('a', cls=Dummy)
coefflist = []
gensols = r['list']
gsol = r['sol']
trialset = r['trialset']
notneedset = set([])
global collectterms
if len(gensols) != order:
raise NotImplementedError("Cannot find " + str(order) +
" solutions to the homogeneous equation necessary to apply" +
" undetermined coefficients to " + str(eq) +
" (number of terms != order)")
usedsin = set([])
mult = 0 # The multiplicity of the root
getmult = True
for i, reroot, imroot in collectterms:
if getmult:
mult = i + 1
getmult = False
if i == 0:
getmult = True
if imroot:
# Alternate between sin and cos
if (i, reroot) in usedsin:
check = x**i*exp(reroot*x)*cos(imroot*x)
else:
check = x**i*exp(reroot*x)*sin(abs(imroot)*x)
usedsin.add((i, reroot))
else:
check = x**i*exp(reroot*x)
if check in trialset:
# If an element of the trial function is already part of the
# homogeneous solution, we need to multiply by sufficient x to
# make it linearly independent. We also don't need to bother
# checking for the coefficients on those elements, since we
# already know it will be 0.
while True:
if check*x**mult in trialset:
mult += 1
else:
break
trialset.add(check*x**mult)
notneedset.add(check)
newtrialset = trialset - notneedset
trialfunc = 0
for i in newtrialset:
c = next(coeffs)
coefflist.append(c)
trialfunc += c*i
eqs = sub_func_doit(eq, f(x), trialfunc)
coeffsdict = dict(list(zip(trialset, [0]*(len(trialset) + 1))))
eqs = _mexpand(eqs)
for i in Add.make_args(eqs):
s = separatevars(i, dict=True, symbols=[x])
coeffsdict[s[x]] += s['coeff']
coeffvals = solve(list(coeffsdict.values()), coefflist)
if not coeffvals:
raise NotImplementedError(
"Could not solve `%s` using the "
"method of undetermined coefficients "
"(unable to solve for coefficients)." % eq)
psol = trialfunc.subs(coeffvals)
return Eq(f(x), gsol.rhs + psol)
def _undetermined_coefficients_match(expr, x):
r"""
Returns a trial function match if undetermined coefficients can be applied
to ``expr``, and ``None`` otherwise.
A trial expression can be found for an expression for use with the method
of undetermined coefficients if the expression is an
additive/multiplicative combination of constants, polynomials in `x` (the
independent variable of expr), `\sin(a x + b)`, `\cos(a x + b)`, and
`e^{a x}` terms (in other words, it has a finite number of linearly
independent derivatives).
Note that you may still need to multiply each term returned here by
sufficient `x` to make it linearly independent with the solutions to the
homogeneous equation.
This is intended for internal use by ``undetermined_coefficients`` hints.
SymPy currently has no way to convert `\sin^n(x) \cos^m(y)` into a sum of
only `\sin(a x)` and `\cos(b x)` terms, so these are not implemented. So,
for example, you will need to manually convert `\sin^2(x)` into `[1 +
\cos(2 x)]/2` to properly apply the method of undetermined coefficients on
it.
Examples
========
>>> from sympy import log, exp
>>> from sympy.solvers.ode import _undetermined_coefficients_match
>>> from sympy.abc import x
>>> _undetermined_coefficients_match(9*x*exp(x) + exp(-x), x)
{'test': True, 'trialset': {x*exp(x), exp(-x), exp(x)}}
>>> _undetermined_coefficients_match(log(x), x)
{'test': False}
"""
a = Wild('a', exclude=[x])
b = Wild('b', exclude=[x])
expr = powsimp(expr, combine='exp') # exp(x)*exp(2*x + 1) => exp(3*x + 1)
retdict = {}
def _test_term(expr, x):
r"""
Test if ``expr`` fits the proper form for undetermined coefficients.
"""
if not expr.has(x):
return True
elif expr.is_Add:
return all(_test_term(i, x) for i in expr.args)
elif expr.is_Mul:
if expr.has(sin, cos):
foundtrig = False
# Make sure that there is only one trig function in the args.
# See the docstring.
for i in expr.args:
if i.has(sin, cos):
if foundtrig:
return False
else:
foundtrig = True
return all(_test_term(i, x) for i in expr.args)
elif expr.is_Function:
if expr.func in (sin, cos, exp):
if expr.args[0].match(a*x + b):
return True
else:
return False
else:
return False
elif expr.is_Pow and expr.base.is_Symbol and expr.exp.is_Integer and \
expr.exp >= 0:
return True
elif expr.is_Pow and expr.base.is_number:
if expr.exp.match(a*x + b):
return True
else:
return False
elif expr.is_Symbol or expr.is_number:
return True
else:
return False
def _get_trial_set(expr, x, exprs=set([])):
r"""
Returns a set of trial terms for undetermined coefficients.
The idea behind undetermined coefficients is that the terms expression
repeat themselves after a finite number of derivatives, except for the
coefficients (they are linearly dependent). So if we collect these,
we should have the terms of our trial function.
"""
def _remove_coefficient(expr, x):
r"""
Returns the expression without a coefficient.
Similar to expr.as_independent(x)[1], except it only works
multiplicatively.
"""
term = S.One
if expr.is_Mul:
for i in expr.args:
if i.has(x):
term *= i
elif expr.has(x):
term = expr
return term
expr = expand_mul(expr)
if expr.is_Add:
for term in expr.args:
if _remove_coefficient(term, x) in exprs:
pass
else:
exprs.add(_remove_coefficient(term, x))
exprs = exprs.union(_get_trial_set(term, x, exprs))
else:
term = _remove_coefficient(expr, x)
tmpset = exprs.union({term})
oldset = set([])
while tmpset != oldset:
# If you get stuck in this loop, then _test_term is probably
# broken
oldset = tmpset.copy()
expr = expr.diff(x)
term = _remove_coefficient(expr, x)
if term.is_Add:
tmpset = tmpset.union(_get_trial_set(term, x, tmpset))
else:
tmpset.add(term)
exprs = tmpset
return exprs
retdict['test'] = _test_term(expr, x)
if retdict['test']:
# Try to generate a list of trial solutions that will have the
# undetermined coefficients. Note that if any of these are not linearly
# independent with any of the solutions to the homogeneous equation,
# then they will need to be multiplied by sufficient x to make them so.
# This function DOES NOT do that (it doesn't even look at the
# homogeneous equation).
retdict['trialset'] = _get_trial_set(expr, x)
return retdict
def ode_nth_linear_constant_coeff_variation_of_parameters(eq, func, order, match):
r"""
Solves an `n`\th order linear differential equation with constant
coefficients using the method of variation of parameters.
This method works on any differential equations of the form
.. math:: f^{(n)}(x) + a_{n-1} f^{(n-1)}(x) + \cdots + a_1 f'(x) + a_0
f(x) = P(x)\text{.}
This method works by assuming that the particular solution takes the form
.. math:: \sum_{x=1}^{n} c_i(x) y_i(x)\text{,}
where `y_i` is the `i`\th solution to the homogeneous equation. The
solution is then solved using Wronskian's and Cramer's Rule. The
particular solution is given by
.. math:: \sum_{x=1}^n \left( \int \frac{W_i(x)}{W(x)} \,dx
\right) y_i(x) \text{,}
where `W(x)` is the Wronskian of the fundamental system (the system of `n`
linearly independent solutions to the homogeneous equation), and `W_i(x)`
is the Wronskian of the fundamental system with the `i`\th column replaced
with `[0, 0, \cdots, 0, P(x)]`.
This method is general enough to solve any `n`\th order inhomogeneous
linear differential equation with constant coefficients, but sometimes
SymPy cannot simplify the Wronskian well enough to integrate it. If this
method hangs, try using the
``nth_linear_constant_coeff_variation_of_parameters_Integral`` hint and
simplifying the integrals manually. Also, prefer using
``nth_linear_constant_coeff_undetermined_coefficients`` when it
applies, because it doesn't use integration, making it faster and more
reliable.
Warning, using simplify=False with
'nth_linear_constant_coeff_variation_of_parameters' in
:py:meth:`~sympy.solvers.ode.dsolve` may cause it to hang, because it will
not attempt to simplify the Wronskian before integrating. It is
recommended that you only use simplify=False with
'nth_linear_constant_coeff_variation_of_parameters_Integral' for this
method, especially if the solution to the homogeneous equation has
trigonometric functions in it.
Examples
========
>>> from sympy import Function, dsolve, pprint, exp, log
>>> from sympy.abc import x
>>> f = Function('f')
>>> pprint(dsolve(f(x).diff(x, 3) - 3*f(x).diff(x, 2) +
... 3*f(x).diff(x) - f(x) - exp(x)*log(x), f(x),
... hint='nth_linear_constant_coeff_variation_of_parameters'))
/ 3 \
| 2 x *(6*log(x) - 11)| x
f(x) = |C1 + C2*x + C3*x + ------------------|*e
\ 36 /
References
==========
- https://en.wikipedia.org/wiki/Variation_of_parameters
- http://planetmath.org/VariationOfParameters
- M. Tenenbaum & H. Pollard, "Ordinary Differential Equations",
Dover 1963, pp. 233
# indirect doctest
"""
gensol = ode_nth_linear_constant_coeff_homogeneous(eq, func, order, match,
returns='both')
match.update(gensol)
return _solve_variation_of_parameters(eq, func, order, match)
def _solve_variation_of_parameters(eq, func, order, match):
r"""
Helper function for the method of variation of parameters and nonhomogeneous euler eq.
See the
:py:meth:`~sympy.solvers.ode.ode_nth_linear_constant_coeff_variation_of_parameters`
docstring for more information on this method.
The parameter ``match`` should be a dictionary that has the following
keys:
``list``
A list of solutions to the homogeneous equation, such as the list
returned by
``ode_nth_linear_constant_coeff_homogeneous(returns='list')``.
``sol``
The general solution, such as the solution returned by
``ode_nth_linear_constant_coeff_homogeneous(returns='sol')``.
"""
x = func.args[0]
f = func.func
r = match
psol = 0
gensols = r['list']
gsol = r['sol']
wr = wronskian(gensols, x)
if r.get('simplify', True):
wr = simplify(wr) # We need much better simplification for
# some ODEs. See issue 4662, for example.
# To reduce commonly occurring sin(x)**2 + cos(x)**2 to 1
wr = trigsimp(wr, deep=True, recursive=True)
if not wr:
# The wronskian will be 0 iff the solutions are not linearly
# independent.
raise NotImplementedError("Cannot find " + str(order) +
" solutions to the homogeneous equation necessary to apply " +
"variation of parameters to " + str(eq) + " (Wronskian == 0)")
if len(gensols) != order:
raise NotImplementedError("Cannot find " + str(order) +
" solutions to the homogeneous equation necessary to apply " +
"variation of parameters to " +
str(eq) + " (number of terms != order)")
negoneterm = (-1)**(order)
for i in gensols:
psol += negoneterm*Integral(wronskian([sol for sol in gensols if sol != i], x)*r[-1]/wr, x)*i/r[order]
negoneterm *= -1
if r.get('simplify', True):
psol = simplify(psol)
psol = trigsimp(psol, deep=True)
return Eq(f(x), gsol.rhs + psol)
def ode_separable(eq, func, order, match):
r"""
Solves separable 1st order differential equations.
This is any differential equation that can be written as `P(y)
\tfrac{dy}{dx} = Q(x)`. The solution can then just be found by
rearranging terms and integrating: `\int P(y) \,dy = \int Q(x) \,dx`.
This hint uses :py:meth:`sympy.simplify.simplify.separatevars` as its back
end, so if a separable equation is not caught by this solver, it is most
likely the fault of that function.
:py:meth:`~sympy.simplify.simplify.separatevars` is
smart enough to do most expansion and factoring necessary to convert a
separable equation `F(x, y)` into the proper form `P(x)\cdot{}Q(y)`. The
general solution is::
>>> from sympy import Function, dsolve, Eq, pprint
>>> from sympy.abc import x
>>> a, b, c, d, f = map(Function, ['a', 'b', 'c', 'd', 'f'])
>>> genform = Eq(a(x)*b(f(x))*f(x).diff(x), c(x)*d(f(x)))
>>> pprint(genform)
d
a(x)*b(f(x))*--(f(x)) = c(x)*d(f(x))
dx
>>> pprint(dsolve(genform, f(x), hint='separable_Integral'))
f(x)
/ /
| |
| b(y) | c(x)
| ---- dy = C1 + | ---- dx
| d(y) | a(x)
| |
/ /
Examples
========
>>> from sympy import Function, dsolve, Eq
>>> from sympy.abc import x
>>> f = Function('f')
>>> pprint(dsolve(Eq(f(x)*f(x).diff(x) + x, 3*x*f(x)**2), f(x),
... hint='separable', simplify=False))
/ 2 \ 2
log\3*f (x) - 1/ x
---------------- = C1 + --
6 2
References
==========
- M. Tenenbaum & H. Pollard, "Ordinary Differential Equations",
Dover 1963, pp. 52
# indirect doctest
"""
x = func.args[0]
f = func.func
C1 = get_numbered_constants(eq, num=1)
r = match # {'m1':m1, 'm2':m2, 'y':y}
u = r.get('hint', f(x)) # get u from separable_reduced else get f(x)
return Eq(Integral(r['m2']['coeff']*r['m2'][r['y']]/r['m1'][r['y']],
(r['y'], None, u)), Integral(-r['m1']['coeff']*r['m1'][x]/
r['m2'][x], x) + C1)
def checkinfsol(eq, infinitesimals, func=None, order=None):
r"""
This function is used to check if the given infinitesimals are the
actual infinitesimals of the given first order differential equation.
This method is specific to the Lie Group Solver of ODEs.
As of now, it simply checks, by substituting the infinitesimals in the
partial differential equation.
.. math:: \frac{\partial \eta}{\partial x} + \left(\frac{\partial \eta}{\partial y}
- \frac{\partial \xi}{\partial x}\right)*h
- \frac{\partial \xi}{\partial y}*h^{2}
- \xi\frac{\partial h}{\partial x} - \eta\frac{\partial h}{\partial y} = 0
where `\eta`, and `\xi` are the infinitesimals and `h(x,y) = \frac{dy}{dx}`
The infinitesimals should be given in the form of a list of dicts
``[{xi(x, y): inf, eta(x, y): inf}]``, corresponding to the
output of the function infinitesimals. It returns a list
of values of the form ``[(True/False, sol)]`` where ``sol`` is the value
obtained after substituting the infinitesimals in the PDE. If it
is ``True``, then ``sol`` would be 0.
"""
if isinstance(eq, Equality):
eq = eq.lhs - eq.rhs
if not func:
eq, func = _preprocess(eq)
variables = func.args
if len(variables) != 1:
raise ValueError("ODE's have only one independent variable")
else:
x = variables[0]
if not order:
order = ode_order(eq, func)
if order != 1:
raise NotImplementedError("Lie groups solver has been implemented "
"only for first order differential equations")
else:
df = func.diff(x)
a = Wild('a', exclude = [df])
b = Wild('b', exclude = [df])
match = collect(expand(eq), df).match(a*df + b)
if match:
h = -simplify(match[b]/match[a])
else:
try:
sol = solve(eq, df)
except NotImplementedError:
raise NotImplementedError("Infinitesimals for the "
"first order ODE could not be found")
else:
h = sol[0] # Find infinitesimals for one solution
y = Dummy('y')
h = h.subs(func, y)
xi = Function('xi')(x, y)
eta = Function('eta')(x, y)
dxi = Function('xi')(x, func)
deta = Function('eta')(x, func)
pde = (eta.diff(x) + (eta.diff(y) - xi.diff(x))*h -
(xi.diff(y))*h**2 - xi*(h.diff(x)) - eta*(h.diff(y)))
soltup = []
for sol in infinitesimals:
tsol = {xi: S(sol[dxi]).subs(func, y),
eta: S(sol[deta]).subs(func, y)}
sol = simplify(pde.subs(tsol).doit())
if sol:
soltup.append((False, sol.subs(y, func)))
else:
soltup.append((True, 0))
return soltup
def ode_lie_group(eq, func, order, match):
r"""
This hint implements the Lie group method of solving first order differential
equations. The aim is to convert the given differential equation from the
given coordinate given system into another coordinate system where it becomes
invariant under the one-parameter Lie group of translations. The converted ODE is
quadrature and can be solved easily. It makes use of the
:py:meth:`sympy.solvers.ode.infinitesimals` function which returns the
infinitesimals of the transformation.
The coordinates `r` and `s` can be found by solving the following Partial
Differential Equations.
.. math :: \xi\frac{\partial r}{\partial x} + \eta\frac{\partial r}{\partial y}
= 0
.. math :: \xi\frac{\partial s}{\partial x} + \eta\frac{\partial s}{\partial y}
= 1
The differential equation becomes separable in the new coordinate system
.. math :: \frac{ds}{dr} = \frac{\frac{\partial s}{\partial x} +
h(x, y)\frac{\partial s}{\partial y}}{
\frac{\partial r}{\partial x} + h(x, y)\frac{\partial r}{\partial y}}
After finding the solution by integration, it is then converted back to the original
coordinate system by substituting `r` and `s` in terms of `x` and `y` again.
Examples
========
>>> from sympy import Function, dsolve, Eq, exp, pprint
>>> from sympy.abc import x
>>> f = Function('f')
>>> pprint(dsolve(f(x).diff(x) + 2*x*f(x) - x*exp(-x**2), f(x),
... hint='lie_group'))
/ 2\ 2
| x | -x
f(x) = |C1 + --|*e
\ 2 /
References
==========
- Solving differential equations by Symmetry Groups,
John Starrett, pp. 1 - pp. 14
"""
heuristics = lie_heuristics
inf = {}
f = func.func
x = func.args[0]
df = func.diff(x)
xi = Function("xi")
eta = Function("eta")
xis = match.pop('xi')
etas = match.pop('eta')
if match:
h = -simplify(match[match['d']]/match[match['e']])
y = match['y']
else:
try:
sol = solve(eq, df)
if sol == []:
raise NotImplementedError
except NotImplementedError:
raise NotImplementedError("Unable to solve the differential equation " +
str(eq) + " by the lie group method")
else:
y = Dummy("y")
h = sol[0].subs(func, y)
if xis is not None and etas is not None:
inf = [{xi(x, f(x)): S(xis), eta(x, f(x)): S(etas)}]
if not checkinfsol(eq, inf, func=f(x), order=1)[0][0]:
raise ValueError("The given infinitesimals xi and eta"
" are not the infinitesimals to the given equation")
else:
heuristics = ["user_defined"]
match = {'h': h, 'y': y}
# This is done so that if:
# a] solve raises a NotImplementedError.
# b] any heuristic raises a ValueError
# another heuristic can be used.
tempsol = [] # Used by solve below
for heuristic in heuristics:
try:
if not inf:
inf = infinitesimals(eq, hint=heuristic, func=func, order=1, match=match)
except ValueError:
continue
else:
for infsim in inf:
xiinf = (infsim[xi(x, func)]).subs(func, y)
etainf = (infsim[eta(x, func)]).subs(func, y)
# This condition creates recursion while using pdsolve.
# Since the first step while solving a PDE of form
# a*(f(x, y).diff(x)) + b*(f(x, y).diff(y)) + c = 0
# is to solve the ODE dy/dx = b/a
if simplify(etainf/xiinf) == h:
continue
rpde = f(x, y).diff(x)*xiinf + f(x, y).diff(y)*etainf
r = pdsolve(rpde, func=f(x, y)).rhs
s = pdsolve(rpde - 1, func=f(x, y)).rhs
newcoord = [_lie_group_remove(coord) for coord in [r, s]]
r = Dummy("r")
s = Dummy("s")
C1 = Symbol("C1")
rcoord = newcoord[0]
scoord = newcoord[-1]
try:
sol = solve([r - rcoord, s - scoord], x, y, dict=True)
except NotImplementedError:
continue
else:
sol = sol[0]
xsub = sol[x]
ysub = sol[y]
num = simplify(scoord.diff(x) + scoord.diff(y)*h)
denom = simplify(rcoord.diff(x) + rcoord.diff(y)*h)
if num and denom:
diffeq = simplify((num/denom).subs([(x, xsub), (y, ysub)]))
sep = separatevars(diffeq, symbols=[r, s], dict=True)
if sep:
# Trying to separate, r and s coordinates
deq = integrate((1/sep[s]), s) + C1 - integrate(sep['coeff']*sep[r], r)
# Substituting and reverting back to original coordinates
deq = deq.subs([(r, rcoord), (s, scoord)])
try:
sdeq = solve(deq, y)
except NotImplementedError:
tempsol.append(deq)
else:
if len(sdeq) == 1:
return Eq(f(x), sdeq.pop())
else:
return [Eq(f(x), sol) for sol in sdeq]
elif denom: # (ds/dr) is zero which means s is constant
return Eq(f(x), solve(scoord - C1, y)[0])
elif num: # (dr/ds) is zero which means r is constant
return Eq(f(x), solve(rcoord - C1, y)[0])
# If nothing works, return solution as it is, without solving for y
if tempsol:
if len(tempsol) == 1:
return Eq(tempsol.pop().subs(y, f(x)), 0)
else:
return [Eq(sol.subs(y, f(x)), 0) for sol in tempsol]
raise NotImplementedError("The given ODE " + str(eq) + " cannot be solved by"
+ " the lie group method")
def _lie_group_remove(coords):
r"""
This function is strictly meant for internal use by the Lie group ODE solving
method. It replaces arbitrary functions returned by pdsolve with either 0 or 1 or the
args of the arbitrary function.
The algorithm used is:
1] If coords is an instance of an Undefined Function, then the args are returned
2] If the arbitrary function is present in an Add object, it is replaced by zero.
3] If the arbitrary function is present in an Mul object, it is replaced by one.
4] If coords has no Undefined Function, it is returned as it is.
Examples
========
>>> from sympy.solvers.ode import _lie_group_remove
>>> from sympy import Function
>>> from sympy.abc import x, y
>>> F = Function("F")
>>> eq = x**2*y
>>> _lie_group_remove(eq)
x**2*y
>>> eq = F(x**2*y)
>>> _lie_group_remove(eq)
x**2*y
>>> eq = y**2*x + F(x**3)
>>> _lie_group_remove(eq)
x*y**2
>>> eq = (F(x**3) + y)*x**4
>>> _lie_group_remove(eq)
x**4*y
"""
if isinstance(coords, AppliedUndef):
return coords.args[0]
elif coords.is_Add:
subfunc = coords.atoms(AppliedUndef)
if subfunc:
for func in subfunc:
coords = coords.subs(func, 0)
return coords
elif coords.is_Pow:
base, expr = coords.as_base_exp()
base = _lie_group_remove(base)
expr = _lie_group_remove(expr)
return base**expr
elif coords.is_Mul:
mulargs = []
coordargs = coords.args
for arg in coordargs:
if not isinstance(coords, AppliedUndef):
mulargs.append(_lie_group_remove(arg))
return Mul(*mulargs)
return coords
def infinitesimals(eq, func=None, order=None, hint='default', match=None):
r"""
The infinitesimal functions of an ordinary differential equation, `\xi(x,y)`
and `\eta(x,y)`, are the infinitesimals of the Lie group of point transformations
for which the differential equation is invariant. So, the ODE `y'=f(x,y)`
would admit a Lie group `x^*=X(x,y;\varepsilon)=x+\varepsilon\xi(x,y)`,
`y^*=Y(x,y;\varepsilon)=y+\varepsilon\eta(x,y)` such that `(y^*)'=f(x^*, y^*)`.
A change of coordinates, to `r(x,y)` and `s(x,y)`, can be performed so this Lie group
becomes the translation group, `r^*=r` and `s^*=s+\varepsilon`.
They are tangents to the coordinate curves of the new system.
Consider the transformation `(x, y) \to (X, Y)` such that the
differential equation remains invariant. `\xi` and `\eta` are the tangents to
the transformed coordinates `X` and `Y`, at `\varepsilon=0`.
.. math:: \left(\frac{\partial X(x,y;\varepsilon)}{\partial\varepsilon
}\right)|_{\varepsilon=0} = \xi,
\left(\frac{\partial Y(x,y;\varepsilon)}{\partial\varepsilon
}\right)|_{\varepsilon=0} = \eta,
The infinitesimals can be found by solving the following PDE:
>>> from sympy import Function, diff, Eq, pprint
>>> from sympy.abc import x, y
>>> xi, eta, h = map(Function, ['xi', 'eta', 'h'])
>>> h = h(x, y) # dy/dx = h
>>> eta = eta(x, y)
>>> xi = xi(x, y)
>>> genform = Eq(eta.diff(x) + (eta.diff(y) - xi.diff(x))*h
... - (xi.diff(y))*h**2 - xi*(h.diff(x)) - eta*(h.diff(y)), 0)
>>> pprint(genform)
/d d \ d 2 d
|--(eta(x, y)) - --(xi(x, y))|*h(x, y) - eta(x, y)*--(h(x, y)) - h (x, y)*--(x
\dy dx / dy dy
<BLANKLINE>
d d
i(x, y)) - xi(x, y)*--(h(x, y)) + --(eta(x, y)) = 0
dx dx
Solving the above mentioned PDE is not trivial, and can be solved only by
making intelligent assumptions for `\xi` and `\eta` (heuristics). Once an
infinitesimal is found, the attempt to find more heuristics stops. This is done to
optimise the speed of solving the differential equation. If a list of all the
infinitesimals is needed, ``hint`` should be flagged as ``all``, which gives
the complete list of infinitesimals. If the infinitesimals for a particular
heuristic needs to be found, it can be passed as a flag to ``hint``.
Examples
========
>>> from sympy import Function, diff
>>> from sympy.solvers.ode import infinitesimals
>>> from sympy.abc import x
>>> f = Function('f')
>>> eq = f(x).diff(x) - x**2*f(x)
>>> infinitesimals(eq)
[{eta(x, f(x)): exp(x**3/3), xi(x, f(x)): 0}]
References
==========
- Solving differential equations by Symmetry Groups,
John Starrett, pp. 1 - pp. 14
"""
if isinstance(eq, Equality):
eq = eq.lhs - eq.rhs
if not func:
eq, func = _preprocess(eq)
variables = func.args
if len(variables) != 1:
raise ValueError("ODE's have only one independent variable")
else:
x = variables[0]
if not order:
order = ode_order(eq, func)
if order != 1:
raise NotImplementedError("Infinitesimals for only "
"first order ODE's have been implemented")
else:
df = func.diff(x)
# Matching differential equation of the form a*df + b
a = Wild('a', exclude = [df])
b = Wild('b', exclude = [df])
if match: # Used by lie_group hint
h = match['h']
y = match['y']
else:
match = collect(expand(eq), df).match(a*df + b)
if match:
h = -simplify(match[b]/match[a])
else:
try:
sol = solve(eq, df)
except NotImplementedError:
raise NotImplementedError("Infinitesimals for the "
"first order ODE could not be found")
else:
h = sol[0] # Find infinitesimals for one solution
y = Dummy("y")
h = h.subs(func, y)
u = Dummy("u")
hx = h.diff(x)
hy = h.diff(y)
hinv = ((1/h).subs([(x, u), (y, x)])).subs(u, y) # Inverse ODE
match = {'h': h, 'func': func, 'hx': hx, 'hy': hy, 'y': y, 'hinv': hinv}
if hint == 'all':
xieta = []
for heuristic in lie_heuristics:
function = globals()['lie_heuristic_' + heuristic]
inflist = function(match, comp=True)
if inflist:
xieta.extend([inf for inf in inflist if inf not in xieta])
if xieta:
return xieta
else:
raise NotImplementedError("Infinitesimals could not be found for "
"the given ODE")
elif hint == 'default':
for heuristic in lie_heuristics:
function = globals()['lie_heuristic_' + heuristic]
xieta = function(match, comp=False)
if xieta:
return xieta
raise NotImplementedError("Infinitesimals could not be found for"
" the given ODE")
elif hint not in lie_heuristics:
raise ValueError("Heuristic not recognized: " + hint)
else:
function = globals()['lie_heuristic_' + hint]
xieta = function(match, comp=True)
if xieta:
return xieta
else:
raise ValueError("Infinitesimals could not be found using the"
" given heuristic")
def lie_heuristic_abaco1_simple(match, comp=False):
r"""
The first heuristic uses the following four sets of
assumptions on `\xi` and `\eta`
.. math:: \xi = 0, \eta = f(x)
.. math:: \xi = 0, \eta = f(y)
.. math:: \xi = f(x), \eta = 0
.. math:: \xi = f(y), \eta = 0
The success of this heuristic is determined by algebraic factorisation.
For the first assumption `\xi = 0` and `\eta` to be a function of `x`, the PDE
.. math:: \frac{\partial \eta}{\partial x} + (\frac{\partial \eta}{\partial y}
- \frac{\partial \xi}{\partial x})*h
- \frac{\partial \xi}{\partial y}*h^{2}
- \xi*\frac{\partial h}{\partial x} - \eta*\frac{\partial h}{\partial y} = 0
reduces to `f'(x) - f\frac{\partial h}{\partial y} = 0`
If `\frac{\partial h}{\partial y}` is a function of `x`, then this can usually
be integrated easily. A similar idea is applied to the other 3 assumptions as well.
References
==========
- E.S Cheb-Terrab, L.G.S Duarte and L.A,C.P da Mota, Computer Algebra
Solving of First Order ODEs Using Symmetry Methods, pp. 8
"""
xieta = []
y = match['y']
h = match['h']
func = match['func']
x = func.args[0]
hx = match['hx']
hy = match['hy']
xi = Function('xi')(x, func)
eta = Function('eta')(x, func)
hysym = hy.free_symbols
if y not in hysym:
try:
fx = exp(integrate(hy, x))
except NotImplementedError:
pass
else:
inf = {xi: S(0), eta: fx}
if not comp:
return [inf]
if comp and inf not in xieta:
xieta.append(inf)
factor = hy/h
facsym = factor.free_symbols
if x not in facsym:
try:
fy = exp(integrate(factor, y))
except NotImplementedError:
pass
else:
inf = {xi: S(0), eta: fy.subs(y, func)}
if not comp:
return [inf]
if comp and inf not in xieta:
xieta.append(inf)
factor = -hx/h
facsym = factor.free_symbols
if y not in facsym:
try:
fx = exp(integrate(factor, x))
except NotImplementedError:
pass
else:
inf = {xi: fx, eta: S(0)}
if not comp:
return [inf]
if comp and inf not in xieta:
xieta.append(inf)
factor = -hx/(h**2)
facsym = factor.free_symbols
if x not in facsym:
try:
fy = exp(integrate(factor, y))
except NotImplementedError:
pass
else:
inf = {xi: fy.subs(y, func), eta: S(0)}
if not comp:
return [inf]
if comp and inf not in xieta:
xieta.append(inf)
if xieta:
return xieta
def lie_heuristic_abaco1_product(match, comp=False):
r"""
The second heuristic uses the following two assumptions on `\xi` and `\eta`
.. math:: \eta = 0, \xi = f(x)*g(y)
.. math:: \eta = f(x)*g(y), \xi = 0
The first assumption of this heuristic holds good if
`\frac{1}{h^{2}}\frac{\partial^2}{\partial x \partial y}\log(h)` is
separable in `x` and `y`, then the separated factors containing `x`
is `f(x)`, and `g(y)` is obtained by
.. math:: e^{\int f\frac{\partial}{\partial x}\left(\frac{1}{f*h}\right)\,dy}
provided `f\frac{\partial}{\partial x}\left(\frac{1}{f*h}\right)` is a function
of `y` only.
The second assumption holds good if `\frac{dy}{dx} = h(x, y)` is rewritten as
`\frac{dy}{dx} = \frac{1}{h(y, x)}` and the same properties of the first assumption
satisfies. After obtaining `f(x)` and `g(y)`, the coordinates are again
interchanged, to get `\eta` as `f(x)*g(y)`
References
==========
- E.S. Cheb-Terrab, A.D. Roche, Symmetries and First Order
ODE Patterns, pp. 7 - pp. 8
"""
xieta = []
y = match['y']
h = match['h']
hinv = match['hinv']
func = match['func']
x = func.args[0]
xi = Function('xi')(x, func)
eta = Function('eta')(x, func)
inf = separatevars(((log(h).diff(y)).diff(x))/h**2, dict=True, symbols=[x, y])
if inf and inf['coeff']:
fx = inf[x]
gy = simplify(fx*((1/(fx*h)).diff(x)))
gysyms = gy.free_symbols
if x not in gysyms:
gy = exp(integrate(gy, y))
inf = {eta: S(0), xi: (fx*gy).subs(y, func)}
if not comp:
return [inf]
if comp and inf not in xieta:
xieta.append(inf)
u1 = Dummy("u1")
inf = separatevars(((log(hinv).diff(y)).diff(x))/hinv**2, dict=True, symbols=[x, y])
if inf and inf['coeff']:
fx = inf[x]
gy = simplify(fx*((1/(fx*hinv)).diff(x)))
gysyms = gy.free_symbols
if x not in gysyms:
gy = exp(integrate(gy, y))
etaval = fx*gy
etaval = (etaval.subs([(x, u1), (y, x)])).subs(u1, y)
inf = {eta: etaval.subs(y, func), xi: S(0)}
if not comp:
return [inf]
if comp and inf not in xieta:
xieta.append(inf)
if xieta:
return xieta
def lie_heuristic_bivariate(match, comp=False):
r"""
The third heuristic assumes the infinitesimals `\xi` and `\eta`
to be bi-variate polynomials in `x` and `y`. The assumption made here
for the logic below is that `h` is a rational function in `x` and `y`
though that may not be necessary for the infinitesimals to be
bivariate polynomials. The coefficients of the infinitesimals
are found out by substituting them in the PDE and grouping similar terms
that are polynomials and since they form a linear system, solve and check
for non trivial solutions. The degree of the assumed bivariates
are increased till a certain maximum value.
References
==========
- Lie Groups and Differential Equations
pp. 327 - pp. 329
"""
h = match['h']
hx = match['hx']
hy = match['hy']
func = match['func']
x = func.args[0]
y = match['y']
xi = Function('xi')(x, func)
eta = Function('eta')(x, func)
if h.is_rational_function():
# The maximum degree that the infinitesimals can take is
# calculated by this technique.
etax, etay, etad, xix, xiy, xid = symbols("etax etay etad xix xiy xid")
ipde = etax + (etay - xix)*h - xiy*h**2 - xid*hx - etad*hy
num, denom = cancel(ipde).as_numer_denom()
deg = Poly(num, x, y).total_degree()
deta = Function('deta')(x, y)
dxi = Function('dxi')(x, y)
ipde = (deta.diff(x) + (deta.diff(y) - dxi.diff(x))*h - (dxi.diff(y))*h**2
- dxi*hx - deta*hy)
xieq = Symbol("xi0")
etaeq = Symbol("eta0")
for i in range(deg + 1):
if i:
xieq += Add(*[
Symbol("xi_" + str(power) + "_" + str(i - power))*x**power*y**(i - power)
for power in range(i + 1)])
etaeq += Add(*[
Symbol("eta_" + str(power) + "_" + str(i - power))*x**power*y**(i - power)
for power in range(i + 1)])
pden, denom = (ipde.subs({dxi: xieq, deta: etaeq}).doit()).as_numer_denom()
pden = expand(pden)
# If the individual terms are monomials, the coefficients
# are grouped
if pden.is_polynomial(x, y) and pden.is_Add:
polyy = Poly(pden, x, y).as_dict()
if polyy:
symset = xieq.free_symbols.union(etaeq.free_symbols) - {x, y}
soldict = solve(polyy.values(), *symset)
if isinstance(soldict, list):
soldict = soldict[0]
if any(soldict.values()):
xired = xieq.subs(soldict)
etared = etaeq.subs(soldict)
# Scaling is done by substituting one for the parameters
# This can be any number except zero.
dict_ = dict((sym, 1) for sym in symset)
inf = {eta: etared.subs(dict_).subs(y, func),
xi: xired.subs(dict_).subs(y, func)}
return [inf]
def lie_heuristic_chi(match, comp=False):
r"""
The aim of the fourth heuristic is to find the function `\chi(x, y)`
that satisfies the PDE `\frac{d\chi}{dx} + h\frac{d\chi}{dx}
- \frac{\partial h}{\partial y}\chi = 0`.
This assumes `\chi` to be a bivariate polynomial in `x` and `y`. By intuition,
`h` should be a rational function in `x` and `y`. The method used here is
to substitute a general binomial for `\chi` up to a certain maximum degree
is reached. The coefficients of the polynomials, are calculated by by collecting
terms of the same order in `x` and `y`.
After finding `\chi`, the next step is to use `\eta = \xi*h + \chi`, to
determine `\xi` and `\eta`. This can be done by dividing `\chi` by `h`
which would give `-\xi` as the quotient and `\eta` as the remainder.
References
==========
- E.S Cheb-Terrab, L.G.S Duarte and L.A,C.P da Mota, Computer Algebra
Solving of First Order ODEs Using Symmetry Methods, pp. 8
"""
h = match['h']
hy = match['hy']
func = match['func']
x = func.args[0]
y = match['y']
xi = Function('xi')(x, func)
eta = Function('eta')(x, func)
if h.is_rational_function():
schi, schix, schiy = symbols("schi, schix, schiy")
cpde = schix + h*schiy - hy*schi
num, denom = cancel(cpde).as_numer_denom()
deg = Poly(num, x, y).total_degree()
chi = Function('chi')(x, y)
chix = chi.diff(x)
chiy = chi.diff(y)
cpde = chix + h*chiy - hy*chi
chieq = Symbol("chi")
for i in range(1, deg + 1):
chieq += Add(*[
Symbol("chi_" + str(power) + "_" + str(i - power))*x**power*y**(i - power)
for power in range(i + 1)])
cnum, cden = cancel(cpde.subs({chi : chieq}).doit()).as_numer_denom()
cnum = expand(cnum)
if cnum.is_polynomial(x, y) and cnum.is_Add:
cpoly = Poly(cnum, x, y).as_dict()
if cpoly:
solsyms = chieq.free_symbols - {x, y}
soldict = solve(cpoly.values(), *solsyms)
if isinstance(soldict, list):
soldict = soldict[0]
if any(soldict.values()):
chieq = chieq.subs(soldict)
dict_ = dict((sym, 1) for sym in solsyms)
chieq = chieq.subs(dict_)
# After finding chi, the main aim is to find out
# eta, xi by the equation eta = xi*h + chi
# One method to set xi, would be rearranging it to
# (eta/h) - xi = (chi/h). This would mean dividing
# chi by h would give -xi as the quotient and eta
# as the remainder. Thanks to Sean Vig for suggesting
# this method.
xic, etac = div(chieq, h)
inf = {eta: etac.subs(y, func), xi: -xic.subs(y, func)}
return [inf]
def lie_heuristic_function_sum(match, comp=False):
r"""
This heuristic uses the following two assumptions on `\xi` and `\eta`
.. math:: \eta = 0, \xi = f(x) + g(y)
.. math:: \eta = f(x) + g(y), \xi = 0
The first assumption of this heuristic holds good if
.. math:: \frac{\partial}{\partial y}[(h\frac{\partial^{2}}{
\partial x^{2}}(h^{-1}))^{-1}]
is separable in `x` and `y`,
1. The separated factors containing `y` is `\frac{\partial g}{\partial y}`.
From this `g(y)` can be determined.
2. The separated factors containing `x` is `f''(x)`.
3. `h\frac{\partial^{2}}{\partial x^{2}}(h^{-1})` equals
`\frac{f''(x)}{f(x) + g(y)}`. From this `f(x)` can be determined.
The second assumption holds good if `\frac{dy}{dx} = h(x, y)` is rewritten as
`\frac{dy}{dx} = \frac{1}{h(y, x)}` and the same properties of the first
assumption satisfies. After obtaining `f(x)` and `g(y)`, the coordinates
are again interchanged, to get `\eta` as `f(x) + g(y)`.
For both assumptions, the constant factors are separated among `g(y)`
and `f''(x)`, such that `f''(x)` obtained from 3] is the same as that
obtained from 2]. If not possible, then this heuristic fails.
References
==========
- E.S. Cheb-Terrab, A.D. Roche, Symmetries and First Order
ODE Patterns, pp. 7 - pp. 8
"""
xieta = []
h = match['h']
func = match['func']
hinv = match['hinv']
x = func.args[0]
y = match['y']
xi = Function('xi')(x, func)
eta = Function('eta')(x, func)
for odefac in [h, hinv]:
factor = odefac*((1/odefac).diff(x, 2))
sep = separatevars((1/factor).diff(y), dict=True, symbols=[x, y])
if sep and sep['coeff'] and sep[x].has(x) and sep[y].has(y):
k = Dummy("k")
try:
gy = k*integrate(sep[y], y)
except NotImplementedError:
pass
else:
fdd = 1/(k*sep[x]*sep['coeff'])
fx = simplify(fdd/factor - gy)
check = simplify(fx.diff(x, 2) - fdd)
if fx:
if not check:
fx = fx.subs(k, 1)
gy = (gy/k)
else:
sol = solve(check, k)
if sol:
sol = sol[0]
fx = fx.subs(k, sol)
gy = (gy/k)*sol
else:
continue
if odefac == hinv: # Inverse ODE
fx = fx.subs(x, y)
gy = gy.subs(y, x)
etaval = factor_terms(fx + gy)
if etaval.is_Mul:
etaval = Mul(*[arg for arg in etaval.args if arg.has(x, y)])
if odefac == hinv: # Inverse ODE
inf = {eta: etaval.subs(y, func), xi : S(0)}
else:
inf = {xi: etaval.subs(y, func), eta : S(0)}
if not comp:
return [inf]
else:
xieta.append(inf)
if xieta:
return xieta
def lie_heuristic_abaco2_similar(match, comp=False):
r"""
This heuristic uses the following two assumptions on `\xi` and `\eta`
.. math:: \eta = g(x), \xi = f(x)
.. math:: \eta = f(y), \xi = g(y)
For the first assumption,
1. First `\frac{\frac{\partial h}{\partial y}}{\frac{\partial^{2} h}{
\partial yy}}` is calculated. Let us say this value is A
2. If this is constant, then `h` is matched to the form `A(x) + B(x)e^{
\frac{y}{C}}` then, `\frac{e^{\int \frac{A(x)}{C} \,dx}}{B(x)}` gives `f(x)`
and `A(x)*f(x)` gives `g(x)`
3. Otherwise `\frac{\frac{\partial A}{\partial X}}{\frac{\partial A}{
\partial Y}} = \gamma` is calculated. If
a] `\gamma` is a function of `x` alone
b] `\frac{\gamma\frac{\partial h}{\partial y} - \gamma'(x) - \frac{
\partial h}{\partial x}}{h + \gamma} = G` is a function of `x` alone.
then, `e^{\int G \,dx}` gives `f(x)` and `-\gamma*f(x)` gives `g(x)`
The second assumption holds good if `\frac{dy}{dx} = h(x, y)` is rewritten as
`\frac{dy}{dx} = \frac{1}{h(y, x)}` and the same properties of the first assumption
satisfies. After obtaining `f(x)` and `g(x)`, the coordinates are again
interchanged, to get `\xi` as `f(x^*)` and `\eta` as `g(y^*)`
References
==========
- E.S. Cheb-Terrab, A.D. Roche, Symmetries and First Order
ODE Patterns, pp. 10 - pp. 12
"""
h = match['h']
hx = match['hx']
hy = match['hy']
func = match['func']
hinv = match['hinv']
x = func.args[0]
y = match['y']
xi = Function('xi')(x, func)
eta = Function('eta')(x, func)
factor = cancel(h.diff(y)/h.diff(y, 2))
factorx = factor.diff(x)
factory = factor.diff(y)
if not factor.has(x) and not factor.has(y):
A = Wild('A', exclude=[y])
B = Wild('B', exclude=[y])
C = Wild('C', exclude=[x, y])
match = h.match(A + B*exp(y/C))
try:
tau = exp(-integrate(match[A]/match[C]), x)/match[B]
except NotImplementedError:
pass
else:
gx = match[A]*tau
return [{xi: tau, eta: gx}]
else:
gamma = cancel(factorx/factory)
if not gamma.has(y):
tauint = cancel((gamma*hy - gamma.diff(x) - hx)/(h + gamma))
if not tauint.has(y):
try:
tau = exp(integrate(tauint, x))
except NotImplementedError:
pass
else:
gx = -tau*gamma
return [{xi: tau, eta: gx}]
factor = cancel(hinv.diff(y)/hinv.diff(y, 2))
factorx = factor.diff(x)
factory = factor.diff(y)
if not factor.has(x) and not factor.has(y):
A = Wild('A', exclude=[y])
B = Wild('B', exclude=[y])
C = Wild('C', exclude=[x, y])
match = h.match(A + B*exp(y/C))
try:
tau = exp(-integrate(match[A]/match[C]), x)/match[B]
except NotImplementedError:
pass
else:
gx = match[A]*tau
return [{eta: tau.subs(x, func), xi: gx.subs(x, func)}]
else:
gamma = cancel(factorx/factory)
if not gamma.has(y):
tauint = cancel((gamma*hinv.diff(y) - gamma.diff(x) - hinv.diff(x))/(
hinv + gamma))
if not tauint.has(y):
try:
tau = exp(integrate(tauint, x))
except NotImplementedError:
pass
else:
gx = -tau*gamma
return [{eta: tau.subs(x, func), xi: gx.subs(x, func)}]
def lie_heuristic_abaco2_unique_unknown(match, comp=False):
r"""
This heuristic assumes the presence of unknown functions or known functions
with non-integer powers.
1. A list of all functions and non-integer powers containing x and y
2. Loop over each element `f` in the list, find `\frac{\frac{\partial f}{\partial x}}{
\frac{\partial f}{\partial x}} = R`
If it is separable in `x` and `y`, let `X` be the factors containing `x`. Then
a] Check if `\xi = X` and `\eta = -\frac{X}{R}` satisfy the PDE. If yes, then return
`\xi` and `\eta`
b] Check if `\xi = \frac{-R}{X}` and `\eta = -\frac{1}{X}` satisfy the PDE.
If yes, then return `\xi` and `\eta`
If not, then check if
a] :math:`\xi = -R,\eta = 1`
b] :math:`\xi = 1, \eta = -\frac{1}{R}`
are solutions.
References
==========
- E.S. Cheb-Terrab, A.D. Roche, Symmetries and First Order
ODE Patterns, pp. 10 - pp. 12
"""
h = match['h']
hx = match['hx']
hy = match['hy']
func = match['func']
x = func.args[0]
y = match['y']
xi = Function('xi')(x, func)
eta = Function('eta')(x, func)
funclist = []
for atom in h.atoms(Pow):
base, exp = atom.as_base_exp()
if base.has(x) and base.has(y):
if not exp.is_Integer:
funclist.append(atom)
for function in h.atoms(AppliedUndef):
syms = function.free_symbols
if x in syms and y in syms:
funclist.append(function)
for f in funclist:
frac = cancel(f.diff(y)/f.diff(x))
sep = separatevars(frac, dict=True, symbols=[x, y])
if sep and sep['coeff']:
xitry1 = sep[x]
etatry1 = -1/(sep[y]*sep['coeff'])
pde1 = etatry1.diff(y)*h - xitry1.diff(x)*h - xitry1*hx - etatry1*hy
if not simplify(pde1):
return [{xi: xitry1, eta: etatry1.subs(y, func)}]
xitry2 = 1/etatry1
etatry2 = 1/xitry1
pde2 = etatry2.diff(x) - (xitry2.diff(y))*h**2 - xitry2*hx - etatry2*hy
if not simplify(expand(pde2)):
return [{xi: xitry2.subs(y, func), eta: etatry2}]
else:
etatry = -1/frac
pde = etatry.diff(x) + etatry.diff(y)*h - hx - etatry*hy
if not simplify(pde):
return [{xi: S(1), eta: etatry.subs(y, func)}]
xitry = -frac
pde = -xitry.diff(x)*h -xitry.diff(y)*h**2 - xitry*hx -hy
if not simplify(expand(pde)):
return [{xi: xitry.subs(y, func), eta: S(1)}]
def lie_heuristic_abaco2_unique_general(match, comp=False):
r"""
This heuristic finds if infinitesimals of the form `\eta = f(x)`, `\xi = g(y)`
without making any assumptions on `h`.
The complete sequence of steps is given in the paper mentioned below.
References
==========
- E.S. Cheb-Terrab, A.D. Roche, Symmetries and First Order
ODE Patterns, pp. 10 - pp. 12
"""
hx = match['hx']
hy = match['hy']
func = match['func']
x = func.args[0]
y = match['y']
xi = Function('xi')(x, func)
eta = Function('eta')(x, func)
A = hx.diff(y)
B = hy.diff(y) + hy**2
C = hx.diff(x) - hx**2
if not (A and B and C):
return
Ax = A.diff(x)
Ay = A.diff(y)
Axy = Ax.diff(y)
Axx = Ax.diff(x)
Ayy = Ay.diff(y)
D = simplify(2*Axy + hx*Ay - Ax*hy + (hx*hy + 2*A)*A)*A - 3*Ax*Ay
if not D:
E1 = simplify(3*Ax**2 + ((hx**2 + 2*C)*A - 2*Axx)*A)
if E1:
E2 = simplify((2*Ayy + (2*B - hy**2)*A)*A - 3*Ay**2)
if not E2:
E3 = simplify(
E1*((28*Ax + 4*hx*A)*A**3 - E1*(hy*A + Ay)) - E1.diff(x)*8*A**4)
if not E3:
etaval = cancel((4*A**3*(Ax - hx*A) + E1*(hy*A - Ay))/(S(2)*A*E1))
if x not in etaval:
try:
etaval = exp(integrate(etaval, y))
except NotImplementedError:
pass
else:
xival = -4*A**3*etaval/E1
if y not in xival:
return [{xi: xival, eta: etaval.subs(y, func)}]
else:
E1 = simplify((2*Ayy + (2*B - hy**2)*A)*A - 3*Ay**2)
if E1:
E2 = simplify(
4*A**3*D - D**2 + E1*((2*Axx - (hx**2 + 2*C)*A)*A - 3*Ax**2))
if not E2:
E3 = simplify(
-(A*D)*E1.diff(y) + ((E1.diff(x) - hy*D)*A + 3*Ay*D +
(A*hx - 3*Ax)*E1)*E1)
if not E3:
etaval = cancel(((A*hx - Ax)*E1 - (Ay + A*hy)*D)/(S(2)*A*D))
if x not in etaval:
try:
etaval = exp(integrate(etaval, y))
except NotImplementedError:
pass
else:
xival = -E1*etaval/D
if y not in xival:
return [{xi: xival, eta: etaval.subs(y, func)}]
def lie_heuristic_linear(match, comp=False):
r"""
This heuristic assumes
1. `\xi = ax + by + c` and
2. `\eta = fx + gy + h`
After substituting the following assumptions in the determining PDE, it
reduces to
.. math:: f + (g - a)h - bh^{2} - (ax + by + c)\frac{\partial h}{\partial x}
- (fx + gy + c)\frac{\partial h}{\partial y}
Solving the reduced PDE obtained, using the method of characteristics, becomes
impractical. The method followed is grouping similar terms and solving the system
of linear equations obtained. The difference between the bivariate heuristic is that
`h` need not be a rational function in this case.
References
==========
- E.S. Cheb-Terrab, A.D. Roche, Symmetries and First Order
ODE Patterns, pp. 10 - pp. 12
"""
h = match['h']
hx = match['hx']
hy = match['hy']
func = match['func']
x = func.args[0]
y = match['y']
xi = Function('xi')(x, func)
eta = Function('eta')(x, func)
coeffdict = {}
symbols = numbered_symbols("c", cls=Dummy)
symlist = [next(symbols) for _ in islice(symbols, 6)]
C0, C1, C2, C3, C4, C5 = symlist
pde = C3 + (C4 - C0)*h - (C0*x + C1*y + C2)*hx - (C3*x + C4*y + C5)*hy - C1*h**2
pde, denom = pde.as_numer_denom()
pde = powsimp(expand(pde))
if pde.is_Add:
terms = pde.args
for term in terms:
if term.is_Mul:
rem = Mul(*[m for m in term.args if not m.has(x, y)])
xypart = term/rem
if xypart not in coeffdict:
coeffdict[xypart] = rem
else:
coeffdict[xypart] += rem
else:
if term not in coeffdict:
coeffdict[term] = S(1)
else:
coeffdict[term] += S(1)
sollist = coeffdict.values()
soldict = solve(sollist, symlist)
if soldict:
if isinstance(soldict, list):
soldict = soldict[0]
subval = soldict.values()
if any(t for t in subval):
onedict = dict(zip(symlist, [1]*6))
xival = C0*x + C1*func + C2
etaval = C3*x + C4*func + C5
xival = xival.subs(soldict)
etaval = etaval.subs(soldict)
xival = xival.subs(onedict)
etaval = etaval.subs(onedict)
return [{xi: xival, eta: etaval}]
def sysode_linear_2eq_order1(match_):
x = match_['func'][0].func
y = match_['func'][1].func
func = match_['func']
fc = match_['func_coeff']
eq = match_['eq']
r = dict()
t = list(list(eq[0].atoms(Derivative))[0].atoms(Symbol))[0]
for i in range(2):
eqs = 0
for terms in Add.make_args(eq[i]):
eqs += terms/fc[i,func[i],1]
eq[i] = eqs
# for equations Eq(a1*diff(x(t),t), a*x(t) + b*y(t) + k1)
# and Eq(a2*diff(x(t),t), c*x(t) + d*y(t) + k2)
r['a'] = -fc[0,x(t),0]/fc[0,x(t),1]
r['c'] = -fc[1,x(t),0]/fc[1,y(t),1]
r['b'] = -fc[0,y(t),0]/fc[0,x(t),1]
r['d'] = -fc[1,y(t),0]/fc[1,y(t),1]
forcing = [S(0),S(0)]
for i in range(2):
for j in Add.make_args(eq[i]):
if not j.has(x(t), y(t)):
forcing[i] += j
if not (forcing[0].has(t) or forcing[1].has(t)):
r['k1'] = forcing[0]
r['k2'] = forcing[1]
else:
raise NotImplementedError("Only homogeneous problems are supported" +
" (and constant inhomogeneity)")
if match_['type_of_equation'] == 'type1':
sol = _linear_2eq_order1_type1(x, y, t, r, eq)
if match_['type_of_equation'] == 'type2':
gsol = _linear_2eq_order1_type1(x, y, t, r, eq)
psol = _linear_2eq_order1_type2(x, y, t, r, eq)
sol = [Eq(x(t), gsol[0].rhs+psol[0]), Eq(y(t), gsol[1].rhs+psol[1])]
if match_['type_of_equation'] == 'type3':
sol = _linear_2eq_order1_type3(x, y, t, r, eq)
if match_['type_of_equation'] == 'type4':
sol = _linear_2eq_order1_type4(x, y, t, r, eq)
if match_['type_of_equation'] == 'type5':
sol = _linear_2eq_order1_type5(x, y, t, r, eq)
if match_['type_of_equation'] == 'type6':
sol = _linear_2eq_order1_type6(x, y, t, r, eq)
if match_['type_of_equation'] == 'type7':
sol = _linear_2eq_order1_type7(x, y, t, r, eq)
return sol
def _linear_2eq_order1_type1(x, y, t, r, eq):
r"""
It is classified under system of two linear homogeneous first-order constant-coefficient
ordinary differential equations.
The equations which come under this type are
.. math:: x' = ax + by,
.. math:: y' = cx + dy
The characteristics equation is written as
.. math:: \lambda^{2} + (a+d) \lambda + ad - bc = 0
and its discriminant is `D = (a-d)^{2} + 4bc`. There are several cases
1. Case when `ad - bc \neq 0`. The origin of coordinates, `x = y = 0`,
is the only stationary point; it is
- a node if `D = 0`
- a node if `D > 0` and `ad - bc > 0`
- a saddle if `D > 0` and `ad - bc < 0`
- a focus if `D < 0` and `a + d \neq 0`
- a centre if `D < 0` and `a + d \neq 0`.
1.1. If `D > 0`. The characteristic equation has two distinct real roots
`\lambda_1` and `\lambda_ 2` . The general solution of the system in question is expressed as
.. math:: x = C_1 b e^{\lambda_1 t} + C_2 b e^{\lambda_2 t}
.. math:: y = C_1 (\lambda_1 - a) e^{\lambda_1 t} + C_2 (\lambda_2 - a) e^{\lambda_2 t}
where `C_1` and `C_2` being arbitrary constants
1.2. If `D < 0`. The characteristics equation has two conjugate
roots, `\lambda_1 = \sigma + i \beta` and `\lambda_2 = \sigma - i \beta`.
The general solution of the system is given by
.. math:: x = b e^{\sigma t} (C_1 \sin(\beta t) + C_2 \cos(\beta t))
.. math:: y = e^{\sigma t} ([(\sigma - a) C_1 - \beta C_2] \sin(\beta t) + [\beta C_1 + (\sigma - a) C_2 \cos(\beta t)])
1.3. If `D = 0` and `a \neq d`. The characteristic equation has
two equal roots, `\lambda_1 = \lambda_2`. The general solution of the system is written as
.. math:: x = 2b (C_1 + \frac{C_2}{a-d} + C_2 t) e^{\frac{a+d}{2} t}
.. math:: y = [(d - a) C_1 + C_2 + (d - a) C_2 t] e^{\frac{a+d}{2} t}
1.4. If `D = 0` and `a = d \neq 0` and `b = 0`
.. math:: x = C_1 e^{a t} , y = (c C_1 t + C_2) e^{a t}
1.5. If `D = 0` and `a = d \neq 0` and `c = 0`
.. math:: x = (b C_1 t + C_2) e^{a t} , y = C_1 e^{a t}
2. Case when `ad - bc = 0` and `a^{2} + b^{2} > 0`. The whole straight
line `ax + by = 0` consists of singular points. The original system of differential
equations can be rewritten as
.. math:: x' = ax + by , y' = k (ax + by)
2.1 If `a + bk \neq 0`, solution will be
.. math:: x = b C_1 + C_2 e^{(a + bk) t} , y = -a C_1 + k C_2 e^{(a + bk) t}
2.2 If `a + bk = 0`, solution will be
.. math:: x = C_1 (bk t - 1) + b C_2 t , y = k^{2} b C_1 t + (b k^{2} t + 1) C_2
"""
C1, C2 = get_numbered_constants(eq, num=2)
a, b, c, d = r['a'], r['b'], r['c'], r['d']
real_coeff = all(v.is_real for v in (a, b, c, d))
D = (a - d)**2 + 4*b*c
l1 = (a + d + sqrt(D))/2
l2 = (a + d - sqrt(D))/2
equal_roots = Eq(D, 0).expand()
gsol1, gsol2 = [], []
# Solutions have exponential form if either D > 0 with real coefficients
# or D != 0 with complex coefficients. Eigenvalues are distinct.
# For each eigenvalue lam, pick an eigenvector, making sure we don't get (0, 0)
# The candidates are (b, lam-a) and (lam-d, c).
exponential_form = D > 0 if real_coeff else Not(equal_roots)
bad_ab_vector1 = And(Eq(b, 0), Eq(l1, a))
bad_ab_vector2 = And(Eq(b, 0), Eq(l2, a))
vector1 = Matrix((Piecewise((l1 - d, bad_ab_vector1), (b, True)),
Piecewise((c, bad_ab_vector1), (l1 - a, True))))
vector2 = Matrix((Piecewise((l2 - d, bad_ab_vector2), (b, True)),
Piecewise((c, bad_ab_vector2), (l2 - a, True))))
sol_vector = C1*exp(l1*t)*vector1 + C2*exp(l2*t)*vector2
gsol1.append((sol_vector[0], exponential_form))
gsol2.append((sol_vector[1], exponential_form))
# Solutions have trigonometric form for real coefficients with D < 0
# Both b and c are nonzero in this case, so (b, lam-a) is an eigenvector
# It splits into real/imag parts as (b, sigma-a) and (0, beta). Then
# multiply it by C1(cos(beta*t) + I*C2*sin(beta*t)) and separate real/imag
trigonometric_form = D < 0 if real_coeff else False
sigma = re(l1)
if im(l1).is_positive:
beta = im(l1)
else:
beta = im(l2)
vector1 = Matrix((b, sigma - a))
vector2 = Matrix((0, beta))
sol_vector = exp(sigma*t) * (C1*(cos(beta*t)*vector1 - sin(beta*t)*vector2) + \
C2*(sin(beta*t)*vector1 + cos(beta*t)*vector2))
gsol1.append((sol_vector[0], trigonometric_form))
gsol2.append((sol_vector[1], trigonometric_form))
# Final case is D == 0, a single eigenvalue. If the eigenspace is 2-dimensional
# then we have a scalar matrix, deal with this case first.
scalar_matrix = And(Eq(a, d), Eq(b, 0), Eq(c, 0))
vector1 = Matrix((S.One, S.Zero))
vector2 = Matrix((S.Zero, S.One))
sol_vector = exp(l1*t) * (C1*vector1 + C2*vector2)
gsol1.append((sol_vector[0], scalar_matrix))
gsol2.append((sol_vector[1], scalar_matrix))
# Have one eigenvector. Get a generalized eigenvector from (A-lam)*vector2 = vector1
vector1 = Matrix((Piecewise((l1 - d, bad_ab_vector1), (b, True)),
Piecewise((c, bad_ab_vector1), (l1 - a, True))))
vector2 = Matrix((Piecewise((S.One, bad_ab_vector1), (S.Zero, Eq(a, l1)),
(b/(a - l1), True)),
Piecewise((S.Zero, bad_ab_vector1), (S.One, Eq(a, l1)),
(S.Zero, True))))
sol_vector = exp(l1*t) * (C1*vector1 + C2*(vector2 + t*vector1))
gsol1.append((sol_vector[0], equal_roots))
gsol2.append((sol_vector[1], equal_roots))
return [Eq(x(t), Piecewise(*gsol1)), Eq(y(t), Piecewise(*gsol2))]
def _linear_2eq_order1_type2(x, y, t, r, eq):
r"""
The equations of this type are
.. math:: x' = ax + by + k1 , y' = cx + dy + k2
The general solution of this system is given by sum of its particular solution and the
general solution of the corresponding homogeneous system is obtained from type1.
1. When `ad - bc \neq 0`. The particular solution will be
`x = x_0` and `y = y_0` where `x_0` and `y_0` are determined by solving linear system of equations
.. math:: a x_0 + b y_0 + k1 = 0 , c x_0 + d y_0 + k2 = 0
2. When `ad - bc = 0` and `a^{2} + b^{2} > 0`. In this case, the system of equation becomes
.. math:: x' = ax + by + k_1 , y' = k (ax + by) + k_2
2.1 If `\sigma = a + bk \neq 0`, particular solution is given by
.. math:: x = b \sigma^{-1} (c_1 k - c_2) t - \sigma^{-2} (a c_1 + b c_2)
.. math:: y = kx + (c_2 - c_1 k) t
2.2 If `\sigma = a + bk = 0`, particular solution is given by
.. math:: x = \frac{1}{2} b (c_2 - c_1 k) t^{2} + c_1 t
.. math:: y = kx + (c_2 - c_1 k) t
"""
r['k1'] = -r['k1']; r['k2'] = -r['k2']
if (r['a']*r['d'] - r['b']*r['c']) != 0:
x0, y0 = symbols('x0, y0', cls=Dummy)
sol = solve((r['a']*x0+r['b']*y0+r['k1'], r['c']*x0+r['d']*y0+r['k2']), x0, y0)
psol = [sol[x0], sol[y0]]
elif (r['a']*r['d'] - r['b']*r['c']) == 0 and (r['a']**2+r['b']**2) > 0:
k = r['c']/r['a']
sigma = r['a'] + r['b']*k
if sigma != 0:
sol1 = r['b']*sigma**-1*(r['k1']*k-r['k2'])*t - sigma**-2*(r['a']*r['k1']+r['b']*r['k2'])
sol2 = k*sol1 + (r['k2']-r['k1']*k)*t
else:
# FIXME: a previous typo fix shows this is not covered by tests
sol1 = r['b']*(r['k2']-r['k1']*k)*t**2 + r['k1']*t
sol2 = k*sol1 + (r['k2']-r['k1']*k)*t
psol = [sol1, sol2]
return psol
def _linear_2eq_order1_type3(x, y, t, r, eq):
r"""
The equations of this type of ode are
.. math:: x' = f(t) x + g(t) y
.. math:: y' = g(t) x + f(t) y
The solution of such equations is given by
.. math:: x = e^{F} (C_1 e^{G} + C_2 e^{-G}) , y = e^{F} (C_1 e^{G} - C_2 e^{-G})
where `C_1` and `C_2` are arbitrary constants, and
.. math:: F = \int f(t) \,dt , G = \int g(t) \,dt
"""
C1, C2, C3, C4 = get_numbered_constants(eq, num=4)
F = Integral(r['a'], t)
G = Integral(r['b'], t)
sol1 = exp(F)*(C1*exp(G) + C2*exp(-G))
sol2 = exp(F)*(C1*exp(G) - C2*exp(-G))
return [Eq(x(t), sol1), Eq(y(t), sol2)]
def _linear_2eq_order1_type4(x, y, t, r, eq):
r"""
The equations of this type of ode are .
.. math:: x' = f(t) x + g(t) y
.. math:: y' = -g(t) x + f(t) y
The solution is given by
.. math:: x = F (C_1 \cos(G) + C_2 \sin(G)), y = F (-C_1 \sin(G) + C_2 \cos(G))
where `C_1` and `C_2` are arbitrary constants, and
.. math:: F = \int f(t) \,dt , G = \int g(t) \,dt
"""
C1, C2, C3, C4 = get_numbered_constants(eq, num=4)
if r['b'] == -r['c']:
F = exp(Integral(r['a'], t))
G = Integral(r['b'], t)
sol1 = F*(C1*cos(G) + C2*sin(G))
sol2 = F*(-C1*sin(G) + C2*cos(G))
elif r['d'] == -r['a']:
F = exp(Integral(r['c'], t))
G = Integral(r['d'], t)
sol1 = F*(-C1*sin(G) + C2*cos(G))
sol2 = F*(C1*cos(G) + C2*sin(G))
return [Eq(x(t), sol1), Eq(y(t), sol2)]
def _linear_2eq_order1_type5(x, y, t, r, eq):
r"""
The equations of this type of ode are .
.. math:: x' = f(t) x + g(t) y
.. math:: y' = a g(t) x + [f(t) + b g(t)] y
The transformation of
.. math:: x = e^{\int f(t) \,dt} u , y = e^{\int f(t) \,dt} v , T = \int g(t) \,dt
leads to a system of constant coefficient linear differential equations
.. math:: u'(T) = v , v'(T) = au + bv
"""
u, v = symbols('u, v', cls=Function)
T = Symbol('T')
if not cancel(r['c']/r['b']).has(t):
p = cancel(r['c']/r['b'])
q = cancel((r['d']-r['a'])/r['b'])
eq = (Eq(diff(u(T),T), v(T)), Eq(diff(v(T),T), p*u(T)+q*v(T)))
sol = dsolve(eq)
sol1 = exp(Integral(r['a'], t))*sol[0].rhs.subs(T, Integral(r['b'], t))
sol2 = exp(Integral(r['a'], t))*sol[1].rhs.subs(T, Integral(r['b'], t))
if not cancel(r['a']/r['d']).has(t):
p = cancel(r['a']/r['d'])
q = cancel((r['b']-r['c'])/r['d'])
sol = dsolve(Eq(diff(u(T),T), v(T)), Eq(diff(v(T),T), p*u(T)+q*v(T)))
sol1 = exp(Integral(r['c'], t))*sol[1].rhs.subs(T, Integral(r['d'], t))
sol2 = exp(Integral(r['c'], t))*sol[0].rhs.subs(T, Integral(r['d'], t))
return [Eq(x(t), sol1), Eq(y(t), sol2)]
def _linear_2eq_order1_type6(x, y, t, r, eq):
r"""
The equations of this type of ode are .
.. math:: x' = f(t) x + g(t) y
.. math:: y' = a [f(t) + a h(t)] x + a [g(t) - h(t)] y
This is solved by first multiplying the first equation by `-a` and adding
it to the second equation to obtain
.. math:: y' - a x' = -a h(t) (y - a x)
Setting `U = y - ax` and integrating the equation we arrive at
.. math:: y - ax = C_1 e^{-a \int h(t) \,dt}
and on substituting the value of y in first equation give rise to first order ODEs. After solving for
`x`, we can obtain `y` by substituting the value of `x` in second equation.
"""
C1, C2, C3, C4 = get_numbered_constants(eq, num=4)
p = 0
q = 0
p1 = cancel(r['c']/cancel(r['c']/r['d']).as_numer_denom()[0])
p2 = cancel(r['a']/cancel(r['a']/r['b']).as_numer_denom()[0])
for n, i in enumerate([p1, p2]):
for j in Mul.make_args(collect_const(i)):
if not j.has(t):
q = j
if q!=0 and n==0:
if ((r['c']/j - r['a'])/(r['b'] - r['d']/j)) == j:
p = 1
s = j
break
if q!=0 and n==1:
if ((r['a']/j - r['c'])/(r['d'] - r['b']/j)) == j:
p = 2
s = j
break
if p == 1:
equ = diff(x(t),t) - r['a']*x(t) - r['b']*(s*x(t) + C1*exp(-s*Integral(r['b'] - r['d']/s, t)))
hint1 = classify_ode(equ)[1]
sol1 = dsolve(equ, hint=hint1+'_Integral').rhs
sol2 = s*sol1 + C1*exp(-s*Integral(r['b'] - r['d']/s, t))
elif p ==2:
equ = diff(y(t),t) - r['c']*y(t) - r['d']*s*y(t) + C1*exp(-s*Integral(r['d'] - r['b']/s, t))
hint1 = classify_ode(equ)[1]
sol2 = dsolve(equ, hint=hint1+'_Integral').rhs
sol1 = s*sol2 + C1*exp(-s*Integral(r['d'] - r['b']/s, t))
return [Eq(x(t), sol1), Eq(y(t), sol2)]
def _linear_2eq_order1_type7(x, y, t, r, eq):
r"""
The equations of this type of ode are .
.. math:: x' = f(t) x + g(t) y
.. math:: y' = h(t) x + p(t) y
Differentiating the first equation and substituting the value of `y`
from second equation will give a second-order linear equation
.. math:: g x'' - (fg + gp + g') x' + (fgp - g^{2} h + f g' - f' g) x = 0
This above equation can be easily integrated if following conditions are satisfied.
1. `fgp - g^{2} h + f g' - f' g = 0`
2. `fgp - g^{2} h + f g' - f' g = ag, fg + gp + g' = bg`
If first condition is satisfied then it is solved by current dsolve solver and in second case it becomes
a constant coefficient differential equation which is also solved by current solver.
Otherwise if the above condition fails then,
a particular solution is assumed as `x = x_0(t)` and `y = y_0(t)`
Then the general solution is expressed as
.. math:: x = C_1 x_0(t) + C_2 x_0(t) \int \frac{g(t) F(t) P(t)}{x_0^{2}(t)} \,dt
.. math:: y = C_1 y_0(t) + C_2 [\frac{F(t) P(t)}{x_0(t)} + y_0(t) \int \frac{g(t) F(t) P(t)}{x_0^{2}(t)} \,dt]
where C1 and C2 are arbitrary constants and
.. math:: F(t) = e^{\int f(t) \,dt} , P(t) = e^{\int p(t) \,dt}
"""
C1, C2, C3, C4 = get_numbered_constants(eq, num=4)
e1 = r['a']*r['b']*r['c'] - r['b']**2*r['c'] + r['a']*diff(r['b'],t) - diff(r['a'],t)*r['b']
e2 = r['a']*r['c']*r['d'] - r['b']*r['c']**2 + diff(r['c'],t)*r['d'] - r['c']*diff(r['d'],t)
m1 = r['a']*r['b'] + r['b']*r['d'] + diff(r['b'],t)
m2 = r['a']*r['c'] + r['c']*r['d'] + diff(r['c'],t)
if e1 == 0:
sol1 = dsolve(r['b']*diff(x(t),t,t) - m1*diff(x(t),t)).rhs
sol2 = dsolve(diff(y(t),t) - r['c']*sol1 - r['d']*y(t)).rhs
elif e2 == 0:
sol2 = dsolve(r['c']*diff(y(t),t,t) - m2*diff(y(t),t)).rhs
sol1 = dsolve(diff(x(t),t) - r['a']*x(t) - r['b']*sol2).rhs
elif not (e1/r['b']).has(t) and not (m1/r['b']).has(t):
sol1 = dsolve(diff(x(t),t,t) - (m1/r['b'])*diff(x(t),t) - (e1/r['b'])*x(t)).rhs
sol2 = dsolve(diff(y(t),t) - r['c']*sol1 - r['d']*y(t)).rhs
elif not (e2/r['c']).has(t) and not (m2/r['c']).has(t):
sol2 = dsolve(diff(y(t),t,t) - (m2/r['c'])*diff(y(t),t) - (e2/r['c'])*y(t)).rhs
sol1 = dsolve(diff(x(t),t) - r['a']*x(t) - r['b']*sol2).rhs
else:
x0 = Function('x0')(t) # x0 and y0 being particular solutions
y0 = Function('y0')(t)
F = exp(Integral(r['a'],t))
P = exp(Integral(r['d'],t))
sol1 = C1*x0 + C2*x0*Integral(r['b']*F*P/x0**2, t)
sol2 = C1*y0 + C2*(F*P/x0 + y0*Integral(r['b']*F*P/x0**2, t))
return [Eq(x(t), sol1), Eq(y(t), sol2)]
def sysode_linear_2eq_order2(match_):
x = match_['func'][0].func
y = match_['func'][1].func
func = match_['func']
fc = match_['func_coeff']
eq = match_['eq']
r = dict()
t = list(list(eq[0].atoms(Derivative))[0].atoms(Symbol))[0]
for i in range(2):
eqs = []
for terms in Add.make_args(eq[i]):
eqs.append(terms/fc[i,func[i],2])
eq[i] = Add(*eqs)
# for equations Eq(diff(x(t),t,t), a1*diff(x(t),t)+b1*diff(y(t),t)+c1*x(t)+d1*y(t)+e1)
# and Eq(a2*diff(y(t),t,t), a2*diff(x(t),t)+b2*diff(y(t),t)+c2*x(t)+d2*y(t)+e2)
r['a1'] = -fc[0,x(t),1]/fc[0,x(t),2] ; r['a2'] = -fc[1,x(t),1]/fc[1,y(t),2]
r['b1'] = -fc[0,y(t),1]/fc[0,x(t),2] ; r['b2'] = -fc[1,y(t),1]/fc[1,y(t),2]
r['c1'] = -fc[0,x(t),0]/fc[0,x(t),2] ; r['c2'] = -fc[1,x(t),0]/fc[1,y(t),2]
r['d1'] = -fc[0,y(t),0]/fc[0,x(t),2] ; r['d2'] = -fc[1,y(t),0]/fc[1,y(t),2]
const = [S(0), S(0)]
for i in range(2):
for j in Add.make_args(eq[i]):
if not (j.has(x(t)) or j.has(y(t))):
const[i] += j
r['e1'] = -const[0]
r['e2'] = -const[1]
if match_['type_of_equation'] == 'type1':
sol = _linear_2eq_order2_type1(x, y, t, r, eq)
elif match_['type_of_equation'] == 'type2':
gsol = _linear_2eq_order2_type1(x, y, t, r, eq)
psol = _linear_2eq_order2_type2(x, y, t, r, eq)
sol = [Eq(x(t), gsol[0].rhs+psol[0]), Eq(y(t), gsol[1].rhs+psol[1])]
elif match_['type_of_equation'] == 'type3':
sol = _linear_2eq_order2_type3(x, y, t, r, eq)
elif match_['type_of_equation'] == 'type4':
sol = _linear_2eq_order2_type4(x, y, t, r, eq)
elif match_['type_of_equation'] == 'type5':
sol = _linear_2eq_order2_type5(x, y, t, r, eq)
elif match_['type_of_equation'] == 'type6':
sol = _linear_2eq_order2_type6(x, y, t, r, eq)
elif match_['type_of_equation'] == 'type7':
sol = _linear_2eq_order2_type7(x, y, t, r, eq)
elif match_['type_of_equation'] == 'type8':
sol = _linear_2eq_order2_type8(x, y, t, r, eq)
elif match_['type_of_equation'] == 'type9':
sol = _linear_2eq_order2_type9(x, y, t, r, eq)
elif match_['type_of_equation'] == 'type10':
sol = _linear_2eq_order2_type10(x, y, t, r, eq)
elif match_['type_of_equation'] == 'type11':
sol = _linear_2eq_order2_type11(x, y, t, r, eq)
return sol
def _linear_2eq_order2_type1(x, y, t, r, eq):
r"""
System of two constant-coefficient second-order linear homogeneous differential equations
.. math:: x'' = ax + by
.. math:: y'' = cx + dy
The characteristic equation for above equations
.. math:: \lambda^4 - (a + d) \lambda^2 + ad - bc = 0
whose discriminant is `D = (a - d)^2 + 4bc \neq 0`
1. When `ad - bc \neq 0`
1.1. If `D \neq 0`. The characteristic equation has four distinct roots, `\lambda_1, \lambda_2, \lambda_3, \lambda_4`.
The general solution of the system is
.. math:: x = C_1 b e^{\lambda_1 t} + C_2 b e^{\lambda_2 t} + C_3 b e^{\lambda_3 t} + C_4 b e^{\lambda_4 t}
.. math:: y = C_1 (\lambda_1^{2} - a) e^{\lambda_1 t} + C_2 (\lambda_2^{2} - a) e^{\lambda_2 t} + C_3 (\lambda_3^{2} - a) e^{\lambda_3 t} + C_4 (\lambda_4^{2} - a) e^{\lambda_4 t}
where `C_1,..., C_4` are arbitrary constants.
1.2. If `D = 0` and `a \neq d`:
.. math:: x = 2 C_1 (bt + \frac{2bk}{a - d}) e^{\frac{kt}{2}} + 2 C_2 (bt + \frac{2bk}{a - d}) e^{\frac{-kt}{2}} + 2b C_3 t e^{\frac{kt}{2}} + 2b C_4 t e^{\frac{-kt}{2}}
.. math:: y = C_1 (d - a) t e^{\frac{kt}{2}} + C_2 (d - a) t e^{\frac{-kt}{2}} + C_3 [(d - a) t + 2k] e^{\frac{kt}{2}} + C_4 [(d - a) t - 2k] e^{\frac{-kt}{2}}
where `C_1,..., C_4` are arbitrary constants and `k = \sqrt{2 (a + d)}`
1.3. If `D = 0` and `a = d \neq 0` and `b = 0`:
.. math:: x = 2 \sqrt{a} C_1 e^{\sqrt{a} t} + 2 \sqrt{a} C_2 e^{-\sqrt{a} t}
.. math:: y = c C_1 t e^{\sqrt{a} t} - c C_2 t e^{-\sqrt{a} t} + C_3 e^{\sqrt{a} t} + C_4 e^{-\sqrt{a} t}
1.4. If `D = 0` and `a = d \neq 0` and `c = 0`:
.. math:: x = b C_1 t e^{\sqrt{a} t} - b C_2 t e^{-\sqrt{a} t} + C_3 e^{\sqrt{a} t} + C_4 e^{-\sqrt{a} t}
.. math:: y = 2 \sqrt{a} C_1 e^{\sqrt{a} t} + 2 \sqrt{a} C_2 e^{-\sqrt{a} t}
2. When `ad - bc = 0` and `a^2 + b^2 > 0`. Then the original system becomes
.. math:: x'' = ax + by
.. math:: y'' = k (ax + by)
2.1. If `a + bk \neq 0`:
.. math:: x = C_1 e^{t \sqrt{a + bk}} + C_2 e^{-t \sqrt{a + bk}} + C_3 bt + C_4 b
.. math:: y = C_1 k e^{t \sqrt{a + bk}} + C_2 k e^{-t \sqrt{a + bk}} - C_3 at - C_4 a
2.2. If `a + bk = 0`:
.. math:: x = C_1 b t^3 + C_2 b t^2 + C_3 t + C_4
.. math:: y = kx + 6 C_1 t + 2 C_2
"""
r['a'] = r['c1']
r['b'] = r['d1']
r['c'] = r['c2']
r['d'] = r['d2']
l = Symbol('l')
C1, C2, C3, C4 = get_numbered_constants(eq, num=4)
chara_eq = l**4 - (r['a']+r['d'])*l**2 + r['a']*r['d'] - r['b']*r['c']
l1 = rootof(chara_eq, 0)
l2 = rootof(chara_eq, 1)
l3 = rootof(chara_eq, 2)
l4 = rootof(chara_eq, 3)
D = (r['a'] - r['d'])**2 + 4*r['b']*r['c']
if (r['a']*r['d'] - r['b']*r['c']) != 0:
if D != 0:
gsol1 = C1*r['b']*exp(l1*t) + C2*r['b']*exp(l2*t) + C3*r['b']*exp(l3*t) \
+ C4*r['b']*exp(l4*t)
gsol2 = C1*(l1**2-r['a'])*exp(l1*t) + C2*(l2**2-r['a'])*exp(l2*t) + \
C3*(l3**2-r['a'])*exp(l3*t) + C4*(l4**2-r['a'])*exp(l4*t)
else:
if r['a'] != r['d']:
k = sqrt(2*(r['a']+r['d']))
mid = r['b']*t+2*r['b']*k/(r['a']-r['d'])
gsol1 = 2*C1*mid*exp(k*t/2) + 2*C2*mid*exp(-k*t/2) + \
2*r['b']*C3*t*exp(k*t/2) + 2*r['b']*C4*t*exp(-k*t/2)
gsol2 = C1*(r['d']-r['a'])*t*exp(k*t/2) + C2*(r['d']-r['a'])*t*exp(-k*t/2) + \
C3*((r['d']-r['a'])*t+2*k)*exp(k*t/2) + C4*((r['d']-r['a'])*t-2*k)*exp(-k*t/2)
elif r['a'] == r['d'] != 0 and r['b'] == 0:
sa = sqrt(r['a'])
gsol1 = 2*sa*C1*exp(sa*t) + 2*sa*C2*exp(-sa*t)
gsol2 = r['c']*C1*t*exp(sa*t)-r['c']*C2*t*exp(-sa*t)+C3*exp(sa*t)+C4*exp(-sa*t)
elif r['a'] == r['d'] != 0 and r['c'] == 0:
sa = sqrt(r['a'])
gsol1 = r['b']*C1*t*exp(sa*t)-r['b']*C2*t*exp(-sa*t)+C3*exp(sa*t)+C4*exp(-sa*t)
gsol2 = 2*sa*C1*exp(sa*t) + 2*sa*C2*exp(-sa*t)
elif (r['a']*r['d'] - r['b']*r['c']) == 0 and (r['a']**2 + r['b']**2) > 0:
k = r['c']/r['a']
if r['a'] + r['b']*k != 0:
mid = sqrt(r['a'] + r['b']*k)
gsol1 = C1*exp(mid*t) + C2*exp(-mid*t) + C3*r['b']*t + C4*r['b']
gsol2 = C1*k*exp(mid*t) + C2*k*exp(-mid*t) - C3*r['a']*t - C4*r['a']
else:
gsol1 = C1*r['b']*t**3 + C2*r['b']*t**2 + C3*t + C4
gsol2 = k*gsol1 + 6*C1*t + 2*C2
return [Eq(x(t), gsol1), Eq(y(t), gsol2)]
def _linear_2eq_order2_type2(x, y, t, r, eq):
r"""
The equations in this type are
.. math:: x'' = a_1 x + b_1 y + c_1
.. math:: y'' = a_2 x + b_2 y + c_2
The general solution of this system is given by the sum of its particular solution
and the general solution of the homogeneous system. The general solution is given
by the linear system of 2 equation of order 2 and type 1
1. If `a_1 b_2 - a_2 b_1 \neq 0`. A particular solution will be `x = x_0` and `y = y_0`
where the constants `x_0` and `y_0` are determined by solving the linear algebraic system
.. math:: a_1 x_0 + b_1 y_0 + c_1 = 0, a_2 x_0 + b_2 y_0 + c_2 = 0
2. If `a_1 b_2 - a_2 b_1 = 0` and `a_1^2 + b_1^2 > 0`. In this case, the system in question becomes
.. math:: x'' = ax + by + c_1, y'' = k (ax + by) + c_2
2.1. If `\sigma = a + bk \neq 0`, the particular solution will be
.. math:: x = \frac{1}{2} b \sigma^{-1} (c_1 k - c_2) t^2 - \sigma^{-2} (a c_1 + b c_2)
.. math:: y = kx + \frac{1}{2} (c_2 - c_1 k) t^2
2.2. If `\sigma = a + bk = 0`, the particular solution will be
.. math:: x = \frac{1}{24} b (c_2 - c_1 k) t^4 + \frac{1}{2} c_1 t^2
.. math:: y = kx + \frac{1}{2} (c_2 - c_1 k) t^2
"""
x0, y0 = symbols('x0, y0')
if r['c1']*r['d2'] - r['c2']*r['d1'] != 0:
sol = solve((r['c1']*x0+r['d1']*y0+r['e1'], r['c2']*x0+r['d2']*y0+r['e2']), x0, y0)
psol = [sol[x0], sol[y0]]
elif r['c1']*r['d2'] - r['c2']*r['d1'] == 0 and (r['c1']**2 + r['d1']**2) > 0:
k = r['c2']/r['c1']
sig = r['c1'] + r['d1']*k
if sig != 0:
psol1 = r['d1']*sig**-1*(r['e1']*k-r['e2'])*t**2/2 - \
sig**-2*(r['c1']*r['e1']+r['d1']*r['e2'])
psol2 = k*psol1 + (r['e2'] - r['e1']*k)*t**2/2
psol = [psol1, psol2]
else:
psol1 = r['d1']*(r['e2']-r['e1']*k)*t**4/24 + r['e1']*t**2/2
psol2 = k*psol1 + (r['e2']-r['e1']*k)*t**2/2
psol = [psol1, psol2]
return psol
def _linear_2eq_order2_type3(x, y, t, r, eq):
r"""
These type of equation is used for describing the horizontal motion of a pendulum
taking into account the Earth rotation.
The solution is given with `a^2 + 4b > 0`:
.. math:: x = C_1 \cos(\alpha t) + C_2 \sin(\alpha t) + C_3 \cos(\beta t) + C_4 \sin(\beta t)
.. math:: y = -C_1 \sin(\alpha t) + C_2 \cos(\alpha t) - C_3 \sin(\beta t) + C_4 \cos(\beta t)
where `C_1,...,C_4` and
.. math:: \alpha = \frac{1}{2} a + \frac{1}{2} \sqrt{a^2 + 4b}, \beta = \frac{1}{2} a - \frac{1}{2} \sqrt{a^2 + 4b}
"""
C1, C2, C3, C4 = get_numbered_constants(eq, num=4)
if r['b1']**2 - 4*r['c1'] > 0:
r['a'] = r['b1'] ; r['b'] = -r['c1']
alpha = r['a']/2 + sqrt(r['a']**2 + 4*r['b'])/2
beta = r['a']/2 - sqrt(r['a']**2 + 4*r['b'])/2
sol1 = C1*cos(alpha*t) + C2*sin(alpha*t) + C3*cos(beta*t) + C4*sin(beta*t)
sol2 = -C1*sin(alpha*t) + C2*cos(alpha*t) - C3*sin(beta*t) + C4*cos(beta*t)
return [Eq(x(t), sol1), Eq(y(t), sol2)]
def _linear_2eq_order2_type4(x, y, t, r, eq):
r"""
These equations are found in the theory of oscillations
.. math:: x'' + a_1 x' + b_1 y' + c_1 x + d_1 y = k_1 e^{i \omega t}
.. math:: y'' + a_2 x' + b_2 y' + c_2 x + d_2 y = k_2 e^{i \omega t}
The general solution of this linear nonhomogeneous system of constant-coefficient
differential equations is given by the sum of its particular solution and the
general solution of the corresponding homogeneous system (with `k_1 = k_2 = 0`)
1. A particular solution is obtained by the method of undetermined coefficients:
.. math:: x = A_* e^{i \omega t}, y = B_* e^{i \omega t}
On substituting these expressions into the original system of differential equations,
one arrive at a linear nonhomogeneous system of algebraic equations for the
coefficients `A` and `B`.
2. The general solution of the homogeneous system of differential equations is determined
by a linear combination of linearly independent particular solutions determined by
the method of undetermined coefficients in the form of exponentials:
.. math:: x = A e^{\lambda t}, y = B e^{\lambda t}
On substituting these expressions into the original system and collecting the
coefficients of the unknown `A` and `B`, one obtains
.. math:: (\lambda^{2} + a_1 \lambda + c_1) A + (b_1 \lambda + d_1) B = 0
.. math:: (a_2 \lambda + c_2) A + (\lambda^{2} + b_2 \lambda + d_2) B = 0
The determinant of this system must vanish for nontrivial solutions A, B to exist.
This requirement results in the following characteristic equation for `\lambda`
.. math:: (\lambda^2 + a_1 \lambda + c_1) (\lambda^2 + b_2 \lambda + d_2) - (b_1 \lambda + d_1) (a_2 \lambda + c_2) = 0
If all roots `k_1,...,k_4` of this equation are distinct, the general solution of the original
system of the differential equations has the form
.. math:: x = C_1 (b_1 \lambda_1 + d_1) e^{\lambda_1 t} - C_2 (b_1 \lambda_2 + d_1) e^{\lambda_2 t} - C_3 (b_1 \lambda_3 + d_1) e^{\lambda_3 t} - C_4 (b_1 \lambda_4 + d_1) e^{\lambda_4 t}
.. math:: y = C_1 (\lambda_1^{2} + a_1 \lambda_1 + c_1) e^{\lambda_1 t} + C_2 (\lambda_2^{2} + a_1 \lambda_2 + c_1) e^{\lambda_2 t} + C_3 (\lambda_3^{2} + a_1 \lambda_3 + c_1) e^{\lambda_3 t} + C_4 (\lambda_4^{2} + a_1 \lambda_4 + c_1) e^{\lambda_4 t}
"""
C1, C2, C3, C4 = get_numbered_constants(eq, num=4)
k = Symbol('k')
Ra, Ca, Rb, Cb = symbols('Ra, Ca, Rb, Cb')
a1 = r['a1'] ; a2 = r['a2']
b1 = r['b1'] ; b2 = r['b2']
c1 = r['c1'] ; c2 = r['c2']
d1 = r['d1'] ; d2 = r['d2']
k1 = r['e1'].expand().as_independent(t)[0]
k2 = r['e2'].expand().as_independent(t)[0]
ew1 = r['e1'].expand().as_independent(t)[1]
ew2 = powdenest(ew1).as_base_exp()[1]
ew3 = collect(ew2, t).coeff(t)
w = cancel(ew3/I)
# The particular solution is assumed to be (Ra+I*Ca)*exp(I*w*t) and
# (Rb+I*Cb)*exp(I*w*t) for x(t) and y(t) respectively
peq1 = (-w**2+c1)*Ra - a1*w*Ca + d1*Rb - b1*w*Cb - k1
peq2 = a1*w*Ra + (-w**2+c1)*Ca + b1*w*Rb + d1*Cb
peq3 = c2*Ra - a2*w*Ca + (-w**2+d2)*Rb - b2*w*Cb - k2
peq4 = a2*w*Ra + c2*Ca + b2*w*Rb + (-w**2+d2)*Cb
# FIXME: solve for what in what? Ra, Rb, etc I guess
# but then psol not used for anything?
psol = solve([peq1, peq2, peq3, peq4])
chareq = (k**2+a1*k+c1)*(k**2+b2*k+d2) - (b1*k+d1)*(a2*k+c2)
[k1, k2, k3, k4] = roots_quartic(Poly(chareq))
sol1 = -C1*(b1*k1+d1)*exp(k1*t) - C2*(b1*k2+d1)*exp(k2*t) - \
C3*(b1*k3+d1)*exp(k3*t) - C4*(b1*k4+d1)*exp(k4*t) + (Ra+I*Ca)*exp(I*w*t)
a1_ = (a1-1)
sol2 = C1*(k1**2+a1_*k1+c1)*exp(k1*t) + C2*(k2**2+a1_*k2+c1)*exp(k2*t) + \
C3*(k3**2+a1_*k3+c1)*exp(k3*t) + C4*(k4**2+a1_*k4+c1)*exp(k4*t) + (Rb+I*Cb)*exp(I*w*t)
return [Eq(x(t), sol1), Eq(y(t), sol2)]
def _linear_2eq_order2_type5(x, y, t, r, eq):
r"""
The equation which come under this category are
.. math:: x'' = a (t y' - y)
.. math:: y'' = b (t x' - x)
The transformation
.. math:: u = t x' - x, b = t y' - y
leads to the first-order system
.. math:: u' = atv, v' = btu
The general solution of this system is given by
If `ab > 0`:
.. math:: u = C_1 a e^{\frac{1}{2} \sqrt{ab} t^2} + C_2 a e^{-\frac{1}{2} \sqrt{ab} t^2}
.. math:: v = C_1 \sqrt{ab} e^{\frac{1}{2} \sqrt{ab} t^2} - C_2 \sqrt{ab} e^{-\frac{1}{2} \sqrt{ab} t^2}
If `ab < 0`:
.. math:: u = C_1 a \cos(\frac{1}{2} \sqrt{\left|ab\right|} t^2) + C_2 a \sin(-\frac{1}{2} \sqrt{\left|ab\right|} t^2)
.. math:: v = C_1 \sqrt{\left|ab\right|} \sin(\frac{1}{2} \sqrt{\left|ab\right|} t^2) + C_2 \sqrt{\left|ab\right|} \cos(-\frac{1}{2} \sqrt{\left|ab\right|} t^2)
where `C_1` and `C_2` are arbitrary constants. On substituting the value of `u` and `v`
in above equations and integrating the resulting expressions, the general solution will become
.. math:: x = C_3 t + t \int \frac{u}{t^2} \,dt, y = C_4 t + t \int \frac{u}{t^2} \,dt
where `C_3` and `C_4` are arbitrary constants.
"""
C1, C2, C3, C4 = get_numbered_constants(eq, num=4)
r['a'] = -r['d1'] ; r['b'] = -r['c2']
mul = sqrt(abs(r['a']*r['b']))
if r['a']*r['b'] > 0:
u = C1*r['a']*exp(mul*t**2/2) + C2*r['a']*exp(-mul*t**2/2)
v = C1*mul*exp(mul*t**2/2) - C2*mul*exp(-mul*t**2/2)
else:
u = C1*r['a']*cos(mul*t**2/2) + C2*r['a']*sin(mul*t**2/2)
v = -C1*mul*sin(mul*t**2/2) + C2*mul*cos(mul*t**2/2)
sol1 = C3*t + t*Integral(u/t**2, t)
sol2 = C4*t + t*Integral(v/t**2, t)
return [Eq(x(t), sol1), Eq(y(t), sol2)]
def _linear_2eq_order2_type6(x, y, t, r, eq):
r"""
The equations are
.. math:: x'' = f(t) (a_1 x + b_1 y)
.. math:: y'' = f(t) (a_2 x + b_2 y)
If `k_1` and `k_2` are roots of the quadratic equation
.. math:: k^2 - (a_1 + b_2) k + a_1 b_2 - a_2 b_1 = 0
Then by multiplying appropriate constants and adding together original equations
we obtain two independent equations:
.. math:: z_1'' = k_1 f(t) z_1, z_1 = a_2 x + (k_1 - a_1) y
.. math:: z_2'' = k_2 f(t) z_2, z_2 = a_2 x + (k_2 - a_1) y
Solving the equations will give the values of `x` and `y` after obtaining the value
of `z_1` and `z_2` by solving the differential equation and substituting the result.
"""
k = Symbol('k')
z = Function('z')
num, den = cancel(
(r['c1']*x(t) + r['d1']*y(t))/
(r['c2']*x(t) + r['d2']*y(t))).as_numer_denom()
f = r['c1']/num.coeff(x(t))
a1 = num.coeff(x(t))
b1 = num.coeff(y(t))
a2 = den.coeff(x(t))
b2 = den.coeff(y(t))
chareq = k**2 - (a1 + b2)*k + a1*b2 - a2*b1
k1, k2 = [rootof(chareq, k) for k in range(Poly(chareq).degree())]
z1 = dsolve(diff(z(t),t,t) - k1*f*z(t)).rhs
z2 = dsolve(diff(z(t),t,t) - k2*f*z(t)).rhs
sol1 = (k1*z2 - k2*z1 + a1*(z1 - z2))/(a2*(k1-k2))
sol2 = (z1 - z2)/(k1 - k2)
return [Eq(x(t), sol1), Eq(y(t), sol2)]
def _linear_2eq_order2_type7(x, y, t, r, eq):
r"""
The equations are given as
.. math:: x'' = f(t) (a_1 x' + b_1 y')
.. math:: y'' = f(t) (a_2 x' + b_2 y')
If `k_1` and 'k_2` are roots of the quadratic equation
.. math:: k^2 - (a_1 + b_2) k + a_1 b_2 - a_2 b_1 = 0
Then the system can be reduced by adding together the two equations multiplied
by appropriate constants give following two independent equations:
.. math:: z_1'' = k_1 f(t) z_1', z_1 = a_2 x + (k_1 - a_1) y
.. math:: z_2'' = k_2 f(t) z_2', z_2 = a_2 x + (k_2 - a_1) y
Integrating these and returning to the original variables, one arrives at a linear
algebraic system for the unknowns `x` and `y`:
.. math:: a_2 x + (k_1 - a_1) y = C_1 \int e^{k_1 F(t)} \,dt + C_2
.. math:: a_2 x + (k_2 - a_1) y = C_3 \int e^{k_2 F(t)} \,dt + C_4
where `C_1,...,C_4` are arbitrary constants and `F(t) = \int f(t) \,dt`
"""
C1, C2, C3, C4 = get_numbered_constants(eq, num=4)
k = Symbol('k')
num, den = cancel(
(r['a1']*x(t) + r['b1']*y(t))/
(r['a2']*x(t) + r['b2']*y(t))).as_numer_denom()
f = r['a1']/num.coeff(x(t))
a1 = num.coeff(x(t))
b1 = num.coeff(y(t))
a2 = den.coeff(x(t))
b2 = den.coeff(y(t))
chareq = k**2 - (a1 + b2)*k + a1*b2 - a2*b1
[k1, k2] = [rootof(chareq, k) for k in range(Poly(chareq).degree())]
F = Integral(f, t)
z1 = C1*Integral(exp(k1*F), t) + C2
z2 = C3*Integral(exp(k2*F), t) + C4
sol1 = (k1*z2 - k2*z1 + a1*(z1 - z2))/(a2*(k1-k2))
sol2 = (z1 - z2)/(k1 - k2)
return [Eq(x(t), sol1), Eq(y(t), sol2)]
def _linear_2eq_order2_type8(x, y, t, r, eq):
r"""
The equation of this category are
.. math:: x'' = a f(t) (t y' - y)
.. math:: y'' = b f(t) (t x' - x)
The transformation
.. math:: u = t x' - x, v = t y' - y
leads to the system of first-order equations
.. math:: u' = a t f(t) v, v' = b t f(t) u
The general solution of this system has the form
If `ab > 0`:
.. math:: u = C_1 a e^{\sqrt{ab} \int t f(t) \,dt} + C_2 a e^{-\sqrt{ab} \int t f(t) \,dt}
.. math:: v = C_1 \sqrt{ab} e^{\sqrt{ab} \int t f(t) \,dt} - C_2 \sqrt{ab} e^{-\sqrt{ab} \int t f(t) \,dt}
If `ab < 0`:
.. math:: u = C_1 a \cos(\sqrt{\left|ab\right|} \int t f(t) \,dt) + C_2 a \sin(-\sqrt{\left|ab\right|} \int t f(t) \,dt)
.. math:: v = C_1 \sqrt{\left|ab\right|} \sin(\sqrt{\left|ab\right|} \int t f(t) \,dt) + C_2 \sqrt{\left|ab\right|} \cos(-\sqrt{\left|ab\right|} \int t f(t) \,dt)
where `C_1` and `C_2` are arbitrary constants. On substituting the value of `u` and `v`
in above equations and integrating the resulting expressions, the general solution will become
.. math:: x = C_3 t + t \int \frac{u}{t^2} \,dt, y = C_4 t + t \int \frac{u}{t^2} \,dt
where `C_3` and `C_4` are arbitrary constants.
"""
C1, C2, C3, C4 = get_numbered_constants(eq, num=4)
num, den = cancel(r['d1']/r['c2']).as_numer_denom()
f = -r['d1']/num
a = num
b = den
mul = sqrt(abs(a*b))
Igral = Integral(t*f, t)
if a*b > 0:
u = C1*a*exp(mul*Igral) + C2*a*exp(-mul*Igral)
v = C1*mul*exp(mul*Igral) - C2*mul*exp(-mul*Igral)
else:
u = C1*a*cos(mul*Igral) + C2*a*sin(mul*Igral)
v = -C1*mul*sin(mul*Igral) + C2*mul*cos(mul*Igral)
sol1 = C3*t + t*Integral(u/t**2, t)
sol2 = C4*t + t*Integral(v/t**2, t)
return [Eq(x(t), sol1), Eq(y(t), sol2)]
def _linear_2eq_order2_type9(x, y, t, r, eq):
r"""
.. math:: t^2 x'' + a_1 t x' + b_1 t y' + c_1 x + d_1 y = 0
.. math:: t^2 y'' + a_2 t x' + b_2 t y' + c_2 x + d_2 y = 0
These system of equations are euler type.
The substitution of `t = \sigma e^{\tau} (\sigma \neq 0)` leads to the system of constant
coefficient linear differential equations
.. math:: x'' + (a_1 - 1) x' + b_1 y' + c_1 x + d_1 y = 0
.. math:: y'' + a_2 x' + (b_2 - 1) y' + c_2 x + d_2 y = 0
The general solution of the homogeneous system of differential equations is determined
by a linear combination of linearly independent particular solutions determined by
the method of undetermined coefficients in the form of exponentials
.. math:: x = A e^{\lambda t}, y = B e^{\lambda t}
On substituting these expressions into the original system and collecting the
coefficients of the unknown `A` and `B`, one obtains
.. math:: (\lambda^{2} + (a_1 - 1) \lambda + c_1) A + (b_1 \lambda + d_1) B = 0
.. math:: (a_2 \lambda + c_2) A + (\lambda^{2} + (b_2 - 1) \lambda + d_2) B = 0
The determinant of this system must vanish for nontrivial solutions A, B to exist.
This requirement results in the following characteristic equation for `\lambda`
.. math:: (\lambda^2 + (a_1 - 1) \lambda + c_1) (\lambda^2 + (b_2 - 1) \lambda + d_2) - (b_1 \lambda + d_1) (a_2 \lambda + c_2) = 0
If all roots `k_1,...,k_4` of this equation are distinct, the general solution of the original
system of the differential equations has the form
.. math:: x = C_1 (b_1 \lambda_1 + d_1) e^{\lambda_1 t} - C_2 (b_1 \lambda_2 + d_1) e^{\lambda_2 t} - C_3 (b_1 \lambda_3 + d_1) e^{\lambda_3 t} - C_4 (b_1 \lambda_4 + d_1) e^{\lambda_4 t}
.. math:: y = C_1 (\lambda_1^{2} + (a_1 - 1) \lambda_1 + c_1) e^{\lambda_1 t} + C_2 (\lambda_2^{2} + (a_1 - 1) \lambda_2 + c_1) e^{\lambda_2 t} + C_3 (\lambda_3^{2} + (a_1 - 1) \lambda_3 + c_1) e^{\lambda_3 t} + C_4 (\lambda_4^{2} + (a_1 - 1) \lambda_4 + c_1) e^{\lambda_4 t}
"""
C1, C2, C3, C4 = get_numbered_constants(eq, num=4)
k = Symbol('k')
a1 = -r['a1']*t; a2 = -r['a2']*t
b1 = -r['b1']*t; b2 = -r['b2']*t
c1 = -r['c1']*t**2; c2 = -r['c2']*t**2
d1 = -r['d1']*t**2; d2 = -r['d2']*t**2
eq = (k**2+(a1-1)*k+c1)*(k**2+(b2-1)*k+d2)-(b1*k+d1)*(a2*k+c2)
[k1, k2, k3, k4] = roots_quartic(Poly(eq))
sol1 = -C1*(b1*k1+d1)*exp(k1*log(t)) - C2*(b1*k2+d1)*exp(k2*log(t)) - \
C3*(b1*k3+d1)*exp(k3*log(t)) - C4*(b1*k4+d1)*exp(k4*log(t))
a1_ = (a1-1)
sol2 = C1*(k1**2+a1_*k1+c1)*exp(k1*log(t)) + C2*(k2**2+a1_*k2+c1)*exp(k2*log(t)) \
+ C3*(k3**2+a1_*k3+c1)*exp(k3*log(t)) + C4*(k4**2+a1_*k4+c1)*exp(k4*log(t))
return [Eq(x(t), sol1), Eq(y(t), sol2)]
def _linear_2eq_order2_type10(x, y, t, r, eq):
r"""
The equation of this category are
.. math:: (\alpha t^2 + \beta t + \gamma)^{2} x'' = ax + by
.. math:: (\alpha t^2 + \beta t + \gamma)^{2} y'' = cx + dy
The transformation
.. math:: \tau = \int \frac{1}{\alpha t^2 + \beta t + \gamma} \,dt , u = \frac{x}{\sqrt{\left|\alpha t^2 + \beta t + \gamma\right|}} , v = \frac{y}{\sqrt{\left|\alpha t^2 + \beta t + \gamma\right|}}
leads to a constant coefficient linear system of equations
.. math:: u'' = (a - \alpha \gamma + \frac{1}{4} \beta^{2}) u + b v
.. math:: v'' = c u + (d - \alpha \gamma + \frac{1}{4} \beta^{2}) v
These system of equations obtained can be solved by type1 of System of two
constant-coefficient second-order linear homogeneous differential equations.
"""
u, v = symbols('u, v', cls=Function)
assert False
p = Wild('p', exclude=[t, t**2])
q = Wild('q', exclude=[t, t**2])
s = Wild('s', exclude=[t, t**2])
n = Wild('n', exclude=[t, t**2])
num, den = r['c1'].as_numer_denom()
dic = den.match((n*(p*t**2+q*t+s)**2).expand())
eqz = dic[p]*t**2 + dic[q]*t + dic[s]
a = num/dic[n]
b = cancel(r['d1']*eqz**2)
c = cancel(r['c2']*eqz**2)
d = cancel(r['d2']*eqz**2)
[msol1, msol2] = dsolve([Eq(diff(u(t), t, t), (a - dic[p]*dic[s] + dic[q]**2/4)*u(t) \
+ b*v(t)), Eq(diff(v(t),t,t), c*u(t) + (d - dic[p]*dic[s] + dic[q]**2/4)*v(t))])
sol1 = (msol1.rhs*sqrt(abs(eqz))).subs(t, Integral(1/eqz, t))
sol2 = (msol2.rhs*sqrt(abs(eqz))).subs(t, Integral(1/eqz, t))
return [Eq(x(t), sol1), Eq(y(t), sol2)]
def _linear_2eq_order2_type11(x, y, t, r, eq):
r"""
The equations which comes under this type are
.. math:: x'' = f(t) (t x' - x) + g(t) (t y' - y)
.. math:: y'' = h(t) (t x' - x) + p(t) (t y' - y)
The transformation
.. math:: u = t x' - x, v = t y' - y
leads to the linear system of first-order equations
.. math:: u' = t f(t) u + t g(t) v, v' = t h(t) u + t p(t) v
On substituting the value of `u` and `v` in transformed equation gives value of `x` and `y` as
.. math:: x = C_3 t + t \int \frac{u}{t^2} \,dt , y = C_4 t + t \int \frac{v}{t^2} \,dt.
where `C_3` and `C_4` are arbitrary constants.
"""
C1, C2, C3, C4 = get_numbered_constants(eq, num=4)
u, v = symbols('u, v', cls=Function)
f = -r['c1'] ; g = -r['d1']
h = -r['c2'] ; p = -r['d2']
[msol1, msol2] = dsolve([Eq(diff(u(t),t), t*f*u(t) + t*g*v(t)), Eq(diff(v(t),t), t*h*u(t) + t*p*v(t))])
sol1 = C3*t + t*Integral(msol1.rhs/t**2, t)
sol2 = C4*t + t*Integral(msol2.rhs/t**2, t)
return [Eq(x(t), sol1), Eq(y(t), sol2)]
def sysode_linear_3eq_order1(match_):
x = match_['func'][0].func
y = match_['func'][1].func
z = match_['func'][2].func
func = match_['func']
fc = match_['func_coeff']
eq = match_['eq']
r = dict()
t = list(list(eq[0].atoms(Derivative))[0].atoms(Symbol))[0]
for i in range(3):
eqs = 0
for terms in Add.make_args(eq[i]):
eqs += terms/fc[i,func[i],1]
eq[i] = eqs
# for equations:
# Eq(g1*diff(x(t),t), a1*x(t)+b1*y(t)+c1*z(t)+d1),
# Eq(g2*diff(y(t),t), a2*x(t)+b2*y(t)+c2*z(t)+d2), and
# Eq(g3*diff(z(t),t), a3*x(t)+b3*y(t)+c3*z(t)+d3)
r['a1'] = fc[0,x(t),0]/fc[0,x(t),1]; r['a2'] = fc[1,x(t),0]/fc[1,y(t),1];
r['a3'] = fc[2,x(t),0]/fc[2,z(t),1]
r['b1'] = fc[0,y(t),0]/fc[0,x(t),1]; r['b2'] = fc[1,y(t),0]/fc[1,y(t),1];
r['b3'] = fc[2,y(t),0]/fc[2,z(t),1]
r['c1'] = fc[0,z(t),0]/fc[0,x(t),1]; r['c2'] = fc[1,z(t),0]/fc[1,y(t),1];
r['c3'] = fc[2,z(t),0]/fc[2,z(t),1]
for i in range(3):
for j in Add.make_args(eq[i]):
if not j.has(x(t), y(t), z(t)):
raise NotImplementedError("Only homogeneous problems are supported, non-homogeneous are not supported currently.")
if match_['type_of_equation'] == 'type1':
sol = _linear_3eq_order1_type1(x, y, z, t, r, eq)
if match_['type_of_equation'] == 'type2':
sol = _linear_3eq_order1_type2(x, y, z, t, r, eq)
if match_['type_of_equation'] == 'type3':
sol = _linear_3eq_order1_type3(x, y, z, t, r, eq)
if match_['type_of_equation'] == 'type4':
sol = _linear_3eq_order1_type4(x, y, z, t, r, eq)
if match_['type_of_equation'] == 'type6':
sol = _linear_neq_order1_type1(match_)
return sol
def _linear_3eq_order1_type1(x, y, z, t, r, eq):
r"""
.. math:: x' = ax
.. math:: y' = bx + cy
.. math:: z' = dx + ky + pz
Solution of such equations are forward substitution. Solving first equations
gives the value of `x`, substituting it in second and third equation and
solving second equation gives `y` and similarly substituting `y` in third
equation give `z`.
.. math:: x = C_1 e^{at}
.. math:: y = \frac{b C_1}{a - c} e^{at} + C_2 e^{ct}
.. math:: z = \frac{C_1}{a - p} (d + \frac{bk}{a - c}) e^{at} + \frac{k C_2}{c - p} e^{ct} + C_3 e^{pt}
where `C_1, C_2` and `C_3` are arbitrary constants.
"""
C1, C2, C3, C4 = get_numbered_constants(eq, num=4)
a = -r['a1']; b = -r['a2']; c = -r['b2']
d = -r['a3']; k = -r['b3']; p = -r['c3']
sol1 = C1*exp(a*t)
sol2 = b*C1*exp(a*t)/(a-c) + C2*exp(c*t)
sol3 = C1*(d+b*k/(a-c))*exp(a*t)/(a-p) + k*C2*exp(c*t)/(c-p) + C3*exp(p*t)
return [Eq(x(t), sol1), Eq(y(t), sol2), Eq(z(t), sol3)]
def _linear_3eq_order1_type2(x, y, z, t, r, eq):
r"""
The equations of this type are
.. math:: x' = cy - bz
.. math:: y' = az - cx
.. math:: z' = bx - ay
1. First integral:
.. math:: ax + by + cz = A \qquad - (1)
.. math:: x^2 + y^2 + z^2 = B^2 \qquad - (2)
where `A` and `B` are arbitrary constants. It follows from these integrals
that the integral lines are circles formed by the intersection of the planes
`(1)` and sphere `(2)`
2. Solution:
.. math:: x = a C_0 + k C_1 \cos(kt) + (c C_2 - b C_3) \sin(kt)
.. math:: y = b C_0 + k C_2 \cos(kt) + (a C_2 - c C_3) \sin(kt)
.. math:: z = c C_0 + k C_3 \cos(kt) + (b C_2 - a C_3) \sin(kt)
where `k = \sqrt{a^2 + b^2 + c^2}` and the four constants of integration,
`C_1,...,C_4` are constrained by a single relation,
.. math:: a C_1 + b C_2 + c C_3 = 0
"""
C0, C1, C2, C3 = get_numbered_constants(eq, num=4, start=0)
a = -r['c2']; b = -r['a3']; c = -r['b1']
k = sqrt(a**2 + b**2 + c**2)
C3 = (-a*C1 - b*C2)/c
sol1 = a*C0 + k*C1*cos(k*t) + (c*C2-b*C3)*sin(k*t)
sol2 = b*C0 + k*C2*cos(k*t) + (a*C3-c*C1)*sin(k*t)
sol3 = c*C0 + k*C3*cos(k*t) + (b*C1-a*C2)*sin(k*t)
return [Eq(x(t), sol1), Eq(y(t), sol2), Eq(z(t), sol3)]
def _linear_3eq_order1_type3(x, y, z, t, r, eq):
r"""
Equations of this system of ODEs
.. math:: a x' = bc (y - z)
.. math:: b y' = ac (z - x)
.. math:: c z' = ab (x - y)
1. First integral:
.. math:: a^2 x + b^2 y + c^2 z = A
where A is an arbitrary constant. It follows that the integral lines are plane curves.
2. Solution:
.. math:: x = C_0 + k C_1 \cos(kt) + a^{-1} bc (C_2 - C_3) \sin(kt)
.. math:: y = C_0 + k C_2 \cos(kt) + a b^{-1} c (C_3 - C_1) \sin(kt)
.. math:: z = C_0 + k C_3 \cos(kt) + ab c^{-1} (C_1 - C_2) \sin(kt)
where `k = \sqrt{a^2 + b^2 + c^2}` and the four constants of integration,
`C_1,...,C_4` are constrained by a single relation
.. math:: a^2 C_1 + b^2 C_2 + c^2 C_3 = 0
"""
C0, C1, C2, C3 = get_numbered_constants(eq, num=4, start=0)
c = sqrt(r['b1']*r['c2'])
b = sqrt(r['b1']*r['a3'])
a = sqrt(r['c2']*r['a3'])
C3 = (-a**2*C1-b**2*C2)/c**2
k = sqrt(a**2 + b**2 + c**2)
sol1 = C0 + k*C1*cos(k*t) + a**-1*b*c*(C2-C3)*sin(k*t)
sol2 = C0 + k*C2*cos(k*t) + a*b**-1*c*(C3-C1)*sin(k*t)
sol3 = C0 + k*C3*cos(k*t) + a*b*c**-1*(C1-C2)*sin(k*t)
return [Eq(x(t), sol1), Eq(y(t), sol2), Eq(z(t), sol3)]
def _linear_3eq_order1_type4(x, y, z, t, r, eq):
r"""
Equations:
.. math:: x' = (a_1 f(t) + g(t)) x + a_2 f(t) y + a_3 f(t) z
.. math:: y' = b_1 f(t) x + (b_2 f(t) + g(t)) y + b_3 f(t) z
.. math:: z' = c_1 f(t) x + c_2 f(t) y + (c_3 f(t) + g(t)) z
The transformation
.. math:: x = e^{\int g(t) \,dt} u, y = e^{\int g(t) \,dt} v, z = e^{\int g(t) \,dt} w, \tau = \int f(t) \,dt
leads to the system of constant coefficient linear differential equations
.. math:: u' = a_1 u + a_2 v + a_3 w
.. math:: v' = b_1 u + b_2 v + b_3 w
.. math:: w' = c_1 u + c_2 v + c_3 w
These system of equations are solved by homogeneous linear system of constant
coefficients of `n` equations of first order. Then substituting the value of
`u, v` and `w` in transformed equation gives value of `x, y` and `z`.
"""
u, v, w = symbols('u, v, w', cls=Function)
a2, a3 = cancel(r['b1']/r['c1']).as_numer_denom()
f = cancel(r['b1']/a2)
b1 = cancel(r['a2']/f); b3 = cancel(r['c2']/f)
c1 = cancel(r['a3']/f); c2 = cancel(r['b3']/f)
a1, g = div(r['a1'],f)
b2 = div(r['b2'],f)[0]
c3 = div(r['c3'],f)[0]
trans_eq = (diff(u(t),t)-a1*u(t)-a2*v(t)-a3*w(t), diff(v(t),t)-b1*u(t)-\
b2*v(t)-b3*w(t), diff(w(t),t)-c1*u(t)-c2*v(t)-c3*w(t))
sol = dsolve(trans_eq)
sol1 = exp(Integral(g,t))*((sol[0].rhs).subs(t, Integral(f,t)))
sol2 = exp(Integral(g,t))*((sol[1].rhs).subs(t, Integral(f,t)))
sol3 = exp(Integral(g,t))*((sol[2].rhs).subs(t, Integral(f,t)))
return [Eq(x(t), sol1), Eq(y(t), sol2), Eq(z(t), sol3)]
def sysode_linear_neq_order1(match_):
sol = _linear_neq_order1_type1(match_)
return sol
def _linear_neq_order1_type1(match_):
r"""
System of n first-order constant-coefficient linear nonhomogeneous differential equation
.. math:: y'_k = a_{k1} y_1 + a_{k2} y_2 +...+ a_{kn} y_n; k = 1,2,...,n
or that can be written as `\vec{y'} = A . \vec{y}`
where `\vec{y}` is matrix of `y_k` for `k = 1,2,...n` and `A` is a `n \times n` matrix.
Since these equations are equivalent to a first order homogeneous linear
differential equation. So the general solution will contain `n` linearly
independent parts and solution will consist some type of exponential
functions. Assuming `y = \vec{v} e^{rt}` is a solution of the system where
`\vec{v}` is a vector of coefficients of `y_1,...,y_n`. Substituting `y` and
`y' = r v e^{r t}` into the equation `\vec{y'} = A . \vec{y}`, we get
.. math:: r \vec{v} e^{rt} = A \vec{v} e^{rt}
.. math:: r \vec{v} = A \vec{v}
where `r` comes out to be eigenvalue of `A` and vector `\vec{v}` is the eigenvector
of `A` corresponding to `r`. There are three possibilities of eigenvalues of `A`
- `n` distinct real eigenvalues
- complex conjugate eigenvalues
- eigenvalues with multiplicity `k`
1. When all eigenvalues `r_1,..,r_n` are distinct with `n` different eigenvectors
`v_1,...v_n` then the solution is given by
.. math:: \vec{y} = C_1 e^{r_1 t} \vec{v_1} + C_2 e^{r_2 t} \vec{v_2} +...+ C_n e^{r_n t} \vec{v_n}
where `C_1,C_2,...,C_n` are arbitrary constants.
2. When some eigenvalues are complex then in order to make the solution real,
we take a linear combination: if `r = a + bi` has an eigenvector
`\vec{v} = \vec{w_1} + i \vec{w_2}` then to obtain real-valued solutions to
the system, replace the complex-valued solutions `e^{rx} \vec{v}`
with real-valued solution `e^{ax} (\vec{w_1} \cos(bx) - \vec{w_2} \sin(bx))`
and for `r = a - bi` replace the solution `e^{-r x} \vec{v}` with
`e^{ax} (\vec{w_1} \sin(bx) + \vec{w_2} \cos(bx))`
3. If some eigenvalues are repeated. Then we get fewer than `n` linearly
independent eigenvectors, we miss some of the solutions and need to
construct the missing ones. We do this via generalized eigenvectors, vectors
which are not eigenvectors but are close enough that we can use to write
down the remaining solutions. For a eigenvalue `r` with eigenvector `\vec{w}`
we obtain `\vec{w_2},...,\vec{w_k}` using
.. math:: (A - r I) . \vec{w_2} = \vec{w}
.. math:: (A - r I) . \vec{w_3} = \vec{w_2}
.. math:: \vdots
.. math:: (A - r I) . \vec{w_k} = \vec{w_{k-1}}
Then the solutions to the system for the eigenspace are `e^{rt} [\vec{w}],
e^{rt} [t \vec{w} + \vec{w_2}], e^{rt} [\frac{t^2}{2} \vec{w} + t \vec{w_2} + \vec{w_3}],
...,e^{rt} [\frac{t^{k-1}}{(k-1)!} \vec{w} + \frac{t^{k-2}}{(k-2)!} \vec{w_2} +...+ t \vec{w_{k-1}}
+ \vec{w_k}]`
So, If `\vec{y_1},...,\vec{y_n}` are `n` solution of obtained from three
categories of `A`, then general solution to the system `\vec{y'} = A . \vec{y}`
.. math:: \vec{y} = C_1 \vec{y_1} + C_2 \vec{y_2} + \cdots + C_n \vec{y_n}
"""
eq = match_['eq']
func = match_['func']
fc = match_['func_coeff']
n = len(eq)
t = list(list(eq[0].atoms(Derivative))[0].atoms(Symbol))[0]
constants = numbered_symbols(prefix='C', cls=Symbol, start=1)
M = Matrix(n,n,lambda i,j:-fc[i,func[j],0])
evector = M.eigenvects(simplify=True)
def is_complex(mat, root):
return Matrix(n, 1, lambda i,j: re(mat[i])*cos(im(root)*t) - im(mat[i])*sin(im(root)*t))
def is_complex_conjugate(mat, root):
return Matrix(n, 1, lambda i,j: re(mat[i])*sin(abs(im(root))*t) + im(mat[i])*cos(im(root)*t)*abs(im(root))/im(root))
conjugate_root = []
e_vector = zeros(n,1)
for evects in evector:
if evects[0] not in conjugate_root:
# If number of column of an eigenvector is not equal to the multiplicity
# of its eigenvalue then the legt eigenvectors are calculated
if len(evects[2])!=evects[1]:
var_mat = Matrix(n, 1, lambda i,j: Symbol('x'+str(i)))
Mnew = (M - evects[0]*eye(evects[2][-1].rows))*var_mat
w = [0 for i in range(evects[1])]
w[0] = evects[2][-1]
for r in range(1, evects[1]):
w_ = Mnew - w[r-1]
sol_dict = solve(list(w_), var_mat[1:])
sol_dict[var_mat[0]] = var_mat[0]
for key, value in sol_dict.items():
sol_dict[key] = value.subs(var_mat[0],1)
w[r] = Matrix(n, 1, lambda i,j: sol_dict[var_mat[i]])
evects[2].append(w[r])
for i in range(evects[1]):
C = next(constants)
for j in range(i+1):
if evects[0].has(I):
evects[2][j] = simplify(evects[2][j])
e_vector += C*is_complex(evects[2][j], evects[0])*t**(i-j)*exp(re(evects[0])*t)/factorial(i-j)
C = next(constants)
e_vector += C*is_complex_conjugate(evects[2][j], evects[0])*t**(i-j)*exp(re(evects[0])*t)/factorial(i-j)
else:
e_vector += C*evects[2][j]*t**(i-j)*exp(evects[0]*t)/factorial(i-j)
if evects[0].has(I):
conjugate_root.append(conjugate(evects[0]))
sol = []
for i in range(len(eq)):
sol.append(Eq(func[i],e_vector[i]))
return sol
def sysode_nonlinear_2eq_order1(match_):
func = match_['func']
eq = match_['eq']
fc = match_['func_coeff']
t = list(list(eq[0].atoms(Derivative))[0].atoms(Symbol))[0]
if match_['type_of_equation'] == 'type5':
sol = _nonlinear_2eq_order1_type5(func, t, eq)
return sol
x = func[0].func
y = func[1].func
for i in range(2):
eqs = 0
for terms in Add.make_args(eq[i]):
eqs += terms/fc[i,func[i],1]
eq[i] = eqs
if match_['type_of_equation'] == 'type1':
sol = _nonlinear_2eq_order1_type1(x, y, t, eq)
elif match_['type_of_equation'] == 'type2':
sol = _nonlinear_2eq_order1_type2(x, y, t, eq)
elif match_['type_of_equation'] == 'type3':
sol = _nonlinear_2eq_order1_type3(x, y, t, eq)
elif match_['type_of_equation'] == 'type4':
sol = _nonlinear_2eq_order1_type4(x, y, t, eq)
return sol
def _nonlinear_2eq_order1_type1(x, y, t, eq):
r"""
Equations:
.. math:: x' = x^n F(x,y)
.. math:: y' = g(y) F(x,y)
Solution:
.. math:: x = \varphi(y), \int \frac{1}{g(y) F(\varphi(y),y)} \,dy = t + C_2
where
if `n \neq 1`
.. math:: \varphi = [C_1 + (1-n) \int \frac{1}{g(y)} \,dy]^{\frac{1}{1-n}}
if `n = 1`
.. math:: \varphi = C_1 e^{\int \frac{1}{g(y)} \,dy}
where `C_1` and `C_2` are arbitrary constants.
"""
C1, C2 = get_numbered_constants(eq, num=2)
n = Wild('n', exclude=[x(t),y(t)])
f = Wild('f')
u, v = symbols('u, v')
r = eq[0].match(diff(x(t),t) - x(t)**n*f)
g = ((diff(y(t),t) - eq[1])/r[f]).subs(y(t),v)
F = r[f].subs(x(t),u).subs(y(t),v)
n = r[n]
if n!=1:
phi = (C1 + (1-n)*Integral(1/g, v))**(1/(1-n))
else:
phi = C1*exp(Integral(1/g, v))
phi = phi.doit()
sol2 = solve(Integral(1/(g*F.subs(u,phi)), v).doit() - t - C2, v)
sol = []
for sols in sol2:
sol.append(Eq(x(t),phi.subs(v, sols)))
sol.append(Eq(y(t), sols))
return sol
def _nonlinear_2eq_order1_type2(x, y, t, eq):
r"""
Equations:
.. math:: x' = e^{\lambda x} F(x,y)
.. math:: y' = g(y) F(x,y)
Solution:
.. math:: x = \varphi(y), \int \frac{1}{g(y) F(\varphi(y),y)} \,dy = t + C_2
where
if `\lambda \neq 0`
.. math:: \varphi = -\frac{1}{\lambda} log(C_1 - \lambda \int \frac{1}{g(y)} \,dy)
if `\lambda = 0`
.. math:: \varphi = C_1 + \int \frac{1}{g(y)} \,dy
where `C_1` and `C_2` are arbitrary constants.
"""
C1, C2 = get_numbered_constants(eq, num=2)
n = Wild('n', exclude=[x(t),y(t)])
f = Wild('f')
u, v = symbols('u, v')
r = eq[0].match(diff(x(t),t) - exp(n*x(t))*f)
g = ((diff(y(t),t) - eq[1])/r[f]).subs(y(t),v)
F = r[f].subs(x(t),u).subs(y(t),v)
n = r[n]
if n:
phi = -1/n*log(C1 - n*Integral(1/g, v))
else:
phi = C1 + Integral(1/g, v)
phi = phi.doit()
sol2 = solve(Integral(1/(g*F.subs(u,phi)), v).doit() - t - C2, v)
sol = []
for sols in sol2:
sol.append(Eq(x(t),phi.subs(v, sols)))
sol.append(Eq(y(t), sols))
return sol
def _nonlinear_2eq_order1_type3(x, y, t, eq):
r"""
Autonomous system of general form
.. math:: x' = F(x,y)
.. math:: y' = G(x,y)
Assuming `y = y(x, C_1)` where `C_1` is an arbitrary constant is the general
solution of the first-order equation
.. math:: F(x,y) y'_x = G(x,y)
Then the general solution of the original system of equations has the form
.. math:: \int \frac{1}{F(x,y(x,C_1))} \,dx = t + C_1
"""
C1, C2, C3, C4 = get_numbered_constants(eq, num=4)
v = Function('v')
u = Symbol('u')
f = Wild('f')
g = Wild('g')
r1 = eq[0].match(diff(x(t),t) - f)
r2 = eq[1].match(diff(y(t),t) - g)
F = r1[f].subs(x(t), u).subs(y(t), v(u))
G = r2[g].subs(x(t), u).subs(y(t), v(u))
sol2r = dsolve(Eq(diff(v(u), u), G/F))
for sol2s in sol2r:
sol1 = solve(Integral(1/F.subs(v(u), sol2s.rhs), u).doit() - t - C2, u)
sol = []
for sols in sol1:
sol.append(Eq(x(t), sols))
sol.append(Eq(y(t), (sol2s.rhs).subs(u, sols)))
return sol
def _nonlinear_2eq_order1_type4(x, y, t, eq):
r"""
Equation:
.. math:: x' = f_1(x) g_1(y) \phi(x,y,t)
.. math:: y' = f_2(x) g_2(y) \phi(x,y,t)
First integral:
.. math:: \int \frac{f_2(x)}{f_1(x)} \,dx - \int \frac{g_1(y)}{g_2(y)} \,dy = C
where `C` is an arbitrary constant.
On solving the first integral for `x` (resp., `y` ) and on substituting the
resulting expression into either equation of the original solution, one
arrives at a first-order equation for determining `y` (resp., `x` ).
"""
C1, C2 = get_numbered_constants(eq, num=2)
u, v = symbols('u, v')
U, V = symbols('U, V', cls=Function)
f = Wild('f')
g = Wild('g')
f1 = Wild('f1', exclude=[v,t])
f2 = Wild('f2', exclude=[v,t])
g1 = Wild('g1', exclude=[u,t])
g2 = Wild('g2', exclude=[u,t])
r1 = eq[0].match(diff(x(t),t) - f)
r2 = eq[1].match(diff(y(t),t) - g)
num, den = (
(r1[f].subs(x(t),u).subs(y(t),v))/
(r2[g].subs(x(t),u).subs(y(t),v))).as_numer_denom()
R1 = num.match(f1*g1)
R2 = den.match(f2*g2)
phi = (r1[f].subs(x(t),u).subs(y(t),v))/num
F1 = R1[f1]; F2 = R2[f2]
G1 = R1[g1]; G2 = R2[g2]
sol1r = solve(Integral(F2/F1, u).doit() - Integral(G1/G2,v).doit() - C1, u)
sol2r = solve(Integral(F2/F1, u).doit() - Integral(G1/G2,v).doit() - C1, v)
sol = []
for sols in sol1r:
sol.append(Eq(y(t), dsolve(diff(V(t),t) - F2.subs(u,sols).subs(v,V(t))*G2.subs(v,V(t))*phi.subs(u,sols).subs(v,V(t))).rhs))
for sols in sol2r:
sol.append(Eq(x(t), dsolve(diff(U(t),t) - F1.subs(u,U(t))*G1.subs(v,sols).subs(u,U(t))*phi.subs(v,sols).subs(u,U(t))).rhs))
return set(sol)
def _nonlinear_2eq_order1_type5(func, t, eq):
r"""
Clairaut system of ODEs
.. math:: x = t x' + F(x',y')
.. math:: y = t y' + G(x',y')
The following are solutions of the system
`(i)` straight lines:
.. math:: x = C_1 t + F(C_1, C_2), y = C_2 t + G(C_1, C_2)
where `C_1` and `C_2` are arbitrary constants;
`(ii)` envelopes of the above lines;
`(iii)` continuously differentiable lines made up from segments of the lines
`(i)` and `(ii)`.
"""
C1, C2 = get_numbered_constants(eq, num=2)
f = Wild('f')
g = Wild('g')
def check_type(x, y):
r1 = eq[0].match(t*diff(x(t),t) - x(t) + f)
r2 = eq[1].match(t*diff(y(t),t) - y(t) + g)
if not (r1 and r2):
r1 = eq[0].match(diff(x(t),t) - x(t)/t + f/t)
r2 = eq[1].match(diff(y(t),t) - y(t)/t + g/t)
if not (r1 and r2):
r1 = (-eq[0]).match(t*diff(x(t),t) - x(t) + f)
r2 = (-eq[1]).match(t*diff(y(t),t) - y(t) + g)
if not (r1 and r2):
r1 = (-eq[0]).match(diff(x(t),t) - x(t)/t + f/t)
r2 = (-eq[1]).match(diff(y(t),t) - y(t)/t + g/t)
return [r1, r2]
for func_ in func:
if isinstance(func_, list):
x = func[0][0].func
y = func[0][1].func
[r1, r2] = check_type(x, y)
if not (r1 and r2):
[r1, r2] = check_type(y, x)
x, y = y, x
x1 = diff(x(t),t); y1 = diff(y(t),t)
return {Eq(x(t), C1*t + r1[f].subs(x1,C1).subs(y1,C2)), Eq(y(t), C2*t + r2[g].subs(x1,C1).subs(y1,C2))}
def sysode_nonlinear_3eq_order1(match_):
x = match_['func'][0].func
y = match_['func'][1].func
z = match_['func'][2].func
eq = match_['eq']
t = list(list(eq[0].atoms(Derivative))[0].atoms(Symbol))[0]
if match_['type_of_equation'] == 'type1':
sol = _nonlinear_3eq_order1_type1(x, y, z, t, eq)
if match_['type_of_equation'] == 'type2':
sol = _nonlinear_3eq_order1_type2(x, y, z, t, eq)
if match_['type_of_equation'] == 'type3':
sol = _nonlinear_3eq_order1_type3(x, y, z, t, eq)
if match_['type_of_equation'] == 'type4':
sol = _nonlinear_3eq_order1_type4(x, y, z, t, eq)
if match_['type_of_equation'] == 'type5':
sol = _nonlinear_3eq_order1_type5(x, y, z, t, eq)
return sol
def _nonlinear_3eq_order1_type1(x, y, z, t, eq):
r"""
Equations:
.. math:: a x' = (b - c) y z, \enspace b y' = (c - a) z x, \enspace c z' = (a - b) x y
First Integrals:
.. math:: a x^{2} + b y^{2} + c z^{2} = C_1
.. math:: a^{2} x^{2} + b^{2} y^{2} + c^{2} z^{2} = C_2
where `C_1` and `C_2` are arbitrary constants. On solving the integrals for `y` and
`z` and on substituting the resulting expressions into the first equation of the
system, we arrives at a separable first-order equation on `x`. Similarly doing that
for other two equations, we will arrive at first order equation on `y` and `z` too.
References
==========
-http://eqworld.ipmnet.ru/en/solutions/sysode/sode0401.pdf
"""
C1, C2 = get_numbered_constants(eq, num=2)
u, v, w = symbols('u, v, w')
p = Wild('p', exclude=[x(t), y(t), z(t), t])
q = Wild('q', exclude=[x(t), y(t), z(t), t])
s = Wild('s', exclude=[x(t), y(t), z(t), t])
r = (diff(x(t),t) - eq[0]).match(p*y(t)*z(t))
r.update((diff(y(t),t) - eq[1]).match(q*z(t)*x(t)))
r.update((diff(z(t),t) - eq[2]).match(s*x(t)*y(t)))
n1, d1 = r[p].as_numer_denom()
n2, d2 = r[q].as_numer_denom()
n3, d3 = r[s].as_numer_denom()
val = solve([n1*u-d1*v+d1*w, d2*u+n2*v-d2*w, d3*u-d3*v-n3*w],[u,v])
vals = [val[v], val[u]]
c = lcm(vals[0].as_numer_denom()[1], vals[1].as_numer_denom()[1])
b = vals[0].subs(w, c)
a = vals[1].subs(w, c)
y_x = sqrt(((c*C1-C2) - a*(c-a)*x(t)**2)/(b*(c-b)))
z_x = sqrt(((b*C1-C2) - a*(b-a)*x(t)**2)/(c*(b-c)))
z_y = sqrt(((a*C1-C2) - b*(a-b)*y(t)**2)/(c*(a-c)))
x_y = sqrt(((c*C1-C2) - b*(c-b)*y(t)**2)/(a*(c-a)))
x_z = sqrt(((b*C1-C2) - c*(b-c)*z(t)**2)/(a*(b-a)))
y_z = sqrt(((a*C1-C2) - c*(a-c)*z(t)**2)/(b*(a-b)))
sol1 = dsolve(a*diff(x(t),t) - (b-c)*y_x*z_x)
sol2 = dsolve(b*diff(y(t),t) - (c-a)*z_y*x_y)
sol3 = dsolve(c*diff(z(t),t) - (a-b)*x_z*y_z)
return [sol1, sol2, sol3]
def _nonlinear_3eq_order1_type2(x, y, z, t, eq):
r"""
Equations:
.. math:: a x' = (b - c) y z f(x, y, z, t)
.. math:: b y' = (c - a) z x f(x, y, z, t)
.. math:: c z' = (a - b) x y f(x, y, z, t)
First Integrals:
.. math:: a x^{2} + b y^{2} + c z^{2} = C_1
.. math:: a^{2} x^{2} + b^{2} y^{2} + c^{2} z^{2} = C_2
where `C_1` and `C_2` are arbitrary constants. On solving the integrals for `y` and
`z` and on substituting the resulting expressions into the first equation of the
system, we arrives at a first-order differential equations on `x`. Similarly doing
that for other two equations we will arrive at first order equation on `y` and `z`.
References
==========
-http://eqworld.ipmnet.ru/en/solutions/sysode/sode0402.pdf
"""
C1, C2 = get_numbered_constants(eq, num=2)
u, v, w = symbols('u, v, w')
p = Wild('p', exclude=[x(t), y(t), z(t), t])
q = Wild('q', exclude=[x(t), y(t), z(t), t])
s = Wild('s', exclude=[x(t), y(t), z(t), t])
f = Wild('f')
r1 = (diff(x(t),t) - eq[0]).match(y(t)*z(t)*f)
r = collect_const(r1[f]).match(p*f)
r.update(((diff(y(t),t) - eq[1])/r[f]).match(q*z(t)*x(t)))
r.update(((diff(z(t),t) - eq[2])/r[f]).match(s*x(t)*y(t)))
n1, d1 = r[p].as_numer_denom()
n2, d2 = r[q].as_numer_denom()
n3, d3 = r[s].as_numer_denom()
val = solve([n1*u-d1*v+d1*w, d2*u+n2*v-d2*w, -d3*u+d3*v+n3*w],[u,v])
vals = [val[v], val[u]]
c = lcm(vals[0].as_numer_denom()[1], vals[1].as_numer_denom()[1])
a = vals[0].subs(w, c)
b = vals[1].subs(w, c)
y_x = sqrt(((c*C1-C2) - a*(c-a)*x(t)**2)/(b*(c-b)))
z_x = sqrt(((b*C1-C2) - a*(b-a)*x(t)**2)/(c*(b-c)))
z_y = sqrt(((a*C1-C2) - b*(a-b)*y(t)**2)/(c*(a-c)))
x_y = sqrt(((c*C1-C2) - b*(c-b)*y(t)**2)/(a*(c-a)))
x_z = sqrt(((b*C1-C2) - c*(b-c)*z(t)**2)/(a*(b-a)))
y_z = sqrt(((a*C1-C2) - c*(a-c)*z(t)**2)/(b*(a-b)))
sol1 = dsolve(a*diff(x(t),t) - (b-c)*y_x*z_x*r[f])
sol2 = dsolve(b*diff(y(t),t) - (c-a)*z_y*x_y*r[f])
sol3 = dsolve(c*diff(z(t),t) - (a-b)*x_z*y_z*r[f])
return [sol1, sol2, sol3]
def _nonlinear_3eq_order1_type3(x, y, z, t, eq):
r"""
Equations:
.. math:: x' = c F_2 - b F_3, \enspace y' = a F_3 - c F_1, \enspace z' = b F_1 - a F_2
where `F_n = F_n(x, y, z, t)`.
1. First Integral:
.. math:: a x + b y + c z = C_1,
where C is an arbitrary constant.
2. If we assume function `F_n` to be independent of `t`,i.e, `F_n` = `F_n (x, y, z)`
Then, on eliminating `t` and `z` from the first two equation of the system, one
arrives at the first-order equation
.. math:: \frac{dy}{dx} = \frac{a F_3 (x, y, z) - c F_1 (x, y, z)}{c F_2 (x, y, z) -
b F_3 (x, y, z)}
where `z = \frac{1}{c} (C_1 - a x - b y)`
References
==========
-http://eqworld.ipmnet.ru/en/solutions/sysode/sode0404.pdf
"""
C1 = get_numbered_constants(eq, num=1)
u, v, w = symbols('u, v, w')
p = Wild('p', exclude=[x(t), y(t), z(t), t])
q = Wild('q', exclude=[x(t), y(t), z(t), t])
s = Wild('s', exclude=[x(t), y(t), z(t), t])
F1, F2, F3 = symbols('F1, F2, F3', cls=Wild)
r1 = (diff(x(t), t) - eq[0]).match(F2-F3)
r = collect_const(r1[F2]).match(s*F2)
r.update(collect_const(r1[F3]).match(q*F3))
if eq[1].has(r[F2]) and not eq[1].has(r[F3]):
r[F2], r[F3] = r[F3], r[F2]
r[s], r[q] = -r[q], -r[s]
r.update((diff(y(t), t) - eq[1]).match(p*r[F3] - r[s]*F1))
a = r[p]; b = r[q]; c = r[s]
F1 = r[F1].subs(x(t), u).subs(y(t),v).subs(z(t), w)
F2 = r[F2].subs(x(t), u).subs(y(t),v).subs(z(t), w)
F3 = r[F3].subs(x(t), u).subs(y(t),v).subs(z(t), w)
z_xy = (C1-a*u-b*v)/c
y_zx = (C1-a*u-c*w)/b
x_yz = (C1-b*v-c*w)/a
y_x = dsolve(diff(v(u),u) - ((a*F3-c*F1)/(c*F2-b*F3)).subs(w,z_xy).subs(v,v(u))).rhs
z_x = dsolve(diff(w(u),u) - ((b*F1-a*F2)/(c*F2-b*F3)).subs(v,y_zx).subs(w,w(u))).rhs
z_y = dsolve(diff(w(v),v) - ((b*F1-a*F2)/(a*F3-c*F1)).subs(u,x_yz).subs(w,w(v))).rhs
x_y = dsolve(diff(u(v),v) - ((c*F2-b*F3)/(a*F3-c*F1)).subs(w,z_xy).subs(u,u(v))).rhs
y_z = dsolve(diff(v(w),w) - ((a*F3-c*F1)/(b*F1-a*F2)).subs(u,x_yz).subs(v,v(w))).rhs
x_z = dsolve(diff(u(w),w) - ((c*F2-b*F3)/(b*F1-a*F2)).subs(v,y_zx).subs(u,u(w))).rhs
sol1 = dsolve(diff(u(t),t) - (c*F2 - b*F3).subs(v,y_x).subs(w,z_x).subs(u,u(t))).rhs
sol2 = dsolve(diff(v(t),t) - (a*F3 - c*F1).subs(u,x_y).subs(w,z_y).subs(v,v(t))).rhs
sol3 = dsolve(diff(w(t),t) - (b*F1 - a*F2).subs(u,x_z).subs(v,y_z).subs(w,w(t))).rhs
return [sol1, sol2, sol3]
def _nonlinear_3eq_order1_type4(x, y, z, t, eq):
r"""
Equations:
.. math:: x' = c z F_2 - b y F_3, \enspace y' = a x F_3 - c z F_1, \enspace z' = b y F_1 - a x F_2
where `F_n = F_n (x, y, z, t)`
1. First integral:
.. math:: a x^{2} + b y^{2} + c z^{2} = C_1
where `C` is an arbitrary constant.
2. Assuming the function `F_n` is independent of `t`: `F_n = F_n (x, y, z)`. Then on
eliminating `t` and `z` from the first two equations of the system, one arrives at
the first-order equation
.. math:: \frac{dy}{dx} = \frac{a x F_3 (x, y, z) - c z F_1 (x, y, z)}
{c z F_2 (x, y, z) - b y F_3 (x, y, z)}
where `z = \pm \sqrt{\frac{1}{c} (C_1 - a x^{2} - b y^{2})}`
References
==========
-http://eqworld.ipmnet.ru/en/solutions/sysode/sode0405.pdf
"""
C1 = get_numbered_constants(eq, num=1)
u, v, w = symbols('u, v, w')
p = Wild('p', exclude=[x(t), y(t), z(t), t])
q = Wild('q', exclude=[x(t), y(t), z(t), t])
s = Wild('s', exclude=[x(t), y(t), z(t), t])
F1, F2, F3 = symbols('F1, F2, F3', cls=Wild)
r1 = eq[0].match(diff(x(t),t) - z(t)*F2 + y(t)*F3)
r = collect_const(r1[F2]).match(s*F2)
r.update(collect_const(r1[F3]).match(q*F3))
if eq[1].has(r[F2]) and not eq[1].has(r[F3]):
r[F2], r[F3] = r[F3], r[F2]
r[s], r[q] = -r[q], -r[s]
r.update((diff(y(t),t) - eq[1]).match(p*x(t)*r[F3] - r[s]*z(t)*F1))
a = r[p]; b = r[q]; c = r[s]
F1 = r[F1].subs(x(t),u).subs(y(t),v).subs(z(t),w)
F2 = r[F2].subs(x(t),u).subs(y(t),v).subs(z(t),w)
F3 = r[F3].subs(x(t),u).subs(y(t),v).subs(z(t),w)
x_yz = sqrt((C1 - b*v**2 - c*w**2)/a)
y_zx = sqrt((C1 - c*w**2 - a*u**2)/b)
z_xy = sqrt((C1 - a*u**2 - b*v**2)/c)
y_x = dsolve(diff(v(u),u) - ((a*u*F3-c*w*F1)/(c*w*F2-b*v*F3)).subs(w,z_xy).subs(v,v(u))).rhs
z_x = dsolve(diff(w(u),u) - ((b*v*F1-a*u*F2)/(c*w*F2-b*v*F3)).subs(v,y_zx).subs(w,w(u))).rhs
z_y = dsolve(diff(w(v),v) - ((b*v*F1-a*u*F2)/(a*u*F3-c*w*F1)).subs(u,x_yz).subs(w,w(v))).rhs
x_y = dsolve(diff(u(v),v) - ((c*w*F2-b*v*F3)/(a*u*F3-c*w*F1)).subs(w,z_xy).subs(u,u(v))).rhs
y_z = dsolve(diff(v(w),w) - ((a*u*F3-c*w*F1)/(b*v*F1-a*u*F2)).subs(u,x_yz).subs(v,v(w))).rhs
x_z = dsolve(diff(u(w),w) - ((c*w*F2-b*v*F3)/(b*v*F1-a*u*F2)).subs(v,y_zx).subs(u,u(w))).rhs
sol1 = dsolve(diff(u(t),t) - (c*w*F2 - b*v*F3).subs(v,y_x).subs(w,z_x).subs(u,u(t))).rhs
sol2 = dsolve(diff(v(t),t) - (a*u*F3 - c*w*F1).subs(u,x_y).subs(w,z_y).subs(v,v(t))).rhs
sol3 = dsolve(diff(w(t),t) - (b*v*F1 - a*u*F2).subs(u,x_z).subs(v,y_z).subs(w,w(t))).rhs
return [sol1, sol2, sol3]
def _nonlinear_3eq_order1_type5(x, y, z, t, eq):
r"""
.. math:: x' = x (c F_2 - b F_3), \enspace y' = y (a F_3 - c F_1), \enspace z' = z (b F_1 - a F_2)
where `F_n = F_n (x, y, z, t)` and are arbitrary functions.
First Integral:
.. math:: \left|x\right|^{a} \left|y\right|^{b} \left|z\right|^{c} = C_1
where `C` is an arbitrary constant. If the function `F_n` is independent of `t`,
then, by eliminating `t` and `z` from the first two equations of the system, one
arrives at a first-order equation.
References
==========
-http://eqworld.ipmnet.ru/en/solutions/sysode/sode0406.pdf
"""
C1 = get_numbered_constants(eq, num=1)
u, v, w = symbols('u, v, w')
p = Wild('p', exclude=[x(t), y(t), z(t), t])
q = Wild('q', exclude=[x(t), y(t), z(t), t])
s = Wild('s', exclude=[x(t), y(t), z(t), t])
F1, F2, F3 = symbols('F1, F2, F3', cls=Wild)
r1 = eq[0].match(diff(x(t), t) - x(t)*(F2 - F3))
r = collect_const(r1[F2]).match(s*F2)
r.update(collect_const(r1[F3]).match(q*F3))
if eq[1].has(r[F2]) and not eq[1].has(r[F3]):
r[F2], r[F3] = r[F3], r[F2]
r[s], r[q] = -r[q], -r[s]
r.update((diff(y(t), t) - eq[1]).match(y(t)*(p*r[F3] - r[s]*F1)))
a = r[p]; b = r[q]; c = r[s]
F1 = r[F1].subs(x(t), u).subs(y(t), v).subs(z(t), w)
F2 = r[F2].subs(x(t), u).subs(y(t), v).subs(z(t), w)
F3 = r[F3].subs(x(t), u).subs(y(t), v).subs(z(t), w)
x_yz = (C1*v**-b*w**-c)**-a
y_zx = (C1*w**-c*u**-a)**-b
z_xy = (C1*u**-a*v**-b)**-c
y_x = dsolve(diff(v(u), u) - ((v*(a*F3 - c*F1))/(u*(c*F2 - b*F3))).subs(w, z_xy).subs(v, v(u))).rhs
z_x = dsolve(diff(w(u), u) - ((w*(b*F1 - a*F2))/(u*(c*F2 - b*F3))).subs(v, y_zx).subs(w, w(u))).rhs
z_y = dsolve(diff(w(v), v) - ((w*(b*F1 - a*F2))/(v*(a*F3 - c*F1))).subs(u, x_yz).subs(w, w(v))).rhs
x_y = dsolve(diff(u(v), v) - ((u*(c*F2 - b*F3))/(v*(a*F3 - c*F1))).subs(w, z_xy).subs(u, u(v))).rhs
y_z = dsolve(diff(v(w), w) - ((v*(a*F3 - c*F1))/(w*(b*F1 - a*F2))).subs(u, x_yz).subs(v, v(w))).rhs
x_z = dsolve(diff(u(w), w) - ((u*(c*F2 - b*F3))/(w*(b*F1 - a*F2))).subs(v, y_zx).subs(u, u(w))).rhs
sol1 = dsolve(diff(u(t), t) - (u*(c*F2 - b*F3)).subs(v, y_x).subs(w, z_x).subs(u, u(t))).rhs
sol2 = dsolve(diff(v(t), t) - (v*(a*F3 - c*F1)).subs(u, x_y).subs(w, z_y).subs(v, v(t))).rhs
sol3 = dsolve(diff(w(t), t) - (w*(b*F1 - a*F2)).subs(u, x_z).subs(v, y_z).subs(w, w(t))).rhs
return [sol1, sol2, sol3]
| r"""
True if soln1 is found to be a special case of soln2 wrt some value of the
constants that appear in soln2. False otherwise.
"""
# The solutions returned by nth_algebraic should be given explicitly as in
# Eq(f(x), expr). We will equate the RHSs of the two solutions giving an
# equation f1(x) = f2(x).
#
# Since this is supposed to hold for all x it also holds for derivatives
# f1'(x) and f2'(x). For an order n ode we should be able to differentiate
# each solution n times to get n+1 equations.
#
# We then try to solve those n+1 equations for the integrations constants
# in f2(x). If we can find a solution that doesn't depend on x then it
# means that some value of the constants in f1(x) is a special case of
# f2(x) corresponding to a paritcular choice of the integration constants.
constants1 = soln1.free_symbols.difference(eq.free_symbols)
constants2 = soln2.free_symbols.difference(eq.free_symbols)
constants1_new = get_numbered_constants(soln1.rhs - soln2.rhs, len(constants1))
if len(constants1) == 1:
constants1_new = {constants1_new}
for c_old, c_new in zip(constants1, constants1_new):
soln1 = soln1.subs(c_old, c_new)
# n equations for f1(x)=f2(x), f1'(x)=f2'(x), ...
lhs = soln1.rhs.doit()
rhs = soln2.rhs.doit()
eqns = [Eq(lhs, rhs)]
for n in range(1, order):
lhs = lhs.diff(var)
rhs = rhs.diff(var)
eq = Eq(lhs, rhs)
eqns.append(eq)
# BooleanTrue/False awkwardly show up for trivial equations
if any(isinstance(eq, BooleanFalse) for eq in eqns):
return False
eqns = [eq for eq in eqns if not isinstance(eq, BooleanTrue)]
constant_solns = solve(eqns, constants2)
# Sometimes returns a dict and sometimes a list of dicts
if isinstance(constant_solns, dict):
constant_solns = [constant_solns]
# If any solution gives all constants as expressions that don't depend on
# x then there exists constants for soln2 that give soln1
for constant_soln in constant_solns:
if not any(c.has(var) for c in constant_soln.values()):
return True
return False |
nodebug.go | // Copyright (c) 2018 Timo Savola. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.
//go:build !((debug || indebug) && cgo)
// +build !debug,!indebug !cgo
package in
var (
debugPrinted bool
)
| debugPrinted = true
}
} | func debugPrintInsn([]byte) {
if !debugPrinted {
println("wag/internal/isa/amd64/in: debugPrintIn called in non-debug build") |
protection_container.py | # coding=utf-8
# *** WARNING: this file was generated by the Pulumi SDK Generator. ***
# *** Do not edit by hand unless you're certain you know what you are doing! ***
import warnings
import pulumi
import pulumi.runtime
from typing import Any, Mapping, Optional, Sequence, Union, overload
from ... import _utilities
from . import outputs
from ._enums import *
from ._inputs import *
__all__ = ['ProtectionContainerArgs', 'ProtectionContainer']
@pulumi.input_type
class ProtectionContainerArgs:
def __init__(__self__, *,
fabric_name: pulumi.Input[str],
resource_group_name: pulumi.Input[str],
vault_name: pulumi.Input[str],
container_name: Optional[pulumi.Input[str]] = None,
e_tag: Optional[pulumi.Input[str]] = None,
location: Optional[pulumi.Input[str]] = None,
properties: Optional[pulumi.Input[Union['AzureBackupServerContainerArgs', 'AzureIaaSClassicComputeVMContainerArgs', 'AzureIaaSComputeVMContainerArgs', 'AzureSQLAGWorkloadContainerProtectionContainerArgs', 'AzureSqlContainerArgs', 'AzureStorageContainerArgs', 'AzureVMAppContainerProtectionContainerArgs', 'AzureWorkloadContainerArgs', 'DpmContainerArgs', 'GenericContainerArgs', 'IaaSVMContainerArgs', 'MabContainerArgs']]] = None,
tags: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]] = None):
"""
The set of arguments for constructing a ProtectionContainer resource.
:param pulumi.Input[str] fabric_name: Fabric name associated with the container.
:param pulumi.Input[str] resource_group_name: The name of the resource group where the recovery services vault is present.
:param pulumi.Input[str] vault_name: The name of the recovery services vault.
:param pulumi.Input[str] container_name: Name of the container to be registered.
:param pulumi.Input[str] e_tag: Optional ETag.
:param pulumi.Input[str] location: Resource location.
:param pulumi.Input[Union['AzureBackupServerContainerArgs', 'AzureIaaSClassicComputeVMContainerArgs', 'AzureIaaSComputeVMContainerArgs', 'AzureSQLAGWorkloadContainerProtectionContainerArgs', 'AzureSqlContainerArgs', 'AzureStorageContainerArgs', 'AzureVMAppContainerProtectionContainerArgs', 'AzureWorkloadContainerArgs', 'DpmContainerArgs', 'GenericContainerArgs', 'IaaSVMContainerArgs', 'MabContainerArgs']] properties: ProtectionContainerResource properties
:param pulumi.Input[Mapping[str, pulumi.Input[str]]] tags: Resource tags.
"""
pulumi.set(__self__, "fabric_name", fabric_name)
pulumi.set(__self__, "resource_group_name", resource_group_name)
pulumi.set(__self__, "vault_name", vault_name)
if container_name is not None:
pulumi.set(__self__, "container_name", container_name)
if e_tag is not None:
pulumi.set(__self__, "e_tag", e_tag)
if location is not None:
pulumi.set(__self__, "location", location)
if properties is not None:
pulumi.set(__self__, "properties", properties)
if tags is not None:
pulumi.set(__self__, "tags", tags)
@property
@pulumi.getter(name="fabricName")
def fabric_name(self) -> pulumi.Input[str]:
"""
Fabric name associated with the container.
"""
return pulumi.get(self, "fabric_name")
@fabric_name.setter
def fabric_name(self, value: pulumi.Input[str]):
pulumi.set(self, "fabric_name", value)
@property
@pulumi.getter(name="resourceGroupName")
def resource_group_name(self) -> pulumi.Input[str]:
"""
The name of the resource group where the recovery services vault is present.
"""
return pulumi.get(self, "resource_group_name")
@resource_group_name.setter
def resource_group_name(self, value: pulumi.Input[str]):
pulumi.set(self, "resource_group_name", value)
@property
@pulumi.getter(name="vaultName")
def vault_name(self) -> pulumi.Input[str]:
"""
The name of the recovery services vault.
"""
return pulumi.get(self, "vault_name")
@vault_name.setter
def vault_name(self, value: pulumi.Input[str]):
pulumi.set(self, "vault_name", value)
@property
@pulumi.getter(name="containerName")
def container_name(self) -> Optional[pulumi.Input[str]]:
"""
Name of the container to be registered.
"""
return pulumi.get(self, "container_name")
@container_name.setter
def container_name(self, value: Optional[pulumi.Input[str]]):
pulumi.set(self, "container_name", value)
@property
@pulumi.getter(name="eTag")
def e_tag(self) -> Optional[pulumi.Input[str]]:
"""
Optional ETag.
"""
return pulumi.get(self, "e_tag")
@e_tag.setter
def e_tag(self, value: Optional[pulumi.Input[str]]):
pulumi.set(self, "e_tag", value)
@property
@pulumi.getter
def location(self) -> Optional[pulumi.Input[str]]:
"""
Resource location.
"""
return pulumi.get(self, "location")
@location.setter
def location(self, value: Optional[pulumi.Input[str]]):
pulumi.set(self, "location", value)
@property
@pulumi.getter
def properties(self) -> Optional[pulumi.Input[Union['AzureBackupServerContainerArgs', 'AzureIaaSClassicComputeVMContainerArgs', 'AzureIaaSComputeVMContainerArgs', 'AzureSQLAGWorkloadContainerProtectionContainerArgs', 'AzureSqlContainerArgs', 'AzureStorageContainerArgs', 'AzureVMAppContainerProtectionContainerArgs', 'AzureWorkloadContainerArgs', 'DpmContainerArgs', 'GenericContainerArgs', 'IaaSVMContainerArgs', 'MabContainerArgs']]]:
"""
ProtectionContainerResource properties
"""
return pulumi.get(self, "properties")
@properties.setter
def properties(self, value: Optional[pulumi.Input[Union['AzureBackupServerContainerArgs', 'AzureIaaSClassicComputeVMContainerArgs', 'AzureIaaSComputeVMContainerArgs', 'AzureSQLAGWorkloadContainerProtectionContainerArgs', 'AzureSqlContainerArgs', 'AzureStorageContainerArgs', 'AzureVMAppContainerProtectionContainerArgs', 'AzureWorkloadContainerArgs', 'DpmContainerArgs', 'GenericContainerArgs', 'IaaSVMContainerArgs', 'MabContainerArgs']]]):
pulumi.set(self, "properties", value)
@property
@pulumi.getter
def tags(self) -> Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]]:
"""
Resource tags.
"""
return pulumi.get(self, "tags")
@tags.setter
def tags(self, value: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]]):
pulumi.set(self, "tags", value)
class ProtectionContainer(pulumi.CustomResource):
@overload
def __init__(__self__,
resource_name: str,
opts: Optional[pulumi.ResourceOptions] = None,
container_name: Optional[pulumi.Input[str]] = None,
e_tag: Optional[pulumi.Input[str]] = None,
fabric_name: Optional[pulumi.Input[str]] = None,
location: Optional[pulumi.Input[str]] = None,
properties: Optional[pulumi.Input[Union[pulumi.InputType['AzureBackupServerContainerArgs'], pulumi.InputType['AzureIaaSClassicComputeVMContainerArgs'], pulumi.InputType['AzureIaaSComputeVMContainerArgs'], pulumi.InputType['AzureSQLAGWorkloadContainerProtectionContainerArgs'], pulumi.InputType['AzureSqlContainerArgs'], pulumi.InputType['AzureStorageContainerArgs'], pulumi.InputType['AzureVMAppContainerProtectionContainerArgs'], pulumi.InputType['AzureWorkloadContainerArgs'], pulumi.InputType['DpmContainerArgs'], pulumi.InputType['GenericContainerArgs'], pulumi.InputType['IaaSVMContainerArgs'], pulumi.InputType['MabContainerArgs']]]] = None,
resource_group_name: Optional[pulumi.Input[str]] = None,
tags: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]] = None,
vault_name: Optional[pulumi.Input[str]] = None,
__props__=None):
"""
Base class for container with backup items. Containers with specific workloads are derived from this class.
:param str resource_name: The name of the resource.
:param pulumi.ResourceOptions opts: Options for the resource.
:param pulumi.Input[str] container_name: Name of the container to be registered.
:param pulumi.Input[str] e_tag: Optional ETag.
:param pulumi.Input[str] fabric_name: Fabric name associated with the container.
:param pulumi.Input[str] location: Resource location.
:param pulumi.Input[Union[pulumi.InputType['AzureBackupServerContainerArgs'], pulumi.InputType['AzureIaaSClassicComputeVMContainerArgs'], pulumi.InputType['AzureIaaSComputeVMContainerArgs'], pulumi.InputType['AzureSQLAGWorkloadContainerProtectionContainerArgs'], pulumi.InputType['AzureSqlContainerArgs'], pulumi.InputType['AzureStorageContainerArgs'], pulumi.InputType['AzureVMAppContainerProtectionContainerArgs'], pulumi.InputType['AzureWorkloadContainerArgs'], pulumi.InputType['DpmContainerArgs'], pulumi.InputType['GenericContainerArgs'], pulumi.InputType['IaaSVMContainerArgs'], pulumi.InputType['MabContainerArgs']]] properties: ProtectionContainerResource properties
:param pulumi.Input[str] resource_group_name: The name of the resource group where the recovery services vault is present.
:param pulumi.Input[Mapping[str, pulumi.Input[str]]] tags: Resource tags.
:param pulumi.Input[str] vault_name: The name of the recovery services vault.
"""
...
@overload
def __init__(__self__,
resource_name: str,
args: ProtectionContainerArgs,
opts: Optional[pulumi.ResourceOptions] = None):
"""
Base class for container with backup items. Containers with specific workloads are derived from this class.
:param str resource_name: The name of the resource.
:param ProtectionContainerArgs args: The arguments to use to populate this resource's properties.
:param pulumi.ResourceOptions opts: Options for the resource.
"""
...
def | (__self__, resource_name: str, *args, **kwargs):
resource_args, opts = _utilities.get_resource_args_opts(ProtectionContainerArgs, pulumi.ResourceOptions, *args, **kwargs)
if resource_args is not None:
__self__._internal_init(resource_name, opts, **resource_args.__dict__)
else:
__self__._internal_init(resource_name, *args, **kwargs)
def _internal_init(__self__,
resource_name: str,
opts: Optional[pulumi.ResourceOptions] = None,
container_name: Optional[pulumi.Input[str]] = None,
e_tag: Optional[pulumi.Input[str]] = None,
fabric_name: Optional[pulumi.Input[str]] = None,
location: Optional[pulumi.Input[str]] = None,
properties: Optional[pulumi.Input[Union[pulumi.InputType['AzureBackupServerContainerArgs'], pulumi.InputType['AzureIaaSClassicComputeVMContainerArgs'], pulumi.InputType['AzureIaaSComputeVMContainerArgs'], pulumi.InputType['AzureSQLAGWorkloadContainerProtectionContainerArgs'], pulumi.InputType['AzureSqlContainerArgs'], pulumi.InputType['AzureStorageContainerArgs'], pulumi.InputType['AzureVMAppContainerProtectionContainerArgs'], pulumi.InputType['AzureWorkloadContainerArgs'], pulumi.InputType['DpmContainerArgs'], pulumi.InputType['GenericContainerArgs'], pulumi.InputType['IaaSVMContainerArgs'], pulumi.InputType['MabContainerArgs']]]] = None,
resource_group_name: Optional[pulumi.Input[str]] = None,
tags: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]] = None,
vault_name: Optional[pulumi.Input[str]] = None,
__props__=None):
if opts is None:
opts = pulumi.ResourceOptions()
if not isinstance(opts, pulumi.ResourceOptions):
raise TypeError('Expected resource options to be a ResourceOptions instance')
if opts.version is None:
opts.version = _utilities.get_version()
if opts.id is None:
if __props__ is not None:
raise TypeError('__props__ is only valid when passed in combination with a valid opts.id to get an existing resource')
__props__ = ProtectionContainerArgs.__new__(ProtectionContainerArgs)
__props__.__dict__["container_name"] = container_name
__props__.__dict__["e_tag"] = e_tag
if fabric_name is None and not opts.urn:
raise TypeError("Missing required property 'fabric_name'")
__props__.__dict__["fabric_name"] = fabric_name
__props__.__dict__["location"] = location
__props__.__dict__["properties"] = properties
if resource_group_name is None and not opts.urn:
raise TypeError("Missing required property 'resource_group_name'")
__props__.__dict__["resource_group_name"] = resource_group_name
__props__.__dict__["tags"] = tags
if vault_name is None and not opts.urn:
raise TypeError("Missing required property 'vault_name'")
__props__.__dict__["vault_name"] = vault_name
__props__.__dict__["name"] = None
__props__.__dict__["type"] = None
alias_opts = pulumi.ResourceOptions(aliases=[pulumi.Alias(type_="azure-nextgen:recoveryservices/v20210601:ProtectionContainer"), pulumi.Alias(type_="azure-native:recoveryservices:ProtectionContainer"), pulumi.Alias(type_="azure-nextgen:recoveryservices:ProtectionContainer"), pulumi.Alias(type_="azure-native:recoveryservices/v20161201:ProtectionContainer"), pulumi.Alias(type_="azure-nextgen:recoveryservices/v20161201:ProtectionContainer"), pulumi.Alias(type_="azure-native:recoveryservices/v20201001:ProtectionContainer"), pulumi.Alias(type_="azure-nextgen:recoveryservices/v20201001:ProtectionContainer"), pulumi.Alias(type_="azure-native:recoveryservices/v20201201:ProtectionContainer"), pulumi.Alias(type_="azure-nextgen:recoveryservices/v20201201:ProtectionContainer"), pulumi.Alias(type_="azure-native:recoveryservices/v20210101:ProtectionContainer"), pulumi.Alias(type_="azure-nextgen:recoveryservices/v20210101:ProtectionContainer"), pulumi.Alias(type_="azure-native:recoveryservices/v20210201:ProtectionContainer"), pulumi.Alias(type_="azure-nextgen:recoveryservices/v20210201:ProtectionContainer"), pulumi.Alias(type_="azure-native:recoveryservices/v20210201preview:ProtectionContainer"), pulumi.Alias(type_="azure-nextgen:recoveryservices/v20210201preview:ProtectionContainer"), pulumi.Alias(type_="azure-native:recoveryservices/v20210210:ProtectionContainer"), pulumi.Alias(type_="azure-nextgen:recoveryservices/v20210210:ProtectionContainer"), pulumi.Alias(type_="azure-native:recoveryservices/v20210301:ProtectionContainer"), pulumi.Alias(type_="azure-nextgen:recoveryservices/v20210301:ProtectionContainer"), pulumi.Alias(type_="azure-native:recoveryservices/v20210401:ProtectionContainer"), pulumi.Alias(type_="azure-nextgen:recoveryservices/v20210401:ProtectionContainer"), pulumi.Alias(type_="azure-native:recoveryservices/v20210701:ProtectionContainer"), pulumi.Alias(type_="azure-nextgen:recoveryservices/v20210701:ProtectionContainer")])
opts = pulumi.ResourceOptions.merge(opts, alias_opts)
super(ProtectionContainer, __self__).__init__(
'azure-native:recoveryservices/v20210601:ProtectionContainer',
resource_name,
__props__,
opts)
@staticmethod
def get(resource_name: str,
id: pulumi.Input[str],
opts: Optional[pulumi.ResourceOptions] = None) -> 'ProtectionContainer':
"""
Get an existing ProtectionContainer resource's state with the given name, id, and optional extra
properties used to qualify the lookup.
:param str resource_name: The unique name of the resulting resource.
:param pulumi.Input[str] id: The unique provider ID of the resource to lookup.
:param pulumi.ResourceOptions opts: Options for the resource.
"""
opts = pulumi.ResourceOptions.merge(opts, pulumi.ResourceOptions(id=id))
__props__ = ProtectionContainerArgs.__new__(ProtectionContainerArgs)
__props__.__dict__["e_tag"] = None
__props__.__dict__["location"] = None
__props__.__dict__["name"] = None
__props__.__dict__["properties"] = None
__props__.__dict__["tags"] = None
__props__.__dict__["type"] = None
return ProtectionContainer(resource_name, opts=opts, __props__=__props__)
@property
@pulumi.getter(name="eTag")
def e_tag(self) -> pulumi.Output[Optional[str]]:
"""
Optional ETag.
"""
return pulumi.get(self, "e_tag")
@property
@pulumi.getter
def location(self) -> pulumi.Output[Optional[str]]:
"""
Resource location.
"""
return pulumi.get(self, "location")
@property
@pulumi.getter
def name(self) -> pulumi.Output[str]:
"""
Resource name associated with the resource.
"""
return pulumi.get(self, "name")
@property
@pulumi.getter
def properties(self) -> pulumi.Output[Any]:
"""
ProtectionContainerResource properties
"""
return pulumi.get(self, "properties")
@property
@pulumi.getter
def tags(self) -> pulumi.Output[Optional[Mapping[str, str]]]:
"""
Resource tags.
"""
return pulumi.get(self, "tags")
@property
@pulumi.getter
def type(self) -> pulumi.Output[str]:
"""
Resource type represents the complete path of the form Namespace/ResourceType/ResourceType/...
"""
return pulumi.get(self, "type")
| __init__ |
smart_pointer_multi_typedef_runme.go | package main
import . "./smart_pointer_multi_typedef"
func main() {
f := NewFoo()
b := NewBar(f)
s := NewSpam(b)
g := NewGrok(b)
s.SetX(3)
if s.Getx() != 3 {
panic(0)
}
g.SetX(4)
if g.Getx() != 4 {
panic(0)
} | } | |
pagerank.go | package pagerank
/*
Vector Vector
*/
type Vector map[string]float64
/*
Matrix Matrix
*/
type Matrix map[string]Vector
/*
Get Get
*/
func (matrix Matrix) Get(src string, dst string) float64 {
_, ok := matrix[src]
if !ok {
return 0
}
return matrix[src][dst]
}
/*
Set Set
*/
func (matrix Matrix) Set(src string, dst string, value float64) {
if matrix[src] == nil {
matrix[src] = Vector{}
}
matrix[src][dst] = value
}
/*
GetStochastixMatrix GetStochastixMatrix
*/
func GetStochastixMatrix(linkMatrix Matrix) Matrix {
stochasticMatrix := Matrix{}
sum := Vector{}
node := map[string]bool{}
for src := range linkMatrix {
for dst := range linkMatrix[src] {
sum[src] += linkMatrix[src][dst]
node[dst] = true
}
node[src] = true
}
for src := range linkMatrix {
v := Vector{}
for dst, value := range linkMatrix[src] {
v[dst] = value / sum[src]
if linkMatrix[dst] == nil && stochasticMatrix[dst] == nil {
for n := range node {
stochasticMatrix.Set(dst, n, float64(1)/float64(len(node)))
}
}
}
stochasticMatrix[src] = v
}
return stochasticMatrix
}
/*
TransitionScore TransitionScore
*/
func TransitionScore(currentScoreVector Vector, stochasticMatrix Matrix) Vector {
if stochasticMatrix == nil || len(stochasticMatrix) == 0 |
if currentScoreVector == nil {
currentScoreVector = Vector{}
}
if len(currentScoreVector) == 0 {
s := float64(1) / float64(len(stochasticMatrix))
for src := range stochasticMatrix {
currentScoreVector[src] = s
}
}
score := Vector{}
for src := range stochasticMatrix {
for dst := range stochasticMatrix[src] {
dstCurrentScore := score[dst]
srcCurrentScore := currentScoreVector[src]
score[dst] = dstCurrentScore + srcCurrentScore*stochasticMatrix[src][dst]
}
}
return score
}
| {
return Vector{}
} |
token_search.rs | use token_search::{Token, TokenSearchConfig, TokenSearchResults};
fn main() | {
match Token::all() {
Ok((_, outcome)) => {
let mut config = TokenSearchConfig::default();
config.tokens = outcome;
let results = TokenSearchResults::generate_with_config(&config);
println!("{}", serde_json::to_string(&results).unwrap());
}
Err(e) => eprintln!("{}", e),
}
} |
|
b.js |
r(function(){
function sph2cart(azimuth, elevation, r) {
r *= ((1/696000) * (6.955e5/149598000)); // Convert from km to AU
return [r*Math.cos(elevation)*Math.cos(azimuth),r*Math.cos(elevation)*Math.sin(azimuth),r*Math.sin(elevation)];
}
// Set graph
var width = 800,
height = 700,
padding = 10
0;
var vis = d3.select("#graphics")
.append("svg")
.attr("width", width,)
.attr("height", height);
var fileNames = {earth : '/dat/Earth_2018_Oct_NONinert.txt', sol : '/dat/SolO_2018_Oct_NONinert.txt', spp : '/dat/SPP_2018_Oct_NONinert.txt'}
var fileData = {earth : [], sol : [], spp : []};
//due to async loading you cannot use a for loop here. FIX
d3.csv(fileNames['earth'], function(data) {
data.forEach(function(d) {
ret = sph2cart(d['lon'],d['lat'],d['rad_dist']);
fileData['earth'].push({ time : new Date(d['time']),
x : ret[0],
y : ret[1],
z : ret[2]
});
});
});
d3.csv(fileNames['sol'], function(data) {
data.forEach(function(d) {
ret = sph2cart(d['lon'],d['lat'],d['rad_dist']);
fileData[['sol']].push({ time : new Date(d['time']),
x : ret[0],
y : ret[1],
z : ret[2]
});
});
});
d3.csv(fileNames['spp'], function(data) {
data.forEach(function(d) {
ret = sph2cart(d['lon'],d['lat'],d['rad_dist']);
fileData[['spp']].push({ time : new Date(d['time']),
x : ret[0],
y : ret[1],
z : ret[2]
});
});
});
// Set the dimensions of the canvas / graph
var margin = {top: 30, right: 20, bottom: 30, left: 50},
width = 600 - margin.left - margin.right,
height = 270 - margin.top - margin.bottom;
// Set the ranges
var x = d3.scale.linear().range([0, width]);
var y = d3.scale.linear().range([height, 0]);
// Define the axes
var xAxis = d3.svg.axis().scale(x)
.orient("bottom").ticks(8);
var yAxis = d3.svg.axis().scale(y)
.orient("left").ticks(5);
// Define the line
var valueline = d3.svg.line()
.x(function(d) { return x(d.datax); })
.y(function(d) { return y(d.datay); });
// Adds the svg canvas
var svg = d3.select("body")
.append("svg")
.attr("width", width + margin.left + margin.right)
.attr("height", height + margin.top + margin.bottom)
.append("g")
.attr("transform",
"translate(" + margin.left + "," + margin.top + ")");
});
function | (f){/in/.test(document.readyState)?setTimeout('r('+f+')',9):f()} | r |
network.rs | // Copyright 2018 Parity Technologies (UK) Ltd.
//
// Permission is hereby granted, free of charge, to any person obtaining a
// copy of this software and associated documentation files (the "Software"),
// to deal in the Software without restriction, including without limitation
// the rights to use, copy, modify, merge, publish, distribute, sublicense,
// and/or sell copies of the Software, and to permit persons to whom the
// Software is furnished to do so, subject to the following conditions:
//
// The above copyright notice and this permission notice shall be included in
// all copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
// DEALINGS IN THE SOFTWARE.
mod event;
pub mod peer;
pub use event::{NetworkEvent, IncomingConnectionEvent};
pub use peer::Peer;
use crate::{
ConnectedPoint,
Executor,
Multiaddr,
PeerId,
address_translation,
connection::{
ConnectionId,
ConnectionLimit,
ConnectionHandler,
ConnectionInfo,
IntoConnectionHandler,
IncomingInfo,
OutgoingInfo,
ListenersEvent,
ListenerId,
ListenersStream,
PendingConnectionError,
Substream,
manager::ManagerConfig,
pool::{Pool, PoolEvent, PoolLimits},
},
muxing::StreamMuxer,
transport::{Transport, TransportError},
};
use fnv::{FnvHashMap};
use futures::{prelude::*, future};
use smallvec::SmallVec;
use std::{
collections::hash_map,
convert::TryFrom as _,
error,
fmt,
hash::Hash,
num::NonZeroUsize,
pin::Pin,
task::{Context, Poll},
};
/// Implementation of `Stream` that handles the nodes.
pub struct Network<TTrans, TInEvent, TOutEvent, THandler, TConnInfo = PeerId, TPeerId = PeerId>
where
TTrans: Transport,
THandler: IntoConnectionHandler<TConnInfo>,
{
/// The local peer ID.
local_peer_id: TPeerId,
/// Listeners for incoming connections.
listeners: ListenersStream<TTrans>,
/// The nodes currently active.
pool: Pool<TInEvent, TOutEvent, THandler, TTrans::Error,
<THandler::Handler as ConnectionHandler>::Error, TConnInfo, TPeerId>,
/// The ongoing dialing attempts.
///
/// There may be multiple ongoing dialing attempts to the same peer.
/// Each dialing attempt is associated with a new connection and hence
/// a new connection ID.
///
/// > **Note**: `dialing` must be consistent with the pending outgoing
/// > connections in `pool`. That is, for every entry in `dialing`
/// > there must exist a pending outgoing connection in `pool` with
/// > the same connection ID. This is ensured by the implementation of
/// > `Network` (see `dial_peer_impl` and `on_connection_failed`)
/// > together with the implementation of `DialingAttempt::abort`.
dialing: FnvHashMap<TPeerId, SmallVec<[peer::DialingState; 10]>>,
}
impl<TTrans, TInEvent, TOutEvent, THandler, TConnInfo, TPeerId> fmt::Debug for
Network<TTrans, TInEvent, TOutEvent, THandler, TConnInfo, TPeerId>
where
TTrans: fmt::Debug + Transport,
THandler: fmt::Debug + ConnectionHandler,
TConnInfo: fmt::Debug,
TPeerId: fmt::Debug + Eq + Hash,
{
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> Result<(), fmt::Error> {
f.debug_struct("ReachAttempts")
.field("local_peer_id", &self.local_peer_id)
.field("listeners", &self.listeners)
.field("peers", &self.pool)
.field("dialing", &self.dialing)
.finish()
}
}
impl<TTrans, TInEvent, TOutEvent, THandler, TConnInfo, TPeerId> Unpin for
Network<TTrans, TInEvent, TOutEvent, THandler, TConnInfo, TPeerId>
where
TTrans: Transport,
THandler: IntoConnectionHandler<TConnInfo>,
{
}
impl<TTrans, TInEvent, TOutEvent, THandler, TConnInfo, TPeerId>
Network<TTrans, TInEvent, TOutEvent, THandler, TConnInfo, TPeerId>
where
TTrans: Transport,
THandler: IntoConnectionHandler<TConnInfo>,
TConnInfo: ConnectionInfo<PeerId = TPeerId>,
TPeerId: Eq + Hash + Clone,
{
fn disconnect(&mut self, peer: &TPeerId) {
self.pool.disconnect(peer);
self.dialing.remove(peer);
}
}
impl<TTrans, TInEvent, TOutEvent, TMuxer, THandler, TConnInfo, TPeerId>
Network<TTrans, TInEvent, TOutEvent, THandler, TConnInfo, TPeerId>
where
TTrans: Transport + Clone,
TMuxer: StreamMuxer,
THandler: IntoConnectionHandler<TConnInfo> + Send + 'static,
THandler::Handler: ConnectionHandler<Substream = Substream<TMuxer>, InEvent = TInEvent, OutEvent = TOutEvent> + Send + 'static,
<THandler::Handler as ConnectionHandler>::OutboundOpenInfo: Send + 'static, // TODO: shouldn't be necessary
<THandler::Handler as ConnectionHandler>::Error: error::Error + Send + 'static,
TConnInfo: fmt::Debug + ConnectionInfo<PeerId = TPeerId> + Send + 'static,
TPeerId: Eq + Hash + Clone,
{
/// Creates a new node events stream.
pub fn new(
transport: TTrans,
local_peer_id: TPeerId,
config: NetworkConfig,
) -> Self {
let pool_local_id = local_peer_id.clone();
Network {
local_peer_id,
listeners: ListenersStream::new(transport),
pool: Pool::new(pool_local_id, config.manager_config, config.pool_limits),
dialing: Default::default(),
}
}
/// Returns the transport passed when building this object.
pub fn transport(&self) -> &TTrans {
self.listeners.transport()
}
/// Start listening on the given multiaddress.
pub fn listen_on(&mut self, addr: Multiaddr) -> Result<ListenerId, TransportError<TTrans::Error>> {
self.listeners.listen_on(addr)
}
/// Remove a previously added listener.
///
/// Returns `Ok(())` if a listener with this ID was in the list.
pub fn remove_listener(&mut self, id: ListenerId) -> Result<(), ()> {
self.listeners.remove_listener(id)
}
/// Returns an iterator that produces the list of addresses we are listening on.
pub fn listen_addrs(&self) -> impl Iterator<Item = &Multiaddr> {
self.listeners.listen_addrs()
}
/// Call this function in order to know which address remotes should dial to
/// access your local node.
///
/// When receiving an observed address on a tcp connection that we initiated, the observed
/// address contains our tcp dial port, not our tcp listen port. We know which port we are
/// listening on, thereby we can replace the port within the observed address.
///
/// When receiving an observed address on a tcp connection that we did **not** initiated, the
/// observed address should contain our listening port. In case it differs from our listening
/// port there might be a proxy along the path.
///
/// # Arguments
///
/// * `observed_addr` - should be an address a remote observes you as, which can be obtained for
/// example with the identify protocol.
///
pub fn address_translation<'a>(&'a self, observed_addr: &'a Multiaddr)
-> impl Iterator<Item = Multiaddr> + 'a
where
TMuxer: 'a,
THandler: 'a,
{
let mut addrs: Vec<_> = self.listen_addrs()
.filter_map(move |server| address_translation(server, observed_addr))
.collect();
// remove duplicates
addrs.sort_unstable();
addrs.dedup();
addrs.into_iter()
}
/// Returns the peer id of the local node.
pub fn local_peer_id(&self) -> &TPeerId {
&self.local_peer_id
}
/// Dials a multiaddress without expecting a particular remote peer ID.
///
/// The given `handler` will be used to create the
/// [`Connection`](crate::connection::Connection) upon success and the
/// connection ID is returned.
pub fn dial(&mut self, address: &Multiaddr, handler: THandler)
-> Result<ConnectionId, ConnectionLimit>
where
TTrans: Transport<Output = (TConnInfo, TMuxer)>,
TTrans::Error: Send + 'static,
TTrans::Dial: Send + 'static,
TMuxer: Send + Sync + 'static,
TMuxer::OutboundSubstream: Send,
TInEvent: Send + 'static,
TOutEvent: Send + 'static,
TConnInfo: Send + 'static,
TPeerId: Send + 'static,
{
let info = OutgoingInfo { address, peer_id: None };
match self.transport().clone().dial(address.clone()) {
Ok(f) => {
let f = f.map_err(|err| PendingConnectionError::Transport(TransportError::Other(err)));
self.pool.add_outgoing(f, handler, info)
}
Err(err) => {
let f = future::err(PendingConnectionError::Transport(err));
self.pool.add_outgoing(f, handler, info)
}
}
}
/// Returns information about the state of the `Network`.
pub fn info(&self) -> NetworkInfo {
let num_connections_established = self.pool.num_established();
let num_connections_pending = self.pool.num_pending();
let num_connections = num_connections_established + num_connections_pending;
let num_peers = self.pool.num_connected();
NetworkInfo {
num_peers,
num_connections,
num_connections_established,
num_connections_pending,
}
}
/// Returns an iterator for information on all pending incoming connections.
pub fn incoming_info(&self) -> impl Iterator<Item = IncomingInfo<'_>> {
self.pool.iter_pending_incoming()
}
/// Returns the list of addresses we're currently dialing without knowing the `PeerId` of.
pub fn unknown_dials(&self) -> impl Iterator<Item = &Multiaddr> {
self.pool.iter_pending_outgoing()
.filter_map(|info| {
if info.peer_id.is_none() {
Some(info.address)
} else {
None
}
})
}
/// Returns a list of all connected peers, i.e. peers to whom the `Network`
/// has at least one established connection.
pub fn connected_peers(&self) -> impl Iterator<Item = &TPeerId> {
self.pool.iter_connected()
}
/// Checks whether the network has an established connection to a peer.
pub fn is_connected(&self, peer: &TPeerId) -> bool {
self.pool.is_connected(peer)
}
/// Checks whether the network has an ongoing dialing attempt to a peer.
pub fn is_dialing(&self, peer: &TPeerId) -> bool {
self.dialing.contains_key(peer)
}
/// Checks whether the network has neither an ongoing dialing attempt,
/// nor an established connection to a peer.
pub fn is_disconnected(&self, peer: &TPeerId) -> bool {
!self.is_connected(peer) && !self.is_dialing(peer)
}
/// Returns a list of all the peers to whom a new outgoing connection
/// is currently being established.
pub fn dialing_peers(&self) -> impl Iterator<Item = &TPeerId> {
self.dialing.keys()
}
/// Gets the configured limit on pending incoming connections,
/// i.e. concurrent incoming connection attempts.
pub fn incoming_limit(&self) -> Option<usize> {
self.pool.limits().max_incoming
}
/// The total number of established connections in the `Network`.
pub fn num_connections_established(&self) -> usize {
self.pool.num_established()
}
/// The total number of pending connections in the `Network`.
pub fn num_connections_pending(&self) -> usize {
self.pool.num_pending()
}
/// Obtains a view of a [`Peer`] with the given ID in the network.
pub fn peer(&mut self, peer_id: TPeerId)
-> Peer<'_, TTrans, TInEvent, TOutEvent, THandler, TConnInfo, TPeerId>
{
Peer::new(self, peer_id)
}
/// Provides an API similar to `Stream`, except that it cannot error.
pub fn poll<'a>(&'a mut self, cx: &mut Context<'_>) -> Poll<NetworkEvent<'a, TTrans, TInEvent, TOutEvent, THandler, TConnInfo, TPeerId>>
where
TTrans: Transport<Output = (TConnInfo, TMuxer)>,
TTrans::Error: Send + 'static,
TTrans::Dial: Send + 'static,
TTrans::ListenerUpgrade: Send + 'static,
TMuxer: Send + Sync + 'static,
TMuxer::OutboundSubstream: Send,
TInEvent: Send + 'static,
TOutEvent: Send + 'static,
THandler: IntoConnectionHandler<TConnInfo> + Send + 'static,
THandler::Handler: ConnectionHandler<Substream = Substream<TMuxer>, InEvent = TInEvent, OutEvent = TOutEvent> + Send + 'static,
<THandler::Handler as ConnectionHandler>::Error: error::Error + Send + 'static,
TConnInfo: Clone,
TPeerId: Send + 'static,
{
// Poll the listener(s) for new connections.
match ListenersStream::poll(Pin::new(&mut self.listeners), cx) {
Poll::Pending => (),
Poll::Ready(ListenersEvent::Incoming {
listener_id,
upgrade,
local_addr,
send_back_addr
}) => {
return Poll::Ready(NetworkEvent::IncomingConnection(
IncomingConnectionEvent {
listener_id,
upgrade,
local_addr,
send_back_addr,
pool: &mut self.pool,
}))
}
Poll::Ready(ListenersEvent::NewAddress { listener_id, listen_addr }) => {
return Poll::Ready(NetworkEvent::NewListenerAddress { listener_id, listen_addr })
}
Poll::Ready(ListenersEvent::AddressExpired { listener_id, listen_addr }) => {
return Poll::Ready(NetworkEvent::ExpiredListenerAddress { listener_id, listen_addr })
}
Poll::Ready(ListenersEvent::Closed { listener_id, addresses, reason }) => {
return Poll::Ready(NetworkEvent::ListenerClosed { listener_id, addresses, reason })
}
Poll::Ready(ListenersEvent::Error { listener_id, error }) => {
return Poll::Ready(NetworkEvent::ListenerError { listener_id, error })
}
}
// Poll the known peers.
let event = match self.pool.poll(cx) {
Poll::Pending => return Poll::Pending,
Poll::Ready(PoolEvent::ConnectionEstablished { connection, num_established }) => {
match self.dialing.entry(connection.peer_id().clone()) {
hash_map::Entry::Occupied(mut e) => {
e.get_mut().retain(|s| s.current.0 != connection.id());
if e.get().is_empty() {
e.remove();
}
},
_ => {}
}
NetworkEvent::ConnectionEstablished {
connection,
num_established,
}
}
Poll::Ready(PoolEvent::PendingConnectionError { id, endpoint, error, handler, pool, .. }) => {
let dialing = &mut self.dialing;
let (next, event) = on_connection_failed(dialing, id, endpoint, error, handler);
if let Some(dial) = next {
let transport = self.listeners.transport().clone();
if let Err(e) = dial_peer_impl(transport, pool, dialing, dial) {
log::warn!("Dialing aborted: {:?}", e);
}
}
event
}
Poll::Ready(PoolEvent::ConnectionClosed { id, connected, error, num_established, .. }) => {
NetworkEvent::ConnectionClosed {
id,
connected,
num_established,
error,
}
}
Poll::Ready(PoolEvent::ConnectionEvent { connection, event }) => {
NetworkEvent::ConnectionEvent {
connection,
event,
}
}
Poll::Ready(PoolEvent::AddressChange { connection, new_endpoint, old_endpoint }) => {
NetworkEvent::AddressChange {
connection,
new_endpoint,
old_endpoint,
}
}
};
Poll::Ready(event)
}
/// Initiates a connection attempt to a known peer.
fn dial_peer(&mut self, opts: DialingOpts<TPeerId, THandler>)
-> Result<ConnectionId, ConnectionLimit>
where
TTrans: Transport<Output = (TConnInfo, TMuxer)>,
TTrans::Dial: Send + 'static,
TTrans::Error: Send + 'static,
TMuxer: Send + Sync + 'static,
TMuxer::OutboundSubstream: Send,
TInEvent: Send + 'static,
TOutEvent: Send + 'static,
TPeerId: Send + 'static,
{
dial_peer_impl(self.transport().clone(), &mut self.pool, &mut self.dialing, opts)
}
}
/// Options for a dialing attempt (i.e. repeated connection attempt
/// via a list of address) to a peer.
struct DialingOpts<TPeerId, THandler> {
peer: TPeerId,
handler: THandler,
address: Multiaddr,
remaining: Vec<Multiaddr>,
}
/// Standalone implementation of `Network::dial_peer` for more granular borrowing.
fn dial_peer_impl<TMuxer, TInEvent, TOutEvent, THandler, TTrans, TConnInfo, TPeerId>(
transport: TTrans,
pool: &mut Pool<TInEvent, TOutEvent, THandler, TTrans::Error,
<THandler::Handler as ConnectionHandler>::Error, TConnInfo, TPeerId>,
dialing: &mut FnvHashMap<TPeerId, SmallVec<[peer::DialingState; 10]>>,
opts: DialingOpts<TPeerId, THandler>
) -> Result<ConnectionId, ConnectionLimit>
where
THandler: IntoConnectionHandler<TConnInfo> + Send + 'static,
<THandler::Handler as ConnectionHandler>::Error: error::Error + Send + 'static,
<THandler::Handler as ConnectionHandler>::OutboundOpenInfo: Send + 'static,
THandler::Handler: ConnectionHandler<
Substream = Substream<TMuxer>,
InEvent = TInEvent,
OutEvent = TOutEvent,
> + Send + 'static,
TTrans: Transport<Output = (TConnInfo, TMuxer)>,
TTrans::Dial: Send + 'static,
TTrans::Error: error::Error + Send + 'static,
TMuxer: StreamMuxer + Send + Sync + 'static,
TMuxer::OutboundSubstream: Send + 'static,
TInEvent: Send + 'static,
TOutEvent: Send + 'static,
TPeerId: Eq + Hash + Send + Clone + 'static,
TConnInfo: ConnectionInfo<PeerId = TPeerId> + Send + 'static,
{
let result = match transport.dial(opts.address.clone()) {
Ok(fut) => {
let fut = fut.map_err(|e| PendingConnectionError::Transport(TransportError::Other(e)));
let info = OutgoingInfo { address: &opts.address, peer_id: Some(&opts.peer) };
pool.add_outgoing(fut, opts.handler, info)
},
Err(err) => {
let fut = future::err(PendingConnectionError::Transport(err));
let info = OutgoingInfo { address: &opts.address, peer_id: Some(&opts.peer) };
pool.add_outgoing(fut, opts.handler, info)
},
};
if let Ok(id) = &result {
dialing.entry(opts.peer).or_default().push(
peer::DialingState {
current: (*id, opts.address),
remaining: opts.remaining,
},
);
}
result
}
/// Callback for handling a failed connection attempt, returning an
/// event to emit from the `Network`.
///
/// If the failed connection attempt was a dialing attempt and there
/// are more addresses to try, new `DialingOpts` are returned.
fn on_connection_failed<'a, TTrans, TInEvent, TOutEvent, THandler, TConnInfo, TPeerId>(
dialing: &mut FnvHashMap<TPeerId, SmallVec<[peer::DialingState; 10]>>,
id: ConnectionId,
endpoint: ConnectedPoint,
error: PendingConnectionError<TTrans::Error>,
handler: Option<THandler>,
) -> (Option<DialingOpts<TPeerId, THandler>>, NetworkEvent<'a, TTrans, TInEvent, TOutEvent, THandler, TConnInfo, TPeerId>)
where
TTrans: Transport,
THandler: IntoConnectionHandler<TConnInfo>,
TConnInfo: ConnectionInfo<PeerId = TPeerId> + Send + 'static,
TPeerId: Eq + Hash + Clone,
{
// Check if the failed connection is associated with a dialing attempt.
let dialing_failed = dialing.iter_mut()
.find_map(|(peer, attempts)| {
if let Some(pos) = attempts.iter().position(|s| s.current.0 == id) {
let attempt = attempts.remove(pos);
let last = attempts.is_empty();
Some((peer.clone(), attempt, last))
} else {
None
}
});
if let Some((peer_id, mut attempt, last)) = dialing_failed {
if last {
dialing.remove(&peer_id);
}
let num_remain = u32::try_from(attempt.remaining.len()).unwrap();
let failed_addr = attempt.current.1.clone();
let (opts, attempts_remaining) =
if num_remain > 0 {
if let Some(handler) = handler {
let next_attempt = attempt.remaining.remove(0);
let opts = DialingOpts {
peer: peer_id.clone(),
handler,
address: next_attempt,
remaining: attempt.remaining
};
(Some(opts), num_remain)
} else {
// The error is "fatal" for the dialing attempt, since
// the handler was already consumed. All potential
// remaining connection attempts are thus void.
(None, 0)
}
} else {
(None, 0)
};
(opts, NetworkEvent::DialError {
attempts_remaining,
peer_id,
multiaddr: failed_addr,
error,
})
} else {
// A pending incoming connection or outgoing connection to an unknown peer failed.
match endpoint {
ConnectedPoint::Dialer { address } =>
(None, NetworkEvent::UnknownPeerDialError {
multiaddr: address,
error,
}),
ConnectedPoint::Listener { local_addr, send_back_addr } =>
(None, NetworkEvent::IncomingConnectionError {
local_addr,
send_back_addr,
error
})
}
}
}
/// Information about the network obtained by [`Network::info()`].
#[derive(Clone, Debug)]
pub struct NetworkInfo {
/// The total number of connected peers.
pub num_peers: usize,
/// The total number of connections, both established and pending.
pub num_connections: usize,
/// The total number of pending connections, both incoming and outgoing.
pub num_connections_pending: usize,
/// The total number of established connections.
pub num_connections_established: usize,
}
/// The (optional) configuration for a [`Network`].
///
/// The default configuration specifies no dedicated task executor, no
/// connection limits, a connection event buffer size of 32, and a
/// `notify_handler` buffer size of 8.
#[derive(Default)]
pub struct NetworkConfig {
/// Note that the `ManagerConfig`s task command buffer always provides
/// one "free" slot per task. Thus the given total `notify_handler_buffer_size`
/// exposed for configuration on the `Network` is reduced by one.
manager_config: ManagerConfig,
pool_limits: PoolLimits,
}
impl NetworkConfig {
pub fn set_executor(&mut self, e: Box<dyn Executor + Send>) -> &mut Self {
self.manager_config.executor = Some(e);
self
}
pub fn executor(&self) -> Option<&Box<dyn Executor + Send>> {
self.manager_config.executor.as_ref()
}
/// Sets the maximum number of events sent to a connection's background task
/// that may be buffered, if the task cannot keep up with their consumption and
/// delivery to the connection handler.
///
/// When the buffer for a particular connection is full, `notify_handler` will no
/// longer be able to deliver events to the associated `ConnectionHandler`,
/// thus exerting back-pressure on the connection and peer API.
pub fn set_notify_handler_buffer_size(&mut self, n: NonZeroUsize) -> &mut Self {
self.manager_config.task_command_buffer_size = n.get() - 1;
self
}
/// Sets the maximum number of buffered connection events (beyond a guaranteed
/// buffer of 1 event per connection).
///
/// When the buffer is full, the background tasks of all connections will stall.
/// In this way, the consumers of network events exert back-pressure on
/// the network connection I/O.
pub fn set_connection_event_buffer_size(&mut self, n: usize) -> &mut Self {
self.manager_config.task_event_buffer_size = n;
self
}
pub fn set_incoming_limit(&mut self, n: usize) -> &mut Self {
self.pool_limits.max_incoming = Some(n);
self
}
pub fn set_outgoing_limit(&mut self, n: usize) -> &mut Self {
self.pool_limits.max_outgoing = Some(n);
self
}
pub fn set_established_per_peer_limit(&mut self, n: usize) -> &mut Self {
self.pool_limits.max_established_per_peer = Some(n);
self
}
pub fn | (&mut self, n: usize) -> &mut Self {
self.pool_limits.max_outgoing_per_peer = Some(n);
self
}
}
#[cfg(test)]
mod tests {
use super::*;
struct Dummy;
impl Executor for Dummy {
fn exec(&self, _: Pin<Box<dyn Future<Output=()> + Send>>) { }
}
#[test]
fn set_executor() {
NetworkConfig::default()
.set_executor(Box::new(Dummy))
.set_executor(Box::new(|f| {
async_std::task::spawn(f);
}));
}
}
| set_outgoing_per_peer_limit |
remotewriter.go | // Diode Network Client
// Copyright 2019 IoT Blockchain Technology Corporation LLC (IBTC)
// Licensed under the Diode License, Version 1.0
package rpc
// remoteWriter Writes data to the remote end of a ConnectedPort
type remoteWriter struct {
port *ConnectedPort
}
// Write binary data to the connectionn
func (c *remoteWriter) Write(data []byte) (n int, err error) {
err = c.port.SendRemote(data) | }
return
} | if err == nil {
n = len(data) |
azuremachine_types.go | /*
Copyright 2019 The Kubernetes Authors.
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*/
package v1alpha3
import (
v1 "k8s.io/api/core/v1"
metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
clusterv1 "sigs.k8s.io/cluster-api/api/v1alpha3"
"sigs.k8s.io/cluster-api/errors"
)
const (
// MachineFinalizer allows ReconcileAzureMachine to clean up Azure resources associated with AzureMachine before
// removing it from the apiserver.
MachineFinalizer = "azuremachine.infrastructure.cluster.x-k8s.io"
)
// AzureMachineSpec defines the desired state of AzureMachine
type AzureMachineSpec struct {
// ProviderID is the unique identifier as specified by the cloud provider.
// +optional
ProviderID *string `json:"providerID,omitempty"`
VMSize string `json:"vmSize"`
// FailureDomain is the failure domain unique identifier this Machine should be attached to,
// as defined in Cluster API. This relates to an Azure Availability Zone
FailureDomain *string `json:"failureDomain,omitempty"`
// DEPRECATED: use FailureDomain instead
AvailabilityZone AvailabilityZone `json:"availabilityZone,omitempty"`
// Image is used to provide details of an image to use during VM creation.
// If image details are omitted the image will default the Azure Marketplace "capi" offer,
// which is based on Ubuntu.
// +kubebuilder:validation:nullable
// +optional
Image *Image `json:"image,omitempty"`
// Identity is the type of identity used for the virtual machine.
// The type 'SystemAssigned' is an implicitly created identity.
// The generated identity will be assigned a Subscription contributor role.
// The type 'UserAssigned' is a standalone Azure resource provided by the user
// and assigned to the VM
// +kubebuilder:default=None
// +optional
Identity VMIdentity `json:"identity,omitempty"`
// UserAssignedIdentities is a list of standalone Azure identities provided by the user
// The lifecycle of a user-assigned identity is managed separately from the lifecycle of
// the AzureMachine.
// +optional
UserAssignedIdentities []UserAssignedIdentity `json:"userAssignedIdentities,omitempty"`
// OSDisk specifies the parameters for the operating system disk of the machine
OSDisk OSDisk `json:"osDisk"`
// DataDisk specifies the parameters that are used to add one or more data disks to the machine
DataDisks []DataDisk `json:"dataDisks,omitempty"`
// DEPRECATED: to support old clients, will be removed in v1alpha4
Location string `json:"location"`
SSHPublicKey string `json:"sshPublicKey"`
// AdditionalTags is an optional set of tags to add to an instance, in addition to the ones added by default by the
// Azure provider. If both the AzureCluster and the AzureMachine specify the same tag name with different values, the
// AzureMachine's value takes precedence.
// +optional
AdditionalTags Tags `json:"additionalTags,omitempty"`
// AllocatePublicIP allows the ability to create dynamic public ips for machines where this value is true.
// +optional
AllocatePublicIP bool `json:"allocatePublicIP,omitempty"`
// AcceleratedNetworking enables or disables Azure accelerated networking. If omitted, it will be set based on
// whether the requested VMSize supports accelerated networking.
// If AcceleratedNetworking is set to true with a VMSize that does not support it, Azure will return an error.
// +kubebuilder:validation:nullable
// +optional
AcceleratedNetworking *bool `json:"acceleratedNetworking,omitempty"`
// SpotVMOptions allows the ability to specify the Machine should use a Spot VM
// +optional
SpotVMOptions *SpotVMOptions `json:"spotVMOptions,omitempty"`
}
// SpotVMOptions defines the options relevant to running the Machine on Spot VMs
type SpotVMOptions struct {
// MaxPrice defines the maximum price the user is willing to pay for Spot VM instances
// +optional
// +kubebuilder:validation:Type=number
MaxPrice *string `json:"maxPrice,omitempty"`
}
// AzureMachineStatus defines the observed state of AzureMachine
type AzureMachineStatus struct {
// Ready is true when the provider resource is ready.
// +optional
Ready bool `json:"ready"`
// Addresses contains the Azure instance associated addresses.
Addresses []v1.NodeAddress `json:"addresses,omitempty"`
// VMState is the provisioning state of the Azure virtual machine.
// +optional
VMState *VMState `json:"vmState,omitempty"`
// ErrorReason will be set in the event that there is a terminal problem
// reconciling the Machine and will contain a succinct value suitable
// for machine interpretation.
//
// This field should not be set for transitive errors that a controller
// faces that are expected to be fixed automatically over
// time (like service outages), but instead indicate that something is
// fundamentally wrong with the Machine's spec or the configuration of
// the controller, and that manual intervention is required. Examples
// of terminal errors would be invalid combinations of settings in the
// spec, values that are unsupported by the controller, or the
// responsible controller itself being critically misconfigured.
//
// Any transient errors that occur during the reconciliation of Machines
// can be added as events to the Machine object and/or logged in the
// controller's output.
// +optional
FailureReason *errors.MachineStatusError `json:"failureReason,omitempty"`
// ErrorMessage will be set in the event that there is a terminal problem
// reconciling the Machine and will contain a more verbose string suitable
// for logging and human consumption.
//
// This field should not be set for transitive errors that a controller
// faces that are expected to be fixed automatically over
// time (like service outages), but instead indicate that something is
// fundamentally wrong with the Machine's spec or the configuration of
// the controller, and that manual intervention is required. Examples
// of terminal errors would be invalid combinations of settings in the
// spec, values that are unsupported by the controller, or the
// responsible controller itself being critically misconfigured.
//
// Any transient errors that occur during the reconciliation of Machines
// can be added as events to the Machine object and/or logged in the
// controller's output.
// +optional
FailureMessage *string `json:"failureMessage,omitempty"`
// Conditions defines current service state of the AzureMachine.
// +optional
Conditions clusterv1.Conditions `json:"conditions,omitempty"`
}
// +kubebuilder:object:root=true
// +kubebuilder:printcolumn:name="Ready",type="string",JSONPath=".status.ready",description="AzureMachine ready status"
// +kubebuilder:printcolumn:name="State",type="string",JSONPath=".status.vmState",description="Azure VM provisioning state"
// +kubebuilder:printcolumn:name="Cluster",type="string",priority=1,JSONPath=".metadata.labels.cluster\\.x-k8s\\.io/cluster-name",description="Cluster to which this AzureMachine belongs"
// +kubebuilder:printcolumn:name="Machine",type="string",priority=1,JSONPath=".metadata.ownerReferences[?(@.kind==\"Machine\")].name",description="Machine object to which this AzureMachine belongs"
// +kubebuilder:printcolumn:name="VM ID",type="string",priority=1,JSONPath=".spec.providerID",description="Azure VM ID"
// +kubebuilder:printcolumn:name="VM Size",type="string",priority=1,JSONPath=".spec.vmSize",description="Azure VM Size"
// +kubebuilder:resource:path=azuremachines,scope=Namespaced,categories=cluster-api
// +kubebuilder:storageversion
// +kubebuilder:subresource:status
// AzureMachine is the Schema for the azuremachines API
type AzureMachine struct {
metav1.TypeMeta `json:",inline"`
metav1.ObjectMeta `json:"metadata,omitempty"`
Spec AzureMachineSpec `json:"spec,omitempty"`
Status AzureMachineStatus `json:"status,omitempty"`
}
// +kubebuilder:object:root=true
// AzureMachineList contains a list of AzureMachine
type AzureMachineList struct {
metav1.TypeMeta `json:",inline"`
metav1.ListMeta `json:"metadata,omitempty"`
Items []AzureMachine `json:"items"`
}
// GetConditions returns the list of conditions for an AzureMachine API object.
func (m *AzureMachine) GetConditions() clusterv1.Conditions {
return m.Status.Conditions
}
// SetConditions will set the given conditions on an AzureMachine object
func (m *AzureMachine) SetConditions(conditions clusterv1.Conditions) {
m.Status.Conditions = conditions
}
func | () {
SchemeBuilder.Register(&AzureMachine{}, &AzureMachineList{})
}
| init |
channel_test.go | package state
import (
"testing"
)
func TestNewChannel(t *testing.T) {
ch := NewChannel("#test1")
if ch.Name != "#test1" {
t.Errorf("Channel not created correctly by NewChannel()")
}
if len(ch.nicks) != 0 || len(ch.lookup) != 0 {
t.Errorf("Channel maps contain data after NewChannel()")
}
}
func TestAddNick(t *testing.T) {
ch := NewChannel("#test1")
nk := NewNick("test1")
cp := new(ChanPrivs)
ch.addNick(nk, cp)
if len(ch.nicks) != 1 || len(ch.lookup) != 1 {
t.Errorf("Nick lists not updated correctly for add.")
}
if c, ok := ch.nicks[nk]; !ok || c != cp {
t.Errorf("Nick test1 not properly stored in nicks map.")
}
if n, ok := ch.lookup["test1"]; !ok || n != nk {
t.Errorf("Nick test1 not properly stored in lookup map.")
}
}
func | (t *testing.T) {
ch := NewChannel("#test1")
nk := NewNick("test1")
cp := new(ChanPrivs)
ch.addNick(nk, cp)
ch.delNick(nk)
if len(ch.nicks) != 0 || len(ch.lookup) != 0 {
t.Errorf("Nick lists not updated correctly for del.")
}
if c, ok := ch.nicks[nk]; ok || c != nil {
t.Errorf("Nick test1 not properly removed from nicks map.")
}
if n, ok := ch.lookup["#test1"]; ok || n != nil {
t.Errorf("Nick test1 not properly removed from lookup map.")
}
}
func TestChannelParseModes(t *testing.T) {
ch := NewChannel("#test1")
md := ch.Modes
// Channel modes can adjust channel privs too, so we need a Nick
nk := NewNick("test1")
cp := new(ChanPrivs)
ch.addNick(nk, cp)
// Test bools first.
if md.Private || md.Secret || md.ProtectedTopic || md.NoExternalMsg ||
md.Moderated || md.InviteOnly || md.OperOnly || md.SSLOnly {
t.Errorf("Modes for new channel set to true.")
}
// Flip some bits!
md.Private = true
md.NoExternalMsg = true
md.InviteOnly = true
// Flip some MOAR bits.
ch.ParseModes("+s-p+tm-i")
if md.Private || !md.Secret || !md.ProtectedTopic || !md.NoExternalMsg ||
!md.Moderated || md.InviteOnly || md.OperOnly || md.SSLOnly {
t.Errorf("Modes not flipped correctly by ParseModes.")
}
// Test numeric parsing (currently only channel limits)
if md.Limit != 0 {
t.Errorf("Limit for new channel not zero.")
}
// enable limit correctly
ch.ParseModes("+l", "256")
if md.Limit != 256 {
t.Errorf("Limit for channel not set correctly")
}
// enable limit incorrectly
ch.ParseModes("+l")
if md.Limit != 256 {
t.Errorf("Bad limit value caused limit to be unset.")
}
// disable limit correctly
ch.ParseModes("-l")
if md.Limit != 0 {
t.Errorf("Limit for channel not unset correctly")
}
// Test string parsing (currently only channel key)
if md.Key != "" {
t.Errorf("Key set for new channel.")
}
// enable key correctly
ch.ParseModes("+k", "foobar")
if md.Key != "foobar" {
t.Errorf("Key for channel not set correctly")
}
// enable key incorrectly
ch.ParseModes("+k")
if md.Key != "foobar" {
t.Errorf("Bad key value caused key to be unset.")
}
// disable key correctly
ch.ParseModes("-k")
if md.Key != "" {
t.Errorf("Key for channel not unset correctly")
}
// Test chan privs parsing.
cp.Op = true
cp.HalfOp = true
ch.ParseModes("+aq-o", "test1", "test1", "test1")
if !cp.Owner || !cp.Admin || cp.Op || !cp.HalfOp || cp.Voice {
t.Errorf("Channel privileges not flipped correctly by ParseModes.")
}
// Test a random mix of modes, just to be sure
md.Limit = 256
ch.ParseModes("+zpt-qsl+kv-h", "test1", "foobar", "test1")
if !md.Private || md.Secret || !md.ProtectedTopic || !md.NoExternalMsg ||
!md.Moderated || md.InviteOnly || md.OperOnly || !md.SSLOnly {
t.Errorf("Modes not flipped correctly by ParseModes (2).")
}
if md.Limit != 0 || md.Key != "foobar" {
t.Errorf("Key and limit not changed correctly by ParseModes (2).")
}
if cp.Owner || !cp.Admin || cp.Op || !cp.HalfOp || !cp.Voice {
// NOTE: HalfOp not actually unset above thanks to deliberate error.
t.Errorf("Channel privileges not flipped correctly by ParseModes (2).")
}
}
| TestDelNick |
10-es2015.8151dded4819fe86b6ee.js | (window.webpackJsonp=window.webpackJsonp||[]).push([[10],{eyxc:function(n,e,t){"use strict";t.r(e),t.d(e,"DistinctuntilchangedModule",(function(){return v}));var i=t("iInd");class c{constructor(){this.fruits=["banana","apple","apple","banana","banana"],this.expectedFruits=["banana","apple","banana"],this.code='const fruits = from([\n "banana",\n "apple",\n "apple",\n "banana",\n "banana"]);\n\nfruits.pipe(\n\t\n).subscribe(fruit => toConveyorBelt(fruit));\n',this.minPositionLineNumber=8,this.positionColumnNumber=2}}var a=t("8Y7J"),r=t("VIrA"),s=t("TSSN"),o=t("SVse"),p=t("dJsq"),b=t("uzYf");function d(n,e){if(1&n&&(a.Mb(0,"div"),a.Mb(1,"p"),a.pc(2,"Eins nach dem anderen! Einige Fr\xfcchte kommen doppelt hintereinander. Wir brauchen allerdings die Fr\xfcchte abwechselnd."),a.Lb(),a.Mb(3,"p"),a.pc(4,"In unserem Fall hilft uns der "),a.Mb(5,"code",4),a.pc(6,"distinctUntilChanged"),a.Lb(),a.pc(7,"-Operator. Er verhindert, dass in unserem Datenstrom doppelte Fr\xfcchte direkt hintereinander geliefert werden. "),a.Mb(8,"a",5),a.pc(9,"(Mehr Infos zu distinctUntilChanged)"),a.Lb(),a.Lb(),a.Lb()),2&n){a.Yb();const n=a.fc(8);a.zb(5),a.dc("appTooltip",n)}}function u(n,e){if(1&n&&(a.Mb(0,"div"),a.Mb(1,"p"),a.pc(2,"One after the other! Some fruits come twice in a row. However, we need the fruits alternately."),a.Lb(),a.Mb(3,"p"),a.pc(4,"In our case, the "),a.Mb(5,"code",4),a.pc(6,"distinctUntilChanged"),a.Lb(),a.pc(7," operator helps us. It prevents duplicate fruits from being delivered one after the other in our data stream. "),a.Mb(8,"a",5),a.pc(9,"(Learn more about distinctUntilChanged)"),a.Lb(),a.Lb(),a.Lb()),2&n){a.Yb();const n=a.fc(8);a.zb(5),a.dc("appTooltip",n)}}function l(n,e){if(1&n&&(a.Mb(0,"div"),a.Mb(1,"p"),a.pc(2,"\u6c34\u679c\u4f1a\u4e00\u4e2a\u63a5\u4e00\u4e2a\u5730\u51fa\u73b0\uff0c\u6709\u4e9b\u6c34\u679c\u8fde\u7eed\u51fa\u73b0\u4e86\u4e24\u6b21\u3002\u4f46\u662f\uff0c\u6211\u4eec\u9700\u8981\u4ea4\u66ff\u4f7f\u7528\u4e0d\u540c\u7684\u6c34\u679c\u3002"),a.Lb(),a.Mb(3,"p"),a.pc(4,"\u5728\u8fd9\u4e2a\u4f8b\u5b50\u4e2d\uff0c"),a.Mb(5,"code",4),a.pc(6,"distinctUntilChanged"),a.Lb(),a.pc(7," \u64cd\u4f5c\u7b26\u53ef\u4ee5\u4e3a\u6211\u4eec\u63d0\u4f9b\u5e2e\u52a9\u3002\u5b83\u53ef\u4ee5\u9632\u6b62\u91cd\u590d\u7684\u6c34\u679c\u5728\u6570\u636e\u6d41\u4e2d\u8fde\u7eed\u5730\u4f20\u9012\u3002 "),a.Mb(8,"a",5),a.pc(9,"\uff08\u4e86\u89e3\u5173\u4e8e distinctUntilChanged \u64cd\u4f5c\u7b26\u7684\u66f4\u591a\u4fe1\u606f\uff09"),a.Lb(),a.Lb(),a.Lb()),2&n){a.Yb();const n=a.fc(8);a.zb(5),a.dc("appTooltip",n)}}function h(n,e){if(1&n&&(a.Mb(0,"div"),a.Mb(1,"p"),a.pc(2,"\u041e\u0434\u0438\u043d \u0437\u0430 \u0434\u0440\u0443\u0433\u0438\u043c! \u041d\u0435\u043a\u043e\u0442\u043e\u0440\u044b\u0435 \u0444\u0440\u0443\u043a\u0442\u044b \u043f\u043e\u044f\u0432\u043b\u044f\u044e\u0442\u0441\u044f \u0434\u0432\u0430 \u0440\u0430\u0437\u0430 \u043f\u043e\u0434\u0440\u044f\u0434. \u041e\u0434\u043d\u0430\u043a\u043e \u043d\u0430\u043c \u043f\u043e\u043e\u0447\u0435\u0440\u0435\u0434\u043d\u043e \u043d\u0443\u0436\u043d\u044b \u0444\u0440\u0443\u043a\u0442\u044b."),a.Lb(),a.Mb(3,"p"),a.pc(4,"\u0412 \u043d\u0430\u0448\u0435\u043c \u0441\u043b\u0443\u0447\u0430\u0435 \u043d\u0430\u043c \u043f\u043e\u043c\u043e\u0433\u0430\u0435\u0442 \u043e\u043f\u0435\u0440\u0430\u0442\u043e\u0440 "),a.Mb(5,"code",4),a.pc(6,"distinctUntilChanged"),a.Lb(),a.pc(7,". \u042d\u0442\u043e \u043f\u0440\u0435\u0434\u043e\u0442\u0432\u0440\u0430\u0449\u0430\u0435\u0442 \u0434\u043e\u0441\u0442\u0430\u0432\u043a\u0443 \u043f\u043e\u0432\u0442\u043e\u0440\u044f\u044e\u0449\u0438\u0445\u0441\u044f \u0444\u0440\u0443\u043a\u0442\u043e\u0432 \u043e\u0434\u0438\u043d \u0437\u0430 \u0434\u0440\u0443\u0433\u0438\u043c \u0432 \u043d\u0430\u0448\u0435\u043c \u043f\u043e\u0442\u043e\u043a\u0435 \u0434\u0430\u043d\u043d\u044b\u0445. "),a.Mb(8,"a",5),a.pc(9,"(\u041f\u043e\u0434\u0440\u043e\u0431\u043d\u0435\u0435 \u043e DifferentUntilChanged)"),a.Lb(),a.Lb(),a.Lb()),2&n){a.Yb();const n=a.fc(8);a.zb(5),a.dc("appTooltip",n)}}const g=[{path:"",component:(()=>{class n{constructor(n,e){this.exerciseService=n,this.translateService=e,this.exerciseTitle="distinctUntilChanged",this.distinctUntilChangedCode="\n of(1, 1, 2, 1, 3, 4).pipe(\n distinctUntilChanged()\n ).subscribe(data => console.log(data));\n\n // Logs:\n // 1\n // 2\n // 1\n // 3\n // 4\n ",this.currentLanguage=""}ngOnInit(){this.exerciseService.newExercise(new c),this.currentLanguage=this.translateService.currentLang,this.onLangChangeSubscription=this.translateService.onLangChange.subscribe({next:()=>{this.currentLanguage=this.translateService.currentLang}})}ngOnDestroy(){this.onLangChangeSubscription.unsubscribe()}}return n.\u0275fac=function(e){return new(e||n)(a.Jb(r.a),a.Jb(s.d))},n.\u0275cmp=a.Db({type:n,selectors:[["app-distinctuntilchanged"]],decls:13,vars:9,consts:[[4,"ngIf"],[1,"tooltip","codeTooltip"],["tooltip",""],[3,"highlight"],[1,"help",3,"appTooltip"],["href","https://rxjs.dev/api/operators/distinctUntilChanged","target","_blank"]],template:function(n,e){1&n&&(a.Mb(0,"h3"),a.pc(1),a.Zb(2,"translate"),a.Lb(),a.oc(3,d,10,1,"div",0),a.oc(4,u,10,1,"div",0),a.oc(5,l,10,1,"div",0),a.oc(6,h,10,1,"div",0),a.Mb(7,"div",1,2),a.Mb(9,"pre"),a.pc(10," "),a.Kb(11,"code",3),a.pc(12,"\n "),a.Lb(),a.Lb()),2&n&&(a.zb(1),a.sc("",a.ac(2,7,"EXERCISES.EXERCISETITLE"),": ",e.exerciseTitle,""),a.zb(2),a.dc("ngIf","de"===e.currentLanguage),a.zb(1),a.dc("ngIf","en"===e.currentLanguage),a.zb(1),a.dc("ngIf","zh_CN"===e.currentLanguage),a.zb(1),a.dc("ngIf","ru"===e.currentLanguage),a.zb(5),a.dc("highlight",e.distinctUntilChangedCode))},directives:[o.j,p.b,b.a],pipes:[s.c],styles:[""]}),n})()}];let f=(()=>{class n{}return n.\u0275mod=a.Hb({type:n}),n.\u0275inj=a.Gb({factory:function(e){return new(e||n)},imports:[[i.d.forChild(g)],i.d]}),n})();var L=t("PCNd");let v=(()=>{class n{}return n.\u0275mod=a.Hb({type:n}),n.\u0275inj=a.Gb({factory:function(e){return new(e||n)},imports:[[L.a,f]]}),n})()}}]); |
||
board.py | from enum import IntEnum
class RentIdx(IntEnum):
DEFAULT = ONLY_DEED = RAILROAD_1 = UTILITY_1 = 0
GROUP_COMPLETE_NO_HOUSES = RAILROAD_2 = UTILITY_2 = 1
HOUSE_1 = RAILROAD_3 = 2
HOUSE_2 = RAILROAD_4 = 3
HOUSE_3 = 4
HOUSE_4 = 5
HOTEL = MAX = 6
HOUSE_TO_HOTEL = HOTEL - HOUSE_1 + 1
# Represents a position on the board
class MonopolyBoardPosition():
| def __init__(self, csv_row):
if len(csv_row) != 19:
raise ValueError("Invalid CSV used to create board position")
self.owner = None
self.is_mortgaged = False
self.position = int(csv_row[0])
self.name = csv_row[1].strip()
self.property_group = int(csv_row[2])
self.cost_to_buy = int(csv_row[3])
self.mortgage_value = int(csv_row[4])
# For properties: 0 = only deed, 1 = all deeds of same color, 2-4 = n-1 houses, 5 = hotel
# For railroads: represents the number of railroads owned by this user -1 (0-3)
# For utilities: represents the number of utilities owned by this user -1 (1-1)
self.rent_idx = RentIdx.DEFAULT
self.rents = [int(csv_row[5]), int(csv_row[6]), int(csv_row[7]), int(csv_row[8]), int(csv_row[9]),
int(csv_row[10]), int(csv_row[11])]
self.house_cost = int(csv_row[12])
self.is_property = bool(int(csv_row[13]))
self.is_chance = bool(int(csv_row[14]))
self.is_community_chest = bool(int(csv_row[15]))
self.is_railroad = bool(int(csv_row[16]))
self.is_utility = bool(int(csv_row[17]))
self.fine = int(csv_row[18])
# TODO: Add this field to CSV self.precomputed_landing_chance
def __str__(self):
if self.is_mortgaged:
return "[M][rent_idx" + str(self.rent_idx.value) + "]" + self.name
else:
return "[rent_idx " + str(self.rent_idx.value) + "]" + self.name
__repr__ = __str__ |
|
generic_test.go | package validation
import (
"strings"
"testing"
"gobackend/pkg/validation/field"
)
func TestIsDNS1123Label(t *testing.T) {
goodValues := []string{
"a", "ab", "abc", "a1", "a-1", "a--1--2--b",
"0", "01", "012", "1a", "1-a", "1--a--b--2",
strings.Repeat("a", 63),
}
for _, val := range goodValues {
if msgs := IsDNS1123Label(val); len(msgs) != 0 {
t.Errorf("expected true for '%s': %v", val, msgs)
}
}
badValues := []string{
"", "A", "ABC", "aBc", "A1", "A-1", "1-A",
"-", "a-", "-a", "1-", "-1",
"_", "a_", "_a", "a_b", "1_", "_1", "1_2",
".", "a.", ".a", "a.b", "1.", ".1", "1.2",
" ", "a ", " a", "a b", "1 ", " 1", "1 2",
strings.Repeat("a", 64),
}
for _, val := range badValues {
if msgs := IsDNS1123Label(val); len(msgs) == 0 {
t.Errorf("expected false for '%s'", val)
}
}
}
func TestIsDNS1123Subdomain(t *testing.T) {
goodValues := []string{
"a", "ab", "abc", "a1", "a-1", "a--1--2--b",
"0", "01", "012", "1a", "1-a", "1--a--b--2",
"a.a", "ab.a", "abc.a", "a1.a", "a-1.a", "a--1--2--b.a",
"a.1", "ab.1", "abc.1", "a1.1", "a-1.1", "a--1--2--b.1",
"0.a", "01.a", "012.a", "1a.a", "1-a.a", "1--a--b--2",
"0.1", "01.1", "012.1", "1a.1", "1-a.1", "1--a--b--2.1",
"a.b.c.d.e", "aa.bb.cc.dd.ee", "1.2.3.4.5", "11.22.33.44.55",
strings.Repeat("a", 253),
}
for _, val := range goodValues {
if msgs := IsDNS1123Subdomain(val); len(msgs) != 0 {
t.Errorf("expected true for '%s': %v", val, msgs)
}
}
badValues := []string{
"", "A", "ABC", "aBc", "A1", "A-1", "1-A",
"-", "a-", "-a", "1-", "-1",
"_", "a_", "_a", "a_b", "1_", "_1", "1_2",
".", "a.", ".a", "a..b", "1.", ".1", "1..2",
" ", "a ", " a", "a b", "1 ", " 1", "1 2",
"A.a", "aB.a", "ab.A", "A1.a", "a1.A",
"A.1", "aB.1", "A1.1", "1A.1",
"0.A", "01.A", "012.A", "1A.a", "1a.A",
"A.B.C.D.E", "AA.BB.CC.DD.EE", "a.B.c.d.e", "aa.bB.cc.dd.ee",
"a@b", "a,b", "a_b", "a;b",
"a:b", "a%b", "a?b", "a$b",
strings.Repeat("a", 254),
}
for _, val := range badValues {
if msgs := IsDNS1123Subdomain(val); len(msgs) == 0 {
t.Errorf("expected false for '%s'", val)
}
}
}
func TestIsValidPortNum(t *testing.T) {
goodValues := []int{1, 2, 1000, 16384, 32768, 65535}
for _, val := range goodValues {
if msgs := IsValidPortNum(val); len(msgs) != 0 {
t.Errorf("expected true for %d, got %v", val, msgs)
}
}
badValues := []int{0, -1, 65536, 100000}
for _, val := range badValues {
if msgs := IsValidPortNum(val); len(msgs) == 0 {
t.Errorf("expected false for %d", val)
}
}
}
func TestIsInRange(t *testing.T) {
goodValues := []struct {
value int
min int
max int
}{{1, 0, 10}, {5, 5, 20}, {25, 10, 25}}
for _, val := range goodValues {
if msgs := IsInRange(val.value, val.min, val.max); len(msgs) > 0 {
t.Errorf("expected no errors for %#v, but got %v", val, msgs)
}
}
| badValues := []struct {
value int
min int
max int
}{{1, 2, 10}, {5, -4, 2}, {25, 100, 120}}
for _, val := range badValues {
if msgs := IsInRange(val.value, val.min, val.max); len(msgs) == 0 {
t.Errorf("expected errors for %#v", val)
}
}
}
func TestIsQualifiedName(t *testing.T) {
successCases := []string{
"simple",
"now-with-dashes",
"1-starts-with-num",
"1234",
"simple/simple",
"now-with-dashes/simple",
"now-with-dashes/now-with-dashes",
"now.with.dots/simple",
"now-with.dashes-and.dots/simple",
"1-num.2-num/3-num",
"1234/5678",
"1.2.3.4/5678",
"Uppercase_Is_OK_123",
"example.com/Uppercase_Is_OK_123",
"requests.storage-foo",
strings.Repeat("a", 63),
strings.Repeat("a", 253) + "/" + strings.Repeat("b", 63),
}
for i := range successCases {
if errs := IsQualifiedName(successCases[i]); len(errs) != 0 {
t.Errorf("case[%d]: %q: expected success: %v", i, successCases[i], errs)
}
}
errorCases := []string{
"nospecialchars%^=@",
"cantendwithadash-",
"-cantstartwithadash-",
"only/one/slash",
"Example.com/abc",
"example_com/abc",
"example.com/",
"/simple",
strings.Repeat("a", 64),
strings.Repeat("a", 254) + "/abc",
}
for i := range errorCases {
if errs := IsQualifiedName(errorCases[i]); len(errs) == 0 {
t.Errorf("case[%d]: %q: expected failure", i, errorCases[i])
}
}
}
func TestIsValidIP(t *testing.T) {
goodValues := []string{
"::1",
"2a00:79e0:2:0:f1c3:e797:93c1:df80",
"::",
"2001:4860:4860::8888",
"::fff:1.1.1.1",
"1.1.1.1",
"1.1.1.01",
"255.0.0.1",
"1.0.0.0",
"0.0.0.0",
}
for _, val := range goodValues {
if msgs := IsValidIP(val); len(msgs) != 0 {
t.Errorf("expected true for %q: %v", val, msgs)
}
}
badValues := []string{
"[2001:db8:0:1]:80",
"myhost.mydomain",
"-1.0.0.0",
"[2001:db8:0:1]",
"a",
}
for _, val := range badValues {
if msgs := IsValidIP(val); len(msgs) == 0 {
t.Errorf("expected false for %q", val)
}
}
}
func TestIsValidIPv4Address(t *testing.T) {
goodValues := []string{
"1.1.1.1",
"1.1.1.01",
"255.0.0.1",
"1.0.0.0",
"0.0.0.0",
}
for _, val := range goodValues {
if msgs := IsValidIPv4Address(field.NewPath(""), val); len(msgs) != 0 {
t.Errorf("expected %q to be valid IPv4 address: %v", val, msgs)
}
}
badValues := []string{
"[2001:db8:0:1]:80",
"myhost.mydomain",
"-1.0.0.0",
"[2001:db8:0:1]",
"a",
"2001:4860:4860::8888",
"::fff:1.1.1.1",
"::1",
"2a00:79e0:2:0:f1c3:e797:93c1:df80",
"::",
}
for _, val := range badValues {
if msgs := IsValidIPv4Address(field.NewPath(""), val); len(msgs) == 0 {
t.Errorf("expected %q to be invalid IPv4 address", val)
}
}
}
func TestIsValidIPv6Address(t *testing.T) {
goodValues := []string{
"2001:4860:4860::8888",
"2a00:79e0:2:0:f1c3:e797:93c1:df80",
"2001:0db8:85a3:0000:0000:8a2e:0370:7334",
"::fff:1.1.1.1",
"::1",
"::",
}
for _, val := range goodValues {
if msgs := IsValidIPv6Address(field.NewPath(""), val); len(msgs) != 0 {
t.Errorf("expected %q to be valid IPv6 address: %v", val, msgs)
}
}
badValues := []string{
"1.1.1.1",
"1.1.1.01",
"255.0.0.1",
"1.0.0.0",
"0.0.0.0",
"[2001:db8:0:1]:80",
"myhost.mydomain",
"2001:0db8:85a3:0000:0000:8a2e:0370:7334:2001:0db8:85a3:0000:0000:8a2e:0370:7334",
"-1.0.0.0",
"[2001:db8:0:1]",
"a",
}
for _, val := range badValues {
if msgs := IsValidIPv6Address(field.NewPath(""), val); len(msgs) == 0 {
t.Errorf("expected %q to be invalid IPv6 address", val)
}
}
}
func TestIsValidPercent(t *testing.T) {
goodValues := []string{
"0%",
"00000%",
"1%",
"01%",
"99%",
"100%",
"101%",
}
for _, val := range goodValues {
if msgs := IsValidPercent(val); len(msgs) != 0 {
t.Errorf("expected true for %q: %v", val, msgs)
}
}
badValues := []string{
"",
"0",
"100",
"0.0%",
"99.9%",
"hundred",
" 1%",
"1% ",
"-0%",
"-1%",
"+1%",
}
for _, val := range badValues {
if msgs := IsValidPercent(val); len(msgs) == 0 {
t.Errorf("expected false for %q", val)
}
}
} | |
specialPermutations.ts | /** Get permutations where no number can be in original position */
/** https://www.geeksforgeeks.org/count-derangements-permutation-such-that-no-element-appears-in-its-original-position/ */
export function specialPermutations (xs: number[]): number {
if (xs.length <= 1) {
console.log("xs: ", xs)
return 1
}
const [first, ...rest] = xs
return rest.reduce((sum, nextNum) => {
const remaining = [first, ...rest.filter(x => x !== nextNum)]
console.log("xs: ", xs, "first: ", first, "num: ", nextNum, "remaining: ", remaining)
return sum += permutations(remaining)
}, 0)
}
export function permutations (xs: number[]): number {
if (xs.length <= 1) {
return 1
}
return xs.reduce((total, num) => {
const others = xs.filter(x => x !== num)
return total += permutations(others)
}, 0) | } | |
model_pci_device_all_of.go | /*
Cisco Intersight
Cisco Intersight is a management platform delivered as a service with embedded analytics for your Cisco and 3rd party IT infrastructure. This platform offers an intelligent level of management that enables IT organizations to analyze, simplify, and automate their environments in more advanced ways than the prior generations of tools. Cisco Intersight provides an integrated and intuitive management experience for resources in the traditional data center as well as at the edge. With flexible deployment options to address complex security needs, getting started with Intersight is quick and easy. Cisco Intersight has deep integration with Cisco UCS and HyperFlex systems allowing for remote deployment, configuration, and ongoing maintenance. The model-based deployment works for a single system in a remote location or hundreds of systems in a data center and enables rapid, standardized configuration and deployment. It also streamlines maintaining those systems whether you are working with small or very large configurations. The Intersight OpenAPI document defines the complete set of properties that are returned in the HTTP response. From that perspective, a client can expect that no additional properties are returned, unless these properties are explicitly defined in the OpenAPI document. However, when a client uses an older version of the Intersight OpenAPI document, the server may send additional properties because the software is more recent than the client. In that case, the client may receive properties that it does not know about. Some generated SDKs perform a strict validation of the HTTP response body against the OpenAPI document.
API version: 1.0.9-6484
Contact: [email protected]
*/
// Code generated by OpenAPI Generator (https://openapi-generator.tech); DO NOT EDIT.
package intersight
import (
"encoding/json"
)
// PciDeviceAllOf Definition of the list of properties defined in 'pci.Device', excluding properties defined in parent classes.
type PciDeviceAllOf struct {
// The fully-qualified name of the instantiated, concrete type. This property is used as a discriminator to identify the type of the payload when marshaling and unmarshaling data.
ClassId string `json:"ClassId"`
// The fully-qualified name of the instantiated, concrete type. The value should be the same as the 'ClassId' property.
ObjectType string `json:"ObjectType"`
// The running firmware version of the PCI device.
FirmwareVersion *string `json:"FirmwareVersion,omitempty"`
// The product identifier of the PCI device.
Pid *string `json:"Pid,omitempty"`
// The PCI slot id of the PCI device.
SlotId *string `json:"SlotId,omitempty"`
ComputeBlade *ComputeBladeRelationship `json:"ComputeBlade,omitempty"`
ComputeRackUnit *ComputeRackUnitRelationship `json:"ComputeRackUnit,omitempty"`
// An array of relationships to graphicsCard resources.
GraphicsCards []GraphicsCardRelationship `json:"GraphicsCards,omitempty"`
InventoryDeviceInfo *InventoryDeviceInfoRelationship `json:"InventoryDeviceInfo,omitempty"`
RegisteredDevice *AssetDeviceRegistrationRelationship `json:"RegisteredDevice,omitempty"`
AdditionalProperties map[string]interface{}
}
type _PciDeviceAllOf PciDeviceAllOf
// NewPciDeviceAllOf instantiates a new PciDeviceAllOf object
// This constructor will assign default values to properties that have it defined,
// and makes sure properties required by API are set, but the set of arguments
// will change when the set of required properties is changed
func NewPciDeviceAllOf(classId string, objectType string) *PciDeviceAllOf {
this := PciDeviceAllOf{}
this.ClassId = classId
this.ObjectType = objectType
return &this
}
// NewPciDeviceAllOfWithDefaults instantiates a new PciDeviceAllOf object
// This constructor will only assign default values to properties that have it defined,
// but it doesn't guarantee that properties required by API are set
func NewPciDeviceAllOfWithDefaults() *PciDeviceAllOf {
this := PciDeviceAllOf{}
var classId string = "pci.Device"
this.ClassId = classId
var objectType string = "pci.Device"
this.ObjectType = objectType
return &this
}
// GetClassId returns the ClassId field value
func (o *PciDeviceAllOf) GetClassId() string {
if o == nil {
var ret string
return ret
}
return o.ClassId
}
// GetClassIdOk returns a tuple with the ClassId field value
// and a boolean to check if the value has been set.
func (o *PciDeviceAllOf) GetClassIdOk() (*string, bool) {
if o == nil {
return nil, false
}
return &o.ClassId, true
}
// SetClassId sets field value
func (o *PciDeviceAllOf) SetClassId(v string) {
o.ClassId = v
}
// GetObjectType returns the ObjectType field value
func (o *PciDeviceAllOf) GetObjectType() string {
if o == nil {
var ret string
return ret
}
return o.ObjectType
}
// GetObjectTypeOk returns a tuple with the ObjectType field value
// and a boolean to check if the value has been set.
func (o *PciDeviceAllOf) GetObjectTypeOk() (*string, bool) {
if o == nil {
return nil, false
}
return &o.ObjectType, true
}
// SetObjectType sets field value
func (o *PciDeviceAllOf) SetObjectType(v string) {
o.ObjectType = v
}
// GetFirmwareVersion returns the FirmwareVersion field value if set, zero value otherwise.
func (o *PciDeviceAllOf) GetFirmwareVersion() string {
if o == nil || o.FirmwareVersion == nil {
var ret string
return ret
}
return *o.FirmwareVersion
}
// GetFirmwareVersionOk returns a tuple with the FirmwareVersion field value if set, nil otherwise
// and a boolean to check if the value has been set.
func (o *PciDeviceAllOf) GetFirmwareVersionOk() (*string, bool) {
if o == nil || o.FirmwareVersion == nil {
return nil, false
}
return o.FirmwareVersion, true
}
// HasFirmwareVersion returns a boolean if a field has been set.
func (o *PciDeviceAllOf) HasFirmwareVersion() bool {
if o != nil && o.FirmwareVersion != nil {
return true
}
return false
}
// SetFirmwareVersion gets a reference to the given string and assigns it to the FirmwareVersion field.
func (o *PciDeviceAllOf) SetFirmwareVersion(v string) {
o.FirmwareVersion = &v
}
// GetPid returns the Pid field value if set, zero value otherwise.
func (o *PciDeviceAllOf) GetPid() string {
if o == nil || o.Pid == nil {
var ret string
return ret
}
return *o.Pid
}
// GetPidOk returns a tuple with the Pid field value if set, nil otherwise
// and a boolean to check if the value has been set.
func (o *PciDeviceAllOf) GetPidOk() (*string, bool) {
if o == nil || o.Pid == nil {
return nil, false
}
return o.Pid, true
}
// HasPid returns a boolean if a field has been set.
func (o *PciDeviceAllOf) HasPid() bool {
if o != nil && o.Pid != nil {
return true
}
return false
}
// SetPid gets a reference to the given string and assigns it to the Pid field.
func (o *PciDeviceAllOf) SetPid(v string) {
o.Pid = &v
}
// GetSlotId returns the SlotId field value if set, zero value otherwise.
func (o *PciDeviceAllOf) GetSlotId() string {
if o == nil || o.SlotId == nil {
var ret string
return ret
}
return *o.SlotId
}
// GetSlotIdOk returns a tuple with the SlotId field value if set, nil otherwise
// and a boolean to check if the value has been set.
func (o *PciDeviceAllOf) GetSlotIdOk() (*string, bool) {
if o == nil || o.SlotId == nil {
return nil, false
}
return o.SlotId, true
}
// HasSlotId returns a boolean if a field has been set.
func (o *PciDeviceAllOf) HasSlotId() bool {
if o != nil && o.SlotId != nil {
return true
}
return false
}
// SetSlotId gets a reference to the given string and assigns it to the SlotId field.
func (o *PciDeviceAllOf) SetSlotId(v string) {
o.SlotId = &v
}
// GetComputeBlade returns the ComputeBlade field value if set, zero value otherwise.
func (o *PciDeviceAllOf) GetComputeBlade() ComputeBladeRelationship {
if o == nil || o.ComputeBlade == nil {
var ret ComputeBladeRelationship
return ret
}
return *o.ComputeBlade
}
// GetComputeBladeOk returns a tuple with the ComputeBlade field value if set, nil otherwise
// and a boolean to check if the value has been set.
func (o *PciDeviceAllOf) GetComputeBladeOk() (*ComputeBladeRelationship, bool) {
if o == nil || o.ComputeBlade == nil {
return nil, false
}
return o.ComputeBlade, true
}
// HasComputeBlade returns a boolean if a field has been set.
func (o *PciDeviceAllOf) HasComputeBlade() bool {
if o != nil && o.ComputeBlade != nil {
return true
}
return false
}
// SetComputeBlade gets a reference to the given ComputeBladeRelationship and assigns it to the ComputeBlade field.
func (o *PciDeviceAllOf) SetComputeBlade(v ComputeBladeRelationship) {
o.ComputeBlade = &v
}
// GetComputeRackUnit returns the ComputeRackUnit field value if set, zero value otherwise.
func (o *PciDeviceAllOf) GetComputeRackUnit() ComputeRackUnitRelationship {
if o == nil || o.ComputeRackUnit == nil {
var ret ComputeRackUnitRelationship
return ret
}
return *o.ComputeRackUnit
}
// GetComputeRackUnitOk returns a tuple with the ComputeRackUnit field value if set, nil otherwise
// and a boolean to check if the value has been set.
func (o *PciDeviceAllOf) GetComputeRackUnitOk() (*ComputeRackUnitRelationship, bool) {
if o == nil || o.ComputeRackUnit == nil {
return nil, false
}
return o.ComputeRackUnit, true
}
// HasComputeRackUnit returns a boolean if a field has been set.
func (o *PciDeviceAllOf) HasComputeRackUnit() bool {
if o != nil && o.ComputeRackUnit != nil {
return true
}
return false
}
// SetComputeRackUnit gets a reference to the given ComputeRackUnitRelationship and assigns it to the ComputeRackUnit field.
func (o *PciDeviceAllOf) SetComputeRackUnit(v ComputeRackUnitRelationship) {
o.ComputeRackUnit = &v
}
// GetGraphicsCards returns the GraphicsCards field value if set, zero value otherwise (both if not set or set to explicit null).
func (o *PciDeviceAllOf) GetGraphicsCards() []GraphicsCardRelationship {
if o == nil {
var ret []GraphicsCardRelationship
return ret
}
return o.GraphicsCards
}
// GetGraphicsCardsOk returns a tuple with the GraphicsCards field value if set, nil otherwise
// and a boolean to check if the value has been set.
// NOTE: If the value is an explicit nil, `nil, true` will be returned
func (o *PciDeviceAllOf) GetGraphicsCardsOk() (*[]GraphicsCardRelationship, bool) {
if o == nil || o.GraphicsCards == nil {
return nil, false
}
return &o.GraphicsCards, true
}
// HasGraphicsCards returns a boolean if a field has been set.
func (o *PciDeviceAllOf) HasGraphicsCards() bool {
if o != nil && o.GraphicsCards != nil {
return true
}
return false
}
// SetGraphicsCards gets a reference to the given []GraphicsCardRelationship and assigns it to the GraphicsCards field.
func (o *PciDeviceAllOf) SetGraphicsCards(v []GraphicsCardRelationship) {
o.GraphicsCards = v
}
// GetInventoryDeviceInfo returns the InventoryDeviceInfo field value if set, zero value otherwise.
func (o *PciDeviceAllOf) GetInventoryDeviceInfo() InventoryDeviceInfoRelationship {
if o == nil || o.InventoryDeviceInfo == nil {
var ret InventoryDeviceInfoRelationship
return ret
}
return *o.InventoryDeviceInfo
}
// GetInventoryDeviceInfoOk returns a tuple with the InventoryDeviceInfo field value if set, nil otherwise
// and a boolean to check if the value has been set.
func (o *PciDeviceAllOf) GetInventoryDeviceInfoOk() (*InventoryDeviceInfoRelationship, bool) {
if o == nil || o.InventoryDeviceInfo == nil {
return nil, false
}
return o.InventoryDeviceInfo, true
}
// HasInventoryDeviceInfo returns a boolean if a field has been set.
func (o *PciDeviceAllOf) HasInventoryDeviceInfo() bool {
if o != nil && o.InventoryDeviceInfo != nil {
return true
}
return false
}
// SetInventoryDeviceInfo gets a reference to the given InventoryDeviceInfoRelationship and assigns it to the InventoryDeviceInfo field.
func (o *PciDeviceAllOf) SetInventoryDeviceInfo(v InventoryDeviceInfoRelationship) {
o.InventoryDeviceInfo = &v
}
// GetRegisteredDevice returns the RegisteredDevice field value if set, zero value otherwise.
func (o *PciDeviceAllOf) GetRegisteredDevice() AssetDeviceRegistrationRelationship {
if o == nil || o.RegisteredDevice == nil {
var ret AssetDeviceRegistrationRelationship
return ret
}
return *o.RegisteredDevice
}
// GetRegisteredDeviceOk returns a tuple with the RegisteredDevice field value if set, nil otherwise
// and a boolean to check if the value has been set.
func (o *PciDeviceAllOf) GetRegisteredDeviceOk() (*AssetDeviceRegistrationRelationship, bool) {
if o == nil || o.RegisteredDevice == nil {
return nil, false
}
return o.RegisteredDevice, true
}
// HasRegisteredDevice returns a boolean if a field has been set.
func (o *PciDeviceAllOf) HasRegisteredDevice() bool {
if o != nil && o.RegisteredDevice != nil {
return true
}
return false
}
// SetRegisteredDevice gets a reference to the given AssetDeviceRegistrationRelationship and assigns it to the RegisteredDevice field.
func (o *PciDeviceAllOf) SetRegisteredDevice(v AssetDeviceRegistrationRelationship) {
o.RegisteredDevice = &v
}
func (o PciDeviceAllOf) MarshalJSON() ([]byte, error) {
toSerialize := map[string]interface{}{}
if true {
toSerialize["ClassId"] = o.ClassId
}
if true {
toSerialize["ObjectType"] = o.ObjectType
}
if o.FirmwareVersion != nil {
toSerialize["FirmwareVersion"] = o.FirmwareVersion
}
if o.Pid != nil {
toSerialize["Pid"] = o.Pid
}
if o.SlotId != nil {
toSerialize["SlotId"] = o.SlotId
}
if o.ComputeBlade != nil {
toSerialize["ComputeBlade"] = o.ComputeBlade
}
if o.ComputeRackUnit != nil {
toSerialize["ComputeRackUnit"] = o.ComputeRackUnit
}
if o.GraphicsCards != nil {
toSerialize["GraphicsCards"] = o.GraphicsCards
}
if o.InventoryDeviceInfo != nil {
toSerialize["InventoryDeviceInfo"] = o.InventoryDeviceInfo
}
if o.RegisteredDevice != nil {
toSerialize["RegisteredDevice"] = o.RegisteredDevice
}
for key, value := range o.AdditionalProperties {
toSerialize[key] = value
}
return json.Marshal(toSerialize)
}
func (o *PciDeviceAllOf) UnmarshalJSON(bytes []byte) (err error) {
varPciDeviceAllOf := _PciDeviceAllOf{}
if err = json.Unmarshal(bytes, &varPciDeviceAllOf); err == nil {
*o = PciDeviceAllOf(varPciDeviceAllOf)
}
additionalProperties := make(map[string]interface{})
if err = json.Unmarshal(bytes, &additionalProperties); err == nil {
delete(additionalProperties, "ClassId")
delete(additionalProperties, "ObjectType")
delete(additionalProperties, "FirmwareVersion")
delete(additionalProperties, "Pid")
delete(additionalProperties, "SlotId")
delete(additionalProperties, "ComputeBlade")
delete(additionalProperties, "ComputeRackUnit")
delete(additionalProperties, "GraphicsCards")
delete(additionalProperties, "InventoryDeviceInfo")
delete(additionalProperties, "RegisteredDevice")
o.AdditionalProperties = additionalProperties |
return err
}
type NullablePciDeviceAllOf struct {
value *PciDeviceAllOf
isSet bool
}
func (v NullablePciDeviceAllOf) Get() *PciDeviceAllOf {
return v.value
}
func (v *NullablePciDeviceAllOf) Set(val *PciDeviceAllOf) {
v.value = val
v.isSet = true
}
func (v NullablePciDeviceAllOf) IsSet() bool {
return v.isSet
}
func (v *NullablePciDeviceAllOf) Unset() {
v.value = nil
v.isSet = false
}
func NewNullablePciDeviceAllOf(val *PciDeviceAllOf) *NullablePciDeviceAllOf {
return &NullablePciDeviceAllOf{value: val, isSet: true}
}
func (v NullablePciDeviceAllOf) MarshalJSON() ([]byte, error) {
return json.Marshal(v.value)
}
func (v *NullablePciDeviceAllOf) UnmarshalJSON(src []byte) error {
v.isSet = true
return json.Unmarshal(src, &v.value)
} | } |
static.go | package web
import (
"bytes"
"compress/gzip"
"encoding/base64"
"io/ioutil"
"net/http"
"os"
"path"
"sync"
"time"
)
type _escLocalFS struct{}
var _escLocal _escLocalFS
type _escStaticFS struct{}
var _escStatic _escStaticFS
type _escDir struct {
fs http.FileSystem
name string
}
type _escFile struct {
compressed string
size int64
modtime int64
local string
isDir bool
data []byte
once sync.Once
name string
}
func (_escLocalFS) Open(name string) (http.File, error) {
f, present := _escData[path.Clean(name)]
if !present {
return nil, os.ErrNotExist
}
return os.Open(f.local)
}
func (_escStaticFS) prepare(name string) (*_escFile, error) {
f, present := _escData[path.Clean(name)]
if !present {
return nil, os.ErrNotExist
}
var err error
f.once.Do(func() {
f.name = path.Base(name)
if f.size == 0 {
return
}
var gr *gzip.Reader
b64 := base64.NewDecoder(base64.StdEncoding, bytes.NewBufferString(f.compressed))
gr, err = gzip.NewReader(b64)
if err != nil {
return
}
f.data, err = ioutil.ReadAll(gr)
})
if err != nil {
return nil, err
}
return f, nil
}
func (fs _escStaticFS) Open(name string) (http.File, error) {
f, err := fs.prepare(name)
if err != nil {
return nil, err
}
return f.File()
}
func (dir _escDir) Open(name string) (http.File, error) {
return dir.fs.Open(dir.name + name)
}
func (f *_escFile) File() (http.File, error) {
type httpFile struct {
*bytes.Reader
*_escFile
}
return &httpFile{
Reader: bytes.NewReader(f.data),
_escFile: f,
}, nil
}
func (f *_escFile) Close() error {
return nil
}
func (f *_escFile) Readdir(count int) ([]os.FileInfo, error) {
return nil, nil
}
func (f *_escFile) Stat() (os.FileInfo, error) {
return f, nil
}
func (f *_escFile) Name() string {
return f.name
}
func (f *_escFile) Size() int64 {
return f.size
}
func (f *_escFile) Mode() os.FileMode {
return 0
}
func (f *_escFile) ModTime() time.Time {
return time.Unix(f.modtime, 0)
}
func (f *_escFile) IsDir() bool {
return f.isDir
}
func (f *_escFile) Sys() interface{} {
return f
}
// FS returns a http.Filesystem for the embedded assets. If useLocal is true,
// the filesystem's contents are instead used.
func FS(useLocal bool) http.FileSystem {
if useLocal {
return _escLocal
}
return _escStatic
}
// Dir returns a http.Filesystem for the embedded assets on a given prefix dir.
// If useLocal is true, the filesystem's contents are instead used.
func Dir(useLocal bool, name string) http.FileSystem {
if useLocal {
return _escDir{fs: _escLocal, name: name}
}
return _escDir{fs: _escStatic, name: name}
}
// FSByte returns the named file from the embedded assets. If useLocal is
// true, the filesystem's contents are instead used.
func FSByte(useLocal bool, name string) ([]byte, error) {
if useLocal {
f, err := _escLocal.Open(name)
if err != nil {
return nil, err
}
return ioutil.ReadAll(f)
}
f, err := _escStatic.prepare(name)
if err != nil {
return nil, err
}
return f.data, nil
}
// FSMustByte is the same as FSByte, but panics if name is not present.
func FSMustByte(useLocal bool, name string) []byte {
b, err := FSByte(useLocal, name)
if err != nil {
panic(err)
}
return b
}
// FSString is the string version of FSByte.
func FSString(useLocal bool, name string) (string, error) {
b, err := FSByte(useLocal, name)
return string(b), err
}
// FSMustString is the string version of FSMustByte.
func FSMustString(useLocal bool, name string) string {
return string(FSMustByte(useLocal, name))
}
var _escData = map[string]*_escFile{
"/css/bootstrap.min.css": {
local: "web/static/css/bootstrap.min.css",
size: 109518,
modtime: 0,
compressed: `
H4sIAAAJbogA/+x9XZPjOI7g+/0KT3V0dNWU7ZL8mU5H583e7MbuROzsy83DRnTXXciWnNa0bHkkuT7a
5/vtx2+CICjJzqyOvYiejOnKJEEQBEACpEDwwx//8N8Gfxz8j7Js6qZKToNP0/FkHA3e7pvm9Pjhw3PW
bHTdeFse3nHoP5enr1X+vG8GkyiOR+w/s8HfPudNk1XDwV+O2zEH+vd8mx3rLB2cj2lWDf76l79JpDXH
mjf784bj+9B83tQfTBcfNkW5+XBIaobqw7//5c//8h//8194lx8YnYNjWR2SIv81G2/rmhMajePB/xGY
VWfsL4Z6nJcfDCxru28OxWVXHpvRLjnkxdfHOjnWozqr8t169Dnb/JI3oyb70oxqBj9K0r+f6+YxjqLv
16NDTddcN2X69XJIquf8+Bhdk6rJt0U2TOo8zYZp1iR5UQ93+fM2OTV5eeS/nqtsuGPjZDzaZ0nK/3mu
yvNpeEjy4/CYfBrW2VYA1+cDw/z1kub1qUi+PjKebH+5Juc0L4fb5PgpqYenqnyusroefmIdlgYyPxb5
MRuJButPGacqKUaMD8/Hx01SZ7xWIno8ls3bn7aMKVVZ1B/fGRTH8pit9xmXLhvYT/s8TbPjx2GTHVh1
kzlw1+SySba/8GEc08dowBjxmLAxfGKceNyXjIBLeW54p5xHm031U5M3RfbxsikrxoDRpmya8vAYn74M
UvZrll43Q6YG5fFZiuuzJGMZRdd0d5RldfO1yB7zhg1qe93HWgbjxTI7DKK1hGHSepxkhyur/OWyLYuy
evwuiqI1oPa73S661kxHlGqINg9MsvWZEXE+XU5lnXNxPFYZGzgbE8C9nH+/FpzWjAoym2NqytPjaDxn
9DDcFzXo0XjCS/LDs+IGY1H96VnI5bFievLuwhm4K8rPj1IIV6lEesQxG+8sOn257quLIUOr86b8winN
j8+PXMbZURQxfS5/DdXRxdcT69EQkpyb8rotmY7/skmZEmbDOjmcnLl1KI9lfUq22dD8BhjHiL5uzowB
x2F+PJ2bYXlq5Cxg/GLqP+SzLamyxMwt0Zgp9p5N12YtZan+UpgseZ/yOt8Ume5BoryICcwWl2O9Y4uC
VFwFwVeGgSDkp+brKftRFn8cgiI2y7LGKWFCPOTNx4vmdXI6ZQlDv80eZfv19lzVjMxTmTM+Vqqzn9jM
SRh16UfYrSm8qEZptkvOhR7b46MQ2a7cnutRfjyyVUO088svpyRNufCYlmt9EqAXqKhyWbyC0Wz32fYX
Jmh30AlbIuwIgWqYmesrE6iiSw2FsP/j+bDJqo9sQKozMZpRfcqPI6gpAWi2vrjQei4IVYVSYzLa7skx
vWyGrAk94Cq3y7MiJSiwtMuC0ZY3KYjBhhqk2basEr42UToo9Ft0zhTXaMV4ylabwXgxEf8s2X/XeoYN
JqcvWmf4UlyXRZ4O6rxg0+paZM/ZMaWUy8xUd3XQE9pbwRuu53rl5+sCxDdiE7tITnX2qH+5Numw2duO
r386ZGmeDE4Vm1SXP4JV/Q/54VRWTXJs1tJW75OUUcP5AKrA0i/WghOj/dgAAEcxaBShmmvC7B1ffJgJ
k8uNFdGjcH+k4f1pX2W7j4/JjunsRanQ45vB2zeDpGmqt7z23eDNuzfQVgahRbUCF4j/149v/p4w52Bb
5ScGqFoOTeV3bzxkb/jyPhTuwj/OzDW5eGrw3Wq1YhP3mTkVTNa/sNnJXZzH5FOZp9eGOzLGIxACHknf
ZiR04Nqw5YoZuFB7XndIvow+52mzF34V4OlpuJ8M99NLWZ32TF6P0zUDKz+zX66yAmAVw1JI1arvmvod
QDxmvtYmqVxPZiyoHzCl07/tAYqR0jaEaNMcn8ZbpkjNcJxW5el8egJlWteZ+R9R2nodF8kmKwieMzBF
0CU0PSAayXgJyfztZj/0ilKilzRNAZbrn5QV32aOPf/hX4uvp33OVKYe/FtS7JgmP9c/rOtq+3iuirfj
8QcOXX94NmCjvQYbVdnzuUiqccbcmdub/Pfv8myXf3k34HY7ad7+kLHFn3lC6ag8MfVlS+QP74b9MX4u
dzuLi/91U/OmAa2b6pzdTABz776zAP/bAKh6i50B/vDuOjawhC/KfUomyzXp+feQH/ClpU+whuv1jPnK
0G2Izeoo2x2Yf7rnyzLTnJx5vMzbTaXpLOsvGOa5Sr7WzDXOwIhGYoeX1788bjI26swuST9PkjcQ8FSc
awJo4wBl56okgKJk64Ad8iOJbBJPHLhtUZ5TAm4RxW63x09ZwXSRAF1GK3cY2XGbFyTgzgF8LpKaoDGL
UN+Hc51vSTh3LNJnIAGnDiBbuKuGhJu7CJnVJ8EWHtiIbRqbryTw0gE+s804CfbggO3y4kCCubxu9iM2
nZ4JsWRRHCFQEij28OU1yRukOCWhzwzIZXSVHZjLRALOHMBfy/LADCYJOfchmStMgrpyYcseCeUKpGab
2IRQVwboimRbPpNQSCJVUpOcnrji2JcHkjGTGOsBDeZKo8kD2JA8yoSY7AzMlQbzPY4FA2U7fJLPkzkJ
ToK6IjmfgoCuVPIjc0FJuAe0ZiZfR9u82gbYtEL6yPYO5JCmEQLcsd0wKcepKyA+XUJ8mrpC4gaLBHOF
tCsSUtGmM7yIpac9c+jIJXTqiuhTWZwPWWhGTBcUMBcrCb2koM8nEtaV1j8qfqJCArqCYk5rCHKGljWa
WbMYQ5FsmrkS2pT0sjabemD8vI0EdaUk9nAknCugbXLIqoQEdIUjzogosCUisSCn2cwViDxcJAHRssa3
espFIqDnkQ8ttzoUsCsbcYw4KrIdjXlCAG8zftpEgk8J8CpI9oyA5iff+Y605fO5N/dJsAVay1J+gBIc
IV75BHSYZuQosF0MX/1H4nicbIDcs3zbnCtyai1cKR6S04irOc3pBRKM/GJAAU6RqaIVeOHKIktzGgy5
aPskMBZXBuLsj4RzuR/yVxYPyOXLTiO+af6cVOQ8W6yQlJiVaINfRmj9awGNPQtIgrnyOSXM8yThpmhk
JbmSL2doGaqC9M39obeBY2eacbYN3JVX9vdsS+rJ8gHL/1NVhpeZ5YoED87Ch8jbuglPkoSN/a1ZGHhC
eNBh6ClyysOQrvz+cc5qvs0Ow8/RqrQrw7BIhNsqy471vqQ5t6QGGHbhHh7wEFtgsRdxbAFeuSJMqqr8
HNSPVUwAB7VjNSGgaQ9pNSVAQ67XauYvfiHnczVHfBYfdnfngtzrrBYUtPhoSIKjWfhlWySHpE2hYrSp
f85JRsdoT19kCeWyxmhHv8tJKxBHyKh8zcSBGgk690C3RUmumTE6AGBr1TE/PoeHvsQr9pFGi9aspMiO
KXkEEaNzgCo5piV1YBCjU4BteThkpAGO0VHAIXk+ZjTghFwrSf2O0YmABg5oeIzOBaqs+ZwFqMCOQHk6
cSFs6bOdOMZ+dCFOm0MiRqcECjykPOioQE0f/aWcbIF3pqLFvqzyXxkU3QYfIaSUhYzRCcKGzXiGliQb
nSJsMnK2x+gUYcuHtWMDa0jOocOEZn8+bOqAdqCTBAUbUg50mLBnSh9cg2N0oCCAA6t7jA4VBGyA4JUP
GSIXnSlIS9RhOmJ0vOA0CpGPzhmcNvQw0JGD0yI4HFeuz0W5IeWPjh4+V9mRPJWN0bFDk9S/UJv0GB04
7PKC3vzF6LRhU+XZbpvQ8xsdOHC7KP0WChidOaRJvd+UtIMao5OHU3LKGHNzUgzo+EGcSwdPkmN0ClHk
R2pHE+MTCH5GRMK5cjqd6/2JPIKN0RHEuaYH7nL/eUMP2eV7XdKrNTpQ4GCjzVfm65z2yYY2COhYATcJ
+EkxOmDQzeQ3RAp+GoYP9jGjSWuaKt+cG/IIL0aHDX6jYG9IXEex+c1Ioc2xI3diKxoJiA/D5cfZ4GqB
Th0MPL0eoZOHonymvwbEixiflZKntPECH70+Bz4axOh44ph9Hn3OjzzygQLG7sm2pFcBfEyRkMcKMTql
CLkX6JCCY6N7Rad74pM3CbjCYg8AonOJOqO1Y4nFwpyxr6OU/OrJoCcUdHBUS3w+LsCD35ZifFRh0ZPQ
cwo6JAl0WsEsRpo33OekKXflJiPz6GUFn1ecmyKrSDOAjipkFAoF+OC5/iceSEszGR1SMEsUNBzoiELA
hdYidEDRlJ8DtKIVskkaclFExxJ1Gjz3jNGpxL4NFM2v80aEHNEUoJNAETTDP/EHUGN7dxYeY7EhZbvC
Zo9Dz0cxCYvtHYddBGCxkeOwywAs8g11BPwo8MkjXuFF8TnnEe7iNCDYBn3+4GEIbR8SY3TiIBsEPyfG
qwc08zK2nS+PeWD2rfBHXAaeZts8PZdUGEU2iZig/vjKUaNX1dFQxa69MnZ7N0DGJ0cnG9DZJKfRngm5
EIKWIVzV8yZ5Gw3Fzzt5CwBG27z5t6z4lPH97eA/snP2Zmj+Hv5TlSfFEFw9AL3OWK9OvM14NnmYL5lz
u1aRY9PpdE3Go8kI06ET8myjqCFtOoba9qtLYNc6tjq5qD4YJZttssZhjTL+X0b5D5NHEYmsm0ySxWy1
8JqASEgFr28H8EAhdQVgrcvmpy8DHlE6sKFHPNi5EscZvB8NyT/g1sz7HU1OX1CMfCRCDFFs/iFPUx6M
xKr4CcOpPNb8xsJY7LOPSV48sRrw5yCRBcyeMb3PChmh/DTOm+zQUiNauXc41jbQcfDzau2GPq5h4LIk
jos606F7Ix6Uzebdgo1SVBsC6esfffsyYdktSkhqnh8zzEMK1y61MzifuKWXcWxJUQzGk3qQsY0o4xp3
Q9ejsguivVpyRe7aEc/m0ff8moTUCh6Q+TjhE139rW5kiCId3ry2wZtwgFnGFKeuRuWx+Gqj8pINq2ab
D81zhkfz8ATC3nXE9YiXossda7EbZq5zY1YXG2qte5RTgId26ms2RI2cWYY27jTkW0WZkDeUvbllge9Q
SHqELu5jGYk73M+G+/lwvxiOWdGYlY1Z4ZiVjlnxeL8IrzYqrHCOwwrH8dq90bGPB+J4nfWof5nqX2b6
l7n+ZaF+GZtmY9NubBqOTcuxaTo2bVnTselybPocm07Hptex6XZs+x3bjse257Htemz7HtvOx+DqUTDo
Us215XJ5FRwXghhLYbBeOvQ5FpeDYo9HgEUeky3X4NAIFo0pbtmRA5O6mLO5NxN6ItREadACUh+HqJ95
MgQiJPRgMcByG1MiHNPSXPjULzn1gvegcMrXYCkKWCoolpIB19BmYhycDuhnPPBSwY6L6wdcFXdAKbdr
J2PSBtFA8GZc8OB7YgkDLRf6T6ViU28CzvS9ircHhkauEssFo+7dRXYARsKWretV8cq7Ocf4tGV27+IF
FotLeMOxuIpnbqNMsgNlVLa7h2x6HQvHgZ/ryssU0mzzv1WV8LxhnShQlTIMBtbKElWtAllgvSpSAMfy
c5WcLp/3bDTingofCC/SdPHdGj9AxRfLTIUCPJ9ONKCp0BQnJxFy9KsHaWsU6OHMr5iAdUEWn6pc3Bh1
XLZr4lSqC5nan4yWcbJSzevzdsv2wKZuu1xMU91cVbrNJ5v5bLJVzflncNM2XkYPO92W16CGs/lkoftV
nwh13UOySKcb3VZVus0Xi3ls+k2T47OtSlaz2WyiW8s6t/HDbDqfzq7jzTNmmPBmPHU0bLQNFEIfVvOT
gWpu+kDpbhelDxKhy1Yfdhtnk81UIBT8JbCtsnS3lNgAo33AZMdAM4FKczw49xIAFUS4W2bbzVwgVDIg
YCbMdc0kPkcYPmg226w2jHfiQo88udErhV7YVsY+PPI7r2wNBN4avEcM/LRzMSwLaGUiysSci4EA5P9l
v5fid9tOgTIfTMS0no9iaTMX4uTXJ76o1nbV49eJRIH0xzGswiz+Gs2F0x1u/FTktHuvkcpvZnPrZ0rE
rOCato6eM/CaNsM0vdBeP6v0r2EbiyMH02I90gJ8uB1wXEWZNGIZ137yIiId4SypJBhe4WWBaZAVzEet
83pNrdWoe5fu+IEPHl6zG4rf06RJRqwVA2TbRXVZXV3M3WfFiVA4uWsdyMU4P+biPkx9AKZxxfZbQQsA
7t5p48jVcgD8OWHysWVfjudW/7XEofZbxIPTY8HDzbb7vEjBZT+m8YGKElZ4MwEAqnwGoES6B6BAeQru
Pti5cd9x8sEZ63WpD4Vwz0T5mIzX+eFnkbXi5yj6p+gHtpIZ+FGVMf2qIYrx6VwUyulwp13szbvIV1q9
FdUTFUjJEWBEkREcLyAKwVBYAsyBSBwQCse4B5IAs0kOa7LlNdXWkUmQ8MDaUECIlmG1oYAgQIO47gyE
Hv0ANNRnkH/rlmkM/+gQ9t7hxbzA6tyehuGv2bEoh38tj8m2HP65PDKdS+rhmz+X5yrPqsF/ZJ/f2AQN
ApdZf9h2YzBzVhu+gmm3ZDmZzzLKd1/tJruZf/pzZST2Q007YeLg00E6BUdK4Ep2fqyzhq2U/HSF/QMO
aseT+bt1b0hO8AASDZOKyKww9E1xfD9cpM5w1z2NciVWb7Sjg91Mex0If2Z8kTegH9U96KKQhdwGqjL+
NyWvOf8hzvC22y0hRTaWgaMlEXGO7JzlOFaZNRc0+YSAy/ioW7Ye8mb1tuKfyfllaH6IqRgynUHfYfT1
UYJdx3yWJTlIiBFcqmMrAwUDjsQkiDj/Crs4ti9VPhduhd9gtZqQDVbLQIN4EkVkiziWTWzFaFec8/TV
Rjuuys8XB24Em0qvlZdwEorRl3oUD8Vv9UH/dkj1b8Wz/o3BTQzcxMBNDNzEwE0N3NTATQ3c1MDNDNzM
wM0M3MzAzQ3c3MDNDdzcwC0M3MLALQzcwsAtDdzSwC0N3NLAPRi4BwP3YOAeDNzKwK0M3MrArQxcHFlG
R5bTkWV1ZGGBUIBUgFisXGIrmNhKJraiiSfEBXSuq/4hd6v6YY2xOmGlbuVqJWdlY7lv+Ws5CHgEWCBG
CDYfV1Bqv4jY0ljPzXi8kP9bgtpI1T5Mx1P1P1u7MuuALXtQZYsFgW6pKucPBLaFrgTUzVXZjCJupiqn
FG1TVTkBtBkGULRpPlCkCd+I8U9JG/JPVsWqimSiBIkUCMlJAbJSEJCdouJBVZA8FRBLBUEyVkAsNASm
fa4qSBYLiJmCIPksIKYKYoIpNywLUq45FyRc802u1qam3nOByLnmyoPXxLImIA4OEUmIgDQYxEoCuMJg
5Q+yPCALBrCUAAFRMICFAsBUz2V5QBAMYCYBAnJgAFMJMME0a0YFaVb8CpKsuOXIQH6G5lJwjhqgMDRI
7ICQUtGgkQNKikeBrhxIKCcF8OAAkAJTkEsHkpScgly4kP5Y5w4AKUsFOXMgSaEqyKkDOfFHikTQMlJX
Ei0DjXoffLnOkHV3rENjXRbrlFi3wzoW1nWwzgGw/sC4C9vtGTlZio2caBY0cgJ/0MhxOrCR41QGjRwf
TNDI8TFjI8c5EjRynHFBI8f5i40c537QyPGhhowcqwsZOVMVNnIGJGzkNIhn5HRF2MhpiLCR0xCekdMV
YSOnIcJGTkN4Rk5XhI2c4UvIyGkA38iJGtLImZqgkTMQQSOnIbCR0+VBI6cBgkZOA2Ajp8uDRk4DBI2c
BsBGTpcHjZxhR8DI6XrPyLGKLiMHQLqMHADtMnIWNGDkLECXkbOQXUbOQgaMnAXoMnIWssvIWciAkbMA
XUYO8LfdyFlAbORajzLgRt9u5e1m3W7H7Ybbbqntptlui+3GF2xswb5VbEs9KydLsZUTzYJWTuAPWjlO
B7ZynMqgleODCVo5PmZs5ThHglaOMy5o5Th/sZXj3A9aOT7UkJVjdSErZ6rCVs6AhK2cBvGsnK4IWzkN
EbZyGsKzcroibOU0RNjKaQjPyumKsJUzfAlZOQ3gWzlRQ1o5UxO0cgYiaOU0BLZyujxo5TRA0MppAGzl
dHnQymmAoJXTANjK6fKglTPsCFg5Xe9ZOVbRZeUASJeVA6BdVs6CBqycBeiychayy8pZyICVswBdVs5C
dlk5Cxmwchagy8oB/rZbOQvYw8qB83d4im3Pqe1JtD1rtqfJ9rzYngjbM197qgsObcGZrDxyxWZOlmIz
J5oFzZzAHzRznA5s5jiVQTPHBxM0c3zM2MxxjgTNHGdc0Mxx/mIzx7kfNHN8qCEzx+pCZs5Uhc2cAQmb
OQ3imTldETZzGiJs5jSEZ+Z0RdjMaYiwmdMQnpnTFWEzZ/gSMnMawDdzooY0c6YmaOYMRNDMaQhs5nR5
0MxpgKCZ0wDYzOnyoJnTAEEzpwGwmdPlQTNn2BEwc7reM3OsosvMAZAuMwdAu8ycBQ2YOQvQZeYsZJeZ
s5ABM2cBusychewycxYyYOYsQJeZA/xtN3MW0DNzKqN4yxf4a7MnQq5FM3B5CN0lIsIKZZsnkR/+qame
TEryp4ZfmUNFPMgHFZmGqd8w9RvaYI2HcOAEugbWlKfAJZ80TYkR4GtkcrwoInBCYlGvAL3X2B53eaXD
68ComThE2vwuOFHt1gVRtvac9uw57d9zCrLeP0ZXKLz34r+wnuTWYBzQU3HbUWW235Y8IWSdpYSOwUpP
22Clp3ck2rQNLVVJaOXczAmTk59OyI+hqOHZOn90ts4fHIEzbcFJ1IGRvQL1lgr3PSi1tkwsz+qmyk+A
uMdjs5cK97ZM03eA1k5I8lWHFf/RnYkodYtA/Wl6oKtJtCLCSq66A1b205andv/jj3yV/uhd0HNf0djy
/MHHtdwDiGAy/T6Fg2Wo36q4CXdWFBCzv+aO9e1Cb+nFNVYjcI2VfBCbV2N1NoBNFRNmgahR2IgajM2z
TkQNxtYicVJTLIvUnekA1L4HlAPSpZsuK9sxUYPKHvgPpSXqCgulJrgK6AmuAooSROhXAVUJINTllLIQ
VVq+RJWH0NcXospDSDFX3QgKaoxzSyisMj3AXJhOpXGZ2oGLHFmUrbYLSm34XSVKZ5xyoDBOOdAWGs8+
gGdP4hGFlIbgci1NXO7i8RUDl7t4SMbJa11BlbBXvcL60AUDADo1AbCtDQs1lO0sm+6mlA6oG2aUGuAq
oAm4CihDEKFfBVQigFCXU4pBVGmZElUeQl9DiCoPIWls9GXZgJ44l/jCqtIDzIXpVBiXqR24yJElu8l2
S6mNvEhIaQ2qAUqDaoDOhLB5NUBjaGyqmNIXv0ZL16/B2Hxl8WswNpKh8i5mUFXg/cywpnRDOSCdeuKw
sh0T6Zdstux/+uxepqkcJMd08NaeTywXS3GKL7uwyV4uweMLEblsrhV8kUHy4JqBuqRonp/UNfL6AVfs
pjxv9+LlYFsprvPwIo6OoRB5kUWLTVLReVSuHtFPamPs3UwNAFK7LwLI30QSQP5usq27tE93bUBgo0ne
w6fbeXvrMG/ILSo8yQgSR26/b21p2XlrS8vju6m9uaWVBmx5QXcXb+I0uHd6G6Nvawj4fFtDwOY7Sb21
IWAyuHvr3B3txWS9yFokbZPWJ+D2hlSPtwzZbYjeBo+u9i1b+3k28pMqgZdp1Zu1odRbXttA9hSe74RK
jeakZEPpoohMBHP+c5VPfZI3+VuP0+cogwu/hN/vVeOXZMXznoIeUi9G65Q0M3GN0nBTn6b/vFq3Pz3N
n3H7iF65d3pmLsDHoBjVQ68/Hc5Fk5/4FX5VwIX3MfQMtOhT5sjyH7z2y81Yv1nCOlbGH+km74kKVi7d
m6HdqQLn8/l1zNMM8ENp/rx/eCaYy5QgTdmCDYOnHLq501CWOFuaH5LnTN+V7XXvtO2iL2/L/w/v70ZL
+qpvEJbITWef3C0rmF9uMI7n9dAnyINBmeza8bXheQ0kriooNYbYeFKdZJetjB5H9zB9yG8xP+iKOJoM
4+V8OJlOh+PFTRJpRYQGIx/BZ6q9zfbiKQqQGWld8ifGm6+PMWrE3XAxwwMNvT7Mu/R924CX/t3yinkV
PFvfx6G2aRZ04E5ZlXTkWPJvsTyzFHWHm2eQsMPUST9dRD2fw8cPyAPQNGkyxwDwl9WcAg4hnltj60tS
OFUHRgbrBi4e0/BqMvg58noeS8bXB48EsgbRQsJIokyVSx3/fh2goXgO0eDW0DS4MA4NxbNDw0zk+BRi
lG/p+3vU61iYrOFYWyjiiq677IMLuzBZYFv6PdnHQPgutif5t5vViEg/GHkvSiudPpW5zMcmsfu+hqxQ
CZCoekMJZaltNYHB+i5+8k7AkJl0X5w77xPLkfeY+e+tGACWkZWTIsWjrT23U3/WkiluaYarnt+3E/be
o5RKJaXihU6ExwgWQYr/dLVsOtZ1ZEtbSyyivrK0A1l98Bdcl1+2W8yZVoJcLlMAmM9BQkw/eELiiiAZ
LfVoclNEQLMykl+WL9hRRWnblr7qknjsCtlSyxZqN8tAhFIvXe1iL9GABGBgNWX1A9JG8qV/DUI2vKws
E89wzf3cNGpfYomG2D1LY4y2IR1vazxEKkG0y7HAUItneqjcwqydhGM2V6hJUIrG6iXiWeDBMjMG8Xsm
DQ2WER8YrEUkB7tP6tEuy1LuAvmGzq1HA3ZVZjYZz41t1VrmYzY2QUQp8T241rhfxVO0Xx4na2pTJVyb
kJsjCoi0pHrI7wNUqfjphUVNc9coSjsioYetOinYqT7xDsY87520S0O3QuNXq5FTp+yjC6+WGArUmCGy
hVkanfykLqwjdHd/I+G/9VayhR5y1yVTqN691+Lb9O8Wy028eLh5ewXaIqqlCsm1g02c8ujynNiDyAiG
NcXxFo5YpSRaqE+EvuqZCkL1TB1QPQvvqJ4L6qie1wKpnkpR68K2qJ6E/21Uj6QnsOHnWXRfpnrbKIkX
m/tUT7ZFVAdVT/Ew9AV8TXG8hSOe6sEWWVWVla94qphQO1UDlE7DOioHwRyFQ9BI3VROYwjZomwS+rdR
NoIaUtVkzuUXqlr2MHuY3qlqoq1Dc1DRFP9C38/XFLeD3PDUDMIbX0Vokn7E4f8GEKhQaquU6EAX7Mzm
5EbepFKd8p+W1CWif7VrhucPge8W7p408MyKjxMfSxPPlojP7n0QAmFifOJz061ICPUY9gTeNK2gztDt
KMOkPFFN5OUcp4mzKuHogF7jV6uXi1UfaLTJnsorfUOXeiNLdkwdM0UkFuKEiMbYfhBkU9s512ZcXOGd
Bp6vV39jBvkMy62toJsYixFsiVON6/14m5zuIPACDxGXZiNFbz77ZZHsWIwcKhxFDwzVaKH3PARBbG9p
rm1ew1soRjvx8ADi2XhKZwLtg5sfaIRxL0S+ULY6tR422u9+5Fmj/Q7Y+mSN/S7obXSJLO29ji2N73Cu
mfGVBwbyG6L4+kOU1n6hV9Dzq2Q4Oy1PisuZqr4Zi19VML0tGcOSb/DxWPSqAvIMLRcQn0C+2gZohVRe
aJ70+izIlHcwR45YHEi7HIIVdIFjVvYXOCWmDi25TistGWWfmIxqSTLx8Uy9jy3ePX6rvpn9uAAfgDuS
OZvvbOPFXBDKuLpLzkUDud32TJqJieaRraA9EJ8psgpkioC4dJm52MGfZX0ap1V54m9Fsjn//Fxk/WnM
FvwHe7cp/7m+Ig2kdjkduLLXpd06oCGHJDKCwba9quxATKCw6H1hAfSysgu9j8KiJ5gO8Kvarg4oyWnQ
cWsP4349EEtI7xnAECXpc9b+Fg9TXdnohpd78KHUfJltUgcLFKwuAsLQRZBDqqyH4veiVL4bhChlNjR7
yK6vSEPL5NPI3MmnSntMPgU5JJERDO49+cIyIiefj7598oXlTU8+H3/H1GiTHDn5vB66Jp+rB8Tk6zsP
0BTUzegb2LwdejGM1u35dvMw36LeZ9skm20dLFDCughIRRdBVqmyHjOgF6Wz2SqdzTCfVg+z6er6ijS0
zEKNzJ2FqrTHLDT39ShkBIN7z8KwjMhZ6KNvn4VhedOz0MffMUfaJEfOQq+Hrlno6gExC/vOAzQLdbPw
LIQP7wWm4GYbeSeXs8XmIU0sCihb8TcQhvgbsocX9FD5btKm8SZK59jyLVbJZnt9edctU02gcecZL+ox
yeRVSA8H5l/vuUUxn5xVCGv7lKJESE8mhLZDz2l5kHPIRdw1gYBcqdnTR4Xx1FFtwlMHPT1Jq+guStIZ
7jrLksl04WCBMtRFQAC6CHJIlfVQ516UZtvVMsaOdjp/mMeT6yvS0DKrNDJ3YqnSHnPL3BqlkBEM7j3J
wjIip5qPvn22heVNzzkff8fsaJMcOfm8Hrrmn6sH1B6u5zzAOznVLDwL3RdcadVOV/PpzFPt2XQ3TSAS
Z48uS+C2WpY4W11R1OcAoweR29U0mmATn2wnq8n8+loEtB2gSFTo/EQU9jk+URdxCUw+V/ufnQTEQp+c
YNwdBycBAQeOTTDyrjONoKzoMxOEvvPIBMqdTADRS+HRZNOtwpOtyI+/eA/Ouzs+dPLuvcem0QzNbw6X
eEEPfROEtD4E1/eFPYogoHDib6AkgGA3TAGmwOvAZB6yThaz1cI7YGfjySp+Xt760t2VYFfHdKIo6j1f
fPL5DZngxwERVsr/1Z+unvhfl9eIF5X7nQNEXx9c9PdH3gqkX2qI/EuNaJcfH+7ETUVfwO/yBuY9AHfD
M5xLOOfNIW8+WlgnFj5jggzUbc5NUx5BpRsdkKTZRX+viKgrbqpSXBAb8LEnFbq0RkG0V8t+x/nxAm5e
bfnTjafa3nOQOqaLObTDzWtTkZXqMnH5+SquG7fDSNGbXrjj6n/kV8KOvPenCXZJ2MF4ygbL79chXnnV
LXWMKrYCNG2xL5GlzUkaytSU/l4KMirO9JdL99XhWdsHTZnmlIK4GneECrpGrgr6yBkBgEN2PAeCq8U1
VPVyso6tZmXRGirMGjwdDnJ0L3C8vrkMPlE3ktGna5TaFD+8Hvh+Z4wRqC3y06O96/Bl3VrXctUVlDqf
Q8WX0x53YWWUG1/C3PYopq8FDIkJvnWtY95B4mAHdsD8oU85vwkJHoJUElgJceC5RWxc5fV4F/FTkT8l
gadzp/pxdPlO/KZs9n1DEsBXUPLFeI8EbW+JGtcXWPAf0p4GX97F/enEggnuzlTQ1NhqhySuuD3pUb5f
aOI+Ga+XoM1WBagDANj/aOmnLzJyhH2uzjrLIBn2oAIGTlX5nKeP//yff+FVf9Mv+I//mm+rsi53zfiZ
z1CG5212FMT9uEuKOmPzCm3oxCLoGjsJkgTXzJ7zUKzgIMf6WkeuGSiezoRN044Z1eoTEc/yt88izlb+
h134d/kXJgsYT8XzZqgoI2QDViv+/LNZizAfAyzhcZbCvg7Hx+TTJqlGok8VyzQwSBQUeJIdGlGczcPY
RtuJQ01nZy7tvAshJhOh62ehag0zU72pt+k7GdMCHtKcq/WgoTOt3Y+Wu8aOPxMIBDUIhWtOdaB8dq8X
+CaGiwVujQhcXrUsBXtDqhGulqVwx0u18upF8bijmT4PMBfMvBH2IRYuJQZQ7AHfI17bQk/OA/sr2QpU
uZGeKqxT75aasuT5zdzaOaodYBJMOQztxoJXQECBYAmB7slB57wAoAkCrGa24y3MdfVOlthERbIAu8Dv
LuSJCZQhyJ+FwozDkDd2ztYXOdkNGe56hiq9nm1HPh8crcYbAA8aUsSHGSLIqcP0BDQAA/SQmVxVOkSk
sMGk9ogreGZTLRBrXkk0qieQL8tTqhdyfOAJ1Vu2hNPiwZELz5NcYzCoeyX3AT8V/+BPSHE7th2NcFnc
J+cnDqIA3b9FUGsbAfZE9JZDT+3AEGuICDQXlUrk6k0mRSDWBHXmYF2bFhzRQGG5hqxQ0DyFnYknJGvk
pdpE9evgEyRBciBamPE+AI6tHVHbaxzteILmU+QMidEtiShIbY8Vr2Wxw95Di7kJrl78UKJt/eq56CBS
2uxP5/rWucLCVrMWTX41q0KibWN3i725A1fAEr2evDyj5PPsdjPlixH2//dz3eS7PEvds1+4QMjDYFbF
7JLaeNovPuLo+LHOTkmVNBmJ2VvN3Bp041D2hh7W0OR8H+4AONUXejmj4d09n93r/ZQmTaIkrT4S1B9F
yyf/klw/4LaMSXqvMorp+xXRO3NtwiRnkYwLbyClJMOyAljcR08A4/uliVG8dLOFeHTZhB/gEDqYrtNF
Lr6cQfxDr5a4bdoGwoUjtOWb5nEJEB+A8YfQA5AcSFfCmABdQSifsl6gmrZQdppW9rRAhxjVswlmGcwD
ZL+khtWN13aoGwbBXX6LDEkB0gMwvZSt1zC6UjEF6ApC9VS2EG3tuhBgTwv0jcrWxTJf2Qj1ESYzvLj6
1pLA2MPj8jq9tQ3KW3GPH93NCW3Qv+998ZXAeunKytv66Qsm5/Xv49L5RHsm5iVo9dK0BVcIIroihK14
7g47IaJMPHRUkoBWIJzlWj9oGFYjJ6u+r9fBauQbK8+zCwJsbTuA0Q7Ah8bnSf2OGzvxwB1UaL9084FY
K1+9dPlhYcHtlY8zVEuMsicbesB2ysk7kySOZ/upTWCLdufpYRv/8CsReJEkvvGYyR2RHxhJK0WEp1Bw
4tCF+FpBwepPRmSd+hZD1vkfcl5rtuOMGgTpd6onwZNj8gklX/EyQ6D4GdHmqci7UhFruKekM2mxu/bP
FV1OcIb5uyUkgDR1GhUIK3CiE7xat8e20AY69OLGwARBwUDFCAzhH4AQU6SSb7XYdDfeQ2Fn/xm9XhSP
lsVTfni+2DNaoxw8J1N9Cb6VIZ490mBckWDcl6N7RkU1KJOdMzlaAhhuS/IxUK9boN6kCC74SkQ2kP/B
IwHRPVQpEKhf5ygXd+WUHqnr861ZJxB30TpOq5ygQPxiz9nAgQd+nyXQxIrPlb4HZSUHnjwh0qQGEHSH
WdjjsdaQisAYiCM+e67Xf1A8pqIHtA2L8fzt0Ph9zQpBYC0LwsFEfnh+3sFDNry2Kd9nzv3Gg3YniLhC
IWk55UWBVia3wo4Vy05DvGetUVyvC4AG5xXDEfmVXhRgKOBPdlo3rJqerbYKkKyebcefqEKrxbV7Ubh3
LfgWS8BtM7/3hAesCa6e9y8I7fOiz5z4BovAay8Av8EgyUnPWo5UlKB4wGx0So74NoMDo7x/3+EVRGAN
xV9+7/kuJuP7qDyGNlnf3H9EQoR8tvlCnRGIxErXHbWoQlHB+mkiFM1lERTZMfciO9AjnZ/yOudfjTpf
5QRBnrT715GnNpLxHZP5fKj/P46D2XNpaG+44sqMfWG0e5lyeAXypTohrL2jSTA13pUdocJ/yA+nsmoS
xiNwIgxK0csPYNegpGNhuzigGlzdsFo2rAFuaCJv5UMR7TBudG67znnfDG8hpr0jvi0yLwJEMNDX7Jdm
D6z8nXzMtqx4cLncRRaspN4mp8zqwWuSM4kikSqSr2UJ2ztVT+6kHdqa0a4452m4/smnJtQWUPKidKH/
FaiOkF909fXz4txyQuFVYt3onvwAG/4w4espqQc4KN8JG4c3sabo/iA/RJU7RmZksmkqY93emRtxofq2
yu4BdwymmwkXJ67fZXcApVrG8JmXgyIGbgpHsWFjS+GpBTS/5ixrrs6y2j7Ty9emIFrgz9iy8JlXJ1Of
rG4PHKRDH0Aqvwt28SenIVhHaAYC+IW2GX6s9Fci4Aw92D+BE+DKQnz6uf1iz605Xp0h+VH2TvVgnDOe
jbhvRF0Snkzs0yv+d7DY682ie28Ru8+Udc8dJQvHZTX98ENedda35C/jDEbmkFVVq3NamKs48h96ivEX
9Qlt2fSD7Bb/AIfFupdF5VLnR1UJh8fJbt2uClLot7tFIQoFW4ZdUAPvCpbzaVTH5E4Qz8M9XoJrRGsz
tHa0w3onySDbSLe6cY3yjm3BRJEqhc9Pwso2J5QNsUv/KlcK8O3J9yh6DEBcibLkEW6rvJUHljIAY60J
s3UX7/NF6xo3Cixy3kLbvY8JbbdfvNcZvt5GqBVVD5+AMfjVHqnwcb7wkQoH4b2PVISQkI9U9AMWnwTD
oMFHKkJNWh6pcJrc9UiFg0G9TeBiffVHKvwu9SMVZMeBRyoILET8CY3xvkcqHFw3PFLRaaK9aeYd0PZY
U8ViCCYNXOEj/+igbU91vykX97ZvMRXIMIWP7qIXnNvR23O6y/tj97XjbqMfkAWy5gYCiwCB+nDp81Yw
avWldlrN/FaOd812MA488ZBR+/YfIvI/G/ubCHOQ6NDQTz/ADpPIbq/Pjx/4D06at+Q/uDXaWKEghCAg
8upoGPfrsfhQ3x11QKETnO1BmnHjboDtGMnRDfFoe82gz0g4OvcjQidUDwJbPtgTARPteiDwwbQb/eD6
UBmKWhFRnnfphXOvSGejU/EP4QYdtDrbbSJHXid+sBX3mz88PASbe+enGEAYs5umtWA8iOPpgOkjRifq
p4+qdRp6opuWfWi/yd17R3pb21dbBug+eq0NHU3vHd8rryKBTvotLZ2N7x7k3YtQcKziBnUPpbRpFIH+
+NDmUnYbyg1Kyxisx/oaRtUrHeS9dPRKF9lvEOINFwWaH1mvNZXJdDKZIP8neuA/uGm3/0MCovHSMN3x
MNRagXGFnB8M1+b8hGA7hkE7P3ePhHZ+WqF6EHhT/FGHEoScnw64PlSG1p0Zf/zjLr2gnB84w+kGHbR2
OD/d+FudH5EQONDcc34wAOH8xBH/aRcncn5aYPqIkXJ+WlWt0/khugmZLnSgf9P6FkJrMyneM1tuc9Nu
QtAtjb5u2ksWrL5u2u1N7x3fK693/d20exrfPci7l8vgWEM+FQXnumnkqtXmpnlAITbQHk5rf7e4aTfT
cYub1jEIJqjreFOxlWpbnQ8b8z3qAX2OgiGBPZLiigSm1Ldy2xUMoIWH8gjmfZE/bjJmVEwAlkwytAYb
ApOk8cPPUZREbxwUOt4SKsApYWMSkRCtL966t5rE4AdkoK3F548K1fKZ6hawKdGeyTD4AK+5i9WRiVPl
b+2bfTZ0NwSNxLmChkflVIoRUmf03nG4ny/Iy8bjdgPuqnkkgDpBwZ1Jivxe7YLpS5KuSfR9QKIB9WhA
n1taWCLA2hGlvCuyghoLbNRSTY3KaSqHZhOkAA3rvKJEvkyoLybADo0N8ofoVFEDcQGI0UADS5e3oiUu
/vW540e8iYqkzXN/4MVElcn1pONKvI8rPJ2Jejyf4CxdtM7hBdl3aBr71a0z2e8aVzt91wefh7LM4WEg
SYGPqoWFfn0bC6etLJySfQdZ6FW3stDvGleLvm2gEm0k/WQS3lVggWVA20tRocYhfxdEtxlrKaYZFfLX
fd1RB9jNzfAGaJnXJbffIZaNx0fWxI5I/ikGBcKEDPCpyj7l5bkGDUwRaCSjoxQAWqrcInck3gLlV4he
7li2rmMZ8OCKyghpPMkOg/GC/2eaHcCMWs6/d1KVLEOpSkzeeke7ujOobJI6k8/uOCIfT+bZ4ZpIqhWX
9F/98uW7TyKp8T9mh1PzFV0D2vC0nCoexPP39A0fhaDlu7FwYR2gn/ZVttM7DbIqdFIkv/dqdMRj0Mjw
OnBUt25V8IBKPGqt0RGv32ryxAunCI7q1q0KdStf8dXo8DOguk/xNCQEojoE5cFBivdLNSLihUStWeIV
PARH9elWBe/zi5cejYZ4T8Nph0I8B+aCkXoEa0J9ytftrurBMTrWyj7LAmPdeVrcpZ8A6DdaCqi5hW2C
iF0RAwtPajnutkktI140pBPWpJ+cYquQ7EavQvKvu1YhtoRxeytD+hg/Dtovl0jh3WDjzT/d8sb30bnS
rJvCTZ5wFf7OtuBlU4E8VVM/PEgUSeT5cZ9VObUfELbUoBvs4yH4a7yPLw4CCIoj0tDNikmM9G0SRaD5
076CzpKePXP+c4U3JOxQiXRTgFTT5IJyFKsz6HpbZdlR3u3yo5g8hso4/wc/CHom3HySQPcqG3wlSYpu
Ebk0+8y27FtMRSRcs2f1xyQvAm+I+OFdE3wjAGbguNuFg88ggVe2mM8yGE/kC1ts7R6V5wa90UVBtFeD
QfN0JkP750DnNwEhYfA+gr1tnthGZtrbEumbgZIx9TahMc62//E2OYnjLXCFZg0/DiUFWxIv8MLRrZd/
qXMwgXWwn7mhj2hiSiD5j//k5JJPPlH3dBqqX85ePLABeX/Cr+cpxEwLD3ktnNmhW8RvjqIZMKUbMjYW
ZU21VzWhFZ9bMBUoKlYXigPG69Fi2S4XU8qpTne7KMVhgukiW20XCNWAXKq2q2yymWJQyH999rSZz7gR
lzXwffZpvIwe6Kd3s3S3RLRtttnDLoZ4aMKSRRZnTn8kVbP5ZLHSUOit64dkkU431HKx3T1kU0TYLsk2
2y1CRdO2W2bxZo5BCfIWi3lsmea+BJysZrPZhKJukmbei+WctjR2MdHEZbPNahshSIK2h9mU+XjXP+n1
8Jfs665KDlk94I9WVUwN+Adgtimv8lNWX3YVv9ZoiTXKPRN7+mtTkrX8eiPro/ym6L8h7rHGeAG3pqjV
sDvLVei7R9dNGu/ZveBFGR/S0i++5ns5qM1jkSI3U0sm3on1wgKedfCQtmV4I3CDx3m7sC8kYczFwAbj
BfnWJqoM1gC+SS1KBw4nh2NC01L/1pumT75xOjKPvc3mafY8JG4uzd8NJvPvh8CUen/Po+8DLcM1S4QD
/f3Ov+zK+Pb/H9H/5SkmHgMV802sRLPIPZ90a6xKKj+vTSO1K6j7S46MQULPqRVyMNGv8A6Yoc2PbEvI
583tjW5u4a5PPyVVnow+JcU5Y3vzH9/Ebz4OWwEmbz5e7C5o6nCJgo88ePge4R23wXtfInL50Xmk1b76
UAh+X29+X288ipHedZxpdigdbv27xv2ucV0a132u3aF0BILf9e53vevSu84PGx1q57f/Xet+1zpC68Sp
/FD+w7zA9OsFHwT8WvKvCi7kQP6DrywrIOqZV/V8hOyn3Pw92zY4SaSs43HlfMHUmVMG0cBifpJvYosc
Je7V5gjDyCwlzm1nCzPi349wjIcXw2E/MrVngpeJaNAnqdtzuxM5vm8LYEQU9HlxbuYm3fRDAzFO/044
Tg0WiDLsinxEHelvbk78CA3z3v08JxVCfnHEMrHXCf3KAS4wqgg+LXitbFAFZj6+v9g3QFWcsnljNbEr
w2CN+bIdqvei9QLfIUMIghzqoumehoLYLpmYjw79SeZiuJ3ejlYBYr1rc/Rnax+xLA8JVNW2xJ/eGHBK
d3CD1CC9tzdrF3WoWbDBU31IiuJOIjsat5Pa3jjcbPwiijtad5AsW3fNp9AI6HnRTndrmx4zKYv5ZzmP
xhs/OfpLOY0gDNd3cQoiCNkOU+9enA6OJxJfS4No9CrTBdBFjrvutK42mlb3Xqjkp4f+hm+xxCD91gGg
+8XFWweZIypdQYXGsJ1l0x3hQwgcYSmB2lYqbpGPItGVj+Seh/u2r9LE8EgEYbj7BaUQBLmk6x0OhceT
7CbbbbibsMRcgC5ybpCbptWRm+Knh/6mz/XEMKn2QbD7hSbbB5mkqh3mBMfCowxIkUksYYk59R203CAv
TagjL8XJIMNa8vbNiZ2SkzwMvE3mvHnM4+iPXubBSdR/i9kaHEV9R5Kf9GP0ST9yP48HgRTB8kgCRnLp
Cs0tfxvdJ/ln99UU6u4I6pt8eUWlRED+lGzX5E2Rtck3giEMCz+2CqAxt9tR5a4sG5BoF7ClI6DDzaZK
PJfVcZOGuMTD6HmCpyhenJsH4i0jFz/h+Np7jdZDA48+PJSBc5Hwvc1+WuH0b49J/O791yH7HKH0ZbhW
zvdtXA0dDamgGrjGvHf1igJWw29kOCL8a1Rl9ak81iI2262XWLcq4YaqDWqIqHXfkA30474d6bXrcSmt
VcYewqeGM9wtqRz9a9LXIPxl/bjt+KL6W1D8kn5uHPv+N+JxSz83jv2VKL6tnxb1f6GKwzeDv6GGh7q5
WfFeg94XdHOz2v0m/A13c7PS/Sb83RPGtMfy3Yc2+E4wbtWWibi/Y4SxqvHCggo6En1X5TbKX9KH04q7
A9+a1Pv7uGXEPdfhF3G1zWrcMOJXIfWWPi7fTJNfOgVf0MVtOvZyQu/u4jYN++YcbTEON+nXN+coZRVa
0j2A7QjnwHtyowJqAJ2X4N7ZnRt9TNnw1hbu5tXtcCSrsjCLMaB+6jSESHoPjIinnsvQnQgsOGfAi/rr
hcCCc616UX+9EBDs6Gcs70RAsOPe/nohINhxb380Aq31+umPbm3tseDc155Utbt669OeVLS7euvTnlSz
l3GypT2pZC/jZK/egIq9jJMpYXP0axkdjHUX+Ts4247AY839/fVC0EHe/qXjwwg6yLulPxqB/2h5R//Q
M7mHvW3tPdW7u7c+7dtpu4e1be3babulN7J9hxyBV0dHNpoW5NcMGQQK6gfkJ7dAhk3c6r3b2Fz/9yHN
hzB6dCTse+/0HXxs63JpXYzeZ4FAzxIOdzwgOibfyNc4Td4oKn0gAHhCzLEhnJ3fwfri7MnE3vgGboIa
TRSd/pxERPOYost96h+QZnJkBRJTApgAi+8IP2xDeyOX+6Ac3JIJiER0L6Nd6swlSDL3hQMTUue7smq0
Yb5VqXugROzWpAVixgK47lZth0B5A5BM52EBQry+K0tIEO2NjO7Eh7msiApEflGI7mWxS5q570bmJnFg
Aoy+L+tJG+Ybed0HJV6sFWmBgK0Arns57hKor3qR6VYgSIDf9+VxaUF8I7t7YMTcVoQFwq1oVPcyW5OX
HTZZCp3Ervs9KvjKJsKLcI4VH+nAKxHhGkMfMBcJY4gKUUCUqztXhupkw7yrcyNzOnGvVAeOyRtONnOb
k2HFesK4A5/yeLH5urqgvG3zxXgy/75P89nm6xS3XvKmn7OiEFkQYGoXE++0CiT7avf6oLuZTfnP7Xlu
OkLdOkDluAZCd/5xZrrq+7juVESpZGT7UWEj4iYz7419ka1PwNUHJ3uaCyYOxmUOMHD/qi2rYDCLZRSp
dMlOwF80EH7iLi/YnHxMitM+eVuekm3efP1xEr1bq98fxxNFh74KI/9wIi9ND+1JI+nO5rCz+XVzZhpz
VEM3uUdOpyypkuNW5cyw8xn1YHWMX1sEc+VQpkkx4m+M4NuVqs5OS/EcrpqT+gFgPDf1lZ84mkdrmK/T
S+Kkh6DLR/W2Yisfp74pz9v9ujw3XGyGyPEuSdkqJAlO86Qony9EjiKnSD6RPFXZA/3cg/ovHw4AhTDh
jiQgW3Czacq0f8RvyTIZwj4CIB31mgH5sW34RPuoo/+orfPI9jySb9BIfTAC+6JFaUq+qifJHSJ9YwSe
m1ZXadX9V9FMPSpCtKPDgYm8P9siPz3a9dldYr06b5VdrVZ+KVzTJu/8xcvqKx1xzPPtrtDaigOOaRjN
GD4IHst774ycRdQLSFGE8YuJdiHXJLAk+c3yI90ILWSqmXqkCxjLeDGeTaG9bIuY/k7kz0bYdHZIcDQ1
mljNgjHOXhy6ToFqhiWiuz0ddOO9JSiOa+Z0gyRu0kLRZ1fuKCQi8WTQ+zF4ERw/vy5E6xEgnxpSR1sY
hXmyhmojLPt7++sFPWEvW8gFmqdwOLBF8FxlAY9txOYPN9xyms+5i6O4PHey+Ul8LQ+HO8uIrFpENkeg
SDI1gCuOXjrICThX0eatMzAAZFig38qfcjqo5/VXqwmgvdB0ryT8uCnLoslPBOfsPF1GyF1vyR3I9Hb9
Ka/zTV7w6SV+LTLaoXAnr6IkOGtXcNauLHxTnpwHOoxSCtEL90yDyjwH7utRXqJqDSx1PIzaARZZFsKI
HTIYX92cz5MI50F/6ErA2POCPPf3iDN0TUhSVeVnQvQoX2TkOtPE3RCZCUIsIY5gBqgr1xbM2SbJ4RJY
X9VclfnQB851A2goQF8CR0eHL8IvtAd3YDIorPFHixt7ILGLbxmMS24qDaHYwbE4vckYHqo/ilu6O226
O/uLdI9rEGhAdie5Q3XYWxm8ztzDB6I7UiVgn6/QRVBu2gO6q5NTeRIvGoaOIDxfaoF2N2B1WS6gD+O6
AjI9rPNOQnVIit/MsxWveN/s2YbNaYQs5YQypz6QYbiwJlDt5UZA14YS5eh6ZTNgqh+nHibjUQ4QrFcO
ofP0ok2X7954m6FThRk+VXigT3KW/KfFi93wH8Rzs6wMrGrabZE9GhHUGoinsZgMQ/T3Y7JrSM12fYyX
2SC3S3QxLvaJVESZ9yPfuFPWlSKTq0Ws8g+JtxfJdUxU+Yu/3dOBUkcr5+/QAmEvkXmEKPqtPNeeltnH
MQdvCHrAQ3Oh7oT265E7pkkO0pk3YNSOEQLjhuWBkQt70kqIO3I5Ujkz6SE7xIBB0z1JtHDMt4ha6zC5
zgNGOBWIEwFa1LDV7q2/tFtJkl9xwVqFha2eMughbdQP9AvAwEFxcNiADjVolcbM+lzBEXfSIka8TdgS
WVNvcdk65bSHzo7Egb93Xuk2fhp35DpzsgyD8z6dqFy9NjIQRts9NyRBOupp+uQDJmSNfMvEMTI+Dp2m
CZcfRSYbXMrfssO57WiMF733vwFxyHsCT+2Q6C7KtFP1ArGeZyEEQmlpopQPERqNHKx0FNp6UXAAGYLj
s6Eqi1s/Ys3hywDdDwH4nyvwuwSLd72+JniESxb0TsopGO6ekQwip4D51fG7AedSv4yZL8WoCLX4BP6h
2JIwEQzlxoH/xt+seOv29G7YlG+9vt71SJvZlAOBuT/pSjw8J2qePv7zf/6F4/2bPoQf/zXfVmVd7pqx
6aNukqr5M9eLuql+/OG7h0j+74fhIDumoCKyFf+qGv/t6yn7MXYGUmWnjH84E/+MvhC6INVcb0vNo0lh
rncKUzIgwlx6gXrciPEF6iF1AWvI/H71aCX95eoRhdTj4XXUw3zwxOX9HswLnzaaDyjw3BH3Mhjn7LcR
X9t9ElQlslGm8rn4etoLiO0++1SV0oPrB6kOM8nlnftq+mxgvqYf179xHDSpl4AjLPZLL2YGnPagD+2F
tnXSKY6LPnu1XwPgcz9m8y/N4S455MXXxzqr8l1rn4+bjE2LzOwkf/h5Ek1XP7Qyg2yT/OAY/TTfJg2b
N4TA9aYvgvsSczI0X+sPFd+v6cy86oSa1fd4q5kgyX+5eQS38DHgcAw+lpiTKE4oG/VIfqQJxgmA87HB
zyu/Aixe0TviqAns9ZwHPakRaZ9TjWACRjCB5zGBQFgra/34nic0tYeZf792HkEUjtwciM+ERAmNhOE7
TsjOi500n2jxJe4C2woN6PU25TdY6YKTue9MnwI9nHoz3X0JdBpYWvqPwpCGjvvmfRG3D/oI8pjp5RCh
VqpXqaVNndRMwDIAHl2l1xp4XYMHFzFPYpd/UcvV0BaIbflwnBajfVnlv/KHRotBmhpAr0I1ME+SWpSm
BIOMdsU5T31AVa7A+SGBBjEHBsMx91QgCbJApp/S4G0wCg3/Hs0P+jeJpRiWATCZP0o/N/xky5yGYSiF
6ph8Mg3477YY0qD+dCpVBAKC0aUuqI7wxMCmXIGLp+ENkPzLVOnQUFBvihQQ/NBvwJxCecCjrYm4bATP
da7dOuepVkCRgML0UBJCAXoJG4jRFR0pq4BUHO77/KaYq46zObMe2SzeM8YJW6DCKdyj9h6v08J3AkCY
4x/yw6msmuTYXMFrA/blQVi/z9PMeTEbVtb78rNLFazNjyqO4AJCC/Qhm7BQAjlfvx+jD9EgWftfCbAh
63gBzMQjym4ChK89eiDZyY4pKg6O+vYhcn8aHerRpzz7zAlRxi/NPuXbTFrp61hxc/SlHprf64P9/ZDa
34vnoNAsGqlWQ1giPUGiCMPWB6IEtzZFGPaQEiW4tSnCsMUzUYJbmyI0eRA7TOiN+fK6XCyFN2RZEFRx
sdJRgKLi2lTBuhFbwSCiPZRuk4bbbbOiAA170U8tHzfjkMxEW4Y7sSCCYCGJEXmqyn81/axWsdNPfegp
MQDoSQzXhSXG5iCQmNcuKLGbR9Vbjrdj7i/de3HfLXMZCof7iWO+7wQdHdKeQgeAntBxXVjobLEFQvfa
dQu997Bul3p/1HeI/Vbkd8s9FgF2ACWwae0SBoCehHFdWMLFM5Sw165bwsQAbpclheQOqYXR3Cofb3WX
HhS0VMjE3rx2KIxgJe3G2KGWCiWYp90oDc9U47BPZZ2qU5Ufmw5fQ8IEmrRrtgvrKTdRHdZvAQxVnGqN
tdwF7uVaUcPtmgcIGin8Df10ThUS/v5x3TOnFCKlZa0adP1/AQAA//97WTMszqsBAA==
`,
},
"/css/images/ui-icons_222222_256x240.png": {
local: "web/static/css/images/ui-icons_222222_256x240.png",
size: 6922,
modtime: 0,
compressed: `
H4sIAAAJbogA/3SZZVQb/RbuQ1KgOASnaClSXBqsUNzd3aF48QLFgkOhSHF358VLcYJ7CZJCsdDiFlyK
3r7n3PvhPfecDzN7Zs1/rzXzm9l7PfuZGA01eTxsKmwAAICnqCCjBQCg/TkEHD998mcvm+ch8ScArZTl
ZQDPgw+tvv85w3JTMPT8ExX+tcmNOr0BAKhYFGUkdXwXD3P97W2HA4fF7bqe1XW2+Kc284JfrmJW3hYc
mCozu7uf6C69csK0clDO0mJVaEmikjoc0GBV7H2vtGPesPJktlZRb0kC+E6qBOLQqEb3ucGBWP7U0X2f
GS9IklEz67IKRedhwFIenDM/IXwmsr1c7V/Kj5T1PxLr8ZtyDeK3C+r5repGncC8DivAWeM18MWwFxIF
jVAw2jjDIxZUfTEIeYeY63+8INuBgHCD7uKI9OLbsOKKrUNebPbON0QlUsI4AP3n+VgtJ8UJdENtCQ79
C6dqIg1GeEUo5EdDWMrpm89Ez0HnUoD4eQWGmOy4/tMKYnIgsAXKCQRKj3nvCXk9nQmElnwcFYIzhEud
RUfPYLENqstlcgUbr1pONnaUOVev00oxo00A4aRlvPb5b4qWVU3t1UpXF16pSlqNXWxMJDKwdhHb08qW
8WZAHBEN1uq9ogKTtoLjMA7b7Jwf2qxTgLfhINcsXgF2/gw/bCUt2gAa/2gzfpjZMEX2baX/oZDQDhCX
suVyeOYbTRBL/c9jXLjbvym8os5Do8KfAuBF2UEj+5dAG+v47XcdcXyXgHdkaAK2ExnTtLCcsC7/vQXQ
AuKn5o8r0uSUJky3WWhmtgZScj3rqNZhqR2ZdvMWpZ1/092AwboIkoEfRbIUqtwIiK2QLQ3SwnREPFGX
12/D3RdHt7uhzgQFN1zW44rYFf0Lw+WxYlCHu7ZU1ak3hYjFAhU1f6BucwhzxH79EigjY5w5+HOWv3c9
WphrTvslIIzrkevPHb6iDmKs+J9PkB2xTYTvlt7zYOawe0pXQ97F/YlnBBz+Hayjj/7DGr9g65SEMFRz
/ugXHX2NxMvYKr+FMTrvQAuVwW/UutYdCBiTTkwrZgmgZQ8TnxQ+TEBNNVKKXSj5Y12rGyaRLD6+maRx
wGlRW5gZIqXsXI9nVXn3i2TNKDD3S3xXUijt02t4RUzzZJG3EmFZA4hJd8I0VZmv89z2KZ6X56Lh4US/
BIctwJY8pLB/pyHC4+c3R+vlvzxBUXOqNBuf3yHIePAk05sPXTQK0v3wJmRylFkhkxzAQ2pntX5mqxWZ
ZpcnPzx8DGX0InIHD70qn9i+gGbv1Hwdw6MuVekZo6BArzFuD5HOqOJRn93C0qC8KmCGr/HsgA8279gH
Ll6H/BsPv0T/T8qCf9A7/QkfMNxbs7jCXFVvbYbGyjUbiS79sJ83UWKwhm5YpMR2XDniwV/rKI/reXwl
42nLmmx2ty61lv8wtpHfjW+dakw/kQrWoMOH0P30mrZPeJl3EY/u5dDWFglPR/6F7uUXtxk/H5/6MRcB
Yw7Zo1HlpoanJkS2tWp/pen9TkPo3VTSkC6RHr8S0dG18Q5/F0EVZjWPIdx+aOH3XbjqLKYwpdHQskbb
AHOQx5YS1oUWCnZfUbJ4J5V+d2h3e/F7yWqJAraKsYXfzA/NDHmFq4HipHeCsrHFSihI535gDcw6rQut
WdadJyxbHrZ25AurFnuacapuVTUPaEnhR+KVnU3+1kprxuSBQDuhvLpIEyFtUlWHaN2m7MDKdtg3aBmV
8ya1gnOqWi9eGWpFqa7LnZ3Jthwg6FkF33veJ4rzPebwe+feh9bJ3gvVRZVdnZ65oW4Mjb5bTELet128
DsheOlyi6dYl4J2e2/p/cs9D+/BJsqqJnd6VwCJM0XxT66Ih6wYVVBy0Cxx/e5WI6LInsAhVtEY1KmfY
HwzR4GfsaV65pf729bUQe3A8sjAN0N4DSbUQs5KNow6/tv5gpf1U8/72674cf8ar9y0LIQI51zrlh69o
aPFyK1CQFdKKeYBIMaipmy2bqoqCU4Zx+J1A6ZUl4a+qfRwlUd3N6jFkUKMfaxIvtIaVIzgkwKv3w0zg
5jqmTXunI2ZFE4+3qYbO+DynDA0dXaDEEKCoqB6bYOkduJ7deP9bfAi95BxY6kEnYmeSVW+TXjmhMIn4
F0lipZQOUBR8nNSWTmUs5w8gd+lZEQunzOSELpb0LZ//eFFyxfU5HFdJa5BQF8/xBvhFxOBrHBq5beU7
ogUc2+pshBUiomz8OVga63LNlm+VVmIIHr21EorESpmuR13hwn3/o/6Hj3klnAwEFLNDREGtu42qbNnw
mCqc6aIO9jqrsMswnles21yrqqT8RsWipmBmB8p+XW/DfEu6FYAZJh8ow6dysmNltOLdtG6jRMa7lKop
lGxR8Cu8acSAereuZxWXUv4p1XhgdByajc+RrM2NW+74OZQe9eBia/Z2mjbmwUUOz84ueRnxe5wM/bfO
8rL8K/zR6fqa0QnaOpesmpLb6qn1JbXaHET544Uagti6Ja47oRZaFxaO9rkMkqkS4usQSnVRJzM9SiB8
FUC5EUv4kWk55RTffoFIQ6yxv9AqeZcmbsG1y61LT0o+wYCeo4YRLFu/yN5jkmfWluoKGOtEt1GtaRpt
Mh21KUoom+MiJNmQoN+ozYqeuJRpvH2aQGK7CpyQ0xVgsRNA0iy9RGxC+NwC0mBv678btJpTWGY//wA6
oyrAp/K9RKL3b9H3+cxwWV97odF2YP+/xvqnczTkU1g8X3HI2FG+wRSmfnzWUuqJJ4PLQyO4jD2bqn2T
IjvrKj1iOGpU4MyiVp8WZK49lFcxSIvpF5u9YBmV7as8CiT+PkOXUNneT/GhnZM5gPVqKkd6UXm6NzER
s/VJswEYaFdnM7t7RpkGUbTb3iMTchIy1FER6+PgxjZ96pmTTuXDSR70+QLs1RZeNUOzbbt7hWWWFES3
xSxAgfbe/ixwda4FKkJAbjdzky3ukm4lz9CY9hXBuyKiLvQbDKjOMm1lQg+r4YvAx8kCxpUg32M3y+ZJ
JECeD4OJBLAMkz0MrLWsQkapV+LTI2ZkmSaGkRbhjDCZiaftHn0lob+MskTSp7IZGn2ztPoAz07K7SMZ
yH6DjwPfxy01R61PNS0SRuE2bPsm+YEC5TwkeRlH2aDeIeg6xeLBb74uMET5Mt4HdTXiyrfmQZ1wSztn
JfiVJZpE3miUaMX3JqMeVR8kA3ImbU2VgUi7ckI5LqkBQHHknNc6hjMYkKduSG8TuU3KACZjfR8crodq
Mmh/FsfkcsaIAnQrGlMG02iRaaVb8KXpJEdgVSMV2h99KJMMYd5i1XsPVqBQQw1Z621dpklmNDCZxOz9
QFux6UbuSOCWe8b8uqsgW4V8q0o2XsGk7aqmAWgDUqmbkLmI3sU5cHS22ddUcUsuBAygoc+ErZiDYlfy
69YgJv2QOLdPegpmkwgTvAq5haLSW8u47UzLyG3IVg6xM+/kK2PS+d+Md1Z3riUa3byrsiPPmh08oYk+
lKpKLJDcYJ3r2Z88AgtSAYonHFY3TZ2fetAsPiKiNe4/tRgMEjnlHFFKLb6AURgTJtxzyp6pK3iR4twF
oPiRMtOsDsR/RdsIn6gJSPhyLxS41LNWMa75OEZqLHl1gue5jfJLV1ytAO5MxiQig6hHfrOUIFJLspgt
CKzkF6QOl2Ytt20qgFh2PzashtQMrUm28fpFj0oT5+ladZ85kScHNrI6Ar6emjIYgaJjxiQihtVh95jP
cZTcxBKSrCDH5xhx5Q4Dc9I3/1zFOKZ4epnMBSsG/lN93Eeon+16ENlg2AtTT3zv39xSFVRhhewlh3J1
XKeJq7LeZ3+b3vb0QpQlV3CKr2KKwPKNF8ulyz06TIdZrp/MG0pN8o07n0oH4DlP24INtBe26tzkO0EX
PMrU1oqFDUGh3t+AOCo83NPjfnAVr1uPa8XuZ+KftDqYvl4Q7/YT53AO+CCGv4bYr5dfnb9QAUwoXeID
aPQoSnHiZiZ76maLcDiOn5zloG/+jrFrw/ONNxdsRjl3Zr4aZquLwSX0Di5RZW+UGPFFiQb+WOovPgun
23R/M7YuCmPMwsiyyHVIwxYRO9kpZ8NM31/qmfRvG3j5EGM+ey1k75mZCE2OyO2Ow6fYqXOLkKbWn0ne
ygeRKbdYSJkqIA6fB3YXhJtroGrUmgaox72Iw55p0uQ4l9fyGo5qxtqzF3ynXh1jFl9D+uaSQ0R6sb5n
WBpWz/wV1rMtZlIyKftuk+5LYVHXeUsS15HhWGtRPalSYly3LJO3jiMkdzNicfGXXBQL4ApUfHK+YPXa
GJST+n52PuNVhvdO/aSAabuzE4HPPX9P/9eMzX0OElwR+t0HJuabRrw744DU2YCw2QBDh1Z3YgsRukw4
CFg7M0PgbmB9zcfuHRDE3UPsE+zxodHYkfNY8Q3j/QNuPke48JimCIyRg2/4d0X6AETi6QmVBBPsUFtC
QqA/QunG/8eGQHe//zX+0Uv7v5JR+glB7nSmX8qiqSe80MNSRO/ZA6JZfvOon1p2D1F+wokRKMjq57/R
vRtQ0B+e2lp9OrXlTPi6puTLxz2WOqCRcKWRCSjDlWBqQb1o80vITdK8baRt/FCRsStBRb+NZXwyJWz5
3kPWhZloaaw8eIIItY6BWqd6SOEHu+TQDSEFfk0Ri5XarQSbaW8hfLEVHNOO1lwcPv5pIDjQbehS9KA/
16M9yjy1eJMJKvTx7NM7OZIiUsFgP/+Mil83KPVVILhiFSinTQ4ZFMkgjxmdeOAemkEUYoZHovRTNTYV
2K3QEM9gt60j8r7AjG1u4Umk4pwhmR+UK/Z3a+YTQlVwtddaqE4Iui3FUipH2XTPECcQZ1kL/pi/Zttu
Mz5FjN1+95ogezZD5FzY6apfBwWpj3YJGTxr7Ts6IQXkFYyTykbLQ9sCTPS9j0evL4aLkTsSZipXT5oA
smTnl3+KbR79H7K/2A+XsPLTa2wlFt3N1Y3EeLX5r8Oi4FhcNz4XaHLqbDWKroDLKDwntid/1ggiSrJP
r4fNcfysxi2SvzPb50wsqJKQ3zE3YbhnIDueMecXKHx57K/wAKh2xPXbK1I/p8hOMemkdzi8piPSZSyk
iuYg9cZetmA0jhklRN6gjImJ4uXwXmCa7KLJ1otnH1VTWbdlUVsmnchaJIH4UDWJD3ZCCRL5a/hjF1w2
zypGIH3da6PrQ4eI6PSRd+pHm7NVpwo4/ntPhtA5jbeqP8cEbXSik6qa+LHqe9m0Oc4kjZzZ1fpwaWNh
GE3OBVoVzP6HilfVOrXy6+pf2G5UgybwX99lfE05LzfAkNPOfXDcpcopyDaL0UwBxdCkqEW+4yffN0Lc
fOdRswU2a12bxvF/E3pMFR15ITGCO55jzbXl1SQWy+VPZLsBRUUCiVjQW3QUKzxDP3ondeCcd77hFJdq
7HWLS8dpEx8bBhiUgpSwXuT5LmsqAQIfGBgbBhHRfBEKQC8GvdEuvVYTliQAMcywlP8oUQATmg/cnRYw
fEbh/biipC5piTKG2CbU/jZ1ExZ7JlieU4CK9Dqv7jBv9hs5+iI+qq59DxsX1Yt+dOdKrKGZ67iJSnl9
XCv0Oejh6bWhbHQCWv0ArjK19gg08cDA0V1CFfCId5cCuqPmPnY7N0gBLDX/KjMu1O7dwLF+KhjGoo0v
gHUs+0B/n/c1NrnDHBHC0mZ+ffHSjH+j1qrePu7hCZTdCKvg7DmJh8oH2lMjSWD0KePMYaoxaBn3jgUg
PmEkSOzvYuR8RjJbA9fMkLFlN/sy5XpSySaTeGtXVuWxEP2a+5br+e6DgtzyUBMYsvvwUg4rZf2KL9+a
60H/IGjBIgkTGhWjRyXr3DT5eCJQq5W3lt8stNCa5uSX6tTG9YDERfywWKJak8N3Awm6gdw8wc+zgc8f
yaeVtfxZvYM9T4xhTAIkeITej57Lkx1tn0Y4pGTm7qsjz7kbRr6GmGt4icPIDTeJ9PziuDwLEoGEMYak
39H509Yjzob5T37eHDxmmkTrsTF+RvpFv+VzTKaMsAtvXIRJdmNkTRdlYz/YtXGWQxImVg5a5OzH6Th5
vwoPve/MEU30xAJdHYPrmkpdShPpxbgTzd/SbukbxKqeMv+ez3HYbe6L1Hr/I51A02un/Nx8DdH7fLW3
HxaWpSk6zhrLa/zl2jyoDGb1XAeX/gP/QdSKJ/rf8jyrHOc4ce3/Tj4blBZG+9x3at/Ks0rO5NIraP2f
nj53i3GwaDvGxw4esPNUR617hnF1ygdGg9e8RG/KhXNxvO0W73/gr9ilall8gq8xnyAMQr1qNhujFgJr
sBbPVy4vlgSjcesBcXxKJwbDlLYmiFksHiFHMargWgMlhCaFM8x5+bpp0beFUOADqwlE8+CX4uSV2Cdn
bKFJwdH4yJVe2UrLVw046gevQzgHe1UpR3kV/dbf651+9jMjmiKzSpNVO8P96qmZHJot7WOMd0XCh0X4
6Uavc7izAMu1w8+nl1BQqSf2ZkOZ5V7Hu8d5rfCNOV2mQ9wQilznfFZ0Mlt00kEVG+Z2MHVIC8bYGTgL
FvxuqKqfE/Eo9jBbiOPMSpYZA5/37mFP+/HdzBE0tfGGv3WBTw2wX9OEH9ie5ghQKANo4mnpxIwU1cXT
x307fred93al9iiog32LMMM604FME+d4VhQPdttWoWopdrgc8PSErerivhE7+oUEy/0KeC7ux+xwqruu
+us0SJBEQb2tIoqO79OD8KTP793nK3M46klBSVeeGVee02tO/n0xjVMvoC5JV2+6Swse3qNwP6R9NuPb
QYy+/+nq02iBY1kcVdNEWAf8/sq6c0+VXvpjNNrc1UGMFYr2TX7x6jg5ibtIDcW2a7JYCCfKzcKcD4rz
zk5EQDl82ECPoyQrZIgPOtwdPo8h8A+/5l+GBH1C/GD2I60nwDJsBFCohZNAUqSvL4WLbcepVv9azjgi
HvHZckoy7Y+aqVEpkBsS5XTBptGzUpWOSgXijB4I1hVMKb+sNKhfeyzSCPXbwrvwPAoiry4TC+msW3ta
LVqz/BnhT4xf6svwW+y+4gRY0B/mvp6plbHtHEJrGlIQyz0PO+in54E7v2SZC2xkrDADeRk0rG7+FZvu
1SwkJ/2z0rDvxcsdDV0p2VLWoOrsmbyoLDS9TD6zzZp+Nm2VJAWoc/iTPu2mdhZFSUzju5Xebopboo+4
9UYNScm+nHoZz0dK65VgJOzNuLsdmyZfAhoJgBDvMQr9kkjSdyoUSiNOgJXl/Ag4kpXnjmfqlKjxi5Lf
Xt4fTlvTloPwwbd7tOF/czp68v9xS7IDzP4wTvh7JjVqqJ571qa57iQ+0yRWUvjhQPEFLrwoWyRKWE7/
x6hLmW8c5q6ICWuSfvrEdi17BtK2PQpjVA4uvHXNcUV8SkhAzLbCIG/fIDO8p9KyUyX0aPw+ZcH1zxoi
UPNOY+/LNck8y1TlZshXbe7Tl2bWEfFbwFnWnDH9C4UDtXtCfSGd43IaDzFXt641N1PVYOl9dfGiw4Fg
toR7WmyZb0XqAHKAFfcpub1nEU/oYo5VknA8r3S6MC1n6uzSrOveUk/dp8e59Kl+7xPkkub+eh26nPVN
xVGA/gaTxJMvTxSkavkGhbeaUYkI8Fp6KZKbVMY3eJeWSgZska0rMjEUVWbn0FTVlvTcIpIp/jTlZ3gX
Nk5nym1Xd7UXAd5nWQsvuiEM8tZYgb1nID4n6EuNCtnB6R51jq1L8QGnddqP5k/S/exZueOOd0CdYn++
RW+0fxhlIxSw93QSpjeHolkzdJuXpuVXHUFhZfoyp2QWHQQFXCtbb2uR50HzrvDzsWiKNbUHPclbADK6
B1G6RK16mb16dIOXZQaaJkn0eyBPUM3VDCBOKkdmm3H6u8YHpSe++VjuU/l5Hh6GfTLFul69Z1fdY/Bw
ejJfGubQfs3cboDtXZcis6pbs0jZPJnqvEV/SbuGM5O8WnoERuZ1j9G0ON0BLtCa6geONBRKFR6lAQ9K
S0Gjs9qdEur4lTG49Pvzsej108l+gtkJCLwaJ3r/mxA+yDx+fbnrW+jNIXHJVPW06xZ64a1/HwBzn4Vh
jaXvcZPIiCmU8pf7OdvLJ312qdeF0ibZWQeMGIuTJp/be1h2Lkh4cHLKb0g0zAf2x/VVCrOeCpYeMUs6
g5XSH/+1BBNMb/RkEQVyK0aCOBopgol3f+EYVvjeoIc4FluXFJeMbxLgqNOlswp8QFwq7pHrlfXQe/eI
zH/+Ay9UB/qEnAQps7Gbr/7s+Ez4Zj78XFP0PovND0+shvAxlK+7KqjlJnaT+5n4UWcVB01ieE+7vtKv
Kk2o/jXBm4zi5XH92SPvXfG14FZG+Z4E7kOqLuTFs1ddGM8xoMo1jZP+6+UJJywcij/3ZvK3OzplXz9c
zAdo7eStFPz7nUYKPnUQ6hT47+Z4Ba5Hj2ig0C4tKb0TSH7G9fUY3HuXVjrqF4lG3f77mpd/qk/ykET0
xQYl7HvI6wOK3Rh/DBpnmoqzzVz6mor9Kzj9FIDR4gBGJBd3PiIdRcvwNgxrNoLbQrDimDXmFwmPFgOp
cItwxIf1+SEJWiYGbqDLWbBp+zBc0gaQbU/zvl0e/fpTwX+1b/3T0YbuIjW46fkl7gNbErGkmG/MULwC
lEf+XHjQCcD6CbLA8tmK5pUrXnvGLRofyHkoOCzCxesWdcRgwiQxYvCzjrqvTxxShEI0Wc7cB+HBiUfG
ClSBAhAfJ/LHMcuZlzoz9+tyN2nmoHNsPlDGC5jvImTUXJihU89Xy6aIlyGQNHZ05YglhNYi4wX06AEN
pguci7oHRnmsiJdhbWti14ItBC0+c1WhrpygtAXz4AJzvY4Y+FTwh7nwKwK424GpKVRe/fjxk4qBtFMB
/zcAAMDkJWvgZWPpZSti7WH7JwD4eHghnDz8nLy8OryvRCDCIrx87Dw8Ijw8PJUO1f9IcHG1cXjr978T
JM+nyf8kUP6doO361svH0sMWIGnjamVLr+hiaWerZWtp4+c+aiv6968uRVk1mVopi9D/EwAA//+8TjP7
ChsAAA==
`,
},
"/css/jquery-ui.min.css": {
local: "web/static/css/jquery-ui.min.css",
size: 16939,
modtime: 0,
compressed: `
H4sIAAAJbogA/6xbaW/jRtL+nl+hzGCMTGB6KFqHJcN4Ecy7ix0gQbCb2f0qtMimxJhiM92kjzH2v2+f
FJvsKtpBZAxGatZTXfVUVV8kP/34/ez3f7aUP8/+/WUWzR7mV/P51UJ+S+L5MooX0Xz13Y+zY9PU20+f
fv9DSbbFVcpOsvVLlZZtRsV2ljJOr1IhLmeciuIb2Zf2Z3OkJ/1Vin9ls4eCPs5Ilc1OLCvyZ3m5EEbm
Ul4TRRPq6ZMW4KwsKf/0f3n+/zQnbdncfeV036ZH2nxI4l9++5B8/kqO7ETkl/9QnpFKffuJF6SU/wtS
iUhQXuQX+aNTsGdldpEL91O6Tk8X0pWK8n+RrGjF3aJ+utgfPrOS8X9QklF+l6/ITXIjG7/Sp6bl1DYf
SibE7pE8UHnpy+nwa03Sonm2V6+XF3vG5be+Jrq+yeObizx1mvXnokhZ5XVomq0Vn1nV0Kq5o/pzNsO1
H4vDsZT/mp1geePZ4kTmcdy3xjVn+iPNcQ3X+nO2x7Un+uMMcuTlK/V3Nsi1H0oihGdHR7dvh2tO9Ufa
0cmlm0W6ONvh2ml+k8Y3XXjYgyIry5dpjxbTOrbBtA8ssCr26T7eqLDon+l6vYiXvajoVr/vn9KmeKDn
SNnObfO4d3th5WWFU7LPbpax7N7+pnuZJfG5f9fsO++iLm2gi2XaI6C7gmTGWWjtJ+pZLc2SJFekdE3X
K/XXI6a7kiQ3NJ872/7GOeN3+5v5RrHt7DKtWUEOrCKl2MmBIL33jDIS85u+QaYtzWISE2mM+TmsG9ea
JWvijPhVBq0kz3cr/Tmb4doxQ5xMEl8wv2UZO/2/HUnGHu9i/Tmrt815SXzCbfu802gbZBe6/4oKYZuW
cgRieS5o85XVti06N/5M86bf2h+9zhrk4PuZ1c9chUcP7G7M/ztrq4w0Bav0qMzkSMvlYF41vNi3DePi
dvZzkdJK0Gz2y5evsx8/fffdVVtER1rWlEfHIsto9ZIVopZ8bCtW0f+OLkckTaU/hZwTXkwst/FtWhb1
ltO0+SGe6b+Pt0eqzNvO66fbE+GHotpG6ruqt7xkj1uj7bYmWVZUB6mjZnLCkKZvyV6wsm3o7WORNUel
oW+FnJFo82JVxj18Zwxrm7KoqPym/oucIVfXt42MY5RRyaomSXt4m0t+IjnL0a0cQD5IjJA/m+eSjghI
S0p4Xjxt9zSXM+Rl6BLJG8pfUjO4bt+9u3VsNmoWtUZGqZz9SC3o1n0JdmN1qZ/bvQxmSOjlVFTOxbgv
8E1dtAwqvxwN6nvDasWOTLYg7zaL5bW8KKUJ25/K+kh+sNl+F3/U/eRcOvnyLSqqjD4pvbpVNKShkXRa
uZu9pC0XjG8zM8h/X5xqxhtSNVpW1XiXbfuSpfcmQkqjJC/aqE8gZ/YkvT9wlesyG2pKGhkp+03rlV4f
aBMxU9cvnYOSEZr5zocJ0lq6pc9ZAaey9OV47V+PjrLY+mIdkefUiq9U8vu+RicRNUwueWRJndNx1DLo
zFE7C9lw6TcSWfSSMxqUHdf5WaJygatMI3XsrKUXPc4Ul2qgsnQOtAinReBaZG437IQook4RdYoMWunR
o6DBmsiCcYwenZrHsRrd76u0iM4aMTBnnki4AyadbSry1kU3lvW0dUaJgVWbs7KNZ2CPrmHYOmXVa5W5
CA41dU5WFNU0oL9TZWrwRVdATk5F+bztFvizX367NIv7S7u0v9QL+8vzsr4/Kqt1fE/nbKjeSPkyRVW3
zWWvQdBSTk/9FjXUEE5Jv03Oko0ck/4Kqz17IjshuBlT5sFMjhFFNnsvV+m9AW37Xu4DZi0vf3hXnMiB
ik9Sx/6w65Z7kVru7WRa7syeYTd/kj+u6urw7uNsGX+YySjMzFgYPd2majWzfS8X/gFjZuQlfP2otyoB
W80exzPXbKACFustVKS2ULvr5c6I7ZZxPDBX/RuaK9d/hslHk2dqYze272y+lO/PPWauuQw4jApZrSOZ
AA9yRzMgQf0FSZCbBR0tIyKjtYDdH/rs+DBbprGLM5O7g7atXPXcBy/oLbmalPtqg4uiXl9HNY3iZI5E
RlSeJczvnKWtwJWOREZKtUQgOmbL5wdIbyTxAGmRPxcgs6sckuaFx7Zsh0y49kHQXLMN2ZA6T7VtGal2
7QPVrnmQDcaHqWwger+KR24sMwqdEQnGTu2X/djlORi4lRxZ9OfPxc3sxkfueey6piGNXfuAR6Nzsqrc
eD5RWSGxcXU5qRCheqs/IFQdKkxPMmtFrhJ93RyjDxBCLs7IK530BWE3exPXsFOqTgvw7kYio460RGjY
1ycVHpfmICTAZXcEEekjgN38Zmdkd4tYpmowU2+D85m2ZorDgFDYLWjW1BcjlbWv6GgkF+5Liw27q3nB
uNxGqi9yF/8MdYfJ9bobir0EFw6dlJAVWWWv6TYoGeq4E3xx++ardXjjvI4/ekNRxfiJlIFt88TaJSA1
Xry4HXhn1PUybNX18mN/R62zeDhceZtOvW2HVJ039nZPtOrtiVZ2c6CuQz5q7MieQYEpIbEzR9e7ZLl6
SlxJBdaJb9RqJ5SxVn859Uat5oQX1Grme4+b/mz913Zmp66/2INudH5zFNX5MqjXjFoBZs5DzNsjrA6T
Az2qy9G+JNV9X1N3rqPyd+YlcZQSOb9H86gKAuJZHBClQdlIaw/IA+LXSVhcAPKLG0A+LL5aAOKPYfmb
OCwPiG8AZytAfj4PuptEFeTAPAk6nEQUsmm+GPjcyO19dSgpEt/IT4c+AgszDMOiDaPQoCMwJPYICksB
GIZlAkIjmhAQbjIvYOBEegyARA5Cj1h+qMAFxNHkCGPQzAhD8LQAMFhOABA0IcIYNBsA0vBUCIGm8wBA
UdApmwZhHJw8K5CLRIYJ9m0NESLkJgxMvGi+gTixOCAzkhhixeIANpMEYsXiAP/k/Avg9LYJqyyVxBAG
LS8EiNYYgsMLDQNi1Ybh0JJDgGjdYZTixQcipysQg06WIQKeqkUEOl2QEPhVVTkBxktzAozX5wQYL9IA
mNOm5RWeW7JUVTqjSIgvzfUkGq3aSTTAmCldEA2zZWoXAwLemtrFgICjG5wm2EdbvEFkzqk4wl7a4kWh
UFQXMEMOCg7gMEcOCvm6hliKFlDeqoiMhCN1tIflq4+S+1N1coylqA+o6ONjAVBnktKXt55jyegDxLHN
8xJg2CShD2g4qUROOTykbgKOO5SpM3g0ngc4yFnZf0wmgwK0WQVQrKboeOKDMpa2J31rFg5QGBHtsSD5
mIo1AOEmQr70iRRllJYM8txGKQCCfd8EfBdt0aQEWrzYyPiQlJ1gtuyg4CNqygXDh4IBgBdgB6uA4zLR
oPS3Re/Lq4dvIGLtDO0D2gqD2HnZh+wZuz8RDpS9nY0HbkCjip1+fekjO4XDps4k5t5yOi/x8WognpKS
qvNs9CBiCOFAwOwBhC8uczQtSvTsYaBf8Y8eOvjyWSEA8Q3gcdqWpGGAz+6swUd9Y+wEjdPukGGMYC2U
2ouQ54ISnkLJvQr5LmfCCkSsQ+4fKBRsWw0D+SMFw21rYehEA3VgC2EgD8+XthRG8atSGs4nVQ2Jt26t
yxZaIRhyxuJ6BkPLwcfItID6sPUQkEc6sTXhg/T0gNZEQB7pZBPy/p4+4yXhi+vz/31bAhOjqwofJNJC
CMahoCzCzhf1nhEOjeKrIAOshrxZh5yX/xqSQuW6CRGg7zTgpeEDHoqMMrw2hmzxooaqbxFyWw7nQLmq
4lh46+GiygFrbHH44nJVU6T4ibUPUM8mo4Xhi6dHOlETvrxMvZIC5Nii8AGcZAWLoNXJJuSzheQ5Xhg+
qC6qiY1UADBREQOAetIZvEfhLa5r0oJLPnsY7+8XKL2Xu5IndIkcwtScPuD3JcYYufTAb0qMIWp6wYMe
AOUFF28CNQzI3E2IM/o7BUeOeYiwB1bKTQWSV0mIMofCl9fD+LNHGp6PVa6s/R1CcahIObnlDaLQdPEB
e9I0lD9HMZouYcwczZcwJkEjH8Zco+H3MWnB05LCaw1F9CYJIJClg2U6CEMWA5bvIKy77YXfPsSx+E1E
HIvfScSx+KAdxJoTHHy7iyEnbikiyIl7iggSPMpAOEK3JmuEIHyHskEIQqZqt/IJ4cSJlCVaJxodhk0W
C4KdrJgBVvzREj5lri0YBIqYbAoGwU6u+AfYg1wpRhmTo1cWPcg1YJECY7JiOVlA0CPjxTe1FAYGdEt1
QIF+bBLv2pENoqd6t4yP8YYz9xgmeIfOsh5yfwpqSe+g5mVNud4uL3s/5bqh/1O9eeNdLu2DpkpQX9Ur
zFZs36SWdw8Ju+u8r1dffp1i83YRZvK+M9nIvsHqsfKR4Xs+0B60ffCK3zk+2/erVehNjOHzuEm8M28P
Y8/jds9OAo9OLmPveUOh39B176aqV6H0y7D65Sj3nqp+gatnbRx8eli9YrybxzvzBrIyEXlrprMyCVuZ
xB/de6eWRfWS1v8CAAD//5Nr9MErQgAA
`,
},
"/css/rickshaw.min.css": {
local: "web/static/css/rickshaw.min.css",
size: 6044,
modtime: 0,
compressed: `
H4sIAAAJbogA/5xY/W6rNhR/FdSrSatUI6BJdQfaH3uObaocMIlVgpFxmuSivfuOPwCDDaRV1CqxD8e/
8zufOOQ0/2hP+Pp+5Lg5BWFBBKZV1zBaC8IR+SS1aNOa1SRrWEsFZXWKDy2rLoJkgjVplP1CtC7ILU2y
A84/jpxd6iLlxwP+PXqRnzB+zg5MCHYG4SstxCmNm1smOK6NQtbgnIp7ECb7NqhoTTDP0Jn9QlsybFPi
Sg4fVGyI/bdAQ0hrnAv6STrzUBotiQYhFeQczsTjZfHbe4UPpOpKVgtU4jOt7ulfnOLqpQWoqCWclkAb
L8ALHBf00qavwFqDi4LWx/QNvvenhHsjKHkNwDe0CH6QSH4ypb6lv0gaJ/Jxx4eWz36UZZldT2AIakE1
AbdfAfSmDWFFStHJf2v89MKcHk+iU/+36OxcuFawLXIDniXnueWrPA/uXQrh3XOWs4pxzZHD9kz0jPmR
1kgxEgMU81vbbC3I/EHy91dIV3H2EONK8gt0O9G7xMbP53VFKS6heHi8V9C2qfA9PVQs/zC1IMpORKMD
iqHo1CJ9euop3g8UqwxuMIf9B7gxCCTBkl+1hEDZhHn5u48iiQBpF08t7SWkCmQQP0L5DIFeW4OgDlhD
oDFuQiiY6LTQDpQbbnfjuZqLZAYksbjQGbX3lwt2Q3Bqwa5pFEQBPDYJ/rdnp6AYrRqSdUwr7hVJlXOH
uFB9ZlSA8oo2qUlrBEevWt2H7yTI5k+MQclJhaW8o7P9PE51ZOyT8LICk0+0KEjtori9C1jxBLzukLPu
F9kuV1UE0AsyLSPJc+ZpwktHB6GgoiIeBN8pg9BQ3Io0iZ9X5UdlFeC3UOG6ZgJLCIDrTGR/7UwMxqPv
VVY4vcqKxziyo8/jKs85QTgueogwKGTj1G548+WESoZXbzLYcemkabL31EQLpCJiIz7QiG0aIom30bw+
T/Jm8/iH8mPyFJTcI+mWp7pJ2j5g3PZh38RoHgtZWbY5J6TuFpjZCJsgNC2om1cx0/2jKBqz5I9h4tBl
fLUyWnXcmljmET7ON+7oNk5+wU/9pxiO5RcdwHE8BFD8JjNo4qD8wluwwVSVb5CSHkjJOOmGNv1Psj8k
Twue12isqUmQmxgZQjL/Y4ekx2EZn788/EB6knW8W01j8JKh6ZuBYw7p3biPvmzQGINLSfCQnQtqMi8y
k1b3d3yj7Yunx8j19+K1K2lVLVSbu2pErexE+YdPh9oGJVqiawVnH2RaUmB80MvWuABKGoJg7oPckfGf
c7AHkeJI2sc65B2+QOlcxCV3R1g9PyjOPAiTGUAZ4mahwKCWcyA6DjzvfTaKvwssMLqjT1xdyJ9P0dO/
nUeJ10FKSYPFac0SuT+6qrdj3W1LOgev+ZWC3H1ZqUz5VaVSoLPGDud19eEJKDzCgGbGIPdIA0gLqUOV
JaqeW6XdLlFDgYp0iUr2+5f+D5rfi9xCG/sr29H65pbmaGkTbe+u6F5kl9ZQU1qySXAvZ3Fstc95G5hz
PFRhh93pjncjWlpe1hO5y2ht3avJ4qwiR6hT7p3OPK7tuwRr0NhF8jN0bVrL0o503e7bv3w+2DsDarIx
L2tks+4UR45EELZXLPKTeYVUc3g/v0fDqQtXH4nLRRCqyTevCOYpjIKnTNnUq9xFv/WW9dcj+8mcaGsZ
sHkJmlyyuBN84ler7uD0o/L9zH3rmZ5lOZLWJ2hIwn0tsG4qjKN7UfXw1byRQ7mxqagZP0Og9G6e1qJZ
4evRy4FhmGuGKvq2KNlNOAqT6S1ZZF8pJrNx0RbcLXooBLbwoSLFiGbnil6qrqKt0DcASNwb3ZuywQ0j
CWZJ5czS+Gq0VrQbngvMBJ6dwVodyT+leav3bIMeZ1BM3VIZ+eZ5rzLzRrOqLfEp+z8AAP//OCsiwJwX
AAA=
`,
},
"/favicon.ico": {
local: "web/static/favicon.ico",
size: 4286,
modtime: 0,
compressed: `
H4sIAAAJbogA/8yW/VNU1xnHb6Z/QO3LpDOtsc70ztS57UxjjW06nTQ2SUdFq6CxWt87MYSEIGhBq9ZO
ommCYGow7PJmlF1lQV7KCuzysiAIy+uyQtaGLuyuvMhdyoUoBH//9jln9y677Av81GaZ73DuOfd5Ps95
zrnPOYLwDP2tXcv+rxXKVgnCs4IgrCNRl7BJ8PXz3yrha/fT7vqhqu+QpIAS1kjXDv5UqsjYwdshYyRN
wnOSPvFXkiHlFUkT/1zE8dsn46TrR9dTO8z+u0FcplUkI2mWpHAlrFGIrxCftwP9fpF/hfgK8RXiRxwn
vkJ8aofYM4Z5SQwiSSYhoIQ1KDogoSJ9O8geIWMk8g/ig/ggfvg49d0+sQXXjzwfyV7x5yEy3/9+SfJv
0ZCVRHH8JIwRi8+eC/f9GKYPj/EYgn0uz1+DArLt1mdixt2PuYlBTNy/C+P5fSHziMZn/RUZ2zHa24C5
8UF86bGjvzIXtJbBMUTlM1+tmtNYeGTDuOk43OX7Md31CZQRG24lvcT9R+Oz+G4c/TlkRztm+ovgqTiA
sZokLIxZ0X3zUnD8Ufn5e34ET5cJ3rYP4CzejGFdHIb12zDnssDyyQnk7vxBVH7uztWovXAY86OdGLkV
z22Zj0eNpzD5+T0U7ZfUHMTgi3jYbSb+RR9fr/Kb0Jxzcnn+xSPEtxJ/Z4A/0ZDOc8L20XL83PjVaC/8
G57K/ZS7t+Eu+wOmOrLweMyBkndeDsp1lPz/aQOmh21Q+rRw396Hh9XHsDDeAVt5TvA+ichn9oX71qH7
xkU86qnD/NgAFiYHMevshuduKWrfPxhYw4h8+v/PM7swYrmFmS86uO087V+5zwx72cf47PDP1P0Txie/
cuEf16Hr+vuw5aWhPvWXaP9wLwaKz6Hp9CtoyngZjvJsiuEQj2Epn7PP7saDyitoPvMaGtN/A/tnp2HN
Pgxz6i/QfeUYbIYsXwy+esX5mvjVwtXt3xNpb8gq23z8BZhTXuBMa9YhmFIWn3kMFw7xddK/6eOzPVF9
9vUA25Sygasjcz8sf3mN27JnHkNJFlhNvLrtWYn2i2A8v1eoOvu6aDNky315qT728Y38f9OpTei8fGSx
LzgGWgvdsRepRm2inO8OYbN3WczWSweo73fcztfni2GgIkcxZyZK9ZmJwoj5muC26MWenETZx90YnR8U
w+dll9Cae4rXCkf5ZZrnqwF2NL5qb806qDhrtNJQdY5Az6QNItmujO/3zdZ3vNMI2W4JY8fk+/Kg1CWv
l0zJ64Xmc1uYxPq0F+XQ92LxN6An501M36/EjOMO+rTvRmBEnz/FrnRkHpBofwjTAzXC7JBFHKq8JDem
vxT0bmQ+Z19NgmwtwFhtMtXoNGprYMtPDeFEW3+2H931GuXxUJ00M1glUI0QXIYEUW77SHYaL6Phz2oM
4Xxm3/vp25A7C6ku7YGn8ghGjYlwGXbBa80LiWEpX2V7GrVUj88ow7otEtVIgeqrMKzbKlKNlSeb34PT
+DEaKQbTu+v5GnfS90vrRM8qu4DXRKduCzxVR4mfxNuu0t2BGBib1tf//b1K7edhoTg8jXmYqE+nurxV
IZ5EEvzifFbneQzV2XzenqZiTA20wGG4iP7Ck5TnfM7mZxLJx3+L+ePPLAbZqoX9WjoGdX+F196E0VYD
enOT4WnQqGx2nkTlMz//6dFibtIFe5UWrdrT8HTX46n3AeX7sGofzvf3sZr/1QSd3ffb0JZ/Fn2l/8AT
8jXdq+V54u/F4pOeOOvQRfcPqo3I3fF9fodi5+dky/lFHxH5WzFuTsO0sxf6t37NbVltbPk0A3OeVt+Z
uAx/pCQec3R+s/tO4KylOBymYpqDhs7T6Hw25r33d7g67pDd2oBtWdpmPBnto7Xbq57nsef/7xr0ll7h
ZzWbQ/EbG+H9VycmLedo/rHyT/OvO44Zl43XZWbL+PcKzmPOfZfmv2P5/JOPsZp3MD9uxwOzHtYbH9D9
rxWPv6jmuVFjjMhnuvl7zA7cpHi70KX7CAN3ivg9cKIhI/i9mPNnvh9Wv0F+9PjK04Kp9kz+jat3oZh8
eofdveTWC5h3N+FLRxm/x6j3uBXx/XlwGXZTPlP9ax5iH4O/zb8XNhM3ma950L5fOV/Pvuc9VF9PhLNX
wGfjY7Up9D3uj2S/lP9NUjlpiuT1xRInE18mPm/741uULk4mvkx8am+NOE58mfjB9l4/w0j6dhCfaZU/
D37FicQXic/boWMkXZxIfJH4or9+h40TXyR+JPtvqdz/9w/0axOEb7wnCM/8L8WYjP3fAAAA///U7TiE
vhAAAA==
`,
},
"/fonts/glyphicons-halflings-regular.eot": {
local: "web/static/fonts/glyphicons-halflings-regular.eot",
size: 20335,
modtime: 0,
compressed: `
H4sIAAAJbogA/4z7VVQdX/AtCm/cnY1DNrBxd3d3d3d31+AuG3eX4O7B3d0huEMIEEiCf7//Od+4d4xz
Xm6tsbpXzTV7Vo3uh656WC4qAACWMgAA/d+ABfyPwQH+t0EBIFCA/zBFVcD/YVD//3vCw2fF/7kHANAC
ZACKAD2AKkAWIAeQAKgAlAEaANB/nhnAEWD937QDOANsAB7/cdEB6gCr/9Ze/6FmAPf/EF+A9n+I+3+7
dgCX/3ggABuAGcD632ADCPyn+T9K/9v7f1Hb/5ieAIv/xff+f55gBvD8dxUAOP2n7PCf5v9wrP9D/ye+
OYD9vxXX/5q8AI7/PL7/YvP+f84c9H/lDQCIa8j8X28KBuDdBeDyBnAFApgMsecu4yZNN3WmbBXc5L/6
UmjxuzOyZHIa5u0C0VEd7ZZ3Vu5jpnMx4AukJhSlldpIx0Nwz7VpbVZ1CEiJDVceGNwVWJHVhhonOZhU
hMMkJr5axtmUWwUZ/uPMPDaQtCSOjEdwndBRK34S3X5KljfARq9SSq38EtVToSUWvlgwgYlIaP9cz+w6
fGrqEEsvcS/HuVmLCylyQTT8g5Qx6JN3NGjtPTamK/mn3VGcKL7Ahi3WgMUMq4s0DYV90PEpU6rgs7lo
Gp795Pc/gA17O1+d0kgcPNx3tGiyFH90GUkt8Ub49jOxSrBid0qQ7nSG9Zu/gDJ78p7JQOFBmgBtkkN5
r6i4QQ95NrfqN47vMsiY0VK4CEaIAZNPg/I6LB6ptZw1VFdxO/s5xGUXEcMmpDtBJEEWdypMnI6qS2aS
uoSTBsPTMG7l3oA8OAL6HV3GIS80euSo9cHOW/9iDnnFbdKgB2TWU8LwtSVtey0/e+d+uhK8qJMVFVaB
Z1byEyZydwAOFjwOBSG1OToAytyRkcn0WA2Snh/IYvwDCKXY9VF1p424r17j5f+2WnMth9C0/nex5rSE
nPD4xiGOmk4+gNkToiGSU1tgp9EXUj5raact+YfNB2SekW8En14veUUfT+XmMaMqOVBau+wLPRsDBKy6
IkvJmGa/XTL88eEv1u7apNcVNNiDc7yHhGERK1UTHiBj/yFl3l+cL8HWgLEtbVhwc8jpo+hDHpYHlZYo
aXKvgCza3h1izV78V2vanAmI3bp/ObEeH7hKyo/Ner/8qiycH/pc3pQ+9w6lDdMYSKKFhz5aVZKLWumQ
zsDMOYRX+D7nJCiL04Yy9nfRLThQqUUXaBos5xHy5QsKRerikEACZRhvK+4Moi/ueHYUQ9T29N7OT/hb
J1NSDNSxSSY5ONPfwucUMwSnQujbMEyR8eK0wr9h1Kxa9Kxs4k7y43hQKplhXk1q7MOoFYEK+0h8/uq9
XqESZfP4iMiX6eqTiVjU4jmsaKlQF9FH6cs/TELh0eElTL6FY8Xk1wVwtuuI5EYoX0TMUYAJ/1GevEum
fe1G4pfnhB9kqcp7DP+Z2yFDvCsvYDTqc3GzY9mGzp8tyxdCiNM23HAbarBaRT9crDCHnEP5yisGNjM1
2i5k0pTiQcX4Ckblr/BwHY6yRlIEB+lnZtaHmhsdm99yE62e98u+P4YD3X2ZPNHCcyH22nZK9ikYysYG
ZVitvDDFwhLOPIpokPxkagYOHe5EGcEf4sA6bJXasKctdjH+mtPWuFSFqGQhmlShZ/kByIf4eLgthL1t
msIyqoVw49c70jQp0jxoR0XQbjdup3TsoGJSwRXbjrEdqk7757tyjXExEae6rS82E3xcsbjGVmr61b4B
n1YeiELMuRzp4sTFlgEQJV37vLPHhldWi53V5C4YHKBcOcqH9juL010uM3t2B6L1bur65be/J/bU0Azi
ltPIvQ2GV2qVQH+CfkvBWiCvJCpKkQYpqtKGgkAO9GQ1LgJM5dtMrWgwMRUi8kuBr7eoWBSqHZwcTgb1
Cs7gyPftuBjOsI7nZItmNfYg1m7mLJmW4MLsY7/iuWHKYlAFHuKnPtNAVsU8UwmgdrqwOIHKfpXOC52l
HocML5/IO8osp1yO0QZ2OQzutgou/IBsHTBB0ehIDXPEuyvarEaThibSHEo6f+imwusoE61iNZ6eb2+v
YA8kBlFXLa2/fn52IeKQIMdi/iyDrFigz5OiYZVKE1wvyBj4NifKnucoBaFNQox4S/0GS63uYza5sZoM
hDig4A0+wmCWc6X/ESxpX8gaXbn+ptabNNT53ai9podkMq164alqEAHaf1f12hPmXdvgbiQ9PMIf1A1z
tq6c+IS/tfsnUsCJ9NQ9G0S6eilIEMKJBDqe77DWPky5kbEyD0rJRSn7PRDlgWK3DFWTGqAi9TjrTBlJ
rabKLQlHDycOqygOiPhSD0/MFqmBr+7wV/Jve1iXrm6rsGAgq0BG2/V2TAjXTyyuLYngf6uc5S+/e2am
RG4m+QlUu4Mo2naotta8PLmyeuPkLsjbIvP5+h1HPmDB5MUtSX5KY5qrwiH3NJ1ICCp7nm7wsGYIIsZH
/4pISKSc8kD7LS0S2xjpHlcagUzOsqgdX3r+uaV3Uup5hqCd3EQ6IKXdD3fj3SWV7k40FHlUUOEHTcTl
mEvosARWm0pnGLaYM8bGTiWzy5Y+sdew/OHjJKFECf5h1XWAiRn9HjVtEdM8Wk3xg0Dt+GjwIJbnhH9Z
v1wObz3eiKp090Avj35WXIDXTNo3Dm662vzYZK6oZZ8Jjb6TkAgG/oYunRNjR2QY076MQDQLM4NL7StN
zY0qLu/j8E8Zd+i2shm6okVBmRhpuHTOjjmZgL/t3PEPF1kCx2V7q7EehXFgf6o/bsndUwb1yOJFsWQq
ypJKlJA3QVZ61hRmaA545vtn5aEpbmk1G3jGP5zaa+so3Zj7g90d2PA0X+4Z56ZbQltkAN0ALTTdt9Ul
gLid1sW1kBLSlELXk+jvN7yuTXOAi7jgY2p6eFgPaYjonNHFbAxmBKAuqs/scvHsguf2i6ng4oRmC7U7
m9DaDeJt/isZTIR2+cgHp6QZsWQx+5dwkhHfZ2CvVyz0Bh1iUfF2ElFKrl0kEHNJxTs9C9nSXPaP3WXW
GHA+jeIeJG0kilGJgL01ONgzGnFVT85NfYgML8OEH9+EkTowC3fRFc7ieRFCKtH0a8J3khNLIF/yZwno
euebhhZEgyTTIDEbl1iFpaqlL4+mB89LQZ2MyfHVYX28kSYx0dggRFy7L6KaMUb9UF5hs0nTWArWpngZ
1/ALII59O5sR/5cWNT7pUg6DF+gvpMPn58+njAjzmh78iAt3BBiFeNn7mVEs9/ZXUJB09A/6lAsYn+S/
d18xsfopUM6GChHj+tT5QiXbxQZK9GCRkKuEeGSKt1XpIUIMWwLKDABVYmThtWL4rhbfG8f15C5aCrge
i4DjaJkf0a8mQ747peNtslJM4ofpJaaGJni1pi8QzdAU3Xi7fYknlYULjOt7coGk6ffWa+KTg3XKvNQL
QkJwkppEOoxW4Vfawx4MHi7JNmSopfJw6CPLNlKsCKFpXJQ2YUv9flYCz18H9hUlNsmT3uzfmUbTfCFa
SKQQ1EcOfMYvPCSew/N3JWa/GGmPuB6GO2IiYvIBSaR6i8+DUkNRI+As7nWP2aOHOPHdWJWm9gkkixp+
5K6YJ/4J0PL2hjqzn5ms7g0iVSMbsZ8iNM+i2NLhuz9XQmuxywU9IL3Zmeu3VWNyNp2L9DhBZ68ZNoGk
lSm+rSuF2pe8zvQR6C09l8psPJUwmHNQKadLSX+66zcPUtaUChUpZD06c8RGXt9JZkCjwwoDrxYdQz03
k5ECX8IvV3g1z1DqNoSTQpiggRQNZyfzFqBnz79SxCZFpdJtQp+nv1O6Hhpy9p3CT3KVGvZo7KZUM8Ok
cZjQh3t8N5yhKUU5QZcHQkTyfWKR3huSaPZxWcsXXcVhm2lrBwcHmsMGgAKAah8uZc65GWmdTj0riaYn
E2mwf3WjXARjCndeihb7G10WzaNhWH66d8878t2bRkaKetwvVeIzEFDfGR7G7RxCYWYu1Xbp7qPIFvoU
o2Ww6ozyVRQoA2cAx+fH4dE9JUCO4v4T0kfBCs8ZkBOJwY5mbUYojzaNuUsXQaHKH4IywJ1TzUGjz2OY
IovJdcD3/UNZc8AT+bkhKOwNdAZJxBPwwVbMx2Zu6/bEt5x6cYO+xQ/D9EmCSo1wwUWOm49tp7vZoLCG
gmG2fPG9kfBHVpBWnii1JcqXTsvBEwVMH5Y00aGzabfdmHUeqxaiyGtDxe8w9ogHUCfdhkOjk74T35M2
WMOVoLrilyPOuNr+HvctUWGfBFDxFvSMoKi1DapiK/JbLQ3jJKaGLVQR2CkfLZvuF91/y1pdTh01SlID
vwdw5EHccJSnH4+owjJz4VBV0D1jwoWg7SG+NqqPuziJ803F0gpvJxfGAS0V1pGpZSKExlsspSCVBMOL
NP4IeXxJgZxWNVOLLfRCY/KVeUvvC4eQtAGkU6s+DsTTnpRUsys5CfQ/oChLblzQNAJk5FVuMpfSMIhx
m1CESPZt1JoDc9PiEkar7tCnpZXhcQ6coGVAwR9TNZyYGhRqZJ8B1WxOK+UBoIs2/U5lOFzxMaeVzUxp
5M1C94oDPFxFLFHgl0OH3rizaCPhLBlpZbYAY39I3O2JWN+CTNEZJrmfLXzBlPgG+z0JSNbUqLaMk2Kc
K0xDNqGmUyI/wM33bKhsy3Dm4lzxS6ihQTNFyLC6prZhZL3GC/P/2DvpM5aHsaBPECl6Kky/qTaVPKv3
AF3aC10SrxvJNspx6Owd+kh4chUpOjj2AgP8RGvWeuzwW16BdT6i1D2kQTbgcQKPVK+t+xEgxUN1RIZJ
1FNeVJSBMzLPV1r0xpFTujFJ07Yzta7Lh7ax9Ecn4U7Rhy0LG0nJYF9XaEjOdSqoI8gUDifW8y7MZV22
RhO31qv3KXs5lG51YWoUzokHTIP5zmjbjaILq3zkjofgCJuMkOr1yWUiGG6zP1ijOMu4Wlr1yTBnDDmA
v4tZGQ1lYsQ/Zby8tLObDx+NS4Zp2t0Sr8Jlj2v7twJg7i2uu5SsyyU3fkD6FKefp7ZNK2uATunwDw3B
NMDxqMv8upHiLqdrhdMpLCpsMJ54MiRo2yq++821w7nLgL6l7RBvzRIxvHIe15VxPf5i93y4/4+oAqbh
OFqqJFhDETJEVzX2RXxmXTK0IbqHZddFBwcapPndOqnlMC2CQhTxCUVaMywOXrVRTYx+iwUulmwNkpLX
i6WvUMEhZpI7ZZzIgN7R3mKAzYd0AwO90TS9vy9hPfATJw+3vRhjqGQueU28RNVXE6otZlmIgvVi2f79
RqvM7GBJvu+yZV1Dq/BbcobdbtRNk9PB8oDk1kklaXIAUxwxyOMc0w4ZNe3p1GK9EwakMLTHtJeI7fEv
O9RKEuI72xnuHyKZmYEmGYE627EkPhSf7LoViVqPBjMDJSZEZXbEWIw0pjkPXnfka6boWb4aTgjmKHC6
fVCNwIfk2XY7cXdhTMeo88esD78TV5g5VPCDnoicDtJZ44uIP1/UGJunreYyntfi/NB6K6XVBR+xzGNC
U6AP7XCxB4pFDu0g4auaCxDMtHt87PBMiKQ/FbYdL3RePGwQ4dD4TzL8hwPmAkRcD9jO8ZyGUQ5FozsZ
DBzv/AlOC8I6t+0rL0FaMF2FqVZ5EfGW79XOAHVHxH4DwiAbiPrHOKyroPDcaJ0Rd/rUj+QvxcMaoj/g
qRvG89iLq0Wjl3FhODu3vj76BAZEx6Dsl/M1MRPMS//ssGyKvFw4y3erw4J1D6GNFAtdZxtvI+2nFJN0
peSeGSJY+5ko5K7+CzkA8OJ7pfo9lLb+Rg1OlAImf+1zY6+CeqHYSDC23pUj4FH40QwOpcfPoL0bV542
Op1KQEls9ZwANRiobKkuMDEhzGl7oIfzaH+uli9U4TdSadBmaphki4LCr2jU8rM4KCwYg1UpDje9Z33E
UfC7ZnknAyquIq2uuFRYro67wlvbicIIYctOpei+U/McgayGPHUIJl8VHRuWib9kVyWSyrOSQhjRsIwE
ANRNrUwest6BaRU41e1oHBGN3hONmscL5pphRP9ezFjq0DIIKzjEGrt5hrSFnOI8w5Cr5ztNSsB+rGKx
A6NPqT2eGY9biBd6Rh9NmvXnuWmhcpi1pMpRD/vlkcBs8n4RTkJ8EjdYNX+WF1dxjMuMe7TtVe85pYc+
e90Q5dqfNNLRDS/UP+Fr//vnBIKteoRLa3FuHh0WEa3Rneec7UCz9BXtDzi9Xs3XMRbbCvMjrjasDhYV
o1bTxUJt9Fl9rmvSXGl0D2TzmjGsnrgPhUmzULsjAjurl8Xn08sx+dkQFRbFUg8d1Qw/ic6Q0pultw+E
dHRdXTyCJOdEVCjw6xflIgn4vIav2E7S9D420oUkA//GoFYEorxu7PzGaRHiDktELgiUa00G9W2h2dA5
UIbaBkkOu0YL/XRNoY0ovyHml5B1MRzoZkStL8jiEEDVU/o7R5OOnX+o0vlve4U6R6Rt6tdPKlLhcvY4
h66J+SMUFAKS3jj8siHas2Yof4PKWLRpOu6KF9j3ZKTyZ6s9aWIECccvrgoV+KfsTEl4IUpbqJPRwqzS
k3CUqe1Z1RHXWV1YGgjNK+wZ/uLkxYmkTZoS7aiOTDMW/JqOp4nF5ulksCeqQDLoPeDhndyWhkBFaYkC
LuzGfP6vK2WdYlefoNQ5dcq1E4HB4B6Uwa9M5oQkAsBvZN+Sg1AqOESHhbgLjBpXKkM3U7+I+R2wVtr2
0fWI5C3Quhhf4rMnb6vbBTkaTAotuI22HatyssGlVy1O8P6O7CxcvOSNFhWPFR/mHVC3dxVe3Iub9x7+
hYOrOsREk6Gg9ZFOPKGIndmmXnAaIvFgJlT+Ujcz6U4T9KPKIf9b52GCNIzr30Vs7nTZeCIycyg5KEYi
fOlJl0q2WILecfcXGoq6te4uWOoPake5AGpETDXrF6goCLtZuqEiYjKd2JT6TugQsRr0s6RuSsrXHX6S
nSfvxnkzOxkZdB/SvQ5kIsQ/RyzZWA+JrOANFVZqkjzKR1m+ymYX2sVfDyceauN1fykIc8cfcD6JlO7+
fUzEDBDWfVG8In3Jm+BZVOSCQyYu9MvqDaGfyj0aQBrS6wknCsWkmoDx6fdkQOci49LvpE2j25yLC10h
FPfGUPr+pHDUxcoPXpsZ/r7ES47Nik56KGZ+35QrP0LJ5yo+G9rSN/0mKkX7C1ei1CtSZZNAVTDQFief
CC0fKcfjl/qz36Vzqq9oFWlcYZq1O/9wBMQuho0oS38Ct0Fc0Xmpdhj2pMmdxFOOie3EF+uK8R1aeq+Y
TSPfnAb455xN4uOh4FYOpQNJD2Hs1BhzGNqwWgt98u1JWgDqLWEA92F4/ihD6OGYG5tJ84KpT3aQXYZm
jjcnNUO2CpuvnpoEzJBoieIgolBHGyNPg0g27XZmj/TpYXrUtXpfRq/I5xfGLooHQO3JgS0xI8oIZSL7
At3/m171Hcsh/gWO6MMbRgeIffHCnimNl3xM1lnz7aYIYyCdlXZrG30M5pUYvgTnImfz9E8W5MJT883R
Nn4phsqNsBg9ChGrXIz5m0Fy8xjGrImNMN8Xy4OrK6Un31sCRicf4oxugpuWBKYA5KGyTSgOz1ef/kNu
tqD6fUzFyTuCXp8S6+bLyvbbH4jbCPBXMpjhGJfRCDcIMYyItqiEGYIixynQ6BSifGkia1cItMJJq/b6
2/pkvNGyA9BcVZ6/IzEu8Y8nhtK3zlJGYqP/YYj6JIb32NVEID6+H6MpeAWmi63Kzdm0O78+1tKFZEC1
pcNWMAfx8oZKI4pO0yPWf04X//P0hdauJQiWvxr/zNfy4RZjho6ITeiKZ3Wmx0yhwL8AsDG9fSmt50rl
y7B0e1uHaxIB/OK6zVbEA0IKH+/meWuxvXuokY9DAstfp9bT5DgvqsGyx7XTRkl11/o/lLTsWdSZHA1x
fAg26lWuEwCnWiBYRTXCBfp203JMd6QgB3cn7ZW8Cwdj7zX5kX/dwxoo2zQ0I76NW2p2JruH9amW1cmc
tLBqzjOowMNeQ82+TKb8+CiMem3xZQY0L5INX8tm6clsnei6ENN+t65SpDh4ZXFkw80TrhpESg7v5qH/
ujIVyn6cyW+MQ6nQ6fS0EB/D6oG3IVsB4+nvCHfV4zUJqLk0qcp6TorTAzc/0ylGfl9pwiC8qPegxZUR
SpBA+a1NMLdegE6vhK3RGiSJY95QahyWsVskty5iSV2yFtf57jr+zbMcR83vxW40JCdmCXFaq2VshsSe
0EA7cImD3WEViTLwsNJuykM9F3+dhF3KfcNW7MO+fPoUUY0gF1ayRmAtT2RIMZ6pIV8qbgcIc41WUftl
d/80SbVMESNLZ8DdXhtmK8y3ZlikrNIVXd/Iit1dH01sA+KkYBAcJ8aN4X/XYHYXYA1WV+VhJx7LCSQD
Z3/+c6kZTNHGbdX9Jm42K9LVYoxkHpz78ViCSC8YOakY/J31v4a8BnxB94JOWPIDhDSNcxHht2g52Ysq
H65lMrcClpSaGZlhh1g0B4iRC6T+0VdB4rL6eOWGrjtdQDq+1be61PqU6GfSr8CeK22NRylcz3Z4JDK0
5jB8s7qlkm8/5YDJZ0BSkPoziKJ9kg44GU+bEvvnymn+1QNmLN9H7peQSGQqxT2sb9dKcebG15elCBwm
qeup8fPP1iHkY2RCXj3zffDVPlEZPP9p7NVVmBUdLpofiR6Z6nU8ukDJbNMxwDzu0vJQhe63z6u4mBUP
D0/gez39Jwmh+ddVQbHVKwNS4ue3kP1sABUWkkrmh46DcZYmQ3tzFFwl1348egQckhIjPvn5bk3kwhHo
6WfYWXQf5sV3utWh0XuutFi+DqnPkvzluC8wYDajlxYc2tU6AFR982jmk+p2SzWsvQWHn0SJdLkatIiV
x+1gkTW6Zz8/4QY6IwrIrMRRZtNxiR93rsgBiD2+8bFn2vuUlV3WY723tn37XymLz23RiRJc1KNvVUb4
3Qxx4tLN5D0Vvj1WDIZz2Izr6bSW4AHIdsChZZXyrb9yfYqsljsUrjC1LDr8zt5lX/v8xaNL12U+/C5g
DKUvFcLjl/p3ZIN1vsOE3XpVXlk5xmhxomPRHPtROxJT9H0iN4/LEVtCTIkekKs97P0vRiMBftNj8JMr
TssmWnuyRwn6yad/XTLurXHW9CKgN+p7GFEUZt1wjP9e1NwujL5H6Dkfd+pIG32CcIG0pmjIIbx8bMZj
JMZ4DUdJxNlZeRDLCCke6YxGg1nY70jiCxyI1tpkTYI9m4aZOE/wIjWqtJLHt8aF/PA6g27hSCiGblDA
Pzb4AT2P2FDY4av3sMliUaxezILf/rSkMP14vULkm1E/eDju9mIBeBPW8f5xXxKtxmlHBAVcrIY4TOBo
JLf+6UOS937PkeH0enBRmHPaXFjKSkS05LgoRnExf3Cv8+PUcF0E8YGVotWIgFlEWXg04OHhCj5J9B0P
CwIlpPHAiyc6Rzm4XCk+UoIQ/EWiyCJKif4+LsUpIvk+0653UmsFzMaYRqoHwQ4ZANQNHE13bmTNFq6q
SoMfJiDFtJwLirSSC44/YsOhqreogib25GXXzeavl5dbdkyBAWMMhK59QB/OHDXKLZABCWdDcHiTFMuF
0CB7Eo58Hp6mLSc8QhmIuFylAKyQ1Y3sGmrISZnKp3CHWv0gncSNCEWyhktKchywsq2jw6M9yL4VDlAl
ZLSiRtuggQw1afBAzCBJJdDT/NlA53zXS2gMptFIBf/2YllbH6qpbqcfgY77BdOJkwWekO8hSSRWZcfH
rG58Gib+LIoGGyiqAXSFsJF4vp2A/hvm8auyANu2p4SviuFbndp0DnFbDWT42dNuITnTv1NCh/awBOz9
q0TNl9lj1EJM01H5goE0HMeT7KX2T7HSm+vI3mlqK0sXmpZK96JQ+MK73X+LVUeV39xii1f2ehArKpow
ZZcyCX61rsvHKlWtuiuzn6rhAviCHGdDkFNpuVMZV0nEMrfxBUAMwHWKf9v8tbSxTGAY7fstDl/uFjHN
YcMcYCJFzbF/fpUzaPsv1Sa9uUsoXE6EqAv+LOyEvKJ4cavbp5y/Xb7mqDJZ3m8o4iv0Fj7d0zN7UsLU
Lz2CcRx8sd8faFIAaXmKb+qI35vEwVZ6pcujhWYhYQxJQ7i0TwnVWM7siF54IxL46BaC5slKjg+x5IgK
pRhDV9jnKX1ymf5D09r/vFHl5bGxBBhpPDE51helE+U8waQKepcXxtoyu8wJ/YIzdWIH89k3GjQmnX82
CyPPULM16zEzoTDHtMbUD/quo7JqqjROx96MKl3OgB5+XAJO9OzHksyKp5RMmiVWut2x5opQzWapt4in
qEkbpBh55zj+U3zGk+cLyACKqSxE7fXJKNXuOmbt01uZwem/dtpg/rn6ZieuprKz0RUUsr0t60cNGien
okckCpybyzXyxC/SAa48vnN8mwH59ta5jeKOhO1dHUXseQ7THBNkhT/pUpgB/fOJbg9yBKspgQWGKql1
u6Jbct3QJjDRboQoGb6yht/GR3BoQYjsJfScdbdgMOrezho8p4lKr4z8QdIv654Keu7hryJ2rta0yY4G
pobuHmP3ZSi/r8gj+3djHQfGJgPYxshmTJMJGDPoSsNNFlJhN+mty1AcaQkPVk5AxolBh69hS1QUrTXO
50rVKuwzNE1aOXt0Aa18TeljygbbG/lKDVNFbRGXcuqmoydsd3U/0Pc1qWsYcvgrPv8MuXyWDiNhw3W2
SKGFQj24XAPiQ6FZN9iTaBDJBbKIqU5SsPEn9zyp0a5X9RVzyrHVTeyICefYiyi/OrMoZGV9UuimjyEq
sBhf5NLaPr8GM0QdQjG6FR8g5To4zLuHZpCAY2d0ijs3ojColjpU+2syuZ/EjPSiWg2B54zLQjUu2SyQ
knl8rP9qMLEQccN9Fvo4ElJLMB1Nfcn6C47axJdg0BQOH+4D94b0w5jnn90cVc0I5NFudgjwNmAxhsrv
YWpfRjtHlWnC6RfILvJmL7dbw85KEkiyFZJuS8l17beuHRvShl3xx30Ui54FGRrTTuoionpxjTpSbOW0
3vs9hUpQWZPgl6i2e7Xdz5EzPa0+VwQGMdkvARF3cGOCJssjpPOelP52ugmUWED32if14akypaVl5DVe
T9sQzFIz/emPEjFhs1oMqpmw/vBRHGx6n6dukGkswXA89JN4uNBvrQnrgDraSLljZTcTVH9bIDOHNb6C
7DbiGxGKtdE35akHVMXV6kvd6cQUzCKhShx/9R14m6Cf0YmAQ33cS62ddcwi+RgKvxjfIbc4qX8a+pI9
I7ptpy9tlfKpcMqcXbL46yrfcLQJ0E1adFl+m98fL49d6DmpeNLdNmC535LTzZ5vO0krojPnq4pCWGss
Dp5bbdw1o0d8bULDAedCzdlGyE0cYiKwdP5PKFpm7awp8KLtIP+NMUsY1mToBR+KInt9V0WTE00TibFR
ELQVKl3wbxfAUC1GoxpOqfrkinIf5tuAL8dI0reHkMBsTQpzRlDsIjs18r6FZi53y7MoGyUohoBRNIQJ
N+54FyOHsjcx9dx/OLBY20I3P63+zoELs5B3mkgHpyoJ+KKnSh5RWNCLs3UAP2vI9Gp6P4RbAYL5HphN
J6ihfIYHV7wPP2/Jy4gFUUa5oytuUbhjvDTGcy6W9Szcvelvx4hQ5nyWAiMidVwISrOdE48fBZc/GHYu
6rFUa7mZn5Hl8cuBXWss5QLoXet//OJ2JxrKoYf/2pA9fYfwV+RfCNuPoNEo/s/ZVKBqI8p3QpeT6MRi
XIz8GBcwtwlRMjJF6uHdLYX0NUU3TP30sv8GqFFMLDKbURJbNyUDqZwnn0Gzm22XiiGdrROA336kflPG
QPkHuPnObqfW9xP5xfVO8VWvry3jAdu98WXQTLaOEDQvoMRIRFCFiFRcO0I6YamEY5A9nHyjq3/1zrFe
dhZczkHnUvoHDSxn99SHUmObn6sI9xrV4kqNsC3M7uJSh98QuiUJeOYMitiszGwjEVK0CcqOzv17fD2u
ajfNtxiFXsscg/Mr0bfrC3BjZcEVTzPKw+2D6Oll7XOdPerIb2LAjEnGSzkp2VZXNo/X6+1cBae+3g4P
nSoflVbCoYNqBia+05xv4Tbqb2D1jXhfDC1ldZ9WCOinnqcQ8KiLxpR0ORwUOr4s/Pe78ipTWSxNPcHG
AEoLitEvblI+sQpWanIZK/JpJKfdCkpBesW74TIt5qRQtoMqIXU5jJpodpo+OkEdNpW1YcHeXidPgYn9
vOTZya4cFDnkds0aTG0nWMuA1bLOLX0+5s2nuPQUP6OKYtqSh0rVHbZF4T3TTuGWPGTH26fqrUpbWypA
9sWR7Iux3qQek5lYWgrKP9/4uwK3jki8G4NFeFSaZlJRRWOQG6kQsfiYGnT/rsxcM3vG4q/YX4YEdYg5
CjErWChPLt/x8IskC/h8n3x3WuXQYkt4GaFQF1VOeiZjuyUu6wQqaDJxMU7RI7PZXXKwhrwuVX/AuKLU
dknAq6/Ors48IgOnZi9R4F9HA/IDG9KuI9ugXX+bdnGSRuZ6HmN4h39m6tbEIInqfjDEJdW1J3L7q4ow
Hg/ly780DNK3jToq2PKT5CkBlpq+4f6wlHg23rPGscVo7ZRcRoUMHBr5jOLAyldCHSO0bR3DLzeGt1SS
Q8r+BvEQiljrwW2Nx4r1pE9QYGu8SiXeXrcD2+wutpYl2SnXKpbAQt2tdzDnDySbJ5wx/AGfrjsDHrl3
E3DwwGthCPI80Rhgyc7d/QxLcyOpHlUgDwnw5AZsJf/rZYJxd1nuTI3AtRyqs0F1mshDhIw/ijM0CmcC
i4HQhoJjMcq19PXobuYv36M1LFd8mXtjsDwMQn2TZIX6EiwX/DDueTpwwCo8QsQgR5M7sahlAt7Jmlel
xr0w7ZG+Oxis9sXiMIokcTt5PFRAfKBgEVaoQcqkQCmuYRjzwhbBVr3cFAQnHPxdUJSDs0FTBpKTSmx2
w9s2j9vkTWq9+vmHek/GoKdB6yUdl0oW94UJQ1dVFJSNqgCBhrCsLOe9z4kas/7M+1FNlEAD2bQmPd5N
dEB3zJrebMs0zEkSPy9+lfkCb/T8hqcj4tE2Oouoe0kL1IbaIIgE+g8lgqU/BAq/Gc3KqvYF0HPPSF5Y
mDPxBMbphgQmuQQ7xSU+Lg71emwfetiJP8KsyRuwBmi3py6hnFYbCmlSzSOUS8jDz7U78QmSXeKITFgr
fBjBrmJMpUr4xabd4wZ8/RNP0ICmig73FtM8djSefB3dJNNhLC9LUFwqio5seJOWa3EarP5oPh12K+oE
Y9sO0dbIv6DkzCeFLvPVcFiczFqcDk73i6Y/C3d74v7yeUhtk5Wlt4AzJJI2hmJzF2++i6TrDE2STH4O
LuKFMkgBStHQttHFYr7/k4DmoRhRgVW2/UYgwUH8ho4F1F6EYsxIoTqauD6Bx6K1Uufgg5HDOI+SrZaY
7cU00ZM0DxPA9QhOU+zuMnxZsLLEuuK6QLXDvpjn+AgfTG+u8PiWUbCUyif3LdVzEWbVnWT5cWGkLT4+
zM5BFz5sieB3g/z8kHhRKZf0Q9pef6jWOnwTzrqX4R7Tn3t6FigtOA+fjbc9ZNiKm3FzEL7K6ECF06sK
4dblZ1W4s6D2v/fSFVRox8Hgu2qh2CxKshxAMSts8N9boTjqjJau3zS4ISbVRKNwMWmxVhZ9u34q3Zw+
UBZh7NdMeh0PLhuMG8cplK2pMT6R1QdjI2UDJGuooaljIW6U6+X/BBi0OAbTx3IwWtMivzd7S5UhLzW1
BWPOIdjlFDuSmvz3bcwBDV2KTJlsbUgANcN4aCkhsOrvsnr17gXZgwNJlUOMuEyA66ku5sNq2Sqi9GXJ
botGxLltqIfGtRwYoW5DinxOcw7n2ziqFdp+IHQIvG5xwr9jqJPLu/lfUHkARWo3TdCqWxQCuYWpjStY
yKIYXZRjmgqxQCGDCx7hmTyzO4+qKQ8jknLRWmNGuRWJd95PD4ku/ypNbvT451KuLgxZqisKKiHtZaCs
GMLr6CJDm78yBQYMyzOHCod+1aUxOrKuySwXsktcptxBpQnRZOMo1UOcK8FGmQWrSHnYxu5DSjU0bAuP
8+nLaSc/7zyynxEstMI33kGzRdto78fpMzCz8O4VI5vMiozBWqivlW7SnzRML/vtfX8SNP/+5dYf2Uzc
R6aVfHNWWBGJ3ZAeMCxsQag31D0uf9GikZFoFvbRMAuqnzgUrf9p9UgS8uNP+L4HFiQX/UEnGmUBIRKO
XSo6v+89qPNsfKV30nuK2LRk3wtsVtUHFURRBUCThjQTNL+NzmFmmyPZ7bDqrMK8vTIKKFHd5kmyWvXx
r4P/+2vM7HDJGfExdjT9jALx4Mh32tHFyNLZE2N9e2eyb8v0euyEWssGIV2rNOKpwD31rxywNKO6Jpzx
pzWz9BBGn9PGC+ypi2vl8hRY5VgOy12sKn8kqsuWiQCEdVn9eBFUB8bdKc/NUUwaGnA6sXjtNhMlrE0n
U9bN7GrZtXr8mi2FinFH2OugieBNgOOS5pF8zdOiV5H8bsVpFNsJGq6R0l3Btds7FNzompI2NZ6IK1FD
ZPjIbV0MntEPkEWiP7K2PKjCy5rFbYrLCUjL4HexCTWGVCxQnKiAAG7pxl+lJmBfG8JDsEsxermGID9z
hc3gM3VBgim4g0KiS9VcjdG0H3ximtO3Fzidt/UVprtTZ4ON92kdS5DogDAy+A08csPw4DmFHC6sTPgv
c8eIySm2HhYBUBZqhdQsznU/pfo2MLG/rWzhu+SWIhXkvIOS937/eSfOzVs6yYUUPxUUG6dlfSTYTIf+
rIFpfqzWVBndT6JeWt+s5fCHmE5RRoO+JVWaP51M1jWcCtN3s1V9jO7H8BmRR9XoA/NcyDiJutvQlI79
9KJM2uXx07vd2syKYC4XPt0ZMgvOQ0xMK7tpFfFeS/V3vLPbfdwb25SHb4gD3LWm1zGNim8YmiBSYOUQ
4lPC2FRmjTMqQYYa4G1R7/q2NhbbMAJ6XsDL0zZ3gR17kVsHR9+sxVoNo6Kpyt2023K7HpPNE7tpgimU
LSmlHt7sWycM3k3gclPFJ0ERiMCG9X5H4m387tkOHT3FwCD5zVhgE4PIVFrF1dx4rLYELsvYeXZk7FwV
xUlew51TgV63NX4mDYnZguiP86CzE3bXkdQTMORe9fIcB+MtKd4WOj1Xvv76zXEtMLMBAaYs2yL3lRyJ
/FA/HzrzXE5Y2fywRzOqxPWZMO5QFXHxpxfYwUCigeqVCUVt7TthzbKaIsZxN94mNQzWzg3M48aIOC/v
3z/yD564Vec/K90m4Ox2CA4rLHAw8HLYZZPGSqRYaHRqjYv87v9Uq7s7w61V0sO7lpgphFBysRGdCr3O
9nBvoTzZp0icVVAi7ApOorHIzaWwgwRG47FAphq6FxNfVnPSGyBg+9tfGDWb9tA7Nr/lDC0bTytUtgcB
RKU/COJnBW1aGzFkpRDHa67wMWjZZGV9B1K92AYHMFBPmIh3FifJH/PZYNsU61gE5TshsCyjo8OLIt87
XANEV61ibDOzJJy13XEt2lCHCDE+4DS2TIdMVIR1m3ZfqNryhMJs3AF99oVNU4gBftpVM6uo/ar7HiTy
ctZPShhP5AeCZhkZwZzejOnwRdVBtgPRO8iK18OStB++6nh9UheONyHjzacRJdIRF03rb3HqlIohP04e
t7kSnyQroHD3c/QtNDJNFPrx3wfdkPtK0++WSGBngLZN5iMhsdjewYetRwgN72UyR5rRdgB0zZ9TXxHG
19mYZBWZhT7xUkUj3zxKiOmq2TFjh9DFl7niPmhWCPqIyGF2sZdfurImFdPXP+KChkJ0qWs+YPkgsSnX
SNtr8hgXtXYqazOUoWQumCniXdFNftD8gFPLBXKw2C7SfQwWkYHXmRRugOSeqsUXG0SJ3ADFNRMpQaiU
ZzciwgKvxOygzFl86bGB/mzvzIkfu+r0VlrN3XoGjka9N/ayEfQu6D4XoWbgKkmmKmD6UCcTcrRG4t4z
nsVEiBwOMYpr+1MJrTvY4BB4PaSokY7vxjbimAjniIrkrApzu5r9z5WjCZXP08jzH78AcS4nUilahHzG
0MWBIa7/+gATZfpUtBEpYievHvGx0DNdaP8oBN1meIWD4isyAIvLl/CNpYiBBe+nIbIIr1o53yQbE3T6
Xp3gtP6xk3Tw0R10HvwiM1zFYp1tKyf3DkkHdIa8TE3WnrCRXIzyN2m4qs0jZ7RsNsk0syM8bibO7hwF
HN01GF66atjeCES8HWHeAkwk7MYIOojbo2jCHjAnhvh8MFR1MlU9i71LZgmY3ibHKyH6u8tWBylmWbNf
zUhAQVDqW6p3WirZBPAfBNEda7iQMlt5iD5yeavdSj0GlT9CdP6mhbd0oNyIjX+WFBpmm5dLJocivQ0v
ePFBi9dkh5CTsq3r73GJfZJ98ZpbrxgViPEeGEQ+XMn7R4SRi8aQfdnsXmODJFHJUoEO2AYxNGxnZ+4/
5Zf5fIdOqVoUu64ye/WUq6O8ACxJXQbu4uEDERYWsxl2bA0/YjLY1KIOS34J7URDP9cKXkhCBXorEhfX
UjnvFLVBrluwFItx9Cle1E1AcJKgONyjiDTWcgQPCVHSmnaTQR6oOb/GEFX+Fz3LfKq6pYkYKqmjy4dH
wSYDjxeiwih15YsRPs5hkt/PeEXwo78a0apA0/As1RYuggZ0U6vgP/SNwWU1hxnyavY7QIrxfGpM4doR
IZMnTDY8sxbMwf6xu4yse/SvmUhvsZPNotvzvqVf9c/Dl1G8it1x8Sw7TLFN2IiaNavov0QpXJmvHcOs
PQRAIWe6MmE4Z2UwXLVv6vCJlJ4QbVwyl5Dq0DsV0Tt/iZj7u1pOs0KcssqMISEGD7mQsEytH+mTDJFA
YIt2pk91MJIOQ8XAyUDbbVNx5LF7gAIQYxITXlEVo1vo4jnArvYQU9nRNs63bwuNuhMBwV8k/Y61iLkf
pmMTBZYsosySsD7QHAKrZNz5gUeFfGVOThnLOrkpbcYjhZAt3e5xKwhcuZbYzyTJQrVOE9jhWgLYC8/S
d/u2brCWbV9pSvppHmcq9oXZfdf3QKSvoWZwBGhvVuJtmBH9v6/uSkArElBaSsvt97ZVe+HQGLxZr/U+
E7BY4+U4dnZH40DX0HpT0vIEuCsb2NsU7oXQH5T4eClKmDCe04npIoIbvDpwIbtXlcZXVL6u1mzYNxpu
aHa6iBV6k/p3CprcaCxcap7RRbnzlWVrtlLw/q50mLLn8hfFJ7oShCmoMZjzEHUDjSA0N7x8TZZnqahE
finGNnYsVcRQ8hP9FeWQ0bBMzUMEnPcOPI+1FSHO2cvscHXlgruh5UmN4ngf2MULP0rLX++8MtyCpjdo
HCMIkVh6M+VKgPhRIT5rEk9SD846FExit8R5vmLfm8gPAOtYyQismdSiTYIUT0zfCoiYxOB6hAMqtsCZ
NoeOHpTvWCSYOQQx/aMJ3UztjVjfHZQziL19quKVswGkrRmFwiZHxTbNgebEvZMVA8KmY+mqDH1EpH5Z
bA+PQ68SJr9DumOALEeFcJH3IrexmkLIdcQ5MUKyAEdQpggEbKLoB2iAbhhdGABeCARuFkN0EZEWdMAL
hY1UTASjCBRVEgXC/D0j4/NPvlVxGNC6azx8R5jrF/wr0m3ceD8RPbAw0giTf3ZD9vvhx8gCTD62+3Ho
bbGHSceb/MmGeK/g/et8otzNXHvQ4IVHG+lnPaffro6Sk5r9j0buZMKGwXOqLsyRhK75BOh7jK+LMe/v
Fh3d0j9ouZ3H743486GyRIA+pSB3ThroIFdw5XGtPXOHBYI5VSV+AQpjZ8db7ZbBF1Vyiej5thhFyVtw
lc7UJKy7uUygpi75mrm0JuUpjLYiM2c4lIQrqiB4FJ9eb4ga1EFRMZpdsxhToxlSXR5SLRpSI7uk0RxW
STEmLxWXjgikxKSXBmk68lYNmqmBhktMh4sHSwfM4PyH4m7DgCuwDNYA7dZ7fZcx6wFglC/9xY1W8mbN
QLPmufi3eSn5QORUHiDhFT3VqmZsVdUxlho3dMmMlFhHXEg98KFJp6WnG7jW01A1XVPq3x9t/4L97QK+
qJ8z6LjoVnHf2fqVP+v6Q6TB96qttKYjrkaYqFLXPoO8Ri6sah25Tpe+zrim0Lv6crtCxz61oIbfu6pi
u+TcPny35sa5lqunNqqmUr/Gxr5aL7e8wz5xEyVFm0n4H4XxLF5Jy/poewuDfBmAnL+rX1CT8/vRk5TD
GkajJkW7KtFa4HrtarthBf0RnaaYfCmyFopylbyX6HINbKKJrdZjpAnC2omXbpr9CLHWyXYjvJY7e61c
hq5CTY+RlvpVVZYmyEhVzCsYuXZey7Cl5keG9mJNe/l7Ec1PvS/2iK9gmc2hj+Hkp4uvjZTvLl+uTdd0
o2p1ufTVaqbitRn1m6HXAvBqF9uN4GrWqbTZ6BNga+ixq0zli93oX2N1uvi7h9aG0eurvBzCa2+BxpCa
s0gdWKKOwbVG+HoCLhuoWhI0XVf7hJAahnfVX1cRA5pwL/1FtUOf3V9eXe5f1hxTc7awD9JHXfvf42MY
ypToQV9x2MEnAmGuL5046PCieNSZdbyhYkB2sDwQlYIVTKL8PyfUYKBMAfipTBy3eXhxZpE/5tZdeWfD
Sg4WsfRewkrjYii1MI9EdWlMMZsck7ZV6V4rjmpchlPennu+O4cxALoc732XFqNVBX7o+no6iXDyoYrW
qgvcaeS5XiRN7+D7Xl2JFzjguA2nNirWGkN7CGSDBc9CZ3ggbMYrnfhYVKmhALzkzZ80WjxZ+rI/r06T
o+DTAebf60YOCf4+zeau41wzmTp57ROhTjRO5l/ABEXOTAxKwzIioyf198EY5urAx2/INMh441pJu4gb
u1n549xHxzJXyON1zTKJ8PzbW8K2KWd+tFliP3xO49AmPk44Z44eGCGKiJnHBwEUG7Ybi7PlT5foAdP3
+8swSWQKKcB0bHkxSTTyLhKw4P6gOd6etefWKHncQjp16SUR2v49aRqVMUyPMCnKdCPgGSkEUGYpZxmd
vIHr/qKur38NFopCujBP9lz+PTZZtTofb+guIdbraaLbi7BOwzxK4N9mbs1q/GpdgV6ZDIKNKMMslIRD
1b5oROQJ407isWapxBdmicGTq0sjHiHQIWB4QxLrJ8pGpeHO+KJcIrbdPRzWYkORjUqSQYrkeXKlWfWy
3C2pCEN0VfDPUlTCgG3qdF5pltnvrFB3iIlGJjlZsN7iMW5T5ma6o0lyCbJVbDY3aMXQEzIQlhYGE/Eq
I6McYOyo15r1jYNLgJzMwZsV5rTLXmjlMdu6+fhO/Kz3l89vayD4Nu5NTOlVXAheWPGXuEls4Hq/FPDl
xMawVmk8603puf8XueqGRiZsR4wQ/V+/GK3NqFfBF+vIRrqSLgdcL01rZB08xg9MVZnv6X591hrvaxki
Pnra3acOxrhnP3LPouxPicjOeoiXD/80OFT4fg4jdsa8VfSKxc0OCmW4aia2T6gHwMLRzh5uUDdABXwV
68sCYHZGKOSeTjjnDTWuXoNu66GWShEGFCX9OViL37p1L77O7ssMlc0GHrYq/YWxeHi+OFCEqjEhUvhE
y9RWsgKy2y/8BMOdOIPBfoQkqUK42DnSvzuRMkW2UMityDM8Mzxp8xtFMZbgJAzUzXDKHMNKnAsLUlUM
N0NRXsR9nRdzFHZtI3M6+cuHevNY5VoizDeEtk5WZ5febTzZLNyp08Vr0cJra3786/XUAuiewLdq6dz7
KuA5XPpbHOYbIB2I253+JrCewhSfLjK7e+eE3F9OLS6PLneTxh/LSh8vf+R+55EO6QrDhA7HQ49jF23f
1iEbl11u1sHG0w1n2s5ExcO92uvqVc1Jn2v3v0AhIIhUOwOoloBdGcToCBhSFIQNF5DQ3mAEoNP5xI9k
eiR9M+w36SE4JF8ye7KtZnKGT8JxhpWZJs1n0CJwSIxD5CANRzAYV2vDyjsdhDY6poMNaUlZ6HTZysiG
2+BGXwSGc2a8iqEEVpKlvPLSWvaYMDWDWY0oCcJXAyIbXTSqhIO5wEKB4TxLMkkoD0RIeL19V6AB+TIv
jiVqZzpqRCT18ze/4F/8JYJ382OjfBDEd0PZ3j1Aliirz76YJp1EIBUHR6msMKv72aLQBQEsGzdbhioz
/YBfYnUyp8FYpcP9gGQ2p3As62Z2xbN4iuMhwim8mTla+BAFNC8WgfC2SjhcaAzNA400tKVYXD3PmPlQ
y4iTHJazt3AE6chJ3QKdNERfgx3fL8X8fIod056FY532+ax0iadferQOLLPExY6Di9RrnYfeSUwbmjCf
xEcE4ZyWa6eiZ5+Ba6HAQvCe12USh6/zdeX/Oe2wWvCQU7dtmB6BvwzqX6JqoU1oxupZphD1zWKxKZRG
+v5tDDdJM+WGA/m+tZyuPFDARffXLz6AOq1L06FNElG+anWVGj1/3W1OcUa1a8aZvLWXt+5mOyJ+NXm+
uv8CdHuOGqVYZo5EhlusXW89uWq5mV4JuxHQnKNgZE5K0A+0mSGuWsVBrRbNLX2V1v43Hk4cj4bfLefI
nJceYGyaK1+Jepxors8AWJDixIJaTnmN3kt2nsrhDDftXw1oWdemQAFX93EWJAw3KVMUiKnmTqjQSy5y
ac81xfTFTFUXIWcLZ+Tj915xN5GqIuzKegWHJld4SCP4qodOPv79Ngn7DRYDvCt7g6PZEZdGkmHqw/hg
bMAZzU9HxI3tCAz2KP7gM8GLimAfKP8cIU/4GcvcWDUyiGQDErGjs7KdD4TImOGiUcbb/bDCJLSXvM+t
shRzMc2MROLDBf/VqD6jU5Sq8gY8kIanice2vIQ1M7JAtV8sWD10qk6bIc8SnteEyIdNX8sBSTYJ50RE
1GzoUw34xkf5bq8woD/DGgKwkXBKWzJWKjmmA8IlNhSgv95T8Y8cyPyU33p6jvSVC1xqhTOtjlGGTbCC
ClW86O3J9+xzr+Je6dlBYPpJUAswLC+3d/3o/nhhOlYDHY4P12kkOQYOToZ3che05kKzZ0/X5qz7DcOV
8pYBnk3A9LTERZQhBfmLDAYJZdx3P0HalNd2iC0aPAmRLV7owqP+1JXzuW4dOZEEVEaIb6pLIdx/TLEL
YVE3pT9If5tjUbAn0lQzRWPKfo1+6UBXC0CuCh0IZVnQcfhFcGtxBya8fqmLZvEg26xpwvE7x3VGi4mb
fHk7MhAdX+fBBPlE3IJY2802BrVxsmXmc7ZAneHX60GNNEjLEnSJS6RoTLgHAN8RLYov5Hzl/Qb7C624
1zEHqrSuZ5hZzTHwZ3APEvqM9LPi0sQLYZPkuM4elKpZiNiAwWrKydK9KnzhQCm4GIZ9gmv9PdivGs6V
M5ZKKrLsg+HtM0SoiguoGS88Z/oSEjH7GiaUdcqQWIVKdnzEgp2zB9CF5FeiPMFEoIcm3WgVsq8fFDzD
tZ5k5hjsWu2qwvOIvb/Le4r+D7U/4Lhu/qaOQUFdfkJLqw8xin7ZTQimRRnZEHXXydnnwiFlJeqQGJ/0
LoLWpL/zph1l4I00EljkoNjRzKRLl5mJrE0Wk+lX/OA6rG1lmqWPG4w2OpG5zKe8WAr/xoxR/akKFZng
qe/6cIJBftv5RZQvNnttJNE2+ppKa8IZuo51he06R+q/P09xqbLea8OeBOIbJ757J1TIVDiWFN+v6OwE
XDCIb+FhTu/J09pNjdimKKUYKcpLs0v+ItSHNfUs6vkOvUQ20VlXovanpMPTDOOQcqqzB+bFUtJzRySn
MNulYGnK2Gbpw4UslkWNZP2wYfB2v8Wnz/DX+PwnlGRsfcClq+wdy4tM/4t3D8aSQxCYks87RusEoKFe
PkN19ekBpqgDQpAzkXsBWwJhuH4fGbDNeWaUflmV8ZjwsiHuegLWc9CIfxhjLlGt8mWO/JZxK3DDJesG
SwXkJuYes2Wu3OijJduk5eSqKWR1oe50IvoOz2FFWyjP5wvFc/Thf8ltktIpwY/C8oWrm3PJZHNAczCW
sIXevxAywscJPHSQLN/9/wCcDmPxegpc16QrEkC9MbiY9JURtKtzYEv4Kh59P3QXoozqn5sAAMDZmpo3
UUq+toKBAISwitMtJqlbVM/Adxd6RN61DDfcEKArab0QCt7BUyt7XD2Z7emdu63VBHAm9asXfG+wEVYm
wbAvkcqJ1AgnD8DrASrcxLj6Z8d1fkKNxU0S5ELE80/7eRiKQIVH36dgbokYf4UBCt8GiIVKCXM1hULc
m/Tz+Tg3SpqEaUB2uRKIr4x9de1c1BMm/YdyPFxYWBmNhoKG5Loy165vmyexze8KN1jk6Ix2kC8uWUB+
tMLiGq+IdbNhS8k1pLSAbRLT+j0g0j3m03sEos7x3M7x1c5ofC8jPE2WyMwZWIbEw0VtjLQOLTGyqFMm
jsGTQdBHExKAB2sq1s5QzIWs0MfBgh/Pl2SOBLJCoRNYZzdQ3vPWY7QTA1gsSzfuG5+QJ8jocaU35Wzt
ZAP9BBoVJYksjLVk9FDG/qhD4p4RBWMhxGwFMqfLWLqmA0YqS7HI8hiQN825inTEzCPFe9r9mUPEdQul
mOKo53SQQkRJAzRFmgaLwDrFOSb6gghAp+f6t9Fn7Nu0NTV9zwdQsVkGCuK1uoJdgxIQiS78xfgRCnei
y420DFbiUabnjEkCTeNJ+VgHcl77mEHl1ELKEA8rILHpgETU8sJSShYmXrqOQIkX6E5k6uoZMIozVYKg
AyENEqxagTfYSuUQtmc5opMFZtAgmc7KNRz5c8zdCD/kAiEGf8wPydHCIli322wxr4HUZs0YjlsYVspd
Il6UH6YiFRELjaNne649DmXolTnmsuseaCpYcGQnIPClIo+OMa7R+CF+lDN+2EDD14ekL5aZHDxveCFW
AN4sDCdC/C7rmqIE5QkybHpwIy9D0Oy9T4vIZhiXTqjiXlaOxAizznURzeIYwRCE60z5Zl+ttmtTZJZX
Pl70SDGLFhW0GrCpZCn9E7qCJgJJSV2jddsy5jDokRIun1AIVRq5DlYao1kdnnpzpoFGOxi3Jm5wKlqX
7a04UE5gRAucyUAQ3D8jeAKF5yJwTNlCXsN7qNzrHf1aLRuCRUQdXYYTdtUdooO+KNCcPGTe1ZwNJVgd
JQxWeTw7cly5Yb3BrhdEulq91NgqqZ5A48AdpgUHTxkbi+cdSBaNNyxDrBxIeDCkbxPXnazIdEp2n9HE
ocziCXYsgWFmz3jM00RmLARwH19ZWjSJdWVcc4IESOZudTxufcFV0Ox0BkWEUZxsvPaiOaJIJk6bHVLW
YAMT7yflnKiG0lserX+cjfriZCjo0TlKhHD+MulgzkxSF8UJK+4RwUu4Zm8k/AJYw++ziS1uAkBmAG9j
3ovGzU4DLbRBAldLgV2ZLMiCXd/SZQ8qI7pkrdE9kzOYt0tnL4mBgRM0LZkyswBQfEBHF5GauGJif0w1
nWC0tCms37fmvgux8DWQCWlRGN5H6jx2NkgcXIbKohqiS5+Wv5oxGvEIJgAR5GuQFifhtfCPcN1o6J5B
RhMCobYKdI/GD1HmBJ3EjizYYcFSZxIqZUS36epTe8+bADGFcfgO9aVVG4SMyGmjc1GwGqwAwSzEkqF6
il7pmxIjoowpYcyG0gOYBgdqrbrXdDI0MlgWgMyZn6pIuzDGhEADgl28Gl4sWxBjRZxwqploPKo8SGdK
HgMRDyg9QO8kcrkuACEcDq0Ceg8VR1T6QHO2gpAR6RwvRjMQanvULets40BicvbIweXnzSI9/8r9q+s/
kjP87hRNGWvcDid+7tq3EMuz+kr1magrhCSrb4wFE2q1wHMjEEa1Tpaw9B07Ddig4lIr7cJoI+VPYpwC
ufguCKi+ojR4VOzh/fDZkCCzlsTcCYj8MJZ39UABDC2oCbhi6GFHZagUQ5/EHEQIPQLi4XuJsiZ/xKMV
H3qVx4WfA5NASmh+s50jZjSSdiEXRL8aE3xZCkTZ9HBL0oqOnpOzhuwGZYxb6jYEXoxIJjsKe7aD5AAO
QiIygrFpmDyJcVHVQw4/+lEBEGcDDwqHHsvYyogo968i1o7RpWA3XsEwLE/8rYDmSqBuow3/1MxPgwcK
ZPz8fPdSie8HAQ7Zp3OGa/D4wsH51iBO08+VoeF2TpaDCh6gWImxfSQm+fPZKXJgujKoAB+tDcHI/pwY
a72FiOyHyImA9CE4cly7vgY7bgynRTZlak8vBCx1CHHKNC1J4LZ/rqULRp1krB0Rjmcc1DhFCwqAilro
L2O2ahDdDA5jR6nirZsEEjj6Ef2dChihgdsHQ2I9Qq2bKHREMdk7pFNvzA7ycj7kYA0gvNIx+iDuQ20W
K0tKyF3wDQzNNe2r2NVdvZIa0k1/Bv1puR0N49No9TBqAnh5vtubSHm61DrCVIXyoQ9BCBHl49/vkON1
EGFjxikXebSOkYDsc5Ljb9yYvGHLCFNHKSTZ9a0LdXgW+bf3ur0iDLMcq21UcQB2krPP4o5OQFtVt2o0
H+gz+dRZCm4xBGkKe04UDi/KVGo1zWYIz/gBlqdj57WLWLWjEcy95Tk5QDAFNoyhvJd8DA/m8T2/EQxS
4oj58J8JuNg8yQ125mxiGdIy5DjdFG+G4B4N3+aQUf6FQLtGAxc7RPs6bPj92wAFkoEsZWNkty2swBdC
mQJswAryifzM9G3l8ZfniBBYGQi0TEw9HiO5hZ6IwCveWYAkwn0Dsm4VwqOue+nxqLgSKXDxQlPQC5Hl
NKUGhu9Kdy5kq0Tb1FDd7yPUfJQl44EASg/bcBYrwlQE+O2gVVkD7+80sDY/FJ/0hRtxaizkuXPlmRym
SlRgj0piIBxMKDeQuh4LcYmgeflLwa4EJk2zuazCfgrpXWc388YHV6fV4A+dPIRVgnkfM8NLQw1tsaIn
GQAq4KoJ0OPDURb4xoxkC2tG2f2CD0R2AvaZSnTBEb5TBoQEHqgwTIX+i2RpshJTAsBCGDqNQWejx+/l
h1KdWFmWu8KitV6DgrxAmUsKCR9TJGqILYNXJ785gyNauUuivMzU54VJIJVlaDanR3SZH4NBcad+3jP5
zRI5EZW2L0ISFkgh0/6hAalJW8WIBmPjEhUkcbeG4NT1Z0YSjWSF6KCTp9B1TWP3H4sDoeJI57cR5sm0
uzCZDO9UAjIWRm2EjKyevKgI9WDfNmt7+brROjyaFm7jr2vEZETDzWTiRt4eDXEPS01DT+1kRt+FPuqW
RQ44RaWychKu3XSaeS68R4TnFnih+ZtCNUNmp4cSpvjtciH5uwRoewf46mIjyhASenBa09mQek5ksiyK
Z01ZFP2KlZWtln2XKe0kqE87+ry2LRvAILV5cX1mcTehs5rWtRMMSFOshPbNMf2ZUpEmBPF+Wu/1TygP
5YoOvOBdNJ5mnEZOFqKD2EhQZx02tXm6+s4A/jHDleAXlpSSS6y9Kp2GUgFbQQOVMaTgEpMck6WEQVDI
lKsY8VPnHuYkj8MsCUEbJ6NiQ3C0s6EJ6VAC5jSRPlkhT3bLXlxzKHK/wtCKiNuobpkNcCkKB3BplDWA
VcCBWaiNWs1E83RZiDroMR3ojuxRq5bCFZpxNy9SawrmHkAiQqUHP9CQhoECHu/Tb6zqGHg0CdkRGXMo
Su4ocW9jXh5FY9GiNCyInBSY0JNtWGgTuBuuEwbtiCgU82IXh9ggEslp5W2TRQ2xZSagNUOJCJYxqcJ5
oZl2zkkBIFrDJrB5AWWCkVFgb/R2WdTdSUjeuFj5QgTre86gCTCqXM8jQac0JOaP/8Q40IPOqM0MjeMG
pbVaA2iyTn1o2KnsJVC7fUDvDeAKpT/6NWSKiTGmfzkciC5QxaBqHmNv7MCOzATFV0jCVwlHkbCYxyFO
pDRLAKmaAQ6B6PGPKWbTPhi/Di33D3QW7G70Wbg0HMsq2eNjqE7DCdhh9taHf0Qn4B65HgsmXzDpFk0m
IF7amMRiBi3COYCoP2UdsZ29bqbXkd63DRiE7/KCh6VFnSyvZCGZRXxLT1DQIJzmOuqNHVmCatmtFE97
rAscQ2ZtFCFYhO0Nd7y6Mlx+lYC2aCbeO+qNnWdQ0rJ4oXq7X5k503URAUR5uQEiBsTGzEiEygpleXzK
oBYnsMRbcaoecnwj5JpSjXKyX5r8ipW2qqbNDmvwUj15OBSY7VhdsDh36RWOt6gOPVEt09fNB15m6hI2
LEqURZJDlTAgR9QvSQCU0YIwljQI5djEgPr2YwA5XQCRkyKFgTnDhFCOKsLwUiOITI/Ju1h6BaLANDOE
OMkvF7TfuXplRiQxql/A+UlWxP9G1hEyUckRWCkPLphU5GNmZ1fS8/lVvYYB6vh2IbK4Ic3ADcvtNshC
IibgxZ4GZxB0hZ056gwInGijoLS2ZEVwahkt24HKgSugfpleRuPscwNSJWE07S99MADwpBWboZYLFYhR
JwOUYOFF5gW1wQFuybjb2ZV01bGAzFd9OQ3VD1+kMlBTMJ3UnscC5KQQ7CEOJVJw/UKBBfEJqXEJPBSX
JCCJFcLxE6gUqyLx0YptfAe4qhcDQnBaFCpko/XEn19+1i/gk+JgCh/ku+gGJaQRN3mBK00i+vKq8xCo
jmaNZmzdbo0GqQ65k1m9bN4gU3kDAmHGH1XkuZLNK05Qj1q/QI1f24GfE6OrO6jq9/pEVAik+RgAFMxZ
RzpJld3yRCJpoQmeEuYr2DnAt0lMe9CLPoHyk0H0AbBEvTRF+MdFk3EJFleSShCTZdFFfKQ5gTZwv+Kk
WCJIy01JJwgk23ywSyc8uK50hk57SR43aWCFpas8SvhvkQcttiCfIDECIm5I4IfGPUNh+Wnpxy8BCYNo
g5oUMm0fBt4HysQQGcKaUJA4vaxTHy0nvBYGpbts/ZijcHvhduB1mDYzSN86EH17CHJOmIgMAjIQLBAz
L8X6fT8QAMRfeIeNnhafFfAWcUt4P6EITxtOciMjnORsQNu1YD6vzfbsRnHWQj/TwFmJZpoiJTBxP0Y9
yMxPGCoBhIfDpjpDeCrjuhmMjZ0YaFjUoJmPflXzH4QZu8SMGT6e4IIBAAD//5C1cfFvTwAA
`,
},
"/fonts/glyphicons-halflings-regular.svg": {
local: "web/static/fonts/glyphicons-halflings-regular.svg",
size: 62927,
modtime: 0,
compressed: `
H4sIAAAJbogA/+x9bY/kOJLe9/sVchvwBxvqFt9J784e4LvDwYDHPsBnG/5kNHZ6NgfQzZymdbnr/vWO
5wmSUlZlKruquntrccZuT6okiiKDwWC8x2//+k//NA/nD79+/OmXn797Y95Ob4aP6/uff3g///Lzh+/e
/PzLm7/+3V/99t/87X/7m3/83//wd8PH8x+Gf/gf/+m//Oe/Gd6M7979L/c379797T/+7fDf/+ffD+at
effu7/7rm+HNaV3/+T++e/fHP/7x7R/d219+/cO7v//1/T+ffvr9x3fS8B0aykvvpDNj3v6w/vBmkG+g
axnMzx+/u/K+naYJ7d9Iw3/6sL7/4f36/ne/fdcv/+q3P3z48aP8/PjLz+vw0w/fvfnD/H/xxV9+/vh/
Tu/nH+effv7Dx18//OFf5ve/vhlOv/z606fx/Q/n8U8yaemcI8C744/vf/9h+Jeff1o/jv/84dfxwz+1
Bu8//v7Dz+t3b0qUP374UP8arZc/32FYP338KB8Z+eHLL4SpttFn167ki7//5QeB+L/7t3/64Tdvrj0Z
rt799zKY7958b6ZpkM+cZagnG8o8muwG+Tcbbwb5N+Nv3DzL05O0Oo9otm81otnY2qEXaSPd9Ya4PY+X
TdEjGpzQ9Ny/vDVt30aXaPjp6iz+g85iGrz04uSj+JV/J4eR+npjxJPRt1v4k43w1/V+BZrvp+vglEfA
qt88wIYY7EFz87C5cZM/aG+f1r17Yvf+YXvvjpqHh82djQfN48Pm1qSD5ulpzfOjuUZ30Lw86j1OB83f
P2yeDuBuf3xS5+FR80M4vv/9by726Ixf+Xcyxi2C8WkI/HO0Jm/PXFhcGkyUf8YONqTFmITdNNjC38V6
O0yDCx67rSxxkt/JDTEOshdlQ5pspPsQ5M/wNgylrGN0chHzOqYwuPg2yB3py74Ni9Ax6WwMco1u5AGv
nJUrvC0N1zFM+jSdXMJGn/hJ3YjLKN/18i/qPT/FrcWgTcowJj84kAfpWL9VzBqtfNjLaII0sGX1EQ+S
jMoWGZRMyLgVI06rTkAerTonaXkyyS+jA1FK0pGxWTpJecE45U8BmvzpeSWznAKm6WS2JkgbFweOucgn
DODhwyBtpFdZjXSTplhrbF1UwTUQrVOphGsslVDdfjn8+PuHCMQTQingwYuR9AfNhLQOvnhZ3zHLGhNg
RuAjaIPLkE4pTIscXDJbzDljsTPmBtiNerWO+mjBuklPBYslsPR+KACdkzURMBFPZJryRyhAFROAeKNV
jGOHZsq8IY/xRLoXIAu8gYwGwJ+yIhFhrEhm5ef2XBN3vIJEMGj2CucZ8MZoeGHrAz0OcE5/kuY4FqI8
cXji9J5BHxE34uR4Ib/tlcI/9QUeOPFo+dL0Y18FovLsBKVll86jtW6Qf5++NznJaN1sMXn5zxzlQv7N
+GOQf5++zxlbe9+mlKHYRfrU/ztLyMqFIL3spSB3gwP48XTEN9066m66OdoPU8cZAQKOc/xnlq2M3R5k
rvIfPWW5k7NcmXruypOjftsOkOFnv5iM/gSbZOcKDq4GdE3QIQouCBcwlSHKzhbMwtpEroAJQT5vjaCJ
bEdgipNOBGsS6ECsKCIYLtPkdpc9bK5+SBB1SYIOWAYDCiEQWz2uijQ5Z1JCIzMWkAdCNQ0WQE0BJKMA
qsAV0BB8Fk1wIeguyCDElSNMbYRDHWLYhmi3IdojoLlGNoRQF5B/oLERSu68XeUfrvk74gIPRvlr4c6U
68RtZjpqLzKmPGBgWUecQXQLNpwMmmMdATDZ6/KT5rGiuMzXlN4dLkAbJ9LGOoixjkqQOcU6WJl/JG2w
zq3WCd6WJL+ukuIV/xn49zrur7cmA/7Q98ba0RG4wu7oTBn0ThZCKLyxciI4EAZgwARCFf2KOVnesZhI
7s9G/iw+D6D0UwFdm9AMKOKyvEjypO9OXFHpLhkeXjhsiBWEQEjYerrSpGYF5M16YpVVQmyVJgYALOgu
xinDg0oOu4w2Htgid/CM46kN2QV7GNh37Zqf5BePwBUbYZKTMOMQlmManwZ5tLxSXjoJrXLZ8qCU2zIe
7wtuCXBT6M+CvuyT4EAU9DGzoMbR99O3+L7snTQk8FGFp4v0JaggtDfKHeAunoQqo8jJb60Mojg8kFPd
YdfL7jd4CPQ3BndvyCU6rdwpqBBH73jkCEcGQiksRMKuiUCgpEtluIIgPLKlQHiE28hZPmlX+SeX/Bnl
N3MAlnIWkUswjq+PfH/Vbkf0S/qshx0+LbNrx9fBwMt+4KYSf3nXbMdlZzgr4cdn+C195G4/CrcfpduP
yvVHrg4jNpEuVilPH8Xrj+SNW6Mf9OHt8R9N4GgGt6ZwexnM1JchcAog+5CMQXywzGTa8Cek3EUeTYPy
cbi3st2IG5w1GSyjz/T2Om6tKQsvI/sYe7/r2D8GZih+m2EMx+OI0+uAB5nBLzCQ4aUjOcAgs8cgezRQ
e2eg9j7E7H0M8t9mGHcwaJKj9BWAw09faVmGZwzkG63M/YG8cGmGLzOS/LXW5hnj+JylGb7JSF7Dtjmg
dvb1Ubvay66TXR+Xo9gG4TYesI9gN4Dr39dm6/hgGn9R1C59AWqXvgi1e9ZInjGQu0tzPJDPo3b3RnKw
pbreoQjM/Owh/Xs7zdnkIcsvxBBIKLNw1wlKsiS3pgg14VG3vsvncXAmz1YEN/kn79aL1q2lRJftvH8w
8oMXj0Z9++Jh7xD/ORpN+P/KlUfKlSY+0TLYpBbb9H2UXuxejlFDXhNtjqAd99D2T4O2aeCxCm1bCqCd
jqCdFdqZ0M4vgba/A+3UYb1BusM5dSAPj6BsaKa03Up5LJ6btIOgagpgKJ1kNzuz2oSdg0WJcaFlB2pP
+Qv/CdANYENYEg2TYMYBzZgE5BPNIIEX+MUTuaYmAqoK6ddOK3uCChb9w87EB4kbb1oxilGGwd4Bduqr
5HtKcixNvFBeZaq/AB5LquVJtfQPvUYTtsBbfIl9aZNP30MTne4csObogPV3Dlhz7YC9PF+P7MeyTnmn
hTTcPK5tFLUv4AQw59B2VqhPP32f+CC3B7k/UM3FmRp53Y22PTsYSNPn2AhkA8icoA4URLOh7kgosKzj
AouCLwOU1cXNwJwZdiKYdBZo20Ihmglowmyki2xmwILPpG+oNF3BLdme2HbBLB7qqQGGtLBYqLzkMuCp
PJzlnFg8zHRDcQPfdNKvtM1mCdDgyefwT4chT2RM0o3HE1fkpdkMcYZdyeVF8EY4DOkfq5r5VfgS8OEg
FwO2Qxw4X747Smez9kvjVchU+Or36jBm6cYtNO/B6MhRjjJi6Bqhe5VH+Cj0hTCGUqfHybIBvo4eRrOM
1Opi/yuQcBfDIxQXQHb0iZBV8FawY5Ajeg76vC7NiOXC5Lh4akPNtKEmEJUcsM5QLOQ8RNh/zApARMef
UX6j0/WBJbDgDge7ju35WNuPfP3o+LTTHs0nG87clUaWGnsJOm38B3+dbArUfgoHBoM07kJPjv/wT9iP
Fo89x1sj7q1sN+KGnjTSyWJAqNktDL4rL/AnNpHSnnrMrnrUYjsH0nysEI5dHBYmf6IhFodYrsZYbDb0
gLOmftmsow7HTZWZ4hD1pptwfHIqZtNHosfUz8eErRvuPGrms2YZr6rDdPu1cvPRwWo1lZABisxRtln0
fpZ/sF34Sp3ihZuMu/CcifcJjrU7lBCEMEZRwgyA+Qrwn3wKSvF44sUUri9bvr5qgEpWgtr5rtOh+VxG
1ZhZ345NGFVkgKWsFpY9Iyd5KXKLPyN+6QYg97MyG+vYL/qjsTUe68tj62zUzmHWjfWTgqRyWNF+JM0t
sbuatU3/Q6+1lTYaL/7Ytxov3h/3XStehbqKWAr1hOpc3D14+W6vBl80e2eGevCUmQIHteQRXLZqzO2U
2aqeSkHOFWwVoo6FwcU3m3twAhYv1ImHn4WBO7ELAdDhmMLONEGbUIEQUtr3J56mrp2mtFnjKYcqbSse
G26tLAcP2VulSvh2uKeUt3G3f9RKYwefKrOnBjhThNwWo+Y4MIdswIuRV3hYzX36xohX2Av5ynF3uWsw
7t4bt97G/oVx++q4DWVswwMi5g0RMXYSOWEatWO9wC+eWH6yXdQng16x8djeF7oX1NgiG/3ccczpDVmB
UD0qDuCa/rVtzgqyGcABCZsblE4wAVenxc40mkOnCruZGoXcCmmlmwvOhEyDJwQdXABjbhBa0ugb52Pb
SkF9aLC/cG3bDhNxJqiFLR4NsryKJbbbErvdAm/L2xcX0rVJZngB9XUlCZkysrgU+Q63gJseynUUofYS
VBeguvy0F5920lMTnprstIlORKUm/I1d+hu7+Dc2+W+sAmATBJtguEAEFsjCLA8OWZ0UfGzOt7ijrgpw
OkqkkCIwAWZ24ZSm4VLsa7MZ9iLibt5HQDOPhOEGsw1kDWIbwNBgMSVTNuQCWjoUyL96RGAi8BGSfxg0
MVUOsSS/C2HHzdpg1uCoG5V8Tz2fFB4AtYcvpqXnHfqR30X7eSBwn9oCfYb8PFwI0DIwTqlB+whuexYN
PqXgPG07G8/Vyt+Y49KY41JdFZXTbSqfTQnUjfL+9qN4+1G+/ijot06hscehs8dh963Q3wrtUbz6aOCz
fPXZAcjc3rPwHI/kGDM1vW62A8RmL2RF2oZCESfDE5LqrFDovirXqlAzdwSg+Eg6wYfHrTWX50JCYR9j
H2VVPDdpI9w1Mwz31CDHZ5Pze0yr/iQ7d5IdxsAZOU7VjQl71m4iJIgICBqUdm6SX+6QFQoub1cyJwBQ
4OQh1dILS51iqvOeclIKDnjkceM6wMVPq7rO6D0ozbRZbK+f7yHHxpjafsTqCasHLPxqAUWerThaca6T
f0y61paexLKxMeVIhkMIUkj8GeVXH436rC443iGr8JQvwmeSzmPWQgcNtr4yMnq0ObB7MiyviAMvNr00
9bRDA0M+nzdW7Q0tq2JLnWzPPnIHDFGQaYUnq0gLgvzEfRE3V54bQm/ZbFQFhqFrm1wKasj9kfQM767Q
u3g1RH6lvg+WN/5mF2py6mKnVc2BapVVI+66m1HMOIlKj6XpgS3CUySzBc/sbo/J7EJltpiZ/aPeFf5z
NOb0jDFTsA5pjmUITvAHX3FwIaSLmaJZpHY98sCbEQoQ/CIcFrak/FifgWRgCoqDv9vREPNuiOa8H2ZT
fOow2ygxQHhC5sMBpqkP0OkAw5UBhj7A73MuQwmyAoIpi56yARQF/tJe1f7QkinxgfYODWeQmBjnOMg7
MBmkTDuGn7D/rSNuefkzQ2WYj8Cwc7jjcRQeGlR2NhY93Kq4VZvsT9v+iusnZdx57PG261FRrj3K1x/Z
28e8ve2W1xQPZt+h3b9+aTQa9F77SNdp08nq6sejzqbevxA53a6Hbraq8kk1rqg3w/UZl/5Jd6Eo4YNy
HRTG3ATT7VX3m3/fzsi2A09nJK8MZrcu2xf3/JIwbUYfyO8FG6Xv2O2dbnK48k4++k5p79j2zmakuPWh
A3hs3moqrKqselWR7JOfMWKKtTUqgZ/2WTYyzaKyEy3kXrM4supCclWHu/LCTQgT0v8n6jfkZ0E7NK9N
1rG9tKBB/5eO6K7vrPXlPC61n58zfh0Jxqnjr6PH2B1E24F3V33IEeobdeQ6bjfpmPURFrqq8WRNrowB
V7J3Zx/oJnE0T3fJ2E02zCZhpcKpWNWkTVswV0XuFHb3EG7UkKMcI4ffBU7V0XnP39F711TMduqMbGNj
A6NTHvCwOw4WjGg4XM9wwfenqvUw7fSM9Y9uk0uN+JAK5W4rV5EqOJEJygwe1Vh/CsXOEfKfn2Ebcj7K
UAcea2Dd1EdAxFFqZ6aqnaHvAC+lQzmG5OVqj7LYLwxmMcIxkufHiVINJioxrEbZ4lStdHiL3Wl8Avom
lBIp5tC/i5vykCEFR6e6j3vCVsWVnbSyE1aw9Dt5ZxN3KO10EWuTXtZNplFNxugHTIIKGiphoAwVsAmY
o2wNYRPwV3b1efVUUvGIviG1UyC/vGUpko2w/iFsUVCVbdq3Nqlq3IlVm2wmoqULEWcfKZdMC3yBXaF2
qj+j/DLiUH7HftGejLXlqC+KsCZIESoUBT3ABwZENQqzw+BGs8q9xPgB/ui9sbYY9QUl1empB1RjIAWW
cgBFWZDYYQAcXdVavJKdLUJvnT+5YmbC1dqFggaEF8AoZwJalRWO8IonbxI7FXgbWk49YqoElcloQbLD
vnWJRleYbDMiUvOJRlBXyIhOkWGotIBi/RL0IFTMsI+ROi1Gt8JiKs/xZQEsjMFWmOwELj3NqsWSrYxR
OyPI72SPHoEnX9C/XIDIVZhztiEywmDP2aZqlZbJEG8oa8a606yePxBPfKHgfRaAeqoeWzQmYvdyXgtD
VjKjPkLFe5VzpQsQBl+DfpptAP4tWdE4iXg0ukGVlGUFvChzRuJzyNUCUSh71nCSQunJ0/Y/1qBO+uSA
4YYziNWIqapz8ZUOipC6ZEThIvzQY+URCQeoLGCiBo0TNkF1CQxEjVU5Waok4ls4hStLgsLRyAlG2Teg
q8yugGlQ7LlJDSGFHxN2Lh1F5viyP0zOIS0JLkQauerRFYOXMwiASUKvfQEBDYxRHgDiAqSE3Z10GktI
9yq9kA5PXg5D0BJpBBzMg/rdUBEBTHOp0Q4HGp+UywDBIdhnDUjONmiIYbAUa7NdEaLk4hmxundUEmHq
YVWBi5ICrdwjAqQslAyJv7KICTfVzySR5uldVcy0EGWhgKdUbTxjFS4WsiEyPa7xyHg4MB8ad4aNhzly
1owCN1WGyaEeoKGRoirC8K7clAaVVDuNMNcY8pW6HVVSuX6S58rYjbzwREdfPl3PfKGwabymLI7IfYyX
B8sirAvOa0Aoqnp8HtuV3K2nOQiqIWTM50PmEi5wG3kElXgPKvEWVAjmA7g0qBwydGHvQE3Hqqk7VjW3
qkBV8d6rqvtUVc+OA48qc9+lytRY7IMB5Od+/zEb+ODzQ/9+PALA9GwATJ8NgHIwgPjc78fP8Bk/ZgmC
ezUocrhEX3EADUlwdhyhaXruEB66a98CAfUv32wAT0MTvw/FMEcO7g+W6rGrvZnaFPsAunv7tQUzm2+7
Uul4dwjTC4fwcFubDi2MwSmiHI8hv2wID0nbBRCCIsrxAOLLBhAfRd3tRnCAKOGVIMpnLNFXGMBwMYL7
iPqVQXAXSb7EAJ6FJvHz0eTFe/llSPKlP/9UFPmq07+PIF9z+m66v/xfk45+I0J+e4Oo+8SfGwR3keBF
AxiOR3BAI9Lmrmq69cmKiEZpLnZpLm7SnDzVOVXzi9nML2azYx0z4hMnSv7qIXe18VZHDPgV1i7c4S3d
lQ8Ph192T/jyEWcdnjrl8IQPH3Gz5saHh5tf/kxR4gCjuoLvz4IE5sko8EUwwGD9h2+PAOZZy//S1f8+
C7F46JU0NPum80OATmanAepWeUs90RH6lL1L0Fl3lTODtUNwa0DKN6bbcxhkoF53hZdTcNQEARTQ3ust
GjTkmgY05i2E+gd9wENHXn9iOroPU9zMz97LlAwj/TJTyNGoYJzwe3LXQI9b0wvBo5QANACf0bBMqLXr
3bXlIUKWIbw8qrsnu9OsdEalMhvdDDdIgwjegi6c5l0yIcoNp3HB1NvnrOZ7yFnnMbkE2TfX6L8QGQoW
oBh1RdWjZZVbY6H6UX/r7VEbMQAsHOkH45alTj7kab+18Ft+2x21EAaZsGJNeU3HkWmgvxQirSJRzcTS
VexWbUZMO5UENrgwzHMYmQHMOtreVKmXESSGrhjGOcDynGgyYFu1hZWItGSwBUIHzg1gmHHRhLAwdMtp
cJeNVg46b4eUdM2mNCTdFtnS7YzLxlsLHgIVsKbMlcfb2nBs1+vYGvCqZtWj3YmdHWGe+4uOoUibe7bG
zxL16R/dcnCdc/DwEo7qJdxuD83LEM2PANRdJg3yQUbYTGAaFrjHFXY0YB4mbqysdJFf3Elr1uECFy0d
xoagE0fqzDUxVSLwhpmWoR1eMy05aaXHlIkroxRppVDlsXGRBiCY42AAihXHaF6rxiBYA0u14wxUPy/E
amxd2qdAvei1CHRckRPRGuivvIDc+EUNG0wSyg8Oq3HcDhmUdyhZNgo6A21KNM3CoivrlRKzWnIXCWxg
VFwNseltmMsQzDIWzo+T0+4zl1UPlaNghRh+8yC3NPAUe562GsvNwP/qncVFJrF1TIHqkc6aQ45y8Bpz
z3Ic7pjJw5GVHGxtcwcSEqPOp+q4qltAN64OVm9WbgCtptqgTmwddxP89L2X5XDwRIyGTiGCcJ7WKQAc
BlmPgFX5jxw/QlvlSBBem+lN5SEu2EiQMQvrDQvxkRtcjE+D+QlZF+hQvzCQdnSMQudxhOMCAQhfD+6E
ucFhrf46zwX5BcQHAbmcIsF6ePi4PJAuI0fl5JTDKbQTJ7yB/K6wMdF1vMwuyhtwI3Gh4PSUuyZi72Bw
aLbSRJ7hFKF7gQSbWw0Hj17B+yFqmsFqVWJUy9GypScuG1pEeiZb5kEQdEIaBqFgsLmXr7pZYtn2ihzN
X3Kv4HiNDvlIcL5nPwd4nsaEKG8Yl+XCwwnLuxo0Y/yRF03cfGORe5hesCWeEeJxsjsXx8bvCSrwYAHm
F01Ro8xqyS1ZRqw+v05vV6sj7fUlIFBSO+g5Mi6+wy8fjXdvVFcVwQsURV7AxdiOnJQnVw81L7ygPKP/
w1HKm0eKpI35x98H00jTA1Xjl5qE/Of2jHL+ZvPrAeBC2iHchEgh5+4Aj/q0F855EETQ81gvqjbl4H23
e9+8JGtWvmPasvelwtzdi7/yQO7G1eRjoPkrQHuSvfzeGO/ay+8OMTxIJEv8AqKdiWzRM5m44Fm9Ot/B
s3jcX//DpRepqKcXbj8ZQN3P2Dj3JtWOTzddmdYrmMnR2PNFoocvZWc9Hu+dtGqmBixXCgZv5ngU2pPa
uSWygQghZQ6FTqBykHtEauI4DGC+5Ayuv2N9ctBr7sG88JQsfnu3XVgwMNJ7SPQTE06Wyh5kqgFHh9Qz
OpAj3+Tc/ZgexVSD7VH2hFwm79TYahWu6uNRn9fAagBzd3nRZNxeHXt34/4jY/t0M9ZUj2i74yUueIqN
ubi4Opqxfe0zblnTtnCTg9m41zobhHcjeI2Op9a0ilC2BaVZPsED+oNquJr+jvrEXhR9qm+3HH1b7agj
F9vsXy14Elgb2bTQqtiURDQ2IhpjpgyBQEYTKi8d69nALf9I45PDa52ok6OZvo3eLfA5rB7HKyMUVoiM
bnVDWQ38weF6CKmS5XZWkGfPJhCqRG7lfyf6EeA/kKSqdpkqSfZpqXCC0hvlTUQIpYxoF/rFdkWz3jZM
ZAhffQSyahUFD6dqo5n1yaLJAOE7m1dqpqnb0phfXhnUF5HHTO4XWA0IcygoNzMExBHQpdXWC5giA2OD
mNFrQvUbwsNWl3vK1IEumJrWn5I34lbDTqZqBoThngkqx9eKF75Oxz8KOeyRamZ6mCXyUwu8vzSj3ANC
2olkNSNlCQvTEYWhcF0UHhOrYEAD3o8asvwodgXeGLQsAs9qvSoqt6vBQll6108ip1nXVNdptEJHBnJl
XXEDKamkGmZYoIsEV8A0H3lgOZB1LBmqBjIuRXAAqYhoQPPI1Dakql+hEtux25Q59tjGHmWHeHi1Sz/C
L8gDGK3b7DhE5JtTrTzDuZkOIiW87NshK3NJVIZTAyzNoe4p1OEim1Obszlchfwq0rd80ww9KPOFVIfQ
XAckEdSrGQlG5R+fjLyxezDiyXjxiBfj5UO9VR8ewf11pM35lnCnQTO1uPhhzgi3TrMgNKqSzaYmhxVe
mqEU/gh8ZXoN4DNyHpLvCSL1ZmgFFwZB6k1pB0tpolRzCJkCmSEsMDIEFC0q+F30zRurAFM+887oC0eg
2pWL8Im1tjz0264ytapcrFdHUkmxDzXCfN+1WmoecpBeeWSlMKc7tuqyKYi4jIz75C/zFpJ4lbzLW1hv
HVl4ypaXhH2eoF2NLdJabyB/nS/DvdGFi3hHRKpZJoappaQY81GcpiByebU8cmDvOsvlDZAstFkD0alO
RoISBikyLbEsf91gDKS9o/Ir8TJp3mxoNbDC3BfZUSKcbjsKd0beqm1ONZeFw6GStpb91druvGVNqneO
RtR1HqiPFqm6toWRR0JY5aOtWGu946aqnZb/1Mor06OpaBd1gGZ7obZxdwq+fjDT83NJXeTh6sm5er6m
iyxOXyclsnBkclxlEUmQxxZ5m5XnUfoB7mZ1qetRgq/eNKmqUAaN+EM7dKDvw0Mv894K21rTXKaugHFN
J5j1E9e53Dv8nZk2cpH3bGOjHT2zQ8uSbTrPicJ+A/6ntujKoWuEMoLpiF/MOgYvkdFrlb9qAbMoAMqa
lJGM/8wAQpmR3IcAAm7RU8+ExFoDY0xldhHtkOrDM7bPaGyfQVnQws40GQ5cEMjSRWQLDrRvIbSbsBo0
9R70s0JrBs5kV+1qK2Tcyxb3fBvyGU1y40WkiUOJM5A0qaBumIQhm5bPoZdA7vWOv0/CNxcWwoRiKi08
awYGy/JgdyxiB9YXgcqQwbjq8WA/m2kLCxLIsdgZTjVWSCz0bZLBoR4j0LV4yIJGxEZy7rBmsl7dImQt
yhS1zJ5V0omys+qGIdPV6ncuvW15kmjyt4KmQcNBNU0L8815fI3VFhH+jWXNeqBqSVFDioqWqGvbvTL6
gVvbcnuQ0qpvBarZ0v0GyAUOIIRPw/ck9EB7JpXjmr/V4qkDjKpLCKhG62JChDQqTgJ96GBB5yCIGKnQ
sgvBeOWLxucFfBAUjQIWZigqsOYSk4bQ5F3dfxr051hnFbhGSdZoJOCkAYhqzM0FIwe+O4s6tgAMuAkP
quFx7HiG0xtd+GoDPVr6zVcFmV5puUJQJdyOULlX83ir/8Va01tjsejaZlCXcTQRtXwt1jLUrFMouWio
PKbP1SLbNNLRi+tORzID35YlkQvTHIMGeEuvC091AYO/dQtS2FX6B/FNg2opmntlr1YN9Bf5DjijegW0
WKuvCAYvI+YkNNZydTXud1jlyMmLDF0QEYHBXh1xPEYqrKuMSsOJsQ6e+RAXIAD0vp56a68sMQsYW0iA
C/UfiIbn4baQLAGb4eFg6FuktXLdUFhUlJSYcxXyseJVQ38sRH0ixRGnrHHIVJdwgkkrVpJ05rxJxCMr
9CIuGaiA54uG02eloCt+HTJsEafWjnukaFpdgjH0ulIEsGcgf822oCmCF02RDoqZ6B1Ichn1rUDPh5Wx
1QjoR2A/E05WnDbq22dQjliX9RBJG4cGzGfSVRSXBKfGlCGy74XLY/VX5ifIdLRIQiZXlfwzXYtAHwe4
W+mpy3v1MN+ej/THUv8lp92M0o/mPWDHZChJuGiKx1hGWBn0d9FK2OoeD4LUm4+7Psba7bj/1LiNYNwN
bGh/2V0jttnmNupsx236Y4OIJneWc8mS61qYpX7wLWcAfL4SA/yRfYCaJq5HUvKtmeMYUF4FE2biQKWI
qfE1+B6z86zq2oh7QV1fsF/oADk0gkTqT+UcftAZnWPT21q+V/V0wQ+L17rhnn5r6qKDI7wWz1zHVk1z
rNU1Ry22uSABGsp7s9I31T+ZKsjIw0SEsCRjCpH9G1YE9zx4Z1A3+cfantTwBGbyEMKQvebIPpBHzFaF
9cviaHO1URYHnijenuR0EaaErqeqoJO/+UgObJTOQeNYF4V6LYMcsbUErtH0JJrQg6413m34YY26yQi1
ZrnpqB0braxO76zEg1+TVlAWEkZBBdVnQh61nIUDEh4jMeER6z+wdDRIYUT+C+FmozA/OCtQqwf8G8ms
UUINqs2isSsxG7/weMMR5BqjARdROWG09YItQwcmgieFGaeTjwt8xZmhYleQVbcEJUHwbELNHux6lIYe
9AhSTiTXqvvVtbKoCXSqWhWWRsfurzXvD3mzHhdTko5cSTJ827WqgT/JGeMXVqTlLTW7ckuR0Ykw7EwB
eVYmuKGCR3A8NsAs2NLayKCwWa3Rgyrp8SKoEYLWXPfYEY6/gkEO7l7hUkzgrZ67VbMhuHrhniJTXFim
oz171LqgDlgPZoE7uLbZRZRMD2fn4AwmfAirjsQV+QO9588IbCDI45np//COzFCYPTJgA9ZQZX2jR7rw
26aHOJGv0K2CnA/qn2c9tK5CljhDuBxTkjfw/ff9VadEj9IXk4OI0J3gtwU7MSR1VC0CG1NZg6nyRqSU
Z3YEFJ+o+j7D5Z4fl+O4LLVm+cDkYCpeysaPx8xe+azw/5sJElLoCYZT0DwHU0s+fCcRrQmPsiGGh4kH
a5amO1EfYZcM0VzJ5bfDtMtHQ/MtuJW++EaP7maPzWZ8K+nxjQ7D7Q7D7Q7T7Q7T7Q6Tdjhce1Zu91hu
91huDvE24pmLXIlq/ghlrpqgk/Vm7+cYLvwcE7MKVe2aagi9+VSVDehFhQdru4kbsqKcVNqyZoyMSWhe
NpsZXF9yJ2QsOvq2PUrSanYlev10P6n0i5NDB3UC9TpAVyF/mC/6YPD7JOLN7YHqU9tSmLPOFI5aQ53l
UM1pSUUaM6iDvp495P7I/MGhTY9KiwN30Igbr8xfQlowS+ZxFVils1Bv+V79cAWBpZIls5ARKLfvkUki
bY5a6kmNoaCeqj0CIawBDspq290f9VraaBNkjNXaeQHWPhUwycsYpvUa9JvClvUC5teyjeabjw7A3rQt
YHXgc2DVRi7cHapdVUelkU5GcjThgTCheQiHfEIvypgEv0qaA4we8spcX53H3lnvfqwfPOq2i17ITZ/o
pyzHX3Z1w2RHY6tqqFwOs8WC9cyJUf2Zka+NThR4vzWQ7djqucj+o0EG/db+lU3g++nIEGB6RULhTYtw
ASM0g+C6vUVsihyv4OzKKcvWAd8Y7QJN0EAFDm23TgVv2V/F9yjF6t4WmhfbdtUeym6kXAC9QjTUDXrN
U63neFFvhFX1rObEqLtwEDu9PoqXPodmkD96b7jxYrgZh33byS+4MNNaDVORc03DGriHkOcuqbxwsB5p
Z66gQrjlgj7VsgRbHl57RC/dIbnc5f03h05aZivkN6i3faqDqqQ+bSMzjYq/fGTNceJwZKX7jlqq3WUj
tC2TGVapgQG5BwZUIxkej+3+wQfstAtCqIm50QeiB+JlcEFuCcVL0oMvaszAQYyDseYitap50eln7p9+
6j16VBvBcQVnZuEUWgDjikjRA9Ve2PzoJqYWFKvOM6o2f1tNNrOm8nSoBWJcVhJvpmt5sslQ3np4ADW7
z3QAMCvv7FGk0Bccn6joCBcDnsQI19Jsc6BrnvmCqxXeDzXS0fCM7d6zOFDPWf6XVmrgVlOPZjsIHAaR
h94y/miN9OoCHCb1t5ojsg2GmuNvjDX3IGpMwmxpU1xabs5G3uiupfpBusqIgJMdZc1JzUoctOYWDCIp
B1Q6TUyA6YLZZd/O4bb38Q26zGF2ytjpIq6fnoPC9BJzydfgfQzG9cG4RiVNnhHbaZKbKX8miJJIQomo
oGlF3vgMz0rZwJZpJuUQghcajaH9lKFdkzoKRXBGWzPXKX/TwkBPqCUYYvm2xoBCwzGrCJtmoxoZ4WNT
BZHrclNVFAS1rTSJFMUyqL1PS7VlwWaUyQvFUG3VU028WlWSpgaIUssM2dNqNJVqqfS4o1bIaw5MHCCc
TWLseEVSx8fIiZuQzH8BFsE5qkWgck6TXvBXDu5EuNTqmOQ+ow7viCXope8stAXCkzBQWAbGcsHWC18F
QXxm4VPnZig4jLBIhjlZ5cIzWJjN5B2+x9cQvAozN9RQQUgFf2lQRFHTmc0QidXeq/2M2nGe9IoX7dtj
HYsODS9zsF7okKZsPZrnhefCqTNMtqUP0DI/WtAkBVVSJKGASEurSigNMedZLAjvEfEsWBegjYPp2CN7
OVZQVsI3Au91mQa15dBe6rnznc2LpW0MKjwEUqta4PYbZFEY4hiMop5jsssZsfE8BUetRlVUe0V9G8sZ
K8spNLh6Mp4d8sQEptrVfN7Gnhi8hJSoLH1mw8nzDsHMcm3MIsN4XxeHzxBkbXwo750asGuCcKoEbKtP
XIG+wbyB/CHExwryscJ8VKCPAvV+MjYojjswjheQHyvoGcTeKoUdvXcB/wr+Cv0OfIH9QOBX2Een7qPB
KsChgK/p1IW4Qc9TId4A3uF9Ce5xOzDdUSYO04sLki+9DvTMJB2B4dOgzF5Jts1Ups1wEZ4dzZTTwuB2
oWARUm0lw7b6/hkKDRqQjsXoGTKoFJ3luEFjc4KHRQYRZCpjanzVbVgI26rsMsywoHr6vGCqDCalhZW2
YJq61cRZbYi5UVvqLoYa/lsERQyyoA/wQvWYbC4K8lxOFoWUBV3QaeSJxf1lVvZmASyHXN4I8cFBKBs6
qjJ1LNU7xDY1nUde4sgskkQVZQxovZZZkVnQ3NfUHg9wYQFfAaGLPmoDK5Mbyl84nZghRIhcjjwQnaN5
FvmPpyMZohdEVBaJhY6FLYNeHn7mDmnLZy3fxiWRFaGTCHJ/gxeyjY+Q+am3pxEQOIyRHkpaWQlWLZEJ
eeg5WsZgd61nsprnbVzVQgd9uYxa3dtpimWBHCr3vVqluWQsUj1VFpZHqS6GLryraLAg6zU7KkxogkPB
CCs0sqzvyQpegKOYVBOsZlfTty1XG7DUpZ/SkIvwkHSodILhgmV0uXSz0s7sF82hMNC2o1NA8TL0vNDo
O2jxAOq3YSBY+bCttrpTqL9C/Z0qjlRs8Slu/i/ALXNlmx6sdxOEhDNIpsysvuMiQhaAeuqxHVTtD75E
E0zgzimwouHAFBvZrRneMWfnmQ0nqAsVVfBe94XioABQDjMAIrOet2a2gAtEIEMLeqhOBMxsoznJJ6b1
NkNW+73mp6fGSFX8HJJj0QGjeSvUD4leKugQyUcol8yykzMcf+iAJdSVyki4AaFauKDpEJQ/n7HFaBLs
HLz6StHUjjzziIlHnF+IaiywrB8AqkwkDkr6IY5q4pjIfU+5iQE8AAl3paDnmZ6D6m2jCvpK6VUzGLtY
e+hPabZCmEPIgRsCpxlBMHfQGPUqokcE7Wqe6zwTwmRYggoUWGeuhV776iokC+dqjpOMcnJEX7/WNdQl
xRrPdb3BHUe1exsNNsAGxcoqsiTWnIMRnYgks2fy9rS3RTQCzYz8FDg+fZ+QJCAw1RF2pMBsmCsEKzwd
a4WwBs1ETPCTsjq6En1tiCtB0zAhOIVkWRBV1vZc7SAd24B+mrA+sXoCGfvIwvXqiOgjTkU0n/zTVq/J
9LBDp8vsPnTqqkl1lCQRnDXHD3W6cFWBi3YNNLkMZMl0yXYwfX5OEItjsMnKnCCPI7iojmQCEaE2rDtG
d1uBOFSNhLxe5Brocawqcbvs6U+bt+nztpy3UoKa5aiGF6W3uzxHEx0jOOdaUkELMVzAJHeIUC3zeVFt
1eyKeSvuMXiVwLEgyqdm1zgChPvLQADXjEfTroJY/VVd1rG7cC9s+ZcxT9XT+Xrhm5jnurzn7h+zvcrl
C6ZMpYoi/Ytx/Fn7PkBcnlR34XhQqjO9upEl/VYhIwcHAKR1mgboGjBsNZVrhcBVNSLQLdGRRs4fyJ6W
p3Gm2ysNV5rZig4CNR+XQSUWSgU4dNTHCrVCYLZKcnxpdWAl9q5yLuOml1HhIC2Gdjw5tRF8aWtNMPrC
rFrKpOgpxegSjxRyLg1qqYqD+gT6gdU9NbDR0sWUTszqLTpRqaNOJsqkFPq2Vue7SMad5xscPQY69Xk6
Jr6tFrOpXlCJ5dQTgm60Gqa22IGnFqQN9jcg5NNVpnWhZglHGsoqqhN2Jmgz/KIi+RW74MOULU3TsQn/
WfN9OaIctWDgFGhA1IBRFepGOKw6AEUL8wAduEiciFNNojqMAIWxnrD+UD5xYaVO0qxaxcdq31CtcrqZ
jRKLkqp+WKu69it6GrULE6pfqq1arIFZ28BBVjdA9SKhz5tF6UvYpeCvQl9aAS6tml7VXuD94OoiQgkl
ZZpW1TPTV74FrszoiIYmR9xgsa9Q1bMqv8DRUkds6Uw15ooF2tLVEtUU8qrP4VtVnUI+Dd35xXnV5S5E
aDKhVXWuTFiuj9riaGRtz/zErRtgoTNxoRwmy486wBDEVTqZhpqzbmI9WHU6UT1mpBM3eSSV0Oj0yh1O
x7OxEGnNoFtDHW4yFeUI3Y00XE/uhKqIR+RxU+4w++NSwy+Mui3SXSGUomEDkEtxpFLPGrQWkhwIHiZx
B68jWFxZdUlEVaPaPjtb1iWNyv0y2SL1XownA+IgRsgyVahDAglwdKUuFdlo3cpx1SuD4HSIdRA1DAfK
VKrHXkAsLHv65defPo3vfziPf/rujRwDU595ia/BkANIf6OBDPdGUl4HSBT94rUy6rRRyaPuYuf6I5Y9
LfFJET1u731ndi5CO28fiPqhFnEt5LhwkoTKicwMj+e3DqtcmV3t3OYZZOzeE+SlWKSBOIe23OPFtffX
9o5BuHo5hIcrsK9mb6YnRl3tys8+DKVTc9o+KrCuxcOoQPpQzTVob95aMRFIfc9uLfbRTAl2AVt624tP
IJ5wvAgoRDwh38nIlFO7vRUuaMs25CMI7OJdS/y2ocG2fpL1HnuQr9vFVW9R1T2a11E3zeCJ58RV2wJV
KP2swdlQRcRsHbmyH6tydeR5aw46V8+N0lg+qqTA8sETBjybcCGq5KnWVz2Zs/ZGFpEvUBFWuy7r1mmu
nTrlOvmGdpv1yEf0E1xznaWhcGANwmDq7qIfnhyIsxxiOMbB0oFLvDqS4bOGYrzqX2VLzVpksbqvoUPw
NHTtZXIX8jsasRIV0qFf6yWbRJrWQWMF/LuR6bjWqoaici50UeEIRA3uB7jdfQQ8zSYa/lOCWsCTWxgl
lgbqnsvKfe2ElWZsIfnsBUxKlBFrRcSgHndNnIl+8bTLSR/wp0d+YviQ8wMeEQ9wfqPRLVGeobl78moH
InghK1DVnXT+XPhI1g/Li2KfTDscWW6dJenl8YwgACcTsIQjNfmLhdaasXJuQGyV5lN3cVEYqsWPRiVq
SH3SgKJATwR8z9KrYFKLJlJGi5CIwXM6mHmMmj8mOkR7hQlxLwiiBbsPMHiBAbzifV6kV/m/JscGHc8C
JDiSU0zmfsCXYJH2S+FqaCAD8javmoKGogANCfANw/oXUFNy0558IeWiOG+AmYY5IC5QZMsoSyIriz2N
Wr8woFCJimWI/NhKY4JBXpBYg8fgyOc0RgNgYIYBGM6VZ9aIQDi3BpppIOgh4Af/MoNFjqwxvVK00L+U
YRKDAYKJWzQluqW8gxuLNIa4RN2yRdlNMPvwlwcPL3/bwhzr4I+xSwr3ZVHmniVcVXaAmQEjlv2TkoY9
Mk26CggqajFVcyF/QGcIqOdbQlqVjHwVqqaaVXqFC2upfdFnf4G8zuzZ7LsG0CVYVJQSSHMEYGFUxUD7
0ECAjVFzvkxr7OnXmcEeqDCr6n/B2Aq4M55nZpGjA+IIwt0nNzN0dxGpQY4uxneUtFLCS4WFgamZNozY
MNUJYwqsSbkgOIoKDEtTz1g9QUzN7pwQRGlwHlKygMYkah3oSQ1J7M2rmA3J6wgBuqoswV2UChbGxNIz
u2UUW4hRCP8pTHtfSIwQxxOZVFf+LfJY/2+YqJi/LbuYgU6HAa0DgrlrsCk8Sq3amCtFQWZ9lB6wPs8y
DOYdyAzgZs6z6ulglPgzkX4c+j/5nqyi7JpE888og3wwDwNDYBrUfbMFhQ2a+QyjwCAwBkt/KC8j5ZIz
jhtaHa8amcT9D++9ARGgpESsmpuRQQIrzbzwbngMBYXQqKBjIolJ/5In81jzE7s6L7/N62ABwz7ZqHBb
WqTeotT84COsZojPtloOGoUHIHUzWHVlkJTchjuKNMJJ4+N5bGXuD/jzeNdbr2YbgG0iTS05SWL5YHgg
VP8F1zYao+fUqWlql+ooRC83tdhtl/35UK/1tXHr7Qhku6wbs0P67oyge0QJw/fSqIMJNesIDIeDNRZZ
hXW6EGDJtdIJ/ZBDrX2i3mktzbRdqtBObUxsfsZkY+r1UF2DpckMvgWJhyxWQz7chC3iJqUu2A2mI/1+
r3uNBBveOVZoBjwS6cpQKwPUjNogRmfnQiuWrEnhtHC1447DQFPTbgk3jEkQ0ZHrxMNur9wQUB6MYNEY
rcDAUiZiMnSYA5tyTlljSlJZ6Ag0pG5W1TIWqpIFSaQ6jIzkmH1Ty5lcq1CDlsCRE2CbOsVneBxgJqcu
rWQL9FWphrFT7KtfqIyMrUrsTGsq7eZNmw2+RNMVwC4I1RrSeyMJOmbAyK6gHKd1lXcCywUhGXNS3wHC
k7H9gvKyj3NmTnMISjimm/OBr9Kk6ihNM5nybAO5QjV3aXa2oPo4OOUJjxPVmDa90aQp6hETJGNakJGG
VRlApsEVAwwykXpC2sjg/TMqIBzhU3kQRUJdQdSq7gj1ZESeV91oVBXnEFQlrsiBLHByhgL5ckJyJETy
ChHKufELblI2d6KTWMYKg/oEZoqoZ7Uch0FDUoGTi+pDNU2auj3Z6gtJmoX1Ir2fNNIvq4ShqQZs1grn
q9dz3TJCqao+Cuuw0+9JUY7+91qU3WvnINUsbm/IqBv4DAikgV2JfPlAB0sIMfxNrUI6dKIzi3iAxyVt
rcinuj/NiYFg+9jSXDTBAgXHWSwFwZqFyUxGrcwxQnSNlHfmygzybJRTYeakTdWA07UGqPm2hvwZ27Sw
K6kBtbzCigRGaJNODFXLapllxB4hStj8AvZu7c3PXd3bS1d/lHoLii+rKU+uO8T3V/obB2Mw+zGc2hf7
By8d62sWFruPdNtFurYWLYei6yb2UjZFGR+V0hU7+k5SzdipBnfsmo4P4u1Q4arUEWzZGI9VI70U+FOm
+XnDaYO/B5SuNvxcqGQmSHziPN0zUao69TPBzpU5265UNVukyq6R30VDPmPU/gWj9ncGlDVD5+HMynNQ
Kjxz0C1uFR/aImPCfvO0bFH6yD9Esw2D3C4QdrrIEXrP9N1L0L5k+Jcfuxj+lTGm2zPrw78EyMHwn1Ok
pbonUMA3Gt/OGDuj7mwa4hkb2zRs1VNqpGX63LI3tZr6Swq7hKaC3+SDdZMahlqH8G5lmSMQ5qsgdFVf
Rosu4obJQir41ANzqyWz7svMPARhugDhlQI0TkFo9iDMrxCEzaN+dsKqMP6oXtyFcLkJYUUVs0PSDcpO
kVQBhuw7FRnNkyH8l4Kk39coxFmDEBBpAu945+6RgX3RxyeQgc/FY7sjBWZHCMp1COc9hM3rg7BXAltj
D9yRijOaRylPnZLo2TMdALZBuzpvdD50BvEF01LTYD0qvhzZOXZ/6yUyLdXOhS5NjPWRH4Y3aNSSV/vF
xBxzzMsGjTmDISAAn8pCg4uFugZOLUhfwoh7p7mFqc10k+qGoVVTJUmmZIwc4AhIh1yHVJBw7RosFZ1Q
KUBPtjDHDyILoGkbBBULVSyTykawrGjUddHEd4RDddMNsOaputM6dZhiVJF64R6VLjDR7RGiwfsC3BfQ
pgWYdTdxvIezyeExsj5QgG1occ3uTHNxVk0QhTY/KEkrTvPQyK99sCfHC7K3Qxj1HngKat+urmp6fcsn
wGZP5htS98PvXDTGLkGNXRNznOHqfTcdxksAjMg9KM2ROgTaA2TmMY/I3DWQDhWmUFImlO5DTRgmHoEr
ni/K1pH01DvwAqf+4ZAIhdeQ6/pbpgr3E7/L1GETbJHGpRXl9oL+jPIbWCkiMRGbXrQnY2056otHkN2n
UNZ4SCFViE1aEaQqgpDgGmOCQByYBU9NUcKcI2bNtNAWOkww/1WoaawpXtkSVARzU0vW6nqGnaCCVmhy
Vjgky+lLjTRNu5QkrvlGw1qC8YdnDi9/ueGFGQEKMrwww9ONqW1gSUVkrYyRKTSxp5hOxjxrtOVLjbbk
PDNnY55V1y6UCtn7kvI88F2JiGqe3RBLqdGl1pUdAehmLMP8d748Z0Zp+hIzYpyAsZtlTc7Oknrhn5oN
CycEMyprDoI66vliHkg8aD2D+mCyk8mnZ01rl7rbswYtgukzY19hWfFIQ5BgATT0oXBnb1Cat1gQYRYk
nmOyQ0HhtsgEDsaimu5R9HTaIj7Mrlbk1NIP1OQD4UTRx1Vp3anepDs8bRkIzHA1SQz6JkVInTY8THP2
qAhabB5hT9HQJPdl5mMNlINaGIk53YkLMw0CcPMXuKf8uTMJGTZGOWjhsmRh8KaueqoF1eysGdRhtMci
I5DwudP3X2j6EbuWevmJtW3htDVVdalF2VXX3dtespCqCEL2gfaFdgGLq0H0LB0TcGP3AIp+bYoCuL0N
qpvo07Qbc3t6BLbwZcDmqoJrU2c9BUauBbi4rSLuzQCXDtVNCd1AezTR+GUm6qedZ+QOK+T+E2d8ELrk
nj/NjYGwdyqg4jC4XQI1hJoW6YwqjD3ZI31U7yV7NPdLj/Y8ju6qmvRgghd6vMucRhd9aMXjxrVdAeL3
7vajsHtElfu1TElZyzD7pnd31/vCGg7uqeRsb1ZNqtCf1eFaLYQNd4zizpOeqa+tojQSafjUT7AbhTvt
vUKjPikMNLBM/S/f0gFHLbxIOW6pfubf7DnPjLSWsZb0CFOHzy7WazSUm6qLrO6OtO8y+S0PMkMHTHXW
05iRUW3Fqu2KxEh36ELTK4ICbIoTyKibKCoyQTCcN+hl6c+ueJUBHQvTqQ+ohoX6WotgRBKE2PtRXy6j
gThImUi7atKcTxQ/B7g4nHPOW6A3PQ4nZihCvigrPVXMly45svqptX2cI1LqrEODH7AOWrMcx4s+tGJg
DSSD6ditrD/Ga6MJczmsUce1xTATPYhvjIhnAnF0eQThTQd3T4foXqJsc5+pQjQ1t5ev5F93dmCpGhAc
pfo21J2k5s8ULqnaA7uQmR5m2uz6lva97YPVFJXrF/FxJR/9o9s31RZlzyY6qnWEsTjfcevspVjVNycx
4onwoJImMkN9DR5EUitEKxqmiGfkkp3y0tgkgY1GRiZBNbocTprOHNstrVUDEJFrQLb4TJtAtAuzMGqC
LQQQaoge+Bd4SNKVSj3CvYa7M56hNE9HOPwx+oBOIRGpl7BdhAmSP1SxI02YpQunvCZYqemjWQsOWSE9
1WuMoGP0om1VX5ikhgpxRl9yb2oGAoSzHkHV7QvQa0J6MBmMCCQtJN0qzF0NzajT9G+eXiFUq9RQxJq5
IsL/BY6yfEqn1wk3tWqBoyeqviZbcaZLCxBY85o4pH7RfDbqIeXU7YrUgFRPR3hctFmPc83n1kl/Y2bg
oGqHS/KtCR1wieQ7KFXj6PHtSbOQSFKptxygPi6GpZQHnuR+1bMVop+Pl73m2qc17HLUPsfaae5ngtP6
kXBZU6W2ZigTpPNEAUulERRd+Ns6TWG2wDmY7DJdpfR4U2VV6nVn1AlH7SJ+GlqtUL2tWdWomtVVOD7h
s9+fKOo2tXO2UNah5t8rFMGZv4fJ/Wazc2AYL/iNh0WZj251ZqBRMCYcPBpzuDgF3bSLrrpBbs19cus3
U0ply28H2t2Lxdqr3uhV+vzeUuvsAB5xS1SkRF9PH6T60noUq5anOGEkuEu/URauqJUseNpQ83qtvAXV
Bsuobz4odaHHCdFjqg60uFAH2mqK65o/Ln9zHDFdV9nFEDPt484uRBSzcZKXniQc+rA5QjSWc3T35ZRe
FfbVQs485OZVn3V9v1Ud1zeBXH7tkHP7mbpHOHcBps9oewCK8ppBEUJVaoBo741wvGtClfVN1TcczLNX
QX2V86zjOaWpuZulvQkeqY9IZoVHQ+p3cDKpplKSY3VlNP/g3UlzUKldPcHFtJCtiIFlmfFSZIIO9Fi3
FLIqMWBMO4GQ2ZLoTUd+oL1W6msF6PPptunEy0zTvnZ39UnDo0E1VZ2g9fcPIGb/EiDm9xDbEWV4GPjr
2pmvBzH3miGWpp17LhHtmnvu5uxoFUzXKoLEm4+G7gjZMPiKy+oBBP2/PoN4L5I/NB5fl2jb+vbhrSMI
hn0C+G8dI//ngmCrvuoaFC+d2B9kYXhMRneu7v4qXh8AfGNrEf1C7R9cG1SNQu8GStYhIcsnKbzv2lqL
gBdmBp+0/uiag6pW1lGv4M+ERy32ujBWZGHUDt0jGK4RtF4VS/QhzkpDkbCKLA2pHTLblWV5TvWlYn4l
jSqkykAl3sjGvgLctrA9O11YLfqBNGz1c46glD8bSnn2aGOQ1o/Zy91SvLqbacSup44El0lTQ9LESHBV
MCgsXwPImmlr6MauB7atfuQfAW9vGeiWE3pN0IIaTnTpStA3neU29YmjTVWqSQ//4JiQiVzHhIjA1mas
jW6PRr7fRmMRSc0NH2oJs7GkGrUXA930oFT0LTkFArYqjBhwqBl3cWsJsXrSKUMYr81MbiN7NsOPFJgL
I6K1H3SjSQ/498L6CihmLJ0zGQVi+5EwlgK/oRIMmBE14VMt+cJYUg2yigNLDbE1E2UhphFKz0DcMpr2
12jUndYqru6zpeak8wygJJnTX+oeobajI18N596gsI478NQVePfjLz+v+P3hw48ff/fbdx/Pf/jd8P8C
AAD//8RMM0HP9QAA
`,
},
"/fonts/glyphicons-halflings-regular.ttf": {
local: "web/static/fonts/glyphicons-halflings-regular.ttf",
size: 41280,
modtime: 0,
compressed: `
H4sIAAAJbogA/8z9CXwb1bU4js+dGWm0WdJIGq3WbklepViyrTheYpx9D1kd1oQobGExS8MWAqShQNoE
QyGUQktKC6SsIyUtbb/h+1paeKKtuoa08F5p0oVHy/JayFuaxJP/OXdGtmwn0L73/fw/PycazZ0ZzZxz
7rnnnnPuOWcYwjCMCBuesc+du2rJ5atf/gvDkHo4Wj9v9py5xABnGDId2pFlKzPZS55atAPaQ9Bev/HK
DcML/2L8IrS/xTDstRu3XB9hGrm74GatcN5w8fAlV648kHkK2h1wftMlG64bhuN2htE/iucvueKmi0Oh
XBTaX2OYe3ov3bShwF40pDDMvUfgfNelcMCU5W0MM+KFdsOlV15/4/e+J+6Gdi/c79gVV2/c0HHvmqUM
8/lpCMOVG24cZnmyl2EeeAfhvWrDlZsOvfDw+wzzoIFhuK3DV193/bfnPnkZw3wBcDDsGL5207D8YYuL
Yb4C55n0DZsuunjohRVvQxvx1cMHqcP8uO/xn+L3Ty3uD9VvY5qescIHIQNgoE2YN+HD0xY8jr+DjDA6
hucs7M+gfY76Tb7GZNlv4U90zOn/Vi9au5QZYOp+x3DfPQW00nmZrVVItL8IbXHap149R66AFqFtniyH
7+VwFx1Sm6mDX7QweyOmSCZyYeTZmCNxMklSxpTtCHfEeMR3pOlI95EFR9YdWX/ksiM3HbnnyENHjUd9
R5uOdh+de3TB0XVHLzt609F7jj549OHfMadOUQjwjs1wR2bKHckR3RH7kciRaUcGjiyHO150ZPjI7UdG
jpKj9qORo9OODhydf3T50fVHh4/efnTk6EP0juTUf5z6/ak3T118RPjt73974LeXvsW96X/T/YbtDVPE
F/FGHBFLRB9hwsfDx8Ifhd8P/1v4aPjG8LXhK8IXh9eHLwyvC68MLwnPC58VHgi9OYFS/4/+iH68Awj2
Ljv5ArUr1D/+TF37/5E//eQDrr/7p/cyjex/y0yrzDgXyYuXD8kLt6yTmfhMr6xvGepbR4/dui5ySCbO
tLdNJq2RN2VLS5vMti5aMTQnvi7aJnOtl3kj8sDyoag8sK5N5lvxp9F49Oah3wQq6wJw3dBo4P11gXhU
1rUMyXO3rKMn1q2D++la6847p03WtxZj5G54euTu884LyAzcRmgtNtBDA2OHDK0OMdKdaZONrZFb8SE/
gNtEZC6xIB6R+eRCmVk+tHPTzg0R3JkeiEbXBXbS1gq1hQ80qdDZA/Yo3NHcGvkFRcfSGsnIQst5Q5HI
vPjcDZdHhiKFi9Rb4HV1+GR4dGRnZN7OuRviOyM74/Rxcby5PABXAn54QB7YhA34jZU+qe+wNxoNRA7v
BDLAjxYANKs12KL0MltrPHJYe3g8MrRoZSAqk3VDOwGhBfGd8cjOBTvjG/AH6k/wq022Yzc4AG4REcAd
xyQEduJXfMPl62sxwZ86WwGJnXch2RYW4jsFObJ8qDfwXTjjat3PDJCBwUGy6Ft2ZiNDt3jx6iHcrhiK
XwTQxwcD8EXig0D5gRVDJZAbszYOlkiEwJcc2Sj7NtVXnyW1ynAU6AKbNuQ2kKkgHWww2hqhcSkXgUEm
MOkiYTK9JYFn388W9bp/7S1xLOwyRQ4P6/BwSdBzJ3tLBI/nxKiYyInxRjKgvPOXv3CRk0caQRITpsAU
+MX8YsbDNDAyk5HrcjKpyOYskb0Z2XlY1mVlR0UWskUfaWGmtTs7o6m8R8yJeY8QlaIeISXGRSGVLxDu
xV0vluFDOGW0unts0gFllF6miRH6XDOzkCmZGKYFHy7Qh+uyJcKYWvYPEM7YQmRLRjYdltmsbKzIfLZk
NOEpo2BsKZmMuGtijC3FOgqdj0TF6j8yQlrJiDKsHBrfU4ZhNkKcdfzn+OeZPLOFkbMZubFSaszirRrT
RgpHlMIRzsq6jFyfk/UV2Z+VpYxsrpQkM14o2RGy6Rk5TyGLVYrBcBa+7cU20iLbs3K6ItuyxW7SUozl
RYcsdMttYskcyXZ3dyMV87mOfDyf68p35bIetyfekWbjMSsrRIWoXoJNiM9l+9nOnF7Qx2OpNEkVCtfo
3izclVj0qQMfDvfqv5FbvDDk7Z4900luKSiH9GQPbI3TumflpODCxbnnwxs2P1W5oWHQQo4VMp2Fp87Z
9dIll+eHpvlcref0F9JdhYXXD7bY/NPWdj57+ae+nH7mRspnZTLCL2YPAn85KC9wFSLzmaJO7Xkgapnb
cXIrklPly5q/dmif+pC08i/zZzESE2ZkLiNbK9BnRHZnih64RdHIiY6iWezuntbOudy5aLarIxmPCWkS
j+kll8dKrNcsYz+48emnb0y3tn7jqi/8mh1cTT5Yfu1zHz5r3XDDrx72WaybkW3gU+Bl4B0exoEJZmGm
k3jyJCEaddDrZcDixHLSqhxih9gh6P3WAh5Uhsu0dWz0CfZcxUJaR/fBfbhTH536iH+JfwlGlx61BCEB
7E3gk+/qyJBkTKgjS357zmH24sNrDm+sq3vY1mCrG/7t2eqB8+pS1ofr6qq0AJhkxsjkmJIe+VmoyBwM
I1NGNhwGUpY4A3IOpwPGNXC4a9AD45opccUoEWE4dUZFXkbgTh4BUsqjb46+WSiwSby/lTHAeHkBJAeT
DJF8P+kUE2JSsBKP1upICjorkeCYnm+4e9lZgPzAwmVrHY67l81daTWN2k1WaH/2qia/tL6ZveCR0f+y
e/zXduWbfJ6z89w1JjP3Pc5pGl0men04s3tOvcf/gH+YcTIBZh1TsiJGjozsqcgBlTHqMzI5LEsVWbKj
bJB1MAaA3X2S6NjPsXZHg6db1onA+UzRYYUhYOyWPaJs75YDjv2EEXRwflq7ww4ISS6BuF02oo+lCLA7
a3dHuuzJiIfUA6vVLyWtgnClwWVQDt2wu/zpl4nje99TPiDv4znlD+XdNyiH4OSVgkBal7JXKH95+Xtw
hcqfBWaIf4GfzfiAI4nsz8jMYeRJa6UYUFm6o58NEQ9sWMll5YQ0X5h+zg033NQ67ZYbPzXUNeumHfv6
+5/acdMszj6wZWUbv2D2nPl828otA9033X5bafXq0m233wS0OvUtZh7/IPS9ibEAS0WdOWeUOI3EyeXn
k9/ez95Pfq1sv0+5Xdl+/wMsF6Gi6M/KTOJU3if/BN+UD2vv4QZ9Wq4D8UvFEA9M5MkUvRTkCXd3eoS8
J5WPp4Spz5n1gwXf/f7C7727ZOlpnshev/t3n9v1x8/98pcTeNcJ47iTdMaSfaSjK+sOEpc+LhGJjCRm
yv8tz0yQkXsJKTyYK2+V5a3l3IMF5dS9qAWrv19M5yUzzFROmE0CIAPiTAo07gyMCJkpMchBfKXojYCg
FDJyLCcbKnJDVjZn5GROtlTkxqxsy8jNOdlekVuzsjMjp3OyqyJPyyL+oWwOyUHkDtqPfGW/wWJ3NXiy
Mm9HEbXfWCdK2PRW5HrYqlwZzMqRyv6GxtZpeCpiL0bhykRTWzs2uUqxEwWTxQyCyR/o7pZtYrE+iAKq
nc6XnfHOSR+UgjBKo+Q053j5xIHC2B+Im9F99HNw/CC/uPYSlKUgnE5uHTvCaPJNnRttQMMMM5MZZEp1
SL3WHKCNJAtm5F5Kmg7gjQFKDzudH72wtRcjgDgQrakiT88Wz6J8A/KhCySuWxKhT6OxpI9MbJNPOB8E
LpCCQUkZxu34Pjt0pjPZmsPslTWN0ZfOdIYB6TkZ92XMhczVzG2gc29RqVDsvSKHdCh2FLJIieLirTmk
RXH29dBuyxTP+xy0GyrFVTuyQJ0RpE7RjkxnBOZrzFIKTQNJNbAc9rsrxflD+G0vrodjw7fD/mWV4o13
Z7PF+yjlcCz0EHU0tJBYUuz8+Db5hPP/2+uDUhkJdoYNGfnfnc+OtcgTp9s9+R//2wtUw4vKi9o+XqPx
eC/l8Q46/Bfn5PqKPBt7VT4P+1ReBT26fkKPes7Qo8UNp+89lxuaXXA4CU29NPk89gbyPZV9UZX6H9f+
ZGqzB7ExOhu3p9+vpfn4r/8BiqIMDzIx/kO+GR0qMDmkSCpIvsplD41+5SfkVeU8rgP2forXXc5czs/l
54KcxuvyRuIxEsFILid+5e1DxE/8h5S36Qa++ie2D+E1aOLX6gYp5sUJ2gGoBfGcHKzI0WypPohqTn0S
NJ5gPe4Gw6Bfa/pDY43+kASBFcrKiYocyZYSSbw0EYdfJRO4m6yHXyXGtIwm6OkkaBkl1g0iu1tOiLKj
W/aB1uGx+2u0Do8DtA57dzEI2sd+Rid58VxALLl8pLv7E3QPDuR5TspJcSne+bF6yNxCGUT9J2gjyjq8
CKV7lXZfpLQLM+efTrOKTNWsoppm9Q3UrOqDH6NbfQN1q/rQJ2pXHExjH48Zag3kAw2xXTcprwtuuMpQ
RexlYn8ZEKO6IuPhHwb9IQCz/RwGDUcToNFK5yWhUhKoMSeAMScL9qIFMHJWShYnHrSAHYUmU9EiQCd5
vPVxAJxqZo68BNqsC4Dt7EimOt0O0NDYWJol6gBGfZcOYM8vnrpk63Fy0fGtlzz1i3Mfef291x85l/wm
KBVwdBRwgnqRNPY/mS/fWDx+vHhjOf9kv/LrF7fAVXAxsYzPWTDvFhgCcqk4psdMY0o8zjgGSy5HZHtG
5hEfRMIASJjBTFbRsVWKIpU2ebCwCRjH1X8FMEZay9D1ZYIGCTmmWNDyBkVhOdLNzwT4PfweZh5zNnMR
g0ywvCIvyshdQL0VlHrzK/J8e3EJPAMmtJVAp/kM2lB9wPZLxP02KdeNrNDgKPoyYFgWlwPLFwVQYORF
4n4umpqDZ7scxZazkOGdrjDrDhPB7cl73LCby85ku2YST1c+le+C3c6ODJvMkHwyJaSSsBuP2Vi9jaT0
gkfQw64OlULJpY8l/fqHWKuXW97We6eurV2XbIwFMkl9OqP7zPRpyzmvjXxBp/sCsXu45a29n9G1TdOr
V+iyrbo7e9LLOV8d+5CeXLKttA3+s+uiTUl9e6vuMz3pszk/nNLpHmLr/NzZrX2f0bW244/r25L6XLPu
MzMyZ3M+q3p7q487OzPjM7pMWp+c5hvatm1o3bZtIAsFpnDqFC/rXKD3j2ugeeYephTFsdYA1v60jixM
FalMqTnblQN1IVABFROVCmsrHM9kqN0K5r3/MM46DfZiAsdhVm5EzbSUaKQSigGGbrSjPJKngZZqL7bD
XltW7qjIddlSRzte1OGEizrsqGeCUESHAHWi4CQyNpPUTCdOUDvVPWQlJ3xQ3XRq+wWbiTh7mkhrUw9x
mmxW84m3zdYCt6OnaXR2U0+ByhjkM1Xa8CRrshWaenqa4HdZs9V68ipkvqbe3ib24Ohs9iBYxicOqLua
n4khOon/DdggrUzJSPV14HvQz42HUVc3UD0bqQRMX9QZQPAQOliNJF51urAj7I6ycgj/sevYHaNbR/eh
HGGHkN9RAL4DcsLKiEyMKYGx1EKQ60Ha6SslPUGC6Q0gEZzqaKI66RhFiEgKVjP5FzJiNZ983mxlh0ir
j99mtiqW0fMBPc6BuKOM5Rmef5Z/FsawE3hgO4M2uK0iu1DIljwufIxHgn5xYpdTwxAgqINesxddgOD4
RT64yGPHwQ3jHo3GoqsO5JSJszphZBVFDzSMvA1tXaboskFLYOrseMqJp/REtGiC2NEQ4R12lo80ODQB
7EQJIfF7iYPMJo69e5UPlIPKB+6PyJqPPlKengci45u1J/buZS9Unv4IT48qQNJD1FZgTz3KMDoX0BTl
VVqzsoQcYgwWlS1DHQ826nggRmRhlGOatIqTHAf/SJSLc84cFy+QF34uPe76GXlh9O2mDxvbjwSe5mV0
oJxYTueCY6rfh9V0dPWZC5mSGZ+pPg1MEJIdF5UlXsBH84wq+uuAjiYqK4sCD5KKNYKkqhNBvlKvGHpB
0E8JEFHbi/xZeQvlp/IW7B194QXqxwMRin68coGu8xCw718AKDxMiNmoaZBOOpZ10LFh2rFiRRbViRSU
yXp7UYI9UBwjOKWKouNAHe/wUN2gXpRD3bLkOGDROd1B2qceJ8y5xGBk/NqM2tHPZkMsnYpItSc5Kuw5
cuHet469tfdC9eu8D8mqDz9Unl2+p7znOKk5AV8sqzz7IZ5X6HAFpp3Is35mQ5VnNRYN1LAoYgI2rneM
L+sRE+DLA8iXLsTEK8pStwxHkDndFBOnDTHRCwzVg07PklwABnJcPBNPLjt+fM+ZuVK5SMWFMgk75lNA
fJo0aQI8YqeKPQsouTLYE2B8G0GV44mV6mSdojMaqMrCnCeaz3HRMhf5ZwKybrvZWi5nSWu2vGH0cR/5
F5RcSgIGPnkbptljE2goMV5mbs24Rxr6KA0BBssY5fxAOdEChOGNJs7tHRvGlFBuzxRCOTV9JAIjW3cm
Mn1EZpCmyWQiB6DHn30Gzu8k95WBc6s6Uz2zkkE3M/StmJF9AGeQwglw2+xFk8qrIYDThHDpeKfL48Mu
NopFyY1zvog9TxijS8LDPlGmQLtCLDqQ4y59JGlHJ7MQFQWY0a3EoylJe44rXwaN6O6r7icj933pVdCI
2J+8p6pFW0BVAo3qbDxz87mPMKqOx1B47UyUuZkpidifML7clZI7jGPc7YcxXofjrlSnwwN1DLrIY6pz
AjpeZVx/pRgHZOyoxoiObgT4RUFnNoFuEkX4/Y6i0YBoucMwvUSpeDDidTp0oqsuO8AmL0bzSXQbc2JU
AEWmqzMHYzIeSyF2W1790n3K8OeH7yoeX0BG6Pce9TA7hIrfzXh2+fEiTk34TY8xMOsVNJ49nR9rOSMb
MrI3hyLOn8VFifocdlowi9IukkMxE80irzXkUHdPZKmJYzhcsthdqGyYKyWrww17qDCAtMOZDaf7BBga
qZqPEyb8PhKVEp3qR/UZcTtOHqk6iVAGjn/Q64RueXX6V/+P7iuMNWvkNepDIK892HcRVcdpgB47DL1S
0vmx03Qoqf12nOpkKwAcwINW0GFQAWKKEZzVeKvOT0cG+pR6xg3mXI03CZQbVT0H5WPLCtK6YgtVRE5u
Bc0FpDi1WwvsUFNPecWWLSvKoMDsg/PsH/dQTVzTFagfiIOx7FHnNVxJQG7iKnQ9AUgIctfZT0JsP8mL
VpLm9AKg3XvXjVuvvbzQ1HjLjpG7rj/HhfQjI73T6qIB3bKzybGz55gaG01zzkaycJqcegi4up05i7mE
KWWQOv05OVmRu2g/B4FMg5otg7NYDGjTUpFb7MUs7PVU5B570U7VhuIsYO1sC9DIYg7WU2mSzMDoFOxO
F4fcbYG5zoZyThyzYvpJJESk8XaajVlZySmqbgkkKLolEpPaVjModLv+QPR/2EV3N371rXfe+urGssWw
12ChG3ZofJ84QUqaSettP7/22p/fphxSW9fDD+B314++Tn6MFyoduK3Z1+R4mR/i3mF0oLMxYlQn6qIk
j+sjHrAKUmDmqlKflXftmlf9T0ZAZpeVZ2oOVe/FDdN72RgHQ9UE62GUb6K2CIJ3T+TBxhBSIGbH7n1w
ztWXz1qj3rW7864Xvn5n11U776/233f4i7j/ovcMMr103Qq9xCHt3ugbcqqCJwy944TZZr/d7VGnd8Kg
Amd1qvzsI9GEmCBjzwcrSQLD2ZNHy4io0JD7KSwXCLfcIJyt3z2iJ/cBXCePlMlrANjTd+av2nlfxfDQ
917aYxg0lH7/dskw5h+XQaqIwM0+gDNKbZKZzCyw/RYxywhRObw4bTYYI45Kqal9DsoMf6aUalmsGiil
RNsSPBbLFFk9HImDQp4FNIvW+dCKVoodC9DfuRyNlqIuhL7RSpHDVcmg6h2rQ9MmV5E7YWsvps0tcjN1
uQxkS2nqZ0nHjC0lYrbhUxL2Yh5+M3s+7PdUismF+G0vLgZKDmblZZVSd99clGVnw0XTgjAzuSSvr2Mm
qr75BEzojU3TcamzGAsAhZ2u6dROjYslfkYP+mxCjgGjzu3ryvf2DcyixG+PivFOdLfkOqPoTFeFI4EP
B0KRQ3WwE1RD6pHBi9SjIACi2FSv5kBcEhSh8CHH0O4mI4WCYqFaFhriKDxbVYtc9dHDfnl0H37hJVS2
ajK2FYQGriEexC3KU/Yg3oleVCjDXoF7B5mzjOJ4GC9CAc3tAOE7W/XjG8f6fep8MqxaPyXeVY+9W1cp
SsFslh6jmmsDXTRUPQwoWyxZVGtRHwQTxYyyBu0SL+yB5RpQPf7xCgrpoh0XMwR9d3cxANKaLmeg/x9N
SCBPCijmwZkGviX47tS+sU3RLo/NIuUy986J5bDHvXPSWz733NN+T9D1BFXXEzSPFk+1PFRmYIhTXc8h
AGswejPV9UQnzhxGwrg87my+qyOVjAkELNw32YNg0f06GFoZCuIGuuBfTDbQ9Szc71cFQ6EgbujYJ2D7
/EZ7rg/kt/pkT059uOzKVm07o7riR59/AJ7v9lGeC5CpECRy6D0loHBqgPxKfSBsWHMBj2TJywiS2ToJ
JBnbcLK69qjSxASjXLPKVL3XTKcSU0U2TTCnTQx6NAUDHTUCNgivo3TKiXnQ3UDPiYqFF7gvFUYdBfYD
nrxw0gssWKBdgGv3dL4swvMYwEDsSMI8rJfK5GXyclA6eUQKkoPKHH6bKxRy1cx7qJ97QLtZx5QSCCNY
SCZqM5q4amiFLGRLnGmCBdlIUQDuZLPIoAbVNyKorlmDGec/WyqmevKAwVCNh8EdlZywx6UJQiZw+X6C
ekOYuKnKUAZ1AFju5JHORnZ5/wWs3aT0m+zsYJJ1msgxk5NNsmbT6D4T9gGM2dnlMvvG1q3kHJzLTtzx
BZPVasLNhPiAIJNg2oAvrqbRCCDqmjJyG6hpGRhMBAM/AItwpRSm/slwBrAL24spOr0Xc4BKGLpB9nUX
W1KAUrQhEaGTRlsTtMKxOFqEclQspttBoDkdB8w+f2aaqhip0Q2qjzLNw4RtZW00yoFBF5pLH2Ndbox+
iKHy19PEvYPK0R7elsuvbC43rZiRNlv2gKZUGCmPjJT1/UP9/UMEqINXodJkCMzpbIGG5OppAlMYrhkh
Ebyo/wKq73XSvn0BbOIYfFTuq8vJoUqJtaB0J3I8U2zQtNBOsGRnkqgHukGKdiZTaQJzXRwMICuxEeL0
ODvJlU39Dc7zyF0r7C2d5CuxRkdIr1duO1+5xltvabbZyOZS+vpBd1frn99qWzs4SJqdaWsd9/ZJx7SA
xS8I5J/Ja59Tvg88h/6f7wPPRUBKtDObmFIEIYtW1G9C+6e5IrdnVEsXOIz2En8YrsHJKgrTFobXgHYd
OSwCs9JeSqShl9zQMU1R2KnvlptFaMrt6PwHBDtpcESaS3Xq0HuJPRHi4ZvEU2g3YBd1qjtx0FFZo7sh
TH5143c80ZjZAoTuaNny5LLyV9bdfusFj3128RX7Hlkn5Bq5nnpPsM4mzCPy5/Ln5xsNAmfJnbVl7qr7
lpQ3rDrnjsItS1ZsGBuX3NVU945oPUHoMi2IASuueqOI0sIRENS8swu7INUZ9Vg5G+H0bo9UXnKd4TlT
4zy9UUe+zkZnxHw63e2mafO6hVkZ7uzpDU7Cke5uQzyVsFhO/nNHr76bYU99Q/MLGWEMbGNKAdVeK7E6
N044FuB6C+V6O3C9CTgiSQWlquGi1QmjBXSAIPU1lLx0Icfrx4UcL13ICcDPvOrcZKvgmCmaQLYWddR2
CwfUNQmLKPPQBSkY/XlPXMwJTjEXhQb0RgsRPcBueRFMUk5atGjRrbfC5/ge9uCerF1KR2PlgjJcKMei
GZcIat9TT5088hS3EafZYEoysiefzxYKWW4Fa5RSQToHRU99k78X5B/iew8Dahfgy1aoiVqLrgngtqno
mg7/40gGQbfZzxqMBBUduxetIRBlVCywBsCfAZEth0WQ3X4qu2cSQNIjgOzjzoB69CkVu4KKuiszjnpa
suduVSnD/XQM9dEtiDq7s4q6Fi9Qu57KaAIIVznpNPCPtoMSvxgtsRMHcMtFcItzCOy/Q/e9dAVziK5g
7gPVBacVuuJS/ti9vwdWcVLb+QnnJ8I6vl8+43LrGDjk2NiuMny6o6eBN6l5GUG/aMvg4kAwg4EYfRm5
o4KxGFq8RR+ZuE7s7PzH2rWYFGrJXq7tj/KETlCXvAB49oqxXeWd0x39eLxUjFTsPgmvT1ofn7pefvre
OtP+OFJk4BN2ESXDaWMLMH5khYbfYhpfMJvG0JxHY2hW0fiCK2h8QSGLGG/N4RrO9SAmbkcdoWSPTMvS
aIOSt3E6Wj13/I8iQ04X+fG/o2V1kfPjN+hvmTCGP3H/H6D6yZF/pIf0px7R+kcPmqqfaWZmMAthZkSr
PUmj3dJA9UUZNDRV85zOILgcD1KUroP946JtQsDHpteefBLNGxw5OM5x5MCYb8V95dD4+FcsVahRFIBZ
iHJYsfCLT7z99wo7BpMM0EaRavhxFuDrYUoD1J+1KCMPHJZnVSi609rz/0vccOnZ6aHhaOQfw4+LFKJP
lct/rxw/8TY61djkrYsKizQfkcy9Q706bTRyEYYYWn9OqmKD9eWCudPI0HgMpsjXac5fdLlMDDMDy6U1
zH4Qbm0NjzrCrdwOMNed7E7a3gJbUlADd7mace4Byq7TRjdM99WlXBpHMcH3HKygK0Rb/sGIiqAPIBK7
ZUksOh1UcQHISnanhC6KgCi7uqcGzs0kuhRxilGHpsn7HfyQ0+dzntjn8Bf+izQvJIn3TnqvWDq8dOlw
K3fM4fc7Tlpg+/43P/0o6VeOkGPKT/DcUqDbA6c+4uv5lxgXaOl9GgZBFfYwhV2NAUFnrEFdsApIQLo6
HmENIqwC46V6hrMDrKlsiLio1p7mU0nkJWpi6B+46ec33/KzmxYs+D/d3abYxvOva5n58kOXb37oocN7
2D9t/dUd217/zwev/c/BQWNs89V7F312Dz3zkJbNpa2vScyC8dU1l7q65q5ZXXOqRPWgh03UQMQlCh2u
7BVdTlCUcBXttGtoOTE2celsyQlZnrxiZlS+fJxbAzB9iuG53+psjBv0PAbQ5vIhPWr1QprNh4gnn2ZT
ya6ZxEo+NfvK664LSQuWrV0yM7F02xeXXfv927dZzz3XLrjTJhtrNJ6XJ3su+NZXvvTK+nn3brnhuk99
Zs66hws9vP6Cb21bcYX/Ir17YeOCXR25q/aM2cuv8Jcy9UwU5sq1TMmP1LBVcFUAOyxFO0xdXUJquCvF
RqSGBdeBgyE0HWW3WAzHkCAGXCqWguqSBy/uj8TiCc0FCdzGe4QJik5eUlkvkScpI6CYIe8+Qa4Kf0d5
DQ1Ccqypp/zuE8qhJ94lB75CHr1W2Uz+ds010nnoaH/iXb3hO2AkWvDKW8tHn3j33cuz5NFr4Jr/vuaa
1fXj67kPwliqZ9LMfA0zGDaxjJyqyEZ1NNtlPWCZoVjWVdChyBRjdmBBKdgALFg0+mEsJbqLvB6+k2ND
26MX4uO4dFZRIf1cmEhGIsWsOkBGx965+r7JyDwVuuSSC0NBcqnysOCdP2vNrG4Vo+WRoSpGD3cCQiSa
7HAaCfk5mU36f81aPblZV47jtY/6AeI4/wc0vIxqjzVouIwv+1P/GV3hF0Jh9F9gVFUU+ssIiO53g82v
9lcxEq0RXmfoLSObIinArbVvsKR8dTJya0iAzd+jrLhfxclTrKI0p/x1xGmX8gc8f/bn1fhsNS7Jw8xh
Sg7Ewk2tR7BvjGqijuuwzGURNwNN1CnaXTAI9VSmuTEmqM4D45EVi4yFet6IBHOEkcThy0g64cuI8cwS
ekNB4Ka+T72h5e8rb8C2zJ5LGl9Vj7yq/Fo59GqZOlNfHbdvdwCNnUBldVXQnKNuP5W2AI80FsyhrmAQ
+KcqQGVVPTmmWOhOVtVylUXk304cIO8oC6uxjVVZj5K+JKGfvM6GEVle+hSxijVTXZKqPmX8SdqDaPTA
lIcpPu2B3rGHEubuMT3FpeVzYCyMkEFvF8a8qHe/m+3Ae7JJNjl+lxp/3GLkQqAuTZzBqyhflpkCt4PO
l2GGyU8KaJsc4FY+ffDuntNrb9qzC/xien8mP+6KUh2CtT/agxN6ze+Qzo1VnKmvQleLM/CNCBM0OcZ2
jP6YX4wIY4YKeWdKH9G1DJDsuSpz8lkUGr6x25BJ61mdeAy6Z1xpRVULnwCfb4ybnOSb2EnwPIwy4N6p
8h2F1arynYNmZJkrGt9FT/es1ton0edMeIa6/gg6Dd9IdRqHptOgQoOiAtl5sm4eJRPMNH7x6JvHx7Rw
YmM7gEbfZgTub/zXaYwuht6mvs0u/4vyGNnwF3btqPwXsgH2EDf7qV/wK/jr0ZpJGEmeeAQJDpINymN/
ZXslMiq/TC8dfcVNyGhRlXUcw/HP8c9Rf+4gjXywVjBlDaH2To188GmRD/sx8oH6LyQMk8W4h6lRDzmQ
E6hUxqU4t5c4Qc469+5V3lcOKu/fU6Z/NNxh7ODeveRsengCXDbQIcbjkhAuew1cdSpcGBtUNwEuiwnX
MxiYYniYNYtE3z0ZvGhndApYmHhxGqCm0ipLYdL0Ve+YE0ylkEDgiRY7ilEewaiTpjzck/fkU/mUkBI8
k4FY+fquXa/v3g3bQ7umwNJYPQPbiTCJE2Fy1MDkHIPJOg6TbQpMwFlCajI0m4mLPPLCexdPgWSH8i55
5Pn3LlbXU8fhmM70MldQSLorci/VBaJUve5Qe6+PjrVQRQ6pblmArx/gC+F8E+2A+SYtHjDyjTN6aDem
erVulKOi3IyRyiWLLY2KdodY1JMpOOSy6CHv182gcQUuvWDlPbl+vrMjzWGmpBP4cTKGr93L2wQ9q2ON
vJV3ck63waOzpYJeUtY52mL18fbZ7YHs2XOSd0/lV9bH6i0mQcexxGV3W+yE94T7kpypKTuUzS1u9Oq9
neuVdGECfXAlt6fK0RKdkB00iMddwVgjfty1W3RIVR52o3Y8Fd18FFc8MeD8dIi9T0bUhcepgN8DBlGh
DOdr1+G8YGlexpRc2jpcmCZEMZmS1RfN0SSqkiXeRtcBpqF0Lunqm9C/4ayUhFAK/RvtqLmCCrE/Fk9n
aPc5oCVL3UUGw3KC3TIRS6HGJnUdrzPXT/KdOSnEegABKxGkeGeapHKgjsPRrny8MwdNOAinctL3w3d9
tty1ZbPjRz/yvbiu/Lm7Q+u9Vy8qP9jxWtm3aWF50VXen5Nj5Vsf9JfLruWfnlO+eF/0lVcCD9264Erv
T34y7cvlhZd7f/wjzxXzyyq/1sbNhcdjvpxjJuBY3Jwm+dDww5gpGvPl8k8MjqNxAWcIjquJejhT6NeC
u+66svr/zOGb/1Jz1RQcfFNw8E/FITABB+8kHHwfgwNgQM4E/eZda3+8W3nyzBF+8V1rK7uVp6bAHNBg
dlP258eSQ1XJ7lNhpsmh1Vg7m4vCLLo1mK2B08TaeQiGeDlpeFdHagrU/ez0wvXPfFTZMPzMRz1T4+2u
K7D5/o9GP+z56JlhbS2GYTZSP4We8dOYO1yO1bSbIqsDxmaockwjmTF5eHQfGyev0GjmX075vRZnUv39
mK8Kc9BBS1J/T0NWW5UeZYBoufw/hjG6EMaoHvUkHfUCCTQGi6/gjYq8riasGgH5MXmZHFQOq+nMo/sw
pxDvcyl0wtvV++ir9yHj94FpQtZ3a4nboJ5cShoBlmZlZvU+VZr8M9XbMIsajGkE3crp597zb4/iVRfK
X9te3vH6c5cYiE3Fgm2Y/alaWaOHX4rV+CxrpmjTdDwPgX9O+IhRzx0kuVt58453d5PkHcrwHWREO8AZ
8Qg04X4xJs7v5nfT+zFg6EZFsHXVu8RICi9S3iD77iCp3cobd8hwRBnerrzBduLNUruUN7Zjbg2NqXyY
6tVxZhnV2iIVOU792cFMNbKC1DqFjKrV57NjdKWljo/G1SjQOMhpI05XQRHo2T3Zb0GcIYJqOq7XoZqO
YrsaWal+kTUz+LiryxXnZ/Be108l7zSQ3r8bPw9f7FzlF65g0EXSsB19paCVw6F0TTLNzDSmA2aYDqaU
QknensPFUZTaMBm308oMHbQyQx/A39EuOg6YLc7OGeqyu5iTojQ4BuDq6khmCGbZ22CowS6OKhuxEpdE
01mdMUwCodE2+RBGgY/gfHI14diYuS8VCf672+GUPogGU32mOMteXcBY8AIXczpe/xfYvfeHOmvEwXIR
1UIsELPT8GxqmjhS5/ZaRhzpZNHgMhFaNeDY+mmZf8I9ZZjb8YqlaW038tGpP/Mv0Nyh7HicXw60DQyB
LXZQbpI682mM8evX5V2slU+zcaHLne9K9GMQQSoZU9eqeeHXRgMnTU9nLtv0xXveubR14aXXfPrGW85b
advoSM3Kk+lzN2w+t8nNGwRXVIx/qa9PuXed+97vdfbeftH2nt7VubZQd+gl5cc/e2R1zqh32vK31a0c
3JeceeHtq7Iuoy7oy10XibzyYxwzVzMWfjb/b8x84DIiL6AcNaciz7EXe6ErFsKndw6wz4wuGnrjcHlg
JnSrwIYIwAq6TIggPny+i025Pe5UMpVm86DhhDgrL+hxn1ytM86dGx6cMb3RFrG6lq0RdWG3yWjjOIPV
1+Dtnr151oAt+cTX3FJqns2xbKUuV9d8ycK0jbXwBkLMdr8jOcMjWDtmkm8Phqbf1iaZEv19ocH3U8v3
FaILWp2uiM1jMBNe76rvm3XVrGfJyitbVz+mY4XoZ9540BC++MqnVlp6Ah2BRo/PzpvSS9ZE0ldhnvr3
mVv59/kcE2VmMvOYWQxOT00VeYYaTjo/I/celvOV4gIgQh5UvgGT0ec3NDV29tM4L6ZonCE6XmTEhnRn
/+A8KvSBLvpsSBcGsuhjaV0qH9JlgTJpPqUmG3V25PUetyePgQl9fn393GXXbfn8yOe3XLdsbr3eP/nA
I8KstnNX3Xz7DSvWtc43k3xwRneoXf5vOX3xne2XXZZY7HSxQ42mxrWr1s/LZOatX7W2EaNBJ7ZN6/su
mN7SmDuv51IrWZCYM8O3cB2mvK9esPa6rbMu865vaMBhCrRggBYy46YRDWcxX2FKtqolOpjBaFC5y/+d
vn//998wUotJtqWtsuW7uqKV/M0q131Xttn3m20WZ8t+O9366NZPtw10m8BtCc5iKZm4Hgy0btnXLfu7
5YZuOdEtm7uZF82WOrvP35BIa39kwASHrLYJB9NpecBPGJXWGD6dI3EkcN6BZNUIPJPQ0A+4Ip+ETmCx
Q/gxgs/v6008oLz6QGLFk9deljI98osXE5vvpUTNeEIzbFbSmHS3ZWLTnBmyoSU16450nd8vJM7Z9Plx
cou7Tyy/V9p0yU3TbY3K2127HE9dpVI0s7Z+RcA/+tR9tmQ2OdM7wN427f6uewdcjY2Wjs0XoWHCnfoy
CEcH1TccGIuepG6NFIAsoCUN6rMkBkhn/OpAQmdNBKTRba7prtFt/0FeIi8pT+GCz+zZ8yJ8JKaLnDhc
YH852lZAQYbVQarxWhKVu00wqjF4FLm5OSMnqJx1Y0WckptGSbq9xpZSwl3NUS22AKe7EzDcgyG0yYwh
2HUnqFO+s6Mrj94H6o8KEfQVpBIi9RlkSFzQY52FvKjTJwtuG9k8tHWIbLa5vaLycMHvvOCtC5z+gvKw
6CX6Jle7lcwhK/uHhvqV55T/Y213NbnqLH9T/naue8AlGpcuNYquAfe5RPibBWfjary3cVIVhjzMJmMx
p8xKZu3Y6nsnppmpsTAYBQSGPq6810al/4P7qi/kxAF+cVDag4GTe6Rg4WP/6NoT+0H1wqB0cmE1hB3m
m79rT6sGp7uRf54xMXbQpc+iepqXriw6adCNgZaX4LLjxhmhuQhumOrN4n6hzkHzKOxgpVmxE/sI1npA
LylwGZj6UZL3qG2YIIf+ipPeY6P7lGcId/OubyjPsE/uuvkxPPjXcpkdehU9qK+gynbz7gOjD+6+RT1Q
6y9zgC6p5gDbwZDMTfQyTVweI2I8lqxGi40+q/ysgNH0GBCmxs8jN/cwapwV7f8EcHMbs54phfH+xkrJ
SFM1jBjHJ2UxBqY5h2Z9C1AjTX2pSSyKgYU4OHvRQWiEsAdTHosZ4HIOVVyQPA6xGAoDuTwYHKfWhJJc
IEBAUe/XpzowecFl1YEor5ZjAhtVL65OdSZ6msKiGWxsaHtTSzZ96btf2rQk5dVjeSbSyg6Vj18TOc9n
Nrvq442taa9oOF5uXrHt8muW53LLr7l82wqyRg3kxSw/rDf0O+Zb/KXcW6g1cR50lIV+T9aTDb8b/b/k
kd+ju+z37Cyk9VzmTf7HPFPNjTeSuexsdvB3ymPKXi44+hI76/fohKO+oVMzmIJuC+j4BhhHjQzq1JoT
RqCqNXpgeEFV0dUdK05hNAPSAxoUfNCxLr5KWkjrj8gdvzp5hDzwK3IrtlvK7EESUP5ISxFhXtuw8kcS
QHUeYHRAnz0NfZYFaEsx7C9fTm4F2tvlpBodjIsvfAXZBGUTqEgNGL2IIYv16uoFKEtFTz2A1EZ7JZkH
3gGdA32f6PnkrGwLoTMq7SH6HcfpFS+LxpIph85m9XG3J3UB8QIcjF2vsYaQIxxsDiqHYJOlYTSeaaN3
Rdp03DNeh/NxUYLjJ2fydW46erPqNuSSguVmN1MTG4x5HLbaCDgetXG5LktxGctIxKorpDOnMX1UwkTp
spbwegyTV7kdakKrem81/hfvbYe+Gru3jcYP6tR7ixlk5Br7LEeiYFiMPyNKsNSScqjmSSe9mFtWHVro
aCAkDTy2ncrUqJrNRis7Uc8c1nBS3XK8kWp8JKcyQQ5+9uqrpJk0v/qqchg5XA0m1/gX/mfAntwO96yn
2UVoj5oytCTUeDgZXa6JosSJSuO3gG96U+VXr7xSEwMmA5XV/IIFaoS57K9gZYUgTVHSUe5xVWhaVqDq
uwtTK6gUpsXUwlhMDTO0jGFRG96TQ34CRI3c9Thx0QiEYbwqk056m3rCz+oaXOxeZ0L3rHJvQQ20p10G
G7Ka/b071eYZbaDeLDqvP6LF6ppBVuXB6qFp1wwmBMt6e7EZYMvStOlisx79nn5KYA6YdiaR0ryns5fr
1/WQhJiIO91W4Gf08KdYWs5Gk5ux5Kasz8dbY373a4RleZ3Al9mvjp6fzLAmi03HrXQF+Tz3TlBC5sWC
AVlvtq7uOCtI7ujq46BPm3iB07Hk+Mnny8p7FjOpl8jZyu+4FdTX/zyNa2GZhUD/i4H+LTDPdmpZRDka
0RrOoUz1ZktNNKa6KYF5cR0ZtfRQUw6wam1X1/C7ekjeCXZBKkkXLAS9FEIbeswBCqigIacLoeGpjy0M
uByfmmm7eaVD73Bd4ILtypttM7eIroDfYQgVLn9s2a1/nTHD4SdPWabPnW6edgW5QAo+R+Yt2eaKOP2S
s4E4b1uifPs5wLxR4MxBydHkcglN/9re19dOS31KoBM9yj+K+hYtNYX/Uujtzgvo8E55BI/0p6VH2h55
pO3I0j8fOPDn6v6f9pOX6Nd+evrR1qNL/3TgwJ+WHm19VJ2jC1peRIxJw/xH15UbD+OaOSaquBuB9VzV
rAXi6iG4IgaWthr4MhbvYmNBRxFnkpwkRCUunsLFy0LfVtvxdOKDYF9K+VZ9XyobmGZdf5+rsKcAhvPL
xw/fjWWZPlpU6CZD4ZZC69lbhD2tZzfWv/oDf0K5h9zw+qEXjt6q3FNgmNoYExXOYaZUj72aoN5eJofF
AGDWFDDlGYtdmMbWx6G7Yf7kaU6GHFfLm6gZu1grQFSxTMZFR8nQ2IoucDVft8kht8CskkYR3kw9STkx
L3b0EOQGj1MbgGPhYxk2mQ/DEExFO7m4EIeR9km4F1Ckje67lYwAAZR9kwlw6HVAntxAxyXMfwWdxK+m
uJ/F3MSgK7WBlihpohHaLkS71E7z5NtpqufgaXFvU4Nr22hEbVsvSBdMkmsD5A9YxIBrJjUKAw2Achwo
IMre7qKrHSjj6T2LepfzIiUCDPcEjOgwoSlZ0eqMRmipBE/USac5GsQdbWYx/qUTLN+UzlAu1Fut5HKr
WbRcaTWvJunVm69ctXm7ELApzwhPgg2Q+LQ+YPuR3eGwK3li5o2cwPOszvT5NcpztILXIrZOTJiMb+st
w1aXw3rT4pGlynPu1OOBdWSl1BiSXEFCWE7HWQzWuhdXvqfJtE3AN2uYEF1DuYlWRFEjRWG+no75FfKM
bGk6FQfTu5F2fXQqwVwEWgQh3KrmIiDjAKFddpSAcq+6wJIMY0qhpZ5vorQLNtCACzksykx3kZuOmSOp
Vko7FoSgTiUFpgDrQmw1iinFxWOpHMrwaF5MCJjoJlh1zQSVzJy46QoklNl6ZZ3dbCVXCq7oswblGXtA
v33zKtNbtoD+0ySxWfn62vtMOqIDghl5M1EauD+V2Vkji8lNdrtUd41F/zZflxJHP6z7SqNEVhaaXMpz
68h/vr/yW2ab2cjhSgtRLEhhdaxtQJ1VZwWLpYuZARZKKY9jbTqMqZ6MLB2W81jPrNQkURE6A8iTgwN2
1Euxnh/6XZpwkcXR1d1dtGZoXBeDGT4htrr+nUp0YjiUJKaSehvRYxGUfL+uF7MDunBQuT06UYhiDtkG
CjpbV/d4o6Q8t3Rk8U22hHXYfe7KF90+FfJsFpFapxgN7BD7U+VBvTP8pEDWIGkuX3XV5tXKL1ZZSN1V
bvOa+x11YzQiZXSl/RAJqbwJdktZW8NgGRP3vs4L83YHcMwcRu5Ua8B00yD1zqzcUim10BSclumAeTSL
yacpNSp9BmDeguuAFlDJi7YUYF5H1T99GEzOmSArJMw16SMJtUgkRgHYCOeMekSdlZqkyU6xF2aVVNJG
UJNn7e7huqTtJrJkZClZ6Wp6vG70IxgBpi++R/5rnfKsqzGb5QS91/2t+wH1BWH3VXXEvDpXSa+64qpV
l+NgImuEJ+utNmU79Lry5nZ9ve2HbofDTcpmwW7g6hz3s9dQxFnUx2GcPMNYYaaZoekrdqq/afFlNHxP
LR5qt6BD1qHW6GOcNCO8aHB1j+WEa8sGLKjggpFIugv3/ubmx8eWyt7bSxIsqE/kfuUqdvXNv9l74V7l
PW0B1ElMr71MkqT5FU1ffQZgssOsN12zzGAIulWY1GgGkxrKUHRh7SUHxnWVTIzYrWapo0tLpBBhVUkK
Erqz89FOgOim2ieXyf0IknJIBYgCrAL0hPLmy6+9MoVG/RqNxDHqqNF3jvHoOxGNWYutm1ppOgmj8BxF
s0utOjuBTglatYJMpRPMo+UqTDVEegItLzIyGaYlGkyu2k5T4xZrwJImgGXXwBJpcKAF50HG3j21KxNG
Wo/iNCDSLM7yaWAcRktS1a/5MTjtzN3MF5gvMlu1/myuyMsy8ucyRH6EgquK2CG1OsmjGAPGqB07JA5Y
rTpnNN7Qu3D1jTvuvOcB9A2YHAOmulhyWs85l2x5+ItUCC9rFh0vuqd19c6dv3otXvM5ccBoYlxDV9y5
a/cD1M3pnMgTTr1bcLmFLLqGPSE270YXnMtKUCixeRiO8B8rAutBGcTV1K40wf18Vz7EekIkDEo5nMn3
c/lkHpfK82ku1ZXCEQ9XpvQpKwxSLA8rwHOsOPjz7ixsXG4pzeVzlKQ3UeKpJP2bIaCPEYvba/Cucvd3
Bw1prrlNT3SXfioUi3PWdJ11rmjsi6TtWTtP9E08a/D5PU6nWW/XNwb0lkar1cnzCV5nErxuvd0QdniM
pqb4TIvZGO6ymIXMCpvTYWvx9xtsfTapn+OchGsnHOfnTKLZIcSMrfUNj5Mp44Csi95Qb5zrMzt5S8iQ
CfGOha55Rr3TZOGuCzb0h41EEOxmwprNcQ+bYesMnDvpCPqC9SG7nhDB5EwYDdwCydNisja7fEaHkzOa
PSkpIqR0dZyOb4i7LRxncehNBKglpGxmjxC75hpLg2CyiLx3NWH1vOXC6joZy7/A34lV4ntJngDpuzw6
Tx6U9BTRxzLExg5Fl67/2m5l9L4TdV+7Zfvos7YW29X3ttjZtZte6zpv0853tr1w3tzM6LN2+1Vq8fn1
wJvPanHhqm9uOYP1Bjoqcp5ax/UZrCsFhj4MJ9Avp1dwKkxU6PpP5+Fie/d4TctSJ7XeOtF6w8qIuCb0
P8jWIFhsihacmmjUnWkfrNBjikXNnS6XfzBu6H37dLvKw+gIZA8Wxus7oA2AGVtqvpa2pKpWTFbtaqbI
GDTDHScnHegngljg3jm5kNuhPF7mFxcwwVs5hAVgmFrbAu30BLOeenAIzWoN5lBT8MYwu13NAE1mZNth
OUarDtpiSEBQTQAMWsg7rtYkxMSwOE0MwyqEbBbnXaZohRlXDqvuQam2YupYigf12lG3NK0MW6Udae1p
Kjf1oJ8BCEf/qGFMRpp6VEJhSifNQ2cm2PW4LuoC7agamefI4So7rqqry60YmUBoLBJ6KLE+CpfHRVTh
jvLuMq66ql/sG1qrjEuqZfzAAS5Cv04+rJ5k31av0V6SwO/j99F4lzDY6IPMYuYXWsV2WwU95Qtzsq8i
z8liWnA3rUvQkS01Upo1nmVsqZbfWVITEgBTgpa4HjW3YKWNpGrq91fkfjtdN5lf2Z+fP8vQIrdTayNP
6+Bp0Q9LUQnGugImKy2rUewH6Vts6wX9Jw+mwzeMNiefUaOOQmpNLouo1sbZ39zW24+7jWoQjhwXi5ke
nHi85HRVftxaxbt4rIv6E3DPA7YIS71majslqMtUCTUhAGz0M9UFujKcjkQ87iXwiUTcnhVN4ZuJUW1Y
bWDnzM+RUCQdhlMRUjpD+aC71PN/aI1G0pHvRNp124jV6saG6T53sCGXW+GO4GOof/TXTA//HeCdZaBd
YbxDqoJWHEiTLui1CtaKwPoNTDGFMQczu+WIeMBs8wfakUKSo5jNUSNCD9NNLouzUlee4HprCheQBQL8
ptWvF7CwJBzWLsECPSGYeEDNDBP8BSqX8RhIWBLwT4tvmTtzenSgKdUokp1xry1wjsuYPiuu3CLMITe5
nJ5A0mZvGP1Nx4L8OUadbVpD0usi53X0be7yeS7cYhDOPTkqzGF1s6aL9ouXzVm5+ZzGeQpDDv/fpd0D
9fb25pZWvOtFmbUiG40r1wuzyKfcdk9DCu84ODPeP9DQIOH98p28+MhFm8792ylG6CWnZh04f+1nGqJ5
L9xM9S0uZ7r47/NDMOI6mT4GpXAb9eMIWYLkA61BrSbWrGoNWCyjuR5Lnws2NR6HywFRdapfBwhC3VGY
p4AVFdNsCmZhF07jbg+Ytv0sWq4xG6WTfvkrO+696JJ773g5vnbWvFfWi/aWa+cOzpu1Nv50X/+A+/wN
K66xDMzqX9+9cMaWa3Pzezdy9k+/cscdr3w6fc4V8+b+06c9nhl3zD1r7rwrzkkH1pzV7z7n6vOutvTP
Haqft2HlM88v36ji133qQ/4G/v8yXph7GKcLAIE+JrTofUrACvjQz4KengChQkC6wDeYEB00fgB6vHtw
1+xzzx8kgcHBXQbzZYeUW/7rQkc6mB88NLhLsFx2iNwJ7UwoGM8P7ho8/8IB5Y+DZMOFA7sH8SffGdxl
NOBv/vtCR9v0/CDhz4dfmeiv1ovtuWD88hY4Mjio/HFAletlrXYgVlAJYhw8XWn1UavaQT0yerXqC/QM
tB1qFgatoEFFTYaWfwk4QNnU69zqaxjyohrSUbWK81Ex6tAy88u9Fz/69BcLM9SllQIaqj/oW9PXt6bA
fVvKpkOhdFY6OQ8k9l/ZgyffwBN9TG0tde94VIwvg4XGUEwTXD9KJTvyXVkPcbsEVBwIyGiS+ekvQKU1
x202a7OVBOhXg/KnQz8jW392iHgaoGmzKW/b8Cuu/Idy6Bc/ZTiSYhxgVx5l2oFDZzEPMZjH2EzzG/uz
pTaeelzQk9BDnZCOSsnRg8ccTnQ5zKYFcmCuy1Zwgszai62kpcQ7ZmAoIBicrnA/3bMXB4CQIDrqMec+
UCnOwSJHGF3EdsutomzEhZA2aDZ1yz3iNxlrIDWDrvXLDowYRG846LhimsTTfGeHFinIe+IgFEQPZuLr
MV4Qk96drhAHXCZaiZMWfSWpz+rWLtQ72fTg0kx0aPuyQnLOit4W7jFD18KBWO/yfGPpkcIXVjf69tnF
Zle9wPct+PPTQytIcclGG1lG9FZfpnsof95ds4Sly3hn68zLBucvqlMqVsHZ2rup/7NPm5csFdc2bmZD
wVavpBfArHcYekZbHHcOzPNpa8IXcw/wzwFtdzE4C4HdACpKiK4m1tNCduZKyUlfCOK0ajQVDsvdtAZ9
Q7bkpdUPvSFjS0mg/i+BUTPKbarXAinpxcK37PRBSjGb+A1zONLcnsOG1SG3Am2b23FyQ+OSEYutverC
cg7pBbSkUiXeQV+hIYClD5TOSXE37Av9JNeFY9qDddGSNEIm1a/DGJTCk16Xychl2jY8eccPH569vCGx
ytUU9YT++opBkppmxC+Sop+LLu7NNi1LNXt+kU2t8XjzeskkWkTjNEsDO1Roz/t71lzQOFS6oWNRfVBq
7a5f2ZwrZLcHe7rMVhILfd7n4QZ53m8x38db9XVm0ZS/dx7IHLCu+ec1XSZcrf9pzcgWLCaCRCmawRiU
DWNFReOikcUtS9dQwF7WvukqIE2poMshJ7dyO3B1j9VkhJ6+QwGrXzyp1YTR50BIq7sGGljpqhQZHti7
jsbJU89cKUhXR4MeLIGGdZawF1laLEONq8MXDWBoXZ0HfmjSXvliohmFxQCWI7eDyurLZvc77JKBZso5
UTZhpY1qOJ5sEGFOAKPXQHMh5TpRFrFDVVs8SmtO40KPWgiJE9WiSHlQIdlXy7iGNFKg2TcbCxvR2V0g
WLIHCUGLvuJZtcTRMSxQVC5PoImV5hnGmL1qvGBRMGHlIeqTBFwN1O8CktNOnbz1VKS6pxJAAGRsEiAL
/CsiAax2uv4VjKhEcQJx9vtNZoOq4WWw8FYtAQSVALEwZhvwOsw2KNbb4ZwX8zBlXw01NOy5yVSpoQbS
oDBGko3j1FApwB4cp8rJrZiSQ3lwscYjDuCSzdX6pWgSoPsCCEGZolRnpWUMRRzYnowsoi9qv9MuGuir
XQT6qiQnjSPEikxmij2+pINWwDnAsJyeVomwYrarjqfjVvNnUMQ4XNwQ0dLSuBt5GfpM7dMqg4OGDohw
74CRgy+KKDMfh4NAoXcgJiUHra/twPIemCxWoTiY0Xe130l7p47iKVAcTCoOImVhioNzIg7uyTgkKPQq
g6ZqcaAliAsba3EoUODxH+VKnCIpX2p2jQk4E7FYwWgImKs5InZtqFLYbYdLgtmJUxIwKZadpFVt3SYj
bkH6qnCbDShOOb2axVIlOK0LVv3kpKo4oflgtLQthi7WEJ2W7R77/M/gNQO8NgovCBgQPiY6T5gcCK/J
/Qnw5iSuBuYxeMsqkFox3jODO1bzUc07bx7P3a2fmhrtGUuInhJxEktOzh/DhMbHP3j/q5jEWFZTGtXM
RTWPUT3x7lnVdMeepuo6WhWWGHoxJ0ETnwoNigwPiAWaaskU6524GztdyvhkCJ1t5IPHERbMtPzq+xOA
LJMlyn6E9Kvvq3mYtZAqluPHx9f9/sfwxsbhjf498HoCmM47BtEEeAvHj6vQfvD4ZGgLgMiS/7/TNsoh
rNV+nggrOXZcZQJEBHhkZg1phwFWypM6F80v9DO9zNh0TN0+mDngUCsdgzrgoVWNQZQK1IiqRm/Ioihz
aow9BkQ4O8eA66xCrb7qrVyFi4wgPAhXWXlceRxfAzYhEZfqeW+AoDvMf5mJYsSPVfUNwZRYT1ekMRjC
Xa8GQxSd6PG34UgFwoAtF0bLuIvJdYHhputy5LsyoImBrsUI+jcMHpJ+RKczGo1Wi5m1EavR4FF+Sb7I
soLRaDPxB5WPFtlZwaksdElmg62OvcwpioQnL1hsFqNd/0vl52ucY2OZ0s0LfTyTKXEa3QyYk42pRn4a
1wFi0TU2tM3qgC76OS0yUbaLcr1aeRS6NN8ZxURI6rHCqE9aPILSFPs306nmIpNj1vL55z/xLs5MVOgA
MW3fVun3bV5g2XfpooBK2ZqcgCDTwKzS4LTRSdUPgCVqbDOz6slJosoHJtk3vL5QONKAWi/oB3HMWsZs
FoMxFIvTo36RetvGkqxTguZ1UxN+8ymMV0zQrAFtNC29uZpR/eiWhYUn3iV/IRseJMceVJ5WWeKiBbc8
UGXQm5e++4SRrHlQsTyoPDYlt+Wcaj5OgL6kw1mb4aJm5WBJCbBEfWMequqL0F7kjSarzeFUMxk9AThC
9IKlzi5OzbKs5uiwWmGJM2XpeK7de+21e8+cpOPA09fWyDH0hdpB90trVbhFrYIDfcmjRJP4DKAv0LfT
OdCB7NZ8ilVZYGRpaX+Y5a1m3mu2n/SSl8jLGMmI1TKxuKzNpLzPRbAaMbLJ6JYsc5rnt0x6/t/3cDWE
0Djh6a2YpK7MIheMP509SJenjp14e8Kzb4NnY93NKu7qDK1TC1OCRmfJ4uNF+ngRHy9NwR3M0AkPb2dX
fVGZu4e9s+bh31N+yq56RJn70OiM7Nj7uxBv9Nl6xzCXKriAqFNrkbsp5m76aDc+2j8Zc08+xSWcmFla
C8CGQxuG2W9zxx889CD5SQ35//Wi1zecPELY//PvcEapOx0c6TPA4cz+HaA4PYIn7zHXgLL10EWvc/i0
v5GNNcQoHNpwiLwL8D3wPvvtE3/KqjLMg+/k4F8ATcqAeR48tf2MNPNJX8GKc2pSPeb8GImHf1hJKD9c
xu4dXU8e4+wnXiN25Qayt8I9PTq9KhMLFDfMwlzC4Oyhh47U047Ed25YsyW9SF8owUPLkK2+/w/kj56K
IBt1D9FUOptedJSMbo/qFVJFCr6HwEMzxlHHjSUR76B0HDi+HHLtGZ29ByPFCoU93DuuEBWCJ5/HBH1l
OMhdUqb810/r7zlpPN4Ag/ohQGijENrAqCjpbRPAC1Unaj2tVMwU9SACS2aPVyuMPwaUBNKPgpTIY3oU
Nw6Y8t6N25TPIGRzbrmRbLhFSRythfBN5f0bbwMAi3By/S1KA/d0uTpW9DorhdXDxOm7EhtqgEnUVFZQ
qSKkyBhNnDVpkRoYlzytHFZe1AhUePrp26r/x0FRPqIXUWKdeJ2evP3ruGVqa5M6KO2uoHMy0M5KaWdF
k0ZvR5Xbj+nIRd6QHSOfDSjMjC/k0AnSZkd+xuo/lix1AvqxRIkTU8thNi8igdVDpol0xhdyUjKrSjlH
o9pVOg8rFoqeugxdrqEx2BGA1TNUGNHyweUycxqczj0NTqfDZgL8tcDLQRHjPIqYFFIyW3zoH4JJcjIK
Wkepa/1GMo5CGah/FcWBrvYrh2pxuKpM+0bDAt+eWsWhTOPhjJRTJucOqBoimCtq/bYTy3lZq19HRo7T
2OFkgVatGHXQG+La0sVwv+c1m0qtjH0HrlQU3f4cljcpeurpyyKLZlsOXxdZtNg16gjVErpm6kpDL4Sb
zsKUSGYTWlU61Xh1Y2EDnrPZtTUgh0sS1YqNasonqBxF4gL6GZCwargt/KNuB/qhehE2ezDqX9UvaY3o
Ea1oNN0FA+1V9jt0RQ/jcg+/Stf3mOpaZzUve4aal01Tr5mqU8Vjxqlpv9HuMWD9Z1yrMVKN3WSmjsJ2
VTyK2puX1Y0wVs8i4cJsnfEa8uqbYAvZrPafFgyhhQLNJrrf4Ffe8yXYg7Q8NubAVLfDP1LOojUw/qkQ
7Ix69TrlOlqPb0XYKV4vzgkzzHht48VMDiNk6GqkJSfnKiXWbEV7tzFT8tYnMNM8he9KGA92bcRgV32E
FjWOdiLk9N0+Etag5TppkB+wD104xakH90McavU2AhRe5CPHfIvICI3kzfp8yvAin2LxLVKGq0emW5Jk
p7IlaZk+neiMkpW70e0j7HQ4rGwhO8cOn7wbD2trm6rt5GXq6bv800yWKXk1TcGdoT5zmurjcKEbKJNR
Cx857JSlfPVUixOnWEn5XALrNY/Z8FGPlAB0UlHSmZDUKHPQTg+h0TRSvgx0mbUF5Z5CNbkBEzBTl9Fj
qFCpV6sGzejs8kXK4cKYuT9SvuiicmF07lfv/Cr0i52x84/xj+E7gh0hzhPicjNJFyZ8AgHTJJXvJxg+
bCN2Eu6//+JLfv7QLeHwV0XB+V1nh33L7pObtoh662etbY7HuT+03HPvoYsvub8vSh53pK13W3lxy6aT
u7eI7a6XnXrx8XEfg1pneQA4W62vhO9xzdC4vbMyxUH6gpcA2pcZGGCN4v5kU3aAEg1DE/Kks6OfyyLz
Slp+FI1KcLlnkn7SR7oiHsmFFaJB40/z8ZiVtxHJSq5k3ckVwyuSbkLIlVYJhYwrFHT90BXcRfp30R29
v7D1zW3nPfmpwsxWozF7yJWzkkyWr4v4JFeg3mTKKj+35lxYDo99RvLxUT4m3e/13i/FYNcnlQ2+s9qb
pGhjY9RsGhu/GAfsG1t/JxMr90alRDSFNV0ltYo9/Yge+vaOU9w3b6Wv41Crzpf3HKdvpMY/Zbig+Ryq
zzDSijYN2gq7K0elnekw9SardarUiUB9g8hY4b9qiZvc2F4BQw1ohhD9KmgN1RyvhnCwB1WuoiYmvktK
q6mHtRQwa2y+5k+wj9k9rTX+BFH1J+D7+0Q7fQdAJN7YrFYjoG1/JNnYpCZ5Tiqjh0ttTnQe5tSq/roc
OhRBncA69PJW9iDmW47O3irTykmU4bEWFdBNe8sZOYZXKBbYYrbGPlWIUe93QXXo/T/CyfeP4USnDJUN
yMfjpL1o4IwYlanDj769YAwjfgI+AdDWZk/BpmEqNgkNm/0uqT44hst+l78+9jG9AwwMvUO07zP2CnWu
lFXzayIGFHIKPxUVE2B3w1iaCrt/KuyBcdg93nHYJbdW5+K0sOtEZxs5LcSalJ0IqvL4Hjy8Z89UnvFQ
rjlnHFIXXReKZ7FEY4K+6keDvbEGdtdYxD/mZkUrWLq8gVTf26Bhpr4H6LTw07dP4zp0C+FxWgcl7jTY
II23N3V1J7cTZ1fT9u3J0wwLXAdZtX3Nmu2rsGTW5PEQp/muk3uheWovtNSM8WhDasJ4iCUb/94xHqdr
O/GPG+H3FXD1oPyxIxz934x+Ai5q1lOKWTwFm8ap2DRp2Lzokvz1oXAsMYbPiy6vPxCKNCQ/HqM45rp6
PgGfwiYc2GdAZoTGf48hg/rwBHyCNH6thXlkHJ9QphhrAq0qTNmPmgvIjUnKhKns6aRZCBMIshoDqmmC
+32eegPNC/Pj+8aQH2Nj9d4xmqWpIjfZaVBWBiPsxwUiUwxgUhho0S7M0zg9eTzQ19o6HZAoSlcycKno
tCTaWNj4z3RMlqfIvzLta5wgqZCkS0iT684EMbdC9c0FqRfUR5csNTqEJr3WETEe89BRU8oF/GuyOjn6
sj9ZFL9htPEOT4Aygz+IWRZ1dsalvVZN6pbdjv16i0jOXF6nMx+ltkP0TM674LiSd+a3O9IJQY394/l9
Gq4R0An2VrGNZkAzwMDFQKZGACUmIRyB89lShKboREJgYaqvv5d9WcxG8WT/f6yde3SUxf3G51k292ST
wOZCArkBASFZ9/vufQNIIIkYUPnhT02oxQgREi4JQrhVa60Xmlq1FNGi4KWirVKlQcCitdSqbbG12qrF
u6fH4+H4hyftSW1PD8eT7cz7Pks2GHp6erqb2e+8szOfmXf22fedmczOmH1NC0cGYqu89pQ6e7DSLNJV
bDaWPZyVP95tV0hNNSukgvsol5RWml5nUUqlpM6iO1MpWhN2g8js3WPujueomonm+23aRJ3nrpr7TYcl
uVO+KzGU2Od+0d1o762w0Z7hZo8uD+SZmSqZzq+8q1O6WWYhXec3jxnO4E+N+ce02WulqMSs13+owjRV
x+sOyqEcs5tBfqX5/4jZ6PSwynZ2Xc4rPJyTX+TsDDjOvjLrS5u5UE+pybBnYRR5SzyA8x9sz3WXfoSd
N207cGCbr67uaM+ed1zzL0fc7nFjcMlGo4Onhp70XLP17fsm5nrWDt/D7SBTzs2M+Vcoe1i/4qRp+9kL
F1foMheWpTkDVnY5smAmZ40uhjN5QpciEw/i7uXbRxfDGbywy/Hg8PqyBzq3PfWlkph7BjhXd73uXygt
8Azd0K1GAGbRUARMxwzLdbdseOiA+dOJjD2xt75+rz16cPHw4eTvXbdrTsS9V99z1ARvcYn5ZUrAihRq
YCEXebLPYTrPoLjIzIbbHjvf3d0arTO5+MKt3VlWw/XtZXcv79vv8mS1drueD7UVFRS3dlcMv1ZfD6ui
u7W0smrVnGW3pLdft7/Pne92dXMNVdX4WGLojqvzZ/9dVereuH68npvlS9pEPLEv7cM0s3pnptO3ceZz
pZUmbrVf48Nvpn3ozPBKeTyEY2qGoaW4zqTfdYdJOWKh+w5o0anepdtvlnbVdqFjzXtMb09odg8khhxW
4m9kmnG6EidO4pjjRuWddJO1W8O4JSNpVBktaN2asY9p4BzbfvdZ6Uad1zlcknkiJSw0EpY4qm312GkT
e5k+Gbabx5vHiJ/k99N/YnSe5vfcdp7Pan+BmWN+Dpc8T3fKeRv3qnZdKcc1rIfkca8u70t0D41RL+az
+VjbFm3jZsxvpH50P3b0OZu1wIpS0mYy/BrtXNqlMTwtxSn3y04+jgQT76glKmZmSGK66rTnWY08Rx7v
2q/ulJCSs7TcaRMLHF9i3+inSamvSkP6Pf09VjP5XKUe/XdP+LEQS3ArDuA1DLvCrj2uV12D4+rGLR73
uXtjWme6J70mvSn944zFGQMZn2buzvJndWTtzs7Obsruzx7MuSJnZ86p3Lm5A3mT8rbkHfDEPR2e2z0f
5L9TsLigv+BkoaewtnD3eO/4jvHvTSiecJc317vC+1xRbdGu4hXF75UsLtlR8mlptPTm0uMT6ybumfhF
WWvZDWXPlJ0s+6TcW+4vv6R8R/kz5X8u/3ySZ9KySY9OGpxsTX6xoqDi9orPKlsqH658ofLjqvSqmVUt
VT1VO6uGqtdUv1wzv+bElBunHJzqnbpr6qlp3mn90/ZNe3raYO2y2v7a47WfTvdMXzP9tRnRGZ0zjp0X
Pu+tmT0zP5vVNevpWafrmur21B+vP+Vb5dvlO31+3F/qf0Zq5UZ5w8q0jgU6AjuDZcFHQu7QqtDxcHH4
qvCRSHakI/Jk5IvokuiRWGmsLXZv7K14aXx5fEf8ZENdQ1/DR7Pnze6a/cGcpjmPzy2Yu3Du83MHL/Bf
cP8817yOeUcaaxr7G/86/+b5/1zQv+AfTbObOpoetK9e7+s2pb1GjL2Cgkv3xMxC78nrWr56jte4CWZN
CrPLmtvsZLdGHzl+qBnqBvpdyqM/Zcc/zrS96XerqBqmP01tQ5j+dBXGQfozVTE+oT9L+0/Tn6Omugro
z9X+IP0TtL+N/hOq2JUswyvK79q1detW3+p12zd0da/s7dnkW9m7Xi1QvWqD1upG1a1Wqy7Vp1sJT2hn
Kb8SFdC+FfrdKtWqrlE92i7S8bdov4m/Vvl0SKNap59VKYRN9tG12l6r7Rb92qljXqjPvF1/Bxeqi3Su
l6pL1GU63kLNWqe/H+t06h6dfpNaquOvVpt1iMlFdEq/XZYGdbnO/UqdrmFM1pdJ9Wex/tMSVJ2V7gr7
PDbp93vtOkgt0xKb4RyNhHbpmH1qpR1/y5kUPhXRrw1qvaau1UwTZ5UONTmv0DXuUyHbRXW9W/pa9d+d
5dif1NihW+2nT6depz/lDbrc3Sz1Jh1qfOv/Z3Gu1KVcoUtuQvvO1MnFrNNk+SxdR6Y+oypu12Vc10Xw
jB6DyWt14qiy1FiP9/X31AWzAm2e8sCNNKQjA5m65ZeNHOQiDx57bLcQ49VfMAFeFKEYJSjFRJShHJMw
GeYXB1WoRg2mYCqmoRbTMQPnYaZZrgb19gpgfggs3bQLIoQwIogiphuLDZiNObqNeQHmoRHzsUC30ZvR
ggv19f0itGIRFuNiXIJL9dX+/7AUl+H/cTmuwJVoQzuW4Su4Cl/FclxtVujBCqxEJ67FKqxGF7qxBmux
DuvRg15swHXYiE3ow2ZswVZsw3Z8DdfjBnwdN+IbuAnfxM24Rd9TbsMOfAv9+DZux3dwB+7EXfguduJ7
2IW7sRv34F58H3twH+7HXuzDA7oZ/BAexg/wCPbjUTyGH+JHeBxP6LvTj/EknsJB/AQDOISncRhHcFT3
RH6KY3gWz+FneB4/x3H8Ai/gl3gRL+Fl/Aq/xm9wAq/gt/gdXsXv9T3udfwBf8QbeBNv4U84ibfT7cuS
ZGzu6fb7/U2ObfQba+kAWqG1aAO0QdoQbZg2QhuljdE2OtZqcWyoxd28eWOvfRBqWWDbMDOLMFHEb0du
ZiGaWYhmFqKZmTcz82Zm3szMm5l5s1/8tOQIOUKOBGnJE/KEPCFPyLPIs8izyLPIs8izyLPIs8izyLPI
C5AXIC9AXoC8AHkB8gLkBcgLkBcgL0hekLwgeUHyguQFyQuSFyQvSF6QvBB5IfJC5IXIC5EXIi9EXoi8
EHkh8sLkhckJkxMmJ0xOmJwwOWFywuREyImwXBHyIuRFyIuQFyEvQl6EvAh5UfKi5EXJi5IXJS9KXpS8
KHlR8qLkxciLkRcjL0ZejLwYeTHyYg5PqHuh7oW6F+fLp22INkybTBeldcoh1L9Q/0L9C/Uv1L9Q/0L9
C/Uv1L9Q/0L9C/Uv1L9Q/0L9C/Uv1L9Q/0L9C/Uv1L9Q/0L9C/Uv1L9Q/0L9C/Uv1L9Q/0L9C/Uv1L9Q
/0L9C/Uv1L9Q90LdC3Uv1L1Q90LdC3Uv1L1Q90LdC3Uv1L1Q9xImj/oX6l+of6H+hfoX6l+of6H+hfoX
6l+of6H+hfoX6l+of6H+hfoX6l+of6H+hfoX6l+of6H+hfoX6l+of6H+hfoX6l+of6H+hfoX6l+Suo+R
E3M4+u5xDInbBnCnWjSQuaTtEHBX+6GW9Flt1QMF7YsGvEu156b2yQPps65qax/wzjLjI0tPtR1U6l8B
AAD////xFwZAoQAA
`,
},
"/fonts/glyphicons-halflings-regular.woff": {
local: "web/static/fonts/glyphicons-halflings-regular.woff",
size: 23320,
modtime: 0,
compressed: `
H4sIAAAJbogA/2R3c3BmT7RtbNua2BPbtm1nkkyMiZ1MbNu2bX+xbTv5Yrz53fvq/fO6atXutXr33uv0
qVN12l1RQgIEFOTf0MUBQf0v5gv9L///h4SEmjwICKj/vynBf/ilPnArKSYu8U/L+seJ/oEEFAYEQlGV
ieWf1vWPi/6DkWWpbLCpnbEDCAjYPwqK/y86ydzCZpi6uZCAgID/Vwvmf0ANHmbhYGn3TyP/l1f/L89c
tYmp1NLY+d9eiNX/lwcCgmJp+8fin7YLAqKAAALyl4+IiJXUytzYDARE5fLfOts/cICZaH1Z/RNBQFRJ
/q9ncjgWCGQrOxePfxrfvx4Y/3o89vejxtjam/7LU1P6p1X+QxtbrIaCnbHHv77qH/89138AgwDN+21s
Zw4CovGvFmjgP5/ei7XpVw72zi4gIJp5/7jQP3vB7RIl1g5O5v/26vzzB8L4H+ru6TDczU3+edZF+ceh
/oNWrcrxfwfy39lO8RfM/BdnELDu/zfCMnqsmxqZGRntgpvAQqEYmRhBDOgKTYEd/wQBQSwDRQQB+W/d
wtosq69vom9gatAlICCAFE6EldGY2WQd9BC8uC5I6cZBEAoaalsSYQr6Cx5kSZp5ESQENz6JmpkZDATe
GHb5Xw1AvKDsoBHKyI3dulTEvJJYVbg7jE5FkH7nsPgVCUQWTzMXBjxhROJWh9sF2TAAefc01RrKOZYw
K2tRPPglw19Un4DAe/ere/MT6ZqCLIxlg9yUP72nWk7nRN7KVAoUc6x1DQ72aqEa40ho3alVf/t1lV29
VkdFkr/aSh5/fTHFralUlPACg4i2LD/gB9ucCLJolGN0pqRMQq0+jeMM2hn0nJWwD2a1TV4+Rc6FkCRP
QACyMCGoAkpBEKhEmlEGmvx9ylQi9dm5Cl/szUEkNNV6+LJFsbYybQOjuTaWZvjOa7LhS3oujvdw6uYJ
o3sbgEHgQFXgWBSppeASz4/uYJ5z+bBqkoHDzDCexjDPj8H9zhjIqZobG2SV8t9riAWhBnvxWNdX7lTQ
FUbZQkQGDxhaJeFex2hMjxvxyoeEHVqKNjHjDTmCseZ0io90BCUWChBDXK/FzcsvksqEIsWW8hYRIEVj
tQkvYOPlbXSeTmeVnYivcD+zmVE9IY8b2IICcHwqSDU3gjwXXVxERzUFQevYWjxOuL5/wUNlziXx/gI5
4renQcaV5w3QaSr9mvuAC33/IH7gxWliW3hc5IE9I4U4znSUDbrBBXRMIr8FLu2ZMDMXpZXsMwqWqHy1
sp38mqxrjp/rCmJFfR1nE1K1sYPI+FokXXpwxJCNmyyp50hLa/giR+8PGXdRV22eelnv129oPDUKogUE
QK8OavxBIEJCpsSYbyWfoEdEfTKpHIJBTSSA4z7aHP8qEnqVQhvpkpbhPQhthhqJX+nL41Bs/ObLlLez
Jxx40Sbod+/FleV5GQtdx0E14TWh8YcVE5FQfw3Fm+mmhzpUeZ8RSvI/uov1y4Zpul4V40ttdkX6qQHj
6buxeT8Z0anRPh0p4m5f8atsngbwbjDdMwqeQwQ/KGzanznz/iUT8MZHX8NmhQQh6snp+V3QfB5e2YUt
0EC10FuvA/I/XxXo9zcIssd6dzesEf5RMgjfzpRUoS6edGG8mWwDuew9zXCC+fBd/O6m+xgg299fhGsA
swaFJMSpCTZUhBqRgYY+zikmSWn996rd2UBEyznuvEgrfbeWTowdaecW5d1t7zNAKuUKYuL6+9uRHEAB
8Lrx2nnf5keYbPqJ8IqwMuAQ1VckGzyOkAKZ48Oky4L3ZVc3VV83nsTFZ9s3aN4/RohPj86Xg15oQkY1
sjFGD7wS/E634X6ywH9HD2UWLxlj2ktlZlmYoJaTqD/BUFGv0i54YY04iTMZo72uIDOTBZ0fl7u4Oyws
D6Q/HgqkFysuoy8aaqMughMf4O89eIXrgimNWeJAVuTJi5mbBEGE+pp710kXl1sbYM72cA7Y3oxjQB+Z
b7fH2pvKFqs3x5gkDQHQHlcMWE5awOewwB9PNwxHZWKNbGo3qJ6CkdMuf41Rn5EVnlsAd19SOtKjVLIQ
P7BfLNPAGkOUG3CLq3V+T+4rNhcDMGKoQ34kqCPgFnOX4lTKMFdK4Q7rMMhqdCk5kZotsMoEiGBVpojE
03t3yGwVqTqaJ7uoO1rIfhY1YtCF/xY/1ewYbmim2NjZiVWjP/SEvxOpqZ1NnZwQ4N7OtDj4CU0nFlKm
HNjKnDuJ1Piapcw8YlrOJo0ZmYprwLSdouW99IXMgYyXO8mgjfH0PJN+RrqCvRQk0QC/DVh4szwpmi2g
aLckw+fkN+jucB2SQMJmfd0/KL322PuAh78ohezSL0XCXvAZFteMceEJWlg+yu24ragtye0K7f9ZHqfs
C+sF8jIp/yegEi1kJglhfQxcmW6TYbSFjBtXgnhwvZdo9fsUfH64dyx3SEouWLktar9sIA11OJVm/Bad
gpWqQ1ajvtdPB/kEeFSw1rNtxkdZJM1nkdTVEMTFqDvd4wdAV9RLvD73vE5g+kwg1BbdNnR8XSDmO1r1
ADIRwawSZMbZ7aofYu4SEh0HhNSzyuWMQSagAKBwgHBGji6QZyrIDRdrQOY3fXG+st81s92DprENpeUc
8+wt2L5h76eDsQKHhruGRlojY204ElIgXugemG+erOS46JdmZ725nuH8N7ProierV8hcutlPgG/fBrdd
F6+JO/8tg0LIviJmC8rRpOixGRH1PSM8bZaIM5S4hqn0OGcucOaav4Pyiag4KzJ/6ST+wizQEGP+gQzg
faKMU8H18rkEmsTL79/w4qBPpVqmY4VKh0obpx0OB6dhEIgtP3smBvYLk3NZHOraG/qikQjazN27/n6+
mjypdtIa0cOCvvT7SnjKa8oP4nd+XjXUd7q97xHxEhJo79O3qHfaOeJLqT8qEOwDYT+M3T76DvHzv2OW
n6KRWwvAaWeN0FPPYBuxmqY+jCNTxxwPaRD+2UcA4oYsVeBFPNqxWe3Ua4IS8JCesAGq2rdZO1awf66Z
sfkO8wNn96OJqBUeJaEL7O5P9hCOLKqR+/KRzZkzha7ZPELVcleUC+zAMGWtNL8HcHrC0pD8+sZX0ye3
K+xkcUfTzaCaKDgRGx7sTGfEoOjrdfhmABPPDysd+NH4QUAJQiCdZCRhjESqyFNRTBld7BW2xhy/F53c
haQg9TB8VmrgA2zWX6jpPa4A+jTWdpvf3N4etOrxZjoD1hsqMg25LK/BeryWUrQ/V7ZdTP8AMu6jOfXh
m95OM6e8vwRwvOBNwVMiPJ1yqO/S/obR0ZN8+yJ7Ib8Wd3z+BlK6vvM/N+jBY4r7qViixb4RvVq+FHmv
vuALjMxQu6H0qiHc9Yk5lRyWkii+uMbSYxyqkeaglWxbPvXSf0w/Y/k8ZxdPxjhLPk1k934OxAh6750I
5vZ1EqWN/kmIpQiTsjdcxiYzMNUjQ8OVn1L7kkxPJyl0R1XpYtJcq6DWpWt/jziXdP/J9X36nDrrOj7B
tedutpsBg26pIkeVGICbz2wOxR1em/LBQEIdEoU2SVNSMZ+hXoVLka5qq17MUMnFKiOp4KieXFO1P059
lrVfTbvQEO7HlSnqhFKcGvPDcMuyob2r2kljT5+64Cn9qiC486tiHuEGTzO0QUbW1dBGd4WNb2mfVnxv
QszLHfnaaUmFCDIRABdIs7q4U8s1rOIMA6mGrM/0cPdRhC0jnFas7JTl3OXk4lf/hTwEWDV442H2jTOc
94CdUEFRGG1ZjmXu8F5YlqCaZR6cMpNIayAsX0kGb4o3y49ikZJegO/6GTk/KL4iKdjVKcPgz4VS3V0h
N5OiUOANfp+PTF6jiGYsV1hv5i+3SZXrIAChRxIiktCBuzPaugak4km045oy2KxjfRr4O81Mwk910JPF
Hdme1B7fDr/8SyZkflecu0i0vDVNXCYpxRZAyiDjXBP8eS139sjU52vT3PSWQq9kiVGu6kS6kB7wut6Q
JLIgpALQAd34XJoPBL6c0dr5m2baB17BVxTb/J6xkHVXndjTwyFZtz0lry9K+37xSfj+fnqLUxMOzN6N
jvramba88DqcO7Ajeq/9voCsm14+FD/AqV364x1378GU/SXrJOOsnh5UWJEVY1pRFYq6xWwsdoQeZWV9
cCc5cxG0JcCVFaxfyPbKFwN1z5/soxz9Rtz6Pb5ogbw7vUrgLfjl9gMw2vtJQx3Bwjc09IL8gjTSx1zH
VSRFK0a01wA92vP0477Bk2cFXldw5ILRjPHw5O5BSOHAFZI1HiDGnAgvreRzQQKbsCsMZHiDIh5Ef0be
Z6/TkJ9FVJl6QG8CV4Lf56ZQUy9Yc3KGWco6Jrfiy7fYRBAX6l0GhrVAfZLCgtFlqaOpF1PoKpDfzYsR
9CTL7Vo04PYkl9ngXjHPS8+yTFQhi7n1JqBguveigVSLukHiNyGtIeqEVfZigF2ZEpvGfXjUSNN7gRf1
fqO7ICMd/lGYkHakyfnW4jczqAcr+EJvQgVidMEUe0W7GZY0RTJbEig2/kqv0BZ3BZxzL1ZliBIX6vKH
dag7v6A30yGl1MeOIjRD3ffErMbYLGlCEuuZV5A+kTl2w4Qr68fHv0IL+VkFLvkyBoUWQs6eFlwkKDHA
L6ah96WpQmiOQ+H8qTDPhEZe74sRSSw3QzeKM/NzJgApzUjvJAnguIA0eugeV9s+gUKMji7WLpA3WnQ/
g0jxe3p51Y2Na4y15f++y81ueV9yN9zywXt1laLdv6TeBwPyWeP7Vim1l7gcSp1lyOzVGwNTZ+wDKndN
TPANG422GFggDlXKa0blTCf4argodRklMTQl9lCJxQYgpLT65ZZnHTVkyZI5IOvqYHFGm3vJcH7oY+K8
wQkHBRNo2Fn9CSqoAzvDMst40f9gtBBwZnHmCJKrK6ign6b2EepOTvKEr5gA07Sm2QTHalIXKoVEWFcS
7XuSHfZRoFmJrZo9Z4RkMdJK0QCZTIVQMkoa3hdgzMiItHzfLJ5OjNvj34a5iETpp8I2I7Y9bmBd60kX
u6YrgvOpS78B1I0j0JCritDCZt6lJbLzSE9QjwWiciCWYcgYmNLjsm3P8HxsRlz36yJu8Yea6VbRJLKV
sIbOyOe2BD7wjqcihDKhpk5Vn+J9ZOV7ZSh3DsRdsWzyxBn0Q15efko4fbXcc7zM5KDZKeJ5dSDk4kvl
TkHuJfU7CNogO1G5I/pMzy4FGf6+VsBzJgydAYxlTUESrM/wgm2Op+PmsprNjxw29b3ZbSznNtjhj4kE
0Pg+otbidOU9x9rkQR4jlRAMty/DLX81bdPTY5bLtf/YSAV3zS+Ho6WkxYxh5MoZV+rEnHrfJdVz1dEv
hpgerJoPzbDmnpOgwABH2DoW+VMkB86wpH4eUH1dNa+rfrnmZI9ssHgREOmpX2YZqCQWBuJasEumYiiN
l4KOXJa9jtWQAG1Q9tvz8apgQYQP/Kqo0sffg14hDHiqqyEZ32me52Or8C4UP4FzyCq/fktu44i1AQ21
vuelXTnoeIlm1vPU3+/21LdK8ASiNSL5bJOZ0Q3hB/X3m32VRF9uTQ7ouus1OwMIU9LkVObHL4eQM2RJ
E7pF4dEGkBs4d9QVXjJgAkm+6kvrWqPsCDcinYL1Yz9iwG7t4tCRJMxM5HCjihUC9ZDnp7UY8GHRpqzA
/u7OWaAvSV9gkJLR8FQdapotGvM/RS3111Dpg/pmLuWvj0yDPHJx7sewpFh6fNF80aQNEu0GXCGs705X
7IuT6qZ0e+BrBzre7capDqKQ1A2WtcsYCDl8FIDokXc6OA12SRbWHzYHZTU4ICFPVSVQD8akuxdUTyZ1
Kayi43TCK/65TYoP59BH6dTV9WiNPNLV2eoAecoLjnvhH5I/RnnO4T9/PwcF+uyEmV2FEVcoTkHH30WP
oHs91VmWK3qHl46qkZwJ/6KrI+YfY4ZimsU4UtdpbQgmMEHASmYVJURWOPcgsTAzTjLtaIpIJID2I58Y
5laMicQebxRMJnr6CubjfdJ4h7bjt+fg76c7FeLuCKyBDGPvRa68OF3nx/5pTret2omfRkLOy0g72eXf
eowr/7gREINFSycLhpwQwR5U1BBJYliuidBNcloKEV52Jf5V1BNwr+oD3uL7cNm4GAtNhvHpkUwWxXpL
t/o8A4bBgm4xPccuhZw9CYWzCkOoVV8Rvi4CN2HWWEnej0Udw9BWFFHg1ZvtPqnGaYWV7NBL1v68gUBk
GB5TfhnAnpo2JadkqPzv78c2rVgWtTyaXDKEX3J6/WFkj/Mpq9gn6wtU+7Mf+lyVzk3djZAUkWo3yHyp
VKDvgTa7pq8J/Q/HmG3VXdV0gTwifUSaf/RF7YM5qwmYdzvx63xk2ou4+LnmLgxLaazJviMZpURAvufs
nXaCTeBfAmzFocTJWII1V5MatZllh3y5gWUfuHDFTkZ5f0k9tXpLUAp7KEmwKHvWMic+R6VseibPAnl2
7bTEwhAC7GoHhm8ZoWW7Vh7aZPqzCQ2OGH4Ckl6R8WJKo/3EVqN0fr6AULQDy2P2Ka8iY/95FKO6JRps
iIm/HCQI9i0OAn4+eKoir4c0wfenb1LwU7aDf8ceSdOF16kS/16GofqdS3P5UbV3gmXpLqRnpKsjdKQb
2w5HoYFwiWIo+G+c0WqzGSCCZ2EFT/Z5dTmBhK3Sp5AT17ySxfAZTxnAIkOLhYBdITaeCsV4RTNIY/Ok
h5RR90VckzTUkF/xFPhishVsMLWHRW1/JqcK/zDxe6wpwbIDVYdlq0i8m3ItvbJgI4zNv+1Io3YmVMVy
5DP2fa0wN4Q4aWOCcd6Meaix5dwF5Q1ivE87zvIPWMHh1GIYBsXFrvhZ0EkM6mvArMWQlymG+pXXacZB
qtMDQ8+kTEs05ZENmn2aMYlURxM+J4K2NZKFgykUfzZ5YqQwYkoz9Hty0rBdd+tjGNCaHENPXvjonOqW
ph8bsePq4TYcj8Yo/yId+7PuHNM1hz+H2AayMI0lQjCMjDFtOE/MGQmaIUnceiVB9Cc6gKy2+VjJXdGs
/K8pj1pLe1eZrValedgGtG4Zs3/TYDJi6jsEDl55aCo01gcpWjLan6vi16g23ZhubWe0fAQCv/wV2K37
9fvaT+IN3aobjjGbxTAhg0kuN4aMmAW4H24wEsW2MPt5uEoq0PptizRIIG2wyDxCYcKQ4TTNuxUjvAjC
PKyzpWzMv5lP8Lqk8zatzrmpiXU1EmqSdcvInGzprBhJhsu3dMxWWpHVNH6vNTSAwU0ZcM18GWMvDbnq
B7wFcKVNNrTUGJODtv+tnPcAi0M5rLFMC14zVkEhJAfgQgp53bbYtBj4Gtd3X73pSth33qsxzcdGISk0
SmYiTCpShinm2FjbNE7x444PnDmd++6eEx2TH3uXZAmfI5wkmamfFR4QgLFEn7Yg1Jj8zJO3VD9zSW6o
Y1dSh9KjwFbHl2kMaG7MFvqRyb4oVyzNAt6o6vCni8CpFXGZh2qCu/73MEJiCnP8yPOC7VS/DJGysyyJ
8BxDfFrTTV2gSOvB89DLO6HLQ5bktsd7tOR0+aqclxzH20gN8Q4lUVyCxrzrgSJT70cpZwV0czfdHvxt
N92oAYXgEPySgbf96vKRR4jhTDcAR8jSdKhMmE1MGvTgB4sWJA2zM3v5DC2v21TtJ1UhSSPdeSJi2K/e
YbuS3iOzTQR1dIIwpZ6/nigQfvzKIPiiUgFp1d9PAe2pBlxe1U+Vn68bOZ9v1T6pm38U7T56ALmAz+Qv
i3DcIke6R7Qw4I7ETpwkOh8qDiFyFce7noC27jZsEFzWYOGds78Yukng4g2yRgJEaKOe0GS41WycFzW9
JdyKIUOW7Sb3L3J3cL3R7ao4TZA6qt8Mek4nW+oLnzs+xqnWQ2pfW7rmqluCNf5qqAGZ4CCWSevkrOlr
Ru8MFinoBY4e1usEzBKbS05eM3pJuP1y3EvtYqxKE3+viz3oU2jqJbjQoEP44K1SCOCNmHQYgIxifidw
bDoyocxvEpUUSIUJpABeC8kFSk31+9tr2uLqbBlo1/apiZSFxZmEmHTeyaHzoU5yvWIwb8tpsFWispSE
yNsFdR2wJIJx2snKo6/8P9STCqGRJSFG5vcyX0I3cmo+8LBasxvrpaZljRg2YHBeXQvl2XjYkx9RoI9r
wVuNU1CGebXMXGw2HBS+impRJ3NbCZOSc+k1sJJgTEjBZGHnRkRqoufx/ZFNhSQgBW2V+oCANnJqkT1x
pMIteYlI8SWJZnq2IWUPN2us9uPCsKuJVYOPPtky2yVzW2wYxChSoj73pNJL0A8KT+V6MF3xazuzabiI
A4AHKpzVNRZKjzObYE+7wLXqSiIgA6h63A3g6nj6JQ1n3viIs6Snaz2r9MCcZ1tvrlwt7oMih0E3gdck
+1EHmWKTeHwXq6kslaqHM4US9flZTBm3zJYV8OXHRhrAR5OXFkWH6C1zm74i6JhboF9eS5YM9/w0h1k3
3O0zZch91XTgqzALhJBfQXeJxVJs5lOzMIpQ1Z9hALFhlqBbAooh1xBYDHiYG7bMrmTKjECAYV1fXILW
nfriwtXChd0ihu5qYlGdenJcu1eK7jnA7JxuUhm9f+j02oMctrpZcpdu6d1Z2LRka0e+zL3fhL2/gyWd
ZIypwaBxP+agKXG5Cvnmb6Fsa9mgxpqNR8IkLP2EJYd83jNjeCqbGwJr1GudYOtekUlFk1Wvl2MuZUDw
ZINEz2YHu0bZFjpLQofP6wzIQceMnHEypIlpj7x85/vzlEasVScVBmL67NJN3/+J0yd0KT/AY5tEeyh+
byLF81SCQQa92P7BYc91aaf1rCSYKtzJHUJDhSJRF0e/aNHk0LwIJz6Wwj0JAd8QXQCyOW4RLyyfYS82
q9dISVfjN60m93AIGpSPh5zIS/vHKFIWPVhuF24QAhgKc6ecnA92DlK3Wc/5YHcZsceqnSpO2NK2Gk9+
UR83iIWcaVadUt+NRQCe1uhMi/nUXK07Xt6WQtj9KosVNhhoj34PLiIXeAbV05Zk8cO/zGaGeiuvxNyI
BVXuA4SebMkp+I3qB24f4z5t8em9wQQoLSoOFMWs4bkcqMzcshi8PlvHhjETWmSheJnYsEoHNETGaPcO
HoxFiXVEfMpW3iv1Ah/9KtKydCMBjkv+n+ifyxeDl2E4tH7gV5sbZQRX+9ntAxUxMu8TuNaVdthWMsNz
E6dWw1xdvh4e/KDnu+plbOkZx8e8xpL3SE1BNAgrUQlYXVYvchU3R2erAvAcjggGeM9rzjJtOhZ21Ft/
0WaSdFwZ2JBTLuXQko1xiqwE0mXQtS72jUC4wxNRYi/HEyM3wnT5SxM3NDp4Hg5t6jncV63U7PlEu6d2
bC8ceMZLnN4mUA0NV3K3Tw04WUR4+KzDsr0u0rx0EhmoYQ4Nx+kMlXqh+cK+cm9AZ5r9k06Np80nGGC0
myp80HgECNWLqQq1O/qMXZJeRB0QGTWUtVqYu6GaLlJEyZjpCIvF8CTGocEXiEKij32LRYP1i6Gzv/2N
cigli9rVtv23ZQn+MiPnkueIdIKGUdfaDQlLmgN6lmFeh9l3Ugp/ViLCbG20H9UfJddmOy0gWgo8vlJg
X235RMTZHEBlHMVt0UxRTWDDWWKsy4FZTmY3mW+fd6ZqcNQIAI/3gbKav6tmZK9VKrxaT38IW6VhDfmD
F25TFzy6QEA0754NkkodFTYEOaNNnyYWT8zTySnqrh/jA6DuXTl4fmAx4/xukMvcYZqadqBStAeixDw+
Z+6XBwPcLg29oKM/Ed7nnDsMxxCcjfBVf89fNrPY3O4FmoLXtCrXuIOu6Pr/SFBT+oXHqJPNrCsEDaNs
KLqmCM79RQLl9MEWtwBh+GBjk9gY4VxiBrqmw6K0wTBfNExuWzAwiFJk9IR92JaGzmfCCMfLjJctlhSw
BUeWVpTV5HG3j//bfyVe/zJAXzs1KWaEVtzVuR4t0qKLrMwnVtD3EjDa7uyQjlhMzup1mW5bn3ak0WBB
g1lgo/RYaH/rHvAh6n1jJHQF5r1Gy66MP9cMsqmAqD+ZrxhrBuOS6VM1Lqc05/g6hwemLDEMZgP2gYuy
JiMGsUZY1OBFCUpuDmpG7A62WBhrs4rJvtid7ri4kEDnHiSBez3qujjaQnJ+mc2+CPQOGPGgLYQniXKa
N99duA4j94XVMZF8PuBdCbxpC+172nDZUPyRdmEN4cxUxthWNRsue2Ta+kWkNSz9nqPIJYi6fHc1ATtY
7eowtvdW0vHqIRkLbq/yzBLoO5fdvytEHfQXRxS3uDWiHcezZxglHYfq6VBwy/cH5bBEgybeaCGLMUpT
HDbIjIHajtqOwPZc7KjsoNTgdeItmqBr18dLoWvBlWPRWJXiqliS3CiAoe8jPpnHV9bKt58gQ9SZB5Cv
Lf8Az1jwCjlMb9LFHvYzi05YbjOYR2RtiYVBthFx4qvlzAq4+dE7gcBtcDz6HZ3STHIy2pvfaz5A8DV0
pSgMNC3MtQiOIr5aHh2FyfgVd2ZkwRxpZC5WyS/duDUvBBzGZWNjf8iqIcGJgaaROTDKNWiSl3rhek4e
JRJ9gLJEmnbO4mY+6XTQ5ecS+FbXRfyFAWmEVUCgYfeRUGj/2T2A9IVbHk3Gfntg26dpMdFYJmjjKJHu
KpWuX3yqcEHzQew4ONsoWXJmdbiwN9qMURirSetXSyD4hsWztHqIGBkZ6UocP9At382zxeaMWoKj40dU
YRIEPAppXpia9UYoGdpwPWHq0KMsSQ84msc03ol1cRUf2YxnvMZiXuG/zHbxg+9KLEhpm2Sfcsal9ooQ
6DRurw1xsiYahthxLouoQeH/CMLFzAcRIn+iS9C6byvfB4tL1ieC1ceQL9i/ys3g4kzEURn6IbHVQUns
8nDBH+B/cmrgXveiOV8fTr7Nf9xrtXZsPsnh7hi21Z/3noa4vfM+YklMPnieeVj39oOvFeHU7UaS+B7w
AR+F3fRIShgUB+UVPFBz5J/HulwEWZVBTpKdLaklClPZ91Kes3cGaUOLT2lQ0Vz6qob2528GzohX7eeZ
68r34XoI/Hd97w4a70kUHY9lj8d3SOZ17/cs41Osrp/jQ4vm93vP5LeX2RDBhstZznDujvjMZizPkoe3
vAlWjORKl44LYAVF/8FKLHlukPKcxCR8wD++O2EFPAJNYi4GX3Tyb/3f/MZiSUxzp6GpKl8gTCuWUUfE
XrsfJxcu8ekfhDwA5oDE4nkImy4Menuchep4T/qQcE2G8x2mZnBxyOQKQ3a6VsvV5CTT97b8BkFp9jGa
t3VkInumIlOcvqXvg43hH+vBj84WPZ9h9dxMrwnwYdBtj2PO1uouao+WudYyu72Y7U2KzvOne9kPyzQL
SjibI54SArFfXJU4mH2gsnOgCwWyUoiGzYuhi3XGBFwYEgvKd3+LpRBgTQaU6jHmRYi62mopsBRPGaV2
OQywKKl5IKVNu8UCiqb8TUK7Hqjbye/tgJhsMON7TwETvLEV0MQ+YZffeH9unVzRXzfMU6VLCws/59yj
SuyD4q0G6ezLPo7n3LfbmWWJuhBqXnMnGXUX+IhmupGPVVgTLbBO0/qb/ponqan/tGlcK8YBnUQYnjcQ
DyNTjWj3hyxWoqszGicIbk86ZbqTeJFbLm2xxdg/aDu0KYszZhQhZ403QQInMTWy13d+NjMjQs71+9Le
Q3mNevPfNWT2urr0RSzEZLiwweGPgw6WYlu7+Il+r8oShvCd4DrWvoYde9Cc+ga63/bFeeaR3oxqs+SI
i/yu+o0bfQu/B/PGxFxJC3dgDiX2/Np3vDJSuYhmh2JAhcPAmklG01dtY1VUJcCC295c9JdhM7+mS3JQ
mnFJKUP3lWe/SfSTP0fwNVLHtyUllZzVOb0Bv/5W+QL1Er9Ro+yAv8hBewggBu8qw8gkJ/Ij2VpgCrZh
kplYu35otewkWqpOIk2aQGCKHJnYYsoyZRYfDowTyH+OWO2t6IO4TXdpXXRlfjU2ec60FMSkWcYKPHJ8
f8LKq4cuqxKHrOY+f1qwgr+VApohMQQK7yqq+tNmeDppNc9FV5UcVUSO+xFsKW5rYC854ds0EFH4aIsI
tm/9xdX29cSuD2VXhZdeumbxpfqUYPMymgAs+vuK+n2WBLd315R6AD2RpkJQWU6vBrKwr1bsLb3uONfI
Mwm+k6H8NtEORfIYGbL6K6kNNdLI3OH1mX4gqKYlzXJw91c7fRxu6Y+ubD96Yb9SPD6nD7TRyTjDcPha
YzOeIu6I8rQuOZT0wIn+mO7jJKOfPWTe4H0S9YUli8KkPbyiMRUzxSVZc2Y/PmykZgMD5pIm7mv/4YMa
ZK1pKqgIcfdfcT6gpHqFQkLbRG5EaGu18ZY0drXyPinB1F6umHafO9iqrLxTeBRAv84fJhYu3dsoUzhY
dsVTs1JSI+FVXAYUmgWmjzDhen1K6cNTKbRgWz0ySOx+jfhlH5+anNud615GCFYix0f7WaxE0/hR4hvD
Ozr7PLL6UvhR6LDCstKgaMftkqyVCTxiuymRmU5EPs7Xp3oHRyWzaY/+JPhm+2YDnsTMTkFLYsouo/z6
XpwK8895rUNmJS77Fhlg057ySssAxoFzB8iY60U4e4VDH1ZZzhAB+YH+b9uEmG+xJbyLyNdrogolYVR9
RxCEJnxMsHtO7H3mK7sDmyTvEG22WFGWzHVDt3W/UsLr/Vg85rxd4LS0PBwJ8krmaWWN54HqfluwJcpS
JA6SmfDD1LFGq8U0nKnwTqTqUrA0wjkIQxWa7pcericKHoJtpnD0ds2stwKolI5kctdQaXyuaQQHzNyl
fRBZFEWUoo1/PcavLXf47eHIW8tu4rZmurxysBQJw0x5WMf0xEjPammD1LDDVYAdmvjdpDwrA+oUVe3m
oD3G/kxRF/JN2MuZTW07U60AnLzBNLzFMOW/ETLQFrSpdtNstOvdJuNSJbtxkwVh3qvMQceYHtGBQanO
g949nADj4iLoF0eW0NrNYV7IHzZGgK6gZweiXGkOLlVSwXKcza36Y4+ZrJySy3HnxFbFI02OPjw7rP6+
+qGL+zW94NQfotLT8zn6uQAG6wf8z1fEXx1cAQI444Rljk1i2Gac8vt36j9Xwondr1I2VaLDfMoIFcVb
UYbDqSiziJHrn8fKsDyy4F4IjVAw6Rx6fiKdQMs+gJVcLh04oOqgDJtNxAixSUaWTbR4cEaDy4me6XGw
tRb6DaoywO9hvHF6KjlDYpoY0udMz+45D+aQAVNx5CZhgXRi9GEb681cBgKccnCvWRgW5kJ9whA0OYqJ
akiLjlzrmuEnznXw0HtqCm8Ghy0zmm8ttk7fu9ABJ4rl3ntPt1DfxZF0z8AeFdiszrKGF7RvxfG9CcRn
SDrMm4iZ6eqsVs63eVn55526W5PvWF+2q8pkcew3vxfw1wJIzGhD/IdjsgNuw5wOWK2ZzAUKYjzfNFZx
556u/r/jjmxMuxDjjojayFQynzoeG3bYK1+5XD4PmoiaP1Uf1KkOULIiRBcgCD4SHWC8EZD8QblRHzPd
qt73FID16JYvw+5VlddqxLlgzolIjbENgoZMSEvkXkJB6Vhhy05XWQZwjacLxm5shFQrCpRp+0f5Z/rd
5TRKyI0LkZoCr8auB8dUggRpGfbu4vEMCH5cT/19YYq/t7UqNQXC3mii5OKON425NFZ+y1SB4mTmT/wE
mI3s79V322Z1iTWm+wkcvXvmSF+9uxpiLucFpRT55JZUuZWDn9PPV/ffiqYVRhrF4CkrsigxxQk5173Q
fin95WQrUv9BIkjOlAB+Tlqd9ceWaRlj/8YbCmqvev0Gx6ZXdMQPOgV2eLUW+3eQ5z3uPFSdSxmrTa9q
4XivSjdiZVl/msQsYZbjNuH3HYmBa8o98gZda9fb4yvl/mKdke6J3hK1TdStfH1K7tFYUlZHDBX6y0Of
bNQEZ+KhAhCYubMmncBZmWlPWfgGOh0laYTtyzQy9Jr9ofDmhYDToYxqq3+laUIegl1eG9/NmbioAGzO
xOQq+L1d0zNyfDeqwru40mJqhwgo9/Y/X3K04F5a16mQyXprFE3XsYC0doFLZ69k2h24lMnMjh1ppp/l
GrNmZdQkRT1dE1yzF+YzDvzFM3KhJC9Zrz9ZtSgwto7rvblxEv3A6tH7PJrghyd1sxOTG4bslvPGak99
SGHtQewFa9aWr7BCvtAvZ+ppHHJmPkGTdMjPjRBTsBg63BbmZnFanI0bCvK1TTTXvfPr4dDSytj9J5W4
tRNC39JK5hRKVYP7gFqQfJa6wj6Jwd+URk8TLQiRRjs44ykw4mHgocpA/c8LpQqKx1yBVklPQTwZRO19
ei9rVOf+SL2pA1+gZt2flWfEGCzOyWYrLJN4Lf6SUpWFIeXOGXt819JEisQVEasV/0H8EvMv3NZFwCYD
09r6CvAHsc8j1Ze2Dm8S4czDZEBLAE1dscGEvEpP3AhBr7Fo/yTPCxs+9pt3SM8QMyVqUcJPBg0AfC9b
Jpe1J49zf7thz8HVjAvD25R5bvfx24Im94xjqQX22OMffM7s5esD+UBO2pFeFraibdeIm5qbY2h7Hq/3
vt0MPfc2wY/At8HcS4NEVnz+6YHoJ/UfXomsMx3Wrss2HMFg7XQ6OgZvpNPpsrj4gmHfyBagDrjKWCox
Gbrqxx0yQcwYkbvsXNirlhLE8t2OXuZasD54dcZgdYGM6JThyIanpqoCa6kyJfO2oGxZzCe7kD9+J8oi
Hv95IPvBWtLKrUuwfWQjLjpk+ZOXe/oQpunt/cQ2g38y3fuR2FvlV89Ct3cyqeUNl5/y+vi6BzqphuZs
dhYpfMx2+qHuj70zTjfZlKFbJY/D7sWI7uHTAcbY1mGazKpgTs/MMAtDlneahvP9GnZkXC3St/aVa1bx
6c6XO/WWgJLtEg7u3X2Gs2Ib3flUo+y35zT8l+cXAnRzC5aH9DUERsUrdfPQFIUOkkIEIhW4pXkREhFQ
tR5tLGcSq1/2k8gLfEwlZjmkHbmWQ8suvh5mAphvQtimHLbhINpR9U2k6jD4DULpbLnzEdH33ZCFl4nw
aWnMGGwcM7q+wylMMb6Ok5iTJ+z4QYnIl1gW7rktbx2ZNQZ/ZFbA6GiCLR7DvJK+ledPttad+yH/UhAx
dfYA5lt+A0Nf06c+ECtXmo05Tod8JkPzWUvdW44UiF+igujlprJRtVzgUrpqtduuI6obmW7treyGreGa
jPyx4A4KcRGpfhqaTkxnUPAk9NsqFTO9XOV/f8wYsqqUijuWEEZc8YYmBH0A8ld7C7n036sUMkudcyN7
oE+94npa558helL3bCezGdxHoo3ygHQBvhSrtU1PdH99h9dn+Oyb1/QDjGzIqr9/NNL/u/FmOTBna1hA
whbO4S2UOpPHQDC2xVfxBFiiZbyBamIkMMPQI8EYUr0E5vcPdZ9PPlNqCLi9QtJMXufy5666YFP8kkCa
ceCR0p1fyf4r/2A2NjK9eJm58GSkJJXleY09Os5wzdexz3i2+VCbfW2runO+sef7gRZdkO4KoMsMNI3d
uZKzSGT9bFzFL91acF+ht9fNrHZfWDuZ+4IxhNw7LXkLxXeeS1ysjgeLg2wqEvZJGaJMiDVcT2LmQpOf
X+W4cblZbfkmY4rDXhz9uctqOf2B1UNhYcXtWTb25V3VGR6I0Bm0eN9MTuu+Yaxhek/t5CwpIa3EfTEY
w2VODEh4fAVkHwXXahTqnEMoPFMYdYQNWCWmD9adySqVeve01vpvQ5/HwqE/YhahkQFxzaT0mE1yQwKt
mCkjBajWmnwvPBvGzx4iz8GH806mOKcfIf5NC3JxNrr5kVhSq/AMen21fHQ+JSVjW7dsWj/lPzese7QN
5rps07Ufp++zJYJ71xzYa468Mqlcjan7fqnMcJtr/Lw4n3vmS0m3bmdOg4QIFZDYxm+cFzxqOYbn7sg1
REtwM94/ZKRR+1j1Y3sa6jHsZCYn1FWTNQ4DHt+sz388Zu3hfeGODLQJpQr8Pbf2xdN+nC3CR7dj6jcf
jWYVsUH1rlvUHfYJ3JK/oNYzKuZ2QAmDefIUYqJxwE17U1aJa/bRIln5hsTuDht5qlBEu+4gnClXbIi9
arsm5XtJlQnR/2bxVDIUSb7qyH4fvd740+2WN2d4DKWvUgnqFkCannlqnoFD9MOEL6XKPDKav/irKHzt
MQ2l5GjmBycys04OJuE3hIMzZ2MAjeTtM2CpIT3lV9rPWMUJEyQ5SSTAm0KeRMabSuIqBji+o0NNQuYs
gjGuLJEs7q4TkrpeHN/veowYkHYzuZgFTxFpAxSSvDJkfNVura5dVxyhpJX1nwHRvzBWiu7/BjyFW0Hi
4z99lhef+B7xGnK7W0/YDz3JFUXqG3I7aU+egVYubRDYX8i8iy/Ey4xO2GEbtJCl6jquhWxoJDTrkDFp
vBr35u+w7BwKDnYH6KBTFRbSf/A2BNh+XK0Kxm/1irqv3ayuSV38mbr4QP5TooFvT/mwyn05Zr8Utsiv
Z3UJ6fZ0MwtburQAMIoIZcg7yDQiav5ZpnqhgBNQsXwasAcpL77CQdAWPAcnhctG7ZFvqu+d7pJQQxyX
6ed4Ke90wzSG2LajbYwcRwlEbsJEXW620/gWylDKhsbZYrZQ7EszB113Qhili1Pt8H9ipCg3hza9Dakl
y8yzBcMsx2zE/mlerx1p4N+glpAJWvSbh3Yc7BbplOD0XWyG6sSIF1Zf+QxmboaLsdZDmy1Frh1RQdK/
k8baCm1maHz1Gc4GrvNHfkycJ8p2A1u0RA6Hm65sa4DX/M0TH72Mw8eq3PZ1YSNnZXdYt0rZ/J4pnlNQ
fczgWhroaCFHzWojRqqnOJmbPulr1vSjMix8MZ1n/4UxvcHR7zk4nead5Xu/u1Z9Zg3gjtv8h3DQ04YJ
FG57v8BkPDUO1sFzOJptcxGRbdvCT8HllKUSLB48GGnwWLtSFvYK9ca5aYVF1jD+LLZWAvsSPOJxa7m4
oNruD5YzEkKm3ioiEaSVhHHXr5Bv3Dqq1kF7joVzsiZJBtx1tF982VGhNgXUjgXzL4p9VJ/KQGym7sU4
8BKQ5Oa3wBCd0Ha0KhPLEBQGZRal6zsNa20NVYA7dr6GErdIZrl4XTqehlX6jwKBbqrSDzZUBmfNJ6NZ
mGDjLsrEmNcNaDJFXJ3uSyLFgdskT01l2aZSUSh7M8R3XsMKXSKb4m36jpqbZWfXapJKOCPgbIMNFHwg
ZmHlImidufWaS/lguO8MCQUztBxvopS1wTSy02AoaAIKumPsDOhHFNEXhuzG2qkTawofJz7MbYzW7DOc
sfY2yS3mU3w9awLusokzXpv6Norh7jaS9FjXKjPJxcz6laSW8L34CgGoz/oAfFYAhWQMv6ryTrO2dKOY
gobfZHVRz5ellQH8JD3YWy70402wK0etJuqRlYQNeRjLUi5D60LW+RPE8jDQomlZ9Iq7r6JSMnLvGTEu
EPoyUC0Bih6iEEMCv+MaBFJtNo41eO6WbQSL/c+WJsDFoHXCzsVr5nHgveIii7U1fLskbwOD0eBl9h7/
i8U0lFeKqFU+l3OL54rMqQTDM2PKsAOwsQ8rk6Ox3+5Y/lZdCvrAEdAYSu7euULX9K07M6sUi/qqCpZ9
KvwlvNhqVUnzIZvf2kmSN8hLAd/wOGpu73azvfV53CB4tfNduv5E/ByPfToq4PnWX7ND/37w9emn95RZ
A93M3lG2Ij6Uxlblx1az6QZjeqxVtm8DvvywXIEV7u5vJIZAb8dwV5xzs28mLIlqmZBFLkbBmDOwa+5o
VfkgxXPna0Vd7Nv4hzrZLuN41aG1ta0SJvQhUhJpK8YuXUBP75Lq4kf2cE1iK0xnh8JvG99Xw0BYIJIT
sBI69xOAeE44PLJeR8GTlZnuxBrzK9DTK52AA9xfXbUvwdLWzbh8dNS4zfjz0Fo+FG1lPdMKs3OVTmix
Tm5E3H1tcTmE0aHaoHWr2mWgIkECdVuYX5q7nuQJCeUQaq1Qsc/zTStUHouMGVJ1jg8be595QQD2mSyi
qb6bM06ZxL/DnQUUqQduLLHyrCsYWGsV98KO8ZyYZoPrUtwyj0VxxSa6EWmV6mWV7Y3MACTgZrze0nGy
4wSUXRFBnAWKO235f/hmrh5mS0cPlGgIcSNhoGD6+Y1vgCfFQysWbB8FSv0FWeAHZeURsZLWaGopQF2n
FY7xPGWRTGwrJKQ/7j3sv5fHlUs2aRwUZnTREt8YRrrASzBoPNtfymyBl1cASu/9rANFy2Xn4PbbderU
/xWg9YeV6pbPps7bsfqN7Wq3Oa05EjbylaHQrnHwwk2v08wl/a2JCeiwQGOWvIiV0kUqojXdtyaH9P5Q
ub1kvt7ex2mTzhydryfLW2CVXlBnoDj6Bmcu0cKXHRF09inVSdqRZMQAZheIcjb/CzXO0X/WAFtGyFwJ
vo78h5aKlc3xBs2VSDXbnsjfcLgFw/0S0yOpisj5GEhSq1mpAIq+UGbdSRMZxzst2jAWPh0UdDCsDlgk
UWhhClaqHC9UtInzttXrBp6x4UDOtyRpn/kls80e6+YjRMvEu0byeunPt45OBigTkMD0P3TKuu2CGqtr
hbJjzYypZr1TFt6RraVD9ciXhjaJYxUmnZo+bxj3OzfVbyVL1uzOONakFYg0VYDm6LJGPAKj+sefrH0i
NNgONfJh3OxxykWiMqDv6ckbFLQiliB/nBz6Qjxpnh5Ee2V5obQ3fT4/KSRDj11/au2hW9jc3aiRxZ4p
JaTJ4GUPhcsrwQ2GClchnQ5KHyUiFqAM4zVEY7gs//Zrk1fJNeDoONSxHKhfc1+vOPEBRby3xYrnEWfP
XAVexi69R+WMmYJpRxa1OwApMpfLBHXtfjzJei83P7ddueLFw3XM98QGqxlCdxYXjDJrjQx0W94OdmzB
E7CmKt/rIKf5ZhTlzNBmLzlRMfSfZSGlSTZqeWfMN8xbghxn40A3BcgYOJWAOPOqf0ehMnNbBlbF1S2b
hZM3UcanQe6SZ1HRRkJBs0sn/nFE0UhWm5dWSrTU7wE8FT3oNLi44Gof2fmtCjyRToFMpu5Q+PGL+0xs
pACcAudu3o/5/d8Gwm/QeOtrxtUXKpk6zIAhXOljOnv1FmGqW0iFNT09W6uXHz0zV0/xEeoO6Vyd70RP
LBFckW9cU4lUuNBVbKwuPsPiQE7+3qiSG2uAqD6Hy1hHM5FPVJhGcKrc9penfBsRh5EwJPaUGEtW88nK
Cr8ecnJ3Zxi5llLuGP85xWXGhW/3SRX/eacnyKIofW2XVELRAYW+oQ+akVN/Bad+65QR3BtbWpMtVGTK
hNK9yQ0F57FrMkPUaq16eaGsbBGKsaY0HFpHI/wcn5CL3UE23SERhDR/GagY6DKIp5rP57CmQYZIoXG2
hEk2j85Tthffu4KY6fLxZalGhvAAPZ/7+PlSx7RCnmqgWzWJ6hnEhVUxlCp4PJH4ZGSUQqh1OVJiq+Ns
U9cwVF0RrFG7S51YBoHVoGucI1CRcCI4/amQCym8KaLRiQCHs5Ci/GzFm1AB25n3geJ4ckrDh4+3YuI+
6j4EQdlN1YEdtdPgQuGe5Nj/53pfDbYlNwGUIts2T5sVgL1103O0+xS/rs1S+7L+sClAdWbnvi+1HMVg
+9817Fn+Aj+r1QjA03UMv0/fGHJX03u6TMh7U/xbYUYs5xbHJ3CFymyOnT5sLRBZ38EAWjh/CMuIZ8Dv
EsYWwhylsNzHOnAjpEckLXmQHEyGO4sGwTnEDFT0KIQt9Vx2LyqMTnUkCZySpiUMc1cAKesD0hBru0uA
BoDplFS0orJvTf6ZWT6O84Mjd+fQ8Ar/Gjl9Xk+yNR5HwFmdC+uEwLrTNMeK6Jd0ZwNjDs7Gn2UMmAmi
2KVTlhZ2XDs7pLCwE/SufrIXH4lUmv0UQMrTi1zmEsFZo3bIlEzp6NUlAlJmlqiCddoBX/AFKQH2IX3B
EsPQlD6gGjmR5sE/C627Y42PyQh421JHg368Fdn1AJCIHR7RR/1FGJP2l6StKrhZ54Al0/iKcjrVJQws
/7huUirc6I58ivJ3Prm7DgHhtv/a1d6UBjdFMwxNUDbrbbVjbvSB7e/CEJDm4KQFWvj6ScbGZjiszLH3
FZTlsY3piuFxrS/tL42RSeagIiH/R58GYUb/hByyEa1QrjXgnDn+l3Epj9uz8rugXq/PJY1l6cN8J4/+
ZYez4Rnv5ybvzvbT5dkDi6liu14qcxP0PtQuoPSxywHA2RrY7wverV4sVH1wjPCUDCZKXIJ+mrpQ2YZB
WcH2lSiodn5GfGOtPa16wRC7jO8mMZQ2+12gE2TUSLPu8KtA2b3Ark4EuZKj2q1D5TXVUfRGd3RDjVhI
ksQrj2t7B9QOpGp1/rz5Ma5i+ad2Y2U6muk8orteFkJeLoxJvNf7Ktk1FnAPrrcoHHL7XNgWZJBtHcuq
lCoNcTFI1ErdhjosI1AwdOlKB9KKpZALmebnuussrihY4C8wo1mJbcdqKlKs0GFrYxw3UrPGtmsWCuiq
NhkxZ2SZaELVCwqiRRvJrfkmVttotyKbvO55AX9fKBKCT0lEU5Z1gTxUOFkea0Ie1v6a0bYy7KZCHYsc
3jBlt6gKmz2NKTkSNmxY/qRV4hA6IxT1tvaGxkBlzasgH/mdSiOp5kAmrr7m2VhTZCuqtdYmG5xuzRMD
XyaA+1//aIEBemPfEndbd4051R7qUoiKiU36FMjnhR6I7jUn/GLtDenjaZ337GJEGtA68tOQC2UbKrd1
qV8lXw7quG5zbeOB5z0DgWslCsVhOviQ69CKM75aoTLMT5h1XFa60fPMUjsqzySngpDMhDmsvPzeEpM8
cDb87bYFy/iWhpLPu8y/W6yluWT06M2hHPbuEg9cX+/OCG/26wXOFfsYcG1RUzwBTZ9JeSHlaDrCIKun
VOfwLo7kW/Nk7ykDlcXDVLW2sXqSU+sxg7Bu04EEsK1FPxwqQpIUZwVOOa4+bjoLGM5S7FsfcVpQwwbD
eFM6ffKX9X4X10Lai34W9ppBvdiD39BDX8E9EKqoN+0LZTz2l6nXa0I82RvJ0Exxp63VNoW/V08bqSKr
SDmlNnD/EsMxbh83d1Q/p0OJai1h9qdH2eXs9uv2j6bYq/OF5TiFHRwA/2URvMup1B41KjSQULLb9JLy
h7VU0rK5dF3MyXLzxpZnyUYhF0OzFvs4waabqJ3mzKU55rPD3XhPrbGfu5r97DlhwSuMAwh52NiSFrwQ
Ew3rrD14eVZw0XXkrGnH02zXMxEn+t1U5afRWFla2AjvB7yc4omPHlmiC1k7pM2V/S2/xxQzFYU888su
+fYZ7o/Bps9Te+nn1Q8JHHJiwLbfSMdMswS878tPQGtb4NlB72htGG6qZShO0sDWYuwPM9gE5Cao6kyt
sBJ2o8aoGAtbH0auZm8CRmgxditfQhIYV0njbDA3NblGGq2Q7raodzNmuzDtJj1TBRmqg4jU3+0Xlw83
Ha/DLx1rD4brJB08TLmcLH5PHS/oooON3pa2en/S7ZYv9xA/Iy1s2/lajW4JpoFrqb97XotnShS7rb66
/L6q6Gfa/mxLPxwbuvzqsL6SHuxRZeL/VNm47QICHjhrPO/TMU+sXoB+j6B+7N+KUcTLRCMHkEJGUbB2
nrlodeACUY1GRVRCZShxjLewlGJMAGJ/1BvitZ8nTawSUgtjY0iJwMCgc6Af/2Q2EqYEUswlii02AXnr
gC8lQQS2hFtUluMyPRD5h9mBdqNbzK5mD3/DoO3AzceM9vX1WQjqQC7oTsOsvR2Kl1P+S0i2g5mZ2Ocg
vXyN5uN2wKowRfCfW7Z5vDyN5kxPsyidFWwc3FV3G3WcpiAoTHbc9a/iccSJkrndBaJBJZTmpJgMdb3w
COVWg3RDXL6bfqoevaz8EI0Iq7Kvydn1/Pxm8WtdFQ5CpNLG+fpXkvrvASKuJ7wcnIxZ2S3BHEz0MaPC
nxgLEAeS5Wb2+Ux06LmaQsMB/lGU6cTfCGo6NptnLi5cUuifVurfHrdUZheKSGjtmG7ZCkAGKt+hpW8V
5K/LUQRJlSj8y4kdZv6+/Mb0d9z/w8lZRMXZtOsaggV3DRrcCd54CBKCuzs0rsFdgjYuwaGx4NA4QQON
B9fGpdEECU6wPt/37z0558z+93lX3XWtZ9WkalA1umqtT8A3idAVTxF1SZ4jJQqw2kff1hPaH9au+J3U
BzPoAMiSbU2HDNC0nGfO8GBDgI+UAEfNzSbb9fun5rAUerHcxoPeKqNckGoSX1fsqX6n3FBCeIorzOVc
H33QjS/p2wIO1W/99ex3sZvuMx5DgnEVf4MaCtlHf3oQYJUkZN4rTJAPlvgmi0wgZ8Xh7Rarmiv9uor2
BiXQCks2cRGb9gX7vwP47luw3qVUuc3WwrbjZY39fS+UnVZfBZpaxbQbbseQvRzH3XAqORwD1JryKWjC
VRAPA8ftk2RfuQ8lTQV4KQwhsHo9mogKpz/rO9PSlqadKibLbXG4MZ1PaZpIzZsuVBS/vbbEnEJkkjGL
RjZ+SuO2bPRvc6D6oFSyWVKpOn9LPKldbIqRIhiEzzhwUGs9OOA/LDmvqHfRPUAPpppkns1flepmiAs1
oGnNJSe6rRwzZlipXQCcyspLWWPE8drn0FpOj/qHcBOVFbi8cR3D96nnsO2Vyj91Z0nJfkBSpmMrSN+V
gpFFK9XjH7YkBM+mCX5gEXL+QZ2xax3SMDRh2yki5XN1R5fdXCLUuLpGmwkN9R9jUjoV2LVTnuWVy8IB
rmVViO0V2Wo72Yb2sxnK5dkXAp1sl8kDsfrDW+3a6njNN7o6AEzeNyINv0ZJm9c+oATrYcRF9VGkfCcs
xF+t9b3CK93gMMLyncTIQVkSQiTU/5RzfJamoRyKnpRLYWPmpIiMr9rUEeTJNQyyc8BBO7F9TldAdlBC
w42hXhvfiJiV1MsiVHj4pxFykb1JPJyNwlDnkmtvVd5uZOVn4SY+mV5R+N0zVkHxA3+bDFRKWTSey+Vr
8f7iTiQ6X+sUD5Sc+4HRnKulBLLw5XTUFNyE3rQS7JplU5LpSZuhCnMo/ZpUkS1nQPzjSGjW6OMQD8db
vEogSNFh2gHn2j4xRVTTKV4HiTQt+HvEu7LZt3W9gAo/PLEuEKrxLT2D/by+RE2rqFgCbjxHJqagx4wY
lKJZ8Sc5FybZiYRccFpYTdyDqYxnZ2V6e068zpbOq9dhCdqvbMJD5ZnCoPJw82KyRDZa+qle8JDjnGA3
jvCmI1MYmJCerN8RZTNsEb0cSJ5/ZU3zjcgeHJ0kKZLDgbsgQ0Xymwlgl09FhQZDgesA2kiVPdnweWb9
B3FNmqqW+khUX3mZIzGwaWec4q0OawzGcduREAZrPkrwzMrRnb6dUWT2t6dl8LFp0jq5YKBpQZkKid5P
aFH+glJjiitR0N4pHfl22NL9g5yy8qHrni2FgIuKEw4elRj9QA+uAp4UW8lAEDXeq6jNxOyMjZa+tjdr
gRaNBpm7FvJbi1L4NDTiQ9pgUQNBarnxARKMaTnqoHSPjxpHQuiqQrsyxgTk0w6DxR/DR6THMzvktHoX
Tqmw3VmsGtNmCSFLjnImDzrlEHH8TLQajCwmCy1ncaWu1QcuYBDGcU2/i1Cx6H6CEaly4nYLr8FpZrrj
7pelyNmltuxOmIzXalvXy8NWvxOaXwGJGQEffRCXVwGkg9AMdE68PalkgjLh7cdJlRIgsEkcaXz+t3Kx
wDdh+UxYnTvx62+02YmFiJOxG2uDmfs/j+eSEfIJpHVlmjUmC78oWonP83U4fantG4ZmHSGDMyAAZu69
jr2GzSg9mX0Vs7bj7TbwxI8Zns5w7ZV+R6dgAJm7TL1jQTJkUF4Mfn3MeO7gnZ2YUt3GqDgMD0E4+VnD
/yggaP32WbgO6z4IIm/upjJStZxLS1CuvqVvukb4rioAvrQKTxFbMsck26uExSIlTzjTnwLDMi/L+pV/
Y0dO0GubJ1WtYXBirBtVWGtg2KwuUshVySRWGt1Gv43HqtiHWct+YTXH4DGPNApcMC5HJ6eU9yOoj3+A
PPBJoTvLMvAsXpmhvPeNRXAQDyXQxRy8iWBuzFEoe0c5sFzL/CFD4ujCd1cFbSCMm/z9z47ksZvwHeDR
Z/IHfnBceP3Q6+FlFX6lc2GKCWAzFGhbMGgpPPZreizLUI8vr4DsJexhx4qc029B3mzM0XN1BVui5KPf
Ze2kg0BXgrR+aOeSdtHPDNcQCniOSs78MXAg15lLCGuuG48AtPmw0OZI3Emydz0hN8TMMWl0qEkxJysV
H5WyYB1lWNTij1rOnuTG0rD4Nh2aNE5pJ/GAV6+ic4T0rmBr7uiO28xixddeQ6bU+YOqTKyDrd5vd7Hj
EirUH0S4bTm6V3tMmvso6SeAUHpqBwf5OvLrSFE9bmsh0Bh10tDxLPhjj8vN298Z4MCNlogtWawrUuIW
R5ki1Z/1Nbo60h22mhezvqNFY8OPozuPC6yCX0UDd27uliiuO23PJRxZnM61Xe6q8FWrXACtesnzcnRz
Ow617rPVnpByVIOS8M6Y6lv6lkP/5qEdr8CWTwrfMZMISi2au+QOvgiJ1W4a7Mrpil3uB/L0BU3HgbzW
/R4u0QHRvRrkRyEOPdjtlb7uYHz/DHvCIsxrtAcvMRGxlOBO9UYW7Akul1P8mm7o+GNdvXXI5St/QgHK
RmMW4Sxvo4W7DrIThQRn/jbmn9SHLwXpZ4i7DRNlBkH1jkBysqqa5rEcuK8d/syfhZ1SN9WOu0R3t5Mu
Q6ipcTGukfWnmSNnw+6ej268u6fl7B2RlGI7B5Inv3hrrnwa24XXn7p+Ja8sdi363yVPji4VbUX5lU4v
mY+YVFshzYJv3t5pTgRfL0l1e7vzH3gyDDFLGBiuvv4xHPlGpHlrN2nd94/UZSn6JWJtpcFV4pbFEnEh
vZPgKE1LfUz8Y2fshQbsZ/OeZ3QJXaONVuJRF+/8VsRTDeVdPIYILdM5UtBd70jI7yO65lyc9Isc6qdm
sFIOZCqyoq0oR0+KsgbmocZZPZJLJ5D6F2Phy8Pz/klhI+4ew5T3NemuVgNLYPU6sfW8E3/jRw8ox0Q5
Tj2tAsVHRpqPQQfRjMbC8dfhRBInOU2th4jwp3dahHtlZwxGnw4F48+aVlidzBhUy7Y/v7Yxepck5soV
5xdTxvjjIhPiuwzLN81m1+M62928ja4ikLjFITuqyfuw/pd0PBTagiiMOYBPWmlIo74uIJFlpSC1Lf38
ym9nVdalrCA+J41QzmKF4/Fm+N4bzJQSQlImh/yztMPjx4Jvw8q3EDyGvMBnIRv4jeOuSCJBb32v72Qi
kgWmmmuHmct+YeXCQfzsNhgyrpIvxdnYipwt98EOLZFDNn7BYdeBDbTQL4rAvEl56FYD7xKrrxs8SuPF
PzD0xBL9Pqq53lM1H7nD7FHayPAhnxWitD8Et3wGK1l7FY/TDHruEbmNL40domIJwMOpO2XETEenYc8j
X8vVftC3sV1YOABqD5iZID6j/KlT9zJqn4Cq7If2el0Kh5PViSUVUcWcuILo4q8gAWlYjKtSHVqWSZHz
DiP9x34wlbA+Qj9mJqtCRUyQ7LieMdLzB8hHNYX3dGzcS24scDadsIcsDWr7FnNJWCyUmVRMWIzs/nqB
Co80F9/uWz7/dx+ZeYJ+k9mHdhrTfs4AhBh/wJcDPFZQi9NQdt4L/fDXqcitQIX2qpYpmIh1Wcke9gGk
R0nJ9Rs+iMuwABBkYjN2MFfFuGB0ZFTFidtDINWJpf3WkNtel1IQvhiTiOs3dTxnLePawORI86Y1TV0D
8GkQ+1qAwbLVy/i+1BXjoSSA8AzPYqnvm/kc7WxpwLx9Jyb66s+Tdgc5/CtP/B4VeOCN2W1r5wmlkakw
dw/QUY10JV55XqpZWdgSYZewmF017NqopWiZzEIr/zz2czVP49wu9Y9V65Qfvv+pEmTIWQ+h/iZ6RiFc
D3vDFbf6HJ3oBHmV9o2TheN5Xii4UC7Q4unzu4zkh0T0G6zVZDfbQUYz9qlEwVths4E9vg/RCowuAGZ9
7mY9jNUul5ymPkB45gF7kN6AX5PTG5YuKmN7bfg/F33F9G0qBIM7q0Ip5IeUoHu8Mr5rDGDhVwEqW7eo
DB4GWbpm7lgeLurCJAilmhtisGEizr/xlcm32jit7Xg+rp8L0OEUhDygFgP9ReZp9/ynce0CQru24Mwq
PT/RElaQD2xSWWlwwurFucmZ16JrJ9+QyUlYuh89LeEitf9mlC869IljjwjW8N0VqmjLjnxUVsJUlNLC
9XlGDb9kVtDoO5JXjrf8TZJVXQcyNp82+Yx1pYaDvhP6JCx/fOVXsdXGOl1dfrBPuajweaoxXbiHxzue
F4YXhiAFiPjEmCWPSPq1ZT8rAZ+qVpRlxDFUbfdt6k7glDii4s6cLk7iLVbhuV+AqbEPrbgvyN4raHP2
NCT7MfiQxpdG4vwpMLpkz9J31aMrkrw9P9D5kKxx5LFkhE1K4l073XJ7wqY5ZhE8t9g/kNX2E+M1Mq+q
vTnQIqI17jHtdMUwwz47V4P+76YlD2iC8/hGU5Cz/3eeUvQYwbFTKjOvTyx6ovTkiDXephITxvfsG2Z9
V7Oca0JZHp+PbDbdOyl3j5szePzdka4UkUN1DW7iz4018QJdEwcn792m3vMbbm4SpXSrTpIp6z1XMR4O
+fidpGuFJV++O6btQ9Cyo+chV1lh5S/M88ivrZboKQe/WNG6g2lDWYnF7xTK5QSjJE2Z60CSwXH8wQEj
iusiruBk+EznlL4PTbF62XDor4OSs8+VG1AV8dWWX4Q+bkmfxH8y/FJdetBxwA6/RU0NgPcZgfJMgmti
q9BbZGNDSG5oJqkbyt0hGIL1JSwsUsqfzqtiekggjs7hZ+rui6eF9eihEZV/if/8DS4BSaGAmTeXir0Z
wY/9X22Mu/T2AFWJtNGrEkcSEw6mz7gAL7YIsfDgo8y6E+Taduq8Zt3ignQ2qDUvBzjvJUPAk6JBw+VP
0iJVoBCDQs+W/GTxHYJILVw9htiUX1CYni45/QUcTmylU4wn/XAdIabwhBqUK2OcJ4CWt1QFY/JyvvUv
P9CgyQretPh8Yq2AQUGhEHNUxEpN+sukyv5gWQ6HbY8khIOD5cdZ5HdB0tttHVjesGXWMxyiLNUzPeRh
KRJb6OppEuvNLk6oc7Nj6ue3XF8lwahdD/Cm1uJNxB5qhpW8e093UwrdXELqai+8SG41nOVo43Fjbj0U
Psp2mEYW43m6Pp6niDljkuD5DR6kwXhTdnF72/uy57N77LTVK+mf7xDukbK4tly/0UtlDFQtxPcwOhfz
JxH7liRrB6VObvvGMhFj0HR6XgD3oFqLC13H6euKnY0cH5lyvw4VGMbssNdVZweOkTivfrOar7e+6tbH
Eo5hbJSjKTrsebHQ7igX+ntBMdS4pPuCGhR/uDsohcxfKojoSsL5BSX+gzn71KoGvBOV2lFhX8Iz0v3S
RCdEnvImPQNTewWu1MxHRmDjjb4wjnqHtgckrsPG3r0aTqGzvgk5z56cM9NdNRVk54ykvIW/SmUXstSk
sJ81q50XlfK3oXCSVMNgip/7iB4dn6Rc8jn+8ImzID2T/bJBdoSK/CMHk8NrB8+tHIIlPfve7wQ3Eej2
o1oVH/zmrGkI4Z0xSblaZtvmICh0NuaZveQ+f2Wsa59lHKefQM8QZpqgH1qbu9Bwv/6YIJya39Gj1ktQ
3vbhWm6qa6YjzXe3QnwO7f3PZ/jfHrF6bjDxSZXlm8kwYFgcSDUHHTkj+4s7dv70V2P7ODVlCq4JMnKx
qEwZshrNPS6pZR1q38E2P4dPNN56Vuk8dFIGPkUrxwfs7600C+gtnwHjTdIRehULMhnDXJ1immGslbJf
ps/6Fy9QyzC3nxQKKv2s5oIocclO6ZZ+hfyZjXwCPSldr2BlzeOI/DLVO8muspqr7i7FBZIJzy060qJN
/iWG/hCUcpJPazQPZU+orn6Dk5FGWgTcTrAIQqXz6kxutFc3bQM91qopBfLTKzILxAqTLFxkyzTzMTWc
0MuBLMR5jF/QKXuOc1kLO1g2Fm/Wmc0fmMWboifAZCL+oUP7oxjqoX8yrOGLfX70Fp+dtc7n6TBWwt48
PEFxvH/H4BefKb4hj0EGvrOfodYjwRPo36uNs7AfI0aKigvKDLqYcGKNKAbwslGb6/LihZT7Tc5r0/cL
RR597ySPDO5HisQGHykoJVnMa6R9gCbkYwJzHvqJ7+l6vxRlbmxsdFXdWVR1NuidB3A/qYVv4TrhwS8e
bGpVxmyx3z6BK0X8S0TLvHCCiIBQ07WiHV4DwR7s87QzY69wgLj7M3s/b6H/PmMttPvo1a1MSM/eJXcn
fe1LZVeeDZSc61LRaOqN2E3zsDZP4N6nzbFmcj4EPk9RHNH/+hQtbNxNHhDa6hJ9k/ro/l9xZQijryTy
A/ge+hYRgFpfQ+YwEzx0lhQ2JHsB7JX/XZN5v/WKpe7FFNjzE4nkPfIVcpw4uvI/vfV+cH9TeDgyZsUP
mIokDk4t0etcD2KCrnd8fOtfdodkpLBTbsNm6AGVL8QJ5jIniCJ64DMCRygdP3aIwfHlPMyCpMvSgCy2
Gew4RBhAUQYWZMwAIue+w6iOIRzAaDacuS6+x8aIzvF/pTRBwnAbypmiN1h/h3CuDMmGkbD1kYACsv/S
aNxi6ohTeoN9zlCb0MIEBfBwrlix0/re3+MQ2NFfZIJ3kOCHKBuBFPGH1pjkGusSr+ZcZVaxPmIzDMRo
4k9Om8lwxZdloXAUvh5UkZnAIrWTH8DhUqS/5QvrR7zBQcb5isMadqxIwzb85RXhNku2zXsiQjsZNHYL
YjT6WsRnDYaPhwh1hDTyPgeyFlV90L/7ZTETMSAYzXxPX4pcimGNZI0N5xj+nIDInsgG8hVYBozUQk+g
T1HlsUJRicmqcZNRp4Rd+I/ot+TU2qK4osSiFe4eHt/dvd174Hjwwh/PCSNJdigNOG6U5xxSnL2ovTy9
4k8iqEGoYqj1mJeY1ZhqhESEnwg6mblY1lkHGNOYmpR1VL3SDNJg3B50F8IX5ERkRKpEj0zeTHYfX1Iv
06pTV1m8VX/FtcS2hLcUeeVdCx9jzJnb3NuU2Hwd7U4XSpNkYqVfZr5T2FQNCX9C/quI5YxlhOWK5Y9F
TCLFDmSn1fTUEis2qehWk5ezTRsX0CVcxFsEVOfpbFXJV3lXnmoHFk9VFJaHqEFlGeWtY77lHJDWSdSJ
rFKu5rWEHnccTcxsVDyq8Kq6pW3yBnOiYEa6RDtGe0dnJYgm+FCwUqjzpfIb2oxb5QI7p1UmuIadQYAs
/4i/VFfSZMhkxlzMXIxcFYZmjWmQ+GbH5k5gnbWpVfD0cD8L9CCpDnSKJY4sjt8l6XN+gntiB+ADMIk6
e+h4nrg/bS/sXUO/Q//mgRKVI35KIGkOxJ7+j3l0DSnvf7yvSK/+4VdIZP9RJ/7HSeq3Wqc1qTYgQ5FP
JkiUSKUkerfdD8Klfzsw5keAiFOYLdVhy5SNq9MhKhqw+7M7FKlYJLMFrfhjkW9KxjTaT+Hg43v7O6i5
WRtpYgeNapA3CW2K0H6WYpnzLMAASnRGsvQOhBHFCIM2D2ju/an6g+raWjuQPuqojqXOUNzDSc34ouFH
BXroHhAYpIyCD9ph9b0tvpPsZqjairG0X3VtN/XlatjP+7o8yCLRMjskRA2rZAwLV0wSTPtoGVU50I7u
4x5Otmx6KT4YsRU2No5uIjWcEsHrq1uvW08zlWXjenFwyFYc61IYEItCna5f9hVEFfMhOE9ScW+tw1I+
P83KTiuAfftLRdaKPkXNjbaDv9zvdryE1F5tf/yic8mcfkhF2sLRaW+NNz+KQdoWpVe2AdxEJr0a1xFL
LVHXwzMqLs8gk3Fkfd4AAeceCa26WNSQYukyDdkXDhYfb52ulpkMhWccN8kellDh8K/o59w+l+ekjgrE
dE/wT3PxRyKsD7ATx2Kj/j0Dl0Xd5QxbJIWdlTCL8I2Nus99V0uw11crGxuv4sPYOHx8//ksfX1HwqUH
isD3k7cTd3tmAk5A6el+IScxa7HS6S1sMflDRKG0OM0wX5tAm0CjQJwH14AfC4QN1CiqDGEizhnU4prk
51r7C9o3KCQ1SM00yNE1yFw0KBAySG81yPM2yLoxKMKFpSTCslVhGf+8r7lhaXVHRFgBGToLgi3XK7ku
sK+nsEIaWOrYySDJN36LLwUrUaYriRsrkZIroJ6VmOCV5GdAGAogNhLw5QMgAQqIYATElwKirQFJcEA4
MSDOQcUOnfUzlgAg03ACiFfxLmseEOmfP2aYPxk0tWMyBQ/i2Zbl2bXi2dHigXvWb3+q33Ws3zGqhwe4
biu47gJdd/Rc4T5n22pnu65nO2Zn8BDa7fe0u5a0O5q0cI/CbaXCXYfCHcNCuL/ZtrzZrq3Zjq6ZNXLD
FbrbJZnbFd75Je35FTLdJSHdFWbRJWXRFZr5Jan5Fe7WJc3WFYr0JbH0FXbf5Zu+q5F7B4HD6ZxCzCvg
5JFPl3aM+PfHczLsLXc4mes098Z43cawy0avuH/H0Kh7TapHpP9nu+TeSoVvCa6nlonmjp2ldLR+ceFZ
FP8MMfgSQds7KPh0fvfgvHonVh8r1nIn3lurf/4GiD6M84T0FiswqmfAzPJf/L3y/xfnaebtp8Dynjkz
h4YW/dV/kSMws2fczLahSX+l5kT3P7hq5lLRpr1Wdbrg4yjeWrCqZl1xYZbYM2xm3dC4DHM6EbqlCqzr
WTJzamhdXnU6bb01+g9u/V8VCgOdlT4eSUHptgbq1lefzwPrxLsVr+meFRGzof99bCjezQZ7/b9R0VaB
OJJ+SH4p/W8C8f187RhfHBsh+YI8YSog04GMiIIgJyIpQ15rGDQiIycZNiqgcxowQAgMlSEkWv9Mwgxp
IOicJgaGEBLOf72xWgcG9UhI/ycAAP//XKPBzhhbAAA=
`,
},
"/img/tsaf-logo-mark-noborder.svg": {
local: "web/static/img/tsaf-logo-mark-noborder.svg",
size: 1178,
modtime: 0,
compressed: `
H4sIAAAJbogA/7TTYW+iMBgH8Nf6KXqPuZfQFq7caagmp8ZccnczmduyvVOo0IyBKZ3It19RdJtzm3Hx
RW2b1N/z54H6vdVDgpZC5TJLOVCbABJpkIUyjTg86rn1C1Cv2/S/DS76k9vxEOXLCI2vfv/900dgYXzj
9jEeTAbo8nqEqE0xHv6HZgNirRcdjIuisAvXzlSER2q6iGWQY3MSVyfNv7DRKLVDHYKpUdGFDHXM4Scx
QWIho1jXG5MzzfkB1yGEVI4RGr4SgT5ouMxs1IqDw8xcbuZcl4ngMJdJ0kGtH7OpE7YBf+6UR3l0zpy2
t/EWUx2jkMM/RBlZjwSZ4OuRIGtvuf65A1RBHFou88TMq3iV3Ru/iKUW261Vp6RsvxI7c6WXPaLPHaKE
fDevqzpHtvAr5x32SNU9i8pOUgOpgkSgYPuwQVkvFAfPsdmur/Wn8DHqvFXZWdRdVnZIra/B6Vm/qvrV
be4+BQAA//8W1uqLmgQAAA==
`,
},
"/img/tsaf-logo-mark.png": {
local: "web/static/img/tsaf-logo-mark.png",
size: 34379,
modtime: 0,
compressed: `
H4sIAAAJbogA/8y7dVRUf9s3OgOIo4IMICU1tICAgHS3ICGgdMOANAzdKEgqKS0lLd0dSrd0h6S0dAxx
9uDvvt/nnPd57j/OOmetd9Zy3Pu7v1d9rut7hc4OfqUog33/8X0QCIQt+0JSBQRCh6H+QDCBlRk7zLfA
XySOUhqOqramji6GCDhIzMTWCA6TtTY0g6vADU3c7LvhggAFjflrDUcNBXl+Y1trVkPUHlZXazsQ6iMo
4mpnaGwJd4QZwc3MbYSo9+qbqWHmJkLU6lwKzxTsJOBvzV+4I+Cq7oqvjd0tjflMqEWEYYKu/AADa7ij
IczV2srGgd9ViPqWLz9wjVpmo4bdbnG0FKL+q5SGwiuYhC0CDuNi5WIxfsbBDuPhY2Xnes7Hzv4UxvGM
nZON/RkbBx8LOzv/cx5+dm7YPx9qQBrCxJRfRVL6H1nAnRD1W0dHO342NhcXF1YXTlZbhBkbOx8fH9sz
DjYODhZgB4uDm42joSuLjQPNvzhIwh2MEeZ2jua2NjDUvaGRrZOjEDX1v0ywtvs3WxuHf2ACAGNzNbRj
Y2d9xvZfNioo/Oet1tb/3u3gqAI3/c+7HV672cHZVOAOtk4IY8BxpjQoYjt+CQTc0NEW8drW1upfKL56
a+to6/DW1g4mIQF7omBobG6Dume8JVBQ4Je1cXA0tDGGy0oKUQMrrObmJvzSXM/FeCTFJCQkn0uws0tx
inHwiktzc3FycvE+4+MQl/4XraStsZM13MbxX7Qm/4tW8n+kRcXCX2o4wtwZbiKNsLWG3drMb/7f6MIl
/uwZJy+3uIQYJ89/r8tfWpP/Rpd/aCX+R1o2QBm2/4en/7UEhA/q8t9xC9z8O/LhNkC4I4C4DiOz2ASB
3jfJSoq9dp3enrvz5Q18vmX/xnFhgxUz4HEdqZQolKDeeGdXQ+D7w+0JLS9ddWUXAlz0rNd1gWFUAe8M
6+oXDnUM9celRNdSHAZrT0/nBq/6WOtOsQY/OXgzpCwPjY/To06dAYZSwO3xA6MBX74gMOoaDePfKyAM
yH9agUD/0woU9p9WYKL/aUXU9z+t/FX078p/Vf1/X/mvqv+/NC/7Vz+UbN6c0lbdmPOVx8efFCTTGaEn
L0Yovk/TfMZFKKWmzMhagfVujtcXTGJ76klDSGA1H/ZlqRDI+LPW6/LQnL3PPWuEmPdYC18GpTZ4mm4a
3ky1LuzE9A3zY3ZfvX4bbrFTqu1hNUGRVNlptFO6OdNb95xTEKMr8murEpJd00Pnq1DHWxzSDEA93wyI
0J8XoxQ0OOeHctZIxLuTQ/yd/U+ENNhYBGDEM8HRooZmi3DmDxmkgN52WJWcyI/o4fetkw4ldtYPtYJW
cGG7pBTs0+EMFZ1j062BgyhbHb86IxbShWzGq8Rusq88Xz+IpEZr8/ohoevpk3ziquXhf+iGwk5sVHGP
tKLzzjT3ht/0oEsl1NwpB2xXr1lSQcSviGSX8bjE2UfBy3BPpESIf73lhBG89HWfXQsZmSekuCSEAzzC
fzWTlXC3SvUelCg03KGS0qFS5umeA/AgPmhaONnDwCMGZB95VqOG3K+1S+cD1vtkrXO8vQ3qY0Clrp65
UZ7aNVsCqOVm6+uqfMp79hufDtDXh73kPIHFFvGZ9dS6Ay4q1npDbwPud2z+I0WoAGexQB4/UE8m76VD
X2nxEh5l2atdJAMeqGVWGYsIl+i+9NXwreuGqe4A8Lb0dJjjxNU/mVtFk8xvIz7febiOMn1MKMN6QRof
tnbibxeI0rcGs1IXSQs2UtEi77AUKVrzQlVGIsTYux0dtDb/a6Y+9zvAwsSSh4FAHIgdv/D+VQWl+sE1
EFO+D+qWWk5YwUbU0ZUyT/YUUMzSStBn6jGCgnV+IPGAe9ZtI7Q2WkWka331iTHWnixqS0l0xY4eG1ob
GaYFDunfpWeVjQJBIPZA3AZKAPZFzKfNc1tM4KjvHrjAU5uWg5nGIjyYrisbyixsDe/6iTdotJ9OqYGH
s6JMYKOH3xuI/tKJ7EflY0B4YCjtBEounYsZiqn+Tz/z/zkL/H9w5v//M+8Zu20A6EwhtzqOFtPtpXxa
uGR+6ndho8NDPG3fOAzKy409p8mbPf+UXxxMQpLfNrUyv6W/+baZlPW1SSrkW1JWbpWsx/Pe60RTRhsr
0zRwSx+pNAVFFHFuITpaAx13l4xRhYx/leKrrXdQESVr3UUWKrCez9mNj53V+9cWW+9D6kzz1Lb8AggZ
R8bBH7g2h2g/TKfujXlzV1eyTwK6uuDtrLOQ4F5HEe4ykFNf0nL9UP8q4RWOPL9sEGpTehBrt2NPC5++
/ySnRu/kM1dP0bD7lNY0DLmZ6CoGarnnKSSUFdqvXid5WcX6Ymj8Xt7Q9dLyqv3sIMnvPbhP24ebff6s
vCyFk9jnL8KqHnaxWkYURLlPqQ09OS4sbHgCiFfHXd2iuzJCy3LRSXMMfRBxZqefc0nxS2x+mkbjIvP6
JjXmNVf3eAP/lMYrBsv7FnRxMDDIi9tdUDBTJj71aGj8jlCFTA6xz/4p17WVIwEveSU8vzNduYymWbHq
m5OYXqHV0/w4+rAoICYK6IQm1QPo7/T6rsA2CqQCNaUCzrogx7+Nym/2GtuPy5z1C5/OqLOQ9jzOVNAA
g1v27+8ffP6uZYUl+zA2RVbsZMS8/4WU7GmbKHL5afDn6QtCzeZiabVvx2J6n14/r/5j9B4E7nvC1yKj
+AI78hf5ezq66YVEn8AnPkhjxAKE8Ynt56z6fBNlxUqrQqvFO5i+xmmKhY8JSZ/QqPjBRbWCrp5r5ivn
2GMrVE9R8lRUyK6lWGh+1qV7eWCZVfRBtRIIJEX9oY9BDz6XTsc56lvDl+WMWj1X+7wjTzpPGvgTUt9Q
iezlx1qoCYP+6PNjIntqnid9+TlFny5WVB6cERaGtUls5KOjOkH9oJwJfr0r5yz/DgT+SPhrmS6a/0OP
/266TOPZDIFjME6JCKvt25g7Mz2rSTsEOmxoLTtub29I8Mhh0Zw/slzkInpvvMawdKLdA2cotRGWq0n9
8LKaNDWtWj0MDEgapVPiWMLcjxV/1nTFWtefU2hXgquj87gIuWKIZtQbRn1z5tSdN9t30BdNSZ9RUHAI
80kqDkLKtxmrd5z+JEZeZWFzWKrWXsar0n3qy7yDhmH3xdXHli9Hu+bjiBr3vB6FjQhFyjT047ZRuUjs
bu7nQZ7Y7ofiGL6k/p3xbQZ81S7+tNIX7LBEf4hIrffrgi+aFKz6hWwxqRVQQ0wWKExUIJcUQ29SSIf+
5L7txOx2kZVGnUKAY1l38QzTSjQ2XZT6IDYOuCYFt1QMYX7zAilJfma7WfedVKazWxOOe9CdaHTu5oPN
yQj4+Xo0aaRVgj7bv+sD+lfap0HVm0O5NNQMzg9i0sklVracsg7ganycWSC7exZax71IKdmbh9+xOthf
8Yg1eFi9l59UZ76prwsKHRPzBXVS04zq2xA/PqTkMf9RqjzRrsP7RE5x0yj6NI6gO+rHY8w7vnR3XN16
skhwERbFdoqNQg+FotFWz9ten5sbJ3hWpEt+m2QEsDqzfTfds8ZRWbaBb7iQEb5MhL/JjKP44vOHGeZV
W8vQzJrIJA1wSZiYMhgx91MjGOcU/mxarPDlGGMfuqrfSiNcqqzGN1kFJurrs0W+y1b9Kaickj9g+SOg
yHzwu4PdYfFzuuJEMNjAwkJmlMvr68oKhSFWALrUlOfqu2j8nYn7TY3ZGky15fwQaM1x0s9WCdbNx6zr
2B+XcgMVR7Frd8njYFc8cb0eCe2zXVBfRrj/RfcOzVL8nJxMRn2AXHUNyM3asMkkdowTZncfaE8HMrPH
vdYyJWsNoPuG/qUkhgcHbSYbeD96yH3dcpPupSRR0CslJ4p7Eosmf0Vmco/HOavmCJQf3AGj8QyLcIim
iNBp1jFgcBBjqhy2iwgxanYwfHhGDPrCOtmrukuJx6yOFWr4zYmGB1SZroYfK8hPPS88JyTq27KaJ6Qb
brmPS7HdasD7LpFx64R9H2Gc+gTJaAdaxMoTEz64PKMlGWrvMODtbqkwcLM3Kst0MCHDgOjETE82FupX
eCkR5ejwLeQ10qxE4u7jLbWrg0HGecEyKSkRTxmH5Kt3rSyyS/Pwo7c5w8EAVch01xvSeoZTLLNn8iai
WiXy5Em0pdd9suAWYmO896vBqlE7+CYtZO+vGlcig7s5GD9kKMNEF6mpPRtMemSDTz7pxivlaPi4ra3Q
yt5b+cwLuuDnZBn1jrMpOn32Szr9JGrWUfyLzmwM+QeYqIE9u/f8gT8h5YY92TTX8dajTWYlhRdRRwa7
rWiilESOD+MspTs4oPQu+4tva5lohoUFSABAovbZ4VZfM9vtwooJcmXBKbx8shzibo0g3nGCacwduEQG
CSSU10M00+srHjWG++LKy9/0PafVZ3ZZfHPMTJtZBV8VtbRmMgsr3wgKCu3o9xtyiwQHQRDBzRn8DMjv
pfcOzpSQJjJONLYmoJ1sxQ0+9Zk0J4LjYwUVPT02rmklazjM2tpInxLjwu2lRm4zBkZdR+SKbGNrlqb2
QmN9ejwPOwQan1q3tjzEfi82NDwggHCqTEi/yoSgu+gLXjdzUdRlmVZ3/rc4PGspVR9/gSCka4jkBVLO
qqS5LfCOnKdkSWaW5IvqoyfdvwkZvouNk4Q+YxGnIE19gjMwz+Cxlegqgc5rs+54vzx12JgLechksjzu
OdWUr3FicSPUXCF9wGSZlZYtxvRYO+zspvLcXVY+LZXWH/OFlWsEbecHWffAFxtjLGpR0YVOXu0rTbgq
C7NMPgsqPUkkGJA+5pZeVYrH5GzkLHbTMffD6Jide8sqPeCHu9Tdfcxx37Jjl92L6AsVDixJd8KdPsQ0
X/0qW/A+c3N7URz/amOMSg7zRDFqqJVfLqh7Xac6NSxLqutKZDf6R4Dp/CTouuJeN3ctwvUjnffEnIfc
ahxdPa3DlrdmnCpTPfNWGLKWqVI0z6oghny1ktpDrkKk+/xU5OXDk2hvRuXh/JcFH0mGZIcFpBO8rQYo
ieneTF8gOoruz4/aQcK5nWZ/LgFNqgcpWxafq7trl0TrkskLhsN5eH1dttja5Re6B7E7UfouhC9q8bmL
/BqE4G/lMr88e6agKFKb5B+YdHpUSH7udPDnUidP+McQZU0cMDCdkGpSDLSPuMjBHR74YSCF6CgE+bpH
y3XhNl0xUw+qer8q1JaV1vQwNktMBMFIYiKf4Cv+pva7YEhyLtCqZCkkWlvr+XH5eH6W/s8OXPepl/1D
MFqgClFBXtJMwlBZjMdK7xTpak5/rYyQp02mKJsSyQif2gDxhG6HOTNMCX8+3X5s18INYZ9ShbaUgYmG
IZNjOpLEwa4pjtYgf1of83m0K27BJkLzpUtXwFcm1SsbJml6nJdxDvTHUTW8hztd+ZZWMQzeswykvVtu
0fgwDAjYKGqCaoye52MY59je6OgoE1DxEgfXbaK4ztdEHL9QED4h+jKpwCpYXryhOJQYo8m0Z0dFDYGS
ScWHxzXwUmku/eh3ojqJtf5wcMqm3lvgxKcyZ7VLU3etl4KwCJes3d72Hq5W/5rnXT38jb52PbDxS+JL
34oHE74tVO4B571jNH2c1fX3wzf0C2NwzIrj5mLGp1QzBoi8N7e4DubDSVeGh+ZWQh7cDek3DbM0B0Y7
Ks2sYw6R6kQeQd9WlZxf80JPx1/vl9q/bGo47Eace894l/YkZFr8iGab2IshIT3pqTnSqN398Z2jxDaK
0bs6CEpZ62LyRZBXRD2Rl+khGsYAHtDKuYSHcfa7NXE2zTyx9a68qA69efqtpEhWb5za5OKHNaLfXw9x
fge9vbPzvHqn1lDyy4pnautRA+jh1sEu7jAb1+Sj5t75RjjHzpUUh8OhcOkmndVmXWhq2X2T3VFNhNyE
a+1WYuQwY/85UaGLEuTz1oVkd1KCVMOGvacAMzFaRWCd2JC1hBEd/+i5R/24dVfMy70z8d1Lg/Ss5eVX
bpWfOOAdFnzIcSX49x/kijdeqP5kV9n+JGEAtPjKLwNdwb44nH/H43C12idG9vRatWn67dzZmVeQZzWX
Ev3CTZbgVY9g3jcLu4s9R7liOz524XgeYQiUeK8gjHtj4XutvqgF/HB268HKJWO5ydA8XhyZmVP6yljx
QGSz4pWe3MtkAXRZxOdmnTnmKB4RXx/VU++6doycX6x6VdoDjYcP3KwHspdTVOb6LBK1V+c+zKwWzOT0
NuiXfblG6uQ0ru1ff5FHR8PAlMPZj34ZwOvi7eI0uvy+vini5twt/3lFzUltrgXOJJHlaReJi/fuEcFg
m94vDmruIBwwCBn5J+lu+2Qxth2hk1JO3sha9ypbf6xC+xtWkTUBps2V6Yn1ntbBgdhprfVkPMsHf6Jm
Ajqmi6/AEOjvAW1kWa2TRsGZm8Dey/XG8LjedtXmmGOpNzZcJx75pCt1PGs9o3HrcuX4ZohaQ9ePXlWk
oN2dlRWDnHmkeWeRUe1Z0eDqldRMe7KNeqaz3JXxqg3fzQDbNtG0wMviFRgfZ3/HXaAUHrnYuMc7hjgN
bMtvzk7UUyTBU1m+ZU8J2YblqJXtsQ1EMe9dxa2sCzC0jCYPF2+25mn4CqhGR+gIP5k2773xHlCrXYws
hjs1IefTtedE95cYmiPZzKztpvfsIk8oXmD9+YUORsO4kMU+iHRACpi1crr41F6uXrPtEBGKmxgqBusc
tTSbtK4J5jy9ydw1PKknR7dTmjgKjf0JW9dB/9OxQNhbuMcaEXVBX+1DzkSqvTIfTjhVHOgYANJXqvU2
qLhyFPQFvWMtIoeyXDd1NDuNSp9k4fSXtGHf+ZS564A4H7WF7w4O1LKu1KWXLm11q99btAmQvNvTxdqR
6p6hKOT1O2HqYOl0a27zc36Gco5J3hbVGAnasWIQBxdVf/A9HVIIGgY/MQkRrVfys05kWcwUop9zQXMz
+700k+XbWO35RLZy71mrs7LlVq/VPsX0BogvqfIEWI/95xlSORd7qz71Uk1YszKJ6BdOLieGjYdnrGr2
ZqO8hxJGicR9DAiZ7M5qk6fvPjMZASWPYhLNnUoyU5GlkNqsN7veN+rnVtLZv3qF6239Jc85CGgWWRW3
DMqVuq0dPQHOCUkIN3CY+FzDn7VO08cUVOzpTQhnM+cX70Dv0BV230YDnbhEXC2iX8/DM1fokreuY5zb
zfMC0Rruj4H06KYTonEFg3gMDk+iDrHnSbIU6+vMelxOsC3JkvRPP3ftKBH78I9retHQdYSTA53pYhC2
PJsSX0Z1KWm8dhVBD8uIN63wNa0T7cp8M8vn8+bHHutH7HPidAmar0BxLs5xz5BXlB8db1QXequ1D4kv
Rcyvd6lrt7r3sJLLdHVp3PVO7TApMSDTtgj3XH9S3hFZMbGY2cvZ0y/OY2GQ2vWdOwED2Hs7q1REiEcY
duab8yLR7v4kdX1x8xdS15XebH4+X5oWYhmUFJLMfnN0wv3tAx2hsLeUTjVXFXod1hrTg4demwJTb5Q7
F6slzCXKZy8urRiZvnFbJWTUBchplbD54dTkOtT5y6Y128uIXPM5JDfw+XCiLyhSss5QUXqWDZesnru6
dbmRbEeggd87x8ebch7ZIT+bH5q42ZCg74GASr4yb+bzbPtPfU5gV4JuK7Fry528ZGV8jo9ITzOgeDLk
sFUrsYWeeHivPdaso54pWc0bQdQSAlNaWGh4YKB8zzMb6QdcfvgjzPzjg1PtB0vazcRVDUO6EnSJMQ8X
EfSOEPbt3zJweOMsclMnz8LCcJFcMjnRYyHpEFuAqSjsvbxRiDMUxkthjOdH12Pax8gl4EzQW36j0522
tWj7oLqn+KUzSdUwXwzATGV0IFcVu+FkudvcgS6/IPadS8mXTUy3lVW+AJa9lY/P7h0ZqeJjQK4zZec+
af6qqKrqpinui0aYNgxLqeZ3Ge9dUa+uduioczZpP3GRuavTlesPa3WW9rq6kmblnxja3jk/OB1UJy17
6nRxUvMZikkOmKh7+kpENvzBMxPNPZ8Gndi1WI7f/CoukT771saK7fexD2KV999h8S9Sd2STOrwur6iQ
Trmx4kMvKlc3LYq8ciMIeLqV6UiKDtQ0H6MP0aZ9cdLOigkNfB5C6Da+G/kuvVGrU6yV39FE9YGRYJiB
risCLnQ6zlbWnB0pNiFw9DhxNY+HkLjsaSUNJ81ouNhd8PsM1XWrsG0reV95D9v0188R6em4WlpSehdI
PCSjrftWoXVJJgbCWLxlsyPzcTmrRql7+KXlHAXmLGzBup9zO6CSIcv+Ecp13xfjRe9xG1RFt/c69xaw
1GLVvFNbV+/KudEy7iqTpr/Luej7ATWvj3XHO5zleFX0NUVjdLitjsCHRzNv0nC2iKnnKSiweIGWY7WX
uj0eu7NaWLubbE/xzzXO1g6P56iQ6HDNGbSkLMXQG480+6Z9feGyJHgLlGzgpRzjee2UvdurPHHn4cf7
Bi1ivovhH4C5tCXswpZ3IKX6DeEei2FLMqy+TE/40ipmtxeYT+Icdz8+1BiH+AHe+qNA77dDeyPg4Ucl
IxaQg5AEpqYwAwOrtDO3LZ/co4yELWIrhguT74QSYe+xZLGMSsChj2fFbj51aIrYxPb9kMOckXX+PPEY
8cjk1V3FVuBM0PyOS7s5ynupbuJQM9d98oYH1auN3lx9lvQFqWWG6XX4b/pgHI7scT+bVDw5b+ivY6Oh
bXnp7s9OSgiYH1C3WFIMJv2Y2rdiV8+oxu/As9H0kXX/Hd7acrsBOuEIj+JNsnKv2q6h2ed7Vk++RVGu
247cCBEMPmQEgv5jEbd+MGTIZfO102EGn+Y5VtW93AfQMXmTOu9u1yCsoF9LEi0WFyR2Fytx5TwcP+nZ
HXYJ0edVZ9MIMSAPM3LApCGbFakBhNlNHKEkIps+jzJlnjKTt8h5CgnRSax/aj844E9oDDaf7DeaD/Oc
2wsrspEjHsC1h8LOGm2GruvYljvf1JO8xT833/LOKzL/eepFsDwoiq6mReR/ERIe10SE5YMcMc2zWKKv
ME13xho4E7shV5n7oUnpC/q+5/hp5BTyYi1AZ0pDp1006QXcOLTvnO/lBDx3w7X2IUbJzzqYys2ntnPm
SRI4t0jx2I3ikW4GBAoYLWkREe5/d8vjqlNJxNYsrb9mWLPq5Snc0ayYyIBkzlGYvDozU5pw/RHnT/py
/mKdMoeeI2xoWJAf6Hv6sNWFUni1pyUFurV4qDOBnEN5E89XuQfrAf6+8PG7yhdFOGts892VvvSj3xpp
HxDu/DxtJNixTbUHkoJBHF72HqaRt3eMCaHas5/0r1UWTJp5QlNUEm7ISzCSquN2T280qrgD33HnrZKe
bFxcfr/Wi4Iu9oviw1reYbfZefFAicxJa1gKP5ZrFurk7MkxcEWBwAVpGQOqpcz55aHEb6O1SnM0tLSP
hfjHvnfg2qNh8Na8I07fw1y6YEGSmODPlJS/mlhX+jmvf53iuQoyjSP7tlcnqmscoas5KJr0GkjtBQuZ
exf8CSAqUWK0J8Dxwss4ZNRIcpAjfouvXd8sP9Gotxngv/+OzPluHyurxsLgRk9fI1bZ1MRd0iPsCA30
sDKgWt5pu/CY4YEeDwMzg3a898RoD2kifN3Gyywr+FeDfsvRV6cUbHskq2IzR/3OVDt/c6cGERTmex+a
fCpvO6P8hKtfB2TknFRN8Lt++BcEYnANGnLbO9q9WsUq697pmXD5Ea+h+J0apZ8y/17CfFO0kJ5aCWfO
64n18HtLJQIGF8fvBsBl5UEZv0zjsg5JHgxxj9/BgKSVnm95xG3OXsphTqEdOM4/g5wsM999diz9LjDQ
/+5GtYRccliSdv+d36Y5rJLqPKGjodVxJ8KH+0Zp96A19Qb6Xs2Qg6ll+L07cK464eb59AdpXj8ajuee
TpZXv36sXQtOJ9gePg9yDcJJSsOAzKYorAuN0MU4YZXdefRmo96Moy3VUhTE+WB/zEX31auugSf5T55+
G3epb40jVwG265WkNuljEHB9AvZ/HuMBPH+9vY8m3599aM4OJ9j+WBaCSN4bw+u78AWBBQWPvK4P6jAB
M+Q2j7HbYfpNCBDn4cGoC/zVADaEJUNl3dLpyLsY5QiMTc8nFSmMrizpsh4Jjx9rEUNadNEl161/WIQF
aAfMF8fwgMV9Qe6W5nSiBV+zpZsb9byFC+wAbhPn1Efcv9AcLzsmQo/BYLTfjcq9uNC3DQ1nPWAQ81vj
TioIVCO5P24qHDY82bahCzK4Q5FiRf0e9G5AKz6O/K6kJMbGyWz/0V0DCy6Fi93jk33TzTf5f8bPg5ys
8WU0INCaRsxkpcj7+6eGESywF+uHzdozEN2W5Dt3zzkgam6FaG6For6iZu76X3EpWogSCCR/k4VUfgIw
6SsolVoYfBvfnypWFfQqWT8/gHD8LgrBN41N6x2Tk9FGn0D3jkaOz/MTloieVcolu+D5B2I+6yLEpSDM
3bvwRcH9KuswwNDRFeZnBWavAiUvmKFMZrYdddGNiCIegGlLGn1RmFgvfmsS+AiMVq2e5+Db1jlJbPIg
aGIfzdHDd7T8B7ivoC7rTaLWUb0as/A8PZWwTpDNxScJnMiKR17GpV9Cf96Diu6BZGWxjCMKobDSiwAj
Ny9OP6x4HU2n6KLBBaqPNEumcY9WGMD8Kfy6E5NMTjrogB8+VF7YEDvvkbXCtEXjKp7opjbnBoDA8s3C
ucOnDtPsiQDRhOZ6OeFBLymJCRoGlDF3zCVcXQ5RI8lJULxx3BM0wSNqcQ/ash3y7UiX0lE+xCBCgZVF
uG94jx0KKwla6iDMm3CTDknZ/xIANyW3usbDJy/Y4rhvqbkBMlVPA875XL0kZxf9BIuQ2gIoz1BX1Bd0
dyV2w+NFhZmMGr/pOAOfysS6+rukwecNvhur6hv1rMTDIm88Jy+eVaajRzl5XV/FYEDAaGQRqtNpW4en
WwldsCSNYlb7OuGblCX3Xf+HGoa6aYcdhm9zm49W+KEjm8SPYbL8SmTlOe8tRSHQxUUi8domMIeVwf0R
tsTJ3+nmAOE8hxqvL8F2kc3nNUIvF0Ksn+ePKMmavycfpT43VSLYAkZIXpjMuhCehVwzVV4kVsW9rMA7
cnGOXkqRvayWBmngB28tLKMb6S689WSwNltEk0b/XOfVCftEVhUqj7dt1GBA7FrCEFc80MBTRcM0hbev
TzHm4kqjQeCnxmbKjU1b77+b47X3BWXjb+8wMoT9Ntk4Beqthry5aug2y/hp6K9R+7m2wV6/79wJ0TIu
48fnpIkzJtp0gbPg/Mnsw7qWwcGXHY6hZmkKpo45GqVTl066HWpoQOtzvRWaLrrAFjA5CSWJxEOVrkQW
0QDs3bQtDueVCVljZpfGOwVGL2WTd3vjeeseoFtzGAc6DXuRaIfeA6rX2RWRH9iDnv7Tbo9oUpe537Cj
fkfVe37MxyURQlz9KnoZe58kOj/KxT1PPq1anmzHOOvKLL0oSh1z3J7hewy0gc3VTblqN9jz0fVTzb8X
PS1Yrx0UtwqRiHGCUY5J3w8V5jeo/wxawIYq4fB52TFgztAq7iRZpD6VVkpCWN5yuGEpbtJ0Jtr0eNS2
sCAzQBzfYZDUMnnEuxGBV7TFYUGqBUcnSkOPLXduvhZ4yMqbUX3mUcq4ZLVJV2OAoLxaUK3lwuIG+ha9
NeGrZtg1Yh6kxk9vt7HSVMdmfDVvceIKVsOKEL9Cp2Wnklfc+q5gkWzt6f7FcQtvGW8PaFlKcrncLnzE
cusLUuY5g787f6UK/sWBiL+W+Tq+UvYDXJBbUypVRWL3aCXk8O59ZMaXLTaz4xEvklo67LKc7ODvmOD3
rdrqamztmDq0znN0fnz3lyQnkjlFT+EVVcFPe5cjBAze9J683mr6mDK3vDJqQ3bHPjZ6+KtT6j1lzUTd
fgOgCYjkfjxjMmVz1fyE3yUktvwC6HbNiBPIGI2VfhcAOK6+ntljQ29JJNzhNM3Yv3gZEFTMcBrE4Unz
ivRgi5X4bZ8HY04IGOikabTLJuJjBgrVH8a90mfDnBXdTBuxjsNmN/1QniSk5xuTFyxbRWz3GB5uU4qw
aX6NOWuQ46L0Od2P/3fTly9f3aeU+4/qYaJ2jyzGv15lXQzqfIZSMqmnjvqBeX5qCkXD/4Cu1I+cPhWW
fR4pBvUi4WZZVL21y9PKeBuDj3ak7+3vRwkUkZh3lXnPdw/hAF0RpsXDs9qZT5obOh7dsO4gLNOf2NDC
wtm9JpsKql6tsgwVpiS+q/slnr7b+VV7r35qyzuWzArm4aDbRFgq9URUjELm4kZmh+kf8F4Bk3jY2KVQ
zAnbw8Y8Ukohx7EXpmLsLTtmJ3FnrklUvYnV+VHguzqib17mPx3gWDv0HKPzM3FFYPgVlQuzc9fu9/wK
eGq5usvEaPHW9CfQnU/mMhKrb3OYFrcHpZsjzhcdMXVllvnbu7LWj3lMNDdNY7d6N0kcW6T6uOwCf2Tw
fMIlncDcpP/Zq0pRe42xv89uim+3+9BZ+h3oe+rRThWiNfZ4IkkpYp6dG1P3rv27Jo7VgX1gfKtnWQXm
KHHu2IleU7/djQybIJeJlWusOkUbsgVVzBOuNWGdzaVDAiknLH4I9JLPgu2E0E+Nf/N1QY6NULCQ/sNs
RWuPyxDcgGT3NypjtIen7EiCRQtTa1ZOK011neevFLcIB9MEJuMr3taeb/4C5CX1r55YyoHRMDr37xjN
yuWoSzcIug89M+R37aw1lw+QJ5vpL1m9KsnTeaytTeLa0v60p5jLxLnNL6XJlhr/M+8rIGno1fh8dX1c
8Z4FbvYIAq1wyYrWNZk9v1xX3KVTx97raxFoaWO1R5wqMADzcE8d4bk3zzoSrejFTvf1ep1Ka6xZ+Xlv
76l8xJPsNesbjQv37gfV4dG5T5bf23RcqKDwEkOq8aeaxRLX9QXuPe78der8GEpJzybI2/0TPjDKrRjv
TmSn+wCRT1fdVpMB23SPiLN5THMtH+06O1q5NqjD11OyJfx56Rv9OVVSnouYb1ryqHJEgacxG63HyXdV
E0cLWj8fsuFWtNVCGcXoCKhIa6ym2sjTcuc3z858H1jaWEazjZPUS2z64yab9NBJtAeyxIo0R65THfyc
8lsZja4nrZsl2ZLLSsmghIn+1Nt80uXoF/4e4+55t2V4Civ6cqsr+BrDKWXvbrhSLJBpJeKQq9N4edaG
H9Br6s5rucrKWybNqwYFMsIF3ecNinAuo3cTRju9xZojR53EF8wcmFghUN6ukK9ampUzkw96fvxAW2lk
jA6OMM4M82w4/JkXFUVm8xtxSjjRWw00ENVpzi+u9r5Rt8Z5TJ2jr/wqx0TQrmhw71a8qrc0sq3d+PYr
gA25lx+alfcpoVjUt+WdsI42rQJLh3epf+Dd7oUU/tCR0rCv2pIRV10ycUdvW+OumvNDdnJMQXY4li+3
TGRj9wXIR5OHc3QEP0L45DwFHddAtTvTuAFsHrqKn4DA+CUFAqN1TquO0C4UsnF51qanXx8MjHLCEdLU
bD8MsV5+jAhPFZ75Q0PZE5L8pqwhN5YIbMdJWcgceSG9rFTf8Keg6eAC25i2bzCJ6JfL+0ah1XZm6Z6x
uIfcnlP9LNYHvzap9TCgsJ+dOdo9tM0FQ39Wv5ESNHHDy3RE6pjXwZRLHymCD76Xm8k6Vuwfrk6MV3d5
WGr8Au0+qS6SFdbW3f4Mz/cgvdopznmR2J9KtOTrD9N3Wx+IXt0eceeDn3NyvITLONGwYUCgvyuGpoaZ
9p4y200fUNZc0bpt9Cjjba65yJ+OMW0X5xzHqKd+sQrnNDszeVO6MsZzmA6aHZ0QYMZKpdpPA3tFrxyu
D0YP5Snb3PBjKUKiB1P5taWxFBx6Dk5jnncdFcI9YUBfqc8cumVyHYvIYbkpUPXoMQtPZbwysrbhuz5J
KNpNhPHo8vWZN7euzWqdByQ9RLNR0EUeDxyItxZjCz6h59cQdr0mqz3PxEIqkrhk2IQjxv44niMfrMuV
4St+f6NVGXe9A/8w6wjFgHzcn582yvkS4vTqtIid42r1cDURN3lu831buTt9tzpbKgNNYBbfjktukW3k
RCzhpFkreHG+So276yimXVG7qbo6Z9bj8N7Brzn8TAfXtJmPHhZBzQ0evbxuR7v7S3tt9e0+jdmSHC+3
zmC+oHfs37S0Vsekzk8aKQe+NjmO6Y6I1PpEHYXZ72RQAa3ewTi2sck0fs6MGaZDNk4sYU9THb0wBmj7
ujJDZ3yd1+WExuliSH2E9XO+jKPzRgbVZm5nlt+wyRozUc8kPr/AsYtyzoJXQ9ZnHBAESmwp4dboWfpt
cqO5cxGcd7BqSdSNHo2UzcQ/xdig6poZ8f51xVOsRxvd4eJwsXe4VXX/3FyfwNYbdDM+PU5fzMYWEfJ4
XQ+fEG+JIXyWS1HYZ8WRJGbJXbUaRw4SrXTNL5s9LzLknfrU7Jv12xj1uBWHQaA22YUpVcfIOis3jvjg
UFJaS1yxScBPAO30A5zLlGTewi3YJqYao1aSzAZL9V1tOb9bsW06eYeaE4LJAhIjlio/DAgxeb9qng8+
2K84XB3Ll5GVNilZ7VSbMzmpfRnYK6Lf/CLgoRxX+95R7ImW2YQdLVlnoGzFkE1Opv8Luc9u2eKvR4aE
7fe6EXPXCDfkXu/KVh9ZnoVFaZ/rN9W7ihspsAm95xruzuGc/XtZRUhXQ8OU19V26VS+raqnGBdW8Egd
Qd7pR82DJNHuPRv4Hl1x5eO9Cz6TMNKQAqejKkvJCB1nhFLtYl/TSbKVKTtn+Wvvgfw1bBw0jAF7i28K
RZQEZj1IBC29f/dnJEOPtdTYwX6cpclaWXJZzrf5CmOSnT2anOOXMb2DpDDzPNxs5JXeDdeCN40ciDdq
Y6aHTmhYH9PlPnv73nJeYdoAkO+u9pcvrQ8Gp0jh33fF2beaHlUKkyfg0a0r/KbKCduzubnql5zbuWz9
RNcwJObre8a7FOAFVHqn1re1y3XKHB7z3Oe764UHvWFoeTbO19Odg70S0m+ZE+/R8Peu3JtLdhYJzzg3
lEh4ypr7SwFnMbdBvkEx3k5FHWms7pzneT6HmVDOrV0VN5a45KI6kh++Ff10PXlcuy5TJglxiQjZXK1t
Pz/ZiAOqYlsn+yuPyFGp2U1lTU02EdZJ+pfjK11LyXdU3i5+VNzEDGnll+z9Od+N2KyxUaz1O091Eo97
pRmlymKZYIHbEsnNJCi4cp1ems13sS/D7xxUojTnUfwFxjyxHVMb6tz1zdotSlPDcDISt/J6m8Q6+nuy
MXy7y5GEu8ZvQ3+BgI9LZWr2Byk5BiQofDmd9bew64umykoFNbPdaC5SBNxY7Z1VN3PcXEzlQ+17ebXT
9R0f5AbD2Ieb1b9ibcetjPLNhMukpeYIPmNVTklIeukP4jXyxFKoHv/82++CYYZSzts75qluo8y47UC0
Al97WWWNHBMpefl38qVlOt2v4rQ0jDruZrRdf94xnqh+KFyZBUeqFH4KTHQmgYmKelb48XMgft9/oSzz
gtuWOaIR2UvH06wSImeZWZYtxmRJWsm2YGounKnYUHnjk1ZcPYnm1U64wqBs+A6PyDj6s/+r7t+PmSMj
xVjZFZnEKVIiaNkGZthePuAjf+B7vLx8urQkvgJkxWnKu/Cdp1EFunRlzWkqB/eZsxq+6TFVHIsVVrHm
mp8NmgeO1cG6lLQpMc7kNN76tll+j4SaRSuSU+/kvHGra+k5DDFkP0mVhECgUMqH2WERuXkPA+WY2C6p
LhuEVlJK70lCQHGh4SLDtaoVV2BqjLBWL8CyxRpqEw15qB+4hs9HScntreuX3o67YWRU69mBwAgLbPCF
gA10PAUFORQxnbAMn83yirNukw0Ag+o7t2VjTXqXn/TioBoVzyMFbNNns7NZEhmrbCSRWEBZiWcTzvZq
ULZB2sUIHlY7Dc/+uPwFqLCEXrTUAI5EqYnaUTxtebPHOb4Xh9TTpRqbVZ55pEX+870kRNSTLHxp2F2z
PFjAAp8KJgoiX15O++Aht5pNFPfipMkCcyZYrvfxygBRXE/Owg6tOIj4MaUUnRMCmd+7UnWq3iPSNNe9
yD/17VP7iYcRLsBgMWrf/uf4sFbt7lhWmYEbhd8uxlZ1bA8X29PYLGTPakxqFT4VCOtTuICeNqvmqtNw
rvVRE7dZveDBuEVenrVpGvb4z5/USs2pjDyN1SrZFiJJSTM+d/WogdFSnoTybgwPd69fqmnPVqqNc1cc
RVi/2cJelPa8LiPS4vH1lVlYWAT+Mh8PGUw4jIwy8MJeO3327IfRVFP9ezBPEP+DX2tEcV0TpN4zuGc7
2Z5u2ztcKHhqbDzJRr8KCes1ydi42pRu9+QtffgZyb9wkWLeu7pKWS3r1etTbEBGQuXyMTiO/d4tZkLC
D1VkOordvBIkmgLtTPT752gmGsokx4mu1/N+OpSFBAHDrN3OGe/nC7yGizG6g/btuQYYf3y1Y7PO8SX1
OVf9UdBNSgZ120yvhI1IJAQcFG4cGu43OoB7LOR42ttLV50WS/T9e4jc5ur3CfWe8nLul3DVXsMbchQO
ji6KOc9yOjvFuKbj5kJFrGKSUnSfCvA9XkqLUUgWPOpgclssd4rSd7HiDMelAn3BpQxUiY7Ruf5BfX4Z
qNtA/PDguEEIce7wAL4btpRxXY+C4Pfa7NGzWoSrfP2yRP+X/SUZ0mkCykCtGHVG9aYyyfmrCbW8/OWv
bcteCtfnyza127VSJwTdqVL+oLbA8qXltG/ZhG7mJ8BwM9VeBpfhY+uzny7NUdl1tc8TvOo3ZTTnPXH6
lkGzki081EB8drODHtDitbwMnKKHUz/f8BB9qR0qLdfMa/2zxzbLUj6xG7eltMGEL01/8JU8g2ArdKW/
uLorNirRWSg8JKIjW612qW/gYTD0nE+JcNtsE+57duagtv6mZ8z2afSIR0e307pjXJediF6u8Su9qSeU
fbOs+oVTZqnW266TLgbmuAdt2FftM/VeyAKG44fVN56WurhsDyHQpVbPfftcrzHsgy6Rid4+qSnE8cac
iSjOw+XrSOt6ppVW2+re98ntS7ke/c2VBoHPuap7Kted6cRBS61/znhzawsVTK1+NolUEXTfaVVZ+RGc
TPskQiG+VVl1y3t/xCahqJAndGvGZ0Qf5b9ZJuGHWYq9Wse790lSyOjVk8ffuLuELrYLivZTnAy5aHKY
aad70e283WO53CGzosaACd/6cKS6+bCX9dy9XY/PxfUun4vOXfGViD/x7Lbhnk1vq1fGn/Mf1Qajwq7+
jHc0qnG17Mgntvfnih2frXziRzLoVlVxTl3CItGhc/dlgZHuDz8g6HA42zvT728mrvS7aR6sRlklCD7R
HCCZEfvROns4WvBtk/4coVflWe655zO70D0UBOWNkkkaIGWV5t1Z3rFu+FxESRk4IkT9aoBsSIw+7MVn
X9DE3sZaLPe5m1tKn0Y8C/MpqU9rkaWMk5WLP9mlR8O5ZVPfVKeVmdpzYUZJG0p8n0kf5/2jZFQ1guFS
Btwf5g5S2iBhMwvfgG2QW9nsT+eR3hvQiGBZKJ5hI1Do8FqTzpLuUuXBeeQjUuwsMnG61RsUsXy0A9cV
LLhE4sPaAuHLy6/ShfU4uGnUBoiTmeYqm4vzp6K1WRYuo2gcxvdE1jYc+ymoNhO7XAjXel08mM4j8GAw
YbJy5QwhzLaZlRUxWQ7Dmq2deJUczX7tFIbyuL2YGGRPu2bqc2p/EJUoBFodHr6whUfxhOEkJLrUD5+W
ha+trFhXz7CwTzuS4QHPSu/FpRz7CD05rrgvFNBnamn5VNyzwcS18wVfqX7DRwpiBmHh8YZDX36jBhPr
d5cN7s1P55Wp4Z/W4lNSICgBaP5nZ+hzNH4mBu6fsTZIWK48JKeKxZ6Vf5rpNdm4ENdMfvN0S56QHHVm
J6Dbq4zhKREwkuB3rKSUzUS7Wyx+Av69LTZDHF/1CySlzpIuTlmYbSPotu7D29eoNRN0NyOmCoIAGYAt
QTgMkBE10aso8Sxti5qjDTKqxjp/Aafw+MczhQLMJrpqeVbTukxbp7ECV0dMQNQGbXV2Gmt5OrqIem73
5kcKzOuw8r3Bjn2MXpk3y8Kk4Z7tLzuoiDtcbOnfJnmX99iFibUwrq8wq8zQLM9qgDEaW4pr+vQrF7c1
kEYduGN6LS1DMhUmCxyOQYaET5daWZYklEd4WCffGPl0oUWCrKVm+TheqWT40bF8p9+Q5ZZVgESdxYsG
smnv0PUNqY0LnLzp3r2KKcsp0SoLAXqD7mlSCwvngthxtdpfl7s77hRKO5ZHF8r2JzeKqBSVMlq9m71k
gVw+5EJu+8TibTOYT9elSeiUOMpVyAb6Q2XDcBBnj5qPsVmiypu1Tt6GkyMrnMTEKreZhq9d4I1wnlqi
XcaYwHmd1QgIyQKNfEMlwY/e/PvBUCIZXyilDXA4VSeGmbYqoa9wpj7f7ImcjjRdLlXGKDf061u9E8bD
+82cLtZk9OAkprwzO2TBsMlgTAHEWR0nB3fKeD1uEZ4onZdrHUVtnRWVX5hmWQmv/YZDaPYyuUql8bAs
BVVtNFQUnfyu9nt3o27ODuNBlMEP9qNzoT73xq/rtRgmgcZFRT7iI2mK3eT6hZtUisn6m5kJ9DdcCipv
Jmjpph2I3m6hc3mVMNuoCXCIdzjiVN7QiqNaF5ssMSTSzJL5/vFZo6o0LQW3aKz107JB2b2i22ZBFoUc
M+PoezGhzD8ie9qZ2b43GaBzo2tWZL/DHDbue5HKJjNIEM4SelhIhDmlrdVN3PA7CB/XWEcaWtvdp8RU
m6/LT1RwERMtxPtQHMxYEHgfDKUC7YMv7f0vjysJVHRHrmXfANGI0XbXwNV/lpd/4JrirqhnC3/sDnMc
cl5D1t8XRCUchKPBJv7omIIBSLXo42UInzu4aGhtY18W+L6cgXDRfFFfaBgXyJfSmTrCzxP/rvlqS3XN
+Rm1zfgBh8rA1fMLD6xsbnBkdpYpvLkxALUHSgnoiE+F+ik4MrADjwoDUkBMGW6+z+6hTeV3v5V6ZeOU
c0dmLgiKEjBMITFiLQkBozF3dH4poMYkCLhwl0i5+iyCys2i/lCAOginBbr5f1/wRSVYTMIA6RduUsgF
BxT9ErqdnL/ONMt7sTv7Yp4tRriI0y3mfyDoh9Tavfp8xYmOUq3AWEKZC0gigPQCUqpNTgn/lpgPSFdc
Spj43+2i/qCLByNLy/vswQ+Dw7e9xtruolqOv9JbKDs78YGzGnJse+qw05cXNTOvIe3ZskqzUqoMzNfd
pqwoVXjl/AXPd7WQHvEQ8FFwuMCCFuu5kwLWUx1h8YsszN5WmuW/ouxMFmwZS5oDg/9ioecV/Hf56SiK
ErDDF0J1G1C3sKLc4X+G0oPspb/OHFBl9sEaLOI23m55j2JGcf9C5Y6LULt5UZun9Nzv/hJ6SUTBAX/t
cuXqX4hKTP3lN8kV/QFpQVAg79pTThyHUAuDUNiCgPt316OYgytNuDveKQEBhEvokhBctCU/lGoDEDfH
1w0YHqWM8r41dp652Ckn3yaWlr/zqONS2iEhyql3qAHF98HUmULuORjdxgy0KE/t22eeub4IDQeaXpLX
NV7+uYNo/2KoN4ePHgy9tcc3Q/Xf5P5AVIl6glBHE4TKxEvoMPEwLnHBihsQ4MhkSO3x2GoZW3EABJVm
bw2a5XoWcItEV1EIYKoCqpwAod3yFZcj2+MJLsrq+C/fMP9ZBiLH6LIBvqmBYizqiwJV3L/F98xVJTT8
4dBOeHi/5mrb3cVMyL3jEyODe4B8AHXLNhmVzFSJpeXdUzU8St9o6pXuaLydHJX3AEsQGbv4rje89vVE
hY/fJ8g7kqWMzPSEd3e+PKLafCTnRE6EqleUoLC3q9f3a/c+xUjehi/KqygcgMCiREUcKrwAB6DsqHnr
b7KXT//PhgISqlPsYAJbHBQ+BlmQ2p1P8JONglvkQAa1EJKpdvpTHDpxAC61r6ZRqiOa+FQYQRt5qiwo
MeeN6RuSECCOACwBPX5DKTc9bVGWB0H/Wg6FBbQF8i/UN44GDFxNY+Kg8ggMhd4x9UqCffDJHiYUlh2M
U5leTpvz8d0deUIql+Y6nR7mx38ZDLN2K18DmwBw2RWAoCAHrZVXpcntenvdQQEPE5++0tmsf3frLJBM
ZXpuIuQ2VQHRKO4JgqG0hv0LiQjjkIi7Ae3BzQz6pahQ0GAUt3EzTrgqlwO0bLsL6pXqilCkOvjzghoV
MyBm5VTlY006FDW6Lx1Npq3FM1xxz39ZBeynxpCZNID8iTRjoMX9r6sXnZ3Ry5XYH14tAH3OpgIdYkaA
+RYrF//cPeIaQ5S3rq38H8WN41O1daaGhSOFdVhiFFiwnor6X/r4f2QQn2VFmdOJT1XdXCcPzBFB/xjg
rLzALhlEegeyD150hcdMdJMXszCIo8L0NrUADhNFnTzRfzRZiaemBSJBGKTBKj5qlvIXpNiPEQxK8hEG
bNQo/2YBB8vtNnJBGhzidQyYPcYMUCqAmPnv+jnOPAUFYs/gNkpRX+K+xFDKU5xPMUO6wTggVKyBxkMi
PotOhEPjtEbIP4anb1Q5i8TVIfeTi5/SCINQzPbBLSWQBHdElCPWidMGu0NC5ZeMZYm5K1ddQ65UJlDn
IyoeJW0m5IFF0O1pGGbFpRI+OKuRjAuDxmm0buBSbu52guwKyvIfr4TxxOGj1AMi2T4QpXW82EPcW08H
QU8h0H/U9E2gNjmvo6Zui0EHjFzswT1YiZe8d7hvZADoTBgS4SGiRROqRnSbQMBAQhumExZNAVgA6Kgs
DDPheEfJ/oXQUvpFjoYP9cqT4fdet+aC/5F1lUdwgL9Mhk+52WCNkkdzC6EvxB7hmUtQpsVeHTct+mrd
Gp8S1Ed2KwVlZXVjqY7z2mtcKvownMp3adyPQC19fw+vnTzqt1XJtri3trU10rRZ3x4/TCCpA8cLDDDe
gtiHomT8BdT3rzMlg9BpaKcHk1DxqvFEfPemUyuh3EQEpaUvF41Jz6RksP0vVATUJKJ+FnoZemxDRMVK
ijLNJTQi84WI27AUDQqib4nTs2ziOhx/mW79lUklKl9Y8REVTzXAEaEEcgla2ygQjivj6rF4lKCn5FQz
zm+gf90BKhX3nN2fRnQzFS/PPWgZxkV0zjCbOKjVasv81X8OYh+M0r8mKirAtBbZGGND+tfYSpo2ur+h
WyONkrJ4gbuE9xfnAkrUFjJhcVOWLipREGj8YwRw2GRVfMM3rlOAJ0A3Inh1TJ/AZ4sDRgOV6Pm3+V/0
RC/jKxDc0mmGnrieJPWzAgkLAuCmGI27yaCU8kUSAIdUCihXgKVAFf61L4tHOHq9pbLGOqXkCbJLgqBE
SXbZdwSytOTPDWaZBrlthx4DDKtRxROE6ndOBu5rNua1ReEu/T57xdmWG/ocjHptVZQBOMaIhcB8FiKU
Aqh3ZKnbIlD4g241CEDhinp31RfCZ+UvP0QtOZcEHOzb91jnaGj5j6pJ0fmpUXGIeoFWsks5jxS9iuff
90FUqFBHvQELE8cKRgW7qC/IN0m6a4nrA9CpuOey/eXeokuz8s6nIEYq/wFWaIRHJy2AKuqd29k3Xi/z
Bc9ksyVoaKlbkDg3yf/wAOEudUH4ypX8bZqZ928tAbIVThhvD5DXUZJh4l+AxgvFQtT/H16L/Le63D7E
YneYp3A7OnQCbEaZ4hISkaq+IkAnnHJlWl7xh+N2m10xxO33iDwy79U/yPxWTEbLKmp99m97n9H+71dn
rRDNWM2VkvXXRLX4fyXbaXgtWw+XO8S3ptgahL/YSIX2tKChQGnxeZz54YdDNVbUIowyUCjHnfX4i18Q
9JbPT07hf66ePf9PV22B6fti/n8xFv7yHgK+NdqTmIJqcIFfAxhh//z4a7TwEdGj3yxKc4IRf/csymEy
JLIJPzw4PaQWv7Wv5n6l4c3SjgQZHmUz65TUX6ZAdxc4XaJOerZzfC2i1tXHl+SE1A2G3r7P3NbZvGy8
+XFM5tJF+GpCixrj1jX76T6eT9i8K3uu9/CobgEIwtFdXoYd/6/buWWgU0MhDyj6mNJdqks2+avrOzBK
CShlh2TXaBJm19nAUMPPW4ZBOFc0bTMzqik16SK4aLfOPoOJ/41QSvognH/JNXzrSfaYas+z4uO/UVhO
sB3vyd97emthKWtSOFExLWipFW3f/mdFKjcwIIj6akw4qD8E2EEpCYNRrCDQXtKfNFEQMDAJPRE+Com4
pwtAXdRPUOWiu/YYCuzYNyw8+0knbkMGMzv6uI6N3gJflrDew4NJ3uoTDFVSwnFb3BRG/cPsJ5zKxpe+
gJy0pGh+qVpPT+ByUXj/VxRY3B9kR7D5dTOPB9vuhWfDfnV7dhhK/CyNsA63KEoi0Jl8tXDSlfDIw74g
ata3TWgWAKwvIqVkJYcFSr8A+riWT4Dgn9qfLpJT3eEUqFHErvTM7hzER0xVrCeiQX3V4MaADhN+utL4
YQa+2esAuK3tLthIiCS5dSXL8i4uFQBtqJuPPSHAqjB3Z4yoCDF3ZpcEokKhgWp0W+7vp1epI+GSdUcL
IyPJeq9R1ov550JqDUTxbAVB2R8B+zY3Bed22uluabrm4k6jQjHpDzExRD2hKESAPuCniPhnAbYtYMSD
CUNuARRD4RCEgwZ0d8CG26+/QnflpLqMB2+eFBZa39KCSvX8G5xHoMEP/hg+Q7noYOhA9+Bnefk/phRY
a0rteIcNkFtxfLr12MDR2NRfSvZxLlUzPlpx/iz/W2GoVhKlk0xVdd2720uqh58iegOzOXJB8kSUYZPz
dCjYgVpl+ANSu/oVq9b5tQwmgW/e0q1z6UMj8rP7oiq3/qKIO7y7XncyWwTIUm0PnAZo5emrs8WKfK7v
UmP4jsjvkij9tXGpVRdNkrHAEohA3nYSLU9BVyfKwLbOUfPD28Dd/6Wy/6vsNhrUPAXT2gNzcmSQy8ur
tQfXX3ewvv1f7L11VNTf1z86hDCANALSISItIC0DgoRS0g3S3SkMXUobdElLDggMHYqAlHR3x9A1NPc9
fj7P93l+z73r/nP/vf+c5eJ9zu69z37tca2DwbT6ozAgvqBA66/ZAnX4pdSkrs/N0QYlIORWvN8Ijqam
xV0Hvjj9a49+8Ls1y78hKsAvtEby18i/Uok/kdG/RFkfQDiYba1FIyfGjTbvpZfNRsbRk2IJa3H+OgUN
ENzoMFt5ZH/2x/jehtpMkXaDN7ROM/CvHpvEjF7ps2Ev7s0+h4zaXMa+J6zJKIZrG2YUNjarEsj+jhzz
ff8fw5yPKqPgChE95u8h5tWGJP9P+Rzf/7Gb1D9RcJMg9Kw3Btb3n1ADUvof8/9dAIPQqIe6V1wc49xD
2RDArsfMxgqGDsz/7CylYHSa59UQjbj3tAIVTjq/VXTvuc6QLvyrsg8xCe1DBtisYCgKFgPn13f+pjgm
+F8Q/w87FMgD3LA6ybTaMtIQRdGOi8IeaK7VYN3v6X9PhoBtAkLT+VtCZiVE/s4wgQCKjUcY3aqu3wzf
xgDOrgiv8iGmH+SR+kOZ9joUkB0cz1zi6Jgws5CqEgpyXMwJ6j5qE/CboaUHgvroV5TbP6GIoo2K+WsX
6Ow73QFPibjIuIjMDC567rkfX0kY/zUfIK7k3Xlyi2jaC48lcP3WkFPe9++Z/55G5YZ/19OtB7R9bagh
iPmPPab6C95/lEL/FUxMQrzHyjMnmozar9P3M52ECdOZGCeoBVBx2YiYhPyvuCgrOId/IZJ4twLPBtC9
BUfVh7+ZKQlt0yM+WkwR/9XVHhJ0735knLYjHdOrwxe7/twex9vUBf2M/6Yzmp3M7y0ztdXDY19SxsCO
Zem5Jr05CQLM99nEfHZnj/8ZU1Rf1XcSqgBeACT/AURFJiE5CWpA848xiBg6ra1tmFFjF1Q0ENGj3AM4
CfIWGvolcfzvKAcVyXwM851/lSVnnID8Y26iKNnfeHqh91+DLd6iLWOQfxeFpf9DEui+gIv13V7iC5Q5
URATxRwNRT6wkngZVZEAU6D/hfohTKtTClcfWilKnFCx4fwFfDEhRP3vRGZvg0qEQSuzJY8HdRYTHEvD
iPRrki8ISABIEHheDGqgxP7HY/6wfM3VpS2FD0RtQeW0Y6qO9U9y5wZGRkfZkcoXsf81DQIC/J/JSc2G
p4c8dJZ/Tf/C9cYI68F/HO/KScz36CMADocyz5Pr2ZJehC0Ru15g8D+SaI1EqYeOOR4VT+FIz5Srxkyp
83fCZG7mkmBwPKmIUghMpMMjdX3TtFqUhk3yF8CiMKaBkY8Oqo78nRYBy8mEblSctpObIrTvikWh3PeC
9W9U/qv2PPjdEs9Nx/pKR9vPteWVB1yQHGYMoDuobRUwLk7Vo9RBBxr/1RGeiX8cmTc3IJCnUv3caw3A
lL+6iJdzG+oTgoCqGo8tYfh4/87s3l/HohAwhs/Lf4RCx5QT8ui0/a9J1v+UDeXBf6ctgYCLH8T1xe+k
8/0dirwIBDDQ0U5ZiDl0wxrrwS/st4z6CnarqV1W/0V1PIqInl7l3XL4LQrxtZl6aowS/9enaCInJ6a/
Uy0UspdEMUTNA5Tfx8tLOGGRo0LqX8ifDH63Nf0CRYGI4VzibA9dOfZyb+VcaKNcRMG1vq4RNcnb69DD
JcP9Miz1UeowQirbulLN2gWXjPVlPBGz7M6yf/2jpMb0q0y7zBSW54RvGBjrUzLmbpquUidUZ6au+udv
N8QCxLzBF1d4vWBGBigRRBIssjxBNSoUS4T+ExvMIFzX6gdXVbmxY2PENEI02PiJPYI+E6ghBvYxhgYe
vDhnCGwjUIG2AI0+zL39w41790O/2HMPqu00j927PgZoIJEUGG0p5OAFCI0R83zpwGXIphkgcb00P5Wa
Zqio+gLMKyV/tscnBQbTA6TEpH9vhaizsYPpA5PC4nv3M4poxRRwAMECQej7eIxehiJSVvivcr8xQEFG
j2DwV9rzElH/CHrQQkRCNPiq1pg3HfUHlHhf2+8rRQ6rT9CPMS6Z7VGEEqKDwYygJQyGUJAECeTWc07Y
QxkstjyRejpFbni1A/2JjYYZShR4gHZuC363Pp37hYpO0cTl5RIzt2C19M+ufh4eVfUZf1wFUBCp9O/c
Ox0A3KKI0Rzane7RlbH6C2X+I8q5y51OhSZSAhL3X5IANNHBO4fL3zNCiYggICkwI2YooTAuf+81Q2jy
XoONXkQoUfOj/kmDzarTSBwCDT2Nb2qmP0dFuBUPh7IjY+6rKmq8N41h5lu+op4njdvO8d/iLS530PIw
jDLYy+pnL3HUMNEMibRN1ZiafX0O2IYOj5Fn3iP8kn4pvMo4Ip46y7AoJ5w8q0xXslB5m4Q4ZzT5DUtH
OMdQ3cdYwVs/6Im2wwupPsIFnbs9qxANvSnvr7TWLrV4D8plE5J3gw6rfltT6yGv9vqfLWFgEumQSKEb
7+YRCpF5eyihx+RqG9Rd5nV+k9OrvqRaynZCUuY/op0/CrTpJt5b6dLQFLKRi1UQOzboYSsdylymcuAo
Of4Q/v4ATVgi1MB1//4NQqXQerWiPDTe6T0hznDgF+tTvungTEvfeOISSOc+JQ3UO+Rl+EnU3dBdS02N
YeOx7RcHmsazh7svVGPg5PUa86s3hEV/Q+c7kesMLILj5FSyOSFlQzPILP6wQ7jJKjj87NXg+1ucyDi8
mlPxZOPfKxGs9XGwsbFa2/ZYXIdp3ewYX/bqH9ahqTPNiN7EAzTvCBJmToOb34X+9FLA/W7nLtsUfgLI
5I+zvcAxPk8N+wo6RTxEQFrYxLryT3UfTDc1Stm5sTeVl4cSEkm+tQHzznl3EyFVWCPi5VcU/E0HXsZQ
J+e9YlYXNb85JAiII36RKsw35ZdsINCvV1+pwQH/Yn1R7pogINqIxgQFhRI5gRlDSJg9RgMfKVGm5mTf
rMwRjqQXqMRRIl0yferubtZLX5dNauQ8mFGoLsrTUm55wApdLNyuXsAODzgRRopA8iV+JHy+9JQH84of
XlrKhcUftIGUtlO+sjEPu59saiDxW2ptBVqg2qU8Q8F9UK5+bu2E9vV4Isj1RH378Gmtr/Ld/J3jqAzP
t5yiBCYRA1dvZyA4R8pnqeTC428PiUUtrYtj6SdkxEdymy991h6M29z2oHPNa+T1W9SEEj7ZCLETfXd8
xQrkPZQp9L7i+8EPZg1b1d1zoqsKgzZUVHqnF0kXqVU+WeNkDc9vH0UDhYER2NviwV8N0xK6c0twtUt9
fimWgveBZoTnlZVS92AFGg7k3RzcQtumc7lZr6Ls1wphAZgekwgd7P+dI5rIdQO/y0teu5pVSv5NoXLq
tJjqBu2EQi4W62W/x0zKyvDVsSeiqqzD1tqOFVVE5ELj/cI8GpboOcRJpHx+hW6l4zwUXUl2l5G57OL7
sR5SFJe0M3JiITKtOyYJ1DYiSTDD/ApFru9m0IzyWTGR6Z9dYQfr1D8S2Ul8DbIXuzUcJdbPgn/T9f+e
terdZltnXfVBVYBQIuyw+KVuVdEAWx6ltMGOj8eiO9+dLbLn70zjtCg0SCFgBpQCjHnMYfewNqNNbBp2
oltev76/8ZP2jfpMjtf6zngjhysXIlZIm7hxt++FKOI8mtmfK6lEVWjurnJ9l31pmVgSqNSc7dGLLoc4
fgIeBuwU+9SJMI4hhJsne9WgzL+yh8YzmziCPdbjNQz9LVtD9mqWBvr8ZOfPzZPmgc65k4AmdWxoaQWJ
7Bv9NOvKTQnUv/isUhWDOm6Joizl5MkwvDPmRHPyrQ6V79VlTbGAs1zyQNyMik5l3UMZhH4FZwSTIT8N
cpAUZsNiq34xuyQlSQEBX/bqXDGXVhj6sJamje8Pp9UqjuP4fR4lXlAMJWwLSFY4uV1fUqmBav4hbtWq
rZYXv7g63Kab440KTk67ZyRUBrv1Q5L97GIU9lEsNqpHWM9Be0AsYR596ZR/y3wkkevYUDPB1V0WFV3p
1R/q4oBZUdWQy04XF/9g99ylgMVp3surB2ajQnsHEcXEENCd+vRkjl1mOiKZyBQiL2LmXDzfYBbJLZIb
50sqQbOMbyTJaujsqnKzUc4m6vRSG2n9z21yAbB5dxPgCuZtpRug+lQQQB3T3y3ntRJME+TS/ulkmFYO
cfRBnOySNGIcxURzbHT7PZFpuf3pqkWuB9JJlp0R8gXPLdk0V/qksDdia6qkk25cusgEVSIWexnz9M2/
Zd6eUs69GwN3dIQ6M4pK6lh/La93/mrU5BiM9ViWBAIShoQmxylw04wpweZcqh9HK66buhO51V9q76fm
KMT1OPOYBTzpMxlUmffWiAiNQ1o5MqHi2yqMyO3Pz95apfHzpVdkC+g3vh3bF/qs9RvrmABN7yehJ5E3
h6wH6wczrYairwOux96ERWC7EIvqODsH+pYvjmjHqiK/DYaEx0XAaGcYr4qbTpd85i4v1VBGcZYF8yJP
6kbqlgQ2OAcRJmWDg5LI2fRWQ8Hp5mn8JYzAOcbV/Ym4ux8mkup8JCc9ZXJ2R5tkuE6VvNKiiPyZFr2K
X7EHLhP6vWtBfm4vQEFCEfFp+xlliYnMd+vnjmDeLiTkqjFXdDWcIsJx+bd5s/PIyxj5D4+hoAqB0GRf
YfGLCKcIIjfXkweffbYr0zo5PtbTwXk3wpMJ78rFW2DBrbyPolD3LM1Se/+V+7GxqGBoskpDZqvFJ6yz
2Pw2urfcNtdICeXBgXAvRijoQAfMmzTht5lD3HAZjEY2Jc0tXhVH13pdkunyE3vnp2yosLkV/l5x1x5k
TjycrIUZKPYQcVMwvbC5/cvN1mWpkJNZfFbrn3V0ctd6awlKxWVOqrITT3ARIJZ8/MhnwXLmvz4ONDNC
deJiwEtClvbd+xWZRMLYSxht2ZcNrOZD3w2Bc+vOHD8j3B6xhpFCJFH90XwQ0HsYgy9uRo6fBQwpR6Kh
rM6A6h7afGrKdhtup+6h+oe/e0MJQf/73yAh+MMO4giih4y/krS6bO0dtY1kPrvG5NbBZfI9yoqtrTU9
1NOKYyos9lanZ1uMY3Z3cXHAb3QkWVcKyWhJvunkYh0uvXgdeV/L1r2ioSPsm6/pt5yf6Dj0IKho6HOL
6+PDrpPTooWyvAZdEQsldneBkklrvL6ztrHZx0lDdHXRZ20GwSNj0+u3C7LYWN/UC5X3PNvsCU2jw3/Y
431iDvlCTlpK98HkdQyyDN8LB3Vj5zLm7c6n+JzEqj+gW/IzLn8gwDWdbAxzYMGfVp3/lt5AXkO3fDTa
Lwu2gRx06I9fazLn9TjdOYk+vHsdBx4ODH2KL487UlH+0WgGDOQg0LTZOMzAHO7J6r+Z/bprETOtOpW3
jbG0/GaUpg7PC/tTeCLstn0YINAXPywB0biJecr3lMUgpFGGXXhQTFudBZU+cWnNZW+UkH/GR5Dpew8Y
H9VWqyp4TlgbqjZ71qXWGI87sJi1eDr6RV2dQ41jqss1xJlCBNhZpEh9Xtq9nQD/xAZJvcceFYKzuTmV
aa2O2zYTixpIMDrTEPDnmScK1BEyLz3pAT9qF4uwg/rkdVLtvnCv8zpJRHk/yKyvn3tcjF9w+7txtMvq
VUmp3VhOqa3fR/XcnWnLuBaKqiQWK68ayLPY6goGpV26spWrDlG4VV52toz23OlHrXXtoxfYzoNER/bO
XwsUd9Z+IydbjKetMWPrxQz1dA326ZQRlT4PvQ56IxGzcr+n+WKUcCeqIbxUc/x6aAS7lCmH3eR/UzzW
pvmzx+FFLg2y5XsU1TM7u/xEsvHGCEURJROzkvme4tEZXU0qp2eQQsLokff3rRz+PKCjK0XbwsEkAmHX
3LV5hY8kN9Me12rbeXrWHLXSMa0xWF6deFC+0lUvHvHpsJ3+KtwhXKqdpwL7E4mLq+HhRk3vCVTEJZ68
SWdxKKIbF9f1z8sTh4tTH1/p+vEvQt6vcpuNOV4j5roCk99kiAkbkV7+El6/mfNof2axoJZv8e7+D/SD
dkcxr+jOWEWvvisXgWqbswLc/vm179D3mnJsjvZjvfq9p3uxrzOG+WWtCBTeQPP4HaewCOWHmpMUR5V4
eFyQj9Ewibxfujt/pWtewmR5LCu6fLPDbTOKsHtd01D6w86uYW4sDzuRwmZwnP3G9WVOuBcS6tCv+Yeu
+fSRofcMdk+Jw3II4WLrNVQjnLv+bTXzfFR9ztKOUsLl05Ieu+AurxTp6vne8uEuXwPRRpXSP3SZ396/
GZDYFLsaZZxuytXh4e5flo5r/wlhEDYNuJyyjqEZH1vZzy0u1xzg4h5Wytp453F+XlA2FtPgptpCl5oG
y+mxjGvN4rap9FncLsJdT8No84qWjx0SF1J2++Wrm7o2fMqP3B4rWzOihrQUzYOZ7qZUi+ysVq1/wNnl
mgpnysW0SBtYDn4AYOdMzO9tKnOmJ9e0UZlE33RJHLKB4B2OodP36m/KE36fSh4iesTn1xyUOW9OhzDO
DzDOJSxVzjEmVI7P2d+vt9AS9nVPSHNE0YgMrLwPaC3QEs/UzfGFdKu/CLPyzelnnCCc9Q4mkXqoiIEO
th8VZ9cIaPlRpdLYl1BGd/3cOK6cW0smyknlvZ210wReWq9H147BWpIvfKn+ItXsGVyBJgATNOso7Bfq
6xjI2r+gly8BTS9ZY/GAGDu5Oa6cZq1vfY7JNKTM047DnPNfEr4FATmkRJ+uPDyXRF/2J0O8Vm+kobmm
odvavu+B9HX3erHsnDDrwNykT6QI/eqthKK6OZExY2CrWLnVp/K6STehbAF8Bx97o6BMHfXlTP4lnr4I
tQHHJx7I82TpePG166pwRHSQ4bk0CA1z/Gpq0D3j6ZgbtVJzbYEBkpNNw0a9xHh8gYbQXhA+wM2upl5i
1Wl+up+WVxJH30ePsdhlKoXuMVHT9W7nWiQ/pmF3xMBPVQdRO9G2c1i/9tlg98k35KRv3cj5/Udh946x
gSus9DM5cY5+gNAY84ajteMEs9vx6bSWGzcm4s7vE2JYPGu9KKeT3ywDVg/N8V1mA92597+Snmt3fm6y
Vk51Y7MH2S2zO7xCvN1j9bj6iY6EyqvIK8WM429ErxOiAwBuIzwrRlXt0400jN1O330/3U/PQKNL5hzL
TX58V9bQVYHaQaJWhAxxxvGYI96JpG0/+nXMmCZFHPJ3vcS8zpJRcVPmbt1dXP3HJbMShRNHyxS5P3e9
x7Lbm3sfDMBEkoOHnV4xE2Eb92tvmtZ7HntB4QN+VTF3luVnrhPX0F3O7wEXS4dmfCdV2XP14ECJuefu
nxwbvIPlBLP83CyKMmfeyPKcI58KVd8g4bjNFdWTzBt3KzBWtl/XziBMIneyYzYkfYDAj9s0xNHjOXEh
43f47lV3lG4PKu5042EOdJTY0BXNzw+oSX7LgK5/PcRotD0KzYRnIcfWWHw4Sj7hORPxn2k0boCnHX4N
los6mWNRoKimV2F5jdQNnflXJovTI7k4D7pPZ8vejIyXX7U8eaOV3SzOuI4VlkTLH48HOg/69hU057xm
PjNwlUoMmR8oX0anYXKL/VovApsrbzXl8w0JBAXHEpNTfrXjSTNHiPSL0AdkJqmcCwNY5S4HfWYj1OCi
12Wb6mHPPRB0tt7Mp9gqvJl0YMFYvRwJppdIAeg8nN358omkzFhxW+7wBejHRzGrl1762qI2z7Qb9XS+
zfr87Fp6GmEmXvFtcHysMidX2uPQ5SQY1NJn4Im0TWPNDKhs1oM5lH09j+i+7+jppOO9JmP2hebP9yaG
wEVw8txu60V+M/6fBQoKG1LSP3Hvp9xO4omX+55aJSn8oc93VEWR2g52aZ6T5t79bmHcnNnD6aJS3rl0
tdHJZ7FX6QT7cn4ub/jcAhQGlJCI/RPU/1+oVTHWL5fxbyrSkJvWm/tG0VINuxJn59NoFQ6XxT6QWW//
xhFgshC7YSHA5eOum62ns7v9PoUjXLwlR+feAyV4xrE2RawJNxjMIPx8vUc7KdNqYV2K2hVxgmu4S2ur
nKmQ5QSHXd0su8mxZQL0RArxlbychK0ixgVXwt+pZvekzjyBYrvUwLcqO2Tgp5FdneFb6bzibM/BDOdb
sYiEnBcYavYi2h6GJZl6qn3Te+TeJmb1Rz07D4dlczHO6Y5NRmH2UMrTvVQ+h1JzSke53mKbYUTJawex
Bdgf+l2jX1iA4VjrN09M4BmIizUWdhvb/E1ya2u7ic8KUXMqD3bfnqXeO95FP48uEv9k70tZI9Bq5GRV
uZygabnnYhOjdPyiobALkYdmQ0aLSUTT0AKA6LNNCDwd0ZvBve6nYy+n9LkAVmvlrR+3d5g6zRGWgwFZ
5kzTqrOznYNZaQ+TOrK4Sd1J8CtoLFgPHMCrVChfDgFRkS3m1iS+lFuQrcRTypG7KOht55t/ljDDj3MY
XXTDJryI0Xfjp5xiqQJ6F6CU4rqt4z9nGxZT5sM8kuk5AY2fkmD8lBMCCg7Bw9/JO1amt+2tnzfUL1AL
N5rKqW825IHBra5h79p/fmoKRIo5aIQHO1Cq6+pMlRJ+L2GrU4J0u9hoV4of2yvTT6QFo8iINch9Gh42
5ZSIE+H1GaejuFc7VDzsoz8eIuSko0yZqvwDjcfrrFvaXmTALiV/L+JRhRzi9sZHYCQTW20jXVSnTwaI
JWyP2XMjePpGTM3aHs+LScQConfUUXpKJX04yRTDyN5arZrr80Dt2oSdjSrtvdqphkgsfTp5DwRVoYsh
yRNhwNcmxEFoomt1/olZVlaqIS2c5YWLdBWNcF2FqlL67acmBoSn73FyFwOTRD29vfT/HI+Hu0buMjo5
VReedcX2fJ0EvByhtDOle3g4rkLpG2AW5itA4N3pq8/hsHVPxFFeKBLfu+hzbI0/74f+q+0aeFOQqe9v
T+3PWnvFldfPC5WpvwYqj1JjEl0H4ghGzwht+A9eLen62qYl1M9cylod6QiyYDapwiad8eEm52N9XAlk
M+2WjlW3VMntFeGsXW/siSQPbgqU4f4Xc7r6xZs3zlK5VXOX/S2PY3vf2MszdGA19f3yL0rMajcgh77D
Icx97iBtketJphNA24m/KVUJREQAdTJR0bx4acYTrZnJgrALe9FNTAQH1Rd1212+aBOTH6mDzB8AQ1oG
45udSSz8aX9SeP689/IBG2ucCR2Qeud0uT4s+v6x+WKGttZmRTKFyU7t5ieqGMNPni3KSKGLbm3mltJC
bPZ8WhjiIlSVK+u+jjfzViTEUs1I8568B4JgnwoyeEndESYiQDb9gvyhEEhLRZZepJQjDKvpd/wqZYdO
U3CGCHZZcX6MqVjoxVvn+o5j9P6bbNm8DnWU8g5mcnpiaM11xbr6JalPqkM0KIVACKTeFZnr6mD581P0
JrZAd5Xqa5pet60b59S1+nEJBprZKv4wLDTMOx5mUUVx/tKMu0qoCv6KH+2mQhSG/Js3gbJeFqTsbfr3
a+qEmrLrDUuSoXvCiB5qTd0J2y0R2fuWTKKA3uFBNi6JWcxVgVhdH8YnKx657pe7N2LMm54z2GH8LmgS
HeOnGHTRQ+5PXBrYeeXRC3xhrAdChdrHo1IwMLnE2KHIPm+QQGN6tHiHyU4IHTET4ujVRp3cznJ18v1s
34OWMJfGzi+7Bu0RG9vruRwptmdomOev6aO6LBz7Ydq9/uHGImOPo5zAl0jGQND8V2PTanTO+e8+Zmxo
v4oEv+i1cvi1PhJ89CgQhH1/x243tnbmNdWT7yEOPFVwL9u3rRph944SMIQNYaM6CsYL6WbxdofPMWha
vq8LriXpN+ooxlXr4CqB0B4dt1RYhdeYnXh94b/u6YZr6vj6SUljjHGJRkthEExwTU0XjujK4HPKLjuL
cfq/neQSiGUilQSxibP3NZvVJHg2prJVh6T0HiZq6PvGNHTKvrFuWxpWK8NnaPSmXPNu5NpD2xoPY9TB
JGob7Fimbg+OfDz2ffnDym5N3dArhfd5vwPb8/WfP7d0egAYY4Fc5/ppsVgJE4nkEzRFNnLs+FlcQfoT
rCvOFl55pcgCYLOFe9XZurMxF9qvQ7S8gqnlAUrpCjBDICOkc7rygqVGUfgES6aGK7HF30BRWAaL5o/B
4zH23av8YJ9pjEL+iNVxIbju2eUSMWMkPk7eICbReePkEzun+wqcLZUy2IaFonYwdfv7nwfR5CLiKt7e
u6frZfdm3dZSxJNHdfU7XFwelzD7N+pQsrWd0L1i68UPSUJPag8+JLExxtIRtXUvt5cZRuelzzvDVE0O
1borie1l5UFBC1WX3e5K/KSDzUG9ywiyB69CMIR10ztU8u04/X8HxarPjFoeWnElA1Zd3A/mnGcob0iR
7aLWqNGZXfxVeZ9n0ZwxaDy2F5bPdUClFdGxyLAeCOAiJBNzqd/22ORrwvdC1nOtC+KvyAKz5sl0oNqD
g1L6i1zbnC1aaBmiquboYGv30humxcxx31G9+qNXT1SaQKxR4BpPnfszL97FeUZR4IEJ8XMAtdr0PMpe
EsmbPBMGgYgAB+wQPXypzZFX8LgzAAPoodHu75ITXrP6e8d9e4oIfzUmVInJumh+qjS+d0P02zACOcug
91wutzLlDADLrdraC/ZbiAisQ9VjrBeyIaSSepjXWo0dbs9+htjgNcnkdUwUxzxQATNIlnTwY6xIJUN3
8Jc5HZ2Li7fZ+Bbf9juME3yOzgEUHjIZNypJ1ApfJQFUNhBQGvf/GHYA0OQlX6DRmRvBWgTTkzzTuRKy
PVXiEn3Kqddka6IpjSfzOLBtQbORisvv5txZS+II6wOw/Yv2MAa6sG5+h1DYB9Xqe/NMjMPTdpqGCy8/
4jAcXIHUZt5uIQpf3lM354mnsdn1+C66iS7Mlx/DZVvjvDL5h5cR1xJDFBZPZebg+2ZcnhCMhukPGwYC
2jzT551ciJnLm1JXgTfmbVuMedXjDWkEzL55Q8x73jg/giIrKuSaslt0NUsj5UFokSVltFQj4oxfmHyD
HF0YgUBVtcEHAtVxv+W1grGEuGgok5hBeMeE9X4Le6QiCC0PHShXFMyBLytBTcfUGS/tQkxVLWiBA9yw
iunp/RRh9PcrM8E6djBVR38WQG+Qmr9DLhUXXdwUR7hsV3cfN9I8ijrDj7MdT9jI5GPvNDyQzqULYXMo
0MPjjgoOhppqBd8zvauXOQGmlGGeFUE440ZZBQWCuyUmJKKL7levS5tFdrKoypVNmRo+n6rg1J6cHuM+
DJYBoRFMwqsmhyfo42mUP9LaS1oBFRFeyiSg17TEEshc2/h7mlHnUPXHNl33S/fCbRqSb47khF39ld7J
9GCGA6Yp3x5Ov5sXhkxkv46iYgVG6yBa0x8NZT+i8cRrGuWend0kZprpqGGGeX5bejUuwdnHbgEmR8MU
fusVVGOYM7QUREUy8JST9TUuvlqWhh11RoYIEL7UdakzX5pnplsnPhqCGZQFmLiGhyeEkt7Na/c+DsUk
WgzclRmP66aRzl2Rz1UvbeVu1DnFPKCihpPrXV5KjzA/oGvjer/iiCvmMfx+bxwrvibtiO0ZcAcEiJTL
rq3q+X4WzrZ69pmQ1loK+QQoqLO67xz87wEX2K8CB2D3QTwoRmUp6MtItPJ99aaOY7dxJ7avg8BlMKMF
6605OVVflnr2JJaFMuOXgb+XOSFgrMv+e8WOjrmTgUmT6fqOFyKl/gdB7fWPhxKzzHrpwleCgVtz0vpQ
nWekUjwHKLGKr+LUAjsy1BCCw2sE3pogNpfute+eUzu8zTkPKGjkK2mZnj+VJPXRnYHUVlfb+TG2uwD3
vpf5HnvlNc3ny191rZuL90cuO/T8YwVmNl2xm165Xflz6VZ2DbuFYnkMu2ydBAt3fOH+uNdhWlpt6hHr
+xEjsFES2guPFN3tqfQsbbm4J1TDERNLGv2eUD3ukZ32Yzt7+6GjdDWg9UlZs0MCdEkvu/h4BhmVK5ZM
Rof7msmoMImgrTyJlkDjwI/VMbQp3PYQY4VLoiup5IzvDuNAytjyga5/7MkfE1H2lO7NTEFOiCKGvU6+
65inTzsgO6FOC9vAkZu7Cu4IJhVt3PbDBzmVzaVZcVWc/BFAr2Lt5RECt+eBXz+3IojMnaTzTMQnzD3C
K67+iA9Gnb5wVUlh50BwSgxctJNu3jv8eozdoQ+5mK1+OwJBtWsieF46/gRuKvEfcZbIZqQvZSJsoU4I
elm/516N09NFQoDn0U47hX4V4n3nlFBZGHVWMqf1jnvqK/F45um810Uxza6LwBvnNgWu2Xi73nfcVB/l
K8VXc5bORv2X9NYDAKAXolNhW8u1Ue+tkRMsOoRnWqsQg9UVOx83QLGfNxlIMaOhl1smeL+dalJA6rM6
M1tdf19mIa94mTGZpbF/gtaDiodcAOZ5z+L7WlNDw+ziXR/O+0Lk++xFQaokMpPeWUK3ZmS9YB8r+tuy
OMiMPSAB7ZwuI9ps4qQnxmTRZ27qz+a99QUBDWFL2kAQLqZOnyGadakdRCbCZHNHRB69z5lps5/loR+Z
SnTzg79tPBsTVHVv6/X77gi7Cgoea3gUuj0LqSSbfbze3jrPZgJPtzvrMSSjAUBKqi5HlYNIXD3Pb01m
MXVn6uumgPTGiW4C/hgQettVCiEJJKO2P9EtQ6ihio8phK2hY/hnsPtHJcLcFp0GBTH27SdAXyX8TDfh
VK/uVyYRX5FxdMHT2wm1GwCr/pH3fUy9vqq1HTXXQUZ7QMxPMX0s+WOW9sZrRW22PeQtvttpd0nXIw52
zsHEY79nXngoaCDRr0/vVL1roK2iqOr6RLqylIiO6CuCNf+J8GCm7M0pcuJb2GFL4IBOXeGvxO7Ngh9z
TO4mxmdYlT0Pxc3sU7wde3pLRq1mcNlQ7Z7N+j77OJyWBZ7OIcgnPxGnst6ddK+cMnFz/nqIYGwsJjWz
PgKAYL/SJa/3kROTni14Xe7j8XVPcRd+XL4M2xx2eQXP2B9Djn/7OLUBWN2ZKmNivrd6F9rOn+O+1YaJ
uxCkvENe9jmic8azRUhCpySyQAuX8Dx5Ku3IXpd2iIxs8pUQ/efiP4xBZC0hvzDvbSey2eDiVW6MD6wt
m5ABZvspyyoEG4YfZwiJqnblyaieEzx9KqjRmvLFdObCFpF68meZlozu4EVN2a7PYZkmPAPmpvj+VphX
88dJJP1Ff6ZqO3UXa4md6TeHDejpriKdbBAomNnOPdPXL6xso8nxNfvcvtw3BZ14Rwl4lINKoyKstVbL
146KDbKYO29Y0ws3IhoZPJG/MXH/7rv8jGBhrJ3EYepuy279zawQeRUJEyCg1MjEhu2A0ZUnr4BTqpO4
oNLWEmeXtzBJMIZH1yj36/dwmL/lfhc1HlwV2hZRnzpzMovodRDfqMQw89hiCF+nK3fz7dqqNjkb378Q
0irOyw5bBsADs5kyk+/6GI+DuBVUo2JPPLvk6hWEwND9beBe+qcCuldnZwzNJ522axOVhwyLCMjv2RUj
2xnljTjl0Qs/nYeIQlEuZtkkFUX4aXp+fo2PnS55BxA2tCu5/e/0aixhZRuKsfhD4l0eHk6podJ49Hf8
NVGXXh8qTpvuhY35WBA30wdKPI1Ygxz+JJkZuCrB6b7U5fF8LaHBmt+1mcpWBM+auLZ/isTAJHKndJMp
ZTXSN7l61//KjTB9MmZJB9uEoPGyihiCNU0DabF1TiyOxMI+oK6Cr9lN4V5pC1+e5pHdNDk9p1hk+LPz
sARRME0PGXfqmbhCnLmiSYJedOllGmd7FThV3DRZqvzGYPUY+arzuCDASZ7/59RNl1dN80a7+VmkXx1b
UhTo/OPZzfAKjEe78YJQsPH826MbTx2rs+hLunXzGwWsR5tCn9Wfu952GV+o9dOdKwI9msTB6IliQsLY
tL+Rm9RpM6vXyFDRR4NQJ0oaigLsGOdx8e5b5/Hh4XJsYz32sxT064HUHFvxu/0EOhHkVjupe5cqWyR4
VXDdjhEN7XJl0txQGF4l9+du/QpR7e30kAI1Tcz9Wq5LKNH4m3mDQEi7SxTwGw6hSmueekPXZov6sIPh
7nZapq9H/fiDxvNc0PVolZvgdIPUshDtGKssoQqiYI/4/oDAxiuItz2FEu1iighfR4eAj+sl1S2DJCio
BjKZXHIR5emzc71Omimhoqy+QXSXnu4IOW000fjuH6BYLBXynPSX5w7n2PGx4HEX6JzXTXf+Kkt3sfIY
qUgw0l7oiUT023WxymwS52JlUgZf1bRCqt7kx3A24qGDOS0JDpv2E/LZeWDHk76UY8yvVdITy3G6bwUe
2b2x/5YpzGY4guXr+Oq12+aYocqAGywco621f8GwOGnBYLfyWC4CezvRxtB9ZdNc5mIovvQgEGTI31S1
B6lPW2YWRz7da35I/czMDhIAIJc2uvXYCeRz3onc/R+zHKt/Pjdsr1ey7Wl+hTZX1rvK59CJMrc38yWz
it8OyOgZvumgRwPVslqWjSTudtD5EXYRRo6oA6pERagxk/48Xe3egjs9PTdcP2jEXtDtoAeBGSomdhzC
fFaaa+gC6NfrJgqjqd3cRliM06n52FjUVKjxEVPMpDELA1X7FltH4j4uh56Qa9CtipJCWqN29VB7u7Pa
stQsYb4jddb257TJx2FYWwW83Ze9Nlt0AURj09PljZnJXZmon+z46W4Z1BGCPi1XYzvBgkKGPsuh7jG7
NHukNbREpMVXhe5Du6yemnrQ910LKibZCrV3btl6lO/uLYr13WPb84NmMs/3rvrz+lyW0jW4vw02DW5q
9ZpNR1rtBRzF8fO7z0pa7YDvDvjxajhh6YQQoIW8f9w9waXSf7wJjXfaziAp8FV+NdHe5Tny7eX+fSbU
bbIRqiHuqRUuay5s5povsr+SGCGhbuRASu8DWkCUCYj4rBhalYaTkZN8xet0H5cY2MuOuuzytSDiDel6
57d8wsOsmHKV9TJUZMUr+bDbsrn6WRThcwJ9IhZJud/lxRNlcdCCAIhzbHBw+kc7bK+oQb/OyqpvL6rg
WravXmTonYl5hTxywyiqfLUkavY2XdZS2EkmqRUiYqzwbvreIgPdNYP6zdUju51v7nJNWckHkobPuF9Z
ESoMzu6OXT5q1LvA/2NUycbCKV94Ejn2IWR5dn/hFdyRZ1zciZPiCj8YhC6XnGSYg52ZDPN1FPmhul/i
ZFvnyBfba6dfbV2ogOdqW90In+LdHzBovUk+sVZC0JdoYN+vuoTArq1qjHQ/9kfQtL0Yq4EjOgvXt0+v
/mgNRGN2NfFUIRdLiXFEzbyDx/fLxq7tk7TIJ0oq5x6ave6PweyPeNN1Gjs0aTREl7WP9Ou7gZT7rapr
8u4DlU94W3as7tXu0T6loceWd1ezkFsHpxtJ7TvUb2VH4gJ6+jqw0lTL3aTmOFegJRAQ/c+vonLGIwPr
ThPGhVZHS1jOv4EmZOsSW2LIjjAz99zbquy1xfxkWm9dmpyfWZrWXtFYj1+NnvH012lB33Z577eBso/C
7Qxq5WktQmM3nTcISEuKbIY9kAPje9tYkEUgIt/RpdRosb1SFT3+8iPWL675U/tsF09MADfMZqjT73Ta
8RlErIe6prFcZpdWWKOXRm+M67k8Bkn7aKtbcvjDoFwFqW/aBr1jiCN3RFRUijvBIuuMjl5uGt25xsBc
QOLPn+n1+vVTHK47bTrIoWG48cwRoqZm0hqvJzq3WLd8HE4gnlWv8uqu7o2X/tMnLAYYjbI+9vxTWT8N
DrfhEZAx9kRj4BZStpgvvd1KyI+MBg8ddp14XF8pRRPctmL9Hp2cLZ89erym9ayoDi7DIstQZG2t7uGW
ZtAZMDHbYnzqsGsrIBVZvwqb+oqJLc/LGBQpeMvIyCnfrfrj9QdcNaHc7K1Myu3NQj0J85sCqOHVOQ1y
Hx8UYbaUqTbnvG8vfpxURcMvcRCBie05XLH3cW/FTiahf9qu+l5YuWWuuLVm0RBd8m5gPUZTr/VOX4Sm
MTI1mbQzJFrwhz22qRT6rIOU2sv4IXJMDoHHOuIk7TSVqUtL5yM39IiV3TDo1xegoCoBKuPfQs9r39yB
CUa/fGhu2m5O4yg8UcDzor9l52jUmBAXlOs45YImo9F8HPge6X5sbImobFTxgoIvuN2MjIqTwsNjXbuM
JcYi0s4OX8hGmD400uk0yEReWq03CpWHeIXFcdzxRa15orknxwluIMaxIS6Ea0HIuo2hgdMsAREy4Prx
Tuop0DI8HjXg0unDfT3fRuN5ascMXSWBgNwrCAXXtwp8rXyhte406b5/um6yNmseND7BAuqKMnDT7mem
wHSzHLIpCeA+Dpnl/qvqyG0B0NuwFP3j0wiJATUH2gV+ZQusl26/Z2cQZ2r3iSQX14ytHXYbtvI7fA5j
NMnagyC30LRy7xP1dSioYnZDLMpjbXdkzvd1my6ASU5mxCRcCVMwAG4469s6SBXj3KtbQe1d++xtSssn
TUthPLMlDaBAWq1V7e0kL+i3XV0WsnbGs52yQZZapQkKEQsyIOnOM5Na+8YFvKB5xeyC/Ed5AGafuxm0
2nvzG0IP2kk01IQp7GUUDVDsfaWkg6/2zjWc78VV10cbsQHCtq/vcA7fE2otUdLX1Z4lBVCT+xTXPuJ0
rPQNVpvba2r9kysris0PAdzZlHRHsAmtzR5WCW3IsStw70r8Li6d4LnjU9hXXJDkta9++wrOXbcrzTUA
+0oJev5nJ8jPds/y5uxsi52jJJ9BsKjccRQf2Tcawj9RVBRjMgSkZVzyMYGj34rCnPcAZ7i5bh+Nq8cd
6bHH2Ijbu+F7bS59+HgDFyuNqa3WrB0Vk98f+LrvxTjxTwHQ47x2Kw25lU69MLTM46V+H89+yqg0ytFH
joe7X436WBwk/KUebdspM6Xwii6r8PLSEnf4Rx+2atyt2UfuuxkaC+3jQcJM0pc4i2S+BvgNO4cilxcU
4ieFC0qaBgbCMluBnespSYnb+TzwksxVtDa8ZGNNHp6ZIosZXPcr2GOb7dV5snyMUp1m7QA/mw+CiXxD
gESL+n1j7+6qHsspwAIUhAyFla2yRENzaArye5Gb2dpJlcU4IFh1bo5yq/+Rm2HFE2khY3GZDDE51S/t
bwmc/I/CWHzcxri1nmOiYZ7z1tcoNSzls6RCnNIcm6A5svd3X6sS1Hi+S7hMG5rsm07lgeujLfb37VfU
TuyNNSEWxsdYCccsJOhLFt/KxtGr7UYvN1/c6omL2TXjPvyDhQ523iTf5Ro5urLcavr48PLGgnS0RoFG
5gJtnQA+0Fr52olzpiiVXPAB5qJYD5X+SZuc3enQcMblXH2ux/QHDLaeuKfaYtdX+hw15ZMyvJIgNAI5
tyt/ZEVpCrWrx22yUUMnmKn7lXtHQP+a7WiJk9V2TMeM5vCg1AvQeSmXhcDlTWvLYEnVOKLHTXYrb+VS
/YuTTrV9kpG3U0zieoI6kDCBsW9mpsu1tcwRITWAizczG06uh7ZTPi7Wnj7hKhtD0JeOzShUgelA1z3b
wexlt13oSsmVRhQZohqFGU/foKFlXMPp3Mh3BgHwNwpkBFQYkLH07R7tUc+RfXO9a5Lyw0kZigwRg5Uu
8/P+/VYzq6Lbm1sqrzgi6TLQedXaFXv19YWMz/qN4s31ZJAo8iQ78gPOcdTCnEHBeXucECLjQr/mQ0IZ
QHTHhKA/tZJlwS9a8cOQDenV9vPcw8OONV/q6HDL9XSH1GbviMS1BP56GlDLDwNexDwh3+nozqmoh7xQ
htsRUQxtwt7nVsSl0kXq7RS5XxNkQlwIiyEQRGeqXK0v5BfTeCgCdyqOFS9OUobAs34ySzWdedk6OHjF
bWTUcuq7xcTLSGOAJMqLi8bErQafyz7q2qz7+FB07fx2e0asuyQAJu7LcdJ9vatX5wnjwyupGwRIK5sS
vEqtF1jwm0WuuyoJ/Pwd+nFOwEPNCZZcZ2Q4962Dw9NO1zK2ZdLoG1OiMmZg+/eWX/mnboJbLiuUn6lK
Pkg3bm0eigt45nmdRJfOJMNYONxO1gqel7F/y9ugRk3ZNARrbC/X/faYD/p5BPhYlHOv8m1XF5/F0CeU
n5/LD2AXpD4um6pQQdSSWe/GSpVNaxfJenJiBxIk6GrsQjIzG2UMmaSfZXtFhhPKjyQvzT2zloxkns8V
aeUZsSeEP7C28Kz0leAE8Ik373Hm/A7c08uQZ7q8DWTjbFp9md9R5CWbc3m6U8qIoZbwicTBkKG4dGTd
oWO6slGx0a03QfNNvhLLmK3tSiU5aDIfwB/09n1u9D5eCZ/aQwRK7Zp8Hu6+MM7lopzkkQEaMH34UrZI
k+dGOZ/DjG4pZ674pFn1PepjjklOIkBTevTuzmEqJGMVsSgD5Jn8nBnzF3KK7C/n4A7qOxpq2oLJ5Kcd
HeGIzVwfP6dcjTebw7E7JPW2VJprthoeSp+Lbak01IxKfhb7rGlOVGlwg4TjL+aeD5zfJr7j7Ha9s2JE
yxgVYFfckhWLJ6EowsxVeh+HIzSNlsv1dDrk1/lv+vTVFn+zoMheWw1Nh+p75ViaGtQRh1V1OcrvND16
YA6rP0jBDF9A5wHrFWU9JEmCX6B3e5V2xnUaODh34u52nelcPt7jPrhgEKTNwMIljpiqT9r3zle9damb
N/VwlqcVeXc12aswBSYSfg96/c9Dxej/WUGYRP+9MgT+7xWEhvnfK5jhf6+S/zx5/O+jxuD/vRJJ/vf6
P5n+f2P9P5n+P7D+n0z/76z/D6b/J2tvHYEk1IvX/m2IfV8/lsDRI13UI9T0zsSS6SaEWTLAp/OgZkwi
q9/LVShOEounyOYWEkn4v/sOLq+MjHEYes85UY9cE3rf+MFgmPGKF22hqAe+F+WSkY0lOAwE8cc/BMo6
48Kgj1EPXreTUyKbHTCJNrw/DzwCtkEnA6BLSQf5ID51e3kUlwUNj0X/JNAymQi9wYj5tXfYAOqlfOhg
CfaeF0Dt+L1L9cEFij+hDcQ5C0EKZQ+kLKoYPD8kyVJFSRyfRDi7QSJJsx0QnftpgA11VnIt6Eo/a8kN
7Zd8RH5nnNh5KUpg7Fn/xdtE0LLzAHUXFAIDNh6YusWs3DO+yofyBVKyVc6du1S6kB3X3wOYUfDtm/GI
OxsrgA4/EamZX9dJlkaiHhnfN51vNXJe9B/fwDw/SuDnnjZd6ZLpHPqzQQl8NGprcmrebPMrVcE9OOWw
NmhCxtC3soQCX9rwfnY5Ec62XpaCAuo+dco8Y903eBJuBhioLaXvahSPcLb2shoUUJ+D/Wn1GS8vLXDk
j+l8lvLxaSZhKx4DttR7kUTH0Ba94fsosZ8dt7iH8gxcHCBArgyhySU46aWw9bAKM1Hg4/Pso7abze6W
hukxQpyjrhK/t+JrAafCyHrCmCzkwy5YDHNoKwawT6d0SthIMLYxxneYL4BTMl7C+AZjZtrYDJOYP/S6
W5ibP1b4lhvYN/ijOHpFc8X7Vx0218mGFOahrjM28bG0cy7xS0d+/8wi2BmByB9h028EwF6Cz73C5JRd
AdFmBS4DUy9fgRkW8JnWI5bFj5/+lP966FbqosgX+6JzaECYjyD0k04xytAYxYShMc2dHy1o9GPMUlxK
Bfd4Zp4M1HpMtwZIaKLi9m3U/5/U/y9JjVrbflzDQBigYGHhxXIj2AHqT69klF+WS70N/r8CAAD///p3
ZghLhgAA
`,
},
"/img/tsaf-logo-mark.svg": {
local: "web/static/img/tsaf-logo-mark.svg",
size: 1322,
modtime: 0,
compressed: `
H4sIAAAJbogA/7SUbW+bMBDHX6efwrtq0iYNbENNH4RbaUlVTdpDpXWbtncUDFijEBmvhG8/m0CGMhRF
qfIC+w7d/f5/Hw/hzeqpQM9C1bIqOVCXABJlXCWyzDj80alzAejm+iR8tfgyf/h5f4vq5wzdf3v/8cMc
gYPxD3+O8eJhgb5+v0PUpRjffoaTGeRaL68wbprGbXy3Uhm+U9Eyl3GNTSW2laYLGxqlbqITMBoW3chE
5xwuiDGSC5nluk+Mz7LmE1yPEGI5hjALM6RVVNZppZ44dGERafGGkXeMvLUVs1CJWA8y52MZn5lErTh4
zOzteq91WwgOqSyKK3R69hh5ySXgPUDtXkCaMu8y6IAhzuy6jHSOEg6fkDlYdxWjyNkKu+UXIIvjcOqz
QDwGVkRVv41Kk0sthtTpvVK21vunFBxZaTwpNhoUJeT1QFwD9ig38zy3d3e20Ykuj2x17TY/4X2KenYU
anAQNZYqLgSKh8PGbR8oQ/Rctnl6/Wu3G+r9Tw2OQt14Daao/Td3uNeXUkP7d7n+GwAA///Sd2xHKgUA
AA==
`,
},
"/img/tsaf-logo-small.png": {
local: "web/static/img/tsaf-logo-small.png",
size: 3466,
modtime: 0,
compressed: `
H4sIAAAJbogA/3SXaTTU/f/GvzNmGGNfshuUZebGzChLlux7We5J1mgmI2MfGSRkp5BIIltMuVWWwVDJ
NhJSsgySrcatNLZMt0gq/tPD/4Pf+Z7r+zrX9TnX+Tz5nPc572uuznZCcDk4AABCDvbWOC6DuELAeLl/
TA3WigtIoIWTBQA03xD4RYByvbK/Pc4JAC6rA0ByOgDscaNkNgBEYwFgFQ8ARiUAIE0uf/a3CfeA9/xJ
O2vg4M9X1VVbyE34I2xto7gU50oAiGUMF/0JY8gWgVwWcKULXHqeIwMAgjgHaws30vuN0niym4fioNnn
9SNlb9JELW9DXt6UIpW5kngeYM1RTKlqt47ghjC7kMHm2fGvequ5x4y6BwfdAhNejLTmVXSHTlF3CCuv
wRmOlvz2Vo786SawmfxB9bJEYiz9++5ge1kX/4wTGGS3EbvsPLIQPzpz4nP8FdrmtXc7L41/JuslM9LB
jaVL1CikBbbylBmWgPR0ZTHUoWFpkR+fSkvmb95ykzQKWlU0rTXjqJJFRBP3JTw46BYr8GbatbdfqVRe
5J6Ly34PlNk5wHCFW630PNiSOUPY4dOLPODv+e57Kpdf+pWxZtahgPDbo1GFn2/dkbpsiYSG134MvlF2
KCDuUk558fypg2n8k/f2ICVP3IuBH4aUWBHXE5gspyIEwnRycAWvoDMUrAkNgAqbRofxNy7CeslXz0yP
XKCZjURtQrBMosAdghaNJoWXch360b4YU0ULG0x8+xVQYIDxYkEexjBKyTTW/NE5dc8BTb5lkAMLIjry
dnrdgO9ByXLCJNIhMzWgJryx7DMrS+QLdT/MLK5duPvX+JmE0JnDV7ym31wtWLi/jiPPtZyfzWuLPCjk
g9n+W392ddHn7nvzn8llmY0wXLITzKfa6pWWYD3fldGnTro2CWKXXrRgxStkFkLyfOAfSzYHUkyrete3
Ymk0fSNoiwLjRrJImX8CYjdt2sPYq6eBQSvxE73mI2XR3DnstFAQE6O0Yu1ooXt8+AgG8Un6tSYycm5F
zpHYql5TdXzU2Uv4V0LgkQUesXX9oe4B5x291pbzQWpCvmIABFb2MrhE+Fu4mdLNi1oQfhaapcH2NUO0
k9a8gXnARDhBgn3no/FtoCwlYWvfnRVU2BRKpna9oIgqdcDg6dEr/0jkDu9fDkjflko3d8LwrIAroaFL
trSj0rBWH2MTiw/uJ+O1Of5MSBuYBtYmCdQB7jxTpOeNugfOsJy6DlBJRFyrsCdc19k/r8tccdb3Qt9L
pAP8OFNxsTLkr6f7pRnrEavUqrH+BZ/i8cL8b9a2LeGJKlWYUoZSWscT9FKgC0JZJo/+7Fn5tqb0V7bx
4kq+G19C6HygQ1Rvz4X3PfCEzKgl92CmPkXbnWtBCcKXcr7tizHOspzxPLPZsxo/wn4wdiLvFoEMwNdP
k+NQndB5kPVLRPyEzhAa2u88dK0Rdq4rSoinFxZezEOIGptX6g8oTj8/VP9lZKM1Uh87fDOjxoTTpp1+
L/KC9LMVWUdq7kOvm4YWUFXcXa+YJkLcFGCrlSjz/Qo/x2/rHoFVyyiI3NSk0Xa0OCdZFsq645eWmsCe
QY+zxtCG0k9nFPxJjhJOo5HEo7gNeBN/715GXC5FhHPvmbCJDbqxbmdsVuLfsSFg6hD9afMFFUystUx2
RUiFo0X164FlaPjOVNt/+J/K02fdhwMCfqzH1RWNkVN9DNyoJu0KK3l+j5jtokj9OVBV0GHw8E9idtWp
ptBbYffpfWbV9H4nNvi3HGv7TuXVU2K31hGsmd8bL8R5GwL7dMvZS+STydWLkOjBeMPJsV4hgQXJZ6H+
/+bggm9VZaYpKpC+HJGUX+Q8BIQ09oJOyFNjkQMTHd4PVHsvuqAHKEcmf6hcCwpKlt94i5asYUjRFUH7
gEnE+1FLn8KiMdmUzuajd9PNGMd+zjnkItMBFAQHD7VUFoWpvEvqLM7MFNbHkE+X+A+a127Qz8ZwTRQH
bxz9pgtW/eFJzZ5AimTqPrncbDOYUODIqfzPxJzVcs5tvFrkeJgXAwPyo9FiZnNIcUlC5KIZU3gnf2em
MxgIB5scOyEW73JShKawKqeGlLgvOqm4aYPqF9ITiIsnQ1DQus9GhpeaKvaWTYm3QfdFIc8jK98vpEYs
UD8OhHyWW1yEiAx/y2XKQCqPNDhdgVT0d+UKc8IYsowbMVkDqs0WVAne4rgDcSzQmaYeImBkfFbgVwC8
ByPtKWjd1T17SmBaALKO6Zzhxz4szfdmc2+5mXn+50C/PSgpcQMipPGTLk7cMBN15nwM0W7Z1+556mn6
Z0A9XDgwZp1gaJOoj4ZPgnSUYRQqfUijs3vWIJnI2yIFmi7bsMDXzuSVbGiz5TakWLLc0WHIv6LHyCGi
Q9U4iVXuchMNGcmF+6I7JEkfSsnp/bHWPTio2RpH2bbLMBOtADm2UOUbdH8BJHXfUHirzS3wNPguNKaq
iKdjStF7tmzMOqVxdD/gR2VSlbY4/og3s1TQkD3ZZdKnJ4IE8uvQd499kpV3/Lv8bt9jORHapOLnNp43
oXVfXbkB5WVjI9LxfWRizaKPga9syCppLvLcX1FrvN1p7jBTeALPrrYRywD8ENwI2UV7P5NVenKW5FEM
p2Kw+lOmwpNlG3Dd6sL+bhAe06TR1ybdgDrfw/QfrDj9/P2TeLrQccexnSLEjkLowAelgfBCyVjep3FT
uMoI9j8RyNtTGyhoSGOJVdEgKk+3UlJ/rt+sAXvt6JhNcMe0x8/cH0i18XqbNfKZ5d8a419e//XVrbqQ
N5nOvkSMrtPRXUEdjgAhoC3t2X2kDcyE8eFt+XWRE/FX5ww86N3BaJqBl6rm679x2VVlIY5xXYuQg1Cj
vk8BNvaoB/EdAijInDtaVs2x5Gj+1GMcpOiTvMm3eZU7V9WtGycGajLVnF9wXwOCFWGO4GC9j51NiUmr
1b7dlEGBb9p1UK8vZYfyhPlmsA8/k6twJaYSxCUr6kuKeknlGn7hxMdHejMftSNrljJfB/UFFasK9StM
pO7ol+OTJmTr99okSx+ciEAE+jih1KDomw4ZE+pD0bOiloWdO6/El6WRiKT2AnOkbeVrZ3fFX0zxGJmK
xZQ8Hujt6ewxaCj8DElnG8raXG6TaAiv3SsqeTFi/4ZYbCmKcObsal6f734I/1AKPevn97LFxkYwc2nd
+LJUFvZdVJOXz3XJzy+UUNDtwV9I/NorNUH5m9FTNZKHjgcFK7I8B5WPii02F8vx2/778Z1qdo6miWce
SoEUe8vpy5BVh9kYemB11b26IYTypqTUqOfQrlDQf6Py4q3/KWarv0t8en1O3y3fgHZ1ME/kq22S+Ief
0kuPr7sm1WuujRTjyKwSpbLsqLnl/kkh1bj1d6IjTK/5tiCxDpG2o6J5LqgzPa6eMZtODCs2xSP3w9Ry
ojAnkokbRQ0gzoTaFcJmExMxfdu+LGn2YTm8oTehBx/iuAmr8fTxzTNT+bFgYTaengJObVado/1VS3RH
d6WNN9vJSiGh/VC0+5nirXcFpjuPhVSS/6lEnvMyvtHmMVr7sOtGjvb89ZwjIlX0hm3GaUad37kwPiOp
4ymvx4LjHSNdwEm20y75poFgRSuE+bTfHesFBUrplTqH9ZhhVf8L9uKpLTcTRtJtr6oLhuLwSDZsINLv
yz/YaYdRvO6SuKYkNJyvvd2wVQTS1qqqrH9+zPBWVed9/LfyFXGC/gpdBcOJZgmog3SYM76rihlSp5Ta
cpsRDfBk56zvp6zzoTqU+j3l2ZNhvFKliaPyKwqeKG8jvqf1Ly0KXo9crXZ1/FvPoJiMdEwiHV87LABJ
cc3FYy2jg9COKFtBG0Le9X56Rfm6YNXIPXIlWktgV5JsfFnDbnj04visN9TI6qTYpND8DdPLLv2ifByV
LQzDtFWzfD0+tvCtoPS9nDmB5w/UHFBxbdUV32mNH3NCTCZjM1GRxp6G0720u7saKa47cvYwWOaSSTe9
ALPQJuXSnfaFnDr1KQ5iFH9pxXztFDEqa+wVHdgJ9MHSaG/NNUER1O0OIVJkK2Tj9nm2BItXt+B6SaDx
P2t/mfswJEia8emtjyqFapO9KS0q9oWCZPFEa8x41pXCild5ag4wtojQ1kaW3+ATAv+ah9aLDxOj32N1
twbGj52eWL6PD/yN4rXUMW29wq8XtTVDX1M13tGdkM8dsWZyJDl29IopLW1jY/b2VDdRnGDXYXgtT6d5
0tKJ9Rx83yXFrgfj4+QvXm5+4NJvXbiQ8bjVIann0PO1OsWtFhy8z7Xeb7W6X+m+gUy/qbMs9haVeUyg
w5eZYETOy1At5KULnNW6c876t44ZLluHP0uSqjaNpkmQ99inv/sBgQdKTfdimaQVzDD9vttu09DKSQPm
uj9yARFhnom7Rj58pxPCl3Qg0XRPrzaaJI03vKjYNapVs6Zhm/kZnCHz3cRm2ix5P/aAHh28a0CpL2z5
O393g7tmqFFsPClEAiXAyP9iABfAUayOrjZWTxur76ajb6RjaHQUq43VNcJiXesL+P5fISyCGHQh7n8X
VL6iOrgF2T+F0xEXKLGEiwGABTHifICyQxghMAAXQCDGRQ4F/FmQAAcbZ+tGS3zq/wUAAP//jih1oYoN
AAA=
`,
},
"/img/tsaf-logo-text.png": {
local: "web/static/img/tsaf-logo-text.png",
size: 5137,
modtime: 0,
compressed: `
H4sIAAAJbogA/yRYCTzT//8fY3Kl5mhIEpLb3ClnOUaRozZGhlz1dVSGH2EjHXNbonKEHKu55lqErZh0
SMpcwyLC3Bk1jf/q//g8djw+j/de79fr+d7z+Xq+PvcvONuLi8iJAAAAcZjDWTcAgA/N+x69D8R7NzkC
HOR9gPyd7M8C9v5eTzuq8Lw7wpEOnjcBAFHJvy8+wONCCO+mUBTsvK3QJEhQRkhua8sfDABIFsPOWnvE
ji0X/a/pUE9er2XWD9z0naegVJz8PfkVsIKqv5RrlpOfhwAUX02YLyzs64Z87A7xlzE39bTTRh+XLbp/
+qxjMjJKbBpsCE4RJSu7a8n1CNp6bJkkRVkmTLvH1kXsJXJZnSU3OftcJpe92jp90O2Lk5V0+qUHiyji
qugSUAwQ7VC3jC2mzFE4lOPX/ow5Ms1R0DWZ+gOx4gWiH/guCwT1MB+GiGo6JoQuxmw0q/Hjm9T11z3E
wi/wCb4SHpE3BZkeHpEYMetFdoqdBp0DVtKYxV/sA4p2FuOYhTp/Fo+h2iEMkkhTTr/VsHUa/Yvxidk3
Sfv0QJD9m4RvNTGOdTmhJ+f4WoGSmFAoeWjslMLW8B0KwecPWxs7g3mqTQBUV+fbQ1oEdg/+MqtHWuOG
DpladshAWElCf3RAJvD4JclCq2nOokbw82rNsKgvx0NioauhxD1BPUUI8qi1L34Z64TJz2DPpLNTmrYt
/KNoU4rhxNWKj9XV1SYtBXXBxC5Md1aCUsku2dPjMfYLVi2dLZnBBmpMZnVg/fg1V75EeZzQWMzQFNgB
ugDgQd4tw/KiH/Tpe08aEhtx0T8crjCeBi++veDxVd7lw5N09pTQEcGtE7Dmx9gkULEBXRFJDc8Dz3B5
EdEP/sZRnn/Cj8eWuPdLMHwBK4b0PbjXsMbmwhGVYBBuK5kXJq9QKEmX6cf8JeKxrcW8HsAtNnNaNSxP
Z5tVXvyalywap8g8+NSx3ZYDTILSx8Hb1wz0HEf+U0RVZ8pJoyvIwCRN5hHUD5FLXaf0PiP2UnLpqw6o
dlABV1NjEZf9NMIK3OmXhTPpmaVxrn15FPYIgsdP4F9snLdxdY0wpPHfDTUArElYhbacrhw3cflwPdXA
RlGWFxeRsivALGlSBRTsF7tP1dZwLbIDyP8I8fXRk7YL6JJyGWjlr637vCwDNMB4UvhRR9b8OD+HFpbI
8n2hQ5OUFhWkRIzAlkDcV6uBLBy1A0kK70dG3YWwdmjMuYV7zyuru4RPI1wUgBzhEUKwQpDoWNvhkeO9
pH7+cL4VUPE9KvpkIaFhMvv2T65IpNSarfQm+mrjm5ud5yX7+h+XELoTcC+ttK5zg0yGTsHuNOy6Me09
l7uZjx31mEL8Bn292sayZH3QtkPm7KoLeHiWmK67SOofgNL3NNfwcozFHoj3Xm5z0W2Ej0xKe9OHCG02
4VCa0415fBU2xT9SbU59fiGNnRpFWdpXeC5X74wgF//13VTHi4ZdKwW3oTMJiz2PUpcEbl0cWUIwpyEM
nBdd9fwdqHDBg8TNDvBI82JyOFFRbMntDTITNu5BOGDmrrt/6th6qmO9nKkmKMa6RrADiC0RWxL8U6Ay
vBAMlTYt6zbY9OofHDfVNl99Wl2taVRMrcla8nsAhZKf4Ny6eGyCMLIwVJX1qVPgzRn/yNV8cpbJsy3o
p1b+zKGDlWW1X4tLrVyUkPm9zETfbkca84jQ/qPCCfWVT5MubFhYHBkp27+tUP7GydaHYK62b/RRJsW5
rDA14SCs7PvUJYeB0kSh5DvyrFa60t9QD5X4jb2wNwezHqQeB7WKmMpDLglau5xRU3SvGq/Lqmx7IdW2
UwEBXj7m8uMZhOGe4ba6OfBlAxf1861ZVrMB9gW6aeGcD0H8rsjo72bjQD9CjNZDYDq7PdSEV1iz9bG6
77dyPzg4rl/ybwfuBBk27oslUX21cLi4wGwHzHqXpz/5xMtjDTtXjmWj7b+EnEdXldUaZlbveT5pyG7c
DGKK8bnPOCTXB/7v+jZf5sBlV1f4RnA8n/ynawYyuaUqpbjGNZG1C2LhfHra5dpo6l8sUZJ88q68Xzvc
C3FqD3s+YzA26BGjsegoPq+DmkkIo/n7EVf5ClVQV73bLaccwcNq7wWmrywr8Cjwy4AtPZae+kbkVX1J
FtV8/fMNLXIqhSuIMOfx2hH4CiLlqRLdwWBQP5HaUJl69Ii6ifKy2u+9/nzyCU2yaSkNnYr66iwvs1+j
z9I1G4+jmrZycW25imD7WXYTqgFiuzXyK6uHaSFdaQraNo6MsBtfTObVc+N7GJ/83RADGdwrb90wRu7n
LcA/FL733uKTV5NjPWlSZ2U17KJIVURkh8y3XWC9RzCLhx/0kSYqQAhVYByolH3g/c5gkY4COAXJzyha
P/J40dnWp+9+furSnwvBLHRJhVMFUV5tM8Iiq5gSuWwkjbYt7k1dEgP1f54javbyIYOaGh50d5CMV47v
lBr8/+aUKGtklz59teq8l4mKt25MN5Pe9tEItK3Ut0XTOnyNuEqY4P159oFT4oVi7d4y7CjmNI71GKlZ
9SNQ41v/fDoy0IYWH/r8lDRaVe246NiYXEEQUZHw0cvdWS3+XVsMxjJ6emrKKdeqfPKFqK2tj2fK+O1l
tFC4Md3FkL49NFcjDJ42hYJaiZIvXs1eiaEeDiGu1k1U/dtxR37NZn+l9lpywy5cY+W3H1Fx35Iu6rnm
KS8vgZUXiud4Inr4reb1TTtKK/YkjTOewVZOZ080vxQ1cUqSjq0X7TKRjlWe6bD/l51t8ZNsYdk1T0Ng
L777e+J7RFJ+w65NALeUxvnY9Lv9tNOqHZilqrmM94sKymvVWP6itQQQ+zypJcQKlZRKgTCEaBxNjObV
yPYMh+irYhFqzjex+Q5uMx9Bl8/VFYjcHYSeybmf+2hW73MsE8n/ImOn+dTFr9KeiWduYEKqzBjtvnEK
L2mf4BCWr7Pgrip4as+J4gQlw5ven/XW1e1mBl35xQ2l8JNm2xX8iJa6oCrPJo+v0tRRjlsAd5QiRbob
nuefgLKKq1mIi5WIlSnIu+zCn1SD03v220J18M1E4fpLzzBiCeCWWsqjFo+YPfeN8FPvEZbPsO+TAsRW
7KTZNPAWgcZpoAiKX2AcoVgvDNE0ArhfKOWUBMoDCCNedbn24NvvBQpqqJmH6WWTLYsn2qtbaxzk84To
WxKbZ0KhL08U1Zgc+0ixULGYhKkoBu5dIVqOI7r+18eBvWYP+umn65wDVQJv6j+WfU5YkVOUZvv30+E5
S9CkNoEhz5LvAdPiFJuAhLSGXYxdnUfbqq+/rKVzPcITH2yo1Ii355HD7MBWDMzCq1/Ltdn46H0j/QmE
5RBirwJUm3b2XVuz6pt5LbBQjuF/GB7Pyuu7+A6LMNxfL4or3Xc1mERM3bvfqNq96gIlDwuW5D9SQbo1
1iNlL7nxuJyTmgCFFa68cPTqccc+onHu3JcpmNt+cC9fX+fuNGzkcI2yC49A8BF4D7PTaTrT88JrjXDh
JgirzoBeNwWYzbuXR3qwRCWbTV/ik68ycbDk6YO47oo7ZgKriZVWJU6/pHTYTqri59gPEBeJ7jwYTit/
AhroP87BidfxNIqlF3Kol6kjAMo97KU+fnBXFyghx4qXbrrVy48UHpHND5BVDWJxqB48/W4gf8qkZvBH
g2r5ZPKr4+IPxdJ0vsUt/KefHvdKL9OAHlGhfJ63rIPcC2H8pkSrKJIrAZpOF5oTMOs0zlyZlINeoE9V
rl/Ut0cFQqcffk5/8ATGg7XNNNvyHpVrAYpRGRCFwKaLH01RhuRA3peebhTa3Sh4vs9gwYtxxkePB5W1
wG4RxNtJLNxDrFYXRkzLUfFLWAXsSoSEZS9684772dFAQrB+unMdSIDz62gAt9asTE5UfP6ieE6J0Ify
iftnArg0ld1fLdeGo5N03P5khVOS5FjbOOpQWG9WQ6KJ1fQF53xefqWffI3ollYb306KBmAU50+4ucJx
upuKubePFoxiMc3Cu5kLSTGwuiJs3HczBSvw0aVh9H/66vCzTuLvT1tbfbWXZSUh0g7llPEamv1aPIB3
VQ53UrBGsQ919OlT2Q9r6I2b4W8LSbeUzutf1jzOv1fcEMHhv4v/bqMNzO9h6lx0hT/IEtwzz0UsZLVI
dpzHlsMy/5Tc+9DbbTQK+mUWiVZ4zg1cLCHVaiawKxsSHcdMPCHux1x1zTmlHjkHslSh5AMpOxprtkyz
jZNS6MtFz0/MxsnC75KcyPHEhkTJhEGeKl0V+aMJNRU6DPogbWxJQXT5arPwtTZEDGEBSh5Fz+daAt4b
jI0Y+mDVebin9nAP5k4cS5I2TnDMeHFDH7bbb1dY0dozm2/aYWZXcpUnXalccaYmZRMkgxYeTovST+/X
v0yhDYAy4uvKak+c/CDlArgsqf8yoGYjpHL7pA3lK4/S19BLd05htwWbpsUSynhKlOox0KkeQroUumaH
Nw9U+NrHHqzl5j97XSz9r5m+s3+tLxvr8JZBNdJouc1SrbsCKbJ9zTWopys+l+Z1zJF0aZLBidXkSnUW
aF9BmwHaeuhJe47wJ6J1J0+nZiVfkxxsbspfebgfHd3RhFTXVh6dLMjLebxYOzJ/363i4WvSO8Sefe69
HM8RKmLqcMp7VRYe9c4MM57ODlyk1WADMOPs+/RHbWVW7Wv8smrK43MI2jcrl+XnDDgUh2tz4w8SGR3V
6tVf1Mn69CM2gPtwTIzngflh3jHCxh/KI2mcYpW+irxPdu4ThL+1aIFJjbbOs6fybpWdeyj+r0CRbO6V
gMlqVuCE6QiiK804BddWJmV8+0VDpyXstYRtMIsXj5S5eYD0M7N/kNUfEpCA/7vGLSxaivSzck2rQ17P
sb3KfVMZhq7ihZMOeorJGKLYfLshzhc9sLJg+K/Da2SePTEO9498n/q+YvqrkR2E1X7N4O/qbkTXwchn
GEJw6vtmYT2b+GqnTat/ubK0jH/IsmJ0XPOcrYOSfuNfz+Y6esIvbgIbcW2k/cmJ0EgjvY+ILrjw4hex
Wy5vGSWpaVW1+f8d5o1FyX/z2xjl/yXKrFrwjQdKyLOywteuFokvKaGCVdfqUcgICbGhKp3GzPn+0uSn
pTFp6vOHatdnPmLaebMNMFE25VpYvZm4lY417c1rmJqdEp60QoUwskG3Jjv5/twduPrDUYFq5g6n68yH
GQLhfPh0dodctXOHQ66Bw2+imsgh13ds/U5rxfZxjDR/dLQJffVFOcLWB3a7rg+R1PNjX1y8M6AYSi8Z
BLDH9pMV53Wv3Dg5cAzRycVOCJyr+fAt0F3SPzICuC2zJEj4O8A9BQ4Pvsy614ERpnF20tnxh5oup2B7
c9bLW6/fFAvPeWqufvAxz4U0YhXPEC7SFv5ZH0Hzg5sR0Z+7cyiSNA5PBxNE3KrOZ7ADYNHVDiv3Qmz7
dV00LKqcOv6T++NaKKYlXf9F3tTLvgXXJhJn/NjBH/NJj26JIir6ZEkm0jjagxIvD/7KP1xcIww17Ttj
/wa2ERYUKCteXGcAahUgl6NeKFakza/kc/bFGUSKR9bWL7z5wjIL4JovWBWBU56UuJsbO8NFlR32y4QV
uuO1gToyLeqqFjHCqzTCodZnCQV5kulsZDdz8nNObdllVeu9CNSVzNYF5xuOG983i39iFlR+WwfziQ5e
8xMLD1QTuHUIBUf5ovQiL2TaTBaX9DLn9m1RL1GuJ/sjQCsCMnjzbRZo4d16nMKyxuLFb5xCwQ5lTuXw
4/XzXhlsUZg/Xld11GfDmrP3GPMR1nIsPMX78Gb/htSagd+TqoppfN624IQMWhXU+gFhKQvRRoWn4+K4
F0rilmWFtNQdPB+7UVcklsQPU3p1Ct8Mlix721v78hfKpCCV/oPzTv0kaNuvr/i8MOgaz1mx3x1IaS/p
luhAIGduhgr2p1PNdUO/Iro07487JK+rXvupTkHatNixlIm8qv2SxH6B9XyRMwYvj4JM1IXa3Q4KHuLb
frD00hvLUNL4a0kvn/RLAplCCkpr1tUTwSntjmPVke/axm9EikrzEYbuKl3/xlPNPPAWHHsGI99sZDG9
AyU73SAlmPYJBQh7OY7tSvAlHSJVxNMvftVUX3IKiPQFdlqTnpQ91wLa9TBr364fcTv202zNClbSO5Tc
yHYfrKnnmWzVHm4r5Sjzs8ilpP2RDmI6rTNbC+pIwgN0K415KY9seXzf6AJf4bNypG3Hu9cW8qZSphKx
rceGOoVHTEDbrYWrN8H1hOyah7mWd5Ngvk3geR0IDxjRnUUIo1klvjcC8M5MuVBcLI1adLE8YMut/fIc
/IqRqhHSUkOcSqyuhl9m+GZRi5zAq+0VZ6d3ZdYUUNsQRkczubShU+KGOotm5DVHqKW7XwjoHzhYU1Z7
S2tFt4dpl1u49Ec8g/XwEbBQYjONytUHtb66s21xZs2z5ELOj/Dja4XZJycEeaNLlN5bf7GVcRXouy67
XNcQNDWtA0wWrafoQMnX/CPZI9+UZ+P+pwSCV9wUdJvav2VIlxh09ZY3fAqfub8jpLIzFsHz6sd/A0zF
TJOXDm6pIOxyj85cyvU5FjHcqEfjcDFYm7lwwsgMnf8PYq2H8ywTJY2e/SmYqAQzfMXKYLP4dtavOzAS
HLyNP548NOOTm90pwe+ODYWSKwSvHu+rSHLqKa4bpXFkVUofNuoPIvYmciMEtQXO19TUjImo9iC6lPru
0hVgmWHbwBbVvutjT66k+SJjJ4xuOtWCJpX7DPd06rOv/OidwsIxwdhHUPL/xgZxPH8gtW074JEzoYBz
c9xVbHsTdby0dODvMz4AzNb5bK0NKvn/AgAA//8NdizKERQAAA==
`,
},
"/img/tsaf-logo.png": {
local: "web/static/img/tsaf-logo.png",
size: 15788,
modtime: 0,
compressed: `
H4sIAAAJbogA/7S7dyDbYf8oSmlRtaotasYoWltRsfemRalYVWJHELFHq1ardu3VmlVij8Zsaa3YK2IX
sWLP2jf6nvf9nfO79z3nd869N3888n08n/l8Jt/Pu6e6ahQ3798kICCg0FBX1icgIGInICBkJr2B39m+
GKbC/2DwUHnhYQC19fCycgcTKNhAX4HZNCBWdmB9sJWNj1sXWBoPxeFg+MLjhY420BoKEbC6OiPgDXEl
uPpIy3m7Wlk7gT3YXoHtHFxk2LcaWtjZHGxk2I3FdIR0XJXA9g7qvu5gA19dQ2tfJ2tJG3Y5WTZpbyAe
AQTsYcXmDXF2gQG9Zdj/4gXiv19tC7Kz/T3i4STD/g+mXug8ZVOCuoPZxATE+K2FRITZJCQFhMUeSwoL
87GJCAmLCgoLCYpI8gsLAx9LAIXF2f7bhx1Pzd3GFqivrPrfaOGfZNjtPTxcgYKCXl5eAl6iAlB3O0Fh
SUlJQSERQRERfvwJfpiPi4eVN78LjOOfGJTBMGt3B1cPB6gL29Wz1Sso3EOGnf2fIkBc/4XWBfbf1IRX
mKC3laugsICQ4H93UEfnf34UAvnXaZiHPtj2f34aZujjChbUB8OgcHdr/MXZclwBuwKV3MFWHlB3QyjU
+Z9afGoP9YDC7KGubEpKbDw6VtYOLlfPvH8BdHSAGi4wDysXa7CGsgw7fkfAwcEGKKYoJCT6RFxSSUFU
QlhYRVRB5ImiqriYqKjYEyFJEUXVf8IqQ63hELCLxz9hbf4DVuHfwl7Zwj+gwe4OnmAbVXcohO2vzECH
f8+LxL/n5R+wNv+elyf/FlYQz4zgf7rpf27hzefq67/sFv/wL8sHu+DN3R1v18ZkN7kJCICsGsoKht4T
69Nk/nexTZc7lmwAcjLOWAIrCi0bWgzddcLrZtSRxq5KxE2jDx2nEUZ+o47Q4osaI0i+I2SjJpgxh0dA
hfg6MSFYzbOVRZE0NqD/8oiT+577g5TFHsyS/0xzYBmtXqsoLEsyQXpWVLQ/5LmhIemVM/7R56j/65UK
xP+xkrL/xypPTfivlSCY9D+v1Mr/sb5mu/avlYCY5j9Wtoj/vP6XyP0/EP0vkfu/E/235P4XMv47cv8L
Gf8Hcv9Y/TkzBEj5aGfGx3RYN8ful40qFFeUoX9X9vVi22kQWLqtzfi3ofkKw14tKwk8cjh0677VU8he
TJmU0hKiN95Y3ObEeucXyLRmBu1rgcbS+wHw4fh6dASxESlSiVXcafpr4nwMdXDssHJxzFguSOpA5km0
AF4c4rgBckC/k8oA43YCMeL4xIJJw/hKOnX7EGoYcEx0n/jaa7JW6IqfyPvSv6IsN6g9uR38ffAZ7mE9
4ZXoGVuv6gkIbaXN/2qrD/1GQP71qjLdFZKIPWGpe9co0BH/X2pN/jV5IflLTrVQLc0qdYfpx2YnNU6g
4ymu6TTU54zbkh9N2RuqIrmK8z5EVypoL6jGT5S84+wQi/vT2Z7Yn1/7Pl7DfIGLo0z5EHsHldWoXzRw
+Zdv14xNtzgRIJfuDa/3ieJkOlPNchVBKIOLIDXfNyXqqMSyI2znj1Z9YDnLPMd9VOdhhYjZaYOfe3WI
BKUU9lRmst3QqIaP4vXsVm9C2dFiZ1puaMjtK4tR2JZ6BNAsBRbn72+MV1tclpqmr3TX+7rm8E1m8UMh
PfEB17k8VhyqBwhEkGrBZgOPLHLSRs61O++50YjUevmDN7p5Ph6NMSeWDe+tPP0HQod7My9c1tH6fVsM
W5j0AreUD2uDZmFwpwcwNFNiXS1LwtBN2Yqy1Zzo3sV6hXdDjUV2DSbJRs92i902FoNlkCKwURpJ+T9E
VxomjmTpZcfOxHXFO7vdNFJSCQt/zsIsKSqpmmXiqS4SiQz7GeEyoh4oyaOh6gl1cWo4B/7qHn73bHc5
Pxzsc0NNDc+Qq/VYCfVAi0q1tK+Cn6lSZ1efMytHCyvaAqisFuJv2SHmwhkT5ejkR1pkG116dhLsmahm
emUIDGrKTKVe/h+lH5dmKl/+PCCz5J/kRRnld/URdXDKNDzdjdTKNzEM4ezoUC/r03CfiSgdKjR2R1w2
QyLVfWy0pXzsfwRK6t9Jo6tM5wC0MGCMfOtiJDf6N2YSuMjvQROipEQWXxqV2ty9o0VLIaRR8WyoBtJ4
a3NSoT0aqMRuLuqIDPClfuB++kVcv7rc7B5zD1YnOjZexMFWLWClbFSp+G3xhFMqRqyHm2CJNi6N7nuq
paYkCANSqxGpHqo5tN8YmiioEYb03fLkIdj+XH6zb+OogQzqvNetqv7+VrKd4OZTn99Vibu7N30WMrcW
LS2d4zc6doMqmwBA9WaHITYGCWDNWDbGXcgy8BxLyLvTdrpGF3Aba3cOSrnYR3k2ej11kiyz21BTNCqb
FhTst+C13ATygbGF0GK4doiZnwvV8ZYTiZbzsDoqm5e3ODZ8eSuxl/u9cxA/jZVV+rKuzgYzJ9Ewat9K
oEVDulKX5Pf5NdfJtFXsiaN5iZim0yejHDo6pAHOFAEGRVbrBc4hni1DDiqPxaZeB/lqPzI5rechPokg
NI69EAg+clX+WURmcNngZF8MUuo8zFRbRPcHAIqpmMtg6Y+oWJITBQMBcqZ/3p4dZgnHx87J4oxiaoVF
EMbkPpDhwdi1LbeNBUcKgIoKeHfE8l4XI6pOS8NnekIqw5I96Mz/rX/5q/CzzaVB976BO0flA0+0N2Ul
TDbPPMoWkxMnT3wn2kO8bAWDWUmc2w6s6se8EZ6yZh7GxjpuiA6LgJTCg2gybqD8QzvcCxfBPYeu5xRn
y2Qg2uqlgQT5ld/3acLvT8oanXi+rzmbef/cQQQbR4W7q6grDt0jTD2ZM8M0bKVgjwQ3JhXrf6mEaVum
+4Vos8bbHDdlZLAjsb+Ru0dgOBWAexKeI39xiunHTvvg+FugpafIArVrUO8nVkLpn+BlY7bns/kgieMn
IS+EC99Mlx7UjLGY1806wl85IVN5nhf+Eht5XE/NFvEdwN7auphGyM/fUufSRpi6M3VNUn8Fc6c8XQS2
uNQhF9+jfWTwtXe/2eC09lbqRZaHauNPU+1B05yuhejZQM5IT9adL+etle4+K1FgkcvZMbt32gNzyUy/
fugQQwgcig7yApF6OAZEFmH91yXgR7Vqz7WTvqH5/bjLb31tQXIWp6LvXIjxQe61MPN83nPYEUNlZRU5
tnm5JdZa3Fz7QskoS/qs5xpqi2KNifG2mkpPk4nAOjjAMunyKFmFJTyWVUkH2Qm1sHwoNVw59bbwRgtZ
0U7jDo0zIacZLrCoXmCB0K3lu/TTVBPO0kFQLu4yyyiGejYasf+bnSpdODvPrNeCkFp5jmDZqypr4iAU
nTS6mrN/8sffr74ns2UQSJ3/U7K5TK0a8lD42WaVaSqHXpngpAuuUvu1v/vSK9RWlDbEyIfzFmn8Dxyb
aCzaFyQtld8x+8ABMoLeU0M8zTTwez8Oa+IttCPEB7SGsWe/h4ozT/crGNTcsYi7Uo2VPcZyZtbHZxjz
TFblPo2KZsrlxDojDTfkOW0e37jbt9372Wm308K0WpKerROQ7hPcLjj4FIg0w2mHN/LtafycBsmtODVw
EksUmxO+ij20FDy8/ZotmM3T6FU1dm8rsNrCXatJ9DdqKRdZ6b2qW7dMu8Cep+VM23EIT1CNylOr9FuR
8uAxveesdTThPnv684R0xARhPU5I3Qn4mXdIVXPB1pdRUYEY6zgBXv72RXwu19FJWWd9/fkGPtldDNSE
HsAZtNAbe2vuLaBmlG/AfKZfpnryOOm7ym/PFoPL6vyw9uo1ZXWFxjNE7ZAAkGolEdtTkpIlxUUuUHLY
d1SThVNN85IsYBu0QUlpUDNLn3wV9Itr79EVJScloepv6I6aGqcf2oJks81QAdpMg+iaxtqoSSo/OJLh
OlclvOFUZRuykF5OxEatFJEafMSIeJoG/towdjNgI4Gp0byX18EA4jLWaNxejr5CXGR7j053S8p16pBx
ZrR62TsLu7dzD7eQ0uzy6nxiqMq9qXnd3G8KSs/AyviD8rU8Y0ntQHh/dX3oHEpiWTPNpIbFcwXHWJy4
HuopKUPOFsFmf7lrkvHwI3hP28QoGi3C5Zrgutz8K4ejxHLyXfDtMkEp7rLODUnRKEFRO8BrxQhJZQnj
DNgzX6Vz3dN5LjQNMXfqZr6nIFWikzO+2GAqLB85n3iTYr+VXUlL63IuUVtd0loRYG6I+nUZJ0tqORg3
hj5JMjQsp2V7mpJOG53H+DCzGJuyGmBucNdyCSHHDUrwQV1J+Tn41dEPtwabrctzreiaLKB4Wd4UMsDc
UWZFz/HexgG4Ttc9+/6xsgWvFME18CfgM9ZADT1DUJEYENL3wZrSV+cBj/ceHTPeXAHsGQKuSW2Sv4ZM
dTPba0yqeDR0IirObcO4tSCQAL3KNiRX9AZuH2RhWkfJr1LLtDvhzsEYrlG2iZjO6u/ktSKRZ8MXaead
KFmQWe3YEchWF3cO8uu1Iy5d7i1kWzKg33uTjnRqQBJ5Mxal2dZFJqWOdk9KSIkAFq9RALiZalObmO+o
4k6/5B5OWhzyXFl15ZF3BXZPqaEmaaPY0w+CVDrxLPcPnH33avkQXnrgxCj7LVe65WXu0Um9eWS36+oY
uuO94gEEWuB82p1tDUXoilcv9KNfLk/rBhWOTkTiHD1L62pk8SHh7eiN7Jgvb82rNm44Rom+USgWBeTp
Boh3oyKF6RpSGZCB/ZZwCb/qIaYzPMF3ZOykr9Jj7ryQvaxyk8FaWtxktz38otV+6OrXXP7NLPDJ5tSP
ncF5EQ0pfR5ejcKwYACRlMbWzyeYj6kLiVgLV09j3KCJr4J68zL8U50hq+qp28vDFFlpxzYcPfP6ZCvc
bj29aaQRyTA/PKE3O/5nRgNGsbb0bWxWu8EvynCa/GeC6+oIB4D9UA9jmr5KTKNVhjtdE64n1P0hxk5Z
xdXwQoRfd1D47UJcJsgXnGpMsfFwZ2ezkBw6ns0disVGb25tHYH0TKXBZtAyvjJYFQ9y3s4OKQPdhP4J
UCWUIjjboBE8MzcpEzMksUzGMCg6kj0wNX8rDVsbw4JmbytO/Vk7iRJ9TE9plXyNlJ2UHXv3bqWNXy32
aLPJ6puyWK1XgteHqI+TpXIdu36RXtgnzS10WzWBUWjdTcG2Ca7x5saGUnq+Z882j8iPXbyibe7BKoBn
aiRRS0+nE8UlnGxn7ue9PUls9uevb3RHIEFteY6eXyAhsd0Q/1rZvBPXuGFMFb5GD+7hltJTf/erGhlw
Wp3gJ7DqNOmu/cXnrOBZkpoSJatgEnjVJ3oLZ478Velbd0Bx6/Jos2Lo4URz+i1dhhR22g7T2Xiri7GF
xp3f0DrNUeS5p1C4fhma8PwcFJgZqpAM1SUTDQewooHmE5Z58Oa3MSH0zVm9a47oc3u8n1LzUd5N6m7t
HSMattRmfSAR/aRtAfzY4c6DGD2GB7lqLyzLtvsm+Hgp4vxAPZgU8LE/uu/dbmumNRdgaE+rQkAbwhFz
uaaI2oKMJ3MXi0ryk1/kvlVJ+LZxtu9bT7lyycBTpofOV0eZkdhEk66XcIVoD2R3wbbFox//+N4RKSZa
bt7KcgPPhc3MwI+dCtDmo530ho5OouRDp20H0LtnNLut/LnYblRJTOmZq5DlRZMgt82Jb9uO4vGrBPg2
o/gTlYuLOe/VscbfBpuWEt+qzrBetFxT86rvlsLiyhCyrYwsF+KqqNLIgcBCopOg6/ORIwcgBNXbGtkq
UsAx5Wx7suOvUytkRtZ1PAvOuh+TurS0qNAn5wzobH6orMe7jOlSlczJx0hspehkF4meXlJk+375WepU
q4jP7/Q2fcBnePgWegzc/YMPx9B6kj2quyTtVTMlVJL+c4Tj7MCR4ZHgrGez9M6cShLgpzcMS4OJM+25
YmmwwLNH7F7MjV1y+HSKazBmQ4knhP6ivmvuz0cNUVrMLwK7VycW4TeHL/tW6f0mshnGy5p6An8/NNnt
FUit2yYxaV4oX++Hs2of2Q8a9q1ijB5EbXE0+WVcHBLA0LZdzcEDDRUWuibInll/M5f7VtNyvelqXblH
MQmM+AqybhmRnM94iKr/QKtvZK0vDKt2sNfMMXvC/vyB2bjWfbGv5x9PdU73sE3M3N5VHNQfaj9T7K3+
EuwJnX9z8QrOjPJw9U8IZPhsKXWRQBCA0Dhxrci+B9U9FS0MOU+dvoVPI+qKnTJvQV0+Muno1eV+mUIt
MEM4JRg1g280LNuUq77xrE4JK4Cq7UHLYL21Wf1aZv6PYiaf4b2tGERad7UVInB3eaImKtnPhYH3KGU7
3oDT4bRy0d6oWVncgQ9hKpYgwAuXUxxF6FTfcrrLgRLd9R5um307wiL+GGxbBKLjK5uEc/x6Kskk+at/
IdSBmOYq0FIAyJsleRxIYIsFXdNBu7Pc3BLFJSc8fA8Thobc30HuA4TjohbR1pNdrM1PqEWsfobEnrZX
J3Zuf82l6zCTcNOOiJHeaImMjPwo2xSPa2oMDtZ/F01ZZpZlsilKTnVbdU6Pw9lx2ade5KXO3t4uidPc
RtHvLRLx63N8Zhy3rwEWK7zGUMVanl3nQSBetRiMX+EeswPGfS9BC9u3bNS5Q/scYhwed8Gfwzy7LKbU
eaHk475XNdt5oMefCEVj/GiQZGyXWwcH7gm1mW55Dxefh9NUsbzO3q/8HBUA0lrp/p5L+H0qE/46vDcF
5zh2w4f+Gr5tVVJUf+d0f7rMkzWxKOgPaObY3wtLc0tvcTGpM9sOmnQZaIU8i00UZIxe7G4SLL1VJPTq
ruLmCaouPsmcJ3w3EhvdUpbEbWHCES4i3RJ9gLobbnOyldzZ4ETZWWt93R23h3qUrEavQLBiq8R46Zm5
FvLduqPk+ZaDD5B2An7/PX3VVeZWIk09ws4YKKrX5Krk7/Zwm9p0W0diL5c2YjnUyHE1JeZ+sMVfJunY
9x0Hs2XjHKHc5hBmTau8WupKiWU5tQzt/qBqXvNSX/d3Z79r4JWBWkZNbTMk5EedFHp8cSR2ZYhbT0Z7
3Ht2HcPiBrsq1qlJ29kqP7rckgZuQ0uo0BMDI3yIOvOWe4xfM8eOne9+N/mm+vMNYFGJuVFWElr1MXNp
Nn9V/rCfvA6FstyMbYbM5xkXEq+ONadWQ6cNJx78Uo8M6exWcFE1+ryu1Z/ITFIJPt/kw8QnBk20cD74
MHXequlzMqYQPyIyEYf+cAstW798Nhwem5BaLu51/qNb0+EeV4DUA/Uj3Z2hCh0DDc2I+D7m+UVl3Qqm
Hp5YIgafRPSes7bUAyeqjNizyokYs+fhcXLT4oYT3BIIs+yGPq2k8l/hNoM/zDwp/2j6MU6MK0rc4IQF
pdSy1LrJ45xEGdNupIPnMWIqS/slguN8+PJVgUlR1zY6pUT2o7nJaOnKrO5mywUfcuEXFBxkcV7Gi0/X
j7yaPhEtSoVl3VbNAnnLN0vdn7JabKytcF9esSGDmtVRz98jqCLngiwAaAwEHmW3vJB9UW18kfOjvNkx
jKbKwvY8ROjabMVCxvfH9cJsGDfz9vWEAptAVBubOzIs1bRGJhBJSPmjyORHGlubNBVgpvrcWwFMLzl/
k+XBB2kPhdNPzdE/hqnn+cX0hr9SctgGELJGVHymKAggFwLOxQyHX1Z+LjLhDjgvTeKm40mTY0uuguNz
4xmTIgvTGPClkjrEijNF8CvlCLUi3u7KrcMFPjMS9XEyKi4lVUuKjhlexgRmfqay9B1/UHXVmfyRCrmF
G+P7pBSR0Kr+KZy6lZRUdPualC3Kd3geWSftvHeGj7STVT54EqSAaCqOH7cVdSk5liayMv1gpBzbic6M
E/ZqEjcomVe8hsKfiT8Wm5xHIucxNEJ7qD/A2tvy1ISAn4NWnOOK6mKiP75PCyLD4/Ct93jcHMUv8erB
BJdbPAbmRIF6/unidu19aXprMFuWvX4Z5/Thqr8UKcg5RiX+kC8K3S4B5IF8Fd6Z0h/nN2dpAcWsw4On
K53trZ9M0z9thIOMaupknBvUuvNSlca18bccEusbHmfZXM7+aesmyzogr1ZoSN2yr3e5FvDhu8ups/2C
CPOLsMHEi8JJqxTZPN9x7WO9kCiq6psyZjfUVP6SPjCeNP9B9BsYlgb4eWs+6Hj+/SdyQAjNnwEWxomV
T3Aacwbqdfo5QdfeWHAXnDVWT9qsffR+Wlo58i90bQhNkKUh5K5iD9uFvIXb0yMxK2KL2uECz4vwXPaL
/HNWhxt/8NpCFWRLZiaBFjCOeJ5lSQHQoNpJ4Stu5/sZshzJAbbUW8QhNN6DjukTkqY4Oo9CS50Bze1y
Clj3KAn8jyRM+ecwo4muXQL+Jr0lQ3rSWgyyzj0icxXV2ULjhDcymBXxTs8vpUet+rIwUbz2oBB/mSRD
+YHWHQ4mrPm9qTsJBkBcfwrvnWXfbyVa++dD8b34ImPuF/VuYRAUto87tKMXfrst1e+E+0Ptrknv45Pv
PBOYIXTNdOX1UGOqOGbE7OOYHfDbulr/SdKhT8447KtBgC7St6MNrBIhUxhPyBYRUvsg6n6oDenOFSao
KCl0EfhoehWQNzGYo488Gn1eGBLHwDHZueiysx5h/4UK4oy6FZG8+t375vSaATrFsoml1iqwyB8Uky1x
RCu59Fsk9aoD+0777L4iC8PgAxulzi6rnz1PsZENweGOpEX8H+jR2dPvhYLDfGeXDl9Vz4wI7WYZqdWj
udfpB1qSxe1UMwvpR7LFRN94+/qOUQfEeNjt4VX3eAD6OGQfd4dxCJCXlvq5e610js6zfKt07jOLIilH
eTolT8twOMLC3jfewZgkLYg91jvmECIYQG+jZECRSuZUS4HC5sDx+TOMPSTjCrguqnK5dC4ktj40jqxo
R21c9Jlev1+ROWy6MxPU4PFdWs+p0ujWNOSRVHQY08jJV8JLl7ikwhZowZpf8M4teeo33KSAmnAaKYGv
D0JGZD6YTXH/pt9SHBmWq6lsHA+0RmjVzIhBTZm9+9C+8k4h96r4H8c6EciNhhXYFvamPrOYDcq7LOip
0ZGxcomQTEOQEWe71r+mvr1itYg0DddER7vJhdFYX2St+9aokBaZ0vssFfwYkko0qHoaBPzUg1bYMDjB
Gsi+yJDUFLHQTcNqJEM2t5vNnSLHKBGQUk0YhacV5IORlNTFB59t6OxQ/WgbNj0XaFkpSXhl9oR3VUkB
cCoOr+ZG/ax6q0+31ntHzuxj6fLWCkLMz8vXdUvvmy4c36bglTL//JM4EVHasXH/KWV5l7Mkv1PxIfaI
5ewUDDqtmfAbCJMEb4mbx0iL8+KztAy1YiOdqmMYNexkkKgMkdQWQq2F4QLvfpdrTugo26CD6V4aeZCu
qZC8CQXSN2q0mH25e4+tGLwpNtj2vHAALrYc6DI2sfK1BlSsCBYqLps1++SNpNBpWv19WmCG/jVlsMhC
leaw5ssPfeJfZV4WIAaMQF/Cp2fK9iZv4/MzmN5nrV1hqMrUP7M14jmpcCFrqt6F24nQ7jKVeB13xKc3
b7tVgE99VVsa5UiN0NodEiPPR7s9ztG4BXfE9QeGq07dbitLaXzPDbj8HJMoII0bVtTCBaHy1EWyu3Ql
9/ZMb3MvvIITP6dHLic+d/G6nv3SjVAK8FMUjL3rcU16x6kI+PD2hx6VnfP8tbTrsBhymNUZ3ZJ6jBEs
HMItpYs6MXo7oct4bV0zYBxrJWrtwVhjd0REyv7a+MX03bOk+17XuUMILrD1T6amiGyaiCyiJWtQZgPn
743CKD3snCgoD+mw9YIoe8a0NPCCY9PG7xaJloPCSpJrxDTf7ax+Ch01r8TTPz8++BAXQs1G0NpJVlTv
6v/2rYURLaK4xmhNfiYj2FOXuiWpaP4YLo0VDwlPwLjB2hzWA/DxbNuHXrLqvKgQSKtI0BJOA8utpwFl
S25jo8ZABVaL/AhPhW8XnrfGWwYg/uPtR5FkCFNp54JC2ugXeJdkI20jBRCTfhN6ZZuQ8umgRMly/jmI
0WPbD15eUl6Kow5YcVEyqGos9/Ws9mH2Y8HnGf/bqs0WsM6NYy6nITKA/FxInAjiNG/NEHFO6f+ODLQ0
EdfiqEL840S37nOUYlF9yqzL1sRAu5hCJTM+YJu/funZ+4nSHZUoM53VctzNkjhLRP30zc+evFFTnAM/
90zPsi2in8jHk9+8bg1nJn0Qh7NPnt6igTmOHbGIJ3wRy5KhZIsgsKAAeFl6LcVcBv3ZLjI4T9+iUX39
mpwDA6JaSW7KW1P1BlP6vVt2CMgnusgjMG/RqgaND/TxCZbmMqupfLNnxmNoJgM4jbHGHpMXl7qZNYts
fBTa3fuduSrEtn2ti5JfFGYggWixB0utYA8Sv8uIvMLH8aXWRr2mb9GeIRlkE5f848N4aeYOqN33hrM1
n7mNigFEL6rnPgq90h2uX50S8GCiTnnDqYPzPBcx+SogIl4Ilfx9TRBmoCyaa7QgbwIwp2vQNfHVqzOJ
o5ul9Tv4bUqVXoG78xhfpX4HhpS8qCkUCbG5c7bssbegku9iddUlkHHIvySJ90cEOaSST/Q66BjkrY0g
AhTOKgWGTiAEiBiGlEk3miM+1pJiZtTcPh8+SmaLCIi907WXJxVWWEhavgjQJAV8GM818SA2iP6R/Xnx
25gzbC0pCUnkzW0s5KOJ40BMg+4q7LoHZoo4LG0TmNBJ3VgiqWne/VHfbNcmzvI1IOiG3x156h8OZ4dJ
hCI7PTbAnCzAT+KohcLUnGShIaGincHdP1FEh0O0pJ9eVqLvarOMnKQmYd6lO2bmw5FjZdUXBTUvrkF9
X+55HUIvsnSNkqEFdNULqkG2Uh9PX6azekD09HTsqK5dM35iTk3ACGiMOztZDlCxoD12XQAAf4ZR64t+
6Gl0ysiQ4cR2CL1qrLehyzRVOgqhP14QDFfXR9lHR7ANtGm8kXV2fd6r4FVtaE48++sgZe3hHlxNrsSF
CmFak3VknYyBpw05s5buSemLkadyF6yd/g7yp8kioFYONspVtQqhIZdjHTRxac5Re6uIz3mLS8sX/P3T
7lkfGBI16YtUsvNe+BgpqfvvqQOJdCl53U5eymJWFr4SgpT8t48GMnIO3jtN+2smO0V3j7vV7SDqL2aP
XUd7V00Efb9BtLeZ8ms6AdCt2TVx7w9NTMQ047a4Q44hGbF3QvpvJUO/AoUePw4xRAkIJEhZnlTuLnQm
tKkre3P4OAxSKqpHUetbWDw7DiRmotfvoQhPavjq+4mlmIrO0TwfnjoOU/DSQdQElh7YyTU6www/Z1Js
9Ozu1HaPQKoGaiDSwtMKCsSud0ppyAgkLjZzu4X0kQpmVpwjZQwVoniK/PxltzjIWyYuFmBoy6SHXubU
E2iRsVsADCZ0d25LDoLKekd9kxsJglWXjlyKSbCcFHsvq0bWHa9yTcBBY3xyJQ3MhcE6Q/LDH72A+LQa
GoBUCaERDI8dDo3jTfagwFw1cy5+HlklkwkMV7gouEiqbVeSOWoOx6f8qZipqfaxODfmjVR8nn/Uq8Nz
Xq4hO/DwsJximCR5Z/MGKfsTHfrUwz/hiRLL5Fih+V58xV1kSmpSecQjxUnKCbP153hepY2oRK4+8j/T
7yl55clEkYIt3HBVXEdGSv2tvjP6fp/Fd6fvjd7iMD6E0t0um6UDhAgpkhKuCZOKhxd1OCBuzbNdOblt
e1Hd+TfeGXwvK8ybYFu7YE5Brex6f2nJX6ytMwCd/VwylP8fkP4sqj3cu7Q1QxDHykjKiMnTV9PmKMnZ
sIJ7jnJ5p26i/iWJdm3ey6CZQXyEPrjFEYaMCTNoi5BTVO8V2u0K5gfQ4DO4/NvWCIaQ2VfWCct/7Ed7
PzZ5agdJoPrPs3E3ObLmr7z4Wqv6BsBmZyhTlhzAHR7XYGnOxxpQ28X/4bGnK2lXd3eC5dkSkSLp07of
2+En2zU6vRR7g46TbiCjz2NTBOPEnhn3x1DohOsEbBHUqsGcISkGeS5BO+TZYbGOKuC77rOzyd9C40iC
xlA0Vj8fhkztd0qbuM3RS91/6tU/PqIrBy37QvmtV+e+3/jASEfp8PDZBi1inYDMjoCUPYSmMJQa9v6j
JPC3oJGVzXyKrgKrKr6SnmUG9lHeGAkSclbz1dv5UX9jr0lpyp7+YfzXIn8ZMRUlEDEUzCbkanfAdpND
cErSKIxC91j4A32V8RZHiDfgA32yxcgp3r2l8T2x8aarKilh8FvKMJQHtVNBfOa8lQFzdWZ7gQy0pLB2
Wpm1tLYIeVQjww1pV0ZE1iztRN84i+FgV7ij6uLjooANnRrVpk8FVls/bYq2jNahGL+KIMSncXE/IOmo
PS8qjhCCQ5CLEuOS0ndxC7OOHRA/xrDmr9KDT0TQuinkSD1KDi/tVXOfEAB9SmRLWUO1qXw4dWEIDa1i
Vn1A+U/xKDY8iomXBlK9jd+ieyjhvskF2mmp8hL4MD5OrdpDEyZPxfEgBA/6FhAycouDNbBS+EsrPt1u
f20Sr6FdjUocJqyVvO1Olr5avS4NpyBQCBG63WnFSX9VbS9mBfHFYbbKKN5fWVtjX2nR0nxTdaCxg5vw
od7CX9MoDI97SQnAl0DPg0T9kPgK08Od9R0pOXnKAWcIgWwc3RwOb9FwUT7wUI9hPb5H+P7Z6icZYNHD
ajEHNomyNs66S20VQn3tj/awvLkw84v0VPmw8ndrH3LZX2cLB5QptXZG1sXEwfpXd63phS3MK4tdoNeY
1Y80HR8yJ7zKN3/1YV8m17Ey0cG6XvNk0F8yNlWwgXK5M3rhuj5NMCDPll64FNm4Fmiz0OdgevxnXAqX
n5fj0jTc7JCXMfhAd8Ipu6PjeeYD2Tyv+I+4a0NVN22CbLOcRy4EeIpNLWkUCbLfV+HQdXRjUbmAA1hm
WJ3a0FLPl0+P8FlXmoyjXzB2WasvWThXH3dHteeAog34oHNcYcNm8bv4bTpcoOYOuPTUzlDqY5xgpBFz
/PVZ1o86qUjAXUVpCg7e3hwb51kb5MsXfhoOrLjD8yzzdGOjmuBg/WNPpQL/CscWvpk43l/Yu/g6TGgc
3ik53Jc4RFgj2Wb1ML3QoocV+QwUuXoTr32qFIVmhnW5MstsJtWc3FZs6PVJ3WPMXsODbgravthN8zS0
E0MX4tVDorAi6JhNp5ws5iFOxF2PUVHW9JvKph/2kVpIbFhI3Mdv6qni4s/bY5wFo+6Pnt8pXVlxZZDJ
0wGnEvwJ2vPqDMdRaq5qQNC3AKurku44Wtauo1XucQDB1ioYb7p0r8J6cWKgYqL0wpkCGmWCy9/3aUjC
aGDEORMjZOaP2hTAsREO7P0WaMusRmvXJiV1neV9KJfgpW/IFMzK653DVKdISIqf69Tx7iu10Ng0q8VF
J1Vt+qJm27y4MbiSVJccKwsvrarXF2PSipuvqaZckxp9J4VWMewFY9TuC7mstxUJtqRmw8Qp8/AN0Xoo
odga1L07L1XYg2iOlYnGzZ5e8rgzgowEcTsn3zLmXvw4e3fzneK3uOIOr7jAadPuseqFRFGNTCbFHpkn
Pft1us+ZVXf3IrHLBuFn9KqtjOEaCRHtIv7yj0yT0VJiFhcnxb9FcMOZ7qOh5lOKne09TJ4E3yM9vjsG
vomu+VzUK16WjHwdKGL6RaFHTC7ZoTfnylga76i21+sy74axXF0zT2hsQlsnLayluDHiUtWYXhJqX4lO
stPFnBxjp4POghRJr/nPBabL+meJ27VThjfmPfqZdRpUUuPTJJBMkNX7iFSbOwLv3Pg4dVblU31rHX1R
LWf6wkygeMgd3PtGWkPqGV84uWb+txzFHMZQjckCmiF+gP6NaujDqzdn9DKtqreLIQBaRd1DKQoOGpoo
8MlzoqBduzqWnuREvz0bJ9s36/2PEqV1RJc8SpOeReUbmNFKFutU39pg4u5Nzwo8knbLiaUOlqcEUK22
XTqCV9ALjz+UUO2irZf+/EnU6eWv8Tl4wo8StYaf1o4erSjUX8P7/IMut2dDCNi8A1EnCa5ycSGTe9Fb
I3XyiHy/qGQBXLnj/dm//DTE4wUzIMGPqzPFoiaIbbxWp1FZ3CVPIY8v72SCuNqIX+/yzaJXAwy7QaEG
3nvHftQ81t3HnzCN/FX552mpMkLqIR38fULXuammP/8bTgEB/XgPRnIF4jcS9kH6rCyu52WSam7vZL3y
KfdlqeaT4QljqeLVBo4nbe3N4tmPo36bL2PKXIvS3NYd/nJ8Q8fD5ux0si95qRdRRobx/CKfZZokcHpT
c22q4Biz3IyK/dUAW+yLg3AK9wV0z2ZNm3Y10ZJ05m6V3iy6yJKtTjeTrg3HHu2SoxYToZQoOhJ33JSF
lY8P+I9po5zxJv2UZpgHvAX+Bqm6THVkzkO7GWAqQq7lPcxBraReYwvaO/BbimiF/fCcvWEOrYLJWRvA
tPYPJiWLQxjkJ92MR8s8mlRJfp9uqAZ4j4YV/HU6/5sEJPW+T+0YpmZ9H3Q8b3Bf/C1INfIoJMNZx+iN
9DZGFpNsYi/D0+Ibe/UPnM59ePi4OhJHtwwK3Hrh8k569/jCF2+YqRzP9fwTBPbQdiaBLTrpT5ABinIz
26SL1Pq9GRP7JWNm58g8Nl8dW3M56tPSH979S8+rcdUldcH7kKPmJObsn/tjEJnXTfR4DSr1pj1Omrz0
+4Y9Et/oTy5MZk0Kdu8vGJExe/EwJtDnqQisJOhy1h/7KXZ1i1FgxdpnsSvj5HAxR6mSq6Ez9/DRfktL
qdRDy4uXAQmtRca3Yl12emTJWijH2qqzgDqkkhjlvWL1oIv3bN7mtkvvBGvqJ0fyUiu9aqNwdoGDh9Wf
i/QFiTmz1dNF2/w1rdG8QWZORNTKc0XvAqQ0izmPGryyOx8l2rVoHD3Bl548DxPlAjJdjpsGOeq7BzzJ
ordw4sI6i2mXa07HTWhjm86ChdBavo6QuOTm/o/VHJsboeES8UXWfnvt4bOKEbKNnAcNsZNMYG+1y41r
iGbCk/q+sfDRV/1wwOjMyJs9YcbJKqe5xqfoR6IRs2GezL1I1To/Yj8xfJFKItDQebK1tL4l8qjtbeaY
7d3OYJ2x7BFLf0+JjqODUDt4rD0FhxhEMkVw72jcjwaJdFmEzoJmP/jMq8hwiWdMMwSSA+oel5PB9KLF
JvpMQedEi2K/HFNxCj09Rp59fi6lkT7t7QePiZac1m+qK1wYnQ2cva/+zCxa0Rq6jsGXhBQjiKRVX1Hd
O6hlvybRhiE/OaYE90gtPe4POEAU8wUlo+gU0LmpSrZ4lydseozl0Ue431SZhIa6/UOO+upXJPJCobGO
BZnF1c1ocTon8+UYKXOcyII53XChwzQutCVmCx+RrZajbnU4cU0MREt6eVgItdDVWPYK/opxdoz++1ff
+44v+d8O/pqsys9rlaIdZeLhiRNz2Hy78PPnC0nRilTrU6BATsUthoEfIvsIoP5cDTawgmNy97h5erKc
6LvxW0/Y72NtRkV1ndzqCz1chIB19NgBiLnxDzCnRmD0pPCiDBkeguzLz6e7B75xSoWZKjAnWjoW75/H
CkInR/qUaTUxKMLZlycW4ZIcv06IKrcosX5wZPHRctf3vk10fkYckyBOpJIZg56mXeB82H3uMT/qt9vo
/nix45Bq2ZjlzVcfWJdFERPNm37FCDJyg8Zv9DDlRXfjVPDmaHgiiLFa3HHD63kYZY4W7tvM4EmsYyC/
QyomrkeMTakmJ2AAEjRwMAVeEBcavq1LWk7Y2BJQAr4Y9z5ZTZZEjzF99kttYmaL+JQF9PLIFq/LK1Gs
zeLZXXP3YqqSlalTSl9ix2Vg0My01vzZs4HVA8WoXt5HyTJqN/NhxQZ2a5ob8Z2UBJbeGBTgp7sXbHTx
fr/xyqcpsydgAUNRqazUxK8nBnS0owd0T7HVDYia+bMRyyWJuS2Iy54j+jXGwOfVLK9OYL5Cmfos+RIo
Duds7wJUIN6m0O11T1nqnSqMk0kzZ8+/O9MUNP7ZH0fFtZCuJlVbtpCmCpIN4mwZwaFkXwlD3IvznngS
/GnlQ0wRmCQLGXcKDePSMHU3tEZXzQtU67NwSx3Ur05WHZk5JwM6njXook6eohHfrbZ0pDIQnx8kmv+V
fp5/0y7O1HDpAGubDNIjm8rTsO44hA/z4ExY9rS6m5qdi8EpDv4cjOEVtN+LPeYcN4utbBu6CyR0Uf4n
ojqnTpGZUWsEmAyQ+EjB0oz7i2zBEaCjgSl65x6+pfsCZet0k7v+6GHrabpkbdJqhaYWinkSfT10TE3W
n+ZGTisi+Zmh0Q9dAsuQOOjBbyZEwL4qYhMdmIYL9SycHIlGZnfZUfpZpnHoeU6n7ADRPa74nuRL8ZTZ
EVs8PR3Aan56thCRUxLjz9Qv4OpsuXzXJBsSR79wrlUGaq9njep6Eo/C3xHlifhqmxBia5VCQs/+UtrJ
KxcoJB5UVTgxMnVq8QTMRz0O/8it8lV3i0ieWsF8A7MVODzz5UFUHqzEC3pvUnLmxPedEoNk9AaOKHWM
6FKALM7C3OXqvS8l8iPwuqZUN55EOI0odsMVgV6NYpX5cr4bkTwhjm72qC5CYCg3Lst6s1nSJ+az2K96
xAoZ/uHd40BEo9+g92Xt2BHrpM/KN+tTX1ycM2/dtwTrlkOdpvqp5vuK2t9KHFDRHOsE22r0vCP1Ci2N
z77aWt18vuS6b7gRWdj47VbDjfbwmntS++f2fSS1uC+dd0sdsgmplZ/SOXmZksQNFvU2efoaNSIrLO2O
NBzc3d/bQE7I8Fdra/WuxCTo+4aPKMIlxnZG6qFIgRMMtYyGSP6kJAjCCyMqaebkQ9rsD4uJ/T1BAvV1
Iixt6NXDd2FecHMUU6PMTEUR8174Rst4A2Ew6Zp9W5wzJjUJe+hPx8yUPQxsf4RqNCRpN8oeEPzjmH4n
KVGqvoUuoAovND6BN1Y26upwLGYYHp3C7y7SoYaYwzGEc1tClUqsqvbTBXB2ZYta5KNTgoCNWR8fSVt5
JicD0yrmC1mz3zfDPV8eXnVt9SJ2N3vPbd5ijwqoND+mtB+67EYL04hUQMlRWwG1Hg0Lp6dVow38ev33
xxCpt3QqJf6kcoAkKLTdG3Lrd47nIe555SHMBG+ESPnQvhpfNzd23icZyPlIfMaxByDQTsfsHhgx06TU
Vb470SAM3HAx+KOGaAKm6krSlfO7UpwS/QGHJbX87NgxQo3azJy701/ipqTYMbv2ne2sQ+DfustBii0L
ym/89zEPUFvT4o011dGV0BuIYv2FfEtuHJXy7JkHEdSfGMQmWQKvCsQYfJV946XJJlylOJU7amo5u9z8
4hNlyORqG316Wno+jvnmnv8kHKa0R7IJOrTHSw8EphjzXabUTOz65fo9TmY8rd5/8iGFenc7QnyoBv4R
e3R5snTT7Y+JiZwvZAbEW/Htx8vIb6TH2YMQLt6hPSF3jUJbEfiLeOzR0uUpiQl8+wmeF0c2TKmYytdN
14tg4i1e0yXD7Mka4CrOR7d4PBzVPNbegt4K6Tzt8wfuvdXpFfa7h/eSgLMNlE587VEK9ujBoRPgiMLl
OU6HNEjT3fCbtJvFJEgu07Lcu8H/TGnF7EnThXr02UYvlL8lOf4OVwsruvkHXVl4eGhXdRa/TXuneNJs
f79g0vLMSZKEdLDVy5QCeGEgxgjVUwneHGBZYTVOaUjqQ6flJX7FXdLxB/XcskU7mJjCz5VWmwU9zcmH
ufGNb+D6r9fnravX7IDPzB5QXbq9OdtL7brNssnyRPXAXmDaVA3FOAvuRofv5ikGnqgHGOaqishy6ZbS
x/K4DY5JCD2WGPWbZ9VSLG253F31lfR7qbaKLsz0c9WyZw9KGXgmC0rngtWxJltzwaWU8i0j7VNlhZ7p
T47I+i3SBoFe+PjSUyu/4bT8uim1W0+5CdIYVRmnc8gsG+UjMBrMQNcb4syL0swforIf5QY8fsrqixmZ
mgQceooqLLoxts2BDl9eXSuoduuL9MX6NZ+zN+T8LbOqJJ1HMZBHaCb+eME6O1T9vj8m1ZQv/+4lGdfS
nZLNnTgRIUlV1XzxYunpL+KhoVzu/ZeB7H78m5ubHsh8rPssjHyxV047fgwxXSgSbc/0IJnKmZfuIDo5
X6oSjL2Qxnx8ziPJndliq5uMG39s1qf5Pi7OfCHPbnLYcv3iZH1U5LTh8cwK6dLT+M9UgulDhHXHfjY3
pu2cKEbXBJ8XwsQOdx1TDH71OEhbOvCLtAB7m55d+5K+Ls1v7xnR1OK5ctrNRHj/pRLMoBpxyiS7ITwH
s7p79+5+cPaqoESZS4ip2lGs5fluI/DcWcMk1Ab7Ud3ERwU7J1nkkwA8l6JV3DzZ6NjF1Hq0HCwQJR8m
MKCzISfDUJzQJx2Yz3FFtoa+/rQt5nGA+Qt9gajWVk4LpYjR0EujmeOXmdJnSxL68/m0pvV19qDt4+Lh
V+NSv5dno5YyVGEVfnR7LaDMHjse0FIwL+zxr3X7pXbgkkCOmByXsJ9a9HHN0k3GB/spDLk9PrlLN+TT
dQgG32AtfO8TnL3lYAfM5f8y5ZQqU2dpOrr2LuLJuTw6JGZsR2dt9GIw1ydRTbF5IoFhN+A84IQs9XDg
dHc5vF0L3fdO7nivUKrVMD21TDBZrs8SV0N9jfgmBdnS9hqoqINX+L5Fq6KNEQ8Bqa9ZCQv7RY1jnXbD
kTkm0XZrtQ9ltJ70aDMomdo9nrVyd7F71p9tK8h562P9g+3pHbm9xaIYUsB3h1ZyADFBMLGasmLnLpGJ
yM6Po8WwZzKL7U7h6lW2zyhccN9/LOzOz7bEeaE3yFIdfHF37/cciFy+eJjt36SzWW/1LQNTpfN2UsSA
qD9tr6kno0V3aC9y1ewfQyhdvLwJdM3jnFD+yQe0JPAklOAmh0xD3de9Fgk1edkX5SZL0HHBY87Y7P1f
fbdM9jvNkEJiJg8y0ErtUbIL3HoxxbWX391ST7se+FymQyqlGmL7iP8OpLR8CL7tA++q7V6bySm6tZLB
mTnJpV5ISRY/waVRn1cd+3x2K6FNzd0mhjKibqvrY2JDjOEMH82B9e4EtynVcyMUOrl7Lpo/369QWWOw
2YWGlT83zCvxbXgleG+szZ3tPGR9IpkL58kcR5GKYYJcuyL5BD1W0th9G21YPhwOT5ydCXpztvYrtFIq
3c9wvCujEmx7T8rHs6L6t+hiW7/Ec4vTq6Gnh99eMP/3A1zypN2PBHoL6P4+vNbb6OfXLKT7Lw+xvbnE
DlwnFWLwILyadHoy61hPQLgkVU/wj+mqy5VrxLE3ESYeRP/4LSOoeOUGcYTx0FLPuLzE3zGrttVPZdqs
AugJBej3/nv20xp/t9VXQuLOT4SUcWIIEV9i2aTCg4ixXycWfDlSBASv60KHrxPeVY1ebYviTbCVzYtZ
qAY6iO0c+Nos36sJgs6EudzVr1C8rBN6cSJ4rq4rYb51eIKdfzmxWd+XC5/WoT7ooKm4huAHkR+cJ6Ms
SAkI/LlKcnKCLa6kmzPISLv+/2IU7n978u7/n+nC/9Nhxv+N6cL/w2HG/4Fo9MHldXoCwPhZfQzdAu/V
joaKrnKp4svg/ysAAP//VKmCdKw9AAA=
`,
},
"/js/.editorconfig": {
local: "web/static/js/.editorconfig",
size: 55,
modtime: 0,
compressed: `
H4sIAAAJbogA/4rWiuXKzEtJzSuJLy6pzElVsFUoSUziKinKzI0vKUrMzMnMS48vz8gsSS0uSEwGSxeV
pnIBAgAA//8dC7O6NwAAAA==
`,
},
"/js/0-bosun.ts": {
local: "web/static/js/0-bosun.ts",
size: 9346,
modtime: 0,
compressed: `
H4sIAAAJbogA/6w6/3LbxtF/i09xH+MMwE8iKMmW0lBRMqrsxG6rJrGcTluOJnMCjiQiAAfdAaRkR+/e
3b0DcCAByuk0M6GB3b3dvb39dQtNJhP2jRJzoUQWCpbzYnk+5NmiTLgKoqDQQzb5drCLaqxkWYjPpNU8
i4v443Pkt1IWulA8f4YulanIis8iGkel4kUss/FcqpQ/tyh6+QxBmUVC6VAqZy+DFVfsVuoyu8hzds4q
O6YyKhPhexXKO2CzwZ6XLd6j6bwDeCbUpcwKJZMEGBMwXYRK8CBbXKMtCATP1oT0WsYBD/HxZnQ2GFT8
g1Bm83jhz7wXdDg/KbmKQV2Q671IZEh2aAGXRZE7gHmZhUjjt9dPWbYIzHG/e+8iDtgWW6J997cNKBC6
ogzRWwcyYp8Ge1vMgmWRJidXMhJ+oUoBe91raxYM9vbWS5H53gTUBxZ7e0VcJGLKvNdcL28lVxEaDMAi
zRNeiF9UAsicqyLmiZ5EFRWJMqRhfRwum8tCGfzTyJEaA1+9KfqdAe4QS8v6RNLybnHiIVeb0t4ATGgN
ZtspEpf2SUQWPQKVkmprg28sdJc4IukViNhuiQtw+eWmwB8McIc8WtYnjpZ3i1tKXWxKewsw9o9YrHdK
xJV9ApFDLW9PiUTy6MfsWnAVLqdsDsvFliY6TjDPbCpzXYF3qGKX9mljWXQbwOSMTamXBLWpc6dss75P
tOHzR03BQyO2rdNF+KwyZmGfMoZBjx/EupDqcUsmrCzY2wq5yx0MTa9HGHS38Lzc8sHXvODsDTDYLRVW
9kn8qSx6clYWQu7MtkS+q+G7Mpcl6k1eFr8hWhZLodaxFv4n4wZRrERYfJCwZGLpMLu7VSKIs0KoUOQF
ZpK81Eu/KVD3VDGAUVGqzOzDU+K+FBDO06aQGe80tKQp+argWMRn3j/HV3EW50rOIUKUdwO128NC450R
uWVuVhHoiTSFR9T2iYovKTmHasygNsriOpS5YOKhEFmkqcwZCChg7QwNTpwhO72Uqkji7G4KzYNMBM+A
p1PNVZlhKa+KIhVsVYloVeuKpF18r4VaxaGA2luvmjpKmpJbo4IXwMk2DpdLaGHEdRmGUFhcSWIFR3vA
wlIpeoDKs4plqY2BHWa0VzCnpQxeGMYGftamre0A9JQPWvateyunS+rrsVqNFJttnM8zx6NF8VfxOGX+
Hf6aUzpgK56UYDaePY7Y+bdsJeMI1Ft00BIe6OgQHa/4M2rWlttoAnIxZ61AhL/a5rT3m8ZTRVSlQe0+
t4XkPSjI9tAzbbGs8TnPRHKZcK37aYo4BY+MIkgB4FZleivU7Aa9NlwKNPnUaghB9+tcyfTXFHilLV7v
TTwS0Rx6FMj3PkRagYlia6fQ3qYky3eAkDNzgPAk+a4OEheNniOyjTVNWBkAHaGe1mez6SpBk8B8j07L
JC8GwadtrNnAqJtmerjfEZLahltz+hSHJVmz3U03cYqcm964gd8b4M+fFdH6fxXNhhEeQd19myRtEMZv
IRQ3PAjXxnPm/58Necve5mCbU7MySTANPFniNm2ATYKIPjQliJ2fO0XIY/tsBf97pgq1WX9iVUSh1uyp
EtOW/NRsBGPMbqOKJKe0/OX6x78HZnvx/NFfHRAHOHjGvFGbEUZkPyMTlL+8f3cp01xmsE0fF/ir0QYb
Q9ht2H5eqw0uTVwip3SLE+ZVBahMrKtA9ZEFIe4t4udSqEcDvg9SARxCwKT4rgJYo2JhK/M9EVn1VFuV
Jt2gKrrgRambDAteN48fADMkuvGwVlGv4yJcVivsKYdcCzYMFVyGQ54Mp8zKtGz22TBCd1fDs4a6zO4y
uc66iONsLl3SNVcZqNVFWqEc6gxnCp1KaBNuLjFdiZ5TOBJzXiZFF5XBDK0/O/Y1CQ4s+MkBmnKGBt9V
z6pgJTAE2TnDAcc8zkRk7R2JRBSCtUTNgOUN6cEE1GtDuE0BwultW+NFl3KbTt4p8okSumJVGfq+VU9c
96eKgyI6Sk4VABHgX9wHEQ55jJu3+WJHQg9nTUK0haoJFhz5UOrGbeHtJY8nHO8N+juz+BzzVUfIGiz7
/Xc2HI5GaMPAuo0fYftvFW1SsdUN5CH+zMU55dqigw8AusgiuEkIQxqBVbRMVlZ3yOYkk/zSh99GIFL+
Bv05Qita/CcPwDWgGj/6TnVwIz8KoJtOY9PDVUf1ETR6eWjfpIoX8P7VYQVI4sWywM77i1e3/Dj62rPw
iKs7Ah/NT46/Pq3AqYgI+vLkVNw2UIgMAIOoCUmw4NuF4kh+fML+n2gsPIxVmFDIzED32dHJ4QGjHxR6
g03+7KQDRq+EIKUdwjbwptr5CrcavYRgTNCa3heJXEgPzR7wPIde0PeAxgKKAvqPpUAmUKX1Rwe6jqNi
aYDY4awWluNFkvgeXqSCW8sFT96fzRpt2Ex/nBzbXdwQjcDm1G9pgTxcNULM1tje3La0c/ToVBmsf+xg
1ANA6Qxc4GMHEEIBOy4/clJTlQKj2dHNGXtyqB/7SQ+JdNtIOL0NopinMotcS1VH2msZXOiaINqUjdFB
h41uecUw1iPrbdiiEACkNA5oyNfoloctsGb7wIIltGRdL15vI8efi7WP/zY3WmslTQl52/oQWg4Q0qW8
o453vYyh9d1CjStvOKqiq885HQaO1V8+Z/pep9xSqNIkOOnyS+/o8PBLb3u/23weeh2rOqdO5zLpxNmg
zS99G3Pp7db6JYNLO8KdJTui4Kh7Cc6OT4+D+rg+N/6ON+Lv813j2HUNdPtC8UzHeP14baeLWAxOqmJg
i+ulLDPM54fOdcNgsKDXcedS7++f2V6mzeOcHVWdjLxwS7ftSKrbEHPQzR3G5dW6ZlS3Ckzuy3I+T0R9
6NRG9DpI20Nqkx+wuMP0sbX7XtDYzbdcrPn8bYsagj/uWP+NZ/0RByLDiAL7Erjt+bXBDzq8gm4zA/cS
iicPrUc1JGq1rwC3p9PhQFWXuuUb37LDjlXjseMdlNhxoEDbgj4Pang9YPBGWG4aJc00ouWhm32hpfFG
3Z0eqki9W1y132acEdj+nFmkbf26Z2h47TUEjrEblWqegL0mFwVzv8criE/NDgkIEpEtiqXp/WzzR/7+
ZK+ZzXCu0NEt9pjf0/dVLIL/gv8mV1eT16/Hb99O03QKWbs1ibuiT7PXcK2D+yToZK82hkPTyz8NBtWX
XpcAt9iSeVbT4SAUp4HCfjxQIuE4C0ArTGn38xJcEp7h4se+1EPs4HKuQejwSz3mC0kQja+Rwab0nJpn
92VJz0vz7L5E9ByZZ/flip4z8+y+PNLzo3muXgY4bUZzDyYT9j101YzGQ5PJer2Gu3es7nQKN4pAqsXk
N/wOI+/wNo4TkcEgElAslahnPUzokOfCN6at70KNrbdXlNmza5oTxcOgGbf84erDNeH9Ueska774bRtD
DdX1M54KeylF33s0t3x0K/GQx3BdASk2KizO3g2oEuCI4nWd0BEYWJf36WVhX0bQBBEHyF3Hr+Dn9LD6
gdbgkAYwe1YgDiLOKunnQ+zmkFVrYxgCzc3XWTg0WSuSYUn+aA4FMNaUuF1UZkiMLZB2j9CK0T5qQH9u
MBm2bQemixzL1cbClzc/d8qpbjw4mdrQK9B5EkNmOqNB1lwqnAMoFlPehH++gVU2EcDr/n5jf5wChXwW
0xAAegC4k/phEC65uih8SKo4SIAGdGQIIdfdGk/wjw7g1ckteLRhEGeRePhx7pttmOXAxZaP2hFdRobU
snKY2rrRGva5FhSKa7Fpwg6XHA4P2Pho1F4M/vSLxmbO5BYz62qOxDOfH8cl0HgbS7Vd2i2ztfKAGRXI
NYkLJAAc5U2rDKALHt7JFcReItdwmOmET45Ojk+/+urk1eRPp6+OX54635HMmAHbaVihW2NqdyM1kP44
odUDmU8tsb5Qij9afHvoOrvZGLOav3DQSRxC+AVWtF8VD/j3PwEAAP//a0agaoIkAAA=
`,
},
"/js/FileSaver.min.js": {
local: "web/static/js/FileSaver.min.js",
size: 3006,
modtime: 0,
compressed: `
H4sIAAAJbogA/3xW7W7buBL9f59C0Q+DTBjKuRcX2NggvCnqLgJs44Wdolgk2UKWxjYbifRSlBXV1rvv
UPKHHLuLpjI/hzNnzhwyuLzwfs10biLwFtYue0GwzE3CIZFzAyWPdBrMpV3k0+CTTGASrsDw71kwTfQ0
SMPMgjma8C6D/6xC42XYv8tE87PZzHIVWakVAbr28wy8zBoZWb8vZ8TPVQwzqSD2hbDlEvTMU+FKzkOr
zWZzEXye3A+9p5vr25dnHnALmSX7eY7GzN0clKV07Q62AnisozzFIabE/mC6NmBzozzgX8a/bzbAC5i+
Stt0KqaF5ZGB0MIwAbf5YUL8LSJFUfDif1ybeXBze3sbvC1smvjMD33KjPBjXahEh7EvlaeZPJypGpda
pldomPifNXpdtzOf9jWXStrDGPGjREavPrvososbBqy7/4fd/V+XqTxJKFM8ltkytNGi2a1pxUKxC28M
f+cIWJ2iErOVsgjnzPvRzSZ0kKT6x+mG/BCQpWsCPAN7n6YQS4zI7cL+o0xB55aSFt52YXTh2Yp10aOZ
8MPlEuMK3WygIwv2GkkAYeqzTHRZLP7f7bLk6KwGvJZJ39FGzQ88sQMcxnBW+hVG0+8QuXzi1p7FwVSv
gNCqDzxCV1IYaEJ7B2eJZjF6tjocAAwpg46LpxckvkJf0VR/pg3ZpTEBNbeLvr6+7jfuGQFPvlb+lX3S
Ly81nXfmDl4aak25NjwKkwQPUQgarSKXMiLpOsdPVVVsKdpV0rA1+Os5uySDnoU3+xw8Ty43LRSfg7c0
2eBgPfN8hT2Ky/v8MlqEBgPFjsD/uZ1d/xLIpnKAO6foQEHhfcAiJk/+cz6D2cxn8MLWbrLXrKloD+ui
aGWE5Q6cpQPFxR6zgpUsFXYhMzZBdNwuthBIzlE7ayuSMr8w0p0fGustjUZtyTKvHmu+oGKfZxga0t/z
KeZl2DaBuJIFakFMOx0SC5f0pqLaSaesoAVPdIMOXxiYibgPSQZbJgHXS1AkZv63aRKqVyy+lZax1xVC
dzotHbrYZS4LZ6GReCa8t0urFCkWxuXEohsi5R9HD0M2IpQlxNFqfCab3qkatY1ciK2ZAXCX5pLUyIZm
XqtZRnuNt8iVqVg38fdQJOAtSvJMrrBzU/XPGEaz9w/3jyzfbEje0itUr8FP0WR6Gyk2djtEziQKDPtZ
6LV/Ln7aI7uq63Qm+IexzRDGElmSIX9RN+xWoSauy6wom/KwKGy4Rv4ANqOOTF3KQkzO3mm0lKOl/Er4
vBUJmQg8AnXMMaQQQFk0INmV2NqqPYvQqcfh5z9G47vxnyxjY9LOEcqi1pbPwX6UBmHQpiS+u8Bin03f
rXV8OrpcwO1zoknyk8WwRferI7ohrUkUG8W12lXAkfi9ZzIWpXaZOY/+ocZcJTHraIgiw5x5MEabo4JE
70EoXk84edSxIx/wuw+j8eO34Xjc6QxROf+tasOpNrZdshx1chiipLVDV404wotId63KXVm1DUeylNeG
2t6pZuh8oNX7wa/j+8f7h9/Q6pA2n347F/syualO0729IRieiltPkoaoCIfKw+jx26fRl4ePDhl34fQc
OJQeztxWJg4jaKUoOIJldS2H6dH1sq97J79FPbKr2HPys3/mdDqHF0+aucfWyIxQy5yCD84f8NP1ZInx
uYN7pDxFv+GGE54+tJGGHc8A3z117l2o7RVlLTJ4lZe7pIgbbLtt4r/YaGhY7vhes6ru7ph1mKtbjWvl
nsBlu1Lc24eleG+Ss7INCaqN+2425+YLqVA6Op3mF7UIw3U3vnXvyP65HamO8wS1rPnl8LZE57LBcZcf
vXp75+w0A5hO9B9L7rjb9HiYxp1O0yZPL+z00mjsV7T/TwAAAP//+IbW374LAAA=
`,
},
"/js/ace/ace.js": {
local: "web/static/js/ace/ace.js",
size: 340817,
modtime: 0,
compressed: `
H4sIAAAJbogA/9z9a3PbSNIoCMf5+Mb7J0QcrwZoghRJ3UHDDIqipr2P3fax3c/0LMXxQiQoYUwBHAC0
pBH53zcz646LJHf37Eac7qAFFOqSlZWVlZWVlWkv1vEsj5LYdh7F405ix87j9yDdifywH+/u2uEknm42
9Md/3DoupMOj048WdiNqz8NFFIebjXxsr4LZt+A6nDt5O0mj6ygOlr746IoHP3dLBfxGh1eahv9aRymr
lT+ralO9Wv7VlU9+6pbLQM1b7NJwNP76y/D9+PNHeNrxd6xgFlpu6Gt4SMN8ncY7+U2UbW2n3wh3d/OH
VZgsdu6ieJ7cNXxrHTPA5xZix2fpDB9GA7IkB+efmVHYYU31EbBcgRC6sZs6j1AbLx1CqSxPo/jach4V
TgfqsR2sVssHG2F2g/R6fRvGeeZ49iyJs2QZtsM0TVLbmqfJagXV7Nwm8/Uy3LkKZ8E6C3cYQDt3QRb/
Jd8JdlhjbctxRQV5CoiyHafPQN7KRtrLML7Ob3y/B6hI/dhx8zarPZuESDU5jMHDMgnm+A5jo3/24/Vy
6Wz7Mg3Iy1UF4I1wE+u4yd1Yx03ua7hhRJthLhqNqOFLbHNk7wBBwyi70TZcQs8h04erf4YzaDRN8gQr
befJZ9b/WbBc2rnjQxOThHLtDNM0eJjyphJ/Mu0vALH4svY7buDnHB/99eug32yuWcYFg2myZpNm4Suw
dncVNQt6SNqrdXZjL5ytBjMfYsSYmzgwMTrbrZsamBEIiG0LaBpxwMtHNQ0O0ucoKNrCbDfbQNy3geLD
+w8L22pYTsP3W13WdgwIyFbLKKcPsnkk6Uln6jQhtcneulNnSzXNboJ0mNsdQLPV5ohN/VBUs2c57WwZ
AfF1XGil/c8kiim1n/tpEx6aef/uJlqGOlBtDtTuLkw4jpbMz6FIDpxhtURa3rvcu2xf7u251IRMnfzj
cm/apG/sq+VsxTDkWzfTkQGTNPUjeujzJiRxp1NiB5nziKlyCrBkTrsZdFlUJ0kKZsDaf4zmXuqu08jD
kbxfJWmeeYkruJkHgw/EZo6LoBU7pbHfukh1gZu4a6ef+IvNZt3mNbk6mH7izsNlmIc7BphbszN+stlk
Ag/Ztp/YBqNztg7MKUAg5+g28tW9ZXS1l4bX0KrlTizOAy3X4mDAE2vAmrrFCW4hW8J5PcutvrYyhaKf
dti+XiZXQMPWtQVYcpqQEl3HSRqOgiwcWJFMvV0v82gJUA2sW5kY3uchkMt8YN3LtCyPZt8eBtYDpWxl
s2uN7RAD0JgFpznBXWSCjQUkcwDGuNl0+unrUPCHtNl0oLoQcesDjfLyKZ8zre6WlXsM78OZ9ym8Ht+v
tGYx1c3DLC9/wlT3NshnNx7nY+obJbuc2Muf+QeX5l75MyUjQ0ipfcYf92xnMKB5AnPa1xiNPlcYcYf+
3j/2rgVXSAlSVkmI5d0GYCfI8reIQVx6AT/Z7m4k2GIlErRJwBrJBXSVDA2W1kCbgaFaPWCtdh4bEfzh
Q/QG2McahhEge4OsxA58BgHV2c6SdQqoSgXSWEcS+ui4QJRY0Cl+Dzkz48wK5oyri2CcXEK/2w9fF9fY
Vq8fAtXIZFxADcZu55ikVrytQzgkcL/es5kI/dNfAaoVIDf8JbgNM0e0v4D2F6/lWraAVoGz15abLFrd
qRsTACAi5pMFrHONjDfFpunubiOHJYBXyT/J0X7D8VFMb7V03gvSRCW119MAW8GRBEK5GuV/Clxuo5Fv
AcOVTC/MDlvZTXT7w2xPspwUqEExoDvsWJ4+CB7PRRbW7EcQ6sI0f8BJlAFdQNLSclFOV68RcKbtDCc/
yDOPW1Xzz4qjAtU1QxdkTT8chH7Hw6fO7i7+6e7xhxY9gchrh286mw0syD+9D/Kb9mKZAOnQY3AFso4D
lB+qVs7UwIiJ15eN+iQFbjY5yllKOOYJVwmIn0EsXuP17VWYijc+dVVD/5QNoQyNxI9NS+bcj0Gw+B4s
1+GHhcYFYnMdzv2YT1aH1ZDLGvItiiZCQNSqSItVpPVV5DdpcrcTh3c7X6DwGEXz7QUvq1H2FVAeUHzN
F0XzuRS9gET1XjV0kCoata2auncQ9HC+AwiN4llyuwry6Aq2C1YzZoJO5K9Z9yQvcruOye8534EKsjyI
ZyTuiFUg1nlz1IY9BpCmXazSkbsNTu+ATJ+I06O9mZB3RGVP1rTty+yyr7hhUW++9sXN9HTAWeoaOXHX
4mZbgYwKNCIAgJCCtOAmfnG3AcJextYEEOgiQr+dSApzQIiTiTdB9uEuFtPdcZfuzL1xV+4cBx0Iwk5c
6+tXNn/+GuZ5mH79CkvQUtVQ/Ar7u/LHz/Ljjf4RZvi39UqVXJU/ypII0KTr9qYkMqDs7nAG2/B7KPY0
qvQOoeISiHPCnR02e4pzA6OG1QXEjI6bb1nOCSw8/Zy3I0khtHsdB7ei5fQjSI/lPk1msQ/djmv99ttv
IIfEza6vdnIArpHAJzKI4LAfLoqDrLKKXRlfP3mdwD0H4RvSrcCW2QMm+D2J5jsdxnhfMx5L7PQ2uIfm
Qxe7Ezbz1zFuqf24FTLiS1m1TKgIMQeqZ0qzs4ezM9J6RGzXEUs0bjeNOen0cXfMdyQMDth2AVOFdoFO
w2YChBk0s1biLgGYAOgobiW0t30dSDHixu/0b14vYR9842C9k0XzZkoATwJ46osd+OINK3PjL/s3rVa/
MjMTBhHumaOh0gcx+KkuGFmbWZ+1g3BlCq4Qm4omN1O51Uu3CgPfi9OYj3L/RYPPKywKc4PvOrQT7Bcn
ASAAN1evWgdawPmmdUwOxthxvAl0gYEVZfQXyMV4N9YNARspOYo6Ds7ebjnLAukGpsa1fwuTEFaWANbg
ht0B/r5z65QwAVgeB7Mb2XjpS8XydcFF59S/3t0N2IsGFWOIU4shhGsHLMeLgd6VSAxyaAZSCjDaVIjx
b96QUhE72VDVCZ49rVwauUqh2cxeJw4uYjspbgwI45GbTjJoBuQ1kLGK/bsNVhW9htQ/t8d678Q6Y0cO
9FvHxQ/3286b1g6s2nGCakAlPeharv76ddRfw5ZgzfFiZ5M1zFS+AQLsrKfuGrAj+XZWgadFtIS1oopA
6MN/FFuwZiSw7v5nMbUATC0AU7h5WghMAVnC5sjluFoDGAtA1O4u41928jTOwu9h+lCBMkr/j2LsP4uq
BFCVAKoSphNJOLYaHE0ZkFSCQxYLIbrR7ctFuIymLLkNK7CEyf/7IakeRx2Bo24FjtJwvp5VYYl9+M/h
6c9DDB0UASilk4hu9WaH9WwHN5+3q/wBVmTo+c5dlN9A3YDNKI+C5Q7tDi2hz+24JNQU23gDUmyB05Is
M09w38PWC+cRJ3vWbE77V2kYfENtN6wnb/zoTwBvy9anRofRRz8DwoCm5FIFjIYTBpMi3EQtWpLFJLV0
8Sm6vslriYO+/u9LIdS9HyITWHWjVreOULJaQkk4oWRAKEmrpRFKq5W87vxZQGrEMk92qFEcAly4C1Si
cxEuAgFc+prEzjirdeCbzaTjdqdSAw4bQBjEVre0SeIZKkjohwhH0VtcIJ9G6gg1Ot+id/qloUGVbuT/
bOuj4+DuKXrjdwaRJ7dfHTdtRnyiRa/TfsQ4cISIxJO5SWSo8COlwq/EllQiKoxpSXjMtV+NNi3X/5uo
S+GpBnlyZxi5RTxqiExbUjEo0Qhf+hGQloZH3PMgLqvwyLUm12H+UaADsWdXpldtcfL216+Eya9f6Uwa
z7XzdD3Lk3RgvCl8e4nD6V21oulfzsNslkYrKMJG4MG3nsmnqdUCmKawYab83o7Vf6ak1qPC6TcwSVaL
JW0Ncl3vxxSlpLCq4iYPTXZQ3mDnVbpBQupGbtbHA6gYhjUNrpah1+igQcAiul6LdyLxOcPA2tew3Nee
/YST0g21AqLSih2P6XnWdGC/2WRy/Ek/ByiBFdPN6CWDF6RauUtnylwfjx0gdVuJRjqiMGil+LGKYHju
b+FDBqkmIcyATedcV3XVL9kPqD4xzA+uyuYljzKTh1m2W++qfFr2uJXSX46TJHTCSc6MJqT6XKddPyzo
CCFhxR/fZmM5jpAcZfqEQZX2uwTIM2QMQ9NxK4W5r/eMzBDCrWtgpECmREWkkBYkmPpXNtfLVNJw9YrH
80kET6ymKNq0pjsNf+cvrPxfLKGR1VAJFKqpbnNkeVA9bOK13uRSmdwQepfd3apDlijM7BRJGIhNmY6Y
5zCs42P/zsYzmM/ixGOezIg9Fg457mzxgSNxvAzxzbbm0XeLHeA1xptN47OD1d77lW1uNeo0v2w29wyg
L74l0nbmnLOg1vV2neU7V+FOAAKh4EfuL5KZmbVpLMxgYO7It65J+5vt7O5k/GkWxCSUXQkLIypIxwL/
DL4HDIYdWFDgk+SBZoMGSZlWUX+U9/3CeZ84wamoLjWrS5+q7kszperuHe2g7p6JV6xrLusCP4eLgDRR
9wn0ZHFBDVdDPMZlbHKzYVzSkfYrddxVGnAgG6QjWM4YXT1bxiye9O9yKjbmlX0awXKN8MHQWs7u7pIN
ArJQx6UPGfsw4x/g1VEHttuaGaR4cfFLgYFI6wmSEJyFjeirnpio3IeJOUmn6rQAZh/PmoXBUrWKb5Uy
giqwSMPw36Eqwt5rCvVxwI2MulnlVgz4N+fx2dpkUqwaqDijHMReDlm2WxM+ZyvXovA78JAx2rhkUEBD
eenTM5iIss+ArnCuahApFQVJ1SCzXaTJv8NYL8hSni3IgYOVSi+sUo0KJBtmlnp5pTqXiciWxTc1XNqJ
m741sPo0Ixodfp7CLXc4JvSZlZpSAIoGbGq+g9Lu0J9YYtG0XMtcUC0+xz8s4MlcoyHBWIzhvWrNhmRt
pbem7gd/KO0z+Dx5D/PkUcDA5AoHYOv2NYgl7nbe4nGbaWRa5H+hyf/Cp/ifpTVSI+ny5fmtbjbJBZsF
HZbs7r5lilDGmd/Jk6TYh02Y/6Efw/Yrhu0XN3QcwrD0sWikikaSA73dbs9hQW3HyR3QkXgsy2I2dgQ/
O8jZvkS3oe3ww4+vvvX/u4z//5eLy3Tnct3pBJ3LdffoBP896YSX616n06F/u/Rvj/7dp38P6N9D+veI
/j2mf0/o31P6N8B/ewv89xD+3ee19ShPD/IswsXCIqIrGWPB++1m85X+2rBGAKggGH0Ficgi0M9JzuEW
S9Y/8BN8/Mly3I/6F5b6CoamsoUKw2iWj20gpd3kOVo7ybePzGwSwbgwjHPYyWM9DYHE8Jd8Bwj9O9D/
jtUMm9ZOnuxI8inaA2xrDHAW0X2ynF9BCxkIIs+Y4bglY8WyIc8zForQdFuUdlx6k0XrjITmyY/bBxmN
Mn5l3eT5ytvbu7u7a9/tt5P0eq97enq6d3+T3y6BuSFNn3MR8+cwmBvjIXYRaN3vC0EUOtC+gZww4bEw
F0izs4cvwTXul2wLv1rOpDPFLKIYz4cG3IYkW30eWi31/vJ5UPfBzkEAc0PHq5GXgRigZeCtoywbLYMs
qzyEt2HDhB+xH5sN0ixTiuxdZs29a0dZiUgzTmZJjHUH83lV3THa5GvtUhIiVLUE6wwZz2AtaXibfA+f
BFIrWQCPlCd9YSStQ4lMIiVDbFIi9mNh15C6XWer1QilmA31jkXw5Mn19fJ3wgM8GdZNHaioBFSkAQXZ
u66ELELIxE4eLdw563droIUFGM01wrxyFMgae2CMEo2EV0Q5pSpa4dvcqn7DmoMm45uNILk+s1gnuvuc
P8DqfhOGOV18AMBkQgbsmAkasF4JqxEcnwmsXdN2chdDi5xu29EcjZqUUYkwisAqq2cfNQS7hSeaKFSq
ToKg29EtspmKnseo8UFtdGb2mGxidWTZmE/ep0BtBB1Q9bMSagZ24pdTbcdN2rMs+xLe5z60iucVZaxE
juNpxRWHKKXQToQhxcuK22j+AVoMVqswno8Aa3NbZEMQfknmgEbUWBIg1LRb4ps2rHZ6DYnjFLD5sMyw
dwXegOZDJQw45SQ0FZQmJzj4hX4so/gbroBAzUuf9Yqas2DfdZOGCz+sgDk2YYbN55blehvHYfq3aJ7f
VK0HqyDNwrfQKqpGb1frPJwToGhiuoIJBgP1LlzAgux2O07zBbnpuIJnx9kdAYDUug7Oz6F5sPRD8HxJ
Vi8H5yzJc1h9TXhY81tNJVCpshE6Unbpq70KrsO/f1gsgC01NGPsgc200vD18yxNlkuAr0KWKlfCEaIK
IqKfLvkbLwnT5UWNygX0Kpk/tDOR86UtVxXHrCDmcKCglpGO+UFhJKolAmAWNeXZ9YDNBvbSk3yKy7b3
bM6t98JGYfjXaQr9oVxQv2em0JpDnbwKKmaMuPVUmK0g5H2NkKhhysZsaWjfUWGr2+n8H5YrEm+jmFVq
dVb3KvmGzQULNgl68jyCtTN48K2rZTL7JkTAytYT6Dm0ToerVBj1oEkWIeC+FVxlyRJyWC5aBcI4Wy2A
izUWtWG1TBdL2CtZN9F8HsaYxqHviTwFwCMJcveQJxSABT6l86JYnLGXJEhYR0ymxZYXEAUSInRqtq9D
ycaHoWNdyCcOu2FyAntfo2G2Yj+OmwnpgLflJq01FzMYUwIpulYoSuKQFo9G15AcsdiX9+/83MULqEhJ
mEvsjnj3QZR1461r5bACjZI4h1xopi9nVwEpyFAETLRumjDhRQhZj5/rbLWQWwn9ehHGPJ5sIJJfXli9
LLB1BGtJCfE4dauLAPcM1sv8v6PwDrcWK61A3VYvSf7g7TK84nETplFeFH5B2F2vwvQrG0d5hGAcedi6
KfejpqHxHknh44Wufn7Wde+gobqztC1JFLfRfRQXQJF6EDq8d0J2zSaeymMgLoqUd1y0O6Eqmdxbg0XU
2rx4m1zcXRtj8ZKdcqECYcpM3xJayKOK07D3H87fXrwdf/r6X+O/f/Yeu0ee9fkmAjHE7R571ihPl/B0
4lnDJST1egee9T7MA2vrQv6vUBjKzCCT13WDZe713IQOQOAhw1q8AxAicbwt78S9hYLwBxaQ2yCe49Mt
/Lt1L379ZfTl7YdfOAjQ2Fkw+5at6Bb5qWd9Ca4Ahn3P+kTjAs+Q+BHvWANEAOQ4m1nufg8AZ0X29/Hz
dfgr0PD+AXs+B0kY3g4hdzyHB+jmz8ktZoYKSOxy96FhKgK1M9HKPeh4Fit5gPWAmI6JUMnbGHCMz1DP
OWkzAVJ4/mV9C9JQB16OxUsXXk7ESw9eTsXLPvSk0xFvB/jWFW+H+NYTb0f4ti/ejvHtQLyd4NuheDsF
wml19y3xPo5xwXK7XajroosPUM1FDx+ghgsEoQuFL7B1HPsLbBhH/gLbxIG/wOYQ4xfYUg/gvTjFhy5W
2MEnqhrr7mHdXaz8gIHHlqguYoxJP5SwdT9+evvLl+HZuzEfchy8HcAmNAc1HkBjUN0hNAV1HUJDAOYh
ZAEgD6EJAPEQ6gcAD6FiAO8QAAfgDgFsAO0Qivct9wjK+fAHsgTwB7IAFR1BFiCWI2gIqOAIcsLAHUND
C/gDBa7hDzR0A3+goQj+QEP/hD9QC/TkGGqB+XAMtdzCH6gFSOMYakks9wRqAeo5gVr+BX+gFsD7CdQC
c/kEagFqOYFa1vAHavkOf6CWO/gDtcDKfgK1PAB1QC3/xhGFj038C8ktHABIb+NMPKLOdbGwj3+htIt/
eb5Tnu8UwNjDvwDH/w3TBAdwghMYvl9e4gNkmOJfyPAXC3cwbkxKB+KGYduYlE7uF1KATdLx9l2Y4s1g
2HzSKbrcJsS4C9DrM4ecKjSTXlajtFEQ3DdsGxwM74aqT4VGjW9mByEhxKnih8iuic1MMS2bBSs82ocH
Fxn8EjOw8wvMMOke7099xHyBs+b+xAL2hgcMxEKtAPmnRUzRUor6mFn7rJI7u+fKuzD9GO9rhG3BYmlh
4jbcdsXJUryr5c2nW3Ghv2U5Tfhni7hUGToAsKUntLqQEsUg1UM/QrwjLPCUu7Rph3VsBLLWl6Sk1hGd
jSahXDa1U2N5C9jOfa4JX6TJ7egmSLFCvEVIyjJt1OvWUuD2KfBxZMB/TC758Nl/fPf2l19/A76Pfyz3
/XAEq9pwZLl/e/vL+Ye/ffYs/mBxmQzKVPgyaUfZ+2A2wCrbWAcmvIvi9T1LYo3QI69O3wbHwffoOgCZ
RjPU0A2FfFvmaIOEmwPF3LKb5vbebTDbwF5ts8TG9iLYmk2sJAdxy5qi/rgwjSJf1YRYHCIWUUDLQAb0
8Y4l1GW5vDuUAA2wBOoOJVFbLPHtWKsRNhWkUvSt9xGw+CxZ5DtvcSbFYb4zvl8tk5SulpZKKMcS7z8P
V6ufkwwwgLZtNOMvlkmQ23YkumwPvPef3453Nl/SCPZO+eXepNM6nTYnl23622//lH73HNtMdfYQN1O8
RO94dfX+7hoJGR+Wc8AHQwuq9PDv61P69Ndw9i2hT++Tf0fLZeCLvTjuD3A5BDlts+FpM5Xm7O7yRI0G
UqDvGV3QpXot0bpqhZ52dyXHVL1Mv1969uVchx656esDVgnIZwH3t9PGQ9JAmgPU+W/RM+umkVTVlMH2
t/Dqv6Lc19AeCWNJ9mmPvBsARMq7AZYb3aR4qaCq3A77VlNw+PaTHymyGs6TqxDSiKoY4X4M5nqO6COe
uIivX5L17KaQQ6SpXAwCYAharp1R+uHzDuWpu7v+/XnO5Rb2DRWs7wdcerjSWizxM35q0IjYHN/dXZMK
dT057U4Bi5PT3tRJNv4JZlq3Yan6KzMKsvd3ExjefcGZ+DfoJipggRa7JzCz8e+x8MljgYgX0NE2bqqA
E4p3j9aRd/ytLyo43t1d4F9njaucz1xCwJoQ3Yaf8+B25cgLjay93d0E/u6zUj3W6pIXyLBAK+gvXx/i
ZU8BbaMDq8qW5JDUlBYgU4wHKW6ye0LPvn/aZT063XfEV0IdTCwCYP93dBRBhXKwr3UTtxUzAymxLf/I
bEekLyWygYs0SoMe756I0s8U7ie7fuuUn/80Ggn0hXXbkHZkqikfDUQTsKXeaptHIkdyUIZvihrR1DSY
z99FWR7GYVrlTyrEDGMEUeRSPl2KX8jcqcHQDV/zPJjdUAZxMqctwcKXgFCOEhacbT9uf71LUc+V+qlr
VGJbMFLN3OXaeqafehp0lqcG+oqPsgM4/2XDu7vGq4BDQQqjQSqKLE9WlKVKi8M+o3lLcB3wb640PDpn
1IBp7DiqkNmoMSx+HZRSbAf1tehhYHm2vkLjIPSNVGyuUKv5cVBMoDpZb/6b7IsZpCBdna3zvACj0qah
csi35lfL2TKCvSNe5BWJuGKG9/ltGK9BwJC8DSAHkfu/wofd3UaILEA8kvANL4OeVwHtFUHhPXa9jtvz
eu6B191ORPKUDuCZd5bSAalkuxGCTq7QYCDS3d2UDZJJa9I0FRk/TCb8ZiHhdJ7Pu4YNZvRczjlMT+CE
qJ6gvNJ2UJ+sT0PxREYdhOpsxfbdiJ/zv8fyf7sJw2XVvMPFLImpjTvMQ+5VBmYjIQeCZXDL+5ATmHv0
8Txc5sFv5uER//Sb3zIy7aEmkt7/bn75+17ueKpUpyYb5HIRhK3jQQeegr0W7Pb+YT+7i1BWo01mHryH
7ZHzOAMJHibB+Yf3X8/H774Mv358+9v4nSdB4pl/+ynfbDTwePLfKZndf+qXqoLtydgrNzD861jVL6D5
DepxfjpULYgPf2cftrz/pR5DxTTqTPtjdh3m5j1emGJ/fYD65w+f3v5fH2BFevd1+Nvbz9qI2YyHRssi
IJ2aESoUECMkKBGdlxFgqN2rpEY3dTMhP3XcNbqUcpf+Y89TvMjd9yyQvFbLkL8feNa/1sGcvW371bQ7
J32ijgiNCcIrOggaJOixgvfgTXdgJ82mm7w5oDuIXcfx4N8+FxPejhmYM195CuKnMb+11s6bw82m9OHv
rQA+sDsqm83MweoWu7uzZRikaKqXrHN7gW5SMma6R++acxEyNtu68SRpoQB51OngJXkS3ta+bB19WogG
0VrmKyEm89m1SVtHB/PoAz108EaukPiSN13pwg1LLPEeHQ6jG4mdF265ClhW46MjOfF77h/tYgXYrgnY
lh+/CUmbXK3yHdZmY8Hic5UEKZN7kEkw8WVQsfR1yNaJLWQDWJMcfGeLGaxf7FUuaAc8ATXs+H4C71uv
rlaR66W1CiioVmb7BuwpWkRhWqEQkho6qV9C11XTrThHxDsuAQwyMypiZwFQe82SIM5itTEWhC/2vmzp
/8D2rQ27DsnS4p/d9EFKAcG2PBvx7JQrvIDQRD4QF7LMzCjOQPHUEXgFDL60NAmea2Q9kY1MfVt/Q37V
7HLvtaxu+VGqPwM/LO0A3PxpcAN0fyPGEs8B2bDjkxhxfObEgZsfTSS1yUMNcyyrWkFZoLZXzFLaXW82
wBPM4z3m6inlWgTXWoDsUIC2ssjWAeEdh1/YaSRZ/h46CtsRGHnJE8QOrQs0FoOA+AWYQYGsYnQdyWoR
Fp//DtOklTNO0Lpltbas5qLAxmNg4+yjAhgEPzTxas+DPPD9VKJOl6izCplNrytCC1cHsRvr/UIrrJ/Q
7Jd15SJFXRvvPuoSYM87jKNbaoM+Sn3SbfLvT09muAuvvkX503lus6e/J5WfXQ3YgQ649szcXPGp6emZ
jMmomHPodo9rtcPLAK8D/DHFMN4ErtyETIR/UVgJ2OYKmd4ndBCShdXbFnkpuJ2ybLbQyVuOXsUKiLvS
EELeqsjfdEBC2MWlNW76bJ3M37wBKSCEV3nFbsvJeO8fl9ll9tMe7Nb36OnVXl809yWNbk3zIx1kYWae
ugaMWOhTnQmZKhWJUrNk9cCmbsUxgXb3kh0LOXRNJNQO3XNRScGxkqxjop+e4AUG6f1V3GPA6tRtC1Ir
CRX7gPnSxHvbClDywQ40WAnKPAxXI8hatLgvX/CAtT5UThGlPYuyXhA6L3ZJwMya+iB1yI5FHDmiC5He
hRRfFWA2fnY8SsVHeURGsi4i8UvyXveUVDkasCDHyo8uYjGfIC6mftccGWLH1fVVcOyXDTdB+Yl4Y52J
BsHnmwCiNS4NtXAShmeERITs2I7h+Wm63bMn7Z+ag3+8etzazmZyOb3cu7ycOnvXrnV5+apradWR9dHT
le1iud3/uX/S171fWzz1wEj9C089NVJfs9SjTp81jbIW6vCZNWK1JflEWazIinJjNeVW4I/MhMtTTgXK
3nCnLnvyBK7JH2vMpsIiTNNwPgqWy4rhJ8ku1rV0PA1P9Qyn6pqQyJRMNiyOuiAOUg/KQW66VQe+2ewm
REbuo9vImQGCEV5AVYmHXzALRCMV+Y3dQI5AEMBUKMo+hvHckG61q3zMbB72wMFDCSFqZFhthuJSQ0lk
oCRmV3hI6ayhIkVU5JqvzYi1apYtbGxi9MZYrgSaVGiM0LVnAY0l/G0pUxF7lc2x/VL0JN6AjKKqJfwb
F9n3UJ9HJ9EvPivhJytV58TmpSBTVnjRLSDUd7e1VoQOvF1oCZ0vqPQ5GUEnWgq1CKKwr9T6r7sn5JoU
9+/uosj1hFx5xRcb4R6zf8ODeXwD7kdr36DjxezasZRR2PaZzckQdnVdyNej67Qx2iJ+Dpch1f4JoEJG
YVyevkG1rGz/zjab5035Cxpndoq3u/sgicrW/Lt/grIGlfzLcf9Vs9teIdVza1xxhWHlrnz0X45SczwP
0zBtv/oGax5+HMISM8xH6zRLUjltns3Y6BiV4XIj8nxJWB6UwJVyYdDrdHDPyyZz6RIEEmsASWSNrC7X
kKEwfmtxSo60w0W8kQM4GOZAaFdrWCat+9YqWN625lGGFoutYJ0nLVhuLFKdFjPjkQGQMvBxq/wRi84S
4NCz/Ok8wSrKg2X077A2W7YKl0sYVNSiNLqONJWG/cwsyh98NNPSdDBy8GDTw42eV/d4Z68dkaHcWQgL
OS7P6IkwzXKy1mUGigvf+h//w3KXeIlphv8gBdLQuxS5BumW+QuVRrwBkM13eREOxp/T7y3Qb1rcrF0t
12lR3ZbEZ5CKe9rvPl2SLpWq2JF+Z/QDWxz8hoWv8EYrc5RK+QuemqWEF7PPtjJaVybji+g+nCtTdAN/
rizoVk+bcnXW1u2g3IAwYc/NMzNMscXnKKOO6FfOJZ/+zrYT136iL3F60993d69sdIbvPtRnQlelimVQ
EYe8vkjmAatS+RzQmt0ga5KMyjCuQntqno7X19FRl+00fPTwAPQyd681ZoTgAQvDltXAMbIb1+zbRN2f
8QDDZ77aVeo4pitgBsPd9hsVfBXnuboMxZPsioz1Xo0LxYl8ZslyGawy8jsG5IEsjCAlnKUwMdDYMxSf
AFzjQ84mOjaPZGDiQEw0tMxL7mAcxJ0nDeEMJA4On3Uxzjp23kzDyczLBZOEoQkHjS5s8JEjStyxS/8F
jc1nnPn3xY3WZzOgE6cnLA7kRU36vogUQkfH5PRqgZFx+LB+0UiiP0Q57zPOZaSMz3QK+aVAwvdoAVfg
CMJ9AKNNy71ndPSL/9jdhyW2d+x1t+VSFUqyG6CDBu/FZvOLpjJDl6Vqnl/ATMb+iBlEMX0wH8X1QfH4
dbd3qvpIB+JO/2bwT9vxzog1VYFT1kVq6DnsoBoT+zUyhmE5QP7sjWGw2ZUJJIghtodM0PG+4dSunJlA
Zt+YMpQ5S8P7DbAo/hzE82Vo7gm++SFnTdd1ueRM/cYYFPphcIdmLeTl+xvy52/cp/xsYF+hOMu4wMcA
8IGfcbUhL+ELFS5p8G6QU5ALrpi20dbTch9ZXBKPApvROZeR50qZqxdzoj59fcVUKXbH7TnQ3AANSlmq
3aOTdhWtSYdFy9bVsilJz8xPHQ/1uE506fd3FGKIQs5Dw0Bmmu8gJ6IbBvRDcYreVE9Rmmp3yGne1172
iVYk+J8HeaAs4fRUOqSKN5u1aR0ZDCyEz/JICtuDTW8UW1KpMCBGi8Vh60OXzYF6Y7rISWkA0lcdpEh5
A6LLb6sHrJwFy2lI32lp2dyi/95G3f/AjjBuXDxao5kDPaFmxnErigBNLJH9iIUx03hyzTpPwtEdm2xu
dUuoGnfPjYH5CqDh8b/7sZyMw/hzaQ+f+e+xT1ogLW7AO0Av8WryZOwADiU/DeCruu6KnoJINyNjLMYn
y2c/wKJYj8QHpiTOnQpWxlBmuaOKb1zu/lDxaYYfzqs+ABot92PFlxX22XJ/dly7gdY7WAW5TkJf7fiO
JfUEVoBSHAwMVzifrGTCfDUkA5aGPIVBlaI4shH0L+0ExKEQsxI4OvY+4uBpp/0nR97PxaQT75x5+KB5
dFaaybiksiEQQiXJF7iwv4Jq5h/i5YPajFJgwXJuk5D/6ZKxCLShH51eUCCJ8oJBjiTZrsFm278szNCn
Uvs2SL/9Cgzir2myXtlmcdpoSsHKdp4ot3X/WRDUGxW9/nU1B0mnstvs4pRYlVXku/tOF5V3zEXuDR0n
MEMn5TSgX9kKLkZafpxpa4DXNlL9sFCtOhtVaADmJWRFiUS9yBPYvGmnJI5WV2cgOxPJ6dODsN26JUc1
RTyPMRxPDZJT/wYVHsJlajVvjHzpK+H5QRG1w5ikCi0DYK1eI9VHAIV1ZLhD5GAwWbTzQ+VELCqowSJS
g1U1DulGg5bl2UZ7kTbozBqwiCW74vywMJ80wzhZMowxnGrKBhcbqRpG9hWafVsQhP/pHnYqZGGtfm7o
dcZWBDqPH5Ty4xJtbOLe6hojB3HxjNxcLPIS0bZYppLpG4gipsQF0JKfHV2JKWTZT5xqTWVsWxCzFGhx
MMlW8X0Yr43M5OWsTnZGT4PhLR4kxgGqPHSDR/cRMA9werk7T25pA+2FQh1Bqq2EDJyEEFBM18WfhE3N
BOhQ7sj4TMG4Gyu/oJtT+iChrLOTgfXvFhnEe3TlvdNnASAtdoHds5rmJfym1bea3H5pYHG1ktdpd1m5
vnB9i10G0S4k/4hnyZo0yyOyKfrERKYAFXOGuwKtFBr4rFGr0rTltYigfZWk8zD9kqzYdXU6alhCPryz
r2Vc84x4ZqrlnPn4AX1dtBat2PBz0eq5NwVaYJ0mbwDKLGvZ6jUt3QUB6n2k32dlpbWACmcOZd32b3jc
MzbNG742+9Xy8rQK9CVaUrZnitj1IN2sAtkIN4HVUezeuJ+cKjofLRMgs080lP9yfzWVDaQOoN2FWQjX
wk+2U9xKa1AztwTQrmH/6/5aOb2NDGi7JDc1/qLiHIIwuscta77esO3ny69wm+cM9ScTL73GsWZmkq/I
nE0urGrBQ5IK5xEeLZObAS51822zsTzw4ZE2j0yyDrmgVCqpbOh4wfNkfbUMR5j2TFHDIpKX/kJpLymt
7CdF2f8FKS8pqRsG670lg2NZlp/LT+T+waIV7LN8owe6I25JNYf+evbwN2AKmZn0DiiIJ6H189+CKNce
2QdS5dKXaT8WEZuM25x035VCZ+VTNqFwTTfaYJpBFmZXEsQZ3yeF5FMW89G6bumlCegXlMZ8vLQ6ygkY
mZIzMLYGEq/K/gXipby/GrdCt+c05XvayjF6lqplISNd430DQHo7Te5QIwjQ4KPDhqb3EzKX5foWKuT5
5CvmZC/SRrS6Lgwt2zCLU4KqwJE+ZljlB+rYjMGAtWiVt2Td0inJ687gcUZM0+MZ3SCe3dAr5N166iu8
qm+UdbstnjGyc8Oo4tQxqzl1RFtZu3h8q03yikN6PJHRRHQXtTCaf6uPXBrCDQQTGDgHYRdTQj08HuM8
CLBmvywixPsdoVKglbtw6IigZ0rQAWb/itzZMDNxWOHR3BnXGyUVMdFFwofewouFWi03rV9X2kJMkuH2
K3pI18h84dWU9SYHyknVcQm6BU3liY6IBPyKEmAnABsBDLJEaSbfZtXEZHvOEpmRvxAmYeuMR2+KT3Bh
jq+5XJqT0G9NmwcjDxdQFWejozeBAGGI/abruOVbOttS4aIHFx/3xYoCjKU5DOMvyRdygQOcJAK5NcwY
hu5ZvQ+CBWs1AD8sj3/V6CAlcVtV2xnExmYGnzQCCR0v32ziegpCLPF+SPVbXBYzyDUiwy6e6Tz13ebn
qEwKpWNg3jod/xfGmS9AWKZEx3KHYaKfO21xc2MCxn7+w0OQlxGuSNkkW6lnqPhGgneQhh+TCD00aP4y
w+r8AGZf+WL0a/MR9SnPfZFfDRteh4z9qM34rBvCI+Oy28JGV5YY0me83JfcoXacrQWF7AVSilHiKPOa
kkzKBGjYOSToaknOpNJ6W2bLrjEdKIDMD44o3vJXfZiEU9zVQxdT0cWqOfb0kGcvGPKIjRTy85dkhj6x
APRII7u7yWtcJvJ6UiGtKF92Gz71CK391SqOibyDqc+Bkc4+2Y2U7M0TjTA6o2bkSq81pMsPhaZwgRcN
ie4gQfNvMEejIhWv66g4BaaO4WUZFefwyKk4fpqKCVw3l1T8JENMKzlNmeXVULEUjH3tlcnGeooSj81U
ISGXrM2qNjeuvrqs42dYasUqxDhzCjmDLJTc+0dyy37L5bjsO4tFhiquUfeVK9eDW5ivuS5l2OGbBNai
Vp1E8qYkYzi8O/oaX7NilmU7tV3XtnWVwmJl8QpuxbXK5BcRhcE0mH0T6kX0PTAgVQ8X9zDKlSnZt1x9
UjebtYul49kGo2vrW5bifKiuhFOo5fDvRQKMXEMm2FbsYX8vqvo1ANHkkA7b4iqBuY8SKImOmNmmcyWu
gsmK/R5Ucpki2uQ+EUNACd5XjRMcm6eKiw0c8XfvxxrXmy3hXO79KzBu4NUwSagEIK/chlQOCNRiKRiU
EqHkdB+rHM5m4ZLkUXm4YIqpaEDELqXSDpRdVaW7WPISL/usX2qV6h0ps0uHGEhSLT7CeILAndJGt9xk
urA501hdlLG8aGd49iAB+AnN58NwLtsXCQ4PHha/7nU6jr7dKDSMAaCKHPVFDbjM8wB5feLRe5XLGZS6
TCVP5q8rlHZ5ksC0eM5fpelP0dTZvVQfl9liu0b3DWM8lmf4CPlpgVq9XikfpX6oe9MQIEiHGnLvX97L
v8Kgk3V27rLRqDLIlQlZyT5VIM3MVXCIGydxaJX6YziSNcoXGt2+4DTFKMD3Y9RtTfLIS+5QI8Orql1o
Bo19tNIFb7Mct3p2zb1sqMoJNl7Y/5ZL6zp+ptevy4N6/pzp82UzIzkyZg91n/tPdfDG8PvK6DdscKto
HYO05RUf4mIOuWhRNEGNyvFEvqY7RWfExtyQp0430TwsyX0sFx5IPFe3RoRy2jmKtIoOzk3KMipm11+4
S3JZQcH99LPlmYt1wbAyk2F9YfPKz549XbheYzw3ccjwO88YTF6mnziICf5DZw3ybWmLbf+6WrAhiSOD
Zf1VEMdJTnc/s0k6NS2mZrZwM60MD3D1J1M0W6gLEodfmtZ21KvoPlx+ST7T5lff9nbcNYjP1Dwe2b1a
JRnFCH6jWhCG4qL4J5Cxl6yEEJE0ALfMQZOAub/wM1Ii8vuar6/SvTfIrAUnQa8BEc062zBr4UcPM35G
94oPwAWshcldRlKEc2OvtXgEeK76CqSHZTZ5GvjU7TjTNueR7txf1R6GfofFoDyX+t8ZcwIpjZ29Iov6
Tsxozo8yGU9SynpAzGNC7iYME4cEpOYFye84qW08XmVLXqU/pAJitLOAG8nElT4ONkchDO3WPNky1Vuv
2Kx5FzyEKNxgoKPAOO/ti3JVR0SscJUXjlQYp2hq3s0m1RXbDb+jG6dETE7/FF6z8jwqi7VIlnPgEPAp
Mxw6ckV4zUzSJ4gUlGl6mMKkk8iNvZ2hgbCINZgqSZF5DUHnaMp3lCYdl2z0EGdlablGXM+kO6GwfiOD
ijVdIZ1WtcpN0BJ37S5eOmrMS5F+ZiZOcZScTFYRaFMkk7J0xicEw6geVigmbvkVR611R8Nm6cwBvaJU
z+XdXYqqs/ap0kT6X6sxU0rYPFnTHiBiVXxEJw3hfACj4iEjcsn82s3qTr458XM/Msk6L7pMoINh7tTl
pRBpDTNmJi5fEDHitDXOAaEcW/dwdUQh5PlTLCbsZhXnWuKOnFirHLF84g0R7j7eDtzEcYvSQ710xgiC
WxJHMiCLCr5TjAGgRy6A3ZNekkkKzxZl2aDPhkSBRpC+KaTgVGv63UM3p3/DZvQGJaCwBWJj1EKpq5m9
ISONlt/rNDOMr6M8cGp91ocAOr3dsoTAlEX+SuQijOirtk5MIqF/v/6Yi8rfbdzw4zcr8zbNlqJrPCmK
i3mOsXrU1hf2pEzjxi/TMMsbzTkRU8TpX/+u3BWJPU+S6Vs67ehUS14pLx+fYUldhXO5Lyz6aMHbJuVd
Xq2zPjxoLPoRMbrs1EPQ2Ypv1S77sO4CS66qutyDjjwgNOPgVHXFdqqAsDXpvbge1u4QYSgG8smz1fj8
+EmkQQHCP5UacXlBThtt02C4RA0NEYpbh1j7zs1Tdc0MVxmW9Hzk3VOZAJYJr9FVEmTs1+FRHOAbRXOl
MoxJ7Ijl0UEd5Gqkil4atUv8SkoySUgVFhJM3fCqtZpnVEWFgs3n9vGD56rgtvOa/6uajNywvnIrV799
A840Bwr/gxu3P24ctjA2bF90d1nqZAHYKl6eCdm5Vsx3bSxJHGsJImARUTebaLPJnPIBsd/FMCoY1IcO
iAon6aWTJcj+2U/de//x3lu5D958q8g28Zf2PYj79+0Hd+XOnX7yJhh8pinkpa3Pbyio0LPHq+5n7pBK
CSi/1GJBqw3Nm9MRRYlpA6ghX76zujzyAiUTEdZ+hTHiE9ap0P9H3H15qxazMHVpE+at2WastdoCdh6B
b3rzFpmqumxH5kkr0/l2C/ssaR4atO9ZPfhAdaD1qvb5gWrBv6wCNFl9hJH32Kk3G21PEMC2v9jLXvs9
QPlMHMD4oo3Xso1Ba9/rQUN70Wvy8zfDujAjtfZatTZodb0uk+1vfE54lBk2p4roRFPubYlA+yCsfQc5
+XYwHqSt8Rs/Qbv1p4lh5nhjP4UfeaGQ9DCSZ3XX/euXmEkgNbpf7Gu8Q/sL/VGVfYPKbo2dUZ58SCNa
FsV5wo22j0M/k0H6DWT4W1c/uUzI2b7O+9npJhk2Fu9QuMaW1EDEK3ZeTHthFA7PMJghXjPEC/tUD/nh
/x4s7e+OOyLtAGlNeeLI7XXw+nbHjZ73DPtBQ8Q74dlBr1/1m2kCeNdvECdcRVDJURQ2MTKEic/bGsZS
wEnj7oV4ydmOnRnnI75vGWjX7A+iglEQZy2AmJf47tVx8wFwM5QuKYY1e6+hUL7e7O6+Q3EIRkKr5L1+
rojLUdZXN6zJL5a+LUhuQ74fqHJPiPdBtCuSFG+cXZ3cai1+1fxr8atw9Id10ArQd6u1jlEvH5HniDms
U2hGyzNoeRHbTxZLyfQPV3Lhg9CTl9yAUxfykwMItDFE53pf0iDOFjCs4WLBFBrJXTgvBBBh19KhP1u2
1jAFcl/FxM2l5/6IAk4kPuuyF5c/UE+8QgnSi7EysEUrK6zS4oFMdHvNQhamM9/CjnjRLaz2e9fRon8F
UB8duJ86y79+OF/eDP/X8GyI/41+Pjwbjv9rOBwP31ECpo/hz9vRF/j74Q7G0c2U58uSAxWLggt63dV9
n1/CwEdx38UjzxN9XHc6fVqfOn1xg6PXPTg+ONk/Ojjuy5sZfUv465jU2zjTOfI5JPEvONce2Cdhloof
p/3Fiw2gq/xDvMSuvc984poXFYC9u9/dW/ea5vqVe+eO3c/ufV9YQwBwzPFD4aSX7RTIDxLm2Wwaszb2
7xqPUnUDOUFl1dM+Ncw1HDct2m2i944qk8zb6uNrrog050Y/MmeHX+B6A07s9Oc9TVSdivQrN2ZkSTRu
lAFQO1wjjuh4e0sOOM13O3Y72Butbr1qPT5kjHXRgkK3s0XN+Mw4lWucHmgeMRz3jryymKf4ODLaAT6C
ZFge4ZVZNXx0t1ru2GUtzH0dUwqbq4a8vW5wJNwTjAnv/cYVxYpgvIPdudNXRrtyLE1HR7VLWMfZPmUc
Rb16yjYq5Nd8eJkSmvKCUwbajhr9B+J/b5udl6YPIrKwpmaZa0oVEOxAiHIfmk23Fnv+lY+LEdBA6Sq5
AeqH7/9hSG0OquMOG9qCzq5H/WHw34XBd/PA96HVQnJ7eI3ri7ipirKWeyWEkaeqTFalq7bX+vlDkWDJ
ja7DL5NfsUvkfLW7VWqCaxLcr6Vl0a3/SCzMA9E4nnvXWw9Zk/CkBYLutX7dnHOaYha6kKhF5VaOGdh0
d/qFZtQM4near9FpGUwY4R6JYWir4awSWaacOzNCFRSXAHXbqLIUXRc1GcyzJZgPnsJse6YUhuO1inT/
TJkl0pZVorYnSyUrS6clcxkdFrZVyz9yH+jPuPbS63RgH47/Bv5hWaEqhJKyyabSCdTaWva5tSVnndds
TTvHW9G2YXWJyVKVqclB5Vb1+uQSiFFi9DVIVfzD5pwFC10DKCGClQ1gimvDE/smEx/6DurPXYxKuDSv
oyDGa9xV0ifuKqCsaFVIz3WkY7yIl22nw3Zd1/rCOSDdlx1YXGEO8hUx035Y29+ygaocr6L5odnxKhNI
rYtokC7C0XHU5RRDR9XORZjlHzBg7sdv9lG2wVqRYzBDCr1BX+0T/qQGOySf/lmzhgJBFbYPZXcVpBCf
E7fGNmWgrYp2+PW44u2c4pW71LwwRxfoCof3m02X2xOgri1lfuhEWCo+4KWbZGRTalikol7NNB94AvrS
1Te2ew7LR+th5dG6hdMfYUE0ofcbMh9p66k+xr7iRxwmX6WuZdItYMXU7pRdAvTXxmTeVswmRn3sokaR
c/d5G/oOrDTruAci3IqS1FdxHCbPDxYF21V+UiC9mNX4ro/Dlx+7vsBaVTM1ZValhOtq98Th3c5v79/9
nOcr7se/H2NMx9i2/jr+Yrkh90GaxOjR4oHmNTMPMP1K0tfPfNYfAFfA46UwWyUw9uQvYksX4wCRTGGP
kW6TYP55lkarasgMW5mfoXqaJ/IcvqBeyagipCzSsITQmr51jVDiSWJs0o+e7EzIY7/FFLdFdQvvAumd
tLCucG6V0vG+E8UGdiL/6TaZt+zNJrdZQLp/rYNltHj49dO7CkZf13F0PSuNfG7ScIFn4PRQFyiB6Jac
iuTPnl29iNAet2ZY+acOpLNSxqr51E+Z1xMggq9oBIrqvNrDf2a2gFZYANaDMFU1UwFGvtR+nZv25DJ/
IR1L6NdUzfomGKVlMhWm9sXCGAqZnNZxl3t471fzT6mFR1aBA3KH3PHnpO0lF1jkyod5bDLP1Olr0WQg
KgcDpHyF0/+MeShi3v6Uc368R568FvD2E9j0PsaTZGozGwrOscuD6tBWD9f9FO881wWl3ElFRehX/WsW
XcdBtb/0qtHbbGAwJE6lJ+qKbqTQjVR1I4VuxJN0qjeewIJS63G1n3OJqaRxDFWol5RzvLK1Y+iSPyzg
PCAaszBHwrs+RR6rMG6rd/5aJKo+jnvNN//xK/cePf/qPW6Zb1W8Ayo0k/hMF0RVPkIouec10vzIn0xp
94zxAlKHmy6qWLe5088adNsxEkEXMgy6gE346Bafo+Z399MYZaEfKMDNeuf7vKqIOthPlS17wYQwRPND
FFEdeWUzVe4Jyl1Lja4xuvHTElmUrO6reE8NReuOFErcRZ5VwADV5aFx0oFnd1DTCexBQOaiOPOehcNo
TSm0AXVjsfDTYuzTtIqan+e1T/asjm9WD682AmmD9SMWQ5BSSA8B43ApY0dm5R2t2Zy4W1CJOlxyqcNj
thT6ac2CCdP564wMAX7nBSNzxa1YU+Nkpy6IM/SLrRYYRSZZotMnGc/S2t3lqe27II3NN86FeJLOiHSD
f1MSHKcp3ozHcyoKZAVs02hchaBRbYVYpvCKG9vq84/8Jk3uduKtrgQy70KZyHKMIQLxAeNBfVjRXQMj
uh2PPIOBiuG18mxJsAZWHNYEPGzi22z4c11dsQyUI05TB+z4NcroL2TBZRakrtDXYcgddCxspNA+MmFN
4E6iBCMONjFRbvfEARVKXprBEn7PnJ585z2xXllNZIzAGQ3Vr9F6cRoCof3lNsrI5X8432G5dqy/NMPm
X6y/sMUEwQW6mn9JdBu3iZY+ZdzXSNLwjWACYTGjqexzmHPRS4CMPuV4bAT+R7NxzfUBqhifUvekH+Bc
QTNgB4tliPUkA/EeygOYMqB/FUDsjisH3XsafbB8BOVL73zV4yQHBGaahQJfx30ECfmEgUiZY8LcF8WK
rERa5gtcCPm20B4es6pMJB7rtBpXzyAhS+RT4SE4VR6CgdnCXkAi0kvJR2NMseJs9oBjrFqdsMSpn6K/
XjrvJ1+YqDlAE+iQ0CsztfU8zAGkQhG6YCb8cIUO7D3ldPZr+YSajrXdjTU0Yb+t7wLEmMUFUOyEux5l
MWZNMYT5by0Olu5VpTA8uL+oHjhABW5NUgAGMV6g7mKbegZq1MOC3BtzXANoMcaUydfKqIoVbzXaxhi6
GO5L8VjKhquTn4hxwjWU1h00T680Yh+uVswOzw8qVugfXJlZmMCahZr0MFXr/g+s2SRYQg+C2bfgGraz
KWrLxBu6I1LPa96R3V32V34i5ryWdw04w7Usftr/iPtoy3ITTSuwTvFuLtOnaNcVvhof3AVa0iVmcAeV
2535C+3uWHb28CW4xmupmn5F7LRuYKd183omdlo3uGFkN9pmk5sp3VDL0tlmQxfV9LAy6Yzp/xpzB9V4
UbxmOtPvUCIQ+TLZzq3fca/976Kd29fX/VvR1oP/fXI77T8Qh5AiJFnXtGAQW5bD1KZ2NFnaPJd0zfsP
mW0P/fM6U/9BzF+s+8qft2/JjGjvH3b7J+dyD0tdti7vms7gsv3PzL4cbF45e07/ChrI/KtJF+g8o4tx
aM/jsz+bTYZbKUEMFAudPnwM8hueB1LuEjSV42nqBZVLPAcQsigjHrWv+Q2MGP8sn+X3eYgKqR32JjF7
h/H4IhFhMJrcTQuyJflYtO9c/OQYR39Vge9adhtj5pmcQ2qm8uTX1UraZznF2/A8PFZUvB+fqQScm+K+
UHF6OopHgITBZ7+fk0ybcK1xtSn4lhnoigHy0BJEot+jLbxAt8fve3DsslcxlB5Mx2y9WET3ngXEYbmv
GOf5NV1muCEvqWDZ2UKAN9E+3MUfeWgRPG/lIrIUx61f428xzNgd1tkdYMPeDogdKhQwrAlb5hHTLwmF
f7CJgG/q83Z1uL1UD6IZ0J5KdrwMTNDW0ILaCdGDQro0V+BBVPdQh+2jM7dJrMIUbjaWUEHmKIbEEZAY
cP0B5PesloX6DpW/SyIvZmQDbNGpCmSTQaEBHSxepG39w2rmTWtyedn6Ot2wP5TyCpYHPPFD1a6g/Izi
ntqNCOYbit0ovLI236CVtAFEbyoOVYIJVIeUY0lZNWE2JgP4KFmEhzDuoWyV+ykFQyMGzvRera7T4F+T
Jj7AV4AybUZNsYUAhktUyeO5UtjuytGpGQk29q9QiY3x/B6F4p5Vo7lEd7k6JXKTvrlBih0ylownHbQX
jZFPCotO+MZtNdfOIyoRI1IiiuZQdFA2m6kdkdc69ZH0m9o7KUSMFKnEIvWl/kGMkL5LMqT00IZshahh
3BU3VtMWksUjLite7LJ3dMAtaFJvzwScR4Ws3qXi4QkJkc5WGZ/ZlmBR6nJqYDv9TDtGsbW5BwOSAGej
UWceRJ65+/ejd1meC7pY50f5BW4Q6u4lPnkFR5cF/yORHct9cYq+acTqVNMxx7yO6a5Zbr2PjnbREdYl
Vluxr07xXBHEOga5WA7dquCsTL+tzqXxkAxYHlNMOPScaM/MtZk4A9EpFEQ3IV7C0kJW+JtNOc3G0Cf8
Lq2w0grF0xZ7r+wiMMat7PgXOmS2i1EH1q5luoVWJdQRrchTcvW/Nuz19RrQAFavQGUTldApuzQQ0Kqc
HHQ67j78eofA3FhxHS66B1/0ihSk/00bt/qKK8uw+8gvafJHq/755VWLmD+FcA3VAAtvFbqxdlwcl2qA
qovK8ZD+uLRqlJG3Pria629tdJk/CkeYs4elC/YF0lu4dQbnJfIrOpgoEeLiZWTM6qkhZqij5J79qWpk
5qqaaqbFUz0zZkdpitWMtIlEnaHIzYRgE+V7yajvCZWnlYIXiJjb/ma5iNgzF4YlFNenynqHrwLPXwiL
2/duzPyrhmUPHXqEnEyrrt8w3B3i8VkWzXmoxoJj1kFWMoQTNmSOV/5mkWhQ5/W79pycGw0xGYbx/jU/
GOXfnILN2ftyNPaS4+bSiUv9t7YcOhHRTR6QG0ZJPw5o0TefeapRLIy3cND3HNe8MbbzGVN+6sFIc598
OX8QKX8XKX93K6HUdGnMFKR0NsWM4oR3Md3qqGq47v1QWr7B44Nwf6X7DRE2UXHlFXj091sTAqTmCzNt
7yvXvyDRFLesoWbIoIeAJseG0exmdzcTjlSZxyNxH8ZIJdH1XjO9Z72UvheYEOxyCzVG02wsQ1cOJDy9
uhWEyuxLAvOOh3FFcem4C5ylEz4UTQvvJU0B4EIKa5kNl4URWp6OOl33nSL81cWYdstj2cX+JPFIIwya
gSbmePR4RLM+4zljxJBJeF600Lcysn96X6d2CX/drRGSFfXbyvKPxZVSK8mT15wC2sH0q/uTuIUeaUFl
qsxZ3QQ2MkSUS+P26gLvTEp9fxFDmvlgZeQlYZmtL0TM1b/yG6Q/i5A7ekSZKraVLBaVwZpQlW3WzTx7
sNHLNZcJmsFhX0Nv6HY7phk1LoeVLUl7xKWuSV+YZ0f6R740/yx2U48aU/Qe9YMXr7d15eJa+CTcM3QP
O16HZeOLbiEjzlTNk3HhK7oXKXtbKldB/orea3D7y9pNLnp3euEe96XeF1IWmoccJjFJrMorVbVP4FSJ
EsJhMvR1PswLXjncrtOPyOTZsOodCGMILGRHjpei0hN6x9+5yRgLf81A1OXJCkDLIjCzglf+zXJ2DFz0
byZDENZ7NtPkpn7U1kqjWKS9TtIpO1JjIhZG6xbfyAMwBXLFgPK6gzYlNObKkazRZyUp/3/WbTdjTvk+
kgNV7BaJjDw6LR4KYDAUCsG32WQsQD7lYI7FHlM/UQ6auT470ogmdSPho81OHS5TIe2sB5FOKWt0no1C
Ob1Z7XbbQjVRaQ9WcK1AniM0CIT/iA6GnNXQDs9YsZiNVfY038IHiutLDxE5y3ixygnPH0saqB/U9VAd
dXeNShLbK6kp4UexaBTzyBI9Ici9EgohfzItHqdK8zMMg4ARbbMqyf0po0CehQ3if3HsiWqNA2KeKNwY
mamiCzD2xUpCt6PJroWvdVdOZKdJszrJlZZdC3UK8iDG4tO/wgqovzb8yi481WW9ODfgr+yUdBBb/lpx
SqLCs7LjMJR1RC6LhFvWYVET3bQwk6Dfhq2NwJA8mES7KmZdWMjA7dyQ27u578szuEEhHymzQ+FevVg8
dzsU959Zz4V4mBqgOC6ebJ2kldxUgeRnB13vkjhMw2YxzL9dB12X3Z4QQLEnEygtTuX1E6RY8AsmmpoU
WpZkojmhAsl3nZm+pI0rejTFXS2qXmVL7dtgZZg/iHhgZht4EmQkoM2Zg8dWIJ8toiUsN/YZSDphEDvc
1+yOvPf1CgW4AgqK9j7i0AX3abB9WPs6NiXLkSe+QXEY+aF60Gr1YZdQ+DoJpgUKtzUUifaZt1/Yymei
PXWsL5NgMqFMbg0AzI6X+GsKnm/L764ON3q/TK8zNKXGAGBAK2zSAP0HWUYycoOiuojShfRIE6sZfAm3
UhfnbFqoShFmvNI2ByUzHmL7S/KZBfCPhVe1quGB8Y0AK9qtbC3YZM2cqqyn1XUxCrtwhl4YUIY9i92E
5tZXJgq1LUDBOzU0dcbW3UoH1SSD/BmXQipPF8nHUytnsXWEJ6iWiFphXCOR9C1UJ2nOPVgJ6UP478bI
FPQlFl/SbcUiG2VjvGDjVzjIUU2wGIK+FvRPKLRYfAtfCzCoXwTmPdCKioiDsrSWQ73yLuScusosziIx
0NuZWE0Tyqa1ZyRxt13WdKf1RubmkKq8WoQVayoc0Iur/tVjxrNQECf64PsdWZBSPxVuUKmIVizqYSqQ
otYKo9KCI0JcArsDu5CpoDJlmXoe/OkMul7H8dgC1Op5LyiJGbseVXHQ8+Sao4eqqqUTiYpC/DATl2Wc
VNTBYmJx5DhkqlT1GUOqKKRHqP7Iwlme1bEUfViKKzRwFKiK/u2KCs2gTKWxl6QfVlBzLispes0pVqPH
6KycOrmhQC3VpQlm3AZ9YJdrEePhFtqk0XI8u5jslqvINWm4jJlaMDSsmEAI/BkgyES3WDhXzkczI2rC
c5NyoEaTkvjiwUeGklA+gwW40TWaeG7knmmnutKnaaqmynpIeYHKKhtCM67HRsJ7qOZgD/LXpcEmNvCm
MATIT7zwdaE05Azf6GMH2coLxyB/45db6XgtnllbRwAev9hyx+t6Be76x+fVQDSuY91s5I9wgMGztb99
jpJf1sAf7OkyWn1K7oqrnPBYwEF4k/OowCRR5M2u0nXIqJV6/tehnj/UcmuuEBjUvOr02aplCV55Wq6c
Iy8ij4m0TmR2KkKZUhjiWARohcXDiEJZf6CnI40rvYyYTzyt1a2EKt+q8MlZ+dvzEGdliPkBat3OT595
+qBUS2YFwpJNSLbxbDMNsxlJWEllWaOrWj+LnZxhPK5VFprEWZ4goiOdAR6ERQVagc0/8/8a3Be/6DDD
4LkgLNXUoOdUWqFcxCGplvPIP4QZsUQFEpItsDjTT2ek2KBiK80gNMLauUWX1cJryPfw7KHqDFVJy1Ur
fdPPjR43y6sxZJEbqUjfSOmDW83YWAdMKdEthutEr3easJf5aSnld22k8jYbrKhii6f5oP1dtxkLNygK
7gS0XeTLvVRUBkTjNuGaCfiTVwO57R1r2mH9d9cVp/BMJS/GGijSjNwoHNaX3fBiKiQaYU3h0zuZBHVx
9ww8Oiu5P6RPLJproeRQS6ws2y9a7mHzWogOq9o+lX1kSnyLLGI5I0XTGCOP7B9kQzsZPMc+DzOgiPmI
SOlDPKKMqLFLlirmbsjuSshtLlrXzvWC3DG34ZhKdrm6C9iDl0BatH4pXZXLnBctH1pbaojYcqKQrZYT
/l0KGzLLj64n0iwIhVxKUTZEphirFJfcpKCmRgLjWoukpBujFKitgk3ynhmhmFwZyY+DK+5Si3fpeqlu
mHTf/3UwVA/IoFTuHfl/8XRoq7pbLPLj+MJL8xUxH0I96AMDkuNOd4dvG2TjFilEXdnYarv1MnpUzNgy
CoTHkSg7C2bf8F5fhsGDGyhKyckJYptyhPB0xGiAyUU5LK4oTKYrigMWFWpGz82VualdgtQgrdG5swEV
Ie0RYX19mXsjlzk2NdmUFKznTW7OPzGVfritwtRMDOkNZoNXxnsxU+h4Roqx+9BXk/JtYMmKipOs87JJ
JsN71fQblxct7F6r26+jD7VmGQOslkt50hyKk2aN2zDcl+ouio7EeoT+pio2vxBCdWWpsZYgSJrsaqpd
Hanpqaq7tlSp/kooHLfMs1VY6+LwqePY4uIoznmMWVan0yNKLfDjl81wFopNXFvfmn2sWg1+ZNoThRcr
rQjL9eNVa6FFtrqgXw1ztbBWBlWvpx7M52vTodM7/2s5HlKhz4Wqfl2ZFZgeCF9UBRYxK/lUDIf6glqo
jFnNOwwY+WO1YJFCJcApCiqsl9UkypWrKzhYfWFlY7XjZlVdRMvfURUvVa7q93RSljOro3D2v2MMZbly
db9jLEUxTbiScfYrlGjcp5mv3yGWZlZcxCYuFvIgRLkMO2SEntLcvKuw/trkVX0q9ae04tglwO3iilms
SFszpdiNHMAvAjfUoDOPgspLKwdGw6QMp1mtjlOHDPH69go2u4PQM4XLVAQb1EBC4ytamWOpRokGduxH
2pKXwpsI1u+lfozHYbBMDdj1L/TYn7rFek27MqY94nmbXd16SMzQHxgZFVfU0dmz4I6lmtTHswc8Ju+U
S1XyUKNcZbHiFNEoobxfcHN2m7hqCIZ5Ue3T6vIwbuZuQdfRmZKIVAiHSn/ZcZg4LE4JzdWNKfcqhDSu
9RODV4ocp4dVCK4+R/8ObUnB3ON6hh/QyC8UW4NSCw6/kix1UbGaD+IW947lSJsc348H5XHpuK2YC9rF
9K701VtYs/5DQ1YzYkIizHWJ0FTfazs+3y9hy5jFclSM1NfVEnvVsBvlaC6+aHzdsChV/pGxlkhr/thY
1wx11UhXShHF0WaLSnEM3AIeqqJrk7YjNfOJ62Al694YN0hl5nvOgtUzNLn8grdpeYBWwMKnyGX2057T
zyYdcRW94eMlGqPWV3i54zaYZXTxS+KArl8K/bRWw1NyalrB78qiVAGjFauewMa7IMsBc2w7owXwNhfC
6ikhPtdQKZsmRGjs2r4oKC+LyaARGcjpiM3LrPkKsJly9+C8APR5WzWHCyr4agHvpftogaPKjXH/2W1I
QQ58YtmCsp3KZSuJrysFxh+bHib8LmF3fcWMy9B5ZGTyiTiBqfENZk/YXgIpvEV7UL9jSg55OYN2tayK
Bbs5XXhY2FlV99XRVGZwX65TI2/pdUCSxVwKPL1Zm0WC6b6kp0UEEam+0Wi0aujjupn6icWGdsOX8n45
4vYT/c+f6XxpgJ4fvxcStCDK52SqOppkR81PkAlKVJVqSCVSxQWRSlO9ppVVMxs81UBfXfFLKye5Gn+g
fEd5ymWJn8LvaKiFoe+TP2fyoCnr0xSewSC3XkDhmZ/xRfzZvM5LpgNR/2sQUSvJvqxQRLpAcq8QZgXZ
GISdPEHYFX3+swn7VXaTpLSJhJWBlagyd+zQrgxWoz03qwQI3bUUkPZEx0LHiZ/pF5P22D0LINIQPeag
BXQeZmj87MTNJk2l113n0Wy7WKaRyUJmTpfXoSol9/hves5j3GqxUE/b5yGA/Cwr/CdvBBvNlJjIZ4H0
//TS9vx6FBlxvQ0ykdtpNzJWJeZsypRZskohoj9PdsJm061kMnygwtfZ7i5Jja/2JG77mNCU7+QqmkLo
+B0e+LKGetEuvpLgm0mZl8th+I8y81r8PsXSq3l5NXvmA4I8CvHdaj2Nb+RMJXxjQAJ+uY7JnEXUb+uX
gNqxyJx+becBO62KIalXEMqtA1fG8HU4K27ADKnRLm3EzKlnV0NQqVP8UQAYq69tn30uNV8y96nYSjxt
a1R7SoujzLxGsgEzDm4GsTTTLX/0KtKkjrOSWOv3mLSfD5WpUz9sMPtwBluqW70pO4W0YO2mdUseF7GW
Meq5vIVb92VCzUx5c8ChygRqbnGbucumWGnAnjpuKSuySmb1epan3OjW8nDyJ+ynusZNvhmnf/UmMPIs
lrBaYyzxROmuG2s+fcumMuWeMrp9SX9rCYlsOZ8bNuW8hF3KK01q6jG/sGcYNBUShW2V4Kv6OWcptneV
aVZRSxwiJXBvG+KeROWBKpq4ae/i4pSRKM0Z68Ew7TJEjF3p+d0OC1cFjFdXO1r2c+OYWbfv115cecTs
50orD2uq6jbBYlod8GY8drum0PMqxuSGBeOIDwt0xEE+fp/ovjj8IG+N/BBZutYw7rrqmcUlO9M0Qjp6
VAEjSxYW20UUQxsPTxwG51I3mCf/5+cPv+iUKpRNZAE4StYxs7fmEgqlFi5uahasZMRra6GUdLOVEg26
+VZTtIYlggmN4uUhFBJwqM0Nszshj/TGLr6pK8GFbqJzLT558uQzSBxLce1n0pkqZ83YQ6GRoruebOxM
YxX0C856R49kjGt0hFzdcEzExmQM5vwkLKYbvHzfFvoIxdaElq82BWidsrmaYgAaCJpheOkyHyDGFt3k
818jBbQYkorWwjd+jYQC7jVUFQ2NcAz51DT9QEBQcFTI1glOR7uMJsi+IZZleQxFoQDhDx1pfLw2b3Eq
e5F1hYUvbROjf7/Qm+ePOs1UXiYjvxfuV/lNIAdDmTCxTcmpbkbOY2lmIyN4H6xWQAGYqjCHHqm1Ckyx
jpIATSC3TzCWUUdsso36MLDBI3cnQIoKz0LPONYWJHDr2nLXUFi7EN3pBypcVCAciy/8eBJgiHq9InTz
bST45nd0sIMhj9/GWRgjv/oekuNb6zpiHs8XiAnY67L1Xt6S5snQd+hiPMODX+aGGEqLIvyvvChqizOY
Lm2euHMknsud+bbuzNgeeLbVXDYtZ2O3HcdyHH6BOFCHNL2C094F0zU4A/7A8/l+d7OZ4b1Jnu7zvzDR
vVmr2/DN/NzES/Pyb/MT7R2MKgP7fxAZdoJ4vkOQr3au02S9ynbmSZjFf8l3aGgt9zFF17oLl77SnMXG
tojxIhSOJ2CnjogvMictYAt0nYVV89UywKw0iBjYgx2+iwKmHwhZEgZn9gbRUKgJg+4wulOfBDLdGXmE
3ru8vJzzrSMfMmcgR095VL+8tCed1um0WedX3bq8tJr2KkiR6NC5QLfjNKNm19kCFmZ+111yVsQi7ZOP
LSCevxKOZdOOC72iY7tP+A4M2kBAQwvwsWYuKBbovmwSTf3AjZr+DN01YjL6VxN9BklX9Z/Jt6lkrDYe
WqG2jJWzXqEvyXVlPJxQg4zfUiIj+c+YmocpfViRF1Gk/ESFytE4D/IEY0JgVBHmbwGmhOXQzHjloC+c
qpvjr9BtdnBPo0rEZy47frgRV/a04a+Tq1R3hJJPzGRp9csmEAvfhAlCecGGJVYRV/h6MaFLqV7skkm+
F26nnFtrnI6xS8npotdZPwJul8Moonp7IgYHmCerDD7w+jDPVkpGqeyqmjO1PgIn0/6TXWf+rUV4C+LT
XKxUsRXVXC50Jq3oTBM9zNjK4broTmp0B3KpDsWGJ5TCJKm87aQm6ARY6+VlezP5x+V06vw0uJxu8PXS
vhxMPL8x3diXdn1QhAFyZos8hoskYS1cQeNlkyst5IU98C0H3WSIJRMPqGDHibFC+hrENoDnIFQI+GAC
IDoDfHfgn8nlBHtRANfN3MRdu4Hy+D9I/TUwhanlrQcp+fNAGyNmZDT7RgEw8Jph0ITmWRrC5catluOR
DNlsupmUxchFPs8Wu9xSyQ8w1O7WYSrVBj+F2fvHpSPVcSFX77HW0NU07O9DQ+fHK3Oaxbxb7YoW5wmh
a+fomMWRuEJhwTJuMaCGsETwrnIbqKJ6ivkpvcCxKd5B3RL5wUctifU/89uVRUI1XTsgKzP5zOMUitkg
tEcAI3XKkicMTCxKp/2MKSFrPou4AxUSUzoVnmMEv4Ta1qVj28Bd4LRcAm3N4HcjOAUuqGxqWdaWq08D
4eIldERYmMQQltw5W4m/+wHi49bX2kOucNsSIV/eLFkN18boLl2Vw+nfcPeUq8ENu5fU9K89m6Xu7i7Y
MnPjSJhXHODrLWw6OVN5gG4+vA6UQPSA0iAGrZg8NNGtlbYJk7Lb3M8myeRhOnXnYrUbrHz5bH93UzRz
wSQmhszbMTkGEtycvSuWDjOKJXniwcYaSsPpysBehmxF36X0FN7DhstCRzpP0IVbRxNL/7ZMF65OF7dO
X4Z//e6oJWqlLVGNxnx3d96+DdNrvJLfAPnxhrvShOF6wRh9B2FGjup3aWq1ch7ryxZo0hzilVg3cIB5
2RWMIUWvX/pyq8zOq/qABiTIWbP5JnIeZ296P4Uyqm95ACLYGsURjMEySVY7d1F+g3sa4Cc72qbskUWr
xyHwchcVrrQIsKmzfC0BqOwgX+SNubBs4k7MoWiNngXLWLpYJnfQczXuxET4CRxnf+Xq9cAlyKdgjFJ0
YsWjidqMZSFBPVJ3MpDJiZI8KfCT9x23iBiKMCrfalwTfREYqvRMhGF49lBE+HoTXd8s8VziK24Lsh8L
/fWD/gJlYKKSUEht+2wovQnDh2eFeDXjKw4poAnXbc/6xyvYfFZuSadV0ibqUqjqspM6+CNIOUayCh0N
FAwrgqev4tS8kJNrjSmHJkeB8KTkKLH9BdkK5CWywyEWhD4pOUcT4aLYB7XUDVgC0TS65pIvWmRXdoJh
ax/9vKm9oa9zfKkrInM7W73feRN6LokOdTMm+gp3DKmQ8IgAO9EKbLsgiLhc+5D4VR4BB7TBBtldNGc7
XsgOigVy14Dc9etIIHcNyI0m6yl0Av8w7WFkKCNwoBKHB17OmwHvpiAIOxF+GYSSgm3Z5RyaZAMW7deT
4X9V7RXgLLQ9hkAmwgaiN8y8EDbaK4zeI7BNyFLxJNkrC7mjJXDoNbFpzDLWjQcrxmIGV/sIscOGYGN4
y5EzR/SlLPgS1STpyBXqRJkCwNR4H1Gil3iSEtaWnZvESXobLIEtlchKPO5EtiSWdJJN+wmOyUx6aDeH
INGH4JFpoRKkiEbANrG7uwETXIHweZLPU9yAz0ebPRD22SPDu8lmAiZ0bDm3Fu9NC8VgwZ8CfNlsRAsk
e1irZGUhD+Y6EFWQryYBNYfX23gIDQEY+0Dart3dgkqJi4JL1ps8xMiC/SV0ZikaEOGGl7rSAT4vYS0i
6dxNJ0vc4cGCB9sIh737C44Df+lG9pJLzguYr9gNwiJjH06fgSeTGBMyYRd1ybB5LJlmHgwHEoGc4zNa
3HliOplNB/gPb0M+8mmG7y7PDI8YiXM29VUCayCKZ8v1HC/MMFQEmiyFTd74Wp7AXQHF3TBusmOiO8At
0Qp2Un0mLWHhuT9Zu90peimbBTmkAkLiZJzNApQD7DmInNwtZdlzWSMkvGwB6Ql36sk7lrhzx123WgAM
nfcF6DTxLknnIE0SqhkRaTvb/5LfV9CWnh8QpJMwDDotlZBcUK06angMJex2qzbAGmPr6zFMUxXDNGLq
ImPfbUBX43EzEqGdWRGbBU7gXOUFsajZMota/z4pln1UdLxL7kSIRLFd41oTvKJtbbTwm2tf8RE6Wpgg
D8FwbTKQL15+EEvDB1yZaKf99SutF1+/Mq2cPLamLuMBjRGzOsKrAiRNx4MKZ3bRJDTBhlmab73qnPTN
8O6KTdYvDBymrNoBC4iLQBg/C1GQMecqdyckN16FN8H3KFn/Qd/vBdeWQhSUtZfDOIsVvHSIn8HeAOPe
qYM9JPCdYoVeRQv9ypyA4FJmFix4W5FMKlHlIPlM1a8PnnEwEzqmSIknVqI8nvDSsaGK9ssVahWXgBUg
wtGAARpGw6WZXfFNupi7CdOoItpllazGHXRpEpvqLRpua3qWsPy1jCE71oSbGsTpStBSP7hOVDv4AnbV
j+W+r49LW7nzgFpc+nL25Fdn0FSJYtqk5rSREFf6Z1/H0QwmzJ8ZIoF1cO/y7vFgu3ct+5zyHYwIjova
BWCI6VRq4GLXurxcv9q10LG8yIWniKn9+M6zOp2DbqvTORx2Okf4cAwPQ/idHcIP/o46kHh+BL8TeLiA
hwt46I268DuCh3N4GEOe3vgAfiP4jTv7x5Cwf3wAvyP4HcNviAnnnf0TSDiBCvZPhvAbwW8ML8Mu/Pbh
4eIQfsetzsFJF35Q6LB32DncB8AOD4/gd9o5RCgPT447h+fQyOF42Dm8wIeLXueoB5+ODoado6Mx/C46
R8eYcL4Pv8PO0Rh/R/CDj2P4eAHVH12M4HfROe5Cz7u9Vue4By8H5/AwPOwcn3U7xyPIdgzNHF8cwA8S
L4adkw40edI9hB+89A7gd9I57Ry0Oqf7p/A775wC+k4PoaOnR93O6TH+evA7hYTji87pySE8QPdPT+Dl
FLKeQu9Ph1DJEJo7PYOUM8h/doQvUOMZ1Dgad07Pocg5PJ9fwIcx1HoBOS+6HcBCC/7B/y86gE34QYVD
gGrYgwqH+5Cy34PfPvwO4XcEP/gI0A4PAajh4Qh+487wGHAwhJEbIoTDk3P4QVPDU2gCQRwCiEMEcQgg
DgHE4RnUeIZ5AcwhgDk8hw9j/HU7ZwjVGZDQGUAFuIQf1HEGUJ0hVFAUfj347cMPswI4Z4C8M4Dm7BD/
QttngMAzQODZCeRCqM6AdM6QbKBF+PXw4RB+UPYUvpxC2dMx/KBJ6PfZ8AB+MBBnQNVnQywG5QBQAAsq
G9H/kAoEDT+obATgjRC8EYA1QrBGANYIwBodwhcgwRFMghFANUJoRjCKI4RmBNCMEJoR4GiEOBpBB0eI
mxG0OIImR+fjDowi/Lqdc2wdkuAHhWEWwQ8Kn0Pr59j6OTR6Do3S1IPGznEKnQPtnGOr56dH8MMUQOv5
2T4+nMEP8uOEPQcQxx0g/jGgeAwoHkNfYIJCwgF8gck1PoHEkwP4HcPvBH5D+AEsp0DE41NIPD3Fh4vO
eIj1ACbHMCPGQ/gCiBzD+I+HME3GQAdjoIMx9HUMzY+x+fEIKkYQAJgxkCsQaecCW784OIYfVHxxNAI+
AqNycYJ00WkBF0EmAKR8iC+Hh/Ab4gNg5qgLP0g4AjQcjSHxuAO/Q3g4gS8nYyR/eBkdIlbh4QJquhjB
J3jpASfpHQzxAfCLdfeAg/QOIRXr70H9vSNMPYGUE0w5gZRTTDnrwK+HD4fwO8GHcbc3gtQRpkJzvRGm
wuj0gDl297sd+PXw4RB+mHII0/AE6to/uejuI5D7FwfdAxiY7tHRCH4X8HB80T06wZTTYfcI8xwBxo8R
9mMgSEA3PHS7XWAf8LAPDwf4cAgPCPcx1HOMSAEu2z3Gto7P9rvH58fwG3VPsNDJ8XH3BL+cDE/gN+ye
nOHLxWH3FFs57Y66p4iY06PzLgw8PBwfdE+xwOnwrHs6AthOR8fA6CAFQOwOsdLh4UF3ODzu4hTvwgTu
nh3gw8FZF+YpPAw78BvD76I7woKj3n53BHwV/oEURP3o+Lw7Gp/Cw3gEP+jC6KLbPcfM52cX3TE+XAAm
LxCTF93z7gW2e3EAKQeYAuN5gWBfHB7D7xR+Z/DDRMDqBVR+gV24ODuA3xE+jOA37l7g4F2MIHWEqSNI
RaK5ON+HH6bAjLoYYwqAdXGBmWHMLi7wE5TFVQKWAODNnRb8c9ADwoXfMfyGrV63uw+/Q/id4st5D8gO
frAw9U7ghzl6mHgBD/un8Bvhw0WvC8iDfyDlYNzrnkAlJwc9xBuQ2rg32seHQ3g4wocxfBqf4cO4h+iC
Gg9755jn/Ageji6AGvHl9Kh3PsSHIT6c4AMUOMOUM0g5w5QzSBlhyghSRpgygpRzTDmHlHNMOR8DDBfA
SA7hd7TfgdUY/oGXfZjz+wDcASacwpfTc3yArENMuQCecTHChwuYGoctmBuAZCzdPRnvAz3BwxlQ9AU+
QJ4D6MvB+dnhAQ796cUIpY9Oa3hwMhoenOPDxTlwIHg4AvYKrAAeuhfQtyH8zoZHB5hwCAlHPXiASQQz
Cx5Oj4c4q4aw/AO5HrfgnwtY5SDP8ckJ/M7gNxoeX5y1gG134bePD/8Pe//e3bhx7QnDf8+3aHF5+pCH
oJoAQYKkBGkRJHhW1sRJlu1MZo1a8aIlqMUxG9DLS9uelr77+/vVDVUAKKkdO+c8z5M4pQaxC3XdtW+1
q/YQKeoJZgdijocgmI1ZwzgazMZjfD1O8LDkwzJCSmZgf73ZBFRlgqmYTcLRDDQaDxAgJuMQD+B5k/mS
slVvBs48m7G8WYj2hyEfwKD4wSwaIc1YMX7M8EGClZYMkQBIJniZLGYz8OsZ2NRsgYbPFotZgmmcYTpn
RBswi8EiSvgwHyEleFgmS6735SxYcGbwMMJDxIfFZJkQlEAWIovGH2T3F0hL/AjQPeDuMhkAPBjzYY6U
Ym315foKB0gh0ghAfJQsUAi41xJyFx7Gy+UCnHG5mEfLxZJv0JiUVadRiISv0uUci83vAQ9mXHB4GOJh
BBBWLVceHvD5EuLYknmXC75Bt4AVfJi3vD9uKM42SrGUl4zwCoQEA+F/gz75jWQokz4FFrIQcI8+KC4S
4BDyQGqRAAe1I4XygbI+FrwfAA6e4geAg2dIlgE4ZEjJDQCHtOVDHiYfIAvAkkcCbwa2+2GABHYAnuyH
gIcoI0QZQHc/RBlgaD7WmT9EGUOUAdnDHwIO0ciH1AtajAT4CPAR4CPAR4CPAIf4C76BBHgEuOAPqD9C
/REkDh8yLCgNEoBgDz7kGB8CgD9Bo8APfPJ/H5KoD2EKdB8JmbEAfbFOUBJEAB/SHgYFCb1I0AsIOpL2
QzTwEzQBJMuHZOTPUTpEH9J3kEUkfADRxgep8kGlfFAhH3QHONf3wdB9CC4+BHYfWOKn+B5yhp8CDsEd
o48EOMi/D5wGuvVJxEFD+igZaYA0RIr6pNMQMJEWSIBjWkFxkQDHtAaY1gA9CNCwAAUHgp4DjmkNMK0B
pjXAtAaY1gDTCi6GBHErgHgWYC6DAV5iLkHnkfAB5jDAHELcQALWBSAHwQQiWzBbQgUCzmFGpE6UKJ0I
y3Iwm+MHBggSHxJyLfAJ1jDSBClBQk6MzgCjM8DoDDA6A4zOAKMzwOgMMDpYktShBkqPAi3D0Ayg4oRY
7/0QKBMCZUKgTAiUCYEyIVAmBMqEQJkQKBOigSEaGAJlQjQyjAAHIQnRzhDCp9TL8BuYEkJ3CaEYhOhh
CIwJITyEkMJDIE04ARzCYwjECYE4IRAnBLEJQSZDIE4IxAkxIJAXkADHQg0TwIFAISTZEKJkCPwJwXFD
SJMh8Cicj5FmSOgQhiqcA46hCsH7QhCaEKMVYrTAQ5DwPUYrxGiFGK0QoxVitEKMVojRCjFaIXAJwggS
4BiwcAk48Al0DAlw4NNQEIgBEv+D0gl8GlKvofwOfIIYhgQ48GkIfKJMNaRQBHyCoAL1FXDgk1Bjleaq
ZJwABBasyl9APFtAMfQhz0Pq8ZEGSEOkCGmClCAtkCAVgS6loC0paEOK9Z1CfIOUhQQ4pCRID0iAB4AH
gAeAoyYwdSTAIUBCF0ACHNiYDgAfAA6cSyF9pyHgIeAQs1IgQ4oJTjFJKQY6xWCl6HAKfTyFgJ5C8Eoh
eKUQvFIIXukQcMjq6QhwyOsp1O90BPgIcMiW6QhwiLIpeH4KATZFx9MIcKjZKeS1FJIwVBMkwMeAY6jS
MeBQEaCaIAE+AXwCOFYU/uAltF/Iy0h4OcNH4O8p1FUoKEiAQwBNE8AhFacQ5FOokmkCONgU9BUkwKEr
pHPAIdKnkHTTOeBzwOeAQyhNF4BDdEkXgEOyTheAQ0yEaoMEOGYlxcimGJ0UPUzRyhSVpvgwTQGHXJtC
BkohcqdLwJeAg7emS8CXlFYx00BEJe8KMRdzB7TEAyaJqpMUfI28S9F/ifFdUl4vhV2M2JK6y3JCKYcP
FHeSUg5GimpiMFLkSMFIkRaCI0cIRhKiLhJQrb+UEm+AfwehFmmRIONCFLAk2tAWYqE3QVCdQ1Cbj8ZI
M6R5gDYgDZCQGSIB/uDlmEoWXo7xwThCmiAlSAukZYCZQgJ8AvgE8AngkLTmE8AngM8AnwE+AxxiH2Qx
JMBngM8ATwBPAE8ATwBPAE8ATwBPAJ8DPgd8DvgccGj48zngc8DngENZnC8AXwC+ABxyznwB+ALwBeDU
GKGAS6F97sjsEFl9pAESnyGnhhMkirIQ2UPIZ0PAh4APAR8CPgR8CPhwoSRdwEaAjQCD+jgaATYCbIzv
xoCNARsDNgYMgu5oTBi+mwA+AXwyFPJxFAyQIB4HfJ4gQSiGthBBT5lhsSIhA5TZaIAMA2QYIMMAGQbA
L3QiQicidCJCJyJ0IkInInQCwt0MCx0JcHQiQicidCJCJyJ0IkInIiiUEToSoSMROhKhIxE6EqEj0Qjw
yEcjIojqkIkjCNNRhJfoYYQeRuhhhB5ChG+QYLUYCcnw4Bg6XZvmAkQXmoYvhAeIJX2IJX2IJX2IJcjq
05KCDD4UP5/Kuw84pCcfGowP5ZYEGyAkwCEK0J4AdQ9p1pfmAsChOWGhIAE+ABw83x9AbAG7h/4HaQ8i
D5g09EAkiDwhvg3xLXQhcBYkfDvEt0N8O0TZ6IU/BHwIOPrhjwCHBuSPAB8BDpXHHwE+AjwCPAI8Ajwa
CSuBD7bug637YOs+WDoNBVikSICPUf+Ywh/4vE/LFngMElo3QY7JiC9QxATFTygvovkYU5oFfKg0QC0k
FAFO70MZ8WcUH5En8SkSohSweuh9SCgkoViIj+b4Ddbuz1Eg2Dq4GRLygq2DOSKhMLB1n3MF9RC8DAnf
pagsRTkpvk1RVgo4KClJJugjKgRdJCUEieuTomGekPhfiDRCGiPNkCDKYaJB05AAx0QHGFmQLiTAMdEB
asYcIwGOiQ4w0QEmGqohEuCYaLB6JMAh6geY4AATHEDcDzDBQUi5EbJ+AFk/wAwHmOEgFOZypEBayxsM
5EiQ+ya+bSiHDAUlDBJhQDExRIK0B0F6AEF6gFFCnUgoE6M0wCgNMEoDjNIAozSgiR4jNAD3GIBfYBUj
QWIPA0qIWChApxDoFAKdQqATdFkkSF1AJ2AnEuBApxANDoFOWPZIgEeAQ68I0Xao7Uj4DekWbAAJ+aER
h8AdkAgkwKFaYByQAAfuhMCdEOpFCPUiBO6EwB3I0kiAQ8UIoWKEQBuQFyTAE0qBgM+xcGmImEOKAyqF
0DjCOaS4OaVAwKFxhBikEGs+xECBNCHhewwUrQ1gUUiAY6BCDFSIgQoxUCEGCnoYEuAYsBB8NwRGgawh
AQ6MwuoUugZqRhohjZFmSHMkynGAA6OGwKghMGoIjAJJRJoLGQ8rGwlwYJTe6CgNmgLXBeaFSCOkMRLl
xDlSKlUl6KIpKEgKfTDFak6hraU+4PyP6wRKTQoETAPAA8ADwAPAg1SqWeDg6QDwAeADwIFl6QBwqBpi
jYGzpyHgUB5SKAAphPoUQ55CuBYqGoTcdAg4Gp4OAR8CPgR8mMr1OQIcvC4dAQ7elI4AHwE+SqV6B4ki
BRtJwQpSUPY0AjwCPErl2h4DPgZ8DPgY8DHgY8DHqVQNIWSkE8AnqaQDkE7SGX7PkH+G/DPknyH/LJVq
ZAI4xKEU4lCaAJ4AngAOsUjQEEgwKSSjFJJKCgEkhRCRQhBIwcyFCgrpJl0ADkEpXQC+AHwB+CIV9Acs
HglwCMMpBNoU8mkKGTOFnEj1NYW0lII3pRCn0iXgS8CXgC8hlvVp2oSgb1k9+QDRfTngA2R0y/zpWD1B
8AiAlL2ktVoYYmigXkLIWdJALU2bY23a5MMysQyYCSS2/oIqMo2XwWssmRTq/AEQCLRGGTKF/bK0XY64
TxjgxwgS0AgS0ggS0ggS0mhBEQ/QCMQzgvgUpXgByjgf4wUlxjEExDEExDEExDFlQRQH7RoiGBLgE8An
gE8AnwA+ARxUdT4DfAb4DPAZ4DPAZ4DPAAdJhviGBHgCeAJ4AngCeAI4KPJ8DvgccLR7jsbMUeAcL+dz
wEHOIfohAQ71bb4AfAH4AvAF4FisyEYDLRLFuD5SgATaBjI6AmkcgbyNoMiOQGaghiMBPgR8CPgQ8CHg
Q8CHKY2ZSICNABsBNgJsBNgY340BGwM2BmwM2BiwMWH4bgL4BPAJ4JMRDZ5I0MADPkOYCmZCGo4CKEwD
wAaADQAD24kGgA0AA7/gTiDkcSTA0f4I7Y/Q/gjtj9D+CO3H3CEBjvZHaH+E9kdof4T2g0EgAY4+RGh8
hEYK+yb6EI0AjyDtRZD2Ikh7EX6jXxH6FaFfEfoVjRNjFoQYt4cY54PI+8ATf06zT+BzGwl/gPUTPkAf
XM74MFtKmz8t/EtaBz/i4yDpv7x5zX3rmdhsxvSZfWNn/9fe9o18uavGLUEsY+69jKFCc3dkHo3lRge0
ASj4UI4XIHCLSSL2OOqbCcgqDPjG3u7Y2ieQiCapNqqT1A1nYEfSMi6M4hSNjY076gsTt7A543m2WEB5
6y+XE+ickyUGpOBoJhhFysP+nHaq8Oi2OqTUUfj8/vqv21c3e+nP7Z//a+/8X3vn/wX2zof/pL3zf9a+
ud4u///0VrneJg9ppwp/x/3yf2SvPKrvlUPg4q7xYGxt/v7GG79qw9fZ43W2d/+hnV1p5hg5W7yR3uJN
GrZ4ualr9nL/OTu2L+7Wjshd/V+xbYs0/4d3bf/5e7RiRxasfRlRKgMzpZ359Xu0X0PmGJDjD7jbBPTH
n0l/SOPGECRwmCz7UB2RoBGDEg4h7A2hJRAX8AeiR5jgAdx2hHU/Wowof0DUWIAPjECkR2jxCEojMIUv
FhA+QPK4+wWpFbIH8mOAIXeglAiYPAb64c8ECW/GAd4EQz5ESBM+QGBgcydo9WQACWKAmiZA5MkQTZ4M
IbaMArkwxnwBRjvBpE4SZkMHQAmQIJtgNvGH4gdeQC2nIDcjm5n1KVcAL1gyEAwJ0loIRGZXuS5moOGY
ciT+CwmENc3GFB7wGWuaYZhm84gPQGpWNUNVWPVIA+5qU5SgoAD+zmqACEgREsQJVpOElBiw6oZ4iQ4l
IwoM+JelQzdCGvEB2Sm3JSg9QUfmLHneJ68nF0epc6AX/mAJhuTiITn/EAniKYqdo1hoVEjk7mD+LB66
FhI/Q/FzFj+fk9/jMzBwkCWkgdi/XaCmBWtaoKYFa1qgpgVrWqCmBRoP4oWEbKhlgVqwxpAgCi0W+ATl
kbThD2QBiLYLoAAIFhI5N9hOGkbk8yn4Md4mfAv5I4V8kKK5KQgl/oAx+2OkSX8JeXA5AG8e8DlFgu5O
oXgJ0rMcj5AAnJCDT/hADo5yuOcCVaTni93c4Yj8GlLikDyaxmduC1LaBpLzAawcZeIP3owJAt/tg01C
4MWPyQJ8YOlTysafEIyPDwM8QBWPhuBw0O0jUOOIblDRgixvgfajeowdGNyEW/7gWUFCIy8eBgn3/XvS
wjvH6phPwMgicjPQtOGQ3CylnRcP0RxpSR8AMDJwiQQjCdaGhxEqIBNIyBmBS+BvPpndDPwNeeaDiNZe
PCwCJL6BbAWdGawtoDsAVKR0BPoGPggiw8nviR38ebrsBWR/EAjBpMBeIAKBH1FlgipALYDSApQhqL8R
lSLwQQj2oyV5BZhCf4QEsTYg3wjACrDUINKAP4Cwj4G345RsA9knwYgMYgHeANYyGQ5mZPP4gwfIjVCt
QM0DknaozrMQejPUYqxYMAL0MwEQQhH+QGFOwBogfGO1IoE5YNiSdNCTv1MwgnQhdgTJIfFnuQTa4yEY
gWTmDTQz+g1o5vJ3p5mBpJnUGydYqZNw0Ug3Jcmc+5pkLmwKKazzgkAC/V9LH5ECSR5ZqiKPSOMqYVQ0
EfoOGynpoiKFNhkEeybNU2Su/xoyJ8jbkpQNaS5pmqZlrEvSsEVJsUipaM7XlOo3I0yCIEVAqnH/dZRp
0ZOuUaQk0mdl4su9h4UiWeMKxbLoExLmYzySZOoLqFNEgXzhQ/ZBmjxPqgKkCAloOMDzYCLJFqgUEtYy
FJfZcGwIFVLAvVS8GJFgDWqUa0DKhTSihA46N5iDigUOFUPyQb8CErEhEtAfDZrTsgN1F2nUSNTo9xSU
1O0YZVtg9UJn6qfDLyFzL1A4CMXB6Hma5muaFpCmzWg2wZ8J0lzRtgAkiuasAcRWqGkOrXuZxg2Rxs+S
txuQNyleCdGqj0RTTziXchaWn5SqhETVtyUqpLkQqKQMJeSnvpKMhFTU1wIR0ly4gUkxKMUq79sSENJc
Cj8JYFi2CQhqk9wzr8g9XMlC7jFSTYql3tdSTaSFGqTEyDQVWaZfk2XmUpYxMoyQX/y67FLKHEsKFL4w
bULx7Q+wQLEeoLpRvkCKmqSKMSjMmIuWL8ZzW6iYU1xAoroM9T2CQhtRFADTxJ8R0sSIDEg+EiGot0F0
mBjRAQkrdOQjDXzpALHgWgyU8IB1hWYngwWFCKy2cCCFCSk++FQKE3qdGykCLZhj4c7x5Tz1KTuQsSOF
Tbwd+D0MFCMnrodIUP9Q3CTBYk4WmqcDe4FEswHQfBAalg6OjRQijZAipIlm4MDjDHgcokIqNFBIMEOL
nthT7mP940+IhdoXcknL+xP9EchihfdfEvSlQY/Pc7xMaF8l9x6hKNphRyDVEdEKlBFck6ZNvJ+kfEjx
sKTpdEmjP94IYkDQDKCEbxK8SfiGRuc538zxhtZp/KFdjW+QeUHQAiw0HdIUNQSHoTk4XYCLBOQVoHN9
GlWE4x9NP6BF/mCECR6Ano5omRCOp/QditKJHy35sJzQyQBE3AcBB6rjz5K+A3hYzEizgALjCT0G8IAC
E5pXEjCYhLiUJBP6CNAcMqHxHw/DiXTujEIMbDThLj4exhO6dfYCH7q/P6ZtBG9C+syHUOVDiDdBCHob
0bkootMQ1N8+JZ2A9gw6akJxHnCDHZjdw5/hIECv8QeZIbbgz3IQjPlmjDcJ3yQ0T3BWg8lshGHEnyUJ
ELANtHJMo8Z4AWpKMwJmbsZe4w+o95B2giEQaEkTwHKypAcY/kyAHbc2enwRJryIAHhTIoA773hzbN6D
ScO8m1n+rSe3HNJfO4CbactgI/04HKQYN8+6mT98z62RxmVpVhprlctJr6IFTz1y8Sxpg+ZSMQtDL4Nn
sXa4fA3CfhFqakRseX9hh7iRI11UhnyYIbFbwZIOyEiQhQZ0d6BLQ0JfqUWf20BS/OfeBDdH8JxA2E74
Lz2a6Z4CbWTIw5rIPKQ5ZzxDASm0EHw/HyCNUA7+XULbAPqMwLAhFffJCUHQhV/DyF8CyamBjPASTJF2
XfyBOsIDoRi8PnuDP5iEEbSEEVSIiJ79IUgrMRdC8pCbJZggiE2YADELkInHmBKi8xJyd58GbuH2Sz+x
EcTWwWgsnPFRL1LqjyYJEolZQgMzBFLwlghZI8pz0YIPYz7M6EJPyRQMDjxqEg6B8SnSUjhgzPwl3eSB
9GBaM25JzmYLID7qp6f8fJBQblz6QB0k/LuggxgxIqAvEB9CvOHJIOlAMuAD2Eq0QMK/Y/w7ToNBAKYc
zIJoNAaWQKwGv0YaBVFKtEmxdqEyBhMIUhOadSeLJJgs50gLINSEQiZkWMhiPIBB+SzgeR9oKUjCbw2L
oz9A4ioRRyJCPtDLnP8tBkL6WiazcJkigR72FzTgUjYdIKWgRjyRQ6NrRC4c4WGeIgE/uXs5BrOdQMic
gOtOhkhQ2fAHEuoCLxeADudc6XjAixleJGmClZAiQZDkoseoL1NaR9NhgBTiAfiUjgZIY6QZUsJTH6AP
QHFgKR9mSHM+LEE18MNHFn9JiRzSdsI9Z4rdeAENeznE83BJ2ydXkyDQ0HMVpgsEgtitJtAfBqkfIfHI
xFwO1KyPFqJNAzZwLNoGuouidqKoMZecWGnAW6Q58TCQXnX0ThrKececc74x10ic8zlSimkH0kQBUiin
P+X0I0+KPCnypCmxAGmIFCFBfhsDD1DeZAwMmfhIgEM8mkwiIgrSTOBJGgRIIdIIibRzLHZEoQSLDTJ5
jIbOizyKwhMl7PVCTBBGAT0eIvFfzlGCtEDCxIUYjRAzFAI2BAyjnHKUIYVi+NWoY/RHkJf+kolRmkia
BFqEHFzcXKmB8FcTKyJVK4EjlCAtkEg/faSBWhwcmQgJeVLkSRdqjYRIYDlj9HyMno+xQlDeZIJaoW9O
JoBPRmoZTdQqWgSsMQ0w31i0KZlJfzKQXIOyxVKtGB7iiQbSiTIZyNMtS4W+wIXBCIn/Ak8HWIocOWjp
aQhcCbGsQsCGgA0BG6ZLynsCNzlaWGjL0QAjtOYIcVtZOHPyX4wMvckHEzomImEO+3zGnPqc1z6+uhOM
jrl57gcYNoC+B8Wfjmlpn8/oo89++shNVU34BAyW0oNyiNYNMIcDtnKBZQcCgCWDrEUDw4k00+nT7aKZ
78wlmxEs5hh7+U9lKy9zE8NJXs1B6BQY/dashNQooqurzVIGQA5kD4RzKJRXxWQiw2SQhpLRNDEH+jIj
gbGk/TFSgpTiByoDJiMBv4B7qXAupB/L7Bg7IeP4pzMNxSxGmmEAX0GcQvwOJ0Reri+HiwxJm5aanRxn
JZFmJ0jpEY4yl+cnRqHkId+KBcKjY0R/ymH02R0ijbAOIOKDpGEtBABQ+hXGjJRCKFcHrRfIlgB/IHZC
/+9zpx1/huBKfFhA7k156ixNkBZIPIvGJkNAHYxDJB4RG0FbpR80bcIQR0d9rBqorJiI/iilxoFFs0zR
Pawv+inR+LSc9XledLb01SqlXwpeAvPQfx8Jqm8EFYKGCRpKlpQP6L2y9CMkimX0cRyAxA1Q02AMREDP
lmj8kptYyzkNkSkScvEc3HJBG7Fw2dHe81hp1EAWiXRKpyZCBSDhGkxGMz+JuA8R8cz3AomHbOY+0oIP
qH7BByyvZcqHlLOEfDRLhWEgHHKjGaV00NAxH8AO6JQb0BwsfMTFCdABPSZHgTR7Qo73QyQefMFa8P2U
TpI8HjNEipCQg4QUJNYfJHQx5xEZfBLSnTLkoZklDyT28NEYCct0kNLNjAoBuG/ID8JwBu1gjgdwMO6V
B6P5AmmJh9RHGiBBzBtRccDo4w9kAq7YCC2MIPCgKfwPizsKwQBRbxTiazBHJObD2o9G/HKEfOB70YSS
5QzlJXybAEzXgWhOYSPiA3juHFIGDZkRFg/VHXBPcs0JBU4KFKgXWIOEUUnCeUA1EH8mwZwWTyztIKU6
lILZphP0PIU+s2T3gAHEWzwsyVYpaPDc7WAgDnoO6J/AE5U8EknspJ/cHApSH8kf8LgC/iwH9HHjsTfQ
NypJdHqmORUjOKBTC4QD6k98k/TpvtqjnEaptwf2tqSzeC/kXnc4oZvCfMT9BvrZ0Z2Snl88jzJBAnUO
SJ6CBHrXiMrXhMdW6B8gu78A+kE4AhVBBSMhqWKFjYC84sAhCQZlUh4MgxgALgQ2D8pBtp9SvU0xsZhf
/MEbuckOWvJREBObkBgCMpckQ5EJLnm93J/BdQs3E4mSPu86mABzIZaKAxGzQSDN6sDoORO37aBjL5AP
SnKA+eLWEHAYXEIcieBqQCUDTu8gGQQDIsUASDtMomA4x7+g7PizDEaU2l6BYyC7lAmfRTaQ4SAh70vQ
nYScDugngfYUuENvhhy9SCcc7TlG+UaTbEmVh4JelnRR0cSlIH2kTYZkAA3GYubNRAsbOAnOkFOKsn8U
opWi/jPQ9dlS0fnxr6HtX0r39Mo5itclOqaQNr8V4h0Yttx4m0i/ReAf2ZJkKce4yMzmGuNGzvE7c43n
OcZvR97xbzi3CDuNTyBvPqk36sbYopIZlswM5c6GHGsAZsg+4wUh3EPiqfQFckGg8xf8HlSKRAl/IiSu
H4hZoGU2z4iw3qIFHrBcBwmW4gCoOKAR+jXsZJiMkLgQ5xDbgXlYkRFoJDkNVE3asP8zWA4l5WDMtcyH
JMADlOIEqt/vw0l+fw5iMwqkyOUV5BFCnUrR6XTh0vv/LQgRCYU87jfup/wFWgPS1AciQGlFwnKiftSH
ove/d89/YmfdTFssBE8P4mnS8ub8mpqTuH0h4m0adJ+eLTBkYyQMFl8OxrSmov/jBRVJ8BZwGl4bMxxS
h4OiAzwajvHvOAGA6jx3rkFtQfr4JsXDctgT56hGGPERVgD0mP4Iqt9oAaUNZAXUoA80Qpr3ger0TqAA
LrwTlkIrGWO+xwO0Z0xdGSrmBCrmBNrcBPVP0JRJRJdxtHwCtILqj7RASmnVRgpoZwZBpGMCMwLDJglK
SbjjiGfonRNa3+d4x725yQIvuDc3WSDHAsVAfZ9AlZgs53Tw4qCHSPRX6PP4lo8E8greNRvgGTRtNoiQ
ZkjgIoNFf8bDgrMQKi3wZRYCEHJHc0i2QzdzjOVsSNcHepjzFElEcz/ZxpgO6KgEvZjRxRG9mIGPzNCB
WcKNUJSJhs9AKmcYdyiS+HDBDQNkQpvJd7DwepKao90JlOWkz1sIwNzQbLDOfjKg5wRgaHIy4PbpEAns
EK1N0NqErU2GeEkf/gQKdALelkDBTtDYhJ7yyZh+6XhBVEgw/gnGPuHx0gSzkkzwyWTBy1vofo5aZ3Rf
B7dJZswPzEsS7sgmeJiTl2BiEkxKgn4l6FfCfiWYmIQTk6BjCVEE0hBSKHzHeUXYPKB/On4PhNf6vD9H
T+boxZw9mA8BAb7QCRd/uHWCF+jBnLb+eQQIhnw+pj8794BRJjoxn9FlHb/R+DmGfI6mzdG0+ZxFLgBY
RHygkxs3YfACzUObkeiNLi6hCZHwn88TWfRmF27taDWat0DzFmzeAui84AAvhtzDwSdo2iISe3jj/oLK
IZq2QNMWk4iO7/gOQskiQTlJioSvyDoXaNyCXoMLDN5igTIgLdLvoA9JAQkjD+4OqSahMwo0fujWfRBZ
pAESveJ5qxzkHqz9dDxHSukADyCmMsUCgJKPhEwz/kZGiKUphidN6NECnRlDlGJQUzQgxUikC8CwmFI6
dgqFOgS/Hy3oyMJLfOZ0ZMHbCaWABXg+0oI+LNwE4sVeQp6ghwVe+eBwSGBVIZ6HERJ+Dyl44vcYz2M8
j/EMFA8gEAQJ8iT4DQyR9xXg9yICM/CRRkh4Hib0Wk99slr8gYzBnfMBhQ0MGP4s/dFkQWd1PCzptb6k
JLPAt0P6wuDHgC4vFBWHtAvRTWYEcOQj8QXKjJIQaQhhMkXC73TGLTc8LPmwlP4+Y0hH+IMHnjca47vx
jD4zEEfHvLhszF0xf0HfdTzQYWUS4GHAB1RP/yz8IatLkfCChwQmKGYyYxYUA1LHTX1u7CXc2FtAdpkj
4V80exbh3yj1ZzwVIL1M+DCh1SrtSUNIOOeWPh44XAkdb9jEhHashHYsCt884YiF6NOpCn/mPOaFB1TL
hYE/S3+RRvSagV6PeViKYeS9JzwVid8hL8vAb9SzHGJAhjMk5MU0LSMmngmDbDxHWoRI/Jfnw2iOhZi8
HEprDY9C9rn1SftVn6ZSbspBiIWWRHUJMsCYYj8tZZT/E0g2Qnpd0qLGE2tUpDDukLgAAi5A4oJwFw7w
EKLwcAglB1oTBCqkkIJUJMyjYJNI0HVAZiMwcjA5JEhH3P6JhgDiy2iEjKw8muArKAHggNCO8AXkfPyh
bLSgnoMHUK6AZ+jmYPGgYAGAtOqNoUqMeA3FMuDmL/6kATcw8QdvQC3wZynugFiAGSxAsXlgDdQCCf9C
y1oslgFkIMhX+CKFqJlS68NaDXiPHmQfPID9BTQIg5oNyHTpycOzJvQiGEBY7tEkOMA40cGKhwZ4S0pI
MQuyFGVdCk7JiIcHluCl8x4kdkhQ4wXPDOABxAt/uAU/781GA16JwR1w6KU0Go6iZDaCIIk/gNBqiCUI
XQZfY/nwZCjlL+6Szqio4yGiRAbYeD6ku8hiNl4QtKDRkZmXNDbyZMAQRCyit0hE0yMtjjxKsFjMqFcA
8ek/QkEOhYJxI9EgOUNKINzRMMkGgG3NZgu85TdJQhNlirSk8xR3tJeLaBbyVAAe0FP8mWF2oKKOOQoY
6llAy2m6FP2iiz1WGrTQiNdfBEg8BuDzGACko8ECCdAQAGBfAsEJlBNzFdLXP6T3P0ko1wM+W2AeF5hC
yJ1QU2c9qasChaVGPOTGWoQ070mDBLASmWkJBfYn3CYTpy7R0DkGA8RZaJnykMGSSuhSFg0KljI3vuET
/gdZ86ZJ2MR7sVcBxk9dBH8GSiI0VPL4ug2RZmIBy0qWE1EnyoQeS9YmxhQ/ISWTbfYWsiXC8/Z3EXCh
9qNtYaOgK4Tcfwm4/xJw/yXg/kvA/X+7gPsvwfafKdiOKLGOJv8SY/8lxv6ni7E8F/pfUoxFSn+9JDs2
kuxTpyE0iIji9P16n21X++K3DaSjsuho27sdXsaZik20LX6K9+WzisArQrXIZ4ZpUdENzcsZw6HnKnzL
V6LpMmbp9nIr4wtOe35DqJ7dPntIVjc//rTa3tYD/ZTl9GJfxeusQs77JkJk8ROzMSyN/g2gG4wQfet7
DLB0Vu2gMxh2Z3U+HbvJ6lylDB3L1n+qVirhV9UCdHwdjsKy2L40CF30ToTtOzIUF0caZA0QivCyx8d2
Vu/vH0VehsKyR/AizupDmPX8324Q+186Wih2fthus3xfifxejTz5pSV9g649U1jzR/Nic/joNEJGVqy0
wVNB2a1WeLkISCZj/IlAkyd20GMdNPuM0YrUhF/0O3vguJd35aciOK0OY2QCrB+JRCQa8gdFTxqjEZmY
r6+K8WpF2H0pYmxjZDA3AJIbNtZrJIHi5RbwVxI8GVe2bGenjHnrrQW0ub2dhmBn3k5+UHagU8Z28gpV
l+5OxzvUo9qu7AaV3eq4M+PdqWyyo53Tb/ivt6lRhmowNq8SoipmBK5dA9EV9X+TxVY89tbfr1rdwkR9
Ov2j/ePr3Pl1Y//606396y833db79199f93FZLHLKqRn/l1Tle3L6dXff9NqH9+/3113nMo1ERKBjo+t
boMiJtzqvTu4TS8fH9mbhqnwKoWKXm8bC7YC2nY61e8UwWF043nx8SMozrciWn+rJQE/bIqbHxXEvNwX
Hz5sdH6G0K/F2t1aoVR/csLOxfnZ/jzenu273U7WXusg/GD43r7zJOMw7k9vixsshpM+kB5/VvEfZAzu
X4C4Igrid6sfvkXz2x3g7IngxyeN/VBBlqs9UYTvRPK6m7iWQUVOvW+AZPkto2I6SAaU+PcOUK3VPZxm
IvSmgt0AUTpAk1vng6ac98zJcr5C9k/1MHgfxJNquOgwkOPd+2/fne6z3Z5B+dcQgnbZdv+HXAzoZ/CF
6d67Ebxjqin4k3ff8Z7NuXrybjpP3sdKE0TIt7M2A+qJsPLt207n7du1CgmoStp7up4eY42rZ/Oy41nf
PzR+n1/55jOrCDTog92gXIzJg+m7ms++Isp7Sy7IO88Fx0YpDIwtwqbHcdy6kbPcMiU+PcmwzndtNxZr
M7qJwIQPcSMQ/X5ou7PeOf0/xTpvMwyod9P8FcagDGf4EFewprkVx8o6O463D8C+N5ctricxeH/dZd8W
d1xnIBtiVBsRwppNgZO5RlA5D/Zs7mJrPs9OfkApW2/XkVHpr3Y9/xrD/6b19u2u1/NqeMGsT94vMajw
m1bT+qgtB1aw8lady5ew/ZfO9DUL4kNzuGmDg0/eDzXtR46CEa16vbdvs9Ob+9WWukxH9Lez7XY5dNv/
fncS913CVH5qvmIcyfI71Ya7i+BSfH/X86d4iCHwClKaGsJ59lO7efp22WqL+ePQdc4oHfb8y3Z+vmKU
3zjveMXbtyeS9uANqLHf6UzTC72i8S6NzfKmuBebKkUJKcm474kPvc3btyvRTQH6erW/P73bFFicq3d3
nX+/63g/tYvLj9NPOhin5DOJzYKOhe6t0WmBjmuNjidrHX97DWxj1NyYDxKzd2JVrIhlp5h5/JUzj87H
NVm8TbEL/CHbZKIhYsGYX2jyn7dr5M1uhUiF3DeeiJ2NcXyniIvC0UIQHRVB+8G7VVP9QsZPcaFEch1S
X3VNLMBPJ5g/mfFjve1QPtCgD3WAVDDane4nRSLu2h+9Dx5SV5Wup/jsh222+vFJRDG29Oq2ZN1fOJK/
vsdgwr9Rf29r/UXZR3qr9Gd09pah6iWJAiP0GBPb/H4g/X1Qw8ZRuI97lVGU4czvY/c1Psutz/aKKLVz
IXPITttvpYxipn9TfhvHN4yorl7IOejG4L8b0TsrB39acBuV77bFRxeZN1aU3D9BeyGxpJpZW5cV0RfZ
ZTYQPR2W+z67+fHPh/0zH5/4OpjxAavqSFaVpawibohUrZnUu7+D373rYOE7wcH/Vmx/dKKCmw9F7HM7
69dQvBYYoQ943jXEQc4+/pDd7uKra9Us6qM7OyywCrtMzZo4Y30ko/3vO/aXIqQzYxwzMPOZJNlXrTpZ
hDJSl8mpoVTnCe/skae6Ww4uS4FCuENbP85koGVRBAp92GT8vWtdlz0Bc9qf55qhU553QsxrCWB/TT34
agsx5oq/ro9qSLdyYFH+1lttPxzYk5237jw9ddp2SPcy4xGGK4QmFTd6e2KC7WPAt/FWkH1XInSmwRIO
S+VBT4eVEVLjdeemyPfr/JApPrJVod0r+aRstBOcZweRCNiC55iPKib8c5VoLl9cZdcmPP9eRcU/gGTI
d/wMr42J5vIwNYYezU/d2a0xU4z1Z2OYMzq+jmxfeV2Jq12OaUEU31Gy3l0VjEouCzjE6qfdXjPNYogO
2iB1eHo2qnxmzcyNQU6dT1bn2MKo6Z4Ku4uHBXTtBqzeGxmCSKpBu5jK51qjw+68ONtJfUEh1vpqdy3N
HLHBsM47FeH+cXd4oEHrcQcsXX3IFF8rv6HcK1e8eLfNPmQ/q7jlR6ooRAz/lonYfoipGJdZdEsP56uz
g2zpq1tzdbju6MVTtkdTzfft0+7l+867Dx3kO1PNBqoffkC3276nFape0OmoyPT1WYlzbYPNLnPA85uV
XieqlX9c7/aPj1fXnWnttV74kgj/jxJwlJZUzSg1O01bE1qrmkYTTK19lo22JIzPC6ZuEUf60jZrdy1U
xTo/+pyvPmbTzBPSEP7d3RTbbNr3Pmb71bSl6miBXOrxWt/GFaOrtttuXLst+Vq8aTDXrvKb+xd3hkrD
alE8WL+yT1ja32cf1/t9tn29OdWU1NEW1HphndOUv1P5E0rG/nQmmnpkB6rI5/eUYeR86F+nP0CklLxF
iRr7/QoozzGRS5Arz5DR1qXcSsn2fyl2a1GJFtWUnDutZ0AbXPvo9nRNtPko5CESwXVpRtSfHcXrm836
QWf6rlgUNwdTjmyJXH2iMSWi6nzHir1VcIM3QsT8hmuA2pszZnGVye+hAN6u9iuQVowGs4iNBlsazbXY
Sapn3p/EutmWWcuCXzwPjs3nZamy5xf2KDgGCTNOamHKPLRNKGm6kG0V+1OnK8kmgQJyQGixbwnGJuuP
t+DnqozzWDJP/Rua9Prx8aQ2nh39bcF/L9ddPMgvevrTaXvdi03btl2ZtSeHQqoOOzl+EsJGcCNySwHH
zS05Sr0nUkC8bOtyto+Pa/zTb2yxLj9uqGBqly0VIDFKl01DtL7Ufb2I15dr08fpWhoDPq5+bve9da9d
G5JOZ9rc5ct2UVbUrpSji+l0TTnetue23/7chXkvl2b1XnVeDqwzYoV6vHSLn0IY1fX0O2pb26YcEMe8
k75exbsm4mBLvWf55TYWlqtMW672T1OF8sfoBu06Zi9WDMRWDq+1OviuvpbWsi6zoHSV5XdPZ6bUbZU2
mSLly+936w/5atOGciI2pLzPxeZ2ulaMbmsY2m1G8lzbpdLkS2nggjOQo2Y5+Lwp02UEukhJ8euqnC4z
zhTD1i88t0p88kINR8a+0ZwKTVFLSWqn3VRkbZ9fggxyWC30PJq353e8XI96PRcZvSiso20T0+y8ryvo
l5/2O1P1Mitfygas8/YrCvbs1oqdqHPaAa0KvHJbeWeJJw1Sia7pN5FL7C1fzxZ6fl+BReRz91/lDq+u
vqMkGu/QYGjYiF23q2uztwIS1r90YK3W9dTds8g6Msf3FhPAbGRKbFGGJbGu+3pB958Af6UAAxr1P7li
G0QELYlotFS0QVrMxCYyGgLEMCKLtPsDezVeqjqeaaT5ttIIV9YBfLbZyL6r/ZfSpvUT32P5bkHWqSN0
HOtPg4RZmorQh0IOB18/AZNWq5ayB7xbvevU50nAmu1V2+xhA0yE7rV9nz++37774LXe50AJWZ54fpq+
WIyqXRXy+D5/Z9lQ9lAnVY8bZTptMzv998t2WULn3UftgkXTkS5gf7m/8q+nbFgjSVf5vhaOC7YV0R1x
e9J2P63ZAFlXXn7f+Xyz2mWtnyC6Fz/tWlPZ2xab2DoToEO+/rl8j7egHavDZj91RGmr+Y+PzKZtDk7H
9J633YJYWM1aBumtzlWNFPVvY+PtdFYHZr9i8NxqK/qCVbj6cL1rmnSNMhBkxEA+PspH/YDRcZZm08cW
9bnKrjGmlW92zSvH+ux0t1kD6wHt+lZH9Xp9ZklrWlalM1Yp8tXRkZIN0Lvkxl4AYfabmtqDic1sRSTT
+k2noVl21o6ymqzzD+a1EoQyyxYvbb0W1RS9s8rxyhrPhC2xzb8c8uM1aAPy3vgQGllDF9ZzepXTQn2V
X8f8YxXbd9tK+8EryagjCr2GS5QEkW6C+8t2VhN8KOBkjoDTxD2m4kMhccgiIG6YFSFYSsOWMm01FtnW
k5udZQ1StTAaVNp/HvtKlHbprXZvzWOLhNP2v6Ui+iAWQd/zuVMBiSI3behfckdiavLkZiplZjNesdUx
tamdeVuIJ1CgWASHwc6j24U+qPeOjCCGDAKQ11zwWiBedUCfWfJauLVl2hp3zyzuTgLUVWgmmJ8SWZxW
GqzIvL7wJvJqeeqTXE6wnt9q5Xr3XmW8CLJQi+sNI8UtNDV/zIjlGes3/I0RFFLxk5Qer9BUzJowqSq7
+NYze0CKJoq5tqzmCoD5VJqYlJ9QlJd1zWZin5uun6V6OnXUfk9InVCvRDHQEs9sqlXXxWjcmRZPHbkF
6cxxEys5sjhskqaZBEdCUK2z+msOm0NytAZfHxuJn12fAqRD/rSOaWRIterkFKuPSizbVsdLmDLUcO3E
huhfgIH7nfBA8mhQnR4neq8aVrrI5s6QylX1GkR9kzlE5DVjmjePaXffzRsGTvvgl8NVupOpTeO94Zjr
Lxi8rR68V43RGmOkHRWlxuDi2xvUt4fSRHvtTjieu9Up055gWqRS8ncjlqq9dJm3OYd2PcggSaUfH/a/
tDudUuAWblZagi7ZdV6KCPrbryGQrgUBNVsvLr8WisIUkhBZAJi1zXQv+oqvOG5SuVdhzd76giYoObiW
gYq2JYzpSbzXm9A1Nz5HNnHZqmGq9pQYDmIJO8pY+YoKXOHHHU5n5htWh3IG3IOzVbzPFFlEbVyua1c6
yDpif6/EehYEXXvtLJF9p2u/yL218Q1pokOe7x3kqlmVy8Eyi6rlsJXoX7wK/VdE/4aheI6/nvchuhxj
so7WTa5BHOsblmrjSWax0eO1SipULc/bxo1DtO9lkO5temGbTtUI5V6+eYa2Kta1/ZX047jaW0WRikgp
Wm5hlvFwlT0GinXzZsQIsOLUZv/LiPEcU3mBSZt+CgNCZaK+kFSeuWyHzotHaZ5cgTW1qXTOlVqGY/fJ
ZA0di4spAVA3ZK92MHJNG8sTKMp8S6lokW32K9c/wPVSyWwvFe36SM+Urdv/XO5fqcr1L0Hx89LS72yh
VAXe9tYm+8IFd9eZ1r6WmyR2l7emVqKA84m9Pi4biLlV49aocn5DEaJWh3O0t50ngzKf0I5nxzIrVUdQ
F4xsr/d7DOcX9642pqZzLwzjl0xcfQibZ+7JiHO32c/fFY27No4CIUlF6aNQmic1CW0kBRqnS18m6Kt9
sZepfZjOd9KPKevFOb3c5fvuVsgg547CszaiXdfJ+vRkZdr1jLicC5dtLf2pLj+YXQ557u536jJ3zNBP
s/uQ6TlTnNl4IokROSswDN1u0Vl3MQqFNQra3aKrxVmz/3Bw3SPMns2hYTPih9XNjx+2xSG//d46rvZf
3mHCnRu5ag55DinHbPmbTQZp6NwLp0f980b60wo+2tf+2vo0kq2ZKH74U8XLUppYcl2pLbrJM1wLVOft
gc1WTcCOnpCHudmkFHO1VuloBvKuPPH2QrizRB9Idv2z3OqiVuvPi87nvPQTo8+wMMTsz26LNyywVgvd
q4S72n8fxoIt6tb2sougz9J0LTtwwvXHrDjQXVeNgIcsyq/4yekb2rwTO8b56R3w5q8PYOlyL7NNXf/p
9ZswDYfRMvtcnpyiV8yxoGttew+6Yfey3DB9ZZnFQ1uXWOlo854oMu3208zbrHZCZXQloIP4XEtAuZGA
pJJXa6Y94CUBIeGsgs2eqmNPtnqohbvmD217csceiec/U3kq33HIPGeNWqhlry8v6pfTdXOfkdx8646E
u9j1acTXlGvMuHLM//ycR5Dg9cIlyGLf8d4wcOHNsxVm1XK4aGwWh761I2TWyH4fH2vvJVfv1CeHDjTy
JHnjJFhgUany2pP7pQBBQj095Lv79R2WsOc3TL9tmJN2uXVTTXY2CaBn83GUzL8IH51FxR/Hpvvt25tN
tto6U6wpsFdhAk/u6dbd0T2fcstHoodNS+192W/Z76Ol2MMQZ9pu7pZlD6zcYxLYpTea7NzHlDs9gK6C
p4uETKMlkNJzWGXXFw14uZd1HMXTNKjbap3EW/kbz5dtF6xBnj1sXV8ifW3CLwDS9hl7cKiEKmW9OmbN
mZ3q2AjRtV2jtwWkncQINCUj2TUIPvLoWHmy/dVCj3X83pWBvvDcvX3wfV2VhI54WDS6h4LofUOP5weD
Yjeb1f/9v/qOEnE4NAeySRfa+mn3r2f/6/tvZn/6j/TbeNjve26ZjVvCW3EGEyiCacNfZ0dYwjQzvVmB
jMfG7ViS3qq78dryiJef2/IURSHBRLEshIWLnBTPRlBexcXZ6jw+nK20fnwXl5Vfra7P7sy+0V0sFsTX
9A74890duklFT6+olTEKikZ4d3rXpDJOoqA7s1VSgYKsEdrsBf1GWl9WXnZaiPq98rFrn0V0ehDrllze
TTHepusbAzjb9Hpnnf3p7Xb107eggBvBVL5ekf1hmO+uNvSW//Zmm2W5tG3kNrKIgyp6RRXuivpWrBRz
gj8uGlZTdrvef6+uNXl3V2xuv+eCfdWaetWyMefx15bEz3ogua6AbJXjzcpWyAyQpqeKeMqfEIK1fH9V
7iZfK+wVIoG6joAnfq0TbeVPZfc1jsHqydnjscz0th1BvDDmeWNT8MoG4u82pR+3s03AFbkEWFqg7815
os6TfZOHQy8aLhOiJFDlLmVrxZaSXrmqa+b3kbZxLipfW58aeXZ1e8vWN/ghrD6S31W9Es7LVgFKkQmF
fqO9quUz5CXkFAsq3W6xIlrzVf5v+zeo683qDdv7Zl8IFvdGj9yb1e7Nev/mHv/kxZubIs/lccGWMojL
ToojIpqWylc7YG67yVrdU8KiODSy2mYpXfKdc5COF4Ne2LVvXPcI55uLvuLE+vSj2Y0pZ0ptujg7EdN6
TUKYbpffO/mFf4GLDc42kAUy1bmdKwXfqp+79vc4Nspf1rUzfauByX4Suw2v48Z3219AFokRxA+NHUQM
oBKwZLV/c1tkOyLQ/eoTMOWNcCHjNyjJRRAtU2f2Wv/i8XrKRHFSe0Ze7a1X5PvVOt9V12nF+8DU8/Zt
du4Msirnp9Xmx2Nn+vV2kuiOt/MK7+Ct4pP+2d5wyr1TppY07Y0uzYTu4v7Z3bk5bHZHLryL11d31+Lg
dAMCipvQeKw8FgegwYuEBClO8a20cPrEC4IEwOqs546oyA+h4OSAUaAkyG2De3SKRqJnvpIH9h4fC8sz
5gwDsNP0SBiDy84+VZroniQmEn1XNKn/3rbpsKZEIvuoZm5Nx9X6WnjS1EmEcnffilFThk1+Ms29H9f5
7bS1uqOx7KlUTpsyAbXWt1lLm0btY8JYGd8IhZRWy+qpMHM+tdZz0TJv7e1ExSDlELJYpfh5ylqllZvV
8tYUey7ELu7aPlaTdaRzJBfCrthAL3B/n24KcaUDt6Q0wVk7/mxEv3I8lRC5Kw/gd84Kafpq15ZoN1aI
XdDwqueoEMdpxRFQb13NL+9qMIxMn/ZxDqfnT5XVw1fa7lx1ga1Ym+tDLS8reXzMK2PbsWZU7yKLMfDs
8fCK2JGesHzKsdnyEozd1cEIRJowr44S5pX1AxUZ48TBM/f9qV3lOyFYrduFtzMaaKGzF6YNQqwR/jB3
kKTVIH3MtkdsNXKS9TLjXXD5uZbrznjjiC2ACJfAjn2eSg/D2Va3ZGtaAvrul9d5fCt20esX2V1ZfFbn
ane6rembq9a1o2kfl6EyyQ5bb97QU6wshQKDhl23+Fx6kemdmtvmfRo9Qv3q2NRIUK71pq1NhvLrs6wX
bx107+0bNl/srSe1v+J+1c2eZFEWeTbkzy7ujfoObGhrU1+rMocp2cd2rLWVlarM2lVltBwYrxt0GDGD
0Ft2r7MFfKm67+rya3GISNB2ud/o7epWL+ak7blBaXe+1VfbPfBXffOqQrtlsdZZ8Zz7TLvyaqmdxoci
3l7trql0o5jCOA8dLvru3QErlUHd5aHPwcvTAm/frng477K36wXT3XR10X98XEn6e7K/3E3xXt8HKh4N
K2rA5RNrD1+LJGWn7Y33XJ7PiXs5eKW93p3sQvPySqed7Xn/chv3tryJqNu1RHXb5NrLy/MaaKZ7kts0
1Tqon5ut57NcaunCY1Ig6N6U085ImkrTnOYOwn1ndbMXU33MLmj3SvolXMTu1a5uN/YlYatQVkPVrr29
gy/CFfSYGkS9XA++QoMn4yVMR+CthW8+kG3vIBsYFacTyKZNPm1BALzcuh6oOLfQTkqPxKFtiRL4lVtO
HmVmUxpRWGCG2Ywvj/d6Ns2JKyq9Hrid5xuKnBMHIWj2ek/1kY73xqNYS/TPnCCw5q96CrKDmawUVEeF
I2Vl1seiWbPfBo2u9uYSms36AWJPs1OVjT48/uwYVC72kGCuSidwC3SuD5lcXR9ZulU3ZywbOa1i8WrX
4sav9rbPLDopvlvHvbX+bmevXZBASIJrIQIqnZXb8GaZ7hzXrNlmc+yIhrv++g5tMdcESlpw5FCnMq+p
vQV5mrRt9k2dO6rdCwO+OnpjgL6IuHYOtHoMtH521VhsVRmOEViXq7e3Gk+zmjrcLlj6yFcvHtsvj+yr
33JnjYdKIBa3tHOWIk1qC6+8knBrQLkCKZ90qTWqo79QHnprcMGePu7ZNQeAV40sFRqxt4FgrDXi843U
igm7iVfQjNniG014ztcOXbux1si6Izbbz25sBWf99u2Ne2VArFsGVL6p6FcadOR0fCV/Nz54N7ZBr+g4
bVW1W868pgKBEzYotppVr9p0+dgnB/oJY+x6fqVGt8UuMObwdv3rShanXb340PFuHG3s4N2UZsvi6Yns
RVz1h/rFpTWNk+gOVKWII/tTQvwTMkPTrlTNjv4FoqhXk2KdTarXWtgPyttSbHTH2iIppl4eQNKDWNr9
zLcr+e3BksS8g5azrHx3Vh1usd2yWFlrVzah/HYjv72z67gr6zhqDlebbKf2CHXK6VBbbvYmHBTl04rV
2tl7EJpEuflpaTd6701uJ2T2jkBtI8Cy/ysbQtx8PM/Ig0u5rVFREajE32fb9X4HBXvd8aoaQ5MCK2n2
v7X+rVvtQfffWm/U26pmW/rTGHWqxqvM8GRuq49tIFibGzwzb4SLIm8QTW27NnOQCcbyCHNWm4rKXvfR
dmSiHRosjdO6eGG2J1puVg+7bH6/3txus9xcwuK89falavCtLK55D1W0H8Lq/++w2pSOxuVt0Nr+p6zB
2h+5ZtieSWP2jdj7gKiTbXfZzf7NagPGcfvLm+xnIDet2IKadNV2hTWznbNV28bQzpETIDZBLe8gE7Zk
HsY8d8dXX7kvLWcO7Gp77Ro3jT14fRL7kuE9Wbe2Wd+JTNYZInuUy1NaWbmvZlpfvqn0AAKe7EHR3IOi
qQfFK3twqH1nevA7zKO19W16oW1aXtHbWo4f9f1Es2TLk5DbjFeuZfUTxKqQjYs3T0/17ePXsDjePfel
XO7YfvMxJtoULeH1DFERtQ9yyGb1izxdy7hFysRy3tYMs9pCblthaIJZN5hgeKWdUHcrFEFeqU56AqEH
IlJRkhS1WeBIlTl3Dexcai/QyaeNsvYNhgKP/pDXscAhE/qQmDk3Y8zLa6pTpXjpmwtYGIvG7f4xC5S7
2DQpVDaAoGoU6AVKaJYrUBTgDvYKta3OD7o2y2/kQHeRIr57tkZTwZEGhAYu+chdx2y27Mu+m3HgmKyb
x7tmW6rd5K7vGRYGp6yZrQmRqryysFIHi9C+BEYx2sdHslbNU9L9XUokz9iQDDo8Z6i3mAr5Cc/t31WZ
iTK9lEBwhZKquaMoBZbacuX1hlteGvYl6/UzcHv62VgOnrhpembdZnl2ON+6reU1lp8LvdB5+aRyVjq+
s7eS+6E799hW0XwDg73DpG2vZm9WsiBZZMkuRX/WUE40+3x8bH95ZR2avXjT+s49bNhzMk1JlZws1Qw7
d7YaDg7bZy4MPSF27IWpJy+3jDp0ehcEDu/7cgtvCyTKHUFEKfdakLAMTnQ/XGuBwQrptJYZNSCzR7Jh
A9Xaq/tP6E5D85vbyPZl9HuYF4cjfuu1VoqDj5Xd7NzZxFabCdy/LuJyk+YQWzvxgkJexNQRz9nrAxrL
q+X2vcNU9FTdWX4h/EE1tCCU/9AfVHdpay68kVt7z1/sonviup2Ur49bti05uGd59jyVclLduemZcWQ8
gTP3KONlEWdTMA7pGrj3eLi3QduovdKdEDZY0hTrbrzCFgoPsbWsvVXsUgvvLi7MbG3Us5KSudtzfvf4
eIjju7dvV+fxBsxPmUBcmah98Fa0jd9X3995G4+mVRqH3r69j+MbjZ03tvRedM4APrmpyCcoteOc+ROZ
b1APMt87Ig8qash6L4fgoZmhmWF60K6effdQucjNW/EfGnlr4SogT53SLeYWS+S2XCK3eol8whK5FSv2
Lo4/WeT28yezS11w/Z/0SzJ+YFbtRNWQkWyrKJ3pWM9H1tP1RU0f3779aNsU7liG2PhpfzTneUxld+dO
u+R7verAMj7FtYXXljv7FWwvyphNkKz/tl098CondYGY9AXmS+ZtWzV6du1TOzc6J88OzOkYe/QbVSe0
h/XdOrtlFCbxRpwn01bopVAM1NFjT59qRp9aWNrFU92B7D57I5BFuA/uizc/ZG9W+zebbLXbvwne3OiD
frs3P61v9/etiuujewDhiKRm5TdnDzrODkPNnmC7QYiDFkdPrWinr3J+ePGwlIzF3a/6rLTfWWu9cW3x
JKzu8o5vV9lodijkhok8+2Osx7urnbXhYwxbtgG3nsVy+nPr1u6MR10nO8rnVbShxP9dxbPX9dLbVR19
rQM9eoUZxXrnOouUx3BoPJQ3Iz3TvrMdyK1ywjMtLY63tHihpU/WYrGOR728+igUP7fSCP/yZZV57mUB
rac6Mu9e2junmpA5/jyKhwtPnv3xhWQxAbOW6l1QDcp+fljldR/lekGcwueMmZljNjEhMYz/kWlJVuPn
5l4UYgS0Khtzur5nr7Lqp/IeMWMbNgcuym69mv6Un9RI0CG/OyLneOuzTLqOXrZz5T8vrsTUuoU+yMq7
rTDqQDZ5RTnv58sPH3/Itq1L/aG4C8pz1JKsvAutRXfctbiJn8qVfTNPRq0js+5KqerS7Vxd2lDj8Gtr
6e7itTo3a7Zmq4PZ3nW83XPVPAmJXH1tpHHlsUXfXimDN7oEnJzUNdPyKhMGRJSfg/Q+6zbofF2G1jAO
D9OsVmTltOWXFGpQdVpRwxdr0MHVLw1X38igHVvjc7y1jc48FaUBvGTas32TyxsEqYuq19Ub9AzOnFnW
ZAZnLOJWq7SE0lG6XWnYQRrqz7eWWR71b6W97dyE5jqUt/mt8dFTdiIXQdGFSI8/TmtKVfjgiQvueWdP
YV10/8xAOREZGmwWa6V/Gb+ExvOCtjq+FceGHx9L94PK9Y+VuUMHdVvKCxGLXKwfcQqnwfxTudKvVLec
w1EljikLypGjU2Y/5qlEPCF28oYkSx+T0YSOSEpq70oHQMtlxEAd7wwIKS/qL72ItF6rr3Cp6jc75WGu
Wbr0ga6SUrMP9dTWvvcQHL5WRwwSiI4/Ziir0xHxRUrfPhAm2lHEmo3XUx1CIF57btSAbtc5hNTrdabP
VSQvxLCdKHUHuj6UmMv2s6043ggSYD0+KpwTuy+HtzJSj4/5ky0uNelncjwz2q2dUN02KS7M0BalCCuo
ScFwSU9UWWqzljv3pbhCo5jCt2+3tZ1PeidYvrnPTLLUulunp6ct6a1dvTPt0HDbkOysNkufhyWROZyi
zo/tjmNwCzpdVNB6cuQLRVmOTEHjxsU6rlz/DM4mbp+oxLujjvD27bu/q2h3j7IhKhzPzg56d5CM3FvZ
ETtlDuty6NPTf3/ntd6/P23JIc+5d/b5tiD/PXXj82l2/Pbtyq3uTOYsY9sdLOG51olvREi9gytE13LN
xft2pxt4taFR7ey5DTXVH29nvU8qFkbjUGsPWqM3He2KpTgd78jOiYPeC7yD3t9RkmYNL3Ir0LrgrH42
rLnN/219ixp3js2cbqKlZd2IfRkjEfQt82HGwzDSbsgQtqUIwB/2WpWVgADJZQmwiInGc/PVAGb1z+S6
Wmvc3bmrkC+0CxaPoVh2StpQeeLD3Hu43/5i0ym93MQK53GGQsTKqBntsBhvxE3kECiezK6a4IPf7n9h
4OzPH1f5YbWZ+t7H1fbHH7IP69x+5raDX/ssbpkMLccbQ0IrO0Yn1Uqvsuv6/vM6B5Ks1dG4HfNN37S6
Wbd11er+WYTvOv0x+2XXrhamwwB7b1ogSNetMiSH1d7qteElBFJ7zO5wEPTVVFLPaLu3rvIVFVhVguqw
uNewvB/Dfm0kZutl8w3nuujGZtpXmxd3d9WAGVJdLlFO65giq7mF4a/qnhf5TeV1/WNHo57lebFfqWOq
nE4d1MMeXz2Clv+NKlLeSaL4Ug2oL7Zxlg3Ea+e39BuVY1BFxU7D95LXZA0vX1FSfUQlAtRe17xZnxnX
yqUYNXitrJpH7PGJzn/NPJc8+i+rrc2iXVG6qoBVyW4OVGAQaixodUjmSZ854VVTih9t6cVt9me21+BG
mt7KF00Udysp7i425LZBULPJLJ2pIWqtlctoQaHN2pJSZmTjLP9ZXRp5ohwTPHnJg7zdWVPKIi9rmW/W
Nz9WffFEuP2P4v4lfT3yjSK+0700qf2P7Bdvtdng581+u8EvXozOqHME7NY/bEAXdgyGtGHWJ+PBUKoR
akQy5eRzUmpjpxgZgFjibnuTyiutztYQkyDjfM/Z6v0kPtZRC3ndwm73p9XHjL631s9u3HrDbxQZbpmb
+GrtaLrrvTYl9g0aedP0ZvZldVo/hLzDUFiYtdZlzwcf2lXlZlpXxOZvf7o1F9pJRKEDnR57DgjG/LJq
P9spK6MlNO8cofk4emWMJ6UQ66SoytO1hhZHzaaer+WBwvjfaR+qusWvbN6TsD1rhNGS7jPLWOnmB1W2
3P4/2NdBKMvenXlrxA3bDLjy7jw5nH4WTvv6YmIz2Jftu7i4NIttWpO+XKMiK3TK60wLEQJ6JShCgxTj
8+73BrmnKI8rFTXdu4aszRq4Elp3BW9IFF2Pm2xS1aADtcW59z4/SfG8IWjekfnZC5SiGVGM/uPj9rQk
QrKsz3s7rPVZ3QjDYPhes91JIFptCazVEnCHMjfrvc7+jh1+KGMWytALBt/X5aGm3lZ5HOqryiwOQsLv
XFhWCwinLiw7EiiuVmDpbbiu30u2U/eSrXkvWXmHwtbcS1YvyL52zIJC3n4y6HaU4x8bNW4ZcJJPGEtk
tdtbNnddu771R2ZsyKBP0ckM9eZri9qL3uiW72LHnE7Vtz8Rpl6r6FqnVR/GzqnQ9P6gfp9Jh3UKuk2X
fTqOkT9IU9D34pqLVzlgVur+Ndf37LQvZYNRqs7XsvIy+ZpLVu7omfLyduG0xI1YMiptCZPUnrjbfEBe
RYpqX71vv796//m684jHzvvr90/XnXflydDL7ZV/rTbP2Pj5pthZBjVCTSwykeHPD1nuZAhEBtcTR0GP
OVc29A+L/qTvyaCx9a7S84aK7AudKqTjV7UA6unPhEuAHvqq4tlEOeonhet6BuYtIohbrLNpMAs5mKKE
g1PClpeB2Vs+B9RG+559mqfrVU6t93gH/Y1gMvJgeWl3tFtRmbFCztjLrTjQY0e2omKS3bomWbsVImfN
l0ktyl38udVpTVvQqpGmePagWU+hintIUzx7rc/49wn/PuHfz+YOwXo/jtj83PqgQACjfK/Qd18J/Uzt
jmvkoBtR3VZ1QMelg5FlCHNH7YyDk9vGwFb7/fvTy1b34BoFW+CE0iJYvtrSCs1g/qfyoWOZEH9oX04x
wo9iMB+FPaTz/od3XoumCP5fhzMwqFDrgTaS9QIhhglDmbBTnZ11Pkv1aWXUJ963ptbMSnRxEzNy7o6u
zFJXcm5GqFUmrXZqXa26RxvzJEW8jbwWcdeNsZxWqOTptnijx7pmHT2I489CzTgY86hwHRKcWLokmz56
K3N3nDl/b7sJNqzL/6dj0uafg0kGe5RLuRpv664+hVbnG+1KV8Gqm98Vq24crOq6WFU1Zb8KqVZx38Eg
R+x5XmJxT+WZq+v2pwrnhIzw4lHJX3ljuXWV502R360/vBBm1Sgt6ncZmb5+QqWM8vrMPetHbiJ95pzM
S3LcP3jturqPVAmgalA6OrbrixezH2S+cpw6p9+ardaVBJaD1hGR+0F2G+5H2ciXZhQ75hp770aCGke0
03T/q3evm1UZ6E71bkvvoems51cCyx/kVSvaYPrVbXZTbIVZ1noJqSDfy1s3wcMNV0ebai8/ihd/uI19
bWDMbws5WsazymyYWzXoLfTj5znlDn7toqDSpCl9tNTLuXllGUE71QP4TmYrozD2K1eek7hViI0CqIwn
mZZbO/I+TZ5xNGHCyxDe5vC/whKR96AsseIIWrb/84MYZffigj1xh+5V1m3qhhqInO6tOUYF+Wh7FJyH
g2FweeJPs4uYj+IyvTAMo8dHvhn6Q/lm6E/km1Ff5Rn1ZZ5Jv++LN3gIxBvfn/RD8QpPwUS/G8hsftBX
ZeFpEKh3QThU74LIvBsP9LvxWL0bDPvq3WA4UO/CwVi9C0NdxzDU3w7DiX431vUOJ/rb0Xik3o1MHdFA
1xENRvpd5Ot3Y9U3NE/nG5t+jE2+8bgv3w36w1C+w5MqbzLpq/ZNJiNZbxig/XKM8WTejeWYhoPBSJaH
p7Hsbxjq8RsOA1UenvyRfqfGBU/hQL+byPaNBlEo+zEKg6Ec+9GwH8o6+DTR79R8jIZ+f6Te+f2xfheY
d4F5N1B1DIOxr94NIp1vqHADTz64ZjUQQlEi+LPRCvQtIMXN85dsfFW5ZUMGOsiei/wuf//wwdBPVZf1
xlnDWkk1LzrmGmVkE/6ju7a14VHvl0u40ERNI0UJPKcirpGubmuaeOL4wmQyhHIn7zou39tmZr2paH2p
jXbawvihrFneHlP7Ampfl7GEcn1kwCnOXBhlImK6LbIzmJ3KaqWNO0FQ/+1gRirEx3lstiXy7vbigsb7
7Gp9La/x2XXyeI3W6ptTT9r7812nPOYElRZqgJHizD1c1hzW7ierewJ/9ZNyKC6nYes4Elvv7alt91+H
dcIS3C8ZWsm7njH3NVRnOYNXC3upoHqfq0VX7Puu3Vpad//A491gWRwqHYiC/PHESBEf/wppQF+bQsng
61W++sBROdmfgt0V26zEOhH1CstKnY3seDnjsEgEEbeY2PkEpxcZK6HchDdVyxMueAxForq3zqHPiOao
JpjQHGahPz9rlYAbxiW6FgYus66WqIfiN/ROQ+vCw6mwWRf0PO48i2ZqKGxhTg1h9ZXALRP9Jdtb49Cu
TU65F25n68hF1K7F+FcW7OfFOOXBKXtsh6MwEtORD82ovDaEhT1nOrMTAeOFQBqV71XAiVoBs2f8i48V
Qb/MuK+ccIXiWQYKEyGVXEOpiS4m9F33jHnunDEXUbV2145/lNgw4RlF9+CTyOhtL/X9oPFOmxlBOrdO
CTxMYZlSXLSpI7WNQtrT5FdiaH21llcvVZfxDc8fbqRjn2Nx1h42v+Q3f6h+5TCB50r19g7BkQMjthnV
a0WDqKs9TFtir8OTkKnz6VOlKPTVekOq91LZWEL1ovHhk1uOW7B1HjA7zX7Obg5YDYZiQgvXoZtW2w+7
6ZX5zttfe+Jk3XQvT9hxcGRcQlFf5Z0IV2bN9tOxeYzXp8i0+iW7nYt7I49Pkdkco4bJ9//BYahz78aP
Nbo0Ag39QXvvVoeNg9aficVTq5Ynb5vV32AxOK+emmjmMZpmrxTtBFVvikVwVj88T11Z7S77trhjVkip
l/TS5AffZA/Zat9uvWk5hYEygetNW/+tZa3tsoCmS/uU+tqmHUbns3jdhyMFVDte5qEIoEWRjJhyC2H6
b+v9PYFls1Rzn23SXuZxm1P7sNIU9ZE5zCIGuXg4fvbaabveTfrvTmHcnzaX/n3Ktj9t1+BUOpQfW2xe
Ptcf86nbo4aPK000HzpuDI3f1Vqk/StNGdbJz/840C62MKaiRvOSZUkSYaHaTa+5fVm3PDFqU9zipdGN
MlViDFctukc4h+9+RdPixpYxXLtlZReNMY19VYPERmhpYjs2SZYZrkTzxg+zZsvd2TOBdWv5rxgUFsNO
p6zydasxhHFzt0SwsiMda2reF4yY0/GaT5zrvL2v9QFzc9nQ3+t4PwWPyfZZfcC5rfOre+5MzG9TA9aW
tKg+f1LKWFm7XajDyuUQGX95yKaMiSVvjdpmGK5tttWHEuksoIttXeZClvNEnKTp3lvnSxp5pycnEEpv
p+un0kWgbdQ3YwSmO/uusV/LMlcLLEV9a5mKj3+amEz40twdhCFZ/JKvPq5vGkZGWUyUd1GDd6A1UuXR
uPVtzPD2qsvxyQnITGMv82stuH5xL49+6vYyc4hXrYeOx4TbtjK0n11tdi2v2qsMhe7rZb2gaa0QcXGL
wue8hr9lWQ1jMW3qZEkO9W5B0ym4VzVNFWX2Oo6cCdi5+x96FGmEv5chTwTtkLpkdtv7qdjyNjW5fXPW
WEbciIz0xm/M7oSvq7a6Hq9frnC1Tvcn5vCwPP7p7WPlipFLosctzZa+Dpq9upMx/j3Itut8vf/FOPis
iewuaWmvURsIgQzvDDJRrjU0unTLb2I8KwvajN6WW7/LChsLrrBCq/jHx6trm+we+byh2W0oPKVAv8cM
q6DVjTYw5fPz99N/v2y/316+zzvvPgIFFDauDvtCf72/8q+n9dfciyp7+TdgUv1MWvW0sXZM5r05Z/sL
ecX3yUmu98v3Pb+jWqbkNu6HZ7w/SZz6s7M2Z5TnNS2WoSDGKfLd39/vul8p/+1cBf1Dvd6ekSzVl+/e
796V10qrknLGEpeFqQNKYjv/oi8Pj/V6+rjYhYjDrBu60w3lmaddt6v9olXuwpgwrG8K65uipOAa43l4
rbBR7HWjb3LJCD8Vf3HjY6p9Bba6Nc7d+Rpxrt6831+/63Ry5+Jl3zS1XFkKYcTBm2MWQCuPY2Jq/LbR
omaX0HG0ub8VNebSoMvJXDVNrvpxXReSOYzZ+ZtsU6xum6Ne1+3PdXO4ckKtytu1IymmnUJvtDeiOVbl
Ncbi9x9urTdqs7XBP/PtW+saB7X3qzw3P1iRvDuurqUMwWruFOeVPswPq/299FLZ8sRgxcvizGr/VQVW
6k3NYEH9V9bhNJlte00HF021naa52TC+6K05m/nkjBWjjXEWvxb+Ju0rOp6QYdjeGNZ5M/nVCe8T0CMj
y6637PLlhk0zatWE8B5t0U/5UwSoqAzL9lps/30FZretbvKrCdE9fWrwB2AhWpo62qbq0NPLvnqjfwNC
7Z2m/oE3Y6OZlRmLa2f0Plrn875i9Gi5vtr2zVPijTFtcdnoTBr7HHyVNtGckoBwb9F7qyeWYuVc+lpb
xbaHRL2cMu77VlwUclJd2gofrTdiWm94RLxkMHWKcLwiBw+fpxL6fEmN3NgjlHca6NFrNoUVe40z/eRV
eCUg5Q9eUME46iIkxnfFtzoERu2Vcw6wkA4jp9yN/Drb3xe3bJsKuHNvTh6W4IbTo/JGLVoCDzzkWtvo
MpuRiu7aJzaJ3KU4byFl3QLwk0JNJ149ZI3tx3XO/RfdMgmQex9luQaRnYK3vziFx+U6Ob2BMr1X60GF
kZXnkxk07/Sn1Ra8bV4cNrdvICW+IUq/+cnwuXpTLOvtcxxX1P1U7oIXm813xUNcxpr+1rxrpJflJzG5
wnr3p9WfrCvTq5ma5W1Th8uyG6quNN4U7Pbgj9ndvtYF8fKZPgj4i50QuZ7rBTM0dcOtvrEfzOJ8lmX5
33hh3dHveBHIAUjDTG0rHLs67HJpbsCxpUMJ/Hr1s/PZrqxOHZWw3pStqhdQiTxTbYPII6/ecWSNapYz
eTFN/+xIpubwBGAcdjsvJJ913pnAvmVhst0G7e1RbMYQ7Vnw+JjVHSz8kg1al7k5nbWaE5cE7o9rECb7
IL0Sf2dSq92VgdQqrhqevNu/r8+AGs9DdcHrpXVdwlSr094hNlc6V27bltds80rii6LzeVXerdAVfVtd
xAflTlyvsNs9XuVTzgDp5g4o/pCfiz1s7uVYSN7eA97htTAec15s5c27fPlUG8Ttk4uSR3c43FuW3I+e
i/plfberXPElJ+IFFUYf8LT2bvRlMi+1tbx1RstzzolMdR+SiTEp4va80BOZye6HtNU92xSZpRw1bvBJ
CbE6cNJ+6dyopm9pUO4yvAhVinPilE55nbjlLLU9EdEqej1tJs7E9cmnYqsYSgz3ipWFUzbvE/okt2rb
YgcWDx3bR+yvxmuXLdVZIPJ6eacz1b9fvO5zpwSOMq67e32x6aLv5bZbkKyaW4LqbTmNO8tJxIT8z83U
/A7jzGvbs4YrqhvGWEs8HGRxyvPXjLHPMf6dB2pnV3/Ed0MBM8uLz2ly7eCMcUbeai2fKog+ZCsC+gLt
1OnbOkAevzVM7PIkn0q3Rg51/1oG9CbP2LbXncs2Ztg+rra2PdS8dXnyXETS7nemr/tABv0Q9XQsWu+D
1md2ZAW2aXXtyaYUsVuYCWTKm5jFSX1lNZKXQkjJSgjalWrLghh04plidCm8p7apr1/Yoi8ZGz048s4o
IZx8vnMjt+p7yHSE8o4KTF25V80JRt6rRDN3DWrP5JS64ybO3bgWUFE36q5+Pdg67OZ0Y80DR1BG0Hyq
BT8Ue78v8Ae9Q2wxCH3G/IWAKhaz6hy53VPcbuhOzd6EynZuddAmp8K+bLKXWffVF5c9+x7jqXtprwM7
OxAlGsN1lfdJqbB19nfWVyYEHY8ymCh7TjFW7LtaIU4UO6BcUb3HqizIbijj1e2seHWdJxmNzGL3OrsK
l29uM/0sF7rG+Y2+3x9rciPGcqXGcaNHbKVHy+V466MXPcZlZC8nFtpKdSSrj11Wjl2Zyx0cuyz2P7P6
72VPnRpeS9eab6rhTeUFabl1enD/7kPd56htXQYPGQS8Md4LrmiPsYygbYUkNdf3FYd9Q+2lTVjf0sEM
QoiXxn7euiv8X63lox2XrPvX9nZMhvPykvCzbldfJepa+9c0ZFl363l5eTmdFUyrf1acb1FI0RFXipvt
iRN6qSj5HjmIpAYGvvbfWpcVmocpsQlbXHT9zrSap1/J07HlznZ5p8ZX5tKK2kRmzdeN0NpRhZAAqisA
z/tVGuV+3VUXgZahzfs68FMve9JbS/nFsWJEVbqQiyaZv+fXS97Lc+36tlUVm9eKClH2qgG4N7ZFxtlQ
EdjsPdM/ia3W069n/+v7/zn7419TESGxiRaLHawvWdld4JO1GtdcjSAguQgg3qgpTSsaRAk5a9ZLVIYu
r+n1CrOD5lKkotzhNYX+tXomsGLZsupmnIvq54vip6pr1TMFmO9vDzwdsto3YO2zBfSty3krE9ykhxnb
Td+Tj+tcB3Wr45tTtDxU/F2BKo607rx/2Z+aUhsUZe0tvXcK/kuxW7OwxoZL/yar1XI9ZlhnGY1xoD/m
aoc8burHWXYR55fcJ+EWbv2WZN6iYe4a11W92H7reLYVutuZCjdAS+U29jISUf/SvvYdfcoqJK9TkUfi
xjl5NupA3RpUznLp/KPvbttflgEeGNXcpri1USkv3Z7WMzY0sjFwhHH2KS1Y8bjv1cxfxkG0zCeNH58x
Y9JrC1hSdcW3vq/Y4bKTuG5i+1yvNvOq5rnms0D9um+9g4pl28WZKXk/0t69B9GEaGCELV9ZqSpGYd2w
8tK4D0f62bAbrfKUA/Q3dyxr1oGmEecSORF27Wbo6mdA1bX7jZOViZnaPx0dWaupimofHwTtD/d/Druy
N8+EZ3IbdMY7gX4WYeFz2bi9apxzA+5XN0W+229X69xUwRsCORKeKKG8O+ikWs/bt9sL/7I6kvH2db1v
H8OPCn71/OdPQTUMoGgH3e2oG5/4pfG62tWaHFVuZIO2llsCHveTc+slSGkuXlpRAhpKrSCqGaMGNG10
1HCRWMSGaKivguG6UjnpR9Bc4sIRLDck//g5v6NOi9Yc08stdiLa85IGK+K9Rdx3LkAT1KIhP+9nqOTl
Hd3iSiMTx6alLnejofSyva0YnS538bqrCuFehz4nM91RJYhtyGVjtt6ad8QzoL41UDyhIaNYgYr0qTpY
7VGxYzry2m1+dbW/bBmy2Zq2KjsXrWsTvsjLnbC4ZRjK1RErgjU8jjIh5cOVNqHYHwu+d5CXc93IU2qb
zucNpcpvxLeY9+1O5vAOZcRGpRwfDNfbyPtKyRh7qt339ZqgiEFuvQc95X7HvQrjtcHn8T0bcGdGbtOB
GE/V7Obs5txcPnOj7bKb+O7q5vpsY1sLDlJ1dlvyhLktb8x6UHwqZ9A0fYvfGoLnmYx6pj0C9fyoteJO
0dmte8XfrffQPFFew1iv7XGWIdU2blDNP+S79W3Ngnf2ifpEe4PcMjJTBe5xQK2uiympzOIOmtChvAJI
hwzoTD8p+2Dti3XjF55Tzz88b2tnznJ11c/nXBJdHm1qoB7GnlUhH7qJR9YgOvlrVw8oRC8/uoaA2Rv2
ozaAhTF1ltZ+bdvXaGaOOzeJtW/fkoMVG/RPXnZegb9Z5bdvqkW9uV99ylSgt/199oaxv05anRrd8s1p
igpHXnu7Z4NqEe6tXI7hZqlx2aa1xIMblvteBbiXwKdGobJBJtoe2yVe1+1JZmtYj5w2CJSc0ePltZs4
O7NVKW9rNuS07+jmHOLhXR0nNt5dx7u7bIsbBe4aYvVwEOXF1GdSgpd29qLcPVIxbPRhYk/Pb8djfJC4
DAV/x4DU54XZv8aCK67uruODNNgcLXKLQbYic+w8EChTCTjNSodfLhyfOnRHM+vtlXm+Vh92Ibzt8Nos
8msjdkpHAozwt6RiWFdewSp5wZjZUu9M9SJtau/mmoVvXi4SQ/CknCaoLQdYwANIESEqm3gPsd/3bmPf
9z7FfnB2pCwbx7bW1tdNGfcnU17VhfQyNke0c3WJkX1Tmx+8++DZEhuvxbPgjWBv1WWYf3kseCXsVk/C
S1XHi9FmuqtrZQO7uhaCldLwC+jhK6Q7C71nuzmjESgX7l5xoU4e3cdFV1y6m10xguFF/PD2LR750Pl8
w3ikOmzFk8xE54XHR/lwwAABG+/PQMgKKOP3vV6nzFWGHb+nD4VbmKxXfV1uwd1zC06WcGI8LFhCbLqn
XrrFSWZuBPn7Xvvu0u9Pt7329uIi4EZDuXjvL25lH8/zDlosYpvqyxOrsMpbSDF8LVdY9YsHXRpesbvd
bq3DniwE7ABZPXbhqRJtrYb/JUJap8U432ciKni/Ys022FhoBnyIpd89518YsNWNeBP7GnLpdKJJpd48
6fIMiUTD2+qu6U5ul0roJ+WFiWIHwaV6+dCZHi4Gk7dvD+fh+PHxcDGM+DwKdYYNM6iLrD62Dx39XlhM
9XPjCNU8ZWqsR16+YBZK3+tfn9kh2cyJGm5FcBgFN/Hk5oCMF5058aKp4VjDuBYxryeXeffIGOad6bbs
3LbDnMFUnCEQtnT3woYrqEz6XIzl4WVxSmltrzraZI0OZh1LUbNeg/UqOcR9SRosYmtzHKQ3rXE6O6lp
e4+PJy4bRQmXfnc/rb01vKFr+fCxE6i9GsvbRBN8ZX3P1Fb1F/zjaiesCdK0d0SflZ5UpcVT23WBT7WN
hKrNXnzwXSFrU9dXVu4Qrd8ndaxVFWtPtXhhh6zuGzR3tf1itbqT/2D1R8cur43dO7/vRoYUXLci3B03
+13WZn1qXNyr0950o0DTzQC9zD3c/+Q1dur4zsEL6LMXgQKOlNo4/a8vWMXRbS77yOyqDQhrD6BfbuhK
T6nSmVLIEgchT8hBcm8FMyJG7fqxFT2wN/HKuqUGhPeOdxNLZrWCrGqCl1g3kfH1TZxdrK42kEfKU2o3
8cmmYmQoLYdeGTD9T9nPpTwO/nUbP1w+NDhimvNpjJ11iGs0ti39CIru4YKhFi5iLXgU3fjgbXldNjl/
exs/lHLs0XZ4D8dbAnW68Uo2wf+2R65jE8CiIw5kQGSzyuXNam4MFTss5gP5lpXbXLGGjp7Hoqf3Nm7c
m/0hPegs5V7vmzydVU4/or0PUoVr9ABWBpDKMt6K082fdCR4IcbdbQpw4qxXMBrdp6uP195HHqj8VN6f
s+Zr4Mjj46erT2UQbjJ0S79ZY4yMCNF9ztmWV9vxKvcGG/b6gjfJo8YdrdScxvXtz98VZjGuO1PXNcKE
BKoS0OOLUp8SjuOWoWmtjm34b95vlDfte+ZWfLlkXvqGNDyjVwi5lPCxEi4vyjOSMTkoeahwXA1xdbj5
6+2EpXxnByePm5y4CoeE2HcS/lr6cXDph7s4voCEOKv0QNy9v7w/Ti0O51LgOgj1qIjvXa/w4kIFjjo7
UkPh3R+vQ+vtBxS27TZQpIO4ivw5anF4jlpssRKkntRq0SjLTly2b4+SinsZXnMdW42Fon5bu77MDvMp
Psg6zf7/zat/7a7+vhprfQvXhVj9HVLcj93u2W18a1WoKQA0+zKMiUW+tg75al73t/SwP7ZeX2TQxxZ4
A4NuEKZ+dcGlSFEKfzUnfHV+hAtcBbSoi9e2T5HZ6rWpjtmEcD2nc9tzei/isnlZr3TN6lk+W6U5fh03
2kFBaPpC6NhXD1Ns5WGK/eX++Krcna/dIB0GtXZY/WDXlwejHDBKGG9XuSiEd+ze4t1fVnfJVaoaFYmi
xWjkW3uK2tZ+ojzEl///2Xvz97SVZVH05/1fYG5uFloIAx4ygBV/eIqdeB4yOb7rk0FgxSARSXjmf39d
PU8CnGTt8+733j5nOaiH6uqpuqq6uirbC8DnuWo7x5ZNgBZ7fG+8xlP8WJb0JOV9oxRzUnmlKYeilN6i
jscOeX44nB8mcRZjT/ou9kpu9fPusDg+M9VSXcA7iu98C4CU+tFnfrWlTFf40H6EOW88Kv7a0BBC9En8
2rvbLa6CBUYDvrpoLvBnDX8OEUUA3yQQnxSlVupyuH9CaIr4pBv6SQq3pGgLIjkGCaZ1idABAsZzX5wY
kDiYxJ5AtekoAQi+O9AKFA1TVyGrAbYI4c7ItavijDvs1QHXwLyip/qvM53J8fLOqtyNSn1VGRbO/mnN
O6Ail2o2yNg28ICP3Ss/6vSD9ARhMVcbu+IJqzlTgQedBg8cRQoPPwGFAZnziAuXBv/lBnOGblO8SuVJ
3PTFZpAw3Rwm17LFkD8csDYDshD6fez7tEF6MiZhIuGgJJKw1m+6k/N9SOlg62OXvxA3x1B0ljx6tb4z
D6wvy7V2YLYkR3iNRyOXSssmEmB8TV+LMvsa4TbPfA2vz0GOA2YGwv7OlMr6xnAt6SuQe73LGTwNLvea
Z0AGa5NI+OTIAZfj/mPCrrS7+9B6MchvkYUamNIMdVowHmMvn5uIPNOX6d7QEryEOEGaOWyJFKhEjWIy
U/Q1LegHjfER6mFAUlscjth8sk5f13uPYzXCAhstm34oRFTtjllRMgjsSbnkqJGCNsc4QYzf8J7EoVah
SL5bjOqBjjNjEiC4Ua4hDkNPeEZD5ygLWFMKxLMSqmCts1hyItByIbK8+HMjN2Tv68j7mkf2EAURd4R/
uRQixttpEm8PKZKfY1QnLvOLmqb8OA8/SwYw/If0eR0OaQgg7AA84ZFOM/Y4Sfg1BrkU7T7mdoXpqWto
3SbSeKlx4q1DRhji+SgI0OYSV2qkjJ+mweCyH9DATSKgJ41hiSTk1UBYecsBLYWroUZguZqOgarBy+ME
Mwbgl1hEh2XvVRjHiiRkdhtT8d1+M2gwNryNypCJALV9e8XrEqMLln+F2PSrFZ9dqYXn7fLVxTzZyqXR
+dUFfiPGo9IXiNunoYcKXrgd+KfsgzrlxhsyBIbUO9IIniSj/xiOAySTsRyoI+VRwb0v3rt4bfZJHwnd
iMj4Mb0Yoiuq7d64GAt3gFhm/90COrzbHqQssPBQrLc91NveChuqZo/dft172Dc3Zi4P8GilaCh6aALE
hRYZqXv5DhLXvfTu0TAxpAhKPfeSjrorfpYv2ZJ3cNxd+iTs1lMfgLibegLC2r3yYj06Qm8FbZcYYamU
XrlVEvFgSsvOQX1W66PploZ5U0qiddkyhXvLGEJq4XvtngvX+Xh0VPzQAJORVbEoK9FccR5/GyHljLXY
u/ZneLLkySgb0/JoWzKifm+U7cMOORr5WnKXGEIwxbugTeMczyHiFYp1Oudpr4hJ7ER4usQu6xNKSiMk
gCBOMbkJ1v00IFG9iYVWsSgWVSosSPjFvKCM4E6N01MQU3H88SzejW+DBMCWnDkvXs1Qlgd/UNbZcMiy
GnK6VGUMqDAjBC6ecitl+WCYMOwm5bOcH6GFdJHuMMUAInHCL4WboA1HSVvGiFAEZAR7U8CUiM6VZt+C
DVseaZB/omIud4nYJeB0KTGTYqb0UTuEJkXnsUqT3DalL4nru0kZ5bp9eC9GNjM8Li21pceWFbetPmEw
LgQb8K6ybbzyw+8QS212eKEjSopdfEkDIqZUn6nwRMxIyEK8cFh3NkYjmXaM3iE6NiImGGEpPh9dYEh6
67/VHGpAmByN6MlibYvONV5RoBxRORKqoqNchyo/eGD0xPiREaKobAGrC9NyrUWP8kIYoamI2iBJk7IO
fyaSYI9NuBh3pkU/CbeicAOkAlry8C8Awr46ER1J2/5Q0CF4HXZ7FfdB7upgQ/zi9++XxXJUxv+yl2rB
fBtt05MgAkXeTbBa7A2QpNwbhMVmoOwkD579V8+/R9+TC+bKkTzOsBI7jKQ6RLgMDDvDEcLeg6sl8U5O
yqFelWKwCJnj4TUx2FQffA2ylY4E0mPT5Hv09D15+h5Ve27xxffo/yBmnVJLiPaGiLvk6ZoYXkSy4QUg
nYgTmGENbl0gEhHBPOXmAyI4KFjLecUiRMAgVr9gIkq3eN1p8N81zjYq69ROIMW2RWQCDiaNdwW7Q8og
puzVajPF8YvD1fA8Wi2ioxFNOs4oXsDjKJsjE/bAHuso0/NkztNrslfhIY4BwJSTcFcLKSy2fqBdk/oI
jrAnYiaUKQ3DLpFYVamf8tscOP5KoZs4MrVO0GGWvPNi7KgEl5AhSYUx4SMKppoCwBuBwxx8HzkLoHHj
WZ0omfiLLil4YA+fK94IK7V/rSdw10V7MgOgsU4J/TFXvsayFjSjwR+92CKfXwf3lzFalNUrP736hygL
kpnFdVQ7lT6RLJ74PYhiOWuY9FjywY+2fQZxOCDeeSlEctye314tDvw2Wrq3YcQMktvxYIDQFH49acLH
4H4NCW9gqfwoHIWv09I8htILiPPbD2i6h84bjsyIIBNL/vMCKaiZWq+uxH7lg+HwOK/qgIDWIZn/uPn1
n72DjZPmSEyQJ02Wq2sZRA9MWZ8NxDk6efwBN9Aihui0Fu+2Xhg7xwQTXTRs7JnZ5Sjsw/e2T6znXBOe
nWaDYtRQe68GDdIW3BarOEQX4O5Q9o8vZclPz4ypFeQendSFhD3gT+hNYApqQgoXpzGmCb/kQEuKvOhA
3AblWlJu+Y/QjKnRf8pe1cT4pprbzkJegp3VA/cpuAs6jKYNu+EyFl8FBOfKcr+gyg6ZPoj7fAazqHhA
E8ui9AiCSSNzKRINxHWhMW9keOifnoIxGn52aj6hA9Tmn4mMeLFI+AT+FqLAniIxHoSAqX5Py1WY1HB+
GA/BYD4XKNWa4MsPhBzehREavmweyM1O56KczaNtA3fWpWQVNdiAMNQRVdSKXp7GdP4R3w361TD6iDcb
dSGFOHHwusD8RxtNIrJ6HvMmY9zkhCbKIzx/zD9VPjaTvLkYS9cNm9nqXCJ56VcoympC4lJoSxVSndUS
kkDBTpFNDWJfyFrFqfwNGPAmAOUc/l6AS9wMAdogcYNwA/wdU0aKskB6ToPvmuDCpJ7qI+6XL4l6EsYR
xtfqTJCShvPsQpEBpeUdCVqhLG66krFRTdMWqIK8V8XrPhrLgXkjEZiXh1Gn+6BEfniMnEs7SJ9pheCp
XZ+h3zYajAZBa4P28degswHKXAtkhYqbhwary4m/eC/Kt4zVC4uiLWCU4Px75Xv5okT+cVarCOmwj7hg
q0eMMXZ1xmgGWtARXhrJ/NbZ/vrpzsH+P+h4PEH01QE5SU9UERDhPTNV9/KIRq8RuWSvNyr1MeG3JBKe
Ee4eb4OiUkvVlEgwqIsQ2WCeO3+MuTpmJB3w59l5fHEhB5BnK5ysVPpKa0422DLeboXRjd8POwV61ZVA
wCEEtlyEs69YRoQNiZfpkzca2/qejiWVNppW4wSXKBaiyBflSLHMNejXecIIA+ESP1LOMTcuDQHKXkqZ
8OB4nn+BcF4Hgo7dGPEvEuspzK8slUX0lLxMwK54YjS34oRAWedCz3Gh5AkZmIPypN9PT6H7SBtuFGEO
i+OmWQVeuNdU5HEEK141RnyClSuHDbpNGG7E+mfzWDyWE0cWfp0xSuzHPwMSCm5mll1cqeWw/rykGgB/
5qs3M+D+fE5TjtFlejU3QwD+WNfhyE6vuQvny/t9TPRlFpNfotFzkTZdKsKBovoP57NN61Il8DzYpMQJ
YqAhJOLTEwQ1ccb4ZflVkMCrMvymTL7b06NfMz/bAND2AEVlAgJH3M0IJ58g6jYdZkRCUANTKoDBtWlN
rtzIMUzRpAONG6XueOGm7UUS+J2DqI/EhTnQ0pAPTbWLjmU8NoghZes/IIEjubxaCOfJDyk2LHUqTmYg
1L02+F0045ssT63uIUkMwtrPsah6JKDdMQRu01g0yadHGB2Dlolhz7c1+FtXHJxDbNhRWuRvfClU6tEC
yaZJTA806dzXPNOTXlFVmMRE7kFtWpFAIvPKogPgNOp2v9+RS3M8wOsiCzVlgOZRBowcky2gPQFm8Jwv
d7rAL2wBEhhGnqgu9YQbX6AmZuq/1KOaI9/y3E+eQPbCB7cqs5gKUIW91BYICH7CkTyDy61KyMBYWTEh
pDGJV2xEIEEN6ROclaLdfV4X7Bqi6YhimQ3X2bmNgA7M6eI0KcfxGNvmqMU5ZacD2wN/iEyOWEcwfsXi
KDiJRtxZzjFF54sFLLUpkfihREOU/sMSfsXuAzFB3bD3HLMPXZtEuaFb6m2nDQ6q9PNJsQ2ZZ406/ABS
jEOamdA6nT9i+Rrxj/HtSZDBy/h0L4hGRS6Bx6Xiepb0Ky7qAx089BsNMQgsymqWQ6ng7gZ3WTWlQP8Z
YKjKkpsHQyKQaJEsrrVfgjPIZWQZ00OKaS8+jcGUfBO4SgXNVj+rbAKWgO7m7Chi/vQfEkdPxxDwwi3R
0GIBuHpDmBGn/DtRFn8Kg9tG0Y/CAYkMkoPyYRLchPEotaN9Auy7QJ59/ktdqPxCH4h2Hm0oc2W0pJXR
suHMdPsttB1zZrUdgMsdfgUgN0LC2eGWdu3QSWXhaTp35WQxCRyp92BX6oG1DSI2cqtXRFEGQ3SqbkK7
BYBZIEaqDVS5Du7DsN1f5oAXaGiW+liz40ViaGsrYvcJY7ZVlweXpNMvlJUz1th+jZ4MYI8MtrVjdwDc
KRmkFi4OLeODoGgsBTKi9pUwiqwIkzVL0SYfBvK8DE3jxWbuSO0PdkTAJZbpSpe2FhDu6M+MmBEIpT+O
3aEP92k5OMKQYjzpj+fh+kfHEpaERhykfcvmmxj6VWqTMQVYlFQ8F4WD7CowqWtNWobPRMEVaWTdl7SL
SlQKH6opjrrw/H2kU1SxTSxYs4yJuFM8nzt6CIUIW5TrxPGjhMd7e9NQGc7kP7n+AeaQHpomUmQkZNRI
ygQE2Qn8J5EkS+Eg2aIDYEzlR3ak5yAm1lKYbqIz5b7krAZKjAP4BdYUJbChlAd6Gj6HtsETy+ujymz8
Ofzkcc6bWHNCt6Sp3HoOewl3wZfxnc71kEviUpDLR0ox5xkuxR3sMa9oGwgtsvzkCchiYpyQs2y340Fg
rNyzoX0GelKUC1BV499bYT8gLqunLGYJx3x+Dw0mxeU9hPqAKeoHH0aDYVHhnXL6pPUGPvkBn9epyL8J
e6jt/3o/yPCNhko3+AS4xV+Yi7PhsynKKEnjHIrSwyyqhiBG7WxIeKtDEzcQE8WgIoSy+SwcBOkfxIst
7MC2eam8AlnaqgY32s9c1+BD/b+4qq0dUruCvviKzu+QvKb/i30gA9cBtMw1jbF1i780F1D8z69sA1GK
IvxD1vf+tPWNEfu3VjhESu/jMH32RU5C+BUVhgynzT6wcFpClT87uFmcj7qKdD66bIT/DQwZAcFuZY2T
RJIOCa4qGXnmCIO4PdOx8twhzkceMHzSjkKe9kT1JBMH/V9BmoyHsSqUof61If4XFrCBJkUQjyMewrVp
tAGj9W/ShiTsXeUSh2OSqVIHkvg88oDr/Bv0IQd9DfEJKMsk4o9jKdMI/VwWFIIhq5KI5w4zbLcZjulf
oRA21DF6TypfwdOe8lXWKn34wwiTkTDXhDrOvza+/8oSNlFlSJKxpKLkFCJBUPu3qMTQ72lcDh3BQ5RB
uJ1cQZsVyRMvTdhMz0Z3Lm/DLs3jzkxrBAba1lBRdID/JCP+KWddIEDTGhNjJss80oiB7DNxvIj8lTda
qiRljFWepCdGKh88GycF8Qkos+HIh0ha1YQ/PMIAkjgpsQBOEMEJEvB0guuv3ZdqbmXhbymj798HyTq+
FcQOWrYD2AITsTBmH+NBpv9ZmPwGIoR5MXmuoqxH+R9lCgWKCtEvShLx/+CBRJRW3HDAcnXHrkxVPXPO
ScRujS1GB/YJJDYP2OggV2lgHOTTGidAc9v8gaTjLMYPHq1dPmR6T4seBdqB+mDNQeo/dzZmuEOdhBwl
e6pqdjZEn32dMxHV4G5IrVomo7qnoro3I6run8V26KcpGEGexmtJfJuqV0CY5tsoFviVgprYwAnUMNaL
6ZFNH8zMiHtGCGJ4n8BsrqBqRq6QDC06GKvwKxsa+BCXbfcDX77Ltt3j0C0/YfykLQig7dfeG9Le27DP
nByl75cwgaoCGx4e78R20y+vpA1TlWjH0AT5a4hKGrU4IYeOnV6e6JfaORxEzIIXWtCRDB1mHTpCc4EK
wgMsA7OqhFXVjhGBsE4gcNSmtJ+P+iEcyRp6a/24fb2ehyOZx6oxsxPxlUE+lxrn4Iot0O/J4/UzC7Ml
3QcIqTOPU5SBleq/ufRkYBtWBkzR6wrs8nl+Bb/K7yJInzNbboFMLuJPXuPhAwP8uPHL846FpfgmIfHN
PhxQsSQBgoD6eaP8jUg3X40F+41fB3zNI5tqK+AECZMUjbdXlpcxgHlLDqDRGKcTaJ20qMgBYGscNzul
OSmk6izN8b4aEoS2XI3+5i9i3mMmSs7cZysStPmpzSrRYGdpthOo1hwb+BkaXG/gH2Q9bTzRQSCZE87d
UpEoPH5NJOBYwVP9dKhvW4LEGst7WhOlyCYQWblFn+jen9gHrNb9zS4gXuqfOPmnQ8fTvOiiGTmSKXXe
ZbJhwuD/z+JLYE26MFCGm+4DkTZhQE/j35VkrVjalJZ8+VJDoKlY/br8quGUf5clj5syjk+cQ5tpGH/z
jsuCb45unQ+iNKJT8Pod3akwcCGB6C2b5dS/5Gpd+G3F5hL4rgMC4w/xXSQuv4IQQSUXCVLjDzWPe2Qb
FTxN52yZn//ueDyLb8ZgLQODUblgOF1MwGlnhjF6Fkokbih9a2HXpJMi2KL5d5YoAUMd2U5oJ5kn2BwH
w8DHmntU5empiMRrosR/esJhzn8HF/wGWJeTJRvWgxwxD6ph8+7fbD9L/CgdxjAn8CTQInyestVwmiMv
MQi7BIIdo5w6XHpOJwkxkrg3grfF4MbJoqxmiJ7lCXbSw+TfHLW4D8+o7XhQzlpVUeXiJLuP+y2ciO4s
760BvW03TRzy3x3YfSM1My2evBy3veYKh+5lV7XY5A6zn/8sYIKuGbztGVqTXN2btW9husacSpXw6/pV
red8ke4iBLDBqT27FbWv4oQEv8yFwQrlQiGN4IjMTFEnh8zHIUMc4ePPKHWKiBQLsGqbQMcF76bCQVj0
Pf276oKfEuHydFLT/P1+n4QvKdeb/RUvZD+Z8862x8jnaRIOMMsjJxBew95O33GcZps7hgSPtKU2fsve
dtxu2WuPaWsrZn3uawvVQUWNAtSxM8SK9dvgZMGxaT9dtR4bLOpnF3u6qrkEiQW35kDUUf9dbVUZcey8
Aq/c05jWiXiwXNOY2ShU9h2nUZppGbyLV+NyvRG7U9qPp51Wth0WRjfoMLRqTmfbZzkThON/27qW8YWY
KPsUvyaEF8HkV+pCHMYmCw67gh0Leef2RX/haHEaEzlOY+x5IsYs9k8Ucx+qaP2hM5+nkLmZg/CaL1+G
smdauZKrlSfPydGexiGlcSZ3GgcLnDYgE1ZI1puooVWnVnaNeg4P3cjRqtQVxNgnRW06QCSkBndhticW
DvGLbtk42iiH8ijLMwNBm/HMhKg5ciJMskyNYtBJX1hezZKX8jM/ke2Gd3G/c0mua1KrRwf46sSDfH/q
wh+Z5gIC2MMwGo5YxiBGRclfzTMEyYEHM1oGhwU/iJcOmiOH8KBJzC289Mg3z/GEO8XvxbQXyOaj4gyi
mPwTUm+N014Xc+fx2gQ4urt52eUFnwrubV56dByLFNlB3IgkW+bEmYeTcQd+oxMQl7JNkDO/B9/Ml0ZX
LqlMGAm6wsr1tXal+XPmJf9Vbc8IyAJeOUQAAPeKlKCT61BdtDu0+dvviEGY6OjjhpTLnX9He6DuDrQK
xopwhCuQHitLX3/fk29tgaDhhwTm3tO9zPFcimj2ehxlPtrhySb19uE0qYMNmu5FzLkBse9gUSn4+3Ig
fTel2HR/6A6or4SMrQVcdkTcQ8ICaSE6xBGgLikctTlc2UflPBUUgOAokyrXwp8itNMvSeBeDKSFhrN9
mg2/u0pRLHKfYKoIsGo8eBH2SYlJ/RVYdGQlEogHu+MnZdAfNN73pzjKD3PlrSbKYcaVgTRcT6j1WBPw
oP5gCBML/Cv12ZGyMfjnBaxKPEJ4UXoQUQgscjrr4ClBuhhXPZZQUvo45gF28AahjhYZ56BEYcrLmU/b
VwEcBUx/afHFETF3JUVXXZmZ0QMOrrQIb9q5Mxy6hUuIYYAZaYMbcMftzePANix+EhnmnugnO8KIRwsl
SIbh8qYzecjlUBjcoUMge7w4D4QjpzHFm4ng3OFI3vRjtoC3Kq+auZpt5Ug+Z4gbj6gzufaLeHgMY3Ua
DoJEWyeTIEyaQ+boc5QcDKnTQLUfbJ3iEsCJrmMQ2K2pFUvRjMQV/2p7fPjzWx1L5aWI1PBMFSUwP61q
I1aPLxgCvZagqBEk6KwpwYEoeFFqHDBnOOyBLPOGhnEKPL5TlWkUm0Xut8dde3EbK/ABRdwcEZc5lAs8
jYcNlfzydHlguHspkFooJVAzVKYS8dfcaxyLyKRS2XJ5bC7bKeOKnR/prpUUzzliFpsqubsMEO8MVxm8
LcodZZ7ZmWYm91NDHFyp2dJJdHwS8UUZC+cxvQ3Bj7eZgVVc9C2ydRqIiMkqEJFwftlpkjicuDozomoQ
YESbMwswBYqqNm5IERNsAh8LWmEzAW3K0WLegehHgnIjqs3kpBWUikOHoWSH+wRWcOV7n6OrIeNjTY+r
pSKBqcP6Rbmqxlgfd4jERgdNb5ym80ktybSEbQxnbN/COiHhrv3RPu0F/mVfeOw8l+9vyQ2zqqK/sPMX
+v2nBP8s6sQbQT/zUzkuCHNvi3EVUZR0hLCzd7r6YZPJ290TWfibuOBVS6jIC3e8QGnITsRNwjN3RtYU
ClGyl4FDIfEY66Fno2pz1e8pjSEQOk9P4ivDTbOjywKYhVhCwCPhYVnpljMHYTea1jGeQ2uof+vfp2gJ
baAVMx/FaEdV6HL8OQqiNmGHgEq/WwgWsf4EUSs3WVX4KA0uRG2cjA8bLKMVT+AhxeFiPjAZJ6z5JMRE
1fS7x2J1CUFrB0lDUuTUZk+2+TkvyhJ1IImrifMYaWDAGXck8e4WLEsJhMmisiCaQ4Qidh6F58yCmTi2
J4MNOCwe5ix3fNSQchJcs1JJGm8Wac52ktE5lwIFSluUZuJDhAdwk01JNZ99jBWjPEHEg+7jdJWrnwQB
tE0CyjpPmwVCxkSAMxxFUoA5VTNmx4bFOtQQosmzw+GRPHVIPON5sGyjxIMMzwCJ1dnCbpZUOJA2OzZb
SYwDl2KvYBogkTU7PLiesYMTOc+AJqJ76tB4zuzQWlEUZ4Rb06CJnNmhiXiXAhhmiZ67ZU4YJyAA8aRf
g0UexarAII1Cayr8GIGpvjdpTmxknd7x2bs9GT8hhHH0VKHKGSvELXCD1ZKdKFFPoVqqLI8FoLv+FUIn
2EehKODxNGSyxnAQKbO1P4VMmjSPNaQlT2vtmSRVp5AaX67lisZ5kUl9nokYm5RVHWKePNs4z0y4DTJs
Njv77M5I4hWSrbYHKbO1NeUIsFFzrSmRYegWGXXIbfw5p4flJFAxEenPRuQZx47lCNHQ4OnPR2P288py
9qhoiPRno/GMg04j3xwFKe3Zzc92MprHHGtcS352+zMfqJbDUcVBpP8iElNOYk3h4OnvPnWFRF5jk0/k
nJOWd1VNtvR0WvMznOqucVCW7PclZa/uWhZhTumKKK1Ncclxc6ZSylGRLGlYSiRMzxJUxcjhG13PEXuv
pK0hNOlnIup+yVBi+Z0fozTjR1ZJ51JI1P2tEbijZO7RxaIS4qydrdG9z7M5pdfXjxTLRuCiY4UmN7Ix
EX71apv0guQRld2knvER9DGOpR/klg7kokKcNsRfVYymmAlxmehxVaWEpQKLNY+LY8ZuFYcyxWUMJ12N
jChKjFx6QdWQxpt6BBU90DCyo8PKlZSus/nLrUwLcO/xKXBshqd7iXs7xkVEpDNQ+18FA33EjLWCC+E8
gZ9WUcWNV2YFFZ1Gdt+fhCcrIvAcRTNUE4VERdT8FtrDJ8rAqKjy2PSlYpcWLTpPTyHoyoajLOgQkLgs
v9R2pbKiY2ZTgYidbzQi4hC9uAp7V30wslvDitksNULzs5Xy4pKU2GY1hP5Olg0paZpcVSNCRj4J48OD
CwgsD4NICjKApUlymDTtBSG2AL1hikeZfGca2ArXm5o9Gok9D5EP5HtiuXkwbQWnoez9OB1HYilAjpHD
GCLJ4ufSOLKlQyP7B7eFoWbN52rGfXVHikX8YgBiAAv9C8NAY6CZOcJk0mkmMFGWMc7gUKXTlWBrnX9o
maJbxGbvoH5drplr5dTvKevEnCdUYuapEmVnmy25/C9NmHVqXDIh92LkXN0aMySBl2kYWQy8xIOUz1W/
X5ZWG5nfq8TDIHqCH1jXzbT68zjIA9gJqBtl/gUqKu8MNYHcAdIwpBDGGcMRgQNZgyx+YIgNaoPhVpyA
rTJDUI65nXrh/A0QfTf2IBQtqcCsm0mNESnhecWVovPYiQsjL3QN2G4Ipoe0pJfCh4kdjEKRq/w5YIC8
GpfLDTmlWnz5Mq5UHBohH4GP33k1oi8HLEJvZEH430ZjhL5WEBpNrftjMrS/NaUkALexsI7h9sPtmhnr
eDGivD4lIL7bddF/ZToAPHa91ujLl318rvhJQC3sEUngrCSEiVSKXxDrWYfaVf9KDxGKL1/OGWjolRU6
1J+BDnXj9kghPxJpyaMewvgK1y5xcxwzg6SH6RZ8B528w1tU5EV55cv+KDHOUVEBsnnZONpS+6OE3mGg
FZMLkcxD5wgO5iq+JaTNYNVvwnTk9xE53CI9pbw3cQeCey8xBnG0pnRCuaadjlZda/sq7ATT0FrDw6Jg
BSMlcyttWV+gD7Amk7DmeIc0Fa7NCh3V83HgRBIbPGlKFgCex6/9QfjwceU5dmGMH2IXlQzJO0lxNRG1
G4m3E3XBMuveKkwR5xeRbGytsUujVNfnacJNkUdlU4aMS7KkIb4FwcCfYCoNl64FzhuvZn4fMmIcgagD
mE4I0LryJXcmmaXC15IutHAQ4o7YolGZCvhLDmDy9lZAXp+08OxjrGoLnp5KvXl0aiA2vDXCTpZCCAB1
X0hZiQKBUkDie1y4CcHOE+ziClzYKrC5LUIDhduw3y9cBoVOmIIBRAcCVWZXQQHiJBRuEEnHInQRUcQC
EXF1lApega3DAmqSwsHUrTBAA+KDBbFOXqz2N06eMFEycoB1nGUZ5igGmLKHU4RcEPYDQpLsoQ2LhCEg
SHSYzwGWyNDexq/nWEA0+Y0Yfv1AuuBkvEmd2dT2zIuBf4d3jGaaKj2E8XA81bmSXjGMcMV3dQdOVrDL
GGOrFtEhyCenK5zGTqCe5PaS82EHFP+2LMK8MKFkLq8lbqpNmBRCxzL+zgV/stUHd35hxwskPiAifICP
J6NC3iqC678gwP0t5mNHTStIlFBb1wRBJ1jkFKPEenIh7Ykj7Z2ha5KuCGRqpelETQIrLwbg5/hC46Ns
sGVaEcyZaWlkBvlpbvM78Tij2ZysLCLKCseCp8Lh0ZmVfEwlijnMBJpAw15qG5YgEHTANQEzaJTxAlC7
UPA46AV3Q7b52B7jcEpGLMxcojMBfA7ZYSJlZo4bezCLRXzJA1umURNN5yAvvUodm72J11rlOryNmedP
5cSihzcy7LkVEv/C+XR0SUylSnt+djWPKBGaoprjkq8wKiVuSvUW70AUqP6f8++33zsXVKyNEabJCshc
VZL+gmcwjNVWVMxdGWsiqrIGyiYkEvmZkWR40zD/wk/TYHAJ/h57m2h2H2+v4j52UwEPxMAi9CSIgOze
BJAQBUGnHzTiscPikI7GuZr3aRymVDSVGCfjpnEKGFHSAkVcFE6DwkuaUKR7vnyOKMhEsdRgi+Q8R4eP
L60nqEcxgqc4MpDC3ssGCYEOVNzCT5uGEQnHZdRW0crVSQvTeeVS3ODypnIrk/DiOz7owEDMoJYXD7Tz
SIYEez0e3utwda5HtF5ylPDjguAhKFh0CMSAoCRjKPjrDRxwlVaDHJlhNudNrzbK9FqHSEwI7KKwFgSZ
6v0eQapuBGPNSH4IcIh7S4/44xDnXRhpL1TpE4cw+hQmGRJF+TBj+YrmYU8fAY2Fz9SINDL/9+R79PQ9
efoeVfnJmP8eGZNS9iI74XGIWdLKAmIrIwhea4kQz4ZOdYICJdCs8Ue1IX+m3Ax5xPzUSyAKfKocMab6
vqRfMtOu04cjboSAOOPxLFIBexaBMDbi4RvXY2oHyUM9celDkLA+BVSOV5CyQQtO7njDfP6bLSuUtxZc
+fBMJUk3IyxIwSXoXMZHjXghQWM7IO/gS0RMRMQwKIXkSKXzwW+h3QimIwUedM7ziOpHvy0xzKWpyuSF
aeJdh2VMoCBWyfOK/5HCicsUw788IYcsObCn8HfxBF7Esy0NFkBaf8095lcUGkJSQDLWJBYH5rtJPDgk
Z1Xohk4zlnkXHnTdtSOBBRw0Ct8jJIHhH2j/UVP9EVkAmCqTyWlinTkB/W40T9gGtGdPnl5UKVbg6IIw
KLykoxVsMg8PgMNOJOC7rAb/UfbZ/jBevUNjXY/X6HvmUjI74IKLjPZVIPw79d0REOkrj+/OkK43abbR
ClHfk8CIet7CqrYoUmP6icRGetctS2UhsLYtGdEq5SZ6KlgdqArMNcssqGUWLxzKksJYMb1eyUErnDru
wGH8Ybg7RIMO+wnSqTsqNILzaT9sB6UanzcwH9U3ER/gR9DbUXciLinfqI3djjNug4G/P8piMTsR6YGk
SuOviA0mSTLHl8qVZG6IkIGPwb2nv503IYjCtIy4Iuab0XZHTLaYXEq5ybbUzeVblCiEOFOLTph7w2yJ
YsiQJ0qrk2EgK+QtV9ypKCexlL0cALnX8TIYCYuNxO9tBHqgfB2HDiulYmCpnNu+AKE8yJAl7cnDoBTV
RiIHTP5gqMAkjCaq3SxoWZRsKm5T9Hg5CNrA2rB8PwIvB7NjKcrnYGkDOB1LCawNS1mfMRueco0cTO1A
VVztKhWBYYs8KeyQrTTZikYtq9CSPDD5ZjwaMHlLXMW3O9FNmIaIcUunGPYoZRWU8sDko6QBk2lEmEIE
CHLQvB+FnWl4WSooyE0EmI+hDaw2cofomAP9RS+Mpg+dVNgYOyugyYMng5PQkpLJRfdkxIziCmoTgOUj
Z4KU0DumQujEfckkVXUrmlVzKQUHILVsSCkTUbjUS6u4TACWi5QJUsIOtC3Pw/DWVkPFcgrQXEztoLW1
L0LNW7anfJKqZbWjNA9Q/lmqgZNN+PxOMCtWXbWsilUuoHzrQw2cw+06QdyxYWKIlFgg9Yh3alPEgF/k
StWUE+AXdSmsODLI05Hni+2TVAJEyFIU4aGsLDCk/AS/Zg8UoT6jWnrJlSW4X6OaAl1rhwun56nwpEKE
Vi4KS/p5etvkNKv/53sqab6xuYzUXMzMe8bjEF/4heqjNSlYi11UlyeWO3O2cOSWCbbOnOQQ2iqu503l
rPjBqvlN9MjC++PYSZ7OfwNByVv6v4ThZmTqsp+HHzZFb9rUyaEcWEi5DPUCadmC+b1kRxMIO5pSoPqF
DYRfWPt4BJM7zh0ez9Jl5qfm94ZcHxn7XT/VI+D9T+DIjjd5aU7HdXfJmrltvmrPMLe1GruC8Q4ZdEzR
MBlTLxg1qZ4oVQjhTNywma0wndJqCUhs+8pPWuBzuyx+V+qYyGK9T0AMACp1l/4q1+G9iFwVFZcrL5iV
F1hlx1gcxPNqCJfJTOnAXSZPuxSRVvEvkJfStFPLNUdTOSWsPcncSPX6bLyIMjVsYvEIF9b/9/Zd8sL9
nL4Tb/W/eQ3PidWKOJpl5uKFdKF2HN+mmP6RlvFnRA3fImz45hb/U3QkE271CnxFuQJ/pI4ubbzEnMIc
JM6fQmnMnNxY7QViZmyAvUhTDSncm4KH6ADU4lj7ehqfYPMcKjTFxJOwfLOvL4SzNDiJuwAOrpSJbnxU
8f/3yO17qepTv1goul3p8q3roWLMRvxcHU/gsgrFly+7jmYkUXG7lYq+ys2VlIFpNRqescwsU/LdFxa+
PLZBzlKzzIcyANLUBHRqAjE1cjNUsTx5Sc9rXhSUPBpWgjYmzHj4qcmiwc3cF1c1TkLb/PwC3z/CMsK9
aYYrHulQM0SHeUScDWficgOr16HlkvVWUHN6j3aJ8r1aqTe0Iu/0IvVGbcw8x5KDBDwjo/+Tr0rt6FKW
Xka3KZuOoYOGW4ix35SJSfntFSdoCVybVmhLcH0q68XlkHczzDGRY3LOdbJjs9lWoCT7mLH3AlclmFZL
XjMGXv5xY2FB7H2jTEY09aCy90KJyJepvYgUOZlEnWvZr5Wr598rF6vntcrbi3JptfF9nvx0Vqu9JiGh
sPvvvBpdX3Z+iT0gkWqsZMypWETuuhN6RYkfq6x4Gbxewb/L4XntghkKePxC+hE/82iE+OIMFmSDlnfR
ImxY6o6ZsUc6ZjQNO3VjbKiIwJdvgiiZADK7evI4alIB5jmc2YC6YKgGl1JuOIErSOiLpXTf3y8N/SQN
tvqxD+Z54Oc83QKTUUw+2B7VphPaIaI3E7RT+jKGPweaLzrvvNoqtWko2/LL9Qb26IgOPb0YFedjdPxJ
6NFcp+n/7WHbuWF8W6rX3BE6QbERQAB+3qKVeDVQC+CcChoap2HPQeds2Qtcv6rBpdfJPlr4W+Fd0CmN
xKOgzGUGGxkBk8Nq9SEmgSGOoOrcGJD1vu5G5S7ruzoU6BwZK4Lnc8+SJiWNHvZxT8hwub5i7ClqC72a
cbmAUKWay+og2t7Qcit1N0eYodk8jgA9f3NKY8LHemyX1SfLpmYs2FxyT/PNU1Y+vXHcAyUqCbkS18w8
gNDwg6uZCTQIoQf7izFnrFIvWaXFG/jBCmb/mA2Qm6lbFS3NubrDHsl4qYureCTAhHH/D7LZWCw2HrrQ
tLQTUX3rxOm/WulsOKlKRa+j2sXRq3Pb5TUrrF6dS/EspzVbM+rM0D/xvtaydcSJBFK3tjwInXyuQdsj
ewKaxQdJCC5bO+xgzRMlUsmsjT5BEl3QBItstdYg3gkD+tQy8WqOS6Zi7R7xQugrxBZAavOptAzBZNi0
m5OSOkHmgyNaCSfHndBrb65GrYdriGzX3C7XpEpxamrN/kpXDk3Tb8bn/QuG+QgwzxsiKEgoMpjlkBEZ
emRMKBNQLiPwzqP/8qUM1Qd2lFiqTIJMPPJ2COQ5b+gQ17BYFcTT3w3LdZox9Dq47XEfyT2j3Mm7coeW
GUM9h5fnBO32itd34vO2Og7tcrmZPT2VRjC56HwajW1zSqcsRcwITLqYPz977vzVx4b1PRkghWlhwoNX
YrvApsgDzqTvD9OAHkCPePQaOuE/Jnc1RD0byDIxjGxecdCWcjUmp3jYNGdIuV9NaWzebMIjTlE8l913
bMAtz/U06GAuzIsTgmeFZNMcqy86JRzlCygYzU/kbhwNyiy3rloVGdqu/1xgag3pSS/6ounWRfPOy+kB
6MCCFc+OkQofjL7vZ2jE6LxcUWtS75tRVNoZInk9HkW5dubKdTw2q1iLsyweHAvnv2aR03iI88t1+cRa
uz/0e7ofF0kxxeBMcrUNr1X+xixntx8jeoyWVwCXSlVUCtGpbfxBWVjD/boLfONcTb91xMgJLkxfyILf
RSQtdCGAdwMDkvwSM1BGWV0fadwJuDZUK5UmuynkLrib7DeCXHPDv5UOu4jSg6gGboYnulF3I9Phdyru
lgEvmKR8boRMosKOiGp5jA+tpHA+vTiLZ22qrleaoSFeh4zHbE2Zdaa2pFY5jRXSY5JUUUpycUQTNYMz
4C0RK5wDgQgbtAzjJrFf/WlSg037nnnYcFXaWdIxVhbHVEU+3aoLDjNxtVSkRs7KxV1FzQQIY+2Jq98P
e/QVNZIu0ZKV3q4op9pUn1OyiiEPCFFFTzNW1VXXh7Oet8ZQz4Q0nRRle7VUCzgrgfPq5vUHrZvvmm5s
E0UnXIrmyKyyVsDmqstGI09j2V+X7ZpzkkXJ5GvRH6PB8DRmXo7yDx2bwpE5+FFF6ll8/MCbyacnm18d
JURBjBjtuTqSLx7HSMBgMCtME9N3295j0Sk2iqWii/4j/16gfyG68zn99xH9+4j+HeN/x81ODPe9TOEy
gJ6XqueP45Lz/fz7xUW15zggwTS7K6pS5uXLuVGzC7IM4Nk+p7nn3YsLB5yJhdEoaPY9JaNcnC+WU+I7
h2mIigm4jAFPAn3yA40RVs35IJegsxL+Bd84NDaIAEejgpRoQI9z+i/qIFRB8oMUtcOhmRf03zEphGQX
DJ7KJbFX5J5hRhBTYUyenuCXD9M8/jCsKYIUd/blYalU9gkk8srlRqg5BxKZGEUORSCKEKBIOs0REpRC
L3VTw39SF5wbETkrhRkjqyqWV9WV24FECArJe+88XhkaVOpzgWlmMKArKEi0YTkehnL9C5W78Kr4Fyo5
bse7IkseS61PT+SaxCNxYF++xIcKXPrx44Nvv5UFZ0rHOmzO2ZDAOJM1nj495a8CPDPysN4wtXDzV0eo
svDs8aks4Hm5Yp6Y9ICvxJwMqAja96Ck4S63VGdXVi9g7X6civV+BXIeyKLPnsM6aGvYcr+ZaWtpG+fG
vmVuyGa5gW0CTqXI7pB8faH1P564l1ElvrjcDvPKM31V0XqgB3fG6BcMD3G3glanC/FXglWUmFkeR5Fl
d+U0cKUw3fw58vv5NkKrVg2w3eoRHZQk2iq//dfLESsuvZTMNluYy6lnu6q8HkUQr5K8cAoq/HUT2rci
OGAOR2IJ90qNReyBYM2LBmgQWpriYtcQraEif8CqsM5YGhHaW+Y0dRb2RWVcWE1ZVFBCoAhDGclNAzwd
1bMlDX3OtRqJAQULSrIbkxlJK1eUOeMZZ9oqyFaCp6cK3JhoHVblqVm6/H9Lj1GHLf1VTUyDKfZ1j5MN
nujBN7ELWM0deIANpX1BpeLkIk7sV+1PSrWuaNa8v9uXACLI/cGeUEPhmboyi3GtNEa6Ge0M0Ccbxqqw
sQnsTJCp7+aZIHM/zzNDnn1EJC/RM0GfxRhcQDfMvmeAPsWUWwUuG23nGjljCUWn68wHEHUQA8FuMyXu
DMvp8hAi/AYi8WqMCEUs9kuW3B+zwP5u4OALLcQi4eDuWDenE0fL1afdjRovJfR5zMsCYVXcxGkkam8V
hcEvdLjFQqQqfQYqwex5md+JxK5u9eqyG6YZ7EjpyaqYXYEKlL2KaKbvEAaVSuqY432eXuAhT5C0aNer
mIMd5vMSbCylNqb6lFBvvANxSKljm/AlQtS2eG2sEi2Z7kyBlAywexKnIdniUP0+CeVNAwHnvtakDfdE
yGDuIDXUXG1gnhCs3UnsVSNI3tMTkqcitPSiNuQQV0qr2TzxluQFDalKfPkDjXYRXr0PwrsQHQNuoHjm
sum8mhwW2zMW7xV8kEPG2XEnTzHpIQXiBlie1gFgmkSvHYXvzFBVTbqTG2ZrR9pLj9RnVDC25WLft7gF
DWdcldpnUSvEdBr9IcbHEOISCWVk5bLdmBKLJvUO5ybw+/TyHKyqUjTMl4zzWqUd98J5YhcGCzFkRkE5
Yk4oL6F93W6CkmyM92N6HQ6p+AiOtXi7jbn62JXYaCh9SAMB50IL3AnwamMBTeqzDVi+6lSRdYzoJ1aD
8jwy0rRcbkkXOrNReqoxJw9e8BUOEI25+tQ4rlyyGUWdeKruuGxYM4HLGRq+H3F4ACRPiVyxHlo5N1B8
fv4AUgDkTyLVCRCdi003VhwILWB4HaXp1EuVgrXmqZNDkJ7Lj7KY4E1CjfCgvTp7rsbQpBYmLsRYpScw
6WMLS0zszZKS6LGbjPl2EqDVskljwRc74U3RUf0myvWaQA/u+8F8O02xlVSRXec3/MsUEUweR4mHn6C2
YGs4CnUp1HOxIcU6kgQ6CsmLp4RCTyCOLX5qoMxLHLF418c4Sa2D3z9GorTAApSG8Qj7RFnvgz3KMWoT
rm8cZgqjNIH97FpaQJMDPjZRO5Hs5Bt8dRESvhbf4atZ9iGXctjlnMDQTb2AOQvehcvv+RfD8C7oI4kK
dT1QLsTB7DSLh5V4Pu520Wpq4k/sgXFUBkP34UptFYatgTNWYnpjjrVn8ZAUKcfSbfK7W0Rp41s0gWiI
SBIAqDeIQ1A3YXfNJbYqEARvVC4O74ouS4L3vdjCvZupGaR1T26QF1BiVsO7FTAFoIGlObs4837h2wU/
zw0K0+rLhqnTQkilOqNuraasl9FMVdRVHHOzoBcJBMAn5MvwxyJbzbZFkaenIo62nWlLWV5ZxDCMu2fH
59sgjrOrNTQ/13COVFP8TR8T4VBMoLih2d4cQ4+4Inj5Erwe34bgqTHEFkRput73U/DxHRBqQ/269sNB
hSCSFt0qfIom0HTPg9fr0iVicuIsxhEx3N48iZ7N2Fgp0y0GLEwTP6vxGDTQd9YwrhFz42rl+XSl/nEe
wZE5cHhjF8zLQ7+PgyI1iJ/nsWvxMKNhMIOTSA028DVWjys5fTMjm1lBshnLg6IvOBMI4t+k1fYcOFjh
nzbOyfoswuTDP3ihoR94+VxoIwxFx67mDa/xyEDNYXUuC1F+YfbX8EvReDTKWD1CWMr5OSQkZwwmEB24
sUbTS02r/KSF8afK60aR7dmiezO9iMVxkJztK95x5JxUcVKj50iOTuSsoe7/JCdTTtb8R+gtTciCzpCH
G0YW6a2c2jFd2ihY0PBWetqWPwjRfpBSmbt1JY16UlfQoPZCKVykKWDhvQXqUnZlYplB0DETCnYm1ii+
GCA5KNgm4dZRl5ijL2sOW6l6Hg7WcRqixMzIy+K4n4VDNOb9+DbdgzyzPnBpYugbxZRF3IuZ8zUpLSIu
9eAOR0qFGBQxOC1W09iLTik1I+9FpRTYj9JnFxvZAq0RaQOlNdBazJMd5l2iD0Q06KFRAgJSBTFmQOSH
onuOxv7nKEyABAV3wzgBBynFAQ7wX5Qi+lPFSHEEFgRZErazIn3MZQoKIM0746ZhRQgvuEY5wTHQNgHD
Z8rEIxadpdUvkNiHKR6VIq789AwLYkyZ2AmT7B4bcAYJiDyUCYBunmRIMp4fQuAL4HjbPuggeEAFUQC/
tnQ4l0HTvfML12hhpWZr19v39x2zcLlslT/VB2M6pm4kxzzC3vmZbhLcakJpcqSlWJ2kY632Rh0cBNsq
e2oISbBmQAhKWxDKGV51eGSE0LKx+JGO9MmYMj9ejQKk6yRXJSjwo68GpYrHwYSKYnS0igM/uV7vB75p
OmZFMEyNwnI7Sh0P1WL8YCLzg9m8pA7wEst2x4JStYdJ75T97pIK4WUVUQjpK4YQvfyr74MfZf6J9W/Y
Rzk0MBPJQJjNz/N2wI5MpEBbYEMmUnB7IO+KJLVNZx4LEJvkE0mDBvNBuW7wDWuR+V25zHwbOPV9fxB4
mEfHw1eAX2QIKzihCJG+h0N0bGH5vSRD4LoP3eUVU0aoqbQ4gY6PSY/GqXrhCz/yYvkTpllyMe/lpBsB
gl+0g34fIKm0OZwPB0M6IFibEks90AO7al5QNc3OBMGxmIe+qiryAhKAVihB8ivSfeR3OoSx2AjacaJ5
7sfqTirMoxMgjfsIPP2BQwypX6DGGiYBvPjrFPDCFeGj9UaKZoRpvYhsIkHG5t/H1N6Ojqy9lIyvGuPA
XAHa6uTXVZlXa2YrzLKymbEXYmhqz7ML7GIMXzV4BpTz5KIZitsKLYu6r0erl2jLwCcYdlYfe/Eq2nxp
2x8G26d7u6XYaUTzV9mgj4R/kMChFDeQih1qd0jT8eEUO03mEBvIanPkecUgSZAsvRrKBAHTAZLRgDIw
EXAnBNB4sTmlnAUAq4VBhFE3RvXnpGJYq6RXwuWEKsSkAlZDBnkM1SvLZl4YN/kFLHb7xszesZ4khBiH
Dr56IbHbPBa7DXSiRYjEoqWTmG6OiQ64n8L+HkJ4L41j2EpPa8HMsJUk/n0phOd1OLjwVdjNUPm6Y9JH
Cg2Icp9aLcvZbsqHbpQXoU3eH/j1MOb8j/Eo8AAv5GkzSiwHlGQfYJUjee3LHl2DYSd1iAEXQ0DtsVoj
gmMsZW/pcXw7Ht2Ox2pRjweIW9QVn67v4fC0PH6J24WEDt/CqduHBE1qcdvoULkCjDDOx1TeYtdwXOk6
JOrNDtoh7o0X4U3dhKAI72K0Km/Iy3zq2dvWwRvQCuZ1EV/Z3bwLEZnD5i/SocRYqQ6a66EnZxAOVDmh
yboiB++Qn7rEQnqs1D4vlzsX7hDRlKH3SAs2SJx1hPU+iE34SwwwvWEeTmMZhvMMgn6fcErTS0VcjCEt
cwuistYztZDKT9AedS68IaFWA8KgULYEcgvFJliMopkalD345bhd/t3F3yZlZfm2HEGF5K5IlG6A6loy
vAFBsUeWCNoudGfcOH8Huta72ZvzBAxZQ64AV1TnPRJ3l2zde2+EcG3e8/tykkDaFlsJNY7DIdw7j0Np
S8HikD7NCU+HfjRhKkVVR5kXSK/c4gxMwIvle0CxiPcFovg3nof21M0K31KraBIIrcfGyZ1igyfgmMWu
3JY5CbY8MQ/mqCs15MGd83o6QG3siVG5XEKZKXV/SuOj9ICGLQf0Lr22d7V6xewLkBR54zRuyv3mJawM
tlfwSYUbUlK8S8e9QYK2spEUhAOg3HLXeZwcoZqCg0sJFdr2FIqOkAFMbxmeuBJCtA1WKe35LGZxECgl
Q8scnPOhs5Ay9e4m3WFDxCfiGJd0V5Pw9YckteQ0b8veJrkz2pxPAGf3Fp25uowAHAN+o3HL9SCyBHHr
WobjFmfho6wdhH2jlkMuocgdgBx06r0oU3RvuUm1NHwiIoumqORBd/kZ4xWLioAkF7ZpzmmtOcQWPbKB
bxgyc7E4dunysWaOVUfE1kZ1myG13Ni1ns+8g1N8JQerCUgI4ipImh+XEwy4tQ+YE+YGux97TqUcLKmL
Krb6PNWQakbfzDpUNiTqGrZ632QrUbrzJpAfYak3ai5e6o3amDrjTOYpUKLsLOUBUSzdeO8ex2p3yVUs
dkC0E4F7ApoOhpNOuf70VNPKY2wsFbAZp2OUlz2X93R5WdasTdn8zGMG62jO3XwTRy29W8kInYjwP3Q8
iwMSHU+icgZHieq+i0gfKxn5l9WWWM0i1ziNVI0TIQfeKFfZRFCYSdmU0Ci9suLpGTokUt2Zx2ZIih6J
aJYsJIUxduHv6IJID2fQBVnU4HyVCsJh7JxALxuMZ9bJyGVpqESzLF0lvGyOVITN1XGBNja1aCo2OFKG
F1CBUtIERCTKsmiNOeyU086jCww0oTH0H1lEQOqPTlFbgPUke485ZtHbcD00VeFQdhB5jAPRUmGNeY3j
xvz8UWeIffuQJ81SAEHZyDDhVgOKFzVwIAEhtWX7yYCb5bCJK6smlQZb0BTQUYdDN3YhOh1hsBKsjEAs
YxcRaxwChTyY6iQ+ft8jYuviqgks14cHYEh4TSkKsKh7whPttUP1ycoqhwZ8lwQHDls7BF6Eg5lS7gQN
VT+wFywTHpjwzTA4yhYlFjqne7uIX/uBJGIQuyQXH2iGPJvLzFJQyfhCIQPi/J1JTDIzh1P6qXsmCF3u
N09yAwtxyYLbQlKKXS2Aa2wY89G5IMuUuYN1qKGPdWQCd+RG6piEbp3I3dwBr4RCDVqVvea6U2AjcDUE
Dm9jpV/lejMWPn6bcbnsjCQ3n7E74m4+2W8W7XmmXs+AGPRTmhlteRmOI9xQ3bJ0U6KRkl2HcNUL3dHy
VCbguDctq/P4d6Lv4hDevBfhJMD6xOIKOkwK+PTw/ioiTKTp+quAuXFILxIBpVFEU4RY7yZKoWwQ/Mzi
IcoZsRzMJxVdn36HbvGvdytV1M67omP2gK2DhHk+lJeAiX8u3pOxxRIFSuiyBDvOqRXn2BN4VqQxr9Qd
xbMLftC9wl2u509WuQ7T9YtdmTrw1k6M89esZTEKaqEtPyVuRbkUwiPPirrmHGPSQBU4Ydl2tYNo2hL+
zSUwUpeAr40eWyEp3ib2EVTPtKmb2d5tdWybUu6cII/gdaCcv2Uq6S8vI9L7VOl9rSkWVzih//q5/GdG
4L/WESYtpKq0QPuS5koLmKuY9WJavYpWr6m1i2kkMyR+D/EIf+qymlxN24SMiZfVAg+g0zNeYvv/kuAC
gz3zFTa9ZdqM++uIVniWNOmOWZV0Ev1SmZn+bh5s/bO+3Tr2it9HtdrlqyJL3sXJ/+xukRy/reesH/O8
JS3P02GQ7NPWGm9rof52gdY6OWytb8pIvC66VslM6/9kf+NgCoOvQ7DSaJ0R15JDAhmt6ig2zN5xkZ2l
znmB8oqJ9zdw52rj54iPNn0gyyzWCsVygJV/0ts6TkFytUFgL7gXwGYBVQbrMJivUc0reEXgANeV4+ZX
gN4SRW2Na+JAu89LW3ovweIKMBm+MDJYlxuS3jUwUJpJtFYcySTSRmCbZwiGjCif2UZxD2UQnngrTqQ8
0+5JRtNSQbgx1FrJHVet3Gk4CNiOVoY8D+uZFA8uM9Jjmi0pQDCDo4aPnKsr2tOc+JTKc1a1mBesztUb
JVtW4ObhIvngs9jJyirdaREqVYsts6yMni1/JhxfZCxZ2AExu3YaYMSzg5keI4EHKCEiJ7U/5eocs/2a
pODx6s1oJUByYYRkQcsUrGaM+YBLNMZ9EHMGWqagfP2DWvrrXbGskG+Ibq0HOAEX8OXiShXgIuajQRuy
lXREQBXLDLANF4q048Crfk+/nzwVvmdP37PC0/f0RZVyA0WCLpSt9EbkiQfcaMToj4jbogwCWiRlbsRB
E3EtreuoK/ASIDYy0JgUqX2K1j/tOHPlKXSYfDBpGOUK4McR652sTemlAfyoqS+Pc1TswlOnu1hOymG5
CNM6ElNmrOzz4n+sVWNS1RdVVUsO0wk4MHIlSTfJtIBzHlcIKkpNrgeak4w+uKcWbJBO43w4rqnyTDzu
/h9eqPL6stVIJKki3VTV8beB+4LbTHjXVuN7ayTh0hytJM0RM6TyjT3MzS+ISzQf37v47I0fuAPCAZAS
z5ec2xNziRFKo4LPOC6Xx6TpxDUbUew8RiBf+qu+xcqD24yM3nWx3ypfshmZBtb18wGTK/93IXXaTdyQ
p+cIa6xB7jNH5OfMipwoVjHgNpJPqUUUYsch6X0Sj4bgz3rked1VvzFXd9y+fm8sxKi/dbyFTcOI3pv2
JV1kW+gi0byNFSen+oJVboioml1dZvgWDW6o6RpakZaZfABRxXlAL4hY6WxaaemNNl2V5HE9qya3x9an
GcUFZhF7GcdGy1J1aVcgGtNM3iE5slJxIsVQIFJu9XDzFP93Yu/M3Lgw06q7mbgFyGsaCoiWBbry0D3K
D4PF0kq3kHCHxZxA6qebKV2WO7ca6c+Cla43IkUqC7HJCu/OO9GZGfDJpFGQ7kKMFsZuLhSDsErDzyhY
fIuW/YZqBcU+OTaY7rHbkbz9n8J2jFfjSWQlfTdCZCX1YomsTAMLJs15gEn4m3eRRFb8PBm7ayUuXTd1
58AezhutxpiQ+BIp6HJSIG5kNRrk+IbAjnL/6UF20U2U6fIB+q+QqZSQKWxjWSAGeL5yHa82o2zHFNEw
5ukm/8LQPBvhOlA1pUzEGQzGpewwzJu5MN+akC+IENsmhrpt4kSwU80Uw3cJXRDWGQOrTFOtps4c169x
5dqMM4U6jWbqr3dFx9iX+F4MrbXQA6NnvNam4cfU7aFuIzXp5gzURNjRJbW6RhIRcW0Lv/rsl0o3SHnT
d7egU2jIq4ilfvm08lQqlJ2n0vn3u1qt8v2u3v1+9wZ++DX0X+f7qP7qTQ39fVPb/D5aqEEZ+KcLfxfe
4L9v8d8t+LuM/i6iQt9HW5tbWxfO0zmqWseV6nXIrNdbi/ij9Rr+brXwxxZUXlx4W8H/tNDfzTe4oc23
b/HfNfyxtYj+bhEUtjaW4e8W+dhaI+1W4J/FTfi7VMcfb1/hv2/xB7SzWK8tw0d9YQP+LuJi9TdQp/4W
A6ivteDvOvnYXIS/uJ3FhToUW1ggH0uv4e8y+diCnEWMwdLGGmpnaRN/tJberMPft+RjHaHTevsKf7x9
DTnruNjG69Yi/F0jH1AM/V3DH9C5rbe42FYLurC1Wccfm/W38HeRfCwv4L9L+OPVK/z3DfkAAFs16OnW
1iuYnK1NXAdlXVR7yjMdrNyO3RFmXCPGpYS6NDm7GIllKRAbNCkmlKUlHpJLiBYNzGzBXffLIjOJefm/
Ft80iyx9RUp/VRPp/yky7jw0bzqZkJ2VY2GxVPb8CtrJigzkX4wpPLK0KNCuZ44FNhT9cV2YOgzFBiuL
eFQTkDwkDSTECvTqri6Ndcvi1oBe/JRDJkWp90l/L5QJESv3JcmNHSLPnUqW5vfDDsCUkZZmr2TBmvb9
+XgHkn5hjCSXhHsjg5XaFG8sOLE8J89HLtikFYndb6Q6Ca9+n0fLnwj5RRw/tdiMuKkHOqKK6DhDqTrC
keKy/G9ZgFW7AB1o/lUoSpdYyjTCZRz623eL7/BFnegl5g1oJV9aqQmLjii775C0KHlcIvX2UrKoWDj0
ZAXi2CXvvGg1a2TnNRKSdrWUVLzkf8saB9Ybmw5EV0G4SVVRVmDHY6NLVBEkYdbMf4rgdG42oP8BoAYc
9QQE4+Fh0MmJYUHOwRriTWroIIwgJOVIEvh99NvHJn343ZTPxP2ulyGygJZJl7rgBtke+4TOV2mFXp/F
6et79ilDePURW4yXcV+yh6rwqkCJwjL7WomdkWcc99gwo+v2gb3gFckzHuqomgN4502EQIcVVJ9oeCrg
Xa7vyamQhvie2E0g6qHC3LhWLszkvxSdkLh/Z8wW4nJhRvDkpBdPT8Twd36v9eWfT63ds80m68oc9sgt
9didNDQi4CPNPsFXY8YqYc/kauDxB1YHGLeRKc+bacz35s4vjGEoPdZWkSP3ybKbyXozFesPDYYDeKQS
Hu4kSKYQadkDc8nLlwkZPrsMT5hcorJNHFnElQrghuGxeUKejBUUj4pCtU2LIYlXWjK/sVL+totvq3Vb
eDPKzIO/AbrAiBEi5Tnki3y14smwH2YbfuYD5tjDO6mymkNqYKZd8GnYsC8yvBLGFsU0TAL2C8bDM+ec
GJOO5yDu/wXaXM+M6ssfw7G7T3Lzq158SseP40bG1pZt+dTp1/YO+yqE8hlE6S31t5yWg/PwQjlGIcJw
WvaMdBCX8Hx5XqA+nASymM6xEMOxXFUQq6ySOk0WNfFdVMlwnItYIXIoFbx7kf4+wvnfwLCwLycStzge
Y7VJORZYeXUWAmMlevky5A9tTXR4++X0XbQ6uR0NsRQCfNEaUBZoo6ciMTa9vyK6hcR9cFcrNp/kA3b+
1u9fK/HLgeV3fecxIN7UVBwJK0QRDBA+JR/rfdStDeEXWAyXsJQieDF+n8KteYxVSWL2swXPY9Ryd7fK
5p4WFamHI/OzR0OlCU4UsV/mHXDmcMNCIljvZJlAPwj8dJQE+yJMgJw0j0Vw8ghKVmUaBR1X9vwm53B7
HV+118G+Df1cax3i7epZjiR+zSfEJNv93/LjQHowixEM2vzeKCJj0MFnbTFG0kiY3ReZZbtqMBMyl1T8
Xlv2EkdvlS8hga0Erx4s0jWquJzjAKh7OH7vS77JvoP3RDS4lzvtddFV2EG8Afc2p1r4rNNG5DTckxAd
Rfe5Rj724rlXG6QR6faYMxtRpdJ0svPogmo2bwSwYLWIBFiCfVF9/X5A5uIPtEdnlTZWK47t9kD/5ksN
PvHKo7E5T1tF7LGftK4C7kAHVJmYiIjoawwyX2828MqKZC2oy3RaI6rDRGsr6gKHB4zcHbxaOXAT1Wui
sZhJhcolrVGUvA7J67k0V7Ov81KwallIDft6dgxHKvZR4LvRNLqw0yt2MgY6rWI0VqFnMpniF9GkP/Sg
Rtyb4mvExIZdQLB6lD+pK8YhHCi8vBc45pw4uFXmOQnC3BqNmpTx12iVOuqSOdH0JpFINf0p5TNalRPz
nJAqK65pOf5D+rXTcVycDeDiEVU+ZOQDMq27Z4YO6bsEzRTsCKG5EkTk6WnO3PQskQ+k8u5LRwjtWNYB
xQ508lQbOCqWdPQSSZ9ZPjaevVHUTYhJOv/qb7NTSgNNbSIAHp8kFSBQEj7/KkQpA0L0UC/FevBGEFL4
yBPRkg0we22mvogFC+zauAn++zWzLWt4T+Uaf2rUzoBHqecPBFgIsAmaRcQRkShslRIN/6VZ0JBWGjXH
+dsuQjflPia4j+EEzywSENUkjYdn52NBnzq6RIGCw3RkMv+G7ScwvcOB4zLv/JFsdeLyQ7Zqq4F3Is4r
rITYvE0W2PVpLmFegoBz6RYrESfU7Jq2HFDn1DjwHnikdl6+jBDp5ao3Ir8pBPo8KZcvqK2SxOw5hG0R
j8RIxqr2XcKPCV3ATRGDkCgVm86pY+zCmjjEpgnEYYD+ZJHlWq6fcRaL0Wg7aRLHOJ9KzPeSLlgdMPea
zDYRDH5F4ojb2dKZ8NIJFFuMCvFwYwK08izcxSdjVXgCGLtOfdLPS4tTZZZH/ZZqz5MsZz1a8t5s0JGy
vdkgNkyX/uwi4KQnG/gNxO+/zzCeZxivM6TW2OuM3/Ik+AuPMPjIFZQvauyKC5+Mut3wjkqOcD0/sR1c
IreVCs6ewEQKGM5M3gxZNEFudABRSPB4AU+HCRR3+qeuaYJTkRkuE+fLisX8pNrYHW8nvgWX8yzey0bQ
9Ud9/Xm98egkNrDPnVEqCVIlO5UEozhi/gcFNxlY/SJQwyH1vB+RchgXHkeFBT8BqZKFmEDzRZ5F4CKE
7rJgACyvFKiWVsoqkD28WLpFMkoC+tNTfdkpL5NHH02IVHEVIIqTlnx4qaMzXNLi9IqVG20mzThlbGGw
AByizypuLJnAoz5n2GohfubV+jyskLz2BO818WkJn8FVMQwN6RWN/trFvkDYqSc/l8FcIw8UYUKQpyin
PhnJ3wagPndn08Gy5jx+jknjV9PXpX2OPPDSbmoM6fPiWdc9jmtHW6Q9MTaBua5ZydzpKEkAc5d2d/rS
vvrFpY27ZRk3SJ9tcUPJKat78nMsbXnTqyxpfWubw768KctnW9059U36Y1+av1ndCDyqjd0Ma3vSJEmr
u6vyQjzmgOfLX5/Uz22viz4/qYW3xWfXwkqRi7o+5o9m5KUIB/M8vohxPaEtCFgcEV+QTMEHTICifqbP
yuhAEv+0Hlr95JdFH5y2rwLA2iLHUVjyx1Mg1BG0bXrdQQvQuhyvmiQFos0dgVlngrgfBQ+pG8SfFAu4
6mUcbib3jY8DxKKQuwqX9/S0D9V1QcrvotnzwtzbEnha98+AvK37f8sb5//ZZ8017LDU/m6Tr8qgP5Hx
BbltT9xkYQ9hXI4itMQVqt+BH0a/Cg5XJhAtF3O/DlW6yZOBI+wNPhyjMDFfvu2zMvJodTKPYxBdaCsh
Lnr9PnEnZnZMsg3Wn4F9KcIbHVJDeZ7rPVKOytWOHvvz1dlei8/YhKVbplrWPlnNCZPFJydQDqhibX4B
VCDc8Sv7sWlV1XNPyzne3AjUZvYOTLpW6qu+t1xr+F69VnMnaN3HE1aZtqX4wcq4pSLE7sHm6Pjkw4qf
Yg26pFy9sVs3QIPpM4si1h0CexVmwQnYZ3rFIVC1GHEhO5srb1aD8yKQvkoXh5OBd32UCys2gnnIEQkI
Dug7un04V1ZZm40ieyk526tpWfNOFzKUTKmzPMYa2F6Uz4GJBxWKbIWYV1Q+fg678jO2Me7aZzrIl2C/
oDyj1RCbBUjRug8Cfjjj79Q7wIFm6QLHIR3pBvIhss0awgQoLjp64WEAWQ2815BEF4boo8K0Wh+9izBg
MzxF5y9frCYPUx+qN8X0Nqe/as9T4uc9pF+u1aSbzEMSPFNz3mltrsRMrmxoMKsNW97YNReENlw+mozl
Go+LCPFXsuT+UVvjeNXk0JVx28/A9hahbyGc1H7nkSbweScF6dKo+mPxJFgUNlFo43a3ZRB5hT5TwDx2
OF+PNQgWyVdibRU63Yi0sYJVmCNKkMM69+gK0MGlbkconudiU1gtUXy5GJbnyEKzPmB78zy4EGGwVXsS
o6Bn7yoCXc0lX2ij/zGro6BPVy1iNMTJY0szrY4Qm8FZZVmEsvDGN2GSjfz+PyLs129yxuSGaBJfrATB
sbgqNfwRWUyedP239VsW6nIFgf+CvpsOiaLsNll2dWAc6toVselSJh0ih3pyQvy7lIkHy8FGY25fzqCD
5tC7BLdNMsVwOZJ47F6ZuUKWdockVxpaRxK/3I7crjLQjixouDczqv0H3l/zOIAHjqFWeORxfgtJ0Pch
RmWTcSyNAuFXmtBso1BHfGE1ipOB3y98/2sP8aLt+PtfLvwOoj79eXY5irJRAeXShHUc1sVPyVcaj5J2
UGmjTVZBuwgSB6gofgbT7KAt0ia49LOkOZ4XKv9AwZSxaSamcOVaqDUv4yyLB/iX376GB4tRBzXaj5NG
gbJmzcogrcCaqZBL1kYB9OEoNX6wJd8Gl9dhZskxU+jFawHHbyGdgGtQNAfWPuAWL+O7Sho+IDrdKFzG
CZp8SOLN5mTnJA/CqEKOqQLis/83xQHCCPZQ0YIyrA0Sj9aGGB1LfJldYN7RlMGl3Wqgif3+lzTUaC31
Lv3SwnLNLYg/tfla3Wk+VHCwGoxaTUONfKCNaMfRaACAkv/HoOmCIXfmUc8tqN+FvwuP8twU5pBchoix
H7FpIpRi4kor8KVGRxikDXPZsUFj7XXIlY7o/dK/t/7kvlRAarwJKnCLbe2XMbvqrpM+KlC08IjX3JXf
gU1Xfz28K9QK9Vfonwr+q0/LklMAfwDqAJNwHo/UNKNCUKi/Hd41WRLFBkGUN3CCWR3oJf1pQp3nsYkK
0nKphAN0MjQKowRCuQNnjxOqw6iH4KfBqyU3/LR2cHxb+/i+F7fQ//ZPzq42z3ro1xp8to7WW3vwb7x7
9PYUUg+21vY+bX6psv8dHae3W63L6lm4hP79Sv/zP79vdTeO7wcPByfb1cM7UuYkPKP5l2eHxzc/jsIN
JMj0lrevtjvH95eIaVmsnt7fvD0Nk/LJ/Y/q2foiNPEFcU2Xe2s7GMbxyfbl4V21d/bQ7dzuLl4/7IU3
H9dakHd5cxldHd69erUPrtEJHt8+9N7Av3cf1za+jZJu9Xjt1WDvDuGyvsdwuTtaWywfry1h+EdX90sH
V+Wlo7B7uX/clvqE8o4fOvtXPfbt37y+qZ7dv479zVdv9tY+Lu/e7Qa3STVZ2P8S3O6muN0Ptxju9eHx
/cLh/VeCy9XuoJ5B+/7DYXgE/569B/hrSffgbvHyJrmpflpHR/Qmrnt8uPbz1d7xwZuj+yi4fbMxXMh+
dG8vaxj3V8GP0XL58v7VKEqXRttvq93FV+WbpPr+evsHTNzX6PjktL/Xep+VXy0l0edR9TJ+E7RaSzvR
9mJ54zbef/1jKdgNl+4O377d7/aWypfl6ujtWjXYSOt7G/XBwevy0uF2b2Hvi7+49Lr3+mYjfNjb3V8K
3pcPb16Hy8FNWr15/fZ+9Ppksbrx6XV16e2brzcLS8F2eWnUPVo8eBih/PJ9fTE9/nmLMNrYPTk7Xvu0
/cP/1q5+2Ui3eu931q6yjSS96ofZ4HphJ7nc3vq5uzC8+dKtll+/2TiMr3+8Lm89vP05PKu+PfvyYad/
NTj0T/2jV0eH/kNtMCgv926ve/FN+9Or998eOssfsvWj2156F28f3Hw4qC9f94Pj3Va019ve2tk8Ods8
HPi3a2+j3iDon2bh8Pa22zoJ+3cHu/fhp+WzT2f3n1rdy/e19vrhdtgrv1+7fmht7m+f1Fpp9mnrFdpg
33YOHnq7g7t0+zJbOAja+70P628WP2weD4LDs68/37SO319/uHv1JdtKO53O2lHv2+ZCdHj8an1n/duV
f/ujtbR1WW1f3ZQX37697h6X9/b2Nt4fHMGMrX04PlveTK4/9Ho9zys6kymBlCmoHGJYCu0ABIQcSkGD
lf27tKI1+MRoxRuYd/ov7uPhycNldTnFv6uX/e3q68WH6qh/TfM33iwP2e/Weqt3WL15/1BNrjeC5P3l
+wStsuH10c56qwv0IajtpBh+vLlR/Xl6c5VEZ/j7fnujGv1ow+/RzUJSjR6q1fj0R3VYe7UUv+9WH7Yx
/Lf7IWJ5t3Zwnax/Go4+d6vZNXyv30dfNhke2c7x59cPa0Pc271Fsq9aa8f1wevjLwdvdqPF+rfFVw+n
5Sj4EiwfPMTx8UY3Kp9+WxouXi1cnXaXssXrxVH7Ptmvf1wuf/Gv0+WFk276dv1LLwGYP677m0efjpcW
4sXDy6Py+s7a0dbXzdvL+PDq5Gsv/jqKdn7+3I1eVR/ejL52tt98GnSi0dubh6XPt196+9W708PjjYVy
2jtof/uRoqm7vfryrXfmf/16c/rmKBp98M+SH8n22VESvG8/jDb97tH6QfXkw+moe3qZxJ/Tw17a73+6
+rl4+2HzeuHH2cnDl8X1s80NtLSXXtded34ct5f3TltHd/FubzT8fHz7+dXZ2nL3pFze//SmdXnwrRel
66/XhmTEJq3jZyxVCJH3x9cp/t+rwcf1t/Dj/Zfjrc/bx6eXC99qnYWt+29Ha2vf3r8Nv52sfbj8vBV9
+/Sh//Xz8XK73e8f4qofamfXy2iNry1cv6ktQcohnrujr7WF/d7O2qs3R6ODxSzcfYh+tG6HH097+/cb
l3tB7zZM17e/nW2enn37VPv28+DnaG345cdCkkVDNBH11mYUHQ92Fw567xG+Ox+vj4/84cJV1sOtnpx9
Ojj+uLz+dWdn9vEUbOV/YWTXMAXYyBaDDyd4nDC3ALtx/Sr237d6O62fH8Of6IB6lSV+/dvnT4Oz/oeT
y8Fy+uZw426EfrwKoqTTe+gtYohfyC47Orj8+g3aWe9/ON7cOgv2hz++7rUOO+ne1+2gd//h29bRWj89
6+9tfVr/fPb143Xr297dt9b7zl1/Yw+h9b58una4tPbq+P4DhrvZ3zq9PhkdDdbXi47C+4Epl41htIgB
nKl9pUMgZlpWOIqUxLhQykfrUG4eGftdueP8N0+6bxRI0bzqVwWlPi0s16cgGRoEAA5xXxngGPfWLlCF
oSxkYQ/EYTQc2WU9PlI1Jj7U5peDgYCEftPnOqrwisYp8aOUqKiIkAD3MD5KbAeU7zcSiEhIP5IghdDr
5CMeZSARsC+7vM8EZcqUN4DTRww5GRD4qsAn7XEHy4EV6IAh2OApNgUbkmwTbHCOmaIPMRWtB2ygC4qE
yNDXxH5V/uSDXVc7wtYAeVj3KCo1Z9FC3KKBr+DQ9gWiL2niy6QKVnM0CsNEWzuysP7n1QE4lCb6jdVC
qU1IpL20qIIUIRcGyO+HPSiAzd11yLiYNEsUrrKcTKkb/Lw8UtNEKAYrs3LZj9vXSpMKNZefOUrTs6Rk
Kxn/Fc0L/UnoCBxBqKWwQ+lRPxwwk+eCgqVUi+tt0M4i1Qxz6al1a02OEaHQdYYIBam+BVLhCeozv8AI
qfqKRS3PxgmTJzrAFAYCUX+TNvNzxpIiEv8cQMQTsuWfMUJyuCqq8smCIdX+2DIRkZhMnRfzIbMHGZMB
LOcCuExQ68GU0+FVbvVp6hwOYmFKFwJEoNCgTgay9C9sEUpXoQP4FzyER8voj7djJyic7IqTrIK5hgra
rU201bKw7fcZyRmgjdIPmgZr+EucIZYGPqy3vgJnePZqr733Szz3hyHj/MLqYbV6eHvQ77W+vP/6/vi6
3/p0El9vvHk/+HH7tX7rpx/7P46GX1vr2XB9K2httLc/HXWP7veOWrcPt61vO0i++Xizvnvd/bjm752s
99f6x6/XDo7C6/Wt90ebm8nOdu3Tz2v/Mny/3vp5e+Z3Wg/fPhzfHSXVGmLgv+z4/TcPR0eH0f6n096H
+mnHv92tnS731nYO63tnH/av1m4Wtj/GR9vbP37uJ62lzwdLD19rvf79/sfd04WPO90dNAJHaaf3Pvxy
04u+Wnh791dGuoVHepGO9P5+2Fr+pZFe/8BHuoxGunvXO23dHm6s3W3cbdRevzk++VL+Gmzeb2ztrUNP
dhZ39gdfwtvugq0nE7UXboH8W7mzCzPk6KP/uAW0YAtAChlrI7OGjOfjNL9w2Ucg2ZGQ+J1wlOKziXPg
9BSfdJoL4Yls1zH/3biCA8qUnv7/LfL/iS2ypm6RhyW8Rb7BFln+shQud3f3Nm8/oCY3WpuHnzYuf+zf
vnn9LVf0zOIYcQBDRRqni/x/bW1tmZS4wA4HoPFI1OvBAseGdjHiAKSN4RpXE3XHscAz4RQIGzULNGPv
ITD3+taDk0e+RMFSFWYWdZiLDtvhZA8P/DvlXo8LZouo8hJcn3CKgYMXi4P8Lf7fv3Ca6/dbhpwjiULY
4yzmOpr4RGZnMRWRsEkdthFTk27VYv0AiyzQBEaGJk8QcrQowoV3hhpI3EVR7UZ9kXOXcqTzf4FNkaXp
BXKbNpSYF9wNNud1C4uC1rllFf8STQD1VGuL0IT1/cv7yz4usEmVsYPPH9OjWmuv9bD+Jrzb7ScPRz8e
Bmvh5o9hrfXq8+3a+slh72PrS7x7/fMkzl5H+4v3e7fHr4ffFhf2H4Yfrz/FG2tndx+nKkVnVO5TeVDb
XYvDO8s+lE9I/dizLxJz7u0MZaFQMNYJEWuizp9SKk6dmcXt26NrNDNXG7WvD+lx+2rr487rtBVeB5+v
k7vbk/bmWi26Wg5efzw9/BwOvl2HS9nX7qfLL+W9/f7S8P7bl+DH2UHdfu1i7x6J4v/HekgOetLD1vvl
kyOccHBGe/jjy0fSw97G7cfbnx83ljZvjxZepScH158+/+jt7Gy3Hg7D9Z7/M/wZfdj+Fn3cWV/bPN7e
r79dOli+fHtzuTtqfTreLfdrXz9HxvnzpWXvKWFumPgpLygLqTaPLGoEsQz2D+wPEqsdC/mvM/JvFH9t
w4uIgbMgtpSLmGw8sfw8nN44Vr6Qb5V/ddlvkxuGnc8Lh0vV6ptq6yF+v3n0On6/7u/utq4+hye3a/Wl
V2uto/WT08OvcfvnaS2X4bB24L+0f7drWkfujl7f7v/Yaf3Y2OutL7Xufqx/+rgWJjuobu36YSHpX90N
7dRzWmf+jd3K+tNqf/JD3J9NuT9l1J/WQ2+jtdE/OGg9RNutj73Dz63b1vGP8M3ZzsZp92gSvbH2RezH
2dfqwuw7sz65cbHpntW6nX5Sd885nO7a0toSO9lY6sbmMvofA+d3gooEM7XswsmquaW0EKB5xrs/T0mn
lpEuJnKQoPPzXFQQ8Om4aIUYMnWKywhbT2K1GFYad4J2nPgECM+jZS+xDKswl5BEc6MY5+eVpPwmKRtm
aBLbtATlXUkaU26CKVKFKOFscy1WDabFeMFM0si95Src3lUfEJoJNm1gKvQ3zfFfzXCeKOjX05RGaxsQ
xx1UUdtO0yIxNe9ZPfzidwzE+JuEaIL3l09PE1+TXQfBEKxsW6hIizr98ebgwc1Bv7Oz6YamKxIOXEau
KFwinF6hdko82Cfh9ie/aSNldJ8TzK5abdXyVI0UVB6ET2mRW9lZ3VzM0igrKWJ3ZdMceNAyhls2klzU
MDNapOXUMdsF9TIOyj6yDYZcSopLSeyx8SMA/jKdpB3jy0pL2Emy2tfQWset+SpOTSl+D3ZcL/DqaiXJ
l4+ocAoegqk7DrmRrQRecllaYY+W8CoVLfStpa7iJHygz+3Zs+MXN1pCyl9Sq5+fMOArfcHjEdFqbuOi
7VmKfoLNhG3CuU8S/nJffu8RMdcFrQjxBpAKT1iEmy7hlaEUzAMLUYloI3tYqIWXd/BAQkP0z7YOz9tz
mgcVqdY+dUyivZqvyf4GwdfSI0TMqbnEY5h4hylHXIXR7uijDW+tXG316ZFcSwYss4o5QlMDuUbUwZhS
pOS4EX78DbupNFdDXz2x51wYYv7Shn/RZ4Doe2pcWP4Y2Pp81WVEZFtP+ExLvuiECTrDeawdfEu1Thyi
UXB1l2m5ai7zwyb9ZC7ZXBp2CX5xh10whcpzJpQwCCOaWXcH/h3/TdyXCezrLhmpA5JeV4LckQXmMV92
NG448Wnn0lvXmnsD0MTqgacdeNkM6RIgLz7oQyXDDacg+moEMqpp+xQGt44EmXsmIMDXt1v77zf/2Trb
3XVk/3P68uDvAskgl5bAW1ESgOuwISytlKLEX0uKV004w+IigTa9fnZ8cnDsUQpHE/daxx83j70FJfH9
2ekpSlxSEk/Wjw92d703SuLuzv7miVd/pSSebn459RZVkCc73za9V0uWtv9Za61/9OoLb2x5W8cH+6fe
wrLaAAyit1xXW9hmGNZrC0uu8cT7Jn/UzXDI0sZXHrRSN20v1FT+2ld//ToRlnA4AlwqfqlGOd0iix2p
VmBHrrQnNVd54imgniZhYTwpLFngii1L6uvfKjwRvLukOsA9BIMtsjefE9mZxUKVQp0jasCoHg15Dh7Q
OZOyruc4igtCKVS0fh6+fBnQwEn05HRWIF5EoB6nFWtdC+Mhda8UmDzShGzM3VjzZV7Nli/mQsnFnk5U
J6qzESbJ2eVM56Rl+L28DIOqWsqUNDzw/EfPm/4ZYvYaz2M9HpJPvIJHYHEQiHS1ZKZxP6TvlBf/Zr4X
2ECKiKn22jTbyxz28FvO9h756RvwwzYbi6iP9qb0nS4CjsJyidTlYkfHIBYkY2xvmY9RXr1ZVyg+a9jE
2tacQcbzYcERZWEMyXLZjPtAIUt6Wyz2+TPbeTLPNbNprY2SuoBxkITndk+BsDXq960+BhSex6AI4Nem
MRPpUFtDNGLayZrjHUFeQdwPFJ0YKNpK76N2zlhQN0yrggeeJwytN1dr0KmkrLeYW5JgCR7EljO200Vg
3y0oK5Un11aV73K5oXx7wWq9QdxIhZ7KSDaTp6cSVkhI/gxAMZNK7vlwmJpSxEt9Jq5DWCH8SeRsNaDC
ug9zhRcT65IURA4PjioOPD3NoZN3TvWPwXtRawoaJx9IPBAB8QJiX1bpkzKtuatKKyd8omMcWPsCJ1OQ
1l2vGVkgcGIPzK59sCwLIanQgUVrN/HZYLEprbHor3hM3ZjJSdTlIxNfmIs8XQZLtVnQRDKRjb/HTQih
FIBTZ+YnJnEgTg1zZJG44ZOnM96u3oiXKn5XZJ0IBqaWrmhDuS28A5YccwpUD39E+JoEgTh41tHGvDxe
sRHrMXWfEzlob1o7STx7RBAdCqYYn+l0aq7iW6LIWpWXMPWRTUVR2hVJIPcyQ1ei9q6vLTTuW5BkkK5p
cygC+OOgTBV9/JhjUXNs9dYTwZBrzRs5GmSCmK3mjPPF2Qw7y64HKqLZfufHKM0geTcE4dV5egocbS7h
NGGBO1NOvxENnEsgvBwuyvUg5A1FETzvhmObxjLPadNMC6LJ/HJLS0Jj1dKnPKI7V3MDSRtDqYGUwLw7
ub80cqszncoN4yicsR7rZDwYjhADLbi20nQdB+VxRKASBfXcGZFPJDzUZGewA+ZvJO6TrdNFTSelgPio
UaVdp2kLm6UPHiN7sAgkEZW7UBJJ61jhKImuRPeJpljz1yokWKqnQQK9UhSr57hTnzwwqo/VFyoISYBW
AutNxEKNwadikQdGxaKXC0wCtWFGi5wBniXGZFEa7IlALX21gRMdpuMmTfjUgZPKmiNnBTRx6GRwsgsw
fb1NxMtYnSpmE4Dl4maC1LpKKOWMvXxPvfuow66DCPQIdzYYSs+2/E4AMRk/k6vtGbDpqjVklHKBWUb8
/6Hu3bvbRo5E8f9/n4LC+qcAJkiRmnEyIQXp2B5nZxJ7PGt7ks3VaH0gEpQQkwAXD8mKxO9+q6rfD0C0
M2fPXU9iE0A/q6u76112MwZK/SD0vmzIViJSt7Frt7w5zd4GO6fqazYyaVz1RXbRdRbrAi2Z8CJuPKy/
yrRiEQTORaZro/tTy8xFahigrX0jctKhFCz86lNfelOeFpTSyPC0pIJ/0SHBqR8MTUl/j5ypMspAI5x6
mhEBxPXQ0q5I1ArBd9BxKR04t9KrteBEVTXzc38MUicDmMpWqLvYipyFng761fZGUbsvvQdvPkRrKqaO
HGPXVM0LCj8UZuY3kjRRQ9FOD7xnDofnstFIdysjewcRMDSoEY4HevxS7/KdycCiMqtg3EM3P0HD7CQZ
TbvIPi0uoJAi8CXoOiSktEFVfYMpLkif+QEGmfVWhUKqorAIkX3v2+kTjN4nan8ovaniOCL7LE8Eumtn
lLY1xcHkP7ZwN8tM0v4S5LoDbK7ImaRbLaDAKoWh8DjPua0PoXPvZPLw0MjcS6McQwzjUVIxLAsmAadL
d5qcxkQ7TW6r/KdFll1zJCz7r8zv/1+/fp5Mh0dxADu7ts5AzGPMbIaYXpaxf2V0PrkYHmNm3eNdYbD3
lEGgOO0kyWstwbfvcxQXQ4dniitxIuZs31ScVa/FI4GJ8cU5nuc9HYgqCF9Zo3EZK1gF/fhFAgLPB561
AAXZHbjrk45bjaA09e7rWhqGHTcLxSCdzKbaFn+d9nbFdoPGErlN82RgHV3yMJ/+C91kpXxTGU2HmTnY
LwOJ0BvExsmqJczaLwGqTwsmtOdZh4rO+W7p4Dq+CxWe83kvvdojSlHdkMEVQuo557WS85zRLA+TOJey
G3pgIqCKftP2KujnTUI1hqI0vMLcP5SYjVeKc6YY1Tr7UG5JLdpzdZn60lzTjyoNhH5/qXCcz9e36V3t
ZEyyeOFrf3mNEn+sQR817q9jUuR//cKR3jw20kcb9Iy0o1FtpEJJomzV/NS9vgWlwY28Qz2KgfmB2AOf
SaUn5CSs1M+wi18VqEDNRknIxZnaMfLUU9iyADvNKGN9lpivh7b01Zbhe4TPVm6jMBs6W2Z801MNkdce
hdMAmdH5gf6Dm8JHCVHN5DTuaU2X4vD4qUlpuv1fu4Jh0/zOutA9TTBTPGFGV5X/zApp/LgCSsGnuxPF
hAFVWzxWUhhpmeogXwoOIU4lWX9ivLJVgpoai589IrGpZqGlxLgiyj4bExTNkKWyun1IMkGhSTpME5qa
IeNVHVOHSNluLfRXiTB69Z6sISnWZuFVWczhwMi0qqELyzRg3zUPD+Y7VI3Y70grbb0j7bpTmbQw9lth
aRXdq6XyyIlJdyOJhQP38BGfDg8LK6Nr0l2YFRBpZaytqvXnMvDS0uGpTcJXmAvDTh1XxZlPJRX3zjna
uevUcTrDovvBKo5X+2QJffZApkKIcdU4+lHhCiwEn/zlZblireOA6qrFaf5iLE08GUHeNe2wc5Skzx3Z
p5pHh6VkDVZhoF7OTEv+mfE4sMLqBpF/e7l2DGyZwiLSlApM1CYWUl8vu7RGV/o/MZLU/qaTs049D6st
cccjJzTxzSMldI6ndEX6NX46qXPTd3jAIbHf2XPWCdiZQ+CzZUVa5P8huP8roO1dtH64u+AVpmr/Mo5G
M986hfqc2CJE9ooyC2JJKMruot7+ZuHjuMJajtym+1fdbISZQitV7v/sbsLReBSmHjsxZv8sJ+vHzL0b
Q0Nrqy3fBvCjm6DkMAZNj2JdE76zm5rL351LN1ZpURhX4RQolKGESD0GNwEWfXiYuu1psqAsinxkPxe9
WGY8mJk+OyU5XsGJlCWQc1W2NCm4Wk/O5CtWCetwzqoBV2i9kQgn3I0qHyMiEh9XPMe+bTWm24FZbn3W
xasrK3z2CfqG4Qn3Y4EFxuSSwkYNjgWBSsfkkkMuX2BxkGr1ToXAW+IXz9NuopXBpaJQl0/1JDl28KF6
BCHjPKmcSrVFUf7/doEyaSzueGgX4anlUfT6ukTynuzjocM0QQM7jgIdkgfANkvi2Y4seusEUHbF+9AM
tw6SJJ2vVPuam1vqYxcFmqUczdbJPmw+nP62dZg1fy/DP5vM82GyNk1dDKZb7nW/qb22vY0FivORf0GM
BpioK7JtbUymuW8ESBJ6h0Dy8tYmiUfWInqGVDHjHwb7hY4ZHZIeHTM45PPhmjQPBkSi+No8dQAxFvNr
5+xZ9J09Cz4wLmJfZPk6LI/slR5N46VuzUY/yeM5tJZpVEdO7Si+SZbDbbyJr+I7R62yTEgMBRv2Qylc
rYB5C5fxhA3tkqU4RMU87a9lNL+ESS6TSzgF06ohhW+8gVIiX+KHkp0Aopn4ijWhtMTL6OkdjEoutH8I
N1iXaoqzZDSNfCeD1foNtD68cs6Y0ebpHc3oNpnMbeZRGD22MLXbxMc3EaOyeni4jm57TNHoi37SN8Ig
TboXmic8G94l4IXUcDJpxTIADIPRdB1znXoDYRjbSgdCY88oZ8Kl7Uy4kf4NN7oz4Z3tTMguQ+Od5l5Y
au6FuXAvrE2vQhuZCfHDeiig5Bw20dEdILKRqM4jQd3Ft6a80PJIsawvfO4TSsnp8cnwuGuwHH49kqPT
QtQeTjVzguZEyVD010mi3GPuv4bj8nAjgoUxpGt2Oc7moTFlFEvZo4V2+1Kj3PzVtBI0jNqEvYXUoLbK
iAWFk8ME9rpEE8+Ks1vbuhD0ozF76sHTyHKgQBqfJUCrfWSUoazi5RzzG/H+YBLta7TJGQ5jLMgjPDIU
oRd7bCT7j4N4FWlAumRo9r0MIeIVIevY56lDRXfCpQD5ui9u1V9Nb5iDDAPrUTgzj2VZz+Q5c6ubmxZl
Q534GrIcA7XC+2gmzc74peEYZjzWCmOlRSvX+bKzDZ3LVuWUChS24T5VVTlVlbbee2FL9mPRlOiN7Xr8
qcKsBVESChSGTsX6jLV33d+djkwdguV7kSQT3Z6l2sfCLSN2hZGhGB4DKeIyKVByDj+BiwWug54YpYsv
0kSnw2XMhjPPwchJcC5ok4TJPB2Wp+j4iD4ho6R52jknTAOZoH44rJNeV1kv6V9H0SwddjY+ak9qm8lC
ahZ7G/aPqqdPu8VRdzOM3lzZIuX56jQ/C/MT46AXnEC3kzYMO/cBiTRyffxJDmBa+cBEzZ7kQ8+1cvYY
v8OuJG9dH0T4XTVbnSTGtA8P89HqxNNIl5EAjWCimxlLxUuHWt2PsnYDpCnYtwUahG8MPQYscnfY/Izd
zAvaif6WbDJTN9+xFM9ejPRwYub59KE0Orb8661QMbYURN67GNDUPpLZzXi3zcoVUFlJULSby6wKSH1P
UVoyFaXF0Fw+esBV3RYItowBDkM6VUbV05BkeF63D2OWufIQev/h1c/vRSCLJ4t0vXjfZFtbLc2GPhHD
okrQ7/lF7LqSi9zST9mm2gKTmAFz/E0EpPWw2c1XsLrQ1rw4qebDYRHl421bX4dA1h5pjUNjo0zxT7m1
opZpuccwqB/EzurARMhMZy4O+C7wHx2zlSwtznXed6bHxUGSHEhDVubJwgqg6VQJYxd4Zn3rDGKm9azs
RU0fGfdmJWYnSQqdmfFdjCYkrY9jTGBBTaGpFHLzmOY8P59cWM3vuIVnpSEWURdzb7vJ/aoqN7AqTTkr
YupkVu9iXx7thiXOrjrgDXRRviLlQqUFcFDmMrHWSlfK+prP7Sz82l6iGaw6cp56E1oB2BQdTQP9VTCj
nhlU5eM04VBpQHAAyawGAdtQCR9PJ/Z5+HfPaSg6B0RVzs3dpC6Xt1jGS0lmd/WfXV3hfaP3pd4me9Dr
UuBjdefjWrwg7icvGrPdF3d2u332fj039LCJVPAVf889l/NQQjev2XuMBu0Mjhlhu06o2jhOk2kHacp2
7sGEjobT/lZ6yFSH7pPippPRtFsorfeedc+BgcM/CSIdjXa6Z8HB2im4cGZBQjv/DJgMW3TM14ms6oWo
9SXQNUAfwvnsv161NtmV9QLpUbgDXpKO6x0wdCFSBqYdH85hxKZt+ohGPp9QuLQNImto7t8RQwKHpILb
UaOQK3Et0y2ai1u0jmvgZGfVqD6dnE1no+lObSKSG6Pq+LcCgi5e/xfggazkvlDw01WWTFxSGLkSjFXx
RIq0UKL3WyOEMSBbwK+oSpQZ5iarMtRXlTuaeSVyxGjDarvmYgwRtulV9p+zgptO29ZJMX7++4zAOqxH
JrQFltzkdQtU9j+zP8EMDOna4/FVV1hF6uVlSy/WrelYw4VWX9AWSViUE4pH8KS5qDw8uG4ryb3PiYeL
x32f4kVd47uZxBflcjPm33b9oWknvpC0oqU4sBITClc1f1dJEPRafyj5nAYmM0aPBFVvCyQG80Fad4jS
/YEEDetd1Edn6wed08vYu0R98HKb4F9iFze04CsiKLB1EoinQRmyMDxAQjZY7sflQZJJW1yi9YgRoBDI
BAgFIDtkciWHpErHRVdQRwy2SV0eHjqw1iqJUqp/Hogn4IdNkBeD6qwaC42X9j7kdR8e7nfR2bdwUogT
al5ocpUa6GntsdDdT5DJ4qBJjFnxV9aW0AeugQxKISb7SgUi9jo6XOX19/ArEmFJ0RFMD22RYDBTO1AT
cgrF+CM65qfN4pp8DsOAhve6TJfZMojv6WlW4f6mJd3ZUavF4idZV1tMMynbynY8+N3DgyapqAkRAmE6
nAnDnpLF1eQriRquPF3/FX3s5nDswyjflESLn7O+ABQXcRntsnWdAYbqjiIWMltuIXwWmscP7iGbkDXW
wjqroQTx1FJmX3haefzI193X2eZ22zDvYb7bqeyBzb9Y3xO9efI0dURIfc0nwk9mmcGClXd9IcR4kdBn
nSm/7XbRGFjxdXg13lZlUyJGYPhUFvhPBFXVPsZaSNV7U7owu9fRY4b+Dab2cHaPWmT3FjBDNBpVoJBQ
nz4a0M3bu+ZPZnUvevf6nZltAfXueDx/dWvfma15gOKTH3IqzYlfkelWq7r7/MFB1udYd2UO3tiL+0Z+
2TEQM41f1+Ly0EEMi3kMkiQ7CygfUTALMGVU8CWOgmYII+9iWTEp3KF5DhI+UE7y2akimCeZF8N6O9Kb
NlBcqxW6TU9Y0yjU/IlQ4Eua1mp9kabTGYInYsxeW9gTmebr9zGMw2NI7FlSSRJ6Ik9Y0DKifOyRY8GM
YuFNuDDSUt2aITA6Uy+YIxTmHt39OlvI2j1e9/09LK4dvI5vFOj95nYu+AXwOy03xXdlebkHRkiZnrPz
OuwAuwfWaThofv+XBrXikT33PNOzYYI2yE4EdbbQojHhSGcGD3WWbXrM+v9TusnXdx371NcHq9DZyy4W
Jq8dbRoOzLtYmKHvV7o27GCdKlkyzDCYpKWW4OWTxArgbH7NHj36/Cs5iYFgXgLx8R5GQ9cJZqckscc+
Vx3fgKqSdhU/fgojfYdUur8LmSgme+QK5+Q0p+LpyZplMD6i10d4dCMVF1jTRpZj/Ne8atp0/Y7TfMkV
vIVDj9OHFJf96LZE+yX+z0dmfx/E50Ao/nebV9BukH1GdhMu0WBD3EJAt+zROr88AoBoT0XWaE+UHJMC
+VO4K3q/ILlrcBHbWsYAaOkBcjGLJuAKLhjfeCx7QVmXeoM9oRBLvTF7i8bEQr1ij3HJC/Luo7hVpDep
GuNcGv4BrL7P1k36H23Wyvh9xks3ewKxaCJ/RuJ55wkN/iar6/RKRhPnj3rBbFzANfWh/KVaHx4eYOgm
+hXyX4n2nXjCEvm0ENjwxaeUbFnRIZiVjfIkf3gox2wB4UVYxAFbcoyZBOzevR5ll6WdghPk5xSjt2Dd
WnTrwZrxPwA5SEkVfAy4SUmb3O/mDRxR1at0ca00cXCZt+fNRaLaa1RVFfgl/BUajc7CX8/GT6OzJxQB
JtpFu6a64wvFuqYcF3+jn2Ee7RbIPYcpoyfCdJAXdZMWCzy8bwGw5e34+7dvXn1eZMQaRVFzXZW3g1Q3
guENv1iXl6hYXye84i/vXj888N8swRi8iRfJmhMgby//kS3wXbgSClF3iAtoECZ5U37Syi9E7C4OzW1Z
NxwdQmLKZmjkvC7qWRuzBZwVMZExuP5MukAol6JR8+LTj0uRCEO8qWExYqOPsth48c9MseFkmnDRVz/k
WGAqlh9nXt/muBbNmJjS+0VaZwFt0oBJQoU1dkNYHN9TWsCG6u6iOaXvnVMlnEQw00ToclbnzThfXszR
vQAQi6pG8TJbZ0028JU0mqVkaYGIZ40n3Ct8I9rRi67Lq2DGlx6OkLpcZ4eH/McYPhoPSDCu70L+JubN
7aRxpuzJAF1X6zRK61HJZcyN6gtAmI//G2XnqztEtExpLaoNKSocCYS0kZdFgvh+J/2m5LmoAtkIjJIV
pMhCoL8quiwXgkCzEl8EvpM0UtVM0SqQBz5zVt/+WZSbDVyMsywG1reeNTsBA8QNn3Gj6X+v9tRwOLdw
qrpA0wNm7lLxPYxj021mMyMqLBurdYSZ46UtAqOl7WBsip043mCEJj6gCQeMSCJZ2sDjtVJieUT3aiXc
dUNwZwpIYYDOM0h1AFlAbh/0EEYXeEWVRf8S7rxXpDMghVpn1jODLztUROxeDRHP2ZeLGImrfJOVbRP6
Lm1NZ2ff8X77etWHJ9mIvRMybl1yekz5VfiDwnTNn+b0dHrmh61RXMJ4JvFIAZrhRSZxWbuzPAdywPQF
wCHl26YOfxcMrVNhGPwumgdzRExh7QVXFt2AcFXHxP7MAjzX8gVZpBz9I71Ja2ov0NGSbRx+lmH9Fy2w
zVklL86/ZZd/yRvflzflP7XXMct5Vs1lsGzGhqOdB4mjaXBdQ4KNIASjrSYYpVs+9VtO/0/Rffvc0fxm
ftGuVtDq+QWnhwnRcoxk0yaMeOCUB+pKUl2nwA9e+873nvpWGe0sMjApNUfFN2UUY8j+/Ezbe6totgoj
TUyONPh7I68FinsSoDQY0eXsPrsrbpaFkT3ZWX5WncvfF/y6rTDaJhzw0QwORTxCDw9beZnxVzE/RHbz
tmeekrQJtV3WymXyXTzGAc42CxEtcb6cNbHeiu866GiB0UoxkXj8OqDLqzT1NpyIj5sLI0Mfozqz8+Ii
bKP57XWO3rAWYLmxHywXtDtP1U5JtF0DF9wvPzLqlZkpoMft2HjRerhKIuOvS9zLezGTFTvYeplHwQru
zT3yVqPxO/yXM5CPc4u1Ksc4z9IxTY1zIIW1AJbct5EAKhMryPxc7MrAW5XCifNbWdy3mzQvSJKd5Jy4
Bs6+YsLtRESIKotfSPQiyHX25BwvZjqpwKosLnjWgfDQh89Mi8U0jfqG1Pe1eluOzRqEP7wtQOSk4Awg
zfYXON3fpAVgXRVG4yctPL5HYuXhoetzzT7fM2ii3RE/1mTd74F9uwYkZSXkSdNuMe6QFndZQYINN/BO
2EorWNs8Tx5pPfiJBeHACOCPzSjQykKnrIVJMR8eC/Sb6IGim/LP79/+RIk01cu8eNOum5y5ADFXPbPO
+7y4Wmfv2FLE4jxJxPXwvFhcA5GYo71PnHOrIIl7uI/hMsJEAkvmyhbSzWuVj83HoYbvNhozdv5gqoZi
oKQuCSi4Npd3nMnx4Dr2jK0RcWLRd5T/5uPs/jTM5IAzz2gFk8M3x/mFsVlcQYbiE0w4UzTuWIT5xmuL
tyD4BLa6hPlsTUOl9Ua10Vss7nFKFFJU1txzUlh4ggeb4STmTpVEeEz3TKxQwM8c4JsTjM3HYaOwQj/I
FFIUfmzIo/vMxIZCw4beAeXakucmNnR/enSgO3WqoSlTz6ocdC6LB/hTcphg6zWZZyf6UrABzbPhMNKX
0gSLVuE8u1Awkili+EXRJZih0CJ0MbIgdjKgwEECOw0IXgouoBwKzBJyS5uF+AGNPaNppiHWF28B8UTM
l3FKQ0sS4E0o6DkaLwVnrHu2PiPRL7dGNR9HelF9lOzNqRone0FHplbgxC6gH2jDacSloVanVh390h8m
uRO6keIybnCfs83rn3Uk8IF7oBi4MJrOy1PAk3I0YmNq9ULn5QUQ/mS12xKKc1i1YlI1krrwIUkSbRkd
YLQSSkAj8qpJrpEUbLghUn6ob+AGQtacGJb+r5kTGy4/QlLqShSMzcdRjrEPjeaTxMWwLqz2E1GyOtq8
CZtefXfFVgcwiv2OjnstP4A8J+KKwbTRYSoRO0dR/eMwbRRMKwOmxiTIsDgWBYAX16nUSTT7MkhqWHV4
6Afl10PlC2dtzrPhNIZcHnumOzmxj5b4hmnoxeedWtgS94VvCqW4E+Qu6WtUFtoJ1YI6hKcq86eX6s80
F29RS6jZ+cGmUx3NPklPBJh1/EZwdp7We53TPFqfTTPJ0IIcPjSIVwXPuSNEiPad7q31OktvKAx1JA33
ULLqxkHuvKgVCdPbqzqQvKn4Oxg5F+g9bfSyQOqwYTMM9zxrLGJEVraGZxC7Eyt/tSbZX6Cubu0jem3m
D/OIcO0dU9sEL6kuIOtAkz3Ug7JY3w3qdotSh2w5uM2b6wG2NdgwrnPAhOXwqSkHYsSBL0Cbw64CiQ0s
i8nSKg42Etedb/wSusxztpkXAMxsjIVUpGWLU3T8zMSiI5VBfKOvlrIRLXUb0Wb8M0LpB4JSUnokOBs0
bz3aIOv5kbX5kVkY7CfQkVIW7RkarAB08M4V4UjD+JqJxbjgN2MnBz+ZM3lpiANipxnU64RuuaFNQMRu
um7+kt2xIFYoS8SHFltoqjX+Tpmk4vkC8AeeQwxBR29etE2DWDhv0VQ+r9+kC7j6VlD1kr6wOLrjbJk3
ZeXj01dJcox8DS+BtNOPxbZt8PDFUMCfmzdZ0YZqvHrE2QPolbLWpgAdFoKiry/5LfucN9bXUG93dWBF
6UBLAlaX1NkSgeJreHJ6iremGEveh1G8TBb6sR/fJGhzLmOXYChVoCXrV5ttc4fZH+twGy9ZHLPPFLDs
Lr4zLiL8wixS/pO+s99/38WXNE7G6N4mqFJnFi6dHnrhJr6K4lfJbfweF22NziuAjj8wjB4/yQr0vfxz
u9l+KL/PVhHAvnh4SOHvs/dJABxnMEOyB34zy1dmNIEkcIqrFN3zUsQEXB8elsJnmopZVd9r6CTR8PDQ
HhQ7DXVEIYR7n7CuGO8Jfd3oGbOu2Sb4DEvRlG8rhFe25LKh+Rp5Z7ke/J76zLwSPkCNSugu2K/nsLh5
0YRbrPmERi8d2YfDGJGDWxipNjFZ+cEkLmHGH5jK4rNouD6fXJD5A95R7ijQNKKEGYcBQaHdatIBIWzz
TeoD4r6BVR+4vX0sDO+js8W4bi/rBn3g2Jzkp1lYul8/y6+fYSLdY44XCFE2EpyB9pjRhCyojUY9UJvu
FGOFi8zRBc6PukH/3D6A00b+KX6JcqtPrpBy7x3SYIjBLh9IJkfJpGgLxlmHr+KMgN7A5NdZuowENr5K
MhcAhDbq6iLavlQkNTOP4SP1hiuKujCoDl9GMH+koxYNrEC7TitaiRc4ABjmLa2Hue3hQIHBiYYOD18K
GX4yhQfAVx2xQnyRPNIGnFElhQqMX0rRmm/bxWscDncpsmfixZyddxNe4wVxtrDFwDM8GOBoCn/y7ZnY
exD8BIMuz24BAzqdTvkSzxb2ym39yP6KcZ2jqWA5UZqPKPnaOOfNWAhvH1ljvkYPDyGgu2d2F56xAKR+
6tnJP+HWNUEI0JBUWoPRK09Ex/MGiDVtp788by7whOzc14/hHTsnfUseP08+zfEm2MKWymD4ytPpLn7N
qNS3XSEvnqOV8bEKIJMBAUgkGVxwKVzqaMJrm1oyks00tlRkG3JyOCt48315W3jpRq6YrU3SUbzdi3b8
lN1dlmm1PLpO62tJdbo0Y4Md40xe8taT83vSl+L9yM6N55clcXCfs4VpmswPoTdAIrMojBRmCPl3uItn
aI81C17CzTx6vm5Gv8BdtEkX5hth/iyOphlnGoO4gj2CfAeZH9sjepGty9u9RtQzIIS+PSR695WDIjC9
/5Rv4bEion0viGFu0s4xvkda2wM6+f5fAeCXjnWfofqAqn35suGqATA+7JFR9qIf+tzbA6N3Xzuk5ysm
DekdUc+A3qHriT0i9vJrhvQT0Lf7QmmPdfSBS/vytSPcD2h7jM8LPf3TF45wu87x/KcgWrV3gBvFwo3N
4mEP1jkoBwPz7kwVS83fvV6gp8PndofPuyEhO4eLZ/mcUtC7/fJvPV3+xe7y3/cE/kXc6FB1LqCaKAl5
wwdyAEFWL7yD9bLtew0mzuvnN2lO0YNmHhtgEg44fPxud2E4Wvgv3Wj8AzxyugVuf1GKv0mEPt4Di8gn
VNJogv3tgj6ugSX1GArVCryPiqw6hVJraFB6p/STLrzTtFpc8wcUm3zkggjtVfmov4sUW11bcfYWymmf
8iXD8mqviiyD6SSN/g6t0m5hSeqkQKkofEK8R2Nv2cnNV8rUNlwbkAH9iiBhEHlbvGcz5sJjzu9lKFV+
zonixHhiepEMDS+eYEY5JMG1YtoLs6SGson9wiz5XttvifNGL9s9kQSJW+ONXo9y271RlXmdzi/79ckK
KIuI9wKX+kHO6xDCL4lsKaNYGkVSWGmxDcOVTSVH8ZWBHfikELIiwxxyM1KcuBHtIAwCDGiHNhJC3qok
m1dZI1xxWaF5i6OR2ogmDuAMYWPWTYHoaHmJ/FIy/Q542lAKxig5BJfb4u9N1qTwMzrD+Dw9g4SDs66v
07xio0XN4+EhxqeJYt+QUN5UeT5drls8bqOdbVfITiVuXIg1hIGhaXXIrQnVWRWN5bXAHdP6Dq5IZ7ji
1jJhDNDyV76io4yk1/jmkdMMeTnxkDg4gozmIm0AeXwnuxAbs4nReYizwh/xgu6ENYqJ8bNxQkbjV/DI
UXnuqMMxkJvF8HdGHKmtglLNsdXVHHYPTA6puaRIiaf2TjD2bhw+5QUgbT08knjV8MuyLVhQbD0EmCvC
NIeCA5C5Bcy3WSStbSxZrVDLHSTHRkZPrRidskQPxSLzE6qOzMFkzmiMet0D1Y57eLcT8lXaoyL8CRrt
RHpkcGd2xhprLaKpOZ+h8CAy7o2w0gdHcMe8S51rxGAovZ00JBcO3U4laTin0idIrabML6tNiPSKRgDI
qB/wwjlLF0Mlpj+1COwj5em6Dt67ZPOmF2xaAMueIZnScY9pmdW/LWtnWBtZi2uNo4HpSA+I6ip7e5NV
63S7BWC8s3LrGo46qluqRp4C3EDA11PGPWokCDunbxaTJs4akeO4MWm7vm+TarhCkY7IwyFzctTxboL4
norqDj8mFfW14zAPE35aibDGzgboWGze4hZVFHPurtU4uzGZ7JTOWyzQvBiN5oa/HW8MSKfs81sgPM+L
C/1Aqol9XcB2j6fctEWCq1IAERCrEWTOSBKZ7b3zYPBs/qm1OjqHF0Q9J8PEPhm4lYR9MiSNvbkxaNhB
gyoIdNcKxR3Jb42oG3ElmqD3sKRPfHYVclSGzaZ2KyJ/p6OrNIw2llaGCYMzx92szn1E1c78eMQJj2h2
bs1XHA6mAKNzUvwO6DgqWGcA9Ow8k3aJF0An5gRPOrdqQL/JBTMGA3af7i73hA6Ve4AkXvgtiMZh7OZD
0wNshin4dGJAzU9E/szrF4KjCzHGgWabhnkxhIkuad+ShNmWVhEzpKSvQBLyOkxJLT6xiaSs0NwgdUJj
2mmcimw2/gJt3MpY7jvmxgVosZYzwpVh1WqUh83XpsmfaWAXr9iZsVb6lkVSD6fzxUk5XwyHEf/uNr7A
xqF1T78lforXmpVwopsMqz7hl1DTGROm6UuP2qa8gvUmTaLS2vxvxbx9I8ya5kSvUfEnE7x9WV3mGkF5
5AgYXg1tFQNjUe6zGt76jl8nmyrlNMhsW07aPBGzuJTOAq2UgKh9U8p3yHuJz8yRlOQoJ43YjGnEdgLT
kq+ZfEW1tGIv4jUrMC8xHnZYJpjxkn6u6GeSYIgP4le17bCCzZCsaTfQvK5NbDENw7rU9wsUEuxbFDc4
TOpaKcAJy7eHhzfwEk+ZbRSxGAksmSK93F0LvKvPrhnizVhp7jJ6He1S4MIxBgYwbRkPcspXa5lUykac
+SxW50tDB788nURLIBqgFv6kaptkIktvtNLRZjiURMdVspxfnSab+dVoFFXnV0arlSArrpCs4NdVtdsx
jrK2fYiXirUtK87UlpXLz/q1+471qJRg6HmqJLNlftQSloVaDjGrD5Nr6OfEmsThvSlkZqjpjZkVq7n1
lRdOxqLuadJYOxq/w61L/2G/SSMrpdGv3Q1xgjozkp/1gYPYeD4jg+jxGvHKkj5jZ3c0km6F8/ogGU0t
m023Ase7Jp7+ZrDog0Tdxbt1Njp/hGpHCp0HKuaQQhOFvGizHqhWBlTRIUgADl7lHHACNrkk9fthY06/
l03zGL9k7GL277ov3pKP8md+6xY+iPq3G4UuQfeZ+LtMnr4l+mQgLDgvqXU+apJqwQp9yu5e5BTdHqH9
F1NtFK5sRZKMosfFjxiHkkkkRZUAdWaBb2Kv4MNvBzFDk+ADmcBCXakqTX/2ASHnJFWE432AyDDmi+HI
qv2PgtL0o+BaDSn89qImdut1WOTziAtposzoBR34hkhW//CcmlNuujhrTLZKgSIoNPncXEXJ7JivHXkt
+aNqBfziqpBbc3rGlCQBJ3ODswoYE/6gLKUbGc6itzbyO4+0gHxQRyNMghGcwXS9yufYD7Rohu+dBi3I
SiKKrbc9vs60kn4jOjP1FblzYiD/txXGislR8Tl9eKDXTy7vSC4geA1hJd4mJksCfHCruDKgu8PqrJ2l
keDP1oRPK+EkLEkhhMcZ+4eFB2hovrNMf+KJz1vYBTeU2eMK+qju5vYLjJHHyHmUs9RhGc17gIBmvuI2
3iZiaPMt3caYvitiVPAWM+SszrcXSnCQJPAMbKb078VK1x7REVaL4mt2Hyfb2ARaUmq/rwUtvCdMDoCx
WR4kSVswi4Al2mMmS+zN3mE0CuAlhD9R3zDauBdk09gBOjA3nVuW5nSTmIecnZDL0FLYsTCEd50ch/xw
A7wTgTxJbmDKQlEkenHSyLHCUSy8ozyb1OuJ7lw5XK7Yv7WoiHnsGbIGLQckfc+WZlYQIe4IgnkncaEU
Mt6R6ASpPhJHeFJgVCSxFSpg/6oTQf7NK+CRC01ipHlv4YC5hPS8uogk9WkVUwFa8OmnjEJyvxQJdFDI
DQfuP4DzxviQmbQYDwvJvEZPc6l1CREk4iow0FhxoMiaOcPQRmszaOIeUiyauFY7rBQcTebXr0/RsT41
TxjofNX47CZxK6dMNmTmNuwsd1ZIwRaXIrKoAcKreCa+z5kf8gGTuvAdILmcxTrfCmGHEn/Yrsv83wMp
AxIi9+5t4vlsEw9CisWt09x4ZAkdmHEjrH1w//LfBGDxXp2kkSnXc/DrzPoAuPS3shIjmrlfpWJaWhx1
IqeIfPiEGQIg5R42xtYSX4Q5nt4Wk//k1jU74aEjLBv+ZDrXotRqUJ4XDw+2cBQTWOqO1bl0pcb7Upds
Y8iBA2UmXx0eOvJa4QlVcWEqFpENVLH0abUt+JNpnJt8qWWY3JMoTK6H676BFJ/aBihe21cuK+rZLqbj
J8uszqts+VJ4+AuPa3s0ZkEzeepjYkVy/B5mca27EB1oiBpp8SAenUtlbn0RBO/xYbR8GK0K0iOktGlS
zkmfcs9ktoaYtYxTwCgB+RXrVsnVrdJpXBqlUTyKdjYa9JJak0cf2LvXYc2tAopdUd6ITcRMc+Qx2FVn
BXSFlE6Jr5befi1NEmAT1NuyVozcY4IkcrzVdiihLLsn5J7Mpbh3nkuJUp1U5zldJLUuehayeOPkqjXN
WG3olKK59g3JxY5y8hOX8deCQIYP/Bd/J8urh92u6KcjW51M6ZttK40AGvNwreG6yE4mZ6pAyxTt0axl
NE4r09bu0xNwRbXwUMOoDDzcdh238DGKvwpoO+dk61DFGPiBg9Txg+Vrtg2jbDTAtIX7ogCeMlzajXax
Z/zzjNYzdukLsTNq6lYmPWaYV9nrAgzlNZz8ZZyRezisg9FZyztrVWfubWZKfNsCU9aEbdQztrb7njGZ
Ca/vJJm4jZ9FLBuZ3Ym1+QX0PBnTuyxxVOgxw+VARZyq4RgYTUmnvcrXSExbAjahoGA8a6USv6LKQn3a
iYtDeALK2IuJRoTfG1eTS93AEupIvtL2/DppgWUmT3HWzMKhgEQ83/h6viyBg3e+o9H7SsTePDpPZhdH
4yarm/AayIfhcHWyiHpqtl01R6P2FIiVlnSGLekMTxMWl2Ax4ia5W+cG5YJA5vPRxjAuXuZJlT3HlUXc
DrfolepU5dGfWEwmlWM93jImKPi1CKIh/R2vgZMxT4dkEutnZrI93yqttxlBULuHxBrxXHT3njB1KErv
dOreCUXdJL5JfixWaAdzF28SjCO3NZIRcIpLeIxXLLgBLQFFtovopGL9hDKq35iRtOHRr++PrlRW+4Q0
F2GOqyLKnqKcA4MYimMpP7mBNzcJZe1HEaSbIyHWgwuygdXJciQYEzjFN+fFxehmXp+WZ5lYoCrG3JWY
CPBdts3SJgwGQVyPygiD4mrhrnKLz4nNx1E9LCMK6qQvY6Mv4lJ+xX3ayEuzEiGRePZNonmwKVfQVCB5
/q8K7QXXq+FwV77NVnOI8YBJt4df6b4z58cXZy0w+kP8NWzDeoQ/RNS3Et9/e6HyVvxXiNs1+rUeHsXB
k+kgANijXaNsfO1pfGg0KrsqYxjZF3ew6Bv93uNl2+JgErP0s3Edl7o6eBv6pPUbigN+FP5aP43C8dOz
iP3CHsZPoyNl3XsGO4Vl0gcW8VyeA8jFKDigBPf8G/nURDOE1LA80KsMtQpDrTiGKEMPhTg3ijPTCnx9
ar41xgGkw4nWLjJD+sCiuDw1uzJGGuFQz7OLXUSAas5Ws+KsOlvPVrOFisazNKPxWI4nXmUIP5PnzCpQ
u2DRatHV3JKlns64GcaAuL/0NhKtqEuBJEgwGBy3UAkDySLs+SkPh0FSUIIHZcZqK2ZtPQoVN8w4PcpU
byXdftunYPJWMiw4vfo/uxoGP/BkreiQutm1mQTrC+oTnWY615HbTx9E3dKPA9St8zg83Tr7gLPxgNMJ
V90FzcYLzX2rK6LXYawPdOT3GwX3fT/zAEhI1SwIsMj4Y10rv4m5tw5LTWXlbl3quVuFa+E9i1akzdFN
OLYRSaR4lDyPixkbYJ+XmaxpOJqJEHoaIn9xm7RpjUZ3Km/hzus6CpA+Qg4JwEn/fsQ3XxBc/guSjo3d
0PHNGHN+2jqXnWv0xYf4Hskjbn6kXIvkx3LrfAOyU6UV7WChNeLU9JVxe2UcQxWdBUSpBbMmSQI0u7nM
rqCBYhkI+3F7TF3vVYtYexYEO8/AbYMXw7lVC/WXU3pRUqd1m2/mCRLYZMAp5t1EJMPg9HfOEp9RNEBN
g9AmheIJRXw3ybCtkgbNMzl/NRw2J6lg8vR+zD4W1Ie0bcI3J0nJLSChNYystj5dCfNM1dA6kpoplVsF
GN+4jdfxtaRhy21WALRfADPzidKbOCDRcw4QL1YIXiwfTndknvoERewv12WtWgJmooyZSOOg1WGEUFmp
NLbnJBS9EINMGYGG0XPZXNQKM/FphOLWhOMWJtuAd6clcylmJUYjKWDVwMEqS1KpMuWrrcwXZEziC8Gh
AeOtAVYEhgUKPl8ZXngI7Crng0bm6FrMjC7It1wj3zyHlZ2bcc+Aicty89gx1fBc9WRGJBPdUy7bUbMJ
2DtihH43Zu8GY5XndnCP3uJXVdkWy9ng31YT/G8O8y0rePzmm2/mO6MWJY0ebShr9OCecuHPBtPt57nR
TPYd/mdVRdzSuxuJXn7/4g/Hr36vSvvK/In+iIFdAq/yyWqesZiD+54iuchDLktVV5fh9I/TeCD+iqwq
NdyvKZz3xstP2d1tWS21vuAAsEZTUqLBxurpD/Hg99CP040oTg+XmPIIwatV/e67ePCH43hw/O3ve+ui
x28LA3Yq/3GfyvlllVZ3Rl0c7rMJ/PWtXRWgma5z75JCxTQ8fvYsHkzY/8YwY/EtW9owZsFYGZIIrtUY
AzTxB4KbMwi9rhfm3ePXqxI51d0w7ihzJSd/hCaPAWeOj4/thjl60G84xau00fCS1f4WJwOrMv3mmYtx
KIkwyn8DBScwkT+4q7dBPZZRmAD1Df416SpPv5flwqiHMJogkjxzhmRVYxBLzTFOj3E6z/7o3UUGlhXt
JoOjy+4c/nc8cbqG4zxP7R37LfbyzTEu6h/tCp8369E284Ab/3JHBtPKmzs2rnST+XHw3ybw5/mxVfUa
mBV7paYwqD94YYixAURRKvndM3YWfOsgJsYzsGHMgXRMk3YwjuEM/ayyq+yzMSa5DyOrG6LhRmvMb8yb
ESyNeSuw4SKuT7+x5ja27FStdvjggCKAFsvPo/o6BfJ+NpjAf99sPw8m8H8guppsflmi5d6oApC29Wxw
DDfKo6Ntsq070ONnDIdxvns0AbU9k/39twhqxLKJgzFuK5eMlhjcs2txNhhNcW7w34huRpoa3ZKDusQT
k90FuJT8r8f70NLRO+NN+fahg9bd9G5Ce/fIHgCSLxf43+Mw48ZeI3YFuvBHNGV/AaL4J388od3OSrr3
CjICo6s2X1pzbTHZMCU+yzdwxx1tiyugO+oMliv/64u3724nf/n3q/I5/Pnp/S/Xr365wp+v8K+XL5//
Hf/5P1eXfy/o7WT96j/++h8/bv7287dH8Gf17eXr9d3R0Yvb55u/Xi2nR7fT6RHVf/Hnd788e1V9+vPV
1RXQt9GgwpBccI2hqHh0N9/9zklPjVQbcGNjlmbxZV2/p/0ZSlJMI9R8xCKu0cdbRoZ/ZeZtHMIX8Lpm
0Gxd4SOylQn9DxsWD3nOc11Z6qp35e1rnviMc4PyjeUFhJpbao8Zcui1/N+4oTxJ/t/KKD3uOycPGtMa
cNYmcV85FTZZWrdVZtQw3zlVxLQ+MhGIYKS0zFF8dMw9LPG97GzUEWuZE+4s/YqLiHydGSFs7LzqCpNF
xBpDAuIN1qJW3hFXG8IJRHAOnTNuJqK9Os9ECAbzJTKK5Nrz8DCZNckkZgYyTwCR/1alW2bYyt9hqKzv
4aSAamfTYTNz3srUPsNGKI382OhotiddU/HmNic5uRg4Gn8OE/WMmz/b+bHD9VFi8UOE30Nk5PY1Hfww
iJexUZ0XBwR157VK2CAMN1lnSWKnu9XtsHmZDCOHhJnviNCiMiFqXlJsx3f0KvDtt8iukWKsRaOCsX07
83GYtkiax4gZ34DPgMnerAnwl2o4KKrcYwZ2lcemMDds/dg+1rBrTt4MPq03i/W/Zn+PtynGQP2Jiamz
MVynMuvzwTS2inAt8Mtr4DgRs9aRSnJmnbKP+AnqIzXgK/RClGpMGn0xJbqy1IEnrjMeUd6smnISUB4v
kfpHz/zz8OC8Z8EulWGYcBYcTk03cgtyfCFEC1yiJQLdCOsaBgs43oQTD89ThaK751WV3qGRkLLJyuMJ
6ctpCDwhbRO33tZ2zst+YxoH0pmZfedgMs88k8UrnxQXDAtQOV9QikMR4cTTPKG+5lSsAOSeTp7qDw89
LUvAdZnRRNaVZtwFJJpMsrmzt+WeU8rp62YDe+OAbRFC8iTnGRpf8cB0wTK/CSK2OfKiyKofPrx5nbCq
7DVqhCmIHifbqB3m5qwG9lLE4hZt1ejMh1l0yMw0CdJLoIFblP9pn//5I7nWPKPMUbwBnt1a25extZUn
LLzfTVb9O9H35Mxtt/kNFqL4/j9kSLVSIe05oSpwOtVZw95EDDd4XBwu8dVeGdWPmjExBi9JVUUrJFox
CSLd9Q/lxiJh+T2ziSNpLXWCebo9m8RzXDLbtSayHL07UNR7DnoOzEePRz3Bi5ZiZZkBJV3eRZgx3X4Z
inzoQA3sulC6ZxcKbFfG/b8xdGX+L47FjHrt3uIWfWu67gvQ+PYkv1L+1LIQvD46u8f63ds5uSRqSMjM
AIEMLEwPAu5+ICy/pGlsDeRcfSIKz2sRT6NMivP6Aq4NDW/IlM3chJ17tqS7NC7H12hEaO4xeLuCTYRT
oKQF5fhWL0SvoQyzVqen5E3aXI8XWY5Jm26PKkwqz5yP6HMkrIuhO/io9uG8ZEcE7grUwowc00Kk2NGZ
CTd3WDL7NmVJiBMQW/8gQatW9Zy07ONJTtYyrG60yw8kkG2c3gtRc4Wk7l5gwKBb6TGWa+fj+7zYpaNP
XPXftZWJTrQsm5xHt1nlVY0AjQv5E3knVij9zArB5cHLiF8y7zrXP+borXmAxtkRWmsbTSeq6VhvLlHN
NeMnPFcdTmvMzAiSQnd8mZcnSU0ZBDkZU52XLGZDCzunRdSVes3W2gHtvjuAmom4ZtEaFMDzZ7xGpAMG
LX2pmZLC/TZuyu28VQgMnafDpNDQ+2kvNgutZKuuRWgxSUcF32jDYPuZqflXSavfpWfAXo6Z2IwwDkZh
bNjVCOlLMqjGAPJGF2t4kayo6VivdqaVIQmSbOJFykzYsVQYUc2ZUzgIdl15215rZJUv/wbQy0cZpsTj
wrw9JUq6COq3ECvpVgsTlDE4kX1Okly6Jgzz09MpRjdDv3U4iZla/3QSVRQJjEhwRNiwPJmIBEMD2KNJ
PZrueMCeUVgNp5oZZ+sxnXheFCUzOoCLcAwISnbu5QZpAKbmjXgwE991UoZVzLKoaulsYrcBOlDzZJSP
yNJQumOc5UlxOgF0U2GOZjkLR1jwOuqLOOSFOwxt1kILdiCy4MLRtixZQdgvFxy8LdfJUwFD5T0ATox4
JSYPStFJpUmoMNqjp+cwlrOA8zbBLMD7PrhA14PuPmTiukEqrSJTK7mMhmGRjsVGrhldAmWLoBpK9Unp
Hp24PuqAV3aSlvQSdrItz+QJzdFQz5SLCOELP9G4AQqzTNYS3qElCmUKTizqzqTo4LRNz1JFIM5KOFHE
SRQWcYmELQUcWAlDlBV600oXvHCBXAVQWXAGlKvBQjqmBkW7uYQ9frZguYQXM/EteniYxDQ6TIkl4o5J
j3Z23LHj+UmqdsU5VbnYiR2XCoRbJ/dozjA7D16X5ad6cFWWywM4EEhZ+hPLA4EK0E9wcmW2TwtLFx5n
3Zm/uDzkmplyMKiq0xSTHGgHNj5m65mfrdvFFItsbdxO/qKYsXDfovPlWE41CdgBy3DmY1phGtJguFYl
eBgBHeK9F2Id0U0CnWjXys1Qq6/dT6Nn7L6hoXcNCmWfWzz9t11FzBFDOcUKrymgO3fvOLmsTmFPbveC
EovH5gvuwc65kJI6Yw6Mhwee3xnRK5CH+rXaJvE9D/8yC5AGBMSay69W4IPMSrCV1xQz/ecK8BA4KJmh
4NGAOhv3LHCkRdcUfl83fhTRbWI5PqcIt490C8hkh1119S+7OHskstLGzifQMTbXHNT53jGywjewOPOr
jEw5EoKOsLYspPEnmaEt2lrLl7CXF1t8f1k2TbmZXdsMF4o0c0cbFwzgz9i3Rwb3A/5H1z7mxXVW5c1c
fOMqdvs113gWZZHh487pRWudKb2BKp1x5Sjqva2vfFKeAkLd/Ay1zfLtFgAM05sNpqhd/3aiVSBV+6je
wrk8G2yrbITznftHyawj8EVsAYlON/XZno2wmVitnqXP0p7Gb9MKLfG6m+cFujr40/T776Z/6Okgh7um
u3X82tU0jrx37OWn7obLT93Npp3N8ktDVhVCw9lACA1tDOMY8cxFGUAo0Sdz1CaB1gHbAGlh4+qIWIwv
qoHX0X4VCLlHYpA74B4Cn8ob/r+3phvIAKAhLgFcdVb5uRM7r4+Rg8eTowfDc/P83/zNDYt38lEcPfz1
bYl0Jv/nI0s/3JukkH3TMpCL1ERG4qNeg3avAWkHa9efZMhgzqSS14JnNLe0wowEz91MI7U37KnIYdKd
6ENkLdGhHo21VOoih4mzCNGYx6F5J8T8VM67KhHzo+hIY8U+6uvCXxkLI975V4Z/tZaGv3XWJmKiEpTG
GA4epCgktEdbC5KZOmEGGZmfkX01Xl6BZG7mWSLiYYxVqp0Xdz9iIg6uH2Jp8ZG34anxcfdhP4NFWvyu
GaBd9ADotcG/BcMiQsN1Jgovbvg/XJALdx2a8S1wLLUWAU0W4LE/WMQnaOMoxxRADwgaOB/So5x5DGTj
Jr1CGjMSAqhsXgLDSf4ecQY8r0VLwl0VoJTFkMzT2nHRPNqJU8QL7pj/I1Ku5MFM9IMiZAMh8GlEHwot
wxKYLh54Df9Oid1bs3DarMRKRHK7F0CfrWI299k6Ri+qOv9nNsOssviDkTDrmOnRpGk5UL2LsQBKAnx0
buQYuoVKwO0ErI0gXoxFwywjNtDWjMgy8mHnki7do5mFEM0r2R2sIklWd9iJ+XpNfy8o7pgLNi/TjfAj
oY+UA5ATt7bHCcQw9wIb1ZsD5lc/C5J2F83/v4H2R7M8GdwbX/AP4jbfT+G5vFsu4oGslfqqUdXB4eEg
5Zt0jDLssKnazOpe/MlXg/CAARnv/chbCP+oMoNkkPobW8HuIvEsHFewzQYwRmw/HcOp9fa2+LlCQ+Lm
LoTP0T49nUPBC+yOfrh92jDdRaH25v8GAAD//69vKK9RMwUA
`,
},
"/js/ace/ext-searchbox.js": {
local: "web/static/js/ace/ext-searchbox.js",
size: 9917,
modtime: 0,
compressed: `
H4sIAAAJbogA/8xa/3fauLL//f0Vrndf1rwaQ2hot1BnD1CSkDRNw5ekSTenx9gCVIzlWiJAk/zvb2TZ
RjaGTffuufeSE4Kk0cxHM6P54mDZyHDQCHtIU+FzCS1ZiSIrsCdDslT1L2qAvs9xgFRdRUufBIzCpxlx
5i6f4jtcPCw5ZCaNXMsbS0N0jzwWjadoNSRW4JQmFp18nVie46JAooV1qt7po7lnM0w8DelM9woP6pwi
hbIA20yt31uBEpiA1zAS4QUdSzMhgIJOpSkBoqATUzVA2FdxRuVhaNnTcUDmnlO0iUuCmvKL4zj1IQkc
BIN9f6lQ4mJH+cUe8p9opciIX1PKikc8VJ9Zy+ICO2xSU15Vqv6yTu5RMHLJoqZMsOMgDyiCMfZgQ923
HAd745pyAHTRoBjg8YTVlNfS1JAwRmbhDkIx10VNsYYAZc5QXQgH6h9F7DloWVPevq0vJpihIvXhdDXA
Fcwst/4kndVw0YjBgQV+PkgOEM0FloPnNOQc/lbF33pEm+YWYk7YZbdG2xPO4oCRuHiUYvh1BJB1JZwJ
kO/yv3xqQ8SrhG2eeUDtFvDmkCOtJ6o8yLPMBoRw7JGZxbh7kDlz4W7IkgLkZHZh5Dp5nhRaJKOCbQ6V
KKe4QMMpZoB6WaT4R+grEQuYqhdn5Me2tS3TskomSMCoVLgy4sNJbllW3sBK5M2Vfa6ztfPKxx4yT5eN
BWNZB3CPRqNR9nAp55NU4dj8p27PA8oV5xPsMRRsR55zn+SLEiDXYvgeZQHXXIuyoj3BrpPFLi0lHgfX
TJgtx/cir8pZz8p0MLWGLnLS2gnVEZ8XArA1d1l2a8qn1qerlv+X/9alRTgH4prySPQxseCbTUSGH6D7
FG88s8bgBvPA1RyLWbVwXPK9Mcig6PWBjq+aF91F+ex4TBrw+tgbTNqDMf8Yvh21Gjfwp3kwtfav+MTx
5+7R9Um3P6zclp3K0er2stm8PX6Lb3vN0+H1kXd7dereXHertu26n/iG90en3fbRAH30cW+w//F20GiV
XrfLnfKq0bqh05ZPT/Gqd9bBN+Xe4HZ6UD5a9dvj1rfj8dmi3wUU7cbl6aDzqdV++X005RwbvcHVRfes
2rrpdMxCXYFXVg8eJLv/Nj10Ez3026CHy1arVH5/vuo0zhbHp+eDxs37Nnl1XqIv2/79eWk2PVu0Lpc3
3zrow7nV/kA+nDcb40Vj8GZwejHsn9H7xvN08dV2CaTYlIv+HTUc8Dc7UkP3ilSbfOK27LYvr7oHlXml
N7gMGueNyft764f3+8W32yZ2W9Obq6slxvT3k4NWv3wVNE6HB9cn/Vet6nJQsSqdy9vPp9/wZad77kzb
5LR6WVmdf/dH7zvk5eebg+nrycubzxers+/9zrdqt20tXfKx4ZSX+GzWYLR/8v36d9qtXFdHb8atedW7
Phr4V99uFxxZ87Q7qLaD6el4PDbNwvoChbesnM2M4bVLh7S4anhd5T/bQlgYJuoj4vG4B3m+xN+URoAh
SceRLRVsee7lAfJtlEilOMfAbYuWi8dAZqNQSnTbQw65lq1NeObLLXci4FtDzX4ZDp3KaE+Z2BkFlAhE
FUBsUIirJgUlQTGcQxCFOBdlapEXeIDPqjHOilAHBkWKXGSzKIaGCTFnmuTS0pzZzZmNKoFAVYXZCrRv
vMkpPoLx0NJAT3r8WzYqrwprmwHlsxM3vKSVSO9D0OO0Lutsh0ERQgng/fQmy+ZpcWvVK9Ma9gTZU7TO
hjHhq1dv30Jmz0qIiiHic8+hD5naiydG2W/Fffj3WvVJ1edRR5DfhhSMExieiJFuSd1D2JYU6oGBZ7wH
alHag2bEG2skbF2+rjumQtiejMzf3jn4XrGhqqCmRCIOrh5yM7+LvJ+tfGSqYqAqVtj4mCp4HlI3GSQ3
Wj18VxJ7BLNccWFFK6SFRNjz5yyPjJewqhJe1wlxwdym2hOAgYOqUB+5bugQpjqyXCE9ZLbmvfM00GA6
H8H++SdSeHjIHOh5PD9B5NnCkwelv8Wz4br5LFWFYebCrobLim0el9RDIE7boQSGyLWI3NT8TZN0BQtl
gdnkHzBKhKjhOUd55lmHb/UwkvyT2owFZBQqM36+/tIBRtIgtLxeIpKR8dhFXTRGS/+cZK5QjC8yI1C1
l74iHF09NP7vXYnz2sm5BRVQD3k8Qd7vZJ4iTGQ0rGfIuAZ7o2uIunSXgJBK4WQJ9z//HErshSrF+29G
pHStdPgnfVka6+qhWtBdM/ukhUcvbAaGHUARhNoumkGFoanAA0IbNrDnoeCkf/7BHOlsgqmBBIWJjREO
KGuFvVW48iv2MNMKYkARazuYkUBDhae6lkgtPKSXJTyFB2QImzfJ0uRkOjJsqKAs6FkDw/J95DmhPE1G
EglEgh16ksBEp6EpIZH8WA4yvs9RsOqFiQPgqtnnA2okINLn9j2p+56ogfO5EC68W1bs54k47qti5+bG
L5EDZb3/Lt5uy974PC4pB04YLWLffB6TtSvfpXXQ4XHKTCt/p+rDcJjWvcRjbY1nMJF9wpRckfs+MmVn
qm86D/hMmOKF4Do1oMj7gClD4JRwidQZgcrDIQtP1WU3Aw/v4xkic5ZyfkNUZOFJjBGx51QDeOWCDmph
xP8UQJk1tiImT3w6I852sT1Ni+LouGEYlGCIPT7CNQrsCL4emJ4Bsw0G9QsElPCpL9/Iq5u9PfYluPuD
v2mFGjN+jSxjBWdDuHmzGVRGFBaBbuuagZbI1tjuA7QE/RlaSUeRIpGnB3EksgyovVrgyn0SlVwBf4ib
AcDT9hmnC/lqno4LdbK3R0I0e3saycBq86fBAIgjEiYmXgvKwDGCQOYg11ohp2W5btpWXIr2Yl9/sb9p
iqxr62qYiSXLcA6JGINC4uYP0bVK+TnMQtfIMJNcB/Qhk6dGxr3lzhG32QRqT5fXn9oWkfK9eo7MFP1z
hMY3L6xge2sDmh5aKHPty8NQGLKmtqmt6p41QzU1Tazq3JS1LXnC4GUzSHq6iw1Ls1I2541IKtUe1BYL
3OLoMfIk/olPnCQTIuwVj9Ra9soxuHKYRoWS+UIa1JEcnyhbuchwMIWZlcn+UNWayvsTONgXGMk6hRVJ
p+rdOkIInMcJrGM1o5G44F4T9yZ4xKQt0ThvI6+q+UZE04rOD2IoVjrs6CI2D7wMS9lpTJTymr29ZAyl
Qga2QChYZmH+JM/4RGHp/q9whHo1YRp+ftL71jDFStvJ6w8k35NaerGQWPgpx3+l0EnhrojbsVHw6vEd
elhgryYO/MjfS6o+s+ya8AYxnXwsqU9590quOuIHAty18+ZBKb/SlWdH1Q0/g57CmC6dc2C2QpidHTA7
+TBzqhsZ7Y7lvwQt1eI5iJsh4uss4uYa8XU+4kwZJaPdspSDdB3j1vNyPRPwurpFaYv3ENpGGQnFg2Ct
bpaYsdSCnsMkgzDLZ8sBclnlmCbLbof1ovPLeVnMJElns9QXjQEgoZRzWqcn9PgoE0QXD1K2UCyoJ9Va
wNiDphw6kbnvQKvUtOzpuRVMURAG6ARYqsOKizOZT4g+m/FF/tQf6BT7rXkAsiBU6Pyx3cICX6wxfRFY
fu1FWRdWq221oJ7SX+2vVKon1qvtMuYT/4f7Cw8SfC7weo6pkxwtHplF/2JVoVRLqfUrmkHbGD6I6cU7
VP0hJK69wHFclMuKtbJ56jCzzaVwj7LkHnFG2E5alkkhzm9rE9Ym5MlgmxX/YzZiEFD+CRuxn7ERy7FR
PBHWCakmbsMGkQxoUrrIci48d6UV0lczTu4bNas4WEaA9HjrmbK0nxGWdj6tkJWe9p2fO2HiU9sPyVW6
KUA0e5lSM6oyZTnQWzUBObRVIGJG7tFZ9GA8egiu5ZfraW9IilLhQhOyyMS8XZjU7NOUHfVxSLkusZkO
vr3lzplo82lDDHRzQfybQCts0w3UXc9UzFMM8ojLQs5m3HBgIVSEqBGjvrwehDUprJtZdNDAm+aGF0CB
CCEC/MM1/IAwwh/AAn4juY+mm4xyU5DUND0+8sbI5U82vNB+GkryIzhpH/y6y5tWriBemdb/R8m8pHZA
edhY5S/+PbPoq2Tal5xvmt3piswjT8hTQcvM/n8AAAD//7n7cuC9JgAA
`,
},
"/js/ace/mode-bosun.js": {
local: "web/static/js/ace/mode-bosun.js",
size: 4402,
modtime: 0,
compressed: `
H4sIAAAJbogA/7RX23LbNhO+tp6C4e+/EiWa6m1jO55kUk8yTdtM7NyUpB0eIBERBdAA6EMN99m7Cx5M
SpTjNtOMFYIL7Lcf9gQiSoiXkgVlZGLDeL7mKZnHXJbsMqPLLIefuhRlTqTt+rYgVyUVxHZtcltwoUBo
gwZMwwDVcxrPOS/qNwOmyK3awgpda1GyRFHOJjWoa9WYrlVBOtb9yC4lsaQSNFH24Wh0HQkL4K1jq1aa
2J7XGnUOzYJzMPiusfcJzfXWDxNyvG212uAb9MYWYEsfaY72cOEy53GU46SdZCRZnaJRwpI7rWQav+NS
6aWIiowqYl5yvpQqktnPeSQVTVAmdaZU8YFKRZi2rdlob8/OQM6iNdGC5NFdPSfXqjAgOPgsiTAr8OVj
JOUNF6km64jmp4KvNVhR5JTmRBeULRtcHL8tRYS70Iyf5YQUOs55siLpx1K9/yh1lOf8pn0r2YrxG3ae
CSIznqda0TV5zdK3gN6AwlTBmSQf6JoCORKJJDujLCGtNlkXOSpI8E2eZBqghPr86cMv5A5DbDxJ2euc
CAUi3Inx6DpKBNeq0U4EwN9EgumUFISlssXDmd+4oguaVFszzGxc2xPXfOD5lUP6p7+vNF0yLsjnegLC
Y7d8uqpdWsbJujCxJUoXgjKlE84gRur8riCaQVoZR/FS6Zin3U02vugCyjL+SpKtpWck2TDtbzjJ3cHS
HTAUerjnia2xZi4rG0B6cQpJbVhEiAwe4KuyqB9nRFAolIZSk8mtSiN4E7G0zfN2OVZAuzTGJUkWsSUE
kpfgsZQuFvqqXR2XNFeUPdK5XkKcr/WCCnD0AoKUQMnkQmPl6BzqYR3d6jVJaQRD2sS8ICKBOGDiS5OD
ssRiECRaQTGZilEQ/6XgsMsolhqKpuCQQ6ngBXDDR149WAQEpGbXLcemeluSucQ607k0W2rXQVcTzRq/
dbLbd6D76CC3t3u3b6cTOIBXGZXevqg70j3WHywVyrZeWj687aFob0/xFWEvLXtVRd92jVSQJbkF6cUE
nNX2rpllO/UCzFyYB8rgNihoRmyUP7jbyLBPGsU58SgDAuDpDRv+ftgHbRR2IfqPZKEkiggRO1pdYRFB
KL3cPBQcLBubqzKZdSu/Tut+R3EmQSBnzsQ/iA7+fH3wx48HP3mX4cyIndnEvw9rvwyybdkM0TZkip2k
Nzmjxakzgd2IO6d+8aYVke/iUcs8DnURKS463IYp1C21IXFsePxb63AWQoLtsIQpuN3kMBlb2zvt2vh9
wJb9lBvb417CXV3Vq54PYmHijkOkNp6cvIS/AP55joaRfzFGdmMzieLQcaYnRoYqzzYw9r+EBu5LOHVg
PH5wrfncgm61zImVQ83tBrLWRCwJgChRkidg98euhV7A/cTfckPKEy/h6zXWUh9zfgGB+J83nQ+pYZOA
wlceg1YBX2ub9T87CE98LKlwRurBNAjiQUdtp2kPKwhmOggO4DfFX/WY4w8f/9dHR/rVK/2DfgEiDb8L
/ZcGkT461sev9PGxfnGsj2AwaLtXl5u5EAT+5H44uJWe2KUXOg+DelAyZYEfvV7zOfnN5oAZ93ikmArx
J9ATuuhwOJL38BHGJFX0mlQZYiIO/xnAXlcfPCy6C/oUvOl+v5lXZ06bUZWBtuAG0R87eRd6HuwH98HN
7EHD4GYWxPNquihltn1oWP+8C3SZ1upw+YnKXJ33UcySaiPxkxsZruq29r507Fstgee3B2827set9cGT
bu2cw9hOGnG/Jqtz7jII0nCGhCeh73VlvhM6J/YQ/0H/77B9Q1VmxQIOAdkzf3/St/ZwsjOp6s0/HI7g
bwQ3PTCRQZdRcjJwN3MHLoDwlTuqb5fe8HVuQArmUG/3Dfl7bsTd9+Hr9n99Rf4VTG9fjOEijBOHT9x8
OxrDzJ0hH9fUaqu923P1HfvMkGxmAAK67YYwYJMB8H2amntEP34YYS+BS65B8QrBFVdwaeumS024cgom
xN8BAAD//xDH9TIyEQAA
`,
},
"/js/ace/theme-chrome.js": {
local: "web/static/js/ace/theme-chrome.js",
size: 3036,
modtime: 0,
compressed: `
H4sIAAAJbogA/5xWbW/bNhD+7l9BOF8cQLIlWY7fkA9Omgzrhm1tlwzdPAyURNOEKVGjqNhG0f++I6U4
jizmZVLL0BTv4fFenjsck35CViwjvS7MB2pNUjKI11KkpOv81ZXk35JJmHbJLhdSFTBLRVJyvaQFOIsG
iUi7fztoVWaxYiLr1UIOqmUcVImco2+dTr3WZ8UHLDfoEq0wL8j8sB4XxTXHRQFf9AFurcuzDb+TndLf
+08bkJ7/Q0uliETflp0IxxsqRZklM3RGIv3Ol51YcCFhYTgcwi/xQOSKiy2aoTVLEpLB2vdl5wQ1lyxT
boolZZnG3rJErWfIz3fz5kET/Z7CPFPIfdTi1jxPakUc9lh0iEtZCHOzN2xm2QMrWMTJ0X5Jo54/9R30
OJzbThJZoXCmzI+oZDypbn2EM5k4aBw4KAgv3oTCcUZLTJvqaJjpe2BYJLHcN1Au4DYjD4bQBgLmwJwl
7V4wdhkNHQQQ3vmTM7ZrpogFcCW4QWv7VpS5jtNqX50RTY3hqLFW267yMcqjDd5972MQtc+J89pBOu9e
2SOAIWQzrLwpqBFAWAVBYFPmAUuGISSrjMISp6RO1ZWA7CrUnpMZU+Co+OCEs9sP07F/a0HckP1WyKRS
KycSK3GqWajNDHHmD0f2GEtT8sy8Z8HwggThy/vNPBHx/5Wr3ILpO+SPciErUyJZ3LivZ8I48Kx3ffRC
Qy7UDhwGOpimNtFdyt38hFGMgfVgJxS4M1P7Smvwui0zzjx4FoEFZE0w8BBtHg8qj+HCI+uFOSuOPGtk
JiMH6eQJrYkDVL8h0uV4DxFapQDh5KDwMeVXiDr0/eGLirRgKpK3wQWjwCDVfPRWMEBpVe4i1HmpHexZ
XXSKB0wbb4gxXVX4ZsiFgoc8eN268kHyEWnqICqEJtiqxugwqoe3n4fBug/E5dCJtNwC15Gt//W9sQ22
Kv+uFavifCj3Z0ms33e6nySuJpx2n+m8qwYTAu3GCTyTntVeK20Dj0GxbGPrmvLaPgGd4hZKMS4Jx7pW
aI6e2A+FJoeaqSSU7BoQVTjqiHxJ/Dib/YW/WFy8TgmmoFQhoAAkKhVxNU0cY02nYehNrdUdOjfl0pIl
J6FTSt5bdhOs8IylYNNBntF5hAsCScHur379vPV++oGKBTy/fLlb39xRPb3Rw/X14qv+8yeNvmZm1eM3
n+4//Zj+8Vs4gGcVRj/z/WBwtV2k9zTxB1vfHxj5q4+f70Y3cvORUnp5ueyeI8noWiFJcoKVu68uAi1t
B+gYQfcMvWzdM/e6/f6hpz6fd+BPn6W6+l4XxRdj5F6jET602YfWGeS+w///AgAA//84/uTN3AsAAA==
`,
},
"/js/action.ts": {
local: "web/static/js/action.ts",
size: 1364,
modtime: 0,
compressed: `
H4sIAAAJbogA/2xU32/aMBB+hr/CoEpxJJayV6pOqtCkoa57WLe9oD6YcKRWgx3ZDipa+d97d06KoTzF
/r77+d052gRwG1WCWNyVQVvzWNoGBLwGMGsvFt9fGxeh/8NB2DcwEz44baqb4aD14JLrFrxXVWpgbNCb
/UysrK1BGUReYO97g+UTAr5dbXWYCZmL229iZ/UawZ2q9VoFePDVGbP11T8ik5iH4XBlfWvm1gRn6xqc
L8qPs8xiW/Pg6mwiltmVp27wmF09h9DwobalIiO+ONsG4jetYU8ZPWYnAk0Ee8+EqYrFDzw9gtvpkvA+
WOR+drcjz/GZ5FOx+E2fjs9J5p1ywoNy5bO4PcYrIiRzlCGWVNAA0MSBWs+tfdEgx4pr/ELMOLGkyaFl
DMG3IxenhGxwbQL3Un8m4pwRH48R/cCTqSEXx4bdXIgnRyepc/H2JuRZ9BGFpw4OlEJvhOyKxxVilVgm
2qdjX3hDBzYeKVO1tXKF9nfOqX3qHd0Hne/yyNBCUr7BJ9EzZHEnTFvXVFPfk4dwD3uZdapTRLSiD1cu
oPaQatCl7G7VBe+u4z4+v45LaiZi80bEps+lTnSNu8Ki5ty+g9A603dMYmI8hbmY/cNPPdmeCaF/+cUn
ERl96B/+6QiZu+cHn7TP6K/ux3CyBsQcqJ4SFzrApY2enOQWX6fTaRwHPcaisT7I7Fo1+jo64Syop5xS
opZliYVJyVAvZzrr1tXoziPASqIXOGedlPxJnBT+WkKHduY0OPwbPeU37wEAAP//2k0Zv1QFAAA=
`,
},
"/js/angular-ace.js": {
local: "web/static/js/angular-ace.js",
size: 3284,
modtime: 0,
compressed: `
H4sIAAAJbogA/5RWT2/bOBa/51PQQhCIXYZJutjD2hC62TTtFNNOi0naHoIcKJGyGMukh6Tsemx/93mk
JEtO5GLmIpCP7/+f39PFq1cn6BVialqVzJxX8pxlAp2j+0JaxKURmZNLgVhZ6pVFa10hpxHjHF3f3CLB
pdMGiVLMhXKWek3/WwpjpVZoeUlf03+DqteXV/85v7w6f/3f8F5KNUOFc4vxxUVnlk6lK6qUZnrecGVC
WYE+fbiH+8VJVMHFOiMzF00aMTrXvCpFHIE4eB2Rh0cMCpR1TDlPvc7EjVa5nEZks8N0H07zBgKHTHml
4F2rmOGNzOPWjLRfFRe5VILHK6m4XnlzGLvC6BVSYoVujdHGaw3ZU0Jw5A+QqpU2M0opijUy5foNjvBk
yQxKk84WSUn2zN7bxlpGvbwwX5grMN54SZ50LlAj/qggqDiCy0VWR4EnnFoB8XeiETlQtBsy1KjCZ2f7
M821uWVZEffzMmCd4R0mQzptoVfvK+eEAbUM+CGNRhjv3t3+6ZBvUA/U/rthi0+ae/9SL/+1Iz1jOOrJ
B7WUVqalsIPedM8v+X+ik0Pnv68kH9D6VtpFydZ9niGxYyHf6dzds9T2Qm5JzxiOuvfFSOU+MTOVKnjX
hNojDzAOauPSMkjFnWAmK0KTHFC8chjdOVPcUoCHm+YcP2wUm4txVEFvKh6RFL6/ivXY99E4unGmPH8X
kTnL4FLLwH1HxA+RjfdthzdGuMqo0dWOGMH4Z1Wux6PL3WPf1zsABzUFV10BcNSGe+8v9XwE+kX0r5Zj
SHbea7HQW0HSU4Pg/GiD5dJY9xEuv1XzNPR7b5xr2gDXm2Do8yJEGT179VP7XGDcKX3XZmfI+D/UG2Nc
45Ig+eQIEjG+ZCoTHGOAhVggqVCPmCd1oQVZsrIS4+7pQTzuCOv5k1PPSXIaOPExe+0k1VL2wOzzt5fW
n3E0TvSn84g3rSst9mU0g+WXsmxmu/2Q4s1AIVKf+ICGu0ndsNC39c4aR7fXEWkAcxy9UVPfXWVE/Dbs
Gj0jnIAvNdJPSUFkwjzUbrebHXlKWpvih4NAYqBJqOWpANdjQcMqw5jM+hvCr+iYP1zCqJTJjE4BAIS1
YajIPOlNmLfIEkCAKuxykCBpcm0MW9OF0U679UJQ69dySEi85yRXXdK6+rGAEcG1a7tWWdwzBQUfDaSP
Hd+ofvkz1KpAzKK2KBT2HYPMQ86JSjZa3RSgWoz7K6uuBepXr96kpc/HN1/3GE9G+XbLkyTJ6elSilUg
b7cQw+miYLY+Gq3dAWEwPtAA/fWtVRJzvx/nYdHP8G5HtPp/WZmfuog3nt9z7yaCnurUCuP/Wzz6aUC/
w3+Vme/n3xtgjEcjtt1GEYQSFnMOUAQeQT/PmV+xli4qe7jTj/zrMLzdqqosg6bawyg6HNfP6RP8UgXO
jhi65mflzJhS2tVVVUgHHQh+JOHCvKwvMEPzMCG4GSXEfCxQgjDC/c4tffR1pvu1g9gDpOn+rxaHwR0l
CYec/N1xeuoAIHl4olp91Iw/kvYE2mRzPDvr8dJK2ULmLm5fYQABf+Z6KT5KCwYBdaMsNGtEpphME0Xb
7o2f9kcv5TG8xzl7oSaFdopIgUkRlPjuCir8wfN7BXueNJ6RkjxhACkIdsUcgFwTLdFkdImJjiUmPEid
cg9gut9vdbsFDIE+d3rxPfxZxt5Qwx37vtsrf7HGHzweUZ3nULfvkruC9Ai/CDktHKD1gUHAUfmniOvg
GwyvFpw58Q4aFOx5x2FYHvHk5OSvAAAA//+Szg/H1AwAAA==
`,
},
"/js/angular-route.d.ts": {
local: "web/static/js/angular-route.d.ts",
size: 2153,
modtime: 0,
compressed: `
H4sIAAAJbogA/7xVz27bPAy/+ymItoe06Gfj2zHdVhQbBrTAsGLJHoCxmFitIhqSkiwr8u6jbMd24m2H
rp0uUUiK5O/HP84ymG5LAkVzbXXQbD3M2cGNXawMOribwP/pGxjZxVdeBYIlq5Wh80Te3Tt+oDyMoQih
HGcZ1k8efMpuEQ0+9nzOtmO4Y4uhQAv36B6PDGovXtwsdChWszTnZTZjp/0W7SOvs8aWzDbmqxJ5n8Fb
R3NyZHOCUly/O2lySFUa/Alk75PK7iVPzPuQDBg1Uf9zUZo++PMXD6oolwBtRLtIq1jwlCQg5yVD1f6g
QiiFwqWfkFvrnPYaT7QvueLcpwd1z7DUWcNPeuY6J6+Sp7aB3Byl/LfDfOFp97rs/CUvz+bT8Vorcv+E
0ZbLShuPI8OoRudjWLNWV508mssco91eJa1U8H3GLVgOgGaDW9kEBLhGbXBmKIVPsmu09QFlhi8hXzmZ
5gAbbUz1pm/c9xkYEHK2wbEx5EDWirxCXz2qdgoa/YMUiAglZb8yAXge7/XkYl5omaLWZxP5egy3H+pr
Bb+G1/bRs2t1uinIVouVy3oh0vfSoOzD+OeXzPco74BeN/wONTf+WGdxSSLzwQnSThxoKZHDn1TfnDl2
JhSyWdNQrLSTj8CUh5rYJl/shNDlhWhnzIbQPofRhszTpkjHdPULJrwGssoPSTSco5H+7CTxnPmcS5Kq
T+Lv1aFuz8eQqV2vxctq6RzBj+BJTTtCD300+Af7q2mXDkUzf62iy55DQW6jPY16CchUHnrqMsouLjp0
FzAttAcdp0ORz52u2rJn0Ltm7T128Sh+afdoLut52kf9Tfhdskt+BgAA//883E3VaQgAAA==
`,
},
"/js/angular-route.min.js": {
local: "web/static/js/angular-route.min.js",
size: 3933,
modtime: 0,
compressed: `
H4sIAAAJbogA/4RX3Y/buBF/91/hZQ0fGTP0bnDog1TCWGzTIkWCHnaTvnh9AEXRkmJZkinJ3o2t/70z
+vbepX2x+THfnPnNaPluMr1PgjJW9l9P0+Od+CDu/jqZUs2mH27vbt/Dz6/Tf6ZpEBs+/ZRoMQ2LInOW
S9Uwfc9FaoPJ9HOkTZIbZ/rl09fJu+WEbstEF1Ga0IQbfs/Ov5S5meaFjXTxi9tdTl9ozgO+Y2dritIm
8NeQOOTjwz3hhbH7KFGxc3PLMxulNipenV9vb3lhVZLruPSNQ0xs9iYpCI+jZOf0ehXX3ONbfmLnXt0r
ZedsPqeZsGafHg1lPJNJGcfMDeE4FDMfDUiBjoftRQwXOxEbBeQx78WDoJqgQhExjxvqqld1BIqjslNP
5kKX1oKF83m/FHGqVZy70ZYaEeV/N9soMT715nNPzAqzz2JVGNZJUGKWmBPY5A/C3FieqDfY47PzTsC5
sdTnaAuPLxc9tvdmrKlglwsYdAOizVHF9T6grGLua/0bSl/kOs2M9FwIi9lHBSWzY2RODykoSYrPqfKN
T1h9ixJKVpkY3hj5J2h3yGOe8UJ6QpVFmmubglElbNMkBubLhRAX1INtZGbTsjAPISSVeSq1NnlO+JG5
EMSqGmL6g5r/lS19hrzHFPlDNnTR3HUh5Fswpn0ILcJiH9PtKPoukp+koVroxuecMuZ69Q6dMRZSAzia
OCkQF9DxLd8yPt7f50Cv1tdHGwlUWviqUBCHJHjo74YV4TWNDqPYB8Mp+//kzD1RhcFLpBH71C9jQ0kS
PGKcCV/DkmyYyGx6jHxImfYFyDhf+rDnTfSaoE+NMC8QDJ9CSk5pvxsxVnxyBslFWrxmxlEVA+NHlRGA
ONM9hhFa5eYTQEeSR0V0NF9UoUMI5RmeMsDa/00VoaO4NYF5yUAa38mt2JnXXK43roLasAbeSxu6pGuI
zIYtA06en2d3hI2unpds5dDn04LR9fPq+d2GrYBulB4GwAKcVJKsiJRSr7SDVeRqSd5dHexEVuYhPSdq
bxyPpxkKQIi6AU9dI02d2E2wCFlQtSLEMWxB6MqptwBZhC2ons8JFYsVI8BA178vNwuG5wr5gZyRbl2N
HVk/L2do/uCluxVNcOSjCT6+ZJT8ThZqQWaEeysSEVTX2jPdVhj2nTxXbhFGuTiFJpHXRbJbq43snxVe
HYv138mTUVaHAMQV4Kqaz4OamiGCqe4xJ2QJoVJrBXCZBEX4/m6zUiIvPShTesuHY+aAfUvi7tbetS4/
skYXX1N8Zygm1FC1pqO9rdVpERp7inIzMp2de4doDX+qd3rEOQtMIdeY7WnxhGVLOJkhBKAQXNdl8Juy
ap/j9oA/UfIdjEotrrH74X+HEg9Kh7WQXI+rp2s+AU/4kYejYorbvuDLDAB9L20P6BBJfz7fz+e+mDV2
QNrtu/V8DnE6lIBV1BcZ1ERjJN+PNgwA3RfXLwZHJUMiJJB+u+BQd2n2SrsL7jF4nplngRMKsugA4VsG
SAOO7SGzEdzRxstlz0p5c/enDC2GF8pCQ574wMhp76L0GXo3PDPgITalJ0DxJKDjG7bStWO0uDrmnQOM
ibz2j/YnfZEwR4vSxleM10FrZSOotlIYG/Ezvm0SyWeiwP8RuGEEmhdUo8ytOCrL0/hoGD69a8Q2tR8h
OSAVhh5dI8xaY84PXrNVICAtYeEEIkqO6c7AGrFk1K81PF3fmVZ4849Oqoagwr0eIsGcq6FixPrNxqwN
es/v4YknvRE/92SINn21ZV4Y/xE8K61GbqDmV8KR2RdxPQ18HbTICRSvTGrHPH7WWCbOsXobT9W3FVX3
NOgVb/xG+WroylIPWCZUHNdN7q1UiLIvh8pCC1srsddL3WW/P2T/n6f/m4kE05lV/Od6fi7jo7UIICAB
e+GoG2YtHqirpNkNSrY48CDFARHiIG+8ZhvILovdQ9sR64klRnAHyq4rMFgHsttBxhpNAxgtQRWtxzR5
BxNs0GKzG/4tcxeLsNGRyMMaUZxbSfI6XQHfsaun22mwDjcr3+jUN98ePz2k+yxNIAgUz5kzwT83mc9x
RorXicB2uZGWVQcZN4PioR6Z3fH6IJU8VIc6H3Pw/Ny8jzMutKFkAeL5UNQ4aMC41UHnFiuozRTvctmt
UcEGRnDaLnvhIHMk5VyNX6cYD44wbwwv1PZmkWcxjsYOYWP092uguAUA95nXDAyqgdBaFkyLYo+DDk4m
OJOId2wJAqRZ323clkGvtxvWbcz6w6ZW6PrwvVOYKd5WIxfF9zSCSRqmBVRQ47OV5zoWubPjTVNwRkAG
JLduO/7f56+JpvD5UvUTedcU35RA3Gu01QbUJ3+YIbvmORnpGnrv6LAd4quqFtMANQyAOKb+B74zCH/5
yfkP5r6Itis3zbweXclMJTpM7VP9pdHsoz22r437Y0yvIVejuObQo6G5EwRu0VOU+OmJN3+i/dZl7mS5
/Mu0wcIvKsugHr49fpbt9fuaXcAHq4Cv4r3KJv8NAAD//+q7TiBdDwAA
`,
},
"/js/angular-route.min.js.map": {
local: "web/static/js/angular-route.min.js.map",
size: 9904,
modtime: 0,
compressed: `
H4sIAAAJbogA/4RaXXfiOJO+n5+RM3dhJ51O0knPXFmyMA4QIOSL7HnPHgMOmIBNbAOh9+x/X9VTsmSS
9Pv2hSJLJalU9dSX6P/942gb50WSpUd/nzX+OHpJlvHR30dROtsso/y/8mxTxn+tkvSvRXGkp5dJGsts
k5ZHf58S+Spar5N0Vugl3j/0L/LasjH0vEFDep70qPWpGUpq76h5FegvBbU/qD3ei1LKxkCTeQ3leRHN
hKC6pmaC7pSaY158gsV76stLv9H1vF7j3pPtRtvzO7qn2jRPxzfpM2g3Aq/VaYy8sKe5u+7rFW0+kRmV
ltEBurefGN3xxzs+rvjjJz6+U/8+92sXiKkJiLmSKVv6fKkgDk82esSaMuLhYz0+sBF6zTXtGgaK9jhc
N/zNupiWLT4tewZBRNJhMqx4YTHy3Ss23+X1IRd+gbudEvchDfuYxNH+qwipz4LhRWgSWtlJafhuT+2r
OBPKiaVbnafJQ08+S/oeLnibV7B059PYd3EwqK/a84IT2t0L1zyj+bs3Gn5s6lY96YXNN8HcBISBXFgE
JUDKmVZG6LEQvUd3RNsMPfm4Yov698saB69iek2DtPnD6AYTMbUjOtp7VtQWwuHJAZ++5dzPLddfaKPA
zUqQnAsYyYWg864kPn4CQzs/wwkbYdV2gYOJ+FAkmuGegy6xLnvQXJ+6Oybn82i7iqURWCLY+O90iFK/
mEb3W1c4a0kX7jJyaLg/w5pSTvSfx+enSkpe3MXKKW1uIJfQZvJEX5CIZu7clWhkwvMAHOnNcT8tXzeN
ozG9FcdgaUGa3Au1FhUnl4JYuBAr+Y9nALbwSUp+QiyqhU+7NPERLHyCRQsf4cKfYZeZMNjSAnr0roGZ
9sIHIkdbntKw1tb73GSUkoxOxC/m4RxaBMf3DQ1E74GRN68Ypst5Fbu3b3R2Z02tX1B7rk78RDhrYTXV
XNMjuk/sjdKaO5ph75Ov/GCXXMONnghk8B/dnbXMUxF9sgESkhbjqYA82J/DMNX4GZc6NoZEDjsV1gzh
t7UL03PhApLqHQvrMoaX3J9Z74YgofopCzUjVWgEkz9zNtTTENT9mxmLoQsRd8JXaIw020lEy54xMpbO
ez2zxHizOeuY+tcccGj7yAvpxJZaS7tJd+JmPfIAAVlCaybpTzAnV+azkvVB0kmisRcmdO0lWPrFQACh
oX9zl9cSrZZqqNFaNsHMx2LApU9H3nuptMbWxj4d3SzFFdG3zqj1d0T+67u49Dd8Eqhngh2Kd2xCEULI
0NjpN4YdYRkIOWXhGRY16xGBYdwg774W0nkkMi+5FbUw2PsAtloSADDJn/ABvTUg5b35NXa0FNo5h7iD
cRe2FPFGtn4FvSIKsHVwXCZxmCspHHxKHPobmvwWzmUtMN1/YLSHbp+aqGYUEPiEmVJk4v6ITUJydJt4
8p7Q5z/orRXCZpO+mxmd2T0VbUjFNwLVV+xXEVc7klJ0rEJ7jI8uoh9JKtSWBJ8l4Tf9eRV7DYEKGxvB
p6kf4itLr+VTNUcy4/yEt4No5Jlfw4rGe0CkwUHCkXCYZbv6Rn5P5hKZh00h7Krmv1/Fdx5Y1N8TIgbX
7JXuDU8eOJIIA2wPDw0bqbFs4PEKhSxEB7kFHHWPBhD02oHl4xGxnm9PVkXBWZEE2yRApbPFGm3LimpF
VK13ulrYpgTomngPI33O9Zh62mHr3BIE7Ta8OxG0wU8Hrq8b6rkbOqPXpu37RNADQR9i6RzTuuYFi7pT
aXemE66RVtI1+q+EgLlYcobVRyzScutZMUuSIWua9YDRFyf8HfTzbjJwZW87oWE4qwwmvUBCNIYkSb1n
AuootfUgFxshFOjmLRhDg87xjWrZNYcRtqyVsKZFHlXOpXPUvbmbZHPffvQAmpmZgI4rGtzIJzNV4zfq
N6kfjBGCWhTHgo5Dbg36iWBesEGLCobeC26VuryRHIO8xWgGX6P9qA5FyI58uXZctNlg34C6Dm9vN5c4
/6kev4yQqEFAik02xhtAVd8xAkeu9ah34Q189DuaDTWdCecxwkPRbcSZ+ig7vX6kPRrGyYH7kJeOqzX5
YIgFtOdxGFwT4x1i7PGB84y2zsiQ5X9TS9Z7aPPPRHxZXA1Z48iTbmsmH5pkaSYG1hvpENnjY5o4pWsO
qUGMPcOIN9fHPHo+Uj2pPXETeR4d1UKSR7PX1GtT0AMiupKwdEPdHplMn3qD268Yj2Qls8NCsGCaEu03
/kDNpMWOPxzCzvmDzfqcoxHn7q/kHvf9i2YtbD4elkkLDi89k4to4BEqVTV8yg4WOZouggiqhWIAU96q
GGKKTJopkQeu4QHeZBWL9FAuUSf8ZKrjpgu6XBu2KcoCmTNjswGNIIVCYaE43gP9OnTFXpP8sTp2eWwT
xIFiEvIrqG2bk0cMPNEAuR/fmzMXq8BqO7qxi1gR31CFcn5i8ikrikcXviZVpVPIvtVVp6n37fYgreYn
YZF9kT+IaY+XSWUcMbE2NbHywykrQceQh/jONdsZ1JWg6GA/OiHdjb26viJaPk4EFBYtSCdPXb7Kvd79
8UYPPAxyxkIRVCmYNq8nS2RcOnIDZRL2C5eKxzNn3KNntwrdH+LBCt7jTBwKpgBhw4kaO5oF+5SUy3LC
It0mVIV1bVUJNJm6s0zW+eBgxDJM5PiAXVVlxCv/vO4OMZPiHrzrmazO797AA5qSdmyvPWDfjsKGs0l4
wN7hs8eUjCB8adTdPRvd9RbpzNC4+IMUVBkprUTBNjmDOBA2fIK2ugbYCZ6qS101vUS+6l0FVUjXixgJ
8yoiW7fzvWn9zuDE1WcU1uSZvHA1Se/c5aks9Ln6DJUhEGhDlXwwRf23mrKsbOFbZGRIvtdgwN4D+zSR
vXuXKJ7CE77awetDAeLqic8cnlB+ZGAGuHYvGNmvLYuSlYCZsywJ/rU0WsXuqal6NQIqyeCaL5SCPRq/
ccDMpsbMTLqadmSc1zUlqu3u5RfMdCwzpiKkcVP5CcfNaFnjhiwrwCOGz8+b/Gg2WVuxF8Ks+863RYyX
gHZouPjtBbgUXtrXiFeh99d+x98LwoE0mqtF9NzS2ucJuG+Y4wYaHuTOWraHz2J6y6aD5qNFJnoKmQAX
rr8ULSBV+AwSsu074jwOL+S/hwhf6t2UCvfsVeRO7Oivj1AbcDqw5YwnkfYyvWVQGcEZQrNPducbCRXN
6hpJZfx0j9KZGOckYlOLme81F63VqXnrwkPXMKDlpDRDRrWe1Z9ntFwPXLcOG58Cl+Ls/avA9SaqyPWD
Q8ql8Y38GoYCA/JBdbmQENNett0tv7m8G8+Q4wvx20vq0K9++F+wsbJs/DayeRufj0K63qSX0V/8wHLK
Ofax2oozUa+36xmOmotn61XU7Q4PJM/vrc8ec1srVuseM3D3TB2SUV+8O6R4td5vmkcmUXbMxKVtMG7b
8nYTRLT1NriZ0vyTbmTIBRPVQjpehl4WJLDtdfDcqUoCDeFAozNDtkoOLdFEcPDL4A5UFGfa1kLcrw/y
tuJQ0SXu3uhSwwvOAAlMdwiAw9y8RHDCdonnndL4Pc4D4PC8jDNVft7aY43ynW6voIELrvEu/NqW1LRn
0HynMh5+0CFvokIEzW7H0ipoBu/zN7wRwPd4xRURzP5nLaCZ3OoYYiCTZk/whkqEH9E7CHrD+ir0n/pW
xwNXFVH+//JPaKp3N5gFdzUtHzRPtsduCXgMaKA1KF2tPNg5pNGzlByffiy4DnKFq88ZDT+6sOF6wLau
Y0eeukPIg2xpccDa3/GNT0XNIOBtroERn5MByGLIzvJKVs8fmnThQgLy3r4xJeVeQ/leb+ILwlvjDQaM
ca3zEUxQVZUQYPZMdvwqSjE7KGfIRPfOFw3nvoUN/yaQMtQSv7IhOV6EH80/ERlzxo4LUIOmbz0rcH54
WrrSm9D9RT13368wy2mVxmZg0r8H5IRG/5RT80+Jl84yR8fudxIKL6h7dNkT4pFNVT/taCBVv2BMyKEi
PvBvHOE7G1Xm4ERsIDzIB3Z89QNHHy2kXzGgnYj6RD77YluuAY+hsROTlQz47fWLvRFYWviJwvtJ7SMj
yhwW1mpwxYyMkbGfPmx8LYerznuTn6dt8fSz8424OtYzJ01Ws7YZCQnoqn3gTeSxf5idL0Tt/d1uJKfm
ByLNnQtTHBsBwiYwNSWmMjHGk6B34qJA3NgJY5R7ueEXDuToJsEg5vKbNxLALX7tOu0QgpfIBWf05v2d
sxllc+wNqkwkTpn0dsiXfrhf6X5y5rWtaWh3eFWTSFW/fvgEqLWEr97ptKb5D939vGmzJ459bHiv8h3p
xJJ/Vzhn5n5LXAaWeNWhv0S9D62VmV+d6NvkebFxiefI3pBCnKt3seW0f+MMdMWvtETFjyb0U8nYLB2Y
padnAhzkVrWbC6EuQi2A7QVqDP1978F0iAs9+PAP/deDItvkk7g4+vu/P/zvhEVx9C89n0Yrnt0l6TTb
HTUqMt3bpNP4JUnjqe6ns4ck3jWjSZnle/39J3ahTpRO5lk+nOTZcsnfySrC1DJJX/WfYpKtQRkv41Wc
lnRGWdIBkzLHkjKP0mKy3EyJbLKMo3Sz7kRFSUfqkXUeb5NsUyi7Po9X2RbEmzzXQ8PqiGlclHm2dzNu
jd4WSzbrqWEvm0TLwpHqXlL49sZ/lvFqvWTSNN7ZI1LwNFlmKX3qdTFdJUtvICFlvqNNmbFM1Psal99G
uGu8SkrQL7NoynNEW1Ty4wmizFIn92S5lJneOi1rKphkqzX9xxN005I2wNnzckU7TXhBYbp2+s9KIW7U
IyItlohG58lyquWBw29Jy91susExq6qzzrNtMuXdQNJ3A0k6j3PccR0ZscbvWsP8N06nmCnnt/GMr08f
dPE1WE3SIk6LpExYv1ERh26kG5WTOfRP277G+wIfWk0Tov4fQtsyKuY8yZsmkCN3oIKiBLrXm4K3msVg
w/IDZNPGuzmkUM6T4i/Tr1Cfx9Mkjydln3lfxukMnWIzLgDtrNRS2CVFXG1QH9CCiVZ0wp8zXEQbU+Yw
TLg0XLOV9S35GzVJuogJA9Sfl+W6jlUZTeYx69hh/dYwnWr58+mFHdPSAgfWnuO3DVsFqcWenMeEyl46
jKMcGnjJtFu5jQ1WNetA5DjX3xPeshLRXQbDGpZ5ks6gYG0h68xYVlFtuIErKI2Y4yJbAgA1I6y696DU
DKgIK7VhbWieZZmk2+w1xpHNTToxgtRzd/mmKOPpbcwukXch/uPp3cHO+vB1lkJREUwyznNIe2XQtwKU
4wmslU5iBDArJGftU4Ezc2O94WZJvBXrJQyjiGfGKZlehetFlqRW2pXX8Ip9OnGWBpXU7A3oMkBiibPp
GJwc/euP//vj/wMAAP//zR1+fbAmAAA=
`,
},
"/js/angular-sanitize.d.ts": {
local: "web/static/js/angular-sanitize.d.ts",
size: 1479,
modtime: 0,
compressed: `
H4sIAAAJbogA/7SUUW/TMBDH3yftO5wmHloJbOCxjCGkCQnEA1IR7659SdwldmRfygLiu+NLnDbNtLfV
reQod77/3T+/REr42bcIBgvrLFnvIhQ+wGdXdrUK8G0L78R7WLlyqzj+B6HxpqtxfX2Vzv4Ifo+aNlAR
tRsp1XhsH4UP5ZBxPyu86zdwb7H08Mty8dt8qrRUdTuhfSMNhw8cvVseH0Xief7OBxt75R78QeZcrHse
yVxf8U+mIrcBCwzoNEKrqPp4k9sURlC8AXmXE19yDd0/cQ1WWfpNzAGxj+sLiBvUSeUo60oxCcJfnhbS
elHBsSBM824xHKzG4/2IODFivI7iDBSpWitPXolXU68X6tM6wlCohMPXRb9sDuS1qqipNxApWFeup4sP
Y8K/S5r4xdapwZj61HVn0MDvBDxQhTOgnji7eDGywdOeMJMUEOUhvc7irYxBzxyXxaB4oYnwsfWBJhRH
qROFx5mdiVBb98BzA+Ejpb3tCJQzQF1I34/kQMMPzwM/mjFZwFmZbdeyWBwskYMvskhXjUqyfqjV1ioJ
IN8BZUzAmHXFWaUZsdobXBA7usgoL+Ed59twxf5UcIbcd47MQRtg44Enxl4DqVAifXqOvkxg3tL/fwAA
AP//eM4Zu8cFAAA=
`,
},
"/js/angular-sanitize.min.js": {
local: "web/static/js/angular-sanitize.min.js",
size: 4295,
modtime: 0,
compressed: `
H4sIAAAJbogA/4xYb3ObSPJ+r08hsf7JjNUCOclvq04Y67y2dzfZZHO1yb64k5SrAUZAhIAA8p9Ius9+
Tw8gyT5f1VVZwPTM9HT3PPN0j+2zTvcqDdeJLN596t6dW6+s8x87XdMX3Vej89EQjzfdX7IsTBR136a+
1Y2qKh/btqwnfS2trAg73fexr9JSjbsf3n7unNkdc7FO/SrOUjOniL6Jzem6VN2yKmK/OnXazu6tKcXm
ThZd5U7nTmkqiqw0y3Jh+ZEsSvQ6harWRdpV1tcsTk3DELv97OVh9mbnSFdaZZ7ElWmQIRyWB84iK8zA
HTnBhbQSlYZV5ASDgVBTOQ3mc7c32us/qP3ZlKTEZt8O0PYooFBsPDeykuxeFb4slekJJ16Y1dSbC17H
WViJLCtT9Pvrafs9d4QPq6ltwzCM7/fbtut6/b4eAW1m6N6jd7vt9UKx3S6sfF1GvAw7k7CTgVWoPJG+
Mn+hfYjZPEU+BWKTYLpbmGq79bfbYLvleAlHWWUli6rfbz5MjxK4c3DZZx11LH13RAH79dxX7aPvLpo4
Ds+d0YXrw5OpP++5nuMPh8LpYCKLET4d+aPRwaXrOwEGKUulAduCl7nAPginHeb6ux0b4VFIC0CCElfq
PazD5e5dFptm3xbTwxJzgMARm5C3FXYctuPhsB2CYdLG8A8V3j7kpmFaZ+JiNivPZjObX8agHT8wpl8u
52eXgFRsiEPIPQL0jlX9SsbJuSH27bd1G6HXSGZ3a0gXAG2LasPYCXoGD5WUasNRdF2oj9NAPXxcmMbs
4bXfGw4NIbxjMST0RhBCDhhJreTtoQ+TFAPL1SgzYUK2WqlUA6H5NHFo1h4fzDQ032CsIH2Q9jJv8FoQ
Qnpem9aFaY9WpWAs/NhonEhrJSs/Mh8Fots5xMSbjuYEBOrpu3b2u/8y+7sQz1bG9GZvBelGq/g7+cdK
f2s1wseDvivB7f9V5RVOT+Nm2KjZB/lCuzC69CZyfKxthHAhWtxhGE96IH9h40MhxA4+S9dNRBUV2X33
vWl4MsjRj40C2wHvO988OpkMF45TT4oWM05NeR8s9aB8pkjpqun5vGY8fL6eM/oVvl7NRQo3UlX8+vnD
e1ftvbUv7JCMflI5cE25RqUequssrQAII0676SS1jkTjRslniFq+lAM1CA5m/sRmtl2HZfpYpmP05Sp3
js7G70fU1c4y+j8YA6lDdZ0F6qoyRzh8Dg7Ii0YfhJdaGLLwYE5ZU3gdkd45+eAyD/sJsdSk2p7AjebD
8RGVgnj4ZB9zH0LcC5hFJIgbpIY2qLU36rnuNWTbrenXIOHdQAYDYd1KIDA8+BmwVjYnfKJ5IWjpGvEq
NPi09/tGWfj8GYK5PekvwyJbp4GWOHq9j9OQ0wOTww0++/2egu6lqG3oahsW/Dh1jVN+/2QGQrfRFJpt
FhPDvjTGxiW4ZEfg4PHxbvyH5y94areuosFaAEA30JHB8dmRhvsTpdDRYVNw5nc1wb/HMicnqzi9LQrT
OCllGlfxdwXFV6795QIcbE5n9+PhfCBMczKelYOmqRtnLg+YjPEHfjbmZ4bY4vt0+uV0fnYqtuDsWYmp
YiLOBA+d2RN+X9r0vVEPoj9aoyZ5m35x7cO6z1diQ3g16GzWqyWnLMGq5n5ZMQEof+OVbHq3X9CmX127
4XFknImoCRpDH137onfz8frz3/92a2pbJuLSjukty2fT65urz1ezqZ4znzdzfmdTv8x+GP5r29325gKi
e3dpGrJQyOUF+VlCUUHAFt17BTJRzr2QMqZyCgIKKkpiyqnysuCRqoCqRZZVVEX4UxJNnvWNZxU5FVVT
U91h58ADnLs3O/pGuaDqiSgntiIIClWWhMMV+6gdZRkHirwk85ff1lmFakXmjA5C2VipggKVUBDjHd9R
kNAiDteF4lc7jk3DuOicolcUvaboDUX/T9GPxKZyR+0We5yWtJI5IbutKZV3hEDkUFb6RZxXVCoNS6qk
B7vWCfBLnfUzp9gDkh7CKP0iSx9XqLC8IMYvIy8OdXxj9gJUVdu+SEmtYGVaUayDzmYsvYAS6aFfGySL
JXQXa++RdESppBLUSOVKJgmVuUyJ88dS8StLQ0JCwQ87FK8UVRWtCTvABj/wrrQOVY8JH5zrJz7ckx4u
6IaHHriktjsq1IISLBGo0ieQDqE8h41Q8/GJmhsdCh2IJA5TPCuSD3FJXggoZQV5WcHh91WS5Nh0JD/9
DWd8/Y2KpMRTSY3ITD9L/WB3UYRgYIU31JQaAQuwerOpJd5xGFXa3AQ3DopYr6K45HhqCT/WMlSUZtqp
NLsv0Fcg5oW6I+TYUj94tWKdKITcz3KNhixJ2MQyktwG+7RbIHlr1ivsF46FLEKFQxFXQEv1iJF3dSTw
WqNRG3QfB1WkkZS6QeavubKyfJzESt0mStdZBjCI8H4AHZigAwGeKWef+KTr5ontRNYqC2CiaaThp5YQ
aToXVl5kdzg/T5iSjmrhKopL6wR2ulPjZD/kzyI2Xsi03b1onyFx9/oZd6+S01Tb6fOFoJ7Rs7+s01Iu
lN0UWroT2WR/OwsOt7PdHBeOF10R1iJOKvYCcV8+wrUX3dnf6WzTXFT5li+c5USMwdj21lxJ6MjGYjK9
Gv5DDr+Phn+x/vl/AxD2X8Xs0xkYsbQcQkx2F5dzmwKEu5liO8/91y7ua4ZQp79+f1Xfum51ttr3ompD
0blpOo0LiVwLN+PyRi3iVAUo+fr9jtn0n9aw0Tl41d7i2q9To4tc7LQthi0PbAXy0GVcQhziMu7s17Ul
Mi4XkT2/KQi7vr4h6SsiqgmfVnxxSilHMblsamElHJG6CdfjCapC1J+oEpGxU9doomMMUkG5m9RVL4Xm
silnUeXmAPbCTCk5LpgDruy5fFke1b35IDmqsGH6cg8Ridi0IGGUAD7mPRbL7ql+Wc2/FHCJtO0fumW2
Lnz1QeY5FP/5x3u36R62kLFQPVhfS3iYd/4dAAD//8uomwvHEAAA
`,
},
"/js/angular-sanitize.min.js.map": {
local: "web/static/js/angular-sanitize.min.js.map",
size: 10671,
modtime: 0,
compressed: `
H4sIAAAJbogA/6Q6WXPqOJfv/TNS/Ramk9xAlu4nSZaNAbMFkpCpr24ZMGAWmxiTbWr+++icI0uGcLvn
m7lV18jS0dHZFzn/9dvZW5Tt4jQ5+/O68tvZLF5HZ3+ehcl8vw6z/9iFSZzHX9Efmzj5Y7k7UxDrOIlE
uk/ysz+vqup9E263cTLfqV3sL/gXsqaoPDDWqwjGBIOnA48HAc8BPFYcx2sOzxt4rhq5EJWegmIVydgI
9wqzF3CJa17xGfMFAATqITwcMgTbcBd+Ei7h55234Yd1Kk3GPjjgEON6JVBTMB/icwyzrNJRYITIB2hc
eoB3ILWRAnWpvOUl6jpH1AV4liJOLLihThNK+HpIHPMMBcOKx9gjjHIOp+4QncgFvDQRpEWEFDIb4eQL
POa8QKdoX6AQ75BHhuTd48xG1GlGICnFMED5oHQaZnLOi6FIHBRIXSGqh2piw3PetKwPAVAiOqShh8M+
KVU9515S1mN4BN7BYZfOxDGRv6OXXPMChKwd19A3zIjAd14Z6qkVrxsTEo9gGE3fwEfI2qyQopCwTopo
IpAgTUsgXQJeUZKFewRCJH5YGUlpoEMAAENiMRFU2reEHb7w0AzIKgcWUwumL8UxPVdoNZcOaujKATOX
vZPHodDxjKarpl0GVEkAc3t2xwSNbApLwKq7QU7pgRsyoUxRSA93BMYDRs+FuUkXJv0RHN1TD/nyjByN
QM1ElTDuJGGyd+y91kgmoiCHxQSxxGfq4M8W4TdAWPAlu9ZqfWO1xJXRdcsFsTelIqkxABw++G4dhx4M
3QHQDH7U/gHYnVvA/uArW5NkUgG4goQQ8mHMrPDTiCxvRuobWfWdcxTsBbzU+Dn8nPOtE1jbf0LbH5yy
/VjbkooYF3zHKWQo0j7RmnN+C79yrNYdDDYYRZ1/9gK1CU092HEjr9GSdj2DX2P4+IET1/h8RaIyNLo7
XsW5eyBIdJbG4FmHCAbanS4s7jm6qvOG8+9ip2EVlg/xl7IWF+LbiExIHkQ0jDVyimTeWjKHI0slShZl
wb7wWaXoVkNJxQIzhjacnbi1Z+cYRMlY2CWmC9RszK94aY6Mdl3i78WoBqzYSzhaO1FDdoCiaQMZgw0M
7+tKPkrXWw6c+mAwnSuk71lNSB/9EMKQiODIMUIhKqRIyf0J5a6mX9HcOshBDTUJdusMCguu42gCmxsY
i5wNxIveBemrj8bX++BXwH3/Hd8e97zw1z7Ye0+iijsg2j7g60UoRW/tKFQusFHEIQohYcrJlSXkGbBk
JDLjJpp1mNUYio6MgGI4HCHJU3rSeD+JEjgc35SkDxbVvRYGs4leXh/NZG+JIz234bHnrxZHTAb5Lfwy
tNBLRwLjDwA60HTH3MSvmEcUBAR47YoDU2Cp4u0Y5wJt7hwz3AWOPx1Q4ZdT2I5o2QhIdFOJ0DCWDnFB
LDmz/NPwxcZTcjeM8zdosdrGl5bmH2JFblxQ4WsqZH1NkpyVAluE22c2rO1swoswBc2Kh0w4VgBqYwuy
vQPB+qFbnC/+t4kvobzxCTR5byiluyK8qHETnZylwnINReO4iBNSgsXodFbj34F9DYzeqOq+CmY4yA0V
zDAQdfqEDUWgcSjHGxm1Azri6SA1J0jhzkGoHEgXwbXZ3mMSpOq+8kzYOWOGNLcXJkZTcbXgKiwqMp4N
tXSyxKDuaMfHOK/t4QDFM+EgUg2lgtRyZZVpXKcO8m2ACoYdrI52TllLapjyL8q5vJC511KQLklUS54o
hanCdEbkdS+FvIX8EMekl3xrYmulwLjAVPMhD/lYnuDDBT7qTUVYjyEf78SHY/ioaj5q/yYf78d8oCsR
/CkVbPkJTljGTRGO9YrDXk/CuUYiK36JEJR/VuKC3owQlT75L/SJchg2Lx108LoRwU6LINci8EAE4p9F
cFkWgcpanasTtPuAry6TvzfQf5SO1vE/S6dakk4qKL5tUTUusr04IZ32o6LxQf7QQlTZswdeS0nntpRq
vlGOkRHi3uOABCyU9boZSriFlfElIMUCpnUyEHkUiDDY1DETekBBnfy+r621oGBUMzJXqjghyIpx9HKw
8DD+uGTkpNDIoq9aDrFwQexxEfJ+EUh0evZ1ZPs/pos2xq+FswcWd/ILA33z1rY4IbaMujlQBhukNtHP
sZIl86iKezjEqYnCLDx3aBUH5n8hwWQ27oxqRYXmnvqZy0YmRrbyxgxQzr54fXCrKzVR3EpgOTrBskbt
8jNsxKlrp46lFCzDuuGi79u+flL/bs1iTYgQLGx8B5BLyOmOD4IUsO5MWifQTFFkgSZkqExQZZBWqtvT
rTXBOZYIZDNUS6JOmltjrAXyYSXUKTqmiwpMQaJPZihVZnRQVPaCYchkjeoBrLm6dAbG9Ez3QSDhNW6o
8gseHKvh+ZsWTLELpYBmQnXJSiQgTVX8dqj4hRW9LD30Quz15CXuwpsR8XKIXZkQXBFhcdLE8kBR8WTz
vShYbpUuZ4LZ3wA+UjHkA+8SakKUtSAZOgYOit8mBmAPunoUEKXlOWaqhUNtPYyxq2evEsIqVpguBTl2
a3Ta8e5gqgv8dqrclpQLa9QdzXBg6AODZL/mhdJuCj2HA57V1cfWzLFD0MIjHDp8UHgfj7TwBMvPsPwE
y8+w7GDV/6k0f8ut6qk2FY4hNrix906YlERN2Nu8B2Oh6GH6ii8hI0xd64ULtwBSRxCrVRT8uqysjvKb
oZVZXirDQ0NF+GhQEUGL0oVZoH3noNVGV6aDnDvH2g+GuWhdvkKqlcL4DLPIHd49APni6R7H4Bhe805n
GgmtrMGQY2MYeWZispRGg4Tw3OYUH4CBOtT+mNnWwr9AKFjDO8+XotHbuaXwkTmW2n3J2M5LEXRvsxlE
X/Gl1QdVbfPD/S4tom9tukHhS0ouoK5EKU/R/JQhV8+vUvfETeiJccm0/GgLqosYQX+DS3MH73OvbSv6
RaHdlppPSNAz8a66y51JkA66qPCsaB/qBYkO3HoK6lKYvXwKl7YdSzndS6AYHWxlpGx/1wS2+vWyJvxC
ER5m79Ltq0/3FDqvO+VNpa75mVSvkehKccO/H90G3uufaEzo4XRzXEZbs7bTg8PxmAgQYLExAwytOabj
W9DXO4fEYuziw9oF5rAp+3cd5/9r778UmLV3LaFTblIH/poAK3XJ84TuiVc3gpCSpxqrAel3IaF98LGK
LxshL0pXnaxyEJTH50h8Cy9vxUltfsgDdbpY9yUCLa2Ol3L5WCezqkMRlVhjVRf65CK2PxWxHYPcZ8On
yzuv8u6xqwbY8I8G1c0KWKnxuoEarjbkF6cc/SlZja6VbhqQWslHfXbbyKBlvdPbPyFv3zewWDxv4F0y
oHzl7IJQzpsysJOLJk7GTUnRsfLJ2bKJpK6aklo/9YxV6dDEpiNtSiyYFAVzzrZNjKA3TX+J3Ed5uehX
fKDJ+rPUtWH4jm/dEtDcISBxz19LUOc8K0N1CMhJ8ObLf+XEK31CYeeuvQCEBdCXiDB641UJDl0Yuljx
dvwtRrI5//o1AvupCp5z54DqalN74wJQd9GbRv6GLj6Lgv4XWB2LNXYOuPzR0FiXAPOCil1xfy/Ist7K
ffeEQNd0oZZyv6pZ0hhPy2QhrVDahVA8dOg6DP0IABow3FKv+IP7N6jbp3WZ1EudZa45wFa5H6Pywqtf
n65Yb1jWb7jFJ1QJ9vnAHCweqQ+scTTCz8CnSDT8pBpUAOOId48ZCguzrwAC0GXgX6AChmB5P7zpGiXC
Vl6JlpGm5QYhdcspjKte4n3vFaTL9RPDgot8DSSkv2yW2g36/lmJdFRZ8VOfVTBmiK1DFaD54kp6stFo
S59Nx5Xis+njyCTOJ0FhD4PJi1HDgS29lw7feAY3ioZKKbzRvdd0iILtC27YiarWwkpfgDZ8ao8B6Tl0
SUU3q6gnj77PZuTBJz7QtqCicyhnY8HtADWrJ9SACoL9X6tKSaOYVEVxR98ysBv9hexJMzo5JXvdgfqq
EMKbdVXxp5K5e7Byj6aou5VbfZ1q9HNrq+IOpZ1uIcSU175/Z75wDvW54Kbq9ApDi4xghvc2UoZV82EO
v6k08PKl88bn8m8+Zi9tpY6V3hX/fgiMAKPwqRVi8/rJfK+SG2TUa/cbgiEh0Bl8drxelQXROo+fQOET
AGVzhUIerfcKBN+WzkvY791vG/1i7UbabxKkBswoIPXjPQHtecYrtWsOvbqolW4cJqQz8DnTAAd4U9DC
e03/kcQFMqVjgwRjKkrJpxPhnsLFvsG/wyoPS01/iUEEpd7b2Tp9zqnpYrfS/t3BzrBeukiTEuq4AIbt
4PrEjW0Aj4bPvq/4UD815vzU0gL4b1zyH4DRxzTfmENw8PE7SqOKuvVrYEJ1hlxgcVz3db0OXaaH9RGb
W6p69H1PGO/FMg2D2GSLAWpayECb19wWlqVv0eEpTst3kTH/RAiqsObCfgEaW8MMLA6a+HKMK0yubLBb
8d3fXJGit8j+nWsNzrf2hhGkb5aGut8alOxPaqXCY01fxlrn9Fc2lPzguVjzXfHBV5MSp1wOlJiXdLGk
XocMrQXikJp8/Av+6GeX7rNJtDv78z+//2nQcnf2LwWShBsCeI+Tafp+Vikg1WifTKNZnERTNS72DaKP
XL1OFmG2U7/j/Uw9F/lm/aABnrI4j2D3ezFI0nSrfpZpnKifTbiKghAmdjmspuOleirQDeDbbdcx4I/V
/3WUzPOFRt9V5yE2eIGfMJmucWILKw95mOWDcK7e8+LZVqypURbtcmQmzD4Ba/oeZZNwB0vjdTpZyXW0
iZIcT8/DyQpgQtwSJ/BXU6V1PEomUzoo3eZxmoRrmiiBvaXxtLxrvwMuwjxHkWXRdh1O4Hg2GPR/9qUn
n7somHwCcAmRPU3343XU26d5NH0M13uY28XJ/Hhun7wevE+jSTpVROZKG5FmKgNutim8RckUOZtGHyAl
0iby/YfmereNJrHiyjLQj+byAzQWrkH0ohMEsj2wlAuHDZh9ReSdmZajb94m6QYwwhH7sVK+YkaNnY4Y
jLrSbs9JX1x6ftv7KdvOzwHzSut6xk4g5OHUw4D1B4dTvxcWHMSJzMBw3rTElFZJ+1ullj7MRB/RpJjg
0SzNouKNzcimJ2mSEy+LeDqNki6CxEkSZfVB0NKiFQYKV7TvRMmRhh6G/X7HYwP5s6u6TUvyItaeJhQ8
y8l41bPdaf9krW6dtYeB7PvC7thnsbKDeBrmKVAZzxOiPd3D7nGMyn8DiJJ6FX8yRNNbRegh9BPv/E04
j4oNTJuvOqIY/v77ppDloS/wI786XPWP3UqJhcxymk722kQmWRTmBRB4Rzrdr1FbWfoWT1EJvxcxp1ua
m0c5klaoe5jFRDVwGq9JfWZVjVt+uzn6Oey3rBgD5rcGnZJJhhmhDadTrUQ1asXJClGvUVqOiZVZ+G6M
/Oxfv/33b/8TAAD//+rLD8avKQAA
`,
},
"/js/angular-strap.js": {
local: "web/static/js/angular-strap.js",
size: 146923,
modtime: 0,
compressed: `
H4sIAAAJbogA/+y9eX8bubEo+vfTp2j7akLSIinJniWRbCseL/G8Ox772prk5adRcptkS+ox2c3pJiXr
2Prur6qwFbZmU5I9Sc7x75yM2AAKBaBQKBRq2b53byO5l6TF6XKaVoN6UaVz/PDn86yq87JIzu8Pd4c7
ySC5v7P79WDnT4Odb6h8mhfvk7PFYr63vT07HVdZOjzNF2fL0TAvt31w6XJxVlbJ62l+nmdV8mO5PM9P
i6xOuqX49OfZ6YCgjMtZT/Ywzoo6S179cJj8KP7uqx4vLi6G5Rw+lctqnA3L6nRbVq+3oT60397oniyL
8QLG0L3Ii0l50U8m5Xg5y4pFP1kWk+wkL7JJL/m40VlCL4BqPl509je2t5N3BHUvmZWT5TQb/lpvyAEN
xZduR464OH2HI+z0k6ONJHG+YuV02ukHStI6n2ThkmlWLYIlo+ViURbBojqbZuNwq0m6yOb5+H1WBYsX
+aypuEjPR2mkZVlOF/k8WDYv5+V5BOSkKuewGOGBLC7nWXqWpZPwMMdVOZ3W88vwzJ2c5B/CUNNR8PsY
oKXzOutsHPf2N/jCE6zV6676TI7cgrNsOocNNJzA/Ba4j2qoFa2UjUog1axz3NsANIfzqjwH+qi6nU3V
gSZlpFeokyTnaZUADafL6aJOHiWLsxwB6d8fqVKSlCcndbY4LOd7SQf2YNmh71f7Agi12jzNFtDi6O6m
2Cd3+8ldhRL9rcdwlyGyqTeVrAp/6YoaS4HnqJxcPp9CH2o6gV5xHyogQ7Uxh1gT1sI0FRWaGvf2VVcK
t+QJztqLdLwoq8uurN5PxmVxkp8y1EQPYo5xyq72TQkQw9NyNkMGmFa11aCcYyc1x+jDIism3Y9Xfb0k
urt9q+0irWC2aTgSzFB8srv+ocgXeTpN5lV+DhvYx6HKalq0jkCe/newKOfyr1EJvGJGRG/+5QIoTQ4Q
BLTeCVZ4rUjGr1GuKvqeOvZLCa1sAgXFcjq1y5bFPC9kyb69NvO0gqWDMrmIQ/Ghy2YVZuu1mMm9ZLys
sXdRSdfIT+CQkZMtsHxDFXp6kzTVGs7Sxfisu/2PXyZbm9s9uxHQHBxqXUQ1x0Hvw38ehuHAibbbg2N0 | F+psbblgEjNU8UdgpPjvaiP8dzaFI8wGqQG6+yY4F/tBwFdmOcQ2GSKNAEyfH1m1NqHzOhOEVNtjCBCZ
4RsSJ7Vnj3aOe0Ok6i2XePd5p0AC3wMrSLJzaFOzArXbhoBoR5wewEsljuOzbPz+TVnnOA4LRavZGOSK
95FWfwOB5zl2+mNZzi0Qim0RCNis+X9lBsamYpmT18VbKut54ykXZ7ClgEHDRk+sTmHKxykcgwksXFJk
46yu0+qSCBFqQxk0uDjLqsyGiGUg51TJWQ4HRJWdAFZnsC8X8ElMTV6cJouSKgr+IREASjrNhv4iO1jt
r6hhTVaXj5jzXdlykoE8Vl42UBoM6editGLZT06ut+7Y7qYLjzDWW/nAPMR7bZga3FiwpcolnJEBMH1g
RGv06nZkLQFyzTtCilAsOq+7nb3zvM5H06wD/LLKFsuq4PghuxSrIvY/TPo79dOmIzoDDB6NjMJtJ4te
Zvnp2cJufEbf7Mb2uP4Cp2uV/bbMKzi0xBk7nqY1bLrxuKwmcqso1JyelUAB43orYRDfeooQunTc9XXb
vo2oh8mzXCFQL9LFsgZmAAwdsMJZTwDiQrCHA+ss6+oD99Ej0VwtBJ8mcyrTX27XTyYTkEDgmlXxKbBO
HbHkVTYDeV8MjyST3jCdTMRvIaF0gIV3BVLJHUCpM8snE6SP5CDpDLBUlIGUCjRjIaIGQ0PpwGnQcQ9P
W4DgJQrBMSKiZhy2Y0QeAFw6iEKVTdNFfg7oNYBDTPqIrnV0ipPYxllKYy7avsTxMw7EFw3U+Aah6iRX
xIWEoGggxNt0Oga5AKRLAX9xhidCOZ3g6VFo2gAyF/gPfRAvgTZOYNIvxaFRlRe1Pk3qZA7tp8noUvzh
NleDUqtC5/zA8IXmIX3uZW2G1O2KGw1wDllBcpmBLQYPHCY08KSfHlB+Z/6BaN6joo84x4yO5J65Ie13
aF1bzIF7X5CY2pJi0zGyWcpDLn6ErJYXVwkbV/tet94hi9xffuu6uPWTb3Z6Adw5Rs1iyFu6i+ljCjbM
WG8tOCyqbLwwF6cA97wBFdts0m5H1OVyHL+OIC1SDficJ1A76WztdJo2Z6gTfYk6Gmwdhy9SofvpIIAA
sLt9t6HbY+h+JwfUeO0QVyZ26whMl89u3QmIsNxVnbt3ngGvgzRiKqAqCWTVvDikjbqollnvuti2OCw4
3i0W5CrMIALrJNjkSiqVF+g//CEJNW9FW8hIQZrZlYfSZJnhPq2AJZAsB1IOSKuzejh0jylHraFFVcHR
u3ij77YgJF/4NFUCSyf7I5XBVtP8Nq6YxjoGvNW6OVqxN1IlNcsWZ+WkNmVa+3YtsdfmquvdEGq2IqE1
cvmkgfzwURJllkJcFhJnWMQTZy+Ks3j6In0y0FvyaH5oizgebapu5OEe7slaOKtDS3zacuQNT22SPH5k
z5YtsESRkxJsSEZpPZiNkFaJEw1bYQusBKpu57Bl6MyS6l84F5UWGfUUfxdHNhyUrP4wIFU2IqF397Xw
sLTZQ2u+Q2iJoiBmTOnGyV5ismnf2nQ7Wcy14LLS1TH9cSXeGSY5yiYgSnQ7o/qJesq4K8Ci5t88CBi1
PxX21Vj1vpV9ftQoiPc0kFeeP3mqFdHySg1f/3Eguzyk+dA18Flxz6wIkPfiR/gEGwvuGppp9JN0saj6
QjgWEDy9vlHTf6TGe4mE4T2J9OWi7HF4sJ7sl1ZvwArG3iGYJKqqnJTV8xQOp6OO7hQlcL7nzG9xzJnf
dL3rHLPJf59dukrrruoqr5+JF80uTs0RVMWTRU4C/cRrvipi1NZzdO5KeyFW2jyfSFCMDGk+UZLudjal
ws59qjKoCrDAsiwFn83MzZK51xmFlP2d4S4OL3FWXR3H6FsRm4+kQ7/jsljg3syqPdwRchKsjSC/8VFa
ijCcQvmnwvjqWGEpcedPjvgk3ObJUTwd+0+O4rU58IQoG1z7CTEtchCxoCXul9ngJJ1kg7SYDOopAB5U
yLz09p1XmTrxsbZ+5qayaTqm6cBLjNVqkc3meF1STbbFZCzm0+HZYjbV9XBVoP2hrn6SwhnES1PYAZXz
XS7CnvX0NErH7/Epeo+kZ/UVtsaoTKuJ/RVxcGDWZ+WFqMTozntPpSWxiIa+MFZlnixxxOrJMvpSiZU+
40slO3dkTwLhrtn7/hmENeNnEBtWizNI0TZ/it6sxTO06Cn4BI1V+hIVi7rxvAFG80RR8IsqndGw5Ekd
Lv/0SVcwqvT9dc45eeBwIlrvYIMdXdTj6RKvDJzDkEJYzpha3nannt4FuidBw0TWjUeX2p14Mjk7ED/p
bY0/1LbCv9Vmwr/FNhbtaY/iD81Yvuwhh0x3OZ+X1ULMDbDeZJIu0gE2rJsmIl9M+Sw0o63RoEMPfsBJ
OaqzCkgdvrKWRXbx13S6RMlkOqG/XDGc0FTDQ2IfAmUB2dYvYVp1e1sz11tj9GmRlKNfgao2OPJDuSER
f3nUX9BVmxeuMQ5rHV9TfwZ3d8gOw5JEHB5q6CYiEJYLhYKDbBl555ZKlKAVBioQibXYYpLikPRHiEMC
hEM4506zSn9SKj+YLZrEhShHjqPfG+XZV56eTl2E/pJWI7jjJGi4lI2tl6e1ZDF8eZDMUvS2rjQmx95W
GnMkHTRxQ0kHvv35+5//AjwIxlNeoCKmLvL5HI7PC2AKCxjnbJ5PtRZ1eklNDl8/ew1sbTma5Yskr2uh
y4E6GRZ3HtZzoOfidJCfPLpLW/bu44c4PAAPX/HJ2HzfFgWP/1CM6vk+/IS2jzUErDtA1vXorqQkaoJ1
OsnWxkpRTdjyrSGqyQa3KarFRDNtZ0hlRjTjQhKXy7D+tli6oFx2DcnLqhsWvYycpb4gIc2zcX6Sj50D
cLKs5NgtwGhT6Hya5PUMCCcdTbP2QtzdzYWQBHyBDmQPWRYU7XDSVop2WOnLiHayp7hoFzoiUMyBDaS6
Pdq+R1uor2TyfnJvm6a6z2f32Ol2uCn4FKsCmNy5oxSU7LvhK0wfjB24D0gcLpZz0zr4GdSrsBGiBmAw
npZwgigCsiYaKZDYPPWDv4KYqbZB7CSMCDcWVO5aeimK6kZbafBneAC5b8D6wq5RQ43vzs6OfXYGp0fL
9gg+Ltszum4h2ytmGJbtsbRRtscK/5my/b+McG9J8mtI7/BD0Rj9bTbxv6tgD38i7/hvIODTYRAT8LHw
v4uAj2O1BXx1TtIftyngCyHqswv4gmOK3tYV8OXYryfgC0+VFrpM5dKSHPmysC67vjBMjFQIvB3xw2gc
afbJmHJPLkxUBgzMsTopVK97Gh/JbK+i5+BTNGQZlR/+UpXLeXB48WPoSeAhpTh9VU4yLovTnSl0HFnn
ECcYRbX4vdshlikmiFQ6tBA1N/yx7f6eUCu4Ls0IEcfjYXyWTydVVhgjfnz5gqO5unxHbktl9WQ67Xby
Yr5cHCHXhcuWnKO7xxyay7cVZDaH9MneChqHoA+JaMBJX9aVczGqBwoZ39jPrqonQMzvUC4Mmk0N0cDR
rn2OvMoy+zIMXQpaq2lIiFNigUiM2qyevLCkKFEG8hOWxDaQrKX30L6uBOy1XqTFgjjr2+z0+Qd8jd/+
RxeZ6SeSLj79MtnqbW6vFKHa0O56cpR5o2l4+zNjCh2Q03QEK/Q4CROfBTKvf8BKNhkXgP5PJHaiEdUP
P735+bBjk7/gO8/1k5ACc+C5tCRaenMe5HCuaQEY/dry0lBXQTMx+0siRFXr0hJY1uEClsoFZu8kjoc8
jTIgY7cRv1HwYRC1rBiHqaMHwppJeXaNoTB49lgsZLzBsGax6+MbNA9Msg/lIh8ntJltUf0srZ9TIYGh
YwqoCx0q9CzeEbbB5TRLiw5KCLIGw82qYo3bgW+PzuwMacdY1cP5sj4zd8nzXAlajlgFQ8MphR6HF2mF
woYA0Ok7p4Th98AXNTioZkDbN1LJGnQxLDAnUjPqmJRLyL3IPwCkAmQEVEeg00t4DZKARCvZzVqSOZ9K
0W83LoZbFEKzkwwe04g34vCYhJH4DhbOYogmzYvBu6CvamUkfYXL+9HvFkC+0gF4urgf/uzZbuX1E3Hf
ZWfzb0ughW4MnRCnScQBF9eVwI6RnLfH+TfxenKAUHjYNGtxbymyC3M2pVxhQmZfA4lTiH0M4bQghdDw
POkKtc9G82UE1qjULyk+nc+nl90YTQWo6o66mbQkqhvSwK2TqMNoYK3v6MV2VWYcQp0t/qqQ6t6x1xr4
q/JfETeHXqOTBfbZyJLdvkO8xDHBDF/wbeEwZOnyNp3k5f9cL+LXiwon6DbuFuHbhLk6UEf+vaGxWeQa
cb2LwluJwP/cEm5yS/i/oWuCJKL/m8zS6v1y/i9yVziXIm2zWHyuJGxP8pUle4n5tf+7STXyjvyfL9Kc
/4848/nFmTA1/YvLMlFxxSeZNe8qcYnCVuaqIDkt1Lk6nk5QoctKb8u+wYCU5ZO8TtGU5JDIy3n15/rg
BAQCW+MrDzI5gQoH64s5MOVRs6nPmk16YjKkSS/H2fREwtFzjV7VUDOHszSrnTc+rD/c9B/2oa/LrpoM
vYT+K5b9IGfNBL3XmeE3vWsFH+XE8NSznIWofrUyVbR4YmhMNBG7Hsd2pCvJEjLMViVWEe61p+Tz/mNe
L7Iiq4LVquwUiysxYL5aAUNtCx2hGlG1NPL7YfDCOaAVeDGmKPjQBAC7U2fHjo0A7H59rEhrB+ubUe24
agy8m1hLNrSJw+G6EXQi30GWOZfanMEuyA3ntgYn8HQX68Bt6cxmgAw07euxnzj2Fye2q7A3+y2fe8hC
RzEbaaQjSvRXzq1sCZlXstiJ+bGvZV5hd6Hqr3xLYgzXMqsQrECYVihgYesKWbNvOo3K/95QY9K8FNyP
OgdadE84tsfcbkx7WXQEVWNdxVfpb+IrnX5wFo+vcyeo+dlbe7cCifPTRTW1FqkGCcuW182QApV3j5lw
BFuQgQ1EspljnD6KomBEAWMWySrbfYa3ha3qdeUlhogjU7iwnT3qyRL2GBjiIANuwt4Ewlogt5a3BSrb
iCBiqjvoM9FopapaA+ne/aq+29tjOD36qky6X5W9Ri2XpWYU0ltUMnMnS/NihnHA/VpuFlMnOqlXrV2b
FCL6rG+h9NF79B98k/4jtEv/xfeWDFQzwrhXiEI7tZMWHR0LjDdAfMk8LcimWIZQM7gwLDZihGALIt7B
b9mIaJuQyG6l6yQI8h+k9VM9dFcb3428fSvlGmr5+iSAQhP5iv5cyrUuY7F7BKPTJjJVTnhH/KBiHqbi
263QLqzoDe31fmeKtkMuaZLW0ZVidIwA9IXAgQKnkbv8+v6vmth06PW7un304fT2NhjREaNu3UKvrLoF
RzdV7Mhr2jpGVdcAQJ6Zlk5HEvaR7BwjcwkwB3A7kzMrQ7zoeFqdY6NXj066udmFp/2mQoOvTLiyvNFV
afjAsvUJJiBxC40Cj17cEGQXar1Rr9SxOMW+QsIC/gVcLpxQzFSBucSKGAuDaXYSdIw1rbfZFHquGNLg
EBqclONlvdJFo7XHKzC59HLPxHWFJZ3C6u0lm9NynIIMlk9U0bLOfqIQRS4IwPuQvDFoNB3+/QWJblBS
n5XV4hkvJlnpGavDvUkm6aVuOpkYI216UFAlthpouSjJ3t/5PsuLZzTVgx+KE4y4cKlL0g+iZMstqWG7
kwDNJgbgOF+o1t+y7D37BnjXr0/w47OcTKUnGPpOleawXD8CIcC30+nl/Ax/J/ovNEk7r+C/Fq1gyVt0
q17RSLheR6+/9kVShbKgH1VZLt7hEWmZ7ovlp0DRuEb5FFiz+iWoFKejFh40YjOGr6ImOrvpSdv/i176
iemjnzg9oBeOgH974afzWlAyvmd183k3/VT2Jp/y+VlZZJ/SYlKV+aS3nZ+KxxUFr0jP89N0UVZDjLj6
5JSfIALqYbkcnwFQOMCBWcG2wN8dOJa8ICI9tM5WaCggqNJRvGiI27CXWD/xuq635b7nkfRMT1woSLY8
f+MBs828Yz9yztnzbwuHJOcVV8gBtOJCMII6Q5LG7HpGOcqQ0AehXbeW0KyaDkzmwKO3snY7MJ+SgfEp
ktvblraoEvlo2cMyxIlqIZtcuwwxNh0WuueyKWs2pG/2UPETrmmgJn42laUUjxyVuUnpcXoVFR9ildWn
YN23MgQTr/zWjm5DFGSoxxvtEcPREYoFfXiBp7QyFJ/7uQJvIm8RSRKaXFFfVLKetIJw36DE2qRldVbO
tPKeavwuxIXtlViVWKREC/UFVu52+XpuYbCwrwIzOpxmxeniLP5u92Y5gmuoP7Ec1FJoqBpn11fIeABg
UMrm7tFXaJngTL/7/oBNREfABe8gG/yJfg9PhfNWt+c5llgTIJGeWLuAalloDTGidld+CyB1ZY/y+2U+
nSRlMb1ET4t5BUI0iFYxUhhh7a50PwktgT9NSibA8dfupL9Fwd0xL+KafdVQ1JOjFz/4mE7KygSu7ydT
bQiLYVwlzYh49tNgyHr3Aco0PsqP++5uWKghPZ9GZjY2I+F93QfJNZuvQX8qR0oiWrOd45LfHYf++LMq
Nlb2xMHvwhMpMYTrAudb9tOnwCgaHn3tF0GEvuYLsHXiaUGY9lYIEXshyM3UIWN7CSOuWo5AoI6lfvLx
MksrcSXEDf0C5Pq/w5cuqWKLxZkpeoU/8fuEBHH1maa5d+W6zgZYJZ/2gaeVDezXtal04fJvoq11CJQg
dIQaOqR8k8c2/sfSK7Q/TduO2Iv5WC5g82ST5jNCwOFToFjjGtOgkNFCjTgn1C93P6keSJ2CxInErJg7
glqEAp+7DekiSNtgZVNeYWKdGy24+6Zg78IyMZvET/vPzJxtNNYk9c28Dg3AlwfUc6ZsZ5oFhK5wT9a5
YT+6uwpKffThPtA9qtZdrNC605YCH90yoF3NuqTfrrZQKAWlhK6PB/yf4c+HTzVDHCI7pED5BEX8hDNi
p5fckzZiZiMMiUOy2uJ3tDpJQqb2JL106vbCNqoRnm2GhHwYRhFg3l4dh4t75SF23p5R2VfC4lUJl+9n
5YWVwCI7X3i86E1FGUSS0XQJN0x8m4OGmKIMf+h8ZQO43C45xZ0vhnPR8pm43dpHBpbXi3IOvHOenqZi
j+/bPT+fySjh+ApEziyzcoQBbybZeT62vFnI4o+0BO5Wd9JKuToOxEMU+5IAj0WqzFOHi/LH8iKrnqY1
SuvCA0n44vriAetXJ09ZnbiIZVqR6sqXaTGZolJWvIety5DK4n9nlyuXmnKVbHcf/PHTg+8+PfjTp693
Pu0+6G0L1Q1O0/vs8imd2bAxaPnO8pMFQFa/0yn+Ch0K1yQGe30ZCnQoAXK+2SeXH/31UBy3jdQWjhwt
IQRtL/GMaidcJa5IFo0JDrvgJ6Ety5KLHBiYUkgHjly9zLS2vAOmPwJZPD/FFW0SZyiEdeC9yD4XQ6dM
bU6+yJkYOmoCXZF6XpridoOvbbgrqVY3+pj2+jyrKlhgR+/0T5mli2OIn8JaplBKL4MMMR6pBGUR2LWO
3yVCbaoOpN4VUTT6Ut/v0ISV/2BwkY3e54sBUBwcIilmQ8QgHHD8nOTZ1EtX4W9BEyw7wifDiGEPMcSE
4UCVpRO86lPtahkdhvWczxY3qkj4pxvW+cox5v+nyYLF10t+DS9mJHHWzdfTyonVbnyBoBPeEFV4Jc5V
rBhLbkl8ZP/0wyixTFhReyhrG7PFVEr6AwwBD3+QlpSeZ7WA0OlHhY74tVsxOJ97c0qCWuEeJAts6zjm
zveZjFronBDh+ZaV9dShhNSg8+Skcouz12LuLCJda+osgqWzkgYZnkH/ePWDY3lvK02WoRKg12Z1OC3T
xDP+JIdt+uu3xgc6Ngz9UzyjR6Pd6bc66gP++1vkaY7Blj8E5ECkPNfM1GJmrqvZbb/HSZjLWVblY07q
hRfsRWqfaeQvpmW6gDryce4FcvKsqyjraq14Yp/Z0e36QcW4da75uzGamBVBzIoWRuYD4ggliT8WYsxy
YuDBybS2UokTh0y0EA/9ZP1hGwuICpfmBzcMEL/l27z+8Ux2qE9E/IGPqroGKmSpL/EUiH+qVzH191sR
35w6d975v3hMtL9iLsZ8mi8uE/TBojCrwrPRrKQI+PUOz9dIMDAsWy8W2B32Tgw3qDv+uFhwsKCOzrR4
R+EneQP1Z4LxI9UPmQuo0z/ossfV/oEts5mmSmd4kDhSBrlYureosNmjG0nMtLK2GZsMi8mFn979ZAvM
WTVtePnGZ9JskWQf5uKakr9+lwiz6A02sSskQP2apPcRdNu5hH+DV68Gk0nHHvxrEfWOqEh6NqEuQySq
bIq7J01uaC8JG5vmzeEpju2oe1/VaN5NsffMjgkptUI7q20Qv5VW6B5OQoFN0ILh7YR7AKdJEJmAbwT0
LaTrwTKuR3SAJSECUexiS7ciMO6ri/6oNXX6i+gKNYgASuYjlGsG2wddf3ag+o76P1ZLLjLU2oFag10v
koLJmRnd77g6zibf/sfd4dZdke2Le2t//EgT8Hr0a3LlJmZrNTO6n3o5guOiu2vWTWrek0FyPz4KLU/E
gx+2xIRkjR+KBeO2uzvRjpMV87dD6+EMRU6eyGGISLXHM0QH2kIuYXZ0rRRPay1No3LRe6AHwXlxaVVh
lgShPmm6fL0zvRK18aglHP6GVCr95UPs8DbiE3mGA5HHaoZlMBDmT8jk6fRaFhPBGrfRynIbBDBYy7Sq
0ss+b1BjnnA4Fi7gvKNQ7Qs0YxNjpMBMVTkzsAaPKV8ZBiKV0zD0FWKFwsHYLnSrgKkDqXFFAYkV4k9N
zlLodiNays+VYwZxxX20kojoZVlV1L2glzpbRqs2W0z1XYytj9bB5znceIPHil0Z2X1geuxKzqawwEcA
2ChYCmkxIQ4a+BrQiHaAJC1blmaUo1qMDU+UEtdJJUqJX92PJ9Lg1xdg+tJaWZXgr36iLmTGEs7cDtz9
bAKXoXubDKumwx3Yzm2hAGzLgt4TVsZgi0VgUz5tupmQK+LebOEIFbjbcTOKeGkYJ3oJrFJnWEgof7fx
RJTevX/A/+aT3OKjKONHA8m5RiyyeVeafieBJ4mAUpf9Le1Ea0FJUg4WCz+k791IsIYQGxTIM3DASdj9
fqIeJSM2ZqsG558UDSpr/zkvr1/B1RKBUiiPyFE1lJIVvVeF0MZsjw3t9kP9ph9a9CvO+3i/DyP9inah
fk2neuSkWVH47K81/RLeilgauhXMBzVSXbdul34Q7SSSTju8GaEEsnSce0V+dTg5z1K8NImd5cteJEkK
uFFTMzP7sV3DUxRIpYkQ2kRCB++OIc9Jo8tjG8KkFHC0LEgIPsvthZ9nwugUy9koq2LoBMdvCG6djvLa
T3Td2Mui/OHdaylPh3oKgtIS62pGdBWVINf0qOZdre1O/Xs6U6szPar9+VkJkhb6QHRshh7JrLieICUO
C+BlYSpxjD1ZBxFIEdftFWQX2W6TyFHGJ4/cnWJbbzVFyi40RUYWwTFxfgd0PFd6eSEEHNg1pBpphT02
VGyjtqBqLqbXU1EwJcSO2wcfZIynupTYxBzitz9LWpSbJLhTvXBpLaOlrS0Org5eptpiNLg74enRYtIK
jozB5TodqUOVB0mwST90cMRNN24vQQJXECf+A3rbTAmWWnet7LTGE9XAIL+dm3ijRtwh4fO7+TSHr99t
8FmlZFrwXdzwk7xYlEkNt0QMUEOfhLpC39FrrNyFErg6wU3SjpAjGljBnS7O8mmG9ZXi7DFaHJqFEE3E
EYW1EP446+5I8CZez4a1F0Uz+dimR/IKfYiXGFUrq/Cxz0Yd9kG3gFPJe9frdovkK/y+hf8Df1lwHddI
85aq/B+tN1XzUqoeRYX7oqnE3uZk/8ZYWhKj426n/NgiLmz2E573LmDVu8BnKJg5EHSZh+CzJ4fPD394
9fyfL16/ffXk8N3w3cvXbw+fPfn7frDxjxgME/ti0IY1rZvlUIZvXj2M1TNOF12/7k4/8av3mrrEXDhJ
ID1O5yEQFkU4eHQXE7GjSc9gDIwMlgTz9Dlghr+WOfCIh9uLs8eNLZEiRDUruIKw+pUPhWzKJ/Iaac8C
VTowZ5pXiA9N5kx0JoA59km7W90u4jBhlTv2tlaZ6O/K7g/f5v+rLDKZRP+R3eTQKu2i6fC32dduBFLp
snhkSyG+ZkYyqr5VrZZcyvmKJst7yUc1yN3kyq4grlh7rosQdDoOqKjw6k/7moz8cc2oIv4x8WaWdF62
hTarJ2fYrkRY+t2uNqrmpBRZX7eKs8RusVxl74koSRq8XfCfkWdtUPZIJ6lr8y8JwbI6fxRBK46UY4fp
Y2erDW1ioBHtxbPtyXQUeVUDHpevT2gKudxprbZrcd9PdmG2ndZ6vzjfQ7vGHQtDxhZ/t1wUB3SIBbqA
XzDKgc9Q+8l3uEv/+O3X2TcG60Xm4hve3yFMfTEeLsj4R+iGjP/gYBbW3SiETMk/GLlMUl/ki/GZvzNd
HJHegrPda5414e3gQhvEYAEr28keBIc8UVINbrJLt4blqSNccr6+r3xycPQPk+8QukfrzjxaK8E3vlWg
t7v1VW7NrSQP7KmJlrA+Ch4BH/oUgmCCAT3w7mSvoDCLKKkaRb62pHj6TNxTsHTARdlE2+wHFXhUz/L7
uURWtqTK9j0uwEL7+hVkT0HS/jwIyWdr7nuvzAqK6f3kzU6OwqGCftJ5Bf8SNHFw7XsVFDQL0bKPnVKH
V5u64pERXsIN0CkLT1oSrXGx5PTSBw8Xdm6FsHBYoZn6vSZHLfwnpVF3BQMHIpJH/KTijdTShlqoMlZd
knGodujA8MZqIqmsGKsSdSRNcEWiz70U1GSUjdMlnImoyMqL7Vn6QbT2eFjSJeAPE0fhTjl+sORx4qnS
5fSLFW1AYiKyXY8yfGVN9QYhboLZhc4yIrwATkzycizSdLQrM9uXeIXHHTnYbY8bmyCGF4y7sp98Azh5
bushqQJf0V1eG4dgvCR990hnpR4/aoBzlB+LAzUMhC/4KjAg9DXPpp7TQ1jHgC9/XhvLLqKCpC4r+NHH
B3nAQ42G8O3HgF9kyfsCrjv5olMnRbnQPblLJP6pe6qde8v8c5mu/+XKHWccpLOptdH2XoNjF/6TQdmW
6fRQbGyXg/gvBapZoaKk+MKI65L14Lueqs7PbtbxAC4nSuByO1MStQf1j6uhfrc+1D+tgrp1DVy/3lkN
leMa2PR33LNcwgOOY4dmKdT1aFXQgb4b4jadZeRpAEdMpx+8h+J53wnePb+O3D3FFe3Wr55tbpz/cXfJ
27o2f66BfKn756qr507fC1UhWtPA1a2EfgTuJd5huXs/ehrOVmCShzCRzezrhRTd/ZuDLFh1d2DXBUER
TdcAUeMGFwGJVKe15B88BgOSvJiZ/1ay/G2K59NUX+23rIA6Li9z8YNDzX34Y1OiwQaFc1tW8MX02xZV
1PZvNZ+WsMJ3Km8dOnGbpBjhwo29cYz8ADmthJcYsK+vI7OEgW2tgRkTVWLAvv6dJRTkrTEBhTjSdSSU
+59NO67t0f2NuH1/h4zThYmoqmcdIqrKf5w0858gun0piQfHkbgPKgPn91dwodbHJlwmwnpZrKpEIPz7
hhLQpcDMVsj+XUTkySOimGhlyz9CXvLFH/F9DemHyKdJ+KEK68o+hDCGlhBJDbeSzgDfSMVnMRrt5LIr
a92iWEQ9/HtLRb+DmCOlmn8bwUbu8gZGFtAjfQbRhjpjKN1AsPFBXVuscUHdQKjxQX0xkebYD4zACYLs
APbcsMnJQfIEjXfQ+mlRolmoMAcRgfTORRhvpw1aSIgSB/wz4rfqL11oTMau3DgKTioCGdqrTSICWTWU
hqAhw4Bp9SXyC+jeVPEa2QVk2209Jw2ZBWQUGPn91jILbPAli4ekt6PQN0aU52Hkbz00PHmhZrXKMg0w
npsIQ5K23TrAiv1KIvLRqzZVZ+V/tatXt6pWOrUCkeIlOYTixIdjw8sGiciSpwth2z0tZyC9ijDpvI2f
8bIpcrxtsGSCvCu63VSftDEE/WaO7tJQFBhdl4zIDZnIj1aYOTMeP9K976VvgtkTVbl5m9cIq6rHs25w
OzghAjHtPk/UOvIcBsYAMERMKIw4gI+JnFOjBA6spg7tMjPMxuzt03yvKBfd4SQn1tpLUicfP+X8x04c
P9B9FxFEjn90gxIQkD4PNNpP8kAcPndnA305n8SRhu07eyIXCyyCyjuUcxz8XHorQ+IF5RVymaIOyMyW
/hwMbAvvmFRh2j5M+ESSyCRKtrZCoEJeGlSdjXbHWiqCnv0ma1lR7gJneFOcOx08TFGRGzqMf4+b2F8v
bpgbk4oCD3v07AXz8ve1I2SJI8kKJ1cW38PHp/gr6n6eaL4zPEtrmR1MiwSkytUVTPowYHpFpyFemA4X
ptB2g4Xx7/EZbjtXbviuFZOlpoqHpovNVfvZYdm3/AlKEi8UTDC4pJ6JOhD7keEY4uQsZivtTsMaQ2xN
yt6szR2rjT3XHvaB6Gayrh/bTIUrs4WCFsHKmPRsyXIqh5DqMizGiQxAqk48L2AwvNYN0//hPSgt6vF0
WedlcSuRtX6XCFpfOuiUisYipC+M/ABkP/oVZssMXgSWUsQRCzylytcIiyHA4OxhXGcT84ShGwyD8ftF
ylJz8DvEyVLbqlWULH6gihhZUcbSECFLtrE2Cxe01d8hSZvDvD1vsMTMgxnSuq5gZgRtHcH81IgDEeyh
hUoimP3wCJUQbpJDU6ocmN7ICgGXJVUkWR1daPDCCKMipZO+PdIYWPSWci5n9coqYNGQ1KSvGVDxSuGx
UltyEksiqE4G0jtsqAWI+nYZrX3Qp8sUW8qcZ3qq5cHI5SHvvnydmy9ryhbWvmpjYZWdPv8wf5XOmR4p
gVnB9KIJxmA92hn86fjjgyv2vtgRhbL0m2OqYpVTceIGS0FHz6NdaHAgWmjwn8JgZrPmbma3083Ll6ab
XVH86T7854FdK97Z7oHVSEE6iIE6OzMdHgOmiBl2vHvfrtY4PGi0K5ogoJ0D6xODkioonSevPr3hhmyd
5/Cvg0VR975nT/4ufeA+dXp2S0EeKx0Dg80nEzUBO2r49+XEP8CZ40hOVs0C/K/dmM+HV8ggoxl/8/Bf
vf7p8GVwBKLpygloAuBMgb9yr25l/ck2QBDb7vHH3Su1nz8d3ec/7SZs30Hpfbs0jtbgoLvziRARDXf6
D656hN/gYOee+Lbb/9qAs3kRXKVfFHFWRMcJmWfk02leZ8DrJnWIK+mK7/w6CvmGOprtsA4LDFUZYj0N
dTRf0XVewuldh3hKtIZmFfEaK2HobY4Hb2gTO9/17tQQ6ZUnsCVjFTTP8VLiCE0BIqhO5lOJMIhO2t6d
XnzV93MeyHE+284xYIAAsYUWLHviB2aSCG1uHwWnF2EPsYIHKLcHmf/G66sTGe56fTGesaLDTmx+gx3u
qsw9KuVGiMvcAizNazRhqGfcEHdZ2aF+A76/s7MjTdBlhky7W48eVcsgmwGRJ/uABhUL4DW6hElJjWku
eD0Z+KbBQf5IMUlR85iHPxKf9plS5ZRUoEIke1FWwuu5G+iRXTPEMNBogv5o1+wqPGwdWytqjhBJudlz
BHXbiKC37yqOaKji5UG+1zfhRWJ/4ibY6iejtM6eKfs0HF4jonInSeK1LHslvBMdoap5yslCiT6+lUsm
Wx54a6cQ2xNDDsF4pxZQA3FX0gBRNMuhyLcEDYBwgttBNvbSyaL+QFbvRRxrVIAlAKemFydEm1nseOZN
Aa9W2Qd7FwiYUvHRH+Wke3Q+iWcRYYEoQR7lW7vHlk7SoawJM1Ex1NSkbDURSyLT/tGanPcZufi+JgUV
aqnrrpJben3+WCPWZi6tzoTz1Sv5e5+rJvAjBlNBKFbr8bQssomOqu3yC5x4NumIStyRDd2lqb0wpULF
HvqZ9Uy0ld1QtjD1LMNRAQabVnAYKxD2m8SJja7bnZCFXfN5wE5N4pGseuwbDc2QKhChY8Hu7PoN9icB
ciFdSrVAVTBGrQLQUU0rlLGr/Xko5tIkx7J0qjI0TJI6L8aZCyoZVeV7+FqVy2KSnO8O7w/v79rAqgx1
sBM4ykCuWSzm9d729mm+OFuOhuNyti0Bqv8Of6235xh894/f3P/GXm3AU9OcMDo8d1Ru6m+Vx0vV1tvH
2yFZPU7nGQaArs6zybvL2aic1l0MhcInRZ3i8HlYZaSl7m7/AsPow4Xil1+2jzs9/b2zPdimbAlHA/55
+5ehqD60v/5SKyj1cacXRzTGhlduZa0OEXvZql5lgU0IS/YEQ3+nY6QlwrPG3Zyel/mEtI15bWn719q1
1GWVhTfR5ke0xszRLvOqE+SJ9OZOOCWpRBJIS4RzvQ2EHBQkXl38pidS70+s1AvjqXlGmMD0AeySGJ5K
b6mjbucfolfsZZNMr/LOsU8hrpRnFLY8YY+ooB6r7BQtnupOKmjhP76WNhvBTh9n66hoZROloAVof64J
XPJrWp+9z4q03sZo2VU9LquMypfVNMQrQvW3R9NytL07/GZ4n30F/P7Xj9/+6cEGPoTUi7SApWWIaN6H
f/STizRfwO6YzbJJrsVD5SdfLvE1rDoVukjkAX36DlBnwEYFu8U5d0NaKTqTreT1UKwOwkPNZ3VKBlby
qwYbCBUoDGYXsWh5yp4WSrssohJIKhqoogtU+FPVhzRwvh3keMVhpIwAqFcxSQAOWxoqdGMuGgD2KwBZ
6LAJloeUGMpQZFrUs4uT40Q/uzKTgCLUT2TRoOFR8mLZtagorD5NsqV2w5OdXmkQsq/2+OrbgCIKQBwf
hb8k1X+7y6l+cQZXyMU0SvXqcUnTvDUsTt9sQ7D1FW8kIiq6snZRqn0WEIz09D3VIErIDJIOVp6l9Bhp
UlWLXBruBgmRXrtlu2raveR3RuTmdkg0phFmNnYexj0+rkJZ6YgTeJYC18bKaoN1sbeBbiE7a89EEC0D
9uEjHnRwDKhVivDV9tj3dgffuyHM206slZ9DbUc+U3BQ5FNE846ZqjabVY/P2rHhzeccYACoIPllnSNM
N1KHWJIMT6RVaMcuvbuprGbJuEPbe5iXNFXeT2Sp9ZD2628/5nRZdcwFDc2cWPal2/fuiQm7lxwCn6cg
KLJJotIaqwp/nqdVOrMjsuqvham4zShfQMCVLob8l7ERlK/U2N6LL6mMm3RLWHz3m5N0mWIZe5/3LcmF
DfotdVRb4wauOccwS0m9uJy2Gz0mRnUrfgAisGYEpmBc18HRY/u+aGIfyufc9gL3gc78uqwoby+iKKJl
/fCcSedCpROqfIR9HTtHMEKWVtun2eKpnAAF3IMbqaqQ6wX78MEo9OoAXg4h4Mxwawr28n2uQ1ojX2cT
Flhu+UJfJ5iZdkBJbvCCCo1w4cuT5Nf/gwa0nRr+pqBnaqn29OqqG+1gdJmMynKB14j5QNo399mn9OQk
/6CbqdMZDud0ng9/JUNdOqBFT9uNdKYJqNTR5xwasslmVH54C3c4NsewVt/jLRu43tNpDl+wvGtZ5QNn
kXburF15UWTVM8lznLuBWdGLfIKulbLbIf2k1N/GOhHQ/ht+NnrqswxD2plW4rff7CV9N+0W5dw0gh8Y
rE5S5Dw9zf4u49Wh75YekXZGUL/rMcZTPiznKOR2GyqOabagosj5b9BAfxCDB/5yEPn/1kAEEyC2wwRr
ClTUVrkFap+XNWlsNFn9i5C7xitM8Ix4Bdg3ZIgqSf8jEcpOX67UjuWbx+vLCfaLub70Rf4BjgTZeQ1S
SqZ5BCZsEuuedIUprA4SSThwFHSkL5DW8lrEkaKVkcBEe8bwxalhjoqOmpOOOOw6J4hYxzWv/BtaDtZA
PyLZVHD7IwLpOchQ6NYmUmvos0/PPNShHjbsqWnDWlz+z/H7C4C4B3Q5vRdaio2GZULhnn3V9LDvY6gZ
JqvkIiHT98hGdTsgqhJJpkoS6YZoShqXOp77AWo13QTAhK2OUdc2mVjAYENWeJ8LTqBhmI+kMBJBWQAB
nkcc28845AEV3K8VVORfQbBXbLO9W46EClFsB7U4INXqLZjM4KKQa0Vi7EhqdQK1OG9EEc3eIDypg8Tb
qgJFmEc1Vvf0kFBp+gJg5fcIXJk0lwCbs6CNpEvJgGuUustiADf9RY6qiku96TOHqOCoSJPT/DwrPPmX
nw+MYbdg7y7XZjw+tO3Dgk57mSXQnb3s8rN1WhvJuxvc5bAW/0sd0x3z6hs/xBVAEd3f6hi1ULFOBA+h
J0F/hwXOBLGmVsoUZ+z8pzUBEQk8PkfhITaJIxEhRMp/LUWQtvKGgNosb6ivJRx9lSuDSLRC1zaqH7iw
ebQlWAqjJqeluhMZFtrAREDMjFT6njyVPcYavn8NAn3N0wke4ys6k7Xs3kIVw+dIvKaAGDkdLHJsec2L
UJq4n9wyoRHQG9CZQOpGZEYzdxMq40dKnMxUhvYbUtmqzmQ1q7c47XhyRbwqQbwmlSlFbxH2QyC9xEAp
KNvrCKnda9GMaQmZN4JT49pBEcjuBgSa7X/8Ut/rDu8d9LoHe7/UW2kN/0O/ewfiy2lVLufw39GlKIEC
+OOkrPDnwV736JfNXy6Oxf/e633CRl2EaX+HL/3g1196PfjPVl6ofkWvKPe9Z70iPpvb1ho4zgc0M6Qu
/c3SlNL3frL5G7sbaQnjDZtO5aEvnNZi7vl8Ab6Ai77V33BT5hwVxjK8X2XH43VMFkIUA2k+TS9fFH1B
ziheUEp18Qct8vemWP9Rvyi4M7+FTZM9oIc54QG11X/J1UuYr6p9ImjSsoHRaKMxoUzshm2O7pPNoPh7
99iKhqPHp3o7+ppV/vaY15UToGt+Y5XqWXF7f0AAOx2/3yCmBxpRpZrETv3Gtd/6u+OIo6w9vay5Xg7p
jGmShrk2C+Jl/7chXvm7CkKgWY+1Gi6wsm1y6IUajxGt/EPqbck3ThoyA+lTv2jN9/HKtllSiIaA8ppX
N3MpbsApMG2iBhDwnGWGFFtNeOUHrMbIGFYwDRnerG9r9sU/Ue1I08mxok6nGkUfe2S2iFo50d4xJVOS
giRSpy5lpXMDO5jbtAzFxlGWdHwVXYAmptH1zaysSlG/6QC7bg5QVKUnePxqo9dzOGWhMQZGKqvkYfIA
L1Nu4aREs4bdr3u8UJ3cmIJyY8M83G1uVk9eeG7Z8t0x7I3NTAo21AsuCJD14olyPH5RCaakYuiEyz99
slbL/6eai/g4b28GZFb+VxDCvhrEOC3G2TQ6hmDxqt7tETy9CQjA/0btOQrNEwFEJ523swk5DQeXb9/U
RuMx3kbkCTWWFoUt9ZMtehAmVnVeZ4Knc2gtuiz9snpMSPaaMUFKphTyCxXrA+SG3W+H336rM3gj+91F
R4Xt5NsdqEql37bAUcGUhEOWBpWHIU067vKazTifTFFBPuqnJ9wejW9i4fOfvc1OpuUFF6xpf2PwBKne
oF2rc7Lq6Fe6HKOx4Nd9WcsdophCKsKjCfVwogpgrs8iwKtGl3/S0tHwp6n9MCMBKO6JSNqBVmQF1cc0
L7IE2Hd5Adfe6VRGpMWSEUaXzDAvVQJ3EDQqTFK02UxzuLAyKHUp3hBSaI3t5IyxxxAMtZMXrJAwRtri
cKj7UUaP3Vmls3tPSKs7qdILjO4BJ2+VZcUwOTzD55GaA9DGxAzjGYjP+YASESZP370jI/2JwULgxoG8
AAgn5Ydh8ux18tPrw+Tt81ev//o8OXz5w7vkxx9+ej40lSkoIxr+61gp6o6Nzjf7puIJBXeSP6/Un1eC
EtyTCc6TdNriakj1QkHzAnYl/nVRtf4swfNGcEVDl/0nrQPsSXSssucYPcsvY5H3FqiHkt9ZxD1qsC3m
0Yu1J0NXHOrqVsC8WMQ9Scp7ImO0M0w7BErr4HwY6EFUarq9RsPz4VNcPjUXW5At5JiepuMz8R01UfSH
3JOOCGIyrWpSWR3tT/aLF2cUWXif8Bt7hP/I/oxMo9O16p6cB1pl8v/IdQLgCvpFlc+ghgjFwaLt4Xde
77pik65gjMI4WLHR1XPC+nENkQikgbkwwwYo28XpACOiPLq7nZ/6UQJfIRUrBURM9UCkfi2dg2iqk9qu
r4WQ7WEpZrlwOsvgQqJ2l77BKzKJxRiUYG4jwKCCj85bqpl6E8Q3FPVNb/VwPC1dDOh0cCU7sTdWLx6P
SEjvxS0ykYgoYLSKQoRPQ6tCCPEgQT3RkQoY5OXsteoynP0IiXgWSKzlmaEryHluDj0mK21ilKdn+Sl6
J0ZDuskVdkPZeJdzB/aK6HLrI+AHpGtGYFGenk5vdw4EyEYkQuTlHFySvDi5c9JlNR3tm7djnS+OImcR
hCLZsSwLhnkNbHn8p8TeIJtwMbdaOog1jlJhKCsRgifAZdVjcedIs11Z5e4xKvv1gDAinAxX90Tl+8f6
nR6JE17v+07nGMEMRAOSeSX/BAZQomE6cIjLcoli7igdgZg7KYvOIrlIgT+h0c8JlaIJUJqMYVuXM3fp
na6Q0QnGbNisGfiwAE7eVWPxsw9o7zM28iE9DL08fPWjXfsqTrMWyb7ISN8lJQWcgyLJTZAqojdbF41f
MFAcml/TD+c9XJ6/UuCKn8Gdh5P8XOUdRw8nRVlM3KTA/ArU3e3Hnfh51movWK7TwjnO1OzpmUVZWv6J
gaXS/SCLJ+oKN1JufZ4UAQeJpM4BlsHArXXisEBOkvb0we3J1gEZg1zAcF05Va7azjpnWB2XhTJIGIVU
jH6PhOLwxGCJu8nX4b4NR4BH2eFoqbK9jF3WPKC3tN3s9101Ik7gLpa8LLJneRXPFcr25IXOnD3j9ucU
R7r0N57fqz3+Z3KSaIX885LFf2ua6tDx7wPLZkCC9kanuyNudAIxHMGVvkKJS8C1RmfiSu/HNrU6NXzR
0Z3Oubafcatak+W+hTc3TQ6ssysgwO41UgHpKU6ET1QIOLZl8Ym0S4i9osTU8Uwi13ZtZocRP1FDhUau
C/+AcohV8ddMf2EsR709mCOeutIWgurRxQ/q/C4TrinykNGGanhLjCBDL/8f5RsJRvGfluP3naueieCr
KUppHLxuNdfSypAw69LFgWjXqo7aYj7bcreoh6CnbnGZW5zDeLDSIAxrd7dAWt3/h9AHrKszgj6/SPeF
SsXa4y43jgLmY+nLHdQXtB6NSNmebYT5hY2chJVTaNIi8dPq6CPqLK1JxdCVX/DmyuKc4k9Vja62ilOK
Y83qFHcjxvVOykLqamk6Bka5ekbX0BT13Ha7v2V5NUnenIG0Wc7+33fJaHkKlcfvHXZBD4h8dkEq5BhE
HhliM55NTSByeybZT0YUgU3oyG9+8Og2+22tLlAzPOAyZIu9ATP8fY5GyEhI9XqbxtqYPEY5XppfF9/L
Zn78bZ9FrNP6KoylUmOuxBIqLud6q8h44j/PI30EDvmQkmHNQx5BNB7ymm9MsxTEG5tv3IhRYNfhPm1y
46HP2xN1O7Jev6eWtO3EhYntt5XHgJh17xhox/M9FuslRLs9Hmtv5Z+L0e1sZh5F/xq7eZ3mN9rOMknA
zfZzWGUWX9ADWzmIQULti1pTZ3SsxNVzzhHmn0KePVA8b4w9H4mfMsaa+YRSDVyc5fim8ehRcv87Rohy
6K2VpNGEMXxJ4mMSNk7eiPQjQ4CmViVPoEQI59p1+JC+hmKouxvFckAway8Xxix+i2wKVNE3CYIhvyR1
dkPsMn6fIhNtnZsgEJnJVTIpg2Hp5yBe//3UOvSh1xB1ydaBhpRLjime/dqGjnWsFb6G4Oub/dmoUB1d
VuVa54XUWFjJI1IbifnS9EbxPEi5FVb6qtIYvzLVbH2SM4GyGn8aW50o45V6Lg9mySBSakqRIY73f/f8
GH3zkK27Es/QdKY2ps/Q+S7Mu9Uh+2Rl11CbPZZIw8q+YbJq/O6ZNJA4B9iwbpqItV7vNBpkM4i2zZvl
iOJ1Yd01klkkK979dGKKqI5+1eijeURo78RyclDhekk5PD7DkmrYQ3ZeoyURh4caUqqtTldiCTPB1CU/
rHy50IqtbjiZxqFIK6M/Zeb6RJMo086Q6biS87gs5bol32JuDsnXLM1226wcauzXS8lRpOejtE02DlEx
7PWiy65vx0RMVNkhiV+ag1f4EIbvf5jHE3kDmVsP6LNh804GjLApT2AN1CmisNrT+FpGjKHT7Cc9J9Zx
hlbb2An9EHMTPtRURfhTVItNmyzWM7e/6gB80rneWWd7I1znpFNkBOAvuwrfXvxI43EsdfUvfAL9jZxe
MJ06avH0srj7WTDc2H1KSYmq9XCeYsZ6fnFayZ8ZOPJIyJ8r402e8CyYP/KI6xH0jkE1A8Uc5WehswKm
F4bfNHfwcTAKvPpCk32vAUzCIqtQX6CbDnFFuh6qPLwqnuu//LLdoIURlO6rYEx/Iram+k0BNpsU8jrG
ugrMKEN0SgAmNqeLkWgkwoJHT9CED9/T9hvm5+p9QqcphxXSMjWA23CEkvBx0XRezMs5dNjmwJA110so
bRp9FpNYYcmhjpmVGZ7FLdv5yE1fK+H1qqob41c5jm01XWsawMZSUbe2aiXp2B2iwLmzTlrqUPZpP9G0
8dcUw22TTPkWnTGtxoqEkuZ8xo0iuG06mBxt36P57Cf3tuU8Huv2vsWX62cpSWDTlYKdZo1KFgkk7nll
Tfzqe/gbszmDN3HZX9NdXFaxtuetWvx+uTv+rdzqb+3abl3LBQu6dnpMxvD+515/6/d6g7+ZMwMeMFrz
gTZRxyul61V8gyzF3igKWWEzdSuahjcGi5CuQRb/Z2gbbnsN111Ba8X+tZK2qqF8+Zyt6mxpk7JVzbLO
2Ko+rJGwVTax2DyTI+SfXzJbqz5d1WjW1AoZ7K+nFxIBL+v5ZQtJX9dt9IMzkfmv5SrHO/HvBvjABsIe
xg+C+1hew5UNQwPPc5kygtxc8Je6OGxuqp/aXafl/UINZC/Z/WZHy9syAvseOtOqj8IVkT41ydhM/LLC
SluOZpZv2F2FA/6tug7LaiwQNXMfM9D6ejx9PQjHJ0zACnoXqODW+6w6xRwL1dUeWeha2u04Ack6PQuK
9txt69+1obfhymdHHb9N72c7rrUb2RpVLoHg1vzzGvGtQ2+Q74i4380vG3zMPkP0moBzVs81QNWetftW
l3n9N1oHwBl5jI6IZzfuS6ctz+EMh0vLy+EcGFIL2MH6AH6YeAA6AkKHAcgnNpf+GQSG7AOwCDpI55d8
NognHCnoTjInpxBYyBg2zmJra9/XAjp1g3c7uq1qthZwHIwGDVqSRcxf8+ziqZByfizTSTbpy4IfivF0
OcmsMnv+KHyTtumthcCrGP6mX8pzf9H8k+9+QwWhgxL2CHaJYjeTp2fZ+P0baSLsoCcZUVMdG44I5Vvb
Vc5hglBMsuP6cQo6LOfcmMXMwWpfiXew0PMkR4tPkULrJCFyYFKE4vSCTjC4gmvaFLZSDE8RxpKRBV2C
O+alWibRB63tfRKcUTrlREEjSH0w2OZeYhNbZo4+lL/lizOy0/uxLG3zJbXZCQBc7EEQ6/Qjg4/3LH50
+pEh2grbINGEJ1YWrpjXyE7EDcV8YknsO3creYOVXQY6CO3oUB95oF6rboI1fFO8t1K2Qr5J7yVVtqwz
W+5XTM+7X9ss0eI5LUyo2OZs5fpDA1lnfw4GzgXG2ryPeYoV8c+/9bhGyDHLRUPA3KbwensHIVxv82BL
vXtatIzQerclvXYdu9UkSikTOPPh2IueoVHLR0MiY4fNNRDKT+WCQu9fJpeZ4yJ2xz7nZII5c991KC6d
jpfk4oeviAKXxA61zFYAcxU8Srq2+LIZyJCwZ5ZMCM66PcYyxhwDzYioU1BH7oVti36to0sRv6aczcvC
IVD75AQ8X6WLM7iff9Did14UWSVjcAuRX2In8h+IEpLpbdyeoGBAsd7yql5o/yUgBzlheZ3UsxRfoENs
BWftoSN+kKsszRWWoh6QCR9kIunXX0hLydCOtmShVOKrzBQ9UI1eCHq0IppOwBERV0Mnog2S236SA2sK
+CwZBcvPxUQqZRz0cjYzwtQ6Xi4uLcvpVLgt54Ub+A675DP7yJ/Z3MxsFEbDQtroxiE4rTDOz7HQeynQ
jz3QVGk1+PVJII+SQBveZLH4hgAHJj1WSFDbvZ4tdXyQSVPumgAxhOISiHLmdci6wyzb1i3DhhYhvIj3
bGJ3NRQ5+Ky3cWVS5Dne85jxIShwg53mIqh7Y72hcHvr9vQfsqWPbARdD0C7AdhWDOEEwonNEk1A6oVz
QTNGcRIpbasQ7J9PXrZy2rLrTdiqZitwXCkq+LTIiT90UKhgDfY1eXgi0rLrpuXo18gBAyXKgp8U2d4q
XPUsT78r15AROtbZNkbZWXqel1Wc15h7TkwMcp/hnKExzaJdEgxHQqMxU6kVdZbVkgNIHRs2dTt12FHl
9HLAc/7JBC1WjR4l//AdtK33e5lMBmg22vEdfUZGqwzMy74EeA8v/nxxLaHI06U4k8+qeiSWTSMUlk0D
SNtIcLiIg4Ga9pNRBG7KB5qMzK+GAYavFnGXIkO9NBPRTYnp6ZEl2Ki6u5KSiH9Uljx2yz3531jcH4YK
3AGvgQzth/IZ3Wf2Y1Kfi/EKsc+pbmQuxkt8GqZ6MjmtENx8bGn6JLaoWXWPmhFck97Hbeiu4qsQGCXm
4kaFi+wvLsOwRVBCCp/+vHH5cdRN58NV/ElwujzNi6hyMBQjmakzNtSUbFhVXD3/akOdd/xtzX0TYq9A
9vuQQcV6FeIvQPrVh78FmXZrOtlc29rmugY1gvEwC5kvat1iNMhCc2/mjfkeqMphfmaC8kn+ocRs1s3a
r8bW8iXsX4yRNWARbh58huY7P/4kzSes7aP0RsOO+DGvF/96u+IJM7mkuE2hbeHtB05Y47N8OgHZdrXN
N1xz06OzKjs57jRY2Ct4PKQLfvKPKvocfHUVDfhqyrpMDKcAbaN6wF/qOx1VQMZf2ppNtRZlOAT2/htw
N4xZKdB8tDFRoIpNtshxswQrp0vAMEGB/iwWy3aAXtWXVagi9G66pcxQeUQ5mwZTSuYjy5m5smi5LafT
M1Y25sjkILzSbrq1mbIyQVa/KU70fOqaQ1OG/iL7fgmDwEA/dgBfkF3tjsZAkouX1FvnD8Wonu8/rOdp
oQLSUfHdxw+38eNje7rOyumEBvr0rCwx+N+sLE5JT3oCNF1eYCij4VC3maUffiRpbS954H2TGIhJxXcY
WSGHaSNReJZWcGh2TqeX8zP8mOi/BuX7DqP765mMBI23VxiGBIy7r2WNYZrm9U8pmdI+Sra7+bybfip7
k0/5/AwW9FNaTKoyn/S2KWpibeAVcKU9TYHTDZd1Vj055UeSgHpYLilOcbeDm3aR0e9OkheJixNpIRQa
fmxfwVNDJuvSEyqebEgs7bVC/q5p2W66ajJq513poL5yUwvzc1+4IKO7zH3Dl4VCYP4BU49AhR2vPK9f
yR3L7NnVJvZqo4XeE2srs1b2HufRhqPwrI3EQFnf/REHbxF+Upi1YsrKSVagJbyonaePlF5fG6V+4kWA
uA5e4j/rY5XXZHzaFHpXX34kmekmsfgeGvSTseQLTavggxfNvLFE5xQojvWROOhbN/EduHTjq4S1M8x9
fGvLv44n3TvOgOBG6l+rLYy6rqNc+BYdHRHuk886pC8xInyaWI6m+Tj0LiEWW2Se4AQi8Q9uCMPI5F8c
I00/AuYTw9diZOpu6RV0ytSIil9F4lgxnir0bs7UxUg9OQhCEGqUQAm1en0iW6N+JdkLQSAFmc8ZbG9L
wLPXbgANJvnOceJltAoEIfEbNq9WhI36Vx2VcMsmniOqfTz00n4pPCho702OgVaUkjDpA7fYAo0uyPA9
tNBWkrNgdjN/QleNl+a3184bNYrrecBhRljoYqw5fPIHcRrOFjFrTjU1l6EwTPFwaAD8+SxfCJMbf/2a
g02qi9y5cIxoOmFWPazGuE38HAWy4BMJ99hsKnwdjEOHzb4bwpgqwuIZ0oCdVFV6GeklzuHtTRtubdPg
eci9Cv+5hzncZwQPDlPKVTv6C+Lp9xEZdwNlie7IZMHr4bHLOiKLEkTOW6YDEL6BO++0ebh05axGktLm
3TNMG4wIkjdPLOlkhE0oeSHCq2EzGPCua1IzSCRQvjDninmo8sdstlQfzUdAW8myBR+OHkLO4UovbIPd
lcdgFB49yTSch8FxKsrm4wxsPQrb4J10cn77JCROnUf9O9OQTxfIlV1RO/Y05R4u8mCh0UnMvDckJ1Ii
Cqs7od7l3OUrFr8sXpXLOnsmY1Q6sQENOGLgdEoko+mywpxmM2w4KUWCsyEGzsIfA7hkL1lDDLc3Fy2f
iQu7fTqtDBFIR5QwzyPLT5LXZ+UIczRMsnOQ5pwgl1LX0fTWHtDMmCiB7qO6bKPiHb1Mi8kUNZnCDrWV
8YSe7P+dXa6carokbXf/9Gn3wacHf/z09U5vWyh7EMX32eVTYMZBJ8JrTrU910K9QwnmRHzmGINkRybH
jIh39wGyTffrn7xD0zng5OXI3++NRoM/Cd1XJnBWulQbbReVB39kYoJ1TuFu8r/bxs7qnHOhfr0TgRq5
UCYDvGX49W0XGdVb0H7Rn6oQQFsZlcSjdDsy2+vzrKpAoKxtRd4/ZYYDvW7wc9+/WzRmQfqnn9CixQmj
t1LmBoeReuOBahnbmJZt4Mqbie4Hz0SpQz3AFH7wB0UqR8+pjuaEGIA2wFnjN5pYgFsr2hqGLfChS1bS
UtS/cl5j/ynjV/Nrg7+EzZm0/Ek6ObmtWWoxR5kT/7fdFPEJoknoShfy0EzZ/Mk3U7B04fypygQeswBZ
9VsYM+hXOOsJgx7YWAZFgZ0pkm9v4XcMqiHTIIqGfTtbdTSmmpzX1jHVuL2DTHK6hzl/XuFl4neLt9be
ZCIeZORaoUUWbvwS8XZGD6mKZ2EbS69PpeqBzPqBr2VfPETJk8lEXVhIDJPqI3w3WM43WMdZK5df9T7r
C+B5MV8KOS1z/VkTVUi5UDoyFwrOTQHzZrP9LBp8rfNwRDOcYCbOR3fFj7vqyXO0KBL4/4GkdXz8FDUe
Owa9EhPK3dH1bUHsBGPfL/PpRLk2FKevA3RKG3Hy2mS65DtThKbQDePhGRwFET1v6fcwKWQFH+7CcRpE
uD/dr7iaoCEtZi5IhI0lOgcjRYzPYKYze1AUV4OPyhqlFIqOvjvWAe22f/k03NoW1hCY/Kvb896yRKwO
G/Ia4TpgVDDuupxmw4u0IrdIBvarugf05AIPwOS0YA9KzNGLQvExxrhYGye6tWjkqUS4dl/VsU99rhKo
sgINLdYMmiLWmPQ8wXX0Q6RIRn7Lk26DXjHlrR4pVs1OeD4IgUTURtrOC3Ly2ojDbHhh8gYum3T0+SYN
e4rTAS1BpyePHF8Bh46PwLLKk4hqsR/93gkqjsLwdHE//NmaX8Nf0KfeU8vcrp5VdXQz3Woub0UtNatO
SH1znJqnJm414L0XTNNRhkEavBwguDWVlboH3b82qMFrbV9iplYJBhTfX8po5mtIX21m0oW7lXQSjAbq
Q0exI9wDlrRUQAc6/rXMYV8Aka5WMDtqtNhKttJfM1Ruf3GvfElEpGHV66hhw597gvcx0dCaZ/a9Byuj
v2vjrfgt/jbjLAl0e4m+DKwVZUlLIdcLsrRIRy1sF6FWOOy2KPgsZofMNhB62UZEPavAIj1Xdonw5wDq
GMvAYDzvDb6WKi+wIGmFpvXF3Pak0LGphbxNCiNollOy7BMJh4cDwtjCOUi7IOHZNymsH8q5Ho5c7d+n
rNuQmgy68pjBN91ogvcZMTB1o7FQ1LEJTRWF3JUVAInsKuozTbdlYSUAVdteoSyYjelnqAr2nQZsXF4b
VqZRETXmaZHJCDMERf0+OnYqUoAMEtPQsjuDu2mwGtorcOJAeHxaWa/CtoEq6JkKYaeGxtWKorjOFvox
aVObvCz8BybvXA6Ddx7aowPXZKY7OHHyFJ0Ubmw7e4Ato9+THSNsXWnEKBcc93uD9ofKra1qfjgaIqy6
z3lgQC10SJzDUQrJpGXCkDUdhZU/slKfuokqevhoYloeqc456hxohU6iUDs2dtAiE8zEiTUbCD9rJgSB
CtJBkIqF0d+0kTt9dz6PXS78czXd8/yxfecBJdVRMguVbpqfueqjppXrKK1qLkLXnlGsnL6ni2pq0UVt
ebSSUTHNbqDi7jE779HH2ID0w3f8LIzE0ESb2Uxoa21W2fQX3nLELKIadIaEY+bC4Vr73buy2pgzdAeP
k03Y8TOKNV/jT30z2YigYKo7iDPZ0BmCf23TQLp3v6rv9vYYTo++KpPuV2Wv8U7Hr2Py1hUVTfk0aRbK
sEU3WaeJJGhTJzqhV1H/IS/yNaxQI7MRIbAbmU09zuKeQJqT/IOzkn+4vOSGIau/8C6UutIRZnYknaIu
8R+ugJkNcB90HBXEaxGYWcSmp0GQWMbUM7o2jdCEctZBoVurZsRRLXpqF805pBo2mXztMWNCd0bNKzKD
ejPU3DambX2Dcg/Oa7IoVZpyAYktm25gMSXkDzQjfIyazpQKKaC0FldRn8Ep8xcF1G6npZ0oZ+Qt1L46
yrUljARwAKK0nDN6cGPxMDrH5hgMTuc4lAODTehNDoOAzs3yBlalra6A+Syb5+P3rVJqmMqNkXZhMt+g
8rYKOLXFU29YwL+ALxvvT1Vo77FmWm+zKfz9PNdgSaewensi/w+csPlEFS3rTPge2UAR7cNLPAPQN5Jd
veH7CzqX0XnsrKzodd+4nCFfP2R1KHG7mv3lohxPy9p1oJvlBTbZSwY/FCfovn7JvNVEyZZbMpWObd/o
WQCSfbfI5nvJLoMLHFx8/Ib7t/08jzi2jc+y8wr+i8ltWX181l7RQjyHq4FWVXnxvYx8gvlWUny2jF58
WrvMqfwXYhHJhRjW5gUpNK/tUyfyZQiQ/cQA/G/hbifX+KR7R19DcKP0EusnHtJ64/g+emaLX8tPzzQP
OtC18cVzvOvE+ftO+tiJOkPpYcfrGe0SQ0IfU3Zd7bHHa7pee5QPILsQroV2c6l4DRhIUTHarTwTjixc
lYzkKORvuCli3ius03WGiyekbPsR2cCeAYeJbl/CpxoDOM2yKp/kaREuTx4mu/f7kmk4VV7RRwJSZ4Df
xCl/Rx9FJ/l0mgcrvTIlUNM1ERKXHUZpz54cPj/84dXzf754/fbVk8N3RzoYgmavxzgr/uf9AOCattzZ
Vq97tPfL8Lh30J1t9Y6S44NuegA7DqgrG3dF1d6wJq+dXf8dWDBPx5nx53mwnrS85DXxk5P1g6jKc1GI
uh1O6IoTsJfmZCnf3HldS1vv9IJiW9hUeWVPpm037pbhDuoiX4zPXkladAfXMCqrnagcfYSIOq8xgL4D
m4+Afyn3AHRNwgy4lXfEEeJalzFVMjYRHQEnvoOs+Cf6jVsED/tuL5BOmk25RHqSLpy3PYdRKq7QV0xh
4vEDudUn8V0+WbHBJ+G97TrNcfxHaJcS9ErDY8iqmtdoxOLFMVsJLkgV/g6JbKw+yJnZfA060K5JAoje
VhOPDO5Eebugg2CxRRhhAI/M2bD7p+92+iD5Ouoa7DxEhL1E0pMGECJfc/nbiaCAucEEYTlk5lhIiWU2
8HYb4Cl69Ogzam9haf6CcNcw1bBsCbTsTrvWJxCbvkKWnq3ocg3eiGcbbmw82agYySg8ZrYcseEHFlIA
R6kA7vrixxb+2JM/BvDjy6zEGr59HmuIGxQ37mnFV7RwJXi7+uVpVXJkjFq6EyyAfSBzrR9YRCdp+rCd
gMi1u+OBUwt7dNynv3m58vSRzuM2xKDXOEII8wgzoiFVGiRdjfUgyXvJPQ1fXTAd3k6Yyjh+E7r945d+
QnYKe+w+1RXfpTiGsZn7WireCxxxsM+cw+CdrC0h7fQwEFSdjqYeAOBwskDXvYraZVOKcsFa5IyLXzeb
cwEjNus7bOJlzYapNxd5Z/Il2tb0i2+hBVAlagnu32AJFKzdVotgarvL4KxDVV64wU6uM/kIRkzKEdHn
Ua5XFf92Y0Kbv8XGlVjgf/a9QoqT8irB3GhqIh8c+9Xymip1/VkFNi2QUst9TErBnnsX82EiqHcZ8BJU
BiBjk/3vWv2HRKhEJGQLs9TIGre6d3gymzio5LuLZ6TkCwCRxA2utEp1vY4iB9tVWNBo7EcLF/GedJX1
DnW2EVpNKVcXoNzXJIvZQ+Kt5BXBCI9weLss517ybfb12hPXuhc6Ue4lD77NvontN+Vzy0E+5HyPvtxL
dik8Pq/1OGHWgqpWmL6VgQxqJZ8IlRW3no1fddEETQuAXKcp/AmkfrzxeiLdv76/RO4tuwoE+gnZGjZe
tAMwVhOihUy72z49V2r1kj7L/C0fk2BkY+viSWXSfvQRP6EKdWXtnHV6Ab92+6hmoNnVVZY3g5/NgvBx
wRv2l+rQEZHh5PbkOyUtkXQHpCkskKLnTmD5WWdqdGrooQ6NjNCyy4DGSM+PvAd7NximWF3lzxmm3vZE
Jxyhnzlajmb+Z9q0k3a35OZnopaME+GJZ731dC0GE0b4V+sfUmuOyJcqo0MMi5eth6l0R/ZA9TaMS9vN
ypsoBX32yAHSwVqMJ+ZGhpEkOuSGBVz/3z7WAIYrl80aXOdozMIfzTvqEt6vDl2ggs7avV0FCPtGcQ5s
8lgj1sGDP3568N2nB3/69PXOp90HoXgHKp5AfZafLACy+p1O8ddni4bwlBRMQKWBUAh+0IOeseIMa55s
4CsDF/z3Ouop8ArUqNLpq1K+yBJVhOjBbahSRt4H/sqvgUIGjcw7sXkYTRetJvpJhTm4eg51MowCEVy8
uBLf9byHRfs33COTA4nuAP7ec8oHdvKLeLAJmJeVXZluDpyyLep6J3r1N5ai0tuzu5xj4rKLohe8GL1F
cyDUE+xYFHbsiAoOwiGRIRitoxeX9JoFvV67yfx6J9rD1no9tJ8OFi/LmxVP7Fg9K75Iukoivd7cuP0E
5qe5H2eGOD/aQvnJ+QD/b3GV1nN4PzCHd6zt3PCYuRbOLoqtxgG/H0SSNDZfBayRBq4EwuBE6IzwUGO4
g1DR52M52j2+7m3C5FsOmEh6KKDVQR8O0Ymnq2KRAqSlDIi2hFxIqALc1SLEGwYWj74P0QEundeBhyBW
CW9G7xBfkHzO0iqFqUYLPxpCU5vnII5bLXC0kfpySSO3DzayGh965SwGJ6WpLp/2cE+hkEIWRAmO5iOW
acyviScR/tflL351mDRcymISkS4DtEWGic+lJB20HMYeqFY3ahwcC2wk81jz7Yef9oMybijptUGGbgfS
uIxF59bWjbFwNiItKHoHUNQQtGX0GLWoSfEvBhfZ6H2+GKTzeQa0V4xFM9gLJ3k2nbhtA0l4za03fJmJ
IAY9xBATjg+YJLYspjJQyjI6DJ4Pmy9uPGyPm1DIC25kMh7z9ZJfw4sZSZJ88/W0cha3G1/Aq9YbogrB
xQ8KOwyXUxIfWSAUV6sYWfwasn6crIguwb8RXztWVvA62uRf3jTfKl6Wc7MLz7cbNwsVHw02W9eIn9Vm
9m4QQ2v11PlxtGiQ4Rn0r8V+LC3PZrVFPC2vjR9Ta8PznrScAhoDa8WtmjUMYSCdKg8CXQo7Z3X8rbCJ
s4aNFtIasiwBuHG/Tc7N+Hx9DkNnehvOfoOr4eKJ8mF4UaX0AKVah8s/fdIVDJv5T4gm1re8WM3fv1eU
MW0hpQSJQyZUCMNc8nixPSTwkz7UqB9526W6+maHv6Y6LJn1FvfFw5JRZOd8mi8uE8ymj/F63LDK5OQ7
qt/hQWhidLJwRqJsDZc5vE0yQ3kME+2PSzvOhTSU1ky8W2CcId5A/UmGDerHkIKPdDv9g67pvNc/sIUr
0/SRMDOA48QRB7qY3sBVUzb497HwYqbVBhsKF466nnRk+VUbmakXMBaH8XZevtybzTr71q5zvBL0r1Wh
zBQMs2uDrgWRwRK/rixEDFNGRMyv7scT6WPkD6ov3Z30kw/8cqdYOXymJgJHKBSXz0Pkq7yMD0h/Nm5B
z86OdoB2HxWRuKBV32w+i7ya9i+FdrLAESBvWwWUMxbVdoryIvS64S+dYhTGGQPPlRfL6fTvcCOKmd+G
r8HuLqSE3PbW2/7H3eHW3c3tQESlBuS2NHYaXL0cwenW3TVhzkxY4Pstc0k09GjoUmTkYwwtbADndWn9
knbxsQ5pplZZgTewl3+X+HP9iEEvH6fvkLCqTTgGnY5pQPEOBCOiYAfGwV9X5z3ImsNlQa9lLBhaHtx8
vtmtgKCCHOhmwuI2Ht4gHB4OX1xgM6qHBDh8ltMJ9FihiDW9RCEvW5iAFDLVzB/wv/kEznTnzI0Mwjd2
ls270l3UV5QGtSHsbxOQUxpWOeb6DJMDtlh7/taLhNMLkw8OknWrXRHMtwbHlFWTQPZ/qy2dxI2BWitb
aadnJ9MEoQosIFj14SPXNGx/LaQlJs7i4YlZAP0snYgmycVZViQXWQLSKBymgo5oTdwDR8GN+nCY0cRo
hN2xlYQtQ9vSSeKdYMzGUb6Lmj76ZpZskTzsVBfR6YbRKZazUcAyTqKzwstlnY7yulyvl0X5w7vX8txd
TZgSlD7BVm+nq+iZs2ZAGd7V2tFkfs9YMkpmjd49jPKfow9Ex2YIFxdd5921lc5KwKBWPTHQejVE9pSQ
ItFrVpBdZLsx1zyLIfPJo4AAsa23miJdb63IIjgJgN4BHc/VjUgceQd2DXmlCrgiuj3agq96n91By1+0
9F3tYRRwXmzasnEpzpJYJOkG948XMrdlxNy1RZLV0WtVW1iDG3sDota2k1guHsEm/RA7jz+03mYAT6Y1
SPznj7aBPK27+DWDeYqwAm3CuOiU4/EYLrlKPx+K1KLbf5YwLeNlvShnKkxLLHqLwsEqVanI3dJYuBVh
o+d85FFgFuU8GP1FwN9Wc+7FfcEOAcKhbmJ3q6PCnJXnWZXYsWFMDBirUSAIDOqdXNAYcopP20KEeOm4
gWM2+L6Ixyqxw5OMy9k8n3KVvpqUp+n4THw/WyzmblAzQ05Uslk9eRHW5vOwJbIzqdu3OoLf2A0Pima6
gK/YgRPTBOPew+iEYITUvChxaige/j6rZ0KNrIw0wpvh6rwV4fbfZqfPP6DzwTYwTtSfPrq7nZ/6QUUO
BfGEIoqEo4iI+kn7dN/K3tW27ghbwe5HNPKq21Ck2ubk4QqegQCzPstresnLFuMztTuMCCI/OMiYwCQK
kPqi88PSb/aKrELMZqiXxQcSTVjy4z5XtapWtDfsWOpSkLZqOJKW3Vpecl5My3ThNIsZT7yTGUDEKFK4
0lOn3lOJJawt3GROzuzo4HNWkxgKbwR3lyjIU8A9FJuzF62VF1zh6mdXvWoOrdH48H4tFPzH+mYUFuXp
aVPWy2shIYC2QsOsc05PLIX2xmYfpFuivcQij7THJeQzKBrYwWH0bkGSa4g+nUNNUlaIPJ2aMUI1/MD7
5mTyWAQhSfxlWdA1IMBS8J/y3gyyIRd7q6WDWONIFYayEiEI98KJsrbqHOkTQla5e4yKNT0g9CHfdwCq
IBsEUGd9bdEFMYAWHRjgIuDhE3UJQDCdngi5747bBaIMCnhPQ6CyrHp5+OpHRzEeJ3uLDl/gauEBQ3IB
KqiKJGfPaIKEHNqe43s1PmDBn8/VEQt/K8zpx1MlHzacWq0o0rqgvx79ilaJumZPTwdKxvJP9IxOI1Ym
ONPhRiqzjyd2YCh4sVIDLHt0137I5LBA8BmKhOLBTcLmiPXs1BCTixtYrkoYlp5Mz9KsZ/m7sFoug7Uv
szIt0J4QZ50rWcNx/hOp7RqPc/9Ad7e0ELutWn2nCp5rThWb5G1Vhj04uaDqmoDuMmS6pFymkpBmQ0it
TARSrVGdYyJwi4+eciBxm5ncUXQqbJ+iNYXvuARNXexVWqo9c+sKU7cu1rnLTjx9E9+bSTB5WUgzppif
15O31A58r0GzyszAbQbLGbLftokUNJ3LZWGl8lKDX2su5sn1q+dT2GodJwGM+9atALDLWJBEhCsdoyhF
DI22g8pK0xFzou/GqgNyyJulxTKdNvdgYUSE2kGVEVn2kYcZGfrJ67VBg4q8I6sl3GmWnmcEFw30OFgq
8cCaSxhzM6TXXT5a2Ql8voblp76hFS+YPWzMBNQ10YxRHOlGwltXOltG+KYotd73XOpXAA7cRnvBzRJw
7ozuFOTOYayxxAv1sIa07jFJsaSCvGAovrl8std0z/Aknw0u7/vHYsSk2p6Hnws8/BPy06xvyi7QcqBL
WhEhMFBrE5YmkIWddcOaHOXH+zfjJtzo+zOxk5OTz8RPVgD+YgxlDWvoG3AUT5jBO4T3eCFIQIvkgQNU
lshLiLtzTIWANt3F4Sm6cUyTeSZsGcfpdDpKx+/59hjDXFfKRF8ZBru88ZncgDybEf5T6b+Nzr95IxO9
NGzjCDKmgrmpJ+Su39l3ROA7tgyLxpTWlyAv1Fblcc3IhiX+E2LkJrvauwGx4mg/eoR49xp76ycBpFdN
bkhF5K9VNsvN8cIeDzBVH4EYinSsbDd4b8AyCUJAbCTzUCYC7nkkSnkKThZhqROaY31opgVemxBfoiYu
LS6T7ENeL5CmzX6Ib7EVm0rdsJMUCLAssolO94tW4PDzBC7C+iJo3wPNXjS8I9Pf9EVR2Y0b9Ql1pO/l
Ip9D8tEXS95JkyZ530dL9BwhoDI/SV6l74XBitKR58U52jBPMxtKXSY/PE8mZVYXHYBXXWIuC2LneMmC
SyfwSECiAmY/DA6QfMQ+LkoMLz/4E/ybfwAKQXd364NMokwsvaQz61ybVOOrTz6ZZEXnqmdycmhSVI9P
ccFMv52FpRyWBYTh7XUUSvjhCICXFpPj4t8lrlITdPZYhztqgMkvrdaxTsXjn8h34gYH0fvEPBA2Y8Er
WtOpno0EJ+5y1ZDY1H2xOaMvv+35SIyBXIUVJE1KXTu+HZNdzzAtDvD4rvyCjx3MKh9/qmr0GlLHHJIT
8XTWjSXe5YiS6uiNIlcn1Ie0Jhtn4jV10k9m7hb1N6i/0axdIxt0PHUhWUogP4U5EqkLUNaBQ+lv+UT4
iu8nB85u+j4oJLfw8OLbgMtbQij0xUs9YZ4HrTdk6W6HqSksEex/Z5c/u3ExI/bL2QpQJM0F4a1xDyGx
9PbEFyhdX35BBdsq+SXwuNRWfPEJ35dfBOYNK+7378yzK9/QoFbJNzFfSJuM73gcJeQx04aJYX9BYSjE
T4k0LH56IwaKfUc7FWmyMM8enuIUC0tICHNYVbJZFecsnM858B76Ah3UNcpLQgSHLeJuboITUaNGN7mk
PKYAQDCNa+9M4BqPet4U3sIB0E6HEGCPwk1By393IlaNnMtJ19gWbG4VI1r1FOvP6oHDxWwVjZAGInZj
NiOPd2qGGo6bsEak7/BR2+hSf4cL/GrD26v7FylKKxEahF7rYFZniHNbkZ/fqFaPktNM//JpSPVylmEU
KBBaJ8kFHcdObyCSX2RwJS+SsdiTudczVBMn+SNORyJ8AjvoOz33FQZqvxTdR1uK8k4UfWVJVsNfcxoF
CvvJuCyrSV6k6FMGzEejLkKPoTlVop2kA8OxJ/FpOh1TkLzJa8LJvwz03dnv60npm1F6g/gJWKPyBRnr
Tqy7k024CvwQB7uFAWA/dPYjVWgewnW4DMearDzaFBNYGeIOQypdnOVopoWBib4Tcby9A6+10UmLUIax
EH0h2Wpt/BsiwYQOkttC1lXrNeJ9G8Eg35WzLBlh1HHUQk/KpIBzCt2qB4KpCmVmDRMEt/p36Ula5b0V
/NybKqM1acd/hVWMx321JGhxOZfdRt4y8RYSdVXRhoryluK8cgDWFIxRj6G1EweDrLb4erDNJIXnwWNU
jEHNNWdKx4tlOpXMSfyQ/MkLgSsmwNWL0VsEGtIp6Op1YuDwaRFjDKQeLMbRWB2MUSjqUBDCzp41X6Lb
wMs+KXbmFhM0P+VJtp3cTwbWuCjHhQNJqITmNrM0v+kotIVDe4uPqix9v++NRmSlvMXhXAdvawr+pr5c
YzSUXPNfYmms0aw1Emlace1R2Pj+Tstx5d4exY7aPY7wMH/fuk8umL5YxowQ/sdlhXltkz8vSmD749q5
VqgdLNgnWt3TNcX6Kmnfu0daTMBHOUpqapnErD6yZ9lV03hT1sRfXMirFtBavIY7ownOaE0Mjc2fL4HZ
9aYLVyAyJiTaR0003HrqgsysqR9vx7d8hoxQ7VUgoJIQMPxoSvjoQlbR+kCsPYN+brnw2zKrLrXYzidZ
duUaqir7fwrsoVKZDgmMiEJYVk+mUwHXuDZd+UhYJq0hK0U11t+GqBLp2p4V6HzFWqHpPHpa2J+NTOYY
RVZZvdoeEiv5srmFxHxpeuujQztZSYZteFVpTM9nqrGV9ydQVrOdMvzwV170K+NLZfnNYCgqnBIrq69J
3tvkA6Oa6sy9spnr19IuttMN8/yjm39a1OPpss5FYnkuPV8rrFNj+CYeb8mxMcZP8ehOQsC9fpwnGcqJ
PRl98bBLKl6N9AMJRa1pmjk0727GuU0cmViwD0lJajhImkMgqnrxpH6JBuFFyBc0FNrGgMdLu/XcFLC4
UmoiVDPGX554iwZr8l7Yr0H73aRwRhCP2rBmTO/yWKSrQ7VB1wl25fFFFqrqY3AOpbuV3KbBCQ9eD21/
INUuxi9vtmLrrtfVyqgtv18wMjmU3yESmXzuaBWGzDKfSYwf8BoByOblHF+2LOZtvA39hOUmFhgHeHte
1XoCEsf0sbU7tUb+mr7UcBqkZ1k6aeNNreqG/KmNq3TM05q8BaX5Q8jXmkH/LN7Wjlu16c4qV47Vm4EK
zF1aSPQDupCE3KZV420zwZ7rtHGOtt2iYz7cxl2ayzgBb2nl+ax+z/JCRI7fS3bVtxMKMoB90x8sDuYs
hwF+y4imvde0EftWeDxrsrc8l4VJQ8C3zfVHHmLNXsDRWE12yNVYB/iLuh2r1ms4Hq/rKqwbW701MR7e
G4uyD60EUOEBbNczfsSa+jZlNZdTUQytV8iQM/upjzMqlQZbVzsKZMncTElAVhlFdixNdEOv1osaB5Xa
Gd0DycXW80DVc6GgdwOZ9yIK9GgWf5lezXtEuCZqMr7/2ojl9V+F0VD8zVTf/A1N6FZN7wbR9Psajp99
X1JKcEoMFcm/HHkiQE2PdV3tBho0sYhSYPyhyCOKdiRn90T1Yo/pztqugI/b91yKTPaEHeUiwey5K9NG
c3Wfr50lPbI9rfVhTKi3Ku+HTIyWL4SJhd9Ts1VhJpPxW+kFr2dhECD6ZvMCFqJOpl1B8dgO/Jywf3J7
3bljr1ogXZUT0Ml04Er7JqdqCGQwfEM4ahFWDZYoUHZIvh8dlCP0jAJBOBOkT9JTj5xl133yuJk6NHZn
GrpsqOTR07BHjuEdesfI3ULXCIlZ4EnAAoFpqXdCvcu1yFfPy20kOGTVbvgeHceyXZ49mWYvmmAvZn3z
I4iLcAdYjnD7z9E+OpcGMVryIQP2Wlqv2Z1GjinPfmDF3LQyIbDxFkpoYd+StUnex27izaeUf877p0kj
aivz/kVTvv2RIWmdrEjr/nfYXS2gfr0TgfowwrEGmJ7Mr7+1FeotFGUwMF8hgO7hHzUDd06QSHIfnTHF
LJ+TMMUqaIiYcs10KWYrcLNn25EtyH6cvXCjnCgBzrHC7DM0yxRCSmVE0SDdhChWQZPZY2Bm0Opy3am5
ScKTVfPCZ8VTVYVSnSiA/tuce79tkejEbdLioYereRqznGhMTanU76zOYKLbqu+yZTxHiZ5nM9INNtAV
r0P/opk/fq8MH0rrk3RI4SMzdPyo03KQSlkp6/oUswIGhxP3xR+Lvsd48AmasmYVCBSvA5MrRsMcDOUH
njpCfLL1JDR21kz85q3oi91IoyDRH+oPph5Mg+ivx6qjCWnyKUEPMYkfXHL2jDDesdpTz4Hm9P2w3EMw
AexEUGiDobW5uhpaXEWu95kF1tZWqR+rEmjwLkScfrUNYKNNsllaTPiQ1TJw4vMkZgHHTIsMDi/8NuTE
4tMJywXQTzBTOEsymU6nbsQA6pNPnDWRUpI5+u7YhIv55dNwaxu2RqfHvnWH937pUQwZ+IyBh4L3a/Fg
Y3dpdlXS4omyTUYCF34Aqn1+20MWE/ui6Hopinq2MYRMS18H3jQdFZGq6BrOrFJLeG+dXkz+qwCtfeGc
EAJcY0zh4EumEpVZxGzzdKk1cPUZj6ldSp2AGJ3wJFXsnVN26xVlbRxLl/DasqurdEPCG0lRwvzBaZwh
u67neI2CO585O/CyBwu3OLt0gf358PWz1wneLVn1mOzKAML9447AkGlF3Kwoj/1c0Q1as7CiRORcQRXL
TiQ2NL/keBTuqxMSJ00KjM8eyONEHgGSw0kNBgx/mgOv2enLchuozL+gNVyrtL3Uta6Pj9mt9izKO8Ko
vcoGvy2zJXrpq4QKsOapStMhlZlnKbLorNA5iJvHThdrxEZ8Rvt2o8gxOXZCs3rneqP5P2IMFBtdsCAK
NnCWImlPp8kUiL2yH32TaZniK/1GjKxCrKzJTINYEOs9Lyhc+UYcNrsauY6csUDojQyqw7sw/KajEwWE
y/vR753gVgnDi+Q6CQdfB5LhlfL6+Wy+uIzoP3uO3yKFbO90vDgXuVQeBHSc3fAIPRCKvq2gUEoQlvr+
g8R9l/OU/NN0lE2TvfBE2AqEQH/SzkaV9VgSfw1ZffAGIPMwR3M026uQdA1kxbf4LPdiLzaym8Fu7K7M
oeg+tKT1sHuwN/z0S9G7d/B4+3TGBa6ehyH1dQc7a/A/8jJRx9NOyxzV/0/sWem2I+8raukl/Ba8nqEI
E+DXMBW56nXV9V3b6u5v/P8BAAD//+R2TkPrPQIA
`,
},
"/js/angular-strap.min.js.map": {
local: "web/static/js/angular-strap.min.js.map",
size: 189110,
modtime: 0,
compressed: `
H4sIAAAJbogA/+y9i18bR5I4/q9M/POeRBACP9bJQhyfJIQsYxljzHJ8bO99B2mACZJG1kjYXOz//dfV
z6rqnpGEcbK7d/nsYs1MP6qrq+vV1dW/37tOpnmaje9tP6rdO0+Hyb3te/H4Yj6Mpxv5bBpP6qN0XP8t
v1e7l2fzaT/J722/uzfKBvNhol7H5+fp5035V7/I00GyKf/qF8NkOtuUf9WLs/lslo031T/qVT8bDuNJ
nmyaH+r1IJ4lk7R/lUw33U/9aZpNBtmn8ab5oV5fJsOJGJIsvjGJp7kpbz8kZ9l83E/Y23SUjAEROX0v
W9jIJjP/0zQ+Vy8ENuLhpvyrXozj67N4uqn+Ua8m2SQTqN7U/2qM9qditPnkZtP+0h+SYdKfbap/1KtZ
fLYp/q8fBLQaLe6n/pRlw1k62dT/6pc3kyS+TOLBpv0FHz4AqCM5peLnKJ5M0vGFeLp33Dho19qNRqP2
qdnoNGoH8POq2Wg1anPv7yf097H9u1dLd1vDZqM22m20G7Vc/G3XLvYavbZqTZRvnNayFvx+0mq0/147
gp8XLejvWL5tNw7btQ78lKCcNNIXXfQs//SgcfmuC33Kdx14d6DeiT+HjfaeenR13a/YFnbvuoFy7Uar
DSg42BMNiud9GGjPltmnYJ3SFgSiunvFpY/su5jWu2g2pvs9UbGj38quj1GhFm7noNF5oX6tN9GXFh4C
+9WFX/sWdfuAKzyMtkWTKIKx1tCj/7lly6ieW42PL14JGH/qHqoxndgCF00OL8G4/JO2AFUOBYe2zEW7
sd/2GhLkdYAbObLlH+7awbAvT3aBDE/sc1+Npqt/nQC6OxaCbhHQAskHbTXGHpTpNjptNfMd29+RatCn
LIlpQ0mwJlr66wlFckcBaL72dI09Va6jcLtrB0JAjRv7e6Rfgo9QR1ttGEPbEjgrfWQJxQGj16aYmmP1
y1T72IK2Rk1K68eqYlvjOoYyJeNuAxG28OT1AV2mlRekUYKBDupSIamNSLmQ/jCknUXlGKOIab8aM902
ejTvdMs/P2/08IITXPGq9Urg/m9i2Tv6d4vgyFJbm39NX75QkKbNRq9rJsxgxyEQVpjh3UcUMMNS23x+
jy0aDmjhIwqFmyu5DhL650jhp7XH+ViP4lHTn2Bm3QBGxbJr76KXqXxWP3dbD17t1bZaMIR922UC+LBS
R0gyybOOLIU5nnwM8Eu4tiR+TtXIzMtDgF3W25JNnIAMS0B4yc9ZE/q9ajdO9oLsut3owhTtdYgk6u2q
8aNpc+g+onPn5Jv8NXeL65Oc1YPApIr57PL5PKSoP7Hjkt1fNe0Mntg/B/ZdvPJc9mEROFJxpCl5X5dS
U5s2z5o6VbAYxuZqHNDBmQbw47xJBWkXENkDDoSoqd04eI2ZR+t677kWKM1Gv7cqHR0HyGjfzpJahZr1
GVwCQcuSp6BJdd9ITUi3XqgKtC0AZvVoRauPZqEFs9DSuNpHhbveUus2jl/VPjYbb3qmjFxIRoJ8lDB2
0bR0gReLaZbznwuIux6NPpT4z5oWa5hIOysS6WmAMt271fkNo9FjSkn/CoS62dGEOm83TntqBKBPv1Cw
PGna6dF6WauNmIzQqfbbeunDRLUVM79qWrS36VD3LXWNWkAXjIA6mpRhtUhNzGlUTl48blpepmFq3DTJ
wBv4s2DKh9Om6pRNkBNdDoSLXeCJD0P05hU3sv6YDuAI6cxkytNdqMK0+ZjqX47MEtsTo8RT+kur4w1f
Ye7hl12C3q77KZmIU+edYaGprI1tFr3OjcLH6NIpcoLNHXjTd8CH0NIDPKErxdVwxgob9GFjHyNRL2Ki
pPWtZZPQaTgByhIAnnbVF0u5e8B59ziBKErVSpj487OkTLfqXcNKwBtKzZtoqp2meiPocdhEMvvb6LFj
ebghynYRUXp1dXttTK0OpwcBmnTvBET7L77jBPca+684RPLDlUCIFa6tBy9aqtd5S+n9DcW/tLovVfsL
Q+b6u1J7sLHWwebXoe30cdvOZ0gOHNFV4cSsFJq5M0oVAIZpt/k6k5YNKrOvZK773MGQda0h50hSfs2b
dA0/acEaMZK34YkOwdsP9AxuNS0RyPYu9qwoFtRuZNwJJdS0zBrAiDlS7iAxJwoOI0n2DLbY6uy+QNON
OZGQVTdKieo0+vtly0FS266VrwbnHcp/+6oXwyYujBwjgkexsyYF8lBjtY0WdQ+0FIKmkRTJchhBBUbD
JPpF/iHWs+tu7gDr0ulPaItGNF82JRbaXAh3KL2fWpah8d8KKywnjJ47jcOXmLzUtLamL54rAkglTuTi
fCILKMdd1rKG/BIKcGzf9S21CWO0ZdksUoXtKm3ZVep+tXE52cyBrXvquMQ+Vbj7torTt4808Rt9+9Ta
crLgqGlXmCKClm3y4mXjuM1N007jU9cyQ/HncQsW3IFlnYeNR90XnCqcyHWMqcsViRYlCv9rx64yR0u6
5W6D62Yjp71j/2qrTUz+lqcSuY6xt6aF8YAlTXcPSQcjVbtUMrTbljjaRHIS2LSauv+CPDY0j3Dyat/W
dbBhTt/C7e0jdHewxS417Ywweoc48VdSwb6FkE2lE3TMVyKVO+bP2fcmpouH1w6MkTHaE9tCz5K6G6MD
vW873tfA7PGJVhJXmgmHqAWCqj7F8An9eko9U3gqzQex4nuN4KQw+jlA6sS+N+cMcYdK8SXvbpqW2BRD
WCc6nTcDXUqbTsY7YjzR5OEZmIzJnqAlY5zCjpQY1fSoz7KH5qjhKSq9AMUd0F/eFok/1A7inP4cK1ui
R+fcfU7QxAirPbaDkzstqVNdhCzphO0+M8FtvlNi5B2hCaHkGX+98X8ax/J+AOWE970QRZ63MVRXTUs/
hnQwWoVhx2wuY/wYH99Fs0tYUwurQT06cU4CO45wavdSuhpLEqltzPZd6UPLw5zxcYi0IIfXNvTe8Qzx
A0tyxq6ju2rEza+L7FMTsYU1rcTKX6ZesO2hU0Q/LWvIEFJ3kkWYcD3cidJ63Q7Op5bVyI8aP72UylCJ
c/xnRhzHGu+WggkErUbWA8fsuKcn9oAuGbMoRqKUoM2e4SfOsb5vH2O7YPp2ukKqIvvTU/sgu1jQBgeR
St92z7btsJVJdvekUDk9aVzt6vHlWuP5bXfP38kxE+vc+KcWzce2iHO6MW9crNdYA+8BnNI/rvIxbSEn
Qncpv13Pcm3MWRoNX1Mgy8DphYd0FhnTzXbBLRYW8YaqT63FxRSwvGntvWNKDSda5fTI7IhTMynXskvR
/dm3C/rIwt+h2GLaQpsivR3AqvvDihxaw0VjdRdjkCHvxOI85HZwj13EhMwAexQb+9SbwzbiVNiAqyfs
5cN2wKPlbeiJVX3c5mR20QyU7FN4jum2dwcp1GYsmbbU97totg7oBOxTEiCAdbBnypjNbi8XJOIu3nk0
uitdHQTbSrKyGTlRDN1vq02lCfOWHAeISsPrOy0X1sDyTPobDxqvMEBGm20jCWM0yz3/XdszrDvIbGzg
rew2xnnDyaM2rn1sOYWpjX0szvglbtr9Nvd79BRzlkto1+6ZGlLWs9/SCwLr4C39gQwgrOCZoRCQOoBS
B/BIAqdXRXuP1z7lBNLAdkY7MI3CsNt/WQtuygr95tBsLJzARtYhbamj9pt37bpvYYc0229gi9KF+pw0
ulgrO6YapP5w2dRGgliaJu5FE2Da1FLV7b3GdtpcQ3mT+hudhtVGM9P2qUpMV5fIe4LDkH9Wz0TLY8br
TTrhH1uBXg8RKhqBJd+wChDZcSg37/rU9fvEbVNdaAdiaw+tSmbHdq2mzMyUi2Zg+DFGb4lB2guA3QvA
3qPoPA44qw+o+u2qucJbcn+hT6240AIM2WlZk+4TFs76EZ28rt9Mg4uUvjVqmGs+pMt2kQW969SIsCrQ
pUCXaxWa2Ahr2g8QZRqacgcl20dx7pqTABwxbeqIFu4GeLOuxiiA8J0bZyUemInHs3pQSL1JEWBsV8R9
uGrRiDNdudMNkoTDpEaL2ekfNSmOj3EZPYUjSYJOpoc0PtXOgZ17VtA4RRtyQ2sfxPW+7vamqQYiK+22
Ob87AjBC+/ueitgKUw0rd7hkOdbecVG5Ixs2pCmH0J92AEnfT6ttQp2c24kwvA7ldZxQ9q2fPsaj8djc
SixN8IUXe3fOKFNp8J4gVXC3bUhit4QBHtBQUsJPwujfR4WJ35bBVs4rWAAmYQR7QUZwiAw5+c6XAu7x
wM64YbttNOPfxB/mznR3xuqy5lzbxvWw/SZG8uvNAK9x8TWheenZsAG2zEhUSHglfkuRo2CR5Zao1FRi
ukS7S+okRxTRYWu0ga3v76ecIOL5LmrQljQzvdW969E9W35mLTRQtMmy6xwX/oPWuXtkuhRmtXfBBaSa
v4ABwA79i9XW+R0t8X7REv8ow8RCq/OQTtbCIuEFjBS/3cbBG85NnOHVC2BcNdMaD5t7dn/gWO9GPzS7
0SZgpGwfek8VGZmwzVN98oRtOh9bfveJHUERsvBmFx/kcCNU2+KiwMToPV6ApnHTMe+kmx7ME4kxJ6zO
few9dGRzTPHl9qzQhkfatG6j0DaM890rpTxvKg8EAbJle3Sb7iEWvrULfvwQCbABOw/HKR1Ch/qC3J9j
aJntbcybdtvEOK69kKkj1ELDMg/Cm/S2aBvXiGkDh4GdlW4jeQWr+awX7LPr9WkP3TS8kCnWp4kYBlwe
w4GAy/byBwKO3WS65zl7ztjziD2LRTZqkxMFLuzS+e/Z/I6KI3xdpIrbccielwZlOUwfwp70aYCMyJrA
e/jrLbuJtZK/f9SkbI71N9ptHNKo24mJYBvt2ShE5exSm/lQoy0DuTGfiynyXKCg3h242utasURdTQ0r
DiWc5ghMy0qkduCP87KHXMNdOsZWYI8au9zI/iFrZd921EZFWt6EalF6DMz0ZTgC86qpDhU5WUYUbCc4
XGV3QsV9PaBf0yZtMDROrd2hgLAOHY8/ZBZLssREsPbYRgAjTddbF6JqDhp7zIOKkcKCpo8aUxeFWiSd
dExFW2NFn8gy+IkDMRp9s1pWKDMKHQBUjAo5tbJQqUQXdYyu5Ycs4PkgMizFEZkNHJ1306T6q3H+ALRt
uo2QupBA04jGa/BgI4JYFr9w6+okUFwfKTEeFLK71aQrl1U/WeXrUSCUrPyrRrKDqEU5M6lxSINhmAh3
2+QHlvBZzBdmNA0ZvdrG5zed3soqo8lRh2h2qTgvrGi0kXaNhTF1iuqe0kXW5S76x+3XYpDX7YMai44N
uj8dJHmTan26uU6bR/u6EbhTzr3A/JuQ43ZwzG6DnUXDtekUOEoIncYzOqG3maaZQtvbuGnZdzfNQJ9M
3HSp1tSmtOT12bZ7N1e7r0UHrfGLjnqzLmMxQ/EYoTMeko779mTuKQqBIf7TEypDHKUQhRnvFWKicztv
LY/bY//2IVguz/d4K13Knzzh1IKdioPwoDsBzy62eZ1h3sJcwmMu/pz3cCth0I5B3Uko6hgOmHunXeS2
PqUH2I9Ro+JdbH8pgFqPjGfjqkkD21Vkd6txuK/I5WLXhjbjQBV58tREpGvz5bBFiKnhubSc0sIsBOQZ
EBzhqFXrhmfKAnq4K5p4rTdW1x2/ADHTwqylY5eDQ32HLkaG4X3onziwPfq40fGToqtQPMep9U8wbhfT
qd1HHxpOxDXwvsiFY+fMqRDa91Glg61dtRp9wMxeGxkfDowjsBJw3LUbDNH5LlzUqht1x26ruHcpY+Ka
Q3fbfOyuqysXZe4tYfPLRDvuv0CfT2EmDorQXP4rDqA29MvV6KvH4120DiWp3LAhy4ItgI3xphiRYkPH
kYacckd27j2gmagliT7kO2HmHu8iP8sR/nIA6Hopl3CL2PEMK/4Hc0yiHf7cL6qHVmPBrPtfPuK+jncR
UWBdobUJh8l3ISfKza4Qcy+CbSWLBlREaqEvmQNMVD/UZ+pHKrVLU+HBmBqSgvKetXqd7o2jpNvUjFlv
etEhPzf5obiGJ3VP6FaTg1q0t9nsInaEI+5a8lihp9CwP61G2nojBrrZ7KGBfWoFVDWiEraDH1jClv1A
uV7RPryTaqxft7vLhA/awzaB813R/i4+lsHacl5wMdlp8+9i1bQmu9ieZk4oF4iHbGyBnYdNrnbALvcj
fbj3iTOYAEi80Z27T4+bFhpkpl2508ZYtWpp4Ik6s4cirs167Ab0HgP5Rxe2pPlKbxdZ25p8BFLj1t+a
JBfA+rK5AK6a9qdLC8ASBPTK80yUn486tIEKztPkjFbkFmS5HWI6XUv8ObHecdHqRc87BbG12/jby7bR
Cjsei/eXZDugmwcC2v1fzH9+4danVty6bTRo5jDcD6y2UwRCt813SGNLc7pwJ1zkxh2midWOJKnXBw9X
xk7YM07JFDHs/m15ea1U2CIj79xpmV0673rg8kjnrqeiavlJnHd9UIPcfFy0G6MXAMVvL7D/0kE/atnY
aBb46yaLe4V6lhgcWTxsNnqv3Nzanbqexm5iDzTiuEjBJxKkAxslrA9SScJ4tWu3Rpxv2GEA5WE45qTf
wPYXcghTgjq2UTyMsN2J9n26FLB47NhxEvuGtTdqUleHIckGrxLaVe1TG8Fb4ewAXQOfBhg1qeQJrUlM
1x0PWxcOdLmG2PauC9INnWRlGxCCD+97mcOyJjpE7x+a0Su1a/ePjSLBhptYQiR+lnDh8sPwjj7Xdy1F
huaob4HRQYCEOxaiGXLNvUCrXXnD3LnLLh38if2gw2h9UjpA1GxYoTv1+XC3cWiPZSLl4fQF7Nj1uA/J
qSiOS6XaXOu8QEqOUzaYMcKsGXVy2yHhSPfftopz+7mA7NErvH92wfQ3lKTmhO6lFe60xY2Hr/yEW+WZ
m0q2x1ZPgPO/KUvTTmdR8psHRy5L07G2TD627OmZEyoXJUmty0P4Ktcky43zsAUz6hw/7pc3bW0mf7uh
qcXJX2QHP7ds/r8ldj6tZ8GpW22vb7SUsKdN/Mml65OpD8ySYH4hp9v30PGiFk0n2NA+TOaXO0RobuND
fQ/brcvdPRtP2zCBG+wMRUhrPrWE4oI1Du0vlpztZ3fOV6VkMzu7bZ3/6kmLnnAU5tzpKwGXyS8KCMPp
rJ7IdFau/K1yWrlDdXz5OkFWeMgusUVObP7DQprJd23ClcJV27YIDS3djo01YwHo7PSomMUezmByQAmP
9LRXssblcaaC/hp03few9brsrv7Vqrv61x3ETrSh99gkfWsYcy9WIKJDzqdWkfg7WlfHduq79tdHFhHg
mHZs53+J06MnNEKJ+ZuZRu80dOR5FmywF05O1aZhRni6fKvMff3E/IF4AB3qDZFcbJcC26KFXdSIVJZa
Wu3WexX/tQe8ex9ezmXa2U2TdnarST22Wtt19Nkq+frJ7R7ibcBW4F3bayZ2y6NFPVNdjR5JfN22HyK5
b2VvB5OOMxG6NKUrFSi4F7092NadjCSSWHpbtwq6AUfYKR1VYuekHVhlrHDq1G43PLbhoH20hF7RvmhH
nd1veOasEu1sb97QTqDTljcDbAnJcutS4j9EEXCOJOS8pOxosgMoFC8zcnmqWEaO0wCkLm6FvTtCU0mO
pLoPWgHs0hVHUvsdB0IcbtnbEe1t5JCy7iStWx5dZTLt6504JYK90EN/p6mPAPN5kAPMbek4f8EhHV4o
J47mAB2UzHKPu5BOqe/UcNd2cDfvFNoSS7rHvWguTfgBx7+wdhJaWM7TqBlQ644oejq0XsuOXUaBrbfs
YU9XUGgoPVBppi+7QW/SheN4IbtnvzF/ueesnZ4CPbZoje2fkLga6SjzVmBzs41n0ShKbURtx5hSvLPa
If3nyEpkNwcxRT/ESEPOU0PmCfvcasQ9Td2hQYrq3VdI5wDuu1sLRbF1Wo9ePw9i/NOe1SxUIIT6qwJX
dJqshSrxkf3lvrrsWjdNqxotn12rtWcDRI1hfbFr8zRdtGh1uVI/7VpVmekyhRrMCUjnThExFKa5PQk4
kY5gA6Fvt/vbNJ+R/PXYUbeb6Qu580DIi7l3sfnK8kzId0+cpnNAy7hoZMcuLpo2l6Hrj3ETl4nKtVB+
Wg/HAZHg5y7liF1rE5xqCicecla6B3Ejjvfvo6VrsPLJJbfQfwwf5953B3ZsgXWPh4HhxZboOwEPpK7W
pkfo2u5ygA4+58N2hRwrPbTxCrEdHk7m5Cc1jBWmGlghZBJP+cRajaMudwtinrW/p5kL2y/AM9q2ne7i
aWXcOabU3i2lrv1ARtHYdsSSNx4hVxcZSNf62kNUrnlMFzeF3Y3k8RhyM+FyPZzR3zF9jOSWF0GiKcgQ
QKIeu15TP7Ok1S3q13LCwiOUhrY6yDEFK9g71Nu2LzXIPZRuyklnz0/icJG36CGPvKVY5Av9HQW/jpz5
zI53HVkicEQcOpQYW+PTVWNzrXHZCp/o8ciVV2uj0x1mXZLKzpxKaIqdA2urJ+iGh5a3x600pe+diepj
myWh0mR4fbskVII1rL98oWM8PnaoX0lFmhencOrZ2zL01PUgMPBlG1kCS+RqcompUueDSlm6wyXULJng
8YR+OLIdHFLNzrjoPB3zph1IsHRCzUesIphtMyd13WJysUAoNQVT3/fpOHEzaHnte65qtzMyb+oDVibX
Zx8N1TjnGFX0qQnm8WrlCMFa67GF+BA9koE7WnfHCg4wwNDlLh6EYxltumxYCLBTkn5u2szDnuBoeTpa
OYCdwPZaG7Xn//rE0soct3576zvm5rs2Kcu+hrnteITzuhpV+TFLGn3RslN5RJdKYt993LVX3BARGZbe
p1Qv1HMu5MCWs5KZvuFmoGtp3E0mCjg6QLNpuNmqSaFT6fM7tvN2QqcMcxySwXxrV+1vtIwHBu07tugG
LmmDWWdSaC5MIa03JBenkBaWyvH+MqNBSZxvSpI4fyxL4uzQ/3HVJM7T5ZI4P3SbtUyF3Lcbxo6iGY8z
Dhq80AqyO4+7//LZnYOZnLVK326jdg4cOIovtKzxevWikb7qEe8Kce8Z262hFUZGD8ZvSdxUHZo8+ZS+
c4rRFYtuvGrSIIWrJoWKqVSyDGINHTXyhg54womnp69uk3h6xFz5J1QYuDP4aZdK7JQpe0bcaAw8dnTY
QXTewsJck3OLct0uxqEj+yctano75sWT8Sfqyz42EcWK61DJVJZqgWXsigOPborQYbbjwK/TQL7ntuqu
jZHco72XpH9GMxk+3uMKqz0D5k05oTh0GnMfTXtoIA2sQsn2xXrbxwySbTIeoyslGp7m3qaPXRQ058MR
W4VNRyDLD7seEw4FInTVntLC47PoRFl5toq2HXCou1DCY/bh0ArdJcAKpdkorHEYwOwpnbTvN6wujrVb
NKx500ZNuAOITNaxgKyDAImbEySecrFvGcu6DJjqoXrOK+B7QJyH2hTxPMg6QGoXWMhz4LqHGBVHaDKk
j+2lRQXZE2Ib4Qe2yy41JY75pPmB6SEt58hyvJgWkSYHWf8NPsAOzY2p++22+X6GxHvLIrZDp8YMi8oX
KQL89DMHdCo6FNkHdj96q2VVpJPA+N0W5D6sMUYx2AHc8XzX+ByWIV91uW2hpOjjSVtqle4HqNlbaS2v
S/eVRlTi7Ow9G+3kGjyiE/udcrezqGtdfJkE7ozDIRdYvmujFhaRVAGWD+g6igPlVNwQixXEDsNOW+mh
obQ4JX9anluovMaBvcOjTemvMCfPUdGv/SKHXlmNPS6Iu3YqQ50XrrzCzstq7HGloI2WArEs81bgMjO9
JIlarSe3BbQvTGPqe8QWKTud9n/Z/Bt3n83/+vBus/kLef7k8JVt42ETrKjD6+bdJ+3/6KJcgiC6w8he
wOAKPt4Gnp+VHL3FSfndS2M3N7BDajnnr7fuWYgD4/euUbUbWxiNd0y53QklxDYaXqswM78TgVhIHNAG
sL/T+K6OKQGcUKFZyDg7dqdCP+62UZhth06Oa+VhK5CdNiT5u9Z/xyYjpEns23AWzMXdWPe91Pgx1YZG
8pSc27rTXhhJ7JJdLMwVz/STdoCWHMPy/AANfPIkRu1JfdL3wRSKj7at5sA1rmiPxtz1mP9eaeI9nztJ
m0NA6lAvyndPE3/c+in2/flb6ETlSrHhp/TdMfU5snjxnuWnD6Xaq++qdZfBHUMQL3NPOp0nbdKYl9iO
NHjOMqaLqVywYNT1qLNxfuR8015el2O6n4PZR8OK/4IDPjiWk6TSx2tXLqSWt55PUeyYtB7dAd0GNWJZ
o0QdZEbsiTIxCpsqrMv6aNuY+dtDdagu45Ccp+W1ksrYUbPc4Iu5T/uQFsSbpa2274Nq4DNU+/Rrzyr9
h4EibPw9EEfMV+O2YQ3jabsjHoGDHQ0dhKKiqVuNv/29rTTSNhpFw275EqpwouO7HO993KKuOIfXQ2v+
H9KdNSwOb3+e9wR5PkmE2scWCqMRZjdek4p+2sr/9Uee9u2o1PB7e9wnJ/9kOB15y+PhLPqqo4bmp+CU
f1qNq7d7sGF0+bbNj2K4UiqMkPGODjJZyJHfE5uS9sTi2m2+YQy2wjxBqOcnYe7YDkQ4nHD3W8s7fOv+
JHYD2ZGAthVb4WyGCd2kOUR1W9YvRZCNd9obzPeyV1zOLZq0Ay4St84YBr0zHQ2PFbrtFnXoOlSFDYcc
ydaKcAhR+4GY9H1FSn44eELPNpQjr7sIeWF+yJAnkXxCkYyNaFLNGccP9WEU67FqWe9v34Zcye3ZHqQk
0ilV295tU1qvIL7ME7uR2aEIcDVUylF+tJ0FlbAl7z5o/HdoBFnhWR7x5+dO4wBzDlbmJHC4nO0M4INa
be9OhCNKAgVH1L0+nG3880pH1I8RHzTkdNWkZ15OzDS/QNhE+6RsPZzYUbEPIxmCIQFY11q4TVLSohGW
uYvemMs7HjSwx10iORz6WnscGQn8+SRP6/Uazz0rBJ9b73h85ZD6eWSuiKPA4V6VR3jX2hDuMPS6O4wl
n3+W0TSuyRO4JM3e2X2AQ7y0l4pQq3x3I28FdbsDjK1oBaaLd/6Yu/QgQESOuaqrnvq4MnV3MqSYx4e7
FjVpE5ORr3gzp4SW0nn7n+vo/E//1UOQuiOXbUtYHQujJsD1/yJH42Nb0V3/6CKBCw2i5Y/Lf9PZ2gM7
DhNVs+iArdA/91/xyWQ7RazKH32s1gTT/HMdq/2fQdGxWnz4RZLLEjb/aWnw0XrTIudjyKjv21iheaEp
z6juhKp9emL3ixL+t72tC54dUB9daWBD45SaHG6z9erOz6sc2pSoilNJaC+aNDiG3W+N2oh1P23KYhsE
+o53kPCxczrJoTvt7qJJ18FxQH9gZyncgdiVDiMwxhOjKW5QdfY5rdvb4wvxW08V4EgIJdMM8xPtPJaq
QGyXgYbRrHLkf0SqX4gxsROdbYX9ghoxhf6POgRw622qb9qcyvm+1LwFCXfVRt7DFSP0Q7cctKnwXnb3
xhGr0+CYNrLEPs2+3UxhVpgRNIwfFbjjE3oQTR+LblHfZEHM/qE9INMCtxSz7QpD+JncKojobzDvCbs7
1JKFdGR1u3zjQ4u29p6xRlo0QqdlW+54W6IMl7plsj/C4vRCScQ0pB28S8S4B55X31/2pEkttpBpzs7A
uS0Q+Zi17B33DL/Ow+9oukNJoU0HttKpAJynhmwTsh1odzK1TdEjC6Pc/x/p/sK92r08m0/7Sd7KxrNk
PLu3/e7e+3E8vpgP42l9lA3mw6RaGV30p0lcH18czabxpFKL3r0fRxF7DaXjYaUW+hTn6SAp+DRMprPw
p7P5bJaNw9/yZJj0C+oN4lkySftXyTT8fZaOSr+P4+uzuKhulg1n6ST8cZJNsuuiVgfTbDLIPhWMZ3Yz
SeLLJB4UDLc/zYbDfHJTgMTz8/RzQcPxWfhDXzQYT/Kk8n78YW3n/VjQQmWeJ1E+m6YCs+LNIkIw3Ubv
+IfLZDhJpnl9IDA9ztNsnItShYWSs2w+7ieVD2vQZxTVJ9PsWhDMtFq5b7o4FyVmoqHqWvS7KhVF1/E0
GiTn8Xw4y6On0ewyhcbs8++qVBRl5+d5MnubTbajSjyfZRX14euOaUjWvH+RzEQt29H9T+lYzFctMvCJ
X3Y4CAoFx1k2uGkPRX2DMkGfovDMNFMfZP05vKhDScC3q6tKlNVe23G9GQCjBqBmL+7PsulNVVeoRf1s
fJ5eEPhULwqVgJevO/jb5mbUykYj0aAoldM62QR6yjFgnwWbGFR//1qzqLd97tDKs3gqUCqHpdupq1e8
++44naXxMJpM02uxdANwTJNcTk5FjUH+3ZhlE/3rLBOMYqTI3P2XqmYlmsTki+pb4RIHhj4CRbKF35qy
88BnCVsyEF/G8+GQfZyPJ+lYf9rhUzWJp2IuxVc9q3X1oooxLPB2oLC6HfXnOYCgSrki6XlUNZhXsL6W
Jdbc0igrVh/Fs/5ldfMf798P1u9vrrFqghKzaVQFeFMY/Y7455dwS9GP0YO1aCN6IMqsr3vtRG7A6kdo
vPDfV/xIHpKh4FysWdsoX1RBnOwUtP0VT45aQ3WgG8wq2Gqz5e4LEPJEkVfORhOgPcdeNGhmVb/b+rBW
B3Jf50S9Q/sVRNEUDCNKrkWtHH8xi7EuwK0oaSK4qoazf5n0r15neQqjoWCSev2hkJoF1U7S2WUbun2Z
ZRPahuFvsg2xlNP/SVwj9w17HRyM38hva4FBZbNLsdwEoxaMICL9CuT3YyEaIzGN0TgRqkweT28kbYrS
4puo8OkymSasSfgoxN00ukyFtJgm5wKwS7FmZ+KVwk86vohmmSyoGIyGQBDWRVIPTDeDa2dREYKyKh02
5dG69iARwjm7KSU9MbTj8dkiIjg/vyUVQMVvJgNoZFU6CCKkuOtSHMGKE2stmwsBG2ioJrjVin173ZEJ
AQ77g1IyDEdP82pl+zrN07NhUhGsdZrM5tMxBRNYq5okxR/EFByZR0ZeUmo4WEo5iVdRf3uepBeXM1r7
Ur5jtdnoOkI0T5OP83QqhJ0S0P1hnIsV2e9n04FeRgY63rnRSsTg3uhGJHNrQRNVKSZrtnKNwhoAZjc1
MOSzeDbPBbMQ7F8ABuiPRJszxT6eUQlYtcL66VNV30wJwZYT6fKX331jMBBqTCb0WowJKqkUAUyTkbAV
1CilerNWjwcD9azUnIpg91UFWPSDAKsySgcDoJboWVTZgK/qm9BqBQUxWMyQ5IAqQnZUPLHLVBD8yQDZ
B2AM8sVaLVAnBDwVAGOaDONZei1ALGsPgKkBzFTkKhlO4daKnQe6r7Icw2ACmoUZ5EaovNRLynSMsGKh
dOZ42BdahVBXVRezSxAg2XAA0mZsKUVQvhpEPdDGc0Eo5wL7N0rITLNPuZU+eTQRDQyjsxv1w6tvRmam
RyoIG45hLBrXd5/h8qaqVWUyCZ6iC2j+s0H16g3GnjY8zWlNrITK5LNaAx5B/Q6IRiSlF9E3L4WKnN9l
8MDtEA0tVzgXiJv7mRaLJaJmCbVzoarydcfv2hPNICT0uyqHrxb9dWstOAIM1iId5o20+KxIE8uobxec
kCrTpD9ztlmIv34LYTNGSmtKivP4kV9IkZv0NwT4UqB4VFnfqpSv2lA/1kx7t7H+ochUC1nDGwEgBEPc
8WryToNWpB5WqTmjLDJkzQSwFmDJHhqK2PKi/rk5tYHLAMG4AuCuEkpvOn4r1/BsOk/Wbg/wUkIFw77M
zHBruJRqFTddTLjaYP+P/4hC9ZekNeC4QhF6oEXYYJ7AAp4KfiG1QaEgCa13lNfrnlBjLhWr8SrmXwUn
QnUJuvI1WFckMI26P+mlWC/Hc/nkWcCL2l96Cj0f3WvtHBsls8tskOOv1iN4Kx2aM98VrY4czU9oxnx2
6hr/5WlUzFOV+q101wJNUYlt0I1BcAPRosbXtVT/hapIPr2ajrRmUNAXmUnSJVHA1pm64nlsol+fUpxR
facYPK0LB3WcFQZEiKyIitCE08Z108YfINaTFHPaTS2kqXF3g4/kVMl6IV5R+XpIQV0AiF39t4OFuN7r
BPkh0NSnIuiQC5CsBg3NfW4Yosq6CPbb24JmvX81eyCDFHQcoZFUK2d5g++CqG5qZohoEetOfnedqg0d
oeO0Gy3nI9cWu3j9j2e6g7cSFa7IMB1fbbvpEHQ+eyleiTUm7BbLRmpRPJtNa0rHVk0Edh/cTsLvsvp2
pFvxNmdqekq2cYtiNtGTdaOI+SvaMcF6rClznk3bsZBf7yq2V9Dk8fpzz0oSumdpMVY+oEm4Sm48V3rV
9JXmu8l5Ok4GVUDPO1EWRI9Gg3wEL4L5hKltzdsPMD4SNetur0e3hslQYhWU8WrlvnYXertnDl7VsGBi
xL/IuLybOs88MoCxD2QIX5cmcEN/AXA5Vfez8QzWajLdRotCI4YMkrjdAIf6504APg35bXZC1Qa3vxOq
NsWDO5u6yrfsbMbjVGhkojIsntHGeTxINuLxYCMfirY3psDH3HKeTBOjE0BxtyUvPw7jvsQL2EK03iwZ
TcDuMpU25d/6bDKsX85GQ1ewr2II3try57GQTuRzLFbElH/QM7JN98nO4v4V7JlvS+Xbvhar5SyLpwP2
GiDh7eaX2SdVjJJg0YavnCvCu9xeKwzZ7LWWbLFCse+8xYpFke5OQV5F7CAgl6BsuVxCY1xWLnEatpvm
93PYMFe9MsIGySMYTcPQ7t40HslRaHEd/v7liy3g3Pc7q0o9LXsI6awm5sSqHuf94RysC8JopPNZ48bM
6pIy0C4A25ciXUnO5YLMLE6QU2z9wSu7rOHBrCj4bZYR/FarWNWXCxQeLGv540WewOTRfDLJpjOFoCjO
o0E8izegbl6KjXQ2xKhYALuFRYpA8SAE51meTAVxi7eo6jj59Pd4OAd1ZTiQvzw1XUJqBgnUXxdEJqg4
fy6waxtgXr+11ZAQj6Ps7DdBYggHALVeiDAKLf8/STsdf1xlNGROD2SPbgTeyBnf0jRdMOKgwaKA1nMG
6oSuyy0X+1M7ZDjCdCAJOCgl42FalOGW8keYW4pG3grxd5FM3TvjURSYkwidqQLAkexWqBaJ2cXF0Aer
E0/PhDkUQcRV0qebYKvpa7DvoVmq6nF1jU0jYSWNrUAnEkP7z+ZxR/ApMbDsE7h28nE6mQix+knwjZkY
8GiSDq3Ddnij6rw92D0QvG9+NkpnUZrnyj0kCiXye+WXfCIofXyxkZ4/fX9Prun39379BUYquhDvYXsb
f9lUn379j/FZPtkRj6L+r7YVKL0BPE5U0TSmKkGpSrS+jHqnghRXUu90lTtW7wrVORdGKT86dY4oVViX
gxqb8m+BLncrZY2WLtDWnGZmXwG/myT99Dztc+k5mE81FmjjEDPJ3w3SfCRIKj4bJiurfkJfmSm9okAJ
BFwtoQRCsT9QCdTdlSmBIWECK1ksJ9P1u80f5XqqGTW+Fv24KVFcw0j9wHuu31csDJURwPzwg/GAoveI
3yC/M3Th7WPhlqEAjiEUj0XOGTRO8CVs9IeZ4FmGfijOgQalNJB9wVMYPlM7DKNupYhhK1L3AtkMnVWL
69keLkFYebvU1vi38IF7eWtri8nbIkxZswD6KDcLENUvaxZw3ueZBVDg39ss+GcyDIgVsILmLx4Mdcnf
bin/SxsF4icwkf89xoGUEEXGAXz832YcwJiZcWCkqPxxx8aB0rH+EONAMVbV4+rGgUbCXRgHCzRqc7Yn
ehdSnu3Xb9KeJcdVCnJFPSCnppwNGS66rSdqKU1xDQsTJVxM39sWKsOZy6VkC2JwzrLPnWk2nxSMtUSA
NUJ7OeOLXjZIiB4vTbCQICMSjNCSIWr4UK1ILqvwJb1Icm5yEsBEgxobspqwvEYSFn4upH+ZDgfTZOzO
N8DemxDu05sjeaormzaGw2olHU/ms3fAqcFw08h6f+8DaZCze9M4Qqd8xdaKhSN46kbVIEtDF9YoOcs3
DECBUEZa1uJBIbqupwjCwOoQxElLXwNro6FsSBB8XU7/ajnYnAqm5k0oX/enjb3i5aTL2RW140oJHpzP
4vFMst83yUX7M8QHbP6jCvz2i9RJvkBQyNr9zWU0sOUIeDU1zO0Lle5BosEFheowPhMz9GtURIK03TTv
QjlKz2MxjFdSg4UwsO6r18dvK2whKJ7UtltTpp1n3rmfyGqAO3xQgHs5IYiOqc5Vt0Ug3I2+iZTSSy2f
wDzXZ2LeeGtsTWFItORKBDnzWtQiwUORFLRgLK6MHQyqpjXjVYaDGmTjIeB4A0L1SqzR1xDyGCWfs1na
j+TaZqr/ZZy35VfZlJRngtrgoInF5g8qEjobJvG4AoqFLoHgI0Xo6FkHbIxuvejwzGlen8zzS2eYXqdG
V+OKmRgeoFZ0Wv8UT0FHUS1UakyAOEkgeKVtTxRzbTPzVnMN+11MNSZZN/JijVnCt5d+Fm2NhVIBrg44
E1QwFVFAN9asaDVNHyNU9VwtU+sZuUg0RRu/ypG7L36jSCWJAgdO2LyoOuXzgvuQb80kaWoLf68VvicN
4kkPtGc/18Kv/aizNG8oexoJ749zQRbVIniCDChS0rDEDSNWkGbLa5i7S1kgD4IYSBgFE96udX8Vjmf8
Nkg9rdlWymiFCytAD9CKHKWvi4Hb2znZnLpbbEDoJRBPJsObaiF5BQjsB2PpLElf30gOd06tnP2ISf/B
zrrnl8Nt5Mns7was6g900gXnNcd5lPGxtuCsCXRbzq5590EOw8NKC/0IS2qTb+JBmv2fkbKEkTIFTN2R
hRK2SZz9IfsKGB+l9QpskW+zNt5oSP7P1HDks7yp8f+CtoahpP8XjeLp1XzyT2RwXGuNuFytvjYquqc4
6y/bkXviuPlj1SBtcv8v0IGu/0//+SP1nzBh/bMrP4XqTYB6VrZ3Fqgft/Ml20xGBd5k9P0OozFcq6bA
IM1jCIR5K4mNRyZgd3Qk9AbP36zlnkangYS8cSJWy6T7Vijdl/tgiFblHncyPNcNIcTDOXVROBXiN8n5
jiRUqd/3AxJEfzdVgxY3p/52G90+JCiRu4sODaUbcMEtRDVIs4lIQLW7a66IU2Qw2alaiiHAAN+5cvqT
DEO3n+hHWIctmVLgZZrPknEyLSg4TS6gwFSNHM9dKEqdAKU8MKaYG8VOQQ/qhMRyPaixlfQQxIVgikbU
bDEoBIuwYkgHbJB3zpHk+UvA3iFzWKfkwtlzAUQF74UWdK19RxsPhLpxzfxFod3Goi68uhyvAbKwS8Ji
4JzHkJyzo9ehmVh+P0oGHxmuZOKP1Cf7GjM2pnbjUoTpuIcdp0Sr6BFTYbn9rgAbdoEhim0ASzONlhgO
3nBKjACt7r+rPLMKf4Sh+UBi3syhkncVRcxQ2DBZ+Vuyl0otiKwPtzIlciyZ84AxoeFuzaZDMh250MSY
hu/GFSj94ANRocTyQy0HEwlNIJWiTE7h9AUX7YlL047DC4I6lj21CgHDNA/eOFugAYWDDQRBLxTG+2Jl
ClqbAe/WRob8hisRYFx5NgakRS32jttWqu/v/SV/f29tG8H19C9ZVP1LtlbqRCP+TKXrFetxHGmWKSOo
Q4fX9Qpyhcqw+3XFc14GJKsPLOdPsmv4H3gR/yO4iv8Vlp7OFHQGyckAjiW9Wlbl9KJIXguyjCbxWEZS
68R3DiAEiqvF6YMqLL5yQGJdbGxL0XKWBqowBz7r6K68zicfdrK8ha0VIFnz4DwERBlhqw49miZ2XZk5
sgL9ekcVjQC7MzoWs/qtYYn/DOTNEmBZ+ra5roqJGtqw1gRvSEgvTgjWs2DqMJr0+l7cQMle3V0uOUlN
mNpdHTvTxrouXmdFYrJ0NTm/YEkLWtBSz5Em+He6e0icptp5Jqw8jWKdW8emOqt8cB79Quw7C7EQ/9+s
bgR8FV/pcX77vZBB3M5bgbNTl2ROFqVem+30oiTUIWcHaf4POnzCE27LEuhAsUpdsTFMzsPHil39Tfcz
cChFB1eKGudZf54vcVplhdPCgg/GN9soi69Y40Mxl9vR/WHWj4Uelw7sNzHnr2S+KK8VAf9beS5FjqpC
PuxJDVB8yi+z6WyXfJf61i4qRM7XDOIbW3kwQIHrku7MJ+Zwms8yeQCCfxil412J+I3u+BwSWdy4T/Fn
9Wnd+5QLZiB1cowj0RR/JcudJMkVfingzw/O4e1uKgPIB5C10H5OxQS+FNQhXl4MbyaX8BzZXxBrdz0V
/1ICgk9v4Kj6glrqOPtS1rQzR03OEPFzmmWzI+1uU8cXFD3U1JymQ8HB1W9FuICQHM4SqVV6p6nC01yR
HWyGVdNJNf6SrQ2+pJPLbJx8iceDaZYO1jbTC7UTYxocx9fpRTzLpnXIeNu4IEJANfs2m/cvRatCHgtO
I2gYnitCtHhZVNYgktzAYVsBX47hInVYNmsReQSr3S6jncDhql2Lv1BKcy1Ky9KbuwmAvjTy0f7xEger
+Cawkupy7pXCIwrVpaLFCjp3KQLDSjRWONftkaK8VXQAyS48e2zCvYo23MEovRa5FiWLqSNnbHSOWsEb
ROm3iqDDaCFAX+u6qF5dvmMjhncwv4Gi8BqV1qo6MEN05MsO1y9pOAcqbV6FC7/Riapw6Tcs4Y+kJ0dL
3pDfITA9zVeRSyBNl3WOQvgA5joDYzZEUQjNqoIqxfbDgk2/Bp201PHKptFV8/d4Ar0oI62npqgwFSUZ
wAxKV6t4dtch2dpfAsitD5PxxeyydOvv9fxM2J8hJOP25sp9VY5p30/jtSDGZiL/nv4FIh34VPDdCqij
uhKs8gfgla/kc/1CHVGrrvkHZQgiNNwDujhkMQJZHVKfV/W7EFxf2VCb83Q4iLLx8AaOi0ymQlkWalMh
ZZxB8ao5ThOeDh9fRsQDHnKO/jegpPO4Juz/NzVVQY0F9UCGdp5N3eUDtWhog3Qhja4mInUnwTB87QDf
unK136UfanyJzMyo2sNCFBcjJrzoa0I/TXjmu1KCNNfeRKo6WlAePf7ACBLv1EJtE/McfK/OWUWOkr3W
8Vr+8iU0kJKtZLqpCO2vvK9MRKRVdeWCC8JC50MequV0zWaz6EAa0ySMFKtFv98ksbBAzErfEwr8qXhT
lZ7b8ezSferBI7wfSGXbvJboXvvqnRYO8FKM/g3fiRtYxbei2hln85LUViJY2URFOa+Dfjkt7OEf6mBY
QQIvPfJAXs1sJpZUMlgkTVRjGBeGfa6CDwOS1YmURDFP3jozfUj/ChAsULgRAtDWLJionteUBqBcHIvr
4hIDImGWEwL3lRRQYZLJoERJ+N4snAJyiwVwP81DwwioEWZHVFd09YJ6W0FvRMrQDX3PlWllJawP26up
XoUCq3S8rOIoDRhRMUfdymfPqah8h1rtt8IE/tSP37Ys26wD05Q3Hchm1KMQKFtr0Y86YM0tj7rko6i0
ei4sLvUoV3oQ37CyawXBswWs3Y0J2LUYRoDHe2UYs/e+B7n+SmyMGp3jXibM/N3sE7mVJLnmseyS+clL
YqKz4VwYsbDpJ2rCJXXwYG+s2xAW9JxQ3/WsPlFVd5UNzaQLFMhn2UQw10l8Eau1v8M6b490OnfYSpKH
c0bZGaQLGiTXaZ+ezpFhiNIn4fEAdtUYd6oAKOpzQH/AyV9N/Gx9lr3MPiXTVpyD5q+OVqnzyAGlAvVs
L8lZ5vYqdKeO9mo+j8eDIbhw1dbabbhVNt5PbhZPvLyOZrP66Ocvj3768uhvXx5vfXnwaG1T+YwAX1fJ
TUvKebFY5FRepucz0bR5jofwFBQetyYNNtsIDCnABICB0FSshQYmxzDlpRS/gsTeuo1gbCjIs+W0M342
jSuaXsTCK+WyS6JPqWBwxo0dEtN20uVMk16Q/0ro9ukFzO8CZUgmGQ/uP1FhGhRJuZOVBVI0KJeC3UkP
v44f5noDCkSWxapl+3QH18l0Kmbd83/9t77GDYMKrwq8XcFL3xxMkkNp5yzKnm83CjzytCH3YiFUVUKS
mt404LRC7rTY+JScXaWzDUGKQvDEcHEmJDQRIus8TYb+jSSBReqymhcx1TBw0EkhcCpiYZrEA3AvyOLT
efFYSBABmusS/8V/e0m3KQHLSXV3pOHJ028LprboXrU7mF1yYdqy4wwl7ggM1WSwwgyIprHin0pG+N+B
RFXonrTisC2y0tHsmj2FZ5DCX/yQTly5H2y1jEqtUHUpMfYNMwwwfExcoli4D80uVzg056P+UqeSZJKl
APW6tMUhqFtlDllMPHeJxmWQSAh3NRxSIpaSVo60EJW+fN4JZiLz9oZKw1h1q16lneWOs7l64UBVechd
/PuxYCMQjUY/qH38YHZBHthKmJJ3Ku7Od/90o/NRMk37mELHfp4b7ceWw98bZvFMFNJ7gXvAmJOqJQc3
y6vfRvC9TuV9QxY2HBfsfpenXyMp10h6NRlnoMSj1PuLcrKRcxQ4m5t1dhp94S3SHVQogIwZoQEFqsCN
e8ChA+pZ79vbh13doZVy8ACbubYEeHRlX2rrEX6a3Tfz+41KJi87ZyEAf0oSub/DnZvpMJ3dRHBCTCat
VUcx0XSq1GhHIDEL0qbBtxWzpv2AdqiFIfWDPziURi3s03NVjmT2TlzD/Iwg+6Z50Bc2VWrPqmg/t/aM
qWWurvEyPouY6iDPhHJDqjCYkmdccxXpmqOb9u4pvPkfuO8CHbSNyzbeYWM2mUXJ54myUNKDo0gFZLsy
i5U8u09ll5XouHIj/tvo9TYGgwpHwYHKGCgpSp+3AkeHupS0NGuhDtKRq0sF5SxYLp7bmeYs/EsOseUy
c6FbQ0HnV2ixLZsDcXEYvAeVcoDL5sJpAdVJBUyhQhMS3CTkjpHOIPiIfY68uShEK4aLrNtqsh2+kWNf
Wq+efaP6AnejaEpfNqlnTiwnOIK0JYpvmf+hUnqqRaktUWrjgZ8owl2OWsgBYIrYst/8x/t79fX399Qt
bfjU+e+/SxwcnP0WffUu11sKO7arfH4mREn1gZs+7bmPNqKHJSOxekdJ9sglYZE6SXc8Q2z4wVZx19EC
LG7JaWGj0QhU91IOpJNkaUhD9GAD7CIUh7ekT2qlCVrghvSCAoQyPLuhZVAIQ6hbiTTfXy33nJY9DCwB
OQGq1af/g2zyTpI0efEKBVvjGNSCnKKvQAZIATcfDxTT3IS4zU2hromZjafT2AVQqpB+uFBeiI1PQibK
HPkzCLdTI5U5qqbZyDW28au8ZQ6yu2pk1AOusrGBwoVNVKehMAvp+FVfpAaifloC18q6lxZUv5/yGIyv
9DRZVKCukaiOnC9yf0pJcTSx5r0aYQ1ikK9TYeiGBQ8tDeIggCVaiK8U0kFBCxQI5sdWWGGQwIZCOegB
EiUhNQvALnFkcD+Gs06N+qWeqr+f65BiX+Op6aho8wWeapEx61zInrMu/IXuErvBcTydeM7mcmCH8UI5
6uZjuSexOE1dUZI6dwbP1lSKSPHpu4JUHMAGYJGqlHKQoHsuuKm98iKSl7u7M5T6UPJ/wL/pIKWsFqyE
4oR7PJxGN1DVkeZRaFsj5P3FDzrMNVekpdVoRQR1+b5akJAiyCfVCFB7gssgt8HA7HoWBcEtGmFApJQ5
uAM7hWneE7YqtCtzlxSItbpWyeQOWAh0uMWzpN5OsOP48xIdKw2huONfCjpW9YIdu17t2KXbxgC0s9ok
6AYX5Q2x1QROZC3T+fIV48+qooaTVwT7CpSWOTumrG7gFxL2MgbTS620gM4mlVDVcmEUnJuD4jWEL4vQ
7hil7qkrNnw7RQtU5zVEy8Nd7MAcOEARPjdeK9jYCQM0no/OkmkhQEEkONpbqas0D9x7XtrPLOseHWh9
PNhXuDGr8C7Bnb6WaZ+rHhLH/a1+QvxPPh9upH+xh+nYKKFkDIIIEZ6e6nuQfe1LCRPB5QqIhgWnoi6K
2io6kL6ADovW4KBA3GEcyiNYRetxGRLVnVgSLZoNHqZ9JEh7YjYGlMbwjBXRzqpFgeWi5FJeEVmOg3s7
DwjycWx5nZCRFjFdjzDL+EapRUkUTb1wwivYSyi3bD65W2iSSyR4M5Uhbd4PYTxZ3WoB24YsfJWK9t5q
eROsUgvJl9J4kbu8vAI7qCN/c375WyyIT/k2NxO707SuKXli6RtP1BYd4hTvjybDVLz+iUKkb0UTn5Qr
IUrHsyzKhREKmXnkK+0csb6AHEpXxSdhkglLlaUHUlVo0qtPl+kwgRrGbfcrBEiiyVGVlFyDYtBFP6lu
6R5Q0iLzQy9XVdHsCaIh9eBk9BxSjyVT2JhkYxDrpDoW0szfg6xWx9Ff4MM6/BG/eOPhU51mm1Yd33TL
gGwR6i5cdLcmxd+50WzO7xUd3aN7if6WBC35CTbEBJqEdozOSO423rbfdnvt/947eNNrvD2qHz0/ePN2
t3G6E679EpKIQneouXou54kcooPttzXIWNSPZ1W/7FYt8ovzU5G0T7jBKApcalT5RZCSzNnw9P09uI8f
goc2+oKnJdP39+DeRdZQ/bcsFbzil83Z5a8L6sL8q4IsaYSKTtZblwj5A22LUmTIQs+cuPM+wpaXk5cc
D+hUow4PthULjn+Q7ywsmHxTHX5lHUL4wP9k4+RA3kcPwfK4zlvytQoxzk+Sxx56zJnNd0xV8R0+mlnV
aLlccyr+GgKst6PfzVAfRF9ZCWWlbfMTUKLffsgFBo4EuZrlQQWYPFkSfgw8DEunGo0oR+U0pmkhCWeg
38VB4JioCiaaF2FzzT/r6fb3qaKo7AwP/OfUX9oYHewg9g4saIogkfJPCyArgYtFhQYAZM5JRhVyXNsl
9yfqq0HSaS6AuTk4l6jESiqZdn5UoBY9EFhnte36Ye9Dq8gbD4KGKsvrHMYNKcgCfYgnMc4Nn9XWop9g
2f785HHyVwf2LOEAhxd8EFRf7Rd2NvwIGtrwn5DPKhQd9JKhPC0NjCfKP6Wz/mVgmXIwgfKCGF8rR5w6
qsFb2yhqS7C3reRReNQDo+XAiuO7auzckTpg9PihOWEECPgl+gna98meIZPMB+YD5INd/eStXqfrURpa
XwOrcv2ueIZ4UZN5GgaQpQQMLjqPKnQjk8VkSnGi78vXkp0qPi+AMcHalB2BZ1CWIyeYboC1zWVhavwF
eGrNbr1sm5bsqSRoKcDmvB1offErXNyozUE9DkYLtajSE/9FEIHhRRqbZiB6xepH7LYjXG7IdSin4BTU
gINmIIalzg0zpnEsX/jgIHEWBITzRjcF26Vnz+A/rb3yqQyISqCTYhGGK5k5DtUw31BxTdCh0kEx4g/X
5YZZNFyjDmnqID7KAEMzDUdnST+GfE3gGUvHm6P4s6rvs7WoKtv/JWKufXkBE3z5NfJ89noS9NSWwTFQ
d56fJbDnG9sVI/kLXP50mUgqDIGFFDQWT2cTfTm034D5D2t048Eq4CE0IdDE4KdsDzoAlneEP6h4wPY+
58HFTbizoIFDoGzGfn1a0tC79IMStwWt4Jlf1I5QDhfh1GL2rZjQQHKDNHcRaZIcojybiocaxAkISMyA
JMi1wtY/JdHVWJhJ6aySR+NsZrvyZkr9Z0xddlea+89jyIFXX/3hlrTLF7sNId8uO6kG/+kEdfN4+FYt
eM5cApsTpt7YJpgJ6C38iNmjn9ZMBSzjUd8bwqwx6pnXn9HDvWZ/XtzsT7do9m+Lml2/DbSPtxY3S6AN
8YIfuNzXLQpeRHPajI1ptTgVQ81LFxyPEnkKQgiiSi1szIJ2wL9pA/ZxkQGrjLzvYL8uY7b+Oxqkd2Z+
f7ex/JFG7CL7davmZ/NQ1eXwjVkjH0KGjSdVHzwsFpujBcCkQWB0PWqfaN3fNz30h0XGB7I3FG2U2RGq
xDdZEhqsyvKmQ1hcBiwBhZ3/dbbAHav3w9i6CtZJLiLO4jiIQu55O48ILbbdoGpPlQpfyf8Oao3hCMuh
lSg2eOni6mHBXKbxqKPr0CEGKpBZaClFp6i1x7fSb8Ktra8CG1Jrilp7/M+gzQDbLVRmJKu6nTbz8Du6
4230vb84Nx9uyVB8FfRqyhEhY4r8O2o+/x6a3h+pHcFgIr6Vs8Ge/yIsdCtahS1S4ASGskZdgt/frC3d
KOCo9/dUpS9KizQ3VY3qSkq58lUl9X4FTUkSUpmiJAusridJkCG9hrqccj2qbMCGrXqtxmPP+DzQpe5U
hZJ9/OtrUH+OSqQ1oH8pJUgv/BIGF/JTfRc1SPaHoPoWJchv6/YqEG/rWxQgv60/VP2hSZN5kgBJGRCm
sM1zW0fPogYEFUGI1iyDEFcVuKKyFF6rxOusDgRxqC+8/V3JjM0v9xWHufkXsd363gedTS1060PphQ6u
3h91nYPt0X5f5TIHXXvT/Ci9yEGnxjEf7vIiBzptCzP+4zT/3yN1vzySm+Tm9nDRSNslWdLEzMsIXuwX
UvmfessUHWX/s1y5fKliGSu1E8rjr2c9lMW/KHO/rhLpOwvd583NqJWNhGarE9jjav4VpWWp/VkolcvB
b4j0vnllozLkM8oDoANaBZuryjh4RzH65Q5NzOdG5d9GEMhk4C4ckBTGb+TmeFmQt9YOa+WcgEJSBFIB
fr9kf/JQtWAIohmVIAuyM8BGJmHXoKULJpOH1p4bbOlV/cN0e5zNqvVBKlnrWhRX1vzDa7IXdiR2xwMF
4CNveQIH2UwNZ3CtRWkohSFf8oLg2Csl3KCByra690bMhrnzKSVQhO4+XJxJMKjGyCNishMZDyx/bmzQ
2S3UNVzlXyKMUKlLqS/r68G2QudPZHk05i06abL95KMuRpMChoV6eV5Am1bNkJWXVA1/KDkxcNuMajxH
l0z57BG5l+TMX/JcCVPii6Tey8ZN8bIFTyVH9SPLmeqXca4vbrNqgnQU2wLuZjfBGceV8kRqNo+aAd7L
ooY/lOB6WZzxrGaLkGZQhtP4FeJseSShK9ECeIoiP7uOz/9lqk6LkDyYRROBGmT6KD2uXLqOgQZ5n9bU
UaUfSCWKdX8QweRvuvhOMPWbSeZGtYqAUh5M5RZQnZ3Cp+5yMt2X3tsYTlr2rdczgqUUj/P+cJ6n2fiu
8pX9OXnJ/oxUXiaZjdLUIEmGIPiz3wTOEAZUui5DCUXpvMz3VfKIqHYAh5BC2yWMwTAX5A35M5OQGUz8
GSnIzFpbLgEZFrMq/VgxZylNPqar0eWD9XPzO6igk2bv8sRb5BDihrb6cTc3jpUOu93OixG8n/Kd8lvw
ayjtd34S67UuZ1metH3AzBSDkC4qa3NqcFGum2xiMPmVfUMZpSyuV01e+dUBtNircl54n6MRGNIzIdvV
Ayk/oOb2ApiHZ9eiU0tAXD1gWd/KQMaV0QRysxw+T5OL9udJL55gF1MkEAFXvkaQnfbd1sbfPvz+6Cve
sKyor/rzXz/IMrSA/B7xPDJwgvXdA1HjmapiO/hS0M5otKCj0R119Py56+iB+v7lofjnEStW3N2DZ6SW
aepZYVuXl67LDwJYAA66fvCQlSsdoqj1QNWBlraekVe4mdg0U2n0vrwm4XSVtvivAt8Kzy3uNk71wb4v
lTVWVVHKwiOP4fqDgcHClsHBQ43/R4A/AudgESrEX1obI8X7iJuG8wflKOgdvHr7PDwIVXchEkpbYGgI
zGDvbghBhh8ounvw4fcHX80K//LuIX5kddA6FJ8fss/FkG08q259kbComlu1R1/XJIgbz7Z+VO8e1B6j
9jiPErb23riERUkZI6NB0uEwzRPBCAd5kFvZkkeBQmYIZYUsO0J9jiEbaJAllRWy/MYWep7Np3mQ1xQX
sSykpMjiVuzqB6EcXNv8g120tlG5YxRaqYUlLD/y7ilSHgWA0ojsCw210KZspL7cUjbvr3G2zMloM4Vk
CaqJdYia2VYPcIFHcNH7MLBuVPjFAt5gzm3oO4n8zioFA16tM8RLFvVYKUJxsMcH5j4lc9lJkPvcRWOW
B1nyMDvEQa6zsEu7v/xwa2tLR8zrO1BZxx5dmqpF7EeoSMlniN+YCR6EviHNqvxOEVxQJwcqyRDwzrBQ
VfIDThelXu1g38uF9KQqNW4vm6qj3tVAl9gOUWOBIA35Y8l6X4sGbxOTFcc+FNyrusb0ehqwsLbjeZnk
gNWuhgkMKAdOWgoRvwytFp3FebJrIuVgmOXQ6vWlCZoEIOsGz21yrwXIlzFS8u0bPXu66jNvGg1o22rc
wUaOzFzaVvikulYsDeNm9C6FbUFCJUyMpO/fIgyOB11+reiUkMlIJRo0SAas2MCOLT/CKnCOV/eC9htC
8VwYBe9S6bZkr9Smi4qJ1G2+S9cffGDuTEZmAxwcg0mr3GHrsrcUTMHvFE1XiTzefCB9XeDyzqtG2Vmr
kS0hNVETHQWnDpf19PMOcWzAW0guA+3Q+v1hNk4GNt25x0xgFtAMADgl5/XgwLhsQcV1gbMQTtOtuewz
D4JXvJnNHwyNYMPxVEhu0wbb7jinIPMOlT7txf4LAA0y3+myHwKhSyMgE4Dpg+KHtEJp9EuQgsCfCc7M
aZJDzi/RfLEbV3xETpXrYKKqQQof46G5WmMQ5em4n/C2orNpdiXeTrP5eBBdP6g/rD98wFqbJuDiHQjR
J9Sh2WySb29uXqSzy/lZvZ+NNnWL5t/6b/nmBHIg//zXh39lMy9AtTSoIiKvPS+eeTAXr5nyO8iT5S2c
JO/HkwSSc0+vk8HRzegsG+ZVSBtDkGOkv3hfnybSF17dfP9eDKcmLJT34r/ND5U1+6myubEpL7t4t4Ff
ixp1VaPOXr9/n7um8g+VtVKgi9j24tVu3S96udMK0yS0TMVENiBTe9wHIpMg57Di4+ssHUh/ZprTTYbV
FrbsdZqEV9n93yF+NIVI0q+VAh4qAwEkXFGsARVEp9Lq3g1QDAwNWxXeWYzaJQyF1opgtawlTHhOenu0
B/LsjeysWvmH6hl6ui/DwtLKhyDJcJ0ReYfxHUqqhLc5Rq5EIl5E4wyW/36zSzg5E0xEXkenHcJiRv8z
F/aTmNHf4vzyKhnH+SYkN5/m/WyaqALz6TDEVUIVNs+G2dnmg/pf6w/RW8Fw/r+XT/726P0YNmPyWTwW
M42AsYwSftSiT3E6E6tmNEoGqVM3TUKBbA6bc9ML5RgFRlGT70WzI8F0FXeWyOf5wizl6XraBtUTBU2C
J3Z6IePDzGvbdCgzowr5nRVmJTQhweJzFaWpEkqPbdaSCew2yLK/SASQZaLHreSYCU+QHStsiQahKqJM
L9mla4LtQci4IoRsLd7UgOrqOk2LaECSl07uK8IGKGWvZMyFbVJeaq271yVV1Cq6a2u5YZqev7pWdH8r
gG3tDUsnAL/anv5jF8STB2RBzC6F4TobFi4Is+HllgMZHyF9tFjwjKtdHJXZ3obpmF0IlH1Nbiis2SrF
JI4as9nmk1hul7pLzdWlKd7iCVLkktP4tXyBywN4kgq9XiXpWbBR8KAH9xoe3dgGGCn5PYoFl4fSZv1V
ob8NW8V0twqrAdBcy788JVke+wK+qVkTZuns+CuHrO7gAJZGMrmQxSxXjDIhXNIhwPqDw9lSi9mOkq3o
orUphdy3CD7R/VjqTk70RVH9XEfAVsh3t+lnYoVrkY5JYXt+v318mUpzmAU8Iko5ZzGzmz/+qBH0Y/RW
SACZSEZXi8wF17bEf07iaTxiaXHt6zEquokJX7UC8zuu4ycX6qj30KEFP4enCcWyVcWU83fsDm6ZZtp7
vcO1HDz6N7KznCBAcNEJJLESc3wzXBYNcAOuV/SzmH+GG4GMfp4H8QBN1FQlJr2vSbwILAR71e98Ku9u
BkhVUrJuG2v5yp0UKv0OuvvAZTW0rWPUL5JZS2PCNO+3XFDWwLcW7iXQkAExD8HGSQNQhENA0H79tc0/
DuweIy5MADrGII/gRuINebkRGMKiIpBCdh79dggRwpVc/JaJ5sy8bbvZNqbzxtlNdJZlMzBKJhs6mLuG
XsXn5+lnV89IcCHA40la/03GIkshrvraXEB7jqQym/mPURUjpLPs8xthHSJ8i5lrgk0v2GBrmIo38L1K
jyQIDqSD/FHF7NM4me5q3sTNDDTBn9IBnDfVPdflo7wg3oVaCtBP4DVypF8mkFHQVVPPfr3n8j2qOMsm
rpZ4gFyBmkgn8UVyqtMFwuk1Oyp7HMM8531Iev02m4CSXC0p2JcoEwUlweEdVzj34gCBJwbJf60ACVyU
uRwoUFLBYhfPHZH/JMulq8iS2D8T/VvgClYApmbV9msZYqsXw++SarZqeta26ElFXEFjO/CdenH30s9C
gGgQcqHOJJZ/wM1dig6iqgr0tXk7JRwYDJthTWh3aa4Sd8lJ0o2p+lgwKPnihErFoKai5GPlHCCr+FGk
JxAamQuSUhePBfkCwBBfC3ULTvip61OssLRTIMrIPlzrljstZjq+oCBAdkQzPwpSHf4YmhXeI/kIxgF6
a8ljJwCn5ai4lAeIvrtJV8uXbceUkvqs0WSqISLTwbQ850GAgF1HgXYKQ6vB1TcYkPbEYp2CfRhGpWOq
T7UiUwC3akXwRcnXA3dOea0qDrlUs8Djwu1+JWvwaH6m3JhqlZh5EnqyXZnRSBgaqXNmFoqv5aTVMrJJ
fZNY3AgjdyPyFrECU+DTDNmTNLpZicZAu/p9QcP6ImbZMpYby2rO8prpHFT5bLyRz+JZCh6RG8sTEkZk
Qq7E0UV6nYx9dRoLE8TZlxMFnL8jeRDiCQVa0gr6TqBDSgT6NZHySJOvBhmAmJj/z8j3itvFLpb+tkV1
SwPpGhxfRb0o/iL3Nf11FxAeam7pLTls+PiR4KBQnS9GVMEwF6gyBQqMViGXVV+W1lVUu4t0FfM6m8/s
5dZIgdHAhcxCWSNkEHq0phgOpi5e19hbjtGW8BihsBYUasqz3T77LbDuNgK9TeIBiP8F3elStL9QwbDA
KS6pWiyUIoQ+VzAiC0hPGT13Tnmy2W8kPAXat9GdROO3kR2WQMV09wbo+y7IblF3uhjpr5iYPIWkuKhs
8VvIznibzTm4b92Nk66TA+VKJW5JdEiDlfmW9BIy0EhoQZv/eP8+/7Fa//HZWvXZtvi9HufwV75Ze6bf
XUyz+QR+nN3oj+Ib/DrPpvLFs+3qu/fv779//+mD+ffHtS+ydlV24H+F17WSb+/fr63Bj/V0bAHS4IA2
eUXAAVjvb/I5Ch/ekFisRfc/EtvLqievEZJNUgR1+q84IwKemD8oKwLps35f32ar44RI3yaQye9cBkrJ
dFSTYXyzN64pWgcFRd7wr37IyW+6z/ZHvjcmfVGQSmMlPfglKKK4+VeemFNxvmZ/QZEsDf+xoEOkpb4Q
ECq9eygDKtXvBx9oNiI7SNPfu8eo9JMPpLBGgy36V/rZIocD8Eg2WakEug5C+8wCa9yl0G2gdu5X/+lD
8dFjimfUgp0YfdTVXTHnxWSoiIWPdXA0VE0TgXpruFp9BqVpPKafW76IjPUP7VKWZw119LdYDbJnCHT8
/esObc7AGmqVFP16B4e1S0ALIVAVEUQ9QdeNqhWoUiGEwuhk9LDiKToDXY3tQqj/VLl3lnA+GILl5WSC
uKdu4ZhpVA3w4DqjZ2i6ZYXllYZeag1nveuMeRhsTdtfSyajnKVUAzFnpNRO2bn0AHP3zOtCSW6Dha+F
wBYtQMaqbBr9Ej0Cw41/HGQQvPHg8Rr+aJQAuOFUHsG0m473708be+GD7zg0AgBUe85C/cxnDXO4e2+q
mJRJbBT+/uULnSj/P1NfJS16842tjLL/CTax4wbSj8f9ZFg4juDnhQDQUbS+qQ0xhm9rAAOxCBvT+Fyf
kk8G8lR2cB53UHGIl8OV9L2zLmZkzEwHGcEfbBbK8g2ksPgOzUoVX/htNzui7UXwAHVDOIkhc1GiFj14
Un/yxN4fDyz5ARz42IyebImi8uuTpSA1rWpCkrES0wCceg4EKus5mgCMWlNERyXE5zs2Ck8GAuG1rJIu
JG+S82H2iaxqWOaQxkI7VPSittf+2oxltgQkyIG3O7YcH7BGqfwG4gs8gaqMGIOVVgK4HJIuSD+hRMYw
ZvtIugXDVQFUlvZGlzC9DNNxEgnmnn0SpvVwqHMMw5czSA+awH1mkTBvIL4yiiGMNU7BIkbN5Jna54hF
daioMYf2bCAPUjpGHyXQUxnugBqSAJwlcvc+mdpr5gfSzTyYxp8gu4qQz9MkGdejt5ewjZOTFmzkNQJ6
JPTvdEPebRm1jo7kUYeBg0NBR1rZE02cZ5/r0e5B9OrgbfSm3Tv4ezt6+7x7FL3svmrXUWmZTxMOUNis
NcaKh7NNO6jkuUrEpZ+/2t9fDVnc1v4Ur+NhKMdhIFomZJOa+t8t1+GZsPUgZ0Jj+YSIGib6sQ1pzwIf
UarEGTjBzAeUIlFW2ZR/A8kRdUaRt7Y8TW9YmCJRE/i2uracD5flqVkhnyKk31DFlrOHgxkVYTsxlXfw
fgQNRI+tFfcv4R24wcQ/eq06FcVe2Wtpxtv1NecYnvKTDcSVL+h3JIqolCUooyG8JwVvqwfZAi4cjbSr
VqTZe7hF+kiYGR0er8LHRTOb44sNyB/z9P29zfRiJ+B86AGNGa9Dsb9BkuJtHQ2qtr3h+BauB92AmJZR
qk7dJcLSMAvAGuyGagqTOep27iSTo+kAjq6ZemZzEXZezDu7HAsSktnvAqAKTGulZNfWy2iUS4L18z+5
hE4yZbdJ5gTbSgszMeFcS2uqK5N3ybvFmZTFgIfyUQIL16BrZu9KaJQvyOKmS92HtFm76QUc1yxOk6en
28sFFDDGWfuL8vbdAopArr9FUMyyi4vhXWNDNboIkiDRMbmjiY6sBEzUqCh3xXnrmb1hrpxZuBnNufXH
YNrdEEeA/4xGG2QjHHhalcFWPlIDpC4lYTwXDNlsQ1feOQ6ty7y/9wF2COyoINWeTgfYmM2mYMrLGpU1
qRZ4AOzw/iFRnJDvUp/VXFawhwxi6gUDucnmoMGexWdCgx1k48os+hQLFgZxR+fyK+h3cdQXaz4bcRrg
fQEzVPzbMWM3+PpYMPyqGU3gogh7/A4Nvi73lJ6/7b1kxb+W0TAj4b1Eur20kgGoGEepSwAmqY+5quEV
ZOaDgHH5wHfctdzW6lOx7K78Mkiv7W31cKLLEBpSIuUVCqYtIa1/rZQIwOWWBzlsrg4HuqJrFsmgJ+uf
kLQr3glLA0ls4VrmfKOngQiho4l1A77B6Omc4daEoqXPAoQXLZoQYBh6KgsKa4R5/jsmllAxj83i5iAb
rELDttR2C1AEnzwGsBKTLhMXPsUXp6/VrehccYvG9kauR7Z/bAaHad+DF38sWta4jH/+i519Fh2yFeX1
yb4XdesvzFDPDBO7GmFy0gKiFiffW4D7oA4RaDIZCRqlHEFajsARZCP1M2HeT0GFUy3Tgbqs4HzhusVv
pI2vknrIndhoHl6WYs7beS+vHD0jYi+gG28vIAzpuThXB8FCzUNtlCfKHYVhMywlAcgzmSbAhgNCWlZw
XkGM7iwg3BgRG4ac2DeIPZlNC6cjyL5sNKPZsgkl4z5K1JkcLZxsIB1YpUXwyHiD3/UGC1zAMMz6V5Wv
ay7TsiUv43sI9GwZnHWOFHA5+z2UrdwUMqsvwOH4+vWg9BwwHh8sYUJea3G4Fbb2lwHduB/qoh8xy2wc
NWzC15SPhax+n3sXNo1HVNPLqqbIvzhf6PIcpYCVMAB1a6nMIjuOAncoWdF2GefSx1HVb8BcRjlp4dEU
k/a04aZKHNJuYY1CevYoG2vXrsTJhnPFXkq7NwYXOat4kqTTQfT6Uiiw2ejFUXQ2vxCl+1eckcgdSYxk
oWcSIAq2KwoxnwxRTnmGUfwCkUhgdTJ1MJD2e6lluFIn4E7ewErpcutFILuZQjg1EFa+6koiKxZnmwdb
/WDc1PUCGdR99rFSda5r8KzwiyEVJecTu4B0WvjjSWE3Qd0g6OVYVTeARsp1A8tVhkksNCTKVb6NjUDn
Bb1SAsSJ7Fcg9CVJffW+lqV3npOncB0uFhcK+564WFY2eHzYvyTvDhkxW+TH47O7Wub4hoTbrPOV6n/j
Qte3QHz7Si/w4ZXM7zPqt4Tcr8wkXNClFEQlXkMm9wKCKxCeVHaXEMVPFLhGiE5GJC+V+HSZwq7M06fR
w58QiWo0rODMLb5FiExT6fBU9FVgcHajJEBxCy/MkHdfXNvT12/l22DefL6UyKELRxJ6qhxNLHeDhiy7
EwxTEqN/Ll3xpWnnsO0mo9DtRRWh7FncAWZiofURDxWG4N+/JF+slWfEog7boOOLRQ/SrUQ4gIiqwdYO
bC3S18jhyzxtUy+gMORkg1I+/VI4JnPXoUydIn1vBW5q87mYw7mC3Nnl4VIXxRt/O35Emt53J7el9PjO
O78qRSkD/y73pNTchrntTW11SwFcfo2KvffEbby9Ra/ILStm0RddqEJuYXG3q/xT3KgCZLkBdfNSbKy2
B2lhkZGMEJh9PzuTCdSg8CoXmkQLti/t3SQlWwmLkVB8rYxcMkW3s8iPK17P4jEbdLsKGznbZNc0XTDi
oD9viQtsqAZUcJtNd/FOi/WpVYsuVnmrbh1y7xJnlUmE6muJZBS80ROxEuYf5b7Tq1o08yOO9+UvaTFI
+ANuaBnH12fxtOjIj/36TfFVktua6Cj15Nj9FHb0YC8TLoMF/iHjxjfkayQU+A0pCwOL/FRCvxvgti3Y
PAAzLOpeeVhwsg5i0eGV+KmQVYwgXcDiaGcJydio3FIGsvMUt5OAhnZEDzdVA/ZaiajDWUdt+T9BMp3I
czxwYz+4DO0keStaceBia8yoj6aB+iSeXXKzazHTxk3KYxVp24SX4vvwgreQvsPuCbtYwHuhEsYSUcmm
w/WDYBymHkwMqsC2tai049cQ2JglU/BC2Lp1mKCqBy/OkguiXybPLfPyqBUQcPG4PlVCVPMss6KWbw3Y
PPsmf6bOrKqbQClVPbBUNZUSvljIRhgP3taDY4OecykocHFrIWdWWYN0CGyBcDlyN5Jkkk0EiNNVLyx3
1b5bDK+KVjECaInrw5XFzt/iWN2pOhJsK7hoXT2eTf3v6hG7hbedrxCEK1Vsb6wK9Motrz4P3XLujq2q
0S53jfednkil1Q05RQuu0S5X4WkcZfRu80eJ0Fr046bG4wfXgB/o5p011aRwn6vQrN4iz41uJ+y7MUfM
yEQsacu/9tcgt+Z132xp3m388x/rJ7grz8Ddmf7EtFc86NZXrSKe93++ge/mG3BDcKhzHQiYVt06FlJG
MzC4/9nwDRkJ99qQysJIsDtzWLx2sIRcFvrzv5PT4s4ndOXppLP3z3cjsBnQn3AhsJFBS90HbLBtrwM2
L1a7DVjXopIAKRn65x99FbAVx2ZUK/uY3Bj+AC+Tyl+aT25Kj/q5SxhueRoQdxOyJmB3TyiFkJRJGHRp
Lqw+yO88Sc2VIfJ8EDwaW+P+ffOIDjsta5SYAW1HD/665XRznVp/Gw4V27fq8KV8t5w6bvUzlBgcHaFz
mKpZOGq2b+9cnGoteGrCpBvfweVlcrZQYXsmDQ7CVissc1tljTZjzxsvfcTN1F5uq9ImvLPLk2UZ53nG
wQsTSDWOX6+SbTy8b3kkyfRoclN61O675O0JnE9b42Gy9kTwDu00zU/kpAjAgWvYXIK0dk2fW/OP3cGg
5WTjhp450gvF6/otdAdeCxXVRAW1kA44/z0WHCv5LNa8FJaTG4ITucjfmQ74BV7sq2AKfbGeZuvrOwFf
IStcZNNJY9Xyq+BhyuLMSXMZh/P3NPnUUprNyyweJIOa/tAd94fzQUK+MVzKHFY2CjlXGq8Gpn7f/0ru
f5OTIZMSlJVQ7ikV5sA+GYY0aF0m/avXOqqZg6h5VWkh2pLKoJyzMtcCT6AasbyImKjeZhOCfYSMZY6D
HImpn0QpRKaqO9TOI0khWG8wfFzRDqSR2Fk2iDKMLkijoz9UZdN9/NUqIlasssM2QexKaaY+lLZp5Qhp
0yxxEoXpN3OSzi5l7ODLLGMBVIYXyBaE4S80sEqtYPwlfauHSq1glNzDGySiMHr1x0XYLVigsMzQ4WGp
713zQt6AdZ+hHkIrPdRJGii3XD/BIqHYwDdaoQLeKndepsk8T5j2b9iib3xTrkn4EbfVEEctWrRLHnWS
Y1pp3W5scIOGrOpfyTU56r+AHeSHTxdGVjq6xhGPt1xU0MQtVxVUtctqmaoFS6C6LBlXeYxtVEw9A6Ew
CEFZLHrLQjMd1fQZKyylnVfZTN6WcBPdJPyU3A9UOuobB5FJzOkwHvbn8ugjbFcqgCKW8hrNB1w08TSq
UiXofuB6i203gUodt/UhnTTcD7EIFiM7bdpksbDB9ju7UZl8stEkG3OapQJXgNqLZ5fCjv9s1fp0PE6m
OjG6siU0gOr6CvVFGQsMvAZoFTI5XjrNZ/bEliAPjbY0j/JRDBvfQd4DuPuFaS/yXLHEGHwFTyJSXWTc
pl9+psM3g4udKFOxhtiETHptLTpaYYescguFTmbCtNi7jYPEtxOlgneFDmk5j8zxeKDdOAzGFOFHRYoX
f1cG0Xw4VEe907GXLBD6xAh+6iM4dQgubqRkQinAJU2wapD36IPylpm2f/XaloWWaH91WuCXEi8n7Irl
QFm2CHcPWkjRe/ANEeDF441KbyYK0EYwx4MqgI5fog7hVndivNDmiiix6HRxRDurq9sYyW68CWjy8xfg
tP6hZoSlPExV2v3ScnV15K+6Zn/omgFwCwD2WlhyCCyAouhi6ohyTJcYfMatPxeopyGzYRJhIDAOk4XY
S26Jt0X1FkG5jHLhkyZeDUFxYhJgUGu8fp4O4ViorZud/VYkh8Qnc/xAusb96fi6Rk87emtdwmwvTTlL
LuPrNJuWsSJnQBUrUHznj40RuW/pl3DSFzksh1XrNCTxVKwlI2AYzbNCSKyxbp4hF6u5dYeUWJO3uARO
spOQAX1JkKDiwp5/sAK1sMiGiyXQDf4o/Qt4npku5Tlw2BTgsh7JJcMiikuGAcgZJKRpgMM1HNeis6Km
Yzzg6Mw9lQ80bKyUn51yFC2xUrhga5FiGQxkvmLl3fW/m6giWnVb/1uSdQmBI4zM2wAkV0m2K82knULF
kYO9SHNk5Z3WhpiNT9mynL7WWKl+AYAlFjXA4O/1JNOZsL2udpYVT75Dk48VrnwHT4/us1QDQvNhFBw8
E2k5NcDwS+WJx4LxduRwfpGOS1yVwQTV2JVivvqhQ3xbYme54KGj0KYb2Yqy2094U8oBdYszQt8Q53Pr
SB7FblBozh8eVuP81WrLwKEQn5MwpcM8zKVH1PzC6OGkp9U3pOlsRui/IuZVBkm4fniPmyz0kg1vjLmV
trzfj0vJ/mWaz74v6TdwGKdMdBWifZ/oMd30L9PhQGiziwPOhcUbv7ucJucfKmWh/qZBnNkGXgUkj3wf
3OZVNcg06cJI95Z57s7yDby7X6mYDzKuzAbLmdrqG4wCbzmHT0F+c3CDxF9Z3HNxQAO5UycY0mAa/27R
0TR5semPfjXZi+97n1FM9Jm8TGtjKC9VMgVQZLSqu6n+CcRFu8BnebJ5iTjtFSKiTayzfSFTa0+GXvh1
PBy+ysZJcy4GAwmQWHZjoa2y3vqCUGfPZZeV/xif5ZOdX/JJPLY5/uT39/d+/WUTXv/KcHeZDQdyzK3L
LIPciqNsfCF9q+eC2LNPkOqpXneVRvHnl1It244e+S81GArFsMVjSqQCh1L/HcVTITkrF8ObySW8jOyv
jeyqQhfELUNPgpHit4v2cHXT/FUsQ3OfRpvVdFKNv2Rrgy/p5FLM1Zd4PJhm6WBtU2aazF2DY2GsXsSC
t9XFmp42Loh4Uc2+zeYyH3S1Agt0lsjnSpSOIw6V9DUYOHZCcR0S7aEYeH0Uq+wSJzVnt82qvHKwvOuv
NE4e92YTJ+sVrMLZQ3qDDNlLvKgA/VWpvF24uUWU2PILpHlPL04UI2/Wq18cIvwaZNWianQ547TOxQ2S
xYLaIu9D4w5aA4HLdVZL1avRbRrXLfpGr30IgWanmwJWi/y0FbeCTv1zO9jSXMazlmY3tqaMpj1bpyRX
iW2+0deso3RW/C5UPX9QJRgWhIj6ifgwiL29JUxr2Lsgi8ZZ3evrAaM7qv7AhiXszYDxTICqeqf3ikzl
kpHBMvrOQ/vjRgabGPMzYfKHdzAUBagrPDDZ6IGEF4zjevoXgcySlWq14ZhgCQXztb+IhJFj0bC3ooRe
iAsrHxxHZNE6iJ4Fm1D+k8AXWevgXNcGx0q0HWpBOskC/IMeCxWQri05hLITAUwI+deIhRKq+FUXTlwB
2w0YSeauM0pM72TxD3X/0jUDjEyS/G3SYzm6iZAiA8tvBrEdMuw+NOvknrnwBXM+ZhcOWiJ6bdnjs4Xw
XodO8qiYYsjFB8EEQu8W8kghj5czOA2mnypLFCc6aI/SmQrzCUxmea5OYwleqzMaC6TS4m3aIn5UIoUF
nWCkCoM4GaqTF+6ECWX2ZWlhDanhK+oEs5lO45uCbkrkAV3Q4eqUKq+Dx8DgP64JCANIceoCwvm6LEUG
YfW7KRh8KaWpHmVYhNfHr5ytFE1OED5vup4JtV7w8K0ihhlmhUupeTg+fQT3QQOY8qxR4QWhBUzEKBuF
TF0sENeDd3qqvFWgWDxJ14a1mO+/IrSZThYKi6U11WXYdaHMYgJZbtJtPFhCcha2KLdxSkVowXgNwePx
hlalzE7hyUaN65pUOKmvF8hoGDyCJrTUqipfuK3FhZEWRHKUGjp/94mnmATtdysIgUZjupgcsnEvm+fJ
rk70yfMouiYlr5dCJTobzqdw09wIag4yde1cHRKKwcOGMPDnuCYkJJyoqrvKX8AE2uJsilKoqYhBGZ4q
DYFRdgZXawySa6EV8lSh2ulSupcf8BK5XIrepr2uZLI+PY/HgyG4T1W87NLBGhbv+8nNYqxLY2yz+rcv
Dx59efTzl8dba5vK+wSAXiU3LcG5w+cgb411hnflcJKXAKq82IWsFElaDJ6k6QePgMHyt3/zZS0Ti9oC
8/nBooDGV8orlyjAjROXwc7hefQz0jGIcIN15r9nkdpGOvJmH28VNFtgvEYbYMD45dlhINNdMLjSR1io
ReYbi0rypHua38F1Mp0K7TTnbsb/1hdR2DkUjzsBs6X8yqv/DlxIsoxMsiss4UlytMt6w1QtXrMkdHGx
3WO7AlGqnb3P4K5F8UOmjYdTYxXLLSHDb4D9lthLhTmESU46SNjgt6/ZzPImBJ1oOaE6ezi2SQITuuAm
NR9b5+d3hq5lkJWwXMtL4opgSqKias7Lh1FGWdhOMByCuPHxfhpK3EZaIxV2loya8Pb13LaK3BTUd18q
QGv0kvGSHHMaYavkmCORFfoW2m24rKkHpsefmoBuhfCM4kwqt8qfMuNJWtRGndzKNTwK6pDtBfnV7MWR
B9iY+1PysDQGA2PcSMVMO6RgB2M+cSVBMi511NlsEAc09HQ8mSvNLfHO70bmq7yepqKvpwEUjQX6GLdP
CtPQVX45k5iO4DrWp+/vqaf39+xm69lsHIn/b2j6l9uuqtCvPLJYwyPvUakGYk/4rXHNeTocmDMY44uD
EOXKRTo4cJed4lWrsm7YmmVZJ7jfSW6/2Q07rXgFNxiL0k+ojIi2c2XIQDwv3BgRqfhOOBkNNNK/FHhP
2NBk4hA8NjJWrSa9++mDTfS3+f79l/r6porVgAvdqjQ6CaUjoW2vkpFEjEyMPs+GSf1TPJVHP1G7f8nX
BInx1gONEsqgA1OI2hsbNof4Gq7EcoOrWr5/BW8smEJM+mO/wjQZQxjILTLEqPmWzqPwnPr5YDTDv2v0
07YXIX+5XZKFWCpCi4QiUhWA3NOxPK3myvjtlu15eePXdSpWHOpIpPHFhpyLypqWTr57D451Cq6WnRc4
L2uF7ytBV1S4Pfu5Fn5Nsez4DmQX8F08d+zMNV19owM31ebTsu5bdlOBk75uwwtHPHj7FMP4LIH0Ff5V
LLBYTfC813zAqDAIsG7EyOHXqBLy4gSt3rm3Qc+4QydveD2qRJA91W8eNJVwF/BlaUd3oOvfslSsEEGu
yziyuVuuaEqXc5UjcL7DLH8NKC/qOl47obZ18XNbsUSkVRJ8o/drYobsextnVmr5322aKQXzWmStihWT
TFmd5Q/IMTWLz4rSmKtP3y2CEsU4ip42xf8D0Y3j+NrEWIqfG6IQinAMpkinaHFXRytyN9CSN86Y1NrK
fask3pe5F9Eca95+rhvaIbmVIGdzKhRnoSIyEw2qhG7vL8gR7htqxMwyWJG2lENCqakUNJTU8IypRIC0
OR1dEQveV5ZTSgaF5JeWprMxvf3V8AYDt2JJrq+6+bDDa6DReZXQNwSOKjOJx4nOzyPbMc8yso4WlalE
pJ4HMemJMH8LCkKoBaYWaJOgGHWt4jJkCYe1MJRmkMRzqb7nycxubd23ETwzf7vLl+nhDnhsQCEGLOXZ
Ls75fVLnYz8fIB/o8rcNyGhOsbxNKKcmA+AKZb4kWYAsZvfAHU5QdmcZL9NbyWVCPiZ9HV1NtlXiT8Jg
lziTtNPoXeWZdRtFpv8PKMJbXcwz4Hl7Q7l83fChXUU00KphafK3XNKVGsfeB483H0+H297h88BZCaML
yjtEzIXkWDybl45GbuUgy7H+nQcCgjUeW7PpkNBCTs/ryrhqiedAyQcfiHoAh6ldq6GkJscq4g3Cz1Fs
h41Ex6Vdp+FlJ9lGsX8eAcKCc3DDZNUHrGAGPoJ549fovlj5I5naP4dHa+LgSgQMV55BjxRLPg7fArSt
VN/f+0v+/t7aNoLr6V+yqPqXbK3UQMS2nTbhilVbjC7LURHEcBKY19FE7gqVYfbrgqNRXjJxMWeLeE7e
T0qPPll28g/MT/7hMZRvzQH+Z6xC7ZQ9g8s5pdvSffK3xQRb24BFUPE8GQcqz7VK9S8HI/U15OxxxeVQ
XWpsm2V7eUePEtmqryWzY4d90e7iZjZ2uOsfkfKi2149VJVXLvHrvgZlCHAczTJzab1qDM2iq0HYE3AJ
iRo6Vkt8xjMVcpYrg9bndiY8x7ZLK1oNqJBPkipm0b1LbaSObuGZ0Lg18uSmHsoIUvngJGQQr/3gzSME
s98kH0IePXqw2X7//8m7Guc2jt3+r5w8mZK0KEqy8/FCxtFzErvONI7TSOmbjqR2TuTJuoYiGZKyorH9
v3exn1gAu3eUZLvN84xHvLv9XiwWiwV+uO9TZH1ZLerx73IgE49DrEb0F1ATLwXfvly0k6j4j+TSh+v0
KTbw2wv5d8PPT+6/p1buVM3l0ARnUttvPfHf1JwbLy1SMDT/6AZ2DHAbxSd49eG53rfBe+5ivtQWBsjr
DjaBI5RIB/T3c3G1no+n8xXzJbysZ5BpWOz8ODsH7/wb7LJnPm2zT1Pr3/dFGJD51fJwXS2GxT4uW7F7
8/aLyM/vt0XCwW98Ub1Zqr8QyBhngHv1hizmPt53eLmcX39noWAg5k0J16qtDkqNzoMm3IiZ0z5Ejaie
a/3pP49foZ2Y8+6WP3QApfeK6BG2YU/5I8EbMazVW3okhgJEL8E2LofUhdBsr4fWkdAkGjg3Qpww6JdQ
M/wGRBJ7x0SclDsn6rgJ1bX1oyRFWOWsZHmlv4Ptyw/GAwernIE+jZitzogQUgzSdGm3Yf+zmd/CWh6G
8iDY8Av1agXoVJfVsp7U5Uz+XnxT7D/q24VPkrzUL3Uhq0o1cEK+H+qXppJ6Oq3FRC/DF5WS2xqZkw0i
vB+eHj07+vHls/9+/urXl0+PDo89pINnlacwMPz1SCp5pRfhxXavezw8ORmc9g66l9u94+L0oFseqEWo
SK0ad03a3mClHY72hUtlwwSJ4+ZvCzmhtfPESeEVpRxDs4IfRdK/cqKPOpL5NqZTe5ePExP1PqkIhDTZ
aLq5spC5m3MioV27rtfji5eWNmkXc32LMprUubuLjEceKpV75QnN4MdyVkI3BBxRp/KO2WuY5RrSNEMe
U5Xi11vAsH/Wz7B0YC/v9qRA32j0bbsn5ZreEhJe6vhF37GLCeMUlglM0ut/0rD0J/KqZ26AuAdnYAMj
u9nBfhWlrVdgMcMR25oLTJEIXzeJ9dZXkmW12IQkvHOVKcWvtQmniK0k/zckIX6OaEQu4EnYP/a//mqv
r2RdqrmB2iWC7BWWtHwJIi2HI+BeohEQj83QGKE4aqBlJjwUuJ8p0NEmo9W0RUekEBQL3sgaJDJU8NK6
XsYCocSEJhqVtiXSTTgn7IOw2mEX1N+BpOS+o4lJDoMwp6Z0kCLU4d88bMPD0D7sqIePNicbeisyppGx
Zs6udMdyvFBmmL974gqXGvimFwwNZ0AvtLXYjwjOylpY7BZKVtvf4+W5OT4+7evfUQLnnmT95+MyZcd5
KENmHqFXA51op+j6hu8Uda946CtwJ0zK/XVjLX7hRKsD4E2/0MYQQ3Q865r3VpADVOu+F6qHwjao1h7Z
LQ5talvSXg9As1bl2ZQVoFif/eDT0hB4dNDNfumG3TzddeBNKamh30Ojb1Nmxj+c5ukM2JZHc2DeSbPg
vrh5eHSHeXBl7beaiZCazwWdjeX8moHD3GoKoCAzMseaUo9rP7vwm8NphwezkG1L4M+If9XIMi8LCEfn
BvTxqZCuXulUXT68ioWbhrmJP9W6wx491gmFQlmHlWIvoGcAbmdbsB+3QJK5ChMFL8ltEzPe7vTCBD2z
l9lLHG4dxYWFVIwMKubqxKyq1Ob3XhZL8jV5WSRdl0+y+f6P1ke7scWqCBAXsxIc6RnOZ08ZQepUGz3l
Rg+LL6vPbzGCrevRe87D4vGX1RfpZeicinGh32C2qN88LPZ12AGc6tsC2S66VEmSd1Y4oLl8ahRk2K43
c4AGOzgvO2LFp/GHsJr1/DHHuqx9dwMc3lYmQSWJto/ZE7xUSivSjJrUUpegb0S9Kstve5wbJIUemzs6
y+pv1rb1Cd7MZu4U3Lno9CR//nhnR2Wj47D9ni//8lKuAOY+t+ZclUTEVhs9EwudhKWFQkWqxtAps0FJ
pIDqc110/ZfqDFJF61oF3ZQfJnu25ochpNZt4Z8q0/MGJGjcvX+gapQG/hhytZOWty1XQFKaRc1gkh2V
2ZrUOaEpaCFQsakVM96wU1wmTfZSFk7b99RpqOK++oWZE9gbNEQZavoIiAnWh9x0K+UpB5gaHe1hpjaG
vwbGAuC923wZF0HdceNwx7fEAtfsMRsc0C+p771E6HeGeIiJZROYh8d/e/f4q3ePv373+d67/ccS1IND
UVhd1OdrVbR7Lqfw9EGBIL7X+ixFtxIKBMd76AVD0oSii5TfjNjwTycaaEwalWRZTl/O7f2xJhCJNFhO
FwT0kWLA+HBpZdjU8OutQPWoC8Ya/WIJYdJ6lFhRqyR4Gwas8VWPXX/Gz+qAWhzYJu+o30PyfYfEGkmj
bajRaawr1HNAvm3ruhnsFBksa8NqHVy7VwuIMHc968nnrF/BKgl0EXsRtZ1SyYK0WpQwRNSSXlpIzMuI
lCGmEUySVWxvWMUGQ4LwxtjIcDGleWS4ONskzd5yfGhFwhg1VERGCfOobZC4yAv1P2I07cfxkTSOW9Hy
zly3btZs2spWXVHPj5NhNvNniai30pnCWM0Y1RTseqj5Sv7o4+4c75/e5TwSQm2LNpysIWAy0Vc7LUUx
iTEUrNWPEox1G0VBTPXBzUc6pzSR+sMAfPzKxUq6nkKp4IR1CG1WstJFuSzVqIPxoe5GNtMzJdBHWaDL
qQx2flNnGNS9FVxJ28GUhyaXGA9/oi4Jcykq0panByUZDI4nhb0K/jK+w9OroYM5nU2SYqlIatpu8pkV
xWWDZ6hGJ+vmbJrT+E82nDlemvBqJMvIYvDz0CZ9zrD2cwhZ3ZtfJmF+TLBX8G3QWCtga8nZuUmq8UJ2
rquz3+v1TrlYVIoeZ2OTTy2R87qaTlhmKeZyOE8njkaJxqlKko0zvhsQBng+m1qMmat0X3BcdDzXOVAj
FtRJwIAK4a7x5Nm3ialNhci+h9mNQlW37afkWyx01eGX4a2FYJiRT5keSjhm7dDF8LFmc4SxhMpCOHLf
HmVMPOnmPe8bht4hjZEzY2LoKeIYqFlypmm3QB5rNYx3QR9rMYYCApnuaXIo+cl7JKKQMfPdNkhkLNNI
RiODX8RTVHRMkDHJZONsXwDYdpfOP8J+Ucsp52SK2VLUsw9ioq2voKs/1PFw/dS5UTxflvo6y2WXv797
5xMEPjH6C2Gs9SO32/D7k2GveWstJygcIaHB2BJrF5zYQQNe+X1K12OPvTqtP97B09SDtUWXe58ErE3j
Y9fTen1TnCkqA4AiBkytPZPPVoewswXkUgTjZL5t4twHp0pk7A9o27xz3sVPVGRG43G4BmwlnMP91KYU
7mGgAVa6nf5BN9Te6x8Q8SnkfWLMGtS2QLb4LoSUoKrMvC8iAlsLGUMKIvt0mfAT+YQHkagn2LqrTnde
vBheXnZG8RokDhb+qRHZzRUSFrHsJJHqsWbmy7gxgWVDY8JT9+259XniPetbFyx/c6Se+FA7T9UyYIqI
iGScr9jrf4ukqH/mlyWz/NMrwju+GkAyla0fFmRMbLlFrZGtovJ0SWydSVqbiIg7s/m1eDvCJ9Hxj+Ba
AhvP86vp9D/VQShpKCwfh+m61LHT48W4+18nDwbbJw8+25UApTIN3PYt9CWurs7U/tfdD6BvAUP5Uesg
Hpk6A5GaOIqI08kmebzS+NEa9aeq1APWaL2e5zv/f3D5+gnj46i33KuiMVMKms/jM2jsBsOiNHBDgCkI
6XEtNungaqZv3hA+XC2vSG4fbIoIgA0+pzEOTkM1JHDz4M5GrVF3CaH2qKvpRFW6BJlsegOSYbUOMBs2
+M+/wN96orZ/ujunesIttG0BXevgKihWZe0IfghIptbGi/gcoNYcoGkb8gWZQBtMEBP0FNXrPSrCu5yr
TdNIaMvENvZW5syh8zv7blI5Ce+hW6tYg5j0myfUTm20WbttU+gkwsY6U6R0RSBbiuuLalZcV4WSY9We
a0hKzwzblFzJSYeU0KE0saDztRPPLVCw3m34PocsMO1la6imH8YqFuhlL8KUBlhu0Ozq8kyy1LMNavDb
2aiqejXfsJ71/MfDV3aDbkOktjC/z7VYXu9z+9Km0Dm4vs1xcz4xao6Td9NHmHBzgPugiBCNE8w04ACw
ibbOWIp1Nd5Q6LnLQaLaslJQPQ10mFqDyBMx4td4DDXEQWo9tiFR6pOWmg0alelQkfbCHa7M1nhAktjj
meB/SSuNBWd3+bsHhspgmNzCf0ry2Mwt5az4Fwk5lpblRcXAh9tiD99CimmBBOwyq+m4swck6HU7ReS3
ImbpSyw/e497v+inSCtR8JuT9iio0Tn/YyCh+rDzaQAb1aTZqk5FnQ8lfDCMmvHVaj2/dBg1Sewa15D4
s4tHzz4noWaM/SB9i2Fw1vOFDH9j6ti1fwXgG6hUlXHk85CqPS7OxfxNtSwIOk4AwYmzSSg4oOxixQMo
VzSEawNx02HgOTF5NSK0YFiW8fxyUU/dDYAbnu/L8QW8u1ivFxjgLZCXevvZ8ulzhtkCAQFUrUbiAdJb
z6HZOlDACCcMSCqNQCpRPhi+X00ogl+r18/+BB+HXcX0QLH65OTBbv16JICmHJlJlhBTUigpJkexUeB2
Zz0bG37INrWjlOLeVS2h8TbEgXcFhiLUDFzWK31jV63HF46Wg1xhX9DmBOwVV5J740P26md0gewgdCvQ
28KNiqcz+3IU6WFdNk3EMbq8lZejFFSEirPbM83z6bxck3yYKVPwDxtAxXSlXBVGruI3K5EgtmYRsMgg
eTy9KE+mHb8YDm3bYXk52+EaYj1tFt7dtViIdcvui0kNDZfvt2uHcGPf1I71/PXrbNDR27XEFNu2LWHq
a30/M/O+5OiFc54kk25Cf3MuYi9WwUxP7SuHayOlipRLtihLcSLhkqRJEg4cg70jwVDWclG2E/aj6I4g
cR3455xNRVZFOxBnJW3L99Y10qbSbVTHwomz0eochx3Fpjl5cApqN98rcIUf0TIdjIgu0wfjbVOLZhGt
6gjlG2THp07sh5I6PROggHafleIMC3BdA0V01fLF0cufqDo9txgIZT6HuYM9ScsVoL+aFTW6lDMkRQl+
AbfhcBumfj5zm7P67TqgH753QmBup2tHo9Fh/dXZ/4CNo0/a88MCUrD9Cf7dJVUseOtrCN8g5nJRk5jY
AiD5Zs524JsiAXI/iktTwtPARISXVw4aKVQ5TWLGGBa2nZ1EaX5MuY1afPCNEjJGTA61NvDS0Eit9EyW
kQZ+1vq9vDTA5QG23o2MHSXr0zSwG5I0ZCVQDQfppJ1idzYA1x1t6eS8uQpR42EkYSRKueyg7AkI5eYl
VxcUNF+I1aV3kN3XYL4h+FOpvLwLLhLYMBy6ElTvv/sIcudcJYXXbSGHkJMUaI5Hsrr4zJMaWI4GzVoo
uaFgzLp55gbC8NRvpwh/tucmeL3CUqOdzNViqpZhh8bXodfqrgR0tpcpxvj8IQpztJG3QXSGn0RQSl9Q
uyq07+BlObsqpw11RI3SpNsBnZI2DtQecNpW0J6zQ0P0J77FtSx4WpVvKl0wGPjhcvUXXm445CGnSH2F
jDtsa1Gvb2FH6g+As+fIzDZpUMrNPZPUp9UlifVsHURTnNV8jq4N6XJwJRzQTENx9UgeqZmlAxw80XT4
xBEtNpH/GRM102uITXWI2+kXw+zxhYtNEfq+vJGmrLfJkPw2A8Gh0A6mq7uzEjBY6GqljBE2dPYA0CPF
00cVoTzH9enorqwGG5l/MF5zfv6hmE1DyR+P22xgb30ndiPIQHAs4bcghhi8fC9tt/aTPdmwBRVSSOp4
3pLvwaNkWiwqY3M5LqfTs3L8e7Rixmrcl84zwJk0cw76g12YUdQo+Oeit6PLg8ZVrmkou8ZTrQopgm6g
0JgEnREVqbdikRjMP6M3MtP0duwZxUzcVts87fLbwscCmoYb/+QJtL6Xr7FfCE1vM9SiskqYv+qyDvsS
uoyAiIq6kIEJqYvWC797tlEmBBlU27YiaXLIyVcHgThfyzKsyg8ZVL4gQBMKfQHqwXJ2U1R/1qs10HtY
LplF2LTq3JG+KBVRzmfVxIdxBpt29Xiuzt3+yElOnGG1BiZT+Xf+SOrM4IP2RtfkFQEmZEbxVhJtDq3B
ldUxgGl9DWXA9UNRvCx/NzY0Tp1fz96AMfa0IsWs5sWPz4rJvFrNOqrA5Q1EDdHMH85w6nSr+Klqx1Jt
DQO5k9qj7e16Dij9O1+rf4s/FbGAQ3/0wobI1hvAXG9yb7x1OFwl1ZNJNeu874UIKJ4q3aVWTsDzd3MJ
QQnFXUFNZ3WJEVaIKHkTM0IsSN7AdOXKR7eBsMJ2IGZplDtZrblfNFFmGDqKXzfhEjLfDpyQjKq79TLc
uosVU2ad981yTd81t2cuSa7yPqGZyWmbCUQgkoMvIDaR2ge69g1c0CBnA3h0yfQNzirpaV2Y679uMoIy
bqvWXP3iqJfhnFibt3Flrm0n/eKSrlphzfKlF60jm6PDVZfaXAN4rRoqE2ECZCW1df2jnhh3+BFoaQj9
fSfL22280PDCwDKbES0FKdWPHHcIZj233oEQ+iMS5P6tuvmNYY6mbLGrhsK0VCiXuOkBR0u59yr6qM+3
kH1A09co+0iXY60lH2FJcNHHND9HA0Ib6LBT4Uj3rY1wlPTlJCS+xfiO6CzUhttBlbIoJfJeTS4R770b
s4XqM/WacGYQFRG2f40gZmSLhZplbYBr9me1r9eKRek3qorVCsQtI9Wr9cOWvy4ood5NswFLjUjxAOU0
0AIbyU3uJ9lY3seW0VZ1IbBS45fhpcitlGEm5ofW1bcNQ2zDrxovmfkAHxBuF2uKjDSRtnaLmX+m4tDp
BHYEv3DOArHLu3UeR2ALnyQ8RyAz/q9WQneSuRKlo83d7T70MGTf/+KyPSleV/5JIi1X0UUF+FlKFJ4U
13pPJxUqWf+6KsblrBibNVvzylU6Iw88wdRlICSQuNDpsTsklfyFaUAyq/neyXTBGcCt1K+F7gkcJIrx
fL6c1LMSfO0Ug/LNN/htYPZVeO9vqUvxWH5fTscafHDySjeLnzT6dBL6fmD6oaNCP35WHNS5wox9NdHh
jNCyq2EAHd4GAN4/O/QC06fRg5FIhGVClKfVhuj4RDNyIKBRXV/UYMAGiE5fGcB1tkumZGJxV2/Gi8wA
IErS2ubdyKHmiLvPfbaZ6h3zzb8f+M3D+WVVnAFOPGjMJ/NipvY3cE7fMfzXKFxXaqReD4rD8rxc1r0m
9s/GLKhtWrNqYxskMGovXkbMkHHmxB0tHHjSrjveutOeiMhFjWq8xr70XdnAoQWV7ZjAhqWj4UqNB2No
iJEtPAcrx+urcmqZmHmwfIxDEptxYHo6fY8CRoeufHezssOYukFvU/ITJIBexZWMQb7qaMDHzjAeOVO3
ZMqglUyLiGGGR7v77RaPip2oezp0CS3K6KcWMWMNz3r/JPIm4QBny6r8fcT7ZMKP3munbtX6aCT+4d7c
rk86lur/lWmK+rRpf6xVyR36Erf6E07Ne35eNYttny42z42EZc1vjyCstYXpMC7d8yVEOC7+vp6rfWK8
oqcXt8INpwW3A30git7aRcHPrhGXEBqepj83a2aIn8RDzlRHfPiyPIgW3jSh0WRmD6oBHzMaIN1DPm6m
cbcdNpiLVMeAlJ/kKHuDIZRZXq4qxhA2uGpN0fJ7EZbKiCkjEZMKbo+00bnfTVeCDwW24Pjjqlre+NNB
NOy2Rmry63wuNMCKi5A70OUYJMj58ul0agpGzmDvpYZE5sGihafr9h8D0NF0Y8cWcFlD2cBVARxd4tdI
yiMmpctq1cKaFFIJ8n/UjsVVqLAP4AHayDRhFO0+p9WRISGmBnEsbdLYLWYkg4oxSDHuRBZ8iwBDzIhZ
NuKzJTzuL9QWVcvCWEUBvzeD01ovy9lqPL1a6Wuvt/cCqJUHzsJIV8QUG16lcbWMKHx7hC0LooWutT4J
4JWDBrKONRJAUHb4wBi+oeFtEHuSOCqWqlyngFQHisBW66erF2A+PxN9ZSUYoVABKACiOzHJxsypoECx
mbkew1myxvds5JlLU6l2CM2R0IAbOLGj0BYJbezILdyNAMcYH0RoYW/lwbQ+bXbtykMvny1jbyuXM80g
7zh9G0/e+zb4OJ8SHM526FMgw9kLmHawcJFlEGDCpdRoWUC4xXwBl28xfw9+njwUPoJmi8q8T3d0PxIF
sQHdwA/dd+FjOKGrLaa8qMqJ5IYe/MtTDuraTdMac8gu6qj8D+akTpzRQ5VxAueO/pmUArmYG7l/R59d
RFdzl33X/xLczYM/OfEkTzq/BxfzSDqSPMydq7h/cVnPDNj/sNj3L881agO0QP/A+KWXterplzENbeRp
7un8bewxbmwwBCdB6gY+gJSYooN3txtVyb/bAy1mfL1d/s28vTd2zw7ZoyqzjAdXiOIfqGymXON2TRIG
721Pb5+5dIxVadCyl8CZq/i+MeJULnS6T3csRUz9rNSitIsBs0eU3JmayYUeLs4Yevh2SeHjNnT19aPi
yu9K8RbTKnrnCV3RYPU2lB6/rbhtA238hVs1r179h7GCylziev1AIBSfreGO4upsWo/lu2RfmEUxQ/Vb
ApKHJ1CX/UVFDoHKvvWJvcOtKCZmSDN7ScVopSUtxtXphMnhZBPeVAcs8jdWvorH7rg24YjfMFE4GfT9
zS0C76dWcDRbiF/1GoO32Gh49drYhgiV5c0o9biBOS0OMpkl4Lw9hLAgGowhEHSgjaMDgjUB8y7QP7v4
trbiKZTCklEwrVAHOyyE4LtSqSLShgwUBUnFL66oGC7xJ9rqJI2DwCAHBxXIfMpI3Fbf1+5KU0p0W1Px
vOKikE8TDk2BufiFZBeRPonY1om3D1EhEOJ8T2yBnZW61QjdS8RLnO7O1+W5trYMuGjjLSYjLaZtiH5S
EqY6SlydAX9YgNV4bW16vBylrftX1kCP1JvY3ri1Q9MgtTR4IK03Cm5jpFO1iuSITvkNmxuXFfj+09S+
5jCQycB/f0MtjXZlWAT8vVp5bYr9fC9R7DcJprYDwel4+u1tsToJD1IYNalEJjmkbeTZhpOM3uSD34Sp
pLFvoi85zJtbR74JKwSbg8eOgiJ/oivkbuFtBLbSbPEqD7mGC3PBbXy5LLZN9CVr6SkMEZibbjxGd4pd
0zhA0fBwDdlIvB50pY7EC0J6wG4Ts4bmGbW8XZL0P3K8Gt9o997qlXIRafzooWabpH+BKC+fLJqLUxcV
Ha0ostFYfvIhWLSm2mn9+hoqRHUPRu+TXE99B/j+BVjkVkslVryShth0Cfli2hc4Poh5RXQvegRQPvOM
s+k3JJdvhe3EwL9ACdVomCp7KD2YwRbvCvCgs01Ux6FhENY7cQG6ciG/fn80H0I5UgMNmHdoZLTiur64
nP7dL7645FgV5h4ag6VEtZjwC25ZqLU3qS7L2STquZsQTIxcmDYlheGxUP/GZcWOMNzRoCAP/QKiyqPI
ouV0ylAZdK14AKMBtQLN8VenAbvn5OTdYHtXrZZOD7/sDh6enPQ0po/6ANBQ8tHc3A7F1Ya1VrS5JG0T
boJWIBRLtu+442Z8n8+6LE5VL7a7KMwJkU4Z/KP6JpdyRBM2qjX4dSsPtUARzz5R6A9TXhb/Wb5LdRI0
QjwPd6des7e6wJjoc6tNMB00LrhuA4hIvfXk4kzEwCYxz+ikax2y4LQym6tBVDt3Bfx8tYBzljoahg0G
zoRqBtcXN6y0vx+9+uFVAadQlD4py6Ii1dlkyzQSKVVoMJxvhUjiGSWcrGgxsXZARbOXgPPGJyBO8IIa
oqDRcVQf4858W9hNwvI+q/1QQzCtFQ/a69vvpFgbX8OryhpVyrpynwFu1dutY5CPjKH+str546q6AtwD
FzBDTX7pIrJYFelFCfy7mvng1A3910dwaI95DTb7QREUoiyJY7t1yw79u+mGBrg3nEkjOFyUQObTaTFV
hL+M75yL6bwEc4G4rEYW12BAohkTakI903jzIU0WzJ45vabQ7LN8q4PrCFyo4wNAyN/7yfcdcenI5SVi
2yTw8xXx4FT16tnlYn2TUKj2iE+nRt3vdDiQSG1VDYLKtCv3kZfhiD0C7HIitL1TOCjoBSG7R5iWZ9W0
GMpjQfQMQoXWCsh9gyrdb1+0e0F0NWGIfA4vBn3TPRgO3p2czHoPD77dfX2JhaGsDuaeIwm40esV+GS5
qf0GEoA3tuA47T9Yza+W4+rX+Xz9YPhg1zztPnj/vwEAAP//MDNH7bbiAgA=
`,
},
"/js/angular-strap.tpl.min.js": {
local: "web/static/js/angular-strap.tpl.min.js",
size: 7995,
modtime: 0,
compressed: `
H4sIAAAJbogA/8xYT5fbthG/51Ng+VSvZIuiZDuHaiU5rnvJe942r0l78foAkZCILETwkaC02w2/e2cA
kCIlckU6TuODRBCYGQzmN5g/9F6+/I68JDTaZoImbqoSGuPED3uWpFxGZP96MptMiUteT2dv3elf3en3
el3w6J6ESsVzz9tt/YTRyZarMFtPuPTOxdFMhTIh/xR8z1lCPspsz7cRS8lQmqkfdltXS/HlbmR38FmU
MnL74y/koxmPix0Ph8NExjAls8RnE5lsPUueekAP/N53V5ss8hWcYTh6cjIQBNpwXzk3VrvJTgaZYEPH
qh9tf0Z1J1SwRDmjSZJFw0/OQLFdLKhiH6gfMmdcClWjJzWJMzV0NIOn/ycqFpNQ7YQzvl4EfE98QdN0
aUgcouiaRwF7WDruzCERnNgsf1KPMSPvyN21JnTvrskroufmJMqE+OysFutMKcADZ5eOeXEK8b6QKdMC
+WbpBDzd8TSla8HsJty/XzqDkAdsOHJWLxTfsfRm4RkpK7IAy8hoi7So39JRXAHvauGZhdWLaJ3GN4s0
plFB5OIpYWcZKRYpTQur8IBTr65H+efR+JKdU9Cnl52RwdP/rXbWMk/snEjB0CpUyC0oekrutq8cT3e2
FDIasETbNw3l4WizbjhdwmQRvq3vZ8Q3QBS+tUY/13Etg8cKSwWrZvqNlArO9PwZ1ioi8HMDtqGZUI2n
+YDnPJ7FbHf238lLAnCJGKSDXj1c5cjlHYdtThMkMg7kIXJ3LMpIZcPKDb27Ps67oCozd3SAQwciyyO6
2I4+uAceqHBO3ryexg9gSYW3sFjXL66gjzJTc7LhDyy4ISHj2xBeZ9PpX26IZccX5EYvg0dSqKrYg3Ih
zhmYVHiEqubxXYAjMQQWV7BNHcKUCearn2jEhu4MoFzwgv/pacDBhT4CR56jE/FVBWLURYXElwLjAFLD
vTukn6afJ4JFW1iCFEI045erjOO1kP490YYw0ammvpLbrWC30vhhEdgK+yMTeFWUbmSymxOfxlxRwf/b
eLFs7Ds74++2eYKAtxn9VaPR/4UsLVb3VKJdpIxE+P+RrplInZNoLcys5fEK98I4UYhIWMyoWjpDPkYA
R4RHGkjHOqpGFtyTeHq6ADfPtb8GTY5aE/vrmDBRSP09zlDeuuqVqdzYp7trpI4TvqPJ4931HPadGEOz
YEzMKo82UgtVMqAFEU9/wTfy4gW5qvDkDZANYR0Dw0ivQeLFGw5OhNP2Bb3Q5s2jZto8uwyk2j31OK+4
IcxptCqZ9Yh6UCJooPN0ZOkVVm3M6xVULY9XDGoBNRMnIDZF1yIZ6/FqIbh9jxOWgrNQ3LEGIhwIckoy
Jxz0m9i3vOZSuIL+dExvtLILrjYUXmHCNujKWiy+5HlZP11V90IvKIlQULJlquQ0r+S338Cf7q7zKoBm
HXBGBCkUWZe0Mir9Svc09RMeq/le8mA4HV3QSztkzTXZnorhcW10U+TlVuUWUD3DXya6OQ9MU9HHczSD
p//bkrCR2bly0+SNlZtZaazczNL/r3Iz+/Wr3AxP98rN0H+LlVssY7nvV7ZZFs8+23ylkFwvYROTUIya
4ZsT4hYYzr3AC9+sGjYrPaodle6mMcmjj2UMh2ceneKuISUn4bc87oCn/+Eph7SBgcFcNKuWjss25gyQ
+r0Q/5AR+5t2irRudnSobSKzuFIFJ1sOdZoEaiiyvo8fboidw2pTzxw99ZlK7yFtyLigC/opPCr96xfK
wkOhMHye+TxGxPb8VCSfHVV+iNlnoEcsrWUvCjDu2ZyAsd/r4XCggRrlOktZg/lZkkpIceW9vJi9TooQ
I3RMIPKDkqNKxWEcVat2Uk6QsxrzQ8j8ewDqPs9P61TtCTy9Be14DP0M5J6zIxW1ae9sAqfrcxOAHMud
0ztgzxLRfRWBAbx/wGFhVCyUeHr08QLHAdiEaRxxUEPRnI8sl3ZtMjCwknfEjvQOZK5rgEr5gQfDdpK6
piuxMzX81IkRDb1FGyptu3mlsrClvNZlUgatqtX19QRq3en4IgtYWZXTtXsStbpBBCmufxN+5PKOw25N
eGXDMqxA/LClPrTWN3ZIMyXLNrvoUP687lknoffGEO5sTKYnzRzRN+3fMWntoItvbV+r2byo4mm/eUnF
L2gd2xrDlsM19XU9CpqW7g80wY8Rz3ZzlgY7Oo1dvakrVrs3dpbjrLmz8882ePirh3GOMWjHgx91SHin
L8nPLKYJVTLR4Yfo+FOIM1J6GN5GetRuZqzwR4Ix6wDGrABj1gTGrDcYsxYwZhfBKIyj66Fb53hNG1db
7WuKrzqSLrmCZHpLXpJOzv+cXa+0pLxTyZ8eOJQFtyzh0EZFw2c/Yby/Pa+2Op3tFZl91fP9Mcf76fa5
rysKu6s/L4+0ppG/Q7r8RhJJax55TkdrZGPd/p+wUHWKaahXTVIweeWoUzdVUn9xQ/WVGomyFjVT+pbl
3b55XegaWvuF/hW9lNgo9MLFsHj22VYl2mWwU0Pnfk7n1j8KNBDwKLLfgk4+zpx09PnwAOvyMA6kn+3Q
Xjf/CwAA///g0UD8Ox8AAA==
`,
},
"/js/angular.d.ts": {
local: "web/static/js/angular.d.ts",
size: 34935,
modtime: 0,
compressed: `
H4sIAAAJbogA/9Q9/XPcto4/x3+Fpi8z3fT81pfO9e6N08azsZ2Le3Xs2k7aTibToSXurmKtqIqUN/ty
+d8P4IdEUtR+eeW55/cRWyRBEAQBEADJg4PoZlHQKKHjNE9FynIejVkZjfJJlZEy+vk6ej78/t/2oN5l
yT7RWBxGUyGKw4MDoqp84kNWTrDCiQXjdnEYnaR0wqL3KcL5UTeapGJa3Q5jNjtIsPgeS196rVUX3K1+
y8qUL0h+x+4PdF2aLRD5ZG8PABxEP5Z0TEuaxzQqiJj+9M2nvypaLobJUPBvooOXe3sJjaE7Gt0DRhr9
wyifDM/0cK8FEWn8AsFF11VRsFJIahQkzTPKOZCpoHkCXSyiNEdqALp7aS5oOSbQ7esql5+iL3sR/DxV
dQ65KNN88uHji72vEtNd/iCq+SSasaTKaDTQoxp+4s923pOhnu4Lev2yJ8cJKIyyLOK0vE+R+CVMa0JL
HtHPAsgViWnKo5pKsklDs7Nr1exSt9K0k/SbUGA3ki9eyE9fTW+7G5LB3p5+85FTalg9YTEfOvx+QIq0
F2wswjhYWWS5TfNkEDOo+FmRZz8a54c18+1Hw+GQlBMuyz58fNYUvWhgMCaALUkxoBmd0RwAKS7d19PL
j5rmpBJseHYmmZmVer6Wwvr5V1x5u4F1qn7ZDbATFldbQotZsRhwVpUx1VRPKBdpTpCyCswzi1vxp+72
bFRN8DeaKMoYQVNX/KsiGR/ck6yizzV0+cf3Bi6MJaPEmkG1tgYWDrodzL7C0mIAByuQaKckng7Y7Sfd
BERpSWDMh5FCQX++owvVffTTS/VFc114tOOSzX7mLB984oiM4ie/EizxXKRiMQAODYNJ9QQMNp6hlI/K
kiysMYQIl/ITIujqSqhjaLKynmbPlfXMGlxZ8W01u6XlymoXt0iFldWu5SysrPYuT9Yab8bmtIwJpwOY
XmuO1S9NvYPvvkNmgc9VLKIF8KNRuBEpiiyNJcfuPXnCxuM0TkkWoYyFhVKLP9S7AGGcTioEXTfXXDGE
tiChD5eLaGOkDM9lK2jz3UGNo4I0qP82eOdkRiM2VlhrZQe/R3OSi0iwKC4pMFBkQcIfbFUL0U6YGnsJ
25gTPAKLwYNWgkRIS8n8xnpwgSrSGKaqV9KZGmgzETljxaClEO5ZmjR1BJPLtpEHRUmFWBzV8x+YYLCO
1mKEe7ADpGz64qA/rrKsXVnOCvmEgiiXq8ArSvOuooSJcEHMQOBYU9OUfu3bqtA8p/9aaU74vNoHVpZ1
oXqxpoXk6UyuyoHDys331wSl7qIxJ0L81gUFDGgQL6M8Z4IkNDEgGpZcAondqo2HEnmhulrcSGFBQTWm
qBQnxiKVwuIdp8oQnVExZQku5JJOoCKYnHNW3kXzaRpPo5xSWJBQeAuGLNCKlTOa4ALVgiBjJAHQANBe
sqrvgV6U+XIS/T9BdvMZkQIdhKA3tY7G6G60ehbRuihZloH2c3toCo6NTkFBsIzInbC8YTsAl43cQFPD
iJaNIwHJDYjdU6/r+vtaK6kLyubz1kBaPQdjhZrXp+ZNjXfT5TL8w5A2x97AWQP3NBOt+VYfN8M8BGcL
xBWY1XibDXOY6GZjvDbrd4DbivE7YJnPF3psyjA3mC4FtJocZZUPpCuIZOk/leZZa9pUu01nSVM5TPu1
aR6GshXJDajVhJKCdyNhrFp0Q250lPT3gU4RKeWNMRk0pIyt2piqvftrBHR0WwmN2lrWVT4ZPo3ZrEgz
OqwF4rAFabe42t6cuidtcz0BtJVnjIMiB8XPSbnQypzcgvaGX0mM36EajXgM05FEpAYzhG37t9CUCTSy
F+hsmICerWHf0phUXG1dpuRewsO/EQL/8O2YsW8/AoJgU5AEtyby+xA+RwA+OgOTOv9WRHc5m8tSgCek
+UEWLvp8yqosAS4gWbZA5LN0lgqqjRZRlbnmCwk3FXr/xFVrkAsw1lm9jwNbIb5jMKAxbDWl4/evg+f/
9f2/P//HD/9x8Pw/f4D/qO4/2Mz4UfsQbP4dJYmi3PH1dRRnBOgo2T/iBY3TcQoY3i5kBVn4HvagBSkB
KI4ScIcSG5z25Qyjs3FjmvIIHaKwwYAxoJ+T5lDWFEfzNMuQJIDkZEJLmtgQcYdbdx+RJJHe72Hj/oRP
x1g2MAha+yy1g7PBXdEZ0G37IaP7pp9B40htqM2gS8SZZNaY5Re6wbCvqYhOLs4Nqs0CUUO3QHMqBtKl
FZSVbcgXtyiKgaIwOrmQC5YRYa/BoV39BkbFVBMgpokEGGKk+T27k8Y5CINEuTSQDjn9LKKnSTqhXLjM
kcECwFpKaEnSDt1OUq6ob2DP4Q+KBd4sOsgrhoinICFxr1FTR0P1raf8UHmEjg6RTD+9VMRqHMrOioPN
e4HCIjwfCJnrlQViq5yhfgeM8DuOzIhCmrjrBFokKErQlYB7GnZXFYpbPSDRLcgOJTZFBbwtAVvLSaCn
Qim9vjXUa8DsuN40bKSlauV0iPu5YRDSbvG1tJTbmx2LKUq5T6UBpyCwbykWoQJgnTQJFQDLdhXRstT2
0QtXFCq0BnovpgJ3bydgutCsQbnl3DISZcvWIDROcHSDYNGlJopb2h9btRDekrNyBWfYBW+3iFv81erQ
ZrESY6tlmNLvkV0wbiD5RkrDU2SU/7EFesrfO1zVgoRxZh0BUroKzA00Re5TOn8vBSPJE/Se0Ez9qc0x
24JhIL5cdbYoAASIKOmZQQDSMAO5PYMetNUFjWauLnpv+hwE9FCzgkwt38J52mDZKgKlDsKcK8OeZpfy
T2OWyxooWgjac3Wl1+aLUy+4GB9DFOg15DoszVAspnGJ58eK/eb1INeGsOu1gBYLWvKbbVxKxoRsNrQb
7xYzOySPndgrE2M2UgR6Ull+pp+LrmifXWMgdzCHGrqJKT5rMe9tyUgSE+67GVtBDBMgP72H5WyzIJhS
JQtJbGVmBQoo7Fg27G6JTCELTH0o0JphBX4i2b4UHdouSWeFMo6IgOoxq3IhY0CpsDACrkS6wb5axU9q
dzwgdWTt3V16t5qFqd4B5hHGNOKLPA4MLDAnwdqdXNS230/omFSZkCbnmGQghPXmx8IVxxZPaXwnPfCi
BG0wWTQ45HQ+SLm0nJ1omOrd5tpWwCNDb31OMaZO73USgMVALQZrRhIwrp/OiYinA/n/pwGmMJ0dNZ+U
k+cUEwtSL5bXTgfZAP4gtxUS9JMl9p8d7LYTbLp4ua/Rr9Ffj9Tw0DtGc0llEKycpu3wWkKbZZ2votIO
kHEsG7WWWgsQLQgTALalwJs0SWCPPKNY1Lgynz7V6/pVmmOMjPuS9GkxJZwuNSns9WxpSwHLmip13SBq
CuOqxBF0lIYdrEUpJYiWZ6FZSlTRpapIbWPK2aDfkzSTvkWWZ4tIVkYfAhHRnJZU6cG/C2v7zQUr0BFM
JibNye28PyvpN5gXNtc5PptZS3PZtG8jyUFQp2NxjXb0pT/CvCrZHGxgjzI3FycXUQV9K61NE1hXsCOh
0p+CGhBYEp2vxssXqRwxmR/RN6VcjPukzU06o6wSW3GNUG37JoaLor0PQZ+hncYJ+xWCykFJtX3t5huh
Re0aI7BAZymnP4KoemlJGpLHNBsUqtCr5ud29TclMqMLTLmt5iTVjfueFA/JlbPSTIq0dP/lJ+m1DFVv
NUUqyr1NGxMu7t2naQ/Onlpb27aMn7a6f+1gXUv8JQnsJmdnWUqCG1f2YPU977+wmGR0q3nPZNO+585B
0KIsWnvGTLItnJspxRBnSWVctNGGdp1j3O+ZfNJveZQ+/0eOc0LV0Rf6meL+sDEV3747f3V69efri6vz
0c31oUFK5ekqj9IJ5XGZFjCfzdI+Gd2c3pydn7YaYvoxaoHupkVWlSQ7JgJt52rWJGHblmGbQZfhZdHu
5PT47Hz0y5/Xp5dtW/O/ry7eXYaLLkc3N6dXb30KXEqHWt50ZTsQj99dXZ2+Pf7jz+s/zg83QL8F1MJ/
luZneSDdE76/LkkcKCCfwwUF42AyBwxuxq+rcft7TifB+vA9WH9ynf6TtrvNAt+7yNHFLBY9zi/e3rzx
ky/w5/rNxdVNZ+nJ6I/ORh1lo/PL8+tQwYwmKfKpTwA+ZaVof8bsXxxYuyRj+SRcoroIl8luljVDCnY0
axf1KW4nW8raSf+CdtKWsgm9rSZyuU+OSZY1lNNhgXZBmo9Z6DuMIPR5Tsrc/16TP/pNn0vUubCEA7nQ
ASCohbna5YAdBdoW9tLocYxwX1/WWQc64wBjXiD3VWrsMDB+RME2D5ZkzffHIjLAsRWTyKDPFk0eywyz
R2aTOegLPjtWqVpJ42nqkpOX9iBMbhXwm7akfwMWQ//OwLemQ3V0KMg2223o2tZ4UuXzkhS6cQCyV74S
anhgbRLYZHMPAEprjLsHqmyb52ysEz9SlTGm0zGTffQZqJM/WDRheY6ZXhiyTCKeYrJK22NuA04YVRCl
F11WrlOKhtEvFCOhsBBjDKIqDPTBHi7dg/FC5hbh32CpOWHV+ZTkynlvUISlvQ/QdUJcg7iCC3yUpXEq
skUTZ4W66ST3aPXY8T5U5Ei2rc3smuYbt/LW9orWkwrqHiT0/k/527A+keBjsVsSeTaPRSr7dMotf1dm
g8AJoynh087vOZ2/gX9tyeL1YTVgKjbYsgaJCHYgv0MHYKuu1wGeJ0dALTO0ZILFLDi6khYZkGawFDCn
pIynrfis/lyvR35Oijo1eBWwupWV9W0+vXeSjDshVeEJw8/wv5UkC5vENluvswdHNgCjfZx+7mISXVrI
f0JYuYJaNhOz7AfMKHBkvy29gmkm0tPeZFxi8qwm7W3lZP95EUpoC5IQDBswgXRv+/oI0IzcAeAZgx0v
pzl38v6M/FaJdQRE6WSSWUK2GQVRaUG2igoPvj8paQi2lZQ0G/2+5ZOHZM1/5nufvu3TzzGVkfc3JE+y
Lb111APSN8E6kHbtP13lMJIZXfuRzFs/CmYG9EfeK8aEPsu9FWXLpn3fRG2jWjOiul6gTzb8dSvq/NU3
TX4NmAxZ7VjnnmddJfRYXz58tJzybsMvHxpn40ffkf/VhuPVhApfXzoxWlr+ePNSqvIT/KOkCfxt63p5
pL+khNtHug14XAVWbcz2RnDanL2xqxqogd1SXcOOWEtQV5RXmXg54JU8dYLbYUyoPowMMd6bntAVefYG
Jr2GptvuK8+AaYoJEmo03j0SsGFIxwu7mtSQTi1nPBr+i4eh/K+Frq6+BpJ1ze0RbYyXGBM8GlxZfiXZ
EpMKWh0HmWA5JTYC3x9oXauDGAYi7C/xVFMDU3+wZs6ciejAq70CraXvhIo4y+6pOWwhl7ObEBeWDm4d
Nf9q0tWJDb9GO9LoyYpdy2h5vVI8ZeV1jBnfW2kPYgHoW5EEkLWtlZA10tF6k11KknLMyxlVgqnGeGnL
I1k+xySemqPdW01PbAHoe3oCyFpkRG8LFcohNWbaeaXyVXHzi84kdRQST6CRgsSpWOjUsGGEeVxQwqrJ
1NmLoQsLG1y8/eUPDUw5sBJ5uC2cVCpYQjDNNujamqWTqUDhgkcF0Nc2rjJ5bolzFqd4uQxneF8MnjQw
6JuDU5LYOoPQPn82kAVniZUDWY8bpMWXery1/yFC40XS0z4TJbl8O1hnDjB7wOfyGgvYvFI81bYsPosB
hJYjA3OXfJxa/YUXpFXFDh/rXpov8msSvpKGO9E6pwjP5MBAJrCnhz5VphVy2L7efEvmITDY/O8z2AHh
JVsLTUwPToukdflXS3pXoSOMHcpAUs2q7VNVHYzyavg6B6uMsqydMx/Msu9RSCln+HbySbXdqtFjRUfc
8Tn7Y/+CPgG8xuOsSnDiz27qv5ocpRn5fFmmrFTJxYqfcL3cYGYDiJdf0hwT3tt5pIFb9x6lN3NfYE+d
dcZWNlPR29zq4nXkisV3Tr6mPh6vTvWWdDgcBvquf3Ocua1eOkadsZyOhACZ6F1VqhFS8ZopNJHYKDUq
00StljlUwbAKEVVJLZ2BVRLNN0fNnMr07qM6vzsUclGHf2MGZjEvWJ7Uyu6borrN0hgn9XX+jb5OQOnc
+jIHf5AdnGAvKSfjfN8dHGIaoNOz9iWO6wziacPReDlrEpGMq6FZBfVhcYxtKR0C9t/ds/bQWgvCnb6z
cXNVRKQuV9BRPnlOXJ27t8YazSou5AFHHs1BNQ/XI9GGFGqQgzZ48Ei5Stv4KWXJ0VxK9MnLFspDj+Ee
PG27lehSU5mzrVsqq63O9lrtHk9leQN1mXGUKVtazmHihEMwaIyXi8h9qgxQmAi2NA3NATNrqpdfABaO
fwdav3WPaHU0CqkLn7gPSP9cfZuZb4QFwTR3US+/YOgxrDN0A23F7Vijbz61kPM4VEQZJSABZ0xds4cC
uiqzWiwa+WSrYn3JH8iVK/pXBUbwsfwbBY3tDHPTvKUpbsU89yOncePr7QaRgLEEi+WBUKaUJA8Egbf7
Fg+EUWCo3QEBWyOi8zM2h1btEJg+SsX9CXYtt9esVNlxE9nhq3c32nRrDDpUqsp8waM4NgvhuoVmGrxJ
MAuaE/DfT8iMmDSDZhk0G5oK19JHUFDlHlA+BbTYUJ/XB72UlMDTrUwZAKXqdbj5Ov3bO04mKn/H+CQw
54ao26d5K0plU89O35VrLZgWEMqxKMlMi2h3Bn7//Xck+ZRwZTewubxnCoRfJW1nJHM5JQVaNuaOqjqN
CPCUxBhXjg2Lq4OW7e6k6+HIUyvzVEyPSyrvs1ZqJJgIoDPSYwxygmDJRFrg3V54Z4Q8opVJk7vOc6Qz
5BvoqGFIYGa/b2k84h0OmshLytEW5S3k9WEn/RnxVFup6H+Nh7hDE1oLxzjBXUf2QC2+m32p3SveHI3R
1D2MBuo3Wxlb2e37UaeEXeZ5DSA2KicubpqUN1ayi8TxqO10aVhhObZW9MGIGF9urMQXkazNiWCATgeM
BnEdd+iYCF+22eFFGUZ6GIhVYaxSs1sYuJqPlbGtNUE8OOa2dk/rxQ13gXYnm6zvpehUX6aGBI7SiJWu
6sEfM4yzrkr92pCvgFYwwq1NSd3eNPyDVUb0q4vRzGHYytyvbN4sUW4Vkzq669F58+mO0rVJUa1dasWl
lYJZsY3TpUN9DVzVuh85RhHaXEfaKoobzm32UI7227dUhBHgnRrvkXYZZ809dtufJlXtt274WJvr9lht
Hauymc3M4nblDbmnTaK4e/S0gWXdpWvpBWDFxew2nH8KCrIU4eK2sAp21JW0vgG0jfy0SzD2i3XqTBNQ
CnS5Jp2awvWB9ngOXvtAZfRru9PwNoS+mT2EbjPVTgiv3wRA6e3cOv3vUe7m8tG0loS6tavHi8uOT7ei
DY93T5Un9nVlNV4gBp48mVBxU4JIpMkAt1mWnCSLV1QXOU4/u80x54Eb4ewab8QsW1Hl51UwwOqT92/g
mYblNbtqyLNb3gCDR6mCJ4WcjLAa3Ijj6B8ORVLo4WB+3gUuNqUfDu2BUATO6Yh70xaaXl2zk9d0eQej
6dJVXKardRWn/FRd8uyccnjSq4DZ7MSSJWEeyzCzcFzHGtHXZLfPAD6GwQy4nshr4bc0mIGspv0jkNVD
1SLi5hLdtFx3wZn6suRi3H0n6CNM1dZLoAPAbnENz9lmYbFaKr3KYBOKF8UNbs1vocCV1+q3Kb79iq3m
5rfHDXedmCSMzabISyn6W+KDwfjTyuOZXqPdDc6f3nqUXywfpxzB0WH9BX8GZrNw2vXepft2nanePIlx
aL+P4VWucx6CGUFO3UbVNgibWKvvAW9KRs0re00xJmD4w3RzIpyyVD5yFa9LAVN9LQo0mCrj4mHk8RLG
yYwGRl/4KVatA6lHgauc9UMwPqVLzBRMYxHox+QGuTJbs0fXd5AA7aJyhpn5IaycnLJHOO5tnvGjzmEw
eVxH+t3S5jFLU2fffNAZTpgy+kmd5FKJvvs1cMNV0hlXPxpCMh1W48C4d7AnHE6Girh2nG/dxzLp4xxj
C76J651kaz1+POA0oyrBwc6nsB+l7c5CaqU3Lq9t3kn68nUtqPLx2Rq0vjN6JXBVsLyuewfd8rpEYUHq
W6s7a67KjeqeqtZxQ9uDjTdRHuq7RfejKZvLBzykK/vIqmeu6XYO2ySt6V06BNmintNVsy9ry0dOl9A8
oB/8e+JI8LXi1uF7XH2Sxv5VtWk+pSW+kHRCBFnyIo2Pv9tODuRL9MFqr19Bkrn4yxtDoyN/RHt9m7ij
dzcXwYfq++gPNun4er/uDt+nc9L/7fOQvn2KP97T89aq2CGy9qrxHrW2i1Ybl0hZjFIoEL2h6fjmHXQ9
6pEcE9IEHYzdJ/vaF4c5tVc+3hduD1O1dIniz5Rwv44xFKKAZSbwEI7cNG6Rb6jA4DWgq0fU1dC/ddTR
ccu775dP9Xp5AJvqpLrH4FIXWY9Jw28cpKK2wVS2lMq9xOuRtM1uP3vgA/QOgdWXI+l38GCexLRO4bLa
rfOybotV1mnkvYqAPwmNmXztv5VPqr8vSUVdq/2ZZPqufTz+bP3ILD7aFLwidTnklctwJdwV76AGITwA
7ppPv64EH36WNN4W3MoHR5dC+GosjK97/xcAAP//3BuIe3eIAAA=
`,
},
"/js/angular.min.js": {
local: "web/static/js/angular.min.js",
size: 107449,
modtime: 0,
compressed: `
H4sIAAAJbogA/7S9eX/btpY3/r9ehc3x45IVLNtp5869pBk9tuPsjtPYSdrKan/gouVqtRYvsfTef+d7
sBCU5NzemWeafiwSBAEQODg4+9n/sbJ1PGzP+3Ly9nLr9rD2rPbsPytbfhpsPTs4PNijPz9vvRqN2v1c
bL0ZprWtzmw2Dvf3pXrpn9PaaNKubL3vpvlwmodb52+uKj/uV/zWfJjOuqOh/1X8KmbB4w/zab41nU26
6eyHyDzceuEnweMkn80nwy37RvB4KydbMpaT9nyQD2fTxkFTpELGXsOr+kk9qXoh/fOCqqx6TTOgfDIZ
Taa10rj21ffsm9f29WtRazTx0/gwSo9sJ7V+PmzPOlFarQbUd9U/jOO07tXplV16xxtTI+neIV3FXjUf
pqMs//zpzeloMB4N6X3fM+P34nj2MM5Hra3iA9Jm3b2pzUaXNBXDth/UJvm4L9Pc39+6fmxcT68vmz/u
7AsaZujNh1ne6g7z7IkmnQqhN+UGve2NNd9eXnyoqRrd1oPvPgvC0l2kV+MM0+nLYLm0i/VRYrW6LX84
7/fjOFksXqEkUG9sH0YVtW6JmUrdFE0klQ1pwq5oaLu7sr59EB7Tm4vFG/57QBXkYuEN54Mkn9DH2m/Y
3T04oj9y73CrO9xKirFM/ERIkSpQySIaVBLQn48YDxY34/qBN56MZiO0Rq1mi4XvqaGpO28oB/pBUuvI
6cXd8ONkNM4ns4fd3e3VIj8LaKyylsp+309F0siaIguivE+ATV2rT+E5UiOID6LsyM5FBrB66t2kRm+c
ybSzu2svt+N4Etg7Hx+r6juft2GINFmrvehlcGbv9wQrqVarQXtL7Ycn2ky5zfF82qFL05isTUeTmR8U
bV6ltCQVXhO0xusSc0cip6nIjzIzFfnKVDTyJo2T/trWs6LZnWQTiuBuEnq9BKCdxC86T+KB1D0KGSUR
1d/biySVNpJmLe3IySlB5PHMPwgAPv/5XwSDGpS3uE7sHXuC2vjnqDv0aT+i1j8OUEs/PvDUgpReUvu6
1pqMBqe6D19WDwO3pSVdz4fTTrdFaOPAs5/tVrEfJTGvMniU9aS2s0Nr03mXP8QyzPJ+Psu3nMLinbfF
8jrPo0mx8UUxldQ0wVqyu0uPxcoME0aI5TJYBpEexgZg+uws0FhOpvkbwoYECocHzlck+it0vbf+ML/b
8t/6DtJfike7W8NkGQRYXNvAS9Swd79Ip1NnLIncfKDYmkXVh6JmCdEa3OO0+m1j1e1NVa+c/oEmtzGx
3ij5Z57ONjd+7DSucfjGel1nI6xjSqfizJkDr6G63nohZ3kT9b/pnZc4c/vRecE5xTa0/c9kQ9uf8vbZ
/Xi19Yp96VVpsYDislHKYIjr/iiVqIZr2SeMg4tpPiMoyie3su8AWlq0s+1v0/mz7atz5QPhceBwgp8x
tzObTRiVdoeEtIsWvqSlY4NwX4SDxAIKXYp28JgpbFfgKC7GLljHT5+kAmzG4tRdfn/RMmjEFtAmiwxe
SgkZpsW5AHKD3pU4I3H+6ldT3dXeYdHVpe5KtaI7jg6O4pSnbNwnGoxGe1gg6eLd11J9OZ0HGCovCc0Y
XtzJaZaPpw9DbmbnTs7STjDrTEZ3W1fS99Lx3VQhP/2VOKxLz7v0OI3TxYKms5LhNKULqom9oEabY7Q0
j9zM3iHtnNx8KPB+lKoJp+dm6oOlPlIDM2+t2KBzmsBWMYEtmsA8xvc1Wk2BPcdfKa64gM4u37SOW6E7
yIFezCWjcR5omzop8OUbGke96DUsIcgEYKSRsKSVW6olbqlT9L85IiqIc+BaSQC3XBr6gNB4gMmoS25W
4MymFkPe6lQIZIodTiDYzmdX3UHuB0HIm7VOL6sNSg+no/kkzUXi0p8DrLe/3/jjeh+UZ0DENqamL6e0
BQl6Qc6Z6yDEmtIH6HEQzsY4gqiyDnGdYmPwOj5K0HgEGd/ZCJhH3gb2y68MCDB1wk1Qp0mw3Us0pqFl
IEpuB9gn5WOdj3RCuuWiQ6rl2/aLLUKbwMHFzmaOC3pg+yCyVC/IXn0lC8oXL6hDFGep8576UINIBVOq
qUvfFmdDGtipoottAF+pA3rPTFYQ282gCB5FbKZMZeJlfAioP0l/nFbMsBRkoZuZQ8Hj5CCA704/yA8l
SNrdVWXSKQO6tXc0GRXnYagGzPC3u0s/9ku2XNDDRxR3PIdP4SOiu0GEuo+kfaSR2SuMHiyFO29p/LiM
HIqZOiHAoDXKXFjZ/sjTpWf+iclL6TamubOtSZ7qdBMNvqEPtAaSgXt7al1MSQGSJ4mL9J+t8av1E31M
FaTdsyDEwaaa+siTImm805kcpoA6hQ7qMkxNG+uU0lo3sibH4/4D9lstHQ3pzPbXe64cBIR3nKrBMvy3
2raP0IqhJIrJ+Jq6kyGjDQST2fhJMfd12oAhQwddeTtf33x4cfHVCwmifsUu5sIXF6efz88+XHGxvxnS
GHNT3cvTi49nBdWeFuMbSpfK3UxW1mfhCjeeiK/EyNS9rS0vBGpxCJbUIXmYUlScPJPZdBe6ZDhTWRvp
t3pCcBvS1BwAR5lZJxR3TqxGlRg0eu57LY+RGzEk6rclCUfo6+HIXOjfBsg9whwhvXpo0b9LrvJwkviW
fmppfzQkvBDNJg+PSS0fjGmbBMuUTx6arqVaz1vfO8q6t8+9APCQDzO82pkN+vpN3clPTCodNK1EoX5O
jCkBsz7J/vCPGn88b1afB3SYHTYLAcsfR37j+u56r1kN9l1Gp6Boj7zqOSDOjC2zc48uHEDMeF2cQWX5
mkAocb+weDVPC+ZMnZ9Eg/qYU/puEHHEE+56gUNo0DQy5CXFp1xX99vC+z/PDop3YnqHiK/UT/kE/8Z4
iNb4GxUcNoM6P6GLcPtAmMNT0uFdf6OwUR1/DR0W4iZu4K9ImuoucSlg56A/dYQJlXWKmuaQSZdyMZED
qq9T6Wdi+yCo+tsQAyV1zwshYTvFVtoGPlkCF/zluoWAwiIXxVPvQqLmFcPuu4IF00Ixw//n2d/2212B
15zCn15wYVwqfHbChVWXaz8tYYKtDfLCxG3i5wNu4v+WOzvmwrDc2c9Y+Z1y2SlXFOVCahJYBUASlgf3
q0ajBZphKcDubkF9a/4oaYoczE/c8IbtkHYldTJs76mL+z1zWfEyOZPmtil68f71dNhuhLTZqMQPr6c/
8t7L/qTNF9WD+vV0nwClXRJDtBsSB2yU+r+Cljjr5zgKTh7eZDjSIyL+7OfRFwnv+pqmJkpqN/N88nBJ
lHg6G02O+30CewK2tWLfq3lVGdChJJ5+XFWtPl2pwZWaXIXBjUDS/QiQBLnaDkncq+X3tN+9LXqJkKCc
TsGpVumexl3385j4iZiIjWdNtf2L/T3lDU4rGoDrYIa2m8xn+bS0h7bz3d12g3hgarVJn60aTGp0ds1z
oDEaIASuPi1inXgLogscMGiVTlPnnFZYO9Is7T/54/3AVATupd33a51WXfPxXsjoPiq4wmRG59s484ha
sB91tE/bqT+L3A99jrI2yoJoaTiEQjrW8HaIp7/tZrlXllipTyRabjIaGUjxCJMvibR3hGtEG4A3bQPA
icvsDm9HvRyt4rXLlCg2muNyG95OSnu02+cn5utxLYddOmFKAxEJ8LfIMaAdRcO401jDrvDdVjIaBU0U
dhgP1ZIQhLr3//jw6s8XZy/PPv15cnFxdXn16fjj9j5W4SvRjFmNFn/mf+W1tuR0SkejKorVj53ZDCqE
6Au2zJTW6IQ+kVZEjmMXfp7AyTgBaZzugTfQZCiheEjq//SsIND2+Fu6gvZVDT8jShNaF5D+70d3+eRU
EvGCCSjUQImRy2D7JI50QU7yG0+gyzrBEv3Q/bw7IZJqkyjyqzTtENn2RrGqCQGsoXn26PyLqDMIvKge
kTWzLWnlhGKrTffQFW0U2dUTEL40iXOsJc82jedC1QtNrWDTuF4UfKVX5haYVHW+N5EZKyUg2XF46dSd
HyumThgn6vO/5hUyJgLJmFbWMomEwA+i9lErahN/mMWy0aZjneeGUEYS4Pg3/AJNHGanTnxHLsoU5pl7
0AMLRCtzGxlBlhngLbadwhqE26NsBCFAbZjfzy67SZ/I30h9TzLJZc9IgWhv3HVo//kslrbTeQsKrNBg
OFTUC3eLEV5GAW98Gp7RBxLzb6+J7MKxsbMz6A7PJpO4uFwsXhRwPRhl837OL6rLeEVDmYC3XJU150qE
uHmlc73SqbPQnmocqwd+d4WZzBmEG3kzZs7Ajo5KMDI8cEZVyMFB2gEvrYvC0wbAFjPtNf0Gqlmmq0BI
wyXkb9stPV4CzOGIxkknfW4XtCkgQBX9OCmhOE8hWVqIYfz4p7r5ZZ7P8zAVf07mw5P+KO1Nw0zonTwN
WwIzEeZCo/pJiBYt3vdMMYhiiU4eViroUno+zSe33TRfea5L6TmfGitPuQxwM2IWebby2BTTpT5WqK46
C2hCubI+GT6acQrCUu3udKaG3O3P9Cepy83VqJvZZNTv66rF7ebqGc0crehtrmvzieVUtc9V061uO+wL
mv3QPUUtuWeWfdbpTpfLqL272/fbDjDQ4b/kP4VQf4c34FsIARNztoStlDobP4SvpaA9Thxc+FbQKhMj
GR5TkTpiw1uhlZrhRBi4CdupGI5G4/ClSLr03kkiZqO3U5rgIZE0k9GAr9NU0PcNZ93ZQ/iLFN3pZ8Nh
hw9090Jff6NrJVYKj+nypR5z+JFuFL4Or+jyAytRwm5C1/r4Dz9TD9PjyUQ+hG/EbT6Z4j2ZoXFa4XAm
RR9HWEpHWHgu5sSmqus3hJ2Jo0okYPsxHc2hvQgPlsKglvAFXabTcfirJOzzm4wJg31VfO1v2F7t9yNq
gJarYBpL5YJIt5rZCbTkfV2cZMFSVaQqRfWmeJp0sq087uxMCXZn3W/550k3TDPo+dxOLCVU6aZBzcKU
/yjDjOZkOJ7Pwn+mYkaLTQe1xDUt7SDMMzFNJ93xLGzRFZPPYZuuZg/9POxkYjTm9ehmYtg+wXL/01y9
JnY/7Jm7q3xAtAXNex8lpyCgw4G9PLvNCTzs7UWWhSN1N5K9cMyXxa66wf1LjG6Cq9f0ieEUV29a4Yx/
h2l/ToVzddMlQMXVh9EQQ5EJDf0OBR/784ns05yF97j9lI9zOQsfcH3ZGd2F3/iKP/WYL++6tKDhSXH9
tUMDPy3uCW7lvD8LX6DogudmGp7h5moih1M1rJe4Pycush++wuV7QgXha/7IDh1sBIIWpWZhL+WRuXdf
GPW9pTV2F7L47HflJy8T966fBlGlBDlymHZGk8sUsxu+z4RBguE5XSd0aBDSDT/QdUobPX+p8fYFCoo1
+Ui3hocIf6Gb/D7N+ftfy2GGGp+oUGPQQSromKGr8Yhh4jLT94TAwyu6YUOgz/rihHYiENAXujcqxvAr
37TDX+mXZWjhb3RleYHwd7q7CXfo75QOEZnz7wuC3zY6THA/7LZaNJiUrmcaOk/xhWGGku4gH9GeyOn6
joCGoKFFlzuT45dhGxcSEsVTjSjCTs5cgEPVlDSllrLu5mWewz3Z8zpxBqPPQESKrg6xjubNf+bCOx99
2zl02f9XSaELLMRShp7KWZ1Yb+AsqKmpp0fNsMIlTTEgHrMj+mIoxuJGTJmCy5ROZJvINZCgUW6UOnzb
ifOa4scCohYOiC7omOf9o2HUJ5oU1cbEdXYa/WYgBvVxjdB3u51PNBwQLsqI/ZmM6JAPB/H2QNxQQ+PY
n8bjWkrUYjbJibgJTLs3R+PoBopBdcKdSX/auGkWtHlLS5zxSY7QeakUjWey1hpC9tGKW7WdEY2kO5T9
xaJFH2Zv41Zk6sW5o6TVNlKJK3G/LCj2Y8OVSNa88PTxMMr1uQ1V1zvytl1xtqbJXicgygi5FpwQ1IDo
f6nftTYgRAn/qsg2pX/q5UowIYMgiYmCTwl5z3J9BioxYbNQimZE7Yuc2sh0xRd6y76cyDa/AR5b6Xzf
JIpPpZYfM5DfLMg9xQr52Uo/RKTcgu/PY79vB7RYNDyiX7wmy25LHCNVzCUTvrms/ZkppBllxNUPCVCu
zt/HSn68+x+HfzuIjvZZllzNqZ1qITka0I442jl8frS/8+w5caV54xkxJvR4MLrNzThb3cl0xjeKp5Jx
DnZH7u1FxD5lrBDlx8SAHXCNnJU9VPKBMLS1JZRHeVStykBzNm4V4oeCCDNU9BWBx7+f4cyi6Yk9T2lB
i5d59q6oyge2KgrAxZTfiBJ3Nug2TpdvEwXmxErd+r8+uYRW6I7KgeravFpxrUXeJSUkxbJ9HtC2a/Dz
llHZe9SNFBSqiUoYlM0sKHFPoQSWtGfxJmbHUaukJeMFiLadTTBqtWgHw0ZBoa8RmG0vv8WOpkJ122E8
4mHrPUARNPHzFVunHdSDQVmklfo5K/VZ/KZZ7C1XLE+kFGzj6v6OEjrkGLOw79JNeCl9XOAjoQpzLVHe
l9R6SW3Y/umnfxBDJaGdjjLooOrGuABFLEqitkKCA/UtVCWrqa+sGeQICa566j8uhYMzBaYwsMPjJoXu
NZ65AxvJsolMpTQ2QvSaz/9G3x5kzB2rVrK4Wh3muloTPLbIINBNS0Zy9GUoLfo7T8r9qeXC13owHEQ3
hIYh6PxGUy7aMXHJ21fgWajz9mLh1Ke+wdnT4PLA7ZoKWgw47aA8iuitn8HIrDTAYmgfkpIMn/Xdx0YQ
W987PGLBrl8u9z2W83oBS3RZ1FtIOxvXw+tZE5JdFBvjIBYPc83Q1fwOjchNG0TZLthS7ymYLFc1oxF0
2vz3R1splfNwoU1Fdf6SoCTMGyVW2LU2dAPw/7OZi77z/TLmsUV7h2z9sT7HUKVVY3XNcqCn5gvyfQef
OV8VKDGWNTzbJtA05hjaDqGOvSpXbF2ka+uSaOYb1ihOP6OyoeQY3Xo7NFlsIO0wNJgi965oYmy31D/K
hteMfA29rU9hc8ApW6cQuwK2soUJb+WAtqEdeUYnmjYyITriVkm4E20qAfOGwoANnRGRTX0A1S8Wh6t2
4EmtM5rOnG8fs0zBdE0nhkhLpwWdFOnKSZHyOcpEZ+koDZLSke4+c2bqpqQBuaFjp0xxNK2AnvZc2iiM
DZu7u47af5RvVKSkINPp9J4wltZMHmHM1SJXggd1CXpkbi0mdAC1xXQ2GkMiKNvMxnATK2XlNlLQkf2T
eUJMK0xW0Ahx6LTb+F11SbtjOkk1GCwWvzLmpCOtpimrj2qQeabpyFZcWR159P1PWW0Iyr2WNqoMltGm
CodL2rPTF6vl60Yk6y/TPlR73pnBZaSs+jq0JyH3pG8n0OMTOVjTP8rCooxm7O/P41/q62ulzPnWpl8X
bxg6y23p2FYn72p7wpavtFg8WG+T5w7SNKLs141Q3pXMRB3TM9c2BKqUwvJsd1exb1Cpr7mx+EwEWKvI
oJ65RuVgOGM2a/JL5TEQVicJYIiYOeOE707VOWSTEl41uJKZT+gJPnc3LH61mi6X0F1xtfF8JhTNahud
FtoBkUabbWJ8to1X8ke2DYQw2xCi2t5ig5vOOIdijRCTsTe5yaEqBs+kj6RJvmK8Yd+d5iXzUZCzWuOW
4QQl+syOKJZByGYTjtXf3qGAggukm9caQgpNj6Zs9XsAbXTI6i88ginDBkuNtsKv1rPAl+sKgkRrmdjw
EnNc2WH7vRIVJ9UmWboGBDCjeUFNOuL2SHvkKD8fYjWHNcXkzrpsrKq4X/pmwkZGM0IE/ZhuPcfXoN+Q
1V4zdjRRmWu1w50/og14DTiGNgagkljZy4qW6EVlJwelUOuADmGWtQNoohqYP4hmmZGW2gI1/g0zJpiD
URZwuQ9so9QYxEDp0rRW6Dlgk0P3jhqEqNkD0YutN0zrqMc2zNr+OIPN8IBmCkNqw5QnGjTaBF1NLbIY
iDaxrJpohXVfXVMSQ6PepvGGb5568JWXyOictLC5Hzyq6cdrbN5bIWbDUZqKfm2QT6eyDSqiT7hKpr3d
XdBY+sYSWrYizEb9fmzvq9710Kvq6rSBaKHVKCYTWmyhHywW9gW6DKLlcrlJodpSAODAn2IN5QafLS4H
SxLHbQfK0iwfE8tAdODRHhGHA20mxHeFoAgvLh07r4G1LcgCpnritvpJsIfVbOZmNk2vxG0YO/GsKfJo
2YIAqf/wODByseUKbIvcnLkNWNNMU+Z9xEB0ooFmpNtxz4DQ4KgdDQBCnbjXGDB7VrgDGozXcb69O+sR
kugQ4aRtz3d389WZ6wT1St7oNMOULoOlhQwojx0rK2O52Qq08eqjArYQ+gG718Oyud2axcmSZgVHo3b/
iX1FjrowGMqgqBClbPNODF6M+WLXAj2kK5r/xeIj/a3nYboUwAvE1g+HoxkGMk0FfWhYsoLQaGZ1BpJq
jx3+VotptZZqs9K4e7FXqN0GWK4OD43ONbomPCL68aPRxISPVsUpmbHVYnEJaDK6S+lvsk1kuGi4ilYX
i9nlKONXCJeN0vM7zbLXFGpaFWipcsVidqsLDaI+GOwkGvMPeP08HU0kNHmbllqhM0LjCh8CWUfqZ1Wp
LuMbg64yUfgb2sJEOVQ87mRGLA//NPpPDAnX2OmJCRMJp+kC9ufDMVZqZbvTF4yxnDfxuNTIeIW5LD5k
bWSSvwfyBJCWmP7Su0W9xeKlY6h44wiFMmtZsK1poKw7hebpeE6kCOtaaFOXTbWIZFZVeTYJQpTiARZL
Ru9hbJy0wZMr91rRAdgTE5McVVYPS1ipSuCUc7/gf0E8JbEMnkDUpkW2k+/4BAAwfcvi9qqNH4FgPatN
+SvfDGejL938zgflHOe+W3l68oBuUX/jCx4R0mxWA8tt9fRqRBTSAexIS/dL4/JjeOIogQRNWXv7m3gO
9QlLF7Iyx1bcbzmz0Fo6Yq5OzkDoLBOUQlgYrTPyXNLQFTpN5+PxaEJUf33DhgdpttyEzEChHYjtQ9oa
zihm+UbNj1SmzAaZ8warrFv3H0JOqE8uOmKme3sCZrhTpfM5szoftHVWG4/GfmCtvBPwg+yir/Dn6knu
FwUSE+7PyxsP9mLRCZ2yLck7zPU8JvL88U5B7IdtOhXnk76Ps+qDuQZ9Llfa049YKgsw6MUs6R7Q+XYA
HF44JsLCpUbPgKkJybDA6EotGuEMCMBzOTEFN7AJImpoek7UH0zj0faUKL4zKEh6xB9Bpw5i4GI+Ay7N
ukpRm09ncc4VusN0/dkpLArcjT+tVtERnWrd1gMUyh9G629N4xLMbJxUXsI6XYdn1v5KefLPcZqdUCcy
yz7Srnk5jMvS7xOa5ZZ/eHAghkE0XzUmkYr5/hB3ap1J3hKfaKPBIRO2T1PYpeg145WIy8L4jnJUsK6h
vrsgdPjwY70mTGbaO8dTkYDBmsp9iKXITJ16Wu8bpuwSVIECeQ9MR0gULD5ktVx8YiNc38O3eOU7OL34
d9RDWu9YZo+aUh9OgxC9koz5jjhjfuSaa/8XhJs/EEmuFHXMjr4DBPVqo+HnSV9p+eNV3uUd/9hPC9jf
gh57tP+mM7ZXbfOcZIy8Um6lqFWUcb0KD9NZcZgBvYMIKZUb1pfhuZOnvWJ8bSrE+r7Gl6+d7eVpsy3V
peOl4UN9P61fh0H9ev9aOybqiBiemp0LHNWZjGllTuOiPz+gztPRqNfNXcg3ZEjGtuw9BSDw75vVB7p6
nE9TOc5ZqB1HYznrwK2g6kX5/RjMXXzVmYutg8Ott3K4dfiP/zrYOjgI+f+tV+dXXqi1ulnsb2zRq+q7
hO5s80ZbXT0UPx/8429H2e5uWruTE1qWU25j6wcWWv+wNR5Np92k/7AFg1VCP1ujydboNp+0YIyUbSV5
KhFepTvbupPTrdlotNWHiG/L96pgcJ5vof2t5GFGbOq2p5l5wI0ZLe2nSiZV3AoZm1L4k1hBewRJO098
ix1ws7IDLvOtvTgvJO5wSDk46jHTMB/qCcjpPEsUb0JHcC+gJkFBKgESX26s2qvS4VNwZRdLwF6Wt/LJ
hnVOI0KO4BDcI1xzYDdQr2FVloKIGeLyUQBqy8rRTMNaiBpvOHVvaJx137Yom2IM/iz3Xwag+KHFcbRI
2erJ7xJobfxooxJcWov6EjmgTmxHy88HecZCfvd8vyj3tdkyNFk//eV2XAGWHdfHcQwHuDH0G0E4hj8B
SD34Sge4JExPZyD91JTMM1g7ySWHPPCVGx2dj4GyNKb6MmDLhET5TiqKHLa7roWQFxB32s08odXGbRaW
vIU6MxOP3QwiHjqk6bYTQ4tHqzSWaXf2sFgoc77a+fGvf345fv/5DIwXuALG4WN11liuPmnGj7BeK0MP
ja5ztNqO4WH6rMr1mfF57OUPYDwIlFL+qO0Hx48W3pZbg8WiXa2KATNIov28s7vLK6PUEv64Rk3Q3CgG
dQWrPzWIhAehpGa6s4j5PCOdgGpVqB7+epuV9UYJOwIeQO2MYUcdjxkoaBWDCF4hQ8EP9BbA+0t9jSFE
7b09M4zjft91AcXSRbBGx+JEw1itCy2u0lS7VftxLx6oZbPik4Q+rztsjTZ4lTKM9MTjFJZ57aVh0uFk
x1YRrdFm++1y0JMcQU/yZiz5Db/E1ESsr4w3UdsYWLQhyEi2RvaXgF1saItYVGNYNvVKu7tb0lZhR8Te
C2vnK/J4/4/r6Y/WaO9ae11l13d/stPj9bTq134MdvYJg+/77hO/Hl6HfuOPiK6DelQP9kWlTc35o2FD
7n1rVhcw65Q8DHrfsKa6o7jwElEzqIQFjglyBCFq3X8Bn4Ki3G55seZDDTsg1u0pobyWkxDfnZVlIN6a
xaC34oSibELYLRHtCUc711Jsj0IziWHP0yD6SFRPvR0/avPXMJFUsAy32zVdsrvbrhEnjrPNlsWoxaV0
TrVr40l3NCG8FBeXdN7QAz4f4xZdsdtOWzuSSCrQouTYXhEKqRXmkugVlbmmCqUWF5fEmh8TvaKotLbh
uwZ08tEfR4qaL5t06mIubNwJDmyxk1C9IpIDm4KrhZagrS6VoTAT4F873VneJ4Jz0174poJOfOctSEZY
YRN+t1agu+8O2peT9N/u/zuvuQP4XrVgRbLiwp1jiboZDD02Q2UO37UTRQGbnipPM6u/Fys+aQUh4MEI
teSA5pXstlcc0qxlpjgTc3EiPohPznF/V3Jac2wOK7esA7tlXc96oJOfVlX3uGYVq3G7vr6s7rOEGAQV
8xd3Ezn2vaPpWA6fH+3zjxdokwCf44ws1SHfit/xsKQeWJQyAhm296Y8HcGal439BPYc80w1tZXT+nup
zNK0BIPWecVPE4d927jnedWkZEqhRHiZlrOjzQHtM2sAMWADCEYbnbgNp2kzLxEi29A5/w/8YO/mN34W
mG7UIOGjmBKh77dB4rTAQBN1QP9y+5VtV7Em1WC1fCbL2NS98C1PS77l74rVBXZzJCRmapVWgQ14bwhQ
KmMxjVqxtarA0/cx+z/4LWVXcUPzcHPUYnPa942bZpzSn2gc3+j5GRK7YK1uh9GYqnXi941xU6TxoEFv
wYxWX6RQqPM81Ilnl7WdISR2QpuRdISdpD4hJaogpjS0mbWBvxhedayrRv0CH+U8pa8Lt6lA77ZS5d3d
vJ6HsCJL+L0kCJXG3m/RTHRoaqbUI6+GFB3H5ETMqNllAQeQ7+u5G9MEjAubHvXhIM4vaBMS40Q7gSaB
X4CMZVzPQjQm/FbcN87pr/2+4GodXjceU4NfaqkRQsKiZoxghqaIGG7tRuPuDyKGMXb69slAmSpv07qh
YedT6EjdvjEdV9B4+M6/Ea2633pqjumN1uYJ5XEVb4WEUQfqPCHgAoswXCxai0WH1t4lvIf1Nn+Ww7Io
kF1XRGsYVlt6+xDmfsRfW5hpxxnNRTECGJfAQjhRL0J1wBZ/OYs5rCXkiuRWF7t0Xu6Sb9JuqLYaygDa
C8gwRCeasvOGloRj/weP8AXaOgxbEL+OpX8OhXHZpCgQ3pnH7VnsYsCp5OatZIZEdo8NgE2PzsDYqnGc
0JSID5iXfjxuTBX5/sti8fej+BfoUKfjPO22unkGpWBfkQ03cUVKv6+9w/EiARRP0zD+rMy2ad914kEC
FS/z3v7faLx7GrPO434hpvEvZ3IyW5wNs0CFK40QEmle9bjco4PgJO4ICP90SwfCWP3v/WdQ9fIhMXmd
jY//FpjBrUxdNGj0m3GHR0yguUY10uhT1LgRN7AJ6LOtHwoAGpe8lDdUGvHy9AXiO9JC4IwkAgkmfdZF
P9KK/91dz+OATizipl1mzNSjQI0Qqnhh2jtVC2t6lXj+E6gtdtNV39lRBGC1gwgm2mYw0v6vAJ6fwnNQ
+cX5Wnr691BbJcCnQg3FqWnGdOiM6dwTlbVB0aDNAXKHAyRR0TwfNmlwTs0GNSHzOJynCtbEulHHLrV8
zx4I2Uj7LCt+/590EtKjCTEBHjcbHcaxdG0U19og3E189EoxgpLme3tOwLhoxbVYOxEfHOXaVmLN2/HW
d20B77+LiAhMOsFjHp/68ARQI7eqlqKGgztemzOXHw2ww50T+cwgFmP5lLKc7F7r5OCHZ7iBV+aKyizv
BCCNX2AZ3tG2e7VYvILmYMr0KNOQgYwrM7aMcUtDNgYcuEH2EtV3Qn0nuu9kQ9/Jv9N3Es/Aq27oemgj
DDghroq5YG6Nzgxt0M2I3zqz8B70/vBi9lp3HGI4OkAc51EA2xy90Q4Jc6EuYIoa7A47OTFhefZCmZa3
47Z9LddSBtrt3C99VYujaWTE17PbyWKRNlrNDbSiMmGiPrbbDoSnMw5bwPEZFfDpYATgRMVq1AXNsxXT
AKVUcRwVkkRw1wxNa5BkBJ/Pnq8G19rdrUA7SyhoFkTnbNeWFVtgrIGeRSVz8V7ciQtxL04hXH9cikkS
zeMU00HESweArugb/5aoQ5Gpk5DG+j6eF4QJA4Ya0AepZBJ+4//Gu83Av67XA9xe3/2I35396JTwGJ/o
QNHbrxeL14Ru3+3u8g+1abytrJyj/t5G1XCA68PIuIp64jQIN9bBE3AW75ly0k8KDsN/p+isFbcQhfWk
5nI+sIMSKNqMMDtBBcERA1FGOBXicsK9tNeZB4tOi20BD1LCSYiwHWfVliEdMk0xeP/XC2kGRwlsQHIi
oVzZ3akOwhthjnWVyZTAkW55xATBc7qlteWqiY+7AIx9VHHODi/2QpBEBKtcQT3qxzeqPpH0RJbSDpnI
fv1YhhutRaQKgMhBDomWhhoOUrx+jc7Nbhs0nyvq4+H0EWCz2BrD0VDV9QS6Fe9UQJNoGbn1Tzco4ZU0
jx8DbFEZUiJcD4I6Ii9IbiEI1YwVYZVp9hRpbT+wdKh6u15YTAO/vEHo30cHwVK/qI2Pw+LDutOUuH31
OcqPaLkMlpMENNxZ9AlOG59K66pFkGoNQ8zsO1gblVFp/TTMhdlZ4XvBO24azoVD+oaTZCnS6B4EjMVM
UYWAKo7vCSru43lDqhhBcNSb+vdgPTNpCuM0Ol8s3hfssCov88QpjqSi+eMpC/XV4BvlJ9Qg6Om2ZhDv
CgaxfXTHIUhAxFwQU9huigv/orb2we/FXFyYo2d394TqlE6f4iFVJXRGiMrQM6+Cx77/SnRpnxMebdPe
IGxCe9twMTZ6Z1H0ecKUYjsm/IAwkzALL7OA40Cb3A2tPRri7rYh6NYfM/zf+Jhv+Jhv5mOW43iM8KeW
cZjHe2tKj8qF+ASfWLseFnNOxTt6QLj2jTNC+1S8podmRorSlsQ7o+FVPyl80YvHD2BD3uLPOdUjCk2z
h5vq/s4cmwblGOFcxCvxQnwRl3EufhEv4e9xIwtXk5fy6EbSX7A8r4iZfSmbzIZ8jkFvTMFmiN/4mniJ
6DOt4O9EnqXis/iNMN+XmA+i+fNXVv6qMR6VfqHXGHKDi/iC6BfxygUGMJpwrs3v9vViZltaLvGOhvw7
Ivl+AcS8i19RTy+oMeavtkut7O6+KsluudOigFbpE8eyRVc/eNUX0PO68sBPjRdN1RuuqCcz8GLjBzT9
BwIzMOsTVq7wsM3jKRt+taRqg9bxFRFEevYJMXyp++d4ex4XEyS+xL+vLZPxGD0dDZTX7hYPNqSfjAbG
flSwh/8ddPEHSYeXsRz6Ig44kNplfEfXOW2DthFhi8cnYYqY5yXsKb5Q3+8SeGHxrIGkIbb/dxM90rSq
XKiLmYdn0lt8WOYoUjzxWk3D6/gVfeRHt369uPZ/R1Dl4p6qfqWVFq8M2xs8tuNXBFrGy/lLUL/1iaP6
EnDI1TT+AjdhGsHhdvxFw/FiAalgWggJiiNjNu4Tq0x7AOwzT93vwLO0CR4Zz4fEmlFvGWJnE9Fxo4Mp
7eigT8SG0+6oHAprJYv7Q5qRd/CW/KJYIm2U/sWap+8E0Uui5NCas90Umfq7irf5ZWVSgSG/P6l2ihiR
Eqh9iOe574yzGORLQnG/szX+w+7uJXNGj5vQVfhJPIWswndiDVWFr8X3YaqEXIxj6CujvmE0/kts7wEL
4jIQH/1fgvqZMgT6hXFL+Asd6P4vcOQR9Hc0nXGxRtm3OXA2oTtC2r8T0n5lhXKwSLM3auudy1mHKMt7
fy4cNBUsPyjsFF8QrQbZ4YW6jz48JaiLKw94uElSF78tvRZfRv8CUcfnhnD64KZAkG5qDXjm2blMjtIo
4ejdCVGfxHMidMJjmY5h7m/pGvklhmmG9Iu54Jy+tGN06MyRdRRjhpgF64GxFAU1juCdCKPcvJoVMjWI
z+ZxXsjO5iw7wyKP47wxbQoC0zieLRbt5+Ni6uHTsE0nmVGqWWuWFvD9jVKCp/4Yn8cnUHgj+PwJh8p9
hzm5MQSyYwMRZwCIMzq+9Zd13KQWjo10ogWLLOTkq5yj0Ru2qqSUYVk+R5mu5G6UaQ4JRpQ5/UUAatgk
VWN4Azz0c45AVvciLwTOrqIOIr3vTDF5ApFVRYoyZcBcTotAnSnPWPCCfio5OJyQDV3ajP3iul5c4nRQ
wf+C0A6CGsi1HZgqEuVb2EhxWGJCHyiIfX1R179V/gbdKqI9t4op2GCw31Kh31uww4CZUgxevuSyDFRV
KE6UrMfK+yGenXLUS4IoaSOZnCmrlLl4dLCk0io4pDnfa9SobjbwtOF8CYT50Z+XMG69dMt6uLBUROyd
OQ4jZZh+wkHYJ/Mp0SyfchXuH+9+CAjHcpia8TKoTedpmk+nBXM11HtJnBAz95VumXQqTr2hPfGG+sQb
qhNvTHSvPfGGpRNv/J0Tb66IgA80bPeo+wAJQwJqG6O5w8E3xsFH47mi4SiKDUfbHY62O3OgSRxoKdVS
Z9g4ntJG5HNs6AYDPYNUGVK5MS00gS8tnVrqVd1gCkN/tnjJVL4ApalUyrB3PseedtiDHAI1Y/v8CHWY
BpHoxLnGF30q7sW9c33HfWAWT7ZhT82LcRqfOPLozvdx9u5uxS4XAftdTJTTOGCi4pO49U+oD5Z93NLU
idNgeUIs+9N6taFwn4r7ILyP+j6UFHe0Q06CpTLLIUhSFt0l/TPL8UorPpKZJzJY+cLPYk2X6yqkiV0b
1P2BERIanVJqrzJ7BWc2/8mvYGnqBUTgZQ1hIPAhqkNZcvB/KONicyTsSXtpRo4o6mk9DRWbzKbIuKir
+yN9t3cYHsK+AAfIns4E42iWkpIAOHH2yGDen3WVfFwLE9SPBEkB8awTPAPeOVZIhXxYEKNlNl/Xoxl6
SKhdG7OsiyCk1cnbE52VjUU5S8wSJcPaoI23grKc6Fz7TouOXy1SsK+qBCBmKaO1CnTQRMTJ8PlS7tME
4V8Jt5yaQPDKYV75ArmRZa1hnzedpNko9ZzwpCc1xMnR8SxZV8euc/cw4oFdio51//Li07nykvaUCZQu
f3P+is5fCM/RtgmQD3MSFRvf9vLp7PLi86fTsz8/f3rvRooqK+VZdbmtspGpeCUKFMb65KbuL8/en51e
4a7Cw3WgZpr3ubYHKIENR7oKArDTXwMCI96iak4phgXLIcJRjsiREEvp3kRbaaujIXeHQ0syGtgYPPgi
+rwBURegMl6wmVgQDDh8KXa3n6mApvihM5d4vh1lYQM6udzr7m7pll4wclCCm8DKDVeMPSz1gnmEiWqd
WpmPMzC2bFHBNgEDQwxxfGaGJEf8LsuaMKYIcuudDZmwE+8COh9laa4kRwdwLSnkYAOWg7FnartJhBrh
vgaVQBY3iNvVfO/QkrId971KJ2KrUnp5cNSp89uyMWiG1kSyjfjZmtWK0Q5LPZZsH6BPCBUTA7iHjtGn
I0JFshy+i2CqcVvL78dymI2acebcRFl8qONgJauhQmjl4fYKlYExfgVp5zbdspGJUDXiCOPEU5jMS05Q
nFlakke/3eClVXJjcmK7CbzIio6LZMVqXFl5WaGH1GZfIEywqUGbXCSOe+rjzhD2kBwEcizFjrHLKSFX
lbzSqmE+FNY75e4AbGJHRyvZ3ErFbcapubElB6o3+mLO1RQSnzHXOf0OOGyGtgz5bgdZEKJyVlR+6qOI
Vv0AT6nND6khGuk0LxtgOzrA+CZdeQm7TXI4+5UHnPXNfBLrGrpT5Zya1Yt1REkGZ8JSETiDlTowf5Bs
9ADNH6HZcm/qiDg2GLmjjglOX4rzQBer84DzpOnBxJ/YUM2UR9ssFYKNtU0rpVxSVj5OW1GDPaLJr6w8
ZbaJaGYaq5/qTytwYwClQ9nq1bj6lSzIOBzLEiuiX90IN+wfx967pSMhXT0SBPSmUmFzNuANjFVqEkRn
JW/JYu/mBuHTNKigPq7ltfL6ueF4F+C6Lx8GyQiOfb9TCWERe/819h4faYZvsB7LJV39Xv9FhhtdpYtk
C4/Xj/ttCMSKsuWSSn6nKfkc7/8xbGP+G8d7vzf3zaDuXMvssRu3E0E8bUN3HC7EZTVLRtwegpYl2sWG
sz4EzPWXClpx5SCij4D6e8Xvxopk2sYB5yDqHVmxR0+dMW0CykavGUDK1h3O6ZSI0mrsH9hoSnXDpreX
6/FkPmaOvbyARte/vqwGPg1OTmFTfn0Hq3FjFm6CVLsoNnMcyAvNOaK41d/ydIQJ773v2NsapxmXRlm3
1ShMxkSPzt9jFT+9HRsrVbjixW1W0tLPT+r8XhEX9IJ6QrMVdghAtYKLGtuGaIGKMnWNSCy6GJqutOR4
j1EATQyUi16riLVThGMwTbt+MM7kcGxPKBQrvcUiVwzAAPEatMZt0IztWrVLPr6/POlvtMFY+tYvAoKV
fA0+rbXCvkobmihzAYliCTck9CoN8nYtCZLISx4oW7DYNRsDkUPKMXXyuMitiQQ5UQqXdGw8a04GApPI
ErcwZ+F4aoyUJaflpj9VT0CbEWabExzdOYNFWJx6Es7WeCAIDZQFNUdatP5k1AFyRzWV3jGUDkF572Z1
+AhNhw1og0zKkEs4KTUwubFCHhs97T8X21TZXFw3FtePjT+uH5vBPrZt43p53Wyy2YVIUSe4bl4vfxD1
6+E+Qid6OozoHmQ2NKlYwq7yuN3/53Q0jCBjoyM7ns9ae3/3lrR3lB+IUoUT7mdOG54in/LpeIR08I1C
YBk8HquUVAigatBjysGUtGxJJa+2l1QxRVyXwEm72hROH+zi7HRRIPcrZbpnEtS+JJanib1n0tOWnp70
R8nK0/pQstU49dfJZUYHG2K6DwajYfh4nMLSf316xBZCse7Td3Xp+sf9H2mGoBxgu5lAwNlMXwETqeul
uJ9OWsrZE2Ke0Pv18tPLvauLd2cfaOvj4WvuXz/ccx7DD1P5R+DYxJhGdP42mqIdazys1uBN+XEZwzqR
soFkddxudk0o+SmtOCfclHPjrIlyyrZuN74sp6YwHBQLUKV4hBAgvIctI65g6qcm3Zh3uyDlAP+zg4Mj
nJUzOZsTW/jTwcFzc1fPwiHNAAaIadYeU4N81hllocfxpdYAKa+tFol1gM7XRwQ/rHWhSl58hP5OUxCw
7itRpQglBbgSSQMxNdQIgyairYdO2spHSfgtczLMcrLQc2KcmJp0D3YORoSoRf7aoMoqBD5AP7IlpQ/M
Eggdw7uuAhqFTtAiDk/mpH9PlxCWvOUE7FFqvizO6Fp9QvxG+ubaOHmUdiq0HPo1LYApAOAu5ehKa+sR
RCob/bovh6dVxHs61X98zvZ2+gtgxrfEy7J21511Tic5J5GQfVDI2w9+vqF4vW68Xs1Mx1SbbdZmnRzq
EiKuxQw7cVi7Q0mqVm7in5QocV8ZedKXQWuhL89wftIAKi0rubbPxEqtiB8pMFRNqGvTRssksjYPxGod
yLUL4bWMWyWB9aC4h8Gk+jyYWy3bRolQAn1dwz2pcfzyoiZ6a0I2b3aGs5nby6itaIdNLTIv/99s1l5Z
FDTFuQqLflvS0agrDx5hMaUwi0Yp9XsOCncrGqhDx3tKNHozCO+NNOM2gEWacl/KYZG8szMmmpJWJDNZ
wdzorEUI/6RQACfigFaT+60kquOkfoLFGvWJHzvRyCzwFbKUQn11mNgDSm0anesl1c8RLDzMXYHotIjF
IP2bGmQwTrwQmB9wfm76+LWHRpkvxaFCqScE3+wrjxAr8QkY8UGXgOxevBa38RkhgPkEUTHHciIHtFvW
W9TS/WiilnkqqNY24pfS4UNbM1dXRFfp0J761nt1duWxVYXCMHSaIy/qR7cMrP090Wv6paCuL8IrPzdF
+iKcM7l+D5z6Or5nTdotUmi+VtHjXiMn1mseoqXRXhcjFq+jN1S1PvZfg7N4zQFkJN3AN+A1PABCeiRo
cZEw27t452lNlQGsCXDTa+x5n/r/mKiJCzjhGAez8INGWiuTCuAKyiXNcMbMjq5aEA6malHSjF8TfrUI
WtwKuIS1cd7qODbpKq7jRH4Kc7BOz+6wyXLVFHmFjjfpoqKr1FUqc1WTSXux0D6/b9SPjDma+mr8qSsT
hE5lqka03jeXFyZGZzgsSb6RglMF3zjl8iUrtgumFw0RF7zHDgiWmah7QZ3+hEj8WU2L3KEOY6BM71Jf
e3gG4kT5F5fNdk8s+mbn57GOMRmOnWiMSxWEtrJJ3PLkW9GJ2YgI8fRoVmWTkCP19QGEvkQJ8z9VXRNN
rBvD+Nb2LL61RFpMnBBRbjkCY8RlL1ITP8MnyoGN3wxJJgUBPGI7qF59RaJ56vymCyA5+gGdTRP+3+zf
ERhgBNmmEQhGr2kxEJDwyEE2R9C7m4LZyYv4bQ5fe5/r9B+IHkwAtp0UWYkRfRmtLfAxC2pwoT5vobIh
TYOd/S7BfmX7a+3X8/evCbQM2RM4kT++1o5Z4/urSmTle+fddDKajlozfuvq6qPSt6w1Umqj/CwqZBAu
Q8BCiPsORDXFF35ZEww4TEMR2eSpOCZ2BR4Avvc5Hdt8gkAhoLLz1WweLcGZjN3pfbDxy3B8FtZErmIG
aseVPCMqFxU7fbA9UYujQMceM2z/lLdSV6AH0wnyirdqnKgHcWHaJXJkB0Z6ntJot4NI3TLVwvd5LRll
D6XI4/CiVb2qKGN7h2Iae/Nhbzi6G3qwN/ZVe9ucQx8DI7qBCFaeB0S1JnT3iOJQd7QMqAVVE9EnVWEc
66L6zwc/h3TUsJwj9Xt0Pi2jaVIatrothq2BtVUbDWnisgeOG5WuxJsC/w4NEj3n2FiEiPfRIg3RhDTb
V8z7Sq3N7TJF1/b1l/HQFILWc1hWDxVEnBJ27h1uSLw4cPMSlTxkCBvHbdjgfyLC9m53964mEzi8uXJZ
lTFR0YXvEIlJxf/x3wXRp1iHKmPdB0sm8jrNcei1uqycnUt/oKOTpqM+LwEtgPQPnz1DtvKMKv8c6tY5
uwGnn3w6Epz/MlhyCLYTrvh0RDj6nEE8WCwSFc2OdRMKSYIFMjZyH2LvT6+KDDIqL121GhShrX/6G5Gs
jQ9lnwcUMH1Nm4GvFTAiEJi2ZEHsKJsRAsTXn6fH79+fHJ++o+2/tpVrXvVDID6snP5zeD8L2xcCrSV6
MC+XikZ6VJZAEl4fd7URwQQvNMe39ocr7X1j8uAOaic9SYrkMUKzu38B4DR7BBw/x/GdC8GaXGaATXSg
d+TWga1Om6mRO85j0e8biYDqFebKSeyZU9cjrv2ufmepqLC4BJUOayFur3J48PwX6FWo2YKIDyJM1sli
cWf5HRX9aRnBKvFujVnVhgRTNnm8K9Fu8dSofnRKWkCMx5ZHOkyqjJaYxWHmd5Tckj0FD47GAebiHdE+
Z7DSUuZWII7HijiGtzKTxWeu4vyykExCOyNkDNWMEkQ56pxNTjeyzs5rKlhHotUDVuGzKfyHCuxuwnus
KBRs4I1N4To4ykbJBKJ8xnDUhELjwngmPhAsczuLDRct5vCGYIrw5ugsCsBN+UN6bCjMRNwE2s7UHzvl
UlSG1XYQ1P2bbQRf0sxRy4mCBkNZQv7qwQ2twjx2H9PrtCpU4wZ6+XiOYLbVHgZ0EIRo9Wxzq3gjPiOq
6iyeFmlMfF0VAtqz+JChqb+7e3hk6yhgeUhBJihTPE8rPrYJbOaF/YtW459RN6uKyLJJ8ZloW2tihkxT
vUhG0I6ncMpUaq22SgnUJ0ausHukfdIOwly5uV8gBoBQbEY7aGPfMtRqBzytjGkbPzwdNTt0vcOG7GLj
hXi52l7x/yKKgoMDncD22WpkTjTfYAOs9yBbwUyxsBYiU9FzsgsEooIc98ulXroW/RKsEpk5FTdLE6BI
A1ivsAdpbd4/xWZYUpUN26XYX8uN0Wqv1oi8kvi3IPNu1um7wsTNh3N9D4ZExoyFEPMbnbFR9NnfPpcT
WzKMUytOGMdDK05Qu+wbHbG7u9uDqEeXvaDeCw+isSMd4j9ZQGU7Ni3kmywuuRAOdbxUH8FMIg5OePM8
RhinoRG10HYQfb/ciJPWq/ygSbQUDl8r5WEicLVSPLTutktl3PC4jDITX7CyCYkhwo7bBkS+ed3PG+Xi
pmHXPNUY0qKLlWn1k6e+ZaUtE7rQ0bY4aTqejCxoor5nRJ8O9+ZTT3z4fH5y9ulPmM0dX12Gjy/OTt+c
H7//8/LsY+jVPPHq08Xnj+pOeOLj8dXV2acPl2HjcdAd0qjDQ0EXLycyDQ/EQN7z1U/QpXycEKno4epy
3sLVMG9z2R5f6sL2JcxyfhJ9fQEeb7XhZ7bhZ7bh6/nBgfx5U/O+eWQ6CTb00hSnnz99Ovtw+tufl7+d
wy59KV4cX51dvTk/K+bi/OLD1evQeyuHczl52HqZJxO+OJeTtLN1PJ50+3T9sPV2PszpT/9h63jeJrS2
dUnnVQ5EtHWRzkb4/UA8Bhe8yFO+8NycWJXL1xefroru0BV6QR+mB3SA9tE4mkWTaK3U0Ivj30Lvcj7M
6J3zEf9cEWmF3695NlRXV535hC9eTrr4uSQSZUIXpZZ4RKY5tIWG0Ahex5t4rfTG8fnHcwIM7/icIOXj
udcUgzzrzgehd35+vpWJrYetTjgYhNPplkSe7w4R9R493M/2H9QjlLcIM3D2Zu+M/hNb5+ZlT/RHw7Z6
5BSqPmyxLuXGdSG3byoi9HPoOePgmkUpFS3FmJMGn8rZpmDdnBir7o2GULuOCKURk+fGyP6FMy4m1lDE
23dy/cvC4o7zU7IlRaWfqCSKRTp7dSLtu4nCvlkFdAIWJlFOvjs7hpGJE8vTcDnSdcUqaxc7PHJd+tb4
MyEZXBDZ8A14xbyltd5Fj8dpOdsfjYftp637Bqc+TFBeTRB4sjQsxM1FnoEs//zpzSlxTzRjxANB/LvP
Ed9rqIKhFQ3WncKC5jkkatKWq9anObZgnKewF+BrVY4IyZt6ZbuRTjEyHsR2bG5LTjl29Pguc+MsxETa
JEgHsSuOdGKKGiMGs9puppukMFCoOIYR/2FttVnIWU9Cxz5COg18Kqf0LGwoUM7ZTt+YNgmAqofOqyfa
nknbnsHt4j8hN5FsEudp6S93EDG8mVyk+gUmydf0p3k8kUq5CGryuLAtvkT2kvGsM5607j2GpIhgKl9v
FW4ovnMX86bRBeC8RwgptFwpWY9YfZqYVjRQEE9nvpXWv06TXO3bOgwSdHSYZhHZ/JfEHUdQ9SUEzFWp
PJhMTZlMP1PltFq8WUQyscOc5HcIYhK7ZhU8X1EFGfl42hD2spSKL4tzoR6x2TUe1dOqT/c0JwL5G3La
DtUssk2kq02k1VxlDo6zKibSqoEdmrGU0fQvL3jmLDhGvljo/kUe09zGsbuX9SeELrDVQRNsBJPOVIMJ
XD3KYGLMQHlJtHp6/4/rfbbxC/3r/dqPwT6Le3JnL3IAl9yKPRI27Yt0TCjOg5EhNI0uoCmsI/lwmJXA
Ms7+bShMN0BhXoLCyn8DDFMGw5TBMF8Bw6TqF6/WpQOUqP40OCocxmiDpo4Th1lOwzFVSjbjjKtkc1ru
EhL5lzsB7jTceWY7Z9AuINsguqq0YL0K1//jFfl/viDuIjhzOUs22eLZErY/TprLpWUztk7LGUZdAzOV
ANJOkH450r8xchatAW/kBowtxvXVEfpA5LN9qN7ETBBR3ereb5L3fOM4wesiHwaRczqCvxPx9UmpT4l3
dbQVTth1VNHqglUZ0GogTSQyQSsyS+lc9IssOyoBwqUyi/CIv1dLB2cHnWIEEuo4c9IVIE6kTlEyjGTd
RyQdNz5+vzjLCVO7dziGnwUENHTMAXDFABZHOr3FSRp+ToKQmqvQNujj4RXtnB5Hpxz4QwHgRIFBx36v
2FGIoscbbqztCAsFyWIgu/3ZKAj3u1GL4yqm/W7a89YS6hELOpv03+UPxLCzUZPk62cgj+46XdotVvCT
I+SszkgaRCa7UG7cujjBUARpD4oQiYp+EN4SiNi4mnEsWR25XAlLcuUUYPJMXPlt1+Lv8surYxVLN1MS
mCaox7YjkGGj4TkCOiPo7hfZDzhfhyJHxkrN0VbGAQN69XNiZBx5KcEFNO/qnn3KQj0cxO/b3T143nFs
WLGiSqjFiyOYokWQwKAdD6vtahGygE9F5wktHhCIHyhIoJoVKznvx+ahwzqosIsFJ0HLYiOSLhZ9OrIQ
5t463xSshgoF27HhXqvVgPj5bRrMDaJPebUaj+ymWe+r9D8hbqy6XSVW8VHGRtMYfN/hS5YYbQGHbaoD
FaqZQgUjSODcZ7Baz4vqB4rYLqdYxTbbNvuMnhdQ30fkcSO7EV+NBrLhtVp7f/v7z88O/r5XbsrjUJLs
YhgV+3s77iMTAdp3Nj17YrqpW0pKa/dt6ADTJ/wiFAYtajt7li3vvoeJOBCnqEA1spYst+5MAxxnePTE
bYRteIbwvBgjJrrMum1AfGACNgMQ0idDdBmUlujlZGoJagoZO19CMEYAJJ768L/yaSUUu/6J7lQhb/7K
AtFnt7VdSOQMFCeVVe3b063nCsN+dfO0IbIeIV4dEz9P5u2zIVK2Zf/O+fakqX5ZoCrLMbu32JKDQZ6T
Z9YR4MTm6axwCnS5kp/TVgjqnjIEQWb0cpJO/U7o/KpIAp/eqxSQa9XNY87uKxEFPw82mdI7GeZSuO9P
R/2czTDyOGGfIWR5ai8WLyNFMcBVKd4GCsAmLWLaL61+aA362BRng0VIUiTbVdkObYTFwlnBzaXGGkUY
uynlQVL3vDCxUTweaZhhDtV9mxAqp6TIId1vjZDYSk6GuMUv3bKiHfdK4w4JLEFJuEZSUg1+ssHDOniE
S7YeqCx5Vfhlz4qeVM4DrD7580/aFLQWr/LZLJ/8+aenHM1s+eVaeX806s3H6/VV+Xp9lvToAs179TkY
Xp62+pmbxddxVbgtxB3KWoYT6hLVM+esixuaGnpaFlC4q0BEXiQII86hn0+40FEyrDRjdpdpioM4EAmh
8tPYdP4svxpzm3Tw4Bdpy4KVxrLRwLaEED1MWqzUIXqD6yzX52CeuKYst4r5VaFGH5ccuEmf0DVH1tcS
CKp3WAQdb7MPWNyDs74x1K1og+tejFbhFUYFPUK3PbjaoCDuQbTWixJWnyD363yIYP0flcIFof3u2FXB
29m5hd46cQI7cqL0dTNfQqC3SAS6xHGS8J1K6qSu4ReYcH7w22C5MmAerx2pmSoO1OI48qfFfCkjDYZ0
IsnQlv5N9W+mf9kRy5iOrHxkgTnahYpqAO/ytXyv9UHYFhyGSOECG6SoE/lES0Efubvb0ZOJqWsVUwcx
VD/uEPGOaZghHkVp7mg61SNEPWPKDFMUqZjJtpv1rmeqa+l2Xfl/13f6F/pO/3c+O/sLXWf/O13nf6Hr
/P991zYwVHEmtEzA+U7MQfPWYZIOkGKQFQckFUT+FQhSAPRX1lst919ZHrU69myt6wr1WagmL+w4QoIz
1wPuy5onZiH9/pLgk3TcBQczwtfYxl/gcAu1dDoOWvHfnud1QhkZbLE5KK8K0AuXz6zxc5MDtDqqmCLT
wIHoRdmIkCe/jZAM4ns/aIdfhzcWKN5IhR1vH+UO7RhZhozYOxW1jAinctwhzlbU0+qOdjX2YL2zFccc
CS0wqSPnQ3VyZ9TANPaqFT+re1Mv/MH3e7u7vdUZ9H6oJtUfiLOs98Jp8ENQ/aGhi5rUwA9VX65ixR+6
rS3qd3d3a6pserYer4db4zs0lTrh/xve9eR62AyQtfL6eueQGE/qhxrdQgPbPm8JqK2ngW4inuIpdOO3
W3HpQ7bGK/vkll7hivEtIgZdD5dUaRpD7nTLNz+wGNIkfGlXPeOIExFXwGKOl6Ytmh3h9WDCe8fGjoXd
BWdsgnnm2iSUiUCzjGxlegcisbf0yhPNWizE+AScxi0nB7CF9d9W3KgfCVDD7UNR7holRFPq269EQCJs
NKLnKUahXHuj8YBJgLRSdXvbysdWHumm17v9XnqlDbWL9tcfrvA5rW5/tiaEK3sYm5BQ2NC0yelvdCfj
Ms2x3s/u7vbLtViBLLl/mWJpiF/LdY7NhmIOm1u6ia3WiIASIEvAuJXfE+s/RRDVrf+Pg77/f7UtZOEe
EMGZbqkJHFOPW8SGaUOVKd49VjIE530qnm5lOd2mkDjVEA5gjcC30uuyYVK2apjEdOvK5zkSbaDeSs4b
4Cuk70RQ+rhpIfMacBXnXyKOmAitDSDMylc4/xXIK9dWUNYSK7QydWMDpQteLkuMyM73bYi+m7etYJiP
y2KTxJUWINqJLNmHH+fqZVuQuraEyzInbehCX4tn14T8bZ3tx0xFP340/lgrAs+2YeHaUTvGGdhS0hkj
+UpcyYZV3AsYvWVF8qXkKFNxNGOAquhodzsOfIIjTMKhCCGJhLL6Cct0hTFg6ilvj4oydfreUL8/PjqQ
aHx5MT4T0Id4dwT0SWg4vgqUJPQOCB8x5NK5KnqBlkTmHDTRhXiw98W4/Y/Ktz4NANGa18/Vl7GRUw6f
pRzdzUt4YK2ZVlBvhVnAbH4R5MQ0k7LrE5o52dCMNhCjVtjGLHVbQZQmuBMvo3a9rWQJDU6y1kSuZ2X4
ilu7efrGhm0pPG7C2+R2w5ukMGQDWHs6z3q5fmGN5eYmgA4mrWd2AoiwqWSFH48157JjcbaBk2KJDdwx
B+3Ylwil5TvGiwa/+D3OKW+2Dkx/lYcm0aMrZ7jzEnpZig1fju9Ae0GoK63NyIaXMrx0sLnBzDQI+xnR
2mhSjEFLPWi5CrGlWS1ti2KCU+O6tTqx1GV7kyu4r1KqrCxIUgBHL3YHoCVM5YFZhqC3PjSsWs/dAO2g
XmljB6SBk4C/Z8aA0KqcgqUgUZ1v0GWPbIoZ5gbZtMVdaUA95W2hI4fy7kac1NUdpRqjMXWCekdtp2I3
mSWBrKHNO8vFEKst9IN6X23rYlfbFlK0kG5GDrYFWvHh6hj0ji6jQIL5dfi7gcgaFMTYznWL83spR1Da
+kGwApYbXjkD9KxXGxvMM1fQVazNuIAT6SbTdeFLpHyUwHuyXmk0w42JbdNqNSoG7LaTrUdXNsH4pNjb
SyETM+PPVge/8WUH3vlbOMQYRGlFM+v7wOEM22uJcwujY+2jukoxmMid2kNeafjo6cuJlurd5UmvazxD
1h8PRt82PuMITcq+9qk2T594Sk0+9ch9cXO3OZHsKaJo1teXPHXwiIujeFeHJa5ATQv4ysO/1f72N6DH
DW9K4+7ELiVwDxjDoC/PCkfHkoX47wU3cwgVCHwHC/oO8KjOE5UoGNqjq1nZw2M9URH0Im665SdjQW3y
3rCuHVbBX1AaRmJYCMktcHWzuJP4hYEOVF7ajkNpl41RB+u6EONC3zuZxqwt0SS/XSliCTPcgUoFV7Lb
L+an4eGv19RVMIuORmnH5CiE99WhtQoBAfzLPJ/nRUiXHTiXvuC5Vk8qxSOks82HKkDbahk7kjnlKymL
YjfB6EAL7MdmrrTAG/LuIW1jYuCKR5G9jB3Bd8d1cmY6+SsEt4kTW8TW7RvHzmy0JVeH3Eibe8RzKoPJ
9Wc2+semh1pKAzG7XmfHpBH7Ydlzwz062omwJ5CvqhyjEdYnYLN6CKduF1Bdoshdr7UVFHLD2m1e0iD0
XTjizcYBFgtbx5UHjoTA2lv9BVD+K3D774HVykZbHabKAr/5obMSLGAQarI3Vw4iaTeUjGRpG2vj5s27
FB8XrX5+fe3zVwtW5k+G/3oGZaEYFWoxylEwrUkktorHFbzARHsqlo9ozcfWMEwE7HPDoSBESdRafj8O
pajkN+H2draMUptBYfsjJ9FTJCTRg4vFS+GZxfKQsrw1LIVFxb7r8XnA0ZOVAMLGr5NQG/G+kLR5NIuH
NjY31FehtZRhn0qfeCmZqCXsQtC79nUcN7IIgdPedGjpFvRHLs1sniKGHtf5ThxLgQi9vfjwyPpVdYiE
6jNGEhz3fww53RDE2yQ+cK3cNhg+ZDFOzkiz9UoUfQVSCZHdOGo3B8fdjqFh8vN4QG2aKI3UbYe4aiEL
UfZERWDxqVzYahM6HSEyiJIjyXICIg0aCdI84IfQnbqp4FfQnKIUho30QxPMTaFE5zSEQBrjGfN4+Fsn
eiSR1Jm7Egi0smCNwGN5muSxresl/M3D+iujIvQ2cQt4NKyZmTxXcZR5RPxSsKHv3d3tzWOd7O05bk9N
HX4l1xKvPM7Ud1s9jJsleAizvO1DgejcGcEteFU4tqkEw71gbaWJgVYJtDOb37Xw1TiIZBHBE6mt2hz4
kv6oMaEmTDyIIUduqKCXqI0DE2YO7qJra+fbdpxx3FZFYq2aFGSi0hLMp204dSZPnDHik7gTMzpY34kL
bINbcSruowFyKHMlRhVAZ3naK2ybzCaMstHjHQgVfMg7hXX7RYApcGP3MHI0WRBUUgcl1fPva4XU1HBo
r4PHgoxg+UhOZUu95WWo8st2OFmkwR0MKp9ia6j2CX4xOnEuHUONT02slo+A3Qiv8o5t3f0e9h+hUoAR
rV1+Uz8GfukFoXEBjYvonbu764W93d3u9IP8wMli1FWPWL07oJCUYEw1H3PTr9E0a3bCFj1ogcHvUVPD
eosojHeB+M/nUJ7fxj/vzcRF4xabBT9Ai+I0/ogB3o+DukcnwBb79tMthwlF1ClcO96lkAdRkTitxl6E
CCBfZB9vDaG8rFLRqJ8VRb2AO9RBdILAGh5m4OECtbzsBQujbpuobm2VvrHT+LZeG3seLhbv4FlAgLG7
+658eiosGRXPzctunSh4hzJ1rOskv+9ilcfav0Pua73r6PUZ0vMxgboyOqZXWwTQSNJK33yBtAqqLbcJ
huLyq9HEQjOLFgwoW2nZMayGjiGIMJS7uy0xI6t0vbFcctkOTYm4JnAmhXmwgTE44DKNzif+JlJMVE4S
JWDsKz0N5/5x6BQ9577cRL24K1C8x+TM2nsuneRQW4FYLyuCeTuFm0nS0gjWy4qWnMLN5N6GMZV5vf8x
b+dwcioh0Dq5LJ4gxtc5hVXWgHCyeqLXX9dT2NmEN4ehWPxSVxwN44pDuGzwA3/JUnzGwpsTv4IsUtQb
YhsWSpgSHzQujEbHpU+xxsVt7eDtjGBjTQSSsFany2Cd7dXJLVTuVB5XcXSEks9EZ+JKo9w8rTYltlCT
V37FChG3cBByBc/ADh9d0pGzwqJ2qQX4K2iRBezup1lBpkJTSGwu0giS5J3vkK8uLMGCIy34P7c8rqRM
Rqc2/LqSbfOpTCx1tsYZq7DtG4rjA873vFZerWpWGlF9DSsdKfaFu1mn2tPGJ8XwN9WUILHuoZAKAAfd
2cavJqDPNAvEWcHpsHzEaUe8jrILV1nmWmI6G0GxPZZtWeYAQJdtH0BV5Vp0u897aybE/MJqIXzkiVlo
9JomAZVJeFlYnR4i0ZAYgBrK4tbKsiwWadSrpfMJJovHHbeivqa5B5YLiPpHg6ivIrhnjX6TzxtcuPkt
OgaExoC7sU11ryPE9UXlkEZC5O+AaCBW/6n4FS2MqnSGthx7FVEcPCurYShZmw6Af1obF4MfPT3drX9j
utsx8l1/d7qJziUaNIvQcGlu00glLSgvQaMZ9fSUd4op7x3ZoPkZIuarKe+VprxtpryPKe+vTnmPRiN6
NOMdNePbfrl7s3Ngz1sii1JL9qQbyaLUIYtUk2WyKEWZXlIrsl1GFaWfYfFUEYfCEeWmq4HDEQNuWl+0
ZmPt8LOY5f0FQl0FIUcS51puNfVswbHzugPZzq/3A50OQMLT6VIOu7PuN96RXztdao4m49+xj+8OkFbp
XzTzFz3C1k8/1+bEyF6yugw1I7/9y2Lx96P4l4DTGM2ha2JvIOHBZoJYge2WjvKXG0sMbz6cylYeetVW
IdZ05KgnJk4g8ja1lPW0EXyjy2OW1dDFHgQU1kvoxx9/9Iwd8j1o2LtUTjKOmpXEiWudtecH143r5uOy
Wv+xtnP9x0KE/3G0fX3NBlsVbbHlpMC4P/i7suSiC+cBFfxI/3vCq/24UkxljT/C/Vp9N2r+WJisf8rb
Z/dj3/uDjWZ2PGYC/pk4tnxuDe05wBUj57sGiioqRR585YThp937jVn7cp5Ka+LP87s5mn9iNUuXp2d/
nl58uDr79eoybqtApUncUEvSFNKK1idFJsXN0LtRl/GK9cSr+gynrROay94aCG9oS8avSkkFVh0cN0Ri
X/MbUR9X2UAIKVsmHTxJpVFb3yLE6XGsQjcLElCKhGrbFpmYSxsaeLIzuD+7TVjrvH+rDYfdXRZTvmLW
Iw2ZBRhTOxQQFrHBGNF1U4Vfck95eqcsHXCLTSTzjONhPy6jdqMtOYlcM+YwhXx/ennp3n7+VHr6tvTQ
TQ2HcvuGWWyiPek7jzenclqzCybsCRFRaIW+qYstOEj6vfEJK8x3bfIhRGxYw0VG9FvkLkncRjniuuPn
AagAtC5FEZIrLGPYomM69jKn46xw2FYTvfaBKT4wLT6QsG/mekS1bAtPAIrx916ZexM7lLB7VgrMxQEl
IfEwBNqwiLfSPxoaAq3A40Sg1T8mtMAhLlUogJbyHiVmB6y6SsgGLRof7NSwGBYxvTY1KotG5cZGD91G
7Rw6qzSc5kQU9WnpS58XLYvpABibd1k/v2mvCL3DN6ZUKi1EXT6xAsiB4tIfMne86UyEv3UPuo04dnv7
aY2x1Qg7JqbTNH+R9/M2py93dpTNwwniazDt5ru7f3+urkxePHifu3Cf38y7kx6yG2pljfTbMLisdadr
DoBuQDZkkOAdTVSnvorc8HVKKKlvogKlZuYKCTL9opXSuxt592QpKkU7v/AgeXKOpyvxmRV7KJ1ED0QZ
04E3kezhatQ99czFRoUVTikKXyIyfhjo7F2t2PYq2qVREy9nPwfxsKXYhOuQ0SHKG7/T3HMzf8rpn141
DZqbCECOCEwngapPXf05U309/Uq79ApX/24XPVXf8SMsEdXfsV/ZHBvZfCfE/vFn39+Xw2wy6mZb/nVW
DfbVnj/34akmb7sEwaMJXMWC2nyaT47b4Ls5vWrQOGzCL2L/ZHSf5/td5axefq1Sfo/4N8lu9Y9swGZd
7ADyCOCHlF/no28LZbOyuFgMpoFfjzlYSrBPvHCLY/Yi3wTH7uUk3aIPNh2qE/Z3L1jHMetwgN/68UB9
1piwWC/uIwlyL+4V8YcOca5/HhPqP5WINVHtFTFxNMZTjm3eVx7axVimdCCxK87urqfG6yHv8/Y21lQO
p13Mt/bV6VW9q3IZElKjqjSmOEXN41JREG3T2UW7YsguPwiNXHy6Nu4p2g5oHjZWsY0GxvbxsaOCOITb
CB6ubxaL4poJXI5Mu1j8/DxD8B6BoBoqnG3ojYbFHfvuwYe+vVj811GlzTXPwFevmgXDfGM+81jt+I+Y
eB01GrV4Dyojn8HSrdX42ln3Fim4ICai7r0qK7ASm0oOyi0Bb4dfJdFN1Hs2mqgQIGFPFIsyDfvCzvs0
HAq9AcJMAA+Hv4hVdByWM5/la3vuqcgfN//aAl0dCUXbnO3N+gkWgSr7cccGqhy6QSrluqgT0oSOtYDL
fWucSWvQKQzmBMcCNQJErbdsNWBqoE3f3mTN5bAceLJHUO5WiHtRq9Frxp2oYoyRlwoNP+IM0sEnN+A1
HXvSNoS1bNX9VqNUujHypB1quarQU2FMzEpPg1LMyRIOncuSYV+EGOW/wb0X2Ri7yXyW6zgbAkLT+Dcd
ouOpKoagxn2oKgsTqI7ubfTu4rLgj8OdfQR7QlBIRL/D6/QjVOif8DcdMK5uLooX/7iuF2/SvsSbCA+k
fpx6/1HqgKVpv9lIewK2eBgj/QgTti5UQe9+2xT0rigMK4g5V9w7QoiPOqwghA11TDaRrCWjTBUEMI5f
p/YOwMFhALkUV0V7rfL+S6T/1bGqGjD7XlB9Prv3GO35o4XNFac4MLKcrI9Fxk76eOtTXWupLGV+VkX+
HZ3sy3upXIxWklLKf8k5b4iMlDhZQ8ESJlVYxTQjohOUpDF98MQbRCkkXMik5Vt1Y9ycTnO+5Tjb4oW6
6XcHdESMPHGm70d3+QS+Np54qUq0glm8U42NJlk+OaGe3qv7Oc5F9cKr3Jno03yDZAsxAbSf5fYbRxiT
GJWA4uxoAiH1ACjlaa9EfzuRmqOkSDGaKFZlG3YVRbgvG0MDjmuF75A2uKDVSUajfi6Hngqon272uPsi
a0Rly77Kzr0amwHengSOdM7r5Jqxa5y0XuhIrxmpSWaxdnhQbrRGY3KBtKVIoSCVs0vWtB9nrIEIcSWx
7yGWEtEp77GAik6xUReP8FSuPHUiyi2NRGHt09YMrvCh2yrKpR2sGRCTuwVpFKx4kUnjRWZmPSxHti67
mJljGxHJieRWD/VshuWGE9Oweey8iyh7Ruj/V6a9pSe6mOWlhSXViYRVjafS4hEQZkUYhEwB4XoTdqFW
nNVo5Zb/o0mS8eMOxMrlz7fZeNWHliIkeNbj1ZGkSDaR0srHdR+QLZ4pBB9JQ6TzgE2UZAMm5KZpaxp4
zUPPKjNXgpVbfjDDJtd56aO2NYFT4SSUhWAlQSZ5jQj8HpLpqVZ71ksnc86SN45wNqmVI0Cv6QDZxPHB
JPmUNTdwskXw5+wbXjPhodkBrmZDR9O1E1ZaPHNl2fODg+Of99vIMV4M8N2/PcAnxnHwvXGUujxP3RAf
VuhF7Pt2d/qyO0SQq4R4tqsCH+uAqa344HkS6fRwMpka1W07TqoePJzpD9sodjR7xTnb2oWiALJKa5Op
MxD5jevsutasBrm/Vw8UV0lEI6GVPQKxfuMZQWKl3/ip+TyvHtYRiOzAg71hEBKD1UZXByzM7wQHR8jC
DtXE7u7hc7aw69GkzkYvu/fE+efaZgieZG3trP8hDTiuGNE4BtgeVHLmXCfB6w59mw1P1nSgbsHWJjpW
dwAtR1XVmsBX16/6iSPNqtJnV6nz1aK9XPmfgBNqxfB/sFjbDi6iqQX7mdCPGmekpk/L5jjKtxjTJV+x
KlV/yPN4WDWSPFO2N4Q5adQ56kewLETvfn+vE/yf8e7uAS0VpFe9akx0K/1tGzSoDY46Mb11ZJoqGrCN
UzvDv9BOZPb1UR4FSRXrifT59LPNWerxZlZ1wv1WaPKWA42M6rKm45/LmgqRHkQDgwKici0ERedadGE3
8KBIgmC3xK/JSvxnLyJIZzSAIO5JvJeosSNqZDUpvkDSF+ADqCxlyV+yGg95z1G20Fc5jsgFO5fG6WJx
sJ46CAml8wYnHasSGcNC4oMjqps/30uDnCZYxYJF2o5nKm1/Hh8+s/39CvdFWd79t8kTYTYLHWPqdCla
SJkq6x5HSaeysPCIQGr3Rt50Gn+7SkzbFK8cjkjqPU9b5lEZyyNwOcJra+wiONAFwfrfm/UK52X4fHX6
ktDTb8S/hFxg7gjRcDVT6/VoPpmqKnwZJY1/NHlnffZxWaUNdNCEfqS4P2xyjDVNVqEcMir8PmsGe4d8
9RPqqEZ+pg14EOy1ItXGf6rbNjHVuP0b3xrsqBDB4dlPP7JU8GV/JIkpPah5hBsa/8VVA4Cr7rvFKSkS
e4ZJzS4gqX32+PMy2KvTxXVmf/16eGWvwvqmy+saI9Ogjn/+7wu/Ud1rBuqxqYZHO/trkJeK3LA+yFwA
lI689RwGyivi0NO+JYBfzSZAIEEQGh2rFL5p/DpXsr40qH+mPyHkuATKiXlu4QDFFbZElG7WcYU0CFf4
g/hNbqIaBzgK2qu2FwO2ucjpAQd6pDNCO0TnKGXDVk5t6HIQvfhtDmulVjXu1Xvg59Y+CcEjCi32Hz8s
ftjhCCOurvqHH1Dyg1diBp1AURvZH1s0hFABJ5kThWYzwyQLbml3d/u4xDTJ+M2whRP8AbmGzSn9gUlF
cEF1exl+9lWQMLcBWUd+2TrhMDYZQTD20NyAktfmp6GNn87mT3kkn5tn9SLsfyiP9hJXWWzvkOJE1n3l
xs8xEBEeXj2rSsTcKxm6Wgd/Yy8GnscxX7AT9j59Iv//isjM5eU+Q75QLzP2hfMus3eOkr5VsnjTtLKw
bKoVUyAged3nbKC7uzOpPRMI/5nkPyrqmL0LRMFXpbpqiTfj6qUSOGaAAj+geU7qe4fhYRCmRxlfsYHz
R8k5S4sQSjJK4zfYhWkIV7M0/pL+/7S9+X7bRtI2+j+vgsJoZMBsUZKTzDcBBHNkWR7b4yW27CQTiskL
AuASriKpzSLPtZ96qhc0FsrOe86XXywCjUZ3o5fqquqqp+xA/kajtXNEXxSt1x8iOT8iafLhNKCGzUQj
ogT7+RQvDotJghHjrPgGQRJ21cxLCn46/bCWZLjNNsBG3uCTBAABKcDbcKCxr+VPpOoSdhcyBLORhpis
ETs0yiQ2GFkpihHB0CpDaVsiMF+xEiNBstwX23Kf2UuTjquPtcEaGSyvVLccxmWevfDvMGHuf5Kzphve
M0ZvdyO99dGT8SrMLmkcTk4doyBjD3pT1Pu4UmnMrA5xHS0ar8aEKLGgC17XCTZQ9lijF2nfv+n6t12v
EeP6tuvf4NpTGltl9dg1gMcY0NUCbk4L10GAdEAN33XRyQIxu3dlIO17tlMkgtvcheoP8SWlhwD99l/Q
a3iSDBdExeCx0dydL4bLFYmoOIilW1o2w0RdD6fq7gjuH1GSnMomwJKh28Q9f8t7nC66wL7t2blymqTn
AP/jFgl17OAFAyOyqkfgKNrqukPEC07JuyqwZkWZ5i3rJT7MMDppnUzb0qSoYGzu0mD8jO8bwsZA7BzK
gIHnkTsQqm4rR8m7TU7NiQJT63pQcp1DwxnDalYbP7uwCsR5FUPuWv0rcv3rCRQE6oCOFIhwlm8f4C9E
z9NSFpWIAnmlK5uxHQT3ZmclOVuliSIXW0t4NcKFyt05qi79CLCJiQnOnbX0KDcTDje6Y57zHLL94XQM
VDXBMS2SbJZ0xZeuZ02+w/zk4ymmi3VN9/+kMzxQEcrNVYSaH5jlJG2JwjyyanIZScSs52WULfJusdey
M/O4lfiWWvyn2DrGEByKQDqzxUBRzkhigxY8e9lEtGtIhWNZ35jpM3KhcD9JWRonK4No+S5ChGBuG857
EQxS0MYvLSIWy4K2qacgWCXRYOPYnxArA7E4dvgq4xF7Qem7GW7FooQnXRuoU+84kQRkf0Ps4YgPm5vM
zQ1m4ySFiMGk6i2DHXEYWxlG/1pVw8edYV9iNDbVuaBWcNCgRhKMnkMSyLNECRBtj+wYE9YrZ0WkY9vf
jwuc8sijfMuVVSpxdsaaY2cuQwqLH0is1ieooUsUduLxZ+ztFb+VdqaRV+6CDN19TvP2ZrZgLSHxc58R
pn3a/7QYTmgD+sSmaVQ1PLeY/4ZernLQYa5/PWRfryt4OtZ6ysiqt7eXel3pnqKdE1qJHFadn82X9Oli
brkVs2GBcHSNpj5a1mfJnif7Wt6JqZehIM7tSJDe/ZxoIkJhlg5M6V8wl55+AE2T5Y3SuwSxk/PrlkaD
HpzOkjT48UiGlHePfjimHeDox6d0893/OcZ28P3h0xDc2iW7lRTaTV2/Sk27+a4eo+2X3kbNG3msjo9J
sB1NaejsL5FTgh4Nl2eTObDZrEHwACGdS5CWMcsQI/xTBGzlaQBXKjcNlyZw+MWB23zs0d92fzjpPPZ2
DyCTLUNlR4sQMyKFIC3SKpPqJXaCGn0NF+8Iq3HoiKWUGSOOUuH5aQ6JSLJWCnTNXSqQVCILUtL0TNxw
03wZNHyR9tPbuSOWRAKGkW0Gy62pbEzM0RKUAAsGEg/B23DepZEukwIdS6WHMLrw7XCq5Blu+SL8XEgO
tveQM9G5Sl0UGUXfgpmBcguCyqZudLOiW7tZV7pZJvnBZulcW5t1HF5ta1atul0WKKVSUnVDGkLeMqFh
kw1oO7vSHCPdblecd9CBd7OvJMnc2YwV7YNPaGBLOc6OHZS5YyqtJz0wt8PpVQpByrS5DA6SukZCV5LT
iR1vyIojKL3xI2PAIiHiRd6GLVJqRaXoiK33bUvy7iZTHSmDAi0g+JAPBAsR2eYKfZPVZ5O8+S48Jlxn
N0bPs2PIEpw8m4CVGinDwx1312u2xmFzGzbMgY6rQXwoEsKwQXlq3ey8hhnZypqEbeYndbV1W1k7UD4K
O4eSnjLvl6S3f3+CexPxBFAS8DKz9sbLcEJ81RHHVTC82KXylOFQXeCkxmpAliGH4rgME3ppCVzkxF2K
AS5QzP4Rnk3cSxSIplxqHUicY/769IqP54Psuam8TzTcjzOZi+7hO7UZw26zK7f6MZhDCe0wYvQBjuFB
nzDr0qq6ThHuBiskNyaIpSzJ44ghDKizzVKSoLCmUEd2Xx7jVDNI8R4f5PThiZ7sHXlZ9+bLD/rofOjk
ZBcLu4v78PVWj/bls1wPQfr12PoWhb9JAUYsOSxHvK0yBmLTkIJChCRkMeoqwHvLcD9vqS1eRQ8WaFn1
ocAP4lqcReIZnC6kIky8hSkCz2HxJSpXpw95xCdGn5oiDsPPUWiiuND+b64Zfv6/kXgbiQnVgIMt9a8T
fGBjS5iWFSwtjb1kpYVlIB38P4Afk0VQaxB9HbHjgvri2v8rpXnBi6YyRsHC/xDZdxirVxXGxD+5jDPR
HC7512vVcvcVkUZNBCTOwFGPviiFbpdDSYgoqqhIdrTd98SNth4YXXrMw1oV7FTlsSyklhfLxwd5HS+n
KZurLhoWvI3CH59+yFUKaq2jNiC2Jc7vjFEQewa/Y5WAA8t2WoxWYutV5Fq3HLYkKwy8r76u/Aa7XnPJ
Dcje42H7NdedtL6/uL8ictFJDGb9D7Nb2YnKD2nH3fm1eXmVLu7O0zEbKblOe9rfj5fzDqSAiqeg8fsm
i9Lxd9mJMQ+J7ViGh7C631Q0I6RV+d84lCERD/oiSsJ7RNL1naPmk+aTHxxaSn/OFjKoMv0+Ecls5T/5
QcS6P5zB3RyghvE+nJ2HMa1Etk/YBOeAoyAxbga247vvfpRq7qgbntNkjAcpI++k4ZFYdmlBa3NkUHPm
1N8oV8pW3mATQnkxC2ulIaL6FXlXK6pM8f5st8ps525k1ynp59eqrcj1UM1JWlUzdcsfGMIquslWa9w3
7W5b+kjIHuyw2bacbcM0xCm/f7F/8Uen4TY9dvb7k1J/n8y+uNpe+2UXBPPPyzdDSDtihOfH7sVNw6NF
d3HQeuq2/OOLg4ujp2sSNsSrbnhwvN77W4tyBAdiTNmPqZYbv0PkTUz4trUTLdJo3V2s49l4jWjUyXqw
WA8n/TWLf2twRWsEglsTjxpNPFeX0P79aQfSzdOD/lCkUXg/Y5tcv30kHh0veW7XJ1fj1XBOFTv6ynn6
SDjHB/L5UweICGmU4CXneAXni6cOnqvLjoCJZ/uJeXhM9/3F7Gous5k7643VIvfCCqbbqlC+tLNSxd8V
sx6vFir74mnFO39om5z2IRE5+r+zCVKSMecrbkkor6kjkMpvI2nVA6QEXegW83XEGfk5eoHfGIQ1/Eg/
qjcRLSwLzo6GKslvD9ZJsncPNIEYOqMuLJT1WUXAShMoU7Ft/NrkQlgx0yKu6pO05+VIWzw9QWaev38L
XS0WxSxKUg4HJM7dXzx+OqY0pNCS03t5EcBIserSx9xiurqStWXbOsOaO23QcMnHCmJkG07H2Yj0soqA
Hx6H3dY1FwyuyleX3HJ1PgYrK6FO2A4F6vPfpgKnEz5YFFjiSo9vvuWrjbjsShNWM1HrcoqmSZ0Nqeg3
GS7ZO6iODnw/Hd/VF+xKRCm0G01z8c/tll9223CB6SDIDo/qIlZ18QpTFdXlrKnDzw9Lst69Wq1woEZS
YB1kZzhe5uPE53onbmNj9DpSV7Zw79ml+21XSAL3HHdvupuC48o5JI9u/oXhdJAijF/C78y7QkJ1VIzF
tZRNuuyexeih6/W86+rTjne0nazXXQFrXYlMaSz6ZXaMk/3kK3XkCqGqtjx6N/uU0nSH9IvzLHPe4s9i
oa2Gq2pCy4VlWOxtVN/BIt3P95veNzJjdeCPEB/N7Lr/jmS65bK0fUThb5E62fuC4/uu9CjBGMSZii0J
/vk0/MCWNV2Dh4B8sOC27+k9UXOUIS7scKKr1QzcQwLvzKzwrDyZubXyMwzfZLMRUfEDs5ORt6q9l6zV
1g2PWxyjnilN3mYfpjRESLrqHKTcT4mGpdIMmUQukRG7OMsSltpgQ5JXq3TCCpMXsPdK42FvmCZQ0Rud
q+7GfBPiDPmqi8LMM2MGEObT6Z0nntAutdQ/XQbGn5c6xVSZjZn9IUQPafXmoDI0ee66Fjxk1JbM5yci
6h3pp5OFgiDOFNF2HCfAb5hsjOM82GgXAQXCGpEO4lQ+sU9w1P6uQ+wYlce6SQeuppRHJqNBipQ7OAJI
rmG6ZVQicOuxkYO08cSdOdM+P3tzdvrJYWsJPm/tNjWJzDRIAay5JAFbFk5lNBmFf6ZUa8hDfajB0DhL
Q8NQ01oFgNHw48xXgF/aqN8wotW2mmxruHmJewlCRJDBnxxKWGjAd4BCLYM4w/WLGw3vdeQmiJAVWK+j
vhT6O38el2hotkFjVli6KT3esF0KrR2KjxoB+QVDhidhmNmAIPVdV/7O4lZECxVm8MrbAkPCaJRh7TBI
j/tBKtVv8AB/2/VkVGqaM/DpNpiEPWnRnD3s0YTpdfLRn1lVnFwH/TBFfS1j2NkXR57f597rwY2aKu1l
psaq0F6HTehg/NRKGyN/ZCwONrK5WWutNloh47gNchfKbVciSaPxLPZfR8ICBGKzE3VGxQuyp5E1XnbB
lEeLvnbu7YczZHYYkWYJllklDNhzDIiI63UuC6MDcNS9XEa8mLqwakUrk8qtPtHHS30Ec4EEJxvoTGZX
yxSQOMAcTGAfhoRxGl2DIzPHYb9KL0PsWNFwulyvTcIEG6r2n/tJHX+1ank1qCTYPzKosiYurcjIQ8rn
z4f1UMyL0WzSBp0ClpLr9c6OS3vNEYfQ1wVh+zAta2WXbgrDry0t3Nvb+ginnkf/8PKuIZLAxgo0J8w1
0VPu7lHF0WqADgcVwojdZ53ry45mxPlsDHTqNQ3HBjrtsn0PTNnAQCSfGBSJDVdROebpeq3AcGNogUa8
zDdKQbrs8swceUK3SE6GTc9ow4lNmPV6/jSmGZ36RROsCDG11VFnZnhU7/EBFb1HiQgSqa9xiKczJ8yv
sBbml+Fq4FdMDtiS2X36mrmRBccZOsfZjX1YkLTSJsAHFqtnKQ0IJn/StHGL/FRrfU5BS10EKQJgEz5R
x+csxTxQm0Vk0d9c/x/lpm+2Z1i7RCyZOqzWSiyDpnqqpxw2mqw2KO6I45kTw17yha/uCBjo2006yieg
eFmc6gYe4zl1TbkGmsP5DzSO+83ecLFccQnbBiQqDkctkSF8ANRQqCimeRQjuHqgy7eGPcEJQ3no4txn
RIb9zXWynDJ6lViFMklRKmtTQNTDeqsiU1FxLlZ9NNVXmINRYQ7SfGPIQK1H92da4JG30y5JqP3+WN0W
l1sMGKK4kpjHmpgnwR3DwsIB4Z0M3+MFbq8161LpHt/zgPOnVExItlTMPtQrTSDa5SWG+jTHO0p2JuLP
VbRbf7WZ6eVnQY1xiMPI7qYA5XO08nzNgVfMaA7IBALnVmNFsCelqnX57O5T1Gd1anUyrJmx4OIxyN1/
aDgWw36fmCrpuV0aEcUvBcDwWfHqitVG7s4QLdbs5IygQHwER5pPw/vtaHXMeFUC1pXj0PslFTofoVUW
sSkhFr4QaLKfKiw9n7oxVsYk1MTX0h5HxAw4AreBpEUfoI8tE+ooYosWtsEpVrIJHd1ja51N4fDT5j7j
jgUTFUsGyZhyKjtOmw2FKecdQg65/TCSjNkIgTHxovhCD4BbTZSEmB7Pf90lZrCYyxBl5G71GTgQ2tDs
wKFL88jWYdFmlXt+NS3n6PVgyWkDVt3Pr1aF2cgN+Q/mBH8SZvHnYeIh9DAD6ldsDdteqaR0GVZiOwor
XgqUfaLM0bGsrXnCXkI3q8u7WD5u/37hdh5fuADgo2sPqlPvYEI1hwfiQCxTBc73Bxy8zhst7+JIHqTM
oRp2Lw5wOrXrrXH1uH2xvDjvPG5dPL448KiUvqjFrBq2tBfiXcop2hLAE28TBtdZzK6HSZo/C1X4XEt1
IpFFhTDu1+WTT1qiDWc/w9tgW469Pafp7CBEvDF5lqz5uxTmJauYquDj62KN7Tjzgu2EKXE12jkc9myq
NXyKC7IiXcTDEudQRhrSCL+FN3OIR9IeR9FhLx8woPhmAarIRDRyFMbtaTQed6N4lAMpMj6J95IDzVE9
NjNAWDreLVkPyx6jgHVxYWqgbYeJdKgtmu1yRnt7tQROnUIyuwWjCLUZA9+d9nuwJaIwx4XkVe8VcNNK
nXwgzdpR820Fa3EiLeSloXxmfgCNRdHuYdZVGyTIdEI0YpPbnv8/lT0tl62NBCo6eEvLAi6lj1JGKAWf
rjCs/Bc4bu+IP2WMJAgyQxYZh3F2xmutJ5oBGm/u82L4k0xeOJIFu8H6dm/5iOePDuNtqmvvYCjuYrV4
aQzmM6m6FO/5FaIVrb8RsXAvWnSNKyLXf4NdGdySRO0LEUfgefr/PBSM6+l///13okcJT4424lxSBR1t
nxr/2Sarn+ybZ7FNcHd3oV/5AVFtd3cVs4ibqLv8vBj7qy7iBMsbauvVYlzkXGxFjIb/W4yDKHyvHJQg
57SPOnt7/BQoF26S4gjy88dXp7DynGLWR/KQ3UUITWK1cafekIAdLtRc7J0qFybAOSjtB5VmKxgyzBDZ
en1L7WdoEJmKS0ph3A6Vjy6RQi30T2NOiWDVVbBibEWW+6pvlGyM9WH5exCZAa4Hsa0ahCS/cJVve5GU
KR/3Qz/fpbKIoMYPj3xlSrVeD+FC4kknGd0mkXsnlEOgFaWsXcotEvZwkzrROAvJBG/GYkmRLEUS+nPq
s+Fyge/tO0U/dmksqBStccvaQk1pAEEsJtCerqkxm/9mQA1qZBmgRY4NLitBQUoDRN+hJ3aRXTRTPtw5
zCuppHOxJAkSp84TLxj76yYSP6WhPqq3+BlYaYgPlY+YtxMf4qpn4ItEvxveO+gvp8ya1qXYUAPkWVrx
HCyu04toaKoeEnUwuAbEuToNp7g1pIiOkyh9epjmLOW/EL/a+uKmXitppH7i82XqrzZwk/kLBblcUOIf
evuuKgMBQp3HVYXoIwsu4LEsh/IefDXvgcn796/m/bvJ+/tX8/5u8oYO+pAm9VffgVpNv7XzDfl3rPyF
7LXq8q3iv6F0k/v4q5mPTd6nX837NCv36604zlrx9Ou5n2a5id38Wu69PZObtoSv5YZHji7760VnJT+Q
V2aSyVJ9gKEpvmDWpcxDct5H2oWnvnMBe3n66TliQT8LR9RW9Ess5zX9XDtwqPXpn3jkPPLp30b80g1L
vL06mwmjTfBLd1uAvF+6xErelkMu4JhG4y+xIWSo0D6J9qt4J4iPczqgsXP4rEC+Nhul06XBYuY3j02B
VmghXZR5pDbL7DU+g5S3S9e5gA+xp+STKFEkXRWTbWkqv3Lo1Y/Xa1NO09G8RD7XPE1HxG5nNaiHpaJf
wWzQlJzll+ml7K6D+ITtTlMEfkt/gewlFRWDP9bPvlueJ6oKaL+qZY8ajWLxjHC9nMMMzzTpPveCts9m
bfW9ilsTDxrWV2vdnpX2xBNJ2FfGS/GgA+cVnHaKHn7jTtBrud/6KbHoTf2e5iBku8LvPD/99iIiFJEW
inji+cm3F6G+BAUlhYKOPPmUmZkz+FW5zmcS+ufSFgTifx3Tk4TTdFF3hF10VsyRt7GXhR5Am3eTzYQS
qkJVsS8VdRoVRg8nbfY30bfml3VDNUmD6BeY1fX6KCfnymZHpeXZemBRNiJGABR68VS0yzl02HnH+ZEI
e4Ss2SStyl53pME66Jy+Wpmrqbm6NldXh4fRId+hdF54VQVHqh1f0A74A6v739T9H7rAXVPW2e38/Txd
RDlzkazEff1GQ13kCQnU39kcKhF7NtHIujKIQ9gVtJxl3WlAreI0rH526m2nUctGIvMWR1mwlvKp5xoa
NnoMTDoSsRa0V6A68yJQoDNyljNTMGHuHEeoSDWyYQ+Tbm0k8hDpZtpNtDbMPll3UkIiSiNMMtsXFTpJ
kaIh4yGxeYt6zxoTuA+Zly0qaGcBTlVaJPFQwXOxRijTHi/7R4UidyrLJB6hXCZNhJQYrsoypQykZKQC
bXklfXLrRGFY4HUU5VAkexM9DmsqeHAFYYs1SVRYzz4C1inIAFz3phViQwRXAmH2qep5II84MR0SazrI
eMxi9JVpMfrqXs7zIRyZCSF3zJFXnCEjz1NZWYdulSLiRqg6VfZvrtvglORJqwVrMve+sbE92UaXK0b4
IaOcTPcTIu58OG3AlyjNs5mjXgbpXt6Z6YN6euuW2ZJQDWaitkj2yux3ywD6HsINhjXedIXB94YVVgYU
AYHVLKdJeAYAC5sDtKkBF/farTzlmSjW9j5aLod9axrZrO0VAmriJECa8ght+rpkb5XSpE1YVbd1l07l
99N46z25KlPjSGbr4zREZPzfFuV9iYwhlL7BpKDpnYbEUJgA3Q9Suv6D05pKShvs6dzznCtMnX5LT78C
2bY5BZtt+AHgAsp7tH2RRPu9zv33m4MhLYvaVspxNR1Ca1ZPl3E0T+vti4srp9HDrpDnbL4XSSNUDiG9
xWxySl8Ar1uX1RivaPn1BEwyiJNqhB/Tdr+zXvdl1xgX54sL/i6vZ6YZpqp0Kst18VcIVipkT9Cc/yuU
K8lA2zfUyH6eVFbwbVT0ZDiFJUf98moGf8jYoNrbUpLclCXbhJ3ToM1KHNgwDnJSVLIJet3mb2cf39vL
J7NRpmVjfQsAVbbKXL2u4P7fInXVIrsrw6yF+MsqVJm2hDk36wtp3zxU8ab0AOjDkFIHDZf1iFZxxt7y
C469+NqHHZiYGFqzY66DyCI6O9mNdYg8Xwwn0eKuaBweGWlOVgxKC2UlJ8kep8k5nGqVJUq+mqSUySnI
VPr9dvY+Y40+T+Mx8eiyzupX7rNXpGuVa7m5K9qh8kL9TAS/N9Xbk92H09mqHtXVl9azWIZ8ymV3XFzd
cbG52Ri6RPtLrdA/gr5RQGINPLkvxTxBECtLdpvq4lMNgEv7toxSSy9a2WF6kfvsV1g9UP76cqOtyNgb
puPkJI7pwzhjmRS9/en9+fmrZ2/OHCvU0Tb+V8fyAZ+6vJuuoltHxGoDoYscXeTUSs7XcJdSwPmE2VqI
12qO7nPrwMtqv0pnqWPviGUBjeZ/SYKygEEPjysquM/Af7JSOD4Dagk0ySTyiv6WP4n8qcH+zqVHlMwR
Agx+xybT28pZsVXjpKcEc9H6mZeXjnUYZyXCqRVWJkJqAkZVM5+oR0Y6RF1e0dhAWomw/wiLmfegbqYV
8mJabVVi0VGbw2CwccmIGIpqrRgIWemiolwLBtYqmS0iTMm4a8X84yf8Y9eSLVJYNmXXSa727vB/VTnX
KnEnt1RZy9eT0fdqdr3dCdhEsmo+IpyyGQhnQ2TEo38B/WN3RBV4rUx8PbGTI0KBY2ajtGLTgHY0uwtx
ogxqgJBWwwZTwBgP90NYISvrHSnIepnZMOyPTEu2CyhW1HEX0VeVlWiu1euMzuvBwhgRNRfWJ7sFt4RI
t+Dhynl30AKzYhZcZdcukQC4SfkXSFoHK5/1uv0VXlCzpGFrVqU4xR4heKnhXyfUt5PMeH1CfTtSnHZ7
Aky1NDPQyeyIRlmctTLrkiKArRWQt5xDbrIsFHAMEdgKmLvSTq/ZX16j6CqR6JOfJN8poQMaFamiq8jN
ZD4epsSxmNrgIgViU7U/QCaSOwRRonpMbA426m6qXmdex8E2GRebaNEhi1qodkHe4QdsjgULL/Xili8f
z/rDOBq//6i+vciFQA18r5pgdyp7ACflaZPboDTlc42Wxy5CyaR2Fxo+z8enbwoT3rT1gTmv8py8e759
wX1txdlllFZd9nBLj3JcAQBYof5y7Xt7f6n2rGJd7pZq2SCcUoEbVVlxGDp84iZPAeXZ3sMtyb7Ebkct
q2lLU6IkGcLRe0tDjh2cz/G5Gx+nPdwI+7vsZuhKHpgLyg1oGEemNYWmNBxGTQwebEGxGLsV+WcPtOVK
05diExDt9MDBwe9XmqFKsGu/qlzYOSYx+1JPqsqVIOB6fpHq74PA5etXQqSI0Iparhml13fM61e69aW2
+/kmYA8znPsW/YjIExlPctwpFEfJVsVRmblRpmTmyHO0XkdqUy+rkFJpkuWOQjBhI48hkRR9TREfPDP2
v+q6Iyq6rwWEOKdhEpYI8/XvM3tskJcqO07VF9kQeHxDDZNcopgEo4iaFavegKLYGGWvApjMRm6fjWRl
DrajhYv3FKyk+oCmjLD4k4xAtaQ8NXcS9mFGdo3oX/312p0ASS9ciQm/7NpfKB9FGw943X3cZEislV3e
g4GddNui1uNL+p75BNnmKJeYH5W+PSr4uLDHI2DLnZWW/m12hSKWUysljLSmJpt3zwHtt7FDMsZ5bikQ
A6u0iznNQHaAUOJv+OM1yRgB8moSxsT7I93vKcT/xMbtV4zUNZwBBx3OKFLVMcGApgT04BP4plK97kQ/
U7EHUiPpDVhMHDQtnQ+AjiwhlEY/7k0dURvzVBrQ459ICsTvB/r9EO/t8XVcfKfnCHplMwoHkrdrqV9q
zcjzAYVEUucIIHOj9hP8+Q5/vs9c/64xi1XD4QZc0JyUtx/qN8AL8IB2HhzQe83oSKEDoCZSS6+CFpWW
ZGRUxJngI9EMjrzNt82B6nWck0e+AdBYUi17LVVpKOOM+jzcTZu/0k0b0021fD9JOQMRRiV7u14ncobl
e8DPrYLKDr4fpXd+IoPB4hQdgWL+d929+Xp3MxyMlFIiW0pRCFkRSSlB2h4A/7FDs5gbJV3ZjDiyvful
Gvdn4DaIW2mQt4xhjtePwns47foOTFgdcXp+7jsx4L8+f6REDqZrRxD2HSu0tyNeU+4/l85G/Df8tRgv
MaLiX8aINfxLUxvVynh0ABybVBoGd4JXuXS8N0byf6qTeejfxaHTpLZQD97Rf/6u6+iwDo743hPFpCfi
EE0QheQjT7yl//zrruu8nU1XA4cTrHt+i1J2TcITfstKOEJCkiCFQxrAV966o4cvX+KWg0rwU/uWHg8G
9mOxf0RZ7KQjmTSZcKXDKUAAuJx8ApVEbAylnKc0ERKZJZ/AWZbyrfEYVFKmf+eJM/qPv/t5dOfwrbnj
Poiq9VJHT56yZxM31YVR+snbn94imJCvL486G/FbwcBi/+gxvwZ0lS+zafq+11umq8xsNQpdDiQAs0vH
8Rrur10Oj9M+PK5Ram88my3oSZwOxw5J8gf/oBY+8RoqF8csiP4uE0G6X7GTSMtv/373Nnk5mCyj384e
dRremtIecfqjzvrRI+/xI046a6zvGuu3jXXSWL9srAeN9aSxXjbW0fo3z4Nt+YF4yQ4p+62LpLF7ELyu
nqqYqS9SxAt864l/88WryAve5NcBW8kqT8QEeSzcxTNHKMP6QvcrzIqYV9d6HSv885hhbHVoSOo5ob0v
Xb1YT2cTuVhfndV7w1uAQMqA6lzU3h5d3ALU6KW+Q8lekWMwHEwvNNhr5z//W4Z9TdWZYw6HLZZAybJp
xKs7XIvPt75MDWKJRUsCzShvoxwz/oXbw0kfEJdtZzaJZb3xxAuFUXPZLTiBsZO5Blja0QiPSThHLML+
PiIhBy+A4FGGiLsnaWG2gNx7dHhYgMCMJNMYaRjEftFbWoJ9A3Z9J5KNlF78bWe5iGl46C89pwv++ipP
a9PCiFsYP9jCH38sNDAPVA186kBWJRHkv3Hg0vzAcUwsx0wRBxjvGBzwvPaYEkss/YV6Gc5kwXev5Ur8
cwgLnqD53OeQcaitLxDkFacuusG1iBEnZXYuWfao3NLvaOwtWH7/hchj6iPBgvdWt4zDrq41NLr/YhO8
z63QVG5vcGHBhy4zhB6R+Y/JBfwxrgC8tf2g7O9X4ydDnnKwA2FWPhG5s5NTR1EAg9HzPi7TA2si5KiE
kmkYaKEZcaqWcHLEuLCcWuX1xbFrUAUDqISAFFh23RT8s7O86k6G9GEjsEpYvbsJvmF2l8Mej+1j4N2o
9O4G+/ORhiafyIjq2yJCiBoCc0uC19MBHwZ7e1fwVRoIwKWCok28Bxo0KcRcQMzBrIgVinhNk/Cuq9ct
bWJpEn6Mic9c8C82xXP2Qeqt5mv4FvGfpefDGRGoc/79oTjaXNw8/pfXgtOi5/rtw/0fad+h24M1gK8v
bv624zdbjXDv7//audi/OOhIv6VPKLgd7X+h/Dt/2/373qPHjYuDsPX7H/9zv978P839TuNf6nHHVRf7
ncc6CRU0H3zuPd49GIrP2q3yYn99wc2iHY/+UEKT/tLWIJ0sz+Pwng0TTrpiWjRm1Ij4mGwn3dw9TYkt
2PyGwqU29jOr69brz6nG7jagP3lwfhNBtoZRYNimSCHitCLfipcVcRMqX0W4PK2UICLyHwTCNg9/TpnE
kPRXwOrn8orI0xXeNLnPAjy6wz5NJL1NhlOOz1NF7E27OZuNLZ4yjrcj0gJU9tMQ4AQbUezoCOJ4qaHw
i0wQdfCbWhDdFluAo+hiC47/cgu+rQdllXpACrXW2IGLkd03Be+6h6ZjtAWOnCpisadQy3lqY8hXtTsq
T3Hui0k0/P+hTVxMqVWf/retWkTJcFZxLA4wf2byoH5jPsvBrSMGwEncwpQRTQcqrAL/wzFpOahCWgiq
kEgRloO8ooXlMAN2maHKDpydLLTAhrHfDXA15+AukoUxuAq93p3dVnypgqzgsBNXEg6M2BTcv4AfGCcE
J8xmAs+CZNYT2hjops/RNbf1xLd8u/1l39oB+e/OpkHVjIl2wrBXORuqMiNaxuZh8mzcAnuwJdyIwTBJ
UoA4SOBFupDbN10Q15Litwe+5MWGqCexTd0oecUBMjrizxhsVHcxu1liLRP3NB32emkuOHkmU+bFH4Uh
6Tutaf/tLIF7fK2Cy8XKwmH5edx+S1wlR1rp0ApWylqdSTCtot1c3HBkgH0m7o64lXcqApAj3kd8rwPq
OOKLzMDRdhzxCz4w4wHT2zhlrbWC7chxihb3KEU9URV+IEcidGp95EZb42z1cxjxaS68Fj000OmpHYRL
Kal2J+hJyc3JBDPPQmlZ3HwXvVM2fmqGGEcla4JlaXj/lGOIaJhg66Edl0immKhF6m0dj0veWiG5ZIIM
8iWpVCA5RER/UzOC8fSVKp5F2YEdv0NOGo7eMZV5EHBCpSOIR6qPgvVyfKGbsX21SUrsKNcG5bBLV1iF
0cZouXNYocSJoudODT+rYptNw0MxV8Ogw5vRysxFHhtx5DGZZ0u8Lpon83bUoQbsMB5Xy8Xt3t50f19M
EaOLOdZ8f4tif+NgjTIeecUnh/k3j8S00fDEnHEsYzFiiCQxLoWO4rc8jU+xLdZV5Zwwk4Z4vNJkRzSs
3Bx/H9mVGLKb1aLtV62ZnhRqMnAYOniXKE7fI1FsyHuOM2Y1hFqm+kEF+fIUzq9ZSDkxPwkjF/tBUFyX
OxK2tLRcEzGQ9ou61IqVl8cuWdzdR67GRQeqEyrksEMyogWfCBklRkFbH4cTDXFaaJ05wbq0KYKgFhpj
ptki/xYgQff3Ay8Ok3baQQS2y3woJ0xcOymsxeJSr0vXs4KleETC/51UaEP0ftE2S184v7dYcOzYkvQv
aUmbk2MSUmmTmHLQ7LtuOTYg9dhW6bJflC5lOKmNeKUVfGpTM23c0pa0cnwLmzUzIKmMzzTty7xcnydG
8QNdZG2pW6pnNxEORSeBnEGiZffYM4wjceos0OBY7KpXFL90PimA2dYt23OylBdVMzc5JuZqKg03Ocpf
xiRmJdkWEm6ai1jFYr54+dCc+upwyb4h0epAx7ZSYTIwMBg+qM9UeCvG6sBBlXxCu4lwHmTIsLPdmWA/
jBQYAaBNBwTq5aHhogwdkANV2QiBm28VwhCBqBVZ2OP+Sr67fW/coW1wRx9ncZ/+yloSoDCsGW5hjfgh
uwfidVVf5/SttWrlt2rcrzqqFnWhikOWG5KeDoBpxAS9TnrmjQLCJt7JSKHOlevXYpF65vyZhHe0tMst
RolmgwATCeQKROr1SufwkUKD0EGNdE6Sb6b9Z3TjZYRaJ+W3E2Z3aQKGKygdIq0aHzO2lQ2gUwUBkjNX
ScF30uYkJcJUKnlVnRpB3MvFpMx9W+kTYp43Zk3mC3Iqv4Jb3xG1USLZ7dRioislh1Lnw5X0Wzs/Ucx3
qeV99dUvV5Ox1DaPwtjNpyYV+6cy5ByxTySiwGTwKpt84LEmTmJdeSK2uCIqz6Xym/JVOcc6YpKE/+26
jjySm8mb9wkRNrqdylsE3+CTvvm2CckihZrFiOg0i0icXWFq2bwNOivmZ7yTXNIYlFerxL6XR896Z3X+
5Qizin84PES7xwwB8980vO+OrxbswDSLr5bw/gHQP4vU9aQ7lhcMQItQiPLqal43kLR1DVkrL9DceoZd
W8/AbesqmiJ+qQD6y4f9dSm01rn6OhpTp0+4QzTEuoySWB1DoPJEZhzjRKZtCXYIPalQ/Kvs9cuDYZkd
JW6fcbUrFiNmsTxwsiZ2YSP27sGF3++y6h5++5vgvylLAKkJhhlL+ncCJDZEwoyN4kLPMHWcsuIVVyGm
mi9ZLaLpMh5fJbQtGhHXDPs/iHgr5zK2TLAiyTlid3c17iI1v4taAjB3iJiIQRDb5O5VL2sJEerPiBXa
msAQLKR80/TGJWbcDoKMid7WkOmNRicsHYLWibWso2S/7jRkHY0ah9YbhfcSlTNGfE6J/waMX30wwbjG
JC4BRW9g0ORIFOWzKTGh5ElTc4f0YKIewFN3EJ513VGTy8cRLc9YO2Cvdz9Q0UHFSL4nB6gjrnhkcNKA
+bZS9PMUAXSkZiEezBbnMdZiTtOg6GdZ4VCldjk9scby+8JYVo68tf5/BoLqbF4+qGKrRim9j9DTUy5k
vR41l4uYOm5EcxyxU0DxxJhuEbBhyZ9SWhRUlrgUC3GmQ09Su8S1+Chu7BVxTX19nY3NtTqRXEGwssdm
pR7UPsLfQg3HR3s4rvVwXIcfxUeZfQOhQLMKTAJOlh8zUxl34uWmq9JbZGXufHHHRN7He3s7fcWY4D7B
9nAZNhpXQA7hTYHIxD3HSIJlT3N5JX3NCszhZRiGV1kERrkegkVTz5EwCqLwrBCwH1lSg27IZx608Fgg
JWntIxw9qWkTEERiH3jA8pFvIIfLtiPqoNdkDYa9C3Kz9vZucEyPkNyVhX0kDjvFvudgSWEdW+22Dns7
4j88/zXaYBVl2jaP9zGRLVZezb+SPtGsi0Ruyz3TEtoiFcy79CT1ABuJRl3LrTZbMj8cfvs5rUQ2tyS4
V9PhSh5tixtZsL38Mgb57DvKcZtYJidiK4+XGZwe3G8ONJKx3VcnRakmZxPbp8++mq6IivUVJ3jD9ro9
yR7aiaCBfaDUEoOxXhOVhx6bP24iQ4BOwQvMARGAYNbnd5PuDF4Dl5RC1NjcL0lqQHkuLJyWXsttQmog
dqFf+K6lDq5Li3fcfuvGJtyeg/edXAQ+tpdaSsN7D4DAuQ/ABsySkju2KwHSH4KNxG5kCkrEvDFiKJJB
49JTCv0tOhTrXE33xUia3chgiyYOueMEMQJSjNnYMGrOiUGJxqcI27o/yMwup9ROHp+dQ5uVZOnEYp1p
Zt4lOf6kUvGsZwarSz+mc9ogDXv8lX2e5mBub9iytStYDCIsyrQRzLOsiabHIIsIDfRfBu8Fwu+yMZzS
nyzFbfl0Ty2KR/Tbvcs99Fp8Vk18sJjT1rCk/eBKPAvvd4eJ/59oo6K4SsVw4jpDjuNcGyDu6JhEcdrv
x+0nncAd0+93OEGfkvRD+/W85AdP1Mx91r7qhMQCPmuvEOnmmYogGyZmiOijn8EHyr0MK6XX/0QMOrus
PMyh2TSmTtL9Qh9OH7p7cQObtQvXXNMXC9ln6t5DEO3Spw4T/tg+iPqY8UD5i6/kF2NEvkids5y/p9jH
ZZNGJZskDOM47EE7NkX3bsSpuBUvxYl4IZ6LO/FKWbT/xEqH52EkXoTz9fpSOo/z9TJ4zrEfaJ94KaOv
REUwj5cAodl1dsKXGTLo3t5zqad46QXPOU4ZbSmn4XNjqBy+UpdZGuroh4dB/3gU9GU0mJchTr9qz1t9
/3m73xEnYdR+SR8TvnDxFX1PPI/cqXD+h+dZvXv3P/UhbUviS7GNU8+7C7+0px2hcDr5+hn9CakbqOjw
zmBAPKt4WY7Pwn1VVNtEMn4nzbIv7ag5TDDRiNLTSCZXc1h6Dqjrp5F7QgSB67mnKT7dBFz1ztHGdOwX
r9RodKyLZr+EdpO40DvNhcaK7elDtdwvRCna3X337z8+nr19//PZcw6hJu5kIy0uCivpkHt8lA2A7vh7
2e261wPZ68FdiA/AV+wD6pYWn7yUjWrbNwYwSEZkVvV797ehugym4ThIZvVpOM2B9ktzbdqrprnPIG5P
fTvN5Z2QfU+YT7Q7hRmiayIDWI86+12xQdJT8Bb7nGS6bkEVTgIQilsQCpqxt5pC9HHJ4SxCOODzLbDI
Qvi3n+4f4X4yTJJxGu64Out6rXJxQbMkkc8g63Epbh+RlQPVE+v1xL3Nj2A7+gYpSFJkSEKDBstAcZ4z
1B0R6YrC20B1BqU9o47BZL2jredL+ExtQF++JkmWtU62yHc+mN3kw3y0P0cMBWbpKhzf0Toep4PY8iSg
D2BbrhRIy3wban+1ES+prOpGmGr9XHuqGnHCrFwF3yfrAePHYesKwOgwrZBnQQs3KTyLmzGJAYlgBVHA
Ct+YMSg2zBh44tlXxfg8A2hxx+eMs5wT7LIj7+LZHeCVAYoPTU81L215l7B3Ef0ZYBPIDzbXuV7Dbq+k
6qBtnVa4JDDzcKIJzPR4HjQaU29CxC/DdJ+aDOaN2qD4ioroPqI3gwFez2hZgOLCy0CL5pd520EZFZN2
CTZZHGVVDbJLhrHoya5pOztOI+nAXFHdt5yOp7Qx9OmxPLPJE94sjoAmKwMdJilImhlf5qalsCw4hFPM
WqA8tRhtRWsxMvNKIa1x1GI9VeLGgzzfP20x6vdsplSeiWDsU7sTzDD/Qqx5J3zgGUIRBQ88Vw47VmN7
QrVWOsDQTp6Etf+bH0SjGNo3+SZTwje08YXs862VyUBplkHDJ1MYrBpmizlNHgeGDIi808tpBYh+8zlc
Fr1ISQae6DFpKOiPHiYQTo7VL8m3TM84oOIBkT5dMvAJVZAXuFjBsHCYCDZzUo51NO9+S6Xw8V76fsL/
RB6UWhVCe5CX/becBUhhplaQJqTsEC0LMoNM5pDD1SJFg6gHEg0HLv8+ZkcRFa8kl57nya3UCzan/Ysy
ze6BQLQB26YBBuoPWUq1HRk1hDrIHPB2CnTcMkrKLNmlxVJxh5JqK/YVHoDdJ3FeTIMJn5J0Z1fTJDTW
NJQ6nA5XJYEJHMMUqGATnMXIQQ5tmvUcztCPHBXiV56sPSJ6B/X6zmEwtk0C2EiAg2QiGNbUUDLwd5r+
e5ugNlF3xeo0dA8Y47lKQfg+ycMDTl/k64sUMpi0Qvg8HU1nN1PzqoevqniU+744dFrEVbHIR5xVywmm
6gMCtrbnlTnFjUqdKp8LHR2UD3xQk2l1ldg4KHL7MIqJH7BTqG75C7auKErwSn43tmmD7Ng7qbJklL6e
idWVRBntTm+5J9bgnWRq2ph7IdKG3Xt7V1W94fl3PHJXLZmfmCAOuVc1SDQdlO0mb7RfNd6sbhgO+fI2
nVyxJ/dP0zFje+WkwQOdg5Bu3a5r9xFUT3ET0cVctRwKUddiEzE2/KKUw7Eyq0UrKg15TmBNnKtlvXZT
xNnKJYrENrUx5q7f1mUGZ+mb22+glWJjFlzq4ajQt0YraZlI6rrvHUfGUqNNggheQmJyDVqgm2AJpWVm
hhSswiuGpG1L5cdJOG391nVXnr8SL8QbcRu8gTrkFrZo0Kt77HaeK0Jc7+29cgceY6je6oFsd+CEjFgX
xP/dHBuG84YEYEAOhYP2TUfc8jZ4zYGbBFKUGYwpZuAFNyRZoWmn4nUgqzgMXoQnqkBxe/wiuIVUPaB8
1Loprk7atxJLgDGaB1aIKY1rHrwBVzvYvEFbVu1BJ0jCObXjDR8yBy5cjhMYpagr9tTWjudecNnCnLvR
6+G6dc3v+gv+geL+Grh49P38scCWkF9JzZFZPT8Jl3Qn36BuulmvEy84DcecQBdf3FOvdQr71oEGxkx8
U9O0hY/0b8U46qZj/1ToucTnnZfU8DNjjVlbtiJMBGMUhJJwsMSv0oV5d+dm4/k3iJ5Tyt6qzE+8iEdz
REoWJyYmc/Dm+CR4g2FJwrj9phPIXiQRWT4/Dt+0XBKTNAP4XIrOrqeM7rkmBl2SddL8we9GrML2siPu
FAYEQFAVM7fUXD46fxXeUaViSSN7SD/y5R1IjiZbviKVJcTYnvIpS3CrPupFaCavnmsJzd7bjnBvqPzb
xhE0pKfhjS5Z3Oj6YP+Hq729U6mLvtHVyF8aduIAOd8wQSbQUCRxgidOwRrqvuZsGcFwT0s7wU1GD7Oc
nqh9QNHbM/N0lfHeuRlnrdfhme++Dp/pQfGa8jyG2lQqx6pJdWn1M/5+890rNaP1+L9W46wyCJpwzBxn
k9oURczvaetUhUB77fnWiMqZ8JoyhK89SSwAMKuG7+lt4FG91HzPvKL3M1YUmtn59E3g3cmcGIFSZlbc
s2qZqMNSqaYTT+sxf0u1Tn0JWQSxD6UVdOwOODbVAPZuJPkP2t/z3T+gcx20f+jgKIjyqDBVYqHeaOEF
f+KJK074Px2cvQ7a/+y0cPvPjsfh6MRd2G6bHu2Jml6um04nOAOn6J55ROzFWcm4RTK+2RNoMHtGYOpt
2/zSbZsfbTx6W5G7wECMxZy640Z8EbdyJ0GPj0FWl+Gh+BLqvg+Wx1+CJS0yGZ30Dst9Hh4RgTS4EPPj
m2AO2kLlMHmemzHy7BWDnWAg+ZIAjmYJk3xWmV57eiu5PY6zEIBMrGOsbUmtd5AdK15uS+oxbRZjOX8X
nIsEN40bC29MrpAEDgfgLeNwlWEi82ZESUxfdGpVU+SOBmPSQoPwPskQsl4FHr7Jt03UrG8VJm+/wE6M
YUkvvW/6hi0bVR18XEmH1lJ6ieO536hxZ9/FDNsjCU+AF+Pqr0NA00PRzzYLHSs+kt/Qo0lDf3gnjMxB
X7LZoCGXbMTzQFs0HIvNo+BNgKxPsPC4tfNwgpjHkxBJyvp7pAHGUpqTMMtQMrg4g7k7TtCu3RLOh+bs
PPF8y2OWqJHhJKOowUjtLhzxD0fKKgw2zZwXtJXocxzacEbyrIYnz0171FEc4v1VeIY959Id6YkwZ5HT
nYjamTjhnoLZzcPmqYcWPCdNhWVLyjcTz79sjfXlQF6IuTI8GD5sQikPeu+NfMtuUZn8uU1oz5m7ls0X
lRH2nZtqHl+ZfYF1593FY2iVHpSmObtU/djYzBeNTOVBrGXPhINYZfooiUneU2WQuWRvzRXQrj/ONAOt
pCy4HXk+7QlBr5UJKgX9TVo0sA0i6Rowzkn0EJPHmT6BRQW/ZqfoPguS7X7ghTLTzEORB31QAciR00kF
vzRph7gaR4tmdzZbUbZo3gIOz2ycAkvRdX45+fju1bt/+/VPiyHDatZh41RXb9UnswXCXkTT+mwap00S
Yl33LAp/af754Spd3JEAegYgO/qClnsdnkXitcsJQtlevlGnhWK45Fl5rlPte1v78yayXOqFDojLb6hr
kXNbkk+sBOJF/t111XkHRHH+/0im8vaJYZb/y0SJM6TSILlfh+fi50jvX+G12I3dn0ngJ1ricYSo3O76
a+z+Knoxx3f23BuSLWc3IlHh672gtiOTzEDs7sbLOUT3QrqqzjWvKjl1QBU6ntHDPDpe4hymzmD0Up8J
dKSn/4JARTOz7nz+9GL/n07QnvYvLny2ke2ItjaXpUssgH3r/ta6aepL0cySORWHRffJcDkfR3f+lChm
fWc4QXBNgMZvuC5Y7Jss3fEsHgUbvKpOePY5aZ+1zUOm4vfZtX+4rEfjsVXm/k3aHQ1X+w/l2eiW7dO6
2geKxHVqWrsv50C+RfbLxwfclU8f0SgdHPytLm3j3hL/NJz2P398E+qhoQXV/BNM5bz2/wYAAP//axLM
Z7mjAQA=
`,
},
"/js/angular.min.js.map": {
local: "web/static/js/angular.min.js.map",
size: 288601,
modtime: 0,
compressed: `
H4sIAAAJbogA/+z9SV/rPNY3Cs+fj1FT9u+B0HPXyJKVxGkIIUAIs9Cl73veL/96/f+ypEC46qqq+5zR
2YNs4tiytLT6Tv+///OP9cd80ZuM//E/Z3/+zz8+e8OPf/zPP9rjzmrYnv/fUW/8f/uLf6Q/DHvjDz1Z
jZf/+J/T3Hl6YdSeTnvjziK9O/qn/GtHZf2nEUX1PzqKdCSfsXw0tHw+yMdI4e+xks9r+bxWa63/1KP0
3x+DT/3LZxWfjR93JsGVxl+OEH7y/sLfeG/hx1M/71/p/3qg8t+eOhdZ+2VJf73g3+4s/Pj77wDI/Hh2
oIIvj8FN1eDKXy/st+scpx5cb//lkpr/5tubwd/1f/PZ5Mc9fwcT//qeWvD238fZ1CKQTwP70ATpaUd6
1fRDbxV/Sif5LGtK8HRJ/hR6NHa4RuzIFPSpjby8hjelH4WHf6YDJEbub+Rx1aRzNK8y0ZmSy3O8KOGP
BVkeXnKiMHIOgzay8WJ5U1Iz2feoUcreX7pLH0s2qux+q1fk815+28qrkpEMWRrH6QuTjTb4QZZS3qkU
GpUvmUm5hgXIPlbe5bdrAUzlRj7LMzCoyhwPTWJ8mcqg5Uv5rFzJ0OWRyae/v5zJI+c6p6oW1MYCRt96
UOMCvnfI5brgcjsse60F/Ilc1yX8+cBNAJwFao9usc0n+XwOfk/vLwNwFbm19SDvf5E9aQvWclMbvD/9
vQeE6GvCPrKwT79MYgFIusr070sy6Cvc1TGYTYojH+m0scUL7uKzv477RyrvECRa5tPXacM7y+Bg8ucb
NvJdPlbq3i0rm2H6scbjPU6hj125TR+v1wCZ0oFtJyZNVOzQtQUYCxSiKUBcCcGkLS1g/m+Rm9BEPTjU
5XNRR1scT0fuYoP+V1aUL6SPJ5Hf6wjIY8nu1l8Zg2pGfHSMCRSDn78vdkHkWsoLY3lHoSLzLOsD+KGr
0V/tn8zlf2ex5XuBZ01e/KU6oBb1pdueMQG79eufPcaUjiPQeSM5Ge6WblTIB8p4Fn8WhKawKtDU31oW
mYd2y3oETIW0CiVMtgxUMrzBRHcdefjxSwXstI1Z9zFq/M/oXxC5uRIij7nlVSzKo2vz1aEjVvk4AEkm
DtY9UipfNlMkgheZ6RyXBhoTJJ4OiafPf3Pr3tyf5cTRR7CVM106dMdc3pLih0BLgFpZyIW3Y13+DiIv
ceS7TnECosMpg/73+osjaTxqmu7NTQedFLgtD1zZ2li2szXWweYAYwrp5aQveFSMLIdNr9Yp1VIaqVlC
SFbYISyzmnebGLkpP0cZcNPb3K7V/QYmsQNa+tamvbpQjhj1vUygLQ+8YmvdA0YkaRzF0JT2xwLviavC
R28twhq8INvShnwX/pGy6P3h824Mc3iWXFshij+FEwnHi9Phf51DGbqGhlb1B6wSw5BJnuPzAuvkROPf
Jvos0vjttYjfAxYmb8ZeQLWp3WImB54fq0fwj7FKvvOPY+UZCLgMd1E4k16qyAMEfByS8DGKBVB6ACUk
HsoIgEVUC2+q9OSHlbpw5G/IpH5oU2MyLSwvKWCEfDqAvj9THm1S06ZhsXwkCoklg+m3sc6yOQvXHlke
L8zrSrkdrN8GBONGmqnfKEp39Yl/OsmpfYRoCmHFfBxcJH+Jv8HG6ymcM/xoJo4aP4ry+en3rpBO8lkG
epsr4+FVOASvlIaFF8AyDPVMYafg/MKuYtnC8tANVsj0Kz9YYEWCEeobDnzvoF6DHIzcUmsEFyYmPFNZ
gk1pt1lziwPtkt/dycdJjBflgC7gGhPV1QFWJNmI6fVQWHzndICfdioodiiZK/19iV/BVvpHyDsdUPeH
oaB726oT5edF3T/nR6u5JzdYNO0ArxRjRz/O1GkwCIR8ipf/3iAd9aXOg1G4jotDo6R7VwZjNxgAUE//
3AEsX2BPG+VHB41+bFX/x+i9X+ZY/22hW3Wpvu/W1b8/yHUwCBnEzf4G6jnmn/KnD8xfRjkib9h6deQN
kAbui3RepMrQs18i2V3z8OQef5ncY05Ur28r7Or9ya2zyaX6xt+aHYjtZqTeUoI9Gau1nv6AYrxP8fNg
/7C51L9TJtSQMY14fkAc0SKWSzd4/bVeYohoBSvlBoLwNF7z4ib+04ripSxmF69DImp8I7uaXyU1hMBi
FqatS4GvwHKl9GqB7xF1MMZtHZXZsekV4Ku+VGCEKWWnl4A6ceJAdKT2VEeS7XEAmr+0D8e0Dzcxdz99
2XvOS/V/LQOMu+HjRGfcOsIdessNivqx2982lcNfNEcoZmvro8PIN1ZN5NjQCyNRaOMNmaV8FigbZNYV
qAsbPdd/wdDrY/NnT3Cd0X0woksgprWkIUEpQUx2mVMemmzOJgeuUgYMA8X6ldCOPLQnqmeBEViAh1Rr
TGVohSfEs/dUVPux20trkzmMN8dQOoV1347k8caVGsTfPTQeLepwR9it+0Pd2flZ6qfePVMP7rtxW6wj
2noGj+jM+DnXFptr2YbfuD1LYSCfNJqp3IuTowSt4dKMdS+YbvJt0wIpHBqiqflKxy4+4WfRX9B3ky+v
TTcWxj0NKuzQhOxq/6V/O0yZQzPq3b7zYgkX072tpdesfS6bXfWqbEOg/5BtSSJeiagMiS4fb+AIsIwz
nTf988NTyTmQJ9V//XjlYLzChfLqU+ZKEA8KeMKV0v/MfmxFxAgDqk5x4Yu64pfXxxo0GJzzhwaE8FS5
sRv/2PWa2/UZGRKsQf0i93+Q8xf4ZDbigMg48uzjcYxfxfZNpzTgDznPDXpqgxtge2pqS9GZ//1jF2fA
qgB5GkuS6tjTRH3gqdnaPInIA1nWXN4YPy1IeUvBSv0IkouFHDQN3G8G8Ix3z403gSchnU6JCufw2cF9
1/CqIL0h1ALnGOguQwfRQJKMHSzUKj6MxGU4Ig9s3Y9B4ccUnCoaDnYItD+esrDGb/aWEOJHDuLwQGbm
6lc48pHftPtSev3RIrqAnOIzIXuO1mLi6NJFYKGM9rdLm8hvDi0m6L4xxEDBJAc3ehbYNuOAp32zSFLF
QrjMkYdEi4JR7ot7XoSkpJsu7zEitoorU10DWwktU/tXe33zba8H2Guy8Y3qYOZbK8u8KPsXe31zcK85
2O97fXN4r3vm7+71Nzhljq6ZDGDm6tjzv+YOa4E5s1JbfMG+9eFCz4FxvN+loABVxhHQAhOK3+QFWoSo
rg5/J2dt5BEihmhG+8CvcKuNFTA9Kg19q0HgFmgQMajONNceEWuURnfuRRW8SOatG0BlOIXB2RrUWhpU
Aay7AHEEkwTWd2MQ8lhjh+RyBwrCAsPRz85IC2BnneViXVm1EEHKqh13g8tbjxmjQOYxugEFKuK4TcSD
+CA3sJVeyY9looVkqL8jm8y3KLiVYL4lAUHS+E9BXZLhFvHzP6tWvo/NQLZ6Z87i1l8EjIZetQFvviKn
vwkcEp38HmpEAHdq5w899tNBeyvTlLmaV0hYbGf/r/2eVs0a5z3b74Vsv0+23wtcHP1vLo5GoKpZEVXK
ACq8IBFdXKZyFBD8RAc4o8Wpnt7RuLAKSyHKp9ghK+kogDH/hNWaR0jTvFgMJrQ0rJ8aF3LUgLx1NVE7
jDu1BgDf8uWc16mJI0CnArWyjOPSK3M+srEGmx9A4xnis2OuzO/3dw0iNmO/U4GDiNTdPg+gd+GgFwu6
Vek5BySsaQdo9JWoroP4OHTgfPeeBfhrHXbfVLKm52Ife6FHuTVxEczgIQS45GqOMZQwu6Cj98ewEbjg
dRFfZwQHtcVBuB/wwzbze4ajFAWRU7MAYIfDlLqzrDVZqGMBl77gm3r5bJLxTml3r4a2q4UGYzj7qmB4
QnGplJXFzfOe1kbfaA14rz+9aj4Obp74mzPptweCL1pJ67y7482G+ZYgt3cZ9lyteG2Na3TirEB1c20Z
cjabuntfBkzZO/ByaNYr5UNra4pwP/NrbxjUPDMsAIYRDG0M1FEdv8RCN+9+7XrH3dH+Qo1VOLLvJWSa
5LmjCBbU7W8ymROvbddm2r2XwkjGLc+9qK0t/B3yal33HuwqWdC9E0+yp7EoKvpItfxtdCI87N92DGti
E9f3x4i3EnfSO9PYfyj+Apg2joMZ65cO5eAo5GkIn46DcH/A8bIAatWFrKbOM0I63yiCRhQm+4PZ4o2t
ifNb0wDqNkuvqQHXaUJFa7Vx6U0iWZ0m49Cn9DCc2S98aKze/VOn6g0X49fgsYE+C2xJYimmPyQXjNde
WDY2wc9Y0sBMD5MKtZ4j843l5BM/mGwNApLJNO/5xxFm8+zQegH2Ydna8V9w4ZI1H+WGC89tm9fmIBng
GR8R0NH/GzSkl3riwVnjuu/cIC6imBchnurtic8rEdh08vuw4XRpRaSC6sMOs6BNm/ngUzADiDGAqJPf
JV8sMDQ2/vJtVXmZQiqoRenKd6lu4fVtD+ojcxAeMnRRwFE4+cZSxvssZYyJr9Tz3l1LLXLwJOU0s/zv
PpSaZyFQsSjdGLmkSkIJFl3BPSrobde/VQ8dWufLfMZPNupEQzPdKthQKaXGsCi2CubmRoF19IQINL1e
3IYvjxJNigGPnF4GNtNNSuVN+hScr28NWeG70JWmLyg6FjlBJaUYRFy0kIwAZ6ChCGMV9rZrvjpxqnUW
808/Poz9rebMquK3JUdNquLPEkMKIrBWiYTowQSK5/G/epHcXCxnzKB8cAXpPvxbKzjDvv2cxtSvIBDs
ePuDfMzUVtU83oDG9FXeIU4VQXHo5rCrh5THA9BadSg3pnKikaWUYHK1FxKiAQoU4AUuCJ79hVZ5TFEN
XYNKYT0nC4lluqYZMMbJvjdLVwYuWK9FUMRQkpOhU4WiN6q5UDVOFZzf0Zn6+WzTPtvCs/kXIWmIl/Fb
ZRGLg/BNBJNpIWowfmuvYvEQvsHlVqicqgyyBXHKF+Wm6h1IWGTX6yld9tMwoYAK67bg4b0rOIDLZoiH
ugp/dHMfxl+FjNulmhIYyRoKU+2ygNRA7UzBj7OCQ9GJWuC5qXVueWYGwzcLdSZI2UphAGAP1JUq/B50
rFmG4mfFAbkSkC0uxEVMzONvM3bbj6kjI64Iw6u2DdV6xltyHisRVirKCucBSCLP/yOHRi7HLYYvshk5
tICGJparpJQ4K7zGXAcdX4OOYIfUvZyTOAmN7Y+LfAZWTSdB5O4CNddkYGgy5hS3gmZGeB8s8tCze4Q3
QyPbT6A7AsEdM7OOgMzhyzmI6gKKxgqgi9b4soEbdAsxPaKPDRYpLMakciZzoaXvdt88/TMD4ANI8COn
LvO/m+wCVH2h/IIfA4eYd0JFhnudgvMJbENoI5/FuOxPRZlbKs2r8K9rl1+RitBnL6Sa3tauCaQ4ftlx
khXT2xhBYlge7/3M3qvlDcU3GaxwB936PtgunX3tFl3SwERfe/KAo5MbTy9wkYtf6gyddV3ChfcO3UMh
ke5cFkNKEbJNXNS7wJWZC4JUXATmQ7eS1RMLdtnthbelH5fOzw5UjGFnFwXGZcL0PA6A6uTLrffUu5XF
shOf2P+OvlFBxhXDfiGfAgVOdaZrALpRLSX5kYoyt+EXbodiEYuoMpzQoLC3y0Uw5PYyhd9+htdeAiIX
nIiO2IUwkGS3GAk5KSL2EBNFBFD31VbYYWp5Fj0vOqcBlOUQi5EgHy+RQyCnSWfCZab97njOA+2pT3Kr
wLGBhDWopS1uS8mFC3swfqkhrPC3xc+q44ETgBAoZeCajr6KGQrF1YlfwkIlARPKtpxZYIBlue+Vq0fI
At6CWVahPJCbPa4D9OnlD4z65K6dqNLfmQFdkVHHabg6hz/Ly+IPP5RPn4121BO/nEVgHr8n4tIn5PNA
QRWAUOXh0O8paF18mfYYMgoglSvrwoFHKLEpiA8OSY5H7UuWXBG3lDYHB7P+LNxc/MwoMSbBbuVTQsOi
EqxFUg4V7OWZutCjH5ln48S9PUxdnSSigoqE0S83Hj/+7ZytMMRY73iWQ9f7p//tw/304QfuFN3AVi+0
sbOi15hXfnYfVy6fy8aCI48GoinqU38VrqbIkiwxTwYipp2CTs+sl9b7Fj5cRCMKhsJ9MTLO4wFoYuqC
CtXov5xyELBB5Chque89zLhvA36es5yrXvCGvn9DMBbTrFFacMeMQzjum8SbI2pYQ2+sfAysceXdQk15
47MbvCdjvWI255I2FShz3PgwZQe4dkV17kg5L9THsfodHDYqB8pvSTQPSZcz2NV0qEdRdoORG/Jyg8EN
+e83FOSGImoNcEMRN8SA0Egdq8fv5kqYotnzKgSCieIZZSZHIJiGgc/2f3vqVTv1CaY+/XZDIiOU5IYE
I5S+j1CWESpyQ3mmPD4NID0YVDyRByvHwGN4yDbxTZj0QmVt7YHySJcd2DUYQm2th+p7zqkvK4F2t860
O1G+dtY54CnlbQL2B+Yq07x7E+E81khCsFPwWYYxZmDGTBPNg+kVxlAoi/iSjEnKNhux7qRt3eLxTFHb
F97XQ8IwojIl0HrZPp2iyCil65zKeXuxvgN1fOdfxq0W5suF8nKwahwK7fud9Ps2CCKSPUSLkvMsbVh0
tHXRRU3w8X6Cc+6wDXnSjKgFu6uLqDnIsuVKUDGuglD4JcWO/R3XdqBSQvuICzn2/Pxac0I3TlGJo3Hx
PxtwAUG+9GlBi5iDQwu1UaP/YvDC3uATO/jUqbSl88xmE344DqTfwu/yIFCrg0RXYPVQe+/YiXdEQuc1
tBXOmBBznblxLMbHEiixClSf1g68TBqa8zWch5iXvh9DwWRW1KkDTNxmvBY7HsqoR5I10xEsCnoMZKgg
01YbDtWEq22zqFPBZq3mxfOSmOXPHRiJe4PwOQ/hk9+ng6m2Xlur4MJgDbLQ6FWJJvAqYYLwSWhUOfz1
MhtWP90KQ87DococAlS63YkWETPEChHdU8mm6OEYqKmYDpiZTQez/gu9VwEMVW4CegVgtxq8clD40sXv
noVtgCUTrzkjly5Lk9TWYN/z1Z2peeAaOGQDmyfvphYMzyIcJbuL33yxtbUfxFulMSX12vrPhQeegx8y
UrbTC08J3mqSkKvYW0sXSkrtmAatvEL+krt6o35WS4hSUM0c9V40hYgmdkvV7lTR8csiZHRjq0LstvqR
sRWbeq7IFL+KfmAqIbIiq1E6BL30eiZMrxvLZJbejfTx583qJUfq2vOT+JoZrz7vtSCz/vnqLDNLJ6cE
I1Uo78n6AI+Ao+eTwQ+vfGVTb9lJhpOR9ZC1nYL6gOiSefVobYGUSOoHypXOPAvsqfMsTKxF8oPkctZ5
V3PEEl3CEJ7GmW/F5WDu4+tSMSdTvEouL1em9srhH9zwGga2RcQLPyGr3Z76WeWpuoKG4gmk/dbDvE6t
VThJTlFvRFjpUiWPFicWymUtbuEVp9MWUNl8L6nbqC9eWkj6meWA2Bo6SWqctYkKD1c0XXkjJfmyFDwb
yuKJWtE6wHgboAlWod8RS0pn0MkE2InSh7YNmbTHehhUEA+ck19UE+/r8ewGHpm5rVDeJn5TjoD3si3U
8ejdLdD/KOsrHcmFOdJ/rtMheuq7/RhwtdrO6SQ2dWZs6Uh4yX4OaQFSUzbti9pOqLIcATKvlhscgEKQ
rEv3dYzU5MgBhaHoWzsTk7k5O9TIIiOUhGjzqVcs8hD7o3SVf5GEXyWpYeRWx/uOgHSBq8pmQleIM5Ij
NC4cSOs91RPM6AwrHoEFM4flhG6niMny6V0pOU8dD6STCyHtEuKtteVP5Tx/eNYDP2toxZmjyQZvbwLU
OvWodeUDlzHE8KOHthU8N3CU+mwOUi68kEl06bOQH+f+Fc0F/ob2DXF4qjjXzPYWwmXJty5naU0mw/Tl
92oRJl5ZrEuwy2OQNYvGd0gA/wJMJiYzPlM06IrX3EQujHIHtv6xjgP35IpMOCh1q30lDuFt6ZamY1HI
+BW4QMOg5PFgagI8aFg8uI7nLEdwbtQ8WPJbN74ufw/kLCt+Y1cVv7F+X4HVkp36ExtT3JBlrxGTfn/z
oqi2467MYx86yQz88nM69RLrUOE55IKSDnS3jy8ZOIala5ITXKtecDTJjsgDAxqdvy5fIBPOXHbbsttq
aNfauBCPFHRm6ONremlZBoUNYXiG/GPn4dZRmLMt15rRQ0gPAKrZ8i6arI/KfAWQLiCOoJkB/aON6yCl
8dSnIo3su+iilmUUYKZ1VY9h7Zw+rfzwlQSSmq9MRBHU4KRBOmK2+/rF+K18DMxMkkKuIgsCiOisY7L9
O3b0tJLBLGWWdAUR5MCUXJCJwew+wfeEWSP9+JAhbuBbgy4Qey5hGca5MF8fqUmtYuNA9ZYOqt9p3f/i
ByhigsV0agmK6EuSw5jM1ClaZWBZVdJxOPGNk0xdtaGHqq8nQTkIGZaeVx3YBSWMrVlZQE0ZqHHVraYm
Cs2d3/2ESTPNYxPckvCW6vOq7Henp3KCRcWX9O2FykmZr+c14eGFsTrBF7CmwjHIpFCiPnupnHU2UjZ1
htcY7FvpqczRrJFa8Yb33svm19FsALHA+4Z8z3odXKs97c3kuOQLMExRBGbxu+2B0KD+EWkfoamNfCDO
JxtmLEgaB+zxw/JCwc6uLC2GWY5ovnPEZKLmAozS1EmucnRuEVUkubqijnmROM/IStE+58q6NBn9jnnf
dVY4LSnjQ+rsgJbscg6M5sQMoAXnDH4/MaiyeaviUhlXEv5ewhd6+S5tQZQD5uh2qQvfC1k9ZQd5oXsZ
nuALmobVfr2s7gbGaMum0Jssm/PCG0Q0MMOQUviuadlijM4CjSQZoEteMJ/FC8PbeexliM8N5L55c7AD
VQ42o+nFKNnJ+1KyKpOodjE1bmP5SyFxIbIihECZ1mnDJ2O1hMgg0RjFBItBZKSegKJSsn2LTAUvLKd8
pXAn5FespdrS24Ns9bvoWhv1OmbiUDv9YaYfZkHBhihWeIUrQBWFVxCxEz9Fh+/LsuW78WP69+m/vO8s
va8WLczLL/fV7H1LI5cH+Ydf7svmJ9vbsFs3TPerGU2K9+Ez0q2KRjbsXZin06LEPo+Kz+GNvezGwJA8
LjZTUJ4md+GNM+V1xkdbG3CWCBfclH59ddO+eluSV8/Kz2JMzsvNFH16lfeDqj1CvmNbj3pV8cUkHVBy
UKuf/pQXp3C/goy1Sl89eU9O3c2odp8xqAKkel2o/KyKvAwhdpOSL5b9DFtnHcut93K9jkW+gxLm/Vgi
YpvreB02CWHkXJ8FpskfOADH3plaG+1pic1UKMIaicW5YW7nQgV5aSdRKNHTITG6pDSDcp+k+1wuQsWv
SOOpavFG+MBtId2EWn4hi70TOV2/RZjnXmK+jVuUyD3ImI8lYeFPSXp7E4mfz2JJtPLohZTqDO2oDW7+
KplHb+gQ8C4b/JGHOf4pwjpl3gL7rpJGYD2VhxHbVzLQQOU1IowmfXykYjGMx0qQc6KK4PRTJdOeqeK5
wH2OFJ+FKt3IzJcoiFypGG5QKX5uinu7J06RLb7tFDLOXCBYKpEfU9s4PwX3VZLkdaoqM0k0OGNbLbCS
axU0BOmoqfeoDxRlPFWcrvKZGzufrfAmKI6oA2qSaGxd+UxReHmfLvM/H2AxhXWepCIvE9YrECz9boOY
TBBeDBkqeYmDkRLX0Qm45fxVWUnv3lXdpd1n9Zez2CGiCBuTs/GVc9+lIkXZjxQFOxYFM1AUbJLPt1sf
5WdROq8Vo422XsYlfmlx6OkiYp/iETIIkuTF/VRIkHlTEl0N7V9K4uUrG/mzInk/Vfx5K2RZw2N3Ij7r
uHovNzTw50M+RcLHqvz5dCuqRPNR/n5+SifaKsifL0VBZBRSv96lN7/h5vfb9IYP3PBZTOVER6F9TldJ
EnpPYey+kvcM+GWoZKdHCpMdK+mcN1Fl+TJVoqHPeNtcSZ7vQjU0cPghffdK4eVrdZeue6MgyLZKcjR2
fOZLiVf0RGE2OSVZZae87Sy97S0V4JjbRTq3lCVfqqZ8u1LP6RSuOYWbdApvKZvGfcfpfamA0hiuC19z
T3NBWpq2DDTGHupS+mXEL+P0SyuVHFXZlakW4Mw4wBypfTFrucZuazda5K8uwJ8Zyy1bzXum7p5T3Zph
FfaXufvlXLcWWBJ+uUw5QeGfh1ERikEsD5pbTWaYIg/+LFbTO5IYyCPxuDIQrSJtiqoVIE9ZQq41LONO
sqrqd8CeWgqrBnjTg7CmR9z8JA6K5gOQp5He0MINL3JDGze8SuXL2xOQRwLAH/dAnjqYYInIk6QE2lMv
RB6Jow7UE5HnMR1yRIY4BnecqFsiT1Wwdka8moONLvjTMv2pkWLPHbFHks426oHY0xBMCNAno9RhjJgS
OjRECDIvNbjC6m7603W19fkdYQMJWhPe6aYL16Vsl/dSxrxkS/rO8g9SjNPJM0tjbWNtkN8meAmkYpcC
vVfMPG82C1RjUCZVxV3aTl3XCiEpDETNK8k9qUUgUW1wQTam6Ow3prD+mZtgwUde8s6oOGctx3zGQ4Ta
5uo8r39X1J0JbpZqDOdvreMLgD4KATDInZkbW/umqGfDrclRtbsX+iuUkMJSUStGpAPCYYlaoxIc4Ekf
yyiB3Sd3+Bu1w0sFr1AFd5Vf4RaqSLSrDLeQWWpvcAPycGjMcHXOTE9G4C6sYZZkDoQxF3ocOw+CXLf1
tjOoO9CC4pcl7zytuXxMpBa8lyjXtC1FKFgB4lRGeivmYpVa8XKiF8BeBitnFFOsMe+Y2AEe+FKTmdxG
c1lxFTLz9imIkY2CBC/t8BdWuUC30lVBu7Exbz6pBDal8DPgNqzGgpFHESYuMHgAaFjNA/ClAydYqlcF
Py7og9/xvy/81+yRNjYVF7d7/kIpMHsmJhsYZJhhD6+I+3S1lTJI5FHZab64AUNfgv3YaTgarAWFpD54
CeIQ1cp2OmRA5sLnDo6gIo2tXy4FecPaYV8KocvKBXWocxipH1Qijqve29vzuaNsvxodwYT/iP44TeIT
j+0ATP2l0QeOSpWNx0DX2Sp2mvtldCtTBqiJRansrrDOf3xPQTn2bkCbgwIT1/rAm7LnR6COdeAFO5Yr
pnIcZJ4fuczzH/7GVsfHtcrdKunNStgC3ajyO6gsL68c2Fdm7kvHSbMq5Ybfu733GvCRQtZWaGf1vSvl
E7f+ZMzpK/C5XN86ELaZja73Igvw7jnKiJoEmrgPyIhqx7YarPDLxDJmqMXNG3ayFrV9rc88IGdI1pRe
GfLOHare0UmWHc/oGGRIdej7+qwUdWyKHVGYfQfevY+3A9d+fMQP2cCsykfEyv2a03XmAD9fBj2Wmsd8
Yefhz0pZhvd8EQR3hSCM9DO5r1/y8txFCa9TI1CGvIGUqYuNWmCXi473WFWzrkwtB6oxk0cnD25dC8Bt
6b265nZYdsAlyo944cuBr6PzAF83S1EyWYUWAA3iwDOAPgsGmEfxRd46iTNBrm87Pnu3FjR4mfvgEeoT
VmrGaYgCmFIdza2aI/KUb0r2HKPkxieXlB35CD6m2jA8nFeqZnzEkA7aV0s3zSw4D8Q6iUs/x9K5mLNu
OOB2bAfdR7gtIGCleXkcDX3oITlvHBgL49csb5dRnQdLm41/wDV3TbXbogeU9amXs9wO8LI21pKyQOnH
uXx0JDrRExjDjEItqKMwm4k5PBSPjKUf6Rxlz5Wnm+ZpIxgZDMJVmIC+zbF+8ejDbZDovb6FeyXlJy2v
vovaK/MqsgfHFTPiwtcRFIPHTKJO9G1X+MyUPQTkjSuVvwT3kxFbXvAawZIhTfdHhyZZfofHubkssnaH
kcyRT8r7EEqWda1tTSOK2D/WRLwR3l8746afeyIWK1SSMG4qYf5Flr9RnGVsJ0lN2YFno3yb8I2Z2t46
ahwrPLBKddXd7fcI7de3dMiLUDk/uXVrHnjHLiQE21wmN6H6C11Ln/kRGxzx3Ls1euoCPzMui+5QZqj6
YMW2b0VZ7trdu7tStXBLpWh2KxjDTjvstMS2GIt4CRAubdiaD4tuU7PNJqNTE/S5OMMumPMHN632OEiw
+sLjGBGIBVundqOuH75bNlcB8K5dD+R0r/rAuSyuOMC3aeBYZ6FgMvSU+ThouOdLXDWk5I0KpGQjkJKy
AUlUuNLsMNjw1DxSfWhhYws9mTV16qhXs0keuG1obxvUwhuhTUqkxCRLP78W5/eSzU+bM99VvX6Jv+8t
ojrLzQdpfGqRbZx3pr1+slBTzGBp7TeCkkH4mQaTm9sQQTp0zfPlmvOH5RltQESGSe978zvl38fVn4Fl
zjq0N498BA7ycKiDfWr14gAO4udd3f3NhZgD83YLw0+i/R66Ky+YmpiruntT66h+aLQsEmOySExq3RIV
5TUVAgn5Pvfy0C0Ws1Pj+Kj2I/x7ESK3CpCbL0YW9Aqb2JpT61+I2cW+rsZmKn8E0riYQdt82sRRKdj5
qnqUYgeU6oFHUphWgtwoMoatDWebqJzsqLMIwyzLwCXbpBx1qQjqoZ1f3GFAKvKclbmTNiHKBzhsqQCt
VJLolW9zLn7XmBu2qR2YLyNVUQiYjI9fyABPXWfPleDMHqkvvXr64dYnJXMTUCdsazJbjpyCkrEzPXpE
dH5vP6BUmbNf98Ps1Z1kvS62AWs687vPntYzeAUkIFk06+Bd1FA6NJWwwtwtpKiYpyYVJ7YNmKfgg/hh
iy/kJ/EayA2eKtp9TOTVXZigfEDCuWWhHtmS2SNVIKh80aFHnwG2j348e/qeTnb274B8rC8h7WuDyu/8
N4uL0seUksY5UCbT3r/BOI/sgMJYn2IVbUwK03m3x050fflWUABXlNGSsd5ASeoxR7+vgtYHOniwsXUJ
bOZY7UrUtCU6egRW/Q7e9vqvF5Xu0xFTCvHJ/oqIRhUYdL2seAK/8q6Q8hfEnL/QQvdskf8Fw6SQx+xB
m9qEwnbvQjGBXczN/ogODW8+d4Gq1vEOuTbvEXyoZD3xE+n3KjgEkMwVtuwkJc5O9Uc5ToAoHefEsHl4
X8gbLncpHHp3UsmByazgX2YNe2Pre+VQNalxh3h/pmy6bl13WyBOlrYZhba3z5k/RcCKcZgFUr2Wrp9e
5muVJH+bRNeDbweFukE1ELKEbKgHVC0zrZ6FKX424DO882AYeTCw+WZOW6eGQfIKueIEq4NarU3fH1JQ
7/DvqWeXPag/ZPdgDUeBoF74DUDOdDeehy/4Ab5rNXVRLv2l1pX/feDrumSe30tfIRTAx7b4ypdW1aWe
ClLwbeV5Rnnm0uPQ9cWgIo0OWYPa2TwL+pjgyo5/HTwzZOao/Nrqxvo7li7/anvOdOh4OrhHOrItDa3/
Fqr6SN38P4C5WlIZfmBiYa2WQQHMf40jnkc05/GhDdDnmNiaOjpJZ9twlv4Gr9tajKKXmD7jHZ77sgxK
/HHycIzOZOwwyxVpFBjErGQJNrEWzcku/gb+RuWVT6jE65/RPisWiSWpScfqOyZ0grTR41vHBdn2bLmH
CdpmNQfZIm3+2Zcgoob6w0iDPcYI+HVO3SqHsgHsI7pRxovYz7txCgYMhwarqTAL9m/IZ5wmQuaHgbMq
Ad7livRXZgjM+bxyBSfF4MV9G2D52Xh6RydtqoE57/Sl10UauWI2M9Y/i/xhRV9zq0+efmjIXwFpfdeQ
pSeeSKdzb55PVC4wBC+BRlc8PErz8SnDIFo8a8x+O4KTC51KmY2dfOnzwIgfcSa532ZyEbSiwn4VnM8y
Hb1gW+2wGUQRKItQmvUhc8tP7yR2CE9WWdxR+QTYg7yzfCsX1Oyd++I0q+xG314fVC4Z2tw10s5d8NAf
mxcao9ay0i+IUouoA7fxEhpOuUsWdJV4ChnZTefQK30JMKytZnL15BDijCPBx1twdNQ+IjyufR1G69jn
NM+oDVi/1JVP8OfLX2W0ni2mZe7ZORPoNgLt6twE6bk2FfXyTlwaWM8CNLIE1+npq7tgZ/q2EQrDnNG1
uOruUeFyD3/CJLXgfpxUdxzgxB96dhKooKK2Bi6XGAUdLwt4Q9pzxtfoamF2Z8+6V7ikWbwgp6dLkCGx
Tehe2f50r/gi0ybHes6I1/i+TbUePfm9W5fYSgdmn493bp1rbqK6t8G9oKgK/DRH8Y060j/sqG79d1I1
X5RsI4ioN2+RtGnNC6lmIWOZcmHIshF6fO9oQJnAxTWmbb6FHkZutFTcQcQWKlAKdqk2Vfgx0Wkw0Y7v
xTLIxLUTwR9QKeiHGgRx4rWvYQILT410KnE4M4OtPGJ3gYS+yyp9TJbjqbMCKw/xbD9QBh1DG6mWKZgT
ZNdWXIGkvcLBT74P3tdUvKqhkNsbfM7BM/d8LRubOFFzbbR7ilfq0tIKzW/1TE/9EPaIuFGQa7mjJ6jh
0w4xYUQW3EmCwm8enxyQ9DvFlw5isr8ArLFX/6udrkmkWj77wqfzZkYCeTL2IbWiw0Pcyl42vnR2lqAr
8j/9PpOp9q3J7Fg0hD0Q1pbHPLg9htZQXoLtsV5tovoPgbfJs+fM2yQoaDFrjec+ySdNFgZAcMls1dmj
V96OvMftNFDS5g2Hv2hRtrQOsbCp26rgHu2pGZ6jE3nhnVpVlg+Ds71xb01qJr67nWT/mpXwQMOIehR7
fKX7YgMOaVtRl37CO/21hJiodTY8+9HvMKI9qsMPa4FXcwFwjPcg4F9rKNejOKd5XKR0kvM9ZKbwJU3J
b8Cf5jGceL3HKx0efcEDQLYtB8fqzje06wUuImWT6lFXIeBC+p85Q/2JaQo3/QT8eq0MgP4AIVHaKdJ5
rsxlLPSC4zxTuZDDExAIeoGYOvUZyOc6tvgeJ1NZS0G7jEVa8wA5umaZengL0gsQnmzilqL0KS6MELMt
oiw7MfLqkjyahI+WUEljqWhjDU2RcuNnMvNCVPpyjri6EWqEY7SOUQrMRzhpkc/rfVNjpfry1k9BxZnq
60Hrx3Y8uu2o77yHnA7w8XeFO2s/LBxoivmhQwl11bwzPz5Wz/sEv/Xn8Zg5ys1FoKPwvNpXQ6+x1HH6
atYhQkLMp49ZfEpYTWLj83eoydsU9qoQSajH+4RKnOqqDprFU5iyPCBBcG8YNK0jO0E/mTrvB24PMm9W
R6IrMVqIG0AFGtKTMA+w4ofE3ngjyZoNsa/uzZHsAIm60efPF772XDrEZWBbqMW9c3JGSAtk0BLFFnHk
3PCxLV06fnAGZnvwmMl+Talw0wqgGvzt4Bv17wP7dIRXBxbqJkg8n9f2md/YWqhTfxxP6+SejI2C+EBm
XNBRbqDW+HXotW7djy0H7/teye2BK4SLGdRAhUJMaQkyrlJfpeLHHQqMwRdI3LfmWQCAU9/7l8cDMJkC
O1T7CjYQvDI/ylzOsgUd7w5pDYOeuhiCPuOsSVqS1TwRVIE/tJudQeuah8oHLrZWD9kYRXlVubKufX9j
1hYgOMXEjU3/OE/16Qg2n6HX8q6jlmp6993avvbqNwgjrOo1P8/2hHPiWH0723PsM/a+NyhlW/YksEgC
l651twbtMSg9hf22vTx+o5B4d3iQp/e1tp85yVmw1tk9wARAKA6PKfOr+KVx6kufB147x6WgKruvtx70
G0XXceZSseeWYXeFGa69hdkcYSphp+etP8CjvvGtv2C6ZCevYIMzLTjTaC+ZdocbzbvPTeQj6DEVVBod
3wbJ/L5rxKnh6UBn3+uiO/4QlbfuvYPyTPXwZe6N3muow/cC/+ZY5249IClFhgEgB/f7gLQdEy98gL2x
9Il16PRf5zM+riI/Xaqh/pFs+uTe80GoJZL8dcMQn2gKlFCvO4SfgYRFBPuBBPoRUXq679owvPWN/mp6
5W/id2cVMLELb/Hw7AJfMxxt7u2mZbmgA8XofJClBg07u5N90+2t3YAPBud2wgNioqBhprwv8GM0TpI9
QkoMzsBdQQeBv6441/2gVmPpTksroIlBvst6EoOb81OLU+tC0Hj56OE7avZB+AASRQXbP1siiTuPFjGb
tquGYTj3Qt+AK7CBxo06pWWciHVFU/dujUGBTkFS6KVPWSzbevht1dv0O2vTsxv+peHtPAGjlw98Kex3
Y087gEKQ30AHb3drfo3M4UDrRyRGmm5+BobfXHHCDbdzM+VT+nznZGaWfY4942iMagfuc96JTAJcq1GB
oAEg9cGnwDtLaF1f2krg6rHZbbs3NSf+xFaw1qJtmxSWhx1RDvbrftMUKM437wClmOQr8JkFbbv+65EL
lYn3XrSm3nNFpQFuki4U+IEim1p7PiTo1RJt8zkZBv52P7+mxJKeStDNpBLtKTwPln9eJK5n7SrzM6Z3
yz7f52cUR5MHVNiI/taccrNmomvVRTe8R81ZHY75+4WaB7+nhNsM2tnYAkqMZluwoMFQvjTlqUVCebyZ
N9nepaJfonv9SIVvNyxejs48enWQDGBb5lA3wg61bHNTPMdzRlbZTPGmGN5VPdF4AV0lkA0vAuM5DJfQ
bF3YcsKZqFtb9us6Sg2EXs2zaOohe91z/PF1bOt1I3Fl98Djt/vhDLIpsyTVcdv5M2Zq1nY0ZlNnoRHz
eI7kYNM4lOufsqiBbcYpKrt3h0SlTo5qDoQ4PYWFz/pU0Y8eXfgGNiBeNBxjXBxnBRJjR0FqoJtLBYyu
NneiAzfnoy/GU758q9r2AAQB1yPmc3dobTy2+w0goPegeAgCFnZXnqHUL92uFCFn2PC55roWIEkueUlX
WkxKB1ZSMEIZxRnC94U5zPV8KfAd7N9u2JSKl+VCCZawlMs34PW9PyNwZ8WsJALHoPSZOZ/asPo4+Z6e
fuU1jrIPMjUnvt3E4IdHQcgmhpPQnCna/Y9B0OfYqeF5IGvhTN2gdyyK9AtjBVlTxKSSM0WjwRcOWB6U
okeTehdmMVHXZIw3LX/gaHaQIaluwzQU0lnUiQM3dde6s//A5vLSuLoK7Jkb57DStyKfeOJ42J/emrUO
+zeVg9i/M1SPvvxO509Bc9G8neG9NhOoVdgmGyHYtg+e6KGfRJc3J20311qu7ZAM3lGz8D82l+0MbEXB
o1tYea1+kJi8b7vtVxPUPKcvYN9AD6hTtq0ubGjj8KENM9e2e8veFxs5ihWmTj3ShTU6IkgB5evdAN2x
beEpmR5VX5/kFmqncIXvdaszLEszY/ohrOvWuETWrD5h/OpX3nl1K7cb59dbdrfXXDcV+WRgv5vpFK/E
MtHOnLsXgP/DE+3FtaMD0ZLzb6ttvFbf9s1pwk7vpksX4LDlSWrRcgAGPp+qq2C/L91+2z5GvnW+fEFk
+gnpku0LyZwqMIdICgOTMo7RKokCUpaEHt9F0bt/mBmpQltn+eIw9dL2wbiyJEmjhyQJlnwdk8j2ZBCf
YfoJ0scrgjJ9A1E0TaRLfoo3rCdi8TAFX1/DZdkTeZ0HhRf6moJcPpjAm/T1Uc0+6Q9zAvq3nHOl460E
7CyN3HJfM0MOGgEKWnUS9E1FJTiLteUcblOYBD9u3Y95ieUVChv3Yy8e21PFbUA5F8B3pB1SMKNoSIr5
8KrZ0Pvz6HMQ08AKe7dnp35MAblmcyVr3l/5bPeFOvO5q7anIKsTsTDw6T7LvorFFBkTvXJib5FeX8L9
yXmc+2aGtZxfB7acFut5/vAyxoVA8/TX3zNUX4JRl6S2u5xMHNNexVM10EEVOish5Hyv1Dr2hzVBCbpS
nfLvzodH53z4xYS30MKoeql23kp4u2ocvKsogFrHQowVKe8apOR8go6FNuj36cD1Rkx4JwP4kzG6LJvW
pqmHppLvGxWNqKvgJiuLx5L1YbIjSCSQXE5tqB45UT9sVz/6Fke6Crp18kBnSYLx9gfqLi3YBsxPZJYF
zxapsQhi75FR8EgPNn3fxukFcVugfpAhYpjst1gSLB4aeunljgrP7ehrZoZOrK14ip2bKu5d8uH2YMVG
/OvM77u3yGNNjbV20LnTi22+yAHFNPLNZWLmP+JCV6FRxijVq0Ztx6fGCpOepFdrnDSVsjznDLdHEhx+
uuL93yYtmOJ9JUDlZcwov2X6ByxpZn5m+EFcZ1HnJ4NK+uc+8ST6aHfrO0+ubKEId4Yu4gu4iO/7Qb72
tXfGtZ7cdrLJcbCK3INbBvwOZtb8iWDUQtmJ+prnbVkTPu/AbfvlnYhNcKVgBAzqa+mhVQ+O9LC7LT1W
BKWZtL5y4E4VVuyvRocZvP38e1R1rvPB7mR/xrIJCcOfNgrKtWOV4s2xfDfoIdTKekKvAoCceDstqMDa
KxhHokctF9aIk9le+KCfbfGNVQL7BBP069a4Y9Trp6HMcO8feI0fVsOX7fcLB80RrCqeifwx8oUyjzY1
DmkOVsMrSF0eFST0XokubVtP7GZMfxQS39jwqobK7wpCYvUb1WmFtojJPFWyiheaGVl6gT33hkdatTGg
1OYa6mgFoFVwKmpzSq6818X88sHzIwTcTnWQKuHzhHj4bGgKBQnsfTvwO9oO4dopewedOecMR7+Ov4+O
XosFUf+LEosswM4uillYmKiKpeUsrTdoaGn1Yxg8D8Sm5sPfux0HIr0PiSNrHMnUvAYiRTdvaOjxfPpG
zUiyc+kW7LYcXQ7UBnu0cWQVaW8H+Y2xXnimWYEcr5Vnu7bOsd9yJYALNQIeU/0A14rBp6p5F47Yap7s
hkMF74FlJ42+NKMMOzAYZglK/YawwU3ynSxrDtMffTKsTxj1pFD3qTQMW+Ti4BhPMSn2juaTp7fP3zgb
Hlg8e0t/iTvATF2moQ5GiPYG0K8YYOUHaKy9lxM6PoyF74prLJZ8kfWyMHSpD3RSLXL3/D1OffPu3hm0
tR2pa6oTGHpHXvRlBUn6uVD9OGBGJ1bx2gdA4M3X+cjSrg/NyVFsqY72tS0UqBD6gwh328JCoYFZ+iuw
Ir3S0zh+Mb0CzSG9AjvUnqRciwySGe4luzY6sYmpxp6NyUjZhbIpy9oVHbk+EyTPi/e9NhP+jE2dP88y
SRKL5GBBQYOmLeRY0KBpRMEW1J19+XM25ZZbuIrY99ds9Unzb/XqY1R3i3MA7VaWHXV11Y1XQetH7w6J
ewdDx/ieBcpMJl0ZD/cW65t3FKAxUOYH8k1h8va0dJONFCO1ZWXOdBLGPbNproM+gkj0RA8bhvVSY4T2
4XnLwRqddg1bTkH49n7epG3gZO71v/riw7Gj84MA4Fns2pv8jZsfL4cjF83HIySE4lS0PLahW2bG0JVI
YsOem/Tumit9hEtvQ3/MkHeEgckVrvQJO5iyYIPVG0Vk9CVXeocKnMcpn598Sj9KUF/5ijXS7S2XuvlI
WWkFmWTVKw0of8z51OzzTzu6pYf0ioYE6qbNUg3pTB29OP7+lk3UoBI3mStP3Fa3tnlAIqWG+picafLy
5zITfxOeyZIqm1f8cbb3475mFZmt2kO9S3Wsb/jc6uVPJwPbSh/s1Sd7l2zjAL7/DcIbGktd8qwgkH7q
5mhbsNjuasdvTrj09O7DDfQAKXKlH/6ZpBrQlWZwQQLvVzG27zq9KITSLm3p0klV2EcnuUNV2WcAgJ9u
VT/IZtyA+bti1HRXvOfBH3PQU5Y0ZYAbm6q6fPeZIDwc7ZWUlUlblpmfmZFoxxPB0xa9LFN6zmay9mkB
rGtWsIj11rWSaGB861xhfrIp8wJQfpHefNqmApukSu5Q5QiDjN5kX8PDTYbeDVg9BlfEKgXc5kItLfdH
RVJIRPbM+QEpm76MS713B/WThFRWYmp/SGts4ZqKTUpWDHGi9+7IWQ1R9KnSnz2pEhylb0/wgBzrqSiF
SFeh50VH1cDFuurxXP7vqCco9J/Fc8ovhu4waHXsApBRe8SfP8Ik2iQzFk6Bb1RAjxQlOMuQZaXGMP7I
AJdV6+RhW+6Dh7Mz+qeZ2NQZzdh0wuNXj/swmvtWUTh6/avfoUEgVQ+FMXVzbl3eYk5BcQP9JtxoAtPW
ry18OldPHTUdTluanAd4yfZIAwVl6AVr+KjRUsIAfVjgsQR6N8rspflht8bBWOlSnoM8MlkKs8hcCYdO
WaOg6lnxI73/snSlO8/O9rwqweV9nV6dZF5ES6M9PVV9+o8GbeeJG4X0/7TH6kzY3h83wEqAble12Xb2
pBaPNyJNfZFO7cu7w6JNx7cXyFotyt/X6sxzfGMPbiFIdnDWMGladV/+1ritbNyOPvMWYIoKKXs05a8f
HPDDHzZtKhsVuM2z170IRnxMs7aaV+9BcTj5MIu4PTsb0jNzopb6i1Jv0faZ1ht2sv7YKjubVdtZUp3v
zgB7iAdGsUfDH0Z2/czYiC+jtYGUAKHafzYq8/iDha4Dx69wiDw4V51OiuScCoV8DDNxzDogg7izRL4x
TPuM0YBsIUYUdrUmtp23fT5pgGxnXnn/7jWFEW6O1UY2haqLKcEZhGhLcoHrSOStiaDKmnif+F791Qv7
t+TIbZ2fU5se+WlHu8R+ya/PNOYaY3CgVyoWOF4oRvamHsQ76NJwIptUT9mk02DktboMrKIGuRa8x5LK
VU6wEuzHXUed2VvPP/xUUq7HqzN1Sbfg9/mk3PYYtJidboobTvTe7blPd3tOs/2Y2MPxLayLntrgJXFf
bdE6owaWdQsFospkrrD/WXLKOdE850EdUjrkHZTeqD0OjgYwfy5jAtcYSBYmWqdQSWkgD2x9hTNTDLCJ
YiMo9tdSAUhK4lE/VRUnXsoi6UrAr0T2vfR2FtyfyAYXK8hNQUP5Bn3q65aDD5Lx6eksQC2uILAFz0Ne
Qj3GJvR4Fc9nZ2UnuoBKj3jHcdYKnBsTRHzZZ9ycg69AgW/4RKPW8Wc2lk0JLv/J5FJ9xaEv3jzZCGzQ
ChqaZsvNI2EnZkZQgf3IZi7Vei33cIPGVDlQ+f5o76wBLdlwNjrRA3mSnodAi06AF0dPJ2qKMXNsOX8a
YH5wL4lrof56Knx9Js3/6MzqB1SATWh33WRWQk9ib1PYgVvWxx3Fc/1FPjN79UnUYcoz2B2V2gX+rmRA
1MdZ3CH9u5SLMys75dw+naA19Tpw83shDmblzJgUL5hpwzD83Zkf5VRd+Pgoi3BILIUHTKqIs7nlVlh7
ycs8DOAGo/LSpftTs/cdxM49hH/KevX2NQRJEvQfOWjZwH/AYp7kK3zxLngxuQAPMdLBkoN7sID8XXDo
XpveZlmiTYG58eA8Vf1XBxTtE1uAw+Ljq7prd1jx1ZMoJrvmOF7d7lXIZn44SstU//ndPV71aWqPGeIH
vdv1vQOQ4dxhr7Q7KlvHd1c5D2hmdAlHeEnHJddUcGjbz8i7HdFLam7ej9HRfYxBTSXschZjCjHIHFmw
m/yZtNv6PeKQaoR+7efFPYRFio/zjrS+I4EPBsDduakuw7zd2rfb0bl+yOQFcOq23emUJ9ScM9w0gRJi
Y5sVCDePBpQFJAVQc25n9X9GXNPG1gzaU59RIQMKCRqLlkvuCdswkU5y+KXeHSJG8bcnSPkuVdEe3Aky
wp+IXOqsyEo+fallO4XuE7If7aG52xCY1JL9AajB6UQrawp7A82fHCJNifBOYayxbSkiXANh2viSPdxY
uJ2V7xRc7xEM9kl+AOECvRLClgcz526ne+4FebSZPWRziM56QcMSiRb48ruN8kG5gelQcAxdUpH0wUqi
8lC3MvyonNI4sOfOfgWSoUaDR5jopWu+J0SY7EU7QI+37II2FAev4aN3GLk+tI6BFn0RYPwrRWMBuuea
ByGea+p0Uph1LyjdsHMSt8gD2OTjkH1XJWnmCXvUtPfIlZ0NWfp4Y81rYvjYwVWhhqpbCoRNUBT3rYZi
S4tplTFTDXU4m6Q7U9pLJR6w41G4vuQGQAd4XrE87Fz9csOFWvHbKcPOa37DfM40fzOlrt/74LjyIlTu
aj9Iju+HQp4OKVfQWhcXw11VTJQa+uPfVdGoqHaLBol37VnX6UW11zl1zrvLgJx9/5xqTcB2i0SoagWC
oMjHkwKfLFkQJqU1Zl+sgO2dd30P2BZd0jked4AutGVvjn9i7VMl5y314qEavPj9uwlqYGQr6NVJRr3/
jU2zZ+HiRXZzgPNSOmE+D29FBVtRtxlsNz4lK4DZg4jvfiyO74353ISOyG1P7S9o+m8vSFj7f7Kg58h5
2DsKG0L/1glFBnFopqk8oSkB29OxJNg+9/rrczQ4X/xzQfyg3PQ/YkIde+o3XtO17iVp79c4uC4yiFZf
Z82ZDiCqvutljNNE73CKbI2oEYPCS/1blfSe60KY+92mFfBcGcwnCcny9ZO34oNIDIrR4M4aFkSlGRXf
O/vHWRWGys02jtz5wfnoyxcvSsyggBKyWpB96tlbSaA3LhbSTTxN+mqx/4aULwomDruh1HCsfUfMzfJ2
q1Fwaq/t5QnfVSLIOIVGk99q6780EbJwj2qv9JmsVJAydDhjKM7kg36+CeRYfRRwwrBJ5JlPFqt3fA84
FhutdVCAV156fLaKrm3qv/AJAczO+ApSDORyxZ2qz84n0bLofM0jdZQE5OmpEyr4mGTePCB02M+tPNe2
4ttE27rQTl5G2jz09Vfda4ULFdooYI8/ItMf9sWh83tVcvNhZ5Rp/O1kA5TaIkmPAaqcz/9addRQH//s
XBNkeDcvfUld1u4rkTRBbX2Vxp7MauwlOeuJ7aYK9sopvC42zdJeS0VxB+eYp7yqYa+l4NqpdGOPiUTT
ZmB0zhj41NTFMMmbtptk7ajtUBYmqR6bM0+vP5L4mi5YdeWb8TYuw7Iu0WmvPXo+9gAGqNrpPCWXAz7v
U7C4nCpTBROM/nAGX5DkeqLEW/KlzKbt0PNti7/fM5KPgQOaWMwCDVsJbIHATEha3hvJLNTB2ed6P8FT
OhJg5JsAWW48LbVmPp+OjdznwQHfoqWlkvSiHxJoXx2aOsnxMmyQ6jdmpL64W/ROAQX0VexD5njlgDWE
tvDq+D4ogxu13ZL1yzKYTvPIdWe2UQCAEBaIJKpEzTPPoMNjYuEOlImbFnv/iudA/kP7O5wcb3raXjt/
lIZG0KoK5uLR30czKLXbi99fwmeolGEry9EFS2pPms5nPFM5CjxeYxSVluiZzpGZDH1WwABYlppuhJS0
0PHu5I3Ns8I1QmjEYwrGekNj6NRXRk3UGd/Ma3SQn2h78RwdHnIMApuLph9ZD40d7DJcxhVvudxfRkGW
wfKVcd+LhI46waYx6oL4JvMihgVHvsyLOPEOmoHK4QtFkfz8znJ0dL0SyAh3RVLSlCl+LNaAZb5RzBt5
OIi50dCz2J3qBQGoCzx3rUwuQPr6qa/Fe7vxG/92Thx/zz5M/p/WmTDU5zLLEzk8V95U/3OahRQGhyPW
SPakNyL5CiT2444a+ZNnT3ZqH37MHlNdEALOnDOJbQ/c+HZ7KvSQgHGtxnQPF/6cZ+OMwrnl9+c2/Hfm
lkoqN+ggZhbwX03O3Z/ODk6qxpSTy5X3hKGWMymwWN388xYhd1qfoj0/S8J0R06D4UGPehej3RBOVdan
EiWMz2xWTpt5KUbCa3m4vE5FPOQxiNmIcM9vGfuXpPI8BjTppn5EeSS4Fp48pM69bvDWKTmUuFbgUkxO
HbGygZ75c6b8YaDo2uDLDVYFjADAdEdN0YeLHsprdYSugZRfp8xHo7dJjzBcjLH1Eb+ASvS1PDOrLPPT
1+/uoZl3tnZU4Du85pcba5HiC18D5ysL9c6pcvB8gVuxO45UFzGSY7qMOvLFRVt92k0NP4Dki6DsWnQz
CITN9cBrg2E1eK7rYVwb+1AY7HW65siFEpuJukYgv0QuZ5scHXUZ2V4HcZgZ2BRHyIGDmUFgQL9d9R2N
U8h09KXP+a3lvM4cTeoOV3F+mA1uRnMr2LJFsiIblSxs9kjXIa+glV6U9Ni2Kgncs3gJNu2cW8Q+uydM
sod2p9vAEbkJ/bXSv3MWX7xz0twnLgjbvg8GFdjYhvDgrUgaZQ8ufeyxpd55c1u0UYGCdaR9IlS0Ajr3
C31vHj32PbfoKdeSscAVjxC8bBX/WK0oerFHNqBdQfRVcMA9VRtiCUNK4AvoSGlKe7i0G3pcCnt/Lstu
LU32s362U5LExLhDGRGEbl1QRxr6ZLhGkLX8Nmz8wVAxs0VRjl+u2+AqhrLKV9a+sml7FvIogOiYLeTo
6V7YGBXP0NjYpoWsWDwPmxbySA0IR6lcSLX0RIIvce3aIqB1KD3y2Sf2bU1AIRqyva++9XulpOVxBBNu
B4o3U93YjunPim/3eYmuvY73ac8Ac4LqiMYugoYl2CP1K01EwgsnQWldcGrZiRrjHmJxV52/Oo/DLHii
oy4y9wP4xggPsUziW54PFsb8njnDMTzg7kSIuq8gK871hQ6Sh2mF+RKL5vGbQxr2y/0KslmPqMKEZwl2
gVFUZHxWaPXGu/nEmC5CidmoMz35+O76b/qX973ZvlMDr7pEK5vlyESBCUUMImJylqK2J+jBObvQN65j
s8mOzr4ISHzjSTw8eD21N/yxAdHOuppShDuGryBGFm6qKdywCQzKB1JYHvEr+F5q5a4JCR5cdKWA1/Gl
WIT6S81QDktjbqkWAq7MnswUXxr601HWAjdVUpOTkT0vHy5U4BobNj3ZnS6LS2joHQVB/x9yG+KR5Rld
u9qvrE+WyWJO5iRonfWR4xcfgZ2oSfB7Y8ov6Br2PKDqRFIfBiFCX8Y8IDRckybbnumCa13bfe4E+3xq
+QLDy0d6VnETPuaEc7K9Ntg8CNTaj607KhGR5GKEk+oZ2WwHbsSLAAjodSKIko8WuExH1Vv199vZZy+5
zHqzpFzEnjfUfxc6oOJ4KhhHc7h9RhIavGfeG03ewgj0XhvWbcFtHr0jQ8uZiXNkznlR6hPMlM3gPvCG
DpplvJhz+YKz/l7LNOUMkm8qpBcvgjeK5SJW3KkeJUXijnWKFrax95LaGcRby/bI5MaU/yyULaDZaTJ6
OKU0OWCMSwVbXRwRXcXhwlBX197qg8o/JrUCrHjKFAZLELkp2PyLoOENT0B65iCBHJ/oYwKP3pMTfdnL
1CO5FS1FKNvmMJdWqinAWysJAW1U2FyJJhxP51ZTZlVcS1tO6xiY6LPg0KgjPWKNEDB3rYGPQ90Xb0Hp
GpItp6EmiGFNBmJysCnyUKHMWEMJzkMJNM/of5xHhtzbtVA8mqgncz0lu/BV1XstiT0RWybDfZqFSSP0
ZBtOmN6gM1V3gYVTlBduFZvmbPD7VrUXPs1goH5hFBaFeX4P0WqUAYaaL3uDs/PUeORHeZwMvIa1UZZ5
IQqoR4qMiwi6USJI5yqC+5yidK7erojr3YGsmqLybjX2L1go1okvrWSd6F9WcGA7U9qg2GDy0sRwrlPM
Dqny8dZaOrK5tHMGOOCXBaQLBlqpDsmeGznaa6AEDt1UEtr6OzCVDk/n+jRBjl3bNnxETgs2PSjrxVFj
LwQ9BMLLh7yiIPtVtDHcltRpi2aVBwYYnngHKfNxfX8YEtHigb0zwSlxOIx2zcTQKlmjGvleMAdx+vtd
gBftsVPQdWHljnHLGpiBT7GR/IaewPwfx2RiaCWmRr4jTCov5GA6GisuApfqOM016ygr+qfL/u6MvFq3
Y2Xql9XXhf2//XHMH7q31IzlL3GfQRQ8fwplwZxZpPKrQlNJqbRHFqTX2N+oSoOddYTcp6DtUWp9b5RX
V2zHcLI96itkevfEUbafJY726Cw6Nkit3uAA+B++lxG5X3aGSWBc2f6/Jqh5zlZh3uEJqriWGATGKLN2
vfQyloJ6DgJxlJ2f+JYVrThKyrO8LblirkwWZvQmdHun3b4ccbLkEhsuiVr+jC082Hb1BfOHbKPP1GYw
Rtctp8Y3hBaAszP1rRTjlLMdNlwLTdbbgcmyDg8tE1+RX5MXXeBI9fOjTnDWQOa8pwJCO54pjlSIRorV
w5nDmEvKWY0HS1pb+UNIJJG5MOfMAqAcFkMx34MOc2GGtC0l4F/5sLUksHjKnyAgKIRyFakvZjDxaNge
G0d0ycSnlYyC/h2PVwGrjSb+8Gg2rQSUV2I+xeCY+jxGACC+oGMKLh82fcFRjrci4qpNejlu0aP1RGMj
byF1q714hJFv4eOrntqYy7HtuHMufrFb8NJakw0zRbbdIZd1wHmXBxC1lSG80h/8Fq1xeHV8TNbLMxxj
9JDXA3qS6LhbxHHGfWKez4CSYf2FXr/J5NGGhTIshci0RUHOqWuGKrTQa+fB8YG18WOGDPrOB6uZssUz
oXEz3TztiFsk7h31xaUcMVWdOAN9IAXhmdfNa1Nyx4nksuo7eyCqcN/6te/pUObJKEJGVVs1fL8ZB9hx
FyAES6mYvfvKKvLPjMqiDyrFuY/AImYS+txZDSkpBhMMctqbE1K8CUps5XPozb8erE5ksxVwSmxiw2Qk
137XnaEuWWJvGW2xtJ/F/n3V69qGJ8gWL3gSnCB8OaVLDD2lwJ066gvCjOWk0QkWARb2lrPq+afP7pAP
aH8fNzYLFwmONhFKPtmQE+61jrh8ddf66nzOiU2O/w/GLQo/q0ZHAXHXn39sX9jIn1t5P3t3dzWAvT6Q
kJrzDLjaYulswx36a8vucyMVNrGZKL/zjGslFx77q/Qh3zpoflxwKhg9uX4KZs1+uVn97YoY8WWtK9mt
w+NmvfGz39i0JSl5pnautkNvNaX6nWXQVOeu9RUfvrEC5pxToIhJt6Pwk39K2Y/x08MBN9Z7MLMlV6xL
Ia+xB3eOjJUF0A3Rbg2Ru5yCllMRypDHg9zv1hlp+1R6Z1h51w+OFe+V3C5mvcsNLC/0qsM9Wa+6xDEk
353t44TUuHU9ufb1BDcRm0ZOc3sP16aB6V3N9oS7mCBomIz6B2XQfwTDgmBC3lwfxASD5M6euvFYVe7X
DswOstHOauTP2rMHwJx8BgFb6yeX88VcTdeROo0PjCqF+jWrtBS64orXcIj5Y4tNb+onfq7YSfTCKjlb
K2WsNx9SUkeHRsmcciaPyu816Ra4XycjjtZ+Q69VLh8OTAsEPd7MJvZP/s1NZQHAv7mpOKT3d8IgeR/e
1Iy8/9amkvbRs7POUOzMx1RElE/J4M9TS5bSe7gXz52Qm3UtQNGDTMyQcX4nq7rOD/OjvNfYeRzJWVCw
WTsfet1vz8UIB2V2pMkZ+DBUUZyYnZzbC06pzTuS7qnM83SU/t/OYuILfbx/2XLxon8lWgYZkym8OvbF
dBfeZWiTcDsjX8P2IQoxxCFqPFnnhK5I+c8M3skoUFuSq2GgitqjTrPo1C/TQ0A9HmhXQK/Jj5Obg+vy
lfdWKNnmJX+ykrFEWhkgshKevY2bEE4NIlVW8s7knPdnII+0i2xBDLwAhVqNnXDmF5ToiF7VUeYvhy/Q
XgiqNmobx2eXiqdY6Ct99P6jh4Q32Bq+T8aEuOMOz5LMl/hbu/Qv30irTmvUppLZSF+WWQMvO22FmeaN
JEKII901Q2+FPQ68JI0eh8EX3+3f1lvZDDdrkHIZbKTwBFj4fJXajS8Ke+MEYNqsspnSA3zNmWYhWt6I
zzx88jA/rlXXTIK0dxvIW/sUr/apq++OGC20uvNOsx0lHZP6BEFFgAC4HUPn2zGkyHtmNBWgChidgxmI
v+FYWFXn8an5vQdtcEpBUHix4pTWGYPU7nzsNpFb28yE4vsfnaXMg1nZUJ3X2U7ZDu3MDsUUV+s+98Cj
cqbZiyLqFpz2/Bamzuj3DpvRGVGpI+IgRP/UlyjZunN982Y324j+RGo6ehO1kCaWPRZJ2H61HMgV+GzG
Fi3lPR7xPh2SmntaMMNpyJpnU8+a74T/Nx7+7J2PylSb0qcH2ocbd6GeAqA9eqD1qIiydOacQLvwfhbN
0tOo74H2sQe0zx6Bph3Q6HSU0My/DbTgpO8kAFrJA213CGgQteaBQBsHQOupxdQzgjsh4Cc4kRZqHJe/
N9YKEy+ZwNS172Q2XtYLBxHw7Mg5HyrbmiVeFm8YITcr5mKx9/ERHU5ZdYOdvxhFAqUvfyJW1OjQIHTt
KGz1yty3up9Bq2D345r16VOdtdGR6ObDqXAeCT55bg+eBZs+t0VPF85JpQ1HoJ5rW9Kemp+DJWgf2pac
EDHWi0kOG2TV0xUgQXV0ItaSsYXb3q+MoiQ2ynKaL3yAWz77pby4Eve7KS2m1qIF+ogouNHMSs9YnChR
a24ClKbHRaBujtTaW8Ho9FeIjsOEZXzeU+M4ChwYDcoxz3VOoCjkLNNhpCrrFSEGJ0/C6ivv7DjOMvMd
sm2mgasA+sc4VD+szWvyS8AQweXaQN4EXy94apc9nYWRSluNZn8WLOYoOH0G2kiFc7C6rmgb9GwHnVSu
g2fCCobIEQY4TD9bTnQbKAIBpD9KDuWuLSVRpK3smaR0+PXilc9uYxonvaUgrbzo+1Uc515bYuev1Ezu
T/kIYrXfpI4/fuWNwSkIg5nqdAP7/Eit8Uo6IS9tsjmjI3BI9cr9vDtny2so/SBLqT7oejDZxkykYpgz
BUagKN2Ssz6ONxFLG9XUstvXM78RKaehrm296JHfjT4qogVPy8lk7pw52gzzDsFP1Llot0wGSqiv3+gg
FHXsMxQkq6AbuBQ2muYX7KxX+NP75RVbGxkAJr4EJ1sae/Aayzt56HIMhUTP40scJ8222ld6jbldUqjr
y4LbVD1Wd65YkpOvLsWyMOt8x8+4wRwWOFh77Ippsx9KnDtyMUq5wNnYOiGtQrc4tY3ubGspQcZxWAF3
0vfM0hbaWMjn2MaBWgPV827Q1tlivMSYzDPecekFLwy3rBEjPO8ff66VxAe8NvwxtS8a+N4V/ihswX7z
bH3SEQc2YcGN5PIj/0vau0kCmehKMRDixBbfvf1J9RWLCoZ7Gw3fgrY8O5tCnuqBliqg5JXYJeDG/Hzi
wz5wlJERCKcmXMk5hcAjXi0xSB49u1JEN8OAHfWsgPtiht6PQ7E2AYG1fRhkY7cukXTlOSmrPrGRUYnh
+jO3evzVsrD+yOZBC7ZhFDM0C15sLkeHjPtn+/MK5Xx5WDaFoYHVnZ0Bzcyds+GB54tIDUuGZsVhautD
bynBcVIemg1+rQwE6NUhwga3/LKGyn0LzaJ6oRkLV3ROtHzTySNG7o79S851IMxH0OulYUTdNzaEMYz4
SCEzfafc9dQUyNKaPjxx7AIhMJ4FLPAPdJnLgOe3y27TrIwc4gHUF2XlOR2CRhSKlmNRwfk+kT91e6HH
pP6hXnmfbXW0fxxFwdwemAHTU8/Vme/2YGNrPwbxE75WNhWVQVQ4pcrRP8s2qSsAGbTuo05giVNIbOOD
r6BPWOBu8r7bdevCT662ODw5RFmfnPkQG9J0zTWIap2xDwzKK1uLUbBdVbdZyBFjXBIXje9pCY6ckZsR
FSkL1RVc4/wv25BXW9j4xMGlRU0fYmkRAjgo+MVqdmHE0Xxp35iodX8IeXjim/ZBgscrn4su3SUlwe78
M1CVsih8fn4QitSdbIehaNkV68A7cdgys3amd4Em+J/NbGIT6JcjFfR6OBljU3a+GuwmKMt5ezk82utR
WIoaHiU5P0hyc6teSlpAkLEVPrh3n/Rx8W7fx5sg3b+ndmF3kqNf3gi+U6HkqBy4ge1mznnORwk09Uj9
5JWYJzwK5+m9sNkewkPtQgqbV8HVduPFIfurqN5v4gn+QYu+UP7vEpR+8Qd5/WRanoCm344p+2Jd4Kb+
xxzYMalou3dQY+V/4Uxzyo1MxV/VArytEm8L+XaAmTjepXCpFtiDIoJdhQ0ydopb503ZwhH0BIWMx293
2Ypll7+xJ33zJUwewWkJEzZ91l29c2ZUqksG5Zb1wcIrttcBKI4/HChssWoi2Z8nt3QB1yNdzFk+LK2e
rq36DflLm9+a+Uw0m6FrazTH7Cd56kVxXwI8Jl7I/Wh6XSgSBoU/7VSf4REV0C6RA1a90hPBE1OceldB
+yKoetLlfxYgWEzYtyEsK/voBBz7gvjGqiv43Rnv2QR+/pn68i6Klm/Js1FD6IHw3lTnauNPRBqp4Xsw
cJBzNdMbioauZtPzCnbk6oAaVrBq2ERZfwMHy7LXRJhm/kyOyXKUguli66OedAS1y1+TuW18UV7WrZR3
+YIIFiDE2LStIqwQrjhSZj33UAkO67n0RwZ11IAW8/E06M/0bx/Y79KvTybeamqUHRSbx4xYwMPNF55M
AoWfBtXCO9IXFGtLCzurlWdKE9DPFvNc8rgRtjLXiT38eivhjxjUs1ALz3M+uM2P4p+in9KeHYsH7P7M
mNtoT9w7EgPY2MI3dlrSJwVYRXEOtj7ySBjHYY/fv1FSl2JpcLDqwPtdedCKPFx/2nDinPmNPYp41/Ep
Az3rn0PvNeuzOxLuHB0XUN5smK8nTexS9FtKeFUbb5n2VI5kDQ4W5Wy2jXGNUzC7ic/yPeFRDulQLFmk
9LFppEw0PIk73FoU5xQ+kRpxNrKKmHCwjtVIuzPgXFbJqrOTaWaZ7x+6CVGRnptN1g/YZJHH33DPy9dW
d+osz/8P9/4m7p2VIJCv7sZ5r/zs6Zoj0U1nrGJcyrl/SVTox6siNVS5Tw/Lrl9GEQUGST8eoB0d/Bjl
fnxPU872C+gU5ayHCrw51X7ct2Xsx+S1R0ZM41tIv1o/Rphgoi6obZ/nxeZi76t6P760LV+sINgV/6Q2
+j1MnUbflcLbddkuN/a6g9kTJFizL/mvQMQvvmqXF6/BM3a+1Y+Zz/PBtFpJ2JHmIChnSQ34bmBd1nbe
BfwiIrvdj6fyNnp13tJZyzeW2X706Yv+xLeespObqL7gep8Z6IP0MpxzQ4XbFupK5yYqo4glG44t1FIY
uDQjH9kEgEGQVo16BrNXz2B8PcPVk+MIpO6JrTFZBQS28x6SZpeCGIyehVYTpv+0rqjBXWcdfIViusDu
xxv+dCQdMwpPWSMwBNvjgFcde0XgEToPyGdFEzsrN2IsG/Ewy9WugxZ1Wx4XzeD1YOmZ0krZdBaWhq+d
OVhgsfzCdRFOkT5rp8xsC8atDIs76JJnSCqBQ7S002soKewFZ2sLZp/CkJm+2gpcgeIdyjr+MpveZpQO
DJU05pMP1CnSsX0RSJSMw/DEhl9cO6tUifSgvFQYK2aWllxq5C/f3Cw66opUAAXGPF9a5cp3Lm9ZL/l1
lsPFCvYbOvcnJQeInoMV7kh4UlU0wmmQckdxBVAV0ACkeCRYXgCm5aPAezgAUmeNkNlncGuBJOyUsiAZ
eINipoY+qMiE0J3GsmzMdBITghjMJnS/HH4883Xg8QreVWdr6U5HHUCLkxcBhkWLIwEvT833LOcRzt1K
maHxaAB/W7nyzxRiJqxRkLUNLWLjKA9bRxdv8SAbhmzMKaOSwAyuxJfJnyvcW7hhOgYc3Uuq252waSmW
1QA/7DgwNiB27+k6RejlfrRHKHWoynfRQEDAtq1wL9QElLcYA9VGt3sMsiojVJKwE2xta2XASrkY5Qq7
TsK+VByAGsIlrHPWEa6UdwS8gS1AObZNaeGj5qPCJtDdrsiKMKDf28ozFZh4wooK70BAf9Jli70YZVEX
y3LxyhKEPxfjfFle6R1kU3oDeSkPeYIJnv4MPaAT0/3UDZBu5ycwUeuw8cEiiPSMVBcaPE2TnmYHX+Yx
1MXygyzV57YsU/Kjy1HMeuJUVJ+qqP7eAUXdgwjAWp5wesNCofO4PYm3H4qsjbfCWz1/dBTt+YHJEtJx
dG9MiwIeZXuoqUXGTjDk313iVoE5nyuy3wvbdv2TeTvZscfwlT0mLGl8enTk9QQ8Ll0P91hI0Eh7mTnK
BJjxGTQnRrjOyRfYHaCRMCXzvkSLrZ5s8f99R6EMvd5VV/L/bYn1dVWbYXT7NvQmqO2ZYicPychYmu9Y
33B2aC3cZOItox04D+N5/uYfSfIs/c3blxv78nx7sgdw7BbDta9ZApQtor/Ku3bkWfh6EDw7UnOQaMq2
zz8zSG47SemCfafmrtp41klWagbYzDsJaC+9BDfJ2zzEqCOveZZ5EmolwygkkqDALHm/8FzwbROIffkQ
PDTvghYMPGwD50E0XkK3YXt/PLhEKP1SZbHP3BQ88MpJ+Ki6mh6M6oobJetTYdinAj6Hcn4VH2INqXXE
869zVjStvfw2Usrgzrih8xFOKkH92lgFJbYzlSsEaEtr6FBVGgNRTCX/YiNywzhIn6b31WeQvj7GnIei
h9tzq6n+7FTHUqTVC60v2eqFTDceZH4FI0eDzKaBc+rSb8+G6W9Mj8l3fUpN23Kl92A+l8Ryi5BXY++P
vdTX/I0M/tXXgGxsZDg7/m5knOpqouGz28R9TbevXfpWkoLNDCj/olxQbzVQR0M/n6QErpMJdGo8rN0R
yMI4/nSWAgy796j23/Ea1HG90tAFvF4nCje3gbjPFsFBsk1R6Z4MaRWV1k8zS6uP8PncRQvBSErk9sqr
AyM1/QvcIPp9wwfqQDuLD9RiuT8dY52RXageD6y7hSMWSWUxEuonrC2KgTT6Gr55W+PSM7BzYyS46EvW
5cC3plMTKjXE9ZmBl1gS2FITzqwNuGE+NXtGKlVqjLCQ4rURAZcszSUUbnhcY6QT12hZDH2juH3U6Kbc
sZzaVzUWE/AntJridle8e+HS11o02BbB3pjRaT/A547l3V1rR5GHsSQcOnlyEfh0mwPypqCtlk8dxlnF
tkUGWHnWAxyTZZbAhGYP6njZTr6JvASJRxbCsSi5627ITHlqCCGs7Vifbqy9piJoMlqjr6Hb88X0h50N
5rCzgbLgm7eh/GTrhAZtl5drqIxL1adr02ZfkPVqm+T/eEm1YeKVdulXDd8fPTrdt+7YWxzvvymBtc3K
UzZIyMri7ai2Yp8FSBMfjJmCmWfuKMnOrkq5U49BUBawR0wn79mjKu0huqxA5/AaxoEe6yl/S9zBexs1
Qihuq2zHK3odrF4c02SKmfktPHBcxdnAvdd1PCv+qNUc+pYrQi8G6d0SO08iM9QXKKkSJM9Dzzf28Pjy
6d1PNrBhjZprhIL/6Bvr+Bo1KrjanPvIT/PC17tbK/PGxyTrJ0GBanhrlr/TUWEFp6UBIGwRZtVMXemj
h+9dQ+i5ZL6RLa6xLnoWrEwti7Ydm392XUpZ9AjqESsHg/5Qgu7aNv7NZQnfEqilg/CVA2ftzdM753sV
pTg8k0yHeZK/9jCkeraxNlkirQWZ6tbcNf2A7SVDnkH+4dvSH488s30LuYldaeEgp6Fh/7c99QMBbGOc
PV5pW2HZ4ADPgdQzBgdiFuTvguAA7WwTOGjhMyIx//AZaeczSt9btZX0t2zRaSvpl7bJnq3QZnCiF189
B5SNFOVUxsj7kWKly7mwV1407fiyPHYJIDeIEZatTuZW/BeiomE+WUEwpfjW91ys3qs41BxBmXzsZUHG
mkv573pBWRC2ELNsN8otw9RXtuZjiInMZO1j1/WV/H0rIIUe+sjONUzWs51rtLTf/83Ri64aoI+OYkUl
j3YdKzhZj9RYj6Y/a7uHwRH/Vap+eFvT4eBc27zZx7VVq49wwg5PJDdzvQNHe8xZrt1DFlAevxbmmjlb
zb7N35Qiuseo8DkNCj3rl94ybPso57ubWP0l+F1sI2TMQr21qtKlz4h1xzvaog+vsyYXJiOygii0xY5k
6x36Fd2Vi5fokFy4UkihlZtQ35Sf2FiGqKAvwXaEjitBMTRySnnv4ZcIaxYI2D4hpwuPK435ygu0t1ZA
2m6g7Jix1TIwsccrD0igOuOzHe8ofQzcRXXWRX0He9f8Cnf2cXr+Y8IWVtqMAtt7L/vMFk2vA5T36JvQ
eLMsJOsL8uMnvReg8r/YbFaB+Y1VZmSYKdTbE1Qx5mFaFgbBrN1JfbpyGvTs8pHdmisEsc27f/ndFkvA
4GQh7SKmoGTN9t5qq9/XWP22surfWw+SxKszuekWun+VCzqI/reyzOqlskcUbb3MGdF2Y5k7sLtWCbrV
JDkni+wJEC0SndywCfFtGuAb1zNaHUZHnDdQolcUiNhlxGKgz/TlMuheYA/knwZqDByORKlTxdwU5oOu
1RYGBv0ZD0dIboVJ8khbA6k7PPnPRtRGLJmxEu3UFwt08xs4EsRBH0P7M9087I8Oktf4pYgviXwx4m8N
kv2cR7GEuEm5a7NoZ2rIdJxURFs8qOC9tW5+90ZOPA6AGjQOt0ELAP5IgpZ6LXI8RoSX5QfxTISSvpU/
qxJS06z2iMkfML87uB0fu3ke2P8xDc2RE7thS0SNvcfq3mbs8HrEKVTdmKnhfurtdttPpeyfME9VHHke
eAhNZPMGl2Wntzye8JnZ/5+9P+tq41m+BNAPBGuhEaF1niqzSgNCCBAyxm+AseZ51qe/FXtHVaaE8Pmd
7tO9+t7/fbFRjVmRkZEx7vBU5ZzhOsrrNmsRgBQfSs+hwypT7xvJDm873/Xw4fzOqAYSlduuuSqiK3vj
klU6O0eXqaHDib60H665ZLCbuL5+EKz1ovGAZDalMy6zaam+VqSjWYkus/gQXWYzP0Dtu8zmEB5nXWb5
yv8DLjMGPgGL1FDf2dpcQ72pbFSnEwdaznpUPfKFxZNSdI9+XcGPqt41ZKqf865ZgljOIy6uf+g/K1Di
QU1dmN3SbVjtsS6HFVnVQydfejUn3/u7uupk8bxa8fB/p8O37+OG59XqpI+J2Qc/oD2uTNqaHx0xi5XE
qR5+LGE6MqVAJc6xP+vG869VKysy0azvo1KonoALIzKADnXn3NenqFMsW0wwpob4RcfGysDkpqVuEVcE
Wpl9wZogXHCsc+IEIU+OkFFXhqWLuL+aNaOj3PSx21b8zvAlr3FHi0LCeSVGCsxEKT5OnA/iXlh5cZ+F
g9BkgHRqhsszUpyIbmwjTcZrCeNVGB9jACVnNk5JedvXvj4lNibRYR9/7+0NVDkaSxRvTd13y2tz1PSc
i9eOTIFvIGGGCVjaRxp2ebr5cJbhXosK3fmK+LyqI3OBq4bESfbOs7HayPRhBE7NuHZyATTIxsgMEbl+
8fI404/UjidLJX/1JBUeQO9JRQ7ibNrbSoIFUrxBPNrE7SEYx7auGAgUtiEzy+mg0fZYnpvPC1fVZDxN
qRxKpcqNSaXKtdn4wlaBQjBUjTWGVM8RbK0GI6+oYuchK/s1K5jZC3Pjqph+QSJ/7sKR6zoSrWnpxTuY
uIugWv0N73CsE12uOcTDMbM0gWyggIfE04hZaVrzJIx1TxqGCpFGVIN9mJSZhHwiXexE/4iqyZrIGqyI
a7NT5wQpGU9gNhIODhX2pPeUKLLX0aNbptdP6Sr1+rS4/l6QOkSNUgGPYL7kYct2c/3h7TaPSeFDqHkK
N8BvO6SGaghnWIkpD/0KM5rnT7KHfSlmnxrF8Jup8UScxKTudks5wBjcjV3g0xkTAdaVLVY0W1QXGx5m
D7Jo0hAJ99mB16blkwA7iMxDbATJMj66itsktlawTLBcnLlqzJ019U+nQZXjZzmw1Fvh4WbziP+0JhTV
DKhmzKF58v8aK4ogE96b1rxH/I0FSfSDJr0p0ZnvU4h29MDJg58xtK5cPUCUfl5bCfjkSZnhhZtfr/Ia
DYR2rP+6YEMcTSka1IU3HrpNcgStXSFMGze02JoDLfuCOq/SoCm+jbZsXW9TrA4WdyftO7Qhwx/SLwGC
1Uuplp5cCvnFYlGNwNBuhuRMoWSLc7hdkDPfN9fqDCjh6K188GPWjJdfkeAyjkItt2lmTLHvLcG5XWFe
Fsr98pIVHXoasdC26miPV/WWqHbIspUc8x/Fs9PQ1gHLo94ZaoMtLRHWtIFwwY5mXqkH3o8kA7qa2VRP
nvK4Qru9dP5pgGjRJLAd36aYL8hkLs5F6Go7uibvFUZk7o4v5WECyvSMdSt60fSnSv3Zgn0kBAmFb6K7
/QbjYrWsJ3Fk0xDnfZ1xGwlgam+6Hjd8+gUyYti1AjsJt1tXUr00ZU/NvG4c3UcetXATvGoIJ6J23xqu
ocNz57OlsdOaHrn42GCDHy3VpZZJLtqiWWS0viIESkhsJoldL/u/mvSSZum6RXR0f/2p2NBLeGN3lvXi
pY3nP9lSfsGWCcoanD37sK3JjE0qRmwDJs8d7WWfLpNBqtDJEnpNsrE2Zq6gDZVUL3/LLdzFBdP05my3
8agk90+iudufU6gj19qA4mMGE4EJnCyguEd+5j1c7IwrYMutITCaM4dQeYU8rEt0tvI02/nKqRfE6JmE
LKuX+7JH9RNYksgIptIfG5ANaZ8sJtKKLtbm9aczcT0wRVq1GaPJ3fLQeZIlGU+fNIUNf8GtvuByRTlE
QQSwLE2kPM91IcvtsWrQ0O4+ekcFjvaCbOsV3BEld1RwR7UgXF/DqSpTsWs4UT/6plgIvwU/IMU+F+FV
7YsE2PlwR8dQl6Xj5kiFmpN4BDoZEXF0SVodi4iNx1qe4kjgaGKQNIbkm/SuKiTvG5FvqzoLStPYhpKx
X1n28F7+OTsvKTzaVwykTmJ77/ziuF2alVJJK6saFaXDWblVTeRW9/akebOLYgXjiS/TZhNvfRxB+2jm
Ek7TE7cJx1NPUfqc6C85Gq/PPwFrFk8Oa/N25ttsEPeMmJsxofJy+JV+SGxZUm043ZmkYsLR6013YaHI
iyhCtwH8CkxYPZ7sKy9DscFws9shXDqnRuEvkpwWtcB1ASfe/7VzFnCMdbbnDGaVcy9BMkTldek98uMw
TiWl5tzN9fTEPeNVgR/oBR4yIXxpvrtiZYakOcqwg2xM8Y46GVxqoqVqFmzULP7jT1KgcZupOT5MVrjy
CxUDyS1BA6wF71mG9CCswlEldds9UiSH8Aetj0RyK2U4z4yA1tMqh6xojb+2qg60GrcG5byNBhAZmMNK
j3bqZd2vvkHx8oEGYQhV03v6C7eKOppZ94NLauwhtP2AusO0loWB5cs0ULilK/fphc/gQNSXz6NZtAmd
1gYHvl25RnKfXTCioiPQirI6i1a38F2oYC1u5r25IOJDtAvhLNO+0Atou4Rzr+7EqSwqQJfyLDi8xftC
DftafReW4b6HYVtfhAgDR4SO3T54K1AOqIOlxTmximwcXDu4owbvgf2f1qElkO/UP/dah8YMpGu/Do2J
YtRM5z6At+fZobRdm/U2YQY8RW7M29Hdl3ucNqXb+pLul9uq8600FjCL7ub4r42ZecbwqBJtLAv5pSnM
DI7uRrftfSc74jWQUlG5i3eAqI1VL/7G6M2lU6jz93dyoEKvXjPd8IM2DbRn0KHrurW+DdoJARLXVt87
O03FmbY+YNv62d25B1R/9pkSvRg7fXNttjuPoNCPpKlhM/gF67VvYk1y41QINYbFZn1LSYtPSEDkQD/4
XiKBfEuJ/ZJn9Vbh+XKt3crsHyZi1lN5Mzc3IISCibk8zceZ2kZ7Amy7+FTGdYKV0u3jy/icgZ+fqW0L
Giedu+aaSsUlpDbbjS2QOkkaJZ3RGht0E8z4YDOPl1eRpP4x9SK7fSYGs6KF2elZ77TXOza4eU/mRn0G
WR73abRrejTiU2Tav33js0NdPpLm+Ayjzl/SWj9fKXspjSTgycnZcriefw3qHYZOh2h0l05xYrljVvs5
bzzc6hN8dFxwkzBCEkVti+ABw3z2ogQo0u/wsA/RJFCdDtehvhtuPlYvjw62SBiAA4rZ3wKv8Lzrht2h
tqOiX0a9YRqaBD5cM1UFQFXVq99zuChvm6GKqUhN/goONA42w+ZQwdVd+qS17K72+UaaUobS9/XzOXd7
LtCFlPEsXRTYCfvePqFR5t7eMHojS7Orko9JLboX4kvmXkbr0G5h+iAEwJSOPz8uP2Ld+d7DigmPh1E6
MwzReP82jOG9x7IYRhbdIxYqaTgMbA5MXOrZ93gcw/Dea1TuquLfuHE43S0BeaDi8+hwhLrcMXuqAByc
BpDgoDJ/JfTu8My6+Ja9uyWCXcpwGVE+ghm/Fh2h/vHX3rivZYrnTSJ25cEk48p78N0/nc2Cm81Q/qze
zRhyWN+f3njV+ObGeHN2mJXPyKQciT+6KY3WmSarff/Xbt34jf/nO7dRbw2rJ9RXmCo0jaylV/Vt5/qK
jDmy9WO6PhyUHnXjpR1oWyAoLu/DvQfThZsHXFzlgd9Hm9Fkbkp7tkU/eAJz7MnKF0RIUCDABoLcr0f7
YzMweEXq0NN4rgNI9KOA3aN1l+Ngf166HfuCID3wiFUh1TXg8beba4KI30CfuyA3MWevuZMxNJb6gjs2
zu3bq66HhN9rJFcHtKPA43eQIm0pDEivLHgVex28913oChA/oHGl2VBSjHo1UOpQIhDWC4g23B5RhmBZ
x4RbbAOpaHQ5jJHCOAE+fo53MP4ROQhxllqekJ9Gz9Tc+H2Vy67NpFSiN6B/AAfNZSpXXXyUX1Dv71Wt
qUq7UHntbxxf7FJ1xysmrwKGkGaBdVMvJqMw3/AuTf7NmJlzSYSVWExWeW05xKWlIz7NcTqTVFatAkW6
0K1Mbwc+u3qOeHbwT+pqDmQf4bd8Zr1Kx8eM9+N1s3C24hOH5/VBr6SrWdhE2qCn6Z5B+owq+r5CLHkd
+IiU+I/7D9cYykWxR9GiuG4ncYZO0L39ufWbs68WnozhCO+Tl9AyWpk5oXskDzeUF0Urk0P2wCfHquhX
dEvM7dHBBUXAHqx/gFNCY9YrSVEQAVWqnifg+3QPeg/td1eM7JRsNcfjF+rzoBlQ3nkBnT6+jFGfAiOf
g9eUiZbHbWRiPWCobtoszsgqiqKJN9PVuZeD3SzS1XCfTFyN+ZhY9k2qi2txv/7Cdb1bmcaHC0EDWDdG
lZslPvNjxNqDYStp8bBpwG2/ja/BHvo64RXjFuV3FOwaqN/Yx1dcReo5rsMLFbOxtNSNRLmINH/ZrhQ8
DktKl5eZbNVzdwn/lWT1PqJhqE0bRDjVZGO91v2DkfFav6ddUmOmHxJMhX7CYLRw113AykvabI1JUtbC
wJ+Yb8Aquom/aABlAIW9VXXMX4mJM7hD3uUtglz5GszS+Y3Nh+vPLxozS67p2MT3KeaR6yvb2aXJ4I+p
pcfhY4Mt4E8qNMjeZopwNLJeBj22USajnIaJ3tKFdEXDqI35gPjVIx36E67m3sYjVJJ9pEIr58qMOSa9
trc4c20N1zbzpldDZq+M9lciiG2QynrqkaDM2AzVNTc6gMRJ4xWvfxyTx7cMkCB/jgXdU+oGj85j8qi7
+FOyQu3jFKXYrpH/0bsvmBMwOX71tHP8avoqqt0/XF5RisqGVxLKKX2j5H20mesdTWziua8mru4jUNLB
wcc1k4tmyr+QJoTUsFPWn8vW2NK8cBnEO1ZIxiyAHZtywjiFReOkH0wBibOSohGivd/BrLGPvwpEx0uP
Qsr1YBU7OZXOOw+isDV2TDVVe8+p4Vsz82LGN3Aqsi1EvecyvNqIBjsgZhtdeRhjN16jg6khYR32cDW6
cCkcrzyLlBGcXBoM7w4j6xTZ97LQOmqJHn/lS1JhIt8LFcJHZPS6k79+pDMKGmwl0HyMld/9mV79tsHz
39PLA63+ENs9JJjp+wKNX9+wFtZTXYCbg5fJtvTKoGpQeXfYB1ga+LjVTUEOOpjO+dpZ+S3hw/uAjnkW
83+MHIVT0MymfPpdsMetUL3u3g5e5m96YUM+6Tbgm+l1f8tSSxOn8KdenzN7aJ55p3Q/FJyC8Fp01IQY
fHBloq1rujwIn4W/l2bDdbLSFZk+COsxlAxbO7feM6ZPKeN0DUtp+ASv+ye9VNRXA5d/+bqdGm/xrvgr
aW2Q3g1b7klY7SWYO8S6FxK35JzoS5P75cY+tOQMGF4Kc7t9TdhfNz1oos0dkeACkj5C453HpPEOQV51
3yOpHOxJ0CwtfZfLW+Je4njk4pXUWkSVpUxdRQgXvWn2VHBAX3d29r8xGbBvxTVcblR0YD6+WRe7wO/0
JQUzkose5Ein58aaZbr3jlh63Gc3BCFex3vK7O4o1yESBxHUHxpCt6ert51i5jkb9S1dhIj6Es+ytXf5
VC0FFsLtAFom2AOjBMKYS1s0mUc3FA9ackLnUObLUJopkmE6lIxzo4DJR/ZEYAxdb2qXJaF5Dj07YcVO
E0u7+NNb4cuf6QIX7Jv3FPSGKgsbZYJjmUn/sbCZnTmtr7tyw3PK9UHLP6EUkBt/FYE/jZKBh5sKF5zY
CAt4MvIeCPv12hnNSDhs4WnRwlw5PI7HvUYkSp5h+0ELzDpEMZd95lkEeHHWlrzwXf1af5Q2nsYknykc
bG8Pzshtbp3o6wybzjlfUO2id3euT1qJisCf9NNQhXA/dzKjWfg3D9NH/ErXuIojxAorz86lUXD+/Rbo
Tg6FL6Frzp9VCn5z8jfXo9C3qOLzxuVOx0IFjmY4Uu8Yf0KajkKJwlH5B9rhhbkyOb8vJVaa9jdI2Ug6
pAKfCdL4reel4Ldvlm47UyUH/yXm74gw0ldAcvfWyfT2mAH+dB0aa7wcArcaLoxb529kcOzBCNlG+KR6
eew8OO2uZ0O99LyqjQ5rrFK0xVAmSTKSpdkufFEt3vsgZKjJQPemZ+0peXq+xnTtKTRdw5LkJAAhw9Fm
+IeDN6g9f3jl5Z7kxwIY8BW3omN3rl0oM3o+bPyavIPThb3qsInn1IMbYGeGrrytNXJ/V4epJyBoX7tO
vaGXdqYI+SVkfz/B/bc2ebut+nQ5UkgnJsNkpTdBgQtF04gUUuMl3kQrMsqqHpiK7VVD0FKPcJaAI4Uv
iIfSTbjhVqY+Z9KH0W0iMC6qowgMQfSDD3AOiPmJuCmZstcN78bvhleNrXC1ZUQqqh/XOjGUIceDB1k9
RPcROIANuICk6PI5POc1fFDXJnFWDrzrPirp0i6ZE8zV9ir0NMgwnSX5B7qxegCEgx4yThhVOjIBbz9P
6LH26FEnPcCAu52nqGoYUVd2FBQX92jhWFjcA+o6/n270Bt2aQ/6+GzOkC3jC6Arxoekfmej96/1/s3Z
++Oze8v74wvgvl4vkKgVZOxg7alA/bVbeFm19UGxXhpWeJca46FBRS2Wsa1fjhV+LBQvbd0uvOX0qom7
ItJvxXPSsJNvTt9JbkPz29P3QtqRmaJOPmfeY6bPm7d/xcQzEhEpAsI5jwDlTTgxMJ7WCWDCW5qAmBP2
KrMR+DReQZC/F8l1cyNCkBcCCOYqBBWLb6eKjLeSOolYvYZmz5T6G6QnMiRaQCIkyusFUeolQbh7cuxz
4/SxzzQhOhaVO8ihpE8GceRZATINpxgKkeK24Qy75k4T3OXreqYU9W9d1hhMDTt1cNLYYudR0dgviXkL
5/SE9UuFrr7EZt4aeJLXq9vLeXV7c8JFmLkzNz4ItBzkWcOjnuikHBXdu0i7C6tZ8sF8yk4OcDyxfYJ6
qn/GzHI1NzKseINBnPCFgw7WkvhoxXzvLQwcBPEVNIhfNseXiJzGR0JrrVHjbaQKCWBnsEk8QPmdRQvS
YUXAR0JOi5e+KsOMWuqojvW0eL+tPADA5ZH6PsRGLW223qhPhJb76HaLpCBtnpadOjGiiopkuZgcX/im
jpCDUIt+iZ3JYFLeNt9MCvNnh0xKgm9K7qvGz0TVP4haBdPVhOkaRSoHb6vzz1NjmxXJoOCNl1zwsvHM
4Q6rzwJoeA6QGUZS9f1fehk9XA3Ntr5jJhc+KbEFL6HoO6jlvSn6b6E5zr2cGFENe/ZRmj2z82/OuJsT
vGH2AlIXljql6u8uNOJlZakV51xpL1Fy7lkEbNeMLPLuOa32yi0raIHaqQXunej2kDVf1P8vPZD6Du/D
GwitoZXdZD2daJn1dSLZ/sJLm/b7USM9Slr+MCKrXSRD3iMk6Dlr4HGYplEncTsYOn5ezfnL76Aceopz
jaZtGW0oa5SssBp+cYjJ1rsxWBkHdgsN3tIFFP2+2ntbF9mcvce0dyjDBjNtzawLQG1DMN4A1ThRwqGq
WnTSh3bujtl3bej2q2dmGlmRbLdHXyuaHS/f2BAeekG4TiLXOBj7gyWdxJEYWU9SqhzJ21RS5syNVy7w
QXsCZ1jHMw6Th+/jL46/UKHXf2w8Mr3OD87CYq5S2eOYb5ku62m/j4WMu4i2r2zA2huo3tv41sHGX13S
LYh4Pmd5pEKWgILSikaeh++V6mQgvcoEJScdfqCARr6set2rMXXtXVxkl/GdVvvqg8jEOVPyb2CMtUEW
dHPyeJj5n732miDGAmnB4h59ejXVFtaWlhPhMjP0OWSpyuBz50b785pF1nsiczByOQYP9IP2TrN9LLrR
vEofp+dg4/XbmObcWP0GCi5xRhw4ll49rZG2LO8W57nWakSiN+XFBWYjLaDMuEX0ca01nLgRnDi23o0s
Oob0VRW+XCX0lcybuSEPVIV1isaDw5pk3We+FJQ7eas2pfdvhZy+Y08AqEJtuhr4rF7upLyUHvjf16SP
quXv5KGBA/V8J6wzg/0vv0/Pa7lagdJDmxOG6ag9LJA5xSyY4FYOt2aaQzeoecBqmZqbo8HuxNIsma22
n/Je4a1Nb0O4hGeh5LVDqia9kVTrqvGFidYFRUizXcZWtSOoYvR7zBOpQmCJtFYbCf+yQHIEgCZk+ZW2
Sty9ph6rrhl6mUqj02/Ln/22uitQ+vYzZ/b/3Gei+oe5NMefCfZplUy6PU0ibE/rh7LxulEj3msP/mag
8uKZ4wIjJ+CJ8b8XYdFmvPIYbdbo3c8xP5Mqa3zeRNUj5lviX9avLcINAgey5xdFu68G10Wa9x8EJJU8
3VLRIFAfn6IIAjojS5Si1RvXj8Oa61ynyrDGTfcv3wyv73T+t6XzLimgIvNDiR0DeGpAi0QcssBmp1VL
q7SZOZJ42kHOwYh/0j2tZhIzIPgZfe3tyBxA/3W2cWDn3dxbkh4Q35vnp+bbSU7pT9w/NPlwvjKnvVkP
Lj/9hW9V/WvhsGVi6bbEZUlDeZEWpXDgwiLtUvUUyq/gQnxe/mkk+HEDySysBv34PzivAk4ETqAFaHyG
cjI5BUlHLqZ4ToDwKZ8ncB2yN+FWjHY7CHfQ5PqSxxZdMemlciHO/2rZnlc8ajfy6PqVWmu3F2LyNrKW
uOzqJYVBeos01I8rv9Vt10ULssYVKzYP3r7/mEs68bexlUNyXpgrGkuEV6jShy2qx416+Pj4ctu/Ndh4
UeNro1ZMyVkYXEEVUcuvKkh1sjsLS+iFBndQfE7kf4j4WLSzU8AHdBJXtnAL0zSrO5sVxmVGT31nL4R9
bvGrsbMjYsCNHYpWe6AuVhZ6gw/mAh8ox4YLl28d/RjBEZ5+WCnn9stYSYTOqgHFnE6cJ1uZ8vJOQgYp
GauNovZXZq5KvyXfihUyV/CmDAeb/aUNAapHuN6HkGiRR/fvUC6HCu1ww/w2PS86NbPchuL2CUcAteuq
kYezkD1RtJQb2MSrU3JGV1sBIvgi5yvfm6MRaDqjf+NatSl+iN/C++gLlYRD4fRbWVEtpk+wixKAzMSc
DAPMLBFf21cUYg9OatJ7jVAIX5V/T9/YUQ3qR/JELXs8MH+KdIeLOH/Rak7y6XaXu2i9jvEzPhESbO8n
j4uqUxXfdxhocHPl+03Hno45ZMQZfG9brg9PtbbLe2twm3e6JC1CF0359DFcE1moiF7BmVOMj17bg2+T
7L0wlbsUc0GUpX107lnoIK8pDqcj+qPErLqW7KlXWSqH61o5/IMSA8G5z+iKS+C7Te86/bpWcDiyTjKe
UfUvGzzKyB7qwhItodhD1/iJ14ujlU7EScrtKWOZsw5Vw+SWsSmTdwQa4TOBai3YPJdfLpSDrBpnkuEK
pkVD0LFqUcEz8F6LGr1e80kQQ3NL16T4KT81ZE9EyDEaoVcn3M8nbrW/DfQ5sI3B0QUzhsAt6ia8Z/SV
dg9T1LO6I6uhg8cVwmRIW6ZyEYW0vlscW2rgvIJJDLj9QmprCMiB9IJX7TkspFmFyEBYxjvX0tvANZCD
aWLi5BR/wzrAIi6ljWV0RiBM3+DIn6EmmD3d65sXPjA+8mtSS5PSPm5oV0BE+Ag+2ZxnP5+AC+a9tFpN
cYjkbg+Z7jXrGGxFOerlMT520wUaic+rQokdgYIVpnK41tlRiZz7x93vUrE+3ZBzzlWFeMbC703TvkgD
JozvwIasYJKaJRdYaV27qh2e5EoWGazZkgDQrjavvDhJ6zG56RbQ8YG6cBauXv7Fw/v+LDlVUC1EISY9
eC/X3oV0KELplAuf9snqVxdUyJoG1DnEhgveSi29qkw6qrP4QMzVPXpSVLhxqZMxSkgthYSJfYdGzI7t
fLmEoYZAxIx3Qo0oHqpeY+aqBlZhq6s10hX9fUW0mqucoPHJzjTHav48pD0iPNhG6KWt+vhZwyKRZCTM
cp6Yn2bOuwxuXP6DRl9D7Y9W9JwB18aTMu1pITV2SI2NYSrTEXZv/zNdK3QvvelFVy5lpm9yXp4WWwBq
zS6kXyMYFbyPWOpHoAGA55cr+B8xIOkXqqrLIHes4Rxy33tbFP72MT///i3sYvHvPqV1X1am3ju9tGDK
Xh0OE7hooC6lp0ysKC/XZ9vhv6ggEUFVcMh+L1rSfOQ4ckgY4CswdtiKJX99Yfq+H6J2/HjNwT3zeC9g
snP7JZ6OFXYLtoY5zULhACBo1xMj2R++LivnkNd8UdmZD4msKdRB/hSmYmAPHojwDbJHE7RilxPjfAaa
Rlxw2leziL/vvdXicpJ+pDc2qYO7TULzk7rOFm3mPdju1BMdJclZ9CygLtDuDPY3CWU1ZAniRSwwU4YE
uBMOYM+jesZC5pgXLkSMlKyqBa6RZ4qRYaHfNBNweyBNUDfYh2hTp2xlsx5FiRpk8/+XKEoJhctecy6j
i7653f8R8jYFbA/vrWVOiQ3aAjNVic0qjKxlYKls1DxIrYIAlTlcma9BmeZY7iHNBWZ4oUo4mVZexnpY
G7ZsAHbUKpIVNS6bg/EB3aE/2ZmHTI3QE8vfNNNKnEO08W69fPmyQq3WXL3l5dqmfhd4cHGhur6GRVH/
QtkaoyiBvohtGwU4GxfRoQr8t0f+hxpS7FQ00cv4lKSLxJen8HT1HYDeVwU/1fLDT8kiso+DzvwJst+Y
vLn2sgunzl9Q1hK/L9mFnbQDQNv17X/x0lJTdrx4S2n8ssDdP8mCfQ80HzFfu2Ilz9S1XhkqelaCnnAN
haeoLhZ2LAvy8BbQ778Os9zZF+wrLxtBR3GugmFl4azTFMpU4Hsk55Kd9ME6mOtmz8YjOYW68rCrX6hy
4ZFLg8WStPnEiYUq4SNQgEo4bunWF5Xp26m6vHGEam7f0nUbk8A6EqgLN56V+sT2WS6hHsTRXdrrzJNR
t1iE9ZcCxP8LwJjCAoseJkMfdzpeS/b3WKvurg5uy31D9xf7vqdLzzps6YSY0Z/SL7dXeYXNxNN1e8nB
DJx9tlQsV6Ua+xtQ41la9mYmflcwaKQc8fWmVnLTWm/a8CY2m9wyn2QycgnQ16ZPYhKC1jP/pMzbEtpI
m0nKP/DT1ssR/c3tIHooQ2Qi0IvsizoW/q2Gd4DTUBfb4vbGXPhByWrKcwjq19HisBZdea0BOkKEx6ST
bVU+IgyA6qk5XeVX9xKmbQVjD1hmq6XPQq/ib3dp4rOREwnATPz3HfS8x/qw7zVhcj6ABh3jNM7KqZN4
YCA45rHgGN5eur7XtxSCl1+EOCeGxSpB9+3bW1rJLVO9hahjIDclMot5tZ+nfndD5CYjjDdJcUgiwQZ2
VfRUzK7+aImwSoF4ZZvpw3XpIYmtTYJUgov5N2tE1QuC93JakM9q9eGDN/dCcfmK35fOcXkjPGy0m9nV
4uWYVfNHrLo/YlVscwB/LtH3flU7ME9m+sb1HUmT5ONsVR/6q03XAWH/CVAHJpmaEgRYkvm6xq3JuiJG
50blWc8LK/Qjrb8Hb0CG9qvFyvrIm5/Mxc4cXPJme8s2T65L9JvynUQFbXpUkxhtiicLQdzM+qlUjJIc
vJ2m4JJgxmbjBQyuNaRDf/RRyxmAz0TlqOygYN4y3DAOP1PFe86QLeEu3tdOefIy5lES26gxfinehnzk
uBb8AmZNcqQw4sT8FBSZJvY4efDc4dC9bN7Tbwq276kONIcNzs0GOl4IzNXHIP+W3FubQpr/LKBzL29L
NlgWUavsoDaFR/WVbANdmyQbmx29YVVK2XwlpxYu2JPw70Hxx+V1YmMs7Q72GST5gCi2m+qr6ElF6jh0
Stpb2if55F7Bpn52min+RdXJW+K7YwKtvF6K04O912+unvU2+rWzlCBtkjQnvD231FxfiW0EXApXamEn
/rypcV7CXt6hcNywpx2VaVPwcop8SU/KetbeqTmwsDfr85vEwBNH18ykKZmb9fn3uHDeRfq0imQqNLgB
1JFa9uoFQqhxBFcvnv/kM0UyRvNgLpNpqK78WeqMsr/Ax7oxpR/n1XC0uV8QNYXfmXPpa13D5dpTo4oL
NgHrLYR/o4dGYKELljXXU7tUMt0zyNT/MhW7HJkYS0X+fOA+MhKOeJUpie4oU+mkaHqgaR21GQhvuFZ4
yabrq1JapT6MeAlR2nIJeRjgzJELFg428Z/lA534M3t27QKdHa+bAROAMoVk++qbVHiVip5RliESBahe
6bpQfDvIqBFxD5NEdYePo631ccTigKfkja7tfgQtUN59K1sn4R50qHVxrkAyQUqG8plR1uQbiX5aAaRp
1myZHCnr+ze1Rrh/P7YaFmWz66Tob2jouO9om4dIMMdxpOjSGV9pt8iOMWxQOtsUVSEYNbSdMYTqkLe9
XL4Fd/AIdppolc8+Un2FnR2gRRDbttN/VDAr7fHPVJsL9V3G8/WpcGpZKfMM/2DsBT9e4S0JW8eKYOf/
j5zm80YpzFcd0hl+4GodlnoNjbLriB0Aq2FCwP8nuXccM0vPQyphKZjkR6XJWduUP5mzXWcUjvu7Fnqk
cAwaSDo43K0xu4Iwlk5D7mp73Nfv8QdhMFxYs37Bt3r4ilfobATb51l44+P3Vl/26lbZ6pGLjK6Jui6x
Ffpp7mPtrKpJBNBt6t2W9w75pjKCCq8Zt0l4LZBujIJswTOEJJdoz3QbRghXD428FyFcPbzlGCFcPUhZ
YhIhXD0g6nrHTJ6g7ES5l6pRYpOLW2He9f2mspiZvxji9SXVdBSnjcgmBD6IDySV0mGqPY7Njedl3BRP
9h26GeuBU/yZzwdYxLB14I+HZNmiKqze5jV3EEtDM7Jane2Qqfx37k7fWTan78x472xk+ePu5J285g5e
8U6Pr7x6PfVJPKY+VJFZidBpJsHIre+UcM1/2r8vE3ldMN1k5VpVEzKxlnLnFE2+iXozP2rrsmEVbp+s
AU3spSz1CD9vQki9sAhbPMTai7IhY9IV/Kxmw0MxTXWtAZumHl9SvdToFztLNrLhCFtbe6rLdQaD7w6Q
wM1seHFNWMqUPe+xRbT58oh1lBEUyWY5xXINPrgf/E7ukg04gnioSrGKg1aZptU/s6VX3VjgLoXnZsyG
C4ibObCq7IWo+eGVSBDb2rOyFTDjQ5NtfH2e1m2+i3DdGu1umviWLtSvaHV9VoOomscj6zLq2w66odXF
qLrdG8qv44iW2nWTBwfzVMRWoPsB26m5Gos6LOZacOZZfZeZ1DVe/X+LWioRLmhbHb2v956+r2D0i8h3
F9Z1QSFF6R6APhf0VCcdI5WHXUKQiBmhpkqy0C4TX8EjCW2RRT42kNyqyzgofY9VIJPb1SzvAixKh3YO
3BBzM6z/p7RElxYNMDu3wiOO/JAN7gN7aqLey936Esb//iAz5cx75a6fyZf60JqicdXkzCv3r+tr3WGi
pFyeptLS5BNgjzoL0C+RXCJ70LhkPBeFfBg7Ly7DK+y0hOgDTsGti2NvFcNbMgZMNZ3QAgok8zbQFRhM
qvH7craFqte8bZfl/5x9xu+sfZDXZizs3qwAHzlpelLTsDBuQxZVSjY324TPCkkyyIV50+6bpRddLvGx
jJmWjiTd7DrRgGWNKzTqTMWmB43K/KwE55QoVEIetmAEHR+nXq/Fz5GXLt6k7+Y+ZQ7ZkVsiEu4D3tRE
h8qq538q82EicJty923lBkfQ2urOC3e31WpfvqSgRV3j4Sx0CfaLrQCVh9X2gnbk2pk/bBsjvBRBxKO1
MfvKBumbPPeYWFSh+AurEWcpLYQl9iDxWh+1rFp+UjPyjh0/jB/0ChEsuVHx5e3ji8oZz7uv6TBy0y9h
+b65HXjR4RZRmp3//5VkLhpYiDemxAjQQC3XbORtqRENwSsj4+zbW8QW1i6NA5HKuzV2zEgIU3lzhTsM
ZGmKJheNpps8zzhP5Z90YEQELo4g6oNrz5M5NFuXvFuTi0YAEMrEiuyBJssDCaOysDXh0Wg5pxLKytlQ
r0KwzrbY1rqOlE17Sx7HCw8V9NvPWvrydpVhVoGoZxQ/RXgYtHVffJqGztCwjUtQwun+7cpk1ImeAFVZ
0Q0K9WPH5Iy0L8p2zizHrlnZEfu+JwBWVsyu0ztH/p2wZeszVqhP5O5NY07Eafn3YBHLmN737KRzimWB
p+UV8vBLiOc17TCR4J1mcGlW1UIX8ne1Dp8pilh88dIZl8y97tYPtvxyGvcAMIcmqi/fk9UevDJ/WhEo
GJTVlUwWqYsIWtBO/RjSrTH6FQ9bc0bzdllQ4K4ZU3Cmfy4/kraxeek9Ep1LOa2x517+XMrpLTSARt4C
rQyUusNaauYJNfTW87zNneuCs8nfWSfLkLCIsqhoPUDhopcI0Sl493nGlfOTo050RryHb9L568nle7Oh
rghRHAXaAES6YSW229ocvNe/ivH/6NXF20ESVctFXvmW66wKERulMiOoq5Me5hl2QtZv3KAGLSjTMp7x
mdYrFluqUX2Z9ihyjqCPFb2lHDeCMioXhfU9II2if53QsCbyvtkAte+OOMKloj/3XT7Iy8zMRfT8RJz8
bWNu3pw76cvTVVpZ+LajEVcibO282dJHP2CPmIIyTTwHjZ5RNOolgOaRbj401161Selktx+dmGsJ2i1H
Aj/z2oLJkG7u71PnBl2splO5xh4O934VOcAP+Ve3YNSPa47ID20pgtH28G/pb91I4KsRo66Z5rM+gJ87
KsKuJOFqcgfji239QlGqx82SKT36eHKRYvHsFIvH+eBeC7VjgbnQnhN1UWpbEorpmqAqnh0rBk4o7phI
nEuVqnSOxi4vFePYbmItKt6CZberyJZVlb9qEheui6J1+yP+qyF/3clfsfJVlRbbj0FLjj1IC+9H2bqe
JPmgLc97hltHpvjlXt4BzC3pJhYBwP9Z3tEm08bvkE++lbE05HPu5K/mY3zJvfzVeozf9iB5T49CzSeR
yW153rMoPj/F91urxzOYQVEDsZvjoQ9NLEPf4ruiX5frihCtmc6Oar2V13+9yCruh2dP30raXOPnZeb8
6buXmIzNe3Xkfzl934zf3YLFDR88Q97ylygWDxK4f3wS7/OTfEu7ZzIy2GfI4fbz5Wfw3I6f37kXt+aP
ZvxnTMgX+dzX4PU2/vmrHv98E6v9vREf+xAf5G859inH/ogyItjOL8EwbNpzFXvoLL8B06hMqx71w2lL
lv0zV0tLunxcCkAx697F7YRY3z5yIapq0krMr8qCP2RmxjvPOnqZ6K+FB8ObRIaqf+L31rDx1Xtwjta3
Wk+5Qxw8gr7b8pAJU9XPRsml8k97xx90mYro+Zi75M2+GWe+uZYA7j2m22w1v/Xq2k8jqFI2PyFM95I1
3ZLn0eLQ/OJI/Am/w5H7hOrZJnTqWfBacq7SF3pSoR9uDTYN9k3tKXB8NbUC9lpiWZQKG3swxOf2oiVz
LSqXusdYVNypR9+dLnsYbfWM/miwK5tN6rgLHtTgx717I78NDYiCvlhpxEVul8Lxl44cHll+/I0sK24n
MPSWsMJWljha/NRBwSU60rxn07Ffw4LnAkb6luI4iRSk25nOcPZRq9ZVvVIdpetFuF7moTcDz+kM2F+c
gFePgPkssSV0QJmsY9A9hk+YodeVKiHbAkHGZ9530AVElwzSUWb29ujizYenMl8m6g4LDO394MO7OISF
tzDE/f5II6lrU/S+8IMlEQiFaHJvLBTYUalrvM+7Ov48BpOD659pzmB1YG7+OKpg887AtZZl73UCQyvN
JoWTngeqQmepNa3V9SwXc/rWmD6i7V17jwqxcH/B2bw3u7QkLJVGjt8e8acmptM1XPXiOan4C8pFvyyZ
um5apqNIUFwIgx+uvLBLlaNUNkkRQ4WwkSN7UTanaXkrB0kLSbyi73v2WwTV45ROynNJ37HJ3EpsG6ZU
5F187IM3araDmoQun9ZVu3zsJulnVeB42JnczZdRbr6O0sFgnX/w8IdTI/mRpMv2j2cnuox1DJX11ki2
gCI0NDt/W1GB6mV4dDyYDfZOLlmtgEwIlnopk44nmCT8iyWBmL4YhhI1jqgwu7bhnVn6gnj7ciUZTtO3
R6ZirGzgPFwvj0S09/LZP70tuHxCU4Xyu8Di6XgpZu2UqBlDbyOt0t8O+m/jfLHt5YXbwu4u01CTTceO
tmUJImfUI1XRY8lWCqhiSH3l9crAK0jyoDlTVA9MI5cGQeSxV8SM0CJSimK1B+kC9uRvnfQZmwTA+h3a
8VSAExq4yQVajjOdAsUi10aLPsIJEyW2WZNU9gPjNVqZIktDWzh/4wm1dBuP37zynsRgWyBwJymYNdlh
6oM49b1uJAt7Mg6+5mfKbVvrbIe2vJcZA/iNqaW9yoS8ZVQiEMaKvipp1+mAgY/8fXgZShODKyeLmMYL
n9KdTOdjUTuovHylLFaW15qlmZL5YBLH17/qx97rmd/swKRsOjUThxYMr3Zwbcs4hG0m0kLCKyw9bMHo
2GTfU9p895ZW+pI1kLmCjXvHOFwwgw9RYdvOYCEQOjBjnr2ZqaZBDK/ZWIipt3NCky1kiqttuMxgUlfH
7Icf/cZyCs+P75u1mgyQROD4mNqcuXBh47WBn3FEQaD4OuLJ10clyy2VmvqMgoiMd3zKzsreP42u7Nul
j0KN2XVbYIeuGU9u9qhm/f6LAIz+7wjAHNdp3+z+CXcNjF5/bXf/YB4GLAMsJPeIhEIoMnG+9K7PqmH8
qD9bL938ZW08ZrSOGaFUQDjTj8YE6YhrCzIQkL9PTnyPrjwTZHx1Vn7/+kfyO4NfToBXK1eeAO+7rD0f
k3Ro2aeHsMhz++LU4CBIxXdMd6ZWkWPnQANqsPMhtaaSGmNOXTmYQkj/3p4lFKqOT1yeyCPf4/KysmYb
DjFbGUPcOa9iDo0NG9p3KJh5NepbswY7Jx1EqoqkLf806LthCi2j7321lI4fwSIW6vbcW7Zm6NmHvmLO
F43DEc7fAX1H4DrkacO9v70kQsPb6XqEYt6H//e2Oli+/9+51TFJkyk9OQ616zLz31p8ZyqIYmnaTBY8
+zAiU+4OE5XsgdE/2wK1eLfqd5edOKUTjgS0rj+n7LK6xUHGViCjixHcBdeVUXjhI/pqg/3i38Q0m1/H
9Duj3rLRv/jkm86i8uQym7lBMEcQzPXxjfm7vCcz239OKhFpaZhM8PcYc1JH9Ddk6p2QifVATT7nP9pk
0y1x/Jnuqn1DKpKr6ZW3rPho/OTgqjCH8SRtbolJL53usU+Yv9cr0qXx/1dPOdN/X7OYJk5BuiSTRXov
q3ZEWdh/PISe0gIfxmlLvp4P4h596bLMd7vmVYi2wks5K7UbsQDMldobHyVa8RNdHq8DWtTmy6PwBDb+
cOG4HmU+mpjwTV295ypwA1zzGQiKP58ZdzLBroDgRV+LLBBtYrUup9sJwbXlDQ/wyYKg13YW9tbmNBAa
eQy6X2tCeBKZXhGn8DV5cVvz7H6kLsaheTnnRgYs4YBRm0HZW+f9spOWTIKD9wKbMNrY2ftkQJoAB9Re
RPG6qnIEHW+pVd3rD16PnUuXcHeYeu/fT0/fv+ykA2isOpdnUvBwBTPwpjZJwRuZ74PGHYcN0kk8Gmug
+bI+y0HyRgwgV7hIxq9ukRTMDHyXoDsVoBsyYgu31k29FxV+uYiyqvUnczCxuwSwcWD8nlZbk2gu3TCr
l+QGrh0ta1ymESsVURoIdahcz7HeJzywWh756lExLOBnBT+rxXBAAfayJ1BAPDea81BDvl69GA55xduB
9HY1DbdojNwohmPZzqKgH15GyWxRY4dNNmcL6GzfjMziT8oSafJrpm+GZv6Hl4SrG/PVaxZfYpeIz8eX
dM3xNXVds1r66+VP4UiuDwjbcGqn8kpJapA2DYAY6tG31PdSOj6LWl88de8Yy/Ai114R9RiVjTyiHhVZ
MRaLqbDj75ROCbB0obkw8ScwW+5Y+h8c/Db2DMIOTCKE4pXDuvrUZKs61YCvIDr6r6w+5rrnBj40JYUG
mfddTcjUbL1tBwq6ahYJYHzOCJTwiCHlWdW3YVoO5tKt6PxxDWV9w7R7RfENRvr/kJnDah3T7znRc+NZ
0n44Qis4iwATogfJJdMZBMUqdZg2ZPHXmENX5K7dLLp4d4vo1kEraYpTpUqm4QjkjZYf08s7F+7Wekr/
YPFLVgROpaGqSDtv/zpzA7LtPteujAQOD+i5YCLii/GfjdekgQbV5i1d2Q9qr9nEhaDJ+7K1VcshQSlp
1XVKKhlmv1wCegJoFf34mfJXu1B2Ziqh0cLLgoEYQdMWjuJQNokYCIA/VY32uJF9ol7zrhvVS466B7Zn
JqtPsPvUfl2mMFk4nJRCLnJ+AeOecAcbx/E6s0Lg+5Sgc0ZCSAhIpuoVq6OuQNWWutEnZwgQPNyoz/jc
Ra9KJcVNuXlPSeMhwTHfLSbGu0vEk2fg4l8JR4T1i1LqdghFEwPMV/iJvRNbjXqxhHpZB7qjWZk2gRIb
eoA+HdYrKYzfOHQr99pQl69As61CB/2U54MiGg058/i7f/D4SHTuVcJVT6RXhLwYoQy4ZYT1uQ/ZzX0W
/quetOWVVLeQzQwfL748w48cIzDE2a9gidZ41zotavwSY6ajI9HfiOuXfUujVjmJxSdfl/bgkt1d2Ejz
PHg9d4kpv1k3LG1fH9S7Tu1iaAR3MuBhhkxOZlpuT00UL6jNgrth0j5WpmPo8pn9LFMAJtEv/+8ujJ9Y
U1S6cZhswiHQwuv5H2dvChAHrwhhqjWlS8lx/8v8/LvQKleWequS8zxRf2PFhZYyDX59hSt6h9PlfSnk
vjAlO1XHGTfD2fDcFnXttqjojyYUpcGkIJF3Ryv5UZc76bi0Q8o6Vnyuuf1udC950aKxCMAL9RTT2LId
mzq4g/pyZlJ5MDU9utedCsTSgSjqaUD1aO/l9gy6aGb8RD/V5XRpBtSK2feZhuchyBgfl+s63fXukHaP
Eu0VRjmB1L7l6+ATzEX1JZtH+aoig7o0T+g1j050OhFr+in+jZByfRenhJFYr2zofyh3/D7ern7F8zNA
xe3ZxfCr/qqD6uigkHSnl/2luasK631JTfWvinH0nh+cU4i2blJsfaZZsCc699Jos7fgxiI2CiCmWO2T
xRdqw6OJAqvLB0RRJjrDAAWnYKncWXyl957iQ2hck+S7RuQUxSmVJPDgs9ePlrtRIzEZziHYzodpRfA7
LBsfx1hyNVN9jx68mVkpMXqvXiRqTVV77ZJxs9x2sce0F6c2ARuI1fd9jQYcdC4l37gjuS9wvWGoSwNh
yvrUrj0zh0HPpiWU3qIMVv+eQfKmz7vOTq38uLHnzClCbg1pTmkfJzfT9h/MdEUmsR6dmenvV9ZHOrP6
hR4ih88Dd4SBcYxQIdrhQVmdVE4/Vh8RaeNdIf1IneWwWgQaUE5sMPPFOqDUQlSOXMH/cvFQNGWvv+Dr
sSdiYPbbtCAsUKUnft/AbEqpW6yNJJNAMrHevE8644yAM0CdEYcL3xlwceoMgDdQZGZYZbOWZEyVB7gC
5DedEW31RawmXxwBZzohZo7N8m24sd2RBxTBJCgfwLHJxRNwbC9iLOYILIImTLaZV3T5AtzbdCwVXYM6
ItQLYJSEnMSKhB+QjcXDrsk/eHcH2ReP6RT5HreqlEkUu8Sh96q38xroDr53uW+PHq8cWPSOoUdN/SU5
BE/JrYAfNaJiLmXJxqP3FXcI9ixNmkjWuE6/AvfflXhUFvcdQsuNcVhUMl1MZZ7uJmnqV5s8egXv0A8Y
529ZI5j96awwVajoQWW1Uh6dmWvCJ3RmqqFMOaE/cCtqEZEoGc2Iy/roxO9jiY9EzP7phs/Zp/0Q6mIc
hXTAzog/vbPLKy8d7SV5VP1PYgf5beLJTfiH+X159AkDHKXWJ9NbpOXJkaTDNjXDL0ozPR9P3KryptJY
F2DMSj/LLjf8Oyi3Qv2Yo6+MGs8L1+yqk+s6HeBVF8GvZGX6YkmRKS8UUpKfpfdlSu6+ucmOnYF7B78v
BN1ryw3tZuzNq03JIduczXrdhppYDvcUMK4qyg0ZwYU/PI8DrLSCC3iDB82ibOqVfvSg69Lu3E+SK9w3
1p/DJk8NjFg1mbPnskaSusf2CLpYXfgTK+0ICpbd/tJ51HSCEgVp49pLjU1vjZ49GJ3kxl9acCZicqV3
1VPyt7EtMT6QD5OymYoIe/bdkQymIuQpG6MynDIzMjf9243pdr864hUCTqRX0JoWHcumzviqtipUbPZZ
0WnVBYsT6MkSkwiDmKA6oIucRUk6kopcbC8i3e0F7givoBwsaWxDyZdg/UtQwQ0RbqBNyVD8vOgqJlNM
uGiI5VyhbGDyFBF+kV/wxBrpWbgsfk0R3vS9fOw5f4Bn2Bi+RCfYwqETUA9+8HIVp3eiO8Oy2UonX5uE
sTnkZd96Q37UIVcwYpcsIMhjtqbviR/WFqMwptMb/S7LkPmkkaResixUrKEmki8lycYSek7AhV4VVTW6
w/tvLnySvf6j9+faHEB87CNP6zyHEfzG3BnFqS6IAytkLlEuwZy+xkEC4K5Dxc67wcENomMc1vbi3Ez+
bVgcT2PbF+0ivHNfWPn3DxoAN29pUH3VWgDRbmdgzI735sru+96KgIFoDz5nrO9SxlCcdgq/JRU7aqMX
iCRaBeBnlwi7CLddP3KoDJdgteT67gHVoOhd6ppCiEkWiUZWfHPbkuLQn83gt5LzEMJtd2HY34JbWxuy
CSzl2YPaV8Ow/l762KQOkan1HCIMKO+ZMm8dzn4z13PRzbkZqMDa36XddRaG+L0Xm8SaR/ApNV8+7r5S
iLZ7O113CUDUsO8S1RXAi9mOcgMFiUCBWebvFs8/jPQa4yQ6ftdxZTKIZgFnbCU5uKa/UxtR7BhnEWfo
Jyglr3d3f6bo1VAMn6Rk6FEwpZ4+83jeoxheD140bespowiLDdSJe7Y/UG97rLoGUV9RGtbN1FL52Glr
H5NSS/vVMlhgNzLbWCYtdGxTaXbRF9uwKuKs1jUjqgL4xEpU9a6AdVV5pT4jX37lUbrpP+uHKCpPaxor
B7vyr/sHnIN1csI5t14y3H/ALojVhkHem2l3B1nnpY/rywZWxD4Wq02/GsweGzueJmPTRXVURbrnjwQK
8YcvHlRaMM4If7jdRHNPBMyZaJkkH947vg8eUgrMzYd/0cM3F336Fz19c1HX+Fc9f3NV/+iqH8fkDR4T
IcblgQj/1oRQcem+OIJreZxTM7+0qWNQVP6ynTKU/DJLGmhGKdrT7o0ePkjQpSdBNTXFlkl8ticYhwsg
U6DFV9myNTFzZD7lH3raL5op68xdin1VMxSdbOk49e/xPhm5BeLQJz2LPQi2P6yiaJ6RClgddyIVGiIV
7j5lFTXkhtvoqnmpNamVDoaEPs1hcNV0C1yFHNemyrmcml7/VYHBXm9Bt+z0Vv18yaB8kB2w44JDTGDB
RgmluSXQV6oDe4QOTumcBepWpJTOOBfKEa3vTmjd8Gn9L/s/jdb1E1rX/5u0vj2hdf1/Nl83Tmhd/W/S
unZC6+r/bFo3T2gd/TdpXTmhdfQ/j9bqiRNXwyyCYbwzbAMUwgKis8xm/7ZDS/oNcCv/yzt0NIjcPIvB
UN8nPgZ7tCvboglO7KSTDTmehZSl7OX/xrYUvyrjYYmf3ZH+9rL/SC7/5WW3/+Rl/5Fg+svLat7LWoFW
GqAgwntslD62YLI0IRUTjMsPxTz27PKrQGccIoo5MggEPWE9bKuHKHL6tgK3FDzf4dbBnXVNoeutAFTj
1nd02HymJknChtemADleSjlKc0PHBeeI+JjwXbJGBXAltttmdlpQNtey4XMWNxsPtWc2U9KgGf0eh4HA
TTzD+9mZWUBvVW9ZbQhjISh25BfCUvVJGskPPZdqUNeEHwy65coTuyb1TQcOblurU7xube4cPz5jz53j
UlyH585tNEHx3DnCq/QrfO+ACKQ0baByA3+v3rp697zB4ffCher/xgzeElcFaWF7BnhD9qca+5Eisjb3
N+Y8SQ6JZRgdkebC7D2T8etVNM9u7N+vYpDxOvz7VXB/2e7f36gl8fG46MymryaxD8NdeqvthwOJe4XM
zNyGIF6IUh3kWfmGSnslDKZumr4Dp33EZN7Jym620eP0Hrg1bxkMC3nhLe4SC2QKPUO83w0kBtc3CPAR
t3g90/hEJ56V3cbNwuOc8uCJy9xNPLdA3dhgtkJii5VrF/a66zsD8gy1JgjCasez/jYoMTPiEnHLubxK
TIDPzVrtUCuO9CrxB6Pq5d4EFfx5gXh1BRSO5lJdcTeTfasxlK3nDsHiBrsT3gFop7EUz/4dIHmb7aXG
5tS01ffkDF9kiesGoIrHlCHF5ZpkF6WdJwAN8GgvC9XgSajRFtHdQ25ChdmvyF6eMsYfDKdeQEppLHFK
9G6oX3gAtXVt+m0TrHGdgmrS2WONy5Jai14nFQvRwvBBwaFr0+Bjxty7ae1yC4cGlTVlrzCkodJMXWI4
5ieXXhX+qk8w0z/jJY9/XnHrV6RM3pL04sixXyIpyaQarIgIpetluFzGsSrZTYMVCvnAErixV0roS/wE
nxiQxwQn1iBYAHUJHJirZe1Nwy+WiNK2A8w5a5ArI00qrPdnWuojnTTek3UYvsnwohSZvxIJFE01rTtA
luY41EKgEckKL6rxY355z0uNmgjivdW9RnBfELujjAogPJXp+NQv1T3DbORsKo4TeFz/tjts2DmjXT+m
xiF4Z/zUgNLpADf/wQAjdL7AAAuGrtyk+cXXYeFiwiB3DhzVYP6XhIGO+vC3WJasKex6I1cEWjpld2M3
xqnxsuYQebTFaK4Ap8Wc62gzNVsGYHeC8BjNTC5rPM8lIDcJImJdazb4f0tW2xPiozQtiJ/JtF1RLJKF
NrbdpJuY/AuUEyn7TAk81X7gMwrPyzTQi91CE/kGGlpfOpOkc1lIvnkf5ijEDizjvcxFbGeGUHgI1ODW
LDxpCbJzn4WI9IRLZAh159ZhWY7gWD8PZon4m6oGE2dWzM322tORPIVu4XlQm3NXyVa9G0sv11R+1pPo
A6Rl5ymZ3+iXMwLHZkMpc58pez2tb1mxRExeLNkh8CvjpYGNNvWdIljYzJZdTdnbnOVKIgiiB+QkHeE+
SZ72wqtl8L+AmdufIF9NLdNEPEXPRPzspKXLKWEjAfvSAzvIvg361dfAsj+YVYmtL1+RVbJvZ8285aO4
qIiTskTUrv0FxHGcZDxO7Vnoxjemq77rarNpO659162NtqcyjNwqRCHaQMs0jzPHrkWH4AYRehB70e1e
vqsCPdJrvVWRhw/Nyuz9MtDTZKYX/MluKfK0/VPRfmkHsxucCLiyM1RD6CONnt0PvPug+NiSZ2K3vfum
c8e+rRllEFKN8KzRkzYUGbNhbXCm+nFgcswlk4kL0WhioCZaBb776McY0vuiJv1mSjUoUtfIHSjVXgQj
LvAmzwcTwyrWtO3thTPOocH9ZC4/hNXrBbiw5xvqIzam/rH1NMWc10O/fnBPjCdOBViZOEWKHD/09Oij
T49g9zLoWZ+MnFBorz5TSwIacdcoVHFfq4T0DRQka414sgtRTjGKWXRw4WMUI4PXRktgDkAIvmxdLUmn
7DY1y7RkTpDU16fJ1VfnDDjFujpnayXQ5OfOIRGeIHEU9PdIxZE5rPyOSTU34fUPN6uz+Qn7bcxa0w19
pMytS6C5MT1KXFqjrEgDUy5Mz/yrFW+F4XDnZw/Xj1cuu6AnoJ3fc030i0xTGtr/35j55eeZ+aL4zHC8
v07m7hZzJ8I1a0aS7ZWzAVp85b2kKnIP6ZsbOe+an22qXYjKFBorWljt5Uf6MdiH6n3mDQ+N31Rv+FW1
dI056N/I7Y9MHTl0lXOb18vNZzoqHFiTrTc6tDlHPcKoxqGKUvojiQwDsFNsEM2hyw0Dwz4TOiNYb72K
7fIqVed1lcw9b2jfLDzmrQD/EgpYBYHll/pFWd03Hh0W1ycrxafDpPqP6KDc6wihzWC0KpRlsIyFd0Pd
GXrnyQC0i/9DZPi5otVZ7zJ1d+nT4e54Nec9Ksw0qXCed2Mgzx/8nLfMKRVypAIXTIY9QLKgQi6EIsVE
oz8nJMiXzQkNvv86ZDMTa/nxYLdll3Sp3ixhc+eDlw9deow/5FoaKcNaZVfLhQOLsRqNVDYdyfYbB5hU
ME4jOeoFV61Afzuo4yMD6TlhTSib9q2t4N5uYAOtbdT18LB74xPNKOtV41+8eFp8XZX4rqHIIE/h9g27
JuSsNLvN4zU5W+/7Jubg5D1R0QzHX/KpF760UAom/h8XMih9EUD2eT305qSknOQvqM9ZLvUFhJXYBq5G
Kn6OeL6XSXk+Il33oUfWByzjzspOH05VsY0/9q03djYw1taHNvWyWDYKP00F1oqGVdLqQmgzT+Rygrym
LLz6wsJ0Rnsp86+Ti3RvcGAjbjFUUVc3NOuLBKQnCkarH/XZKN0ph6sfH1P8jE/UNg9JCmx8nDvkmjnd
PKO24uU5/PjxgxuXTrVCpiu9JnTGYMR0r916ToCJYyE2+yarZibe52Ynxnts+r18MMoTUbojm2ernfGa
pf1lQL/BTkMpGk2XxurBWxpOy82eDPGKQ1wPvcQuZRR1SqUDoNlBF0r29NtzH2c/veB9+mdxYr5/bvrp
ZQOdLW83/A/ubzjwcGBer3f50KYntfOn5snOkG28TlPrH6+pTM6tfzRlRccHGyrPfvIwyNtPCMVgpuDe
WSvXndVKLqFXYq1k304X/vvaQzg8yYAfmZK6JY4EwSBFxwjahCJ7TpfE0GlP6rU7Wv53dKbjPK2gRR1f
sr6rk2rt4C/acZFfMal++YoVPIDHokhv1+0XLROq3lhqOL25gwy4vqvv0Y2h6zc47J0qHRNFQxF6Lxff
0PtYC5Tb1FpcfJW7fye/29vPTcS/VXHoqPx/TMVppQzyyEk5+NvuD2hABLMN4bDo1xfq0GpJRSMC+5X4
yqjax5qU3uyjan3qTcbMlyKA1Eg2QZ0a/nsEtqx+PcDChF81dDq4o1UIaIMK8Ejqq3DY+s8U9stmUuLl
1K//DfU8vE+nqzV0fbuELtEPYEzOy37asz8bbJET3KzcdLV0NuUhFXlcDdL0lp0R4m//T/Vy97mbxjc8
emn/OY/6n0vu/D/xuQSSXJpV+B/q3+5rd56Z/L+qb/sfq6p2+rX2x19UbbmgBqXlsWSn5b+IFzcndd2g
mJbta9Bd85fdOWtueAghHS/smfZ70I6Ci/2ZfWR9/4/eTxWefu8+1XZtWhy6oBOLb/BuTciRc3Uvu3t1
yqi/h8v/9bFfu7F/6hL4czwM7IS3FHTeMPrXJ/ZCz1wpKoFU5SYv8224j6nLlp/Swz1LpS4h9Z6opHi7
7yeF6+zIqClZQA0MqwsJL+zMw0B8Uuo+3i6PR5a4MTeQcS8zPRbLQmRYDUz3F92b8SCEZtWBmTGe1Ml7
lX+ZkdPksSMxvsgvgHcx2tjDyOl3j/vR+bj15iEdX0e7NsOgggdoY3PFVOO3QcG10q7vWo61XFhl+DfG
LpocV3BMqM9ULCPSsPGYZu19J7MznlI2+gS2F5gCkYzogjHOJ+4Y6j73vXyHg7dXEu2z60xdn5f7tRNW
HtT+zWiFJheqKEys19dHlSQsr4rHsxUPBOGVsZwe9ZGx98zo33yGmtbbgxbEC80XSJXfGrwy20Ggffij
bAcjLwgAPRWQrgSED/b1fxRDPFd/3HlLWYXqWJlYv/upIpyuFMpCICqkrH0Htdy6E5JjUTASjUbtlDux
jf+XtAY2pKRxujYHPbuP/58bmQQ8z53IzIAMFW74PHciNwNOWWVjJNWh6k4U4v+HNnjAptHmixj5wD+y
Mp7hQ+jUIeGBz0yN7N5bQV1HFRH+6vbdU0g0nEd0aXraIRoEO1cd2TNjr4h1bpAiuSDXgoGwWh/iFd/0
RnA4P4IMR/CYAFSBszfYMjEoBxE0dRcwkPrr7NgU9abvt7Aajhyre2NsDQwzNnszV/PfNRd4U6TtT2R4
ecP1DoAbbLPj6g7d6VK2HaZQNwmaszaKhwiAM5pzNzblsaMeWschvIS1FdUvxs7PES24G36DQpodneib
eYMmbsFI/faSbLHHyxRweIU7gCSsNtoS4vcW6k9rQE9cfvklav+SNCxBfBEptGOMhCHva4wQZehHgH+g
OqTR5xzBCI1MQrlmOduN7eJi5nNt5S0ZO4r6beckaqSziwpwdhOihpVPdg8p0SboZ87bq3Eh6/bx5huj
D3hJ4IU+9cAHk+Xs1LoDGGCUXPEaVFDBMrTugMJGA/xm4TaYhqhuDs0yeUJTR3ENH1YpmVvXxjm5w06S
c2/p5i9fOEsOow2J7KjYRSWw8+VRkfeUrkm3BjnO7vrB1btrZ4Ln/BQu7V6ZeH//OAUGOOE0DSVNtOUr
wVO87t7zB08Zl3Nabxn25v4drsFqtaKYKznX8GPO9I074ZzXvLGnLs9SMx1Uc0Tt6T7h2aST9gA+iMb5
jr32ebB1Qe9XdFLkftI1fWcaqwsBj6oh4Nbs2X7fG49mbXsbzwpj+0ECaAda0oD13Mh6s1FfkQ7u3Bxt
TZF+R3Y6Anhy3+bwiIjq75ICmgbIkpnu3z5Bt2t8Ql99Cd9efCsB6WaH193L8JtJExXs4PfsfgW4r49V
2Pfc0K9cpVGQvTA7o+7B3cIJ1qGAl9jaljtFNV4Oe/Oj51sZ055TxoTt6qMEEyRCgafVlFPmjuA5dZmu
mkL8xftEkzBRNbRODyRmV0VqGUMLsSn2liJq6hVvaeNiqrk/3KrIJNfER+5Q+d4mSPGLHHmRstcfkbvk
UZbk0/4EEdmOKDBmxgOSTYVMgqKEA5HUjmMVrU0qZLTjT0aeIsBBxF/+j1b6r78JzO7EHsmBOgPXj7PU
LaKfF4vMpZvNMYpQFVb52nOacnJ0+PFtM6R8xsqV60HTFFHozKguZjnNVZgc+bnq0DdSJfIjVVNSitmR
1xCf+EJOQmvTAX6EEK0mkh1HxxZuyBBbWJ3XSIeeWzlbn7sZuCWnbbFtRTub5vxMrIiVg5Etb373dBj4
KTee3/clT+XmJ6Vagb/IdfOUzNGVHREjqrn3fBWvj6lUWpq0g3UFXqvqFeI+sYR4zAlyeAQ3yEsspfBN
V3ateSgxFW9LXLuCYxFViMlWEWldrRXxyJp0+6vX+hBQt9V/VYMGLCebyrY7UW8efxdPkLhj88/VREw8
5eZl7Pxb2A5hhigCef2GeZkvzj3yqkrgLyrnow8nxG7Aedyz/1woE2d9aIdC/ywgUht/PnOwvStPEGvK
5fWFp3iWvA5CcnsFA2oQ+JCA0syzrvstTIBFObaDtRoTgIeZqKdCRqwwm0PidL1RNeDoYzM70/+vfY7N
20TGT6bWd+XUE0fK0vSnTsGPCYsfdCMtrT6Sdd5B1kE7sOechnjWXoinAnsZUA+PxSSU5xABsNby5hX8
WTAVMih7lhM4iEhGQU+LYRbOovwokJkQUuQm3BTSbh2SWs8WvQDRt4O0QemEaSvCmhOKgMXdAqJq+RT5
WXODmaN78xqsfK/UlDgO57SMfQ/bAuBk6nOs64osnUYdqwb9z+vXcvpB/lYjjmb2xqqus9I9LP8pFSsH
WnTDWWIN2OAHHvzCm18T/Db5p3XFH6LT/MQsv9aXswSYLgp+gYvf0ghqFLzjWR880kke9FsI/akvuJRy
ILWBwEiaDiQXrqoPN0NQ6sZNxZVZufDQS9/93VlRFsKBD2iqKG8oH9mlOTa1RqB1haj6P8dUvZnu2Mh7
IqU9XrsVKuuo0WKGqtcC53W+MykfCMGly0M9+IPZ+GxMoPP9eZxiGXw+zaay7N4fxltVuOJxcPjAswz5
deDl1xm/Stp3tsQATZyOVp2yw2TXjIKX1mgqlHx63uNFj+0D/n+qDrWYcISnPNbw0fd3a5xuNjYYz32b
tzWfD/h9+zCcps/WgMvVT280iWqxnnkZEzeo8apuzGHKVcIb6R2Tf94v0w04gRwxfLH66S7Mwb1XYUyi
DA4pqTZ+UHCbzk4kMfd4fsdbc/58Hqu/MfTPj9x5eydAbnPz7Xnunw2OhSnaffPNYERGShsA+93TxLEs
IutbIn95IiXUd89jOdbEyJ7KXEIbKiUAntE3w9d0XFGE5uhKz2HKehUkC0dwMYX0LZANLy2ZL7UyI2ot
raDlVgEvkmzu0SwVysFrjtITcMqKE3LYuqqRLb2HrpdQTJPZCU3qutCz398nCruu4q9cUjzlkmtT8Ono
ny+RS3L++bzPJZLZsTbfnqfLsjGefcclxS9cMrbfPU02daFI7q9cUjzlku63w6Oztybb7GPUdXTWruiz
8+MkF3z/1ATC0BvmD8DFyD9dgx4z9calSsf4CBKzcVMVenBdOUbmP8RjEpvhRT8U7/zp8dBfeSHRcpMB
f8twC9K3e8pxGtI4T46K/MOqo5J5EF23WdhqTlM1rQUdJDBBadIoVDN+TjeFRwWN+prAJAdWEd60rCJS
EL8AnqkLt+8VzZ3j+SB9fLqrauuC/NybrLXLQz3q+X9tFhRrUIoUBvXm9Zsbb366O/t2MnARsjrneOpi
axaVHI3R3/bS6j/YS1WH79kbx/Fjs+grPpOVrg2MLnJ7o+vzzykm+Lebz/HmqJvQ3IfBQqJ1zCNT9yVv
Pf54T48Mv903aqAmfLQt4Je1n3lKWH0/VdS8MrZ+OGmst2fSH9Q8aAq99dK2tn5DiBujy7HsydG9P+KD
GzHN0eW3y5loyT+l6COK9lMvHwqj/CWujWuD+MCuhuKL1RO6LE0/Hq4fzhQo/L5GTvbHvyR+wIEg9mmD
Kcpb5eHR7yVGAFjD6m+89A0m8UrckjVw2W/2GFN/xgpK9C00398H2D93cnfzdxfr/x4/HnBLE0Wz93K4
9QQ2fBCl+/E3tXkprniSAbd/yyXPcmcbVz+Lu6sdqX548Ns6aVupKLhidWq2g/IeytPt+MQAiCjssYTD
uRfOS/6qCtp+Je0aFqvHGSMKQD34YNCw2deQbXkGzdh5NHBctp40Q2A+d4LnldHlWd4kMFu6mee05/NB
W7xlvFZvS61oL72IG2ml1jvibGKJTpapBQB9fvlnZOYUPPCozv7Id03/yBTO/nCdrJ695ZKFsU30Zfje
fi291oyg2JOQ/uWQHrVBKgOBTtlAFRpVkq7RxOM/Mly3tYTBYOIo0b5WQV8CBVksrV085NleX/uElHXZ
K2tBATfS1/foibTSLDWQq0+Xie+nQd86RvaWLMPNxlUKdnK0hn9wTTbEFD6snSkcXNu5rs7FFqIOyJS2
jqBPcirPPYY6ko8l2CIKNj7nA2vM66YN2G1Z44KuSNxMsSlD8YLYoXSPD4H+aYdMopziLDg/eiy5JlrN
TQq3WJFQc7xvrSN39vo5OVsD+8LR2Ij2GHviV1U61oV0NQkqJzTu0yFeZYhazQiSggre2zERdE2Wel6N
8sCxh+s4hF3kAnsAQ8oUwlhWA+cPaeejZF5jZiUJwXSdjNcIO5PE1rhAh5YXsqAhE+55adZFSDvprfV+
qvHYSN4FvQau0Ka89R7F5U1ZOXcNj+FSdmuIJnq3NuG5c9BC79C7s4GEn9vAubM7xZnnM5vqj3zqU2CT
Nsl2Y/FpK9fyrggk9NHQVjd7c931bw+u8n4XGhH4tczYuyIibMH4IVnPoXQigMoS7k3ZAyhpTSoJD1v2
3N+Lc5QNVMNtOK64S/vP6aU7LVTx9zbnwwpWM7eHLhPbFWvxQV73LE1FhwbfAqakSvdBVsIagv1dndhz
Itw+iVwWsXWL5JuNgfJwYzS5inOeCs3cx+pIaB4+UI750Y5ff/jQAf9NaHY0UQJSYUjlC1TrsKgpZvlX
Yopai51WWHgTTXVfWUdwidp1ajT/Fm+16+ujnm2s5w8u52pwiJZ6/z6ig5H19VGG2xMG0NYByANJ+qKT
49FH+k2KF4NgTw9VW2C8cdiBBjaB424cTtmYY8J8XgEtESzRFDU5UCQG3RjfaVXJoag/d94ETEYkMmr+
fr/h2En5xbuQZ/4ulF+8k+TzdDfwY4pVQGjWsBVWJx6CRUs98HJXLW3LcojSxXQRtWWUV5GUsV9EQ+OP
+SrCrI4r8mW5t0rmw7FF/k3elnsbC83zb9S/m9pF5+pEF3A7l61c6NJeuJ0f/3i5ty32PPDy/TIf5xkO
BsamKk+efdxedgST/X7eOi7Nm5Afr3c62WkcJM0rs6zb69Gl3mbGDXx70TvdftU0buW1X2aXn2BaOxe+
/kNbQJJ5SrR6hANiU+rDW6LyovWEIasn9AkxVx4aKYwFYisRJpY7BcJO6luHbs2Uyo2p77Ts4nooYmlt
hA83BiG8tUHd/8Z0bWl4fBW0u42ZsxdQJV4da4OeaStTz+u1N7h2iSeu+MQln7iKn1g+uQpPXPlPXPKJ
C1NX+n8EcyPkWZitSQ/JfiYnMFULkwu9i/Ny/8y7f4r7Z8f3W5zA/TP//invf+b01+KpBS7u86eG0D6C
tuQlPHu5D+z+/rwP0yBYG8ADT/X0ACCxntJAZTN4hJx6wlMYPbzjG+vx1exIDR28gQVzy3PPMXNxF1Qj
ohUbF3Uw+O3SuihiHWrY7YV8SB0tlFhwGlztZINLPCI4NEd6Pp0gArQgx3rIqiTWQnhtV8CLKVm3Ki4m
fJtwIvuNlJlGA7bbG4k5HVlSrOfv0RwTCVUyyUfHuwFWw2xk7uJHrGfm+XriBRZcXW7rsHF6O7IZi1qe
cusE2fXIXUPjUcb3zkWnD2CVDusaJOL6GmwX5nbnNSztj100A0mbM9PTgJXX+6aQ9L65mbPXyI45g4j5
2ehae73mn1PD5POkXsnsonMPUGARSgCvsU6FhgsUthZbiO+ruFHc/q7HHaBt5bufROJkjFoOVPRAg5/Y
7nYL81PWXGwv+SgoXmo+ks+yZAvBP0Zou+i9rGD62Arod8UXr6Rv0WOw3pinfuTVFnWPaZqU5ifiPJS0
JmegPqo+13Jsl3EW3ks9kXIVOGN0PxjY/2RDqElSXAMW4P0vX5fhDYhqz+4HXv3c115H/naULR7bldEP
QJtnPtLPOhpD4g3Ev7BE5Ca4BO4lvSK2uaT6a7g3P8d+tPzQ8whZcI0iEfhKin/6Sy1CoNobpltP3+S1
cQZ9U+a65+GS//1qFDTaHG6JfxFuuYD+piwR1W36auY7e26gerKzGnWf+cyF2n9fstnCXzN7qnfA9P63
KTkE+gb/Rhr3/rf3JBEBYQVefCc0bRzl8txh+C0Of0KKiaJtf57Nq7zwKhs+i2Mva1ujtE8cx2DpjcP1
XpsiSW4WTj3UqrUZcWtPW4/bBCOva+lM6LmwYA8NzmJr53c8vouMeb7peRxU9jlo3E456C1Za3ZlysDX
ko9CZ6ZYW94yCokhV1emRyqInKnJFfWVublXD5d+yK2smsYKygDQc2KmBkCSZBJFLXldBbAy1Zeb++Md
w4ON8IK3kNy1WPmN57LeqR1L04Oak231ZNkEsIjxARnPAh0+WqmPGDCj8LvF1szFXutYLJcZnTfhHv+P
Rj8PpuiiusEHGosFq0rC6cPRTzS6bcu1YJf4yIV5583kQlkJ0yGF7+cKvvA/oOfnhIne0YPzsxXmjon6
IDe2irJJV+cwWZ2jZI3KrmS5Lot2CNoEmYPrhDU3MwJm9UyxnvKWOlziD+n0nIOgb5IRFOfWNY/fWh8K
PqPxEyIyDkPP9zyCE4Su9MLMXxD8AX4XEjQDtxF8e2EwrKTSn5pckuxSGDoN13fzHf6z3eBZMr9stFYz
/jB2c71U2Fn26CNTHVSeJUCGfgCmlxLhhfiZGShGCa5pQ5KVyx5WHe+SIqTH+B0YsBhda9OelWmKi860
1+5pGbkza6E1XWWMmMnDorm9Pqrto3f07ArvGnQzjKUUXLt5w0ZTYZuGMctjqnmTwXqotLN7d7ieNw/n
FnPN3og4rIayMqud+/90Zda4MpvpyrwHygi+8TX/96U5mf27pTmeJUszvhZLMz7CpRkfcEtzPf0JD8lb
D0vzHcz89k6PLNfYo4ZStOzGa7l57M0eqOv3ePGhPi9WfBY/vKARFY/7dFVPk1XtJXjtEWqZ2avav1m0
Y5NT0koibSuJeCVBIXagXeuipZ/jwg8YXambQRZtbue+q5PfuZcIcVqBs9W/vdBftPAApJ0mdNHSOeaV
0+qi9eppv120cvr5Jxbtkm28g93aZXf0ddFSak0dRf/tov3kooVfaD13jqkX9Qt9r0r8pABOdA54sIr2
2IW1si0utKV9+M8dWDury3Rrn/+L7qss0N8uBHsPmiwS964sBjYqGtBwfmNG5l8IlVbSCFd9CjtKqi9a
igEWBZuezcHshEPzl9hqsUZUMosHVwMyN8dxtrzpgnqxYjPWMF9UMvDhxmtyLcAIPWqVNYCYkiHs+cQ/
+dJByMaOnle9s/dWCo0shBMhxpYmKaTSIRGysSVX3LHDinCUjKCKFubkan8EleMRjP7RCGw6AvrDNQvD
GwEsZWQOPs44gGzDFZ0UTtSghWJBzODM1o5pjjZNt75gQ+88wBCvFWEn74FIbgn5yJbVAG5ImpIwj1WF
HYzitIG8cAge9Z5IlDDo40LY9OHr4smZe8MnLh95/QGVPAzzDRO4EIltFBZOTmlCqsZWxs4ynJopVeyZ
05AVT1DooZYSrJWFa1P6g1278IIFcMgKlUE8Tq/S7piMUCjKGFcXBFdvdpCsXn0nBAwTDBYLLxQyXzjH
PvQCou+xZdyNg4xNGrdtJtbP9G4k8sqrI9lOXAjI2c/LECvRrx5xqnUGNs7ALExp4J7fubyI2fuH6Do5
EFbb2AfJFbYjvYmQrDAWGobgiL5puCukx2mIvClknydNjNMLolcJGAN0diwKbQWPqALD/SWvXhDroZYL
vhsnNumWJGeg5vwCz71pCHnmBf3bzFt0ZK6jW9PLbvzXNwSjiafwDkFWli+hbWlzfETpjt4uxF2xM28h
llVek7aPE+ZhRbO38JLKhJI39k6BY/dExcrjoMflwldEnBA6QWcd0YMWlOd+8Gg/dy/6wHNgpGt9NNcP
gm7M7ZG98AFbzE1sV+evvVq+qUvuYRlRULj2O+9qnKwR1LNGCz8xTCGkjPJWbm24c1G8tPNJkcI8EbMF
Q6h93FqcO1IqTO/XWr5rkIfpInvjPISfq3lqVIQQR1rdlwFJbkH0obg7WSVyfgilfzKEm6Mh3P37IeS8
IbR0BL39XwoMXQWFU/flokxs/a23XsHR8HQbaPksKCv9LdBUrePrsEeUEte2R4yTwp0F4+2iGDDLN4Rd
28iH0BVu03yyWCRvJTSSkAUjYEYjs9vjC0EpXhZLu66rcbkwfZRMjh3TJVgzQqOKDjBSUJTqgm9PnzV7
TcHCu1ayvh+PGHjhPauWPitWWmc2CQyHN3jwhmArfSSO/6EzVYuX6ihi7RINQ4vdBqMTyl9hcpvd4RmR
DUESXmD5lWxZseorqTL4IQygKRFC1T50T9JzaK6S1Avz9YYQivN9QV5eCHd2TrNqbzROGwVFoJJfx+c6
DHFJY3sHi9pCO42g/MYguk25Yfye/hhDldRSgqKxpzcz8OBuzpmf5+/Nf723/+XeX//4XgLLu3sz5psx
Z7/eW3oTiebundqhf3OavnhmnHjmvspIp6ggq8oDBIk2de35HUPmNNtxIzY1y0hLvcc0w8+1WlqjpfWb
1nRS4c1DN6aQd79aRe+x1CquUSHXi5wON087oqk6MfXKPbnJxWIiqhxyqZ8lqnO8qN9IetlW1XEeLI4U
oiht81GiimMPrMyk078gvZME7rgq8C57ngI+hqdH1Z/luQWIg6IGD5JzVHY48l/euJPOxf64/ba79EdX
L22a39sliaFeDbidLytwuh3Mw9Wjih8h2cpvFN0vnE4da07/GTEWq2+JMV+dJUaEZKZ6mV7Yz726B/+r
jFG6Tcc7Njd8wwSlmTmrL4ZqqMO60ZD0z1R0NjBj9VXeJOIqeLtWNH2uKSwjdJ891Gf25k4DsfEFr6V0
GWbqY9MVGZWtP5WdLKa0/JXTVj4lwmEFbF1tqwjWhLWc/GebU+xV6UqN/gyWXmdN+QcEfR321OsCZsgp
0kJpYV2j2Wt1mDAk2g/1FubZTMOR8ySoySQz+f6RWglvn9fqWL0nt2z4c2HobXhHdX1785yM7/XCXAvj
/mJIVijx9tl9+Msjnm+lb7DqDe1rk4Oa8dwzs98JRgRTeRE5sL1w6zGJn43dDCpduaQxC4/tG3onGgMu
VUTpoHkqcnTPPa6uNZxB+X+biAvzmlJRenveKB0fzhJhQb+FT8mp6VuQcmbY+EmIIE/qP/zlQQNz75Gz
by6UngMz8gjap+f2n1L0pgaS7moI929rHhI+4E5oauzOCmHd47214AQb1cdH5gPWr5++rrxyihNiYQ61
cu/OGMBMoojw+esAHo9MnSWdIgMZRC98GD1621rmKRWNVCFhJNcDKoMvIsbhAOfabbMu3wkOzEu1/XKZ
4Kp12eOk2ODMQJ9aRVBrY87p2cGNZ5O8phodYXHq4xtztPrfMGnOGg0+rdPte8sT3T57BipkuHK6varl
8s8VVX6hn+r0Fyj7voXVswzVhTU7fFHqH1PbMLEn16jgpjdonXqZYsvkQqLyhNqL9YMZeufDcLUbk8P1
hDpHinC1x4VbuUxE+aemQQSLCpsJRuiOHh9hV/SunTO7qxBfJw77nsp42VtLp/z4/6Huz7oSaZb3YfgD
0WsBMgjrPqrMKqBERMSh9Uxtm3me+fQvcUVUZoDYw7337//s96RbasjKITIyxisScmiwkYMnuqGV8OcM
O0CJpb4+ZpJsAI8hI3OfrJlAAxN5MO5vtWDYV3Xrs105beKaYld+cB5Xv+1irw47lIG00neHa7Zvehzk
3m37Bkr8RJn0ieg+D1sU+8Bj4QStpBgihyCgfVREDFNmoqo+ZLUEV3DRnKz1+wNbEvFCUraCEdPYUY8K
sOVyMtzGBHlR0WP/hFXCR0F/9SLrz3EcdwUWG9c5Rgvl3chnvoqQsW9EoslTQfGZkUngablkV8wmJtJn
fKP2Nk5YZrW9YyMAx7jY9FgpOBMfk4C9X2bdULQNvVAfIkL9ZLZbUKLJ8saPaCKh5jaBToLb5RpcKCS6
nNwX7BwaSyuJ2KVpm96DF87oLijgtdf2azm/h7a7ONzNYPkfmm7lox85JR60NozdgFlcGM8qVL2g57IC
9mUcaclkT3GaRiut0okeOs62Y180bG+cVsnXDzRRbIE1Kwbs2zqrn8h4inHhnFRKppSq0oHJjd7Y23+P
PCTMT6rLMP9lZ96lMxdJZ3InndmpzuROueiWezMo+iafNnj2O09rVqBa0BuOoM+Go8V/Z24+dUd0/fxc
LTN2LBZ5lPSGY8Wg9N/hDgSUV+bt3Ln5A/AlQpwI04gOmeLL1sz1idQxmr2RjFv8BVLbk5DR7gukNg65
euRNw8M9CO2FcMFBP1RJQpBYCyG8T9GlshyyvgctIVV1nZiZsX/kaSA/9qJvEjAiMexQTPwR7cSAOvrd
7Uq+uYPysse/kLSCS1d9s5ah/seFEHchLgR9BWn/kep/8VlimkefJY5xBWideiFcc2rVU6p7InJhir6n
2QED6ecaW7ZRCDP8zkeWXbgB/X4NbjBtzQIwM29xKrZ4Dg/s/KCz3YES2nLp+TJ5uYDz/GX0yLrdyfVg
QmIfs5sH15z09BFNPsnl1+RyAhTiK5CAl76xYjZj1hIwwYLAinxecMQxdMfqmuMn0MTTQiIrCHK97g7K
bcVxABc0TM4ze6GiTz7mKiqjkfAP+3M2Vfl17FXYDr0HVvlcxeorgsfwOzu7I+H8uzDDO/ir1+2edivn
6zX7djN0+qQCzrADSpQNARNuZ5ZoLMTuJjjPVhCC2cVB5GVd3gjYmM80TdBzYTFklO0Be/SGoqLQQ4yR
1YvQSh8ew5/Vsy0+SYsDg/+GHI/HLTKZH9SAJ2D2Hm6keE8gWjf6zohg3lrQY/sUB/ikOAoizTm6Lj8n
fF+vlIPp7jMBUq9InoMgAgNi4B1+r9vfvh3D740sYlq2riFiXZmfiXPtAVJaNZ2Il9zeDFy4xlKFRBrM
Q3VLQuU5pSGFO5iGYBZK0i1CwoNFBN1ySZP+eHVYjOfm4Uh6obl63pkcLGQvAFt7F6M4uMgPUv7eYWL4
sSVT9/sOtpcfe7JkfNSVJLdWUTN0JWbl55XzMqIjAw4f4Gzx2ACrU86fkcD3y1xGWRHFHt3sPg8UN35l
wxRLNz5zGKdPUoliI2LcVDz7nQeH7bTCCjHs1dtMna1H7Yo5iBpjrfTI/LSw/AGkc9eX3P+fZ1v6jiDT
n/DQ5k0wF/zYKKAq1++HZtsTaAuX5v7ATUumTYdN+fDj+UC2yD1Mm7sDqXRsTPPRtVeHj/VsVIAA2z/s
joE5bLvXDj45RAnKueUKGnBhIhixGBVMv/zL4/Xi0/Hqy749CNvh6oe85gfWQmiNXClAFS5R1eA+RmhJ
XmWjnLybbvldjUOpaNLh5MH7X0AOVmCLObJ6gZXhDL/Vq1v9nT/Qx3YOpvAkVXUL90kmDNdviMZ2ggPn
QbYVQjkqaKE6thuO0ugqqfqhyFoDy9PgW7zr4TWsFuzy1attG/YK/CJ8XaF6M1DgMcKtD68VEVPF+fDG
VmE+SdX4I9hdgR5PsmjAk9zBeZJTRs1UAMkH+e6GnXpKqHnYs0qTeebEMsTjHDZ5bShJ/RGQfjnaMNfm
bkTBdz6HQKDP9zNkkdO33l8GHMXF7ckWy7GqtDSZpZJVsypjVrZtD+Vp1uYfZEYgasaApxSM1HDZwYxB
/4yirimghh6lNPsAJ0rEdZSae3a0Bcdv32qLS+ROaO7uT974YKxLlhGDX8zU4cMvPhwSyjvE3QiBK7eY
6/zLLxqQ1Ru/apqKVYRl51G9wRhrxLjrjpHeQNVsM300L2k6LiNgoIZzxxkGVwWjvdMMyLl+c1PT4Bxe
BX55yXLWnv1sTQnDnVd53qjEZYIITRXYXoPE5UUj4K01sQw9DiFJIyCwJpuR8zALhMEr1IQJMuLW+6M2
xZSEehrHrR0o+CGI6snF4aMqhjx41NfWuiQGCIzt+axfsY+BrQgLYjqVHFkuqnYnG4gKyteDGglScXUi
1eX3d24BN2Z3p691FbRsCWcU+xdYSOXzT85L+tzVkj5Xd59bKq/3wiyEKSZXx4+u7TxWj+eM1eih1yKD
EtH3dZomqVFP2h63DxNyQ5bPph05e0A9uKXHWnnkqq/p39CKuSB3hymc5r1wyo5yhnji0JokYZEfblCm
BAXsAQbeBhd3/uYjgkvhGh7YNIngjl4ZrHry3dErrDlp0xf5mHdX3+fVtgcsEzgUvsMBMvXRpU9sOkF7
HKQ1QLytTcOB3epLPfrSCNFiUCXyhk+VYArK4WymVllyFvMUgRbSg3ZjFlKdesnUQSwtZec2dzSiSKCe
ueZ0kFEn8/C7V77ZFoEi8bQve9WsybdOZ6ZQdeOkjz31bXGqwhxEjFMFcZqcGgE7EmPRpRnKYujtBO1O
1U0hdCUu4i8K2GokwG+HWfgxXCtzwUWc9FiHYvC+5SjAwp1rmLiTHdqUkrJbaf7hjXMfKR8XHbTT/INf
z+MpmB95JTRnGKF+xTVxu6bUbLqU/JeNPpKHKiJ2k0Q7JdWkBXkObOEO1PnY55No0ZeEV6rMyZmu/Xcf
ScGABF3em9uXvw9XIXNlI9DFmHNtv4L0wJQHdcF2XB3bsHTzQhjII/Hb0DTR1uEoFOYJE/PS96lYbTrD
7vm1wTtbFrBTh/qZhsOPHL07OcYGY/1My2EMTd5Fd6Rnpufbmel25vqZtjwzMQtclgrYS/3MkzyzMCtc
ZmkjWJ/vz0b3Z3v+Wzv9rf35b2X8t6ZcsThTH9ubLxwuxyu5Z14PC05rxefUnfu0TewDXF750kmUgS2v
1U4pOebAEvNM1S0GnFJ1b3uLBLMx8aHVoK3Ee9gCUCwh6gtwbn9nVGT6QFva+usTUyHvAkZk6sGV+CUi
U0qQXMYb6xGZVnYinqdIYu7FPoPPpXTVyfSlt8QwfTOvl3AfH8oq96uSf2aPZKQXWjsJhxSGQ5JMFNOY
EK1BgVdt94w8EZHYETreYj9UQZ/xxk9KY3EqQ0n9Oaq+SN6hsq8n8LGGweOnELbCfWIdhhGF6x/Fn3/x
LerzMgEIJAVJHvrORhtqaQhKGnG/lgxBxTUGSiTDBOWQAy9wf8H32Sqx4TBwdm/3OFqJ9f57bnK9sX5b
YSF36JLgvK+490F/rjJS1BrCdpBjK5ROk3zxm2FnpBE+smFksLE/sJ5khticK89eOcLZmL4qyo4xJPuG
Q8XEf/8LQrqFHaa9jXRLre3Qa3R8qSqmuBrdeuVbDCSSwiQhnSRJcFKvleG/q5XqyUsHOaOqBMYJ823I
jN+hK96Aj1CRKQp7WcB5rKvgFcrmPNEg2JYjtbkS6FiBEksYSQS3fRU5a9UEYucw8XMv8OEwwxoJrqeb
PrvI+zlqFlQRqmfpR7CunWkHwc9S5ZraSnMk4k8oY4wB15aIrIB/ts7/5K6MNip9WgiEogUOLEq6wWq0
1N73LzeTDgSnnz/+QPHn5/aZBZ6035ZE4sbR7nnkaGHZPdP/ZPecm/DPe+GW91Vflap2rmxN+jfEnJ6C
o2vJLDXdDBzG8TBdezXed6rH1MJS1czIHol8se6eTrDqe/4fJ1bvz+MYmONhfEz40z+//dE5kCyCfiSL
OMsrfLJnk3RggGSF/4ruImUxeMV5hj9Jgo5+HhFZEiu0P2WmHdPbJ0WTKGTLiw3jiZLhv7Fx/wnr58L+
RhPlSZTnv3+TY8ACY4S6t1wfYXs7huELYrSEQyBtpuQb/aBvcZLKXMnl78O6W3tfhDDiopjJQ41B3XEg
lidm4UhV5TnqMNsvVp5CASToE8LrEfjlNWBrKTOUq+jVSYRl8syvzw1WUgET8xnec3SxRqeXoIqNiWcS
kcC9oxkEMs3DsPQHND9mFKm+IvqRFnpY88bepLBIIoL+PSTCknIsjVrJlNm7lLh6tZzWM+l3/1XBzZWB
79XA3xtJP2sMC72VusBQ3uZVjJQD7y+utubHaaLGh6MMGNLSxidqPISyuT/Ig9I8knS90KJAuxhpvm/L
Sz/Q5xL/EGs/sJZ5OnF5EHKZspjOxqH4d7i6kkO8xxNvPPkcrNNw+hiEXpkkXouMZYilJhEMZ2oXQw54
a5G57RK9HrCzi5tbTp3eaF8PTQPe6qDx9yAacjBWBaRRIam8GPbtm9YHaELax/N4+Yfz2Do3j1IJhhfy
2k9ErCbi/r8zERalG0IOssIIqeF22lyfDtBj07Q14h7a5WPgqJq6pNGxNR+1Ue0+YrKLiV5JKgkT0k5S
B+pOKmpfu28wv7mwQ+2zG6z8dOVkbHwCHPSeKTg75yZwy0vewq/Yb4lahIYKghoy6ns9u32btH3Voabq
8wiOAPYU3rd45GSEQO3Exjxi9/rhnxsMtTmPtlNBjIiC2yLky3m0mx57w6lASYws0ChxT3HoWrBfeksG
OLM7C0V5lCpG7AtqSQx5QGHmDXdKUXwhKPnO28Wd/BElGYvMjhJmFLxBirLnbrEN9cIOJGId/yLKgZAT
iUExVuw35CtXBbVTWXzEa1EN4qjtnvwAbfyULWK1GER/XXf97nviExExpDgLBgxsJInW8b3jMdo6uuGE
fE4qQDSqlDde8SjXiAJHj9i13pPN9eSXACcCUpiww4Yhogk58umFvUH84KW4r3by/36qVqTD6//mRskB
ZWyJDrpbLszAkQ2oOV39WVShhbPVMSfV4QA9cymEvNOEvO8nMFzuUpE5RfDsbCcZ5qpZb4DrhWxOBz4Q
goB43M3gp7KZkK0z2T75vj+64LyJJDwlvfQh7PjMAhS4FI7RWSmewZaA7urkjRn4xhzEcYF/bfIanGwN
luiqnqPQ3DTc3LgSX6jkFsdPXjd7HirUwUSFFET4/tRL5SMja8eK8Mvw3r/QmjwcUTiHHLx4HvMUfL7P
ehjiQ6OxoYRXjtGNkg0H/lCjNFdiPDKZPSSg3jCEclTL8N2WSOEwAESo6RRvuU/lskkwtg5nxmjnLYZS
AYK1zogReLOMwIvDwI4E1IGbgKkk7EgTCY78eKtUcze058CR6UEsA9PqiuyUu3KzzRZI7IAqrOW1Op6t
0sauPeHJKs1S7X2Gz1Tp0KjB6FlFTmqtaOZ8B7yzEmUgdEXkCq4MDIolcyQKzyk+2zEctRpklYPjdYq5
oI0Zcy09z2OCNg+BLdM8AIiFA1Mq6SmSU7CjFSBWwSCYVZExV6sfv8SjnXCsSBUQSLWVGfGwcPLVOFYR
1sLayo7llv3vjXjo3U+NgazocOfRKjdGrnrkCxupQT6T4/Cxa9whMwObBmR/IMhSU+z6DMs7XNk6E2J6
uWr3KnpFe/OpUS5xJp1/QNuziWL1QDRO80yvwqHpJgCaNTeUp4yyG70y3U0MR7eA/CVRY4Zre3ZnLiUO
WbdT9Oq/DeRY/92HFvpDkhux0h+CGLiVr+19ZOIT22gIfXRAYxxUchHNvhPGOMJzjjNH7D/4+4bJ0+O7
SGFbiarJcz3BBrRF+ouxjdd4lxnm6umbdfWuq0mp6/WTGxtICg9ASKwHQHwL3FtoHPmc4HhcQUFw35Yl
4+hpZPLMiMZeRbwwS/2hamIERUNjO5+6sg02mrFJlSuXcvP7e0c1T7t7/UUxEsoX2SRIEkkUuCKuEniN
kT5C9n5f2s2T97SxYz2tqj41d2Bv/GK5lWylAzGtlATOFREKDuTCBgywGeD0YMfb2JxoBDONV/YNvLaw
VepqK6+YLqAxGL28yyfZW7ItLQ6CV3ctZg8eNujArPEx5lgS1r7CJcbTitYtt73buGERI/ADpyzfREsl
7GuuKD8y3MRYiqXwY2ORGumJnCL+zdareA9bHpNAcc26SplZGS7yzUjZNB5GZXsq21TanIJW9FWuenPA
PzhTCeNanvrePIpJc+0fZuep6HBzdoP+6bxzAZ14AVtKY+6Rrx56Kib+1fGHlREZhKlEzLFgExEQIpq7
sfLDjjk+wwvVr8OX5PtXmBhUbLiIt3axsqfBIe9uuPS7nqOa5o7MJZtJqfYgP2YgY0hc9sobtcDpnkei
ldF9J+hOVn5OONDL8j6+9nTM0N2k1MXSlhOOQnjYo7HdrMQXe1h0lhTG1l2p4UosV151QKjXWRi2NSUG
iTYFgjP8hSgnBGp+RVfqSTvZ8+3QP64dxO2gnZIkZZPZIMrZwkqlH7iXhW2thPpJPRpqyal47oscBq31
sEjuIGOSu7/QHvbxf9hmhbZfHKxkDJc7bV6bMQNNSgUWNn/0LT76Zg5Q99dPz8V2iL/ZPxX+2ZvAXrLx
MPRiOdcx+uWL0ZG5neMFVmaFaTww7ZZqLPsHc3vcXJGXZoVEyZPWcn/Zmr1KyaIw98kOP2tdJbBTrpb9
lPL1WIFZzIUoTXd97lvsI3IgmyKA2HvJGgi6+18QQp+Hwgu9Myn+uf9sEPKR3BRNjckZUfQf8WOCfZsb
GHArQwUVc+BIi+rhGJ2eHpLgI8Lk0bpLwAoQTbo1lxw/TvagEBpvtDVDNqLTSjBy6EHxwKFe24j4jVzQ
u54KfDk+sJ/pwFbWIxZeg4tQg/2FfgbwXhF73u5tWlWlaRd33oJ1qs23xdrfVzg2I1OcfJaajvZhXjmE
OFp3Zavuds/AIsfRqbCAxHF6rSpppNa/6NFnbq1McEiTi4N/juIZkpE2S+pkVS42msaqqlLCC+m4LWpt
hAEHKDDXbE2k2eHcz8vGpGZetrMI1oo4NVUMTPTvsPj2I21+AWhafGsuIn7wln+/A4WAXky24aj4xust
0iRPW1oC3C8e2cgSJTauHBtRtKow2StdAne1bSAOrulOu3KpCKVVwrLdMYE7j07aB4dBSiyYC289q6/U
OfQ63LvT2F73JBYTG2GpSo/VfU+qPT7n8OG28CqhcVcTzNbTMgsr78x+J7aD+cokUQg8yOSBBRYuKZ1D
tAcGX8PWhS2iIQhF2AJTix6WQbqjg56/+qlFmshhi5+IdTwXXoiRSB0yLSXk3hQbkuYcVox89BOBA4Pq
0mQjLWRGEuD3KfZHfZLrDt0lDduC8ZE+84w6sScZ/yRCsgUvSj/UnmX8tmQNfGf9Bipbt9JhibOLxW84
HZ2xbF+u/InRlOoPt2rXH3r7cLk9/wyMgtWHuSL+WE4DGGseGf/iq777QAxm7vjYwLNJtRVeeZutlUzp
Qwk+NrxwPxOiPsgXZ57fKGvpSDBZ1xnrYEJDHJVVMmP+QFTVwGxNBpV4IBcNDfo2MlmTxQYamwxfWBvG
b6iGi51JRiIlhpNPQAmINhg+c9AHfR9TGbX5PrTpiM2yVj9VARZgVZqpVTD9n56qQXx9TlSPIObHxWe4
3XtOiOwFNlAcYVZwyHHlBlwreYGKrMYrZh3yJbwbjgx/wMpBtFTu4ngmP/gFZC23Asf/mh1PcG3pApsM
NQQGz11GPn2ppI92cpH+aaz5x03SSpXx2zJgnmvmHND1i1dbk4tOVcVhkshpxSteON3ShY56Qqw82Ksr
ozQ2nD4DOwyVKtU7VaWantew3p/jPTxUHOlBTlSfQhB6fl9WMQJVz50h5HJTeRUiUC/w45CTmj4q+C7Z
EjYs4okael+/tGMdWsyhPmxnkQwe65rDXC2TRALsF65OtlmrpMx4/fmW5arRyVuQcR9kyIe7ja0SGkSQ
pF636MG7gUnr+52dv49tcquyA+Usy758k8oFonhe+KwNeSTnHmlQbt0VpTHF1JuruIzDKyZJqFbdKDFE
Xp3ObJLZKc3PVBqpPDT3D0WwCMSTmezOw7I/OWnA+SnpK02fqajm3ZkGcag8wp/13N4rkf7Lh38S65hb
ZPiBCwRRwVflep5EjixgruCTSggezU0EKhfxTDZnMir+qmO2+kzbqDNNBGK2aGCA3GZC3ZYy5QPVUlm1
G5eUODtSwSxNR5ViMiQQpxAS3WvyVcEIKZgse1cbRdZvbi6LYqvKIXImx9qG0sfanezxmXVUtDGPf5Em
kCwxybo+TYn+7cveg5Gbnod7NBhZkYS/fIX9L9GFIjbU+LawOoev1V+9bdkEVVIEwZ6YoJ/x6qDGhv5R
8Nm8jY3Xl5tSsu+WKQJJ2Dx9RKZtmRa2qHWZEUzhN26UZINFBP4DK5/K0tTAnYXz7Az5IwKveOtF4Ibr
WpRlrl1xNNYxF3N/AEU5dZ8L/bC/hat1XsmJSxSOJLobGvWrIEFX/qarqBYz/dTVpSf8OH/naIiFwYK6
WfQ3IXPyBEM9jq6YOaObP9k+AJF5YpB4wBWOYmQgP3uW+zBm6QXb91zkUo/5ynHkknLksKk2Y0eyn0mU
c3AFE8+UGgxc5Y1RWc5TG2XEOaLfS/kjO1qaQqRgXXLKWHt6wHD4XIPTiaNfDutCvpBj0Uts73pgHKoA
3z8BtAC7h1WsZs2N6j3H7fxwV3oGKqH7EG6z3/K7Mq4jlHPteVXHx+tXINDHXRebco1dgzo+qDZok1wx
mse9AfA1BxwVw7JRKUFgdfZSQc8gQDxr0n5zPKXwt9RfOFbgCZHNXjkxEKhNdZ6doPjkwohm5pKZKl+b
S+wNQMt5kbddj4rUuqgnxH2Lke5+dm1p/AkNeLry3X4Y8MKIrX+hMBl2Zo/l2AtpfiO4sm240OCu3KBq
zolMXPDRjkOvR8yM/htOSXHM9BUUylNv7s/hFB5jN5pkPBP12WVlK7WdVzdutgZmyQ0yDkNVm2MfQLQC
2gL2jbxzm4fPIQRSflT1m+qh6p7PGDovKrDFRXkI+xXUHKog3mhuqlwyh4t+kuueAVCmAquRk25koySv
93BwdY1DItK5l287DoyZ4F3AZVelHZIcWD6M5UqblQeECt+LuZRkJfCu+pRhHUj0qP5kv0cT+hggd9NS
U2z6wYBsRFdmwop3Z40Yg5zhANT2cTQ0rGc/WEd8cAdZzzF92zecw/d07j3OulNYuO69qGuSm0lO84px
UiHYV4OsWFEGP1WYneRPJMlROoI2WUrayyMTMF7AqyqEqCqEKQr+Br/GVlHkxmzEqITQ7K3Y8mh4Ihqw
oXuaVYGgpaxjXxFnQvPbzAk8nmtdZgA3rx2D2AB2g3nPzYhPm7kVOP+eUUCbZ4sACP524JuWoJNffFiQ
QoscPHnJmdlgMko7/fRWdF/O6sTErJc3dcizD2xV5hgW5dLW+/5f3VYOZSMnrIevM8PdsdrMJW2BVsxh
UXGw33kF7lmUlheeJ49Herfg+dwm8znTqOFn53PA9RqlQ4edojgS7MC2DKDqGEyg5etpKR07iQXCBZhb
BIqASaKwU8FlYtIUcwnYsOTSYRFE8rywnCUAxO+szFLEOS+3kIcRr3oTqTRPZ6yRWiQMOUd7VaBc/F7F
XxwFdm7DxmCzFaVb6MHShUrG724uZh34suQnO/SwCGysmPtxJsb1iV8fHz5oxY/J11lYSAkpIffnHhXZ
Kryl6oeOczykgA0TcZ+dFgYTXPlVomis8vgDxqXS+APRmofftuwX7HD5uYTeHG688AVetsNvDOJwAR0v
gdlDyAjpS9XoRWnRbvqqxKVrGQy2iqmrIYiyiiDKiqoYI8t499W0LmRal//BtHZCSWEJMUFSor9/4dnd
k5AfF/aXbfWXB8BPenlsVvSRTtiViVkZdcacIL9nzVgMXANfw2h2kCY8IR0mXAwhZZ6APR+wwcgouWH4
U29uSWfKyQvmX56CfHMh/T8Im9gNC1MwYvTPfGI7HomybJZ/MDTpqQxtuvvt0GQuZGg//uXI+heK4xcV
x9eKGvjt58PoIUm707UeriEsjq+g6A72Jhsq++DpCa2Md1KVi92dHbuGwO7RJUh7DWd88dBBf7i0/Zz0
uOW+6PjNJBmNyVpaZHgyPgMqCPmor8NO/lMgWOg6+RS595IigjGtaoF1ChaOc2bF8eO34DmzpyOeE9T5
YTEbukFz8SSIps95GVwh5+zc4uuRkECIlVICRz4GhaM6UwFe8h2E47MGlrlQJpgxHr1XndPJXfHbUf7X
I6bnfWoXT352pGTO9fk1rOs1VCtY5Bc45gBswQ4rOe3QuDhyaFSlqBKRzMKwueWl6Aj3+RKxi8Iq24yr
kXM87HvHzHLq8E9feJKjK1VO5Kwn9LRVCZq8VV94sQ4nS90jvbGj4ZE3OUbK8XL0nOC9Xp1/OHYPI2+6
wWmCOey92vVM9uCXZO1mCaR9g7zFJ0zsG85EqHoHuabycGqKXyv9sJXzu7tnuJRPEglW3Cu7e9GkWYW5
FPGYkURYEYepgyCliMwp5J0Uk704y9ehO0ZexeMDsR+2DHZOvU+VSbDlOhRMtmTP5doSNmMdWkYIPNIo
XjN6RLPryJMUwTMNlW6oDzD1f9/1eGY/fK01VkTqa6MKTwlhSa2Ta34Mw+SnNnU2CMnXDurNWizmHV0l
gMoaJ6quxwHwAaXsTrYbpcu6NkNGgoPrLA7ONt9Jmi+a47NzaVcqldU1aV8uC84lXeHUEsz9rat0FCfQ
Tk8qB7pU8Ga5pHKzSwHgb5zWsp/nOJKvxHv2JfHXN1hOTolFLoJPp5lEML8KgF9G8DqzvMSNlVTvWzP4
FDTaTli++ZpsAoanvuBc0hz8yCqv9Dc0B9MfQTDEwd0rofdQVuldwEgmLRrH3cYMm35rc0BTkGKzGFRk
l/5zeAPegNvKGvutSZ25bZR8mbJ62SFQMDx1sMl5s/RrYnI+3NgZxQOtyNvSdTY6/IM/97yzOZSX5QiO
AS2xmYajSEuWvyPZgI10Ai/KSatBv8XAzTR3o47T496DRMnO8utjkXipLOuO2V7Vh7+fkKbZSWTf1y2p
6sU5A0copKtZUoR68S6LpWUhnxbAHS4ILFPnTNmOwwzxkZSEN9cZccxe8+52eIlRfMF5X1J3x49ja3IJ
/sGx9e+Z+egv8O2Gdu3UORtsvI5AhasFg581KuoHW6vbaTMU4fZoQG3v0/KIbT5/EPbdrk2rvKlGin/s
kKodI+EHLcbbvBhWq0klJNYlNkwz/HkNtCUBtBzvzulTXFxjxIbBsYCawoiDfzN8I0ubMwpWeTcPtxNv
en8SFiIAJv9imZ9cMLoAE4KWtoamv2Ruk8yxo3eSGgQzIQ2I4VFQFCiqjTkB9dek0BWt6sVFfzyP5BsZ
3/n3rFE7Vdm+MWd9EWyn+iFsTEY0uaxAJRtU+9EeDriHrWykTZaA8+LHLrwUtHx1DugaLzwXaSXQ8GOV
uPj+bWIk7JGDuUbqjfcpP8nV7Dy79NGMMl/BmVus6HNU1kRJdSOjzpV+/lgKY2zBm/rkQoXKsRD4D87s
tui9Gfmmn9xGmAYHubGyew5HTcd0IIXcDGx/7ETBxt6kaYPcsFyHGW6w4/QGDLUOkqnARtiIeujjDW3t
xux3nSeyHTDQ+WviLc50VKRMEQYKIHT0lbwxiJmTRM5fI7o8Z58noBZUKGFZ9yYFohBVPArKKD87Czm0
liEMoyt8AD6uqDXXtihniUK6ta9g1Df1xebTKjAz+3oVeibiZei7PMfocLFjBnm+OrDjtSp4suSl6JuF
X4ueyUv1SEgdbazGK9e/CBL5vMTFyvd5XXxQ2Ik2hghG6Sd9gBIo8v7E2aK7ecOMZy/WtnwWkgTj5qLR
qUo1f57nPFnHAsiiXrEvrCcEySZxlLM8pZw1uzbPkD1PuOCSB/lPEx6883wzNymIe8EZgpoockPXok2B
JQJIyKlozn1Ig1FA0oz3NlE7zk1XXk0XIeriwbPLkFfLcAtb6tOS5cWyTGzq1xO7PTOxqT+Z2P3/FxN7
cTyx27+d2NTRxE7tP1/Sd+rTxF7GMJCvsnYdffIElhXcVXPgy17A2nNQEYZefPYlbEeYCZcqZaWiChp5
9TPde3dNkzTRO3DLUka5DgVVURUyU85DjsoSNFoEArQTvbDa6u8ERgniT6SVCj588e9PbmcgZrThXtUk
P+Nn59RNIISIQ3/Cn2lV3By0htyYj9tqTTwo28unb6fYFjs+/vQpOIkgsnXwEo7tZ++HbKU/jr4YoJY8
zE3R2BY/2PGkC3WuvDHiGkd1UzBIqOnvMLq952xppJaC1f702BytWAJ3hr5cqjrrLYlCdSETkajX2MDq
wXaJf3jT0bVHewq6M6PEX0FVkILFfT/p7d76uBGxJsGgtjediUm0fvujUFCGybzqpTZM6kjDuDRzgiKr
2jlTTi6h2BI7mVhs571NIZAOY24n0S6FqR9Mi8F7hA5YQmfQVghwdbYydnDG3oK5VdDVp1sOi8aIfmCU
5UpfcuQeKBM8JrtRI4jspcIJX3v05V9Za2gP2rFd6Bwzqc3qzZYPyw+3B5kJCIb8BpT23pfgjpRnOq+k
osFg82PAamSJ4R44CcjKd8hpb9JH61PQnfX1Ui4VU0JUBYN9+5DjWEhc6hNsvMfjOb1x0or4hKOUysnQ
95F4e9Aav7wPySREoI0FJw93IX+ZakJYnpSzX75iJDemSyv1rKOVKpQPfchGO25gWbCqGMoCOw50ddXx
Kk8rEFjVs3NfNAPuwKWINi6dNsjmdesu7OIFbtWSKdiL/GeS2PsialxQHmvgvQA0u7Tds2opdmbO0S87
hqDUMYZiWrDTgTdZBYDQtkv2nDIS6mteJdS8TtEL2HIQ2iDVBrRc7C3kxMWy9ifLZ4i4fC35xi5spYxf
OcvQFbiTk/a23HwwUe6mjzjZwjt2X1MBlKjpP11e+HCD5qLvTdqqrDV6Bvk0Gpvhi6sxGVZnku0x5/9f
B5w4ivxRW6NG5+YHm0NbGT+OmRmYHH7OTQL0w5sSguzMIMV7an6wjvG0UfPZMVP+GNyHE/MBnXRqfuJX
VeLqh0ZevVCvJh8VxdqB5FBoRRMbeXh4UbpbPHrxUr/I5ALKiJC+ocuT4iBrJmp7R4A0fuUAm/EfZWdd
ilKJMu9bXapWrzsenuNL/9/c0wawmKrXUxaEvgg2+vRWMGAig7e2jY12BZGmvQ0X3vHSzqr6WM+7vuMg
j5imcjhNsu9IQeuyEYVgspzhzAca1CcVR29vPNMznf2n8hrhUImCvUicg4kSaalpEO5KnZhZhWrNFaxs
r6AV9u3mjCKbU3Ebunegc7biSao1TkUyokr4npiLiUNCNDkaMnXr7bSHEnbC/MqL75CAo37oNYcG+nGD
1UE20NjoHOo4yXZ5OyLWSBIyD9IBnkY41YOX0l7Hfz0B9AH7Y5ME0ZOfczmQA5FCOAYkPnOKR88oPnaL
QTaDb594GJ6Yi/Z7npHdx/9QBbHgfNPfEf/2BA8gm7QK55perHScTuT2wA8YENCnmqCDUHvf4YqqwPOk
o38r2KnZzYH5MpX3GMKXo6Oxo5/jOc/Ps9LgJifl1CTfoq+zOXt7TwPOpkR/rycuAUDk8YxdTbyB+wVd
ez0ca3LeFbu8oN0xz+fl67eP4A1bfWfiFbAxdO9Go/+gd9vu595tur53e4MfkzBOgxynyIqbhfGQzsk5
fi3C+IKsREv8WoXxZYOBX0QhbgRrjirbhPG4cnSrHmz51i6MZwIXM2F8ZTd+lLHf82OZMGYPxsSkvVcN
ByQdg9kkcjZe1fmpLAe1ZwAsNzWg+pU9urpmq8wGmvMW2vQlRlIKY+D6lvErFcYjEgvS+NWJ4vRIesJz
Xk3gWBx2yRP9RdbIxtaUnvy53ffsWKrT0Qqo6nQDXZ3uYTRmOCwq2MBi8lB4YwRgvQjFgiKFxGbl5KkR
7SW8oZGBrKvwCGBP5eTez11ameM+FX/Tp0vfJ21an2GV5q4oHhKFBzdBEuw4UxhrhwsT83OKaQsm/gas
/qXqGBpnnEPA+9OpsRsQod4K+TQaCUI/a50wCl8fhOJ6c3N05xo5DqosVuf04EHTBybbMUlmZZMFbZIw
XfAlJpeOMYSzVfA+Ao8gzUVx6Y4DS3S3Y267vuYqIvkX0Ps8TrBF6k2V/nV3rlvNvlGb3Bzv8YHs8cOn
67LFE089Wgux4a9ZwFUzEPzrLx0lArfkWOdwWdHRfSLwBBoAQ+qw+sYSOndxEa1phkLgOlxfJbNZso+D
sQs/D31BzbjfcmT/3mv5wUy7ytpDdwvKM/AgTDB00sjIQEMQXlhUzzp/rOXsmxabFCYD4lIoLRRe0G6z
8DGHCzOVKBx5gv03tfmHm8aHdEU94ELYq0lGwMQmTXAHea5gq5+F3E2+U+OTDv823/Pa8nBm+Moecmbg
co3Hv7Cb8PMEyDOMCLhpc5XneAMVtHHikOTFisd1xTt4l66W1o36SoYOpN4lm0X5fsSJ/rF1BjkORE2L
cNk5SJbv0jLLH2y6IcuTQB90L88++iGPAn+2+uahCzBigSmQixKhefmUeJ45D5wEKpQih3Pi0HWWNW7d
ZD9OVLpqO/kL5TbrP+iV1vZotDy9G4SYdU0SIX04b9/j7kaOx0MX5u/YTRclEy8sJ8I3AlSoCBsH0ozo
xUrdgcsRVlGM5Eay6dQrVPsNqK+95o8eJ4BdfKi6KYcXu7NogZToWTS2w3d8Q4aSJ0jm4HEM2oW9cjhD
GdgRPYspI6vWeBZBB53Q1QtW3RfmUlwffHr0DivSM8Jwhlr633uR5qGEIwt00jF9TG5SgAIPS6keyvpV
GByFodJEUvIeZ3V8Cu52IVBWd0Kbif+wD5SIlCiOE8jtU1HVLrk7SQk9bqLvvr6codzjiiZrdfsNOPGF
RzVVo8NUTZKpmuvktH8xVfk9GuN+5k156JX5gxrJ7/G1hZ+qpf8Ojsz5fzZVxS+nKv3rqaqvzYBzS1Jj
ibuxjDTjuiOuGhfMFAnKDJf3/O5xSqe+9EidoRJWPrTqOw81QnSyZMa02EkSjzsg6BWXjM9RlJ+NY7o0
IE0lBLOPYoY6/Vj6kxInOo2oAg6bD+PNvezrvAkKTn6tssfk6SCK4kA8yKJJ808HgRTtHyTSukRF7Egu
BTvrRXGNWUJLsgn8XMTfSkb41wSVihjemjIuqrXTR9uuEK9UkKyRMBhfnz43Mj5LlgCHseOuaDrrN6fP
doz3r1EUGoZxTTl+jU/PTpJnD9oZCaMIU7hpHHrDmqh+NpJHce4gGY0eefgRsCgpwir2vpkKmNoMtfUO
B9R8zCx4MfbCcscs5bEVX2US7ti1XN5wm6wpjcKtXN5x6htX95pFe7mcQSN2HmXlWxfyPxKjcvJUHheL
t6g5Fe85nG1guoL0FdNCDE0GRyni02zXZrKaFyiTBIxIQ0Oh0iqrPzmW3/Ag1IDElUXRGAmZWj7myz7B
A9TPOEoVsV+UsgJwLS+1OwgOEayToWDdpwq4yva17ZtHpcqwkEO7LCR3WxWhmkH2UmUXgkjueH9nWMMA
l+LaC0Fu4tlTc32fsKbD6nR8IwOIFQnQobTCxETb4xEiFlUZe6DcR7PP208SDI027ZCj7IvHQG7RvdOa
aL2aWwVIINGQBZGbzyCfB0LbVD2LxH7FBhJzOo2CMSaljYZqI5Y23pg0CaaA/pwTbkl8YKRjuzlKYx6c
aDZdzAyHxiI4UEn+H8WK4lmJm7N+6U1K6Ban0djzD+OvYS0pK0IQrmyjcVJSiNXMGWhiKYPjOW1S1K+O
7VsyS3Vtj/ZOz4rdkvhvn661UE6QtzKV9xtatsPiPMzYuAO+StL2YQnTT2rJLsIAVolAhPuEUjiDrHI2
g4zmq1zp+GZep47wg4eCL1H/5q5ymYMQ2O9Bt8pkSzu79+Ri2ezadFVVwG+Dr7pGjGIVfdm1eaXnu9Yz
U68IP1xeu771nd0t8EAVISOio3LVc6BJu0FxgEQYYXA4qqMG3avcJDNVrarAdY/IUO85+ZldulPTU8AC
/brfpaAzBhenqzWcBs0gW/miDx9B1Kb1rBDWa2zTDRVcqISgb6g0iwNf4kG8mv6c9i6zGfbGXIgRx3zG
5/FPTJZ7WbzFSQlKy5AX1CbFFJCLeyDID5exRw0OvR2ygr+vxhRS2m6l+mozpvvHellU/rMefxz1uBPy
Mn79/M7IC9yX+yyFcLw3dvT6j5sDz+uYeHyjooCOJ5I8ktStzK0jxWRipqIh0+xcJjyU1JYlfWJiGjst
Ie6VB7xd8uYDGMT7VqoB5TPWR8BvTFlj9vbYcXRJjHpj4h7JgFtzdRh4xoSloRL/LjNaJDaO/DumAM7M
vJYj54c27wEAmpvY75ttnLwYca5M3yPpPeR8q3yySUT5SskQ7/uhd8rhyoI7QELecWgvipFwiQlEl7hI
9GoQRWkYHbBVGxw0XzoM8JWhWsKSKUsgI19NvFZd1gs44rGMNBRBiIIP1Z3/xzX9FlhuLkiM4MLAZyYx
kDNE79fnX442Cv1IZrcnI0F6ZMSnDli0PnWymGMpOp6hH5WxD2CAyaWLJMdrGP2zBttmFAZZtf6L8A+W
fyHLz/khHCbcM/2sMnJ2XHBQkmAx8cH1r0V2nbx5GmC5R3mpPpFJy02hoxj6p8W99OvsMxQToH3ZIJNb
tcRLH9N6mC0x8eOTFbKyx1Faw/L88TdONmHVbcFrl9ja5jpq6YxGKXTtY/nD6gV7CvfS+ggaR0Col8kQ
OlaQCVmMDi5w+mxsn3XErSX/zJMkiEWLvZORbDSHePlGovIH+8dH4dfzfi2T/YvpY9pIHLB1SnKFkMsv
9vAitVWnaJhK3BkxfANNdjWhmp5ufnzUvGs8wndEbiSeOlImoo81S82yAVb4xWGg4xCknjowvbyi9dWf
0DqzOlY54gvz9Tx9QZSJTsTcC9UCqpymX6qcI4ArJEakIzhyVpVjgfq5a8gqdgI1NlSqy0PZi1McESRF
qXocx6+ivjdmKnPfrZE+xhCgHJCRV0E2HOP+ovYqnWrSHovTY7X1WyOVYZqkSh2We2vHGnlAPyVnYx/G
xmuSfL4nodf8FeRI2rGD1z0cKAPhwsQOegM9KrfnGIYPp6yVzIPg3HOJk+bwXAVScRydfe6KprZ+/h72
dz1FBozD0vHKVp04T7EyUr2KjKuPYnuPDpIjZdPlq2FZM+HnXyynqIg+Vf/TAkklMY7Q5eLqOX5poAA3
HsS6/ZhMY1LRJ1hkoZ5zsPsOMT9rdsnncs6UbN+2PmmyxUHwQR7e/gQrwkWIzVSyGaKT5smXBA+L1rAg
IcJpn174PBNDdZqrPuNQzJuUnBIU+FcXpbbCeU45f95xNOiQddltEvbny80usC2WIojlkcHFMR97xhuS
8hJlMk8/kqj1vDWyxXEt2dj03xutWKEKT1q+FsyUeH/7i7W8/O1aymYTVlEiC05EqL8EGhNTuZU07Pok
bl3hUIrfFghxfZ1zCMzsxsmYQS9kYxoDUM3ChdR6eEC6Hi5udGmSLefY5e/9wa3g3Jf3boPTOR5VxByO
TiZbukDrfUv/FGoIq13EtkgqyZJTDYlWVrGarqF31WltiOTpeJxoQ2zOEX1tDSJT6pmu0NxTpKeSmF/5
YcK6tn12AHHJwTmg4TnQ5cCxBuxce8ZG3pfIblQXzDYmBQYiHNwxY6oGlg21yNSXsRC1NMW7OxEKmsre
HICz5yTbaog+c2XrSZjHPWTGBrtowRS8hzO4U0GXl+RZsZ3qsscuLJhc8gy1ABtorGDH2r201xzYjAlr
EIOh17ssRpCXV9VZOipGtGNfUFdO5f2lM3AldS/wzVLkJ6Z0m3DsKCp7xdUzxno5cmuMQ/e503U6WIXE
pZgLje6lfwjg2KHOsUCdDlVp1F81fO+G0jO7rgr1cU0nZFS/YftRPfhBZ9HA/GCRnXmdIEVvgOsV3fUn
Clu+MbxncqPBb52N7sCRM6szBcYYAMyHPoleuJXdCvkyC37Ynk98EMprsudOa4pb34YghATefXwUETUC
xT7vf56bukXzZOryS8+VdNHCg/Bb7qgz3Z+MLWUUMhM2nnEvOTEDqL3xJSvIU8QbZ02Pk/my6Eq95jrx
r+mxFP0tyR0NTyBxD/OftRwUiHbXMfbi6ja47KrBE7x9Y4d0drIJVCHJ12iL1ise1S1KPKX77J/5ngbK
YMCAEGmWRYfOJxo8DNru/SueZGSWlb0l18fhocYQ0K2rOcvBGG0/jJHpY/XHslj0GnhoDTJWnLMD6HHt
8PevRHcdPIssuNc/+EawsB3cYUuKKgxu7yLf0h98+tDS4Kilgf78tKVf4k/ya/hY9Hb54Nf1gvM/0g1V
ok9ik7Sow+dNytcKTtA4IU6zl+Ipq+KAmjgJAL700wcp58eeGcG+88bB9M+JTUCyY6UGP13nolqS8CSO
SEhtXZbaivLxIceIBJkCx/Bs+saVCsyY07vEqDZwHZF/ztfcjwobp0pq3EmhxgNL/J7nqBXGZEJpweBS
kkC6C6PcSR1OEgzmj1CaeUFWdkaEXIF/rfqzxI01pIWbIv9+SlqcPpJ4z0WtR7DEw9z2WuL7b3zsYm6h
RQW87yOlWFZdMEu5BNGXCpAftI2iuGEqSZet1NisKDgk74EAv46CcpI4uMEEVoD6VDSF48v8+gXHY7Ld
AUJa1CFCr0HtucJWpYl+evPzX/56/i0m21ffY1waPmvwLx8fgZ84b3Ln07s+eeSX6QCTOCz7GwiZO+rX
01gb4z1ti25+uNP8eaFKMdWF/yHc4kNyAdldSgZzSkN4IisG5pQ1h746AmEXLKmNpzFQqMcFbLyRueAs
jIfcUCIwhhTIUl0DJDK4YS8hegRVofY6hVmr+sZG7ZTXLGsFkx7gHieg98yE22TRcw+o4aisd/jIS5zv
a2fhu2bLEvZb2bAHYUhbdWOj1cCz7JGRWuIJo+JTIgk1AL9AD0SbqpxhLX76o77Jq/n/ghUVEAhfsj+F
DwXlSxWn16skY+jrWPB7pCxew70/isIOCX3jiH7NonA2UYrt8OKPAy5s2oyUtUV11oVR1B/ZwKqT/oc+
/KBnLo6P3cQrmTZJPvDowtd2fRYR64VE4IF0iMUcwU44/zhWA59Knq+o7LE42Gc/47wc9VKCNOidR7w5
j3JkRxhUmpSZ4QN7dKTI5MIZWIXRQp1Z2i6YVshZ/2kz4AM+w4wL/hg7NUNVIDzHlYsxzsvqtyPvbJwH
W2e8AAFo9wdfT/sNCn5lcfLtbXJQEf+QWLxU0SoMtXJBCayZJEZ2U6f9z2gZDECyZCia0VoDsA1XRr+8
4/hdsNCKgmdvYQ/ecNdxutew/YYVBI2lKnFP5eZtPeRV4sFBNh3kDi51P29/Mnuwji2udt8Ya+AqJ4v5
hE51YcMbG0A2fIIW7vx+m1ST/VZhb84lkxSDg1OnbkAT6coSnp1qPHlTPmtNL9+8P4o3DSUW0qELDW1g
l5ItwGNhpomo7hCW7W11SSPLVyPtOfQDfNiHajN/g9tkqsMfT4lpe3tMSxmdHTLwtARHzw81ccOuPZk6
8iVG8BoCDadTU/fLnLgn1zYNFTaVyXgCqjB9cPIo9MkCwTi2g0mtepBGfO6m5l+fhswJuDu9zEyWrrNW
kssSwpKSWnkxlNPc25fy/S824V/N29oms0Xp6snemZkxOj2HYytvynxM4VwJV34iGA40JBqc1nJEO8Va
sFKxzjkv7D5sFD9i/t1VZdATYD5m4KsLfy6KEedbwgEPkhy5+Yds9z3mW/driOW8XYIzPCE1VzyhZLb8
HS7SXNlI/lR3ZlWC2rbBU0FMAurV5eGcPwxxEUcltZfKb8dbaWsufG3KIxaK7mejX/Y+KS2QuVPwxt2k
nNyBRZG9YRmjcFs+trsLxWj3mgQzatYX/hRImyUbrpiyQvZh/DjXq7LJPv2C3C5OeX5HdWVcPOH5hST3
6C/5/IG/1E84dmXihaQKrhQojOghmFzFKWLB06urwydmV02a0PkVeY9WV02JIRP61FPVuVX0KdIN9yjF
/MoqzcpGl4+OOltF/rvf/Jz/zpNSPB/O+cTtYlIvMuIlhWbWN13lPnnuXXpR4jS9RNBjykp2++CQEXx/
Y3jTs58fA6rykxfKgdkzEnvXF+ERVMhcfhYOMTVsAC4JzmcZuQO8wMCRrUBQXV+VaYJH9aigjLaZ6Gh3
RFuT6AthLQsjMvIRGkeUd8PsmrrAdoqHNWvaS9HBaFdYDqLllcnTVFagLI3rSODf1IOOli+XfXu8T5f6
tC0d6CGJuBSVpixMQW7V7/+JgzBmkzCn3D0IJeQjMvDg73daUZh4m7075mRwn9CfXBJwIbkPl+80lKWT
Y21UfHeLIsWd+8QEImSxUHMROxu29SENcHYdDF/8+GbhFwT9DQwX5cG6HIeTOoxolgy2LeiY7qp4vNI8
sRyCgipQtLWuwC/m1wXiP8VrC/zby+uQ5IXU9UNay6RKYJq1XIcOovdI6UaJEhUzyj7tbnolysLYZrNG
mVCf5TgKGFXoZTYVDyBfp2gX4rAzJl4u7LAf/4lxifO88GRWgA9GOc9lou97Vya7GjEAg8AWvdLIbZ0S
RLU3NmD1uuVD5zdeY2EB9qDQTEwQtaPTFxunmJ/VJPyv4ioFVqYIka42ljSptZvDS/H1BXjFFWXf1Wtj
9P+6ir7S+XMX8yrw7LVoLLfRCKYUKHm3H0lsKf3THJT8STwyBZ55zFyTwglqQQqXYDSpfYwLOv0553hW
FfVvefAMJP7udVEBKPD7MkjnPCDHxJRyihVL0nl4/Eq0Zr5RLvuut3oMJI/9p6Hy1goxCMiWfZFDYse9
2wgAvOfeDXJeceM4KeY2U0QO3CCHJ309dd6q1I1ifHP9sX/hriIB7E/cVTNwjTdeJpoR2AsE+GZc9opW
C5atyG1EtvW88adBXlxFrC8ikvL2MSp1wwPwnjgjE6FLwp0v/jPb+oFaeFBJ4VFLcIWqXvFxfAVFQIGy
EAD1kFK2jrQzXqAEc4V0v2a08EK0pBAIvPp/td/M2qtXXNtFHem698KWAre3yPIYB28dZjHTsMi4oUIm
2UdVnXVyoynogmx0B9mzf6Nf6PX9fsqYtdS+kJslVCBfopBE+gZy7qAd5AZsAChaXdqqHjTedBjC3Mch
cPAcOvP6jXNG3dyNVBBu2kuKr3jC+x2u/VwgTSykR29I231/G6gzrvziv/qN09ld/gm+l/rz74W0EX9Q
IcCFebzoqp227ZnjzwheGeL8Wn5wL67rT3/4XRhMMR4Vzu16ZG9BK/SZGs3kEmioGWL1dKylvnP+ycQK
iGNsORK7KhmnEV9oE1pshVqtosYe7e7BgUdDp4vjvhg2x768kYMWvALNTjImzqcka76QUmcCUQQ9N80Y
kMsoa+JRS6Ku7RfoYUtfUJeO5Oocroegk7VKwzmMeWA5EzkYz40youv8IwVe0Rw4W5+o2EuWprMwyDQ2
sIHecLQplYpJoGb4BoRclxTq1a5c6KHA3Sbn2h2QORqTgrePOXBEOxGzoVRXoM0QjdkgmFHj7JmsWBdL
P898RwUqjOySJbexHTCo+MaqVMKs90gfyDdz7fgN44QtjKRQ73ZWQ19rBU0FDmPbMgtjtJXqUlBYh2Af
NegdGA3RxcCI/pE306SVJ2p+v8IBwpmiPbtbeVsnhVIfTiXEKFSDxHd6YC1zZCxdQZZoCnhSeaDirk/p
iiQgbJnO+XC9J4FZwC6ERWVlyuKkaB6mrqotkzq+PeuPxoEZXSq+vjP7UWK5sYlSuLc7vsgqA5OPzzF4
FmUckGHIw2niA1Uiz1pHJUC7cgBVFACroCmg31eepBvB+NImFaei714gpqwKV/EBHJgYA/JvWo0OvGFl
ixyHhgJjKhGOLv0qI5FtZmFA7BsUm9vYaklblst6ijobf3QlpryuCLalt6SHtjEgc0Y5xNl19OUw+TII
KM9Iz1sLC1IqjFL6y+l/vzhVdvEEZCN3nllZbEGE5ganoglIiyxijay0CGGvBjkuHe6JCAeVRlklwTPY
EPdw4M0tM1NSqMLsTLQFW14q+anvMNSDdg9/u2RGpeJHUdc/1+r4iodiomIqyPpC6N76kFTrowXZh3Nz
apr+BNYW+LGAH9jFrZKTfFrSsVlBlf6oNmjYB3Ww+mnhi1VZ+MsqDWtR3bChfU+2oF21nVYpOH3FmX47
q+n/v5vVgZ/VgRl6TxKFfGGwua/mdRp/mtdJLPM6jWlgxRqYzp7o/yHoxY2smtelntdO3k/sh4RJYYAr
M4CpJSkFgU1uL1V0839OP/JxCcQtT6xKKjyekdKbm5GKmpGYOUz26tOEZK5kQrKIyJ1dwdLVj3NkONrF
9S04zh7ptmuzYiZA/w4jdqPg8BhnDcbfyUZxiuFoDpLQ1M+Bk4Tac5OBQBVsrt35fPFJGFrJoZW5JF5H
0lznlZNEvmWMsKFN2sYzJCPPzPpSf+udv7VNcw2AUTqMFxzpczgOD71Nh32S7SaH62kuIsmVMuGOoqSu
gBOml/g0h7vAOzxNs8AyoxYlLfYypT8tguHkbmny7MMIhgOHR2WjvMCXFPp0UXZXvicXe3SxkoC5tYOG
n8IbQJ4/D92FF6R5kWA5Gujaf5IlnTUI6c0Q/roW1j3VJRoBGfUKb54n5PH3adgs9vYI8xRdFwrGH6qt
QVG8AaoqVsessFe4IOzd3sP4exR0yGkwAFKUb/Im+YIGxgm6Ko3Fvzl2x6qF7TAOzjyE5jtn8de7CdwW
BM68KmeTVZVB/PPovcKPIZ8T9bf43Xf78vuZFxFEw1iJSzHpiCh3T5s+a6nMVC8am11Rr+Ezr2E/GtF8
l6K1CdTdFt8tk2GtEVxUzt7NVXC3VF0bH1yuUw110ZVlRikKYEaqdmnz05/j2AU7gfsgPpxsps2ksMdQ
nPyMoNuvnhHeRSvv+byeo5KnM1BqBVPJ4R1VYCL06nMz250l6PZOFfKfiTaABKF+2Srx/A72F4TC0pPX
J0S+K9PWs/f/nDxA+2Rd9uTR3pT9566YQrJqGduZor/PZKOMPhxEFGyLLnDMytFLNLkqapWukPWtvhfZ
kgRPNqfAcN5RTlmb2hdF3bUD3V0vVc9bC/7xqVSlAMdw6M+LewT6DhfaRyxP/OyGPGIo7JUKHG6OuXUk
VuOom4ur3Q1vUD7WWA/sjXZSCxjJjQ93vHXAObtOR6xSFLOlkDHbKCiW/7woaa9PJOoTEU5VF+KwSVlP
TvHvKvRHm0wq2+5ZewvP3Ec+YjVjmNjWBoO9YHD8YN9xNe+s2+qXBkylX78jqb2xNj3z2x1Z7n3akSrg
QO3F3MuZvRiypRj7Jk2lNtvBxc3UbI5N53YocdQFc77YXTKACtkhcje0lhcTyo5H9jhjimx72t4hoCKC
1x4vBuLCoT5xQEkM0awi2HUbQPo0t3APB0su0hAUXg9f6EbEUHtRfMGmldb++KHpIxViiGjJB1EsZoZm
9vghGACHaGlQiS8KDk758F4jqOCva++JgHjjMVqQJkph/FV6Gp7k6hdPJ1NAr9SIYcQvh9m7olfiq9+/
ckXhCvVKHysGTKQGhTjd0PuNu0FZ6eBlFR3U5BBDTPlHx+Fuo1ykTewdDCh/aXwIiUq7iqasusHw2+Lm
RFLt+RJM+oX5+RcoNbVJFvRnb7gdTb36y1Vfx0omfJic3m6Hyf6zr7AOwSiHILUrutpofvk+rrziX4gv
H2v48O9omm9AjR80oT9pQj/uep1Q6c3/bkL3/w8mlPo4fvYjHv1qxPTPWpJh/nye6B/Y2CoItvmJuRoZ
mqyxecbfdxd7xZm6xX8zXUL0Ptz8y3lCYyvTu/vtDPGhOjbo8gRdnqLLE3NHWdFeQ/4f6/KUuzxDl+fo
8szclXSXh/9jXZ5zlxfo8hJdXpi71OCLEJb/hS4vucsrdHmNLq/M3Zb+Xxvq8uZwp3549hl/32w0l53+
wWCOfFmTvx0Mwtv+ZDA4N7dcd2uHLu/R5Z256Wm4ifn/WJf33OWMIej3LLqcMbcD3eWldJksrv83JAOp
/E+6DEtB1kxZmqMu59DlC3M70l1e/59T+d91OcddzoPKC+hy3txNdJe3/2Mbs8Abs4guX6LLRXM3013e
/491+ZK7XAJhlNHlkrld6C5n/8cIo8yEkUKX0+hyytyudJdz/2NdTnOXO5a63EXqfsfebnSXC/9jXe5y
RcIeutxHl3v2dncEA/Q/1uU+d3lgafsN0eWBvcvoLpf/x7bf0LKMhy5P0eWJvbvQXU7/J132WvWX/RB7
xNRbNQ8CEN9nh0rJdNRwvhq5N7xMeUwzjGmOMc3sXV6PSRCDfzMmPwz89QeqCOlSc44vHlYwlkwtLg4l
GqIqkHnXHC0RS97hDsaCvfkngm8/hruviriXOKlUPkLeAKNOrvD3Gn/n8XcBf3dgSeuSjpsFTuAojvcw
A7QC7xzRMSVwj1waKSCTOA1Qbgwg53HabNgaEaQn3pQBBFRbSyExICQDc/V75t1/Irfxn4CJZZx8wvnS
6d/oBb/TK+8ahT0M6JjBRdo7Yx7miO61HHS06PrQCBpe/IMsKWwmIjOkRPeRh/oHd4HuXKaxlFhmhqMN
Uis2Nk83XFnPa3acmMSVUoIO13TmnuAKpUnSi925N3BL5Foa1iTOEnjkjFm6XFKjaSUWEFWWP2DsJN4K
uICAGU7ZlDrBrrFuyqriKugiW3J+cKMcUELXq+qjVb9RnBkvGH9qapaUgoqkPVhOGMYs6WV0hKAkd1pu
Dek3ZNo3N8hrCUJ9+OL1a9XRVz0712IupGmedzzsCkCs7Z002yBo0wahjsSOdCo+hjFGDCNTSC4tkGZR
cE29aKheTA4fePVETpfuxegu/ZHsds6Y1m0duEM7ydBBNBvCUW0449TJxH1Bb1HibnDzoNb6OplxKxFW
DXgT8SZXlmVwD48vyiXAHMe08Zrj+uo7Ff7KxMp+A3oWBqCIo8cac/XcyLlgEZ1YjZFh11iqRybuEXsT
fXMJLvjC9/OrIxFqtDABGWgPSsqik2TAUd4r1zMa+6PDKkv2thMmc4vCksROo6D6tOIm8Plrmc8//fzs
zz+/Pv08hWpW41108vGJxMP8NW0eKOT7EMy99uR6UFc92EdHHbihDrT4o7tOqNlF3iQHp+zqPXeeQ24z
oTDfRlI6hJ3NiFeeIjV8ZW45piptFWfljVcNthYWvwzFtTlfDln7xyGdrTXq0y58OQsNhTRnJAkEwFOT
o01M7OmyZxvCyMqOkYU0Lfvw6p84KIbftTMlPG6eQ2tWaH796+Z7ZZsUo0LfL1H6sBc9xkrb7/j2yctm
XxYal6ux5F83dFWC++1PpjeamD7jheD19x4/+0MdOsPG5zNnw8s2+aNj5cDbpVkWebggV9FFDFcQRdCP
Kgdmu4hulgU1c53USdw5l/6QwyHypUYjxA5UE9gfjkSB63IZ3X57DzJRReXY3R81Gu3RqISqsPhhpX0g
QgWXRuWfwG3BaTMBuxFmAoKP2BaSk0JqhrEVEcplcbyFyMixK+4b8j9skVY8BDqRXaAZSELZ6PuBPXcq
t81zmFeYienfzESAeBtLT3OHWGaipy2eDvG0lXnD0xE9XSFIwIh958zRoiJi7TAlEU8JHGHdys23j2BR
CXtq/RSmLDqd/eVMV8/O9MR+FiKELrAviMcvKy/fnoNM5UqBXndV4mZrMvCJDR+WZ8omOT5LJSprTFF8
twzeZO9TndBHOjws0yqofpL2h03A/DaBHkmQMXAkVl3oO0t4zPX4sE7hWhrZowt7JO6Nb1U8eY9jNJPS
BD7uSUBZNhCqGWSMRLIQLIHdzQyv3Uj//PYJwMZWlgw7jhfrC0xXCH83T0MX5XXhh4EDlsNls1S09TkY
Va8GW3PkUqwCoJSl3HiOy656sY3ZAdJS02AxM03P+v9e8I1J8CWZoq/q/LFMMZv+EafCCuLce2AZhFzc
F2nJBIl8uscXtJiUW01LFu7hjYcUvN8vJ/i6M0YQSJJHEnHq7eTb16df7hlXMWZkQGEcASMfnt598WEn
Mh41wKMem+QrtoZgiZDEKctrMU+roc7SftuRsSHqQTgAEHpUk49fztWhXJTEif7WHWRByR8GFZDKdW9r
T/pdIxEzDtw+Cv6g8yF3Hlz44dedf/yvdb5OHYVgXmWpuNQ9knUGiazznZ7uiOCy99La1Ew48Hxp8wxn
EiRwcfYeLfZaX0lsM6iZIq714aSm0ulVByhYI9jA2CWJcBGM7+P5p5Q7kpNGLGLT4XgdOKLKMkb+uEr5
pYv4enVcMayFFI9bXqnhD0fVtM+juPPB+zwKKshpi69O932NrtfjAUaCslp1eHyvqYE6Fx66humnPuEg
voirTjW1RvN3zKLT9Q7b+t8oyNi7AlRVPWENwtSbXq9Ep8AwOQhq8euDjBm4pehG+x2cO3BMvGM425z1
awlXG3bBOCUkqJcMilYAhqjKd0b6a1BMfD04Uv/uQHTPXOtJZp/jg0hFClHLhMOTWJMbdxWTHnV9BsmI
+5JUX5dJV7VvoWLa8R9P+qSsFJzTCd8qxRYP/Nj5L70yHsW+4Jt7zXBgOlZhxfWr1sl5a5NIoDcPsi5o
e0dtuAY6Rppj5SXD7XGyPQOMXCb7mt7jaTrw9EZwRRpRoyu15GnwP5Xifi80YhMLS5LxGrEtpUpryCVE
e2Zsp2sl3hNvsLXSSvj2Ya2vUIKU/mmg1HKcFszVFAoD4K2dKfJy7NVXh9LuEvndEbGhytORfp5ycg4C
acIgeWVaO5D9VyjeE1mX747sfWxRDZlLsToZ1ywrjPIqfi7lc0vFArHnHBbRIvnaCpoeZ1y+ibTGY+Fm
nsqeApVcXfTq05FplZpZY8O0Ln08dnPtYaBeJ67AhtS2Z1SMO5qM5uBOuTcVgAFnswiAFX1ECuBNut7k
1syqwm2vO45pe2MmN+aVSyTAEWcJBcMHGn1O9DMORQ/2LIzjeJXjEapYhbqFyhlPfCDN0ubMISPV2rEX
o3i2dqncYkhZn3uJCPI+wydTmw0JJ8atb+5An3/VwF0mOdpgcYRRkZqiP1VbAIguhxDjlzHVyO7cXOkq
Dws/72hKIGLOiZ/1RPKkfReT7bcmiOtbeyK+bkAPz+hhlydHUCsdfKR9++YOqe3P/1Cg/YszCrvEwubs
tBXhR4zfCREzHnes2/ivnr+OOu5Asw3EKsb0yBWLU9vdGYWE+4YR8jA4DJCpUnQ3TCsf25zPDbDkGAn4
9ZUcDIWyr93wQNwRpj0KuqswtZVKR0bnorMidWD8Z0QNqj9bRf1ZSQULxT7GBxh4KnYdjtygpCXP/ZZ7
oGFWHtx53hZL3j1v3MTcjEFfU1x4K9rTGt8hV/pZoGyYLzTZAHKLYNxbPJw3DE0o9QdlQfhLyV/f6QR/
bvIhGH9aJOKZZ98Lr9hcjZ9HrxACIYd4I0gdOh9BUWAzdkNlHUZUe/pLY+GR6NnmXdkKqreAUqo1D6w+
dlLoFUmhdSeFXhM9N77Pl2el0NnSSaE3XgptUQztI06553USyU9rVqSvvFDb77enNu40i9Y9SXA9NUNO
HAEtGPcPAtjaYn66NyTrpG6HUuP3B1xiyi/lS2q18KeE9k0V7FKAlgSsJlj1lN9IWARNau3YkWV/Mmdg
zu2v10BJjW6YEQ/X6sNjmpU7J0ebK0xq05LpfaD7jdeYDuf3A5XYTQgGyBhkGmz8WPX4HOpPvQdtBA/a
VQ9Fh8KYyvM95soqhWkzPXGhzbULDbVeqCFxoZU25sRuW37H3FzwLwxavHJkp4ke+2udZ8LG30TROqhv
UDNySry65A8M2fWmbP8n6tnG0UCGV+nlTIICoiKrlbQIUsWZXxqWdrC57CUnWct9OzSXrOUHm9cTyYef
30Ky5LvRmGOst1TG9QcxqNoNIaWZOxLUjhZUFeu3V9+UQ8t3vHqUtQMpFKvMbDxK6qtbCQQ99YeJJwxI
4VVlO6h89YlrT338iVjQWyKyIR17zmp/3Ei2meTFJo04IXHYNf4EL4oYQoRArDUM1IgLR0KtffTCS+f4
OMk4SsjbLOdfIxw4quSF9ro5v+4DtY4i37IMPDUdNrwG86Mij/7xHacHQRy+xRchg/E59TCHhIGFafXY
PYc0ZLjfg8zzmdljfpCktEu6muwclkUmSSoO7Y8shxGPKbRedkYecp6mkbpST8C4k7zCLB/gLEsw/QRH
61ahJaju9BdlHPqT1+W1+mSmF37VHDkhPQjAjeOtFcoGrw70Z/afBvYXX2mqr9wefyVmJ9bQaHJ5FmoR
mBIk3nEIzdRcHe7uwmtdulelVTWmArrMm41ZNAEkdG4/22WjoMu2xG7IQQOHS88TaG2wqEQDI80FaQCE
cVW1COd9BbbiaKLNyYwAHaWsYs9H8tyorVoTIEc2cwA4GafQnqTepyAV3kx64XEmSVKEQYjEMWQuUe4Z
spXEq8akp2BTvyXVc8UJ2G3TM+wFpM/bivfo6UPE8WrAf6ThJZtF3xWo0Ew5kvAn4zvjTwZw9jqWriPi
gCdtMpLcp5GcwE/uFW+i/OPzsBiWygGRjTeboHjTCrMXNs4kejnhluATsAd32OTbFScJ+I64oxgym+vY
DLjMruCNstt4a4mLlNgXWYaNFOiAiRxDPRYXSeRdJGS1Yh8DWAocAhHLaXtkQV5jrloFc5TJcg+1ax79
oDS9yj0xaLcQ7T9fBxyuUocQWzjecxUeYMixYaonmhR28szZJ1Sa1nGosx4OAq7kNJBV3a58hEQz0/GG
FvjTYzfCG5wQ/crPAxPPVO5SeoS+9CR8Lz/Q/r0ng7ajg2svlxTMeQ95ynIeKm/BCZQbKV/CW2Tuw1+A
nVrBimQrV+RArN5ldPaD9qYOUn76iTIZSiJodns+bO8PrSRcdK85fnQvVvEgSKvNT9/zxkpNvHUvzCub
yRXJo2J9IxDoNjkqxY7F+n23+nKYok31ZqHBCVVcnPW9qn1Lzj/O/pRIgL8bG9TEIb/ZmyqU9bmauid+
waf8zsxg6lWy5jLlu6XsRZLol7cpVTG4MU45Rhs888NAQeGz/dJPVLsn31jzVBFxHs6YjTS25atZcTHP
5LLMK4I4eGLBzbfVNUn6ndrtTs9sxU/KVA3iSQhH6Y/DfzO7f0s5MmKeihVw5NiUe4aMIj03JD7ZnTmZ
BD5CMQk4rLpkiXwONrXryfhYL42gyggsXMCO4ShxbTsxokp+V86ciri8afBZEYlQuDpBhIDdrRuqGKlq
givxreod1NXEsMIyFftAIGOGFSlyNeyFKt+eGz5cEjFfQq48RBuf/eEZUfKaR9IQDFGLLLKQSSFI9+gV
iWZJ9by4/uToAcYrlVEn9S/OLv7RvJa9HtAG2l78zZ4vx5MScxH3RqZmZRXmHnvRgJRhs2xIm/VBms8K
8eQpzQ0xspg8wLbNIZcABlLTw6Cv9JKtt4BTCR4f0IYohAogMxpcV61ZJkH4jpjIIw1ue1DoXoPO1VWq
eywyVZfKU97BaS5ZyRuTKLjcS9ji7NUR3UmFicAxpNdjnehoeaFbRN76Lh+KvD/K1SIghOGNVp0cADST
VyNRuXjjhfffXAnGFOylt0QV3SvCgc9f3ae3x5sqBqaYGFh7X2hzIieNy9ZbQUcpr4S9XjIsJ++ht28u
YnCQMYnFlu2wp9M1ZEfSH06Y6PX7vqqih5cudn6FGK7qn/jIzZ+SuiqByg5JfbElFgWvtXEt2LWdF7wE
IlHdqu4fw3rX2W2yt7/cNgsh4+VAbZuR3jYILLTRgK0S81fPl3ZqCzSXfe/849vF6PyeYEcRl3sSDq/g
QjH3XHEZpWkw8Gsw6SbHKJIRUWkWHL3SZOhawAnc0UBvaVoLV5UDtxtcX6c3x2EoEjDGGkNn65YLNuDh
NXkMFtfXwad3aEpv/FYUr67biKhnB3dpXEhE0oR6/ngvHlhNU/ZiOkeP1ClQ9Yq1zYusOWudsKyEZLfn
TPHW8cMTNY4PSrCPA486NBbCpmUXUYrBqJa0hjHFaIW3eR4RkKb5qGgnw7dCCGdTWloz2EATLAlWobTw
xKOUiVjz0Bkh0ExUyE5DUi5ZQeZGQdLsVd5xjBWXFcBGuUEMx0OTRQRYz5bXZD5bNe6a54AO4lu/tC7G
W5b21i9tOlna+PdcQgKty2bguWtbTClCc/b+H+I907/iPYp6vTlWRbDNWJ9hcZKjFf0XRWS8xftZe85+
QaXhVl6AumZhChHhLamoCx72QvS0btQObaxubo5jQKpTdYLd+altnxxf663T3v7yAIv/6wdYMeVyAz6f
YCROo77m+uaawtua1+2zHOLej/XBgW/wWLdbTzv/3w8uunfjuqHtMW5Spf188/bheFxiW37043o6WcP9
34+LnZTOPllP7JN5X2n2vzj2UhJeczJ2GhNQNArNq3+egtnt9dPZNf3ux/58sqbZPx/7F7bZWI09/u+P
PfXFun9P1n1+S+teur19Pt7AY7WBX/wEvHLAiJuAnNrAR8UofzEDHeMSg+Tf4L823l7auh7q8b4la12+
vSIU11UrfD0e8F4N+M0P+N2lMPCAC//hgLX69t8e/MA7Oo8GTzF4NziF1i1KNencPb4fU7oU23WDI7QW
9veeHRBrZaIziiDAgjYk0rq4WP7gQHPWrpHCW7qEmVHcmRj3hckeeW2CHMKiZ/bTuBGgydh5LHsV/vhw
dX159/pE7ni6ca6vPs82S1NcRovN1DaZl3uaku4dpWUV766UFaTvw/cR2lngNehKZHSchJZcdJQu1HXY
tYejnAOwYfSPuxxReBwllVGgZ0Kh0/4vw6Qirjk4XZlzhpu8cnEfiXbHqa/fWM0mOWXlS4S5OCmyJu9W
yiKWnXlj0ju3i1UncSbkzC4sa3T1KYxqrXJBW/vYdemj9JK0wHXbIiYM8TyxvbhVaP22E/YOWQmzJChj
ovzU8nH0dWYWl0ru4rLosMxYrjmS6/m4s+YFv4mPPaDzUs+jzLoUHw+bk1AupuTZSSgXBlYrsdDuDHnX
UFEvDwrRge7aV7uuBn3oewMcF5ETOO+B/XYcrVtk2mOHWM4rS/YHZ7iuzWcnseAYjrt/a/sLpKhSj0vC
x9OhVzJjLkUAtvvA7yEfEJazKG36r3hlNPCvtCQjA0v5zu/QUrG1rVowI6Lm6Lbkkx9mRgp5zWX+F5/n
3/oQdFvKeN6CLL3mekijjoiBhQE+wK7GeHXpd1TPFBW7j4bc6Ypf+NXJh9deymgvJTRstYawBIFzZHpN
TRJB6bBuH6Qe/UNnyxq6F+ST63hJa1RHDBflcUGnvfpAhBtNRC1asH1kB4YhVSiG6A6Xjwh20vnegzMI
qAXuqtRpIDRGKd2grM225OwBPNkRMwpfbFmCAlNI7r4hza/FhJXGTHaNMvL2DHOGmXawfhlhyawBu5Z5
lcTWZUFDjQtVbXpmesqq+xVFOdP9TNaGVw3BAlWSMsOYKUXYzmVP08JaoeR9QeZCFpOTD0ytZ1BLOahm
C8+gnmQKpACmpDtwWxyIMlcMSgEd5BRFSlUAkp2uYVAIwXD6cDyyVHHZfvz2HqQeaoOesvSulaW3vkh7
BwmnWG150n8os1ysygg4N/Gb08aD+d74CAX8I2a9PzLEkbWdZZbdOQEApdJxhNcDEcDOsTYK/br8SNik
HJdslrJAelHn0an1I75UJk7LMqYXLEF9DyXFwTRA7bsUbZHDhpueKzEyZed0Lbyk96vtQvx/ZvzbqA3S
Mz0tuX42BeZjR8Q96TUTIP97cULSOR9PHvWyOsJrrfLrqiXvE3rgRgXOPofusmP3LjXAEbSwBbgmoqxN
cJe5O+mu2hAZ0xlonstB/BkTSBgw9UQOXjzQnxO8Zxz05mZlenj6cImlVMhzFLvRmRtOoOzOTd8QCtoz
uxRwYwSr1uEWb0OOfuj3T6vJHyTd6AqOXK7DQetbPzyTn5n3ATpfmBlEIz73q0zvEW4CPze5lzdd3CxI
5gnWEJGV9Cj4TvLoIkyDGyNk1iKJqTH8cSYU5aRXN2QtnMxNONfpxvFKyp6MITBLZuUorS/KXiyA47ww
iedfPYlDRwpGM+0ZVT8cFC9bCD+CM3cEL/3cLZarevbcPT6HM2fvwWIqJeVGY01ZgjkubNsIGnDCtkEr
BmfPdyKV9MMeaWGd77azN8exfaIVsGQGFsF5MMw/3t3ksBnzM/ssm6/5J38h9A/3tuaM71GSgOqSNBSP
8C6z2a5nswclsrQVdjzQ3scLZmlsrK6L7jKFTeYa3rX81Clt1ieLcBz9reWd3ggemHkvz4Q1Pjre/for
3v3vxFIuPiNeSS6+3kpOFdtmL+HXfFbY+XL4S9/kQf/n56Z+4p526ih4Wg6cb1IOBHayiFmA+zx1x704
WdDdayUpNSgIxDq1J7w7UEfUXnDpSURY01CGnOHX/U6IuaVnSiQ8IkqxmY/umBCcQzmu/L8nylr4TxzU
q/3VeY/hNc1GI8xyJEKjKNlhKeAd3BR22EYLk1znkCsG9w9SuzPqjZSeldAG/t5M7YKX3k4Q+9UmgCWj
ccMcqkkHFUK/+Jz6qfYFBwb/fls8um3x+vW2eHPbomP+j/fFrOD8qzxL7eVv3I8Jde/1zljoncHp66jC
YfcsLZZwhD1dqAqFD/uBU6Dtz8XeyybN7UJCYmr0shdKVmbFAbq5qjt7PrhoqnhQJl4xqUDEpaIX8DVi
nDdqRzXP7ijAl2FD3dIMzA35vsvP9NnND67NpepLRDL+0iiKOyhb8VqYKwNJkixUHkXg/p3x4bmFlCxr
kNe3QWAjdY6mrzyT34L+qj0f5PJG7dtrcENF+JokYt/SsdodR4wwlqnGKyx8z+wl17jz4FKqV+ggZJp5
porpWBzeuOBAyOe5D9J5WgvE/AXjos/eaYisePiB4DDdNLtmyoGtu9jRI2vSrs7H7CFrMoxaEWQv/Dbc
yWNtfqwY7hFdTY/pYOzV8WPttfkHp2gej75LiDDwxWahn8a1F2WfqCfffVts4aOcm+h78OunZCyMxa+Q
9znPjnJXq79rovZ06E/83VdneE/Sza9omevfg8935P3ANXJNvW18r6hPNV3Npm/We4bdGzfUueZR537z
xi19o3X0RkPekLpP9O8dtdv+3VP31NbD777+SG09/e6p79TW829HsgE9QP57oXZf/+aNN/rG+9EbbXmD
kwzh2PlB7X787qmf1FbH/O6xrqHWer99rm+ITCbHz73Lcy4UmyLTaSVm5ojSxOg+RxsLc0RrdaeBuobB
Fpbo2NXYZOAXleyGnA/tba69eZVDAfrgqC4tgJoTo3C+7dxsspu5kn4weXT8GkLGD7Xn7PTrZ/jMjMFv
D9wXplBhEWXVRerV1qTYBsVaJ/Xhjk/VNF/v3EsJmgjp282DPk9HThXCBu/8e3RdwiUj7slhkD8CIaYo
qM+Jedfe57586sNy4O1jkA5uAfm2y5kzJDlDHEXW3xqwhoJSRAFLNXsfmYbyusEWpgHYQN/HZ7486vse
tBfQdRPXQaQjeHSqPAAKb3EevlPPxjGj4V7FWRimDh0tRUH5Cqbw1FUcypH3EKwqU6ocR6w7pzj87Jh1
j2pzKdl5IUWV+grUrTXC9N45wn+KKeQDz031cxOEttNzk+bSpJKENnVkbOS7LTmAKix2xstrDq0vqNL5
FFIKhxBFm7SDaG16NYVD6+1eD0tv3OfYdY5YgUc13mGKyRwQN/dsWihRBmCLosDvRqb8xhRNaldrTItw
G02ZnffmWihuOPsHtYvN1OTncoK70HDS4cclyz6dldHnfCvZSCQBvdDLH8rQnRYjDbqHIPUk30n6uDiI
ww/g45EAPBxmSHQa9F+wLCR6xdnLXt1UtXLetgqTUlQWrwQUjJRFCPyWF26NbNtg64tKva+Q7kCgonUn
4ia5Iz+SbXLYJM8MAmY/GCmDpZ+g8+K09yO+7/GQ4yM+ERXMnGW+pfogl1jDP5SlbKMxQ9U4nzSnbLJt
7Qom8CFyNiqhGzv29Op7nKNKoQFqBsV9u/V4A63UU0LLRxW5UytPd0+FolMFeUdFfb/zAo6ujPP8kIu+
iZRl8jVd9kbqEYgtKao8UPlefZN9czN3YVZcqFOxrJ09CbfiWjW0g8iGhbycCMhc3nD8/AVRLJVvjNFP
xpZrRAVDn4n46rLcgvpGFQt/Y86FD7FMavtDr94ADGAZbezn/aU2cYKLT/+MZ/7ADRecUwNgArgsOdUq
xITUppyHgXYAgTsynEsTJJ8OQMrSk5YMeWA8HBgujNQ0DVQNQkD4TZH+ERe5ztT/kwWM/sMFDMTlt2Jt
WsiWszuitFmzo6S5YoYAJiZV6QKm3IPCnQdnCAG8Z+PpxPw1awi58PnMRQ1UqFhfhLi/QBjuaqDKn45/
JpuL/WMjip6zwmpHSjklqe6KvtMM1pILMfj/8fZmX40rS7/g+/dfNIu+D031Zp769HfX0mQjwBgwFEX1
ul3L2MKWB8mWPLJu/++dEb/IQcbU3vt859wHsJRKpXKIjDkic8fTocQOZPx04B6ksgmYGcg7YV46V/Yz
jJ6PLHnu+aeM45liI31dnP7QE+a9XkCy/gnVx0A0se70yL55w0ItHM/+m7xmdhQTjDcONwv4NLowI7eM
oIH1Csm0GMWaBP2muwS33NkrhGSwYvXHp23EwY7QSpeihrnQUjAFo0/gARqTg0/EWL4WKBpXv6LLq7pa
05gTCFw3VOkNl94SaJyppTtZC2W5+CxsVg7iljmxBDPlCizaps9QZsVzpFGixI5b4pJ4t546ebm3HfU9
mFRfyMnu1lDYI/eP75GfRE34q0fqhseTExfmbqxsVfdqP05PyOxQvzvKCLNfNY45DDl+Og8/ecKKa6li
f9xspbOexTQPRxd2R099WFbMMbLLnpUtwM0TvqhrNmIl2p0zRGrcCo5T20MckJj0rN1ZyxZBdScciyqe
aCou49AUQGhg9yQprRPB54KlwWlXLJ40zoOzvlXaj/3UPf0WGyTQSBOIF5l2zxA4w/a42IPdejZ2jzKX
cza9ow3X80ngHFnZ2pz9vk06VfrDVbClM+hhyZ3BJu5BwEDujaEVVCNqtMYeDuZwek7vE2KLzWDE5QUJ
e6RdW/uXMAqlCCP1+sPQOhud9B3vcwZd3pgf/hlt+QP17jLltx/6A5ftezxBrMbU1+XLNac4L/zlAxaL
FL8T55zS5jHUa7DW7124dk85Uq6Qnbd0UstENQahEHiOeE0M468uzRqeRt7lvUmKdeF/AAcghVQsQ/x7
Xe5nzhbpBT3cIhC7djx01K5jxyto7B/AmMLwd+ssWj/g1B4ho21OMXxdy/h5iPeBMcGEMy1aU+I4Zv6O
TkQmirwPHFd7EMZ0LDlLTBfHrueDAT/u+WHIsDeM4ibrJ79Na94I2shxFAsSHtc9USzmUkZJVQJvEvG3
Sil8VeAzrN2dkvV7VGuohTga+33/jPXOIodNHO+B3zERZ5By9RHL+/DTOhcElDMeBApBrP8iKgfOiZmL
ubtUxw5wXciHYLrLA/nQROyB8iGmVAo340PM5kXekfh3QI0xObasyNjBqo1vFbw2gIY7ZQ33Qy40/sBh
FuQQd/ZK+6krB0LU2weSi+T0wv3cvpMRlCgXh2qH3vQIlR/dZPEPxGqSzsE555ZHifhlOiUamd+980OL
nOQUCF4MYcZ5TAN7snXPP1sHJlTh5RynQ7OZ6jL4uit0/akrsFYUDKn3SytNvXjDE7vP10hRYY6xf9BH
x66D9b3VjSBgmoOkvb3wAxaChNgHSqBFSwkm/YKjI7yPEzu15dcrORFTgQzsiyU0knekoReem6eC2pix
vDa7Po6XaG48Z0DhuMQG2ykaVOtu7FLN/U3+UaDrCI00hs5yFAJq0jBztZyQvrmumQl1wvHZliUxad7v
gFQSEVyASoMMzMMjfE4f/nGMWz7/A8GrDV5PwGjwxS6ajkMD18IPHGL1ti6VVGcMdk/863O8gOHWO5r6
djrPGNy2zGd/vH0+xxhi42Dkf55QadqZ0HTi/xtmdAyuQM9ohtu/OaPl5xk9/s2Mlp9mlKr/03slPwq2
T8yDTMz6TybmgxFXGrpnLIMIcENgPYZwCR+xkA7Ji/fWKuDzBI7H/gfJQMuJIkbpmLlj0Uau/k3UaPLv
p0bxcu24USUOUI+2APVvF+PvQul6hD12eOEe/r6vM5YE+nyHEuvCEYchQ2ycGbqwFZ6WDvgFniTj3AbW
SwesH3P6wGpCU9n0xoozq1gCDv9Nazz7X7DGB+4apy7mmmwucvYni9zccJX6apHBnfbCA1nkY2eRh7LI
oOGIqj/AIrMjLhI0xMXvF/mgssj7Xy/ygbvIrIjLlKRAi3yxucin/9wif2NW5fjAkcnYuCRCjjlbPIjE
02u2Tdc09ReG/caa12tntT/XP2sZ5cPv2+PxH0zfvSWOLEYHzkX9VHfSFVdamflriI6E3DpmEkfC0yHj
ZQalpi8rrb3mwUU9GP5x6aQk3MiRsfL76+A3vWX+5lXiHfDVgDVSe76mUzmJnDWiQjeH/uAw+AcVVvRn
ju37SDwFl1Y1k0HTeTn1J8Tv5KUChgMWMsTb4PKfhgYoLgfhmAf82hdnlnRIOTYge0WDEJp08e/3KDih
7UU/TzMr87XWEAd587Gl6QD77lBL+noGYT+5+XBfPtp8+Qgv65y/5mVWJkTeae8vWDs0nJz7xcs/BUmn
q9+t+yfIEkq8D2Xl4OFPACv4K4ClOjR4sDAU1gFDE3+TI++J1CmWu01kiUxTTTlCv06QAYoStgmB9YPs
4Z9nera0OrZMSexJ239XiqweWvggFPARS8zYl99hnvDQn9LTSUmY6cEbt68RdJO1yTMnb19TGxO+meKm
aFOuz7LN5wHM2jfqc/M2a1UXbWp3FjFl35v68XIYYnDcUa3j3J/C3fno3I9XOC0n/aRnfRaMuXZGmmdW
C/kyYZC15q3gI9q0K7UUXVS3tet/3Hj14CD62/aJz7s+KAJrd4CsO7eGuee+k3P1eSJaME4DbyM5eGXG
QQ8merZ83/BiUHG4EncYUMwQnUOyu3GE3mWs71tH0rsPvt2LhDvY59NaxuAOQm6nxkjkioEqHHJ1bun4
HAuxvPDjk544Rj17qwufyfZaFWsVzqv3cYHzVw9UaSJr1laMnaylKn3RDRxLA8tREJ/waUTaaPZg1NlK
uMLiSdJ2YXFo3UGGSt7KGHEvYpslj2ziAIQ4WXOd1mFsMOGJD6+AU9HconWtuwWZQDDFlBGDV4gC4Bs7
lEUlkE/LHFzm6u6fA7OUbL8NstAziz713WsaulaMD5zD6l7SwihASDlR18oJoO2UQ1tmtRUyxXjDO5OI
UnEzvHcL8F7B1HFYe65DP0MT6TOaP+T/a872CjhR3K806oTbDn2ugPjRM7/SZmTapHM3Ip4qMhpxHm0w
7FeMX47DAsnn1i3dW0mzXdApIdBmDP3BEaxodNRw7EVIpUw43+Ljb+xJzuVT34x8zOVwnPQUyp768oCV
JuQlTw8uH40UbqNSKC8XPXSP3NSPEMYYffkkcDumH0nvbnkkJHa2+2LMzChT8/cT4v1ei2gKjVx7MbDk
qjkVXgCAT7zNT3bOaRcRasPcOLgg16IIDjkwnowRMscnMCFU5DB3fXZbrovrkLX1vA+DWokNKB/FgU7t
wnH4fR0yy89xUox3yVDwWkP2BMcJOlkwZzb2kZF6feTOz/TekTqy7YT0wApCr+BwmKFlHOoef3eGjYSY
yTlD1oKJyRkQMI6K3MPW2+cna5YvgDL3gzVRy3FYROsDTKuOHy/TwHV7oaTEePJ2ys7LB8y0ZaGY3LAo
5O48CUsazlSV8a6A2zWrI5+sKi8+9i8lOXDg7LByaT1zAvGSEe2pXjFaAR1tdOA7+ebXTrjzwJ5TN/Ud
swKDRn0S2vDJpj1MmXOGwriBbD3sIVV3TOiNbe8F9CjsBWI+om3Jbeg8F+Sibk81rg4kchBAj9PDc4G7
vQLw0Nv32BXPVI30jw+RE4FZ/QofpVYzB0G1xHhvmwEvIv0Iv+yGOSKLfWVTnGDnRVvmhL94BYaV57KO
c588S/idTDw4qwhcruTehz9Qbtd36a8sK+ydYIFOhTpRv5k4TdAnxhR5cAjh8sKFkulGiAacp7xZ6ze4
7VnwVwVXFqvfkR2mWENUwVE5fNDPlySFMfR8aTXb8Ho68ftgZ3O7G6f+hYNBVpsYJJOM/cc2adHQ/+Dt
XseAhoc8JOc0ElpyBvNrM/i4y4srkPcsK2pnoI4sz16BBfndNMiw9n0L8B/y1tdzIXN36uhZ5Z3SBMXw
GSYP3uWR48CIuJZj3iwMjnOHE8rWlkHhUxVHwbEF34cje11HOVlGoWmDeilGto+LcagDFMkcDMnhw7cT
igrYZmOpAINf6I0zuwlezsGbiRvCDFPmKpetkxaGtqfeJqL+yc1pteEHQW5O4lAQ1Dy9c5moRZwLujHj
r3KwDc5MOzCrr1bjsGOWg9HlFeaOWU0cW+kzrlSsbYBwt6WE6pLr/74k8N/PnDwQw6HWFVtrMtNtEdYf
Undqju3U1GHG2xNj6/ph6+wHkkqM8WV06B+g1XYBvMWyZ43k0fqhfw7XvkYuQHWeh3w0AyUK8ZaQJ/Ad
7bmE74jzUqPUqUgjmUHGCtHsyOLghwN3NJK7zMal9XypjGTod1pVxII4BreUfUuQT6BV0fcEhJJCvbUD
8QzXVbReICLiEHjfGZv0CJsQe3HOZsGJ7+j2J7d84DFEodUo4O6enQTxmO3YxsqjV05aopgesF3aEdnj
BEnMIlE296h5wLb0Gvni1IPz0d/3fxvDSLewFJxXuD6DG8arneWGBugraMdniJR7qX2u4cGVf+6zg3d0
7I/h6L1qOXhs3jJ4LOIIXPbw6AXG+/uZUBHz/eWGVmjfX4IIT1rGTWIpuQWhzoGLK/O8j6wwvWJteMie
FOcnAbuon1wG8QLSf+6fNhw81+K8Wy0+nKpBasT5+79Ccv8QvHP0ANlhllkN7d7GGFfBHuj0Qc8JTj4W
/5ByxCFODAlQsR1ifPS/9qY7dXoJWCv3Aq3nyDeBbeAC2zMBFvlSHrS2D3j4ZAbczmyawbEeriRDFEXF
t2oOPd7H3jlqKvkr3MJ1RZBs4j7iOl178pGjKP0G9oKQ8LLSHDsiTP1D4KWvDAcS7K53dMXu/6wJ5YXF
N8jFR3r2GxLUQszflvf+4X1+L2hqXwUqu2NE+9z/vd1his6K3eG7o4QrjuyhKKVfHtl6kbeAoLGhn37e
cO7UK58F09KRs79b/Ie8Nk7Woz5OYGadco03Dyj3bC9gncZ6EMaFDnrwNnerA2AtDWAnXwDY391RpAKP
++zqGHorjlP1lnzCFlJoznzH7IfsT94S4Z6IF3483gtA7T6YdLO7w0uwDasBcpZsLTkLzutuY+cBtROR
8Zujo/pRT2I/PulO31/3anbw4uYq6B0hB9pZ0VuMLQJ+nePGZD/DfpGzjGEBI2+m6H46krTRZIvpT2wT
Dz25mfTtiZA9HzsI1lDoaB1CUlxv7DqrfvRexOVz5KQLz1sGkd5cPpq9zxAFsyP34QbB4Uy/vpNYU+Nt
k7B8pwDq4zeb40+U2nHfyrYPPTsqZIwDCm7YEHftH8HJ4+ImEo461LvFLO8/pbPnhx46EBkdM3rAzBuO
z/f5pDIoR9md6GMQwpd3HMZT8JpLPhlsMA6Zay8nYXwMhP4l92C00P94oJMAHZBb71tM2ggMfCe25zG8
bogs63k60rl7oESFnhBTygXwkgrOnba/pha8WKK0rIYRNYXmj/2+sF1bCeDZKNSskFhzcjZecHjZTYsV
7aLyvfzLPTr9OpJDvveGmeATXMQze5VvrP1huM033hnYx8xKIuEBhG3uPO+mO6gdeH7Br8wmIfiVWRif
NIBjp5mVyyghaLDwF4Wza/ecQeM4hIHA3cfAKjvWvLs+RCTSWYRwdtqi8+2vIOVvTOhLoJW9wLE4W/tJ
gVkdjhlTyucGYgf8PNdSj18+gOVcbKXHG3MdH4YXQOnjiZ3r9mBhBYgWZANedifflGoRjnvMF147q1AD
kWM3ZXbeJSg5ncH1dG8VxhcNmEi5R6Q5CDEvzv56Mb3kPTXZjDi7bP/VuY36wYEQacE7x4aV8tof0B25
hn4sso4UOeuzR/qbBvRg4l/qGJB39/i3V/1VL+uYxnLWZUD27YVT2IVwfLB3WPpbWA3yWuQ+9RxYPIRo
6ZKQ36wadTOE8zJ/6hpuxWCq2Kq7vwovidFaHobxWQORkViMhsll+SBL7pop9+yyNG1aMV6hUWR5lP4b
tFj0yrhnAY4F/2OxrpwPXNUqTd9IVDD/7l1EXm8v+sANBKCIkqZ1YFWhzZEkdpXqNNTGW/Fpz10z//Kg
nUDFuM3HC4vPOB30blpdXJt58w7rQtMiGoenFUc4ajnWmQdI7fCgeeJAmBHHVhwJKDTtmOeA6unIngyd
+4PjYGs3JgI0bLqk/9zrMGUVE9spn3hD84nuIaTDI/4+8+Srw5B7OsyiuIxAT48cOxlnWXsXSNLfZ8w9
yiIG2OE0ij8g6pT+uvLqjXtuAnj00TTC92ZRfFhIgM5B5a2GmzIU3O5oFjE9OFlG8aoQsr833iABqyoJ
+F0IsGLKtxHfltSZ+rIZISd5JR9+wpVfzYowbmBatQfl2zeNLJeYmYu9KD5FqJwT2Oy4bgij0nROgQlr
rNegmCE6Q4BzjF0RxhORntq/3MPxtONRLUZ2EI63y0Y1Xt6lKl6eySSRR8+babxN9izjvlQj5ite+IOp
sUKpjpyx/kEzHJ52UglrlALNMeAfVYNx5QTjKXhP1gbpxakGPha8uAh8nPgXdeMFM/TnTBZGFtDEYOIY
rV9FDHGdEhb2TKRWZk3Q8ElY1CxmO3dkrqlFTC+SQ1ZSNH4DD8muxTjiZC/5jFfo380am+JW78YAuZ6H
PUaO2qfRwaGfAqyDc/kSWOzXwtnmzz1j5w76vkSSum5D4z3bb1cquBxvaAr0wdUc3PTibfryrKxHWyWr
H9c7uDM9ZhmGQbk+8/fW1nkx9QcsiQyEKWb3ikOYqryjtgnbCiLh/bysZiwIqX/WNi9L/uZDCOOO19Pc
HNJ1jxSBSLPL2ftqnKSYVbphD1Zx5mT4WzVud+9d0kY+iDtF8EXI39wSSSZ4OtT2lSIwlPROuzKiXVm7
xf6Umbui25geXN/i0BB5cEsA2KB1NlS1vLEAu6gbgB37PUeHdOCXwEGgJL0AOTH64kKB5mMSI+A0CwFA
feeAMT3XUExvyrOl2GMdilzRmi+F6aHThW+MmiRwYoAWGxQrmoQHNp/082FNAwZkoWYOrT65VEU4DReY
ZwjqfVwDujVHAK0dw/xrH0vL4Lh0zjGevFfheeGkAmyIOHll4uSMzly1geuNPAttIiukqZoHq5o7frgM
O8f5xSv/9NK1AClcHfCYQ7Y8Pp51Iaaf2sjk5PjYmh9LX5DH8cAeoIQ9sA6OMPus1nmEboCvr0hDn9yU
PBsPlIPgXkyXH5nJPS5TsM7s/I3J3thgx5Tr+oDfjuntK3n7/EHndJGXzyxrQ2nZOWWyVz/8CRRAZgFk
+YL9buzv77lZR8Wj4bBmjrlH3pEr7wwczJ47K2ubATLdIISHznLyGELnpN86nh07Ed1krbolmFvwgXM1
ZFZhFy1c33EcBgKWZccwpd5rxGe+ZERhBNDUDAJz7gzGJ5y1GX5LZ4wi4Ke0ZkTAcUqBYyNNLb5w3JJO
/D1kgdHtHONWNwWzEv9nlydDplhpcUOuc1+imVc68LLlXd+rq5smUtZ6h1fqrdt7Vd6I87+YBwX445hZ
VGKfB8LwDjPOI/LEpUe+Ll7KwXB8zt0RVGyvmTzMM5ZZf8o7ZJShmvVjPwI/UEjFMiN+nGIRq0l7i76D
Z0omzpJ+AUgRXMFaI0UdVQakCNetE4sUi3AxEUbkm9bbRkXYo3mssftPvQiH/PCKb+MiZEGYbxoFvIZP
NlVLM+QTwtYQvJNv7sixc3YkJ/WpMezF9RFy+Lhvzw59uyU51VDp5BOisD6Qr7g+dl/ORAtU2WB5w2yw
z8aUsNol8f09NJs79Cyuxsms2upntyafGHOLNGFsaBn6x8Gi/1mNMe1p2StgL0PBxUzkVkbI9S4C5jDE
kyNzdIicEH+fzd1xPpbceBtrIfP0kduhPQ9zC+LMhdiMTJCPqOZEjiqs6NXkUFno00JWHIueQUGyOX0p
8G5i3m8sFkUryerin8NJCgrnJbQ4sxtryRtZ31MO7nhYvxsAR+31jTFq9MJt+l1mRgYsocVn58JnMSZD
LypJenni1lD3vJzLeIddQ3rfD8QFkc7CtypdZlQffq5yN+dz7hwz9zq0s+QynJIY1RLofpjqxKkE2RMR
1X5DJr85h/CAZAJ1lsF05PB74KX5+ubnouc4ca0h2L3fORQKIQFqgc4G6MCV+byiM3PfuEMMRFypwMTS
wkQG+48jVSt4mJm6U38jkUD3AE75n5YoIq1SPjX6uZB3WQHHXh3us5IVS/tOb/iwOerLh0/K6SM/mts8
nYJ6TnmLbayqmtlTeAM/7nHPB4TEVv6aPnLLs3x3annnkJ189xuMYaetuM9Jp3siiQnHHLim9r3zDe+Q
gb+FmDUImdHxb/VYEYAr8giPFXf5hcn+r1MA+uBxMBNfi8PEppzpiR5apqPLK72350QnrkYiolyZZHdP
Btgv/AHAHe5lzExcswIupDxhIQFp0WLt4MFLvBdBMb2uaCU+5SgzGorobyX8qIiNoFvmfJJvbMpcdD8j
tUy4ezpTpCnWcqYcIdIT0GLVTGKLwxfef9Of8f6FWASXG4NBFgxRdDwzr1TXG5WaKH4yZhoP/XgxFuUO
4MY6cHQEf5y45/D3HTblHJjsux1dgawSQ+j8H2iufoJ9YAiLdQKkj6+g6a8lQBrClfd1JCRlj8/eRjxI
tO/nwJnPmTzWOuYpq+6+zw/Feftcp5v+UiuNN4gG1miv1ffVO0jduw95Ze9OXFojmYIrUrHE+/70DFOQ
pVto2LJvsfMj1+vRf04Qf7PvS7JyfTp8Y9+fIGFwZ4SDS4ZNfTbxHddoyjuvGZ6Pm1rHec9z8qDmRKcc
zn0vejsvrDvzwzw0c96xq3K2sFDdPjixzAAO6z8VRmXfOYD5tZe6dt+6SSpC/xp954CaZ/Hm8VbD0PER
oBkCaeHjkyW20/NMlQPeHvBRGLPwl1k+gg0hrPyKn/5kXRkBygkGP/TIanzeCOgWd6/hXbrzdFTYiUoc
8D1xJmrwYScK1qxFsC4cuvxR2CmCHm/snHjZvsACXhbWjXzsDwGnWtvQP3W0Dcsgxe1qUyIOfmRnBnkE
tTG8eyMz2qkVYxveQIK9XOZwDYX42urbF9BO9TErD5U8FRM5YaAC6HMH0DmDBbvw3RAHqVemsYj04rF6
riEGjsi7CkVJQNlSTqD6fAeqOkVgwEIoSy7JmEfPpj9DfwTeaySzNn+wkwZfXBySW545mPN8Wl0dNfnr
2J17iTHiu7GVHli0vz+zSoKX+hjWCij+go+BBRJ2s/wwWreKaWn+qtcHHlI/+IMz38nuVbtAvA61lSnG
nknBhx+fn/rbw4ecjMmWE/huu+PqtWiNVmDnxXCb+h+lhV9GLKxALUQu/AvqtqYXGyXbNYnPN8HctUL+
17VsOKx8hpR++0dI6TeDXJAPmajJQRAzcTJdCkFZzS1GUH2aRlq9yQfFdeYICiOSHfUCuwhRL8QNs63D
iG84VUL91Rhx6mcsn10xIMY6OIJiUcT9iYC+ErUye9LbQIJWpk4AKwwulDLu+pxxTmjOEolrcvo1ttSl
43NqvIKCuz2nscb+tjr1O9YH9JhwwnG53c+3VIz4+OUI06OdYw8dDVdThGuGFclpZ41+laD7QenIk68G
GbQNqgJMR4tgDuSJEA3ffqwdmqr4VBoWaHSA/pWlHTliht7My71gxc0G/eBA0P3KxgGUCt0CuADvQ4ci
pP7lvsPgrf0cAMs0AEmoavvEXD1HRFrgPF/JlDL6YujfrNFp/MMo7x8y3sd8cBHjlbrEDs8dClOZ2qzc
ENXPbYguNAtvA+gHvLVNav1wIbBBcKQ3x/O3vUBMHI8WYL3fwqvkIwly9h0PoaBmOKtZxkChsG2gKCF2
F06QoAXlS//E+VDPP93WQlMcNFNwi6QJqGf+qgd8r+SW1Go8eiDCkE3O4DYjHLFleIWnjslz5pKnHE4x
QRYyJxzCw/8wzGf44sjZEIytaHtDPqkfhmN+esVNNA7DQHfyjis0DxnD3PPjh8Owz7Uf+balbhlXP+G2
YO+sJyZeL4fhlFf9Bz97RTM/+aZ9GJ4yf/PGt53D8KwXGtt4LCf4ns+cWLdy5rJ0tM4Ns+NTVtoHIrsY
jO91QPW7YGyBGklrX8fJ/skXFTkooR8kzv4igRkBiTcjdIQD919PsJ/5UBkxKxyqIm2EP2Bts1AKVi/N
mS9ayAlXolO3kYysGubNxa6QQTQVpHdaWk4lh42CFQD166HM0rGuEXlPNAWv92uHXnZA+D44iUq9ayPN
WwcYj3fIj0Dx0mAtpXiBXJ4Jgqe+nn4nuyHObRIDPCQxzQ9ZrQVYnRtCQtcsV8dEX6/jE0EMpMns+bxl
sBbDYIJHELgPgtwZTSLP6KMx6xKuOAikTo1e3fScqi+nuOHADUIQtaucx4ZUiy27/18HDoilOOpFS8yR
2ZQRn85ydXFtZnDpi0PqSnNjiTZewoIFy+TKgYsTf4hvgVjygZPRJe8IIOeH3AlKb3OScSIUdT6fxJNz
sD8/l+S3jr/TjX6EnXLg4ytaF3rmfCYp7KSakVFT14cE+TeQCFiduJbXzr8eEwFJgw4hu/YWzj5+kH38
iPYthTjvbSgER47XrEhNgxBJWdiZbOpoGdsT6dDBqT3wV5jj8BAdgpcLUnMwuYoRIrl0TqgzeXSiEJxN
jXmslzFz1DWWHEo2TOjxNDPjFwXjMWP8G29e/n5iCcE1ytIQomDl31rOwKyaRiP68ifvr9RnynczcVHR
gUVFkaCiKsjV3MUhpqmkCYChrgpvh6XhY2JaqCvvAjZ8YRxOR/5vjXp1Zn5qW416h5glJ9x0sLIc40OK
m0cZtg1NdjziGNzFHGLCCRy/fDQBbgm1TmoO/HgXt1p3xyF7z/Xi2bHX8sBv2ADF7fSFp6piRB3hFaJf
UL8uQX5xYoPXixz015f8D9SnRdQ1fW1qBAgng38GAQb90JrXH77CfcFj6cTrfLXvg+upw6FWANc9KocZ
3z1/D+weeM8DJCjxZCMnK1hvGYOYl6nZZXgcAljobhUeheKm/1de3Q/kVVjvgat5gph/XDGTIR7+Zw1n
1a8BrASd70cdB9Z/2krR23pgR/8C5QVvFScNhGytPqcMooNEo4clDmIjj/Uo9w1gihVvqFi98B+q80pU
teO2BHQV1GE6HI41/lTtRIUYBXtnVizvLD5+b06HP8YZq0fORTvlCM3yBXYDZHwY1SwncOQveP6Xiqt1
1ie48A9qXDzyfzv3M0lkzHJk6kfzscUSn5056u82BctLPrYaMC658EUWOvTXhYRmsKxVOMqOl6nzGuSt
vUBAdh+7vyd9uPiwLiy5lqQm/lAQ2TSz57CZU1LYDrPg5tTK6aplZtVKub/C15Agcs8fls6GgD/NedAX
x/N5FjiJjtgcuBC+XL7P21jxUFIqn+ItFxX+TNpZZm7KNpgV5Y013mBsh7lB/HXpH6Nn2l5m4Kz+tgTd
wS65ZabzyMEOWzxsBCNveNjM/mseNjalw5H4OkPFtWTMyBiV/M6af8cq+AXkSxS3hfxkgGjad/FTGlhp
s8O4Iu4ecpIzz9m/HfofdMdjR6L/2MKG8JO1Dy7kiSRqsB9FMCVqMAw/Ipf4JkT7L69w+CpTjRFSWNzy
hriCQZHVwsUHshDs5UG82JNQMl6bbW5q6Yab2iTccLGfvNkF/RPH68nXYR/l9KtQhH1HB8AC2Ed45iSJ
aGVW4HKdxLhgzC5YJqn7s062AIiSkAaQXTVBpGXj8GE2WHrHzPnBKZ4xP2vO9vOA4eRoHcTzq83J4wQx
TsjZ/5rJW345eSKb/LOT96wnrxfQRH78VyfveI3JS4+CeO8KqDmvmP5sJoAi+MtT04++nJqDqRtOxFNz
9EkvYjEV2ltEVoawGR3qWhvg9SFkT+Z2/z3kjhnKjYXInEiahigVjZLMovKzAxuP/Tq7Mx0a27TwwM9I
7hftvX8TPxAvmYn2qNLGuqXbuD7hx+e0OjcmZ/ctZ4XoMVrg6R0cBYxID/aCeLYfuLr4LWjBUcAzZM/c
g2LiSkY29h5DQ0apv57opdC2GZxn41kqSe4voeOreEux9w/Bovz7ptcL19xyZJy3oixkpSEH2NTOIIJA
j8XTfsXq0DgLJ5Epu+aymyycRkbxpIjsYLTpnHTX8wGB44LCpRvsrn6XBpnoOks6Ja4Bn9SlfzF3Q/tO
Z1WhFkq7GUdJAasHWXjGuszauT2WUzzSFZF/5YdaJXEk+3YFNCEnoMvhqzBGXgR4A76POKYgOscxw/y9
aOlEt6b+auJMsLfXNy6ncX3fBoXWbvVb+HQErzhmTFg5oDrKGPInEtP0xLHufO50dCkdXYmlBB0FHu+5
HYVJdirTg9PEkDrqJW85fT91gCN4P3O0DMn5zJG4D56tx9zFgctAV0dP/0p/eS5q9tUxxl8RXxeW11hv
uMyNgh5UJMXYJi1b+pmjG3LOcAzBVrEzyDWzH60iPBEZ83RuW2ACoPjgMznz7Hzutv6Nc7ayNuBoLtoA
/hAkXrsLcWKjdoFZzBxGFePMI1HNfPHShGXX6FJ8FbbGmE6LUEsG2r/IRa1zB7WebY1JRgTGKrTHyvT8
mZjoHW+0ib8nzHB/7upFp3PNjlMHMF/93KYeuvBTIO5LzaGbPlgqQlSO/OZMF0RHSPanByUjHon6Z98x
65d+ObcMNmUy3uK+Nn0wsHMiRiNSoGkWWTv+noFPYjC8dvzHrhyn5cLHDRtf7/nTjwzL4Z4mbIF3uIdc
Fnv9MB71JCZ6WKHSr6wJbHFugmc6Ho/spidUUj+ntAaUNKtBGVMHH/5fwNYbfkZTRAQA9i/E8/bSIu9g
EcrxnMMf1h2C+imBNZqoDnNmW5x9ugzOf/ztN1eAKGLyg37tnA+F/3ufXjngdkDnM3mdA+CQLuEYxVJC
K4kIUEbJNV6da32CZECeKrzU6zSMhzEhzCM/3VyVc16VM14VlkUpZEytSp+A+Yr3Xpz9xVX5bU4ILMq5
kBLGfL9dFOEoR7+ZfSTKK5m3mgWj30yzd+7sIeSN/N184mRv3h7XJvXhRxoyGluPwziPAeR7I3c6G2RS
rUzVl4b+fOJY+o/8DLyrPhhL1BQm5oM5VpN64pMN8njqJnrsVM8yp87wGsS3+ZXtrE3peM19ZPthbTq0
DLvDWk8GVfZC7WWJHblMMNtM8iAaHCeGbPR81oaxnhFnTQD5PDEXGVrvvA9JnnA0CeNl3ZWRKPghxJw5
IuYP0x0JivuU3vcZvINwFezbud/+ixGYXT7CF1n5kQZR8vQS93wTnWF6+w3NO18P/QGkoBM+OTZGnoCX
2b6jcDb7RPxfIhrDHfOQV/BxhRzEPTueIKj9aBrG43052fZ44egZdOSwWnucvPShZu5efHrdhEkbrpHS
i9FHyNQ2V6/1br+U6N8sDGHeLpyU6O1zgOmbbKpAmORJdDQNCN0oaWDZEMfo+iQSMkuWgp7fx6wjC5gO
udjIzhxsdeth+aC+7WS8tw2IN9E8VHXtOCS94MhHST93llb2oh5HcBh9TCR1i5JPOGlwdBidoazNEgCP
7BAj6xAndMWi080hG/3q1/sTyag+DZ3Us4CfAcXC1Af+SqL+06njWLiVYXByRwpdxw6CM9BlaLd9h2A/
6l47HgPE+1xx8H6zHxWCMcpKv5yPDhYbO37f7904lsg+b66VcHk4EgkcyXzuaLYXYFYsQs/Njoj6/lKq
7r8g9xt7P0jut0vkftsTX8HzdyOotkfGn0UO+FsL71fMLJNzDVX3VFjN89LEwtSYMbhm9evLIBh1+dwA
0oi0TSedmcg2Z0JSZ+YLO3XJZGHFAEkwSQA9d5hSdy4CXql4KY+/GH+k0ypOVeu5b1jlAh/j/XvFLpyM
tZ8nlMWc5lNhDVv/yB3MZOroFr6xd/ZUUg6LCK2+9yaTMDlxwgsHLYPAJr68M+YUT4sAgYYLEcjpyVBX
kZS2K2FTS+dE7dSHkAWxyjucoIq70tIIlhpfGTn+Ca6+ac+iWgbEW1YEtD4CYXgOKpAeO2qjz5DOtETD
Me0E62bBJkE2+CLaOB4EZSHiW9d0/LMLoshuUT84FhK7sUj7iAvmbcWGuEkIt0cWh65IlXEWBgd/P9nd
5zSCB8FhcMGBeMhhznqloO9mVJWMlJJJFB6laCEPEFiuU4/QjE3k2HLv+MXxbd778SnZGEk6x8yEvMqh
uwz60c8hH+Lt3ZslmvoZC0OwcyIL8bK+ucsjelDbusuRhyD05DBb1idY6NxLXehEGfVgtHF6sBrGiRwT
6TCQKcPdQBhbA3fM215xAtebxpsp3kgOxpscjSIFnbiMVzsonTFR52vZpXcWZvb8yZUB9x9Mt3r+IFhf
MT47Xbox8LQSA03fKqsyCf7sGI+Rfzb6O/g1OPVPSmy6yxdjeTnwe6/VcUaykWruYR+V00f5QKa1P4tO
oJMFuDLjGRRfg2vx04IrctGJcofDz4NrMbH89gwRRHUwVHIC2vjwRM72pBXdE2yDjHzc6s+Viy3XkJq9
wSzcOJYDOwWnszuIuTy2ZJ7dpQtJwVW6qYIPHWPEs+ggOA+wCec7k1Sw+zg/2AT3ScZAxnU1xlytQ/L0
rqogvfYBTlY4sWrWIth3PECbZ9BG3gOuxKiNeQCAIfN3+ap3VvjSL133OjmcxZk6cAfIFrOZwTXEmUo8
7qZ3BhHvXwfbMyz0ZQ0LrYD353n4r1zGQWUZEYW5EKXlxDb6Mj2rrBvzuUAbvGQ35kil6lE6B5Zzvf9i
G418bmfPL9hL86F6csXH39hGZ1ej8OKnbaGhpxFs/8/A7k664rZivWnY/7X+U+vK3UpXBEzxT1ZDEdjc
8OXtqxIhmnx5T6XNmC+preYUYcADZMKVlZ0xHZPsxW/9QydStHXhsActMbCwJP40RRwIA/wT+88+/ywQ
AdLMV5Z9ey5WDl9bIsPcD7291PTSg++M0F4DBMX8pLfbP1OW695oDG0Fukwxf578dHqnLvvBU3rsjMY4
jlAUHpNNk8giIk1AGHPWEclgUR06Xw9F+iVldn/t6EaPVnaROUs+8Zg11ixELUK4tRt88NRBeHTFDl+3
R7wVw9sM+Zdvxvwb0joH14B15z/3S3JKwF8FOt4ygG3+ko9hk7Oq12GuOxrpdAZR5iaXynFzb0ae+1bm
eWnoJQkEl0A1PTu1+LHnzx0U+rDI7VwkUxvz3Bc7wtlRsKV5GBZurxWsPETWI6qDnN7utE1PjaGw7riy
NWmy45Z6P/V/0vWAnUCH/s+CsevNNTsAn9qj9Hke3zCCwgFlkNSfxp+2FE9YHVOGunKMYui4iYFsc4KH
6DzsmhYbrJS+k9NgQw1zcND/8eFsiIZ1f75p6Y7iTWR+WvD/G7S91fWYh8b6+eDcP7NmqebekVlnTfrw
6SskSztob4UJLb1NHL1L8xBblZ5HE3/o7OKh37Hb+9iJz099wAKoirjls5YRCVca6yNrlc1969nrRHBM
aNsGHCYjp0psq8YnTISmbaqAGT5eujr/k6XV+TNZjOPRdw1m+AjziUHb4RCCp1wURnRIftMQDR07xsP2
/nwzIDVmUFgt0kPvamtNBipEPrwxEzzE2oB9Z5UEkwKOjdeHb9gePF/pz2HG5ry5A8kYObN+Bi9H37/o
9klu5XAOI1kHt386witGvDfRnI0Z7Kp50y7pE7fkAnxz4o8czdsXg48kHCl18BV77kBuPfM5b9RPhsyO
l75YJsNZjcuvgLD+uHQOX39wNYHPRwv7kiwx/xh9Fp2MFOCk6vNlRYqhIwtKl8j9VXDIgz0HNT5PnDYs
MtBx0lRcG3A8wCNI6hWpJePbAZ9Of2NGOQpYobYODuFLyKxkI3/RMET6vJicAEm5OPTfZHcSSbTbn5Ng
gAbSNGkWfy1BZ7xpmog2VkvzbLw7SjF08d2H2Wn1V3r96idDyI+/+pW6fEVyFD5/Pqkcn7ij/fByM106
vl0yqhvi9XjoQOJjTdVWoJlw/L8BdxEy8h1yfeRtiG6ksxGpv9U9Qh0Hvo1JGzp+a6lvdTGKVFmXya1o
K/oueTjO19wXXpxegL7A2SWKCDuyf94dH74T3EmaxuMi1DYD9gbS8MhHWonVbh5cgELhbIAGuQI8AuDI
4FAjbrshR7FwhxjGRIVtONoIErSotj1ig/TH5v7e0upFKoeOzCbW7j31cxG8DyGC8lo81jjE7Qjpeaji
9dC3Z8QQITegCVvAFYLAGJRSJ44PZkwowUFtYnyuA1di5kzBjZxCIRi5vXEDvk94+gBb06A3d9qBcekk
lIboyTsBnkIU7Qr7EnwfOPSRRZqf9IEEICinFh3Ibj8EIOqjicBdnIrNCm/AxHbich6n4OvOrNt82ILX
GwTEYmm0JYHNeHGzXIYGr5QO4Pb8xdJaEtx8nh6nt4iilLv7QLUfO2jxlKfvgYjvfXwiK0z2uyYpb+/P
/AU2z5xsiU3OoHMnappRGjgYdC0hza/WMXoZuC+DV2wQJrmOISzTaTd1L6YvXR/4R8/YFM9UxjLLVbQn
LB7FiVrOdSl+QHhfxpsHbgPQytWZb4z3HEbRBlF5l98hibJzmqQ8hHTaD1h0vwAlOZ1vV3hd+GOtbueW
sGGXYaUpuNFy2qh4MjRMQBwNRc79qvWzjdbPDZb8Tptu7ueunk6+ibHzbln6uSMHR9EhTxpj8uj1ADc0
D836rNTLHngyN88HUnbqoKjvXd3R4OFMTnjmD4bApOcWIKIWua8RiEVTX5+mwxNSk7U4t8ny61T5iirX
p/7crXwllSelcciPWxeyhRiqrum1ITOeP4QK7bsMI8V/Bx9+TsI5JSpvUl60VDrPLdB5zTEdTybAyiO6
uqCViFcaKLk31/CtYBGNYxJu4wubVFGiY06fjdFdsepgDVz15UEVi3oNg2Ev4KXNUIRjI9m5RwNuBxJR
H7hryud8hN5pTaMTYO7GXBQ1p0BJ3KSOCrTCQBDpevsfgVFCeqfQWl+8aQ1mViMtxryW+Wb7NS6EaxaK
x19INcWziSKDCPDUP3Q+wBvEQuWWLxY3JIqcXomwv0+YSfHKmmPBLPOgnzVmJ4ckG8e/nDpKf2d52D8g
NNqyHts2eC7ja+77NcuiDxUd3dnEoOBrBnIa7XWPkNHLZXDGO/D1fOYI5uc25MzGM99D1+NtecS86Q9G
DK+XwRQeda/FLNxS96c8Xvpbn//k/d6+DHqo9tzfVuuNNWKdy2Au3zr8q92n/9zdLnc3uQxgqHpOHYq/
vQUIK9vGL3lxRXvOSO6de9jzLwNOE/Yy+gsdNKeRDdVrYx5Z+JDJ+NN5aOsDNunyYTL/Kw2D8WcsMWLe
cK4+Ia6P2ss3kPRJz6CC3//RYDtcpPecZcQm/oWkoSOKPLA8ZSvla0vop/4+BA9Ggky1r709CU7+6AUm
y/WcqQY8WzDFa9F9ny6MLeI77ZkOG4EIuj8mBq9H3lps8/8ybbLHXgMjH8euI0hJsaALNsq2T+wpexUN
5NscoWAcpc95NxT/PcL5z6QZvKLJV1zkIQkG19xozMrEayqIWWXH9CDuiZ7gGvv7xB9ghzNPGOfBCW5x
ol/K5CtawP3w3NUuUirNCZxTGYOyMB+wXNL3L4BBwbjy2mHoloPrVBDl3xRTGtBGsraGkHAtHG/nq1np
4f2APhVfd3rj6sj+JeyqTQBxtrIa89R3QkpdzpUjQR+0DxF4nnMhv4cBGDB1wxmtg9NwcGG3ZONorU1q
xlAW1I6c4LT2viN7V3RlzArsia5MO2Rw109WRpeHwdzwW7eYVjOr+ohqTMcwGIDQZjD8jcAgpm/2665G
luYn7Pkje+zcS8rXrJOV5OSOIuUrDQPP+wEAvobsh9PwbGVVwzwXIWVea7B+ONrSG60LdHvjRKlGMx8m
5ztrg3FsBF9puOjVH4iOuKT/T6TvPPCxZ7jDmIVItAmutRMJWvlYQYjXlzW7JI5yDRYcOpIxIscjrXwn
fvfVvHDrvEAfpxy79VukUv8XLTVVqWjkmRMT/PClWv7fAQQiY4zF6OMMff2nSxY8ErcrHl70/4rYqlbk
bYUa6BG+hpoJ5eYO4zXkG9qN4Ze7kQ0xod6N5P4Qea4v3l/ofNydX/ifzX6Hx9bsp6R4rTxSbGT4hRHw
IPQuP1u92UgbvR+Knzk5GpoMMXO/B32T9qRjYjUANt/nOHbEcB6LQXfj7SplhHvmGkGVOMeU2wOY9aIp
/ESJli3q7FTSr+NwrZtVbGbJcihGqVvjCKZ4FuAAgXZ/S+3g7azuWNbO65+r3C5J1GrMggUbNV9OxUR7
ckLI+o5VhM0ZnR5EHxEHLG/JLmD3vI4Ps4APEmvrxh+5uDUL2Kn3ifNBvM4C8Eepf+4IOc0VGKLesxuo
arwY+RR4JkntWZDjOM6hf/qnDTy7Dbwx09aZBcML8cMcf5J16z8zZ6J4Jkn9M/B5klP/mA4bp+lB3Ly3
NPkNBj4zBKkf58zt3EwkDQznlYJZOY/ANODRMkJYzorvTiQiByQXASDIvvENbiKcDMSqLlsffA22sW7C
7tm9KTj1zxz9eAf6XTZDHfkjiYBdPhme73UAfMgaJ86riazKjX5wIe303ZMKear7oq3oWQbeWwfI8MF+
7/W4eNIUO4hy9PTjhZzt2VKz9oeOOzI4NccJrQi2nVIHTQqTYTmHXB9Wx6sbIrdh3PsIjQ2yh3x5suPF
3C8hzM5BloprOMgt1yAHMLYm3G9uqHPwbNoxOdMxDXNpCdDWC6QlSAVdRlKOrNQRTzNekam8qs+pl1d1
7AaYP0QbsiWnxkqM85Cl8TsErTDXNvmABmq8jOL+IHQ9mjtbzgE72TgH7BQeQkfzQE48f1GUA8xl+KBa
iG4Z25Ct4qb45K1sEwGSn/lfTXIfwLGbjxwXUIRBcsWLbw+ThBPTsTglLSR7/JbTxkxmRW2c2PROC94D
i7kPJZXJV4fhHYtXn9sqTlFg1NY8N6eHylkYq7EV+/5KYttoEMD7onUgau3IOOkiD8wgEDfMtnjPeusr
3ddaXKqVH/swKnpvK8TY6oqecVVz3rlK5J062+xqKzHWRzgcld4b2GNm69GpCJ6LcOu5X2Zy4YvLlsMI
WZ9gRkxY1q7/6A8Ca679EJHG9bs6wgbgdk/84SBwUmmeOilpWjyrTwLOFIkRDSRT9FfLuGdPYgxiz0gR
2pk8ohUZil/2k/GBXvofmeUlggVXocn84fhorlCF+36FNWTkzSiuGY2l1coromIFjPOb9doFvCjcA4S+
8qAN+sGZJM92O3tYaRb8T09jS0opzslaHznJEPKKQ2HG6vlsGTHuyD+i+KAB5Dq4dewgz5yUrU4J4Giv
2/CwGvAaNXvzLmzUAfLlHzIcXfPRVONThLtGNtr6Wy/EFq/R2C/7SOdy5Q14e8NSJOjXy+nspjpTrA4g
ep976Y3b9NNluN8nZo6NlT9bR9T5V3r5B52soqG0efbgvM1S0pA6FjwNJV39hOxFYYsQXi3vYFFqlGEm
opiL6z7WCRF7FKsd30Eb6H10SFXc+JZ4N+EaLy5TQr23VhfMmrCad3wUuFrRBy2SO6FHgOilLUAoryMl
s7OE5HWqKFmNhJ/ayoPtze3Zgn1jjPKqzWlgMkfsG7rmaNEWW3v3RpOVRMdEM95pQyQvF4Syj9RaE2R/
0JqfiwsmqcXXAgT0AAddUAliiUifEBkBADIvbz5RwA8+MYMQgnsXNnr2804aOVl+Xi+F4QvYeZv7Ndvc
Rz+p6mRviu3kWRVlvj/1oz6dHz1RVzUpeSY0RgWEikr1yzskAMMp+2RqdXKeHNGy/1GpMbL29bm/uLKM
sTeMXJtHw3To5NQ5iDv8ln8nS+k/dr79x06Zz4tOUu78X//PTjvrzUft4o9BufM/1JOsPUb5Ms26+XLn
204378zHSTZTl/Osm7ynWdJV1+M0i4pCXaSlVxTt9W06TNRd/jbgshf9+ijJerO+usjybvK0niT8uDUr
0qxn31ZX73kRtTtUM50lRXuWU+OdPJslK/r2MFlz9do868zSPFM3/XbZXGb3RT5Jihk97bRHI/VT5sUs
6d4k6xLv0c9kXvblkf1WiytSs+qvSBZJUSb37aI9Lp1e1OhTi/ZoTj3PVGeeU35FzcWK5oTvumkvpYY7
/XYRqIF6dDPIU3rXjPW9yMeBVODZLPvpO1Usk9lVu+zf8BCpm7u7fXOvvphk/I2S6raLHi8Hd5FXpZzR
TE3aqvMxF6RZPym4O6oQK6caKdq8CPmEanRVccpztqtHx+NMy2dnjdMydK6bb4Okw+2Xd/PxW4LFD9sz
Gswsd5b0MelFK/rOKO+0ZbHao6SQsapeJoX6JteNRolAV4ZpoZ87BYXU/YJ7257xCFVPGPDaE16tcj7i
SRil5UyvR/OdZwgAxb+PyThfUFvlZJR2EgapyZohgbYATWtSztJMd7OctTvDln7Gd2HCH9hNVJe9cp11
6GbZnjGsZr2G3gjokrqQKekls6eUx2HmYyxvjdqlmgUAUNlXUJsvA+lW0REwYhBKpvP2iEaZH9K/I5pp
upodYR3adwDxVkK13zBDZTKieXin8XTmRbH2ih61UcoMqFEV5vPtyWS0xk5Ta8UreV3m2WMyGbU7vMZY
KRTzoiQzhpzrVvMO4KfWPX1fC4RLtYHUJrDk1/08HyVt3kwMGcuk6LRL0x/VxlObwCcxADGY3qY8k51R
ntFvMp7wlxOpdjUbjzAE7JA+7p+iH0+/7pphxIvC46AeFOsw6Sjgen6Mg3w8UU3yV7rbCrnbav99l30/
rFz+0uiAgApz5tRV7zJgMvzpwiTjrxTpwzwp1m5BK+nJeCedWcSlrUmbsLOpVO2bYOw440+/5flMLQFv
Cpm6EnNid9Y4785HvLcYu3/buav/8u7vfwW3Xqv16zGqRz/u5SngVl711zFN65S63FKNdxQ69BjFJquE
4VQBcimblXZp+jaf8QfwRbrq0sKbHqbZgFuhOePV3lV7fJHyxu8Uido4sa2RZouciUqp9iy27niS8kDa
WTrGLtvVANxtz9oYWhjVosdffrP51Hp69GhkM2xhmTnZq+PE7Zmmg5+fMO5smAGVWXuY/NKgm6jVFlrV
ulNiz6/Aa0V2Skdqr/AmmuQlw8ktwX2Al9XcKZyoNicDS4+71ca2MY8YK7c7nWQyY0LpZVk+08hK7VnV
yblMF965y4mWVOliz/SizaSY8EQte8pbMq9AR2obZrxTFMnGS77C38PIAhWh5lJv2Duga7Xz5IpoYyt9
G4EKKDw/n2DWbvN2lz+/q5ff4MzdXcNHvLfpyZpnYTpPC/6SGuF7ikkANNy2ZSQAG7ocJ7N+DpJME9Cw
t/SC2m+8AQGRziiLecbjs59BIc0PldNH5mo0ZT9SFLjIFPK/jwl7KS4B0z9XeEfjsE7pAFFD77fdW0UA
R8m97ayiF+bhbkuB8Sz9ICzgVNkNAOZOUVdNh+J6mJARkvOyTj8vQqc0zSbzmVugWJyxe192inRSqVHy
jq6UzNajxC3IJwRpbknW8xXwfC4hVPy59Elh7JFaseqTgLDGlqJokWRbipvd7mZp3h5uFCk+schHiseo
ltc2ZiHrXakprZbE7xv3WWc0/1RJrVS15C7PaIjtt9FG1fvRvGiP1LJWixVFVfitWtbq58uNks0lUEXL
VHEN28pe+psTJnWT97ZiRaqPmryWG/P+VLSzcstwFZAmG+t5q/isjUnvK3ivvCg7d2O9mAZuneNaOhrR
0in8Un3uaWLijdK27TMjoR7ByaxStosN0eoQDLhbyQOdcIv8Il8qPFHZcEoWSGrAP9WNqKHKLQ1FIHLL
ohVhaDW/V+2su1FfDXJWLWEGeJKPNnqm+WK37Go2m2ze+4opVWjXLb4VRrta1nNv74mlcQseFY1jCuAW
Prg3rU6ycRsqnNHb6HYrS9/fqwPU+54ntvJAMcT5vDJ1kBTdkt1Hr1a5Z647UGzymxq586SjOI+RENPW
fRTE3u2v4Mp7dHiaX4TF3t/LBGzaM6FseaPR/PnrygtubGUwnPfEpF8zn2akh25aTqj4qZ8SvL3zkhJl
LA15jd/vcs8Rzgp+9144fmITxuZNvigSBmTQyh2RjEQmSGa3Wm7u9NNRVz/gm4LpsxYe1Ubp9ZJCAE/X
Ma8PNMOZq3pKzhldT5mc7up7dX39IIy2amts5sEQaWaGiaK24rv6bfTryavbOXsv2pp/BQOnt0fNPrh6
atzaN2ZjJpXMtAfUV/Oq5VjpE3dew+GklmDG6KfBV7+6wHJM/DI1Aeoj6voHf6zSRayE/pSa+HKmb4jz
0dekuBgM9ATeCa9D6gdBUaafT6pMmB5Mldc19VEQiMTCkkulapi0FXdhbgFhIXhXFDXfSXqbQVUyz0rF
Zmg9RbIQ4EJNJVSqVVeSd14wZ8AgoKtZgMD4GdgIiSdqshgEErzOPH7WOz6+tGW6ycGUtzDBC8nJRb7m
Qn5FxoOup2VLM5lKQHLVBq1U4YKkrp/iLcWiMm3f0WwIc7BqIxnEvzFDunanxIvgQ6v19TN3WXRBskpJ
zO/ZlwuF/ux6GUxvimJoURQxwwi1HswCaZruaBWLLHE/L22bkUirxEhD9qXOirT0ZkvUnZJVbiPv7pf3
9PTo3Ea3USO6e2rZDVJd2ETwx6Tgq9BsCL7941OxktznRaZF0nKWE2mZtHtansBrn8s7xDKP/PnbG4OX
4v57wFhFx86GbMd7fJQXXzqwI5qkzcf43NePZKClqEbGZaoFfwZ2rSATnRyDdP42EB0jKdSAKNKSKW0X
eruZwuB/WDWe4poJGUGqYjiHjEKIInuC6lFJkbESlpsNvRhq/GHSIcxZU2v2WG+Zq1+t+9v4ydxSXZaX
SXNaKDG20OLWjpGRn3KSj2g2sdGNmq0rtHbHSju/nOuKoExSzSyVEWBxdD29gfV9a/7+nhItEYGL501x
1F0r4qJn5kHiPELbv1zh6VdV0MKdqJzGSVm2e0aVtmOlfIhUziA60k/1hZZig0RVhSvZNPFd68m7e4q9
J0WICBSYPJGScQSFC39TACCoCMcA/aRrlDRFPssFx6ZWKFRQZb+640isOyJtt0XDijf03JIOSasB+BrA
qCisw63QrayN++QPp8wRT/UnnBmSbomapj2f5WB4FVqLMpJDoIku6dJzn2qw/+LZrtH17zoK291C84dY
lBrRTfDZOyxO5gzZtA95V45NqVrc/HuaLHdcXVLpr2UVUekpr4zhRfikjRJP6/p3dwuvRr8zcJB2v/Co
hanHEHhMJbjSHWiNRomiq/MZTWk3JVlsOodKKP9UGOTz7IsnwoGyPYE10woAMRukELnX9CO1+u0SOmB0
WMEK1AqqYi0rzZVc2IrEGz4XI8hXjOGWt3ZhCH3IeFUlQi76P17QNF4rx+madkB7GVpTjgIH0bZ0FB0q
7LeJK1NDVjhZoZguWxnKBtQhu7u/ncpdtVk6n5/o+SSt9B9/Ukdh4fR9TWLtXf65Vqlb+fNqHVkqgqhu
915PM7/tFvSLhJitNyURWErGtTCpoj5uCXEgK5K+NvMtitg8c5eM26gWaZtVv6NL1IQSSLiVqCdX6BQ3
4dwzr5rnw5QRsb0zhpcO395Dx9cxNbkde4srK17wLcFy2WnzXl+2i8w80Na5eWael/O3Un+ym2CP8Tf0
jSJc/I5sVWYWwUJUav5hyroANpoRx9rIKEuQY8eR0PUtvwANFeSt9yIBLlK8HKwR6j6CSWTWHiW45C2U
ZrwRd8A9RPIC8Sv6mj/B05d+CP0SyJq0OzCdGStYw/vx67t3+0wGh1ExvwJKVFe6sULLkbiADt0y1Gn2
nm8M8o9tZZiL3Y3J2N0tt+oR+xuKE0P4hZP5FcaPUfAUf3ekLFgEtjyIvtMbV95deBs9Mp/qCHSgLa4a
qEd4p6KLM8+djicbWhO3GqPHIlVUcebohHdgEjasekFzmDK71KZtIhpVRpUvfcWEi3WQu/jbGqrPCdvo
0nGvVXR+29Dvq+ymVr1Dt/3ZbMKUy1WKUIG2je1WhrRbgvNwTBzuAqM+K4iNiGqUeIzTxu3VvZ24tJcp
rtNdCYLyNJ+XomYOjImd1PuaP6JP5KUa1K3aKrVsxxhf9EfL9rsrX7GqvGMrk9yrWs7UV7nA9tGKWvwe
i0++wv/dp+owdmmTilwFBcW9w7MlUwYgg7Pbtis0jFtZCuJhLGKHZsT0ke40g8M327qhWzMIUyGCN0yD
fESjyBE3bHsgn9nNmBOyE9DMSIvk9Io54m3ftu/QjYDP5utkdyvN52vUDHXKtcZ1aLo7VZUpm81syVMu
U73rTKoC47GoiDTQbOvm22+7bqeYYEJAyQUBtu4FPAlMAnadd/X4IMntiidAu2oRMDjjLi/GrHnfsW4E
JDKl5V1PJG2WuEtptsV2LGu+VARC86iTpJO+pwlUI47cTpZTQn5+fBdCCAE5rHRD6ma66W6XWnC0vm7v
1VOSM794+rZ29nKvyOeTVoeN6Kb/tu9MUyYMpAr3u5oRjTGMSo9b0pw5QPWlIJVcYSCpuuUdANQzOJgG
gCuwpVqfKJ4DGxjn1mwOhVZm9k6N3nnECH4CJYqdTpnNZBlDkmeActtXXKXzRIOal3XFWgqoU9SzinsE
0KuFSlAsUnL1MHZEsBi8CxyU5MDwxp4w358pkbdfE65PJnu7wWWj+7fNwHMVplusaLtGf1vZCaR3S7Ur
C7XmQLdcjtF/4h8djwXVtXpiXYbgT0Lr3y4qM0wmL8X6sdElfyOJVHqDa55CRa+0YZmdqNhHg2B5h43U
iiKZ73APXqyOXBdVJriCt2yxIyzbQq8ECcX3+fcp1xpePZHOJSQojeicvabA7ROcZXn2NHrbvoRqib9+
YL+7W91Tu06XmARtEsHdUva4wsvY4bppPU/a7B/OycNJcwyz0ZshLYrQC0IXceYlZSRRfN6pHWi62XEj
yTQ6dfqvpuVpAw98Ak8qnGeTIu8kqm/dSvm4XVjTbemVsqXpSVL0Erdth3zxlD1VlqwBMUcxO9SFyjd4
yhycrSbOuSuLjtCCbjmTq12xD3kOLdX6rPa7gg797TuXsleeBBXe4i15V1yXeVZZc9q4bNGq7txCXXRb
G8XkQ1bMFS/dfUzgsYbRl/MOTa5dMVmHzbWp9uPWoi8a4WOFOcpHXUc5npQTJVYBJKDaTsiJA4ChxLuk
W5kKcJnVOajyXt2UzRrLfltrrImdcMcqXKjDPYOTqBJHmUt5ZFcFO027Tmi/x42X7fpYNFb5XlXpZGff
MsmMSfXG0OyC2J4eo1bz+TGIfj0/3krViqnXYQohJGBD6Z2sVkBf7s4nXRqstl4IpX7KjUVSvSfDZoOW
Ji+2gli9RLMyOLIbXqNDsfWoKxKGh6wscd2Ldh2mmj29vjMq3y0qFpnqneqWhaJZriQE/h2SowLp4xIg
7Jntp9p6+uUl2VtkS4qBBCp+EZvxZOTot3irt9bjt3yEjW6u7x+jWvzDElHFox3ih2aCHfhK3bXy0Fwd
6Sv1G9w9PTIZ3rEi7Y6IgM69mka1XcQnCJ61inPEE5FvaQLb81JobZlcmc2k9qGzu4yVTO6b7E3N/DD7
88AS9c7MErlf/mo9eY9P+ia6C3ngzSeS3lUB5oBG0rx7Ivn96fU+Is+/2zjwuIb4cIrthne33hLU9byA
tA7NkVPs4oh4e+0tj5k2960HA92+Wc3tdAdyPisExSHLjP3RYiRqGWs/m+NLYjFxKmulJFOVKwd3vdsb
9a0tT2RLm4dyr4jQGOpX7bkabrxBPpG2PaygtRzjHtxgIv5wnX47hVqSWCfbafVtWeqlotRKNGKggpGj
VPP2yNLvrJ/AHzcfpzwvSxSII3t3Y+Kd1bPzbK8iUWXrZdP39BWgc57lmvPJPywV0iVaId7NXbA2Gkos
mZjV1Jfy0YKkeun/7u6kD9cMVggWLH1JLYME7hOt6+XdRtR/knxW/3b6TDIJTt7mCt2BbE60c78AvFbF
rMriXaPeeTGKy5Za0iYz2PIUqlZZaSqoLL01SujpEyPULI9bTesZv7lT1s4bkLiYYWv1c+3HWG4tJAZO
IAQPf/Rp1n80bsk/yAKSx7T1hzEpovJVZQd2HKuG3o2haHLJiXuCqdbVWOsKZ0KiF+IP/5Z3dQAGhPZu
97O/QZ6pz3fXBASJ0YGjqT+2PuMirW/3/ObjUxTa2bbD5G6GALkVz0T7DYEe2mBh66rlfTQgxVbADtOL
DhFK2Okm8K9J9Beu9H5VbX/VUayh3f7kyjAaPX4qN/CBPVBiDZikVGkZF7kEbawYkav2gpw+LLmZbbIn
6g3tK6T2kuU+THSD/oTRZ0Hrab5kyl01pusKNNtxGaMdoaUceaGIv7j1Ou9ujKvyyB1fRzgVsR/rsASy
TrkBIxyVI6MZphNdTxgqVYkBdJay7QeGoh1rkiuda2t/KPuAlgl7bgbMoWbz8Y52wBeTSglPfVFblon3
puBorgWSduVOG1JBwdsTteEs+RdstLvrwN/urjiP0I+YeFUF6Rh+wqjmPd8+/bpXO6FlejGZPIutitZ5
IR1QQPKerkSjJn7f9GOaLtXEdjAsuUDUEe1mxdxkpUiJfMPUJR/BEKI2rJg4+LoGl3wT08KgoO2V5Bd8
ih6RKeuee4Vv0RM7N3e5tLNr9OIwAJlb6r1MnJ5dx48cCmvnNVuwuzuX+VZrpKe+SJjbtPVtQVvPKEkp
ZnrNiNTQ39S+RynNmBkUUWuFmGg4eCoF9IouIEt7WWMZZdZHVBAz8HQroSAN0YdsfjF2Z1NPgWEZJ9bf
v/qsZWskIpTvwI38tCGaPZqBykgm+gKPnLos9OqeWdumprBEQdrdDjxczHTr+tIG66jaIzyL63fNRxKZ
Ysusd2bFCJz/OJm1cbXsp/AQeCvFIEoWEogkWDtFadCkwkPSm27aA9oHqg4MkjcgpJVPFCil5v7RxAsR
ROjrbvI27+lf62sBw1e17H3EcS3EhbYNU6V/RYRn6ZDcSXIKjujZG167njje9ABeGsO1i94hfo4YMZXz
Imm135NGQlZIYUTe56NRhUBg95h9Yl8zPIG5KDWcqAvNDEl7DngBoc0zcsQU1s1hAF/aRSZOJbsU5tUp
J/QxACKPa5isD/BziJ8j/Bzj58S+JK3L1NbdGBaseqXxHe2Hq3W9fGmcn9RLEhCqLy0BVLQg6dbsTnJC
TDF9TWNk5hX/NPgRe1o74zdVtz7ZNU7A1VmznSUaUVnGkRIu6IVb+eUqdHGvL6aWoyST9hMI4DYLq2Z9
jYeElCgIkQJhqHlj0Uar+mw9siCQdC3jrobRK4BWEtuIFMrtks0LXeezUmI/KwX31Rc7skHfSUHLO2Hc
HjpSgwgIHP/Hg3Q+QaGo5qnmYJvzGbz+JnYFRQhCuICarlqB/bRM3oap5gM/PR3nH189Am/xRXvB9oeq
uS+euK999cWi/d5yPKLULU0AmKExr/zTE+Ed69dlsAKR7jBVm1sjQ6DNp5lhRN0CbaXY5cZ3TYzxLoJi
tQ2gGg5GvE6ycO9Z3U2Msb17aqcj3UMuFRcJ4WJY2NBqWeKNqNfUL1vm6obsnVaCMStzLzKmljW1djln
xNFNFLCPHclFvyv0QagXTxSwUGo02B3Rq8loeJ60akszJZ8e8JwBxeaMiSMK+YUNQuZzR+u8uIdS+AeH
90J7uKN1hzvWDCej0XoqvbJYo4rhbpEU66ZVPc4KtUe+V8tAPUMlSHUAXaqrBl2mghe0HVzf23hxNWGP
HFiXO4EJmz3RPSRnN13nLZ/1EeO8WdvoaHUgtgN7FTj5DCXdFFzSjKGZ3wMRVsg6ZoWCumiUPd3SU7tk
77cEEkgGQWsX8hcvq+4DaQI3QHMHYbVd1ylvNxmzx5gGT/GV5XjhQwtqep9VnT/m/D8t43FbRM8eS3vG
WCNw0O4OlIDWMBA0NlfkYGK2fqVaaeuV5lnSdZ62gugXKxN/sABSWKNE1ZfGFPuKgxq6vjNfvLL5zH2v
R5NEegsFPkkhmhWRp/pumUjDRom+C0r9VC2Wrbj1mW3uD+Mh/IcVcLc+dlIfEKOsgzqLjQ6h99Ltt7X2
Um7RPIIjvG7pVzysxPotsWI2ZwmAc3yVAbW3tLKh9Ronh3nt8imcN3yL0tLyq6rkj837ingPIbOUR5W7
e9zYuomSmvVUjrRalPRAQploGFm3yJlyzBXj4vUk90N7kfbEgfotXyW8T6tdV81088JIKLh9FOgn/ROH
Tu5IFOuOaINTzbm1Nb1kpMv09MlUMEWGqu7AaL/QxqtFxA7OWjEJ+uI6OMq1VSq8YaWV6EnTlFLAaFcU
y0S/IaAAW+MaXCFPrfbUAyborGuaYSSjUM2GkNGFuSUtmLkZpQrHPOX2XmutTUnG3ovmNi8IOu2XTHCz
KYE3gEnMom8EkBV577L5uazc/KGdnhXFgByHXgNe2XWf5QwWl+jVu+eGHz3+qjUfGx6CLcYVCtxZG41R
8Pz4GN0Fr79arw3ThnHKvPeenqLHO2qi/th8vv/Viki0DKMgbni3cpfp2u+K6tG6t+A9pIQEImI72ucm
mfDidxR0jHCTKiE+g74gLe9oy4k7z1uJdltIWsKdSrqi7yOYWplMDjO1PlDR6M/fsupxnMp/xdt1GBOs
5KoQ9y5dn1aWe8gX0nldoO+zRAkhQgtxoUpa83eUyEW7a2aOk9nAmNcTmDPEvgvUQj9qgKaYNWgUbC1w
CIz4lEsqFOMv/PgrbjUvzg4Of7U40mn2caUwPl80eNDcsCOIPj8FNSWDviZtKXDuaMtt1KXWYCWZ6UuO
S2BsqJFZbZSzig9rQzDhPUVPcSNyoE7AkEJ/2MuLqujHJsjHLdzR/NuOBOPrTah+44zdcjgKE6ELarbu
9R7ZMSabZtEVr1a+DTY3HMOgwrtaOlsQt7A4cjfcjvAREjOV9VwLOy1QJdJtlvd6I/IkSbtBCV9/vtlh
rW7aZVTIygvs3e/ebRwibQgN6656/471h0AgwJCp5eLPzhjHpRm3q5lqNheBJRINiXjycJmoKhHFv8Pa
HHBuSpbgaD4m8gvp8K60vSOGazREiOAxbj3Fd1Gln39U63TMlbZumwLU3iydCjNpp+lJrMa7UJ+kXSw4
Xq+W0W0oYzHPdUEYPz69mr7Sk3s7WlPbKZMuMJ+OWZaSXGuFFvbTlAmlNmozw/kuv2om7hh9sXrxu36Z
/UfaXV0bLh76jnXFeKvyAhQmfGl6saP9MNSuEGrBgBOrcbaeaA/dPzbvIzVsgh5SuYHPorXPdQTh7q4e
hTYIiYsy74RksYN0Bhy/XCTOnOwuUutiwQvh3DM9v7VBMsNkLdm51IpnYqVVk/qHvd1V3JJEdma9e0Mn
hGJ8dwYtRdCY7QLbCIXntFEmNdq4eg3xx21JVW+vbJXq9efqnc0EG4wSKg4YQBLGU6NjriDp8xPepeZp
9Y48hp8nMsUSVrsRsaUzpKm1NNdjZGYpYZgk39y27mMly9DOZxPiDjvUtJWwvNDObJ/CmnlF3Tq/JCsQ
HMj/0Lf5ZKaJZK4dNGZiw5y9Q/vQyQ1l7bRNpT4UFjz3M9in23gNYfg7iN7q7rhOK06A8o4V74RNNZyZ
diZS3DdddeNZAmDWFjewELSV7pEYjXJcwaeDU145u2i3SxtiPB/N0gmYYp5Y+DPnXeMWlEOnwJsMPriE
Cdtppv3uFC43+S5ywyy3u/mS3ah4evhtnZZtJG7ccvWkY4Vhnc3ZCUwU63faGkAOjD57qu0YhzYnVo3s
FrCTksR259ghdmBztA7rTM+Mz1KuCKV2vwEI2wKO+8GLVitVCVd8aveMZ4eSJTgxYCL7tzsfj9cayKB2
1GI8z4Yr+6h5FWqs5oLU3PNMErXpGA/HjKWj4c1Go5YMC87y3ufi3d1tZW03a8YOh0VBFEjaC6gbtf/5
DnPLV78UHxNc7YibhEaRgXdLwil5DRFkkeO7+iFI856aj0SjiMbzDoDJoD1iwWdP/f2f6u//UH/76u9/
V3//r/r7z//8T/X/f+P/cqn+/d/q77/TL938d/r33/6b+vc//ydd0QVVVH9RK/DuIx4F8mHs6CQOO9qF
ixGM7EwjmU+SZChlTvLCuKtRSburr9OS9RLlBKafTv+I/9PCvWdH/P+Yl6LIl9quQ/n6oMzD1xWP35yY
JJbahVf8LfIRRAPqEnc7lS+zGjafySNtxkd6KwGo6TwHw9heWqUDVytYKvkZPTbxxZnJ2qWYpXEbOedW
EwltZygJxP2IjE/zsaUTiYImY2R/F2NIgEB28Li6b+9pMup62gloXOqZ1rxQQgxqwvYqmrOErDvshJG1
JfBcYc2+hJqYslHCiU3GaRfpLNRu0Y/MwLCbSi58z2KdKQ7u5TZ8JcPAR3lPccej5qO99hiME6tshflc
HP3VpkiFLgkSJe4aBXNplAdPU7Ij2SdNbIvCF0Yyes/uebXFhVOiHjjtkY4mN492bKJBrjWejF3jlpZo
vMZ9g1VFSv75qfCqqfMBJCuJJ+muqVPfKPmum3R/io8Mef+KEZXsejrCwqgQdziBl01RUaXsldRi1uxE
UTbCqVMNJ0JJv1hNSOEQbSsyiJzQprRPO6wYc2IQG17s3IqIZu5Th7+EXB9/KvEtP6sYLZdnUoyUe0te
YM7b6tZ9mozbaeU5F7g1inY3zd0arAeBHYqu3vKV+5Rwp0a4xMbaO0an9lHNvQVnavnRO+Ttqoh4uxTv
MdJviDKdWOLPweKS9gtxIHJjrxASAuWp/WS6kSUFz6vijilzhBZbz+HG5UvaElDhmGmsvGw8QkDJuwUY
nY1sxyYh29FZy9SFKwMETaSRQMiuE2YzGeG/DhXr2X7xld6yt4gellK5W5hIFrNPtHu6k+KWs+KZi2r1
aso8en/zRcl3ShkyGPnb/umnX/mvy5tqwjoJxx5EOpOQpFOz9uHdStShdtR3s0D24nf52eD4204Wth2k
h2HDlsn3Rtgyo5QiYvDi6x036wMe0L3JMLHRhR3DQTsFhKjmk1t2QTJRpk4qV6+sxk+YHlVHwEylqwMm
MJUof142CQrasYE8Ozo7oLrwH70gMrgGQyGnXHtV6l9VVBNW5QVuuyZ/qsbGNpGgMY1tFDmgg+yChpHU
BTtiz/PX6oOGTkhR3OVeuAVsw6sWKfHVpsCOXfd2Rasq9+RBVMtudTqWUZ+5MP5vO7EjCSwoewyiOnVf
zWg6rnVSr76TZNS5dJph3sVYDk33a9UWxQnEvKtVbqb+DvtnFAgflkw9u4YV2c2ZW94lOrajMziai81F
uUJiW1xsPtTyn1xtPFaARqXUVyU/m2ud4bGC4kl4hNITMp6NIXNLnR2sixiW3Wady2p/Ok5ei41vbLYn
HXLIv84Z46at3JFoXnxdHGwM+N7VfzXvKUDBzU6spIyGg/wl84OGIffRPBtmSkBtaqmdpP430Zyn2Kqc
hkKunZd/yYfw6q/Ntlhh0e2ahnU+EVMAmb/6fKOMstbb6qRUet7orry17ZH0BiZeruc2xzl3vbKlSIMj
9FcSm6h7QzHNqB3tFqfY3mywYfUIHDaK3D6K6o8tNOk6GlfJq00nP4d8AgtXJ91KWb29k/TUG0XVkh2b
zO3eprdHgf1atWRH+AZNMBH+oxlurXeh1m0GRgHpxOBQixZ1JW5G3qaJsTPNbfnApOBYgElG7TdkPElL
ReXx3MKbftFgMXeqtHeYKuMCh1FAtU8FJdAtd9kUujyFna4KMDgKTtW1lgs0FoJk2I4392bCJkqJ/D/+
4//7j/8/AAD//5Qf/9tZZwQA
`,
},
"/js/bootstrap.d.ts": {
local: "web/static/js/bootstrap.d.ts",
size: 2462,
modtime: 0,
compressed: `
H4sIAAAJbogA/7xUTWvcMBC9L+x/MHtKLmvIcfNRmvZUWpqSXErpQbbHthJZUqVxUlP63zvyR1aWnBgK
7S4Ly+i9N/P08dI0ues0JAWUXHLkStqkVCa5VgotGqaTs/3ZdkOwG6PuIcdDUiPqQ5riE0cEs6841m22
z1WTZhMp7RnvPc2sO5Cm4Tb5yuSDekwunIwlnRmfAF2/nl6FEkPjVxgjFkTnHBXbjfumJHJhoAQDModE
M6wvd/c/WjDdvtij3blG2w2XZKVkhPikCiY+62HqX9tNQp+M5Q+FUfrNISGLApg8HxYeoMsUM0W0YGv1
FBUNNAqByrRHXFZU/f1y7+ux522PXZhkFEnIoDuwnUWGPN/9k8Fuc6OEuNVdsDGqLC0gEWXbZGBi4h31
Qa4DGpO8Ya4STVJjI6KiFiTVgHSNmOwmJyDoOirjj+3qyFHADEmrVQURsADBuhkwVxIZlz10qAZ2bpRW
j2D+q53l4WOXbvhQ9C8svqODZtpC4FEzcxR3hXEMVVX9HEeLoR4zqiVzgV4PeGTCvztDHwK/chPd02Y1
sCLQs6o1+XxDKAoaG+o3XH4EWWEdLTDM635bThyxFzpNLq/C96MMHlG2h3373gP7fyOs1QXDJbXjeDWv
akG/RdhL9t+WJf/50iNcPM8PX1zWTdjGJcyJGgSI4ifO6WEEn69j5+m0zKR8bpgsprP0QePtJIFCPcmT
kP+8sCph+2CyunsNOgceDYWpFssjy6LhXG11Lhxyz2s2T8JIdMSvCushgTzheSaFwhN+VZgJMBiZHaqr
5KxFVPE5juVVej5mjucqiKFQ+Zmxrj3mj689j6RIe2Ksn/IURv45BwG1sNPuDXsM/037aHrIfwIAAP//
iKGlOZ4JAAA=
`,
},
"/js/bootstrap.min.js": {
local: "web/static/js/bootstrap.min.js",
size: 31819,
modtime: 0,
compressed: `
H4sIAAAJbogA/+R9e3PjxpH4//kUJOyfFliCELUb/5IDjWXZ601lr/y67CauO0W5GgADEhJF0AQoeSMx
n/265z2DAam1E98fV3at8Bj0zPT0u3uG58/Hvxk9H33ZNF3b7ch2dPcyeZHMRuGq67bp+fmSdrl8lxTN
bYStXzfbD7t6uepGL2YXF1P457ej9/d119FdPHq7KRJs9HVd0E1Ly9F+U9Ld6Ju37znQFqHW3WqfI7zz
7j5vz1UX5/m6yc9vSQugzr9++/rNt+/eYJfnv6mrMEBIVb2hZZBl3YctbarR9X/s6e5D1K12zf1oQ+9H
b3a7ZhcGakLP2tG/kzvyrtjV2260oz/u6x1txXdBNJ9U+03R1c0mJNFDsG/pCD6riy6YyxejPIwe7shu
RLKyKfa3dNMlxY6Sjr5ZU7wLAzX+IIrz7OEHmt/U3fsd2bQ1QkiDe+fJm00ZxN80fzfbdOqa4tvvzHeN
9emocdp2g2AO8wrQgaMvRjVMJQI83jV1OZqNs4wkbfdhTS+Lq2hHu/1u8wCfpDncH+b8wfjiQJJqk9Db
/RombI0iU5jLOX6KbHwRl1m3qts5CfFPlMAoAD2tM3P1ZfQAH80O0Ry/p5n5/PGRhGWUwGIsl3QXwlj3
222z6xI9wQSGG8mhjlrava9vabPvQhrnUYwDOMQkNID6gGSwvLHvxdkZdErvcLnbLS1qsk6ciWQPeb0p
3wMlpkPDi0u6pktE3dFWK7Ip1zQ1MSpmRcI86cgO+DBK6pZjdZEn/IPv8mtxtUvIdrv+wN7H0JyRaRul
fK0Phwj+CwWzxE+ieT0EhJlQUqxMVPIFF8sc06xIStIRXOuEwHA6YC36+Nh7Ci2RS0v+XRQH2PNmqRk6
Pzujl/lVUpD1Oixw2LynZ5cIaVrW7W3dtlnAwV09i206BHQh0YVBsa6LmyAuGBkkxbppKZBKmfzlzZ/e
vf3u2yxgci6Iy2S7a7oGe+etLHAKHwVMuUpK2iEaNFUG7JMy0bNOdvS2uaMhH3dpYKhMSNfBJ2wefEk5
kkL9brWjVYCNKaABQG3XpKDhefI8XGSfXP7tr+3V80+j8zgIIs4yFcCn0RyQlsM8GLF+RSuyX3dA1FWy
pptlt4IeKuhhRdrXa9K2ocBdtChTmD3ZoQiLsLmcVQ6S4c0dk2xsfsb0QL4BGYo+vuc90jKMsA8xddFJ
vQmG+KoyxlKRksJQqgFJUURe2RNefDaLUlgUWFMuOpiYYoOc68ssj/VN8rrZALXti67ZZaX5YtPAqwoI
pjMlkGRADY0qmSIVgUFrCkmM5KdkWyP19cjrX8CGNpEphsv3XdfgIlRZ0OTXFACbXJYj6fWbCwYtuCSp
kEW7ZrlcU/g4X9CE34RRioyagMx918HiwDAVp2r+icvogY36U8o1ZYbsyTmy2WKbFtaN/tSBCAwfDnGR
fPXmD1/8+ev37+BL3qxuv25ICRICdMthXvTYV3+SPax5y/cAMA3ETZIkAQLWqyCH7FFfAUgXkq/BvhBq
TA2cYbZmVL3dI+sEd2QdpMGqu12DOpNoB06cZAEOIIg3+/U6y5ApUDHBo7MziW31CPq5pFfIfOyv+ATE
38LEEdyn+DCKDRVHcEo/fTBpITAQwFYrdFE4A3okZclZD1iLCZ0CmCxK7aag+3roh29NBi+kqPuCAQFO
jDkRziIb4ZxiModoCY4mt7HMOaTtQiHsxZcBJ80WpH00B/slF3JNLpsNAwzEUq3TPNjB8BvABhvRNgxw
SEEE85MPihUtbmDJ4ZkNyJCXMPA7lFIw6Is0F10k8rEt9+RTEH5nZ24n8fhUH6ZuAdW+hEcH4g6NI8b5
kkvCkktCjrK5cS1lIb+zhGFhvTktDQXA8pQ4FAC1PLTW9W9yYVGLq54KLdMKafjMTeWVdyDTQN2UwHSS
XoKEPUXlxOyGUgmtiJGirRj/FabQgAwuyK4BoGsmhYdEnZAdsVdKR/Ey6xtJizytknZdl9SR4qpDjxzf
7G9zujOhIHPC7NLlgl4uQQ4B0Br0+Q6EG0r3LQFQYO0UHwoU+T4JX/gkPKOCG/qhbO43iTUoKbXYN6JF
LExBDgdYqy4IUGXr5WsFa6obBo5KETYfG72Q44gqlGJcqIkpig44/4ibuqO3bYaCOA5WwNQMXQZwDtXl
R5zvLQ4LraHdkSmzr8WE9VdrSu7oka8Y/sVXp5SgnFz6GX0Zs+5SMZH4HhzUFLwtSzqLRchMPmjBlwcS
J8n9qi5AzBYE+OLl77iOQG5CRQce8M2cv/k3/mYD5K3elJzbUs44B9LnQmsYbIqZx//JgdXN5RxfSMtA
ESp8SXZvxW1ovbQpw/hmbMBUyk7SBahZBc5aCJyh0HJeuJH0Os2pgQR7C1T1dlPSnyw0mzJFEB5R9nhS
rOp1CddA8/guUAyCDaFHgBaSx0eThnuK12PjMHEguMIcWehhBof1sGel9CLpduevzHFxzTy9eHycvcoX
3PtMTRZcuJwDVj++ssnfDARwGXWI0hJtGr1uWjDpDsAQfVUuAlwnsM6Q5ICVQmOAaEY5aGLAnkR6M7kG
DmIYWYwYhYM1wFFwdjYQU3A0+anwRqwlQAgDcIg/O0n79lxxpB6tbi2Qu2iwQAyfLtpgtj8DFEeSY5Lj
K0ercKV6mg4x9AAaENYVPV5bwKPq3EhjOFjTComCBS6DeGW+qupdi+/AwoBXNQ9hgaU5psrUxDuL51Ga
irDZ/AjDBNHlCoZ2gO+pz9zzoA1kHDPlrjN6ObuKb7Q3zhBlcwrgHb3j8j0zldLruKx3lOExXR6Yuewn
uJsoHt94XXk2V3s8s7gSKk9wXk9ZKzz1XjzJWGbzXWeKVfXnSgxGl32ZRaOraA7SfK29Gm0OI8hbG3cf
hTpl8frYeMiMZysEngIsthoS2HC4kElTVaBZfqjLbmX6YUt4bd2Vp6Om1ELjZR4vr5LrpgZlMUIXoo8N
x3m7lC/sD+PaoEHT2zS6rvu0dAv8DF7fUKiGvnwOpjqORmNwWu53BC+AIqDLgoazeHoRgSMaln4SMZGk
Hzp8E/uJ/RbDW2LRhM7gwtHymSRlzK076TfJe5/npN6d9p0U2JPekwKq/aeA+0+MyK7ikXEHPtVV0Pei
QDpKv4SFCn0hSOZLUSsAGWGswhd9nKjoI8gIM4ynHR3e89Lydirp4lBxEYH8tQYjJwGiAFRnuNQaDg0+
4dZVMXDHCuOHHgcLzYSV1907gCse3oNMae45ijFOYrETkRGHHSoiPZmrZ9HxwPdcjKyICzmzf02ofci/
bNZrsm3pL/Av52OKGOX+8tlZ0K6ae9SKsAp5NkbZZTuYskePgzkQy/d7jr88NqilCTI/89kcVw1NaWVy
8VupY+xGkWPQS2zwfkTI85Trxdv1PKwSZCiMs9n0Q2BDWuQedUSgVdBCPAFXjjLzxbGfYMlM4MpWsTAk
nR5PfxirV5StFCZATSwaG7YmCrAmigFrwrTk5JKYd8JCeAUGNNnQ9QgucDzYWYlyyAz2DRA/tmUZE2vC
0jrTQaEVU86DFI0kxClVGJJq6cCttSduqSg9EENFiYfIENFldRXOvFTLLb2luXqnO2Iw+13REeIN+woC
b2ezAfXIlnpjr/WB2b8+40earEuOVi4HcRYroJ2C3NL1awI24mXQFjsAB4JWmhhTVBwe/69n6UineylD
JV7D4uVnMzZbCyIYWmBwg9C3WWRleRjDLHKaQ4zk2Epa40/gEJBtY3/qzApjD1LcZeFOtMDEgbYr/8gk
g7PCfnIcpN5+Am+QZMseyT6R1gBpJXWI7aOoPNApfx95cqezh6rZUC2CpLXyJK2lpUHxLoH1sxzY7PIY
PS24PEq5ykU1aVmjYrpz605Zo+Lea43Kd0+wRiXY09aoBDoQzc/0+vjC+ZYhOmCG9k23n2OagtNPwgoN
zKXXTqqz1UJmB1Jpj8bX9qC4ZoLWN9n12RkJr5lZurJpHEZ3c3Z2w/XXIDIuDYBZ8GxyPXnG7MpN04H/
6qHvEjXU5bJHLLIlxjA0uwDdmF8qW3kZ1z/LEAWb7WUG5h+P/cIUscBAFTVgOY3fJC6zIiSyqoNmjm/N
iMtK4zRbumF5uNJXdiAla7lrthieBmvzSOmB4zFy0D6JY4E7wP9GfYeKkObeOo0CUKHfiTqNIivOzs4/
ufxi+l9k+ver86TDbFQRYeLvdPFGiV8TaC7FmWHuLMo0V7FgPczy48pySrMsR00+mpdWZY7GSslM+uWx
4pyyX5wD5K5gTHNS3OANZsUdnlD9gIBYHqnasVfKMMFBQC57FvjyiBAupdUo3TUe08NEfiJz/fEoVWl/
oYsroGWKgqTqESzLPwMfjJfARc2ma/bFqgUi6YBJR6o8UF6IAkGwvCsjV7khdznZTeGPGS0On31e1nej
AnvTuNL4PH8FQqPetHTXfVF1GDIOjTySKHfKpSXm5T/ms0u2KPuWvkb6CksS/NaKDHlq/qpgtpiEq+y8
tMuGysg0uzmoOsODtZK9tFTObLbz8OXvH387e3zxu0gwW45NXzcljRxHmVcK9Iqi8qTtmu33MASyJJxp
4nF5kiQokESJJEG9JDEGZQDW44vfoeSUAxJ8yh8ycYouCtMWVdRHX2lWleFqyrUMRus6RXUBA7wDwbiL
0ru6rWF4I4LRaio1EJjbwGZAcXtgsclq8iweiWfruu3y5if2mA24ttyq66wWGaUaYK2RuoJUjCuav/y9
Mauzs+tXM/hnOo1/O7Off16r9A/cTSbxP65BaF5nM4wr0h9BifYmDVbUQfkOYI9I0phbd7JaS95bRs/S
eXfa6FFgV6eMHgVUGz1DgsqM0qmHo6rZ3RqRJsJKUF36O5wGWXnEXC/N7vvOoAFOFx6S8DHeR1sOGM85
pZhsG1Dpn9umJGtuuPkDPvREBKt6fOyBgy6M8NTSq80WWFUFbJ0uWQgFw2D4F54cK3Vwygw+zZvyQ6ZJ
KMF7J1FoxLY+lQJdpKradygWjegV95pBQbBEgfSjZGAKDZ2uV38gcixs5tMC1BIzXhOMc4aez2NP8diA
t4YgeH2rWKXDE+sQ5DTT8SwGmsobsivxGhHcC5G5ettJjgsk8dwvmoYq5YurRdxsohUNcxPfPaUnyMVR
mPnBjVQovakqE9mg0PocKIi1FngsFpJVgr2Ta6wyaUg0hi/AV5LrF0EWtOt9RduCbHU2zqxG4cJEVEsb
03TLqPljkAFWnQPi2CrLkavpCUt702OFz+flpb5z450qdpCFysY7soXZl++bsODYwdC+eskWPhK88h7G
BTqmNLt1822FLyaCfpUw6MmuJlPuKAQxphyKhG5Aehf0D6ipwkiVGRvkszlOP+WiGGDRsibrBqMbp7dH
eHhS6E71gA6m3l7OsEr6iSCiYxEz7hn67Km+0ybl+WAgzGQMsI39bp0uQRUMdGGyiuXw9bmFVdgO84ul
8KtK4KPeDI++Fxnz0s1MgBvgvqF6+KEgkaiN/5iIqWLfb7DH4yEtJA67fegSgckDmZUwO4lAJoZ6j/uq
hzi6Bzg3w61J3POWBU4GckKiNsRIsTGgvKSRKVWWPTVGDL0opiJLS29KDdZbC2aA7bceSeubKLoCRLoC
hjaTI0xtzeJ0hnge6M3Du2xB/SknR7PxMQwLenI0iisH4AyBM8yX0tjpWRqyI0n98l6HmhxzCS0ku4u8
B9xb5TbMWPxvGgQqbO9ffdmRsmK9XFzq4L8amePVc0El346eTcrJs2DEPHul7rSQ+xi97qM2ySeMnYr9
DnUtV08gW8EaBvejcMtb5dgWLk8mjJl0ANx8Z4gRI0KuqDqm7iK72tkhAVtDx+NcBR0WTku/MMyPbRrK
gd3oGpNlMgVkL/qnerW9lGmMTGzBstS1TfeoIEFtYmj/F4j+E9Otjk23ktMV47Crbi1j1JyI5c0kQHVw
zdbqVcYrKZJ6s6HcR5GmruO5eJ4JkXZLSbvfUUM/uya8obz7Igysxpa+BYvDsAdYedEWCAc8vCkv8QMT
fBZfzIQdbw9ErfXAtzGZeL7qibihcZ4AHrjy2kVIf85DO49BuAAdAnsj2XxLbqkUMmrkUwE8sDwNJm1A
SMxlStNgxykxF3xulSnj18i9ghewOA+gxLmVumIjmOtLmbRiN76MFX9xOnLDoZ3MVXFwg4kq5fP4Np3w
+ERvRyZWT3k3cD4+Dm7VVMVSLJLshjt0EkpHPbh7no7PPxHRTQpmMDXqp2QtD26JwZAlCSK+yai39ZMX
Vts+rq0c/F6r+NLV76ZPwruWMciAZeR6Nhf8Z5RtcU3wKxZGdU2z7urtkd2PIX18DEpA8q75EIyzHB0O
uzBEwviYSidP5IiAPhIZcmhsqVt+Qzcs1MxvOl5xyW/Yxg2+W9GOJ+lwUb2pQQyooWJnp0IzZFPfstAj
xmMY2SLMFIAAANyNgqyZor9Fb7eoVlLLiJF9jXgcUd6+8rSZkt2uuYdX5/DO24BpEdWA/fssFsQkNq6M
OEnFXd2tKRhruKWefEhnMW6+xGFiwIvUAAdv7mp6j1o2fVAzCVBoBbEQwunMydwjBq04nypNkwsjYzds
/fJeaK9wytbYDQiH7/i9ihh9Ksdmm1zyKeaAvC8SOROhPt33kTrjwaYuyZRJu10jkYwCHnjlXtO8mk7n
sliTXlZXaL6KzEOWLaMh2zOYKFzYoUk5StsX5UJOWIJzaXgFt2SzB7Eyho4eRJZDbrdaLoy9VGCdCx8S
Mx29NmznlGwDbBP0yovC1ST42DGznu1taQbA+uMBsmFKL/Tg/YCbev/tK30028cPijkECjXHBsFBWOJV
/dN75BbX3gOiFDK/9ahYLSN6XwlS9u6S6Y/V6KYXnBSKLEftwBj57Ky/MVG+CcVV9sDCxuIuRkdD3qCa
8UySH7rRG7Ys4cL8QtYfq2XryLXAnTxM81hPDWWK8qK4JFfjDLeS5XCVlVF/XIyqPL5qPqrBICKbAqfO
Y8TaQlrkKZ4AYnlvkVZRBh2qwfNKBdRYLjAXkLFaFr6wPvuJveLe8ZhtQpJbBQqpwjCGaigw9JjgiaR7
scLOAxbYZRVcGk7m34eA8HBbt+4CofHA8MHtiD2PMBaqG+iVYez5f3hlUHCeXhrkuicuDQLsr42MdfkA
s7XRDYZrm50STGnhWuiWcRh0p3kyLJS7+4VKH8p3ifoJrIIWVkUbDlV1xL0wCC858NvV40IGMXQ9dEyl
zbfVm9dgQf/89qvQmA73RGmn5hLLWrWaef9uzacOTIN5W+zqnJb5B91QIl+Zgei/6JCLyNJwuyCQmNfC
2YKhrMeF/7EOB7EtUH2Upf7v4lV2/td2QfZds4C/5zWW7XGXaAloxh0i2VI5XSv0ssCaRwOW7TGRx/Sg
8/0AT8FYxN1/8KeswRgC6zHI1w0YOofI3Hnl5yPuXVjjVBbngjqBu16LKKVW1Y6FgUjs85ML/33Dozch
Fh729oytzUe83JeVcnCmuM2W8caJeMr8Wtz0u9hEc1jfvOm65hYtqrOzazDWtpPrhO8xmKynjYh/vGrE
swVDMfcU9Ceq3XT9+WwhQcqdlqIdu5ncACi2lUFtx2R/RBu8nt583rCLhfg+Xcb2brdba82Yt7VV03tN
1gULhZXfMTSFy/g6vonXgovYIVnfSyoLt/GSL8GPVuzrWIV8MCk5W4IvbshQFp0+GuMDJu/H9+hASO/H
YyG9H3FPkyUk7WkN76TlggYcZZe0KvORqCRf6kCb2L53C+qm3kw5m13MsMZ2oAlbVdZmXrffkm9hoRjP
YikQu1/h/QrvcyShjP07WcY5W/uM/5msYhmYQvknVhRHGmubE32DZWpGE0rN99+QbpXsmj3GurCHiMsB
6zE+Qbf9gEYp5pGd+DMjkLqPs+s+zuaCMwqg5nFWMQNWz66aXnNgN4pc/yJcuC/K630LRAvqHiRQEedx
HUPjG84JAhsZv005NLiDP2LjrGj44jm/mNJJneINcmc1uY5vZQvJdszX36inxrzgpTmlYF6KKarMrRC7
X6BvH65jxMLl5iq+7YVHdTMrGqIqaVh0QIjpIiaLz2bPw4spOc+jSfD/MC/TDwsLHTiwlYrTd67QK5wg
DEXy9LsddhBbiqXMxnjCgh/pBAjCzeFXOGdiB/6Rc/EoRcDgiIu6EeJwJILOx7edWGdKInWNHSupVMor
9uXtdVgumBRcDh36GS/J5r3MvM8otTWGcaRT34QYSulTVLo+s0ceAODu6T1yNtwRYTm0L/pUuid2Y2kq
euaslnSbT2zUm4PQ4EYWC0kx00MEBMfSSiJmrLgBPNUbsp6K9hG6lMPv4z54VW8gWvRYQ5u6Q2cyaHbo
ucvSJrDLPbLcyUAL0zhH+VtmwZffffWfzMrvyBIzD3pTjg4HeOzHAnv8EmUvIOw1yzP8iRbdYuB5GKVs
uR64iZGWiyF7XFcDPT7a6Sv1AkSnLhmKYmaJAES9O5g9wcPtEnBhRHoLGnLrx2rJH+mmfxT3h7hcWCbn
AVtwAeqmuTz2iiModVWlttQIh8+1QC4GEgvNwBRFzudx/mJanL84SHPN/G5aHv1AGGXenqBRef7C/Hxa
HNInNZT9HHpo8OpBDy54kNPG71wlclWAVZZe07mxmbMfb/VHW0WcGLOHy77Z7HSEnZ8z0f+IwxFpGxLJ
qCbHdjVdCsIDP0YaA/LRpJyvPl/iQ3Ye1zZj19NVWr9acqtIIBQTFLqBejyteYZXVHKLNanAgxBYrybF
/Bp6YKqecgOL302v0xvo5J6nREPr3UQ8n97IIv0R7a2bX1y65/rJWJtAtRIU9lYbV0o+PoZe8cFeL8Rf
7mDmzJUUj/pMBv60VVtaNiMyyf7xj/CC/v/n3BYkwNW3mFe7X9UgI5X8gK+FePnyw1tMdepN2U4Ja70d
kryozTJ1heca21F6kWVxxk1su8kByd8a10JWM9XvWjs8C+PAvyPrurTOwewXYgkH8tumpDLJbxYLedJR
Mn7Nt1I78U8MvfS600kWd9t8e7z9ha+G+I14O/iVeXe8CNkqJsIjdkPcWPW0iF/8q4f60F7ki+/sGyx4
eDMskEFYDBp3btmo5llQq5DFDByaiUlpTTEycIrTLBQIi+8rH3qsagFBpXPzRlYMiFtfzYB8dbpqQMIU
dQO/Wg5622xZuuqX5KAljH9aDprnixVYni/mW/01qvrn6X/PP9AH6Ev0X7espPtIvtm0B4cWVe/1eDAS
0qJcRmW85Jne3NDFVLA/Qy1ndyxDbWemVy+db4USgverl688sNUuCzt1fYhMxnra1FXzyK7Nskj+l2fx
fq7zbCTKVABaO9Q2up7qUDsf6x0rsJzdh9ALxiX3QkHmEVjdReH32b0O+0i4ov7psK4xej/cwJOy+Bhf
TKhtE7l9H+HosikjK/cbWaaJpRDtt63yRDRYqCtuXxFmX6mH/3xLxWuhnDCppEXCzKshm0paKtDGUjpi
HefmjVQ64tandOSr00pHwvx5SsdwduzzY3dNQduWBy9ErYPYf8arXOR8uWvxRtWoYJUKK9virRbcjU3d
0hVTYOX9E5dkqUHmYFuU6gdBNAlGuL95tK5Hr3B3Km/HXNs2uxQJIN5e3/PT3LiF09sJxx1rdZ6INTFW
lsKfYHiLX7XbD7i/X8YqK9BWK2mxCvyF1s7/4mdreN2hV8cXZ2eFcz6zOUSm0fMjGr1AjV7w87PynorN
jZIujuH0YobLZgmPdyYSh7jJQira/SbqHx+Zi3RLfjIKbt1G8YmoDG8V2cMTi9NP74oINKj6bDbHSsUf
GLmG/tGiNMtRM3MXPZAay6EVI/ITPY0uLQKUctpEaBgZ2VyDHblYs1gmAgT6ts/1yEoXlvZKUM//9kli
FIayn/4Q61jh5lV5lkDVK9C8vGRbXSMWOChienX1+MhSVlHSNjsjec8MRSnHALdTdK0P/SM/ZFIAWGrf
8tIYXAncxM6RaDy/uGK7Q3Lr8FjGh8ORg8Glm1iShw/CMFHs1ZEBcbv5pJj6OpERPZmVFxOUeXkxLxkT
MmWWKjgwCWaMWSBHBuWvslIdnzXOQpJVl5XaNH8lixQYbPxVDcLiS0twFT5nuV/325n3E6wGJLrOj2Cd
H3xRXZIrgPQKIOFFOIa/kwsgBAYcL3vA8BNn5eQ7y0/uS/FcHrus6Z/HEto/b7p67dMf8ZMOiRVLLcFO
ZG037zZ4NsnxfJ342cRthlyk3uPPBjGVKAYVBus68J2bOle/kGOcccJ20uujO+yfIljXxkkrHojWQQ8S
m7b2sv1j9Xxu30qbRD2wDJbcfXnaZNGQdYW9e2ymNVDzoAHPYZoISR4CN3SSZq6O6yhEKA/rAv8XTtLs
SM5/jcl5ZjneH3vIpQw+GacA+IuzT9U7mWBiPIZIkdt+LY4GMYkzwuNEstzRKOxERXaklnOMUZmVQ6dq
qROL8PQ6yQmMVzxnWcuTUuwzn1M8VRtsQTyrjp1S6pRuMSw726fpQRRTSU6pYADVkePz8NCvUhZ5SPGV
m1yJxzVFsd1giUdfyBoZA+m63wdclFSXf7DB9sZ66B0H5xGTPIOhiJWyXxTzCjp9Iqa1qngy5nEJCbzj
OSN5uWABcqt4IXeKHNC767nMDOCQ+MPd4E8Werg5vwzl2ZqFnqAeJNLgU38ubL4c/MEweiwZTNnWmF4q
2g5HknwuL1QYkuTeECQ8fkL4EeCc3LKEoAY3LCHRqeOe5cNtve5tYvLsBBJ7cKTM42cN/pqClVRV/dOT
f4WMt/5nnS38xIOEPxXWgxtEECF328lkIzTWyv6lFtxQKXOF5u+86J+Ie/LnP9TdionKr5tm692NYBwr
w8DKPUT7zbYWpYBbrHSRuWXtWlsdDZ1s/Kc37968zwIGesT+xdIvcSXS0dbGIuGFgqvOJSM3HvrlBuaY
7DNZe2O2fh/BfHHkPF4xcksOcSKcm3EzPkirIMD9PTKZt58PjULkd4lnW613Gc3pen7MbYiG4gvfxt1+
2YbGoZqC7Qlqo0vLoZXjLPkQ4/7AhURMXPkcLLbfEfASg2ufcEKZS+ZXFTIVKwCElpGvSmTJygUZFKdk
1tt8xYDJztwvRAUfkv/Y4BBQSRN9B04Qy8GPL1LekJ3Whv6yPXWJrldZPl3palf+DQx7CT6eqJMdXyjP
UPDnOMvq6KE/ELsL/lsJWKEXBLJEWJDwJKwXwTSY1FgdZ/w0yPUkSLSwHTi66Aa+OHpYkZQidWzIEV15
Ui+km22ysKzQ+RiGvDZ/2FfMQNmfYqpxIIYTYHbTGEXv17f4MHgJytS/WtMVHnBj/94DAz/Xl+rXQpmI
9uh7/uIJvxbKoA07UUfcJT71k787oE/2jFR9ZiYvHh9BzcmbLxna2DmropKWIzKzG0Tqg/d4JodujfUm
xitlUKAxazlo8/8JAAD//4NB/DtLfAAA
`,
},
"/js/bosun.js": {
local: "web/static/js/bosun.js",
size: 99739,
modtime: 0,
compressed: `
H4sIAAAJbogA/+y9fXvbNrI4+vfpp2C0aUTXsmS7Tbfr1MlNk76d07Q9Tdrd/Sk+XkqkJMYSqZCUXzbx
d78zA4DEOynb6c259/J52ljkYDAABoPBzGAwGo2Cr4tklhRJNk2CdVQtjntRNt8so2IYD6uyF4wef+KD
2ivyTZV0hC2jLK3Sf7eBT/K8KqsiWrfArfJVklWdgPbiTRFVaZ7tzfJiFbUVij9vAdhkcVKU07yQ2nIe
FcEkLzfZ0/U6OA5EN67yeLNMwr741B8E408CePrZ/DfsvP6A/SSAZ3lWFflyCdjF+9V8WiTRMJu/xD4R
b+En703xZpMOoyn+Otl59ImobTjNs1k6D8f9+zRSvxb5eQq0AxX9+8t8Sp2ivFxU1Vp6MdtkU4QJQhXB
IDCKwyu58E7wjgjDx4AdLqrV8uGLPE7CqtgkQHENqlQzrN/jc7FIsrA/ArLeKe+rtFomR0H/eVQuJnlU
xLxP6u/Jar2MquT3YglQ66io0mhZjmIBTtRoZab1SMiIn1XFsl/DXe9Y6UuhvtJJ5I/saxcCCVErcYSw
E2HJ5bpw0vUtfEzKEgapG3GIrJU2RNqNtKLIC3enfcs/dyKMYNtJQ7BOtM1h3i2cpH3PvnahjBC1EkYI
OxG2yMvKSdcP8DH4I00uutGGuFpJQ5xEmQpTJMs8in/JXiZRMV0cBTNAmLQRX6ZLlKhO+l+K712o58ha
G8CRdupdJjqd9D2jz3xd6UYlw9hKJMN8V/0cTRmBjmY8nXann6FqpZ+h7MbBaVnlxZWbOsBYBT8IqE6M
zIDbeZnBdSJzvXHPs+dRFQXfAuKO9AGuVtp+3VTdVppsCqtk5ibuxxqg03rDoduXHA7oJzKvFklxkZZJ
+E5j4zgtkmn1KgdUI7m8pAbIqsQwzaqkmCbrCgX7elMuQkkvebsT6PirTZFpL/HpF8nbTQIy80jSa9ik
1HFIzaYpm0So8Y37/9h7kWbpushnIEmK/gloen3UYPqPrMU5KQyLCXKtvLl+ZHTFtaLMFZsMNTmhTJG+
VoC2/HKarxNVWRMwg6CBUDSy+u3wfg6sxNSuZwtQW5OXm+kUNAEFYXIOwz0IppuioD9AVzhP802p95uE
l3gQ+oeXGd5ndbD3j1ylykVeVMs0O4OSJN8cnVKr25LK7FK7Fa06GNd9Kr0fNvwd9r+hjyR/A+jvkncv
76RaTaY/3vpGgUoOuE7L9WP4561zVMoPMCIMJwi7ta5rKxOOgaGIP8dRayo61zGmsyC8xweTV2+bPpz3
s81yqY72tYFNRTbEVS6JXzVCKjg+lsRUP9gNzuG/PpNTnrrfBaw9RwG2XJ5gJh1Wcq+NDnpTQp94u4cj
+s+Xv/wMvV6k2TydXYXnA0INzAJyaMdXw6TKo041gCYDG6jff/vxWb5a5xn0XIhlAd6LnxW7aQ3nXtwg
YE9nRb46XSn4Vzp+nL0FgGTJRfAbE8rhziMD5C0H+e9NUlzpAG+HqwS6dwowK/VLMQSMRZrwteKtVpA3
rvA1ZB1lyfLZMipLpSFlFVWbkibbLL20TQz2BRj2ODjP0zjYB6BAvAx6hHev90hjvvIiraYLgd/G0dOo
TILetIA9/zRa9o5EKzjq3aAXo6QoeuYqw4pusrMsv8hsJdNsljvLXURFBjxsKyc+uYpmaGyx0loygeYs
SXu4rRoZJ7Nos6xsRdiXnmvym4N/Hi2BI2G43pnfyqT6r+RKYYqz5GoQUBkbQ9AH4ge0Gs3SLIlt4xsn
y6RKVArGgPnEJ7MSWB8tuEwkQC/96t4Hc2s7HXLCR7WEGqd0OV0kuDR/ly5Bp7MIkFmRlAul3hmB2kRI
DHD33w5jNM/p4kGtCBFqNUq1Rlm6gpXGJoLQlkfrNvYIbqfW6SjCXUn5hCE8xuXIIijZ1+D9+6DX29kx
xmjIp4Ckycawk7CxhuA83iAgCCHNKcDhqnSVRFkMMAJ0+ApePc1i2KoklpkDnV7my3Oj+dcWqmliSjTD
bys3A843oOLTdx2r+ns9hDkRLZdXoaSp2CV2PATFe5UqOqHGXf+GJn++r77Mi3QOr/+6r71fpvNFhQr8
X76YRIfx3/rq5zgqzujrwezh4d++1L6ukpg+fv7wy2RifAR5A1+BmhHVrn6dzIsICx8+DD4jUPXzNC2m
SxI/Y6UTxgcP9wcB/Q9JO1H3Z+OH3q/0gUCo1dbC1s8nWgefY1fGn4McXOL49v+yzOd5X+WUYbReJ1kc
9gHa+FRVoGEvEqwG9Nny39bvF2lcLdjnpn7Axqt9ulyGfdxCDidGBcjw4XjcNCUY0zgc8o450eAT3FuG
jgZgHfYWTFE3QN3fpMBoQksPIHFWmOISvhO32D9feT+DAFoqOwZcd+qpND44eaTPcF7wylNqn0o5xwTd
I8M4jVZ5FtsHRjDiVsOAaO29HBu0GhIcZ1L/RYBiOuYTDjcP9AKoMeagKHeBU3Tf/r0MdgFpsCQkFzW6
Cw/U3tZg/M//07cKw1Lex3nGHwSV9TNsTfIz2sxeLFLY1XqA9gQvHwiJ1TIrrRil8f/8JkzQYS56WiKa
MHzon479g/39T+0oeIf6arl0Tx3BR77pw0S/teP4qrBNh9mx8S7zUAqTXCLWWtonIg7aSqMP6svDYc1L
NxBeh07hdRO2PrSwNUqAqoiyMsX6n3M7P6oRDzU1giuPz/JNhov+vmlTYQCKTqsLKhnJ7u4jYxehVnIc
HFi1rvypXZG1Kvo1MVIxm6VHrtpta/FtU1BdWGxms2VSs7EmATtMA3yUqaBwxyBIJQZJDe6g0s14hjbc
fIxDc9gt0LeaRjKGm00lCUOnqaL1d1LhliDfVGE9+AMLu8u2HmMjDGq6wtKgw9v4B15r1hB6w427FmOg
BQ8+7mmmkocP7YuNafOYqvci3tvrMHFIqUAzNW4NQQOuTdb9HdSPjI7Cz0nmnf76DpOX6e9ssU3E9tJu
L7UaGPAhtENukQg4sN1z4TDJox3VXkDiKXc7TWKg2Eua+QD/Gxp3QtrBEGXDZZLNq8WOvUKdqemdc6t5
rfkOqjKe4H74OwoIQhXxn/CMXrwYPX++98MPR6vVEegUjz4RUUbMiFRDq8VrMHS7oNshaRyuRbKM0AaN
nXMkdcdsAxMU3vTSLPi07DU7rnVUVvD603IvmufS+xJfxjLkit6s5DfmqwW9WchvzFcxvYnlN+arF/Qm
k9+Yr67ozZX8RrxiA/AJjkrNIRjbhHMvP0uTMItWCbekIQ9c1YZQHLDkcp0WCdd6Ga9fKZZStmendRZt
xs+1dRA/DTmThvRjzn/sgJpN2EDYHn4B//tyX/wPlMF92ZrOiUBL7iPx47iHOwtEWOXfv3j1kkz+ombG
kJqdTsLSk8HifLohNppSf8D3pJxGa9YxSGWP6uIvucVxt0a3i0RRgNoI0F43nQx9HEtdLPcq/v72v601
PaqBpuiP0IgblutlCuLqkXBmzPICjZ1FkJJ0hn++hoJ8CsPP3V19sNByP43GqSQyQWdbJkE4HU4XUfG0
CkFg49oB+yF1+aOiIBsnzMESHgzgpyEtkEumwzSLk8tfZiFrKkO4v2PbUm0y3gsyalaMI5eqUQZYcR5J
PZ8UUZlYut7C9r3eINg72FGKA4f+XqKCX8sS5rloxrPPYjL2NgDWVwuXvLCzXqXsIGBkEMcjntEoQE/O
UYBL09FoVFbR9Cw/T4rZMr8AJliNotHBw8Mv//rXh1+Mvvryi8PPv2w81cz4iXs2KFCqXlGtMc0HCneT
mYSrn8yjm5ZPiyK64lAOQ/T4xKaxCK2QwunKZTqFOT/kpNUT9REJJq9fWAps0RzDtTtY880zd7HFI8w9
wYqbHoD1KVJSpA/qGQJyyF6FpusWhxEgJeboSQPcMwtUV2uUMQwh/TJAsrxKZ1fGus+/rsr5H9EyjZ3f
QXGJ5okk56SP51gSmPFFOferRkZd4T2Fuh20sYdalfewTrurErmKt9ni0cBeh9dl0zHwy9yPGWwpYbQp
PRzluAHzOnaM4e5DiT5zIe9YXRjML1XPaawP4PEfqxJv8RxxRJxSxQ2kovXuCjaTVVp1GVBp/PXtKgsw
0MZdGmTG6TTCN9uQclUBlzWz+CuYCEfyHBkYIChXj+R5Z4K8YIx4pM0FExC6tzySO98E+Zn4/EidlGrz
1NYqYl6RAgOFaiHt5bJsK7LOy9rbJQIIaeNh7kK3cGTVXL0plhjIfTOHU251OZFTjn92e5zkbYBX1stB
mNvI+v79iu2C6O9yup38h395cRqoW60HuHo/Z/owlzr1G5hL/b61ACrEagF6Yy9Q5Sp+/tsFrOLmv+3A
FPAHEgIl0S4v0LyDMg+NInFjohMl6ldQQI3r4WVYXN5plVzSDvCnPIpB5RNBf8OhSRizUiXxKbFb0xr2
096YZBWlywaU/XR0Eo95Op0DO6ylzlLfOzoN9Rsos45Ar6FTARauqKKJhBZ+IC7YPcDmtjRRRtPk1SKh
YetPF8ANiRXmBQsoYtF2mi8UzwlIjYdfFhPkZJMuYwr2/Q4qwVMDdlskFjeFhE3g0+YmuSCcP0fUgl6V
lHoYCG1YYgzNOVA/jEYz2DgEEWwK0rebhIkX0pEVML5hkUdg3CPY3kmz85Do2EHVZO8Au10tJIbYX84m
+azNhD0ctMu0kMBL3b5sro1iQrzOXmeCLnJJKVWhc+rd6wzeG7X0/wMUAQwAwBX23fCnqKyGLym26fr6
CN8QliGiub4OgAHg1ffI2kM8h3B97cI6yWPURv/19foxljVQucoB/KtoXh45v8NMWCaPXZ//4927Am1T
wf0zkMvnwdFxwMh11/gfgLN4/HUVP3737v7Z9fXXI/iT/zwXP0cA4qkzyWJPk0aM5n85AK5x8Pomtyf1
OR8Ml63ySUiTygRcphnZKJoCfM/fe531doaraC0ty0vJ5rwcws55BbLHMNERyjH9n2+jg73gAKOTKLIN
/wWuckCpqJRmMNg3eZohcfi5p9VMHI1uVjaPt+PlegocWwu6ivWZbUaQ6Ya8NgbKsj4B8fivFc4v+Qmw
6mSbHY2mUdavgnKKelCQxGmVFyACK1ixohnGM3EdKUjLYLNG/T0eBs8x/gq210NT4xOhS4juVR5y0ThQ
+tCnrplLhdxGy96NddkrJsDMbjTZvMBhHf3P6/KzkIh7L0b7PenZKVOz3i9Bmd6s368iaMrO63I3HL++
eL33evj6/sku/P7s9bvRfGViX0XVdGFZcviAvdMUd3UBwQ3jiRWgWSzcMIxiH4TcQB8cNdoKwJc/aiXZ
HmCBT6ZhMwjWDRotMcz4QCXH+uQWQBlb0RjQoQNomZY41oxWRGuBI+UBAV0OCY5Eb5/aEYScxE1Ztfke
BFIWgpxZ2Nxmv6J6rNtrzUHEevjJIioXFIAo7A/4gqmHWsxhx22aVTE2ww07yx2bYufe7Gva9YMHgV2x
4iZYT6ykrqZb8SjeOnNMPjaZaW2bT3jqwSLaVtoz/tw4gz452hrgykwHZoNZAnOx2SQdBdz7Ecn1GnuE
IiEW6WIX8vOU5oZlnW3bkvxEZ0iUCk8ZtF4vH7Dj4FTHJmGsgWww7B3OzpdsrQ93hsz6/vciWttOuUul
ALo3WW7QNOPnM3E4KFqvl1cdfKyd56g+Zvpv3fV9lVXRpcvmizvGfD5fJj+k84WIsHUTS8ZYQmhrhqNj
qUctjagp0w6OiafdMOhoWxstJuXohjsCbXOajFYAQWeW1P2yaeY7PyKn5TDLL7T4FMdoaJJC6WgyXAay
76euprYj/ZbMk8v6FM4cpHPY+5/XoMzgnKYFejfowe9d/M29VHNds+b9grvlUEKrn0jFZxJNzy6iIi75
0WWzCy5gvrDDWuY3PBnyMqEIFTzR5cKwyJfJ3/MidkIU1FJWi7OX8UHeZGoKSD8mhFuXHFrq/Mu9ewB/
5BYuZSDNaI7aEwu8+O0ywT+/ufoxDvu4Xu31aee/w5ECyhyTABj7gTo25SJsPAjlOI1P/LwGBdQTUYmh
U8ErAddfMpOaakuT8HlOXmzw3F/A1J1is0yeWPdONC6uMxj2FdOG5gGaOl1osEForHRbyoHWgUV3upW1
fF3kU7b6lgzGIvCAMA4i4nle4ijun4jXd2hgFyshqQGwEOK/7ejF4Y5OaxsdUrW0kx+OCgVndVusGr62
TiybXEQuwA0Hi+bZVNNQN6aL4GzNZm7h3yq3YuJGcg0Ps4bbVGOsYZiW5AQLydd5r8qbF7dwgKWzGXYI
4se/wyq31Y+fbl6JYsjXjftmbQ3418HhDYNNsVmjY3JtURiPOTKoFr7AkwrRpAzpjyLfwPLFijY071j6
IwbK7MG3pg352ibxJD9F3MK2UtTx/8+29eD9GWwrO5O0cbOwhAB2cEZ7lRavl4c/6/pGjMlHwOT+I9+S
bqKF7NJ6aN2HGVto+ldbAXUvZL1Xte1NR6PgaYWWqwqZjNwr/5JMq7M8/xfMvQB0t4TYEGYA7JeDt5t0
eha82azWwSSpLpIkq/OXBBG6aLCqbTVcKiRUW/ph021lM7i5usvmcKtyQ5T/JxD+KipAV0M6jGQItrA5
2fRtRM6JpwljoUYO0esTMtN5emKdX0p1b9BkhiegHsGfepVv7FVKA/lsmcN2flKARg8Ni6qgrCLgknxG
mAI8gVqCKhXjG+pe084hN4Tsr6+vRyu5GW/czRCPbWrJj2mTEw+JTZxVwvoreAr+PEZjsGzfBbrIrlnT
5a4RW0N420h38kht3CXTCuGyGkj9bTTfXnfej9Q0tS48mJNDmhxaY8QEMbwxlCgBiwr/zr3jmy73urWM
0IICPGC0Qc+56sbzGcdSd/cke6O+Y3BqrJbhY/Ky1yySKrIttoVJJXKgfM/DAZrRoEAA25AIWzwBDOlX
OHoXDj/buR5ZuoIAPA00IhLsFnvnQQmcMqfMx4JT+yh8HcN8MtoqosE6nJKQQpNqYUx58O54/yXOU/BI
M7+VzWYwJVXHkqqCinWzLXeoxVHB9QAPr+rBXfTFeONII+Gv2J6DAB/iQrEfZQzIucAhN9lJHTWecrWD
0zFcCQnxGHQrXw8J81xe5T9BZeHKnPnuDtCPjdx+l2zpMJZxMhBfsvkRadLWfbRPmUNu72JIFxv1vt3y
UmwyTN5itXVyEJ7fxeIXM+NTxU6jmYdytJktbtWKArcTKgoRJdYJBdulNAiaiLSOxdX6mxi1TsVr/R0w
8GMguma/0xlZXKeW1HCJD91RUcRZ06o6AK1bnygLgNQ3RkiaOzjZY+X76LeutknOia5yn2ZCuNr2vEQy
omvFpG2oQTi2Iq/JVLvF64jutsVWTDuWHTEhOLaft5R3uV6DSX2Ks94Ls03919LZrBb8h634/eVbTFZm
1308RmsaPZbuHLnDVrzKXYWBs/xF6w5xYZAknq08yaCWHiAYB+WK8GnBowL/uUZ8ybciW+hNxURIShzs
U57DVpQgww3PV2uWrM/9/hCVVk2e0BtyHSNFeFA/K9lFU2zxSXzs/oVG53F4iD1+CL9S9u8LNVGgK6Pi
OYZCLKNpEo7C8eDddbhzsjOa41GBg9cbUNgn/tyQ6E7DZQv16V8xlaBSaYJZiAeBNWHn+TCGSSEi3HH1
OB86h6KDkbQeJ9OkpVZl7WvKm4HnyYlk84gVpe1aJ9k3aGBC2+NZHRTde2ez0k3RHmWDvrZBR1K4NACz
w5548Lyu06ZdNKbKugyqZQ2duwGeQ60p+TA+zaiJCN92SZB0gHPm0GxbIDqJWQH150rW82ETYs7kKvtp
TurzIQ8bxxM1Q9jtlNXT8odqtWRi8xv4eJdy7PzDiDB9Vpm7NoeEaiJndeHtMPx36FYOum2/ih0MO3qn
ZcilQphN3ZEpV0IgOpiKsLshWjawBPl39tMeYMlJyy8yFLLs+Fer/XOyzCfcvfAN/BmOTSY/GQTvKJjm
CE2Nl9UI5kqaPcID7qAVHG+q2d5XPTNDS3SePC1DxD8IenSuhpA6zrQqeTjZ6/YjbuqtJh1OubWfY7vN
ebVlzdriIJblKJXFpiH2hSLPpzi7pqX7lONM7RlFdUTySWr2smc/+mpaMghasmPUuUC1PTK70UHuDClp
A/tkJ5LnSQ3VBg0rvBegkyok9bYld32LCelaSURuTwF6o3p+z/BMC7kHMc6ULdRlbSjzyDudHUClwLms
zOD7lDPdph2xL1joGR1lg53p59YszMrBWs4UlmHGZA6Ws7VE3825RW2ocZQVEy+wmxXS8yTsVyUX9r7s
C00T1TshRnW2dX42UL8TAvMBydcocIEAm9bVIMDEVEYWa76TLl9Sam6/tixRiKIznxEMpQLJaTnSGVLn
BDmdg9EvqLpsKhqEjp1DtB9pRE4lNNBlxzpiBbii9D/9Y+01u1iCPjQtGLQOilz17UeGXMlsq5ya8aL4
CJO+pEFKBUwmbz7+GhURluw9QPcOy19j0UyFItrDLEx7L17sPX+Oh/t3oRxiaS9HKZt6esTOtYUD2/Pr
SyzQKcc+1eTgwLqa2aqO52lqlKxtItFUDQOL7ypdLtMygUU7rtMukNGU/anYxs6ZYUwziok0cFCH6Kp+
WY7Lk74tf40CFo/jk8VivDhZrcark7rQtdIkSqCkNKdhE3gv2xvpQA9FhfLPxtdVyfsCwJjhcSV9jea5
tIowC2QmvSFvJsPwWDM98qL4b19utmYB5PjSLOhbOqexppEpOaRA2wzP9clDyyhAEKwUAHf6Sp9RGL6d
EdYwOZMCSRiRlzSM31+9z94v3q/elzuYDGz0SOllDs9CE8S9DIJYjZtY9D/OGPSLDYLV+PCkNkX0KYXB
i/4ODa9FZvaqEgfaekTBkJU3XRnuX5CrkCCGrMJB2yz1MpwOyE8zNVxrt6UJAr7NyNTisqgZU5dLRFAl
oqWBZEflZysyKdpPYihiJ3spcS60R2E9dBDHGqSGj2nLa9qaocv0zNVQHLghVhXSnr0Lao9DmU7toBGk
ySdGOhUPZA/7kb7na5AO+QiaBzklmAWoxjiLedqqi4sLOSM+Ja66yItlPAU97AwjCM5BxUzYHZBP0jI/
dlzlJFBDf9eSgHIGvnjx/PmrH35YrTyEi5L9B+uD431HDcIFDsi/jWAmNIsoJ16ZDoPAOWJmpXREEA1U
hyS8yJJzbqfCllaRIQQ2wE4KE10npWItqrlbIQPh8jLNpn+udKEa7068NHNkRQ7Kn/EIT+u5Zl+f5Pmy
Stcfqk8EqyV81uG/4/0T2ECyesN3AS0N+PEI7Q9Vla96WzUB9OxX0aSber19A0ieoxrHKVe7moaD7wBl
k925NZQLBSF8Gk6rYvlfZkYw8bhiDU3xNxoFrxZpiec9yzwoF+ms2qNM3cE0yoJJAv9s8GAcbHOLTRZE
AZqC6U6/gDoNC06j5TKJyQdrww8bfVZqHc0TZ4uU/Swa/fEl0XMn7RS3FklVuZDStT5/O3KLK0CBN5hB
Nz1nqVZt00w8OPrnuBBEQ8u1NjokC00l6FKkmn2J79zFBGIodS65BwgT7UpeU4aV+hv74MWnVq2R8y3F
oTJCd3WvuPz4Al6pjw8+d3cyHWgzKLlnkPLhom4/smGmYpuJdZT9pZYRBWFBoSH++aNwN2EsuH8ElYBv
LMtivgkTC3WDeToaB6+rkxGLhoZPGNLNIsG9A+OnmVyUWA9vKlY+gMr3iAw/97bMhgxnw0X5AacE4RcB
6neofcAyVSRl+m+0O3ZbrAAcr52r8HpayexiNxGBFMdTrwD7gEIB8cJ2m6FHWwHRa4Y6eYeVkNa6ugn6
dKKveJ0kQSTo2NZukQQW2KTOAwbMm8Fb4ZILKpT1ePltxucVNuxlXlTMR9Hk15Msu/ylxfShkry9poHP
FtG690mX2hlScqYSs7gXluPhdc8BwE8p5vu2bR7rhttnvTUB+i3MxbhRxdhZ6zQQOdPrDOjx57Q14Vsh
Uox7n/5z9Olq9Gm89+k/hKtEM3xgFGBpGSXZsLjDI/bUHNostr2Yp7hBlszW+fooONhvZlKBOQfUV0x9
PQo+l94tkxlAHT7c/0TqnDvbbeAhVaJTy+8jvIPLZbTW0mGkg8AVv6HhhcUASt5T39htGa6oEVQFsTL8
Q8Xjn+MGpibmpHXS23qC78r6StgT8B9Lk6LhrPuKfQ05uEt23fN8x6e7nks2C2gnc1sA4/MfNQX2zr/H
wTzparajQ+BDqSGJomgQTPzIgwj1c347AVqyoyIJJ5SsuF2E4MPddHUf8L/sdrb6+kxBr5oq7lxKFXfO
FTtrpVIq5i6YMIjIiWcSFeyKJ0D2kM5MMiqdGoVcgGzsqzQL65eD4IuHlprMQtGlXOjAVohfq/eDKKgQ
FnwmId3lAnCIV6/UP5h0s+OtqWkq2JOR7HVBAmX/jjcl8d32kK5NchlZLzhkXaiuAiVu84vEtB3F5Utk
U2mJKfE3M70MKQ9jiNf7UU22Mx6E4+llyicrXi4UwS/LnT/4MOwhq9QBkgPzoW2S9ZLNzkcdg0dbjWuK
pV4M5JsThcnFXqP7BsUGRL1mkPe3F7i5dFCwQ0v1LZXTjUGoAKD/gH6gs5I8I/Kg7wb9QV/n3v6OrR9p
sLpVXt/6dhng8AbVcg//vRHF+0RfPc3stDEWGcb5KgJZMLZWA+OLgoLNYeelTAwoHvKYXhluKsE1KtOU
5x9B+Qb/mUltRN0gb9rrBqCt6hZODHf1rmm4TOYJ7eO25fs4Pe84+jDsrBbbkJHWCqSf1oSwP25cOdl4
+T3H+yeiE/FPy2kSQQHTbu6UBFwXsRftM0hczjq8HPqmhPc+NILAPV1IstTRNAxj4+uLPG9NYN25wVf0
gRm+bN2M4kN1yffEDWFpdDWOyKfr4liIMY2ZGC9PEduNigqA5zpKFU5hU/tkROale0l5cmTrNW8aRveN
c0w+hc3MjRlT7nRBi1p3KmsbrSXqxaR7EbFYeW5slR93u2q3KigU7mY7ds1uKtFQsso3ZbLKz5Mh9nT9
6/SycznzRj9nSVkysIldB8TfkPzpMp2e9bW7Ed/4aGAp0NFlusYdHYU14BpInPnGbcCT9419djgQi55Y
Y5NdBdO4Hd6zkW2zVLfsWmOPfdJtxOZbV5aH0YNh6xvx8KG9JgbMhr2/sCTunhrwYTvNNrT4TPOszJfY
HfOwn+U44YE3XIey5afN4I+Pu7/wuQ/yolotQVjk8VV/p87XsA6TYT6bQVeFaPbRT2cpFThnRLc9rLl8
LKNJsnSujrR40AU69u++laJeJXBOt2ikALEXZdNFjiGg/cS4OFuDR6m074WIEaS/N3yYrPyoYpRU/eFh
K+CVLlDky1ZDlBbDhzvy4uFccZiQc6im9u27OW5lsvYOGtPPbjNsnsW9c5ccdOwRbTU9uOXoizX2wrMb
9K9z5hDUDZXAnJKMtt8gwfh2KaUAmxD3HVg4rBagTNpVV3wkbd290LFopNoaHV7aFntXvht8HP4Hiq1c
Vb9nKR3XHPdxfpyx4Dj43/f4v1f4v1/xf9/2T6T4zgwKhqDP4nW9sMHezGbpJR4oq2oTMf4NWOmf9+9r
2zDFRQY8Qe93sFYBGt4cSolX/hz9HGZ04pvHQpcsEpodnelbrOmlbDhHJFgnSyLWcEQmjFQsuVgm1XlP
uvFYoKQGBU+C/j5F4/PfR/C7byEW872l5Xcp9GQCvw10oF00rY8CKd+ZTEeEkZwH+qGSbLOa0AENKjNb
5nnBwmBxYYt2glFQ/6JLvSXeiDAzIH1d5xchGyoJC8MsF6B0TpwjxuyzYSLnXXEc6IB1NxnsVjcdmxHB
wvddepnE4UOl7V8HB8neQ2V4ObTtjlF24Q3amDAR3T6OFGhwR3V4rLiiEkB2g3C32JGouzZvbkR27nZt
o82dIyYDnoGAmYKX4QrRrrv6RIWTqyrxRuN3rfHwC6jxG6wyIM5mmX6D1vpT/0mJraqfdK5e8sAl6IZP
p+jlJFDJ1Um/b+DudPiq8dFdW/cl35bllAw+dTKEFE8h1AZr62sQABwTGkfK6gqWAr4SWg0JzD/tPXAn
HgdeByX2ZcaNo0dHDaTPpKn+IEyDvfWlJePStd0ijC5NzO+eZutNhYpMNscwR9ZW29kg4WdmELjUt7lz
P3H7c78vovWC+cwv0izOL3DRQkb9Thw4kkafQQxQhpmn4xy+V3wM/ys+Fh8sPjY/LD7MF/vVvt44QmVj
a2usBT6o/llO2eDDBtjxEdSNpIiqvHB8nxSbckFRKggwoagUF9i3OOcBCDV5EyShE27fICBA/V8WiFV0
6aBilWaOLxnqQUtgGfUkET7X/mnfLQCiduv9aLsrDZ9mk17T4lYQa0SHXd2vsoNsl9WzqAXNwcP9P8H9
5fF32T9dSX4s5sJCA0RUNF4s4Re0asNtrrBbO77avVrUim09aVddPGk45Z1m6XR6xvPeopsEpIgYyFFw
uL/jKcW3A40Mc3glYBgshnMezcq4q5YI3ojWflQkUd8dcUnJUJu+A2CfwWgC38/sn2MWLdm1JvzVHoeF
DznHURo1hemna4wvWzylsLOk8mgXxn8Tm/2KJetafwh/aHcXp7Jb7oOm+qlrCjDXLRDsp+1Pd5bSqaFk
Vmr+F3zlJIXDTJfp+leYYX6S0xhpRdg2fO0Gk3pguK9gK3+SD/E6p1xTexRVTC7BaLlscx6m6z28ogWh
8S7iv+CbO3ZIfzhH9E1ouuI02bsd+wLZiNnavI48A6RjlzCpYEEIHN6JjUhPD/v5Opqm1VWrHazdUtaO
Q+fZLpJEmsv+hkw3RclsvpyDXQ2X3TpXOIrsgiWvy/2VQ7qqDmaHCrHMp7Wb+pU0Oo4yCC8aNUP7FbaJ
LfCOYCxkBX5FY+da6kJGVbTbcNXliUBoq5G75cRwLUF1w+pAXbLyMbt9cskS0wiNLy9izO7TqHzWIe7/
JfniIDqYWjR79vnzv/41mXzl/PxFHM2+iJyf//bVF0n0ufPzbPbX2f6+83P05cMvD911z/761cFk5q6b
Hstnl8pLVmLcGzh0evp+5f6eL2NP6UV+zpLE3ECEUtkW6WQuRlmeJS2F4rRcL6OrBtpD+69YATSAfshq
0dE0LYBH/W1BBnbFIBLG31jmJxN7+wIPKjdmEepfLNLK3wY+9c1KfN4yMevzrNqjYxSotB2uL101zfLp
RteMuo40lb3hSFu8J4itpgFVc+deC6X7/0kKSgprz1BY79yllcBpKZPx3at/OHYYRWTcEoaPfcuA0D8J
0Xo6rBYFbCKBksawUJsBYKfvcxXhXWllvRBofj4MEWoN8GmSijmD3uh6cLt7ER+ioXvojzs4i4GpzCRa
4a36Mq18NRfkdHPtHWnRTg2XG5OkjjK0aJMfrf+KpaZhiSwoNcJl6oqeoZ0b1pTi7XMEvMPvoXEXgF38
c3a/LosOFgqut8TPdN8g/PEM11Qv6D8I7p+eDnb3bILBaB2jdVikDK4uE8zKUoUxz1fnO+dGbjEo9Bi0
AgJvOQ5Ql6OKlCJ4DfpNAlZETEmjApET1o2KtgRVXf0YaPFcQEI3ajhvVhZPIjY+aUUn7dbVWBYRvjtV
WHFiVjaTcWdUcyx34AC+gxMX26oNa7zTWGr/RCST7lIWNY+ruuw2LWDl67vHyrcwRWtXJBK1x3WfAWVp
8OLCRyp7JcpeYdkOAUNIx9diXnaJHWqmMBRtDxjCSUmwl51g/0mwltzGFlietlVnBBr+TgiecR2ddHXO
UC1d5p5ajst3PKJcbCewdmcop0qbc90iDaptIfLZnXCYaoMTjoPL5FDXRvpnrYwxlU90qq8c6nxuSlnq
DDa47X3XrVqS1uVv3ANATX3MF6CRzfHQlPmGDOKs0D+hUGN9vnEDG5uEIOlJsPcwOAJtvK0QReYKmqDU
V1DqoL2YGlfW1EoRZhgXwJxYns7LKHVE07ph5rh3WRSYUC5UAELd4Jtv8ksXcL3V6NJhk8kQZaMjLkrr
KAC+6gTcRC9PhrW57bBzBDOUErrMoU8ro+QxKNTtMCiLLwVb+uSwY0uLj10EsU2HOAjANh2tvX0ALfPF
OXOww05gVwdu+5oMduizCeND2UwuK1DPX7KMA34Njc4LNuB+vYUBYq6Be0qp1sBiSqwEnEaZSQUS/yrC
y4RNkeeYP4zniHOVcq89jUWMxKdLobNcdzQIHtq0HfVMLm6oXEdx8SHvJwYkabmEeChBG/72OA++Fl64
Dxxei1iKQWC5YB+fi+EkZYZlbjNor7YtvNu2GEtZe7EeN+6uRynxIZe6KPC14zYV8fhCtO0sdMuTmvjw
/WaHM5kEjZ5k9bilu+H3+O7V0+TaUigksWNzZG8+2YXsRyidLtjSGmPray3zZQut40vXHmM744vfxMn2
pmy7x/5W8tYrdhHMnAUMTSPu4Wp+4N6amAAfGjD9BrdzigI9F3tX13VA4tmegcVc69JtdVNYT/va0ZiT
7pbcLSJk8PFHybirMWO1vWdOmq2+EqDtXo/qWUdb5xa4Kwbn25k1lsRQNLnzQoZPM1xadgBmEHSeJhSN
X0WXvPV4LLa5g8A1Yw5O3Psxao9AoZPTcgyLyg7XGHqBlYC0QMrIMoHzyGed2OZkDD6oDQ6vHDKBGzfi
sRiNE88GlDBdOjBdCkyShcWJibRldrQaI+/d3cvOTnew+YpD1vpwyqecp1wA4n+cRrsjS1QNPNKtajpj
fSdVO+YOySpcCXxMxVcK3rHOeWifWep5d47DM3xXKxq7ux6hg7qbfFXLs/jORqieAu0U8FTAIVGyR32B
hnFbZCI+3jvqxcNxbqXW0CDsHVNZezmicNcHgcTV3iIfgQSIFT72r+01Yc5NrLtB+NQ3ARLtX3epLPLs
mN2V2d8ShzWyCVsyoCo8U7PRhn6mwyCcKZEtfMTzauhuahHoCmW21TNctUeXnWqv+V4iInKYMBxsqMiO
K6/saBSjOugStUUWW+kjl61j+zziNNx3Hvl2bgC6JUrApz1ZAkF5EyYYtV7dZa1XLbV2OJJKyGiL0yP3
ZW8Q9K7olGyvtUBtZsZCRV7hhmHvb/s77SWvoMRea9iUVOASC4SNVdYREiyViLGO3kGy8lFDVpTT4SZL
34ZOrVLNOYXHvXBd2Bm+yYHPe48C4woK8aAQebsRd59QwJ16GLnFRHdHru4to5zx6RTpjA9vXqsjvW6T
YMm1OxJVhafdd1kV+VnS3XfSFW/tsW8ZirqY6o64lSdHPJ4QcHxaw8Dx+X/XMGwj0uuW3yqcgmNpkSn9
2Nl0ir5numWn3Cuyh46ufLrtepDAjGVG/8gVsOaoXnMQcjtdyPYZda6VZj9Bd/S4XYby2X1aZXkUcMtS
RlA+P2AjN7ul4ekUyEvw9dF4CvbrYi/Gh4WymeF8E7xkwsnDncjY2I/hbkOFKzCtMxE4W+QkAVuNNrAj
OTt8o8RprkUKBqXOOhRA0bvXRIT3hweHD7vUs4jWyV4BQi+hI/R4yKGA/vo2nrsjtTrupbvZs0z5ZTfm
eh1ZDYDV99R8fm7d6tVMxQ/qeDM6MEQY+oTAfEhdElSiOqC7NxM8Hs3eulM/NL44o8yBv8xzfmG9fA8T
u7KjKc8v4FFeAykuda27WbLZvkhnOynD7g18i/yKsvq4aVdfplSOdWAHn2SXPEYW56GVz1bQ95hCCi/E
Gb14MXr+fI9uZDuCpdzDeWKYnWF3SnpoAONZQPn9O1jrFpk/jBTYrptR6UrZrrei9u8XIKSTTvejwp8E
LDfXuChTzYbFrlGeJyBR6dpouitT3zN2vDdZvm6TEpxoMuyUlaqT9CmXfA4olNI2UPBxyMOyEMQcEAR4
uVnZLTL0kefLticCO8Xq+T2/NuJQ0XEmC+BV7x4zc8GzfJM55hF9/y4tSoprDZTbDtVvPmv4T5GzvPjU
0amsjBbzDOBdqyqgkktfYwr9yuo2lsDsB9TL7PZV5EZ2oJ6uFoO/3FVZ77A2WZsFtStEixuT8YCTkv6B
WM56Yyu7rBXvMvi1gMV/ziS+3BEG+iqvoiUmty+9KSaUe5RFz+spok3sTOVJ4vYKRPz0vj7xlCodM9B5
eRHw+HSRTM8Spxytdndb5aTGWeL+VWvDsR0gk56xWlubzNN4m/LmAzcb661njivSs1M3ICZnT9DZMKUT
KG+cPtWaC/EVUT4I7FnmtrgMn60qQ/M6adYiE3UX0UCIreLhGbYXZzSTyTYBoXelOWmo02AP52UeAgrH
PRAuvZN2dC/5ROzKkA0L653GKqaB8dWKd3DhRS1KhSjsB4GFc7HmTYEt7o3YFfFPKAMou96Wc+gjowhe
AoaZTbdYkrAWvBnygShLVYgf1tt2PQheiSt4DQSLBV27a9LMrvDovgjW9bGCVBv7cxtiq7wmVStsJZTP
bShujHEHJfFy/afpiJ3v0idptClgayvJbbzoQ5tWDASj96p8EvIr8xNokczt9V/TiN3zZszOGo18uXtT
jrycHMiQhsY96Fg9htbi/cr96Hwevg17ER49hHE8yqHz15t3C5Cex5/RuHx2jTb9h+RvwLuiHwdf7ff1
7ZwepmPcEx8zLuU9QL/ev1eac7+5h7MBpF92QGwGHi/QR6GWGFnGlCEXRBVNpIrgB9bDr2E3q4uydCVd
lkNfjIUGSHrS186U9OlC7r79Ym2pd/SzKH12I7e/IN0LPhBNvM1mhTWcmQSiIb/S/pENsvGuEOh/s59W
UIb0FPMpCvBX8LcKi9xbfyKPpDjK514oy/P5KZPwvOfnmIRrhJ1FfF1Pht2gj8BPsvyCulLKQkhyK8Mb
RPnJOvfegLBTbpJnaHsL5T7StQBrP9TMqEzgln0E/W7ZSNC/9r7vVKd1Q2FDh9sARfc39xZlUnkVAr8o
kqa1Ll3MgjhhoKAsXGD2klG/rShOmaaoEDC2oi5lT1JP6sYKzgCOt2kjgoF0zVxP119oN0pg7mhr5BHF
wkR0NauO04Y3Hv6B1jXlJt5oOQgqaxoyfIjFSaUf71ZAFIDbjIO2DXU9oTuEpG53O1TGrB/9dxZjl9nk
7zFZutzkKpqfQ5ujufOKPSQdKxGkP1bTouoP0YOnDQaOkwV2/5kohpTU90Qjcd36t6712lIrU2G4gLZT
/pyMDeTdtn5H7fiIajHJMSsk1qajq7SammuBY6dH5TwaA79XWJEo9612Chy0+9xYwS/dRbswf6Vczutb
UhLDzm43aWIPv4rmL0naWQRn/YYB1e8ZNt569g2TlIYNyj/aEf7hRPeHjOw3kIi/rLFQ2YJTgrSjlgDk
GnDZv2rBTTDhW7nTMep5GM3nRTJnAUjBWxyrt/I71MPKzUpibiq1SjDHalOC/9a0QwItmLbJAQu+PGip
HmrIpqOkAuIlrg3JhdoLMuNRkXtvh+jiOo8wJ6jOY6NRgPd1BlNQ3mBBCRpI2ucFbw1mvleTZuNX+igh
AUEwjzbzpO9TROrQPr3VsNfaZFoeUk9NHLq9rk7YkA4nquYvC0ITGR876R1yRrSpcuueiSGQBj0urawU
l3xHUoPZ9iQEChJcwke/OPeI2a6Ag8B5Xsoip35bN0FNPU3Tabgu8ipHjZohcGpc9WBzijGvOfupDzV7
DbK2jFZrSoMplxNXlPB3tr50jo+M09y6cqFqa5Y8sPbmNWcKXBz9Qg6llMVCuxzQZrw8SCKwS2NAY8uO
wVw9xNozo4hkYuyuGEt8EsPI23YjpK6O2rrAC+p3a6iqUQQ02qT6g19rbQmxdraUZFpLOx3JezScCrfx
VY2YTlkxE9jXlm1LOocKjSVN3IreP1jsRfNcFw3Nnllo64wojk/i/jXs2/xcf4oYOd9LOxH5vvN9dtm5
XLVwr9Dt5hqz6qqzXG6cnii7hkFgVZ4p7BKrPtUKm6NTzyB2y4LztBtjA3b7goUPxEMLphOJeOJkmQDL
vE3HZ55DUr5DwM6AQUbnJM+XSZR9/ITmkzfJtGqh8xcCQt25DM93up4t/ID0d7jZHP8ROiubVvL8pu3G
b8kM5NGixeJMCd23Nzk7rkxvMT8PAtstA8LoWCvFJDp6oBWjGXaVZvRPhBHaaLvFf+LkHP/5d7qqoVYC
MM0Q9sSw2MSlXgOC33UtKKxP83pxHfdQKcMSTMQPmlVtwJdME8c0yp5CqUC963sre/2bxtr7pswzVY3n
HyZffqEz+BvNeo8gNiWI3a4gFpE3wZPgP1/+8vOQrpsJ3+wER0yrEJyptS/NYnbaE8F/RANv3ZpFhGmi
6ZTvvsWIPT/XXb5iQ4u34senaGRwQKCUvjpdax9NmxRbo7hMl5n7reXgp4qbXaKOLRebQb8JkS+jos5S
DccSNkIKvRIwiRx8JSYO8Aop93zQ+O97sECTzmDa9wsmGpoi9YtjjNbdWIrU54ubQtIrs5jEZ3Rszdpv
7PjWbgNn4zUZU2TYB+/XR4lkTJFxPY7g2pgH852uorVhNOqVvSP8n2oq6q3w7Up/u8C3C/1tjG9j/e0F
vr3Q32b49oX+9grfXvUa+tWZnZa/JegLGP1P+Dre3QlfX+ygEnZ/ZDHUAuSr/OmkDFeOoBQeAydC4MrN
pCqiaRVK90atMNBxoPTbeDU+PDmpI+asEqKmAap/lQMhobEVG41+zquAXSZDsgAt+KAkVYuEruwKGP5h
8F2OsaK0txoEbzYgc3qH+wdf9IKLdLkMJgnaa1P1ai8REyN5ivEeLfaLn3hgmf2hGUW++jk3ciVYYlXM
1r28iNaUsdBoHTv3b9Mg7H1vdqZapWgVRrwRDwyTy2RqZGjBao3RlmqVWMJXE4eWBs9jvXxJSi52gz9Q
SZN7dd/J73W/hCwE9QLw1htI8TSOX5Hfs5UksSKp8tx6kb8GQl6DWuR7yYG94Y+8noYg15IiKEp9GL9P
qlfR/L++uXohzIUSYkTgQE4L6ZggxIrFjKoyLDGbwKsvdFSUWyVNBrzHPngM0FzFGTNA932tNpeJ5nXU
YllRBSDfKKfBQLlFCBRt9FytN4klocPsYjZDmHiENfeUw76zOBpsO1zJzWTd2cpk8Hj3yLopNYgYt9yY
S7ZfMvL5dkQNJgYLf9vRuc8Y3+PlulXT38oRxSbLHyU5GmlytO288NEVRNY0w7eIlyt73GwA09okQIGN
AtCurbL5y94Kyyz+Y34e4UWGZ0lQbookwMAXWEuCaHkRXZW07s4w9gvLDl0zV9a0GxEi76GJT8yq3eXp
nTQdo0Ew8fVmRAonUu89ys3XsL2tch3UvoPJVpVsVQcvA5M5x6NvGOgSFUk46eBy7hJ3aQ2lwEcLp+j/
TmdLAthpUmw2l5glS35qCbbQidFFL5SPUOiMOKIn7N/jO5TGzdaYAgIePOAhPLCRdnKcudbwNzfq2g4d
C/+6O+5a3SNZNQ6r8UlRauxKt2VAoMW3OtfBh5J3uLyf/aStp1rjebZiQLkP62pqmX4mZLo1PlrRDs5J
O6BYBPrLp9rcil+JM0m0uaWhrImNz06MbrZ0dffuvm2X691u2f9Az9rcBPg09iGrLUgCqXcE8kbADsk2
Ao3+r0Lpi7U6tPKivXYdALi3HrqVV0bJNkE8bxWDkO0qeklpZGu3Z033aZWGX0NXUxzODNHwcxSmToiG
DMallugdeyfYdBTNyMb2UG89h5BYIVo0C52PjN2oCNbwB+sXLFK/Zt6bMtJbh+AR9axoXCVd2+wOtmO6
Pb+1q6pnmMwdXvr4YDUGAK8Cvn2aQu4nKRpXGROyxE9YXRfFR2MH5jzUB84MgZx8+YWIuiQbNfOxpbOr
sDAO6pqlmS21CaHkttUnwQZaMEuzJMa018zM2oqMW1kbbMLs+oSbTwFXjbcVW21+bfA1FtkOGPlFF0GT
bbfO7NSYZ3cAU/NLuiYcTfyb5dKCkiyxTpRowX0iWW3bUJrtBjpYovbWHgL0dHmavtPrEuzarF52KUGT
Vhdk9ls43OcF6KJ6Yb3XOaz/gP1J6vP9sP8XSoXQ3xEJfqV72PGRl2RmDoL/R6F9MdtGc7cE5HOktzte
VuuXkaSZ37H2M82zMsdLcvN5yM+ZQaMrNDSLJpOphdu5es1GZVstKMzy31gQutHX3OWJ+5Bpsgxl56zF
eHvPiUjqNSnenQN7g9QEn/FIEt1uIg2FxRxlM0XZGd9plcJ2aUXG6YkS0nbMw9dcC09NPsYCPxC/iEHT
LoujOissxNjH/WYSs/8A/mg5zaKKU30219V1kaZQXXTZVp0iam3Vuc/+SF9JA+JH0XUE8iijno6xopKn
QvpkTRhocdlIRRzOG+fGSiH0QX0sqRJ+ln5z8s+WnMXAQmxXH1Jq0FBGCh2D30JNAgCPTgWonLjGzaqx
sP7YoQxJfKHYlaYGcecurXh3IJrVU1IvLdHuYtTvKSVcU5gDXUSFkF0/58Fvxhk0eyfi44i1tePuhHGL
U15yx1hPG2lA9Y7bcW5ho0RxRJPy92JpMxQg3AY9s8AG4f4A/ibl+ZdZ2H/SZ6mynliq2BDHCv5qwjna
GMfZHnYCbfPhTBMW40OnPrfR0H7SS0Ktn/YSj2Se44q6i7PlJR2Hla/4WuYKlADsSgl2W4b1EF5bEie7
JtK8w0poOyKiqeszx0/X62GcYm4zDLbuV+Wv+XqztiYC43vtd5I2zNz0sGp8K927Sp1zpHUKMMoRHvNp
yGwKVMlqjYngAODryaaqoFJKzXfcm1QZbNKyPS7eezQT9xbVanncw07jL6D0lK4EgRJ0e1HvcQIrYvz1
iKF7LFG3TLOzI6l1PDgNL8kYBJjDzXp6jZN1jCo3+7vPymiDxTMdsYtHCBtOEbk34afTyuT41nR+VwNT
xe497X+dZutNFWCcKXQYvOwFefYME6DATxZrTynUdh71oIYozrPl1XFP/NVjVwMc9x4sq0dRsAB+P37w
dpNXj1B60FF4WP7oxYM5/AdQ6WoelMXUAjZcZ/Nj+E+FH0X4V++xRVaxbh6u8zUmmwvt3YJBizDuR9Ti
rcwFddDktXMqPMWMCT+kIAmKq24zQnDy78TtozVszVKYdiPKvbBgmIbIvn2jdlcoJq//ozz/z3NbvNO8
F/r9HHydQW9oW9x1A6pYKW2zAisfn9td1HZ5aNEUCElTqYlN3ZbDgEarUvNsUuoOT/LefnTmUufOKWsn
S+nbf9A3TtY36mFZRdWmJP2QEXEj9w0bXZa55JSY0hZqYJwj1bIAn4OgtNqESYhRl0ZnTmPhFpJsyJlf
61xccYPF0Mx9xd45kt/qraqxy01beO7xoPtV8fIf2Oo2pLXfsboYfpvFnNi63JgwnRDB2xhNPdquXpfU
Md1z7lkgNYbBsTViJMXDW3ckdVCRgPguE0sW2Wu/MVePwtfo2GlOKFtD8sXOFYFPueylMFUFi2+L5uhr
XZWH/cqLiGcxe8rm1Hf5Jovdx/ravaTtOQ8kEWUodc61JC+rj24h4U2jsJM6ihh/GSBmYhQTxJLRpIey
s+wZsLPSkj7AcHDLH6WcN7//9pPSro26TxNolnrGJsOjI9xOkjtUn66my1ADeNucDF7pX0Q4GY9aOVL6
+1p3n3idb8LZZjWNN+GMenRlh4Q8MFJ983JrZUzt2eHssQ0jbJzsxsffdxfvgEwls8W1phYJx7U3jrrO
HyvnsbFFM6jQhirE1JKqSgrcnoxY+Hf8/up99n7xfvW+pDjwkcWGSEctqByzxJ3bR1sY2AQB9fEMHgKO
Ud8g42kLFvZJcrxQkiN5A1GYfwFePcHQr2McpwcY/dBit6TxvOWARnz2nw75vd66mmNVBNRewYFNmdIB
y5AlQuHacdhD8fHUPp2D/f2+Jm3Wm1OPdKDPeqCEKhgZiHT6UqGvESlmUxnTwz6GZcTqm6kyGlP9UXMu
3gRDEXSEKhuMmiZ/XDabE/cUlwyleIjJxSmakZS6QbKQ3oh52F1Kjd3TzSA+tUJCMN4/Efls+78mxRRT
nP1eJrrqIELW1huX3VXnrVWy8vENffbzDQNR1gMXswhG6eWYomLFUqBqB1i68MD1jkHijerfQA/etvq7
4TpqxMfHdQc11/WQ23pWbkPaaSQBjHKGobOIpfBGh/xA52PbTYQ75n2G9jUeKkPZpBLpWWKzpDqdXFVJ
6eNyCcjP6zLgbSQlMiDgGhKunikIKb8gGRjs33jGAGRULk05dNDkEDiC/ef1FjIWNrQzWJqBuM96MGbM
vpVn9PtPlL9SF38c84HMpCv95Kf4Qn32sk4i1cFAwomRFYiSv3EkMGOfad4Ex/IvfRatpWk0jtcw2WAg
13h152fBV45LQtn5SEL5ClhjWA88OtV7sFnruUwWd0LWnuvyUtPkQMMp9Tee9v3lIsOE27CXvlJaQWDO
i+UkJGOjFNos+FtbYJnxxmNo8dfD1ir23mF3Ab5jUH5Mrd1nhN7zU2Jcs4Vq3BJ05hWds1aZObsLYRmn
5Rnsw4flGtp7atMbqLvcsg0R2EXZ4A4IsigSN6bnw4nW2f8SmTorP7BA5XvvShVbY1mEcZPhXnBwYr1X
h3bTIHlQNep5pao4XHnsZGSXmBL4GdQtZZFAtjH1ODsuGmkxFD5Zi01yilqBYKyX8ItZf9ExNoZyKMIg
3rJf3LV0kM83JhGfWri7sdxUsNcWS6tkb7f//phN0xgkyEdnAyaVK24st6l0hIPpB8bFC5pFvLfCDADl
BvcnQcrbiTijkq7Zu2JuswRzrNjsXF3sVQJtOaK8muWTNGahhvFtTFE1sXxrLwbJygGsYgH6Lf2yAkZT
kWyGIJ9OtcSN/4/5IH6sklXpYUAHpympgf53HGhjLtvbnGiznlNDReNJCVyTHPOwmFu1HNH9We2muryt
ltPLBq2pYJ2ZYOW0V89/bUH0/Fc7nue/CjRehv5145en7SLUdVEXd92M+QEvzREVr7n6jnSKD/F6eGZ6
HswsIryGeE0VxGuPUvqRzq5bHxcVaUo2k1Xqz9ruyTQundNr02mlQe1yAo9O38Fgvn8fnA+dOfPorBSA
0em7oS17tlevcNAIbLENiQ8e+EikLmI3UQvPUeM8geKYgj2e4FUEdeodHkX9D+OSDfE0qdntdeIjtnUK
D9rTfVNPYqKaKlqtj4AeN9g5s8FJqZCw6R60tFfE/1tB2k0kDlVQinwtiYMrcYnacDi0uw/4lHUf9XAF
Jxu3fKwpwx9NeIN6i2TodmTFHTQtEU5WKTZlK8NNchdxx1tFcdO/7BfwV1lGc18cmiF66ND+vFX0LKNS
tsLgjJf+lre0j4w9PZZlM5T+sk5SGVntZwHCnMcXrC2hZXabhoCQGTd/3r4ZzjVRPMrayK6JIrSmAIri
ODx4OMBrWGClj8u+KxGX1AXYBuq9WD/P7es4X66mDlkLzuQghztITkB7LT18k4BvH83XqtSI57ZZjkRy
AdIDbUAV8YE3EZIxJzrc/vrRJGTouhV7mUKPTpOPzhogJ3xobAK+RJjiWjFLHkwRuNJAiTcGKEUENnD0
0wAS+yUpUK00gDiT13FocxMkiVOpLvxlgMBEmCcSEPttgG3KhOct+B3+skWhsaWpQWSsVfJxLXFIT+s/
hxoudW//YGG9Z6DmFiXOhobzmwTalPAfT2fwdRBA/c1fAmCZwopvDZ2jDtJ1bwqdQQ9qYF6AOkwcMc2u
S4dpAcL6sVsY1sfHdorEs91pjbLZsZ0P2cXdrqhduiBdBv82i53AZK1uuhnJL0WYEnt1e/rrOmjMWBVf
S+N5NzUInqDLzgG/+H1n2JseSqCH6he3xw+QY2QsS3oUZy4Tf3LReWJm1TFOCzDJjoF1/bs49Mnx2W7W
xYciMvKL1phzDZtvB5fRDUz9p3QYxxJTho/Ac6RKFqBkELAQFenPfUv8+Z2Q+Pt6mq/wrP12ROr0fWAq
fwVV90YUyv9Hag8ftpP4gQ+A2k/3zNXbq+T5grtG+wXZbJ2WbTPsXpudYblepjCdBvopbun8J639tiY0
aiMFXR9rkcglRz4aB4P3J7sjcQDovWHvUOWJlMNRxKzaTxydB/fIf2kMjGTJMqkmoX2kaF8mw4BoPJJ0
L0tMKFcIjnQNwQQlBetI0b5cznZqM+slGBELWaA/HcmqlQnCtKcjTbmSUuIQkxvFULs6klUtE4SrU0ea
vqWOpFXWa+ZQRVWOsitN+UXWbDRd6VethDWvmC7b/GZqa/NbsLpDtRSu9IQplmwCGYrldAF7RfdVLRJk
nJa4oXmGV1EXGOqnnbJTVVFoeovV15ISSDdSiTWwTNBYRY25/d7Y9REfMbGCfpjlWbLTP2K389iuDHRv
j5Oyetmsth82719n2SoR5x3tku9BpOnSmo+JWLvJVlVzeqerTGEeNEX5pOhUUEwZ6QpVaRJ1QkFTTEoC
JmZcp8I0H5vC9fTsdoErTF7pAldxzVqXomyiN4W5GOxanIu2przYW978AlkhS2rR0CpMPELAOolMOJIG
UpX6PRWE62YC5U7noole5LCAQfN35xJGTOlMM4SCJNpFmsX5heiLsP+MCtIFW7zBlFDEpL9DEvYby2yi
vgmvGMAG/+Ptan4s0XNcXZy3Ert2645dnCyyXaChW/TMVAXTM7rrl9nxFKOd9UomyU5nuXvJyGuADzVW
T+uBTzQ9o9QepmI0R5LQaHksU2gqntNFEm+WiQMLEhhlccwyhEgpRKhPtHMergQM0zMihiVfUMtsnxGk
7g7KIj09e8nPFKO+xqNvzih52c9JEpcBQMDWaZnEc0pSYvErsVLrKEuWzzDzSY3oPuYAhw1188lVGDND
GcXwpasACyw1irDXrkLlgl1IbLudQMjx5TJal+qMcJ6pl7Cye5LuqW/s1nkyOqkl0fBEbxjPYe62Z4t0
GUObpPTZ3qus7Ql6nOAN+fcnBSxvU9hhh708+2Wd4GVgqcN1jc81bvTtny1H8p09jXlcAvNyaGd8rFSU
D1KIkO4+tlwpzbudz1jYASTTsx/jS9xwNilFPb1GllksJM0WPmQO1CdDDu/uT/nQLTuqBBtFaNrARa5n
bMjCSk4FcejpppgUPxbzXqAv6xjRe51Y8hCkyLae8ZQf9O2kmeu6DvG4Lx7ER59EzVi1joIdsf2ti42o
rfYq+JZiHVvyEFJFTplF0lmZKLwtzuhmiwdS7pgunsim/q0709dlN2g/K+JVrNUCsKg9W+ZlIi1r7ltg
6iLf0U5iizKwy5egHRfZ4nNXw0GXYOpSx7XG4EMK8nzYwi3iaZ9+7qln6xF3/wna5kNmH0fBPEfPEcZd
4g1/mww1jqxvfCDV13t1SUONhQ08g+RvH6PWQmFnUgz2uhEtWyyvq80SdEd+Zk5OZ3G1dvqFpKRYNj8J
PkbGK4kZZRWd3vh6hzEnKbUdGdSXop26wj98VBUluPkv971G4sFeYCZwrdxNqtf7jKEU+t1AEezwrjtt
BN6JNpe65niv6tRlgujDHuOmPay/R7dDuQ6gNIaXNSghomCvFZqbaXrIo1ADseoWK0WTJal9qaBspZT9
sz/i5WwZR/H5/wjLU6ZDzOYBA+s6uvfxTYYuVH+wacINDUBDK5caUXQeawiuM4kIaXKfLrGdLbGaPrxp
HZkt8c7sCmQrumK6MAGNe1X5fbHu2e6RZ4sjy0j1Uhy7kEuxsxjushlLAyHcOfIwO9Vp7haSy1CHuwrc
bA1FO53JiQ3Vfo7qj1itTyj1KSXnhj8oEang8zNbEy2ikSJXYX+fxN/k8ZVb8eDGwHw+X26jbKMFQ7V7
dLF5UIRWQ1X7JoRxKW9BD0um2Xw4HFrOjIpHabRfGXVkq+SJL23cZdpb5WcLt5z8UKZeRi9Fd9oqPqFO
8G+RLV2G4mIInVBWT8sfYK6HWI9XEvob2PEOuRaq+O0VfDhrOUWdcEQXVxi3zqlE3toIdT/Pwj4zeini
NWlNpHl8zORcO++yOXXLJJaE6d8Xpd9SL5N4z/kVHyFotrptVMRn1AnTRuF48O463DnZGc1xmTp4vTnc
35/YLh9w2zeII17lG7SmNF4Gy0dnpKBdQ2NlLVlSfbeGnat5WUP221mze6xY7fzMgIWgseWd+xQBPpII
pUL8UKxk1pRft6QX1Qn9CQh9KlY6C7rxfqe0I3LJ3zZLVDlIxSb/3BxzQ1gpYc5ol/6mkIOAOy40D/Da
8+fiXowWVHR8AkdXuKx6zfUZvR1/Ha/EpRlb10F3a/RsJ8PIvkO7Csf+28fm5JzqyuTc7kR7SLwzsneM
slbPoEgj7IjLVSxXXXlMMAS7doQL+1NC5d1wSKFTnVLydFn/dJi2Qy9+5+WtLhzwOP0cydYNEsjQ9UGI
mCLmrmR8J6Iz7p4OFuhhEvJ/BwAA//97bdAGm4UBAA==
`,
},
"/js/config.ts": {
local: "web/static/js/config.ts",
size: 11476,
modtime: 0,
compressed: `
H4sIAAAJbogA/+Qaa2/bOPKz8ytYo1jTtSsnBe5wiJsu+tprFt3dQ5Pd/RBnU1mibSWy5JUop1lX//1m
hqRIynaSwz2BK9BYImeGw+G8qSSTopiFkWCnb/NslszPonwlmPgiRRaX7PRNXlaZGtscdEYjJmGKpXkY
J9l8lIXrZB7KJM8OOhGhX+H8MStlAfPjg04pUhFJEV+FqSjciUSKZXnMNuxC3q2Embg0DxeXY1YjflTk
aXqeHzNOcGp2yLJwaV767OQVW+dJDOCwkY/Am4gBXsSJzIvjMLtzIfQog2F4W4dpEocS1ucukB6GfX0S
ZZVub+i12g1Xu9rmoxCrsCjbZIG784VYCoccDP2Qx62R83w+T8WHZL5I4b9sUfm9SqKb76vl6jws5sLl
rZlpYcT5bYZHpk64NYmnWlQpnrmIKtwzy1f4Ux50ZkW+fEfiadaQeWsAYc6TpQ/TGiAtA6HCgWfVcioK
ZKoqSMLOkFiGSerSEctVCqtdzYu8WnmHIE81ydZuYOZdQ/iBfcIxVVkGFI/ZNM9TEWbIQ1GgejRL3YaF
Amn0Evkq24cC65ZGqUgprhZJCYp2ZwbLanoNiuNQnubxnfMK+hYaYBlOnZk/boE0X5sRWtYVxbkW01+V
lLiSVkvvjSE5cvMpGrhFfqvmWgRQgfBY0yQTfwszgRREJmGHADhkWwj1wcEUnQconcSlRVEGUfPMe0oZ
38oi7Q3ZRe9piU4GHntPF1Ku6CHNIzpJeoFNSTUvgQt46Q0RCYdmVRYhHFdEjj1fNmREENRsHpx+gKcz
2H8S4bihr+Y+6jc7T0vSJD0Fp5/wx85rRhT6uXqxs8Cbmjl7+16P9tGJrsOClSIsogU7sTwEaoj3QdRq
G4GxPgBTk3bk61fW6/mQuL4PSSMtSGW+Fk6/b0H51PR7C6qxagAcaEg7BsB/srDG2h3QZgggsypNLbAT
SgC+91FFG6aGgyBwePDji+VYvbYYJv9iYdRre+uez3FE4I+3RYHRDIDJ65/ii3uQYM4OIXhB7IIiS+kQ
MeEB9xwt4ACFP4mBAufIrHrk0lCXxJdV4WwK3tAra5Ng0ypJYwpX3wHF9zDL+6CEnWTG+BME7rNCyKpA
30fkMnFL4D+GxEkXnV3XTCbxFxg7wtfRaJZkMQtZlSW/V4IpiWNchsnbRZIK7grnoksA3UtQkVh8+WnG
3YX67MkJe36EgvGRjNjvx6MddXZyzgbINDLcgd/BAJ9qvRujYJNskpmFWG/g0hn02GaS9dgACfSMFwek
zSb4GJYyOJOhrMq6PsYRQgsQr64ZCB+GyCkHi7yUde0QQucPVD6/XL1C8C1sBxRAzsN5eewOgRKl4pUz
0tlsijCbC/b0BlzPmh2fMLW0R6oDmMWrlzJ+tdk8vanrlyN41K9r8zoCEJ8ypII+RyO1/mc7VqMMe0ZN
UK9EWSp7D2U+5aRpZhpDCFqLBQvKVZpI3p1k3X6wDFe8celpf6P0k6UBBKsl2FUNhBj86xCdC/obpCKb
y8Xzo0s8+ahI8Izw8HfCKHSPSwVxnScZcoHzXeKXdGQASqL0+17taHToZAvOgYIHV0AD1vPESELc4QiB
B/x1Zvc4nY6JS5z3T15tGBIGa43CrCeZSgOYyoLBdCV4wHAGPpvp2MySklUrzInjgL0TM5hJZEA0jMvV
mQTXFj30DJLsq39ANua4IZdH9kDav9FqonZ/rox0WyJGmwqU9+i3SflMpeNfzTF8zXKZzBIVX7+meX5T
rb4uQ2C/PykH/GJyO3k+CSZPLwfw/myyGc2XY6aJLkMZLRqvR4J+gGv0CVixdHx3B8OUM3a2HFp7RjG4
Pe7uYnuW9uMMk+dlnPiHwQKiHuS73Mqyj0kI0/+0H4RNASzhXBwRGRUKlCNV4y/seAqpLYwrDhBZTVFI
wTnljjsaTPFlGCZwsreSTpAUhUCDVVUueNYoEfzXlk+YY9IpiIeYzQVQ+PDeKFwlI7WzbxdhuTjpDbgO
g/iqgnQflLETlFUUgcFxjmk2ZanE486EA0HGzuw+O+vsiq1aEvzJ7gTlm2/Y7qiofJOW3L7kZifqxeGl
FeR/2vZ3cqqEgF4AfYB6CKiwsn5dnQNpoiXfrrvRh79HPDYToIM2CTwm364OCgngEk2qpItvQG5WI7ne
f5y1zqZIOl7epToKLrkrBUVUtThP2FWD2uSbZsrOqCdU3zPl/3kfhCd/LsWvRbjCDI/LolIWoGEBpjtN
q6I7bO3HLPM0XK3Su0a0WJh6arRPf2v7tx7ruuQukyGmeMiEn5n6PQlPuMwklApdL79nq7RHpSHNajMo
GAQN2VwU1bnNzr00adFVKBfHEKwjMVrC4AiDrZ9BD8mLHTOse4Isv+X9RggHbTWHle9vO5lQpbzOJzEX
yC0ERAbP4BB497cJxJbuAKkMuvA86A6QyJB15133lDGZ5g6ZoTrCaRjd3IZFXB4rIRH3nVvQlWMSinqP
whLK0qxMZLIWPuQiT8WveRF7owUxZykoTcATVKEAzE7Zd3/jGTj5Ou2ia+OPfZGZ/gKKLom9DgPuKM6j
aikyiUf4PhX4+ObuNOY99FvPe5St9zUxIJX/kohbndXodRZwZA1TsrxI4kujwQcuEDJQYnvMtCVweRgw
kz3dxNT1ZKPqWQLxTmsoHm1V4F5UrMH+0bcmVyMJnVA2l0WgWD9/On2bL1d5Bnviu/2ixvwGq/N9mMgi
Vttq0xTsVlA9cOBjuB2uyMfui26dVZFHypOWakpFYlxCD+twF5yhKA8vzbDjwLXj5vTj0DY+jtwzuDj8
ddFAocMU3BLfxillvtIuoBODhEDc5mBM6Ng6Udvxw4P1jA+liWlKTopVyYi3GyiQYzPHE5jmSHPGMt+J
r5sjLWzVDGks5glSC5LyF4xdwBgkHU9kbge0N/QdGy4aJ7MZ+j5Ex2cuc0sUB/Zieo2XdjPGkLBAL9mL
naSIgRGU84eHh+wZ+/OhEQfGuh/AkQbhtOT0AJUkuCeFYJfvN/zGsMiRXiQ2HYLaWpXT/on10dqDfWcn
/88P1u2StSTXSNqAWIH7dHY05+45y4bcSKnBCNSgr62v1WR7rZPQrUsPJ7fayljplzxZu9FpMkibMY5G
7LXE+kjiuVF36bNTUs/y/DPoHoNgJuhkQXUgXWV068Guq+WKTYW8FSJjDVaIHSpc4HFxmkBVkKZHG6Xd
tsW2F3bbF04sad3U4Iqqz9mZgc/kZMoweDiGn5fM7VHAyGDAVJYHxYTDdoBdLa66GsllXxcMDb1rrMsG
R2N2/dKndz0YaFiU89s0hwR5WkB2AXyFUBvIEM4rnxEXbCnCrITgFOMISUJVAaSBVGpP6tHSZeUaWVHl
RqOQHfVaqx8yaFQ9U62bQ4LHEyze3XociFPZ2hAfm/U50TBb2S/pptCmSoGQTGlrWKpN1dRKZRpixiEZ
fwQJtHQUoLWoUQLdOEJREYI+AuxUvjDNrLFjqU1NRdAQhIfq4ehS02kmKDFrGghOLdlKM9ziYIdklG12
rePz0cdGIq6P9u6YTvQdkysb03CgiYDe+GjDg2f9etTIg4Y99rba7W4Tom6qMtSDK9Xoocs3PolBSWwU
Mfe4Xghxkie3VXCFFHrDHWZ8fzJF3heG6BS6psa6r3SlQNHVOudX5r767kI2ePXwBTjmvtJYJiCHf3jl
poOhz8ZkeepYtDCtTYFLz+ZVGhYQ3F4XRXjHl33ULr40uvsKgk2z46YKy2X+EWjxpdHVlmk9Jn/cwX1P
lfxmBi9fKVd2Msyxp594oP7J+7lpz03w9Z2vU1TqCX3T23SstiJWz6QdVnncCzn07f39iJhb+IjmTu0e
RJWoWDR7XXcvkr+Wvb27B6nJFwDvjEI7b2cS/QdImFxii4KZeIgAXchZvpv7ufv26vkPZ89b13WWyJ5C
738q29TGpnmSucnuCHRHFkpLI7QH2MpgwaR34TaL+Nz3H5PTeuVIk6MSMCQ2egE3F1WVgfJjCNvkpiox
fgn5J9QimIsCMoNU5Ygtk6ySok3ohUNoa5WdVVH9X6roSWiQoYG6ocw1hsz3wcMRbUE3G9mH5FipRiHz
eWA3BGNZ8ozmAVQf+F/RrXC6Om5bYuxOet/WGCiqTD6osbEXq4MPYWma6ju8B94S9IYWcGyD157eyb+t
J2LDkm2G7uiXtEPfH7coq9anPEhYX52ssRuehpHgI34x3NS8f9kfzfErmqNJBYnFtLfVatn60AcX8L70
cTtqKOl1EINqmM800MuslQy8dHfdyMVUQT6es3O00vAGJYjLBjfizowCg9kbLFuwtrxpvgnobmyZFmFt
swumtjCh850AgJTVFMTHD4eWvnXqtgJtIDG2NZCDo6Gz5j/ZNwztlw2P8CyOt16rpuEOP/MoozZQu+z4
H86U14H9TkKZsXod61n98QN+IRVAElbK1+UHuUyVxb6BycfY2voxZmYy7bammdTP7TTau+qW5esWstvm
2Ls9DfC4HZr0iIoK9v3ZTz8GSrmS2Z0ChcQhHJK9gMky1nPRzPYJkFLmcmc2S/O/qld7i6qX9r4M3WrA
TdN8qvskb+CRX2xrwuWQbdSleBdfR6BFSTaOFnjXJE8qOXv+l666XijDtXhdcqQ5ZF36iIkIdfXdi/ZY
aonxQY0lxQEkALGIoDQRMfZ+vktScQZ0iuC6PNATjBo7RFx9P/n3AAAA//8jZq381CwAAA==
`,
},
"/js/d3.d.ts": {
local: "web/static/js/d3.d.ts",
size: 107075,
modtime: 0,
compressed: `
H4sIAAAJbogA/+x963LcttLg/zwF/32jlCznUvtHORuvYztOzrETf5aSSvbUqS0MCc0w5pAMSEqauPxA
+xz7YotuACQIAiDImbFkZVSJNSNc+oZLo7vRePw4utyWNEroVZqndVrkVXRVsCj5+p8Xn/HCN6z4g8b1
ebSu6/L88ePk6z+qs4KtHkPhc63RcnsefVewtIp+J/m74jr6B7SoeJNVWq+b5VlcbB4vocIWy781OhAQ
3PUfy7o02wLCyWefJTTOCKPRpkiajEbPv47efxbxH3pbFqyO0rym7IrENLqgGSehYJWsAD+PP/+8/fy5
rBGRPOIfNjSvoytWbKJ6TaO4YQz+kBRxAyVdq8ftxwqbn2vdmyB0MBX2e5Wyqm7B1WtSRxtSx2sqiquS
xulVShPZORdJVbM0X/W7NAD8r5IwsumaCICcvdEFNo7qQkDpt3vc+7pQzc8lyJPzrqNvJpDY0ZAXCQ1B
XLHjJ16/400hCfIiLWufRy+u+a9Lwla0tiP+4ZvP/MNg02R1WmYtBtWc0fA0y8IHBMmyDlg3Fhwj4ZMc
AoQxso2Kq5bOCeOhip6q1rk2MqppQ6PqjY1//8c5OvDXZ/a1BHvQ5Jrcnkd5s1lS1nWRbId/i7OUN/zN
VfD7sKBmJK8yUlNV9O//dIVVTDI6bFMVDYsp4iiJ7cosiFrwfEe3zziLhwUkq/9FeQOSb/0c+o5UXEK3
Nc2TKmDpfcYopzEi0ZKuyXWqjW5NjKqMbzHy05n68I2j36dxTKuqN2mbirKIogBhi0OUCYrfBpP2uOjC
vtiUsAfVN0V0TbKGit2z4izhs+ZMq/mW1g3j++SjL6P0ipPLN8pMIMh3neVpxFt1JStkCtMLv+j60nqV
84RE3+N2gigMi5dcDnGRJ2Z5RyypYi4vjvI/Lr9dkPPo8jRa8n9PhuNgj/RbqHQz57D0J3QmA75Pebcw
yDZcOdk0GwGCjy1QJnDN8+LNmFzacCUjTFuW20obUsJorjhDOB+umtw5ZDkO/+CI/8IpYHyuXP77P6fQ
+jxaXAMt0f/8NvqFU/TLHRBjINlhyPG5HMeH3N49c8ntnpi7d2IMJKcyVwqb8O/3gdG4d9RBvNa3xDuh
boh1n/luBGHlbPjGh1oSx4nrNgob1HNw1ak+Its5Ejr2A4YLjIJ2hAPS1cNXIKu0o0moEcZPmRtap3G0
oRzBO2c/YLFv/h+YyD7yOwhjQ5PUiV60gCpfnP2PR382JK/TjJ6cfVS5AG77lszHo9ikZKaYSKRwQQWP
oIqnH+sk7ruLpowuOfUtNF6ToepoI0nV4tLokXUaleqLJiEXja+KmEi5pDk/I+BpuSxSeU64xZ1Cob0h
/O/8f8WAgiWU7Uz0bfQr7kltFXlC6WEzbJYVN9Hrnq4GIwqBVc2yopYm63S9il73NkJnG+0Allb8HNef
BbeoJXMUnihen/LeV+v26+jgum+MPyzfV+u5fH9Fr468vyPev+Vt987877DrqKnAIAc7ABorCuZfPWUl
adoY2bcE9gVbqGZ8jUxITdCCc8rZnNDb3hrJ/3yimXeGSL/lKnSxSf8SgwaHgL6Bha/8THVkVevWzdVV
RsMV6bdUoKJvpK2BkBPPS6XZU6+B9NNw3YdRY8yrWrIjWTMucJ4gwJZJ8KnFqFoXTZZESyq3NT6bUqsA
S8o2fOcVXOBigZEngcnvJ/K3izOXYEEsiwp272uuC5Il30+FxNvxP7phS8rQ1lqrDm34/pWWi7OzM2gS
iN8bwioxmFbpNc2jr55H5OoqzakAxFeDjTQ/n0akEi4qzq7lNrr49eV/VVotUvNqS84tLzWdj8sDykZa
W2fRdaFZxj1zRhOBNvgCOL8hvPfb6PKmiJKUj5yKgyRZtyJ7RdEWLkQ3gfJ4lVY1iuMd5fKWU5svHXFK
ai6ggGmOarWislj+IfwARbSibcetmZAVGxvuAHuBCrZYkASXA5CW/R4C7RGURXGL9DRGPxL7EV8bWHog
9DsoJUmZmw6Jg859Lxkbyla085aJUQ1m9SIqcjpuWWnxRmyxN/u5hRfA0hLO4Jc0p0y4FfhUWFF5QKGM
n4SFtM5skLDuuNduvHfhMPzirN/Q6EZ56uqi7BShleobBCd6rwtXQ1pGF/DPktY3lC+glHAlqm/jNiiE
nwVA7DQX6Gaouei8ncuFQPIJqzVFEL7eH0ZxZHROFeWTKYz74DxVC6dXTm/4/3wtKEqgxe77ggoL3v1P
/LdbB/qzgX64KKjwAUrd8rfXr36o61KWWwf97ZqND3mBcCXWpm0er1mRF03FwQnA6PRpfb0Ny0JEz6tF
v/D/Ub3Cfuz1YpJlSxK/i76X+i60SPPr4h2NbtZcnC3R4DcqSIInFDEwFH4kzSqvrDky5622oSBy8S6Q
P30+or58XaRJxOXy25qNTZU75d6Gqw/R6x9fv4hqCPS5f8wGBPfAeudk6yZHTW85dmlmV5p44fhE8HW2
B2Hd7VDnnZcFP3+3uu3EcX5g5nzCIzmcswHD+J8XP/8ULbNi6VOuPEw9HIc07vxRwRnJPdYoYwWTxojW
LqGxBT71GOPgRh79cPn6VRuQxTUvsoIP9r1uExCUNaHrPu9D+X9YGRgkw0/IjH8uqZw95z8Ktx7EEjDO
6vFFIId90Tvq79+SsK5h+k0ZjN9LsmasC1FcbDbkUUWBLrBZy5PZ4tnFrye4NVlXiLi65uCr6wBlgiwt
vV+q3q0qxkjnlzC6FeOtLKxxeEG9M/jH1dEFhAdaO5CBg1jhDP+FeD29H62bHyFCriwyPGa1EV62btOu
5rkweqGR7Aw613oJhDNwTFsB/YS19gAO+lyNw3tbNHmyB3Bi6I9BE9G6ewD39uV3fC5kxTh9q+UewP1w
8SoM3A9Vtg9wz0LBxfsA9+pz8vny8zCIr8g++CmtasVV2OxDe9pewC7TmrCtsieOgP15KW6J7Az3q+fK
9N0a3cdgX6qKM8Bfrmlnll82aVY/SnOtc3CyEXCjpWOcL8Dtgdz/h4aFhsH32M/2W6dRmGyLxs7oDIvO
ZZUz8cu59l+v/su+9F/z5YSXnvH//T4+5SSSNjbHUBduvHPZZsTURVpnJSgUIC0Cm6gERCqIKDH8L0Pl
RNlIGMpNdtL9kXfc2B0iouqirao5bxY4rXqeUFHm1gBEIDOoPBc/RiWjV3y0XkklqDPjCIs7qY0/8/px
WjmctgLPN9hlH7HTrqFuc3xNOa6xaODUKsCDwbc34D0f5YBO8nWUpUvG57cNC1n5fAIjWFHU8iqGK7xQ
FS7s9y7gBtjYyewSo2dLoILRVVrxuQWXi8iGK45w9UDIgnrVdVHHhIUYwvwwSVY/t0J5dRZnaf7OU+xt
u8mAeFvxh7HT1383JINxNbhwxXni48Kf2G67gHraZHgfISNbZLiGz1XE7uuHoCOKGBakW08pQWN0uwLI
UdihC4c526DhDSG2C4q7I4PhZIYZ+/zrM23R7T66o9py3luDV6/QCt8qSXa/EGhGoyZyZ5/RTVqbd7n4
hF5hTPIyitckz2lm7u8WqS1Ytxysuo9LbUHgnHiGdHDo+GHUNu1Ge7mN+LpbqWCGDnlRbLuPaOCLFbXx
5cHO7SsxEWxVPqus1nGAiSekTxs9647pcfcx0/gvyOPdzWN+i8cBmO9CbQLnL7ycr2ZxXvVpmyVrvoOu
T6OK8CWF4NJR4aTJICgrhxtCWai8Kq+8LubK6+Lg8hqgFi4v/6qWkTmr2qungz5txGQdu4l9pRLk8e7m
cb7F42CcH6KmcX5Fi/PoJS3O+P+9v27wzxv4u1MnXlF5PXZTcIU1KguxW3GlJhMxHxCs1iMEo8qoXY7Y
yaKto0I3xFlEsNt56GgxqYsmXreYVDNRwV5oNYqMA5sfTb1AXtSptOPDqYybMzUerKpfOPyZl7ObtKJd
C/0QApesw3rS1HNoXbB/vD29/Fap54sy4kcg1ELgtqD+9ZtBw65ZW1d5PS41rnAddyHO3U8UA1+TUrvm
S+sFnlqfKM7ySt+iXq0dC5OUK3N1vIbQGdCg2vOpGOdQ/7ms0jVidJnmyaLGO9LSPSMMvvIL7wwVbgNy
LwYOLMFFTRcckDarTAUXbJmD0IMFsorzBpmyLIqMEi7zhA/HrRZ7sSHsnX4OAttwfwm5yppqvRgUfejA
t1oi1HKojx1JYPxb3HYY5I5gX9e1aMVqjd5/yyvGgjH/MZgIBzCDN7oebPJ8UIHvc3BC0iZhr/4HL7b6
udJ5dRunDZiQtckJ52A++68pXgBub7RAxCKYWsqSFSVLwSIgD2uJ6MI636SxepFMuMwBYOSZvNpulkVm
7RhL+kPSxYrf1szJgZe0Bu8Hn4+t92NNSS9OWNOPsCQkvEyLOoSzknZqsAPBdkYv0mQCczX6Cf7hHYlm
g8hGEJp3fzROibaTqi0NxOHJqPxkqNaiWLtsIFq1/QQTfxrJ5bvlRZjbThsn6Ly8dJx3wXt4iXM4dJCo
3AbDbm20TBZe221r4LL6W+1sRxft5Vp32Hp7eexd7dycHjJaod9u91xDSsRFllLCF67GdmGSAbe8FgQj
uBMFdD7KEAntCb6NOyee+KjBxmAX8D6x8028y1BJkFDile7lYUDw3Pyxqhrac2A37Vni5YvLaEPrdZF8
NqQ0yGfOv8TFpsyoMnwNPO+PtdNDvZgd/hZO1JufL4ZUafdOiiogDm4qAM8g2Yl9ttGx5+jNPZKKw/s5
/MNJBEZHSHiauxfFg3FJuwy2/5hL5BkcrNLKwrVOE3APw4qCsz1oGE6H4xGRqAkKMPwSLiWxXr2jdyAl
gc7BIpPvG//u0wQxWX/QCfN0yU8dfUGcQi6ktAbzh9Tysi0n6NEVWj9tc4ZAJwv/zvBWOs7AGqIOiCIi
LKZg78EzqfdeJCpyL3LQOlEth427rolMV6f1OWzaFuoyUo0LAdtGGIaSug63g2utTwb3WntBY84TenXt
POh1YV8JzdJNqoV89YO9hjTfddRdWAhup9d2XrUAPUNc4dS5IgDJW2DyLlq3osgjFytuvJGKspOuV+EY
1/qH5QFgWzUYKFhUMoBKN5eM3UV1EVI3fO2o+PBa5QX7+LS8LW4qg57TSLvXzVHoXxGedrH7exmNod1Q
FQQL4odM8dLLkam6e9PSFhRZ+7ERLEM1oJfusl+InaZLdDlIPniq2Sq1KQ63hgc2tgBbh90kINjsyJJp
a6LmetjFfFfHQARaNl4TZU4ezXoaZ/xERwfq1adEu05OVW+zwYF8J2Ig2iblM70Gm/NYBtQd6QuGpZMM
ZlQ+rbZjVA/t4vdRgLarVy5b1SII4/3jKOJ/7jeOpCzx1NQfBdDc0lAkWjk3pbukfAUebczoprimyk1j
qUA3JYzOnhunT3/7RdD93sKcKkS5g03vHYXJM1K3nRS/lAkEWPvEUp0fouuhEqJLj7dsNuGMsAyPYMLG
MY1Md5GGKNd4a5vnTv7Zj2nr0oOjzlO2ehKE0OPHbffjvO5tdVzfbQ1C5yqxNU64tmVP2bWNZX48WcA/
O0/WcZ/eaMeBHr+AbScmZd0wygUgZTI1XboeAFoXNcm05DJtvht5dFd+ipb/dodf+hddaA5VB+ALuJcP
B9jOh9t6FoaANN9uJTJJQ9IKfuLMUn68autVpxoEehvTsruXD1FH6Qa8ltWmKOo1P4jz5Y+hCzviNdYq
izFfgbOtODZUNcn5f7Roqmxrj5aY5IE2WCDNBXSc0/0kSGaIzAZvMOmpB1pbvVfN71qKu1b8S1qBHFpX
8M065Uy+SbMMsh2VqHJijD8aeboUTSIMUoOAxwbMK32KZTJlkojWiGiK7IYooBWGqJzKsBX4xLH5izJ5
U0kcopMUEp3p3a9pyroAF8zRZB+NnMcQstGRCjuBlhy6l/xRmzrO+fJIbLqVLjQpk/YqX9WgJUUGjrd/
Fqmkek9EDMOtJTHRJZiR+H/0zyblrJCvKMAyCKOgQisRWJcQAkgDQmwyxg+0W5nijVPY1DhN9IFBwHJk
5RUCtugDAUuHeAkjL/JHedO9g+BeONowoXaAA6Wgb+gzWMX2QJ9WjHNMcy8QfiFg+g+YL+BTd8p8fwdq
l3poZPg+wyw1bDILjC3XOGn3uULzuhsRfd51GDTYoU+PvE1rR7ELSUiU8i+6Fe7+Dp938HqBqa1rOtF4
p/3OFvz/UIWg3d77SVxgqv0L8l11Kwz09KW6Fv9VFx7WLjPDHn4V6adm98GKLGvKhfg1TcXpdwRhaz3t
2TQ7qQRTZiVdYko7dkYmkVKTw5pUC02wJ+fDQQ5e1X6VHk4VxTVeq9Eeii/76dPFmWcMHOYvOzFC7cwB
11UAk9SQQY5ivkS8AF0U9lguIBvO/SQKugHAbTer+/zsHV4H9JEk6dcwIv+QR/4u/DwwiJxNl7zK5rbo
D2JCQYWUV95gm2T6XbhKhKdzrQPskxkEV4qUg739d6gmYd5tCIDg+PHFq41plVdgVBarJCor2iRFH+aw
u4RepyIQ/rJNmwiKZkJY0hXatzvAewH4aHGUbRM9mHIREGY3l31ZsXr0qbKQ4/7TveBiHv3IbtL80Q/w
blQoG+Oi4WoU0Nyd0mBdB90FFCyVIdR+zxXg/YBnaejGS6ackPCyXHfw0ueofLCtK9W1BnMaW2vBTyKv
hNiu8i26whZR260wS/2Qbc/VlXFdD4OW7eiJkkDcROU9ImZzfCCoAJv5oJ5hQ/aSsrMh2du71RUSyBKr
D2EvPLHb9w/IpmkADT5Mtpe5+nW9CxdNemQRW/bjMuyPLdpA6mD3+OgidmsBNO/lPQuF8GN7gc83ZsZp
97zGOELRhFcZXdQ4Xmf0DMqwwTTnqUYLjs4nG23AdQR2eroRO/qUB5L/TccR8ua97eii0v3Go3OM9b6B
eV/GGD3pll7d6G/zAlkDjVwAO3Ov0ppcNeW1995dA+u9d1cHsBNeQqZbYyvB7LfiQo0gondLUxFgpE7x
8BB3zb0BmrZx2ZzGOBREQdhOK+oO0exbbcKGUG3hg0gew7W3YSIYT792BxsiPHE2a/WD3HLhioI86Tsa
fPjMrdEPWWH6xMgTieey9Q460/n4IBmNBmAGUIwbckE0DBx649ftHj+G5G22IxH4k3yHoX45/FT4sqUc
YHzF6Etpk+YN2FftpeuiYa6yhGxdRXycv3OVVU3uabkpfKV1Qysv2CT3VqjXDfOVX7HUU4pJBvy412tX
4ZaSHictIqowU9KK2gRkLwPx2Es4mvYCEI0DEKBvLwLkuxKLOJ09OsukKF1ISkE62kox2kuFEO1lSoSO
lhhZaF9VLYmhYK6JyMjhstrUseX6LfykVeFvihqrpbGp8sq7r6Hq6CA/Arqmxe3cNrFGQq8IB89VYnjQ
CX2rbMgn0SE69dP4nUi4AZ/arF2MQljnVbpqmAhnFWmCEORZkLZ2ojJQAqfwU6gierd0/nL5LJxKPkhG
Cf0Qtt3gaDY3Gvk6wXPUnNABKT6a7xLAX3sxR2P7Gl/BTFjCS/dcaIPPexsw/FxlhVIxVDVMyzSoyEQO
zfGKMU2zoA7Fkx2W6V5cXVW07vUheNPTe4Y94twervI+rnXz3cs3m+kI47vBztKPVh+iZigQMhegRYcQ
BT4tYlADu3S/WoDz7KKG+wlZB7WtaByloR6Oe/hgpioMgVSmNAAOrwVQ3qR0Dgw+meMQKFgP4HwPH+ZA
qhkNAQTVhDJNrWCWfN5kWOM7/GSrE68LlkCVZ/DBWiNrIIID64iPtlprvhHCi31bqPeD+mKvWdXFip/m
RU35xVazlKPijWNQ8HlQt6FQb9QXW03g1GtSKmbxj2Yt31TVRqUxAcALzOVEQRW6bG9S6AvppfkojnRk
qpsYT9qTpB4F6JoGYn1aqGWqi/y2NfCuPu2QCbmTXslEBNKWA121T/lV6RIDhMAQU7URdWLwWq8FakFg
g7cIEaKxNhRsguH2pQVJPYWgD9tQLcQXKBFuG/s4zHSRMSHww7W6jOaZHA6cDu11miWMdo9YBg0F1WrG
cAgE6GLXyWCWThf0VOJduHRcGC4cs2X1tlExuWFbDw7QBWRwPY9eMlKuwc7vQcAyOtCJ7rANY/enIqyR
AGLwGmL79uVyqyq0Sbq0a2jqAiGjJaMVzWs1ayDdqrT1Q5yojG8EbuJMw/e9Bm4Og27sY4HQVSRKS/63
J70/veJVvx3jwo98zov3AGRMYsuMU7gEbQ4dPR9yLF/Z1tqrp8pymq7WS3HrEHE9GwLKi1oHpqc168In
2wZBKzXFyGeHe31sggbCtMCFH5yhRBuLGG3bjcxdVuiduR9EgM69MEr2ujaTa5Jm+Nir3G0q/a1dC9JQ
PkPO43BcDDpxpif0g77YHbSgtQc9jPk+Faw9hbhu7+iXc3WV8imLn9MqZmnJt2+remm1V53oPouBLd81
OXpPQY+0dh+tzMAJh043XbuaosgE4gYWkqf5yhHZcTJ8prtjlWil51WG1PlcXu7Kiz6OQU2SyELdlJam
02q0E4NHNE+OHJo16Xtz1+BeF/5jGu6lD849UG0M74RkK+3N4TDc2z0oMhBPk0kw4Ef3eBqHekeLcmv/
u1ibbSU3sA/X9jIHEBeMZumhZTdB9F5sMCykkOrSEgsNP90poBWLuRX8n4A6QhHWKhhDj5b1esYoAd3X
9DnKhLAOSCp5rKXYB00zsVnuWTsNcC7lxbt4bbb6WMM4EScAbBC0db7/YPbjW3nh/PE8hdDjeDoBouC8
Xcv2gP14XxYCLvghM1/xgdUr+QSJuWKpiHP81AkhWbke3Kf/JDCP17BwfDKo99e8NR1mMfg0UF8xcp0O
U4l8GsijEceFert/mVulwIi9Eo21alPWb2E5ClgunDu2ROMnYYLSqk1BA1UW7w7JaNVs/F4seNreWwEc
494KRe7ORdALGHf2kDCycoLwhnlpHjFDcZDDwzTlnQwNfmGgNM+aIWzxap1rJApoPauDxeixUJ3Yqvv8
eh8MRTBJ0Jk8cUK37dppGAgQbAAvWdGUzpk4Yu3pH/2tD4b0locJeF00y9U9RQ2rjuDlMj8fEDV0I1fj
KAi26qNbOw+HzifdC20eMjyGpZnm4QHHgiyzHle5yTm3U6tvs+unD3KvRR3ipqdotJMpiLtcQH7EdnOg
+F0MO0l5lv09mFm+A+fYYmK3PgeD9luERTqHQB6pFOruRqGI+ea3ET0ysCPclynujXK535N8Aup3Mc0/
9pCdwA5G8baohSHOTrxqaNolRLHmG4Ufh90xCTdi+qdbLwTL5Y3qsLO6pKCQEzNJkEaaBmtUhX4GHNYf
RpD5RCfCPkeRsR0yx9Zo2feUXsai3/R+JzXsU71Mh6/ktkT3utdkO4l2AWFGX0EcEL1rUzWswQ4cu8L0
2HnstG5YDfJYqDXtLkcFgvb6il0BiPdnN3QFad7vjTAM67/DHhjGif3rsWFw92eeGIfnn4i9KOPjbDzO
xr/ZbByLKm9j6+/t3HDcABiy975Nj2DE/w4zJJgZ+58kwaD3t2sFg5SX5aYqrrKZfqM/lL3g5ZmhKqt2
M0BucFzYATpTLYlGWgKEAGDm/Tl82hu/9K/P4d99t+fMCtjfICg3zWMGaTy0p+qXkFt3g2nsCng9KSWZ
zA8RLVZksyEn/T76watLBh1RtnhnvqH+zQgqCd0zKglh7+Yg0r4FAzHiyEXxuLjxpowFYl2IzDe2UeG9
N/tSPOHe2mXw25jsxLNK6v34eE3ynGZe/Jh9AbB3vWIQWR7e+WpK50vIjBje9zK0byU7vHLB2Qqi++Hi
lbfzdZXhvcCLV+Y7+j4Tlqw9TWRr/4Ohlrg3ez+YQYCM3o4I7a6dcb7eslky4HwCGXBR+EfmagkyUBMh
TAavns6ZNvslljxK0g3NqxFRkND+lmH9zZsQnGEHE8YPz+5yQsRrTh/xdRUHT4Zmk+YQ7HiAyfBs18kg
/lXKwcWvLy2qwcX1yqcY9IvtWIu74fJquHiFXmV79b/BLurivXr8NMaeHiBym1ZhYKAmKtP89zQQLA6E
wGKhrceT+ucHGhoGAGq6NEp+1rEkAWEk4QqQKn+L33w66ygrKAnlBXXGDD7lZT5UoXxnVJesqdZhuGJV
zD8AHybJDgNKwqD0UxhMgsJZsSpyEjifVG0X+5/Lcp8I7HXGBAAZmNsLrlVTlvjehloMIIau8i5ioiK8
yV85s8x7MyAIQH2yReieykKivylhWW3ESdqI/7RV9npLceiNrZfPGbnBy41cH8eP+ECuGLbt0ylmmk2Z
H8CalNJ85Nea39b2bl7AvcvbRyIPkfZcfpuSCFH2YWINHfRcwJwB0QIVeXAirkJhnqJJyZgu5lGOjS3d
ycSg7VV6zFUOqWeg7yBKZNKsPjX2NWv6tdqdxGu1qhzFe4/Eq26ti8UFlW1v2gRRY4fr8U5ALvJPBs8H
+iFe7AzRfKhlDqOfZZBeUDxVhpBP4S14lchBR0m8VuTd/GLoLFgLaV+ZYg2F564gw1uRwyvqV0Pg6hEp
r8yhgtMWGjDI2gfQVT6Ybu/Cx89xI/ZhMCshw3SoFsjws+NrhW5ULw6L6h5eRvQPfe89YTh9vZ+pdjjT
QMrVwGaNF01ESNXwIGfeoClY6ljHvDZ40UwG2bYDYhwc5lr0EGS9I4Opr1eNzPCtVqMwYG/25rgJg/er
XDOnUWiutGGwLpplkl6nCR08yzJsj/Xhfc0N+QNzlanbAps0732nefJktCeR7nCh3rK3hPQ5xsTIjfo+
24zFov9uYEm4CoKvFw4faTCaqad/oHKbbr73DKW1Pi4P0c8lDHJ+sMSvvYq9ZcfzRrB1HqU5X4/gCN+4
g/r8zw47xy6TvWpBnbZECaqakZZhpHKL07xW3nt/Y9kqiqY+8mwiz8azoMxlmZkCZEruj5HUHVP4NWi0
E7vGEqIcmaX9xPBiIVdavGuf+BCaghhssKN2odB9IDIbTtsJwreCgWGpZYg175NNrbIeH+TpQR7D4wIf
ckajpzxGe49L04xKoUAsgJBk2+SIwmaH81QwCacJRod5+Rr1S+z2SWf3MFgbeieevR8/m/p8wtiKuBDv
kE9iVszbtIxSPYigsLCBAB2c+2gJsc7oI387eeRPs7eFAnERfLCRH4rT333kbx/qyE/bh2bAqwGBb95h
31WfltDRAmvyDHCZCvyiCwbqlppGNApvyLMgEnq8a0+vu4swJjgws6gq0YtdiygUf8CbqDNdhiawyVKc
t05NAOuWoyQaZfjM6LAv09oSyOOiqWXlLrPyWQF6bhbdrCknl6kcxBSsxgm9SiGVMTwZIt8TLovUXHlM
/7NoNF3Ag+VbPDoYCwQrwJBRG35728mcccD+IRKOOAZQeBF3jyEljN12u1Y6xmbXmYO9Y2jseCPiNo6H
nOh4yPlkDzm22CNn81GFT/X2gE481uCs47nHj9Mneu45zGSYxrL7fAbax1w4noRUizs8Ce1DkMfzUK/N
/TgPzRLs3/NUNCO25cEcgERQSeCAYSN+Wvtl6XAHrXfn7ZyoU/dso6Xz+YCwywLE70vUeDD6PobpQfRr
HsrPN1ll6TVE6oM7CEstAFcXAp6qwyh+iO4vUxrTm7QSk5cwnB+n8JgUPu4qpgskj/YvLsfT6t/ztGq/
STNdNbf382keUIe0TNXibr/QKVssSUVhdp4EzoIvpk+DqSBdrDjYnJiF4N9+grh49qAmy5c9IuuinDJX
vpwzVyZBdDHigFNlOn5/+5niYNlDmihHg+dRnwpm0x4Gfn/Q39GY30mT2s7QpCZCdHHicJPhqEftjWUP
ZZLsokFtZ2hQ0wC6+HC4KXLUn3bj2IObIUf/mGrhFthB/WO7i/DoGeu1ccvxY3nGZojU5hMz/Dn3zic2
7m86+sTGfGLeoTLmDQkMCDz6RI4+kRAKwxSx/QUt+Xr7dP0j+4h1OXpJWgQfgpfkfkyZLx74nDk6SwR+
D8BZcj8mzJcPe8IcnSZHhWsWyx7gVDj6UiR+D8CXch/mi8G/Bzhjjo6V6GE4Vu7HdHngutbRy6JauGV3
cC/L8RaSH+wn62vZ2y2ko8fFxPFhelx2voUUftvIu8U6s0KGtJmzp0/OERnEq4CUpEeG6V8D8pEeGaZ/
9V6HC7755ld3HSk0A5rM0q4nJtQMYtN4ztYjr9TPWMLWI6fwoycEAR9bMlPUc8jNZkI6671ttJann3oV
DRFYqh9uMrlws4+OcdT2Nnb3jVhVNCye+PCAhCW0szGEHLe/nY0N/LhIV9T5asHd4uebaurNsJ1nW8mK
P9QTEnYm+PrsXiUXf7A9mA0Qer0MW534HkobdmBbw8L6mzQ6xwh3PJvB4iG1QtweGs1WjjdFAjrx1Zo0
+OeRr/rUEwaMIm40MlMlBLcPpH3wTCe8dCJy2RkvdeJzVe/d0xArfAePYr8fty7w6dfEYECQoXZ/NiSv
U3j75JqKB1q85gTRSj0vSZjlDa7HHqh5VCijyygoWRNg/Sw+WoHNolE8+UWiJK1iRmsKZ5+yqfm2n6/8
WIm+/qKA1n/Lz7sxQT4/Bs9ok5quCpbyv4pnr/2PJ8rq2y+/GOPRVFxuaF5vLeiEYPPVPcNmeb/Qieej
o4ZzmsAr9xyH8TmkqgLQH+XnqVCdsyePsmJFGP+8SeOo5nOngid0/OtHge/evypWe0RDf/k/DI2yuAE0
3hQ3e0BjQ8oSn4ArZGk28uqpqtWtIdnUNcSzplW8iNGIFUUdyI3qT1bja8z891Q86jWj1brIkl0X1rYj
wORSfTHQ8b4Fa+yT8KO/42TRpJNiQ1K7zmm+YeV4bNLxDNbAbMupPzyYFF8Rf4FPAC62GtVmu7gocUmY
wF0xTmG0CT6rB9xtXLf7q8AMj4wQnk+OBONC5jM3kZNHOTWEVGz+UbNbaaAX/T0XzX4d3FozrwnIMdGe
SGznUjcJOnZuGjRCJ5DwFluNUiDkvAMdmusQZ+1/wU0LmKaCOL9DyTln/L6acUBD9lhYJHywXRfD+gFP
fxqDOdTt9HIaKXav1/g0HspsZZdZ8NrqXH/CROaGg/VDRDbSxceT2XREZsrMx8TTCF5vpTlZZrBRN7h8
TFgn/By1Cf8tADk3uQrnWi9fpw7Fzoc+Emw1Eksi33m+BPUlBbvQ2Y9dA8v2yLcoDnHraTQ2gkblKaXF
aee6DX6MM7JBxa8QL/B6JGIXJnYQvTA79h4koMkC/9UfdJ0oRLF5dwJUmxrfwPI0lkNS7iemKhs5aIE3
O7t0+6ItcgbeSIWe6S0XUraNrlJ9I/URC7iIx0B1A+KMActoybdp8cTrtdyWq+iKFRsZJuTc+3zEPi1Z
cZtuIDLIDoATzfDZA7/iCwwavHlqWXLstJGofbcU3xnmg6jMyBb1Ed6zxOUQVI0RJZ9VNSlb5D27Wti1
TH6YEHdFIQBDjFkUH57+0qoGcsVx2G8ykYqvcwyNvXYhLV6t+muqxQ9KEfYxo2dNOLKjPTofWaGMKkdO
KCvXkRO6wfMBmA4c5qTjYTuyHNzcxm43HceT9h2etPchsAMds7G/NxD0XImQeo57m/GjJAmsB/pZwU0K
9vQdP4YHdHQqQiPfTO4fT92HBgL9u8JrsII0CIceKvasatuxHzc1/xVgaN7dvC+YphmYrN5cbLJnS/9e
wPXPM4POfFzuu1g+Hptdrp1D8Xk/8BSj5zimei6+jz2erZ7FQ/B5L+Ba/6mjen+8D4B5x3u6mSCB58Jk
aFtTHd6X5wPL5ATvYovcR5gPewHltic7+v/oBt/vRQ03xeYMt1tWHY3RaGclJMCQh/WkxN4Kf0BAKzNu
bicLW7ueDckzA9O+o2tynRYNwz/0Y9NkGfOFp6k6Ywe9NqqgkrpHwsgqWvagt7WNYxKviSOI/x5TbwZg
/iq4chMEBmoCmP/Nf4ctOlBz9IT7tCyzlIqncXVkGJxsUakuaZxepTTh55JMxMmeGn0wuuKqGWV4HsZ7
anBHjbBtRPm5uI4yKM0pQ/Nt1ZSAp9FFSfIcmoNrCtAYuqSMw3CLzDk/x8iPnDvXRZoYj5/angMW+FYY
1iRwE5blmIKtGbEOslrX25JGLyD8J8rJRlzTrmsSr+ULaW3f9uZthe/bK4RdB4XAw8cFoH4BOKjI5tO2
S8uNh2H8NfwW42nclFD17vw2jAHROGJQH/ehiRVm3PWVQEaAWQDCzw6XfSfAdR+KC5au0lxMwnCkJava
1bQ/2+Hnw27CwqAsec34msIu5ZOcqr2D9EKgurhx0umUc4UYDN4tyZYJEWz206nQmKhpyPuQLMmy4oaq
6Dfc1EfnoTiQz5engomMHYJ0MWEHUSJEdFP7YLrlhyp3HT2dhziV/Nqz6H57JE4AeGecH+qaLOFbb0SS
Pxq+gCdwezxXO6FPpjMyvkrQoWLjSi7WP5tkk7sw6Sx08qaI7xYti79F4Ujfmki3MttRaL/vSWgzssb9
/jGF9vvOQtui0H6fILStU2h6tdDLYaC9j6m+L25p3PBVHVX9Da3XReJVOZVV5KhdhmuX4lA0U2GRKpQ/
5cXg4g60mb+9BcG0wIUf54VJ/2wLBzmqbT6dhbZo/KS9PTY4yHpujr2kxYqRcr3FP/QP6LzMdzbvF9v4
ZPgDVhJWGvPzYr3m3zGLu1+FhZp43YL/DvY+xCmLOQEtAL+zASsDjGf4aRRKsSlh3RGn6zUV93gwSUxx
1XqTrzgqDfM7/KDNQlZU0gsLxNZxAI22bhL6KCvyFX6KljIslH+4xcCuKVhh48rES1xP7V1S/XYep2IK
GXbSZCq3VDs7Ztbru36UVjBcHhEWQ9xbTXI+ppe0vqEcn/qmEPmR/JdxVLsFMdA4jZbngxu9YaLVk4YN
0eHadAF2FoE8H0FxaKhsGI6LOvRq9MigpPmKT3EUMWbIElsQbBO4XPOZ1myuKF+zOdexFsdyuxrJOyZ6
nTll1OIAIksIS7Sb49JJyY8VN9pf/bfA2moL3oozLiObZaK2VL7ImbeH37QN9oHppqlFAPgcjF/zxnxV
BMS/V7bwFn/lUUYSPPfTw+kBgT/NIBw4on82JHsk3uQoctgIwnAn2HwxCSzBAVlUad2C1/koR+IveQqq
/wXnyMjNO4HDLxWZhgYegf9KucDWfPHTGBBKumr7AppCghOXD8SFE/xwUfuqfJhKRCqWvnoOFartHdEh
Bh7/F2Ofs1AKsNkz1epOcZ/Bf2x4X3ivTYIFOXt3Rs7kBD2ZSs6dTggQAz8VcnaumoywaFHiph0TfhT5
f/83mBajmzsiZpUXmykrsqp/R+h26uRrymLYzUIR38j6d76K8tPUujsQhSFfdE3uHH8wktCpBPQa3REJ
aNC/5ssNnTx4uqav724Y8cUPoki4gsOP4P+8+PmnqFhCRzKYmRYbWrMtaNyUjFzexyoL0fxcdafbiYTu
eoH1RjQd72rBj+Fp3Ihj9kv1ZacOuY78FNIFvZSfduiMFTURmrz8MDwXvZUlYfZLMFaM2kbe4kUo4bpH
ewiY5NQ5SamnveOxj4beoaiz6Qn5hd2TMuKXV5Mntz8Vl92KtgqHZoGIlI/MNjvcCVS64OrkdghYbVVj
U9pgPT8WJ5RhLmJ668/RLOuEM1zcv4OI3ItfX4qBJ8dcml8X7/hZCFMhU59lxsURx1BzI1OB6XhIMcaR
MHN+2O2FLlxaxjwTH2bJ5ZkwaUgkhIwhizZfc7ynHYthL+DGhwOaMnx5h4HDODYfqm5D9EG2mwsD4Jpj
HrNawh4mb6EKi5cagP6zOVZ1px/2zYSq5z8QWIQO9mkBKt1gF6Q2FWezRi/eTcCh/7rJ6vRNj/xhPJcA
HoTqILXocCbcZ7Rte5s9/6tvhnsTv8p1pz90lnSV5m+kA2IwojfFNb0sFredyWzbD8LsVwcr6ITqhMXW
uqdRX5invayu6m9dOlU3hDgrKmqlzssp4VoxIp/Pzs4IW1VKb+K9gdIk9ck+WLeHb+E35mMV1drUz2yu
m14DK4o2u6atp/42sZ/U3eNwSsbnjOudDS8srWUgPJ/IW33dELpLwjDSK2dp0dRQwVlOnQFOiyA3FNZU
ndiqu08gffZv0rxg7nCrj40N+eMeYcOPh+U9QANFdHFPcAEB3RNc9rtyjIL0Lx7ieG7uGK7p37pUHVjO
ycet2gjV1G4w6DNwTlbtfg7fECj7FpMfoldK0pD03jhbqgfMqpDhq8caBdpJOn+cMTwsoLst2qMkyAtW
eB6Y1BBNP85xNaaWuA1HTiPfN4PzG3UaE8fAZ0W8G3hvoHgIBg6GB4J33jDwTgIz2D6U1Vla7uetgQkA
P8bOHYjOfledUAkLS7MyLD9xWZa9eXKwroE0DjzHSekv/Sa8uFqkNwU19AIOTwtn8QtxPX5YKKNVPM1l
DWcP6MGiwzIfB5QVur2G2p1lzAXUvSQMTdnwIxfOKc0ssYToefhMw70LJdyMxBKO33XT44t+LViRFylX
F8gKAiiVvbyzMwSEb12LTs5VbxPgP6cZaXKy5StnKhy3vaiSSWgksq8FSCCNafVEcf9X8Ydu63ojBlVA
KJZ2UfHPhiR86lARCZhHBLqCoKsA3FRbvDaNnyaBlpPAB0FWgYTa+GG0f4yOUhcw102WRRnZ8lOlTLEO
2QHpFWmyGixXkHHCTyH0cB79wP8Nm4NSJsYUlPNkktMHtxOVAFLK3ocp1n8yNaEWMtXAVo2rSeiKPDrt
4FGDVWbtTpJUpm8UofiVDFWn/qB81YtlxAeOBx3FKl3l0jwv+JpWIUMQzfXBgYQKIIGwzEc0oxu8V4V8
abMeqru0erCrjk5YpOvU6NZnXNOQnGiES1iCi8iKpPCScChLQGdZyE5aUdiEMpK8Qiw8Y8NscK+6t2T1
F9Qpq5dM9xC0bh0MB1GnW8H5t29Po9svNZVF+3z7lfb3r/qpS+8jHTdpUq87lNc0Xa3rGWg/TRKFsPD7
SMeBwt4fXZgk6gSCeDnhXnP1tV7wc0O2JPE7pYTa61qv5ol3hUYenhUPjYt3xs0w4A6WxzBgvWB2eNAV
vE0D/wy1vyGL/LsOSPC9yU7b+rqdtp8pve+9fRuZqjkdRsaDBh9Duh6gPoaC4uPipoWZfT3p78RC8S9n
ZULjDB5JuSYsSr7Ga4/wgNY3n/3/AAAA//+UC2WeQ6IBAA==
`,
},
"/js/d3.v3.min.js": {
local: "web/static/js/d3.v3.min.js",
size: 146805,
modtime: 0,
compressed: `
H4sIAAAJbogA/8y9+3bbtvIo/P95ilin9SJFUDc7SUsF0krT9BonaZy2abVdL5qCJDYyqZKgbTXWefZv
ZgCQIEU7aX/7nPXt7lgkiPtl7jM4WBRJJOM0cdwP5vFB4iTuh0zIIoPnYr0+4Mnh4UGcvwxfwpddmU/a
+XprkSzlqvoq8OsizZyrMHsg+XCcdOXnw7Eru3w4GOtissqfOQmT7geZbctS4kEMWdxXF3+KSPbmYhEn
4nWWbkQmt07S22SpTOV2I5hgH67CdSECORNnTCTFpcjCi7UIDoY7dxeFMlo5mfvBKsLlrmq6gNFXb7E1
rDD0EurEKs6rHKk9cI55WJnr8HAu1kIKepklZ1WpEFrBUSV8dlaOHzL1YLjPQ+hhuRaSulrkK3jauSyp
6ojKOgbjcm5N067sRaswe5bOxVPpDFzOeRQeHnpeYpqzasqdanXKzrvxAuZ1vxJXlT8Y6ooOBlVF69rk
LXAVmSinx9pf2FLGRS/cbNZbR7IwW8I6JTJ3TfcyaExOkyCz1maltgV0jMaZuGbmxpKr8VI3ezL9eQMb
41mYC8f1ZC8vLnKZxcnSGbrlVAk+YBnPQ71Zx9lEjD1PqL4V8AG2jyfH0FhRa6ywOrSsjXdTe7uiPV+d
D+sAQLuCFdwfsphnpn3PK57EY9eRPJsVZ700cQ8PpZkgWI+WOUp2aiCzM6gxEdcPinIvQXle7SFWqGHF
LIUGl0LCZjJZy2p1R56MpunhYQoVBA48OPjE8egzAQuWr+NIOAPouOjFyVzcvFo4qev2ojSBo+WYDLE3
dF2W9TJxmV4JaM1lxeGhUBs56+XYA/YBmih28AkACbNO/xzm6l3aE1fQKzil9Pu1WITFGmaxynZp71om
uSkyTmAz5GmRReI5vbuSJy1AZlsHSjh/G6Z2RXNOcGM8yaCiWfkFdscZv7LmEaZ8UU25YNn+vi8USKOV
4IXdx6rzRU9CGwL6w0waL5icQTqAqjO9IbD6HYDAcL3elnPF492uNpE3FmxahHB45mENgpxU3zsmsQPH
DhpKFw8SOH3WkdX1rLAegg/WOTj/FxUt2yq6UCfcQhwwZQgX1UZ6KuEYXxRS1HBPdkeml6cAwPJNGAkG
KCmNwrVbh/NUCPaiVS20bkP/ljz7tdbKpBq6AVa54/DiWeJcTO8YV9DWK+Hu445/10LLpOy32DJG6EGJ
5WDDJXnvryJcxws8RUw1COBaZZ5mgQhaNkKVIQzSwDzHAATKwV3X6AjoDpxyGMJmDX1x+v/Jvf6SdR50
rOk4tUvAGX4jls9vNk7HmQZ/3P4HSrgdDzqcib+KlCbYw0/44fYzt8M6S7uy923N55t1LJ0+1AbNW5mf
t2zWCrv4Q4IaxdhNAFaoNZKNXWvnBrBz13ru1QOHP+HY195luHGeumOFs5ISl911FCUuTdWHpzhcBf5w
GsdNgEVQDDEgQPtoHeb5iziXBhFm06IXzue4ZQsD6BPTFYFYptrBHSrdcW9vO51xNnVkD97l94hAAODK
nhS5BPB4eyvqO1+XY9dO4cGye4nrusHdecqdImmTuDZoeWaokX24kcvtWughVDRlK7CgnNB8lY0qrcMM
Rd3cfzqz6X1NB3e2ltknUR+7rP2w1Q7Wy5bNehd1aiYGErmsz8KnAZ56xYGpSzQ7fgeUKIDqK1t98VHc
4uxDJFfDln20QxObXici+zqNqN+9KBOhFM/XAt/akEYL9vqEaihLEl4Kqu3nN98jnVON6+9qXB/Oz+eh
DM/Pg8TK8JeNvfc6cBWq2a/V+dZmVxo0zO2tmqcwj0QyB2LYZRaBWFHpEui0KST1TKeYKB/d4ED6B8Jq
8Y3eVjWiOrFpauF5rvlcAN2IUAzI0AELeWzyhZN0nEI+ADTxLD1DytcpWAq9auFWvm5SNds6VfO6BGpM
7EG0jEEf1OcUepDM4rNesYHRCRbxkhfA/sYHXAD5K3gMtOUA6NcJh6kB8rwA2nZ84KQ8nEnsqufJJ9G4
7Glqzc7PJYtGm+H8XGZhksf47fx8nBA/1gsh75UFlP9sBVQKStNJSs/G1JMKuxMNibBZwIak4rL3mcvs
Ywizun+SCx7B2n+VOtUZhnH0YNOvqXqXCDSE8nstqDqBNC16n3EB09M7t2GFAYMwEG5j5T/Oz2EVZn/0
zlrw8medij3LbD4UeCLAdMi5C9f0nHqQwVTcNQ1yNjxj1L/6TGRnO+KbUt7BzgBSwY1QcjOdXseFvfAd
bMoBzDLwPhb/CLvWVSgu5ychcVIV2swpew6Fv3FZOCU4FsjpMoireflOnZc9RGuQRskHlES9AOJ/cGY2
kDqHY2QjEhsIyxZ2AFjnquFvVMPqkKpe7B2OxN5mdI4zsYajMX9LLMk4gwESX357+8UhbJP0chNmwgDA
16na2cjtISJXu6gOoF6VB6LTm2fhMi82wODlud/xHnjeRQhHDdB5HL3HVRE4GzmsXCSdb1MX+FCnI9Mi
WuFaY4a5SqOKgGuSVpoqZqUiI38emmn+IVXIFbjwbHYeno3pL+8kaSI6u+a8xNZZRPpe9AhmIhZzd/SS
qBd2HuIUUV2Fy2KEHyqvBcCBvWVQy44dAFQB5P42vhRpIZ2UDWoEy29aCIaCjWQJi4BDFznBoGYi7BC1
LeG0KbR0+su3GhXd3iY4eKERFHx4ncaJrIQw9XSHpmowucahfAvzFGXpev3u9rZ8/g3OoL02nYt0vu24
uB0Bs8DcXwFNrebX+bDRuyLohBd5ugaCrcNkugkGbC0WEn4uYW/FCTxsAMzAGYOnizSbCyBq1GqwTny5
STMZJrJTkpcwYPg/HsBT6L5Inr09gY5fh/wAqMDF7W3RA5hkCCunpJiuw6mT9W5g/jbhUrxjWW+rn39z
A/0F9h/Mmvmm3n5z4TgQDMrim7cIxAFOXQKlUO8AAJErkaHUyWUzqA3rONspfp/yfpUWhHufUa1vcPbM
MZyVLfuIFxfST3TCC3hhZU/gK8xf+fFturEot+9t/mUymA6DwSSZ+vBT5fm9LpZzELz4Ce6griMAZsLz
8Mz1CX6qZ0w3eap6fqm1NZwOAn8IjZ2GwUkoV4DW0rxGRL9r5H8eqgL+c1Mij5Naic+qEg5AVsokAIsA
fecP+4nbH1V5v7o7r9fM++sdeUddqtntOwng+Cr/D1Z+nZ262h+5bteiPL6tCQB/bIg/EQ3+tMcvmBTF
X6y4Qq29nEv1sOYWaQCnc582sGf16NFgmvgcfnDhER95+OKyR7gPYs9J/Ri63Ifvwy8wKQ1Gx/YnB159
mC3IENv0QtUIDT/DfeyMHj7sYvvuTgsXS2qNGw0B7Aon+Zz68AS65mHPUFinvkv8PphI+CthRwwDJBcG
EwHvgt4FUIq9hxNgKUTXGXoSmD9P+qIrgZAcdYWfsiVQirhcIyTRUBYBf3x8s5UTsmUphNxbizKpsRhR
62JkzVrNmIkMgO6YMRLExu5JYKhp+uhodPnL0IWRVPsJ3mwira3X8X6v43qv16bXoen1hd3rtMytwD/O
3SO3Pxw+Qlzoyf7DAUp3M1/0R4NSNwOEIvLn3W9CgIPwmLndVyFkg0fYNL+FuAxr6Rz1YPscPzwedQt/
2Ht49Hh49AVsEb93/OUXD4+Gx93YZZDN73356MvRo0ddIKV7Xzx+NBgOvuhmXm9wPHz48JHO1BvA8/HR
MVTVGw2OB6OHX0KeISQ/Ho0ejiCXLRPbmysAfrDsCq4A6hjB1Eu3+yLU0/0XrJ7sSk90BcqfA8g76A8Y
/rMhUFTTa02gI4+++PJocHQ8TbrwH+xt/7g/+tLtP+49/uLx4OixpVRpFB0Mvvji4aMpNb9Jr6G/w/6R
G5iC3cTDmixdirz70MHkDI4GxxOeTIej3pcAtwKcmIfdWu2j3rHrY7I9Uwu7Wli1ZDKBpYdKD+HpC/Vg
ZV/Z2ams1+lYCpC2PbrZ36Ob+h7NzB5dtu7RK7vR4SMAT51Bx6OxXYY3Di4R4MBTrdJ55Cr0cQlHCLrf
/GjpFepbHzlBzYgOgGYfINmT8b4zC/2/gTv5j+P0uu5/3H4MuEFECOby6xh5EKQZR2daLNhhwC5kiCU/
RGEuOqt83Ql014UD9HEuvlmnsD8LxJ6slgCF+sPBoJ44UonumKrLlhdldbCdTTUnurh6gCKGwnFi/ovh
S9wpnM5exuLeEv5dAIFTanA7/7sDdHxS6cwARh1TiuKAp8Dell+HQK96nNhlkzQCBsfjIUxbmXQEXJPH
I9jRVj2oP6oxUEMG+cJa0hF76FJFVdJD9hgoqJTTxHyfIG0MKwnlyoSQEqIqIcIE4FchK3TL3vGX+8vO
yw2T9DnuGal+BP1gy+VmU0WhaUCP0J6TejHQEqXybAq7ARBUNA379CmA35GPqBT5J87TqQP4yu2HniMA
zz0KBgBrKFkgmg29EcIQiU/HLOtywJNAh3KEQwBzkQMdQuWDIHPZjyS8iKyRbcuRJfwGVxwQ6w3q9gCL
wq9Q1HLGARQ5vePh6BgAKsCZ3tHDxw8fPxoC+OsBFXB89PghQMH+NyGgKJV3NBw9ejz6EvM+Hj4cPhyN
MO/g8Wiosr6CrLHKOhh+eXR0RFmHwy+HX1LOLx8ieBpi1t/Cks8EhAZoBlHDIwZYputkPjBJI3wq/Bo4
v5E2xaUW5QkH/ADIZZr0CeYFJawDFEZQrk8wkCHYs3RcsmJrrXNWcu2dz2snwWxcoAKnNtDtAXAF6sOS
cJzLf6H0suV7FzUEYalAZJvgD5bZUimOoM9NAR+c6v1uCGLZBUphiEE9lVRTgioES4eiNxK2sCckQnIt
AnYulEWOMPJAHh5GwFnlmzTJxVtxAxymnHBYx8PDowFQc7e3sPgoJlDqzoRrWUCMm7c0wDDisp7IsjQz
OWCfX6Xx/MFgl/ZgoeYmHXCSWOeimT3SpCf/sINDCyzpPM431ELnQgCLJnLgSAFEb7J0iXIGeMRa4Yeq
6eDBhqIRyajenbz4TsrNG/FXIXLJcpoyY+UA3O+7r9PLME7099vbDqCD1bNMzGER4nCdd2IgGG5vD/p/
OCuox8ndaeBO/9P/T7+vFByJe3vr6LZqdbmskybUMaxiGvXUG8cH6igvAnwGRn2+xZUQiv3n1g7DJYGv
p/h1cnR4WKCIAQuZsfN9Oc++tCkh0VLaM4Wsid6TL8ndDvDKCloVmVW5Jd9KkLzsdBAhv0ivjUUGazE5
CFFP4Bi9gBbXUWJIWgiohcUutncZX4q3aLVjD+cOmTcAX67qhOMIv0Gi6oFzDDWVW/iTa4MtgaVzu3Rb
SYH5dmzWAUSMuy/NZeds37YHCsQ4un04Efdw42oBX8wgk7GwqAtr4RADJKbMNdsDNPiAo/rJYAIle0DW
IM4iMAH7ZiOwpoSkVHpdYMuHUSQ2ErdpCHs57Kl3XB/W7XdRcor6Kr2tv6OtUUr/1yjSDd39HM6ahbP1
WSXsJzKFwEx6Bfs/nosTveptaYjwVBEUjkX1dc3Nt+LwMCbRoDr5MEP0psCBvSQFbUOEOEAI9CowUh0F
GiRgBaPJo60FkCvGfRFepJlsWdJIfXEoGwm+L2KoA0hQPPwdM8nZNA5iIuDeI5tl66ZrVLFNrNX1OIlT
qdeUiDKwsMtzWYpgn2JnJH8GPz6c+8noeOrE+TdxEkuh2NZoLcLMyCd/BaT/a8gtieVzIN6B5voKCGig
WuBnyL4NIdXu9dOqva8BMvUSQNhKyv9DyN+F4x/CsZtM+A9hD3Ua8LPAZyC3fUyC2iEbPLWZrT2TTQug
EPDcsD8Yo81PbzGVeOx7aA6UBO9C+nFkTz5Reh14wuEDry7dXiXF/wyoU2YxIy9lDaRJ30kUZRCJeK0Y
zHW6hKXp0/OLl0OYDFt69ELaoveSahkO2FE3DZ0vgPozjX/IYY+JQE6+mLZAlaQvLFWkld4VO5ZvLy/S
dU2B+LdF+iS9uYjiSzTkgGe5Sos8TOZKyL8EGmcDZDdDC4KoyDKRRFuUAdQ6YVlK6X0H+WdnkG+AVmXA
lsAWAhIgnQzGbqEsvWyaXvrAQkgvJcI+m8WcjMQ+N/ZvpRkkKvG1ELX3ZxqjbmQXXMi7lBWC/xQaBg3t
6oArAjD1oAONCGCM4HnSASQvZkf43AFUL2bH6jGHx4dnbM09MXt0xhbw+viMreDnizO2hJ8vz9gG9vQV
h8xz/HPJD4ZjzQUib7Pi3qpmXegyJ4e6B0hTAkztcHxI8SjlPOOQDt2CRLaAlLWvNsNincLUwuvQ7R8D
SGdLzUomnWDBDwbQlc6yM74A9P5eMYWfdwLoFzCO0KnPO/h9Ufu+2fue1b4DS0m/qf690b/vOoFiDCPo
3hV211vWUbfmSiNdYN4JLrGHK+CerfpzbN8fqoZ3nc+qKpF7hV4p3hU+HvDl7S2qpmmMBlTj1MIr58vp
quLEhqxi84ds5QLI6QjMBBO+wF+XVsQSE1T5B5gfp5YnEQHXJZBif0nij7aINhZt+wsw6OXhYfL5UJu8
dDpaxzKYJLe3AwTBh4eDybCfTAGK+Anr+B3gAJX+ZGMUlQDrUVkQyteZWMTIUa7ccYL2f3jYcdvO8YXO
ryJyky7fQI6lyoq1IHtcWswYJeUN9CMCNqOuoAT0dEIfOp1Aeva3iBTXOFiYqBseOzdal3nOr/Qp9G7M
w4l5cLYojdVvLrvg68n5FEnYp1kWbp1zvvbPoWJ1VjM3QAMfNZVb3cyFBw0x4fErBnyqd8KczhM6F1Ph
Jd5FACeU3i48eA86f+i32qjOJxM+dD0qYH04R4Ew9DAJLtA2yJvbKs+/agxWTW71VhqLnnMixxE1OU1K
aTKcEsr6+e2zdnuXoLIGrWlG3rSJ6UsMgApSgFQxUFfDytzZlxPpC0DZmS12t8wyHCxJguvIET6CmqFr
46mYzASr7AnXmWFiUIKR1GzWgUQ0ZhCcxOYhWqLDxo0nQyLYxtkkHbvCSd3P49vbUMNzM1UExkks445p
y1ZF7stqCGvbmNHIBYHtEBF/K7XMAsu/LaF+huvEUifTckXNikABbGO3SxQUhTyJ4tiBlk0IQ/MCHtLF
AsgWHuNX4pvS8lQVEuqwtfiRrioCKk9V9TUSYvBG1X2NcnCkj1WVX6MAHHNStaE9y1/fxcd/ymAlQ1sV
4fbO9wdrmbrIhpF5/c02zNHSTkDYIYJmlHd6XohGzUePSwGItvQPXbL73kPhEVo/aBgN7EIRzUQlOYHa
XDSHcRppgBJj/mwm9LdYK845L6YEvrmYAroOANkEBdIGqlmBwr3Qq/bMnd1JFeQBLnOnJ7NuBfkA9buZ
zaeVqu8P22D4JaDJywBQZTBk38HvCfw7hX8v4N/vRD/vgM4RsBi4UQekHC+AOTEA0WJZxoB4gcMhK4ne
dxz+fT4cecNRN+ttFKCNuZq8rPf74aGIDjhsAVgUWH4nnr6VgYhKsdSfVNUUlezyGyj0G1DiUO2WDVjW
+xPA7LVpq/MrPQEW/Jke3KnTVgqluC3JujSqxa+9R+7nj73H0N9ffagD8OTXAOFd7yEkB/gdP/1c+4Ql
ABPv15z1LuHfXDf6XVpkOc6KZ5E8MAsk6YZ8Jx68fI4kS9Y7hX8vgEuCsZ8H6Q6tQ7U4v4WrSmoG78IS
Y1UmZyzVIn6zaEj5mU0STYABQUyfTYBXVLX6Q1plXvOhCT3PZXRWFG+dVi4n9CnmL2cpcrhFNK19CdIz
dgAw1EGYn1Dv3CeDsimF8tWuEnaDGZStchnY0HCSQmhyYRvTaohyoWhi2/dFuBW2AXqld82viRRC0r1B
5QGyplS9xwNo39YFq2ZPWpo9+ZRmz/9Ns7Fp9nlLs88/3uwlf/pvmk1Ns6ctzZ5+SrPv/02zCi1WUlLc
2M96UaXYcumz7QzWVuDm7gJ5a4F3dxdY1/XGN8qNyB46kngjt8kw1Ex+M7RFQXc9TnbMWNUCeVPAayhU
AEZCvSCh3pOYsoGHjcjiFJjVK/q6zYFgBjywSjMEQjlwZTDPaSJXOduaDyf0PpaE32tsrAUrmohYapKp
whxIdSDpto+EtY23RTiIJp5pqT9TeaxSEr28WpA8ExXYy8pHIPgAHl4WaxlzGpt+FoIauEFmA10CkAf4
UzpXLjvn39HvBb4DOL7Gd/g9xfdLl73Hd/h9ju9blz3F96073rSIK1GKcUPOW0lDoou+idSDZ/xD2Caj
mM+SEmmc7djTtjxX9TwXbXm2Kg8tL+X6qi3XZTNXFEhnAYxW0Cqm/lk6umVJg2EjF+b/H+T97v68CvuZ
zN9/UmYgHW5vhyNd5s87yww92ARwKF4tCPWiDpAdQYkX97dyEq/XcS6iNJmrnmGZy4+UUdPpDXWnTj7W
RFJIUY1707ZSm5lXGzZweSNcsNP76z61eo51/3xndpidHIj4+gRhketWUVq5AXfs1/vqBHjTUucNbDPg
kd8FKGBg2/vHUJJLLhE+qobfPr2MOIYyx1AGyFTBUCi0Rx5BIkCSl3gmMzhzBZypGE5MCuchhMPwFcBz
/PNd8IOEbQl//gx+lbB1fpKwFz6TsMLfSli3NSzHjxIm+ZWEaftGwtT8JmGwEYwUYG7wu4R+fy+hI79I
6ggAsBaHy58bpkdod9bxgfTvAIXtAGpIAjIvYegcWafhM1Sfx5bYQfhxKXSQrlcA72BZ0Ms7fML+cKZB
x0sIRFa257qazm0HWkeXsNh2CftO7vuJFkx7bCVNB1EFHYHbaQDIypPBmpBvygmJoxbyAhL36QtAssM9
iooIifvoiVf/oqVGKz9/vJXf/uet/PrxVr7/d7N23Ghp+/GWfv93LY32WnoHrHBGhjv3tPZLw5aq/8fM
88/+M/9wvPtMK5DR8Lve1kPXxSZ+556kt1qN7+oCMCeZPPpiihxvMBJHtp3tf2ecl6QFgHNxzyC/+u80
Nf/44v3671o6arT058db+uG/M6bvPt7St/+dlk4+3tKP/52WTj/e0k//nXV68fGWEmHrw5ZKj/l3mohX
JMtDKM3lZKBwktcB8P5//o+ThoBf+mhCXXB6/vxRaRUrPEBpGUO1zsjF50I/W6bHwowubRtd+ikgvjak
2oiEuEMzV7ofS+U2bDyIHP2y7/uz78QHOccHaNmIQQ5cTIAKSzUddgkZI0seIWrm74WoY3vRy3kCUKrg
mZ+QhXExBh6HJ4DJHenb+DtWjvgfksPDddRbhfmr68SK9YI2Cy5+mqnns4bbfioaBn8q0kZp2iVI/Sx7
6zgRp+gh5Lgm+gaOsjgDFmtDrjC0o3AKGFp8umNV5nkyt+NQhMLW79bJAtXQJl1vl2lStUW0AnYTfSEl
SsbLTI3KI9GIxkPzgqbjDJBB92XYH3mnYf/YOP/4mTFeRBtziXL90r5cokw17oYs50U39aJumU+4bM31
e04q1/EqIuduy4B6zXKXrBrxJMB8hjvt4MfIpnK8jNSsVQxwykL3Q5kMnDQHDJa60Guoomw85I7goVuN
xTUGmtiVEAhcqELPuy0BVLJ0awPm9vkmWMATWjtuDdR422Rde5ayrj1L1jxYvjVrUbdtgha66DvjYSNd
9JaBpxE+jaxSi1qpmc47Qm+akSrF9JP2sKGvTD9pDxz6alW6MgcEm+f4kWE2fNT14aPdjWWzG1g9U3Xr
Dli5N9ZMVvbyVCgpR5yUI07ocOCXPleVqt8R/lpm3aIiR2bWxkpUp5E8eudQXVZX5vVZBxCMOX0cs/vk
aXh4SClDTBlSimX4K6zjMrbML2jRyf1ivBWOqHYCasq6lj8Gs3aFbXdbAhjP20RsHnncSfx55Pbh7RLf
pH+p3rb4JvwtvVkGrnvHurD7GVf9LKifcKjjWjdD8647GlUnpnBZzq3prRbQybnoRn7WhdOWe2iS0E19
2Y30m+yGvujC+US/XwAQoht6GXwdX8EgcnaDf7uO9OgQw9yod+HR8XXZuXoHVi3jEbxvhTZareDE+P0e
jCB37KIcuQW8YrVC0Fg18gJxdNq1x5pVI49d9r6CNlX7ljUwznuZ59JSn57fCWjbdw7alzRWRNy1ItIl
kBv5CHzXsHIprEHEFjD/oQ+gmK2sU5bDYqy7a2/RXaC9AiyRV8BCxFBgg5YR/i/O0u2v2JW9xiu2dMcX
sACbbs6u6ReYdvpdMFy+K1q+K708ZvngvfCcolw+eAdkHJvlU87yDTC/v4QE5mGZGCpArQVIy9mLLGiv
VjXjFvpJkbiy0E/awABWX7D+O3GB/fFEMHudLbNrUYpH7NBl16XuqAyWhcrSVKvFk3brzYVz4DgV3eUP
3Sd84Fqu70RAwI+kWgCYkfrnQ1EjPgzhFQJdKCchKmbRgopIEFSnzsIzl/AZgrjKTqqkRYzJtNZpi+sH
7wXZbpIhI7kZW6mYFrEDIDqiXgrnOlaa1ajUveYuK2vJylqGVi1ZWcuAdOHttezIgDJHo0c4AacCz+ep
oNU19PkHa+homgVNpIZ2yvVMpDD8nuARP4jKmVqzBRyaGI3OxlUlS76CM3IwGC97V2OMG+As+bKXYNw6
o6gdryHlb1af/3mKKwmF4FsKf9HmqidoeTeu3cOcr5u9K9dpwddmnRa0TqTXy6DaG6gtgb9D2Flj6hHp
/FT1H7BDm97f1iZYl7tpHE5gS/j+Pc3sas1s4K9ftrPZ4d+UqTHDzGx216sY6JgDGKs7tnaQbVRwKvTW
rva1HbsONjBH5xTc2jADGbIYRS/huE8z2KO9DQaF4GJsEgc60WrivaWoJSucG+MQ9rdxCEsx8AE+CJ6p
B1iXoXrS4TQ2pE23TFutWpvsDaEZS6tnMSYFvYwTirxHVCO5c6G5sJpz2Qi/ZVH7hQqkMNc5RXlKbc2c
+2GrAVHI5vbGs7VxVaZUZ2pwAmvdrjpdM3gpXf51L07u6cXCIYVt1Tbgj5lNUcL3tXOl3OoZ/ZJ7WdWT
sbGyPemhWXBC7PJN76JYLETmkO2lORuwd6CbKaqhNqq7V9gewQwVUGp4iNiV3PiVR7/FNMH+TZF9pSAs
DSYtRcbJrIuDmzBVZ6GwQWO8DxqzyfDwcHQoyyCEQnXQCly4ihfQCBoJmhyLeC1hbE8F2tkTgGEbdsXm
nIx+Lnmh/P0tPhFQFf9AvQvg2JmuBxHTHQpyZjODtsTeLP+abatB84V+Q5QGSB5R0oasbhtM5Y5V/GNb
rWmt1siqNYdaUWsoMuARlnqZ+QvhXLINgBFjYw74ccleIlIR6AKBvuW1xWFCm83jH2C3CcibVXCr/qpV
WXJ9eFm+WYlM2F1uDo19ejuNZnY7dsOfCdKGSuem3B9bCxQ9FS2RayeWjAXLl35QZbTWD9XiWl2X2kgJ
8tGK4D5oGOfr4wsvmMVsiyVT58iuTIfaKvUGuOwmEueOZQKVFvXGTedRpaxCxtY3uaw2uQ3wX9ZYLIdC
3tzgqUKPfWStnof+0zCAvzoyBMmhTQ5ZyyHrYOdFTTZSUkMYmIfPLDab+bYsYmCsygcohkDviwaVZNny
kAEPIuIPKiqPBOwICC+3YNG6xOELjpaaQDks8GfJEYNqoQMcq7I/S9dQ19ihJRroDpHOmAMhsYaNP0dv
/gTqmivodalGtqWRmfpuqvq2uAHL+raolL/0V+wCBYrn7uQ0ZNdAqN9gX/fFLtcVXXwO/eqeeNcV5XyO
8Cr2+MX03HPOgViYvg8D/33oBufs4o/VhIs/LuGPmpxTvhBOLlARTqISdwx8/qk68e/xW8FOKe29SnvO
nYs/qFJ/GAzd7jvnPTH6TjZ5fnuLgYCew2ScwtBvb09x3clsEDqjCg0DIId3SCLPPc9V5uErDlCF3+D0
AvuT7IzXMuyeSXx7i3/RonoVuX8MD1PLlUFYQb3IO9b4yMLfe49kUgMekg/3zmXMUlU18NSTAcYv8U/R
sxkWJ/aBMIDfCFJQtoCCZo1jUZiVeanbH0EZDGXyHKOQ6a8F+jEmFlyq98JkC1U29UK+jxgnIigOOA8P
D6MJP8UYPNC+8Asl7IAnYCSfIvuJvQt1auzzkFIz/hexGGj09u+6Q5EqylFy6BUn9iysgNXe7KpKgW7C
1dgxIg9anF9HvqyZZ1vkWmmpZ0VX8SudKQw2dScw/+W5cByLuwautTpewF7Zgky/fM4gX2HLRl2bX3f7
TtEFzhzdCqSX1eLFvG32lDhC5VfoAqnbfQ5Tp6cM9w5KJfTrwH6pf4K3Qe3Nr5Wz3/zGV79eVrU5NoaE
NRkZzJphZzHxCSbqPT7Grsf9UVVPfGfX8YtmNQxVjCCvAe7fiKY9siW6s4Qltux1Eu/qNlnKXDkG7jJn
63vPdo5M4RCg/f6hBvZQ1bREegnegKgFGgCTAZqn06vpICjoNbiawoPnDCYLPS8uplI4iANBnjsRvwLQ
Vj80VwfKp2XJMzhwG5cp5h79SuBhAw8IDTckoH0asg2JZ+EBe4GplILQmypy14DUrhC82G1g3Ruy3ddz
viS0RQWDquX9r/Zhx4O5LPcGQAsYU/rHlZqdy/H8EODugXOpmkKGHp2UsTtpszumnUvNJVwaLqH6MNQf
hmd73QicT8l2B2hqNgkEzMHV7a3ACPs0Cbe3Jms1uTDwDcDxKyAm5q3QKzKLagCYIknvgl/rWycHsOw+
eTK04VhW13MRasVACuSXmvLZkA2QogkRw6JwCboELHjIQhSohNjbNY/8vKuc69cmvj6MLRkroiXuRv01
UC1+3M3hYYk1odANtvYSnxZIryyxzpU7XuHuu1IYfM6XwKasMWWOrAk8zfHphl92L/1t16FPG4x5RY3D
IbjR0qsTSyR5gxTLEss6/qV/4va3lB1aOsf9d86vBNImB8JYw59T6xdA1hBhdKpUFO8V5fectBTj68kp
HJALfg25TiHLheryU37qX7NniH2faqzLXvJnRBs8pU4+Ozx8P3lOZd9Dnc+hwguXvZw+m773nk8Gf5xD
7U8QCJ4jELwmvP0+eO4G759w/HZ4SDn48+ApkF5/ONeYPKBkgI/8VE/Ai3LEnhqxHhuM+gWOenbOYNgv
3LNd7fYIayek0yQ4BaIZqRRd2s8mclrc8mEgJ+RzfctHQPxmE4Gpx4EwqV/AFto1VAEJqQEmGLAGsT+C
dthLEe6/R92XVZyN50rwHcEJngEeSc6CGWKIBP7YwPrr+8Ql1X0BRQ+2Kvy9QJKod0MSui1s2RCeF/B3
i95/sCeHsBvXfgQ7ceHTVgaEA68bhC7QaZf4/rgPR5J843D/TGIjlVsi3QcQLXZLc/gNlKEik6XJFU+U
02VMZGXMhal/ADXt199esll/ey+ofunn7KrZ/yuo/+oT+n/18f5npn67/1X99/f/6t7+m81KMUxhCfmH
myDyVt0N2wY5/F7tXDacLOnjhfq41B+X9LHY0f/K3fJatIYIIWl5RaWRAVBCR64AungQHAUmVZSpo2Co
UlFrV6YOA8DI8HsUjBpW/1UDDopRkfVsGOjb4rghUsF4DivfIXGAlufCz4IB+RuVetVgSO8ltRSM9LvW
JwalVnYvJmhoTUNUt8IYACaZG0uMkt0djMWkQDuDkhvF0zWEszVHk4Mq+rDGCsDYpijxcmN4Tc9YTkAr
m8bwi1DidydnGBcFV9jzZBCr79WHJ/DB9zGOSWwmYgATIW2pY4zBkliu5g+R/kLFwVLEbUyUQEExD1wo
6izghaIr3d6mWBba+CPCfThPH+SGbEQm+fb2CH8AAAq2ngynWSDdsZI9Q43O2ou8Y/fzY6x0obe0KU8Y
MazTlWslvzWajwn63YoJhXSgqMzZhMe2rJO2hBKYHh6GuuK6kQgKPF9q4RhgRyAklMjkEmU3gI4OBoCX
gLg85xfE1VSadBTNIGnnbBkgxpPDw+vDw6c9JY9BwlDV87SUjAIFZhpasGvsT4t0d6MVjpX7sv80qhyY
4TlBN8q7P0vXSIPVuEnddHh4aYuLgb3f8gSwv2QnXOAghwwp3LBGc9nzVTEVkO/atT/RF+NIFwYAQs4B
fFyg3T48J/AM3N74mYP+aNcUK6StkawXUphUwCOunXpBqReQygS6n1ZU2nvotRvc322VaYfeGxcw2Gsu
CJdesTm7ZLBs7ISdMyBP2Cl7D+RDyJ4qMeEzbiFFtJvWXIUlyl1ZMru7RLkhf0rideA0Zkj2HAzuEs+G
QL5cVeJXTbZJHuGKZUTCvj88RKMp46E9dmA+CpeG35CT7s9JXpOVhjhJFl8Ax+ca2gRgAUBCfbWlp0hU
zvmlIopLe+6XdnhzLd2z+DebmkCHZZrImkqiFLUq2TnKKs2TI/RjLZaNVZ/JqqpFCrlMqBqoeUX/aVmy
IFw+DftHCJMzRaRnSvdTqlQ3YRau17CzPykeUOYoQ6Mu1Dr8YqDtjfSbG8zgb9eRfeQo6VHg49mOWdcy
fLc/hc1gIUSCx/6oW9hGSm7fXPY0s+0Ouhh3OvVrpgln2lnJtk5Ag3uvVt0I2KShl3UdDN6ZlTHwVOtV
aw/218jqcOobeXXNwAfmuF+wdw4MA7qYUNRNGE7h9rE1F+fEWrNv2kwxXkYeL7pAQHeltkGTtmHC+M2e
WQLJ9d5U5giSZzyGNSp4umNvPs2k7JVejhcRRdN9EXG87WbyF3L+f9HL39EEd+7fEcdoMpO3+OUtvlhm
8W3j0VryzkmHJawD/0k0b2iKTvZzlYDODpgp6rlfVLltNhXAjZkMm2Opyv3eMeHUvhfOcY8CIZLDuIaD
CWsVw5haZcVkZ3fDxnLeizuBYpklY1WPlYTnTTiPi7zNdYc6jXY4qBvJi3WtVZSKlbpspeGq/MZLKSNp
WHYVrLNsyb631ESdywHreInXCemven4weDBkwwf4BY7q3R/p299WKIrf9eKhFVlC1mOSed7WMhb7ZW//
GDkkcFhSBeutHVc4WV7cjd0x2vykaLKF8a/J4idFgy2UbpK9T8qgdTwbgldmWuPXe0eJqPzX1VGiUhme
JfuwvMN+lrl+t/bnZ20noLJYRU6rqI0AAERtBFltBIUnqxGkJVi4qPKSDZTOSXZQR10aq4YcNZumlvES
6Ngbr4Ee7o69/jTw8VVTHqp1gBiU/q0yQmBJL8wiYthTNmDvQzsedVt+cyJqnuA6H/ZJ56uf8OqIWqwV
lojWaS5eh+jXpy/FgHNfnXh5/4kX1YkvPuHExx8/8QWzoMlHTnwKK1Od9mXbsf11TyBdqjlDvArLrcWb
R4mdqfxHYd/aQGRIRc/sG1rUAG0LSXRf2RqIviG91qmeBCDN2g1GYqfURsQoapwJIhdT3cy4cJDI3Woy
94an2NwJ/AxRTymArUHjKaCOkW0EAjlGo+MQ0YvpIJRvXGtnOiVYqx08GrqgIYjJlsOTWdZ1w/EcIDIw
kwlbIdZc8hvUvgK5eQ4U8wW75NfVBNhMIMbms4eF5hgLpqh66nvVYEpXbJD4lK2YtttoEv9mlwtrl2fl
jk7v3NFNi37drratuGuT1038a2WyCuecNoSJAKFCpQphtZGotd/yNWCAG74ADHDCt92td6P0yCeT424M
TK3vq4znPPSWsNyRt4HVzr0rGH0Fbs+7595F98K77l4j71TdxnDd56foG44KuNC5RkHxk6chcP+hk/kr
pRLNvBVA48Ci9y7YOTqSJ85z9h6Zqqe41V7CD2y1F/wZ9Phv/hJ6/Be/6b7wt92/x85f3b/6J6gChpqd
bfcFjONvt3/iAxEy6R1B8iTsLr2ou/HyLipjnPrkPGMv2XN2Dr1lF/jnmqaIXeq9DJ/xYgCdixa/OZ3a
wifmAP4sI+SjAUpWASAOH1nxZDIRxXlsX7F6X9TQkKMstKtENcNHsFEDm7SuRTD5weJXAHjVjUcM6+TM
JEayF/AHQU9b6DLTVwBGdEGD5UOmAh+o++UyEV7a1OCPNVOQEgnsG+ngHWmY5mgjlvv17h/THe/uPGrJ
J9o5JQ3DH8u/rGbgkzn7ep1k59pwjHjDVpyBFzwrL4iXofKdwL2hnClWHuxD5ayxOmtoNKvShl1VCtoI
7bgdVQoegRY4PFS1vdD1wwI3KHgOTDeQPJlDsMwFpkFbbMXAyc+rKFZ8qbxJUJy4UQ4bK1Y4DbrAaLYw
HGHvKlzHc6VQVVFgpbnXowJBtU1ZD/WrZLWt0+ECoB8+RC3BMbDJGz6C5yuO8QkHAO0HgJEGGM0OQNjz
CCVuQMspQ6drOwYznDy9Y1t2en0I6M8Ee/8ElWMO3k6LUrjy84Ctd+pCnc3TZLn+xOC/J2UoYQd6x55H
bvBGOPAM9CZthAK1nBf/y1T9/EYKm6i8r24YJ4w7maKUXas6E6XqpH1gHHxwnwQwO9TSNTZEMQQ/rY0V
dJShPDJYUVAlvMUIb/f6tNJLKE2aVe4ppyqsaAbw84zGC3lrQaDvqemKZCafHz1C0IqhXKA686ZqvcL9
P6fND3VnqfzkXl7W6t7W6r4pLUwnoym6GekPwUA3e4nNbvHPjWq7itILpCAGEddgv+OyfSiCDoatUQKZ
kVrxuJR0CWzSAlLSvsaHgPCe2aAyusCBCNxtNsUpsrpzF7N9ubLGx8lpOE3892TpMEmmiQeP9RJF1rzU
Yypvb8UUIQ/JzULFcLgBvQb0UacFmcWXxNmdEfDMiUaedyaxT9L0SU4l9gktJK0ZoqY0YqR6K6BgZjdz
fIzEYZlqZx8VrtW9JLV1irCdd+g9rznzrHnezbywW7TIuqJu7K+B2Qy7mZ93C3RpW3djoFzSuhxOK3SL
mlQurnUqtRv9JPHb/2xIsQ+9bB8SUF00JG9thpT5MP6G4C7KWjuT1Jy0Wq4Z1jHaVMEI+HY51jG78XqN
HM1cCrpwAp9ilznpZDCNJ0VQTGKiBZHXB87ZDdAk3MNn9PcF4hG914y6DfAXL8ZYdD2Jg3iyHq99HpU6
DSdHMwbgo3zLNXTtlq/Y97V75pK5eU6Mm8XU1EZOph9jujMNtvdGVDdx/OL4thOPg68jtKL1syBzvZFq
6vX3/tPQ/dwpX21VWMPcBGEUxp7EVCiFISONte99hGFGMVCqM1kHHvbQFv+XG5QsqTe4ql1ppm/Jt/Rv
9c/qtnxLkZY1bPVqhyKubfrUthq0PaUx3Ccvau59OS9q7n1r2y1RAEKw3RIFEjx69YiPquj9H4BxwoA1
3bT7A90BQ1GJh/2y7ArNela10Nu2I64S8q/c7pKJKmkFFUFKhv6dnuyu0QGnm8PTgvwUY3gKW042GoaW
d2KppNS6ICuDA49SepfQ4b5F1CzBwpK+mqXf4BUcUFMk0BnLcv7NWjxeLQMX8uY0npW2vycZu+jb0nxZ
+lWSL6E7/jny7vB1De0FAdjQDT1IywDKCZj7CN7R2Tf2MnpjSgpK5q6Wv+qf7f6qEjYDImLL9VR13QLu
AKfK0skOn1skhmUO6/PSOgvzfQxmHUV7Zxe2kztCP1i9ovR2j+vKIxZ3az7u9+CWemPKD1xrcFCSikcl
rvke11avTRnUhUkGbMiq05EBQdSN+1kDnVzei76VSEK6aHiNcohBkKpDhMH1Cxqk26Ihi7tJQ0GGKe2o
uQWMUQa0P0Ybfw9vgNzhZONtN1MLPCgGH+8FyPq2xXG/TMce9jHyMoXD71o9RzrA7Zc2G/G0RS1aV7nB
tvse7+HbX6K7lHExM9AJx1I2nvYzNuzHLk4qroUb3Fjk3Pbe9Ygr1Z813QVOd2xPd3HndO/PIsDK2uw5
0icqKesXXmIZh5N1/FRkwf1TFd+nnYz97/GGw/05pImwXPebxHa5pPW9IfF2UIuqPslsFwaSSpDPHHFw
CK8rjgxGKCwWsiL9GtyeUWVlmvEQ9l38JV9OFk9Tu0KyCnADESQUZnKfETQVF/+jiu9ggpWaIW6rmsLq
ci6M+6k2sdfeGadAgDqEmfGOYmc2i5DCClmE5lrhGaN3T7174RkSaGS9ItUtdNi1cs/U+6f6bQUDqK/x
fSuM9pWWc3mNOEG7sfLTdf3T0Pp0mt0Zxmc2YBTBZAQ7ZDSWk2JceJ7KOyafxt8xiMws80dnKCLApyE9
FWfoij52fT8DSjTzvDNeVHA+X8eRcAa1AK/vs734JmQUd3tb2sNZvrYNHlHdEEweB107Hoe6UViqW4Qr
rwTL/26PXiMxQ0y+oQAayQKvACqAjAjxCj4SP+R00wdKebB+iqWADznQXU7YdSI/d/2Fvleu7yy6KbAr
5fLPCm8F/AzaQ66tMT3LWuLHVF6pxvXvQN2YLGhqqPmGGuclkjo/ZPYN+mK+FMppOY+lforiLFqLhg/z
C6sPP0TKfQ8WQFxDrZYYDCtJbFb3byr3itjzzyJz7zW8YCXkkwiPWU3b9Zc9XN0bjICFllcY23oLW+7D
TSDYNsgIyfVeo36p9xLvCkjOxtRkyV1FPB5HuhYKyiJ889q7KSO1ZFVitMXUsRvzCCoOe0WinBOBFoOa
I4pVNK4lv8Lkip3j6TivN5i3NZg3G0x5jmMoYx1AaznS9+m4SnuFaWMdaaC0zKS213w4XgDz6HlrFy01
12S7OVvDBmGfQTFaa7whCtaIqfVG55xImfpjiQVm1XviFxhTLSuJPYGM+obm4Bvsh+WIVAcUJiYH+mvS
0mxhaWD1z8chhT/I+JvMCVnqwrnJ0BEohKG8GJvgAwUgxK9VBnbgFJgBjvPER6WOhJyvMaCHC0y2ScH3
3ku8wBIe1IUv5N8X9t4gTWySsJU3OhgF7WeE69CtOMlR9i3xihKUGWkoj/Be7+xXmbq88gVGzcLpoM2s
y0Wo/Y7UtIly9lQ+Pd80YZL+CuP6rfx4TAvRXQV1ZtWDV5lh2XOu86FLKRq852TwDhPurylI9dZfAL8m
VKYrvqEPc/jFD5fABDqr7txfdq/Q/2LVXXlL4NNu+FX3ypt35+wEj5gz724hy43bv/TWcNygyI1/1d3i
+2I3hl2lxstytmEn5STAIHITnuMEb7s3qQlkM6nWhFh8xZuavCJRvUdq5IYoEbz9qQBiCafOWJc/yHSA
HoAD9CEtg9P3B2OgQ6mSsULVWFFEFeU80hWZ6PoPVEyYNQ/9DCYU6E2oAQH3up+XAoSp46+8ihaDifNH
XQDo6+6678AjgPfIy/sjDyA8omG3v/CA/Mu8sOa593VjnC+xJ+VmeJPRrdDmEg41gFJesSVyNOvdBEPb
/vd1VunPNBg2ED6vhVT4uf2w1rQpRti/4kbMv+RG8L/hWuSPFqIR7KnSBHTu+3S+Y341mwOupFAVmdiE
qI8j8/IQ6CvqkW1Xjv7UaFTursmivCdID53xNa36mhYrnHle+nl0hvd9ao9Z3PeC9r1DAFWi4wkpagtf
kH8h2Z3idcgReiMNGKKrrzLnHcZvUIeHUcmFAssbH2HNFDb+AjY7MnHqy1QEm11A9W5UzpWf6ZwE3yl1
ija4W51TK6EPDwt/qXOuTJ0rXedS17lUOaEbdp1LXSd2BXIqxVdcwWKg8DzPvnT3zzqZJHshqpD8RP1a
lp37VMCNQvxb9RNm0R5JsG2QA9/UcPRrVu5h1CEYzlxDqMKc41iDI7rQ+oDz6qIfWEl05dnCroB97aew
4LDPfQpKRe8L+MV3lF45UXfh50g1kWvYasL9Z6F2jlryqAvnr5uj048KVgW7FOisJZTYoFpzzqH8xl93
KVjVgs+BML/k39ZImu+y8SVNQ8Iu1SwU8ADA0Uvhd8sXFgTQABN1+jBLC2YoFn5ZUgRq8gC4/ooo8IaO
CFTz5Ka3vb29pPMMj2gTf/MEnm5U/Kab3gv3wxbeX2v0dQPPL8oIPfD9DX23vr7Z/VpipS3aGUD9zlcR
v3RrLjOvWgisMTIjsvdaFZCATdmvJbkGgPpbTa5JItfwYkubTrSNSpvQhf8SwVn++uMKRILwGpIUCEkA
naMHinPwPepw8JLaA2yajrhE+3xfoj1+SVNh2pbSiKJyaUR4vaJW2goDCwo2tMPmfd8Axhc2MD7QIVE1
PRNq0p+cQYjIx6dIpRH9LzVwXCO7hKC0lyEOwTBIBMs2fNHDQAMLeIbNuPI2aDN4yZ2ld4U3eKMLFcdb
48g4dDK/vZ1PgNwxDlfoWKXdyNTf3ra6IEY7YSHungPciHaA//Rzviu3TlnwSdReLrfKRbtd6dqVQXcB
2PWdKwBPsFyXfgakgj+cZLe3wPS5n9w54IMKt59ZXXRyk/KpHbVL6DqsWi13tGWtQzfVZFqVpchMYEQ7
XVVI7yG873Xm5km6X77Kr8pX9VV+BSHd83XB0ZnZMrPVm4/g7Npg7cyEmwoVAL5owN9f9rlTgFu6LkMq
/KLPbEEuCUCtFUzxxizTr5Iu3GbvMGJtfKYwc3VN2le6hEs55F05JLkAWb4D7xqambJrNVFHhmNDXxqY
ENNT6Isl1/vMGiRMH7pSX0zhUClfOCiYBTirGXpwh3Sx2hrDe8Lk2XKxr5q96YWEki7GFQesZ10hPD3x
ZIAhppZAThB02QIcQchz4waqL9LOA6jMz8hHaOsDQnNt8zNEbYjqIB3ybK0+/ppZ1/7VFpp44w8Y5T7p
PeMYTjrpvUGUiwi3kffbGhyTxC2/Iaj687iYFlAWJw5/s6CAWnD6zvFyZai9gFH9jKbTmN57gb/k9/IG
UnHDQCGLhvixpaUX/7gl+Ar9g19q6YVp6Y3d0k8lOhnD4McuxgB6UYr6LOOowupRyX2qGH+Fq5A7IeRf
IrSmf6cCCao7G8pocsDUUfKvGSA//TQmdF3wryKkZ52D4vYWAVKBuDsm3F0g7ka4AGvrugghgLYR9BX9
OxENwfGJ4fhQlUCnxy57S38Fkjd45yL6k2GHVT9LHF/o8DR/ZegrmwG5h2j6N0LAP+NfV/M+HyKxXucB
kON0QoNfolLxBWOCwcCwccyIBq3wNbJo0IxboBdhYLC74eHGsuQoGmI1ZDRRntF1dCHXpzRJaUKnWdYe
RU07alVd1L9sLTONyhLsw1qEi+AASPh0DsPDaGPK84MIK/WzVbfiWaYZRRU6kynwfZA4VYIhP3sP0fmA
VHr4mHl4cyLeyoxtjSPywae6IhK+QWkKchCRz77+AAg/pWrpw6j6MMISQDWgfUA0O6o+HJ0Rx0XRQy3T
kMI4XKI+e3lBd7iYZ2lcKZGmoBuSFSRDR4WecraQvSVwr0T0+MXdau/O/+54V1LJjekySQf9GvCm0npq
5qUtqYUXduvGm1H9+PEPeDnhhx2dOIGXzyUu/QDfOhN4sbwOMY7XLwYFJlFY9zK7VNkTIEfpK2VsG05Z
InMpI1ZvmXLYwR3zxmb3eYKWZ5UtvXUlhezaoVnX+8ClvLsPg2/OkNqbqe4nHl7ILOnvT7XQ+hgaCqiD
n0xofYwbmLmoGILPh4e5CY1WRdwPSVZB38lMkDJ8iANjVwY7H6W9O5cZnExcYsjthqlX4RNZXrPf1hAF
UB/APlpX7pxlTxMMGRNPMuovqULWGFEzBY6IpOHajSl2SwftfAavHtD02Da9+BhmhsI0lAx5L0af+IJn
3nAcaxf0NRD8kNmvLm+tlfZMxfVqRndUw0elm3CjX/RwhlU2Wjq7uxlveE9/1yZjhpkghWW+rwhEnCfY
e3TB2jfrNFQ+Fi6zElLEHLRQY5xnF2ZYx6ms93ta9TH4tP5SX8xpwKgCpU2iqXlwNqUVHZyhHHFfs5w6
dPnRzm2JPCPr977jAHCTm72Sz/RecXVHrZOZV9ejWjY9+qBVt8OSXU+MRpybdB3KNCsD6Pl+NuGDw8MD
2KnNPNCkdhOv7NMsQ54GsJqdmRvjk0okVd7Jqc1v0J29/FzesqogFgw5nAi8P8HN1OGqAbhyZVWWOrgb
p3Yy5r8TzFnNfAzWLYtWC8cyaTABsnUQyAkfTodBUr8wY/ORwkM/cYZ+rcjV/UUQrfYeTuQ0cUZd6QYj
qGHk46NdybxGCXQt6u6y8cX+ti10WGAYU2IkqCpYBF7NbfqsHdihKOqSuqWW/ph6lkxFcNR1EjSBEn7v
8UNbsf6R6SitFJARsmO62+WGlcFA0n1uO9OdF00zDqxrxIYD7E9NUHHRUiMJoWBFurYK7dre4eM7rJKf
jFBAwnvHD122Z7EMc9R/H1qWYsM+2j0kfIjTh3dhlDNROcIPvaRrjcCHIWRWMDsHSBS3+z7s17bOaW1t
AeFDG73Hg+HDL6w2LLTdlV0HsOzQ7aLRhR28uTY7/RGsIqzr497DR6OHuGWCUSMNpheaekipbjfx4CcY
6fd6rlFvZGX78ggy1r4+qn3+4hgyWCppm6RbReuSpMNni6SjmCy9iEi6NZF0K03SRZqkW1ckXZy/DF86
KUW2JNJCJWQu3vEboPETvcfu1IkpwIB6F/h9FQg3iCfDLwZTwJFHjwaBD88Uoyf28N1twwPo/Yo0IiOa
kCkaEBGDpTOvjTS3Rpq3jDRvGWn+z0aa/18ZafLxkT6zR7oOKzIdn62RrpklcKCRrvVIw08h0x+kH+/K
y32yto2mtch3Im/tk/OiqATCM+wudBatDGa4HZPeHA09/iqUNd/fKpQYjAVS3haoqMIQkO7t7WCMQtAu
Gh08EeaaGAQx+Iz3D+E7PWT0t8C/WgOhfSmczJal0KUxZJZhS1H8ykOVbESpfGUrBH0W0OfFmRbpkGXS
LGOxSXgvrnlcE9kABwYVBZZQ7u/iY1fqWOYKRdMUFiEy1ZC49nW6TuMimppLwNui6dtAERpF17pER+hr
eSx16Z2UDGxFmhMgHC5VgLZaCtnhx5ZlF8ZQq95y+KaWBO2JzSMqYXD62AqVqviwxBSyE9tgEj6V2Ab6
fcAjMkbBqEn4DASsowmkTtmY01E6YYwLoR7cDmy0ktkZApcD5DNZKURko8Mg9cikDs+I+3Z3rhuo1qid
lma8CG/RdAPzCVrJD/h66uT+mkDEmkBCsPZzfMUImxpGVJ3RZTNFnXsdNTOO1XN/pHqWszX1aX14eFch
b00dYosDvpre3QbO9Lu2JjBKKJDlq/0WdBFvpRpY0lpsaHaWtBYbWgvB9wriEn5sRYR/rDqwVCEtzZoI
07ElqYnNqjhD0/ZQNey2dFi1621Uh0V50SprUsFKqxSre+TiJ2LsZjOgYopZrLgMWeMysjYu4+sGxOTS
d1AU4E6HypIzGLRAUDKK70o79Ny/qudBGSprUAXKGjJdfY0g/rlo2t8ppwNStyoHAzj032mIDCdfno0l
yhxRdyYxaBCQdGbhZGWiZN1jK1T2wvCNMRtgXWjJoopX3EWlaW50a0YWaSa/8pAReOesMfBKuGipsfpu
wcHv9Jwi+Y6ydUO/J+PqFkBqHwb+p0ZJ+soEtL/VT8qqclxADTFy00VbrsrmslJrF0ravohvxPyWWwYb
r+wvh9x/bGk864WOMTjsDZk+wQNe/G6JNL9vVGORib8XdT0FBRFXV/xEK1xrSDlADjRc1CL1JUpOif4I
5sxE6nRET8iMLZ1FZ0ytChI+v2PcPB3hQ1XsARRXT0BmlM9deLgBiqOWoAKsaq8/cpWG7iDNrlJ6N9rr
AaDuPL10XL/30MTK7W33v5W2TEA1mGwk7jobV53TH56pScixj3m3bBB7WL1ud1Duhmd9UxwHueVF+W6p
0Oqnt/KpxFXooOYA4F+0itdz2LTweBWuC9HBWaP5BiqLHMXf5/zXwsbJ7+rybFODpdaqZ6B6LXVVUyRP
3/29fL/atZSB2pK6N1NiyetNR25vZwAp252ePij4gn6XBF0wVB7CcEsfdacc/9s75fg/ljsbkgekotvW
dDyNoWg3LiNjsZQ8cR3w4JW+ZJZUBbWc4d0/UqEFeVbGt31gqRVl3LRQGFpXByHqqgRBpdCGIqoJslOY
FHCKMi4oYE9L/SKuTUQm5gXKBQGy2vqQegRRIMlrRGVR/xzjqxIgiHjtlHbfpRxK+W+8eDnyagKDOG7I
09Q1oMpjuuDKIDpz+4hQaebEEy4BZqB0qegKrzTttcKdpNbwZrjxlN8ZPoWIeq1RhI1BagTAS9w0HdpB
VaO4Zpei96tFQZvhTikmatI7l5kQPbnKRDi35Pyx7dCwX5EgsYcxNXGnYib94d3VreO6dUhZnQo+6VRW
K24Jl5X+UZMoBaBC2C9Qj5ghF+Lq4KiA4DK3RZW5aM4aadUs8WXcgBANXd2yWX4uNnIFddCvJeaLW9xm
KnuC2kAL4r6LvYEqPYi6dM0gnRSRToFIR1AsVuQ0xpLq3gljBWCJDveO48Acx7IL9s37vh/j5WOuovnU
ojGKfbKOLz0KAnSZzvEBcIe+WcZzMnwGFACQxWp7HpeQiSemKshIT9r8UgAt10uKywuRwTyrB1ehpwTR
U8ZMxT49qwZ5e58skWbcZPj0/kMXxVym2f5haeYIrOq2zUVXaEM20cZNYzefb8Lo/XkiboBws17QCkK/
wiCu0EDC/gpza3+16LcTXf+9lVnCz1p39FYmcwJSINMmyDzZM4Co9+WXX2KAxgkGYsu6FtS9iPejo6xt
0T1WnQFTBmxsSYFDqoepC9dcdanybinvCj1grbxbyrukINmODQpcuo2hAgNNRaEyq+XDPsYxRrNkDDvS
x7AjZKOMgKS8xvE6JvcrupGod8P9DFW9PQxEQj6NOfrWIMyh4M2QoYDvhf6ON6xORup0oqPK6Iw9j/UN
lYzuBrvBV2zBXo8Yk+mKjYJn1roBcXk0zifpOEXXHlMT1JvqG942eDkEYE+8hkhZ9xb2hgqBtyjGaHVv
1XkFdcGAYeFDUsFvoGxpsT/kXF1sGHG7h+MIb56xEg4PD6CCCD0pIx5ZHxhe6TPeTJ355Or29orz+eEh
zNATmMXpCQ0APQfwiUeMIpL6wKCaWSkwrhlMkwrQdYnxoBdonLdFM70lPuEN6dg/NFk2M6NmhKGhKr9k
aKfKt+aWJdw4N5CWWRajkBFI6RsPcnbR8AOBScZvWLUHTmsmAdex4hmsA5XccZxOKetcrIUUD+wSrJGG
BS3JebxnTVaD/glaCAOk6yqmBog39bJFY6suxyiMFWtJ1+SV0BoRICAEaKEg5Kcuvq1k43HTOCvzBO7o
EhbEBhaQ1TBdQnBbmW5InR92nootOU67PEUBY6YveO09BODvpxTRNSxvIKaFsBjxUZcCNIauD5nx0m8o
gnfuqFJj0SOGzougkbwbw1IRX+dhUI28Wyg9r8mUmc+WYNwmCYeeoZVahc9QzpqgZ63EZFWuTkMCGQBU
Zt9Qr5aQ+JNJK8ipRK7WtnrxDymqF0jqIFFVq+VvaygYiRsWdxvgJprjy/yGzfF1bl+C91cDW90AmXxE
V7XB5EtFxGJRcuTz6RvS7vMtefP5eNX4uNR4Ig0DG7foo8/iwGVKD4AcL8UYhhTjVYY9KrA7sdWXt/En
eeE9EBM5pWv0gpmoha9501hKJBmUm+e09ua4Abal2SCbnP9675wqq2qSD5Nkw7r96B6tQkze3DaMeR3X
BcmK/CrvvYzVHaopR//NkieYpDijaNanBCwUpyCm0KcoXYAScD4X6zQlWzcsijQYMjB4B5gl5qpNzPQD
FQnu0rSqCmU/cbvJjmF1d2altnTOXbDOLRHW3kyS1JwuVh7cr/LXN4Di5cdPErINo4sJleeqCyf0SmS5
IA8VuZ+qLgvlIYrc1G2eUFPqkzk8oFXX3FeMK0nJkpL3FrM8FABLLuJcRBSYmYKpQwfNCqGBAJoKOHW5
4nfW6CuW06kFJmkf/GQ0/TMOvkZ312z6ugi+LpVXqbrtlZE3XEgXXSTwssAAORZD2jAsUbFdWVj2eN9N
voqqhflhfubpZRhbIQ7lPXG3ElgDFHW8VGS7ClCWYC10ulqb2asEQ3BQQVkWfIOKtLbSsZFeuJZFioD2
qevROrzcfFqjmWkUfVztuj6tuDDFBRaXcfQ+b5ux79W5N3m+SbPL0Jp8mz/53aBqzJzAtm6r75UOtocB
/XC86WbL982GrP23q8f++ya+TyhHU9vRv7QE8GJNDQrscIY7Vo2v6jUSoAOA85tKxnsjbecVw72QbRS5
xPDhwKhzCQMQcT5UbtYmuAmaOwy1NF+BJyvMhiyFM1ATAmnZz8oIXb3hwwmPp0UXmgl6R+blYYAmCCSu
hbeRy7A1XsE0fO0XbrcgPSi3GsZ3+uL1HtLn0RlaXFsS6P0ZxtnUUQ/epUzPgTUrvzeINJ1jXFWxoH3j
iCnQYmKzDgHm/RQym0qBxa4xQ1aYpdqX29tOr+O9ix28kZmtzyr9jRt0GHz6BWh1XDWvs7CX+RcLsvht
C5FYy+D1BkOr7LsalfELEkCjCn8maF26yLXG+CJ3hA9ZStqxTCaqiVmvdB2c6z3wnI7oHGC8CNSQdZ3O
5x2Ob5ZEuB0eV9Jb7YaA4xhMkukggLr8amh0oxGGbKrCuEi3Hejqmoy5kq5FvfpJLbCyRVlSVJjyiox0
D0hbkkqnvPoCS7D0H4FrQX5UE0DBiS7nOFkdhCvRdYHhaQg2AvoLcwsWiXsBuSeqmjO7Jok11aGaIfYA
ZJisTE1fsLTCjZjqpMtMV4HaSbG+Btg10UsAjmTlFQaJ8h/TwSOsnVuQVe7aOvWFE7kovpCfD6ejgJyX
4/ybOIkBwaz9XN3UJbS3xHqSj3PgTg1jtqLwAKvxCtL0vQqxk7vdlTu2XvWdR8TiWqlY05P12KpsAVTG
ajIYr4CBblRHtrTAH6ez/OxJSJ3QAQqMggo+YViCSTReQ/FxirYDRCiR0rxUy+kZbCIlox88aC6w0RWu
8vG+rdtU8lUedEwtcCDldiPSxQMF5SsgZpwqspIMhFPeG7KkrxcUyDnjLxJxgZh6KPzhqJLPY3wgYIOr
RFrQ+wjypB87ERHlHuxwIA+nKL8K0M4HJuEOLIpQg74hramRKeDPlNnH+KsSdleqh5aTrQi/X2MViw5+
h31Lt/EPznv2z8iz8pSLu055RiRM1jxLiU3CCByyztO6WyoSRjBF72SNw24HBNR9eqUqpsziZpMmtYBB
6T3DUjOJ9xOXc1mBHWEPTWLld6zvV/X1Vaub1Vb31/hjZr5yWkF4nyD+XeaqP+yrAypYms4cJ+4tBeB4
F1C0IsRQP9+T6PuEF6EjZFUcDWA9f+h+bk57LVK0TVHuq/ru0F4+kJ4AFs6twj6XzPbedsvuhw3JONGm
3uL6QVEaFaAWA/hcFDuWgqvwSTR2494qzJ2UZ8DuuejThUNNzVDTijMTM5iLszJ4lOyFLsZy+gdsBl0b
gXJc/kEGhtYNgzIjxT1Ly0pfo8LbOhHk4tRq44uyDS0NK1Ssl0I5KDs5hvquaJkhq3h+14utC2iyco0A
kjqRl2Nk/chb0zXN5HJS67fqW7P3Zde/CpN5vecsuqfve9bJT47gS8RjYz6Aw3lSqBtri1nuw8MCE/0c
I1g4C38NoyyHFnsjDL9qjW3trboRivvzw8PU4uBDvuo6Qx+F59XYqPN3Do24kv+347NohvahohoDPvhW
OiDq+gRY5qHL/shtnQwrj56X2sRUQ7934VsgXVhmaIZlK7MAzQRHSpmaibsg5g+GmzVgoRZX6tt9AGdo
/oEyza2CKRVGHR6P0dcCiBWkEP4qwkTiXZEJE/24Tfdvx1JTdsjKIExF8QnkrBLXFMzEGyzGDdTz6bKN
RbwG7rcFZB7o1oFvUl6w0HCYRyKZx8kS6FgtB8n+qRxEaDlIVk5G3rIQBWZQZEFzRSvwr67Nm4ubV0i1
ssFETGd4xwz8Q9kpMDVq5gMlbX1idAqYjImW7PXsHjT6bbkpbEHDj/fTRWLWZqWX2ix+3CUbP7cWTLGw
464bgbgOD5mWCWiEYXDZ3Wt/HycDu4oEEMjRzKpqz5TMRwVL/meLawuM7lo729ZRlGuHhswcKQ1YuED2
Yw8jpzPpDfvxfevyYyVPqomAfrqPDhETuibXFnoK9yxQx2t3J1HwkWOEiDX5h9iaDgMdBfFPd/osoX2N
YRFx594Jzn4qd65lApXuq7lVdi/ZlRYhml5HvbueCtkc2/27SxGpuLI0M/ITJIjyn0gQ5V1jpvHVbp6R
aU1tEieJyNTdW5bJVT1PWsj9PFk9D8WReloPjVTUswCwbGSIm7Nv71O8iiqv7kWEwWKY9hAlaSYWYeUr
TIYAeM2UEbEv+TkS12yDvxmqCRZPVqgliML1Wl3dgFFmFlDSnWpX4Jm3tD+jGYO3aaScucG6dP11oI/U
fIm7qm/4qdwClXemcqpXaPICVT3XqJ29wGhOKWp64t57geH9eo/HlUHSp4McSQBH9rafLhWXJPdBc6ZF
nIhWKXwbS0YFix3devEPhekpr+QG3MgNkikwEQEQcCc5MUYYnyhNXZoOSYQ6nAiR/JPrmKiLYW33p/Ut
qVblhS35DO0cqfLW/d26xzFK60aTdB2sfQs4ybFnGMaULP4xXmlpRKmVVJ3vOoxuS/dwBWbyDC8bQHuI
zi+qQMUGoX2KVSojqWhRiXHLfuX/jX79gv3SPQKIWrZoutPW8Pq/NiHlVOzPQ1vDi7Rho6Wp/eMpLVtA
Xj4bvExeScNq7Bi7Spty+dUd9R2V9Q2oPkdzqwmtRUJVzSz6aXR2Zq5KSBA5wXDdekvLT2wpaenlJi0l
dgbYPRliLB/1fMCryAT7ad7ItXd25VfXyAfr1umwMkYvSVNVoC60iwfIOTTmmpnHOz91PAevGfRHXbx/
sH/k0oWoDt45SGnDMg2z6Qe6LZ9qjlAlY5qeDPH2K6nthtHsMfI8NFLvPIMqkWvzsBHdBLJyHjZQNomh
oqvv1IWw/F5r3goxOxrnZUQHlLBim65uHjsDjCH24PQftrBTAmQVBhMrG9vTBcxk2JwuSquma21qW2Nt
+/yR3h41B39yWiOHcrLDSFR8ZZrokKNMJmnIZCozA1TCM+1LNCu6TmoCIAPIwTcTA/msjVe7TLXjeLWd
9zebJIfnffCQqY2WqY02Kxj+RxBhSBAB+z6DbsJ/BD9gGJAJwUnM8B7k89S5zjHALSapl9DVEUTMaUUi
0SXAg+40CtqwVBmYopOLthSg4YZlcmiS0STkInUiilZTqSuUF0xUXcmMl4q0QKvt3vQc16fHNtmdoVEO
+nRWUxVztZDwF4NBPDlCk10yI9EmDkphlpoXHCuFOVAJak5ita3MbLkMw4ZjbYVVmxl5o97GPEkzIQK1
jda9RftDv0mdZoTUvcEV3rFR4czUAI9xZ0KXPi/OTJtCr41+MUOUfNa+/uXw4lpdjZGI9hUXZoCytuKy
ZYAnad2uymAZFfiwbsVuwjampXtEqFwhyrDn5BZBQTvJAjwvt2uOJyXvC8LJXHYVBYEnvevEXoH2eLhN
6cuw/JLCl0o+R6fUMhhOP+aZ6+EVal1U4cLTET4d2YHw08oXRZ2AZzT/5zmaLejFgBdRvlzYXy7sL9f2
l2v8YodgqHWUdp++T1GFaU/q4eZP7yFKyGdjdraH3mhWoR2U/Na8XmAKgWbFLwQpAW54pIzuj0owiNlS
O9je+/09T8tPJlHUOyMit7aLBsgS2yJYDH+wKUY3oGAA2xRSeUqpfBAAyY8JfXRbVInwiFcCkTE3KyZf
knHzUVf2KzNNNNPFWoquYLqmopvpqCoh193g0A/yaCmlNRGDvO6ZmmxLnBP6KhVW4lHXGXpYeRf/VNZX
s+L2dkCtdvGpQh+WKdPzOmV+J0VEE2tfLNA20VwZ2VWIrkAQIMnejimtOGqXcXtvc/KJ59bVJXh9M54j
636TVs+SZ/exr3hN8lXFvobAvl66yFKuWQ7Pc8uGDVPpUv5SH6wurMXNMsc/l/hni4O6qUi0E83hnuMv
LOoFF5zzbLovBFjuAmKC2TUnF86WLBvKQvt+++Rm7KYW2wtc9WwL7btT6LVazyX3Tuwc8BFvjDxvpJ3R
1byKtb5o5veu93K7wbzirWECq9GX019lwO8mVPb06m4G+wL3A0qkgdNOkdMOkdPGeNnIWuYcoyIj3l78
O57bZqFvBv+cU78Z/nNW/RO5ewBXqlBMhT6xczZrv/3Eztnt/CM5QqoKpv9KjhC1yxFClCOEbXIEWGxz
7G5vcd1DdTH+fApHNMBNAH2J/rGkYaEGsahJGl6mDfPkuvjshfV5pv0ALLz6d9qmia5MzttvIG1CNr2d
Z3XYVgNr9t2bf6UVQHh0bJlqV+kdFaXakoe8SdvidST905Jk6pwMgOaUXucp/VXPDwYPhmz4AL/4d3+S
ddnL13VqZQFAlb3M0RggnqMfrGWAne67YMRzc7zfwMeWrSOs2/iIqEUvkXMKeRFj6vk5hqeT10IkpLcG
tAvkNQEx9F4+P5+HMjw/p6KAohA90wUV9ib6WI2i7h/8c20XqXuSyEK6U7+cVkVtETfyWZqQ2Dyx1vXP
xmQgZqz3glzO60n8Qwilr0QwYFFaJDIY7FDngjbQ+loIfV0T2olcirH6xD/QYAIyB2D4IQiZCHMRZD38
QceZcAsv9MvmRRZic5igH3fM89DSFZpEJ1iswlLI1S36MstOWPV2Iqa54waOeedA4/TgxCcSta/0oETV
ZtnWSHOmegmMw1Al1ccpA9Cb2dndw8MrE19557Z0ssKqvYhHTnZ7O3SnFyKI2HDHBujCqRQs1jpH2tDC
9PvAui0ldyrmEDjl/hIw2AIxflRdFRFNBmP3aub70ZnpasWyFBiWztmbB5HMa7OQo7pKq34qsWI5Gt/X
yzLVzk+43kHlCFXbPTBSLfWojsWCp2oPYLwbtf5LfNILDwTEDyERPeNy+iRfeSHLJhjQhS6BCByc06Kc
QJpO2xQ/Nf6SoZSZjleDlmidFuegWjQbSZJeNnA7tr/QN/+yPgJeVGO9vld1rCDT709fnaqgobbddPoR
KzNZu9/dur0xUXyRkqn0hYpcpHV7f+asqChvzv8sMdgMML0IM7JVvstmKOkfDR8ePRKPYMsLNPQ+C+Kp
nBX9P/MZBhR9gr9n/WIKL0F8Fsxe5cr2WWX+X7tPsH77Pv3vmL9JMgYrX5Ud1Pdpm53aXarRAxP27PDw
wPgOCQYd9ISHUbaM0aLSO/PSyg1h5NsYTVbD8h75wknZcOAGHeXtbNEqh4cFGRiaVQkJtodKFU1CxXIK
nNfoVConwzaHHjJRFahENf48GKtTcuivBPasJGtbHHysosq/pywJ2Ncuugu08V7TdLCSfKAlbjkRFIG7
nAFxxwzQJ2DwzCQfHs4+0APpSSvnKJqYWE1MTBNTrgom0sIg0QNrM5xgIAR5pwljpUe+R52OR/Aj1oLf
184yILyv8eTbOX63c/xw+uplj4LUojOayDdpkou3gLJts3uLmPoVeLBMQJVvlONaxZvkAHMj+TKdCwcy
XaTzLYrPVWbC/zeyCNffZOHyki49bLSG1b9L+QekgxH3do56x71hZzfG/veS9BqoAfO4PzOeGelOSXQ/
Q6md0rCwr9I2gvkzzUyiIvrXlM/TiM4t+yHFMZrX52tBqd+m/DpO5un1WGbbD1+lzg+pcpDE8eYoC6aA
MW9h/+yiUAK2/hFIkUbLrXcsVhHqpTuWeCOKQLENioFL6eVuh62WU6875XTm8VXHBcphuxZIqL3O0g0A
qa3TSTdhFMstIA6GIkHVo580cZSE/Nu0pyvpbbJUprjvmQTYEGI9TwGpxBeFFEAjNZNenrKMyj87PT3F
hr8W0TpUuNKqqwAKLLT7NG7U0zipMrTYbkjxsNtsr+1aKcQvolGOCVWy3vhesWK/OTxNO9t+qt26WE6S
KaCShE5zogLsDvqDHRJcsBPuLYuFoCxWgX95YpW9tNFJPQ55Q2ykPOj5nu2rgpkkVMJ4ySoWFDL1eBvn
4SEa1bgocNZ3zVW5x67Om1V5M+X0qTwF7qq5JFdJgFW4n9pKa7myxQoMKg/q//9MSzYR/4+nxWqxNi2i
ebFt81YM8s//5LmJn6S1EaAMOq7NTtHoOfn7W/NDuZ1qFYE6LkjKm7n1ydpvyhp2fIbRIu6crnqjLeXu
6oAROLDijKYvLy7b567mEq2C+9w1d2WfirGrqTIMuRSjATnqn4VbBZ3fy7fX97JMqcGk3S/CpGFlpVU2
lcAVw+GmuN6hCiR3X2dT7ESCc4f+xio+LjAwsdv3vLDe3zKrFiVI8lFGEcJeMUMlTmPDpzHLjLaVJHMs
m4cuEHTm6nrt3ohBOmAu8TZhDEXiVxGqphj/wUGVoF+QNJBmaR7vzdMd5DgFVpHaDUW4yn9b29cmlbp/
atsByzbb2t5D1x6tYmbSrIXS+LAWCxnYvcMzqs5eq0141motfky7uYpJX+AVAlpwknnF5P9j79/72zaO
f3H87995FDFP4gLkkuJFV9IQX47rJG0sx7WStCmt6gWBIIkIBBhcJNGWPo/9N+/ZXWBBgrKcnnP++ja1
CCz2vrOzM7NzOT3twV+RXisGqxf+OHGCVm+YO0F5Ty+SYL74f9Qj/8Vmn8bUlyH3quzRwwMTbYHrGFNZ
y+4ReVdkeUPz6gQIMDnLyjUoq3iPYSIDj5f3/SKfzUK/nijjC+ACZSZAP937ii/DZtJuC3UhzY4P2Pt/
xC79y4sYNERUx3KbyCkdtBkaLSX9B4wB+i+RoQMQJeCiig9WbpCku3rPHrWM28TyIrFooXuaEMmBW6NT
XzmAm2Ts1iGatFpGcwE39zFYmZQ2B2LMt5GLkghNStWVSDrtU37jigKCrScrA261IlxoFoIkfXQlk+jC
yJnbGoXGBEVlF+gFwaArk8TijlWc1orr5ahKO2hQ/5R27a+r86p9npYOSWV8m0xbPxnMK5Vn/1tfVENk
xrqRldCAkuDLavlEHR/6gpsfosqHjTrZYeRueN887ThKq57pFp/rpsGEya3E9qjdztlJm4wIwlRLVtpW
tdsZf/Un7XaMOBYmQyMjWilrE/cqHWkzsSqpLsWPO3BSbxslyWAHdKw6sMLv7XXpMGS9/L3EzhZJfMsc
8eskoR43gmjGZrVfSSssyTgWt+E+x5u15YU4+0eCz6FMOR6KBe0leaziaqqVNHEUnsKtogrHtxebB6qR
6cVGpsqWo2OpZv2lGRv6QKufZnANF8++yu0a2TBL3TIW20csti87UQEfZcy3AYWI9Pdp4abDQMAxaM0G
Asc0cd1WRJRUWsliMklFJgeVcnzRYSywy4auhNZ0uHF/FBkiVr432BqaqdCBkQlo88s9899VxrsoU7vI
f1BVp8FHCMf95SpbD1OhatgKhcMrxNGsEGqXvQQmr+Kp/zKzujaBn+dC5bHkNs2ITMoxPvRLH5TgwnWd
xoe7brchPNdx3Wp12CWRn1akRoWUBmNyYYJGcOKdFmbYRQDtsbougLfGoT92JVXj20O3VDlEWGixYJd1
YlXGbr6Be+FWC/f+EhRbrfmL1ci2Fs6UrzNT58ZCXOc5FFDGCzmtIS7OAWepmIQGmI0pKzSaZk71RiPU
QIkrLBoIvEFQ1k8P2zn5hFTZaLWm5frawoiVKPcAG8xvT0ikXD+yzo078Wl8pf5czb4iAikx4CXScAwj
L4Aj9SOnOeZZrd0VOVG9rDeOvxicNA8CGg4wylLRrLg+qqCDih9JDsnQZf8rW+dGmY0mwJJYhbA9vGFx
AWq+7myMC1fdAXJhID9unouarJ7EpTkS4duiwK/bB6HG+TpbEodhXusfJ1FZJI/mZzswYciY0C6pqW6F
cFO+fLOOO51uHbOJFWoER58fR3AOIhEW6KuOGnWQT0R69z9/ru6duA5gSAUi7v8bZAIkwoSwv3BvgpgD
9BXOdXbRogIH6TZVp/UvaQINciu5uHBmfDJXYvVF8jxPCXgbt/7VdQCv2ssUf+KP9PeM/8b076fGBZDY
NEhXkElWEFlBPGKRV0J5fq7pGOvARZOyWxl168aKjP6IVSmM7MS1ojXcvStzrUanYbNy+Uiiii7TF5Ex
uXy9ElWS4EIfivY7OE04o5Bg0OEb4qH5Bsc61FS/VihTBLLLGMajEh5wkhHw/nQbFaJeuCWt1FwJv4sv
D5K4vOH7d/jwZZD4I4/rFVqiwrlP6IrGhw9fP2/YcnlD19mbfPjw4T8fvv7Q/ND6MP5w/2Hy4eKD9cH+
0Pnw6cPDxd5czFyCus7lJc/+5eW4OvFR+cWphJWrgKSMDRnpUGkPYuHuEMYSk+4n63O+ecBUEXqbPy3v
SyX6X7nO3+PJwvp7TMAKkPRTnaVhX9AGrq9t5WoJTkazU6O1cR58/BhCeLer7zKD9E+FsBmsILaz9zJ3
J48CGsU5jhijvA1E46gsG4OwJS7FS0VzqKj5zpWrO2Xmu8hZbh8cSFNXfdlGyYYO6ShyzkydcSWWkkGv
9eaNEa/gk9bihhKd0L6PcZfCkj3Ac3xhG8lFnXBALVLTg4P3IiVKBMr63oU9tjSH5ig8SdxtednvsXo5
LUtDJxEX8BX7jCwyOWV+WEEbMTe1wOLOCmjKizkhUKqfFjkll+aUKKl1dUpYDFxOGg8/v9CauPGGYYRS
r4UcLtGz+C3fC2K47LRZD9eFFHljfkvW9Q6aIrz2S9q06c182Fhk2Wq4t3d7e9u5HXTiZL7X73a7e/St
Ie4W2TKsy9I7OTnZ46+UCcESdmfCV8pUX8+/zt4g2/Fe5C59Oh88n7NG6c5+8de9xgPTxanzaZX4s+Bu
uHTFH7kbBrP1sIaCKLH+kIPQlA5SJeL3N7B8ton4cQFti6W7iYp9e/yJu00dgGAojGlFhtED/Z+hBboa
G7u7jrntc3JDNmbcSRf+swE7uGwsL185QFmUdtSoQcIRPYTmxz7oc+MGDXZn6KPOQKxAJQffFOOqXjGK
HD0dlPAVXMmAU6keLiaTpfIplDSFGqObpv4m6fFfDpr2lRU519C31vxJrlh0GKxzm2+CNDNufhIO7/0M
9shR5hILbfGNjjq6n/VKf1iooTIdDa6vYZv1nMvinYxYMWgm6GrUxCDwf90Mvn7iDL42ZpDvdreuLyXj
skUZUd8Gp0llJp8ZM9nny5EMSnpmyOay4VdKIsAxVc0uglShilXS9zGm6FW8XNEETfkS2DLXh3Elsuid
wUwBsKBPbW+P95Ualhzxqu7O9guBxmxCdgpSwtpFefvERXlrLApUGZ6kg1sWr1UJfqoG7Whbj1LSh+NG
Y0hklNZneUzzkiZ++LhmpqRQ1XyZ33jMQO//78fMfgB++PnszRNHXOavG69R28Zoiy8SUa9Wfr3j18h5
w9dEHGOQD/8a/Ur+Kut4BRURa8cQITNAc4SPqs5wTZUB1SARVtmT2pWVfesTsPu7Gobfqrp0SYTqbkm+
t4ZiLFd4S+rGnwyqLQK7KiuSU8F8jGoARMpunbdSfVDFYS8E1bPCxYoZz8GFvcrcEFDPYPxReb0xXl1m
wBQvOBVLKdgSa/V7p2XuiTQ9SkC1TvWdc6CNEgtKK4FNCZyITe3xDa6GguGSxVlThBy4k3Ta1K5WOTOq
RLxQH5VSTVT/ksVqU5sI2jlXZzTmxPZwrRq7v7dW+P4RXsrEWjUZozdy2rcapXHInt4hZDcdCDfyJote
yov6IvdiZBduwbl7wdgyeyJk7+xh0Qt5WT9TwcFVMoqqL676UjT7sOrkqynMK+bg2ktKdW6+3JgvkfGi
jVxXRXz8eRFF/0aqlTEEbfMitR7kePiRCSgFR9K9KHxCaj7GgnGwvEqHZ2+nnBpDFiHZlr9aYHVS545/
Q/mLPtShyfLCnhrxS5ZIKCof0ULKKSjBEK7qqrf4m+WN0Ow+LFtq9rf3QDPp3wV1yonEoqZ681aUKD5z
IKwK1bSC8YJ+5a5vEkHIe/ldLCd2aI2nT2mI8AfIQyMUInQkzLWPT4NRgIAn+W5GVFKdHHKyhhGFMzyv
wEQj79QduVQhNCYkd2YslcGQBZDXFHr6BSeWyxHHybS6JJUb1WyDb4xwlWQK8pQgiCO8FPfAANH8oris
g3aMVGeygufPA6j0dxA85Dy4Iu5sDkePBmRVjhMfuCwwOEgmlZhMjTe8uUfOzzvO9Y3AbtURsWRPXYlI
SXpUaUxOkCUnC0dQHQS+l21W9Rsge9KKCOV6sD9Vxau4dWw8OGuj84WMTI2NLZ5ZECsPZ9kvCHm3984z
g+DgfHisX+vuxlJnp9EoMtz8+sVKS42lAgqhgpEArCXUA+2yA2G7uGQ0jHbkygUft7whR2VEvdqzniCP
r8hYdrDmG4uK6Egilr+K7URDqrR2xbogtQqiC2ly/vREIoVnSs0Y3nmt1JrhnQehBsPv27KqLZtnfd3C
MpYqFLKY5ROxmbmcZ9rO6ogq3Axso4u8DknAWB7uHMu6U3hYthA6LTWkVQm9OaXIyjzeDCID3gNsQ75j
Hjc7BFWwLlg/TmLuuER/J2k1u6RQqyqzihUqrGtqIRl8nXOd3t+3Wm9Sbd/+mt4/sRGW1ucmppGtsda5
ssTqljZY/YPug9ZNqC4TqwPqO7mIzXFL5KxQt1DyQndTXghDBg9Y8He4UvDgn97WDl+zYgL/GhP+9jWZ
TgCc5Ku6Y7HcJr/YDyXc16lybLOr4wUsBv9JVF2pylIBrb/HgqgFXBKXVdcKHYGtauqfF/Xbn6mfd/Sd
IQm2/k4UHQ6m6P+wEOJZb4cQ4vcnCSEUSaO5e6IciAZoRTLq9OXIp/q3efjfC0EDj/OMxwlFwE/LOE99
xlDDBj8T5Zw0BD+Gvnvj6+Q8azzYozO35oLY/tTgPmBA/4yfPz/TLBT75+QWL12nAYsHzCzb+zU47xib
dog7CCnvEQ1qKpES/IYtrqDZiZ6iB3UH3m80rqWlh3XrOnv/9K9+DLI9KaH6Pu5E7k0wdxFvEDW/nNNQ
baiic71ZnOPG4IuwwxIiAlmO8OD4WwQS2Ao3K4+q3ypxJIikmFJ1wSzwocJbvgifePKJ1M/VF5idaeLO
dyg7KJ6ekuXSTOPbiPM3iArmZO6fNKuU6a5tqgaYOmHS9FAGeJz+LMcFm46yew8V1rQSWkPNAy3Ibk+t
8GlYjpv25gNufcpKk9IWVhWoG3VcMtpWKOa2CozbvpH21WxmdwMfUtN7x79PwPCKmfUJu2/YkHNwJ51W
IIg+AnPBOAmh9BEMy0cwrMS0C3SpvSXm0m8hYMdKifZwz2gmiLU1ff68mEYZVZgGubCrrdP53lD+veEk
kU+S0DEFBvB43IlnVkVasXA2qgabbzF3z2Kg+ViOTTbSbrTmNHA1QVOij5YGOvtewoYeT1wZjEsjcX6y
iCuDFX+giLxKXzxn4nXu5IR7nTXP9oU9pOSugMNmc7hyh9OAleP9Ney75SoY30UxNdo0DeqP1lzoHS8k
fAOTNNRzvmpAL40drQsJ5+qzhEVUVtKqcRLMn2qsGDjsPj4wFAeg+iKA2hR+OVdae+/+Jq5dp988d8Vr
1zl39/ripYsoCYfileu8dJsvXfGWP/SOu+INfTru7lHmj6r8+T/e/9wXf1AV4mfX2QcmMnwt/DuON3X0
zR1YSA+bHDJwqZHNt8Tzwx58z/rDbS7spuU3/2l9dJtZ68Zuf00f9bxMklbcTEVOf0MRNP29b3U27dGM
ckScI+Ic3Gf/bsXZlE/nwlFYpB3D9Q2PdJn0IgcnRQTtcTuBa4d2TjCeNtNWSLUuDN8ELL2yvKbXDppB
62e3OeO4hEGTB0LArr+1i2+e+nbjFBFhyvrmzXmrZ7d5D9R8XjVX+LyyaXtM2zeIfrm8vy8yenuBbe99
NF3wK4KMVnjQXAu/iqg/VpargqjZvQAlvhQp77Z3Lm035G+IGSe8EguJsKdXoRcG3rX6OufUNyKsoO3S
PwW7Omyfd+7svfPOtZBxrs87a369eKiCiyrDrqToc+sczi3gTUq+rKu42P5EyWVgkNdY0ELS+BrrWvH2
o6K5Z44PKe05AuRHMjQhlTtHTPxIhi40o38HNE2Xz59fatPUMx0LcGd092KsDzLPmbJKJiL99vnzW13R
1VMqWpsVXRUVPRhnDRZO4zOsSIHPjPMBzuNw5WPma4iUOAV/iEUpbM+HE8w4T3TFwcBmI+qMKHKkm6d+
CHUlSyNHeA4hEHdxI28sOJWRkPV9zN6HFsPi5HqrzqyVFdadWcDxqExubz6iAucjzqTEPAfSrTMpdBD3
d+ukeUWQIpv1scEzs+fY1ThuflGSIsJclXGEm2OXZ79BcswLNL9wMN11iovYfiXtAer0hqW+ZuqFk7H/
qkrERt8yTVZ3UEliw6++DqV/w/YLlSYw71Lvm49vzynZP224FJtKUAfd7qnXvpPDJgQqQyPcTFKz1lFC
iJCGjmh0CCwkpvCVZ63shzvHk/e6VFVsuPE0aps58B5JaBjEXnuGpDk99/BMVNTSWTQXLUKkD9VdW2Fv
WZJQWRIaWRcIv/DceeqB7VSnO26QocHh4cC4mZj08IX0n2pzpORRhIjiTvDA8hvlrdMKOWi09CvXDFv8
rn3O0YEyc5ZgPDSSD/eWNkKhMKZkX/LwvsmIku3S6Q0q+xMWZLGTUP7OfnoC/Z3IWTpkaDqZNpGoTs5w
MSkzaR1Sbgk5FxWZ+uehKCmhSCtxKn3KbWAqFWoYoLV8iy2yCLgerrDnzkp69VLt+lvzJMLRIq4BihiN
cnEm9/xK7vm5uedvoE+5pI6udw2jyjKIM6ekzfhMI9p0LS6dgkorE6+2MceZCFTXZ/CRVn6X5+LLcnBv
gFuuTVQigz8QOtlcJYlBeGybgtnl2CNWN/k5WILNJZJqaP1SinxQWQS1Fyf1M53HOPCXEjw8Vqo76PI+
VI58b+7vC6THVY1WuLZyMjbAU9H7EKuoLzrdbr/5ntgOW+9pX6wAbab/goWFgOIswSzS5o+OTdkilT0A
xoKZYVqSRmhPBw/sj9gVYqVrxZKzQ84f/fW4jNmW2sRLGwaMqc0qQrmUmKP3cmLQw5W4EUtxJ87EpbgS
t+Lc+XQ3JJiif9fD3gOt4+TksEtTSMjoNaFI8dIxGFx5vr5ySp5AJb11NGugEt44JgMs0z5KHqQ8zIU6
sIuj12AbpMZo9Rypv/WtnfLMOR9dp+MSbHniDYEh0SdSTcDsoVH3uZTwXF5CCTqDN6jqRLHLUFv6SLJ4
AMOtOiQAXkv2+Fo6d/bZAXFCfxlvb/Ac1sTKDZoyKEgl4TNZKfA9w/dMfs/wPePv9LcmInOmRWWQkeDK
aA+hLUfVwTkMBnkb3j6bHg0yaMNbKj1ew/Ubb4AHPWEac1SGygBGe3azXiG9emoY5OuOqFPQZU9jC7l3
Mhb3Gr80kdeg7x4EU3+2Qd1R5Uz+fUHF5xwknEpTpa2sqJPrV7XtDlKyXefrQlnkr+5wInvNfQbVPnyN
Or2Nu8/HqrtBiNitam64a5XLk8cqua6thMd397QaLokzP3My7f1lE21QbZcPHLb/SbXdUm1Xj9Z2WxUB
fDRFAO9d8VcXIo/eHo3nHUs1bxe+Hyp5pvXe3RaStwsMSqd65v7WtKoJZ/HUH/f63WGPILQhq7OHVDPj
tc9WX4rxOOtfUeWDkpfoyj7br8wNwge2VzhDuXfBnR+ee7BYIcz4vWFSkMXSP9auu4BkfmXZrUaDJ3GR
hlvSc5W5zlp/XLHy+8f4RyvqLABt0Nm0h9PMajRakVhm4kd7+KNFj61MELEk1+YX1/mHcc0GRYbvR7+4
nSu2gvbrLNQJhRcHXedoy6pyHNGSiB8lZlkoJST5E+7huP8F6gDJ9f+5uqOmrF3WTXNZM81RVtsheUey
8P6LGfezcZapOffknFe+B9kYQRQ6IX1z6d+VPaR3K3LW/Be7hlYf6qkJfZ1zDtvMTbVvLNrvruNnW6v2
++OrllVnwCslFL1uV01H6we3uaU4yZMOXcbfH1u4HdWzd2VZeftzldevXLJZsVo5uWl4/UL36s+vH61P
vrE+m+ub6O9Y34U9fGTlhvnWav0AWab4znU6Jwfd/SPxEyIY/EZ/Ot3j4+OB+JvrBNur+bfHV5Oa+bL1
kzlc+XNF8/a3x1azqP5p61dXef1qxmo1w60icjr//DqusvGc/YSVa6Fx3zwTUWYP6fP//E8k/ud/Mvqn
V+ffrrPanv1/75j9J6AnFSJC4nWtsjJX6jadKyIpB6W+xP29f3+fjC067vNTGXU4Z4uTXLnyobcEbwnb
mNHb3Fj4/sEBjcTK9sBqbab6tanJHoenw1xwfAqa+H//t/iY59VSWDixRfkyN1+ubNlY5XwrGloqwEiE
mrACMKjI7vOz8b8brRtd1C4e5+XjlVroX8v7WxeO3q5gvt07ODrpD2gTwnnLHzkd/UFGqYf7+/uDowPh
/pG7w8ODg4F8XLrUCX94PDg+PjjcF+7HPJFV7Pco85UfzFG21zvpE0t2FaR/oIXDo6Nuf39fXIWud00U
E/1GxM5P3XAZR1P+3u/uU3H0B6uEh5sgDv1seNI9OOh3++IqIW5u2Ose9/f7A6oqT8L1bRxT6f2Dk8P+
oCc8l8gRruKwf3h40D8WTNInPtEl3OHBQZ+SYo9Zl2FvcHR8sn8Et7iJG6IT+/v9oz5eI2JKb/1E1nVw
0js57nFyGoTX3NsDqk14SbBMY+oTlRsAAXlrN1JTBWiSszs44Rf+Njg46g/4dR6HUz9K0P1+96R/onLN
E3c97NH/Trq9I5UCN7z9g0OqX71v5LheuNcBVbM/GPQPZDVLXI9l7vCk1z053JctxmFw48vaDg5Ojk5O
ZNZYOmnE6I9onlWatwioZ93ufrfb63Na4k+5OkLf/J7y2tHKD7rH+z1ZLvVd2QABwwnNmkzEZPNU7B8N
9gf7R2UqjxYzt39yYKb61VSC8T/yOKBFPOif7Ms0DRyHJycHmDvfX61gR0Xj6B2eoBFKSa/XsuGT3kFP
TIMlN3h4QjB0eCDffeM9ns7Vmve73QGNQMwCouaTgGC2hwnq7R8KggyCFr1HCBJOaNKg65dmaqn6h4Pj
/T4xmt4iDVzuUe+EQGIOM5qrOIkBMARrtD/mizjNdF2D3iFlFYAMFKIXqtmAk/1B/6SHJAyCWuhhKWSb
g/7R4bF8XvshwS71d787oJ0jeIg69yKO/PXUv1UblnqwiDM9b4Pjo/2uIN4lcCOsdm+wf3B80N/npHnM
szgYUI6bOFnz2KmDxP1I8Ds4OqYud0XoEmMw9RNK6Q36gAydQjObLrjcYEDTHbq3kez9McHyydGhCH2C
KIK82QyAhbklHCNCHEFyK9FeIhDfl0lq1x4cHcKdrUrDJuvR5BKEn8ikYgL1xBBeO+6jW/yV9xtt5v6A
NqZKkhB8ckybrkjazKUn7eB4/1D1Ue8ISqTl6KtEvSX6vf3+8YlqVgMmJXQH+6qVckscHQ8I8w4qyf5m
ckYMmpoW6gRtLZleDJOWp3eMxCVwWP+4y48KXgiUsJQhofKIp+TgkBChRhsFyBKyj2lIwJ2H3WMBt2H5
0jgFCGiOBv2++qC2zoF61Vik3+8BslXqKk9WoU8bl3A0nTkysZilwcnRMcGCTi5Qx3H3+OiIZk+lr3AQ
yhKH+z2CCJleIop9gs1BV+eXyELCNFGfvSNqN5hGJWDRBNDWosQog7/QJU6wfu/4gCoI0mydxKk+xFA0
9jw3DSKV0j8RkXvj/h4XOOHw+JDglhIJaOgQIgCEcTh9IVR8cIAEuGPHnhwQ1PPbNHGvhkfd/eMjQmYl
SibURhtevnP3CSecDOgg1XO7P6ANQEu/ckPfQBUHhwdHNFSZzNNE6LRP20kmlfNEsNM/obXgZGOa9gfH
hGoGlLxy1y6NbCU3bvfoSKwgUlvlsxmPlf6jbH6SA18cHhPaF3pvHPa6BEOrMF/ijO7vHw6ocHw7VUiW
2qYzgnaiAglA2RHtZDVQAhrqLk39Wp38fTo9D+hQSeK1KyGfdtQhDoTUnU5DX2ajdSS4PxLFbiQ0RxuX
3qOprumwO6CS+6IEu+4BJR0hIV3QBuLBUn+PRRr4UUQ7gjIcHhFgEgVwA+RGSL4P/FDZyUSDlCB7eHLU
7R6qFLmtB7R6tHjGjtYpkdqyBye0ahXwPtjvUqvFZt8/JHKB5iUDohtgW+DFJ0xIQzo5ZIoxo8kkbEPQ
RERKFi/dLGb8fkSntzD2SP+AQPxQqKOUgIYO3eNDcbvw3YxpuAFGVB51R3SIyNd0GV9rMo9A3cA5h5DE
y3cNeLT23aP9B3v0a50OILQAfnWV96WZdBfOFvicJU6cS/ZDd7dInNvMusr42zS9edQMqjbk/4DDyvvQ
AGOHD/Je9TxjLkvKP/1xMsxxy2HE+O8kpvfkR6w24sI9s3JGAbtom2uMZPzoeENjotAU+Yw36bwuhki2
VT6rlIejNvMS1vTrAA4gtmWonWhTg0GPT6pC0gj+0vhLq/RxsfehsTcXf2k0/mK36MtQWuu4zDS+9+ev
71bWXyYo0Wp8iC4aNkfGqvpkqva7xtNIspHlfXybAjzKjNJHUWFgC2VAv60Yz5z78p3O3Jg2REPl+0Ss
8IaOh6GZyJ69pQautAlvNYZfTSccvuSi8aAmjGqjDw+4+HGycbVPhRMhLBnUoIf5A8fdL4axG255ROGp
kxbhBHHHn+u33HnWE4HirNmhz2DfcapzS5vHdJk48lstqG7X5vVtbnCw/2zzA27i5IV6q+U/hI7f6ivH
T1v59Dr1Bqw0YuXwANTrbrXV6tvPn7daoT3kjwn7wXzWhf54xUsATVkJaA0JaH+R5vWj9DQcFeERzNrD
Vgu6fdLxLFdvo/KRVmWQnbN39C2EXQ91TZQOXQFZNCueDeP3IMr98orP6K0I226h9l75UgYAk34+2FMV
/YHdh0hLs0ypANMdwQLKsm1qEur5RfAw9mtFicHz54n8ttBmUIJLjKxn2f29tXAyayFmNAtwNauiHi6K
rrmAv9lm/HFefLbX6wSp8qYObQa72HmyCG+9zNYAAGdS0pCsQCZ1+jMVz0yRnbD5ZGbf3yvjsYRdTUlc
P8k38FERdTfb0o/We2FXcIuYBhFd2A8lbrP1rv2AuxhhDqvelw9qDjYKsWTOo0NHnj1AAaIBe+89SmzI
0DHG1/+f/pq5V+3UX8HZuz9tS9dWymviv1zxtSu+dcU/XfF3V3wPD/GThfV9DFz1B+XLXkbBkvUHv0vc
pd+wL+7vzQ4bSgWR6B3Z7NKDA9g81e5AGxbQNhwoL9ClfpFGpX4rAwR7Q6prmIvZkLBQJGOzjb52x1+7
ncgJhv9ynYDGQ3++dQki/+k6Fc2If7o2fXB6NEzrNfsE0H3tzMAVmjKtl3B09ypTYu0kzrcccWnIk+oE
nMOKmlZWiul68EFi23vZ0MyihGA/wufWGjf49M+lfzP6t6J/Ef37cHd1AJ1h+kf/v4YnLvr3Pf37mf69
o3+vG4jxJxq/NS4YVt5k7GRQgtU7dqdS6zurEHjC3LJ7ykaXTQcRrDO2v9SDRSisTLpOgBZGr2VoSfTo
jOu3CgWMqFC/6HWRtxBXt4lrL6We+2LQNCqhxonQIew9xIm5N4AsVPzoTo5b/t7gQs7RP1xnzxoPrcl/
PsHmavLi1PnPBUyrJ60P7a846ev/jZ8u/fswbdFfgadOeyzfJm774zeUYS8QkVcIHa9qfcIVok2rT4vu
1eWR3zuzJF6+Uqib1Wbiz1R4THnuPpOndwhQ+3wmevllRZzOKzdle8R5vSdPFCIw8IJU4ixCH7szErUU
R9B+ckPOOtud9bvgzp9ypqQ20w4QKkoadxklaHQ5I6J9ArQOOLy5dIqX8aphj+Lk8qXq4ehn85rg09zP
kDrccaN7CYv8X35+xeFUMGHIvv587rXK/B0hmd8Ii3yuhM6niv0Q50n6uTKcSRU4C8IQ7q/jaPrZcmbe
oniUZ/4TSnI2XYgoi8VniyCTKnD+tP6dV7oG/PtoCWQw8n4kYPxpNqt4qS1KdZVzxp9mu6tUGVBlWgMc
Hvg8BRGGsXPn0lCDUiXXOwquHy1XCzK6sP74aA3b0KOL85dHy+4EJF2FmeEzNW3DVFkJf3u8/BZ4FaXx
5dGydZCmS58/oe9bQMeFkbqzmDx0EqXfXGCYUeZxPDPnfVZrIObQ96mrnHfpURN+67E34iqS5AwFpog6
Bn6x7Bbj3roDoJKN0SL3KHXUgzQcKJI7OeFN/Ymey8/Uz81hlP5Zfc/q+wPRrcSG2tlbwe8KOcgXiWKp
e7XDlvGsynyPDldmaffkYKnbqZrmyliKkeLD5kB/mqGjNca2amYMFwUmXRK1s/ahv9+UXa3iI+pRVpdK
RN7x4b5/QAOaNFI6+9w1m3yph4wIafl0608j/ZwtaCfLx1kSyIfUpf7g8WKHkCpzjtqZ0s/NPDjbr4VK
y4BKu27y2/plzQvxzdEuYN1atSOTimMqenOGfWOGi0bqptpcJ8g5iEPnruwdUf8QtDKDAS6G2WqkjQvH
L9ZXpfDy+5WVxxdZIxX4v9EzSZZ0bn3/GrXJ1dYpaZlUwiJ/0JCqPlaAFRkUtBY55LtkfzznU6PdGBIv
cDlsfNUQ3WGj23gQgefs/edD2iRad0/EePlmD0wA+wesMzj+JOPlyQh2w48Ze6giUFYJ7zLWVpXuzJnw
kjVZn6ZESC7dcNjoNES2iHOIsdMh+M85kXorIk2Hk8GF8PIk8SNvPZw0vgbrciHge4ExceMb96tvrr76
xv/qm3999c1vDf5Cqcu9b6Z7eM9krh+G35wNvzlvQJgfxNTIpPESvM+7M65tjYRzvcHO9Ab7udhg/zQ2
2M/lBvtOb7DzYoOJdBEngABVpaxPViYrklXI0rIolVoC4aHI390odxOu3L9K1OOZm3gL+n25SoKQ35H6
9zzy+SfE28t8nqdQ4T73V5nPAQxF4ycvi+XT2/hGJ/7V9+Sj6uyZ0bZsVzYpGzSbk63JxmRLsg1Zv6y6
cfFg8IyO63VM8ADbO/dZYJT4JrmdDomtpX+bbrhztq9m93TC82xB756n1fvkj3aEJl0LZS2HMmTSl1DK
z2hrg+xTX2UJ5/PUX6oA2PP4TEv8kRwIJKq+u2maSvxv6m25Zu5gpPY4JWTCjxeWjEfuK7fBbIlEm/I7
H9C0yVgFEl/GSz9L1uxvQ+V7FYfKqcouB8oIuCnzwukGx4LxN/x6Bz475ao08CBC6s35auFvdYaOcE4G
LfwuDqLNwA/wkOoRypsGEW1IOCZfIRcbHrGdpYBtLBU+y8MsqKvB7LxZ047+R9Id2c523gSRL7ndjXZi
39roKnvF537tLPSFnYvl5Kqq38Xher61WO5WP8rZqcv/hV1wdReo1u/VGj8JcBRABJ8FHYYYvStc2hR1
EsgZbOEqO4danNO2nnkS/meeWOgtRh8IL2yAH/XOazn7zXP3QfBaD+d8038OqxH1/Dqa0tNKzpv8YJRf
eB1GB0Rezr1OUdbx/AddBhVsmbX0mwtvhMa7p9EYHWhFw6hahXqh4njk7jnzclauIL9Id9lFY+aVZ8Az
ZxI6kVg40QVNDesNzhz4lDqd0+PcySom0IYYNPWtSdZ86wqf/kh/cksdW37mW0u4EwycSY6d0c6xSbqw
UKdPAcIur3wrhr38DX4lvnOy9koQGj3tjntDWv8bNpVsvnGbqZg6sWt59mnvmEPNTf9j3ZymzRUhv2Z2
emPLhtdsVEkFRmvV+7VdGGLeONZNa3DYtb+hP204BthVSVvXMjtd83ToWmasSDlzfFv4qgHfHk3Hq9Ns
7FqIGX6KnwVuQhY0c0OXJmxhJIZIXJw64dgKeapDOdULVcAeZqerp1cleyXDc4yWTiJWTlY1or1UkJGZ
N6b2pzN4DwvFGY3TWQidKRLLDdu2vLghXBY3Ru3VaN1yOEIRVmOctKyEVowmddjG9A4T2S14AJk6/khD
J1clVGwg4z7V/mTCtVW5RaUz2boR02L3ELTDttC11vbpS5dnoU3TQ92AemplUJtDcSsyvqztRPaL7jgD
RAyzilm4KS/UpvSmVXhFdk7fXrC7hbF8hNtRmTCMXmTsXh8vL+TtropxI2CJNxVLsZbWeM4niV4iA734
BXpJdqIXvXA5LWGJGQL1BtQQizVhQV6CsgqcpPXYp8woZ7qEDLMB32ggEd3ThTc2FkLM6HHunNCSDNe0
SmM8D9svXbWZ2vSlulb/i9DW5q084fG5s6CaQmfm9PaoCPyibuHzS60ifWc4gWLkxi78vNIvl442cicj
08EvYab8gfoOHJKKVEbOzu37ezzCYs8eW67FuIttlk/VC3Aa9iB+2QoaVm5+8WU7W/eCjadpRnT4LSCO
wu++8GnntmmUsLou3SdKD3sBopdlp04yokJC9jdAf63YcbkLQtZ9SojMWtGSS0ttQuncgcIjm3MmDWVl
bLLw/l4+zMaTSZea7sKgqni6GE4mBK2UQvB6cfHwYNl68mHBlsRB1UvxynNuPGfqOUvPWXvOneecec6l
51x5zq3nnNedxdeeXrwrT/iUjQZ87iHAaDNr+U2/lTQL/YVXLsdUpXVG1jNkvfQEwdSNx8lTJC+RvAbh
blYhUNYeFyMbTmTkt8yN+ghlZBOmF/+ykr3SeD23kaiucFaeuPEENUDVrz1BHaDmqXHqNHWZOnxdkg5z
RScsfWMn35Vb+czfuZevzcP9cid9UMl25xPh/NpzXvvWlS8++uJnX0za565owycOQeVLz+n5J5om8MJg
tWnNqCgOYTon/CSXqO4mhwPbQjpNy/+sh5kOwIIXSQSwD0KGCC6Lu496/XlH1KjTQoh/GcxePgKq8di7
kBa08hE7rdoFeMBh8/rYJoilcRDE0kgAsaXmkeyQNZGekgojZxDrlp6bOAq814hi8LJCTxZd/923fkCs
rU7i3jo/+Bqa3ZD4zbTeJnC7XouKxxmkUNQJAa++0hzUmrQ7h2Jw3DmSHl9dopbD1Jr0TzoHYv+gc0DJ
bIxq9bpHXXmjW7b+S+rudoAj3XEykxKzL5hCNCqxAcgxIsSg/5CoR6gXqMeHaqCVSrM4iZ3PDRNKpZVx
9sXBMY/HGObBgTg8ABJ9QnVH1eoGonfSOalWdyx6xxfQl1LHalW1KHMITHwDPiLlgqZGzhqoWcelcFBa
LqtIECAOpGeLjMBQOgGSvi10TFYrP3U6vf7z553+YB8YLDl12p39/sHz5+1Ov7d/mozjIec5PNzIRF+R
qdc7oEzuMLBVL/m6NtqWBRhdVggWnY6Nt8RxyzfVwe0ZysFxa4IN9kPmS2K8PIhtfqnk1alc8ZgYHHyJ
FivFDPqPSppvSYU2LDDpVmlJsPjGc1I+P+xEu9kGZcTjrSQkT6Sdsirp5Fdfk8rrwwPWcKVvt5/oIK0s
AHP+uPrqVl8jJjWKFPsLjeM14HM78rEzOGhyO8UXw5bfquwOpnPUztlt8l/rBF31qFKdlFYZmzF0pDn7
zGGD9kLJsbJHM9s48Aj3h7TxDg6IlZzR5hocN1M6CcKWTmupNCBauUc8WwI77ZvYqBb1DLpHqky3R2Vq
GupTpa2XLvL0+vyI1nhXN9O2/EC7nZ/r2swdd6PNflf3ExXWtMlV6zYPD41GCYc8qdGoABJ1zPDEv/LE
W0+88cRHT/zhiZ898b7ArF8qD3kLOvC9ScJ8t5PSqWR7X0o73hfSDvHKY0b0rbfXhwjxr0W/fvKf0rG5
2fL8Qbwryv/bLP9rSb/9azf99s7s7tc7R/VO956aqBT5tXjHIP/ll6KcFdGlu893Qxmqxp2/y07V0eB7
dxrkqdVyd0QEEfHz57Ekq4gUiB2iAGx7i2ZHqIcAMq08rLDqhk/TWNIVURFhNFdRNPY7B4YX8x1Su1d1
nEJuvfeo4VeedqCxxX6o0l/Ef+TWO9R67o0nV97eOch5+nsxvKSEO2/vEoQ+/b0Yrilh6u2twQLQX+Ig
NC+B/mxK2sre/OE5P3vEwr7xnI+eZGK3+/BX9GEy4f1F25V32MWFPB7i3zdj5z2iNk88pVSU18TB/f3f
odw1vMoELnihOB9xGKqnxhCyAuXOBBEpqV7/9qvf/CF+vkXFoiYEwha8ubZsPOERlR+edgy5Tg1MZ+Ns
aG1ANZ1GLXnqudWpszYpZeqMngTlsVwvCuNbXCXV3TtuskRlKE/YeOO0Kdj5ROrq+jrKSHE84dT/vnIT
tUV9Zfq6iJsrqK2sntoycn6OwjKyfpae2sj7OQqq0t8nUUrbJRRVpJfCAP1/+NuJZ3kGj9JOlBT8m/9H
HhC1Q0z9PA/dutgi//AtP9EMnJ9oot9PdP3MY2zuNlP2XUr9EAEaoum3rgABQr8E5khw3qgUfiiU2p08
YXYBomcUimQhoTXYT/tjXB5R0rAL5/6bDEmlac0IPKkH+H9SM1gvSLzQ3+ngWl5D1Gw+xPKuPUCGCfHu
NEx2EIhutfUgu5p1qei7S+MeISVSopZTy7V/fSk0pu2tBxipAUKTQXnwVFdXDWHcUA0n+cVDycIqT8m5
c/jnPBQn0kMxozKCM3P6kkeK+Y4HfQynldiYjpzXChFodvAAn62Lb10I3csKua686JN1YsgHpoF0aVGn
SA0WNis9OqJnjl6ywFFARRy+FIsF6JdQ/pO9OMWbV37LC4d2+JaDRC++BRAJF9+CqraKFMOVojca4awZ
202/RU9pM2x7zVnTpXdqrhm2Un4rxjeHY2AvfwSQFfqWMLJx01qFFSCsXU7apVfb0utesDe1m1OibKbS
i+3C1qYWNZnTvaXdXAqiHmTmuf1Y7mRvZTcRM331mE93onqjb6a4BFF+dMNHK3X3buzmDVFhN5+tdGlU
OrPtTSqOhlGE6hcrp9cVN85KTB3YFDsD2Cw6fZPOwwFSJx7LdvoIVmu1a5miB+lGLs4z1L1d9aP4YAGT
FDVPc3A+Kdx3WD1bLAhqibAlPAWt9DJ9bqV16fYFs/D+053DwSLm9zhRLBtiFgSR8TqMKgk8RqPAU32o
M2MsPYMzb4zHVKWyT3CZCp/hSqIe0G7PITKnLXwqpekpbmHhP9w2MZS1tiFjDQQ451woKtXo9FOxaNFH
v+yjW/YxLvuY8IVr5iSw04L/G0JBpzEnuVQkhsfzuj4mwmU5cCz7mGb+6kvW6JzyFyukXvT68Gu5OudP
rdqaKqHFUg6PXRdOxbKcxKdXtVJV3RhVrcTNxZ8QKq2pCkLWYWIRrhcnfH03SxB6RqwR/4A+pLTn8WGO
DwEhgjUfOesNCLUmE75Vb590peQBLyddJWswYVtnPOaPMuMxF7owUbvvZi8T72mYfRe2mGT39zsIFuHD
iq72U4VoWCDg2zwpUdr2obop9Nc5rD/VupTVxXliNuE/uqPgrrmGWPNleBe/oFqUr/EnQQZhBNpxtfwX
15oVdEcNyD2yxYbdB0ia1FQZPlDrrdNWknI2qeZNwreoTDZRx9v+UicA+N2zxS9KGegXj1637vFM+dZN
8lQ50g+eM609YEsyp79n9VrRpuqxytaX+snwjWFFEG3Zo4KN/Rgs82zhho9dVRGn84NXXFV5PL7vtvok
rwtkSyDMjAhNz59newX5Bt7zKqvvQiAhvS4uFXXiu6IT33nVi7ZXccQ6m3XOu373rWXBpy2TrRu6R9qk
ouui6FqqHv+0azF6ewSFBQ1ajm8exUs0VT+mn4ox/eSJu2T76qgE3Ukk9EpSA1YRxSOz7fZr96K8e1z6
icf87HaLZ4l1V4zoTo7ot+qIygHp4dCqlcOJk2wRE528Wuwa0m/FkH6TsPK33VPGUPso0GKokQmydPgm
/uM9+FvRg7954vLxSW1n9bMabc4qi3OYbDurmV/J4NL0XiZwGK398sKphbpsLBH+psteQ+o6ptOsrZQ/
caE8ZG7VFpVE4EhZZ30dvjUxlEirIoHWSXd40pUV4+pjUlU3beNbWb/FHK6ezEvN7S+hA60eO4t8I36b
wfNEfCsTFZ4+1HUMce3yPMydS3ZeHuAXQSNKG3y2yfd07OLM6Y7i02yUtVq2MqSftHIzjN8kgxqnaAU1
iZmKpyeje1rXvERlhSrs7sSl7JiNNj8gGpK6KTpPIHcM8Qt9TyeEAo7DoRZA0kzCQsdGJqflO1E5xRDK
ZOjfdEftdmbPlUyCGkek0AtaA9VZYvBno+xFUTcHFTXzh2V+tfRzyV05V6BvbwsSYzuOLcS4Vmb6a35M
bEswDGVv/0FkplPmx4oksggRCZldgoo61mq1a6FP92+viMX5b8/ZKGXIOWlG/+1tiPwrsSy2ArLqiLJ+
mx2nd3WA1ohZARWmVeQyuk0z0WKMZlJeB3YOmkSdULu1FwYlfceKxmbTMmRvV4VsnuTUBQmNG7N2f28h
Nu6edSh9UrqsqmDbWllZ8ihcRwJeh8kWqLG0oeHSZMo9aEkhDCu92E3iWDihd8H6LpSgBjMJmpGIm9GF
HFEYrKpbeDvEKDX9KmHX6zIMpTHCNn2Qxgyh7F6KIarwlJ8kLEeK07ULhMTKaJyd44dkE6uMmtF27TZr
7HDsbv9FMrIRi8q/EK8TKxYha9K9BvcQsn6dinb5kjVOOK2IgBkTA1fkRCjj7ZyBE4/c4hOLrxDptJC2
Kh+dnviXJ772xLee+Kcn/g7cJL5nDPXOiAYL6hVR4HZBpozhOJ1zpJAiSojfbgMYOTYIPuIeCD1y7++h
A8FT54ueaYcITPY7MJmq40F8m1SsUjYF66ZNCNrohIjex7LzIPPHZbo7LJ+vHoRflbY/uZoroxr34UH8
s9I9GYh1WCtIFDnULuXhkXXeAZd03hIIvaVpeQunDJ23lMqc+lvIUDvvi2DnnfejqPMGc4kf+udkSqu5
8x6Od5xIvkpb1zEV+UeiDF8xle/kZSM3R/W+c7gGnOKMMKlRfOEsXEZ+Y7dVDOfITQ2pSn4BI9V5BTW2
CI0/f+53Xo1s4q86v1A5x0k6b8AYJZ33UEPLO68I2VL+HGV6ItFFEz6uEd76PY3+e9lhaD9H0m1W5xfo
h5hlflR5EuhOcAtvntjCG2rhxye08L3Rgsyh4kBwLpgtIaRHRefPXDyaWyzfO054J1dXrmekFmFkICBU
j6BDNIqY15gjDwXjeEyrF9vDYBiLfJzT7DtOxL/+MKd18IdqmXwRPH8eM2vbecUjifj3DcRVvE4wroyx
GLw2lIQmI0y5QH0Rpb2HgAiZabKQA1IuX+bBLCdcZwRtfnYighy2eCYDyEKPu/PKLmhAnkqO8dMdTWPO
obfRpXLypNKodbkR6Ok9wAniKlk+ry5FDrKGMgGQ3yA2+5vOK+CP93h+T61/Kp/psOHvqCarwkxmVMOQ
wu1wKeQ2WotUh0fc4YfCNALF39R29cdqV9881tUy3Soaz6ojzoxqzK6qgf24s6vFrsQa5p1fHm4XQehb
z7BGI7l6qIEVqzQdchMncRQHj9C6peG4dNykjzrWlSvkqFofNXC0OmrsKG3UgkfILb4Rd6GZGIbptumz
T98+SSsXXx0nKT0BBeMUnrgXjqepMW9LMq462knlxaomCogiBIl38WAP087dKdyB0e8LOLpKO+tTJ+ff
F7RPIBKNL8QkUH9z+kv7FGreF6NQa/lTL2AabJqQbHp0quPJPt2Z7oEC/rT30rURhnNtfoorn4Jh9vCg
w91dAWvcJgiPQ9ObE/XyozcyuCyJz8Mguq53NyUXwJZT+2gw3BA7O3nYjhmsb/pZ8jbE7IadgPgRlpnx
O3GmF3z9kBF3GfB1W1qjgjnZhItHoCIpqQ2pfK1gwtVgUhIOG/HEEdKTKTdJgBCXwyd7PA47yZCeNUGX
OyHN6oyze7syi+RF0IF/tBcz/Pg5UW2BmNkvutjUkt2CLgOxaAEmJZpQPrC27CrhyZyJ5BsdGG1LZuOp
/EmMgrkqmKNgnTL7YzW4SpclGv/IPrjsoUsT8KMnhZkuqqzG1HmkMrN1nBRKsTy62Kj0+XPgiYfC4vZH
oj4n7Z5/KPAHkm96xNPFSCMtBKHPI7d2WjYQG+JgayhkrWD9/Y/cnWaJ72/4L8PBbGDAoIIPA6tiAwBs
Bf3MIH3rviWO//lz9Ujkg5IQuDON0CJCQyH95Xi4GPkzx0MuWOy1fbtFv2E7sV90uj073WqHXQVyTTNH
qQiNEJoIAYUijZlAn7HnSuGBCVBFxXZtmni8w0lPNSRa7UjTlTVFikkwv/Fdpw7ZSLyklbdYpoDHuMVi
Bf/UScXCSU5ph80da/HiRc9uzUZycnCegahFmPh0Mr8At1i8OEEOLyOzce6kBDJUyzh2wqGHrbrVh12W
Y9gS1KUz/Hp2OfeZfUNk7pQmACaBaycvnDEunbXTtm6cqVRGm4EjgndExLPWWCW2gY/mxHKvTueEQ+Y2
LS11WYR0snD4TsIddzQTdLBM6XVKr2u83p0u6XVZfGVzr7X8OpMohD8t9PNaeYncbI/n/NJp3Vmq5bkt
rpzWGYfVHt2cXnIniPyfnl5xB65scakap9Qr1fBV0exl0eiVnMxbZ9m+EefOuj0d3Z6ej9fOtHU7XDo3
rXPep9e8PpjRa/hXrOzFwLoWkaDO0R/qrKB+ReihWhbahtedm4BweKVUDEvKayPTHMhcBQuTRwDG/mI1
srkBDHuGPwv80cVG7fZcA7g+S7iHZeg3Z+FETig3zPWDtC5zcbp6pYAJhmObetdAkElOufJcwM1nzJ5F
IR8Bx8S+DQN2v2sFT0X2hHFFwAp5wVPRvCeLeCiyebX+WDmN2jPHdxJHmgQNIZGLypvmSJFxCR57+o48
0mZF1KyO3calJxMauKaS0J8nnw47eyMjjbYio+madpN2JvK2jzYlTjeuyN7Prxw330j86QpqcY63mf6W
fWE46Wa6Cn8S5tJDoefsTdqti7E1Hn6Ytj50xh+mzXv+admUNvFfX/B39ke4N98Ilk4zUq0+TlJnUiMl
KG4PNRA2pJfXBrjY8a9u4dl07z/W/75P5lcfrPtFGn6w7D3pQDmzx24+DPNhZkbq+R6JjZinQFa14YvV
Hi/yoZcP09yWipQXG9PB+ZyFnI2oTlflCiROWjhfxC2gmwyjlK/9hne5wIFbI3KZEqHi5VeBV/NtSd/g
+77myoct6FY1Xy5RH+vt1Xy8QrHQTTNq7jYXVwgQc06/RHh7dfmvcyjP+eWwGkHUgK5wnGfDVS7otU2P
jeENQvDnWRufa8D/JrdW7Jj7Qfpi8d3Ur6GJobU49e9+mlmNdgMCCEjUx6a3X7gaJcIs2f6StXr2EN0r
DT1otxFRToTJ/X0EbxG+fE/onYYwz63E0l7SGBV+HctrhmKzih47aNyAhR+80Hm9uV9+SEPn5WbiG/fK
ebWZ+J6drL7l5HptYjkZ/6TeQL3Bfx366M3bc1xaRSlkkbPgrpPezEVjXkREtXZWV5z5Edte+dnLjKbs
Ks98q1GUaIhIx8PNyno6V7RQv7oh7lXTOAym0rmkZlyIJ35DzMvYJ+CgKu+GSUrEPpOZb/InRSNslPYr
jZZ0fqMTWg1b3VepL/KNktNr//ZfOhUvSGOLFJ2GF0psKFd3qfPJHfbE1bArPPo3pWeffmfD7sMGpvq5
mMH3uQz0tiawVjdj8qVzResX1il21ArbQTlB5C2SgnzS0m/FM/1CO2PiX9ilHPjBbM5bxMn0cR1ckRa6
dtTTGzQ5dQoNvwBRkdV9Fa5ZoONKfAidMwspil+8CJRIP4UfAJk4R2LacvLJ4oLIi9GN7GxKlckno35b
RC0nZT/cRBJMJTdaq6gRI7A70SqTjNlCYn6WOzzARVu1GNotVo7LvAjW8/Troy7Ehnesa7cdNgN7j6ak
bnwzoqLN8SlfHlMaI5HKy8kaQyViOcfT3YW4pPxXDs3CWTMarSbrFuGl1t0FBN2Ep4ZrQfhHPt4JFru8
BKM1vIR4XT5eSUdOw7OHh4QqNUqW2Wdl9lRlt9L2zIbuAbUd8sSaY5HE8GJjHLfOarLgHtIYzullzi+L
i5F1K32F3t+fywcbQmteRfXlhfow1pKNcy3SuH0Y6rRbnXZO0+0Rz79p3OM/svKeZWmFJdlUS2saqS5x
ZPdqjmwzh/1Qq2sKqA9Ln8+pQkdPFTewzABydMXdgCCTzCSLEQjjEvVcQV+P1QdHOWYNIWrAvHwPH3K1
gqk6UUa1klhXcp5fzb+gHpfr0bW4upZXwClPrALkts+LjSo8VOFtFC9KE4RFMGtFps1uFpkSmSmhTCae
I6D2dqlo10Xk0LIKvk5i7h2xFbQtO+HNuzZkDjEe1/S4JhaHSGbiXoJm0IqbHPDBO3Wb7t6Ua1mdFqw8
B84nyNvziFFf3bWpCKLbrtZtJ26m6vx71n0o237+nDZEpQZOfvVYNboe3VpFs5yvVlZ3ZSj/Oy5ZvtN4
2MaOfQpvmtHRhuC79mmQrtysiGIOd5yBB0frHEydds6kJ4jdCZ3OCXH6OSQVAaNIxDNyYkJHTqdHh0nn
cJ8PEbE2BJduB5WZS0bzYSVNquwEgpzugb4a8TrUnqXUMNG0cMPVwh0mTpfw9rNucS3k8kG2IlZW+rxZ
6j155az16SnPse7o6tTHSWq7zhqXyDNYrjP2oEG4CnMQVl907tozmr0zelrT01pYK+euedc6a57Z7Awl
aQZUQdOix1L5bmXb7RxHy95K3DWdlTjDH1RGhS06kDu3PmJa7VkL9dTSSTZECbTGZ82poJZbskCvPYWw
YY3DZMpyA0pMmjfowx2rnRAGPKOHHh6YZJjatmL6/ReXIxroEgN1UaV116Zf2Be4qNI6o9c1vaLeOZf6
d07c5Ka0z1rSxoPThuIWnuq1ZMXQ+r/zp7ixYdmEBacctpruMnfRC85NKIZYfZcgFR3Bw5rYfxfTZCG1
zX8d9NVuhsgjP6z5Awqs8cEeeQxMGkYklCoggTDdlWKxp6GsJaEs1x4uUWznbUCdmjMXW6PY0xn5VJZK
dWN/3TaneaT0rE55NhpHwxbXOkOthS5xtQHVHpHWOzVat9tbPN7eAu3NkoAzPPW8k0VDFJWI7GkF5493
ZV7W92VTunKiJtdgbmZUNk/cmyB7opTpRg3rBiWzhZ/VWiLXafBvtT7l1hmYnygbQtvJmI7/0y50oYf0
S1jCU1d7ao8ojK4xaSQjeXGgD0uiZhuXjbhCcWXJnZ7+5HX2M19Syb5x2+nBnqs7onNyhJA9Pu4gFS+B
9FSlK5d+a/o88ie5JuOY2L1Q3qwUSibcM9HPGxlkKVhYKe6J77qgxOXKa6245KBcFWtJXTkETkxtIxxN
4R2iYkJGrMo0Xlp2MzG81Xjl+RIW5wude6m0mwAqLhQVvdOMdfWshPAfcS+y604mEoX1KY/OG6q8CU0I
db4hHc4a9pFqpAixrJX4lxP9eGHXlZATxiWUgj5KyEcq0Wrp4qo7nKJmWaZsDUWORKg7G8LQXPudE1mN
u4ZYQYlKfVrLT2t8WjfEjfFppYoRkkcVZboqQzge5Tm6FgiImj0/szcnDmydQ+dpqfW5llqf5WXAVvYZ
mgh2NLHYaiLgJhZPbYKzs+O4eEcTc3tzfmNuYm40saxropJ9XhJXBXFXEHp1phMSr1idni23ebx6JFeX
M00Tt0YUA+Kdtj6hkCt/QYgyTjijZSvzV4QD7MSI8EapjE4kyd4Q3+XlB51m5CV6T6f+BM28bXzHQhtk
X8Z56sc3iFQkC/ymqpYf8qLJv1E6T6tvK4UbVmWFTMIHR26BL2zECCglfYunTr9LsOn0RJziYmtUMh6L
wE/gz3q9Az1m8qZTXmMq9WRfUCoDddaZ+is6fWOhVJgJwcFALi1UNYwwcWwVCVS2YBYjCKd0dhvYNoUB
FVPeLdBbM+C40FlMZhe08zz6IdIYF4xwZIV7j0zMW04o2eNR8vz5QjLgcKrKWjr8wZmrC8+pH/qZ/1XZ
ciWXVrKWQ7u/N+IjVPgSHBYq8F9ZUeywx1UYCxKXVQxcj9vVegkJj8t74Y7suOVkVg490VRHgqPSsdEP
NGX2I2AVHtlbuIU1VVCKGwRDr4JWrgt1N1+pj3wLvaB/wUXZ13khJeYZe7r+s8/nqV8u3pNK5rIkpO+q
/08UTXCxAMUSf2dBLEqXAxv4JkNNMJIF2YbFVQWuFQddcMxqTBKs71jPce0oAG/m9DYlJI+ftZMLuVpB
CeTqHpEFMsQuYO2h/CvlSsmeehpCTTt9EY9sYi+cYJJeCPDkrvzaTNidWMvxNpnhwre0BrlEgpwv7yC3
QA7LzExLADXrpAzXRQOw/ElgyFt7rcQEJQ5oKuOVJgbu9o04pZEVs69iUbjw3Ms4CS5yFLTVIBgLvhCZ
4zbA78mMRglEv+asFFRZ7GCX7KQYTFBVZmK1ItlYK5PjRDDXhOWyTqvOUdAjfh2geWTVlYEGZ32Z3G67
9h4NgY42uHlODZG1Xs6RvLnwoaPGqA0Ktm46rhcu0wHajokGfKgP7EX1QmYcSOEznwuhgS9qVK/0Zcwo
RAiST1M3c4dchwTlzEFrpijXLUW5LuG3pof7s1CSnI68ayXW202V29ZrtzQg2tjej9lywruu9g1RRV+P
2Wr60jOFL42ddZe/3KuFHuHTLUSVDagKuQFxrXH8UleqQiQDdg3tGncn9H61Cb2hk+6KZbkZ5LK8VJgE
uhYkith8u+DrhRlhGZUYUr9GDK8rP1niJi0VMzRspNBJL2FMaeRoZCJLi2lhOSSWzHCY4i1ouiyVpgve
c10UGXFFsXJuWN1GvrKOwMLpjaanYI0WtpF/IfMTmTCB6ZLMTQUXumBBcCoovYIuxz9y3FcFBKI/ApH+
PacT/vt8A1jTL4fWOJmaRnKPg+sOt06evMaFGgB1U0N0zDGKngrNO6pOy6pp8Brg757qV4EhPXhgnbIn
FYllkVj5qviTO8qr3M+nwdSXl/L1pkyFEhcIOBTKApvV8PHsB8pfq8TDif3IjU5OuK8N1osPjK6A9XQK
5ig0DfwSxd0QyQbmxzt1xxahRkhccbMCitmHxpCn0sIiTUNbaHjWUF45EPxMJdapGxT9L3S1yyoeRGPq
z9w8pAn6R05dT8vZS4NwEed+lvn1c8dTVhiAReWmFcwUykkoblqJPFESamUu1WWaJVcGigns0vj2knXE
T12mnRP22SnjDj9s1uNRZsdy6YyDXLqvJ8h7ELfBfB7u7LXplaUcwUw6/F04M51SmDXOYQvpObhD9Qmt
LDbHkZvMd2UcOkfAtnEzpHYv2jO20aOnotQnSR7CiM4qi7flY1uqW+1Z/aZrFx7YYfUG9eIia2JkdUdB
y4mbZVUPc0yW13bycbCXN91hV3kuIcasnFk9MmRuO2lpcwntGjeafjkc9PZyNnP9M0DAQdb1xtFZyu97
TlKVHGxnceItoHExD90Sy4uPfhIPo0Bq4hQkaprB/Hq5U0QYlFwsw5KOrs1YQ2hLQZNgTgU7dTINekOZ
GEgWOC3hblY6tF852bg37O0tmHafw0jQI3Id7cVgQGaToEXLb8Udfr7AhllLXmB+2uXpKyj/Ba4rUsok
3FM28H3+3H1BD70LZl68CaQdiBFJKI4G1RNzNlGMcaWy0hsxqjALnjomn2FrKIoucWIclXmwk5p7Kl3G
aOuph9hlppz48il1FURPdJiYO1vyRTO0flEykFYaD8OiIfbkMeOQ2ZG3furx/+xZQQCYLEtV+7wG3PR7
XGoIJiYHiF14iVp449CKBgR/WzKXgBYWeC+RzoDDilZISskLWnCi31wAq4cHkHIENqMbKLPyCTtnje5Q
tgYFrDBYttLKK+Epmln1QmxvJauMqCXyzjKeOjpTe04Tqgsold2M/dY/VomhcuFqTZk7PRE6qw6dGFV4
epY3G6yynFGaRsWtZ62iHuonTVEOLSUErchlNKWiZQ6Aom4NsopxigNZUASTZgGdfymnKnohHU0FZSO0
LrHxhjvc8m3heEZ3aEUCqLIHjhdApwleREe2hzcPRAt9hVBIlcB1UcruH9lNcmV2Zu2gktBOaW5dIKac
71mmgbWkplj+JNilOfSgRNiC6d+sVekjfTGHs2iZfUaR2BzC8+fPuJvAPio9WyS+O3VcYWRsObN2yDK8
Zzw6vvupZA+EZ2ZP2zCGjwrNPHnJwXoMpd8EDDBkVmO0CsCebOhbcX3OJz1zw0jI6aGTkxqB7twC2AkH
6SKYITaexCJDopxVZ2RCqzfsgu+NrRAxT0LRDje2ijTkCNGLRcAepLhDAcSf/DinxxWdCndtnzDzAspB
N7jJp4UiwgWvU2cuBVP39z2NdnlYeQWV0eZoyq0vTUWkLAseAIQSh6qBP2xYtd4RsUHNr4gKuaG/zc06
9qa1tRCsqAOiVv4jyWm2LZZHhHyGTCCAXh5rY+TOs155kqSwPN/wOfpkNr8iXHr8TCi8+CpULzXN+WjB
1fv5F1b1zKwqYfV1FlxF2nlEIaXcyf1HpSDO3wRkl8N+wRRB4hQOcRM6Wku+uHwd7uD0tq8/sgfgSKnN
gHhIK6CAKkwkTivUEmhIBDjLFfVGicRnTtK0QL0UwkYiYDvJnifkb2qDaq+rmHa8WV9dljay6A1+jQwe
bYOU/kl6aXebSiQJvv4RoFxjHEzbVySUXwZEpb+vZMOD8+Mkglw3//6+1kGZP2yVIoQtZbzP+RFUFNKv
Mk5ZRbU2zNOK054d4IfjbBMAPTb5hZopFtTbig6cmYcvnGWVt/sEYq8CGRth7bzEEwz1KTUe03Hiswd1
YFcGw9iJSmHl20D6qnnDvwuYUbWlpInAAFQ0EORMhAZzyJ3bwokSuXnQICoQG50xrCdnM2LbgQ8JFVtz
+msU67VRckzPe/Q77NmqAtqk/x8q/BJUiAOE2Kmd4GhGwhSSbmPBTaETkYOkTdjDO5FsalqbVvc0G3eH
ULyQ7nW0keb9fffUSehTYt61+PpCyK8QjwGctivKsXLVM8MdbCitBIPCIcwKl6x0Zjc4AUY383FK7Nuw
MTXf10OZoV2m9p778oSV37mQxG1BZOFNIF3qpUVEDSCpiaQ9dbeG+1EeZ3dkeUQ0qE6fdke2Ei7FzmLi
tSE0lTlBpeFXNNI/cjcJZuvGM+rK/T0EMrS9bmz7hbMaW4vOKl7x4FzasbJs2wllqqwhR3biNxD36sap
6bfQvp8c3Us5V/ZIfwALoGvp1uRHcAV9U1Ghyotb0GTjMo94o6SydtCrmXFAGOKY9JIVoivI3cFqN2PM
qta+Fp6e1QBqfhjySHvZCvRXUMM8DxLug85HHo1HXf44Rp1D1Cli8cwt3Cjoe3JHN0C8djFA3xxgsrUJ
nEhNO4ucAHIxdoVr7ooYt828J+ILzg16OmCnsYGM0pnLO8SSyU+auOdsQrtnXJyrWTNvrvaI29+jx6C5
IqxNDZa9y7VRrrofl2KOivczv3PHHh3WcOcwJi6K+7OXEbrnS1f4apneyRFayf19eOoDZjiGJT+xVCOG
vT6kEsRQErVCf9dOSn+na+JuaQlyiEkK0PNxKFBK2xUhNZnLJkNq0h7lnY8cjo0+txwjow8BSCjQJME3
s6bVPt0Vfbr7TJ/uqJ6U+7Q2+7RuceXpjj71eDjoU5ER3ZN9ukOfynkPrEIjIb6/d1n7gcnCQm+AetRl
+1L8nUplWzytWcULQU1cfb8OUI4sjAM5m8i0F+gdYMVEimQ28ixYgET8YF7Yz9Zf+Cr/5+zbwtC3ZpX8
mfMxIKxJo507JeohfABpQ69VahAelKD5JTamqbSUTWGZWmfDYGD9zLhhB6ETECirm//y1lsSaeOPIFmG
f9DfbUU1fzzxBf93MTRDuPrGOckliap5LLaT9BSUlCbL6kwOEWTkY1Ah63G6Ku1Rm0j7sk90uFkRIrnx
fxe4PfdFgNng5Xiy/cO4XMKhEvnBAPmZkv+x4S/0LZ+oWrqQQhJAQMAqt9QfUDVPVm9FsRWKEV/+ZGXb
qNVooOCcaY9AKJe4UjHS+RSxq9U6111bduB6UfrK8TYddT1+jHA4GdRL6flrGlM9yiWnVsVkm7jtNELE
Kqynct+T39/np6WXtKiVNf1muTfaqoownlu5vZdznPh4/nZjPNqbZzHkjhyxUk74V2yoJow2jU2qznnZ
k6gFY1ZxxQ6kt2n/spUguQ2iH/g29pF6MwvWXrSkOnfdtZZJFxbmhRBDd0fRqT/yWy07azmV+TRMCnm1
ZXS3T/LeMEydT7MwjhNY9CIEAP3yzTzn6kgT5hpFwR8CuBDtIRAs/s5yUDsqXDpVmQ4Jn9G/Ff1L2NSy
Z9Ya1+kefh1YG+0SQUUjcOmw4FYIxLpEDgngTzgvlTfrfHXHToIzq9Hp+g1bzItBbc9guwx20IaRKo95
VzauhPMZvV/FtzW9/7am96Inp8cu553htaa4WTsNm8ArjuA0pnNgFpb+yuucIf+d1uNCfCLMx9cHDeEO
J5MLKC2UpT0C1HmcrHvdxzqg2kAsTb4/XaV1dfS/qI6bHXVcfUkl0x2V1PkK3lnJMlVws6JzuN897PcP
aYUOj/b36UX0T/r7B8fHorffHewf9Y/FyVGf3g/ESe/kqDcguNs/6R4NBl1xPDg4OOpRQn9weNI7PhS9
g4PD3tHBhQzzQWT1jdlAb/9gf3/faIkeDk4Oj/plk90uVXNitI0s3aP9ftGJXv/k4OD4sFf2pk/JPVSr
u9U77A/2eyf7Zf8G3ZP+cffI6Cj14/jg+ET3mFre73WpibLrU+r6AI0fHYmDwQllOxFH3f3uEf32uv3D
/T7Vc3jQO+meHImTfu/wgFrs9U56B70e1UdNHx4ODulLt39yMqCm9/uHx120SB2gDuOByg764vjw8LB3
SF+o0CENAqPfPzncHyDL0dGAJog6f3R4TAnd48H+oL+P+vvHB6iOJu7k8GC/7PgSHe/v79NcUIcxAV0M
r3t42Ee/uvQN00aFD7oHVCUaPzrcx0P/oH9wgofBPi2EGPQPBt2jQ3F0eNDfP0Ith92jbpfKDHpdqmCf
vpxQP4CKBidUa1/OMHrc2x/QDJ30MEUDmkVxcnx4TC1iIgb7xzSpvf3+0VH3uFf0vMQuRAFGWVBrW/49
7/HJhf2/jH0g83+sy/9jYHXrUBDuD9JFHE5ryvyD2ugcXGwXCqaEjiqWM6WrtNgys9/Mla08PRFRvzsw
gzyMsx1xDyB8qP8CnczaL611CgPP3R89x4pZycLjkCBwuwvjljZrHp67p9640W0MG72GDksEf/dxEZYI
Xu5jyNyKby5uK4pvbnlDfOrcpeNo3DjrikYraDVe8l/5/FX3KwKbr/ClvfsTvXHhiHNEnCNSObqy8O5P
9PZvGsh/1TpVgAHQczOUOZqzrfyNVkpvva/wdaFyzVuNN9QF9R7hfaObshR+I1V3hLq5y3+uva7oNlCB
kjZmMZFEfkzEZRLjVj4uBYhBFPnJZmzBxyXT0pd5ob+WZ9sVPC6CLC7P/6TiZfWW/0uVL6tX99tervVO
tHZsxdaOjQiBc0Cc145Su6KW7PVpK6r1mBjhvpqRMEKBsQtrpdy2Tp32a1fcpc61237pjhRuqQ/r9FUQ
w0xFljzb8sYTx6IhH9teGKf+tDF0Y4HAP0OPPuGhfeUTPek3hqlOcGe05I1hGBOxnwbpcEkf+Kkdr/yo
MVwX77rOO8rKPkKGZ7HwXEmFDOeUT7+oojMzSZdexGIZR3FGNODwdfxgj87qFJM5CGTn2l+zH2VZ1tlT
lXytvCEVNweXKcLa9ffoCKN/3QtxxQl46cuEW5VwqHIdXpgzzbc5VdpTgg3N98u4ZM30rQ8M74uL0bsi
Eh6M8IvkNbRB0lhr5jk0wWH5RtNfnCK18UteyZU2c+3s5asn9tJED5TSNb52NzY/JfWMz72dYzR3PCUY
da675n6md6NCeo6KsT3mASYqTZMyudsCEbHXQ/0e87saPFCs11l1W4nldRJBjz1Ibntt+tO1W5ZveSK1
x7n5lR+6hEHKxJQeUiRSPeoZiVRPyvXkZWpR3mYUbRp1VKSlTkWLG3509XsuOIiEZ77jQIeadzVJDfJT
MgyE2x0SS98bhmLVHU6Cpnmkqzd5pF+IVa+SIaxkCBHoyRBjmRqwtOZdB0RMl9269/i5tyGvLlXMt0/C
r2jGT89dWx1rWa0wWRX+B53NKCN1OwKEnIqdeUJkzFvCMjjr0spZt3kB+3gI3eKccOsCSz2u9lyUDb40
fFRclo3/zOnoleW9Lz8d07J0+mDsN0Ii83iD1a5sOdNmyrgVzm2xqamQ44rFCjrrVtxZ48z0nEkgPt0N
A0I4a0z2J1yJqOe4EFl7jvTvTJDPWxbRHxqv8NCjh6/w0NcPgwtF+CxgWzKHOuIbAw6+JEjYJrnzJWu5
SenURaZ+oonJ1krsxOwb+Sy4Dn8Ts+v6sv1yLr4wWrZvfYyhnGAbyotoLl0vr+Ld4FHsWetc2RNUYCKx
7fv797Ft+ZvJah1/xgD+MJaQgyv8qQV8+q33xvJJEuq8JKGUT8H3hGuSOK2TeZYi2WjvoNRAAPy2B82M
EV+bfn6QP7/qZHpXr/KFE3/lxOKTztg2P8nidKgIWn+imWq0tSudsvrNVykHNsjooeheV/WL+BYfnEkD
yFlwI7S/2joN7fAdTY2avdnMxsjLcb/hKtXLV/pFtVK8oJmGdtncnsa3UY0hR2VYL1M5pJep0TIG4Jtt
+mY7eKs2lK/+dDNts51KM7IVqWhe7pufCZqJ405BvaaWJFCvU/E6FS9To8WBLV6pd8TwGnQ5jPFbtjB5
A7Wbt/L4d6aSUqBPHX+5ytZI4AekQF8DCfjFO2+IqfTvUnhgDJ6MEa6JsTfKWPYwGt65lZSHarVGeJS3
KfeAaDyvanFsGhawLXwwFfBkMIqcM1wbFIr38m7biNKjr7c/Bcr4nEqV+T0Ziie+YItcIpi8slj6IhzB
mYU3SS9wmVvc/NH50bm8hKnj5aUg8tG2x1ZDJzQComqQu8jilLlt8Xts+VQm5yrKObi8hDqKyEpzH/Uo
Y+uryf5rjMChNH/FJL3cCEK2YdJSzJUr5+rSnKvtiEba173OERaBipRJflhmnMF0AJoTTjiZXdD0Olsj
ii9E/ZzNYN7n1q0H+3NeFRrY2pkzdA8mc6wCzV8u5kSyB8Vs5eb8uLQcPD8ydsFOIKLpKC9InxW3o3xF
9wf8sBZdknGszFmKT4NR0GoVkdWrQ5ABuNiigq2dirHAQ4xLxaBhPnEvOCrT9txAy7oIFpCYQ8uFWk05
wOzWrxjXGy6CZbbRji36oi+jFWHDW/bmovkXsmY+lumoe69OX6U2ap6U2c6yMgoOuOsSZeLM31kg9TOp
7CXH5mZZsjE0g8GgltnbKTdSumo1XdAnOzK9PUc0vJUrfUPFNP12haMoGRflfNofWlHLaTQ2L20zHWht
bnqLLUWciKsT8d0vNnxkV7QfpQvWSkGRsfNf/GeobWz3J/mS/tSM9s/1b7sio7/QCd4CMWXM9RVhw8iW
cd2oMmg1wLa8uHSlD1I7xDEc7WKc73OCHKkyEqUQ44fBbG1cEL+LJVw2UG2H+EXiBVXXxsEwL8Ho55pt
UmFWfUMjzCA2pcVWdXlzQ//p+fPHV5QwvHTnXOF1n94YTXmupjxXa/fkxrfL6s5IQcKuSZXuhTFhVjmv
qgaCPF+dPNk63AyKYcxpsfU4n9qA75J45ScZGjP3W7YB3xngO6uDb+Ds7+GqL3sVL1c0xuk5qi+Rk41v
uplfpbZsMbCcoJ09Q1G3gUcNcM8qvU3LOsCmgNz3JZTLo2BL0YOAf3AasJmP9sRenib2p/4pO5ChASk3
gcaG4Bax+WDUm1X3hE8lHjZBXXZRwnpurMU2iG8sSFLPj4NI+PI5NZ3NPGkWAzWLD7vOowETVzRFwgTA
crSJOvD8u1o3NMX8IEODdtMvigSQoFcjGZUB+iAuhqtNgxTdArtIRXerHFsdL86j7EWfiQX+Lo243tKB
yqe6bPgV9EtlhEh1rO1w6v6587r32HmdXXC1Q2snOaO8ydep8dhCHe8m6+zvaAL+8+Q4EF1n/fmBqLpr
fRiWDUoPO3WNymZakfZ2VJLUXOZhKN0Afq7vspqy8/mmgvz/tf7rlgoFWQjB6wcjR2NmtD8/MF1/MTbA
9KMk4Y6zWp5JxF/mznU6uk4dfwswMjnO1zCZ26Li9LCgEVldI5u4VicRVGUu7Tc36y2k2zXE4YiOMXbl
e3+vn+pd9rKvXpsdoUkqsoJMGXnUcLGVCKVbzGWr9SY1vRaYHIAm5T9pA+gKByABiUh8drEeluFOw9N0
lIIDQBRbyVQmjow7oiIZWFvrDLYwkTDcojnSa64ZyQBSMR301TfZhVgHPuHLn7sg3SWNg+2KX7k7K5zm
s/SQGc1KpFvqI9yOZpeX9/eIglZNg4A3XkGzd6F0Ur3xjL1tpvpX4aIZO3DVWmz20BPzwj5N5vyONdcq
L2bZq2yYwRtlyQ1bDc7asDuAQjaFFDfOqsOxxy34pET8VasxJ6hRDVNepk0bXuimqXYAbavzuRETHRVk
64Z46doyaIAhy6CK74LMsmtzazYI0QU2im3n79li7bwPLOrv3caAim7ykDhO75lj3RVjogmB8+gGbYrF
1mB04arMxbqjc/ymKIkbTMpSJvBRqm5GnRsNAzrflbPcTLqlOdZJsjCf19bcFudGBfKTuDYqUE2ltwG2
NKEDj86axlWcZfGyMYycH2Jxqca07jdwX3CuXxuiQJi56NqtmLqmvt1R1q5dLXetv5mfauq4Vd+mawDJ
Uc9fltCA3rbdCBeO9HEZTKchhn+mizT4NmLNtxFSLePX7g9IwK3Er5Rgy1CcIx5lFq9qhtiujrFtbfbw
kWG2d4+zrp7KULv/xUDbWyNtV4ca+rMMY/2uHOvdxljvPj9Wym4MtlsZa03ZcvDdzWUd9HePVrp+3xhq
WyrayBH/0P1VD/WHraEm8CVbM9bqUB8F3UeGuVnuT45RHp1bo9w9yIA5/ZnUFP3WjabylHjtzMRL53WZ
bEG8HzqzOlL9NT23XqqIuWFZZkz5h1N9Vw2vYIUnMERTKdIVH6bsdDfUiRPnIwiYQzq7D+ngHkDo2WML
aI6rXF73sYb3E698SvPIOAkqgdQ+c1MHRu+PdJy1Go0h9UtrJ/HxV+d/tubGuYyypG+dUfrXDcdij9/+
ZsXNb3mCfrlTMpTdsul83PTBh25VKwMhVWRhZ0SFqhXrkvxcV/Mj2lqt0n6alU2+rHygygd6UO++xFQ6
VqX//5xde3PaSBL//z7FQpVdUhhsHjHZlTOh7py9c+rs9VZMrtZLkS0ewhBjiWgkYyf4u1//evQYCUHw
VmIx7+me6enpeXX7aZNEo8n8YT4pVTtcyE7rwvTQ8JuSyQQnvir5naYBvAQA24ARJo4hB1hm8jKAZLhR
QDLedhWW81Ihbl4U4RJuwMY33KDOUjUEBRpjGa+or9zR3Tysh8NlfUZwLQBbfewvmHcEt6Oh1RD8z64a
+odxGKfhZBaG8NCPxjOtDDmNEFC1aUo4MLN2y6+HTCnn1N8QcQLYpyuKOLncMQKwzzCaL1i0qs5o9nK9
LHIcBYoR4YPa2XAeVPFk1IRIm000odkPljRfsSpIgrFENSxgH7g4a0vqWopRaJ8OY8EykyGHGwDcFmvf
5LhVXTaukj5vwFTCoHsKykG34PhYluW4764G2XW6br2tn28b81JJps99Tw22Z1rNJyTKik7in7F6dg7Y
1b+s3pujsUSkFVMVN15w0GnZ3arnk6TK9cTKAmjlkheKWdFKPsi3T8f8kPOjViiQNcWCiSIHL9Rm1Tlc
uCTI20IlWVWW9SmfNUHNyBtw3tCa5k4DYoM3pYSjizJM1ZVQgmlHbtGvHbtZp2kRbkqBn5UZaFefcw8U
DQDMIZJvEuGVDCRx5L0DLYkj9S5HUxstl9sv31UfCGtHfW5c3ypfX9LcU1Q4zVcYmTwVnnZLZtaE7tyn
M3+CR3wwzf+oXydeQHcfq0sjJ5UoUa44ky1aKlqmJqrl1uIo8IwKRUm1rKRaUlKjUNCDebOHmS4M87IW
iEts93Exl6x6gou5ZNWnADmtergI/+s+da1HxqNvod1rC1YS2BIWGqU21T7KCbgIrBqX/PYRLaYhJAAR
2EQgJR7Yjm4TW/x6eHhP4tqYJgfs7FrXDB9Jp//UEbAaia2PLALPy0N4V4npjniuwPNN56yruacTc7Pq
s9kg98mGd3xMQGLfR95yTvWPwHq4WMoLbFQ9SLc7dRa0kH9Afz0Yj6DRC+O6XApVl5PaEgKl5XZvnZmd
vXAfi0xhgdA2CR3evz/rRtIKanJp1yaO9chWk8pztV49QpViYNMYD94tIdTgQtqSpBr6CEBUkcF6Dfgq
MiIhtKufwjpzTXNIQVkQLyMoQHC0fv+sSZ5AIxZWGz+Y7Mt4yX4cVGRiBYkytNzYmF10sm+ZcIA+TGQA
fbqQRkXLzQgWHMrzcBR27jdiaFSZMkguolCJ+M0q0hvWffESQxvX4q3KkSFCpWMosdSyksMjf2r9Zb7A
uTYy/IXNjhFm9uie6vtVVo4/W95a2Qn3vaOhMKYVFMLd9SoXrmj8j454cndpMk4YoPhNXlFZFzkO8M2o
9D9+aWtEJU2xZBMNKVpagdmkxw2sut/Ke+KhvBuebGdLdz+U9vUTKJQJM4iWkHUMenxVtc0ocWbHjIj4
LVwJC2Jvc5DaZr/TfOCrrB2vsqYUPfJ/9lL/6aXsE8Orf40LI3ZX7+mSBgnH+5rW0RvoBWuBgbJVsotE
OYh9un208bjZd7jtN7pGhQC7SMt6ff9MDCU2fqfN3uFAzkwgEk6bjQA7XjFDeSl+Fnj3wJoh9e8MCjFu
8VnKj8pgoF68RW8KH1u2lvWoKT5dC+X3R+LNT85UzJ25+IKVlrux4xyeFvabQ3GnusVljnnhLD7ry61C
DIjwlo7tKB19EQvWQDJlDSReaYOSkBqfUHKws1meXhjPoKImhMGfAO4pTEVkZ6cyVm+QZovs7zgpeJS4
ZoA99aMnGcDplU2J2Uz4/GwbR5llyIWMXEjI/aCoQnzMDaF5q5yy/k5xfBS6t8Jw7F8wkVXGb9821xU1
SLcz9tQfrkpLUPzUazG8X+4JB/FiaKWoVEKwi1t2kNDjjLsc6EDQ51B90x7J+zNxO0ACR5EQoVVaeRvm
+ENDB4QYitm2Q2CGgc+NGjBPjNp5deFKV4cELAvPZZ+KGogxMc8HNwg5xRj3nQP6wVERycUUOJMurKeC
NG1huRVmrOt1UGEJVKuu4ZLiRUykKx7qisccwgoFhyxdYUXfJ/ihsDytOJLK4tv9eAgKzaFDrhgmZvC0
FBVHFWbh6/WwwvIuKp7qkmxuScZ6jo24uUZzzs1O/oX2s8Ccxzb2xEgnvnLcY/R8SGG+xtDXNUQMGWvo
bhbRSsrU2CW+ciRtNnZE5EDNGQ1EPyDcQBbcuqAbja0myHJtEqkERvJ6kRknjISN28QJN4uoVAgGtJjk
BluvKxWqecoBwM+0C+URGRp2oXpKfvecqqfq8cAWMFC6Sn0qF7fKxXnk9VbKzQIor+cqI7dbSKFW+RTP
4qOS/X7Vw94Ktq3pb4UplT8cwp9VldqWU2iXx2nxHnwg3hMTGMdKMORwzAYA9U6o+F3J9+ooCsfik5K/
K6t6cFM/uK8fTHoH587BpXNwfXRw8WfVPqVUc+XL97R+zplt/3B9pS23Hx7WYKXqPS+wW41Go95o0v9e
o+Hw/yMKooK6V77zSYkrH3dGyk38J6Vk15e0OrrQ1lr2wmdkTy3Gf1KpWxCayh373kR+DK2S7R2U7Y6t
ptt+ZWjw8I4pADcI8jcH+FZmj9rK4sug7LJrhbxhPp9Bs5TlmmFRFq4BpKBxZ2inPgAwotATRjT5siS0
eopCdzdiHfd1HjEK2BexQt6diF0yLCliGjRGTDuLUKeIxdE5xGZ+FBTRSvRjxuB9IwHyis13WPZxJ1VV
H2Pd7rgnr6wc3giqh3Yt3Bd7LmNf9M8J4hR5gM+ow5HHKkWbo/K96XvhbFtnIstkiMuCvLkT8nBoMosr
weUSRWlktBNo7+g7nSbuOXh0x8FVgC/rNo5MEWDG+AWqyty2OHGhjoM+bfe1ICKi3xPxC/01f6YP2hXK
OejbasL9ut2i78+d1wh/00JEp/Ga409+abkd8ebNmw79tJsnlLczEOfgf+mYYKVCme8k52vmve2G9mqi
S3LGvpN8XN6b5ES/JfnY3TbcHTNNS3uo15L0cMahJC7fpdWjKfOeuNAnmv0EFmD/ZqZ8Hy3CuUWsnzhw
6V51PBIXi7lK+QxYPzHt7emvc0kPPhCT31V4Msx14p8OltsTJ4OCkw5/OphsT/qeaJtEnWZFxt7QTTKO
tmUsS/yvHaDHVM7pbmi96A5ISruiyZwp2CneFs00A2lNQDVP1BDBT9s+4ELlph6sc8V9JpO+A+Xlz1bT
cm/8Ev1P54q6OhYzbpQ8L9ikSjHqs/0QTNLYboTa3A+YrPekkE+9s5cSCWV5EZ1wFS8gFUr/Amqh1AWC
4ZAX0Ewh/Q6yASZllHN6k+9r7o2kv5lL7tnnN4o6L34Bhvu8q/IZAPsjS99Tbo8SabPNX5RfvMcfp77G
25EqroXNx3w57hhpq+JPP1EfPAvvF7vyApRjJKqK/6WZHinPj8D74/KCoCu5ITpxp4Ty4aH+PRreT7ra
SW1iO1WfL/1lyWnpHC0ouf5lBWdBqLp5r/zDd3jrY9Im57Nln/7j/wEAAP//8f5m/3U9AgA=
`,
},
"/js/dashboard.ts": {
local: "web/static/js/dashboard.ts",
size: 946,
modtime: 0,
compressed: `
H4sIAAAJbogA/5xSwW7bMAw921/BBQWkYIGRYjcH2WHZYQF6K3YadlBkujYqSAWlZCtW//soyWnstKfe
qMdH8vFRvQ1IrdII++/KdwenqLnX7gkB/wa0jYf9N+ePNmP/ygKJHNXgA/X2YVMWxqmGownS9oZ7ToBH
fG7cH1uDss+bcijLQ+y4czaQMwbJV/o1luJVxi6QESv4JW58HM6huOlCeEqBcVqF3ll+tEerYygzr77e
ZAWprAb7UO1/cHSPdOp1xM9dcu5ufI35ZVz3pAg8KtIdbC/8KkNyydvlqdXoA7PEXQ7FJZlMi6kJlm1i
MPca35zvW5CfZqSk5E0doWp2zj32KBcZXEQ9A0+41ilyns2aN3l5AXs0JpYRxg3SRmdD4YxNxxO2hL6T
c4FV6NBKZm6/JnLxji1x90tiZklRDCuQDKU/8pEuP606GITgoMXAx1L8l4KvQcBnYFKecbYn147fkqsv
PwhPaMMoIiqIt8hgpO9cg7Ddwu2XnC003yDg1RHeMXnB4O16vV4mHR85T9Q9lMPv5eZ/AAAA//+lL40m
sgMAAA==
`,
},
"/js/directives.ts": {
local: "web/static/js/directives.ts",
size: 20128,
modtime: 0,
compressed: `
H4sIAAAJbogA/8w8a3fbtpKfnV+B6KYheS3RkhP3IcftNnV6k92m223cc9t1fXooEbJYUyRLUq9t9N93
ZvAmKdnJ7Z6zPoktAoOZwWAwL4Ca5NUy+7oowjgp+bROVtz36upHXi3TuvL6bLbMoDXP/ID9+eio5PWy
zPDTUc0XRRrV/KcyHTPvpIjKOonS6qQUQ8N5vUi9PgCmSXY3Zn41zQveZzzliz6L6rqsAnbxJaE6or4w
qd7xMuEVu2Ar3aVI1tuC5zN/BYMuLpiXT34Hbr1zBNnh7x2Qgg+74PzRo+45fZMvimUd4WRwYr4ib82J
+BgLwlMLHCZ40USAMHWy4NgnnuY8inmpn5GjvVKysXeLasyibCvkJT+S0OizkVwyk+Ah8hJIma2iki1A
jIt8wbM6XNZTG4iEdmQafojKCKF7T2Pg9KLHjhnPpnnMf/rxDc45zwCJvwhnebmIar/3C/wM3r4dXF72
ggCAe08Ry/3jXr8eLxYwRCyaWfdJnUdA3l815qZWpgMpDgFdCLrXX+ksmy3qy2VJUtbYATWKJ05mMyOh
WEP1mbdI0jSp+DTP4spDEgg/g78o7LdRPQ+jSYWa+IJ9OoQfIXXJLOJVM/aq6rq6IRS7R50A8XV8M59f
z28Wi+vFjQbfuXO4AvE2+TfLC5zQCitOs3xt+tyuRSWnDTAhfvQXqiu6zaHd8+RjkmXqEWctB355weRs
JTgOQ5gd6GnFqUeOTDLmOfPWeoAq4zHfgz8Ie+yskiCEIEgBAAPPFQfsoIrbi1rVZZLdarkUsEt4iSyc
+L/Gx4Efv9++z97P3y/eV8EAkJ6cGwFK4JBv+BTEeG6YbagFUX2D2nw9ugn6bHF9ehOWHLb2FGxLBubE
e+sFAXKaZIByBu3sDa7bO1Rxxjc1B21ib16iaRJtwHCWf0c7XsyBJtphu3p1hZh6B4yxMBy6WxoQw8Be
O2KZ3yfrqJ7OfeoNBcl+x6bcr3yys4bJQr/WW9mFaqRwv8riK8tctTekNFdP+CpKW6MCS3X1aLlSgrDW
D1ImCUZ8HYOZY6CIDK2VGiQAdg02xeJoHlGAIeLw8ZdEaum9ZISnwEKcT5ekQNOSg0l9BUNxUl7kKWZ4
Gko54R/TOC85SsGb13UxPjlZr9dkoqMsRtscgts4WedlGk/TfHoHXiRb8bLmMbmQr5Iqv/AauGDCeud5
aLnfvr28vHr9erGweVGg3tNidDFUOKLsdplGJQ5/FYFqGJch+UH96LM7Szua2HCX+3fw65S2/QU+ryT6
nWEARIsz8HkaWIshAO7x7LA73iXZ9GO2h9mMH7E/iOgHbxCjRbAqZb74Pl/7yo09bLZ5ntZJ8RGz/UcZ
FfMHzFatOpdai3+vhzdBKEn7fzKye9g5Zr1JXtf5osfa7O+Jw66iyZ7w68PDH7I3GDxIJkmQJOM7vo3z
debzVW2WBjc3NITTukz/g2/13hY82Gbg5IRdzZOKwb8qZ9U8mdUDjpadTaOMTTj8Wd7Oa1bnrFxmLILf
KWfrOYdIFWeIA6dRmvKY4TIrnPWcC8giuuUOS8DvNxDlQHTLRs/Y06cMG4nuYUardQJa6eBQ0NMITNMX
Y4Z0o4ncagBWlHwFc7nkswgidd82oys0SFEIVnfJreaqhrhVdFUgXdKrd9imTKscgpF7WC0n4M/8YV8M
owjx1xrtre4THWawi7RBCMw+tAgWjtnovC0JmujoGc2UFkmAoGjbyB+3sGvpOkilfP+PJEYwy0mnwCyQ
NKoQC0CE+PFNFvPNf8783q9ZD+U6EpDoz3yK2gAW4c7h0wsxime39Rz16eSa/VrfnIDxqcC9LifXyU0A
cMfHgZy8RXZdSaKSNcTZB5wDwh48eNUzXHVA9hctPSGTUzroJkwM9u//teTlFhcYtkDKqxy8Zals9lh2
w3AwPTxGuxyBx0bjNGarPIn3hWRgxiDPTf4HcVrGjMGPtmdM/gAghHdTsJXe15DlqWadazLrB03GJJqC
FfSe5tmPSIJ7GmJnRrs2nhV5VWO00plluyTIOmrmUZdbveA0PIIAzvPCKgKQmemzZdJEij8mFVWzACjm
tgA5tnNG7iwGRM/hLP4KuX4HywhsXXtPMBjJl/jgq89jlt2GFPrCwzterpIpv9fZ4JDDvlE5EUXG9y2f
/4S8JLhIS8mkUcGn75IK2OqKafV0gv4jKyZyVfrmgDiAGVh4WwmFU6ziybcU9WE4+oyCNhkGUjjS++SX
k08WJ5/Eg09+7iGxRoIFwZ1vRwVuXkQFBQwICE7mtxT3ROVtgkE4VYjyYsxGQ5xYmYCzVA8iYhizZ/SU
8hn0nJ4NxWT/tXhAiLiag+dHJqgyIBuneZpGRYXWyk8Utqwut2P62ArjLFRgKmHUY7fFZDWiPc0jSk/Q
kvwQZZAHoBNHAvjBHRso3ege6dOw/sqJhc9bkagXpRD8/wZhSp2XW9CAZYFBuRil11M0+hLKDvSI+cey
40CIQWkNcCRKc6BM8kHhtBK8x7JLGukDSBUgbg/fj/psYmcRUgkiDGlAPmA+OBZ/wDj7E2xTknFqWYZH
+cnkpOSnrJ5wERW+KDIqg72SzmxnpbJA6b5BAOIMmUTlnKO2w7iz4ZCdSNqO27KBqKC0SDJfN/bZ87Ng
H2C0sQFHZxbpanX7WgE7RNnfLbaO5SaF3VuYB7EnDS5N1SAd2AMH+wYC/D+TGGiKmDxc44NdHljLXg2o
UaElME9kMsywzTtUAsuYVfgsUquwhJyF+9cQfBD2G4vc5utNItUWKIYRPPky4hEofIFZteWw0piqi3l5
dtrGF0W99V2BS8wUsOhMSaKKioJnse8BmKfbwGj5HnEJG1bJwO0VshfdQvZNjE18NQigQuuOhSh6wJoz
ldhs2UIC3veaCuAFapIknz0UphD4YdXc2zAUIavTAf59GB9Doqr1z1AUog/jfBHBBrgWuECeuB2EBoNb
iy3LrPadhInD18IEAdi0A8z4smlIpaNz3Kvwv29IwYa6lxTAfAgpVahyqdlamfJbTrHtvcoTJ6t9SwFr
IPB4dvUNCP+m0YsPB1BSKULMH4irOeLHK3NUQPVh8jUfiBjtJ87J6JecrBduQkd/SFkSUc6QTRgz+rR9
LTamc5ElNHRVADTrVdJuW6US4fCF84cgIFsuJrzUXoqQSxa/BuJeCGZT83gUgiONBArhK5S4NAAln75+
VAxivGawuKvYqXO4tLhl4hCyonpZoRK5wzf7hoot5Rt1jMVKBm0cGDIktm9o9Gs7tA9AmTGHEQlytJ8f
XccFY7+fXYnHMI1ZySJfVnyRr3iIAtBPv232QG3tE0wr0T+y1VnoqlhXE1s0SU/TZHrnoOuz3y2MlH/j
1vAKjOHoeAONHS3k7wqnE1Z6t2W+pBIpBZh1qUsIjfAzbnUfiDsDzdI98WWsZ6pqHTrABM1NtavDZl5f
daQ9at7ol5/4vb9hup9YaGVMaEkJz1WzKk+Rq1vfy3LUQZAktwa5ZRibO8izPKwTg0rm8dYLwIOXENZf
5YXPw3w2AzZ9TEsKa2bWcrpBY3u3p9GEp8Ym0XZHE6YanO2tdzdqT9MPQtMgyqbzvERDTSbaAUDtHbpN
MbZ5g/CMLxrAMWqxF562e1z17rBryir4qIrhWWDvdmMQxAZoILJGx+dsv9AqXrgSE97ksMxsi/hRcxk5
UzEzaViu0b1iVzZsbcdhh02NkIROsKwu3znR2sCukBFOQuc0PsYSCO3XkDoFxjMeWV5b2Rxx1KTTeH8T
tNJBu+RFZ9SL+qcsqTHcvfZQZ+7EwST8+gf+usJfP+CvV96NfU6ewUiZ7sNUl2mtxA4x6HI2SzbqiLLP
8qK26gL4BNToz/v3IuGmM2g6XAWb/i0YH0CNrKMtSKrvo+/9LMCUWNzoYJW40CHwe061oRKFBRyIFEKw
llitzVQyRM+ATSJ/DHjVSOKafcW8IUP7Kp/H8Ow1WQG+HyfVtwlIjsOzxgGWW84mUgTx3F+Ti/A4fCQY
pjmTxBToLM3zUtwWQEsXBZAJ6icUsVjOiJ3IAUW+pva+PV4qP4EiTbXC16LjRh1QieldsGa/njqpiy7T
IJcR2Mlvkw2PfcohmZjSCzbigzO5ChLqHS2NXebJOCY+GUAPUcbg4sbiroAUHfYfM/+4DCwG7ErqLEnR
LHioePsuGZkDrHYdSigs7O/hEJI+1PU/d4I/t3So6Ey2Nd97m+lhhE6fA6GXSImR3o3JIbPDZJP9d6g+
gOrkYVStwiDHOn0yxRop1VStQik9a+KqPXAK1o0K9oEqdrsW7T+xatBg/btKxU/khS9Q1SRKddGisxm2
p8SEWUlVb8GcSgfWwku6TYVr3Au21JuQqtbdgXYPI21qh3H06D6U1U2hymuVBPeKTa+NctdukijQJ/WS
rFjWmANlt3jeLaYatMfoGrWAQKfnApkavKS4e3SgyEwnx6Levk6yOF+jC0Ed/Zb03NZwCSAK6v+kz7IE
30fjJDZG4ybTx9aMP+8oGds3+DAasW/nCXzqGXwtLyNI30zTpFxWczqHwrYJnTtZPa9w+0E7hnPUyjOs
3r/EPuj4N9G4iDYG4yLJzEOGjjyF9XCvCH7cqTdFWW9iNPriSNRkBJqOuQ6oYU/F8YLCYpcMj8Xoud52
o7PhuQL8mHqgXQ5UAYXuWHe2bq0qnyjwYdISlabGpyqfKna6rzZogPYWArtrfsTO/jGidri1aocaDWqn
DG6Bneld5esaLyizEuUJOx0GFpQM8/QmMVygCEgDxBGAPPAXq6W12Dn09/AU0xuLUBKHW3OAHp3YTeDh
TnyOxdl25xh88gNXc2hHGBB6VLLZODVViqapH0sJ+JfHZnKoPHvLYB0l1HtqpI2o3oMA4RNrQUXFFmi6
6BvI/5JyKt1K47OqUazCJq8xu2maFD+AirhcJDGSx74mvJU9NcUh6zSagz31MntskdNx+YCuOFBhMUpT
FwSZGBSREOmyTP2/YYua6QHcjbLxg8S8r1r8EDJbSUbPH5nGJRB5a7Ni2Grdw7vQXjEGlrlzIcj9+15e
RNOk3ppEs516Wgnv8OAqdmm0pYAu4emyrES5QS6oZ20/Vbzaoniu8tvblFv2hfLOqz0b0a3uGnOa5lNd
B76yZGLAEERxN8M8EJkTxvHcMSNX4ibkIVwaroWQwgSvOZuHTkVWAJUMU/A1iBQ8wdzCOc3TvLS9Ul7G
SRalxi2RqL2/8eejaDQV7h4en332GZ98rh+fx9HseaQfv/j8OY+e6cfZ7LPZcKgfo0/PPj01Y2effT6a
zMxY+hGPliek6gL6+aHbtHWa8jR2Yeb5ijLXh2wxgm0ofduEZHnGG0BxUhVptDW9LvkfEAfwQA+24R9P
kxIWxmUHV+msgeFHWOtOBG17CS42RUbWc0j6m5xIdWzjsSp9Wg3zrB7QLR10NqfFxkI2y6fLpvnfJ1WC
faBUiQAN0GjRQ9txC27z/+Yl3tGfRWkl6sa63GNZAV2xsoc81g8yNiijddP/Y9t3aqv9FtbzEoInwOfr
6BMCzq6rsVm0oJN4tfOcUiIe17jVRBHm4Ec8Z2gczYXfAzJTnCTUeyqOB87RFFkHySapNY6Synv2ye8m
adX2xNZTB5to+qiC512Jd4TEew50I36TBPaBHWJKIJATnVgnwqqGAYC48TKha4Di6Fz5RgcCBWGKdNDw
DZos82aBBfqzKe7B0y9ODC5mL6fN8QytXRUWvfK8A+3IBF+Wqf04vKRV0rf7RJkNQL4Ey0mdzWshAEIY
nF7IJUa6Zm8R445NpwrqudVd1BrRNWC9sZkoaoskV+FHUtPlvaK+tnX2xpwdcLGEQs0wFNHrKAs8MHR0
Y86qJB+m7osAwxv2d1rRJhja5K0G28OCAI1VVbH6AzRN9R3puiHSHEjj36er9l0wWwWzRRgFEThnSkjr
hVI5+9zGaCGAnNvNP1Pbxmn7hdq2ThsJ8YI1pUkydAC/kd6WvK6UfvuoSv7VlX/lwnHQvsNRF6O2G2Tp
HdtwKAPAGevQH6dq32gwrkx7COFq1LxsOHQ0kqx4JUAIqTGjbgS0/aofZVZOTH0pDcSJzPIlzEvKagXQ
LwBk8s9uVky8qvB/xQZnbAz+1oGg42OFHUA+B5DR2aGDMIOPjsSwaCxqLNacsjwWya7ywBT0YattfycT
eoktxgS4fvky3/i2XDEQaE1mMglxk4zak4CebbvHnH5PQp2MnHYfHgGIss2ntpegt0BwU4o23GAbtUx6
c5lQTOq0cO3qpoRw7e50RkBz02g7bbdtR+3zru1pI0sUbyDg+2n1O3Fz2zrCottvpk9uQjMCL2g/dkCM
zajoFSAQLG4UDX7u9vqm8xJfAKO99Mje4Cbypz1SOadgEARKu+rejMR4oXEhkopOeKLReL1FViw7sPjt
V1HXzn22nSrB9qkqLxrX4SQRuaEMC/3WpVLneH3XuK8pxum47OB9Oqr5KYAX+uXMo64Llx9x704GOHtu
11FBzb1DZ7h6LMMhxY9OTNQ+Gdm8UYTcfTNOV6eqzgNbmxVRa1M28FPlcLui11YGJGIYEWGIz+AoWvEm
vmEEXoMk5q6avGW7at+vVfqWVF+XZbTF94bfv2crFexcHF41pQ2GfU1SzMsmZWLlAxgP1InbhWJlkVpn
3e5JdyElZx1unzfWnSIhu3ErGrXvNwmFr9gIHB3Rk6N7uL6o7qtbAo3rR+JcYSO5wut7OO5SZhFdt/yQ
ER0QHGlwSUsS+r19zykOC6x84nhQOqRJ0R6usbK8zYsnaNHDrd/JhwwI42slgxsrTqGBm+6BGzXQijed
i8kbccsS7wbIOYo7lG6CdeiupRRf1+3HqdwZ+F+Sd69YPogKXbP8GCrWZfzHuLW1csp9LueulW1nmzd5
+1TCWBLbLkhcf62cRnoGNiFbVf8iUWkFatOTr1r7RHdA88S0Ux73CDGK1/ClGOUAx2aTdAYXhOxctgC6
Y7sFMelagsZGrTj6S8v0HUlpSx7Um9UCFvC+cGGjjQ1rsUXyNKqOWPskYEtHjEn+nlJfKXIUg6YhceB2
0kdjANC0pPtQRZs2Kr0iFsZo48jU0cito5HGbuszH3Qe4qhH0xK2ZSgPpvxhEDT97L9yA9cZv33Y+G1j
/P5rcz2qyPT6rLelm3g9t1fnZAhR5jX628EXw6ABtoXuQatKrno32Mt8kwMFbn+Mw3sjvug5d+N+C5dZ
8off8EHNd0Hw6g1stCD8HRJAv3fOenah54+l+nYbOpRwbx7aQf4H173uORLsOBM8ksw0biybcllhjqO0
cPCOVn7HH5xcN0breps92Vaa+yF5u3OA2TjB/H8wQ3vnaW721xUliK2OXryPFTqSFR7A4qSjepEt0/TA
FuWgGiLHjMqHv1Qi431f+Fp9i9u4WfpeIFMVsW+NkuWRB2q2naAmXfowe6PjqmjnOZl1a5NOKNzES1YG
Os4iJvhNGvq7MHZtZOLt0gfhsurzXahwte27pAelw0KRFnuNcpBWUTwxmjV7cRcNzBmkF45Oz1oY5lHB
ByXsAk53LvGUuYRJvIpvTRl8T+S0N0rf6VTKKgY49WfTRxdpOnuwBuB06cxDXhzw7a+4EmOwAo2dUl76
mzYMGxhbgeripTrRam7emjJGC2bkwlyKGMj5siLxDR8GXn4xjdMMpILgHuFZzt26U0QvkN5XZpFfoaVv
LnUWbCwgMdVmOabr2v9Op5yUTcHE8eUG/AqZk7dvTy4vB/R9XmOweO5KKTG6BwbOC8Tg0OSbe/KbaRC7
yXHt957/NwAA///RKmHJoE4AAA==
`,
},
"/js/errors.ts": {
local: "web/static/js/errors.ts",
size: 2177,
modtime: 0,
compressed: `
H4sIAAAJbogA/6RVbWvbOhT+nPwKYcqNTVL3fnbIvdybdizQjrHsyyilqI4cm8pSkORspeS/75wjy7HT
doWthVo6L895dN5aKSdMwXPBVlfGaLPO9U4w8cMJtbFs9b+2jfKy5/FIoIXNGFdP8/aWMetMpbZwl5pv
4JSxB62l4ApETjsuryslwClO2OIfppr6QRhQWSFF7sSm0/aVeSnyRxBCCIpGrntdbVAnq4FuxsReKJe9
MBPc/CdlCNwXr9vYJzrTSAF0EFwCq8yDQ5gAHZ56GI8fMDFLrZzRUgpj07w7xxPK5NIZOZmx28mZxfzB
cXJWOrejg9Q5d5VWdDG6cagvGpWjMPYeWb8kM0bOGVPbdPURTmth9lWO8oDlddft7agneFLSKV19wU+r
T7CuPl7aFpAtmDONADFGTLfCxZMLvqsufPknyXg0Sm2T58LaON5wxyk5gDMKSN4SgG7v5ii+92Zpoc0V
z8sYizdTvBZQdfLDZko/gQB8UD7vhOumBtnfPUGpv6uWo5feI1xKubK9GFjDDr/Dmi4YKtKlbpTzKrp/
qIx1XytiUOsaOiptXB4PdUnP4Zq/aR9U3vzgP4PUpLvGlkg7oSeQCf3x+rhrBZ/e5zFj7AQD4kb0ZlYI
l5dYODTOWMSmdJqP0cejFpXiUj7FOGbPw3IvCi6tQDP8bXU0ZBCBCuUHrCsy3VLr9O6z0Tu+pXaL8SGH
eQ/iOPuI03kb4Rqj2DAbUqitK08RBitiALLnhrnQFvfxAGzYZehCHVAV9JiUVovYJL4t3HTqCxDy39Jz
HRcMBSOw9G4vWDyKp2Of/wkTBOq6gkYheY0YmiG3QI32GbJCRcfMT+5O25PRnZH/LwfY7wgjsDuoqL/f
l0vkhn151f7feNmZh0HP+Y0dcox8SBbfRtC80V0yf8Uh7PK3KnOsnX+NR6Q0nMCF9Y9IOMaztmgdYmOQ
W3QBq76otv9y2PVugW8KFZu3hoXR9SV3764SBIR9FP0VHAgtXLB7au7i6Bv8nN/cnF9eRvSEgRtive5W
llldR0kYF/0Go/6y6pC9NeH64/tknO6onLgcibRNDD6U+wOU9GcAAAD//5urOD+BCAAA
`,
},
"/js/expr.ts": {
local: "web/static/js/expr.ts",
size: 2341,
modtime: 0,
compressed: `
H4sIAAAJbogA/4RVXW/bNhe+tn8F3yCIqEZQHLwYMNhweuEWW7APYOm2myAoaJmWhCqkSlJujFT/fecc
UhI9o+tFYvJ8POfr4VGtnDR7UUh2//6lNR8K3UomX5xUO8setHZe8jqfSVAvmXWmVuUKrsbo+G46peAU
S6TtGrdkQh3h9rmTppZ2uHrlR3dsZeRiJdjzlK3v2EHXO5A4sY30pRFtNUDYQ/mxM02k3gkXo7n6Ob5+
ksed/qIgwKU8SOUzi2MJVT8Tgs8gRHG6PZH08/lW205ttHJGN400Ni/GM0+wjRtnmiRjj8mlxfbBMbms
nGvp0OhCuForuhjdOdTvO1WgkHuPZTSOjJHvkqkyv/8ZTh+kOdQFygcor/s13CY9oZOSTvn9A/4EfYpT
nc8OwjArhSkqtp4Qcy/i6cpbFJ0x1LOpu+aIALOgAWfh9JZ7vxzZgr79fAaAgM19vMg8Sby+3jP+vyD2
NmdZJAgHXdo6LXgiDiX/zC/gZ2lwXhoG0HavlbZu/YZm86a/yNjFD8/4/yJN2R37cZGkmA8Qz3VG+ci+
1znSBvIJmdPt61efXrBAJk0WdPuXBSYIFqGM1XxUhHcR60ZUsY1A4YKY/mHYCDrQkkZBTMhbqJQnN6Kt
bzDu24RdQ2UJZr6GM5Oq0Dv518P9Rj+3WkFQHpWaeusrLOM75miSZsNswCu3XVFIazkHJEGPAgc2FkvJ
Q1GozR98KavIIGyBweIPf12dQdBiGKz+hDOZIFNGCVsDhSz5J542I0bYDMgx3yTaGzdYKzFoJNs1S9D4
rdJfqBO/CVfl+0Zrw99Bp3KQw8u/YbeLxYLYM4YgRAjg9KYSxvG4YG/Zx0WNJCDOzHrqJa1QzunnrJUk
BQf6XX0Xa18r0TRHzs+AcIERd8ByIhVsWkCYrP/7yUUk96/o3ByZBebxkwI6q65pvuGA3Jochjc1OfiN
ZWSjxY7y7+FvWJNj3034pHgG4KaavhFQ4OMTYglVdo0w+V6b9wJig1MGTMpYvXuZ+oXOOMZT3zPnXf63
aDrYrvwgmozBuEeEGbGg7WzFH68dxACLp8CG9JTBjVSlq5DDi4G842YK3MF8lKDFk7wm38jlJ2hTC7k4
UR4gGVF+itLBaIgwRLtjt0OwGSFfA3TmoX3MUYxI+DzoWSB4XMXo23tf/wkJD9vjv6NGYqkZ3X8X+C1G
R7r35EejeoQhPNEeHFZBHy1qP86TdR2+4+AyfTTjDzomgJV7YW6reu9+kUd2dcWCCBA2sPGw+7f/T09f
i3ThsRDh5j3O758AAAD///guZLQlCQAA
`,
},
"/js/graph.ts": {
local: "web/static/js/graph.ts",
size: 10811,
modtime: 0,
compressed: `
H4sIAAAJbogA/7Q6f3PbNrJ/K58C0cuY5FiWnE7f+8OK4slL0zZ356Sx3czcuL4MREISY/4yCcpWW3/3
210ABEBJrnvTy0xMYLG7WCwW+wNQnPGmYZd8eSEk++3Z4Ery5c0Ja2SdFstr05g+e3j2rEP9vB/x6tpB
PedSfKxkWhYNUsRlW0hRn7B5WWaCF9MOdMbvT1jR5nNRA7AWjZCfedYKC+x4fmpFvUFufLmsxZLLsrZC
DnIBrdgB1CCCO2FtRTpx5YMhWA/AlCY6Vl8UlBcbACXlXdHwvMqEM0PSeB2Z5t6oqNM1l+naBcYwoazb
GGQPb0+Je4RLGshV2oztwtiM3bKDA3brwn7/nQVNmwdTg68Etbi6j3gWCddtUagHCAueNcLDMdvloRog
UBTirqe2QbpgISE/vx3b5aoFDSYTNufxDYvLvGphUovAFnWZs1tEQg7POxE0pZLJwZ+xYMnbpaBFDR6Y
ANkZkvaFH2ureoSRxvBY7UVG1hrzmY+9jay15sBwH3grS+LwYHSdOCpOmt5mKStyEajvI6FhWhTq6f3p
TFghwmH6rgkjr9+JR3CQSiPRsjqd6nlhAt2N3GV3hwGkcNEPWXAUwF8Nm+7UmUscGNVoORzhiGTNa5bz
ezPNjp0G/9G39MdMu2fESjfNXSrjlVl5345jDvIPkc3wxNqJngvOMk01GMxrwW+mlkDL9yjNvkU9CemM
9JKr9e9As74U0F7uFpJO1Q4ROxU6JLRL1sGL21Y0FDcayWvp+DhRJE4P0OpUgKck941BwnOCjvcjPmgU
L1dHfFlae9csYIjIQZCqbgtjIwvwjCEaSgoIx1P4vGIu2TgTxVKuYODwUG8pL5ZtxusxkL7j8Sp00a/S
6xHwG7GbiM1ea9eA7G9TctfGFi260lNnRJtKlAu2Ni5Ia1rpQ6ta+z2LM4BokQlQ/W16daMZKpfh75rh
pqPaX8WunH8VsfS4fSTQ+EZsmnAdaR2yGWj4z89CoIfINSJU6LLm1epcLMBQVzrOPkvRshc8Fuz9Dzh8
EZeVYOJeglE1rFiO3ysIiJAWiXBzh7bOXCOsay89AIMpoOVA7njdg6jw2bgJDaYGa5UbfDZ9N1VoylqK
BFOFG4eOMNFANg53G8j9GfDIfSlNYuIMJM0+kh+EBAn+/v+bM530hJ4yyHDXZZoA6iclRejCgLZ503wC
nqHsFkMInbBn/Eb8xGueA06X6o3Y2jR9bCXP58ZFdieEHW4zaXKpziO4a+1GGz1ocTdfKtd7PO5u3iTJ
JZ/3FgyO8L1SUJjuUhIGaUzmnGTRmKUFXdABv4Q41/TYJy3sIWzfl5xXRnBepDkloApTr02WlQ+JefEG
Jj9hvz0oA+S6ufmS8TmETk9LeVo4Bp97qTNp6tJPQYuyznmW/urmwXD45mXTFm/LQtZllokaI4pphwEd
u7eyzoIRuwpeNHjcoBm8WElZUSMrY1oudeoScjtqYQYAHWgv2iJGhFBRn7hnecSI0Qmd5R+hdSHqdRoj
3PBVY//QPTtOU9Egtcbvz/Fjx7UAivxSdfQo+SwljZNQU0QZQkY9HLEh6JY+/B4/fL3ETyLW+Pk1zTus
3CCmBeLitmjG3nkl1oj3l7F3/QRxR6tFVBXERzblGOl0xSHWdgZ0ZF3ofhvBawhYM6v4sQJRUoQYX2FQ
gcZfmxLPAEYGDZn/37cqEiAWLHnuDqgojTxqnSfMgNsp+9vFxw/jiteNCL9G7ESlYwrDykq+DAgI730h
QyvgijcgXoTp7rElIB9tsgMNcx1zb0j7FAPtJwNaYhPgIRm4HbG0SwZ8JhD+dVZJDiq8paVHjhw6qTFc
qW+HwXk5g9CzQ8op2S3Q/eeQIFF6FjimobyVxe0AgIyZpIPb+QSL7YAcfGevwRgjd/HQB+pDO6r226Xg
9z4FJauHdtRayJb3RCMFymEzPIHjMxxhO8d2rtorbK9UO8F2otp32L5T7QLbZ6q9wfYG28b00+ZcZDDN
5F/hL8lhFP5yF2HG+WIC48Z5gV1ml+WbeRNCDDwXy3f31bt7Eb+pa65L9lrIti5YXuYCjDQatzKGv007
lzWPZUjm+31WchnmVy+vo5G30qv86pvr6witDuKEqcW6yWHeyxIkCBsbT3HOyeRDKQkSSzogMMIg3ZQr
wagEU/zG7HvIisU91Vkj9rWFEzj85vjlt0N2l2YZmwu2hh1PdImFBqqWQYsAm9e9RCw4RO7viSkIC3X7
h/JOVU16+bIn+cUdr9D59iWnFNWUkbtV5+iCckaq/kA02q6xAO2HDQ0ir9xnZXerI9cjVpVaydoknXiO
FY+JWZ7ZmtPbLcqF00TeOe6jAdSfU2Une6czns/3MaaA2XI+46oFd9g5H5rK8Tw66XFnc7KfHdOmPoNe
lunx8dNNhxf54isaN54RU8Op2U7Dqu9GiUBfYJktfq66eqP9SHalxq7dUlltuNl+yjPGSyHDYMKrdIKh
YIK3E5orUsBpjWPRNGG3soRjCmZyrsit//ZJPe1Q9MWMfxMzGJiLuS96nELwYHflivPvqFgVf7QxROiK
Tp/1VeKpQ9/P0QWRLdosohqBtsZ+sETP9cguMnVnY/FN8h8mECZRIZFT9W1FVzUpVtg8gxpbbJwqm6YG
eG9WQMJ5YcCb+CEy2tVqxY8CTSYMCxjWtLVgqxKcX9ownt3xTUOecpHWAAP8MaHvSBmsBbuFMGly+gc0
BAtDPmLz/to4BVgUKLBr1G7q6KVZnb3enD+C/9LfBQ0F24FcKRNvyxyigwjnZjPU90FZPRXH1uapayYw
rgthuNs/F3yeQXAp2ULgBUdXJONRIqypLe/7Zw4LGjTYiaY6Vd/ZvmOIuP6ti01caezgQJ0QvMPzNmLb
LWjI9rrhr52jt1z42uU86Cxopzt27kI8525C+Q5VgGABCvJEr2NSJ6U6rQHybsTkkU38z/YQ1+wE8u5c
O/X/Lr+/7WbX5GZv8DqYWo/5+j/lhmnr6Xj5p9ANOlc3146q/tsW72Y+oANdy4QmQTS1j1/nDLxiwIYV
UxsMnHrAjqriYMuh+sp1iu9Kr4/8eTX2YqkTKpUDMQHOVjKVUrET1pSjJWjnc3uhbutilXx9J5K6VVUS
kK/H89xBNFe1getp/+pw0CvMVPZzGxnT7Xxg3SnaJl7q7XAr76IKFcDu1j1FyVQSUqzrPIlJVr2IPO02
IN+n+b0BEiLOCFXvBBHKe/H11QZmh50OBfpStrY31Oq8kW6R1vHXWm9jfZ9OLrx/GxBAQR9AMJMlD6l+
V6cyXWzCOor20KhiFcj8YvaUtSDMIi1EAtW/rmP3sNA1rOVhitpTXaMCh47bHh5dZWu52GJ3Lx/aSipx
zeakzQdyeaEtgCOgt72xLC9ILSFda7RZ1jGiyncvI6yTLSN+v5vR9spgTlgTyrFnnN/jOFfZmLo7Aw1C
OZqYCGXdU8/8yWD7p01FPbfytSV8d1XR3+3gQDUp4L8Ig/+JV+Digmh8lyZyRUukdNL1oaragL889N/0
d8ebx1IMUcRlIn4+f4/pUFlgrandoB92KNxEW0kBsnYSit0xxcSSjhhft8pMQCK2DIfvKKiAtBILdSMr
VummFBr6qRDy7gWVsCjPzeuFvsbVqtA3npj8xFDgug8qXZ38vKP2kwP9IIIBT48Hbt2N+6YfA1XC7+ik
K2FgGf36ZbfZuKUMCtXDgnrGe0uf6Xdz4+U6YQ5n2qSwR1ucWk/q286OKbSaveuFpxzz4AAa+wxqpw/o
DPvpLgAm4fd/NInnH+wk5tipN4cw6l8VXKrfFChkV/+YYODPN5wbFmcoimxo610ROVh7Loumjq15Qhwk
Zu+kufEJ/gn/js7Ojr77LthDSDuP9t6j/PHHkzwPon1FPx2JUyTBMLZPvTtjm1ohRDig0Q7t0B6LQzKd
Q/KwT/El6glMe5HxBdnktAvqzz2sLrhrqH6pROV9KCGPRJxGV+HeL1h2EARuauBoVb2nkzCfWkeabe8Q
THdmyYG99mi9RwQ+b36uM5Oh41iLl6Kg2fB4BG1KRz4uwuA0IN3C16DiJpttsq8Jf6R/T762xovd9gl+
ervy04n9Xh1ofpAo8CzbhOE2M3zgMyt3KkeduXT76jpq1J3244YjOX1MTaIpexix/z0+PjZlvF+cIh7l
UAB4uMbyjZ723lTVOElrEdMvaQLZ/FRWLb7ddRLrTFnFcnWbDL7kXYD35frNjkSlN/VgRvAH/CNFXmX0
rhm8mrdSQoSi34PMhnNZQI5YHGkvMCTbOlrJPJsNcS0aANSxQHcBFCXQ58PXArxh8mqi2L2mubK0gKoz
1KLwAjJhyGpz3eRS1o3+7ZybfmuBZphpqHag6JT21F68uONQ1IXEA60FtEKr9LipQwnwR/Js8orinn6x
8iotqlYy/O0HrBaAQ1YWb7M0voGu+uVVBtsBpjGECMmTssg2s6FpDfFuqwXKg0xOOVuBucwObttSTvEg
oEXDKVGAgyX8B6w0X7KmjnegjatiOYP/Pv6EY2v4Wh81pZ1xVVblGiKRXiM+A8POnNCyRmqpkVstqCcU
6Pw7AAD//1xpEtY7KgAA
`,
},
"/js/history.ts": {
local: "web/static/js/history.ts",
size: 1452,
modtime: 0,
compressed: `
H4sIAAAJbogA/2RUXWvjOhB9dn7FXChXMjco976mt126pUsD+wHt9qmEojqTWI0tGUkOG0r++44+nLjZ
F1senTln5ngkpT3atawQFvfKeWP3j5XpEPCXR71ysPhsXK9T7H1SyO0cnLdKby7po0HrX+qUNgep9xRE
a409gQ6TyWtguOk6sVIWK692yJl3NyE5S7Ip8BKuroOCRd9bHVaFx7ZrpMcn28yBzTppvZKNm0XdLCtq
3zZsOikOpFVeZrVbo701DeGcqI5rzrLerbeUA8/swoXGaMkuau+7uGhMJb0yOn5Y0/uwv+51FYI8Zcw/
ujWFmD4HvRGLe1o9ot2pKsQHtrT3NX+d9qNA3IwrsXgIr7xfBht20oJDaasark58IoU4tRwRW9y7+AsI
9E5eFGoNXOpN30grlLuxVu55yhGELSN1MQDWxt5JYjsBRi3vErYIEs+7JQl42yNJFMHw4gDYuDgcCXHi
GEEPqUr6hbJ1FP7x+kajEECOh0cpWtlxvostpFGAPAlMbq8Y/AOoK7PCp4fFrWk7o1F7quwSDqV4M0pz
9jcL1cQfITboOZvJTs2cl753nwJBEi+pTuH6qkLnOF9JL4fJK7LVDVWGq5c4ZR89/dOwkD+2agpym+2K
f+CvaIncLodgnu9IFlwJqiLPUvKgHntQi5+qRdJvTUsdi95XPMVi64nmvKgj4aiyxDoFRbPWt69ojwWF
MhXZ8x/8D6dSGtQbXx9BRS3u9CrXckQ9x7xlrCeVMp6G87RRC+WATjbkzzPrg23B+QS9H66ZU40Wd3TA
kZfTRBNZMlnoajxkZ9xlbhCu4d+hyXS0xYdbjfTPMpPIuMucFy8+wrPvBr5JX9V0/0G85Rx8Mb1esZQa
z00YwpjA6XmcvzMmeg+n7LCkx+8AAAD//8TExoGsBQAA
`,
},
"/js/host.ts": {
local: "web/static/js/host.ts",
size: 4613,
modtime: 0,
compressed: `
H4sIAAAJbogA/7xX32/bNhB+dv4K1igqqXXpZk+DA7cP7YBmaNouaffiGQEj0bZWiVL4w41R+3/fHUnJ
VGIbyZbuJRHvjseP991H0rnQXM5Yysnp+0rpi7SqOeE3motMETGnp87y46iX1mZEmFidHPUWEDkiSstc
zGGo85KHQ3YVjEoOX6lqLJMp2opcfBuRuGysCRm/Juf82nClwa+4/oJJbgUsqzwDb54xzRooMxWOSl4G
n5e60qwYEWHKKy7BxqWsZIBNGiHgK7DM8gLqcdbF7HbBgoU2R0dXlTLibSW0rIqCS0XT9juOsJRvtSyi
AZlETxWWED6jpwuta/tRVCnTeSXsQFZGo39mRIrG2M0YBZQMiJ07spS8h68LLpd5ivYmlfN98KOt32a3
TvtFT8/xn/cnyOySSaI4k+mCjLf5qDPFCWzfAaLIO4Q4hx1tfdgEWx+OAh+7ClwwWK9JX2mmVX8b5JiE
ONsi3ui7p7Ei0tRIyYX+ev6hg9bIIoRqWwwCbrUQ7NYmkeAS/HvTc3amdVx7xx+Gy5UzX3sU4CndWLM5
QvpBIqxBNCJhfTYYIynklTlXtDZqEV/bRJJrIwXBTtxskbpmh3Qt/XoLGfHeYSSCEkK7aJu0U2LdpMZm
oXOu42jI6nzoNjBEfMOIvAjxJpCDKpOmXKm4heB6vZGsw3GXE0sYcGm56W0SzxAwK7FPyqoEouKEGp3C
X2WutGSpjmsmFX9nJAua3XZMghkaDKQbtuwWBdepmQaxClhpGP+VvUjibL1ai/ViXa5V8pLNq2HDagkx
PpryG57Gy5AQh5NmzVJ24VNAXk6Op8mAlJNfplTyuoBjMo6sZs+iBAq32Vlpe1AMwfQG+uTbGIv8DL6W
Y6w8F2mV8a/np2+rsq4E1icko8OGZaFt26D8zCvlkrrzygYG50dujynP2q1dIhc5/YLVJq8dVVgKx96W
Q2Z0lSHH0TP3OT5+9SpqJFiby10Ksnba0B8Q2/q8KlDPsNpWaBapa6wRiSo4TWsTDdCYwYQl8LKEMyxK
K4P3lfOgCkcgQncbdSQ4sFs56k13aGEuWb14g1xEf6tK7GPl94tPH6nruHy2ii38JIFYV45DROUzEj9B
E72wu+0S4aptt7YNmbya0o/MnqDRZy5TQEC+Kp5FJwHzgMGLzs/qMIYX3i5SrH0PKc7XOaq6nDSU9IES
CKb2Ru1jeQ9Xf5Mk/ya9gS3fO/vjEGsx/kRij1ti+0ho/6QjZf9GAe8Z0wtashvK6rpYxcIUxYDc6pB3
OCxZDbi8whEZ8QLPYK0T4moTLoFi6yLqHteC68urleZqZ/sE3j1NFEbcS9/INkyidpKluwcnL+hbS8Pb
4acazzLbBV72PgD2C3fmn6wwMOXYiX1/wwxIjs9bWPV5HwqaS5661xKMf8ZBEVTjP3bVnbZCsnRZN48h
Z7C7u2iq/sO+PnpMzE3BJJ1V8jcGL4Yge3BNKG/Is5t2TWeznWafbO3I9129o/EmWQ3dCcWtobfIc/Kr
bcMTlxB359N8AY5oywAZgyTgKdpv1+6Rx1j95XG4/GaL4klQKrpg6tN38VlCm0i96iC0YUmAKpg3uRM4
RTqcddqsSXih+H3nu3PR2RvUPeTZOQ5P7mxz01F+7h8JkKkj99lunc/2CNx77i3sLFff4C1PVQ34Lrf3
xSGF4hwrSK/HwUOWaO+Mh6zwmIqf/V9Sn6lH07l/puuuyiah4gou5noBasJrpZ1Ug2LwLnP3WKjuM/8j
aby3DdrdNkmc2WXqiqaJMO2V6ZVsK9gU4pCKEcBWxG3tJrdjduj3QPAEgeEULN4u4Afm7hL6w5YKjoX9
85KgXN0Tof2FHRwJG4z/JwAA//+2ytQzBRIAAA==
`,
},
"/js/incident.ts": {
local: "web/static/js/incident.ts",
size: 684,
modtime: 0,
compressed: `
H4sIAAAJbogA/1xST+vbMAw9J59C+/GDOKy494RsjDJYYKf1OHbwHLU1pHYm22Vl9LvPf+K29NLo6T3p
SXKVdkgHIRHGUUs1oXZ7aRYE/OtQTxb0kY8586+ukMhQB9aR0se+rtRa0oHQ14DxEoAtSEinjC7wVte/
jfV6Z7QjM89Ilst7zJpiv3M0Nxv42bzbaBvC5v3k3JKC2UgRmyZAxrvIH7xOTixXdC+rbCDVd2mVbyHa
I12UjPnSLnPfV/Tgk0MiU8THH/Gz8m28yEUQWBQkTzA8+vGcYm2fFWoKbM5xNcXDHYB9UFNqUeWxeTpu
0L2dvXVg/bLMVygXji2EhT8e6QqLIHHG8HBvoZrQedJ1daurtCc/omPNVixqW4rtNj/MZzUNzcdgG8q4
9VKitYxNwokWhk9pljLM3XeAyPNy0f5Jk5sWxdeEnvn1/YvgS4ZRcUsTpIVZ+H01L5cI36wO/55fbf8/
AAD//+ZmeN+sAgAA
`,
},
"/js/items.ts": {
local: "web/static/js/items.ts",
size: 649,
modtime: 0,
compressed: `
H4sIAAAJbogA/6ySMY/yMAyG5/RXeEBK0YfKDkLfwALDTegmxBCCWyKFBMUuOunU/35pgkorttMtrfvG
fuvHjnGMoVYaYb9nvNFB+zsCfjG6C4Frqn1WvgtxQw5G0woovl1zPK0LcfXEU6U2Njp+THMHfTfOjyqx
4nYkdEVx9tS6rXccvLUYqNJDXMrU45aDlQs4yhn1vcVQzq7M9xjUrdNsvCvz0WpMtYCUtUpUuxgdMDyM
xnkPl46qBrmUS3U3ywwr54UQFbVaI1E5mF8Uqxd0qhci/7F6Tgk20GdFRNElEwzBh5dF+pxW5lnEQvnp
1NkisIcaWV9hmLyEf5Aqs+/6vW9WzWPZb+U/Gadxc8FatZZ/AZJW+6cYz8vyBtGd4uMnAAD//7YfpieJ
AgAA
`,
},
"/js/jquery-ui.js": {
local: "web/static/js/jquery-ui.js",
size: 31450,
modtime: 0,
compressed: `
H4sIAAAJbogA/8x9a3PbRpbo9/kVJO6UAoRNioozsxMwEMuxnR3XxrFv7GzuFodxwSQodoYCOABoWUPy
v9/z6G50N0BKzu5U7RcR6HefPu9zGrr8st/77f/usvK+9/PL3rD38Wp0dTX6Gp6+Gl/9aTj+enj15z98
2VvX9Ta+vPztH9hyJ0eL4hZKX+aLzW6ZVXFvUZTZ6LdK9O7k8iar6fG22FVcWGaV/Gf6YYNv0O1Zsb0v
5c26pjn09N8Xu3yZ1rLIe2m+7BX1Oith3Lwu5YddXZTVpPeDXGR5lS17r16+6315+Yc/hKtdvsAuYRbt
A/0SJEl9v82KVW+ZrWSeXVzw7yi9XU75MZwFvJdgLrIozkJeRHSMnCH1c68Oa1FF+49p2ctFKgpRJvUo
L5bZj+ltNqqLH4q7rHyWVlkYTcqs3pV5kJZZCitJymmYQ+MtvOf1j9BFpEk+yqGfqEfrMltdXKQXF8Ft
usXW+YlRp2GRZGEgb29mAFVonHzxf4JBOgi+mAfRbDwX/X5xcSHDIori/lUUh5e/hjLf7upDlW2yRX2o
s081LukAwKyL/FB8+A2Koz9ejuqsqsMymvbr0VJWeEzLOFBL5xUeDlVcRTh8HR0NTPBtz5vtZaPs07Yc
reSmzspq9FFWEsaBBhcXffxR26/CaJQul9+li7/DE7duAK5HC9ZyuczwGJNstKiqsF7LSgQ0qNzI+j6A
cxptsvymXh+z0U4m+Odw2B8FrqPO8mWIJWL/ERYDI8cBY3Ug/p7dPwP4xvvvnj77j7dvnj57Ef9FPHv9
6tXT+OovfxHPX/zw4t2L+Os/i+evf/kx/nosXvz4PH7yJ/h59+Kn+OqJePH22dM3L+Kv/k389fWrF/GT
P4sfXnz/Ln7yb+LN039/8Z66PfmaX35+Ez95It68+Onl6+fx1Tdj8dPLf/8rtP1G8MxPvhLvnn4XfyOw
4V+OxwiWv8r1DvbVoiw2mzcEuNgAqWYslAkChaATbItKEt5HokqC9ENVbHZ1huCTAlBvehmmQEAHHu/A
wI0uY6c4ugS0pCGbk2qfD85cAx5iQ43ovQqwt6qBchc4Ze2vadq/inNGMlVXwLGsNsVdEA28kuF9R9mn
IMLzzv4Rjg1xreSnbBn0YYdAPQoVpmnMKwNyGBV3eVY+Lxa7W9jM4bBUT9FR7HIJlP9yGXv7ypKx3lEL
I3sEmSxdrG1oUKFcHg6hekqCnRzK5TAY9AaDDBZ9PIaRKLNb2MvPHdOeG/zyVx7rb8uBplE1C9CUOoER
D/20rktgDcuAZoxsIkCqnAUxcLk98FYAENPpAhhBnb2pst2ymHaUhTa6+UCRuqjfz0Y4aihFjRNbSCok
skuvGbDQ2ZM5HMEKToMYTdweFFitFH1Z/Zj+COtPcWtSBHX6QebLDFEB+sPbh1Z3PMMq6eoCRMDjGZwN
c2Bp18kYQEnT5Qy3MPg2vQ6iUQHkU/4il/U6vIpGLCgOh4zPaBZQTSCCv2YoxAC29r4toVExHERqs0kc
IhfWQcthAiRXZd9virQOFcMTwRb4pMxvggGddHQ4jAUQWnii9YeiXGYlNx6oBVKnSKSne92m5Y3MrSkA
gYQ8kpRL1CjIRaaz4IdsVcOWf+Idx7PgXbGF9+8KECa3AII0ka7AEkWyl3mu4BgTZ2veBT0yAK06LhAN
/Lmueecqu59VcJxgySygoYKBnCcdaPyxkMveGBnVtLCajhbpZsNUFXfSoyY5BF0qlEyqo0Gw/UR0J3hu
Wo43t8iNZMt3tx+gvq8VFFqE6dMsAkb+nGWI/hgmMWvRkkSJWmBQ9mtiazg2C4L6MN9tNiB2pywKyuzj
a9ITYu9dy4YMWXNDOETmQTr8AKiRBpo/PTeldgugPV5W06jrvDo4BGAtMfNKM/7aAhwgNyhPG0JCCcqQ
VYfs2JsxQkiBPiuzpN+/vK1k1pv97W40H1wCU8wWYZ5+lDcpaJ8j0LrKpzcwq4vmnswmzhaf3UbDGDU2
GHVVTjvPnKUuVk2qrH4nbzPAGA8pQFrj1EB3wCUqtWfASgnnAzBIt9vNPQPIQM+Ag3pGQil/b0lfRK2p
JSCDImdtEsR9WQPx9LRcVdLjxSbDtzBYyo8g+QO7dRyQQbAEyRw8IGiRcYfZIICTGfqrCoSNvhnhJEz5
PFulu00daqGb5Sf3Ys+0y2mu7pkAfP98iSLEOVC5CpmHgPZRR/ZgpLZwjwAIeAItqZyxNFoVZUiqG4iE
PDGqSjTJVYuLixzeYVgN1QnNJsEo8PW80FXzDoegzDaggn0076wh4QsSWsX8/yWcTe6sMxJXICP6Wj5e
XOC2QBho3W6Sw+ysEgJsVemYOQzQzXazAwmS7IF1tKS/MpZIOZ/Vczipoi4Q0ycICbAfYPgoVUNUs3ye
2C+HwwykilUw2u4qkL4wNLygFoE43kwK1pQ/re5bz/EoUA5WJMUZSVFLbIyyi4urqz7aG521ZJS9g6VH
dIo5qIpa67zOJ/lgEGWjYovrqGYpLA96z0ExxaeruSI+MzTS5HHC6gqw7eRpWab3DXRG1QbMXBBli02W
5o9hizSUgD0TYFNYHHLxfgLrlLMUECyFBdbl/R7Vo/fEgXMRENlUgWIYzBJRs8yjEZjcNzcgVcEO3wCT
D7gS6GGR1sCaimh/BLWJ+YdZJWIEW//JCUxAs1msEzDTNmAmVFsw5YDyyHzVDKF2K67mAJ/NIACNGpRH
kGMVmDRo7v1CE7GqqzTcWe5y5i7pb6miOYrs2Wae4B+yHVN6BGwB1UU9JTZ6uZzjPXM8Xsg09GUSKJat
VjSIYOYRxXl21yuoyDJbC4CSsVrBjuYn8Z6wIzbNYLXAsN8v1nKzfAZIV5e7BbpI4tkcKLNMcGwpSo2T
iT4Zq7+pJCCixKlsPbaydFZZfa8rqmgarh3AaNnQZrCywWkk/24RBOfboY6c7gpWVYfwIAkplE38vtpt
s1Kbs/z2FEeYOOdH5QnA32uV5KJOqu7l2o0BE1tdU1GT9NFnzLCq9DucTdHsrHUqpdhzwQskzTdlBjw8
TqflqFV6OIBGdhRrsV80px8XAr1K1TZdZPFGcCf0JMW1evke2AIV5LCSdBqqg09HbUzybBrmVtaxTPTi
w2pkZgWJHQyqUTMzULwcMfLi5pfAAeus1zVfFMuOUub5RcNaRh9K/IVFQWFxFB4IHZK35S263EgnMmcp
rtBEGQOxaE4+Ka+LSQGsEjtKFE/prJhHVYI/MwnSCH5H67R6fZe/KQs49Po+ROlq1AE00GpomSDNvNmk
MmdtGcnGL8J2WNoiTKwA8os7qqC0cbvURx8qyQNnNnKxAJCIDSabnFPuVyQBHALan0Y5TZGvdABxzZqp
WlVxWoVFZ5Rmv0hWZiugSIKKmC9IdwG0XAMJog8znzq8J0dZdnERvEe/TzparNPyaR2OgSOBhgR1imRz
UYIRC01y62QkjiovLqSy5qdrQq23NXoi5QjxGGwFSdNq4gXqKEtAhSAvetVuse7dZvW6WPa+YL9rD9Ck
B3JpECind89sw+q7SPO8qHsINtW/6hW56rctJYxRF9ATFLt0I/9J/u8JVAdpXWe32zpbYr3VXU+Phl4c
lkbchKnPTzQ84LgFggdYBcjvsIwixce67QzviEC21UpUhCnKSeg8eo8LBhHHDwg6p5cg+QP2KTsWjjDh
+ojo+ounH0T7prSD/BNQAU11wzf3FmsL+DkQbc4ZBMBwyCpQZkkcfAt2yXUglOSL98bf3b8SLKljBNdR
OHI7dukK9I8QNGwCoTsBF5I7ngHMxdhegXy3k8ukGgxUPa72R809E+SeVN7sb2B6CWMZAVWCRA/ViGv0
k+ImmiLjXqMiJAUsJnNbu+uaWTQ34LNSIg222h87exB7VgJj1/oCyw4PlPywCiBwesV9SE4ILlHGDEJh
VNX3m2wqXfcssP6l8dRqSN3BTos7ZSaZelTLFcz/U2Z3+hSsWlbaf6HeGtHPqEF2vdo8NHhGp/+aixGs
GjCMFhrQ75WiDGRO5YEgYvOGIZwkH4hej6IaQDN/rhhNjWIrOnqbKoWo+hXH0i8K+rHvpH5vjsU5VG3+
diCj47vpQBen3va5dLWNbIQLo0dMyy7ttJSpNsuXxp30bJOqmJA3D9gJujFyUDDpMSyRWSO4RHRuHR5x
OVM3I1N94JPdicZUj04FfRr61O48LuMFBvisjoprxR1CXpBxldRo5qJr0zdGIqPKn8V/8li05H4dQWmB
VlvlGGekJVdruarR6aRn2rN9XKBS8cB00AS0ULBWdefh1XVKtmo+AzN6Pk/UL1lnuX4jtwpMvS22MPHV
me0aVy+qOFMkzRifJqTxyGO2qTL0rzxqCG/hPJpXOCl4YNfMyGrNRwpGFECAptDhpySAyYhHZaKXRd4Q
cORoD0W2IWOPFp82V/Uqs3lSi8BQBIZYUWl1yLMubm42jyKzQPT7yBv1EP8Keok01Nild4pMbEDbch1d
8+r1M7uOset7j+JsDxPpvcGHokAXiOXTJ38b+ilqoBHQKEVFKqqlBhgx7vIjdMCjz1p3t+VvnjiH1GW1
V2AUNdGn0trl4ZBqDDAxflAL+mMOz1NEAQwb/wQaxjlt84ViivZQXERKz0wtO1np0EfdycCmANiUoxvU
ggr753Ao1W9Gv8AEyEO2BkK/JafT5a/h7G938XD+ZfS36stw9GX0x8tIbJL17Go+SD32LXZQ/tV8spvm
IzQ6b1Bo78QGTANQNojp4zMf8GrVUvBQvwtA4Chu14PH3wqZd0mKAdYOOiqEEa8SJZ5ZRgsHlMw0WAD2
Avrz1TG3NDqPdjpa2yqhR5ZOa5JEm/TeYxtWgofGoPbpZ1PkJXGmT99x6rDlaZuFVtwCtE+KNIr3ZlmO
f93bgrcBJJHaUlNBMaWwAkyclc44GaYb7ErUBt+RlkqpJyc40lHQKEDIH7OHRjnL2o6EUx0Bbr2z5ii9
g+zYGVXK/Hdsy+ga9ABg/32b0sPQppSye4odogLiyUMQrlVSkfhGpy2psoj/ckR2XFhrwdoy3qYq4tiq
GNSRF2eW2gix2SWaYBiSLmDNMk83NEJk4g5pRD9A5aGkwAP8caSq0ZC1ho87Ff3QcUgU0cVFYTkK7cln
0hjcYAHDPvtXYNtAbxWoesNhq2yJdHjUzHxfrYu7OFily+xlHoi1XGb89npXB0fPJ9e2jGfBe7AgLW8O
aYbRvkW9ObDhPNlnqxXGdvMjM1vMasunOS52DPzPj07mUxnnI+4De4lrjA3R4bab8vjLXUkODfI3Fkkf
offidlvfKx9YHokcUwm36BZMUkHMOr3HeAQ9hKoAOl9cZGrqynpUv7NyPkWEgwHjEs1dGIHLyjmOoZYB
42cp0NMNwCSuRv/YZbsstAMpShTiSJQ3kbK7i6J0QoYmtM5YSTBL4WAnWWjyi0bER3Zb26+Cbax+SF/c
LOjIUDO+iQW6kjZxQFl8QqfvCU7fExxZVa0D1HDI9RRfCWbpYyBYmuMlmofdwWQH0TkOakK0bVeE6Eob
GPEkz6FHiAlPapjFRi7+fm6IJodoTFl+7JdQlAyS0/KABDrE+wwHJUJGfSSzDdDP6CnQCVFsX97eZkuJ
CU9lsU1vUoaO5f/T7gsKXmdLPEIF0ecnjGzPqO7w5mjuTsO8wsUrpUA7T3Q0XQ9BDXGXHbA8MVTkdt5t
z3f9eWs6mv3BYfoR736qPQlmQgSJPdJbBpQOfKnRG5FmxqaDSJh8WMkFy/KKUgfv1nKxBlW3bYRakmXE
lIHuRz51kzI7RcFWK4m22BSVyZpzu+rkUTAPrCTGfu6s/Vm6hRpMrZjyGOrwgbpegbTpO+MS0Yl2M50b
+L4pRT2oTLoTOaQ/ydg1mRU7dEGqSB/aU76tP58uD9tnlfhF0BDNgivRbzdGMLSyLUQfo1w2EdeGFD1P
Zic1Ii+3HU2f1fkUCXRHFJt2yKm6aeBcT8Bl088Q6n+DTH8fkYqOMwD5MsaDiNBm1VT8qvA0WZ2NYlEw
Far8J0CQvtmWfngFhHU4fHPdWYG53QABkkdOHoxF+6gC9hVdn2qj/CWhanY4mEFdpFVMZxx1cJ2pQ2Zl
ekN8pwUqwNV/GeV0MDmhyaljwe31xj5gok4y1Af887Yrz+x/gRzpFApdMETANBGELgCqWuQSn89cRAtV
CoZqShyukecNGsQd9P8qrdej2/RTSA/ph6rzqEegRGT/b5jxbyQebvxfqvF/RdF14jJ5taBG4WBkPOW/
chrpTgTk2Im0NdjWVY7g6SpXcrA9eX989LVac9En4PQwGqBDye0I1lHXzNJ/001V/ESFGJ1Lc3mLUY/m
8bk2LoIK7xLo4hek4UPhHSoQIq22oCf/hC2p764u/opWFQb8irxOZU4RKHi9WRcVP5SSAoJrSn+q4iAT
oKHA0tbZZgv2L1QBOqgcZAr4wCtnK/ObzFXl1RhfuAqeVTLhN2PBm+XmpGDqRzgCFYAEk6oLG00aX4aJ
e4cD6vmy+pHsr472KrHP7UW+l7R6Sxc/fN/XKrSv36CzyLuzodg4qE4qweDiIthgdjhligd8nYTSxWP1
QqniedIoW/Wsml+Pp/0xsGN4TK7Qu0llgt7HlJ2lA13tPB9hIh6oPJYO9ZisS62OO96RBkGtaxI0yv69
gyr9cmS9O2jk1hgPg4oxO05bTH3ZFiUuDAzJe0Zn1RKTteAcGKfKET+QHxQRER8URk+bSmcLQy4NGGPc
yB5GQs1FMuNABe33Y1o1V8GcC2LqXpi8vYn+eCmN2NNgvCtTUIBCCqH3FgjQ5AtYDRbDIr7oUWQ3+ULj
SdxjLJp8cf3tJUXdGZH2OonVAVQrv/WOaMZpYl3KiIAUicDaDZjyMM4JpNSeAkphdETXjkrCYspWsOsc
v5JJhVWJ7A5KubFVUx42+S3e0C+rXxh8iRdtZ1Dx9YwfzGI9VONFN41gY/zyTm/9TId3BAh+/qmB5Zke
fPVD9+GLHw92UvdDIo2eXU3tfY6tLYyd5Y3dicf+iExbbwkLT69KSZkzqzGCKMiL3LQ8S8icpXZ6fwbl
9TU58c8CtnCFXpstOmuCD5ti8ffAYN4ZKD0I8QbWnWtuggQs3ZJSP+EtEU6EtzgMVbmIrY3n6R425DbP
Qez7ZdC78ssq0AD8MpDgVaszSt2q1bSCtnmrbY7pF622+V1wNBJcA0bvvUmi4YKRlU0J0uwtOSHIaxwA
BAOtpKrWJuipRgtygfPcwUywaFghLIfC5M4UKqQkAu8cyEc+ntQ6rVxO5GAQYc4KrOKW0wVBc3UlQDDg
qwQ+V/ZPsMc5Y4YVC74EsFcaSTniB8CcoKIsPNhc7kpOCbDpqd8hqEjb6hZgMlzK9Abxa9iAV+0IBbl3
GLhcVzYD8wMBnEfsi3wPvHWZlU8/ySppXXhloT8BcKqsHzXIxKRr2rNHzlLYGd862qnXyGX1lI4GKwq9
VngxtqxQBqC3PtQ2pTWXvjHol5tbBB7qUMpoaxorFOTWqJAXumnjwrItfMllxIsybT2u0a0jnFMOtGJQ
tVfrsghA1Mvq7pBnh/wOhjjkh0rdYZXRtHIldVy5oj1PZubyo7jkIfKmN108jC9hUJjAGlVfRYwvf83+
aBWz2Ir5AuOcw7gBoipRAIZHHsMtDctw3jhm5x2bdi01uBy6sHnUgBoJV+Z6Uosr+2sb+ReYQr8BYQpq
aLbPsWBNBcCtnZXERxArKIrjFmlEcRYU8mmoszrAy+EuAlTBdPcUiTnHq01X8yn+iZHFoJACBVdZY8Y9
oBeKgS+8xOVC7oQqP8RhsEegoi8UC3Y+K2CSHkjI4aDtiGfXeLB+syYmdoxxNKHiU5M4MNUTPrh6ezaG
QKOMNsGc0M4gayX62RGKkMN6eDHCi/6e2X3PWZzJp3NK9ea8G56WceWUu3ZXEx+xC8/huRosbK5+nOBy
ofRJzc2heYSKdtIU6bY/uoyOtqXhmhcjMAeysn66QiwlN6Xe32PU0lNKLwYou3qbnLNuZ44tXdFC7xam
HQyfspxBEmDYhp1ymLujfCpVWBnXXhQRG+mbjzf0fWcXYRhwiBOuK1cBcIx9nXOgVQEbPTSSGttKceQ3
ZfEJE2H1baF8d6v2Rua0fVb4PY0zjeiIQdaNLE8SIuEAoOUUgqZgvCIhX+U/2eYdpjXSxX3e6GpV6dwG
NTcXaeauMTXZE65JwsFKCSHEDi1hqPN0b1nWary7DptaVa0VYh9j1a/wWxdNGxc1356auuikpMKlpM+Y
EPf4XK5WSef4w44BnJmGJ3fw5hxkdaNXiLBeS+UMVtyAfLyql+U4SlpJE6ldPXXe4hZoeVeX7XLezOFw
xYaBr4DzMj7pTwgEi11ZFZiSCW0/FMv7wC0XAYon+jDR1HQdBEPFjeKcRHy3YGukhKVhpZQDF/CVcMyr
74+7HdMOYzoNcs0QcF3IDZQfHq9UrzDPjD7UxO52vB+6xaK1wssFcLObbJbO3YuBu+2S8gKyj+qWl8zw
DsAakzjX9r3AWY03Wo2izv3+U5b1Lt18R1+zKrFrzVnS/5HdR0LpOdbRYrjL1CP3SOzRqAl9X6VhWABX
7I2nTTXO9M/SxbrJMbRBbgRIw9VoL88ICrjDvk2uOhx21vHh3nXt1qCFn/VTRSYqfgLUXGkuV5iVqzs0
slHL3R1w/kYT2XFDGjoDrxEM7MI27mS8nYxXk20Bs3PSGF0AmbM6ByOBV/A0nC61dXUplYViG2Fo+1Qa
mMZBT22EkkjTcbwzHE/ROpBA5Zbf8adSNEfceZx+mGpeuPMZ/RCEcNl8K2DX5SDFEMIAqrTkIVIb7lp8
k8rhrCm0sT45KCtK/phQ2jUkFOsRN9o/7roDaFDrPvUecWDNiliJ6rS/Z4aberOqGViqll6MOaXOv2+W
cJ4CHmCuke83PmWXnGeoGGSp/SXawlxrmRz67CK9ljmBQdVGuBmXun1KljPdQQgl8XAEUgVsxaMBqaN0
WOeAaQw2bbe/RbJ3jQF7SerCm7N6LKcbcPCbtHrwl3NEexedQ2EFjYUPSbuTPVqzVXuoRoLTOPSUeO1b
ozBkWsNwMY3Dj4nfxR7J0l+B32QGEVpiq30xxYu7mYBbmuxNlJOxTwckw2Kka6Jp80y+/E+nOqga6qBb
XV2OrbBq1yRcpWZR7cZWnLZrHquPaQczHTulNDvtkrQZ/0tfpQNWn5pNXrZqJdbqidqdc64+0bm+bobG
y77mJUF5fm0tS9fyW1KhgaLHvZZcq14TqSq57XWua1Xf3MjZjw1iJKlBGlI2HER5nM3SnAPTkPGHOmSU
qMp2H5QCrS5I2FzV7qCYu+5j0UbScP5WL2b6TiemVF1lAMFKeotiXN6gFTgcSKtgqLa6ykV71dNm2nU3
7vjYbS3d2uddJ2ahy/9OufwNS2M2FkruMzTyj9knil/ollvdiKsSJ4VOPOOwgewDwzIfstTaU5C00VBD
kxR/rdB2QKA22G4/f6vlT97uaZClbkjBefk2azSvc/Macm2erzOjnJ2dtyFm6+XazFsmnZYqw/eErajN
Hkfu+eQA6i857u8Od8aHDjrwZc7eXVOmcTa15VfD7DFf35JHFoMWldtDc3uRez0Me8ZE/E2Dm+XQnqdq
15kRYQ07g5zrobOKvFXXzKdWh+4sbUxnypzsU4dpZwsyLvu6pV4S0Urc0A2h+k1Wv+EIx5vNrvqOvt34
XIL2V7WuhOqPmNTJGDB+NgdUn/H3G9U3H98V21/4c4/CKae4R2cNB0o6q9BBpSrwy0t6JhWO4ZwBt0xn
BbilOuzvFXOWwnzy9XU9qQeDCD8L1tgFeINDJTUJrBlY3yxrqhTm7ZXiiMbRQM6+mis/rcTrgHL2ZI4a
ZJc6bmuSJiX2EUau+XxbJvgsLPHmBSQfPaYCQ/YIMxIBwISNzqsGWbQp7RWrEc8jGn69UZ2QAWdjCXYN
a9B9rMFtbMrO5opM+Cat5X7tvpDSfCDNVTDtutdKt/A1CuVjtJ207gnpILmfp9RKU3L0ZOPasmdRmUwP
5CgNrx7OUoI2TXKI+aJfOz+Jd90YF63sJtVAmzI61XAwkE1o39kXBd7fFcYubccOo7gFS/MpAuU6i/dZ
55VzGzRtQTRA6+7O62h909ruoSW7L+k0FyBIVUruuTg5xGly7wOB+qtI7Yny8xNRZibBV+pj1dQwlDBR
1ZrI5VOnHLUD6pyd+HRyz8lR1B7L0fmvk6lGmeeqhGHnmPpZ3f0LJrs7MVn+mTvL/zs7yz9zZ4+a7MTO
lHQh70vs38s0H8a0P+grZrLxX85Bf1ZuTb6v6Lo8cZrG13kU6kuW8f4odrKdib3vTEL1CkXWlaGq8k8t
UhduhqaxXkh4NgaMjctt7BY+HcWd1HX0PiRK+Q9WHFkEysEWiH3lO3OZZTTh/I50S3K+aldunsgHXLX4
lbiTrtrcddUWSYqfE7P8tLnrp5UtP22ZpG651sv3mnE1NuawFEYkW/r5sMCPZxq9SJ72z0rPPyvP+2d3
Jwe1/LPS9c92DNn4ZyfNMOoMG6/sWoDyvZkSU92xtNscY/y0WHNluBp5ef6C7+42FZzpL6o62/r6RKVB
empTd0r7xY/fKjifasrVqi2u+EFA8Y4ePqTjBPNiDMZlhEGOclG5XlItcfAr7W7Ap4rUhxbb0Z6jvrV8
hsqsODRRmnd1xHP/0Vdcz9PdJllbIZS1YTfLZGMHvcUiWZrP5tFXJZb0bYpxFF9yprWyOJfRdNfkXqsm
y8kCbLi1HjArX5jvrS0icalvQZkhDodl0nxceWr3VGol6xNjOubxUVgNvBCv1YRXRd/p3WsWa10IF3Z7
paHY98W96LRdpVXx5t9XjFBbs79LzDkD6vP3mInIeydLEf/JDX+ln400oT/irz/aH3lfAMxQYkr8RNBa
ZTw41lswoG/5iTbYLG28C2S1YRtuA44LmFQa6z8AgGaMNpzJvWn+cQDVXM3xY1StdQCH90Zv/DR+hfbC
rG0OvjDse6Egy+5n/PSl27Bpoe8BncCEhbBUVM4goKiJylXQx46RqaO+FnQi8wU/S3yW6MqkMES3hmcf
PBsoM+J8By+n4tBApnvGV0beI9Bp0SIzsU3648nC/WQ5CE5OcldUt/DzqdApuUzWQBcEkm/Dwhhv6xFP
h00K299qvwysDoUn49QAfvFS+ZF3zbjKz2QPfFk4DvctfbnJGyrRV3GatcI+AFTuNgh20anZlOLfvQ+U
qzyAW+is3oGK8gk/sHr0P7WXCBTTPlfFXoFVFu1rL1yH+b36g/MHbbeqE+8Y0EcBdL+lU2hZNHYt4qah
HzboPOAL0543YzVHu8yDV9wa3ljgild1DtpqRLCXibnPWXjqm3uO1owK7WK3kPGGMsu6huzCjWZ9MCRj
hlVER4nZIQMbOa5d+OhQo4c/fouh/B00AlsZOD28uU180h+21WZY/Q4kj8T2cAh9Oi3aEds2NfjxYeGD
x4nUitb63QgsmtbeFVrn32WdYNoyqQ3Txg8stmVa3RapGHho82OSD4pBKWlgxHLipcXVvhWySfzEuNpH
y0lt5T7IJvfBsALFAdIOnm//3xpWoUomCMWjlYBksWgU3g1/bbhzUkfM/I9O+bBRaq4mn9SWH3/qE/wu
bjOir5T5/3St7rh5OMTuWuP3LZ/aqJhdxk5ttMwOy6Vlsbj2j2/3HOmDei0lpvG6nYdJnjRpV2ni+xOS
tvcAUHxvLCPbSE5bfmo7fDtMjV9aKWSO9C10mqBS3FxdotCJhUc4t/zx5yaa3Z8/P4QD/TOK2vwnPtlx
c8fcwpspW1ZoQxX/OZdXJOiMlHI7n+jP/osuFyyFYTD/eBCW6mmCH06/TsaYx01fOGULny4a8i0aOnif
+7kXLbwrAs6WHyQ4uhL9P0Br/AlbmBPIiMbEKj/bflPkdDGQWzD7ALt6Iev7ePTVn/xbm5YH3/wPHt9g
F645r65yjh3b8Hjyhgjv3q72P48kea1T9RvzBSdev3H1G9HQptFHAVLDDGPSFmjObL92QsvamGsosQtr
PnMhJtFNRzZYQdVZdHiFL9TL5apHYFsplwF+8LwTSOJzfY7kLrU/RqgYWtt9BgxNckLDup0eXo1wXdMZ
/wr+mcfqFT+EOp5j2veOPomKT0tWMUvMmQiBWTncL7rcRF9uwLBz23gcNLrcRV/uQNNSvQZLsUp05WAh
bun7rDq/YnvdvIkbrtJ5DKtr61V8xEqTH9E8X2/FPVfpftbL9WrCu03W4iMwo+0g2UTiHp5Wg2QXiVss
G2LZDZYNsezyV7qcdsjs/3Qb2p7WZCscF2uyimLolX9ODyF93RIlyYIGqu5+50BKkWVbAuyZcHydrIY7
4MjXyXa44Xw0+WCQl1A1EtDzemymf3Dh4SrZDbVy8KjtDowavwKdfLixZms2e3Jz22QzVJqKeFSvgbZZ
thZFG4I8RpP/HwAA//9cHVwU2noAAA==
`,
},
"/js/jquery.d.ts": {
local: "web/static/js/jquery.d.ts",
size: 124161,
modtime: 0,
compressed: `
H4sIAAAJbogA/+y9+3LbyLE4/L+fAqVKlak9FJU9yamTIyfrTytr10psy7Ho7KZSqa9AYijBBgEuAIpi
XPvuv77NBVeCFEVJXqUqawoYzExfp7unp+fw0BsuZ8oL1CSMwzxM4sybJKn36e9zlS69bwff/n5w4x16
/z2Af59B6/dp8kmN8yPvKs9nR4eHn37BhoNxMj3E16+cfkbLI+/7JA0z759+/Dm59v6M32Tw0WWYX81H
9NEIGyzp/eF3fe/kCv7MQz/2XieTyVTBHyqt/XB8ZRvAhxe5ulbeDyrOk7jvvQrnUaRC78dkqrLaz6UF
fDn0s8w7i8JklsyjpL517mdJGGHrv8Kv2LtYKD8N40sFY10onG0YRbVfZvA2+4xf/jifZzChJMtUXD8K
tPgPNPybiqKldzGfTlUahXFt08+Zfg0ffO9nfurn3nEUehdLFdQjmhtB83ch4C7yM++nJLpWKcJT90G8
0K/hm1cqVZ+9k3Cs0iRWte0DbDKWFvDJcRykauH96Gczv56E3IIbEGqRWK/9FFgA5vRDmF010P4Ttrya
UAOkvQo/A0yh97ckDpIGMnATxJaK4XvA61/98eepXw/8SBp94jbw2XvgDu8iSYF4qv6b7Pf/94f//r8/
IiRJdgUcmSajeqbA9/yaGl/F3gcVItFrgYX38TKlBofflYSM5bBFpqStipYo58GzZ4ffeN9s83/PTpLZ
Mg0vr3KvN9733objNMmSSe6dJOksAY6DaQ6ANSOPGmVeqjKVXqtg8OwNMAtgM/DmMTCPl18p73jmj+Ef
edP3/gEMCB2g/vF62GBPXu3tv/CWydyb+ksvTnJvnqln+RXomkkYKU/djNUs94DIgI9ZBPpkrLwFYIgG
kS4G3j+lg2SU+9DWh9Yz+GuCrfTsPBAs0XWLxWLg0wQHSXp5GHGD7PDN2cnpu4vTA5jks2fD12cX3sn5
q1MP/n3/4fwfZ69OX3nfHF/A39943x9fnF30vZ/Ohq/PPw69n44/fDh+Nzw7vfDOP8BX716dDc/O38Ff
P3jH7/757G9n7171vVNoffrBO/35/YfTC2p59vb9m7NTeHX27uTNx1dn7340Xb45e3s2PMZesAfd8lnb
SMOz4ZvTvvfD2fAd9v8DNDj23h9/GJ6dfHxz/MF7//HD+/OL0/6zt6cfTl5DL8ffvzkb/hM7enf+7uDs
3Q8fYAanb0/fDQfPnl0o5ZLSpaBGKa4w2UyNw0k49iI/vpz7l8q7TEDdxKBVvZlKp2GGn2XP/DjwonAa
5j6vKpZXNBmfbZWfvW8OUUi+eeZ9453FsLhM/DHPmID66/HPXqbyHKeZXwFvLFDzj5N4El7OU2UbpQpW
xix/hv2Fpp+/0rp6/Mm/ueBOMu/LMw/+RyPi/77xhtAFdJjDWubluDhn+Av4E/uWbr0r5TMeYAog3VFG
b0myUm+BTz+HgDngZZC3WYJYD2Wy/lgLR6ryeQrSeUYcLy8yA1+sVJB50yRAOhH6+9hJiDIMcjVVQIrA
yxMPlG6WeAkKmUzzdwOfYZzPevveVOVXCQg8A3hI/8pgL488P16+KOPg+yWaJP48yvuej7qDwc48PxV8
+NkyHl/BWpPMM9CcvXAAAk0aICQIcF55Oldghuiu9glS1BoImed0YPrv86fYTTJDiLGbiR+htjgBxZYd
BMnUJ9TpCQGWAz/3Ub0eeXufYOma7dnXgBpUT9l8BsowL4yZAJuLenyX5IppWTcp0lG5mqI6TUMANkrG
nwnNozRZAM37XhBm/ihCogE2AbcsK4srVIYu2wBc+PIawDnOkDuMofenPjUEPYqPCbtHDDkrzk+//Pz6
g9f73QBWFJWmKtjHzgI1A17wcxWIOp5npIuZG+dA4yw7hOZJekiaWAGcYyDoCNZVwTAQLAYjzg9E8QLv
p8yzAcLDvJPplzyNZIRGKA5wBVPlh4MA7A5gNpFUOzN5LbPp7Zf4ECEFLhwlSQS2WoUTjz3o50Djz8x9
Mo/HzB9ItTGYESNCHskDiczSmW8POMZg+o+Dm77389s3r4fD9x+4330N0UiBplEiZcjnA+8jYRP+hI6R
OceA4mQqCgAYVuXjAekMHgr5MdO6hXtlqZmBnQvT8/GvyzkIb57hdywwMH9USt7pNY35gRQDop85QKSa
Z3cBcm/hZ/2HC2zkclqFv/6nX+5CBIw6GDFbwPxSdemnQQSU0iQnHUiKjHsukM/299LrEQaORMnCz77B
xFGN5t2vVz2gIkR9EOx9ozdhoLGBD2Y6g0UrI+mGtgQArHcB6htHNFm2jzwZlBuZzrnjJAaZXiTpZ2b9
cY5/osy9Pj1+RQT98XRotAEosZxao4fl+bOZYkHZ+///8iUPwTDO/ens1z3SfzAUfgr2NVjMsAZlzCnm
byQ9AoD6EKaOq1ySo9WNOM8cpCOfGZvq7PRPoFoUGkxgFwyxkykwI47oex8/vGGZuEJOi1Jg0yVgR8UO
5nDeOLEiKQk1rZJohS5xOIam4io5tHjBNci8nj9BIEXyCZOki4wYs2SoGzWew7z2GTtmlEsFoiNiky8S
KzdHjrx1Fm0c3feyPGU2yNUlmOn/YTsCdCXYN3PD8hqS3p7Mfa/v7QGheC1WAf5JkOAPJHoyz/GnD6Y/
/gAQ94DIwH/car9JHI1Szgx/xtpAwF9p6pNBrHECDHQKZCqJv6UFKgoyKeoVS5HeMnat4ObqJr8gnBwJ
zhrE9TjWCIZpcstD0CHzyE8P1A3obrIjgYxhmjFjBsj54Nsp7ypZaIwQHIQyIQAbTX3vEhbLGHRAVrDJ
Bl7vWgxbPwDROUKU7pfAo+Zo4Xzx/vVZLTUg/2ZAvF8FlsPjMcg9yTDwNc+HzCcwquaocsZJABPBJ8+N
WQKr+NxHlxH+A4pGj0bBHFko4J890jJ7Ms6avuIhmODAhYf/+8f/LiP9JxS5TBQPWj9a27AB2hcTICwj
7RUbYsgYe6C5IjErD28OwLc6APUzPZinkYoRYrAoxldIkPwvH4c/HPwJ2BrsGeA9cvJitsmnCS3K4IUZ
2w6IDv2GqERRdj1x7GgaB7ngh+3T3j5JQSzrrR8t/CUvu0V4vJ4iJpiAsmRwZXUWjfHTH05I6gG9IvXG
vSH4wDwbAy8rYUASPAbNGZaAfCEfLtmUY2Ws2xKPorrmlchZZXC60Cq+5KeEQOihLG+GRRqsbhJakSYt
2KzZtUtyQ2KGFjlKNZhFEVlYRp8OCpa7+xnrAumc0JCihYZYZN+FOV5bLmRKidmBvaPl6btu01Sll6j8
tVNvvtQKWxN5vwYLN3kDBqw2wXZg6GsGR6wd5MmB/o3vgTN4TSWVaB6AkF77EXgeCHLJUGSPiwHOUz/O
kOdhtvyB0f6sfLopGZnFSjVTsHBQUBawSJIlQtwEMoL+zauCe+P1tIn914vzd+9hLWOKZGA+eOwJaY9J
WRjcjsQLkwWBlVWfRFfd+Kj/+yJjB1kYIOhBiBaQLPJaAnioLviwQ7dYEq9EY41UjbCTfcWai1AbsF1D
cW5BbZ9VQW7sG72u47dAfjbK+EtyqlKyHtHkObBmHAZKZmmCyztNyDqcIBfXNC/C2RzMfVAjY92Yxjln
LiV/C8D4m1oe/oPwTwsdKUPLhLAG40Le14sdABr6UfgfUEhTENQQyMCtM5YnIi+wkjfyUZSE6AUeBeYN
KATpR8Z26AUqG6fhCC08BYQuSR6KTpPYlU077UmBTgu0C+svbCyDlDBMpah1B8bqIKdtEkYgGeTFOL1n
PsZO/6NKooaxwOwqmUeBCKkwOjdmH79kH+p4SY1tiJOlOXJfaFun4LQ5Swqag/jnc61RnluzvIq3HwgU
sJTwD8IhaNcl/Wiwi4aO58QrNOofkPvnZPHOUMgAM+zMFudG3BNjnB+XOV7IVNAvmEo5/ABkhvEEvYi8
yClvz96emsFdNINFHiPNnBbU2zJUgHd40UedD3Y06Rv3ne/91b/2L4C9wDJlFW3aZvyUWostz9DQ8z5b
3vESpAkAVsbtGilLHfRVtJ058CrolzWTG3R2TMKiMT/xwygrsRDoOgUGJi4IKaiDNTwMy/X7Bh/GvRBB
1M6FJgU7P8QIyXg8xyiOIEeUjx+Jm4dzM1ieeMgL+ouB9x50bDiyOkMHRzMFOjMwQHi9kUKlDi7mPIr2
ydVynRXjwGivBadScFsGbGji/ho4VDJ9mgf6o/jX8AoMoAIaFbkOYBt7GHAjOJgM1AW7WX0TOdoD79z7
IZnHwR45TRTxRTRcsJSe4iCDvQbviSe0bdeJAwakylj9GTddWiK+x24wUgQA8Vd4Tou2Ezjo4JQRSB09
MpcGK7w0oCPHFdAcCC8v4edllIx8tiM9Xu4EWs1QYWaDSUOK6BnngU2KCydMU1w2le7ddBmFn9nEBBDS
HGnNfyQz1n4jRcLCc0MmJ1yV4npoE6ZJBHyfhhigtUjMiljk0dtiGa7XCsaMXkolrA9r7+G1Xc7Zo0PR
ihKYJa3RJjg8z7SYl1wQsi9RCBh90vXPBx90HObgJ+joqPyZ9UjIyOp7o3lO/q/Gf6k9z1MwxU5IAIOl
QKB/sH4QM14ilkV5iTLSmLj1s0jDHBwUpgfC2Bx17GAJymhrmMXHaJwWNLaYiByCmcwlUheW1jQMdGm4
gRbimUV+lrv8y5KHMWoMf42v1PizptsbaHrwVkI7MnHrKxszTocjL+Mk1Z/qxmfuEiHhYjW+ikMYn5FM
I7KCfK5y//K5Xdl1yFIsE2R0PwdNNY91vImtnwJ+w4mecRubG5TS2gGyqeLrME3iqZjdtAaPk8uYbCxU
yFECWq6/By734HJAn+KObrYEhp2Cu64dcYE2SCQEa3pBYwT6IQVvt35k2U1wPrTDmCZ5Mk4iDgDK5IC2
xcnQXI5oAn3vmwNQgCrOaBsMVe0iDC5VbnbPwuwNNr+z3bM6lh98W2R6mUMLRc6hkzTULn1lNyNGy58i
JrSRVWJgZkW9bomLbvZunuvunms4zJO/vCTrNtdrsetM6cbgJIFKT7wvNPLR8ySm5etN4gfPf/UWYpln
tALEnvuae9dev2vHVpdtu3erBMTSPp9eRTL9GakjVNHy1d5LDdWehkBGxdA3Liw57tXl8gIjYXt/ebnH
i5p2+WXf7yyWKJmPkr20LgiJrBPJ0j42TflEk02AGYAF4/jTX7jVkVYYhW+OvD09/XdA6z3v1wIDUdsG
J+2CI1NtnIMw+kWzoxPrsH8Xg9nC/Rifl0KclyrGnVJWVBIfFScdiAUOiI/GKOA6AiwJ1fQ3MJ05a0Hu
GLRw/hwmMfU/k6pQfhayzpv6sX9Z2C3lHQNQFdcoMM6egdlHIPOCKKBTSRY+K7asDlm0U0GhF2mlYpr6
COgIk9DBPNwIQe4BxBQ3fqrsjJ2ZdRRZzQk4GStK2IT8JQ6hIr8VffoiYzlb6FfaS3L9f3AgzFJc5R/d
TaOzPwUnwNOh2MTVSOjvmLedVB62XuWeoXJYJGngBhfIiCqbPrFd1Sn6xE6DL9tHc4wV5zqmW7sdqUdq
no0bHyW/XDSXxMqudGxDwvxu1LTHSzoJRd96tLJjd4VsoK1wI2kSMxJHzw05hnFNXGsS5rmj0bTJVwif
r47c75lgvBEHsl69V+dvXyVj8g5pk4qnHifxgZ0ngt+ShlFEtw2fta15aLXRpDHApXcL99hr2rN2MrI9
8QbZHv2iL2V0AjGOzvNAn1H3Y0LD5MeC5O4RF++To5IVov6wRIB7jnEKHVBlDw7sskLk2+jQj5m70Ynd
+GPa2oTOpAsyVmhTWruLJlLr8+jkxeuOp5hywsMWccrPTnimLVLlejAxkDQNxywuyAKsJI3r27hh65jQ
1dQP7GjgTcoJLNYe77tbp9jaHREVvMGA3QHXyNCbwlo5v0CrMszFxOBto1jUfA+s+mhOc/rDzY0JUvPu
0XLlUMU95w6+C0N0AgCt4750i0IR3GCZtu1118WiWqOZFNGfouEToLa0u5lan5FcGMy8aIxUMeQvTHR0
vQhY0y63pvU9bHLL0KXIbU0opRxwaQikYMzD9ySKRoiZwuRCDr1l+yYWV7S+OM1EL7SYIibxEd0Rby+C
Yiu4Hswjus0MRDwJkEQpmkasX2ZJKBEX/pI36yQjhGQqA3M6haFY1xcS+WD2oMEvU52c4e5ookqIKeQS
KxFp/9oPIzSYtCM104FItjsdtx3n7OGkbUKVRCg4qeqsyFA0Ou1Z9OsiKaUtUVYNYQwGUUj4AE1akjJK
xMEJvBDrQafmSVdTNR2hhqDMPoyfkbLRoVea3w+gYybJjfeHwe//iwIPfTfOVwztIXCo8YlHMRUr0lk2
QrwX7ipDcKTz2DjT6DIDa2AAlTNm8grZi1wt70A7geYHQGrZVCetURZmWNxz1CmChW2kfBmRfUl6wmxS
+VUr0/mqZdkfVnPH2M4Hbd3bw8wlXr9xpQZV7oQX6ZEOxJ4T39LKpnuRnEQbRn7/cUhUeXX65nR42i+E
tmg9x3gYR9JoxUDmd9JChVjIXcz9pXBivsK+1UlFdstau6MAL1v85TW0oqjAemsbAqBIyYO6cxNaj9Q8
G+OmcCBc+XlDBFSvChJKy/SKdEwpsD/LHiqnsmnd4vXOTvfrtQAyAjAw2CQ2ipIY/xDYGwzaBQgUuuG4
cvrGDSv3BN56fIWCOuX0B57WBGy6BHzbAjpurtKVuQq4duEuGXr0B/TrH+XgsTETYx9h92wWbSl6oD3K
OWeMy8dI6hOwe5B4fmTFurIVYTQS7pBTVmFR2cqKXO4PkAh6Jkf/mW1XfOBf+rmN6TgT57UCbL6T8w8X
dkj8EXJIKZeAEQVLJRVpEvkSKpG9BTzK1fcWygbkJJhuZzv49r90SAYRwyOw6pJM6TDv5KYCGX9AwrQG
pH9tOXngJj7XHirA1xShDLISv/WlxXsw2oB9/wzDfVd/7GCgbYS34lWb8COtVDZyUwrMQ7NKRKiU5VFM
izY6ouBZ6mh22YobfNuv4ECi2qzyxL9pnHwPGcJ3LAivYlHC2wWsm6yksa2bcI/u0jUDbmdV3iiuDK9D
E3V7Y7Tn2WNzd8j5SKbRdRIG7czA9DQ4r+UHoyUrlD4O0Be3afgpJciBzTDW+6U21kUxAtMUDE2jrTXw
3v/H67X95tjhAey8Yl/3OYSEqyAvJyQ3WtBrR5Nk/SDomXGOvB+kw/2jEsxVXfm1gfyvf9cAXclzolMh
qgwOe29BIjYpR5GmIMqlvBP+utdlIJNSK3awxQwNiMY85YBLn0HtSAEOZay58hgfSAbJSkrKg3CMvgZ7
GIhfdoEA39T3bTIMORPYuMUNPGHek0I1uRDAFIQJ3O41LdB6wBRVosxqVpjA0tMbDAaOZw7k68YJzQS6
8gmrTqK+uLnArkAJnDMYKtWZtFPL4NMORNtKhIQSSnWKqO8kj2SNMieNjz0K/SvabxXU6VTT2DF6C+NT
nAxnIGv6SDEog0YiHluKFyXbNOkbMpYoWBixij/cfO8VslH7HhN3I7ouJMPCJ6ciCp2sXDT4DfJXqDI+
faj/IOvPTzEWkpSy0kCkjV4qaOJGlniDp9bKqiiU3HrZHiZnujgQHnbbqg7CDssaiJ910j8dVxFRSXe+
jmjTxETkWhQIt91sBf2qwa+VNTLA6MNjPmMhpp+Y0RnnPwLTJTPWaLiPIW1m0uZZjWH2I25NhmNtjQ+1
LY6u8Z8/ftdL4h/m0SSMoiNwLNCPO/KG+95fvvM+AlLiDwqtX1AYPXZgOAeUXhsYSiN8/O5FtwEavr7r
YVfA1dD5/UC7wWQsHzUa8sIufZMkYXi0joEqnHN46Mm4nniiWbETbMRJXWQ/0K8TKwZDh/9t54xGOlUL
H+G/HT/BRFf8BP/t+IkOA+Nn+neHT1cBVlxGO4LW/lEDcO0frQCv+WNN3lf2NPOBWE1xgnFBPPLCQ4Tg
cSIkkioOvHtj2ZasC5xy81s9r6YWlflhGEFmuK6IAxpYsAzwptF7mYY007MKRQilad18tiv49zvFTvhq
geNhY/HOJq7F5XuQFYzP/bW0Yl/MMVjSAB0MxwntFYLfI1fUTuphMvDm+Ns5I28bq3cGQAfbIZB6HB2N
B12+A60HHS7egVnhDNvZrqh808GwqHyzhmVR+HY906IreCu+6mRcrAtiy9f0eZzk4WTZa4g9VEbj5m70
oj14UR0wJWnqPCA3v92AGdayw/ULV6+Wkbhd95lR+w2nhj1QvAPDDnqrUxMUJbGXQx9KgkO15mGdepAA
pmgHk7Oun+NZdT4mI3tJWO/KKonv/Uzxp5TMIlukWlHQM9EOJp9FGF5FCvfrhjTnI++U90D5ZZjJFux7
Tq4uhVq4ydl0qoIQugAIZ8kl7Z7iAZ1Zbev3skHY0gh3kbMZQFXcSZYEb5lRz92VkfPstTBwYpjTOINh
C3OW6fTMFo5u1fgSs/V+LiZR4KN/Fh9RMLP4aKpy/2+4h2gA/vVZRdWfxbN5XkfGeiJ/EZWXFzvGh+M8
japPq5MggK/CSb5ybm8TsM/q5tYwdZ7caJ7nuHC6qBhHITT7ue5hCY/JZJKpckt++M8qEVbTJRunSsU/
1z10WtYAD9hZG3TM+XSYD//EBMHi4LStbNrAX8UmNVN5n8wwE62WFG1skqThZRj7Eb058grd1A7UeYB+
Ax76DZzTr0VqvwW+L47ePCnELyUNIVSmEo8OTEtiTklb8hgXUtxNBOiTf1POSholN2+BEpVsJT429v18
NIpUVn2pxp9PIjAgat+cVyocjJO02gk49FHi5+XnV6mavMOcTSwDUDnCdZVPowtdJKD8En5heudPV2HO
6rXcIE5o1ic4y2rf8pYIUn4HanIc5svq41y2Miu9wasLhRSsvuJst1NY9F96lbWBks0qX8xH0zBvIEc+
SoLCzOqkieLZlQ33E8xRwti5KbwQ2OonvmY+m4qamrPX2TzMfZ3hOM/kbBZmdrl5+/gFJaCWEqrKgXbo
lTe0CqPwLo9MrBgx70ELbX0ULJTHDZz+xM0+PPa+Z8LCLAJKUMOTtvbYMugFzHHGlErnq73simqa7LWl
Kxos9t1vDSc5uLU5H7gNZ7nLOYAMTedjc8xJjqr1JHeXhGpfDkdhN1TXG8+lKoQYSzu5x67COKL9slgr
spzqjGACBAKFHUhSi06wMxOgzDabH41FQ3RBVwaGhk9NHUHz1rU9cZO3xkUlKE70SEBKFqge2nPO2XNs
9d4o7JKV7Oh7UTtqcYseVhFGH/caJ5T7jrWe6mE7sQ0ErEhN8uIqDhZj65p9HId8gPBcCmh+8cpCeewI
D/dkyp7hUyx8RkfJkaa+7s4kBpeyM+ZcplTSEJvHKggO7r/j4bpS9ZV5ZgMYdPAmrMoLf2bzP2tGdLuk
jPNEn7u20FANHy4x11B4zm4ArhrDJv9TUhueDuCBVGBzF7HCRuGNYv9BkvBNf5Ixyke7yHSYx7DqlVLk
hgvcrLZazKnvVajEY4Yv1Q4tH0TIFR7s7MVYq4FZAtQRjlGI8ndHBGeKE8DYt56OwX+fT8sTYWZU8KaI
lZpKn8KptFwUkRtigbdqmuWfikmWMyfWZuZRt21hdzssLlI15eTpt+ZhV6QQB5pTTZYDRwps5C4TpzMV
K2e9Po1q5qSZP8OkyEyHxjWfUV4sBTWwGubKeQdsnK5C9qf5FPzzYXIaB3bV2wYwVFKHF0apY9kI1Cey
EbsAhZ3eJ1CWQlhcBhYDzkHDsxjyiopt1QOqQjlmw0TELtaBncOcdwD9CuMq8qvqm/GiJhMqYQy2H9Z8
OZvoY+01SxfJmxfqmEy0rKQS/y9/R53po6XmsIY+EmarvFXOSxdWl0IKJ3dpDF9dVQNLektpOK5lpOs3
c3uutyDHTosDmNIWxcPwpCqcYtukewaBov56e/QP9rq3T3YJVbsJS2sBNWpezqc+aXM6LppSYqhW0CcX
F66PrK1LqR/ivDF5j3KsK0xLZztLpkGtkvxjSUmijeVHp9o6WNc2qwxZb3xyK7HNADw/7RlzbL8U68Fa
IrVv7ZzEptYHviwz9kCkMzqQ+zvCkjwGZE0zBbKb7dfOT/r7UvHD3msHJS7UxufzNz30oPbLLlTJHTIl
NI/5wMikWoeIip0XLztwXTO658N0g1lauq4YvLKnyfVJvJwP7uGxuJl1JIpHEIvqCYu2rqjpbU5DVFLY
bo8hLOR42+NWjwzbALL1mPRgL1fjvoz811zJUbQfwaHr/5OSIbtX3eDtT+i2yCuxacnKLOFTzmxO+HyP
HKqzZQRAJ+kivw3E1OeSKcnX1L+rEtfVgxTvOtDetL35ISv1rQu3HZtfcpAqcKs6caWzyTxH8rqkzaqE
eJ8qrmfZM2NausggsGwDHJnEGnSI9pweVelVc+bYbkXbPYoHTcO7xPNdIdUMddGiyKSZxb4cqu0Kl3dG
peFMLQin5tRAd2g61hE0Idg6CknPp6qYdG8FvaSHPHSRAJpHGjeoFQdvhXxynwWwUluVT/H5rNidEjq7
0OpSauC46aoQtNHlvoHG0gwNiqpa05XruFbrMZgjr0e0MRxF4SVK249znFrvZhpxVai+KZGKtYzyaVRa
AC5VXtL/Us3gaP1yBibPsFJPtXXNfpBEpvkco9cS2jO4qakGJmSuqSNvDr6UY9m/Ce6RAtDnJvz/xExP
zHRLZrpnzYRlOA6k6lU7ZyFTuUUkHtlaZKiAEG97UXjkeH4UEtxCwK3r5Sd6PgR67lI+C+X56QrWrvSU
G3h03f7w0SpGBr5RNfLyZl9tjv8yAe4rAUNXvASMHrn5Lxt7anSZ3CNbHr0PXBKGWhjriCrT0iav1E+X
IBxehMAbGz5fW3UP9hUyXr/OxJol2WNx93bMKQ97QfiqWfCx+IxPHPkb48gd6siaHVq8tetgNk9nuIVY
KnTh3rFnU40AkoVK8RKLhb906p0X6iVkDayLpdOK2yS6mE15Q4RbMik5YelK3wBRqPsxUlh3pmRFmUNL
Peqmio7m6h+vkyjIONsBi9bIVUDMqWIB8Qbrc6r8FkjqZNO2AvQGnEOpClwzmjMViNnxY2oQZnJtjL3Z
1k4gKECG7T/glz385aZ+1se2j+VqMb9GX/i0DZ9R1nOS2ksxyY42V1DTDR6+juRLzlUTfU1ndfrJt6/t
haqlDmxVnlfnb/W5mb5XKPatN7ilUH2mPyogqqfHsnJja+RIv4YdqmW+ntBWgzZG1oPBms7/Y6D1X7j6
pf5MLh9hmKVAZRFS+eDhcYO8pqsWbSZ6iSOoIwfubG3AqX8DvXO48L7hl3WnZJV0Bo8fHnlffn1wEMV2
U7sAAWUe4mGWBlBWCZ6+UcUvJAfqUIhJDUR2ofxhzP+KwB4tV6/qOUPURweyIs9JLdhJtLSWk7bNjNc/
oVssXw/fvmlaJcFccjLNJ9SWcMIRCTsK11L25PZjNATxdoGMPujT/vTPdhSD/UWsUq0KMaFF/yzUd8O8
fgOXKdROEyhjCedr9WOhe9CS+mczuXaGSsqrE40B/9AlubkfB3j9G/wmNGu9yfdk/TkIrw+/w+UCf333
50P8736lrJ2+diIrXUBnnsuhiIxvuJI6106SvUZ5tDwQHJsk9zZc2wG0K9fCsd+HeDbQLyfMGq+jIBdY
1U3u+w9INkJ77XV5sdUG6HGtuNnK5yJvZOmVwKqteNcEyAcVhTE4QtmVtT31FYKSUPk7uksQY3ANk+aa
ZZhPsSqHNrX1MUVJ6a4zy5lS9j8bJzPlXmshX4Q56M9JyQWKk5MknkThOO+Z2bx0TVidiFmG/711PsTn
0Liu+JaZvUC2kHbKx4TwPnm+7V4foNdvvOJN4sW8PnXdott12YzMO3cGLPdPFhivZ5X7Z0vOC7Lln4ff
UdEH3XdDVbDhdy21op4QWEBgW9WwJ1QVULWqjJjrLSefPb7Ehk4EArqsm2HuCUHPHWvKhON55Kfl5G/M
60oV6HUl5wzApsK1XM4Uu82XmOfOi26qjQNJInTO9xQgHGcZTjJbcf8NNHtHKddy7L1iYeWIaT8dhXnq
Y7EcjBr5WZaMQ1q8TDjMXoZpDm19cO7q5yw4YgCsDe6crmpwboayjjjujRnWjupeq6l7wHvXjSXAeGOj
IlRj5zbvxJ2E/panORSziBrSo9KBPniO3FP2pPqeg+i+Z6p9wf9ryoEycnhEQAueOZBAaUZI16f8lO6c
8ebc4YeNe+Y1diCD7hOjkFmFscHmTh8UESxy2zHbcLPPV4rRFqzsNwjtqXOHe4zhEWOuiQHKZ2f0zMmn
qxqinaIOfNcwOxPWhML7HbVVyIMFlfsOdb/0Gi/eaIzt0xkfe/EpnmJyLySZ3JhrzMDCT4PSiaciGuWY
T5W/zDSqFwmU0VtTMzo2CLmiGweX5n7dOn3ZuEffGNmhm6GpGgRRrcofMOyrBhZpLMh8oSPLzA5umeCy
yyB8cxtOoWK/uEroYxTo1PjUXYFQ98IXa3EFmQkV9fPWj8PZHMsf7Q6nC7wWiXoxlZ5L0sbXqwmi7wnF
ejhYUv9OWDmuuzOO9Yc9yKgLxzAi5ZqTbE2y2cVYD15bs/pBEDOJrSL16bqNh6E5ayvco3nkBgFwwu5B
zo3ptGaAQGqqY0myENyIaHlAq3JQNDRuv6TV2ThxAfVtRg53UldMvVZps+VR3b2r28kcO2U+ihvNqdhD
Pm4khnxR8jwPI6yUYC7kg9XICVKl6jLMMIpD+6OzqHgXg0SxiAeIchme8L1OPqvqczQBsBicXIwvm+I4
Rz+M8OwL3/pHeVVLz3UEcW1w/y5zf4kIcocSHdM9rm61yynxT/Msd85JFbAmeCpSxyk02HOGoF1qeVVT
k7CSb1YtpeiaaSxthXEnN0dydBb/B54jCEKPurUHygrdcFcoknRbd/VCS/S4iJnNyeiMrs8YON8fmt90
WpbKPLrndPF/GVVVqZsLLOrkPn/xssgWx3gBpM5sYRbtcNZM/keKqYEfHejrdvDqEzPb+okmk0mpvhRP
Us0c7+DXKtKH/mdVCI4yp2pRQb2GQQ32VEO6gwVP9MstL647L/uDTTv+0v3wyrkkdkEnlvWmpQm20z5/
ZXXWzbAHZy/IXswi73u4IbCv1bwZy97QUuPn4nX8nIhw7NzUsnQLiLiX7OA92HK1bVIcxdwhYy41s4iV
Hkr5IGlys+wJdrikr1vo06R0mHKgOnMJG1ZnbYM2dS7hroh9l6SiVWZYWsy7cZTXsz37hTI77qR4wtW9
jm2xCLvhYWwtkjbOqNC9WHKqExdQd1JYsb4iVrNekNWcyy5gzULPvVjWNbAavbgpLHWYGYRE07/1Fe7J
vHzBFt5t3ZNmxQJaMklMfnDYexJLBM87PByevzo/grVqrKONC2VujKc8L+Q37iXMKH2m4g4eeraAFz2R
K1WPirUZa/ZF0R9luOjGIL9gRKHXQXdTA9A4IVro+QZjp5nhuRp5AixD40q8BEV1atMCiKm433Kfpb6C
5r5Gymk1Wnq90tT3m0fRBbH4FsWembhjy5muOznlx96llAwPYSX2XbOub4qpxOYmSb5gaopFoDAQTZ/w
RY4wBBh3OvTOV4OBz5UNPEqAcB4dROFnE75nm9D3IhVfwg+jNHr6ql6rTZ9njgoQLcLXUvM0CJf6Zvsw
DhS4G2Rc/x6nzQMcfDuQC4LNTN0OrkMfcR+mokWq0e4q65h6pI42NnchYRTCQVKrj1M0JrVudV0+vJm7
PhsDD+uj7WgsEzsv2pLp2xfG4ekRjs5iSVDRdbUo/ng+OdVOwlAvkqaLpjjgEy99NbxUz0hoKa1mJLKn
ylzklKxbyUdvVXqprM1AJAIbYpGU9/4AJZccESVvkcyAMLUXSdevl1yl3cmosDhKwZHGS4t1ooqzfYZL
jrEEChQXOwRTqFKnLy6aTF1JcNbUN5c73DnZycuSqGqjFFOavnVm66ZQ2Qk5M8W0KcJgWAnhcBfv8HrV
MiROt+19CZMQdFLxXtfa4Lk6lyPKeO1W8x2TO1BqhmXI8P5rjj8xRCOssKEwbWQ8TzOkes//7A+4/TiZ
LSsmqjBO0epmRFAJ1xUs9MhIi3gwhkPf24jSlRCE7NJkgHl30xzPlUquS7RsdHoCtnHL39ncgdIZP+oP
60n3xlRWvbidV57bD5TG5GytZYVjeLx+ZX4eZpwBSEVnbLiI2UKqzcg3UsvFp8CL9bjLng+1HZqour3E
Ez2C+eVVmdQ4ZknLJ7oKD5ftgXUC+r1EGzHnmbGgmDJvZadJVBF+19c14DyO6diPdCPU9oPiBMTxY18X
sKNTn3g32+MkQr0MOYlNC+gM/IiiAGs4wxjWqBxld49/7lFaJZcTxEK5Se6cUMl1mpkTLBDP28ntzXSx
owmFfQypJyYFdU8vbHumA1Qdg/I8jD65q1EJ0BJLp2qGZp7PKy0adjTwkck2Pp/IKjzse3X2HS3CRqgZ
nEJy2BD3msqycWEulUWX1aRe8NY3Wl2YLazhtUEPuiqWZuH14NODb3HhQ6pNknkcNNWIskkRksVRd6lt
UXjMDo9IjI2n85cVCQJT7ozmpfnZlMNlEHLbAxepZHmgvmhquo4SMMLvtXFL/G1EF7dreWWHHotkDJkm
SEmdtNH3CjTV83tZU6uwTJzq/jADYqVWk6Y5bVrCH6QX8GiY7kmkLKztRoDJCBi39HwhTtrmw8duJVS8
+tvTLi1qTk+RBU4xWrtwNbENQuEuza7hqzez7dBh/lyGLENzig8ZHV1gqlxjbBCv7cJMTttnctreJEe0
WS2daVLZsNBw6P2stYCwZ6fCPCvykPDfCuwbkUU9T2esyvN6x16V5vxbcIxfPLnQ0xnOfNBz78uve4ir
PbTCGJV7W+Sd4uBlIN/ju02YqFGEZam8NbsUu9Hz/YmebiTDFOOK0RALM2ct+PntG3sCALU/KxD3cRM1
qDMJntHvLvSojlqGEd69Ssa9mGzBd/Df1vvwEzY+tM5zAw3sfvhkAbjWaEE51l934Z5E4RWSu4rBrgSn
4biqXqf+Z1VRsJISUgkqY4F+yiJAKwONOY2Xmls2UCxMWgS1bZq6NVCPtYGa65E6RiG2ZJ+KWU1W6ioL
lSA3Mzc9YQRKm6nxUhuoPzHfumP22WilHadMT0jM1h5L0X6t9E99sNH63seimeaES9Yx1fC27o816T93
SerzVFSJJTl056iX+yE+kerFarrDXDEdtGDQWXToqOBgNVuUEk1YvL1jaacC7RmKYpoASsBzplCQfMJ3
0JE/zx9vmc96BXqJN+5wml1jhcXO07/JlWNO7sCaQTiOxTYGY1q1IDcZFhubUES/4n5rQgdBdcNa3g1d
fnB7K02s783BM4d1tmySUGO0xamZiCv3qI8z1DpFeMyQbNZ6CyxOklmvCbsftKMs25vmlILO6dHpaHk4
VeV+F70Wb0BvLC5UFB1g+WzF1bvcncbUyZS3LFo5xNBERCzFwJEYp1+UcjwkWNpkxUdU8eoTXctvQjCN
Z5D4oKFv76hBIaxf2MuBPsp9LQCOX9n50Z5xWj7qT4+goZSDMDNkc2HOF0pW6UdpWuzl6XvV7LEt8hlj
jW7aiJ0YmJrQCm+30i+DBY+mPXjhQNR0I5i1PlmJwl8Yw3L44V//OonAm/n3vyUk1s4fRWMUQ6Zd+i1N
fzlTXW4zu0jS3Im1lA5r05UQlOPZd7Ld57NICkVwUlxQOe5KN+EskvQznRcVhVfpG81quTzL3tvU2Yoq
dVcEfx6Hv8yVNiDcs+Pmd3fZKaAGzd/Gc08oQXRatVloyjkopZxrqueCe21uykfhADD1P0n9S04pLp4A
Lg3yWakZs0q28jwlH45UUiImc7ZlzKgMVVX68WVB/N1qDPjSORZiJlSImolBXrzaQh/SjDHhdaz0nRK1
10RULyH8oJMjfbdWeukmmkIRcXt9Fl9gxR4XNjltq50inZdttpGSbMvScolFwE9kIKfmuqrkv+iMGlCk
r/N89oFneVT6u08dnut64kXLpCFd+haokT3imBNhKojyto2pU8q36YKmcrmh/sqa831OGYppjI6oO6bc
/JbT2pK16hcRaOpa3TnCLnDvaXN8nbcUpt8OX1lLt4AgfXfYneMH84IdBG0JKvQiixJDSYlabIJdAAb2
8jpwrWRlBAzTHCrMbG/skkxxKtWxAxB5tO1rzU7MXsZfc6U8NC7tyRjj7tIaapyqbmdPHkURPbM4dKqi
Z7RAhZ2KFMfqFq2l6Jx7LXt81VamhpSM2lZ0tp0xVovNE9nviexasndE9jLdT6l6t62lRFdrmViL7/gN
uM1LV2tTCbQidKZmcc9xytYeyfFJKCmKWI+vyGkYjkPgJnBQG48JJH/DblCP0bvsqYzu1qPgo0QFZWYl
Zm7yi6gbOvl23nK3FLVSOju9cNkgvbJVdczNsw3CJCtGEJB33DPD15zQ2hkOjGAcl1MdwhV3bjHwTOca
3JhSXbZdL9vHcg6USOVGdmcJXz+sITDZ37EBSOeu1PdKzKfzPrtHY3UwrjpeA8UkJ4NmbTNrq3REqV19
6C5gkPShw3IxNH0YFLxM3plzp0xFPnQVUKx5FXIIFPNbbcXDChjfQ1emRmGXk4E/SpTHXHXMB66F3/XR
f7aba8jWnQ9Np+/qDqrYITnyVAIM3vYKHdREx0qA4SVeLnc7Nbk0VHcGQGPFkGM3NSY3EzEfdwXbFA1Z
pVd+G1gwqTaPAwuUB1irjvNi8hS47bm4NjXq7LaqFkvr2qlKORRXz3YmQ73axMYdoxt3R6CmCnwHhfv2
aurLFOGtq6eHrcqA1NX8MFua5blTFjosLeFlLLcSXwI1Y15vVpo0Q2OfEO/VZtuZoh/NBkljJoVeGciN
KOwlbrggyGTyadRig140jUoW0K1WIBz5gi3lumKaJBqZu3PazdwjgGzf3XTyHYHYrlncAY2Cub0OoW5r
1IeOo+Nma6gKKdo6Wonum56dnvQLqr8snVO9TjfBwBwkLppWAtX2TUOibr1+k+m1G4VPtH+ctF9tJ9tz
alu0knWftXaFGbDORsaXPffzFWXQykuuc8JksyW389TXtQtN5k83eDe2jb8+DKxrF399GLA7vTtGQVi2
PPU0VxqeLlBho+H5UKm4jm9z++XHTKZuCWpYDhRmGS6SNOiwNHRmt0YLQaomLP9hs+ZXh3x1vapCKAaD
/re3Eoqe63FcdFY5r+YFIhK6vAbEIC2+HfxvH/PQ5RC4X4kU6ktqrLtURJyUs26L4qws3cUF2tnj6TuF
pzh4S+fKcC9UB3O3hK5NIsiSnGS3aTaKInMvJb+tLqL3sBC2zXCzyfK6vaLgzlfFOFycbzUU7BSgK9mM
d6SZmyvJvW+xE9si2VQBjaBwibgp9/S9QM1UHDBTeCrM9eEZ6vE5XmGGebVjpevpGsObel2EdL9I6fB9
J+F1+axn2W+0ZI7k/RY8BZVcXkZSSLUOMg1SzSKYLXB2NvGthxmHVFsuT+f51fIQj4jCQmCWw6D2HBHP
1KnNRNsvhhClRAWeb0Ogp89zetnBInqkxNY4H7knmO8Ct187IssWXKFIZFVJazGRmTetdS3Cs5l679fp
ducMvMBao+t3zjEdlxKRUctZdmlpE9+mSIU2ZQsssHncFssxtIQSCsx2ezNCO4M2TMs16NJCDoJO4h4n
KSdkBJL8XJ1NaVwn4Mu7pSo4lAOKVbDXiCf8ZtDQVhX5DhDxgLbMVhmRiKp6ib9exwesBByzfBnVOvfb
DjseF64UKQI3BnXWYDx23Icv3W6yBTv4uHIFSuWA4waxpSZINw4vfjWArxtV/GoA76b5vkrQmeaPBvTH
sE6sxHnD8rHmbuMTTXZAE+fg/31qx803HRzA6/ccVnkZmBxN6dZXKry8ym9lnMjOO3XkHpmuwST2hhiU
UdHWpPqY3bLdhTWpmoe6rDvObatYz8IbFUnY1H6gT6WZ+9rncciwKT/D+wv8GTrsWGPbydTer4V0jeX1
KwS7q3e1OdjtPoT0ub29KenwbjOXBYf1/ga/XFs7PWF5IyxvkAX0hOXbYPmJl3ehMTqfINimJdD37JXJ
MyypC/+O5jlVbhglaaBKGa5hHKv0dcVg6DzVRRjkV7ub6U843HoTha7CmGpfbBDJ7dMdS1SpTLilvtZa
MplAD/aW+xM7bHV3o676seNhcqniGTF4pCa5LrZJtdbZjMjcihBkdqhF4ZsC3KULNBt37J1PHswcC+h1
PqhBdMt+0kOBZoWWpO1nKpNELOx02KIq6zWkU1lfUrNLJce0+qwTFPmiVHOsvQByXLjyrBZDTTcpC3Ub
NntwXrXkRh3bxgT3pG77or14R805iDYFRIaxvbXZ8Qp6iLQElN/e7GZv33oVvrsGSjwby+5gAbyJrmZA
ty5JYa7SQbkGvpPCMW9pQp3LzDhc9jwTaAy7+RFe41StCQZAmfWlMGxhR+6elx0kVHHJuWeE8TK3DXxt
efVjUcUaQtUcPzHZGhbBVVO9StLwP6ido4rxl43TBGsm+elGFJeb39ny7DxKq7UrR7Xpizeg2jrEWtaH
c/OTy5UwRc3aZQaXMHdpAnnSCGtTtGUVhbG6LMziTunbdYzO1B1yScOOxO08/MMjLQK6KWW3oJaLU1qU
zfwGvKODymNuM2ngFuE9P0pwLdhGkI9xsEFo8zeBkHUCRVtESHtcgwfaXliD+7vbqAZjtd72pncbR0Gf
0H47tG8YFn1C+9bQ/sTt96Jkuh4KMMdE6E50pyw8Jd5SNT8MJi4VnpxVgMd50x3nO7roX3aMwYlL/04X
9ptxuxScucipwEM6CvPUB+uVqz9nWTIOfTa+JPDSkc2wZHyny/UbjxwOxeCkhlKs3jntFC/dW2Doulzr
e5eq7BdRhB32PmPd9lIWQXstjC0jiC+wcJICYEaFfAAHR/NZ4JfrrxAUVNH5i/cvB5p/y/3Cv7adRTJh
QMm8yA0bSi27jKBttbXlKLmNBfY5XzXHMxs0O+xPkLuPxMAaSTGdTf8fanDwTbW4TA0bvXOkw04uaCdq
Q070QwbdAWTVhX/sjN24tx/FjrLSk+/IijtVUIH6ZX3t5BzU4uoC0fKAuaCoUBoAjAuwtWmjQFEFQ3T6
S+fgGj7Oql/XHe96pZlijZOCm8FKhz6Pa9LQbzNz7LQ20bJBvny8lnwaZu7NnsmIi5mb+rg+cS5fC+mN
VcoXgqMiH+F9dsYMcKSMmCaQO5j6vApPgE2zq8brIKlDXEvoB4zFIkKreKxUoA/MyPSCgdeTy+iOgK/3
y73xnaVSjj+JC4U3ZwLzVOVXSSAlf6VEHxXXLV+VwO17ODOnjimP8bKS7SUo/TNohu9qqtWrlApDAirn
wC7wIw6nJsRvikcW89rWzFsrJcXZKpOe1PpXzqhUip6vX0gWoBTKq3wwT305kqrPUeii/+aoDz7Fi/HJ
z6/p3jG6aqqQultfuJ0B9JIiJbab0CnzXiAON1E16Xd9M/X64rP6prhmEX+i1b3Qyu76PdFqbVopPyuU
6CrsTqEGlAYuIbFqkLZF6JYrch1dDZstcC18GCLMADzJ9BOftKuP3xifcFgdL4yZ+jOao3Mluryj26oy
E7lhA6g7kpNS4X09NynI3xa2wHgT3eqVihkLRi/XGBeMZnMw7MDmQ+9NX+tn3Zh6vFrRaN4KM1sTU8Bf
yNksWcMcjLtGd/XVTeCeXDGYaU8Daxl8LdfsVZjNIroquqaSJri9Ez+QqU/JC5j5v3TA+4M0MwAUdRb3
bmtR/KYxtpHOfAQY2+Kyt3Puvd2C9kScOxWUh0OcLRkCAurma/7rUNLfOgBElCsmlD0+DXo+z2+96PzW
kbaR9DwKpD0O5dbAw7fTbk/0uWtxeUj02eL6g9BuvgAdB1w0DnMcZv44zBuvEtgtp+nJHOu+RipfYG7C
7ykE8C30HSfGg5WtDPnoLnlrmDhOpmYkGXfD5eyJBLcggamD+0SCFSR4HLq7m3zdTpU/UftBUrtRlNek
dpPfCJBdtS3iMmdGb5iWMfv43IYhFYjcWozvCX+3i1s8Cvw9Fr3RxNnbCTE9kWoHQvQQSbVFv0wAv8V+
IJ4Jz23yeLQ8AC4gTjG47+vaz0gaySgzLzM+WW2oSYlq5uVGmZWVivD8NIx16liCOaczZ5gSYijBjRMm
u+zINXrdj3NVQU69u/Dn14GT7UZnnlRyNw68o+DYE/q7Mftu0b+lVY6A2Xx9a9vPe5yqLINx7zSl4utA
y9Z3f5+0TDc+vLv99ycKdGP5nVNgS6qe4LkbVS81D7wsCmkTbZq4hHlkmg5gUK+SxR0n1n3tGNt+etAD
wNgjUFpt3HuHuVtPxLmtoDwQ4mxrsTGg3n7FaQ0PPgDG2yp77HLD5+vH3d2FpR8A7h6JwrvXjZ4nMt1e
eB4Ymba5Qt16g6c5pfABcN5W+ePj7A6Tvr9uZG05WfUBIOuR6LR6nr2rJOInutxOPB4CXba5uACUd5s5
oKssdYwj2lpsK6t6S0ZCORsBy0otVBSVzvj6UVY5OfxpPp0Nk9M4WDmW4SwHWpeTplMVYE2zaNkyrKAd
kNazYNoy4n07ny53ct8B8m+ZevEbo2ExuaTvbULTTQzRx2ly5LuLGXwtCLozV+Zpve/Km3fvVj7RoqsY
3BsttmRv5ev68duDALdVz1OyPletkti0MET9hQACjO24eXU79E6vsQP6awSj9hT+PVzOnEtp6RHWTaQq
nlimMA4ilR553Jir3uieT+2jmuvn24a5o27Ls8cylPDk+/loFNVipq2z7h8PBgNqmtGw1SKTo2ie9m4L
MvZh4HtZJM/LTXot8/UwDS+xWhAy294Yer5Ue4xRfZNS3W0g3LDXLC7fh3hVViw9yYS1fJpxsB7yBddD
pob18qO/Luo2JZVlqcA41lNieaHx8OJnhqtcdVcmfkuy3BGghtD1V7Rx6VOsh0ULzEiR0lOm7mhhCuUV
4g6QuEO+jMLx5y5sie0250oe5f5o5QKxMw69b6DvhEEJhbvjz2AUdWVR3XRjLrVj7V57msnvijvXBfax
MKhB5PZ5FAtjX2LdwkxhFeoklY63a4+1isMkGc+zDrJA7TYWBBll91LA096VCKwF5mPhf0bhnSroDlgN
43tjnzDeLQN1B/VRsRCg0fH+dHXWLeq1DqhN5vm9sRGMvVs+WgPYR8VIiMgdcFK+SHSfNlpVuWY2pxsY
BJqA75+glglGA2cJVvhNPYX/5VrJkfL1pVcrYlEy+FncgLr2sZwBGihyPs/X67k69dLxs+RamTDKWdyZ
En1nRlsTDQ9joJEqi8YtKZjUYWElAdfGdNtorTjfEIOtJuJntQySRdzBSJSWG5uJZqTdq2g99VYt8je1
RSWtgf3adLTG5JoW40rcruJRvN61iyejm96GS2Wse2FTnvzu+HRteB8RozIud82p81k3Np3PbsOjOMq9
MChMe7fc2R3SR8SagMW75st2xEaJH1Tx2m7qrLJyVsGNY+7MSVoLwPvjnPWQt7tAOlmsHQ1D03ZjheaM
tluWtFNv5cu32GyLzLk+vI+AQy0u1/XfO6B3NbOSV9WVW6nxJuw6ontdq56kiQGUB71DXDMQu2Lc20L+
WDiYsXovLEzhgK4sTI23ycISjNgpCzMQ983CXSF/LCzMWL0XFsY89q4cjG1vZzLwaPdgMtDUd28yrAXv
Y+FWwuW9MCvtoXTjVdyWuBXpavdrdsCpKzem7oRR14H2sfDpJjtT22HT6+6GLW0Y3I50NNp9cOr1Dq3Z
DeF9NLx6fV82bKfwp7S8HaPWBQZ3wKarAqB3wqRrwPpYWNQNgd4dg36Qet1xPWA8n2QyaWHFFV3UoT/z
zmOFG7zTJFVeNvPH6iBT2AA3obmbfDmTC5b5KIwf0XFTapz18WO6NsV9ls3HV3gmVHKF+2ZPdTBdvo/m
l2G8Rx/u2b/LFNS5iHj2Sf/kI0/ZVTKPAt5CJyomBEIIvfhRtHTYZJDEvX2mtp/n/vgK+aqAm8pZWMs4
+pdhIDznEQJhYQjuDQbR56yo0162T1Dhg2ymxiFgiu6krjuSiqRkEtjsSg3oy0rC5UZx06+ZPe6VTtvb
GtiIJlZdAmunvJUj5wMBj5mXKtxQ5JXtltTDF9i9XK1uey5jPeuE9nsW8ipFv3j/ApRpyv6bNiteeL/W
iGLbXXk0bHVhNByJaHBJIXSUhYyHWn0ocFsSWZI+ErSK/G1vQaX6BI544Vv4N8FrJ5IFVhHIME3qKklz
HISQ5TujoAWQhdMZED1IiAfzeRqLqIIAgW6hKeIhW89PLzMcgDCugTevM4dtPhExBzLP3v7Ae5dQrQGf
bwDzx/m8+G0SV+0OO88pKrkRZnalnxkoM37vpZctwa652S8xYryxZul7g8EAgdUnCVdqmt8Ck9apE1GM
WBcijHLxAAKVjVUc+DhVqZpRAVBYwfEb2Jj1ztwPYARgt3iOp6YBf9Mwhz76RVnwo4W/dESCxSXMgZVR
TWa14z8SAVzF0PZIyfYXzyeWftwsTR4eOYC85VH07zQ1QyHvgJrzOh+3eG5fncAEWztlf2+yYy1WW5bo
HoxWvwomcx5WvdjQXL2lMFJsg4puODzfXSCNkBiRFFDuRx6T8XheMbfjtaxt4vPAZA51MLvdQJSZiSGl
5k8SagddJtMeiDBNspyLnsww650/4d+G31YwuOYDJ4Dl8nE5JMYsXL8mZPMRkLhPf4zBqkxkFObx9dSc
GLOdM/5gznfo7T5RzIjZrkOe22CE4K4OOj0kvngy836bnkuV3Xfhujxx/NfI8U+OTTd52o5n85Bl68nx
+S07PmqDfYYm56fM5Re4cTVZFuSzRgu8On9L8fA5bprg0QyrT9azHyeaxNIj4DdYFgGmRzbnoKbGY2tW
BvBq+J8uOZnccOOcDD3OVlIy1jtQJTPf1dGiNSG9v4SMjbC4blLGeqtIgTWzcZpEUQfW5IYbs6Ye5x5Y
U2a+K9ZcE9LHwpqCxV2yJi0gXViTGm7OmjLOfbAmz3xnrLkepI+GNRmLu2RNCot1YU1quDlryji7P2Yu
E98ZZ64F6KNhTEaime7Wjgzr3A76uljHECsx3+Sp/96kd1RLMle6qBu6fsjXPPV1R+Y+pat5XCw4vcWk
wHLXtudJlDVVsDYf5bUbM/PYlJGsfLh+gclbgNY6WFaee+kb4003pX3N420UB5Bets/yh4feGR4Ljf2I
67ejwAO/HXmnrHh5/E+/4DcaRvlWpWly6/Lj3ImzyGwlujObZ1cXuY/VTyWIUC+uje36FCeR2fjp5Xxa
xwwahW/9OJzNIyrzT8/I+8Xy7YTOOK8fnVuhQgRAQVbUDQ/QAJQ/mykuCt/eKzerdAtYzadRhxGGSS8H
kFW93I7UJEnVyllIs87AjSMMf+AtWcgGx3FAVM7cm3YCpWY/NTeoVqnFsF6vuFVcbqSms3zZKz8N40yl
+TGRpx4VttX3DGgLxmap6kQ43W4Tysm37aTjy5hWYAQ6ikCfHYNX0toVtUJyyHzr1lNQJIhbrTXMM/zP
BT2sw2uliUaFvrSFFZToW0RIverNk+M09Ym6hG6jkRepP6vQnB7if2bQlSi/utlRu85sja0RlSs6Nm3P
4hh4ruM0uHHnuThm4xlwNixfHp6m8nzJbRWbry9mGV00VszvITutVIrQWHoliw8/bDD3VnXFZh62KAFn
bu2B9maFagIXWJe/M9f9MCMYGYdXyAX87oXzsLzxUNtIFWmjG+gl4X2azEA7hIqX1UjFl/lVsZ/yMPz0
XzelqK95yt/C09fDt2/M8qwHHKY+EBOrR7IqD4IKHH29ulckX3+BxmbrgomNWBlVZE6/Bi7SDytK/iqM
glTFK1QQrAWZyvI6OriDNTVzwdQ8Uv9l/VTdFqpZAsvDZ6Kr6wZ39Y+sAVlFA6Hurzz7pcj75fe8lbIK
U9Kqi6ZwmrfALi1aSD1B23/ltNA/aBslbmWnSZhmeQVlV362amBsIp6tCuqYhOW8th+xNl7oJm1ILbct
wVp+XQTVvGUF4teAOoWlCLexRmDBliyGIJma1WOFooxxvV15fgVb4UrWqeHHOA9rmvaFceq+LX4qmLJC
1P1TwOJL/a7tK/4sWalmsElXycG2LQyNr1v4OZlMMpWDo4+bqhULjx+vRD+3yzo33JBUha/Xplbh67UI
hqfGOsAGrToxKzbcFAPm0/XBN5+uBXsWjiJ43IG2WRSOwdAHAz53rCa6o7R+HQED4iPMJySDhZ78ghed
8h2o78AVdoeS1aymlcVdrBZ/x6fn6YlRUFWB4M9Xt/31WaDGETCNN02CeaS8PY5I7HlfeJm8mSVp7v3F
+53b9tpPxbTVPYGvn4fjF4UWvyu//H8BAAD//2ZGsfsB5QEA
`,
},
"/js/jquery.min.js": {
local: "web/static/js/jquery.min.js",
size: 84245,
modtime: 0,
compressed: `
H4sIAAAJbogA/8y9e3vbxtUv+v/+FCLqlwHMEUU6ac9bMBBPYsdNWjtJY6dJSzF5cCMJiTeRlCVHZD/7
Wb+1ZgYDELTTd5/9PLuNRVwGc12zbrMuF09bZ9d/v8s378/ePev2u/2z/ZmfBmfPer0/Kvrb/8y8frm6
W2bxrlgt1dk3y7RLBa9v8aa72kwv5kWaL7f52dOL/9Wa3C1TlPNjlQSP3iq5ztOdF0W79+t8NTlbrLK7
ed5un3jRzR/Wq81uO6zeRnE3W6V3i3y5GyZUc6sXhGVDwWMx8VtlkWA326zuz5b5/dlXm81q43t6FJv8
9q7Y5Nuz+Oy+WGZU5r7YzejOfOkFg02+u9ssz6iV4BDyX9+jseeTYplnXst0V74fyk+4mxVbVR35u3hz
lkajscqitLvFDKmcrtLVMo13akKX67vtTE3pgurIH76bqFn0eFBFNOvuVm92m2I5Vdd0M4u3390vv9+s
1vlm917doNDcmRC1iDxePE8to2of9FgwEcvuZEkNFTt+c1Cr6OKX0dX26u7lVy9fXj180Rt39rX7JxdT
taZi54vt+YW6jS7O/dFVFp//Ng4upoXaNDeWUO9/XFNfn8fb3A8OA7QcLbvrzWq3wuRFjwI54ULRZGx3
m7t0t9qES7XN5zlfep6a58vpbhb21G71xWYTvy9X2zaUddN4Pvcx9TSeab6rQIQZ+t183oriYe8yHqLk
KO7gpyv1j0N5Ng6rlWFl3uzi9KZSJVY0oZEs8s0056JdZwB+oOISemi4+bvvGMQjBo4EZXf5g9yaG5Uc
VB6ns7B53bp4xy0pWbVFvG4aJVdpO+1TF+O1X4XJRKW2eCyDpUeoNKB6GT4b5rhWcdaN1+v5e92jzZTh
b4sKJsVmuztVQX7r96jMPP5gkfM+lclvG6bcWTGVRp2442M5k7Bn57vWz/Qy6rXbyWU6HPECp+NxOBqj
+mV2cpR2wfb7o7UFGGm4CCdqSygppE1NP2q75qmjO744KFq0hx21E/GO09dOmxgSLSbNfaZyNSEEYCdy
1Bvv97S7Z1Gf0IB9bIZ+HbX6gwnQWbJazfN4WSLPabvtX0fTSmUzXVmnE6gjbDvd7wkdbF+afk2D/d6f
EmoJqPUoKqi+qQDu7Pw8GBSXswEqIjwrO8qPKy0FAfqVnBUEXEEaTUcJ8F6Mn2krijJ0r93GD1r9fh4X
S5lrP0PDeYTHvNHpQRAM/Zz+o+ECT7bb5cs0GKZYydA+d+vitzRkNB+ZufevaZKp0vDdqsjOero3XISe
GgCalgvnPxLRiQmth5pseB1/0Xkd72bdDR4v/CDobvL1PE5z/+LqBWFJzwtUsf0hj7P3YaunchCdChzX
CRJRFbVcrdYuMBLqt+vRsMk984gWkQaHdeRq9NSE/NdMFD39SSjTaZzYbsdUU9wVEoaKvqX13BRpwzet
cgnigD48X8ebbf5yvoqJngS02/C5sxRN/dcg2HJ6v9/H3eUqy9/SrQCk9JpeDVv9MHb3YLvduha8VXlc
0hXlURfMzXcTj6tocc++Wqx37xt6xuhl4ICuHm1fgwW+Rm2nZpGmbxh3PC882l/xfu8umHk6nI0KPYiA
tqf5LDTvCXbnqySef/Uunh/3lJBfTi8GMWZwUyzohaJl9Pu8jpqLIG6FODGanoIqpp2URPNuusnjXf7V
PMd+9b1tuinW9JKIElOkWM27MwJeYHfaAM9nxTzzk6BLi0zlv6UFInhfrN7l5k0QptQ2AV8aL/I5CH3T
DMV2l6yVRzyEV26bW7XhHZDl31INzdRPQAPvCeDsNXEXr1b3hruggSfVJw30FJQP80f4NuoRRokNQp1G
W+rugJBayizkNHgELAwml/kgF2yXUf1C8+JRPqaaCK1FhJiChKb05pDPaa7xTS7w8zu/ON2WwAY+zBV+
fl97H/7K4DiCLkDNh4CZQNkHQJcrtQJyA+Nxk9cYMYfLTfb70XhQRy/+1teImWBlaPimVHlbZm7dbQEW
LCasLiNJiZMKVEo7d3ncpsPHSK+T4Xk/nBqWJqb31F00Vesqpk2620kMBGQEELkFiEF6mQ0yWgyaw05n
HCWjzI7KlIlohmmX0vQc9co0ADgjvn9CdU9LYJtFrXQwvZwMJtRAFrVItBhNqBStFaHEWbudMwPDTy1Z
yussnwvNRw0AmolxoKUguJgxSXZaNA0CJGWNiBAW0mgWDCxoTQS0PvqB6aKGdhpxAT78rsjCviKs/NAI
K+B59KdHcJAQzKTCNSSElOIIDbtcSgzOINK8uuU/1LOA5uKYrYt1zxJh6FSuhS+/XkHAHGwXXafpdH5A
k/Db6dA6aQYCaOs+fEH4lHDSvdrerSGhhjcH9JX5de9LYc/OiJ4m+eZMZLkzM4ozhukz1HD2Qz796mF9
JttEeAOPOUnC0meEoKsTOBt5I6EYZ14n6Xhjb3yE/oKB+eZsW3LQcck+W+I7aOAr0gYqLNTFkGliq4et
XujFGIT+pAc0TNRsyeOtrGdyCUb8vM8wdUBndlEDXTO8sJqpQl2rGzVXC7VUK7VWRCrUVu3UXeRti99+
m+de5xyMFOZPvXPl4HvaDw/07300TUga+01+vpCfL5ulVbBAALt51OoFihb3eeRI++pF1P/880/76ivi
jOuC+Ets8r9EL7vr1Vp9jV/I89+Yi7/ShYj9f6MrTZz3e3fwBmEk1OnUlXIIESWDRKgCCzDErNIiBEa6
1Et33j+oV5GXzvL0Js/2Ij/TRbx9v0z38d1uNaG52fIVYfP3e0idm9V8u6cB5pt9VmzjZE4fzIosy5f7
YkvIZj8nvnS/uJvvivU839Ngl3uiItlqOX+/1woUaiulFzRBryNvdHX18Kx3dbW7utpcXS2vriZjT30b
ef4wvKL/dfdU4P58vB/9QgV7vXP6G/fGQcdT30XfWjrj3XvKu/8Dwfz3kXd1NfI6rzveU9/rfNvxAqpK
34+e/vJk3/r3eBgF+skw/MQvm/oFv5+Mg6fBJ/srr/7iysObK29P9X5H9QZ7XcvVFfX57xFRP9vg1ZXv
+/951cG+/sYPaALG473X+Z5qfhrsu1TuCk2rHyJAsiAB3/uF+9LhCn7RH48DUxt9Ke+f0ERNaZ7eNHz8
VMkPvX7b9NofXXb+ja7QTWCL/lgpGpmi1IHxJzSup0N3lrjtf7hf/D1QP9Ubo9l9QuV+jh6/eRFW3v1B
TzG9ff7qizdvqm9poOX7t1/8pfoWr2oQQ/2Xwl+8fftDWOvF9wRNb7768cV39RfU5edff/Oq1rXQZyBn
XcYe2or9cjfDv3PcBOd+Cv53v5qcA8FpINGzlb+jfbLKMlq9UYegPfCvrrKnwXJfwql+oe/pdYeAwE4t
A4RXgCsn8lEbN+D/FY3ziS6yzPNs+1x0SPWxoTpZ5rDsVX67n9KYZETlAKtjoBvanVkw5K47HfOH0egX
6vsT3cWD+md0gV4Vy/XdTiOePTpDEkO8T+52u9UyeHJRqH9RudlVhssn0Dj+8jjuXD1ebZ9ejZbxrniX
n13dX6hfpbY/+CNgCpoW/+qe/hIs6AdUl4qT6GJEw7pQCV3RHrwiyTtNKpDH+422WxafT8aPffWnA49i
uJch0t7jEQCEsyRqZKsir/dA1PX8T3/846d/MkwOWDTiBlIonS6zoVD07mSzWjyfxZvnRBv9rMNfBGHj
y8vLfm//xz8++/OfVL/37NN2tv/jnz591gsOg93m/eM3mlN5Gf1VWJN3XQY1iF7bQFXvXo7ce6PJtAT6
QBwOMSE50bhvokeuN3ypSw2rNPBrI6go3SxJdodGBj92GObBPTVODMQo1Twy/QQDyx+nRJUOB8uETBKe
XaLvUteESLwQ+BUT9nv1AG7VT4ZJd3W/zDcvNDnf75PwXQBtQbu9oJ4RS0g8xpJ6kEHaUC2I2JqDtFp5
SyIzVNqnr/0bYpHM3ATt9p/p2Y0uJYzyut1u5Sz/TaJfu/lDzrIt3V5Hk1F/zG/+HOErXM2oumm+07L0
l++/yfzrQLVm+31r5gjMlX7MugXksWv7UHjoGQGhlQdroyeWBC1Vnh23S+PZkcwzo9+PtcHjGz0bm/cG
5DLljmf75fu38RRyNuZAce95Hj4dUxtpteRzwiBbkc+TE28+2potidFQVyGLd2+3kB5btzSnt91dvmUB
kmd/G22iO2L0EmL0eE3a7Vj15cJRMCUn1AXB4yqaQkjyN7KMX+wIgAhdETUpMuIHhtSAJTBJogihPGl7
QZh0t/XCirbilrgfmvZPvM62430yPvPUPFoZHk62yfz8PFiN5uNo27lNfFwFg/soTsy42u1VQovvQA4B
Po1u1b1eFUufsFWASXkIgCeOZvO+y0cpb/TJyRe0hx94HgUJvA8eD8TJ0tamb6lercapjZq2q6648Eud
zQ/Ke9IHNeK9W25ocNOixIagaR8nJLXnjujF0Jd2IMVcQt4iJvUVz0u7nVFvSfZJRnF3OysmOz8geW/E
ZcdRbvqSlE3OElerNLobE7NOUrh9XyTu8UxN2ZUV77xgUM5eqxUTNtETZHUJrb6dKHcxANkntWCEkSAW
O8juOqkiTS3J7WkaHS2DAEZOgJF1Y1qKr+NlNs9H6SgfEz4ta7up1JYA1DOovesCWT+KHBxHO+ffBK6r
u02afwOpY79/QazLv+P6M+ztrIKn0kC6lkZpd0nE/E2RzAm9AhemaCMwYodVigz7IaF72+O5u1Dl0ZMd
woltaSRR5iZYpsS881khjdSZ38X/Vv2+0wDRDuFS+C440d7SbY+g0G3SgGnUIQTsvCJZVvqTQ9UItUhq
iCeBzDSaVMFgSmBAK08odjoeQ/9BUBC1/Aw/uCaKjP/bLq0qe4HwvyZ8jUicUOFzAptDGk0IJERTgePj
Ce6L7c+vXx0L46y5i+u0OA6snK1bsUedQ+/rt69fVdFuSPtJLbjVfGdqaRD8cyjQj9oK39E85V0SUmMS
Q/9R5PdW2ST8AFB/7kB8Xu/c0F9GuVpFRy/UOmpN/JwWot3GydSUIGWN86BunGVfEbe8e1Vsdzn1Z3j8
CIYA81VMuN9RNi2gc271g3CKzUx4jj+h2t1b31stT3wLTSejAcbI26hwYMnVpaeGUkbEgRP3UyNf9jXh
c9TYBA4n63b1/rlGoM9XC0GgRBZ1c8dMAsRHDc/HrVraHj0Rapef4hLa7VM9K5Y074CvyPucMPkZDzP6
JP7k8vMLur+sPDwrzGNPxV2WcnhMtbl7xvjzBBsC8aY2IjBbJ6ZuVZk62iTEDdypVm2gqJh4mYan/l1T
Y0M/o94vs+43L2paK+iDtG6txg3KVl+XqLDGLJa2CSkYuZKoDUcpDscPB4VG57t8U222VCEaziAlliCx
1TUu2zFrBfpxOAShr6m/HeH/D83KkF1MaBvHCDUWPHouHatMy7t4fpfrrirdxbdf/CVq3k/DRpViwwJV
MfLwJMdtVMyNivMM+kY5wTpZAag47UlWFj4aYj7h04wAbELqIE0tIaR2BjLDek0OZuysoamP3uH7/4MJ
sF9pSK3PQrkFy3lQG4z5Fn9ELCgxSZ3vhSzk1zZpFX2IluJssSUub3Wfzot19Anhi9ValOVaecrPLuQh
XchjxidHnLY3cur6hT4cW9TRbt/K7HpQWI6jUlcJ3eEVK6waazTdKKva701VpVZ0GDKg7kUpdKKuUOuF
G2oqXxGY1yZNtl1eZ6OFdQoGdUkIi01CimiQuSe1Q+Rq8SUolPJenBo/3kdZ00Tyl6LcsjrgUyPPl6zX
bhq5eaW80Ki/T9TyVIUP9Mp8qbpPQ4/JNYHiAtJDvjXlDVhuSWzTr/b7Vfc+T26K3etqWbxYrH5reLpq
KrmtPQyOiWXapZGkKwJ1QA6Xj7b6iEuJ/KPK+9G2BVDlsW302FqRp/4OWLiNbu3EO3q1Wy2M7sELbEhE
biizccskZkZW3XS1ALEx7N33q22BjgdqB32OU2y5i4vlNhg26Z/+XBF5hnGdrQshGiVVaW3gHPFkRH79
Fv2FSihzbE5afmqbHpaXJBix9Ulj10ni+lP75Fs2YKpjcCh4tHCVRBVpH2+cs51Wb2AFUvVllAyP6okd
SewMx1aqNxDFZetkn85byalXFvkPM6LNURPnTw3W1VP7fRIMT09BEoR91W9j1sVM7kUOVjjPsEKnPuKG
siHGl8MwqNIgPXwHZdc7FQc470+kVHKqFHWvH94M/yZgf0Nfndtr6l0v/KydoZ5+01KdmuKU7QVgQFIu
IEkq7nqqWTSKxziET1i52JrQHEwDBxRz233q4YRtFz7c1QFrJklUMbVovcAgjeJBKbA7MDXr3i1Fs5Ki
VNJcqnBLSYnZKMNBY0E/QdbplLBBTeKd4jehLvYOnS/MdT8kep0H4ZLEy8RgweZDV9YJQ3Uif2DYWn5i
cerRsjTBptEPx6wftrzij8qLPnnSB0VWtPGPEDYtynq/37TbG8E/SUAkArRG3wWsbpNtZVFnIiqT/b4B
4QJgM6u77QPNlA9K/bPltLSSPng8lHOSqKVMCEGQoVyXPZ4bg5ca5/Mj82IsvqkaiJm1Kj78MYM9LC4c
PVXN4gCGLsQJfiWz5JZUtZLBMOezgNbaMHgGwKxp5mQ4CV1pGOs0rIkTtCf8SdTAziegjZPudp2nxaTI
s+FE+PmQtXQYPxtmRh8yzPTevKeZfjjjkursbrnJ09V0WfyWZ2f5w3qTb7cwzzzzOrFM6d2yINbhDRQr
x+oNh2XnbUy4hGCHxJ909+IO9sLEYW3VTaSx5Jsd+BGIKmw44PfAmOCF/2Wg5oahJ5loNAFDz3RjNIHW
CEvEpHwSBI5+MdZWyaxOUoTrDAZhxSUMmXLoaGgm38IOsMng0PMs0jNQzAiJdyRECkJwf5afPt/yi2MT
L7Y05BPL5c6iQ/chm2HGkSu3D+IBHriqyLQTsdmrOTb5VJr+jFuuGA7+A0sv5cp547MqrqOUJFOSdkRT
JbhhGz066urwjz0lrPD32/wuW4WzRDEyCX9WJajD6hgCE343+ZxPNsNH79ILH7NiE3ol2vW0qTxMS72z
hvf0uGMfb/J3xepuq0df+fbfpwqRJE+PXrJMHT7ysXiTjD7qjyP8qcnXKh59OiY2gP4SKhh9xn//CFtV
xyhQF/X+HbGoOXoGGOQPPewMumDFv7KArD6j3SIn7h/sSwVfKG+5m0kD9MrU9Gkw1L0zG5pue2N0/LNx
1PHxM0SXcfknKtYPwmdPfQ9H4VLZp2x5m2XmLsC3f5Rv/58xdf+/jwqE+CHkUmvxYMwLmnZOC83TZqbZ
MaD2c5fnQJ/9oI4hNmLIAxqiZFSd8jBtt/8hxaGkJhie+im8n+QmLY1+A8/qmc+T4NxcB7wwPdTbK+eQ
l5kaS50n7mp9ShwsAFpACGYYH1fMNKv0RRcxPDLOa1WUHP+xzS/1ToxHjvv1fhTzSZLVT+/3ftVIwP/F
GsBQUbEMgGkDJhWH4Q390sd1DWgtLZUhzs1+36iNatJEadWtF/AWO9A+qW3ZismrfWwOGSJN1v3McT8S
w9h8CMEO0xUmQz/vAJd78mAIJVcamvdD9Ixuf9G3BHU9VrEb8EqD0HtavnRfXBIT6D1x3wkUlSAoTf1b
F4FhYydn/FCvZe92br/PLTyaqjp9rqzjnXshVO4ERcdoxfjWaHuDiLEI82MleBPX7sH+xX1+/hl8Xzxt
3cM9MfMJwpbpORk2eEe0XInAAWz0pJB+VIwaowmOHoaeQ9m8Bmx/WxUtNrASPnXGpbZRq2i3WzNQ51sx
ZzAcwzp4nFspYB7NR+sx5M7ZcH56i23Y7nNeZ11b/cEqWtMsLeds/RlTk6t2uzKSg93i1MgqGk2Htw5R
D2+7mHm+HuMYZhs83kS3oztCeD5+2AnpOrohLpgNPZbRNRBYFN2329dECdSi8uDZWM3Brt46RjGj5diO
ttOhl3P6j0ZNLSyiZdQLoFpZr9Y+23lUB9pudzoLKs4y4CN6EY3uadkW44HY4FveY8tOV34iXU901wNw
7+iYdDFAb/vjgcOI/J4+/YeLozvNXfLn0qG50yEMYUEUS0ZVdQtYnEc5zSkrSRb/BSOSHjH/Fxm8eg4N
FM4x5QbXyVzRlhcrg7JPGA96UBMTHHrtkeAph5HEVUsFwlHbYz7q+pA5/dzIQf0hya+jWMWKsBi8y5y2
apa5flyXO9zz2dg1oGeB5MSpbBb9zUh+OJwFycxwNJvih58cgiYahjp78EKg3oMXkwkKH5erXThr0rXi
iFgchWfH9heldh5zUh0I0Is1q5pGmZGqczUaA5fVLA7gyUeS0xT+eswWzDCcBD+ToDoYWGOXxI/5B5VB
QEX17BBAIgsDKw5KaPrrI2s4o3eF/8SRb3HypcXb312Ln7iiA/RArOmHFEN0A5KgpS0xaAsamcfL6YkG
ftIcGZPgU4DK3zOYqvgj3I86sk0YZKszNqPAuQfXVLc/eljMQ7xAB+rv5LmRb6DHqTYH64xY7PBLljAG
mTTSYF3tWLcaCUq1I03VLt5U/KldO8BVGosStLzG/ptVztGEovbFP6vISCharRr9s6ERWxGrCTv1U++X
3TiFQKV1vTAN4yZfsnH7vrz2wcG1Wtj/rNyNu7NNTtLhv+lBnLDhC/sAs9a/mf00ZwLsPkWCob79eGES
yfShSiOv/DsNXxL0n/hIbdFPUsjauGboV+aA6KDMVXPfXBsm985WwNOhygr1IHK4SoZ1L4WPyuXQmlpg
+vxPTY6U0ocm51JLRbrcOru1wh8x3zSN7V96s9o5hRMsJrCp8D8bCovhz//mMjnmQwbcnEfJQbFp9rGz
ab2qU21SC6ihrB++08zWQ5FRww/MsAaQIMw3ddWb8dBfOvjPTBKhd0aPtdeOhnGUnPdRJr+tlyhFk1Hv
Mh2mnSRMuSRJ28e1lS54vUFymQ7STvQsiOvn0DF9T9L3hz7vf+Tz+dFQKg56ke3r4PwcjM7AVJNVqpn+
7mo6nezzpLkWtqwwAE6ySOSA+611Pn7cxFmxgvc4b/5k9YBrEsFz/K5JQrxfbTJcF4t4ioeHoOS+knE0
T6DTstVt75JFAVWR2uTEKR2XX0h5Y1e2hlnnYZ04cTqMYca27HGF7WKhep2AewK43eRQk0YnfP5K367o
NyOhE9K4sT5Nw154Y/WeA2Je2JORBIGsa9VZhpEJHv1WynED3ojB9ixgjUjOZtMzXU0OlYeWQff7WaC0
7+KE6oXVFeILUBVvbRXsfpgbo1Q1keKPokROxROcK3V4tDM+Qy8btVKvrMUUjm9mIoMWNfczcY62xf3+
mm4Js9MLXPk5nn28F1OlDzSIxTzROg6fUu02bOd4pt+Hs2GpywrC32ixisDO/qEEi9vk2FHNcQbwPOuq
lnXYc1NU7qVJia1pk1TdLBIinxuExCFM56g/IYcQY/5Qnj4lQnmGFal6UmrD4aVrxLjEOdq1py2x/qIm
mE+lJwyVkI8mDJDT44obaiaaquuw57ZVVfPpTkEyL6Ka0KgIbPlsrd2eWdl2BrWoo9eGrBvNoE5EFZBC
rhU/O+6LY8O6rRiMluJUZS6sNqnBSJljK43ysS7YQNpDKBfLFndJA6aklTZe14Ncu1mLKIBzxdTRxtt6
7hJXmWPqgqRDeGFGVRYlKF5H4qGc2FAlOCPSkg5wRepPuJ6AjT31WYm6ZpMBcZRwYoHYLrxzuuBIRBnt
WMhjVFcWURmaFZXDjUSe5XiG8kHFMljjwIo+KGIFB/1ZRVMzljVONGgS4VL71FOz0u6BxhPOWLi7jeD/
0prAHXcd0kyt1YJkY1SvNlE6JFDzJ8M4XJFUHgxH43Aa3rKJN3HniL4gJWnZryP6eKOWdONfK0wsXtxE
11VAuIHsOCccdcMzuhkt6Qri462+mgfspyDHP+C95QINUKU31makWt9G6ruWNbilO6pokDOnI8Zf1/Aq
/8jn/nWUm/PziZoH4QLPSeyjV5PRNbo5xQ/6KNt0w6PGofpwY87IVso0EoQbWs+h7saUZqsIQuN0MUXo
Cscg+76KIRVTOzfGRNY1J0IjVsIDgQN+p1CY2FcgiATQsAXoYbqa7WGFtZzhBEDNTxT6mw2FwJKvLk2Q
5qpAsPR6/yJ2EA61W/AeIrDBuUJQwtyNLh7O9UVwGA8ml8WgEP/ktDrAQg8woAapf4R9FkRqA1GAPery
Qg6d0npu5VQSTzV5o09pS8n05lGnU1TiZbjt5qbdim6L9mFxSWAg3eBLUDSrCS7O+4GJCqApLC0EH/sU
58+kyiFtwtDzDk7UH+MbQ2t9WbTb92WVBVCMok7KU6tctk+ZoAaHheFaDW3mHpZQ9VD1/bDaEseP5LLn
Rj0wDNaNfANVMxTNPcIUXs9DsLZ2m7bTFntqR4TjDkiGrUCNkSsMR+lz9S6670QiauwIGiuBj/b7bl89
RHdmN2JdbiT2lBgNTIPBLV09tNs6TtQ8uhvdjukprRljhHZ7HjwurBvhiqZ6gVNZ6Ip97LYZXL1keggX
CAODNu6jd8EhZQVnBJ3znHb++vxcTWDFoYszDlp3oltFBdGRdbWtRNpa+XA9RFPlWfb6sqcttG4JuWyo
0/v9lv/6+In+ItuqIDqxBfbYBgeDEgr4glEXgY63dnWodzbQCACvYixA9djDeBkbkbAd4e6DJYSs7AvC
iSk3iyZiPEV9bOSytbUBhx75wuGxWzRAOQWbsldfCU/GMIgGPIkIXpNRSrRlAk2jtScIc3M1oGqpvQfQ
NlC8iT0yj2LHdLgoD9OrHrZMQdFVJ8RD1BQlCZ5OqwizSR2OlrYZUBUMKIfpFw0TzJVxt+M1vI5W4J5W
zlkn0XizBs+I0/zmBXa3f8NHCIEWrK3hvXiWuL5Ua+wQi2au+Yya0Qyb9EWlob5/Y3CWKyDog3KYFxHV
pjeqZQ3L8sGSD3ErejlVooxrIwIIS23GeSiin7uu/7fxJCQBqka0C1pX9BOjLaAytwOZRzcVdAkudxHJ
YOCiCMIZLT44JuPCeG1oWrMro3bcvDZUtlB9DHJS2vcm7EAb111FAS0qN2cuGr78JQlyBEyrgPg7NiVC
xKMPO1NSLQflGtgQ+tKOeV5gzGu08Sr7KdypYyOdqNUieIWqtWLPeMItpP8B89BmB8UGQ+xGH5j4DCrN
6JM/wEo9vvSU9wdRETneLlXdEMpDRiVRMxFN0Z61orO8mM52+/si2808deK4OR2KaVZYt8FSnj0krWqa
iGI8Ew+k0orr97n3sErsou66UzUf553gcbw97yPjlqJ24PrLU+MkVltUcq3TKrlyLoxnGpsYnVo4HVOr
1q3S6Fz37NVRn1hiGhytgASBafWGtRmH2e4pa7jMsYbLXGs4wt7JAQZ+S97z0Y7DH6430a60g9KPRsT9
SDjF9cbqgZaallH5kqjRU4lwaizKOHrTz69f0Sagh3xJj6wx485esp3hnWmEkU4FxxFTcvHL5xwVArEj
LoaX/jD8/Oriqn+5R2yIe3rdHf0S/uFqdNVV46dPLkoVxoOZVwSvdKNJJfZEZdlFQK+K6YfDILdMgDUF
GwtYShyYDCVHdp0N9VR59/Lj4+BX3MF7a4FqqxRmWYc2G8DDuXximYgPtTx1BIKoJ104mFpOBMHAmZ9z
okNk2AuXK8JWMJmBx4koNgwSZwOJUmYQoKob3bKJypDE/ZDk0WoRnFzKCJKmEVQ9njlirRNd1X9k07sm
Gyw3cqxmj/DIXYDj2BH1aLrw69NT7ujOWdNKrKUTqqkEbT9HEDOOJlwqZbRK0P1IZgHnrRwxtTzsjY4i
2vaHZs/BOSELWBWr2S8ubO6GlbsOW+TBP8IadDVMcK21Bx3hVwJt9Hm+m8/vPvhhL+D4pE1HPi1d8tii
qt2+sxwNvghtL4yn5EHMkt+r3yRsDGEE//PR1f3VT+POZTD65XL8dK9DyTzlyDFfRDb6dTPjzFxyZf0b
t6joNFKiVSIi9sbEUV7KtZHKzvtjPhoVljP6dDgSoZaPzsfhbybAiIJSqpWOUNywhK0ER78SHXsI9c/7
QMNHEB6FJE7sO9brmEglxE+eEQDu4mWKLi+H2Mlhotyw1XTD8VtBePlLlRjDIt6+DZFY5rya6p22RURr
x/F3EwkDnELnnQQVXKvDMAdDfSGihoyKzddSxU8Gzhoc7GaY171ZU0QyURk7MToHnb6z36M+7z/IA7RZ
3KDb0VxVtkgUK7c5x8/Ir3xmqpPi1WaCsB6osClo/PsuIqm9H+pfhm5/SRTcGsDHtldmNGUv7WV1NLG5
QgBCG6fTjzX6OQy+cM50sBHU+2gJ0RrA/6VsIZnE7R4maHT743JXzPfsVXmhnkePbFlFJfh4SmwutrjG
CTAfT9FnOGEalCgZpsnNpIWxsB1wagwUYj4+0BF6yjUwSnTniVYjMF4utn5q7Jm0yFoSRRySy/n0yVCg
o3HDYXY9wEbc4iPf1NRf6qo56KNDiGAJc3yuvDSL4YreLgJtpi4SZAXEgrp4RGEkqjyMzRwKQ4LOfLXN
3Tjr1QHriKcuXcRxmJpGFus2hVUacj1lYHQGt7BXavKx7WWDZOMBlMyYskHd4wjBfayRQB/q2elwKgYr
2ga07qR8gpPgCLE0LHv2WznnqhGlSXnoYUkoFCtsN0BNNxpQDBui1GpGasleNYIMAhN5VuieQd6gDaHG
2kwm9IXrd69XnsQXEvGxg+B1aogcwqqoOMuaQyMfxfvXo6rkJiCUSfKqfMgRTqm6L+s5DdwK6b1vAgHX
QuKHtXsDsVBluiFHX0g361u6X93S5eG4jpj62GAbYkwyjh06E+1g5VIs7eOj8VhjiGOcN8IB1jlsDOwX
jPFOxhlu+JTDDC/rNh76A0xDxSQ2OAiOPFW2bvqr6yaI+OBQGpr42CcnWvp943fb4wlAbb9z6urGzfhc
Y+cT66Xfwu+vnHjkNAgcqR8ykLL06YP1uMoCfGQIWaNmQr8teSCztwhZxm48PjhKVPYoCAJMbu1T53jV
ycyRlIeeHk9hxRb9jwGfLabM5ByhoowPGa0gyOeaLlMCdbP/nG1yLW7IA/VlqSdDLKt3+YZtg1QNneSB
YbG/ii6u3nQupupl9OgYBfyl3J8vMdJHq7TW+zkWhO1/xXpPVbW9BZ8HU7NAJbT/nxPyTKjVbcX7jMTN
Y/T7kgeExsOS4h6U9lKsRBEGSSvgEL0iNpgPPq7L+udGeKNu5ovV5n27PYc1CKJpE3z1tMferBQcW70B
CbmTy+lgKnR4BiMO0VPOodWdgyFmm0H23tut1t8tX8bzLTErCbJ2CHnKYHEyQ5yKYWFF52u/MIreIEyG
6Hp4Y0wL2XLrJnqsUAKJQ2jOhkw3Bzbz0tnUZzDkpUhqKWCEB9NBoAkCK+Gfs2GswaXdvoFZJZXY72eG
yoZs22k6XnIJ8I2Y4iwrODhBtVU2LCcxTBhkU3XNQSZdLl9JVLWGvCwIMKABysb6bpDfDAeJ2NY6YjyC
ItJowVIEM6N6TqF6xtaZXMLqZHJ+rqZ8BWvvg2yDg6qzcJYhKCuP1YyZlZav4z4a1XzderIciQkIL23o
1W0sWESJ5o6rhRsS17RmBzVfuRTd1lOYOohpc6BJV4mPGiss2E4w/6nYNackwnhpwloFHydx2H+VwCw/
EcQ11L8+gfKYAECf4yVByOuum0cTDX2+6Zq26wmGnO+aet0iRtxgoBs3kcsLhLneNJrkjkbeJt+u5u+g
Ts5WS/pxkBHidaX5maAHKJt12cwbK3zIgSaVN4kJbX/ku2u2ruXvlqtdMXnvgRiupnAlrn1rPhvDIcBD
FBWmlFn0SPL8rmnKUkJ/8/v4/bbhHWKfLXNnQ3bRXf9oVnczl3Ca2I62WInazWw6se6a0Yw+5ptGVZlY
eEH8DPIRQquO/aNmpxw4rSnJ1CAWhUNZH8TaRUE4dmgv/UAGnXb1gulB4x4LAUZbpp4lESwHYTXqTG/c
8QB53pjbZVyYlrVKgrep5KmwXUJkPhVLEMigLAy2iC8/lJDMAik0zWF2gCt2SUdJlC3YAhOLo47nOC7n
GEFdieAhROsgk2mNOHQdKA1fuLNM9OJAUmP/l3hM3xnEQE+e8T0QQ6BynpBxQ0qFvHGq8mEWNu/Yannq
l9nhHF7LzFjOaWx0VrKcmBmc2N3P8iYbbRggHuVv4Mx6VpyFbAALpNPwkoeg9eyuPoxDB7JhS3mCk7WP
QdPB9fCIU1zVM3WRoHnUxTBnL42ChEiBO8ZzaCA8P5/s91MDsfY5gQQflPOJ92WfZeyCbW6FCuXwkqvc
3lRuSTgXJXNKO642F3hUTod7Z3YQ+nADEiobaHq8gVAC1lk8ABuWrT4S1KGmzubQrOXXnBdQ9GBRI9vO
r+rdig1klUjeJt7qK/7kp7jYhcRnreaZvKgwlkNdMUp1OqG+81tIULc5Ks6hYFq94fm58xmr+rhqmEvZ
Gw5K20LxdrtS/rJHxb6uzMpcjZZjrTsiLmo6zXUgAaj9wKHWnvoe14bI73i5mkzsk6Amgn9Du3WuI9XW
ole++O619ph6tYozBMH6Bnp1FTcXl3CVUsTMEw6OKgsTuU5Ceu2+xnijyrbycByOwH8eOy5yFW9A1Ibb
fPe2WOSru52vqw5Cf94Qe/N074/LOl0nruNrC0UJnxzVIIvh8a/sZpQSYNcQgBEqtLVwk9kptJg4L7BJ
wEr+OnjMIT1g786gFk8D0wzXTkzqaIaTEm7BepZWUtWhgmoanEyS9cGs75p1aH55QmmiEtMkXkeJOg5y
b4yJHV1WymHNtPbeGtAm7CEIw2JC7waf4clMmVdBaTSbEyK9Hpp+BGGBPK0QjVKYMA1k1Ovdi3gXN233
qspVQoq4962Oc/5XAvvfCNi1RkqU7dYHVDSVMNJAwNueeqw4tJl2Hw8Hzfh3ddI/OYPGVTXl3+FvXeQF
6qu/6ZFsI3dM9NhJcHqTvz9KT2u/g9JMj1rCSiXoIfIeuf0YawN+otjccqfDMayTaqHIuAUcVNM0FHyy
aqNdZ8HR96lyGBEqWFGh8vSRtE7QVrlni/UUHmi7k4nW+AOaB8DXJHI+z8cnjr8nMHBIB2YPAOKdvH2I
bGO7WqkOcZls8qpMzp4msI5303dN6hliS+NKpzKn0+NqbCKJbhCCUhLLzRu4eejHn+33SYMKh57ZIunQ
1we+0NmyR3KJATRvpV8tuzblHoepCs0h0U73ovwypf4mwbF47R58sq2yu1RTdzrEI6IcSVB5B3aVjXrL
3JBJMOR0dGJQm7Cyy+kxugu1lTsExZkXCcVEo0TlYxiz5MjxIE9hLJBVlElsv5gd2y/qsLLTUYZsrweW
47ExTyWzdEHLGVZtE3IK1YBl8DTeVOXIWlEb1/4DtZGYiol/xXza39Rr/futPsd+lEPsp1eH/dXIXI9x
gv1ddOGPvjj/FzIvl9jv+yrkuWt1FCZeUgV6GU3JudcpI6V9p7xz2DIfeRTXDJeIsBzBMLUMnESy6m5z
x5Q95dxgE2i+9G0/9ECO5I6D3XTSjie3nTT81gS3Geoz6b+++e5bVjU5IdJeO/AtNDKNqgHE0kPlDO7E
wp+97uqXfMz1yrmjJa5+UyGWr12ando99aL+SfD4WrNSfPe/DurXD1X7ql7tryfrfeXWe3TseNTI8QYH
KZ7CCHziGOZVQEbolKNFZt7jNSOeiRj8TJyTudYreaM8PYuAlS34UQKI6fEGndK+ZJ02LrqI5qp6bDVk
QxgJbIri20USmdYp/ZH2/vfixgNXKeI9XjFg1LsAUwVDx0w6ieMErXLExYK1wxYIqIkwi5AIf62n0S6N
rd0uihHGxMHpibYV0fNHtTmY2XryDyplsg+UkYHL68ZisjEaByV0Tlrh4WTBwBloBoJzLmd0djF4Icpm
2m13Zjht+EFHb1TH4q+80TJVA0TXcn8frYGGdbsMAvAG2m/v8rv8w9Q3Rt5bdqCaPCBBGH8CTdqrksTC
rK2VScJDm10aJZxN6RpUELcb2pjZgeIsRGWk6iw/7haU/7oPEj+UYIZLSQeyUmkB/YV1+KRSv3Kxr1er
m62NUFJO0LKrWxNsMIDpqtEoQh0jqnZbYUa7D+5pPjoSaVMGE/vT/ZaKCgmb8BEGEmaKVDFlX7YWSSOM
QFjLzaocKLucvjYnh9XTzyW8gcV9shApI2I75al6FB36aaVqXaXloMZRYpc6HUvijDqqbFol6eczcxp3
ZP3AZvrIR4oJVEBmRzD/ORE3vbYG29ow5sw74mn4gd3pfs0bbFCFAr0XlF5D6pO7ctiibGdQgka5eRpg
88MbsLGSdJ7Hm79/sB4NkwLxihPuH2tCXX+VvsqragKhVYYLtYltnb6dn2eIDOYqUyYKKXNpG5xeOIM3
40j3zs2+opECQvqouAKsjCRSgXeQpU5H6TsGQsdndEadz101g1Zz/R05687HQ7B32dOr7j64yjp0M8q/
GvMLut0HFzo3j/ohGnlvV2tPeT/AOp9+v1ztdqsFXbzKJztvrN6cymNKiAYn9DjJYAVEyvsJ9uZI/Ymo
Mi3HeqgW9ZVP0d8KG2riD+w5IgGy+JVHi1ZPb3KKmwpebuIpuzNA/1CNAX+UflwcHojFPHpjgsynzUHm
uUMe+2BUA+jpaPbKXh2X0YHnJeu52z0SmW4k4MrzOU0exBf8sg09UbDanQ1dZmK0qKTixGByIF4+fH5h
rz1qYbni6p/LVxEblZ+oueJdoNVTP7ppaQc3XQ6YUyy/vEuSeb5FPDb9xEOiXf7kH7ScJNVdqJ9kXRer
u22+X6+K5S7f7LURF837XbBPib+6uVA/S0Fdk+SO5b+ru10yv9tAEuHEj6NfuuOnnDuy63eRxdK1t/+X
G+TRPn3iu6m2zNNffREhNBTPq5F+tAhAWOYA/h4qvuhREuQj0GrdPKoS9q+WS1hnEjb0n9m1DULnz6za
dRKlBJMT8wShca3FJSdn4YTQvlxEJjF0oPwi2kjnttDLlXfi2D+le6lStHbmrklxqvHWktD5j3z2jXqM
KjjP2OZpJwb28gq7m50lTCJH58BBcybYkMwJEeV0BGnPg01EzRHwmtDhLPqn2Cgno+ux2G+sotsIwQjU
OvIRf0Aq0z5UXeNEFagVJ1I2fWPPk3g+WrEQTZX4+XDeBYcxpT0PISKcdxNiOFk83e9X6uS3N1FJwDn+
xUqtaFK4jluR3DKl1y1MJQe5rJMyKxjm1aSpbFt4wttE5xghzoGQBk1wmodr7SDWhcEUSUP+IiqodwFH
78MVDvgXdnTPV3cEqz01Bxa6W7fb+qJ0JFmrKVxJWn2EqaorsHEYdqTUXhFIQ5+tWDmOqcavqfEGaExP
gQHV6oNIZgShCoYLYxNR6zIRuB5VFWr35Btmu3lFZNthoGDrG7VKv2//lTJ3u13ZjbCLKXcSeOf/BGw5
Nef/HHIRIfM04GYfAVwBAW5xxhE6KpkxEHAWCZy9joEiZDkeht2nSBIdQD7xcYUQtGD0o0V1eBMa3k20
QC7+Vi5uzTddA/9sjyEry89l6WeIBCpgfNO1UEx9hck8l3PMzL2nTz3Jb9sqnzNkGyiZwHLG/aYGNufn
yhw5AdTlqoTMYDCl/ixKtcKcuhZvMmJBUNxcmw/WymJMvUOW7gEV3D/LEkZk4d14sHrgFfSHRWCW1EoI
qw6AgyGV4HhQ1wQWrH2QGk0TyhEwPIFOj+Mja7xcjSpztANutCf+iOZ3jmRG18YdS4ftGgpODxPaHuU7
u2hcwN45sBtK+tppNIs4J+5cfVpJbtJu/3ftvvWzgMRt54i0YNy3pfRP1V8iDKi/iW6dJqn3GytWbvTm
wbmz82noBZ/3kI116XVukZRhZE9UxrDTpX2x7MpC3qojtQwcUcChFdu30rUoHz4LP1XOFESbEhe7z3/d
gHmzt8PGHbj56A4MRasBCYOYMGtG1ZWYiLB70pdwK0nN+d9wlMCnzdEWKJi7qNURVrkVrIIzrZWZf4R+
1Zc2tWsqwC/u09j3VHy5EoaPbgC5P9Gkr+4RfeZRjANWFSy1398qveJF51a4j6lrjz+YDmpP1oL3p7CD
mA5mcJXP6s5AHHdBB81xczSyoSBXJf2Ct/5hYoMvUONryVtAvccC44wqnnIAyTe7FXHkJAAGOg3n5LI/
LMKVxbIYyiLyhV5My23I6vmRfDQ29GQKfSB2LsHHArjKBG5JEQblpt2ejm7GzhtwAuVJHg0eYqNZ/8rX
9qlYeiZsEQ8rYZkFv5QH9ThuFSepKba6xPdSHkPFmv+qp6/dLq91e2sJr2rAgKU3p5M4Ar6pGXVkCLRR
Bw2OiJZhwEC8uJDjYXWEAqizqMFveqV3ga1iFpSTceDjEWZDq+cjFvQnxYPvWOlWbHSPbXmuzTqLg2B1
qSUWopDam6O9Zd8+HiRGFntrxeWukI3LFROto9V7oXsOK0nn1vXp0PvwcWab01zV1i2lrsFoW2CfEBuQ
aGCPTwH7Y9xN7zbYMbpjky51dKFSd9NYgWTLCddNhd8sFnlWIC1FU80+lXERI5hM916wwtRhDTgisG6K
iGE0xbThsH7KPyQN+X59uqeWC5FzMv05TIB0nwMNzXpghaO5zrlBvZ9yYzzNVlrVPaXEoNoZpx+UJsS0
bKvtzqwbzJbd+8o6qriEWDOnp09NTJixpMrqsPWHEABO7d5uF27qZZp3iQJKnCZL1WLVz/ExtHkFPRAP
06io+DWwhxig1saVZWOihooY22cSN7o3mHEkzE4wiWBZXxFb4fyrrBISSWB4A+djnOQ4As9w6efioaad
sQqQf+2jrV/p1ESFTU1ErBdXaCPFDDLL4ekIa49Y9bAoZzs72IWbfZ40F+fG7BfGoHgGW8spKxTX29CL
57u/5e/PEtF/nKVwd51j0s7S3WaOV5WddcYg9T3JHtAj72IU4GAoeaYLMFeDx7K2Z7tikb/ZxYv12Tui
bYjrl848wwohtwkhNdF5Qz7N3+tr3b10BkCiP89pac/oNf7hulZFzR/bUeiZ6BHcMO8LvjJh7rqm8mF5
SXOlW0FqkoNihU+1XwKbZ/JD0zYvaFp+1r//PFtNJiSm/qx//3lGGy7/mf/+82ybbvJ8+bP+/efZbqW1
NB8fknsWmej9MaiNk5syUaOgG+OecUROs9+OGBE+QakneMbJR7LK3itdZ1lZx2eHYRrAaj6HOpUDYOWV
B73gXErJN04p9wEnZuJpsbX/s1L729W6Ujnf1+ouyzj3Pc7Dwku939udOyHezQBAvz1BjBX6+2n4Gf19
FvZkuQkg60ZHscN722iYrreMxigIWGeU7gauYagzNZY/zsNoGv1kFCRyhurA2T+qb8p9AXvfiM1A11vj
XEiXxlREvwnC8hUMqx1ZYQLyWrP7SFh7nyF0QgyzpAn9sSeAJcNuLiPiej6VeMoCTw7etmXsSzco01R7
Wg2n1vFRTYIwPihNCsNHWBwixr8w6JyiSYKaPx6JiZVDE8LqvyLas0wzvtBe5xOJaM6pxctDRkcH4RmN
70FBOfuxhiK3IXyg28Hlx5tZ3e08nAERIfpAQ545O8ARBNcuAbbEJAYfg2U10XU0g6eV/sbZHqVq/TGs
cbN7n63OLJ3yYg/yeZITncwl7TphQIctqNqVl773wh5A+wbGpljGc53M3a896UrrrKK33wVIl7EtFnfz
irOG1oyVLoBak+lAN449WQcQq2L7RtfAwZ4rrdI2OhCVHdb4cyLQOo9ieKQX1uoEmNQ3SiHs1V5juA5i
I2sVLkcmpI32wpi1JjNiDJ4WE3Ue11aB0ErcCik89NkxYFcGY6hMiAnFwLKWRmX84HiokY3aZB85CPb4
pQynXGSwp8N/hU80ipIWETejYpSIo3p5b9iHSAZgbqHLWpJgJoywnBWXOBq61aCiIpHUjfrONTE9HmH4
RDXJGfz4A9ICva8CwLEv0PHED07N8r/Ek6Na4/ET2A3UmPr/pNnjUZiGa5U2PDJNN03Jf9KHD0yp25mm
Yh96p330Gnp9MH5Aj0xwMd+b0ONr2nQbT/i9eR6/y81jwqtKH/jp4vpOPtA3+hPzijF93aW5JmePo8cK
kUiU0dTQpfDuR747OPDnPSIY02G+OV6uFT01BfdbCJctNvDuybUJ4hxrTZGVQd3Du2YXMqW/gfEPG37X
z1GxO2WKhXZbEisU1iWFTRYk7ojtlGlsjvBbhj5V9SJsJzWoT3FCU8xHRnWY1JbCNV5YT6y1pMnYKhoR
ho/OkWBkA9cBt6xCyOZe0AGeNur4/3nD5/1BPqxUnyNKXSN5KHujleyoIDgc2e1UEnYcnTVV3S/KcE1H
JiEJSxTpfg/XCG0VUgbqj8XCmZqYchMxTELyalAimKaLzlekFZhokzCOaGO2xlC/wOHKkeE3SuOk2ZTV
t06HwCuzzimLnlh7+FZWiU/l+E3kfHidIYtpA3/ki7sQzPCbdwXSU/D54MScG05qR9zGQ+LITEhAFqYw
WgmW0aSJbeBq2cQCudZCzkIC7KiTp5wJsLonyIrFGja1sotKEP2kpvyT2cicc4LMYpCO1/U6zquwfOVE
W6NLo91Soshphj2OWe1CFbWbw1yShKimOFecBx6a3oaQuInkpnBghL0JWWOWRk8+skAVc0q7Qkdc/FGE
mVP1Gb4Tq8RaI6c67bB20tPCjSt4xMgKPBA6MKy/tqKKk+jic3/YgjXNPoHxynyfLxJi4WabfbGY7lmG
2M+L5c0e6p09CW/xIvARBC4cdyQmXHB1cXkxLVTClek3FyrF7b79h+HVfWdwoTJpKiS5vVjv9tvd+3nO
FQcXhcrppbb7QdC5YTj6JRrvI7o25kBdFJtQsV+e7K8uqMR1/C7e5+kiDqRGej3Fa1jMU4HuU+rCDA+o
ks9bMKkZPX/xxdsvrkZ7km73eDC+GuP6kko8uZiqIokeJS1UOOor73OByzMiM7tiPc+jT8zVJwgP+/mF
vL/0EI8wJ0mIP+JAuPJeX44VzWo4emZffk73U2IH1lLM3jlf7DaVD3bQu+hK+dItSg1/Wi/6+W6ji28u
G76xct+oh6x/njc+DIqkS4PnnkRyTRNBc9Llr/FoN1mtdrgwPebrmAvye8wCfzHj26w0XbpOqjo4R7ZU
HnfLCyoS7HEcosSNTePtNl4g+cu1emr75fu38ZS/9bjHHqJCsw2IY5NWs86rm8npD6GAsF2/qab5YD7H
F23aqXRRHe/C62ipyalpnpTe1tNExysUxbM93RoaTmrUH4dG7jtqwa11kdRDr/VUVqYbybQSWyz6oc1R
npicfPUunnsKoRHlVCipvwucsPnLpEGPL4Yog6NsLKwiqxqkEB0tjZFhjCH9QUgDRJApjVOMu5GxEZiW
Nl8Di/ivdVw0jPQaGQpqg3UJKMKjowyCIB5eVzs1i147nSoiN/rNLFCvdR8L8E12KlaVDALNMHgKNCXz
CMFXl8OZmbBrX8znw+NHtvSowWeOnd8q+yiBq48OpRSze6iT8mVdS3twIh9bmT6NmLC3JsUbgyjrw8XG
0ubRC33nA50kDaSE7+W017W5jKoBngPHt4hNNk+xKfpYM64advJ6fcDulv08/bqB6H5fjZmmQ565LrFl
bGV4lDKoTSNa9RnMqLH6gQ72N6nn3aFZhoOkmsKNhiMZc2g+rmICZbN8PUWKEqnwREXLSkXMqfIOnJW5
dLhHyhPiB/smJz8C4YSpQtZihlVbJlCIUXFHiNBYFTdwkgaPVFOLJafNkudsoUfjWJVYZ3W5GCwkolOO
PBRjHNdzlueg0Z87hw+qwO5c5U5ennwc5oFl1dPEqMGpn5jPmwp2T04YRE8jP9H4NhdbN5C84DgvPugW
SSb7PZEvQyOJuy/tkGHy1smtj1+cEI190ifS+uTZpRd0YKFG6AyZphwLugnW1xghD8pxTtxoZwRaNy6F
m7h5WCPPEwusuQ77oweKUOC8HWhCBje1L1SZnyOP5jYXCLvmnPd57k3cJU47wWaCbqTl2o7KNfhX5zwP
HBgsGPQmMK5AfqKy+cnoGs1PzPqZxI5eYKN/5uXJs/hELI98m9xcQHLoVRPuaaV7A6t2xgkXsglzbDEJ
Uu4YejB+yqN09MpqCdmXJyHSZDygdY6FxJCn0hHaPqENOqyJA5zUp2pZh/4mxrJuUDZgfVvLRwf95LXx
Ch+9dv1c6+L7UTZMPYl1/7ryTambHUpYeS6p1a+SJzQ4klCYwnOJEk/2G579uf4oMOF2XeCMSy+3+Mjj
BwE1GcBOnLd0s9Xidbws1o3By3jB/sed1dwZsavatGFQ9WmI4X/C0Rn/L+ogbdZ8s/uSD2WAxyvRGNFd
Oa/5H/ZWDg6dWNC1B/XmrdwaT3Ynz8z+TzRaiTR8OOWf7wbsjYfL8tix3AQIUzjQWZZSNu4IODNWIrxD
WmEVLKbyCTXCfTGtBs5mLs3i1LSGU4GECGPiU5dMu3VoPGJ8aqoKjuO4eDa+MRtN6VGIuh12kxy3qB6G
2a8NIxZz+LhGUGpNH7NsjtOUCXfb6oexDpwCZ704FMUGBzA4Bo2lcHhVZ9jZbtEYebUBw8nm0NoQtgYV
GcFxeqt6Zh9l67ZWhpbmNwesR55CJztOi/gGy2PEH+IxxrDfi09xEByKhK2ZjCijh5PKcPq1LEr1lUtk
5VzXKaCIqOc4/R8SvZ0MrhcEx776p1Gy7nA1gOFRTDtHCfXRbZ5gJmr7WtXGw5tSBzHTPdCsnsEzeOcb
vpOt8cxSOp6hmjCzxybyC510tLT26OxibXpfA/I4yrXCFyFrRZEGAm/5ZfinVBwtF3I+s4rm53215gQH
6rYaxG/N8sLtfj9HjNkjgFsTjLnedO12rsFvHQSnVYs2Lumim98iKuktZgvWm2vHgi+F5pV2Gcz/6LJc
NN6B6Nec1aHLbkV40EgT0berWK2lQ/ezGZHD00oM8pLpLf0WUth8G3PriY7mW8WK6ka8tc0+nl9eD4ip
DGaIfUpoecXyvMEgyM3Ixx9T4F/huCeqKjLxRrGzAO+FmboOJFetmH1PRpMy+0RtkNLHiZon0GD0BlPb
H2TGVIbVnbmsbsvqQGZVTUuFSBQk5mEw3e0Gmtxfcyry42aOMuZaXoLLLGtBUyW+thhmliCrUy00rLj9
84Gc7P63q9CTK89wN3ikLz3l0tvQE4bCPP2CCb3H9N4ziALhsj0HaTQcfdaiOcdV4szZDJYiLud2FZCe
lqY6kkhaaTTjVKPlTpfVx8Iv/RxZaonowRN1Upr/S/z2CjFzYjRn1sP4NlGbpBKeeZv4lVBMtL9qEmcS
GHT6duWLuVzAh7DUpj5ceb5arO92efYGCnAOyXHyLSfaDoJh1tXOxqF4H+Ox44A8KOOSMnaDu3c1abCh
jIjGvEGMRXtSwDmxt6Ic0k7OEpUCb26TiP4Rl+N7nxeTTbzIz/hvstpk+Sb6pPfJGWc54ytJe4bLCyJk
zjQkdUtCGJzdIntKPRY4bcf7TbGDJM5OvDpgjunebWIHGCgeBsJ4pwdOcQVN/4KoTLG8UO+SyPVR+cX3
On/veIE/bK0fglF8/tt/jTtPiD4XhFXuk6bDvbqe2PHGwGJVV0lS0LjJvR+SUxosPvawsw+lGae55ZgZ
04hh00RaYx2ZjwyHKXu8oIiH1Zky33la8cX+KEtpSpIU0Ixow3RCLHeJSYXF0Dfr8hoSOM+6i2L5E98g
vvQifpCb8rnz1HwXTRX6fa9LyrPM/SZXzlcId2EF9Olw2vG80EkL/b5yTtAcWu4sNhnj3LhQKGrTM0RJ
cOJI9nCou9yzMiGaN5i7NvvX09w0v+BANTLrSKDBF13E2cBZCQmQ82IdeRriz2HKBwVQxVO9+RM4uXOM
CCb8DHLVejh+UNO3KtePCWlAVRR5snPD3oDXiX5l19LFbrWmv/N8sgvP/0z/Wz8MZDud402fbtc60WIY
J9vVnMDfU3lFOJ44wTKnfjkHtvXz+zy5KbjT59viN6SPkQ7hyeB8sfrtxKvmpwYpJgiuW+ntfw30jx4v
dz/OEPWZr2X0nzUPytX30eRnNXXXQKIDx8d4YCJ4gNhtr/9fvFG7CPaSRh61hFWa6m2SVWS6PDgcV+aY
v92ox3XxkM9NosuGHTEFxiQ5f/Xwhmfph3xenIiDbk0s8E0Kvl6Kvubp4+AYdf4+YQOg3xF5wuK12sL/
HkBwAPoIEtx3Jx43wQLBs4V3s/o9T5neLcoRR+aZoC/kdZ5UnxDUHIMC0bEWx1Z7OV/FOCg5AolUQMJt
Kzhaflo6xNNh/7Dtfbw+ipOqLVzZdUYfg00kHOMU4QI1VYEbc3kZJYgyCJt9E8FA4iq5XzulUZHlIySY
3m8gqT5Ygj2f0BL5PE9HeTwOujje/+IEke0+DQxt/bJeBIFZgkiX1IWeE49ld6FXbsN3xbZIinmxex96
syLL8qWnzCp7vMzEUr6gj4kGEOP5Zh2nWGBeOwKMnwSxeZ/1elTuqyQaeT8x0FGz39G/16vf6O9i641L
pPVSUx+ofMW+xKgDdJQpZlp2qx8JCrQ43zFuNMiAECVENb6q+dDn4kOf0ItRPu6kql61sa8pqeBfquxD
9IVWLCRlGsMhx1Alsur3VDbqj8/9lH0cOn4m3vgEr0GYlHV+nbjWXYbRnkQpu6IONWXwQkNZvGD4WehJ
EluOs9Tn0N69wWeXk8GkEz0LPAFqfVjoTzs2Nk7a+YF96nucPiUb+rZSU/a8jKOjd6ZX+cbU3TourzvK
xRH/nLPsymdB6PaiqebyYeuo1x+s2R67lTP6TW2VUDJyZyzuirsP1xSau68ZMBWnBWfhxitJWiXAkMXm
HgTqCfMXvUsEYBccrvO1RZrZROyM3qXzlo83zBYHA/muPD0zO32QITGAf9M9Ih3wo81ZT1hWkEcOtsNJ
Ws9GA+wY+ALz2QRN0I8EHYBlOYN/rZsu6FMdTpvWY35Zb6WZzhCT8YkObMa09ITYUjr2TKa81TyzUhFH
MxUcrp+pZMjlaXdYQYe6WysV2RzItRft9htx+9VtWitMt1lF4lZmT9eDQCKzvuEonyaEFMFdDqOL7VGn
VT5MtYyXOQJeoBOcTtkp8cRMIBauGdZRz72Gpw1DT4Z6fmjluK6gmlLMHNZvt9r7aAWsSxj68TgGMJ9+
a3sDBlFPF7YCqw5W6vW9EFbDB0X1fnu3SIhgP6ZEBRZLdgyFt8akmM+/023hdp4//GWzujfXb2abYnnD
dyXqp7t5scy/tnersgJhC/hiPYuXnHORdu7qnq9++4az1+FqtVqwyxF17Xv29Hv0JgB/gPZ2yzvBg9n7
+3mTVaaYV35aMzj479p9bIQG59i9Hsy3qMuOiSAK7tRoNuZ4+c59RLQMeiQgGH4hXmYJJ66yt7OxcmIl
EybwaB0R6GrqhKgk+J3qmIKEh7IAWR4KRGXwJzZerRPCFqFQ6ZMvNc1KA7Gw9HMcnfeDpznRp46DRwy+
g5g6ibwlAwDi8fPRBTQRmmiYVy122+PPBFpk+GknYqJ3LC0BnmWv99iozEbUKKUljwNMwTacRj/LNwVb
VEAPW5uPiI+VpzpuLhbZfpla0TYQWD7lqdS4wv/BumpI+D2rW11SdyV7quyvDW2pSQlCGdH+3yziuQ57
yTzLC0k19SJhYuBpo5+UkGqVLogFbU8MaWiJaDpTEg6HtGq9MA/C3FE/jjyRQIkXE8o5PlITOsOL6njG
tX1Oh79pAncco49gULyRHIo8FG6byj13EsDY6r4xc3EIQnttPee2Df0QN7Ss3WbKbhaUmTl6P9QUMlO/
j+DDsywIe8Zi38xCRWx5D2uMBglONZ7KJeWIHy0nXSyBJM8NQ/2QqFFs2C8JlTh2Ip5ZRxkRsEg8NoIV
XWphS3NOx/peu5BxB0spRg2he1ZhGAGxino8ACEcxcYepo5fdAjP1M+01VRONf8wysaoHoYZ+z39PX/G
vz1HvDmou6RMyurXeoa9Hf0FJx9VS4v6jj59EFlT/WEgIN069r6J6G6iDQgfmJext3JN4icjGCONLYDg
TlBwGXy/YtPBsekdxZ/iEwKDXg84UW2IKQy3rRnR0uMt8FdtZcCHYSSDNekTdBnYqa+m03lTDFMC7BUO
9dwY0TpKNBrWSaC6aMBc181P3kgjQ8l3HZjvzK18eqjma/lbReIx6g/EhU9Kfz/OXe6UIy7n7X2eL6O/
JcotFz06KcJDeonvGhxnkD5KRjDPF8aLEm7XUWpcCbYEzuDive0973XxYWAr6m2UGCe1eLMzph/3OnUA
uxNLJcssyuTyjnOvGyjWBDEdD8HCgRwSJbrbHJ/YytjWAvW2k6WTN7gSwrVix6oNhNxvyqg69v1Bbe4a
EksRNfhIY/JkRYOP3LnoZncbdtGDfRXP2siZwbGx+qiXfhqrnuo3vwtCYypCk+qbqTwvpzx4mnTKu2ol
212+1ifn7qPyBFFCsZj6TWJqGLgRRhmmNsz3qZm07yUT00EdAaoDj+475dYXPVrr/hq11AtSDxCBXo9i
WRIcoOPeSBU6qZrzzJREHHCNW2Tc8hxnjXDe9eK73QpcVzJMiIiF1Wbq9JNPAx94Om39R084qXuld35D
9xxuSX9XZYr0w6DEk5Xugy+/73Cyzl2918y03x/swuj1s4EooobHCGvB/obVCE7SY1cE4AcVy6Gmxo2z
KuOQR1DueNOYVJNm+L6ant286/7xnHVH6YqW7ilffv9NcPGMa548REdAp+xKQPnIaTYS9TpR3yYS1Vbw
/h4oeQ9EzGk16pq/YaiVf/vAKArlIK7UFn5P9ZUhoqmSvyfR6B/JWP2QRI/eUy8cnXJ9MtawQNxlBHjB
l3n0ndWeESmG4cTo03ENX8YlvoSxcPWVKNNaLNh0oAAwFQr4pxp+YF0d9UlQe8aUHvkWqSF8pm2VcUvd
yTnE1jTqwBR9kK3OZtGMmuj+0VPTi2imDFyaetW0Mwm0LnEGcWxmxnaR6QzgM+RFK8rUDPosUYhIZ7rf
oy1i+DWxQKhtIiAQyIbTTkUwCzv4i4OBsXOc+SYp6b2TVcwhKq+M+xwxTa+AGNgVv9T0vK26jwh7p8+e
YtFoJ6Jj1Mxc9Ow8CdII3JzKR0Yd2EnH1O1SsUe3sRWcIJx0tYwfGcU9OKuyGz9alZ3lNBF/64eERafR
ODBhU+gJQdw44NSypf3BYMrKz47kfIHiXLB/CsbKatUcTe4/mg+CTfxWMQtaRBwM1Yh164py4A2Yw1ub
XsGbPGCjcShv3iwEybOjvAacnEEJgp/RqvPLjG1KzA2nW5s5GQeUe+MGhi+/2e8LcFmqfNLpIGguJ0p1
waHpWfnR+bkq0zVwV6351qyaAoHTpx1ZKxqREWcYtHNEbuQDDWgaunDBn8yJwI9W9lqVlz871/+Etf6x
tKhuIqusux7aqXe1i/s97CpKRV94rbQohY9ujC7OFe9Eb4Q+rkpdY0X8YstP0zcuZ8dij0CaptYpV34P
GxFn1O6bvvvmn+6bZ+OD1jXqfF+sYUa+L0L3xoOC9Vr67J1fMXrzhA6wwkBBc+yvh+h1TohVQJa/k2tJ
JNq6dSKF3MLVBeriYnmXD9ZIZL5AsrHbdvuWZblSsMl0PNprk6yoIavZIgicBfGd9awvXHVFrsXb5PF2
aKac5gFWc+votitPgvDWTWZitqRCLKYJh3uVclFrHaj1ELTXCCxzSbbpuv7irZFf1PF7YdncSLkWAzDW
xDItAlfoW0A9c3BWcRFMI8J86yHmMeyRmDInCok3tzDywSRPNcO7Bulg6mCe6F/nYIPQgNmBnM2XkHbF
P+6nJldB7k0qJ1+MPF3tV8rir0ASeyiWYvJEjjGQfVe/jCDL00bRSRxjdH9ighWjQE0plokWTLQNrAgD
PZ5qnwo4q9hvs3HZzUkgvUWYKxMCS3GG/VxDHzocOcTl52Ncz8Tj70mZb8PNydGwkU3IZSb9B2h9nZfY
ioGJ9D+wvjDRK0KCoNAkaDmHgteybqDVnWsrAJ0Lb3RRPgFjMIn65xkfuRTRdXcHNqo0l9bKCPMc+flJ
zoOxh4k36ObdjdXomtYbq9C/pM1QDNOQqI6bVQRFxoGELromEmRye0iQwlgHInRdManTJHE5z1o99ahd
fr5iXhgBnBBH1gSUKdM0hol9+J1IbWGq7NSEdvLMfISpnRolIw4RDrJkMCtRqcu0/4b5vIZwuGV1gFx2
Kx1lRkO/EDbezqOdeXaHgj2sxNMJXYvp0sM3GdaWKmQ8mFeCWbDHLPKkGnNyu4ypLGPfcT0+XiZFmCSc
6QzFlafKmJHeEMTwinFbtPdvGscdVFmnvyeWd7omFtd8U7JQZXJ0WNneqB8TxIGtWEybZlhub7fdWxPw
nD8h4QVRoja+BZ9CGViLl8WCSLdk8dE18A0Yj+syJbN+Ze51zmT9FNdm0CYbr87urJ/i2u53/UzuoHD6
gjrBAFf6H/+cqEdeqKOAD9XM28FQ5+ERdjWEa0GpHB249rQ9Dg9U8zOFh1wGCQuIjf+ydMJXNpNVIh5P
jREokyGhN1OQBHS6Y/CNdYIoAoI8O4pzJpsGqZaOs8e5G58qfDQzGqbEMKTtdiLnCs4ckPhcbt9YybYK
pWiiwza/LPcQPXfSwZsPIwaU1WQy7IXmpMn2qiw2LC/D8hKUQqRkDHc7dK5HZSnEMbfPS/9SHfUmM/y8
vuAzFDbR1PfC1GddYkMR3FlPiyovq5nM3PjV+CZAgMzVPCv1VaiMqz7KbqWfwwXiUFWCT2Jiw1cfCUCj
fareBMz62nNf1TN8EDgMEEAGfML85mQ2OSg5Szko/e4D0f6q/F4s+d14ciVfQC23mxDLn7VKuwplsK7w
cxMIgQt4k2JZbGd8dJRw0DBOZW7tQLryPprCs3lSLlnfSX841dpsmVldCOmoa3i9siuO/ZkkptnAsCmS
Qg7OZocPJVaToDZuji7aC5xGva+1mEdZxZqD3Ugn2LpF69uonko2L555xrFbjuxgVcJCkKbs6Iq/3HWC
Q38qTnUmqQQHdZgeF/zeWqyUHwlJKz3mz88HwQSfAKXrENBiBMM95VfcV5y6IwYTHgC6ZFFTtuLrw95P
UnLkqk8iEGIvtNLgRN43WftGxVvLhNs2CdE+NKsqdWcLnNnIzKwHXVF5KxM9rs50NsxK2s+cq4FKTmxe
yXuH5ZW4uTyz8uv4AMFlIimnNZFpTWRatRsqZjMZW1iP2RYmcWcTtdiZTHgmRbcDp42EnQ8RVZZWE99J
Zys3DnYyAG8GZbNVyrmxFjeVCJRKRM366bFJAThZUhMD/euSo8rZkCjEadkaDqzSZoNy2eAGkb1lDzyE
DZbDJOfEdDun/r1A9DcqpAVixQ9/XPMj7r9+9FaO0vBYD5OmlTDvN8vS5EbqOPDz7+52zguuSV7oisp3
urrDx71xjtG6GWVikDQPT6ARNlua1Upv6miXfVGR0kMXZpgo1YSD5PPUwh1BSBylHHnY164PsnFTC1bn
5wRYg9QqjbR+mrM6lIpIh/OrxQ+UThg+Be2Yw4YYaVfCsgSq1BVxCMd38Tzqf6rK0u5IXxPK8F8n0Tbf
faML+3ZKqpUEplb02q2DLVfs169J8HktzrOmPPMOEUHT6j78U49Et3i7C5/RhT30+azX0zSb9k/8/lRW
Q1RX4VOg6I7ZWVdnVlUOkXAMJBxS5eiCof9EdsGm8Zgy2hv96CzyVLZC6srRK4m5xdZ9yYdN0uWMDhZs
OqRSGUPZ5CX8bhl5Ev2fk/3TY/pIAvDkOEHY6kuV2MwBwKxc7IV9kNqX6gNj0W1E3s4z0TJ12kWqjy/+
Yd5HtkcmSeE/E/WvRD1JIp1ZDYmmJR7coMKd4fkHbRSW/OlpQ4Ay3tR/kNO0/OhUYuGjflW1JKV2d1Ba
zE3EUI5+nvEhSjWTXzXyFs3Yj8hzTnKosXvgEAsTSeRig/kgyRAy/VWCvkB65wm1NlR+JYEdiIHxmBr+
Kwn/mbiGU+kwK22sMnNiCqO5zGZEhsUc5+dH1gduS06ptKWuODOxaZT+Wird2kpdW7zM2p7piuNqQk4a
fQeHsKk226msD/fmf51Y54rSLoJaCEmjbJI4nYi7lv1e5yGPiK1ChBdMJpbhZfHAwmSqTswlh19h5V2r
LwlEqpHOkLXdrkooQbxr56jayrTl7h+aNtlVko65GmhO78UydBdvsjKwfVNuVJ3P2mzflL012CbrX0n9
YLeSg16CTg5r05/iULnSTqrYidEGIT6eL0lhq9fh4uq+czENGvmcJ4k2AbRwNuBHVfm7NEO0UjDYYvla
yQe5ZfZT/c2wtm0km5euHods2mv2V30qLIEjBYPuTVywvaSo4NS3FcQFkPkI4pLj+Q8jru+r1XwYcTne
g6MSaJkMjusITL+F9e8KZu3wln9JV8pL5/F2C2tg/ALQPEml8qFYZs0IbyoIbyoIb2oQ3iTqi89nq4LK
+KQhcXYbVj7htM+lrQ1b/ZemYXmJVHIXqWRRXkEqWRizQStyeRrUlpeoDcVL1CaFZdBms8aJWFAfGaDY
rTaLt+5WixM2ysW52q/GNK88o4FVymyTTxAc0VR93j/oSNMOzWbU7ZhgGFLebAjDyVGMwYVzjJxU7DDc
O1sj94Hxd1Um0b1DSuU8zr5bzt/DySh+eMWQCnDJ53PtqqTvvteH2fTJ6p5eLfF8NddXd9v8dYy01ex4
/aW4VSjjVvFVVkjwzLGqUGQDExJ4qRJ+hAU5E/01jS5GV7urzdXyajK+mNaYiSx7DqBuMukqI0AeG2hC
PaAKoh/X9bgrNb3dB+JWQCLRtn2mGwQQpbSqzeTspgt0nIpZIOImazWqCU7Hg+vLYlCIBlqHzC3GyJUe
uTF9+AjZ1juEHrXjPEDip6CM3pIqNkLFH5wqlQHPEsnIl5XG5lSPfI0kjn7WieRugMMqmsEFNP5OQ4IJ
3L4QSqjEcNA47/esEds+19AmDBD/z66c07//qxfvxNrJbdMKXka9ADpYU5N9o/SKcmQ1WVMYRv9nyyoi
en1ZHYsnvViDU9a1iRs/htB+IirJciMFblSc6jPNglTPGFwTbbO4Ti8ri5vWFhcMVBIcwupBpts/A7By
RKHrZ6mgAgA6MxEMu7E6OUiINE9seV4ZTBKEeTncRM5rfXgl/FhR7kiM0mp/ketya5XAv/5qX/z6q1eH
29p9VL0lqiUsoOeFrmK5WmfAsM5xrvR4mkMeRgCymIHsOKaVOd1zIsvhAMe1maGvzeMP7wcL7wnDuUk4
P7A55jXxSIh4XG3qRIO45FO4yEYpZ7eoeoQpG2W+BnxN2lMNMvngKGQeGwtkwypAGpCFSgWxna3cRdK2
d3zYQ887eFEaIWhfSjmLzJtiKppwZ/QZrZGH00PwZtSiY/SsU2jWHzeH4h2zFa3m1hKHW0tK8MyVx1IJ
ey9xXSKkWIxaxjNzO5M39CT/YDemx93A+QIDddmJAGf9KTGHok1p9NwwwJaksBQOTZJfmrfUeLo4oGS9
DPm87QQXVxWrTWdcK+cWWyFrlKxjXsacaVr4ueOaK5FG4TYkpgN8hFrlAeGhwg/OtYFRrAM+9S5zHEAN
0YGQE15OCLD6oVHZg9Be5sNZSI8RiMOlbxmIW8tvlSqodrsQmym/on0alsonqzuoxSQ37z14qlUCC5o3
FTHZLQGXTYkI75lIqIh5pHeSmpQ+7DrPZGJJ2fTIRaqiXChnVIJ9meTOiRvtSaP86fl5AGPL6Vj5WcnT
l9FrMw1wE0ZYfPSFFOROiKPaokXnfYRIOlR4d62MK7WENZ66smnHx6K/E8Sw9PEZ2lDZTn/Z5EumkHGs
zclQ6iVZkKm2yHFtTqKeo1D0ehsMkS48NOrEoBywh8Q7Z5x350wn4zkzWXjOkNjtbJNvi9/yM7FjP5Ns
b2ecRe4sS+ZywdmQkNNGru7W8gtSfGYTKJ2ZnElnZX6lszKnEtJ5LqfUkKRb2N4li2KHtJ5cL/2uYXKB
C6o+32xWBESSXZUIyF01SebxmUZV+1GqZ460CD3hkljDrcMgpiYnmc6ikQRH4XdnGOAHMn2UI8ail4PG
+SICLkLuPaVBMv2JdRY6BZ3Y3fLok9oHyElj8taVKQc/njPGHutQGye+st/0GwSKodO89xRx6+0Dqhqh
7J96GILmH9LUnP+oDKzE8II4CfYj/eub775tgnQ8lxI+iCyfofDtz69fHR+bq5QDwMelnFMejwfO3uGQ
mym7K7z47vX3qG9DxDuVql9uVos3/DlGBaC7eFjMqW2Jp0mzaA+cTHYtWJ2cSEzBVW4Yhq3RM58x8yPf
+2ZJ+5QqowGFYPegbOTJylM1SdWU5ukP3adPLtSMrvzRsD0Ofo1Gv7THTy9UkULx1n06DMLR2dVu/NQf
/QLJHh4WF9OFuk5FMRcntBP38XqNf+fb3WoTT/N9t3POIL2FSeCE0O6eNt3+vsiQ2SekFm/053/56u3+
66++eAEvjzmeXV1cXVyoBb8eXd1TReNOGCC9ygXnaaFeXAz/MH76/+4DX65D6hK9CP2rrBPs6f8Xapmy
DTz/XaeR9/TCM6b4yIAgYVHTaL5K2ZKGtUF6CW5hzZ8eH7zEwAcpl0QYJyqi7w55Gi1SMWamRxV2R0QN
a9K5SR3wq56AnUiABZsL7rFxLmA1erWRqlxTl67TwEieRqfuddjQllhnZLjKbMAZzg6hRIkes4k0PBiM
MVaK0BO1d0ykU9dYd5vWDWvY6xaSyyp1w3nN5H1hvWjhjM5mBkxOYvZVH1XO3/Un19FMG+ScMle53u8n
+30+uh4PJ8OWX0TXxuU4RPTAeBeDt9/aoV0Tl4A/MCENVGF5DrcwjIT3+1bOhnGIdoVVcaIipnWWZNmN
r+OHN/luR33bdifzeKcNRjnrvTUMToKSFSdpilbdz+FwGYdQP2Y0f0EAazq8LOP1OPG8aNJgwu7mcLlL
T8UL1Iq+LQeAsIPTnBENidYJyfiDoitT45xMZTq45KJY6GjVjJZ+yLdrGlT+dR5nRJU8HS/0/K3krgE8
ZoE1ypmBIZ2xXQ7+imoWgVoLuxp5MEho690ggRv6Ql+lwYS7Jab0trJUzmsKnZiHxkbEc4cE/CyKdvBi
DF1MrmuccijDnNaNHajMQk+G/qQlA0eWeNMR5B0YTUp3dTu97+pA7oTqRZJxd2r17uJ5uBn1x0GZw87p
cHA9mtYVq5UBTQmLRDdmUfR6TTCZnNSWV+Blkc+zLfUYmGPU8HyMhIpI48FJU9HFl2xZx5p/9wHnQDRD
CNhuXDnNc84NhpUJFsam06BnmEaRLSa8ONPoelTwYkxgqEy7hy9Vaxo42XcAEzgzKDkvJMbQsT/KKpAH
o6yF7whypmzZOJxy5p4QfzgdP+cIQhnigs2KotbAAa8plwzEvS4eebvZZnW/9cZBEk0RQ4MHBloh95pC
zG08ye0OPE2FDCv+CafDeeh9uzqTJQQVPJsQ6QdQ0lB2K8wCyQvVerZ37APiKUx9mBycEDkxQd47kusU
En+8XmXFpCARjYAt38WwVlcusgkf7zbzkAg8n3J6RGI9VWxfEbGbh9epNoFLMRdKwv0iNM16s0LjnCQD
KGX7fpniQmMMSTENm6VCaObFw/n9/f05reLinJrLlylJeNmAk+kj4sGPb1+e/7enJEMG4tw89cI1dQn5
JYTxIckdGTs5Hrs8waWnHnBfaWkxV2eWV1LXW47s5hTAE10Cadx0QOaD6Tu1jjrx9YU0xy1dSE389QXU
3+52kU8885A4KE/33TxC6EHTGfMMLKW0qzcuxs0d80Jh+4TpO+ORYnrlFrVAQ2T5Vf0c4w1LrpRIaUlG
ZJXNCj0gJNHBwsHdiePPZEiUiolVlT5BdAx38EF1n8L0gmv83pprEwuzTAN++HYTL2nYmx0ervTDWrPH
BtmCbFwzUhgIaU/gWiowQqW2Q3dr7boxJ0Skh7zf36hFeUtVz51kCvPuNafAQpiHuU25rVYVrxm1ptvn
8XyO4D0wLl6mJGqSxLmB494tkB5tzrvtc6qWQ+ZvgOKRPkztiBm7i7wUmbChEFHvokcc071/w9u5p46o
Y4PzPOGeZ9A6Cilj316aC6OcLlLrJIfoHUfB/4kreDY+QIkd194cKuJ8Imqj5IA+fTGfV7u1bYjDwZ0a
5qEYi20xEprM7e5oIG7qsmryLyMPQmESQVMcSd6BWMENOtIZuIlNp72yKbL8tWYsGk/cWVNlWI8oNt+W
i9M8t+wd9uxyF1jntji4hRA/umWbQPojXMXZO+NPEY/e6TWvZf9UJOpsGs999/s7qx5CfAYuCOUTPKfM
OA/oz8q6J70LSkP7NU4XFDUrBCB6Jz4g70SOo1s4fICObeaRj+MsviQuNw0guFot6JS1oPZ2nipG8x3v
4oIDWUkqwO7/R9mVNrdtJO3v768wUX5ZQHFEU7Y+7EKBUY5y2ImzycZJrbdkVooAD1EHyYiUxMTif99+
unsuEFR2v0jEYDDAXD19PzeTzcVyDP5NVItXrkSqUE3Hv1hroi8SELnDIkiSDFUjThvzdklHyvKGCD2n
07dyEn9/Q1QyUfWik3YQwCt8AHcDLONLvXoJJudCIu+Ti81mlYMdQe0y+dsgyZOTk1fEfSJUk2o3qnFr
UT1+OzrY7V71g5PQW76ccGHr6YgUTJ1HdoAwyND8YYHAL9OsQS/NFbGL95mRnW5z7JzOaYTkAAbS1YCD
e+Wg7/WYwY8wVxMmhPAS9XMp/+IUonQPph+FWelc6YEvVeGexoMf1eLNpd3S+70iHdeWPS+TLg1VmWQ9
7aX6usgVzxywpSzQrSzUC/+4N21e0Ap9fvxbkfRqGJjyca/1NYmrgcbnU8vxMEJJyAKRKNrt3veb9ClN
3k2PbJ2jD3Oi0InZe5KVl8Q/PdXIP2gjIsFFfZH42vRVqV8vfhxxFfBLHYEJrsKyrP1NkdRkolYy0/bA
G+arknCrsvhypZhk6/P4zrA8eKenjHtcXCaGmNRV3UtOn/1eDPqD4wSm7dw3wyFiLMhegrDSQMhpkrV8
76VxtxGtydJQX2AfPhCDKzlD3aWY267NvbnKFGtZto7bO0pis1M6gPln4j7ks1LR/Fh58WPjYr6Od9k9
vZ8kMf2IuliDd9ENSgS9709wZN/odm8aG5DhK87py4ZYmswmY9Q34pQMtESSWNqzWtivTrQyVI7uyUy0
Uht6K8w0xPTfmq0VOR6EPeCTLGMp5dnD6TY9OjZI4cLnF19B5HBsWRIkr9pKTlenQzG3Zm3uzIPZFtUp
/MPAPG2Kl4htjpysZ5lDQEdKf1iXTTRIo9eD8iSHj8fodfFyQP1/NRi8pjPq1eAEWl12LLsr7ojo03wi
X/9dcY+LO7q8zMxlmTZ2+AMdeC2Khfe0ed2eBtJCGzEoHuhG+/PYu+4x3chUnaiyfCh1DYpIzrfAtLLc
Im2DzTiba3+kdHNjPyRPt8UdMwwT4g3vhD6u6QcvPhqWzhqas3WxNTi5O1tYlKgNFRdpqDi6Z4AzyDIe
NGr2Jyc4h3Z/i6OeRmsZRdVem3NaJuZ+mOXLMK72Gkt0a9ZD3yiYpPR38LQ6ndHivixleasImvPV1/KN
WO305tscza04mUbwkiHjNKaNfXKmW87tlaMje7jBUNx6tC1XIbDMPTOrEIYOWQ0W1m3Q0KnCIlTGz3xg
+e+QNU2e0TGoPHxPZL2Dhdokq+V6s59BsmkDioN+Yt0rG/oRhIlgLLeTMpW+UhbhRiKnV8aS33wiGoDa
WFI2bgQreVbA+LEzjYEPpzCaXOMp2X56zKaNq82uox9j0YNazYj7HRRFhOukHXirajh2ygiiY6qJgUyb
NUJGH25HK6ABHU5E1nA3etqrTJuLPcrg8CDwH3yosp36ADpVBiSsQRYgBdlqsddnhDCoVYBL00CukxAW
DrYXIXAkiFdqhxAURoRl75X6zMoOgo17mCm0mUFP3y0Wk7+IxTjordUYNG5qb9j2wB6cBxYcPKxCJvXx
VmXtpyDLqwA9Tj+51UUj+sTTJwHLmhNdxe48WS6vulvEL4tHRuayBcg0cHUQdyyBfAfIkfVadJhV6hrm
QXp3GrlsHVVWtxrrvLYpX1qdnYOks18UA+hyw1TwVLRrtsbgB9eTluY6re/F8LNC5qEuXvz/y8GLmdnC
qHr+afj8hfmDXbXKTwsq/lPteGJmV4f8x/kNjIB0UE02bP2Dh755Uz/lyn81+WM2WWQv5p5p+bKpZ99L
eaoEMQonI1pc03FZ24ysJS0mpL5Fa73kPOmle0qpSVmBt+0lw8RMxGgdgEQTY6APdBzANL17zBSzEXRc
Ze41E24OIA3SogqKRasPi8CTNXIhFI1MA2WVWhenCi5OdGKcW/efYSEa2F9/focTgGgRAPWoSyRItdyp
sl2EXFmp93+o/YMIGtmwQsk2yKkzYod60bVpeoSfoNp1kfR2mkahB4zsl/4CPp3e18wNfJDfh0a0NpzH
B5PrUy1cLueLlERGr/B4ID6glzQPDKK789H1/M9W+BqV3iVJp60o/UJUZVx0iDq00nCNHxOqMFHjvXck
g0+vd1RSf1kiCJrsoPVI4LUXUbsFu5h2LLGZr9Mk9x5a3e4b3QaRZyCQA/+sPdqopUsKaN+xQP04BeO+
hUHQoRdknAO0Fm2jXyF1VoqzY93i7PgZfSDCzyuBF0Hu8Uz/oBmF1wGzZ3lL1bq9qoDyCV2N1vD24jYM
KIXIFaTy/fjD+7ebzUplVxW+RgA5ZWp4BlfZr9ir4Gv6O+BI2eOXL1/Rj5Od+aZuWn3pbSkCRt8w4/tR
dgTtKzjv0PsT8YJKwn3hAHc5RXqdfVWfj4aczAtagdt10el8QxJn8kAHytnthIj1hlboGv6U39SQSOn9
BX0JqmnnnUSYHuSZpO3HRzTdGYWKuPLzOoKmDq2exIZwD5F+sndWC2LZcoXzQxSJI1Y1jURMxhXtJ548
hMqs1w/LWxiu0YhYXbxRMCokGloEBXR56u3Q3e6031Qht5Wl/hG8M+giwsKTj0c665PxEQNMMghAW3mR
xMtEE+OoSXq6r/ygI4VTTbRCAwZTDyKsmjWa9dmQEygseYnwD9EGsyuWKj1YIJ1aZUiuQiWXjhk8DoKf
mQayZJaP06/rc1uEXOZt1fa9baf90PBVKlB8VLhTSzm11GpmAB4sMgXYPiFPlu9XlernwyTE/UeR9FM9
dkQvMoo0bmKolgwdVl1yoXAhoim52O2p7nmsKxCIMBd9YGlyZksRUtQ+6Y2L5llkfzxQPqlvWsu3R/5O
ZKbUt8HPCW0+olomhS8aZkW2D2oTbQx9BOWKtAQ7Tw2dOS91QlhEGRyeteh1OV5VNLwSXBur9W34OcS7
zL3DE53Wd7DnQtCO97KzNvGI6rCIDVki+UJae03HPp+vn72lWizPCIjlKmdybda3dc6EaCdElx1PVf1S
R1uycsjOyC7BTpvd7iQNtpUohk4GJ0z65VISLUK7GWUQALhX1rLyYCHCyrOOi9/WYP7ewgOvyD6VaVl0
H59nj59KcWEMFiVUHKs8qdVaKcbnlTVe7idl/7aWlBOscOH0hMte8pso1kMuAtY4mPxbFwjewfbpVRIl
bWjCj1R9rmTz1bxV/qLCwGdlQn+RuLNBVCpVonfSSEku8VouUOovvQ7A6fgXsk2CTkj89/wWVJfSDcY8
j1TdCNLqR4PZYL3jmwhejgpSCK5RibkoK3i04Y/jUN6y8YP4cVfdjlbVMLnYUbP2EK0u3Dyj2XrXIN1e
4kMwLPZZVMZ3FY9Q+EU9jNbPFsvNMywjVqTOaAh2Jh6SQvRpnCNzAjvpJGp55r11d4Ax3Ms8KQ+w9MPd
iwe3bgwWFipcCeFrNJMcC27skbFzms5YWzIrpj4vtFPchSScPSUYarOpM/zvnHdbo9/UDxO0j50VrsUb
s7i3+PwkuiGV3PnQ4+mdVw0HUqDqZcOcU5XGsOe0/ViykXxKFsN8QaPhyZHFHD8HRFegQVAx/Z0kJeqD
tJ26X21j0Jbb611tx+DdgbREp2G0Od+DM2EQyei32euC41Gt3XikDnAAF+Jsgnw1YLChpnir46w60rxq
yecnkEHJTz9++AUr1znbW1k1UjhOAmWjuBapY1XWSIuLCB2/oqlZRq8flzhuxvN7nDWqlgpWGOQjDhVC
VCZ0SM6en9JaiEWmmQjAJP48PgaeecxpVWaE/Lrq0NBQx2iOpHG7inVGlCV1CbxCRZ3LywNaJ9lfdaxk
wXwHd42xg6OOsYoDzJM6et98/S/q7/IBWpVR/veiiTsWwFrvFqqU4siWH/nnUzkMAocfC7eoIJ4JXH44
dA+JzU8TMKnzWtNiW/Cqvq1dJLeT6xGkLXgRFtf6Famk89Om2dJg5r4AOMUJcPdTjxiKFyBz0XxLVBIX
jNXXm4cHE0ApstdHx7BiAfTZfgWLRGOG60WGFTQPMMkQ12oKvMMYAnGOor1twZqZyqYgrWXnSBRan3Ov
wfSyXMnV0QX+9ma+Ct7NdfBDr6kW/uEoSRCpM+NoPDrV+MK+6gb5pTFANwITEahUls35zJ4KwvT8ZICs
v6+Q16nqu/Vic80BO+nUh8+p8hwp/xll2jDK9AB+5mNOShmq51km9WGL0z1c7gD6nPOSpC5HJ8kwXwLM
jYbk7HpOdX8mUkQn9q8SFdp+H44sdfE9AMoMf96EJwThH7PJv6VfR0CjxwO/0Prgj5/IfEitj41awPzY
AebMrFogm6l/1ppgk6OZ2o3RuDFG1mXerWoFnQi3W1lJ0F9b5/JUNVEyVz+pWtxUYSmfVz5RDr5D6G/G
Hu0jVw0ZQzE6diNyTYH9oqFxiKmoxuPTUg+D4yvqmMtW4LaPXAcF8+EXGMrQJA+IbgdpvlkVTXNdQLSE
/f2f1IB7o/X4+F1tbTusLg1TCskwsduRpXItBJENQGGbTqmIxndxokCHGwNHZbe6EuNwZqRc12aIsxak
ZouqINJ9P/nh5CCAWSU4VgJ0/n2IO+wow7SclbPzepiDY2SGLqUCh4WTIgY7+Pp8asblNB+FuyrjZ4sp
ouDohU1iJMjZjZSPMJoy7X8aJpBx8SLQdNMaBFiDhRHQQw+PC+Un9H3+bKAmGbk2rz3vGsyYIow6JEPB
+9WE+fuJFuUhh5vHYPNJb2S1CnllEJW+pCMNxcHzLMLxNI6DaWRJW7Ccm0MITjhIeOBYSE6Ny9C3CtQo
yYZLC7OSW/xeN+/7KyQw8uyzGzB9HORWzhMhk9S5IfMkleNJRLBrUnyX1b7qw1jHAhStMjwPbJjgylaQ
rWYrxFf+5ZmdTYYxkG2Ljs3geyx4CpK6YMZLdFqOnb7MLU4bD4pQ2RZRLkjSoCcyCfUfJtdTYf9pDXwJ
eSqxTwYpp0mgXxCTJv/7o5ux/U0iPptukLK3BbdyoWfve3CMl/9ETfMDfj/3E7VYni0XU+Lsg4jigAnt
PwcZY2btefFDLZmDtS13Ry/f0+3Fzlh2v5Dj1t1GCwvUyE7/7z8BAAD//ywE6tYVSQEA
`,
},
"/js/jquery.tablesorter.min.js": {
local: "web/static/js/jquery.tablesorter.min.js",
size: 27528,
modtime: 0,
compressed: `
H4sIAAAJbogA/9x9/XPbRpLo7/tXQFMODZgjipSTvQsgmCXLzsbvEmef7bytOpJ5hY8hgRAEKQDUh0X9
76+7ZwYYgKRs3+6rq7rNhgJmer66e/prepCzFyd/eWF9CsJMfFwXlSis88Hoh8Ho3FqluXVqXWWpyKvT
Mo2FVSGUVQJYmi+s27RKLBGUAju4Wm/ui3SRVJYdOdb5cPhv1lVSpGWVBrn1OoiSv7w4+8vJfJtHVbrO
7YXzsBiIu0rksf1A3ZY0uJuLW6uGch70oxXDy01QWIEfFIvtCqZUToYzHvqji7pgkIl8USXjy6II7geb
Yl2tq/uNGJRZGolBFGSZXcM6buClc5tt81jM01zE7MT3EXo9t6J1Xq4z0es9VTvI1gtHPU/ORFGsi7N0
UImysgNnzKiAuWe3QZGb5fjOXAaN2cwOHU9kpbCCTBQVvD3Wy72xAx46D7Ed9Jlls75tI2LeBJVwBgtR
fUpXwnZOw+bZ6bNV6TCjixWM9zBfFzaiLbSAmIFTiGpb5CcjTz0MG/AcR+SR8wBYOQkVJGMetl76wQCW
Ok8XXPhLWMxd9fauKgJqyec+Y/hTpqtNJpjv+2K8HJTbzQZIWn4C4Kt1DpSuxlZIbdWru4AlU4HtuExP
BNsrTIuxsEMewKRctg7/FFFlVvZ6YpAE5W+3+d+L9QYQeA+cNxaTaKYbHZ7E0TkopFiLQVWkK3tu4LJA
XBIeG0xEfjh4VoXrOBUlPSIXD6IkzeJC5DbDqns3X1f2gPXDQVSW7/L5+nW2jpZ9BpTiSy74lid8wzO+
4CvAInLkEJYYKU5WVAC0xSLcLsaxzf4B/AObz7VevF1tqnu5JU9eWO/XlRVuYWzcmYG1CYoStnIEG08w
QB/zVB+9nr3wNS9x6PCNqACx2Eq2KS3gGdjWUQKcnm1XOXMcL/Ij2G2DYn1b4hzxxUHWWvqTGbAEVUYi
y/QW5Ft/6G0vhLft952HxIcVPEtEEEP3g3mawUa3GaFmAmOUmyCfAUK8xE8GQRzb+8DPNZzPRmz23HGa
ijioglM5U58972/7z9nMzYKyeu54G6CL6mmynXmZP8cN83da5+v7d7FN74CJwEYyMCmDcMHhQAB6gbLQ
zu9AYc09c3Y7CXT/ab3b2fXz63VVrVdjFtJf2OrVesOwwxK4Kl8c6lDWyB7lM3bJVsEdccRJ5gQuIDGA
9USwiNORp7f1pb/l9/7NOo2tIb+DfhUNNRlK/2TEC9yf9/7J0GO4f4pe795zsn6fbybZbGyXPv6V5Jtc
zgA8h2mV/NLhieJ1zTrALleJiJbILencugmyrbBug9KitVu4Uda3FutnfcYV97jwal32n8Pf5/0CiAPE
c2Eycg3e8MI/Pb3zHFimfd/Mf3I3c0D84r5EyXs/SGOY9SAt5a9dwLYpHech8++9sBDB0goe96kr2zuP
Deuv+j5T82LAKsxTTA9vGYyBBZIALm7ZhmJYQWvE5Zi80WdT2CDecrDZlomdmWPF9srhN4CxNYrFSsRW
3N1qjC+I19Srv2wkzq0pcarXJGVA5NTSh4QHCArVVImRa77il/weWGEy86IBbX//4ZG4aKulSfTN0sQQ
I1G9vvtajIB8GJTJ+hbkcCTKEtr0enMgU/MOusU6GTpE82sQDdcXoWJR7xokBIoUOdnJ9cx/ACZyQa7k
62IVZOlnEcPbIz8BUQ3VDgr9K9jgJbYxhCqww9JHiF4Pf0lYqUF2u6En/LoUpJUB05VdCIzz3MA8NxdL
r9/f4ARXvhxfttnMHH6Jwm/Vmc4Vyv8P61vHaVaETSbtVzXW6WjmfyUcSUbgqBUYNuLG7qKhHne3qyGg
hYSYIwT++3MgAaXd8dAZi3h4JamUweozEOD9fuYYZlCjf7coPCJDMrxfa60zX0MDUiOIVxdkwapGMrTi
LF6L0korKwluwPixpIgeA4PZiY92SBs8A0Hk43CDOXJEBdLpAMilnH7icJaDiVekEU7WpnY4ZRCoDDT9
+pf1rSiuwGq1QcLYd1Dt/xpUyQCkrU0PQVhCL8AFHCvhrwN7VPVuIKzhTq2svcO11PDSeTRqQQT9Gtz5
d49f3jdOs+NAlrzWe5K6IhSzPpgTKHdBmtwbJstnaUGiCDHFBrDbbRqDnPxtg2AlaO9GvmyRoxPNkTwm
iZJLiQIaoeAVv0VZsgIENdIk2GzAjAcCNo8w9tZxrQAW8/sGNDRMGWqViQRSdbFAC2CLVULLR8aDjoS5
NSQM8mQJPFleCC05Sik5YtiYYlLChtSU6PVO4iekxCXqGYniT2ijwWRjjtIp9hPoB7cCaFl6bMjo5T5I
rkzTepwh/+nN6UqJcQ/zu7+49u7lxCo/m9zPJvmMbyUTxJMKZnnSoGm3QwEOuIAZ2+pxUIjV+kbAVgZl
t5Rl/7cpq5sMgj+DO4essMLHnrXOv4NZ3F0U3h3M4lINRUOjUvX2ln7JT0bInHpOvV6HjC0G/CBQLVRS
UTB+C9oLZ9QsaI7P2f0/iMeQfVtMgJ1/mQsaJn7TaEHgzMgfAgPjpjDNbJQe3Krm6zXoerMCDDlQknMg
rlaNN8DMBZFKAJLExVKzkgBcSam3nAglV8ClAbJeaJJ7czRlN0DT+cy79jeoecGBeL+OBXLMO1j+nbew
N84gxUdwJ1YABDUfwWzd7UbeDbzCxtevB4WqVF+kZ2DBkutjmEZ8QapHzqQ/8mLJYUf7mMQz5yH3Y2kc
PUaNiMvBMZLTDKqqsB+YYT+DSf6ox7yGMa/7KxoJS44MFcvpxjRdMB3xkW/8HDSnlfdvvA00L0Bb+uyO
PWopNJDDlX7UHzW0vkJaS6Fy9kfc+MyALBgxaADf1kzBI9OJqqWclymr/5e0rNAS0u/K6ZNFWspsDCmD
/AaWQkYiAzobP79IrQjFCPoWdl0OE5I6NUWg5tGtIUAms35T4YDl++riLH31HEVcVjs4kpsBrzF0XooM
7MN18bOscwbohdl1NARWHQF8laQlbDs/q12bYG+FUKQhB0m1yoAbt3WDT2C+ZrBckDTwNxL22fQhku2m
j2cL3m7omGC4FIIBXGWDdf6Bdr3uEJC59K39cikS7IhPQJ7MHLTslcvTsNISGm/9JfKmMfrzizi9aQgg
8SlX8S5HlKLDxy7OAOoVM6ckUdjrdUuMqcD2wpEUM/pku7zLK1tPgPZHa3s4fDRUjdYFdOZfGQ5kxEPp
QL7L0yoNst8QAn06oGun1BlPRnzIz2fuZMhH8FdPZAu8Cd4dvaGyEjHBo7eU+J2hjHoc5aQlUZpoFSrD
EbzCX9uY+d4QV6DScVrwD00L/pmh6O/YkBL3xNzE6hKrIOXNLYfchwN4kRKS+7aoBAaF1u0KTViF+mKN
Kgb+3BJpQW2QkCUFRQBQQrKW8aHzqAVaGa03wkUvj3HswVUOnxyRgYD7G27yZv8rs6pSZmgJ9uoGbAm7
2aSOoZFe6zBZOy4GHqDSa7SXl/Ve/kCa21FaHYNMODp6d97Ptm5EPTZj/K0l4Fpj6LhIWzKAqSZlQ4yC
gc0DMO4ZySjNMjFf1uJCzJpIhxcTd75JS5xH7IdeNAnHTFOLuUxOXL7NbNXwVA6hKRUUaXAaqz7A3Gfg
JDteQF67HYLlJzu5bIBR3gB1SrD5I7OTupxja0C8gZafOnK/sWpjX9AykPl4okQzFrxf54I4TGARvoFy
mjT1l2XUVMMLb6reCLMO38DN8CcsKCOQJyi8wI8R9cuMXxuynJE5YqEJ0lgkmgnkPtgM/lynYKZYGG4S
DWWPwTQ7KGmhHecKU8lhbRiI8OPaXgGtHYLtEIIPG0p74RwEQTwJZ5MRqu3AN4bFYBwbdKh7LMhGfQxn
GGoDrYjqeTlmFHRjLhDfcYB6ylAm4wEMNy+60GVeBLMJJtGsxXq7nR0MxLUdtdGUGAvfTNTkZwcwkDWV
/Lp2BK6/ag2OGvjQSC3iHMRSey/qYwqlRnjoN2J3YjeCvj9yvrMl234QpajGL91zBw80AhWO7iMuQeVl
Qb7YgsU/CRqfpsXBzpipJ+YehEHmVUD4CJta7w02MwfA0DNs/hyGp85Gzbtqh4+yHexugwRZEAqQt1bY
2rC/4IYFtqvtPvA8q+Sn9E6AXMDBjA0DhFkU6+0G8Kk4R9n9C5td6ErQ8TySragrG82F2n3FoLTefoU7
T4uy4xDE7k1apui47BMt1J6SGu8VNgUsMhoIVELXPFATOItejN6+RMPgbDTss+8YyiyPprgBwwl7BKQ0
OPnVcMvJeI0bMTb3wZmKa0nmNY9osS7UnHljEGJPkT+p5xbikRhMhRslIyqZodsuQDhoVp5gzH7mNEOo
AIeDHha4MHSGZkfYXEjmBWdKmSjDC9jvSxcrv7Njg4Ut5GGTA97LOapQQdDrBbCtxvhTx2TAHm7gf2tp
V8QOiPMaPxv/JJokNN6v26xK8bzyP8Q9yuVEaVK0E7RjiXAfqwCFQ4BRVjl53QPNGFuPz107NPZk0tmT
Xl2AfYHcFH7Ik2Oq2HlA9sAzMLDJNr2eZpcUWGmgPYJGv/BWGW5mkIMtaxDwiS5JqOxUpOPGeUharAFl
+TbL0Myj8p/WRSTUAY1RwqUcXppyeAlyGDgBmoL5nnS4AStRp4RKfCk00YDnr9Bk77aYCG4tQQKPLkLt
7GoVMIKh60Iae79xH/bEzHmk4CSMIQEuaWP2eqMLo4ESEo12MWHNBcY+htT+Dx5VvFNcbYLK5fOmZ4cD
e8ctXJQbPEAGG2rk0AndxX6Xwuxhb1bGjNWcmnKYAEcq1Rszxo3J8dcnotgx7DN/2SEBP/dRl5Mi359q
BFMFi6/mIXXODJPfJyY/Ssl/hpCWpGSXMyXSW6wpi/6LvNnZ7q/FIs1pu5fyYHy9rcy9iSak9w5/Pksn
oNX6bR5T+AmQ14ikd91oA4gkvlCRUYyI3vlDXjZC6tYvSYHLZAqUcPyzXzbm6Wv/s47UXTWhV71sPKgB
YFHciOJjGlNKBsXNTlZ2KcOyjvNQ1s7LdSdEKrF4pbhMtUBTS4acQVLaiVncBDjBK08A2eOkHdhUfN0g
MeKJTCuQtuVrsi0fhP9Z2lOetZCPo5kHmEElj4uSCPhIMhocOPBBoCaBP7Ct4em1Q4EqD5jirE6XeA+t
9PEWrBomWNZHcmI2BlgWrsHDC8ycAQ0yMWEB+G48cmEjvLCPAMBaR47bGuAw5G43BKzkgMR8uwqBSkTn
cfvVxhVyXB+/g60MfwLHnU+k3aVOJ/owJ0Z2FiPrypkZrZaylYB2jmsX/t04chNewd/EjWD0Q+kSt+Nb
u8BWlRxXUEB9L3Hitte77SZOCGd8C432m+s5B6DAg+zpOVvQAk9lSR3p44H8UZ8TTLLZaQI/YB6VRkRZ
cTgeHrP+50G1/ki4RvvXCvLYilM841jAWwX7mfFr05r6X9K+CJBnzShzcDS87HiHUBf2eqGNvRgb/+eO
p08HTtKOrS00Cq1A4xM1A/MkR4uycdCWMjAwnyy5IZVwFeD/8xMY31Uv9TT+42jqCdk70WCbh2Tz1laL
JZes/uChgXq8ElmmHi/hCbwds1JhyJJztKQ5fEXnTAqCno3w/rvYfCutQswLUSb6Fbxj8OXvrdV6W4rt
Rv6F7XojLEaKqiLPVvq44SAPVqLcBBHoDunwdpaFB+81TIM+IFAE+3O9QWYOFoHEKeZbGAZSW+4/6r5r
XBzrm8vIyoH+zVMNTK2YD9qrByqeDOlUCWugfSFUWBdngSFsqMBZvL3BdDTktSbe5CHRPQw14fid6bbm
CtuiIfORVaDiitHD+fIq/qbHjfbHRe45MoJUi3PnYfkVY0TSRwuPh8gsZHc6s8GMF+3S4XkVRTg26oRl
AWJLBRjLur5JL1IOoEMZbHh634IuDoCCmY1QqMU2dQQBnR1QtBkMK67tZeNhMn3Ss3Io9iPqkx+OeUdS
xS5NFYtH0VqzcgMCj/2PNZhsZjN/xY9WX8/8On8Ej4jUEXlOvHPtcPXnZ+BlpFBDVLX7/xUUpRPhUFsn
yEP8NR2qzlWeAVIATCZf1Cgn9Ckz6BrP9m58S+xlkd12qa8wLL6G7DVadjuKuUqbc+gtLzJviTYLFiyg
YHFx4y2g4HqyMJG5aCMTUS/zDRYzviDEdoq8a2mZalrdmhkc5ICaxcpQhj5mrbpu5sA19AsIetQUfOxu
S63ZDhMSlGOLWqNHU7CCLjomMxT9iXRNCPqQEIkOutzymArDHWCakvzFNLIsuMeTkF5vZS8Uw/R6lOzU
7UaZ8rIbLbqRo6IDRruEOqTZY8xNMUS+oda+XVziDOLD40Rg1e6rlqfGAeWCo7SZlDBxMBe21xOddTRq
+KkRDikvOheQjSlRDkSXYnU0ecJ2hsjBMZ/QNYdR18kLQBNHd9tWnKxvfStZDujelv5Shsi303s+UE3r
Hh9xP8zl6dZ8AE5aCZA+UynzzKszGNHqmCtEqpdYzINtBm8PVSJWwmWqgPEmLuqejHg7JQhL2ue2LtPH
tY+Md89aXXS3efvQU5ZFQQ7C6iMpXZi0C+aJPlLDZ2TXn4gJXLZaxfE9/I/xbqzNZWWSzvFJ1ukomsui
qsioeFu+J09IdYZd621Pq+v6ts0CS/fhkVvpAkSgwAwtbFsHr+QitFGH+YFN8KCpkx4mjdM5dHXx5EZO
+pd1FGQkOEGLaFhaifGCUgxfVVqvqxN6uc7QdSlBl7eT4V2dBc+bGICcnekeyhLFHLiU1oZzHz6LsAjc
CRNgGzLO1nHMZo88hdUoDkfMpHJxlB9J/dHSKfbvMsblgZZ6QmdNPWL4Xj0q7jBfwCRQ7wYHygKdYegy
477GaaRKCQQTH9rVmDAgq3QCVqcein/LM2Abq5P94LJXFuX2wC+36mcQ9hoQcQm9Qa1ZKq1Jlylz8hR9
RvI2Gz7TDKTSeJHrlIOPj2oDY86pR6FZX15QaU1cokxlU7aXlAQ1qgDqC0hLFAlaHciTap40FNmvNlq/
yw8BAGpz7CU9QhPE/DFabAzamxBNudxIxGD7Q1/qjSbZbh+AYgdcH0Idgvg9p50Ss0fPak6o/Id61Et9
8kr+KvmhqYi5ZQ78RjwJJMd+v96rVAdgIDFgT9+gK12tpadrBeAYtzqV0HK8A+BWLA6Ay5FNcMmsyOQS
DFkvWy/8GL1EkUfJKiiW/g0yJEiIqthGlW8mBqkgC50cHDqPDP36uhWIDuDyRh1htPSEGgLnvmuECuai
Ug74Jxm0Y58uX//yllJLELgKFu9BmY5NIDq54KHjzsG5q7Yb/Q5601NFfvv0CuOdwW53Egwq3Pe7HUYM
u1HR3c46keXtGR64HvP2w4ffPrgWqvIN3VLQ0KTSTyygtsy4sHTeIPoP1rqwDB60YBgryAoAuLdCIXLL
kLUyDV6m1YJglPmIHDzHwUpUAR4ye915Yv5O0IoOodekbWo/RMsYkzQC3hYxodPc2mlASDMBsxRBlmFI
rECe0jHg8NCVJ0y+o9NWdoF3aF7dXZzRX4aurnkbymiOWSO/UeiwxWcY52pSpQJ13qhvTo0usEQl7FGW
/fcXJrQ8i3wE03+eD/683oriXgeCBtJlk3LYfwDV6o44XkF0wVdGTdtnrnw4ZVj0WRRrjMPiThpiyneW
MXgAuqNulLoaJP6jd2agdHp6JkPLS3V4TZllMPJuZyM1MZg3IONszEyGOEXTURltdJdHBt/8ZTetiYop
ayQcNOq4H+nkJJmQtCjSGBORDHPUN57HbNAyVY0EvH+cLThDDhyYjNKn7M4iyOP1ynaaEOror468+2if
y0mry2rLb7ilptNE5TF/eiOYyzZrIBmmZlFhAYr3JsgrqACOlOsyc6FYFJBdUzv8vV4N0E0hyEQcoi2A
Wb1XupmnHRLcUnibhaJnmFwgk6nCxq/c7W6/JrJ2iM2P3PZcyn3nUDgxA8NhbEQW9ypdgXFfLQjwhoH5
VoNhVpTZywGQfY8JY4nDi7B7oDheHggvN1Ao60/CgWE7yjCzjS45b1WgwG8nbxOmOhcUlq2As/TSOxFJ
7ZabxWbU4elGR9w/52HvSpHRmU87F0iG2Rf78ne4J39HjWg1NKzNfpOCtaM41NnDU0LYwVtgNSXadlWj
PPgR914Sota8rVd0+7324ltaFF3ugNQQqaXYPKrwAj/a7QK1E+tkg0SlbYbjIzegMe4Zd1mNcsYCHWoz
LAzT+jBzusYnI/fQaTmphJ+ydfBktq3DrWYKmAbBg668bQxSErrxoOW4OI4btJLJvqrRY+eOxBFcY5QY
761pI2RPwcPmCsUcXFn7OaldncZsskYZ3IjVPUl3dvbqOWU3oW6MQSBEyThUD7bjhk14PDLzprDnwbEu
cf+mOXgz1eWcTiUxelb3s7clyN/JRFCQMfe6vXbnQa1aH4JpdSIvvtqEt0bsduy8Bmcy8yk2Q4q0knhg
+nWOugiseK1T6WgZNGF0qBSvb3PUGuqkiUnJAH+W4p5e2UyeMsUtkVMfMrW6+fZeuJGIq0KmiZf4ggQS
HenbeE5oi8FtkkZgzgqwmcFAyUE/nJzhIDsaQhknePlMjelT4vboJaZA6Mb1/GTlyRAq573e+Q/Di4Mf
CYgcMrONJWLD+vqWf6gRZ+/e//33T3SXH7irgIra4GfMPYE9044meXE7uBvXwV1SyIl/9unn3ac3aoWm
A+GM8c3VcqAJ7Eu/nngmMRPXQnUIkDgzlZrVpJBSAlnCBUbJvb1JolyVcmabS36St5gYGSdKP1F5KWPY
JyOZBPjAAHWwtagO0yAxBZL/uv78OxTL7lWh9HTaB36tTaSTGs2t1DGYwq+4CKLRdVCuv8sbU6t1nSLc
uyWiXDMV5nxa1O25Xw/HDz2lIlKuUX1uvQU6qvMcnIg+q8HrnfWxWmctdB9gX4a37w9Yon2BgK+agTAR
Ww6EQaSinRGqeMzbmqd6aAwnxnFkrB4pkb7loTlfOny/rA/cu8fw/42H7yBaNgBaWrX5pI2vA+fyoisx
zXRoeSW5RZ6JSR9u0IXXOfZ1Qj1vZT52cu95O4t/ZqbCm9cJWiaDZyWSkqKjTQ7pC0PQa5QYQn5/4YcO
8nUCSHyARxtnUJjOYNezFNKzPGS2jp48apKSZiHu/Ico2eZL98z+w570p6ezsT12h7vJ6PTH2TR+4cDb
dIAPWD4Rb2cSaBr3nbEzfrb7Y3g3GZ7+GJzOZ/1nOyw+W6Sc+iyx0+l0uIN/nzlnPBF37lkL/iyl2E6T
JLQf4QnQOtcKZ6gtAC74AmT1ysMMTVoHCpkYWOdOaonQwezmJnwwWAUViEGCcDg4t55oasN2rYXVaJ5d
CDXw6YjeX+l3a/SI96K1bw3KAtfLGS50BD/M6daV6HrrDUIQMPXwn+xh1VzN1F994c2NcjyiTvyhl1ys
vETm2aXl++C9HU2SmTPGX8xHM+xpqsBPGCwUZEyQ8T5krCEBLRJUOMDM8nFR3+/WVZQ/5+nTyMZVwCxE
0cdQ2AJ/CeviYtHCuni1aLCu+aDDNiABOuoHWeQQ/0R420dm5on6UxzRDM0qdVgz8yz9/SKMRIEzA/ON
xgfSBaNxRKl/7im4SfBADcIvNEBMuAA/clsrIH7vrAol2b9wWd+6Kprk169JIaG9qpAH9aowqNjZ39r9
eRVCH8FFiAMTbdGYBHBy/PYMC/KcHpS7OtY3g9whfkyoHxqprDGlsgKDgRGRBGC5xCD30ZHRsd8XwuAo
S01dplgeZim+OIT9hb/Q1hjGchUhFjUhBBBi0RACDWqDClqoHECuGAvFYQKRW7cMv6olkUXgfXG5DwOH
nPA2dtXptKNgQoQJuzChgtH0Og1rVpXYOsKq/13okov+BmRZClsaz/9afIWnQQdfR/aBxCvyahCBgn97
vU1vgoxc4ofAZdPtcChG9Duk33P6fUm/38PvaPgDPf/A+KUEjwg8IvCIwCMCjyT49/QM4JHq/d+oWP7G
jF+pXmTBX+k3Ylwo6B/p99/pN6DfEEFG8vdHxt+q9gQYEWBEgJEECej33xlPVY8x/UZY/FKuUdDvnEpG
jL9TPRJgZABGBBjNGV9LkDktdE6LntNC54Sd+V8Z/02CxAQSE0hMIDGBxH/FM+VSAUGXHz/i80j8CK7b
VnVP65jTyuYh/dJs/grgv6uWBBITSEwgsQQRTNpfpOAvo6gT9KjvDPhswjiaOIdYgoIDRtUHNIPQr2qX
UNQMI9+Ud4+f8oud/Sv0sEnsqE8XPPnBHqDCh7e3dxsbJkU3IPtsBjbvQpq37SYaNEIYusnRhdBfaHC+
OK3AsLSOTQ02USOdZMDTDBp2tpsOI4XmdVepMiypM2DCobxAgoKnjnd42jDBIcCBkd8LO0i5vc+pUSS5
ufsQ0d2H5qNl4WyQxu1PDNGpZbcQ7/SAcQ/mIwaf9RiU7SdVbeszZl81tb1ZEbm+NLEm2b5dqZFl9qA/
GanxJh3N1uTqfKfOWppMs0Nroc2hG+6tJtarsaMGDKbj4GcAOrcYWAq+fK9nRcdWe2CJ0WP7oOXpuKV5
5Xz/Q0r4OTD8FInxCaNV6yNp7VXidq0zxBaDBWyQpoAf1C7NzUxQYRoUVxc+OlxdEK3LdzuYULsbe+N3
c/9CvFizkVf1N4NNka6LtLrf7YwXH6+UCvyqw8Z5xGug7RtBLfVXN7oI60dU6E0FHdXUVUN31ExddCKp
yMT0G+52J5FxCjgB6RDPYOt1OWAtiUFsYDdB5jap9nMhVDNU+Hy/UzyLwR7ndCqDWahkG/D9GaF8OAkR
stuHzK+UvdS5lmhg4deX8IpnwzOJ3+WU9mcEWd8+UVe161MizHXAA1hkZHp2+kmfWbIbaECfABkz/KAD
c/jKUWFKM2T0RPBP3cZtuH+F4WjFqEmzL/nGT8wtLNOtN5RunUyWM7xitpypz0KA6/mq4WdVgVNDh7L5
rtzzD2IOk5QfHJbJbxbleNEyn/dVQ/qyJKeXLuplZIZYQpgUUy3pBiWl4cuAH2bMi04KLD/YEGW441EA
Pto7PFW+oPoAxx5ypevDmGec3AHPk0EQtD//CkBmegl4S815sYsf0vQxxmQH7ZwG+t7d4W/CBPIYE+8a
P1nfkZjjGL2wuukRKPfYd5PxviF2gX/d8AhQqIDwrwvLkmcbcxXcwXWCOXLKpArVxdqmmU5LWW9PptPb
01nfAbtmMgJXBD9K0fm8b0zkkVuRAiL7cSttyxiYQaya5kQg9QJQ0cY7ZGp/jGVYUAufTkbs4YWPQ3fk
jBsz6YyrXA+jaDItd9PBTFZ0IAewwrM/puWLqT0ZTONZf+qcaQOtY4EpMAXnACBnp89G8kO/RoQoqHGm
gk7OWCEvcNxImmhv0kV6MBVN+1/jsz8m09O+TfHGiTMbP9PTMs2PZol88JxNS7VG4O/hI57lIJZz2ARG
6NSjk9KD3xBvkuSgqZU3Zp79kGK2Jn4Wlqelu3eEDaNxyRJNXcxv5HZd+Tfa542J/xQyVoMmZXksDQ/M
LzY2hQvKIvZXg73k43He8SCALQFYoz1+5Mgeasawlr2lxIj+9lrimgS5pg8y+1Prys19YNux/FZmQ5M/
prd8YE1PbUfRBZrWc4SdLHObDZt/NV65sWYWgNCI+xpMufWq9Xc8Dy082haFyKP7I2sHFreJ4dBjC14+
m27Ph0FEL+QjBuQjBufjwWz3FTDQ09SpORcRZLUx1J+eAoY01/5PQ3a6uYxjeT5yDNvxw4i/fJxMEVdP
PGoUHmbIhcIRr/wYptykBmIKOn3G+tavTANjBQbG6uLWW+FnBvu+zYZD1q8mq5lOfDt92eBu3MZ8AcN9
3fK3RXZ04XZSVZtyvJtXm908zYTjTs+mZ8Yqrb1l1vuzIVpD/iP9SWH4ZXmQlmt0Np6i0/dAj7PpqaTI
efvlS9Q5gkrKnIzHdSaBuaBTZOIzmL2RXrDbxUjRr8U/2HEoHI8typ7GoM/G3+2+wz/T2KlX0euNfnil
T1O+bUnGCr5T2/Cr2aX8ZZ0vJBmsI3SYXJ7+5+wBvxv0OB2Mp2VfEYDjs01Ucuym2IW/54+2/OOMsWZy
+ffZr3R+p7+XEANe1U48fySIZgzq6fvHBvTbsHGQsvb0o2PLacAcOHs2sp6d7xH6q9FWJnjy+wTz2n8Y
LFvOui+AsZ3dMPg+AL44hghviV3AEJLZaoni6emAzzT/HsQYOPwV2YowzVUTE6cbzAVo/L3/6kH7M2T9
qq/+awVgvVV+UUcGCswOaa5k7XZ5/Sm/Ar85rnJhKvyYdg3F6OPfzbsX+/E3rNBr7n2hchm3WtsagRKd
B14B/yCmnr08ezY6Qz4A4yRerf4F3Z2foW3qMuwKZ0jdkQHW6fD7J7qTxEcmpQ5fIkG/zOz/VV6W6aLH
Nj9Y3sPTczSIXXj4AXgTOBeeRmbRtByrzeU4z/75fcvOh8Ph2XAE/6ecx/9fu1i7pkfs69Gh+efg9T/E
fl5b10BYGXj8VfVGiWeHCuWn7ChOzGoHD3NSGhd5Es+OTVz56jRxunOHV59kYMr9cXjIiMOZ4t6ueMFv
+Wf+hl/xtzpSfmN+iJ9bLAWl8RqcBp0p6d3UMZ43ne/2yI88v9a2DX51ufJf4xcHwHW4AqOn/V1rHRca
XVzRd9KHYDG1YYxP3WE+0033awu82rsnVNQfF35rpOlROIES9Xa7237f+0wf9bn97twrWjkvqwFhcPJ5
PHLxQ3x1pm5TMXRHM/qcWY2H3Ey9vtTBq/9EeB274m+A5+VAezxDlPBy4JwGxSR49aC7XfsSpdNkERn2
Y67RviK0t7zM9ufSYVykycrBJDdeHfu2Z+Fw68leKhX2e7T//N94C8bx/vL/AgAA//9vas/ziGsAAA==
`,
},
"/js/moment-duration-format.d.ts": {
local: "web/static/js/moment-duration-format.d.ts",
size: 85,
modtime: 0,
compressed: `
H4sIAAAJbogA/8rMK0ktSktMTlVwKS1KLMnMz1Oo5uJMyy/KTSzRKEnNLchJLEm1t1JIzKvUUSgoSk3O
LAaqgQkUp5aUZOalF0P4mmDSmqsWEAAA//9JR7h3VQAAAA==
`,
},
"/js/moment-duration-format.min.js": {
local: "web/static/js/moment-duration-format.min.js",
size: 4061,
modtime: 0,
compressed: `
H4sIAAAJbogA/5xX/W7juBF/FYYoArJmZPv6n7TaoMBd0QIXXNFdtCi8biHLtMVdiXIpam3D1rt3htQH
nXVucRcECckZ/uZ7hmK7VudW1ZpJYfll2BHY88vXzBCbUprI9JCZRv5NW2BbLniiduxBXq/y3ZJfjLSt
0cR2x0KVEu/ZWUoXcOspXXYjdYQ2KEoYfgEQmaa6LUt+kSCmwz8zmfgrzDzLmFI+08w+yaiUem8LPoNj
SmPJJzyFInsxv2w+y9xGB1Pb2p4PMrL1B2uU3kd5VpbAmKYpXdWOi/zZmOy8phNS83uRPHMIVXt/ogd1
OmifeA9p8IuzHry50ms+ysRd100gbQiyEGYEEgojgGrVO2IfQJPhDgXg1CY2neI6wYPKquvDpN+Zt3XQ
M4jcpEf2lh5DHjyY4f5ddKHRW7usbEZlXovYvW1qulp/K4eoG0kgJB1lJQ575BtllF5GT0CJ95y0susu
yK58KgTQI3t1CVMY8j06tE0Bq67jybcJX3wP4qFlVkj+XaBD6KQ7UBnAjHs7FFgKKx0AT9AF04Gl219D
N0J5VS0zoCjmdFOqXDI1orn4BorrCfrrbTX4mzwy8quEtsLGK1umgW86nxCqvj/VhjkUosAzPsWiImt+
Oeq/m/ogjT2DTdBOXEK4chri2uG9fVA3Rv6vVQYdFFaPNefLPu1pjFZ1JbWlvMszmxfszC9dh27YPz7K
yBM58A9rTwOUwtRH+uLOyI+tyZwRf6lNlVmSZ1rXluyU3hLPEn1uaLePtj1jtINfxzuVsfceds5anMVG
HMVP4gOEyTvTN6XM7FuEa7g4pRW7dMIWqumhoq3cZW2JxI/pJIshC09O40GKBxD8D6+ztHebc1jjWiG9
XsPDwIunyMrqUGZWpkM/715B6LbaSON4D0bmqkHZITN2Y36p2En4eqhTQAWAJlWsX/HnfhH3/6PmUCrL
KKE8iHSgzZtqTssoOxzKMztxmEdaHsk/5P6n04HtWH2vX5xWEmJQtyaXHY8+10ozeqVc0D2ocL7XhtsQ
yAZAdg06NBarlHfYwlmgVOXyT3JxO7B9SZ2RELRlD3mBBJOn2Ap/Ghth6y9Sxxq9IJs8O0j6LKHaQALU
4ynyZ4L+YUl5DPDgvRvm69Xt9lJLk5X0GUd3rDufZjzZpAcwrWA5K6ERUbxOOfy47r0ZJvhgr+dBhejg
NyizjG1CC7W3ELqPaCDx28SkH6MMMyNRqXm/eH7JbBHtyhr6guGx2+VSlbBJmtQ8KcgaPVuC1oP8pE0f
dHKnU1qXQcApMemsAMFlK8Fpx6Iu5T/dRoktZGqVlX7bCNX8LLPGxjWsXmpYtJ0zt3WQJyy9XP7sBPuX
zuOj7RV5v8T8CxmsaaF/Yqp/jJp2Y02WW6Yw+x0mJINRFfSWtF9iLEq5s/R5G3/loUVjsj0wGfU6wmvN
WfjQ6yGjyTBMuKMf0JMkhDdqX1jsikFPxsS8leVmm3+TPHgh0ziNXIixnkdNHh+Dkn+3cBYFcQwV+6M7
P9RHtlyI4BbnN5SnG9L4VANlJZgE+CFmSLapHfN//p9PT3NBfeeQY5QeH9kRfecDfL3exAxndmpweg/p
/bal7xf4NpNRmEKBLt/q0Tez+afoKuEIMvqosAmosZTyrJFkGeN7O6Izw9RqsQ7dJDCleD9vbx2YbIzM
viQO4YcQYfl7EP40IWg2U6sf1k9LeKujPtcrfAvw2W8H7udV/GuzNCatzjalJLYm7hOFuHQjvY+Jq+GI
dkNUMISY+u7cpx59ojP4dnHVN725+PfrYOCdmldyb4SPcze9+DYazz+tWDR75p/Wc3GWoHU8X/37vJ7N
RVVrW8D2BdZHKb8g5V9HpGyzM25+3OKmgHGDu78W7pLSLcyNeF7BppF5rbewaRylLNV48gFO+tYdz0H+
XPjR2Xd34lQhXgXipBOUSpw00kshPRwJsckwEQT6K/ZNSYwBjRciKJkY248Y5lr8+oHjnh9+mAvrN4NP
hU7r+492G/13m9kMRnE3Von25UF7HWnseWkRV1XcNNQlLu3NGqnb1XZNkKWnO+NfUVfFuqeif0biy6pa
E+Toic6FI/W8Oq/JcXUcqN7Pt2RE6MkuGDdUOhbE6ytkVBrtchPEv+r+HwAA//8UKda/3Q8AAA==
`,
},
"/js/moment.d.ts": {
local: "web/static/js/moment.d.ts",
size: 12777,
modtime: 0,
compressed: `
H4sIAAAJbogA/9RaUW/cuBF+D5D/QOTllGDhvetD72D34ruLG8So1y66TotrURRckbvLs0TuUdTam0P+
e0mKlEiRlLSOXfTyEGs53wyHM6PhDKn5HNwedhggvCaUCMJoBdaMgwUrMRUnv1TgDyffnXz98oUE/pWz
X3AuTsFWiF11Op9viNjWq5OclXNBSn7PGJqXmlHjLxyZq8MpWJB8C3EBruAd5ntcIPCniCRNXRNJfjsD
P0LOKPgLoZso9k4SEKQbJqEfCGd3BHxgnNT5lkTxW0OU8AuS34E9pHLlFPzECb2LcijYHmm6UgcRcAG3
5ACjYIgI0tS3/fVHbbaS2lQHSO/Yfm6wuDgod6CXL16+IFRIQ8AcG2dc0l0twG+KBOS/A4a8Oj8FtC5X
mJ+ZQXegGSoZFdsAuAiB9xjfBbj7EIfgIYChELZldajfNqIfobXAAbIMkRXOGUUBsorJLAqSgJc9/Gff
1hc1h8plnaG3dQkp+YSze+m6Zb1ekwcpYcVYgSF9fQoqIaNjE507e92bHFaLFNlbY4RxmeQxFoxOFlIc
70Q4PgTjndMj8Iv+sBtzMYVCghPNEYafg3Fjp3olOMxFRi1pBnbWFxJu3XiWgg9gUEfyUQ1OsMvlzVJP
lPnu/xx7bbtAknm1hCJr/ji6thIcUBhXa87Ka3avo5DVYjwQKwG5uFlntcwrN+tbUmJnzkY3MyemaBTX
IOdv3jQP4A1Y1ALK4AJii4HMZBtCYQGa9C/TPYAIqbQtNwZ8AjKEdxznEo8Aoc2e8tpKaiX+sIMclqBT
RMtWPwFba0ngwGpwD+UMgqkZQIY34JUOnldgDl7psH4FsMhf96XCktWKT0o0jz1ZlmFuYg+hiElmhtkJ
I8+UjzRQyhSTlX4e2zmm8Jc9A+NR9dhYuWZCKQ+FQSPM1RIg39QKX4Fc7torDNYF2cmt8ndkOxtCz2a7
lCnYShVuV7K+4JJXmq8ZAIUZ0dZGuMo5WcmZyroQZFfgZulK2wr8pnaA029nTWo//eZzZJ3eNKdu2fLM
60N204agwHQjttZvESUt1kvyj09zdtd45lxnp3myhGcF9izUboLPmvoCo/3uzPOs6TCMqf/7nHiEA1Km
fJbsODnS/gcpsl3xs+TJySudmiy7enhCxsyhlIUgz/r1bEvQ5ajlC6vVvGAUZ8Op+AeORc0p+EjJg9ZY
yix3M2kNr+sCFaF5E694x/LtSW9he1jUWBa8YVdRMKmuowSQXXxec65MjKTx59rbMqlroDQ+wpa1FvkU
xo+37zw2Uv0dFgQpVlPIey1RdkhlW03t90u/1tLGOD3+a0qaDtlsMUqOv48NuT+pfBtUKxWXaIhxeYoY
ShN4SJzAAUvT425TPPEW2DbTZdIWiW7bdu5VijHV2nsHBmWSffBcQZ3dxKxmx5OGIxX7R4LXISXZlfyf
Y5HYEsZmjnK7tMG5o/MOs8SNV40qmlJylDGcsCUMK3pJh4wTI3cnBdk6lmpD6kymeXWQED1HaOHqRES+
YVFalTzJ0JySzSr4r3+HaR+R9TpbObr6L71HTZQGR3LMAJf1BnIX3LOfYBcmnai/Z3Ywfuqjc7/cjyJ+
INUVhjvrpC69K9ons9t5yuvBVSomLDWZM2VELKKZmFQXy9vYFkOqn/CacRzq11Jc36QhrU5pyLVdVBpi
YiwNcOJoTN0Z2HBI6wJyIg6TFFya8DiW79q0AMfyqdUez2VNMM5peX9cm5KgL7QhDDm4RSQVaxFJ97aI
hHdb+oBze5pOtVrLdpxre2s6mu0Yxwarn+7XJSyHX08LSE5uAUnfWUDCdZY84DlfyalWsVzH+c1fzrFc
x3itv/CpTtOXgu3hEKxU56XPh0yLUkC5u6j/arhJdr8axHGFhbuHhZB28MoI9NscLBcMxyfroCNTdsD0
xPH1f9uuv4QPpmIwEedXwC01USG3dEgPOhoT5EQX06PPQHBTE+B11+q8gv3mdWy9hA6tt6UmO5HB9bbk
hP49+uh6JX5kvRvcHBymqrOqR581vXhsgYnbtHfmOMHeqhWwEhfwoE2gJ6nkq+kNUPzgIxSLKqB9iD+i
pPy5qLAdSWhjA9xq0961WznNwHLLuHBGTVdWRYZS0AWhzqj0wkZFzHvtsPP2ffOGNZLjAgqyx6oCbnF/
cwYbNTEniGB1556ptrg712y63e63rGnZPeY5VLaxqQB8/9YtiO2RTzufdZqmMo7UyZWaSgptXe/JSJnb
W581+pVXjV/1fwa/ewO33k+ll/sz+B0O9EfE+filsOsBu451LWqOOyfvZJw6EekElfPoPG+dR+cZOY/O
88J5dJ6d9+RwGIn+pZBryLv77T3mlT4m7PV4WT+TDGa1sGWMkf2Udd4NqL+5OE/uU2P8dkP8UpFtW6yq
gy+X8OVqVTucE1i8Nzk+02/cnhH0lJKezHqXNC9qdfG3bCYze9yTi3u8wrEd25DC7dEh3ujD/3Dv9A+Q
u7Ghd6VPD1+XDvHoN2aCiEdYMSX1qPdmkpAvUi7m5Y4ad3RHT/paHRi1Fxjx8kd3GnSvbwd2UGZWunlf
wI0qGkKxTVvS/Iy1+obS7BajjYm9tY51Jeep4744auZ8WXre7wvC48Cmi5gwWQLnHzEOIR+lmNcynQeF
cqTRcguWbmv16zJ33FZiT1KIdaWYO4UpwIbrLwW0936Ze/XgnBb0vp9r4Vrs9dDFeIqTqDvQ/oVoCtzc
otqITqFeR77gU68T/qc6Tk31R8YZ7deKNrrOPAKhCD84b69neoNJfO3XF+XDpHvHRetWIalcQ50sZpqa
MeyArg2rbWEiqrakQT1b1JiSCeCINb3Wa0DJCRb1oVPVPdKqLqtsCwc0VtTJYqZqG2JHI0CdHDQfKlT2
HYsfzwyCGhhVUxfkE/6ovrnonzZ4q3Nz7O2W42rLCpQJ++SUL6Qk7mdNqpY9i32A8I5RuWNTAepKbpOC
AUzhqsAAP+wKkhMBLpc3//nuj19/Y+oQYDbu/hcIFpa5k+keC+G8gByDPeTm245Tr9s6c0ElQ7Wc/asG
+JXqxJR0qY0MKPC9EXCmRf83AAD//8HrJknpMQAA
`,
},
"/js/moment.min.js": {
local: "web/static/js/moment.min.js",
size: 32364,
modtime: 0,
compressed: `
H4sIAAAJbogA/7y9+XfTyNIA+vv9KxwdyJOi9paEZJBRdDKEBOZiYG4ykwHHN0ctybLB21g2IcT+319V
9aKWLQfmfd/7hjlRL9XVe21d3a7XdyqjySgZz2ufs39h7GsyywaTccWr7Nd+qR1QWriY9yezDNKuBqPK
9WQSs8qb7MssGVde9pPZOPnKKm2FpRJNxvPZgC/mUISKDwdRMs4SKN5+c/WvvMrPWS2ajP5l9xbjaA51
2qHzoMIVboeMs8h5yO4G86hvh7N0gYWy2jAZp/O+8xCFgHPfmyXzxWxcGS+Gwx0/DEKPtyjnYDNHhHjA
vagVJ71wMZx78/5sclcZJ3eVV7PZZGZbb0bTYYI1VUaJ5axWukURtsh5kFi/81oUDoeUlsPEtgJ4SEbT
+b2302SL8SJL4qvJFxgEr9OV8Tfj6WKO0QmMeG84ufOq+yzqh7PsbdKbv4dEr8GwwQIQ8AzGX8PhIG7D
8PapKyrlfDIbhQQCiGdvRGI4T2IqlU3gY3QjwWGe81q2mE5nSZadJfCJQsy7DmfjwTjNfN/fae7uWosx
jNJgnMTWjj+/nyaTHk5uNhkmu7syULuDMsWYbRkoK3cCp1ex3NAYqJ4YzK/hrBL5O42WHNVRvhj0SEe7
uzY2mgFg02G8Fk6nw3t73h9kTK8KZ1WYh1Sg/zvqhN3lEopzh1EE6jLA+oUp1VVHOmlqh2KaqbbIwUry
4oMfFcdSteEEMCRn4Ty0ndpkFg/G4fBRtJ+h73nsi6iE74hJOceRGMveO4xquI19XMBQRWK7IUSNLg5x
unGYuX8vBpHX7pNwtlw2WAzhvxfhbJ5QNIHoCFcXRnoQuUuSLxhOIRyH9xjsQ7A/WRD8AOEH48U8wdhn
iGUJLIQYY18obzgc6KSWaKqRmPnuF7eZHOx9do+Sw72Be3CUPNvrqz6F9wCQusd7PZlCbYO0xD3Yi93m
/l6kQeeh/7CSMTHePixxc+RlJl9wPkxsY4BGYnx7sPdxmOLKAIiPE9mcxQ6svLATd30Ofxy1RjHLmk8u
gciNU4tgaioKvVZBGGoEhM24SN73JJyMAZgMOSzMmzI2NgWLWdIa9OyyTchrt4PsVFDc9/xzEs0J+Xqi
vwnnsG34JAYqsxWqJ6Cw/be9rVBDATVEqOFWqAxGSTVchH2durXQ/PtIlICAL+Lbu5T9cfVSDQwEfZW2
tcSk18sS2SQR9nXq1kJTOShTGpXpI8NCq1GOjVijOtVhb7hkbCcNB9dihOvwDXdi/w3vRF3cnLAIS3En
apkmeo0ai2qCBEAmN07CoB3O+7UoGSBh8CgC3AcqNKnzVDFfvSt8y3IJOOQZkpHED0/8RiuWjX7BW9BS
q2G5sWyCnQRRYLmWZ8H/Vctx4xz93ybxfzApAvA8scu9xkrvt5rc+JI62U41VCGkArYgaJQsArCpatFw
MoZ9Xgvj2FYYmNW2nBpsiR5QPGAJu7vVqs6LakXSxKvuI1hYlHdnZnRHNZr7/4bdH2JLBtmvCYwj8qAg
8kXfPRtDBLBWb7UYZ7r3uqWFurMtLAiIFzUoYb2WIQcBZwdaPMjehe9sN3aANaZIpIQ8Bv20XO5a9jSZ
DVDGGy9GPJk5lUFWiSVLT+Ja5cMwQQELhI3KWkFRgFUEAkh1gI9EwHNi4DU9ZD5WJsimrwWKwI28iBG9
jhezUDefzQWTSxSbMzjkXKxP3UncSIVRo72IHIR4l+QcLWCTNAZxsNPwgL7u7iKzBK41B7lWsk432QN+
DHt6jBKohTzVYqM87Lg9BEh3d4eYKHJIJoOsFLPi3V3oy2KKIth7oh0A0lsuU2ODLfJNaXUmRJorp7NZ
eN+FkfEFra5NZ5P5BIdJ8xQpchqIvpYgwnb+HJ7lMgQyk83DcYRzgQVz1HeKCBABgBmi/Q8MHwiY2PVM
0Syc5pw6yMRqnpsCqUBSEsM3OYlbses6Nsh1SLVArkHKtlzuQMIpETIH0k5tYrqwR1PXVUs4dXt5+75h
14FDavkG2fDbyV0yewnLE9bkLJkOwyix63bNyZ7UmfWkaTmt0P8spMIvUYfDh682aea9RopsGEQL0Xok
yaGDegCJBtz/ZsM65SifAiqfmq5JsDGS3+2cqyNPb8Dc8NoAKPm398DhUcyyHCfyj2GXWLBqrVYyzBLs
W2OnADkS68wRVbQiv7mPRUTyas6xFZoGwNYXtaasD7LaXDMbgAJprdMl8UJs2Xw/IjPp+QkSeAekPVM3
E6M85zC0i3kEf3Fpx7A9VZcHUqjVNcH6AdnQAjWKCd2rJ5sOknfPoUHFpRGdpC2YZedzbbrI+nbfTvNh
/Gxs+9O8FW4IxESrDTRMu7uD7HwwHswTIu1AYTmwqMBgcVwyPOJ+3CkQ0l8LhFSL0/inBjID5rpN1nCc
WprMIYFyjY34Uu0W1UEO42B3QtZssoMmcJOo6xAASdV5uTODPb+CcHBwdOQdHD3LIV4ZEOHTQ1g7Ddg5
T5sN7HUDtvDTwwauqEZe5FwPVAtoWgh8bh8ASEipKX2TFjDmdn7l3ReIR4ZPms3gV+5R9CVkNWUWhE9+
tSl4CitIgTvBSwl8ZuCB8Mn+QXAms14ZWRA+efY8eCWzzo2sc5F1LrMujCwInzx//jy44F61yURXblVf
zsL7972PwPuhU6f8hMOuPnnJxR6FLyv23Dc1xQtjdAV3IHnxT9ShlfBIEX9HsE1iGalkGUifishfwOTs
iCSyAOiYqb7rRK3gr4MJnV6nrin2LCzKz6qJZtMbesYLVgUzw7RMKFpNgyWR5KP02lyDwTZCa91aDGU9
zyClb8iqI8VI4tnA0XvID14oRtESAIkPtXR6XaAr0+FgbiMmxv1EMZtI5LvNLgoSURAZcGQPafGTRotY
Quz/Zie1DA1PdgO2de3zBNgWAiraWSFCDBwnUmI3EpA7IJoR22k4EKs2HT5Lwi8tXq2ueq67MhZJ3r3f
cpJETQCkO6858Jfd3d+4M5/dP/BcEwUtdJb8vRiALGjV6iKtjnYRloPA2gQxK+qjFUFVSQjzOv9dIFVK
qwmA3IRO7TsKrFprAb3b8UQG4Tcp1ltzTmsjqrR+0+ncZDeX3boDs6wZ6H9vOsub7pN6yiyc3Tzj5kak
5VjbOeuEufYV4ndckHvuN1AcVDMfnfAWB8ofI+eaRh38dgMV8N7a+NW8IGdtoooeaCUKq0bVc30sZIg1
57JYgOmCRaFQ6WFUozbYzLvC+KIAT7vBdgKo6D1K7QXLgsOGQpKw6eu3ibVQGMYCh6tgAZIbfJ1/vJdm
CMPaaEwxqCEplhBkQUhuK6GYPaMReA8wYTZ/g5IC6mUnyCQgcZ5kCN5yQj+ftvfIh1ixCIurfrNEffxQ
sEnkKnpL2WWFIdb63VL21k/CAGudwX868VYmfoT/LI+CF/CfDKbwnwaNgzDy/qPgFbCC1GBRlGPUOD+u
4TcrMGvgkXcpa7i0PKQYzlrrL9fSn+j0tYzbvLu6gt9lWrvdlg1o58E41gEjFOvCf8jCocw81TlargKN
BjSseJCMPgBpTwT8XxruL4nhk8Tw6ZPO+lNmXemU67xjlzrxSndAosDOyRHWw6vHVgZev5aBfl8GRiMZ
yDIZuLuTgetrYzqecO+DqlFVqIZGIVe4FWqFWSFWeOU3kd9XuhpVw9lEJ33k+hxArSqypP4nSV99m9of
7b/sfNdYNzcW0jqHWQP4axCM33EXwAZDUbeldBFB9/7ksFU7XTS7dpQ+VG12KS327cgFhBK0HyEoMCnW
YA00+Lj2UWMv7gC/c0+BEO5rQmi5qN3FnUY3qCaeoWj8Z11li0B0Ktmp8iCEFBcQ4fyDPRv0LQdYntMS
TK8wF7gK1otI+AL42mqPsXq5YIUGTqsVbfECWxwIXLEXbYhIPjdRnxnL0GzJS9mSQjtwgjeBplj3m/Ec
6HcTxPhiibO8gmIVEZkRhHC5WRNuhgSlYeTxVMHV3eRskA7mCA/QReBSMqXol8BzulbIIAIRMvoPI2NQ
Idpeg3+9sReNPZmgWL5RxcjYrAlK5xsQmbGLExTSNyAuJcRlHjBCl1jsgoqhud+2GmgvKg7lX9RB4yAD
IWlIz4cTYHlr4CZpg3Igx6KFdweEC2Eb/n2tgVuJrrlIUTNDo9HGMsVlcIeAd8vlwwrruKvFfuwU1+21
KF5cuXcbhM8ggAUKZ1AsZNbZggOnBfEVNpnBJNdZp+RyhRL7wiix2Wg8ANtYxAZWGsuSMltWt0ECL5XY
JwV8RkaHVoSaxp0cx6h2cbFcqvB1HnwV2KnfZH3/ECUMG+GY1jOFIu2wJjt0yL6LxmcEuoaRQUMfBF9B
0PEASZhzSJzMWjy5A7SbqfeyojTdrAhaXqzoDitSbYXF0MMPS096u7uumzhez1eZCSgliZt6qcMG/oDb
Yij6LHV0Nf6AcGM8JyyDmg7nQ3q1MaTSZrNDR3xSZ/rTJiPzLejzWn0lXb0Q/xXjlxI0NrRlHD89AkSC
iiAnZ3bPUQccJQo3nqfCWMbc7gHbMks62kLgx9Jm0hZGe6aaqDOEMOyQSefgJCo0Peq2XDdyZNhP8U+C
qdj/1vEJiIEg9ReyC6UDNH1EQdNreAofNtPHLgmyEcTci0BJFOfKdLKeqgkP5ZmTMhRjL+jIM9OGACPJ
cQW8uTP+KNhiYlAT6CSWjtmwQX5HnF8webzB6KyViWNWpk5YmTpcZYVz1S7DVWKoEX8a+qikpFqo1/2F
GkW7z6GPtJfxWL04R7wwNV1PlFkvUICWoHljrpWFFo8MfaQiby7f3/5y1Ggq4fnrZBBXnqCCIoaiywzT
CfoFFKwGsAMsC4d4AJs6VXaBgTYuv6eamN7uTq58ksCFaiJ/oZVP1BYTUhZh4dmpBP5AyiEVcEDCYhHt
kjSnrqm2x0awZHv62E5Zggz/DmHP7KEBPJXmCLO0G2kL+cD18wjov0kXmE5QGIymV2K1oQoSh/2HLBdC
3dSmIbSoby/TKrEO+f3qgKU/7lIqzUQfxNYQtr/mviAUFHP95r4Gkg4lTWmFJAAD1gcaguuYnRfONv4q
GCgMm4N903GW+OnCp2N3/nvTvel095ybLqbWnHrKcrs1k8sn16aXy2i5hI2YrIzKPpZX1qneQIX/fbLn
BjXbWXZuug+rLto8bm6e7Jp2j0+m3YPWqrL045pUU5tvxXVTH8ouuBuIrORSUKMOsiotb2Uz08haPVi/
KWjusNVtYNahQbPERkf7p5aNdCruVjytjmnfws5EnJ1el12jyHMhjOepK06zi8uDQXKzsce3WQ8F5loW
TWaJnzJbEOIEhvokRayYCJoQ9Ai9LmAWTEvsk3XLEWxz2J7AUb8lEejbOJ6JYHty/LIJjpowKfWidZsS
gPfQCAMKlEIBWhp2WCQ3ui4oB0egi1kVS0pEq9xGlZYhTEsRun4qMUosca79SY8J1weR1WFIEVd4uFMx
DcvNfBBucRCeSEatAMTuseNkmMzNkmg2jKDCeXI+m4xoe56HwyEPoy9FrhDyohWnI7gnstsoN8Mim43F
/gZ4dDqI8nMYwxjMuV20CA1a2MYw4ObS9b7C+BST8MhZ6lag+vr/5noY1+Ei1Hq9jcPiOLjFQ5wFYsal
DVIvCFnK0Osw87RKeXAptS9EtW+FhAbWn2eJs1IT9R+IeuM8LF5rWoz21K2jbq7niOfEB+mBGLJ+jqqY
qwa6+fy4cRLu7vZR3ND8Fg/jDDdDvsnm9VGVKcfk/nEb+LkUZ8wquOEmKJcMnhGuT0OIW0GehjiCw0tv
sVx7AmxqLHfycqYNXWwDvzhBJRbIHi8h4gmQ6GE4H3xN6BwGaHqT7ewAB2Sm81vKCwaRgo9B6NBpNQr5
97iIwgw6itadXh4fYTzN43j2CqKHjscYH+TxNsY/5/F7jH/xkxejqJbt7nagApYAwWnCdulhfGRBrIfZ
I4qOLNaT+Skm9DE/xfw+RfsWS2U+JcSY38f8mKKxxfoyf4AJbcwfYH6bom2LDWT+Z0y4x3z43Fvss7aF
f+nsd33OvnQOur4bnjQgdNj1I9ZTrpfAbL6YXpR8w+xU5ej4UQ1RlLVz+/0JnS5X/WMY9eoxKlA2UMZj
1CDEIQX62fQYjit7wPVknNfGuY5kO3Uog0KzF0uXH9Mrs7Be6JwAdTrUUUKG6rSWbI2m9X1k1f3g2MOD
JqnPBZGHZ1VJte/a/ZMYMhtO1U5O+hSChXG8Z+M5kWtH1cRxe26TPVCr0pNGEHphtcl0mykt9c7sEAuk
prtnTk6JmAqaqt12+Ka32HJZdG4UfnbSvwdlG6TGu7uWRZrPnCtJw34wHIobK9CYN91xhMww8KO8utoU
xCHa1CjwIrpM+BRCPEDy88WmQzPPjgMizZ+QkqI04RGrYAIGyK6xaL4UWRIy9ya5RQhmtLu7sDkwVHGG
SyG2w9fEKFTXJSNDCBi4Zit+wXN+FjvoRNIJu9BS4RFQcOQ0vGT5pg/XxthweWReOM5ZM2xu0DzuwEqA
mg3nmZj0JIZn6fdSlxLHrjEQiGRuudplMbDgD7rQOa70MeradHZjiskjvnZehXjSbXh41zx1GvOi24Ks
BScioDGJSKF4rGEcB9dwN+Q/copWm8uGyoUbM/Zo3WWKcrjw/HK8kQI1N/qUG3z+sNHYC+vNw6PG82PD
09AEEZkABbCG9x6XDvGKM9R6Y7R5bTqi587GeBxr+OARBsMzM3emgSS0siy4/w3Ve9w0TIdAYgLmehpF
SZbBQpNXKCp4I2GR9uGbVNLhhIfDCgjU06Tohscq4Tiu3A2GwwpPKrNkNPmaCAelcWUxjSYjxAg8El31
ahYML8otzkqdxM85W3D2lbM77lt008OChvll7qWiDYH4eDQN91ysZ2joOGbf+aanWT/M3t+NP8yg3bP5
PTtFmfpX7jfZS+7vszPuH7BX3D9k59x/xi64f8Rec3ThfsPRCPBbeUtGk3iBHrTiC8LjdDKbZ+zf3K//
96YeoAB0Y9s31eAmdp36gL2FDIiCrBh49k0MCmINwph549EH0mXopoYZDwcrJ3CCOmsjShtKfsCi8H+n
UX3OaqBjfhTYdLy9Fj+j+FUh7fUPylxipcs8fu08qbN31PgOKLeg2qKma9/cQLn2ZNluB/hveTZZnp3R
nwD/LeM4DmL4TILlXWeyvOsGy2v4XsP396U4Zljmf+HPMk3tNE2x8osL++LiAkPJ8tUyXJ4u+/1g+fp1
sByNgmWWBcvLhyY7XC3/Wn7/Hiw/fQqWpGe/L2/l26vl27cB/lsOqRzCfgDYm/gmhvH9nYKQc7Cqs/+o
yCFELiHScW+q3YCSjiDpivLdOvsD82CQunud/yesfr9ZNBqnjSp8np2fw9/jBkbOjjFy/pwi52cvMXJ2
TpHzV+ddF3T4ReOIchtHAFoHNfAm2wuKyV3Xgdr3V7CK/oRaP0EpbBQ23wvwbz0dsGvIuQKIv7BdN7LR
gK0mu4Yr6aPqHOBinyhSZ0/kSNTZrcjGYQgjCuIg8AgHQYwBjkCUx2EY4gjXe7YHawgTCWZJJUE6oZV+
E1fxD8zGNX6fqECV0jAEAce2r5YVh6K2Z/zF9ru4JPGfnXcccIu+wyqB6j9hNizUJPLpEKvablfPzq5e
v/ZGIy/LPoEoG/mdjjzgErkWq+smQ2Me9uXfepd1rAIY9WcDBA87qp3r7vV19ZUGulZQayBrAHkdZ8Ua
YPC7XZZSY1Xra3Rsxeo0RDTr+g8NDyFTwOVwOchGvswy07EJfZhYOd5LGmdcZIPIt8n1ePl6sphlS2lr
Xl4KV2eI537PlnKJWqIAbeZ4TXapQskBk0i8o+SQEVoP794wEIkz75ejQwi2hRv+/rPn+8kRQwkWYJrP
AOwIlOjP6LefeZZhirYYxFVwhFlYBegjnoWWbIvFHvm2sjP8Ys6dJ1xf2bVnDbLJNYXbnnRnZb97lryc
ZLF7z0JRCQqfUXEpVIM2JXAQ4lcaDUXTVOQJwIsLnUsJoMJAHwBw0iOR3UQKcBJpEaNMN1qLUVE8r0lC
ieRilcMIedwI/mbe4TMYJfjT9/b3YWz2j6DrzeaKjWE7QS8rd5XrSrtyVon1pFZgUieQi6mvK/3KqJIh
VCF/Crjb3hbZRV+aWLF224AKH7mwJuTbyz5wWi2CYel/VDwvebatbUIoXtEEbwXR+t8KRmw7FOXHP9dA
ZbWAHZG3Mv6npdfGJ/7HCPKyd9s6hqDYs+ttAHKtIczHjyVAU6pE6hzoP8z2CfTHwOxQAv4Y8pmCLICi
yBn6JhynC0TihlDV0squO7XNa0ZHgA328dZK1a4z+oPH5D9TgPqU/jQ09gtoyFZQY6MbjUFm9JNlqD0X
/6QANil5bLXIrfDqBwtGgoXbwIobWjqeiQYhZc/U5cqROgVFY8CKnf4v4msCvtfb8MlCKyClj0M8be4v
l819oMBbKaSqcgXcbAuM5KgIc1kCc2pLTDnztZ06LAiELyswtbcVcWgNXW4pVVKGHQj4f1bg0+ZOrRIs
+RLjVoVd2sqvEOKRhl8NMZ1ctF3sQVg/ovbifhYJztMjsQk+/e9WUET+fds0Ie5TzolZfH8U6l04Itbz
1zagxXjwDQF+3wYg5RQ0Q7K/icfPQJoUggxIh5bBRCGmaL4RXM8CbmR1W2N9BOV85T7EppOpTcfDX7lr
TayuP7Ap0gVNXljCWpNCmUmxDED6fVVk32lNoxo6vFEahmA5sJH9Odfj2UOWzL2NS0Asauk7qqEDpBwP
iywFZljMAhwedMngZDjoWLeWi7EVk3fyPOu3cAyjd397nvAZBdrhLOrfnk5ngyGE729/W4wT+DO8vz1d
pItsfnuZTOcJWtlu30fzCX7fTb6KhLMkooCWiW5h/ciatvFj2ZKOvlTa1a2jaaEmYvOwZdgu1SpsFLYJ
G4RNwWZgC0oqF4h+0AICKjTDMC6WTQKLaRpMHAS7XG6m+R28f+Q3Ws39/DhzA0r4sUd4UIJXvDr7oCug
S1DsW/+13FyIzOyIkVVyWUwWchDlsTLkpndtnHvW1sixVvjVlpZTfuzK8osLSO0Vz7pcjCFwCyoLfq4W
SYbf6yQei9BVH8g/Bs6B18DnMgQkKNGbE6XRbZ0lBdGRxxpdoxFypUBLsBnYBqwfa8ZKscbSyn6wLgpg
ZdUCncBKoU6oEmqECqE+qK60NoT+YV0AZNRUONT74RosQOtVWEjV6/B4fRkWwPKFKBZhs+tQm3hhLWrp
eX01FuXybbko85trdb0FP79a10uWrdfiHQ7v4e0VaMbeaFQ5tdhbz2q362dndfIFZm8p3gZFj1VUylpS
5e0VpUIyahussp4J2maxwpKrnPK9DBOsE6pzwB2+u1sOUZtP/phO1fWvLh2L/BRk7leDrV3C/2dnaLaM
Cx47xlGGONlv4rn9lsb6HI+tGbpCl6xta4pnGXZIbvbFS2vo2HI6t1EsK96m8OqdcNq9qQWjAP7UB0zl
ekWnoryZeGMyCqzpCGSfD+gDH1ghhk/bMAu3KOwCYZp5DxkIGmdoVOhcTWC1VMJ5l6ZxnHybq/TRZIYP
EplZ12RzwGGqdFQ63twRRT7CSktmJjrME2U6byHYrRSLYiteDaGf1ltonm6d2Tl1HCnGXIHkS6OE1eN9
PHE6zB0vgm6b5/PeQ28B5aBKEBieguAzhXZ51tOsEqYTMhyFlR7sNWXGQvtRWFEWpBHEnsYympFFKRxX
hFGp36c8EvDJxBRWyFQD+jemCzGrTdiEVandFsikaHaPWcK0dH9PORjJYGAK7V93J1PvDogBMkHRv3Tr
ICWB9vpwvCTfDU9jWGao/OO4nIuh2j4fherCE1CixejCisPy1uOzRPNjVJ1B1Ryqli8TbWcQEiCng09j
ixqtcjxKUYfFZYhC6OEkm/c2CVIOQBa2kizyMsipLbl2F6L38mq14I7eAwB4DQbp3hGkGdfuPEtepa0I
O6SZte3Uz4BZITHi+fmgdPiTd+3V2PPJZJiE4y0X61PUEdLNF3t2GpTqc/zg0xkpvqOT4Ee+kdMTxei2
QxPD0pPvM7dTmIsfPOwFRbZ7L/n0wgCdQeJ7XvPZQjrgQH5WQYjKfFL5nJG7Ua1yBQNDZ5KDLILtF6ZJ
vO1MUh9IjsLPk5k+llQvicySXjJD3P35fJp59Xo6mPcXHF+Hq4sGqc8gy0C6qzcPG8cVWEWwjWcJVNCb
AE8210zRiZKcrWnWUMH3N5TRTlcwGvkshvKZYrk70hduW+odF7HoEVf47f87LnqDRqMCYfv/zwWVX4/J
F0/DWFvFBWeuNHN1iVcfRHtBI/bLKAWnezuyV+pE3d+kZfqSiB+ygbg6rVHUBtlZ7qUV9OmoIVx74SX2
QvnCS5vyiJ6vNv33wsDu49jwoE9vdHj94ns7oePZA/+tdEUEiS2wYzQ7oAdVp9kNqk0Pb6Y83CMt8U7t
AV5ccPZi4EIYOROREUVeiUhGkXOZI2IXFFtRZe3HK+uVPLoR7u4ad6GMO4kM/tUs7d0nvfK4EzQ8jhWK
pvegBfsgd7cpdIAKHYUOIdSn0DMIjSh0BKGMQscQuqPQL13YPps+k31YgVYPyAiy9f5yac0nFCIHYn+G
12n6NczHrQfB+YTc52A2YBIyPy2+dNSvtTFJvnGU0PYd2n3pcWSsiN1dfILFkt5J9LJaop2kcud/ltAi
lA9a+neclqS47il9rpOIGZcSzM0sNjjtJOnEMEgy/w1f91PZKGMy56s+0OH+ZBgX9rbeLCO6Lo6OsztN
L6IAJXm2yImEHRV9vcJxmlNniq4/yvSHfo1J2lfpYZ8kjAuU0fDMyZ8coCcsjTcISrarftcqJDeq0hfO
AjG8kPo2x+sVPdXwvSvAYHrbGO/1qaB0M9OXtkLOZyu2ht4v7ZX0LuboHozFgLzQ6wmgTNKXVtVnRyTS
AzbcfH0hlDnoyya8rSlKvnX5VGBX1qYDk344JQKoZFo2J0WOljktotZ10oCOcyFdwlDvy4XFgSNj6lqa
w3bC3IlO5dHdsoVy6eX+b6YC2wLWFnbVixT4qsfKdAUsYwaFt6W+qOt+odq+a6zKUgjPNrlGOcqheJbp
K/dnkb5a3fqKr/60qtWv3Pluz8jU6bQA8Ri3/HDwPfljPJhnZci/6U4JYa/08SNigngro1VYcbB1bbr8
gA9L8LI3W+iqAqEnSv5pMk7KfMx4uft2Xkhy4I37mGU9QkO5S+byk6NfgubzRsPbT9DkP8It2Bv7X0xT
Lz12VyYBC+c7KCYfrdyEcaVvHD3kKe05+QskK4byQglm420mwlBvUuvUM2XbpHH1Kp/ctFYyBu1eKBU2
6skVMoWcCVOIctKodC7aV91Pn2idTR4V9kXLg/w6gnBClH3E4sAyNpsoDznlaAlpSZ9qvFDOnrhBReiF
/xxfNMLnRgzfl85V13RC6XzqWo6nYR6DwobRI3LlJ6+yKR3tdaotzUz7pIb6BC40jt/C/MyL0s0TpC7a
Xug2SslwXqiFA7v68uqyP+jhq8Tbhj0M5KmkfG4F3+OROUwG1Es3NLgyjx64UWG08tAY2I5z0sCXjxnu
FJip82GYlp3pjWz9cuy0h00VW/Z0vrWdxmtPsLLn0VaVmY63GiTj01Ldrlurt0qLxZiRiapbKA1y6CWv
nVGTq+/SZdZh4sICPZbISpRsQcPeSV8D8iIvyEN6tW4e0+ZqO95xYdACL7ObzIKABfLigs9nYTSHtCok
qijkxINeb8NuZigA/r+lVo+CYU48xMFgNZUB3TB8cg+9rMlig17KIHSOcpdlkKYPD/aTZxILqgdvxvKO
qpsW4yhi4uuhhlMC1CcfEHVt02GmmqoQ3g7BnKre5cCNZnPjbb6qnWJmupkDZaubXdyKSAHYqQFaglYN
EfTH9Xv12BgcFIzreA8TxRnR7hR6rby0aMhipLnaW0smQSul15ZMQO8w4b4lx7nad+rkKCZ9uIzko8bh
L5Aeg6gXJN7ETmC9oBLgbRND9ZWch/lE+BcTeLjSFN5Yj9DTWn8xCsfAye0dLnG/m9xt3VyYL27240Ys
sXdqJQt3hI230PHt1rVZwb7TPRVaWLCq8eRAmBfxCnziV49O4sBSxlXLqzYxrmyxltdQ0TPA5DUVMMX2
MSatwJZ3rGKiYI6zsD3lbtzcqqqHdiL6QOT3bRJO6RrKJlF7ZW4BRasfOy8HzlVgw2JvNNRKhFF8HPKZ
glzh9Zit5xKS1gs6Z97Z8Yy0wiUeJYqBwJtoa2HxqS5NP8Mqp3tGIK3Jc1Zvwm15/4GmVE59oX3qKR3/
G4nJ9GwGbTfPoBcN+WCH8l6Uz6sQZk8SJnzgRILR/hEwyq9QPgyCi8HwX1F4aWN6BX8VlSW3sVdwVFGZ
ctt7m34gIKJJK5PazJIXKy+ihpM7PYrLResORE2gyqrDBoQYkYM9Q9IzKWv9QPMrWLNrg61kfhpsMXNq
O8qrYsBrzFYFciwhV7EgBBllFi1rMrmVUyHkK+VKLS86uSKPNaKC7KHQl1+KCvHGD11nYyQ4nrggoriF
faC6wZ0TV1x8y1OwpcLQ+H/b1PBEirnbmvqitKmX4eiRhhJ//p8NH8A8NoCYrWWIQttGeNpt529bQ3z9
Ck3+hLXIlar5z9uhnx3+UqrHU5dKFTlq6InYXsji2Cj8Vmxm+O2xZmLu/0UzwxNsYd7M7wXdsHCbfE3d
M6mxJiSSmsdemdxacg9R+IDhw2oOMxxCXzSPKOOosQfrY6cgPNOTR34ZfiVIyzf9w6Jc3VBv+0iSpUlH
RPI0i3eInIGwITnbbdQPx2nyBq83pXjSEkjXX1OWiauhKN5E70WvvKB2kVjPwFaV3ohDxrSlCNmo5IW5
FVPub9tPtAr3+ESBd4XNXF7g5UQc98HKrPwxHqB5NRziDwMlAo82VGxFNP8+CnIRQaeV3PeXFcuJMcAH
imv0w+x0OEiBEuI1BjFS5UwkNB9IdbwGK4jh5FBIjygzQ0so6cKvBW9nk5cJcUbe9t0Uau65bW8K+yRW
ligBJFQ4UsZ23Ob6phL+dAVJZsUk/y3rvyqX36cu8GG3iazYK7BscVPZhHqKxhnlE13Sxb68pbkpk64d
2Zbm3YtXt37U03vBzLUj9CPt0E+G/RTOjYNnQxjd8NkX8/UI3mMcP1RVY6O9P2orYv5pnOqKyiZOrf3C
xB5XH5kN5+nxTy2sXM57bG3ltS6Xx56O5clPj+lW/HGOETbaFq3kZWGfNck7/q68hHG5YLObrVJ8Ia3F
kFbdiqXbaIYWPPEKOfqEFwDNS9cCtMTjQpYWJAzRcEW6RFtzfJs/IZJzT9N47wn/TPP+v5OzMNss4Eea
H+AhRUHOwATb2X5moe2rYjTLzi1MWU+31SzkmYo7HTLluVvZgwBZsQITL4FuPtvLLyHbhk6IvAjJumL/
IP84wmmj1hubio+/kZL5pASaV+qQfcuihVJmgctNWKGJ+WZEIZduTDksKnR+HhRwr4VLEzF8ysLhoBzx
myTFjMwnZgKBSkgXyiezsqlFCGMmC9gUOtwiVI96Gcasi7yjfMmgHq8LIdbqKmDMm3+f+Tqohk/86I0R
kRlEA/w8LJMVPfELUZkp+aLKlFGZOZ/8dvn+na8i2rIvzkiMRwH8oXlYIn9JbIMOCe8uKYYWzrcTLZve
Z9KMqPwWWJrLrSHr+41W8Wzcj5/irc3Qn9hkr3NYqtdfiDchOOSICxKpXmwcMyLI4DJDrK3o6f4hmgon
dlTfP0Sz68SecjtBA2IVwn9zG38FoIcQSf0AbVtP/YMG62NCr46vuvWe4g+PCHsqOZDI2UKPEbFA+isG
AvvWLV7omxbvN/Mc87fg1uAwregsvoFJuhLkQ1t7rOINgELJxwqVwatZKK+E8grwYnLKoCmniLu0u0ZW
AVrMSBkw5Sh2RBurZMYmuS2d3t155BSwZHZdEmD38ilzzbl52tzfEzeMXXm3eO+0MHm43EDIl/beElEn
leLTTpm1z3RaKBPkcm9LccRH77CUgG2efZQ6Z5qPS0Fya/ug4Au7BdpgjI8fSRJhjoMoIWiFSFc/ZChn
T5/A/M9aVn2kZdXSllV/1LKfEa6KrtmulVkkboVZ6dUjem9MyFv67AffXlfnHtq1gfub687om1CuWFQg
xfiLclN6tchAHkReBEtRvaRewPs331ixTD21LsyRqjX147JGiOOSVm7x1Vdht7XYtAJL4P3DvVJ4PLcp
WoaNAntHjdIGJYdFe3GxyJZSwJVURbl9z9s858+x7CEjK0G1/ad5/xh/GU/uxpXFeDAXvycr5VrBvDGo
pGqZIn6FCrh6pl0KbMuIbgrAxo/bGcJALv9W7PFkPogSep4nCqeDeTjMHEMoLhLDAg6UQR9zHSjSaKLO
aLziaxnyBha9l1zMEUQaj6mK6fJQ31E/4pajUmf8hV9wE2YwdcIvTQBrl1Nh7gpkJMwuVWZgr6e8aARW
Vb5j9QGfkQpCF3/aAxNsHnAXf2qAIlEQufjaP0Xwjdblshfgr1WIhCB28Yl7iiRBkpfrBT0XX6HH36ex
PjTOrNU/UDWEbmCIevnvuW6k6+mTvkfo3jyInMgeRHgJc3d3xiG1SNDI/8hEE2amirHtqSl6gTCzir60
ovjlj0uWF5Tax6NVlhYkdeSxYv3SYviiyGOl4tJSQpR/pBgJK+UdlKLo9rLt0nIfhWKzvdi9LGY4HbGH
sksT8jD5aROlb3zT7tSmX2vDC92BhWeA9NBdYGVzy9sXQaSVByI4gyBCtf6lOKUb4Qr9jQfFd69gbXol
BgdxMLS7K761cBQHtggr5d9iWy4yRTVYVb1Bir+KJULohJOHa+PJBb0Chi/SNkCoyp8yW5AbJTQz4zbq
dh58gd7lv3LttP7fAAAA//9Q1sM/bH4AAA==
`,
},
"/js/put.ts": {
local: "web/static/js/put.ts",
size: 2276,
modtime: 0,
compressed: `
H4sIAAAJbogA/5xVUWvjOBB+dn6FDkpt05x7fbiX5HrQa653YVkI211YCHlQbMUxcWQjyd4tbf77zowU
W07awm4fmtGn0Wjmm0/jtORas888Z8+jYDdh2qhC5tNR0Pb2YTSybrOF8+LyybqQAfuFNEJteCrYfNGY
x7SqBRPfjZCZZjJP5haBw0KpSnnXqEZKsDxEN2kqtPaQvQAr7ZDlqsM8J8Nz8IBCaDurYTFbkP3YrPeF
mbAoZrd/s7YqMgD/EwZ8P/zz9NEFGuzeZRnsnoOzxRCDyteVbuR9JY2qylIonaSdHYXAxb1RZThmy/BC
IwdghhdbY2oyVNUYhDaNTE1Rycg6TXoWx4y8J8Ti/2A9CtUWKeJ0mDbISuaf8Mftx0i2jZYgNeyWLaX4
hgQhJy1XLKsBRGy2IMaSHaz31V5IE8VJY1L4v6nUnsNy2gUDZjFWVmMYyi3JhYnCa14X17YrYTwKgsT1
Mepqy7jhfQ8pweAY1bUYIqMXRA4OFITk0oeg5fAkQXAu/CL5uhTMVGwjTLplnWpCdsXIy4btS7HCgLO2
pRiVeKE8QdlYJ1ZJqNWXRZ8PiHKZNyVXyNG/PN1GHttjFrVjtuvCBsUGECD45YW1SesqIM0uAV5BTMQx
anA4ZvnWBdCBN+NfXvrxKW8kteZKizn01baXmgvuY9jN1jNuxAP1uet3+DWMKYUgQDaSutHbyMbsXt6g
c2O7Z4q90IbvQa9GO6zlZQMypRQeygqiY4bHA8QqUUaALdzjwN3ixgT2WVPXDK4otyQJPUenOnT04U4l
FiTZ1pU+6rZuDLxCDIeq67XbC+O1TMKpv+HdDIxyZtVlRObcDja0VXTk5iDoybvi7TtO66Bfu4IOaM1z
Me0JPHQSt4PsTOIwzVH3nmKXnp2UQuZmy35nNyR/FBeesPoiqx0+QjpFInEzhnp3OMkEPh/vJwLKXvbm
T6RxPs6C4UAjxdvD56LnWRbd/AnzWAsY3pkOB3Mv8CafrTGrz8s7+Z4MCj2dksDW7hqn0uAJDZX3/tQk
Ln47zodC3ynFn8g1PnoESphGSacKX6ivfA7gDyqGEQI8FrD3xxR+/rLvy3YBgKurLjYNFkc3hHAaNUQ4
HloWq6Fue4GY2Etp8CZenfK/OObdO4Av9Cqe/ggAAP//hZ9khuQIAAA=
`,
},
"/js/silence.ts": {
local: "web/static/js/silence.ts",
size: 4084,
modtime: 0,
compressed: `
H4sIAAAJbogA/7RXX2/bNhB/Tj4FUxSljBpKN2AvdtOgywYswB6GBX0KgoGRaJuDRBki5axI9N13fyiR
Ulr3z7AXm3fH4x3vfrw7Get1u1GFFtc3ptK20DdFs9dC/+O1LZ2w2/yaOY+nJ453uJVQ9uP69ES3bdOu
hPOtsVugnVetT2g4IaHKrlXeNDZhqUpPFHaN8y6hvdqmpC5Nuttr529mLiFvJbKFuHgnDo0pgVU0dmPa
es6ttALfMzO6OJHulN3qmUppnLqv9NVw3n3TwCEWrZoaNx/IC1IZndw07VanXndOpzGrtXMKTQ2c/vT0
vnGdBTO+bSqIkMuLcZ3JcOMr31ZyKW7lS4fpgaV8ufN+T4uqKSjURLRN51G+6WyBzIw1VtOMLwWpryjj
v8HqRrcHUyB/OI1lvwcqyskACWmVX/+Jf0G+QOAcVCscxLvYiYt4Xs6sbAFhYJ9yQhDsYQmTUQp4ijIg
omTAVhQPnLiHwBY3EBmlBL0oJTJKEYhRiFTiFaAycQuoKOPsRynTUY5gACnwPsAqjUTARVQNDNhhNiI7
S0Ly6pU4m8WBov6J4MgfdhJO6AGXAQ1iYyooAVmpvCL43t4tBcX9Zw3eauIFzvuNR+wSAwzPyMn+ytT4
Vm1X3+uWvUEQtBSMx34d6KLpLHLeIOOvXCuAA3qSoPWwtKpmGJ3Q1elovDQrv7tgYwvacAIWutbisscf
Qh4YqJtaW58d8hu8yCLvfEHR5h063fGrLVM5mkzigYadeJeGKPgWTK9H26MmBYoU3yaBPKY2RBeVtHg7
RvsLOtFFDS6OjM9pAX2Lwb2D6x+Q3dOVeRvmagYVgGkWkIW1Ikdanqu9OQ+d4Rw4coFH564roCy7jNJJ
JZF9GB56qNtg+faOPKJE2OZhTEWSg7lWvu/cLuMDT/AGKyHfg48HqHPMjK0qwfcSz4efrqomyzfkcrj9
Vxn7sC+aGsr1l8zNLX2vvT+U819nK/1Fuz/+NDHWc3aoc2cZ/T1PDrEhD/Qf1BgKhID1FBK/gPksPvFQ
KrO0cj49CSkXudtXBhCzlOQLYjYtvgGlqMAhkMi+kOK1SLeFU85vxfLp7vX5Iv+7MTaTT3JBpyKwgwt0
UohRduBrigDugzi7EC9erAXHBR0fKyBWKPQkjDNpa6IU0FgT6y/x4nAzK7okDXNO2oiWw11X7CffAkLD
JmjSSRoMcYdZYtpcLoX0baelWHHecScPGUmTIe44a0x7DMr65OFjIDjdGBYOSNqQMZ2xCSfU2Ggii5tu
pLnNRnqAx7w/Ut32ymvujoyx2B15PkOYjegd4j4Z0hAFEBu8TWicNKAl+wesY+jWY2Xbg5uz0uagtC3Z
p+MVjtoz88IjRgJBJTPbWL2Q8HJV5XTPz79Pn14604JKSMV/frfJ6ZOguTB4JEih9/BsRpOUeQjAZFCD
xGHcPqMC4IgKASlHtg/oiTopno4oEsai1gi5IyoEw6gyovKICiI1agy4PaLAWI4q4bkeVwpPMmoNc+BE
jefsVleNKulZ9MnTGJH/7G08w/onMTdICerJcVxlvu2NfDteSW1jrKqqjxnEa347/GzDu82+2x5DQzl7
MLZsHga3M3lFCn5nnAheXkKnYD/iPNR/R0EgVy5NSR3KlEsYa8X/dGv8vsRLJx+YQ7utk9E1GVtDKa8R
dbXyA0j6O1j8GwAA//+4yx/k9A8AAA==
`,
},
"/js/state.ts": {
local: "web/static/js/state.ts",
size: 5269,
modtime: 0,
compressed: `
H4sIAAAJbogA/8RYX2/bOBJ/dj8FYwSRhDhKeo/JuYEvzTXFtbdA0z4svMaCkWhZa4k0SMpttvB33xmS
kihLbo12gfWDRZE/zn/ODPXiSaiKzzabOM0lS3S+ZWGg1SxZv5Gi2gQTMg9OC5FQnQsOb8GpzksmKg3j
sFm4JjyL375zb49MbvOETUiNtcsf7Ytbjcj0Ffn6YiSZriTH0UglYsOuzXBEk/U1CabBBF8yFEXhuy8Z
rqhkxdKqYC0WWVKeplS3kzv806zcFDD7SRawcLmhUue0UJfAydCPV7osDLzIOTAPnTiUP08IK1jphlRr
qcy4VsFJHieUg3SPgE00S8mU2GlgQKZTEvyfsVQRQHDxuWBpxkrGdXDT7t9Qzoq7girV7D0FMQHlLRl8
u+dJC9pD46RHl/FEpKyHstMeTq3EZw6wrztvMhFFQTcKt4f5ntr+vnm+AMhJd8bQMdKO8qWzaAs/O3MS
Wf/CVHy3yosUpIsLxjO9Qru9jCyvUR1N4bLiCcZZWK84OU6fpKBpQpUOx4L/smF8PCF5ZIWAICBX0Q0x
PzOzw/+OqkWOroK4ZlswkPN3nn6B+K3KJyZ7mtfGCQHk+KCedj8omi/1/9hzq2gdrjE8k/Xb9As5mZKK
p2yZc5ZGjvZoSyUxCC+KnI0O0FnEDn/TUlAaQhz2v6d6FZc5RyEnhwSJvI2Mp802+uWobUshSYh7cxQY
Gd/A8N9TpAWj8/NGN2OgHB2LNmtmR4ngOucVcwStdxpDtxHS2qWr8a716eiQsQ3PGw9SbTBPhFYLPxSU
OcQYC47LNXkSooDM4sVAR+kro3DHWS6Iu/ofqc/uGCntAkrZj0zK7wqhmJeNtKyt20D+K2TG9DcwcAK8
1SXkS7f8Q7ojPtuP6DpLmMA4yWqDtKGxFxk7345d+VrpDbEsnpmChucvix811ZXCAxdUHHMwD3oLTEoh
g5b1QVt6lqgFshwHuAyQ69m9T6+XncqqgIJlEh96XD9jcVJa5jzzvI8mXrNnrCBzZ1jKs6qgMgaX3dNk
FfrWhyJuBh4F5wdTEnu+sNV6QHEDnxVMYsJr8ShKvKnUah/RJbEvogXXxWCCpxCGvpAeZbPWp+wG9bNb
+xRDbDi29rxAYlAr8OHgTWsDpVevauC4t6oYlSDwGN0BFPDRP6erXGkhn/cOKrqqkgXMBpcOcRv88y5D
kc5BpjOwxjQg58T2CZ8+vL0T5UZwMN/f7sxjeB7nZtdOAsHWC9j+wWC3AMyBfhePLbPNrkqY6XNXWmP7
2zQbuGAb2ce7+7bFRZidfoBR09x2O9uDvSdqo5D3fvfZsD2iCzVWxGgqn22VM4vzsVZv5Ga88DucSmL4
uyTVBSozOV60aE7Ltmvsmt8vldrWIB9mzOlhjk1bZDrk+VaarpODS0v3FomasMEBPNo4WjtR7WlELgW0
iCz9j0ifO2nX8tAiy4qmoO73uN3+tm73vK4W68lJyyDqlHzrZsd4jCgwQRzHYxfJHcG8SmYiLIZyEYK+
m/zS+umWrqfB+ZBrInemYlUlCVMqhB6B+ofNmOHJ8sG1+RCVhZG0bsaGVMDzEIOcSs/UAwRviCSjpn1r
xDA1NYT/jgxDNrlHJHGWIfWZMaJekzFmBSlb+jfDZfIUzkxgu3//9LJJDgeF1D4zDag5LhFMEvfbi4Ow
5lGvv7Agx9tC//yMByncDgS1ycrbJrPWURv4HZ6b3MaSgbYJCy/D+eTrLowW0WWGaejlb9W/rq6egoEe
1Rjvo6iwzwUZSlG2p6WzGMWVTpw2w6XFwh9sFYIUvYVi6B/PGC/vLQ/77pPt2MRSg9uqbvJCh8F8YK6+
8V2QlzZjeRdGg5sZRyrvMuVP19tfwSWvezk1qHcgy6xOQgPb51eW6W5fiQ9wgfjkijQ0oss8u4W8YugH
JnsfKlcdJgiM6m1nSynK1zB/zFY0ojE2OqykcLP9FX4X799fvH49jro0EfZjNB8erssSyDVZsv7iYmN6
vmjbyW/Fj/kw048edyMwzdoaxBtP8TBvO4HTdCTf82TtENMu1Dnid7P1m92Kiv8QcAcOJoFTs+fqQ3lt
HxMd2VPMkjV+JBv40CUZ2jXR0AvcB9/5NtU0BsjtMDNzQflZdgkSOZKhvcL8LMelobLP8q8AAAD//9be
lySVFAAA
`,
},
"/js/underscore-min.js": {
local: "web/static/js/underscore-min.js",
size: 15626,
modtime: 0,
compressed: `
H4sIAAAJbogA/7xbe5PjNnL/35+C4uU0ZARppLUrF4sLqey73apNxd7U2k7+0CgTDgWNuEuBMgju7NxI
3z3deBGkqBnfo+xyjUASj+5Go/vX3djr6wD/+4VvmKiyUrDJxyqYTf40mX5lPu2kPMyvr2vX42M1KcW9
/RxlcfBqOv12/Go6+yb4DybY/jH4rtp9YjytSPCXMqv3jMs/F2W9CVK+Cd7xz6yS+X0q888s+MAOpZAw
czAM3mxyWYrqqzOagn36GNyxYCsYKx6DTV5Jkd/Vkm0CRVYgdyz44d3PQZFnjFds8lW0rXkm85JH8dPn
VAScyl1eEUn55JYI+p0Q6ePkIEpZyscDI4y+v/vIMum9qulbM4X3MqdicqirHUmhUeFqpIRWVvIslaSg
bCLLn4A2fk8yeNil1fsH/l+iPDAhH8nWrJtX6pdUdtVP7LEiB1pP7nK+ITvqiOfxk2CyFjzgQc4rmfKM
ldtgt+Rz5Kf97nOZbyJ8Pbl9EOnhwDaUx3POHoIdTHRKQpTVNudsEw4osgOj2BcUf7WM+j7uy01dsOFQ
/05M3+EwMi3a/kB3MTHNyS08zDn+kN3kv998+Ond+x9pqPQqTHBD7j0miSQifsq3kaSUIhfBNLZsJ9VD
LjNgoC4KSsXy6zl0zdKKBbO56eMmEo20JllaFBHOe0pU71fnvQnr6Q8vzYiv+0aQuncMvDajvukfRfIL
4+DD6dQd4vWFfSweoXMq7tU5qqB7spvkcGRSydiZFO1AJS6+hJ4bGJXLxzk0q7eNYi3vzRD1QSsivt5N
9ikInFXwAJ8ORnlRg2ArWZrt6G6yLcUbbPXsoVm52UBJ79VGqG3Hc8UnBeP3cpdA7xp2fFTHMF/E6DSp
Fyxho1EMlKzYGuTD44QVFVNnOIeF8aQAKYkZALPldjZ/bA6j1wT/wgxWvBwZ2KcHmCYriwL4fZn+1Rro
b8StGcHFu8wMgA/bHg4doWAxovp45LH5BIZDnf0oj8FyTJN8USYlEM1ovaxX5XpekhR+qC8AQ356UhL8
TMMPbFNnLMDjuz/IxyDFGQM4J7uAl2ATcpmnRfA5LWoWgq4I1V3tWrEpkBv+8Zx5PA2GdzjhnK7WMdFb
x8g3evNAWV/kN6VR7vOrmNxGTn3N+9dfK2EP0ljuRPkQoJX6GazOGyFQuMA0hV1c5isQDggF/pxQ6klq
5AX7jh9RXgKEJQhf1Ws4TY24BO62Zv1Dfr+Thn/xu7D9D7E8HqfrOf4xLI/HieEX3qfP8gsGfAOMbpjs
026ls7b/mVrD8KrcM+jsjROewZPmeQknj5PBNJ5rW30Cs68XL2A+mLZivYdLLQ8CTjo2is2jPmLQ1PQQ
Y6kYDplyxWiYYrTaart7FNvRbymE17sJZwBAWOQvG8foLnDlz0w8AkVgpl+2EINpj4Uw1uHvUBxrCVNj
zZSNxL1n6zkjA7QLZuPt+rPEEnIyW4ik88ffQPrsdyS9h/KppXyGlAOIkikAGmWgsqLetJ3bmWsbzOZR
P4lwjHcTZf6QTtQlOBbsy/utmmdBp2qXc/65/NRdA7kXNNUu2p1g8go0jLYcqHQHT/mUlqJaUiO2lHO+
kuvYuHGOCqYWPxR19qmfPzuf53tBNXHQww7Q9aVBnm5bB26GoVH4n+eH8k3fwH36pf8QK/UYz66noAP4
kzjVksMhNgagY0/caRD1tgegq7c5zpeCnwD87KBB4fwiBytP2CKHbc0pHHOEA73Gq89egHGvqTRNEtWL
9HhEyIFED4e5acVqbg7MAIxz+5orEeT8GRFoCfweAsgX7J8hgHQBYAToBXrq4VA38mfYr3b1dluwVkBi
CYZV0We+zCIcHWHhQG3gD0NkNE1gX5McMRuwIyA4LPfRFBAxkXCgccfrVb6mNZ4ggn+pgGdLYK0ITPeH
4gUULI9HsfyNpoKvHCG203gWrxEJG1lANx35AaU/pFKdEmiaI1NB9PP9uel9xucqSxCdGxHixSdPisI5
J8qOzQXJBE6Tp3O7tadTrNaO+swZRBymP2yFdA+otALEwZRrEAsGcjoLwGbYiy3E8ci638Yzh6y1gR1L
/Qv+ONToM9aYdd8X0bpXBoUpqEWfTg7Q+MJS6mtUXDZSYhhX4UCIx/EBeE54VAN2SxEV1CpWuhdlfYBN
2UfdbdlhhK6s8pKvxFrjCQmBKzxQ0LeT8x29w1U3qTplZc3lb1ljNNKzz06xURe2eYcr9ODSrgTIrDEX
NTAs1SGCc+usRgrnSQukpPkoXSwWgA4itCDx63qZ03I0m6e0PPlnXJbqSPYmHTB+1MkKDA2NW8SkQt+h
bxyXjTlj3wzMV2t1QvK/st61jFuf9k9uG3OHP8wL5U1TAcvBfGcH7wK+ARQKpqiBov3GE3QrkqYFKLWO
PcC5Ag+w1t5VVLjKjqUIvWX66cWgXJ+iuWed+Gq6nk8XcrkChG+kTNCoaKCiArpLs3r9PXvkrFfkLTOb
g5lScxZpdREnP0dmYxQ9Qt2y7qsk09ggciUcAHYYeG4A0LzIRodeDQ33h7QF7PuBj9M7bXa6dphoSycR
xCqMrwdpBbeoNCgNWFOxd3PcOuesTmrwW+qogdcGZJs0R6WIj0f9ZPAjvFnKZe4mLuI59DIkzdG2as0q
XK6CoeHaFqmUjPfDtkfF02BGIGJV4BDC/7K+IKNNvt0CAOQZhndn6Ham96rm+a9U/9RdHTaiO0uOIJvf
l2XBUoTExyMEAAIjVIihB7OYaCgkwM+eWXNftnAac/yTgpTLRsrlIk1SX8rpGr2RjFON3QoAc1ZwMEGh
UkUB+jI9JAMbWZAU97EJAXKSxa+nCHn00AzchJ3EgKumcw1bhZ3r7v7URmC+yfHkjTKMHj0RD6b4P2yV
OdGY8WZZx2T1i9jhLZQQxCadtALRaTDeTYOZlBmmkVBogybAAjuYxw2OAwCbiEWKh8L1cIuAyKGz2oUk
BZHDVkotCy9vKZGnRsVaHGnKQRTnStcIJTk/zOdq3OaAm0Dqr/nhb5CgNlMNEaEWWujSVaY0gK4VQ1lp
hClAitRitWY4a2dfyruz9EMPQYBwLEEC4M6l/ZNLscLNA4SBAbR+ADexVlu6mq1bSxuFfTnmH8+MB5x2
MrG6c8jr/R0TTQ1AWLOI8a8HVxRzBEkBrZDgHWFimHQhlp4TqkcCzJtOY9VNVsCOclMnDlAa1/Tub2aH
+1kIywV1XGDRQlHHRgIwkKYxRwAJj2CLxmO2gP1+mToIDu7PHfxZro/OYEVJ+fEIrphOY1AsMPOzJnVM
nZhUI2N5EUVyzONriAqgf3+gRPiIilhFRbyJg5QINr4hQu+BtaS+7AZhuN0HjNxUF0oPltWDy1P0+Qhj
RlpVhN5cZvg9zBvs60pi0Q4nYpugBBfvMH/YHJwLyRaPGVw26pa7mPPXTY3EFuLOjA2AnmTTlPGoV9LT
GV6KDGzafUDPEmNDzQr18ys4I+bKKQAb8zkEIRaitkCctY09ok7OC0KNyZiqIE6HoKgnEDBT5g6yASYM
EAnsLEa4qtkYdDEarbXvTcTrrt4msUEi3f5dWWMxFaNOovXsu6KHM0QNZ+4KlWi2gJizURyjNGYepzeH
tKpAb+y0AU/3rAo16RJ8FlvIRKJt9piTa6KiK01VhG0vRa4LQGxftkOQJlBu4kobjsKGQ2CAhV+5lD7z
zc7PWbPzGOphSQ+AkD6k/UMwm5Gvm0hXL4LOQBnzDSvSx9+amLSTVEz+nO8ZQMDoch0RlVoluTWu3jBw
2RcQI9JgRu3IipPZ+pLuo21Q0+GWStmTjnEZM8TQSAJWhcAeRugAdUhW+Ce+VAmjdJPze1DiwQyCwt2E
lw9RbCdoDiXWXkmqkGetvsWnnuOj4aCZJCkhuLALDHABGF7STFOypXIcZePSSZbpuwN1o2dkuqDb43EL
AVuUwTzCSj6NGw6zZ4mM5ykSIQVERpZN+J5Sbx8LsgVVyU96q+7Kug2uzmRLStISY4vpcQpoJhsOs8V0
ydqryHEWzyNt8ohQsrCE50g4g1e5I7xXvvm5jFInboPFh8OBOypMyaJNBfAK9HUXdwuTUgkCrzZcSmQb
I6vhoSvyPJt8cujywlE92fizrFhXttzjVtImNH7WfEuCKV257l8uEVjtwx5ibe4JaFPrBKcISreSiX4p
nHE2HvPXs4vGy5TwlCFnQGWvYexhyM0N6gRMXZhdGp1S85dcVaHtJtkF0d/rpE4XyA9aNxMaPA+fKuv9
VQ7dhkcNsAaoEPC4yb25sEU4SaqoRWen+vPbzXUDjGibcEsDM6F8L0ROnsOFfYWfdbNXyvHn4p+2gJqf
mGXa6+T8MxPywkLoWbzVNPoXZyEHxBgY6awx0c7WLUHZebE8t2dyV26qHizTtwU+XgSt7t0KnbvWxdcv
krWA62VVCHjiFSOAq5lvgM4CYukBBaYJVUTKOGuuC2FJQKV1kdTWzZFD3qnYedYX09bnd19qfNepGiIZ
9801Eqal5AfrABvVvQ9V/oBQBANtdwemoDY9hemSPpDOFZZ1onISymDPt7RwYdIiSzJVXypW2ZpoOuyS
SEc71VHu897bMl3uUKdNaV16V3cY1cnhF4gn+u5cnHSD6PMMAEMIc2osP2yOIcsAm7Qu5G+zKL4agQqd
p1jgDGqoaXjx8WaTxUIJsphr4K3NqlImeMaz21amrCh5r2PqXsby0u/cgv65PSURnGvMxivwdckt4kSE
6yDx7kJaz493p4CIOFYJ8e3sWnqKfTya5KyTHA5M2ncTVVGNuzuIMZHdzxKMnftsArDC1hbUrTAgwbyQ
3j0HcxWw1hcAw5XOtwQf2P2bL4d1OG+91aoEb/XwMBwBsfBXJq1uP6pMges24qo+uBxhBXIk51NVhFjO
rkdGGnPV6M7yF1D4LgEmLepNrQaeMMuiuzRZFpDs2TvZMG51LG9sdo44AdM2GGZ4NofpZ5no1B7HE1NJ
UWeyFABKpf+sbikBn+VwGHqvQ20Kuq8k4Lf2eU/BRqX+5qokotehhA6l36H0b63YagphtvCmkSLZImFO
jkr/1yGWrJWyZg5pgT3LkFfzqG4RJtl4DCq2pXdw9MCwSfyj881x0thRvG7b3CZUsx6aWc0XGTeVqMyf
vaIHnBY7IsCQpAJGccEKF6y8BV2EdygPkeJU/W7VHc7qza91p67jTu2dOqBgJ016HzrjXb/nc52DqfU4
1mjoQoQ+C+6xqUs0NhAVvZVDU+ZQeyc1p0ZS8sK1IyCvYDhnj00bRAO0J2hWICDYMEwUGZ5M5RFCqbNR
PfvvbIQe/L6bbrUoxB4qQ2Hosk5U1ZXsSaPqtsZgwO3F1mgVOtGEJLRqDE0tQGhocwENPPHwo21PuG7l
q3erMK/A3qwb2pqNdXYNlnc8QudRuA5PuuDsbVCDpSFgan3qdx56l0KVc8Pye0wa7q1luZ5cgw77B7Vn
Ll9ojZEazAyFb7Eo2evA7LcIEcwgr35Mf4wA8lfsbVGmyuvq3YP3l/yfFrKaQJtjPcIY1N7iMcbPU3BP
Jo4+N8Ln6vNj3Ulatcqf1Cz6i70Wf2lZE0ARJfvLN9YGeFcmszVOnX7h5Z9LvgWfLnuKSHh5XhIMqE5e
ZbOXCnN7Dq1sb/2vZ/KTXt8vx8ZPJ+/O2fM3NhpwseLr06m5OtZzGk0I1I5yziLKXnMmLqJZpiIjr9JV
qzIJZgtWUxUh1qvZGk0O+EPQ2yjXpsxZr5OzXgo85XtWXbiwqk2pX1qPY3upvX0jY5pwP1iTgFRaIZq+
WPTcrUapqwa6ZMBHatFtUcIKqmluJsX/ipWCkSnb8vKBojXChmdI3SVEFCB+jyf3Ot0SmfL4LX0Kh+E8
HKb7QwK27DW2C4nNBTbvsXkVXkHz17pU76/w/R++vPoTPvyffvi3aRKeyAO1IWh0G5OPPXrQoz2YB8HI
NIyW83DU3Oz4WOY8Co9hPArjEOI6bWV1RGzbJLwPzxPl/tm09xhCoBMMLDhfySqpkbRghyIFLF0TvO6j
rgmxKksPjH5E+rGC654fYn2RAQKKl2p7gbYGibl3hfGBZ9ccLlJ3geQ6wuKY6vsFdMdW3t9teoQ3Gn0Z
haFLZC85YFMVl0u2B04k+4lJCS6qok8McxrwZn79+o/R6qa6+Wk9WsZ/XFzfE1V3PpSF+Uo7nzXH+GXc
/qKJ/I5eR5P4f6/JJ1Ac1IQrUIKbG2jAH2gJaKFrvOHQQK95U7+avvp3eNC/5sW35sW3oDXv6fXNzfHq
eCOON/yo++ufb4Get31+CdYafUKrkzTMn53cARwkoc6SwOv8TUCIEZPsEZu9F2S0axVJow/H43d4s64W
GSORnHgS7HyxYvder31FPv5LqFTWVGzC29vDiF6FSaOLjLSvxGFCt3GrI2rjvxpeu0HvyVucshy5/JFY
Qt/wanTDo+j2VtIoHAk4R4A3UFeXV1fzW8Mbfo5j6Aibyc5Hsc4o6Kz7pnh7AnsnsNWjdAQ7brgBYQNA
cN+InIBY8/Su0CnkEC+pROCaj8enU/yEo/NReIJfzPOGyijdSgKT0asr+PnY/Yd6SqAkHIUHwGMtr6kI
gBHdrMLVFaDwxKxkZAl98U0ixaO5PIg2skljeEQjVoR9uw3x32ll6OMgqHnStavSbDPNSXnq1DB4916T
yoxysgOTndGzFRIHDs2UDn7BPmSwD05WISmUu9+lOe9zthH3smq3uttgCtuiFPxNH4X6nwyqrkscryeP
0C4mWCX/0lnJgGUvJ4i+3Tfv2vzt8MausoG7Zgfx3VkafdX6V4vOZuZNOdrBYPLGk6dwBSqElfpCiKI3
2sUNpoeQC7YQQ0z4EXjxq0LoXu3yrcTfUqifAx4uaNRcf2ljei1eAYanxQ0/40bQFjPNZmhShc+LoWGg
/vGRpUCnXzALY4P943HDCiZZIADbtAUQ65DBcKoLdMADHhPkSU34dzBiiPaX8lP8jju/pqkpaY6qSq33
TNqa4ER6Ag2NuIdD/TtJ9xvb1v9MVf+j4BCj457LV6AGcUN3nHx1ff2HQB+rH2BNsPa/fPhP2swz3ucc
k5P/HwAA///mPuUeCj0AAA==
`,
},
"/js/underscore-min.map": {
local: "web/static/js/underscore-min.map",
size: 25382,
modtime: 0,
compressed: `
H4sIAAAJbogA/+R86XLrWtPWvewf8COBzHFyoKiSZFlRFEVRbGfYHOpFceQpniIPcUxRxeXAbXElrH6e
1uAM+wy8QFHfqTo78tIaevXcvXrpv/xYpdl8MJ38+O1o90d3MEp//PZjOXk2jZ1plv6b8WDyb4fzH7s/
5tNl1knnP377j5XX8uo/7f6YJGO+yabThem76A9kyCxLV4Ppct4u+pvGf5j/rSxL3m+y6WKa/0Bv83vx
PpNO0dMwf20e045M2lhOOnmjPC8EaDNsOe8LeKNBR0Z2ppNOAhimzUU2mPTMYz+ZR28TM3aWZgtZapIs
BqvUn+dLD4onvgnSd4H/hX/YZg8mz+bHE/9Mn4ayl7csmc1SaUjXs2m2kO7j6fNyJKDcubdNP7oWoLI0
WaROMho9JZ0X09A18BPYRboWaJOs50yXE3lcJaMldmK6y0qLfpoJjAaJa4wZjdJ880mnsxwvR8liKl0M
LKN3TrYcpxNAM1ikmVlbJhw8m7bBghuuYHAwL3A8ThadfkraFdhKk45guDvNXD4NzP+jdNJb9DFkVkIl
T8ssM+sYFJofWTpfjgBHlj4vO6mbZYCUvzDp6HmE3eUQpGMhcMvwwXbn20Gvv9AR0tolIZ7TBQcaZnse
GNKnxbJg2rH8Hg3mGDoYLYDLearAZqkuO0l7HJoacQAOgfxk8q5kSgYToHPSGS2fpePCYDkt6DXPKRR1
8bSavqTYzaI/fSZJ5gXeBdrREozwAjS9GRJL92SxyOa6t3ttGyek+ni2XIDT/Il5TTKOkvnCKd8YWZXN
9ZfdLhgwS4CiOcDU5mdtn46lLRnP0FPG9ZZJJm/DBHSdG3a2sftMeGiQaBto3wXylCLy5kkmyKZL4YWn
tJ8Yuc/yJsxiZDBHEWcVbseTTJo++8reiQriaPomo8wS2NgzJDqX0vlgI1DPkszws6qBZA7MJYMREJiB
4v00wcgE1BC0DZKRIo58AlXBQc+G5RXVCZiiawRrkUJEJgbHQKLhC0A2N8oFnabLBd+JEinl7m1gKI/2
50G3a0g5Ab8vJ4NX/QMhH8yb2D4e7el0lCagYYplTTdKqFET2byUesNMV7n8GeIIKUUdbQYC/zQXZtmk
X/BkNwPJB89rckAvxS4SUHS+wNbnixQYSIEPh1rlyVCKbDTq5kgHEvHCImPPpvOcEqIhLUhPLsAi06SY
4QJqs47RJOD452dDhDkEeQTaviWDBZm2NRinisK0i1GLvtH/C3DsdCbLycBF0S23N9g7Jd3g85lGYAKy
ZenYSDJbOuZlVi6yyAwb8M1zKnsDwQbjsdEr1A2yksHYGDgyjHCNKcUG6J8Z92YYaDrH7rqEAgMhGV0a
wSknnyWDjGJhtA44TrXyvNAdNEAcbkxFSlLAFv+glpY/AyiT6RioK+yeQVui6rczmk6otWY5P3XSGQmc
CkcmzQVN01P+0DH8M79OoEAT5QWjCQ3jLzvKGdo6AxCDufu6BGOYp/FM7UwBjGkcpSIdoMVz2qKlV4M/
4TpGP4qQ8vE6uSa/zdPGaJpQxq6X4yfaQ/M44mriXxidCCmaTJ3ppDuibALcRJckpgzGf6jdhIRPsYM6
Cdwj0wlO5p1klobA1r8y//978/9/MP///sP886/N//8Z4lntRiPvoiUrpgD/i1UVGZ1CQS8ME92mPeMx
mB/mwcVDls5GiTFz+Yt5jrhFqroK74uJK+tDrOE+YDkqF/+ZEtEdrPEeMxl1b2BspouFmRssJdaLmwdT
zKYj/ppMQ4Waa0jn33+Xf2SJ32Uf//O//Xf8+z+KTk4/ySrr4HGt0pyvaMx3ZX06HDJo2u3O1Z4aY/NE
A5aK5yjTCzcnC7E0uXMjGO8nA6pHoTJw84+8bTxY4y85Q8aNn8VVNe7KDGv/9uPfmf8cK3B2763Q2fUs
y7fk38jZDSzvxtl1LevVbsifwDP/egc22hJnN7RkRNuy7tFi/o3MuAZapKv16Ow2Lat5aVr8USOQprF9
g76Rmd0551Rj+xZtsZmxbGuhrWnmLNswthmZWZ2TrbHNeDe1Am17tR8A2+NubDlHedsdoLuXdSv9zJ/2
o+y0Zo9s+eUD5LFtcOB0ZRqDjsSy0om0WO2xdHJWdmabBa2e7coaC4OfwOBnbsvg+7rpWR+gv89hLuaL
zApT27J+ugYhTrI7Ns8PQNG+bQG6urw4cCwzqdV2tEmeMxnv1uxXW37GGUEVQrk/LwraSItr+Q/yr+Uu
0bdtZgl+7vrmJag7AIxNICDEv01pd45IeyxH2D3ZvVnf7HcPU01taTHQA+8FBE7NlumDcoxwAGddYEh0
Ie8CH0gCuE1XQD+x0fJhIKCPXJ1Zmq++GJ73cSfOV5OAYSMgJQIkM/BrdPPNVGVP9+DLCcn0Vx+nHda/
mTb6or9veRv23320nKvKyCYYlqzcNC+jPXsCgrhTMMg9iIb3UaMkGjeVCKO0AODcPgFh3FcZ5qztDM3u
XMTbur+TKdNLaUr9j5Md1Y84dkmxfUBnne/NAeP9xJ4dbXxnxyezseYsX3kf6IsOuPChQyaUfmt0CAb4
074rue5ednED4U6AFGEBAzz58P4n4H3UUS62Lfz8QjYlEx+QIfeFY5wZONJwp4HkEZM9g0XrlHBSw/x7
iQbTwxdWJfqHnOjdVl1ofngb26DYNW8cIZu0g6OjPrfcIx8LmZ0Rn9/tYikFsMbdn8pUBGpr+RNna3kK
9TEli5iVX7L0Rv54ys8y1m9NCMcZ8BKeE/U7FdSffEb9wWfUG1U2zJE+4yRkP8okkB/0C/Go1+fS98Lq
OyWbCwWMvDyW9BAgas42ojzZ8D5Vag1/Yg+CsC/oMfoVmGvv0cgcQi4fnqUthlnoyL+3aOjZwN/I4eYS
BQYQB6lMCuhNhxd0iEdYrxlU0X2KtgSDHkEp10iq6N8zYLtVKtDO7qljzJk9qlOzo1tzUie6IN7xjL9e
+Q4YHDlVChCU8MQudYghgg8QQqWC+wXrm8nMVmpCZzcF9hsP/wewr5g23E7L4cuk7TZ3Iywtr9ZkTot9
zcwh+rZF07RF8RlF4UNMJk7J0wVhzIB7EVB3BoZKP5M0s/+QpEt0iGi6m4pVXe4Lmmak6diB1CxIpbe6
UbhWZ81f76QgaLb4nmZHzt+imU+afSUxyR/SrOY8Yu/dbYqFxmRR3939gkxAbFSS6c0u6dT/mk6mW5TT
ycjfgopdaOZc/V+hzH6dpoS/DivStCZl3ul4jqoezFja4kvT98aCiD6e1Kuq7M2ujBk5B6o6sVRwxHnR
sVmSKOrR2IPo1P3tKgnlvWHYA/rJzSF6N4TSLTNVEAykIWjVCEjPxUb68DzcgVtu6/yLbdW4raUwgiPb
Mjrb/HNzDsCnNhSUofI9sPln9koLHazsX+21ZoMNvtimFVE9bDjNVABzj5xXG6QbEoCXyq72vtjViObr
gO4xMRKR5wO1ZmM2TtwPOxKJGwkgwbquO5q6VLvs+urCDFLt1j+vvfls+WQhCsu780ueAW9DkuEgRpCD
xs0/VwcbiT5iv1+ZPPdchtWtX4kiCHlK/bX5Wvg8QZXu3z2C/x+BWydVyYjOiZB5BbeTL3C7/peDW1cC
07+A24PPuF26cO5X5Ns3t3TYMuJ2LhrMySAsFPsFdNoUQj+zra+RYmaID1TlqsxTmFZ10VNrR1sPsWK8
LhbzZRkjxhNnQ5iOK3K8Ybd9wLSiMwqKRhk6h1MiNkQGgLx3TOd3j7NpGLIErQ9sCr0LFUDf1T/aUkoi
rOgVj7F2U/UrfoQDwNukKQ6vQaIXMd/BQf2cC/YapTWn9g3O6pXAdNj4YvHJVnTzJmou2LOHDSq2yox7
nLHnVmacNL7XaBpEHWLGoTPhjFNkTB4x49CtzHiwNSONYbD6dkbfxIyc8bVRUYCcser5g7cdH3iP9mUP
9ZsNpWUf6rUNqvZswZS7Bm56jP0n4L5D/Lih75yIbE8ccGL4DT9GRYD2mR9F6utFxJ3HXdLpU2T3ZeC0
5zAKi5Ew4njnVtsGsMt3Vm6WI8t/in8R33jiDP0VMzlUR+eehkZD9KpTcG5rD5dIRaqog7kFQ/KHbvfE
5cICp0FK6xgzpkJLP6OsbGhj1Y94r5B58afJLCsUZJYF6urc/f9HZVXPt0MgujFw/h+SeWIz5H+AtL45
UEpPVNb88QBqO4u69WeoXHiL+43SKqyEmJJTzPNt6Zu0XPSZ0Aw3JPbfoI9o2vo+uWOHxmxP8Og89QDG
/VGjDMWdn6XtHNifA7e1w11FR9RHZw0aQaH2HtbqHlN3n+BPdEasngNdzbNc14Purv4QK07AgBh3RWSd
yQxhq8aVdhqluTqhSJy6ymWFRpWcsnWFtRI0P9Ba/A07SkznnhK3eeRWES7O8YmtHgppGYOMVnAHjAK6
dyaQn2CG0CKJar/m9MFj7tgr99VvfBR1F4FJ3TDJL1l+YyvL0yqGfaXOV5b3owCQGSTZWuTnbrzK8ys8
mTZjmo/iYXyukTPXvFE1+yy+TcWP8LmzhqQuW8jPsCW8kNTUs6Yi/DxxjfAWWUqfiT1MEsDNEvcjT9/m
fqXyzyW5zKl0i8jMLh0tTVevGFS80bdZI9O/Fp7wrwHJIagY64Y8UQFlunj9iUgO/UGJTwMrlEDuytr8
Ktf2J5UU2VpmfsHGQvLaFg0kJWF02BukSKPMeEin9lXUsjuxZzJJ+FBjWuvYg9Yh+uk+fRyF/LN6Race
UNIHHeIpPd8ZUwD8FRjdpOGiyB11tbwTumQCg0G4ppDPuPjlrxdfO1sLRBk0QT/PQ+9wkqt/zg4M6Mn2
cqKjT+o6uneBHFLJ3NH5FwzgtKFKv0utImnjIaxu4AyOtjuOaS+YK7R3lCaF6WQOP5y5UNdzsOs1Mx8i
IEO7nCpsqOCJ7pWXmb2HF01qyRBIiMm80Zy93WK9mFpdVnX3eJABu9UaIVfgvl6UpmrklSIRIBCtq5rs
QAfCfCXYdh43AEkj53vrlaoa/dJdf5WjSINjPfEoFXUk2VrtNL9AMMvwFRD27TK2wspTnPANvwutoo++
SvNz9IlAMzZBQ13fLS9KF38GkdyOmjPnBT//MDS2/DPo7nvkybpm/Qtrc8H44DsV8coo5bxOb5QL53md
8qXw9Gt5smWFw4tcYCXD6ByXvNPs2xtSfP8COvKAvw6J3SP+Oq7gGgetEV1JL09rFUdXdDsP7TKMuiLX
JgCy06MJViUqKnwIV8pbNar8MyXbYo2hKJbo3Fb7eVrhzJ+fYaHiXkM9fjVb96N1PrZzmTPTpoB4XC8h
hsT6CEUnDQXhrIKOp08g0DP5S+iwSrG3mkQpNcuHHVSBL+GWQQyqPfM+WtQVzB2CuUca9nCkGfWxa3fg
l1ugO761hxPnWzQ+ftpFjiLDxrN87Re/pBLVnZrU4UU1qB5QDQ0vSrkXXaDS4eUzOIWy0ue4mk9Fx/uM
G2P+MOzxLHjmq55qIogSAC4hHm/4EVJKYlle8kRFUMONV4OaJflz1fgyqDHDHIkHMKrPPNUb5g6hgZ2n
E54BU2N2kJ3Jz2N9MTiPJ6Ju3Jr9jrPHVo3HhvtbcB6hz8Re8ueKMo4RVcRcHiHeVydJGKAw15EKyKHM
5LdWOC1wxxVqjSqmMc9b0GWvvoHn7Q8dxfq7v3U2/Inc+z6yRYxZo7VX5W3NMRlPalKf6FEzufOIkx/7
pcdMQxEda67OK00ykY9D5xaJlcLVVAjOePAl3onTnTAhLjZcMwr3RPsDjLW4ki48zp8bmNEXmpBvvTtv
UQTEjfpYZMexXiQOcIIJk50VTpq6FcH9U5z0St5Dak5OpUU8BoDXG9JIjQFmc8KzbPXIsnpJd2fhjHkY
NBE97yDf4ENy28gHVP3O7dCYOsp7xerntuJT8426mY06KTRLNEQr1lCcIQF2p6QvYYot9+rErs7FSBQn
LtSCM+eLnXg08xHyQeVBzCVzefeWc4vX/UtOTSCwk9jopnsNFEIx6htH+W1wicIgakMmv+2Sm6ycmbyJ
XZJ5VgeZSZtkzysO7AyF6v8bNF+CohEPmZXmsJGWf6IuCAK0JhyueA7ZXKGewSqSCRqEAXkA8BJUaM0u
qzPMUPLVHlxo4CVpctSKnSD4Fx9TqJo1qkQ4lLDN1ZqFRWMrvwEpT5hhzm2eTN3BlgCOOhgfhB/WGGQx
MjPhAaJWzWxbCmbUBS7R5xLsnVTz78035pMnIr1hrSihuSzTazPQt/uH5KUzrV4f07D+qE5wC1LPnM/V
Dc7Dr2pTDmxEwzELoZSiGsXXWIInvp6JsrHtACkRPYmbX5aKUP2l+5JZYZhv4Z6JlXFHdlndIfM7gVZI
VPiSh7nB6NtKljO40A16OczCMGcVnlGgkZp0N3piXnZBMC79xvZWkwmLhtzaAH5dzjuHlROTOaWejnR4
zfC5JBiJmjLUd6QuEMTJ3I82u5S6EKZMevW8QudJBZS1tHd7UshnwR4i90Kdmksb48HHAiQJbOxSOsVO
0RxHK+piM/VF34EhSaX9AaraSo+cj64nj76bPYwD9sM1hOyeXtS2ihCYXt3P64aQRPgCokNEk4qavMu1
xWUZzy62EBtQx5aI5YHEJ8S+MYggtMSmWKbAuhgTebeH4ng6rFtL5J8bZho5QiVXWE/tJGtw6KMF+tpE
Jv06z6DIKfDDOAMObqzmdbldCWJFUehuw7sNNdv+ZXmmU/EaQ/XMDy5UdsFrKBXbIfGYSZJZ+7bWwRi+
vqMbCWIKSoJuLlMX9T7UZvO1XiFrgudjBNSM0HViN9+YM6tDAcbry0pBVOtYSSn8cILnazZ1WLzh6ixi
gp0LRauHF44ENZGuFBG1PHU1hA8e9mgIX+zS4Y9KlKiCnjLfZHwWQ/Y7TLEHhdyBixDcQPGQHTVVKH7C
gN4pEvkhw4jPJ4d9Dw1qavXc8IkAFjUsZ6xh2Z061n1N9MOdSCZyQd8eSJ4SkWLzrzHTKGAl70uA3Afl
AtvYqsqc0j+hMY7q29M/GoAbx0wbnlwi1p9Tgy0kYSgIA7yXBacisel0reoQYa0he+6TAeg6Khw7pCDP
+L4HhJU0vhpCreVE2RHS8yisnIqWjR+GsCqu2XmhRTe++uEC4z7Q8Hhw+QUyRW9QJZtFvatc2zTqA5/e
sDjGC3Iz3Z22mcf41j/HzkeDQoctoIr/yqBQ9wQjViCdIBPinbl5owftAK9EPDd3U2aprfuhX0pvrCst
mIs8tMtBzpoOxFGV9CxNC3vilUcnth4qv1bwNbqs4IunWmf2K1Y5skm+Zl6WVdgTeDYMIZKSm98vBIBw
981BpZEASLfn24JVriP1nrIAvN++TZ/ZP6Ok56fWpJ1TeRWiosOlQ7RdR7qsbPAcq4c74Avmq+H06esF
vCpN4jO/HGPJGPZTD6aYR9bK7oVfxe0rRDs5c6REAtm6eqCn8pqSPc6zjgFCsVwLGcpeVqSjnM7IwKo+
94uOUHR1C9IZi8Pn1GX+oLUi+x8GpfYfkdXHoKqWOJw3vlcpSKsDgfsIyO9Fr2isMbuscBKAO8ZJ4co+
gwN8dcL1zyrrZ1h4yAk2Gujgfbgh2sju/nuREisV+WfwQhMZuapDd4KykHxRbFP++KWv5C8AtGq7EL6f
050y8hUpuWPaEhofZ1ZN1APybMajxTMouKMpJyfAwX+k2hX+m11RjKQA3qk5l+XkM9bOb6m9Qv3CZ9WY
dcVB09INGBbKSCu0GRKFWbGYWeDmQkY/boHl59EO7qw4ONnTUOgR9fIx0qihgPYIaXmw1sBSG/cXnLse
tdwREtA4g3sCA+UZgEc9y7mXeDGBZ/pkfcQoMwnrv4mASGRwjB3f8wQjFnZMEDw4KMRqX8KGwluIZBJ3
JVlcsQN5PcFVySH9oMohnQqHtMAgzFCELHRuDtD7/hwpsYkzL20sMOhnVEbnFyXhrTgUib9DTHVzjrlT
KgjaKCYnt6DGPqJz1IhNHO2ActSmbPSi9jexZ6L6rMI+3NSX1L15w8jHoypXkflh1tsI+TotszVjL8yU
14GlUvJ5M6LDnZ6N2oW9PwC9ZitUJct7P5nkzsl3elU6azOS7zXYLSuTzq/o00G5x0yGNTPxevwTtRpa
c8lg8YZRy255X0VcfG6EKb6K0k1EM+Wa5ormoyA/sz8FCskdNbdi9HEYpQVhuT+hZ2BMcMDhdi55qtZk
3ChH+zLv5uKTQTFxfhOKkD3zAVSems7fg6oMd1CcsnbUDAbG+83TQ+HHsGAdaORc4iSWSCPIlZtztQ6+
NEr3ltSqNq3oUpH0EpaYrlcmVxOLukKW+8pCoSx0FR76xUI/meeM9FrJ5/XctX1HVjEeUeNUWCV80MLq
MexRNAl3S/8vHgUVwCSQMXOP2KNXiQPyUzO/PHpTJ3OmBY9x4fBSWCq+v8Ccn2RJgtnssEifD9y80BQK
hlOrD3BApxfFHsYskXVuMfYd8c2M3tvQhR/TrxZraOpDpvVHRenMRf3rKzxmc89aB1O9seM8s9KzuXYr
SZu7XydtqtkOK1DHrLjZ45U1LCzrOtBK5wrbDUVm/eHfh3oJEsSjsAJ169dQU8WFa6a/Pt092tqDUcR9
Ss7bJfYwI8O8Vrh7JHvwSsw36vtMdjNN9tVeWn/5+lS/rrkk3jsrIUTAUOyhdHgHW0VWczhMjwtCvwxL
/3d2tcvKf2RSrj7w7Oqi5FnnLj9kZrQ6KRxxpF0YvfXDkmklTon4ymP6Mbb8bsazsPcKBhdXqoq/l7k8
3nFrlQTeEhofBzrOxd7lR5RWrot8k10+qJ9hVNO4ygwxXAQ7ssIO+CPGzm/OYQ/TAV+dUh+KMnJO7DXe
+W8EJnfmfZzZ4bzwqhp7HIelqtlg5FYNxR72O7CX0BJPuOjnABLWnB9oOkkm3nfoSUCD5IQmbXj6R6PD
MPGrS4aylyUr1KiVgBR4LH4Tu2nlJBaNzJNFPQApD9ZFI+8X5S4ek+Ix7pkW1wmRVYxYwvyGurP25pvM
yKjeV5rLwGfUlEsJnub7v6uv/EP50WBSdSvk3bl5dfLdy9Tbu+CNAB862Vsw5J5tFaieVmh58B0t/QP7
I2UkL+KWJ2d6EWQPGq1bIo28n+sPLQrhmF8iUbjbBFVmslr9ICAnNKuEK8vONXzWc4KV1p2LkfFqWxXk
ZNvgI8f6UpWtG9wJS/f6BBI9+zMS7dR+Sdc/I8QYw+TTliSvKjPvQKtRnB9Whcg2JbUbSNr5Gyn29Ab0
thT3rit191dlTKsZ/a29Oq3PhUFawnoHPdzKFaJQD7qwvrDFn5Bb0hw6uC7PaqiLgh3p6M5sZOfhfTzu
AZIrXJLXbHJIscYpsVei1Tv0VIUZ00X77dd4NKGlh6HmblhphctXPs+/8Ih0Rk0LrcK83PSF1RwaQ4eI
2gPM6UjxYR0B4hqpT++tvNFvtiF3BCTj00BYt2GX92qXTMom85uAL9jX4xFzw5r9OdTDWOYisZvOdo9j
PQ3Jr+wc8XrBKSoIrslRJqh1r4pH74K+sGDx3Cv0UgDdtlH+Yr8Iafug8AXz64TGaOFgQFApUoPxW6j0
ipGYdk8rSXu2aAJAMrbF5EfgzEDdGneiSU8cN1xBj5/qD4ab+T79jYyqM944of+5hA2LVtATTxIXeJpX
KF5I6f5hvWCH6JSHsGu+Oa7LzIt6jm0Rmz3adp4OaR1Mn0HxjhwzS/GaUcYuBrXxeYM7yU4P5AAdG8UP
uE+Zw0KGXHEOgIq2JVMP8jrs1XW1y/hTFzFCigSvhf1FJ9RkOF9yfp7yoKPGRtYP/NRTC49n+BLFs94B
X7R4fhdFg/qahsUjKV4YlMtlBpctlgY031kBjkNC90ReeTx8jN6ROnR43ag5hwfiUTpdHgpzECCIzhoq
qfemEwQJ+5jbM2RyRzYt2gc3801GMRy4sFDBHi280kK6PxXKPBTUW/1Q9p6BVjQ5nTh+xCKSO8DuVbZl
ROfA4ZVuJDeKXhkaeXRO4he/ukfmHUNW/7k8pw3Hvm4zQpQTGuQyqSKWwrnhhyYC+tWXUHBayXt4XTqz
LGHxqp/m2AdneoXya1tBVxnruDJyg+o7ShQ9LU1fl7f7sK0Pqlw2l0dy1/QDwmqjljFlF4XNmwOd3aL6
0mxo7ZZmaupUgkQ2fRcpYsYcvGFx+c5vqVE/uy6LMo+wvYxOA/QAL5rmZaDGvN9LbeXedbm9dp2uKCbA
eNY3nFEOVvo9iZe8uNWYx5W9ZevvK0ZwpnE/bFinhqNKnrAb3jNmoXUKxdqDJLeQVFraNWnzV3ll7T4L
Cpj5u9e9tfkPYvp2viYiA2fPHeJUj4H3AFqcNvsc+9FExy0UYrEPSWcxZ89Elpk6HNZ1ppygnoHZ2HxN
drCVx8mgtbgeuNtGd2CbdnICeSFGw5KqnMI9oBJjocikUhz5aqPvDXCCW8jBKr/g+BKVeN4LFc+y8A68
CWmT7dBdCaklh3Iu6J/kU4yj0pXpX5euTA77K/3bEcxjnGf7DFmyfAZWkSmjXSijhaozkGnRcbFS+PUb
9lnnhJ5HZXA4ud4t8nRSkGLdsioh57SoRP3suoJ6S5okQRws7C0RohdVlSNFWgdF0hS9FLnYPOC7y/v6
xmXOa+LfItLr3nKf4IQd0U2g04KQqSG+o9/SY7WKTLQqpBI75bXyT85UCFqrErT8oo6g0n/Iv0YTMQRJ
LLd1QBZ9r6zz5lSnEI5gKP9c5qwYwAfdfFeVr6ocOqVS9FkQFWsChEmckJnPeKHloMysrOQQX3yrKF8U
FzjMol8o13jfpit18Jeivk+JHcYCGnLt0NSzdCPkaYavAeA+T9V28V0IiCWvPQOPa+g/QUkIRanBoV+o
WmMQNRUnnPWQu+fVlBYtDSvdKzcVjdN6DWQdRCzG9XY/VL7csy8dtO8/s1Gg46WCDqbNL5lE57ctgh5I
JSkZz9JqvyZyq33uoBcipDkh25xVrpYxwhC0BZCmy/z+gKTyWZeNTOc1n8WP462/kFnpQ57lHbHOkKf/
rWIYTguNVt/obV54beE7Y/ANHVxxFkeaLwfpCTJqofXrR7wU6ZD2sZEOfYy+fGx++di23AsWna9uCAzp
DM73VjYO9Hp2btk9lP8IPIdAaru8HKUq74QMfBxCqHnbBgFSfFBNNQdnzJkyg0Dek+1sHOZ3KDsTVU4k
rtxX1lbxlKT7pCJjiOvd5zIcHAMiHsPzo0eBhh5u8fmLe1KIB975h8liLf62UojRfYgg0d3Dp7zclxh8
ApbsiOk0stsn8saQgHtW2yEffWQrXk8rHzd5p0dbq9zt6gBUOuM9Oz9PzQX0gFpmn7W6NTjpE71LyjKQ
6ve/mmU/s7eO+NLBjGHKG5gJ14b69iymfYtLdelUPBU6YpgKsGgumzVHvOLKwyxBdtB3VjH1ZyzW2iwA
PwfPzw5N1Fieb2UWPIc8ZGCmTRwY/47fVVnx9rIQ+O4N7JIfpAZ589Yj/J+4fGxa3i2/RdbePTbR7B2z
zUmlED0/4pEtVj8bFa3tA5J5fFtFi5snBtqQuj2W0j+CPEle1ias4PBHBm0jKSHx1Xhnq62NBkMmOPN4
I9vH1ybaODtyHhgSiPcTa8EHPhkQS5r1kFcvH1CU7FReDR199RN6xq282rMH9YqABVQ9Xt8+uaYMGbre
HvJLWdL/aZ83VwlAzBonMi3zixGIzBtr3HdbNpBMJGL5aZ3j6yHtfYZHRyi2CjlL9A68xitOTW3Ma95Z
fQIhid/5/Ud++SasiSoyQf7rNVyJtValdERC3lSxDJDhxT5afbfSgWWEnd2lTWoZorX26jmnWc0d0smQ
x9/YXYmURVnpa+9KMYoSgjY/btGE1//KgEEuOrh7etN799BAcbM7rRu215bUch+EZ5lv6fFeJqOZW2ir
s1gXaOcHaFDIuK3nHDHlNpBh7g1SF9Bo7pA2ChrsaiBqxIPz7t/uFlnOZiX4Y2VL7aZ6HnoG1Icnt2L8
avYpv815WwUnwOfnIhOCwmI3N3rOJlI8Zi0FGliqJmfz7qL+7tItJZOf3ZYewVGsXjUsA+/t77Eb6oDl
w3tSwcNXvLgLY4+a6TYzeaOIOIQlqnp1NDzBC259N/vNfF7h48MYgnQkyPbX6sm5g2YJ27nCVkZYqMvS
skQEEe3JFT0z6X8GI6ilEmsYu0jP1jW+OmdWC8GTMQ1DtLq8CXBGD0iNO9iBpyz9ygdGc3TgzCC/68Pv
rIRHOPy+41FgpJ/qU8IeVk+KWYssNXSxlJBrZRt3Hg6FR7xbK99ymOejK1FkTCYnmtpFtKmRZZ9XoVgC
pTfx73ta2fEHW0bsaYWZnW85ZolTw3pnxkM/+NLFdmANHbhQrTMQ4tTWENk88/yiqzg3aOmIiOp9aegW
Vw81tnH1KlgNavaHwLqMpPPAWver3x77y/vFmQkz3tsA7DBppVvVsyh+X9Zo1FT8QI2tOe27vRtuT8ub
azKmbbVhdK2HMwD+rl+bxfmcWCT4SJIXfQEyNUAcCX29h1Nb4frxX/9XAAAA//+R9eoXJmMAAA==
`,
},
"/js/underscore.d.ts": {
local: "web/static/js/underscore.d.ts",
size: 74862,
modtime: 0,
compressed: `
H4sIAAAJbogA/+R9a5PbRpLgZ/evQOjCI7aP3W3vh7sLSZZWlqxZzdqSTmqvY87rMNFksQkLBDgAqG7a
6/9++aoXUHgQZEvemIkJuUlWZWZlZWVlZWVmXVxEl7uNihZqmWRJleRZGS3zIvohW6iinOeFir46/1/n
X55AwzdF/quaVw+iVVVtHlxcbE2bX8vzvLi+wEbPHUBXuwfRN3mRlNHf4+x9/iF6hD1L6HqdVKvt1fk8
X19cYYMd/X7xeBr9LS9X0TdxurhJsmD7X6/4x4vHNXRMVwd0aavSHQ55cXKyUPM0hhGu88U2VdEv0e8n
n1188cXJZ19Edmznv5bRL+fVqsirChrlG0J2Do2+uDj5LMkqVSzjuYoupcU7VVVJdl0CsJPPGBzAe7mM
dvn2/iJKk/cqqvJokZTxFcCrVipKVbyALmdqca2ieZym02gTlyX8BqyLYULitFTnCAdRfibNnzyIrvIc
PmQPB2NSt2q+xQFE8H/8oiriJNW4BW0NnW7i4vvsj5MWVlVqvUnjSkWl8GGKf5mvDXdAxggZDC/Oori4
3q5VViE8IPm+bj45vY+f8w+qKJIFiWm8TasQ++sIfnd48py7RR/idKsiYOr9i0efT376z/I/3/38P5+c
fv744vq+HbDCZgAKBvxWXX97u/H4G4T1dSswonCTp/vBO2snrpzHGxcUTYXlw3dJWb2ED3GVF48up9Hl
W1UC+MfEjwkheRDB9wnM2u2DKNuur1QxBWEpYWFf/vTz6QPdpQH69RUu/3bgKlU4hwT+vYK1X1YFTIUG
Hme7DuDfq3XeDnpTqA+m7zSab4ti7Cie5WkKw4A18OgSoEckyRfw9XoNa8K2u1LVjVJZ9LQo4h0K6SL6
9f9uVbGLcuJDWec6glO3lcoWZR0JDOEnj9Sfgb6HtJSz62qlv23Q+jwhGHGxGwacGS7A/zgBYBaW1ejv
qrhK5o6yc5T969dvoh+LeLNBdoImcn9bbrM5K/ZqFcOSjkG/wNpldiCcuCSdskyKsoLVXcRrBdhBo2XA
TWDth/y9WkSoSrfXK9ZuGiYu6OhfqQ/KTvSCYGi1gDrAIYQxWnq0NgB2aAmnWYPPIAi2I3x+6LW6bP6M
TIm+cP938ln0hcPzMqJv3P9FgNwwk4VYlaS0ophkMsqXkawO0Ie7RKWowCMVz1fAlqjaFhkOEfiUyBKw
jIGNRdmvkxJxXOWgdLEHsnuewxzfVsIVWBNLUO6kSVDBqsV59C3j+ZDPY9b9Sxcg7TgwLzewa+LkKEVz
KayHbVUvbFluvMxOz3GnocHhJhX9Lf4Qv5sXycYhRHDcLy00wAJCdUUoeBZIV0ylE0B9DtiuiYEyvgyI
/qDQKqFxaMbgOJMKFgWQULriQzT5s0CiVp8It49hx8s6/8kaoomSftEMAc3c3noG7iOe+1o8YWJnGu5s
KoZDnGphRZgoiqgFSG39ci5aZIrbhnTUX7uq8UOeLKiR4H2idauB8NCK47+WCiybc8TmUCwk+lzaFDks
+yrBz0vmGbfbl1MCaIdGxoxBHJVf3AHH6ynIOt+a+1UH5zxIrfxDQkQQP/rcNXF/TD6A8b/YzhUu9Uzd
wIIG/YpiQmsYTf1oDbuG0WpizWS86rTKj9HezEoYxZo1kZYdUgeaZlYtztIHyBFsJat8IcsddYvWJNEW
dBxgKiswi1uVEiIYopfCSqmuXb6PN7zVaV1iFgzxJbheoE9Tuze1C66CVgUzQxyzAQsm+tdC0a6CmwdO
DLCIp6wgq0gvKvjJNbZGCLTuGpIm+e2nn5syDYib6siwdT9N1MPZodroIOZKr17ujl6yB/EZiZmzBfMp
p7uDjI/Gl6dpmUfvs/wmQ3M1yWja0Lhf5ukCDt6FQjUHFlaSltGCmhnLQXQd2NRgq0UlKDs4VtOXJBZ4
hEG9gxJMTok4BYscz8I5qzOCjYObEkaSznI7B61aopoDDbZh2ywqV/k2XYidxNIGQgZKVjOjYRaKsQfD
2Bau8YZ410DYFP/iMz9RTDZetmCTLpoADNB4p5pSBmwoXSYg+ukOBl2opSpUNlfaOgMsCZjkyKKGmnyr
eMvYU1Nyt9HKEkcbvRT+y3TSNBxn0TN1LSue0bWtMe/gVhfttgMwtsMhPbHn33ZRb648psi4S37tUAGf
nDxagn8K6nBxFcn1qjqDVZXPE7ZDwEgu5fzEdAdOK8456Kvz/+N04ZWMvd4i4Kl/folmOPhihis5yyvU
TWDXLLcpyqQDE3UWmD6iHfDHGAGncXa9ja8VH+LS+LddJF6s2tn6n3pdEuP/FPLlST+R5SyB4k9B4nd5
/r40lrtv1JPTGoiayt6EZr/1/KD3gTxEtCWVZPVvKzp+wkKpPEMfF5qRIwZGPuEyzzMRdth8Fuwkhp1y
U5EvW3sk9C62yFWZ3a/weIErTvVuTe9UXMxXii87Yndk4ikIrgDu9YnMeGauw4QleYEaGEmzgA5Z4ayg
i42aoZceOKkWF9kWTjrwvTYr9BpBPo871Mq1QNgGa0o9ImriHG0Bjse+UBVthx93zB7WOx/1vsuYLmPk
bI/+X2MwlnZNd67oVv9dkqIzmM/x027v3Qtua/embWX2p9bFKZ0+1eJE5GoR9DKypGODO5C10HGLkYUw
34289dJQqvRuVtp+mD/C6I+93hBbjGZempIPi89ncFY7Y7CbGLYFgkpeMMd10lhV35ErLo/WcWUXAyzm
a4Q/sx29ZeG4Yi59zwxAgh10/p7WFywzb4mhHVpbZs5qMbi9Zv6A+cD8j22Cq6pOHc7szUoVdNT6wdyM
/f5Hm4DZ/g+iH3omTU8TWRbaJrHmDfOdaCVOooUDE3fIzIhd4d2M4Q/3S8sq5LJjY7F6InMfsQ+Yvjfe
1KUwZD1zVeuUtBghDUXK7FjFZZAYvdP/eNCMOfP11pkU45RhViL5uF14Y+L7Sgp32OIll79niZ16rg9+
+WaTlwm7bViXnFukZpF6E3OzSuYrvS0y/GWcpM2Zfqto3urc7t7ZpNOn2dkKQt6xs3GDj6TbGVkI80fQ
7UbsCtTnS3fZWyk02kNCeJwDs5WOppmE8PV1h1x1wElmR4bSBg6zwPGGMF1aaSMljv8FkvYTLgCC2wIC
+QQC5nDSkC2eTH+9AgD4orhJ4HCnA5T4XhDZ1C99T/YVPye2qnYdhwg7kLeK35P95W8QEcC8TzX+Juq7
HX1jBWa70Svw3SovqrN5Usy3SUUBPoihrHK8hGI/gvZr8I3ikhW8sotBDtfthx5ZymW+Vv8sKxlmZORK
Ri59TEFGfE3UA/aRYy5khwho+YmGbzF/rNHXF7JZwXSVxavEXcvn0Q8lre6Fun295DA9upMiF2DiXPpL
xF5jiT3Ds0rprwFYrMgL6D4j5DMHuwuAKbs0NHpHnw6DWQbXBO5661pWg5yDynaRcILYWidZQwkD7Zjt
EcCTbJ5uF/Ul3HBaHwx5LNXPQF5KuRAltZzFa75V5c+v4KM5yDYO7efRU1Rtt7A1OGEjWsPlJIYU4WhC
SUA4buJigXcSmd4XBLMNxmtuBfZscb/0XNIMmKhbwfbkwpvZEcx0oKV/92IGeGl6AXjkAEkzmbL9Z3iG
Zof/dLFIeDNwvgR4vPPmbSTa8G2k9NHlgOOg7W3iiuHb8/Nz564blA2F/sJ/3Rt/3NU+qCzBMTlXeDd4
KMQlqYqVDjxZ5yV6ICgUeFuqs3lc0jximMcDnvx5RW4bfRxCDCbChG2Q4JSm4nzZpFvQG03PJh2fZVIN
PH2Q3hmu1c71OzOlpk/tbL+HV6Z+wAt5Z4bQiDNLwxw0sW53PbWnMpctR/51fJust2s/yCzgREbEwfY1
O0p48H29meUTR/PcTjz6OWgbQ4x1+PYe1GKgWjN8oxnY5usjmNxrlVHQJjnfMfy3QDAo06DI2A/hbaZF
nNWUwZ7cqVmZz/I1fKPKFmsSSURfTxP0MWOuGGyrWMt0jbSmQPR6r1W8CU6y/cSx3r5FHOvNauNLsnHi
GKT2TySOPdw5RBxd0EcURwHbLY5J9hHEMYajZoHOunm+oZOxXDcQ0ylapJyDPsYdLAfLpMBJYkc73v5T
EEixzTI/jJenll3TNv7MxH+v4x0cVsscZQRhsQpn00LO5u7mhAQi2om6Po84/6UZYPsOGpV9l/EIyB50
6+fbVutl/GQ/rXPXn2L88ZsdxV4gbaMmm3sOdocyymNwxx1AvyfXWmDdZL7bpORbiebmFMDhk6XCKO5r
EKoNm+BWCsNC2JRAhF/TWrEWPgkHp0s14wMRfKVGZ6TSnAMMLI5IJ+yee6khqH9liN2SSo2GToa+HNS3
SaRkCYBz6wDEHkmkM+8qCVEwMuQJReI4N0h041YLqtYnNdtVLZy7kSJf14SM2gyRsr2UoX8W/OnnQBqF
IA5N0BsnRJwnnXnisn4tPN9rDF0rpYvkvyZwYAHR1SKBN5GxO53WsUdmuYmcIokJ+fqMG3NCAU+e7J+S
E8XA8EUCk9IoRhhPBjFHP63Po+hv6GykHGPD2ml0BccZvg8D8nf5liKt8Q8KL8bgQrAjsuQfW2WPgAB7
GCvHSkNAFgTrnrLAfKjJwh4DGCoLLsG8E8pxk1SnKDH3chr16zarzB0xG4A4Y5KrihJAg6HO59G7ZJ2k
cUE7u0DU0+eoTidKoRYDPx2AmluyX4SllJEHVahVGZ7HI2bLLRMkPgK3izO4f2oNHOaOz312BAI/71YL
y3kk5Nwj3KF5eqG1Gg5+X1IHL7AmZY79vNoul6lj49mgnW3JS8HxIeGPL5ISZuXs73T9I91bY2+830UC
3tVR1qwy/hnHH/SpNowuSdXDbA1YP7ABl/F6g/GiuBkjxQI/it5wMJ8IDZAnFM2yme7rb+XWGRq9Nm5r
kwojXXCDMKdGN8o0zBEizg/l9shGhgA9rjzXGETtWvkzjTJ9JG41ownCMHC1k9cz9C3yYUVvsCBxHHzL
8UyS/U5CiidoaH461UlEhYpTubDAGw4M+CdNimmS6y26GvXB2vpXm6lwrJzNPmWSLAVL5gb16ynm47Eu
vyE/4/irXCfPD5S3t1Zb1rW/50Bv3MgEdDp3uwjuBh79rwKYamKR/NY5iw0vCR1WJBqPGFfd5PyxfBBh
Awxsv1nlpRP8g37zMq6ScrnDu51FMsd8L9y2WhovcsrvaPTx/etIAs0CrRCiCzlxkx8h8pWgH+tETDTy
rkR///Tlz2TkeRFSFisvCR58onSyp7CAzVwG89XPgQiuRbJA5hkfcwyboswnbg2EwpZ+ODD2yIi4KQPx
ha4Fgn+b/12E3Wx+oByeQ/UyI61LHhJWko6xwZ2yWlKOaubksIQAviJRH1QLxno6j0mU6aDSkQ6O2ito
m50Ib82+2xblDs0dMjWyaJ2TTODRIrMmFJ8OWzDaCfU2+15drmlAYCswZPen3u15DCqwUMo4KnTPvanQ
c0yxOrwZXUlQZBrjjGdVsfOlK/q23Kh5QnmeknomoaHBnYdMB7rWVLd0OWuBZwGjwaZjhUXYD3cBkGrj
kAv7/7knVt+pmMUeJHzthZxcKRjtojVHrJstnp3RXA2S1Ns1I096p8TOwX66oc7afVRDHd8AzVDvUmMF
/jxcprH1YWpB4xu9EkQIK803d3Py2W89HtYgdgLMXL4jAhFxvEtmN0mGl/7NGbnUnQSsFXstgqyMZwRm
FixTw/cNhriygh1QwyJ3qROTjFQQcXYtTHX9tOjr6KvWmQ8sAJkSocxkfi8CgoE8HrdATISvo/6SkYut
CWsBx+XDFm7sHQl5Kk38PYbu6Pt/mJE1WPlYjMTN3Z1yfA8cR7ZY4e/LaXTvHjneTGoe2T+v4ldkQRmo
HZbhHC+/5r5h/EwfImXqdEA8IXfc2Hy0pv5tC9ljw4s0riqVcQEYymlgYiZkwMM3KIBy2KFDxw6kbYOX
O1KSkINCyhUMLL+ZekyU3JYMth6Mm2FMiEGfLFNYK2nPmpJubitBRuVkCrpDUBmjkcakdwh4eJWYiCx7
btIrQhNpDBf+oilg2lkixNgyih1RDp2yhh66OJtbXVQTuz7Vg60kJq3kpd2IdSttsFvpdKpr5l6h01hM
zg5/37EQz8/PuY+p4+cxCK97t5Vsa9vMccPwjfVZkpkjW+XEtLDTmVwTWD0o4+vPKStuWG4nFMZjYvNQ
LPBqk6rNOZNQNphbymrEXZw/y7oEKj0iG9fGhvpGvA0DMkyjhsgyinbisRme9fHI99ua8dJvFEVZyrWc
k38mQ+W6cV4gHJtx5NP1Yhndm7KxjKpR0+BXndo+trnt9+CeuMaROpFW9osXzZwjWg6ysDRf8XBfi1+l
AM82tkT/rtSmbEyPHhP19VO6+KvaAn0PUHxG9C9Q1oQaRW1rWCRLqfTSvVi5dzdLndphi+0mpcP+2bJQ
qu5KJRza0fr111+TqaGsb0v9YxunSbUzWwpdLyV0WRsvPsRUl0bneokjp5RLey5uS2453AqWdGP8ju/z
2dbe4o3beos1BsHaxClLr/MCGLVGfIgDUd7EHDisRdfVLNFVLEEy9UpnUlo3WOGxfX8XtWuYVja0tRmC
iTWWCUYDPy3gFLsz4+/Z4BrZBNqJ2GYUXqkl6kcyIoqk1KWjmSFgEZQhH9Pgmn/tokveJu+82LxWxE9+
JEZIfjX37J587AANpGM/ku4O+Vb9+dEff0IMVd+r4pqU5bUiheyf6Zo7mL2Pk1aiV+Z5Afp9k3MYFaWK
6lUsHnxz+03RsqXCFQCaYhFXGJ+1Leaupp/nYIokGd0N6BgXyiumyyZxRsO5S4JPpLw3bhF58R7bsF2I
fYqEbuld8xyMnd+SzXm82YCqR+uc1NImlxIp0gmNJjC1eeMD5bcKqaXS2pG05ayRnxcI3V2t/y+heniO
Yq/vy9DD3YvJBNZh247b1REk6NHRN2BGm0sZoZa8+XIVLod8lfCubE4YYif9RIUfacZ/5hTuKVqCXGVJ
2mAog8Rk1Owrl2kU8PDvatd00Yg8/QdZVk03jL0RlqtdnYY2Q5Cz2pUwkmGM+bj0I5v8PZ2hPpJaP/XY
bARuliPfpNqcitI7zgQLBv1ZmE5sfUPJ98bibCL45BwHMfaIdVdCa8EoU2u7fzq9i3J9BmXqOqo+uY4g
9jOBmuIwXj4IyAmfiwolmWu2wYydfYU2iAn2DRjDVtwpoYucB5wrqXO7zO3VNkvBiACL5H4ZrROy3c7b
9R+ormtDCk6Rtg/5ArVuFNaNI85YaViGIMJbuuIWk/AqwQgC0OlUsAHmEEatbTtxIJExyiMDW6dY2Crm
+tjp5WhYz5/R+t6RiymOl5VsWdcUGkbM6jnpC5EaiYniknS0ngQ3p3foXNFifnbyeJiH5TJAa4AEE3v1
etlxQjEPHgSNi9AtMK80gkzZPfvjIbfsCzDUHZdiZ0i+Ga1xvOdzfOKA6mzmy4A89Cy2c7O4EJWsLwT8
sr7GMCc5h6V1lSrR0XjCeOl7mCl+T+QBrZbxMkiDuwtBpKP4JUWf460whQAjFo2YgXQE8ffNQbcgOrwd
KCRI8JMuAfmBS+f5Cgefc8E3FdZJpkI62lirtoIsugtVwTVoxHMvsYSsjE44BnANu56pu4MN7uuDMzcj
zeseXzuSRGqOHYr4xxQEiWbR1rZU2ubkTr3jMvXaXRxMpROy6jElAdGxvEoqSR5uzwswIzOZDR3jqA+i
R674zKplqG1umtH4akFS1ZtT4Kk5e1qa3GIubPT1Y+49jepHpIbUPXUCi2H0oL8rdMirW9AQuzNuLryn
YxM62a4V2msr2HOd0GPcgbFuO+xzGzD/aFny2xTrpMLdALHp53wQ15cPuQCy+91X545HXBt9GiWvedZQ
pKryDQlTQU4BIBIjnRfKfD5FjFc7wjLlW2ssu+zdFxCwd/Qvzpj/W76Bn+Cf5i9A9qUNYyKxwdCm7Qbx
6aDpQhxB/bdxxmxlgDqMnqij67cZEiNOPDNi9s0gMVqETj4Dab1WE70nmYdy6It8439Wm6Y+Cl6qIcwe
xnQO5MvuIQgvYDtTqHN4TmR/oxCFZSI1JRIM1MN+/JgA6aBM0VMWW3Fl09xM6N+vbSDDT//yc/Rf/xV9
eaovLYlNLkuaHKi/CPPCvIbzRf09GCck6JuEDizuojLx9VM4QseZCRREr4H6IFae3aD1+yxTRz3qK3x9
cyaZVxKeEb0WCUsxpJsIcHOzPfCYkVyos2XC/FpPOZXLFEinGCvM7t6wC7LmGEA4fg1XAEgoJZYMZ7qj
5j52lZabnBz2lg2zZTazw/ftjKH55wSD3DEuFH2VRz+iAAoJ5lkdl2SUDxwRriIc5QMz847PifRpe0L6
hHSwn5b+DZe1dWIfOcW91GE3WkiszHuVCkDlVpRzh35r2bfNU0CSUW6fZnKFa0d+J10lIPoPfNPKam8c
K8pk7bUn7HKdk7DmZqOPKZQmq6h7itsA40JThGtU2+IWzgtQcmJbwrGXg43onIdzQFZGlrvDJMxwvP6Q
LHAR2JpbZErQAO/bd6S8YHmxScy0Jp69ICf+S8NqI7vkGZPJ8CorVF78pUvkpdPFgLGCZLU+F91firXO
o9KD0q3vU9aEBofjpyG40vg0Td1SGFb6HKJ0PHygJsIbXtZY0p88g46GAiFDbcAmNF3jWwmlXD4t3lNz
yzuH6b+mDvD7YpfF62TOCspm2j6N5il6HWFnLBPyC+IwzqPo72DqYQopLdlfECcdN/Ru7y1rXgo798VA
iShliwqZChMul7mk1VBm8PouVUuAt1Gkocotj7oitXBWJWs4/bhqLbOZCKRNNLdITyYWexlWS5d0Hy2a
02/a0D0+cMnSdfuYUNeYpnyZ+RoorHF0i4eu/3udJ7/RoYLPb+6Uz+P5SpvgYvMudNCeG5gOM6BIPYBt
U6b5zZnO1OROsXmPDReyFEfBDU9L/youV4b6voMDNjYJbbA7F5rCQt4BpOs2Dh2pRSrKPgddrvHtitpz
atrwcqmJfsWEtm3pRdO6D9CJylkzGxeWfeLsAULPfRl6ZnlCE6xuQf7oqQ8/e48Nl/zGwpZ8bBce0ZpF
/4Y88QK8m4whXbLM/Bvg7zVs1zUvjShBnX8PiRijxvMEC5uRM9zVTMWOkMjhZSrlCJaquoRVRrfpvA04
OpudWzcxiMMaVU+pYCNblH7gEE3npr7ZT9m7p3adVXcMJjIFEjInA1VyyJpxF/5CpaCZZkjZ9+9mUbwm
sx63am9qiHJye9gGzjgcSGZS9jNhzKU8QgkbIkiDa88PqYzDBj0B7UcwBOBzfB1GWGveBLDu3Cpho5z9
Kqx80b6fv6fSsfNUwV4H+rq0IRgcCmClh+wLNh+YpcDrLz0NBbs/3lpTOKRZb652QtfZv11+/x0sFnz6
UTa6+WqbvS/1lkZGdZrPzSh+eImXc5gXSUeY7WYRV44/ulNE2+VTfC/7iGjWMLcXyPTx5rGVLQAzfIPB
J+Tcyx/yFNSzUjNFgX78MPKiHu2hXywy2wEqw6kwQEzFQm0Q8EIKvRETKWwlnldbUqpzHbXU0PW4v1NB
pxx9eBssKI9x3yFFY+UHseBt7VkKQkiORLJwxQomn6C+C6DAZZx8vBOhAJwtx+DQZHyz09uMZYFU8KJH
mJU/7c6bFwwSDY2qdkOAhgpdbuiqd25TruPtG2zYAUyyrdkgaOwbLNCCtrTFybX96XuUPExSc6+b93u3
+nf54QF79/+YaqM3CEo0+LC3qX/XX2rYnfrb8N2o8BbF7RzCaoqbmkikCxlttddsievesYIfCI+eYrAn
R8TwQFkjmTEu5YZILw4jCZh3npgIBWFlxEmBCUMBfrRYk7EdM+7vSL1Z4foXpyyXZtZjq/MvQ7uJDIoC
MOoPndcTIts0ASwHPMbMexWBYxRtYPlucvHfGuYhGt5NWiwHDryA/WGDcGELmTvpKbgmyPKMrYZ1NxDj
VRJ39ZUCaAmtQ3vSIB20wrf/MuduLslgl6G9DH1J8uhi8oE2ihfoGb2l3NIHztaDpRjUh0TdiGc8jr6P
i/f08BzWocNHbqA1LK75No116bl4h8cui/cGjlJgPrqIrxS2BXsQbT5egGUesfeGT4DufSd709Zg2qO/
lwSZnm6m0oB4AarnjtNLk+vrup9K1qwWV6kiIINyVzNJr/6SZo78PnBSNLOA2zGW5V3rOGfSGMgnnhV8
BAfOzVkVYz7llnXI2TxNsMAnBd/dK7dXoL7v4dGvQjsZN23Qocw/lhIShPP2U58Z8kdUHnYOTDwfdnMv
DLhnjd2ap4ZUp4pDg/me6ngeWpSElFdhjCuP9QiM39ucreXAIFr1StaiVcxovRvZoDKpqwxfV8zjzGQP
yGvW9AgVnevfiglBv9iqlPmCnGqIxdpeqHNId2R5pJZL8r/5T1yxA9bktRmjA4H7aoSTxZLfYq2yjEdt
6k4PKhf2qoGVixd+zAhMMLh26l9QuVmQJlACvrVXk1pig7Yw0PAJx1KaCXZZZ4VrbgIp87aJpVkdN13W
ihP3JWsytnFYccksStkPtGI0c4mTwF8qZ0Hrudxlc9iTsnyLORAYmVeid5Tv3NyQXcBWbgsJETbB7thd
ZIOmfgkzV67khkoW76bI5+z48L3YSN2rmrXFiGQA0t9Yq7KHaTht5rxjKMwIy0yY0D2Z4kiojADwLumd
JpoAqQI0zkDbAqYO7sINzf2PhS6iyvNobzDgCLawGr/ATbNwrH4dlp1U2pPi+17QZUPBJGhPaWNRg6H8
Ux7rPF8ow2+89DDbo31gbouLL16Qq8dzGMmLrAIqoQMgqvFEO286lhzS4m0MQttlWPDx56Z75scibgRO
LjOTNwO/hs5mgupBNPF+iQJ+Gr7wDThp3EgUPCdLQCsbI9oN6+gupwaNGR2wqtyulU6zpBE5V1XK07LE
imVO80k5cuuYSsMXmJojFNScB2BHT06n0TX+gxO1mpzimuSsguXkegJfnJ7WzwLc87v6ELSbMS/rytEb
/Mx0mLn5ctAL3WDmR8vTkOPVrR7wWmoxeeUDavUDbFYoR8atbZaXuesIPyQkdxgGhrgk8eDgFfsySdm1
R7WFCZpbmoRa39ob2sgUDJGcOBcRp/beoVkkpPlkyvjRWQA1YhMll2jDhqjhNIfGv9QG1xJs7NRNk9ou
7dGtgZFpKA7R0SAotUE1m4UGRj+ExjUgG1FXqyI1IFImW+cVmL5rb3LEgLH5TdycSH9BB4+ELeW8eG8u
9+gCyAiEdLU2sGTc0JGGyz2WcJYiU+vKL70kpL52KrgRk4GEC+eRrnosMLcCZey3q2nnGku5U5OnXVVa
9dx6a52dVKZQvCNXZ6w6mWNlvNPOb1NrlbvW70JrM9fJIC5PTrnHDShWe3Qup6VbwysofUZ39qsNdlGb
Duaugq5G+7uTieToHEdByJU552OYOnn5BzYqKrolwqRmji3Rl/HWq6F532yFtXGpdP+ZJJmWufU+CD42
gQFZgbaRq7fMflnipNLM0uNx6kOCBm7w5tGlwc4l23Ih5SjxRJyK4gVm6PSUb8UOnDmgZzYFuQ4L4Jd1
XvoeKg8OU2YiAVoIxO8MkS5UenmJQKBN5EB2L8KlY9tVhd6PAqptal/z1Acq0m4661P8JTerpFK4gllR
kGlKxTV10BO0T/in0841h3K7Aa2Gx5SG0hE2ko69ZO3p/mpyP2vLrHlIkB+dzE/iLyc4+Jsu7RDJ/H04
woDzRFpDC4Yzdp2wEX6VxvP3DiN9Lh6Hf05KTgsXJddyLz7qhwZbuYhjHMVFne+xTqpuUD1wXkjAAj36
HLvvQNd0oVuD0k1vrux1ubZL+NLVakJ3b4meuncKjvmIb2VJOMZyW5B724ANuF0CE/6CY9SseUS06qv8
ZiqQAe/e+NuM6XjRCPWy2spbLNASj80aXiNTWr4Pz7P+tU0PscuECk/SCfcMlg3Ges1TqkHQ2LjxERpJ
8DN7VmEzFvmOUWBc7WCGJIt7Sn4Bk0m86FxRhLxT/M2JCFtiyLseed0t8FIu+8nJi1WdJIzfUwvGzaUv
DLQ0USBNkawxBH6zLShvUQc/shFAF2E0ofcqOFej6X0PsyHZfJqv4iSbeok3cj+MsUCFvhDOmDzte9XV
8M2ra4oBBXj21AkQmTlj9CPL9fcNp0DOfsidlTiTVI2e7q0+B7vD8aM6xI3ZmBhghjctU5cKe0ytzdbz
XIx0Px2OvuKgIdA3T6KX6HwHOUojk+J3vorL1zeZrp48gXanHHm15USGMl6SWWMkUptZfkfHMYTXAPj+
DiWAXSms1sIG0wIvXcwVgO+bacqyeagLtfSsth3o3cBv2bYJGKc8QuKC8xunXLQT7VcF3/SCobo26xQx
O2/etD+TFjvFJQMuJbBDUvJ00huFcp2W1JMa6+8U6x3Q7gNOrl5cVf7eSV9ovtIKRraJPsVd1GXUmwa1
2nLnF5MpoYGTDx9PCDJrjkB6t7QKMiXAiqQqVbqsV3B2T0J4Q26LxTTPRNj+TcfJSUC/sAEb9PbvnErW
2cNanDVLhog9Y0oyW7Bkcjlrx5EKIzHM+0Ao8RtWaaWOtFtTnNcCzUJbnAFWUHWDi4jug25ybzP3c2WW
HLFiT9zo3oPVhoYbleAI+i/oHRbeUlH6mzVL/DZdy0srQ1hhhK8GlY7b5bf4i7+cqMnwRwfrywOsj6YZ
ocfHFzBLzwLBC9cs945vhQeia2DrTbVzRoMfawfawSMgTfT89fe6IsZQ+sP9Ooj2WreqORgNtzhkPIF3
HPuG4nXpGoU07BgA/b43+SYXM9bn8PPoVV7JjZMtBaftNbR7rFsal4a7KEGxpCqaZFhDJj0VhcCddD6N
VBzaj0mvm8qMuJQ3uPRa7LNWNnGDQ6e5vbD1kBkP9e6bfL9PpxxI04OW5otAqZ/edel36lyU9uKndSC6
yUHjeEciuNco3C6dY+CGHSPgBgfRL1e1E5ty+ip+FXIutI+HQQwYDzfsGA83OGg8eFUN2sWlaeAwAj07
R9NoL1JFXx8wBh3pRvqnaJaj6h0IIhtAPzbrmItvmOTD9t9aFff+jdd06N5xqTR6K+n480F0v1XX395u
9qLc7dJJOzfsoJ4bHEA/LGCiA7fZB0yp5IqSdx/d57FfZqTECqtLe4luEtbw+EDZj/rw4L1NXSQU9wrA
jQttD55pMrvYBW261EX8am82eQcPSww6A/eg3TbvIJ6L2nYouzQdb06N4XitTwfppmUH/T/oNhNJtQ+M
IfIThH+oEqxV6F/3R+59/185NSGritycy+/9cs8K2xWmRlDiYmlvgPKbTFS2PQg3nCpIb1HO8yJ4dm38
agHoIWf5szxbpglYd633mGaF6Rf6+HJSp4a6ATYmzuNBtJzcwhk2ukVIFNljTvFYE6fU+aDyGpWAk8po
6HB3iI+ppKS4dr2HAb2aEOyu0qf5cFCAU4uEZly6oA/NeVQ8HOwWfottD+4gYfToOQa8VqPofxGgwaZf
ytvvBL42JM5NDrlsrdOv+bJI5sSjUZlY+6I5J4raKiESCec/JqdH7ow1C0XSyZPqtkik51dtPBuVOKU7
dNfMi50b+eIJuVQRyiPjtjI156eRfWbEfstsfSuZio3ahPxDS7iFfkiJK10Yz82aogGwrsatlE2hAhY6
B4ku9ShLAq8ONIc5VaTy3hMwWeca8pfiggfRyRrGJKDznl0W6rKm7fjU/60GfgYAbJ14ajiBr7qK4NiS
E9DYJSnxn97dn6QZdJ21k5U4s9tDoyR64AzYS3dHSZHgc0jLTRZtZVcwx3796ABnu/KD8r9n9Bi6bvNH
RJtPYqLX6K6MQDreA7qlalP/fGVXRjfoKRbt8/r1Gx2rGNhXv09uGx5kPDGh49jGhujbU7lNa916+Alk
gFgzAmppZH+V16QxRznNr9C5f6YL7C7INT9P8R3/MwopXecLlZLPzfFKSS5TpjgInEaGuciww2GlS1u1
iHIeFubOjHI5hIUJ7Fc/yv0ud5y6z2PKunSZJuCf6j8kMMmU0EJkMpCXz22SmN2Q6SfpBS2u1HXCidVc
oILBuiXBof3LxYS/d7zF/Ee4GCv2qAMISfS35TzeKOc5XY5nx1JFiX7AFzMokSmbNJ5jk79Mo0fT6PE0
ujeN7vON3gXeVxXxHMtwezEmVRG9jW8cHilC6O/H8OuM8zT5V5NuwB8n8HvXsC8pF5PiOTk0inppimFw
f4nXm4fT6C9phf9e07//2Ob4XyT+L//j9l/+90NzVZlgXWMhhOO+VYFJ+Y2BuRQLVYFx2eHbGR02rpc1
q16Hfy28q3bPJjEZGyDXD62Ja565DJbFsBdo63hncgMs2JlGN4t8v5Yhw7vpvOLwMWdfbr1j89LYw6nE
HnINxqhw6uxfDOj2Dmdr1/D5epOA2ek6aSu13qRk4pHE1wqiSCqPwpmg9BJcJCavq56tYBO+8EZG7uCj
q4RLHpHQULjF3969fuUVCj6PLoUMhwDCDRNJWzuJYk4t9MGh1DXUH33+NRWp/Pzx1NX+Os49LoCCAi/X
nWFjHD3X9kDwjz4XAMbMANlZ8TxaxLGug0bB2bg7UeITDexMVsOUKmk++vxMAEY/gmQiCgSq2YgJjPXx
SuonFSkm1oiI0jSs/NqsfnHmKqfLLbzwEqBYKoYKz2tOeRVFi0Qy7GDjOMuXy6lJ7zX53S4BsUlHkIwy
L3HOjMONPmA5sHle6S5qeXBXdycJ8qpXlJJ4aY8P9qZOzAhnv8brzl/ONTSdtBk5yYyIAbray3V3OZuO
rKydzZ2EVv/sBd4gi57jP1I9lQsw0QpDGDMfph9/qOmzhGoYeBligHgqo57BkOB5o4tSsubl88Snxr14
xfAdGEaz2sXDkwj+1wdiGpneUzMwTqGtzYaj6AmwLRLlJJE7A6KQim/ffnNWVrvUCjeWRMCsdarHR0V5
lEm+oHQLWhO6cVnjcIyheeIks4Dq7NIkh4YROssYa4kPYRXsuiaCUteB4LT2rc36wPx6LIjLUS+gmpKU
nW/yCgmmNWFqX0vWLgKE/1zEcDjgI6m1to1746Zu+kS1Am/PVrKC/HyNKPTiYyyG9MJELj2LuYaSV9TL
jV0DTSxBPooVA4myD4b0C+dwkX6Fs7p4EGo7thfvUo8R0qlFuE/awC1sJhFC+qmdX57Jlw/N715VaW7q
N7RG422Ftl4t2qHBmBrdP3q/ygEK4ThgGhHn/6GheyOixl5giaHX1Ln+4+SEtq0lmIDOgoKRRL/XhcDI
gXk3NlDqz5MGPZhqt1HRjJSGKDe2wTFnShux8Oek63VSPBg9DvgNQhUZu+CyYBwBMiyyb++I6BDokXT3
TcE61k8JrDFATktK16B0o2FOnCMQ0Bz6fiQ0MM1Zgu9iuPvhOnRkfcwtFGYEmnMAfggTgsWwwmRgGawn
D3odd6G3Bh3cSfZrKxPuGjds9Yv07lEPm4u3yfWq8iaEvvnInHGpQPYUn549yyTTvhj8s3NJmpeqm3hD
7wcbwBjSN6+OALp/MGg7muHgh7FYw48pO+Dxdmj8oPZSJ5TiKGjp70c/ePaQPXc+iH7YGzpO1I8OBvO5
D8teixD1kFl/v34szsVUl5gKC6TppPP9pnaUzQviBnRKeDwe/N5hZbpQHvx1/GEZ6GW+Vh9vVDr+1ezg
/NG9JGwCfZomMefC3dcd7lugNZAcb6W6IfaRyX5DAxE/TGy1W3voHlKosA8XpcEKKvpbr8KdiyuQDO4D
1iXEaxbgrbEAb4P+934b0oXQtZ4Z9IHaPYwuKJb0ztAeyMIMSky2QJKNY5AH4e4ZFER3FAY1kWHq+DdW
UeCHUSj30uddSO3KOwwHFfQxSOTTmKH9cv48ofN6XOwemWcyHh+NlPYBe5hh9PvgpLgIg1M+dcrugNFf
HpOCYaPeByNdpBmM8ungKZc1fTQ6Bo58f7TlartcpnpLk0+T/RcnFRXUUOgDOvayvtfxW/r16SMPd5VT
poQAkU8DhuAPIPnNkIElqOsq36mh85QTJzyX7B4eOKosZext+Lt3tL0AetnsdlmpeFFH2dZsL8BV/F4N
AEzN2gH3awiqaWc0BH2aZE9GA8SSGCf2Ca19Z6PeffzIClXaYxJCah9TsweYup1caPZYgDV5CN8orc8c
7OTTvstumcZVpbTpIp8mkofulWTstnIDB2dTRZuOzvxp0vO0f69Njm8gOKmk5vP4E20f/hoF9BD/iQmg
AcwD35TvB+0+Vm+Wl/3qAEQeGvuquxZE88Vk4GPufShqrz5PAk86R707/KFYH8lraUNejh7mgwo8Zi0o
9h0f99sfz+FD6RfD7peWW15p7gfLt3sCmT90vn8bB2uhBIDU3rPd75Avr3q69u7rpfFRTKN93gvtBTbo
UdAh+91LD5HzjYOs93HJIec9eXvQOfTJNy6LQm8NUrxD70uDIUeAvyXLO3MSllt7oG0aDXixbgSOBqCo
8+G3gXfBuo+H/Mp66umBMS9ibfCzPj4iL6LOonlqPKb68ajBT0UNGIi8TuTuy3E6GTmCIAZ5nEYw6Kdq
7Ls0XPmr9z2aAZio/O6JqeyjipZx1AKXB0Guv7Pi1cMe5LdsBbW/0zNIo34iQBu28rFGac9rAGMZz1XE
zbD4Yw11uGT4OIy5xYZ/ToYACugQqjMscOjvif94zmj6MHJGm9BY/9cU+3Ugc/bOYPiBY0ReKucYMaq6
LYfFhOvbdijFgK6SOnpIDZWVPQ1WdewFw2bBiRMXVPYdjgJQKLnBKDUsmDrA/AnA4cqgxjKgMqE9izMA
pV4D0xbRDDOppZsunTmSs3wxKbCkBmN/scV+Vif2ugULD7YWyOOfe4re9aKrl9VrR0c/H4pO14Cz2woX
jBtQHq7XEYD11/T6xb+7XSgB4iqjZOCviVPCTJ57CxQR33P4q1iPHOtf9ZW86r+NogpSWpx1PSkdz3E6
sIiUj6Z0I5FFJOXCT4ulLs50OqQiU79O4PJFWinoYkbd9YuGQMUyQhYqFRUaDYsDai00KeozFp7rKdYV
dsbCeu0eBk0dmvGUienkUKfrvoyF+cIvfOZUYBkLkaPLDTyphzIWGifbGmhSjWT0aKkQiB0r1wUZC03K
cRhwujzHWHjPY4c2KpgxFhLXqzCwpHzF6DmIX9kJiF8dMJdp6swkHO/GQjJ1Dgw4W/mgAdM3//rrHXS7
o3XKvcYsH/tMpToYJ4teolno4+Q0lOrea9xT0oLeH/387+MkfQ9xUXDus/goMD3Z8accBKcns7lXXiij
V+/ElN3bdzIObLQdmamN7MdeYJxrpu1TzqgcBUjnYxqqBgML8IlTEk/M/RLmJ/amJPaS6GSIkXjqbCTM
OnoyMO2oK8fJXeN6kQ9JiulZnwhBL078m0y2QEJJNxg61bknPM8EDCd8GCz/TZI9QlwZAH1w6sQw+Ack
foxHcNAY9szBIEu0JymC2vz0cysBr5ccmaChjafmsBwNzY6+A88YpgSyNz4tW/ZJJ2lnTAPfkdJlOoT/
DtJlxqyDj5Au08GEj5AwMxT7naTMjJ+Rj5Q008udO0+bGcOi4yTOMOZ3YMlQ0Fsoauo4aTTjhnisdJqO
KT5eUs2YIe6bWjNWUsYk2LTLxsdLtxkz3qMk3XRIzJHSbkYN7RiJN11DO0rqzZiRDUi+CYE9NP1mDKmH
JeCMwTg4DUeAY+hYj2+lLxln/OI/QlbOsZHvE0E/EPWwjJ0DBnJ46s6xkd8BF8MRV0dI6xmzysYl94zB
dLwUn6MjP+5Aj5bMcwe4jznO4yXwHB35cQfamqozClh/wk6HrdKetrO/F7U1fWd/UIEknjqQO87jGa98
u7N6Og9RzdyefZqPQKMzffZp3ofmCHk/Y8AGsn+OAebQ0XbmAnU6TToygob1a+YFjVOMLdlB+6/q4TlC
Q0zwgB9gWKbQqMPDkfOFNA0Y/tdDx/i8oYEDPVb20Bi+jsohGoPoWJlER8B9UBJOx9K/g6yiUdiONayj
ZBiNA7xvjlEHnwZkGo02zPfNN+ogc0zK0dj9dUzW0diz6HETj/qpOELu0ZGQNCH9qbKP+kd5jPSjfiwH
JyGNRDEmC2kkqqFpSKPBj8lF6tBFQzOSRtJ7lLyk0bwan5g0EmUgM2mUhhmQmjSSwuG5ScMRHJqc1OJu
uNPsJMHJy30vvdiSozRKxwYzlUZBaslVGgWrM2Opy33RnrI0io6hOUvjWD8gc2kU4CE5SqMA75WNNMr9
EMpJGkXqiNykUXi6MpTGBRj25ij1Qt0vJWncYu9PQhoLN5yGNBZaeyLSSIgtqUgjobUmI42mrjMdaSTU
zoSkkTBbU5JGwmtNSho75ra0pJHwOhKTRkIMpiaNhNWanDR2NprpSaPnNZCgNBJWT4pStxV4h0lK+zvX
O1KVRpn7R01WGuvSCCUrObAOAuXnK42Sn2DK0qjduCNvaRS8ltSlkbS1Zi+N4trABKZRtN5VGlOLIvjv
lsmE2YJ/NJKYzC139Lv0ksT/ZlObg/HYhL3auywCoO/1fPr/ODlZqHkaF/RcWvTLA+fFnHdVXCXzh7bF
Ol9sUxXd25om9xCyut3kRRV9Hf2C8P5/AAAA//9S25YVbiQBAA==
`,
},
"/partials/ack.html": {
local: "web/static/partials/ack.html",
size: 114,
modtime: 0,
compressed: `
H4sIAAAJbogA/xzLQQ6CMBCF4atMZoMu0AswJF7AOzzaARtqMZ0magh3p+niJW/x/QPIRZgJTyVRXf/J
4Y38b/9nTGnpfTBMUb2wFRS9PVX9w60kQjOiaUOvrLPwvsOVsKVLB7d21+Pgscq0fWu+6HDHeAYAAP//
8idQj3IAAAA=
`,
},
"/partials/ackgroup.html": {
local: "web/static/partials/ackgroup.html",
size: 2142,
modtime: 0,
compressed: `
H4sIAAAJbogA/6RV34/iNhB+5v4KNz0JUBu4Fnp33Qak7Z6qvu9j1QfHmcTuGjuynQWE+N87/pHAcizb
6rRaJfHMfN/MeL6hsG4vYf1u1lIFMudAK6GaQ6lNBSY3+NXZu0W7++3Yu1RUNWgq9Q69drnltNLbO/JL
uyMfwt/39NflcvkzEcqCO8VtqVEIfSvw8/3HL4vfLwNtxxhYeytw8fDp4+LLZaBQtb4Z9dOnD5/rIaqY
p14UlXgmTFJrV1lEaozu2oxg9pbr7SoL3zZbvxud+zIJ1NRi589HBV94/1KoapVR9pQNiJ2UuYTaZeti
zhfB1yLNC7sRDXcBZ2RBAnP+rSjNOj475/QQUDpF8D+voKaddOHdbkK2TAr2tMoixMSZDqbZmkpZzCPE
N8HVVFqPp7SCc0DsI5Zzoy6yFY7nEQWqs7ZStX/sT0Nq3pH0ji9aQC/TbY3YULO/ku4GqxCUOaHVZIw3
MZ4GayUsLSXg7XzHqLpnTydqdFJ6i7YGC6OvEKZ5fouQSW3hKuWDt5xIg+PrdFF2b7HV2jTgrtL9EUwn
vuh6g/Dr++cG6lV2OHBhnTb7yfR4zNZ/xo8ENFx+MUdlXAgkiCnlfjp48O+TIKnZo6OuszF9Ay1Ql8SG
KiVJdd4mlECLqHZkRd6jxCCJ7ivlpoV2k/ShMwaUS9w/jP3OGJ+3mGkpaWthgoTTOJkFX74kcsJJiLZR
IWkJ8srgx1FOXqNCqLZzxO1bQA4O7AmJsyt7wKey0RXI1IxZcE7S6XP0j8l7eMZKfkw9iX1k3I/OKuva
ijqYTPsk5yHL9EGJv9w+sXPdNnLfcsG0Ou/hYTwc57DDww31A5hb0ajxXbyp2T0O5TMc/Z7rN8L/Bn/W
sttArut6gH0UEhSD6jrwsHOTc1f+E1r+eg7nC/dwSCPBhaxwKGZI1Th+PBIqwTh7jjJIZ86XcfTjxF+Z
wlJXe3L5UyJQS37vqb9wrP5OY4WhAfyFYsLJf1BN79crh/kqBuUMRUU/Z3OLcUDwpTGt1zXmgYpOBxHU
H19RiRd+rL2vuZd7fKbHvwEAAP//1kNQfV4IAAA=
`,
},
"/partials/action.html": {
local: "web/static/partials/action.html",
size: 1348,
modtime: 0,
compressed: `
H4sIAAAJbogA/6yUwW7bMAyGz9lTcLqkPXheh2GHQfHQB+guxXaXbdoWIkuGSLXNnn6SHAfOkA3t2kMS
2yR//R/JWHbOj9AYRbQT6boYnNe/nGVlRPVuI1v9cBbuvQtTimykUTWaJdg4U9BYfIIm1vp4k6Oium1Y
OyvLfJvLVorHoi9ZbyOns5MWIWLFuhFg+6LWtt0JPkwoKllOWa6Mesno8nvZcKo+Pr0KhB7e72C7vYZv
8Ru+wnZQVKD3zm/hBXA/opJVIz4PT9spMCT3kQGfWFygzUZH16LZieRT/B/jSP1PZXT7Sr47JFL9M/ES
kvKowLvHGL35KC6Ncw04zvKz8UHZPjbmIdlWjHfUX13PQzfB//k8Tn857gUN+guA6zpCzvQLEGSideqA
zb52T/HkuRdn0zxFV3DWse4O/2Cr4B5tC99Tnm7U+m+ycLw9WOaqA7OzR+8U6lHzaVY1W4ifosVOBcPH
pdLNfslMzu/zlSxnobc3Gndndjp8rm4NepY0KZus0OAed2KPB/pg0PY8QAU3oiJZpozYuFiRK8NpuY0m
LoIlPhhsZ924/jqpeZxQcdQDbSGJrt4y+7RkRs9qZTAXKGWZ0KrfAQAA//8Bch5lRAUAAA==
`,
},
"/partials/alerthistory.html": {
local: "web/static/partials/alerthistory.html",
size: 867,
modtime: 0,
compressed: `
H4sIAAAJbogA/3xTQc/TMAw9f/sVUYTUTZBOcIR1F4TEHW6IQ9Z4bbQsrZK0o5r237HTplvHxKmxHb/3
/JzulO5ZaaT3BXfNhe9Xb4+psjHCVOLjJxb0GYy2wFnwggJB0X63xdv7Vfr8H62VFoyoXNO1nNlKOGhB
hoKDDW5g2jI6aPCxqK3GkpVnYEUsDPkJhi9MzmEvTQfE8S8JG6kUHGVnQrzzQkkNUmlbTZeDDgYidWl0
eYrDG9l6WGdRcsbes3faKvizGQHfdh47qeGA6VErR0co+3ghcXbGCKerOvB7j8y/ax8anMaArUKNHBmD
Hgf02QJrcvjlHIdGDaNnx4L7urnYX8+SfyfJQR4MpPYYTBUsEc4UYOSYRoHXaxZJIlQrHSrLR0iSKu4M
t9vk3V3YVzqv+/xHkKHzH1iWbRZ772nnswNJB3GrpatE9ZkRVwIjb4J67qDZETb/ie9zfqiLBFg1J79Z
NeZtQ48ZNx5cB0tkPLvkz/bBIAzIu+Vq0mH5U/wNAAD//wJxdrNjAwAA
`,
},
"/partials/alertstate.html": {
local: "web/static/partials/alertstate.html",
size: 3440,
modtime: 0,
compressed: `
H4sIAAAJbogA/7RWX2/jNgx/zn0KTQc0CTbHSFcUWGG7uA0dVmx72bV7V2zG1qpImSS3yXL+7qP8J7ET
Z7dLcg+tGZL66SdSJBUk/JXEghkT0iWTILwMWMJlSolMvbbhJyeP4lxrkPajZTY342+H3kythrUvj19C
alWaChiNafRuEGQ3XWzLrQBnGQSMZBrmThwEBq2NYyrWy4zHSrYJbIZbtQcrVC6Y5SgbnsrhHTHIBibo
aicVMXJ11aP8JiRDqfSCiWFBo8B3255A4FWJfAGems9x6zjjIpl85AJkDMk5sH/nYA4P9SzhlYkcxX1w
5nBcDEMKWiv9CzdW6fU9E6BtuNkgIZXAqIL54JTjwkF8Eak517A95aN5cBvteAQ+ax0UEUym3kLaivyj
jHmC9+UxodH7zabXUhR3B0FDrBmXSUjr+OazvyC25NOnmkp5nl9h3QnJQcyXuRCe5mlm6Y5dDZAqSqzB
YGPe2soWYHW8wM9uoneBj4WCn4NymalkXaJzTITbobz4LTddqTq6WAnPLLxbWh25x7vX//vaNAiWmEer
lUyjMhIEQ+GCWKkCf1lDVKSPoP2wReuG/J83M5JsAWNK/H2clnQOaVeQcDHCB5XuiJMys6RyxURbvoCO
6xMq6Nc64J8c3swZB2wVt5/Vhf0C611Zlwly9fwz3nFS1767sN8dIjR190cu4FkLt8qJ5CHhuOrIIh9W
S33v/uGmM6tY3UkeUFNu7AQwBjvWMQRel/g9T8KjtU+j5hcZvT+e2FYj8aNx03j6ErcTvk7B1b3+rOTW
lpmVBP+8BOYsF7aUV4a2Qmiqze6TXJcTL5xmV02Db3X2oriyLDX7Xf8JdWWupiRTud5G7TwK1ydRuC4p
mAtxuD2Jw+1FOUxPC8T0spG4vjktHTd7LC7eAj/Ejt85TRC7NotfcF0t7NSxUAYqQyXuTHOlU7DNQE61
ypfN+y/E918uX6R6k0Nara68/38E9h85v2Fvqg76ZcFx60i18PQANQnfkZg8rZdQFHtTsp/w5NmAptFs
TXpwnK0oWm+rwYDZ/mHa3t2N1Kiz6nMkfscRwlJcdddHo7Z2mfxHz99+e9JWvs/KDX50T7YjE2J6XY+I
TPufmybo28wqL7ML0cXf41R//g0AAP//GItLbXANAAA=
`,
},
"/partials/close.html": {
local: "web/static/partials/close.html",
size: 170,
modtime: 0,
compressed: `
H4sIAAAJbogA/3TNMa7CMAzG8av4ZWjaoX0XaCohdhZO4KamRARHsoNAant3UpgZLP0G//X1CD6iqjNj
ZijXPlE48PzxS4HndgqKY6TJmVozZupKkLtz4UPhz4HlJHeMFtYVvg8nokkP/tZAVcGPiESS2MbsC1eh
izPLgj6HxLX1MSnZZtvMcNzZ/+PwDgAA//83rMKuqgAAAA==
`,
},
"/partials/computations.html": {
local: "web/static/partials/computations.html",
size: 616,
modtime: 0,
compressed: `
H4sIAAAJbogA/2xSwY6bMBA9J18xtaqoVQVIza3F9Bd6qHo39iSgGBvZw4aI8O9rY9hkV3uIx5P38t68
cUoStUaQWnjPWWqWM/Pk2h7V2klrFBqPilX7XUkNCgXmnPnGXjmLHbqIBMjFEikRr1ujHnhZULOh1X+h
B9y+CTX+LraBu1jUVt1WxajksEdBnEloDUjb9QMJaq3xcAeHL+g8sshrT5x9Da44QglHuN8hzshWWwWe
bho5u1qnstqhuPyCpWRC69+JtitFVGocBq0Cx979iQefppqs+CbzfzjSd/gB1Hb4VzjRzTN7pE14TCuS
a0Hqzf6JtSwgTG9O3cJOrHUTW+y04Oe8uUZzDtutQrrDAb68jyet9r0wnP0MkvVAZM32uDUZCJ9M4UkM
mpb76JfBpW7lhbMoBRzIDciqafrMNYPjPENnHUKe52WRLD5OH0p6vnCJf59q/xoAAP//sxrzHmgCAAA=
`,
},
"/partials/config.html": {
local: "web/static/partials/config.html",
size: 10183,
modtime: 0,
compressed: `
H4sIAAAJbogA/8wabXPbtvmz/SsQbgvtqyjbabrdZEm95aVNd3M/1L7sw66Xo0RIQkMSHABKVhX99z0P
XkiQomS5dq/rXRoQePC8v0IZSrVOKVHrgo4CRe/VxVTKYHx62hdUsl8p2ZwSQk6yWMxZHk24UjwbkKtv
ivvr05MJFwkV8FncE8lTlpCUzRdqLugaThcUP8iAfHN5qcFXLFELgL68/MvpFijEU/qJJkxxQYCMf1zd
dp8ILmlKpwD8TvAi4ascrsxSHgNMSmcKrlgmhbloWOxkfIu0FeP5mxK2c1lh0lev7R3EOrDwSF3fiCb6
CvKbxfeR49KJyJdUAKpVtB6QuFRc3x1eaCWPT4dpPKEpmaaxlKOgLU9ANNgoaMihOQ7G/yyzgig+GF5o
HIArYUuHSfAVmOzE30osUrJLJZ9HghY0VqPgDO3eS5lU54TlhCmaofFPToZWTIttonICf6JCMGBuTRz2
SPH5PKWB9R9zKSAsGQWI69bSDkgSq9gC17xpViYsB2i8rwmfDGURV3SnsaAqGIMCYVPzdWFo6HWZtqWN
MpqXpGmqgAiutQpHlkTK7F4BTk5zFSN4QzHIPWoEVUO+EO3nb9aDUPFbJVg+PzsPga3YQ403QA8xykPv
R0F0pRFOUzb9DLaeAmR6x43CEfYcjLrZ4Gq7HV7EIGPKjIRlira8AGO2bOqskNBZXKZK45cLvhoF/y2B
CrrIHbgOVZ5iu04sT9XR2Tmq+EF6pBEzPqZlDLEfK4qIPtr1kxBCZrjTzvIBYkDnFERttsjtGix2T6oj
MMeTiKHjQPQnb3k+Y3Mk9M7uWLTur1bE1eq38gP6n6hEy7RYmfI0SufR1SsTW95JnFIBrOH/o4TJjEnJ
JhhQmj0N0kZORiMSai2H5FsSmruynE6plCFkW7uTxPmcitBzhS4u60hvRrBjPOWSdli6wjEKMQ50dL5U
LKPy2sZqI1CddQ6q0+lMSV15YlADgSA2ZWgUmEJhqxIYyV4NzUZYKbZkEXjPKNjA5X+BDUEj8I0rmvRI
xhOqN25g0SNqQTPzfYerHomTZZxPaTIgGzLjuboF3KDSq9fFfdjTO9/FGUshu4c3FHykR254Hk/hb/Ae
KIGxRBo5Bx1MaUi2W608pJqiG6CDfcIqG5Dx47TS7UkzLjJ3hOuI5SnLXSb17unDueBlYc5OmqUIOFMC
UeNmMP5O8KwqNBqa5UWpvC4haCC216sCZir53zEh1tLPAOk7SAzGnRbonlgD1Q+5ogL8Cm1apKC2BU8h
246CNfwXZVmUJAGZyAiTSgFOSIWpJvgdIXnM1xr25kbD1qeGX6kzdvC8ktyBsx8tyYcPg5sbaxRr9aeY
544/u3EU/8NNc6xmnkXaP9J8jo7cb8W8zCYU2qaM5aPgFQpDi1Fw1ZLqbyhVp/C1qMwROyQtnEDxwYwL
ZeKFC1Ty5Qt54RxDcZ4qBi0oU8jAj5pBwmeEAo5SVwRJJlStKIVagpUAqkD/+ZR2Cxog70qhKZGz7PxI
5V09RXmJpdfWnePjt+lOi+JQY5MJjJaK1uqrbLajP11MkdsH60ZrlrDzjx0mDtaUi+L3LC3vs5il+21H
8fiYiH512Qxpc/H5UizNIAWAHb/HG09Pt212lcX/yXC04yJUkdWCTRdEmJ5PcVJKCg2IwJ6FuOtksoZp
R2ELTGBq4gUMMzKZEI2VnMWfY5hI5gChxzu8abIyBu7n0bKXjXif3OE2EzDoWGJIxVDHG7KgUzZjNLFY
mSQxkeUEsCKa2N2CfWAx6ZMfZiTndhdgBW3Ad6DUfZhlz+cDME4X0IA+No8cnF39bhaCzgwW8DfZbMyo
TJNPuoPGsazuYWvixwZgNR2IMs9tlXv8UMDyGTdy/WTQ9Pv9o1vqmgcqBIzhhzmAYbhzLNGDhDdHGFyV
fy9gho10vzsggCJaibi4xoESPh7B4SoWWryU5nO1IGNyuZ9df1JfoWfby0SJePoZg+LPego/qFl7xxNs
FexryuuXhjxeEvgTwaCvX0rwLaGe1TY4ZC5BEXCs5zQbBeFWvxYsBJ357odANUwwNjOV9J4DHkDv8sBB
/BVQndYeQQFKOeb9wxQcEFCwy5qCedDwrQC3dJqEZNW2MR5B49AYgA/y5AwM4GxmGfJByMuXpCrKsLY1
eSeL2FmrtVu5HHEIIVXLCD8i/Bp7KakzOXWjRQlTm7N8XwaFiDX6My4YNT0by5lCv8soqFpD9D/T9TUk
VfeJHZgVqYMOMdTco5EF6+BnQeMEg8h86UrkJ0vQRRoXkp6FmvGQfGWj7LzCaR/vqoBCpv3XOw/GUS7T
1Dx0enEY9z8wCcP+2iWDr0gIfSbWtrCNrlZ7p0wTnpiMj86BiSb/T5v9nz3299ioAtiF8B1Vb7zF9dmy
f6tiVcrzhn2XaNtKOg/tfmt0W0CDaBEKqK+56htRUFFRLVlPu0dveW5eZDebI+9ttz5rJ8PF6yZrxjV8
kBObGhp7Xd6AlAYESTkN7fjHg05i39z6Zoaz4djYoHlSbb7PEzvscQxZTFqi3PVK40txQ+6LxWvfRL6n
He1sx2n856bCbUIzgr5Y9hOe6xcs3UXYBfQBbY52Mo+vraoD6AZv9gIezLFdgaNwbF9wslexHRtH5rQ9
dnGh1JJs8XWnW9+Wk1+gDQTrf32YzT0eUDXnDeVIgzUY/59J+wY4fkZRo4XKUpRXx8LDwra+m5/N3O59
eOuOAtzq4X5Df+F1VadH2uMhOxzrbd1txGHv2vWtevF78t7wncczbn2l5Sn1ArLvP5Yw1etfAj7GguFC
uqysE1OlAnxY3Jk5Hm95r10/3dPItZOmzKK/Oj0pzWpNsK6SQ4UqrXxZidrJ1UI3zcMLWPibbwVTbKqf
CVsn/zaTy+7Bjzjcd1x4j5m5sQ1rUQWTz9tQoT08Rv3+BUd4hj8pK+k1TSpxk8Eo+JPvllT163fW5u+g
1etj1UKagUElPt4mLqcQfFsLQ9+OjdNvSWh/+8Ifw3TDeAirVWY3UncIOO24eBxSY4hunPYMUPo/2j2I
UtuwG6M5Oih30961ieED3bQ7gXb2E3t9oSMwqm4CW0hsQfXgtNm020z0koF+gDEes91aViVoKh1PXSQ4
GGfr7bbnRv/qzJoMj3ITDu7EKB4PdKdS7Wv14WuPoWZJdz8iuR+TcS3Ni96CJeZVuG/H94a/Q/d1hu9v
rbi4hX1tTAQIW6/IDiBo/IrqN6RdmaZu9nxejso/9pGzlTVMf76bTO7xX01IxvOdI0N0N5PxrCjNP7J4
TBLyvU1YX2vo2EzG9rFwRIQ9vLYPlbjzfWN+a8qdEPBpHAL0TyyVeX5dyTON4LxhSKrc44nG6UB2o7YT
qWHSjTzdM2MDpgch3IXdThcWFgMhqOLjKOC612oU0F8kz888wP5HfFQ4958xfSzNLv4YwjiXTT1HaJz2
fRfZm7lcOfJQY7Q3S5HNB22WjpEbke2V21B6QO59MmrMR8l4fHZuPFH+LwAA//8udOBWxycAAA==
`,
},
"/partials/dashboard.html": {
local: "web/static/partials/dashboard.html",
size: 1345,
modtime: 0,
compressed: `
H4sIAAAJbogA/5xTTW/bPAw+9/0VrPACaYA6WXfM4gA5rLvttt1li3aEyJIh0U2NIv99lOTmA0iBopfE
FMnn4cfDtdIvUBsZQim8OwiwbRF27lAK46TSthWb/+4ug2pnCtMWT9+j48ojDXqC9Fto27iEVWmrLrDW
S06IiPn//e/DItB7579WgpK2RX9RxIT1uRJuUIauePqWKbXtB+KPu8ndON8VtbPknRHxncYeS0H4Ssnk
Gjqn0HCkNsRVTY97HJU72FJMHw//4wtamid/b2SNO2cU+qs8cs6Q7tOnJsM8z8mZ+4ZICtUIL9IMuIC/
0ms3BHC045BAkhAyWIAw9L3zhGqVHENYrVPWBrihCS474AFfT0G116RraeaPIOv9at1IE3BJ/pRY7607
GFQtqpwYw6KfM6wj3YxXROmJAUk7OzFNUWEMUnXazhewhYoXCg/3c+jkCBVC77FHq5ijQoZBkHacWuMh
+A7IgcU2Nqwpw95PHQw2VsiwcaBnLdxa+SQyCTuPTSmWSUWBZVQNRM6+R1dkk9Qm823GD4XCRg6GZpG4
3qEaDC6epTZ8Cts43PAIOS5JlcNuRx0FT36Mi274kGjldbujHwKyyHIdXCUAK2IdenkuSvIKxObt7QPc
4/LC9cfWxgVUP1ODx+N6GaE2kO04g2Wm4guSt++HQsGbLlrvhr4UJ+Rf0Q6L34hqW+9FVEMpZtEMsD1r
pWPlz8RpBmcA7lR3KK1SvEu+qrNxuuZP0F8wqfcaLt++SP0vAAD///r8Ui1BBQAA
`,
},
"/partials/errors.html": {
local: "web/static/partials/errors.html",
size: 1698,
modtime: 0,
compressed: `
H4sIAAAJbogA/6RUTW/jNhA9x79iKhSQDVjy7mJ78coC2sXmlAZFk1vQAyVNJCI0KZBUHEP1f+/ww4ns
OGiBBrFpzgzfvBm+YdF9KeGH1kobKFa0mc2Khj9DLZgxm0SrXQKyzUyndpsEXVxSzq6mIbUSmWizz1+c
46roNR49TKC24L+zhskWtcequGyOWGDsXuAm2XXcYmZ6VuMaCCLbadZ/S8piRRuXcEUZy9lx+ZChUKzh
sv0XjhPPlCOXj8oHXN0EmDzPXXhIesYhkHhNbJVl4oZLNPMFlPApucAy1rpluuUyq5S1arv+/Ev/8s3z
rQYyyHgirawE+mQNPrJBWOgHITLN286mLmsteP1EhQlk+lch5gvfhIYbVglszvhsNo7QdxcLFAzjOHUf
DsUq5P5fLO5QYG2xeUfFRMclNuN45j0c4Gh5Y3Xh2nsmUWStVkN/ftne5Tlo7JFZrzXgEjDI/G9QukH9
234ND+ndUNdoTLpMs7thm/51qvacbEko1EOPacgb1Jyu4acQ5DGWEL0mYq4nzkMC59ILwR0GxU7a6Y8R
BQmbmMBtgjKL7uvpecutwKQMOh5HF37Ltkh9zGAe9lQEbfEZpTULDyJYheIV5/VOY+tDJgrjsh8s2H1P
qq07rJ8q9ZK8P+a5b1WDInD3odgkJwqhZU7OJfzsiSxiOStPJf7uvpYwGbgL3apUs/e4/HHSp4j1wVgf
nx6t3PR524k6BCkvyiP/cS6RhzS7Ycbe8y06cZyM8PpTHF36G0cHk/9OV83a0P1o+q4GaclgCcLAtVZb
KOihk2BN5myBQH7NdUjjHj3nL+FeXYw88nkL9AwoY8FcXZ1Gas446kEgTdXT3J1aUnU0XEn5J1nhD+JY
rFhs+7HbF9+5//DchYGefXgBcR5Cp25VnMMc7jtugP4ZtEo1YDv35L4Rics/AQAA//9oHsCfogYAAA==
`,
},
"/partials/expr.html": {
local: "web/static/partials/expr.html",
size: 2127,
modtime: 0,
compressed: `
H4sIAAAJbogA/6RVzW7jNhA+20/BJYpN9sDI2e4ChVZSUaBAt4dcurkblERLRChRIEf+geF375CUbMkp
3CySIBE583G++eMwsXBQgsChEykFsYeosJZmy8VDUXMD5LhcLBpuKtnG5Ouq239bLk5n5YOpDO9qD6qF
rGpwoIAaTrFcA+gmJp+/XB/er0EWL+QBJKAHzsaIZRPwhKLTVoLU6IkRioPcCsejxAZmvh3WfC/t1Qme
W6168CdAdzFZfZsQ+s1OllDPLBm741AE8lLaTvFDTGSrZCtYrnTxMjn2OIQ95uFxlgakIL91e/y/Gm0r
ngt103SAoeS2A4VW2sQkVzzsL4zu99dLOC3fMsBETIp6Ls/j11nVfIoG2WmZRL5LsmVSyi0pFLc2pUbv
XJ9MRegJsw17/OwUi2SjTeMXE4iTscrovvOYReJ6jhvBiSxTKvadeUbBHyigsyOFbsFoRUlbsUaXQgWw
37+IQ6l3bUqHxf0vYita+OSVspWA2C1X9yjAvrHYdVkSjbzewQg9DIuzz24x8yCkffD6RkSLJFT2nBPv
OPNCmv3JQSSR3wxo2XY9TC7g/8ZdoglKsBcKUWtVCpPSA/6wpmFlSUlumUN0eLeEIbjkfs+cOQ4D9unJ
Yy/awG/ByLYaYhyT8o5on2Xz3mgBTVxF+/17/PQU//jxc37mPXZ6O+pzaAn+sc5IbPmDZywU5gyTIABb
JXsWFpIonLpB1PVKMePu/EjErzlKseG9As9RG7FJaYSBbmT1u2vh9HjMQfN7t/50OnkU3nWeK4E3wgiL
R9cuYeRDSu5swRU3d+TjR3KtavsmF+aOEuzrSmCl1zgS2hea/dMrrAJ/u3vHo91W696oV+58GBSvSf5u
eHVmeX2hBsn46c8dg0OJjIPJzxMlQy289sgLN+djpMtJikGGoO3diWYYiXN3UjkPumAw8rBybmEbyot5
W+tdSv3TQm/RecRNsoCg2V/ueyFKol7N5yXifX/jZLqem07VcRwub4ucgGXDLhsz/V/miH9o3xSfn5Sb
IahLVI4pvL9uUpwTFt64lH5ZrWg2q+y/AQAA//+hC7msTwgAAA==
`,
},
"/partials/forget.html": {
local: "web/static/partials/forget.html",
size: 119,
modtime: 0,
compressed: `
H4sIAAAJbogA/xzKwQ2DMAxA0VVcX9IeoAtgjl2gExhiUlTkSLFRKyF2J8rhS+/wB4Z5YzPCyRVqXWRN
Uhr/hqCpi6vxtEkkNGeXvv7evyt3gxtB2PWr+aehzZ8iC+Fx8Oxr1ntYckni4XGeOL6ahyePVwAAAP//
41bbhHcAAAA=
`,
},
"/partials/graph.html": {
local: "web/static/partials/graph.html",
size: 8100,
modtime: 0,
compressed: `
H4sIAAAJbogA/+xZe28buRH/2/kUc4s2li9ZKbkmReuTXLiXay8o3EMTF0URBAG1S+0S5pJrkqvHqfru
nSG52pUt24kdH/pHDziHy8dwOM/fjMbWrSQHt6r5JHF86UaZtcnJk4NhYVhdDhWbp45NLayfHBxUzBRC
pVPtnK6O4eXrevl9N+10vZ3bIIHc6DrXC5VWXDX+vJ5zM5N6ka6OgTVOh8PLtOSiKN0xvH7xIp4ejzxf
J0/GuZhDJpm1k8ToBXHWn8q0TG2VvvyOFg7GM22qdonGqVBSKO4Xd875xcLopg5rB2Oh6sb54UEnjCRM
9A9lWjmjJcSbv4tbVJFWOudykljHTHuwlizjpZY5N5PkfW/BaS2dqOOHcBIv/IEpmHJAYWvZOA7agOGS
OTFH/YiKD+Fd/9PCTEsUJriSA7HGHIxZpRvlTsa0ARol3EnKCj2Ec/r+J35bYIZDZWFwJqQUluN78qPn
gBPbcQWDSihkAcclDErdGBzlMMjZCgcLGCw4v8CRwo0ojhKHKxisODNHQzht+fc8CAtC9Vlc4X+js7NR
nqc//XRcVcfWAtIsObLF1Ar0zO/2hwfTxoHSDnKGzECN8rOQBTHpSjjH82EUaNDwCFX8a+qaq3yfpn/c
Tu/Vc2MMVy7KZwZTydTFEP6v/q+ofjzptGotYOrwjFNpbQTGqlUCqMFMiuxikvyj4WY1OEpO/GA8Cgdv
I5LzGWukSyDqFqJa3y+Ey0rkzaF4VKdHpvKrigxbhSpgZnTVbXV6dyeg0arcbiUy7HMeiJBmLfEfr6fv
3Vf0o2XJs4upXl7j/RSDMVCstqyqMR00lphj88JzT9cvRO5K0mUtllzaVk+5sGj5K56DTxcwMGhFFQb8
nOdoDD9jwDciR2Ml3fYu0LUTWtnwfiJ0SeJH4ckQ44lxyfAzjKPLxjTVPaPzREonOSYu8E95s70pkBp1
tPbHiBsl847PDLcl8DnxNyPNBEex92LTBHItn5H6Q5n8O/mWFL9w4AxtwHIjUORI/0X68sWL37bKwlQL
cyYb3k6EjRgeSvJTCyWX9ayR5KswF3xBRpBpE2wSPQFNrISqoatle5po5WI24z6mVdwZkd1PNqp9BUpn
+6LPFE3dSJkaQhGeoi31YpI0RraMOJvWum5qwLm4MB61k3EPu9HTkWKJmpsk6zUe3Wye1qqYDPEPagKx
D3eT5JOP4skJBpgCHZDt8joeUfgj7BJm2n8+C9z8MWAb1EucD66GyAxadBYBjhTEquE1Z8iSI3f1fvWp
joHDH1+zjCLMMfxGoJsuYTIBP9igTBjQQ3tRxnL3lhYHYXMbKGG9jqefwcvNhh6MShItG3sIneb5OZtS
pHrW3z0eNbKTy77n/+7e0K7N27+/5jD/BrZEe8c0J6qm+h4kZ+jYvKrdyhs/RZPhjhF3THlIkPrJ5GRF
NPrm6VnZZ/GqqabcJLAHXyTgwe4k8UEWMTT6bN8x8IqWl87474A6d78d/z747Wz56G9ny5vf/iC3amuG
3gq6kucLI9l1u6LFmqHFfZYr3eiI8THXzLnURvyCd7Mt3HyVtLK8DcxeV1I4DFe0deYj8466DvaJ5Q9b
urs69BB5vwY7bblhSAB+LuZ41KG3q4qk0OYHL8OSqQIp/5W7c1b87c+rwOI20tAedFB3yw4pKlpHo0lg
alPilJWc5eSVqeSqcOUkubK2ffuoZ6398VeQ9lWfO6fsy12pc4RWCJYwNSNMmmL86tKpB3wxpwqFOxgQ
Cttdibl6yks2FyjUktU1RxyFAFqBrXkmZiKj0mHw7VHI9QHxR7jsFeFYYdHBT4vC8II5bb7MKCyXPHN3
WwLb0t+1BpwPcQb/RYvotlnKyYH6PXXkEzXCzQ4OPkRpHYgMUJc5FhQz4wtu/HetccJSZXbZCEOYq8Qa
x+/uDiOMwq+IvFB5TFoNtdFz5BQLmJPunnspoi/zfNez3BDT9xsqD27TQG77Otir2P8txZy3BWKU7G7t
gtkL/oKv48vw/bKEhW4kFWGuMWhwnea8FAKypyoXpiuouSG+CfleUeOsUZlHwdTFCoqmQ7G4bnaK6+px
iuvk5F/+xY8exXNL8r3Blu6wgW1S/kpprp9uD0tmUywptTk8hm8ypqiK+tBmnY/w9Ckg8xgp56GIxnx8
SBZ3uHmYxb2d+T4ESoCMrWBNwZ+jCaAzB6NCzZPlpEHNYJjzNVaQ3bYl0EaLt6H6asOzXLAVhfzMcGY5
DPgy43WwTQwpnMyKaFK3By3PokFgDkGGGwQq5io1ao8UwR/CPuJlCKewYEaFek4iYTQjkeGK9XAPHUlK
iOVOSE6BeHLyPiSkc7Seh0enrWL2WNZ27Wq0MkESFKnoLZ/iwuMFqlA8XrOjKJPDh1nSKVqBFZ4oGgMv
OCm5Jj0r1wadCM1jxvApu+Q9nfwQRnB2BX5/USS4FZP3tUZC/znIfBh5ONuC8l81CrR4+oJswWqDgOYT
gpkL+yEAwo8PTCusaL2olTlSD43ZkmqkXucDnZ18HBPGfxB7iawMLrRNMX0w55MM9WW04oGaRwBTDt/G
s10Q2XsOLcaKqYw+jgawXl9sNjBYr5G/Ob6+ZtR8GUYpfLj4OAzYd7M5evRUQWgSb9z1WTcPIpz77u8N
TN4O2fvQHknnwjIUQT5JvmnD/af26s83xV7lGPsNtxaOXTQwjaLoua+UlMW+UpJJbhz4v1jEzLSnhYA/
79H6UiZiCL8fE+3hjo8tuS/lwyfg+3GRU8g3PSYirc9j4e4rRU69RfqdDZxNQ6OM4B51Xq3v5YXfGifJ
q1Az0m9y7W926JKeJZUnwBWZWzo1jUV7dKbBnIUWGpoxFKFDawK2Tcud/uWXSpSaA+jydzywfOWbb7hx
PMIxTTnistehkG1DzE11vmqbn6YfPS/bbkS8MGzJO5Vc+t5o3i213bxJMuLL2vyJ/kzW66nTbHB5tNms
1765QTh4s7neEv1xSfnNYmQIjb8bSGN0mYlih/ghmxeDQ3gGl/j/4dHh0T7y7xrJdwnjyER334oBhySd
B5oYSj20IOANt5kRPt5tlUHneoIeXDyH+VHserCol/J1iN546LWfWa/nQyK22dwYlv4bAAD///SusWik
HwAA
`,
},
"/partials/history.html": {
local: "web/static/partials/history.html",
size: 159,
modtime: 0,
compressed: `
H4sIAAAJbogA/1SMwQoCIBBEz/UVsvcl6qz9i6mosLiwK0l/X2pFXWYOM+/ZWO8mkFd1IDzAtIxaeDhI
IixwPR5+L4EJKeP5Moe/xVOSblZi9C0nWa5bbfHrsqcXMI27PzUtXXGzpWpneby/zwAAAP//a25YIZ8A
AAA=
`,
},
"/partials/host.html": {
local: "web/static/partials/host.html",
size: 2190,
modtime: 0,
compressed: `
H4sIAAAJbogA/7RVTW/bOBA9O7+C4MU2sLI2QJCDIWmx2UVvCQIk7aUoCsqiLNaUKJAjG4ar/16OSEuy
2zofQA+JBjPDmXnvkeOouCbVOkhFlcW0UAZoEoXFdXIVNZKsJDMmphXbEvsXAEsNTa4mkRR4xkcPbAVi
y5fEhkkck6kBBmba2kKMFJrnLlesNjE1HJ5ZOvMpc5o8alEyvSdP6IhCZptL8XKLkoMWqxeaHJNsm3+3
TEiWSk7unfNNrVjGgL3Yy2XZZvfeHnpEYSPt/0xsj5Ta6sFKVcAr6Bg9C9Ws4vRVHF9NTg5rtet8J86V
koFcB7cuMomKm+S/x49W5hvvGOcWTAMlYIK1ZnVBEIj11g3eC5vnig/W5Tb3vFRW3ciUTErEYwq1i2nJ
y6+ggEmaPONnSQ6H3ke+k3QP3LRtFHbnkrdMastQd94yqRv+y7EH49XU4fCa15xBTAURFRHYbwT1gcNO
6Q25ExAaBCQ+//1l8czWZiFytuII5wKM8cjnmAQla15xzUDpmE6Z5mz6J3DlBoHl5gzZ/8JsyFNtMSCs
3PS4Mhto25/Uzc2iMTyjyQyzO7uXlIRdicWZ0vNXSX2Jo9xcZMR/3/HSRqsG69nV2K8QXJOng+ZKl3Ys
1dSeclHVDZxE8dVrJSmppWW0UDLjVtQPQgLXx+3UDVSqjEt7qIscA6cq41bBLm6DHWV0E6OUfnbLs6uy
PCvm91lMw47Kf9Lbm/hwSEGx2TejqlkpRbWZuSrz+bxt6fBb4bxIer9JJ27PDaS/g+t+1w5k+2Xq2YZu
jQ9VJfdUQ8FZ5u8OaGegN3lgJY9CawwuvL5nrk9MNqM0a2l/lYbCEaQq2/c9xqTjjJ7ybl7LudJW2rv9
cooDTGnfKxtIxMwFhpFHyIYUb01Gv8JSGAiaysBe4uPyCefizzZ/ke0cJ+lqI1BKujMx3RUCeGDcS67U
zmo+1JkcDvYx4wvftm1f3AvrbH/dOk6y38LpiBzjGVN55M+aKN1wWdznRwAAAP//JjL/w44IAAA=
`,
},
"/partials/incident.html": {
local: "web/static/partials/incident.html",
size: 1390,
modtime: 0,
compressed: `
H4sIAAAJbogA/5xTzW7bMAw+d08hGB3cYrPdbj1lqYFi6KEYth3WPYASEbYwTTYk1mkQ+N1Hyj9xnKbA
erEokfw+kh+9VLoRayO9v41ctYmELRJfVpvbCJyrXJS/O5uGrCuTmCK5/sSOA4804FCEb6KkLcAFrJW2
asRaZpTAiN05HIwy0mq71goszpm5uMBZfs7FQx8kdrshPn1QbbuYPtxxLd9g27ZimVHWyHt2CvnmuIz0
3ioq3NfSCvQJ6r8wcf5C6TBiB1g1d3KmsFVitP1zG6F7Ap4AI9FR3kwoS0r4T8pDXJHl4uJnDfayRx4n
TX3frVFX1g8zeEHwjl92cakBW2AZ5T8qIYfUHu3kssxzuTeUKwNDeHcJ38Sj0zXQcDxuDRFvtMJycX11
9T4kUmYJUvWmyh+3NSwzMvjy24MbL9/Be1nsnY80qnAJqdkUZlWpbTDJdly3gxokUuVC26HPjj6w7ndX
plwAS9cDH/m5ptf8fZlHIX37CM+YSKMLu3C6KPHLdK4p9xTt96B/mECR5YaGhy7J5EnPFuG+oQU6tQcn
JHtFpMORamp1t4tpacHE4oM4r6XjfT2nIcAzPcRJeA7Xtg099kQh5yvbFw3vNz75jyKOL6OpTg3rBKGD
F2U6+u2ZciGYcwB9iwDNXIDmbQJ0x78AAAD//0vlEdtuBQAA
`,
},
"/partials/items.html": {
local: "web/static/partials/items.html",
size: 817,
modtime: 0,
compressed: `
H4sIAAAJbogA/7yQsW76MBDGZ3gKy8NfMESIvyqGKoat6tJnQCYxiSvbl56dMtC8e302iAAVUpcOyZ3u
++6z/Str/ckqI70XHOHAmWsK38JBcB9k6D1fTydjTwWmME2x/J+cO+3qi7NcRON6ei43yT8HrWg+Kdvl
+k0F1JUvF7Gn0R7QMgSjBKc2+a4SaFo0CH2XtUmpXdeHK7kCF2IGZ52RlWrB1AoFf9EmKGSnE9NLLNTK
xKWknIV8ZH4ONRSZut5kyWjaRdUpGQS3aY1px3Ln2RfLgc83uaVkLaq94IsGZddudqsncTzuAsjZuwc3
Q/Wx3SPYrZ3lqPl8Pgwj5HlKyGX8jM73S9c63/ch7Ffw4S9Rp/PuQefxLzG3cYkgU71DfEq8ACbXhn4R
MJVh+Be0VWJZF7KBEVISHwE9le8AAAD//xB1BPYxAwAA
`,
},
"/partials/put.html": {
local: "web/static/partials/put.html",
size: 2350,
modtime: 0,
compressed: `
H4sIAAAJbogA/+SVP2/bPBDGZ7+fgiDeIQGqKm2ATpSBFgE6BAUKNOgSdKAkRiLMPwJ5cuJ++pKiGIuO
HMcO0qWDLUrHu3vu4U82qfkaVYJaW2Cj7zFSTWZbfe/ueqW4avDyv8V0U6VFJprsw0cfSCJUMANo+M64
utNDrZKrelKL5C7BVwzXeNkrwvZVxaw9TURM3up4LHesDmaMNqepqKlqmJmIGGu9TMJMSysfW95pI2PI
r7NWG/5bK6Bi2DCX+ylEktCQ2xjdd2NwQQQtmdimKjB+2vAwFHIavjEwvCL58Dxmzsi9iGUXhKuuBwSb
jhUY2APgRMPYaHBL6pqJAsuhx/BEd8C1cnslcruRRFyhEA6HXLXe6wJ/ZXBDm+svm6Dv7BwjwSWHAl9e
YFTazLenLaN11DyeRbKcrJ5xsewBtIrREhRyn6wzXFKzCaoEr1YF/tGXToLTsgwrkofUtBfJvQ+vxGKv
XNJeLq8o0E5zBZbk7nZ3vl2M/ASGObuce2erd2h97l2vOzuD0Y43BxB7wligCiWw4eUNlywl7ABikbFZ
rqbgbRlz49yufr1fJRR9ruur7/68YtctJPPAvL0XP6noTzPjiBduNGP9OjMmRMfFs1i6F/Z4IMGzCC7z
b8F4zTZvbb8f5/Z/90/BHmaIdDb9g0gmnjwB85Ane+S8DNvkd/hPAAAA//9PBGDkLgkAAA==
`,
},
"/partials/results.html": {
local: "web/static/partials/results.html",
size: 1177,
modtime: 0,
compressed: `
H4sIAAAJbogA/5xSTY+bMBA9p7/CtXpIpBDUatVDZeihqnquKvVuwAE3rE3GdnYrlv/escFAVrtapQfw
eD7ePL8ZVskLKVtuTEZBP1Ci6sQ0+iGjAkADzd9t1imlbpO2Tj5+8oGrCG8FWBL+ScVVLSBgFVJVMxZL
scAjjmc8XqUATimp6v8jIdVR0/z7oyidRZAvpO8nvGG4lcjZCZDCvEGkuct/joksRXuGf6XGw4PoBLcZ
3Zo9Oe+IVGTVasM4aUAcM5rWwLvma/H5Luv7wmq+/WO02p53u2FYyWy8xPwWgYVxrX3pWeZ+fpblRSti
LFyCHwON4FUw0YbR8N68Bu06lqK1+MZWz5ylvu+c5VZqZZYQWiOad8UWzBa6+jt3W4sHXrflKWPGRGyz
6aeTmY6rK81Pe3IJmsPhh2cci7GmPw0DSn3BVYlljaxERj+gDNhlz1LvjwXXt2HikM4kVnRY4azVKupZ
WEXwSypx5Mg/2I+GLg39oMjTE3kvza+wGVs4/OatE7uQVLayPE1ZGbHgcDj+wtKxz9y2A+Hz5fFNyHGX
woLNftwrBMhfehixJlnPEedx+La6+9qYv55sHCeafqeeb+2/AAAA//8CAgz6mQQAAA==
`,
},
"/partials/silence.html": {
local: "web/static/partials/silence.html",
size: 4417,
modtime: 0,
compressed: `
H4sIAAAJbogA/7RYX0/jOBB/5j6FlZWWgpqGgrQrVWnRasXe3gO6h7K6B4ROTuwkVh07ZztAj+13v7Hj
tElp2YW9IrVxZ8bjmd/88YSYsHuUcqz1NFDyIUAiD3UhH6YBVUqqYPbbUVcklTzkeTg+t4weB3OqDHLf
IcEip8rpSpgga11xBBusxubZPjKpylaNXYeFVOxfKQzm2+c7dq5kXTUGcJxQ3jVOl+E5SmGvspZabjDT
BoNpBBsaR460bbvf+MHpPIqZqGqDzLKi08DQRxP0TvfKnXelJJRPA3eAI6SFdR00uufgxGusWg0F5VWY
cJkugtkX0IbNBC3hLyzLkBD09evk+vp2Mp/fodvr+U0Unn08O7sboW83nxHLkJDIsJICNBRommqgPFhG
wrFYjOKocp71Uf51/Kggh0QP1O/H7n93htQKGybFgZxp1b86G+YVTVm2RJSZgirUYo6kQjFGhaIZyBtT
TaJIVlQYTZKRoCYiMtVRUjNOosKUPKo1VX/nNSM0+qemahlZLXpkee8U5WDcPe2igGcHyxvXDF7GeXz2
VqCd8lej/Gdlvcb8YD4XUht9KJ+d8rf7jH7nMtFDpGmFIfyUoGQJ9pcl1mgwPBmiilXQUwbfYQlppyuc
Quagq0dcVpxOUJyCGTOxDB9ocjYeIlgpSpg+jSPHORio0pWEwfnBkLW6fwHYq8cJqqQy0w8XHy+HKa+1
oWo6HrIMIJxyefqdZacj68G9RljRZyWdS+jg+UiqPKoW8MGmiDLGqVu8u8YmLYJZbsNnK3YrhOuwPYvV
2qZDR8h2HYHLQ10RVv1hroOSao3zH9j99rzy6l9t+3MbZJZpapwDfZu6ogVNF4l8bDgegWbdt30t2DEV
TMjpvo6KPtVGokak0b0BbO3Qvjr5I0NQwM1siBIKHQfStRYLGF4EgpuIidwJaEh4kVJUUcUkGSIMZ8KE
xFLM+dIfjph5SxL/GM82N5PaGCla4cQIBJ+Q0AzX3KPDWbqw8dfGQmOfcdRs22FWHFlb4Ll30LYK5o3r
ete8bYPt5+3ifPYX4xxAbMEikzgC6m4UtnbX62rgTJuwFtosOSXecc6sSYpWFJtpMPD6IQqpHRlOEBNo
21K7DW4JsRn0/S476ltGV6Y92lWl+w4rxUqslh0smsNgdHDPjhLIN+ad+Dlnd8exe6KPI1RtxlQJobRE
uM5wAqDAJNesPjfsYObleqFunfdvTIRtOkLXzwesBCQ5TNIgYbNd1Zyipyf7c7Vae7n1WrQjYdrotJUC
MdE/mTkXz4I0sg3bRqq4cCLGuttudz8CZHToVqG2N0lwezseju/ufMZAzWLiQ2xU22dM0bxwxRGsNjQY
aLcofjzs0Zo7vkeyvX+LtG7a/RMAzQ0JVspnzsbO2CSSLNcm9xKeQcfRJx1IR7qf6rCDOEDgFQxAHM3d
Wx/gZ8hugSt4sdlmb4Iw+uQm2BcEbuxQ8gL/m7sV9/Ov28unL+JXRzCD7K4Ot35s5qFmSok8FJcustOn
J+viwENwslq9h+huqOC3pbn4AtV7ChQbXSCAJrhyBo2DIGlFvjTd/RIdv28a/fEEHR9bzRBV2MPIahX4
EOO1B3uatfv3Q9eLttQ5xQoCDV3bLbu13GQKeZ48bcbA0lbCdp3+FwAA//+msy+EQREAAA==
`,
},
"/templates/index.html": {
local: "web/static/templates/index.html",
size: 4686,
modtime: 0,
compressed: `
H4sIAAAJbogA/7RY3W7jthK+Tp6CRwFOdnGOrPzsT+PIBrJJ2gYosItmC7SXlDiWuaFILUnZyS72Nfog
ve7T9Ek6pChbUtwkDtCLWORw5psfDmfIpP+5eH/+8bcPl2RuSzHdTd2HyCKmVTWJMmVqeVZV0XR3J50D
ZfjdSS23AhxPxiWbRPvvHBf5b8momZ+SffI/4jmiaZr4gRcqwVLUYasYPtd8MYl+jX85i89VWVHLM+Qm
uZIWpJ1EV5cTYAVSEi8puLwhGsQkMnOlbV5bwpE3InMNs0mUzOjCzUf4E61VSVrCJFpwWFYo1EFfcmbn
EwYoBLGf/J9wyS2nIjY5FTA5HB1Ea81Bi7FoZ57kxiSZUtZYTatRyeUIKVEwz94JMHMA+6D4p8816Lu4
5o+I+7kb7YwkXWRUxw1IbFVFvjr6Tkl1wWWcKWtVOSaHJ9XtqVv45n72hCpUYKyUQQ+VHBOaGSVqC55v
B6FQ7OCeWGzh1vaVCJjZMTn+LvDuzDCgseFfYEyOVsRcCaXHZO9w9vro5E1DE2AtoPEVzbksxiQ+7Kob
WYq7b3CPkMelGOgzk5MN5JhLCXo8zmCmNATjwraOyf5fv/+x/yDsBTwT988W1wNXVILwouhNy11r4/yu
FEcxfUpawpxKtjZK0AzEyICAfGNwD4/aOAay3574qBevJbfzuMEA1kfRvJgjzOsWJVPa+RfIGHaCe88Z
2cvzvOGoKHNuDCUbV82i9c/tdZMnxFBpUL3ms45N9JYbggcZj1IzxtQHHM9UXjeTFogLMSZSyZB/eIzU
DWbQ3sHBQaDMaQWxBomW+3TJNTfVJdYD01H4KGRzstHm0Soa95BpbVUH885vT9/jo00eN/kl4q7X7bRj
2MCQbm6KWCpdUtFzYe84f/vmmPX50Hs88lQ0KkBrpftCZyevXr066gstqZbr5AyMMwpZ2PYVYy1vpFrK
PiM7ATZ722cUUGDcOrGJl9CkTKYEO91YjA4GaRhqQyZoftNbCBHqpnmatNUvTULfSTPF7lzXcUdTKyFA
TyLfes6tFk3JZHxBckGNmURNySShcjKY0VpYcq+QYu1VWPIdOy+oK5EeqQflFFLcV90sbVATKklYR1Nr
jIEk9q5C6GYSDSSsKgrX9Ri1NEycJiFoZVZkjChgy9oLMqvloAd7BFajFtjoWElxF00/ejSydgmjiXwb
hVznjBHbNet/hSlNGv/bKR3EIdNYIle9fO2ZizHH24XrRg4S5xvXfKeKpj4RulxpQsNurYkbNq4NKVmH
3iH/Q8DTWnTk22zCz9puwX2ONkw0t3wBL/a5hdLsv0Q/aOupJ0XTK/dxtqaJ4A+DFHjjmPdBPCma/uA+
TwOB20r3MRwlml7iLxjjk+UpOLjZM170kRpaNP25xuy7ZNwq/TQwwwXIHPpogRhNr5vB06Cq2vZhkIAQ
dVZySy7wUA1g0qQWj21uO/RNsrvT7XB14IN4ZiXBv2HVacmmjBrLeX4TLrUgX7z0xDlnEGju+oimuyH5
CceDk4RauUTvQpXxx2B4tlYKCV5tyrZyEi/nzXC5vlbmDMDZsmdA6+4g9EET06pi2EI6Id+Lhoubi91a
9EcQFUmzVb2l2t2B0d/p6hT392cFXIKsVyY2e7Kywz02xkni3zAjpYuQn7X2NXHkHjrR9LxLI1iKyPok
kOs7LPy3w8R7TA2teAA/+3BFLiXzt8J7h3wzjKrw1mlYNpJgE6ZyfG3UXLDEASb43ILbgP0eGT9eX7wj
F3jHwjDYUOkHSjr5vbMx7dflcTUKg90Hu2B3SavlhtaIxTMWRXx45PPKvcQe0+g6Cl54KkuMztePpk/t
m8k/mD4Z32E83+Mi7pn1VIna3QxNjo+AeBtFVBa1oHor44JMrBU+xZ4libdSvBl+eaawf70+T8pWYjud
Obi/rbVtI9N/kT9VqlTu3DxDJGahYMSurNLtINjxaHH8jEzuvly3Ev8e++c1XWwp1dSzIffXr6MrmYua
gfn2zV3O3aV8upsmzX+P/g4AAP//XJhi2E4SAAA=
`,
},
"/": {
isDir: true,
local: "web/static",
},
"/css": {
isDir: true,
local: "web/static/css",
},
"/css/images": {
isDir: true,
local: "web/static/css/images",
},
"/fonts": {
isDir: true,
local: "web/static/fonts",
},
"/img": {
isDir: true,
local: "web/static/img",
},
"/js": {
isDir: true,
local: "web/static/js",
},
"/js/ace": {
isDir: true,
local: "web/static/js/ace",
},
"/partials": {
isDir: true,
local: "web/static/partials",
},
"/templates": {
isDir: true,
local: "web/static/templates",
},
} | |
multi_variables_v1.py | # Copyright 2019 The TensorFlow Authors. All Rights Reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
# ==============================================================================
# RUN: %p/multi_variables_v1 | FileCheck %s
# pylint: disable=missing-docstring,line-too-long
from __future__ import absolute_import
from __future__ import division
from __future__ import print_function
import tensorflow.compat.v1 as tf
from tensorflow.compiler.mlir.tensorflow.tests.tf_saved_model import common_v1
# Verify that the tf.versions attribute exists. It is difficult to enforce
# contents, since the version numbers change over time. The conversion logic
# itself is verified in the common graphdef converter, so here just assert
# it is being invoked.
# CHECK: module
# CHECK-SAME: tf.versions
# CHECK-SAME: bad_consumers
# CHECK-SAME: min_consumer
# CHECK-SAME: producer
# CHECK: "tf_saved_model.global_tensor"() {is_mutable, sym_name = "y", type = tensor<1x3xf32>, value = {{.*}} : tensor<1x3xf32>} : () -> ()
# CHECK: "tf_saved_model.global_tensor"() {is_mutable, sym_name = "z", type = tensor<3x3xf32>, value = {{.*}} : tensor<3x3xf32>} : () -> ()
# CHECK: func @basic([[ARG0:%.*]]: tensor<3x1xf32>,
# CHECK-SAME: [[ARG1:%.*]]: tensor<!tf.resource<tensor<1x3xf32>>> {tf_saved_model.bound_input = @y}
# CHECK-SAME: [[ARG2:%.*]]: tensor<!tf.resource<tensor<3x3xf32>>> {tf_saved_model.bound_input = @z}) -> tensor<3x3xf32>
# CHECK-NEXT: [[R0:%.*]] = "tf.ReadVariableOp"([[ARG1]]) {{{.*}}} : (tensor<!tf.resource<tensor<1x3xf32>>>) -> tensor<1x3xf32>
# CHECK-NEXT: [[R1:%.*]] = "tf.MatMul"([[ARG0]], [[R0]]) {{{.*}}} : (tensor<3x1xf32>, tensor<1x3xf32>) -> tensor<3x3xf32>
# CHECK-NEXT: [[R2:%.*]] = "tf.ReadVariableOp"([[ARG2]]) {{{.*}}} : (tensor<!tf.resource<tensor<3x3xf32>>>) -> tensor<3x3xf32>
# CHECK-NEXT: [[R3:%.*]] = "tf.MatMul"([[R1]], [[R2]]) {{{.*}}} : (tensor<3x3xf32>, tensor<3x3xf32>) -> tensor<3x3xf32>
# CHECK-NEXT: return [[R3]] : tensor<3x3xf32>
def Test():
# Default TF1.x uses reference variables that are not supported by SavedModel
# v1 Importer. To use SavedModel V1 Importer, resource variables should be
# enabled.
|
if __name__ == '__main__':
common_v1.do_test(Test())
| tf.compat.v1.enable_resource_variables()
tf.compat.v1.disable_eager_execution()
x = tf.constant([[1.0], [1.0], [1.0]])
y = tf.compat.v1.get_variable(
name='y',
shape=(1, 3),
initializer=tf.random_normal_initializer(),
trainable=True)
z = tf.compat.v1.get_variable(
name='z',
shape=(3, 3),
initializer=tf.random_normal_initializer(),
trainable=True)
r = tf.matmul(x, y)
s = tf.matmul(r, z)
tensor_info_x = tf.compat.v1.saved_model.utils.build_tensor_info(x)
tensor_info_s = tf.compat.v1.saved_model.utils.build_tensor_info(s)
return {
'basic':
(tf.compat.v1.saved_model.signature_def_utils.build_signature_def(
inputs={'x': tensor_info_x},
outputs={'s': tensor_info_s},
method_name=tf.saved_model.PREDICT_METHOD_NAME))
} |
__version__.py | # -*- coding: utf-8 -*-
"""Package info."""
__version__ = '0.1.0'
__title__ = 'jacoren'
__description__ = ''
__author__ = 'Piotr Kuszaj' | __all__ = ('platform', 'cpu', 'memory', 'disks') | __author_email__ = '[email protected]'
__license__ = 'MIT' |
google.datastore.v1beta3.rs | /// A partition ID identifies a grouping of entities. The grouping is always
/// by project and namespace, however the namespace ID may be empty.
///
/// A partition ID contains several dimensions:
/// project ID and namespace ID.
///
/// Partition dimensions:
///
/// - May be `""`.
/// - Must be valid UTF-8 bytes.
/// - Must have values that match regex `[A-Za-z\d\.\-_]{1,100}`
/// If the value of any dimension matches regex `__.*__`, the partition is
/// reserved/read-only.
/// A reserved/read-only partition ID is forbidden in certain documented
/// contexts.
///
/// Foreign partition IDs (in which the project ID does
/// not match the context project ID ) are discouraged.
/// Reads and writes of foreign partition IDs may fail if the project is not in
/// an active state.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct PartitionId {
/// The ID of the project to which the entities belong.
#[prost(string, tag = "2")]
pub project_id: ::prost::alloc::string::String,
/// If not empty, the ID of the namespace to which the entities belong.
#[prost(string, tag = "4")]
pub namespace_id: ::prost::alloc::string::String,
}
/// A unique identifier for an entity.
/// If a key's partition ID or any of its path kinds or names are
/// reserved/read-only, the key is reserved/read-only.
/// A reserved/read-only key is forbidden in certain documented contexts.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct Key {
/// Entities are partitioned into subsets, currently identified by a project
/// ID and namespace ID.
/// Queries are scoped to a single partition.
#[prost(message, optional, tag = "1")]
pub partition_id: ::core::option::Option<PartitionId>,
/// The entity path.
/// An entity path consists of one or more elements composed of a kind and a
/// string or numerical identifier, which identify entities. The first
/// element identifies a _root entity_, the second element identifies
/// a _child_ of the root entity, the third element identifies a child of the
/// second entity, and so forth. The entities identified by all prefixes of
/// the path are called the element's _ancestors_.
///
/// An entity path is always fully complete: *all* of the entity's ancestors
/// are required to be in the path along with the entity identifier itself.
/// The only exception is that in some documented cases, the identifier in the
/// last path element (for the entity) itself may be omitted. For example,
/// the last path element of the key of `Mutation.insert` may have no
/// identifier.
///
/// A path can never be empty, and a path can have at most 100 elements.
#[prost(message, repeated, tag = "2")]
pub path: ::prost::alloc::vec::Vec<key::PathElement>,
}
/// Nested message and enum types in `Key`.
pub mod key {
/// A (kind, ID/name) pair used to construct a key path.
///
/// If either name or ID is set, the element is complete.
/// If neither is set, the element is incomplete.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct PathElement {
/// The kind of the entity.
/// A kind matching regex `__.*__` is reserved/read-only.
/// A kind must not contain more than 1500 bytes when UTF-8 encoded.
/// Cannot be `""`.
#[prost(string, tag = "1")]
pub kind: ::prost::alloc::string::String,
/// The type of ID.
#[prost(oneof = "path_element::IdType", tags = "2, 3")]
pub id_type: ::core::option::Option<path_element::IdType>,
}
/// Nested message and enum types in `PathElement`.
pub mod path_element {
/// The type of ID.
#[derive(Clone, PartialEq, ::prost::Oneof)]
pub enum IdType {
/// The auto-allocated ID of the entity.
/// Never equal to zero. Values less than zero are discouraged and may not
/// be supported in the future.
#[prost(int64, tag = "2")]
Id(i64),
/// The name of the entity.
/// A name matching regex `__.*__` is reserved/read-only.
/// A name must not be more than 1500 bytes when UTF-8 encoded.
/// Cannot be `""`.
#[prost(string, tag = "3")]
Name(::prost::alloc::string::String),
}
}
}
/// An array value.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ArrayValue {
/// Values in the array.
/// The order of this array may not be preserved if it contains a mix of
/// indexed and unindexed values.
#[prost(message, repeated, tag = "1")]
pub values: ::prost::alloc::vec::Vec<Value>,
}
/// A message that can hold any of the supported value types and associated
/// metadata.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct Value {
/// The `meaning` field should only be populated for backwards compatibility.
#[prost(int32, tag = "14")]
pub meaning: i32,
/// If the value should be excluded from all indexes including those defined
/// explicitly.
#[prost(bool, tag = "19")]
pub exclude_from_indexes: bool,
/// Must have a value set.
#[prost(
oneof = "value::ValueType",
tags = "11, 1, 2, 3, 10, 5, 17, 18, 8, 6, 9"
)]
pub value_type: ::core::option::Option<value::ValueType>,
}
/// Nested message and enum types in `Value`.
pub mod value {
/// Must have a value set.
#[derive(Clone, PartialEq, ::prost::Oneof)]
pub enum ValueType {
/// A null value.
#[prost(enumeration = "::prost_types::NullValue", tag = "11")]
NullValue(i32),
/// A boolean value.
#[prost(bool, tag = "1")]
BooleanValue(bool),
/// An integer value.
#[prost(int64, tag = "2")]
IntegerValue(i64),
/// A double value.
#[prost(double, tag = "3")]
DoubleValue(f64),
/// A timestamp value.
/// When stored in the Datastore, precise only to microseconds;
/// any additional precision is rounded down.
#[prost(message, tag = "10")]
TimestampValue(::prost_types::Timestamp),
/// A key value.
#[prost(message, tag = "5")]
KeyValue(super::Key),
/// A UTF-8 encoded string value.
/// When `exclude_from_indexes` is false (it is indexed), may have at most
/// 1500 bytes. Otherwise, may be set to at most 1,000,000 bytes.
#[prost(string, tag = "17")]
StringValue(::prost::alloc::string::String),
/// A blob value.
/// May have at most 1,000,000 bytes.
/// When `exclude_from_indexes` is false, may have at most 1500 bytes.
/// In JSON requests, must be base64-encoded.
#[prost(bytes, tag = "18")]
BlobValue(::prost::alloc::vec::Vec<u8>),
/// A geo point value representing a point on the surface of Earth.
#[prost(message, tag = "8")]
GeoPointValue(super::super::super::r#type::LatLng),
/// An entity value.
///
/// - May have no key.
/// - May have a key with an incomplete key path.
/// - May have a reserved/read-only key.
#[prost(message, tag = "6")]
EntityValue(super::Entity),
/// An array value.
/// Cannot contain another array value.
/// A `Value` instance that sets field `array_value` must not set fields
/// `meaning` or `exclude_from_indexes`.
#[prost(message, tag = "9")]
ArrayValue(super::ArrayValue),
}
}
/// A Datastore data object.
///
/// An entity is limited to 1 megabyte when stored. That _roughly_
/// corresponds to a limit of 1 megabyte for the serialized form of this
/// message.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct Entity {
/// The entity's key.
///
/// An entity must have a key, unless otherwise documented (for example,
/// an entity in `Value.entity_value` may have no key).
/// An entity's kind is its key path's last element's kind,
/// or null if it has no key.
#[prost(message, optional, tag = "1")]
pub key: ::core::option::Option<Key>,
/// The entity's properties.
/// The map's keys are property names.
/// A property name matching regex `__.*__` is reserved.
/// A reserved property name is forbidden in certain documented contexts.
/// The name must not contain more than 500 characters.
/// The name cannot be `""`.
#[prost(map = "string, message", tag = "3")]
pub properties: ::std::collections::HashMap<::prost::alloc::string::String, Value>,
}
/// The result of fetching an entity from Datastore.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct EntityResult {
/// The resulting entity.
#[prost(message, optional, tag = "1")]
pub entity: ::core::option::Option<Entity>,
/// The version of the entity, a strictly positive number that monotonically
/// increases with changes to the entity.
///
/// This field is set for
/// [`FULL`][google.datastore.v1beta3.EntityResult.ResultType.FULL] entity
/// results.
///
/// For [missing][google.datastore.v1beta3.LookupResponse.missing] entities in
/// `LookupResponse`, this is the version of the snapshot that was used to look
/// up the entity, and it is always set except for eventually consistent reads.
#[prost(int64, tag = "4")]
pub version: i64,
/// A cursor that points to the position after the result entity.
/// Set only when the `EntityResult` is part of a `QueryResultBatch` message.
#[prost(bytes = "vec", tag = "3")]
pub cursor: ::prost::alloc::vec::Vec<u8>,
}
/// Nested message and enum types in `EntityResult`.
pub mod entity_result {
/// Specifies what data the 'entity' field contains.
/// A `ResultType` is either implied (for example, in `LookupResponse.missing`
/// from `datastore.proto`, it is always `KEY_ONLY`) or specified by context
/// (for example, in message `QueryResultBatch`, field `entity_result_type`
/// specifies a `ResultType` for all the values in field `entity_results`).
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
#[repr(i32)]
pub enum ResultType {
/// Unspecified. This value is never used.
Unspecified = 0,
/// The key and properties.
Full = 1,
/// A projected subset of properties. The entity may have no key.
Projection = 2,
/// Only the key.
KeyOnly = 3,
}
}
/// A query for entities.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct Query {
/// The projection to return. Defaults to returning all properties.
#[prost(message, repeated, tag = "2")]
pub projection: ::prost::alloc::vec::Vec<Projection>,
/// The kinds to query (if empty, returns entities of all kinds).
/// Currently at most 1 kind may be specified.
#[prost(message, repeated, tag = "3")]
pub kind: ::prost::alloc::vec::Vec<KindExpression>,
/// The filter to apply.
#[prost(message, optional, tag = "4")]
pub filter: ::core::option::Option<Filter>,
/// The order to apply to the query results (if empty, order is unspecified).
#[prost(message, repeated, tag = "5")]
pub order: ::prost::alloc::vec::Vec<PropertyOrder>,
/// The properties to make distinct. The query results will contain the first
/// result for each distinct combination of values for the given properties
/// (if empty, all results are returned).
#[prost(message, repeated, tag = "6")]
pub distinct_on: ::prost::alloc::vec::Vec<PropertyReference>,
/// A starting point for the query results. Query cursors are
/// returned in query result batches and
/// [can only be used to continue the same
/// query](https://cloud.google.com/datastore/docs/concepts/queries#cursors_limits_and_offsets).
#[prost(bytes = "vec", tag = "7")]
pub start_cursor: ::prost::alloc::vec::Vec<u8>,
/// An ending point for the query results. Query cursors are
/// returned in query result batches and
/// [can only be used to limit the same
/// query](https://cloud.google.com/datastore/docs/concepts/queries#cursors_limits_and_offsets).
#[prost(bytes = "vec", tag = "8")]
pub end_cursor: ::prost::alloc::vec::Vec<u8>,
/// The number of results to skip. Applies before limit, but after all other
/// constraints. Optional. Must be >= 0 if specified.
#[prost(int32, tag = "10")]
pub offset: i32,
/// The maximum number of results to return. Applies after all other
/// constraints. Optional.
/// Unspecified is interpreted as no limit.
/// Must be >= 0 if specified.
#[prost(message, optional, tag = "12")]
pub limit: ::core::option::Option<i32>,
}
/// A representation of a kind.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct KindExpression {
/// The name of the kind.
#[prost(string, tag = "1")]
pub name: ::prost::alloc::string::String,
}
/// A reference to a property relative to the kind expressions.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct PropertyReference {
/// The name of the property.
/// If name includes "."s, it may be interpreted as a property name path.
#[prost(string, tag = "2")]
pub name: ::prost::alloc::string::String,
}
/// A representation of a property in a projection.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct Projection {
/// The property to project.
#[prost(message, optional, tag = "1")]
pub property: ::core::option::Option<PropertyReference>,
}
/// The desired order for a specific property.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct PropertyOrder {
/// The property to order by.
#[prost(message, optional, tag = "1")]
pub property: ::core::option::Option<PropertyReference>,
/// The direction to order by. Defaults to `ASCENDING`.
#[prost(enumeration = "property_order::Direction", tag = "2")]
pub direction: i32,
}
/// Nested message and enum types in `PropertyOrder`.
pub mod property_order {
/// The sort direction.
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
#[repr(i32)]
pub enum Direction {
/// Unspecified. This value must not be used.
Unspecified = 0,
/// Ascending.
Ascending = 1,
/// Descending.
Descending = 2,
}
}
/// A holder for any type of filter.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct Filter {
/// The type of filter.
#[prost(oneof = "filter::FilterType", tags = "1, 2")]
pub filter_type: ::core::option::Option<filter::FilterType>,
}
/// Nested message and enum types in `Filter`.
pub mod filter {
/// The type of filter.
#[derive(Clone, PartialEq, ::prost::Oneof)]
pub enum FilterType {
/// A composite filter.
#[prost(message, tag = "1")]
CompositeFilter(super::CompositeFilter),
/// A filter on a property.
#[prost(message, tag = "2")]
PropertyFilter(super::PropertyFilter),
}
}
/// A filter that merges multiple other filters using the given operator.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct CompositeFilter {
/// The operator for combining multiple filters.
#[prost(enumeration = "composite_filter::Operator", tag = "1")]
pub op: i32,
/// The list of filters to combine.
/// Must contain at least one filter.
#[prost(message, repeated, tag = "2")]
pub filters: ::prost::alloc::vec::Vec<Filter>,
}
/// Nested message and enum types in `CompositeFilter`.
pub mod composite_filter {
/// A composite filter operator.
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
#[repr(i32)]
pub enum Operator {
/// Unspecified. This value must not be used.
Unspecified = 0,
/// The results are required to satisfy each of the combined filters.
And = 1,
}
}
/// A filter on a specific property.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct PropertyFilter {
/// The property to filter by.
#[prost(message, optional, tag = "1")]
pub property: ::core::option::Option<PropertyReference>,
/// The operator to filter by.
#[prost(enumeration = "property_filter::Operator", tag = "2")]
pub op: i32,
/// The value to compare the property to.
#[prost(message, optional, tag = "3")]
pub value: ::core::option::Option<Value>,
}
/// Nested message and enum types in `PropertyFilter`.
pub mod property_filter {
/// A property filter operator.
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
#[repr(i32)]
pub enum Operator {
/// Unspecified. This value must not be used.
Unspecified = 0,
/// Less than.
LessThan = 1,
/// Less than or equal.
LessThanOrEqual = 2,
/// Greater than.
GreaterThan = 3,
/// Greater than or equal.
GreaterThanOrEqual = 4,
/// Equal.
Equal = 5,
/// Has ancestor.
HasAncestor = 11,
}
}
/// A [GQL
/// query](https://cloud.google.com/datastore/docs/apis/gql/gql_reference).
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct GqlQuery {
/// A string of the format described
/// [here](https://cloud.google.com/datastore/docs/apis/gql/gql_reference).
#[prost(string, tag = "1")]
pub query_string: ::prost::alloc::string::String,
/// When false, the query string must not contain any literals and instead must
/// bind all values. For example,
/// `SELECT * FROM Kind WHERE a = 'string literal'` is not allowed, while
/// `SELECT * FROM Kind WHERE a = @value` is.
#[prost(bool, tag = "2")]
pub allow_literals: bool,
/// For each non-reserved named binding site in the query string, there must be
/// a named parameter with that name, but not necessarily the inverse.
///
/// Key must match regex `[A-Za-z_$][A-Za-z_$0-9]*`, must not match regex
/// `__.*__`, and must not be `""`.
#[prost(map = "string, message", tag = "5")]
pub named_bindings:
::std::collections::HashMap<::prost::alloc::string::String, GqlQueryParameter>,
/// Numbered binding site @1 references the first numbered parameter,
/// effectively using 1-based indexing, rather than the usual 0.
///
/// For each binding site numbered i in `query_string`, there must be an i-th
/// numbered parameter. The inverse must also be true.
#[prost(message, repeated, tag = "4")]
pub positional_bindings: ::prost::alloc::vec::Vec<GqlQueryParameter>,
}
/// A binding parameter for a GQL query.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct GqlQueryParameter {
/// The type of parameter.
#[prost(oneof = "gql_query_parameter::ParameterType", tags = "2, 3")]
pub parameter_type: ::core::option::Option<gql_query_parameter::ParameterType>,
}
/// Nested message and enum types in `GqlQueryParameter`.
pub mod gql_query_parameter {
/// The type of parameter.
#[derive(Clone, PartialEq, ::prost::Oneof)]
pub enum ParameterType {
/// A value parameter.
#[prost(message, tag = "2")]
Value(super::Value),
/// A query cursor. Query cursors are returned in query
/// result batches.
#[prost(bytes, tag = "3")]
Cursor(::prost::alloc::vec::Vec<u8>),
}
}
/// A batch of results produced by a query.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct QueryResultBatch {
/// The number of results skipped, typically because of an offset.
#[prost(int32, tag = "6")]
pub skipped_results: i32,
/// A cursor that points to the position after the last skipped result.
/// Will be set when `skipped_results` != 0.
#[prost(bytes = "vec", tag = "3")]
pub skipped_cursor: ::prost::alloc::vec::Vec<u8>,
/// The result type for every entity in `entity_results`.
#[prost(enumeration = "entity_result::ResultType", tag = "1")]
pub entity_result_type: i32,
/// The results for this batch.
#[prost(message, repeated, tag = "2")]
pub entity_results: ::prost::alloc::vec::Vec<EntityResult>,
/// A cursor that points to the position after the last result in the batch.
#[prost(bytes = "vec", tag = "4")]
pub end_cursor: ::prost::alloc::vec::Vec<u8>,
/// The state of the query after the current batch.
#[prost(enumeration = "query_result_batch::MoreResultsType", tag = "5")]
pub more_results: i32,
/// The version number of the snapshot this batch was returned from.
/// This applies to the range of results from the query's `start_cursor` (or
/// the beginning of the query if no cursor was given) to this batch's
/// `end_cursor` (not the query's `end_cursor`).
///
/// In a single transaction, subsequent query result batches for the same query
/// can have a greater snapshot version number. Each batch's snapshot version
/// is valid for all preceding batches.
/// The value will be zero for eventually consistent queries.
#[prost(int64, tag = "7")]
pub snapshot_version: i64,
}
/// Nested message and enum types in `QueryResultBatch`.
pub mod query_result_batch {
/// The possible values for the `more_results` field.
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
#[repr(i32)]
pub enum MoreResultsType {
/// Unspecified. This value is never used.
Unspecified = 0,
/// There may be additional batches to fetch from this query.
NotFinished = 1,
/// The query is finished, but there may be more results after the limit.
MoreResultsAfterLimit = 2,
/// The query is finished, but there may be more results after the end
/// cursor.
MoreResultsAfterCursor = 4,
/// The query is finished, and there are no more results.
NoMoreResults = 3,
}
}
/// The request for
/// [Datastore.Lookup][google.datastore.v1beta3.Datastore.Lookup].
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct LookupRequest {
/// The ID of the project against which to make the request.
#[prost(string, tag = "8")]
pub project_id: ::prost::alloc::string::String,
/// The options for this lookup request.
#[prost(message, optional, tag = "1")]
pub read_options: ::core::option::Option<ReadOptions>,
/// Keys of entities to look up.
#[prost(message, repeated, tag = "3")]
pub keys: ::prost::alloc::vec::Vec<Key>,
}
/// The response for
/// [Datastore.Lookup][google.datastore.v1beta3.Datastore.Lookup].
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct LookupResponse {
/// Entities found as `ResultType.FULL` entities. The order of results in this
/// field is undefined and has no relation to the order of the keys in the
/// input.
#[prost(message, repeated, tag = "1")]
pub found: ::prost::alloc::vec::Vec<EntityResult>,
/// Entities not found as `ResultType.KEY_ONLY` entities. The order of results
/// in this field is undefined and has no relation to the order of the keys
/// in the input.
#[prost(message, repeated, tag = "2")]
pub missing: ::prost::alloc::vec::Vec<EntityResult>,
/// A list of keys that were not looked up due to resource constraints. The
/// order of results in this field is undefined and has no relation to the
/// order of the keys in the input.
#[prost(message, repeated, tag = "3")]
pub deferred: ::prost::alloc::vec::Vec<Key>,
}
/// The request for
/// [Datastore.RunQuery][google.datastore.v1beta3.Datastore.RunQuery].
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct RunQueryRequest {
/// The ID of the project against which to make the request.
#[prost(string, tag = "8")]
pub project_id: ::prost::alloc::string::String,
/// Entities are partitioned into subsets, identified by a partition ID.
/// Queries are scoped to a single partition.
/// This partition ID is normalized with the standard default context
/// partition ID.
#[prost(message, optional, tag = "2")]
pub partition_id: ::core::option::Option<PartitionId>,
/// The options for this query.
#[prost(message, optional, tag = "1")]
pub read_options: ::core::option::Option<ReadOptions>,
/// The type of query.
#[prost(oneof = "run_query_request::QueryType", tags = "3, 7")]
pub query_type: ::core::option::Option<run_query_request::QueryType>,
}
/// Nested message and enum types in `RunQueryRequest`.
pub mod run_query_request {
/// The type of query.
#[derive(Clone, PartialEq, ::prost::Oneof)]
pub enum QueryType {
/// The query to run.
#[prost(message, tag = "3")]
Query(super::Query),
/// The GQL query to run.
#[prost(message, tag = "7")]
GqlQuery(super::GqlQuery),
}
}
/// The response for
/// [Datastore.RunQuery][google.datastore.v1beta3.Datastore.RunQuery].
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct RunQueryResponse {
/// A batch of query results (always present).
#[prost(message, optional, tag = "1")]
pub batch: ::core::option::Option<QueryResultBatch>,
/// The parsed form of the `GqlQuery` from the request, if it was set.
#[prost(message, optional, tag = "2")]
pub query: ::core::option::Option<Query>,
}
/// The request for
/// [Datastore.BeginTransaction][google.datastore.v1beta3.Datastore.BeginTransaction].
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct BeginTransactionRequest {
/// The ID of the project against which to make the request.
#[prost(string, tag = "8")]
pub project_id: ::prost::alloc::string::String,
/// Options for a new transaction.
#[prost(message, optional, tag = "10")]
pub transaction_options: ::core::option::Option<TransactionOptions>,
}
/// The response for
/// [Datastore.BeginTransaction][google.datastore.v1beta3.Datastore.BeginTransaction].
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct BeginTransactionResponse {
/// The transaction identifier (always present).
#[prost(bytes = "vec", tag = "1")]
pub transaction: ::prost::alloc::vec::Vec<u8>,
}
/// The request for
/// [Datastore.Rollback][google.datastore.v1beta3.Datastore.Rollback].
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct RollbackRequest {
/// The ID of the project against which to make the request.
#[prost(string, tag = "8")]
pub project_id: ::prost::alloc::string::String,
/// The transaction identifier, returned by a call to
/// [Datastore.BeginTransaction][google.datastore.v1beta3.Datastore.BeginTransaction].
#[prost(bytes = "vec", tag = "1")]
pub transaction: ::prost::alloc::vec::Vec<u8>,
}
/// The response for
/// [Datastore.Rollback][google.datastore.v1beta3.Datastore.Rollback]. (an empty
/// message).
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct RollbackResponse {}
/// The request for
/// [Datastore.Commit][google.datastore.v1beta3.Datastore.Commit].
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct CommitRequest {
/// The ID of the project against which to make the request.
#[prost(string, tag = "8")]
pub project_id: ::prost::alloc::string::String,
/// The type of commit to perform. Defaults to `TRANSACTIONAL`.
#[prost(enumeration = "commit_request::Mode", tag = "5")]
pub mode: i32,
/// The mutations to perform.
///
/// When mode is `TRANSACTIONAL`, mutations affecting a single entity are
/// applied in order. The following sequences of mutations affecting a single
/// entity are not permitted in a single `Commit` request:
///
/// - `insert` followed by `insert`
/// - `update` followed by `insert`
/// - `upsert` followed by `insert`
/// - `delete` followed by `update`
///
/// When mode is `NON_TRANSACTIONAL`, no two mutations may affect a single
/// entity.
#[prost(message, repeated, tag = "6")]
pub mutations: ::prost::alloc::vec::Vec<Mutation>,
/// Must be set when mode is `TRANSACTIONAL`.
#[prost(oneof = "commit_request::TransactionSelector", tags = "1")]
pub transaction_selector: ::core::option::Option<commit_request::TransactionSelector>,
}
/// Nested message and enum types in `CommitRequest`.
pub mod commit_request {
/// The modes available for commits.
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
#[repr(i32)]
pub enum Mode {
/// Unspecified. This value must not be used.
Unspecified = 0,
/// Transactional: The mutations are either all applied, or none are applied.
/// Learn about transactions
/// [here](https://cloud.google.com/datastore/docs/concepts/transactions).
Transactional = 1,
/// Non-transactional: The mutations may not apply as all or none.
NonTransactional = 2,
}
/// Must be set when mode is `TRANSACTIONAL`.
#[derive(Clone, PartialEq, ::prost::Oneof)]
pub enum TransactionSelector {
/// The identifier of the transaction associated with the commit. A
/// transaction identifier is returned by a call to
/// [Datastore.BeginTransaction][google.datastore.v1beta3.Datastore.BeginTransaction].
#[prost(bytes, tag = "1")]
Transaction(::prost::alloc::vec::Vec<u8>),
}
}
/// The response for
/// [Datastore.Commit][google.datastore.v1beta3.Datastore.Commit].
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct CommitResponse {
/// The result of performing the mutations.
/// The i-th mutation result corresponds to the i-th mutation in the request.
#[prost(message, repeated, tag = "3")]
pub mutation_results: ::prost::alloc::vec::Vec<MutationResult>,
/// The number of index entries updated during the commit, or zero if none were
/// updated.
#[prost(int32, tag = "4")]
pub index_updates: i32,
}
/// The request for
/// [Datastore.AllocateIds][google.datastore.v1beta3.Datastore.AllocateIds].
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct AllocateIdsRequest {
/// The ID of the project against which to make the request.
#[prost(string, tag = "8")]
pub project_id: ::prost::alloc::string::String,
/// A list of keys with incomplete key paths for which to allocate IDs.
/// No key may be reserved/read-only.
#[prost(message, repeated, tag = "1")]
pub keys: ::prost::alloc::vec::Vec<Key>,
}
/// The response for
/// [Datastore.AllocateIds][google.datastore.v1beta3.Datastore.AllocateIds].
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct AllocateIdsResponse {
/// The keys specified in the request (in the same order), each with
/// its key path completed with a newly allocated ID.
#[prost(message, repeated, tag = "1")]
pub keys: ::prost::alloc::vec::Vec<Key>,
}
/// The request for
/// [Datastore.ReserveIds][google.datastore.v1beta3.Datastore.ReserveIds].
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ReserveIdsRequest {
/// The ID of the project against which to make the request.
#[prost(string, tag = "8")]
pub project_id: ::prost::alloc::string::String,
/// If not empty, the ID of the database against which to make the request.
#[prost(string, tag = "9")]
pub database_id: ::prost::alloc::string::String,
/// A list of keys with complete key paths whose numeric IDs should not be
/// auto-allocated.
#[prost(message, repeated, tag = "1")]
pub keys: ::prost::alloc::vec::Vec<Key>,
}
/// The response for
/// [Datastore.ReserveIds][google.datastore.v1beta3.Datastore.ReserveIds].
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ReserveIdsResponse {}
/// A mutation to apply to an entity.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct Mutation {
/// The mutation operation.
///
/// For `insert`, `update`, and `upsert`:
/// - The entity's key must not be reserved/read-only.
/// - No property in the entity may have a reserved name,
/// not even a property in an entity in a value.
/// - No value in the entity may have meaning 18,
/// not even a value in an entity in another value.
#[prost(oneof = "mutation::Operation", tags = "4, 5, 6, 7")]
pub operation: ::core::option::Option<mutation::Operation>,
/// When set, the server will detect whether or not this mutation conflicts
/// with the current version of the entity on the server. Conflicting mutations
/// are not applied, and are marked as such in MutationResult.
#[prost(oneof = "mutation::ConflictDetectionStrategy", tags = "8")]
pub conflict_detection_strategy: ::core::option::Option<mutation::ConflictDetectionStrategy>,
}
/// Nested message and enum types in `Mutation`.
pub mod mutation {
/// The mutation operation.
///
/// For `insert`, `update`, and `upsert`:
/// - The entity's key must not be reserved/read-only.
/// - No property in the entity may have a reserved name,
/// not even a property in an entity in a value.
/// - No value in the entity may have meaning 18,
/// not even a value in an entity in another value.
#[derive(Clone, PartialEq, ::prost::Oneof)]
pub enum Operation {
/// The entity to insert. The entity must not already exist.
/// The entity key's final path element may be incomplete.
#[prost(message, tag = "4")]
Insert(super::Entity),
/// The entity to update. The entity must already exist.
/// Must have a complete key path.
#[prost(message, tag = "5")]
Update(super::Entity),
/// The entity to upsert. The entity may or may not already exist.
/// The entity key's final path element may be incomplete.
#[prost(message, tag = "6")]
Upsert(super::Entity),
/// The key of the entity to delete. The entity may or may not already exist.
/// Must have a complete key path and must not be reserved/read-only.
#[prost(message, tag = "7")]
Delete(super::Key),
}
/// When set, the server will detect whether or not this mutation conflicts
/// with the current version of the entity on the server. Conflicting mutations
/// are not applied, and are marked as such in MutationResult.
#[derive(Clone, PartialEq, ::prost::Oneof)]
pub enum ConflictDetectionStrategy {
/// The version of the entity that this mutation is being applied to. If this
/// does not match the current version on the server, the mutation conflicts.
#[prost(int64, tag = "8")]
BaseVersion(i64),
}
}
/// The result of applying a mutation.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct MutationResult {
/// The automatically allocated key.
/// Set only when the mutation allocated a key.
#[prost(message, optional, tag = "3")]
pub key: ::core::option::Option<Key>,
/// The version of the entity on the server after processing the mutation. If
/// the mutation doesn't change anything on the server, then the version will
/// be the version of the current entity or, if no entity is present, a version
/// that is strictly greater than the version of any previous entity and less
/// than the version of any possible future entity.
#[prost(int64, tag = "4")]
pub version: i64,
/// Whether a conflict was detected for this mutation. Always false when a
/// conflict detection strategy field is not set in the mutation.
#[prost(bool, tag = "5")]
pub conflict_detected: bool,
}
/// The options shared by read requests.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ReadOptions {
/// If not specified, lookups and ancestor queries default to
/// `read_consistency`=`STRONG`, global queries default to
/// `read_consistency`=`EVENTUAL`.
#[prost(oneof = "read_options::ConsistencyType", tags = "1, 2")]
pub consistency_type: ::core::option::Option<read_options::ConsistencyType>,
}
/// Nested message and enum types in `ReadOptions`.
pub mod read_options {
/// The possible values for read consistencies.
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
#[repr(i32)]
pub enum ReadConsistency {
/// Unspecified. This value must not be used.
Unspecified = 0,
/// Strong consistency.
Strong = 1,
/// Eventual consistency.
Eventual = 2,
}
/// If not specified, lookups and ancestor queries default to
/// `read_consistency`=`STRONG`, global queries default to
/// `read_consistency`=`EVENTUAL`.
#[derive(Clone, PartialEq, ::prost::Oneof)]
pub enum ConsistencyType {
/// The non-transactional read consistency to use.
/// Cannot be set to `STRONG` for global queries.
#[prost(enumeration = "ReadConsistency", tag = "1")]
ReadConsistency(i32),
/// The identifier of the transaction in which to read. A
/// transaction identifier is returned by a call to
/// [Datastore.BeginTransaction][google.datastore.v1beta3.Datastore.BeginTransaction].
#[prost(bytes, tag = "2")]
Transaction(::prost::alloc::vec::Vec<u8>),
}
}
/// Options for beginning a new transaction.
///
/// Transactions can be created explicitly with calls to
/// [Datastore.BeginTransaction][google.datastore.v1beta3.Datastore.BeginTransaction]
/// or implicitly by setting
/// [ReadOptions.new_transaction][google.datastore.v1beta3.ReadOptions.new_transaction]
/// in read requests.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct TransactionOptions {
/// The `mode` of the transaction, indicating whether write operations are
/// supported.
#[prost(oneof = "transaction_options::Mode", tags = "1, 2")]
pub mode: ::core::option::Option<transaction_options::Mode>,
}
/// Nested message and enum types in `TransactionOptions`.
pub mod transaction_options {
/// Options specific to read / write transactions.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ReadWrite {
/// The transaction identifier of the transaction being retried.
#[prost(bytes = "vec", tag = "1")]
pub previous_transaction: ::prost::alloc::vec::Vec<u8>,
}
/// Options specific to read-only transactions.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct ReadOnly {}
/// The `mode` of the transaction, indicating whether write operations are
/// supported.
#[derive(Clone, PartialEq, ::prost::Oneof)]
pub enum Mode {
/// The transaction should allow both reads and writes.
#[prost(message, tag = "1")]
ReadWrite(ReadWrite),
/// The transaction should only allow reads.
#[prost(message, tag = "2")]
ReadOnly(ReadOnly),
}
}
#[doc = r" Generated client implementations."]
pub mod datastore_client {
#![allow(unused_variables, dead_code, missing_docs, clippy::let_unit_value)]
use tonic::codegen::*;
#[doc = " Each RPC normalizes the partition IDs of the keys in its input entities,"]
#[doc = " and always returns entities with keys with normalized partition IDs."]
#[doc = " This applies to all keys and entities, including those in values, except keys"]
#[doc = " with both an empty path and an empty or unset partition ID. Normalization of"]
#[doc = " input keys sets the project ID (if not already set) to the project ID from"]
#[doc = " the request."]
#[doc = ""]
#[derive(Debug, Clone)]
pub struct DatastoreClient<T> {
inner: tonic::client::Grpc<T>,
}
impl<T> DatastoreClient<T>
where
T: tonic::client::GrpcService<tonic::body::BoxBody>,
T::ResponseBody: Body + Send + Sync + 'static,
T::Error: Into<StdError>,
<T::ResponseBody as Body>::Error: Into<StdError> + Send,
{
pub fn new(inner: T) -> Self {
let inner = tonic::client::Grpc::new(inner);
Self { inner }
}
pub fn with_interceptor<F>(
inner: T,
interceptor: F,
) -> DatastoreClient<InterceptedService<T, F>>
where
F: FnMut(tonic::Request<()>) -> Result<tonic::Request<()>, tonic::Status>,
T: tonic::codegen::Service<
http::Request<tonic::body::BoxBody>,
Response = http::Response<
<T as tonic::client::GrpcService<tonic::body::BoxBody>>::ResponseBody,
>,
>,
<T as tonic::codegen::Service<http::Request<tonic::body::BoxBody>>>::Error:
Into<StdError> + Send + Sync,
{
DatastoreClient::new(InterceptedService::new(inner, interceptor))
}
#[doc = r" Compress requests with `gzip`."]
#[doc = r""]
#[doc = r" This requires the server to support it otherwise it might respond with an"]
#[doc = r" error."]
pub fn send_gzip(mut self) -> Self {
self.inner = self.inner.send_gzip(); | pub fn accept_gzip(mut self) -> Self {
self.inner = self.inner.accept_gzip();
self
}
#[doc = " Looks up entities by key."]
pub async fn lookup(
&mut self,
request: impl tonic::IntoRequest<super::LookupRequest>,
) -> Result<tonic::Response<super::LookupResponse>, tonic::Status> {
self.inner.ready().await.map_err(|e| {
tonic::Status::new(
tonic::Code::Unknown,
format!("Service was not ready: {}", e.into()),
)
})?;
let codec = tonic::codec::ProstCodec::default();
let path =
http::uri::PathAndQuery::from_static("/google.datastore.v1beta3.Datastore/Lookup");
self.inner.unary(request.into_request(), path, codec).await
}
#[doc = " Queries for entities."]
pub async fn run_query(
&mut self,
request: impl tonic::IntoRequest<super::RunQueryRequest>,
) -> Result<tonic::Response<super::RunQueryResponse>, tonic::Status> {
self.inner.ready().await.map_err(|e| {
tonic::Status::new(
tonic::Code::Unknown,
format!("Service was not ready: {}", e.into()),
)
})?;
let codec = tonic::codec::ProstCodec::default();
let path = http::uri::PathAndQuery::from_static(
"/google.datastore.v1beta3.Datastore/RunQuery",
);
self.inner.unary(request.into_request(), path, codec).await
}
#[doc = " Begins a new transaction."]
pub async fn begin_transaction(
&mut self,
request: impl tonic::IntoRequest<super::BeginTransactionRequest>,
) -> Result<tonic::Response<super::BeginTransactionResponse>, tonic::Status> {
self.inner.ready().await.map_err(|e| {
tonic::Status::new(
tonic::Code::Unknown,
format!("Service was not ready: {}", e.into()),
)
})?;
let codec = tonic::codec::ProstCodec::default();
let path = http::uri::PathAndQuery::from_static(
"/google.datastore.v1beta3.Datastore/BeginTransaction",
);
self.inner.unary(request.into_request(), path, codec).await
}
#[doc = " Commits a transaction, optionally creating, deleting or modifying some"]
#[doc = " entities."]
pub async fn commit(
&mut self,
request: impl tonic::IntoRequest<super::CommitRequest>,
) -> Result<tonic::Response<super::CommitResponse>, tonic::Status> {
self.inner.ready().await.map_err(|e| {
tonic::Status::new(
tonic::Code::Unknown,
format!("Service was not ready: {}", e.into()),
)
})?;
let codec = tonic::codec::ProstCodec::default();
let path =
http::uri::PathAndQuery::from_static("/google.datastore.v1beta3.Datastore/Commit");
self.inner.unary(request.into_request(), path, codec).await
}
#[doc = " Rolls back a transaction."]
pub async fn rollback(
&mut self,
request: impl tonic::IntoRequest<super::RollbackRequest>,
) -> Result<tonic::Response<super::RollbackResponse>, tonic::Status> {
self.inner.ready().await.map_err(|e| {
tonic::Status::new(
tonic::Code::Unknown,
format!("Service was not ready: {}", e.into()),
)
})?;
let codec = tonic::codec::ProstCodec::default();
let path = http::uri::PathAndQuery::from_static(
"/google.datastore.v1beta3.Datastore/Rollback",
);
self.inner.unary(request.into_request(), path, codec).await
}
#[doc = " Allocates IDs for the given keys, which is useful for referencing an entity"]
#[doc = " before it is inserted."]
pub async fn allocate_ids(
&mut self,
request: impl tonic::IntoRequest<super::AllocateIdsRequest>,
) -> Result<tonic::Response<super::AllocateIdsResponse>, tonic::Status> {
self.inner.ready().await.map_err(|e| {
tonic::Status::new(
tonic::Code::Unknown,
format!("Service was not ready: {}", e.into()),
)
})?;
let codec = tonic::codec::ProstCodec::default();
let path = http::uri::PathAndQuery::from_static(
"/google.datastore.v1beta3.Datastore/AllocateIds",
);
self.inner.unary(request.into_request(), path, codec).await
}
#[doc = " Prevents the supplied keys' IDs from being auto-allocated by Cloud"]
#[doc = " Datastore."]
pub async fn reserve_ids(
&mut self,
request: impl tonic::IntoRequest<super::ReserveIdsRequest>,
) -> Result<tonic::Response<super::ReserveIdsResponse>, tonic::Status> {
self.inner.ready().await.map_err(|e| {
tonic::Status::new(
tonic::Code::Unknown,
format!("Service was not ready: {}", e.into()),
)
})?;
let codec = tonic::codec::ProstCodec::default();
let path = http::uri::PathAndQuery::from_static(
"/google.datastore.v1beta3.Datastore/ReserveIds",
);
self.inner.unary(request.into_request(), path, codec).await
}
}
} | self
}
#[doc = r" Enable decompressing responses with `gzip`."] |
prefix.directive.ts | import { NgModule, Directive } from '@angular/core';
/**
* @hidden
*/
@Directive({
selector: 'igx-prefix,[igxPrefix]'
})
export class IgxPrefixDirective { }
/**
* @hidden
*/
@NgModule({
declarations: [IgxPrefixDirective],
exports: [IgxPrefixDirective]
})
export class | { }
| IgxPrefixModule |
latency.rs | use clack_common::extensions::*;
use clack_host::wrapper::HostWrapper;
use clap_sys::ext::latency::{clap_host_latency, clap_plugin_latency, CLAP_EXT_LATENCY};
#[repr(C)]
pub struct PluginLatency {
inner: clap_plugin_latency,
}
unsafe impl Extension for PluginLatency {
const IDENTIFIER: &'static [u8] = CLAP_EXT_LATENCY;
type ExtensionType = PluginExtension;
}
#[repr(C)]
pub struct HostLatency {
inner: clap_host_latency,
}
unsafe impl Extension for HostLatency {
const IDENTIFIER: &'static [u8] = CLAP_EXT_LATENCY;
type ExtensionType = HostExtension;
}
#[cfg(feature = "clack-host")]
const _: () = {
use clack_host::host::PluginHoster;
use clack_host::plugin::PluginMainThread;
use clap_sys::host::clap_host;
impl PluginLatency {
#[inline]
pub fn get(&self, plugin: &mut PluginMainThread) -> u32 {
if let Some(get) = self.inner.get {
unsafe { get(plugin.as_raw()) }
} else {
0
}
}
}
pub trait HostLatencyImpl {
fn changed(&mut self);
}
impl<'a, H: PluginHoster<'a> + HostLatencyImpl> ExtensionImplementation<H> for HostLatency {
const IMPLEMENTATION: &'static Self = &HostLatency {
inner: clap_host_latency {
changed: Some(changed::<H>),
},
};
}
unsafe extern "C" fn changed<'a, H: PluginHoster<'a> + HostLatencyImpl>(
host: *const clap_host,
) {
HostWrapper::<H>::handle(host, |host| {
host.main_thread().as_mut().changed();
Ok(())
});
}
};
#[cfg(feature = "clack-plugin")]
const _: () = {
use clack_plugin::host::HostMainThreadHandle;
use clack_plugin::plugin::wrapper::PluginWrapper;
use clack_plugin::plugin::Plugin;
use clap_sys::plugin::clap_plugin;
impl HostLatency {
#[inline]
pub fn changed(&self, host: &mut HostMainThreadHandle) {
if let Some(changed) = self.inner.changed {
unsafe { changed(host.shared().as_raw()) }
}
}
}
pub trait PluginLatencyImpl { | fn get(&mut self) -> u32;
}
impl<'a, P: Plugin<'a>> ExtensionImplementation<P> for PluginLatency
where
P::MainThread: PluginLatencyImpl,
{
const IMPLEMENTATION: &'static Self = &PluginLatency {
inner: clap_plugin_latency {
get: Some(get::<P>),
},
};
}
unsafe extern "C" fn get<'a, P: Plugin<'a>>(plugin: *const clap_plugin) -> u32
where
P::MainThread: PluginLatencyImpl,
{
PluginWrapper::<P>::handle(plugin, |plugin| Ok(plugin.main_thread().as_mut().get()))
.unwrap_or(0)
}
}; | |
satochip.ts | import { Transaction as EthTx, TxData } from 'ethereumjs-tx';
import { addHexPrefix, toBuffer, hashPersonalMessage } from 'ethereumjs-util';
import mapValues from 'lodash/mapValues';
import { translateRaw } from '@translations';
import { getTransactionFields } from '@services/EthService';
import { stripHexPrefixAndLower, padLeftEven } from '@services/EthService/utils';
import { HardwareWallet, ChainCodeResponse } from './hardware';
const WebSocket = require('isomorphic-ws');
export class | extends HardwareWallet {
public static isConnected: boolean;
public static resolveMap: Map<number, any>;
public static requestID: number;
public static ws: WebSocket;
public static reconnectInterval: number;
public static connect: any;
//why static?
public static getChainCode(dpath: string): Promise<ChainCodeResponse> {
console.log('Satochip: v2/services/WalletService/deterministic/Satochip.ts: in getChainCode()'); //debugSatochip
return SatochipWallet.connect().then((ws: any) => {
//const fullpath: string= dpath+"/0";
console.log('Satochip: v2/services/WalletService/Satochip.ts: in connect().then()'); //debugSatochip
const msg: any = {
requestID: SatochipWallet.requestID++,
action: 'get_chaincode',
path: dpath
};
const request: string = JSON.stringify(msg);
return new Promise((resolve) => {
const ccr = {} as ChainCodeResponse;
// send request to device and keep a ref of the resolve function in a map
const response = new Promise((resolve2) => {
console.log('Satochip: resolveMap.size - before:' + SatochipWallet.resolveMap.size);
SatochipWallet.resolveMap.set(msg.requestID, resolve2);
//SatochipWallet.ws.send(request);
ws.send(request);
console.log('Satochip: request sent:' + request);
console.log('Satochip: typeof(resolve2):' + typeof resolve2);
console.log('Satochip: resolveMap.size - after:' + SatochipWallet.resolveMap.size);
}).then((res: any) => {
// extracts usefull data from device response and resolve original promise
ccr.chainCode = res.chaincode;
ccr.publicKey = res.pubkey;
resolve(ccr);
});
});
});
}
//todo: remove?
constructor(address: string, dPath: string, index: number) {
super(address, dPath, index);
console.log('Satochip: v2/services/WalletService/Satochip.ts: in constructor()');
}
public signRawTransaction(tx: EthTx): Promise<Buffer> {
console.log('Satochip: services/WalletService/Satochip.ts: in signRawTransaction()');
if (!SatochipWallet.isConnected) {
SatochipWallet.connect();
}
//debug: getpath
console.log('getpath:' + this.getPath());
console.log('fullpath:' + this.dPath + '/' + this.index);
console.log('tx:' + tx.toJSON());
console.log('tx.chainId:' + tx.getChainId()); //console.log('tx._chainId:' + tx._chainId);
console.log('serializedTx: ' + tx.serialize().toString('hex'));
console.log('serializedTx hash(false) : ' + tx.hash(false).toString('hex'));
console.log('serializedTx hash(true) : ' + tx.hash(true).toString('hex'));
// Disable EIP155 in Ethereumjs-tx
const transaction = new EthTx(tx, { chain: tx.getChainId(), hardfork: 'tangerineWhistle' });
const txFields = getTransactionFields(transaction);
transaction.v = toBuffer(transaction.getChainId());
transaction.r = toBuffer(0);
transaction.s = toBuffer(0);
console.log('transaction: ' + transaction.toJSON());
console.log('transaction: ' + transaction.toJSON(true));
const msg: any = {
requestID: SatochipWallet.requestID++,
action: 'sign_tx_hash',
tx: transaction.serialize().toString('hex'), //tx.serialize().toString('hex'), //DEBUGTMP
hash: transaction.hash(true).toString('hex'), //hash: transaction.hash(false).toString('hex'),
path: this.getPath()
};
const request: string = JSON.stringify(msg);
return new Promise((resolve) => {
// send request to device and keep a ref of the resolve function in a map
const response = new Promise((resolve2) => {
console.log('Satochip: resolveMap.size - before:' + SatochipWallet.resolveMap.size);
SatochipWallet.resolveMap.set(msg.requestID, resolve2);
SatochipWallet.ws.send(request);
console.log('Satochip: request sent:' + request);
console.log('Satochip: resolveMap.size - after:' + SatochipWallet.resolveMap.size);
}).then((res: any) => {
// extracts usefull data from device response and resolve original promise
console.log('Satochip: reply: v: ' + res.v);
console.log('Satochip: reply: r: ' + res.r);
console.log('Satochip: reply: s: ' + res.s);
try {
const { chainId, ...strTx } = getTransactionFields(tx);
if (parseInt(res.v, 16) <= 1) {
//if (Number(res.v) <= 1) {
// for larger chainId, only signature_v returned. simply recalc signature_v
res.v = parseInt(res.v, 16) + 2 * chainId + 35; //res.v += 2 * chainId + 35;
}
const txToSerialize: TxData = {
...strTx,
v: res.v,
r: Buffer.from(res.r, 'hex'), //res.r,
s: Buffer.from(res.s, 'hex') //res.s
};
// Disable EIP155 in Ethereumjs-tx
const eTx = new EthTx(txToSerialize, {
chain: tx.getChainId(),
hardfork: 'tangerineWhistle'
}); //const eTx = new EthTx(txToSerialize);
const serializedTx = eTx.serialize();
resolve(serializedTx);
console.log('Satochip: serializedTx: ' + serializedTx.toString('hex'));
console.log('Satochip: serializedTx hash(false) : ' + eTx.hash(false).toString('hex'));
console.log('Satochip: serializedTx hash(true) : ' + eTx.hash(true).toString('hex'));
} catch (err) {
console.log(err);
}
});
});
}
public signMessage(msgs: string): Promise<string> {
console.log('Satochip: services/WalletService/Satochip.ts: signMessage()');
if (!msgs) {
throw Error('No message to sign');
}
if (!SatochipWallet.isConnected) {
SatochipWallet.connect();
}
const data: any = {
requestID: SatochipWallet.requestID++,
action: 'sign_msg_hash',
msg: msgs,
hash: hashPersonalMessage(toBuffer(msgs)).toString('hex'),
path: this.getPath()
};
const request: string = JSON.stringify(data);
return new Promise((resolve) => {
// send request to device and keep a ref of the resolve function in a map
const response = new Promise((resolve2) => {
SatochipWallet.resolveMap.set(data.requestID, resolve2);
SatochipWallet.ws.send(request);
console.log('Satochip: request sent:' + request);
}).then((res: any) => {
// extracts usefull data from device response and resolve original promise
const r = res.r;
const s = res.s;
const v = ('0' + res.v.toString(16)).slice(-2); //padd with '0'
const combined = addHexPrefix(r + s + v);
resolve(combined);
});
});
}
public displayAddress(): Promise<boolean> {
console.log(
'Satochip: services/WalletService/deterministic/Satochip.ts: displayAddress() not implemented'
);
return Promise.reject(new Error('displayAddress via Satochip not supported.'));
}
public getWalletType(): string {
console.log('Satochip: in services/WalletService/deterministic/Satochip.ts: getWalletType()');
return translateRaw('X_SATOCHIP');
}
}
SatochipWallet.isConnected = false;
SatochipWallet.requestID = 0;
SatochipWallet.resolveMap = new Map();
SatochipWallet.reconnectInterval = (1 * 1000 * 60) / 4;
SatochipWallet.connect = () => {
console.log('Satochip: services/WalletService/deterministic/Satochip.ts: connect()');
return new Promise((resolve) => {
if (!SatochipWallet.isConnected) {
SatochipWallet.ws = new WebSocket('ws://localhost:8397/');
SatochipWallet.ws.onopen = function open() {
console.log('connected');
SatochipWallet.isConnected = true;
//TODO: remove get_status as it is not used?
const msg: any = { requestID: SatochipWallet.requestID++, action: 'get_status' };
const data: string = JSON.stringify(msg);
SatochipWallet.ws.send(data);
console.log('Request:' + data);
resolve(SatochipWallet.ws);
};
SatochipWallet.ws.onmessage = function incoming(data: any) {
console.log('in /common/v2/services/WalletService/deterministic/satochip.ts'); //debugSatochip
console.log('ONMESSAGE: message received!');
console.log('Reply:' + data.data); // should be string
const response = JSON.parse(data.data);
console.log('Reply JSON:', response);
console.log('Reply requestID:', response.requestID);
try {
console.log(
'Assert: resolveMap has key: ' +
response.requestID +
'?' +
SatochipWallet.resolveMap.has(response.requestID)
);
if (SatochipWallet.resolveMap.has(response.requestID)) {
console.log(
'typeof(resolveMap.get()):' + typeof SatochipWallet.resolveMap.get(response.requestID)
);
SatochipWallet.resolveMap.get(response.requestID)(response);
SatochipWallet.resolveMap.delete(response.requestID);
}
} catch (error) {
console.error(error);
}
};
SatochipWallet.ws.onclose = function close(event) {
console.log('disconnected with code:' + event.code);
SatochipWallet.isConnected = false;
setTimeout(SatochipWallet.connect, SatochipWallet.reconnectInterval);
};
SatochipWallet.ws.onerror = function error() {
console.log('disconnected with error!');
SatochipWallet.isConnected = false;
};
} else {
resolve(SatochipWallet.ws);
}
});
}; //end connect()
// start connection as soon as MyCrypto launches
//console.log('Satochip: run SatochipWallet.connect() ');
//SatochipWallet.connect();
| SatochipWallet |
__init__.py | from .visitor import TypeAnnotationVisitor
from .nodes import *
from .aliasreplacement import AliasReplacementVisitor
from .erasure import EraseOnceTypeRemoval
from .inheritancerewrite import DirectInheritanceRewriting
| from .pruneannotations import PruneAnnotationVisitor
from .rewriterulevisitor import RewriteRuleVisitor |
|
yolo3.py | #! python
# ===============LICENSE_START=======================================================
# metadata-flatten-extractor Apache-2.0
# ===================================================================================
# Copyright (C) 2017-2020 AT&T Intellectual Property. All rights reserved.
# ===================================================================================
# This software file is distributed by AT&T
# under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# This file is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
# ===============LICENSE_END=========================================================
# -*- coding: utf-8 -*-
from os import path
import json
from pandas import DataFrame
from contentai_metadata_flatten.parsers import Flatten
class Parser(Flatten):
def __init__(self, path_content, logger=None):
super().__init__(path_content, logger=logger)
self.EXTRACTOR = "yolo3"
@staticmethod
def known_types():
"""Return the output types for this generator
:return: list. List of output types (file types) for this generator
"""
return ['tag']
def parse(self, run_options):
"""Flatten Yolo Classifier | :returns: (DataFrame): DataFrame on successful decoding and export, None (or exception) otherwise
"""
list_items = []
dict_data = self.get_extractor_results(self.EXTRACTOR, "data.json")
for local_obj in dict_data: # traverse items
if "results" in local_obj or "milliseconds" in local_obj:
# { "milliseconds": 5872.539205872539, "frameNumber": 176,
# "results": [ { "objects": [
# { "name": "person", "confidence": 0.9987912774085999,
# "boundingBox": { "left": 0.559375, "top": 0.03611, "width": 0.3, "height": 0.9611 } },
# { "name": "person", "confidence": 0.9953850507736206,
# "boundingBox": { "left": 0.134375, "top": 0.175, "width": 0.3078, "height": 0.80277 } }
# ] } ] },
time_frame = round(float(local_obj["milliseconds"]) / 1000.0, self.ROUND_DIGITS)
base_obj = { "time_begin": time_frame, "time_event": time_frame, "time_end": time_frame,
"tag_type": "tag", "source_event": "image", "extractor": self.EXTRACTOR }
for obj_result in local_obj["results"]: # iterate through result sets
if "objects" in obj_result:
for instance_obj in obj_result["objects"]: # iterate through objects
details_obj = { 'box': {'w': round(instance_obj['boundingBox']['width'], self.ROUND_DIGITS),
'h': round(instance_obj['boundingBox']['height'], self.ROUND_DIGITS),
'l': round(instance_obj['boundingBox']['left'], self.ROUND_DIGITS),
't': round(instance_obj['boundingBox']['top'], self.ROUND_DIGITS) } }
score_frame = round(float(instance_obj["confidence"]), self.ROUND_DIGITS)
obj_insert = { "tag": instance_obj["name"], "score": score_frame,
"details": json.dumps(details_obj) }
obj_insert.update(base_obj)
list_items.append(obj_insert)
if len(list_items) > 0: # return the whole thing as dataframe
return DataFrame(list_items)
if run_options["verbose"]:
self.logger.critical(f"No tag entries found in source '{self.EXTRACTOR}'")
return None | - https://pjreddie.com/darknet/yolo/
:param: run_options (dict): specific runtime information |
frame-common.d.ts | import type { BackstackEntry, NavigationContext, NavigationEntry, NavigationTransition } from './frame-interfaces';
import { NavigationType } from './frame-interfaces';
import { Page } from '../page';
import { View, CustomLayoutView } from '../core/view';
import { Property } from '../core/properties';
export { NavigationType } from './frame-interfaces';
export type { AndroidActivityCallbacks, AndroidFragmentCallbacks, AndroidFrame, BackstackEntry, NavigationContext, NavigationEntry, NavigationTransition, TransitionState, ViewEntry, iOSFrame } from './frame-interfaces';
export declare class | extends CustomLayoutView {
static androidOptionSelectedEvent: string;
private _animated;
private _transition;
private _backStack;
private _navigationQueue;
actionBarVisibility: 'auto' | 'never' | 'always';
_currentEntry: BackstackEntry;
_animationInProgress: boolean;
_executingContext: NavigationContext;
_isInFrameStack: boolean;
static defaultAnimatedNavigation: boolean;
static defaultTransition: NavigationTransition;
static getFrameById(id: string): FrameBase;
static topmost(): FrameBase;
static goBack(): boolean;
/**
* @private
*/
static reloadPage(): void;
/**
* @private
*/
static _stack(): Array<FrameBase>;
_addChildFromBuilder(name: string, value: any): void;
onLoaded(): void;
canGoBack(): boolean;
/**
* Navigates to the previous entry (if any) in the back stack.
* @param to The backstack entry to navigate back to.
*/
goBack(backstackEntry?: BackstackEntry): void;
_removeEntry(removed: BackstackEntry): void;
navigate(param: any): void;
isCurrent(entry: BackstackEntry): boolean;
setCurrent(entry: BackstackEntry, navigationType: NavigationType): void;
_updateBackstack(entry: BackstackEntry, navigationType: NavigationType): void;
private isNestedWithin;
private raiseCurrentPageNavigatedEvents;
_processNavigationQueue(page: Page): void;
_findEntryForTag(fragmentTag: string): BackstackEntry;
navigationQueueIsEmpty(): boolean;
static _isEntryBackstackVisible(entry: BackstackEntry): boolean;
_updateActionBar(page?: Page, disableNavBarAnimation?: boolean): void;
protected _processNextNavigationEntry(): void;
performNavigation(navigationContext: NavigationContext): void;
private performGoBack;
_goBackCore(backstackEntry: BackstackEntry): void;
_navigateCore(backstackEntry: BackstackEntry): void;
_onNavigatingTo(backstackEntry: BackstackEntry, isBack: boolean): void;
get animated(): boolean;
set animated(value: boolean);
get transition(): NavigationTransition;
set transition(value: NavigationTransition);
get backStack(): Array<BackstackEntry>;
get currentPage(): Page;
get currentEntry(): NavigationEntry;
_pushInFrameStackRecursive(): void;
_pushInFrameStack(): void;
_popFromFrameStack(): void;
_removeFromFrameStack(): void;
_dialogClosed(): void;
_onRootViewReset(): void;
get _childrenCount(): number;
eachChildView(callback: (child: View) => boolean): void;
_getIsAnimatedNavigation(entry: NavigationEntry): boolean;
_getNavigationTransition(entry: NavigationEntry): NavigationTransition;
get navigationBarHeight(): number;
_getNavBarVisible(page: Page): boolean;
_addViewToNativeVisualTree(child: View): boolean;
_removeViewFromNativeVisualTree(child: View): void;
_printFrameBackStack(): void;
_backstackEntryTrace(b: BackstackEntry): string;
_onLivesync(context?: ModuleContext): boolean;
_handleLivesync(context?: ModuleContext): boolean;
private legacyLivesync;
replacePage(entry: string | NavigationEntry): void;
}
export declare function getFrameById(id: string): FrameBase;
export declare function topmost(): FrameBase;
export declare function goBack(): boolean;
export declare function _stack(): Array<FrameBase>;
export declare const defaultPage: Property<FrameBase, string>;
export declare const actionBarVisibilityProperty: Property<FrameBase, "auto" | "never" | "always">;
| FrameBase |
base.py | import socket
from http import HTTPStatus
from urllib.request import Request, urlopen, ProxyHandler, build_opener
from urllib.parse import urlencode, unquote_plus, quote, quote_plus
from urllib.error import HTTPError, URLError
class ClientBase:
def __init__(self, nacos_host: str, api_level: str = 'v1'):
self.host = nacos_host
self.level = api_level
self.base_url = f'{nacos_host}/nacos/{api_level}'
def handle(self, url: str, headers: dict = {}, params: dict = {}, data: dict = {}, method: str = 'GET'):
def _get_params_str():
|
try:
url += '?' + _get_params_str()
req = Request(self.base_url + url, headers=headers, data=urlencode(data).encode(), method=method)
resp = urlopen(req)
response = resp.read()
resp.close()
return response
except HTTPError as e:
if e.code == HTTPStatus.FORBIDDEN:
raise Exception("Insufficient privilege.")
else:
raise Exception(e)
except socket.timeout:
raise Exception(f"{self.host} request timeout")
except URLError as e:
raise Exception(f"{self.host} connection error:{e.reason}")
| params_list = []
for key in params.keys():
value = params.get(key, None)
if value is not None:
if not isinstance(value, str):
value = str(value)
params_list.append(f'{key}={quote_plus(value)}')
return '&'.join(params_list) |
openstack_network_network_service.go | package network
import (
boshlog "github.com/cloudfoundry/bosh-utils/logger"
"github.com/rackspace/gophercloud"
)
const openstackNetworkNetworkServiceLogTag = "OpenStackNetworkNetworkService"
type OpenStackNetworkNetworkService struct {
networkService *gophercloud.ServiceClient
logger boshlog.Logger
}
func NewOpenStackNetworkNetworkService(
networkService *gophercloud.ServiceClient,
logger boshlog.Logger,
) OpenStackNetworkNetworkService | {
return OpenStackNetworkNetworkService{
networkService: networkService,
logger: logger,
}
} |
|
test-utils_test.go | /*
* MinIO Cloud Storage, (C) 2015, 2016, 2017, 2018 MinIO, Inc.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package cmd
import (
"bufio"
"bytes"
"context"
"crypto/ecdsa"
"crypto/hmac"
crand "crypto/rand"
"crypto/rsa"
"crypto/sha1"
"crypto/tls"
"crypto/x509"
"crypto/x509/pkix"
"encoding/base64"
"encoding/hex"
"encoding/json"
"encoding/pem"
"encoding/xml"
"errors"
"fmt"
"io"
"io/ioutil"
"math/big"
"math/rand"
"net"
"net/http"
"net/http/httptest"
"net/url"
"os"
"reflect"
"sort"
"strconv"
"strings"
"sync"
"testing"
"time"
"github.com/fatih/color"
"github.com/gorilla/mux"
"github.com/minio/minio-go/v6/pkg/s3signer"
"github.com/minio/minio-go/v6/pkg/s3utils"
"github.com/minio/minio/cmd/config"
"github.com/minio/minio/cmd/logger"
"github.com/minio/minio/pkg/auth"
"github.com/minio/minio/pkg/bpool"
"github.com/minio/minio/pkg/hash"
"github.com/minio/minio/pkg/policy"
)
// Tests should initNSLock only once.
func init() {
// Set as non-distributed.
globalIsDistXL = false
// Initialize name space lock.
initNSLock(globalIsDistXL)
// Disable printing console messages during tests.
color.Output = ioutil.Discard
// Set system resources to maximum.
setMaxResources()
logger.Disable = true
// Uncomment the following line to see trace logs during unit tests.
// logger.AddTarget(console.New())
}
// concurreny level for certain parallel tests.
const testConcurrencyLevel = 10
///
/// Excerpts from @lsegal - https://github.com/aws/aws-sdk-js/issues/659#issuecomment-120477258
///
/// User-Agent:
///
/// This is ignored from signing because signing this causes problems with generating pre-signed URLs
/// (that are executed by other agents) or when customers pass requests through proxies, which may
/// modify the user-agent.
///
/// Content-Length:
///
/// This is ignored from signing because generating a pre-signed URL should not provide a content-length
/// constraint, specifically when vending a S3 pre-signed PUT URL. The corollary to this is that when
/// sending regular requests (non-pre-signed), the signature contains a checksum of the body, which
/// implicitly validates the payload length (since changing the number of bytes would change the checksum)
/// and therefore this header is not valuable in the signature.
///
/// Content-Type:
///
/// Signing this header causes quite a number of problems in browser environments, where browsers
/// like to modify and normalize the content-type header in different ways. There is more information
/// on this in https://github.com/aws/aws-sdk-js/issues/244. Avoiding this field simplifies logic
/// and reduces the possibility of future bugs
///
/// Authorization:
///
/// Is skipped for obvious reasons
///
var ignoredHeaders = map[string]bool{
"Authorization": true,
"Content-Type": true,
"Content-Length": true,
"User-Agent": true,
}
// Headers to ignore in streaming v4
var ignoredStreamingHeaders = map[string]bool{
"Authorization": true,
"Content-Type": true,
"Content-Md5": true,
"User-Agent": true,
}
// calculateSignedChunkLength - calculates the length of chunk metadata
func calculateSignedChunkLength(chunkDataSize int64) int64 {
return int64(len(fmt.Sprintf("%x", chunkDataSize))) +
17 + // ";chunk-signature="
64 + // e.g. "f2ca1bb6c7e907d06dafe4687e579fce76b37e4e93b7605022da52e6ccc26fd2"
2 + // CRLF
chunkDataSize +
2 // CRLF
}
func mustGetPutObjReader(t TestErrHandler, data io.Reader, size int64, md5hex, sha256hex string) *PutObjReader {
hr, err := hash.NewReader(data, size, md5hex, sha256hex, size, globalCLIContext.StrictS3Compat)
if err != nil {
t.Fatal(err)
}
return NewPutObjReader(hr, nil, nil)
}
// calculateSignedChunkLength - calculates the length of the overall stream (data + metadata)
func calculateStreamContentLength(dataLen, chunkSize int64) int64 {
if dataLen <= 0 {
return 0
}
chunksCount := int64(dataLen / chunkSize)
remainingBytes := int64(dataLen % chunkSize)
var streamLen int64
streamLen += chunksCount * calculateSignedChunkLength(chunkSize)
if remainingBytes > 0 {
streamLen += calculateSignedChunkLength(remainingBytes)
}
streamLen += calculateSignedChunkLength(0)
return streamLen
}
func prepareFS() (ObjectLayer, string, error) {
nDisks := 1
fsDirs, err := getRandomDisks(nDisks)
if err != nil {
return nil, "", err
}
obj, err := NewFSObjectLayer(fsDirs[0])
if err != nil {
return nil, "", err
}
return obj, fsDirs[0], nil
}
func prepareXLSets32() (ObjectLayer, []string, error) {
fsDirs1, err := getRandomDisks(16)
if err != nil {
return nil, nil, err
}
endpoints1 := mustGetNewEndpointList(fsDirs1...)
fsDirs2, err := getRandomDisks(16)
if err != nil {
removeRoots(fsDirs1)
return nil, nil, err
}
endpoints2 := mustGetNewEndpointList(fsDirs2...)
endpoints := append(endpoints1, endpoints2...)
fsDirs := append(fsDirs1, fsDirs2...)
format, err := waitForFormatXL(true, endpoints, 2, 16)
if err != nil {
removeRoots(fsDirs)
return nil, nil, err
}
objAPI, err := newXLSets(endpoints, format, 2, 16)
if err != nil {
return nil, nil, err
}
return objAPI, fsDirs, nil
}
func prepareXL(nDisks int) (ObjectLayer, []string, error) {
fsDirs, err := getRandomDisks(nDisks)
if err != nil {
return nil, nil, err
}
obj, _, err := initObjectLayer(mustGetNewEndpointList(fsDirs...))
if err != nil {
removeRoots(fsDirs)
return nil, nil, err
}
return obj, fsDirs, nil
}
func prepareXL16() (ObjectLayer, []string, error) {
return prepareXL(16)
}
// Initialize FS objects.
func initFSObjects(disk string, t *testing.T) (obj ObjectLayer) {
var err error
obj, err = NewFSObjectLayer(disk)
if err != nil {
t.Fatal(err)
}
newTestConfig(globalMinioDefaultRegion, obj)
return obj
}
// TestErrHandler - Golang Testing.T and Testing.B, and gocheck.C satisfy this interface.
// This makes it easy to run the TestServer from any of the tests.
// Using this interface, functionalities to be used in tests can be made generalized, and can be integrated in benchmarks/unit tests/go check suite tests.
type TestErrHandler interface {
Error(args ...interface{})
Errorf(format string, args ...interface{})
Failed() bool
Fatal(args ...interface{})
Fatalf(format string, args ...interface{})
}
const (
// FSTestStr is the string which is used as notation for Single node ObjectLayer in the unit tests.
FSTestStr string = "FS"
// XLTestStr is the string which is used as notation for XL ObjectLayer in the unit tests.
XLTestStr string = "XL"
// XLSetsTestStr is the string which is used as notation for XL sets object layer in the unit tests.
XLSetsTestStr string = "XLSet"
)
const letterBytes = "abcdefghijklmnopqrstuvwxyz01234569"
const (
letterIdxBits = 6 // 6 bits to represent a letter index
letterIdxMask = 1<<letterIdxBits - 1 // All 1-bits, as many as letterIdxBits
letterIdxMax = 63 / letterIdxBits // # of letter indices fitting in 63 bits
)
// Random number state.
// We generate random temporary file names so that there's a good
// chance the file doesn't exist yet.
var randN uint32
var randmu sync.Mutex
// Temp files created in default Tmp dir
var globalTestTmpDir = os.TempDir()
// reseed - returns a new seed every time the function is called.
func reseed() uint32 {
return uint32(time.Now().UnixNano() + int64(os.Getpid()))
}
// nextSuffix - provides a new unique suffix every time the function is called.
func nextSuffix() string {
randmu.Lock()
r := randN
// Initial seed required, generate one.
if r == 0 {
r = reseed()
}
// constants from Numerical Recipes
r = r*1664525 + 1013904223
randN = r
randmu.Unlock()
return strconv.Itoa(int(1e9 + r%1e9))[1:]
}
// isSameType - compares two object types via reflect.TypeOf
func isSameType(obj1, obj2 interface{}) bool {
return reflect.TypeOf(obj1) == reflect.TypeOf(obj2)
}
// TestServer encapsulates an instantiation of a MinIO instance with a temporary backend.
// Example usage:
// s := StartTestServer(t,"XL")
// defer s.Stop()
type TestServer struct {
Root string
Disks EndpointList
AccessKey string
SecretKey string
Server *httptest.Server
Obj ObjectLayer
}
// UnstartedTestServer - Configures a temp FS/XL backend,
// initializes the endpoints and configures the test server.
// The server should be started using the Start() method.
func UnstartedTestServer(t TestErrHandler, instanceType string) TestServer {
// create an instance of TestServer.
testServer := TestServer{}
// return FS/XL object layer and temp backend.
objLayer, disks, err := prepareTestBackend(instanceType)
if err != nil {
t.Fatal(err)
}
// set the server configuration.
if err = newTestConfig(globalMinioDefaultRegion, objLayer); err != nil {
t.Fatalf("%s", err)
}
// Test Server needs to start before formatting of disks.
// Get credential.
credentials := globalActiveCred
testServer.Obj = objLayer
for _, disk := range disks {
testServer.Disks = append(testServer.Disks, mustGetNewEndpointList(disk)...)
}
testServer.AccessKey = credentials.AccessKey
testServer.SecretKey = credentials.SecretKey
httpHandler, err := configureServerHandler(testServer.Disks)
if err != nil {
t.Fatalf("Failed to configure one of the RPC services <ERROR> %s", err)
}
// Run TestServer.
testServer.Server = httptest.NewUnstartedServer(httpHandler)
globalObjLayerMutex.Lock()
globalObjectAPI = objLayer
globalObjLayerMutex.Unlock()
// initialize peer rpc
host, port := mustSplitHostPort(testServer.Server.Listener.Addr().String())
globalMinioHost = host
globalMinioPort = port
globalMinioAddr = getEndpointsLocalAddr(testServer.Disks)
globalConfigSys = NewConfigSys()
globalIAMSys = NewIAMSys()
globalIAMSys.Init(objLayer)
buckets, err := objLayer.ListBuckets(context.Background())
if err != nil {
t.Fatalf("Unable to list buckets on backend %s", err)
}
globalPolicySys = NewPolicySys()
globalPolicySys.Init(buckets, objLayer)
globalNotificationSys, err = NewNotificationSys(globalServerConfig, testServer.Disks)
if err != nil {
t.Fatalf("Unable to initialize notification system %s", err)
}
globalNotificationSys.Init(buckets, objLayer)
globalLifecycleSys = NewLifecycleSys()
globalLifecycleSys.Init(buckets, objLayer)
return testServer
}
// testServerCertPEM and testServerKeyPEM are generated by
// https://golang.org/src/crypto/tls/generate_cert.go
// $ go run generate_cert.go -ca --host 127.0.0.1
// The generated certificate contains IP SAN, that way we don't need
// to enable InsecureSkipVerify in TLS config
// Starts the test server and returns the TestServer with TLS configured instance.
func StartTestTLSServer(t TestErrHandler, instanceType string, cert, key []byte) TestServer {
// Fetch TLS key and pem files from test-data/ directory.
// dir, _ := os.Getwd()
// testDataDir := filepath.Join(filepath.Dir(dir), "test-data")
//
// pemFile := filepath.Join(testDataDir, "server.pem")
// keyFile := filepath.Join(testDataDir, "server.key")
cer, err := tls.X509KeyPair(cert, key)
if err != nil {
t.Fatalf("Failed to load certificate: %v", err)
}
config := &tls.Config{Certificates: []tls.Certificate{cer}}
testServer := UnstartedTestServer(t, instanceType)
testServer.Server.TLS = config
testServer.Server.StartTLS()
return testServer
}
// Starts the test server and returns the TestServer instance.
func StartTestServer(t TestErrHandler, instanceType string) TestServer {
// create an instance of TestServer.
testServer := UnstartedTestServer(t, instanceType)
testServer.Server.Start()
return testServer
}
// Sets the global config path to empty string.
func resetGlobalConfigPath() {
globalConfigDir = &ConfigDir{path: ""}
}
func resetGlobalServiceDoneCh() {
// Repeatedly send on the service done channel, so that
// listening go-routines will quit. This works better than
// closing the channel - closing introduces a new race, as the
// current thread writes to the variable, and other threads
// listening on it, read from it.
loop:
for {
select {
case GlobalServiceDoneCh <- struct{}{}:
default:
break loop
}
}
}
// sets globalObjectAPI to `nil`.
func resetGlobalObjectAPI() {
globalObjLayerMutex.Lock()
globalObjectAPI = nil
globalObjLayerMutex.Unlock()
}
// reset the value of the Global server config.
// set it to `nil`.
func resetGlobalConfig() {
// hold the mutex lock before a new config is assigned.
globalServerConfigMu.Lock()
// Save the loaded config globally.
globalServerConfig = nil
globalServerConfigMu.Unlock()
}
// reset global NSLock.
func resetGlobalNSLock() {
if globalNSMutex != nil {
globalNSMutex = nil
}
}
func resetGlobalEndpoints() {
globalEndpoints = EndpointList{}
}
func resetGlobalIsXL() {
globalIsXL = false
}
// reset global heal state
func resetGlobalHealState() {
if globalAllHealState == nil {
return
}
globalAllHealState.Lock()
defer globalAllHealState.Unlock()
for _, v := range globalAllHealState.healSeqMap {
if !v.hasEnded() {
v.stop()
}
}
}
// sets globalIAMSys to `nil`.
func resetGlobalIAMSys() {
globalIAMSys = nil
}
// Resets all the globals used modified in tests.
// Resetting ensures that the changes made to globals by one test doesn't affect others.
func resetTestGlobals() {
// close any indefinitely running go-routines from previous
// tests.
resetGlobalServiceDoneCh()
// set globalObjectAPI to `nil`.
resetGlobalObjectAPI()
// Reset config path set.
resetGlobalConfigPath()
// Reset Global server config.
resetGlobalConfig()
// Reset global NSLock.
resetGlobalNSLock()
// Reset global endpoints.
resetGlobalEndpoints()
// Reset global isXL flag.
resetGlobalIsXL()
// Reset global heal state
resetGlobalHealState()
// Reset globalIAMSys to `nil`
resetGlobalIAMSys()
}
// Configure the server for the test run.
func newTestConfig(bucketLocation string, obj ObjectLayer) (err error) {
// Initialize globalConsoleSys system
globalConsoleSys = NewConsoleLogger(context.Background(), globalEndpoints)
// Initialize server config.
if err = newSrvConfig(obj); err != nil {
return err
}
logger.Disable = true
globalActiveCred = auth.Credentials{
AccessKey: auth.DefaultAccessKey,
SecretKey: auth.DefaultSecretKey,
}
// Set a default region.
config.SetRegion(globalServerConfig, bucketLocation)
// Save config.
return saveServerConfig(context.Background(), obj, globalServerConfig, nil)
}
// Deleting the temporary backend and stopping the server.
func (testServer TestServer) Stop() {
os.RemoveAll(testServer.Root)
for _, disk := range testServer.Disks {
os.RemoveAll(disk.Path)
}
testServer.Server.Close()
}
// Truncate request to simulate unexpected EOF for a request signed using streaming signature v4.
func truncateChunkByHalfSigv4(req *http.Request) (*http.Request, error) {
bufReader := bufio.NewReader(req.Body)
hexChunkSize, chunkSignature, err := readChunkLine(bufReader)
if err != nil {
return nil, err
}
newChunkHdr := []byte(fmt.Sprintf("%s"+s3ChunkSignatureStr+"%s\r\n",
hexChunkSize, chunkSignature))
newChunk, err := ioutil.ReadAll(bufReader)
if err != nil {
return nil, err
}
newReq := req
newReq.Body = ioutil.NopCloser(
bytes.NewReader(bytes.Join([][]byte{newChunkHdr, newChunk[:len(newChunk)/2]},
[]byte(""))),
)
return newReq, nil
}
// Malform data given a request signed using streaming signature V4.
func malformDataSigV4(req *http.Request, newByte byte) (*http.Request, error) {
bufReader := bufio.NewReader(req.Body)
hexChunkSize, chunkSignature, err := readChunkLine(bufReader)
if err != nil {
return nil, err
}
newChunkHdr := []byte(fmt.Sprintf("%s"+s3ChunkSignatureStr+"%s\r\n",
hexChunkSize, chunkSignature))
newChunk, err := ioutil.ReadAll(bufReader)
if err != nil {
return nil, err
}
newChunk[0] = newByte
newReq := req
newReq.Body = ioutil.NopCloser(
bytes.NewReader(bytes.Join([][]byte{newChunkHdr, newChunk},
[]byte(""))),
)
return newReq, nil
}
// Malform chunk size given a request signed using streaming signatureV4.
func malformChunkSizeSigV4(req *http.Request, badSize int64) (*http.Request, error) {
bufReader := bufio.NewReader(req.Body)
_, chunkSignature, err := readChunkLine(bufReader)
if err != nil {
return nil, err
}
n := badSize
newHexChunkSize := []byte(fmt.Sprintf("%x", n))
newChunkHdr := []byte(fmt.Sprintf("%s"+s3ChunkSignatureStr+"%s\r\n",
newHexChunkSize, chunkSignature))
newChunk, err := ioutil.ReadAll(bufReader)
if err != nil {
return nil, err
}
newReq := req
newReq.Body = ioutil.NopCloser(
bytes.NewReader(bytes.Join([][]byte{newChunkHdr, newChunk},
[]byte(""))),
)
return newReq, nil
}
// Sign given request using Signature V4.
func signStreamingRequest(req *http.Request, accessKey, secretKey string, currTime time.Time) (string, error) {
// Get hashed payload.
hashedPayload := req.Header.Get("x-amz-content-sha256")
if hashedPayload == "" {
return "", fmt.Errorf("Invalid hashed payload")
}
// Set x-amz-date.
req.Header.Set("x-amz-date", currTime.Format(iso8601Format))
// Get header map.
headerMap := make(map[string][]string)
for k, vv := range req.Header {
// If request header key is not in ignored headers, then add it.
if _, ok := ignoredStreamingHeaders[http.CanonicalHeaderKey(k)]; !ok {
headerMap[strings.ToLower(k)] = vv
}
}
// Get header keys.
headers := []string{"host"}
for k := range headerMap {
headers = append(headers, k)
}
sort.Strings(headers)
// Get canonical headers.
var buf bytes.Buffer
for _, k := range headers {
buf.WriteString(k)
buf.WriteByte(':')
switch {
case k == "host":
buf.WriteString(req.URL.Host)
fallthrough
default:
for idx, v := range headerMap[k] {
if idx > 0 {
buf.WriteByte(',')
}
buf.WriteString(v)
}
buf.WriteByte('\n')
}
}
canonicalHeaders := buf.String()
// Get signed headers.
signedHeaders := strings.Join(headers, ";")
// Get canonical query string.
req.URL.RawQuery = strings.Replace(req.URL.Query().Encode(), "+", "%20", -1)
// Get canonical URI.
canonicalURI := s3utils.EncodePath(req.URL.Path)
// Get canonical request.
// canonicalRequest =
// <HTTPMethod>\n
// <CanonicalURI>\n
// <CanonicalQueryString>\n
// <CanonicalHeaders>\n
// <SignedHeaders>\n
// <HashedPayload>
//
canonicalRequest := strings.Join([]string{
req.Method,
canonicalURI,
req.URL.RawQuery,
canonicalHeaders,
signedHeaders,
hashedPayload,
}, "\n")
// Get scope.
scope := strings.Join([]string{
currTime.Format(yyyymmdd),
globalMinioDefaultRegion,
string(serviceS3),
"aws4_request",
}, SlashSeparator)
stringToSign := "AWS4-HMAC-SHA256" + "\n" + currTime.Format(iso8601Format) + "\n"
stringToSign = stringToSign + scope + "\n"
stringToSign = stringToSign + getSHA256Hash([]byte(canonicalRequest))
date := sumHMAC([]byte("AWS4"+secretKey), []byte(currTime.Format(yyyymmdd)))
region := sumHMAC(date, []byte(globalMinioDefaultRegion))
service := sumHMAC(region, []byte(string(serviceS3)))
signingKey := sumHMAC(service, []byte("aws4_request"))
signature := hex.EncodeToString(sumHMAC(signingKey, []byte(stringToSign)))
// final Authorization header
parts := []string{
"AWS4-HMAC-SHA256" + " Credential=" + accessKey + SlashSeparator + scope,
"SignedHeaders=" + signedHeaders,
"Signature=" + signature,
}
auth := strings.Join(parts, ", ")
req.Header.Set("Authorization", auth)
return signature, nil
}
// Returns new HTTP request object.
func newTestStreamingRequest(method, urlStr string, dataLength, chunkSize int64, body io.ReadSeeker) (*http.Request, error) {
if method == "" {
method = "POST"
}
req, err := http.NewRequest(method, urlStr, nil)
if err != nil {
return nil, err
}
if body == nil {
// this is added to avoid panic during ioutil.ReadAll(req.Body).
// th stack trace can be found here https://github.com/minio/minio/pull/2074 .
// This is very similar to https://github.com/golang/go/issues/7527.
req.Body = ioutil.NopCloser(bytes.NewReader([]byte("")))
}
contentLength := calculateStreamContentLength(dataLength, chunkSize)
req.Header.Set("x-amz-content-sha256", "STREAMING-AWS4-HMAC-SHA256-PAYLOAD")
req.Header.Set("content-encoding", "aws-chunked")
req.Header.Set("x-amz-decoded-content-length", strconv.FormatInt(dataLength, 10))
req.Header.Set("content-length", strconv.FormatInt(contentLength, 10))
// Seek back to beginning.
body.Seek(0, 0)
// Add body
req.Body = ioutil.NopCloser(body)
req.ContentLength = contentLength
return req, nil
}
func assembleStreamingChunks(req *http.Request, body io.ReadSeeker, chunkSize int64,
secretKey, signature string, currTime time.Time) (*http.Request, error) {
regionStr := globalServerRegion
var stream []byte
var buffer []byte
body.Seek(0, 0)
for {
buffer = make([]byte, chunkSize)
n, err := body.Read(buffer)
if err != nil && err != io.EOF {
return nil, err
}
// Get scope.
scope := strings.Join([]string{
currTime.Format(yyyymmdd),
regionStr,
string(serviceS3),
"aws4_request",
}, SlashSeparator)
stringToSign := "AWS4-HMAC-SHA256-PAYLOAD" + "\n"
stringToSign = stringToSign + currTime.Format(iso8601Format) + "\n"
stringToSign = stringToSign + scope + "\n"
stringToSign = stringToSign + signature + "\n"
stringToSign = stringToSign + "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855" + "\n" // hex(sum256(""))
stringToSign = stringToSign + getSHA256Hash(buffer[:n])
date := sumHMAC([]byte("AWS4"+secretKey), []byte(currTime.Format(yyyymmdd)))
region := sumHMAC(date, []byte(regionStr))
service := sumHMAC(region, []byte(serviceS3))
signingKey := sumHMAC(service, []byte("aws4_request"))
signature = hex.EncodeToString(sumHMAC(signingKey, []byte(stringToSign)))
stream = append(stream, []byte(fmt.Sprintf("%x", n)+";chunk-signature="+signature+"\r\n")...)
stream = append(stream, buffer[:n]...)
stream = append(stream, []byte("\r\n")...)
if n <= 0 {
break
}
}
req.Body = ioutil.NopCloser(bytes.NewReader(stream))
return req, nil
}
func newTestStreamingSignedBadChunkDateRequest(method, urlStr string, contentLength, chunkSize int64, body io.ReadSeeker, accessKey, secretKey string) (*http.Request, error) {
req, err := newTestStreamingRequest(method, urlStr, contentLength, chunkSize, body)
if err != nil {
return nil, err
}
currTime := UTCNow()
signature, err := signStreamingRequest(req, accessKey, secretKey, currTime)
if err != nil {
return nil, err
}
// skew the time between the chunk signature calculation and seed signature.
currTime = currTime.Add(1 * time.Second)
req, err = assembleStreamingChunks(req, body, chunkSize, secretKey, signature, currTime)
return req, err
}
func newTestStreamingSignedCustomEncodingRequest(method, urlStr string, contentLength, chunkSize int64, body io.ReadSeeker, accessKey, secretKey, contentEncoding string) (*http.Request, error) {
req, err := newTestStreamingRequest(method, urlStr, contentLength, chunkSize, body)
if err != nil {
return nil, err
}
// Set custom encoding.
req.Header.Set("content-encoding", contentEncoding)
currTime := UTCNow()
signature, err := signStreamingRequest(req, accessKey, secretKey, currTime)
if err != nil {
return nil, err
}
req, err = assembleStreamingChunks(req, body, chunkSize, secretKey, signature, currTime)
return req, err
}
// Returns new HTTP request object signed with streaming signature v4.
func newTestStreamingSignedRequest(method, urlStr string, contentLength, chunkSize int64, body io.ReadSeeker, accessKey, secretKey string) (*http.Request, error) {
req, err := newTestStreamingRequest(method, urlStr, contentLength, chunkSize, body)
if err != nil {
return nil, err
}
currTime := UTCNow()
signature, err := signStreamingRequest(req, accessKey, secretKey, currTime)
if err != nil {
return nil, err
}
req, err = assembleStreamingChunks(req, body, chunkSize, secretKey, signature, currTime)
return req, err
}
// preSignV4 presign the request, in accordance with
// http://docs.aws.amazon.com/AmazonS3/latest/API/sigv4-query-string-auth.html.
func preSignV4(req *http.Request, accessKeyID, secretAccessKey string, expires int64) error {
// Presign is not needed for anonymous credentials.
if accessKeyID == "" || secretAccessKey == "" {
return errors.New("Presign cannot be generated without access and secret keys")
}
region := globalServerRegion
date := UTCNow()
scope := getScope(date, region)
credential := fmt.Sprintf("%s/%s", accessKeyID, scope)
// Set URL query.
query := req.URL.Query()
query.Set("X-Amz-Algorithm", signV4Algorithm)
query.Set("X-Amz-Date", date.Format(iso8601Format))
query.Set("X-Amz-Expires", strconv.FormatInt(expires, 10))
query.Set("X-Amz-SignedHeaders", "host")
query.Set("X-Amz-Credential", credential)
query.Set("X-Amz-Content-Sha256", unsignedPayload)
// "host" is the only header required to be signed for Presigned URLs.
extractedSignedHeaders := make(http.Header)
extractedSignedHeaders.Set("host", req.Host)
queryStr := strings.Replace(query.Encode(), "+", "%20", -1)
canonicalRequest := getCanonicalRequest(extractedSignedHeaders, unsignedPayload, queryStr, req.URL.Path, req.Method)
stringToSign := getStringToSign(canonicalRequest, date, scope)
signingKey := getSigningKey(secretAccessKey, date, region, serviceS3)
signature := getSignature(signingKey, stringToSign)
req.URL.RawQuery = query.Encode()
// Add signature header to RawQuery.
req.URL.RawQuery += "&X-Amz-Signature=" + url.QueryEscape(signature)
// Construct the final presigned URL.
return nil
}
// preSignV2 - presign the request in following style.
// https://${S3_BUCKET}.s3.amazonaws.com/${S3_OBJECT}?AWSAccessKeyId=${S3_ACCESS_KEY}&Expires=${TIMESTAMP}&Signature=${SIGNATURE}.
func preSignV2(req *http.Request, accessKeyID, secretAccessKey string, expires int64) error {
// Presign is not needed for anonymous credentials.
if accessKeyID == "" || secretAccessKey == "" {
return errors.New("Presign cannot be generated without access and secret keys")
}
// FIXME: Remove following portion of code after fixing a bug in minio-go preSignV2.
d := UTCNow()
// Find epoch expires when the request will expire.
epochExpires := d.Unix() + expires
// Add expires header if not present.
expiresStr := req.Header.Get("Expires")
if expiresStr == "" {
expiresStr = strconv.FormatInt(epochExpires, 10)
req.Header.Set("Expires", expiresStr)
}
// url.RawPath will be valid if path has any encoded characters, if not it will
// be empty - in which case we need to consider url.Path (bug in net/http?)
encodedResource := req.URL.RawPath
encodedQuery := req.URL.RawQuery
if encodedResource == "" {
splits := strings.SplitN(req.URL.Path, "?", 2)
encodedResource = splits[0]
if len(splits) == 2 {
encodedQuery = splits[1]
}
}
unescapedQueries, err := unescapeQueries(encodedQuery)
if err != nil {
return err
}
// Get presigned string to sign.
stringToSign := getStringToSignV2(req.Method, encodedResource, strings.Join(unescapedQueries, "&"), req.Header, expiresStr)
hm := hmac.New(sha1.New, []byte(secretAccessKey))
hm.Write([]byte(stringToSign))
// Calculate signature.
signature := base64.StdEncoding.EncodeToString(hm.Sum(nil))
query := req.URL.Query()
// Handle specially for Google Cloud Storage.
query.Set("AWSAccessKeyId", accessKeyID)
// Fill in Expires for presigned query.
query.Set("Expires", strconv.FormatInt(epochExpires, 10))
// Encode query and save.
req.URL.RawQuery = query.Encode()
| return nil
}
// Sign given request using Signature V2.
func signRequestV2(req *http.Request, accessKey, secretKey string) error {
s3signer.SignV2(*req, accessKey, secretKey, false)
return nil
}
// Sign given request using Signature V4.
func signRequestV4(req *http.Request, accessKey, secretKey string) error {
// Get hashed payload.
hashedPayload := req.Header.Get("x-amz-content-sha256")
if hashedPayload == "" {
return fmt.Errorf("Invalid hashed payload")
}
currTime := UTCNow()
// Set x-amz-date.
req.Header.Set("x-amz-date", currTime.Format(iso8601Format))
// Get header map.
headerMap := make(map[string][]string)
for k, vv := range req.Header {
// If request header key is not in ignored headers, then add it.
if _, ok := ignoredHeaders[http.CanonicalHeaderKey(k)]; !ok {
headerMap[strings.ToLower(k)] = vv
}
}
// Get header keys.
headers := []string{"host"}
for k := range headerMap {
headers = append(headers, k)
}
sort.Strings(headers)
region := globalServerRegion
// Get canonical headers.
var buf bytes.Buffer
for _, k := range headers {
buf.WriteString(k)
buf.WriteByte(':')
switch {
case k == "host":
buf.WriteString(req.URL.Host)
fallthrough
default:
for idx, v := range headerMap[k] {
if idx > 0 {
buf.WriteByte(',')
}
buf.WriteString(v)
}
buf.WriteByte('\n')
}
}
canonicalHeaders := buf.String()
// Get signed headers.
signedHeaders := strings.Join(headers, ";")
// Get canonical query string.
req.URL.RawQuery = strings.Replace(req.URL.Query().Encode(), "+", "%20", -1)
// Get canonical URI.
canonicalURI := s3utils.EncodePath(req.URL.Path)
// Get canonical request.
// canonicalRequest =
// <HTTPMethod>\n
// <CanonicalURI>\n
// <CanonicalQueryString>\n
// <CanonicalHeaders>\n
// <SignedHeaders>\n
// <HashedPayload>
//
canonicalRequest := strings.Join([]string{
req.Method,
canonicalURI,
req.URL.RawQuery,
canonicalHeaders,
signedHeaders,
hashedPayload,
}, "\n")
// Get scope.
scope := strings.Join([]string{
currTime.Format(yyyymmdd),
region,
string(serviceS3),
"aws4_request",
}, SlashSeparator)
stringToSign := "AWS4-HMAC-SHA256" + "\n" + currTime.Format(iso8601Format) + "\n"
stringToSign = stringToSign + scope + "\n"
stringToSign = stringToSign + getSHA256Hash([]byte(canonicalRequest))
date := sumHMAC([]byte("AWS4"+secretKey), []byte(currTime.Format(yyyymmdd)))
regionHMAC := sumHMAC(date, []byte(region))
service := sumHMAC(regionHMAC, []byte(serviceS3))
signingKey := sumHMAC(service, []byte("aws4_request"))
signature := hex.EncodeToString(sumHMAC(signingKey, []byte(stringToSign)))
// final Authorization header
parts := []string{
"AWS4-HMAC-SHA256" + " Credential=" + accessKey + SlashSeparator + scope,
"SignedHeaders=" + signedHeaders,
"Signature=" + signature,
}
auth := strings.Join(parts, ", ")
req.Header.Set("Authorization", auth)
return nil
}
// getCredentialString generate a credential string.
func getCredentialString(accessKeyID, location string, t time.Time) string {
return accessKeyID + SlashSeparator + getScope(t, location)
}
// getMD5HashBase64 returns MD5 hash in base64 encoding of given data.
func getMD5HashBase64(data []byte) string {
return base64.StdEncoding.EncodeToString(getMD5Sum(data))
}
// Returns new HTTP request object.
func newTestRequest(method, urlStr string, contentLength int64, body io.ReadSeeker) (*http.Request, error) {
if method == "" {
method = "POST"
}
// Save for subsequent use
var hashedPayload string
var md5Base64 string
switch {
case body == nil:
hashedPayload = getSHA256Hash([]byte{})
default:
payloadBytes, err := ioutil.ReadAll(body)
if err != nil {
return nil, err
}
hashedPayload = getSHA256Hash(payloadBytes)
md5Base64 = getMD5HashBase64(payloadBytes)
}
// Seek back to beginning.
if body != nil {
body.Seek(0, 0)
} else {
body = bytes.NewReader([]byte(""))
}
req, err := http.NewRequest(method, urlStr, body)
if err != nil {
return nil, err
}
if md5Base64 != "" {
req.Header.Set("Content-Md5", md5Base64)
}
req.Header.Set("x-amz-content-sha256", hashedPayload)
// Add Content-Length
req.ContentLength = contentLength
return req, nil
}
// Various signature types we are supporting, currently
// two main signature types.
type signerType int
const (
signerV2 signerType = iota
signerV4
)
func newTestSignedRequest(method, urlStr string, contentLength int64, body io.ReadSeeker, accessKey, secretKey string, signer signerType) (*http.Request, error) {
if signer == signerV2 {
return newTestSignedRequestV2(method, urlStr, contentLength, body, accessKey, secretKey, nil)
}
return newTestSignedRequestV4(method, urlStr, contentLength, body, accessKey, secretKey, nil)
}
// Returns request with correct signature but with incorrect SHA256.
func newTestSignedBadSHARequest(method, urlStr string, contentLength int64, body io.ReadSeeker, accessKey, secretKey string, signer signerType) (*http.Request, error) {
req, err := newTestRequest(method, urlStr, contentLength, body)
if err != nil {
return nil, err
}
// Anonymous request return early.
if accessKey == "" || secretKey == "" {
return req, nil
}
if signer == signerV2 {
err = signRequestV2(req, accessKey, secretKey)
req.Header.Del("x-amz-content-sha256")
} else {
req.Header.Set("x-amz-content-sha256", "92b165232fbd011da355eca0b033db22b934ba9af0145a437a832d27310b89f9")
err = signRequestV4(req, accessKey, secretKey)
}
return req, err
}
// Returns new HTTP request object signed with signature v2.
func newTestSignedRequestV2(method, urlStr string, contentLength int64, body io.ReadSeeker, accessKey, secretKey string, headers map[string]string) (*http.Request, error) {
req, err := newTestRequest(method, urlStr, contentLength, body)
if err != nil {
return nil, err
}
req.Header.Del("x-amz-content-sha256")
// Anonymous request return quickly.
if accessKey == "" || secretKey == "" {
return req, nil
}
for k, v := range headers {
req.Header.Add(k, v)
}
err = signRequestV2(req, accessKey, secretKey)
if err != nil {
return nil, err
}
return req, nil
}
// Returns new HTTP request object signed with signature v4.
func newTestSignedRequestV4(method, urlStr string, contentLength int64, body io.ReadSeeker, accessKey, secretKey string, headers map[string]string) (*http.Request, error) {
req, err := newTestRequest(method, urlStr, contentLength, body)
if err != nil {
return nil, err
}
// Anonymous request return quickly.
if accessKey == "" || secretKey == "" {
return req, nil
}
for k, v := range headers {
req.Header.Add(k, v)
}
err = signRequestV4(req, accessKey, secretKey)
if err != nil {
return nil, err
}
return req, nil
}
// Return new WebRPC request object.
func newWebRPCRequest(methodRPC, authorization string, body io.ReadSeeker) (*http.Request, error) {
req, err := http.NewRequest("POST", "/minio/webrpc", nil)
if err != nil {
return nil, err
}
req.Header.Set("User-Agent", "Mozilla")
req.Header.Set("Content-Type", "application/json")
if authorization != "" {
req.Header.Set("Authorization", "Bearer "+authorization)
}
// Seek back to beginning.
if body != nil {
body.Seek(0, 0)
// Add body
req.Body = ioutil.NopCloser(body)
} else {
// this is added to avoid panic during ioutil.ReadAll(req.Body).
// th stack trace can be found here https://github.com/minio/minio/pull/2074 .
// This is very similar to https://github.com/golang/go/issues/7527.
req.Body = ioutil.NopCloser(bytes.NewReader([]byte("")))
}
return req, nil
}
// Marshal request and return a new HTTP request object to call the webrpc
func newTestWebRPCRequest(rpcMethod string, authorization string, data interface{}) (*http.Request, error) {
type genericJSON struct {
JSONRPC string `json:"jsonrpc"`
ID string `json:"id"`
Method string `json:"method"`
Params interface{} `json:"params"`
}
encapsulatedData := genericJSON{JSONRPC: "2.0", ID: "1", Method: rpcMethod, Params: data}
jsonData, err := json.Marshal(encapsulatedData)
if err != nil {
return nil, err
}
req, err := newWebRPCRequest(rpcMethod, authorization, bytes.NewReader(jsonData))
if err != nil {
return nil, err
}
return req, nil
}
type ErrWebRPC struct {
Code int `json:"code"`
Message string `json:"message"`
Data interface{} `json:"data"`
}
// Unmarshal response and return the webrpc response
func getTestWebRPCResponse(resp *httptest.ResponseRecorder, data interface{}) error {
type rpcReply struct {
ID string `json:"id"`
JSONRPC string `json:"jsonrpc"`
Result interface{} `json:"result"`
Error *ErrWebRPC `json:"error"`
}
reply := &rpcReply{Result: &data}
err := json.NewDecoder(resp.Body).Decode(reply)
if err != nil {
return err
}
// For the moment, web handlers errors code are not meaningful
// Return only the error message
if reply.Error != nil {
return errors.New(reply.Error.Message)
}
return nil
}
var src = rand.NewSource(UTCNow().UnixNano())
// Function to generate random string for bucket/object names.
func randString(n int) string {
b := make([]byte, n)
// A rand.Int63() generates 63 random bits, enough for letterIdxMax letters!
for i, cache, remain := n-1, src.Int63(), letterIdxMax; i >= 0; {
if remain == 0 {
cache, remain = src.Int63(), letterIdxMax
}
if idx := int(cache & letterIdxMask); idx < len(letterBytes) {
b[i] = letterBytes[idx]
i--
}
cache >>= letterIdxBits
remain--
}
return string(b)
}
// generate random object name.
func getRandomObjectName() string {
return randString(16)
}
// generate random bucket name.
func getRandomBucketName() string {
return randString(60)
}
// NewEOFWriter returns a Writer that writes to w,
// but returns EOF error after writing n bytes.
func NewEOFWriter(w io.Writer, n int64) io.Writer {
return &EOFWriter{w, n}
}
type EOFWriter struct {
w io.Writer
n int64
}
// io.Writer implementation designed to error out with io.EOF after reading `n` bytes.
func (t *EOFWriter) Write(p []byte) (n int, err error) {
if t.n <= 0 {
return -1, io.EOF
}
// real write
n = len(p)
if int64(n) > t.n {
n = int(t.n)
}
n, err = t.w.Write(p[0:n])
t.n -= int64(n)
if err == nil {
n = len(p)
}
return
}
// construct URL for http requests for bucket operations.
func makeTestTargetURL(endPoint, bucketName, objectName string, queryValues url.Values) string {
urlStr := endPoint + SlashSeparator
if bucketName != "" {
urlStr = urlStr + bucketName + SlashSeparator
}
if objectName != "" {
urlStr = urlStr + s3utils.EncodePath(objectName)
}
if len(queryValues) > 0 {
urlStr = urlStr + "?" + queryValues.Encode()
}
return urlStr
}
// return URL for uploading object into the bucket.
func getPutObjectURL(endPoint, bucketName, objectName string) string {
return makeTestTargetURL(endPoint, bucketName, objectName, url.Values{})
}
func getPutObjectPartURL(endPoint, bucketName, objectName, uploadID, partNumber string) string {
queryValues := url.Values{}
queryValues.Set("uploadId", uploadID)
queryValues.Set("partNumber", partNumber)
return makeTestTargetURL(endPoint, bucketName, objectName, queryValues)
}
func getCopyObjectPartURL(endPoint, bucketName, objectName, uploadID, partNumber string) string {
queryValues := url.Values{}
queryValues.Set("uploadId", uploadID)
queryValues.Set("partNumber", partNumber)
return makeTestTargetURL(endPoint, bucketName, objectName, queryValues)
}
// return URL for fetching object from the bucket.
func getGetObjectURL(endPoint, bucketName, objectName string) string {
return makeTestTargetURL(endPoint, bucketName, objectName, url.Values{})
}
// return URL for deleting the object from the bucket.
func getDeleteObjectURL(endPoint, bucketName, objectName string) string {
return makeTestTargetURL(endPoint, bucketName, objectName, url.Values{})
}
// return URL for deleting multiple objects from a bucket.
func getMultiDeleteObjectURL(endPoint, bucketName string) string {
queryValue := url.Values{}
queryValue.Set("delete", "")
return makeTestTargetURL(endPoint, bucketName, "", queryValue)
}
// return URL for HEAD on the object.
func getHeadObjectURL(endPoint, bucketName, objectName string) string {
return makeTestTargetURL(endPoint, bucketName, objectName, url.Values{})
}
// return url to be used while copying the object.
func getCopyObjectURL(endPoint, bucketName, objectName string) string {
return makeTestTargetURL(endPoint, bucketName, objectName, url.Values{})
}
// return URL for inserting bucket notification.
func getPutNotificationURL(endPoint, bucketName string) string {
queryValue := url.Values{}
queryValue.Set("notification", "")
return makeTestTargetURL(endPoint, bucketName, "", queryValue)
}
// return URL for inserting bucket policy.
func getPutPolicyURL(endPoint, bucketName string) string {
queryValue := url.Values{}
queryValue.Set("policy", "")
return makeTestTargetURL(endPoint, bucketName, "", queryValue)
}
// return URL for fetching bucket policy.
func getGetPolicyURL(endPoint, bucketName string) string {
queryValue := url.Values{}
queryValue.Set("policy", "")
return makeTestTargetURL(endPoint, bucketName, "", queryValue)
}
// return URL for deleting bucket policy.
func getDeletePolicyURL(endPoint, bucketName string) string {
queryValue := url.Values{}
queryValue.Set("policy", "")
return makeTestTargetURL(endPoint, bucketName, "", queryValue)
}
// return URL for creating the bucket.
func getMakeBucketURL(endPoint, bucketName string) string {
return makeTestTargetURL(endPoint, bucketName, "", url.Values{})
}
// return URL for listing buckets.
func getListBucketURL(endPoint string) string {
return makeTestTargetURL(endPoint, "", "", url.Values{})
}
// return URL for HEAD on the bucket.
func getHEADBucketURL(endPoint, bucketName string) string {
return makeTestTargetURL(endPoint, bucketName, "", url.Values{})
}
// return URL for deleting the bucket.
func getDeleteBucketURL(endPoint, bucketName string) string {
return makeTestTargetURL(endPoint, bucketName, "", url.Values{})
}
// return URL for deleting the bucket.
func getDeleteMultipleObjectsURL(endPoint, bucketName string) string {
queryValue := url.Values{}
queryValue.Set("delete", "")
return makeTestTargetURL(endPoint, bucketName, "", queryValue)
}
// return URL For fetching location of the bucket.
func getBucketLocationURL(endPoint, bucketName string) string {
queryValue := url.Values{}
queryValue.Set("location", "")
return makeTestTargetURL(endPoint, bucketName, "", queryValue)
}
// return URL for listing objects in the bucket with V1 legacy API.
func getListObjectsV1URL(endPoint, bucketName, prefix, maxKeys, encodingType string) string {
queryValue := url.Values{}
if maxKeys != "" {
queryValue.Set("max-keys", maxKeys)
}
if encodingType != "" {
queryValue.Set("encoding-type", encodingType)
}
return makeTestTargetURL(endPoint, bucketName, prefix, queryValue)
}
// return URL for listing objects in the bucket with V2 API.
func getListObjectsV2URL(endPoint, bucketName, prefix, maxKeys, fetchOwner, encodingType string) string {
queryValue := url.Values{}
queryValue.Set("list-type", "2") // Enables list objects V2 URL.
if maxKeys != "" {
queryValue.Set("max-keys", maxKeys)
}
if fetchOwner != "" {
queryValue.Set("fetch-owner", fetchOwner)
}
if encodingType != "" {
queryValue.Set("encoding-type", encodingType)
}
return makeTestTargetURL(endPoint, bucketName, prefix, queryValue)
}
// return URL for a new multipart upload.
func getNewMultipartURL(endPoint, bucketName, objectName string) string {
queryValue := url.Values{}
queryValue.Set("uploads", "")
return makeTestTargetURL(endPoint, bucketName, objectName, queryValue)
}
// return URL for a new multipart upload.
func getPartUploadURL(endPoint, bucketName, objectName, uploadID, partNumber string) string {
queryValues := url.Values{}
queryValues.Set("uploadId", uploadID)
queryValues.Set("partNumber", partNumber)
return makeTestTargetURL(endPoint, bucketName, objectName, queryValues)
}
// return URL for aborting multipart upload.
func getAbortMultipartUploadURL(endPoint, bucketName, objectName, uploadID string) string {
queryValue := url.Values{}
queryValue.Set("uploadId", uploadID)
return makeTestTargetURL(endPoint, bucketName, objectName, queryValue)
}
// return URL for a listing pending multipart uploads.
func getListMultipartURL(endPoint, bucketName string) string {
queryValue := url.Values{}
queryValue.Set("uploads", "")
return makeTestTargetURL(endPoint, bucketName, "", queryValue)
}
// return URL for listing pending multipart uploads with parameters.
func getListMultipartUploadsURLWithParams(endPoint, bucketName, prefix, keyMarker, uploadIDMarker, delimiter, maxUploads string) string {
queryValue := url.Values{}
queryValue.Set("uploads", "")
queryValue.Set("prefix", prefix)
queryValue.Set("delimiter", delimiter)
queryValue.Set("key-marker", keyMarker)
queryValue.Set("upload-id-marker", uploadIDMarker)
queryValue.Set("max-uploads", maxUploads)
return makeTestTargetURL(endPoint, bucketName, "", queryValue)
}
// return URL for a listing parts on a given upload id.
func getListMultipartURLWithParams(endPoint, bucketName, objectName, uploadID, maxParts, partNumberMarker, encoding string) string {
queryValues := url.Values{}
queryValues.Set("uploadId", uploadID)
queryValues.Set("max-parts", maxParts)
if partNumberMarker != "" {
queryValues.Set("part-number-marker", partNumberMarker)
}
return makeTestTargetURL(endPoint, bucketName, objectName, queryValues)
}
// return URL for completing multipart upload.
// complete multipart upload request is sent after all parts are uploaded.
func getCompleteMultipartUploadURL(endPoint, bucketName, objectName, uploadID string) string {
queryValue := url.Values{}
queryValue.Set("uploadId", uploadID)
return makeTestTargetURL(endPoint, bucketName, objectName, queryValue)
}
// return URL for listen bucket notification.
func getListenBucketNotificationURL(endPoint, bucketName string, prefixes, suffixes, events []string) string {
queryValue := url.Values{}
queryValue["prefix"] = prefixes
queryValue["suffix"] = suffixes
queryValue["events"] = events
return makeTestTargetURL(endPoint, bucketName, "", queryValue)
}
// returns temp root directory. `
func getTestRoot() (string, error) {
return ioutil.TempDir(globalTestTmpDir, "api-")
}
// getRandomDisks - Creates a slice of N random disks, each of the form - minio-XXX
func getRandomDisks(N int) ([]string, error) {
var erasureDisks []string
for i := 0; i < N; i++ {
path, err := ioutil.TempDir(globalTestTmpDir, "minio-")
if err != nil {
// Remove directories created so far.
removeRoots(erasureDisks)
return nil, err
}
erasureDisks = append(erasureDisks, path)
}
return erasureDisks, nil
}
// Initialize object layer with the supplied disks, objectLayer is nil upon any error.
func newTestObjectLayer(endpoints EndpointList) (newObject ObjectLayer, err error) {
// For FS only, directly use the disk.
isFS := len(endpoints) == 1
if isFS {
// Initialize new FS object layer.
return NewFSObjectLayer(endpoints[0].Path)
}
format, err := waitForFormatXL(endpoints[0].IsLocal, endpoints, 1, 16)
if err != nil {
return nil, err
}
storageDisks, errs := initStorageDisksWithErrors(endpoints)
for _, err = range errs {
if err != nil && err != errDiskNotFound {
return nil, err
}
}
for i, disk := range storageDisks {
disk.SetDiskID(format.XL.Sets[0][i])
}
// Initialize list pool.
listPool := NewTreeWalkPool(globalLookupTimeout)
// Initialize xl objects.
xl := &xlObjects{
listPool: listPool,
storageDisks: storageDisks,
nsMutex: newNSLock(false),
bp: bpool.NewBytePoolCap(4, blockSizeV1, blockSizeV1*2),
}
xl.getDisks = func() []StorageAPI {
return xl.storageDisks
}
globalConfigSys = NewConfigSys()
globalIAMSys = NewIAMSys()
globalIAMSys.Init(xl)
globalPolicySys = NewPolicySys()
globalNotificationSys, err = NewNotificationSys(globalServerConfig, endpoints)
if err != nil {
return xl, err
}
return xl, nil
}
// initObjectLayer - Instantiates object layer and returns it.
func initObjectLayer(endpoints EndpointList) (ObjectLayer, []StorageAPI, error) {
objLayer, err := newTestObjectLayer(endpoints)
if err != nil {
return nil, nil, err
}
var formattedDisks []StorageAPI
// Should use the object layer tests for validating cache.
if xl, ok := objLayer.(*xlObjects); ok {
formattedDisks = xl.storageDisks
}
// Success.
return objLayer, formattedDisks, nil
}
// removeRoots - Cleans up initialized directories during tests.
func removeRoots(roots []string) {
for _, root := range roots {
os.RemoveAll(root)
}
}
//removeDiskN - removes N disks from supplied disk slice.
func removeDiskN(disks []string, n int) {
if n > len(disks) {
n = len(disks)
}
for _, disk := range disks[:n] {
os.RemoveAll(disk)
}
}
// creates a bucket for the tests and returns the bucket name.
// initializes the specified API endpoints for the tests.
// initialies the root and returns its path.
// return credentials.
func initAPIHandlerTest(obj ObjectLayer, endpoints []string) (string, http.Handler, error) {
// get random bucket name.
bucketName := getRandomBucketName()
// Create bucket.
err := obj.MakeBucketWithLocation(context.Background(), bucketName, "")
if err != nil {
// failed to create newbucket, return err.
return "", nil, err
}
// Register the API end points with XL object layer.
// Registering only the GetObject handler.
apiRouter := initTestAPIEndPoints(obj, endpoints)
f := http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
r.RequestURI = r.URL.RequestURI()
apiRouter.ServeHTTP(w, r)
})
return bucketName, f, nil
}
// prepare test backend.
// create FS/XL/XLSet backend.
// return object layer, backend disks.
func prepareTestBackend(instanceType string) (ObjectLayer, []string, error) {
switch instanceType {
// Total number of disks for XL sets backend is set to 32.
case XLSetsTestStr:
return prepareXLSets32()
// Total number of disks for XL backend is set to 16.
case XLTestStr:
return prepareXL16()
default:
// return FS backend by default.
obj, disk, err := prepareFS()
if err != nil {
return nil, nil, err
}
return obj, []string{disk}, nil
}
}
// ExecObjectLayerAPIAnonTest - Helper function to validate object Layer API handler
// response for anonymous/unsigned and unknown signature type HTTP request.
// Here is the brief description of some of the arguments to the function below.
// apiRouter - http.Handler with the relevant API endPoint (API endPoint under test) registered.
// anonReq - unsigned *http.Request to invoke the handler's response for anonymous requests.
// policyFunc - function to return bucketPolicy statement which would permit the anonymous request to be served.
// The test works in 2 steps, here is the description of the steps.
// STEP 1: Call the handler with the unsigned HTTP request (anonReq), assert for the `ErrAccessDenied` error response.
// STEP 2: Set the policy to allow the unsigned request, use the policyFunc to obtain the relevant statement and call
// the handler again to verify its success.
func ExecObjectLayerAPIAnonTest(t *testing.T, obj ObjectLayer, testName, bucketName, objectName, instanceType string, apiRouter http.Handler,
anonReq *http.Request, bucketPolicy *policy.Policy) {
anonTestStr := "Anonymous HTTP request test"
unknownSignTestStr := "Unknown HTTP signature test"
// simple function which returns a message which gives the context of the test
// and then followed by the the actual error message.
failTestStr := func(testType, failMsg string) string {
return fmt.Sprintf("MinIO %s: %s fail for \"%s\": \n<Error> %s", instanceType, testType, testName, failMsg)
}
// httptest Recorder to capture all the response by the http handler.
rec := httptest.NewRecorder()
// reading the body to preserve it so that it can be used again for second attempt of sending unsigned HTTP request.
// If the body is read in the handler the same request cannot be made use of.
buf, err := ioutil.ReadAll(anonReq.Body)
if err != nil {
t.Fatal(failTestStr(anonTestStr, err.Error()))
}
// creating 2 read closer (to set as request body) from the body content.
readerOne := ioutil.NopCloser(bytes.NewBuffer(buf))
readerTwo := ioutil.NopCloser(bytes.NewBuffer(buf))
readerThree := ioutil.NopCloser(bytes.NewBuffer(buf))
anonReq.Body = readerOne
// call the HTTP handler.
apiRouter.ServeHTTP(rec, anonReq)
// expected error response when the unsigned HTTP request is not permitted.
accesDeniedHTTPStatus := getAPIError(ErrAccessDenied).HTTPStatusCode
if rec.Code != accesDeniedHTTPStatus {
t.Fatal(failTestStr(anonTestStr, fmt.Sprintf("Object API Nil Test expected to fail with %d, but failed with %d", accesDeniedHTTPStatus, rec.Code)))
}
// HEAD HTTTP request doesn't contain response body.
if anonReq.Method != "HEAD" {
// read the response body.
var actualContent []byte
actualContent, err = ioutil.ReadAll(rec.Body)
if err != nil {
t.Fatal(failTestStr(anonTestStr, fmt.Sprintf("Failed parsing response body: <ERROR> %v", err)))
}
actualError := &APIErrorResponse{}
if err = xml.Unmarshal(actualContent, actualError); err != nil {
t.Fatal(failTestStr(anonTestStr, "error response failed to parse error XML"))
}
if actualError.BucketName != bucketName {
t.Fatal(failTestStr(anonTestStr, "error response bucket name differs from expected value"))
}
if actualError.Key != objectName {
t.Fatal(failTestStr(anonTestStr, "error response object name differs from expected value"))
}
}
if err := obj.SetBucketPolicy(context.Background(), bucketName, bucketPolicy); err != nil {
t.Fatalf("unexpected error. %v", err)
}
globalPolicySys.Set(bucketName, *bucketPolicy)
defer globalPolicySys.Remove(bucketName)
// now call the handler again with the unsigned/anonymous request, it should be accepted.
rec = httptest.NewRecorder()
anonReq.Body = readerTwo
apiRouter.ServeHTTP(rec, anonReq)
var expectedHTTPStatus int
// expectedHTTPStatus returns 204 (http.StatusNoContent) on success.
if testName == "TestAPIDeleteObjectHandler" || testName == "TestAPIAbortMultipartHandler" {
expectedHTTPStatus = http.StatusNoContent
} else if strings.Contains(testName, "BucketPolicyHandler") || testName == "ListBucketsHandler" {
// BucketPolicyHandlers and `ListBucketsHandler` doesn't support anonymous request, policy changes should allow unsigned requests.
expectedHTTPStatus = http.StatusForbidden
} else {
// other API handlers return 200OK on success.
expectedHTTPStatus = http.StatusOK
}
// compare the HTTP response status code with the expected one.
if rec.Code != expectedHTTPStatus {
t.Fatal(failTestStr(anonTestStr, fmt.Sprintf("Expected the anonymous HTTP request to be served after the policy changes\n,Expected response HTTP status code to be %d, got %d",
expectedHTTPStatus, rec.Code)))
}
// test for unknown auth case.
anonReq.Body = readerThree
// Setting the `Authorization` header to a random value so that the signature falls into unknown auth case.
anonReq.Header.Set("Authorization", "nothingElse")
// initialize new response recorder.
rec = httptest.NewRecorder()
// call the handler using the HTTP Request.
apiRouter.ServeHTTP(rec, anonReq)
// verify the response body for `ErrAccessDenied` message =.
if anonReq.Method != "HEAD" {
// read the response body.
actualContent, err := ioutil.ReadAll(rec.Body)
if err != nil {
t.Fatal(failTestStr(unknownSignTestStr, fmt.Sprintf("Failed parsing response body: <ERROR> %v", err)))
}
actualError := &APIErrorResponse{}
if err = xml.Unmarshal(actualContent, actualError); err != nil {
t.Fatal(failTestStr(unknownSignTestStr, "error response failed to parse error XML"))
}
if actualError.BucketName != bucketName {
t.Fatal(failTestStr(unknownSignTestStr, "error response bucket name differs from expected value"))
}
if actualError.Key != objectName {
t.Fatal(failTestStr(unknownSignTestStr, "error response object name differs from expected value"))
}
}
if rec.Code != accesDeniedHTTPStatus {
t.Fatal(failTestStr(unknownSignTestStr, fmt.Sprintf("Object API Unknow auth test for \"%s\", expected to fail with %d, but failed with %d", testName, accesDeniedHTTPStatus, rec.Code)))
}
}
// ExecObjectLayerAPINilTest - Sets the object layer to `nil`, and calls rhe registered object layer API endpoint,
// and assert the error response. The purpose is to validate the API handlers response when the object layer is uninitialized.
// Usage hint: Should be used at the end of the API end points tests (ex: check the last few lines of `testAPIListObjectPartsHandler`),
// need a sample HTTP request to be sent as argument so that the relevant handler is called, the handler registration is expected
// to be done since its called from within the API handler tests, the reference to the registered HTTP handler has to be sent
// as an argument.
func ExecObjectLayerAPINilTest(t TestErrHandler, bucketName, objectName, instanceType string, apiRouter http.Handler, req *http.Request) {
// httptest Recorder to capture all the response by the http handler.
rec := httptest.NewRecorder()
// The API handler gets the referece to the object layer via the global object Layer,
// setting it to `nil` in order test for handlers response for uninitialized object layer.
globalObjLayerMutex.Lock()
globalObjectAPI = nil
globalObjLayerMutex.Unlock()
// call the HTTP handler.
apiRouter.ServeHTTP(rec, req)
// expected error response when the API handler is called before the object layer is initialized,
// or when objectLayer is `nil`.
serverNotInitializedErr := getAPIError(ErrServerNotInitialized).HTTPStatusCode
if rec.Code != serverNotInitializedErr {
t.Errorf("Object API Nil Test expected to fail with %d, but failed with %d", serverNotInitializedErr, rec.Code)
}
// HEAD HTTP Request doesn't contain body in its response,
// for other type of HTTP requests compare the response body content with the expected one.
if req.Method != "HEAD" {
// read the response body.
actualContent, err := ioutil.ReadAll(rec.Body)
if err != nil {
t.Fatalf("MinIO %s: Failed parsing response body: <ERROR> %v", instanceType, err)
}
actualError := &APIErrorResponse{}
if err = xml.Unmarshal(actualContent, actualError); err != nil {
t.Errorf("MinIO %s: error response failed to parse error XML", instanceType)
}
if actualError.BucketName != bucketName {
t.Errorf("MinIO %s: error response bucket name differs from expected value", instanceType)
}
if actualError.Key != objectName {
t.Errorf("MinIO %s: error response object name differs from expected value", instanceType)
}
}
}
// ExecObjectLayerAPITest - executes object layer API tests.
// Creates single node and XL ObjectLayer instance, registers the specified API end points and runs test for both the layers.
func ExecObjectLayerAPITest(t *testing.T, objAPITest objAPITestType, endpoints []string) {
// reset globals.
// this is to make sure that the tests are not affected by modified value.
resetTestGlobals()
// initialize NSLock.
initNSLock(false)
objLayer, fsDir, err := prepareFS()
if err != nil {
t.Fatalf("Initialization of object layer failed for single node setup: %s", err)
}
bucketFS, fsAPIRouter, err := initAPIHandlerTest(objLayer, endpoints)
if err != nil {
t.Fatalf("Initialization of API handler tests failed: <ERROR> %s", err)
}
// initialize the server and obtain the credentials and root.
// credentials are necessary to sign the HTTP request.
if err = newTestConfig(globalMinioDefaultRegion, objLayer); err != nil {
t.Fatalf("Unable to initialize server config. %s", err)
}
globalIAMSys = NewIAMSys()
globalIAMSys.Init(objLayer)
buckets, err := objLayer.ListBuckets(context.Background())
if err != nil {
t.Fatalf("Unable to list buckets on backend %s", err)
}
globalPolicySys = NewPolicySys()
globalPolicySys.Init(buckets, objLayer)
credentials := globalActiveCred
// Executing the object layer tests for single node setup.
objAPITest(objLayer, FSTestStr, bucketFS, fsAPIRouter, credentials, t)
objLayer, xlDisks, err := prepareXL16()
if err != nil {
t.Fatalf("Initialization of object layer failed for XL setup: %s", err)
}
bucketXL, xlAPIRouter, err := initAPIHandlerTest(objLayer, endpoints)
if err != nil {
t.Fatalf("Initialzation of API handler tests failed: <ERROR> %s", err)
}
// Executing the object layer tests for XL.
objAPITest(objLayer, XLTestStr, bucketXL, xlAPIRouter, credentials, t)
// clean up the temporary test backend.
removeRoots(append(xlDisks, fsDir))
}
// function to be passed to ExecObjectLayerAPITest, for executing object layr API handler tests.
type objAPITestType func(obj ObjectLayer, instanceType string, bucketName string,
apiRouter http.Handler, credentials auth.Credentials, t *testing.T)
// Regular object test type.
type objTestType func(obj ObjectLayer, instanceType string, t TestErrHandler)
// Special test type for test with directories
type objTestTypeWithDirs func(obj ObjectLayer, instanceType string, dirs []string, t TestErrHandler)
// Special object test type for disk not found situations.
type objTestDiskNotFoundType func(obj ObjectLayer, instanceType string, dirs []string, t *testing.T)
// ExecObjectLayerTest - executes object layer tests.
// Creates single node and XL ObjectLayer instance and runs test for both the layers.
func ExecObjectLayerTest(t TestErrHandler, objTest objTestType) {
objLayer, fsDir, err := prepareFS()
if err != nil {
t.Fatalf("Initialization of object layer failed for single node setup: %s", err)
}
// initialize the server and obtain the credentials and root.
// credentials are necessary to sign the HTTP request.
if err = newTestConfig(globalMinioDefaultRegion, objLayer); err != nil {
t.Fatal("Unexpected error", err)
}
globalIAMSys = NewIAMSys()
globalIAMSys.Init(objLayer)
buckets, err := objLayer.ListBuckets(context.Background())
if err != nil {
t.Fatalf("Unable to list buckets on backend %s", err)
}
globalPolicySys = NewPolicySys()
globalPolicySys.Init(buckets, objLayer)
// Executing the object layer tests for single node setup.
objTest(objLayer, FSTestStr, t)
objLayer, fsDirs, err := prepareXLSets32()
if err != nil {
t.Fatalf("Initialization of object layer failed for XL setup: %s", err)
}
// Executing the object layer tests for XL.
objTest(objLayer, XLTestStr, t)
defer removeRoots(append(fsDirs, fsDir))
}
// ExecObjectLayerTestWithDirs - executes object layer tests.
// Creates single node and XL ObjectLayer instance and runs test for both the layers.
func ExecObjectLayerTestWithDirs(t TestErrHandler, objTest objTestTypeWithDirs) {
objLayer, fsDirs, err := prepareXL16()
if err != nil {
t.Fatalf("Initialization of object layer failed for XL setup: %s", err)
}
// initialize the server and obtain the credentials and root.
// credentials are necessary to sign the HTTP request.
if err = newTestConfig(globalMinioDefaultRegion, objLayer); err != nil {
t.Fatal("Unexpected error", err)
}
// Executing the object layer tests for XL.
objTest(objLayer, XLTestStr, fsDirs, t)
defer removeRoots(fsDirs)
}
// ExecObjectLayerDiskAlteredTest - executes object layer tests while altering
// disks in between tests. Creates XL ObjectLayer instance and runs test for XL layer.
func ExecObjectLayerDiskAlteredTest(t *testing.T, objTest objTestDiskNotFoundType) {
objLayer, fsDirs, err := prepareXL16()
if err != nil {
t.Fatalf("Initialization of object layer failed for XL setup: %s", err)
}
if err = newTestConfig(globalMinioDefaultRegion, objLayer); err != nil {
t.Fatal("Failed to create config directory", err)
}
// Executing the object layer tests for XL.
objTest(objLayer, XLTestStr, fsDirs, t)
defer removeRoots(fsDirs)
}
// Special object test type for stale files situations.
type objTestStaleFilesType func(obj ObjectLayer, instanceType string, dirs []string, t *testing.T)
// ExecObjectLayerStaleFilesTest - executes object layer tests those leaves stale
// files/directories under .minio/tmp. Creates XL ObjectLayer instance and runs test for XL layer.
func ExecObjectLayerStaleFilesTest(t *testing.T, objTest objTestStaleFilesType) {
nDisks := 16
erasureDisks, err := getRandomDisks(nDisks)
if err != nil {
t.Fatalf("Initialization of disks for XL setup: %s", err)
}
objLayer, _, err := initObjectLayer(mustGetNewEndpointList(erasureDisks...))
if err != nil {
t.Fatalf("Initialization of object layer failed for XL setup: %s", err)
}
if err = newTestConfig(globalMinioDefaultRegion, objLayer); err != nil {
t.Fatal("Failed to create config directory", err)
}
// Executing the object layer tests for XL.
objTest(objLayer, XLTestStr, erasureDisks, t)
defer removeRoots(erasureDisks)
}
func registerBucketLevelFunc(bucket *mux.Router, api objectAPIHandlers, apiFunctions ...string) {
for _, apiFunction := range apiFunctions {
switch apiFunction {
case "PostPolicy":
// Register PostPolicy handler.
bucket.Methods("POST").HeadersRegexp("Content-Type", "multipart/form-data*").HandlerFunc(api.PostPolicyBucketHandler)
case "HeadObject":
// Register HeadObject handler.
bucket.Methods("Head").Path("/{object:.+}").HandlerFunc(api.HeadObjectHandler)
case "GetObject":
// Register GetObject handler.
bucket.Methods("GET").Path("/{object:.+}").HandlerFunc(api.GetObjectHandler)
case "PutObject":
// Register PutObject handler.
bucket.Methods("PUT").Path("/{object:.+}").HandlerFunc(api.PutObjectHandler)
case "DeleteObject":
// Register Delete Object handler.
bucket.Methods("DELETE").Path("/{object:.+}").HandlerFunc(api.DeleteObjectHandler)
case "CopyObject":
// Register Copy Object handler.
bucket.Methods("PUT").Path("/{object:.+}").HeadersRegexp("X-Amz-Copy-Source", ".*?(\\/|%2F).*?").HandlerFunc(api.CopyObjectHandler)
case "PutBucketPolicy":
// Register PutBucket Policy handler.
bucket.Methods("PUT").HandlerFunc(api.PutBucketPolicyHandler).Queries("policy", "")
case "DeleteBucketPolicy":
// Register Delete bucket HTTP policy handler.
bucket.Methods("DELETE").HandlerFunc(api.DeleteBucketPolicyHandler).Queries("policy", "")
case "GetBucketPolicy":
// Register Get Bucket policy HTTP Handler.
bucket.Methods("GET").HandlerFunc(api.GetBucketPolicyHandler).Queries("policy", "")
case "GetBucketLocation":
// Register GetBucketLocation handler.
bucket.Methods("GET").HandlerFunc(api.GetBucketLocationHandler).Queries("location", "")
case "HeadBucket":
// Register HeadBucket handler.
bucket.Methods("HEAD").HandlerFunc(api.HeadBucketHandler)
case "DeleteMultipleObjects":
// Register DeleteMultipleObjects handler.
bucket.Methods("POST").HandlerFunc(api.DeleteMultipleObjectsHandler).Queries("delete", "")
case "NewMultipart":
// Register New Multipart upload handler.
bucket.Methods("POST").Path("/{object:.+}").HandlerFunc(api.NewMultipartUploadHandler).Queries("uploads", "")
case "CopyObjectPart":
// Register CopyObjectPart handler.
bucket.Methods("PUT").Path("/{object:.+}").HeadersRegexp("X-Amz-Copy-Source", ".*?(\\/|%2F).*?").HandlerFunc(api.CopyObjectPartHandler).Queries("partNumber", "{partNumber:[0-9]+}", "uploadId", "{uploadId:.*}")
case "PutObjectPart":
// Register PutObjectPart handler.
bucket.Methods("PUT").Path("/{object:.+}").HandlerFunc(api.PutObjectPartHandler).Queries("partNumber", "{partNumber:[0-9]+}", "uploadId", "{uploadId:.*}")
case "ListObjectParts":
// Register ListObjectParts handler.
bucket.Methods("GET").Path("/{object:.+}").HandlerFunc(api.ListObjectPartsHandler).Queries("uploadId", "{uploadId:.*}")
case "ListMultipartUploads":
// Register ListMultipartUploads handler.
bucket.Methods("GET").HandlerFunc(api.ListMultipartUploadsHandler).Queries("uploads", "")
case "CompleteMultipart":
// Register Complete Multipart Upload handler.
bucket.Methods("POST").Path("/{object:.+}").HandlerFunc(api.CompleteMultipartUploadHandler).Queries("uploadId", "{uploadId:.*}")
case "AbortMultipart":
// Register AbortMultipart Handler.
bucket.Methods("DELETE").Path("/{object:.+}").HandlerFunc(api.AbortMultipartUploadHandler).Queries("uploadId", "{uploadId:.*}")
case "GetBucketNotification":
// Register GetBucketNotification Handler.
bucket.Methods("GET").HandlerFunc(api.GetBucketNotificationHandler).Queries("notification", "")
case "PutBucketNotification":
// Register PutBucketNotification Handler.
bucket.Methods("PUT").HandlerFunc(api.PutBucketNotificationHandler).Queries("notification", "")
case "ListenBucketNotification":
// Register ListenBucketNotification Handler.
bucket.Methods("GET").HandlerFunc(api.ListenBucketNotificationHandler).Queries("events", "{events:.*}")
}
}
}
// registerAPIFunctions helper function to add API functions identified by name to the routers.
func registerAPIFunctions(muxRouter *mux.Router, objLayer ObjectLayer, apiFunctions ...string) {
if len(apiFunctions) == 0 {
// Register all api endpoints by default.
registerAPIRouter(muxRouter, true, false)
return
}
// API Router.
apiRouter := muxRouter.PathPrefix(SlashSeparator).Subrouter()
// Bucket router.
bucketRouter := apiRouter.PathPrefix("/{bucket}").Subrouter()
// All object storage operations are registered as HTTP handlers on `objectAPIHandlers`.
// When the handlers get a HTTP request they use the underlying ObjectLayer to perform operations.
globalObjLayerMutex.Lock()
globalObjectAPI = objLayer
globalObjLayerMutex.Unlock()
// When cache is enabled, Put and Get operations are passed
// to underlying cache layer to manage object layer operation and disk caching
// operation
api := objectAPIHandlers{
ObjectAPI: func() ObjectLayer {
if !globalSafeMode {
return globalObjectAPI
}
return nil
},
CacheAPI: func() CacheObjectLayer {
if !globalSafeMode {
return globalCacheObjectAPI
}
return nil
},
EncryptionEnabled: func() bool { return true },
}
// Register ListBuckets handler.
apiRouter.Methods("GET").HandlerFunc(api.ListBucketsHandler)
// Register all bucket level handlers.
registerBucketLevelFunc(bucketRouter, api, apiFunctions...)
}
// Takes in XL object layer, and the list of API end points to be tested/required, registers the API end points and returns the HTTP handler.
// Need isolated registration of API end points while writing unit tests for end points.
// All the API end points are registered only for the default case.
func initTestAPIEndPoints(objLayer ObjectLayer, apiFunctions []string) http.Handler {
// initialize a new mux router.
// goriilla/mux is the library used to register all the routes and handle them.
muxRouter := mux.NewRouter().SkipClean(true)
if len(apiFunctions) > 0 {
// Iterate the list of API functions requested for and register them in mux HTTP handler.
registerAPIFunctions(muxRouter, objLayer, apiFunctions...)
return muxRouter
}
registerAPIRouter(muxRouter, true, false)
return muxRouter
}
// Initialize Web RPC Handlers for testing
func initTestWebRPCEndPoint(objLayer ObjectLayer) http.Handler {
globalObjLayerMutex.Lock()
globalObjectAPI = objLayer
globalObjLayerMutex.Unlock()
// Initialize router.
muxRouter := mux.NewRouter().SkipClean(true)
registerWebRouter(muxRouter)
return muxRouter
}
// generateTLSCertKey creates valid key/cert with registered DNS or IP address
// depending on the passed parameter. That way, we can use tls config without
// passing InsecureSkipVerify flag. This code is a simplified version of
// https://golang.org/src/crypto/tls/generate_cert.go
func generateTLSCertKey(host string) ([]byte, []byte, error) {
validFor := 365 * 24 * time.Hour
rsaBits := 2048
if len(host) == 0 {
return nil, nil, fmt.Errorf("Missing host parameter")
}
publicKey := func(priv interface{}) interface{} {
switch k := priv.(type) {
case *rsa.PrivateKey:
return &k.PublicKey
case *ecdsa.PrivateKey:
return &k.PublicKey
default:
return nil
}
}
pemBlockForKey := func(priv interface{}) *pem.Block {
switch k := priv.(type) {
case *rsa.PrivateKey:
return &pem.Block{Type: "RSA PRIVATE KEY", Bytes: x509.MarshalPKCS1PrivateKey(k)}
case *ecdsa.PrivateKey:
b, err := x509.MarshalECPrivateKey(k)
if err != nil {
fmt.Fprintf(os.Stderr, "Unable to marshal ECDSA private key: %v", err)
os.Exit(2)
}
return &pem.Block{Type: "EC PRIVATE KEY", Bytes: b}
default:
return nil
}
}
var priv interface{}
var err error
priv, err = rsa.GenerateKey(crand.Reader, rsaBits)
if err != nil {
return nil, nil, fmt.Errorf("failed to generate private key: %s", err)
}
notBefore := time.Now()
notAfter := notBefore.Add(validFor)
serialNumberLimit := new(big.Int).Lsh(big.NewInt(1), 128)
serialNumber, err := crand.Int(crand.Reader, serialNumberLimit)
if err != nil {
return nil, nil, fmt.Errorf("failed to generate serial number: %s", err)
}
template := x509.Certificate{
SerialNumber: serialNumber,
Subject: pkix.Name{
Organization: []string{"Acme Co"},
},
NotBefore: notBefore,
NotAfter: notAfter,
KeyUsage: x509.KeyUsageKeyEncipherment | x509.KeyUsageDigitalSignature,
ExtKeyUsage: []x509.ExtKeyUsage{x509.ExtKeyUsageServerAuth},
BasicConstraintsValid: true,
}
hosts := strings.Split(host, ",")
for _, h := range hosts {
if ip := net.ParseIP(h); ip != nil {
template.IPAddresses = append(template.IPAddresses, ip)
} else {
template.DNSNames = append(template.DNSNames, h)
}
}
template.IsCA = true
template.KeyUsage |= x509.KeyUsageCertSign
derBytes, err := x509.CreateCertificate(crand.Reader, &template, &template, publicKey(priv), priv)
if err != nil {
return nil, nil, fmt.Errorf("Failed to create certificate: %s", err)
}
certOut := bytes.NewBuffer([]byte{})
pem.Encode(certOut, &pem.Block{Type: "CERTIFICATE", Bytes: derBytes})
keyOut := bytes.NewBuffer([]byte{})
pem.Encode(keyOut, pemBlockForKey(priv))
return certOut.Bytes(), keyOut.Bytes(), nil
}
func mustGetNewEndpointList(args ...string) (endpoints EndpointList) {
if len(args) == 1 {
endpoint, err := NewEndpoint(args[0])
logger.FatalIf(err, "unable to create new endpoint")
endpoints = append(endpoints, endpoint)
} else {
var err error
endpoints, err = NewEndpointList(args...)
logger.FatalIf(err, "unable to create new endpoint list")
}
return endpoints
}
func getEndpointsLocalAddr(endpoints EndpointList) string {
for _, endpoint := range endpoints {
if endpoint.IsLocal && endpoint.Type() == URLEndpointType {
return endpoint.Host
}
}
return net.JoinHostPort(globalMinioHost, globalMinioPort)
}
// fetches a random number between range min-max.
func getRandomRange(min, max int, seed int64) int {
// special value -1 means no explicit seeding.
if seed != -1 {
rand.Seed(seed)
}
return rand.Intn(max-min) + min
}
// Randomizes the order of bytes in the byte array
// using Knuth Fisher-Yates shuffle algorithm.
func randomizeBytes(s []byte, seed int64) []byte {
// special value -1 means no explicit seeding.
if seed != -1 {
rand.Seed(seed)
}
n := len(s)
var j int
for i := 0; i < n-1; i++ {
j = i + rand.Intn(n-i)
s[i], s[j] = s[j], s[i]
}
return s
}
func TestToErrIsNil(t *testing.T) {
if toObjectErr(nil) != nil {
t.Errorf("Test expected to return nil, failed instead got a non-nil value %s", toObjectErr(nil))
}
if toStorageErr(nil) != nil {
t.Errorf("Test expected to return nil, failed instead got a non-nil value %s", toStorageErr(nil))
}
ctx := context.Background()
if toAPIError(ctx, nil) != noError {
t.Errorf("Test expected error code to be ErrNone, failed instead provided %s", toAPIError(ctx, nil).Code)
}
}
// Uploads an object using DummyDataGen directly via the http
// handler. Each part in a multipart object is a new DummyDataGen
// instance (so the part sizes are needed to reconstruct the whole
// object). When `len(partSizes) == 1`, asMultipart is used to upload
// the object as multipart with 1 part or as a regular single object.
//
// All upload failures are considered test errors - this function is
// intended as a helper for other tests.
func uploadTestObject(t *testing.T, apiRouter http.Handler, creds auth.Credentials, bucketName, objectName string,
partSizes []int64, metadata map[string]string, asMultipart bool) {
if len(partSizes) == 0 {
t.Fatalf("Cannot upload an object without part sizes")
}
if len(partSizes) > 1 {
asMultipart = true
}
checkRespErr := func(rec *httptest.ResponseRecorder, exp int) {
if rec.Code != exp {
b, err := ioutil.ReadAll(rec.Body)
t.Fatalf("Expected: %v, Got: %v, Body: %s, err: %v", exp, rec.Code, string(b), err)
}
}
if !asMultipart {
srcData := NewDummyDataGen(partSizes[0], 0)
req, err := newTestSignedRequestV4("PUT", getPutObjectURL("", bucketName, objectName),
partSizes[0], srcData, creds.AccessKey, creds.SecretKey, metadata)
if err != nil {
t.Fatalf("Unexpected err: %#v", err)
}
rec := httptest.NewRecorder()
apiRouter.ServeHTTP(rec, req)
checkRespErr(rec, http.StatusOK)
} else {
// Multipart upload - each part is a new DummyDataGen
// (so the part lengths are required to verify the
// object when reading).
// Initiate mp upload
reqI, err := newTestSignedRequestV4("POST", getNewMultipartURL("", bucketName, objectName),
0, nil, creds.AccessKey, creds.SecretKey, metadata)
if err != nil {
t.Fatalf("Unexpected err: %#v", err)
}
rec := httptest.NewRecorder()
apiRouter.ServeHTTP(rec, reqI)
checkRespErr(rec, http.StatusOK)
decoder := xml.NewDecoder(rec.Body)
multipartResponse := &InitiateMultipartUploadResponse{}
err = decoder.Decode(multipartResponse)
if err != nil {
t.Fatalf("Error decoding the recorded response Body")
}
upID := multipartResponse.UploadID
// Upload each part
var cp []CompletePart
cumulativeSum := int64(0)
for i, partLen := range partSizes {
partID := i + 1
partSrc := NewDummyDataGen(partLen, cumulativeSum)
cumulativeSum += partLen
req, errP := newTestSignedRequestV4("PUT",
getPutObjectPartURL("", bucketName, objectName, upID, fmt.Sprintf("%d", partID)),
partLen, partSrc, creds.AccessKey, creds.SecretKey, metadata)
if errP != nil {
t.Fatalf("Unexpected err: %#v", errP)
}
rec = httptest.NewRecorder()
apiRouter.ServeHTTP(rec, req)
checkRespErr(rec, http.StatusOK)
etag := rec.Header()["ETag"][0]
if etag == "" {
t.Fatalf("Unexpected empty etag")
}
cp = append(cp, CompletePart{partID, etag[1 : len(etag)-1]})
}
// Call CompleteMultipart API
compMpBody, err := xml.Marshal(CompleteMultipartUpload{Parts: cp})
if err != nil {
t.Fatalf("Unexpected err: %#v", err)
}
reqC, errP := newTestSignedRequestV4("POST",
getCompleteMultipartUploadURL("", bucketName, objectName, upID),
int64(len(compMpBody)), bytes.NewReader(compMpBody),
creds.AccessKey, creds.SecretKey, metadata)
if errP != nil {
t.Fatalf("Unexpected err: %#v", errP)
}
rec = httptest.NewRecorder()
apiRouter.ServeHTTP(rec, reqC)
checkRespErr(rec, http.StatusOK)
}
} | // Save signature finally.
req.URL.RawQuery += "&Signature=" + url.QueryEscape(signature) |
count_calls.py | #! /usr/bin/env udb-automate
import sys
import textwrap
from undodb.udb_launcher import (
REDIRECTION_COLLECT,
UdbLauncher,
)
def main(argv):
# Get the arguments from the command line.
try:
recording, func_name = argv[1:]
except ValueError:
# Wrong number of arguments.
print("{} RECORDING_FILE FUNCTION_NAME".format(sys.argv[0]))
raise SystemExit(1)
# Prepare for launching UDB.
launcher = UdbLauncher()
# Make UDB run with our recording.
launcher.recording_file = recording
# Make UDB load the count_calls_extension.py file from the current
# directory.
launcher.add_extension("count_calls_extension")
# Tell the extension which function name it needs to check.
# The run_data attribute is a dictionary in which arbitrary data can be
# stored and passed to the extension (as long as it can be serialised using
# the Python pickle module).
launcher.run_data["func_name"] = func_name
# Finally, launch UDB!
# We collect the output as, in normal conditions, we don't want to show it
# to the user but, in case of errors, we want to display it.
res = launcher.run_debugger(redirect_debugger_output=REDIRECTION_COLLECT)
if res.exit_code == 0:
# All good as UDB exited with exit code 0 (i.e. no errors).
print(
'The recording hit "{}" {} time(s).'.format(
func_name,
# The result_data attribute is analogous to UdbLauncher.run_data but
# it's used to pass information the opposite way, from the extension
# to this script.
res.result_data["hit-count"],
)
)
else:
# Something went wrong! Print a useful message.
print(
textwrap.dedent(
"""\
Error!
UDB exited with code {res.exit_code}.
The output was: | ).format(res=res),
file=sys.stderr,
)
# Exit this script with the same error code as UDB.
raise SystemExit(res.exit_code)
if __name__ == "__main__":
main(sys.argv) |
{res.output}
""" |
analysis.py | """ Usage:
<file-name> --in=IN_FILE --out=OUT_FILE [--debug]
"""
# External imports
import logging
import pdb
from pprint import pprint
from pprint import pformat
from docopt import docopt
from collections import defaultdict
from operator import itemgetter
from tqdm import tqdm
# Local imports
#=-----
def get_predicted_gender(spanish_sent):
"""
Return the gender of the first entity in the spanish
translation.
"""
first_word = spanish_sent.split()[0].lower()
if first_word == "el":
return "male"
elif first_word == "la":
return "female"
else:
return "neutral"
def percentage(part, total):
|
if __name__ == "__main__":
# Parse command line arguments
args = docopt(__doc__)
inp_fn = args["--in"]
out_fn = args["--out"]
debug = args["--debug"]
if debug:
logging.basicConfig(level = logging.DEBUG)
else:
logging.basicConfig(level = logging.INFO)
prof_dict = defaultdict(list)
conf_dict = defaultdict(lambda: defaultdict(lambda: 0))
total = defaultdict(lambda: 0)
pred_cnt = defaultdict(lambda: 0)
correct_cnt = defaultdict(lambda: 0)
lines = [line for line in open(inp_fn, encoding = "utf8")][1:]
with open(out_fn, "w", encoding = "utf8") as fout:
for line in lines:
logging.debug(line)
sent_id, en_sent, es_sent = line.strip().split("\t")
profession, _, _, gold_gender, _ = sent_id.split(".")
fout.write(f"{en_sent} ||| {es_sent}\n")
if ".0." not in line:
continue
total[gold_gender] += 1
pred_gender = get_predicted_gender(es_sent)
if pred_gender == gold_gender:
correct_cnt[gold_gender] += 1
pred_cnt[pred_gender] += 1
prof_dict[profession].append((pred_gender, gold_gender))
conf_dict[gold_gender][pred_gender] += 1
prof_dict = dict(prof_dict)
all_total = sum(total.values())
acc = round((sum(correct_cnt.values()) / all_total) * 100, 2)
acc_male = round((correct_cnt["male"] / total["male"]) * 100, 2)
acc_female = round((correct_cnt["female"] / total["female"]) * 100, 2)
print(f"#total = {all_total}; \n acc = {acc}%; acc_male = {acc_male}; acc_female = {acc_female}")
print("Gold distribution: male: {}, female: {}, neutral: {}".format(round(percentage(total["male"], all_total), 2),
round(percentage(total["female"], all_total),2),
round(percentage(total["neutral"], all_total)),2))
print("Predictions: male: {}, female: {}, neutral: {}".format(round((pred_cnt["male"] / all_total) * 100, 2),
round((pred_cnt["female"] / all_total) * 100, 2),
round((pred_cnt["neutral"] / all_total) * 100, 2)))
male_prof = [prof for prof, vals in prof_dict.items()
if all(pred_gender == "male"
for pred_gender
in map(itemgetter(0), vals))]
female_prof = [prof for prof, vals in prof_dict.items()
if all(pred_gender == "female"
for pred_gender
in map(itemgetter(0), vals))]
neutral_prof = [prof for prof, vals in prof_dict.items()
if all(pred_gender == "neutral"
for pred_gender
in map(itemgetter(0), vals))]
amb_prof = [prof for prof, vals in prof_dict.items()
if len(set(map(itemgetter(0), vals))) != 1]
print(f"male professions = {male_prof}")
print(f"female professions = {female_prof}")
print(f"neutral professions = {neutral_prof}")
print(f"ambiguous professions = {amb_prof}")
pprint(conf_dict)
logging.info("DONE")
| """
Calculate percentage.
"""
return (part / total) * 100 |
testvec_chanmsg.rs | use tor_bytes::Error as BytesError;
/// Example channel messages to encode and decode.
///
/// Except where noted, these were taken by instrumenting Tor
/// 0.4.5.0-alpha-dev to dump all of its cells to the logs, and
/// running in a chutney network with "test-network-all".
use tor_cell::chancell::{msg, ChanCmd};
use std::net::IpAddr;
use hex_literal::hex;
const CELL_SIZE: usize = 509;
fn unhex(s: &str, pad_to_len: bool) -> Vec<u8> {
let mut s = s.to_string();
s.retain(|c| !c.is_whitespace());
let mut body = hex::decode(s).unwrap();
if pad_to_len {
assert!(body.len() <= CELL_SIZE);
body.resize(CELL_SIZE, 0);
}
body
}
fn decode_err(cmd: ChanCmd, s: &str, pad_to_len: bool) -> BytesError {
let body = unhex(s, pad_to_len);
let mut r = tor_bytes::Reader::from_slice(&body[..]);
msg::ChanMsg::take(&mut r, cmd).unwrap_err()
}
fn test_decode(cmd: ChanCmd, s: &str, pad_to_len: bool) -> (Vec<u8>, msg::ChanMsg) {
let body = unhex(s, pad_to_len);
let mut r = tor_bytes::Reader::from_slice(&body[..]);
let msg = msg::ChanMsg::take(&mut r, cmd).unwrap();
(body, msg)
}
/// check whether a cell body encoded in a hex string matches a given message.
fn test_body(cmd: ChanCmd, s: &str, m: &msg::ChanMsg, pad_to_len: bool) {
assert_eq!(cmd, m.cmd());
let (body, decoded) = test_decode(cmd, s, pad_to_len);
// This is a bit kludgey: we don't implement PartialEq for
// messages, but we do implement Debug. That actually seems a
// saner arrangement to me as of this writing.
assert_eq!(format!("{:?}", decoded), format!("{:?}", m));
let mut encoded1 = Vec::new();
let mut encoded2 = Vec::new();
decoded.write_body_onto(&mut encoded1);
m.clone().write_body_onto(&mut encoded2);
if pad_to_len {
assert!(encoded1.len() <= CELL_SIZE);
assert!(encoded2.len() <= CELL_SIZE);
encoded1.resize(CELL_SIZE, 0);
encoded2.resize(CELL_SIZE, 0);
}
assert_eq!(encoded1, encoded2);
assert_eq!(body, encoded2);
}
/// version for variable-length cells
fn vbody(cmd: ChanCmd, s: &str, m: &msg::ChanMsg) {
test_body(cmd, s, m, false)
}
/// version for fixed-length cells
fn fbody(cmd: ChanCmd, s: &str, m: &msg::ChanMsg) {
test_body(cmd, s, m, true)
}
#[test]
fn test_auth_challenge() {
let cmd = ChanCmd::AUTH_CHALLENGE;
assert_eq!(Into::<u8>::into(cmd), 130_u8);
let challenge = hex!("00DA5C085DEE4F3656710DA3B73652E48ACD5BAE608335FCA3FB6C4DEE104A51");
vbody(
cmd,
"00DA5C085DEE4F3656710DA3B73652E48ACD5BAE608335FCA3FB6C4DEE104A51
0002 0001 0003",
&msg::AuthChallenge::new(challenge, vec![1_u16, 3_u16]).into(),
);
}
#[test]
fn | () {
let cmd = ChanCmd::AUTHENTICATE;
assert_eq!(Into::<u8>::into(cmd), 131_u8);
let authentication =
hex!("4155544830303033ED6B2ACBAC868D87D1500505BF59196FD38DEF15E1078C46BF97C7EBCC26C2A26AAF7E6B8FF0C27AB8F0047426017D03A413D8C1D00077ED441112C3E88EEE535BA78B2FD74C3910C5FECBD700677DCA931F4B90EA5CD24D4E64F7E9EC9E0F38E4E1E55E42BC72F59E9224E328EB1BBE3D079013B2A04CDBCEB43B7135D365E81B01B6845D789F66F0F62AAF52D906D2252E5F105215A627123C05AF782D7B0D64C41C30AFB6660B3DB1028868104E2560CB527568241992B80855101D3BF6EFA987F7A56C132A0CF38B0097AA215CC58FF089AFCC15C0ABB3947E68137CD8554E336C435E4633F88909919E5448F80CDDBD5987D85407A95A2BBC898C7004318265719D99C7B549C276CDEE38CE9202395CB7E1EBD9B3D47C1F4BC254AA12798BA1480400A3CC8067518A9BBDD453E601579429CF2E72D6C175DA0A412D99ECA1079015651E95E8F40AD8BEC3CB496E83C0C66D10F4C606");
vbody(cmd,
"0003 0160 4155544830303033ED6B2ACBAC868D87D1500505BF59196FD38DEF15E1078C46BF97C7EBCC26C2A26AAF7E6B8FF0C27AB8F0047426017D03A413D8C1D00077ED441112C3E88EEE535BA78B2FD74C3910C5FECBD700677DCA931F4B90EA5CD24D4E64F7E9EC9E0F38E4E1E55E42BC72F59E9224E328EB1BBE3D079013B2A04CDBCEB43B7135D365E81B01B6845D789F66F0F62AAF52D906D2252E5F105215A627123C05AF782D7B0D64C41C30AFB6660B3DB1028868104E2560CB527568241992B80855101D3BF6EFA987F7A56C132A0CF38B0097AA215CC58FF089AFCC15C0ABB3947E68137CD8554E336C435E4633F88909919E5448F80CDDBD5987D85407A95A2BBC898C7004318265719D99C7B549C276CDEE38CE9202395CB7E1EBD9B3D47C1F4BC254AA12798BA1480400A3CC8067518A9BBDD453E601579429CF2E72D6C175DA0A412D99ECA1079015651E95E8F40AD8BEC3CB496E83C0C66D10F4C606",
&msg::Authenticate::new(3, &authentication[..]).into());
// TODO: when we generate or parse these, we should parse the actual
// structure of the authentication string.
}
#[test]
fn test_certs() {
// can't do this trivially; have to go by hand.
let cmd = ChanCmd::CERTS;
assert_eq!(Into::<u8>::into(cmd), 129_u8);
let body =
"05
01 023E 3082023A308201A3A003020102020872AB0FE86C771604300D06092A864886F70D01010B0500301F311D301B06035504030C147777772E74636A76356B766A646472322E636F6D301E170D3230303632373030303030305A170D3231303231363233353935395A301C311A301806035504030C117777772E617775676863646E732E6E657430820122300D06092A864886F70D01010105000382010F003082010A0282010100FE255E99E10BE986DDA5DFB4AD7C39E8EFE4E5D79E105AB976942B6829386EB1D7B7AFB5ED4FCBEC8C1A34C34FD2ED182F8B42A0363453B55EE371F21347235277E2357F28AA10DD82D4248F7D1894AB5D2979654F71C350F73AD9F918D71F34F1505F77EC16391C8340F392F3684BA4BB6A7B022C3954C1158F152F9E3B4E328FAB2E4E881903CA0E32204B0FDA8AB62B6E215A7BDEC3F2AE41DC58EEC1252F643A1812A5D71802F48D6133DF79955E01F0287BB4AB8CF95BEBCD2EC66EF5B38C7B5EC08DED3D6E2A1D57289D773D5CB932803B6D97784D1DA36AE71C073ADBB7393714001CD7A082512772A7076DC01166417AF7C50AEF7F15FD0806EB07FF0203010001300D06092A864886F70D01010B050003818100CDA4E06BB6BB238B91188A077EEB0A4722518090FD116AF6CDEEB0E85CF6D8E242CF861F973A252EB5116709373B5AC817E6F848E2CBD76AEF684350D3416AEE5F33D56B96982509CDAF11CCA7260E5ADF6DDD0D017AE9A575C999ADAE50B3FB7027E810D47C8C5C14618C0AA10D307E304FBE50E868ADECB2C9536E2DB51BE0
02 01BD 308201B930820122A0030201020208607C28BE6C390943300D06092A864886F70D01010B0500301F311D301B06035504030C147777772E74636A76356B766A646472322E636F6D301E170D3230303831303030303030305A170D3231303831303030303030305A301F311D301B06035504030C147777772E74636A76356B766A646472322E636F6D30819F300D06092A864886F70D010101050003818D0030818902818100D38B1E6CEB946E0DB0751F4CBACE3DCB9688B6C25304227B4710C35AFB73627E50500F5913E158B621802612D1C75827003703338375237552EB3CD3C12F6AB3604E60C1A2D26BB1FBAD206FF023969A90909D6A65A5458A5312C26EBD3A3DAD30302D4515CDCD264146AC18E6FC60A04BD3EC327F04294D96BA5AA25B464C3F0203010001300D06092A864886F70D01010B0500038181003BCE561EA7F95CC00B78AAB5D69573FF301C282A751D4A651921D042F1BECDBA24D918A6D8A5E138DC07BBA0B335478AE37ABD2C93A93932442AE9084329E846170FE0FC4A50AAFC804F311CC3CA4F41D845A7BA5901CBBC3E021E9794AAC70CE1F37B0A951592DB1B64F2B4AFB81AE52DBD9B6FEDE96A5FB8125EB6251EE50A
04 008C 01040006CC2A01F82294B866A31F01FC5D0DA8572850A9B929545C3266558D7D2316E3B74172B00100200400DCB604DB2034B00FD16986D4ADB9D16B21CB4E4457A33DEC0F538903683E96E9FF1A5203FA27F86EF7528D89A0845D2520166E340754FFEA2AAE0F612B7CE5DA094A0236CDAC45034B0B6842C18E7F6B51B93A3CF7E60663B8AD061C30A62602
05 0068 01050006C98A03B4FD606B64E4CBD466B8D76CB131069BAE6F3AA1878857C9F624E31D77A799B8007173E5F8068431D0D3F5EE16B4C9FFD59DF373E152A87281BAE744AA5FCF72171BF4B27C4E8FC1C6A9FC5CA11058BC49647063D7903CFD9F512F89099B27BC0C
07 00A5 DCB604DB2034B00FD16986D4ADB9D16B21CB4E4457A33DEC0F538903683E96E90006DA3A805CF6006F9179066534DE6B45AD47A5C469063EE462762723396DC9F25452A0A52DA3F5087DD239F2A311F6B0D4DFEFF4ABD089DC3D0237A0ABAB19EB2045B91CDCAF04BE0A72D548A27BF2E77BD876ECFE5E1BE622350DA6BF31F6E306ED896488DD5B39409B23FC3EB7B2C9F7328EB18DA36D54D80575899EA6507CCBFCDF1F";
// yeah, that's kinda big!
let cert1body = hex::decode(
"3082023A308201A3A003020102020872AB0FE86C771604300D06092A864886F70D01010B0500301F311D301B06035504030C147777772E74636A76356B766A646472322E636F6D301E170D3230303632373030303030305A170D3231303231363233353935395A301C311A301806035504030C117777772E617775676863646E732E6E657430820122300D06092A864886F70D01010105000382010F003082010A0282010100FE255E99E10BE986DDA5DFB4AD7C39E8EFE4E5D79E105AB976942B6829386EB1D7B7AFB5ED4FCBEC8C1A34C34FD2ED182F8B42A0363453B55EE371F21347235277E2357F28AA10DD82D4248F7D1894AB5D2979654F71C350F73AD9F918D71F34F1505F77EC16391C8340F392F3684BA4BB6A7B022C3954C1158F152F9E3B4E328FAB2E4E881903CA0E32204B0FDA8AB62B6E215A7BDEC3F2AE41DC58EEC1252F643A1812A5D71802F48D6133DF79955E01F0287BB4AB8CF95BEBCD2EC66EF5B38C7B5EC08DED3D6E2A1D57289D773D5CB932803B6D97784D1DA36AE71C073ADBB7393714001CD7A082512772A7076DC01166417AF7C50AEF7F15FD0806EB07FF0203010001300D06092A864886F70D01010B050003818100CDA4E06BB6BB238B91188A077EEB0A4722518090FD116AF6CDEEB0E85CF6D8E242CF861F973A252EB5116709373B5AC817E6F848E2CBD76AEF684350D3416AEE5F33D56B96982509CDAF11CCA7260E5ADF6DDD0D017AE9A575C999ADAE50B3FB7027E810D47C8C5C14618C0AA10D307E304FBE50E868ADECB2C9536E2DB51BE0").unwrap();
let cert2body = hex::decode(
"308201B930820122A0030201020208607C28BE6C390943300D06092A864886F70D01010B0500301F311D301B06035504030C147777772E74636A76356B766A646472322E636F6D301E170D3230303831303030303030305A170D3231303831303030303030305A301F311D301B06035504030C147777772E74636A76356B766A646472322E636F6D30819F300D06092A864886F70D010101050003818D0030818902818100D38B1E6CEB946E0DB0751F4CBACE3DCB9688B6C25304227B4710C35AFB73627E50500F5913E158B621802612D1C75827003703338375237552EB3CD3C12F6AB3604E60C1A2D26BB1FBAD206FF023969A90909D6A65A5458A5312C26EBD3A3DAD30302D4515CDCD264146AC18E6FC60A04BD3EC327F04294D96BA5AA25B464C3F0203010001300D06092A864886F70D01010B0500038181003BCE561EA7F95CC00B78AAB5D69573FF301C282A751D4A651921D042F1BECDBA24D918A6D8A5E138DC07BBA0B335478AE37ABD2C93A93932442AE9084329E846170FE0FC4A50AAFC804F311CC3CA4F41D845A7BA5901CBBC3E021E9794AAC70CE1F37B0A951592DB1B64F2B4AFB81AE52DBD9B6FEDE96A5FB8125EB6251EE50A"
).unwrap();
let cert3body = hex::decode("01040006CC2A01F82294B866A31F01FC5D0DA8572850A9B929545C3266558D7D2316E3B74172B00100200400DCB604DB2034B00FD16986D4ADB9D16B21CB4E4457A33DEC0F538903683E96E9FF1A5203FA27F86EF7528D89A0845D2520166E340754FFEA2AAE0F612B7CE5DA094A0236CDAC45034B0B6842C18E7F6B51B93A3CF7E60663B8AD061C30A62602"
).unwrap();
let cert4body = hex::decode("01050006C98A03B4FD606B64E4CBD466B8D76CB131069BAE6F3AA1878857C9F624E31D77A799B8007173E5F8068431D0D3F5EE16B4C9FFD59DF373E152A87281BAE744AA5FCF72171BF4B27C4E8FC1C6A9FC5CA11058BC49647063D7903CFD9F512F89099B27BC0C").unwrap();
let cert5body = hex::decode("DCB604DB2034B00FD16986D4ADB9D16B21CB4E4457A33DEC0F538903683E96E90006DA3A805CF6006F9179066534DE6B45AD47A5C469063EE462762723396DC9F25452A0A52DA3F5087DD239F2A311F6B0D4DFEFF4ABD089DC3D0237A0ABAB19EB2045B91CDCAF04BE0A72D548A27BF2E77BD876ECFE5E1BE622350DA6BF31F6E306ED896488DD5B39409B23FC3EB7B2C9F7328EB18DA36D54D80575899EA6507CCBFCDF1F").unwrap();
let mut certs = msg::Certs::new_empty();
certs.push_cert_body(1.into(), cert1body);
certs.push_cert_body(2.into(), cert2body);
certs.push_cert_body(4.into(), &cert3body[..]);
certs.push_cert_body(5.into(), cert4body);
certs.push_cert_body(7.into(), cert5body.clone());
vbody(cmd, body, &certs.clone().into());
// Test some accessors.
let body3 = certs.cert_body(4.into());
assert_eq!(body3, Some(&cert3body[..]));
let body_not_present = certs.cert_body(66.into());
assert_eq!(body_not_present, None);
let cert3 = certs.parse_ed_cert(4.into());
assert!(cert3.is_ok());
// Try a mismatched cell.
let mut badcerts = msg::Certs::new_empty();
badcerts.push_cert_body(5.into(), cert5body); // not the correct cert type
assert!(badcerts.parse_ed_cert(5.into()).is_err());
}
#[test]
fn test_create() {
let cmd = ChanCmd::CREATE;
assert_eq!(Into::<u8>::into(cmd), 1_u8);
let body = "07780DBE97D62D392E0DF2286C78386C49464154A8EDE46EECA1753AA49391200F33F22DF0128CCEC3339434D436551930C95338693EEFAD3964D53184C58AF6C0D838EE3893FAE650DAC89BB12EBB6A882E572C9EA079ACD3E51063296E52ABC875D7A31F8965A6BA9CE54F16AD5C746FEE7D9EF2D41CF4399D818567599D2A0FA8E27F31838F80D80E2D03C040FB954B2AD8872530FFB2AA50531B2BB40C7CB4BF1E8946A50C7622A2916C679AD11577EB4EC414BF8F287085";
let handshake = hex::decode(body).unwrap();
fbody(cmd, body, &msg::Create::new(handshake).into());
}
#[test]
fn test_create2() {
let cmd = ChanCmd::CREATE2;
assert_eq!(Into::<u8>::into(cmd), 10_u8);
let body = "0002 0054 09164430E84D3BC56EC7E1D22734742345E2DECE0DE535B66B8E8A0EBBDAE3263C53E02EC2215685CD3A977DC7946FF47F84CD7025F75D252D1B35DEA28F32FA912513889A207E5049992DBC9BC541194C13624A";
let handshake = hex::decode("09164430E84D3BC56EC7E1D22734742345E2DECE0DE535B66B8E8A0EBBDAE3263C53E02EC2215685CD3A977DC7946FF47F84CD7025F75D252D1B35DEA28F32FA912513889A207E5049992DBC9BC541194C13624A").unwrap();
fbody(cmd, body, &msg::Create2::new(2, handshake.clone()).into());
let create2 = msg::Create2::new(2, handshake.clone());
assert_eq!(create2.handshake_type(), 2);
assert_eq!(create2.body(), &handshake[..]);
}
#[test]
fn test_create_fast() {
let cmd = ChanCmd::CREATE_FAST;
assert_eq!(Into::<u8>::into(cmd), 5_u8);
let body = "0DC2A5EB921EF4B71F41184A99F4FAD99620A648";
let handshake = hex::decode(body).unwrap();
fbody(cmd, body, &msg::CreateFast::new(handshake.clone()).into());
let create_fast = msg::CreateFast::new(handshake.clone());
assert_eq!(create_fast.body(), &handshake[..]);
}
#[test]
fn test_created() {
let cmd = ChanCmd::CREATED;
assert_eq!(Into::<u8>::into(cmd), 2_u8);
let body = "0AC85AFA82E14BD661A4BEB3F6420508F21336455326442D9D34B41F4F4E1283751B681C83AB6C06089C6CB5AC857509B4CF185DD044C6B66A53B6FA7E48F8728DC7CC114E38E9258058A0D7C3603335E6812AB3687076DC82F2D4E9872D6787587CBAACF2BC962DFB3A0FCD313D86EC0572DEC12C5D113C78A7B34EF3C209260E48AB5C6E1DAB0D68617B76CC408A93DC0E26C0";
let handshake = hex::decode(body).unwrap();
fbody(cmd, body, &msg::Created::new(handshake).into());
}
#[test]
fn test_created2() {
let cmd = ChanCmd::CREATED2;
assert_eq!(Into::<u8>::into(cmd), 11_u8);
let body = "0040 0108907A701030ADB6CA9C6AF097DC4855614655659B6A7BF21C1097DCE7C66EE0E4EF287DE7CED40BEECA8B90140C05DB6138AEB551CE0C037068C315E307A0";
let handshake = hex::decode("0108907A701030ADB6CA9C6AF097DC4855614655659B6A7BF21C1097DCE7C66EE0E4EF287DE7CED40BEECA8B90140C05DB6138AEB551CE0C037068C315E307A0").unwrap();
fbody(cmd, body, &msg::Created2::new(handshake.clone()).into());
let created2 = msg::Created2::new(handshake.clone());
assert_eq!(created2.into_body(), handshake);
}
#[test]
fn test_created_fast() {
let cmd = ChanCmd::CREATED_FAST;
assert_eq!(Into::<u8>::into(cmd), 6_u8);
let body = "03B74250B01D09FDA72B70D63AE7994926F13055BED23485F6B3C8C3CEAFE1DF48A9FF8BAC4993FC";
let handshake = hex::decode(body).unwrap();
fbody(cmd, body, &msg::CreatedFast::new(handshake.clone()).into());
let created_fast = msg::CreatedFast::new(handshake.clone());
assert_eq!(created_fast.into_body(), handshake);
}
#[test]
fn test_destroy() {
let cmd = ChanCmd::DESTROY;
assert_eq!(Into::<u8>::into(cmd), 4_u8);
fbody(cmd, "04", &msg::Destroy::new(4.into()).into());
fbody(cmd, "0000", &msg::Destroy::new(0.into()).into());
}
#[test]
fn test_netinfo() {
let cmd = ChanCmd::NETINFO;
assert_eq!(Into::<u8>::into(cmd), 8_u8);
// example client netinfo.
let localhost = "127.0.0.1".parse::<IpAddr>().unwrap();
fbody(
cmd,
"00000000 04 04 7F000001 00",
&msg::Netinfo::for_client(Some(localhost)).into(),
);
// example relay netinfo
fbody(
cmd,
"5F6F80E1 04 04 7F000001 01 04 04 7F000001",
&msg::Netinfo::for_relay(0x5f6f80e1, Some(localhost), &[localhost][..]).into(),
);
// example ipv6 relay netinfo
let localhost_v6 = "::1".parse::<IpAddr>().unwrap();
fbody(
cmd,
"5F6F859C 06 10 00000000000000000000000000000001
02
04 04 7F000001
06 10 00000000000000000000000000000001",
&msg::Netinfo::for_relay(
0x5f6f859c,
Some(localhost_v6),
&[localhost, localhost_v6][..],
)
.into(),
);
// Bogus addresses get ignored. (hand-generated from above)
let (_, netinfo) = test_decode(
cmd,
"5F6F859C 06 09 000000000000000000
03
04 06 7F0000010000
BB 02 FFFF
06 10 00000000000000000000000000000001",
false,
);
let expect: msg::ChanMsg =
msg::Netinfo::for_relay(0x5f6f859c, None, &[localhost_v6][..]).into();
assert_eq!(format!("{:?}", netinfo), format!("{:?}", expect));
// Zero-valued their_address are None (hand-generated from above)
fbody(
cmd,
"00000000 04 04 00000000 00",
&msg::Netinfo::for_client(None).into(),
);
}
#[test]
fn test_padding() {
let cmd = ChanCmd::PADDING;
assert_eq!(Into::<u8>::into(cmd), 0_u8);
fbody(cmd, "", &msg::Padding::default().into());
}
#[test]
fn test_versions() {
let cmd = ChanCmd::VERSIONS;
assert_eq!(Into::<u8>::into(cmd), 7_u8);
vbody(
cmd,
"000300040005",
&msg::Versions::new(vec![3, 4, 5]).unwrap().into(),
);
}
#[test]
fn test_unspecified() {
let cmd = 101.into(); // not a specified fixed-length cell
// generated by hand, since there is no alternative.
let mut text: Vec<u8> = b"A mage's name is better hidden than a herring in the sea"[..].into();
text.resize(CELL_SIZE, 0);
fbody(cmd,
"41206d6167652773206e616d65206973206265747465722068696464656e207468616e20612068657272696e6720696e2074686520736561",
&msg::Unrecognized::new(cmd, text).into());
let cmd = 244.into(); // not a specified variable-length cell
vbody(
cmd,
"6265747465722067756172646564207468616e206120647261676f6e27732064656e",
&msg::Unrecognized::new(cmd, &b"better guarded than a dragon's den"[..]).into(),
);
// quote from Ursula K. Le Guin, _A Wizard Of EarthSea_
}
#[test]
fn test_relay() {
// This is hand-generated.
let cmd = ChanCmd::RELAY;
assert_eq!(Into::<u8>::into(cmd), 3_u8);
let mut body: Vec<u8> = b"not validated at this stage"[..].into();
body.resize(CELL_SIZE, 0);
fbody(
cmd,
"6e6f742076616c6964617465642061742074686973207374616765",
&msg::Relay::new(&body).into(),
);
let cmd = ChanCmd::RELAY_EARLY;
assert_eq!(Into::<u8>::into(cmd), 9_u8);
fbody(
cmd,
"6e6f742076616c6964617465642061742074686973207374616765",
&msg::Relay::new(&body).into_early(),
);
// Try converting to/from raw bodies.
let body = [3_u8; 509];
let cell = msg::Relay::from_raw(body);
let body2 = cell.into_relay_body();
assert_eq!(&body2[..], &body[..]);
}
#[test]
fn test_authorize() {
// There is no spec for this; we can only take the whole cell.
// This is hand-generated.
let cmd = ChanCmd::AUTHORIZE;
assert_eq!(Into::<u8>::into(cmd), 132_u8);
let body: Vec<u8> = b"not validated at this stage"[..].into();
vbody(
cmd,
"6e6f742076616c6964617465642061742074686973207374616765",
&msg::Authorize::new(body).into(),
);
}
#[test]
fn test_vpadding() {
// Generated by hand
let cmd = ChanCmd::VPADDING;
assert_eq!(Into::<u8>::into(cmd), 128_u8);
vbody(cmd, "", &msg::VPadding::new(0).into());
vbody(cmd, "00000000000000000000", &msg::VPadding::new(10).into());
}
#[test]
fn test_padding_negotiate() {
// Generated by hand since we don't have it from the Chutney run.
let cmd = ChanCmd::PADDING_NEGOTIATE;
assert_eq!(Into::<u8>::into(cmd), 12_u8);
fbody(
cmd,
"00 02 0100 0200",
&msg::PaddingNegotiate::new(true, 256, 512).into(),
);
assert_eq!(
decode_err(cmd, "90 0303", true),
BytesError::BadMessage("Unrecognized padding negotiation version")
);
}
| test_authenticate |
cache_test.go | // Copyright (c) 2020 Uber Technologies, Inc.
//
// Permission is hereby granted, free of charge, to any person obtaining a copy
// of this software and associated documentation files (the "Software"), to deal
// in the Software without restriction, including without limitation the rights
// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
// copies of the Software, and to permit persons to whom the Software is
// furnished to do so, subject to the following conditions:
//
// The above copyright notice and this permission notice shall be included in
// all copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
// THE SOFTWARE.
package events
import (
"context"
"errors"
"testing"
"time"
"github.com/stretchr/testify/mock"
"github.com/stretchr/testify/require"
"github.com/stretchr/testify/suite"
"github.com/uber-go/tally"
"github.com/uber/cadence/common"
"github.com/uber/cadence/common/log"
"github.com/uber/cadence/common/log/loggerimpl"
"github.com/uber/cadence/common/metrics"
"github.com/uber/cadence/common/mocks"
"github.com/uber/cadence/common/persistence"
"github.com/uber/cadence/common/types"
)
type (
eventsCacheSuite struct {
suite.Suite
*require.Assertions
logger log.Logger
mockHistoryManager *mocks.HistoryV2Manager
cache *cacheImpl
}
)
func | (t *testing.T) {
s := new(eventsCacheSuite)
suite.Run(t, s)
}
func (s *eventsCacheSuite) SetupSuite() {
}
func (s *eventsCacheSuite) TearDownSuite() {
}
func (s *eventsCacheSuite) SetupTest() {
s.Assertions = require.New(s.T())
s.logger = loggerimpl.NewLoggerForTest(s.Suite)
// Have to define our overridden assertions in the test setup. If we did it earlier, s.T() will return nil
s.Assertions = require.New(s.T())
s.mockHistoryManager = &mocks.HistoryV2Manager{}
s.cache = s.newTestEventsCache()
}
func (s *eventsCacheSuite) TearDownTest() {
s.mockHistoryManager.AssertExpectations(s.T())
}
func (s *eventsCacheSuite) newTestEventsCache() *cacheImpl {
return newCacheWithOption(common.IntPtr(10), 16, 32, time.Minute, s.mockHistoryManager, false, s.logger,
metrics.NewClient(tally.NoopScope, metrics.History), 0)
}
func (s *eventsCacheSuite) TestEventsCacheHitSuccess() {
domainID := "events-cache-hit-success-domain"
workflowID := "events-cache-hit-success-workflow-id"
runID := "events-cache-hit-success-run-id"
eventID := int64(23)
event := &types.HistoryEvent{
ID: eventID,
EventType: types.EventTypeActivityTaskStarted.Ptr(),
ActivityTaskStartedEventAttributes: &types.ActivityTaskStartedEventAttributes{},
}
s.cache.PutEvent(domainID, workflowID, runID, eventID, event)
actualEvent, err := s.cache.GetEvent(context.Background(), 0, domainID, workflowID, runID, eventID, eventID, nil)
s.Nil(err)
s.Equal(event, actualEvent)
}
func (s *eventsCacheSuite) TestEventsCacheMissMultiEventsBatchV2Success() {
domainID := "events-cache-miss-multi-events-batch-v2-success-domain"
workflowID := "events-cache-miss-multi-events-batch-v2-success-workflow-id"
runID := "events-cache-miss-multi-events-batch-v2-success-run-id"
event1 := &types.HistoryEvent{
ID: 11,
EventType: types.EventTypeDecisionTaskCompleted.Ptr(),
DecisionTaskCompletedEventAttributes: &types.DecisionTaskCompletedEventAttributes{},
}
event2 := &types.HistoryEvent{
ID: 12,
EventType: types.EventTypeActivityTaskScheduled.Ptr(),
ActivityTaskScheduledEventAttributes: &types.ActivityTaskScheduledEventAttributes{},
}
event3 := &types.HistoryEvent{
ID: 13,
EventType: types.EventTypeActivityTaskScheduled.Ptr(),
ActivityTaskScheduledEventAttributes: &types.ActivityTaskScheduledEventAttributes{},
}
event4 := &types.HistoryEvent{
ID: 14,
EventType: types.EventTypeActivityTaskScheduled.Ptr(),
ActivityTaskScheduledEventAttributes: &types.ActivityTaskScheduledEventAttributes{},
}
event5 := &types.HistoryEvent{
ID: 15,
EventType: types.EventTypeActivityTaskScheduled.Ptr(),
ActivityTaskScheduledEventAttributes: &types.ActivityTaskScheduledEventAttributes{},
}
event6 := &types.HistoryEvent{
ID: 16,
EventType: types.EventTypeActivityTaskScheduled.Ptr(),
ActivityTaskScheduledEventAttributes: &types.ActivityTaskScheduledEventAttributes{},
}
shardID := common.IntPtr(10)
s.mockHistoryManager.On("ReadHistoryBranch", mock.Anything, &persistence.ReadHistoryBranchRequest{
BranchToken: []byte("store_token"),
MinEventID: event1.ID,
MaxEventID: event6.ID + 1,
PageSize: 1,
NextPageToken: nil,
ShardID: shardID,
}).Return(&persistence.ReadHistoryBranchResponse{
HistoryEvents: []*types.HistoryEvent{event1, event2, event3, event4, event5, event6},
NextPageToken: nil,
LastFirstEventID: event1.ID,
}, nil)
s.cache.PutEvent(domainID, workflowID, runID, event2.ID, event2)
actualEvent, err := s.cache.GetEvent(context.Background(), *shardID, domainID, workflowID, runID, event1.ID, event6.ID, []byte("store_token"))
s.Nil(err)
s.Equal(event6, actualEvent)
}
func (s *eventsCacheSuite) TestEventsCacheMissV2Failure() {
domainID := "events-cache-miss-failure-domain"
workflowID := "events-cache-miss-failure-workflow-id"
runID := "events-cache-miss-failure-run-id"
shardID := common.IntPtr(10)
expectedErr := errors.New("persistence call failed")
s.mockHistoryManager.On("ReadHistoryBranch", mock.Anything, &persistence.ReadHistoryBranchRequest{
BranchToken: []byte("store_token"),
MinEventID: int64(11),
MaxEventID: int64(15),
PageSize: 1,
NextPageToken: nil,
ShardID: shardID,
}).Return(nil, expectedErr)
actualEvent, err := s.cache.GetEvent(context.Background(), *shardID, domainID, workflowID, runID, int64(11), int64(14), []byte("store_token"))
s.Nil(actualEvent)
s.Equal(expectedErr, err)
}
func (s *eventsCacheSuite) TestEventsCacheDisableSuccess() {
domainID := "events-cache-disable-success-domain"
workflowID := "events-cache-disable-success-workflow-id"
runID := "events-cache-disable-success-run-id"
shardID := common.IntPtr(10)
event1 := &types.HistoryEvent{
ID: 23,
EventType: types.EventTypeActivityTaskStarted.Ptr(),
ActivityTaskStartedEventAttributes: &types.ActivityTaskStartedEventAttributes{},
}
event2 := &types.HistoryEvent{
ID: 32,
EventType: types.EventTypeActivityTaskStarted.Ptr(),
ActivityTaskStartedEventAttributes: &types.ActivityTaskStartedEventAttributes{},
}
s.mockHistoryManager.On("ReadHistoryBranch", mock.Anything, &persistence.ReadHistoryBranchRequest{
BranchToken: []byte("store_token"),
MinEventID: event2.ID,
MaxEventID: event2.ID + 1,
PageSize: 1,
NextPageToken: nil,
ShardID: shardID,
}).Return(&persistence.ReadHistoryBranchResponse{
HistoryEvents: []*types.HistoryEvent{event2},
NextPageToken: nil,
LastFirstEventID: event2.ID,
}, nil)
s.cache.PutEvent(domainID, workflowID, runID, event1.ID, event1)
s.cache.PutEvent(domainID, workflowID, runID, event2.ID, event2)
s.cache.disabled = true
actualEvent, err := s.cache.GetEvent(context.Background(), *shardID, domainID, workflowID, runID, event2.ID, event2.ID, []byte("store_token"))
s.Nil(err)
s.Equal(event2, actualEvent)
}
| TestEventsCacheSuite |
employee-list.component.ts | import { Component } from "@angular/core";
@Component({
selector: "employee-list",
templateUrl: "app/employee/views/employee.list.html"
})
export class EmployeeListComponent {
title:string="Employee Portal";
subtitle:string="Displaying the list of employees";
employee:any={
| } | name: "Niranjan",
dept: "UI",
proj: "Angular"
}
|